gcc/optabs.c

   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
   4    Free Software Foundation, Inc.
   5
   6 This file is part of GCC.
   7
   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
  11 version.
  12
  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
  16 for more details.
  17
  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/>.  */
  21
  22
  23 #include "config.h"
  24 #include "system.h"
  25 #include "coretypes.h"
  26 #include "tm.h"
  27 #include "toplev.h"
  28
  29 /* Include insn-config.h before expr.h so that HAVE_conditional_move
  30    is properly defined.  */
  31 #include "insn-config.h"
  32 #include "rtl.h"
  33 #include "tree.h"
  34 #include "tm_p.h"
  35 #include "flags.h"
  36 #include "function.h"
  37 #include "except.h"
  38 #include "expr.h"
  39 #include "optabs.h"
  40 #include "libfuncs.h"
  41 #include "recog.h"
  42 #include "reload.h"
  43 #include "ggc.h"
  44 #include "real.h"
  45 #include "basic-block.h"
  46 #include "target.h"
  47
  48 /* Each optab contains info on how this target machine
  49    can perform a particular operation
  50    for all sizes and kinds of operands.
  51
  52    The operation to be performed is often specified
  53    by passing one of these optabs as an argument.
  54
  55    See expr.h for documentation of these optabs.  */
  56
  57 #if GCC_VERSION >= 4000
  58 __extension__ struct optab optab_table[OTI_MAX]
  59   = { [0 ... OTI_MAX - 1].handlers[0 ... NUM_MACHINE_MODES - 1].insn_code
  60       = CODE_FOR_nothing };
  61 #else
  62 /* init_insn_codes will do runtime initialization otherwise.  */
  63 struct optab optab_table[OTI_MAX];
  64 #endif
  65
  66 rtx libfunc_table[LTI_MAX];
  67
  68 /* Tables of patterns for converting one mode to another.  */
  69 #if GCC_VERSION >= 4000
  70 __extension__ struct convert_optab convert_optab_table[COI_MAX]
  71   = { [0 ... COI_MAX - 1].handlers[0 ... NUM_MACHINE_MODES - 1]
  72         [0 ... NUM_MACHINE_MODES - 1].insn_code
  73       = CODE_FOR_nothing };
  74 #else
  75 /* init_convert_optab will do runtime initialization otherwise.  */
  76 struct convert_optab convert_optab_table[COI_MAX];
  77 #endif
  78
  79 /* Contains the optab used for each rtx code.  */
  80 optab code_to_optab[NUM_RTX_CODE + 1];
  81
  82 /* Indexed by the rtx-code for a conditional (eg. EQ, LT,...)
  83    gives the gen_function to make a branch to test that condition.  */
  84
  85 rtxfun bcc_gen_fctn[NUM_RTX_CODE];
  86
  87 /* Indexed by the rtx-code for a conditional (eg. EQ, LT,...)
  88    gives the insn code to make a store-condition insn
  89    to test that condition.  */
  90
  91 enum insn_code setcc_gen_code[NUM_RTX_CODE];
  92
  93 #ifdef HAVE_conditional_move
  94 /* Indexed by the machine mode, gives the insn code to make a conditional
  95    move insn.  This is not indexed by the rtx-code like bcc_gen_fctn and
  96    setcc_gen_code to cut down on the number of named patterns.  Consider a day
  97    when a lot more rtx codes are conditional (eg: for the ARM).  */
  98
  99 enum insn_code movcc_gen_code[NUM_MACHINE_MODES];
 100 #endif
 101
 102 /* Indexed by the machine mode, gives the insn code for vector conditional
 103    operation.  */
 104
 105 enum insn_code vcond_gen_code[NUM_MACHINE_MODES];
 106 enum insn_code vcondu_gen_code[NUM_MACHINE_MODES];
 107
 108 /* The insn generating function can not take an rtx_code argument.
 109    TRAP_RTX is used as an rtx argument.  Its code is replaced with
 110    the code to be used in the trap insn and all other fields are ignored.  */
 111 static GTY(()) rtx trap_rtx;
 112
 113 static void prepare_float_lib_cmp (rtx *, rtx *, enum rtx_code *,
 114                                    enum machine_mode *, int *);
 115 static rtx expand_unop_direct (enum machine_mode, optab, rtx, rtx, int);
 116
 117 /* Debug facility for use in GDB.  */
 118 void debug_optab_libfuncs (void);
 119
 120 #ifndef HAVE_conditional_trap
 121 #define HAVE_conditional_trap 0
 122 #define gen_conditional_trap(a,b) (gcc_unreachable (), NULL_RTX)
 123 #endif
 124
 125 /* Prefixes for the current version of decimal floating point (BID vs. DPD) */
 126 #if ENABLE_DECIMAL_BID_FORMAT
 127 #define DECIMAL_PREFIX "bid_"
 128 #else
 129 #define DECIMAL_PREFIX "dpd_"
 130 #endif
 131 \f
 132
 133 /* Info about libfunc.  We use same hashtable for normal optabs and conversion
 134    optab.  In the first case mode2 is unused.  */
 135 struct libfunc_entry GTY(())
 136 {
 137   size_t optab;
 138   enum machine_mode mode1, mode2;
 139   rtx libfunc;
 140 };
 141
 142 /* Hash table used to convert declarations into nodes.  */
 143 static GTY((param_is (struct libfunc_entry))) htab_t libfunc_hash;
 144
 145 /* Used for attribute_hash.  */
 146
 147 static hashval_t
 148 hash_libfunc (const void *p)
 149 {
 150   const struct libfunc_entry *const e = (const struct libfunc_entry *) p;
 151
 152   return (((int) e->mode1 + (int) e->mode2 * NUM_MACHINE_MODES)
 153           ^ e->optab);
 154 }
 155
 156 /* Used for optab_hash.  */
 157
 158 static int
 159 eq_libfunc (const void *p, const void *q)
 160 {
 161   const struct libfunc_entry *const e1 = (const struct libfunc_entry *) p;
 162   const struct libfunc_entry *const e2 = (const struct libfunc_entry *) q;
 163
 164   return (e1->optab == e2->optab
 165           && e1->mode1 == e2->mode1
 166           && e1->mode2 == e2->mode2);
 167 }
 168
 169 /* Return libfunc corresponding operation defined by OPTAB converting
 170    from MODE2 to MODE1.  Trigger lazy initialization if needed, return NULL
 171    if no libfunc is available.  */
 172 rtx
 173 convert_optab_libfunc (convert_optab optab, enum machine_mode mode1,
 174                        enum machine_mode mode2)
 175 {
 176   struct libfunc_entry e;
 177   struct libfunc_entry **slot;
 178
 179   e.optab = (size_t) (optab - &convert_optab_table[0]);
 180   e.mode1 = mode1;
 181   e.mode2 = mode2;
 182   slot = (struct libfunc_entry **) htab_find_slot (libfunc_hash, &e, NO_INSERT);
 183   if (!slot)
 184     {
 185       if (optab->libcall_gen)
 186         {
 187           optab->libcall_gen (optab, optab->libcall_basename, mode1, mode2);
 188           slot = (struct libfunc_entry **) htab_find_slot (libfunc_hash, &e, NO_INSERT);
 189           if (slot)
 190             return (*slot)->libfunc;
 191           else
 192             return NULL;
 193         }
 194       return NULL;
 195     }
 196   return (*slot)->libfunc;
 197 }
 198
 199 /* Return libfunc corresponding operation defined by OPTAB in MODE.
 200    Trigger lazy initialization if needed, return NULL if no libfunc is
 201    available.  */
 202 rtx
 203 optab_libfunc (optab optab, enum machine_mode mode)
 204 {
 205   struct libfunc_entry e;
 206   struct libfunc_entry **slot;
 207
 208   e.optab = (size_t) (optab - &optab_table[0]);
 209   e.mode1 = mode;
 210   e.mode2 = VOIDmode;
 211   slot = (struct libfunc_entry **) htab_find_slot (libfunc_hash, &e, NO_INSERT);
 212   if (!slot)
 213     {
 214       if (optab->libcall_gen)
 215         {
 216           optab->libcall_gen (optab, optab->libcall_basename,
 217                               optab->libcall_suffix, mode);
 218           slot = (struct libfunc_entry **) htab_find_slot (libfunc_hash,
 219                                                            &e, NO_INSERT);
 220           if (slot)
 221             return (*slot)->libfunc;
 222           else
 223             return NULL;
 224         }
 225       return NULL;
 226     }
 227   return (*slot)->libfunc;
 228 }
 229
 230 \f
 231 /* Add a REG_EQUAL note to the last insn in INSNS.  TARGET is being set to
 232    the result of operation CODE applied to OP0 (and OP1 if it is a binary
 233    operation).
 234
 235    If the last insn does not set TARGET, don't do anything, but return 1.
 236
 237    If a previous insn sets TARGET and TARGET is one of OP0 or OP1,
 238    don't add the REG_EQUAL note but return 0.  Our caller can then try
 239    again, ensuring that TARGET is not one of the operands.  */
 240
 241 static int
 242 add_equal_note (rtx insns, rtx target, enum rtx_code code, rtx op0, rtx op1)
 243 {
 244   rtx last_insn, insn, set;
 245   rtx note;
 246
 247   gcc_assert (insns && INSN_P (insns) && NEXT_INSN (insns));
 248
 249   if (GET_RTX_CLASS (code) != RTX_COMM_ARITH
 250       && GET_RTX_CLASS (code) != RTX_BIN_ARITH
 251       && GET_RTX_CLASS (code) != RTX_COMM_COMPARE
 252       && GET_RTX_CLASS (code) != RTX_COMPARE
 253       && GET_RTX_CLASS (code) != RTX_UNARY)
 254     return 1;
 255
 256   if (GET_CODE (target) == ZERO_EXTRACT)
 257     return 1;
 258
 259   for (last_insn = insns;
 260        NEXT_INSN (last_insn) != NULL_RTX;
 261        last_insn = NEXT_INSN (last_insn))
 262     ;
 263
 264   set = single_set (last_insn);
 265   if (set == NULL_RTX)
 266     return 1;
 267
 268   if (! rtx_equal_p (SET_DEST (set), target)
 269       /* For a STRICT_LOW_PART, the REG_NOTE applies to what is inside it.  */
 270       && (GET_CODE (SET_DEST (set)) != STRICT_LOW_PART
 271           || ! rtx_equal_p (XEXP (SET_DEST (set), 0), target)))
 272     return 1;
 273
 274   /* If TARGET is in OP0 or OP1, check if anything in SEQ sets TARGET
 275      besides the last insn.  */
 276   if (reg_overlap_mentioned_p (target, op0)
 277       || (op1 && reg_overlap_mentioned_p (target, op1)))
 278     {
 279       insn = PREV_INSN (last_insn);
 280       while (insn != NULL_RTX)
 281         {
 282           if (reg_set_p (target, insn))
 283             return 0;
 284
 285           insn = PREV_INSN (insn);
 286         }
 287     }
 288
 289   if (GET_RTX_CLASS (code) == RTX_UNARY)
 290     note = gen_rtx_fmt_e (code, GET_MODE (target), copy_rtx (op0));
 291   else
 292     note = gen_rtx_fmt_ee (code, GET_MODE (target), copy_rtx (op0), copy_rtx (op1));
 293
 294   set_unique_reg_note (last_insn, REG_EQUAL, note);
 295
 296   return 1;
 297 }
 298 \f
 299 /* Widen OP to MODE and return the rtx for the widened operand.  UNSIGNEDP
 300    says whether OP is signed or unsigned.  NO_EXTEND is nonzero if we need
 301    not actually do a sign-extend or zero-extend, but can leave the
 302    higher-order bits of the result rtx undefined, for example, in the case
 303    of logical operations, but not right shifts.  */
 304
 305 static rtx
 306 widen_operand (rtx op, enum machine_mode mode, enum machine_mode oldmode,
 307                int unsignedp, int no_extend)
 308 {
 309   rtx result;
 310
 311   /* If we don't have to extend and this is a constant, return it.  */
 312   if (no_extend && GET_MODE (op) == VOIDmode)
 313     return op;
 314
 315   /* If we must extend do so.  If OP is a SUBREG for a promoted object, also
 316      extend since it will be more efficient to do so unless the signedness of
 317      a promoted object differs from our extension.  */
 318   if (! no_extend
 319       || (GET_CODE (op) == SUBREG && SUBREG_PROMOTED_VAR_P (op)
 320           && SUBREG_PROMOTED_UNSIGNED_P (op) == unsignedp))
 321     return convert_modes (mode, oldmode, op, unsignedp);
 322
 323   /* If MODE is no wider than a single word, we return a paradoxical
 324      SUBREG.  */
 325   if (GET_MODE_SIZE (mode) <= UNITS_PER_WORD)
 326     return gen_rtx_SUBREG (mode, force_reg (GET_MODE (op), op), 0);
 327
 328   /* Otherwise, get an object of MODE, clobber it, and set the low-order
 329      part to OP.  */
 330
 331   result = gen_reg_rtx (mode);
 332   emit_clobber (result);
 333   emit_move_insn (gen_lowpart (GET_MODE (op), result), op);
 334   return result;
 335 }
 336 \f
 337 /* Return the optab used for computing the operation given by the tree code,
 338    CODE and the tree EXP.  This function is not always usable (for example, it
 339    cannot give complete results for multiplication or division) but probably
 340    ought to be relied on more widely throughout the expander.  */
 341 optab
 342 optab_for_tree_code (enum tree_code code, const_tree type,
 343                      enum optab_subtype subtype)
 344 {
 345   bool trapv;
 346   switch (code)
 347     {
 348     case BIT_AND_EXPR:
 349       return and_optab;
 350
 351     case BIT_IOR_EXPR:
 352       return ior_optab;
 353
 354     case BIT_NOT_EXPR:
 355       return one_cmpl_optab;
 356
 357     case BIT_XOR_EXPR:
 358       return xor_optab;
 359
 360     case TRUNC_MOD_EXPR:
 361     case CEIL_MOD_EXPR:
 362     case FLOOR_MOD_EXPR:
 363     case ROUND_MOD_EXPR:
 364       return TYPE_UNSIGNED (type) ? umod_optab : smod_optab;
 365
 366     case RDIV_EXPR:
 367     case TRUNC_DIV_EXPR:
 368     case CEIL_DIV_EXPR:
 369     case FLOOR_DIV_EXPR:
 370     case ROUND_DIV_EXPR:
 371     case EXACT_DIV_EXPR:
 372       if (TYPE_SATURATING(type))
 373         return TYPE_UNSIGNED(type) ? usdiv_optab : ssdiv_optab;
 374       return TYPE_UNSIGNED (type) ? udiv_optab : sdiv_optab;
 375
 376     case LSHIFT_EXPR:
 377       if (VECTOR_MODE_P (TYPE_MODE (type)))
 378         {
 379           if (subtype == optab_vector)
 380             return TYPE_SATURATING (type) ? NULL : vashl_optab;
 381
 382           gcc_assert (subtype == optab_scalar);
 383         }
 384       if (TYPE_SATURATING(type))
 385         return TYPE_UNSIGNED(type) ? usashl_optab : ssashl_optab;
 386       return ashl_optab;
 387
 388     case RSHIFT_EXPR:
 389       if (VECTOR_MODE_P (TYPE_MODE (type)))
 390         {
 391           if (subtype == optab_vector)
 392             return TYPE_UNSIGNED (type) ? vlshr_optab : vashr_optab;
 393
 394           gcc_assert (subtype == optab_scalar);
 395         }
 396       return TYPE_UNSIGNED (type) ? lshr_optab : ashr_optab;
 397
 398     case LROTATE_EXPR:
 399       if (VECTOR_MODE_P (TYPE_MODE (type)))
 400         {
 401           if (subtype == optab_vector)
 402             return vrotl_optab;
 403
 404           gcc_assert (subtype == optab_scalar);
 405         }
 406       return rotl_optab;
 407
 408     case RROTATE_EXPR:
 409       if (VECTOR_MODE_P (TYPE_MODE (type)))
 410         {
 411           if (subtype == optab_vector)
 412             return vrotr_optab;
 413
 414           gcc_assert (subtype == optab_scalar);
 415         }
 416       return rotr_optab;
 417
 418     case MAX_EXPR:
 419       return TYPE_UNSIGNED (type) ? umax_optab : smax_optab;
 420
 421     case MIN_EXPR:
 422       return TYPE_UNSIGNED (type) ? umin_optab : smin_optab;
 423
 424     case REALIGN_LOAD_EXPR:
 425       return vec_realign_load_optab;
 426
 427     case WIDEN_SUM_EXPR:
 428       return TYPE_UNSIGNED (type) ? usum_widen_optab : ssum_widen_optab;
 429
 430     case DOT_PROD_EXPR:
 431       return TYPE_UNSIGNED (type) ? udot_prod_optab : sdot_prod_optab;
 432
 433     case REDUC_MAX_EXPR:
 434       return TYPE_UNSIGNED (type) ? reduc_umax_optab : reduc_smax_optab;
 435
 436     case REDUC_MIN_EXPR:
 437       return TYPE_UNSIGNED (type) ? reduc_umin_optab : reduc_smin_optab;
 438
 439     case REDUC_PLUS_EXPR:
 440       return TYPE_UNSIGNED (type) ? reduc_uplus_optab : reduc_splus_optab;
 441
 442     case VEC_LSHIFT_EXPR:
 443       return vec_shl_optab;
 444
 445     case VEC_RSHIFT_EXPR:
 446       return vec_shr_optab;
 447
 448     case VEC_WIDEN_MULT_HI_EXPR:
 449       return TYPE_UNSIGNED (type) ?
 450         vec_widen_umult_hi_optab : vec_widen_smult_hi_optab;
 451
 452     case VEC_WIDEN_MULT_LO_EXPR:
 453       return TYPE_UNSIGNED (type) ?
 454         vec_widen_umult_lo_optab : vec_widen_smult_lo_optab;
 455
 456     case VEC_UNPACK_HI_EXPR:
 457       return TYPE_UNSIGNED (type) ?
 458         vec_unpacku_hi_optab : vec_unpacks_hi_optab;
 459
 460     case VEC_UNPACK_LO_EXPR:
 461       return TYPE_UNSIGNED (type) ?
 462         vec_unpacku_lo_optab : vec_unpacks_lo_optab;
 463
 464     case VEC_UNPACK_FLOAT_HI_EXPR:
 465       /* The signedness is determined from input operand.  */
 466       return TYPE_UNSIGNED (type) ?
 467         vec_unpacku_float_hi_optab : vec_unpacks_float_hi_optab;
 468
 469     case VEC_UNPACK_FLOAT_LO_EXPR:
 470       /* The signedness is determined from input operand.  */
 471       return TYPE_UNSIGNED (type) ?
 472         vec_unpacku_float_lo_optab : vec_unpacks_float_lo_optab;
 473
 474     case VEC_PACK_TRUNC_EXPR:
 475       return vec_pack_trunc_optab;
 476
 477     case VEC_PACK_SAT_EXPR:
 478       return TYPE_UNSIGNED (type) ? vec_pack_usat_optab : vec_pack_ssat_optab;
 479
 480     case VEC_PACK_FIX_TRUNC_EXPR:
 481       /* The signedness is determined from output operand.  */
 482       return TYPE_UNSIGNED (type) ?
 483         vec_pack_ufix_trunc_optab : vec_pack_sfix_trunc_optab;
 484
 485     default:
 486       break;
 487     }
 488
 489   trapv = INTEGRAL_TYPE_P (type) && TYPE_OVERFLOW_TRAPS (type);
 490   switch (code)
 491     {
 492     case POINTER_PLUS_EXPR:
 493     case PLUS_EXPR:
 494       if (TYPE_SATURATING(type))
 495         return TYPE_UNSIGNED(type) ? usadd_optab : ssadd_optab;
 496       return trapv ? addv_optab : add_optab;
 497
 498     case MINUS_EXPR:
 499       if (TYPE_SATURATING(type))
 500         return TYPE_UNSIGNED(type) ? ussub_optab : sssub_optab;
 501       return trapv ? subv_optab : sub_optab;
 502
 503     case MULT_EXPR:
 504       if (TYPE_SATURATING(type))
 505         return TYPE_UNSIGNED(type) ? usmul_optab : ssmul_optab;
 506       return trapv ? smulv_optab : smul_optab;
 507
 508     case NEGATE_EXPR:
 509       if (TYPE_SATURATING(type))
 510         return TYPE_UNSIGNED(type) ? usneg_optab : ssneg_optab;
 511       return trapv ? negv_optab : neg_optab;
 512
 513     case ABS_EXPR:
 514       return trapv ? absv_optab : abs_optab;
 515
 516     case VEC_EXTRACT_EVEN_EXPR:
 517       return vec_extract_even_optab;
 518
 519     case VEC_EXTRACT_ODD_EXPR:
 520       return vec_extract_odd_optab;
 521
 522     case VEC_INTERLEAVE_HIGH_EXPR:
 523       return vec_interleave_high_optab;
 524
 525     case VEC_INTERLEAVE_LOW_EXPR:
 526       return vec_interleave_low_optab;
 527
 528     default:
 529       return NULL;
 530     }
 531 }
 532 \f
 533
 534 /* Expand vector widening operations.
 535
 536    There are two different classes of operations handled here:
 537    1) Operations whose result is wider than all the arguments to the operation.
 538       Examples: VEC_UNPACK_HI/LO_EXPR, VEC_WIDEN_MULT_HI/LO_EXPR
 539       In this case OP0 and optionally OP1 would be initialized,
 540       but WIDE_OP wouldn't (not relevant for this case).
 541    2) Operations whose result is of the same size as the last argument to the
 542       operation, but wider than all the other arguments to the operation.
 543       Examples: WIDEN_SUM_EXPR, VEC_DOT_PROD_EXPR.
 544       In the case WIDE_OP, OP0 and optionally OP1 would be initialized.
 545
 546    E.g, when called to expand the following operations, this is how
 547    the arguments will be initialized:
 548                                 nops    OP0     OP1     WIDE_OP
 549    widening-sum                 2       oprnd0  -       oprnd1
 550    widening-dot-product         3       oprnd0  oprnd1  oprnd2
 551    widening-mult                2       oprnd0  oprnd1  -
 552    type-promotion (vec-unpack)  1       oprnd0  -       -  */
 553
 554 rtx
 555 expand_widen_pattern_expr (tree exp, rtx op0, rtx op1, rtx wide_op, rtx target,
 556                            int unsignedp)
 557 {
 558   tree oprnd0, oprnd1, oprnd2;
 559   enum machine_mode wmode = 0, tmode0, tmode1 = 0;
 560   optab widen_pattern_optab;
 561   int icode;
 562   enum machine_mode xmode0, xmode1 = 0, wxmode = 0;
 563   rtx temp;
 564   rtx pat;
 565   rtx xop0, xop1, wxop;
 566   int nops = TREE_OPERAND_LENGTH (exp);
 567
 568   oprnd0 = TREE_OPERAND (exp, 0);
 569   tmode0 = TYPE_MODE (TREE_TYPE (oprnd0));
 570   widen_pattern_optab =
 571     optab_for_tree_code (TREE_CODE (exp), TREE_TYPE (oprnd0), optab_default);
 572   icode = (int) optab_handler (widen_pattern_optab, tmode0)->insn_code;
 573   gcc_assert (icode != CODE_FOR_nothing);
 574   xmode0 = insn_data[icode].operand[1].mode;
 575
 576   if (nops >= 2)
 577     {
 578       oprnd1 = TREE_OPERAND (exp, 1);
 579       tmode1 = TYPE_MODE (TREE_TYPE (oprnd1));
 580       xmode1 = insn_data[icode].operand[2].mode;
 581     }
 582
 583   /* The last operand is of a wider mode than the rest of the operands.  */
 584   if (nops == 2)
 585     {
 586       wmode = tmode1;
 587       wxmode = xmode1;
 588     }
 589   else if (nops == 3)
 590     {
 591       gcc_assert (tmode1 == tmode0);
 592       gcc_assert (op1);
 593       oprnd2 = TREE_OPERAND (exp, 2);
 594       wmode = TYPE_MODE (TREE_TYPE (oprnd2));
 595       wxmode = insn_data[icode].operand[3].mode;
 596     }
 597
 598   if (!wide_op)
 599     wmode = wxmode = insn_data[icode].operand[0].mode;
 600
 601   if (!target
 602       || ! (*insn_data[icode].operand[0].predicate) (target, wmode))
 603     temp = gen_reg_rtx (wmode);
 604   else
 605     temp = target;
 606
 607   xop0 = op0;
 608   xop1 = op1;
 609   wxop = wide_op;
 610
 611   /* In case the insn wants input operands in modes different from
 612      those of the actual operands, convert the operands.  It would
 613      seem that we don't need to convert CONST_INTs, but we do, so
 614      that they're properly zero-extended, sign-extended or truncated
 615      for their mode.  */
 616
 617   if (GET_MODE (op0) != xmode0 && xmode0 != VOIDmode)
 618     xop0 = convert_modes (xmode0,
 619                           GET_MODE (op0) != VOIDmode
 620                           ? GET_MODE (op0)
 621                           : tmode0,
 622                           xop0, unsignedp);
 623
 624   if (op1)
 625     if (GET_MODE (op1) != xmode1 && xmode1 != VOIDmode)
 626       xop1 = convert_modes (xmode1,
 627                             GET_MODE (op1) != VOIDmode
 628                             ? GET_MODE (op1)
 629                             : tmode1,
 630                             xop1, unsignedp);
 631
 632   if (wide_op)
 633     if (GET_MODE (wide_op) != wxmode && wxmode != VOIDmode)
 634       wxop = convert_modes (wxmode,
 635                             GET_MODE (wide_op) != VOIDmode
 636                             ? GET_MODE (wide_op)
 637                             : wmode,
 638                             wxop, unsignedp);
 639
 640   /* Now, if insn's predicates don't allow our operands, put them into
 641      pseudo regs.  */
 642
 643   if (! (*insn_data[icode].operand[1].predicate) (xop0, xmode0)
 644       && xmode0 != VOIDmode)
 645     xop0 = copy_to_mode_reg (xmode0, xop0);
 646
 647   if (op1)
 648     {
 649       if (! (*insn_data[icode].operand[2].predicate) (xop1, xmode1)
 650           && xmode1 != VOIDmode)
 651         xop1 = copy_to_mode_reg (xmode1, xop1);
 652
 653       if (wide_op)
 654         {
 655           if (! (*insn_data[icode].operand[3].predicate) (wxop, wxmode)
 656               && wxmode != VOIDmode)
 657             wxop = copy_to_mode_reg (wxmode, wxop);
 658
 659           pat = GEN_FCN (icode) (temp, xop0, xop1, wxop);
 660         }
 661       else
 662         pat = GEN_FCN (icode) (temp, xop0, xop1);
 663     }
 664   else
 665     {
 666       if (wide_op)
 667         {
 668           if (! (*insn_data[icode].operand[2].predicate) (wxop, wxmode)
 669               && wxmode != VOIDmode)
 670             wxop = copy_to_mode_reg (wxmode, wxop);
 671
 672           pat = GEN_FCN (icode) (temp, xop0, wxop);
 673         }
 674       else
 675         pat = GEN_FCN (icode) (temp, xop0);
 676     }
 677
 678   emit_insn (pat);
 679   return temp;
 680 }
 681
 682 /* Generate code to perform an operation specified by TERNARY_OPTAB
 683    on operands OP0, OP1 and OP2, with result having machine-mode MODE.
 684
 685    UNSIGNEDP is for the case where we have to widen the operands
 686    to perform the operation.  It says to use zero-extension.
 687
 688    If TARGET is nonzero, the value
 689    is generated there, if it is convenient to do so.
 690    In all cases an rtx is returned for the locus of the value;
 691    this may or may not be TARGET.  */
 692
 693 rtx
 694 expand_ternary_op (enum machine_mode mode, optab ternary_optab, rtx op0,
 695                    rtx op1, rtx op2, rtx target, int unsignedp)
 696 {
 697   int icode = (int) optab_handler (ternary_optab, mode)->insn_code;
 698   enum machine_mode mode0 = insn_data[icode].operand[1].mode;
 699   enum machine_mode mode1 = insn_data[icode].operand[2].mode;
 700   enum machine_mode mode2 = insn_data[icode].operand[3].mode;
 701   rtx temp;
 702   rtx pat;
 703   rtx xop0 = op0, xop1 = op1, xop2 = op2;
 704
 705   gcc_assert (optab_handler (ternary_optab, mode)->insn_code
 706               != CODE_FOR_nothing);
 707
 708   if (!target || !insn_data[icode].operand[0].predicate (target, mode))
 709     temp = gen_reg_rtx (mode);
 710   else
 711     temp = target;
 712
 713   /* In case the insn wants input operands in modes different from
 714      those of the actual operands, convert the operands.  It would
 715      seem that we don't need to convert CONST_INTs, but we do, so
 716      that they're properly zero-extended, sign-extended or truncated
 717      for their mode.  */
 718
 719   if (GET_MODE (op0) != mode0 && mode0 != VOIDmode)
 720     xop0 = convert_modes (mode0,
 721                           GET_MODE (op0) != VOIDmode
 722                           ? GET_MODE (op0)
 723                           : mode,
 724                           xop0, unsignedp);
 725
 726   if (GET_MODE (op1) != mode1 && mode1 != VOIDmode)
 727     xop1 = convert_modes (mode1,
 728                           GET_MODE (op1) != VOIDmode
 729                           ? GET_MODE (op1)
 730                           : mode,
 731                           xop1, unsignedp);
 732
 733   if (GET_MODE (op2) != mode2 && mode2 != VOIDmode)
 734     xop2 = convert_modes (mode2,
 735                           GET_MODE (op2) != VOIDmode
 736                           ? GET_MODE (op2)
 737                           : mode,
 738                           xop2, unsignedp);
 739
 740   /* Now, if insn's predicates don't allow our operands, put them into
 741      pseudo regs.  */
 742
 743   if (!insn_data[icode].operand[1].predicate (xop0, mode0)
 744       && mode0 != VOIDmode)
 745     xop0 = copy_to_mode_reg (mode0, xop0);
 746
 747   if (!insn_data[icode].operand[2].predicate (xop1, mode1)
 748       && mode1 != VOIDmode)
 749     xop1 = copy_to_mode_reg (mode1, xop1);
 750
 751   if (!insn_data[icode].operand[3].predicate (xop2, mode2)
 752       && mode2 != VOIDmode)
 753     xop2 = copy_to_mode_reg (mode2, xop2);
 754
 755   pat = GEN_FCN (icode) (temp, xop0, xop1, xop2);
 756
 757   emit_insn (pat);
 758   return temp;
 759 }
 760
 761
 762 /* Like expand_binop, but return a constant rtx if the result can be
 763    calculated at compile time.  The arguments and return value are
 764    otherwise the same as for expand_binop.  */
 765
 766 static rtx
 767 simplify_expand_binop (enum machine_mode mode, optab binoptab,
 768                        rtx op0, rtx op1, rtx target, int unsignedp,
 769                        enum optab_methods methods)
 770 {
 771   if (CONSTANT_P (op0) && CONSTANT_P (op1))
 772     {
 773       rtx x = simplify_binary_operation (binoptab->code, mode, op0, op1);
 774
 775       if (x)
 776         return x;
 777     }
 778
 779   return expand_binop (mode, binoptab, op0, op1, target, unsignedp, methods);
 780 }
 781
 782 /* Like simplify_expand_binop, but always put the result in TARGET.
 783    Return true if the expansion succeeded.  */
 784
 785 bool
 786 force_expand_binop (enum machine_mode mode, optab binoptab,
 787                     rtx op0, rtx op1, rtx target, int unsignedp,
 788                     enum optab_methods methods)
 789 {
 790   rtx x = simplify_expand_binop (mode, binoptab, op0, op1,
 791                                  target, unsignedp, methods);
 792   if (x == 0)
 793     return false;
 794   if (x != target)
 795     emit_move_insn (target, x);
 796   return true;
 797 }
 798
 799 /* Generate insns for VEC_LSHIFT_EXPR, VEC_RSHIFT_EXPR.  */
 800
 801 rtx
 802 expand_vec_shift_expr (tree vec_shift_expr, rtx target)
 803 {
 804   enum insn_code icode;
 805   rtx rtx_op1, rtx_op2;
 806   enum machine_mode mode1;
 807   enum machine_mode mode2;
 808   enum machine_mode mode = TYPE_MODE (TREE_TYPE (vec_shift_expr));
 809   tree vec_oprnd = TREE_OPERAND (vec_shift_expr, 0);
 810   tree shift_oprnd = TREE_OPERAND (vec_shift_expr, 1);
 811   optab shift_optab;
 812   rtx pat;
 813
 814   switch (TREE_CODE (vec_shift_expr))
 815     {
 816       case VEC_RSHIFT_EXPR:
 817         shift_optab = vec_shr_optab;
 818         break;
 819       case VEC_LSHIFT_EXPR:
 820         shift_optab = vec_shl_optab;
 821         break;
 822       default:
 823         gcc_unreachable ();
 824     }
 825
 826   icode = (int) optab_handler (shift_optab, mode)->insn_code;
 827   gcc_assert (icode != CODE_FOR_nothing);
 828
 829   mode1 = insn_data[icode].operand[1].mode;
 830   mode2 = insn_data[icode].operand[2].mode;
 831
 832   rtx_op1 = expand_normal (vec_oprnd);
 833   if (!(*insn_data[icode].operand[1].predicate) (rtx_op1, mode1)
 834       && mode1 != VOIDmode)
 835     rtx_op1 = force_reg (mode1, rtx_op1);
 836
 837   rtx_op2 = expand_normal (shift_oprnd);
 838   if (!(*insn_data[icode].operand[2].predicate) (rtx_op2, mode2)
 839       && mode2 != VOIDmode)
 840     rtx_op2 = force_reg (mode2, rtx_op2);
 841
 842   if (!target
 843       || ! (*insn_data[icode].operand[0].predicate) (target, mode))
 844     target = gen_reg_rtx (mode);
 845
 846   /* Emit instruction */
 847   pat = GEN_FCN (icode) (target, rtx_op1, rtx_op2);
 848   gcc_assert (pat);
 849   emit_insn (pat);
 850
 851   return target;
 852 }
 853
 854 /* This subroutine of expand_doubleword_shift handles the cases in which
 855    the effective shift value is >= BITS_PER_WORD.  The arguments and return
 856    value are the same as for the parent routine, except that SUPERWORD_OP1
 857    is the shift count to use when shifting OUTOF_INPUT into INTO_TARGET.
 858    INTO_TARGET may be null if the caller has decided to calculate it.  */
 859
 860 static bool
 861 expand_superword_shift (optab binoptab, rtx outof_input, rtx superword_op1,
 862                         rtx outof_target, rtx into_target,
 863                         int unsignedp, enum optab_methods methods)
 864 {
 865   if (into_target != 0)
 866     if (!force_expand_binop (word_mode, binoptab, outof_input, superword_op1,
 867                              into_target, unsignedp, methods))
 868       return false;
 869
 870   if (outof_target != 0)
 871     {
 872       /* For a signed right shift, we must fill OUTOF_TARGET with copies
 873          of the sign bit, otherwise we must fill it with zeros.  */
 874       if (binoptab != ashr_optab)
 875         emit_move_insn (outof_target, CONST0_RTX (word_mode));
 876       else
 877         if (!force_expand_binop (word_mode, binoptab,
 878                                  outof_input, GEN_INT (BITS_PER_WORD - 1),
 879                                  outof_target, unsignedp, methods))
 880           return false;
 881     }
 882   return true;
 883 }
 884
 885 /* This subroutine of expand_doubleword_shift handles the cases in which
 886    the effective shift value is < BITS_PER_WORD.  The arguments and return
 887    value are the same as for the parent routine.  */
 888
 889 static bool
 890 expand_subword_shift (enum machine_mode op1_mode, optab binoptab,
 891                       rtx outof_input, rtx into_input, rtx op1,
 892                       rtx outof_target, rtx into_target,
 893                       int unsignedp, enum optab_methods methods,
 894                       unsigned HOST_WIDE_INT shift_mask)
 895 {
 896   optab reverse_unsigned_shift, unsigned_shift;
 897   rtx tmp, carries;
 898
 899   reverse_unsigned_shift = (binoptab == ashl_optab ? lshr_optab : ashl_optab);
 900   unsigned_shift = (binoptab == ashl_optab ? ashl_optab : lshr_optab);
 901
 902   /* The low OP1 bits of INTO_TARGET come from the high bits of OUTOF_INPUT.
 903      We therefore need to shift OUTOF_INPUT by (BITS_PER_WORD - OP1) bits in
 904      the opposite direction to BINOPTAB.  */
 905   if (CONSTANT_P (op1) || shift_mask >= BITS_PER_WORD)
 906     {
 907       carries = outof_input;
 908       tmp = immed_double_const (BITS_PER_WORD, 0, op1_mode);
 909       tmp = simplify_expand_binop (op1_mode, sub_optab, tmp, op1,
 910                                    0, true, methods);
 911     }
 912   else
 913     {
 914       /* We must avoid shifting by BITS_PER_WORD bits since that is either
 915          the same as a zero shift (if shift_mask == BITS_PER_WORD - 1) or
 916          has unknown behavior.  Do a single shift first, then shift by the
 917          remainder.  It's OK to use ~OP1 as the remainder if shift counts
 918          are truncated to the mode size.  */
 919       carries = expand_binop (word_mode, reverse_unsigned_shift,
 920                               outof_input, const1_rtx, 0, unsignedp, methods);
 921       if (shift_mask == BITS_PER_WORD - 1)
 922         {
 923           tmp = immed_double_const (-1, -1, op1_mode);
 924           tmp = simplify_expand_binop (op1_mode, xor_optab, op1, tmp,
 925                                        0, true, methods);
 926         }
 927       else
 928         {
 929           tmp = immed_double_const (BITS_PER_WORD - 1, 0, op1_mode);
 930           tmp = simplify_expand_binop (op1_mode, sub_optab, tmp, op1,
 931                                        0, true, methods);
 932         }
 933     }
 934   if (tmp == 0 || carries == 0)
 935     return false;
 936   carries = expand_binop (word_mode, reverse_unsigned_shift,
 937                           carries, tmp, 0, unsignedp, methods);
 938   if (carries == 0)
 939     return false;
 940
 941   /* Shift INTO_INPUT logically by OP1.  This is the last use of INTO_INPUT
 942      so the result can go directly into INTO_TARGET if convenient.  */
 943   tmp = expand_binop (word_mode, unsigned_shift, into_input, op1,
 944                       into_target, unsignedp, methods);
 945   if (tmp == 0)
 946     return false;
 947
 948   /* Now OR in the bits carried over from OUTOF_INPUT.  */
 949   if (!force_expand_binop (word_mode, ior_optab, tmp, carries,
 950                            into_target, unsignedp, methods))
 951     return false;
 952
 953   /* Use a standard word_mode shift for the out-of half.  */
 954   if (outof_target != 0)
 955     if (!force_expand_binop (word_mode, binoptab, outof_input, op1,
 956                              outof_target, unsignedp, methods))
 957       return false;
 958
 959   return true;
 960 }
 961
 962
 963 #ifdef HAVE_conditional_move
 964 /* Try implementing expand_doubleword_shift using conditional moves.
 965    The shift is by < BITS_PER_WORD if (CMP_CODE CMP1 CMP2) is true,
 966    otherwise it is by >= BITS_PER_WORD.  SUBWORD_OP1 and SUPERWORD_OP1
 967    are the shift counts to use in the former and latter case.  All other
 968    arguments are the same as the parent routine.  */
 969
 970 static bool
 971 expand_doubleword_shift_condmove (enum machine_mode op1_mode, optab binoptab,
 972                                   enum rtx_code cmp_code, rtx cmp1, rtx cmp2,
 973                                   rtx outof_input, rtx into_input,
 974                                   rtx subword_op1, rtx superword_op1,
 975                                   rtx outof_target, rtx into_target,
 976                                   int unsignedp, enum optab_methods methods,
 977                                   unsigned HOST_WIDE_INT shift_mask)
 978 {
 979   rtx outof_superword, into_superword;
 980
 981   /* Put the superword version of the output into OUTOF_SUPERWORD and
 982      INTO_SUPERWORD.  */
 983   outof_superword = outof_target != 0 ? gen_reg_rtx (word_mode) : 0;
 984   if (outof_target != 0 && subword_op1 == superword_op1)
 985     {
 986       /* The value INTO_TARGET >> SUBWORD_OP1, which we later store in
 987          OUTOF_TARGET, is the same as the value of INTO_SUPERWORD.  */
 988       into_superword = outof_target;
 989       if (!expand_superword_shift (binoptab, outof_input, superword_op1,
 990                                    outof_superword, 0, unsignedp, methods))
 991         return false;
 992     }
 993   else
 994     {
 995       into_superword = gen_reg_rtx (word_mode);
 996       if (!expand_superword_shift (binoptab, outof_input, superword_op1,
 997                                    outof_superword, into_superword,
 998                                    unsignedp, methods))
 999         return false;
1000     }
1001
1002   /* Put the subword version directly in OUTOF_TARGET and INTO_TARGET.  */
1003   if (!expand_subword_shift (op1_mode, binoptab,
1004                              outof_input, into_input, subword_op1,
1005                              outof_target, into_target,
1006                              unsignedp, methods, shift_mask))
1007     return false;
1008
1009   /* Select between them.  Do the INTO half first because INTO_SUPERWORD
1010      might be the current value of OUTOF_TARGET.  */
1011   if (!emit_conditional_move (into_target, cmp_code, cmp1, cmp2, op1_mode,
1012                               into_target, into_superword, word_mode, false))
1013     return false;
1014
1015   if (outof_target != 0)
1016     if (!emit_conditional_move (outof_target, cmp_code, cmp1, cmp2, op1_mode,
1017                                 outof_target, outof_superword,
1018                                 word_mode, false))
1019       return false;
1020
1021   return true;
1022 }
1023 #endif
1024
1025 /* Expand a doubleword shift (ashl, ashr or lshr) using word-mode shifts.
1026    OUTOF_INPUT and INTO_INPUT are the two word-sized halves of the first
1027    input operand; the shift moves bits in the direction OUTOF_INPUT->
1028    INTO_TARGET.  OUTOF_TARGET and INTO_TARGET are the equivalent words
1029    of the target.  OP1 is the shift count and OP1_MODE is its mode.
1030    If OP1 is constant, it will have been truncated as appropriate
1031    and is known to be nonzero.
1032
1033    If SHIFT_MASK is zero, the result of word shifts is undefined when the
1034    shift count is outside the range [0, BITS_PER_WORD).  This routine must
1035    avoid generating such shifts for OP1s in the range [0, BITS_PER_WORD * 2).
1036
1037    If SHIFT_MASK is nonzero, all word-mode shift counts are effectively
1038    masked by it and shifts in the range [BITS_PER_WORD, SHIFT_MASK) will
1039    fill with zeros or sign bits as appropriate.
1040
1041    If SHIFT_MASK is BITS_PER_WORD - 1, this routine will synthesize
1042    a doubleword shift whose equivalent mask is BITS_PER_WORD * 2 - 1.
1043    Doing this preserves semantics required by SHIFT_COUNT_TRUNCATED.
1044    In all other cases, shifts by values outside [0, BITS_PER_UNIT * 2)
1045    are undefined.
1046
1047    BINOPTAB, UNSIGNEDP and METHODS are as for expand_binop.  This function
1048    may not use INTO_INPUT after modifying INTO_TARGET, and similarly for
1049    OUTOF_INPUT and OUTOF_TARGET.  OUTOF_TARGET can be null if the parent
1050    function wants to calculate it itself.
1051
1052    Return true if the shift could be successfully synthesized.  */
1053
1054 static bool
1055 expand_doubleword_shift (enum machine_mode op1_mode, optab binoptab,
1056                          rtx outof_input, rtx into_input, rtx op1,
1057                          rtx outof_target, rtx into_target,
1058                          int unsignedp, enum optab_methods methods,
1059                          unsigned HOST_WIDE_INT shift_mask)
1060 {
1061   rtx superword_op1, tmp, cmp1, cmp2;
1062   rtx subword_label, done_label;
1063   enum rtx_code cmp_code;
1064
1065   /* See if word-mode shifts by BITS_PER_WORD...BITS_PER_WORD * 2 - 1 will
1066      fill the result with sign or zero bits as appropriate.  If so, the value
1067      of OUTOF_TARGET will always be (SHIFT OUTOF_INPUT OP1).   Recursively call
1068      this routine to calculate INTO_TARGET (which depends on both OUTOF_INPUT
1069      and INTO_INPUT), then emit code to set up OUTOF_TARGET.
1070
1071      This isn't worthwhile for constant shifts since the optimizers will
1072      cope better with in-range shift counts.  */
1073   if (shift_mask >= BITS_PER_WORD
1074       && outof_target != 0
1075       && !CONSTANT_P (op1))
1076     {
1077       if (!expand_doubleword_shift (op1_mode, binoptab,
1078                                     outof_input, into_input, op1,
1079                                     0, into_target,
1080                                     unsignedp, methods, shift_mask))
1081         return false;
1082       if (!force_expand_binop (word_mode, binoptab, outof_input, op1,
1083                                outof_target, unsignedp, methods))
1084         return false;
1085       return true;
1086     }
1087
1088   /* Set CMP_CODE, CMP1 and CMP2 so that the rtx (CMP_CODE CMP1 CMP2)
1089      is true when the effective shift value is less than BITS_PER_WORD.
1090      Set SUPERWORD_OP1 to the shift count that should be used to shift
1091      OUTOF_INPUT into INTO_TARGET when the condition is false.  */
1092   tmp = immed_double_const (BITS_PER_WORD, 0, op1_mode);
1093   if (!CONSTANT_P (op1) && shift_mask == BITS_PER_WORD - 1)
1094     {
1095       /* Set CMP1 to OP1 & BITS_PER_WORD.  The result is zero iff OP1
1096          is a subword shift count.  */
1097       cmp1 = simplify_expand_binop (op1_mode, and_optab, op1, tmp,
1098                                     0, true, methods);
1099       cmp2 = CONST0_RTX (op1_mode);
1100       cmp_code = EQ;
1101       superword_op1 = op1;
1102     }
1103   else
1104     {
1105       /* Set CMP1 to OP1 - BITS_PER_WORD.  */
1106       cmp1 = simplify_expand_binop (op1_mode, sub_optab, op1, tmp,
1107                                     0, true, methods);
1108       cmp2 = CONST0_RTX (op1_mode);
1109       cmp_code = LT;
1110       superword_op1 = cmp1;
1111     }
1112   if (cmp1 == 0)
1113     return false;
1114
1115   /* If we can compute the condition at compile time, pick the
1116      appropriate subroutine.  */
1117   tmp = simplify_relational_operation (cmp_code, SImode, op1_mode, cmp1, cmp2);
1118   if (tmp != 0 && GET_CODE (tmp) == CONST_INT)
1119     {
1120       if (tmp == const0_rtx)
1121         return expand_superword_shift (binoptab, outof_input, superword_op1,
1122                                        outof_target, into_target,
1123                                        unsignedp, methods);
1124       else
1125         return expand_subword_shift (op1_mode, binoptab,
1126                                      outof_input, into_input, op1,
1127                                      outof_target, into_target,
1128                                      unsignedp, methods, shift_mask);
1129     }
1130
1131 #ifdef HAVE_conditional_move
1132   /* Try using conditional moves to generate straight-line code.  */
1133   {
1134     rtx start = get_last_insn ();
1135     if (expand_doubleword_shift_condmove (op1_mode, binoptab,
1136                                           cmp_code, cmp1, cmp2,
1137                                           outof_input, into_input,
1138                                           op1, superword_op1,
1139                                           outof_target, into_target,
1140                                           unsignedp, methods, shift_mask))
1141       return true;
1142     delete_insns_since (start);
1143   }
1144 #endif
1145
1146   /* As a last resort, use branches to select the correct alternative.  */
1147   subword_label = gen_label_rtx ();
1148   done_label = gen_label_rtx ();
1149
1150   NO_DEFER_POP;
1151   do_compare_rtx_and_jump (cmp1, cmp2, cmp_code, false, op1_mode,
1152                            0, 0, subword_label);
1153   OK_DEFER_POP;
1154
1155   if (!expand_superword_shift (binoptab, outof_input, superword_op1,
1156                                outof_target, into_target,
1157                                unsignedp, methods))
1158     return false;
1159
1160   emit_jump_insn (gen_jump (done_label));
1161   emit_barrier ();
1162   emit_label (subword_label);
1163
1164   if (!expand_subword_shift (op1_mode, binoptab,
1165                              outof_input, into_input, op1,
1166                              outof_target, into_target,
1167                              unsignedp, methods, shift_mask))
1168     return false;
1169
1170   emit_label (done_label);
1171   return true;
1172 }
1173 \f
1174 /* Subroutine of expand_binop.  Perform a double word multiplication of
1175    operands OP0 and OP1 both of mode MODE, which is exactly twice as wide
1176    as the target's word_mode.  This function return NULL_RTX if anything
1177    goes wrong, in which case it may have already emitted instructions
1178    which need to be deleted.
1179
1180    If we want to multiply two two-word values and have normal and widening
1181    multiplies of single-word values, we can do this with three smaller
1182    multiplications.
1183
1184    The multiplication proceeds as follows:
1185                                  _______________________
1186                                 [__op0_high_|__op0_low__]
1187                                  _______________________
1188         *                       [__op1_high_|__op1_low__]
1189         _______________________________________________
1190                                  _______________________
1191     (1)                         [__op0_low__*__op1_low__]
1192                      _______________________
1193     (2a)            [__op0_low__*__op1_high_]
1194                      _______________________
1195     (2b)            [__op0_high_*__op1_low__]
1196          _______________________
1197     (3) [__op0_high_*__op1_high_]
1198
1199
1200   This gives a 4-word result.  Since we are only interested in the
1201   lower 2 words, partial result (3) and the upper words of (2a) and
1202   (2b) don't need to be calculated.  Hence (2a) and (2b) can be
1203   calculated using non-widening multiplication.
1204
1205   (1), however, needs to be calculated with an unsigned widening
1206   multiplication.  If this operation is not directly supported we
1207   try using a signed widening multiplication and adjust the result.
1208   This adjustment works as follows:
1209
1210       If both operands are positive then no adjustment is needed.
1211
1212       If the operands have different signs, for example op0_low < 0 and
1213       op1_low >= 0, the instruction treats the most significant bit of
1214       op0_low as a sign bit instead of a bit with significance
1215       2**(BITS_PER_WORD-1), i.e. the instruction multiplies op1_low
1216       with 2**BITS_PER_WORD - op0_low, and two's complements the
1217       result.  Conclusion: We need to add op1_low * 2**BITS_PER_WORD to
1218       the result.
1219
1220       Similarly, if both operands are negative, we need to add
1221       (op0_low + op1_low) * 2**BITS_PER_WORD.
1222
1223       We use a trick to adjust quickly.  We logically shift op0_low right
1224       (op1_low) BITS_PER_WORD-1 steps to get 0 or 1, and add this to
1225       op0_high (op1_high) before it is used to calculate 2b (2a).  If no
1226       logical shift exists, we do an arithmetic right shift and subtract
1227       the 0 or -1.  */
1228
1229 static rtx
1230 expand_doubleword_mult (enum machine_mode mode, rtx op0, rtx op1, rtx target,
1231                        bool umulp, enum optab_methods methods)
1232 {
1233   int low = (WORDS_BIG_ENDIAN ? 1 : 0);
1234   int high = (WORDS_BIG_ENDIAN ? 0 : 1);
1235   rtx wordm1 = umulp ? NULL_RTX : GEN_INT (BITS_PER_WORD - 1);
1236   rtx product, adjust, product_high, temp;
1237
1238   rtx op0_high = operand_subword_force (op0, high, mode);
1239   rtx op0_low = operand_subword_force (op0, low, mode);
1240   rtx op1_high = operand_subword_force (op1, high, mode);
1241   rtx op1_low = operand_subword_force (op1, low, mode);
1242
1243   /* If we're using an unsigned multiply to directly compute the product
1244      of the low-order words of the operands and perform any required
1245      adjustments of the operands, we begin by trying two more multiplications
1246      and then computing the appropriate sum.
1247
1248      We have checked above that the required addition is provided.
1249      Full-word addition will normally always succeed, especially if
1250      it is provided at all, so we don't worry about its failure.  The
1251      multiplication may well fail, however, so we do handle that.  */
1252
1253   if (!umulp)
1254     {
1255       /* ??? This could be done with emit_store_flag where available.  */
1256       temp = expand_binop (word_mode, lshr_optab, op0_low, wordm1,
1257                            NULL_RTX, 1, methods);
1258       if (temp)
1259         op0_high = expand_binop (word_mode, add_optab, op0_high, temp,
1260                                  NULL_RTX, 0, OPTAB_DIRECT);
1261       else
1262         {
1263           temp = expand_binop (word_mode, ashr_optab, op0_low, wordm1,
1264                                NULL_RTX, 0, methods);
1265           if (!temp)
1266             return NULL_RTX;
1267           op0_high = expand_binop (word_mode, sub_optab, op0_high, temp,
1268                                    NULL_RTX, 0, OPTAB_DIRECT);
1269         }
1270
1271       if (!op0_high)
1272         return NULL_RTX;
1273     }
1274
1275   adjust = expand_binop (word_mode, smul_optab, op0_high, op1_low,
1276                          NULL_RTX, 0, OPTAB_DIRECT);
1277   if (!adjust)
1278     return NULL_RTX;
1279
1280   /* OP0_HIGH should now be dead.  */
1281
1282   if (!umulp)
1283     {
1284       /* ??? This could be done with emit_store_flag where available.  */
1285       temp = expand_binop (word_mode, lshr_optab, op1_low, wordm1,
1286                            NULL_RTX, 1, methods);
1287       if (temp)
1288         op1_high = expand_binop (word_mode, add_optab, op1_high, temp,
1289                                  NULL_RTX, 0, OPTAB_DIRECT);
1290       else
1291         {
1292           temp = expand_binop (word_mode, ashr_optab, op1_low, wordm1,
1293                                NULL_RTX, 0, methods);
1294           if (!temp)
1295             return NULL_RTX;
1296           op1_high = expand_binop (word_mode, sub_optab, op1_high, temp,
1297                                    NULL_RTX, 0, OPTAB_DIRECT);
1298         }
1299
1300       if (!op1_high)
1301         return NULL_RTX;
1302     }
1303
1304   temp = expand_binop (word_mode, smul_optab, op1_high, op0_low,
1305                        NULL_RTX, 0, OPTAB_DIRECT);
1306   if (!temp)
1307     return NULL_RTX;
1308
1309   /* OP1_HIGH should now be dead.  */
1310
1311   adjust = expand_binop (word_mode, add_optab, adjust, temp,
1312                          adjust, 0, OPTAB_DIRECT);
1313
1314   if (target && !REG_P (target))
1315     target = NULL_RTX;
1316
1317   if (umulp)
1318     product = expand_binop (mode, umul_widen_optab, op0_low, op1_low,
1319                             target, 1, OPTAB_DIRECT);
1320   else
1321     product = expand_binop (mode, smul_widen_optab, op0_low, op1_low,
1322                             target, 1, OPTAB_DIRECT);
1323
1324   if (!product)
1325     return NULL_RTX;
1326
1327   product_high = operand_subword (product, high, 1, mode);
1328   adjust = expand_binop (word_mode, add_optab, product_high, adjust,
1329                          REG_P (product_high) ? product_high : adjust,
1330                          0, OPTAB_DIRECT);
1331   emit_move_insn (product_high, adjust);
1332   return product;
1333 }
1334 \f
1335 /* Wrapper around expand_binop which takes an rtx code to specify
1336    the operation to perform, not an optab pointer.  All other
1337    arguments are the same.  */
1338 rtx
1339 expand_simple_binop (enum machine_mode mode, enum rtx_code code, rtx op0,
1340                      rtx op1, rtx target, int unsignedp,
1341                      enum optab_methods methods)
1342 {
1343   optab binop = code_to_optab[(int) code];
1344   gcc_assert (binop);
1345
1346   return expand_binop (mode, binop, op0, op1, target, unsignedp, methods);
1347 }
1348
1349 /* Return whether OP0 and OP1 should be swapped when expanding a commutative
1350    binop.  Order them according to commutative_operand_precedence and, if
1351    possible, try to put TARGET or a pseudo first.  */
1352 static bool
1353 swap_commutative_operands_with_target (rtx target, rtx op0, rtx op1)
1354 {
1355   int op0_prec = commutative_operand_precedence (op0);
1356   int op1_prec = commutative_operand_precedence (op1);
1357
1358   if (op0_prec < op1_prec)
1359     return true;
1360
1361   if (op0_prec > op1_prec)
1362     return false;
1363
1364   /* With equal precedence, both orders are ok, but it is better if the
1365      first operand is TARGET, or if both TARGET and OP0 are pseudos.  */
1366   if (target == 0 || REG_P (target))
1367     return (REG_P (op1) && !REG_P (op0)) || target == op1;
1368   else
1369     return rtx_equal_p (op1, target);
1370 }
1371
1372 /* Return true if BINOPTAB implements a shift operation.  */
1373
1374 static bool
1375 shift_optab_p (optab binoptab)
1376 {
1377   switch (binoptab->code)
1378     {
1379     case ASHIFT:
1380     case SS_ASHIFT:
1381     case US_ASHIFT:
1382     case ASHIFTRT:
1383     case LSHIFTRT:
1384     case ROTATE:
1385     case ROTATERT:
1386       return true;
1387
1388     default:
1389       return false;
1390     }
1391 }
1392
1393 /* Return true if BINOPTAB implements a commutative binary operation.  */
1394
1395 static bool
1396 commutative_optab_p (optab binoptab)
1397 {
1398   return (GET_RTX_CLASS (binoptab->code) == RTX_COMM_ARITH
1399           || binoptab == smul_widen_optab
1400           || binoptab == umul_widen_optab
1401           || binoptab == smul_highpart_optab
1402           || binoptab == umul_highpart_optab);
1403 }
1404
1405 /* X is to be used in mode MODE as an operand to BINOPTAB.  If we're
1406    optimizing, and if the operand is a constant that costs more than
1407    1 instruction, force the constant into a register and return that
1408    register.  Return X otherwise.  UNSIGNEDP says whether X is unsigned.  */
1409
1410 static rtx
1411 avoid_expensive_constant (enum machine_mode mode, optab binoptab,
1412                           rtx x, bool unsignedp)
1413 {
1414   if (mode != VOIDmode
1415       && optimize
1416       && CONSTANT_P (x)
1417       && rtx_cost (x, binoptab->code) > COSTS_N_INSNS (1))
1418     {
1419       if (GET_CODE (x) == CONST_INT)
1420         {
1421           HOST_WIDE_INT intval = trunc_int_for_mode (INTVAL (x), mode);
1422           if (intval != INTVAL (x))
1423             x = GEN_INT (intval);
1424         }
1425       else
1426         x = convert_modes (mode, VOIDmode, x, unsignedp);
1427       x = force_reg (mode, x);
1428     }
1429   return x;
1430 }
1431
1432 /* Helper function for expand_binop: handle the case where there
1433    is an insn that directly implements the indicated operation.
1434    Returns null if this is not possible.  */
1435 static rtx
1436 expand_binop_directly (enum machine_mode mode, optab binoptab,
1437                        rtx op0, rtx op1,
1438                        rtx target, int unsignedp, enum optab_methods methods,
1439                        rtx last)
1440 {
1441   int icode = (int) optab_handler (binoptab, mode)->insn_code;
1442   enum machine_mode mode0 = insn_data[icode].operand[1].mode;
1443   enum machine_mode mode1 = insn_data[icode].operand[2].mode;
1444   enum machine_mode tmp_mode;
1445   bool commutative_p;
1446   rtx pat;
1447   rtx xop0 = op0, xop1 = op1;
1448   rtx temp;
1449   rtx swap;
1450
1451   if (target)
1452     temp = target;
1453   else
1454     temp = gen_reg_rtx (mode);
1455
1456   /* If it is a commutative operator and the modes would match
1457      if we would swap the operands, we can save the conversions.  */
1458   commutative_p = commutative_optab_p (binoptab);
1459   if (commutative_p
1460       && GET_MODE (xop0) != mode0 && GET_MODE (xop1) != mode1
1461       && GET_MODE (xop0) == mode1 && GET_MODE (xop1) == mode1)
1462     {
1463       swap = xop0;
1464       xop0 = xop1;
1465       xop1 = swap;
1466     }
1467
1468   /* If we are optimizing, force expensive constants into a register.  */
1469   xop0 = avoid_expensive_constant (mode0, binoptab, xop0, unsignedp);
1470   if (!shift_optab_p (binoptab))
1471     xop1 = avoid_expensive_constant (mode1, binoptab, xop1, unsignedp);
1472
1473   /* In case the insn wants input operands in modes different from
1474      those of the actual operands, convert the operands.  It would
1475      seem that we don't need to convert CONST_INTs, but we do, so
1476      that they're properly zero-extended, sign-extended or truncated
1477      for their mode.  */
1478
1479   if (GET_MODE (xop0) != mode0 && mode0 != VOIDmode)
1480     xop0 = convert_modes (mode0,
1481                           GET_MODE (xop0) != VOIDmode
1482                           ? GET_MODE (xop0)
1483                           : mode,
1484                           xop0, unsignedp);
1485
1486   if (GET_MODE (xop1) != mode1 && mode1 != VOIDmode)
1487     xop1 = convert_modes (mode1,
1488                           GET_MODE (xop1) != VOIDmode
1489                           ? GET_MODE (xop1)
1490                           : mode,
1491                           xop1, unsignedp);
1492
1493   /* If operation is commutative,
1494      try to make the first operand a register.
1495      Even better, try to make it the same as the target.
1496      Also try to make the last operand a constant.  */
1497   if (commutative_p
1498       && swap_commutative_operands_with_target (target, xop0, xop1))
1499     {
1500       swap = xop1;
1501       xop1 = xop0;
1502       xop0 = swap;
1503     }
1504
1505   /* Now, if insn's predicates don't allow our operands, put them into
1506      pseudo regs.  */
1507
1508   if (!insn_data[icode].operand[1].predicate (xop0, mode0)
1509       && mode0 != VOIDmode)
1510     xop0 = copy_to_mode_reg (mode0, xop0);
1511
1512   if (!insn_data[icode].operand[2].predicate (xop1, mode1)
1513       && mode1 != VOIDmode)
1514     xop1 = copy_to_mode_reg (mode1, xop1);
1515
1516   if (binoptab == vec_pack_trunc_optab
1517       || binoptab == vec_pack_usat_optab
1518       || binoptab == vec_pack_ssat_optab
1519       || binoptab == vec_pack_ufix_trunc_optab
1520       || binoptab == vec_pack_sfix_trunc_optab)
1521     {
1522       /* The mode of the result is different then the mode of the
1523          arguments.  */
1524       tmp_mode = insn_data[icode].operand[0].mode;
1525       if (GET_MODE_NUNITS (tmp_mode) != 2 * GET_MODE_NUNITS (mode))
1526         return 0;
1527     }
1528   else
1529     tmp_mode = mode;
1530
1531   if (!insn_data[icode].operand[0].predicate (temp, tmp_mode))
1532     temp = gen_reg_rtx (tmp_mode);
1533
1534   pat = GEN_FCN (icode) (temp, xop0, xop1);
1535   if (pat)
1536     {
1537       /* If PAT is composed of more than one insn, try to add an appropriate
1538          REG_EQUAL note to it.  If we can't because TEMP conflicts with an
1539          operand, call expand_binop again, this time without a target.  */
1540       if (INSN_P (pat) && NEXT_INSN (pat) != NULL_RTX
1541           && ! add_equal_note (pat, temp, binoptab->code, xop0, xop1))
1542         {
1543           delete_insns_since (last);
1544           return expand_binop (mode, binoptab, op0, op1, NULL_RTX,
1545                                unsignedp, methods);
1546         }
1547
1548       emit_insn (pat);
1549       return temp;
1550     }
1551
1552   delete_insns_since (last);
1553   return NULL_RTX;
1554 }
1555
1556 /* Generate code to perform an operation specified by BINOPTAB
1557    on operands OP0 and OP1, with result having machine-mode MODE.
1558
1559    UNSIGNEDP is for the case where we have to widen the operands
1560    to perform the operation.  It says to use zero-extension.
1561
1562    If TARGET is nonzero, the value
1563    is generated there, if it is convenient to do so.
1564    In all cases an rtx is returned for the locus of the value;
1565    this may or may not be TARGET.  */
1566
1567 rtx
1568 expand_binop (enum machine_mode mode, optab binoptab, rtx op0, rtx op1,
1569               rtx target, int unsignedp, enum optab_methods methods)
1570 {
1571   enum optab_methods next_methods
1572     = (methods == OPTAB_LIB || methods == OPTAB_LIB_WIDEN
1573        ? OPTAB_WIDEN : methods);
1574   enum mode_class mclass;
1575   enum machine_mode wider_mode;
1576   rtx libfunc;
1577   rtx temp;
1578   rtx entry_last = get_last_insn ();
1579   rtx last;
1580
1581   mclass = GET_MODE_CLASS (mode);
1582
1583   /* If subtracting an integer constant, convert this into an addition of
1584      the negated constant.  */
1585
1586   if (binoptab == sub_optab && GET_CODE (op1) == CONST_INT)
1587     {
1588       op1 = negate_rtx (mode, op1);
1589       binoptab = add_optab;
1590     }
1591
1592   /* Record where to delete back to if we backtrack.  */
1593   last = get_last_insn ();
1594
1595   /* If we can do it with a three-operand insn, do so.  */
1596
1597   if (methods != OPTAB_MUST_WIDEN
1598       && optab_handler (binoptab, mode)->insn_code != CODE_FOR_nothing)
1599     {
1600       temp = expand_binop_directly (mode, binoptab, op0, op1, target,
1601                                     unsignedp, methods, last);
1602       if (temp)
1603         return temp;
1604     }
1605
1606   /* If we were trying to rotate, and that didn't work, try rotating
1607      the other direction before falling back to shifts and bitwise-or.  */
1608   if (((binoptab == rotl_optab
1609         && optab_handler (rotr_optab, mode)->insn_code != CODE_FOR_nothing)
1610        || (binoptab == rotr_optab
1611            && optab_handler (rotl_optab, mode)->insn_code != CODE_FOR_nothing))
1612       && mclass == MODE_INT)
1613     {
1614       optab otheroptab = (binoptab == rotl_optab ? rotr_optab : rotl_optab);
1615       rtx newop1;
1616       unsigned int bits = GET_MODE_BITSIZE (mode);
1617
1618       if (GET_CODE (op1) == CONST_INT)
1619         newop1 = GEN_INT (bits - INTVAL (op1));
1620       else if (targetm.shift_truncation_mask (mode) == bits - 1)
1621         newop1 = negate_rtx (mode, op1);
1622       else
1623         newop1 = expand_binop (mode, sub_optab,
1624                                GEN_INT (bits), op1,
1625                                NULL_RTX, unsignedp, OPTAB_DIRECT);
1626
1627       temp = expand_binop_directly (mode, otheroptab, op0, newop1,
1628                                     target, unsignedp, methods, last);
1629       if (temp)
1630         return temp;
1631     }
1632
1633   /* If this is a multiply, see if we can do a widening operation that
1634      takes operands of this mode and makes a wider mode.  */
1635
1636   if (binoptab == smul_optab
1637       && GET_MODE_WIDER_MODE (mode) != VOIDmode
1638       && ((optab_handler ((unsignedp ? umul_widen_optab : smul_widen_optab),
1639                           GET_MODE_WIDER_MODE (mode))->insn_code)
1640           != CODE_FOR_nothing))
1641     {
1642       temp = expand_binop (GET_MODE_WIDER_MODE (mode),
1643                            unsignedp ? umul_widen_optab : smul_widen_optab,
1644                            op0, op1, NULL_RTX, unsignedp, OPTAB_DIRECT);
1645
1646       if (temp != 0)
1647         {
1648           if (GET_MODE_CLASS (mode) == MODE_INT
1649               && TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (mode),
1650                                         GET_MODE_BITSIZE (GET_MODE (temp))))
1651             return gen_lowpart (mode, temp);
1652           else
1653             return convert_to_mode (mode, temp, unsignedp);
1654         }
1655     }
1656
1657   /* Look for a wider mode of the same class for which we think we
1658      can open-code the operation.  Check for a widening multiply at the
1659      wider mode as well.  */
1660
1661   if (CLASS_HAS_WIDER_MODES_P (mclass)
1662       && methods != OPTAB_DIRECT && methods != OPTAB_LIB)
1663     for (wider_mode = GET_MODE_WIDER_MODE (mode);
1664          wider_mode != VOIDmode;
1665          wider_mode = GET_MODE_WIDER_MODE (wider_mode))
1666       {
1667         if (optab_handler (binoptab, wider_mode)->insn_code != CODE_FOR_nothing
1668             || (binoptab == smul_optab
1669                 && GET_MODE_WIDER_MODE (wider_mode) != VOIDmode
1670                 && ((optab_handler ((unsignedp ? umul_widen_optab
1671                                      : smul_widen_optab),
1672                                      GET_MODE_WIDER_MODE (wider_mode))->insn_code)
1673                     != CODE_FOR_nothing)))
1674           {
1675             rtx xop0 = op0, xop1 = op1;
1676             int no_extend = 0;
1677
1678             /* For certain integer operations, we need not actually extend
1679                the narrow operands, as long as we will truncate
1680                the results to the same narrowness.  */
1681
1682             if ((binoptab == ior_optab || binoptab == and_optab
1683                  || binoptab == xor_optab
1684                  || binoptab == add_optab || binoptab == sub_optab
1685                  || binoptab == smul_optab || binoptab == ashl_optab)
1686                 && mclass == MODE_INT)
1687               {
1688                 no_extend = 1;
1689                 xop0 = avoid_expensive_constant (mode, binoptab,
1690                                                  xop0, unsignedp);
1691                 if (binoptab != ashl_optab)
1692                   xop1 = avoid_expensive_constant (mode, binoptab,
1693                                                    xop1, unsignedp);
1694               }
1695
1696             xop0 = widen_operand (xop0, wider_mode, mode, unsignedp, no_extend);
1697
1698             /* The second operand of a shift must always be extended.  */
1699             xop1 = widen_operand (xop1, wider_mode, mode, unsignedp,
1700                                   no_extend && binoptab != ashl_optab);
1701
1702             temp = expand_binop (wider_mode, binoptab, xop0, xop1, NULL_RTX,
1703                                  unsignedp, OPTAB_DIRECT);
1704             if (temp)
1705               {
1706                 if (mclass != MODE_INT
1707                     || !TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (mode),
1708                                                GET_MODE_BITSIZE (wider_mode)))
1709                   {
1710                     if (target == 0)
1711                       target = gen_reg_rtx (mode);
1712                     convert_move (target, temp, 0);
1713                     return target;
1714                   }
1715                 else
1716                   return gen_lowpart (mode, temp);
1717               }
1718             else
1719               delete_insns_since (last);
1720           }
1721       }
1722
1723   /* If operation is commutative,
1724      try to make the first operand a register.
1725      Even better, try to make it the same as the target.
1726      Also try to make the last operand a constant.  */
1727   if (commutative_optab_p (binoptab)
1728       && swap_commutative_operands_with_target (target, op0, op1))
1729     {
1730       temp = op1;
1731       op1 = op0;
1732       op0 = temp;
1733     }
1734
1735   /* These can be done a word at a time.  */
1736   if ((binoptab == and_optab || binoptab == ior_optab || binoptab == xor_optab)
1737       && mclass == MODE_INT
1738       && GET_MODE_SIZE (mode) > UNITS_PER_WORD
1739       && optab_handler (binoptab, word_mode)->insn_code != CODE_FOR_nothing)
1740     {
1741       int i;
1742       rtx insns;
1743       rtx equiv_value;
1744
1745       /* If TARGET is the same as one of the operands, the REG_EQUAL note
1746          won't be accurate, so use a new target.  */
1747       if (target == 0 || target == op0 || target == op1)
1748         target = gen_reg_rtx (mode);
1749
1750       start_sequence ();
1751
1752       /* Do the actual arithmetic.  */
1753       for (i = 0; i < GET_MODE_BITSIZE (mode) / BITS_PER_WORD; i++)
1754         {
1755           rtx target_piece = operand_subword (target, i, 1, mode);
1756           rtx x = expand_binop (word_mode, binoptab,
1757                                 operand_subword_force (op0, i, mode),
1758                                 operand_subword_force (op1, i, mode),
1759                                 target_piece, unsignedp, next_methods);
1760
1761           if (x == 0)
1762             break;
1763
1764           if (target_piece != x)
1765             emit_move_insn (target_piece, x);
1766         }
1767
1768       insns = get_insns ();
1769       end_sequence ();
1770
1771       if (i == GET_MODE_BITSIZE (mode) / BITS_PER_WORD)
1772         {
1773           if (binoptab->code != UNKNOWN)
1774             equiv_value
1775               = gen_rtx_fmt_ee (binoptab->code, mode,
1776                                 copy_rtx (op0), copy_rtx (op1));
1777           else
1778             equiv_value = 0;
1779
1780           emit_insn (insns);
1781           return target;
1782         }
1783     }
1784
1785   /* Synthesize double word shifts from single word shifts.  */
1786   if ((binoptab == lshr_optab || binoptab == ashl_optab
1787        || binoptab == ashr_optab)
1788       && mclass == MODE_INT
1789       && (GET_CODE (op1) == CONST_INT || optimize_insn_for_speed_p ())
1790       && GET_MODE_SIZE (mode) == 2 * UNITS_PER_WORD
1791       && optab_handler (binoptab, word_mode)->insn_code != CODE_FOR_nothing
1792       && optab_handler (ashl_optab, word_mode)->insn_code != CODE_FOR_nothing
1793       && optab_handler (lshr_optab, word_mode)->insn_code != CODE_FOR_nothing)
1794     {
1795       unsigned HOST_WIDE_INT shift_mask, double_shift_mask;
1796       enum machine_mode op1_mode;
1797
1798       double_shift_mask = targetm.shift_truncation_mask (mode);
1799       shift_mask = targetm.shift_truncation_mask (word_mode);
1800       op1_mode = GET_MODE (op1) != VOIDmode ? GET_MODE (op1) : word_mode;
1801
1802       /* Apply the truncation to constant shifts.  */
1803       if (double_shift_mask > 0 && GET_CODE (op1) == CONST_INT)
1804         op1 = GEN_INT (INTVAL (op1) & double_shift_mask);
1805
1806       if (op1 == CONST0_RTX (op1_mode))
1807         return op0;
1808
1809       /* Make sure that this is a combination that expand_doubleword_shift
1810          can handle.  See the comments there for details.  */
1811       if (double_shift_mask == 0
1812           || (shift_mask == BITS_PER_WORD - 1
1813               && double_shift_mask == BITS_PER_WORD * 2 - 1))
1814         {
1815           rtx insns;
1816           rtx into_target, outof_target;
1817           rtx into_input, outof_input;
1818           int left_shift, outof_word;
1819
1820           /* If TARGET is the same as one of the operands, the REG_EQUAL note
1821              won't be accurate, so use a new target.  */
1822           if (target == 0 || target == op0 || target == op1)
1823             target = gen_reg_rtx (mode);
1824
1825           start_sequence ();
1826
1827           /* OUTOF_* is the word we are shifting bits away from, and
1828              INTO_* is the word that we are shifting bits towards, thus
1829              they differ depending on the direction of the shift and
1830              WORDS_BIG_ENDIAN.  */
1831
1832           left_shift = binoptab == ashl_optab;
1833           outof_word = left_shift ^ ! WORDS_BIG_ENDIAN;
1834
1835           outof_target = operand_subword (target, outof_word, 1, mode);
1836           into_target = operand_subword (target, 1 - outof_word, 1, mode);
1837
1838           outof_input = operand_subword_force (op0, outof_word, mode);
1839           into_input = operand_subword_force (op0, 1 - outof_word, mode);
1840
1841           if (expand_doubleword_shift (op1_mode, binoptab,
1842                                        outof_input, into_input, op1,
1843                                        outof_target, into_target,
1844                                        unsignedp, next_methods, shift_mask))
1845             {
1846               insns = get_insns ();
1847               end_sequence ();
1848
1849               emit_insn (insns);
1850               return target;
1851             }
1852           end_sequence ();
1853         }
1854     }
1855
1856   /* Synthesize double word rotates from single word shifts.  */
1857   if ((binoptab == rotl_optab || binoptab == rotr_optab)
1858       && mclass == MODE_INT
1859       && GET_CODE (op1) == CONST_INT
1860       && GET_MODE_SIZE (mode) == 2 * UNITS_PER_WORD
1861       && optab_handler (ashl_optab, word_mode)->insn_code != CODE_FOR_nothing
1862       && optab_handler (lshr_optab, word_mode)->insn_code != CODE_FOR_nothing)
1863     {
1864       rtx insns;
1865       rtx into_target, outof_target;
1866       rtx into_input, outof_input;
1867       rtx inter;
1868       int shift_count, left_shift, outof_word;
1869
1870       /* If TARGET is the same as one of the operands, the REG_EQUAL note
1871          won't be accurate, so use a new target. Do this also if target is not
1872          a REG, first because having a register instead may open optimization
1873          opportunities, and second because if target and op0 happen to be MEMs
1874          designating the same location, we would risk clobbering it too early
1875          in the code sequence we generate below.  */
1876       if (target == 0 || target == op0 || target == op1 || ! REG_P (target))
1877         target = gen_reg_rtx (mode);
1878
1879       start_sequence ();
1880
1881       shift_count = INTVAL (op1);
1882
1883       /* OUTOF_* is the word we are shifting bits away from, and
1884          INTO_* is the word that we are shifting bits towards, thus
1885          they differ depending on the direction of the shift and
1886          WORDS_BIG_ENDIAN.  */
1887
1888       left_shift = (binoptab == rotl_optab);
1889       outof_word = left_shift ^ ! WORDS_BIG_ENDIAN;
1890
1891       outof_target = operand_subword (target, outof_word, 1, mode);
1892       into_target = operand_subword (target, 1 - outof_word, 1, mode);
1893
1894       outof_input = operand_subword_force (op0, outof_word, mode);
1895       into_input = operand_subword_force (op0, 1 - outof_word, mode);
1896
1897       if (shift_count == BITS_PER_WORD)
1898         {
1899           /* This is just a word swap.  */
1900           emit_move_insn (outof_target, into_input);
1901           emit_move_insn (into_target, outof_input);
1902           inter = const0_rtx;
1903         }
1904       else
1905         {
1906           rtx into_temp1, into_temp2, outof_temp1, outof_temp2;
1907           rtx first_shift_count, second_shift_count;
1908           optab reverse_unsigned_shift, unsigned_shift;
1909
1910           reverse_unsigned_shift = (left_shift ^ (shift_count < BITS_PER_WORD)
1911                                     ? lshr_optab : ashl_optab);
1912
1913           unsigned_shift = (left_shift ^ (shift_count < BITS_PER_WORD)
1914                             ? ashl_optab : lshr_optab);
1915
1916           if (shift_count > BITS_PER_WORD)
1917             {
1918               first_shift_count = GEN_INT (shift_count - BITS_PER_WORD);
1919               second_shift_count = GEN_INT (2 * BITS_PER_WORD - shift_count);
1920             }
1921           else
1922             {
1923               first_shift_count = GEN_INT (BITS_PER_WORD - shift_count);
1924               second_shift_count = GEN_INT (shift_count);
1925             }
1926
1927           into_temp1 = expand_binop (word_mode, unsigned_shift,
1928                                      outof_input, first_shift_count,
1929                                      NULL_RTX, unsignedp, next_methods);
1930           into_temp2 = expand_binop (word_mode, reverse_unsigned_shift,
1931                                      into_input, second_shift_count,
1932                                      NULL_RTX, unsignedp, next_methods);
1933
1934           if (into_temp1 != 0 && into_temp2 != 0)
1935             inter = expand_binop (word_mode, ior_optab, into_temp1, into_temp2,
1936                                   into_target, unsignedp, next_methods);
1937           else
1938             inter = 0;
1939
1940           if (inter != 0 && inter != into_target)
1941             emit_move_insn (into_target, inter);
1942
1943           outof_temp1 = expand_binop (word_mode, unsigned_shift,
1944                                       into_input, first_shift_count,
1945                                       NULL_RTX, unsignedp, next_methods);
1946           outof_temp2 = expand_binop (word_mode, reverse_unsigned_shift,
1947                                       outof_input, second_shift_count,
1948                                       NULL_RTX, unsignedp, next_methods);
1949
1950           if (inter != 0 && outof_temp1 != 0 && outof_temp2 != 0)
1951             inter = expand_binop (word_mode, ior_optab,
1952                                   outof_temp1, outof_temp2,
1953                                   outof_target, unsignedp, next_methods);
1954
1955           if (inter != 0 && inter != outof_target)
1956             emit_move_insn (outof_target, inter);
1957         }
1958
1959       insns = get_insns ();
1960       end_sequence ();
1961
1962       if (inter != 0)
1963         {
1964           emit_insn (insns);
1965           return target;
1966         }
1967     }
1968
1969   /* These can be done a word at a time by propagating carries.  */
1970   if ((binoptab == add_optab || binoptab == sub_optab)
1971       && mclass == MODE_INT
1972       && GET_MODE_SIZE (mode) >= 2 * UNITS_PER_WORD
1973       && optab_handler (binoptab, word_mode)->insn_code != CODE_FOR_nothing)
1974     {
1975       unsigned int i;
1976       optab otheroptab = binoptab == add_optab ? sub_optab : add_optab;
1977       const unsigned int nwords = GET_MODE_BITSIZE (mode) / BITS_PER_WORD;
1978       rtx carry_in = NULL_RTX, carry_out = NULL_RTX;
1979       rtx xop0, xop1, xtarget;
1980
1981       /* We can handle either a 1 or -1 value for the carry.  If STORE_FLAG
1982          value is one of those, use it.  Otherwise, use 1 since it is the
1983          one easiest to get.  */
1984 #if STORE_FLAG_VALUE == 1 || STORE_FLAG_VALUE == -1
1985       int normalizep = STORE_FLAG_VALUE;
1986 #else
1987       int normalizep = 1;
1988 #endif
1989
1990       /* Prepare the operands.  */
1991       xop0 = force_reg (mode, op0);
1992       xop1 = force_reg (mode, op1);
1993
1994       xtarget = gen_reg_rtx (mode);
1995
1996       if (target == 0 || !REG_P (target))
1997         target = xtarget;
1998
1999       /* Indicate for flow that the entire target reg is being set.  */
2000       if (REG_P (target))
2001         emit_clobber (xtarget);
2002
2003       /* Do the actual arithmetic.  */
2004       for (i = 0; i < nwords; i++)
2005         {
2006           int index = (WORDS_BIG_ENDIAN ? nwords - i - 1 : i);
2007           rtx target_piece = operand_subword (xtarget, index, 1, mode);
2008           rtx op0_piece = operand_subword_force (xop0, index, mode);
2009           rtx op1_piece = operand_subword_force (xop1, index, mode);
2010           rtx x;
2011
2012           /* Main add/subtract of the input operands.  */
2013           x = expand_binop (word_mode, binoptab,
2014                             op0_piece, op1_piece,
2015                             target_piece, unsignedp, next_methods);
2016           if (x == 0)
2017             break;
2018
2019           if (i + 1 < nwords)
2020             {
2021               /* Store carry from main add/subtract.  */
2022               carry_out = gen_reg_rtx (word_mode);
2023               carry_out = emit_store_flag_force (carry_out,
2024                                                  (binoptab == add_optab
2025                                                   ? LT : GT),
2026                                                  x, op0_piece,
2027                                                  word_mode, 1, normalizep);
2028             }
2029
2030           if (i > 0)
2031             {
2032               rtx newx;
2033
2034               /* Add/subtract previous carry to main result.  */
2035               newx = expand_binop (word_mode,
2036                                    normalizep == 1 ? binoptab : otheroptab,
2037                                    x, carry_in,
2038                                    NULL_RTX, 1, next_methods);
2039
2040               if (i + 1 < nwords)
2041                 {
2042                   /* Get out carry from adding/subtracting carry in.  */
2043                   rtx carry_tmp = gen_reg_rtx (word_mode);
2044                   carry_tmp = emit_store_flag_force (carry_tmp,
2045                                                      (binoptab == add_optab
2046                                                       ? LT : GT),
2047                                                      newx, x,
2048                                                      word_mode, 1, normalizep);
2049
2050                   /* Logical-ior the two poss. carry together.  */
2051                   carry_out = expand_binop (word_mode, ior_optab,
2052                                             carry_out, carry_tmp,
2053                                             carry_out, 0, next_methods);
2054                   if (carry_out == 0)
2055                     break;
2056                 }
2057               emit_move_insn (target_piece, newx);
2058             }
2059           else
2060             {
2061               if (x != target_piece)
2062                 emit_move_insn (target_piece, x);
2063             }
2064
2065           carry_in = carry_out;
2066         }
2067
2068       if (i == GET_MODE_BITSIZE (mode) / (unsigned) BITS_PER_WORD)
2069         {
2070           if (optab_handler (mov_optab, mode)->insn_code != CODE_FOR_nothing
2071               || ! rtx_equal_p (target, xtarget))
2072             {
2073               rtx temp = emit_move_insn (target, xtarget);
2074
2075               set_unique_reg_note (temp,
2076                                    REG_EQUAL,
2077                                    gen_rtx_fmt_ee (binoptab->code, mode,
2078                                                    copy_rtx (xop0),
2079                                                    copy_rtx (xop1)));
2080             }
2081           else
2082             target = xtarget;
2083
2084           return target;
2085         }
2086
2087       else
2088         delete_insns_since (last);
2089     }
2090
2091   /* Attempt to synthesize double word multiplies using a sequence of word
2092      mode multiplications.  We first attempt to generate a sequence using a
2093      more efficient unsigned widening multiply, and if that fails we then
2094      try using a signed widening multiply.  */
2095
2096   if (binoptab == smul_optab
2097       && mclass == MODE_INT
2098       && GET_MODE_SIZE (mode) == 2 * UNITS_PER_WORD
2099       && optab_handler (smul_optab, word_mode)->insn_code != CODE_FOR_nothing
2100       && optab_handler (add_optab, word_mode)->insn_code != CODE_FOR_nothing)
2101     {
2102       rtx product = NULL_RTX;
2103
2104       if (optab_handler (umul_widen_optab, mode)->insn_code
2105           != CODE_FOR_nothing)
2106         {
2107           product = expand_doubleword_mult (mode, op0, op1, target,
2108                                             true, methods);
2109           if (!product)
2110             delete_insns_since (last);
2111         }
2112
2113       if (product == NULL_RTX
2114           && optab_handler (smul_widen_optab, mode)->insn_code
2115              != CODE_FOR_nothing)
2116         {
2117           product = expand_doubleword_mult (mode, op0, op1, target,
2118                                             false, methods);
2119           if (!product)
2120             delete_insns_since (last);
2121         }
2122
2123       if (product != NULL_RTX)
2124         {
2125           if (optab_handler (mov_optab, mode)->insn_code != CODE_FOR_nothing)
2126             {
2127               temp = emit_move_insn (target ? target : product, product);
2128               set_unique_reg_note (temp,
2129                                    REG_EQUAL,
2130                                    gen_rtx_fmt_ee (MULT, mode,
2131                                                    copy_rtx (op0),
2132                                                    copy_rtx (op1)));
2133             }
2134           return product;
2135         }
2136     }
2137
2138   /* It can't be open-coded in this mode.
2139      Use a library call if one is available and caller says that's ok.  */
2140
2141   libfunc = optab_libfunc (binoptab, mode);
2142   if (libfunc
2143       && (methods == OPTAB_LIB || methods == OPTAB_LIB_WIDEN))
2144     {
2145       rtx insns;
2146       rtx op1x = op1;
2147       enum machine_mode op1_mode = mode;
2148       rtx value;
2149
2150       start_sequence ();
2151
2152       if (shift_optab_p (binoptab))
2153         {
2154           op1_mode = targetm.libgcc_shift_count_mode ();
2155           /* Specify unsigned here,
2156              since negative shift counts are meaningless.  */
2157           op1x = convert_to_mode (op1_mode, op1, 1);
2158         }
2159
2160       if (GET_MODE (op0) != VOIDmode
2161           && GET_MODE (op0) != mode)
2162         op0 = convert_to_mode (mode, op0, unsignedp);
2163
2164       /* Pass 1 for NO_QUEUE so we don't lose any increments
2165          if the libcall is cse'd or moved.  */
2166       value = emit_library_call_value (libfunc,
2167                                        NULL_RTX, LCT_CONST, mode, 2,
2168                                        op0, mode, op1x, op1_mode);
2169
2170       insns = get_insns ();
2171       end_sequence ();
2172
2173       target = gen_reg_rtx (mode);
2174       emit_libcall_block (insns, target, value,
2175                           gen_rtx_fmt_ee (binoptab->code, mode, op0, op1));
2176
2177       return target;
2178     }
2179
2180   delete_insns_since (last);
2181
2182   /* It can't be done in this mode.  Can we do it in a wider mode?  */
2183
2184   if (! (methods == OPTAB_WIDEN || methods == OPTAB_LIB_WIDEN
2185          || methods == OPTAB_MUST_WIDEN))
2186     {
2187       /* Caller says, don't even try.  */
2188       delete_insns_since (entry_last);
2189       return 0;
2190     }
2191
2192   /* Compute the value of METHODS to pass to recursive calls.
2193      Don't allow widening to be tried recursively.  */
2194
2195   methods = (methods == OPTAB_LIB_WIDEN ? OPTAB_LIB : OPTAB_DIRECT);
2196
2197   /* Look for a wider mode of the same class for which it appears we can do
2198      the operation.  */
2199
2200   if (CLASS_HAS_WIDER_MODES_P (mclass))
2201     {
2202       for (wider_mode = GET_MODE_WIDER_MODE (mode);
2203            wider_mode != VOIDmode;
2204            wider_mode = GET_MODE_WIDER_MODE (wider_mode))
2205         {
2206           if ((optab_handler (binoptab, wider_mode)->insn_code
2207                != CODE_FOR_nothing)
2208               || (methods == OPTAB_LIB
2209                   && optab_libfunc (binoptab, wider_mode)))
2210             {
2211               rtx xop0 = op0, xop1 = op1;
2212               int no_extend = 0;
2213
2214               /* For certain integer operations, we need not actually extend
2215                  the narrow operands, as long as we will truncate
2216                  the results to the same narrowness.  */
2217
2218               if ((binoptab == ior_optab || binoptab == and_optab
2219                    || binoptab == xor_optab
2220                    || binoptab == add_optab || binoptab == sub_optab
2221                    || binoptab == smul_optab || binoptab == ashl_optab)
2222                   && mclass == MODE_INT)
2223                 no_extend = 1;
2224
2225               xop0 = widen_operand (xop0, wider_mode, mode,
2226                                     unsignedp, no_extend);
2227
2228               /* The second operand of a shift must always be extended.  */
2229               xop1 = widen_operand (xop1, wider_mode, mode, unsignedp,
2230                                     no_extend && binoptab != ashl_optab);
2231
2232               temp = expand_binop (wider_mode, binoptab, xop0, xop1, NULL_RTX,
2233                                    unsignedp, methods);
2234               if (temp)
2235                 {
2236                   if (mclass != MODE_INT
2237                       || !TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (mode),
2238                                                  GET_MODE_BITSIZE (wider_mode)))
2239                     {
2240                       if (target == 0)
2241                         target = gen_reg_rtx (mode);
2242                       convert_move (target, temp, 0);
2243                       return target;
2244                     }
2245                   else
2246                     return gen_lowpart (mode, temp);
2247                 }
2248               else
2249                 delete_insns_since (last);
2250             }
2251         }
2252     }
2253
2254   delete_insns_since (entry_last);
2255   return 0;
2256 }
2257 \f
2258 /* Expand a binary operator which has both signed and unsigned forms.
2259    UOPTAB is the optab for unsigned operations, and SOPTAB is for
2260    signed operations.
2261
2262    If we widen unsigned operands, we may use a signed wider operation instead
2263    of an unsigned wider operation, since the result would be the same.  */
2264
2265 rtx
2266 sign_expand_binop (enum machine_mode mode, optab uoptab, optab soptab,
2267                    rtx op0, rtx op1, rtx target, int unsignedp,
2268                    enum optab_methods methods)
2269 {
2270   rtx temp;
2271   optab direct_optab = unsignedp ? uoptab : soptab;
2272   struct optab wide_soptab;
2273
2274   /* Do it without widening, if possible.  */
2275   temp = expand_binop (mode, direct_optab, op0, op1, target,
2276                        unsignedp, OPTAB_DIRECT);
2277   if (temp || methods == OPTAB_DIRECT)
2278     return temp;
2279
2280   /* Try widening to a signed int.  Make a fake signed optab that
2281      hides any signed insn for direct use.  */
2282   wide_soptab = *soptab;
2283   optab_handler (&wide_soptab, mode)->insn_code = CODE_FOR_nothing;
2284   /* We don't want to generate new hash table entries from this fake
2285      optab.  */
2286   wide_soptab.libcall_gen = NULL;
2287
2288   temp = expand_binop (mode, &wide_soptab, op0, op1, target,
2289                        unsignedp, OPTAB_WIDEN);
2290
2291   /* For unsigned operands, try widening to an unsigned int.  */
2292   if (temp == 0 && unsignedp)
2293     temp = expand_binop (mode, uoptab, op0, op1, target,
2294                          unsignedp, OPTAB_WIDEN);
2295   if (temp || methods == OPTAB_WIDEN)
2296     return temp;
2297
2298   /* Use the right width lib call if that exists.  */
2299   temp = expand_binop (mode, direct_optab, op0, op1, target, unsignedp, OPTAB_LIB);
2300   if (temp || methods == OPTAB_LIB)
2301     return temp;
2302
2303   /* Must widen and use a lib call, use either signed or unsigned.  */
2304   temp = expand_binop (mode, &wide_soptab, op0, op1, target,
2305                        unsignedp, methods);
2306   if (temp != 0)
2307     return temp;
2308   if (unsignedp)
2309     return expand_binop (mode, uoptab, op0, op1, target,
2310                          unsignedp, methods);
2311   return 0;
2312 }
2313 \f
2314 /* Generate code to perform an operation specified by UNOPPTAB
2315    on operand OP0, with two results to TARG0 and TARG1.
2316    We assume that the order of the operands for the instruction
2317    is TARG0, TARG1, OP0.
2318
2319    Either TARG0 or TARG1 may be zero, but what that means is that
2320    the result is not actually wanted.  We will generate it into
2321    a dummy pseudo-reg and discard it.  They may not both be zero.
2322
2323    Returns 1 if this operation can be performed; 0 if not.  */
2324
2325 int
2326 expand_twoval_unop (optab unoptab, rtx op0, rtx targ0, rtx targ1,
2327                     int unsignedp)
2328 {
2329   enum machine_mode mode = GET_MODE (targ0 ? targ0 : targ1);
2330   enum mode_class mclass;
2331   enum machine_mode wider_mode;
2332   rtx entry_last = get_last_insn ();
2333   rtx last;
2334
2335   mclass = GET_MODE_CLASS (mode);
2336
2337   if (!targ0)
2338     targ0 = gen_reg_rtx (mode);
2339   if (!targ1)
2340     targ1 = gen_reg_rtx (mode);
2341
2342   /* Record where to go back to if we fail.  */
2343   last = get_last_insn ();
2344
2345   if (optab_handler (unoptab, mode)->insn_code != CODE_FOR_nothing)
2346     {
2347       int icode = (int) optab_handler (unoptab, mode)->insn_code;
2348       enum machine_mode mode0 = insn_data[icode].operand[2].mode;
2349       rtx pat;
2350       rtx xop0 = op0;
2351
2352       if (GET_MODE (xop0) != VOIDmode
2353           && GET_MODE (xop0) != mode0)
2354         xop0 = convert_to_mode (mode0, xop0, unsignedp);
2355
2356       /* Now, if insn doesn't accept these operands, put them into pseudos.  */
2357       if (!insn_data[icode].operand[2].predicate (xop0, mode0))
2358         xop0 = copy_to_mode_reg (mode0, xop0);
2359
2360       /* We could handle this, but we should always be called with a pseudo
2361          for our targets and all insns should take them as outputs.  */
2362       gcc_assert (insn_data[icode].operand[0].predicate (targ0, mode));
2363       gcc_assert (insn_data[icode].operand[1].predicate (targ1, mode));
2364
2365       pat = GEN_FCN (icode) (targ0, targ1, xop0);
2366       if (pat)
2367         {
2368           emit_insn (pat);
2369           return 1;
2370         }
2371       else
2372         delete_insns_since (last);
2373     }
2374
2375   /* It can't be done in this mode.  Can we do it in a wider mode?  */
2376
2377   if (CLASS_HAS_WIDER_MODES_P (mclass))
2378     {
2379       for (wider_mode = GET_MODE_WIDER_MODE (mode);
2380            wider_mode != VOIDmode;
2381            wider_mode = GET_MODE_WIDER_MODE (wider_mode))
2382         {
2383           if (optab_handler (unoptab, wider_mode)->insn_code
2384               != CODE_FOR_nothing)
2385             {
2386               rtx t0 = gen_reg_rtx (wider_mode);
2387               rtx t1 = gen_reg_rtx (wider_mode);
2388               rtx cop0 = convert_modes (wider_mode, mode, op0, unsignedp);
2389
2390               if (expand_twoval_unop (unoptab, cop0, t0, t1, unsignedp))
2391                 {
2392                   convert_move (targ0, t0, unsignedp);
2393                   convert_move (targ1, t1, unsignedp);
2394                   return 1;
2395                 }
2396               else
2397                 delete_insns_since (last);
2398             }
2399         }
2400     }
2401
2402   delete_insns_since (entry_last);
2403   return 0;
2404 }
2405 \f
2406 /* Generate code to perform an operation specified by BINOPTAB
2407    on operands OP0 and OP1, with two results to TARG1 and TARG2.
2408    We assume that the order of the operands for the instruction
2409    is TARG0, OP0, OP1, TARG1, which would fit a pattern like
2410    [(set TARG0 (operate OP0 OP1)) (set TARG1 (operate ...))].
2411
2412    Either TARG0 or TARG1 may be zero, but what that means is that
2413    the result is not actually wanted.  We will generate it into
2414    a dummy pseudo-reg and discard it.  They may not both be zero.
2415
2416    Returns 1 if this operation can be performed; 0 if not.  */
2417
2418 int
2419 expand_twoval_binop (optab binoptab, rtx op0, rtx op1, rtx targ0, rtx targ1,
2420                      int unsignedp)
2421 {
2422   enum machine_mode mode = GET_MODE (targ0 ? targ0 : targ1);
2423   enum mode_class mclass;
2424   enum machine_mode wider_mode;
2425   rtx entry_last = get_last_insn ();
2426   rtx last;
2427
2428   mclass = GET_MODE_CLASS (mode);
2429
2430   if (!targ0)
2431     targ0 = gen_reg_rtx (mode);
2432   if (!targ1)
2433     targ1 = gen_reg_rtx (mode);
2434
2435   /* Record where to go back to if we fail.  */
2436   last = get_last_insn ();
2437
2438   if (optab_handler (binoptab, mode)->insn_code != CODE_FOR_nothing)
2439     {
2440       int icode = (int) optab_handler (binoptab, mode)->insn_code;
2441       enum machine_mode mode0 = insn_data[icode].operand[1].mode;
2442       enum machine_mode mode1 = insn_data[icode].operand[2].mode;
2443       rtx pat;
2444       rtx xop0 = op0, xop1 = op1;
2445
2446       /* If we are optimizing, force expensive constants into a register.  */
2447       xop0 = avoid_expensive_constant (mode0, binoptab, xop0, unsignedp);
2448       xop1 = avoid_expensive_constant (mode1, binoptab, xop1, unsignedp);
2449
2450       /* In case the insn wants input operands in modes different from
2451          those of the actual operands, convert the operands.  It would
2452          seem that we don't need to convert CONST_INTs, but we do, so
2453          that they're properly zero-extended, sign-extended or truncated
2454          for their mode.  */
2455
2456       if (GET_MODE (op0) != mode0 && mode0 != VOIDmode)
2457         xop0 = convert_modes (mode0,
2458                               GET_MODE (op0) != VOIDmode
2459                               ? GET_MODE (op0)
2460                               : mode,
2461                               xop0, unsignedp);
2462
2463       if (GET_MODE (op1) != mode1 && mode1 != VOIDmode)
2464         xop1 = convert_modes (mode1,
2465                               GET_MODE (op1) != VOIDmode
2466                               ? GET_MODE (op1)
2467                               : mode,
2468                               xop1, unsignedp);
2469
2470       /* Now, if insn doesn't accept these operands, put them into pseudos.  */
2471       if (!insn_data[icode].operand[1].predicate (xop0, mode0))
2472         xop0 = copy_to_mode_reg (mode0, xop0);
2473
2474       if (!insn_data[icode].operand[2].predicate (xop1, mode1))
2475         xop1 = copy_to_mode_reg (mode1, xop1);
2476
2477       /* We could handle this, but we should always be called with a pseudo
2478          for our targets and all insns should take them as outputs.  */
2479       gcc_assert (insn_data[icode].operand[0].predicate (targ0, mode));
2480       gcc_assert (insn_data[icode].operand[3].predicate (targ1, mode));
2481
2482       pat = GEN_FCN (icode) (targ0, xop0, xop1, targ1);
2483       if (pat)
2484         {
2485           emit_insn (pat);
2486           return 1;
2487         }
2488       else
2489         delete_insns_since (last);
2490     }
2491
2492   /* It can't be done in this mode.  Can we do it in a wider mode?  */
2493
2494   if (CLASS_HAS_WIDER_MODES_P (mclass))
2495     {
2496       for (wider_mode = GET_MODE_WIDER_MODE (mode);
2497            wider_mode != VOIDmode;
2498            wider_mode = GET_MODE_WIDER_MODE (wider_mode))
2499         {
2500           if (optab_handler (binoptab, wider_mode)->insn_code
2501               != CODE_FOR_nothing)
2502             {
2503               rtx t0 = gen_reg_rtx (wider_mode);
2504               rtx t1 = gen_reg_rtx (wider_mode);
2505               rtx cop0 = convert_modes (wider_mode, mode, op0, unsignedp);
2506               rtx cop1 = convert_modes (wider_mode, mode, op1, unsignedp);
2507
2508               if (expand_twoval_binop (binoptab, cop0, cop1,
2509                                        t0, t1, unsignedp))
2510                 {
2511                   convert_move (targ0, t0, unsignedp);
2512                   convert_move (targ1, t1, unsignedp);
2513                   return 1;
2514                 }
2515               else
2516                 delete_insns_since (last);
2517             }
2518         }
2519     }
2520
2521   delete_insns_since (entry_last);
2522   return 0;
2523 }
2524
2525 /* Expand the two-valued library call indicated by BINOPTAB, but
2526    preserve only one of the values.  If TARG0 is non-NULL, the first
2527    value is placed into TARG0; otherwise the second value is placed
2528    into TARG1.  Exactly one of TARG0 and TARG1 must be non-NULL.  The
2529    value stored into TARG0 or TARG1 is equivalent to (CODE OP0 OP1).
2530    This routine assumes that the value returned by the library call is
2531    as if the return value was of an integral mode twice as wide as the
2532    mode of OP0.  Returns 1 if the call was successful.  */
2533
2534 bool
2535 expand_twoval_binop_libfunc (optab binoptab, rtx op0, rtx op1,
2536                              rtx targ0, rtx targ1, enum rtx_code code)
2537 {
2538   enum machine_mode mode;
2539   enum machine_mode libval_mode;
2540   rtx libval;
2541   rtx insns;
2542   rtx libfunc;
2543
2544   /* Exactly one of TARG0 or TARG1 should be non-NULL.  */
2545   gcc_assert (!targ0 != !targ1);
2546
2547   mode = GET_MODE (op0);
2548   libfunc = optab_libfunc (binoptab, mode);
2549   if (!libfunc)
2550     return false;
2551
2552   /* The value returned by the library function will have twice as
2553      many bits as the nominal MODE.  */
2554   libval_mode = smallest_mode_for_size (2 * GET_MODE_BITSIZE (mode),
2555                                         MODE_INT);
2556   start_sequence ();
2557   libval = emit_library_call_value (libfunc, NULL_RTX, LCT_CONST,
2558                                     libval_mode, 2,
2559                                     op0, mode,
2560                                     op1, mode);
2561   /* Get the part of VAL containing the value that we want.  */
2562   libval = simplify_gen_subreg (mode, libval, libval_mode,
2563                                 targ0 ? 0 : GET_MODE_SIZE (mode));
2564   insns = get_insns ();
2565   end_sequence ();
2566   /* Move the into the desired location.  */
2567   emit_libcall_block (insns, targ0 ? targ0 : targ1, libval,
2568                       gen_rtx_fmt_ee (code, mode, op0, op1));
2569
2570   return true;
2571 }
2572
2573 \f
2574 /* Wrapper around expand_unop which takes an rtx code to specify
2575    the operation to perform, not an optab pointer.  All other
2576    arguments are the same.  */
2577 rtx
2578 expand_simple_unop (enum machine_mode mode, enum rtx_code code, rtx op0,
2579                     rtx target, int unsignedp)
2580 {
2581   optab unop = code_to_optab[(int) code];
2582   gcc_assert (unop);
2583
2584   return expand_unop (mode, unop, op0, target, unsignedp);
2585 }
2586
2587 /* Try calculating
2588         (clz:narrow x)
2589    as
2590         (clz:wide (zero_extend:wide x)) - ((width wide) - (width narrow)).  */
2591 static rtx
2592 widen_clz (enum machine_mode mode, rtx op0, rtx target)
2593 {
2594   enum mode_class mclass = GET_MODE_CLASS (mode);
2595   if (CLASS_HAS_WIDER_MODES_P (mclass))
2596     {
2597       enum machine_mode wider_mode;
2598       for (wider_mode = GET_MODE_WIDER_MODE (mode);
2599            wider_mode != VOIDmode;
2600            wider_mode = GET_MODE_WIDER_MODE (wider_mode))
2601         {
2602           if (optab_handler (clz_optab, wider_mode)->insn_code
2603               != CODE_FOR_nothing)
2604             {
2605               rtx xop0, temp, last;
2606
2607               last = get_last_insn ();
2608
2609               if (target == 0)
2610                 target = gen_reg_rtx (mode);
2611               xop0 = widen_operand (op0, wider_mode, mode, true, false);
2612               temp = expand_unop (wider_mode, clz_optab, xop0, NULL_RTX, true);
2613               if (temp != 0)
2614                 temp = expand_binop (wider_mode, sub_optab, temp,
2615                                      GEN_INT (GET_MODE_BITSIZE (wider_mode)
2616                                               - GET_MODE_BITSIZE (mode)),
2617                                      target, true, OPTAB_DIRECT);
2618               if (temp == 0)
2619                 delete_insns_since (last);
2620
2621               return temp;
2622             }
2623         }
2624     }
2625   return 0;
2626 }
2627
2628 /* Try calculating clz of a double-word quantity as two clz's of word-sized
2629    quantities, choosing which based on whether the high word is nonzero.  */
2630 static rtx
2631 expand_doubleword_clz (enum machine_mode mode, rtx op0, rtx target)
2632 {
2633   rtx xop0 = force_reg (mode, op0);
2634   rtx subhi = gen_highpart (word_mode, xop0);
2635   rtx sublo = gen_lowpart (word_mode, xop0);
2636   rtx hi0_label = gen_label_rtx ();
2637   rtx after_label = gen_label_rtx ();
2638   rtx seq, temp, result;
2639
2640   /* If we were not given a target, use a word_mode register, not a
2641      'mode' register.  The result will fit, and nobody is expecting
2642      anything bigger (the return type of __builtin_clz* is int).  */
2643   if (!target)
2644     target = gen_reg_rtx (word_mode);
2645
2646   /* In any case, write to a word_mode scratch in both branches of the
2647      conditional, so we can ensure there is a single move insn setting
2648      'target' to tag a REG_EQUAL note on.  */
2649   result = gen_reg_rtx (word_mode);
2650
2651   start_sequence ();
2652
2653   /* If the high word is not equal to zero,
2654      then clz of the full value is clz of the high word.  */
2655   emit_cmp_and_jump_insns (subhi, CONST0_RTX (word_mode), EQ, 0,
2656                            word_mode, true, hi0_label);
2657
2658   temp = expand_unop_direct (word_mode, clz_optab, subhi, result, true);
2659   if (!temp)
2660     goto fail;
2661
2662   if (temp != result)
2663     convert_move (result, temp, true);
2664
2665   emit_jump_insn (gen_jump (after_label));
2666   emit_barrier ();
2667
2668   /* Else clz of the full value is clz of the low word plus the number
2669      of bits in the high word.  */
2670   emit_label (hi0_label);
2671
2672   temp = expand_unop_direct (word_mode, clz_optab, sublo, 0, true);
2673   if (!temp)
2674     goto fail;
2675   temp = expand_binop (word_mode, add_optab, temp,
2676                        GEN_INT (GET_MODE_BITSIZE (word_mode)),
2677                        result, true, OPTAB_DIRECT);
2678   if (!temp)
2679     goto fail;
2680   if (temp != result)
2681     convert_move (result, temp, true);
2682
2683   emit_label (after_label);
2684   convert_move (target, result, true);
2685
2686   seq = get_insns ();
2687   end_sequence ();
2688
2689   add_equal_note (seq, target, CLZ, xop0, 0);
2690   emit_insn (seq);
2691   return target;
2692
2693  fail:
2694   end_sequence ();
2695   return 0;
2696 }
2697
2698 /* Try calculating
2699         (bswap:narrow x)
2700    as
2701         (lshiftrt:wide (bswap:wide x) ((width wide) - (width narrow))).  */
2702 static rtx
2703 widen_bswap (enum machine_mode mode, rtx op0, rtx target)
2704 {
2705   enum mode_class mclass = GET_MODE_CLASS (mode);
2706   enum machine_mode wider_mode;
2707   rtx x, last;
2708
2709   if (!CLASS_HAS_WIDER_MODES_P (mclass))
2710     return NULL_RTX;
2711
2712   for (wider_mode = GET_MODE_WIDER_MODE (mode);
2713        wider_mode != VOIDmode;
2714        wider_mode = GET_MODE_WIDER_MODE (wider_mode))
2715     if (optab_handler (bswap_optab, wider_mode)->insn_code != CODE_FOR_nothing)
2716       goto found;
2717   return NULL_RTX;
2718
2719  found:
2720   last = get_last_insn ();
2721
2722   x = widen_operand (op0, wider_mode, mode, true, true);
2723   x = expand_unop (wider_mode, bswap_optab, x, NULL_RTX, true);
2724
2725   if (x != 0)
2726     x = expand_shift (RSHIFT_EXPR, wider_mode, x,
2727                       size_int (GET_MODE_BITSIZE (wider_mode)
2728                                 - GET_MODE_BITSIZE (mode)),
2729                       NULL_RTX, true);
2730
2731   if (x != 0)
2732     {
2733       if (target == 0)
2734         target = gen_reg_rtx (mode);
2735       emit_move_insn (target, gen_lowpart (mode, x));
2736     }
2737   else
2738     delete_insns_since (last);
2739
2740   return target;
2741 }
2742
2743 /* Try calculating bswap as two bswaps of two word-sized operands.  */
2744
2745 static rtx
2746 expand_doubleword_bswap (enum machine_mode mode, rtx op, rtx target)
2747 {
2748   rtx t0, t1;
2749
2750   t1 = expand_unop (word_mode, bswap_optab,
2751                     operand_subword_force (op, 0, mode), NULL_RTX, true);
2752   t0 = expand_unop (word_mode, bswap_optab,
2753                     operand_subword_force (op, 1, mode), NULL_RTX, true);
2754
2755   if (target == 0)
2756     target = gen_reg_rtx (mode);
2757   if (REG_P (target))
2758     emit_clobber (target);
2759   emit_move_insn (operand_subword (target, 0, 1, mode), t0);
2760   emit_move_insn (operand_subword (target, 1, 1, mode), t1);
2761
2762   return target;
2763 }
2764
2765 /* Try calculating (parity x) as (and (popcount x) 1), where
2766    popcount can also be done in a wider mode.  */
2767 static rtx
2768 expand_parity (enum machine_mode mode, rtx op0, rtx target)
2769 {
2770   enum mode_class mclass = GET_MODE_CLASS (mode);
2771   if (CLASS_HAS_WIDER_MODES_P (mclass))
2772     {
2773       enum machine_mode wider_mode;
2774       for (wider_mode = mode; wider_mode != VOIDmode;
2775            wider_mode = GET_MODE_WIDER_MODE (wider_mode))
2776         {
2777           if (optab_handler (popcount_optab, wider_mode)->insn_code
2778               != CODE_FOR_nothing)
2779             {
2780               rtx xop0, temp, last;
2781
2782               last = get_last_insn ();
2783
2784               if (target == 0)
2785                 target = gen_reg_rtx (mode);
2786               xop0 = widen_operand (op0, wider_mode, mode, true, false);
2787               temp = expand_unop (wider_mode, popcount_optab, xop0, NULL_RTX,
2788                                   true);
2789               if (temp != 0)
2790                 temp = expand_binop (wider_mode, and_optab, temp, const1_rtx,
2791                                      target, true, OPTAB_DIRECT);
2792               if (temp == 0)
2793                 delete_insns_since (last);
2794
2795               return temp;
2796             }
2797         }
2798     }
2799   return 0;
2800 }
2801
2802 /* Try calculating ctz(x) as K - clz(x & -x) ,
2803    where K is GET_MODE_BITSIZE(mode) - 1.
2804
2805    Both __builtin_ctz and __builtin_clz are undefined at zero, so we
2806    don't have to worry about what the hardware does in that case.  (If
2807    the clz instruction produces the usual value at 0, which is K, the
2808    result of this code sequence will be -1; expand_ffs, below, relies
2809    on this.  It might be nice to have it be K instead, for consistency
2810    with the (very few) processors that provide a ctz with a defined
2811    value, but that would take one more instruction, and it would be
2812    less convenient for expand_ffs anyway.  */
2813
2814 static rtx
2815 expand_ctz (enum machine_mode mode, rtx op0, rtx target)
2816 {
2817   rtx seq, temp;
2818
2819   if (optab_handler (clz_optab, mode)->insn_code == CODE_FOR_nothing)
2820     return 0;
2821
2822   start_sequence ();
2823
2824   temp = expand_unop_direct (mode, neg_optab, op0, NULL_RTX, true);
2825   if (temp)
2826     temp = expand_binop (mode, and_optab, op0, temp, NULL_RTX,
2827                          true, OPTAB_DIRECT);
2828   if (temp)
2829     temp = expand_unop_direct (mode, clz_optab, temp, NULL_RTX, true);
2830   if (temp)
2831     temp = expand_binop (mode, sub_optab, GEN_INT (GET_MODE_BITSIZE (mode) - 1),
2832                          temp, target,
2833                          true, OPTAB_DIRECT);
2834   if (temp == 0)
2835     {
2836       end_sequence ();
2837       return 0;
2838     }
2839
2840   seq = get_insns ();
2841   end_sequence ();
2842
2843   add_equal_note (seq, temp, CTZ, op0, 0);
2844   emit_insn (seq);
2845   return temp;
2846 }
2847
2848
2849 /* Try calculating ffs(x) using ctz(x) if we have that instruction, or
2850    else with the sequence used by expand_clz.
2851
2852    The ffs builtin promises to return zero for a zero value and ctz/clz
2853    may have an undefined value in that case.  If they do not give us a
2854    convenient value, we have to generate a test and branch.  */
2855 static rtx
2856 expand_ffs (enum machine_mode mode, rtx op0, rtx target)
2857 {
2858   HOST_WIDE_INT val = 0;
2859   bool defined_at_zero = false;
2860   rtx temp, seq;
2861
2862   if (optab_handler (ctz_optab, mode)->insn_code != CODE_FOR_nothing)
2863     {
2864       start_sequence ();
2865
2866       temp = expand_unop_direct (mode, ctz_optab, op0, 0, true);
2867       if (!temp)
2868         goto fail;
2869
2870       defined_at_zero = (CTZ_DEFINED_VALUE_AT_ZERO (mode, val) == 2);
2871     }
2872   else if (optab_handler (clz_optab, mode)->insn_code != CODE_FOR_nothing)
2873     {
2874       start_sequence ();
2875       temp = expand_ctz (mode, op0, 0);
2876       if (!temp)
2877         goto fail;
2878
2879       if (CLZ_DEFINED_VALUE_AT_ZERO (mode, val) == 2)
2880         {
2881           defined_at_zero = true;
2882           val = (GET_MODE_BITSIZE (mode) - 1) - val;
2883         }
2884     }
2885   else
2886     return 0;
2887
2888   if (defined_at_zero && val == -1)
2889     /* No correction needed at zero.  */;
2890   else
2891     {
2892       /* We don't try to do anything clever with the situation found
2893          on some processors (eg Alpha) where ctz(0:mode) ==
2894          bitsize(mode).  If someone can think of a way to send N to -1
2895          and leave alone all values in the range 0..N-1 (where N is a
2896          power of two), cheaper than this test-and-branch, please add it.
2897
2898          The test-and-branch is done after the operation itself, in case
2899          the operation sets condition codes that can be recycled for this.
2900          (This is true on i386, for instance.)  */
2901
2902       rtx nonzero_label = gen_label_rtx ();
2903       emit_cmp_and_jump_insns (op0, CONST0_RTX (mode), NE, 0,
2904                                mode, true, nonzero_label);
2905
2906       convert_move (temp, GEN_INT (-1), false);
2907       emit_label (nonzero_label);
2908     }
2909
2910   /* temp now has a value in the range -1..bitsize-1.  ffs is supposed
2911      to produce a value in the range 0..bitsize.  */
2912   temp = expand_binop (mode, add_optab, temp, GEN_INT (1),
2913                        target, false, OPTAB_DIRECT);
2914   if (!temp)
2915     goto fail;
2916
2917   seq = get_insns ();
2918   end_sequence ();
2919
2920   add_equal_note (seq, temp, FFS, op0, 0);
2921   emit_insn (seq);
2922   return temp;
2923
2924  fail:
2925   end_sequence ();
2926   return 0;
2927 }
2928
2929 /* Extract the OMODE lowpart from VAL, which has IMODE.  Under certain
2930    conditions, VAL may already be a SUBREG against which we cannot generate
2931    a further SUBREG.  In this case, we expect forcing the value into a
2932    register will work around the situation.  */
2933
2934 static rtx
2935 lowpart_subreg_maybe_copy (enum machine_mode omode, rtx val,
2936                            enum machine_mode imode)
2937 {
2938   rtx ret;
2939   ret = lowpart_subreg (omode, val, imode);
2940   if (ret == NULL)
2941     {
2942       val = force_reg (imode, val);
2943       ret = lowpart_subreg (omode, val, imode);
2944       gcc_assert (ret != NULL);
2945     }
2946   return ret;
2947 }
2948
2949 /* Expand a floating point absolute value or negation operation via a
2950    logical operation on the sign bit.  */
2951
2952 static rtx
2953 expand_absneg_bit (enum rtx_code code, enum machine_mode mode,
2954                    rtx op0, rtx target)
2955 {
2956   const struct real_format *fmt;
2957   int bitpos, word, nwords, i;
2958   enum machine_mode imode;
2959   HOST_WIDE_INT hi, lo;
2960   rtx temp, insns;
2961
2962   /* The format has to have a simple sign bit.  */
2963   fmt = REAL_MODE_FORMAT (mode);
2964   if (fmt == NULL)
2965     return NULL_RTX;
2966
2967   bitpos = fmt->signbit_rw;
2968   if (bitpos < 0)
2969     return NULL_RTX;
2970
2971   /* Don't create negative zeros if the format doesn't support them.  */
2972   if (code == NEG && !fmt->has_signed_zero)
2973     return NULL_RTX;
2974
2975   if (GET_MODE_SIZE (mode) <= UNITS_PER_WORD)
2976     {
2977       imode = int_mode_for_mode (mode);
2978       if (imode == BLKmode)
2979         return NULL_RTX;
2980       word = 0;
2981       nwords = 1;
2982     }
2983   else
2984     {
2985       imode = word_mode;
2986
2987       if (FLOAT_WORDS_BIG_ENDIAN)
2988         word = (GET_MODE_BITSIZE (mode) - bitpos) / BITS_PER_WORD;
2989       else
2990         word = bitpos / BITS_PER_WORD;
2991       bitpos = bitpos % BITS_PER_WORD;
2992       nwords = (GET_MODE_BITSIZE (mode) + BITS_PER_WORD - 1) / BITS_PER_WORD;
2993     }
2994
2995   if (bitpos < HOST_BITS_PER_WIDE_INT)
2996     {
2997       hi = 0;
2998       lo = (HOST_WIDE_INT) 1 << bitpos;
2999     }
3000   else
3001     {
3002       hi = (HOST_WIDE_INT) 1 << (bitpos - HOST_BITS_PER_WIDE_INT);
3003       lo = 0;
3004     }
3005   if (code == ABS)
3006     lo = ~lo, hi = ~hi;
3007
3008   if (target == 0 || target == op0)
3009     target = gen_reg_rtx (mode);
3010
3011   if (nwords > 1)
3012     {
3013       start_sequence ();
3014
3015       for (i = 0; i < nwords; ++i)
3016         {
3017           rtx targ_piece = operand_subword (target, i, 1, mode);
3018           rtx op0_piece = operand_subword_force (op0, i, mode);
3019
3020           if (i == word)
3021             {
3022               temp = expand_binop (imode, code == ABS ? and_optab : xor_optab,
3023                                    op0_piece,
3024                                    immed_double_const (lo, hi, imode),
3025                                    targ_piece, 1, OPTAB_LIB_WIDEN);
3026               if (temp != targ_piece)
3027                 emit_move_insn (targ_piece, temp);
3028             }
3029           else
3030             emit_move_insn (targ_piece, op0_piece);
3031         }
3032
3033       insns = get_insns ();
3034       end_sequence ();
3035
3036       emit_insn (insns);
3037     }
3038   else
3039     {
3040       temp = expand_binop (imode, code == ABS ? and_optab : xor_optab,
3041                            gen_lowpart (imode, op0),
3042                            immed_double_const (lo, hi, imode),
3043                            gen_lowpart (imode, target), 1, OPTAB_LIB_WIDEN);
3044       target = lowpart_subreg_maybe_copy (mode, temp, imode);
3045
3046       set_unique_reg_note (get_last_insn (), REG_EQUAL,
3047                            gen_rtx_fmt_e (code, mode, copy_rtx (op0)));
3048     }
3049
3050   return target;
3051 }
3052
3053 /* As expand_unop, but will fail rather than attempt the operation in a
3054    different mode or with a libcall.  */
3055 static rtx
3056 expand_unop_direct (enum machine_mode mode, optab unoptab, rtx op0, rtx target,
3057              int unsignedp)
3058 {
3059   if (optab_handler (unoptab, mode)->insn_code != CODE_FOR_nothing)
3060     {
3061       int icode = (int) optab_handler (unoptab, mode)->insn_code;
3062       enum machine_mode mode0 = insn_data[icode].operand[1].mode;
3063       rtx xop0 = op0;
3064       rtx last = get_last_insn ();
3065       rtx pat, temp;
3066
3067       if (target)
3068         temp = target;
3069       else
3070         temp = gen_reg_rtx (mode);
3071
3072       if (GET_MODE (xop0) != VOIDmode
3073           && GET_MODE (xop0) != mode0)
3074         xop0 = convert_to_mode (mode0, xop0, unsignedp);
3075
3076       /* Now, if insn doesn't accept our operand, put it into a pseudo.  */
3077
3078       if (!insn_data[icode].operand[1].predicate (xop0, mode0))
3079         xop0 = copy_to_mode_reg (mode0, xop0);
3080
3081       if (!insn_data[icode].operand[0].predicate (temp, mode))
3082         temp = gen_reg_rtx (mode);
3083
3084       pat = GEN_FCN (icode) (temp, xop0);
3085       if (pat)
3086         {
3087           if (INSN_P (pat) && NEXT_INSN (pat) != NULL_RTX
3088               && ! add_equal_note (pat, temp, unoptab->code, xop0, NULL_RTX))
3089             {
3090               delete_insns_since (last);
3091               return expand_unop (mode, unoptab, op0, NULL_RTX, unsignedp);
3092             }
3093
3094           emit_insn (pat);
3095
3096           return temp;
3097         }
3098       else
3099         delete_insns_since (last);
3100     }
3101   return 0;
3102 }
3103
3104 /* Generate code to perform an operation specified by UNOPTAB
3105    on operand OP0, with result having machine-mode MODE.
3106
3107    UNSIGNEDP is for the case where we have to widen the operands
3108    to perform the operation.  It says to use zero-extension.
3109
3110    If TARGET is nonzero, the value
3111    is generated there, if it is convenient to do so.
3112    In all cases an rtx is returned for the locus of the value;
3113    this may or may not be TARGET.  */
3114
3115 rtx
3116 expand_unop (enum machine_mode mode, optab unoptab, rtx op0, rtx target,
3117              int unsignedp)
3118 {
3119   enum mode_class mclass = GET_MODE_CLASS (mode);
3120   enum machine_mode wider_mode;
3121   rtx temp;
3122   rtx libfunc;
3123
3124   temp = expand_unop_direct (mode, unoptab, op0, target, unsignedp);
3125   if (temp)
3126     return temp;
3127
3128   /* It can't be done in this mode.  Can we open-code it in a wider mode?  */
3129
3130   /* Widening (or narrowing) clz needs special treatment.  */
3131   if (unoptab == clz_optab)
3132     {
3133       temp = widen_clz (mode, op0, target);
3134       if (temp)
3135         return temp;
3136
3137       if (GET_MODE_SIZE (mode) == 2 * UNITS_PER_WORD
3138           && optab_handler (unoptab, word_mode)->insn_code != CODE_FOR_nothing)
3139         {
3140           temp = expand_doubleword_clz (mode, op0, target);
3141           if (temp)
3142             return temp;
3143         }
3144
3145         goto try_libcall;
3146     }
3147
3148   /* Widening (or narrowing) bswap needs special treatment.  */
3149   if (unoptab == bswap_optab)
3150     {
3151       temp = widen_bswap (mode, op0, target);
3152       if (temp)
3153         return temp;
3154
3155       if (GET_MODE_SIZE (mode) == 2 * UNITS_PER_WORD
3156           && optab_handler (unoptab, word_mode)->insn_code != CODE_FOR_nothing)
3157         {
3158           temp = expand_doubleword_bswap (mode, op0, target);
3159           if (temp)
3160             return temp;
3161         }
3162
3163       goto try_libcall;
3164     }
3165
3166   if (CLASS_HAS_WIDER_MODES_P (mclass))
3167     for (wider_mode = GET_MODE_WIDER_MODE (mode);
3168          wider_mode != VOIDmode;
3169          wider_mode = GET_MODE_WIDER_MODE (wider_mode))
3170       {
3171         if (optab_handler (unoptab, wider_mode)->insn_code != CODE_FOR_nothing)
3172           {
3173             rtx xop0 = op0;
3174             rtx last = get_last_insn ();
3175
3176             /* For certain operations, we need not actually extend
3177                the narrow operand, as long as we will truncate the
3178                results to the same narrowness.  */
3179
3180             xop0 = widen_operand (xop0, wider_mode, mode, unsignedp,
3181                                   (unoptab == neg_optab
3182                                    || unoptab == one_cmpl_optab)
3183                                   && mclass == MODE_INT);
3184
3185             temp = expand_unop (wider_mode, unoptab, xop0, NULL_RTX,
3186                                 unsignedp);
3187
3188             if (temp)
3189               {
3190                 if (mclass != MODE_INT
3191                     || !TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (mode),
3192                                                GET_MODE_BITSIZE (wider_mode)))
3193                   {
3194                     if (target == 0)
3195                       target = gen_reg_rtx (mode);
3196                     convert_move (target, temp, 0);
3197                     return target;
3198                   }
3199                 else
3200                   return gen_lowpart (mode, temp);
3201               }
3202             else
3203               delete_insns_since (last);
3204           }
3205       }
3206
3207   /* These can be done a word at a time.  */
3208   if (unoptab == one_cmpl_optab
3209       && mclass == MODE_INT
3210       && GET_MODE_SIZE (mode) > UNITS_PER_WORD
3211       && optab_handler (unoptab, word_mode)->insn_code != CODE_FOR_nothing)
3212     {
3213       int i;
3214       rtx insns;
3215
3216       if (target == 0 || target == op0)
3217         target = gen_reg_rtx (mode);
3218
3219       start_sequence ();
3220
3221       /* Do the actual arithmetic.  */
3222       for (i = 0; i < GET_MODE_BITSIZE (mode) / BITS_PER_WORD; i++)
3223         {
3224           rtx target_piece = operand_subword (target, i, 1, mode);
3225           rtx x = expand_unop (word_mode, unoptab,
3226                                operand_subword_force (op0, i, mode),
3227                                target_piece, unsignedp);
3228
3229           if (target_piece != x)
3230             emit_move_insn (target_piece, x);
3231         }
3232
3233       insns = get_insns ();
3234       end_sequence ();
3235
3236       emit_insn (insns);
3237       return target;
3238     }
3239
3240   if (unoptab->code == NEG)
3241     {
3242       /* Try negating floating point values by flipping the sign bit.  */
3243       if (SCALAR_FLOAT_MODE_P (mode))
3244         {
3245           temp = expand_absneg_bit (NEG, mode, op0, target);
3246           if (temp)
3247             return temp;
3248         }
3249
3250       /* If there is no negation pattern, and we have no negative zero,
3251          try subtracting from zero.  */
3252       if (!HONOR_SIGNED_ZEROS (mode))
3253         {
3254           temp = expand_binop (mode, (unoptab == negv_optab
3255                                       ? subv_optab : sub_optab),
3256                                CONST0_RTX (mode), op0, target,
3257                                unsignedp, OPTAB_DIRECT);
3258           if (temp)
3259             return temp;
3260         }
3261     }
3262
3263   /* Try calculating parity (x) as popcount (x) % 2.  */
3264   if (unoptab == parity_optab)
3265     {
3266       temp = expand_parity (mode, op0, target);
3267       if (temp)
3268         return temp;
3269     }
3270
3271   /* Try implementing ffs (x) in terms of clz (x).  */
3272   if (unoptab == ffs_optab)
3273     {
3274       temp = expand_ffs (mode, op0, target);
3275       if (temp)
3276         return temp;
3277     }
3278
3279   /* Try implementing ctz (x) in terms of clz (x).  */
3280   if (unoptab == ctz_optab)
3281     {
3282       temp = expand_ctz (mode, op0, target);
3283       if (temp)
3284         return temp;
3285     }
3286
3287  try_libcall:
3288   /* Now try a library call in this mode.  */
3289   libfunc = optab_libfunc (unoptab, mode);
3290   if (libfunc)
3291     {
3292       rtx insns;
3293       rtx value;
3294       rtx eq_value;
3295       enum machine_mode outmode = mode;
3296
3297       /* All of these functions return small values.  Thus we choose to
3298          have them return something that isn't a double-word.  */
3299       if (unoptab == ffs_optab || unoptab == clz_optab || unoptab == ctz_optab
3300           || unoptab == popcount_optab || unoptab == parity_optab)
3301         outmode
3302             = GET_MODE (hard_libcall_value (TYPE_MODE (integer_type_node)));
3303
3304       start_sequence ();
3305
3306       /* Pass 1 for NO_QUEUE so we don't lose any increments
3307          if the libcall is cse'd or moved.  */
3308       value = emit_library_call_value (libfunc, NULL_RTX, LCT_CONST, outmode,
3309                                        1, op0, mode);
3310       insns = get_insns ();
3311       end_sequence ();
3312
3313       target = gen_reg_rtx (outmode);
3314       eq_value = gen_rtx_fmt_e (unoptab->code, mode, op0);
3315       if (GET_MODE_SIZE (outmode) < GET_MODE_SIZE (mode))
3316         eq_value = simplify_gen_unary (TRUNCATE, outmode, eq_value, mode);
3317       else if (GET_MODE_SIZE (outmode) > GET_MODE_SIZE (mode))
3318         eq_value = simplify_gen_unary (ZERO_EXTEND, outmode, eq_value, mode);
3319       emit_libcall_block (insns, target, value, eq_value);
3320
3321       return target;
3322     }
3323
3324   /* It can't be done in this mode.  Can we do it in a wider mode?  */
3325
3326   if (CLASS_HAS_WIDER_MODES_P (mclass))
3327     {
3328       for (wider_mode = GET_MODE_WIDER_MODE (mode);
3329            wider_mode != VOIDmode;
3330            wider_mode = GET_MODE_WIDER_MODE (wider_mode))
3331         {
3332           if ((optab_handler (unoptab, wider_mode)->insn_code
3333                != CODE_FOR_nothing)
3334               || optab_libfunc (unoptab, wider_mode))
3335             {
3336               rtx xop0 = op0;
3337               rtx last = get_last_insn ();
3338
3339               /* For certain operations, we need not actually extend
3340                  the narrow operand, as long as we will truncate the
3341                  results to the same narrowness.  */
3342
3343               xop0 = widen_operand (xop0, wider_mode, mode, unsignedp,
3344                                     (unoptab == neg_optab
3345                                      || unoptab == one_cmpl_optab)
3346                                     && mclass == MODE_INT);
3347
3348               temp = expand_unop (wider_mode, unoptab, xop0, NULL_RTX,
3349                                   unsignedp);
3350
3351               /* If we are generating clz using wider mode, adjust the
3352                  result.  */
3353               if (unoptab == clz_optab && temp != 0)
3354                 temp = expand_binop (wider_mode, sub_optab, temp,
3355                                      GEN_INT (GET_MODE_BITSIZE (wider_mode)
3356                                               - GET_MODE_BITSIZE (mode)),
3357                                      target, true, OPTAB_DIRECT);
3358
3359               if (temp)
3360                 {
3361                   if (mclass != MODE_INT)
3362                     {
3363                       if (target == 0)
3364                         target = gen_reg_rtx (mode);
3365                       convert_move (target, temp, 0);
3366                       return target;
3367                     }
3368                   else
3369                     return gen_lowpart (mode, temp);
3370                 }
3371               else
3372                 delete_insns_since (last);
3373             }
3374         }
3375     }
3376
3377   /* One final attempt at implementing negation via subtraction,
3378      this time allowing widening of the operand.  */
3379   if (unoptab->code == NEG && !HONOR_SIGNED_ZEROS (mode))
3380     {
3381       rtx temp;
3382       temp = expand_binop (mode,
3383                            unoptab == negv_optab ? subv_optab : sub_optab,
3384                            CONST0_RTX (mode), op0,
3385                            target, unsignedp, OPTAB_LIB_WIDEN);
3386       if (temp)
3387         return temp;
3388     }
3389
3390   return 0;
3391 }
3392 \f
3393 /* Emit code to compute the absolute value of OP0, with result to
3394    TARGET if convenient.  (TARGET may be 0.)  The return value says
3395    where the result actually is to be found.
3396
3397    MODE is the mode of the operand; the mode of the result is
3398    different but can be deduced from MODE.
3399
3400  */
3401
3402 rtx
3403 expand_abs_nojump (enum machine_mode mode, rtx op0, rtx target,
3404                    int result_unsignedp)
3405 {
3406   rtx temp;
3407
3408   if (! flag_trapv)
3409     result_unsignedp = 1;
3410
3411   /* First try to do it with a special abs instruction.  */
3412   temp = expand_unop (mode, result_unsignedp ? abs_optab : absv_optab,
3413                       op0, target, 0);
3414   if (temp != 0)
3415     return temp;
3416
3417   /* For floating point modes, try clearing the sign bit.  */
3418   if (SCALAR_FLOAT_MODE_P (mode))
3419     {
3420       temp = expand_absneg_bit (ABS, mode, op0, target);
3421       if (temp)
3422         return temp;
3423     }
3424
3425   /* If we have a MAX insn, we can do this as MAX (x, -x).  */
3426   if (optab_handler (smax_optab, mode)->insn_code != CODE_FOR_nothing
3427       && !HONOR_SIGNED_ZEROS (mode))
3428     {
3429       rtx last = get_last_insn ();
3430
3431       temp = expand_unop (mode, neg_optab, op0, NULL_RTX, 0);
3432       if (temp != 0)
3433         temp = expand_binop (mode, smax_optab, op0, temp, target, 0,
3434                              OPTAB_WIDEN);
3435
3436       if (temp != 0)
3437         return temp;
3438
3439       delete_insns_since (last);
3440     }
3441
3442   /* If this machine has expensive jumps, we can do integer absolute
3443      value of X as (((signed) x >> (W-1)) ^ x) - ((signed) x >> (W-1)),
3444      where W is the width of MODE.  */
3445
3446   if (GET_MODE_CLASS (mode) == MODE_INT && BRANCH_COST >= 2)
3447     {
3448       rtx extended = expand_shift (RSHIFT_EXPR, mode, op0,
3449                                    size_int (GET_MODE_BITSIZE (mode) - 1),
3450                                    NULL_RTX, 0);
3451
3452       temp = expand_binop (mode, xor_optab, extended, op0, target, 0,
3453                            OPTAB_LIB_WIDEN);
3454       if (temp != 0)
3455         temp = expand_binop (mode, result_unsignedp ? sub_optab : subv_optab,
3456                              temp, extended, target, 0, OPTAB_LIB_WIDEN);
3457
3458       if (temp != 0)
3459         return temp;
3460     }
3461
3462   return NULL_RTX;
3463 }
3464
3465 rtx
3466 expand_abs (enum machine_mode mode, rtx op0, rtx target,
3467             int result_unsignedp, int safe)
3468 {
3469   rtx temp, op1;
3470
3471   if (! flag_trapv)
3472     result_unsignedp = 1;
3473
3474   temp = expand_abs_nojump (mode, op0, target, result_unsignedp);
3475   if (temp != 0)
3476     return temp;
3477
3478   /* If that does not win, use conditional jump and negate.  */
3479
3480   /* It is safe to use the target if it is the same
3481      as the source if this is also a pseudo register */
3482   if (op0 == target && REG_P (op0)
3483       && REGNO (op0) >= FIRST_PSEUDO_REGISTER)
3484     safe = 1;
3485
3486   op1 = gen_label_rtx ();
3487   if (target == 0 || ! safe
3488       || GET_MODE (target) != mode
3489       || (MEM_P (target) && MEM_VOLATILE_P (target))
3490       || (REG_P (target)
3491           && REGNO (target) < FIRST_PSEUDO_REGISTER))
3492     target = gen_reg_rtx (mode);
3493
3494   emit_move_insn (target, op0);
3495   NO_DEFER_POP;
3496
3497   do_compare_rtx_and_jump (target, CONST0_RTX (mode), GE, 0, mode,
3498                            NULL_RTX, NULL_RTX, op1);
3499
3500   op0 = expand_unop (mode, result_unsignedp ? neg_optab : negv_optab,
3501                      target, target, 0);
3502   if (op0 != target)
3503     emit_move_insn (target, op0);
3504   emit_label (op1);
3505   OK_DEFER_POP;
3506   return target;
3507 }
3508
3509 /* A subroutine of expand_copysign, perform the copysign operation using the
3510    abs and neg primitives advertised to exist on the target.  The assumption
3511    is that we have a split register file, and leaving op0 in fp registers,
3512    and not playing with subregs so much, will help the register allocator.  */
3513
3514 static rtx
3515 expand_copysign_absneg (enum machine_mode mode, rtx op0, rtx op1, rtx target,
3516                         int bitpos, bool op0_is_abs)
3517 {
3518   enum machine_mode imode;
3519   int icode;
3520   rtx sign, label;
3521
3522   if (target == op1)
3523     target = NULL_RTX;
3524
3525   /* Check if the back end provides an insn that handles signbit for the
3526      argument's mode. */
3527   icode = (int) signbit_optab->handlers [(int) mode].insn_code;
3528   if (icode != CODE_FOR_nothing)
3529     {
3530       imode = insn_data[icode].operand[0].mode;
3531       sign = gen_reg_rtx (imode);
3532       emit_unop_insn (icode, sign, op1, UNKNOWN);
3533     }
3534   else
3535     {
3536       HOST_WIDE_INT hi, lo;
3537
3538       if (GET_MODE_SIZE (mode) <= UNITS_PER_WORD)
3539         {
3540           imode = int_mode_for_mode (mode);
3541           if (imode == BLKmode)
3542             return NULL_RTX;
3543           op1 = gen_lowpart (imode, op1);
3544         }
3545       else
3546         {
3547           int word;
3548
3549           imode = word_mode;
3550           if (FLOAT_WORDS_BIG_ENDIAN)
3551             word = (GET_MODE_BITSIZE (mode) - bitpos) / BITS_PER_WORD;
3552           else
3553             word = bitpos / BITS_PER_WORD;
3554           bitpos = bitpos % BITS_PER_WORD;
3555           op1 = operand_subword_force (op1, word, mode);
3556         }
3557
3558       if (bitpos < HOST_BITS_PER_WIDE_INT)
3559         {
3560           hi = 0;
3561           lo = (HOST_WIDE_INT) 1 << bitpos;
3562         }
3563       else
3564         {
3565           hi = (HOST_WIDE_INT) 1 << (bitpos - HOST_BITS_PER_WIDE_INT);
3566           lo = 0;
3567         }
3568
3569       sign = gen_reg_rtx (imode);
3570       sign = expand_binop (imode, and_optab, op1,
3571                            immed_double_const (lo, hi, imode),
3572                            NULL_RTX, 1, OPTAB_LIB_WIDEN);
3573     }
3574
3575   if (!op0_is_abs)
3576     {
3577       op0 = expand_unop (mode, abs_optab, op0, target, 0);
3578       if (op0 == NULL)
3579         return NULL_RTX;
3580       target = op0;
3581     }
3582   else
3583     {
3584       if (target == NULL_RTX)
3585         target = copy_to_reg (op0);
3586       else
3587         emit_move_insn (target, op0);
3588     }
3589
3590   label = gen_label_rtx ();
3591   emit_cmp_and_jump_insns (sign, const0_rtx, EQ, NULL_RTX, imode, 1, label);
3592
3593   if (GET_CODE (op0) == CONST_DOUBLE)
3594     op0 = simplify_unary_operation (NEG, mode, op0, mode);
3595   else
3596     op0 = expand_unop (mode, neg_optab, op0, target, 0);
3597   if (op0 != target)
3598     emit_move_insn (target, op0);
3599
3600   emit_label (label);
3601
3602   return target;
3603 }
3604
3605
3606 /* A subroutine of expand_copysign, perform the entire copysign operation
3607    with integer bitmasks.  BITPOS is the position of the sign bit; OP0_IS_ABS
3608    is true if op0 is known to have its sign bit clear.  */
3609
3610 static rtx
3611 expand_copysign_bit (enum machine_mode mode, rtx op0, rtx op1, rtx target,
3612                      int bitpos, bool op0_is_abs)
3613 {
3614   enum machine_mode imode;
3615   HOST_WIDE_INT hi, lo;
3616   int word, nwords, i;
3617   rtx temp, insns;
3618
3619   if (GET_MODE_SIZE (mode) <= UNITS_PER_WORD)
3620     {
3621       imode = int_mode_for_mode (mode);
3622       if (imode == BLKmode)
3623         return NULL_RTX;
3624       word = 0;
3625       nwords = 1;
3626     }
3627   else
3628     {
3629       imode = word_mode;
3630
3631       if (FLOAT_WORDS_BIG_ENDIAN)
3632         word = (GET_MODE_BITSIZE (mode) - bitpos) / BITS_PER_WORD;
3633       else
3634         word = bitpos / BITS_PER_WORD;
3635       bitpos = bitpos % BITS_PER_WORD;
3636       nwords = (GET_MODE_BITSIZE (mode) + BITS_PER_WORD - 1) / BITS_PER_WORD;
3637     }
3638
3639   if (bitpos < HOST_BITS_PER_WIDE_INT)
3640     {
3641       hi = 0;
3642       lo = (HOST_WIDE_INT) 1 << bitpos;
3643     }
3644   else
3645     {
3646       hi = (HOST_WIDE_INT) 1 << (bitpos - HOST_BITS_PER_WIDE_INT);
3647       lo = 0;
3648     }
3649
3650   if (target == 0 || target == op0 || target == op1)
3651     target = gen_reg_rtx (mode);
3652
3653   if (nwords > 1)
3654     {
3655       start_sequence ();
3656
3657       for (i = 0; i < nwords; ++i)
3658         {
3659           rtx targ_piece = operand_subword (target, i, 1, mode);
3660           rtx op0_piece = operand_subword_force (op0, i, mode);
3661
3662           if (i == word)
3663             {
3664               if (!op0_is_abs)
3665                 op0_piece = expand_binop (imode, and_optab, op0_piece,
3666                                           immed_double_const (~lo, ~hi, imode),
3667                                           NULL_RTX, 1, OPTAB_LIB_WIDEN);
3668
3669               op1 = expand_binop (imode, and_optab,
3670                                   operand_subword_force (op1, i, mode),
3671                                   immed_double_const (lo, hi, imode),
3672                                   NULL_RTX, 1, OPTAB_LIB_WIDEN);
3673
3674               temp = expand_binop (imode, ior_optab, op0_piece, op1,
3675                                    targ_piece, 1, OPTAB_LIB_WIDEN);
3676               if (temp != targ_piece)
3677                 emit_move_insn (targ_piece, temp);
3678             }
3679           else
3680             emit_move_insn (targ_piece, op0_piece);
3681         }
3682
3683       insns = get_insns ();
3684       end_sequence ();
3685
3686       emit_insn (insns);
3687     }
3688   else
3689     {
3690       op1 = expand_binop (imode, and_optab, gen_lowpart (imode, op1),
3691                           immed_double_const (lo, hi, imode),
3692                           NULL_RTX, 1, OPTAB_LIB_WIDEN);
3693
3694       op0 = gen_lowpart (imode, op0);
3695       if (!op0_is_abs)
3696         op0 = expand_binop (imode, and_optab, op0,
3697                             immed_double_const (~lo, ~hi, imode),
3698                             NULL_RTX, 1, OPTAB_LIB_WIDEN);
3699
3700       temp = expand_binop (imode, ior_optab, op0, op1,
3701                            gen_lowpart (imode, target), 1, OPTAB_LIB_WIDEN);
3702       target = lowpart_subreg_maybe_copy (mode, temp, imode);
3703     }
3704
3705   return target;
3706 }
3707
3708 /* Expand the C99 copysign operation.  OP0 and OP1 must be the same
3709    scalar floating point mode.  Return NULL if we do not know how to
3710    expand the operation inline.  */
3711
3712 rtx
3713 expand_copysign (rtx op0, rtx op1, rtx target)
3714 {
3715   enum machine_mode mode = GET_MODE (op0);
3716   const struct real_format *fmt;
3717   bool op0_is_abs;
3718   rtx temp;
3719
3720   gcc_assert (SCALAR_FLOAT_MODE_P (mode));
3721   gcc_assert (GET_MODE (op1) == mode);
3722
3723   /* First try to do it with a special instruction.  */
3724   temp = expand_binop (mode, copysign_optab, op0, op1,
3725                        target, 0, OPTAB_DIRECT);
3726   if (temp)
3727     return temp;
3728
3729   fmt = REAL_MODE_FORMAT (mode);
3730   if (fmt == NULL || !fmt->has_signed_zero)
3731     return NULL_RTX;
3732
3733   op0_is_abs = false;
3734   if (GET_CODE (op0) == CONST_DOUBLE)
3735     {
3736       if (real_isneg (CONST_DOUBLE_REAL_VALUE (op0)))
3737         op0 = simplify_unary_operation (ABS, mode, op0, mode);
3738       op0_is_abs = true;
3739     }
3740
3741   if (fmt->signbit_ro >= 0
3742       && (GET_CODE (op0) == CONST_DOUBLE
3743           || (optab_handler (neg_optab, mode)->insn_code != CODE_FOR_nothing
3744               && optab_handler (abs_optab, mode)->insn_code != CODE_FOR_nothing)))
3745     {
3746       temp = expand_copysign_absneg (mode, op0, op1, target,
3747                                      fmt->signbit_ro, op0_is_abs);
3748       if (temp)
3749         return temp;
3750     }
3751
3752   if (fmt->signbit_rw < 0)
3753     return NULL_RTX;
3754   return expand_copysign_bit (mode, op0, op1, target,
3755                               fmt->signbit_rw, op0_is_abs);
3756 }
3757 \f
3758 /* Generate an instruction whose insn-code is INSN_CODE,
3759    with two operands: an output TARGET and an input OP0.
3760    TARGET *must* be nonzero, and the output is always stored there.
3761    CODE is an rtx code such that (CODE OP0) is an rtx that describes
3762    the value that is stored into TARGET.
3763
3764    Return false if expansion failed.  */
3765
3766 bool
3767 maybe_emit_unop_insn (int icode, rtx target, rtx op0, enum rtx_code code)
3768 {
3769   rtx temp;
3770   enum machine_mode mode0 = insn_data[icode].operand[1].mode;
3771   rtx pat;
3772   rtx last = get_last_insn ();
3773
3774   temp = target;
3775
3776   /* Now, if insn does not accept our operands, put them into pseudos.  */
3777
3778   if (!insn_data[icode].operand[1].predicate (op0, mode0))
3779     op0 = copy_to_mode_reg (mode0, op0);
3780
3781   if (!insn_data[icode].operand[0].predicate (temp, GET_MODE (temp)))
3782     temp = gen_reg_rtx (GET_MODE (temp));
3783
3784   pat = GEN_FCN (icode) (temp, op0);
3785   if (!pat)
3786     {
3787       delete_insns_since (last);
3788       return false;
3789     }
3790
3791   if (INSN_P (pat) && NEXT_INSN (pat) != NULL_RTX && code != UNKNOWN)
3792     add_equal_note (pat, temp, code, op0, NULL_RTX);
3793
3794   emit_insn (pat);
3795
3796   if (temp != target)
3797     emit_move_insn (target, temp);
3798   return true;
3799 }
3800 /* Generate an instruction whose insn-code is INSN_CODE,
3801    with two operands: an output TARGET and an input OP0.
3802    TARGET *must* be nonzero, and the output is always stored there.
3803    CODE is an rtx code such that (CODE OP0) is an rtx that describes
3804    the value that is stored into TARGET.  */
3805
3806 void
3807 emit_unop_insn (int icode, rtx target, rtx op0, enum rtx_code code)
3808 {
3809   bool ok = maybe_emit_unop_insn (icode, target, op0, code);
3810   gcc_assert (ok);
3811 }
3812 \f
3813 struct no_conflict_data
3814 {
3815   rtx target, first, insn;
3816   bool must_stay;
3817 };
3818
3819 /* Called via note_stores by emit_libcall_block.  Set P->must_stay if
3820    the currently examined clobber / store has to stay in the list of
3821    insns that constitute the actual libcall block.  */
3822 static void
3823 no_conflict_move_test (rtx dest, const_rtx set, void *p0)
3824 {
3825   struct no_conflict_data *p= (struct no_conflict_data *) p0;
3826
3827   /* If this inns directly contributes to setting the target, it must stay.  */
3828   if (reg_overlap_mentioned_p (p->target, dest))
3829     p->must_stay = true;
3830   /* If we haven't committed to keeping any other insns in the list yet,
3831      there is nothing more to check.  */
3832   else if (p->insn == p->first)
3833     return;
3834   /* If this insn sets / clobbers a register that feeds one of the insns
3835      already in the list, this insn has to stay too.  */
3836   else if (reg_overlap_mentioned_p (dest, PATTERN (p->first))
3837            || (CALL_P (p->first) && (find_reg_fusage (p->first, USE, dest)))
3838            || reg_used_between_p (dest, p->first, p->insn)
3839            /* Likewise if this insn depends on a register set by a previous
3840               insn in the list, or if it sets a result (presumably a hard
3841               register) that is set or clobbered by a previous insn.
3842               N.B. the modified_*_p (SET_DEST...) tests applied to a MEM
3843               SET_DEST perform the former check on the address, and the latter
3844               check on the MEM.  */
3845            || (GET_CODE (set) == SET
3846                && (modified_in_p (SET_SRC (set), p->first)
3847                    || modified_in_p (SET_DEST (set), p->first)
3848                    || modified_between_p (SET_SRC (set), p->first, p->insn)
3849                    || modified_between_p (SET_DEST (set), p->first, p->insn))))
3850     p->must_stay = true;
3851 }
3852
3853 \f
3854 /* Emit code to make a call to a constant function or a library call.
3855
3856    INSNS is a list containing all insns emitted in the call.
3857    These insns leave the result in RESULT.  Our block is to copy RESULT
3858    to TARGET, which is logically equivalent to EQUIV.
3859
3860    We first emit any insns that set a pseudo on the assumption that these are
3861    loading constants into registers; doing so allows them to be safely cse'ed
3862    between blocks.  Then we emit all the other insns in the block, followed by
3863    an insn to move RESULT to TARGET.  This last insn will have a REQ_EQUAL
3864    note with an operand of EQUIV.  */
3865
3866 void
3867 emit_libcall_block (rtx insns, rtx target, rtx result, rtx equiv)
3868 {
3869   rtx final_dest = target;
3870   rtx prev, next, last, insn;
3871
3872   /* If this is a reg with REG_USERVAR_P set, then it could possibly turn
3873      into a MEM later.  Protect the libcall block from this change.  */
3874   if (! REG_P (target) || REG_USERVAR_P (target))
3875     target = gen_reg_rtx (GET_MODE (target));
3876
3877   /* If we're using non-call exceptions, a libcall corresponding to an
3878      operation that may trap may also trap.  */
3879   if (flag_non_call_exceptions && may_trap_p (equiv))
3880     {
3881       for (insn = insns; insn; insn = NEXT_INSN (insn))
3882         if (CALL_P (insn))
3883           {
3884             rtx note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
3885
3886             if (note != 0 && INTVAL (XEXP (note, 0)) <= 0)
3887               remove_note (insn, note);
3888           }
3889     }
3890   else
3891   /* look for any CALL_INSNs in this sequence, and attach a REG_EH_REGION
3892      reg note to indicate that this call cannot throw or execute a nonlocal
3893      goto (unless there is already a REG_EH_REGION note, in which case
3894      we update it).  */
3895     for (insn = insns; insn; insn = NEXT_INSN (insn))
3896       if (CALL_P (insn))
3897         {
3898           rtx note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
3899
3900           if (note != 0)
3901             XEXP (note, 0) = constm1_rtx;
3902           else
3903             add_reg_note (insn, REG_EH_REGION, constm1_rtx);
3904         }
3905
3906   /* First emit all insns that set pseudos.  Remove them from the list as
3907      we go.  Avoid insns that set pseudos which were referenced in previous
3908      insns.  These can be generated by move_by_pieces, for example,
3909      to update an address.  Similarly, avoid insns that reference things
3910      set in previous insns.  */
3911
3912   for (insn = insns; insn; insn = next)
3913     {
3914       rtx set = single_set (insn);
3915
3916       next = NEXT_INSN (insn);
3917
3918       if (set != 0 && REG_P (SET_DEST (set))
3919           && REGNO (SET_DEST (set)) >= FIRST_PSEUDO_REGISTER)
3920         {
3921           struct no_conflict_data data;
3922
3923           data.target = const0_rtx;
3924           data.first = insns;
3925           data.insn = insn;
3926           data.must_stay = 0;
3927           note_stores (PATTERN (insn), no_conflict_move_test, &data);
3928           if (! data.must_stay)
3929             {
3930               if (PREV_INSN (insn))
3931                 NEXT_INSN (PREV_INSN (insn)) = next;
3932               else
3933                 insns = next;
3934
3935               if (next)
3936                 PREV_INSN (next) = PREV_INSN (insn);
3937
3938               add_insn (insn);
3939             }
3940         }
3941
3942       /* Some ports use a loop to copy large arguments onto the stack.
3943          Don't move anything outside such a loop.  */
3944       if (LABEL_P (insn))
3945         break;
3946     }
3947
3948   prev = get_last_insn ();
3949
3950   /* Write the remaining insns followed by the final copy.  */
3951
3952   for (insn = insns; insn; insn = next)
3953     {
3954       next = NEXT_INSN (insn);
3955
3956       add_insn (insn);
3957     }
3958
3959   last = emit_move_insn (target, result);
3960   if (optab_handler (mov_optab, GET_MODE (target))->insn_code
3961       != CODE_FOR_nothing)
3962     set_unique_reg_note (last, REG_EQUAL, copy_rtx (equiv));
3963
3964   if (final_dest != target)
3965     emit_move_insn (final_dest, target);
3966 }
3967 \f
3968 /* Nonzero if we can perform a comparison of mode MODE straightforwardly.
3969    PURPOSE describes how this comparison will be used.  CODE is the rtx
3970    comparison code we will be using.
3971
3972    ??? Actually, CODE is slightly weaker than that.  A target is still
3973    required to implement all of the normal bcc operations, but not
3974    required to implement all (or any) of the unordered bcc operations.  */
3975
3976 int
3977 can_compare_p (enum rtx_code code, enum machine_mode mode,
3978                enum can_compare_purpose purpose)
3979 {
3980   do
3981     {
3982       if (optab_handler (cmp_optab, mode)->insn_code != CODE_FOR_nothing)
3983         {
3984           if (purpose == ccp_jump)
3985             return bcc_gen_fctn[(int) code] != NULL;
3986           else if (purpose == ccp_store_flag)
3987             return setcc_gen_code[(int) code] != CODE_FOR_nothing;
3988           else
3989             /* There's only one cmov entry point, and it's allowed to fail.  */
3990             return 1;
3991         }
3992       if (purpose == ccp_jump
3993           && optab_handler (cbranch_optab, mode)->insn_code != CODE_FOR_nothing)
3994         return 1;
3995       if (purpose == ccp_cmov
3996           && optab_handler (cmov_optab, mode)->insn_code != CODE_FOR_nothing)
3997         return 1;
3998       if (purpose == ccp_store_flag
3999           && optab_handler (cstore_optab, mode)->insn_code != CODE_FOR_nothing)
4000         return 1;
4001       mode = GET_MODE_WIDER_MODE (mode);
4002     }
4003   while (mode != VOIDmode);
4004
4005   return 0;
4006 }
4007
4008 /* This function is called when we are going to emit a compare instruction that
4009    compares the values found in *PX and *PY, using the rtl operator COMPARISON.
4010
4011    *PMODE is the mode of the inputs (in case they are const_int).
4012    *PUNSIGNEDP nonzero says that the operands are unsigned;
4013    this matters if they need to be widened.
4014
4015    If they have mode BLKmode, then SIZE specifies the size of both operands.
4016
4017    This function performs all the setup necessary so that the caller only has
4018    to emit a single comparison insn.  This setup can involve doing a BLKmode
4019    comparison or emitting a library call to perform the comparison if no insn
4020    is available to handle it.
4021    The values which are passed in through pointers can be modified; the caller
4022    should perform the comparison on the modified values.  Constant
4023    comparisons must have already been folded.  */
4024
4025 static void
4026 prepare_cmp_insn (rtx *px, rtx *py, enum rtx_code *pcomparison, rtx size,
4027                   enum machine_mode *pmode, int *punsignedp,
4028                   enum can_compare_purpose purpose)
4029 {
4030   enum machine_mode mode = *pmode;
4031   rtx x = *px, y = *py;
4032   int unsignedp = *punsignedp;
4033   rtx libfunc;
4034
4035   /* If we are inside an appropriately-short loop and we are optimizing,
4036      force expensive constants into a register.  */
4037   if (CONSTANT_P (x) && optimize
4038       && rtx_cost (x, COMPARE) > COSTS_N_INSNS (1))
4039     x = force_reg (mode, x);
4040
4041   if (CONSTANT_P (y) && optimize
4042       && rtx_cost (y, COMPARE) > COSTS_N_INSNS (1))
4043     y = force_reg (mode, y);
4044
4045 #ifdef HAVE_cc0
4046   /* Make sure if we have a canonical comparison.  The RTL
4047      documentation states that canonical comparisons are required only
4048      for targets which have cc0.  */
4049   gcc_assert (!CONSTANT_P (x) || CONSTANT_P (y));
4050 #endif
4051
4052   /* Don't let both operands fail to indicate the mode.  */
4053   if (GET_MODE (x) == VOIDmode && GET_MODE (y) == VOIDmode)
4054     x = force_reg (mode, x);
4055
4056   /* Handle all BLKmode compares.  */
4057
4058   if (mode == BLKmode)
4059     {
4060       enum machine_mode cmp_mode, result_mode;
4061       enum insn_code cmp_code;
4062       tree length_type;
4063       rtx libfunc;
4064       rtx result;
4065       rtx opalign
4066         = GEN_INT (MIN (MEM_ALIGN (x), MEM_ALIGN (y)) / BITS_PER_UNIT);
4067
4068       gcc_assert (size);
4069
4070       /* Try to use a memory block compare insn - either cmpstr
4071          or cmpmem will do.  */
4072       for (cmp_mode = GET_CLASS_NARROWEST_MODE (MODE_INT);
4073            cmp_mode != VOIDmode;
4074            cmp_mode = GET_MODE_WIDER_MODE (cmp_mode))
4075         {
4076           cmp_code = cmpmem_optab[cmp_mode];
4077           if (cmp_code == CODE_FOR_nothing)
4078             cmp_code = cmpstr_optab[cmp_mode];
4079           if (cmp_code == CODE_FOR_nothing)
4080             cmp_code = cmpstrn_optab[cmp_mode];
4081           if (cmp_code == CODE_FOR_nothing)
4082             continue;
4083
4084           /* Must make sure the size fits the insn's mode.  */
4085           if ((GET_CODE (size) == CONST_INT
4086                && INTVAL (size) >= (1 << GET_MODE_BITSIZE (cmp_mode)))
4087               || (GET_MODE_BITSIZE (GET_MODE (size))
4088                   > GET_MODE_BITSIZE (cmp_mode)))
4089             continue;
4090
4091           result_mode = insn_data[cmp_code].operand[0].mode;
4092           result = gen_reg_rtx (result_mode);
4093           size = convert_to_mode (cmp_mode, size, 1);
4094           emit_insn (GEN_FCN (cmp_code) (result, x, y, size, opalign));
4095
4096           *px = result;
4097           *py = const0_rtx;
4098           *pmode = result_mode;
4099           return;
4100         }
4101
4102       /* Otherwise call a library function, memcmp.  */
4103       libfunc = memcmp_libfunc;
4104       length_type = sizetype;
4105       result_mode = TYPE_MODE (integer_type_node);
4106       cmp_mode = TYPE_MODE (length_type);
4107       size = convert_to_mode (TYPE_MODE (length_type), size,
4108                               TYPE_UNSIGNED (length_type));
4109
4110       result = emit_library_call_value (libfunc, 0, LCT_PURE,
4111                                         result_mode, 3,
4112                                         XEXP (x, 0), Pmode,
4113                                         XEXP (y, 0), Pmode,
4114                                         size, cmp_mode);
4115       *px = result;
4116       *py = const0_rtx;
4117       *pmode = result_mode;
4118       return;
4119     }
4120
4121   /* Don't allow operands to the compare to trap, as that can put the
4122      compare and branch in different basic blocks.  */
4123   if (flag_non_call_exceptions)
4124     {
4125       if (may_trap_p (x))
4126         x = force_reg (mode, x);
4127       if (may_trap_p (y))
4128         y = force_reg (mode, y);
4129     }
4130
4131   *px = x;
4132   *py = y;
4133   if (can_compare_p (*pcomparison, mode, purpose))
4134     return;
4135
4136   /* Handle a lib call just for the mode we are using.  */
4137
4138   libfunc = optab_libfunc (cmp_optab, mode);
4139   if (libfunc && !SCALAR_FLOAT_MODE_P (mode))
4140     {
4141       rtx result;
4142
4143       /* If we want unsigned, and this mode has a distinct unsigned
4144          comparison routine, use that.  */
4145       if (unsignedp)
4146         {
4147           rtx ulibfunc = optab_libfunc (ucmp_optab, mode);
4148           if (ulibfunc)
4149             libfunc = ulibfunc;
4150         }
4151
4152       result = emit_library_call_value (libfunc, NULL_RTX, LCT_CONST,
4153                                         targetm.libgcc_cmp_return_mode (),
4154                                         2, x, mode, y, mode);
4155
4156       /* There are two kinds of comparison routines. Biased routines
4157          return 0/1/2, and unbiased routines return -1/0/1. Other parts
4158          of gcc expect that the comparison operation is equivalent
4159          to the modified comparison. For signed comparisons compare the
4160          result against 1 in the biased case, and zero in the unbiased
4161          case. For unsigned comparisons always compare against 1 after
4162          biasing the unbiased result by adding 1. This gives us a way to
4163          represent LTU. */
4164       *px = result;
4165       *pmode = word_mode;
4166       *py = const1_rtx;
4167
4168       if (!TARGET_LIB_INT_CMP_BIASED)
4169         {
4170           if (*punsignedp)
4171             *px = plus_constant (result, 1);
4172           else
4173             *py = const0_rtx;
4174         }
4175       return;
4176     }
4177
4178   gcc_assert (SCALAR_FLOAT_MODE_P (mode));
4179   prepare_float_lib_cmp (px, py, pcomparison, pmode, punsignedp);
4180 }
4181
4182 /* Before emitting an insn with code ICODE, make sure that X, which is going
4183    to be used for operand OPNUM of the insn, is converted from mode MODE to
4184    WIDER_MODE (UNSIGNEDP determines whether it is an unsigned conversion), and
4185    that it is accepted by the operand predicate.  Return the new value.  */
4186
4187 static rtx
4188 prepare_operand (int icode, rtx x, int opnum, enum machine_mode mode,
4189                  enum machine_mode wider_mode, int unsignedp)
4190 {
4191   if (mode != wider_mode)
4192     x = convert_modes (wider_mode, mode, x, unsignedp);
4193
4194   if (!insn_data[icode].operand[opnum].predicate
4195       (x, insn_data[icode].operand[opnum].mode))
4196     {
4197       if (reload_completed)
4198         return NULL_RTX;
4199       x = copy_to_mode_reg (insn_data[icode].operand[opnum].mode, x);
4200     }
4201
4202   return x;
4203 }
4204
4205 /* Subroutine of emit_cmp_and_jump_insns; this function is called when we know
4206    we can do the comparison.
4207    The arguments are the same as for emit_cmp_and_jump_insns; but LABEL may
4208    be NULL_RTX which indicates that only a comparison is to be generated.  */
4209
4210 static void
4211 emit_cmp_and_jump_insn_1 (rtx x, rtx y, enum machine_mode mode,
4212                           enum rtx_code comparison, int unsignedp, rtx label)
4213 {
4214   rtx test = gen_rtx_fmt_ee (comparison, mode, x, y);
4215   enum mode_class mclass = GET_MODE_CLASS (mode);
4216   enum machine_mode wider_mode = mode;
4217
4218   /* Try combined insns first.  */
4219   do
4220     {
4221       enum insn_code icode;
4222       PUT_MODE (test, wider_mode);
4223
4224       if (label)
4225         {
4226           icode = optab_handler (cbranch_optab, wider_mode)->insn_code;
4227
4228           if (icode != CODE_FOR_nothing
4229               && insn_data[icode].operand[0].predicate (test, wider_mode))
4230             {
4231               x = prepare_operand (icode, x, 1, mode, wider_mode, unsignedp);
4232               y = prepare_operand (icode, y, 2, mode, wider_mode, unsignedp);
4233               emit_jump_insn (GEN_FCN (icode) (test, x, y, label));
4234               return;
4235             }
4236         }
4237
4238       /* Handle some compares against zero.  */
4239       icode = (int) optab_handler (tst_optab, wider_mode)->insn_code;
4240       if (y == CONST0_RTX (mode) && icode != CODE_FOR_nothing)
4241         {
4242           x = prepare_operand (icode, x, 0, mode, wider_mode, unsignedp);
4243           emit_insn (GEN_FCN (icode) (x));
4244           if (label)
4245             emit_jump_insn (bcc_gen_fctn[(int) comparison] (label));
4246           return;
4247         }
4248
4249       /* Handle compares for which there is a directly suitable insn.  */
4250
4251       icode = (int) optab_handler (cmp_optab, wider_mode)->insn_code;
4252       if (icode != CODE_FOR_nothing)
4253         {
4254           x = prepare_operand (icode, x, 0, mode, wider_mode, unsignedp);
4255           y = prepare_operand (icode, y, 1, mode, wider_mode, unsignedp);
4256           emit_insn (GEN_FCN (icode) (x, y));
4257           if (label)
4258             emit_jump_insn (bcc_gen_fctn[(int) comparison] (label));
4259           return;
4260         }
4261
4262       if (!CLASS_HAS_WIDER_MODES_P (mclass))
4263         break;
4264
4265       wider_mode = GET_MODE_WIDER_MODE (wider_mode);
4266     }
4267   while (wider_mode != VOIDmode);
4268
4269   gcc_unreachable ();
4270 }
4271
4272 /* Generate code to compare X with Y so that the condition codes are
4273    set and to jump to LABEL if the condition is true.  If X is a
4274    constant and Y is not a constant, then the comparison is swapped to
4275    ensure that the comparison RTL has the canonical form.
4276
4277    UNSIGNEDP nonzero says that X and Y are unsigned; this matters if they
4278    need to be widened by emit_cmp_insn.  UNSIGNEDP is also used to select
4279    the proper branch condition code.
4280
4281    If X and Y have mode BLKmode, then SIZE specifies the size of both X and Y.
4282
4283    MODE is the mode of the inputs (in case they are const_int).
4284
4285    COMPARISON is the rtl operator to compare with (EQ, NE, GT, etc.).  It will
4286    be passed unchanged to emit_cmp_insn, then potentially converted into an
4287    unsigned variant based on UNSIGNEDP to select a proper jump instruction.  */
4288
4289 void
4290 emit_cmp_and_jump_insns (rtx x, rtx y, enum rtx_code comparison, rtx size,
4291                          enum machine_mode mode, int unsignedp, rtx label)
4292 {
4293   rtx op0 = x, op1 = y;
4294
4295   /* Swap operands and condition to ensure canonical RTL.  */
4296   if (swap_commutative_operands_p (x, y))
4297     {
4298       /* If we're not emitting a branch, callers are required to pass
4299          operands in an order conforming to canonical RTL.  We relax this
4300          for commutative comparisons so callers using EQ don't need to do
4301          swapping by hand.  */
4302       gcc_assert (label || (comparison == swap_condition (comparison)));
4303
4304       op0 = y, op1 = x;
4305       comparison = swap_condition (comparison);
4306     }
4307
4308 #ifdef HAVE_cc0
4309   /* If OP0 is still a constant, then both X and Y must be constants.
4310      Force X into a register to create canonical RTL.  */
4311   if (CONSTANT_P (op0))
4312     op0 = force_reg (mode, op0);
4313 #endif
4314
4315   if (unsignedp)
4316     comparison = unsigned_condition (comparison);
4317
4318   prepare_cmp_insn (&op0, &op1, &comparison, size, &mode, &unsignedp,
4319                     ccp_jump);
4320   emit_cmp_and_jump_insn_1 (op0, op1, mode, comparison, unsignedp, label);
4321 }
4322
4323 /* Like emit_cmp_and_jump_insns, but generate only the comparison.  */
4324
4325 void
4326 emit_cmp_insn (rtx x, rtx y, enum rtx_code comparison, rtx size,
4327                enum machine_mode mode, int unsignedp)
4328 {
4329   emit_cmp_and_jump_insns (x, y, comparison, size, mode, unsignedp, 0);
4330 }
4331 \f
4332 /* Emit a library call comparison between floating point X and Y.
4333    COMPARISON is the rtl operator to compare with (EQ, NE, GT, etc.).  */
4334
4335 static void
4336 prepare_float_lib_cmp (rtx *px, rtx *py, enum rtx_code *pcomparison,
4337                        enum machine_mode *pmode, int *punsignedp)
4338 {
4339   enum rtx_code comparison = *pcomparison;
4340   enum rtx_code swapped = swap_condition (comparison);
4341   enum rtx_code reversed = reverse_condition_maybe_unordered (comparison);
4342   rtx x = *px;
4343   rtx y = *py;
4344   enum machine_mode orig_mode = GET_MODE (x);
4345   enum machine_mode mode, cmp_mode;
4346   rtx value, target, insns, equiv;
4347   rtx libfunc = 0;
4348   bool reversed_p = false;
4349   cmp_mode = targetm.libgcc_cmp_return_mode ();
4350
4351   for (mode = orig_mode;
4352        mode != VOIDmode;
4353        mode = GET_MODE_WIDER_MODE (mode))
4354     {
4355       if ((libfunc = optab_libfunc (code_to_optab[comparison], mode)))
4356         break;
4357
4358       if ((libfunc = optab_libfunc (code_to_optab[swapped] , mode)))
4359         {
4360           rtx tmp;
4361           tmp = x; x = y; y = tmp;
4362           comparison = swapped;
4363           break;
4364         }
4365
4366       if ((libfunc = optab_libfunc (code_to_optab[reversed], mode))
4367           && FLOAT_LIB_COMPARE_RETURNS_BOOL (mode, reversed))
4368         {
4369           comparison = reversed;
4370           reversed_p = true;
4371           break;
4372         }
4373     }
4374
4375   gcc_assert (mode != VOIDmode);
4376
4377   if (mode != orig_mode)
4378     {
4379       x = convert_to_mode (mode, x, 0);
4380       y = convert_to_mode (mode, y, 0);
4381     }
4382
4383   /* Attach a REG_EQUAL note describing the semantics of the libcall to
4384      the RTL.  The allows the RTL optimizers to delete the libcall if the
4385      condition can be determined at compile-time.  */
4386   if (comparison == UNORDERED)
4387     {
4388       rtx temp = simplify_gen_relational (NE, cmp_mode, mode, x, x);
4389       equiv = simplify_gen_relational (NE, cmp_mode, mode, y, y);
4390       equiv = simplify_gen_ternary (IF_THEN_ELSE, cmp_mode, cmp_mode,
4391                                     temp, const_true_rtx, equiv);
4392     }
4393   else
4394     {
4395       equiv = simplify_gen_relational (comparison, cmp_mode, mode, x, y);
4396       if (! FLOAT_LIB_COMPARE_RETURNS_BOOL (mode, comparison))
4397         {
4398           rtx true_rtx, false_rtx;
4399
4400           switch (comparison)
4401             {
4402             case EQ:
4403               true_rtx = const0_rtx;
4404               false_rtx = const_true_rtx;
4405               break;
4406
4407             case NE:
4408               true_rtx = const_true_rtx;
4409               false_rtx = const0_rtx;
4410               break;
4411
4412             case GT:
4413               true_rtx = const1_rtx;
4414               false_rtx = const0_rtx;
4415               break;
4416
4417             case GE:
4418               true_rtx = const0_rtx;
4419               false_rtx = constm1_rtx;
4420               break;
4421
4422             case LT:
4423               true_rtx = constm1_rtx;
4424               false_rtx = const0_rtx;
4425               break;
4426
4427             case LE:
4428               true_rtx = const0_rtx;
4429               false_rtx = const1_rtx;
4430               break;
4431
4432             default:
4433               gcc_unreachable ();
4434             }
4435           equiv = simplify_gen_ternary (IF_THEN_ELSE, cmp_mode, cmp_mode,
4436                                         equiv, true_rtx, false_rtx);
4437         }
4438     }
4439
4440   start_sequence ();
4441   value = emit_library_call_value (libfunc, NULL_RTX, LCT_CONST,
4442                                    cmp_mode, 2, x, mode, y, mode);
4443   insns = get_insns ();
4444   end_sequence ();
4445
4446   target = gen_reg_rtx (cmp_mode);
4447   emit_libcall_block (insns, target, value, equiv);
4448
4449   if (comparison == UNORDERED
4450       || FLOAT_LIB_COMPARE_RETURNS_BOOL (mode, comparison))
4451     comparison = reversed_p ? EQ : NE;
4452
4453   *px = target;
4454   *py = const0_rtx;
4455   *pmode = cmp_mode;
4456   *pcomparison = comparison;
4457   *punsignedp = 0;
4458 }
4459 \f
4460 /* Generate code to indirectly jump to a location given in the rtx LOC.  */
4461
4462 void
4463 emit_indirect_jump (rtx loc)
4464 {
4465   if (!insn_data[(int) CODE_FOR_indirect_jump].operand[0].predicate
4466       (loc, Pmode))
4467     loc = copy_to_mode_reg (Pmode, loc);
4468
4469   emit_jump_insn (gen_indirect_jump (loc));
4470   emit_barrier ();
4471 }
4472 \f
4473 #ifdef HAVE_conditional_move
4474
4475 /* Emit a conditional move instruction if the machine supports one for that
4476    condition and machine mode.
4477
4478    OP0 and OP1 are the operands that should be compared using CODE.  CMODE is
4479    the mode to use should they be constants.  If it is VOIDmode, they cannot
4480    both be constants.
4481
4482    OP2 should be stored in TARGET if the comparison is true, otherwise OP3
4483    should be stored there.  MODE is the mode to use should they be constants.
4484    If it is VOIDmode, they cannot both be constants.
4485
4486    The result is either TARGET (perhaps modified) or NULL_RTX if the operation
4487    is not supported.  */
4488
4489 rtx
4490 emit_conditional_move (rtx target, enum rtx_code code, rtx op0, rtx op1,
4491                        enum machine_mode cmode, rtx op2, rtx op3,
4492                        enum machine_mode mode, int unsignedp)
4493 {
4494   rtx tem, subtarget, comparison, insn;
4495   enum insn_code icode;
4496   enum rtx_code reversed;
4497
4498   /* If one operand is constant, make it the second one.  Only do this
4499      if the other operand is not constant as well.  */
4500
4501   if (swap_commutative_operands_p (op0, op1))
4502     {
4503       tem = op0;
4504       op0 = op1;
4505       op1 = tem;
4506       code = swap_condition (code);
4507     }
4508
4509   /* get_condition will prefer to generate LT and GT even if the old
4510      comparison was against zero, so undo that canonicalization here since
4511      comparisons against zero are cheaper.  */
4512   if (code == LT && op1 == const1_rtx)
4513     code = LE, op1 = const0_rtx;
4514   else if (code == GT && op1 == constm1_rtx)
4515     code = GE, op1 = const0_rtx;
4516
4517   if (cmode == VOIDmode)
4518     cmode = GET_MODE (op0);
4519
4520   if (swap_commutative_operands_p (op2, op3)
4521       && ((reversed = reversed_comparison_code_parts (code, op0, op1, NULL))
4522           != UNKNOWN))
4523     {
4524       tem = op2;
4525       op2 = op3;
4526       op3 = tem;
4527       code = reversed;
4528     }
4529
4530   if (mode == VOIDmode)
4531     mode = GET_MODE (op2);
4532
4533   icode = movcc_gen_code[mode];
4534
4535   if (icode == CODE_FOR_nothing)
4536     return 0;
4537
4538   if (!target)
4539     target = gen_reg_rtx (mode);
4540
4541   subtarget = target;
4542
4543   /* If the insn doesn't accept these operands, put them in pseudos.  */
4544
4545   if (!insn_data[icode].operand[0].predicate
4546       (subtarget, insn_data[icode].operand[0].mode))
4547     subtarget = gen_reg_rtx (insn_data[icode].operand[0].mode);
4548
4549   if (!insn_data[icode].operand[2].predicate
4550       (op2, insn_data[icode].operand[2].mode))
4551     op2 = copy_to_mode_reg (insn_data[icode].operand[2].mode, op2);
4552
4553   if (!insn_data[icode].operand[3].predicate
4554       (op3, insn_data[icode].operand[3].mode))
4555     op3 = copy_to_mode_reg (insn_data[icode].operand[3].mode, op3);
4556
4557   /* Everything should now be in the suitable form, so emit the compare insn
4558      and then the conditional move.  */
4559
4560   comparison
4561     = compare_from_rtx (op0, op1, code, unsignedp, cmode, NULL_RTX);
4562
4563   /* ??? Watch for const0_rtx (nop) and const_true_rtx (unconditional)?  */
4564   /* We can get const0_rtx or const_true_rtx in some circumstances.  Just
4565      return NULL and let the caller figure out how best to deal with this
4566      situation.  */
4567   if (GET_CODE (comparison) != code)
4568     return NULL_RTX;
4569
4570   insn = GEN_FCN (icode) (subtarget, comparison, op2, op3);
4571
4572   /* If that failed, then give up.  */
4573   if (insn == 0)
4574     return 0;
4575
4576   emit_insn (insn);
4577
4578   if (subtarget != target)
4579     convert_move (target, subtarget, 0);
4580
4581   return target;
4582 }
4583
4584 /* Return nonzero if a conditional move of mode MODE is supported.
4585
4586    This function is for combine so it can tell whether an insn that looks
4587    like a conditional move is actually supported by the hardware.  If we
4588    guess wrong we lose a bit on optimization, but that's it.  */
4589 /* ??? sparc64 supports conditionally moving integers values based on fp
4590    comparisons, and vice versa.  How do we handle them?  */
4591
4592 int
4593 can_conditionally_move_p (enum machine_mode mode)
4594 {
4595   if (movcc_gen_code[mode] != CODE_FOR_nothing)
4596     return 1;
4597
4598   return 0;
4599 }
4600
4601 #endif /* HAVE_conditional_move */
4602
4603 /* Emit a conditional addition instruction if the machine supports one for that
4604    condition and machine mode.
4605
4606    OP0 and OP1 are the operands that should be compared using CODE.  CMODE is
4607    the mode to use should they be constants.  If it is VOIDmode, they cannot
4608    both be constants.
4609
4610    OP2 should be stored in TARGET if the comparison is true, otherwise OP2+OP3
4611    should be stored there.  MODE is the mode to use should they be constants.
4612    If it is VOIDmode, they cannot both be constants.
4613
4614    The result is either TARGET (perhaps modified) or NULL_RTX if the operation
4615    is not supported.  */
4616
4617 rtx
4618 emit_conditional_add (rtx target, enum rtx_code code, rtx op0, rtx op1,
4619                       enum machine_mode cmode, rtx op2, rtx op3,
4620                       enum machine_mode mode, int unsignedp)
4621 {
4622   rtx tem, subtarget, comparison, insn;
4623   enum insn_code icode;
4624   enum rtx_code reversed;
4625
4626   /* If one operand is constant, make it the second one.  Only do this
4627      if the other operand is not constant as well.  */
4628
4629   if (swap_commutative_operands_p (op0, op1))
4630     {
4631       tem = op0;
4632       op0 = op1;
4633       op1 = tem;
4634       code = swap_condition (code);
4635     }
4636
4637   /* get_condition will prefer to generate LT and GT even if the old
4638      comparison was against zero, so undo that canonicalization here since
4639      comparisons against zero are cheaper.  */
4640   if (code == LT && op1 == const1_rtx)
4641     code = LE, op1 = const0_rtx;
4642   else if (code == GT && op1 == constm1_rtx)
4643     code = GE, op1 = const0_rtx;
4644
4645   if (cmode == VOIDmode)
4646     cmode = GET_MODE (op0);
4647
4648   if (swap_commutative_operands_p (op2, op3)
4649       && ((reversed = reversed_comparison_code_parts (code, op0, op1, NULL))
4650           != UNKNOWN))
4651     {
4652       tem = op2;
4653       op2 = op3;
4654       op3 = tem;
4655       code = reversed;
4656     }
4657
4658   if (mode == VOIDmode)
4659     mode = GET_MODE (op2);
4660
4661   icode = optab_handler (addcc_optab, mode)->insn_code;
4662
4663   if (icode == CODE_FOR_nothing)
4664     return 0;
4665
4666   if (!target)
4667     target = gen_reg_rtx (mode);
4668
4669   /* If the insn doesn't accept these operands, put them in pseudos.  */
4670
4671   if (!insn_data[icode].operand[0].predicate
4672       (target, insn_data[icode].operand[0].mode))
4673     subtarget = gen_reg_rtx (insn_data[icode].operand[0].mode);
4674   else
4675     subtarget = target;
4676
4677   if (!insn_data[icode].operand[2].predicate
4678       (op2, insn_data[icode].operand[2].mode))
4679     op2 = copy_to_mode_reg (insn_data[icode].operand[2].mode, op2);
4680
4681   if (!insn_data[icode].operand[3].predicate
4682       (op3, insn_data[icode].operand[3].mode))
4683     op3 = copy_to_mode_reg (insn_data[icode].operand[3].mode, op3);
4684
4685   /* Everything should now be in the suitable form, so emit the compare insn
4686      and then the conditional move.  */
4687
4688   comparison
4689     = compare_from_rtx (op0, op1, code, unsignedp, cmode, NULL_RTX);
4690
4691   /* ??? Watch for const0_rtx (nop) and const_true_rtx (unconditional)?  */
4692   /* We can get const0_rtx or const_true_rtx in some circumstances.  Just
4693      return NULL and let the caller figure out how best to deal with this
4694      situation.  */
4695   if (GET_CODE (comparison) != code)
4696     return NULL_RTX;
4697
4698   insn = GEN_FCN (icode) (subtarget, comparison, op2, op3);
4699
4700   /* If that failed, then give up.  */
4701   if (insn == 0)
4702     return 0;
4703
4704   emit_insn (insn);
4705
4706   if (subtarget != target)
4707     convert_move (target, subtarget, 0);
4708
4709   return target;
4710 }
4711 \f
4712 /* These functions attempt to generate an insn body, rather than
4713    emitting the insn, but if the gen function already emits them, we
4714    make no attempt to turn them back into naked patterns.  */
4715
4716 /* Generate and return an insn body to add Y to X.  */
4717
4718 rtx
4719 gen_add2_insn (rtx x, rtx y)
4720 {
4721   int icode = (int) optab_handler (add_optab, GET_MODE (x))->insn_code;
4722
4723   gcc_assert (insn_data[icode].operand[0].predicate
4724               (x, insn_data[icode].operand[0].mode));
4725   gcc_assert (insn_data[icode].operand[1].predicate
4726               (x, insn_data[icode].operand[1].mode));
4727   gcc_assert (insn_data[icode].operand[2].predicate
4728               (y, insn_data[icode].operand[2].mode));
4729
4730   return GEN_FCN (icode) (x, x, y);
4731 }
4732
4733 /* Generate and return an insn body to add r1 and c,
4734    storing the result in r0.  */
4735
4736 rtx
4737 gen_add3_insn (rtx r0, rtx r1, rtx c)
4738 {
4739   int icode = (int) optab_handler (add_optab, GET_MODE (r0))->insn_code;
4740
4741   if (icode == CODE_FOR_nothing
4742       || !(insn_data[icode].operand[0].predicate
4743            (r0, insn_data[icode].operand[0].mode))
4744       || !(insn_data[icode].operand[1].predicate
4745            (r1, insn_data[icode].operand[1].mode))
4746       || !(insn_data[icode].operand[2].predicate
4747            (c, insn_data[icode].operand[2].mode)))
4748     return NULL_RTX;
4749
4750   return GEN_FCN (icode) (r0, r1, c);
4751 }
4752
4753 int
4754 have_add2_insn (rtx x, rtx y)
4755 {
4756   int icode;
4757
4758   gcc_assert (GET_MODE (x) != VOIDmode);
4759
4760   icode = (int) optab_handler (add_optab, GET_MODE (x))->insn_code;
4761
4762   if (icode == CODE_FOR_nothing)
4763     return 0;
4764
4765   if (!(insn_data[icode].operand[0].predicate
4766         (x, insn_data[icode].operand[0].mode))
4767       || !(insn_data[icode].operand[1].predicate
4768            (x, insn_data[icode].operand[1].mode))
4769       || !(insn_data[icode].operand[2].predicate
4770            (y, insn_data[icode].operand[2].mode)))
4771     return 0;
4772
4773   return 1;
4774 }
4775
4776 /* Generate and return an insn body to subtract Y from X.  */
4777
4778 rtx
4779 gen_sub2_insn (rtx x, rtx y)
4780 {
4781   int icode = (int) optab_handler (sub_optab, GET_MODE (x))->insn_code;
4782
4783   gcc_assert (insn_data[icode].operand[0].predicate
4784               (x, insn_data[icode].operand[0].mode));
4785   gcc_assert (insn_data[icode].operand[1].predicate
4786               (x, insn_data[icode].operand[1].mode));
4787   gcc_assert  (insn_data[icode].operand[2].predicate
4788                (y, insn_data[icode].operand[2].mode));
4789
4790   return GEN_FCN (icode) (x, x, y);
4791 }
4792
4793 /* Generate and return an insn body to subtract r1 and c,
4794    storing the result in r0.  */
4795
4796 rtx
4797 gen_sub3_insn (rtx r0, rtx r1, rtx c)
4798 {
4799   int icode = (int) optab_handler (sub_optab, GET_MODE (r0))->insn_code;
4800
4801   if (icode == CODE_FOR_nothing
4802       || !(insn_data[icode].operand[0].predicate
4803            (r0, insn_data[icode].operand[0].mode))
4804       || !(insn_data[icode].operand[1].predicate
4805            (r1, insn_data[icode].operand[1].mode))
4806       || !(insn_data[icode].operand[2].predicate
4807            (c, insn_data[icode].operand[2].mode)))
4808     return NULL_RTX;
4809
4810   return GEN_FCN (icode) (r0, r1, c);
4811 }
4812
4813 int
4814 have_sub2_insn (rtx x, rtx y)
4815 {
4816   int icode;
4817
4818   gcc_assert (GET_MODE (x) != VOIDmode);
4819
4820   icode = (int) optab_handler (sub_optab, GET_MODE (x))->insn_code;
4821
4822   if (icode == CODE_FOR_nothing)
4823     return 0;
4824
4825   if (!(insn_data[icode].operand[0].predicate
4826         (x, insn_data[icode].operand[0].mode))
4827       || !(insn_data[icode].operand[1].predicate
4828            (x, insn_data[icode].operand[1].mode))
4829       || !(insn_data[icode].operand[2].predicate
4830            (y, insn_data[icode].operand[2].mode)))
4831     return 0;
4832
4833   return 1;
4834 }
4835
4836 /* Generate the body of an instruction to copy Y into X.
4837    It may be a list of insns, if one insn isn't enough.  */
4838
4839 rtx
4840 gen_move_insn (rtx x, rtx y)
4841 {
4842   rtx seq;
4843
4844   start_sequence ();
4845   emit_move_insn_1 (x, y);
4846   seq = get_insns ();
4847   end_sequence ();
4848   return seq;
4849 }
4850 \f
4851 /* Return the insn code used to extend FROM_MODE to TO_MODE.
4852    UNSIGNEDP specifies zero-extension instead of sign-extension.  If
4853    no such operation exists, CODE_FOR_nothing will be returned.  */
4854
4855 enum insn_code
4856 can_extend_p (enum machine_mode to_mode, enum machine_mode from_mode,
4857               int unsignedp)
4858 {
4859   convert_optab tab;
4860 #ifdef HAVE_ptr_extend
4861   if (unsignedp < 0)
4862     return CODE_FOR_ptr_extend;
4863 #endif
4864
4865   tab = unsignedp ? zext_optab : sext_optab;
4866   return convert_optab_handler (tab, to_mode, from_mode)->insn_code;
4867 }
4868
4869 /* Generate the body of an insn to extend Y (with mode MFROM)
4870    into X (with mode MTO).  Do zero-extension if UNSIGNEDP is nonzero.  */
4871
4872 rtx
4873 gen_extend_insn (rtx x, rtx y, enum machine_mode mto,
4874                  enum machine_mode mfrom, int unsignedp)
4875 {
4876   enum insn_code icode = can_extend_p (mto, mfrom, unsignedp);
4877   return GEN_FCN (icode) (x, y);
4878 }
4879 \f
4880 /* can_fix_p and can_float_p say whether the target machine
4881    can directly convert a given fixed point type to
4882    a given floating point type, or vice versa.
4883    The returned value is the CODE_FOR_... value to use,
4884    or CODE_FOR_nothing if these modes cannot be directly converted.
4885
4886    *TRUNCP_PTR is set to 1 if it is necessary to output
4887    an explicit FTRUNC insn before the fix insn; otherwise 0.  */
4888
4889 static enum insn_code
4890 can_fix_p (enum machine_mode fixmode, enum machine_mode fltmode,
4891            int unsignedp, int *truncp_ptr)
4892 {
4893   convert_optab tab;
4894   enum insn_code icode;
4895
4896   tab = unsignedp ? ufixtrunc_optab : sfixtrunc_optab;
4897   icode = convert_optab_handler (tab, fixmode, fltmode)->insn_code;
4898   if (icode != CODE_FOR_nothing)
4899     {
4900       *truncp_ptr = 0;
4901       return icode;
4902     }
4903
4904   /* FIXME: This requires a port to define both FIX and FTRUNC pattern
4905      for this to work. We need to rework the fix* and ftrunc* patterns
4906      and documentation.  */
4907   tab = unsignedp ? ufix_optab : sfix_optab;
4908   icode = convert_optab_handler (tab, fixmode, fltmode)->insn_code;
4909   if (icode != CODE_FOR_nothing
4910       && optab_handler (ftrunc_optab, fltmode)->insn_code != CODE_FOR_nothing)
4911     {
4912       *truncp_ptr = 1;
4913       return icode;
4914     }
4915
4916   *truncp_ptr = 0;
4917   return CODE_FOR_nothing;
4918 }
4919
4920 static enum insn_code
4921 can_float_p (enum machine_mode fltmode, enum machine_mode fixmode,
4922              int unsignedp)
4923 {
4924   convert_optab tab;
4925
4926   tab = unsignedp ? ufloat_optab : sfloat_optab;
4927   return convert_optab_handler (tab, fltmode, fixmode)->insn_code;
4928 }
4929 \f
4930 /* Generate code to convert FROM to floating point
4931    and store in TO.  FROM must be fixed point and not VOIDmode.
4932    UNSIGNEDP nonzero means regard FROM as unsigned.
4933    Normally this is done by correcting the final value
4934    if it is negative.  */
4935
4936 void
4937 expand_float (rtx to, rtx from, int unsignedp)
4938 {
4939   enum insn_code icode;
4940   rtx target = to;
4941   enum machine_mode fmode, imode;
4942   bool can_do_signed = false;
4943
4944   /* Crash now, because we won't be able to decide which mode to use.  */
4945   gcc_assert (GET_MODE (from) != VOIDmode);
4946
4947   /* Look for an insn to do the conversion.  Do it in the specified
4948      modes if possible; otherwise convert either input, output or both to
4949      wider mode.  If the integer mode is wider than the mode of FROM,
4950      we can do the conversion signed even if the input is unsigned.  */
4951
4952   for (fmode = GET_MODE (to); fmode != VOIDmode;
4953        fmode = GET_MODE_WIDER_MODE (fmode))
4954     for (imode = GET_MODE (from); imode != VOIDmode;
4955          imode = GET_MODE_WIDER_MODE (imode))
4956       {
4957         int doing_unsigned = unsignedp;
4958
4959         if (fmode != GET_MODE (to)
4960             && significand_size (fmode) < GET_MODE_BITSIZE (GET_MODE (from)))
4961           continue;
4962
4963         icode = can_float_p (fmode, imode, unsignedp);
4964         if (icode == CODE_FOR_nothing && unsignedp)
4965           {
4966             enum insn_code scode = can_float_p (fmode, imode, 0);
4967             if (scode != CODE_FOR_nothing)
4968               can_do_signed = true;
4969             if (imode != GET_MODE (from))
4970               icode = scode, doing_unsigned = 0;
4971           }
4972
4973         if (icode != CODE_FOR_nothing)
4974           {
4975             if (imode != GET_MODE (from))
4976               from = convert_to_mode (imode, from, unsignedp);
4977
4978             if (fmode != GET_MODE (to))
4979               target = gen_reg_rtx (fmode);
4980
4981             emit_unop_insn (icode, target, from,
4982                             doing_unsigned ? UNSIGNED_FLOAT : FLOAT);
4983
4984             if (target != to)
4985               convert_move (to, target, 0);
4986             return;
4987           }
4988       }
4989
4990   /* Unsigned integer, and no way to convert directly.  Convert as signed,
4991      then unconditionally adjust the result.  */
4992   if (unsignedp && can_do_signed)
4993     {
4994       rtx label = gen_label_rtx ();
4995       rtx temp;
4996       REAL_VALUE_TYPE offset;
4997
4998       /* Look for a usable floating mode FMODE wider than the source and at
4999          least as wide as the target.  Using FMODE will avoid rounding woes
5000          with unsigned values greater than the signed maximum value.  */
5001
5002       for (fmode = GET_MODE (to);  fmode != VOIDmode;
5003            fmode = GET_MODE_WIDER_MODE (fmode))
5004         if (GET_MODE_BITSIZE (GET_MODE (from)) < GET_MODE_BITSIZE (fmode)
5005             && can_float_p (fmode, GET_MODE (from), 0) != CODE_FOR_nothing)
5006           break;
5007
5008       if (fmode == VOIDmode)
5009         {
5010           /* There is no such mode.  Pretend the target is wide enough.  */
5011           fmode = GET_MODE (to);
5012
5013           /* Avoid double-rounding when TO is narrower than FROM.  */
5014           if ((significand_size (fmode) + 1)
5015               < GET_MODE_BITSIZE (GET_MODE (from)))
5016             {
5017               rtx temp1;
5018               rtx neglabel = gen_label_rtx ();
5019
5020               /* Don't use TARGET if it isn't a register, is a hard register,
5021                  or is the wrong mode.  */
5022               if (!REG_P (target)
5023                   || REGNO (target) < FIRST_PSEUDO_REGISTER
5024                   || GET_MODE (target) != fmode)
5025                 target = gen_reg_rtx (fmode);
5026
5027               imode = GET_MODE (from);
5028               do_pending_stack_adjust ();
5029
5030               /* Test whether the sign bit is set.  */
5031               emit_cmp_and_jump_insns (from, const0_rtx, LT, NULL_RTX, imode,
5032                                        0, neglabel);
5033
5034               /* The sign bit is not set.  Convert as signed.  */
5035               expand_float (target, from, 0);
5036               emit_jump_insn (gen_jump (label));
5037               emit_barrier ();
5038
5039               /* The sign bit is set.
5040                  Convert to a usable (positive signed) value by shifting right
5041                  one bit, while remembering if a nonzero bit was shifted
5042                  out; i.e., compute  (from & 1) | (from >> 1).  */
5043
5044               emit_label (neglabel);
5045               temp = expand_binop (imode, and_optab, from, const1_rtx,
5046                                    NULL_RTX, 1, OPTAB_LIB_WIDEN);
5047               temp1 = expand_shift (RSHIFT_EXPR, imode, from, integer_one_node,
5048                                     NULL_RTX, 1);
5049               temp = expand_binop (imode, ior_optab, temp, temp1, temp, 1,
5050                                    OPTAB_LIB_WIDEN);
5051               expand_float (target, temp, 0);
5052
5053               /* Multiply by 2 to undo the shift above.  */
5054               temp = expand_binop (fmode, add_optab, target, target,
5055                                    target, 0, OPTAB_LIB_WIDEN);
5056               if (temp != target)
5057                 emit_move_insn (target, temp);
5058
5059               do_pending_stack_adjust ();
5060               emit_label (label);
5061               goto done;
5062             }
5063         }
5064
5065       /* If we are about to do some arithmetic to correct for an
5066          unsigned operand, do it in a pseudo-register.  */
5067
5068       if (GET_MODE (to) != fmode
5069           || !REG_P (to) || REGNO (to) < FIRST_PSEUDO_REGISTER)
5070         target = gen_reg_rtx (fmode);
5071
5072       /* Convert as signed integer to floating.  */
5073       expand_float (target, from, 0);
5074
5075       /* If FROM is negative (and therefore TO is negative),
5076          correct its value by 2**bitwidth.  */
5077
5078       do_pending_stack_adjust ();
5079       emit_cmp_and_jump_insns (from, const0_rtx, GE, NULL_RTX, GET_MODE (from),
5080                                0, label);
5081
5082
5083       real_2expN (&offset, GET_MODE_BITSIZE (GET_MODE (from)), fmode);
5084       temp = expand_binop (fmode, add_optab, target,
5085                            CONST_DOUBLE_FROM_REAL_VALUE (offset, fmode),
5086                            target, 0, OPTAB_LIB_WIDEN);
5087       if (temp != target)
5088         emit_move_insn (target, temp);
5089
5090       do_pending_stack_adjust ();
5091       emit_label (label);
5092       goto done;
5093     }
5094
5095   /* No hardware instruction available; call a library routine.  */
5096     {
5097       rtx libfunc;
5098       rtx insns;
5099       rtx value;
5100       convert_optab tab = unsignedp ? ufloat_optab : sfloat_optab;
5101
5102       if (GET_MODE_SIZE (GET_MODE (from)) < GET_MODE_SIZE (SImode))
5103         from = convert_to_mode (SImode, from, unsignedp);
5104
5105       libfunc = convert_optab_libfunc (tab, GET_MODE (to), GET_MODE (from));
5106       gcc_assert (libfunc);
5107
5108       start_sequence ();
5109
5110       value = emit_library_call_value (libfunc, NULL_RTX, LCT_CONST,
5111                                        GET_MODE (to), 1, from,
5112                                        GET_MODE (from));
5113       insns = get_insns ();
5114       end_sequence ();
5115
5116       emit_libcall_block (insns, target, value,
5117                           gen_rtx_fmt_e (unsignedp ? UNSIGNED_FLOAT : FLOAT,
5118                                          GET_MODE (to), from));
5119     }
5120
5121  done:
5122
5123   /* Copy result to requested destination
5124      if we have been computing in a temp location.  */
5125
5126   if (target != to)
5127     {
5128       if (GET_MODE (target) == GET_MODE (to))
5129         emit_move_insn (to, target);
5130       else
5131         convert_move (to, target, 0);
5132     }
5133 }
5134 \f
5135 /* Generate code to convert FROM to fixed point and store in TO.  FROM
5136    must be floating point.  */
5137
5138 void
5139 expand_fix (rtx to, rtx from, int unsignedp)
5140 {
5141   enum insn_code icode;
5142   rtx target = to;
5143   enum machine_mode fmode, imode;
5144   int must_trunc = 0;
5145
5146   /* We first try to find a pair of modes, one real and one integer, at
5147      least as wide as FROM and TO, respectively, in which we can open-code
5148      this conversion.  If the integer mode is wider than the mode of TO,
5149      we can do the conversion either signed or unsigned.  */
5150
5151   for (fmode = GET_MODE (from); fmode != VOIDmode;
5152        fmode = GET_MODE_WIDER_MODE (fmode))
5153     for (imode = GET_MODE (to); imode != VOIDmode;
5154          imode = GET_MODE_WIDER_MODE (imode))
5155       {
5156         int doing_unsigned = unsignedp;
5157
5158         icode = can_fix_p (imode, fmode, unsignedp, &must_trunc);
5159         if (icode == CODE_FOR_nothing && imode != GET_MODE (to) && unsignedp)
5160           icode = can_fix_p (imode, fmode, 0, &must_trunc), doing_unsigned = 0;
5161
5162         if (icode != CODE_FOR_nothing)
5163           {
5164             rtx last = get_last_insn ();
5165             if (fmode != GET_MODE (from))
5166               from = convert_to_mode (fmode, from, 0);
5167
5168             if (must_trunc)
5169               {
5170                 rtx temp = gen_reg_rtx (GET_MODE (from));
5171                 from = expand_unop (GET_MODE (from), ftrunc_optab, from,
5172                                     temp, 0);
5173               }
5174
5175             if (imode != GET_MODE (to))
5176               target = gen_reg_rtx (imode);
5177
5178             if (maybe_emit_unop_insn (icode, target, from,
5179                                       doing_unsigned ? UNSIGNED_FIX : FIX))
5180               {
5181                 if (target != to)
5182                   convert_move (to, target, unsignedp);
5183                 return;
5184               }
5185             delete_insns_since (last);
5186           }
5187       }
5188
5189   /* For an unsigned conversion, there is one more way to do it.
5190      If we have a signed conversion, we generate code that compares
5191      the real value to the largest representable positive number.  If if
5192      is smaller, the conversion is done normally.  Otherwise, subtract
5193      one plus the highest signed number, convert, and add it back.
5194
5195      We only need to check all real modes, since we know we didn't find
5196      anything with a wider integer mode.
5197
5198      This code used to extend FP value into mode wider than the destination.
5199      This is needed for decimal float modes which cannot accurately
5200      represent one plus the highest signed number of the same size, but
5201      not for binary modes.  Consider, for instance conversion from SFmode
5202      into DImode.
5203
5204      The hot path through the code is dealing with inputs smaller than 2^63
5205      and doing just the conversion, so there is no bits to lose.
5206
5207      In the other path we know the value is positive in the range 2^63..2^64-1
5208      inclusive.  (as for other input overflow happens and result is undefined)
5209      So we know that the most important bit set in mantissa corresponds to
5210      2^63.  The subtraction of 2^63 should not generate any rounding as it
5211      simply clears out that bit.  The rest is trivial.  */
5212
5213   if (unsignedp && GET_MODE_BITSIZE (GET_MODE (to)) <= HOST_BITS_PER_WIDE_INT)
5214     for (fmode = GET_MODE (from); fmode != VOIDmode;
5215          fmode = GET_MODE_WIDER_MODE (fmode))
5216       if (CODE_FOR_nothing != can_fix_p (GET_MODE (to), fmode, 0, &must_trunc)
5217           && (!DECIMAL_FLOAT_MODE_P (fmode)
5218               || GET_MODE_BITSIZE (fmode) > GET_MODE_BITSIZE (GET_MODE (to))))
5219         {
5220           int bitsize;
5221           REAL_VALUE_TYPE offset;
5222           rtx limit, lab1, lab2, insn;
5223
5224           bitsize = GET_MODE_BITSIZE (GET_MODE (to));
5225           real_2expN (&offset, bitsize - 1, fmode);
5226           limit = CONST_DOUBLE_FROM_REAL_VALUE (offset, fmode);
5227           lab1 = gen_label_rtx ();
5228           lab2 = gen_label_rtx ();
5229
5230           if (fmode != GET_MODE (from))
5231             from = convert_to_mode (fmode, from, 0);
5232
5233           /* See if we need to do the subtraction.  */
5234           do_pending_stack_adjust ();
5235           emit_cmp_and_jump_insns (from, limit, GE, NULL_RTX, GET_MODE (from),
5236                                    0, lab1);
5237
5238           /* If not, do the signed "fix" and branch around fixup code.  */
5239           expand_fix (to, from, 0);
5240           emit_jump_insn (gen_jump (lab2));
5241           emit_barrier ();
5242
5243           /* Otherwise, subtract 2**(N-1), convert to signed number,
5244              then add 2**(N-1).  Do the addition using XOR since this
5245              will often generate better code.  */
5246           emit_label (lab1);
5247           target = expand_binop (GET_MODE (from), sub_optab, from, limit,
5248                                  NULL_RTX, 0, OPTAB_LIB_WIDEN);
5249           expand_fix (to, target, 0);
5250           target = expand_binop (GET_MODE (to), xor_optab, to,
5251                                  gen_int_mode
5252                                  ((HOST_WIDE_INT) 1 << (bitsize - 1),
5253                                   GET_MODE (to)),
5254                                  to, 1, OPTAB_LIB_WIDEN);
5255
5256           if (target != to)
5257             emit_move_insn (to, target);
5258
5259           emit_label (lab2);
5260
5261           if (optab_handler (mov_optab, GET_MODE (to))->insn_code
5262               != CODE_FOR_nothing)
5263             {
5264               /* Make a place for a REG_NOTE and add it.  */
5265               insn = emit_move_insn (to, to);
5266               set_unique_reg_note (insn,
5267                                    REG_EQUAL,
5268                                    gen_rtx_fmt_e (UNSIGNED_FIX,
5269                                                   GET_MODE (to),
5270                                                   copy_rtx (from)));
5271             }
5272
5273           return;
5274         }
5275
5276   /* We can't do it with an insn, so use a library call.  But first ensure
5277      that the mode of TO is at least as wide as SImode, since those are the
5278      only library calls we know about.  */
5279
5280   if (GET_MODE_SIZE (GET_MODE (to)) < GET_MODE_SIZE (SImode))
5281     {
5282       target = gen_reg_rtx (SImode);
5283
5284       expand_fix (target, from, unsignedp);
5285     }
5286   else
5287     {
5288       rtx insns;
5289       rtx value;
5290       rtx libfunc;
5291
5292       convert_optab tab = unsignedp ? ufix_optab : sfix_optab;
5293       libfunc = convert_optab_libfunc (tab, GET_MODE (to), GET_MODE (from));
5294       gcc_assert (libfunc);
5295
5296       start_sequence ();
5297
5298       value = emit_library_call_value (libfunc, NULL_RTX, LCT_CONST,
5299                                        GET_MODE (to), 1, from,
5300                                        GET_MODE (from));
5301       insns = get_insns ();
5302       end_sequence ();
5303
5304       emit_libcall_block (insns, target, value,
5305                           gen_rtx_fmt_e (unsignedp ? UNSIGNED_FIX : FIX,
5306                                          GET_MODE (to), from));
5307     }
5308
5309   if (target != to)
5310     {
5311       if (GET_MODE (to) == GET_MODE (target))
5312         emit_move_insn (to, target);
5313       else
5314         convert_move (to, target, 0);
5315     }
5316 }
5317
5318 /* Generate code to convert FROM or TO a fixed-point.
5319    If UINTP is true, either TO or FROM is an unsigned integer.
5320    If SATP is true, we need to saturate the result.  */
5321
5322 void
5323 expand_fixed_convert (rtx to, rtx from, int uintp, int satp)
5324 {
5325   enum machine_mode to_mode = GET_MODE (to);
5326   enum machine_mode from_mode = GET_MODE (from);
5327   convert_optab tab;
5328   enum rtx_code this_code;
5329   enum insn_code code;
5330   rtx insns, value;
5331   rtx libfunc;
5332
5333   if (to_mode == from_mode)
5334     {
5335       emit_move_insn (to, from);
5336       return;
5337     }
5338
5339   if (uintp)
5340     {
5341       tab = satp ? satfractuns_optab : fractuns_optab;
5342       this_code = satp ? UNSIGNED_SAT_FRACT : UNSIGNED_FRACT_CONVERT;
5343     }
5344   else
5345     {
5346       tab = satp ? satfract_optab : fract_optab;
5347       this_code = satp ? SAT_FRACT : FRACT_CONVERT;
5348     }
5349   code = tab->handlers[to_mode][from_mode].insn_code;
5350   if (code != CODE_FOR_nothing)
5351     {
5352       emit_unop_insn (code, to, from, this_code);
5353       return;
5354     }
5355
5356   libfunc = convert_optab_libfunc (tab, to_mode, from_mode);
5357   gcc_assert (libfunc);
5358
5359   start_sequence ();
5360   value = emit_library_call_value (libfunc, NULL_RTX, LCT_CONST, to_mode,
5361                                    1, from, from_mode);
5362   insns = get_insns ();
5363   end_sequence ();
5364
5365   emit_libcall_block (insns, to, value,
5366                       gen_rtx_fmt_e (tab->code, to_mode, from));
5367 }
5368
5369 /* Generate code to convert FROM to fixed point and store in TO.  FROM
5370    must be floating point, TO must be signed.  Use the conversion optab
5371    TAB to do the conversion.  */
5372
5373 bool
5374 expand_sfix_optab (rtx to, rtx from, convert_optab tab)
5375 {
5376   enum insn_code icode;
5377   rtx target = to;
5378   enum machine_mode fmode, imode;
5379
5380   /* We first try to find a pair of modes, one real and one integer, at
5381      least as wide as FROM and TO, respectively, in which we can open-code
5382      this conversion.  If the integer mode is wider than the mode of TO,
5383      we can do the conversion either signed or unsigned.  */
5384
5385   for (fmode = GET_MODE (from); fmode != VOIDmode;
5386        fmode = GET_MODE_WIDER_MODE (fmode))
5387     for (imode = GET_MODE (to); imode != VOIDmode;
5388          imode = GET_MODE_WIDER_MODE (imode))
5389       {
5390         icode = convert_optab_handler (tab, imode, fmode)->insn_code;
5391         if (icode != CODE_FOR_nothing)
5392           {
5393             rtx last = get_last_insn ();
5394             if (fmode != GET_MODE (from))
5395               from = convert_to_mode (fmode, from, 0);
5396
5397             if (imode != GET_MODE (to))
5398               target = gen_reg_rtx (imode);
5399
5400             if (!maybe_emit_unop_insn (icode, target, from, UNKNOWN))
5401               {
5402                 delete_insns_since (last);
5403                 continue;
5404               }
5405             if (target != to)
5406               convert_move (to, target, 0);
5407             return true;
5408           }
5409       }
5410
5411   return false;
5412 }
5413 \f
5414 /* Report whether we have an instruction to perform the operation
5415    specified by CODE on operands of mode MODE.  */
5416 int
5417 have_insn_for (enum rtx_code code, enum machine_mode mode)
5418 {
5419   return (code_to_optab[(int) code] != 0
5420           && (optab_handler (code_to_optab[(int) code], mode)->insn_code
5421               != CODE_FOR_nothing));
5422 }
5423
5424 /* Set all insn_code fields to CODE_FOR_nothing.  */
5425
5426 static void
5427 init_insn_codes (void)
5428 {
5429   unsigned int i;
5430
5431   for (i = 0; i < (unsigned int) OTI_MAX; i++)
5432     {
5433       unsigned int j;
5434       optab op;
5435
5436       op = &optab_table[i];
5437       for (j = 0; j < NUM_MACHINE_MODES; j++)
5438         optab_handler (op, j)->insn_code = CODE_FOR_nothing;
5439     }
5440   for (i = 0; i < (unsigned int) COI_MAX; i++)
5441     {
5442       unsigned int j, k;
5443       convert_optab op;
5444
5445       op = &convert_optab_table[i];
5446       for (j = 0; j < NUM_MACHINE_MODES; j++)
5447         for (k = 0; k < NUM_MACHINE_MODES; k++)
5448           convert_optab_handler (op, j, k)->insn_code = CODE_FOR_nothing;
5449     }
5450 }
5451
5452 /* Initialize OP's code to CODE, and write it into the code_to_optab table.  */
5453 static inline void
5454 init_optab (optab op, enum rtx_code code)
5455 {
5456   op->code = code;
5457   code_to_optab[(int) code] = op;
5458 }
5459
5460 /* Same, but fill in its code as CODE, and do _not_ write it into
5461    the code_to_optab table.  */
5462 static inline void
5463 init_optabv (optab op, enum rtx_code code)
5464 {
5465   op->code = code;
5466 }
5467
5468 /* Conversion optabs never go in the code_to_optab table.  */
5469 static void
5470 init_convert_optab (convert_optab op, enum rtx_code code)
5471 {
5472   op->code = code;
5473 }
5474
5475 /* Initialize the libfunc fields of an entire group of entries in some
5476    optab.  Each entry is set equal to a string consisting of a leading
5477    pair of underscores followed by a generic operation name followed by
5478    a mode name (downshifted to lowercase) followed by a single character
5479    representing the number of operands for the given operation (which is
5480    usually one of the characters '2', '3', or '4').
5481
5482    OPTABLE is the table in which libfunc fields are to be initialized.
5483    OPNAME is the generic (string) name of the operation.
5484    SUFFIX is the character which specifies the number of operands for
5485      the given generic operation.
5486    MODE is the mode to generate for.
5487 */
5488
5489 static void
5490 gen_libfunc (optab optable, const char *opname, int suffix, enum machine_mode mode)
5491 {
5492   unsigned opname_len = strlen (opname);
5493   const char *mname = GET_MODE_NAME (mode);
5494   unsigned mname_len = strlen (mname);
5495   char *libfunc_name = XALLOCAVEC (char, 2 + opname_len + mname_len + 1 + 1);
5496   char *p;
5497   const char *q;
5498
5499   p = libfunc_name;
5500   *p++ = '_';
5501   *p++ = '_';
5502   for (q = opname; *q; )
5503     *p++ = *q++;
5504   for (q = mname; *q; q++)
5505     *p++ = TOLOWER (*q);
5506   *p++ = suffix;
5507   *p = '\0';
5508
5509   set_optab_libfunc (optable, mode,
5510                      ggc_alloc_string (libfunc_name, p - libfunc_name));
5511 }
5512
5513 /* Like gen_libfunc, but verify that integer operation is involved.  */
5514
5515 static void
5516 gen_int_libfunc (optab optable, const char *opname, char suffix,
5517                  enum machine_mode mode)
5518 {
5519   int maxsize = 2 * BITS_PER_WORD;
5520
5521   if (GET_MODE_CLASS (mode) != MODE_INT)
5522     return;
5523   if (maxsize < LONG_LONG_TYPE_SIZE)
5524     maxsize = LONG_LONG_TYPE_SIZE;
5525   if (GET_MODE_CLASS (mode) != MODE_INT
5526       || mode < word_mode || GET_MODE_BITSIZE (mode) > maxsize)
5527     return;
5528   gen_libfunc (optable, opname, suffix, mode);
5529 }
5530
5531 /* Like gen_libfunc, but verify that FP and set decimal prefix if needed.  */
5532
5533 static void
5534 gen_fp_libfunc (optab optable, const char *opname, char suffix,
5535                 enum machine_mode mode)
5536 {
5537   char *dec_opname;
5538
5539   if (GET_MODE_CLASS (mode) == MODE_FLOAT)
5540     gen_libfunc (optable, opname, suffix, mode);
5541   if (DECIMAL_FLOAT_MODE_P (mode))
5542     {
5543       dec_opname = XALLOCAVEC (char, sizeof (DECIMAL_PREFIX) + strlen (opname));
5544       /* For BID support, change the name to have either a bid_ or dpd_ prefix
5545          depending on the low level floating format used.  */
5546       memcpy (dec_opname, DECIMAL_PREFIX, sizeof (DECIMAL_PREFIX) - 1);
5547       strcpy (dec_opname + sizeof (DECIMAL_PREFIX) - 1, opname);
5548       gen_libfunc (optable, dec_opname, suffix, mode);
5549     }
5550 }
5551
5552 /* Like gen_libfunc, but verify that fixed-point operation is involved.  */
5553
5554 static void
5555 gen_fixed_libfunc (optab optable, const char *opname, char suffix,
5556                    enum machine_mode mode)
5557 {
5558   if (!ALL_FIXED_POINT_MODE_P (mode))
5559     return;
5560   gen_libfunc (optable, opname, suffix, mode);
5561 }
5562
5563 /* Like gen_libfunc, but verify that signed fixed-point operation is
5564    involved.  */
5565
5566 static void
5567 gen_signed_fixed_libfunc (optab optable, const char *opname, char suffix,
5568                           enum machine_mode mode)
5569 {
5570   if (!SIGNED_FIXED_POINT_MODE_P (mode))
5571     return;
5572   gen_libfunc (optable, opname, suffix, mode);
5573 }
5574
5575 /* Like gen_libfunc, but verify that unsigned fixed-point operation is
5576    involved.  */
5577
5578 static void
5579 gen_unsigned_fixed_libfunc (optab optable, const char *opname, char suffix,
5580                             enum machine_mode mode)
5581 {
5582   if (!UNSIGNED_FIXED_POINT_MODE_P (mode))
5583     return;
5584   gen_libfunc (optable, opname, suffix, mode);
5585 }
5586
5587 /* Like gen_libfunc, but verify that FP or INT operation is involved.  */
5588
5589 static void
5590 gen_int_fp_libfunc (optab optable, const char *name, char suffix,
5591                     enum machine_mode mode)
5592 {
5593   if (DECIMAL_FLOAT_MODE_P (mode) || GET_MODE_CLASS (mode) == MODE_FLOAT)
5594     gen_fp_libfunc (optable, name, suffix, mode);
5595   if (INTEGRAL_MODE_P (mode))
5596     gen_int_libfunc (optable, name, suffix, mode);
5597 }
5598
5599 /* Like gen_libfunc, but verify that FP or INT operation is involved
5600    and add 'v' suffix for integer operation.  */
5601
5602 static void
5603 gen_intv_fp_libfunc (optab optable, const char *name, char suffix,
5604                      enum machine_mode mode)
5605 {
5606   if (DECIMAL_FLOAT_MODE_P (mode) || GET_MODE_CLASS (mode) == MODE_FLOAT)
5607     gen_fp_libfunc (optable, name, suffix, mode);
5608   if (GET_MODE_CLASS (mode) == MODE_INT)
5609     {
5610       int len = strlen (name);
5611       char *v_name = XALLOCAVEC (char, len + 2);
5612       strcpy (v_name, name);
5613       v_name[len] = 'v';
5614       v_name[len + 1] = 0;
5615       gen_int_libfunc (optable, v_name, suffix, mode);
5616     }
5617 }
5618
5619 /* Like gen_libfunc, but verify that FP or INT or FIXED operation is
5620    involved.  */
5621
5622 static void
5623 gen_int_fp_fixed_libfunc (optab optable, const char *name, char suffix,
5624                           enum machine_mode mode)
5625 {
5626   if (DECIMAL_FLOAT_MODE_P (mode) || GET_MODE_CLASS (mode) == MODE_FLOAT)
5627     gen_fp_libfunc (optable, name, suffix, mode);
5628   if (INTEGRAL_MODE_P (mode))
5629     gen_int_libfunc (optable, name, suffix, mode);
5630   if (ALL_FIXED_POINT_MODE_P (mode))
5631     gen_fixed_libfunc (optable, name, suffix, mode);
5632 }
5633
5634 /* Like gen_libfunc, but verify that FP or INT or signed FIXED operation is
5635    involved.  */
5636
5637 static void
5638 gen_int_fp_signed_fixed_libfunc (optab optable, const char *name, char suffix,
5639                                  enum machine_mode mode)
5640 {
5641   if (DECIMAL_FLOAT_MODE_P (mode) || GET_MODE_CLASS (mode) == MODE_FLOAT)
5642     gen_fp_libfunc (optable, name, suffix, mode);
5643   if (INTEGRAL_MODE_P (mode))
5644     gen_int_libfunc (optable, name, suffix, mode);
5645   if (SIGNED_FIXED_POINT_MODE_P (mode))
5646     gen_signed_fixed_libfunc (optable, name, suffix, mode);
5647 }
5648
5649 /* Like gen_libfunc, but verify that INT or FIXED operation is
5650    involved.  */
5651
5652 static void
5653 gen_int_fixed_libfunc (optab optable, const char *name, char suffix,
5654                        enum machine_mode mode)
5655 {
5656   if (INTEGRAL_MODE_P (mode))
5657     gen_int_libfunc (optable, name, suffix, mode);
5658   if (ALL_FIXED_POINT_MODE_P (mode))
5659     gen_fixed_libfunc (optable, name, suffix, mode);
5660 }
5661
5662 /* Like gen_libfunc, but verify that INT or signed FIXED operation is
5663    involved.  */
5664
5665 static void
5666 gen_int_signed_fixed_libfunc (optab optable, const char *name, char suffix,
5667                               enum machine_mode mode)
5668 {
5669   if (INTEGRAL_MODE_P (mode))
5670     gen_int_libfunc (optable, name, suffix, mode);
5671   if (SIGNED_FIXED_POINT_MODE_P (mode))
5672     gen_signed_fixed_libfunc (optable, name, suffix, mode);
5673 }
5674
5675 /* Like gen_libfunc, but verify that INT or unsigned FIXED operation is
5676    involved.  */
5677
5678 static void
5679 gen_int_unsigned_fixed_libfunc (optab optable, const char *name, char suffix,
5680                                 enum machine_mode mode)
5681 {
5682   if (INTEGRAL_MODE_P (mode))
5683     gen_int_libfunc (optable, name, suffix, mode);
5684   if (UNSIGNED_FIXED_POINT_MODE_P (mode))
5685     gen_unsigned_fixed_libfunc (optable, name, suffix, mode);
5686 }
5687
5688 /* Initialize the libfunc fields of an entire group of entries of an
5689    inter-mode-class conversion optab.  The string formation rules are
5690    similar to the ones for init_libfuncs, above, but instead of having
5691    a mode name and an operand count these functions have two mode names
5692    and no operand count.  */
5693
5694 static void
5695 gen_interclass_conv_libfunc (convert_optab tab,
5696                              const char *opname,
5697                              enum machine_mode tmode,
5698                              enum machine_mode fmode)
5699 {
5700   size_t opname_len = strlen (opname);
5701   size_t mname_len = 0;
5702
5703   const char *fname, *tname;
5704   const char *q;
5705   char *libfunc_name, *suffix;
5706   char *nondec_name, *dec_name, *nondec_suffix, *dec_suffix;
5707   char *p;
5708
5709   /* If this is a decimal conversion, add the current BID vs. DPD prefix that
5710      depends on which underlying decimal floating point format is used.  */
5711   const size_t dec_len = sizeof (DECIMAL_PREFIX) - 1;
5712
5713   mname_len = strlen (GET_MODE_NAME (tmode)) + strlen (GET_MODE_NAME (fmode));
5714
5715   nondec_name = XALLOCAVEC (char, 2 + opname_len + mname_len + 1 + 1);
5716   nondec_name[0] = '_';
5717   nondec_name[1] = '_';
5718   memcpy (&nondec_name[2], opname, opname_len);
5719   nondec_suffix = nondec_name + opname_len + 2;
5720
5721   dec_name = XALLOCAVEC (char, 2 + dec_len + opname_len + mname_len + 1 + 1);
5722   dec_name[0] = '_';
5723   dec_name[1] = '_';
5724   memcpy (&dec_name[2], DECIMAL_PREFIX, dec_len);
5725   memcpy (&dec_name[2+dec_len], opname, opname_len);
5726   dec_suffix = dec_name + dec_len + opname_len + 2;
5727
5728   fname = GET_MODE_NAME (fmode);
5729   tname = GET_MODE_NAME (tmode);
5730
5731   if (DECIMAL_FLOAT_MODE_P(fmode) || DECIMAL_FLOAT_MODE_P(tmode))
5732     {
5733       libfunc_name = dec_name;
5734       suffix = dec_suffix;
5735     }
5736   else
5737     {
5738       libfunc_name = nondec_name;
5739       suffix = nondec_suffix;
5740     }
5741
5742   p = suffix;
5743   for (q = fname; *q; p++, q++)
5744     *p = TOLOWER (*q);
5745   for (q = tname; *q; p++, q++)
5746     *p = TOLOWER (*q);
5747
5748   *p = '\0';
5749
5750   set_conv_libfunc (tab, tmode, fmode,
5751                     ggc_alloc_string (libfunc_name, p - libfunc_name));
5752 }
5753
5754 /* Same as gen_interclass_conv_libfunc but verify that we are producing
5755    int->fp conversion.  */
5756
5757 static void
5758 gen_int_to_fp_conv_libfunc (convert_optab tab,
5759                             const char *opname,
5760                             enum machine_mode tmode,
5761                             enum machine_mode fmode)
5762 {
5763   if (GET_MODE_CLASS (fmode) != MODE_INT)
5764     return;
5765   if (GET_MODE_CLASS (tmode) != MODE_FLOAT && !DECIMAL_FLOAT_MODE_P (tmode))
5766     return;
5767   gen_interclass_conv_libfunc (tab, opname, tmode, fmode);
5768 }
5769
5770 /* ufloat_optab is special by using floatun for FP and floatuns decimal fp
5771    naming scheme.  */
5772
5773 static void
5774 gen_ufloat_conv_libfunc (convert_optab tab,
5775                          const char *opname ATTRIBUTE_UNUSED,
5776                          enum machine_mode tmode,
5777                          enum machine_mode fmode)
5778 {
5779   if (DECIMAL_FLOAT_MODE_P (tmode))
5780     gen_int_to_fp_conv_libfunc (tab, "floatuns", tmode, fmode);
5781   else
5782     gen_int_to_fp_conv_libfunc (tab, "floatun", tmode, fmode);
5783 }
5784
5785 /* Same as gen_interclass_conv_libfunc but verify that we are producing
5786    fp->int conversion.  */
5787
5788 static void
5789 gen_int_to_fp_nondecimal_conv_libfunc (convert_optab tab,
5790                                        const char *opname,
5791                                        enum machine_mode tmode,
5792                                        enum machine_mode fmode)
5793 {
5794   if (GET_MODE_CLASS (fmode) != MODE_INT)
5795     return;
5796   if (GET_MODE_CLASS (tmode) != MODE_FLOAT)
5797     return;
5798   gen_interclass_conv_libfunc (tab, opname, tmode, fmode);
5799 }
5800
5801 /* Same as gen_interclass_conv_libfunc but verify that we are producing
5802    fp->int conversion with no decimal floating point involved.  */
5803
5804 static void
5805 gen_fp_to_int_conv_libfunc (convert_optab tab,
5806                             const char *opname,
5807                             enum machine_mode tmode,
5808                             enum machine_mode fmode)
5809 {
5810   if (GET_MODE_CLASS (fmode) != MODE_FLOAT && !DECIMAL_FLOAT_MODE_P (fmode))
5811     return;
5812   if (GET_MODE_CLASS (tmode) != MODE_INT)
5813     return;
5814   gen_interclass_conv_libfunc (tab, opname, tmode, fmode);
5815 }
5816
5817 /* Initialize the libfunc fields of an of an intra-mode-class conversion optab.
5818    The string formation rules are
5819    similar to the ones for init_libfunc, above.  */
5820
5821 static void
5822 gen_intraclass_conv_libfunc (convert_optab tab, const char *opname,
5823                              enum machine_mode tmode, enum machine_mode fmode)
5824 {
5825   size_t opname_len = strlen (opname);
5826   size_t mname_len = 0;
5827
5828   const char *fname, *tname;
5829   const char *q;
5830   char *nondec_name, *dec_name, *nondec_suffix, *dec_suffix;
5831   char *libfunc_name, *suffix;
5832   char *p;
5833
5834   /* If this is a decimal conversion, add the current BID vs. DPD prefix that
5835      depends on which underlying decimal floating point format is used.  */
5836   const size_t dec_len = sizeof (DECIMAL_PREFIX) - 1;
5837
5838   mname_len = strlen (GET_MODE_NAME (tmode)) + strlen (GET_MODE_NAME (fmode));
5839
5840   nondec_name = XALLOCAVEC (char, 2 + opname_len + mname_len + 1 + 1);
5841   nondec_name[0] = '_';
5842   nondec_name[1] = '_';
5843   memcpy (&nondec_name[2], opname, opname_len);
5844   nondec_suffix = nondec_name + opname_len + 2;
5845
5846   dec_name = XALLOCAVEC (char, 2 + dec_len + opname_len + mname_len + 1 + 1);
5847   dec_name[0] = '_';
5848   dec_name[1] = '_';
5849   memcpy (&dec_name[2], DECIMAL_PREFIX, dec_len);
5850   memcpy (&dec_name[2 + dec_len], opname, opname_len);
5851   dec_suffix = dec_name + dec_len + opname_len + 2;
5852
5853   fname = GET_MODE_NAME (fmode);
5854   tname = GET_MODE_NAME (tmode);
5855
5856   if (DECIMAL_FLOAT_MODE_P(fmode) || DECIMAL_FLOAT_MODE_P(tmode))
5857     {
5858       libfunc_name = dec_name;
5859       suffix = dec_suffix;
5860     }
5861   else
5862     {
5863       libfunc_name = nondec_name;
5864       suffix = nondec_suffix;
5865     }
5866
5867   p = suffix;
5868   for (q = fname; *q; p++, q++)
5869     *p = TOLOWER (*q);
5870   for (q = tname; *q; p++, q++)
5871     *p = TOLOWER (*q);
5872
5873   *p++ = '2';
5874   *p = '\0';
5875
5876   set_conv_libfunc (tab, tmode, fmode,
5877                     ggc_alloc_string (libfunc_name, p - libfunc_name));
5878 }
5879
5880 /* Pick proper libcall for trunc_optab.  We need to chose if we do
5881    truncation or extension and interclass or intraclass.  */
5882
5883 static void
5884 gen_trunc_conv_libfunc (convert_optab tab,
5885                          const char *opname,
5886                          enum machine_mode tmode,
5887                          enum machine_mode fmode)
5888 {
5889   if (GET_MODE_CLASS (tmode) != MODE_FLOAT && !DECIMAL_FLOAT_MODE_P (tmode))
5890     return;
5891   if (GET_MODE_CLASS (fmode) != MODE_FLOAT && !DECIMAL_FLOAT_MODE_P (fmode))
5892     return;
5893   if (tmode == fmode)
5894     return;
5895
5896   if ((GET_MODE_CLASS (tmode) == MODE_FLOAT && DECIMAL_FLOAT_MODE_P (fmode))
5897       || (GET_MODE_CLASS (fmode) == MODE_FLOAT && DECIMAL_FLOAT_MODE_P (tmode)))
5898      gen_interclass_conv_libfunc (tab, opname, tmode, fmode);
5899
5900   if (GET_MODE_PRECISION (fmode) <= GET_MODE_PRECISION (tmode))
5901     return;
5902
5903   if ((GET_MODE_CLASS (tmode) == MODE_FLOAT
5904        && GET_MODE_CLASS (fmode) == MODE_FLOAT)
5905       || (DECIMAL_FLOAT_MODE_P (fmode) && DECIMAL_FLOAT_MODE_P (tmode)))
5906     gen_intraclass_conv_libfunc (tab, opname, tmode, fmode);
5907 }
5908
5909 /* Pick proper libcall for extend_optab.  We need to chose if we do
5910    truncation or extension and interclass or intraclass.  */
5911
5912 static void
5913 gen_extend_conv_libfunc (convert_optab tab,
5914                          const char *opname ATTRIBUTE_UNUSED,
5915                          enum machine_mode tmode,
5916                          enum machine_mode fmode)
5917 {
5918   if (GET_MODE_CLASS (tmode) != MODE_FLOAT && !DECIMAL_FLOAT_MODE_P (tmode))
5919     return;
5920   if (GET_MODE_CLASS (fmode) != MODE_FLOAT && !DECIMAL_FLOAT_MODE_P (fmode))
5921     return;
5922   if (tmode == fmode)
5923     return;
5924
5925   if ((GET_MODE_CLASS (tmode) == MODE_FLOAT && DECIMAL_FLOAT_MODE_P (fmode))
5926       || (GET_MODE_CLASS (fmode) == MODE_FLOAT && DECIMAL_FLOAT_MODE_P (tmode)))
5927      gen_interclass_conv_libfunc (tab, opname, tmode, fmode);
5928
5929   if (GET_MODE_PRECISION (fmode) > GET_MODE_PRECISION (tmode))
5930     return;
5931
5932   if ((GET_MODE_CLASS (tmode) == MODE_FLOAT
5933        && GET_MODE_CLASS (fmode) == MODE_FLOAT)
5934       || (DECIMAL_FLOAT_MODE_P (fmode) && DECIMAL_FLOAT_MODE_P (tmode)))
5935     gen_intraclass_conv_libfunc (tab, opname, tmode, fmode);
5936 }
5937
5938 /* Pick proper libcall for fract_optab.  We need to chose if we do
5939    interclass or intraclass.  */
5940
5941 static void
5942 gen_fract_conv_libfunc (convert_optab tab,
5943                         const char *opname,
5944                         enum machine_mode tmode,
5945                         enum machine_mode fmode)
5946 {
5947   if (tmode == fmode)
5948     return;
5949   if (!(ALL_FIXED_POINT_MODE_P (tmode) || ALL_FIXED_POINT_MODE_P (fmode)))
5950     return;
5951
5952   if (GET_MODE_CLASS (tmode) == GET_MODE_CLASS (fmode))
5953     gen_intraclass_conv_libfunc (tab, opname, tmode, fmode);
5954   else
5955     gen_interclass_conv_libfunc (tab, opname, tmode, fmode);
5956 }
5957
5958 /* Pick proper libcall for fractuns_optab.  */
5959
5960 static void
5961 gen_fractuns_conv_libfunc (convert_optab tab,
5962                            const char *opname,
5963                            enum machine_mode tmode,
5964                            enum machine_mode fmode)
5965 {
5966   if (tmode == fmode)
5967     return;
5968   /* One mode must be a fixed-point mode, and the other must be an integer
5969      mode. */
5970   if (!((ALL_FIXED_POINT_MODE_P (tmode) && GET_MODE_CLASS (fmode) == MODE_INT)
5971         || (ALL_FIXED_POINT_MODE_P (fmode)
5972             && GET_MODE_CLASS (tmode) == MODE_INT)))
5973     return;
5974
5975   gen_interclass_conv_libfunc (tab, opname, tmode, fmode);
5976 }
5977
5978 /* Pick proper libcall for satfract_optab.  We need to chose if we do
5979    interclass or intraclass.  */
5980
5981 static void
5982 gen_satfract_conv_libfunc (convert_optab tab,
5983                            const char *opname,
5984                            enum machine_mode tmode,
5985                            enum machine_mode fmode)
5986 {
5987   if (tmode == fmode)
5988     return;
5989   /* TMODE must be a fixed-point mode.  */
5990   if (!ALL_FIXED_POINT_MODE_P (tmode))
5991     return;
5992
5993   if (GET_MODE_CLASS (tmode) == GET_MODE_CLASS (fmode))
5994     gen_intraclass_conv_libfunc (tab, opname, tmode, fmode);
5995   else
5996     gen_interclass_conv_libfunc (tab, opname, tmode, fmode);
5997 }
5998
5999 /* Pick proper libcall for satfractuns_optab.  */
6000
6001 static void
6002 gen_satfractuns_conv_libfunc (convert_optab tab,
6003                               const char *opname,
6004                               enum machine_mode tmode,
6005                               enum machine_mode fmode)
6006 {
6007   if (tmode == fmode)
6008     return;
6009   /* TMODE must be a fixed-point mode, and FMODE must be an integer mode. */
6010   if (!(ALL_FIXED_POINT_MODE_P (tmode) && GET_MODE_CLASS (fmode) == MODE_INT))
6011     return;
6012
6013   gen_interclass_conv_libfunc (tab, opname, tmode, fmode);
6014 }
6015
6016 /* A table of previously-created libfuncs, hashed by name.  */
6017 static GTY ((param_is (union tree_node))) htab_t libfunc_decls;
6018
6019 /* Hashtable callbacks for libfunc_decls.  */
6020
6021 static hashval_t
6022 libfunc_decl_hash (const void *entry)
6023 {
6024   return htab_hash_string (IDENTIFIER_POINTER (DECL_NAME ((const_tree) entry)));
6025 }
6026
6027 static int
6028 libfunc_decl_eq (const void *entry1, const void *entry2)
6029 {
6030   return DECL_NAME ((const_tree) entry1) == (const_tree) entry2;
6031 }
6032
6033 rtx
6034 init_one_libfunc (const char *name)
6035 {
6036   tree id, decl;
6037   void **slot;
6038   hashval_t hash;
6039
6040   if (libfunc_decls == NULL)
6041     libfunc_decls = htab_create_ggc (37, libfunc_decl_hash,
6042                                      libfunc_decl_eq, NULL);
6043
6044   /* See if we have already created a libfunc decl for this function.  */
6045   id = get_identifier (name);
6046   hash = htab_hash_string (name);
6047   slot = htab_find_slot_with_hash (libfunc_decls, id, hash, INSERT);
6048   decl = (tree) *slot;
6049   if (decl == NULL)
6050     {
6051       /* Create a new decl, so that it can be passed to
6052          targetm.encode_section_info.  */
6053       /* ??? We don't have any type information except for this is
6054          a function.  Pretend this is "int foo()".  */
6055       decl = build_decl (FUNCTION_DECL, get_identifier (name),
6056                          build_function_type (integer_type_node, NULL_TREE));
6057       DECL_ARTIFICIAL (decl) = 1;
6058       DECL_EXTERNAL (decl) = 1;
6059       TREE_PUBLIC (decl) = 1;
6060
6061       /* Zap the nonsensical SYMBOL_REF_DECL for this.  What we're left with
6062          are the flags assigned by targetm.encode_section_info.  */
6063       SET_SYMBOL_REF_DECL (XEXP (DECL_RTL (decl), 0), NULL);
6064
6065       *slot = decl;
6066     }
6067   return XEXP (DECL_RTL (decl), 0);
6068 }
6069
6070 /* Call this to reset the function entry for one optab (OPTABLE) in mode
6071    MODE to NAME, which should be either 0 or a string constant.  */
6072 void
6073 set_optab_libfunc (optab optable, enum machine_mode mode, const char *name)
6074 {
6075   rtx val;
6076   struct libfunc_entry e;
6077   struct libfunc_entry **slot;
6078   e.optab = (size_t) (optable - &optab_table[0]);
6079   e.mode1 = mode;
6080   e.mode2 = VOIDmode;
6081
6082   if (name)
6083     val = init_one_libfunc (name);
6084   else
6085     val = 0;
6086   slot = (struct libfunc_entry **) htab_find_slot (libfunc_hash, &e, INSERT);
6087   if (*slot == NULL)
6088     *slot = GGC_NEW (struct libfunc_entry);
6089   (*slot)->optab = (size_t) (optable - &optab_table[0]);
6090   (*slot)->mode1 = mode;
6091   (*slot)->mode2 = VOIDmode;
6092   (*slot)->libfunc = val;
6093 }
6094
6095 /* Call this to reset the function entry for one conversion optab
6096    (OPTABLE) from mode FMODE to mode TMODE to NAME, which should be
6097    either 0 or a string constant.  */
6098 void
6099 set_conv_libfunc (convert_optab optable, enum machine_mode tmode,
6100                   enum machine_mode fmode, const char *name)
6101 {
6102   rtx val;
6103   struct libfunc_entry e;
6104   struct libfunc_entry **slot;
6105   e.optab = (size_t) (optable - &convert_optab_table[0]);
6106   e.mode1 = tmode;
6107   e.mode2 = fmode;
6108
6109   if (name)
6110     val = init_one_libfunc (name);
6111   else
6112     val = 0;
6113   slot = (struct libfunc_entry **) htab_find_slot (libfunc_hash, &e, INSERT);
6114   if (*slot == NULL)
6115     *slot = GGC_NEW (struct libfunc_entry);
6116   (*slot)->optab = (size_t) (optable - &convert_optab_table[0]);
6117   (*slot)->mode1 = tmode;
6118   (*slot)->mode2 = fmode;
6119   (*slot)->libfunc = val;
6120 }
6121
6122 /* Call this to initialize the contents of the optabs
6123    appropriately for the current target machine.  */
6124
6125 void
6126 init_optabs (void)
6127 {
6128   unsigned int i;
6129   enum machine_mode int_mode;
6130   static bool reinit;
6131
6132   libfunc_hash = htab_create_ggc (10, hash_libfunc, eq_libfunc, NULL);
6133   /* Start by initializing all tables to contain CODE_FOR_nothing.  */
6134
6135   for (i = 0; i < NUM_RTX_CODE; i++)
6136     setcc_gen_code[i] = CODE_FOR_nothing;
6137
6138 #ifdef HAVE_conditional_move
6139   for (i = 0; i < NUM_MACHINE_MODES; i++)
6140     movcc_gen_code[i] = CODE_FOR_nothing;
6141 #endif
6142
6143   for (i = 0; i < NUM_MACHINE_MODES; i++)
6144     {
6145       vcond_gen_code[i] = CODE_FOR_nothing;
6146       vcondu_gen_code[i] = CODE_FOR_nothing;
6147     }
6148
6149 #if GCC_VERSION >= 4000
6150   /* We statically initialize the insn_codes with CODE_FOR_nothing.  */
6151   if (reinit)
6152     init_insn_codes ();
6153 #else
6154   init_insn_codes ();
6155 #endif
6156
6157   init_optab (add_optab, PLUS);
6158   init_optabv (addv_optab, PLUS);
6159   init_optab (sub_optab, MINUS);
6160   init_optabv (subv_optab, MINUS);
6161   init_optab (ssadd_optab, SS_PLUS);
6162   init_optab (usadd_optab, US_PLUS);
6163   init_optab (sssub_optab, SS_MINUS);
6164   init_optab (ussub_optab, US_MINUS);
6165   init_optab (smul_optab, MULT);
6166   init_optab (ssmul_optab, SS_MULT);
6167   init_optab (usmul_optab, US_MULT);
6168   init_optabv (smulv_optab, MULT);
6169   init_optab (smul_highpart_optab, UNKNOWN);
6170   init_optab (umul_highpart_optab, UNKNOWN);
6171   init_optab (smul_widen_optab, UNKNOWN);
6172   init_optab (umul_widen_optab, UNKNOWN);
6173   init_optab (usmul_widen_optab, UNKNOWN);
6174   init_optab (smadd_widen_optab, UNKNOWN);
6175   init_optab (umadd_widen_optab, UNKNOWN);
6176   init_optab (ssmadd_widen_optab, UNKNOWN);
6177   init_optab (usmadd_widen_optab, UNKNOWN);
6178   init_optab (smsub_widen_optab, UNKNOWN);
6179   init_optab (umsub_widen_optab, UNKNOWN);
6180   init_optab (ssmsub_widen_optab, UNKNOWN);
6181   init_optab (usmsub_widen_optab, UNKNOWN);
6182   init_optab (sdiv_optab, DIV);
6183   init_optab (ssdiv_optab, SS_DIV);
6184   init_optab (usdiv_optab, US_DIV);
6185   init_optabv (sdivv_optab, DIV);
6186   init_optab (sdivmod_optab, UNKNOWN);
6187   init_optab (udiv_optab, UDIV);
6188   init_optab (udivmod_optab, UNKNOWN);
6189   init_optab (smod_optab, MOD);
6190   init_optab (umod_optab, UMOD);
6191   init_optab (fmod_optab, UNKNOWN);
6192   init_optab (remainder_optab, UNKNOWN);
6193   init_optab (ftrunc_optab, UNKNOWN);
6194   init_optab (and_optab, AND);
6195   init_optab (ior_optab, IOR);
6196   init_optab (xor_optab, XOR);
6197   init_optab (ashl_optab, ASHIFT);
6198   init_optab (ssashl_optab, SS_ASHIFT);
6199   init_optab (usashl_optab, US_ASHIFT);
6200   init_optab (ashr_optab, ASHIFTRT);
6201   init_optab (lshr_optab, LSHIFTRT);
6202   init_optab (rotl_optab, ROTATE);
6203   init_optab (rotr_optab, ROTATERT);
6204   init_optab (smin_optab, SMIN);
6205   init_optab (smax_optab, SMAX);
6206   init_optab (umin_optab, UMIN);
6207   init_optab (umax_optab, UMAX);
6208   init_optab (pow_optab, UNKNOWN);
6209   init_optab (atan2_optab, UNKNOWN);
6210
6211   /* These three have codes assigned exclusively for the sake of
6212      have_insn_for.  */
6213   init_optab (mov_optab, SET);
6214   init_optab (movstrict_optab, STRICT_LOW_PART);
6215   init_optab (cmp_optab, COMPARE);
6216
6217   init_optab (storent_optab, UNKNOWN);
6218
6219   init_optab (ucmp_optab, UNKNOWN);
6220   init_optab (tst_optab, UNKNOWN);
6221
6222   init_optab (eq_optab, EQ);
6223   init_optab (ne_optab, NE);
6224   init_optab (gt_optab, GT);
6225   init_optab (ge_optab, GE);
6226   init_optab (lt_optab, LT);
6227   init_optab (le_optab, LE);
6228   init_optab (unord_optab, UNORDERED);
6229
6230   init_optab (neg_optab, NEG);
6231   init_optab (ssneg_optab, SS_NEG);
6232   init_optab (usneg_optab, US_NEG);
6233   init_optabv (negv_optab, NEG);
6234   init_optab (abs_optab, ABS);
6235   init_optabv (absv_optab, ABS);
6236   init_optab (addcc_optab, UNKNOWN);
6237   init_optab (one_cmpl_optab, NOT);
6238   init_optab (bswap_optab, BSWAP);
6239   init_optab (ffs_optab, FFS);
6240   init_optab (clz_optab, CLZ);
6241   init_optab (ctz_optab, CTZ);
6242   init_optab (popcount_optab, POPCOUNT);
6243   init_optab (parity_optab, PARITY);
6244   init_optab (sqrt_optab, SQRT);
6245   init_optab (floor_optab, UNKNOWN);
6246   init_optab (ceil_optab, UNKNOWN);
6247   init_optab (round_optab, UNKNOWN);
6248   init_optab (btrunc_optab, UNKNOWN);
6249   init_optab (nearbyint_optab, UNKNOWN);
6250   init_optab (rint_optab, UNKNOWN);
6251   init_optab (sincos_optab, UNKNOWN);
6252   init_optab (sin_optab, UNKNOWN);
6253   init_optab (asin_optab, UNKNOWN);
6254   init_optab (cos_optab, UNKNOWN);
6255   init_optab (acos_optab, UNKNOWN);
6256   init_optab (exp_optab, UNKNOWN);
6257   init_optab (exp10_optab, UNKNOWN);
6258   init_optab (exp2_optab, UNKNOWN);
6259   init_optab (expm1_optab, UNKNOWN);
6260   init_optab (ldexp_optab, UNKNOWN);
6261   init_optab (scalb_optab, UNKNOWN);
6262   init_optab (logb_optab, UNKNOWN);
6263   init_optab (ilogb_optab, UNKNOWN);
6264   init_optab (log_optab, UNKNOWN);
6265   init_optab (log10_optab, UNKNOWN);
6266   init_optab (log2_optab, UNKNOWN);
6267   init_optab (log1p_optab, UNKNOWN);
6268   init_optab (tan_optab, UNKNOWN);
6269   init_optab (atan_optab, UNKNOWN);
6270   init_optab (copysign_optab, UNKNOWN);
6271   init_optab (signbit_optab, UNKNOWN);
6272
6273   init_optab (isinf_optab, UNKNOWN);
6274
6275   init_optab (strlen_optab, UNKNOWN);
6276   init_optab (cbranch_optab, UNKNOWN);
6277   init_optab (cmov_optab, UNKNOWN);
6278   init_optab (cstore_optab, UNKNOWN);
6279   init_optab (push_optab, UNKNOWN);
6280
6281   init_optab (reduc_smax_optab, UNKNOWN);
6282   init_optab (reduc_umax_optab, UNKNOWN);
6283   init_optab (reduc_smin_optab, UNKNOWN);
6284   init_optab (reduc_umin_optab, UNKNOWN);
6285   init_optab (reduc_splus_optab, UNKNOWN);
6286   init_optab (reduc_uplus_optab, UNKNOWN);
6287
6288   init_optab (ssum_widen_optab, UNKNOWN);
6289   init_optab (usum_widen_optab, UNKNOWN);
6290   init_optab (sdot_prod_optab, UNKNOWN);
6291   init_optab (udot_prod_optab, UNKNOWN);
6292
6293   init_optab (vec_extract_optab, UNKNOWN);
6294   init_optab (vec_extract_even_optab, UNKNOWN);
6295   init_optab (vec_extract_odd_optab, UNKNOWN);
6296   init_optab (vec_interleave_high_optab, UNKNOWN);
6297   init_optab (vec_interleave_low_optab, UNKNOWN);
6298   init_optab (vec_set_optab, UNKNOWN);
6299   init_optab (vec_init_optab, UNKNOWN);
6300   init_optab (vec_shl_optab, UNKNOWN);
6301   init_optab (vec_shr_optab, UNKNOWN);
6302   init_optab (vec_realign_load_optab, UNKNOWN);
6303   init_optab (movmisalign_optab, UNKNOWN);
6304   init_optab (vec_widen_umult_hi_optab, UNKNOWN);
6305   init_optab (vec_widen_umult_lo_optab, UNKNOWN);
6306   init_optab (vec_widen_smult_hi_optab, UNKNOWN);
6307   init_optab (vec_widen_smult_lo_optab, UNKNOWN);
6308   init_optab (vec_unpacks_hi_optab, UNKNOWN);
6309   init_optab (vec_unpacks_lo_optab, UNKNOWN);
6310   init_optab (vec_unpacku_hi_optab, UNKNOWN);
6311   init_optab (vec_unpacku_lo_optab, UNKNOWN);
6312   init_optab (vec_unpacks_float_hi_optab, UNKNOWN);
6313   init_optab (vec_unpacks_float_lo_optab, UNKNOWN);
6314   init_optab (vec_unpacku_float_hi_optab, UNKNOWN);
6315   init_optab (vec_unpacku_float_lo_optab, UNKNOWN);
6316   init_optab (vec_pack_trunc_optab, UNKNOWN);
6317   init_optab (vec_pack_usat_optab, UNKNOWN);
6318   init_optab (vec_pack_ssat_optab, UNKNOWN);
6319   init_optab (vec_pack_ufix_trunc_optab, UNKNOWN);
6320   init_optab (vec_pack_sfix_trunc_optab, UNKNOWN);
6321
6322   init_optab (powi_optab, UNKNOWN);
6323
6324   /* Conversions.  */
6325   init_convert_optab (sext_optab, SIGN_EXTEND);
6326   init_convert_optab (zext_optab, ZERO_EXTEND);
6327   init_convert_optab (trunc_optab, TRUNCATE);
6328   init_convert_optab (sfix_optab, FIX);
6329   init_convert_optab (ufix_optab, UNSIGNED_FIX);
6330   init_convert_optab (sfixtrunc_optab, UNKNOWN);
6331   init_convert_optab (ufixtrunc_optab, UNKNOWN);
6332   init_convert_optab (sfloat_optab, FLOAT);
6333   init_convert_optab (ufloat_optab, UNSIGNED_FLOAT);
6334   init_convert_optab (lrint_optab, UNKNOWN);
6335   init_convert_optab (lround_optab, UNKNOWN);
6336   init_convert_optab (lfloor_optab, UNKNOWN);
6337   init_convert_optab (lceil_optab, UNKNOWN);
6338
6339   init_convert_optab (fract_optab, FRACT_CONVERT);
6340   init_convert_optab (fractuns_optab, UNSIGNED_FRACT_CONVERT);
6341   init_convert_optab (satfract_optab, SAT_FRACT);
6342   init_convert_optab (satfractuns_optab, UNSIGNED_SAT_FRACT);
6343
6344   for (i = 0; i < NUM_MACHINE_MODES; i++)
6345     {
6346       movmem_optab[i] = CODE_FOR_nothing;
6347       cmpstr_optab[i] = CODE_FOR_nothing;
6348       cmpstrn_optab[i] = CODE_FOR_nothing;
6349       cmpmem_optab[i] = CODE_FOR_nothing;
6350       setmem_optab[i] = CODE_FOR_nothing;
6351
6352       sync_add_optab[i] = CODE_FOR_nothing;
6353       sync_sub_optab[i] = CODE_FOR_nothing;
6354       sync_ior_optab[i] = CODE_FOR_nothing;
6355       sync_and_optab[i] = CODE_FOR_nothing;
6356       sync_xor_optab[i] = CODE_FOR_nothing;
6357       sync_nand_optab[i] = CODE_FOR_nothing;
6358       sync_old_add_optab[i] = CODE_FOR_nothing;
6359       sync_old_sub_optab[i] = CODE_FOR_nothing;
6360       sync_old_ior_optab[i] = CODE_FOR_nothing;
6361       sync_old_and_optab[i] = CODE_FOR_nothing;
6362       sync_old_xor_optab[i] = CODE_FOR_nothing;
6363       sync_old_nand_optab[i] = CODE_FOR_nothing;
6364       sync_new_add_optab[i] = CODE_FOR_nothing;
6365       sync_new_sub_optab[i] = CODE_FOR_nothing;
6366       sync_new_ior_optab[i] = CODE_FOR_nothing;
6367       sync_new_and_optab[i] = CODE_FOR_nothing;
6368       sync_new_xor_optab[i] = CODE_FOR_nothing;
6369       sync_new_nand_optab[i] = CODE_FOR_nothing;
6370       sync_compare_and_swap[i] = CODE_FOR_nothing;
6371       sync_compare_and_swap_cc[i] = CODE_FOR_nothing;
6372       sync_lock_test_and_set[i] = CODE_FOR_nothing;
6373       sync_lock_release[i] = CODE_FOR_nothing;
6374
6375       reload_in_optab[i] = reload_out_optab[i] = CODE_FOR_nothing;
6376     }
6377
6378   /* Fill in the optabs with the insns we support.  */
6379   init_all_optabs ();
6380
6381   /* Initialize the optabs with the names of the library functions.  */
6382   add_optab->libcall_basename = "add";
6383   add_optab->libcall_suffix = '3';
6384   add_optab->libcall_gen = gen_int_fp_fixed_libfunc;
6385   addv_optab->libcall_basename = "add";
6386   addv_optab->libcall_suffix = '3';
6387   addv_optab->libcall_gen = gen_intv_fp_libfunc;
6388   ssadd_optab->libcall_basename = "ssadd";
6389   ssadd_optab->libcall_suffix = '3';
6390   ssadd_optab->libcall_gen = gen_signed_fixed_libfunc;
6391   usadd_optab->libcall_basename = "usadd";
6392   usadd_optab->libcall_suffix = '3';
6393   usadd_optab->libcall_gen = gen_unsigned_fixed_libfunc;
6394   sub_optab->libcall_basename = "sub";
6395   sub_optab->libcall_suffix = '3';
6396   sub_optab->libcall_gen = gen_int_fp_fixed_libfunc;
6397   subv_optab->libcall_basename = "sub";
6398   subv_optab->libcall_suffix = '3';
6399   subv_optab->libcall_gen = gen_intv_fp_libfunc;
6400   sssub_optab->libcall_basename = "sssub";
6401   sssub_optab->libcall_suffix = '3';
6402   sssub_optab->libcall_gen = gen_signed_fixed_libfunc;
6403   ussub_optab->libcall_basename = "ussub";
6404   ussub_optab->libcall_suffix = '3';
6405   ussub_optab->libcall_gen = gen_unsigned_fixed_libfunc;
6406   smul_optab->libcall_basename = "mul";
6407   smul_optab->libcall_suffix = '3';
6408   smul_optab->libcall_gen = gen_int_fp_fixed_libfunc;
6409   smulv_optab->libcall_basename = "mul";
6410   smulv_optab->libcall_suffix = '3';
6411   smulv_optab->libcall_gen = gen_intv_fp_libfunc;
6412   ssmul_optab->libcall_basename = "ssmul";
6413   ssmul_optab->libcall_suffix = '3';
6414   ssmul_optab->libcall_gen = gen_signed_fixed_libfunc;
6415   usmul_optab->libcall_basename = "usmul";
6416   usmul_optab->libcall_suffix = '3';
6417   usmul_optab->libcall_gen = gen_unsigned_fixed_libfunc;
6418   sdiv_optab->libcall_basename = "div";
6419   sdiv_optab->libcall_suffix = '3';
6420   sdiv_optab->libcall_gen = gen_int_fp_signed_fixed_libfunc;
6421   sdivv_optab->libcall_basename = "divv";
6422   sdivv_optab->libcall_suffix = '3';
6423   sdivv_optab->libcall_gen = gen_int_libfunc;
6424   ssdiv_optab->libcall_basename = "ssdiv";
6425   ssdiv_optab->libcall_suffix = '3';
6426   ssdiv_optab->libcall_gen = gen_signed_fixed_libfunc;
6427   udiv_optab->libcall_basename = "udiv";
6428   udiv_optab->libcall_suffix = '3';
6429   udiv_optab->libcall_gen = gen_int_unsigned_fixed_libfunc;
6430   usdiv_optab->libcall_basename = "usdiv";
6431   usdiv_optab->libcall_suffix = '3';
6432   usdiv_optab->libcall_gen = gen_unsigned_fixed_libfunc;
6433   sdivmod_optab->libcall_basename = "divmod";
6434   sdivmod_optab->libcall_suffix = '4';
6435   sdivmod_optab->libcall_gen = gen_int_libfunc;
6436   udivmod_optab->libcall_basename = "udivmod";
6437   udivmod_optab->libcall_suffix = '4';
6438   udivmod_optab->libcall_gen = gen_int_libfunc;
6439   smod_optab->libcall_basename = "mod";
6440   smod_optab->libcall_suffix = '3';
6441   smod_optab->libcall_gen = gen_int_libfunc;
6442   umod_optab->libcall_basename = "umod";
6443   umod_optab->libcall_suffix = '3';
6444   umod_optab->libcall_gen = gen_int_libfunc;
6445   ftrunc_optab->libcall_basename = "ftrunc";
6446   ftrunc_optab->libcall_suffix = '2';
6447   ftrunc_optab->libcall_gen = gen_fp_libfunc;
6448   and_optab->libcall_basename = "and";
6449   and_optab->libcall_suffix = '3';
6450   and_optab->libcall_gen = gen_int_libfunc;
6451   ior_optab->libcall_basename = "ior";
6452   ior_optab->libcall_suffix = '3';
6453   ior_optab->libcall_gen = gen_int_libfunc;
6454   xor_optab->libcall_basename = "xor";
6455   xor_optab->libcall_suffix = '3';
6456   xor_optab->libcall_gen = gen_int_libfunc;
6457   ashl_optab->libcall_basename = "ashl";
6458   ashl_optab->libcall_suffix = '3';
6459   ashl_optab->libcall_gen = gen_int_fixed_libfunc;
6460   ssashl_optab->libcall_basename = "ssashl";
6461   ssashl_optab->libcall_suffix = '3';
6462   ssashl_optab->libcall_gen = gen_signed_fixed_libfunc;
6463   usashl_optab->libcall_basename = "usashl";
6464   usashl_optab->libcall_suffix = '3';
6465   usashl_optab->libcall_gen = gen_unsigned_fixed_libfunc;
6466   ashr_optab->libcall_basename = "ashr";
6467   ashr_optab->libcall_suffix = '3';
6468   ashr_optab->libcall_gen = gen_int_signed_fixed_libfunc;
6469   lshr_optab->libcall_basename = "lshr";
6470   lshr_optab->libcall_suffix = '3';
6471   lshr_optab->libcall_gen = gen_int_unsigned_fixed_libfunc;
6472   smin_optab->libcall_basename = "min";
6473   smin_optab->libcall_suffix = '3';
6474   smin_optab->libcall_gen = gen_int_fp_libfunc;
6475   smax_optab->libcall_basename = "max";
6476   smax_optab->libcall_suffix = '3';
6477   smax_optab->libcall_gen = gen_int_fp_libfunc;
6478   umin_optab->libcall_basename = "umin";
6479   umin_optab->libcall_suffix = '3';
6480   umin_optab->libcall_gen = gen_int_libfunc;
6481   umax_optab->libcall_basename = "umax";
6482   umax_optab->libcall_suffix = '3';
6483   umax_optab->libcall_gen = gen_int_libfunc;
6484   neg_optab->libcall_basename = "neg";
6485   neg_optab->libcall_suffix = '2';
6486   neg_optab->libcall_gen = gen_int_fp_fixed_libfunc;
6487   ssneg_optab->libcall_basename = "ssneg";
6488   ssneg_optab->libcall_suffix = '2';
6489   ssneg_optab->libcall_gen = gen_signed_fixed_libfunc;
6490   usneg_optab->libcall_basename = "usneg";
6491   usneg_optab->libcall_suffix = '2';
6492   usneg_optab->libcall_gen = gen_unsigned_fixed_libfunc;
6493   negv_optab->libcall_basename = "neg";
6494   negv_optab->libcall_suffix = '2';
6495   negv_optab->libcall_gen = gen_intv_fp_libfunc;
6496   one_cmpl_optab->libcall_basename = "one_cmpl";
6497   one_cmpl_optab->libcall_suffix = '2';
6498   one_cmpl_optab->libcall_gen = gen_int_libfunc;
6499   ffs_optab->libcall_basename = "ffs";
6500   ffs_optab->libcall_suffix = '2';
6501   ffs_optab->libcall_gen = gen_int_libfunc;
6502   clz_optab->libcall_basename = "clz";
6503   clz_optab->libcall_suffix = '2';
6504   clz_optab->libcall_gen = gen_int_libfunc;
6505   ctz_optab->libcall_basename = "ctz";
6506   ctz_optab->libcall_suffix = '2';
6507   ctz_optab->libcall_gen = gen_int_libfunc;
6508   popcount_optab->libcall_basename = "popcount";
6509   popcount_optab->libcall_suffix = '2';
6510   popcount_optab->libcall_gen = gen_int_libfunc;
6511   parity_optab->libcall_basename = "parity";
6512   parity_optab->libcall_suffix = '2';
6513   parity_optab->libcall_gen = gen_int_libfunc;
6514
6515   /* Comparison libcalls for integers MUST come in pairs,
6516      signed/unsigned.  */
6517   cmp_optab->libcall_basename = "cmp";
6518   cmp_optab->libcall_suffix = '2';
6519   cmp_optab->libcall_gen = gen_int_fp_fixed_libfunc;
6520   ucmp_optab->libcall_basename = "ucmp";
6521   ucmp_optab->libcall_suffix = '2';
6522   ucmp_optab->libcall_gen = gen_int_libfunc;
6523
6524   /* EQ etc are floating point only.  */
6525   eq_optab->libcall_basename = "eq";
6526   eq_optab->libcall_suffix = '2';
6527   eq_optab->libcall_gen = gen_fp_libfunc;
6528   ne_optab->libcall_basename = "ne";
6529   ne_optab->libcall_suffix = '2';
6530   ne_optab->libcall_gen = gen_fp_libfunc;
6531   gt_optab->libcall_basename = "gt";
6532   gt_optab->libcall_suffix = '2';
6533   gt_optab->libcall_gen = gen_fp_libfunc;
6534   ge_optab->libcall_basename = "ge";
6535   ge_optab->libcall_suffix = '2';
6536   ge_optab->libcall_gen = gen_fp_libfunc;
6537   lt_optab->libcall_basename = "lt";
6538   lt_optab->libcall_suffix = '2';
6539   lt_optab->libcall_gen = gen_fp_libfunc;
6540   le_optab->libcall_basename = "le";
6541   le_optab->libcall_suffix = '2';
6542   le_optab->libcall_gen = gen_fp_libfunc;
6543   unord_optab->libcall_basename = "unord";
6544   unord_optab->libcall_suffix = '2';
6545   unord_optab->libcall_gen = gen_fp_libfunc;
6546
6547   powi_optab->libcall_basename = "powi";
6548   powi_optab->libcall_suffix = '2';
6549   powi_optab->libcall_gen = gen_fp_libfunc;
6550
6551   /* Conversions.  */
6552   sfloat_optab->libcall_basename = "float";
6553   sfloat_optab->libcall_gen = gen_int_to_fp_conv_libfunc;
6554   ufloat_optab->libcall_gen = gen_ufloat_conv_libfunc;
6555   sfix_optab->libcall_basename = "fix";
6556   sfix_optab->libcall_gen = gen_fp_to_int_conv_libfunc;
6557   ufix_optab->libcall_basename = "fixuns";
6558   ufix_optab->libcall_gen = gen_fp_to_int_conv_libfunc;
6559   lrint_optab->libcall_basename = "lrint";
6560   lrint_optab->libcall_gen = gen_int_to_fp_nondecimal_conv_libfunc;
6561   lround_optab->libcall_basename = "lround";
6562   lround_optab->libcall_gen = gen_int_to_fp_nondecimal_conv_libfunc;
6563   lfloor_optab->libcall_basename = "lfloor";
6564   lfloor_optab->libcall_gen = gen_int_to_fp_nondecimal_conv_libfunc;
6565   lceil_optab->libcall_basename = "lceil";
6566   lceil_optab->libcall_gen = gen_int_to_fp_nondecimal_conv_libfunc;
6567
6568   /* trunc_optab is also used for FLOAT_EXTEND.  */
6569   sext_optab->libcall_basename = "extend";
6570   sext_optab->libcall_gen = gen_extend_conv_libfunc;
6571   trunc_optab->libcall_basename = "trunc";
6572   trunc_optab->libcall_gen = gen_trunc_conv_libfunc;
6573
6574   /* Conversions for fixed-point modes and other modes.  */
6575   fract_optab->libcall_basename = "fract";
6576   fract_optab->libcall_gen = gen_fract_conv_libfunc;
6577   satfract_optab->libcall_basename = "satfract";
6578   satfract_optab->libcall_gen = gen_satfract_conv_libfunc;
6579   fractuns_optab->libcall_basename = "fractuns";
6580   fractuns_optab->libcall_gen = gen_fractuns_conv_libfunc;
6581   satfractuns_optab->libcall_basename = "satfractuns";
6582   satfractuns_optab->libcall_gen = gen_satfractuns_conv_libfunc;
6583
6584   /* The ffs function operates on `int'.  Fall back on it if we do not
6585      have a libgcc2 function for that width.  */
6586   if (INT_TYPE_SIZE < BITS_PER_WORD)
6587     {
6588       int_mode = mode_for_size (INT_TYPE_SIZE, MODE_INT, 0);
6589       set_optab_libfunc (ffs_optab, mode_for_size (INT_TYPE_SIZE, MODE_INT, 0),
6590                          "ffs");
6591     }
6592
6593   /* Explicitly initialize the bswap libfuncs since we need them to be
6594      valid for things other than word_mode.  */
6595   set_optab_libfunc (bswap_optab, SImode, "__bswapsi2");
6596   set_optab_libfunc (bswap_optab, DImode, "__bswapdi2");
6597
6598   /* Use cabs for double complex abs, since systems generally have cabs.
6599      Don't define any libcall for float complex, so that cabs will be used.  */
6600   if (complex_double_type_node)
6601     set_optab_libfunc (abs_optab, TYPE_MODE (complex_double_type_node), "cabs");
6602
6603   abort_libfunc = init_one_libfunc ("abort");
6604   memcpy_libfunc = init_one_libfunc ("memcpy");
6605   memmove_libfunc = init_one_libfunc ("memmove");
6606   memcmp_libfunc = init_one_libfunc ("memcmp");
6607   memset_libfunc = init_one_libfunc ("memset");
6608   setbits_libfunc = init_one_libfunc ("__setbits");
6609
6610 #ifndef DONT_USE_BUILTIN_SETJMP
6611   setjmp_libfunc = init_one_libfunc ("__builtin_setjmp");
6612   longjmp_libfunc = init_one_libfunc ("__builtin_longjmp");
6613 #else
6614   setjmp_libfunc = init_one_libfunc ("setjmp");
6615   longjmp_libfunc = init_one_libfunc ("longjmp");
6616 #endif
6617   unwind_sjlj_register_libfunc = init_one_libfunc ("_Unwind_SjLj_Register");
6618   unwind_sjlj_unregister_libfunc
6619     = init_one_libfunc ("_Unwind_SjLj_Unregister");
6620
6621   /* For function entry/exit instrumentation.  */
6622   profile_function_entry_libfunc
6623     = init_one_libfunc ("__cyg_profile_func_enter");
6624   profile_function_exit_libfunc
6625     = init_one_libfunc ("__cyg_profile_func_exit");
6626
6627   gcov_flush_libfunc = init_one_libfunc ("__gcov_flush");
6628
6629   if (HAVE_conditional_trap)
6630     trap_rtx = gen_rtx_fmt_ee (EQ, VOIDmode, NULL_RTX, NULL_RTX);
6631
6632   /* Allow the target to add more libcalls or rename some, etc.  */
6633   targetm.init_libfuncs ();
6634
6635   reinit = true;
6636 }
6637
6638 /* Print information about the current contents of the optabs on
6639    STDERR.  */
6640
6641 void
6642 debug_optab_libfuncs (void)
6643 {
6644   int i;
6645   int j;
6646   int k;
6647
6648   /* Dump the arithmetic optabs.  */
6649   for (i = 0; i != (int) OTI_MAX; i++)
6650     for (j = 0; j < NUM_MACHINE_MODES; ++j)
6651       {
6652         optab o;
6653         rtx l;
6654
6655         o = &optab_table[i];
6656         l = optab_libfunc (o, j);
6657         if (l)
6658           {
6659             gcc_assert (GET_CODE (l) == SYMBOL_REF);
6660             fprintf (stderr, "%s\t%s:\t%s\n",
6661                      GET_RTX_NAME (o->code),
6662                      GET_MODE_NAME (j),
6663                      XSTR (l, 0));
6664           }
6665       }
6666
6667   /* Dump the conversion optabs.  */
6668   for (i = 0; i < (int) COI_MAX; ++i)
6669     for (j = 0; j < NUM_MACHINE_MODES; ++j)
6670       for (k = 0; k < NUM_MACHINE_MODES; ++k)
6671         {
6672           convert_optab o;
6673           rtx l;
6674
6675           o = &convert_optab_table[i];
6676           l = convert_optab_libfunc (o, j, k);
6677           if (l)
6678             {
6679               gcc_assert (GET_CODE (l) == SYMBOL_REF);
6680               fprintf (stderr, "%s\t%s\t%s:\t%s\n",
6681                        GET_RTX_NAME (o->code),
6682                        GET_MODE_NAME (j),
6683                        GET_MODE_NAME (k),
6684                        XSTR (l, 0));
6685             }
6686         }
6687 }
6688
6689 \f
6690 /* Generate insns to trap with code TCODE if OP1 and OP2 satisfy condition
6691    CODE.  Return 0 on failure.  */
6692
6693 rtx
6694 gen_cond_trap (enum rtx_code code ATTRIBUTE_UNUSED, rtx op1,
6695                rtx op2 ATTRIBUTE_UNUSED, rtx tcode ATTRIBUTE_UNUSED)
6696 {
6697   enum machine_mode mode = GET_MODE (op1);
6698   enum insn_code icode;
6699   rtx insn;
6700
6701   if (!HAVE_conditional_trap)
6702     return 0;
6703
6704   if (mode == VOIDmode)
6705     return 0;
6706
6707   icode = optab_handler (cmp_optab, mode)->insn_code;
6708   if (icode == CODE_FOR_nothing)
6709     return 0;
6710
6711   start_sequence ();
6712   op1 = prepare_operand (icode, op1, 0, mode, mode, 0);
6713   op2 = prepare_operand (icode, op2, 1, mode, mode, 0);
6714   if (!op1 || !op2)
6715     {
6716       end_sequence ();
6717       return 0;
6718     }
6719   emit_insn (GEN_FCN (icode) (op1, op2));
6720
6721   PUT_CODE (trap_rtx, code);
6722   gcc_assert (HAVE_conditional_trap);
6723   insn = gen_conditional_trap (trap_rtx, tcode);
6724   if (insn)
6725     {
6726       emit_insn (insn);
6727       insn = get_insns ();
6728     }
6729   end_sequence ();
6730
6731   return insn;
6732 }
6733
6734 /* Return rtx code for TCODE. Use UNSIGNEDP to select signed
6735    or unsigned operation code.  */
6736
6737 static enum rtx_code
6738 get_rtx_code (enum tree_code tcode, bool unsignedp)
6739 {
6740   enum rtx_code code;
6741   switch (tcode)
6742     {
6743     case EQ_EXPR:
6744       code = EQ;
6745       break;
6746     case NE_EXPR:
6747       code = NE;
6748       break;
6749     case LT_EXPR:
6750       code = unsignedp ? LTU : LT;
6751       break;
6752     case LE_EXPR:
6753       code = unsignedp ? LEU : LE;
6754       break;
6755     case GT_EXPR:
6756       code = unsignedp ? GTU : GT;
6757       break;
6758     case GE_EXPR:
6759       code = unsignedp ? GEU : GE;
6760       break;
6761
6762     case UNORDERED_EXPR:
6763       code = UNORDERED;
6764       break;
6765     case ORDERED_EXPR:
6766       code = ORDERED;
6767       break;
6768     case UNLT_EXPR:
6769       code = UNLT;
6770       break;
6771     case UNLE_EXPR:
6772       code = UNLE;
6773       break;
6774     case UNGT_EXPR:
6775       code = UNGT;
6776       break;
6777     case UNGE_EXPR:
6778       code = UNGE;
6779       break;
6780     case UNEQ_EXPR:
6781       code = UNEQ;
6782       break;
6783     case LTGT_EXPR:
6784       code = LTGT;
6785       break;
6786
6787     default:
6788       gcc_unreachable ();
6789     }
6790   return code;
6791 }
6792
6793 /* Return comparison rtx for COND. Use UNSIGNEDP to select signed or
6794    unsigned operators. Do not generate compare instruction.  */
6795
6796 static rtx
6797 vector_compare_rtx (tree cond, bool unsignedp, enum insn_code icode)
6798 {
6799   enum rtx_code rcode;
6800   tree t_op0, t_op1;
6801   rtx rtx_op0, rtx_op1;
6802
6803   /* This is unlikely. While generating VEC_COND_EXPR, auto vectorizer
6804      ensures that condition is a relational operation.  */
6805   gcc_assert (COMPARISON_CLASS_P (cond));
6806
6807   rcode = get_rtx_code (TREE_CODE (cond), unsignedp);
6808   t_op0 = TREE_OPERAND (cond, 0);
6809   t_op1 = TREE_OPERAND (cond, 1);
6810
6811   /* Expand operands.  */
6812   rtx_op0 = expand_expr (t_op0, NULL_RTX, TYPE_MODE (TREE_TYPE (t_op0)),
6813                          EXPAND_STACK_PARM);
6814   rtx_op1 = expand_expr (t_op1, NULL_RTX, TYPE_MODE (TREE_TYPE (t_op1)),
6815                          EXPAND_STACK_PARM);
6816
6817   if (!insn_data[icode].operand[4].predicate (rtx_op0, GET_MODE (rtx_op0))
6818       && GET_MODE (rtx_op0) != VOIDmode)
6819     rtx_op0 = force_reg (GET_MODE (rtx_op0), rtx_op0);
6820
6821   if (!insn_data[icode].operand[5].predicate (rtx_op1, GET_MODE (rtx_op1))
6822       && GET_MODE (rtx_op1) != VOIDmode)
6823     rtx_op1 = force_reg (GET_MODE (rtx_op1), rtx_op1);
6824
6825   return gen_rtx_fmt_ee (rcode, VOIDmode, rtx_op0, rtx_op1);
6826 }
6827
6828 /* Return insn code for VEC_COND_EXPR EXPR.  */
6829
6830 static inline enum insn_code
6831 get_vcond_icode (tree expr, enum machine_mode mode)
6832 {
6833   enum insn_code icode = CODE_FOR_nothing;
6834
6835   if (TYPE_UNSIGNED (TREE_TYPE (expr)))
6836     icode = vcondu_gen_code[mode];
6837   else
6838     icode = vcond_gen_code[mode];
6839   return icode;
6840 }
6841
6842 /* Return TRUE iff, appropriate vector insns are available
6843    for vector cond expr expr in VMODE mode.  */
6844
6845 bool
6846 expand_vec_cond_expr_p (tree expr, enum machine_mode vmode)
6847 {
6848   if (get_vcond_icode (expr, vmode) == CODE_FOR_nothing)
6849     return false;
6850   return true;
6851 }
6852
6853 /* Generate insns for VEC_COND_EXPR.  */
6854
6855 rtx
6856 expand_vec_cond_expr (tree vec_cond_expr, rtx target)
6857 {
6858   enum insn_code icode;
6859   rtx comparison, rtx_op1, rtx_op2, cc_op0, cc_op1;
6860   enum machine_mode mode = TYPE_MODE (TREE_TYPE (vec_cond_expr));
6861   bool unsignedp = TYPE_UNSIGNED (TREE_TYPE (vec_cond_expr));
6862
6863   icode = get_vcond_icode (vec_cond_expr, mode);
6864   if (icode == CODE_FOR_nothing)
6865     return 0;
6866
6867   if (!target || !insn_data[icode].operand[0].predicate (target, mode))
6868     target = gen_reg_rtx (mode);
6869
6870   /* Get comparison rtx.  First expand both cond expr operands.  */
6871   comparison = vector_compare_rtx (TREE_OPERAND (vec_cond_expr, 0),
6872                                    unsignedp, icode);
6873   cc_op0 = XEXP (comparison, 0);
6874   cc_op1 = XEXP (comparison, 1);
6875   /* Expand both operands and force them in reg, if required.  */
6876   rtx_op1 = expand_normal (TREE_OPERAND (vec_cond_expr, 1));
6877   if (!insn_data[icode].operand[1].predicate (rtx_op1, mode)
6878       && mode != VOIDmode)
6879     rtx_op1 = force_reg (mode, rtx_op1);
6880
6881   rtx_op2 = expand_normal (TREE_OPERAND (vec_cond_expr, 2));
6882   if (!insn_data[icode].operand[2].predicate (rtx_op2, mode)
6883       && mode != VOIDmode)
6884     rtx_op2 = force_reg (mode, rtx_op2);
6885
6886   /* Emit instruction! */
6887   emit_insn (GEN_FCN (icode) (target, rtx_op1, rtx_op2,
6888                               comparison, cc_op0,  cc_op1));
6889
6890   return target;
6891 }
6892
6893 \f
6894 /* This is an internal subroutine of the other compare_and_swap expanders.
6895    MEM, OLD_VAL and NEW_VAL are as you'd expect for a compare-and-swap
6896    operation.  TARGET is an optional place to store the value result of
6897    the operation.  ICODE is the particular instruction to expand.  Return
6898    the result of the operation.  */
6899
6900 static rtx
6901 expand_val_compare_and_swap_1 (rtx mem, rtx old_val, rtx new_val,
6902                                rtx target, enum insn_code icode)
6903 {
6904   enum machine_mode mode = GET_MODE (mem);
6905   rtx insn;
6906
6907   if (!target || !insn_data[icode].operand[0].predicate (target, mode))
6908     target = gen_reg_rtx (mode);
6909
6910   if (GET_MODE (old_val) != VOIDmode && GET_MODE (old_val) != mode)
6911     old_val = convert_modes (mode, GET_MODE (old_val), old_val, 1);
6912   if (!insn_data[icode].operand[2].predicate (old_val, mode))
6913     old_val = force_reg (mode, old_val);
6914
6915   if (GET_MODE (new_val) != VOIDmode && GET_MODE (new_val) != mode)
6916     new_val = convert_modes (mode, GET_MODE (new_val), new_val, 1);
6917   if (!insn_data[icode].operand[3].predicate (new_val, mode))
6918     new_val = force_reg (mode, new_val);
6919
6920   insn = GEN_FCN (icode) (target, mem, old_val, new_val);
6921   if (insn == NULL_RTX)
6922     return NULL_RTX;
6923   emit_insn (insn);
6924
6925   return target;
6926 }
6927
6928 /* Expand a compare-and-swap operation and return its value.  */
6929
6930 rtx
6931 expand_val_compare_and_swap (rtx mem, rtx old_val, rtx new_val, rtx target)
6932 {
6933   enum machine_mode mode = GET_MODE (mem);
6934   enum insn_code icode = sync_compare_and_swap[mode];
6935
6936   if (icode == CODE_FOR_nothing)
6937     return NULL_RTX;
6938
6939   return expand_val_compare_and_swap_1 (mem, old_val, new_val, target, icode);
6940 }
6941
6942 /* Expand a compare-and-swap operation and store true into the result if
6943    the operation was successful and false otherwise.  Return the result.
6944    Unlike other routines, TARGET is not optional.  */
6945
6946 rtx
6947 expand_bool_compare_and_swap (rtx mem, rtx old_val, rtx new_val, rtx target)
6948 {
6949   enum machine_mode mode = GET_MODE (mem);
6950   enum insn_code icode;
6951   rtx subtarget, label0, label1;
6952
6953   /* If the target supports a compare-and-swap pattern that simultaneously
6954      sets some flag for success, then use it.  Otherwise use the regular
6955      compare-and-swap and follow that immediately with a compare insn.  */
6956   icode = sync_compare_and_swap_cc[mode];
6957   switch (icode)
6958     {
6959     default:
6960       subtarget = expand_val_compare_and_swap_1 (mem, old_val, new_val,
6961                                                  NULL_RTX, icode);
6962       if (subtarget != NULL_RTX)
6963         break;
6964
6965       /* FALLTHRU */
6966     case CODE_FOR_nothing:
6967       icode = sync_compare_and_swap[mode];
6968       if (icode == CODE_FOR_nothing)
6969         return NULL_RTX;
6970
6971       /* Ensure that if old_val == mem, that we're not comparing
6972          against an old value.  */
6973       if (MEM_P (old_val))
6974         old_val = force_reg (mode, old_val);
6975
6976       subtarget = expand_val_compare_and_swap_1 (mem, old_val, new_val,
6977                                                  NULL_RTX, icode);
6978       if (subtarget == NULL_RTX)
6979         return NULL_RTX;
6980
6981       emit_cmp_insn (subtarget, old_val, EQ, const0_rtx, mode, true);
6982     }
6983
6984   /* If the target has a sane STORE_FLAG_VALUE, then go ahead and use a
6985      setcc instruction from the beginning.  We don't work too hard here,
6986      but it's nice to not be stupid about initial code gen either.  */
6987   if (STORE_FLAG_VALUE == 1)
6988     {
6989       icode = setcc_gen_code[EQ];
6990       if (icode != CODE_FOR_nothing)
6991         {
6992           enum machine_mode cmode = insn_data[icode].operand[0].mode;
6993           rtx insn;
6994
6995           subtarget = target;
6996           if (!insn_data[icode].operand[0].predicate (target, cmode))
6997             subtarget = gen_reg_rtx (cmode);
6998
6999           insn = GEN_FCN (icode) (subtarget);
7000           if (insn)
7001             {
7002               emit_insn (insn);
7003               if (GET_MODE (target) != GET_MODE (subtarget))
7004                 {
7005                   convert_move (target, subtarget, 1);
7006                   subtarget = target;
7007                 }
7008               return subtarget;
7009             }
7010         }
7011     }
7012
7013   /* Without an appropriate setcc instruction, use a set of branches to
7014      get 1 and 0 stored into target.  Presumably if the target has a
7015      STORE_FLAG_VALUE that isn't 1, then this will get cleaned up by ifcvt.  */
7016
7017   label0 = gen_label_rtx ();
7018   label1 = gen_label_rtx ();
7019
7020   emit_jump_insn (bcc_gen_fctn[EQ] (label0));
7021   emit_move_insn (target, const0_rtx);
7022   emit_jump_insn (gen_jump (label1));
7023   emit_barrier ();
7024   emit_label (label0);
7025   emit_move_insn (target, const1_rtx);
7026   emit_label (label1);
7027
7028   return target;
7029 }
7030
7031 /* This is a helper function for the other atomic operations.  This function
7032    emits a loop that contains SEQ that iterates until a compare-and-swap
7033    operation at the end succeeds.  MEM is the memory to be modified.  SEQ is
7034    a set of instructions that takes a value from OLD_REG as an input and
7035    produces a value in NEW_REG as an output.  Before SEQ, OLD_REG will be
7036    set to the current contents of MEM.  After SEQ, a compare-and-swap will
7037    attempt to update MEM with NEW_REG.  The function returns true when the
7038    loop was generated successfully.  */
7039
7040 static bool
7041 expand_compare_and_swap_loop (rtx mem, rtx old_reg, rtx new_reg, rtx seq)
7042 {
7043   enum machine_mode mode = GET_MODE (mem);
7044   enum insn_code icode;
7045   rtx label, cmp_reg, subtarget;
7046
7047   /* The loop we want to generate looks like
7048
7049         cmp_reg = mem;
7050       label:
7051         old_reg = cmp_reg;
7052         seq;
7053         cmp_reg = compare-and-swap(mem, old_reg, new_reg)
7054         if (cmp_reg != old_reg)
7055           goto label;
7056
7057      Note that we only do the plain load from memory once.  Subsequent
7058      iterations use the value loaded by the compare-and-swap pattern.  */
7059
7060   label = gen_label_rtx ();
7061   cmp_reg = gen_reg_rtx (mode);
7062
7063   emit_move_insn (cmp_reg, mem);
7064   emit_label (label);
7065   emit_move_insn (old_reg, cmp_reg);
7066   if (seq)
7067     emit_insn (seq);
7068
7069   /* If the target supports a compare-and-swap pattern that simultaneously
7070      sets some flag for success, then use it.  Otherwise use the regular
7071      compare-and-swap and follow that immediately with a compare insn.  */
7072   icode = sync_compare_and_swap_cc[mode];
7073   switch (icode)
7074     {
7075     default:
7076       subtarget = expand_val_compare_and_swap_1 (mem, old_reg, new_reg,
7077                                                  cmp_reg, icode);
7078       if (subtarget != NULL_RTX)
7079         {
7080           gcc_assert (subtarget == cmp_reg);
7081           break;
7082         }
7083
7084       /* FALLTHRU */
7085     case CODE_FOR_nothing:
7086       icode = sync_compare_and_swap[mode];
7087       if (icode == CODE_FOR_nothing)
7088         return false;
7089
7090       subtarget = expand_val_compare_and_swap_1 (mem, old_reg, new_reg,
7091                                                  cmp_reg, icode);
7092       if (subtarget == NULL_RTX)
7093         return false;
7094       if (subtarget != cmp_reg)
7095         emit_move_insn (cmp_reg, subtarget);
7096
7097       emit_cmp_insn (cmp_reg, old_reg, EQ, const0_rtx, mode, true);
7098     }
7099
7100   /* ??? Mark this jump predicted not taken?  */
7101   emit_jump_insn (bcc_gen_fctn[NE] (label));
7102
7103   return true;
7104 }
7105
7106 /* This function generates the atomic operation MEM CODE= VAL.  In this
7107    case, we do not care about any resulting value.  Returns NULL if we
7108    cannot generate the operation.  */
7109
7110 rtx
7111 expand_sync_operation (rtx mem, rtx val, enum rtx_code code)
7112 {
7113   enum machine_mode mode = GET_MODE (mem);
7114   enum insn_code icode;
7115   rtx insn;
7116
7117   /* Look to see if the target supports the operation directly.  */
7118   switch (code)
7119     {
7120     case PLUS:
7121       icode = sync_add_optab[mode];
7122       break;
7123     case IOR:
7124       icode = sync_ior_optab[mode];
7125       break;
7126     case XOR:
7127       icode = sync_xor_optab[mode];
7128       break;
7129     case AND:
7130       icode = sync_and_optab[mode];
7131       break;
7132     case NOT:
7133       icode = sync_nand_optab[mode];
7134       break;
7135
7136     case MINUS:
7137       icode = sync_sub_optab[mode];
7138       if (icode == CODE_FOR_nothing || CONST_INT_P (val))
7139         {
7140           icode = sync_add_optab[mode];
7141           if (icode != CODE_FOR_nothing)
7142             {
7143               val = expand_simple_unop (mode, NEG, val, NULL_RTX, 1);
7144               code = PLUS;
7145             }
7146         }
7147       break;
7148
7149     default:
7150       gcc_unreachable ();
7151     }
7152
7153   /* Generate the direct operation, if present.  */
7154   if (icode != CODE_FOR_nothing)
7155     {
7156       if (GET_MODE (val) != VOIDmode && GET_MODE (val) != mode)
7157         val = convert_modes (mode, GET_MODE (val), val, 1);
7158       if (!insn_data[icode].operand[1].predicate (val, mode))
7159         val = force_reg (mode, val);
7160
7161       insn = GEN_FCN (icode) (mem, val);
7162       if (insn)
7163         {
7164           emit_insn (insn);
7165           return const0_rtx;
7166         }
7167     }
7168
7169   /* Failing that, generate a compare-and-swap loop in which we perform the
7170      operation with normal arithmetic instructions.  */
7171   if (sync_compare_and_swap[mode] != CODE_FOR_nothing)
7172     {
7173       rtx t0 = gen_reg_rtx (mode), t1;
7174
7175       start_sequence ();
7176
7177       t1 = t0;
7178       if (code == NOT)
7179         {
7180           t1 = expand_simple_unop (mode, NOT, t1, NULL_RTX, true);
7181           code = AND;
7182         }
7183       t1 = expand_simple_binop (mode, code, t1, val, NULL_RTX,
7184                                 true, OPTAB_LIB_WIDEN);
7185
7186       insn = get_insns ();
7187       end_sequence ();
7188
7189       if (t1 != NULL && expand_compare_and_swap_loop (mem, t0, t1, insn))
7190         return const0_rtx;
7191     }
7192
7193   return NULL_RTX;
7194 }
7195
7196 /* This function generates the atomic operation MEM CODE= VAL.  In this
7197    case, we do care about the resulting value: if AFTER is true then
7198    return the value MEM holds after the operation, if AFTER is false
7199    then return the value MEM holds before the operation.  TARGET is an
7200    optional place for the result value to be stored.  */
7201
7202 rtx
7203 expand_sync_fetch_operation (rtx mem, rtx val, enum rtx_code code,
7204                              bool after, rtx target)
7205 {
7206   enum machine_mode mode = GET_MODE (mem);
7207   enum insn_code old_code, new_code, icode;
7208   bool compensate;
7209   rtx insn;
7210
7211   /* Look to see if the target supports the operation directly.  */
7212   switch (code)
7213     {
7214     case PLUS:
7215       old_code = sync_old_add_optab[mode];
7216       new_code = sync_new_add_optab[mode];
7217       break;
7218     case IOR:
7219       old_code = sync_old_ior_optab[mode];
7220       new_code = sync_new_ior_optab[mode];
7221       break;
7222     case XOR:
7223       old_code = sync_old_xor_optab[mode];
7224       new_code = sync_new_xor_optab[mode];
7225       break;
7226     case AND:
7227       old_code = sync_old_and_optab[mode];
7228       new_code = sync_new_and_optab[mode];
7229       break;
7230     case NOT:
7231       old_code = sync_old_nand_optab[mode];
7232       new_code = sync_new_nand_optab[mode];
7233       break;
7234
7235     case MINUS:
7236       old_code = sync_old_sub_optab[mode];
7237       new_code = sync_new_sub_optab[mode];
7238       if ((old_code == CODE_FOR_nothing && new_code == CODE_FOR_nothing)
7239           || CONST_INT_P (val))
7240         {
7241           old_code = sync_old_add_optab[mode];
7242           new_code = sync_new_add_optab[mode];
7243           if (old_code != CODE_FOR_nothing || new_code != CODE_FOR_nothing)
7244             {
7245               val = expand_simple_unop (mode, NEG, val, NULL_RTX, 1);
7246               code = PLUS;
7247             }
7248         }
7249       break;
7250
7251     default:
7252       gcc_unreachable ();
7253     }
7254
7255   /* If the target does supports the proper new/old operation, great.  But
7256      if we only support the opposite old/new operation, check to see if we
7257      can compensate.  In the case in which the old value is supported, then
7258      we can always perform the operation again with normal arithmetic.  In
7259      the case in which the new value is supported, then we can only handle
7260      this in the case the operation is reversible.  */
7261   compensate = false;
7262   if (after)
7263     {
7264       icode = new_code;
7265       if (icode == CODE_FOR_nothing)
7266         {
7267           icode = old_code;
7268           if (icode != CODE_FOR_nothing)
7269             compensate = true;
7270         }
7271     }
7272   else
7273     {
7274       icode = old_code;
7275       if (icode == CODE_FOR_nothing
7276           && (code == PLUS || code == MINUS || code == XOR))
7277         {
7278           icode = new_code;
7279           if (icode != CODE_FOR_nothing)
7280             compensate = true;
7281         }
7282     }
7283
7284   /* If we found something supported, great.  */
7285   if (icode != CODE_FOR_nothing)
7286     {
7287       if (!target || !insn_data[icode].operand[0].predicate (target, mode))
7288         target = gen_reg_rtx (mode);
7289
7290       if (GET_MODE (val) != VOIDmode && GET_MODE (val) != mode)
7291         val = convert_modes (mode, GET_MODE (val), val, 1);
7292       if (!insn_data[icode].operand[2].predicate (val, mode))
7293         val = force_reg (mode, val);
7294
7295       insn = GEN_FCN (icode) (target, mem, val);
7296       if (insn)
7297         {
7298           emit_insn (insn);
7299
7300           /* If we need to compensate for using an operation with the
7301              wrong return value, do so now.  */
7302           if (compensate)
7303             {
7304               if (!after)
7305                 {
7306                   if (code == PLUS)
7307                     code = MINUS;
7308                   else if (code == MINUS)
7309                     code = PLUS;
7310                 }
7311
7312               if (code == NOT)
7313                 target = expand_simple_unop (mode, NOT, target, NULL_RTX, true);
7314               target = expand_simple_binop (mode, code, target, val, NULL_RTX,
7315                                             true, OPTAB_LIB_WIDEN);
7316             }
7317
7318           return target;
7319         }
7320     }
7321
7322   /* Failing that, generate a compare-and-swap loop in which we perform the
7323      operation with normal arithmetic instructions.  */
7324   if (sync_compare_and_swap[mode] != CODE_FOR_nothing)
7325     {
7326       rtx t0 = gen_reg_rtx (mode), t1;
7327
7328       if (!target || !register_operand (target, mode))
7329         target = gen_reg_rtx (mode);
7330
7331       start_sequence ();
7332
7333       if (!after)
7334         emit_move_insn (target, t0);
7335       t1 = t0;
7336       if (code == NOT)
7337         {
7338           t1 = expand_simple_unop (mode, NOT, t1, NULL_RTX, true);
7339           code = AND;
7340         }
7341       t1 = expand_simple_binop (mode, code, t1, val, NULL_RTX,
7342                                 true, OPTAB_LIB_WIDEN);
7343       if (after)
7344         emit_move_insn (target, t1);
7345
7346       insn = get_insns ();
7347       end_sequence ();
7348
7349       if (t1 != NULL && expand_compare_and_swap_loop (mem, t0, t1, insn))
7350         return target;
7351     }
7352
7353   return NULL_RTX;
7354 }
7355
7356 /* This function expands a test-and-set operation.  Ideally we atomically
7357    store VAL in MEM and return the previous value in MEM.  Some targets
7358    may not support this operation and only support VAL with the constant 1;
7359    in this case while the return value will be 0/1, but the exact value
7360    stored in MEM is target defined.  TARGET is an option place to stick
7361    the return value.  */
7362
7363 rtx
7364 expand_sync_lock_test_and_set (rtx mem, rtx val, rtx target)
7365 {
7366   enum machine_mode mode = GET_MODE (mem);
7367   enum insn_code icode;
7368   rtx insn;
7369
7370   /* If the target supports the test-and-set directly, great.  */
7371   icode = sync_lock_test_and_set[mode];
7372   if (icode != CODE_FOR_nothing)
7373     {
7374       if (!target || !insn_data[icode].operand[0].predicate (target, mode))
7375         target = gen_reg_rtx (mode);
7376
7377       if (GET_MODE (val) != VOIDmode && GET_MODE (val) != mode)
7378         val = convert_modes (mode, GET_MODE (val), val, 1);
7379       if (!insn_data[icode].operand[2].predicate (val, mode))
7380         val = force_reg (mode, val);
7381
7382       insn = GEN_FCN (icode) (target, mem, val);
7383       if (insn)
7384         {
7385           emit_insn (insn);
7386           return target;
7387         }
7388     }
7389
7390   /* Otherwise, use a compare-and-swap loop for the exchange.  */
7391   if (sync_compare_and_swap[mode] != CODE_FOR_nothing)
7392     {
7393       if (!target || !register_operand (target, mode))
7394         target = gen_reg_rtx (mode);
7395       if (GET_MODE (val) != VOIDmode && GET_MODE (val) != mode)
7396         val = convert_modes (mode, GET_MODE (val), val, 1);
7397       if (expand_compare_and_swap_loop (mem, target, val, NULL_RTX))
7398         return target;
7399     }
7400
7401   return NULL_RTX;
7402 }
7403
7404 #include "gt-optabs.h"