1 /* Expand the basic unary and binary arithmetic operations, for GNU compiler.
2 Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
4 2011 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
25 #include "coretypes.h"
27 #include "diagnostic-core.h"
29 /* Include insn-config.h before expr.h so that HAVE_conditional_move
30 is properly defined. */
31 #include "insn-config.h"
44 #include "basic-block.h"
47 struct target_optabs default_target_optabs;
48 struct target_libfuncs default_target_libfuncs;
50 struct target_optabs *this_target_optabs = &default_target_optabs;
51 struct target_libfuncs *this_target_libfuncs = &default_target_libfuncs;
54 #define libfunc_hash \
55 (this_target_libfuncs->x_libfunc_hash)
57 /* Contains the optab used for each rtx code. */
58 optab code_to_optab[NUM_RTX_CODE + 1];
60 static void prepare_float_lib_cmp (rtx, rtx, enum rtx_code, rtx *,
62 static rtx expand_unop_direct (enum machine_mode, optab, rtx, rtx, int);
64 /* Debug facility for use in GDB. */
65 void debug_optab_libfuncs (void);
67 /* Prefixes for the current version of decimal floating point (BID vs. DPD) */
68 #if ENABLE_DECIMAL_BID_FORMAT
69 #define DECIMAL_PREFIX "bid_"
71 #define DECIMAL_PREFIX "dpd_"
74 /* Used for libfunc_hash. */
77 hash_libfunc (const void *p)
79 const struct libfunc_entry *const e = (const struct libfunc_entry *) p;
81 return (((int) e->mode1 + (int) e->mode2 * NUM_MACHINE_MODES)
85 /* Used for libfunc_hash. */
88 eq_libfunc (const void *p, const void *q)
90 const struct libfunc_entry *const e1 = (const struct libfunc_entry *) p;
91 const struct libfunc_entry *const e2 = (const struct libfunc_entry *) q;
93 return (e1->optab == e2->optab
94 && e1->mode1 == e2->mode1
95 && e1->mode2 == e2->mode2);
98 /* Return libfunc corresponding operation defined by OPTAB converting
99 from MODE2 to MODE1. Trigger lazy initialization if needed, return NULL
100 if no libfunc is available. */
102 convert_optab_libfunc (convert_optab optab, enum machine_mode mode1,
103 enum machine_mode mode2)
105 struct libfunc_entry e;
106 struct libfunc_entry **slot;
108 e.optab = (size_t) (optab - &convert_optab_table[0]);
111 slot = (struct libfunc_entry **) htab_find_slot (libfunc_hash, &e, NO_INSERT);
114 if (optab->libcall_gen)
116 optab->libcall_gen (optab, optab->libcall_basename, mode1, mode2);
117 slot = (struct libfunc_entry **) htab_find_slot (libfunc_hash, &e, NO_INSERT);
119 return (*slot)->libfunc;
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 e.optab = (size_t) (optab - &optab_table[0]);
140 slot = (struct libfunc_entry **) htab_find_slot (libfunc_hash, &e, NO_INSERT);
143 if (optab->libcall_gen)
145 optab->libcall_gen (optab, optab->libcall_basename,
146 optab->libcall_suffix, mode);
147 slot = (struct libfunc_entry **) htab_find_slot (libfunc_hash,
150 return (*slot)->libfunc;
156 return (*slot)->libfunc;
160 /* Add a REG_EQUAL note to the last insn in INSNS. TARGET is being set to
161 the result of operation CODE applied to OP0 (and OP1 if it is a binary
164 If the last insn does not set TARGET, don't do anything, but return 1.
166 If a previous insn sets TARGET and TARGET is one of OP0 or OP1,
167 don't add the REG_EQUAL note but return 0. Our caller can then try
168 again, ensuring that TARGET is not one of the operands. */
171 add_equal_note (rtx insns, rtx target, enum rtx_code code, rtx op0, rtx op1)
173 rtx last_insn, insn, set;
176 gcc_assert (insns && INSN_P (insns) && NEXT_INSN (insns));
178 if (GET_RTX_CLASS (code) != RTX_COMM_ARITH
179 && GET_RTX_CLASS (code) != RTX_BIN_ARITH
180 && GET_RTX_CLASS (code) != RTX_COMM_COMPARE
181 && GET_RTX_CLASS (code) != RTX_COMPARE
182 && GET_RTX_CLASS (code) != RTX_UNARY)
185 if (GET_CODE (target) == ZERO_EXTRACT)
188 for (last_insn = insns;
189 NEXT_INSN (last_insn) != NULL_RTX;
190 last_insn = NEXT_INSN (last_insn))
193 set = single_set (last_insn);
197 if (! rtx_equal_p (SET_DEST (set), target)
198 /* For a STRICT_LOW_PART, the REG_NOTE applies to what is inside it. */
199 && (GET_CODE (SET_DEST (set)) != STRICT_LOW_PART
200 || ! rtx_equal_p (XEXP (SET_DEST (set), 0), target)))
203 /* If TARGET is in OP0 or OP1, check if anything in SEQ sets TARGET
204 besides the last insn. */
205 if (reg_overlap_mentioned_p (target, op0)
206 || (op1 && reg_overlap_mentioned_p (target, op1)))
208 insn = PREV_INSN (last_insn);
209 while (insn != NULL_RTX)
211 if (reg_set_p (target, insn))
214 insn = PREV_INSN (insn);
218 if (GET_RTX_CLASS (code) == RTX_UNARY)
219 note = gen_rtx_fmt_e (code, GET_MODE (target), copy_rtx (op0));
221 note = gen_rtx_fmt_ee (code, GET_MODE (target), copy_rtx (op0), copy_rtx (op1));
223 set_unique_reg_note (last_insn, REG_EQUAL, note);
228 /* Widen OP to MODE and return the rtx for the widened operand. UNSIGNEDP
229 says whether OP is signed or unsigned. NO_EXTEND is nonzero if we need
230 not actually do a sign-extend or zero-extend, but can leave the
231 higher-order bits of the result rtx undefined, for example, in the case
232 of logical operations, but not right shifts. */
235 widen_operand (rtx op, enum machine_mode mode, enum machine_mode oldmode,
236 int unsignedp, int no_extend)
240 /* If we don't have to extend and this is a constant, return it. */
241 if (no_extend && GET_MODE (op) == VOIDmode)
244 /* If we must extend do so. If OP is a SUBREG for a promoted object, also
245 extend since it will be more efficient to do so unless the signedness of
246 a promoted object differs from our extension. */
248 || (GET_CODE (op) == SUBREG && SUBREG_PROMOTED_VAR_P (op)
249 && SUBREG_PROMOTED_UNSIGNED_P (op) == unsignedp))
250 return convert_modes (mode, oldmode, op, unsignedp);
252 /* If MODE is no wider than a single word, we return a paradoxical
254 if (GET_MODE_SIZE (mode) <= UNITS_PER_WORD)
255 return gen_rtx_SUBREG (mode, force_reg (GET_MODE (op), op), 0);
257 /* Otherwise, get an object of MODE, clobber it, and set the low-order
260 result = gen_reg_rtx (mode);
261 emit_clobber (result);
262 emit_move_insn (gen_lowpart (GET_MODE (op), result), op);
266 /* Return the optab used for computing the operation given by the tree code,
267 CODE and the tree EXP. This function is not always usable (for example, it
268 cannot give complete results for multiplication or division) but probably
269 ought to be relied on more widely throughout the expander. */
271 optab_for_tree_code (enum tree_code code, const_tree type,
272 enum optab_subtype subtype)
284 return one_cmpl_optab;
293 return TYPE_UNSIGNED (type) ? umod_optab : smod_optab;
301 if (TYPE_SATURATING(type))
302 return TYPE_UNSIGNED(type) ? usdiv_optab : ssdiv_optab;
303 return TYPE_UNSIGNED (type) ? udiv_optab : sdiv_optab;
306 if (TREE_CODE (type) == VECTOR_TYPE)
308 if (subtype == optab_vector)
309 return TYPE_SATURATING (type) ? NULL : vashl_optab;
311 gcc_assert (subtype == optab_scalar);
313 if (TYPE_SATURATING(type))
314 return TYPE_UNSIGNED(type) ? usashl_optab : ssashl_optab;
318 if (TREE_CODE (type) == VECTOR_TYPE)
320 if (subtype == optab_vector)
321 return TYPE_UNSIGNED (type) ? vlshr_optab : vashr_optab;
323 gcc_assert (subtype == optab_scalar);
325 return TYPE_UNSIGNED (type) ? lshr_optab : ashr_optab;
328 if (TREE_CODE (type) == VECTOR_TYPE)
330 if (subtype == optab_vector)
333 gcc_assert (subtype == optab_scalar);
338 if (TREE_CODE (type) == VECTOR_TYPE)
340 if (subtype == optab_vector)
343 gcc_assert (subtype == optab_scalar);
348 return TYPE_UNSIGNED (type) ? umax_optab : smax_optab;
351 return TYPE_UNSIGNED (type) ? umin_optab : smin_optab;
353 case REALIGN_LOAD_EXPR:
354 return vec_realign_load_optab;
357 return TYPE_UNSIGNED (type) ? usum_widen_optab : ssum_widen_optab;
360 return TYPE_UNSIGNED (type) ? udot_prod_optab : sdot_prod_optab;
362 case WIDEN_MULT_PLUS_EXPR:
363 return (TYPE_UNSIGNED (type)
364 ? (TYPE_SATURATING (type)
365 ? usmadd_widen_optab : umadd_widen_optab)
366 : (TYPE_SATURATING (type)
367 ? ssmadd_widen_optab : smadd_widen_optab));
369 case WIDEN_MULT_MINUS_EXPR:
370 return (TYPE_UNSIGNED (type)
371 ? (TYPE_SATURATING (type)
372 ? usmsub_widen_optab : umsub_widen_optab)
373 : (TYPE_SATURATING (type)
374 ? ssmsub_widen_optab : smsub_widen_optab));
380 return TYPE_UNSIGNED (type) ? reduc_umax_optab : reduc_smax_optab;
383 return TYPE_UNSIGNED (type) ? reduc_umin_optab : reduc_smin_optab;
385 case REDUC_PLUS_EXPR:
386 return TYPE_UNSIGNED (type) ? reduc_uplus_optab : reduc_splus_optab;
388 case VEC_LSHIFT_EXPR:
389 return vec_shl_optab;
391 case VEC_RSHIFT_EXPR:
392 return vec_shr_optab;
394 case VEC_WIDEN_MULT_HI_EXPR:
395 return TYPE_UNSIGNED (type) ?
396 vec_widen_umult_hi_optab : vec_widen_smult_hi_optab;
398 case VEC_WIDEN_MULT_LO_EXPR:
399 return TYPE_UNSIGNED (type) ?
400 vec_widen_umult_lo_optab : vec_widen_smult_lo_optab;
402 case VEC_UNPACK_HI_EXPR:
403 return TYPE_UNSIGNED (type) ?
404 vec_unpacku_hi_optab : vec_unpacks_hi_optab;
406 case VEC_UNPACK_LO_EXPR:
407 return TYPE_UNSIGNED (type) ?
408 vec_unpacku_lo_optab : vec_unpacks_lo_optab;
410 case VEC_UNPACK_FLOAT_HI_EXPR:
411 /* The signedness is determined from input operand. */
412 return TYPE_UNSIGNED (type) ?
413 vec_unpacku_float_hi_optab : vec_unpacks_float_hi_optab;
415 case VEC_UNPACK_FLOAT_LO_EXPR:
416 /* The signedness is determined from input operand. */
417 return TYPE_UNSIGNED (type) ?
418 vec_unpacku_float_lo_optab : vec_unpacks_float_lo_optab;
420 case VEC_PACK_TRUNC_EXPR:
421 return vec_pack_trunc_optab;
423 case VEC_PACK_SAT_EXPR:
424 return TYPE_UNSIGNED (type) ? vec_pack_usat_optab : vec_pack_ssat_optab;
426 case VEC_PACK_FIX_TRUNC_EXPR:
427 /* The signedness is determined from output operand. */
428 return TYPE_UNSIGNED (type) ?
429 vec_pack_ufix_trunc_optab : vec_pack_sfix_trunc_optab;
435 trapv = INTEGRAL_TYPE_P (type) && TYPE_OVERFLOW_TRAPS (type);
438 case POINTER_PLUS_EXPR:
440 if (TYPE_SATURATING(type))
441 return TYPE_UNSIGNED(type) ? usadd_optab : ssadd_optab;
442 return trapv ? addv_optab : add_optab;
445 if (TYPE_SATURATING(type))
446 return TYPE_UNSIGNED(type) ? ussub_optab : sssub_optab;
447 return trapv ? subv_optab : sub_optab;
450 if (TYPE_SATURATING(type))
451 return TYPE_UNSIGNED(type) ? usmul_optab : ssmul_optab;
452 return trapv ? smulv_optab : smul_optab;
455 if (TYPE_SATURATING(type))
456 return TYPE_UNSIGNED(type) ? usneg_optab : ssneg_optab;
457 return trapv ? negv_optab : neg_optab;
460 return trapv ? absv_optab : abs_optab;
462 case VEC_EXTRACT_EVEN_EXPR:
463 return vec_extract_even_optab;
465 case VEC_EXTRACT_ODD_EXPR:
466 return vec_extract_odd_optab;
468 case VEC_INTERLEAVE_HIGH_EXPR:
469 return vec_interleave_high_optab;
471 case VEC_INTERLEAVE_LOW_EXPR:
472 return vec_interleave_low_optab;
480 /* Expand vector widening operations.
482 There are two different classes of operations handled here:
483 1) Operations whose result is wider than all the arguments to the operation.
484 Examples: VEC_UNPACK_HI/LO_EXPR, VEC_WIDEN_MULT_HI/LO_EXPR
485 In this case OP0 and optionally OP1 would be initialized,
486 but WIDE_OP wouldn't (not relevant for this case).
487 2) Operations whose result is of the same size as the last argument to the
488 operation, but wider than all the other arguments to the operation.
489 Examples: WIDEN_SUM_EXPR, VEC_DOT_PROD_EXPR.
490 In the case WIDE_OP, OP0 and optionally OP1 would be initialized.
492 E.g, when called to expand the following operations, this is how
493 the arguments will be initialized:
495 widening-sum 2 oprnd0 - oprnd1
496 widening-dot-product 3 oprnd0 oprnd1 oprnd2
497 widening-mult 2 oprnd0 oprnd1 -
498 type-promotion (vec-unpack) 1 oprnd0 - - */
501 expand_widen_pattern_expr (sepops ops, rtx op0, rtx op1, rtx wide_op,
502 rtx target, int unsignedp)
504 struct expand_operand eops[4];
505 tree oprnd0, oprnd1, oprnd2;
506 enum machine_mode wmode = VOIDmode, tmode0, tmode1 = VOIDmode;
507 optab widen_pattern_optab;
508 enum insn_code icode;
509 int nops = TREE_CODE_LENGTH (ops->code);
513 tmode0 = TYPE_MODE (TREE_TYPE (oprnd0));
514 widen_pattern_optab =
515 optab_for_tree_code (ops->code, TREE_TYPE (oprnd0), optab_default);
516 if (ops->code == WIDEN_MULT_PLUS_EXPR
517 || ops->code == WIDEN_MULT_MINUS_EXPR)
518 icode = optab_handler (widen_pattern_optab,
519 TYPE_MODE (TREE_TYPE (ops->op2)));
521 icode = optab_handler (widen_pattern_optab, tmode0);
522 gcc_assert (icode != CODE_FOR_nothing);
527 tmode1 = TYPE_MODE (TREE_TYPE (oprnd1));
530 /* The last operand is of a wider mode than the rest of the operands. */
535 gcc_assert (tmode1 == tmode0);
538 wmode = TYPE_MODE (TREE_TYPE (oprnd2));
542 create_output_operand (&eops[op++], target, TYPE_MODE (ops->type));
543 create_convert_operand_from (&eops[op++], op0, tmode0, unsignedp);
545 create_convert_operand_from (&eops[op++], op1, tmode1, unsignedp);
547 create_convert_operand_from (&eops[op++], wide_op, wmode, unsignedp);
548 expand_insn (icode, op, eops);
549 return eops[0].value;
552 /* Generate code to perform an operation specified by TERNARY_OPTAB
553 on operands OP0, OP1 and OP2, with result having machine-mode MODE.
555 UNSIGNEDP is for the case where we have to widen the operands
556 to perform the operation. It says to use zero-extension.
558 If TARGET is nonzero, the value
559 is generated there, if it is convenient to do so.
560 In all cases an rtx is returned for the locus of the value;
561 this may or may not be TARGET. */
564 expand_ternary_op (enum machine_mode mode, optab ternary_optab, rtx op0,
565 rtx op1, rtx op2, rtx target, int unsignedp)
567 struct expand_operand ops[4];
568 enum insn_code icode = optab_handler (ternary_optab, mode);
570 gcc_assert (optab_handler (ternary_optab, mode) != CODE_FOR_nothing);
572 create_output_operand (&ops[0], target, mode);
573 create_convert_operand_from (&ops[1], op0, mode, unsignedp);
574 create_convert_operand_from (&ops[2], op1, mode, unsignedp);
575 create_convert_operand_from (&ops[3], op2, mode, unsignedp);
576 expand_insn (icode, 4, ops);
581 /* Like expand_binop, but return a constant rtx if the result can be
582 calculated at compile time. The arguments and return value are
583 otherwise the same as for expand_binop. */
586 simplify_expand_binop (enum machine_mode mode, optab binoptab,
587 rtx op0, rtx op1, rtx target, int unsignedp,
588 enum optab_methods methods)
590 if (CONSTANT_P (op0) && CONSTANT_P (op1))
592 rtx x = simplify_binary_operation (binoptab->code, mode, op0, op1);
598 return expand_binop (mode, binoptab, op0, op1, target, unsignedp, methods);
601 /* Like simplify_expand_binop, but always put the result in TARGET.
602 Return true if the expansion succeeded. */
605 force_expand_binop (enum machine_mode mode, optab binoptab,
606 rtx op0, rtx op1, rtx target, int unsignedp,
607 enum optab_methods methods)
609 rtx x = simplify_expand_binop (mode, binoptab, op0, op1,
610 target, unsignedp, methods);
614 emit_move_insn (target, x);
618 /* Generate insns for VEC_LSHIFT_EXPR, VEC_RSHIFT_EXPR. */
621 expand_vec_shift_expr (sepops ops, rtx target)
623 struct expand_operand eops[3];
624 enum insn_code icode;
625 rtx rtx_op1, rtx_op2;
626 enum machine_mode mode = TYPE_MODE (ops->type);
627 tree vec_oprnd = ops->op0;
628 tree shift_oprnd = ops->op1;
633 case VEC_RSHIFT_EXPR:
634 shift_optab = vec_shr_optab;
636 case VEC_LSHIFT_EXPR:
637 shift_optab = vec_shl_optab;
643 icode = optab_handler (shift_optab, mode);
644 gcc_assert (icode != CODE_FOR_nothing);
646 rtx_op1 = expand_normal (vec_oprnd);
647 rtx_op2 = expand_normal (shift_oprnd);
649 create_output_operand (&eops[0], target, mode);
650 create_input_operand (&eops[1], rtx_op1, GET_MODE (rtx_op1));
651 create_convert_operand_from_type (&eops[2], rtx_op2, TREE_TYPE (shift_oprnd));
652 expand_insn (icode, 3, eops);
654 return eops[0].value;
657 /* This subroutine of expand_doubleword_shift handles the cases in which
658 the effective shift value is >= BITS_PER_WORD. The arguments and return
659 value are the same as for the parent routine, except that SUPERWORD_OP1
660 is the shift count to use when shifting OUTOF_INPUT into INTO_TARGET.
661 INTO_TARGET may be null if the caller has decided to calculate it. */
664 expand_superword_shift (optab binoptab, rtx outof_input, rtx superword_op1,
665 rtx outof_target, rtx into_target,
666 int unsignedp, enum optab_methods methods)
668 if (into_target != 0)
669 if (!force_expand_binop (word_mode, binoptab, outof_input, superword_op1,
670 into_target, unsignedp, methods))
673 if (outof_target != 0)
675 /* For a signed right shift, we must fill OUTOF_TARGET with copies
676 of the sign bit, otherwise we must fill it with zeros. */
677 if (binoptab != ashr_optab)
678 emit_move_insn (outof_target, CONST0_RTX (word_mode));
680 if (!force_expand_binop (word_mode, binoptab,
681 outof_input, GEN_INT (BITS_PER_WORD - 1),
682 outof_target, unsignedp, methods))
688 /* This subroutine of expand_doubleword_shift handles the cases in which
689 the effective shift value is < BITS_PER_WORD. The arguments and return
690 value are the same as for the parent routine. */
693 expand_subword_shift (enum machine_mode op1_mode, optab binoptab,
694 rtx outof_input, rtx into_input, rtx op1,
695 rtx outof_target, rtx into_target,
696 int unsignedp, enum optab_methods methods,
697 unsigned HOST_WIDE_INT shift_mask)
699 optab reverse_unsigned_shift, unsigned_shift;
702 reverse_unsigned_shift = (binoptab == ashl_optab ? lshr_optab : ashl_optab);
703 unsigned_shift = (binoptab == ashl_optab ? ashl_optab : lshr_optab);
705 /* The low OP1 bits of INTO_TARGET come from the high bits of OUTOF_INPUT.
706 We therefore need to shift OUTOF_INPUT by (BITS_PER_WORD - OP1) bits in
707 the opposite direction to BINOPTAB. */
708 if (CONSTANT_P (op1) || shift_mask >= BITS_PER_WORD)
710 carries = outof_input;
711 tmp = immed_double_const (BITS_PER_WORD, 0, op1_mode);
712 tmp = simplify_expand_binop (op1_mode, sub_optab, tmp, op1,
717 /* We must avoid shifting by BITS_PER_WORD bits since that is either
718 the same as a zero shift (if shift_mask == BITS_PER_WORD - 1) or
719 has unknown behavior. Do a single shift first, then shift by the
720 remainder. It's OK to use ~OP1 as the remainder if shift counts
721 are truncated to the mode size. */
722 carries = expand_binop (word_mode, reverse_unsigned_shift,
723 outof_input, const1_rtx, 0, unsignedp, methods);
724 if (shift_mask == BITS_PER_WORD - 1)
726 tmp = immed_double_const (-1, -1, op1_mode);
727 tmp = simplify_expand_binop (op1_mode, xor_optab, op1, tmp,
732 tmp = immed_double_const (BITS_PER_WORD - 1, 0, op1_mode);
733 tmp = simplify_expand_binop (op1_mode, sub_optab, tmp, op1,
737 if (tmp == 0 || carries == 0)
739 carries = expand_binop (word_mode, reverse_unsigned_shift,
740 carries, tmp, 0, unsignedp, methods);
744 /* Shift INTO_INPUT logically by OP1. This is the last use of INTO_INPUT
745 so the result can go directly into INTO_TARGET if convenient. */
746 tmp = expand_binop (word_mode, unsigned_shift, into_input, op1,
747 into_target, unsignedp, methods);
751 /* Now OR in the bits carried over from OUTOF_INPUT. */
752 if (!force_expand_binop (word_mode, ior_optab, tmp, carries,
753 into_target, unsignedp, methods))
756 /* Use a standard word_mode shift for the out-of half. */
757 if (outof_target != 0)
758 if (!force_expand_binop (word_mode, binoptab, outof_input, op1,
759 outof_target, unsignedp, methods))
766 #ifdef HAVE_conditional_move
767 /* Try implementing expand_doubleword_shift using conditional moves.
768 The shift is by < BITS_PER_WORD if (CMP_CODE CMP1 CMP2) is true,
769 otherwise it is by >= BITS_PER_WORD. SUBWORD_OP1 and SUPERWORD_OP1
770 are the shift counts to use in the former and latter case. All other
771 arguments are the same as the parent routine. */
774 expand_doubleword_shift_condmove (enum machine_mode op1_mode, optab binoptab,
775 enum rtx_code cmp_code, rtx cmp1, rtx cmp2,
776 rtx outof_input, rtx into_input,
777 rtx subword_op1, rtx superword_op1,
778 rtx outof_target, rtx into_target,
779 int unsignedp, enum optab_methods methods,
780 unsigned HOST_WIDE_INT shift_mask)
782 rtx outof_superword, into_superword;
784 /* Put the superword version of the output into OUTOF_SUPERWORD and
786 outof_superword = outof_target != 0 ? gen_reg_rtx (word_mode) : 0;
787 if (outof_target != 0 && subword_op1 == superword_op1)
789 /* The value INTO_TARGET >> SUBWORD_OP1, which we later store in
790 OUTOF_TARGET, is the same as the value of INTO_SUPERWORD. */
791 into_superword = outof_target;
792 if (!expand_superword_shift (binoptab, outof_input, superword_op1,
793 outof_superword, 0, unsignedp, methods))
798 into_superword = gen_reg_rtx (word_mode);
799 if (!expand_superword_shift (binoptab, outof_input, superword_op1,
800 outof_superword, into_superword,
805 /* Put the subword version directly in OUTOF_TARGET and INTO_TARGET. */
806 if (!expand_subword_shift (op1_mode, binoptab,
807 outof_input, into_input, subword_op1,
808 outof_target, into_target,
809 unsignedp, methods, shift_mask))
812 /* Select between them. Do the INTO half first because INTO_SUPERWORD
813 might be the current value of OUTOF_TARGET. */
814 if (!emit_conditional_move (into_target, cmp_code, cmp1, cmp2, op1_mode,
815 into_target, into_superword, word_mode, false))
818 if (outof_target != 0)
819 if (!emit_conditional_move (outof_target, cmp_code, cmp1, cmp2, op1_mode,
820 outof_target, outof_superword,
828 /* Expand a doubleword shift (ashl, ashr or lshr) using word-mode shifts.
829 OUTOF_INPUT and INTO_INPUT are the two word-sized halves of the first
830 input operand; the shift moves bits in the direction OUTOF_INPUT->
831 INTO_TARGET. OUTOF_TARGET and INTO_TARGET are the equivalent words
832 of the target. OP1 is the shift count and OP1_MODE is its mode.
833 If OP1 is constant, it will have been truncated as appropriate
834 and is known to be nonzero.
836 If SHIFT_MASK is zero, the result of word shifts is undefined when the
837 shift count is outside the range [0, BITS_PER_WORD). This routine must
838 avoid generating such shifts for OP1s in the range [0, BITS_PER_WORD * 2).
840 If SHIFT_MASK is nonzero, all word-mode shift counts are effectively
841 masked by it and shifts in the range [BITS_PER_WORD, SHIFT_MASK) will
842 fill with zeros or sign bits as appropriate.
844 If SHIFT_MASK is BITS_PER_WORD - 1, this routine will synthesize
845 a doubleword shift whose equivalent mask is BITS_PER_WORD * 2 - 1.
846 Doing this preserves semantics required by SHIFT_COUNT_TRUNCATED.
847 In all other cases, shifts by values outside [0, BITS_PER_UNIT * 2)
850 BINOPTAB, UNSIGNEDP and METHODS are as for expand_binop. This function
851 may not use INTO_INPUT after modifying INTO_TARGET, and similarly for
852 OUTOF_INPUT and OUTOF_TARGET. OUTOF_TARGET can be null if the parent
853 function wants to calculate it itself.
855 Return true if the shift could be successfully synthesized. */
858 expand_doubleword_shift (enum machine_mode op1_mode, optab binoptab,
859 rtx outof_input, rtx into_input, rtx op1,
860 rtx outof_target, rtx into_target,
861 int unsignedp, enum optab_methods methods,
862 unsigned HOST_WIDE_INT shift_mask)
864 rtx superword_op1, tmp, cmp1, cmp2;
865 rtx subword_label, done_label;
866 enum rtx_code cmp_code;
868 /* See if word-mode shifts by BITS_PER_WORD...BITS_PER_WORD * 2 - 1 will
869 fill the result with sign or zero bits as appropriate. If so, the value
870 of OUTOF_TARGET will always be (SHIFT OUTOF_INPUT OP1). Recursively call
871 this routine to calculate INTO_TARGET (which depends on both OUTOF_INPUT
872 and INTO_INPUT), then emit code to set up OUTOF_TARGET.
874 This isn't worthwhile for constant shifts since the optimizers will
875 cope better with in-range shift counts. */
876 if (shift_mask >= BITS_PER_WORD
878 && !CONSTANT_P (op1))
880 if (!expand_doubleword_shift (op1_mode, binoptab,
881 outof_input, into_input, op1,
883 unsignedp, methods, shift_mask))
885 if (!force_expand_binop (word_mode, binoptab, outof_input, op1,
886 outof_target, unsignedp, methods))
891 /* Set CMP_CODE, CMP1 and CMP2 so that the rtx (CMP_CODE CMP1 CMP2)
892 is true when the effective shift value is less than BITS_PER_WORD.
893 Set SUPERWORD_OP1 to the shift count that should be used to shift
894 OUTOF_INPUT into INTO_TARGET when the condition is false. */
895 tmp = immed_double_const (BITS_PER_WORD, 0, op1_mode);
896 if (!CONSTANT_P (op1) && shift_mask == BITS_PER_WORD - 1)
898 /* Set CMP1 to OP1 & BITS_PER_WORD. The result is zero iff OP1
899 is a subword shift count. */
900 cmp1 = simplify_expand_binop (op1_mode, and_optab, op1, tmp,
902 cmp2 = CONST0_RTX (op1_mode);
908 /* Set CMP1 to OP1 - BITS_PER_WORD. */
909 cmp1 = simplify_expand_binop (op1_mode, sub_optab, op1, tmp,
911 cmp2 = CONST0_RTX (op1_mode);
913 superword_op1 = cmp1;
918 /* If we can compute the condition at compile time, pick the
919 appropriate subroutine. */
920 tmp = simplify_relational_operation (cmp_code, SImode, op1_mode, cmp1, cmp2);
921 if (tmp != 0 && CONST_INT_P (tmp))
923 if (tmp == const0_rtx)
924 return expand_superword_shift (binoptab, outof_input, superword_op1,
925 outof_target, into_target,
928 return expand_subword_shift (op1_mode, binoptab,
929 outof_input, into_input, op1,
930 outof_target, into_target,
931 unsignedp, methods, shift_mask);
934 #ifdef HAVE_conditional_move
935 /* Try using conditional moves to generate straight-line code. */
937 rtx start = get_last_insn ();
938 if (expand_doubleword_shift_condmove (op1_mode, binoptab,
939 cmp_code, cmp1, cmp2,
940 outof_input, into_input,
942 outof_target, into_target,
943 unsignedp, methods, shift_mask))
945 delete_insns_since (start);
949 /* As a last resort, use branches to select the correct alternative. */
950 subword_label = gen_label_rtx ();
951 done_label = gen_label_rtx ();
954 do_compare_rtx_and_jump (cmp1, cmp2, cmp_code, false, op1_mode,
955 0, 0, subword_label, -1);
958 if (!expand_superword_shift (binoptab, outof_input, superword_op1,
959 outof_target, into_target,
963 emit_jump_insn (gen_jump (done_label));
965 emit_label (subword_label);
967 if (!expand_subword_shift (op1_mode, binoptab,
968 outof_input, into_input, op1,
969 outof_target, into_target,
970 unsignedp, methods, shift_mask))
973 emit_label (done_label);
977 /* Subroutine of expand_binop. Perform a double word multiplication of
978 operands OP0 and OP1 both of mode MODE, which is exactly twice as wide
979 as the target's word_mode. This function return NULL_RTX if anything
980 goes wrong, in which case it may have already emitted instructions
981 which need to be deleted.
983 If we want to multiply two two-word values and have normal and widening
984 multiplies of single-word values, we can do this with three smaller
987 The multiplication proceeds as follows:
988 _______________________
989 [__op0_high_|__op0_low__]
990 _______________________
991 * [__op1_high_|__op1_low__]
992 _______________________________________________
993 _______________________
994 (1) [__op0_low__*__op1_low__]
995 _______________________
996 (2a) [__op0_low__*__op1_high_]
997 _______________________
998 (2b) [__op0_high_*__op1_low__]
999 _______________________
1000 (3) [__op0_high_*__op1_high_]
1003 This gives a 4-word result. Since we are only interested in the
1004 lower 2 words, partial result (3) and the upper words of (2a) and
1005 (2b) don't need to be calculated. Hence (2a) and (2b) can be
1006 calculated using non-widening multiplication.
1008 (1), however, needs to be calculated with an unsigned widening
1009 multiplication. If this operation is not directly supported we
1010 try using a signed widening multiplication and adjust the result.
1011 This adjustment works as follows:
1013 If both operands are positive then no adjustment is needed.
1015 If the operands have different signs, for example op0_low < 0 and
1016 op1_low >= 0, the instruction treats the most significant bit of
1017 op0_low as a sign bit instead of a bit with significance
1018 2**(BITS_PER_WORD-1), i.e. the instruction multiplies op1_low
1019 with 2**BITS_PER_WORD - op0_low, and two's complements the
1020 result. Conclusion: We need to add op1_low * 2**BITS_PER_WORD to
1023 Similarly, if both operands are negative, we need to add
1024 (op0_low + op1_low) * 2**BITS_PER_WORD.
1026 We use a trick to adjust quickly. We logically shift op0_low right
1027 (op1_low) BITS_PER_WORD-1 steps to get 0 or 1, and add this to
1028 op0_high (op1_high) before it is used to calculate 2b (2a). If no
1029 logical shift exists, we do an arithmetic right shift and subtract
1033 expand_doubleword_mult (enum machine_mode mode, rtx op0, rtx op1, rtx target,
1034 bool umulp, enum optab_methods methods)
1036 int low = (WORDS_BIG_ENDIAN ? 1 : 0);
1037 int high = (WORDS_BIG_ENDIAN ? 0 : 1);
1038 rtx wordm1 = umulp ? NULL_RTX : GEN_INT (BITS_PER_WORD - 1);
1039 rtx product, adjust, product_high, temp;
1041 rtx op0_high = operand_subword_force (op0, high, mode);
1042 rtx op0_low = operand_subword_force (op0, low, mode);
1043 rtx op1_high = operand_subword_force (op1, high, mode);
1044 rtx op1_low = operand_subword_force (op1, low, mode);
1046 /* If we're using an unsigned multiply to directly compute the product
1047 of the low-order words of the operands and perform any required
1048 adjustments of the operands, we begin by trying two more multiplications
1049 and then computing the appropriate sum.
1051 We have checked above that the required addition is provided.
1052 Full-word addition will normally always succeed, especially if
1053 it is provided at all, so we don't worry about its failure. The
1054 multiplication may well fail, however, so we do handle that. */
1058 /* ??? This could be done with emit_store_flag where available. */
1059 temp = expand_binop (word_mode, lshr_optab, op0_low, wordm1,
1060 NULL_RTX, 1, methods);
1062 op0_high = expand_binop (word_mode, add_optab, op0_high, temp,
1063 NULL_RTX, 0, OPTAB_DIRECT);
1066 temp = expand_binop (word_mode, ashr_optab, op0_low, wordm1,
1067 NULL_RTX, 0, methods);
1070 op0_high = expand_binop (word_mode, sub_optab, op0_high, temp,
1071 NULL_RTX, 0, OPTAB_DIRECT);
1078 adjust = expand_binop (word_mode, smul_optab, op0_high, op1_low,
1079 NULL_RTX, 0, OPTAB_DIRECT);
1083 /* OP0_HIGH should now be dead. */
1087 /* ??? This could be done with emit_store_flag where available. */
1088 temp = expand_binop (word_mode, lshr_optab, op1_low, wordm1,
1089 NULL_RTX, 1, methods);
1091 op1_high = expand_binop (word_mode, add_optab, op1_high, temp,
1092 NULL_RTX, 0, OPTAB_DIRECT);
1095 temp = expand_binop (word_mode, ashr_optab, op1_low, wordm1,
1096 NULL_RTX, 0, methods);
1099 op1_high = expand_binop (word_mode, sub_optab, op1_high, temp,
1100 NULL_RTX, 0, OPTAB_DIRECT);
1107 temp = expand_binop (word_mode, smul_optab, op1_high, op0_low,
1108 NULL_RTX, 0, OPTAB_DIRECT);
1112 /* OP1_HIGH should now be dead. */
1114 adjust = expand_binop (word_mode, add_optab, adjust, temp,
1115 NULL_RTX, 0, OPTAB_DIRECT);
1117 if (target && !REG_P (target))
1121 product = expand_binop (mode, umul_widen_optab, op0_low, op1_low,
1122 target, 1, OPTAB_DIRECT);
1124 product = expand_binop (mode, smul_widen_optab, op0_low, op1_low,
1125 target, 1, OPTAB_DIRECT);
1130 product_high = operand_subword (product, high, 1, mode);
1131 adjust = expand_binop (word_mode, add_optab, product_high, adjust,
1132 NULL_RTX, 0, OPTAB_DIRECT);
1133 emit_move_insn (product_high, adjust);
1137 /* Wrapper around expand_binop which takes an rtx code to specify
1138 the operation to perform, not an optab pointer. All other
1139 arguments are the same. */
1141 expand_simple_binop (enum machine_mode mode, enum rtx_code code, rtx op0,
1142 rtx op1, rtx target, int unsignedp,
1143 enum optab_methods methods)
1145 optab binop = code_to_optab[(int) code];
1148 return expand_binop (mode, binop, op0, op1, target, unsignedp, methods);
1151 /* Return whether OP0 and OP1 should be swapped when expanding a commutative
1152 binop. Order them according to commutative_operand_precedence and, if
1153 possible, try to put TARGET or a pseudo first. */
1155 swap_commutative_operands_with_target (rtx target, rtx op0, rtx op1)
1157 int op0_prec = commutative_operand_precedence (op0);
1158 int op1_prec = commutative_operand_precedence (op1);
1160 if (op0_prec < op1_prec)
1163 if (op0_prec > op1_prec)
1166 /* With equal precedence, both orders are ok, but it is better if the
1167 first operand is TARGET, or if both TARGET and OP0 are pseudos. */
1168 if (target == 0 || REG_P (target))
1169 return (REG_P (op1) && !REG_P (op0)) || target == op1;
1171 return rtx_equal_p (op1, target);
1174 /* Return true if BINOPTAB implements a shift operation. */
1177 shift_optab_p (optab binoptab)
1179 switch (binoptab->code)
1195 /* Return true if BINOPTAB implements a commutative binary operation. */
1198 commutative_optab_p (optab binoptab)
1200 return (GET_RTX_CLASS (binoptab->code) == RTX_COMM_ARITH
1201 || binoptab == smul_widen_optab
1202 || binoptab == umul_widen_optab
1203 || binoptab == smul_highpart_optab
1204 || binoptab == umul_highpart_optab);
1207 /* X is to be used in mode MODE as an operand to BINOPTAB. If we're
1208 optimizing, and if the operand is a constant that costs more than
1209 1 instruction, force the constant into a register and return that
1210 register. Return X otherwise. UNSIGNEDP says whether X is unsigned. */
1213 avoid_expensive_constant (enum machine_mode mode, optab binoptab,
1214 rtx x, bool unsignedp)
1216 bool speed = optimize_insn_for_speed_p ();
1218 if (mode != VOIDmode
1221 && rtx_cost (x, binoptab->code, speed) > rtx_cost (x, SET, speed))
1223 if (CONST_INT_P (x))
1225 HOST_WIDE_INT intval = trunc_int_for_mode (INTVAL (x), mode);
1226 if (intval != INTVAL (x))
1227 x = GEN_INT (intval);
1230 x = convert_modes (mode, VOIDmode, x, unsignedp);
1231 x = force_reg (mode, x);
1236 /* Helper function for expand_binop: handle the case where there
1237 is an insn that directly implements the indicated operation.
1238 Returns null if this is not possible. */
1240 expand_binop_directly (enum machine_mode mode, optab binoptab,
1242 rtx target, int unsignedp, enum optab_methods methods,
1245 enum insn_code icode = optab_handler (binoptab, mode);
1246 enum machine_mode xmode0 = insn_data[(int) icode].operand[1].mode;
1247 enum machine_mode xmode1 = insn_data[(int) icode].operand[2].mode;
1248 enum machine_mode mode0, mode1, tmp_mode;
1249 struct expand_operand ops[3];
1252 rtx xop0 = op0, xop1 = op1;
1255 /* If it is a commutative operator and the modes would match
1256 if we would swap the operands, we can save the conversions. */
1257 commutative_p = commutative_optab_p (binoptab);
1259 && GET_MODE (xop0) != xmode0 && GET_MODE (xop1) != xmode1
1260 && GET_MODE (xop0) == xmode1 && GET_MODE (xop1) == xmode1)
1267 /* If we are optimizing, force expensive constants into a register. */
1268 xop0 = avoid_expensive_constant (xmode0, binoptab, xop0, unsignedp);
1269 if (!shift_optab_p (binoptab))
1270 xop1 = avoid_expensive_constant (xmode1, binoptab, xop1, unsignedp);
1272 /* In case the insn wants input operands in modes different from
1273 those of the actual operands, convert the operands. It would
1274 seem that we don't need to convert CONST_INTs, but we do, so
1275 that they're properly zero-extended, sign-extended or truncated
1278 mode0 = GET_MODE (xop0) != VOIDmode ? GET_MODE (xop0) : mode;
1279 if (xmode0 != VOIDmode && xmode0 != mode0)
1281 xop0 = convert_modes (xmode0, mode0, xop0, unsignedp);
1285 mode1 = GET_MODE (xop1) != VOIDmode ? GET_MODE (xop1) : mode;
1286 if (xmode1 != VOIDmode && xmode1 != mode1)
1288 xop1 = convert_modes (xmode1, mode1, xop1, unsignedp);
1292 /* If operation is commutative,
1293 try to make the first operand a register.
1294 Even better, try to make it the same as the target.
1295 Also try to make the last operand a constant. */
1297 && swap_commutative_operands_with_target (target, xop0, xop1))
1304 /* Now, if insn's predicates don't allow our operands, put them into
1307 if (binoptab == vec_pack_trunc_optab
1308 || binoptab == vec_pack_usat_optab
1309 || binoptab == vec_pack_ssat_optab
1310 || binoptab == vec_pack_ufix_trunc_optab
1311 || binoptab == vec_pack_sfix_trunc_optab)
1313 /* The mode of the result is different then the mode of the
1315 tmp_mode = insn_data[(int) icode].operand[0].mode;
1316 if (GET_MODE_NUNITS (tmp_mode) != 2 * GET_MODE_NUNITS (mode))
1318 delete_insns_since (last);
1325 create_output_operand (&ops[0], target, tmp_mode);
1326 create_input_operand (&ops[1], xop0, mode0);
1327 create_input_operand (&ops[2], xop1, mode1);
1328 pat = maybe_gen_insn (icode, 3, ops);
1331 /* If PAT is composed of more than one insn, try to add an appropriate
1332 REG_EQUAL note to it. If we can't because TEMP conflicts with an
1333 operand, call expand_binop again, this time without a target. */
1334 if (INSN_P (pat) && NEXT_INSN (pat) != NULL_RTX
1335 && ! add_equal_note (pat, ops[0].value, binoptab->code,
1336 ops[1].value, ops[2].value))
1338 delete_insns_since (last);
1339 return expand_binop (mode, binoptab, op0, op1, NULL_RTX,
1340 unsignedp, methods);
1344 return ops[0].value;
1346 delete_insns_since (last);
1350 /* Generate code to perform an operation specified by BINOPTAB
1351 on operands OP0 and OP1, with result having machine-mode MODE.
1353 UNSIGNEDP is for the case where we have to widen the operands
1354 to perform the operation. It says to use zero-extension.
1356 If TARGET is nonzero, the value
1357 is generated there, if it is convenient to do so.
1358 In all cases an rtx is returned for the locus of the value;
1359 this may or may not be TARGET. */
1362 expand_binop (enum machine_mode mode, optab binoptab, rtx op0, rtx op1,
1363 rtx target, int unsignedp, enum optab_methods methods)
1365 enum optab_methods next_methods
1366 = (methods == OPTAB_LIB || methods == OPTAB_LIB_WIDEN
1367 ? OPTAB_WIDEN : methods);
1368 enum mode_class mclass;
1369 enum machine_mode wider_mode;
1372 rtx entry_last = get_last_insn ();
1375 mclass = GET_MODE_CLASS (mode);
1377 /* If subtracting an integer constant, convert this into an addition of
1378 the negated constant. */
1380 if (binoptab == sub_optab && CONST_INT_P (op1))
1382 op1 = negate_rtx (mode, op1);
1383 binoptab = add_optab;
1386 /* Record where to delete back to if we backtrack. */
1387 last = get_last_insn ();
1389 /* If we can do it with a three-operand insn, do so. */
1391 if (methods != OPTAB_MUST_WIDEN
1392 && optab_handler (binoptab, mode) != CODE_FOR_nothing)
1394 temp = expand_binop_directly (mode, binoptab, op0, op1, target,
1395 unsignedp, methods, last);
1400 /* If we were trying to rotate, and that didn't work, try rotating
1401 the other direction before falling back to shifts and bitwise-or. */
1402 if (((binoptab == rotl_optab
1403 && optab_handler (rotr_optab, mode) != CODE_FOR_nothing)
1404 || (binoptab == rotr_optab
1405 && optab_handler (rotl_optab, mode) != CODE_FOR_nothing))
1406 && mclass == MODE_INT)
1408 optab otheroptab = (binoptab == rotl_optab ? rotr_optab : rotl_optab);
1410 unsigned int bits = GET_MODE_PRECISION (mode);
1412 if (CONST_INT_P (op1))
1413 newop1 = GEN_INT (bits - INTVAL (op1));
1414 else if (targetm.shift_truncation_mask (mode) == bits - 1)
1415 newop1 = negate_rtx (GET_MODE (op1), op1);
1417 newop1 = expand_binop (GET_MODE (op1), sub_optab,
1418 GEN_INT (bits), op1,
1419 NULL_RTX, unsignedp, OPTAB_DIRECT);
1421 temp = expand_binop_directly (mode, otheroptab, op0, newop1,
1422 target, unsignedp, methods, last);
1427 /* If this is a multiply, see if we can do a widening operation that
1428 takes operands of this mode and makes a wider mode. */
1430 if (binoptab == smul_optab
1431 && GET_MODE_WIDER_MODE (mode) != VOIDmode
1432 && (optab_handler ((unsignedp ? umul_widen_optab : smul_widen_optab),
1433 GET_MODE_WIDER_MODE (mode))
1434 != CODE_FOR_nothing))
1436 temp = expand_binop (GET_MODE_WIDER_MODE (mode),
1437 unsignedp ? umul_widen_optab : smul_widen_optab,
1438 op0, op1, NULL_RTX, unsignedp, OPTAB_DIRECT);
1442 if (GET_MODE_CLASS (mode) == MODE_INT
1443 && TRULY_NOOP_TRUNCATION_MODES_P (mode, GET_MODE (temp)))
1444 return gen_lowpart (mode, temp);
1446 return convert_to_mode (mode, temp, unsignedp);
1450 /* Look for a wider mode of the same class for which we think we
1451 can open-code the operation. Check for a widening multiply at the
1452 wider mode as well. */
1454 if (CLASS_HAS_WIDER_MODES_P (mclass)
1455 && methods != OPTAB_DIRECT && methods != OPTAB_LIB)
1456 for (wider_mode = GET_MODE_WIDER_MODE (mode);
1457 wider_mode != VOIDmode;
1458 wider_mode = GET_MODE_WIDER_MODE (wider_mode))
1460 if (optab_handler (binoptab, wider_mode) != CODE_FOR_nothing
1461 || (binoptab == smul_optab
1462 && GET_MODE_WIDER_MODE (wider_mode) != VOIDmode
1463 && (optab_handler ((unsignedp ? umul_widen_optab
1464 : smul_widen_optab),
1465 GET_MODE_WIDER_MODE (wider_mode))
1466 != CODE_FOR_nothing)))
1468 rtx xop0 = op0, xop1 = op1;
1471 /* For certain integer operations, we need not actually extend
1472 the narrow operands, as long as we will truncate
1473 the results to the same narrowness. */
1475 if ((binoptab == ior_optab || binoptab == and_optab
1476 || binoptab == xor_optab
1477 || binoptab == add_optab || binoptab == sub_optab
1478 || binoptab == smul_optab || binoptab == ashl_optab)
1479 && mclass == MODE_INT)
1482 xop0 = avoid_expensive_constant (mode, binoptab,
1484 if (binoptab != ashl_optab)
1485 xop1 = avoid_expensive_constant (mode, binoptab,
1489 xop0 = widen_operand (xop0, wider_mode, mode, unsignedp, no_extend);
1491 /* The second operand of a shift must always be extended. */
1492 xop1 = widen_operand (xop1, wider_mode, mode, unsignedp,
1493 no_extend && binoptab != ashl_optab);
1495 temp = expand_binop (wider_mode, binoptab, xop0, xop1, NULL_RTX,
1496 unsignedp, OPTAB_DIRECT);
1499 if (mclass != MODE_INT
1500 || !TRULY_NOOP_TRUNCATION_MODES_P (mode, wider_mode))
1503 target = gen_reg_rtx (mode);
1504 convert_move (target, temp, 0);
1508 return gen_lowpart (mode, temp);
1511 delete_insns_since (last);
1515 /* If operation is commutative,
1516 try to make the first operand a register.
1517 Even better, try to make it the same as the target.
1518 Also try to make the last operand a constant. */
1519 if (commutative_optab_p (binoptab)
1520 && swap_commutative_operands_with_target (target, op0, op1))
1527 /* These can be done a word at a time. */
1528 if ((binoptab == and_optab || binoptab == ior_optab || binoptab == xor_optab)
1529 && mclass == MODE_INT
1530 && GET_MODE_SIZE (mode) > UNITS_PER_WORD
1531 && optab_handler (binoptab, word_mode) != CODE_FOR_nothing)
1536 /* If TARGET is the same as one of the operands, the REG_EQUAL note
1537 won't be accurate, so use a new target. */
1541 || !valid_multiword_target_p (target))
1542 target = gen_reg_rtx (mode);
1546 /* Do the actual arithmetic. */
1547 for (i = 0; i < GET_MODE_BITSIZE (mode) / BITS_PER_WORD; i++)
1549 rtx target_piece = operand_subword (target, i, 1, mode);
1550 rtx x = expand_binop (word_mode, binoptab,
1551 operand_subword_force (op0, i, mode),
1552 operand_subword_force (op1, i, mode),
1553 target_piece, unsignedp, next_methods);
1558 if (target_piece != x)
1559 emit_move_insn (target_piece, x);
1562 insns = get_insns ();
1565 if (i == GET_MODE_BITSIZE (mode) / BITS_PER_WORD)
1572 /* Synthesize double word shifts from single word shifts. */
1573 if ((binoptab == lshr_optab || binoptab == ashl_optab
1574 || binoptab == ashr_optab)
1575 && mclass == MODE_INT
1576 && (CONST_INT_P (op1) || optimize_insn_for_speed_p ())
1577 && GET_MODE_SIZE (mode) == 2 * UNITS_PER_WORD
1578 && optab_handler (binoptab, word_mode) != CODE_FOR_nothing
1579 && optab_handler (ashl_optab, word_mode) != CODE_FOR_nothing
1580 && optab_handler (lshr_optab, word_mode) != CODE_FOR_nothing)
1582 unsigned HOST_WIDE_INT shift_mask, double_shift_mask;
1583 enum machine_mode op1_mode;
1585 double_shift_mask = targetm.shift_truncation_mask (mode);
1586 shift_mask = targetm.shift_truncation_mask (word_mode);
1587 op1_mode = GET_MODE (op1) != VOIDmode ? GET_MODE (op1) : word_mode;
1589 /* Apply the truncation to constant shifts. */
1590 if (double_shift_mask > 0 && CONST_INT_P (op1))
1591 op1 = GEN_INT (INTVAL (op1) & double_shift_mask);
1593 if (op1 == CONST0_RTX (op1_mode))
1596 /* Make sure that this is a combination that expand_doubleword_shift
1597 can handle. See the comments there for details. */
1598 if (double_shift_mask == 0
1599 || (shift_mask == BITS_PER_WORD - 1
1600 && double_shift_mask == BITS_PER_WORD * 2 - 1))
1603 rtx into_target, outof_target;
1604 rtx into_input, outof_input;
1605 int left_shift, outof_word;
1607 /* If TARGET is the same as one of the operands, the REG_EQUAL note
1608 won't be accurate, so use a new target. */
1612 || !valid_multiword_target_p (target))
1613 target = gen_reg_rtx (mode);
1617 /* OUTOF_* is the word we are shifting bits away from, and
1618 INTO_* is the word that we are shifting bits towards, thus
1619 they differ depending on the direction of the shift and
1620 WORDS_BIG_ENDIAN. */
1622 left_shift = binoptab == ashl_optab;
1623 outof_word = left_shift ^ ! WORDS_BIG_ENDIAN;
1625 outof_target = operand_subword (target, outof_word, 1, mode);
1626 into_target = operand_subword (target, 1 - outof_word, 1, mode);
1628 outof_input = operand_subword_force (op0, outof_word, mode);
1629 into_input = operand_subword_force (op0, 1 - outof_word, mode);
1631 if (expand_doubleword_shift (op1_mode, binoptab,
1632 outof_input, into_input, op1,
1633 outof_target, into_target,
1634 unsignedp, next_methods, shift_mask))
1636 insns = get_insns ();
1646 /* Synthesize double word rotates from single word shifts. */
1647 if ((binoptab == rotl_optab || binoptab == rotr_optab)
1648 && mclass == MODE_INT
1649 && CONST_INT_P (op1)
1650 && GET_MODE_SIZE (mode) == 2 * UNITS_PER_WORD
1651 && optab_handler (ashl_optab, word_mode) != CODE_FOR_nothing
1652 && optab_handler (lshr_optab, word_mode) != CODE_FOR_nothing)
1655 rtx into_target, outof_target;
1656 rtx into_input, outof_input;
1658 int shift_count, left_shift, outof_word;
1660 /* If TARGET is the same as one of the operands, the REG_EQUAL note
1661 won't be accurate, so use a new target. Do this also if target is not
1662 a REG, first because having a register instead may open optimization
1663 opportunities, and second because if target and op0 happen to be MEMs
1664 designating the same location, we would risk clobbering it too early
1665 in the code sequence we generate below. */
1670 || !valid_multiword_target_p (target))
1671 target = gen_reg_rtx (mode);
1675 shift_count = INTVAL (op1);
1677 /* OUTOF_* is the word we are shifting bits away from, and
1678 INTO_* is the word that we are shifting bits towards, thus
1679 they differ depending on the direction of the shift and
1680 WORDS_BIG_ENDIAN. */
1682 left_shift = (binoptab == rotl_optab);
1683 outof_word = left_shift ^ ! WORDS_BIG_ENDIAN;
1685 outof_target = operand_subword (target, outof_word, 1, mode);
1686 into_target = operand_subword (target, 1 - outof_word, 1, mode);
1688 outof_input = operand_subword_force (op0, outof_word, mode);
1689 into_input = operand_subword_force (op0, 1 - outof_word, mode);
1691 if (shift_count == BITS_PER_WORD)
1693 /* This is just a word swap. */
1694 emit_move_insn (outof_target, into_input);
1695 emit_move_insn (into_target, outof_input);
1700 rtx into_temp1, into_temp2, outof_temp1, outof_temp2;
1701 rtx first_shift_count, second_shift_count;
1702 optab reverse_unsigned_shift, unsigned_shift;
1704 reverse_unsigned_shift = (left_shift ^ (shift_count < BITS_PER_WORD)
1705 ? lshr_optab : ashl_optab);
1707 unsigned_shift = (left_shift ^ (shift_count < BITS_PER_WORD)
1708 ? ashl_optab : lshr_optab);
1710 if (shift_count > BITS_PER_WORD)
1712 first_shift_count = GEN_INT (shift_count - BITS_PER_WORD);
1713 second_shift_count = GEN_INT (2 * BITS_PER_WORD - shift_count);
1717 first_shift_count = GEN_INT (BITS_PER_WORD - shift_count);
1718 second_shift_count = GEN_INT (shift_count);
1721 into_temp1 = expand_binop (word_mode, unsigned_shift,
1722 outof_input, first_shift_count,
1723 NULL_RTX, unsignedp, next_methods);
1724 into_temp2 = expand_binop (word_mode, reverse_unsigned_shift,
1725 into_input, second_shift_count,
1726 NULL_RTX, unsignedp, next_methods);
1728 if (into_temp1 != 0 && into_temp2 != 0)
1729 inter = expand_binop (word_mode, ior_optab, into_temp1, into_temp2,
1730 into_target, unsignedp, next_methods);
1734 if (inter != 0 && inter != into_target)
1735 emit_move_insn (into_target, inter);
1737 outof_temp1 = expand_binop (word_mode, unsigned_shift,
1738 into_input, first_shift_count,
1739 NULL_RTX, unsignedp, next_methods);
1740 outof_temp2 = expand_binop (word_mode, reverse_unsigned_shift,
1741 outof_input, second_shift_count,
1742 NULL_RTX, unsignedp, next_methods);
1744 if (inter != 0 && outof_temp1 != 0 && outof_temp2 != 0)
1745 inter = expand_binop (word_mode, ior_optab,
1746 outof_temp1, outof_temp2,
1747 outof_target, unsignedp, next_methods);
1749 if (inter != 0 && inter != outof_target)
1750 emit_move_insn (outof_target, inter);
1753 insns = get_insns ();
1763 /* These can be done a word at a time by propagating carries. */
1764 if ((binoptab == add_optab || binoptab == sub_optab)
1765 && mclass == MODE_INT
1766 && GET_MODE_SIZE (mode) >= 2 * UNITS_PER_WORD
1767 && optab_handler (binoptab, word_mode) != CODE_FOR_nothing)
1770 optab otheroptab = binoptab == add_optab ? sub_optab : add_optab;
1771 const unsigned int nwords = GET_MODE_BITSIZE (mode) / BITS_PER_WORD;
1772 rtx carry_in = NULL_RTX, carry_out = NULL_RTX;
1773 rtx xop0, xop1, xtarget;
1775 /* We can handle either a 1 or -1 value for the carry. If STORE_FLAG
1776 value is one of those, use it. Otherwise, use 1 since it is the
1777 one easiest to get. */
1778 #if STORE_FLAG_VALUE == 1 || STORE_FLAG_VALUE == -1
1779 int normalizep = STORE_FLAG_VALUE;
1784 /* Prepare the operands. */
1785 xop0 = force_reg (mode, op0);
1786 xop1 = force_reg (mode, op1);
1788 xtarget = gen_reg_rtx (mode);
1790 if (target == 0 || !REG_P (target) || !valid_multiword_target_p (target))
1793 /* Indicate for flow that the entire target reg is being set. */
1795 emit_clobber (xtarget);
1797 /* Do the actual arithmetic. */
1798 for (i = 0; i < nwords; i++)
1800 int index = (WORDS_BIG_ENDIAN ? nwords - i - 1 : i);
1801 rtx target_piece = operand_subword (xtarget, index, 1, mode);
1802 rtx op0_piece = operand_subword_force (xop0, index, mode);
1803 rtx op1_piece = operand_subword_force (xop1, index, mode);
1806 /* Main add/subtract of the input operands. */
1807 x = expand_binop (word_mode, binoptab,
1808 op0_piece, op1_piece,
1809 target_piece, unsignedp, next_methods);
1815 /* Store carry from main add/subtract. */
1816 carry_out = gen_reg_rtx (word_mode);
1817 carry_out = emit_store_flag_force (carry_out,
1818 (binoptab == add_optab
1821 word_mode, 1, normalizep);
1828 /* Add/subtract previous carry to main result. */
1829 newx = expand_binop (word_mode,
1830 normalizep == 1 ? binoptab : otheroptab,
1832 NULL_RTX, 1, next_methods);
1836 /* Get out carry from adding/subtracting carry in. */
1837 rtx carry_tmp = gen_reg_rtx (word_mode);
1838 carry_tmp = emit_store_flag_force (carry_tmp,
1839 (binoptab == add_optab
1842 word_mode, 1, normalizep);
1844 /* Logical-ior the two poss. carry together. */
1845 carry_out = expand_binop (word_mode, ior_optab,
1846 carry_out, carry_tmp,
1847 carry_out, 0, next_methods);
1851 emit_move_insn (target_piece, newx);
1855 if (x != target_piece)
1856 emit_move_insn (target_piece, x);
1859 carry_in = carry_out;
1862 if (i == GET_MODE_BITSIZE (mode) / (unsigned) BITS_PER_WORD)
1864 if (optab_handler (mov_optab, mode) != CODE_FOR_nothing
1865 || ! rtx_equal_p (target, xtarget))
1867 rtx temp = emit_move_insn (target, xtarget);
1869 set_unique_reg_note (temp,
1871 gen_rtx_fmt_ee (binoptab->code, mode,
1882 delete_insns_since (last);
1885 /* Attempt to synthesize double word multiplies using a sequence of word
1886 mode multiplications. We first attempt to generate a sequence using a
1887 more efficient unsigned widening multiply, and if that fails we then
1888 try using a signed widening multiply. */
1890 if (binoptab == smul_optab
1891 && mclass == MODE_INT
1892 && GET_MODE_SIZE (mode) == 2 * UNITS_PER_WORD
1893 && optab_handler (smul_optab, word_mode) != CODE_FOR_nothing
1894 && optab_handler (add_optab, word_mode) != CODE_FOR_nothing)
1896 rtx product = NULL_RTX;
1898 if (optab_handler (umul_widen_optab, mode) != CODE_FOR_nothing)
1900 product = expand_doubleword_mult (mode, op0, op1, target,
1903 delete_insns_since (last);
1906 if (product == NULL_RTX
1907 && optab_handler (smul_widen_optab, mode) != CODE_FOR_nothing)
1909 product = expand_doubleword_mult (mode, op0, op1, target,
1912 delete_insns_since (last);
1915 if (product != NULL_RTX)
1917 if (optab_handler (mov_optab, mode) != CODE_FOR_nothing)
1919 temp = emit_move_insn (target ? target : product, product);
1920 set_unique_reg_note (temp,
1922 gen_rtx_fmt_ee (MULT, mode,
1930 /* It can't be open-coded in this mode.
1931 Use a library call if one is available and caller says that's ok. */
1933 libfunc = optab_libfunc (binoptab, mode);
1935 && (methods == OPTAB_LIB || methods == OPTAB_LIB_WIDEN))
1939 enum machine_mode op1_mode = mode;
1944 if (shift_optab_p (binoptab))
1946 op1_mode = targetm.libgcc_shift_count_mode ();
1947 /* Specify unsigned here,
1948 since negative shift counts are meaningless. */
1949 op1x = convert_to_mode (op1_mode, op1, 1);
1952 if (GET_MODE (op0) != VOIDmode
1953 && GET_MODE (op0) != mode)
1954 op0 = convert_to_mode (mode, op0, unsignedp);
1956 /* Pass 1 for NO_QUEUE so we don't lose any increments
1957 if the libcall is cse'd or moved. */
1958 value = emit_library_call_value (libfunc,
1959 NULL_RTX, LCT_CONST, mode, 2,
1960 op0, mode, op1x, op1_mode);
1962 insns = get_insns ();
1965 target = gen_reg_rtx (mode);
1966 emit_libcall_block (insns, target, value,
1967 gen_rtx_fmt_ee (binoptab->code, mode, op0, op1));
1972 delete_insns_since (last);
1974 /* It can't be done in this mode. Can we do it in a wider mode? */
1976 if (! (methods == OPTAB_WIDEN || methods == OPTAB_LIB_WIDEN
1977 || methods == OPTAB_MUST_WIDEN))
1979 /* Caller says, don't even try. */
1980 delete_insns_since (entry_last);
1984 /* Compute the value of METHODS to pass to recursive calls.
1985 Don't allow widening to be tried recursively. */
1987 methods = (methods == OPTAB_LIB_WIDEN ? OPTAB_LIB : OPTAB_DIRECT);
1989 /* Look for a wider mode of the same class for which it appears we can do
1992 if (CLASS_HAS_WIDER_MODES_P (mclass))
1994 for (wider_mode = GET_MODE_WIDER_MODE (mode);
1995 wider_mode != VOIDmode;
1996 wider_mode = GET_MODE_WIDER_MODE (wider_mode))
1998 if (optab_handler (binoptab, wider_mode) != CODE_FOR_nothing
1999 || (methods == OPTAB_LIB
2000 && optab_libfunc (binoptab, wider_mode)))
2002 rtx xop0 = op0, xop1 = op1;
2005 /* For certain integer operations, we need not actually extend
2006 the narrow operands, as long as we will truncate
2007 the results to the same narrowness. */
2009 if ((binoptab == ior_optab || binoptab == and_optab
2010 || binoptab == xor_optab
2011 || binoptab == add_optab || binoptab == sub_optab
2012 || binoptab == smul_optab || binoptab == ashl_optab)
2013 && mclass == MODE_INT)
2016 xop0 = widen_operand (xop0, wider_mode, mode,
2017 unsignedp, no_extend);
2019 /* The second operand of a shift must always be extended. */
2020 xop1 = widen_operand (xop1, wider_mode, mode, unsignedp,
2021 no_extend && binoptab != ashl_optab);
2023 temp = expand_binop (wider_mode, binoptab, xop0, xop1, NULL_RTX,
2024 unsignedp, methods);
2027 if (mclass != MODE_INT
2028 || !TRULY_NOOP_TRUNCATION_MODES_P (mode, wider_mode))
2031 target = gen_reg_rtx (mode);
2032 convert_move (target, temp, 0);
2036 return gen_lowpart (mode, temp);
2039 delete_insns_since (last);
2044 delete_insns_since (entry_last);
2048 /* Expand a binary operator which has both signed and unsigned forms.
2049 UOPTAB is the optab for unsigned operations, and SOPTAB is for
2052 If we widen unsigned operands, we may use a signed wider operation instead
2053 of an unsigned wider operation, since the result would be the same. */
2056 sign_expand_binop (enum machine_mode mode, optab uoptab, optab soptab,
2057 rtx op0, rtx op1, rtx target, int unsignedp,
2058 enum optab_methods methods)
2061 optab direct_optab = unsignedp ? uoptab : soptab;
2062 struct optab_d wide_soptab;
2064 /* Do it without widening, if possible. */
2065 temp = expand_binop (mode, direct_optab, op0, op1, target,
2066 unsignedp, OPTAB_DIRECT);
2067 if (temp || methods == OPTAB_DIRECT)
2070 /* Try widening to a signed int. Make a fake signed optab that
2071 hides any signed insn for direct use. */
2072 wide_soptab = *soptab;
2073 set_optab_handler (&wide_soptab, mode, CODE_FOR_nothing);
2074 /* We don't want to generate new hash table entries from this fake
2076 wide_soptab.libcall_gen = NULL;
2078 temp = expand_binop (mode, &wide_soptab, op0, op1, target,
2079 unsignedp, OPTAB_WIDEN);
2081 /* For unsigned operands, try widening to an unsigned int. */
2082 if (temp == 0 && unsignedp)
2083 temp = expand_binop (mode, uoptab, op0, op1, target,
2084 unsignedp, OPTAB_WIDEN);
2085 if (temp || methods == OPTAB_WIDEN)
2088 /* Use the right width libcall if that exists. */
2089 temp = expand_binop (mode, direct_optab, op0, op1, target, unsignedp, OPTAB_LIB);
2090 if (temp || methods == OPTAB_LIB)
2093 /* Must widen and use a libcall, use either signed or unsigned. */
2094 temp = expand_binop (mode, &wide_soptab, op0, op1, target,
2095 unsignedp, methods);
2099 return expand_binop (mode, uoptab, op0, op1, target,
2100 unsignedp, methods);
2104 /* Generate code to perform an operation specified by UNOPPTAB
2105 on operand OP0, with two results to TARG0 and TARG1.
2106 We assume that the order of the operands for the instruction
2107 is TARG0, TARG1, OP0.
2109 Either TARG0 or TARG1 may be zero, but what that means is that
2110 the result is not actually wanted. We will generate it into
2111 a dummy pseudo-reg and discard it. They may not both be zero.
2113 Returns 1 if this operation can be performed; 0 if not. */
2116 expand_twoval_unop (optab unoptab, rtx op0, rtx targ0, rtx targ1,
2119 enum machine_mode mode = GET_MODE (targ0 ? targ0 : targ1);
2120 enum mode_class mclass;
2121 enum machine_mode wider_mode;
2122 rtx entry_last = get_last_insn ();
2125 mclass = GET_MODE_CLASS (mode);
2128 targ0 = gen_reg_rtx (mode);
2130 targ1 = gen_reg_rtx (mode);
2132 /* Record where to go back to if we fail. */
2133 last = get_last_insn ();
2135 if (optab_handler (unoptab, mode) != CODE_FOR_nothing)
2137 struct expand_operand ops[3];
2138 enum insn_code icode = optab_handler (unoptab, mode);
2140 create_fixed_operand (&ops[0], targ0);
2141 create_fixed_operand (&ops[1], targ1);
2142 create_convert_operand_from (&ops[2], op0, mode, unsignedp);
2143 if (maybe_expand_insn (icode, 3, ops))
2147 /* It can't be done in this mode. Can we do it in a wider mode? */
2149 if (CLASS_HAS_WIDER_MODES_P (mclass))
2151 for (wider_mode = GET_MODE_WIDER_MODE (mode);
2152 wider_mode != VOIDmode;
2153 wider_mode = GET_MODE_WIDER_MODE (wider_mode))
2155 if (optab_handler (unoptab, wider_mode) != CODE_FOR_nothing)
2157 rtx t0 = gen_reg_rtx (wider_mode);
2158 rtx t1 = gen_reg_rtx (wider_mode);
2159 rtx cop0 = convert_modes (wider_mode, mode, op0, unsignedp);
2161 if (expand_twoval_unop (unoptab, cop0, t0, t1, unsignedp))
2163 convert_move (targ0, t0, unsignedp);
2164 convert_move (targ1, t1, unsignedp);
2168 delete_insns_since (last);
2173 delete_insns_since (entry_last);
2177 /* Generate code to perform an operation specified by BINOPTAB
2178 on operands OP0 and OP1, with two results to TARG1 and TARG2.
2179 We assume that the order of the operands for the instruction
2180 is TARG0, OP0, OP1, TARG1, which would fit a pattern like
2181 [(set TARG0 (operate OP0 OP1)) (set TARG1 (operate ...))].
2183 Either TARG0 or TARG1 may be zero, but what that means is that
2184 the result is not actually wanted. We will generate it into
2185 a dummy pseudo-reg and discard it. They may not both be zero.
2187 Returns 1 if this operation can be performed; 0 if not. */
2190 expand_twoval_binop (optab binoptab, rtx op0, rtx op1, rtx targ0, rtx targ1,
2193 enum machine_mode mode = GET_MODE (targ0 ? targ0 : targ1);
2194 enum mode_class mclass;
2195 enum machine_mode wider_mode;
2196 rtx entry_last = get_last_insn ();
2199 mclass = GET_MODE_CLASS (mode);
2202 targ0 = gen_reg_rtx (mode);
2204 targ1 = gen_reg_rtx (mode);
2206 /* Record where to go back to if we fail. */
2207 last = get_last_insn ();
2209 if (optab_handler (binoptab, mode) != CODE_FOR_nothing)
2211 struct expand_operand ops[4];
2212 enum insn_code icode = optab_handler (binoptab, mode);
2213 enum machine_mode mode0 = insn_data[icode].operand[1].mode;
2214 enum machine_mode mode1 = insn_data[icode].operand[2].mode;
2215 rtx xop0 = op0, xop1 = op1;
2217 /* If we are optimizing, force expensive constants into a register. */
2218 xop0 = avoid_expensive_constant (mode0, binoptab, xop0, unsignedp);
2219 xop1 = avoid_expensive_constant (mode1, binoptab, xop1, unsignedp);
2221 create_fixed_operand (&ops[0], targ0);
2222 create_convert_operand_from (&ops[1], op0, mode, unsignedp);
2223 create_convert_operand_from (&ops[2], op1, mode, unsignedp);
2224 create_fixed_operand (&ops[3], targ1);
2225 if (maybe_expand_insn (icode, 4, ops))
2227 delete_insns_since (last);
2230 /* It can't be done in this mode. Can we do it in a wider mode? */
2232 if (CLASS_HAS_WIDER_MODES_P (mclass))
2234 for (wider_mode = GET_MODE_WIDER_MODE (mode);
2235 wider_mode != VOIDmode;
2236 wider_mode = GET_MODE_WIDER_MODE (wider_mode))
2238 if (optab_handler (binoptab, wider_mode) != CODE_FOR_nothing)
2240 rtx t0 = gen_reg_rtx (wider_mode);
2241 rtx t1 = gen_reg_rtx (wider_mode);
2242 rtx cop0 = convert_modes (wider_mode, mode, op0, unsignedp);
2243 rtx cop1 = convert_modes (wider_mode, mode, op1, unsignedp);
2245 if (expand_twoval_binop (binoptab, cop0, cop1,
2248 convert_move (targ0, t0, unsignedp);
2249 convert_move (targ1, t1, unsignedp);
2253 delete_insns_since (last);
2258 delete_insns_since (entry_last);
2262 /* Expand the two-valued library call indicated by BINOPTAB, but
2263 preserve only one of the values. If TARG0 is non-NULL, the first
2264 value is placed into TARG0; otherwise the second value is placed
2265 into TARG1. Exactly one of TARG0 and TARG1 must be non-NULL. The
2266 value stored into TARG0 or TARG1 is equivalent to (CODE OP0 OP1).
2267 This routine assumes that the value returned by the library call is
2268 as if the return value was of an integral mode twice as wide as the
2269 mode of OP0. Returns 1 if the call was successful. */
2272 expand_twoval_binop_libfunc (optab binoptab, rtx op0, rtx op1,
2273 rtx targ0, rtx targ1, enum rtx_code code)
2275 enum machine_mode mode;
2276 enum machine_mode libval_mode;
2281 /* Exactly one of TARG0 or TARG1 should be non-NULL. */
2282 gcc_assert (!targ0 != !targ1);
2284 mode = GET_MODE (op0);
2285 libfunc = optab_libfunc (binoptab, mode);
2289 /* The value returned by the library function will have twice as
2290 many bits as the nominal MODE. */
2291 libval_mode = smallest_mode_for_size (2 * GET_MODE_BITSIZE (mode),
2294 libval = emit_library_call_value (libfunc, NULL_RTX, LCT_CONST,
2298 /* Get the part of VAL containing the value that we want. */
2299 libval = simplify_gen_subreg (mode, libval, libval_mode,
2300 targ0 ? 0 : GET_MODE_SIZE (mode));
2301 insns = get_insns ();
2303 /* Move the into the desired location. */
2304 emit_libcall_block (insns, targ0 ? targ0 : targ1, libval,
2305 gen_rtx_fmt_ee (code, mode, op0, op1));
2311 /* Wrapper around expand_unop which takes an rtx code to specify
2312 the operation to perform, not an optab pointer. All other
2313 arguments are the same. */
2315 expand_simple_unop (enum machine_mode mode, enum rtx_code code, rtx op0,
2316 rtx target, int unsignedp)
2318 optab unop = code_to_optab[(int) code];
2321 return expand_unop (mode, unop, op0, target, unsignedp);
2327 (clz:wide (zero_extend:wide x)) - ((width wide) - (width narrow)).
2329 A similar operation can be used for clrsb. UNOPTAB says which operation
2330 we are trying to expand. */
2332 widen_leading (enum machine_mode mode, rtx op0, rtx target, optab unoptab)
2334 enum mode_class mclass = GET_MODE_CLASS (mode);
2335 if (CLASS_HAS_WIDER_MODES_P (mclass))
2337 enum machine_mode wider_mode;
2338 for (wider_mode = GET_MODE_WIDER_MODE (mode);
2339 wider_mode != VOIDmode;
2340 wider_mode = GET_MODE_WIDER_MODE (wider_mode))
2342 if (optab_handler (unoptab, wider_mode) != CODE_FOR_nothing)
2344 rtx xop0, temp, last;
2346 last = get_last_insn ();
2349 target = gen_reg_rtx (mode);
2350 xop0 = widen_operand (op0, wider_mode, mode,
2351 unoptab != clrsb_optab, false);
2352 temp = expand_unop (wider_mode, unoptab, xop0, NULL_RTX,
2353 unoptab != clrsb_optab);
2355 temp = expand_binop (wider_mode, sub_optab, temp,
2356 GEN_INT (GET_MODE_PRECISION (wider_mode)
2357 - GET_MODE_PRECISION (mode)),
2358 target, true, OPTAB_DIRECT);
2360 delete_insns_since (last);
2369 /* Try calculating clz of a double-word quantity as two clz's of word-sized
2370 quantities, choosing which based on whether the high word is nonzero. */
2372 expand_doubleword_clz (enum machine_mode mode, rtx op0, rtx target)
2374 rtx xop0 = force_reg (mode, op0);
2375 rtx subhi = gen_highpart (word_mode, xop0);
2376 rtx sublo = gen_lowpart (word_mode, xop0);
2377 rtx hi0_label = gen_label_rtx ();
2378 rtx after_label = gen_label_rtx ();
2379 rtx seq, temp, result;
2381 /* If we were not given a target, use a word_mode register, not a
2382 'mode' register. The result will fit, and nobody is expecting
2383 anything bigger (the return type of __builtin_clz* is int). */
2385 target = gen_reg_rtx (word_mode);
2387 /* In any case, write to a word_mode scratch in both branches of the
2388 conditional, so we can ensure there is a single move insn setting
2389 'target' to tag a REG_EQUAL note on. */
2390 result = gen_reg_rtx (word_mode);
2394 /* If the high word is not equal to zero,
2395 then clz of the full value is clz of the high word. */
2396 emit_cmp_and_jump_insns (subhi, CONST0_RTX (word_mode), EQ, 0,
2397 word_mode, true, hi0_label);
2399 temp = expand_unop_direct (word_mode, clz_optab, subhi, result, true);
2404 convert_move (result, temp, true);
2406 emit_jump_insn (gen_jump (after_label));
2409 /* Else clz of the full value is clz of the low word plus the number
2410 of bits in the high word. */
2411 emit_label (hi0_label);
2413 temp = expand_unop_direct (word_mode, clz_optab, sublo, 0, true);
2416 temp = expand_binop (word_mode, add_optab, temp,
2417 GEN_INT (GET_MODE_BITSIZE (word_mode)),
2418 result, true, OPTAB_DIRECT);
2422 convert_move (result, temp, true);
2424 emit_label (after_label);
2425 convert_move (target, result, true);
2430 add_equal_note (seq, target, CLZ, xop0, 0);
2442 (lshiftrt:wide (bswap:wide x) ((width wide) - (width narrow))). */
2444 widen_bswap (enum machine_mode mode, rtx op0, rtx target)
2446 enum mode_class mclass = GET_MODE_CLASS (mode);
2447 enum machine_mode wider_mode;
2450 if (!CLASS_HAS_WIDER_MODES_P (mclass))
2453 for (wider_mode = GET_MODE_WIDER_MODE (mode);
2454 wider_mode != VOIDmode;
2455 wider_mode = GET_MODE_WIDER_MODE (wider_mode))
2456 if (optab_handler (bswap_optab, wider_mode) != CODE_FOR_nothing)
2461 last = get_last_insn ();
2463 x = widen_operand (op0, wider_mode, mode, true, true);
2464 x = expand_unop (wider_mode, bswap_optab, x, NULL_RTX, true);
2467 x = expand_shift (RSHIFT_EXPR, wider_mode, x,
2468 GET_MODE_BITSIZE (wider_mode)
2469 - GET_MODE_BITSIZE (mode),
2475 target = gen_reg_rtx (mode);
2476 emit_move_insn (target, gen_lowpart (mode, x));
2479 delete_insns_since (last);
2484 /* Try calculating bswap as two bswaps of two word-sized operands. */
2487 expand_doubleword_bswap (enum machine_mode mode, rtx op, rtx target)
2491 t1 = expand_unop (word_mode, bswap_optab,
2492 operand_subword_force (op, 0, mode), NULL_RTX, true);
2493 t0 = expand_unop (word_mode, bswap_optab,
2494 operand_subword_force (op, 1, mode), NULL_RTX, true);
2496 if (target == 0 || !valid_multiword_target_p (target))
2497 target = gen_reg_rtx (mode);
2499 emit_clobber (target);
2500 emit_move_insn (operand_subword (target, 0, 1, mode), t0);
2501 emit_move_insn (operand_subword (target, 1, 1, mode), t1);
2506 /* Try calculating (parity x) as (and (popcount x) 1), where
2507 popcount can also be done in a wider mode. */
2509 expand_parity (enum machine_mode mode, rtx op0, rtx target)
2511 enum mode_class mclass = GET_MODE_CLASS (mode);
2512 if (CLASS_HAS_WIDER_MODES_P (mclass))
2514 enum machine_mode wider_mode;
2515 for (wider_mode = mode; wider_mode != VOIDmode;
2516 wider_mode = GET_MODE_WIDER_MODE (wider_mode))
2518 if (optab_handler (popcount_optab, wider_mode) != CODE_FOR_nothing)
2520 rtx xop0, temp, last;
2522 last = get_last_insn ();
2525 target = gen_reg_rtx (mode);
2526 xop0 = widen_operand (op0, wider_mode, mode, true, false);
2527 temp = expand_unop (wider_mode, popcount_optab, xop0, NULL_RTX,
2530 temp = expand_binop (wider_mode, and_optab, temp, const1_rtx,
2531 target, true, OPTAB_DIRECT);
2533 delete_insns_since (last);
2542 /* Try calculating ctz(x) as K - clz(x & -x) ,
2543 where K is GET_MODE_PRECISION(mode) - 1.
2545 Both __builtin_ctz and __builtin_clz are undefined at zero, so we
2546 don't have to worry about what the hardware does in that case. (If
2547 the clz instruction produces the usual value at 0, which is K, the
2548 result of this code sequence will be -1; expand_ffs, below, relies
2549 on this. It might be nice to have it be K instead, for consistency
2550 with the (very few) processors that provide a ctz with a defined
2551 value, but that would take one more instruction, and it would be
2552 less convenient for expand_ffs anyway. */
2555 expand_ctz (enum machine_mode mode, rtx op0, rtx target)
2559 if (optab_handler (clz_optab, mode) == CODE_FOR_nothing)
2564 temp = expand_unop_direct (mode, neg_optab, op0, NULL_RTX, true);
2566 temp = expand_binop (mode, and_optab, op0, temp, NULL_RTX,
2567 true, OPTAB_DIRECT);
2569 temp = expand_unop_direct (mode, clz_optab, temp, NULL_RTX, true);
2571 temp = expand_binop (mode, sub_optab, GEN_INT (GET_MODE_PRECISION (mode) - 1),
2573 true, OPTAB_DIRECT);
2583 add_equal_note (seq, temp, CTZ, op0, 0);
2589 /* Try calculating ffs(x) using ctz(x) if we have that instruction, or
2590 else with the sequence used by expand_clz.
2592 The ffs builtin promises to return zero for a zero value and ctz/clz
2593 may have an undefined value in that case. If they do not give us a
2594 convenient value, we have to generate a test and branch. */
2596 expand_ffs (enum machine_mode mode, rtx op0, rtx target)
2598 HOST_WIDE_INT val = 0;
2599 bool defined_at_zero = false;
2602 if (optab_handler (ctz_optab, mode) != CODE_FOR_nothing)
2606 temp = expand_unop_direct (mode, ctz_optab, op0, 0, true);
2610 defined_at_zero = (CTZ_DEFINED_VALUE_AT_ZERO (mode, val) == 2);
2612 else if (optab_handler (clz_optab, mode) != CODE_FOR_nothing)
2615 temp = expand_ctz (mode, op0, 0);
2619 if (CLZ_DEFINED_VALUE_AT_ZERO (mode, val) == 2)
2621 defined_at_zero = true;
2622 val = (GET_MODE_PRECISION (mode) - 1) - val;
2628 if (defined_at_zero && val == -1)
2629 /* No correction needed at zero. */;
2632 /* We don't try to do anything clever with the situation found
2633 on some processors (eg Alpha) where ctz(0:mode) ==
2634 bitsize(mode). If someone can think of a way to send N to -1
2635 and leave alone all values in the range 0..N-1 (where N is a
2636 power of two), cheaper than this test-and-branch, please add it.
2638 The test-and-branch is done after the operation itself, in case
2639 the operation sets condition codes that can be recycled for this.
2640 (This is true on i386, for instance.) */
2642 rtx nonzero_label = gen_label_rtx ();
2643 emit_cmp_and_jump_insns (op0, CONST0_RTX (mode), NE, 0,
2644 mode, true, nonzero_label);
2646 convert_move (temp, GEN_INT (-1), false);
2647 emit_label (nonzero_label);
2650 /* temp now has a value in the range -1..bitsize-1. ffs is supposed
2651 to produce a value in the range 0..bitsize. */
2652 temp = expand_binop (mode, add_optab, temp, GEN_INT (1),
2653 target, false, OPTAB_DIRECT);
2660 add_equal_note (seq, temp, FFS, op0, 0);
2669 /* Extract the OMODE lowpart from VAL, which has IMODE. Under certain
2670 conditions, VAL may already be a SUBREG against which we cannot generate
2671 a further SUBREG. In this case, we expect forcing the value into a
2672 register will work around the situation. */
2675 lowpart_subreg_maybe_copy (enum machine_mode omode, rtx val,
2676 enum machine_mode imode)
2679 ret = lowpart_subreg (omode, val, imode);
2682 val = force_reg (imode, val);
2683 ret = lowpart_subreg (omode, val, imode);
2684 gcc_assert (ret != NULL);
2689 /* Expand a floating point absolute value or negation operation via a
2690 logical operation on the sign bit. */
2693 expand_absneg_bit (enum rtx_code code, enum machine_mode mode,
2694 rtx op0, rtx target)
2696 const struct real_format *fmt;
2697 int bitpos, word, nwords, i;
2698 enum machine_mode imode;
2702 /* The format has to have a simple sign bit. */
2703 fmt = REAL_MODE_FORMAT (mode);
2707 bitpos = fmt->signbit_rw;
2711 /* Don't create negative zeros if the format doesn't support them. */
2712 if (code == NEG && !fmt->has_signed_zero)
2715 if (GET_MODE_SIZE (mode) <= UNITS_PER_WORD)
2717 imode = int_mode_for_mode (mode);
2718 if (imode == BLKmode)
2727 if (FLOAT_WORDS_BIG_ENDIAN)
2728 word = (GET_MODE_BITSIZE (mode) - bitpos) / BITS_PER_WORD;
2730 word = bitpos / BITS_PER_WORD;
2731 bitpos = bitpos % BITS_PER_WORD;
2732 nwords = (GET_MODE_BITSIZE (mode) + BITS_PER_WORD - 1) / BITS_PER_WORD;
2735 mask = double_int_setbit (double_int_zero, bitpos);
2737 mask = double_int_not (mask);
2741 || (nwords > 1 && !valid_multiword_target_p (target)))
2742 target = gen_reg_rtx (mode);
2748 for (i = 0; i < nwords; ++i)
2750 rtx targ_piece = operand_subword (target, i, 1, mode);
2751 rtx op0_piece = operand_subword_force (op0, i, mode);
2755 temp = expand_binop (imode, code == ABS ? and_optab : xor_optab,
2757 immed_double_int_const (mask, imode),
2758 targ_piece, 1, OPTAB_LIB_WIDEN);
2759 if (temp != targ_piece)
2760 emit_move_insn (targ_piece, temp);
2763 emit_move_insn (targ_piece, op0_piece);
2766 insns = get_insns ();
2773 temp = expand_binop (imode, code == ABS ? and_optab : xor_optab,
2774 gen_lowpart (imode, op0),
2775 immed_double_int_const (mask, imode),
2776 gen_lowpart (imode, target), 1, OPTAB_LIB_WIDEN);
2777 target = lowpart_subreg_maybe_copy (mode, temp, imode);
2779 set_unique_reg_note (get_last_insn (), REG_EQUAL,
2780 gen_rtx_fmt_e (code, mode, copy_rtx (op0)));
2786 /* As expand_unop, but will fail rather than attempt the operation in a
2787 different mode or with a libcall. */
2789 expand_unop_direct (enum machine_mode mode, optab unoptab, rtx op0, rtx target,
2792 if (optab_handler (unoptab, mode) != CODE_FOR_nothing)
2794 struct expand_operand ops[2];
2795 enum insn_code icode = optab_handler (unoptab, mode);
2796 rtx last = get_last_insn ();
2799 create_output_operand (&ops[0], target, mode);
2800 create_convert_operand_from (&ops[1], op0, mode, unsignedp);
2801 pat = maybe_gen_insn (icode, 2, ops);
2804 if (INSN_P (pat) && NEXT_INSN (pat) != NULL_RTX
2805 && ! add_equal_note (pat, ops[0].value, unoptab->code,
2806 ops[1].value, NULL_RTX))
2808 delete_insns_since (last);
2809 return expand_unop (mode, unoptab, op0, NULL_RTX, unsignedp);
2814 return ops[0].value;
2820 /* Generate code to perform an operation specified by UNOPTAB
2821 on operand OP0, with result having machine-mode MODE.
2823 UNSIGNEDP is for the case where we have to widen the operands
2824 to perform the operation. It says to use zero-extension.
2826 If TARGET is nonzero, the value
2827 is generated there, if it is convenient to do so.
2828 In all cases an rtx is returned for the locus of the value;
2829 this may or may not be TARGET. */
2832 expand_unop (enum machine_mode mode, optab unoptab, rtx op0, rtx target,
2835 enum mode_class mclass = GET_MODE_CLASS (mode);
2836 enum machine_mode wider_mode;
2840 temp = expand_unop_direct (mode, unoptab, op0, target, unsignedp);
2844 /* It can't be done in this mode. Can we open-code it in a wider mode? */
2846 /* Widening (or narrowing) clz needs special treatment. */
2847 if (unoptab == clz_optab)
2849 temp = widen_leading (mode, op0, target, unoptab);
2853 if (GET_MODE_SIZE (mode) == 2 * UNITS_PER_WORD
2854 && optab_handler (unoptab, word_mode) != CODE_FOR_nothing)
2856 temp = expand_doubleword_clz (mode, op0, target);
2864 if (unoptab == clrsb_optab)
2866 temp = widen_leading (mode, op0, target, unoptab);
2872 /* Widening (or narrowing) bswap needs special treatment. */
2873 if (unoptab == bswap_optab)
2875 temp = widen_bswap (mode, op0, target);
2879 if (GET_MODE_SIZE (mode) == 2 * UNITS_PER_WORD
2880 && optab_handler (unoptab, word_mode) != CODE_FOR_nothing)
2882 temp = expand_doubleword_bswap (mode, op0, target);
2890 if (CLASS_HAS_WIDER_MODES_P (mclass))
2891 for (wider_mode = GET_MODE_WIDER_MODE (mode);
2892 wider_mode != VOIDmode;
2893 wider_mode = GET_MODE_WIDER_MODE (wider_mode))
2895 if (optab_handler (unoptab, wider_mode) != CODE_FOR_nothing)
2898 rtx last = get_last_insn ();
2900 /* For certain operations, we need not actually extend
2901 the narrow operand, as long as we will truncate the
2902 results to the same narrowness. */
2904 xop0 = widen_operand (xop0, wider_mode, mode, unsignedp,
2905 (unoptab == neg_optab
2906 || unoptab == one_cmpl_optab)
2907 && mclass == MODE_INT);
2909 temp = expand_unop (wider_mode, unoptab, xop0, NULL_RTX,
2914 if (mclass != MODE_INT
2915 || !TRULY_NOOP_TRUNCATION_MODES_P (mode, wider_mode))
2918 target = gen_reg_rtx (mode);
2919 convert_move (target, temp, 0);
2923 return gen_lowpart (mode, temp);
2926 delete_insns_since (last);
2930 /* These can be done a word at a time. */
2931 if (unoptab == one_cmpl_optab
2932 && mclass == MODE_INT
2933 && GET_MODE_SIZE (mode) > UNITS_PER_WORD
2934 && optab_handler (unoptab, word_mode) != CODE_FOR_nothing)
2939 if (target == 0 || target == op0 || !valid_multiword_target_p (target))
2940 target = gen_reg_rtx (mode);
2944 /* Do the actual arithmetic. */
2945 for (i = 0; i < GET_MODE_BITSIZE (mode) / BITS_PER_WORD; i++)
2947 rtx target_piece = operand_subword (target, i, 1, mode);
2948 rtx x = expand_unop (word_mode, unoptab,
2949 operand_subword_force (op0, i, mode),
2950 target_piece, unsignedp);
2952 if (target_piece != x)
2953 emit_move_insn (target_piece, x);
2956 insns = get_insns ();
2963 if (unoptab->code == NEG)
2965 /* Try negating floating point values by flipping the sign bit. */
2966 if (SCALAR_FLOAT_MODE_P (mode))
2968 temp = expand_absneg_bit (NEG, mode, op0, target);
2973 /* If there is no negation pattern, and we have no negative zero,
2974 try subtracting from zero. */
2975 if (!HONOR_SIGNED_ZEROS (mode))
2977 temp = expand_binop (mode, (unoptab == negv_optab
2978 ? subv_optab : sub_optab),
2979 CONST0_RTX (mode), op0, target,
2980 unsignedp, OPTAB_DIRECT);
2986 /* Try calculating parity (x) as popcount (x) % 2. */
2987 if (unoptab == parity_optab)
2989 temp = expand_parity (mode, op0, target);
2994 /* Try implementing ffs (x) in terms of clz (x). */
2995 if (unoptab == ffs_optab)
2997 temp = expand_ffs (mode, op0, target);
3002 /* Try implementing ctz (x) in terms of clz (x). */
3003 if (unoptab == ctz_optab)
3005 temp = expand_ctz (mode, op0, target);
3011 /* Now try a library call in this mode. */
3012 libfunc = optab_libfunc (unoptab, mode);
3018 enum machine_mode outmode = mode;
3020 /* All of these functions return small values. Thus we choose to
3021 have them return something that isn't a double-word. */
3022 if (unoptab == ffs_optab || unoptab == clz_optab || unoptab == ctz_optab
3023 || unoptab == clrsb_optab || unoptab == popcount_optab
3024 || unoptab == parity_optab)
3026 = GET_MODE (hard_libcall_value (TYPE_MODE (integer_type_node),
3027 optab_libfunc (unoptab, mode)));
3031 /* Pass 1 for NO_QUEUE so we don't lose any increments
3032 if the libcall is cse'd or moved. */
3033 value = emit_library_call_value (libfunc, NULL_RTX, LCT_CONST, outmode,
3035 insns = get_insns ();
3038 target = gen_reg_rtx (outmode);
3039 eq_value = gen_rtx_fmt_e (unoptab->code, mode, op0);
3040 if (GET_MODE_SIZE (outmode) < GET_MODE_SIZE (mode))
3041 eq_value = simplify_gen_unary (TRUNCATE, outmode, eq_value, mode);
3042 else if (GET_MODE_SIZE (outmode) > GET_MODE_SIZE (mode))
3043 eq_value = simplify_gen_unary (ZERO_EXTEND, outmode, eq_value, mode);
3044 emit_libcall_block (insns, target, value, eq_value);
3049 /* It can't be done in this mode. Can we do it in a wider mode? */
3051 if (CLASS_HAS_WIDER_MODES_P (mclass))
3053 for (wider_mode = GET_MODE_WIDER_MODE (mode);
3054 wider_mode != VOIDmode;
3055 wider_mode = GET_MODE_WIDER_MODE (wider_mode))
3057 if (optab_handler (unoptab, wider_mode) != CODE_FOR_nothing
3058 || optab_libfunc (unoptab, wider_mode))
3061 rtx last = get_last_insn ();
3063 /* For certain operations, we need not actually extend
3064 the narrow operand, as long as we will truncate the
3065 results to the same narrowness. */
3067 xop0 = widen_operand (xop0, wider_mode, mode, unsignedp,
3068 (unoptab == neg_optab
3069 || unoptab == one_cmpl_optab)
3070 && mclass == MODE_INT);
3072 temp = expand_unop (wider_mode, unoptab, xop0, NULL_RTX,
3075 /* If we are generating clz using wider mode, adjust the
3076 result. Similarly for clrsb. */
3077 if ((unoptab == clz_optab || unoptab == clrsb_optab)
3079 temp = expand_binop (wider_mode, sub_optab, temp,
3080 GEN_INT (GET_MODE_PRECISION (wider_mode)
3081 - GET_MODE_PRECISION (mode)),
3082 target, true, OPTAB_DIRECT);
3086 if (mclass != MODE_INT)
3089 target = gen_reg_rtx (mode);
3090 convert_move (target, temp, 0);
3094 return gen_lowpart (mode, temp);
3097 delete_insns_since (last);
3102 /* One final attempt at implementing negation via subtraction,
3103 this time allowing widening of the operand. */
3104 if (unoptab->code == NEG && !HONOR_SIGNED_ZEROS (mode))
3107 temp = expand_binop (mode,
3108 unoptab == negv_optab ? subv_optab : sub_optab,
3109 CONST0_RTX (mode), op0,
3110 target, unsignedp, OPTAB_LIB_WIDEN);
3118 /* Emit code to compute the absolute value of OP0, with result to
3119 TARGET if convenient. (TARGET may be 0.) The return value says
3120 where the result actually is to be found.
3122 MODE is the mode of the operand; the mode of the result is
3123 different but can be deduced from MODE.
3128 expand_abs_nojump (enum machine_mode mode, rtx op0, rtx target,
3129 int result_unsignedp)
3134 result_unsignedp = 1;
3136 /* First try to do it with a special abs instruction. */
3137 temp = expand_unop (mode, result_unsignedp ? abs_optab : absv_optab,
3142 /* For floating point modes, try clearing the sign bit. */
3143 if (SCALAR_FLOAT_MODE_P (mode))
3145 temp = expand_absneg_bit (ABS, mode, op0, target);
3150 /* If we have a MAX insn, we can do this as MAX (x, -x). */
3151 if (optab_handler (smax_optab, mode) != CODE_FOR_nothing
3152 && !HONOR_SIGNED_ZEROS (mode))
3154 rtx last = get_last_insn ();
3156 temp = expand_unop (mode, neg_optab, op0, NULL_RTX, 0);
3158 temp = expand_binop (mode, smax_optab, op0, temp, target, 0,
3164 delete_insns_since (last);
3167 /* If this machine has expensive jumps, we can do integer absolute
3168 value of X as (((signed) x >> (W-1)) ^ x) - ((signed) x >> (W-1)),
3169 where W is the width of MODE. */
3171 if (GET_MODE_CLASS (mode) == MODE_INT
3172 && BRANCH_COST (optimize_insn_for_speed_p (),
3175 rtx extended = expand_shift (RSHIFT_EXPR, mode, op0,
3176 GET_MODE_PRECISION (mode) - 1,
3179 temp = expand_binop (mode, xor_optab, extended, op0, target, 0,
3182 temp = expand_binop (mode, result_unsignedp ? sub_optab : subv_optab,
3183 temp, extended, target, 0, OPTAB_LIB_WIDEN);
3193 expand_abs (enum machine_mode mode, rtx op0, rtx target,
3194 int result_unsignedp, int safe)
3199 result_unsignedp = 1;
3201 temp = expand_abs_nojump (mode, op0, target, result_unsignedp);
3205 /* If that does not win, use conditional jump and negate. */
3207 /* It is safe to use the target if it is the same
3208 as the source if this is also a pseudo register */
3209 if (op0 == target && REG_P (op0)
3210 && REGNO (op0) >= FIRST_PSEUDO_REGISTER)
3213 op1 = gen_label_rtx ();
3214 if (target == 0 || ! safe
3215 || GET_MODE (target) != mode
3216 || (MEM_P (target) && MEM_VOLATILE_P (target))
3218 && REGNO (target) < FIRST_PSEUDO_REGISTER))
3219 target = gen_reg_rtx (mode);
3221 emit_move_insn (target, op0);
3224 do_compare_rtx_and_jump (target, CONST0_RTX (mode), GE, 0, mode,
3225 NULL_RTX, NULL_RTX, op1, -1);
3227 op0 = expand_unop (mode, result_unsignedp ? neg_optab : negv_optab,
3230 emit_move_insn (target, op0);
3236 /* Emit code to compute the one's complement absolute value of OP0
3237 (if (OP0 < 0) OP0 = ~OP0), with result to TARGET if convenient.
3238 (TARGET may be NULL_RTX.) The return value says where the result
3239 actually is to be found.
3241 MODE is the mode of the operand; the mode of the result is
3242 different but can be deduced from MODE. */
3245 expand_one_cmpl_abs_nojump (enum machine_mode mode, rtx op0, rtx target)
3249 /* Not applicable for floating point modes. */
3250 if (FLOAT_MODE_P (mode))
3253 /* If we have a MAX insn, we can do this as MAX (x, ~x). */
3254 if (optab_handler (smax_optab, mode) != CODE_FOR_nothing)
3256 rtx last = get_last_insn ();
3258 temp = expand_unop (mode, one_cmpl_optab, op0, NULL_RTX, 0);
3260 temp = expand_binop (mode, smax_optab, op0, temp, target, 0,
3266 delete_insns_since (last);
3269 /* If this machine has expensive jumps, we can do one's complement
3270 absolute value of X as (((signed) x >> (W-1)) ^ x). */
3272 if (GET_MODE_CLASS (mode) == MODE_INT
3273 && BRANCH_COST (optimize_insn_for_speed_p (),
3276 rtx extended = expand_shift (RSHIFT_EXPR, mode, op0,
3277 GET_MODE_PRECISION (mode) - 1,
3280 temp = expand_binop (mode, xor_optab, extended, op0, target, 0,
3290 /* A subroutine of expand_copysign, perform the copysign operation using the
3291 abs and neg primitives advertised to exist on the target. The assumption
3292 is that we have a split register file, and leaving op0 in fp registers,
3293 and not playing with subregs so much, will help the register allocator. */
3296 expand_copysign_absneg (enum machine_mode mode, rtx op0, rtx op1, rtx target,
3297 int bitpos, bool op0_is_abs)
3299 enum machine_mode imode;
3300 enum insn_code icode;
3306 /* Check if the back end provides an insn that handles signbit for the
3308 icode = optab_handler (signbit_optab, mode);
3309 if (icode != CODE_FOR_nothing)
3311 imode = insn_data[(int) icode].operand[0].mode;
3312 sign = gen_reg_rtx (imode);
3313 emit_unop_insn (icode, sign, op1, UNKNOWN);
3319 if (GET_MODE_SIZE (mode) <= UNITS_PER_WORD)
3321 imode = int_mode_for_mode (mode);
3322 if (imode == BLKmode)
3324 op1 = gen_lowpart (imode, op1);
3331 if (FLOAT_WORDS_BIG_ENDIAN)
3332 word = (GET_MODE_BITSIZE (mode) - bitpos) / BITS_PER_WORD;
3334 word = bitpos / BITS_PER_WORD;
3335 bitpos = bitpos % BITS_PER_WORD;
3336 op1 = operand_subword_force (op1, word, mode);
3339 mask = double_int_setbit (double_int_zero, bitpos);
3341 sign = expand_binop (imode, and_optab, op1,
3342 immed_double_int_const (mask, imode),
3343 NULL_RTX, 1, OPTAB_LIB_WIDEN);
3348 op0 = expand_unop (mode, abs_optab, op0, target, 0);
3355 if (target == NULL_RTX)
3356 target = copy_to_reg (op0);
3358 emit_move_insn (target, op0);
3361 label = gen_label_rtx ();
3362 emit_cmp_and_jump_insns (sign, const0_rtx, EQ, NULL_RTX, imode, 1, label);
3364 if (GET_CODE (op0) == CONST_DOUBLE)
3365 op0 = simplify_unary_operation (NEG, mode, op0, mode);
3367 op0 = expand_unop (mode, neg_optab, op0, target, 0);
3369 emit_move_insn (target, op0);
3377 /* A subroutine of expand_copysign, perform the entire copysign operation
3378 with integer bitmasks. BITPOS is the position of the sign bit; OP0_IS_ABS
3379 is true if op0 is known to have its sign bit clear. */
3382 expand_copysign_bit (enum machine_mode mode, rtx op0, rtx op1, rtx target,
3383 int bitpos, bool op0_is_abs)
3385 enum machine_mode imode;
3387 int word, nwords, i;
3390 if (GET_MODE_SIZE (mode) <= UNITS_PER_WORD)
3392 imode = int_mode_for_mode (mode);
3393 if (imode == BLKmode)
3402 if (FLOAT_WORDS_BIG_ENDIAN)
3403 word = (GET_MODE_BITSIZE (mode) - bitpos) / BITS_PER_WORD;
3405 word = bitpos / BITS_PER_WORD;
3406 bitpos = bitpos % BITS_PER_WORD;
3407 nwords = (GET_MODE_BITSIZE (mode) + BITS_PER_WORD - 1) / BITS_PER_WORD;
3410 mask = double_int_setbit (double_int_zero, bitpos);
3415 || (nwords > 1 && !valid_multiword_target_p (target)))
3416 target = gen_reg_rtx (mode);
3422 for (i = 0; i < nwords; ++i)
3424 rtx targ_piece = operand_subword (target, i, 1, mode);
3425 rtx op0_piece = operand_subword_force (op0, i, mode);
3431 = expand_binop (imode, and_optab, op0_piece,
3432 immed_double_int_const (double_int_not (mask),
3434 NULL_RTX, 1, OPTAB_LIB_WIDEN);
3436 op1 = expand_binop (imode, and_optab,
3437 operand_subword_force (op1, i, mode),
3438 immed_double_int_const (mask, imode),
3439 NULL_RTX, 1, OPTAB_LIB_WIDEN);
3441 temp = expand_binop (imode, ior_optab, op0_piece, op1,
3442 targ_piece, 1, OPTAB_LIB_WIDEN);
3443 if (temp != targ_piece)
3444 emit_move_insn (targ_piece, temp);
3447 emit_move_insn (targ_piece, op0_piece);
3450 insns = get_insns ();
3457 op1 = expand_binop (imode, and_optab, gen_lowpart (imode, op1),
3458 immed_double_int_const (mask, imode),
3459 NULL_RTX, 1, OPTAB_LIB_WIDEN);
3461 op0 = gen_lowpart (imode, op0);
3463 op0 = expand_binop (imode, and_optab, op0,
3464 immed_double_int_const (double_int_not (mask),
3466 NULL_RTX, 1, OPTAB_LIB_WIDEN);
3468 temp = expand_binop (imode, ior_optab, op0, op1,
3469 gen_lowpart (imode, target), 1, OPTAB_LIB_WIDEN);
3470 target = lowpart_subreg_maybe_copy (mode, temp, imode);
3476 /* Expand the C99 copysign operation. OP0 and OP1 must be the same
3477 scalar floating point mode. Return NULL if we do not know how to
3478 expand the operation inline. */
3481 expand_copysign (rtx op0, rtx op1, rtx target)
3483 enum machine_mode mode = GET_MODE (op0);
3484 const struct real_format *fmt;
3488 gcc_assert (SCALAR_FLOAT_MODE_P (mode));
3489 gcc_assert (GET_MODE (op1) == mode);
3491 /* First try to do it with a special instruction. */
3492 temp = expand_binop (mode, copysign_optab, op0, op1,
3493 target, 0, OPTAB_DIRECT);
3497 fmt = REAL_MODE_FORMAT (mode);
3498 if (fmt == NULL || !fmt->has_signed_zero)
3502 if (GET_CODE (op0) == CONST_DOUBLE)
3504 if (real_isneg (CONST_DOUBLE_REAL_VALUE (op0)))
3505 op0 = simplify_unary_operation (ABS, mode, op0, mode);
3509 if (fmt->signbit_ro >= 0
3510 && (GET_CODE (op0) == CONST_DOUBLE
3511 || (optab_handler (neg_optab, mode) != CODE_FOR_nothing
3512 && optab_handler (abs_optab, mode) != CODE_FOR_nothing)))
3514 temp = expand_copysign_absneg (mode, op0, op1, target,
3515 fmt->signbit_ro, op0_is_abs);
3520 if (fmt->signbit_rw < 0)
3522 return expand_copysign_bit (mode, op0, op1, target,
3523 fmt->signbit_rw, op0_is_abs);
3526 /* Generate an instruction whose insn-code is INSN_CODE,
3527 with two operands: an output TARGET and an input OP0.
3528 TARGET *must* be nonzero, and the output is always stored there.
3529 CODE is an rtx code such that (CODE OP0) is an rtx that describes
3530 the value that is stored into TARGET.
3532 Return false if expansion failed. */
3535 maybe_emit_unop_insn (enum insn_code icode, rtx target, rtx op0,
3538 struct expand_operand ops[2];
3541 create_output_operand (&ops[0], target, GET_MODE (target));
3542 create_input_operand (&ops[1], op0, GET_MODE (op0));
3543 pat = maybe_gen_insn (icode, 2, ops);
3547 if (INSN_P (pat) && NEXT_INSN (pat) != NULL_RTX && code != UNKNOWN)
3548 add_equal_note (pat, ops[0].value, code, ops[1].value, NULL_RTX);
3552 if (ops[0].value != target)
3553 emit_move_insn (target, ops[0].value);
3556 /* Generate an instruction whose insn-code is INSN_CODE,
3557 with two operands: an output TARGET and an input OP0.
3558 TARGET *must* be nonzero, and the output is always stored there.
3559 CODE is an rtx code such that (CODE OP0) is an rtx that describes
3560 the value that is stored into TARGET. */
3563 emit_unop_insn (enum insn_code icode, rtx target, rtx op0, enum rtx_code code)
3565 bool ok = maybe_emit_unop_insn (icode, target, op0, code);
3569 struct no_conflict_data
3571 rtx target, first, insn;
3575 /* Called via note_stores by emit_libcall_block. Set P->must_stay if
3576 the currently examined clobber / store has to stay in the list of
3577 insns that constitute the actual libcall block. */
3579 no_conflict_move_test (rtx dest, const_rtx set, void *p0)
3581 struct no_conflict_data *p= (struct no_conflict_data *) p0;
3583 /* If this inns directly contributes to setting the target, it must stay. */
3584 if (reg_overlap_mentioned_p (p->target, dest))
3585 p->must_stay = true;
3586 /* If we haven't committed to keeping any other insns in the list yet,
3587 there is nothing more to check. */
3588 else if (p->insn == p->first)
3590 /* If this insn sets / clobbers a register that feeds one of the insns
3591 already in the list, this insn has to stay too. */
3592 else if (reg_overlap_mentioned_p (dest, PATTERN (p->first))
3593 || (CALL_P (p->first) && (find_reg_fusage (p->first, USE, dest)))
3594 || reg_used_between_p (dest, p->first, p->insn)
3595 /* Likewise if this insn depends on a register set by a previous
3596 insn in the list, or if it sets a result (presumably a hard
3597 register) that is set or clobbered by a previous insn.
3598 N.B. the modified_*_p (SET_DEST...) tests applied to a MEM
3599 SET_DEST perform the former check on the address, and the latter
3600 check on the MEM. */
3601 || (GET_CODE (set) == SET
3602 && (modified_in_p (SET_SRC (set), p->first)
3603 || modified_in_p (SET_DEST (set), p->first)
3604 || modified_between_p (SET_SRC (set), p->first, p->insn)
3605 || modified_between_p (SET_DEST (set), p->first, p->insn))))
3606 p->must_stay = true;
3610 /* Emit code to make a call to a constant function or a library call.
3612 INSNS is a list containing all insns emitted in the call.
3613 These insns leave the result in RESULT. Our block is to copy RESULT
3614 to TARGET, which is logically equivalent to EQUIV.
3616 We first emit any insns that set a pseudo on the assumption that these are
3617 loading constants into registers; doing so allows them to be safely cse'ed
3618 between blocks. Then we emit all the other insns in the block, followed by
3619 an insn to move RESULT to TARGET. This last insn will have a REQ_EQUAL
3620 note with an operand of EQUIV. */
3623 emit_libcall_block (rtx insns, rtx target, rtx result, rtx equiv)
3625 rtx final_dest = target;
3626 rtx next, last, insn;
3628 /* If this is a reg with REG_USERVAR_P set, then it could possibly turn
3629 into a MEM later. Protect the libcall block from this change. */
3630 if (! REG_P (target) || REG_USERVAR_P (target))
3631 target = gen_reg_rtx (GET_MODE (target));
3633 /* If we're using non-call exceptions, a libcall corresponding to an
3634 operation that may trap may also trap. */
3635 /* ??? See the comment in front of make_reg_eh_region_note. */
3636 if (cfun->can_throw_non_call_exceptions && may_trap_p (equiv))
3638 for (insn = insns; insn; insn = NEXT_INSN (insn))
3641 rtx note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
3644 int lp_nr = INTVAL (XEXP (note, 0));
3645 if (lp_nr == 0 || lp_nr == INT_MIN)
3646 remove_note (insn, note);
3652 /* Look for any CALL_INSNs in this sequence, and attach a REG_EH_REGION
3653 reg note to indicate that this call cannot throw or execute a nonlocal
3654 goto (unless there is already a REG_EH_REGION note, in which case
3656 for (insn = insns; insn; insn = NEXT_INSN (insn))
3658 make_reg_eh_region_note_nothrow_nononlocal (insn);
3661 /* First emit all insns that set pseudos. Remove them from the list as
3662 we go. Avoid insns that set pseudos which were referenced in previous
3663 insns. These can be generated by move_by_pieces, for example,
3664 to update an address. Similarly, avoid insns that reference things
3665 set in previous insns. */
3667 for (insn = insns; insn; insn = next)
3669 rtx set = single_set (insn);
3671 next = NEXT_INSN (insn);
3673 if (set != 0 && REG_P (SET_DEST (set))
3674 && REGNO (SET_DEST (set)) >= FIRST_PSEUDO_REGISTER)
3676 struct no_conflict_data data;
3678 data.target = const0_rtx;
3682 note_stores (PATTERN (insn), no_conflict_move_test, &data);
3683 if (! data.must_stay)
3685 if (PREV_INSN (insn))
3686 NEXT_INSN (PREV_INSN (insn)) = next;
3691 PREV_INSN (next) = PREV_INSN (insn);
3697 /* Some ports use a loop to copy large arguments onto the stack.
3698 Don't move anything outside such a loop. */
3703 /* Write the remaining insns followed by the final copy. */
3704 for (insn = insns; insn; insn = next)
3706 next = NEXT_INSN (insn);
3711 last = emit_move_insn (target, result);
3712 if (optab_handler (mov_optab, GET_MODE (target)) != CODE_FOR_nothing)
3713 set_unique_reg_note (last, REG_EQUAL, copy_rtx (equiv));
3715 if (final_dest != target)
3716 emit_move_insn (final_dest, target);
3719 /* Nonzero if we can perform a comparison of mode MODE straightforwardly.
3720 PURPOSE describes how this comparison will be used. CODE is the rtx
3721 comparison code we will be using.
3723 ??? Actually, CODE is slightly weaker than that. A target is still
3724 required to implement all of the normal bcc operations, but not
3725 required to implement all (or any) of the unordered bcc operations. */
3728 can_compare_p (enum rtx_code code, enum machine_mode mode,
3729 enum can_compare_purpose purpose)
3732 test = gen_rtx_fmt_ee (code, mode, const0_rtx, const0_rtx);
3735 enum insn_code icode;
3737 if (purpose == ccp_jump
3738 && (icode = optab_handler (cbranch_optab, mode)) != CODE_FOR_nothing
3739 && insn_operand_matches (icode, 0, test))
3741 if (purpose == ccp_store_flag
3742 && (icode = optab_handler (cstore_optab, mode)) != CODE_FOR_nothing
3743 && insn_operand_matches (icode, 1, test))
3745 if (purpose == ccp_cmov
3746 && optab_handler (cmov_optab, mode) != CODE_FOR_nothing)
3749 mode = GET_MODE_WIDER_MODE (mode);
3750 PUT_MODE (test, mode);
3752 while (mode != VOIDmode);
3757 /* This function is called when we are going to emit a compare instruction that
3758 compares the values found in *PX and *PY, using the rtl operator COMPARISON.
3760 *PMODE is the mode of the inputs (in case they are const_int).
3761 *PUNSIGNEDP nonzero says that the operands are unsigned;
3762 this matters if they need to be widened (as given by METHODS).
3764 If they have mode BLKmode, then SIZE specifies the size of both operands.
3766 This function performs all the setup necessary so that the caller only has
3767 to emit a single comparison insn. This setup can involve doing a BLKmode
3768 comparison or emitting a library call to perform the comparison if no insn
3769 is available to handle it.
3770 The values which are passed in through pointers can be modified; the caller
3771 should perform the comparison on the modified values. Constant
3772 comparisons must have already been folded. */
3775 prepare_cmp_insn (rtx x, rtx y, enum rtx_code comparison, rtx size,
3776 int unsignedp, enum optab_methods methods,
3777 rtx *ptest, enum machine_mode *pmode)
3779 enum machine_mode mode = *pmode;
3781 enum machine_mode cmp_mode;
3782 enum mode_class mclass;
3784 /* The other methods are not needed. */
3785 gcc_assert (methods == OPTAB_DIRECT || methods == OPTAB_WIDEN
3786 || methods == OPTAB_LIB_WIDEN);
3788 /* If we are optimizing, force expensive constants into a register. */
3789 if (CONSTANT_P (x) && optimize
3790 && (rtx_cost (x, COMPARE, optimize_insn_for_speed_p ())
3791 > COSTS_N_INSNS (1)))
3792 x = force_reg (mode, x);
3794 if (CONSTANT_P (y) && optimize
3795 && (rtx_cost (y, COMPARE, optimize_insn_for_speed_p ())
3796 > COSTS_N_INSNS (1)))
3797 y = force_reg (mode, y);
3800 /* Make sure if we have a canonical comparison. The RTL
3801 documentation states that canonical comparisons are required only
3802 for targets which have cc0. */
3803 gcc_assert (!CONSTANT_P (x) || CONSTANT_P (y));
3806 /* Don't let both operands fail to indicate the mode. */
3807 if (GET_MODE (x) == VOIDmode && GET_MODE (y) == VOIDmode)
3808 x = force_reg (mode, x);
3809 if (mode == VOIDmode)
3810 mode = GET_MODE (x) != VOIDmode ? GET_MODE (x) : GET_MODE (y);
3812 /* Handle all BLKmode compares. */
3814 if (mode == BLKmode)
3816 enum machine_mode result_mode;
3817 enum insn_code cmp_code;
3822 = GEN_INT (MIN (MEM_ALIGN (x), MEM_ALIGN (y)) / BITS_PER_UNIT);
3826 /* Try to use a memory block compare insn - either cmpstr
3827 or cmpmem will do. */
3828 for (cmp_mode = GET_CLASS_NARROWEST_MODE (MODE_INT);
3829 cmp_mode != VOIDmode;
3830 cmp_mode = GET_MODE_WIDER_MODE (cmp_mode))
3832 cmp_code = direct_optab_handler (cmpmem_optab, cmp_mode);
3833 if (cmp_code == CODE_FOR_nothing)
3834 cmp_code = direct_optab_handler (cmpstr_optab, cmp_mode);
3835 if (cmp_code == CODE_FOR_nothing)
3836 cmp_code = direct_optab_handler (cmpstrn_optab, cmp_mode);
3837 if (cmp_code == CODE_FOR_nothing)
3840 /* Must make sure the size fits the insn's mode. */
3841 if ((CONST_INT_P (size)
3842 && INTVAL (size) >= (1 << GET_MODE_BITSIZE (cmp_mode)))
3843 || (GET_MODE_BITSIZE (GET_MODE (size))
3844 > GET_MODE_BITSIZE (cmp_mode)))
3847 result_mode = insn_data[cmp_code].operand[0].mode;
3848 result = gen_reg_rtx (result_mode);
3849 size = convert_to_mode (cmp_mode, size, 1);
3850 emit_insn (GEN_FCN (cmp_code) (result, x, y, size, opalign));
3852 *ptest = gen_rtx_fmt_ee (comparison, VOIDmode, result, const0_rtx);
3853 *pmode = result_mode;
3857 if (methods != OPTAB_LIB && methods != OPTAB_LIB_WIDEN)
3860 /* Otherwise call a library function, memcmp. */
3861 libfunc = memcmp_libfunc;
3862 length_type = sizetype;
3863 result_mode = TYPE_MODE (integer_type_node);
3864 cmp_mode = TYPE_MODE (length_type);
3865 size = convert_to_mode (TYPE_MODE (length_type), size,
3866 TYPE_UNSIGNED (length_type));
3868 result = emit_library_call_value (libfunc, 0, LCT_PURE,
3874 *ptest = gen_rtx_fmt_ee (comparison, VOIDmode, result, const0_rtx);
3875 *pmode = result_mode;
3879 /* Don't allow operands to the compare to trap, as that can put the
3880 compare and branch in different basic blocks. */
3881 if (cfun->can_throw_non_call_exceptions)
3884 x = force_reg (mode, x);
3886 y = force_reg (mode, y);
3889 if (GET_MODE_CLASS (mode) == MODE_CC)
3891 gcc_assert (can_compare_p (comparison, CCmode, ccp_jump));
3892 *ptest = gen_rtx_fmt_ee (comparison, VOIDmode, x, y);
3896 mclass = GET_MODE_CLASS (mode);
3897 test = gen_rtx_fmt_ee (comparison, VOIDmode, x, y);
3901 enum insn_code icode;
3902 icode = optab_handler (cbranch_optab, cmp_mode);
3903 if (icode != CODE_FOR_nothing
3904 && insn_operand_matches (icode, 0, test))
3906 rtx last = get_last_insn ();
3907 rtx op0 = prepare_operand (icode, x, 1, mode, cmp_mode, unsignedp);
3908 rtx op1 = prepare_operand (icode, y, 2, mode, cmp_mode, unsignedp);
3910 && insn_operand_matches (icode, 1, op0)
3911 && insn_operand_matches (icode, 2, op1))
3913 XEXP (test, 0) = op0;
3914 XEXP (test, 1) = op1;
3919 delete_insns_since (last);
3922 if (methods == OPTAB_DIRECT || !CLASS_HAS_WIDER_MODES_P (mclass))
3924 cmp_mode = GET_MODE_WIDER_MODE (cmp_mode);
3926 while (cmp_mode != VOIDmode);
3928 if (methods != OPTAB_LIB_WIDEN)
3931 if (!SCALAR_FLOAT_MODE_P (mode))
3935 /* Handle a libcall just for the mode we are using. */
3936 libfunc = optab_libfunc (cmp_optab, mode);
3937 gcc_assert (libfunc);
3939 /* If we want unsigned, and this mode has a distinct unsigned
3940 comparison routine, use that. */
3943 rtx ulibfunc = optab_libfunc (ucmp_optab, mode);
3948 result = emit_library_call_value (libfunc, NULL_RTX, LCT_CONST,
3949 targetm.libgcc_cmp_return_mode (),
3950 2, x, mode, y, mode);
3952 /* There are two kinds of comparison routines. Biased routines
3953 return 0/1/2, and unbiased routines return -1/0/1. Other parts
3954 of gcc expect that the comparison operation is equivalent
3955 to the modified comparison. For signed comparisons compare the
3956 result against 1 in the biased case, and zero in the unbiased
3957 case. For unsigned comparisons always compare against 1 after
3958 biasing the unbiased result by adding 1. This gives us a way to
3963 if (!TARGET_LIB_INT_CMP_BIASED)
3966 x = plus_constant (result, 1);
3972 prepare_cmp_insn (x, y, comparison, NULL_RTX, unsignedp, methods,
3976 prepare_float_lib_cmp (x, y, comparison, ptest, pmode);
3984 /* Before emitting an insn with code ICODE, make sure that X, which is going
3985 to be used for operand OPNUM of the insn, is converted from mode MODE to
3986 WIDER_MODE (UNSIGNEDP determines whether it is an unsigned conversion), and
3987 that it is accepted by the operand predicate. Return the new value. */
3990 prepare_operand (enum insn_code icode, rtx x, int opnum, enum machine_mode mode,
3991 enum machine_mode wider_mode, int unsignedp)
3993 if (mode != wider_mode)
3994 x = convert_modes (wider_mode, mode, x, unsignedp);
3996 if (!insn_operand_matches (icode, opnum, x))
3998 if (reload_completed)
4000 x = copy_to_mode_reg (insn_data[(int) icode].operand[opnum].mode, x);
4006 /* Subroutine of emit_cmp_and_jump_insns; this function is called when we know
4007 we can do the branch. */
4010 emit_cmp_and_jump_insn_1 (rtx test, enum machine_mode mode, rtx label)
4012 enum machine_mode optab_mode;
4013 enum mode_class mclass;
4014 enum insn_code icode;
4016 mclass = GET_MODE_CLASS (mode);
4017 optab_mode = (mclass == MODE_CC) ? CCmode : mode;
4018 icode = optab_handler (cbranch_optab, optab_mode);
4020 gcc_assert (icode != CODE_FOR_nothing);
4021 gcc_assert (insn_operand_matches (icode, 0, test));
4022 emit_jump_insn (GEN_FCN (icode) (test, XEXP (test, 0), XEXP (test, 1), label));
4025 /* Generate code to compare X with Y so that the condition codes are
4026 set and to jump to LABEL if the condition is true. If X is a
4027 constant and Y is not a constant, then the comparison is swapped to
4028 ensure that the comparison RTL has the canonical form.
4030 UNSIGNEDP nonzero says that X and Y are unsigned; this matters if they
4031 need to be widened. UNSIGNEDP is also used to select the proper
4032 branch condition code.
4034 If X and Y have mode BLKmode, then SIZE specifies the size of both X and Y.
4036 MODE is the mode of the inputs (in case they are const_int).
4038 COMPARISON is the rtl operator to compare with (EQ, NE, GT, etc.).
4039 It will be potentially converted into an unsigned variant based on
4040 UNSIGNEDP to select a proper jump instruction. */
4043 emit_cmp_and_jump_insns (rtx x, rtx y, enum rtx_code comparison, rtx size,
4044 enum machine_mode mode, int unsignedp, rtx label)
4046 rtx op0 = x, op1 = y;
4049 /* Swap operands and condition to ensure canonical RTL. */
4050 if (swap_commutative_operands_p (x, y)
4051 && can_compare_p (swap_condition (comparison), mode, ccp_jump))
4054 comparison = swap_condition (comparison);
4057 /* If OP0 is still a constant, then both X and Y must be constants
4058 or the opposite comparison is not supported. Force X into a register
4059 to create canonical RTL. */
4060 if (CONSTANT_P (op0))
4061 op0 = force_reg (mode, op0);
4064 comparison = unsigned_condition (comparison);
4066 prepare_cmp_insn (op0, op1, comparison, size, unsignedp, OPTAB_LIB_WIDEN,
4068 emit_cmp_and_jump_insn_1 (test, mode, label);
4072 /* Emit a library call comparison between floating point X and Y.
4073 COMPARISON is the rtl operator to compare with (EQ, NE, GT, etc.). */
4076 prepare_float_lib_cmp (rtx x, rtx y, enum rtx_code comparison,
4077 rtx *ptest, enum machine_mode *pmode)
4079 enum rtx_code swapped = swap_condition (comparison);
4080 enum rtx_code reversed = reverse_condition_maybe_unordered (comparison);
4081 enum machine_mode orig_mode = GET_MODE (x);
4082 enum machine_mode mode, cmp_mode;
4083 rtx true_rtx, false_rtx;
4084 rtx value, target, insns, equiv;
4086 bool reversed_p = false;
4087 cmp_mode = targetm.libgcc_cmp_return_mode ();
4089 for (mode = orig_mode;
4091 mode = GET_MODE_WIDER_MODE (mode))
4093 if (code_to_optab[comparison]
4094 && (libfunc = optab_libfunc (code_to_optab[comparison], mode)))
4097 if (code_to_optab[swapped]
4098 && (libfunc = optab_libfunc (code_to_optab[swapped], mode)))
4101 tmp = x; x = y; y = tmp;
4102 comparison = swapped;
4106 if (code_to_optab[reversed]
4107 && (libfunc = optab_libfunc (code_to_optab[reversed], mode)))
4109 comparison = reversed;
4115 gcc_assert (mode != VOIDmode);
4117 if (mode != orig_mode)
4119 x = convert_to_mode (mode, x, 0);
4120 y = convert_to_mode (mode, y, 0);
4123 /* Attach a REG_EQUAL note describing the semantics of the libcall to
4124 the RTL. The allows the RTL optimizers to delete the libcall if the
4125 condition can be determined at compile-time. */
4126 if (comparison == UNORDERED
4127 || FLOAT_LIB_COMPARE_RETURNS_BOOL (mode, comparison))
4129 true_rtx = const_true_rtx;
4130 false_rtx = const0_rtx;
4137 true_rtx = const0_rtx;
4138 false_rtx = const_true_rtx;
4142 true_rtx = const_true_rtx;
4143 false_rtx = const0_rtx;
4147 true_rtx = const1_rtx;
4148 false_rtx = const0_rtx;
4152 true_rtx = const0_rtx;
4153 false_rtx = constm1_rtx;
4157 true_rtx = constm1_rtx;
4158 false_rtx = const0_rtx;
4162 true_rtx = const0_rtx;
4163 false_rtx = const1_rtx;
4171 if (comparison == UNORDERED)
4173 rtx temp = simplify_gen_relational (NE, cmp_mode, mode, x, x);
4174 equiv = simplify_gen_relational (NE, cmp_mode, mode, y, y);
4175 equiv = simplify_gen_ternary (IF_THEN_ELSE, cmp_mode, cmp_mode,
4176 temp, const_true_rtx, equiv);
4180 equiv = simplify_gen_relational (comparison, cmp_mode, mode, x, y);
4181 if (! FLOAT_LIB_COMPARE_RETURNS_BOOL (mode, comparison))
4182 equiv = simplify_gen_ternary (IF_THEN_ELSE, cmp_mode, cmp_mode,
4183 equiv, true_rtx, false_rtx);
4187 value = emit_library_call_value (libfunc, NULL_RTX, LCT_CONST,
4188 cmp_mode, 2, x, mode, y, mode);
4189 insns = get_insns ();
4192 target = gen_reg_rtx (cmp_mode);
4193 emit_libcall_block (insns, target, value, equiv);
4195 if (comparison == UNORDERED
4196 || FLOAT_LIB_COMPARE_RETURNS_BOOL (mode, comparison)
4198 *ptest = gen_rtx_fmt_ee (reversed_p ? EQ : NE, VOIDmode, target, false_rtx);
4200 *ptest = gen_rtx_fmt_ee (comparison, VOIDmode, target, const0_rtx);
4205 /* Generate code to indirectly jump to a location given in the rtx LOC. */
4208 emit_indirect_jump (rtx loc)
4210 struct expand_operand ops[1];
4212 create_address_operand (&ops[0], loc);
4213 expand_jump_insn (CODE_FOR_indirect_jump, 1, ops);
4217 #ifdef HAVE_conditional_move
4219 /* Emit a conditional move instruction if the machine supports one for that
4220 condition and machine mode.
4222 OP0 and OP1 are the operands that should be compared using CODE. CMODE is
4223 the mode to use should they be constants. If it is VOIDmode, they cannot
4226 OP2 should be stored in TARGET if the comparison is true, otherwise OP3
4227 should be stored there. MODE is the mode to use should they be constants.
4228 If it is VOIDmode, they cannot both be constants.
4230 The result is either TARGET (perhaps modified) or NULL_RTX if the operation
4231 is not supported. */
4234 emit_conditional_move (rtx target, enum rtx_code code, rtx op0, rtx op1,
4235 enum machine_mode cmode, rtx op2, rtx op3,
4236 enum machine_mode mode, int unsignedp)
4238 rtx tem, comparison, last;
4239 enum insn_code icode;
4240 enum rtx_code reversed;
4242 /* If one operand is constant, make it the second one. Only do this
4243 if the other operand is not constant as well. */
4245 if (swap_commutative_operands_p (op0, op1))
4250 code = swap_condition (code);
4253 /* get_condition will prefer to generate LT and GT even if the old
4254 comparison was against zero, so undo that canonicalization here since
4255 comparisons against zero are cheaper. */
4256 if (code == LT && op1 == const1_rtx)
4257 code = LE, op1 = const0_rtx;
4258 else if (code == GT && op1 == constm1_rtx)
4259 code = GE, op1 = const0_rtx;
4261 if (cmode == VOIDmode)
4262 cmode = GET_MODE (op0);
4264 if (swap_commutative_operands_p (op2, op3)
4265 && ((reversed = reversed_comparison_code_parts (code, op0, op1, NULL))
4274 if (mode == VOIDmode)
4275 mode = GET_MODE (op2);
4277 icode = direct_optab_handler (movcc_optab, mode);
4279 if (icode == CODE_FOR_nothing)
4283 target = gen_reg_rtx (mode);
4285 code = unsignedp ? unsigned_condition (code) : code;
4286 comparison = simplify_gen_relational (code, VOIDmode, cmode, op0, op1);
4288 /* We can get const0_rtx or const_true_rtx in some circumstances. Just
4289 return NULL and let the caller figure out how best to deal with this
4291 if (!COMPARISON_P (comparison))
4294 do_pending_stack_adjust ();
4295 last = get_last_insn ();
4296 prepare_cmp_insn (XEXP (comparison, 0), XEXP (comparison, 1),
4297 GET_CODE (comparison), NULL_RTX, unsignedp, OPTAB_WIDEN,
4298 &comparison, &cmode);
4301 struct expand_operand ops[4];
4303 create_output_operand (&ops[0], target, mode);
4304 create_fixed_operand (&ops[1], comparison);
4305 create_input_operand (&ops[2], op2, mode);
4306 create_input_operand (&ops[3], op3, mode);
4307 if (maybe_expand_insn (icode, 4, ops))
4309 if (ops[0].value != target)
4310 convert_move (target, ops[0].value, false);
4314 delete_insns_since (last);
4318 /* Return nonzero if a conditional move of mode MODE is supported.
4320 This function is for combine so it can tell whether an insn that looks
4321 like a conditional move is actually supported by the hardware. If we
4322 guess wrong we lose a bit on optimization, but that's it. */
4323 /* ??? sparc64 supports conditionally moving integers values based on fp
4324 comparisons, and vice versa. How do we handle them? */
4327 can_conditionally_move_p (enum machine_mode mode)
4329 if (direct_optab_handler (movcc_optab, mode) != CODE_FOR_nothing)
4335 #endif /* HAVE_conditional_move */
4337 /* Emit a conditional addition instruction if the machine supports one for that
4338 condition and machine mode.
4340 OP0 and OP1 are the operands that should be compared using CODE. CMODE is
4341 the mode to use should they be constants. If it is VOIDmode, they cannot
4344 OP2 should be stored in TARGET if the comparison is true, otherwise OP2+OP3
4345 should be stored there. MODE is the mode to use should they be constants.
4346 If it is VOIDmode, they cannot both be constants.
4348 The result is either TARGET (perhaps modified) or NULL_RTX if the operation
4349 is not supported. */
4352 emit_conditional_add (rtx target, enum rtx_code code, rtx op0, rtx op1,
4353 enum machine_mode cmode, rtx op2, rtx op3,
4354 enum machine_mode mode, int unsignedp)
4356 rtx tem, comparison, last;
4357 enum insn_code icode;
4358 enum rtx_code reversed;
4360 /* If one operand is constant, make it the second one. Only do this
4361 if the other operand is not constant as well. */
4363 if (swap_commutative_operands_p (op0, op1))
4368 code = swap_condition (code);
4371 /* get_condition will prefer to generate LT and GT even if the old
4372 comparison was against zero, so undo that canonicalization here since
4373 comparisons against zero are cheaper. */
4374 if (code == LT && op1 == const1_rtx)
4375 code = LE, op1 = const0_rtx;
4376 else if (code == GT && op1 == constm1_rtx)
4377 code = GE, op1 = const0_rtx;
4379 if (cmode == VOIDmode)
4380 cmode = GET_MODE (op0);
4382 if (swap_commutative_operands_p (op2, op3)
4383 && ((reversed = reversed_comparison_code_parts (code, op0, op1, NULL))
4392 if (mode == VOIDmode)
4393 mode = GET_MODE (op2);
4395 icode = optab_handler (addcc_optab, mode);
4397 if (icode == CODE_FOR_nothing)
4401 target = gen_reg_rtx (mode);
4403 code = unsignedp ? unsigned_condition (code) : code;
4404 comparison = simplify_gen_relational (code, VOIDmode, cmode, op0, op1);
4406 /* We can get const0_rtx or const_true_rtx in some circumstances. Just
4407 return NULL and let the caller figure out how best to deal with this
4409 if (!COMPARISON_P (comparison))
4412 do_pending_stack_adjust ();
4413 last = get_last_insn ();
4414 prepare_cmp_insn (XEXP (comparison, 0), XEXP (comparison, 1),
4415 GET_CODE (comparison), NULL_RTX, unsignedp, OPTAB_WIDEN,
4416 &comparison, &cmode);
4419 struct expand_operand ops[4];
4421 create_output_operand (&ops[0], target, mode);
4422 create_fixed_operand (&ops[1], comparison);
4423 create_input_operand (&ops[2], op2, mode);
4424 create_input_operand (&ops[3], op3, mode);
4425 if (maybe_expand_insn (icode, 4, ops))
4427 if (ops[0].value != target)
4428 convert_move (target, ops[0].value, false);
4432 delete_insns_since (last);
4436 /* These functions attempt to generate an insn body, rather than
4437 emitting the insn, but if the gen function already emits them, we
4438 make no attempt to turn them back into naked patterns. */
4440 /* Generate and return an insn body to add Y to X. */
4443 gen_add2_insn (rtx x, rtx y)
4445 enum insn_code icode = optab_handler (add_optab, GET_MODE (x));
4447 gcc_assert (insn_operand_matches (icode, 0, x));
4448 gcc_assert (insn_operand_matches (icode, 1, x));
4449 gcc_assert (insn_operand_matches (icode, 2, y));
4451 return GEN_FCN (icode) (x, x, y);
4454 /* Generate and return an insn body to add r1 and c,
4455 storing the result in r0. */
4458 gen_add3_insn (rtx r0, rtx r1, rtx c)
4460 enum insn_code icode = optab_handler (add_optab, GET_MODE (r0));
4462 if (icode == CODE_FOR_nothing
4463 || !insn_operand_matches (icode, 0, r0)
4464 || !insn_operand_matches (icode, 1, r1)
4465 || !insn_operand_matches (icode, 2, c))
4468 return GEN_FCN (icode) (r0, r1, c);
4472 have_add2_insn (rtx x, rtx y)
4474 enum insn_code icode;
4476 gcc_assert (GET_MODE (x) != VOIDmode);
4478 icode = optab_handler (add_optab, GET_MODE (x));
4480 if (icode == CODE_FOR_nothing)
4483 if (!insn_operand_matches (icode, 0, x)
4484 || !insn_operand_matches (icode, 1, x)
4485 || !insn_operand_matches (icode, 2, y))
4491 /* Generate and return an insn body to subtract Y from X. */
4494 gen_sub2_insn (rtx x, rtx y)
4496 enum insn_code icode = optab_handler (sub_optab, GET_MODE (x));
4498 gcc_assert (insn_operand_matches (icode, 0, x));
4499 gcc_assert (insn_operand_matches (icode, 1, x));
4500 gcc_assert (insn_operand_matches (icode, 2, y));
4502 return GEN_FCN (icode) (x, x, y);
4505 /* Generate and return an insn body to subtract r1 and c,
4506 storing the result in r0. */
4509 gen_sub3_insn (rtx r0, rtx r1, rtx c)
4511 enum insn_code icode = optab_handler (sub_optab, GET_MODE (r0));
4513 if (icode == CODE_FOR_nothing
4514 || !insn_operand_matches (icode, 0, r0)
4515 || !insn_operand_matches (icode, 1, r1)
4516 || !insn_operand_matches (icode, 2, c))
4519 return GEN_FCN (icode) (r0, r1, c);
4523 have_sub2_insn (rtx x, rtx y)
4525 enum insn_code icode;
4527 gcc_assert (GET_MODE (x) != VOIDmode);
4529 icode = optab_handler (sub_optab, GET_MODE (x));
4531 if (icode == CODE_FOR_nothing)
4534 if (!insn_operand_matches (icode, 0, x)
4535 || !insn_operand_matches (icode, 1, x)
4536 || !insn_operand_matches (icode, 2, y))
4542 /* Generate the body of an instruction to copy Y into X.
4543 It may be a list of insns, if one insn isn't enough. */
4546 gen_move_insn (rtx x, rtx y)
4551 emit_move_insn_1 (x, y);
4557 /* Return the insn code used to extend FROM_MODE to TO_MODE.
4558 UNSIGNEDP specifies zero-extension instead of sign-extension. If
4559 no such operation exists, CODE_FOR_nothing will be returned. */
4562 can_extend_p (enum machine_mode to_mode, enum machine_mode from_mode,
4566 #ifdef HAVE_ptr_extend
4568 return CODE_FOR_ptr_extend;
4571 tab = unsignedp ? zext_optab : sext_optab;
4572 return convert_optab_handler (tab, to_mode, from_mode);
4575 /* Generate the body of an insn to extend Y (with mode MFROM)
4576 into X (with mode MTO). Do zero-extension if UNSIGNEDP is nonzero. */
4579 gen_extend_insn (rtx x, rtx y, enum machine_mode mto,
4580 enum machine_mode mfrom, int unsignedp)
4582 enum insn_code icode = can_extend_p (mto, mfrom, unsignedp);
4583 return GEN_FCN (icode) (x, y);
4586 /* can_fix_p and can_float_p say whether the target machine
4587 can directly convert a given fixed point type to
4588 a given floating point type, or vice versa.
4589 The returned value is the CODE_FOR_... value to use,
4590 or CODE_FOR_nothing if these modes cannot be directly converted.
4592 *TRUNCP_PTR is set to 1 if it is necessary to output
4593 an explicit FTRUNC insn before the fix insn; otherwise 0. */
4595 static enum insn_code
4596 can_fix_p (enum machine_mode fixmode, enum machine_mode fltmode,
4597 int unsignedp, int *truncp_ptr)
4600 enum insn_code icode;
4602 tab = unsignedp ? ufixtrunc_optab : sfixtrunc_optab;
4603 icode = convert_optab_handler (tab, fixmode, fltmode);
4604 if (icode != CODE_FOR_nothing)
4610 /* FIXME: This requires a port to define both FIX and FTRUNC pattern
4611 for this to work. We need to rework the fix* and ftrunc* patterns
4612 and documentation. */
4613 tab = unsignedp ? ufix_optab : sfix_optab;
4614 icode = convert_optab_handler (tab, fixmode, fltmode);
4615 if (icode != CODE_FOR_nothing
4616 && optab_handler (ftrunc_optab, fltmode) != CODE_FOR_nothing)
4623 return CODE_FOR_nothing;
4626 static enum insn_code
4627 can_float_p (enum machine_mode fltmode, enum machine_mode fixmode,
4632 tab = unsignedp ? ufloat_optab : sfloat_optab;
4633 return convert_optab_handler (tab, fltmode, fixmode);
4636 /* Generate code to convert FROM to floating point
4637 and store in TO. FROM must be fixed point and not VOIDmode.
4638 UNSIGNEDP nonzero means regard FROM as unsigned.
4639 Normally this is done by correcting the final value
4640 if it is negative. */
4643 expand_float (rtx to, rtx from, int unsignedp)
4645 enum insn_code icode;
4647 enum machine_mode fmode, imode;
4648 bool can_do_signed = false;
4650 /* Crash now, because we won't be able to decide which mode to use. */
4651 gcc_assert (GET_MODE (from) != VOIDmode);
4653 /* Look for an insn to do the conversion. Do it in the specified
4654 modes if possible; otherwise convert either input, output or both to
4655 wider mode. If the integer mode is wider than the mode of FROM,
4656 we can do the conversion signed even if the input is unsigned. */
4658 for (fmode = GET_MODE (to); fmode != VOIDmode;
4659 fmode = GET_MODE_WIDER_MODE (fmode))
4660 for (imode = GET_MODE (from); imode != VOIDmode;
4661 imode = GET_MODE_WIDER_MODE (imode))
4663 int doing_unsigned = unsignedp;
4665 if (fmode != GET_MODE (to)
4666 && significand_size (fmode) < GET_MODE_PRECISION (GET_MODE (from)))
4669 icode = can_float_p (fmode, imode, unsignedp);
4670 if (icode == CODE_FOR_nothing && unsignedp)
4672 enum insn_code scode = can_float_p (fmode, imode, 0);
4673 if (scode != CODE_FOR_nothing)
4674 can_do_signed = true;
4675 if (imode != GET_MODE (from))
4676 icode = scode, doing_unsigned = 0;
4679 if (icode != CODE_FOR_nothing)
4681 if (imode != GET_MODE (from))
4682 from = convert_to_mode (imode, from, unsignedp);
4684 if (fmode != GET_MODE (to))
4685 target = gen_reg_rtx (fmode);
4687 emit_unop_insn (icode, target, from,
4688 doing_unsigned ? UNSIGNED_FLOAT : FLOAT);
4691 convert_move (to, target, 0);
4696 /* Unsigned integer, and no way to convert directly. Convert as signed,
4697 then unconditionally adjust the result. */
4698 if (unsignedp && can_do_signed)
4700 rtx label = gen_label_rtx ();
4702 REAL_VALUE_TYPE offset;
4704 /* Look for a usable floating mode FMODE wider than the source and at
4705 least as wide as the target. Using FMODE will avoid rounding woes
4706 with unsigned values greater than the signed maximum value. */
4708 for (fmode = GET_MODE (to); fmode != VOIDmode;
4709 fmode = GET_MODE_WIDER_MODE (fmode))
4710 if (GET_MODE_PRECISION (GET_MODE (from)) < GET_MODE_BITSIZE (fmode)
4711 && can_float_p (fmode, GET_MODE (from), 0) != CODE_FOR_nothing)
4714 if (fmode == VOIDmode)
4716 /* There is no such mode. Pretend the target is wide enough. */
4717 fmode = GET_MODE (to);
4719 /* Avoid double-rounding when TO is narrower than FROM. */
4720 if ((significand_size (fmode) + 1)
4721 < GET_MODE_PRECISION (GET_MODE (from)))
4724 rtx neglabel = gen_label_rtx ();
4726 /* Don't use TARGET if it isn't a register, is a hard register,
4727 or is the wrong mode. */
4729 || REGNO (target) < FIRST_PSEUDO_REGISTER
4730 || GET_MODE (target) != fmode)
4731 target = gen_reg_rtx (fmode);
4733 imode = GET_MODE (from);
4734 do_pending_stack_adjust ();
4736 /* Test whether the sign bit is set. */
4737 emit_cmp_and_jump_insns (from, const0_rtx, LT, NULL_RTX, imode,
4740 /* The sign bit is not set. Convert as signed. */
4741 expand_float (target, from, 0);
4742 emit_jump_insn (gen_jump (label));
4745 /* The sign bit is set.
4746 Convert to a usable (positive signed) value by shifting right
4747 one bit, while remembering if a nonzero bit was shifted
4748 out; i.e., compute (from & 1) | (from >> 1). */
4750 emit_label (neglabel);
4751 temp = expand_binop (imode, and_optab, from, const1_rtx,
4752 NULL_RTX, 1, OPTAB_LIB_WIDEN);
4753 temp1 = expand_shift (RSHIFT_EXPR, imode, from, 1, NULL_RTX, 1);
4754 temp = expand_binop (imode, ior_optab, temp, temp1, temp, 1,
4756 expand_float (target, temp, 0);
4758 /* Multiply by 2 to undo the shift above. */
4759 temp = expand_binop (fmode, add_optab, target, target,
4760 target, 0, OPTAB_LIB_WIDEN);
4762 emit_move_insn (target, temp);
4764 do_pending_stack_adjust ();
4770 /* If we are about to do some arithmetic to correct for an
4771 unsigned operand, do it in a pseudo-register. */
4773 if (GET_MODE (to) != fmode
4774 || !REG_P (to) || REGNO (to) < FIRST_PSEUDO_REGISTER)
4775 target = gen_reg_rtx (fmode);
4777 /* Convert as signed integer to floating. */
4778 expand_float (target, from, 0);
4780 /* If FROM is negative (and therefore TO is negative),
4781 correct its value by 2**bitwidth. */
4783 do_pending_stack_adjust ();
4784 emit_cmp_and_jump_insns (from, const0_rtx, GE, NULL_RTX, GET_MODE (from),
4788 real_2expN (&offset, GET_MODE_PRECISION (GET_MODE (from)), fmode);
4789 temp = expand_binop (fmode, add_optab, target,
4790 CONST_DOUBLE_FROM_REAL_VALUE (offset, fmode),
4791 target, 0, OPTAB_LIB_WIDEN);
4793 emit_move_insn (target, temp);
4795 do_pending_stack_adjust ();
4800 /* No hardware instruction available; call a library routine. */
4805 convert_optab tab = unsignedp ? ufloat_optab : sfloat_optab;
4807 if (GET_MODE_SIZE (GET_MODE (from)) < GET_MODE_SIZE (SImode))
4808 from = convert_to_mode (SImode, from, unsignedp);
4810 libfunc = convert_optab_libfunc (tab, GET_MODE (to), GET_MODE (from));
4811 gcc_assert (libfunc);
4815 value = emit_library_call_value (libfunc, NULL_RTX, LCT_CONST,
4816 GET_MODE (to), 1, from,
4818 insns = get_insns ();
4821 emit_libcall_block (insns, target, value,
4822 gen_rtx_fmt_e (unsignedp ? UNSIGNED_FLOAT : FLOAT,
4823 GET_MODE (to), from));
4828 /* Copy result to requested destination
4829 if we have been computing in a temp location. */
4833 if (GET_MODE (target) == GET_MODE (to))
4834 emit_move_insn (to, target);
4836 convert_move (to, target, 0);
4840 /* Generate code to convert FROM to fixed point and store in TO. FROM
4841 must be floating point. */
4844 expand_fix (rtx to, rtx from, int unsignedp)
4846 enum insn_code icode;
4848 enum machine_mode fmode, imode;
4851 /* We first try to find a pair of modes, one real and one integer, at
4852 least as wide as FROM and TO, respectively, in which we can open-code
4853 this conversion. If the integer mode is wider than the mode of TO,
4854 we can do the conversion either signed or unsigned. */
4856 for (fmode = GET_MODE (from); fmode != VOIDmode;
4857 fmode = GET_MODE_WIDER_MODE (fmode))
4858 for (imode = GET_MODE (to); imode != VOIDmode;
4859 imode = GET_MODE_WIDER_MODE (imode))
4861 int doing_unsigned = unsignedp;
4863 icode = can_fix_p (imode, fmode, unsignedp, &must_trunc);
4864 if (icode == CODE_FOR_nothing && imode != GET_MODE (to) && unsignedp)
4865 icode = can_fix_p (imode, fmode, 0, &must_trunc), doing_unsigned = 0;
4867 if (icode != CODE_FOR_nothing)
4869 rtx last = get_last_insn ();
4870 if (fmode != GET_MODE (from))
4871 from = convert_to_mode (fmode, from, 0);
4875 rtx temp = gen_reg_rtx (GET_MODE (from));
4876 from = expand_unop (GET_MODE (from), ftrunc_optab, from,
4880 if (imode != GET_MODE (to))
4881 target = gen_reg_rtx (imode);
4883 if (maybe_emit_unop_insn (icode, target, from,
4884 doing_unsigned ? UNSIGNED_FIX : FIX))
4887 convert_move (to, target, unsignedp);
4890 delete_insns_since (last);
4894 /* For an unsigned conversion, there is one more way to do it.
4895 If we have a signed conversion, we generate code that compares
4896 the real value to the largest representable positive number. If if
4897 is smaller, the conversion is done normally. Otherwise, subtract
4898 one plus the highest signed number, convert, and add it back.
4900 We only need to check all real modes, since we know we didn't find
4901 anything with a wider integer mode.
4903 This code used to extend FP value into mode wider than the destination.
4904 This is needed for decimal float modes which cannot accurately
4905 represent one plus the highest signed number of the same size, but
4906 not for binary modes. Consider, for instance conversion from SFmode
4909 The hot path through the code is dealing with inputs smaller than 2^63
4910 and doing just the conversion, so there is no bits to lose.
4912 In the other path we know the value is positive in the range 2^63..2^64-1
4913 inclusive. (as for other input overflow happens and result is undefined)
4914 So we know that the most important bit set in mantissa corresponds to
4915 2^63. The subtraction of 2^63 should not generate any rounding as it
4916 simply clears out that bit. The rest is trivial. */
4918 if (unsignedp && GET_MODE_PRECISION (GET_MODE (to)) <= HOST_BITS_PER_WIDE_INT)
4919 for (fmode = GET_MODE (from); fmode != VOIDmode;
4920 fmode = GET_MODE_WIDER_MODE (fmode))
4921 if (CODE_FOR_nothing != can_fix_p (GET_MODE (to), fmode, 0, &must_trunc)
4922 && (!DECIMAL_FLOAT_MODE_P (fmode)
4923 || GET_MODE_BITSIZE (fmode) > GET_MODE_PRECISION (GET_MODE (to))))
4926 REAL_VALUE_TYPE offset;
4927 rtx limit, lab1, lab2, insn;
4929 bitsize = GET_MODE_PRECISION (GET_MODE (to));
4930 real_2expN (&offset, bitsize - 1, fmode);
4931 limit = CONST_DOUBLE_FROM_REAL_VALUE (offset, fmode);
4932 lab1 = gen_label_rtx ();
4933 lab2 = gen_label_rtx ();
4935 if (fmode != GET_MODE (from))
4936 from = convert_to_mode (fmode, from, 0);
4938 /* See if we need to do the subtraction. */
4939 do_pending_stack_adjust ();
4940 emit_cmp_and_jump_insns (from, limit, GE, NULL_RTX, GET_MODE (from),
4943 /* If not, do the signed "fix" and branch around fixup code. */
4944 expand_fix (to, from, 0);
4945 emit_jump_insn (gen_jump (lab2));
4948 /* Otherwise, subtract 2**(N-1), convert to signed number,
4949 then add 2**(N-1). Do the addition using XOR since this
4950 will often generate better code. */
4952 target = expand_binop (GET_MODE (from), sub_optab, from, limit,
4953 NULL_RTX, 0, OPTAB_LIB_WIDEN);
4954 expand_fix (to, target, 0);
4955 target = expand_binop (GET_MODE (to), xor_optab, to,
4957 ((HOST_WIDE_INT) 1 << (bitsize - 1),
4959 to, 1, OPTAB_LIB_WIDEN);
4962 emit_move_insn (to, target);
4966 if (optab_handler (mov_optab, GET_MODE (to)) != CODE_FOR_nothing)
4968 /* Make a place for a REG_NOTE and add it. */
4969 insn = emit_move_insn (to, to);
4970 set_unique_reg_note (insn,
4972 gen_rtx_fmt_e (UNSIGNED_FIX,
4980 /* We can't do it with an insn, so use a library call. But first ensure
4981 that the mode of TO is at least as wide as SImode, since those are the
4982 only library calls we know about. */
4984 if (GET_MODE_SIZE (GET_MODE (to)) < GET_MODE_SIZE (SImode))
4986 target = gen_reg_rtx (SImode);
4988 expand_fix (target, from, unsignedp);
4996 convert_optab tab = unsignedp ? ufix_optab : sfix_optab;
4997 libfunc = convert_optab_libfunc (tab, GET_MODE (to), GET_MODE (from));
4998 gcc_assert (libfunc);
5002 value = emit_library_call_value (libfunc, NULL_RTX, LCT_CONST,
5003 GET_MODE (to), 1, from,
5005 insns = get_insns ();
5008 emit_libcall_block (insns, target, value,
5009 gen_rtx_fmt_e (unsignedp ? UNSIGNED_FIX : FIX,
5010 GET_MODE (to), from));
5015 if (GET_MODE (to) == GET_MODE (target))
5016 emit_move_insn (to, target);
5018 convert_move (to, target, 0);
5022 /* Generate code to convert FROM or TO a fixed-point.
5023 If UINTP is true, either TO or FROM is an unsigned integer.
5024 If SATP is true, we need to saturate the result. */
5027 expand_fixed_convert (rtx to, rtx from, int uintp, int satp)
5029 enum machine_mode to_mode = GET_MODE (to);
5030 enum machine_mode from_mode = GET_MODE (from);
5032 enum rtx_code this_code;
5033 enum insn_code code;
5037 if (to_mode == from_mode)
5039 emit_move_insn (to, from);
5045 tab = satp ? satfractuns_optab : fractuns_optab;
5046 this_code = satp ? UNSIGNED_SAT_FRACT : UNSIGNED_FRACT_CONVERT;
5050 tab = satp ? satfract_optab : fract_optab;
5051 this_code = satp ? SAT_FRACT : FRACT_CONVERT;
5053 code = convert_optab_handler (tab, to_mode, from_mode);
5054 if (code != CODE_FOR_nothing)
5056 emit_unop_insn (code, to, from, this_code);
5060 libfunc = convert_optab_libfunc (tab, to_mode, from_mode);
5061 gcc_assert (libfunc);
5064 value = emit_library_call_value (libfunc, NULL_RTX, LCT_CONST, to_mode,
5065 1, from, from_mode);
5066 insns = get_insns ();
5069 emit_libcall_block (insns, to, value,
5070 gen_rtx_fmt_e (tab->code, to_mode, from));
5073 /* Generate code to convert FROM to fixed point and store in TO. FROM
5074 must be floating point, TO must be signed. Use the conversion optab
5075 TAB to do the conversion. */
5078 expand_sfix_optab (rtx to, rtx from, convert_optab tab)
5080 enum insn_code icode;
5082 enum machine_mode fmode, imode;
5084 /* We first try to find a pair of modes, one real and one integer, at
5085 least as wide as FROM and TO, respectively, in which we can open-code
5086 this conversion. If the integer mode is wider than the mode of TO,
5087 we can do the conversion either signed or unsigned. */
5089 for (fmode = GET_MODE (from); fmode != VOIDmode;
5090 fmode = GET_MODE_WIDER_MODE (fmode))
5091 for (imode = GET_MODE (to); imode != VOIDmode;
5092 imode = GET_MODE_WIDER_MODE (imode))
5094 icode = convert_optab_handler (tab, imode, fmode);
5095 if (icode != CODE_FOR_nothing)
5097 rtx last = get_last_insn ();
5098 if (fmode != GET_MODE (from))
5099 from = convert_to_mode (fmode, from, 0);
5101 if (imode != GET_MODE (to))
5102 target = gen_reg_rtx (imode);
5104 if (!maybe_emit_unop_insn (icode, target, from, UNKNOWN))
5106 delete_insns_since (last);
5110 convert_move (to, target, 0);
5118 /* Report whether we have an instruction to perform the operation
5119 specified by CODE on operands of mode MODE. */
5121 have_insn_for (enum rtx_code code, enum machine_mode mode)
5123 return (code_to_optab[(int) code] != 0
5124 && (optab_handler (code_to_optab[(int) code], mode)
5125 != CODE_FOR_nothing));
5128 /* Set all insn_code fields to CODE_FOR_nothing. */
5131 init_insn_codes (void)
5133 memset (optab_table, 0, sizeof (optab_table));
5134 memset (convert_optab_table, 0, sizeof (convert_optab_table));
5135 memset (direct_optab_table, 0, sizeof (direct_optab_table));
5138 /* Initialize OP's code to CODE, and write it into the code_to_optab table. */
5140 init_optab (optab op, enum rtx_code code)
5143 code_to_optab[(int) code] = op;
5146 /* Same, but fill in its code as CODE, and do _not_ write it into
5147 the code_to_optab table. */
5149 init_optabv (optab op, enum rtx_code code)
5154 /* Conversion optabs never go in the code_to_optab table. */
5156 init_convert_optab (convert_optab op, enum rtx_code code)
5161 /* Initialize the libfunc fields of an entire group of entries in some
5162 optab. Each entry is set equal to a string consisting of a leading
5163 pair of underscores followed by a generic operation name followed by
5164 a mode name (downshifted to lowercase) followed by a single character
5165 representing the number of operands for the given operation (which is
5166 usually one of the characters '2', '3', or '4').
5168 OPTABLE is the table in which libfunc fields are to be initialized.
5169 OPNAME is the generic (string) name of the operation.
5170 SUFFIX is the character which specifies the number of operands for
5171 the given generic operation.
5172 MODE is the mode to generate for.
5176 gen_libfunc (optab optable, const char *opname, int suffix, enum machine_mode mode)
5178 unsigned opname_len = strlen (opname);
5179 const char *mname = GET_MODE_NAME (mode);
5180 unsigned mname_len = strlen (mname);
5181 int prefix_len = targetm.libfunc_gnu_prefix ? 6 : 2;
5182 int len = prefix_len + opname_len + mname_len + 1 + 1;
5183 char *libfunc_name = XALLOCAVEC (char, len);
5190 if (targetm.libfunc_gnu_prefix)
5197 for (q = opname; *q; )
5199 for (q = mname; *q; q++)
5200 *p++ = TOLOWER (*q);
5204 set_optab_libfunc (optable, mode,
5205 ggc_alloc_string (libfunc_name, p - libfunc_name));
5208 /* Like gen_libfunc, but verify that integer operation is involved. */
5211 gen_int_libfunc (optab optable, const char *opname, char suffix,
5212 enum machine_mode mode)
5214 int maxsize = 2 * BITS_PER_WORD;
5216 if (GET_MODE_CLASS (mode) != MODE_INT)
5218 if (maxsize < LONG_LONG_TYPE_SIZE)
5219 maxsize = LONG_LONG_TYPE_SIZE;
5220 if (GET_MODE_CLASS (mode) != MODE_INT
5221 || mode < word_mode || GET_MODE_BITSIZE (mode) > maxsize)
5223 gen_libfunc (optable, opname, suffix, mode);
5226 /* Like gen_libfunc, but verify that FP and set decimal prefix if needed. */
5229 gen_fp_libfunc (optab optable, const char *opname, char suffix,
5230 enum machine_mode mode)
5234 if (GET_MODE_CLASS (mode) == MODE_FLOAT)
5235 gen_libfunc (optable, opname, suffix, mode);
5236 if (DECIMAL_FLOAT_MODE_P (mode))
5238 dec_opname = XALLOCAVEC (char, sizeof (DECIMAL_PREFIX) + strlen (opname));
5239 /* For BID support, change the name to have either a bid_ or dpd_ prefix
5240 depending on the low level floating format used. */
5241 memcpy (dec_opname, DECIMAL_PREFIX, sizeof (DECIMAL_PREFIX) - 1);
5242 strcpy (dec_opname + sizeof (DECIMAL_PREFIX) - 1, opname);
5243 gen_libfunc (optable, dec_opname, suffix, mode);
5247 /* Like gen_libfunc, but verify that fixed-point operation is involved. */
5250 gen_fixed_libfunc (optab optable, const char *opname, char suffix,
5251 enum machine_mode mode)
5253 if (!ALL_FIXED_POINT_MODE_P (mode))
5255 gen_libfunc (optable, opname, suffix, mode);
5258 /* Like gen_libfunc, but verify that signed fixed-point operation is
5262 gen_signed_fixed_libfunc (optab optable, const char *opname, char suffix,
5263 enum machine_mode mode)
5265 if (!SIGNED_FIXED_POINT_MODE_P (mode))
5267 gen_libfunc (optable, opname, suffix, mode);
5270 /* Like gen_libfunc, but verify that unsigned fixed-point operation is
5274 gen_unsigned_fixed_libfunc (optab optable, const char *opname, char suffix,
5275 enum machine_mode mode)
5277 if (!UNSIGNED_FIXED_POINT_MODE_P (mode))
5279 gen_libfunc (optable, opname, suffix, mode);
5282 /* Like gen_libfunc, but verify that FP or INT operation is involved. */
5285 gen_int_fp_libfunc (optab optable, const char *name, char suffix,
5286 enum machine_mode mode)
5288 if (DECIMAL_FLOAT_MODE_P (mode) || GET_MODE_CLASS (mode) == MODE_FLOAT)
5289 gen_fp_libfunc (optable, name, suffix, mode);
5290 if (INTEGRAL_MODE_P (mode))
5291 gen_int_libfunc (optable, name, suffix, mode);
5294 /* Like gen_libfunc, but verify that FP or INT operation is involved
5295 and add 'v' suffix for integer operation. */
5298 gen_intv_fp_libfunc (optab optable, const char *name, char suffix,
5299 enum machine_mode mode)
5301 if (DECIMAL_FLOAT_MODE_P (mode) || GET_MODE_CLASS (mode) == MODE_FLOAT)
5302 gen_fp_libfunc (optable, name, suffix, mode);
5303 if (GET_MODE_CLASS (mode) == MODE_INT)
5305 int len = strlen (name);
5306 char *v_name = XALLOCAVEC (char, len + 2);
5307 strcpy (v_name, name);
5309 v_name[len + 1] = 0;
5310 gen_int_libfunc (optable, v_name, suffix, mode);
5314 /* Like gen_libfunc, but verify that FP or INT or FIXED operation is
5318 gen_int_fp_fixed_libfunc (optab optable, const char *name, char suffix,
5319 enum machine_mode mode)
5321 if (DECIMAL_FLOAT_MODE_P (mode) || GET_MODE_CLASS (mode) == MODE_FLOAT)
5322 gen_fp_libfunc (optable, name, suffix, mode);
5323 if (INTEGRAL_MODE_P (mode))
5324 gen_int_libfunc (optable, name, suffix, mode);
5325 if (ALL_FIXED_POINT_MODE_P (mode))
5326 gen_fixed_libfunc (optable, name, suffix, mode);
5329 /* Like gen_libfunc, but verify that FP or INT or signed FIXED operation is
5333 gen_int_fp_signed_fixed_libfunc (optab optable, const char *name, char suffix,
5334 enum machine_mode mode)
5336 if (DECIMAL_FLOAT_MODE_P (mode) || GET_MODE_CLASS (mode) == MODE_FLOAT)
5337 gen_fp_libfunc (optable, name, suffix, mode);
5338 if (INTEGRAL_MODE_P (mode))
5339 gen_int_libfunc (optable, name, suffix, mode);
5340 if (SIGNED_FIXED_POINT_MODE_P (mode))
5341 gen_signed_fixed_libfunc (optable, name, suffix, mode);
5344 /* Like gen_libfunc, but verify that INT or FIXED operation is
5348 gen_int_fixed_libfunc (optab optable, const char *name, char suffix,
5349 enum machine_mode mode)
5351 if (INTEGRAL_MODE_P (mode))
5352 gen_int_libfunc (optable, name, suffix, mode);
5353 if (ALL_FIXED_POINT_MODE_P (mode))
5354 gen_fixed_libfunc (optable, name, suffix, mode);
5357 /* Like gen_libfunc, but verify that INT or signed FIXED operation is
5361 gen_int_signed_fixed_libfunc (optab optable, const char *name, char suffix,
5362 enum machine_mode mode)
5364 if (INTEGRAL_MODE_P (mode))
5365 gen_int_libfunc (optable, name, suffix, mode);
5366 if (SIGNED_FIXED_POINT_MODE_P (mode))
5367 gen_signed_fixed_libfunc (optable, name, suffix, mode);
5370 /* Like gen_libfunc, but verify that INT or unsigned FIXED operation is
5374 gen_int_unsigned_fixed_libfunc (optab optable, const char *name, char suffix,
5375 enum machine_mode mode)
5377 if (INTEGRAL_MODE_P (mode))
5378 gen_int_libfunc (optable, name, suffix, mode);
5379 if (UNSIGNED_FIXED_POINT_MODE_P (mode))
5380 gen_unsigned_fixed_libfunc (optable, name, suffix, mode);
5383 /* Initialize the libfunc fields of an entire group of entries of an
5384 inter-mode-class conversion optab. The string formation rules are
5385 similar to the ones for init_libfuncs, above, but instead of having
5386 a mode name and an operand count these functions have two mode names
5387 and no operand count. */
5390 gen_interclass_conv_libfunc (convert_optab tab,
5392 enum machine_mode tmode,
5393 enum machine_mode fmode)
5395 size_t opname_len = strlen (opname);
5396 size_t mname_len = 0;
5398 const char *fname, *tname;
5400 int prefix_len = targetm.libfunc_gnu_prefix ? 6 : 2;
5401 char *libfunc_name, *suffix;
5402 char *nondec_name, *dec_name, *nondec_suffix, *dec_suffix;
5405 /* If this is a decimal conversion, add the current BID vs. DPD prefix that
5406 depends on which underlying decimal floating point format is used. */
5407 const size_t dec_len = sizeof (DECIMAL_PREFIX) - 1;
5409 mname_len = strlen (GET_MODE_NAME (tmode)) + strlen (GET_MODE_NAME (fmode));
5411 nondec_name = XALLOCAVEC (char, prefix_len + opname_len + mname_len + 1 + 1);
5412 nondec_name[0] = '_';
5413 nondec_name[1] = '_';
5414 if (targetm.libfunc_gnu_prefix)
5416 nondec_name[2] = 'g';
5417 nondec_name[3] = 'n';
5418 nondec_name[4] = 'u';
5419 nondec_name[5] = '_';
5422 memcpy (&nondec_name[prefix_len], opname, opname_len);
5423 nondec_suffix = nondec_name + opname_len + prefix_len;
5425 dec_name = XALLOCAVEC (char, 2 + dec_len + opname_len + mname_len + 1 + 1);
5428 memcpy (&dec_name[2], DECIMAL_PREFIX, dec_len);
5429 memcpy (&dec_name[2+dec_len], opname, opname_len);
5430 dec_suffix = dec_name + dec_len + opname_len + 2;
5432 fname = GET_MODE_NAME (fmode);
5433 tname = GET_MODE_NAME (tmode);
5435 if (DECIMAL_FLOAT_MODE_P(fmode) || DECIMAL_FLOAT_MODE_P(tmode))
5437 libfunc_name = dec_name;
5438 suffix = dec_suffix;
5442 libfunc_name = nondec_name;
5443 suffix = nondec_suffix;
5447 for (q = fname; *q; p++, q++)
5449 for (q = tname; *q; p++, q++)
5454 set_conv_libfunc (tab, tmode, fmode,
5455 ggc_alloc_string (libfunc_name, p - libfunc_name));
5458 /* Same as gen_interclass_conv_libfunc but verify that we are producing
5459 int->fp conversion. */
5462 gen_int_to_fp_conv_libfunc (convert_optab tab,
5464 enum machine_mode tmode,
5465 enum machine_mode fmode)
5467 if (GET_MODE_CLASS (fmode) != MODE_INT)
5469 if (GET_MODE_CLASS (tmode) != MODE_FLOAT && !DECIMAL_FLOAT_MODE_P (tmode))
5471 gen_interclass_conv_libfunc (tab, opname, tmode, fmode);
5474 /* ufloat_optab is special by using floatun for FP and floatuns decimal fp
5478 gen_ufloat_conv_libfunc (convert_optab tab,
5479 const char *opname ATTRIBUTE_UNUSED,
5480 enum machine_mode tmode,
5481 enum machine_mode fmode)
5483 if (DECIMAL_FLOAT_MODE_P (tmode))
5484 gen_int_to_fp_conv_libfunc (tab, "floatuns", tmode, fmode);
5486 gen_int_to_fp_conv_libfunc (tab, "floatun", tmode, fmode);
5489 /* Same as gen_interclass_conv_libfunc but verify that we are producing
5490 fp->int conversion. */
5493 gen_int_to_fp_nondecimal_conv_libfunc (convert_optab tab,
5495 enum machine_mode tmode,
5496 enum machine_mode fmode)
5498 if (GET_MODE_CLASS (fmode) != MODE_INT)
5500 if (GET_MODE_CLASS (tmode) != MODE_FLOAT)
5502 gen_interclass_conv_libfunc (tab, opname, tmode, fmode);
5505 /* Same as gen_interclass_conv_libfunc but verify that we are producing
5506 fp->int conversion with no decimal floating point involved. */
5509 gen_fp_to_int_conv_libfunc (convert_optab tab,
5511 enum machine_mode tmode,
5512 enum machine_mode fmode)
5514 if (GET_MODE_CLASS (fmode) != MODE_FLOAT && !DECIMAL_FLOAT_MODE_P (fmode))
5516 if (GET_MODE_CLASS (tmode) != MODE_INT)
5518 gen_interclass_conv_libfunc (tab, opname, tmode, fmode);
5521 /* Initialize the libfunc fields of an of an intra-mode-class conversion optab.
5522 The string formation rules are
5523 similar to the ones for init_libfunc, above. */
5526 gen_intraclass_conv_libfunc (convert_optab tab, const char *opname,
5527 enum machine_mode tmode, enum machine_mode fmode)
5529 size_t opname_len = strlen (opname);
5530 size_t mname_len = 0;
5532 const char *fname, *tname;
5534 int prefix_len = targetm.libfunc_gnu_prefix ? 6 : 2;
5535 char *nondec_name, *dec_name, *nondec_suffix, *dec_suffix;
5536 char *libfunc_name, *suffix;
5539 /* If this is a decimal conversion, add the current BID vs. DPD prefix that
5540 depends on which underlying decimal floating point format is used. */
5541 const size_t dec_len = sizeof (DECIMAL_PREFIX) - 1;
5543 mname_len = strlen (GET_MODE_NAME (tmode)) + strlen (GET_MODE_NAME (fmode));
5545 nondec_name = XALLOCAVEC (char, 2 + opname_len + mname_len + 1 + 1);
5546 nondec_name[0] = '_';
5547 nondec_name[1] = '_';
5548 if (targetm.libfunc_gnu_prefix)
5550 nondec_name[2] = 'g';
5551 nondec_name[3] = 'n';
5552 nondec_name[4] = 'u';
5553 nondec_name[5] = '_';
5555 memcpy (&nondec_name[prefix_len], opname, opname_len);
5556 nondec_suffix = nondec_name + opname_len + prefix_len;
5558 dec_name = XALLOCAVEC (char, 2 + dec_len + opname_len + mname_len + 1 + 1);
5561 memcpy (&dec_name[2], DECIMAL_PREFIX, dec_len);
5562 memcpy (&dec_name[2 + dec_len], opname, opname_len);
5563 dec_suffix = dec_name + dec_len + opname_len + 2;
5565 fname = GET_MODE_NAME (fmode);
5566 tname = GET_MODE_NAME (tmode);
5568 if (DECIMAL_FLOAT_MODE_P(fmode) || DECIMAL_FLOAT_MODE_P(tmode))
5570 libfunc_name = dec_name;
5571 suffix = dec_suffix;
5575 libfunc_name = nondec_name;
5576 suffix = nondec_suffix;
5580 for (q = fname; *q; p++, q++)
5582 for (q = tname; *q; p++, q++)
5588 set_conv_libfunc (tab, tmode, fmode,
5589 ggc_alloc_string (libfunc_name, p - libfunc_name));
5592 /* Pick proper libcall for trunc_optab. We need to chose if we do
5593 truncation or extension and interclass or intraclass. */
5596 gen_trunc_conv_libfunc (convert_optab tab,
5598 enum machine_mode tmode,
5599 enum machine_mode fmode)
5601 if (GET_MODE_CLASS (tmode) != MODE_FLOAT && !DECIMAL_FLOAT_MODE_P (tmode))
5603 if (GET_MODE_CLASS (fmode) != MODE_FLOAT && !DECIMAL_FLOAT_MODE_P (fmode))
5608 if ((GET_MODE_CLASS (tmode) == MODE_FLOAT && DECIMAL_FLOAT_MODE_P (fmode))
5609 || (GET_MODE_CLASS (fmode) == MODE_FLOAT && DECIMAL_FLOAT_MODE_P (tmode)))
5610 gen_interclass_conv_libfunc (tab, opname, tmode, fmode);
5612 if (GET_MODE_PRECISION (fmode) <= GET_MODE_PRECISION (tmode))
5615 if ((GET_MODE_CLASS (tmode) == MODE_FLOAT
5616 && GET_MODE_CLASS (fmode) == MODE_FLOAT)
5617 || (DECIMAL_FLOAT_MODE_P (fmode) && DECIMAL_FLOAT_MODE_P (tmode)))
5618 gen_intraclass_conv_libfunc (tab, opname, tmode, fmode);
5621 /* Pick proper libcall for extend_optab. We need to chose if we do
5622 truncation or extension and interclass or intraclass. */
5625 gen_extend_conv_libfunc (convert_optab tab,
5626 const char *opname ATTRIBUTE_UNUSED,
5627 enum machine_mode tmode,
5628 enum machine_mode fmode)
5630 if (GET_MODE_CLASS (tmode) != MODE_FLOAT && !DECIMAL_FLOAT_MODE_P (tmode))
5632 if (GET_MODE_CLASS (fmode) != MODE_FLOAT && !DECIMAL_FLOAT_MODE_P (fmode))
5637 if ((GET_MODE_CLASS (tmode) == MODE_FLOAT && DECIMAL_FLOAT_MODE_P (fmode))
5638 || (GET_MODE_CLASS (fmode) == MODE_FLOAT && DECIMAL_FLOAT_MODE_P (tmode)))
5639 gen_interclass_conv_libfunc (tab, opname, tmode, fmode);
5641 if (GET_MODE_PRECISION (fmode) > GET_MODE_PRECISION (tmode))
5644 if ((GET_MODE_CLASS (tmode) == MODE_FLOAT
5645 && GET_MODE_CLASS (fmode) == MODE_FLOAT)
5646 || (DECIMAL_FLOAT_MODE_P (fmode) && DECIMAL_FLOAT_MODE_P (tmode)))
5647 gen_intraclass_conv_libfunc (tab, opname, tmode, fmode);
5650 /* Pick proper libcall for fract_optab. We need to chose if we do
5651 interclass or intraclass. */
5654 gen_fract_conv_libfunc (convert_optab tab,
5656 enum machine_mode tmode,
5657 enum machine_mode fmode)
5661 if (!(ALL_FIXED_POINT_MODE_P (tmode) || ALL_FIXED_POINT_MODE_P (fmode)))
5664 if (GET_MODE_CLASS (tmode) == GET_MODE_CLASS (fmode))
5665 gen_intraclass_conv_libfunc (tab, opname, tmode, fmode);
5667 gen_interclass_conv_libfunc (tab, opname, tmode, fmode);
5670 /* Pick proper libcall for fractuns_optab. */
5673 gen_fractuns_conv_libfunc (convert_optab tab,
5675 enum machine_mode tmode,
5676 enum machine_mode fmode)
5680 /* One mode must be a fixed-point mode, and the other must be an integer
5682 if (!((ALL_FIXED_POINT_MODE_P (tmode) && GET_MODE_CLASS (fmode) == MODE_INT)
5683 || (ALL_FIXED_POINT_MODE_P (fmode)
5684 && GET_MODE_CLASS (tmode) == MODE_INT)))
5687 gen_interclass_conv_libfunc (tab, opname, tmode, fmode);
5690 /* Pick proper libcall for satfract_optab. We need to chose if we do
5691 interclass or intraclass. */
5694 gen_satfract_conv_libfunc (convert_optab tab,
5696 enum machine_mode tmode,
5697 enum machine_mode fmode)
5701 /* TMODE must be a fixed-point mode. */
5702 if (!ALL_FIXED_POINT_MODE_P (tmode))
5705 if (GET_MODE_CLASS (tmode) == GET_MODE_CLASS (fmode))
5706 gen_intraclass_conv_libfunc (tab, opname, tmode, fmode);
5708 gen_interclass_conv_libfunc (tab, opname, tmode, fmode);
5711 /* Pick proper libcall for satfractuns_optab. */
5714 gen_satfractuns_conv_libfunc (convert_optab tab,
5716 enum machine_mode tmode,
5717 enum machine_mode fmode)
5721 /* TMODE must be a fixed-point mode, and FMODE must be an integer mode. */
5722 if (!(ALL_FIXED_POINT_MODE_P (tmode) && GET_MODE_CLASS (fmode) == MODE_INT))
5725 gen_interclass_conv_libfunc (tab, opname, tmode, fmode);
5728 /* A table of previously-created libfuncs, hashed by name. */
5729 static GTY ((param_is (union tree_node))) htab_t libfunc_decls;
5731 /* Hashtable callbacks for libfunc_decls. */
5734 libfunc_decl_hash (const void *entry)
5736 return IDENTIFIER_HASH_VALUE (DECL_NAME ((const_tree) entry));
5740 libfunc_decl_eq (const void *entry1, const void *entry2)
5742 return DECL_NAME ((const_tree) entry1) == (const_tree) entry2;
5745 /* Build a decl for a libfunc named NAME. */
5748 build_libfunc_function (const char *name)
5750 tree decl = build_decl (UNKNOWN_LOCATION, FUNCTION_DECL,
5751 get_identifier (name),
5752 build_function_type (integer_type_node, NULL_TREE));
5753 /* ??? We don't have any type information except for this is
5754 a function. Pretend this is "int foo()". */
5755 DECL_ARTIFICIAL (decl) = 1;
5756 DECL_EXTERNAL (decl) = 1;
5757 TREE_PUBLIC (decl) = 1;
5758 gcc_assert (DECL_ASSEMBLER_NAME (decl));
5760 /* Zap the nonsensical SYMBOL_REF_DECL for this. What we're left with
5761 are the flags assigned by targetm.encode_section_info. */
5762 SET_SYMBOL_REF_DECL (XEXP (DECL_RTL (decl), 0), NULL);
5768 init_one_libfunc (const char *name)
5774 if (libfunc_decls == NULL)
5775 libfunc_decls = htab_create_ggc (37, libfunc_decl_hash,
5776 libfunc_decl_eq, NULL);
5778 /* See if we have already created a libfunc decl for this function. */
5779 id = get_identifier (name);
5780 hash = IDENTIFIER_HASH_VALUE (id);
5781 slot = htab_find_slot_with_hash (libfunc_decls, id, hash, INSERT);
5782 decl = (tree) *slot;
5785 /* Create a new decl, so that it can be passed to
5786 targetm.encode_section_info. */
5787 decl = build_libfunc_function (name);
5790 return XEXP (DECL_RTL (decl), 0);
5793 /* Adjust the assembler name of libfunc NAME to ASMSPEC. */
5796 set_user_assembler_libfunc (const char *name, const char *asmspec)
5802 id = get_identifier (name);
5803 hash = IDENTIFIER_HASH_VALUE (id);
5804 slot = htab_find_slot_with_hash (libfunc_decls, id, hash, NO_INSERT);
5806 decl = (tree) *slot;
5807 set_user_assembler_name (decl, asmspec);
5808 return XEXP (DECL_RTL (decl), 0);
5811 /* Call this to reset the function entry for one optab (OPTABLE) in mode
5812 MODE to NAME, which should be either 0 or a string constant. */
5814 set_optab_libfunc (optab optable, enum machine_mode mode, const char *name)
5817 struct libfunc_entry e;
5818 struct libfunc_entry **slot;
5819 e.optab = (size_t) (optable - &optab_table[0]);
5824 val = init_one_libfunc (name);
5827 slot = (struct libfunc_entry **) htab_find_slot (libfunc_hash, &e, INSERT);
5829 *slot = ggc_alloc_libfunc_entry ();
5830 (*slot)->optab = (size_t) (optable - &optab_table[0]);
5831 (*slot)->mode1 = mode;
5832 (*slot)->mode2 = VOIDmode;
5833 (*slot)->libfunc = val;
5836 /* Call this to reset the function entry for one conversion optab
5837 (OPTABLE) from mode FMODE to mode TMODE to NAME, which should be
5838 either 0 or a string constant. */
5840 set_conv_libfunc (convert_optab optable, enum machine_mode tmode,
5841 enum machine_mode fmode, const char *name)
5844 struct libfunc_entry e;
5845 struct libfunc_entry **slot;
5846 e.optab = (size_t) (optable - &convert_optab_table[0]);
5851 val = init_one_libfunc (name);
5854 slot = (struct libfunc_entry **) htab_find_slot (libfunc_hash, &e, INSERT);
5856 *slot = ggc_alloc_libfunc_entry ();
5857 (*slot)->optab = (size_t) (optable - &convert_optab_table[0]);
5858 (*slot)->mode1 = tmode;
5859 (*slot)->mode2 = fmode;
5860 (*slot)->libfunc = val;
5863 /* Call this to initialize the contents of the optabs
5864 appropriately for the current target machine. */
5871 htab_empty (libfunc_hash);
5872 /* We statically initialize the insn_codes with the equivalent of
5873 CODE_FOR_nothing. Repeat the process if reinitialising. */
5877 libfunc_hash = htab_create_ggc (10, hash_libfunc, eq_libfunc, NULL);
5879 init_optab (add_optab, PLUS);
5880 init_optabv (addv_optab, PLUS);
5881 init_optab (sub_optab, MINUS);
5882 init_optabv (subv_optab, MINUS);
5883 init_optab (ssadd_optab, SS_PLUS);
5884 init_optab (usadd_optab, US_PLUS);
5885 init_optab (sssub_optab, SS_MINUS);
5886 init_optab (ussub_optab, US_MINUS);
5887 init_optab (smul_optab, MULT);
5888 init_optab (ssmul_optab, SS_MULT);
5889 init_optab (usmul_optab, US_MULT);
5890 init_optabv (smulv_optab, MULT);
5891 init_optab (smul_highpart_optab, UNKNOWN);
5892 init_optab (umul_highpart_optab, UNKNOWN);
5893 init_optab (smul_widen_optab, UNKNOWN);
5894 init_optab (umul_widen_optab, UNKNOWN);
5895 init_optab (usmul_widen_optab, UNKNOWN);
5896 init_optab (smadd_widen_optab, UNKNOWN);
5897 init_optab (umadd_widen_optab, UNKNOWN);
5898 init_optab (ssmadd_widen_optab, UNKNOWN);
5899 init_optab (usmadd_widen_optab, UNKNOWN);
5900 init_optab (smsub_widen_optab, UNKNOWN);
5901 init_optab (umsub_widen_optab, UNKNOWN);
5902 init_optab (ssmsub_widen_optab, UNKNOWN);
5903 init_optab (usmsub_widen_optab, UNKNOWN);
5904 init_optab (sdiv_optab, DIV);
5905 init_optab (ssdiv_optab, SS_DIV);
5906 init_optab (usdiv_optab, US_DIV);
5907 init_optabv (sdivv_optab, DIV);
5908 init_optab (sdivmod_optab, UNKNOWN);
5909 init_optab (udiv_optab, UDIV);
5910 init_optab (udivmod_optab, UNKNOWN);
5911 init_optab (smod_optab, MOD);
5912 init_optab (umod_optab, UMOD);
5913 init_optab (fmod_optab, UNKNOWN);
5914 init_optab (remainder_optab, UNKNOWN);
5915 init_optab (ftrunc_optab, UNKNOWN);
5916 init_optab (and_optab, AND);
5917 init_optab (ior_optab, IOR);
5918 init_optab (xor_optab, XOR);
5919 init_optab (ashl_optab, ASHIFT);
5920 init_optab (ssashl_optab, SS_ASHIFT);
5921 init_optab (usashl_optab, US_ASHIFT);
5922 init_optab (ashr_optab, ASHIFTRT);
5923 init_optab (lshr_optab, LSHIFTRT);
5924 init_optabv (vashl_optab, ASHIFT);
5925 init_optabv (vashr_optab, ASHIFTRT);
5926 init_optabv (vlshr_optab, LSHIFTRT);
5927 init_optab (rotl_optab, ROTATE);
5928 init_optab (rotr_optab, ROTATERT);
5929 init_optab (smin_optab, SMIN);
5930 init_optab (smax_optab, SMAX);
5931 init_optab (umin_optab, UMIN);
5932 init_optab (umax_optab, UMAX);
5933 init_optab (pow_optab, UNKNOWN);
5934 init_optab (atan2_optab, UNKNOWN);
5935 init_optab (fma_optab, FMA);
5936 init_optab (fms_optab, UNKNOWN);
5937 init_optab (fnma_optab, UNKNOWN);
5938 init_optab (fnms_optab, UNKNOWN);
5940 /* These three have codes assigned exclusively for the sake of
5942 init_optab (mov_optab, SET);
5943 init_optab (movstrict_optab, STRICT_LOW_PART);
5944 init_optab (cbranch_optab, COMPARE);
5946 init_optab (cmov_optab, UNKNOWN);
5947 init_optab (cstore_optab, UNKNOWN);
5948 init_optab (ctrap_optab, UNKNOWN);
5950 init_optab (storent_optab, UNKNOWN);
5952 init_optab (cmp_optab, UNKNOWN);
5953 init_optab (ucmp_optab, UNKNOWN);
5955 init_optab (eq_optab, EQ);
5956 init_optab (ne_optab, NE);
5957 init_optab (gt_optab, GT);
5958 init_optab (ge_optab, GE);
5959 init_optab (lt_optab, LT);
5960 init_optab (le_optab, LE);
5961 init_optab (unord_optab, UNORDERED);
5963 init_optab (neg_optab, NEG);
5964 init_optab (ssneg_optab, SS_NEG);
5965 init_optab (usneg_optab, US_NEG);
5966 init_optabv (negv_optab, NEG);
5967 init_optab (abs_optab, ABS);
5968 init_optabv (absv_optab, ABS);
5969 init_optab (addcc_optab, UNKNOWN);
5970 init_optab (one_cmpl_optab, NOT);
5971 init_optab (bswap_optab, BSWAP);
5972 init_optab (ffs_optab, FFS);
5973 init_optab (clz_optab, CLZ);
5974 init_optab (ctz_optab, CTZ);
5975 init_optab (clrsb_optab, CLRSB);
5976 init_optab (popcount_optab, POPCOUNT);
5977 init_optab (parity_optab, PARITY);
5978 init_optab (sqrt_optab, SQRT);
5979 init_optab (floor_optab, UNKNOWN);
5980 init_optab (ceil_optab, UNKNOWN);
5981 init_optab (round_optab, UNKNOWN);
5982 init_optab (btrunc_optab, UNKNOWN);
5983 init_optab (nearbyint_optab, UNKNOWN);
5984 init_optab (rint_optab, UNKNOWN);
5985 init_optab (sincos_optab, UNKNOWN);
5986 init_optab (sin_optab, UNKNOWN);
5987 init_optab (asin_optab, UNKNOWN);
5988 init_optab (cos_optab, UNKNOWN);
5989 init_optab (acos_optab, UNKNOWN);
5990 init_optab (exp_optab, UNKNOWN);
5991 init_optab (exp10_optab, UNKNOWN);
5992 init_optab (exp2_optab, UNKNOWN);
5993 init_optab (expm1_optab, UNKNOWN);
5994 init_optab (ldexp_optab, UNKNOWN);
5995 init_optab (scalb_optab, UNKNOWN);
5996 init_optab (significand_optab, UNKNOWN);
5997 init_optab (logb_optab, UNKNOWN);
5998 init_optab (ilogb_optab, UNKNOWN);
5999 init_optab (log_optab, UNKNOWN);
6000 init_optab (log10_optab, UNKNOWN);
6001 init_optab (log2_optab, UNKNOWN);
6002 init_optab (log1p_optab, UNKNOWN);
6003 init_optab (tan_optab, UNKNOWN);
6004 init_optab (atan_optab, UNKNOWN);
6005 init_optab (copysign_optab, UNKNOWN);
6006 init_optab (signbit_optab, UNKNOWN);
6008 init_optab (isinf_optab, UNKNOWN);
6010 init_optab (strlen_optab, UNKNOWN);
6011 init_optab (push_optab, UNKNOWN);
6013 init_optab (reduc_smax_optab, UNKNOWN);
6014 init_optab (reduc_umax_optab, UNKNOWN);
6015 init_optab (reduc_smin_optab, UNKNOWN);
6016 init_optab (reduc_umin_optab, UNKNOWN);
6017 init_optab (reduc_splus_optab, UNKNOWN);
6018 init_optab (reduc_uplus_optab, UNKNOWN);
6020 init_optab (ssum_widen_optab, UNKNOWN);
6021 init_optab (usum_widen_optab, UNKNOWN);
6022 init_optab (sdot_prod_optab, UNKNOWN);
6023 init_optab (udot_prod_optab, UNKNOWN);
6025 init_optab (vec_extract_optab, UNKNOWN);
6026 init_optab (vec_extract_even_optab, UNKNOWN);
6027 init_optab (vec_extract_odd_optab, UNKNOWN);
6028 init_optab (vec_interleave_high_optab, UNKNOWN);
6029 init_optab (vec_interleave_low_optab, UNKNOWN);
6030 init_optab (vec_set_optab, UNKNOWN);
6031 init_optab (vec_init_optab, UNKNOWN);
6032 init_optab (vec_shl_optab, UNKNOWN);
6033 init_optab (vec_shr_optab, UNKNOWN);
6034 init_optab (vec_realign_load_optab, UNKNOWN);
6035 init_optab (movmisalign_optab, UNKNOWN);
6036 init_optab (vec_widen_umult_hi_optab, UNKNOWN);
6037 init_optab (vec_widen_umult_lo_optab, UNKNOWN);
6038 init_optab (vec_widen_smult_hi_optab, UNKNOWN);
6039 init_optab (vec_widen_smult_lo_optab, UNKNOWN);
6040 init_optab (vec_unpacks_hi_optab, UNKNOWN);
6041 init_optab (vec_unpacks_lo_optab, UNKNOWN);
6042 init_optab (vec_unpacku_hi_optab, UNKNOWN);
6043 init_optab (vec_unpacku_lo_optab, UNKNOWN);
6044 init_optab (vec_unpacks_float_hi_optab, UNKNOWN);
6045 init_optab (vec_unpacks_float_lo_optab, UNKNOWN);
6046 init_optab (vec_unpacku_float_hi_optab, UNKNOWN);
6047 init_optab (vec_unpacku_float_lo_optab, UNKNOWN);
6048 init_optab (vec_pack_trunc_optab, UNKNOWN);
6049 init_optab (vec_pack_usat_optab, UNKNOWN);
6050 init_optab (vec_pack_ssat_optab, UNKNOWN);
6051 init_optab (vec_pack_ufix_trunc_optab, UNKNOWN);
6052 init_optab (vec_pack_sfix_trunc_optab, UNKNOWN);
6054 init_optab (powi_optab, UNKNOWN);
6057 init_convert_optab (sext_optab, SIGN_EXTEND);
6058 init_convert_optab (zext_optab, ZERO_EXTEND);
6059 init_convert_optab (trunc_optab, TRUNCATE);
6060 init_convert_optab (sfix_optab, FIX);
6061 init_convert_optab (ufix_optab, UNSIGNED_FIX);
6062 init_convert_optab (sfixtrunc_optab, UNKNOWN);
6063 init_convert_optab (ufixtrunc_optab, UNKNOWN);
6064 init_convert_optab (sfloat_optab, FLOAT);
6065 init_convert_optab (ufloat_optab, UNSIGNED_FLOAT);
6066 init_convert_optab (lrint_optab, UNKNOWN);
6067 init_convert_optab (lround_optab, UNKNOWN);
6068 init_convert_optab (lfloor_optab, UNKNOWN);
6069 init_convert_optab (lceil_optab, UNKNOWN);
6071 init_convert_optab (fract_optab, FRACT_CONVERT);
6072 init_convert_optab (fractuns_optab, UNSIGNED_FRACT_CONVERT);
6073 init_convert_optab (satfract_optab, SAT_FRACT);
6074 init_convert_optab (satfractuns_optab, UNSIGNED_SAT_FRACT);
6076 /* Fill in the optabs with the insns we support. */
6079 /* Initialize the optabs with the names of the library functions. */
6080 add_optab->libcall_basename = "add";
6081 add_optab->libcall_suffix = '3';
6082 add_optab->libcall_gen = gen_int_fp_fixed_libfunc;
6083 addv_optab->libcall_basename = "add";
6084 addv_optab->libcall_suffix = '3';
6085 addv_optab->libcall_gen = gen_intv_fp_libfunc;
6086 ssadd_optab->libcall_basename = "ssadd";
6087 ssadd_optab->libcall_suffix = '3';
6088 ssadd_optab->libcall_gen = gen_signed_fixed_libfunc;
6089 usadd_optab->libcall_basename = "usadd";
6090 usadd_optab->libcall_suffix = '3';
6091 usadd_optab->libcall_gen = gen_unsigned_fixed_libfunc;
6092 sub_optab->libcall_basename = "sub";
6093 sub_optab->libcall_suffix = '3';
6094 sub_optab->libcall_gen = gen_int_fp_fixed_libfunc;
6095 subv_optab->libcall_basename = "sub";
6096 subv_optab->libcall_suffix = '3';
6097 subv_optab->libcall_gen = gen_intv_fp_libfunc;
6098 sssub_optab->libcall_basename = "sssub";
6099 sssub_optab->libcall_suffix = '3';
6100 sssub_optab->libcall_gen = gen_signed_fixed_libfunc;
6101 ussub_optab->libcall_basename = "ussub";
6102 ussub_optab->libcall_suffix = '3';
6103 ussub_optab->libcall_gen = gen_unsigned_fixed_libfunc;
6104 smul_optab->libcall_basename = "mul";
6105 smul_optab->libcall_suffix = '3';
6106 smul_optab->libcall_gen = gen_int_fp_fixed_libfunc;
6107 smulv_optab->libcall_basename = "mul";
6108 smulv_optab->libcall_suffix = '3';
6109 smulv_optab->libcall_gen = gen_intv_fp_libfunc;
6110 ssmul_optab->libcall_basename = "ssmul";
6111 ssmul_optab->libcall_suffix = '3';
6112 ssmul_optab->libcall_gen = gen_signed_fixed_libfunc;
6113 usmul_optab->libcall_basename = "usmul";
6114 usmul_optab->libcall_suffix = '3';
6115 usmul_optab->libcall_gen = gen_unsigned_fixed_libfunc;
6116 sdiv_optab->libcall_basename = "div";
6117 sdiv_optab->libcall_suffix = '3';
6118 sdiv_optab->libcall_gen = gen_int_fp_signed_fixed_libfunc;
6119 sdivv_optab->libcall_basename = "divv";
6120 sdivv_optab->libcall_suffix = '3';
6121 sdivv_optab->libcall_gen = gen_int_libfunc;
6122 ssdiv_optab->libcall_basename = "ssdiv";
6123 ssdiv_optab->libcall_suffix = '3';
6124 ssdiv_optab->libcall_gen = gen_signed_fixed_libfunc;
6125 udiv_optab->libcall_basename = "udiv";
6126 udiv_optab->libcall_suffix = '3';
6127 udiv_optab->libcall_gen = gen_int_unsigned_fixed_libfunc;
6128 usdiv_optab->libcall_basename = "usdiv";
6129 usdiv_optab->libcall_suffix = '3';
6130 usdiv_optab->libcall_gen = gen_unsigned_fixed_libfunc;
6131 sdivmod_optab->libcall_basename = "divmod";
6132 sdivmod_optab->libcall_suffix = '4';
6133 sdivmod_optab->libcall_gen = gen_int_libfunc;
6134 udivmod_optab->libcall_basename = "udivmod";
6135 udivmod_optab->libcall_suffix = '4';
6136 udivmod_optab->libcall_gen = gen_int_libfunc;
6137 smod_optab->libcall_basename = "mod";
6138 smod_optab->libcall_suffix = '3';
6139 smod_optab->libcall_gen = gen_int_libfunc;
6140 umod_optab->libcall_basename = "umod";
6141 umod_optab->libcall_suffix = '3';
6142 umod_optab->libcall_gen = gen_int_libfunc;
6143 ftrunc_optab->libcall_basename = "ftrunc";
6144 ftrunc_optab->libcall_suffix = '2';
6145 ftrunc_optab->libcall_gen = gen_fp_libfunc;
6146 and_optab->libcall_basename = "and";
6147 and_optab->libcall_suffix = '3';
6148 and_optab->libcall_gen = gen_int_libfunc;
6149 ior_optab->libcall_basename = "ior";
6150 ior_optab->libcall_suffix = '3';
6151 ior_optab->libcall_gen = gen_int_libfunc;
6152 xor_optab->libcall_basename = "xor";
6153 xor_optab->libcall_suffix = '3';
6154 xor_optab->libcall_gen = gen_int_libfunc;
6155 ashl_optab->libcall_basename = "ashl";
6156 ashl_optab->libcall_suffix = '3';
6157 ashl_optab->libcall_gen = gen_int_fixed_libfunc;
6158 ssashl_optab->libcall_basename = "ssashl";
6159 ssashl_optab->libcall_suffix = '3';
6160 ssashl_optab->libcall_gen = gen_signed_fixed_libfunc;
6161 usashl_optab->libcall_basename = "usashl";
6162 usashl_optab->libcall_suffix = '3';
6163 usashl_optab->libcall_gen = gen_unsigned_fixed_libfunc;
6164 ashr_optab->libcall_basename = "ashr";
6165 ashr_optab->libcall_suffix = '3';
6166 ashr_optab->libcall_gen = gen_int_signed_fixed_libfunc;
6167 lshr_optab->libcall_basename = "lshr";
6168 lshr_optab->libcall_suffix = '3';
6169 lshr_optab->libcall_gen = gen_int_unsigned_fixed_libfunc;
6170 smin_optab->libcall_basename = "min";
6171 smin_optab->libcall_suffix = '3';
6172 smin_optab->libcall_gen = gen_int_fp_libfunc;
6173 smax_optab->libcall_basename = "max";
6174 smax_optab->libcall_suffix = '3';
6175 smax_optab->libcall_gen = gen_int_fp_libfunc;
6176 umin_optab->libcall_basename = "umin";
6177 umin_optab->libcall_suffix = '3';
6178 umin_optab->libcall_gen = gen_int_libfunc;
6179 umax_optab->libcall_basename = "umax";
6180 umax_optab->libcall_suffix = '3';
6181 umax_optab->libcall_gen = gen_int_libfunc;
6182 neg_optab->libcall_basename = "neg";
6183 neg_optab->libcall_suffix = '2';
6184 neg_optab->libcall_gen = gen_int_fp_fixed_libfunc;
6185 ssneg_optab->libcall_basename = "ssneg";
6186 ssneg_optab->libcall_suffix = '2';
6187 ssneg_optab->libcall_gen = gen_signed_fixed_libfunc;
6188 usneg_optab->libcall_basename = "usneg";
6189 usneg_optab->libcall_suffix = '2';
6190 usneg_optab->libcall_gen = gen_unsigned_fixed_libfunc;
6191 negv_optab->libcall_basename = "neg";
6192 negv_optab->libcall_suffix = '2';
6193 negv_optab->libcall_gen = gen_intv_fp_libfunc;
6194 one_cmpl_optab->libcall_basename = "one_cmpl";
6195 one_cmpl_optab->libcall_suffix = '2';
6196 one_cmpl_optab->libcall_gen = gen_int_libfunc;
6197 ffs_optab->libcall_basename = "ffs";
6198 ffs_optab->libcall_suffix = '2';
6199 ffs_optab->libcall_gen = gen_int_libfunc;
6200 clz_optab->libcall_basename = "clz";
6201 clz_optab->libcall_suffix = '2';
6202 clz_optab->libcall_gen = gen_int_libfunc;
6203 ctz_optab->libcall_basename = "ctz";
6204 ctz_optab->libcall_suffix = '2';
6205 ctz_optab->libcall_gen = gen_int_libfunc;
6206 clrsb_optab->libcall_basename = "clrsb";
6207 clrsb_optab->libcall_suffix = '2';
6208 clrsb_optab->libcall_gen = gen_int_libfunc;
6209 popcount_optab->libcall_basename = "popcount";
6210 popcount_optab->libcall_suffix = '2';
6211 popcount_optab->libcall_gen = gen_int_libfunc;
6212 parity_optab->libcall_basename = "parity";
6213 parity_optab->libcall_suffix = '2';
6214 parity_optab->libcall_gen = gen_int_libfunc;
6216 /* Comparison libcalls for integers MUST come in pairs,
6218 cmp_optab->libcall_basename = "cmp";
6219 cmp_optab->libcall_suffix = '2';
6220 cmp_optab->libcall_gen = gen_int_fp_fixed_libfunc;
6221 ucmp_optab->libcall_basename = "ucmp";
6222 ucmp_optab->libcall_suffix = '2';
6223 ucmp_optab->libcall_gen = gen_int_libfunc;
6225 /* EQ etc are floating point only. */
6226 eq_optab->libcall_basename = "eq";
6227 eq_optab->libcall_suffix = '2';
6228 eq_optab->libcall_gen = gen_fp_libfunc;
6229 ne_optab->libcall_basename = "ne";
6230 ne_optab->libcall_suffix = '2';
6231 ne_optab->libcall_gen = gen_fp_libfunc;
6232 gt_optab->libcall_basename = "gt";
6233 gt_optab->libcall_suffix = '2';
6234 gt_optab->libcall_gen = gen_fp_libfunc;
6235 ge_optab->libcall_basename = "ge";
6236 ge_optab->libcall_suffix = '2';
6237 ge_optab->libcall_gen = gen_fp_libfunc;
6238 lt_optab->libcall_basename = "lt";
6239 lt_optab->libcall_suffix = '2';
6240 lt_optab->libcall_gen = gen_fp_libfunc;
6241 le_optab->libcall_basename = "le";
6242 le_optab->libcall_suffix = '2';
6243 le_optab->libcall_gen = gen_fp_libfunc;
6244 unord_optab->libcall_basename = "unord";
6245 unord_optab->libcall_suffix = '2';
6246 unord_optab->libcall_gen = gen_fp_libfunc;
6248 powi_optab->libcall_basename = "powi";
6249 powi_optab->libcall_suffix = '2';
6250 powi_optab->libcall_gen = gen_fp_libfunc;
6253 sfloat_optab->libcall_basename = "float";
6254 sfloat_optab->libcall_gen = gen_int_to_fp_conv_libfunc;
6255 ufloat_optab->libcall_gen = gen_ufloat_conv_libfunc;
6256 sfix_optab->libcall_basename = "fix";
6257 sfix_optab->libcall_gen = gen_fp_to_int_conv_libfunc;
6258 ufix_optab->libcall_basename = "fixuns";
6259 ufix_optab->libcall_gen = gen_fp_to_int_conv_libfunc;
6260 lrint_optab->libcall_basename = "lrint";
6261 lrint_optab->libcall_gen = gen_int_to_fp_nondecimal_conv_libfunc;
6262 lround_optab->libcall_basename = "lround";
6263 lround_optab->libcall_gen = gen_int_to_fp_nondecimal_conv_libfunc;
6264 lfloor_optab->libcall_basename = "lfloor";
6265 lfloor_optab->libcall_gen = gen_int_to_fp_nondecimal_conv_libfunc;
6266 lceil_optab->libcall_basename = "lceil";
6267 lceil_optab->libcall_gen = gen_int_to_fp_nondecimal_conv_libfunc;
6269 /* trunc_optab is also used for FLOAT_EXTEND. */
6270 sext_optab->libcall_basename = "extend";
6271 sext_optab->libcall_gen = gen_extend_conv_libfunc;
6272 trunc_optab->libcall_basename = "trunc";
6273 trunc_optab->libcall_gen = gen_trunc_conv_libfunc;
6275 /* Conversions for fixed-point modes and other modes. */
6276 fract_optab->libcall_basename = "fract";
6277 fract_optab->libcall_gen = gen_fract_conv_libfunc;
6278 satfract_optab->libcall_basename = "satfract";
6279 satfract_optab->libcall_gen = gen_satfract_conv_libfunc;
6280 fractuns_optab->libcall_basename = "fractuns";
6281 fractuns_optab->libcall_gen = gen_fractuns_conv_libfunc;
6282 satfractuns_optab->libcall_basename = "satfractuns";
6283 satfractuns_optab->libcall_gen = gen_satfractuns_conv_libfunc;
6285 /* The ffs function operates on `int'. Fall back on it if we do not
6286 have a libgcc2 function for that width. */
6287 if (INT_TYPE_SIZE < BITS_PER_WORD)
6288 set_optab_libfunc (ffs_optab, mode_for_size (INT_TYPE_SIZE, MODE_INT, 0),
6291 /* Explicitly initialize the bswap libfuncs since we need them to be
6292 valid for things other than word_mode. */
6293 if (targetm.libfunc_gnu_prefix)
6295 set_optab_libfunc (bswap_optab, SImode, "__gnu_bswapsi2");
6296 set_optab_libfunc (bswap_optab, DImode, "__gnu_bswapdi2");
6300 set_optab_libfunc (bswap_optab, SImode, "__bswapsi2");
6301 set_optab_libfunc (bswap_optab, DImode, "__bswapdi2");
6304 /* Use cabs for double complex abs, since systems generally have cabs.
6305 Don't define any libcall for float complex, so that cabs will be used. */
6306 if (complex_double_type_node)
6307 set_optab_libfunc (abs_optab, TYPE_MODE (complex_double_type_node), "cabs");
6309 abort_libfunc = init_one_libfunc ("abort");
6310 memcpy_libfunc = init_one_libfunc ("memcpy");
6311 memmove_libfunc = init_one_libfunc ("memmove");
6312 memcmp_libfunc = init_one_libfunc ("memcmp");
6313 memset_libfunc = init_one_libfunc ("memset");
6314 setbits_libfunc = init_one_libfunc ("__setbits");
6316 #ifndef DONT_USE_BUILTIN_SETJMP
6317 setjmp_libfunc = init_one_libfunc ("__builtin_setjmp");
6318 longjmp_libfunc = init_one_libfunc ("__builtin_longjmp");
6320 setjmp_libfunc = init_one_libfunc ("setjmp");
6321 longjmp_libfunc = init_one_libfunc ("longjmp");
6323 unwind_sjlj_register_libfunc = init_one_libfunc ("_Unwind_SjLj_Register");
6324 unwind_sjlj_unregister_libfunc
6325 = init_one_libfunc ("_Unwind_SjLj_Unregister");
6327 /* For function entry/exit instrumentation. */
6328 profile_function_entry_libfunc
6329 = init_one_libfunc ("__cyg_profile_func_enter");
6330 profile_function_exit_libfunc
6331 = init_one_libfunc ("__cyg_profile_func_exit");
6333 gcov_flush_libfunc = init_one_libfunc ("__gcov_flush");
6335 /* Allow the target to add more libcalls or rename some, etc. */
6336 targetm.init_libfuncs ();
6339 /* Print information about the current contents of the optabs on
6343 debug_optab_libfuncs (void)
6349 /* Dump the arithmetic optabs. */
6350 for (i = 0; i != (int) OTI_MAX; i++)
6351 for (j = 0; j < NUM_MACHINE_MODES; ++j)
6356 o = &optab_table[i];
6357 l = optab_libfunc (o, (enum machine_mode) j);
6360 gcc_assert (GET_CODE (l) == SYMBOL_REF);
6361 fprintf (stderr, "%s\t%s:\t%s\n",
6362 GET_RTX_NAME (o->code),
6368 /* Dump the conversion optabs. */
6369 for (i = 0; i < (int) COI_MAX; ++i)
6370 for (j = 0; j < NUM_MACHINE_MODES; ++j)
6371 for (k = 0; k < NUM_MACHINE_MODES; ++k)
6376 o = &convert_optab_table[i];
6377 l = convert_optab_libfunc (o, (enum machine_mode) j,
6378 (enum machine_mode) k);
6381 gcc_assert (GET_CODE (l) == SYMBOL_REF);
6382 fprintf (stderr, "%s\t%s\t%s:\t%s\n",
6383 GET_RTX_NAME (o->code),
6392 /* Generate insns to trap with code TCODE if OP1 and OP2 satisfy condition
6393 CODE. Return 0 on failure. */
6396 gen_cond_trap (enum rtx_code code, rtx op1, rtx op2, rtx tcode)
6398 enum machine_mode mode = GET_MODE (op1);
6399 enum insn_code icode;
6403 if (mode == VOIDmode)
6406 icode = optab_handler (ctrap_optab, mode);
6407 if (icode == CODE_FOR_nothing)
6410 /* Some targets only accept a zero trap code. */
6411 if (!insn_operand_matches (icode, 3, tcode))
6414 do_pending_stack_adjust ();
6416 prepare_cmp_insn (op1, op2, code, NULL_RTX, false, OPTAB_DIRECT,
6421 insn = GEN_FCN (icode) (trap_rtx, XEXP (trap_rtx, 0), XEXP (trap_rtx, 1),
6424 /* If that failed, then give up. */
6432 insn = get_insns ();
6437 /* Return rtx code for TCODE. Use UNSIGNEDP to select signed
6438 or unsigned operation code. */
6440 static enum rtx_code
6441 get_rtx_code (enum tree_code tcode, bool unsignedp)
6453 code = unsignedp ? LTU : LT;
6456 code = unsignedp ? LEU : LE;
6459 code = unsignedp ? GTU : GT;
6462 code = unsignedp ? GEU : GE;
6465 case UNORDERED_EXPR:
6496 /* Return comparison rtx for COND. Use UNSIGNEDP to select signed or
6497 unsigned operators. Do not generate compare instruction. */
6500 vector_compare_rtx (tree cond, bool unsignedp, enum insn_code icode)
6502 struct expand_operand ops[2];
6503 enum rtx_code rcode;
6505 rtx rtx_op0, rtx_op1;
6507 /* This is unlikely. While generating VEC_COND_EXPR, auto vectorizer
6508 ensures that condition is a relational operation. */
6509 gcc_assert (COMPARISON_CLASS_P (cond));
6511 rcode = get_rtx_code (TREE_CODE (cond), unsignedp);
6512 t_op0 = TREE_OPERAND (cond, 0);
6513 t_op1 = TREE_OPERAND (cond, 1);
6515 /* Expand operands. */
6516 rtx_op0 = expand_expr (t_op0, NULL_RTX, TYPE_MODE (TREE_TYPE (t_op0)),
6518 rtx_op1 = expand_expr (t_op1, NULL_RTX, TYPE_MODE (TREE_TYPE (t_op1)),
6521 create_input_operand (&ops[0], rtx_op0, GET_MODE (rtx_op0));
6522 create_input_operand (&ops[1], rtx_op1, GET_MODE (rtx_op1));
6523 if (!maybe_legitimize_operands (icode, 4, 2, ops))
6525 return gen_rtx_fmt_ee (rcode, VOIDmode, ops[0].value, ops[1].value);
6528 /* Return insn code for TYPE, the type of a VEC_COND_EXPR. */
6530 static inline enum insn_code
6531 get_vcond_icode (tree type, enum machine_mode mode)
6533 enum insn_code icode = CODE_FOR_nothing;
6535 if (TYPE_UNSIGNED (type))
6536 icode = direct_optab_handler (vcondu_optab, mode);
6538 icode = direct_optab_handler (vcond_optab, mode);
6542 /* Return TRUE iff, appropriate vector insns are available
6543 for vector cond expr with type TYPE in VMODE mode. */
6546 expand_vec_cond_expr_p (tree type, enum machine_mode vmode)
6548 if (get_vcond_icode (type, vmode) == CODE_FOR_nothing)
6553 /* Generate insns for a VEC_COND_EXPR, given its TYPE and its
6557 expand_vec_cond_expr (tree vec_cond_type, tree op0, tree op1, tree op2,
6560 struct expand_operand ops[6];
6561 enum insn_code icode;
6562 rtx comparison, rtx_op1, rtx_op2;
6563 enum machine_mode mode = TYPE_MODE (vec_cond_type);
6564 bool unsignedp = TYPE_UNSIGNED (vec_cond_type);
6566 icode = get_vcond_icode (vec_cond_type, mode);
6567 if (icode == CODE_FOR_nothing)
6570 comparison = vector_compare_rtx (op0, unsignedp, icode);
6571 rtx_op1 = expand_normal (op1);
6572 rtx_op2 = expand_normal (op2);
6574 create_output_operand (&ops[0], target, mode);
6575 create_input_operand (&ops[1], rtx_op1, mode);
6576 create_input_operand (&ops[2], rtx_op2, mode);
6577 create_fixed_operand (&ops[3], comparison);
6578 create_fixed_operand (&ops[4], XEXP (comparison, 0));
6579 create_fixed_operand (&ops[5], XEXP (comparison, 1));
6580 expand_insn (icode, 6, ops);
6581 return ops[0].value;
6585 /* This is an internal subroutine of the other compare_and_swap expanders.
6586 MEM, OLD_VAL and NEW_VAL are as you'd expect for a compare-and-swap
6587 operation. TARGET is an optional place to store the value result of
6588 the operation. ICODE is the particular instruction to expand. Return
6589 the result of the operation. */
6592 expand_val_compare_and_swap_1 (rtx mem, rtx old_val, rtx new_val,
6593 rtx target, enum insn_code icode)
6595 struct expand_operand ops[4];
6596 enum machine_mode mode = GET_MODE (mem);
6598 create_output_operand (&ops[0], target, mode);
6599 create_fixed_operand (&ops[1], mem);
6600 /* OLD_VAL and NEW_VAL may have been promoted to a wider mode.
6601 Shrink them if so. */
6602 create_convert_operand_to (&ops[2], old_val, mode, true);
6603 create_convert_operand_to (&ops[3], new_val, mode, true);
6604 if (maybe_expand_insn (icode, 4, ops))
6605 return ops[0].value;
6609 /* Expand a compare-and-swap operation and return its value. */
6612 expand_val_compare_and_swap (rtx mem, rtx old_val, rtx new_val, rtx target)
6614 enum machine_mode mode = GET_MODE (mem);
6615 enum insn_code icode
6616 = direct_optab_handler (sync_compare_and_swap_optab, mode);
6618 if (icode == CODE_FOR_nothing)
6621 return expand_val_compare_and_swap_1 (mem, old_val, new_val, target, icode);
6624 /* Helper function to find the MODE_CC set in a sync_compare_and_swap
6628 find_cc_set (rtx x, const_rtx pat, void *data)
6630 if (REG_P (x) && GET_MODE_CLASS (GET_MODE (x)) == MODE_CC
6631 && GET_CODE (pat) == SET)
6633 rtx *p_cc_reg = (rtx *) data;
6634 gcc_assert (!*p_cc_reg);
6639 /* Expand a compare-and-swap operation and store true into the result if
6640 the operation was successful and false otherwise. Return the result.
6641 Unlike other routines, TARGET is not optional. */
6644 expand_bool_compare_and_swap (rtx mem, rtx old_val, rtx new_val, rtx target)
6646 enum machine_mode mode = GET_MODE (mem);
6647 enum insn_code icode;
6648 rtx subtarget, seq, cc_reg;
6650 /* If the target supports a compare-and-swap pattern that simultaneously
6651 sets some flag for success, then use it. Otherwise use the regular
6652 compare-and-swap and follow that immediately with a compare insn. */
6653 icode = direct_optab_handler (sync_compare_and_swap_optab, mode);
6654 if (icode == CODE_FOR_nothing)
6657 do_pending_stack_adjust ();
6661 subtarget = expand_val_compare_and_swap_1 (mem, old_val, new_val,
6664 if (subtarget == NULL_RTX)
6670 if (have_insn_for (COMPARE, CCmode))
6671 note_stores (PATTERN (get_last_insn ()), find_cc_set, &cc_reg);
6675 /* We might be comparing against an old value. Try again. :-( */
6676 if (!cc_reg && MEM_P (old_val))
6679 old_val = force_reg (mode, old_val);
6686 return emit_store_flag_force (target, EQ, cc_reg, const0_rtx, VOIDmode, 0, 1);
6688 return emit_store_flag_force (target, EQ, subtarget, old_val, VOIDmode, 1, 1);
6691 /* This is a helper function for the other atomic operations. This function
6692 emits a loop that contains SEQ that iterates until a compare-and-swap
6693 operation at the end succeeds. MEM is the memory to be modified. SEQ is
6694 a set of instructions that takes a value from OLD_REG as an input and
6695 produces a value in NEW_REG as an output. Before SEQ, OLD_REG will be
6696 set to the current contents of MEM. After SEQ, a compare-and-swap will
6697 attempt to update MEM with NEW_REG. The function returns true when the
6698 loop was generated successfully. */
6701 expand_compare_and_swap_loop (rtx mem, rtx old_reg, rtx new_reg, rtx seq)
6703 enum machine_mode mode = GET_MODE (mem);
6704 enum insn_code icode;
6705 rtx label, cmp_reg, subtarget, cc_reg;
6707 /* The loop we want to generate looks like
6713 cmp_reg = compare-and-swap(mem, old_reg, new_reg)
6714 if (cmp_reg != old_reg)
6717 Note that we only do the plain load from memory once. Subsequent
6718 iterations use the value loaded by the compare-and-swap pattern. */
6720 label = gen_label_rtx ();
6721 cmp_reg = gen_reg_rtx (mode);
6723 emit_move_insn (cmp_reg, mem);
6725 emit_move_insn (old_reg, cmp_reg);
6729 /* If the target supports a compare-and-swap pattern that simultaneously
6730 sets some flag for success, then use it. Otherwise use the regular
6731 compare-and-swap and follow that immediately with a compare insn. */
6732 icode = direct_optab_handler (sync_compare_and_swap_optab, mode);
6733 if (icode == CODE_FOR_nothing)
6736 subtarget = expand_val_compare_and_swap_1 (mem, old_reg, new_reg,
6738 if (subtarget == NULL_RTX)
6742 if (have_insn_for (COMPARE, CCmode))
6743 note_stores (PATTERN (get_last_insn ()), find_cc_set, &cc_reg);
6747 old_reg = const0_rtx;
6751 if (subtarget != cmp_reg)
6752 emit_move_insn (cmp_reg, subtarget);
6755 /* ??? Mark this jump predicted not taken? */
6756 emit_cmp_and_jump_insns (cmp_reg, old_reg, NE, const0_rtx, GET_MODE (cmp_reg), 1,
6761 /* This function generates the atomic operation MEM CODE= VAL. In this
6762 case, we do not care about any resulting value. Returns NULL if we
6763 cannot generate the operation. */
6766 expand_sync_operation (rtx mem, rtx val, enum rtx_code code)
6768 enum machine_mode mode = GET_MODE (mem);
6769 enum insn_code icode;
6772 /* Look to see if the target supports the operation directly. */
6776 icode = direct_optab_handler (sync_add_optab, mode);
6779 icode = direct_optab_handler (sync_ior_optab, mode);
6782 icode = direct_optab_handler (sync_xor_optab, mode);
6785 icode = direct_optab_handler (sync_and_optab, mode);
6788 icode = direct_optab_handler (sync_nand_optab, mode);
6792 icode = direct_optab_handler (sync_sub_optab, mode);
6793 if (icode == CODE_FOR_nothing || CONST_INT_P (val))
6795 icode = direct_optab_handler (sync_add_optab, mode);
6796 if (icode != CODE_FOR_nothing)
6798 val = expand_simple_unop (mode, NEG, val, NULL_RTX, 1);
6808 /* Generate the direct operation, if present. */
6809 if (icode != CODE_FOR_nothing)
6811 struct expand_operand ops[2];
6813 create_fixed_operand (&ops[0], mem);
6814 /* VAL may have been promoted to a wider mode. Shrink it if so. */
6815 create_convert_operand_to (&ops[1], val, mode, true);
6816 if (maybe_expand_insn (icode, 2, ops))
6820 /* Failing that, generate a compare-and-swap loop in which we perform the
6821 operation with normal arithmetic instructions. */
6822 if (direct_optab_handler (sync_compare_and_swap_optab, mode)
6823 != CODE_FOR_nothing)
6825 rtx t0 = gen_reg_rtx (mode), t1;
6832 t1 = expand_simple_binop (mode, AND, t1, val, NULL_RTX,
6833 true, OPTAB_LIB_WIDEN);
6834 t1 = expand_simple_unop (mode, code, t1, NULL_RTX, true);
6837 t1 = expand_simple_binop (mode, code, t1, val, NULL_RTX,
6838 true, OPTAB_LIB_WIDEN);
6839 insn = get_insns ();
6842 if (t1 != NULL && expand_compare_and_swap_loop (mem, t0, t1, insn))
6849 /* This function generates the atomic operation MEM CODE= VAL. In this
6850 case, we do care about the resulting value: if AFTER is true then
6851 return the value MEM holds after the operation, if AFTER is false
6852 then return the value MEM holds before the operation. TARGET is an
6853 optional place for the result value to be stored. */
6856 expand_sync_fetch_operation (rtx mem, rtx val, enum rtx_code code,
6857 bool after, rtx target)
6859 enum machine_mode mode = GET_MODE (mem);
6860 enum insn_code old_code, new_code, icode;
6864 /* Look to see if the target supports the operation directly. */
6868 old_code = direct_optab_handler (sync_old_add_optab, mode);
6869 new_code = direct_optab_handler (sync_new_add_optab, mode);
6872 old_code = direct_optab_handler (sync_old_ior_optab, mode);
6873 new_code = direct_optab_handler (sync_new_ior_optab, mode);
6876 old_code = direct_optab_handler (sync_old_xor_optab, mode);
6877 new_code = direct_optab_handler (sync_new_xor_optab, mode);
6880 old_code = direct_optab_handler (sync_old_and_optab, mode);
6881 new_code = direct_optab_handler (sync_new_and_optab, mode);
6884 old_code = direct_optab_handler (sync_old_nand_optab, mode);
6885 new_code = direct_optab_handler (sync_new_nand_optab, mode);
6889 old_code = direct_optab_handler (sync_old_sub_optab, mode);
6890 new_code = direct_optab_handler (sync_new_sub_optab, mode);
6891 if ((old_code == CODE_FOR_nothing && new_code == CODE_FOR_nothing)
6892 || CONST_INT_P (val))
6894 old_code = direct_optab_handler (sync_old_add_optab, mode);
6895 new_code = direct_optab_handler (sync_new_add_optab, mode);
6896 if (old_code != CODE_FOR_nothing || new_code != CODE_FOR_nothing)
6898 val = expand_simple_unop (mode, NEG, val, NULL_RTX, 1);
6908 /* If the target does supports the proper new/old operation, great. But
6909 if we only support the opposite old/new operation, check to see if we
6910 can compensate. In the case in which the old value is supported, then
6911 we can always perform the operation again with normal arithmetic. In
6912 the case in which the new value is supported, then we can only handle
6913 this in the case the operation is reversible. */
6918 if (icode == CODE_FOR_nothing)
6921 if (icode != CODE_FOR_nothing)
6928 if (icode == CODE_FOR_nothing
6929 && (code == PLUS || code == MINUS || code == XOR))
6932 if (icode != CODE_FOR_nothing)
6937 /* If we found something supported, great. */
6938 if (icode != CODE_FOR_nothing)
6940 struct expand_operand ops[3];
6942 create_output_operand (&ops[0], target, mode);
6943 create_fixed_operand (&ops[1], mem);
6944 /* VAL may have been promoted to a wider mode. Shrink it if so. */
6945 create_convert_operand_to (&ops[2], val, mode, true);
6946 if (maybe_expand_insn (icode, 3, ops))
6948 target = ops[0].value;
6950 /* If we need to compensate for using an operation with the
6951 wrong return value, do so now. */
6958 else if (code == MINUS)
6964 target = expand_simple_binop (mode, AND, target, val,
6967 target = expand_simple_unop (mode, code, target,
6971 target = expand_simple_binop (mode, code, target, val,
6980 /* Failing that, generate a compare-and-swap loop in which we perform the
6981 operation with normal arithmetic instructions. */
6982 if (direct_optab_handler (sync_compare_and_swap_optab, mode)
6983 != CODE_FOR_nothing)
6985 rtx t0 = gen_reg_rtx (mode), t1;
6987 if (!target || !register_operand (target, mode))
6988 target = gen_reg_rtx (mode);
6993 emit_move_insn (target, t0);
6997 t1 = expand_simple_binop (mode, AND, t1, val, NULL_RTX,
6998 true, OPTAB_LIB_WIDEN);
6999 t1 = expand_simple_unop (mode, code, t1, NULL_RTX, true);
7002 t1 = expand_simple_binop (mode, code, t1, val, NULL_RTX,
7003 true, OPTAB_LIB_WIDEN);
7005 emit_move_insn (target, t1);
7007 insn = get_insns ();
7010 if (t1 != NULL && expand_compare_and_swap_loop (mem, t0, t1, insn))
7017 /* This function expands a test-and-set operation. Ideally we atomically
7018 store VAL in MEM and return the previous value in MEM. Some targets
7019 may not support this operation and only support VAL with the constant 1;
7020 in this case while the return value will be 0/1, but the exact value
7021 stored in MEM is target defined. TARGET is an option place to stick
7022 the return value. */
7025 expand_sync_lock_test_and_set (rtx mem, rtx val, rtx target)
7027 enum machine_mode mode = GET_MODE (mem);
7028 enum insn_code icode;
7030 /* If the target supports the test-and-set directly, great. */
7031 icode = direct_optab_handler (sync_lock_test_and_set_optab, mode);
7032 if (icode != CODE_FOR_nothing)
7034 struct expand_operand ops[3];
7036 create_output_operand (&ops[0], target, mode);
7037 create_fixed_operand (&ops[1], mem);
7038 /* VAL may have been promoted to a wider mode. Shrink it if so. */
7039 create_convert_operand_to (&ops[2], val, mode, true);
7040 if (maybe_expand_insn (icode, 3, ops))
7041 return ops[0].value;
7044 /* Otherwise, use a compare-and-swap loop for the exchange. */
7045 if (direct_optab_handler (sync_compare_and_swap_optab, mode)
7046 != CODE_FOR_nothing)
7048 if (!target || !register_operand (target, mode))
7049 target = gen_reg_rtx (mode);
7050 if (GET_MODE (val) != VOIDmode && GET_MODE (val) != mode)
7051 val = convert_modes (mode, GET_MODE (val), val, 1);
7052 if (expand_compare_and_swap_loop (mem, target, val, NULL_RTX))
7059 /* Return true if OPERAND is suitable for operand number OPNO of
7060 instruction ICODE. */
7063 insn_operand_matches (enum insn_code icode, unsigned int opno, rtx operand)
7065 return (!insn_data[(int) icode].operand[opno].predicate
7066 || (insn_data[(int) icode].operand[opno].predicate
7067 (operand, insn_data[(int) icode].operand[opno].mode)));
7070 /* TARGET is a target of a multiword operation that we are going to
7071 implement as a series of word-mode operations. Return true if
7072 TARGET is suitable for this purpose. */
7075 valid_multiword_target_p (rtx target)
7077 enum machine_mode mode;
7080 mode = GET_MODE (target);
7081 for (i = 0; i < GET_MODE_SIZE (mode); i += UNITS_PER_WORD)
7082 if (!validate_subreg (word_mode, mode, target, i))
7087 /* Like maybe_legitimize_operand, but do not change the code of the
7088 current rtx value. */
7091 maybe_legitimize_operand_same_code (enum insn_code icode, unsigned int opno,
7092 struct expand_operand *op)
7094 /* See if the operand matches in its current form. */
7095 if (insn_operand_matches (icode, opno, op->value))
7098 /* If the operand is a memory whose address has no side effects,
7099 try forcing the address into a register. The check for side
7100 effects is important because force_reg cannot handle things
7101 like auto-modified addresses. */
7102 if (insn_data[(int) icode].operand[opno].allows_mem
7103 && MEM_P (op->value)
7104 && !side_effects_p (XEXP (op->value, 0)))
7106 rtx addr, mem, last;
7108 last = get_last_insn ();
7109 addr = force_reg (Pmode, XEXP (op->value, 0));
7110 mem = replace_equiv_address (op->value, addr);
7111 if (insn_operand_matches (icode, opno, mem))
7116 delete_insns_since (last);
7122 /* Try to make OP match operand OPNO of instruction ICODE. Return true
7123 on success, storing the new operand value back in OP. */
7126 maybe_legitimize_operand (enum insn_code icode, unsigned int opno,
7127 struct expand_operand *op)
7129 enum machine_mode mode, imode;
7130 bool old_volatile_ok, result;
7136 old_volatile_ok = volatile_ok;
7138 result = maybe_legitimize_operand_same_code (icode, opno, op);
7139 volatile_ok = old_volatile_ok;
7143 gcc_assert (mode != VOIDmode);
7145 && op->value != const0_rtx
7146 && GET_MODE (op->value) == mode
7147 && maybe_legitimize_operand_same_code (icode, opno, op))
7150 op->value = gen_reg_rtx (mode);
7155 gcc_assert (mode != VOIDmode);
7156 gcc_assert (GET_MODE (op->value) == VOIDmode
7157 || GET_MODE (op->value) == mode);
7158 if (maybe_legitimize_operand_same_code (icode, opno, op))
7161 op->value = copy_to_mode_reg (mode, op->value);
7164 case EXPAND_CONVERT_TO:
7165 gcc_assert (mode != VOIDmode);
7166 op->value = convert_to_mode (mode, op->value, op->unsigned_p);
7169 case EXPAND_CONVERT_FROM:
7170 if (GET_MODE (op->value) != VOIDmode)
7171 mode = GET_MODE (op->value);
7173 /* The caller must tell us what mode this value has. */
7174 gcc_assert (mode != VOIDmode);
7176 imode = insn_data[(int) icode].operand[opno].mode;
7177 if (imode != VOIDmode && imode != mode)
7179 op->value = convert_modes (imode, mode, op->value, op->unsigned_p);
7184 case EXPAND_ADDRESS:
7185 gcc_assert (mode != VOIDmode);
7186 op->value = convert_memory_address (mode, op->value);
7189 case EXPAND_INTEGER:
7190 mode = insn_data[(int) icode].operand[opno].mode;
7191 if (mode != VOIDmode && const_int_operand (op->value, mode))
7195 return insn_operand_matches (icode, opno, op->value);
7198 /* Make OP describe an input operand that should have the same value
7199 as VALUE, after any mode conversion that the target might request.
7200 TYPE is the type of VALUE. */
7203 create_convert_operand_from_type (struct expand_operand *op,
7204 rtx value, tree type)
7206 create_convert_operand_from (op, value, TYPE_MODE (type),
7207 TYPE_UNSIGNED (type));
7210 /* Try to make operands [OPS, OPS + NOPS) match operands [OPNO, OPNO + NOPS)
7211 of instruction ICODE. Return true on success, leaving the new operand
7212 values in the OPS themselves. Emit no code on failure. */
7215 maybe_legitimize_operands (enum insn_code icode, unsigned int opno,
7216 unsigned int nops, struct expand_operand *ops)
7221 last = get_last_insn ();
7222 for (i = 0; i < nops; i++)
7223 if (!maybe_legitimize_operand (icode, opno + i, &ops[i]))
7225 delete_insns_since (last);
7231 /* Try to generate instruction ICODE, using operands [OPS, OPS + NOPS)
7232 as its operands. Return the instruction pattern on success,
7233 and emit any necessary set-up code. Return null and emit no
7237 maybe_gen_insn (enum insn_code icode, unsigned int nops,
7238 struct expand_operand *ops)
7240 gcc_assert (nops == (unsigned int) insn_data[(int) icode].n_generator_args);
7241 if (!maybe_legitimize_operands (icode, 0, nops, ops))
7247 return GEN_FCN (icode) (ops[0].value);
7249 return GEN_FCN (icode) (ops[0].value, ops[1].value);
7251 return GEN_FCN (icode) (ops[0].value, ops[1].value, ops[2].value);
7253 return GEN_FCN (icode) (ops[0].value, ops[1].value, ops[2].value,
7256 return GEN_FCN (icode) (ops[0].value, ops[1].value, ops[2].value,
7257 ops[3].value, ops[4].value);
7259 return GEN_FCN (icode) (ops[0].value, ops[1].value, ops[2].value,
7260 ops[3].value, ops[4].value, ops[5].value);
7265 /* Try to emit instruction ICODE, using operands [OPS, OPS + NOPS)
7266 as its operands. Return true on success and emit no code on failure. */
7269 maybe_expand_insn (enum insn_code icode, unsigned int nops,
7270 struct expand_operand *ops)
7272 rtx pat = maybe_gen_insn (icode, nops, ops);
7281 /* Like maybe_expand_insn, but for jumps. */
7284 maybe_expand_jump_insn (enum insn_code icode, unsigned int nops,
7285 struct expand_operand *ops)
7287 rtx pat = maybe_gen_insn (icode, nops, ops);
7290 emit_jump_insn (pat);
7296 /* Emit instruction ICODE, using operands [OPS, OPS + NOPS)
7300 expand_insn (enum insn_code icode, unsigned int nops,
7301 struct expand_operand *ops)
7303 if (!maybe_expand_insn (icode, nops, ops))
7307 /* Like expand_insn, but for jumps. */
7310 expand_jump_insn (enum insn_code icode, unsigned int nops,
7311 struct expand_operand *ops)
7313 if (!maybe_expand_jump_insn (icode, nops, ops))
7317 #include "gt-optabs.h"