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