1 /* Expand the basic unary and binary arithmetic operations, for GNU compiler.
2 Copyright (C) 1987-2013 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
25 #include "diagnostic-core.h"
27 /* Include insn-config.h before expr.h so that HAVE_conditional_move
28 is properly defined. */
29 #include "insn-config.h"
42 #include "basic-block.h"
45 struct target_optabs default_target_optabs
;
46 struct target_libfuncs default_target_libfuncs
;
47 struct target_optabs
*this_fn_optabs
= &default_target_optabs
;
49 struct target_optabs
*this_target_optabs
= &default_target_optabs
;
50 struct target_libfuncs
*this_target_libfuncs
= &default_target_libfuncs
;
53 #define libfunc_hash \
54 (this_target_libfuncs->x_libfunc_hash)
56 static void prepare_float_lib_cmp (rtx
, rtx
, enum rtx_code
, rtx
*,
58 static rtx
expand_unop_direct (enum machine_mode
, optab
, rtx
, rtx
, int);
59 static void emit_libcall_block_1 (rtx
, rtx
, rtx
, rtx
, bool);
61 /* Debug facility for use in GDB. */
62 void debug_optab_libfuncs (void);
64 /* Prefixes for the current version of decimal floating point (BID vs. DPD) */
65 #if ENABLE_DECIMAL_BID_FORMAT
66 #define DECIMAL_PREFIX "bid_"
68 #define DECIMAL_PREFIX "dpd_"
71 /* Used for libfunc_hash. */
74 hash_libfunc (const void *p
)
76 const struct libfunc_entry
*const e
= (const struct libfunc_entry
*) p
;
77 return ((e
->mode1
+ e
->mode2
* NUM_MACHINE_MODES
) ^ e
->op
);
80 /* Used for libfunc_hash. */
83 eq_libfunc (const void *p
, const void *q
)
85 const struct libfunc_entry
*const e1
= (const struct libfunc_entry
*) p
;
86 const struct libfunc_entry
*const e2
= (const struct libfunc_entry
*) q
;
87 return e1
->op
== e2
->op
&& e1
->mode1
== e2
->mode1
&& e1
->mode2
== e2
->mode2
;
90 /* Return libfunc corresponding operation defined by OPTAB converting
91 from MODE2 to MODE1. Trigger lazy initialization if needed, return NULL
92 if no libfunc is available. */
94 convert_optab_libfunc (convert_optab optab
, enum machine_mode mode1
,
95 enum machine_mode mode2
)
97 struct libfunc_entry e
;
98 struct libfunc_entry
**slot
;
100 /* ??? This ought to be an assert, but not all of the places
101 that we expand optabs know about the optabs that got moved
103 if (!(optab
>= FIRST_CONV_OPTAB
&& optab
<= LAST_CONVLIB_OPTAB
))
109 slot
= (struct libfunc_entry
**)
110 htab_find_slot (libfunc_hash
, &e
, NO_INSERT
);
113 const struct convert_optab_libcall_d
*d
114 = &convlib_def
[optab
- FIRST_CONV_OPTAB
];
116 if (d
->libcall_gen
== NULL
)
119 d
->libcall_gen (optab
, d
->libcall_basename
, mode1
, mode2
);
120 slot
= (struct libfunc_entry
**)
121 htab_find_slot (libfunc_hash
, &e
, NO_INSERT
);
125 return (*slot
)->libfunc
;
128 /* Return libfunc corresponding operation defined by OPTAB in MODE.
129 Trigger lazy initialization if needed, return NULL if no libfunc is
132 optab_libfunc (optab optab
, enum machine_mode mode
)
134 struct libfunc_entry e
;
135 struct libfunc_entry
**slot
;
137 /* ??? This ought to be an assert, but not all of the places
138 that we expand optabs know about the optabs that got moved
140 if (!(optab
>= FIRST_NORM_OPTAB
&& optab
<= LAST_NORMLIB_OPTAB
))
146 slot
= (struct libfunc_entry
**)
147 htab_find_slot (libfunc_hash
, &e
, NO_INSERT
);
150 const struct optab_libcall_d
*d
151 = &normlib_def
[optab
- FIRST_NORM_OPTAB
];
153 if (d
->libcall_gen
== NULL
)
156 d
->libcall_gen (optab
, d
->libcall_basename
, d
->libcall_suffix
, mode
);
157 slot
= (struct libfunc_entry
**)
158 htab_find_slot (libfunc_hash
, &e
, NO_INSERT
);
162 return (*slot
)->libfunc
;
166 /* Add a REG_EQUAL note to the last insn in INSNS. TARGET is being set to
167 the result of operation CODE applied to OP0 (and OP1 if it is a binary
170 If the last insn does not set TARGET, don't do anything, but return 1.
172 If the last insn or a previous insn sets TARGET and TARGET is one of OP0
173 or OP1, don't add the REG_EQUAL note but return 0. Our caller can then
174 try again, ensuring that TARGET is not one of the operands. */
177 add_equal_note (rtx insns
, rtx target
, enum rtx_code code
, rtx op0
, rtx op1
)
182 gcc_assert (insns
&& INSN_P (insns
) && NEXT_INSN (insns
));
184 if (GET_RTX_CLASS (code
) != RTX_COMM_ARITH
185 && GET_RTX_CLASS (code
) != RTX_BIN_ARITH
186 && GET_RTX_CLASS (code
) != RTX_COMM_COMPARE
187 && GET_RTX_CLASS (code
) != RTX_COMPARE
188 && GET_RTX_CLASS (code
) != RTX_UNARY
)
191 if (GET_CODE (target
) == ZERO_EXTRACT
)
194 for (last_insn
= insns
;
195 NEXT_INSN (last_insn
) != NULL_RTX
;
196 last_insn
= NEXT_INSN (last_insn
))
199 /* If TARGET is in OP0 or OP1, punt. We'd end up with a note referencing
200 a value changing in the insn, so the note would be invalid for CSE. */
201 if (reg_overlap_mentioned_p (target
, op0
)
202 || (op1
&& reg_overlap_mentioned_p (target
, op1
)))
205 && (rtx_equal_p (target
, op0
)
206 || (op1
&& rtx_equal_p (target
, op1
))))
208 /* For MEM target, with MEM = MEM op X, prefer no REG_EQUAL note
209 over expanding it as temp = MEM op X, MEM = temp. If the target
210 supports MEM = MEM op X instructions, it is sometimes too hard
211 to reconstruct that form later, especially if X is also a memory,
212 and due to multiple occurrences of addresses the address might
213 be forced into register unnecessarily.
214 Note that not emitting the REG_EQUIV note might inhibit
215 CSE in some cases. */
216 set
= single_set (last_insn
);
218 && GET_CODE (SET_SRC (set
)) == code
219 && MEM_P (SET_DEST (set
))
220 && (rtx_equal_p (SET_DEST (set
), XEXP (SET_SRC (set
), 0))
221 || (op1
&& rtx_equal_p (SET_DEST (set
),
222 XEXP (SET_SRC (set
), 1)))))
228 set
= single_set (last_insn
);
232 if (! rtx_equal_p (SET_DEST (set
), target
)
233 /* For a STRICT_LOW_PART, the REG_NOTE applies to what is inside it. */
234 && (GET_CODE (SET_DEST (set
)) != STRICT_LOW_PART
235 || ! rtx_equal_p (XEXP (SET_DEST (set
), 0), target
)))
238 if (GET_RTX_CLASS (code
) == RTX_UNARY
)
248 if (GET_MODE (op0
) != VOIDmode
&& GET_MODE (target
) != GET_MODE (op0
))
250 note
= gen_rtx_fmt_e (code
, GET_MODE (op0
), copy_rtx (op0
));
251 if (GET_MODE_SIZE (GET_MODE (op0
))
252 > GET_MODE_SIZE (GET_MODE (target
)))
253 note
= simplify_gen_unary (TRUNCATE
, GET_MODE (target
),
254 note
, GET_MODE (op0
));
256 note
= simplify_gen_unary (ZERO_EXTEND
, GET_MODE (target
),
257 note
, GET_MODE (op0
));
262 note
= gen_rtx_fmt_e (code
, GET_MODE (target
), copy_rtx (op0
));
266 note
= gen_rtx_fmt_ee (code
, GET_MODE (target
), copy_rtx (op0
), copy_rtx (op1
));
268 set_unique_reg_note (last_insn
, REG_EQUAL
, note
);
273 /* Given two input operands, OP0 and OP1, determine what the correct from_mode
274 for a widening operation would be. In most cases this would be OP0, but if
275 that's a constant it'll be VOIDmode, which isn't useful. */
277 static enum machine_mode
278 widened_mode (enum machine_mode to_mode
, rtx op0
, rtx op1
)
280 enum machine_mode m0
= GET_MODE (op0
);
281 enum machine_mode m1
= GET_MODE (op1
);
282 enum machine_mode result
;
284 if (m0
== VOIDmode
&& m1
== VOIDmode
)
286 else if (m0
== VOIDmode
|| GET_MODE_SIZE (m0
) < GET_MODE_SIZE (m1
))
291 if (GET_MODE_SIZE (result
) > GET_MODE_SIZE (to_mode
))
297 /* Find a widening optab even if it doesn't widen as much as we want.
298 E.g. if from_mode is HImode, and to_mode is DImode, and there is no
299 direct HI->SI insn, then return SI->DI, if that exists.
300 If PERMIT_NON_WIDENING is non-zero then this can be used with
301 non-widening optabs also. */
304 find_widening_optab_handler_and_mode (optab op
, enum machine_mode to_mode
,
305 enum machine_mode from_mode
,
306 int permit_non_widening
,
307 enum machine_mode
*found_mode
)
309 for (; (permit_non_widening
|| from_mode
!= to_mode
)
310 && GET_MODE_SIZE (from_mode
) <= GET_MODE_SIZE (to_mode
)
311 && from_mode
!= VOIDmode
;
312 from_mode
= GET_MODE_WIDER_MODE (from_mode
))
314 enum insn_code handler
= widening_optab_handler (op
, to_mode
,
317 if (handler
!= CODE_FOR_nothing
)
320 *found_mode
= from_mode
;
325 return CODE_FOR_nothing
;
328 /* Widen OP to MODE and return the rtx for the widened operand. UNSIGNEDP
329 says whether OP is signed or unsigned. NO_EXTEND is nonzero if we need
330 not actually do a sign-extend or zero-extend, but can leave the
331 higher-order bits of the result rtx undefined, for example, in the case
332 of logical operations, but not right shifts. */
335 widen_operand (rtx op
, enum machine_mode mode
, enum machine_mode oldmode
,
336 int unsignedp
, int no_extend
)
340 /* If we don't have to extend and this is a constant, return it. */
341 if (no_extend
&& GET_MODE (op
) == VOIDmode
)
344 /* If we must extend do so. If OP is a SUBREG for a promoted object, also
345 extend since it will be more efficient to do so unless the signedness of
346 a promoted object differs from our extension. */
348 || (GET_CODE (op
) == SUBREG
&& SUBREG_PROMOTED_VAR_P (op
)
349 && SUBREG_PROMOTED_UNSIGNED_P (op
) == unsignedp
))
350 return convert_modes (mode
, oldmode
, op
, unsignedp
);
352 /* If MODE is no wider than a single word, we return a lowpart or paradoxical
354 if (GET_MODE_SIZE (mode
) <= UNITS_PER_WORD
)
355 return gen_lowpart (mode
, force_reg (GET_MODE (op
), op
));
357 /* Otherwise, get an object of MODE, clobber it, and set the low-order
360 result
= gen_reg_rtx (mode
);
361 emit_clobber (result
);
362 emit_move_insn (gen_lowpart (GET_MODE (op
), result
), op
);
366 /* Return the optab used for computing the operation given by the tree code,
367 CODE and the tree EXP. This function is not always usable (for example, it
368 cannot give complete results for multiplication or division) but probably
369 ought to be relied on more widely throughout the expander. */
371 optab_for_tree_code (enum tree_code code
, const_tree type
,
372 enum optab_subtype subtype
)
384 return one_cmpl_optab
;
389 case MULT_HIGHPART_EXPR
:
390 return TYPE_UNSIGNED (type
) ? umul_highpart_optab
: smul_highpart_optab
;
396 return TYPE_UNSIGNED (type
) ? umod_optab
: smod_optab
;
404 if (TYPE_SATURATING (type
))
405 return TYPE_UNSIGNED (type
) ? usdiv_optab
: ssdiv_optab
;
406 return TYPE_UNSIGNED (type
) ? udiv_optab
: sdiv_optab
;
409 if (TREE_CODE (type
) == VECTOR_TYPE
)
411 if (subtype
== optab_vector
)
412 return TYPE_SATURATING (type
) ? unknown_optab
: vashl_optab
;
414 gcc_assert (subtype
== optab_scalar
);
416 if (TYPE_SATURATING (type
))
417 return TYPE_UNSIGNED (type
) ? usashl_optab
: ssashl_optab
;
421 if (TREE_CODE (type
) == VECTOR_TYPE
)
423 if (subtype
== optab_vector
)
424 return TYPE_UNSIGNED (type
) ? vlshr_optab
: vashr_optab
;
426 gcc_assert (subtype
== optab_scalar
);
428 return TYPE_UNSIGNED (type
) ? lshr_optab
: ashr_optab
;
431 if (TREE_CODE (type
) == VECTOR_TYPE
)
433 if (subtype
== optab_vector
)
436 gcc_assert (subtype
== optab_scalar
);
441 if (TREE_CODE (type
) == VECTOR_TYPE
)
443 if (subtype
== optab_vector
)
446 gcc_assert (subtype
== optab_scalar
);
451 return TYPE_UNSIGNED (type
) ? umax_optab
: smax_optab
;
454 return TYPE_UNSIGNED (type
) ? umin_optab
: smin_optab
;
456 case REALIGN_LOAD_EXPR
:
457 return vec_realign_load_optab
;
460 return TYPE_UNSIGNED (type
) ? usum_widen_optab
: ssum_widen_optab
;
463 return TYPE_UNSIGNED (type
) ? udot_prod_optab
: sdot_prod_optab
;
465 case WIDEN_MULT_PLUS_EXPR
:
466 return (TYPE_UNSIGNED (type
)
467 ? (TYPE_SATURATING (type
)
468 ? usmadd_widen_optab
: umadd_widen_optab
)
469 : (TYPE_SATURATING (type
)
470 ? ssmadd_widen_optab
: smadd_widen_optab
));
472 case WIDEN_MULT_MINUS_EXPR
:
473 return (TYPE_UNSIGNED (type
)
474 ? (TYPE_SATURATING (type
)
475 ? usmsub_widen_optab
: umsub_widen_optab
)
476 : (TYPE_SATURATING (type
)
477 ? ssmsub_widen_optab
: smsub_widen_optab
));
483 return TYPE_UNSIGNED (type
) ? reduc_umax_optab
: reduc_smax_optab
;
486 return TYPE_UNSIGNED (type
) ? reduc_umin_optab
: reduc_smin_optab
;
488 case REDUC_PLUS_EXPR
:
489 return TYPE_UNSIGNED (type
) ? reduc_uplus_optab
: reduc_splus_optab
;
491 case VEC_LSHIFT_EXPR
:
492 return vec_shl_optab
;
494 case VEC_RSHIFT_EXPR
:
495 return vec_shr_optab
;
497 case VEC_WIDEN_MULT_HI_EXPR
:
498 return TYPE_UNSIGNED (type
) ?
499 vec_widen_umult_hi_optab
: vec_widen_smult_hi_optab
;
501 case VEC_WIDEN_MULT_LO_EXPR
:
502 return TYPE_UNSIGNED (type
) ?
503 vec_widen_umult_lo_optab
: vec_widen_smult_lo_optab
;
505 case VEC_WIDEN_MULT_EVEN_EXPR
:
506 return TYPE_UNSIGNED (type
) ?
507 vec_widen_umult_even_optab
: vec_widen_smult_even_optab
;
509 case VEC_WIDEN_MULT_ODD_EXPR
:
510 return TYPE_UNSIGNED (type
) ?
511 vec_widen_umult_odd_optab
: vec_widen_smult_odd_optab
;
513 case VEC_WIDEN_LSHIFT_HI_EXPR
:
514 return TYPE_UNSIGNED (type
) ?
515 vec_widen_ushiftl_hi_optab
: vec_widen_sshiftl_hi_optab
;
517 case VEC_WIDEN_LSHIFT_LO_EXPR
:
518 return TYPE_UNSIGNED (type
) ?
519 vec_widen_ushiftl_lo_optab
: vec_widen_sshiftl_lo_optab
;
521 case VEC_UNPACK_HI_EXPR
:
522 return TYPE_UNSIGNED (type
) ?
523 vec_unpacku_hi_optab
: vec_unpacks_hi_optab
;
525 case VEC_UNPACK_LO_EXPR
:
526 return TYPE_UNSIGNED (type
) ?
527 vec_unpacku_lo_optab
: vec_unpacks_lo_optab
;
529 case VEC_UNPACK_FLOAT_HI_EXPR
:
530 /* The signedness is determined from input operand. */
531 return TYPE_UNSIGNED (type
) ?
532 vec_unpacku_float_hi_optab
: vec_unpacks_float_hi_optab
;
534 case VEC_UNPACK_FLOAT_LO_EXPR
:
535 /* The signedness is determined from input operand. */
536 return TYPE_UNSIGNED (type
) ?
537 vec_unpacku_float_lo_optab
: vec_unpacks_float_lo_optab
;
539 case VEC_PACK_TRUNC_EXPR
:
540 return vec_pack_trunc_optab
;
542 case VEC_PACK_SAT_EXPR
:
543 return TYPE_UNSIGNED (type
) ? vec_pack_usat_optab
: vec_pack_ssat_optab
;
545 case VEC_PACK_FIX_TRUNC_EXPR
:
546 /* The signedness is determined from output operand. */
547 return TYPE_UNSIGNED (type
) ?
548 vec_pack_ufix_trunc_optab
: vec_pack_sfix_trunc_optab
;
554 trapv
= INTEGRAL_TYPE_P (type
) && TYPE_OVERFLOW_TRAPS (type
);
557 case POINTER_PLUS_EXPR
:
559 if (TYPE_SATURATING (type
))
560 return TYPE_UNSIGNED (type
) ? usadd_optab
: ssadd_optab
;
561 return trapv
? addv_optab
: add_optab
;
564 if (TYPE_SATURATING (type
))
565 return TYPE_UNSIGNED (type
) ? ussub_optab
: sssub_optab
;
566 return trapv
? subv_optab
: sub_optab
;
569 if (TYPE_SATURATING (type
))
570 return TYPE_UNSIGNED (type
) ? usmul_optab
: ssmul_optab
;
571 return trapv
? smulv_optab
: smul_optab
;
574 if (TYPE_SATURATING (type
))
575 return TYPE_UNSIGNED (type
) ? usneg_optab
: ssneg_optab
;
576 return trapv
? negv_optab
: neg_optab
;
579 return trapv
? absv_optab
: abs_optab
;
582 return unknown_optab
;
587 /* Expand vector widening operations.
589 There are two different classes of operations handled here:
590 1) Operations whose result is wider than all the arguments to the operation.
591 Examples: VEC_UNPACK_HI/LO_EXPR, VEC_WIDEN_MULT_HI/LO_EXPR
592 In this case OP0 and optionally OP1 would be initialized,
593 but WIDE_OP wouldn't (not relevant for this case).
594 2) Operations whose result is of the same size as the last argument to the
595 operation, but wider than all the other arguments to the operation.
596 Examples: WIDEN_SUM_EXPR, VEC_DOT_PROD_EXPR.
597 In the case WIDE_OP, OP0 and optionally OP1 would be initialized.
599 E.g, when called to expand the following operations, this is how
600 the arguments will be initialized:
602 widening-sum 2 oprnd0 - oprnd1
603 widening-dot-product 3 oprnd0 oprnd1 oprnd2
604 widening-mult 2 oprnd0 oprnd1 -
605 type-promotion (vec-unpack) 1 oprnd0 - - */
608 expand_widen_pattern_expr (sepops ops
, rtx op0
, rtx op1
, rtx wide_op
,
609 rtx target
, int unsignedp
)
611 struct expand_operand eops
[4];
612 tree oprnd0
, oprnd1
, oprnd2
;
613 enum machine_mode wmode
= VOIDmode
, tmode0
, tmode1
= VOIDmode
;
614 optab widen_pattern_optab
;
615 enum insn_code icode
;
616 int nops
= TREE_CODE_LENGTH (ops
->code
);
620 tmode0
= TYPE_MODE (TREE_TYPE (oprnd0
));
621 widen_pattern_optab
=
622 optab_for_tree_code (ops
->code
, TREE_TYPE (oprnd0
), optab_default
);
623 if (ops
->code
== WIDEN_MULT_PLUS_EXPR
624 || ops
->code
== WIDEN_MULT_MINUS_EXPR
)
625 icode
= find_widening_optab_handler (widen_pattern_optab
,
626 TYPE_MODE (TREE_TYPE (ops
->op2
)),
629 icode
= optab_handler (widen_pattern_optab
, tmode0
);
630 gcc_assert (icode
!= CODE_FOR_nothing
);
635 tmode1
= TYPE_MODE (TREE_TYPE (oprnd1
));
638 /* The last operand is of a wider mode than the rest of the operands. */
643 gcc_assert (tmode1
== tmode0
);
646 wmode
= TYPE_MODE (TREE_TYPE (oprnd2
));
650 create_output_operand (&eops
[op
++], target
, TYPE_MODE (ops
->type
));
651 create_convert_operand_from (&eops
[op
++], op0
, tmode0
, unsignedp
);
653 create_convert_operand_from (&eops
[op
++], op1
, tmode1
, unsignedp
);
655 create_convert_operand_from (&eops
[op
++], wide_op
, wmode
, unsignedp
);
656 expand_insn (icode
, op
, eops
);
657 return eops
[0].value
;
660 /* Generate code to perform an operation specified by TERNARY_OPTAB
661 on operands OP0, OP1 and OP2, with result having machine-mode MODE.
663 UNSIGNEDP is for the case where we have to widen the operands
664 to perform the operation. It says to use zero-extension.
666 If TARGET is nonzero, the value
667 is generated there, if it is convenient to do so.
668 In all cases an rtx is returned for the locus of the value;
669 this may or may not be TARGET. */
672 expand_ternary_op (enum machine_mode mode
, optab ternary_optab
, rtx op0
,
673 rtx op1
, rtx op2
, rtx target
, int unsignedp
)
675 struct expand_operand ops
[4];
676 enum insn_code icode
= optab_handler (ternary_optab
, mode
);
678 gcc_assert (optab_handler (ternary_optab
, mode
) != CODE_FOR_nothing
);
680 create_output_operand (&ops
[0], target
, mode
);
681 create_convert_operand_from (&ops
[1], op0
, mode
, unsignedp
);
682 create_convert_operand_from (&ops
[2], op1
, mode
, unsignedp
);
683 create_convert_operand_from (&ops
[3], op2
, mode
, unsignedp
);
684 expand_insn (icode
, 4, ops
);
689 /* Like expand_binop, but return a constant rtx if the result can be
690 calculated at compile time. The arguments and return value are
691 otherwise the same as for expand_binop. */
694 simplify_expand_binop (enum machine_mode mode
, optab binoptab
,
695 rtx op0
, rtx op1
, rtx target
, int unsignedp
,
696 enum optab_methods methods
)
698 if (CONSTANT_P (op0
) && CONSTANT_P (op1
))
700 rtx x
= simplify_binary_operation (optab_to_code (binoptab
),
706 return expand_binop (mode
, binoptab
, op0
, op1
, target
, unsignedp
, methods
);
709 /* Like simplify_expand_binop, but always put the result in TARGET.
710 Return true if the expansion succeeded. */
713 force_expand_binop (enum machine_mode mode
, optab binoptab
,
714 rtx op0
, rtx op1
, rtx target
, int unsignedp
,
715 enum optab_methods methods
)
717 rtx x
= simplify_expand_binop (mode
, binoptab
, op0
, op1
,
718 target
, unsignedp
, methods
);
722 emit_move_insn (target
, x
);
726 /* Generate insns for VEC_LSHIFT_EXPR, VEC_RSHIFT_EXPR. */
729 expand_vec_shift_expr (sepops ops
, rtx target
)
731 struct expand_operand eops
[3];
732 enum insn_code icode
;
733 rtx rtx_op1
, rtx_op2
;
734 enum machine_mode mode
= TYPE_MODE (ops
->type
);
735 tree vec_oprnd
= ops
->op0
;
736 tree shift_oprnd
= ops
->op1
;
741 case VEC_RSHIFT_EXPR
:
742 shift_optab
= vec_shr_optab
;
744 case VEC_LSHIFT_EXPR
:
745 shift_optab
= vec_shl_optab
;
751 icode
= optab_handler (shift_optab
, mode
);
752 gcc_assert (icode
!= CODE_FOR_nothing
);
754 rtx_op1
= expand_normal (vec_oprnd
);
755 rtx_op2
= expand_normal (shift_oprnd
);
757 create_output_operand (&eops
[0], target
, mode
);
758 create_input_operand (&eops
[1], rtx_op1
, GET_MODE (rtx_op1
));
759 create_convert_operand_from_type (&eops
[2], rtx_op2
, TREE_TYPE (shift_oprnd
));
760 expand_insn (icode
, 3, eops
);
762 return eops
[0].value
;
765 /* Create a new vector value in VMODE with all elements set to OP. The
766 mode of OP must be the element mode of VMODE. If OP is a constant,
767 then the return value will be a constant. */
770 expand_vector_broadcast (enum machine_mode vmode
, rtx op
)
772 enum insn_code icode
;
777 gcc_checking_assert (VECTOR_MODE_P (vmode
));
779 n
= GET_MODE_NUNITS (vmode
);
780 vec
= rtvec_alloc (n
);
781 for (i
= 0; i
< n
; ++i
)
782 RTVEC_ELT (vec
, i
) = op
;
785 return gen_rtx_CONST_VECTOR (vmode
, vec
);
787 /* ??? If the target doesn't have a vec_init, then we have no easy way
788 of performing this operation. Most of this sort of generic support
789 is hidden away in the vector lowering support in gimple. */
790 icode
= optab_handler (vec_init_optab
, vmode
);
791 if (icode
== CODE_FOR_nothing
)
794 ret
= gen_reg_rtx (vmode
);
795 emit_insn (GEN_FCN (icode
) (ret
, gen_rtx_PARALLEL (vmode
, vec
)));
800 /* This subroutine of expand_doubleword_shift handles the cases in which
801 the effective shift value is >= BITS_PER_WORD. The arguments and return
802 value are the same as for the parent routine, except that SUPERWORD_OP1
803 is the shift count to use when shifting OUTOF_INPUT into INTO_TARGET.
804 INTO_TARGET may be null if the caller has decided to calculate it. */
807 expand_superword_shift (optab binoptab
, rtx outof_input
, rtx superword_op1
,
808 rtx outof_target
, rtx into_target
,
809 int unsignedp
, enum optab_methods methods
)
811 if (into_target
!= 0)
812 if (!force_expand_binop (word_mode
, binoptab
, outof_input
, superword_op1
,
813 into_target
, unsignedp
, methods
))
816 if (outof_target
!= 0)
818 /* For a signed right shift, we must fill OUTOF_TARGET with copies
819 of the sign bit, otherwise we must fill it with zeros. */
820 if (binoptab
!= ashr_optab
)
821 emit_move_insn (outof_target
, CONST0_RTX (word_mode
));
823 if (!force_expand_binop (word_mode
, binoptab
,
824 outof_input
, GEN_INT (BITS_PER_WORD
- 1),
825 outof_target
, unsignedp
, methods
))
831 /* This subroutine of expand_doubleword_shift handles the cases in which
832 the effective shift value is < BITS_PER_WORD. The arguments and return
833 value are the same as for the parent routine. */
836 expand_subword_shift (enum machine_mode op1_mode
, optab binoptab
,
837 rtx outof_input
, rtx into_input
, rtx op1
,
838 rtx outof_target
, rtx into_target
,
839 int unsignedp
, enum optab_methods methods
,
840 unsigned HOST_WIDE_INT shift_mask
)
842 optab reverse_unsigned_shift
, unsigned_shift
;
845 reverse_unsigned_shift
= (binoptab
== ashl_optab
? lshr_optab
: ashl_optab
);
846 unsigned_shift
= (binoptab
== ashl_optab
? ashl_optab
: lshr_optab
);
848 /* The low OP1 bits of INTO_TARGET come from the high bits of OUTOF_INPUT.
849 We therefore need to shift OUTOF_INPUT by (BITS_PER_WORD - OP1) bits in
850 the opposite direction to BINOPTAB. */
851 if (CONSTANT_P (op1
) || shift_mask
>= BITS_PER_WORD
)
853 carries
= outof_input
;
854 tmp
= immed_wide_int_const (wi::shwi (BITS_PER_WORD
,
855 op1_mode
), op1_mode
);
856 tmp
= simplify_expand_binop (op1_mode
, sub_optab
, tmp
, op1
,
861 /* We must avoid shifting by BITS_PER_WORD bits since that is either
862 the same as a zero shift (if shift_mask == BITS_PER_WORD - 1) or
863 has unknown behavior. Do a single shift first, then shift by the
864 remainder. It's OK to use ~OP1 as the remainder if shift counts
865 are truncated to the mode size. */
866 carries
= expand_binop (word_mode
, reverse_unsigned_shift
,
867 outof_input
, const1_rtx
, 0, unsignedp
, methods
);
868 if (shift_mask
== BITS_PER_WORD
- 1)
870 tmp
= immed_wide_int_const
871 (wi::minus_one (GET_MODE_PRECISION (op1_mode
)), op1_mode
);
872 tmp
= simplify_expand_binop (op1_mode
, xor_optab
, op1
, tmp
,
877 tmp
= immed_wide_int_const (wi::shwi (BITS_PER_WORD
- 1,
878 op1_mode
), op1_mode
);
879 tmp
= simplify_expand_binop (op1_mode
, sub_optab
, tmp
, op1
,
883 if (tmp
== 0 || carries
== 0)
885 carries
= expand_binop (word_mode
, reverse_unsigned_shift
,
886 carries
, tmp
, 0, unsignedp
, methods
);
890 /* Shift INTO_INPUT logically by OP1. This is the last use of INTO_INPUT
891 so the result can go directly into INTO_TARGET if convenient. */
892 tmp
= expand_binop (word_mode
, unsigned_shift
, into_input
, op1
,
893 into_target
, unsignedp
, methods
);
897 /* Now OR in the bits carried over from OUTOF_INPUT. */
898 if (!force_expand_binop (word_mode
, ior_optab
, tmp
, carries
,
899 into_target
, unsignedp
, methods
))
902 /* Use a standard word_mode shift for the out-of half. */
903 if (outof_target
!= 0)
904 if (!force_expand_binop (word_mode
, binoptab
, outof_input
, op1
,
905 outof_target
, unsignedp
, methods
))
912 #ifdef HAVE_conditional_move
913 /* Try implementing expand_doubleword_shift using conditional moves.
914 The shift is by < BITS_PER_WORD if (CMP_CODE CMP1 CMP2) is true,
915 otherwise it is by >= BITS_PER_WORD. SUBWORD_OP1 and SUPERWORD_OP1
916 are the shift counts to use in the former and latter case. All other
917 arguments are the same as the parent routine. */
920 expand_doubleword_shift_condmove (enum machine_mode op1_mode
, optab binoptab
,
921 enum rtx_code cmp_code
, rtx cmp1
, rtx cmp2
,
922 rtx outof_input
, rtx into_input
,
923 rtx subword_op1
, rtx superword_op1
,
924 rtx outof_target
, rtx into_target
,
925 int unsignedp
, enum optab_methods methods
,
926 unsigned HOST_WIDE_INT shift_mask
)
928 rtx outof_superword
, into_superword
;
930 /* Put the superword version of the output into OUTOF_SUPERWORD and
932 outof_superword
= outof_target
!= 0 ? gen_reg_rtx (word_mode
) : 0;
933 if (outof_target
!= 0 && subword_op1
== superword_op1
)
935 /* The value INTO_TARGET >> SUBWORD_OP1, which we later store in
936 OUTOF_TARGET, is the same as the value of INTO_SUPERWORD. */
937 into_superword
= outof_target
;
938 if (!expand_superword_shift (binoptab
, outof_input
, superword_op1
,
939 outof_superword
, 0, unsignedp
, methods
))
944 into_superword
= gen_reg_rtx (word_mode
);
945 if (!expand_superword_shift (binoptab
, outof_input
, superword_op1
,
946 outof_superword
, into_superword
,
951 /* Put the subword version directly in OUTOF_TARGET and INTO_TARGET. */
952 if (!expand_subword_shift (op1_mode
, binoptab
,
953 outof_input
, into_input
, subword_op1
,
954 outof_target
, into_target
,
955 unsignedp
, methods
, shift_mask
))
958 /* Select between them. Do the INTO half first because INTO_SUPERWORD
959 might be the current value of OUTOF_TARGET. */
960 if (!emit_conditional_move (into_target
, cmp_code
, cmp1
, cmp2
, op1_mode
,
961 into_target
, into_superword
, word_mode
, false))
964 if (outof_target
!= 0)
965 if (!emit_conditional_move (outof_target
, cmp_code
, cmp1
, cmp2
, op1_mode
,
966 outof_target
, outof_superword
,
974 /* Expand a doubleword shift (ashl, ashr or lshr) using word-mode shifts.
975 OUTOF_INPUT and INTO_INPUT are the two word-sized halves of the first
976 input operand; the shift moves bits in the direction OUTOF_INPUT->
977 INTO_TARGET. OUTOF_TARGET and INTO_TARGET are the equivalent words
978 of the target. OP1 is the shift count and OP1_MODE is its mode.
979 If OP1 is constant, it will have been truncated as appropriate
980 and is known to be nonzero.
982 If SHIFT_MASK is zero, the result of word shifts is undefined when the
983 shift count is outside the range [0, BITS_PER_WORD). This routine must
984 avoid generating such shifts for OP1s in the range [0, BITS_PER_WORD * 2).
986 If SHIFT_MASK is nonzero, all word-mode shift counts are effectively
987 masked by it and shifts in the range [BITS_PER_WORD, SHIFT_MASK) will
988 fill with zeros or sign bits as appropriate.
990 If SHIFT_MASK is BITS_PER_WORD - 1, this routine will synthesize
991 a doubleword shift whose equivalent mask is BITS_PER_WORD * 2 - 1.
992 Doing this preserves semantics required by SHIFT_COUNT_TRUNCATED.
993 In all other cases, shifts by values outside [0, BITS_PER_UNIT * 2)
996 BINOPTAB, UNSIGNEDP and METHODS are as for expand_binop. This function
997 may not use INTO_INPUT after modifying INTO_TARGET, and similarly for
998 OUTOF_INPUT and OUTOF_TARGET. OUTOF_TARGET can be null if the parent
999 function wants to calculate it itself.
1001 Return true if the shift could be successfully synthesized. */
1004 expand_doubleword_shift (enum machine_mode op1_mode
, optab binoptab
,
1005 rtx outof_input
, rtx into_input
, rtx op1
,
1006 rtx outof_target
, rtx into_target
,
1007 int unsignedp
, enum optab_methods methods
,
1008 unsigned HOST_WIDE_INT shift_mask
)
1010 rtx superword_op1
, tmp
, cmp1
, cmp2
;
1011 rtx subword_label
, done_label
;
1012 enum rtx_code cmp_code
;
1014 /* See if word-mode shifts by BITS_PER_WORD...BITS_PER_WORD * 2 - 1 will
1015 fill the result with sign or zero bits as appropriate. If so, the value
1016 of OUTOF_TARGET will always be (SHIFT OUTOF_INPUT OP1). Recursively call
1017 this routine to calculate INTO_TARGET (which depends on both OUTOF_INPUT
1018 and INTO_INPUT), then emit code to set up OUTOF_TARGET.
1020 This isn't worthwhile for constant shifts since the optimizers will
1021 cope better with in-range shift counts. */
1022 if (shift_mask
>= BITS_PER_WORD
1023 && outof_target
!= 0
1024 && !CONSTANT_P (op1
))
1026 if (!expand_doubleword_shift (op1_mode
, binoptab
,
1027 outof_input
, into_input
, op1
,
1029 unsignedp
, methods
, shift_mask
))
1031 if (!force_expand_binop (word_mode
, binoptab
, outof_input
, op1
,
1032 outof_target
, unsignedp
, methods
))
1037 /* Set CMP_CODE, CMP1 and CMP2 so that the rtx (CMP_CODE CMP1 CMP2)
1038 is true when the effective shift value is less than BITS_PER_WORD.
1039 Set SUPERWORD_OP1 to the shift count that should be used to shift
1040 OUTOF_INPUT into INTO_TARGET when the condition is false. */
1041 tmp
= immed_wide_int_const (wi::shwi (BITS_PER_WORD
, op1_mode
), op1_mode
);
1042 if (!CONSTANT_P (op1
) && shift_mask
== BITS_PER_WORD
- 1)
1044 /* Set CMP1 to OP1 & BITS_PER_WORD. The result is zero iff OP1
1045 is a subword shift count. */
1046 cmp1
= simplify_expand_binop (op1_mode
, and_optab
, op1
, tmp
,
1048 cmp2
= CONST0_RTX (op1_mode
);
1050 superword_op1
= op1
;
1054 /* Set CMP1 to OP1 - BITS_PER_WORD. */
1055 cmp1
= simplify_expand_binop (op1_mode
, sub_optab
, op1
, tmp
,
1057 cmp2
= CONST0_RTX (op1_mode
);
1059 superword_op1
= cmp1
;
1064 /* If we can compute the condition at compile time, pick the
1065 appropriate subroutine. */
1066 tmp
= simplify_relational_operation (cmp_code
, SImode
, op1_mode
, cmp1
, cmp2
);
1067 if (tmp
!= 0 && CONST_INT_P (tmp
))
1069 if (tmp
== const0_rtx
)
1070 return expand_superword_shift (binoptab
, outof_input
, superword_op1
,
1071 outof_target
, into_target
,
1072 unsignedp
, methods
);
1074 return expand_subword_shift (op1_mode
, binoptab
,
1075 outof_input
, into_input
, op1
,
1076 outof_target
, into_target
,
1077 unsignedp
, methods
, shift_mask
);
1080 #ifdef HAVE_conditional_move
1081 /* Try using conditional moves to generate straight-line code. */
1083 rtx start
= get_last_insn ();
1084 if (expand_doubleword_shift_condmove (op1_mode
, binoptab
,
1085 cmp_code
, cmp1
, cmp2
,
1086 outof_input
, into_input
,
1088 outof_target
, into_target
,
1089 unsignedp
, methods
, shift_mask
))
1091 delete_insns_since (start
);
1095 /* As a last resort, use branches to select the correct alternative. */
1096 subword_label
= gen_label_rtx ();
1097 done_label
= gen_label_rtx ();
1100 do_compare_rtx_and_jump (cmp1
, cmp2
, cmp_code
, false, op1_mode
,
1101 0, 0, subword_label
, -1);
1104 if (!expand_superword_shift (binoptab
, outof_input
, superword_op1
,
1105 outof_target
, into_target
,
1106 unsignedp
, methods
))
1109 emit_jump_insn (gen_jump (done_label
));
1111 emit_label (subword_label
);
1113 if (!expand_subword_shift (op1_mode
, binoptab
,
1114 outof_input
, into_input
, op1
,
1115 outof_target
, into_target
,
1116 unsignedp
, methods
, shift_mask
))
1119 emit_label (done_label
);
1123 /* Subroutine of expand_binop. Perform a double word multiplication of
1124 operands OP0 and OP1 both of mode MODE, which is exactly twice as wide
1125 as the target's word_mode. This function return NULL_RTX if anything
1126 goes wrong, in which case it may have already emitted instructions
1127 which need to be deleted.
1129 If we want to multiply two two-word values and have normal and widening
1130 multiplies of single-word values, we can do this with three smaller
1133 The multiplication proceeds as follows:
1134 _______________________
1135 [__op0_high_|__op0_low__]
1136 _______________________
1137 * [__op1_high_|__op1_low__]
1138 _______________________________________________
1139 _______________________
1140 (1) [__op0_low__*__op1_low__]
1141 _______________________
1142 (2a) [__op0_low__*__op1_high_]
1143 _______________________
1144 (2b) [__op0_high_*__op1_low__]
1145 _______________________
1146 (3) [__op0_high_*__op1_high_]
1149 This gives a 4-word result. Since we are only interested in the
1150 lower 2 words, partial result (3) and the upper words of (2a) and
1151 (2b) don't need to be calculated. Hence (2a) and (2b) can be
1152 calculated using non-widening multiplication.
1154 (1), however, needs to be calculated with an unsigned widening
1155 multiplication. If this operation is not directly supported we
1156 try using a signed widening multiplication and adjust the result.
1157 This adjustment works as follows:
1159 If both operands are positive then no adjustment is needed.
1161 If the operands have different signs, for example op0_low < 0 and
1162 op1_low >= 0, the instruction treats the most significant bit of
1163 op0_low as a sign bit instead of a bit with significance
1164 2**(BITS_PER_WORD-1), i.e. the instruction multiplies op1_low
1165 with 2**BITS_PER_WORD - op0_low, and two's complements the
1166 result. Conclusion: We need to add op1_low * 2**BITS_PER_WORD to
1169 Similarly, if both operands are negative, we need to add
1170 (op0_low + op1_low) * 2**BITS_PER_WORD.
1172 We use a trick to adjust quickly. We logically shift op0_low right
1173 (op1_low) BITS_PER_WORD-1 steps to get 0 or 1, and add this to
1174 op0_high (op1_high) before it is used to calculate 2b (2a). If no
1175 logical shift exists, we do an arithmetic right shift and subtract
1179 expand_doubleword_mult (enum machine_mode mode
, rtx op0
, rtx op1
, rtx target
,
1180 bool umulp
, enum optab_methods methods
)
1182 int low
= (WORDS_BIG_ENDIAN
? 1 : 0);
1183 int high
= (WORDS_BIG_ENDIAN
? 0 : 1);
1184 rtx wordm1
= umulp
? NULL_RTX
: GEN_INT (BITS_PER_WORD
- 1);
1185 rtx product
, adjust
, product_high
, temp
;
1187 rtx op0_high
= operand_subword_force (op0
, high
, mode
);
1188 rtx op0_low
= operand_subword_force (op0
, low
, mode
);
1189 rtx op1_high
= operand_subword_force (op1
, high
, mode
);
1190 rtx op1_low
= operand_subword_force (op1
, low
, mode
);
1192 /* If we're using an unsigned multiply to directly compute the product
1193 of the low-order words of the operands and perform any required
1194 adjustments of the operands, we begin by trying two more multiplications
1195 and then computing the appropriate sum.
1197 We have checked above that the required addition is provided.
1198 Full-word addition will normally always succeed, especially if
1199 it is provided at all, so we don't worry about its failure. The
1200 multiplication may well fail, however, so we do handle that. */
1204 /* ??? This could be done with emit_store_flag where available. */
1205 temp
= expand_binop (word_mode
, lshr_optab
, op0_low
, wordm1
,
1206 NULL_RTX
, 1, methods
);
1208 op0_high
= expand_binop (word_mode
, add_optab
, op0_high
, temp
,
1209 NULL_RTX
, 0, OPTAB_DIRECT
);
1212 temp
= expand_binop (word_mode
, ashr_optab
, op0_low
, wordm1
,
1213 NULL_RTX
, 0, methods
);
1216 op0_high
= expand_binop (word_mode
, sub_optab
, op0_high
, temp
,
1217 NULL_RTX
, 0, OPTAB_DIRECT
);
1224 adjust
= expand_binop (word_mode
, smul_optab
, op0_high
, op1_low
,
1225 NULL_RTX
, 0, OPTAB_DIRECT
);
1229 /* OP0_HIGH should now be dead. */
1233 /* ??? This could be done with emit_store_flag where available. */
1234 temp
= expand_binop (word_mode
, lshr_optab
, op1_low
, wordm1
,
1235 NULL_RTX
, 1, methods
);
1237 op1_high
= expand_binop (word_mode
, add_optab
, op1_high
, temp
,
1238 NULL_RTX
, 0, OPTAB_DIRECT
);
1241 temp
= expand_binop (word_mode
, ashr_optab
, op1_low
, wordm1
,
1242 NULL_RTX
, 0, methods
);
1245 op1_high
= expand_binop (word_mode
, sub_optab
, op1_high
, temp
,
1246 NULL_RTX
, 0, OPTAB_DIRECT
);
1253 temp
= expand_binop (word_mode
, smul_optab
, op1_high
, op0_low
,
1254 NULL_RTX
, 0, OPTAB_DIRECT
);
1258 /* OP1_HIGH should now be dead. */
1260 adjust
= expand_binop (word_mode
, add_optab
, adjust
, temp
,
1261 NULL_RTX
, 0, OPTAB_DIRECT
);
1263 if (target
&& !REG_P (target
))
1267 product
= expand_binop (mode
, umul_widen_optab
, op0_low
, op1_low
,
1268 target
, 1, OPTAB_DIRECT
);
1270 product
= expand_binop (mode
, smul_widen_optab
, op0_low
, op1_low
,
1271 target
, 1, OPTAB_DIRECT
);
1276 product_high
= operand_subword (product
, high
, 1, mode
);
1277 adjust
= expand_binop (word_mode
, add_optab
, product_high
, adjust
,
1278 NULL_RTX
, 0, OPTAB_DIRECT
);
1279 emit_move_insn (product_high
, adjust
);
1283 /* Wrapper around expand_binop which takes an rtx code to specify
1284 the operation to perform, not an optab pointer. All other
1285 arguments are the same. */
1287 expand_simple_binop (enum machine_mode mode
, enum rtx_code code
, rtx op0
,
1288 rtx op1
, rtx target
, int unsignedp
,
1289 enum optab_methods methods
)
1291 optab binop
= code_to_optab (code
);
1294 return expand_binop (mode
, binop
, op0
, op1
, target
, unsignedp
, methods
);
1297 /* Return whether OP0 and OP1 should be swapped when expanding a commutative
1298 binop. Order them according to commutative_operand_precedence and, if
1299 possible, try to put TARGET or a pseudo first. */
1301 swap_commutative_operands_with_target (rtx target
, rtx op0
, rtx op1
)
1303 int op0_prec
= commutative_operand_precedence (op0
);
1304 int op1_prec
= commutative_operand_precedence (op1
);
1306 if (op0_prec
< op1_prec
)
1309 if (op0_prec
> op1_prec
)
1312 /* With equal precedence, both orders are ok, but it is better if the
1313 first operand is TARGET, or if both TARGET and OP0 are pseudos. */
1314 if (target
== 0 || REG_P (target
))
1315 return (REG_P (op1
) && !REG_P (op0
)) || target
== op1
;
1317 return rtx_equal_p (op1
, target
);
1320 /* Return true if BINOPTAB implements a shift operation. */
1323 shift_optab_p (optab binoptab
)
1325 switch (optab_to_code (binoptab
))
1341 /* Return true if BINOPTAB implements a commutative binary operation. */
1344 commutative_optab_p (optab binoptab
)
1346 return (GET_RTX_CLASS (optab_to_code (binoptab
)) == RTX_COMM_ARITH
1347 || binoptab
== smul_widen_optab
1348 || binoptab
== umul_widen_optab
1349 || binoptab
== smul_highpart_optab
1350 || binoptab
== umul_highpart_optab
);
1353 /* X is to be used in mode MODE as operand OPN to BINOPTAB. If we're
1354 optimizing, and if the operand is a constant that costs more than
1355 1 instruction, force the constant into a register and return that
1356 register. Return X otherwise. UNSIGNEDP says whether X is unsigned. */
1359 avoid_expensive_constant (enum machine_mode mode
, optab binoptab
,
1360 int opn
, rtx x
, bool unsignedp
)
1362 bool speed
= optimize_insn_for_speed_p ();
1364 if (mode
!= VOIDmode
1367 && (rtx_cost (x
, optab_to_code (binoptab
), opn
, speed
)
1368 > set_src_cost (x
, speed
)))
1370 if (CONST_INT_P (x
))
1372 HOST_WIDE_INT intval
= trunc_int_for_mode (INTVAL (x
), mode
);
1373 if (intval
!= INTVAL (x
))
1374 x
= GEN_INT (intval
);
1377 x
= convert_modes (mode
, VOIDmode
, x
, unsignedp
);
1378 x
= force_reg (mode
, x
);
1383 /* Helper function for expand_binop: handle the case where there
1384 is an insn that directly implements the indicated operation.
1385 Returns null if this is not possible. */
1387 expand_binop_directly (enum machine_mode mode
, optab binoptab
,
1389 rtx target
, int unsignedp
, enum optab_methods methods
,
1392 enum machine_mode from_mode
= widened_mode (mode
, op0
, op1
);
1393 enum insn_code icode
= find_widening_optab_handler (binoptab
, mode
,
1395 enum machine_mode xmode0
= insn_data
[(int) icode
].operand
[1].mode
;
1396 enum machine_mode xmode1
= insn_data
[(int) icode
].operand
[2].mode
;
1397 enum machine_mode mode0
, mode1
, tmp_mode
;
1398 struct expand_operand ops
[3];
1401 rtx xop0
= op0
, xop1
= op1
;
1404 /* If it is a commutative operator and the modes would match
1405 if we would swap the operands, we can save the conversions. */
1406 commutative_p
= commutative_optab_p (binoptab
);
1408 && GET_MODE (xop0
) != xmode0
&& GET_MODE (xop1
) != xmode1
1409 && GET_MODE (xop0
) == xmode1
&& GET_MODE (xop1
) == xmode1
)
1416 /* If we are optimizing, force expensive constants into a register. */
1417 xop0
= avoid_expensive_constant (xmode0
, binoptab
, 0, xop0
, unsignedp
);
1418 if (!shift_optab_p (binoptab
))
1419 xop1
= avoid_expensive_constant (xmode1
, binoptab
, 1, xop1
, unsignedp
);
1421 /* In case the insn wants input operands in modes different from
1422 those of the actual operands, convert the operands. It would
1423 seem that we don't need to convert CONST_INTs, but we do, so
1424 that they're properly zero-extended, sign-extended or truncated
1427 mode0
= GET_MODE (xop0
) != VOIDmode
? GET_MODE (xop0
) : mode
;
1428 if (xmode0
!= VOIDmode
&& xmode0
!= mode0
)
1430 xop0
= convert_modes (xmode0
, mode0
, xop0
, unsignedp
);
1434 mode1
= GET_MODE (xop1
) != VOIDmode
? GET_MODE (xop1
) : mode
;
1435 if (xmode1
!= VOIDmode
&& xmode1
!= mode1
)
1437 xop1
= convert_modes (xmode1
, mode1
, xop1
, unsignedp
);
1441 /* If operation is commutative,
1442 try to make the first operand a register.
1443 Even better, try to make it the same as the target.
1444 Also try to make the last operand a constant. */
1446 && swap_commutative_operands_with_target (target
, xop0
, xop1
))
1453 /* Now, if insn's predicates don't allow our operands, put them into
1456 if (binoptab
== vec_pack_trunc_optab
1457 || binoptab
== vec_pack_usat_optab
1458 || binoptab
== vec_pack_ssat_optab
1459 || binoptab
== vec_pack_ufix_trunc_optab
1460 || binoptab
== vec_pack_sfix_trunc_optab
)
1462 /* The mode of the result is different then the mode of the
1464 tmp_mode
= insn_data
[(int) icode
].operand
[0].mode
;
1465 if (GET_MODE_NUNITS (tmp_mode
) != 2 * GET_MODE_NUNITS (mode
))
1467 delete_insns_since (last
);
1474 create_output_operand (&ops
[0], target
, tmp_mode
);
1475 create_input_operand (&ops
[1], xop0
, mode0
);
1476 create_input_operand (&ops
[2], xop1
, mode1
);
1477 pat
= maybe_gen_insn (icode
, 3, ops
);
1480 /* If PAT is composed of more than one insn, try to add an appropriate
1481 REG_EQUAL note to it. If we can't because TEMP conflicts with an
1482 operand, call expand_binop again, this time without a target. */
1483 if (INSN_P (pat
) && NEXT_INSN (pat
) != NULL_RTX
1484 && ! add_equal_note (pat
, ops
[0].value
, optab_to_code (binoptab
),
1485 ops
[1].value
, ops
[2].value
))
1487 delete_insns_since (last
);
1488 return expand_binop (mode
, binoptab
, op0
, op1
, NULL_RTX
,
1489 unsignedp
, methods
);
1493 return ops
[0].value
;
1495 delete_insns_since (last
);
1499 /* Generate code to perform an operation specified by BINOPTAB
1500 on operands OP0 and OP1, with result having machine-mode MODE.
1502 UNSIGNEDP is for the case where we have to widen the operands
1503 to perform the operation. It says to use zero-extension.
1505 If TARGET is nonzero, the value
1506 is generated there, if it is convenient to do so.
1507 In all cases an rtx is returned for the locus of the value;
1508 this may or may not be TARGET. */
1511 expand_binop (enum machine_mode mode
, optab binoptab
, rtx op0
, rtx op1
,
1512 rtx target
, int unsignedp
, enum optab_methods methods
)
1514 enum optab_methods next_methods
1515 = (methods
== OPTAB_LIB
|| methods
== OPTAB_LIB_WIDEN
1516 ? OPTAB_WIDEN
: methods
);
1517 enum mode_class mclass
;
1518 enum machine_mode wider_mode
;
1521 rtx entry_last
= get_last_insn ();
1524 mclass
= GET_MODE_CLASS (mode
);
1526 /* If subtracting an integer constant, convert this into an addition of
1527 the negated constant. */
1529 if (binoptab
== sub_optab
&& CONST_INT_P (op1
))
1531 op1
= negate_rtx (mode
, op1
);
1532 binoptab
= add_optab
;
1535 /* Record where to delete back to if we backtrack. */
1536 last
= get_last_insn ();
1538 /* If we can do it with a three-operand insn, do so. */
1540 if (methods
!= OPTAB_MUST_WIDEN
1541 && find_widening_optab_handler (binoptab
, mode
,
1542 widened_mode (mode
, op0
, op1
), 1)
1543 != CODE_FOR_nothing
)
1545 temp
= expand_binop_directly (mode
, binoptab
, op0
, op1
, target
,
1546 unsignedp
, methods
, last
);
1551 /* If we were trying to rotate, and that didn't work, try rotating
1552 the other direction before falling back to shifts and bitwise-or. */
1553 if (((binoptab
== rotl_optab
1554 && optab_handler (rotr_optab
, mode
) != CODE_FOR_nothing
)
1555 || (binoptab
== rotr_optab
1556 && optab_handler (rotl_optab
, mode
) != CODE_FOR_nothing
))
1557 && mclass
== MODE_INT
)
1559 optab otheroptab
= (binoptab
== rotl_optab
? rotr_optab
: rotl_optab
);
1561 unsigned int bits
= GET_MODE_PRECISION (mode
);
1563 if (CONST_INT_P (op1
))
1564 newop1
= GEN_INT (bits
- INTVAL (op1
));
1565 else if (targetm
.shift_truncation_mask (mode
) == bits
- 1)
1566 newop1
= negate_rtx (GET_MODE (op1
), op1
);
1568 newop1
= expand_binop (GET_MODE (op1
), sub_optab
,
1569 gen_int_mode (bits
, GET_MODE (op1
)), op1
,
1570 NULL_RTX
, unsignedp
, OPTAB_DIRECT
);
1572 temp
= expand_binop_directly (mode
, otheroptab
, op0
, newop1
,
1573 target
, unsignedp
, methods
, last
);
1578 /* If this is a multiply, see if we can do a widening operation that
1579 takes operands of this mode and makes a wider mode. */
1581 if (binoptab
== smul_optab
1582 && GET_MODE_2XWIDER_MODE (mode
) != VOIDmode
1583 && (widening_optab_handler ((unsignedp
? umul_widen_optab
1584 : smul_widen_optab
),
1585 GET_MODE_2XWIDER_MODE (mode
), mode
)
1586 != CODE_FOR_nothing
))
1588 temp
= expand_binop (GET_MODE_2XWIDER_MODE (mode
),
1589 unsignedp
? umul_widen_optab
: smul_widen_optab
,
1590 op0
, op1
, NULL_RTX
, unsignedp
, OPTAB_DIRECT
);
1594 if (GET_MODE_CLASS (mode
) == MODE_INT
1595 && TRULY_NOOP_TRUNCATION_MODES_P (mode
, GET_MODE (temp
)))
1596 return gen_lowpart (mode
, temp
);
1598 return convert_to_mode (mode
, temp
, unsignedp
);
1602 /* If this is a vector shift by a scalar, see if we can do a vector
1603 shift by a vector. If so, broadcast the scalar into a vector. */
1604 if (mclass
== MODE_VECTOR_INT
)
1606 optab otheroptab
= unknown_optab
;
1608 if (binoptab
== ashl_optab
)
1609 otheroptab
= vashl_optab
;
1610 else if (binoptab
== ashr_optab
)
1611 otheroptab
= vashr_optab
;
1612 else if (binoptab
== lshr_optab
)
1613 otheroptab
= vlshr_optab
;
1614 else if (binoptab
== rotl_optab
)
1615 otheroptab
= vrotl_optab
;
1616 else if (binoptab
== rotr_optab
)
1617 otheroptab
= vrotr_optab
;
1619 if (otheroptab
&& optab_handler (otheroptab
, mode
) != CODE_FOR_nothing
)
1621 rtx vop1
= expand_vector_broadcast (mode
, op1
);
1624 temp
= expand_binop_directly (mode
, otheroptab
, op0
, vop1
,
1625 target
, unsignedp
, methods
, last
);
1632 /* Look for a wider mode of the same class for which we think we
1633 can open-code the operation. Check for a widening multiply at the
1634 wider mode as well. */
1636 if (CLASS_HAS_WIDER_MODES_P (mclass
)
1637 && methods
!= OPTAB_DIRECT
&& methods
!= OPTAB_LIB
)
1638 for (wider_mode
= GET_MODE_WIDER_MODE (mode
);
1639 wider_mode
!= VOIDmode
;
1640 wider_mode
= GET_MODE_WIDER_MODE (wider_mode
))
1642 if (optab_handler (binoptab
, wider_mode
) != CODE_FOR_nothing
1643 || (binoptab
== smul_optab
1644 && GET_MODE_WIDER_MODE (wider_mode
) != VOIDmode
1645 && (find_widening_optab_handler ((unsignedp
1647 : smul_widen_optab
),
1648 GET_MODE_WIDER_MODE (wider_mode
),
1650 != CODE_FOR_nothing
)))
1652 rtx xop0
= op0
, xop1
= op1
;
1655 /* For certain integer operations, we need not actually extend
1656 the narrow operands, as long as we will truncate
1657 the results to the same narrowness. */
1659 if ((binoptab
== ior_optab
|| binoptab
== and_optab
1660 || binoptab
== xor_optab
1661 || binoptab
== add_optab
|| binoptab
== sub_optab
1662 || binoptab
== smul_optab
|| binoptab
== ashl_optab
)
1663 && mclass
== MODE_INT
)
1666 xop0
= avoid_expensive_constant (mode
, binoptab
, 0,
1668 if (binoptab
!= ashl_optab
)
1669 xop1
= avoid_expensive_constant (mode
, binoptab
, 1,
1673 xop0
= widen_operand (xop0
, wider_mode
, mode
, unsignedp
, no_extend
);
1675 /* The second operand of a shift must always be extended. */
1676 xop1
= widen_operand (xop1
, wider_mode
, mode
, unsignedp
,
1677 no_extend
&& binoptab
!= ashl_optab
);
1679 temp
= expand_binop (wider_mode
, binoptab
, xop0
, xop1
, NULL_RTX
,
1680 unsignedp
, OPTAB_DIRECT
);
1683 if (mclass
!= MODE_INT
1684 || !TRULY_NOOP_TRUNCATION_MODES_P (mode
, wider_mode
))
1687 target
= gen_reg_rtx (mode
);
1688 convert_move (target
, temp
, 0);
1692 return gen_lowpart (mode
, temp
);
1695 delete_insns_since (last
);
1699 /* If operation is commutative,
1700 try to make the first operand a register.
1701 Even better, try to make it the same as the target.
1702 Also try to make the last operand a constant. */
1703 if (commutative_optab_p (binoptab
)
1704 && swap_commutative_operands_with_target (target
, op0
, op1
))
1711 /* These can be done a word at a time. */
1712 if ((binoptab
== and_optab
|| binoptab
== ior_optab
|| binoptab
== xor_optab
)
1713 && mclass
== MODE_INT
1714 && GET_MODE_SIZE (mode
) > UNITS_PER_WORD
1715 && optab_handler (binoptab
, word_mode
) != CODE_FOR_nothing
)
1720 /* If TARGET is the same as one of the operands, the REG_EQUAL note
1721 won't be accurate, so use a new target. */
1725 || !valid_multiword_target_p (target
))
1726 target
= gen_reg_rtx (mode
);
1730 /* Do the actual arithmetic. */
1731 for (i
= 0; i
< GET_MODE_BITSIZE (mode
) / BITS_PER_WORD
; i
++)
1733 rtx target_piece
= operand_subword (target
, i
, 1, mode
);
1734 rtx x
= expand_binop (word_mode
, binoptab
,
1735 operand_subword_force (op0
, i
, mode
),
1736 operand_subword_force (op1
, i
, mode
),
1737 target_piece
, unsignedp
, next_methods
);
1742 if (target_piece
!= x
)
1743 emit_move_insn (target_piece
, x
);
1746 insns
= get_insns ();
1749 if (i
== GET_MODE_BITSIZE (mode
) / BITS_PER_WORD
)
1756 /* Synthesize double word shifts from single word shifts. */
1757 if ((binoptab
== lshr_optab
|| binoptab
== ashl_optab
1758 || binoptab
== ashr_optab
)
1759 && mclass
== MODE_INT
1760 && (CONST_INT_P (op1
) || optimize_insn_for_speed_p ())
1761 && GET_MODE_SIZE (mode
) == 2 * UNITS_PER_WORD
1762 && GET_MODE_PRECISION (mode
) == GET_MODE_BITSIZE (mode
)
1763 && optab_handler (binoptab
, word_mode
) != CODE_FOR_nothing
1764 && optab_handler (ashl_optab
, word_mode
) != CODE_FOR_nothing
1765 && optab_handler (lshr_optab
, word_mode
) != CODE_FOR_nothing
)
1767 unsigned HOST_WIDE_INT shift_mask
, double_shift_mask
;
1768 enum machine_mode op1_mode
;
1770 double_shift_mask
= targetm
.shift_truncation_mask (mode
);
1771 shift_mask
= targetm
.shift_truncation_mask (word_mode
);
1772 op1_mode
= GET_MODE (op1
) != VOIDmode
? GET_MODE (op1
) : word_mode
;
1774 /* Apply the truncation to constant shifts. */
1775 if (double_shift_mask
> 0 && CONST_INT_P (op1
))
1776 op1
= GEN_INT (INTVAL (op1
) & double_shift_mask
);
1778 if (op1
== CONST0_RTX (op1_mode
))
1781 /* Make sure that this is a combination that expand_doubleword_shift
1782 can handle. See the comments there for details. */
1783 if (double_shift_mask
== 0
1784 || (shift_mask
== BITS_PER_WORD
- 1
1785 && double_shift_mask
== BITS_PER_WORD
* 2 - 1))
1788 rtx into_target
, outof_target
;
1789 rtx into_input
, outof_input
;
1790 int left_shift
, outof_word
;
1792 /* If TARGET is the same as one of the operands, the REG_EQUAL note
1793 won't be accurate, so use a new target. */
1797 || !valid_multiword_target_p (target
))
1798 target
= gen_reg_rtx (mode
);
1802 /* OUTOF_* is the word we are shifting bits away from, and
1803 INTO_* is the word that we are shifting bits towards, thus
1804 they differ depending on the direction of the shift and
1805 WORDS_BIG_ENDIAN. */
1807 left_shift
= binoptab
== ashl_optab
;
1808 outof_word
= left_shift
^ ! WORDS_BIG_ENDIAN
;
1810 outof_target
= operand_subword (target
, outof_word
, 1, mode
);
1811 into_target
= operand_subword (target
, 1 - outof_word
, 1, mode
);
1813 outof_input
= operand_subword_force (op0
, outof_word
, mode
);
1814 into_input
= operand_subword_force (op0
, 1 - outof_word
, mode
);
1816 if (expand_doubleword_shift (op1_mode
, binoptab
,
1817 outof_input
, into_input
, op1
,
1818 outof_target
, into_target
,
1819 unsignedp
, next_methods
, shift_mask
))
1821 insns
= get_insns ();
1831 /* Synthesize double word rotates from single word shifts. */
1832 if ((binoptab
== rotl_optab
|| binoptab
== rotr_optab
)
1833 && mclass
== MODE_INT
1834 && CONST_INT_P (op1
)
1835 && GET_MODE_PRECISION (mode
) == 2 * BITS_PER_WORD
1836 && optab_handler (ashl_optab
, word_mode
) != CODE_FOR_nothing
1837 && optab_handler (lshr_optab
, word_mode
) != CODE_FOR_nothing
)
1840 rtx into_target
, outof_target
;
1841 rtx into_input
, outof_input
;
1843 int shift_count
, left_shift
, outof_word
;
1845 /* If TARGET is the same as one of the operands, the REG_EQUAL note
1846 won't be accurate, so use a new target. Do this also if target is not
1847 a REG, first because having a register instead may open optimization
1848 opportunities, and second because if target and op0 happen to be MEMs
1849 designating the same location, we would risk clobbering it too early
1850 in the code sequence we generate below. */
1855 || !valid_multiword_target_p (target
))
1856 target
= gen_reg_rtx (mode
);
1860 shift_count
= INTVAL (op1
);
1862 /* OUTOF_* is the word we are shifting bits away from, and
1863 INTO_* is the word that we are shifting bits towards, thus
1864 they differ depending on the direction of the shift and
1865 WORDS_BIG_ENDIAN. */
1867 left_shift
= (binoptab
== rotl_optab
);
1868 outof_word
= left_shift
^ ! WORDS_BIG_ENDIAN
;
1870 outof_target
= operand_subword (target
, outof_word
, 1, mode
);
1871 into_target
= operand_subword (target
, 1 - outof_word
, 1, mode
);
1873 outof_input
= operand_subword_force (op0
, outof_word
, mode
);
1874 into_input
= operand_subword_force (op0
, 1 - outof_word
, mode
);
1876 if (shift_count
== BITS_PER_WORD
)
1878 /* This is just a word swap. */
1879 emit_move_insn (outof_target
, into_input
);
1880 emit_move_insn (into_target
, outof_input
);
1885 rtx into_temp1
, into_temp2
, outof_temp1
, outof_temp2
;
1886 rtx first_shift_count
, second_shift_count
;
1887 optab reverse_unsigned_shift
, unsigned_shift
;
1889 reverse_unsigned_shift
= (left_shift
^ (shift_count
< BITS_PER_WORD
)
1890 ? lshr_optab
: ashl_optab
);
1892 unsigned_shift
= (left_shift
^ (shift_count
< BITS_PER_WORD
)
1893 ? ashl_optab
: lshr_optab
);
1895 if (shift_count
> BITS_PER_WORD
)
1897 first_shift_count
= GEN_INT (shift_count
- BITS_PER_WORD
);
1898 second_shift_count
= GEN_INT (2 * BITS_PER_WORD
- shift_count
);
1902 first_shift_count
= GEN_INT (BITS_PER_WORD
- shift_count
);
1903 second_shift_count
= GEN_INT (shift_count
);
1906 into_temp1
= expand_binop (word_mode
, unsigned_shift
,
1907 outof_input
, first_shift_count
,
1908 NULL_RTX
, unsignedp
, next_methods
);
1909 into_temp2
= expand_binop (word_mode
, reverse_unsigned_shift
,
1910 into_input
, second_shift_count
,
1911 NULL_RTX
, unsignedp
, next_methods
);
1913 if (into_temp1
!= 0 && into_temp2
!= 0)
1914 inter
= expand_binop (word_mode
, ior_optab
, into_temp1
, into_temp2
,
1915 into_target
, unsignedp
, next_methods
);
1919 if (inter
!= 0 && inter
!= into_target
)
1920 emit_move_insn (into_target
, inter
);
1922 outof_temp1
= expand_binop (word_mode
, unsigned_shift
,
1923 into_input
, first_shift_count
,
1924 NULL_RTX
, unsignedp
, next_methods
);
1925 outof_temp2
= expand_binop (word_mode
, reverse_unsigned_shift
,
1926 outof_input
, second_shift_count
,
1927 NULL_RTX
, unsignedp
, next_methods
);
1929 if (inter
!= 0 && outof_temp1
!= 0 && outof_temp2
!= 0)
1930 inter
= expand_binop (word_mode
, ior_optab
,
1931 outof_temp1
, outof_temp2
,
1932 outof_target
, unsignedp
, next_methods
);
1934 if (inter
!= 0 && inter
!= outof_target
)
1935 emit_move_insn (outof_target
, inter
);
1938 insns
= get_insns ();
1948 /* These can be done a word at a time by propagating carries. */
1949 if ((binoptab
== add_optab
|| binoptab
== sub_optab
)
1950 && mclass
== MODE_INT
1951 && GET_MODE_SIZE (mode
) >= 2 * UNITS_PER_WORD
1952 && optab_handler (binoptab
, word_mode
) != CODE_FOR_nothing
)
1955 optab otheroptab
= binoptab
== add_optab
? sub_optab
: add_optab
;
1956 const unsigned int nwords
= GET_MODE_BITSIZE (mode
) / BITS_PER_WORD
;
1957 rtx carry_in
= NULL_RTX
, carry_out
= NULL_RTX
;
1958 rtx xop0
, xop1
, xtarget
;
1960 /* We can handle either a 1 or -1 value for the carry. If STORE_FLAG
1961 value is one of those, use it. Otherwise, use 1 since it is the
1962 one easiest to get. */
1963 #if STORE_FLAG_VALUE == 1 || STORE_FLAG_VALUE == -1
1964 int normalizep
= STORE_FLAG_VALUE
;
1969 /* Prepare the operands. */
1970 xop0
= force_reg (mode
, op0
);
1971 xop1
= force_reg (mode
, op1
);
1973 xtarget
= gen_reg_rtx (mode
);
1975 if (target
== 0 || !REG_P (target
) || !valid_multiword_target_p (target
))
1978 /* Indicate for flow that the entire target reg is being set. */
1980 emit_clobber (xtarget
);
1982 /* Do the actual arithmetic. */
1983 for (i
= 0; i
< nwords
; i
++)
1985 int index
= (WORDS_BIG_ENDIAN
? nwords
- i
- 1 : i
);
1986 rtx target_piece
= operand_subword (xtarget
, index
, 1, mode
);
1987 rtx op0_piece
= operand_subword_force (xop0
, index
, mode
);
1988 rtx op1_piece
= operand_subword_force (xop1
, index
, mode
);
1991 /* Main add/subtract of the input operands. */
1992 x
= expand_binop (word_mode
, binoptab
,
1993 op0_piece
, op1_piece
,
1994 target_piece
, unsignedp
, next_methods
);
2000 /* Store carry from main add/subtract. */
2001 carry_out
= gen_reg_rtx (word_mode
);
2002 carry_out
= emit_store_flag_force (carry_out
,
2003 (binoptab
== add_optab
2006 word_mode
, 1, normalizep
);
2013 /* Add/subtract previous carry to main result. */
2014 newx
= expand_binop (word_mode
,
2015 normalizep
== 1 ? binoptab
: otheroptab
,
2017 NULL_RTX
, 1, next_methods
);
2021 /* Get out carry from adding/subtracting carry in. */
2022 rtx carry_tmp
= gen_reg_rtx (word_mode
);
2023 carry_tmp
= emit_store_flag_force (carry_tmp
,
2024 (binoptab
== add_optab
2027 word_mode
, 1, normalizep
);
2029 /* Logical-ior the two poss. carry together. */
2030 carry_out
= expand_binop (word_mode
, ior_optab
,
2031 carry_out
, carry_tmp
,
2032 carry_out
, 0, next_methods
);
2036 emit_move_insn (target_piece
, newx
);
2040 if (x
!= target_piece
)
2041 emit_move_insn (target_piece
, x
);
2044 carry_in
= carry_out
;
2047 if (i
== GET_MODE_BITSIZE (mode
) / (unsigned) BITS_PER_WORD
)
2049 if (optab_handler (mov_optab
, mode
) != CODE_FOR_nothing
2050 || ! rtx_equal_p (target
, xtarget
))
2052 rtx temp
= emit_move_insn (target
, xtarget
);
2054 set_dst_reg_note (temp
, REG_EQUAL
,
2055 gen_rtx_fmt_ee (optab_to_code (binoptab
),
2056 mode
, copy_rtx (xop0
),
2067 delete_insns_since (last
);
2070 /* Attempt to synthesize double word multiplies using a sequence of word
2071 mode multiplications. We first attempt to generate a sequence using a
2072 more efficient unsigned widening multiply, and if that fails we then
2073 try using a signed widening multiply. */
2075 if (binoptab
== smul_optab
2076 && mclass
== MODE_INT
2077 && GET_MODE_SIZE (mode
) == 2 * UNITS_PER_WORD
2078 && optab_handler (smul_optab
, word_mode
) != CODE_FOR_nothing
2079 && optab_handler (add_optab
, word_mode
) != CODE_FOR_nothing
)
2081 rtx product
= NULL_RTX
;
2082 if (widening_optab_handler (umul_widen_optab
, mode
, word_mode
)
2083 != CODE_FOR_nothing
)
2085 product
= expand_doubleword_mult (mode
, op0
, op1
, target
,
2088 delete_insns_since (last
);
2091 if (product
== NULL_RTX
2092 && widening_optab_handler (smul_widen_optab
, mode
, word_mode
)
2093 != CODE_FOR_nothing
)
2095 product
= expand_doubleword_mult (mode
, op0
, op1
, target
,
2098 delete_insns_since (last
);
2101 if (product
!= NULL_RTX
)
2103 if (optab_handler (mov_optab
, mode
) != CODE_FOR_nothing
)
2105 temp
= emit_move_insn (target
? target
: product
, product
);
2106 set_dst_reg_note (temp
,
2108 gen_rtx_fmt_ee (MULT
, mode
,
2111 target
? target
: product
);
2117 /* It can't be open-coded in this mode.
2118 Use a library call if one is available and caller says that's ok. */
2120 libfunc
= optab_libfunc (binoptab
, mode
);
2122 && (methods
== OPTAB_LIB
|| methods
== OPTAB_LIB_WIDEN
))
2126 enum machine_mode op1_mode
= mode
;
2131 if (shift_optab_p (binoptab
))
2133 op1_mode
= targetm
.libgcc_shift_count_mode ();
2134 /* Specify unsigned here,
2135 since negative shift counts are meaningless. */
2136 op1x
= convert_to_mode (op1_mode
, op1
, 1);
2139 if (GET_MODE (op0
) != VOIDmode
2140 && GET_MODE (op0
) != mode
)
2141 op0
= convert_to_mode (mode
, op0
, unsignedp
);
2143 /* Pass 1 for NO_QUEUE so we don't lose any increments
2144 if the libcall is cse'd or moved. */
2145 value
= emit_library_call_value (libfunc
,
2146 NULL_RTX
, LCT_CONST
, mode
, 2,
2147 op0
, mode
, op1x
, op1_mode
);
2149 insns
= get_insns ();
2152 target
= gen_reg_rtx (mode
);
2153 emit_libcall_block_1 (insns
, target
, value
,
2154 gen_rtx_fmt_ee (optab_to_code (binoptab
),
2156 trapv_binoptab_p (binoptab
));
2161 delete_insns_since (last
);
2163 /* It can't be done in this mode. Can we do it in a wider mode? */
2165 if (! (methods
== OPTAB_WIDEN
|| methods
== OPTAB_LIB_WIDEN
2166 || methods
== OPTAB_MUST_WIDEN
))
2168 /* Caller says, don't even try. */
2169 delete_insns_since (entry_last
);
2173 /* Compute the value of METHODS to pass to recursive calls.
2174 Don't allow widening to be tried recursively. */
2176 methods
= (methods
== OPTAB_LIB_WIDEN
? OPTAB_LIB
: OPTAB_DIRECT
);
2178 /* Look for a wider mode of the same class for which it appears we can do
2181 if (CLASS_HAS_WIDER_MODES_P (mclass
))
2183 for (wider_mode
= GET_MODE_WIDER_MODE (mode
);
2184 wider_mode
!= VOIDmode
;
2185 wider_mode
= GET_MODE_WIDER_MODE (wider_mode
))
2187 if (find_widening_optab_handler (binoptab
, wider_mode
, mode
, 1)
2189 || (methods
== OPTAB_LIB
2190 && optab_libfunc (binoptab
, wider_mode
)))
2192 rtx xop0
= op0
, xop1
= op1
;
2195 /* For certain integer operations, we need not actually extend
2196 the narrow operands, as long as we will truncate
2197 the results to the same narrowness. */
2199 if ((binoptab
== ior_optab
|| binoptab
== and_optab
2200 || binoptab
== xor_optab
2201 || binoptab
== add_optab
|| binoptab
== sub_optab
2202 || binoptab
== smul_optab
|| binoptab
== ashl_optab
)
2203 && mclass
== MODE_INT
)
2206 xop0
= widen_operand (xop0
, wider_mode
, mode
,
2207 unsignedp
, no_extend
);
2209 /* The second operand of a shift must always be extended. */
2210 xop1
= widen_operand (xop1
, wider_mode
, mode
, unsignedp
,
2211 no_extend
&& binoptab
!= ashl_optab
);
2213 temp
= expand_binop (wider_mode
, binoptab
, xop0
, xop1
, NULL_RTX
,
2214 unsignedp
, methods
);
2217 if (mclass
!= MODE_INT
2218 || !TRULY_NOOP_TRUNCATION_MODES_P (mode
, wider_mode
))
2221 target
= gen_reg_rtx (mode
);
2222 convert_move (target
, temp
, 0);
2226 return gen_lowpart (mode
, temp
);
2229 delete_insns_since (last
);
2234 delete_insns_since (entry_last
);
2238 /* Expand a binary operator which has both signed and unsigned forms.
2239 UOPTAB is the optab for unsigned operations, and SOPTAB is for
2242 If we widen unsigned operands, we may use a signed wider operation instead
2243 of an unsigned wider operation, since the result would be the same. */
2246 sign_expand_binop (enum machine_mode mode
, optab uoptab
, optab soptab
,
2247 rtx op0
, rtx op1
, rtx target
, int unsignedp
,
2248 enum optab_methods methods
)
2251 optab direct_optab
= unsignedp
? uoptab
: soptab
;
2254 /* Do it without widening, if possible. */
2255 temp
= expand_binop (mode
, direct_optab
, op0
, op1
, target
,
2256 unsignedp
, OPTAB_DIRECT
);
2257 if (temp
|| methods
== OPTAB_DIRECT
)
2260 /* Try widening to a signed int. Disable any direct use of any
2261 signed insn in the current mode. */
2262 save_enable
= swap_optab_enable (soptab
, mode
, false);
2264 temp
= expand_binop (mode
, soptab
, op0
, op1
, target
,
2265 unsignedp
, OPTAB_WIDEN
);
2267 /* For unsigned operands, try widening to an unsigned int. */
2268 if (!temp
&& unsignedp
)
2269 temp
= expand_binop (mode
, uoptab
, op0
, op1
, target
,
2270 unsignedp
, OPTAB_WIDEN
);
2271 if (temp
|| methods
== OPTAB_WIDEN
)
2274 /* Use the right width libcall if that exists. */
2275 temp
= expand_binop (mode
, direct_optab
, op0
, op1
, target
,
2276 unsignedp
, OPTAB_LIB
);
2277 if (temp
|| methods
== OPTAB_LIB
)
2280 /* Must widen and use a libcall, use either signed or unsigned. */
2281 temp
= expand_binop (mode
, soptab
, op0
, op1
, target
,
2282 unsignedp
, methods
);
2283 if (!temp
&& unsignedp
)
2284 temp
= expand_binop (mode
, uoptab
, op0
, op1
, target
,
2285 unsignedp
, methods
);
2288 /* Undo the fiddling above. */
2290 swap_optab_enable (soptab
, mode
, true);
2294 /* Generate code to perform an operation specified by UNOPPTAB
2295 on operand OP0, with two results to TARG0 and TARG1.
2296 We assume that the order of the operands for the instruction
2297 is TARG0, TARG1, OP0.
2299 Either TARG0 or TARG1 may be zero, but what that means is that
2300 the result is not actually wanted. We will generate it into
2301 a dummy pseudo-reg and discard it. They may not both be zero.
2303 Returns 1 if this operation can be performed; 0 if not. */
2306 expand_twoval_unop (optab unoptab
, rtx op0
, rtx targ0
, rtx targ1
,
2309 enum machine_mode mode
= GET_MODE (targ0
? targ0
: targ1
);
2310 enum mode_class mclass
;
2311 enum machine_mode wider_mode
;
2312 rtx entry_last
= get_last_insn ();
2315 mclass
= GET_MODE_CLASS (mode
);
2318 targ0
= gen_reg_rtx (mode
);
2320 targ1
= gen_reg_rtx (mode
);
2322 /* Record where to go back to if we fail. */
2323 last
= get_last_insn ();
2325 if (optab_handler (unoptab
, mode
) != CODE_FOR_nothing
)
2327 struct expand_operand ops
[3];
2328 enum insn_code icode
= optab_handler (unoptab
, mode
);
2330 create_fixed_operand (&ops
[0], targ0
);
2331 create_fixed_operand (&ops
[1], targ1
);
2332 create_convert_operand_from (&ops
[2], op0
, mode
, unsignedp
);
2333 if (maybe_expand_insn (icode
, 3, ops
))
2337 /* It can't be done in this mode. Can we do it in a wider mode? */
2339 if (CLASS_HAS_WIDER_MODES_P (mclass
))
2341 for (wider_mode
= GET_MODE_WIDER_MODE (mode
);
2342 wider_mode
!= VOIDmode
;
2343 wider_mode
= GET_MODE_WIDER_MODE (wider_mode
))
2345 if (optab_handler (unoptab
, wider_mode
) != CODE_FOR_nothing
)
2347 rtx t0
= gen_reg_rtx (wider_mode
);
2348 rtx t1
= gen_reg_rtx (wider_mode
);
2349 rtx cop0
= convert_modes (wider_mode
, mode
, op0
, unsignedp
);
2351 if (expand_twoval_unop (unoptab
, cop0
, t0
, t1
, unsignedp
))
2353 convert_move (targ0
, t0
, unsignedp
);
2354 convert_move (targ1
, t1
, unsignedp
);
2358 delete_insns_since (last
);
2363 delete_insns_since (entry_last
);
2367 /* Generate code to perform an operation specified by BINOPTAB
2368 on operands OP0 and OP1, with two results to TARG1 and TARG2.
2369 We assume that the order of the operands for the instruction
2370 is TARG0, OP0, OP1, TARG1, which would fit a pattern like
2371 [(set TARG0 (operate OP0 OP1)) (set TARG1 (operate ...))].
2373 Either TARG0 or TARG1 may be zero, but what that means is that
2374 the result is not actually wanted. We will generate it into
2375 a dummy pseudo-reg and discard it. They may not both be zero.
2377 Returns 1 if this operation can be performed; 0 if not. */
2380 expand_twoval_binop (optab binoptab
, rtx op0
, rtx op1
, rtx targ0
, rtx targ1
,
2383 enum machine_mode mode
= GET_MODE (targ0
? targ0
: targ1
);
2384 enum mode_class mclass
;
2385 enum machine_mode wider_mode
;
2386 rtx entry_last
= get_last_insn ();
2389 mclass
= GET_MODE_CLASS (mode
);
2392 targ0
= gen_reg_rtx (mode
);
2394 targ1
= gen_reg_rtx (mode
);
2396 /* Record where to go back to if we fail. */
2397 last
= get_last_insn ();
2399 if (optab_handler (binoptab
, mode
) != CODE_FOR_nothing
)
2401 struct expand_operand ops
[4];
2402 enum insn_code icode
= optab_handler (binoptab
, mode
);
2403 enum machine_mode mode0
= insn_data
[icode
].operand
[1].mode
;
2404 enum machine_mode mode1
= insn_data
[icode
].operand
[2].mode
;
2405 rtx xop0
= op0
, xop1
= op1
;
2407 /* If we are optimizing, force expensive constants into a register. */
2408 xop0
= avoid_expensive_constant (mode0
, binoptab
, 0, xop0
, unsignedp
);
2409 xop1
= avoid_expensive_constant (mode1
, binoptab
, 1, xop1
, unsignedp
);
2411 create_fixed_operand (&ops
[0], targ0
);
2412 create_convert_operand_from (&ops
[1], op0
, mode
, unsignedp
);
2413 create_convert_operand_from (&ops
[2], op1
, mode
, unsignedp
);
2414 create_fixed_operand (&ops
[3], targ1
);
2415 if (maybe_expand_insn (icode
, 4, ops
))
2417 delete_insns_since (last
);
2420 /* It can't be done in this mode. Can we do it in a wider mode? */
2422 if (CLASS_HAS_WIDER_MODES_P (mclass
))
2424 for (wider_mode
= GET_MODE_WIDER_MODE (mode
);
2425 wider_mode
!= VOIDmode
;
2426 wider_mode
= GET_MODE_WIDER_MODE (wider_mode
))
2428 if (optab_handler (binoptab
, wider_mode
) != CODE_FOR_nothing
)
2430 rtx t0
= gen_reg_rtx (wider_mode
);
2431 rtx t1
= gen_reg_rtx (wider_mode
);
2432 rtx cop0
= convert_modes (wider_mode
, mode
, op0
, unsignedp
);
2433 rtx cop1
= convert_modes (wider_mode
, mode
, op1
, unsignedp
);
2435 if (expand_twoval_binop (binoptab
, cop0
, cop1
,
2438 convert_move (targ0
, t0
, unsignedp
);
2439 convert_move (targ1
, t1
, unsignedp
);
2443 delete_insns_since (last
);
2448 delete_insns_since (entry_last
);
2452 /* Expand the two-valued library call indicated by BINOPTAB, but
2453 preserve only one of the values. If TARG0 is non-NULL, the first
2454 value is placed into TARG0; otherwise the second value is placed
2455 into TARG1. Exactly one of TARG0 and TARG1 must be non-NULL. The
2456 value stored into TARG0 or TARG1 is equivalent to (CODE OP0 OP1).
2457 This routine assumes that the value returned by the library call is
2458 as if the return value was of an integral mode twice as wide as the
2459 mode of OP0. Returns 1 if the call was successful. */
2462 expand_twoval_binop_libfunc (optab binoptab
, rtx op0
, rtx op1
,
2463 rtx targ0
, rtx targ1
, enum rtx_code code
)
2465 enum machine_mode mode
;
2466 enum machine_mode libval_mode
;
2471 /* Exactly one of TARG0 or TARG1 should be non-NULL. */
2472 gcc_assert (!targ0
!= !targ1
);
2474 mode
= GET_MODE (op0
);
2475 libfunc
= optab_libfunc (binoptab
, mode
);
2479 /* The value returned by the library function will have twice as
2480 many bits as the nominal MODE. */
2481 libval_mode
= smallest_mode_for_size (2 * GET_MODE_BITSIZE (mode
),
2484 libval
= emit_library_call_value (libfunc
, NULL_RTX
, LCT_CONST
,
2488 /* Get the part of VAL containing the value that we want. */
2489 libval
= simplify_gen_subreg (mode
, libval
, libval_mode
,
2490 targ0
? 0 : GET_MODE_SIZE (mode
));
2491 insns
= get_insns ();
2493 /* Move the into the desired location. */
2494 emit_libcall_block (insns
, targ0
? targ0
: targ1
, libval
,
2495 gen_rtx_fmt_ee (code
, mode
, op0
, op1
));
2501 /* Wrapper around expand_unop which takes an rtx code to specify
2502 the operation to perform, not an optab pointer. All other
2503 arguments are the same. */
2505 expand_simple_unop (enum machine_mode mode
, enum rtx_code code
, rtx op0
,
2506 rtx target
, int unsignedp
)
2508 optab unop
= code_to_optab (code
);
2511 return expand_unop (mode
, unop
, op0
, target
, unsignedp
);
2517 (clz:wide (zero_extend:wide x)) - ((width wide) - (width narrow)).
2519 A similar operation can be used for clrsb. UNOPTAB says which operation
2520 we are trying to expand. */
2522 widen_leading (enum machine_mode mode
, rtx op0
, rtx target
, optab unoptab
)
2524 enum mode_class mclass
= GET_MODE_CLASS (mode
);
2525 if (CLASS_HAS_WIDER_MODES_P (mclass
))
2527 enum machine_mode wider_mode
;
2528 for (wider_mode
= GET_MODE_WIDER_MODE (mode
);
2529 wider_mode
!= VOIDmode
;
2530 wider_mode
= GET_MODE_WIDER_MODE (wider_mode
))
2532 if (optab_handler (unoptab
, wider_mode
) != CODE_FOR_nothing
)
2534 rtx xop0
, temp
, last
;
2536 last
= get_last_insn ();
2539 target
= gen_reg_rtx (mode
);
2540 xop0
= widen_operand (op0
, wider_mode
, mode
,
2541 unoptab
!= clrsb_optab
, false);
2542 temp
= expand_unop (wider_mode
, unoptab
, xop0
, NULL_RTX
,
2543 unoptab
!= clrsb_optab
);
2546 (wider_mode
, sub_optab
, temp
,
2547 gen_int_mode (GET_MODE_PRECISION (wider_mode
)
2548 - GET_MODE_PRECISION (mode
),
2550 target
, true, OPTAB_DIRECT
);
2552 delete_insns_since (last
);
2561 /* Try calculating clz of a double-word quantity as two clz's of word-sized
2562 quantities, choosing which based on whether the high word is nonzero. */
2564 expand_doubleword_clz (enum machine_mode mode
, rtx op0
, rtx target
)
2566 rtx xop0
= force_reg (mode
, op0
);
2567 rtx subhi
= gen_highpart (word_mode
, xop0
);
2568 rtx sublo
= gen_lowpart (word_mode
, xop0
);
2569 rtx hi0_label
= gen_label_rtx ();
2570 rtx after_label
= gen_label_rtx ();
2571 rtx seq
, temp
, result
;
2573 /* If we were not given a target, use a word_mode register, not a
2574 'mode' register. The result will fit, and nobody is expecting
2575 anything bigger (the return type of __builtin_clz* is int). */
2577 target
= gen_reg_rtx (word_mode
);
2579 /* In any case, write to a word_mode scratch in both branches of the
2580 conditional, so we can ensure there is a single move insn setting
2581 'target' to tag a REG_EQUAL note on. */
2582 result
= gen_reg_rtx (word_mode
);
2586 /* If the high word is not equal to zero,
2587 then clz of the full value is clz of the high word. */
2588 emit_cmp_and_jump_insns (subhi
, CONST0_RTX (word_mode
), EQ
, 0,
2589 word_mode
, true, hi0_label
);
2591 temp
= expand_unop_direct (word_mode
, clz_optab
, subhi
, result
, true);
2596 convert_move (result
, temp
, true);
2598 emit_jump_insn (gen_jump (after_label
));
2601 /* Else clz of the full value is clz of the low word plus the number
2602 of bits in the high word. */
2603 emit_label (hi0_label
);
2605 temp
= expand_unop_direct (word_mode
, clz_optab
, sublo
, 0, true);
2608 temp
= expand_binop (word_mode
, add_optab
, temp
,
2609 gen_int_mode (GET_MODE_BITSIZE (word_mode
), word_mode
),
2610 result
, true, OPTAB_DIRECT
);
2614 convert_move (result
, temp
, true);
2616 emit_label (after_label
);
2617 convert_move (target
, result
, true);
2622 add_equal_note (seq
, target
, CLZ
, xop0
, 0);
2634 (lshiftrt:wide (bswap:wide x) ((width wide) - (width narrow))). */
2636 widen_bswap (enum machine_mode mode
, rtx op0
, rtx target
)
2638 enum mode_class mclass
= GET_MODE_CLASS (mode
);
2639 enum machine_mode wider_mode
;
2642 if (!CLASS_HAS_WIDER_MODES_P (mclass
))
2645 for (wider_mode
= GET_MODE_WIDER_MODE (mode
);
2646 wider_mode
!= VOIDmode
;
2647 wider_mode
= GET_MODE_WIDER_MODE (wider_mode
))
2648 if (optab_handler (bswap_optab
, wider_mode
) != CODE_FOR_nothing
)
2653 last
= get_last_insn ();
2655 x
= widen_operand (op0
, wider_mode
, mode
, true, true);
2656 x
= expand_unop (wider_mode
, bswap_optab
, x
, NULL_RTX
, true);
2658 gcc_assert (GET_MODE_PRECISION (wider_mode
) == GET_MODE_BITSIZE (wider_mode
)
2659 && GET_MODE_PRECISION (mode
) == GET_MODE_BITSIZE (mode
));
2661 x
= expand_shift (RSHIFT_EXPR
, wider_mode
, x
,
2662 GET_MODE_BITSIZE (wider_mode
)
2663 - GET_MODE_BITSIZE (mode
),
2669 target
= gen_reg_rtx (mode
);
2670 emit_move_insn (target
, gen_lowpart (mode
, x
));
2673 delete_insns_since (last
);
2678 /* Try calculating bswap as two bswaps of two word-sized operands. */
2681 expand_doubleword_bswap (enum machine_mode mode
, rtx op
, rtx target
)
2685 t1
= expand_unop (word_mode
, bswap_optab
,
2686 operand_subword_force (op
, 0, mode
), NULL_RTX
, true);
2687 t0
= expand_unop (word_mode
, bswap_optab
,
2688 operand_subword_force (op
, 1, mode
), NULL_RTX
, true);
2690 if (target
== 0 || !valid_multiword_target_p (target
))
2691 target
= gen_reg_rtx (mode
);
2693 emit_clobber (target
);
2694 emit_move_insn (operand_subword (target
, 0, 1, mode
), t0
);
2695 emit_move_insn (operand_subword (target
, 1, 1, mode
), t1
);
2700 /* Try calculating (parity x) as (and (popcount x) 1), where
2701 popcount can also be done in a wider mode. */
2703 expand_parity (enum machine_mode mode
, rtx op0
, rtx target
)
2705 enum mode_class mclass
= GET_MODE_CLASS (mode
);
2706 if (CLASS_HAS_WIDER_MODES_P (mclass
))
2708 enum machine_mode wider_mode
;
2709 for (wider_mode
= mode
; wider_mode
!= VOIDmode
;
2710 wider_mode
= GET_MODE_WIDER_MODE (wider_mode
))
2712 if (optab_handler (popcount_optab
, wider_mode
) != CODE_FOR_nothing
)
2714 rtx xop0
, temp
, last
;
2716 last
= get_last_insn ();
2719 target
= gen_reg_rtx (mode
);
2720 xop0
= widen_operand (op0
, wider_mode
, mode
, true, false);
2721 temp
= expand_unop (wider_mode
, popcount_optab
, xop0
, NULL_RTX
,
2724 temp
= expand_binop (wider_mode
, and_optab
, temp
, const1_rtx
,
2725 target
, true, OPTAB_DIRECT
);
2727 delete_insns_since (last
);
2736 /* Try calculating ctz(x) as K - clz(x & -x) ,
2737 where K is GET_MODE_PRECISION(mode) - 1.
2739 Both __builtin_ctz and __builtin_clz are undefined at zero, so we
2740 don't have to worry about what the hardware does in that case. (If
2741 the clz instruction produces the usual value at 0, which is K, the
2742 result of this code sequence will be -1; expand_ffs, below, relies
2743 on this. It might be nice to have it be K instead, for consistency
2744 with the (very few) processors that provide a ctz with a defined
2745 value, but that would take one more instruction, and it would be
2746 less convenient for expand_ffs anyway. */
2749 expand_ctz (enum machine_mode mode
, rtx op0
, rtx target
)
2753 if (optab_handler (clz_optab
, mode
) == CODE_FOR_nothing
)
2758 temp
= expand_unop_direct (mode
, neg_optab
, op0
, NULL_RTX
, true);
2760 temp
= expand_binop (mode
, and_optab
, op0
, temp
, NULL_RTX
,
2761 true, OPTAB_DIRECT
);
2763 temp
= expand_unop_direct (mode
, clz_optab
, temp
, NULL_RTX
, true);
2765 temp
= expand_binop (mode
, sub_optab
,
2766 gen_int_mode (GET_MODE_PRECISION (mode
) - 1, mode
),
2768 true, OPTAB_DIRECT
);
2778 add_equal_note (seq
, temp
, CTZ
, op0
, 0);
2784 /* Try calculating ffs(x) using ctz(x) if we have that instruction, or
2785 else with the sequence used by expand_clz.
2787 The ffs builtin promises to return zero for a zero value and ctz/clz
2788 may have an undefined value in that case. If they do not give us a
2789 convenient value, we have to generate a test and branch. */
2791 expand_ffs (enum machine_mode mode
, rtx op0
, rtx target
)
2793 HOST_WIDE_INT val
= 0;
2794 bool defined_at_zero
= false;
2797 if (optab_handler (ctz_optab
, mode
) != CODE_FOR_nothing
)
2801 temp
= expand_unop_direct (mode
, ctz_optab
, op0
, 0, true);
2805 defined_at_zero
= (CTZ_DEFINED_VALUE_AT_ZERO (mode
, val
) == 2);
2807 else if (optab_handler (clz_optab
, mode
) != CODE_FOR_nothing
)
2810 temp
= expand_ctz (mode
, op0
, 0);
2814 if (CLZ_DEFINED_VALUE_AT_ZERO (mode
, val
) == 2)
2816 defined_at_zero
= true;
2817 val
= (GET_MODE_PRECISION (mode
) - 1) - val
;
2823 if (defined_at_zero
&& val
== -1)
2824 /* No correction needed at zero. */;
2827 /* We don't try to do anything clever with the situation found
2828 on some processors (eg Alpha) where ctz(0:mode) ==
2829 bitsize(mode). If someone can think of a way to send N to -1
2830 and leave alone all values in the range 0..N-1 (where N is a
2831 power of two), cheaper than this test-and-branch, please add it.
2833 The test-and-branch is done after the operation itself, in case
2834 the operation sets condition codes that can be recycled for this.
2835 (This is true on i386, for instance.) */
2837 rtx nonzero_label
= gen_label_rtx ();
2838 emit_cmp_and_jump_insns (op0
, CONST0_RTX (mode
), NE
, 0,
2839 mode
, true, nonzero_label
);
2841 convert_move (temp
, GEN_INT (-1), false);
2842 emit_label (nonzero_label
);
2845 /* temp now has a value in the range -1..bitsize-1. ffs is supposed
2846 to produce a value in the range 0..bitsize. */
2847 temp
= expand_binop (mode
, add_optab
, temp
, gen_int_mode (1, mode
),
2848 target
, false, OPTAB_DIRECT
);
2855 add_equal_note (seq
, temp
, FFS
, op0
, 0);
2864 /* Extract the OMODE lowpart from VAL, which has IMODE. Under certain
2865 conditions, VAL may already be a SUBREG against which we cannot generate
2866 a further SUBREG. In this case, we expect forcing the value into a
2867 register will work around the situation. */
2870 lowpart_subreg_maybe_copy (enum machine_mode omode
, rtx val
,
2871 enum machine_mode imode
)
2874 ret
= lowpart_subreg (omode
, val
, imode
);
2877 val
= force_reg (imode
, val
);
2878 ret
= lowpart_subreg (omode
, val
, imode
);
2879 gcc_assert (ret
!= NULL
);
2884 /* Expand a floating point absolute value or negation operation via a
2885 logical operation on the sign bit. */
2888 expand_absneg_bit (enum rtx_code code
, enum machine_mode mode
,
2889 rtx op0
, rtx target
)
2891 const struct real_format
*fmt
;
2892 int bitpos
, word
, nwords
, i
;
2893 enum machine_mode imode
;
2896 /* The format has to have a simple sign bit. */
2897 fmt
= REAL_MODE_FORMAT (mode
);
2901 bitpos
= fmt
->signbit_rw
;
2905 /* Don't create negative zeros if the format doesn't support them. */
2906 if (code
== NEG
&& !fmt
->has_signed_zero
)
2909 if (GET_MODE_SIZE (mode
) <= UNITS_PER_WORD
)
2911 imode
= int_mode_for_mode (mode
);
2912 if (imode
== BLKmode
)
2921 if (FLOAT_WORDS_BIG_ENDIAN
)
2922 word
= (GET_MODE_BITSIZE (mode
) - bitpos
) / BITS_PER_WORD
;
2924 word
= bitpos
/ BITS_PER_WORD
;
2925 bitpos
= bitpos
% BITS_PER_WORD
;
2926 nwords
= (GET_MODE_BITSIZE (mode
) + BITS_PER_WORD
- 1) / BITS_PER_WORD
;
2929 wide_int mask
= wi::set_bit_in_zero (bitpos
, GET_MODE_PRECISION (imode
));
2935 || (nwords
> 1 && !valid_multiword_target_p (target
)))
2936 target
= gen_reg_rtx (mode
);
2942 for (i
= 0; i
< nwords
; ++i
)
2944 rtx targ_piece
= operand_subword (target
, i
, 1, mode
);
2945 rtx op0_piece
= operand_subword_force (op0
, i
, mode
);
2949 temp
= expand_binop (imode
, code
== ABS
? and_optab
: xor_optab
,
2951 immed_wide_int_const (mask
, imode
),
2952 targ_piece
, 1, OPTAB_LIB_WIDEN
);
2953 if (temp
!= targ_piece
)
2954 emit_move_insn (targ_piece
, temp
);
2957 emit_move_insn (targ_piece
, op0_piece
);
2960 insns
= get_insns ();
2967 temp
= expand_binop (imode
, code
== ABS
? and_optab
: xor_optab
,
2968 gen_lowpart (imode
, op0
),
2969 immed_wide_int_const (mask
, imode
),
2970 gen_lowpart (imode
, target
), 1, OPTAB_LIB_WIDEN
);
2971 target
= lowpart_subreg_maybe_copy (mode
, temp
, imode
);
2973 set_dst_reg_note (get_last_insn (), REG_EQUAL
,
2974 gen_rtx_fmt_e (code
, mode
, copy_rtx (op0
)),
2981 /* As expand_unop, but will fail rather than attempt the operation in a
2982 different mode or with a libcall. */
2984 expand_unop_direct (enum machine_mode mode
, optab unoptab
, rtx op0
, rtx target
,
2987 if (optab_handler (unoptab
, mode
) != CODE_FOR_nothing
)
2989 struct expand_operand ops
[2];
2990 enum insn_code icode
= optab_handler (unoptab
, mode
);
2991 rtx last
= get_last_insn ();
2994 create_output_operand (&ops
[0], target
, mode
);
2995 create_convert_operand_from (&ops
[1], op0
, mode
, unsignedp
);
2996 pat
= maybe_gen_insn (icode
, 2, ops
);
2999 if (INSN_P (pat
) && NEXT_INSN (pat
) != NULL_RTX
3000 && ! add_equal_note (pat
, ops
[0].value
, optab_to_code (unoptab
),
3001 ops
[1].value
, NULL_RTX
))
3003 delete_insns_since (last
);
3004 return expand_unop (mode
, unoptab
, op0
, NULL_RTX
, unsignedp
);
3009 return ops
[0].value
;
3015 /* Generate code to perform an operation specified by UNOPTAB
3016 on operand OP0, with result having machine-mode MODE.
3018 UNSIGNEDP is for the case where we have to widen the operands
3019 to perform the operation. It says to use zero-extension.
3021 If TARGET is nonzero, the value
3022 is generated there, if it is convenient to do so.
3023 In all cases an rtx is returned for the locus of the value;
3024 this may or may not be TARGET. */
3027 expand_unop (enum machine_mode mode
, optab unoptab
, rtx op0
, rtx target
,
3030 enum mode_class mclass
= GET_MODE_CLASS (mode
);
3031 enum machine_mode wider_mode
;
3035 temp
= expand_unop_direct (mode
, unoptab
, op0
, target
, unsignedp
);
3039 /* It can't be done in this mode. Can we open-code it in a wider mode? */
3041 /* Widening (or narrowing) clz needs special treatment. */
3042 if (unoptab
== clz_optab
)
3044 temp
= widen_leading (mode
, op0
, target
, unoptab
);
3048 if (GET_MODE_SIZE (mode
) == 2 * UNITS_PER_WORD
3049 && optab_handler (unoptab
, word_mode
) != CODE_FOR_nothing
)
3051 temp
= expand_doubleword_clz (mode
, op0
, target
);
3059 if (unoptab
== clrsb_optab
)
3061 temp
= widen_leading (mode
, op0
, target
, unoptab
);
3067 /* Widening (or narrowing) bswap needs special treatment. */
3068 if (unoptab
== bswap_optab
)
3070 /* HImode is special because in this mode BSWAP is equivalent to ROTATE
3071 or ROTATERT. First try these directly; if this fails, then try the
3072 obvious pair of shifts with allowed widening, as this will probably
3073 be always more efficient than the other fallback methods. */
3076 rtx last
, temp1
, temp2
;
3078 if (optab_handler (rotl_optab
, mode
) != CODE_FOR_nothing
)
3080 temp
= expand_binop (mode
, rotl_optab
, op0
, GEN_INT (8), target
,
3081 unsignedp
, OPTAB_DIRECT
);
3086 if (optab_handler (rotr_optab
, mode
) != CODE_FOR_nothing
)
3088 temp
= expand_binop (mode
, rotr_optab
, op0
, GEN_INT (8), target
,
3089 unsignedp
, OPTAB_DIRECT
);
3094 last
= get_last_insn ();
3096 temp1
= expand_binop (mode
, ashl_optab
, op0
, GEN_INT (8), NULL_RTX
,
3097 unsignedp
, OPTAB_WIDEN
);
3098 temp2
= expand_binop (mode
, lshr_optab
, op0
, GEN_INT (8), NULL_RTX
,
3099 unsignedp
, OPTAB_WIDEN
);
3102 temp
= expand_binop (mode
, ior_optab
, temp1
, temp2
, target
,
3103 unsignedp
, OPTAB_WIDEN
);
3108 delete_insns_since (last
);
3111 temp
= widen_bswap (mode
, op0
, target
);
3115 if (GET_MODE_SIZE (mode
) == 2 * UNITS_PER_WORD
3116 && optab_handler (unoptab
, word_mode
) != CODE_FOR_nothing
)
3118 temp
= expand_doubleword_bswap (mode
, op0
, target
);
3126 if (CLASS_HAS_WIDER_MODES_P (mclass
))
3127 for (wider_mode
= GET_MODE_WIDER_MODE (mode
);
3128 wider_mode
!= VOIDmode
;
3129 wider_mode
= GET_MODE_WIDER_MODE (wider_mode
))
3131 if (optab_handler (unoptab
, wider_mode
) != CODE_FOR_nothing
)
3134 rtx last
= get_last_insn ();
3136 /* For certain operations, we need not actually extend
3137 the narrow operand, as long as we will truncate the
3138 results to the same narrowness. */
3140 xop0
= widen_operand (xop0
, wider_mode
, mode
, unsignedp
,
3141 (unoptab
== neg_optab
3142 || unoptab
== one_cmpl_optab
)
3143 && mclass
== MODE_INT
);
3145 temp
= expand_unop (wider_mode
, unoptab
, xop0
, NULL_RTX
,
3150 if (mclass
!= MODE_INT
3151 || !TRULY_NOOP_TRUNCATION_MODES_P (mode
, wider_mode
))
3154 target
= gen_reg_rtx (mode
);
3155 convert_move (target
, temp
, 0);
3159 return gen_lowpart (mode
, temp
);
3162 delete_insns_since (last
);
3166 /* These can be done a word at a time. */
3167 if (unoptab
== one_cmpl_optab
3168 && mclass
== MODE_INT
3169 && GET_MODE_SIZE (mode
) > UNITS_PER_WORD
3170 && optab_handler (unoptab
, word_mode
) != CODE_FOR_nothing
)
3175 if (target
== 0 || target
== op0
|| !valid_multiword_target_p (target
))
3176 target
= gen_reg_rtx (mode
);
3180 /* Do the actual arithmetic. */
3181 for (i
= 0; i
< GET_MODE_BITSIZE (mode
) / BITS_PER_WORD
; i
++)
3183 rtx target_piece
= operand_subword (target
, i
, 1, mode
);
3184 rtx x
= expand_unop (word_mode
, unoptab
,
3185 operand_subword_force (op0
, i
, mode
),
3186 target_piece
, unsignedp
);
3188 if (target_piece
!= x
)
3189 emit_move_insn (target_piece
, x
);
3192 insns
= get_insns ();
3199 if (optab_to_code (unoptab
) == NEG
)
3201 /* Try negating floating point values by flipping the sign bit. */
3202 if (SCALAR_FLOAT_MODE_P (mode
))
3204 temp
= expand_absneg_bit (NEG
, mode
, op0
, target
);
3209 /* If there is no negation pattern, and we have no negative zero,
3210 try subtracting from zero. */
3211 if (!HONOR_SIGNED_ZEROS (mode
))
3213 temp
= expand_binop (mode
, (unoptab
== negv_optab
3214 ? subv_optab
: sub_optab
),
3215 CONST0_RTX (mode
), op0
, target
,
3216 unsignedp
, OPTAB_DIRECT
);
3222 /* Try calculating parity (x) as popcount (x) % 2. */
3223 if (unoptab
== parity_optab
)
3225 temp
= expand_parity (mode
, op0
, target
);
3230 /* Try implementing ffs (x) in terms of clz (x). */
3231 if (unoptab
== ffs_optab
)
3233 temp
= expand_ffs (mode
, op0
, target
);
3238 /* Try implementing ctz (x) in terms of clz (x). */
3239 if (unoptab
== ctz_optab
)
3241 temp
= expand_ctz (mode
, op0
, target
);
3247 /* Now try a library call in this mode. */
3248 libfunc
= optab_libfunc (unoptab
, mode
);
3254 enum machine_mode outmode
= mode
;
3256 /* All of these functions return small values. Thus we choose to
3257 have them return something that isn't a double-word. */
3258 if (unoptab
== ffs_optab
|| unoptab
== clz_optab
|| unoptab
== ctz_optab
3259 || unoptab
== clrsb_optab
|| unoptab
== popcount_optab
3260 || unoptab
== parity_optab
)
3262 = GET_MODE (hard_libcall_value (TYPE_MODE (integer_type_node
),
3263 optab_libfunc (unoptab
, mode
)));
3267 /* Pass 1 for NO_QUEUE so we don't lose any increments
3268 if the libcall is cse'd or moved. */
3269 value
= emit_library_call_value (libfunc
, NULL_RTX
, LCT_CONST
, outmode
,
3271 insns
= get_insns ();
3274 target
= gen_reg_rtx (outmode
);
3275 eq_value
= gen_rtx_fmt_e (optab_to_code (unoptab
), mode
, op0
);
3276 if (GET_MODE_SIZE (outmode
) < GET_MODE_SIZE (mode
))
3277 eq_value
= simplify_gen_unary (TRUNCATE
, outmode
, eq_value
, mode
);
3278 else if (GET_MODE_SIZE (outmode
) > GET_MODE_SIZE (mode
))
3279 eq_value
= simplify_gen_unary (ZERO_EXTEND
, outmode
, eq_value
, mode
);
3280 emit_libcall_block_1 (insns
, target
, value
, eq_value
,
3281 trapv_unoptab_p (unoptab
));
3286 /* It can't be done in this mode. Can we do it in a wider mode? */
3288 if (CLASS_HAS_WIDER_MODES_P (mclass
))
3290 for (wider_mode
= GET_MODE_WIDER_MODE (mode
);
3291 wider_mode
!= VOIDmode
;
3292 wider_mode
= GET_MODE_WIDER_MODE (wider_mode
))
3294 if (optab_handler (unoptab
, wider_mode
) != CODE_FOR_nothing
3295 || optab_libfunc (unoptab
, wider_mode
))
3298 rtx last
= get_last_insn ();
3300 /* For certain operations, we need not actually extend
3301 the narrow operand, as long as we will truncate the
3302 results to the same narrowness. */
3303 xop0
= widen_operand (xop0
, wider_mode
, mode
, unsignedp
,
3304 (unoptab
== neg_optab
3305 || unoptab
== one_cmpl_optab
3306 || unoptab
== bswap_optab
)
3307 && mclass
== MODE_INT
);
3309 temp
= expand_unop (wider_mode
, unoptab
, xop0
, NULL_RTX
,
3312 /* If we are generating clz using wider mode, adjust the
3313 result. Similarly for clrsb. */
3314 if ((unoptab
== clz_optab
|| unoptab
== clrsb_optab
)
3317 (wider_mode
, sub_optab
, temp
,
3318 gen_int_mode (GET_MODE_PRECISION (wider_mode
)
3319 - GET_MODE_PRECISION (mode
),
3321 target
, true, OPTAB_DIRECT
);
3323 /* Likewise for bswap. */
3324 if (unoptab
== bswap_optab
&& temp
!= 0)
3326 gcc_assert (GET_MODE_PRECISION (wider_mode
)
3327 == GET_MODE_BITSIZE (wider_mode
)
3328 && GET_MODE_PRECISION (mode
)
3329 == GET_MODE_BITSIZE (mode
));
3331 temp
= expand_shift (RSHIFT_EXPR
, wider_mode
, temp
,
3332 GET_MODE_BITSIZE (wider_mode
)
3333 - GET_MODE_BITSIZE (mode
),
3339 if (mclass
!= MODE_INT
)
3342 target
= gen_reg_rtx (mode
);
3343 convert_move (target
, temp
, 0);
3347 return gen_lowpart (mode
, temp
);
3350 delete_insns_since (last
);
3355 /* One final attempt at implementing negation via subtraction,
3356 this time allowing widening of the operand. */
3357 if (optab_to_code (unoptab
) == NEG
&& !HONOR_SIGNED_ZEROS (mode
))
3360 temp
= expand_binop (mode
,
3361 unoptab
== negv_optab
? subv_optab
: sub_optab
,
3362 CONST0_RTX (mode
), op0
,
3363 target
, unsignedp
, OPTAB_LIB_WIDEN
);
3371 /* Emit code to compute the absolute value of OP0, with result to
3372 TARGET if convenient. (TARGET may be 0.) The return value says
3373 where the result actually is to be found.
3375 MODE is the mode of the operand; the mode of the result is
3376 different but can be deduced from MODE.
3381 expand_abs_nojump (enum machine_mode mode
, rtx op0
, rtx target
,
3382 int result_unsignedp
)
3387 result_unsignedp
= 1;
3389 /* First try to do it with a special abs instruction. */
3390 temp
= expand_unop (mode
, result_unsignedp
? abs_optab
: absv_optab
,
3395 /* For floating point modes, try clearing the sign bit. */
3396 if (SCALAR_FLOAT_MODE_P (mode
))
3398 temp
= expand_absneg_bit (ABS
, mode
, op0
, target
);
3403 /* If we have a MAX insn, we can do this as MAX (x, -x). */
3404 if (optab_handler (smax_optab
, mode
) != CODE_FOR_nothing
3405 && !HONOR_SIGNED_ZEROS (mode
))
3407 rtx last
= get_last_insn ();
3409 temp
= expand_unop (mode
, neg_optab
, op0
, NULL_RTX
, 0);
3411 temp
= expand_binop (mode
, smax_optab
, op0
, temp
, target
, 0,
3417 delete_insns_since (last
);
3420 /* If this machine has expensive jumps, we can do integer absolute
3421 value of X as (((signed) x >> (W-1)) ^ x) - ((signed) x >> (W-1)),
3422 where W is the width of MODE. */
3424 if (GET_MODE_CLASS (mode
) == MODE_INT
3425 && BRANCH_COST (optimize_insn_for_speed_p (),
3428 rtx extended
= expand_shift (RSHIFT_EXPR
, mode
, op0
,
3429 GET_MODE_PRECISION (mode
) - 1,
3432 temp
= expand_binop (mode
, xor_optab
, extended
, op0
, target
, 0,
3435 temp
= expand_binop (mode
, result_unsignedp
? sub_optab
: subv_optab
,
3436 temp
, extended
, target
, 0, OPTAB_LIB_WIDEN
);
3446 expand_abs (enum machine_mode mode
, rtx op0
, rtx target
,
3447 int result_unsignedp
, int safe
)
3452 result_unsignedp
= 1;
3454 temp
= expand_abs_nojump (mode
, op0
, target
, result_unsignedp
);
3458 /* If that does not win, use conditional jump and negate. */
3460 /* It is safe to use the target if it is the same
3461 as the source if this is also a pseudo register */
3462 if (op0
== target
&& REG_P (op0
)
3463 && REGNO (op0
) >= FIRST_PSEUDO_REGISTER
)
3466 op1
= gen_label_rtx ();
3467 if (target
== 0 || ! safe
3468 || GET_MODE (target
) != mode
3469 || (MEM_P (target
) && MEM_VOLATILE_P (target
))
3471 && REGNO (target
) < FIRST_PSEUDO_REGISTER
))
3472 target
= gen_reg_rtx (mode
);
3474 emit_move_insn (target
, op0
);
3477 do_compare_rtx_and_jump (target
, CONST0_RTX (mode
), GE
, 0, mode
,
3478 NULL_RTX
, NULL_RTX
, op1
, -1);
3480 op0
= expand_unop (mode
, result_unsignedp
? neg_optab
: negv_optab
,
3483 emit_move_insn (target
, op0
);
3489 /* Emit code to compute the one's complement absolute value of OP0
3490 (if (OP0 < 0) OP0 = ~OP0), with result to TARGET if convenient.
3491 (TARGET may be NULL_RTX.) The return value says where the result
3492 actually is to be found.
3494 MODE is the mode of the operand; the mode of the result is
3495 different but can be deduced from MODE. */
3498 expand_one_cmpl_abs_nojump (enum machine_mode mode
, rtx op0
, rtx target
)
3502 /* Not applicable for floating point modes. */
3503 if (FLOAT_MODE_P (mode
))
3506 /* If we have a MAX insn, we can do this as MAX (x, ~x). */
3507 if (optab_handler (smax_optab
, mode
) != CODE_FOR_nothing
)
3509 rtx last
= get_last_insn ();
3511 temp
= expand_unop (mode
, one_cmpl_optab
, op0
, NULL_RTX
, 0);
3513 temp
= expand_binop (mode
, smax_optab
, op0
, temp
, target
, 0,
3519 delete_insns_since (last
);
3522 /* If this machine has expensive jumps, we can do one's complement
3523 absolute value of X as (((signed) x >> (W-1)) ^ x). */
3525 if (GET_MODE_CLASS (mode
) == MODE_INT
3526 && BRANCH_COST (optimize_insn_for_speed_p (),
3529 rtx extended
= expand_shift (RSHIFT_EXPR
, mode
, op0
,
3530 GET_MODE_PRECISION (mode
) - 1,
3533 temp
= expand_binop (mode
, xor_optab
, extended
, op0
, target
, 0,
3543 /* A subroutine of expand_copysign, perform the copysign operation using the
3544 abs and neg primitives advertised to exist on the target. The assumption
3545 is that we have a split register file, and leaving op0 in fp registers,
3546 and not playing with subregs so much, will help the register allocator. */
3549 expand_copysign_absneg (enum machine_mode mode
, rtx op0
, rtx op1
, rtx target
,
3550 int bitpos
, bool op0_is_abs
)
3552 enum machine_mode imode
;
3553 enum insn_code icode
;
3559 /* Check if the back end provides an insn that handles signbit for the
3561 icode
= optab_handler (signbit_optab
, mode
);
3562 if (icode
!= CODE_FOR_nothing
)
3564 imode
= insn_data
[(int) icode
].operand
[0].mode
;
3565 sign
= gen_reg_rtx (imode
);
3566 emit_unop_insn (icode
, sign
, op1
, UNKNOWN
);
3570 if (GET_MODE_SIZE (mode
) <= UNITS_PER_WORD
)
3572 imode
= int_mode_for_mode (mode
);
3573 if (imode
== BLKmode
)
3575 op1
= gen_lowpart (imode
, op1
);
3582 if (FLOAT_WORDS_BIG_ENDIAN
)
3583 word
= (GET_MODE_BITSIZE (mode
) - bitpos
) / BITS_PER_WORD
;
3585 word
= bitpos
/ BITS_PER_WORD
;
3586 bitpos
= bitpos
% BITS_PER_WORD
;
3587 op1
= operand_subword_force (op1
, word
, mode
);
3590 wide_int mask
= wi::set_bit_in_zero (bitpos
, GET_MODE_PRECISION (imode
));
3591 sign
= expand_binop (imode
, and_optab
, op1
,
3592 immed_wide_int_const (mask
, imode
),
3593 NULL_RTX
, 1, OPTAB_LIB_WIDEN
);
3598 op0
= expand_unop (mode
, abs_optab
, op0
, target
, 0);
3605 if (target
== NULL_RTX
)
3606 target
= copy_to_reg (op0
);
3608 emit_move_insn (target
, op0
);
3611 label
= gen_label_rtx ();
3612 emit_cmp_and_jump_insns (sign
, const0_rtx
, EQ
, NULL_RTX
, imode
, 1, label
);
3614 if (CONST_DOUBLE_AS_FLOAT_P (op0
))
3615 op0
= simplify_unary_operation (NEG
, mode
, op0
, mode
);
3617 op0
= expand_unop (mode
, neg_optab
, op0
, target
, 0);
3619 emit_move_insn (target
, op0
);
3627 /* A subroutine of expand_copysign, perform the entire copysign operation
3628 with integer bitmasks. BITPOS is the position of the sign bit; OP0_IS_ABS
3629 is true if op0 is known to have its sign bit clear. */
3632 expand_copysign_bit (enum machine_mode mode
, rtx op0
, rtx op1
, rtx target
,
3633 int bitpos
, bool op0_is_abs
)
3635 enum machine_mode imode
;
3636 int word
, nwords
, i
;
3639 if (GET_MODE_SIZE (mode
) <= UNITS_PER_WORD
)
3641 imode
= int_mode_for_mode (mode
);
3642 if (imode
== BLKmode
)
3651 if (FLOAT_WORDS_BIG_ENDIAN
)
3652 word
= (GET_MODE_BITSIZE (mode
) - bitpos
) / BITS_PER_WORD
;
3654 word
= bitpos
/ BITS_PER_WORD
;
3655 bitpos
= bitpos
% BITS_PER_WORD
;
3656 nwords
= (GET_MODE_BITSIZE (mode
) + BITS_PER_WORD
- 1) / BITS_PER_WORD
;
3659 wide_int mask
= wi::set_bit_in_zero (bitpos
, GET_MODE_PRECISION (imode
));
3664 || (nwords
> 1 && !valid_multiword_target_p (target
)))
3665 target
= gen_reg_rtx (mode
);
3671 for (i
= 0; i
< nwords
; ++i
)
3673 rtx targ_piece
= operand_subword (target
, i
, 1, mode
);
3674 rtx op0_piece
= operand_subword_force (op0
, i
, mode
);
3680 = expand_binop (imode
, and_optab
, op0_piece
,
3681 immed_wide_int_const (-mask
, imode
),
3682 NULL_RTX
, 1, OPTAB_LIB_WIDEN
);
3683 op1
= expand_binop (imode
, and_optab
,
3684 operand_subword_force (op1
, i
, mode
),
3685 immed_wide_int_const (mask
, imode
),
3686 NULL_RTX
, 1, OPTAB_LIB_WIDEN
);
3688 temp
= expand_binop (imode
, ior_optab
, op0_piece
, op1
,
3689 targ_piece
, 1, OPTAB_LIB_WIDEN
);
3690 if (temp
!= targ_piece
)
3691 emit_move_insn (targ_piece
, temp
);
3694 emit_move_insn (targ_piece
, op0_piece
);
3697 insns
= get_insns ();
3704 op1
= expand_binop (imode
, and_optab
, gen_lowpart (imode
, op1
),
3705 immed_wide_int_const (mask
, imode
),
3706 NULL_RTX
, 1, OPTAB_LIB_WIDEN
);
3708 op0
= gen_lowpart (imode
, op0
);
3710 op0
= expand_binop (imode
, and_optab
, op0
,
3711 immed_wide_int_const (-mask
, imode
),
3712 NULL_RTX
, 1, OPTAB_LIB_WIDEN
);
3713 temp
= expand_binop (imode
, ior_optab
, op0
, op1
,
3714 gen_lowpart (imode
, target
), 1, OPTAB_LIB_WIDEN
);
3715 target
= lowpart_subreg_maybe_copy (mode
, temp
, imode
);
3721 /* Expand the C99 copysign operation. OP0 and OP1 must be the same
3722 scalar floating point mode. Return NULL if we do not know how to
3723 expand the operation inline. */
3726 expand_copysign (rtx op0
, rtx op1
, rtx target
)
3728 enum machine_mode mode
= GET_MODE (op0
);
3729 const struct real_format
*fmt
;
3733 gcc_assert (SCALAR_FLOAT_MODE_P (mode
));
3734 gcc_assert (GET_MODE (op1
) == mode
);
3736 /* First try to do it with a special instruction. */
3737 temp
= expand_binop (mode
, copysign_optab
, op0
, op1
,
3738 target
, 0, OPTAB_DIRECT
);
3742 fmt
= REAL_MODE_FORMAT (mode
);
3743 if (fmt
== NULL
|| !fmt
->has_signed_zero
)
3747 if (CONST_DOUBLE_AS_FLOAT_P (op0
))
3749 if (real_isneg (CONST_DOUBLE_REAL_VALUE (op0
)))
3750 op0
= simplify_unary_operation (ABS
, mode
, op0
, mode
);
3754 if (fmt
->signbit_ro
>= 0
3755 && (CONST_DOUBLE_AS_FLOAT_P (op0
)
3756 || (optab_handler (neg_optab
, mode
) != CODE_FOR_nothing
3757 && optab_handler (abs_optab
, mode
) != CODE_FOR_nothing
)))
3759 temp
= expand_copysign_absneg (mode
, op0
, op1
, target
,
3760 fmt
->signbit_ro
, op0_is_abs
);
3765 if (fmt
->signbit_rw
< 0)
3767 return expand_copysign_bit (mode
, op0
, op1
, target
,
3768 fmt
->signbit_rw
, op0_is_abs
);
3771 /* Generate an instruction whose insn-code is INSN_CODE,
3772 with two operands: an output TARGET and an input OP0.
3773 TARGET *must* be nonzero, and the output is always stored there.
3774 CODE is an rtx code such that (CODE OP0) is an rtx that describes
3775 the value that is stored into TARGET.
3777 Return false if expansion failed. */
3780 maybe_emit_unop_insn (enum insn_code icode
, rtx target
, rtx op0
,
3783 struct expand_operand ops
[2];
3786 create_output_operand (&ops
[0], target
, GET_MODE (target
));
3787 create_input_operand (&ops
[1], op0
, GET_MODE (op0
));
3788 pat
= maybe_gen_insn (icode
, 2, ops
);
3792 if (INSN_P (pat
) && NEXT_INSN (pat
) != NULL_RTX
&& code
!= UNKNOWN
)
3793 add_equal_note (pat
, ops
[0].value
, code
, ops
[1].value
, NULL_RTX
);
3797 if (ops
[0].value
!= target
)
3798 emit_move_insn (target
, ops
[0].value
);
3801 /* Generate an instruction whose insn-code is INSN_CODE,
3802 with two operands: an output TARGET and an input OP0.
3803 TARGET *must* be nonzero, and the output is always stored there.
3804 CODE is an rtx code such that (CODE OP0) is an rtx that describes
3805 the value that is stored into TARGET. */
3808 emit_unop_insn (enum insn_code icode
, rtx target
, rtx op0
, enum rtx_code code
)
3810 bool ok
= maybe_emit_unop_insn (icode
, target
, op0
, code
);
3814 struct no_conflict_data
3816 rtx target
, first
, insn
;
3820 /* Called via note_stores by emit_libcall_block. Set P->must_stay if
3821 the currently examined clobber / store has to stay in the list of
3822 insns that constitute the actual libcall block. */
3824 no_conflict_move_test (rtx dest
, const_rtx set
, void *p0
)
3826 struct no_conflict_data
*p
= (struct no_conflict_data
*) p0
;
3828 /* If this inns directly contributes to setting the target, it must stay. */
3829 if (reg_overlap_mentioned_p (p
->target
, dest
))
3830 p
->must_stay
= true;
3831 /* If we haven't committed to keeping any other insns in the list yet,
3832 there is nothing more to check. */
3833 else if (p
->insn
== p
->first
)
3835 /* If this insn sets / clobbers a register that feeds one of the insns
3836 already in the list, this insn has to stay too. */
3837 else if (reg_overlap_mentioned_p (dest
, PATTERN (p
->first
))
3838 || (CALL_P (p
->first
) && (find_reg_fusage (p
->first
, USE
, dest
)))
3839 || reg_used_between_p (dest
, p
->first
, p
->insn
)
3840 /* Likewise if this insn depends on a register set by a previous
3841 insn in the list, or if it sets a result (presumably a hard
3842 register) that is set or clobbered by a previous insn.
3843 N.B. the modified_*_p (SET_DEST...) tests applied to a MEM
3844 SET_DEST perform the former check on the address, and the latter
3845 check on the MEM. */
3846 || (GET_CODE (set
) == SET
3847 && (modified_in_p (SET_SRC (set
), p
->first
)
3848 || modified_in_p (SET_DEST (set
), p
->first
)
3849 || modified_between_p (SET_SRC (set
), p
->first
, p
->insn
)
3850 || modified_between_p (SET_DEST (set
), p
->first
, p
->insn
))))
3851 p
->must_stay
= true;
3855 /* Emit code to make a call to a constant function or a library call.
3857 INSNS is a list containing all insns emitted in the call.
3858 These insns leave the result in RESULT. Our block is to copy RESULT
3859 to TARGET, which is logically equivalent to EQUIV.
3861 We first emit any insns that set a pseudo on the assumption that these are
3862 loading constants into registers; doing so allows them to be safely cse'ed
3863 between blocks. Then we emit all the other insns in the block, followed by
3864 an insn to move RESULT to TARGET. This last insn will have a REQ_EQUAL
3865 note with an operand of EQUIV. */
3868 emit_libcall_block_1 (rtx insns
, rtx target
, rtx result
, rtx equiv
,
3869 bool equiv_may_trap
)
3871 rtx final_dest
= target
;
3872 rtx next
, last
, insn
;
3874 /* If this is a reg with REG_USERVAR_P set, then it could possibly turn
3875 into a MEM later. Protect the libcall block from this change. */
3876 if (! REG_P (target
) || REG_USERVAR_P (target
))
3877 target
= gen_reg_rtx (GET_MODE (target
));
3879 /* If we're using non-call exceptions, a libcall corresponding to an
3880 operation that may trap may also trap. */
3881 /* ??? See the comment in front of make_reg_eh_region_note. */
3882 if (cfun
->can_throw_non_call_exceptions
3883 && (equiv_may_trap
|| may_trap_p (equiv
)))
3885 for (insn
= insns
; insn
; insn
= NEXT_INSN (insn
))
3888 rtx note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
3891 int lp_nr
= INTVAL (XEXP (note
, 0));
3892 if (lp_nr
== 0 || lp_nr
== INT_MIN
)
3893 remove_note (insn
, note
);
3899 /* Look for any CALL_INSNs in this sequence, and attach a REG_EH_REGION
3900 reg note to indicate that this call cannot throw or execute a nonlocal
3901 goto (unless there is already a REG_EH_REGION note, in which case
3903 for (insn
= insns
; insn
; insn
= NEXT_INSN (insn
))
3905 make_reg_eh_region_note_nothrow_nononlocal (insn
);
3908 /* First emit all insns that set pseudos. Remove them from the list as
3909 we go. Avoid insns that set pseudos which were referenced in previous
3910 insns. These can be generated by move_by_pieces, for example,
3911 to update an address. Similarly, avoid insns that reference things
3912 set in previous insns. */
3914 for (insn
= insns
; insn
; insn
= next
)
3916 rtx set
= single_set (insn
);
3918 next
= NEXT_INSN (insn
);
3920 if (set
!= 0 && REG_P (SET_DEST (set
))
3921 && REGNO (SET_DEST (set
)) >= FIRST_PSEUDO_REGISTER
)
3923 struct no_conflict_data data
;
3925 data
.target
= const0_rtx
;
3929 note_stores (PATTERN (insn
), no_conflict_move_test
, &data
);
3930 if (! data
.must_stay
)
3932 if (PREV_INSN (insn
))
3933 NEXT_INSN (PREV_INSN (insn
)) = next
;
3938 PREV_INSN (next
) = PREV_INSN (insn
);
3944 /* Some ports use a loop to copy large arguments onto the stack.
3945 Don't move anything outside such a loop. */
3950 /* Write the remaining insns followed by the final copy. */
3951 for (insn
= insns
; insn
; insn
= next
)
3953 next
= NEXT_INSN (insn
);
3958 last
= emit_move_insn (target
, result
);
3959 set_dst_reg_note (last
, REG_EQUAL
, copy_rtx (equiv
), target
);
3961 if (final_dest
!= target
)
3962 emit_move_insn (final_dest
, target
);
3966 emit_libcall_block (rtx insns
, rtx target
, rtx result
, rtx equiv
)
3968 emit_libcall_block_1 (insns
, target
, result
, equiv
, false);
3971 /* Nonzero if we can perform a comparison of mode MODE straightforwardly.
3972 PURPOSE describes how this comparison will be used. CODE is the rtx
3973 comparison code we will be using.
3975 ??? Actually, CODE is slightly weaker than that. A target is still
3976 required to implement all of the normal bcc operations, but not
3977 required to implement all (or any) of the unordered bcc operations. */
3980 can_compare_p (enum rtx_code code
, enum machine_mode mode
,
3981 enum can_compare_purpose purpose
)
3984 test
= gen_rtx_fmt_ee (code
, mode
, const0_rtx
, const0_rtx
);
3987 enum insn_code icode
;
3989 if (purpose
== ccp_jump
3990 && (icode
= optab_handler (cbranch_optab
, mode
)) != CODE_FOR_nothing
3991 && insn_operand_matches (icode
, 0, test
))
3993 if (purpose
== ccp_store_flag
3994 && (icode
= optab_handler (cstore_optab
, mode
)) != CODE_FOR_nothing
3995 && insn_operand_matches (icode
, 1, test
))
3997 if (purpose
== ccp_cmov
3998 && optab_handler (cmov_optab
, mode
) != CODE_FOR_nothing
)
4001 mode
= GET_MODE_WIDER_MODE (mode
);
4002 PUT_MODE (test
, mode
);
4004 while (mode
!= VOIDmode
);
4009 /* This function is called when we are going to emit a compare instruction that
4010 compares the values found in *PX and *PY, using the rtl operator COMPARISON.
4012 *PMODE is the mode of the inputs (in case they are const_int).
4013 *PUNSIGNEDP nonzero says that the operands are unsigned;
4014 this matters if they need to be widened (as given by METHODS).
4016 If they have mode BLKmode, then SIZE specifies the size of both operands.
4018 This function performs all the setup necessary so that the caller only has
4019 to emit a single comparison insn. This setup can involve doing a BLKmode
4020 comparison or emitting a library call to perform the comparison if no insn
4021 is available to handle it.
4022 The values which are passed in through pointers can be modified; the caller
4023 should perform the comparison on the modified values. Constant
4024 comparisons must have already been folded. */
4027 prepare_cmp_insn (rtx x
, rtx y
, enum rtx_code comparison
, rtx size
,
4028 int unsignedp
, enum optab_methods methods
,
4029 rtx
*ptest
, enum machine_mode
*pmode
)
4031 enum machine_mode mode
= *pmode
;
4033 enum machine_mode cmp_mode
;
4034 enum mode_class mclass
;
4036 /* The other methods are not needed. */
4037 gcc_assert (methods
== OPTAB_DIRECT
|| methods
== OPTAB_WIDEN
4038 || methods
== OPTAB_LIB_WIDEN
);
4040 /* If we are optimizing, force expensive constants into a register. */
4041 if (CONSTANT_P (x
) && optimize
4042 && (rtx_cost (x
, COMPARE
, 0, optimize_insn_for_speed_p ())
4043 > COSTS_N_INSNS (1)))
4044 x
= force_reg (mode
, x
);
4046 if (CONSTANT_P (y
) && optimize
4047 && (rtx_cost (y
, COMPARE
, 1, optimize_insn_for_speed_p ())
4048 > COSTS_N_INSNS (1)))
4049 y
= force_reg (mode
, y
);
4052 /* Make sure if we have a canonical comparison. The RTL
4053 documentation states that canonical comparisons are required only
4054 for targets which have cc0. */
4055 gcc_assert (!CONSTANT_P (x
) || CONSTANT_P (y
));
4058 /* Don't let both operands fail to indicate the mode. */
4059 if (GET_MODE (x
) == VOIDmode
&& GET_MODE (y
) == VOIDmode
)
4060 x
= force_reg (mode
, x
);
4061 if (mode
== VOIDmode
)
4062 mode
= GET_MODE (x
) != VOIDmode
? GET_MODE (x
) : GET_MODE (y
);
4064 /* Handle all BLKmode compares. */
4066 if (mode
== BLKmode
)
4068 enum machine_mode result_mode
;
4069 enum insn_code cmp_code
;
4074 = GEN_INT (MIN (MEM_ALIGN (x
), MEM_ALIGN (y
)) / BITS_PER_UNIT
);
4078 /* Try to use a memory block compare insn - either cmpstr
4079 or cmpmem will do. */
4080 for (cmp_mode
= GET_CLASS_NARROWEST_MODE (MODE_INT
);
4081 cmp_mode
!= VOIDmode
;
4082 cmp_mode
= GET_MODE_WIDER_MODE (cmp_mode
))
4084 cmp_code
= direct_optab_handler (cmpmem_optab
, cmp_mode
);
4085 if (cmp_code
== CODE_FOR_nothing
)
4086 cmp_code
= direct_optab_handler (cmpstr_optab
, cmp_mode
);
4087 if (cmp_code
== CODE_FOR_nothing
)
4088 cmp_code
= direct_optab_handler (cmpstrn_optab
, cmp_mode
);
4089 if (cmp_code
== CODE_FOR_nothing
)
4092 /* Must make sure the size fits the insn's mode. */
4093 if ((CONST_INT_P (size
)
4094 && INTVAL (size
) >= (1 << GET_MODE_BITSIZE (cmp_mode
)))
4095 || (GET_MODE_BITSIZE (GET_MODE (size
))
4096 > GET_MODE_BITSIZE (cmp_mode
)))
4099 result_mode
= insn_data
[cmp_code
].operand
[0].mode
;
4100 result
= gen_reg_rtx (result_mode
);
4101 size
= convert_to_mode (cmp_mode
, size
, 1);
4102 emit_insn (GEN_FCN (cmp_code
) (result
, x
, y
, size
, opalign
));
4104 *ptest
= gen_rtx_fmt_ee (comparison
, VOIDmode
, result
, const0_rtx
);
4105 *pmode
= result_mode
;
4109 if (methods
!= OPTAB_LIB
&& methods
!= OPTAB_LIB_WIDEN
)
4112 /* Otherwise call a library function, memcmp. */
4113 libfunc
= memcmp_libfunc
;
4114 length_type
= sizetype
;
4115 result_mode
= TYPE_MODE (integer_type_node
);
4116 cmp_mode
= TYPE_MODE (length_type
);
4117 size
= convert_to_mode (TYPE_MODE (length_type
), size
,
4118 TYPE_UNSIGNED (length_type
));
4120 result
= emit_library_call_value (libfunc
, 0, LCT_PURE
,
4128 methods
= OPTAB_LIB_WIDEN
;
4132 /* Don't allow operands to the compare to trap, as that can put the
4133 compare and branch in different basic blocks. */
4134 if (cfun
->can_throw_non_call_exceptions
)
4137 x
= force_reg (mode
, x
);
4139 y
= force_reg (mode
, y
);
4142 if (GET_MODE_CLASS (mode
) == MODE_CC
)
4144 gcc_assert (can_compare_p (comparison
, CCmode
, ccp_jump
));
4145 *ptest
= gen_rtx_fmt_ee (comparison
, VOIDmode
, x
, y
);
4149 mclass
= GET_MODE_CLASS (mode
);
4150 test
= gen_rtx_fmt_ee (comparison
, VOIDmode
, x
, y
);
4154 enum insn_code icode
;
4155 icode
= optab_handler (cbranch_optab
, cmp_mode
);
4156 if (icode
!= CODE_FOR_nothing
4157 && insn_operand_matches (icode
, 0, test
))
4159 rtx last
= get_last_insn ();
4160 rtx op0
= prepare_operand (icode
, x
, 1, mode
, cmp_mode
, unsignedp
);
4161 rtx op1
= prepare_operand (icode
, y
, 2, mode
, cmp_mode
, unsignedp
);
4163 && insn_operand_matches (icode
, 1, op0
)
4164 && insn_operand_matches (icode
, 2, op1
))
4166 XEXP (test
, 0) = op0
;
4167 XEXP (test
, 1) = op1
;
4172 delete_insns_since (last
);
4175 if (methods
== OPTAB_DIRECT
|| !CLASS_HAS_WIDER_MODES_P (mclass
))
4177 cmp_mode
= GET_MODE_WIDER_MODE (cmp_mode
);
4179 while (cmp_mode
!= VOIDmode
);
4181 if (methods
!= OPTAB_LIB_WIDEN
)
4184 if (!SCALAR_FLOAT_MODE_P (mode
))
4187 enum machine_mode ret_mode
;
4189 /* Handle a libcall just for the mode we are using. */
4190 libfunc
= optab_libfunc (cmp_optab
, mode
);
4191 gcc_assert (libfunc
);
4193 /* If we want unsigned, and this mode has a distinct unsigned
4194 comparison routine, use that. */
4197 rtx ulibfunc
= optab_libfunc (ucmp_optab
, mode
);
4202 ret_mode
= targetm
.libgcc_cmp_return_mode ();
4203 result
= emit_library_call_value (libfunc
, NULL_RTX
, LCT_CONST
,
4204 ret_mode
, 2, x
, mode
, y
, mode
);
4206 /* There are two kinds of comparison routines. Biased routines
4207 return 0/1/2, and unbiased routines return -1/0/1. Other parts
4208 of gcc expect that the comparison operation is equivalent
4209 to the modified comparison. For signed comparisons compare the
4210 result against 1 in the biased case, and zero in the unbiased
4211 case. For unsigned comparisons always compare against 1 after
4212 biasing the unbiased result by adding 1. This gives us a way to
4214 The comparisons in the fixed-point helper library are always
4219 if (!TARGET_LIB_INT_CMP_BIASED
&& !ALL_FIXED_POINT_MODE_P (mode
))
4222 x
= plus_constant (ret_mode
, result
, 1);
4228 prepare_cmp_insn (x
, y
, comparison
, NULL_RTX
, unsignedp
, methods
,
4232 prepare_float_lib_cmp (x
, y
, comparison
, ptest
, pmode
);
4240 /* Before emitting an insn with code ICODE, make sure that X, which is going
4241 to be used for operand OPNUM of the insn, is converted from mode MODE to
4242 WIDER_MODE (UNSIGNEDP determines whether it is an unsigned conversion), and
4243 that it is accepted by the operand predicate. Return the new value. */
4246 prepare_operand (enum insn_code icode
, rtx x
, int opnum
, enum machine_mode mode
,
4247 enum machine_mode wider_mode
, int unsignedp
)
4249 if (mode
!= wider_mode
)
4250 x
= convert_modes (wider_mode
, mode
, x
, unsignedp
);
4252 if (!insn_operand_matches (icode
, opnum
, x
))
4254 if (reload_completed
)
4256 x
= copy_to_mode_reg (insn_data
[(int) icode
].operand
[opnum
].mode
, x
);
4262 /* Subroutine of emit_cmp_and_jump_insns; this function is called when we know
4263 we can do the branch. */
4266 emit_cmp_and_jump_insn_1 (rtx test
, enum machine_mode mode
, rtx label
, int prob
)
4268 enum machine_mode optab_mode
;
4269 enum mode_class mclass
;
4270 enum insn_code icode
;
4273 mclass
= GET_MODE_CLASS (mode
);
4274 optab_mode
= (mclass
== MODE_CC
) ? CCmode
: mode
;
4275 icode
= optab_handler (cbranch_optab
, optab_mode
);
4277 gcc_assert (icode
!= CODE_FOR_nothing
);
4278 gcc_assert (insn_operand_matches (icode
, 0, test
));
4279 insn
= emit_jump_insn (GEN_FCN (icode
) (test
, XEXP (test
, 0),
4280 XEXP (test
, 1), label
));
4282 && profile_status
!= PROFILE_ABSENT
4285 && any_condjump_p (insn
)
4286 && !find_reg_note (insn
, REG_BR_PROB
, 0))
4287 add_int_reg_note (insn
, REG_BR_PROB
, prob
);
4290 /* Generate code to compare X with Y so that the condition codes are
4291 set and to jump to LABEL if the condition is true. If X is a
4292 constant and Y is not a constant, then the comparison is swapped to
4293 ensure that the comparison RTL has the canonical form.
4295 UNSIGNEDP nonzero says that X and Y are unsigned; this matters if they
4296 need to be widened. UNSIGNEDP is also used to select the proper
4297 branch condition code.
4299 If X and Y have mode BLKmode, then SIZE specifies the size of both X and Y.
4301 MODE is the mode of the inputs (in case they are const_int).
4303 COMPARISON is the rtl operator to compare with (EQ, NE, GT, etc.).
4304 It will be potentially converted into an unsigned variant based on
4305 UNSIGNEDP to select a proper jump instruction.
4307 PROB is the probability of jumping to LABEL. */
4310 emit_cmp_and_jump_insns (rtx x
, rtx y
, enum rtx_code comparison
, rtx size
,
4311 enum machine_mode mode
, int unsignedp
, rtx label
,
4314 rtx op0
= x
, op1
= y
;
4317 /* Swap operands and condition to ensure canonical RTL. */
4318 if (swap_commutative_operands_p (x
, y
)
4319 && can_compare_p (swap_condition (comparison
), mode
, ccp_jump
))
4322 comparison
= swap_condition (comparison
);
4325 /* If OP0 is still a constant, then both X and Y must be constants
4326 or the opposite comparison is not supported. Force X into a register
4327 to create canonical RTL. */
4328 if (CONSTANT_P (op0
))
4329 op0
= force_reg (mode
, op0
);
4332 comparison
= unsigned_condition (comparison
);
4334 prepare_cmp_insn (op0
, op1
, comparison
, size
, unsignedp
, OPTAB_LIB_WIDEN
,
4336 emit_cmp_and_jump_insn_1 (test
, mode
, label
, prob
);
4340 /* Emit a library call comparison between floating point X and Y.
4341 COMPARISON is the rtl operator to compare with (EQ, NE, GT, etc.). */
4344 prepare_float_lib_cmp (rtx x
, rtx y
, enum rtx_code comparison
,
4345 rtx
*ptest
, enum machine_mode
*pmode
)
4347 enum rtx_code swapped
= swap_condition (comparison
);
4348 enum rtx_code reversed
= reverse_condition_maybe_unordered (comparison
);
4349 enum machine_mode orig_mode
= GET_MODE (x
);
4350 enum machine_mode mode
, cmp_mode
;
4351 rtx true_rtx
, false_rtx
;
4352 rtx value
, target
, insns
, equiv
;
4354 bool reversed_p
= false;
4355 cmp_mode
= targetm
.libgcc_cmp_return_mode ();
4357 for (mode
= orig_mode
;
4359 mode
= GET_MODE_WIDER_MODE (mode
))
4361 if (code_to_optab (comparison
)
4362 && (libfunc
= optab_libfunc (code_to_optab (comparison
), mode
)))
4365 if (code_to_optab (swapped
)
4366 && (libfunc
= optab_libfunc (code_to_optab (swapped
), mode
)))
4369 tmp
= x
; x
= y
; y
= tmp
;
4370 comparison
= swapped
;
4374 if (code_to_optab (reversed
)
4375 && (libfunc
= optab_libfunc (code_to_optab (reversed
), mode
)))
4377 comparison
= reversed
;
4383 gcc_assert (mode
!= VOIDmode
);
4385 if (mode
!= orig_mode
)
4387 x
= convert_to_mode (mode
, x
, 0);
4388 y
= convert_to_mode (mode
, y
, 0);
4391 /* Attach a REG_EQUAL note describing the semantics of the libcall to
4392 the RTL. The allows the RTL optimizers to delete the libcall if the
4393 condition can be determined at compile-time. */
4394 if (comparison
== UNORDERED
4395 || FLOAT_LIB_COMPARE_RETURNS_BOOL (mode
, comparison
))
4397 true_rtx
= const_true_rtx
;
4398 false_rtx
= const0_rtx
;
4405 true_rtx
= const0_rtx
;
4406 false_rtx
= const_true_rtx
;
4410 true_rtx
= const_true_rtx
;
4411 false_rtx
= const0_rtx
;
4415 true_rtx
= const1_rtx
;
4416 false_rtx
= const0_rtx
;
4420 true_rtx
= const0_rtx
;
4421 false_rtx
= constm1_rtx
;
4425 true_rtx
= constm1_rtx
;
4426 false_rtx
= const0_rtx
;
4430 true_rtx
= const0_rtx
;
4431 false_rtx
= const1_rtx
;
4439 if (comparison
== UNORDERED
)
4441 rtx temp
= simplify_gen_relational (NE
, cmp_mode
, mode
, x
, x
);
4442 equiv
= simplify_gen_relational (NE
, cmp_mode
, mode
, y
, y
);
4443 equiv
= simplify_gen_ternary (IF_THEN_ELSE
, cmp_mode
, cmp_mode
,
4444 temp
, const_true_rtx
, equiv
);
4448 equiv
= simplify_gen_relational (comparison
, cmp_mode
, mode
, x
, y
);
4449 if (! FLOAT_LIB_COMPARE_RETURNS_BOOL (mode
, comparison
))
4450 equiv
= simplify_gen_ternary (IF_THEN_ELSE
, cmp_mode
, cmp_mode
,
4451 equiv
, true_rtx
, false_rtx
);
4455 value
= emit_library_call_value (libfunc
, NULL_RTX
, LCT_CONST
,
4456 cmp_mode
, 2, x
, mode
, y
, mode
);
4457 insns
= get_insns ();
4460 target
= gen_reg_rtx (cmp_mode
);
4461 emit_libcall_block (insns
, target
, value
, equiv
);
4463 if (comparison
== UNORDERED
4464 || FLOAT_LIB_COMPARE_RETURNS_BOOL (mode
, comparison
)
4466 *ptest
= gen_rtx_fmt_ee (reversed_p
? EQ
: NE
, VOIDmode
, target
, false_rtx
);
4468 *ptest
= gen_rtx_fmt_ee (comparison
, VOIDmode
, target
, const0_rtx
);
4473 /* Generate code to indirectly jump to a location given in the rtx LOC. */
4476 emit_indirect_jump (rtx loc
)
4478 struct expand_operand ops
[1];
4480 create_address_operand (&ops
[0], loc
);
4481 expand_jump_insn (CODE_FOR_indirect_jump
, 1, ops
);
4485 #ifdef HAVE_conditional_move
4487 /* Emit a conditional move instruction if the machine supports one for that
4488 condition and machine mode.
4490 OP0 and OP1 are the operands that should be compared using CODE. CMODE is
4491 the mode to use should they be constants. If it is VOIDmode, they cannot
4494 OP2 should be stored in TARGET if the comparison is true, otherwise OP3
4495 should be stored there. MODE is the mode to use should they be constants.
4496 If it is VOIDmode, they cannot both be constants.
4498 The result is either TARGET (perhaps modified) or NULL_RTX if the operation
4499 is not supported. */
4502 emit_conditional_move (rtx target
, enum rtx_code code
, rtx op0
, rtx op1
,
4503 enum machine_mode cmode
, rtx op2
, rtx op3
,
4504 enum machine_mode mode
, int unsignedp
)
4506 rtx tem
, comparison
, last
;
4507 enum insn_code icode
;
4508 enum rtx_code reversed
;
4510 /* If one operand is constant, make it the second one. Only do this
4511 if the other operand is not constant as well. */
4513 if (swap_commutative_operands_p (op0
, op1
))
4518 code
= swap_condition (code
);
4521 /* get_condition will prefer to generate LT and GT even if the old
4522 comparison was against zero, so undo that canonicalization here since
4523 comparisons against zero are cheaper. */
4524 if (code
== LT
&& op1
== const1_rtx
)
4525 code
= LE
, op1
= const0_rtx
;
4526 else if (code
== GT
&& op1
== constm1_rtx
)
4527 code
= GE
, op1
= const0_rtx
;
4529 if (cmode
== VOIDmode
)
4530 cmode
= GET_MODE (op0
);
4532 if (swap_commutative_operands_p (op2
, op3
)
4533 && ((reversed
= reversed_comparison_code_parts (code
, op0
, op1
, NULL
))
4542 if (mode
== VOIDmode
)
4543 mode
= GET_MODE (op2
);
4545 icode
= direct_optab_handler (movcc_optab
, mode
);
4547 if (icode
== CODE_FOR_nothing
)
4551 target
= gen_reg_rtx (mode
);
4553 code
= unsignedp
? unsigned_condition (code
) : code
;
4554 comparison
= simplify_gen_relational (code
, VOIDmode
, cmode
, op0
, op1
);
4556 /* We can get const0_rtx or const_true_rtx in some circumstances. Just
4557 return NULL and let the caller figure out how best to deal with this
4559 if (!COMPARISON_P (comparison
))
4562 do_pending_stack_adjust ();
4563 last
= get_last_insn ();
4564 prepare_cmp_insn (XEXP (comparison
, 0), XEXP (comparison
, 1),
4565 GET_CODE (comparison
), NULL_RTX
, unsignedp
, OPTAB_WIDEN
,
4566 &comparison
, &cmode
);
4569 struct expand_operand ops
[4];
4571 create_output_operand (&ops
[0], target
, mode
);
4572 create_fixed_operand (&ops
[1], comparison
);
4573 create_input_operand (&ops
[2], op2
, mode
);
4574 create_input_operand (&ops
[3], op3
, mode
);
4575 if (maybe_expand_insn (icode
, 4, ops
))
4577 if (ops
[0].value
!= target
)
4578 convert_move (target
, ops
[0].value
, false);
4582 delete_insns_since (last
);
4586 /* Return nonzero if a conditional move of mode MODE is supported.
4588 This function is for combine so it can tell whether an insn that looks
4589 like a conditional move is actually supported by the hardware. If we
4590 guess wrong we lose a bit on optimization, but that's it. */
4591 /* ??? sparc64 supports conditionally moving integers values based on fp
4592 comparisons, and vice versa. How do we handle them? */
4595 can_conditionally_move_p (enum machine_mode mode
)
4597 if (direct_optab_handler (movcc_optab
, mode
) != CODE_FOR_nothing
)
4603 #endif /* HAVE_conditional_move */
4605 /* Emit a conditional addition instruction if the machine supports one for that
4606 condition and machine mode.
4608 OP0 and OP1 are the operands that should be compared using CODE. CMODE is
4609 the mode to use should they be constants. If it is VOIDmode, they cannot
4612 OP2 should be stored in TARGET if the comparison is false, otherwise OP2+OP3
4613 should be stored there. MODE is the mode to use should they be constants.
4614 If it is VOIDmode, they cannot both be constants.
4616 The result is either TARGET (perhaps modified) or NULL_RTX if the operation
4617 is not supported. */
4620 emit_conditional_add (rtx target
, enum rtx_code code
, rtx op0
, rtx op1
,
4621 enum machine_mode cmode
, rtx op2
, rtx op3
,
4622 enum machine_mode mode
, int unsignedp
)
4624 rtx tem
, comparison
, last
;
4625 enum insn_code icode
;
4627 /* If one operand is constant, make it the second one. Only do this
4628 if the other operand is not constant as well. */
4630 if (swap_commutative_operands_p (op0
, op1
))
4635 code
= swap_condition (code
);
4638 /* get_condition will prefer to generate LT and GT even if the old
4639 comparison was against zero, so undo that canonicalization here since
4640 comparisons against zero are cheaper. */
4641 if (code
== LT
&& op1
== const1_rtx
)
4642 code
= LE
, op1
= const0_rtx
;
4643 else if (code
== GT
&& op1
== constm1_rtx
)
4644 code
= GE
, op1
= const0_rtx
;
4646 if (cmode
== VOIDmode
)
4647 cmode
= GET_MODE (op0
);
4649 if (mode
== VOIDmode
)
4650 mode
= GET_MODE (op2
);
4652 icode
= optab_handler (addcc_optab
, mode
);
4654 if (icode
== CODE_FOR_nothing
)
4658 target
= gen_reg_rtx (mode
);
4660 code
= unsignedp
? unsigned_condition (code
) : code
;
4661 comparison
= simplify_gen_relational (code
, VOIDmode
, cmode
, op0
, op1
);
4663 /* We can get const0_rtx or const_true_rtx in some circumstances. Just
4664 return NULL and let the caller figure out how best to deal with this
4666 if (!COMPARISON_P (comparison
))
4669 do_pending_stack_adjust ();
4670 last
= get_last_insn ();
4671 prepare_cmp_insn (XEXP (comparison
, 0), XEXP (comparison
, 1),
4672 GET_CODE (comparison
), NULL_RTX
, unsignedp
, OPTAB_WIDEN
,
4673 &comparison
, &cmode
);
4676 struct expand_operand ops
[4];
4678 create_output_operand (&ops
[0], target
, mode
);
4679 create_fixed_operand (&ops
[1], comparison
);
4680 create_input_operand (&ops
[2], op2
, mode
);
4681 create_input_operand (&ops
[3], op3
, mode
);
4682 if (maybe_expand_insn (icode
, 4, ops
))
4684 if (ops
[0].value
!= target
)
4685 convert_move (target
, ops
[0].value
, false);
4689 delete_insns_since (last
);
4693 /* These functions attempt to generate an insn body, rather than
4694 emitting the insn, but if the gen function already emits them, we
4695 make no attempt to turn them back into naked patterns. */
4697 /* Generate and return an insn body to add Y to X. */
4700 gen_add2_insn (rtx x
, rtx y
)
4702 enum insn_code icode
= optab_handler (add_optab
, GET_MODE (x
));
4704 gcc_assert (insn_operand_matches (icode
, 0, x
));
4705 gcc_assert (insn_operand_matches (icode
, 1, x
));
4706 gcc_assert (insn_operand_matches (icode
, 2, y
));
4708 return GEN_FCN (icode
) (x
, x
, y
);
4711 /* Generate and return an insn body to add r1 and c,
4712 storing the result in r0. */
4715 gen_add3_insn (rtx r0
, rtx r1
, rtx c
)
4717 enum insn_code icode
= optab_handler (add_optab
, GET_MODE (r0
));
4719 if (icode
== CODE_FOR_nothing
4720 || !insn_operand_matches (icode
, 0, r0
)
4721 || !insn_operand_matches (icode
, 1, r1
)
4722 || !insn_operand_matches (icode
, 2, c
))
4725 return GEN_FCN (icode
) (r0
, r1
, c
);
4729 have_add2_insn (rtx x
, rtx y
)
4731 enum insn_code icode
;
4733 gcc_assert (GET_MODE (x
) != VOIDmode
);
4735 icode
= optab_handler (add_optab
, GET_MODE (x
));
4737 if (icode
== CODE_FOR_nothing
)
4740 if (!insn_operand_matches (icode
, 0, x
)
4741 || !insn_operand_matches (icode
, 1, x
)
4742 || !insn_operand_matches (icode
, 2, y
))
4748 /* Generate and return an insn body to subtract Y from X. */
4751 gen_sub2_insn (rtx x
, rtx y
)
4753 enum insn_code icode
= optab_handler (sub_optab
, GET_MODE (x
));
4755 gcc_assert (insn_operand_matches (icode
, 0, x
));
4756 gcc_assert (insn_operand_matches (icode
, 1, x
));
4757 gcc_assert (insn_operand_matches (icode
, 2, y
));
4759 return GEN_FCN (icode
) (x
, x
, y
);
4762 /* Generate and return an insn body to subtract r1 and c,
4763 storing the result in r0. */
4766 gen_sub3_insn (rtx r0
, rtx r1
, rtx c
)
4768 enum insn_code icode
= optab_handler (sub_optab
, GET_MODE (r0
));
4770 if (icode
== CODE_FOR_nothing
4771 || !insn_operand_matches (icode
, 0, r0
)
4772 || !insn_operand_matches (icode
, 1, r1
)
4773 || !insn_operand_matches (icode
, 2, c
))
4776 return GEN_FCN (icode
) (r0
, r1
, c
);
4780 have_sub2_insn (rtx x
, rtx y
)
4782 enum insn_code icode
;
4784 gcc_assert (GET_MODE (x
) != VOIDmode
);
4786 icode
= optab_handler (sub_optab
, GET_MODE (x
));
4788 if (icode
== CODE_FOR_nothing
)
4791 if (!insn_operand_matches (icode
, 0, x
)
4792 || !insn_operand_matches (icode
, 1, x
)
4793 || !insn_operand_matches (icode
, 2, y
))
4799 /* Generate the body of an instruction to copy Y into X.
4800 It may be a list of insns, if one insn isn't enough. */
4803 gen_move_insn (rtx x
, rtx y
)
4808 emit_move_insn_1 (x
, y
);
4814 /* Return the insn code used to extend FROM_MODE to TO_MODE.
4815 UNSIGNEDP specifies zero-extension instead of sign-extension. If
4816 no such operation exists, CODE_FOR_nothing will be returned. */
4819 can_extend_p (enum machine_mode to_mode
, enum machine_mode from_mode
,
4823 #ifdef HAVE_ptr_extend
4825 return CODE_FOR_ptr_extend
;
4828 tab
= unsignedp
? zext_optab
: sext_optab
;
4829 return convert_optab_handler (tab
, to_mode
, from_mode
);
4832 /* Generate the body of an insn to extend Y (with mode MFROM)
4833 into X (with mode MTO). Do zero-extension if UNSIGNEDP is nonzero. */
4836 gen_extend_insn (rtx x
, rtx y
, enum machine_mode mto
,
4837 enum machine_mode mfrom
, int unsignedp
)
4839 enum insn_code icode
= can_extend_p (mto
, mfrom
, unsignedp
);
4840 return GEN_FCN (icode
) (x
, y
);
4843 /* can_fix_p and can_float_p say whether the target machine
4844 can directly convert a given fixed point type to
4845 a given floating point type, or vice versa.
4846 The returned value is the CODE_FOR_... value to use,
4847 or CODE_FOR_nothing if these modes cannot be directly converted.
4849 *TRUNCP_PTR is set to 1 if it is necessary to output
4850 an explicit FTRUNC insn before the fix insn; otherwise 0. */
4852 static enum insn_code
4853 can_fix_p (enum machine_mode fixmode
, enum machine_mode fltmode
,
4854 int unsignedp
, int *truncp_ptr
)
4857 enum insn_code icode
;
4859 tab
= unsignedp
? ufixtrunc_optab
: sfixtrunc_optab
;
4860 icode
= convert_optab_handler (tab
, fixmode
, fltmode
);
4861 if (icode
!= CODE_FOR_nothing
)
4867 /* FIXME: This requires a port to define both FIX and FTRUNC pattern
4868 for this to work. We need to rework the fix* and ftrunc* patterns
4869 and documentation. */
4870 tab
= unsignedp
? ufix_optab
: sfix_optab
;
4871 icode
= convert_optab_handler (tab
, fixmode
, fltmode
);
4872 if (icode
!= CODE_FOR_nothing
4873 && optab_handler (ftrunc_optab
, fltmode
) != CODE_FOR_nothing
)
4880 return CODE_FOR_nothing
;
4884 can_float_p (enum machine_mode fltmode
, enum machine_mode fixmode
,
4889 tab
= unsignedp
? ufloat_optab
: sfloat_optab
;
4890 return convert_optab_handler (tab
, fltmode
, fixmode
);
4893 /* Function supportable_convert_operation
4895 Check whether an operation represented by the code CODE is a
4896 convert operation that is supported by the target platform in
4897 vector form (i.e., when operating on arguments of type VECTYPE_IN
4898 producing a result of type VECTYPE_OUT).
4900 Convert operations we currently support directly are FIX_TRUNC and FLOAT.
4901 This function checks if these operations are supported
4902 by the target platform either directly (via vector tree-codes), or via
4906 - CODE1 is code of vector operation to be used when
4907 vectorizing the operation, if available.
4908 - DECL is decl of target builtin functions to be used
4909 when vectorizing the operation, if available. In this case,
4910 CODE1 is CALL_EXPR. */
4913 supportable_convert_operation (enum tree_code code
,
4914 tree vectype_out
, tree vectype_in
,
4915 tree
*decl
, enum tree_code
*code1
)
4917 enum machine_mode m1
,m2
;
4920 m1
= TYPE_MODE (vectype_out
);
4921 m2
= TYPE_MODE (vectype_in
);
4923 /* First check if we can done conversion directly. */
4924 if ((code
== FIX_TRUNC_EXPR
4925 && can_fix_p (m1
,m2
,TYPE_UNSIGNED (vectype_out
), &truncp
)
4926 != CODE_FOR_nothing
)
4927 || (code
== FLOAT_EXPR
4928 && can_float_p (m1
,m2
,TYPE_UNSIGNED (vectype_in
))
4929 != CODE_FOR_nothing
))
4935 /* Now check for builtin. */
4936 if (targetm
.vectorize
.builtin_conversion
4937 && targetm
.vectorize
.builtin_conversion (code
, vectype_out
, vectype_in
))
4940 *decl
= targetm
.vectorize
.builtin_conversion (code
, vectype_out
, vectype_in
);
4947 /* Generate code to convert FROM to floating point
4948 and store in TO. FROM must be fixed point and not VOIDmode.
4949 UNSIGNEDP nonzero means regard FROM as unsigned.
4950 Normally this is done by correcting the final value
4951 if it is negative. */
4954 expand_float (rtx to
, rtx from
, int unsignedp
)
4956 enum insn_code icode
;
4958 enum machine_mode fmode
, imode
;
4959 bool can_do_signed
= false;
4961 /* Crash now, because we won't be able to decide which mode to use. */
4962 gcc_assert (GET_MODE (from
) != VOIDmode
);
4964 /* Look for an insn to do the conversion. Do it in the specified
4965 modes if possible; otherwise convert either input, output or both to
4966 wider mode. If the integer mode is wider than the mode of FROM,
4967 we can do the conversion signed even if the input is unsigned. */
4969 for (fmode
= GET_MODE (to
); fmode
!= VOIDmode
;
4970 fmode
= GET_MODE_WIDER_MODE (fmode
))
4971 for (imode
= GET_MODE (from
); imode
!= VOIDmode
;
4972 imode
= GET_MODE_WIDER_MODE (imode
))
4974 int doing_unsigned
= unsignedp
;
4976 if (fmode
!= GET_MODE (to
)
4977 && significand_size (fmode
) < GET_MODE_PRECISION (GET_MODE (from
)))
4980 icode
= can_float_p (fmode
, imode
, unsignedp
);
4981 if (icode
== CODE_FOR_nothing
&& unsignedp
)
4983 enum insn_code scode
= can_float_p (fmode
, imode
, 0);
4984 if (scode
!= CODE_FOR_nothing
)
4985 can_do_signed
= true;
4986 if (imode
!= GET_MODE (from
))
4987 icode
= scode
, doing_unsigned
= 0;
4990 if (icode
!= CODE_FOR_nothing
)
4992 if (imode
!= GET_MODE (from
))
4993 from
= convert_to_mode (imode
, from
, unsignedp
);
4995 if (fmode
!= GET_MODE (to
))
4996 target
= gen_reg_rtx (fmode
);
4998 emit_unop_insn (icode
, target
, from
,
4999 doing_unsigned
? UNSIGNED_FLOAT
: FLOAT
);
5002 convert_move (to
, target
, 0);
5007 /* Unsigned integer, and no way to convert directly. Convert as signed,
5008 then unconditionally adjust the result. */
5009 if (unsignedp
&& can_do_signed
)
5011 rtx label
= gen_label_rtx ();
5013 REAL_VALUE_TYPE offset
;
5015 /* Look for a usable floating mode FMODE wider than the source and at
5016 least as wide as the target. Using FMODE will avoid rounding woes
5017 with unsigned values greater than the signed maximum value. */
5019 for (fmode
= GET_MODE (to
); fmode
!= VOIDmode
;
5020 fmode
= GET_MODE_WIDER_MODE (fmode
))
5021 if (GET_MODE_PRECISION (GET_MODE (from
)) < GET_MODE_BITSIZE (fmode
)
5022 && can_float_p (fmode
, GET_MODE (from
), 0) != CODE_FOR_nothing
)
5025 if (fmode
== VOIDmode
)
5027 /* There is no such mode. Pretend the target is wide enough. */
5028 fmode
= GET_MODE (to
);
5030 /* Avoid double-rounding when TO is narrower than FROM. */
5031 if ((significand_size (fmode
) + 1)
5032 < GET_MODE_PRECISION (GET_MODE (from
)))
5035 rtx neglabel
= gen_label_rtx ();
5037 /* Don't use TARGET if it isn't a register, is a hard register,
5038 or is the wrong mode. */
5040 || REGNO (target
) < FIRST_PSEUDO_REGISTER
5041 || GET_MODE (target
) != fmode
)
5042 target
= gen_reg_rtx (fmode
);
5044 imode
= GET_MODE (from
);
5045 do_pending_stack_adjust ();
5047 /* Test whether the sign bit is set. */
5048 emit_cmp_and_jump_insns (from
, const0_rtx
, LT
, NULL_RTX
, imode
,
5051 /* The sign bit is not set. Convert as signed. */
5052 expand_float (target
, from
, 0);
5053 emit_jump_insn (gen_jump (label
));
5056 /* The sign bit is set.
5057 Convert to a usable (positive signed) value by shifting right
5058 one bit, while remembering if a nonzero bit was shifted
5059 out; i.e., compute (from & 1) | (from >> 1). */
5061 emit_label (neglabel
);
5062 temp
= expand_binop (imode
, and_optab
, from
, const1_rtx
,
5063 NULL_RTX
, 1, OPTAB_LIB_WIDEN
);
5064 temp1
= expand_shift (RSHIFT_EXPR
, imode
, from
, 1, NULL_RTX
, 1);
5065 temp
= expand_binop (imode
, ior_optab
, temp
, temp1
, temp
, 1,
5067 expand_float (target
, temp
, 0);
5069 /* Multiply by 2 to undo the shift above. */
5070 temp
= expand_binop (fmode
, add_optab
, target
, target
,
5071 target
, 0, OPTAB_LIB_WIDEN
);
5073 emit_move_insn (target
, temp
);
5075 do_pending_stack_adjust ();
5081 /* If we are about to do some arithmetic to correct for an
5082 unsigned operand, do it in a pseudo-register. */
5084 if (GET_MODE (to
) != fmode
5085 || !REG_P (to
) || REGNO (to
) < FIRST_PSEUDO_REGISTER
)
5086 target
= gen_reg_rtx (fmode
);
5088 /* Convert as signed integer to floating. */
5089 expand_float (target
, from
, 0);
5091 /* If FROM is negative (and therefore TO is negative),
5092 correct its value by 2**bitwidth. */
5094 do_pending_stack_adjust ();
5095 emit_cmp_and_jump_insns (from
, const0_rtx
, GE
, NULL_RTX
, GET_MODE (from
),
5099 real_2expN (&offset
, GET_MODE_PRECISION (GET_MODE (from
)), fmode
);
5100 temp
= expand_binop (fmode
, add_optab
, target
,
5101 CONST_DOUBLE_FROM_REAL_VALUE (offset
, fmode
),
5102 target
, 0, OPTAB_LIB_WIDEN
);
5104 emit_move_insn (target
, temp
);
5106 do_pending_stack_adjust ();
5111 /* No hardware instruction available; call a library routine. */
5116 convert_optab tab
= unsignedp
? ufloat_optab
: sfloat_optab
;
5118 if (GET_MODE_SIZE (GET_MODE (from
)) < GET_MODE_SIZE (SImode
))
5119 from
= convert_to_mode (SImode
, from
, unsignedp
);
5121 libfunc
= convert_optab_libfunc (tab
, GET_MODE (to
), GET_MODE (from
));
5122 gcc_assert (libfunc
);
5126 value
= emit_library_call_value (libfunc
, NULL_RTX
, LCT_CONST
,
5127 GET_MODE (to
), 1, from
,
5129 insns
= get_insns ();
5132 emit_libcall_block (insns
, target
, value
,
5133 gen_rtx_fmt_e (unsignedp
? UNSIGNED_FLOAT
: FLOAT
,
5134 GET_MODE (to
), from
));
5139 /* Copy result to requested destination
5140 if we have been computing in a temp location. */
5144 if (GET_MODE (target
) == GET_MODE (to
))
5145 emit_move_insn (to
, target
);
5147 convert_move (to
, target
, 0);
5151 /* Generate code to convert FROM to fixed point and store in TO. FROM
5152 must be floating point. */
5155 expand_fix (rtx to
, rtx from
, int unsignedp
)
5157 enum insn_code icode
;
5159 enum machine_mode fmode
, imode
;
5162 /* We first try to find a pair of modes, one real and one integer, at
5163 least as wide as FROM and TO, respectively, in which we can open-code
5164 this conversion. If the integer mode is wider than the mode of TO,
5165 we can do the conversion either signed or unsigned. */
5167 for (fmode
= GET_MODE (from
); fmode
!= VOIDmode
;
5168 fmode
= GET_MODE_WIDER_MODE (fmode
))
5169 for (imode
= GET_MODE (to
); imode
!= VOIDmode
;
5170 imode
= GET_MODE_WIDER_MODE (imode
))
5172 int doing_unsigned
= unsignedp
;
5174 icode
= can_fix_p (imode
, fmode
, unsignedp
, &must_trunc
);
5175 if (icode
== CODE_FOR_nothing
&& imode
!= GET_MODE (to
) && unsignedp
)
5176 icode
= can_fix_p (imode
, fmode
, 0, &must_trunc
), doing_unsigned
= 0;
5178 if (icode
!= CODE_FOR_nothing
)
5180 rtx last
= get_last_insn ();
5181 if (fmode
!= GET_MODE (from
))
5182 from
= convert_to_mode (fmode
, from
, 0);
5186 rtx temp
= gen_reg_rtx (GET_MODE (from
));
5187 from
= expand_unop (GET_MODE (from
), ftrunc_optab
, from
,
5191 if (imode
!= GET_MODE (to
))
5192 target
= gen_reg_rtx (imode
);
5194 if (maybe_emit_unop_insn (icode
, target
, from
,
5195 doing_unsigned
? UNSIGNED_FIX
: FIX
))
5198 convert_move (to
, target
, unsignedp
);
5201 delete_insns_since (last
);
5205 /* For an unsigned conversion, there is one more way to do it.
5206 If we have a signed conversion, we generate code that compares
5207 the real value to the largest representable positive number. If if
5208 is smaller, the conversion is done normally. Otherwise, subtract
5209 one plus the highest signed number, convert, and add it back.
5211 We only need to check all real modes, since we know we didn't find
5212 anything with a wider integer mode.
5214 This code used to extend FP value into mode wider than the destination.
5215 This is needed for decimal float modes which cannot accurately
5216 represent one plus the highest signed number of the same size, but
5217 not for binary modes. Consider, for instance conversion from SFmode
5220 The hot path through the code is dealing with inputs smaller than 2^63
5221 and doing just the conversion, so there is no bits to lose.
5223 In the other path we know the value is positive in the range 2^63..2^64-1
5224 inclusive. (as for other input overflow happens and result is undefined)
5225 So we know that the most important bit set in mantissa corresponds to
5226 2^63. The subtraction of 2^63 should not generate any rounding as it
5227 simply clears out that bit. The rest is trivial. */
5229 if (unsignedp
&& GET_MODE_PRECISION (GET_MODE (to
)) <= HOST_BITS_PER_WIDE_INT
)
5230 for (fmode
= GET_MODE (from
); fmode
!= VOIDmode
;
5231 fmode
= GET_MODE_WIDER_MODE (fmode
))
5232 if (CODE_FOR_nothing
!= can_fix_p (GET_MODE (to
), fmode
, 0, &must_trunc
)
5233 && (!DECIMAL_FLOAT_MODE_P (fmode
)
5234 || GET_MODE_BITSIZE (fmode
) > GET_MODE_PRECISION (GET_MODE (to
))))
5237 REAL_VALUE_TYPE offset
;
5238 rtx limit
, lab1
, lab2
, insn
;
5240 bitsize
= GET_MODE_PRECISION (GET_MODE (to
));
5241 real_2expN (&offset
, bitsize
- 1, fmode
);
5242 limit
= CONST_DOUBLE_FROM_REAL_VALUE (offset
, fmode
);
5243 lab1
= gen_label_rtx ();
5244 lab2
= gen_label_rtx ();
5246 if (fmode
!= GET_MODE (from
))
5247 from
= convert_to_mode (fmode
, from
, 0);
5249 /* See if we need to do the subtraction. */
5250 do_pending_stack_adjust ();
5251 emit_cmp_and_jump_insns (from
, limit
, GE
, NULL_RTX
, GET_MODE (from
),
5254 /* If not, do the signed "fix" and branch around fixup code. */
5255 expand_fix (to
, from
, 0);
5256 emit_jump_insn (gen_jump (lab2
));
5259 /* Otherwise, subtract 2**(N-1), convert to signed number,
5260 then add 2**(N-1). Do the addition using XOR since this
5261 will often generate better code. */
5263 target
= expand_binop (GET_MODE (from
), sub_optab
, from
, limit
,
5264 NULL_RTX
, 0, OPTAB_LIB_WIDEN
);
5265 expand_fix (to
, target
, 0);
5266 target
= expand_binop (GET_MODE (to
), xor_optab
, to
,
5268 ((HOST_WIDE_INT
) 1 << (bitsize
- 1),
5270 to
, 1, OPTAB_LIB_WIDEN
);
5273 emit_move_insn (to
, target
);
5277 if (optab_handler (mov_optab
, GET_MODE (to
)) != CODE_FOR_nothing
)
5279 /* Make a place for a REG_NOTE and add it. */
5280 insn
= emit_move_insn (to
, to
);
5281 set_dst_reg_note (insn
, REG_EQUAL
,
5282 gen_rtx_fmt_e (UNSIGNED_FIX
, GET_MODE (to
),
5290 /* We can't do it with an insn, so use a library call. But first ensure
5291 that the mode of TO is at least as wide as SImode, since those are the
5292 only library calls we know about. */
5294 if (GET_MODE_SIZE (GET_MODE (to
)) < GET_MODE_SIZE (SImode
))
5296 target
= gen_reg_rtx (SImode
);
5298 expand_fix (target
, from
, unsignedp
);
5306 convert_optab tab
= unsignedp
? ufix_optab
: sfix_optab
;
5307 libfunc
= convert_optab_libfunc (tab
, GET_MODE (to
), GET_MODE (from
));
5308 gcc_assert (libfunc
);
5312 value
= emit_library_call_value (libfunc
, NULL_RTX
, LCT_CONST
,
5313 GET_MODE (to
), 1, from
,
5315 insns
= get_insns ();
5318 emit_libcall_block (insns
, target
, value
,
5319 gen_rtx_fmt_e (unsignedp
? UNSIGNED_FIX
: FIX
,
5320 GET_MODE (to
), from
));
5325 if (GET_MODE (to
) == GET_MODE (target
))
5326 emit_move_insn (to
, target
);
5328 convert_move (to
, target
, 0);
5332 /* Generate code to convert FROM or TO a fixed-point.
5333 If UINTP is true, either TO or FROM is an unsigned integer.
5334 If SATP is true, we need to saturate the result. */
5337 expand_fixed_convert (rtx to
, rtx from
, int uintp
, int satp
)
5339 enum machine_mode to_mode
= GET_MODE (to
);
5340 enum machine_mode from_mode
= GET_MODE (from
);
5342 enum rtx_code this_code
;
5343 enum insn_code code
;
5347 if (to_mode
== from_mode
)
5349 emit_move_insn (to
, from
);
5355 tab
= satp
? satfractuns_optab
: fractuns_optab
;
5356 this_code
= satp
? UNSIGNED_SAT_FRACT
: UNSIGNED_FRACT_CONVERT
;
5360 tab
= satp
? satfract_optab
: fract_optab
;
5361 this_code
= satp
? SAT_FRACT
: FRACT_CONVERT
;
5363 code
= convert_optab_handler (tab
, to_mode
, from_mode
);
5364 if (code
!= CODE_FOR_nothing
)
5366 emit_unop_insn (code
, to
, from
, this_code
);
5370 libfunc
= convert_optab_libfunc (tab
, to_mode
, from_mode
);
5371 gcc_assert (libfunc
);
5374 value
= emit_library_call_value (libfunc
, NULL_RTX
, LCT_CONST
, to_mode
,
5375 1, from
, from_mode
);
5376 insns
= get_insns ();
5379 emit_libcall_block (insns
, to
, value
,
5380 gen_rtx_fmt_e (optab_to_code (tab
), to_mode
, from
));
5383 /* Generate code to convert FROM to fixed point and store in TO. FROM
5384 must be floating point, TO must be signed. Use the conversion optab
5385 TAB to do the conversion. */
5388 expand_sfix_optab (rtx to
, rtx from
, convert_optab tab
)
5390 enum insn_code icode
;
5392 enum machine_mode fmode
, imode
;
5394 /* We first try to find a pair of modes, one real and one integer, at
5395 least as wide as FROM and TO, respectively, in which we can open-code
5396 this conversion. If the integer mode is wider than the mode of TO,
5397 we can do the conversion either signed or unsigned. */
5399 for (fmode
= GET_MODE (from
); fmode
!= VOIDmode
;
5400 fmode
= GET_MODE_WIDER_MODE (fmode
))
5401 for (imode
= GET_MODE (to
); imode
!= VOIDmode
;
5402 imode
= GET_MODE_WIDER_MODE (imode
))
5404 icode
= convert_optab_handler (tab
, imode
, fmode
);
5405 if (icode
!= CODE_FOR_nothing
)
5407 rtx last
= get_last_insn ();
5408 if (fmode
!= GET_MODE (from
))
5409 from
= convert_to_mode (fmode
, from
, 0);
5411 if (imode
!= GET_MODE (to
))
5412 target
= gen_reg_rtx (imode
);
5414 if (!maybe_emit_unop_insn (icode
, target
, from
, UNKNOWN
))
5416 delete_insns_since (last
);
5420 convert_move (to
, target
, 0);
5428 /* Report whether we have an instruction to perform the operation
5429 specified by CODE on operands of mode MODE. */
5431 have_insn_for (enum rtx_code code
, enum machine_mode mode
)
5433 return (code_to_optab (code
)
5434 && (optab_handler (code_to_optab (code
), mode
)
5435 != CODE_FOR_nothing
));
5438 /* Initialize the libfunc fields of an entire group of entries in some
5439 optab. Each entry is set equal to a string consisting of a leading
5440 pair of underscores followed by a generic operation name followed by
5441 a mode name (downshifted to lowercase) followed by a single character
5442 representing the number of operands for the given operation (which is
5443 usually one of the characters '2', '3', or '4').
5445 OPTABLE is the table in which libfunc fields are to be initialized.
5446 OPNAME is the generic (string) name of the operation.
5447 SUFFIX is the character which specifies the number of operands for
5448 the given generic operation.
5449 MODE is the mode to generate for.
5453 gen_libfunc (optab optable
, const char *opname
, int suffix
,
5454 enum machine_mode mode
)
5456 unsigned opname_len
= strlen (opname
);
5457 const char *mname
= GET_MODE_NAME (mode
);
5458 unsigned mname_len
= strlen (mname
);
5459 int prefix_len
= targetm
.libfunc_gnu_prefix
? 6 : 2;
5460 int len
= prefix_len
+ opname_len
+ mname_len
+ 1 + 1;
5461 char *libfunc_name
= XALLOCAVEC (char, len
);
5468 if (targetm
.libfunc_gnu_prefix
)
5475 for (q
= opname
; *q
; )
5477 for (q
= mname
; *q
; q
++)
5478 *p
++ = TOLOWER (*q
);
5482 set_optab_libfunc (optable
, mode
,
5483 ggc_alloc_string (libfunc_name
, p
- libfunc_name
));
5486 /* Like gen_libfunc, but verify that integer operation is involved. */
5489 gen_int_libfunc (optab optable
, const char *opname
, char suffix
,
5490 enum machine_mode mode
)
5492 int maxsize
= 2 * BITS_PER_WORD
;
5494 if (GET_MODE_CLASS (mode
) != MODE_INT
)
5496 if (maxsize
< LONG_LONG_TYPE_SIZE
)
5497 maxsize
= LONG_LONG_TYPE_SIZE
;
5498 if (GET_MODE_CLASS (mode
) != MODE_INT
5499 || mode
< word_mode
|| GET_MODE_BITSIZE (mode
) > maxsize
)
5501 gen_libfunc (optable
, opname
, suffix
, mode
);
5504 /* Like gen_libfunc, but verify that FP and set decimal prefix if needed. */
5507 gen_fp_libfunc (optab optable
, const char *opname
, char suffix
,
5508 enum machine_mode mode
)
5512 if (GET_MODE_CLASS (mode
) == MODE_FLOAT
)
5513 gen_libfunc (optable
, opname
, suffix
, mode
);
5514 if (DECIMAL_FLOAT_MODE_P (mode
))
5516 dec_opname
= XALLOCAVEC (char, sizeof (DECIMAL_PREFIX
) + strlen (opname
));
5517 /* For BID support, change the name to have either a bid_ or dpd_ prefix
5518 depending on the low level floating format used. */
5519 memcpy (dec_opname
, DECIMAL_PREFIX
, sizeof (DECIMAL_PREFIX
) - 1);
5520 strcpy (dec_opname
+ sizeof (DECIMAL_PREFIX
) - 1, opname
);
5521 gen_libfunc (optable
, dec_opname
, suffix
, mode
);
5525 /* Like gen_libfunc, but verify that fixed-point operation is involved. */
5528 gen_fixed_libfunc (optab optable
, const char *opname
, char suffix
,
5529 enum machine_mode mode
)
5531 if (!ALL_FIXED_POINT_MODE_P (mode
))
5533 gen_libfunc (optable
, opname
, suffix
, mode
);
5536 /* Like gen_libfunc, but verify that signed fixed-point operation is
5540 gen_signed_fixed_libfunc (optab optable
, const char *opname
, char suffix
,
5541 enum machine_mode mode
)
5543 if (!SIGNED_FIXED_POINT_MODE_P (mode
))
5545 gen_libfunc (optable
, opname
, suffix
, mode
);
5548 /* Like gen_libfunc, but verify that unsigned fixed-point operation is
5552 gen_unsigned_fixed_libfunc (optab optable
, const char *opname
, char suffix
,
5553 enum machine_mode mode
)
5555 if (!UNSIGNED_FIXED_POINT_MODE_P (mode
))
5557 gen_libfunc (optable
, opname
, suffix
, mode
);
5560 /* Like gen_libfunc, but verify that FP or INT operation is involved. */
5563 gen_int_fp_libfunc (optab optable
, const char *name
, char suffix
,
5564 enum machine_mode mode
)
5566 if (DECIMAL_FLOAT_MODE_P (mode
) || GET_MODE_CLASS (mode
) == MODE_FLOAT
)
5567 gen_fp_libfunc (optable
, name
, suffix
, mode
);
5568 if (INTEGRAL_MODE_P (mode
))
5569 gen_int_libfunc (optable
, name
, suffix
, mode
);
5572 /* Like gen_libfunc, but verify that FP or INT operation is involved
5573 and add 'v' suffix for integer operation. */
5576 gen_intv_fp_libfunc (optab optable
, const char *name
, char suffix
,
5577 enum machine_mode mode
)
5579 if (DECIMAL_FLOAT_MODE_P (mode
) || GET_MODE_CLASS (mode
) == MODE_FLOAT
)
5580 gen_fp_libfunc (optable
, name
, suffix
, mode
);
5581 if (GET_MODE_CLASS (mode
) == MODE_INT
)
5583 int len
= strlen (name
);
5584 char *v_name
= XALLOCAVEC (char, len
+ 2);
5585 strcpy (v_name
, name
);
5587 v_name
[len
+ 1] = 0;
5588 gen_int_libfunc (optable
, v_name
, suffix
, mode
);
5592 /* Like gen_libfunc, but verify that FP or INT or FIXED operation is
5596 gen_int_fp_fixed_libfunc (optab optable
, const char *name
, char suffix
,
5597 enum machine_mode mode
)
5599 if (DECIMAL_FLOAT_MODE_P (mode
) || GET_MODE_CLASS (mode
) == MODE_FLOAT
)
5600 gen_fp_libfunc (optable
, name
, suffix
, mode
);
5601 if (INTEGRAL_MODE_P (mode
))
5602 gen_int_libfunc (optable
, name
, suffix
, mode
);
5603 if (ALL_FIXED_POINT_MODE_P (mode
))
5604 gen_fixed_libfunc (optable
, name
, suffix
, mode
);
5607 /* Like gen_libfunc, but verify that FP or INT or signed FIXED operation is
5611 gen_int_fp_signed_fixed_libfunc (optab optable
, const char *name
, char suffix
,
5612 enum machine_mode mode
)
5614 if (DECIMAL_FLOAT_MODE_P (mode
) || GET_MODE_CLASS (mode
) == MODE_FLOAT
)
5615 gen_fp_libfunc (optable
, name
, suffix
, mode
);
5616 if (INTEGRAL_MODE_P (mode
))
5617 gen_int_libfunc (optable
, name
, suffix
, mode
);
5618 if (SIGNED_FIXED_POINT_MODE_P (mode
))
5619 gen_signed_fixed_libfunc (optable
, name
, suffix
, mode
);
5622 /* Like gen_libfunc, but verify that INT or FIXED operation is
5626 gen_int_fixed_libfunc (optab optable
, const char *name
, char suffix
,
5627 enum machine_mode mode
)
5629 if (INTEGRAL_MODE_P (mode
))
5630 gen_int_libfunc (optable
, name
, suffix
, mode
);
5631 if (ALL_FIXED_POINT_MODE_P (mode
))
5632 gen_fixed_libfunc (optable
, name
, suffix
, mode
);
5635 /* Like gen_libfunc, but verify that INT or signed FIXED operation is
5639 gen_int_signed_fixed_libfunc (optab optable
, const char *name
, char suffix
,
5640 enum machine_mode mode
)
5642 if (INTEGRAL_MODE_P (mode
))
5643 gen_int_libfunc (optable
, name
, suffix
, mode
);
5644 if (SIGNED_FIXED_POINT_MODE_P (mode
))
5645 gen_signed_fixed_libfunc (optable
, name
, suffix
, mode
);
5648 /* Like gen_libfunc, but verify that INT or unsigned FIXED operation is
5652 gen_int_unsigned_fixed_libfunc (optab optable
, const char *name
, char suffix
,
5653 enum machine_mode mode
)
5655 if (INTEGRAL_MODE_P (mode
))
5656 gen_int_libfunc (optable
, name
, suffix
, mode
);
5657 if (UNSIGNED_FIXED_POINT_MODE_P (mode
))
5658 gen_unsigned_fixed_libfunc (optable
, name
, suffix
, mode
);
5661 /* Initialize the libfunc fields of an entire group of entries of an
5662 inter-mode-class conversion optab. The string formation rules are
5663 similar to the ones for init_libfuncs, above, but instead of having
5664 a mode name and an operand count these functions have two mode names
5665 and no operand count. */
5668 gen_interclass_conv_libfunc (convert_optab tab
,
5670 enum machine_mode tmode
,
5671 enum machine_mode fmode
)
5673 size_t opname_len
= strlen (opname
);
5674 size_t mname_len
= 0;
5676 const char *fname
, *tname
;
5678 int prefix_len
= targetm
.libfunc_gnu_prefix
? 6 : 2;
5679 char *libfunc_name
, *suffix
;
5680 char *nondec_name
, *dec_name
, *nondec_suffix
, *dec_suffix
;
5683 /* If this is a decimal conversion, add the current BID vs. DPD prefix that
5684 depends on which underlying decimal floating point format is used. */
5685 const size_t dec_len
= sizeof (DECIMAL_PREFIX
) - 1;
5687 mname_len
= strlen (GET_MODE_NAME (tmode
)) + strlen (GET_MODE_NAME (fmode
));
5689 nondec_name
= XALLOCAVEC (char, prefix_len
+ opname_len
+ mname_len
+ 1 + 1);
5690 nondec_name
[0] = '_';
5691 nondec_name
[1] = '_';
5692 if (targetm
.libfunc_gnu_prefix
)
5694 nondec_name
[2] = 'g';
5695 nondec_name
[3] = 'n';
5696 nondec_name
[4] = 'u';
5697 nondec_name
[5] = '_';
5700 memcpy (&nondec_name
[prefix_len
], opname
, opname_len
);
5701 nondec_suffix
= nondec_name
+ opname_len
+ prefix_len
;
5703 dec_name
= XALLOCAVEC (char, 2 + dec_len
+ opname_len
+ mname_len
+ 1 + 1);
5706 memcpy (&dec_name
[2], DECIMAL_PREFIX
, dec_len
);
5707 memcpy (&dec_name
[2+dec_len
], opname
, opname_len
);
5708 dec_suffix
= dec_name
+ dec_len
+ opname_len
+ 2;
5710 fname
= GET_MODE_NAME (fmode
);
5711 tname
= GET_MODE_NAME (tmode
);
5713 if (DECIMAL_FLOAT_MODE_P (fmode
) || DECIMAL_FLOAT_MODE_P (tmode
))
5715 libfunc_name
= dec_name
;
5716 suffix
= dec_suffix
;
5720 libfunc_name
= nondec_name
;
5721 suffix
= nondec_suffix
;
5725 for (q
= fname
; *q
; p
++, q
++)
5727 for (q
= tname
; *q
; p
++, q
++)
5732 set_conv_libfunc (tab
, tmode
, fmode
,
5733 ggc_alloc_string (libfunc_name
, p
- libfunc_name
));
5736 /* Same as gen_interclass_conv_libfunc but verify that we are producing
5737 int->fp conversion. */
5740 gen_int_to_fp_conv_libfunc (convert_optab tab
,
5742 enum machine_mode tmode
,
5743 enum machine_mode fmode
)
5745 if (GET_MODE_CLASS (fmode
) != MODE_INT
)
5747 if (GET_MODE_CLASS (tmode
) != MODE_FLOAT
&& !DECIMAL_FLOAT_MODE_P (tmode
))
5749 gen_interclass_conv_libfunc (tab
, opname
, tmode
, fmode
);
5752 /* ufloat_optab is special by using floatun for FP and floatuns decimal fp
5756 gen_ufloat_conv_libfunc (convert_optab tab
,
5757 const char *opname ATTRIBUTE_UNUSED
,
5758 enum machine_mode tmode
,
5759 enum machine_mode fmode
)
5761 if (DECIMAL_FLOAT_MODE_P (tmode
))
5762 gen_int_to_fp_conv_libfunc (tab
, "floatuns", tmode
, fmode
);
5764 gen_int_to_fp_conv_libfunc (tab
, "floatun", tmode
, fmode
);
5767 /* Same as gen_interclass_conv_libfunc but verify that we are producing
5768 fp->int conversion. */
5771 gen_int_to_fp_nondecimal_conv_libfunc (convert_optab tab
,
5773 enum machine_mode tmode
,
5774 enum machine_mode fmode
)
5776 if (GET_MODE_CLASS (fmode
) != MODE_INT
)
5778 if (GET_MODE_CLASS (tmode
) != MODE_FLOAT
)
5780 gen_interclass_conv_libfunc (tab
, opname
, tmode
, fmode
);
5783 /* Same as gen_interclass_conv_libfunc but verify that we are producing
5784 fp->int conversion with no decimal floating point involved. */
5787 gen_fp_to_int_conv_libfunc (convert_optab tab
,
5789 enum machine_mode tmode
,
5790 enum machine_mode fmode
)
5792 if (GET_MODE_CLASS (fmode
) != MODE_FLOAT
&& !DECIMAL_FLOAT_MODE_P (fmode
))
5794 if (GET_MODE_CLASS (tmode
) != MODE_INT
)
5796 gen_interclass_conv_libfunc (tab
, opname
, tmode
, fmode
);
5799 /* Initialize the libfunc fields of an of an intra-mode-class conversion optab.
5800 The string formation rules are
5801 similar to the ones for init_libfunc, above. */
5804 gen_intraclass_conv_libfunc (convert_optab tab
, const char *opname
,
5805 enum machine_mode tmode
, enum machine_mode fmode
)
5807 size_t opname_len
= strlen (opname
);
5808 size_t mname_len
= 0;
5810 const char *fname
, *tname
;
5812 int prefix_len
= targetm
.libfunc_gnu_prefix
? 6 : 2;
5813 char *nondec_name
, *dec_name
, *nondec_suffix
, *dec_suffix
;
5814 char *libfunc_name
, *suffix
;
5817 /* If this is a decimal conversion, add the current BID vs. DPD prefix that
5818 depends on which underlying decimal floating point format is used. */
5819 const size_t dec_len
= sizeof (DECIMAL_PREFIX
) - 1;
5821 mname_len
= strlen (GET_MODE_NAME (tmode
)) + strlen (GET_MODE_NAME (fmode
));
5823 nondec_name
= XALLOCAVEC (char, 2 + opname_len
+ mname_len
+ 1 + 1);
5824 nondec_name
[0] = '_';
5825 nondec_name
[1] = '_';
5826 if (targetm
.libfunc_gnu_prefix
)
5828 nondec_name
[2] = 'g';
5829 nondec_name
[3] = 'n';
5830 nondec_name
[4] = 'u';
5831 nondec_name
[5] = '_';
5833 memcpy (&nondec_name
[prefix_len
], opname
, opname_len
);
5834 nondec_suffix
= nondec_name
+ opname_len
+ prefix_len
;
5836 dec_name
= XALLOCAVEC (char, 2 + dec_len
+ opname_len
+ mname_len
+ 1 + 1);
5839 memcpy (&dec_name
[2], DECIMAL_PREFIX
, dec_len
);
5840 memcpy (&dec_name
[2 + dec_len
], opname
, opname_len
);
5841 dec_suffix
= dec_name
+ dec_len
+ opname_len
+ 2;
5843 fname
= GET_MODE_NAME (fmode
);
5844 tname
= GET_MODE_NAME (tmode
);
5846 if (DECIMAL_FLOAT_MODE_P (fmode
) || DECIMAL_FLOAT_MODE_P (tmode
))
5848 libfunc_name
= dec_name
;
5849 suffix
= dec_suffix
;
5853 libfunc_name
= nondec_name
;
5854 suffix
= nondec_suffix
;
5858 for (q
= fname
; *q
; p
++, q
++)
5860 for (q
= tname
; *q
; p
++, q
++)
5866 set_conv_libfunc (tab
, tmode
, fmode
,
5867 ggc_alloc_string (libfunc_name
, p
- libfunc_name
));
5870 /* Pick proper libcall for trunc_optab. We need to chose if we do
5871 truncation or extension and interclass or intraclass. */
5874 gen_trunc_conv_libfunc (convert_optab tab
,
5876 enum machine_mode tmode
,
5877 enum machine_mode fmode
)
5879 if (GET_MODE_CLASS (tmode
) != MODE_FLOAT
&& !DECIMAL_FLOAT_MODE_P (tmode
))
5881 if (GET_MODE_CLASS (fmode
) != MODE_FLOAT
&& !DECIMAL_FLOAT_MODE_P (fmode
))
5886 if ((GET_MODE_CLASS (tmode
) == MODE_FLOAT
&& DECIMAL_FLOAT_MODE_P (fmode
))
5887 || (GET_MODE_CLASS (fmode
) == MODE_FLOAT
&& DECIMAL_FLOAT_MODE_P (tmode
)))
5888 gen_interclass_conv_libfunc (tab
, opname
, tmode
, fmode
);
5890 if (GET_MODE_PRECISION (fmode
) <= GET_MODE_PRECISION (tmode
))
5893 if ((GET_MODE_CLASS (tmode
) == MODE_FLOAT
5894 && GET_MODE_CLASS (fmode
) == MODE_FLOAT
)
5895 || (DECIMAL_FLOAT_MODE_P (fmode
) && DECIMAL_FLOAT_MODE_P (tmode
)))
5896 gen_intraclass_conv_libfunc (tab
, opname
, tmode
, fmode
);
5899 /* Pick proper libcall for extend_optab. We need to chose if we do
5900 truncation or extension and interclass or intraclass. */
5903 gen_extend_conv_libfunc (convert_optab tab
,
5904 const char *opname ATTRIBUTE_UNUSED
,
5905 enum machine_mode tmode
,
5906 enum machine_mode fmode
)
5908 if (GET_MODE_CLASS (tmode
) != MODE_FLOAT
&& !DECIMAL_FLOAT_MODE_P (tmode
))
5910 if (GET_MODE_CLASS (fmode
) != MODE_FLOAT
&& !DECIMAL_FLOAT_MODE_P (fmode
))
5915 if ((GET_MODE_CLASS (tmode
) == MODE_FLOAT
&& DECIMAL_FLOAT_MODE_P (fmode
))
5916 || (GET_MODE_CLASS (fmode
) == MODE_FLOAT
&& DECIMAL_FLOAT_MODE_P (tmode
)))
5917 gen_interclass_conv_libfunc (tab
, opname
, tmode
, fmode
);
5919 if (GET_MODE_PRECISION (fmode
) > GET_MODE_PRECISION (tmode
))
5922 if ((GET_MODE_CLASS (tmode
) == MODE_FLOAT
5923 && GET_MODE_CLASS (fmode
) == MODE_FLOAT
)
5924 || (DECIMAL_FLOAT_MODE_P (fmode
) && DECIMAL_FLOAT_MODE_P (tmode
)))
5925 gen_intraclass_conv_libfunc (tab
, opname
, tmode
, fmode
);
5928 /* Pick proper libcall for fract_optab. We need to chose if we do
5929 interclass or intraclass. */
5932 gen_fract_conv_libfunc (convert_optab tab
,
5934 enum machine_mode tmode
,
5935 enum machine_mode fmode
)
5939 if (!(ALL_FIXED_POINT_MODE_P (tmode
) || ALL_FIXED_POINT_MODE_P (fmode
)))
5942 if (GET_MODE_CLASS (tmode
) == GET_MODE_CLASS (fmode
))
5943 gen_intraclass_conv_libfunc (tab
, opname
, tmode
, fmode
);
5945 gen_interclass_conv_libfunc (tab
, opname
, tmode
, fmode
);
5948 /* Pick proper libcall for fractuns_optab. */
5951 gen_fractuns_conv_libfunc (convert_optab tab
,
5953 enum machine_mode tmode
,
5954 enum machine_mode fmode
)
5958 /* One mode must be a fixed-point mode, and the other must be an integer
5960 if (!((ALL_FIXED_POINT_MODE_P (tmode
) && GET_MODE_CLASS (fmode
) == MODE_INT
)
5961 || (ALL_FIXED_POINT_MODE_P (fmode
)
5962 && GET_MODE_CLASS (tmode
) == MODE_INT
)))
5965 gen_interclass_conv_libfunc (tab
, opname
, tmode
, fmode
);
5968 /* Pick proper libcall for satfract_optab. We need to chose if we do
5969 interclass or intraclass. */
5972 gen_satfract_conv_libfunc (convert_optab tab
,
5974 enum machine_mode tmode
,
5975 enum machine_mode fmode
)
5979 /* TMODE must be a fixed-point mode. */
5980 if (!ALL_FIXED_POINT_MODE_P (tmode
))
5983 if (GET_MODE_CLASS (tmode
) == GET_MODE_CLASS (fmode
))
5984 gen_intraclass_conv_libfunc (tab
, opname
, tmode
, fmode
);
5986 gen_interclass_conv_libfunc (tab
, opname
, tmode
, fmode
);
5989 /* Pick proper libcall for satfractuns_optab. */
5992 gen_satfractuns_conv_libfunc (convert_optab tab
,
5994 enum machine_mode tmode
,
5995 enum machine_mode fmode
)
5999 /* TMODE must be a fixed-point mode, and FMODE must be an integer mode. */
6000 if (!(ALL_FIXED_POINT_MODE_P (tmode
) && GET_MODE_CLASS (fmode
) == MODE_INT
))
6003 gen_interclass_conv_libfunc (tab
, opname
, tmode
, fmode
);
6006 /* A table of previously-created libfuncs, hashed by name. */
6007 static GTY ((param_is (union tree_node
))) htab_t libfunc_decls
;
6009 /* Hashtable callbacks for libfunc_decls. */
6012 libfunc_decl_hash (const void *entry
)
6014 return IDENTIFIER_HASH_VALUE (DECL_NAME ((const_tree
) entry
));
6018 libfunc_decl_eq (const void *entry1
, const void *entry2
)
6020 return DECL_NAME ((const_tree
) entry1
) == (const_tree
) entry2
;
6023 /* Build a decl for a libfunc named NAME. */
6026 build_libfunc_function (const char *name
)
6028 tree decl
= build_decl (UNKNOWN_LOCATION
, FUNCTION_DECL
,
6029 get_identifier (name
),
6030 build_function_type (integer_type_node
, NULL_TREE
));
6031 /* ??? We don't have any type information except for this is
6032 a function. Pretend this is "int foo()". */
6033 DECL_ARTIFICIAL (decl
) = 1;
6034 DECL_EXTERNAL (decl
) = 1;
6035 TREE_PUBLIC (decl
) = 1;
6036 gcc_assert (DECL_ASSEMBLER_NAME (decl
));
6038 /* Zap the nonsensical SYMBOL_REF_DECL for this. What we're left with
6039 are the flags assigned by targetm.encode_section_info. */
6040 SET_SYMBOL_REF_DECL (XEXP (DECL_RTL (decl
), 0), NULL
);
6046 init_one_libfunc (const char *name
)
6052 if (libfunc_decls
== NULL
)
6053 libfunc_decls
= htab_create_ggc (37, libfunc_decl_hash
,
6054 libfunc_decl_eq
, NULL
);
6056 /* See if we have already created a libfunc decl for this function. */
6057 id
= get_identifier (name
);
6058 hash
= IDENTIFIER_HASH_VALUE (id
);
6059 slot
= htab_find_slot_with_hash (libfunc_decls
, id
, hash
, INSERT
);
6060 decl
= (tree
) *slot
;
6063 /* Create a new decl, so that it can be passed to
6064 targetm.encode_section_info. */
6065 decl
= build_libfunc_function (name
);
6068 return XEXP (DECL_RTL (decl
), 0);
6071 /* Adjust the assembler name of libfunc NAME to ASMSPEC. */
6074 set_user_assembler_libfunc (const char *name
, const char *asmspec
)
6080 id
= get_identifier (name
);
6081 hash
= IDENTIFIER_HASH_VALUE (id
);
6082 slot
= htab_find_slot_with_hash (libfunc_decls
, id
, hash
, NO_INSERT
);
6084 decl
= (tree
) *slot
;
6085 set_user_assembler_name (decl
, asmspec
);
6086 return XEXP (DECL_RTL (decl
), 0);
6089 /* Call this to reset the function entry for one optab (OPTABLE) in mode
6090 MODE to NAME, which should be either 0 or a string constant. */
6092 set_optab_libfunc (optab op
, enum machine_mode mode
, const char *name
)
6095 struct libfunc_entry e
;
6096 struct libfunc_entry
**slot
;
6103 val
= init_one_libfunc (name
);
6106 slot
= (struct libfunc_entry
**) htab_find_slot (libfunc_hash
, &e
, INSERT
);
6108 *slot
= ggc_alloc_libfunc_entry ();
6110 (*slot
)->mode1
= mode
;
6111 (*slot
)->mode2
= VOIDmode
;
6112 (*slot
)->libfunc
= val
;
6115 /* Call this to reset the function entry for one conversion optab
6116 (OPTABLE) from mode FMODE to mode TMODE to NAME, which should be
6117 either 0 or a string constant. */
6119 set_conv_libfunc (convert_optab optab
, enum machine_mode tmode
,
6120 enum machine_mode fmode
, const char *name
)
6123 struct libfunc_entry e
;
6124 struct libfunc_entry
**slot
;
6131 val
= init_one_libfunc (name
);
6134 slot
= (struct libfunc_entry
**) htab_find_slot (libfunc_hash
, &e
, INSERT
);
6136 *slot
= ggc_alloc_libfunc_entry ();
6137 (*slot
)->op
= optab
;
6138 (*slot
)->mode1
= tmode
;
6139 (*slot
)->mode2
= fmode
;
6140 (*slot
)->libfunc
= val
;
6143 /* Call this to initialize the contents of the optabs
6144 appropriately for the current target machine. */
6150 htab_empty (libfunc_hash
);
6152 libfunc_hash
= htab_create_ggc (10, hash_libfunc
, eq_libfunc
, NULL
);
6154 /* Fill in the optabs with the insns we support. */
6155 init_all_optabs (this_fn_optabs
);
6157 /* The ffs function operates on `int'. Fall back on it if we do not
6158 have a libgcc2 function for that width. */
6159 if (INT_TYPE_SIZE
< BITS_PER_WORD
)
6160 set_optab_libfunc (ffs_optab
, mode_for_size (INT_TYPE_SIZE
, MODE_INT
, 0),
6163 /* Explicitly initialize the bswap libfuncs since we need them to be
6164 valid for things other than word_mode. */
6165 if (targetm
.libfunc_gnu_prefix
)
6167 set_optab_libfunc (bswap_optab
, SImode
, "__gnu_bswapsi2");
6168 set_optab_libfunc (bswap_optab
, DImode
, "__gnu_bswapdi2");
6172 set_optab_libfunc (bswap_optab
, SImode
, "__bswapsi2");
6173 set_optab_libfunc (bswap_optab
, DImode
, "__bswapdi2");
6176 /* Use cabs for double complex abs, since systems generally have cabs.
6177 Don't define any libcall for float complex, so that cabs will be used. */
6178 if (complex_double_type_node
)
6179 set_optab_libfunc (abs_optab
, TYPE_MODE (complex_double_type_node
),
6182 abort_libfunc
= init_one_libfunc ("abort");
6183 memcpy_libfunc
= init_one_libfunc ("memcpy");
6184 memmove_libfunc
= init_one_libfunc ("memmove");
6185 memcmp_libfunc
= init_one_libfunc ("memcmp");
6186 memset_libfunc
= init_one_libfunc ("memset");
6187 setbits_libfunc
= init_one_libfunc ("__setbits");
6189 #ifndef DONT_USE_BUILTIN_SETJMP
6190 setjmp_libfunc
= init_one_libfunc ("__builtin_setjmp");
6191 longjmp_libfunc
= init_one_libfunc ("__builtin_longjmp");
6193 setjmp_libfunc
= init_one_libfunc ("setjmp");
6194 longjmp_libfunc
= init_one_libfunc ("longjmp");
6196 unwind_sjlj_register_libfunc
= init_one_libfunc ("_Unwind_SjLj_Register");
6197 unwind_sjlj_unregister_libfunc
6198 = init_one_libfunc ("_Unwind_SjLj_Unregister");
6200 /* For function entry/exit instrumentation. */
6201 profile_function_entry_libfunc
6202 = init_one_libfunc ("__cyg_profile_func_enter");
6203 profile_function_exit_libfunc
6204 = init_one_libfunc ("__cyg_profile_func_exit");
6206 gcov_flush_libfunc
= init_one_libfunc ("__gcov_flush");
6208 /* Allow the target to add more libcalls or rename some, etc. */
6209 targetm
.init_libfuncs ();
6212 /* Use the current target and options to initialize
6213 TREE_OPTIMIZATION_OPTABS (OPTNODE). */
6216 init_tree_optimization_optabs (tree optnode
)
6218 /* Quick exit if we have already computed optabs for this target. */
6219 if (TREE_OPTIMIZATION_BASE_OPTABS (optnode
) == this_target_optabs
)
6222 /* Forget any previous information and set up for the current target. */
6223 TREE_OPTIMIZATION_BASE_OPTABS (optnode
) = this_target_optabs
;
6224 struct target_optabs
*tmp_optabs
= (struct target_optabs
*)
6225 TREE_OPTIMIZATION_OPTABS (optnode
);
6227 memset (tmp_optabs
, 0, sizeof (struct target_optabs
));
6229 tmp_optabs
= (struct target_optabs
*)
6230 ggc_alloc_atomic (sizeof (struct target_optabs
));
6232 /* Generate a new set of optabs into tmp_optabs. */
6233 init_all_optabs (tmp_optabs
);
6235 /* If the optabs changed, record it. */
6236 if (memcmp (tmp_optabs
, this_target_optabs
, sizeof (struct target_optabs
)))
6237 TREE_OPTIMIZATION_OPTABS (optnode
) = (unsigned char *) tmp_optabs
;
6240 TREE_OPTIMIZATION_OPTABS (optnode
) = NULL
;
6241 ggc_free (tmp_optabs
);
6245 /* A helper function for init_sync_libfuncs. Using the basename BASE,
6246 install libfuncs into TAB for BASE_N for 1 <= N <= MAX. */
6249 init_sync_libfuncs_1 (optab tab
, const char *base
, int max
)
6251 enum machine_mode mode
;
6253 size_t len
= strlen (base
);
6256 gcc_assert (max
<= 8);
6257 gcc_assert (len
+ 3 < sizeof (buf
));
6259 memcpy (buf
, base
, len
);
6262 buf
[len
+ 2] = '\0';
6265 for (i
= 1; i
<= max
; i
*= 2)
6267 buf
[len
+ 1] = '0' + i
;
6268 set_optab_libfunc (tab
, mode
, buf
);
6269 mode
= GET_MODE_2XWIDER_MODE (mode
);
6274 init_sync_libfuncs (int max
)
6276 if (!flag_sync_libcalls
)
6279 init_sync_libfuncs_1 (sync_compare_and_swap_optab
,
6280 "__sync_val_compare_and_swap", max
);
6281 init_sync_libfuncs_1 (sync_lock_test_and_set_optab
,
6282 "__sync_lock_test_and_set", max
);
6284 init_sync_libfuncs_1 (sync_old_add_optab
, "__sync_fetch_and_add", max
);
6285 init_sync_libfuncs_1 (sync_old_sub_optab
, "__sync_fetch_and_sub", max
);
6286 init_sync_libfuncs_1 (sync_old_ior_optab
, "__sync_fetch_and_or", max
);
6287 init_sync_libfuncs_1 (sync_old_and_optab
, "__sync_fetch_and_and", max
);
6288 init_sync_libfuncs_1 (sync_old_xor_optab
, "__sync_fetch_and_xor", max
);
6289 init_sync_libfuncs_1 (sync_old_nand_optab
, "__sync_fetch_and_nand", max
);
6291 init_sync_libfuncs_1 (sync_new_add_optab
, "__sync_add_and_fetch", max
);
6292 init_sync_libfuncs_1 (sync_new_sub_optab
, "__sync_sub_and_fetch", max
);
6293 init_sync_libfuncs_1 (sync_new_ior_optab
, "__sync_or_and_fetch", max
);
6294 init_sync_libfuncs_1 (sync_new_and_optab
, "__sync_and_and_fetch", max
);
6295 init_sync_libfuncs_1 (sync_new_xor_optab
, "__sync_xor_and_fetch", max
);
6296 init_sync_libfuncs_1 (sync_new_nand_optab
, "__sync_nand_and_fetch", max
);
6299 /* Print information about the current contents of the optabs on
6303 debug_optab_libfuncs (void)
6307 /* Dump the arithmetic optabs. */
6308 for (i
= FIRST_NORM_OPTAB
; i
<= LAST_NORMLIB_OPTAB
; ++i
)
6309 for (j
= 0; j
< NUM_MACHINE_MODES
; ++j
)
6311 rtx l
= optab_libfunc ((optab
) i
, (enum machine_mode
) j
);
6314 gcc_assert (GET_CODE (l
) == SYMBOL_REF
);
6315 fprintf (stderr
, "%s\t%s:\t%s\n",
6316 GET_RTX_NAME (optab_to_code ((optab
) i
)),
6322 /* Dump the conversion optabs. */
6323 for (i
= FIRST_CONV_OPTAB
; i
<= LAST_CONVLIB_OPTAB
; ++i
)
6324 for (j
= 0; j
< NUM_MACHINE_MODES
; ++j
)
6325 for (k
= 0; k
< NUM_MACHINE_MODES
; ++k
)
6327 rtx l
= convert_optab_libfunc ((optab
) i
, (enum machine_mode
) j
,
6328 (enum machine_mode
) k
);
6331 gcc_assert (GET_CODE (l
) == SYMBOL_REF
);
6332 fprintf (stderr
, "%s\t%s\t%s:\t%s\n",
6333 GET_RTX_NAME (optab_to_code ((optab
) i
)),
6342 /* Generate insns to trap with code TCODE if OP1 and OP2 satisfy condition
6343 CODE. Return 0 on failure. */
6346 gen_cond_trap (enum rtx_code code
, rtx op1
, rtx op2
, rtx tcode
)
6348 enum machine_mode mode
= GET_MODE (op1
);
6349 enum insn_code icode
;
6353 if (mode
== VOIDmode
)
6356 icode
= optab_handler (ctrap_optab
, mode
);
6357 if (icode
== CODE_FOR_nothing
)
6360 /* Some targets only accept a zero trap code. */
6361 if (!insn_operand_matches (icode
, 3, tcode
))
6364 do_pending_stack_adjust ();
6366 prepare_cmp_insn (op1
, op2
, code
, NULL_RTX
, false, OPTAB_DIRECT
,
6371 insn
= GEN_FCN (icode
) (trap_rtx
, XEXP (trap_rtx
, 0), XEXP (trap_rtx
, 1),
6374 /* If that failed, then give up. */
6382 insn
= get_insns ();
6387 /* Return rtx code for TCODE. Use UNSIGNEDP to select signed
6388 or unsigned operation code. */
6390 static enum rtx_code
6391 get_rtx_code (enum tree_code tcode
, bool unsignedp
)
6403 code
= unsignedp
? LTU
: LT
;
6406 code
= unsignedp
? LEU
: LE
;
6409 code
= unsignedp
? GTU
: GT
;
6412 code
= unsignedp
? GEU
: GE
;
6415 case UNORDERED_EXPR
:
6446 /* Return comparison rtx for COND. Use UNSIGNEDP to select signed or
6447 unsigned operators. Do not generate compare instruction. */
6450 vector_compare_rtx (enum tree_code tcode
, tree t_op0
, tree t_op1
,
6451 bool unsignedp
, enum insn_code icode
)
6453 struct expand_operand ops
[2];
6454 rtx rtx_op0
, rtx_op1
;
6455 enum rtx_code rcode
= get_rtx_code (tcode
, unsignedp
);
6457 gcc_assert (TREE_CODE_CLASS (tcode
) == tcc_comparison
);
6459 /* Expand operands. */
6460 rtx_op0
= expand_expr (t_op0
, NULL_RTX
, TYPE_MODE (TREE_TYPE (t_op0
)),
6462 rtx_op1
= expand_expr (t_op1
, NULL_RTX
, TYPE_MODE (TREE_TYPE (t_op1
)),
6465 create_input_operand (&ops
[0], rtx_op0
, GET_MODE (rtx_op0
));
6466 create_input_operand (&ops
[1], rtx_op1
, GET_MODE (rtx_op1
));
6467 if (!maybe_legitimize_operands (icode
, 4, 2, ops
))
6469 return gen_rtx_fmt_ee (rcode
, VOIDmode
, ops
[0].value
, ops
[1].value
);
6472 /* Return true if VEC_PERM_EXPR can be expanded using SIMD extensions
6473 of the CPU. SEL may be NULL, which stands for an unknown constant. */
6476 can_vec_perm_p (enum machine_mode mode
, bool variable
,
6477 const unsigned char *sel
)
6479 enum machine_mode qimode
;
6481 /* If the target doesn't implement a vector mode for the vector type,
6482 then no operations are supported. */
6483 if (!VECTOR_MODE_P (mode
))
6488 if (direct_optab_handler (vec_perm_const_optab
, mode
) != CODE_FOR_nothing
6490 || targetm
.vectorize
.vec_perm_const_ok
== NULL
6491 || targetm
.vectorize
.vec_perm_const_ok (mode
, sel
)))
6495 if (direct_optab_handler (vec_perm_optab
, mode
) != CODE_FOR_nothing
)
6498 /* We allow fallback to a QI vector mode, and adjust the mask. */
6499 if (GET_MODE_INNER (mode
) == QImode
)
6501 qimode
= mode_for_vector (QImode
, GET_MODE_SIZE (mode
));
6502 if (!VECTOR_MODE_P (qimode
))
6505 /* ??? For completeness, we ought to check the QImode version of
6506 vec_perm_const_optab. But all users of this implicit lowering
6507 feature implement the variable vec_perm_optab. */
6508 if (direct_optab_handler (vec_perm_optab
, qimode
) == CODE_FOR_nothing
)
6511 /* In order to support the lowering of variable permutations,
6512 we need to support shifts and adds. */
6515 if (GET_MODE_UNIT_SIZE (mode
) > 2
6516 && optab_handler (ashl_optab
, mode
) == CODE_FOR_nothing
6517 && optab_handler (vashl_optab
, mode
) == CODE_FOR_nothing
)
6519 if (optab_handler (add_optab
, qimode
) == CODE_FOR_nothing
)
6526 /* A subroutine of expand_vec_perm for expanding one vec_perm insn. */
6529 expand_vec_perm_1 (enum insn_code icode
, rtx target
,
6530 rtx v0
, rtx v1
, rtx sel
)
6532 enum machine_mode tmode
= GET_MODE (target
);
6533 enum machine_mode smode
= GET_MODE (sel
);
6534 struct expand_operand ops
[4];
6536 create_output_operand (&ops
[0], target
, tmode
);
6537 create_input_operand (&ops
[3], sel
, smode
);
6539 /* Make an effort to preserve v0 == v1. The target expander is able to
6540 rely on this to determine if we're permuting a single input operand. */
6541 if (rtx_equal_p (v0
, v1
))
6543 if (!insn_operand_matches (icode
, 1, v0
))
6544 v0
= force_reg (tmode
, v0
);
6545 gcc_checking_assert (insn_operand_matches (icode
, 1, v0
));
6546 gcc_checking_assert (insn_operand_matches (icode
, 2, v0
));
6548 create_fixed_operand (&ops
[1], v0
);
6549 create_fixed_operand (&ops
[2], v0
);
6553 create_input_operand (&ops
[1], v0
, tmode
);
6554 create_input_operand (&ops
[2], v1
, tmode
);
6557 if (maybe_expand_insn (icode
, 4, ops
))
6558 return ops
[0].value
;
6562 /* Generate instructions for vec_perm optab given its mode
6563 and three operands. */
6566 expand_vec_perm (enum machine_mode mode
, rtx v0
, rtx v1
, rtx sel
, rtx target
)
6568 enum insn_code icode
;
6569 enum machine_mode qimode
;
6570 unsigned int i
, w
, e
, u
;
6571 rtx tmp
, sel_qi
= NULL
;
6574 if (!target
|| GET_MODE (target
) != mode
)
6575 target
= gen_reg_rtx (mode
);
6577 w
= GET_MODE_SIZE (mode
);
6578 e
= GET_MODE_NUNITS (mode
);
6579 u
= GET_MODE_UNIT_SIZE (mode
);
6581 /* Set QIMODE to a different vector mode with byte elements.
6582 If no such mode, or if MODE already has byte elements, use VOIDmode. */
6584 if (GET_MODE_INNER (mode
) != QImode
)
6586 qimode
= mode_for_vector (QImode
, w
);
6587 if (!VECTOR_MODE_P (qimode
))
6591 /* If the input is a constant, expand it specially. */
6592 gcc_assert (GET_MODE_CLASS (GET_MODE (sel
)) == MODE_VECTOR_INT
);
6593 if (GET_CODE (sel
) == CONST_VECTOR
)
6595 icode
= direct_optab_handler (vec_perm_const_optab
, mode
);
6596 if (icode
!= CODE_FOR_nothing
)
6598 tmp
= expand_vec_perm_1 (icode
, target
, v0
, v1
, sel
);
6603 /* Fall back to a constant byte-based permutation. */
6604 if (qimode
!= VOIDmode
)
6606 vec
= rtvec_alloc (w
);
6607 for (i
= 0; i
< e
; ++i
)
6609 unsigned int j
, this_e
;
6611 this_e
= INTVAL (CONST_VECTOR_ELT (sel
, i
));
6612 this_e
&= 2 * e
- 1;
6615 for (j
= 0; j
< u
; ++j
)
6616 RTVEC_ELT (vec
, i
* u
+ j
) = GEN_INT (this_e
+ j
);
6618 sel_qi
= gen_rtx_CONST_VECTOR (qimode
, vec
);
6620 icode
= direct_optab_handler (vec_perm_const_optab
, qimode
);
6621 if (icode
!= CODE_FOR_nothing
)
6623 tmp
= expand_vec_perm_1 (icode
, gen_lowpart (qimode
, target
),
6624 gen_lowpart (qimode
, v0
),
6625 gen_lowpart (qimode
, v1
), sel_qi
);
6627 return gen_lowpart (mode
, tmp
);
6632 /* Otherwise expand as a fully variable permuation. */
6633 icode
= direct_optab_handler (vec_perm_optab
, mode
);
6634 if (icode
!= CODE_FOR_nothing
)
6636 tmp
= expand_vec_perm_1 (icode
, target
, v0
, v1
, sel
);
6641 /* As a special case to aid several targets, lower the element-based
6642 permutation to a byte-based permutation and try again. */
6643 if (qimode
== VOIDmode
)
6645 icode
= direct_optab_handler (vec_perm_optab
, qimode
);
6646 if (icode
== CODE_FOR_nothing
)
6651 /* Multiply each element by its byte size. */
6652 enum machine_mode selmode
= GET_MODE (sel
);
6654 sel
= expand_simple_binop (selmode
, PLUS
, sel
, sel
,
6655 sel
, 0, OPTAB_DIRECT
);
6657 sel
= expand_simple_binop (selmode
, ASHIFT
, sel
,
6658 GEN_INT (exact_log2 (u
)),
6659 sel
, 0, OPTAB_DIRECT
);
6660 gcc_assert (sel
!= NULL
);
6662 /* Broadcast the low byte each element into each of its bytes. */
6663 vec
= rtvec_alloc (w
);
6664 for (i
= 0; i
< w
; ++i
)
6666 int this_e
= i
/ u
* u
;
6667 if (BYTES_BIG_ENDIAN
)
6669 RTVEC_ELT (vec
, i
) = GEN_INT (this_e
);
6671 tmp
= gen_rtx_CONST_VECTOR (qimode
, vec
);
6672 sel
= gen_lowpart (qimode
, sel
);
6673 sel
= expand_vec_perm (qimode
, sel
, sel
, tmp
, NULL
);
6674 gcc_assert (sel
!= NULL
);
6676 /* Add the byte offset to each byte element. */
6677 /* Note that the definition of the indicies here is memory ordering,
6678 so there should be no difference between big and little endian. */
6679 vec
= rtvec_alloc (w
);
6680 for (i
= 0; i
< w
; ++i
)
6681 RTVEC_ELT (vec
, i
) = GEN_INT (i
% u
);
6682 tmp
= gen_rtx_CONST_VECTOR (qimode
, vec
);
6683 sel_qi
= expand_simple_binop (qimode
, PLUS
, sel
, tmp
,
6684 sel
, 0, OPTAB_DIRECT
);
6685 gcc_assert (sel_qi
!= NULL
);
6688 tmp
= expand_vec_perm_1 (icode
, gen_lowpart (qimode
, target
),
6689 gen_lowpart (qimode
, v0
),
6690 gen_lowpart (qimode
, v1
), sel_qi
);
6692 tmp
= gen_lowpart (mode
, tmp
);
6696 /* Return insn code for a conditional operator with a comparison in
6697 mode CMODE, unsigned if UNS is true, resulting in a value of mode VMODE. */
6699 static inline enum insn_code
6700 get_vcond_icode (enum machine_mode vmode
, enum machine_mode cmode
, bool uns
)
6702 enum insn_code icode
= CODE_FOR_nothing
;
6704 icode
= convert_optab_handler (vcondu_optab
, vmode
, cmode
);
6706 icode
= convert_optab_handler (vcond_optab
, vmode
, cmode
);
6710 /* Return TRUE iff, appropriate vector insns are available
6711 for vector cond expr with vector type VALUE_TYPE and a comparison
6712 with operand vector types in CMP_OP_TYPE. */
6715 expand_vec_cond_expr_p (tree value_type
, tree cmp_op_type
)
6717 enum machine_mode value_mode
= TYPE_MODE (value_type
);
6718 enum machine_mode cmp_op_mode
= TYPE_MODE (cmp_op_type
);
6719 if (GET_MODE_SIZE (value_mode
) != GET_MODE_SIZE (cmp_op_mode
)
6720 || GET_MODE_NUNITS (value_mode
) != GET_MODE_NUNITS (cmp_op_mode
)
6721 || get_vcond_icode (TYPE_MODE (value_type
), TYPE_MODE (cmp_op_type
),
6722 TYPE_UNSIGNED (cmp_op_type
)) == CODE_FOR_nothing
)
6727 /* Generate insns for a VEC_COND_EXPR, given its TYPE and its
6731 expand_vec_cond_expr (tree vec_cond_type
, tree op0
, tree op1
, tree op2
,
6734 struct expand_operand ops
[6];
6735 enum insn_code icode
;
6736 rtx comparison
, rtx_op1
, rtx_op2
;
6737 enum machine_mode mode
= TYPE_MODE (vec_cond_type
);
6738 enum machine_mode cmp_op_mode
;
6741 enum tree_code tcode
;
6743 if (COMPARISON_CLASS_P (op0
))
6745 op0a
= TREE_OPERAND (op0
, 0);
6746 op0b
= TREE_OPERAND (op0
, 1);
6747 tcode
= TREE_CODE (op0
);
6752 gcc_assert (!TYPE_UNSIGNED (TREE_TYPE (op0
)));
6754 op0b
= build_zero_cst (TREE_TYPE (op0
));
6757 unsignedp
= TYPE_UNSIGNED (TREE_TYPE (op0a
));
6758 cmp_op_mode
= TYPE_MODE (TREE_TYPE (op0a
));
6761 gcc_assert (GET_MODE_SIZE (mode
) == GET_MODE_SIZE (cmp_op_mode
)
6762 && GET_MODE_NUNITS (mode
) == GET_MODE_NUNITS (cmp_op_mode
));
6764 icode
= get_vcond_icode (mode
, cmp_op_mode
, unsignedp
);
6765 if (icode
== CODE_FOR_nothing
)
6768 comparison
= vector_compare_rtx (tcode
, op0a
, op0b
, unsignedp
, icode
);
6769 rtx_op1
= expand_normal (op1
);
6770 rtx_op2
= expand_normal (op2
);
6772 create_output_operand (&ops
[0], target
, mode
);
6773 create_input_operand (&ops
[1], rtx_op1
, mode
);
6774 create_input_operand (&ops
[2], rtx_op2
, mode
);
6775 create_fixed_operand (&ops
[3], comparison
);
6776 create_fixed_operand (&ops
[4], XEXP (comparison
, 0));
6777 create_fixed_operand (&ops
[5], XEXP (comparison
, 1));
6778 expand_insn (icode
, 6, ops
);
6779 return ops
[0].value
;
6782 /* Return non-zero if a highpart multiply is supported of can be synthisized.
6783 For the benefit of expand_mult_highpart, the return value is 1 for direct,
6784 2 for even/odd widening, and 3 for hi/lo widening. */
6787 can_mult_highpart_p (enum machine_mode mode
, bool uns_p
)
6793 op
= uns_p
? umul_highpart_optab
: smul_highpart_optab
;
6794 if (optab_handler (op
, mode
) != CODE_FOR_nothing
)
6797 /* If the mode is an integral vector, synth from widening operations. */
6798 if (GET_MODE_CLASS (mode
) != MODE_VECTOR_INT
)
6801 nunits
= GET_MODE_NUNITS (mode
);
6802 sel
= XALLOCAVEC (unsigned char, nunits
);
6804 op
= uns_p
? vec_widen_umult_even_optab
: vec_widen_smult_even_optab
;
6805 if (optab_handler (op
, mode
) != CODE_FOR_nothing
)
6807 op
= uns_p
? vec_widen_umult_odd_optab
: vec_widen_smult_odd_optab
;
6808 if (optab_handler (op
, mode
) != CODE_FOR_nothing
)
6810 for (i
= 0; i
< nunits
; ++i
)
6811 sel
[i
] = !BYTES_BIG_ENDIAN
+ (i
& ~1) + ((i
& 1) ? nunits
: 0);
6812 if (can_vec_perm_p (mode
, false, sel
))
6817 op
= uns_p
? vec_widen_umult_hi_optab
: vec_widen_smult_hi_optab
;
6818 if (optab_handler (op
, mode
) != CODE_FOR_nothing
)
6820 op
= uns_p
? vec_widen_umult_lo_optab
: vec_widen_smult_lo_optab
;
6821 if (optab_handler (op
, mode
) != CODE_FOR_nothing
)
6823 for (i
= 0; i
< nunits
; ++i
)
6824 sel
[i
] = 2 * i
+ (BYTES_BIG_ENDIAN
? 0 : 1);
6825 if (can_vec_perm_p (mode
, false, sel
))
6833 /* Expand a highpart multiply. */
6836 expand_mult_highpart (enum machine_mode mode
, rtx op0
, rtx op1
,
6837 rtx target
, bool uns_p
)
6839 struct expand_operand eops
[3];
6840 enum insn_code icode
;
6841 int method
, i
, nunits
;
6842 enum machine_mode wmode
;
6847 method
= can_mult_highpart_p (mode
, uns_p
);
6853 tab1
= uns_p
? umul_highpart_optab
: smul_highpart_optab
;
6854 return expand_binop (mode
, tab1
, op0
, op1
, target
, uns_p
,
6857 tab1
= uns_p
? vec_widen_umult_even_optab
: vec_widen_smult_even_optab
;
6858 tab2
= uns_p
? vec_widen_umult_odd_optab
: vec_widen_smult_odd_optab
;
6861 tab1
= uns_p
? vec_widen_umult_lo_optab
: vec_widen_smult_lo_optab
;
6862 tab2
= uns_p
? vec_widen_umult_hi_optab
: vec_widen_smult_hi_optab
;
6863 if (BYTES_BIG_ENDIAN
)
6874 icode
= optab_handler (tab1
, mode
);
6875 nunits
= GET_MODE_NUNITS (mode
);
6876 wmode
= insn_data
[icode
].operand
[0].mode
;
6877 gcc_checking_assert (2 * GET_MODE_NUNITS (wmode
) == nunits
);
6878 gcc_checking_assert (GET_MODE_SIZE (wmode
) == GET_MODE_SIZE (mode
));
6880 create_output_operand (&eops
[0], gen_reg_rtx (wmode
), wmode
);
6881 create_input_operand (&eops
[1], op0
, mode
);
6882 create_input_operand (&eops
[2], op1
, mode
);
6883 expand_insn (icode
, 3, eops
);
6884 m1
= gen_lowpart (mode
, eops
[0].value
);
6886 create_output_operand (&eops
[0], gen_reg_rtx (wmode
), wmode
);
6887 create_input_operand (&eops
[1], op0
, mode
);
6888 create_input_operand (&eops
[2], op1
, mode
);
6889 expand_insn (optab_handler (tab2
, mode
), 3, eops
);
6890 m2
= gen_lowpart (mode
, eops
[0].value
);
6892 v
= rtvec_alloc (nunits
);
6895 for (i
= 0; i
< nunits
; ++i
)
6896 RTVEC_ELT (v
, i
) = GEN_INT (!BYTES_BIG_ENDIAN
+ (i
& ~1)
6897 + ((i
& 1) ? nunits
: 0));
6901 for (i
= 0; i
< nunits
; ++i
)
6902 RTVEC_ELT (v
, i
) = GEN_INT (2 * i
+ (BYTES_BIG_ENDIAN
? 0 : 1));
6904 perm
= gen_rtx_CONST_VECTOR (mode
, v
);
6906 return expand_vec_perm (mode
, m1
, m2
, perm
, target
);
6909 /* Return true if there is a compare_and_swap pattern. */
6912 can_compare_and_swap_p (enum machine_mode mode
, bool allow_libcall
)
6914 enum insn_code icode
;
6916 /* Check for __atomic_compare_and_swap. */
6917 icode
= direct_optab_handler (atomic_compare_and_swap_optab
, mode
);
6918 if (icode
!= CODE_FOR_nothing
)
6921 /* Check for __sync_compare_and_swap. */
6922 icode
= optab_handler (sync_compare_and_swap_optab
, mode
);
6923 if (icode
!= CODE_FOR_nothing
)
6925 if (allow_libcall
&& optab_libfunc (sync_compare_and_swap_optab
, mode
))
6928 /* No inline compare and swap. */
6932 /* Return true if an atomic exchange can be performed. */
6935 can_atomic_exchange_p (enum machine_mode mode
, bool allow_libcall
)
6937 enum insn_code icode
;
6939 /* Check for __atomic_exchange. */
6940 icode
= direct_optab_handler (atomic_exchange_optab
, mode
);
6941 if (icode
!= CODE_FOR_nothing
)
6944 /* Don't check __sync_test_and_set, as on some platforms that
6945 has reduced functionality. Targets that really do support
6946 a proper exchange should simply be updated to the __atomics. */
6948 return can_compare_and_swap_p (mode
, allow_libcall
);
6952 /* Helper function to find the MODE_CC set in a sync_compare_and_swap
6956 find_cc_set (rtx x
, const_rtx pat
, void *data
)
6958 if (REG_P (x
) && GET_MODE_CLASS (GET_MODE (x
)) == MODE_CC
6959 && GET_CODE (pat
) == SET
)
6961 rtx
*p_cc_reg
= (rtx
*) data
;
6962 gcc_assert (!*p_cc_reg
);
6967 /* This is a helper function for the other atomic operations. This function
6968 emits a loop that contains SEQ that iterates until a compare-and-swap
6969 operation at the end succeeds. MEM is the memory to be modified. SEQ is
6970 a set of instructions that takes a value from OLD_REG as an input and
6971 produces a value in NEW_REG as an output. Before SEQ, OLD_REG will be
6972 set to the current contents of MEM. After SEQ, a compare-and-swap will
6973 attempt to update MEM with NEW_REG. The function returns true when the
6974 loop was generated successfully. */
6977 expand_compare_and_swap_loop (rtx mem
, rtx old_reg
, rtx new_reg
, rtx seq
)
6979 enum machine_mode mode
= GET_MODE (mem
);
6980 rtx label
, cmp_reg
, success
, oldval
;
6982 /* The loop we want to generate looks like
6988 (success, cmp_reg) = compare-and-swap(mem, old_reg, new_reg)
6992 Note that we only do the plain load from memory once. Subsequent
6993 iterations use the value loaded by the compare-and-swap pattern. */
6995 label
= gen_label_rtx ();
6996 cmp_reg
= gen_reg_rtx (mode
);
6998 emit_move_insn (cmp_reg
, mem
);
7000 emit_move_insn (old_reg
, cmp_reg
);
7006 if (!expand_atomic_compare_and_swap (&success
, &oldval
, mem
, old_reg
,
7007 new_reg
, false, MEMMODEL_SEQ_CST
,
7011 if (oldval
!= cmp_reg
)
7012 emit_move_insn (cmp_reg
, oldval
);
7014 /* Mark this jump predicted not taken. */
7015 emit_cmp_and_jump_insns (success
, const0_rtx
, EQ
, const0_rtx
,
7016 GET_MODE (success
), 1, label
, 0);
7021 /* This function tries to emit an atomic_exchange intruction. VAL is written
7022 to *MEM using memory model MODEL. The previous contents of *MEM are returned,
7023 using TARGET if possible. */
7026 maybe_emit_atomic_exchange (rtx target
, rtx mem
, rtx val
, enum memmodel model
)
7028 enum machine_mode mode
= GET_MODE (mem
);
7029 enum insn_code icode
;
7031 /* If the target supports the exchange directly, great. */
7032 icode
= direct_optab_handler (atomic_exchange_optab
, mode
);
7033 if (icode
!= CODE_FOR_nothing
)
7035 struct expand_operand ops
[4];
7037 create_output_operand (&ops
[0], target
, mode
);
7038 create_fixed_operand (&ops
[1], mem
);
7039 /* VAL may have been promoted to a wider mode. Shrink it if so. */
7040 create_convert_operand_to (&ops
[2], val
, mode
, true);
7041 create_integer_operand (&ops
[3], model
);
7042 if (maybe_expand_insn (icode
, 4, ops
))
7043 return ops
[0].value
;
7049 /* This function tries to implement an atomic exchange operation using
7050 __sync_lock_test_and_set. VAL is written to *MEM using memory model MODEL.
7051 The previous contents of *MEM are returned, using TARGET if possible.
7052 Since this instructionn is an acquire barrier only, stronger memory
7053 models may require additional barriers to be emitted. */
7056 maybe_emit_sync_lock_test_and_set (rtx target
, rtx mem
, rtx val
,
7057 enum memmodel model
)
7059 enum machine_mode mode
= GET_MODE (mem
);
7060 enum insn_code icode
;
7061 rtx last_insn
= get_last_insn ();
7063 icode
= optab_handler (sync_lock_test_and_set_optab
, mode
);
7065 /* Legacy sync_lock_test_and_set is an acquire barrier. If the pattern
7066 exists, and the memory model is stronger than acquire, add a release
7067 barrier before the instruction. */
7069 if ((model
& MEMMODEL_MASK
) == MEMMODEL_SEQ_CST
7070 || (model
& MEMMODEL_MASK
) == MEMMODEL_RELEASE
7071 || (model
& MEMMODEL_MASK
) == MEMMODEL_ACQ_REL
)
7072 expand_mem_thread_fence (model
);
7074 if (icode
!= CODE_FOR_nothing
)
7076 struct expand_operand ops
[3];
7077 create_output_operand (&ops
[0], target
, mode
);
7078 create_fixed_operand (&ops
[1], mem
);
7079 /* VAL may have been promoted to a wider mode. Shrink it if so. */
7080 create_convert_operand_to (&ops
[2], val
, mode
, true);
7081 if (maybe_expand_insn (icode
, 3, ops
))
7082 return ops
[0].value
;
7085 /* If an external test-and-set libcall is provided, use that instead of
7086 any external compare-and-swap that we might get from the compare-and-
7087 swap-loop expansion later. */
7088 if (!can_compare_and_swap_p (mode
, false))
7090 rtx libfunc
= optab_libfunc (sync_lock_test_and_set_optab
, mode
);
7091 if (libfunc
!= NULL
)
7095 addr
= convert_memory_address (ptr_mode
, XEXP (mem
, 0));
7096 return emit_library_call_value (libfunc
, NULL_RTX
, LCT_NORMAL
,
7097 mode
, 2, addr
, ptr_mode
,
7102 /* If the test_and_set can't be emitted, eliminate any barrier that might
7103 have been emitted. */
7104 delete_insns_since (last_insn
);
7108 /* This function tries to implement an atomic exchange operation using a
7109 compare_and_swap loop. VAL is written to *MEM. The previous contents of
7110 *MEM are returned, using TARGET if possible. No memory model is required
7111 since a compare_and_swap loop is seq-cst. */
7114 maybe_emit_compare_and_swap_exchange_loop (rtx target
, rtx mem
, rtx val
)
7116 enum machine_mode mode
= GET_MODE (mem
);
7118 if (can_compare_and_swap_p (mode
, true))
7120 if (!target
|| !register_operand (target
, mode
))
7121 target
= gen_reg_rtx (mode
);
7122 if (GET_MODE (val
) != VOIDmode
&& GET_MODE (val
) != mode
)
7123 val
= convert_modes (mode
, GET_MODE (val
), val
, 1);
7124 if (expand_compare_and_swap_loop (mem
, target
, val
, NULL_RTX
))
7131 /* This function tries to implement an atomic test-and-set operation
7132 using the atomic_test_and_set instruction pattern. A boolean value
7133 is returned from the operation, using TARGET if possible. */
7135 #ifndef HAVE_atomic_test_and_set
7136 #define HAVE_atomic_test_and_set 0
7137 #define CODE_FOR_atomic_test_and_set CODE_FOR_nothing
7141 maybe_emit_atomic_test_and_set (rtx target
, rtx mem
, enum memmodel model
)
7143 enum machine_mode pat_bool_mode
;
7144 struct expand_operand ops
[3];
7146 if (!HAVE_atomic_test_and_set
)
7149 /* While we always get QImode from __atomic_test_and_set, we get
7150 other memory modes from __sync_lock_test_and_set. Note that we
7151 use no endian adjustment here. This matches the 4.6 behavior
7152 in the Sparc backend. */
7154 (insn_data
[CODE_FOR_atomic_test_and_set
].operand
[1].mode
== QImode
);
7155 if (GET_MODE (mem
) != QImode
)
7156 mem
= adjust_address_nv (mem
, QImode
, 0);
7158 pat_bool_mode
= insn_data
[CODE_FOR_atomic_test_and_set
].operand
[0].mode
;
7159 create_output_operand (&ops
[0], target
, pat_bool_mode
);
7160 create_fixed_operand (&ops
[1], mem
);
7161 create_integer_operand (&ops
[2], model
);
7163 if (maybe_expand_insn (CODE_FOR_atomic_test_and_set
, 3, ops
))
7164 return ops
[0].value
;
7168 /* This function expands the legacy _sync_lock test_and_set operation which is
7169 generally an atomic exchange. Some limited targets only allow the
7170 constant 1 to be stored. This is an ACQUIRE operation.
7172 TARGET is an optional place to stick the return value.
7173 MEM is where VAL is stored. */
7176 expand_sync_lock_test_and_set (rtx target
, rtx mem
, rtx val
)
7180 /* Try an atomic_exchange first. */
7181 ret
= maybe_emit_atomic_exchange (target
, mem
, val
, MEMMODEL_ACQUIRE
);
7185 ret
= maybe_emit_sync_lock_test_and_set (target
, mem
, val
, MEMMODEL_ACQUIRE
);
7189 ret
= maybe_emit_compare_and_swap_exchange_loop (target
, mem
, val
);
7193 /* If there are no other options, try atomic_test_and_set if the value
7194 being stored is 1. */
7195 if (val
== const1_rtx
)
7196 ret
= maybe_emit_atomic_test_and_set (target
, mem
, MEMMODEL_ACQUIRE
);
7201 /* This function expands the atomic test_and_set operation:
7202 atomically store a boolean TRUE into MEM and return the previous value.
7204 MEMMODEL is the memory model variant to use.
7205 TARGET is an optional place to stick the return value. */
7208 expand_atomic_test_and_set (rtx target
, rtx mem
, enum memmodel model
)
7210 enum machine_mode mode
= GET_MODE (mem
);
7211 rtx ret
, trueval
, subtarget
;
7213 ret
= maybe_emit_atomic_test_and_set (target
, mem
, model
);
7217 /* Be binary compatible with non-default settings of trueval, and different
7218 cpu revisions. E.g. one revision may have atomic-test-and-set, but
7219 another only has atomic-exchange. */
7220 if (targetm
.atomic_test_and_set_trueval
== 1)
7222 trueval
= const1_rtx
;
7223 subtarget
= target
? target
: gen_reg_rtx (mode
);
7227 trueval
= gen_int_mode (targetm
.atomic_test_and_set_trueval
, mode
);
7228 subtarget
= gen_reg_rtx (mode
);
7231 /* Try the atomic-exchange optab... */
7232 ret
= maybe_emit_atomic_exchange (subtarget
, mem
, trueval
, model
);
7234 /* ... then an atomic-compare-and-swap loop ... */
7236 ret
= maybe_emit_compare_and_swap_exchange_loop (subtarget
, mem
, trueval
);
7238 /* ... before trying the vaguely defined legacy lock_test_and_set. */
7240 ret
= maybe_emit_sync_lock_test_and_set (subtarget
, mem
, trueval
, model
);
7242 /* Recall that the legacy lock_test_and_set optab was allowed to do magic
7243 things with the value 1. Thus we try again without trueval. */
7244 if (!ret
&& targetm
.atomic_test_and_set_trueval
!= 1)
7245 ret
= maybe_emit_sync_lock_test_and_set (subtarget
, mem
, const1_rtx
, model
);
7247 /* Failing all else, assume a single threaded environment and simply
7248 perform the operation. */
7251 emit_move_insn (subtarget
, mem
);
7252 emit_move_insn (mem
, trueval
);
7256 /* Recall that have to return a boolean value; rectify if trueval
7257 is not exactly one. */
7258 if (targetm
.atomic_test_and_set_trueval
!= 1)
7259 ret
= emit_store_flag_force (target
, NE
, ret
, const0_rtx
, mode
, 0, 1);
7264 /* This function expands the atomic exchange operation:
7265 atomically store VAL in MEM and return the previous value in MEM.
7267 MEMMODEL is the memory model variant to use.
7268 TARGET is an optional place to stick the return value. */
7271 expand_atomic_exchange (rtx target
, rtx mem
, rtx val
, enum memmodel model
)
7275 ret
= maybe_emit_atomic_exchange (target
, mem
, val
, model
);
7277 /* Next try a compare-and-swap loop for the exchange. */
7279 ret
= maybe_emit_compare_and_swap_exchange_loop (target
, mem
, val
);
7284 /* This function expands the atomic compare exchange operation:
7286 *PTARGET_BOOL is an optional place to store the boolean success/failure.
7287 *PTARGET_OVAL is an optional place to store the old value from memory.
7288 Both target parameters may be NULL to indicate that we do not care about
7289 that return value. Both target parameters are updated on success to
7290 the actual location of the corresponding result.
7292 MEMMODEL is the memory model variant to use.
7294 The return value of the function is true for success. */
7297 expand_atomic_compare_and_swap (rtx
*ptarget_bool
, rtx
*ptarget_oval
,
7298 rtx mem
, rtx expected
, rtx desired
,
7299 bool is_weak
, enum memmodel succ_model
,
7300 enum memmodel fail_model
)
7302 enum machine_mode mode
= GET_MODE (mem
);
7303 struct expand_operand ops
[8];
7304 enum insn_code icode
;
7305 rtx target_oval
, target_bool
= NULL_RTX
;
7308 /* Load expected into a register for the compare and swap. */
7309 if (MEM_P (expected
))
7310 expected
= copy_to_reg (expected
);
7312 /* Make sure we always have some place to put the return oldval.
7313 Further, make sure that place is distinct from the input expected,
7314 just in case we need that path down below. */
7315 if (ptarget_oval
== NULL
7316 || (target_oval
= *ptarget_oval
) == NULL
7317 || reg_overlap_mentioned_p (expected
, target_oval
))
7318 target_oval
= gen_reg_rtx (mode
);
7320 icode
= direct_optab_handler (atomic_compare_and_swap_optab
, mode
);
7321 if (icode
!= CODE_FOR_nothing
)
7323 enum machine_mode bool_mode
= insn_data
[icode
].operand
[0].mode
;
7325 /* Make sure we always have a place for the bool operand. */
7326 if (ptarget_bool
== NULL
7327 || (target_bool
= *ptarget_bool
) == NULL
7328 || GET_MODE (target_bool
) != bool_mode
)
7329 target_bool
= gen_reg_rtx (bool_mode
);
7331 /* Emit the compare_and_swap. */
7332 create_output_operand (&ops
[0], target_bool
, bool_mode
);
7333 create_output_operand (&ops
[1], target_oval
, mode
);
7334 create_fixed_operand (&ops
[2], mem
);
7335 create_convert_operand_to (&ops
[3], expected
, mode
, true);
7336 create_convert_operand_to (&ops
[4], desired
, mode
, true);
7337 create_integer_operand (&ops
[5], is_weak
);
7338 create_integer_operand (&ops
[6], succ_model
);
7339 create_integer_operand (&ops
[7], fail_model
);
7340 expand_insn (icode
, 8, ops
);
7342 /* Return success/failure. */
7343 target_bool
= ops
[0].value
;
7344 target_oval
= ops
[1].value
;
7348 /* Otherwise fall back to the original __sync_val_compare_and_swap
7349 which is always seq-cst. */
7350 icode
= optab_handler (sync_compare_and_swap_optab
, mode
);
7351 if (icode
!= CODE_FOR_nothing
)
7355 create_output_operand (&ops
[0], target_oval
, mode
);
7356 create_fixed_operand (&ops
[1], mem
);
7357 create_convert_operand_to (&ops
[2], expected
, mode
, true);
7358 create_convert_operand_to (&ops
[3], desired
, mode
, true);
7359 if (!maybe_expand_insn (icode
, 4, ops
))
7362 target_oval
= ops
[0].value
;
7364 /* If the caller isn't interested in the boolean return value,
7365 skip the computation of it. */
7366 if (ptarget_bool
== NULL
)
7369 /* Otherwise, work out if the compare-and-swap succeeded. */
7371 if (have_insn_for (COMPARE
, CCmode
))
7372 note_stores (PATTERN (get_last_insn ()), find_cc_set
, &cc_reg
);
7375 target_bool
= emit_store_flag_force (target_bool
, EQ
, cc_reg
,
7376 const0_rtx
, VOIDmode
, 0, 1);
7379 goto success_bool_from_val
;
7382 /* Also check for library support for __sync_val_compare_and_swap. */
7383 libfunc
= optab_libfunc (sync_compare_and_swap_optab
, mode
);
7384 if (libfunc
!= NULL
)
7386 rtx addr
= convert_memory_address (ptr_mode
, XEXP (mem
, 0));
7387 target_oval
= emit_library_call_value (libfunc
, NULL_RTX
, LCT_NORMAL
,
7388 mode
, 3, addr
, ptr_mode
,
7389 expected
, mode
, desired
, mode
);
7391 /* Compute the boolean return value only if requested. */
7393 goto success_bool_from_val
;
7401 success_bool_from_val
:
7402 target_bool
= emit_store_flag_force (target_bool
, EQ
, target_oval
,
7403 expected
, VOIDmode
, 1, 1);
7405 /* Make sure that the oval output winds up where the caller asked. */
7407 *ptarget_oval
= target_oval
;
7409 *ptarget_bool
= target_bool
;
7413 /* Generate asm volatile("" : : : "memory") as the memory barrier. */
7416 expand_asm_memory_barrier (void)
7420 asm_op
= gen_rtx_ASM_OPERANDS (VOIDmode
, empty_string
, empty_string
, 0,
7421 rtvec_alloc (0), rtvec_alloc (0),
7422 rtvec_alloc (0), UNKNOWN_LOCATION
);
7423 MEM_VOLATILE_P (asm_op
) = 1;
7425 clob
= gen_rtx_SCRATCH (VOIDmode
);
7426 clob
= gen_rtx_MEM (BLKmode
, clob
);
7427 clob
= gen_rtx_CLOBBER (VOIDmode
, clob
);
7429 emit_insn (gen_rtx_PARALLEL (VOIDmode
, gen_rtvec (2, asm_op
, clob
)));
7432 /* This routine will either emit the mem_thread_fence pattern or issue a
7433 sync_synchronize to generate a fence for memory model MEMMODEL. */
7435 #ifndef HAVE_mem_thread_fence
7436 # define HAVE_mem_thread_fence 0
7437 # define gen_mem_thread_fence(x) (gcc_unreachable (), NULL_RTX)
7439 #ifndef HAVE_memory_barrier
7440 # define HAVE_memory_barrier 0
7441 # define gen_memory_barrier() (gcc_unreachable (), NULL_RTX)
7445 expand_mem_thread_fence (enum memmodel model
)
7447 if (HAVE_mem_thread_fence
)
7448 emit_insn (gen_mem_thread_fence (GEN_INT (model
)));
7449 else if ((model
& MEMMODEL_MASK
) != MEMMODEL_RELAXED
)
7451 if (HAVE_memory_barrier
)
7452 emit_insn (gen_memory_barrier ());
7453 else if (synchronize_libfunc
!= NULL_RTX
)
7454 emit_library_call (synchronize_libfunc
, LCT_NORMAL
, VOIDmode
, 0);
7456 expand_asm_memory_barrier ();
7460 /* This routine will either emit the mem_signal_fence pattern or issue a
7461 sync_synchronize to generate a fence for memory model MEMMODEL. */
7463 #ifndef HAVE_mem_signal_fence
7464 # define HAVE_mem_signal_fence 0
7465 # define gen_mem_signal_fence(x) (gcc_unreachable (), NULL_RTX)
7469 expand_mem_signal_fence (enum memmodel model
)
7471 if (HAVE_mem_signal_fence
)
7472 emit_insn (gen_mem_signal_fence (GEN_INT (model
)));
7473 else if ((model
& MEMMODEL_MASK
) != MEMMODEL_RELAXED
)
7475 /* By default targets are coherent between a thread and the signal
7476 handler running on the same thread. Thus this really becomes a
7477 compiler barrier, in that stores must not be sunk past
7478 (or raised above) a given point. */
7479 expand_asm_memory_barrier ();
7483 /* This function expands the atomic load operation:
7484 return the atomically loaded value in MEM.
7486 MEMMODEL is the memory model variant to use.
7487 TARGET is an option place to stick the return value. */
7490 expand_atomic_load (rtx target
, rtx mem
, enum memmodel model
)
7492 enum machine_mode mode
= GET_MODE (mem
);
7493 enum insn_code icode
;
7495 /* If the target supports the load directly, great. */
7496 icode
= direct_optab_handler (atomic_load_optab
, mode
);
7497 if (icode
!= CODE_FOR_nothing
)
7499 struct expand_operand ops
[3];
7501 create_output_operand (&ops
[0], target
, mode
);
7502 create_fixed_operand (&ops
[1], mem
);
7503 create_integer_operand (&ops
[2], model
);
7504 if (maybe_expand_insn (icode
, 3, ops
))
7505 return ops
[0].value
;
7508 /* If the size of the object is greater than word size on this target,
7509 then we assume that a load will not be atomic. */
7510 if (GET_MODE_PRECISION (mode
) > BITS_PER_WORD
)
7512 /* Issue val = compare_and_swap (mem, 0, 0).
7513 This may cause the occasional harmless store of 0 when the value is
7514 already 0, but it seems to be OK according to the standards guys. */
7515 if (expand_atomic_compare_and_swap (NULL
, &target
, mem
, const0_rtx
,
7516 const0_rtx
, false, model
, model
))
7519 /* Otherwise there is no atomic load, leave the library call. */
7523 /* Otherwise assume loads are atomic, and emit the proper barriers. */
7524 if (!target
|| target
== const0_rtx
)
7525 target
= gen_reg_rtx (mode
);
7527 /* For SEQ_CST, emit a barrier before the load. */
7528 if ((model
& MEMMODEL_MASK
) == MEMMODEL_SEQ_CST
)
7529 expand_mem_thread_fence (model
);
7531 emit_move_insn (target
, mem
);
7533 /* Emit the appropriate barrier after the load. */
7534 expand_mem_thread_fence (model
);
7539 /* This function expands the atomic store operation:
7540 Atomically store VAL in MEM.
7541 MEMMODEL is the memory model variant to use.
7542 USE_RELEASE is true if __sync_lock_release can be used as a fall back.
7543 function returns const0_rtx if a pattern was emitted. */
7546 expand_atomic_store (rtx mem
, rtx val
, enum memmodel model
, bool use_release
)
7548 enum machine_mode mode
= GET_MODE (mem
);
7549 enum insn_code icode
;
7550 struct expand_operand ops
[3];
7552 /* If the target supports the store directly, great. */
7553 icode
= direct_optab_handler (atomic_store_optab
, mode
);
7554 if (icode
!= CODE_FOR_nothing
)
7556 create_fixed_operand (&ops
[0], mem
);
7557 create_input_operand (&ops
[1], val
, mode
);
7558 create_integer_operand (&ops
[2], model
);
7559 if (maybe_expand_insn (icode
, 3, ops
))
7563 /* If using __sync_lock_release is a viable alternative, try it. */
7566 icode
= direct_optab_handler (sync_lock_release_optab
, mode
);
7567 if (icode
!= CODE_FOR_nothing
)
7569 create_fixed_operand (&ops
[0], mem
);
7570 create_input_operand (&ops
[1], const0_rtx
, mode
);
7571 if (maybe_expand_insn (icode
, 2, ops
))
7573 /* lock_release is only a release barrier. */
7574 if ((model
& MEMMODEL_MASK
) == MEMMODEL_SEQ_CST
)
7575 expand_mem_thread_fence (model
);
7581 /* If the size of the object is greater than word size on this target,
7582 a default store will not be atomic, Try a mem_exchange and throw away
7583 the result. If that doesn't work, don't do anything. */
7584 if (GET_MODE_PRECISION (mode
) > BITS_PER_WORD
)
7586 rtx target
= maybe_emit_atomic_exchange (NULL_RTX
, mem
, val
, model
);
7588 target
= maybe_emit_compare_and_swap_exchange_loop (NULL_RTX
, mem
, val
);
7595 /* Otherwise assume stores are atomic, and emit the proper barriers. */
7596 expand_mem_thread_fence (model
);
7598 emit_move_insn (mem
, val
);
7600 /* For SEQ_CST, also emit a barrier after the store. */
7601 if ((model
& MEMMODEL_MASK
) == MEMMODEL_SEQ_CST
)
7602 expand_mem_thread_fence (model
);
7608 /* Structure containing the pointers and values required to process the
7609 various forms of the atomic_fetch_op and atomic_op_fetch builtins. */
7611 struct atomic_op_functions
7613 direct_optab mem_fetch_before
;
7614 direct_optab mem_fetch_after
;
7615 direct_optab mem_no_result
;
7618 direct_optab no_result
;
7619 enum rtx_code reverse_code
;
7623 /* Fill in structure pointed to by OP with the various optab entries for an
7624 operation of type CODE. */
7627 get_atomic_op_for_code (struct atomic_op_functions
*op
, enum rtx_code code
)
7629 gcc_assert (op
!= NULL
);
7631 /* If SWITCHABLE_TARGET is defined, then subtargets can be switched
7632 in the source code during compilation, and the optab entries are not
7633 computable until runtime. Fill in the values at runtime. */
7637 op
->mem_fetch_before
= atomic_fetch_add_optab
;
7638 op
->mem_fetch_after
= atomic_add_fetch_optab
;
7639 op
->mem_no_result
= atomic_add_optab
;
7640 op
->fetch_before
= sync_old_add_optab
;
7641 op
->fetch_after
= sync_new_add_optab
;
7642 op
->no_result
= sync_add_optab
;
7643 op
->reverse_code
= MINUS
;
7646 op
->mem_fetch_before
= atomic_fetch_sub_optab
;
7647 op
->mem_fetch_after
= atomic_sub_fetch_optab
;
7648 op
->mem_no_result
= atomic_sub_optab
;
7649 op
->fetch_before
= sync_old_sub_optab
;
7650 op
->fetch_after
= sync_new_sub_optab
;
7651 op
->no_result
= sync_sub_optab
;
7652 op
->reverse_code
= PLUS
;
7655 op
->mem_fetch_before
= atomic_fetch_xor_optab
;
7656 op
->mem_fetch_after
= atomic_xor_fetch_optab
;
7657 op
->mem_no_result
= atomic_xor_optab
;
7658 op
->fetch_before
= sync_old_xor_optab
;
7659 op
->fetch_after
= sync_new_xor_optab
;
7660 op
->no_result
= sync_xor_optab
;
7661 op
->reverse_code
= XOR
;
7664 op
->mem_fetch_before
= atomic_fetch_and_optab
;
7665 op
->mem_fetch_after
= atomic_and_fetch_optab
;
7666 op
->mem_no_result
= atomic_and_optab
;
7667 op
->fetch_before
= sync_old_and_optab
;
7668 op
->fetch_after
= sync_new_and_optab
;
7669 op
->no_result
= sync_and_optab
;
7670 op
->reverse_code
= UNKNOWN
;
7673 op
->mem_fetch_before
= atomic_fetch_or_optab
;
7674 op
->mem_fetch_after
= atomic_or_fetch_optab
;
7675 op
->mem_no_result
= atomic_or_optab
;
7676 op
->fetch_before
= sync_old_ior_optab
;
7677 op
->fetch_after
= sync_new_ior_optab
;
7678 op
->no_result
= sync_ior_optab
;
7679 op
->reverse_code
= UNKNOWN
;
7682 op
->mem_fetch_before
= atomic_fetch_nand_optab
;
7683 op
->mem_fetch_after
= atomic_nand_fetch_optab
;
7684 op
->mem_no_result
= atomic_nand_optab
;
7685 op
->fetch_before
= sync_old_nand_optab
;
7686 op
->fetch_after
= sync_new_nand_optab
;
7687 op
->no_result
= sync_nand_optab
;
7688 op
->reverse_code
= UNKNOWN
;
7695 /* See if there is a more optimal way to implement the operation "*MEM CODE VAL"
7696 using memory order MODEL. If AFTER is true the operation needs to return
7697 the value of *MEM after the operation, otherwise the previous value.
7698 TARGET is an optional place to place the result. The result is unused if
7700 Return the result if there is a better sequence, otherwise NULL_RTX. */
7703 maybe_optimize_fetch_op (rtx target
, rtx mem
, rtx val
, enum rtx_code code
,
7704 enum memmodel model
, bool after
)
7706 /* If the value is prefetched, or not used, it may be possible to replace
7707 the sequence with a native exchange operation. */
7708 if (!after
|| target
== const0_rtx
)
7710 /* fetch_and (&x, 0, m) can be replaced with exchange (&x, 0, m). */
7711 if (code
== AND
&& val
== const0_rtx
)
7713 if (target
== const0_rtx
)
7714 target
= gen_reg_rtx (GET_MODE (mem
));
7715 return maybe_emit_atomic_exchange (target
, mem
, val
, model
);
7718 /* fetch_or (&x, -1, m) can be replaced with exchange (&x, -1, m). */
7719 if (code
== IOR
&& val
== constm1_rtx
)
7721 if (target
== const0_rtx
)
7722 target
= gen_reg_rtx (GET_MODE (mem
));
7723 return maybe_emit_atomic_exchange (target
, mem
, val
, model
);
7730 /* Try to emit an instruction for a specific operation varaition.
7731 OPTAB contains the OP functions.
7732 TARGET is an optional place to return the result. const0_rtx means unused.
7733 MEM is the memory location to operate on.
7734 VAL is the value to use in the operation.
7735 USE_MEMMODEL is TRUE if the variation with a memory model should be tried.
7736 MODEL is the memory model, if used.
7737 AFTER is true if the returned result is the value after the operation. */
7740 maybe_emit_op (const struct atomic_op_functions
*optab
, rtx target
, rtx mem
,
7741 rtx val
, bool use_memmodel
, enum memmodel model
, bool after
)
7743 enum machine_mode mode
= GET_MODE (mem
);
7744 struct expand_operand ops
[4];
7745 enum insn_code icode
;
7749 /* Check to see if there is a result returned. */
7750 if (target
== const0_rtx
)
7754 icode
= direct_optab_handler (optab
->mem_no_result
, mode
);
7755 create_integer_operand (&ops
[2], model
);
7760 icode
= direct_optab_handler (optab
->no_result
, mode
);
7764 /* Otherwise, we need to generate a result. */
7769 icode
= direct_optab_handler (after
? optab
->mem_fetch_after
7770 : optab
->mem_fetch_before
, mode
);
7771 create_integer_operand (&ops
[3], model
);
7776 icode
= optab_handler (after
? optab
->fetch_after
7777 : optab
->fetch_before
, mode
);
7780 create_output_operand (&ops
[op_counter
++], target
, mode
);
7782 if (icode
== CODE_FOR_nothing
)
7785 create_fixed_operand (&ops
[op_counter
++], mem
);
7786 /* VAL may have been promoted to a wider mode. Shrink it if so. */
7787 create_convert_operand_to (&ops
[op_counter
++], val
, mode
, true);
7789 if (maybe_expand_insn (icode
, num_ops
, ops
))
7790 return (target
== const0_rtx
? const0_rtx
: ops
[0].value
);
7796 /* This function expands an atomic fetch_OP or OP_fetch operation:
7797 TARGET is an option place to stick the return value. const0_rtx indicates
7798 the result is unused.
7799 atomically fetch MEM, perform the operation with VAL and return it to MEM.
7800 CODE is the operation being performed (OP)
7801 MEMMODEL is the memory model variant to use.
7802 AFTER is true to return the result of the operation (OP_fetch).
7803 AFTER is false to return the value before the operation (fetch_OP).
7805 This function will *only* generate instructions if there is a direct
7806 optab. No compare and swap loops or libcalls will be generated. */
7809 expand_atomic_fetch_op_no_fallback (rtx target
, rtx mem
, rtx val
,
7810 enum rtx_code code
, enum memmodel model
,
7813 enum machine_mode mode
= GET_MODE (mem
);
7814 struct atomic_op_functions optab
;
7816 bool unused_result
= (target
== const0_rtx
);
7818 get_atomic_op_for_code (&optab
, code
);
7820 /* Check to see if there are any better instructions. */
7821 result
= maybe_optimize_fetch_op (target
, mem
, val
, code
, model
, after
);
7825 /* Check for the case where the result isn't used and try those patterns. */
7828 /* Try the memory model variant first. */
7829 result
= maybe_emit_op (&optab
, target
, mem
, val
, true, model
, true);
7833 /* Next try the old style withuot a memory model. */
7834 result
= maybe_emit_op (&optab
, target
, mem
, val
, false, model
, true);
7838 /* There is no no-result pattern, so try patterns with a result. */
7842 /* Try the __atomic version. */
7843 result
= maybe_emit_op (&optab
, target
, mem
, val
, true, model
, after
);
7847 /* Try the older __sync version. */
7848 result
= maybe_emit_op (&optab
, target
, mem
, val
, false, model
, after
);
7852 /* If the fetch value can be calculated from the other variation of fetch,
7853 try that operation. */
7854 if (after
|| unused_result
|| optab
.reverse_code
!= UNKNOWN
)
7856 /* Try the __atomic version, then the older __sync version. */
7857 result
= maybe_emit_op (&optab
, target
, mem
, val
, true, model
, !after
);
7859 result
= maybe_emit_op (&optab
, target
, mem
, val
, false, model
, !after
);
7863 /* If the result isn't used, no need to do compensation code. */
7867 /* Issue compensation code. Fetch_after == fetch_before OP val.
7868 Fetch_before == after REVERSE_OP val. */
7870 code
= optab
.reverse_code
;
7873 result
= expand_simple_binop (mode
, AND
, result
, val
, NULL_RTX
,
7874 true, OPTAB_LIB_WIDEN
);
7875 result
= expand_simple_unop (mode
, NOT
, result
, target
, true);
7878 result
= expand_simple_binop (mode
, code
, result
, val
, target
,
7879 true, OPTAB_LIB_WIDEN
);
7884 /* No direct opcode can be generated. */
7890 /* This function expands an atomic fetch_OP or OP_fetch operation:
7891 TARGET is an option place to stick the return value. const0_rtx indicates
7892 the result is unused.
7893 atomically fetch MEM, perform the operation with VAL and return it to MEM.
7894 CODE is the operation being performed (OP)
7895 MEMMODEL is the memory model variant to use.
7896 AFTER is true to return the result of the operation (OP_fetch).
7897 AFTER is false to return the value before the operation (fetch_OP). */
7899 expand_atomic_fetch_op (rtx target
, rtx mem
, rtx val
, enum rtx_code code
,
7900 enum memmodel model
, bool after
)
7902 enum machine_mode mode
= GET_MODE (mem
);
7904 bool unused_result
= (target
== const0_rtx
);
7906 result
= expand_atomic_fetch_op_no_fallback (target
, mem
, val
, code
, model
,
7912 /* Add/sub can be implemented by doing the reverse operation with -(val). */
7913 if (code
== PLUS
|| code
== MINUS
)
7916 enum rtx_code reverse
= (code
== PLUS
? MINUS
: PLUS
);
7919 tmp
= expand_simple_unop (mode
, NEG
, val
, NULL_RTX
, true);
7920 result
= expand_atomic_fetch_op_no_fallback (target
, mem
, tmp
, reverse
,
7924 /* PLUS worked so emit the insns and return. */
7931 /* PLUS did not work, so throw away the negation code and continue. */
7935 /* Try the __sync libcalls only if we can't do compare-and-swap inline. */
7936 if (!can_compare_and_swap_p (mode
, false))
7940 enum rtx_code orig_code
= code
;
7941 struct atomic_op_functions optab
;
7943 get_atomic_op_for_code (&optab
, code
);
7944 libfunc
= optab_libfunc (after
? optab
.fetch_after
7945 : optab
.fetch_before
, mode
);
7947 && (after
|| unused_result
|| optab
.reverse_code
!= UNKNOWN
))
7951 code
= optab
.reverse_code
;
7952 libfunc
= optab_libfunc (after
? optab
.fetch_before
7953 : optab
.fetch_after
, mode
);
7955 if (libfunc
!= NULL
)
7957 rtx addr
= convert_memory_address (ptr_mode
, XEXP (mem
, 0));
7958 result
= emit_library_call_value (libfunc
, NULL
, LCT_NORMAL
, mode
,
7959 2, addr
, ptr_mode
, val
, mode
);
7961 if (!unused_result
&& fixup
)
7962 result
= expand_simple_binop (mode
, code
, result
, val
, target
,
7963 true, OPTAB_LIB_WIDEN
);
7967 /* We need the original code for any further attempts. */
7971 /* If nothing else has succeeded, default to a compare and swap loop. */
7972 if (can_compare_and_swap_p (mode
, true))
7975 rtx t0
= gen_reg_rtx (mode
), t1
;
7979 /* If the result is used, get a register for it. */
7982 if (!target
|| !register_operand (target
, mode
))
7983 target
= gen_reg_rtx (mode
);
7984 /* If fetch_before, copy the value now. */
7986 emit_move_insn (target
, t0
);
7989 target
= const0_rtx
;
7994 t1
= expand_simple_binop (mode
, AND
, t1
, val
, NULL_RTX
,
7995 true, OPTAB_LIB_WIDEN
);
7996 t1
= expand_simple_unop (mode
, code
, t1
, NULL_RTX
, true);
7999 t1
= expand_simple_binop (mode
, code
, t1
, val
, NULL_RTX
, true,
8002 /* For after, copy the value now. */
8003 if (!unused_result
&& after
)
8004 emit_move_insn (target
, t1
);
8005 insn
= get_insns ();
8008 if (t1
!= NULL
&& expand_compare_and_swap_loop (mem
, t0
, t1
, insn
))
8015 /* Return true if OPERAND is suitable for operand number OPNO of
8016 instruction ICODE. */
8019 insn_operand_matches (enum insn_code icode
, unsigned int opno
, rtx operand
)
8021 return (!insn_data
[(int) icode
].operand
[opno
].predicate
8022 || (insn_data
[(int) icode
].operand
[opno
].predicate
8023 (operand
, insn_data
[(int) icode
].operand
[opno
].mode
)));
8026 /* TARGET is a target of a multiword operation that we are going to
8027 implement as a series of word-mode operations. Return true if
8028 TARGET is suitable for this purpose. */
8031 valid_multiword_target_p (rtx target
)
8033 enum machine_mode mode
;
8036 mode
= GET_MODE (target
);
8037 for (i
= 0; i
< GET_MODE_SIZE (mode
); i
+= UNITS_PER_WORD
)
8038 if (!validate_subreg (word_mode
, mode
, target
, i
))
8043 /* Like maybe_legitimize_operand, but do not change the code of the
8044 current rtx value. */
8047 maybe_legitimize_operand_same_code (enum insn_code icode
, unsigned int opno
,
8048 struct expand_operand
*op
)
8050 /* See if the operand matches in its current form. */
8051 if (insn_operand_matches (icode
, opno
, op
->value
))
8054 /* If the operand is a memory whose address has no side effects,
8055 try forcing the address into a non-virtual pseudo register.
8056 The check for side effects is important because copy_to_mode_reg
8057 cannot handle things like auto-modified addresses. */
8058 if (insn_data
[(int) icode
].operand
[opno
].allows_mem
&& MEM_P (op
->value
))
8063 addr
= XEXP (mem
, 0);
8064 if (!(REG_P (addr
) && REGNO (addr
) > LAST_VIRTUAL_REGISTER
)
8065 && !side_effects_p (addr
))
8068 enum machine_mode mode
;
8070 last
= get_last_insn ();
8071 mode
= get_address_mode (mem
);
8072 mem
= replace_equiv_address (mem
, copy_to_mode_reg (mode
, addr
));
8073 if (insn_operand_matches (icode
, opno
, mem
))
8078 delete_insns_since (last
);
8085 /* Try to make OP match operand OPNO of instruction ICODE. Return true
8086 on success, storing the new operand value back in OP. */
8089 maybe_legitimize_operand (enum insn_code icode
, unsigned int opno
,
8090 struct expand_operand
*op
)
8092 enum machine_mode mode
, imode
;
8093 bool old_volatile_ok
, result
;
8099 old_volatile_ok
= volatile_ok
;
8101 result
= maybe_legitimize_operand_same_code (icode
, opno
, op
);
8102 volatile_ok
= old_volatile_ok
;
8106 gcc_assert (mode
!= VOIDmode
);
8108 && op
->value
!= const0_rtx
8109 && GET_MODE (op
->value
) == mode
8110 && maybe_legitimize_operand_same_code (icode
, opno
, op
))
8113 op
->value
= gen_reg_rtx (mode
);
8118 gcc_assert (mode
!= VOIDmode
);
8119 gcc_assert (GET_MODE (op
->value
) == VOIDmode
8120 || GET_MODE (op
->value
) == mode
);
8121 if (maybe_legitimize_operand_same_code (icode
, opno
, op
))
8124 op
->value
= copy_to_mode_reg (mode
, op
->value
);
8127 case EXPAND_CONVERT_TO
:
8128 gcc_assert (mode
!= VOIDmode
);
8129 op
->value
= convert_to_mode (mode
, op
->value
, op
->unsigned_p
);
8132 case EXPAND_CONVERT_FROM
:
8133 if (GET_MODE (op
->value
) != VOIDmode
)
8134 mode
= GET_MODE (op
->value
);
8136 /* The caller must tell us what mode this value has. */
8137 gcc_assert (mode
!= VOIDmode
);
8139 imode
= insn_data
[(int) icode
].operand
[opno
].mode
;
8140 if (imode
!= VOIDmode
&& imode
!= mode
)
8142 op
->value
= convert_modes (imode
, mode
, op
->value
, op
->unsigned_p
);
8147 case EXPAND_ADDRESS
:
8148 gcc_assert (mode
!= VOIDmode
);
8149 op
->value
= convert_memory_address (mode
, op
->value
);
8152 case EXPAND_INTEGER
:
8153 mode
= insn_data
[(int) icode
].operand
[opno
].mode
;
8154 if (mode
!= VOIDmode
&& const_int_operand (op
->value
, mode
))
8158 return insn_operand_matches (icode
, opno
, op
->value
);
8161 /* Make OP describe an input operand that should have the same value
8162 as VALUE, after any mode conversion that the target might request.
8163 TYPE is the type of VALUE. */
8166 create_convert_operand_from_type (struct expand_operand
*op
,
8167 rtx value
, tree type
)
8169 create_convert_operand_from (op
, value
, TYPE_MODE (type
),
8170 TYPE_UNSIGNED (type
));
8173 /* Try to make operands [OPS, OPS + NOPS) match operands [OPNO, OPNO + NOPS)
8174 of instruction ICODE. Return true on success, leaving the new operand
8175 values in the OPS themselves. Emit no code on failure. */
8178 maybe_legitimize_operands (enum insn_code icode
, unsigned int opno
,
8179 unsigned int nops
, struct expand_operand
*ops
)
8184 last
= get_last_insn ();
8185 for (i
= 0; i
< nops
; i
++)
8186 if (!maybe_legitimize_operand (icode
, opno
+ i
, &ops
[i
]))
8188 delete_insns_since (last
);
8194 /* Try to generate instruction ICODE, using operands [OPS, OPS + NOPS)
8195 as its operands. Return the instruction pattern on success,
8196 and emit any necessary set-up code. Return null and emit no
8200 maybe_gen_insn (enum insn_code icode
, unsigned int nops
,
8201 struct expand_operand
*ops
)
8203 gcc_assert (nops
== (unsigned int) insn_data
[(int) icode
].n_generator_args
);
8204 if (!maybe_legitimize_operands (icode
, 0, nops
, ops
))
8210 return GEN_FCN (icode
) (ops
[0].value
);
8212 return GEN_FCN (icode
) (ops
[0].value
, ops
[1].value
);
8214 return GEN_FCN (icode
) (ops
[0].value
, ops
[1].value
, ops
[2].value
);
8216 return GEN_FCN (icode
) (ops
[0].value
, ops
[1].value
, ops
[2].value
,
8219 return GEN_FCN (icode
) (ops
[0].value
, ops
[1].value
, ops
[2].value
,
8220 ops
[3].value
, ops
[4].value
);
8222 return GEN_FCN (icode
) (ops
[0].value
, ops
[1].value
, ops
[2].value
,
8223 ops
[3].value
, ops
[4].value
, ops
[5].value
);
8225 return GEN_FCN (icode
) (ops
[0].value
, ops
[1].value
, ops
[2].value
,
8226 ops
[3].value
, ops
[4].value
, ops
[5].value
,
8229 return GEN_FCN (icode
) (ops
[0].value
, ops
[1].value
, ops
[2].value
,
8230 ops
[3].value
, ops
[4].value
, ops
[5].value
,
8231 ops
[6].value
, ops
[7].value
);
8236 /* Try to emit instruction ICODE, using operands [OPS, OPS + NOPS)
8237 as its operands. Return true on success and emit no code on failure. */
8240 maybe_expand_insn (enum insn_code icode
, unsigned int nops
,
8241 struct expand_operand
*ops
)
8243 rtx pat
= maybe_gen_insn (icode
, nops
, ops
);
8252 /* Like maybe_expand_insn, but for jumps. */
8255 maybe_expand_jump_insn (enum insn_code icode
, unsigned int nops
,
8256 struct expand_operand
*ops
)
8258 rtx pat
= maybe_gen_insn (icode
, nops
, ops
);
8261 emit_jump_insn (pat
);
8267 /* Emit instruction ICODE, using operands [OPS, OPS + NOPS)
8271 expand_insn (enum insn_code icode
, unsigned int nops
,
8272 struct expand_operand
*ops
)
8274 if (!maybe_expand_insn (icode
, nops
, ops
))
8278 /* Like expand_insn, but for jumps. */
8281 expand_jump_insn (enum insn_code icode
, unsigned int nops
,
8282 struct expand_operand
*ops
)
8284 if (!maybe_expand_jump_insn (icode
, nops
, ops
))
8288 /* Reduce conditional compilation elsewhere. */
8291 #define CODE_FOR_insv CODE_FOR_nothing
8295 #define CODE_FOR_extv CODE_FOR_nothing
8298 #define HAVE_extzv 0
8299 #define CODE_FOR_extzv CODE_FOR_nothing
8302 /* Enumerates the possible types of structure operand to an
8304 enum extraction_type
{ ET_unaligned_mem
, ET_reg
};
8306 /* Check whether insv, extv or extzv pattern ICODE can be used for an
8307 insertion or extraction of type TYPE on a structure of mode MODE.
8308 Return true if so and fill in *INSN accordingly. STRUCT_OP is the
8309 operand number of the structure (the first sign_extract or zero_extract
8310 operand) and FIELD_OP is the operand number of the field (the other
8311 side of the set from the sign_extract or zero_extract). */
8314 get_traditional_extraction_insn (extraction_insn
*insn
,
8315 enum extraction_type type
,
8316 enum machine_mode mode
,
8317 enum insn_code icode
,
8318 int struct_op
, int field_op
)
8320 const struct insn_data_d
*data
= &insn_data
[icode
];
8322 enum machine_mode struct_mode
= data
->operand
[struct_op
].mode
;
8323 if (struct_mode
== VOIDmode
)
8324 struct_mode
= word_mode
;
8325 if (mode
!= struct_mode
)
8328 enum machine_mode field_mode
= data
->operand
[field_op
].mode
;
8329 if (field_mode
== VOIDmode
)
8330 field_mode
= word_mode
;
8332 enum machine_mode pos_mode
= data
->operand
[struct_op
+ 2].mode
;
8333 if (pos_mode
== VOIDmode
)
8334 pos_mode
= word_mode
;
8336 insn
->icode
= icode
;
8337 insn
->field_mode
= field_mode
;
8338 insn
->struct_mode
= (type
== ET_unaligned_mem
? byte_mode
: struct_mode
);
8339 insn
->pos_mode
= pos_mode
;
8343 /* Return true if an optab exists to perform an insertion or extraction
8344 of type TYPE in mode MODE. Describe the instruction in *INSN if so.
8346 REG_OPTAB is the optab to use for register structures and
8347 MISALIGN_OPTAB is the optab to use for misaligned memory structures.
8348 POS_OP is the operand number of the bit position. */
8351 get_optab_extraction_insn (struct extraction_insn
*insn
,
8352 enum extraction_type type
,
8353 enum machine_mode mode
, direct_optab reg_optab
,
8354 direct_optab misalign_optab
, int pos_op
)
8356 direct_optab optab
= (type
== ET_unaligned_mem
? misalign_optab
: reg_optab
);
8357 enum insn_code icode
= direct_optab_handler (optab
, mode
);
8358 if (icode
== CODE_FOR_nothing
)
8361 const struct insn_data_d
*data
= &insn_data
[icode
];
8363 insn
->icode
= icode
;
8364 insn
->field_mode
= mode
;
8365 insn
->struct_mode
= (type
== ET_unaligned_mem
? BLKmode
: mode
);
8366 insn
->pos_mode
= data
->operand
[pos_op
].mode
;
8367 if (insn
->pos_mode
== VOIDmode
)
8368 insn
->pos_mode
= word_mode
;
8372 /* Return true if an instruction exists to perform an insertion or
8373 extraction (PATTERN says which) of type TYPE in mode MODE.
8374 Describe the instruction in *INSN if so. */
8377 get_extraction_insn (extraction_insn
*insn
,
8378 enum extraction_pattern pattern
,
8379 enum extraction_type type
,
8380 enum machine_mode mode
)
8386 && get_traditional_extraction_insn (insn
, type
, mode
,
8387 CODE_FOR_insv
, 0, 3))
8389 return get_optab_extraction_insn (insn
, type
, mode
, insv_optab
,
8390 insvmisalign_optab
, 2);
8394 && get_traditional_extraction_insn (insn
, type
, mode
,
8395 CODE_FOR_extv
, 1, 0))
8397 return get_optab_extraction_insn (insn
, type
, mode
, extv_optab
,
8398 extvmisalign_optab
, 3);
8402 && get_traditional_extraction_insn (insn
, type
, mode
,
8403 CODE_FOR_extzv
, 1, 0))
8405 return get_optab_extraction_insn (insn
, type
, mode
, extzv_optab
,
8406 extzvmisalign_optab
, 3);
8413 /* Return true if an instruction exists to access a field of mode
8414 FIELDMODE in a structure that has STRUCT_BITS significant bits.
8415 Describe the "best" such instruction in *INSN if so. PATTERN and
8416 TYPE describe the type of insertion or extraction we want to perform.
8418 For an insertion, the number of significant structure bits includes
8419 all bits of the target. For an extraction, it need only include the
8420 most significant bit of the field. Larger widths are acceptable
8424 get_best_extraction_insn (extraction_insn
*insn
,
8425 enum extraction_pattern pattern
,
8426 enum extraction_type type
,
8427 unsigned HOST_WIDE_INT struct_bits
,
8428 enum machine_mode field_mode
)
8430 enum machine_mode mode
= smallest_mode_for_size (struct_bits
, MODE_INT
);
8431 while (mode
!= VOIDmode
)
8433 if (get_extraction_insn (insn
, pattern
, type
, mode
))
8435 while (mode
!= VOIDmode
8436 && GET_MODE_SIZE (mode
) <= GET_MODE_SIZE (field_mode
)
8437 && !TRULY_NOOP_TRUNCATION_MODES_P (insn
->field_mode
,
8440 get_extraction_insn (insn
, pattern
, type
, mode
);
8441 mode
= GET_MODE_WIDER_MODE (mode
);
8445 mode
= GET_MODE_WIDER_MODE (mode
);
8450 /* Return true if an instruction exists to access a field of mode
8451 FIELDMODE in a register structure that has STRUCT_BITS significant bits.
8452 Describe the "best" such instruction in *INSN if so. PATTERN describes
8453 the type of insertion or extraction we want to perform.
8455 For an insertion, the number of significant structure bits includes
8456 all bits of the target. For an extraction, it need only include the
8457 most significant bit of the field. Larger widths are acceptable
8461 get_best_reg_extraction_insn (extraction_insn
*insn
,
8462 enum extraction_pattern pattern
,
8463 unsigned HOST_WIDE_INT struct_bits
,
8464 enum machine_mode field_mode
)
8466 return get_best_extraction_insn (insn
, pattern
, ET_reg
, struct_bits
,
8470 /* Return true if an instruction exists to access a field of BITSIZE
8471 bits starting BITNUM bits into a memory structure. Describe the
8472 "best" such instruction in *INSN if so. PATTERN describes the type
8473 of insertion or extraction we want to perform and FIELDMODE is the
8474 natural mode of the extracted field.
8476 The instructions considered here only access bytes that overlap
8477 the bitfield; they do not touch any surrounding bytes. */
8480 get_best_mem_extraction_insn (extraction_insn
*insn
,
8481 enum extraction_pattern pattern
,
8482 HOST_WIDE_INT bitsize
, HOST_WIDE_INT bitnum
,
8483 enum machine_mode field_mode
)
8485 unsigned HOST_WIDE_INT struct_bits
= (bitnum
% BITS_PER_UNIT
8487 + BITS_PER_UNIT
- 1);
8488 struct_bits
-= struct_bits
% BITS_PER_UNIT
;
8489 return get_best_extraction_insn (insn
, pattern
, ET_unaligned_mem
,
8490 struct_bits
, field_mode
);
8493 #include "gt-optabs.h"