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