gcc/expr.c

   1 /* Convert tree expression to rtl instructions, for GNU compiler.
   2    Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   3    2000, 2001, 2002 Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "machmode.h"
  25 #include "rtl.h"
  26 #include "tree.h"
  27 #include "obstack.h"
  28 #include "flags.h"
  29 #include "regs.h"
  30 #include "hard-reg-set.h"
  31 #include "except.h"
  32 #include "function.h"
  33 #include "insn-config.h"
  34 #include "insn-attr.h"
  35 /* Include expr.h after insn-config.h so we get HAVE_conditional_move.  */
  36 #include "expr.h"
  37 #include "optabs.h"
  38 #include "libfuncs.h"
  39 #include "recog.h"
  40 #include "reload.h"
  41 #include "output.h"
  42 #include "typeclass.h"
  43 #include "toplev.h"
  44 #include "ggc.h"
  45 #include "langhooks.h"
  46 #include "intl.h"
  47 #include "tm_p.h"
  48
  49 /* Decide whether a function's arguments should be processed
  50    from first to last or from last to first.
  51
  52    They should if the stack and args grow in opposite directions, but
  53    only if we have push insns.  */
  54
  55 #ifdef PUSH_ROUNDING
  56
  57 #if defined (STACK_GROWS_DOWNWARD) != defined (ARGS_GROW_DOWNWARD)
  58 #define PUSH_ARGS_REVERSED      /* If it's last to first.  */
  59 #endif
  60
  61 #endif
  62
  63 #ifndef STACK_PUSH_CODE
  64 #ifdef STACK_GROWS_DOWNWARD
  65 #define STACK_PUSH_CODE PRE_DEC
  66 #else
  67 #define STACK_PUSH_CODE PRE_INC
  68 #endif
  69 #endif
  70
  71 /* Assume that case vectors are not pc-relative.  */
  72 #ifndef CASE_VECTOR_PC_RELATIVE
  73 #define CASE_VECTOR_PC_RELATIVE 0
  74 #endif
  75
  76 /* If this is nonzero, we do not bother generating VOLATILE
  77    around volatile memory references, and we are willing to
  78    output indirect addresses.  If cse is to follow, we reject
  79    indirect addresses so a useful potential cse is generated;
  80    if it is used only once, instruction combination will produce
  81    the same indirect address eventually.  */
  82 int cse_not_expected;
  83
  84 /* Chain of pending expressions for PLACEHOLDER_EXPR to replace.  */
  85 static tree placeholder_list = 0;
  86
  87 /* This structure is used by move_by_pieces to describe the move to
  88    be performed.  */
  89 struct move_by_pieces
  90 {
  91   rtx to;
  92   rtx to_addr;
  93   int autinc_to;
  94   int explicit_inc_to;
  95   rtx from;
  96   rtx from_addr;
  97   int autinc_from;
  98   int explicit_inc_from;
  99   unsigned HOST_WIDE_INT len;
 100   HOST_WIDE_INT offset;
 101   int reverse;
 102 };
 103
 104 /* This structure is used by store_by_pieces to describe the clear to
 105    be performed.  */
 106
 107 struct store_by_pieces
 108 {
 109   rtx to;
 110   rtx to_addr;
 111   int autinc_to;
 112   int explicit_inc_to;
 113   unsigned HOST_WIDE_INT len;
 114   HOST_WIDE_INT offset;
 115   rtx (*constfun) PARAMS ((PTR, HOST_WIDE_INT, enum machine_mode));
 116   PTR constfundata;
 117   int reverse;
 118 };
 119
 120 extern struct obstack permanent_obstack;
 121
 122 static rtx enqueue_insn         PARAMS ((rtx, rtx));
 123 static unsigned HOST_WIDE_INT move_by_pieces_ninsns
 124                                 PARAMS ((unsigned HOST_WIDE_INT,
 125                                          unsigned int));
 126 static void move_by_pieces_1    PARAMS ((rtx (*) (rtx, ...), enum machine_mode,
 127                                          struct move_by_pieces *));
 128 static rtx clear_by_pieces_1    PARAMS ((PTR, HOST_WIDE_INT,
 129                                          enum machine_mode));
 130 static void clear_by_pieces     PARAMS ((rtx, unsigned HOST_WIDE_INT,
 131                                          unsigned int));
 132 static void store_by_pieces_1   PARAMS ((struct store_by_pieces *,
 133                                          unsigned int));
 134 static void store_by_pieces_2   PARAMS ((rtx (*) (rtx, ...),
 135                                          enum machine_mode,
 136                                          struct store_by_pieces *));
 137 static rtx get_subtarget        PARAMS ((rtx));
 138 static int is_zeros_p           PARAMS ((tree));
 139 static int mostly_zeros_p       PARAMS ((tree));
 140 static void store_constructor_field PARAMS ((rtx, unsigned HOST_WIDE_INT,
 141                                              HOST_WIDE_INT, enum machine_mode,
 142                                              tree, tree, int, int));
 143 static void store_constructor   PARAMS ((tree, rtx, int, HOST_WIDE_INT));
 144 static rtx store_field          PARAMS ((rtx, HOST_WIDE_INT,
 145                                          HOST_WIDE_INT, enum machine_mode,
 146                                          tree, enum machine_mode, int, tree,
 147                                          int));
 148 static rtx var_rtx              PARAMS ((tree));
 149 static HOST_WIDE_INT highest_pow2_factor PARAMS ((tree));
 150 static rtx expand_increment     PARAMS ((tree, int, int));
 151 static void do_jump_by_parts_greater PARAMS ((tree, int, rtx, rtx));
 152 static void do_jump_by_parts_equality PARAMS ((tree, rtx, rtx));
 153 static void do_compare_and_jump PARAMS ((tree, enum rtx_code, enum rtx_code,
 154                                          rtx, rtx));
 155 static rtx do_store_flag        PARAMS ((tree, rtx, enum machine_mode, int));
 156 #ifdef PUSH_ROUNDING
 157 static void emit_single_push_insn PARAMS ((enum machine_mode, rtx, tree));
 158 #endif
 159 static void do_tablejump PARAMS ((rtx, enum machine_mode, rtx, rtx, rtx));
 160
 161 /* Record for each mode whether we can move a register directly to or
 162    from an object of that mode in memory.  If we can't, we won't try
 163    to use that mode directly when accessing a field of that mode.  */
 164
 165 static char direct_load[NUM_MACHINE_MODES];
 166 static char direct_store[NUM_MACHINE_MODES];
 167
 168 /* If a memory-to-memory move would take MOVE_RATIO or more simple
 169    move-instruction sequences, we will do a movstr or libcall instead.  */
 170
 171 #ifndef MOVE_RATIO
 172 #if defined (HAVE_movstrqi) || defined (HAVE_movstrhi) || defined (HAVE_movstrsi) || defined (HAVE_movstrdi) || defined (HAVE_movstrti)
 173 #define MOVE_RATIO 2
 174 #else
 175 /* If we are optimizing for space (-Os), cut down the default move ratio.  */
 176 #define MOVE_RATIO (optimize_size ? 3 : 15)
 177 #endif
 178 #endif
 179
 180 /* This macro is used to determine whether move_by_pieces should be called
 181    to perform a structure copy.  */
 182 #ifndef MOVE_BY_PIECES_P
 183 #define MOVE_BY_PIECES_P(SIZE, ALIGN) \
 184   (move_by_pieces_ninsns (SIZE, ALIGN) < (unsigned int) MOVE_RATIO)
 185 #endif
 186
 187 /* This array records the insn_code of insns to perform block moves.  */
 188 enum insn_code movstr_optab[NUM_MACHINE_MODES];
 189
 190 /* This array records the insn_code of insns to perform block clears.  */
 191 enum insn_code clrstr_optab[NUM_MACHINE_MODES];
 192
 193 /* SLOW_UNALIGNED_ACCESS is non-zero if unaligned accesses are very slow.  */
 194
 195 #ifndef SLOW_UNALIGNED_ACCESS
 196 #define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) STRICT_ALIGNMENT
 197 #endif
 198 \f
 199 /* This is run once per compilation to set up which modes can be used
 200    directly in memory and to initialize the block move optab.  */
 201
 202 void
 203 init_expr_once ()
 204 {
 205   rtx insn, pat;
 206   enum machine_mode mode;
 207   int num_clobbers;
 208   rtx mem, mem1;
 209
 210   start_sequence ();
 211
 212   /* Try indexing by frame ptr and try by stack ptr.
 213      It is known that on the Convex the stack ptr isn't a valid index.
 214      With luck, one or the other is valid on any machine.  */
 215   mem = gen_rtx_MEM (VOIDmode, stack_pointer_rtx);
 216   mem1 = gen_rtx_MEM (VOIDmode, frame_pointer_rtx);
 217
 218   insn = emit_insn (gen_rtx_SET (0, NULL_RTX, NULL_RTX));
 219   pat = PATTERN (insn);
 220
 221   for (mode = VOIDmode; (int) mode < NUM_MACHINE_MODES;
 222        mode = (enum machine_mode) ((int) mode + 1))
 223     {
 224       int regno;
 225       rtx reg;
 226
 227       direct_load[(int) mode] = direct_store[(int) mode] = 0;
 228       PUT_MODE (mem, mode);
 229       PUT_MODE (mem1, mode);
 230
 231       /* See if there is some register that can be used in this mode and
 232          directly loaded or stored from memory.  */
 233
 234       if (mode != VOIDmode && mode != BLKmode)
 235         for (regno = 0; regno < FIRST_PSEUDO_REGISTER
 236              && (direct_load[(int) mode] == 0 || direct_store[(int) mode] == 0);
 237              regno++)
 238           {
 239             if (! HARD_REGNO_MODE_OK (regno, mode))
 240               continue;
 241
 242             reg = gen_rtx_REG (mode, regno);
 243
 244             SET_SRC (pat) = mem;
 245             SET_DEST (pat) = reg;
 246             if (recog (pat, insn, &num_clobbers) >= 0)
 247               direct_load[(int) mode] = 1;
 248
 249             SET_SRC (pat) = mem1;
 250             SET_DEST (pat) = reg;
 251             if (recog (pat, insn, &num_clobbers) >= 0)
 252               direct_load[(int) mode] = 1;
 253
 254             SET_SRC (pat) = reg;
 255             SET_DEST (pat) = mem;
 256             if (recog (pat, insn, &num_clobbers) >= 0)
 257               direct_store[(int) mode] = 1;
 258
 259             SET_SRC (pat) = reg;
 260             SET_DEST (pat) = mem1;
 261             if (recog (pat, insn, &num_clobbers) >= 0)
 262               direct_store[(int) mode] = 1;
 263           }
 264     }
 265
 266   end_sequence ();
 267 }
 268
 269 /* This is run at the start of compiling a function.  */
 270
 271 void
 272 init_expr ()
 273 {
 274   cfun->expr = (struct expr_status *) xmalloc (sizeof (struct expr_status));
 275
 276   pending_chain = 0;
 277   pending_stack_adjust = 0;
 278   stack_pointer_delta = 0;
 279   inhibit_defer_pop = 0;
 280   saveregs_value = 0;
 281   apply_args_value = 0;
 282   forced_labels = 0;
 283 }
 284
 285 void
 286 mark_expr_status (p)
 287      struct expr_status *p;
 288 {
 289   if (p == NULL)
 290     return;
 291
 292   ggc_mark_rtx (p->x_saveregs_value);
 293   ggc_mark_rtx (p->x_apply_args_value);
 294   ggc_mark_rtx (p->x_forced_labels);
 295 }
 296
 297 void
 298 free_expr_status (f)
 299      struct function *f;
 300 {
 301   free (f->expr);
 302   f->expr = NULL;
 303 }
 304
 305 /* Small sanity check that the queue is empty at the end of a function.  */
 306
 307 void
 308 finish_expr_for_function ()
 309 {
 310   if (pending_chain)
 311     abort ();
 312 }
 313 \f
 314 /* Manage the queue of increment instructions to be output
 315    for POSTINCREMENT_EXPR expressions, etc.  */
 316
 317 /* Queue up to increment (or change) VAR later.  BODY says how:
 318    BODY should be the same thing you would pass to emit_insn
 319    to increment right away.  It will go to emit_insn later on.
 320
 321    The value is a QUEUED expression to be used in place of VAR
 322    where you want to guarantee the pre-incrementation value of VAR.  */
 323
 324 static rtx
 325 enqueue_insn (var, body)
 326      rtx var, body;
 327 {
 328   pending_chain = gen_rtx_QUEUED (GET_MODE (var), var, NULL_RTX, NULL_RTX,
 329                                   body, pending_chain);
 330   return pending_chain;
 331 }
 332
 333 /* Use protect_from_queue to convert a QUEUED expression
 334    into something that you can put immediately into an instruction.
 335    If the queued incrementation has not happened yet,
 336    protect_from_queue returns the variable itself.
 337    If the incrementation has happened, protect_from_queue returns a temp
 338    that contains a copy of the old value of the variable.
 339
 340    Any time an rtx which might possibly be a QUEUED is to be put
 341    into an instruction, it must be passed through protect_from_queue first.
 342    QUEUED expressions are not meaningful in instructions.
 343
 344    Do not pass a value through protect_from_queue and then hold
 345    on to it for a while before putting it in an instruction!
 346    If the queue is flushed in between, incorrect code will result.  */
 347
 348 rtx
 349 protect_from_queue (x, modify)
 350      rtx x;
 351      int modify;
 352 {
 353   RTX_CODE code = GET_CODE (x);
 354
 355 #if 0  /* A QUEUED can hang around after the queue is forced out.  */
 356   /* Shortcut for most common case.  */
 357   if (pending_chain == 0)
 358     return x;
 359 #endif
 360
 361   if (code != QUEUED)
 362     {
 363       /* A special hack for read access to (MEM (QUEUED ...)) to facilitate
 364          use of autoincrement.  Make a copy of the contents of the memory
 365          location rather than a copy of the address, but not if the value is
 366          of mode BLKmode.  Don't modify X in place since it might be
 367          shared.  */
 368       if (code == MEM && GET_MODE (x) != BLKmode
 369           && GET_CODE (XEXP (x, 0)) == QUEUED && !modify)
 370         {
 371           rtx y = XEXP (x, 0);
 372           rtx new = replace_equiv_address_nv (x, QUEUED_VAR (y));
 373
 374           if (QUEUED_INSN (y))
 375             {
 376               rtx temp = gen_reg_rtx (GET_MODE (x));
 377
 378               emit_insn_before (gen_move_insn (temp, new),
 379                                 QUEUED_INSN (y));
 380               return temp;
 381             }
 382
 383           /* Copy the address into a pseudo, so that the returned value
 384              remains correct across calls to emit_queue.  */
 385           return replace_equiv_address (new, copy_to_reg (XEXP (new, 0)));
 386         }
 387
 388       /* Otherwise, recursively protect the subexpressions of all
 389          the kinds of rtx's that can contain a QUEUED.  */
 390       if (code == MEM)
 391         {
 392           rtx tem = protect_from_queue (XEXP (x, 0), 0);
 393           if (tem != XEXP (x, 0))
 394             {
 395               x = copy_rtx (x);
 396               XEXP (x, 0) = tem;
 397             }
 398         }
 399       else if (code == PLUS || code == MULT)
 400         {
 401           rtx new0 = protect_from_queue (XEXP (x, 0), 0);
 402           rtx new1 = protect_from_queue (XEXP (x, 1), 0);
 403           if (new0 != XEXP (x, 0) || new1 != XEXP (x, 1))
 404             {
 405               x = copy_rtx (x);
 406               XEXP (x, 0) = new0;
 407               XEXP (x, 1) = new1;
 408             }
 409         }
 410       return x;
 411     }
 412   /* If the increment has not happened, use the variable itself.  Copy it
 413      into a new pseudo so that the value remains correct across calls to
 414      emit_queue.  */
 415   if (QUEUED_INSN (x) == 0)
 416     return copy_to_reg (QUEUED_VAR (x));
 417   /* If the increment has happened and a pre-increment copy exists,
 418      use that copy.  */
 419   if (QUEUED_COPY (x) != 0)
 420     return QUEUED_COPY (x);
 421   /* The increment has happened but we haven't set up a pre-increment copy.
 422      Set one up now, and use it.  */
 423   QUEUED_COPY (x) = gen_reg_rtx (GET_MODE (QUEUED_VAR (x)));
 424   emit_insn_before (gen_move_insn (QUEUED_COPY (x), QUEUED_VAR (x)),
 425                     QUEUED_INSN (x));
 426   return QUEUED_COPY (x);
 427 }
 428
 429 /* Return nonzero if X contains a QUEUED expression:
 430    if it contains anything that will be altered by a queued increment.
 431    We handle only combinations of MEM, PLUS, MINUS and MULT operators
 432    since memory addresses generally contain only those.  */
 433
 434 int
 435 queued_subexp_p (x)
 436      rtx x;
 437 {
 438   enum rtx_code code = GET_CODE (x);
 439   switch (code)
 440     {
 441     case QUEUED:
 442       return 1;
 443     case MEM:
 444       return queued_subexp_p (XEXP (x, 0));
 445     case MULT:
 446     case PLUS:
 447     case MINUS:
 448       return (queued_subexp_p (XEXP (x, 0))
 449               || queued_subexp_p (XEXP (x, 1)));
 450     default:
 451       return 0;
 452     }
 453 }
 454
 455 /* Perform all the pending incrementations.  */
 456
 457 void
 458 emit_queue ()
 459 {
 460   rtx p;
 461   while ((p = pending_chain))
 462     {
 463       rtx body = QUEUED_BODY (p);
 464
 465       if (GET_CODE (body) == SEQUENCE)
 466         {
 467           QUEUED_INSN (p) = XVECEXP (QUEUED_BODY (p), 0, 0);
 468           emit_insn (QUEUED_BODY (p));
 469         }
 470       else
 471         QUEUED_INSN (p) = emit_insn (QUEUED_BODY (p));
 472       pending_chain = QUEUED_NEXT (p);
 473     }
 474 }
 475 \f
 476 /* Copy data from FROM to TO, where the machine modes are not the same.
 477    Both modes may be integer, or both may be floating.
 478    UNSIGNEDP should be nonzero if FROM is an unsigned type.
 479    This causes zero-extension instead of sign-extension.  */
 480
 481 void
 482 convert_move (to, from, unsignedp)
 483      rtx to, from;
 484      int unsignedp;
 485 {
 486   enum machine_mode to_mode = GET_MODE (to);
 487   enum machine_mode from_mode = GET_MODE (from);
 488   int to_real = GET_MODE_CLASS (to_mode) == MODE_FLOAT;
 489   int from_real = GET_MODE_CLASS (from_mode) == MODE_FLOAT;
 490   enum insn_code code;
 491   rtx libcall;
 492
 493   /* rtx code for making an equivalent value.  */
 494   enum rtx_code equiv_code = (unsignedp ? ZERO_EXTEND : SIGN_EXTEND);
 495
 496   to = protect_from_queue (to, 1);
 497   from = protect_from_queue (from, 0);
 498
 499   if (to_real != from_real)
 500     abort ();
 501
 502   /* If FROM is a SUBREG that indicates that we have already done at least
 503      the required extension, strip it.  We don't handle such SUBREGs as
 504      TO here.  */
 505
 506   if (GET_CODE (from) == SUBREG && SUBREG_PROMOTED_VAR_P (from)
 507       && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (from)))
 508           >= GET_MODE_SIZE (to_mode))
 509       && SUBREG_PROMOTED_UNSIGNED_P (from) == unsignedp)
 510     from = gen_lowpart (to_mode, from), from_mode = to_mode;
 511
 512   if (GET_CODE (to) == SUBREG && SUBREG_PROMOTED_VAR_P (to))
 513     abort ();
 514
 515   if (to_mode == from_mode
 516       || (from_mode == VOIDmode && CONSTANT_P (from)))
 517     {
 518       emit_move_insn (to, from);
 519       return;
 520     }
 521
 522   if (VECTOR_MODE_P (to_mode) || VECTOR_MODE_P (from_mode))
 523     {
 524       if (GET_MODE_BITSIZE (from_mode) != GET_MODE_BITSIZE (to_mode))
 525         abort ();
 526
 527       if (VECTOR_MODE_P (to_mode))
 528         from = simplify_gen_subreg (to_mode, from, GET_MODE (from), 0);
 529       else
 530         to = simplify_gen_subreg (from_mode, to, GET_MODE (to), 0);
 531
 532       emit_move_insn (to, from);
 533       return;
 534     }
 535
 536   if (to_real != from_real)
 537     abort ();
 538
 539   if (to_real)
 540     {
 541       rtx value, insns;
 542
 543       if (GET_MODE_BITSIZE (from_mode) < GET_MODE_BITSIZE (to_mode))
 544         {
 545           /* Try converting directly if the insn is supported.  */
 546           if ((code = can_extend_p (to_mode, from_mode, 0))
 547               != CODE_FOR_nothing)
 548             {
 549               emit_unop_insn (code, to, from, UNKNOWN);
 550               return;
 551             }
 552         }
 553
 554 #ifdef HAVE_trunchfqf2
 555       if (HAVE_trunchfqf2 && from_mode == HFmode && to_mode == QFmode)
 556         {
 557           emit_unop_insn (CODE_FOR_trunchfqf2, to, from, UNKNOWN);
 558           return;
 559         }
 560 #endif
 561 #ifdef HAVE_trunctqfqf2
 562       if (HAVE_trunctqfqf2 && from_mode == TQFmode && to_mode == QFmode)
 563         {
 564           emit_unop_insn (CODE_FOR_trunctqfqf2, to, from, UNKNOWN);
 565           return;
 566         }
 567 #endif
 568 #ifdef HAVE_truncsfqf2
 569       if (HAVE_truncsfqf2 && from_mode == SFmode && to_mode == QFmode)
 570         {
 571           emit_unop_insn (CODE_FOR_truncsfqf2, to, from, UNKNOWN);
 572           return;
 573         }
 574 #endif
 575 #ifdef HAVE_truncdfqf2
 576       if (HAVE_truncdfqf2 && from_mode == DFmode && to_mode == QFmode)
 577         {
 578           emit_unop_insn (CODE_FOR_truncdfqf2, to, from, UNKNOWN);
 579           return;
 580         }
 581 #endif
 582 #ifdef HAVE_truncxfqf2
 583       if (HAVE_truncxfqf2 && from_mode == XFmode && to_mode == QFmode)
 584         {
 585           emit_unop_insn (CODE_FOR_truncxfqf2, to, from, UNKNOWN);
 586           return;
 587         }
 588 #endif
 589 #ifdef HAVE_trunctfqf2
 590       if (HAVE_trunctfqf2 && from_mode == TFmode && to_mode == QFmode)
 591         {
 592           emit_unop_insn (CODE_FOR_trunctfqf2, to, from, UNKNOWN);
 593           return;
 594         }
 595 #endif
 596
 597 #ifdef HAVE_trunctqfhf2
 598       if (HAVE_trunctqfhf2 && from_mode == TQFmode && to_mode == HFmode)
 599         {
 600           emit_unop_insn (CODE_FOR_trunctqfhf2, to, from, UNKNOWN);
 601           return;
 602         }
 603 #endif
 604 #ifdef HAVE_truncsfhf2
 605       if (HAVE_truncsfhf2 && from_mode == SFmode && to_mode == HFmode)
 606         {
 607           emit_unop_insn (CODE_FOR_truncsfhf2, to, from, UNKNOWN);
 608           return;
 609         }
 610 #endif
 611 #ifdef HAVE_truncdfhf2
 612       if (HAVE_truncdfhf2 && from_mode == DFmode && to_mode == HFmode)
 613         {
 614           emit_unop_insn (CODE_FOR_truncdfhf2, to, from, UNKNOWN);
 615           return;
 616         }
 617 #endif
 618 #ifdef HAVE_truncxfhf2
 619       if (HAVE_truncxfhf2 && from_mode == XFmode && to_mode == HFmode)
 620         {
 621           emit_unop_insn (CODE_FOR_truncxfhf2, to, from, UNKNOWN);
 622           return;
 623         }
 624 #endif
 625 #ifdef HAVE_trunctfhf2
 626       if (HAVE_trunctfhf2 && from_mode == TFmode && to_mode == HFmode)
 627         {
 628           emit_unop_insn (CODE_FOR_trunctfhf2, to, from, UNKNOWN);
 629           return;
 630         }
 631 #endif
 632
 633 #ifdef HAVE_truncsftqf2
 634       if (HAVE_truncsftqf2 && from_mode == SFmode && to_mode == TQFmode)
 635         {
 636           emit_unop_insn (CODE_FOR_truncsftqf2, to, from, UNKNOWN);
 637           return;
 638         }
 639 #endif
 640 #ifdef HAVE_truncdftqf2
 641       if (HAVE_truncdftqf2 && from_mode == DFmode && to_mode == TQFmode)
 642         {
 643           emit_unop_insn (CODE_FOR_truncdftqf2, to, from, UNKNOWN);
 644           return;
 645         }
 646 #endif
 647 #ifdef HAVE_truncxftqf2
 648       if (HAVE_truncxftqf2 && from_mode == XFmode && to_mode == TQFmode)
 649         {
 650           emit_unop_insn (CODE_FOR_truncxftqf2, to, from, UNKNOWN);
 651           return;
 652         }
 653 #endif
 654 #ifdef HAVE_trunctftqf2
 655       if (HAVE_trunctftqf2 && from_mode == TFmode && to_mode == TQFmode)
 656         {
 657           emit_unop_insn (CODE_FOR_trunctftqf2, to, from, UNKNOWN);
 658           return;
 659         }
 660 #endif
 661
 662 #ifdef HAVE_truncdfsf2
 663       if (HAVE_truncdfsf2 && from_mode == DFmode && to_mode == SFmode)
 664         {
 665           emit_unop_insn (CODE_FOR_truncdfsf2, to, from, UNKNOWN);
 666           return;
 667         }
 668 #endif
 669 #ifdef HAVE_truncxfsf2
 670       if (HAVE_truncxfsf2 && from_mode == XFmode && to_mode == SFmode)
 671         {
 672           emit_unop_insn (CODE_FOR_truncxfsf2, to, from, UNKNOWN);
 673           return;
 674         }
 675 #endif
 676 #ifdef HAVE_trunctfsf2
 677       if (HAVE_trunctfsf2 && from_mode == TFmode && to_mode == SFmode)
 678         {
 679           emit_unop_insn (CODE_FOR_trunctfsf2, to, from, UNKNOWN);
 680           return;
 681         }
 682 #endif
 683 #ifdef HAVE_truncxfdf2
 684       if (HAVE_truncxfdf2 && from_mode == XFmode && to_mode == DFmode)
 685         {
 686           emit_unop_insn (CODE_FOR_truncxfdf2, to, from, UNKNOWN);
 687           return;
 688         }
 689 #endif
 690 #ifdef HAVE_trunctfdf2
 691       if (HAVE_trunctfdf2 && from_mode == TFmode && to_mode == DFmode)
 692         {
 693           emit_unop_insn (CODE_FOR_trunctfdf2, to, from, UNKNOWN);
 694           return;
 695         }
 696 #endif
 697
 698       libcall = (rtx) 0;
 699       switch (from_mode)
 700         {
 701         case SFmode:
 702           switch (to_mode)
 703             {
 704             case DFmode:
 705               libcall = extendsfdf2_libfunc;
 706               break;
 707
 708             case XFmode:
 709               libcall = extendsfxf2_libfunc;
 710               break;
 711
 712             case TFmode:
 713               libcall = extendsftf2_libfunc;
 714               break;
 715
 716             default:
 717               break;
 718             }
 719           break;
 720
 721         case DFmode:
 722           switch (to_mode)
 723             {
 724             case SFmode:
 725               libcall = truncdfsf2_libfunc;
 726               break;
 727
 728             case XFmode:
 729               libcall = extenddfxf2_libfunc;
 730               break;
 731
 732             case TFmode:
 733               libcall = extenddftf2_libfunc;
 734               break;
 735
 736             default:
 737               break;
 738             }
 739           break;
 740
 741         case XFmode:
 742           switch (to_mode)
 743             {
 744             case SFmode:
 745               libcall = truncxfsf2_libfunc;
 746               break;
 747
 748             case DFmode:
 749               libcall = truncxfdf2_libfunc;
 750               break;
 751
 752             default:
 753               break;
 754             }
 755           break;
 756
 757         case TFmode:
 758           switch (to_mode)
 759             {
 760             case SFmode:
 761               libcall = trunctfsf2_libfunc;
 762               break;
 763
 764             case DFmode:
 765               libcall = trunctfdf2_libfunc;
 766               break;
 767
 768             default:
 769               break;
 770             }
 771           break;
 772
 773         default:
 774           break;
 775         }
 776
 777       if (libcall == (rtx) 0)
 778         /* This conversion is not implemented yet.  */
 779         abort ();
 780
 781       start_sequence ();
 782       value = emit_library_call_value (libcall, NULL_RTX, LCT_CONST, to_mode,
 783                                        1, from, from_mode);
 784       insns = get_insns ();
 785       end_sequence ();
 786       emit_libcall_block (insns, to, value, gen_rtx_FLOAT_TRUNCATE (to_mode,
 787                                                                     from));
 788       return;
 789     }
 790
 791   /* Now both modes are integers.  */
 792
 793   /* Handle expanding beyond a word.  */
 794   if (GET_MODE_BITSIZE (from_mode) < GET_MODE_BITSIZE (to_mode)
 795       && GET_MODE_BITSIZE (to_mode) > BITS_PER_WORD)
 796     {
 797       rtx insns;
 798       rtx lowpart;
 799       rtx fill_value;
 800       rtx lowfrom;
 801       int i;
 802       enum machine_mode lowpart_mode;
 803       int nwords = CEIL (GET_MODE_SIZE (to_mode), UNITS_PER_WORD);
 804
 805       /* Try converting directly if the insn is supported.  */
 806       if ((code = can_extend_p (to_mode, from_mode, unsignedp))
 807           != CODE_FOR_nothing)
 808         {
 809           /* If FROM is a SUBREG, put it into a register.  Do this
 810              so that we always generate the same set of insns for
 811              better cse'ing; if an intermediate assignment occurred,
 812              we won't be doing the operation directly on the SUBREG.  */
 813           if (optimize > 0 && GET_CODE (from) == SUBREG)
 814             from = force_reg (from_mode, from);
 815           emit_unop_insn (code, to, from, equiv_code);
 816           return;
 817         }
 818       /* Next, try converting via full word.  */
 819       else if (GET_MODE_BITSIZE (from_mode) < BITS_PER_WORD
 820                && ((code = can_extend_p (to_mode, word_mode, unsignedp))
 821                    != CODE_FOR_nothing))
 822         {
 823           if (GET_CODE (to) == REG)
 824             emit_insn (gen_rtx_CLOBBER (VOIDmode, to));
 825           convert_move (gen_lowpart (word_mode, to), from, unsignedp);
 826           emit_unop_insn (code, to,
 827                           gen_lowpart (word_mode, to), equiv_code);
 828           return;
 829         }
 830
 831       /* No special multiword conversion insn; do it by hand.  */
 832       start_sequence ();
 833
 834       /* Since we will turn this into a no conflict block, we must ensure
 835          that the source does not overlap the target.  */
 836
 837       if (reg_overlap_mentioned_p (to, from))
 838         from = force_reg (from_mode, from);
 839
 840       /* Get a copy of FROM widened to a word, if necessary.  */
 841       if (GET_MODE_BITSIZE (from_mode) < BITS_PER_WORD)
 842         lowpart_mode = word_mode;
 843       else
 844         lowpart_mode = from_mode;
 845
 846       lowfrom = convert_to_mode (lowpart_mode, from, unsignedp);
 847
 848       lowpart = gen_lowpart (lowpart_mode, to);
 849       emit_move_insn (lowpart, lowfrom);
 850
 851       /* Compute the value to put in each remaining word.  */
 852       if (unsignedp)
 853         fill_value = const0_rtx;
 854       else
 855         {
 856 #ifdef HAVE_slt
 857           if (HAVE_slt
 858               && insn_data[(int) CODE_FOR_slt].operand[0].mode == word_mode
 859               && STORE_FLAG_VALUE == -1)
 860             {
 861               emit_cmp_insn (lowfrom, const0_rtx, NE, NULL_RTX,
 862                              lowpart_mode, 0);
 863               fill_value = gen_reg_rtx (word_mode);
 864               emit_insn (gen_slt (fill_value));
 865             }
 866           else
 867 #endif
 868             {
 869               fill_value
 870                 = expand_shift (RSHIFT_EXPR, lowpart_mode, lowfrom,
 871                                 size_int (GET_MODE_BITSIZE (lowpart_mode) - 1),
 872                                 NULL_RTX, 0);
 873               fill_value = convert_to_mode (word_mode, fill_value, 1);
 874             }
 875         }
 876
 877       /* Fill the remaining words.  */
 878       for (i = GET_MODE_SIZE (lowpart_mode) / UNITS_PER_WORD; i < nwords; i++)
 879         {
 880           int index = (WORDS_BIG_ENDIAN ? nwords - i - 1 : i);
 881           rtx subword = operand_subword (to, index, 1, to_mode);
 882
 883           if (subword == 0)
 884             abort ();
 885
 886           if (fill_value != subword)
 887             emit_move_insn (subword, fill_value);
 888         }
 889
 890       insns = get_insns ();
 891       end_sequence ();
 892
 893       emit_no_conflict_block (insns, to, from, NULL_RTX,
 894                               gen_rtx_fmt_e (equiv_code, to_mode, copy_rtx (from)));
 895       return;
 896     }
 897
 898   /* Truncating multi-word to a word or less.  */
 899   if (GET_MODE_BITSIZE (from_mode) > BITS_PER_WORD
 900       && GET_MODE_BITSIZE (to_mode) <= BITS_PER_WORD)
 901     {
 902       if (!((GET_CODE (from) == MEM
 903              && ! MEM_VOLATILE_P (from)
 904              && direct_load[(int) to_mode]
 905              && ! mode_dependent_address_p (XEXP (from, 0)))
 906             || GET_CODE (from) == REG
 907             || GET_CODE (from) == SUBREG))
 908         from = force_reg (from_mode, from);
 909       convert_move (to, gen_lowpart (word_mode, from), 0);
 910       return;
 911     }
 912
 913   /* Handle pointer conversion.  */                     /* SPEE 900220.  */
 914   if (to_mode == PQImode)
 915     {
 916       if (from_mode != QImode)
 917         from = convert_to_mode (QImode, from, unsignedp);
 918
 919 #ifdef HAVE_truncqipqi2
 920       if (HAVE_truncqipqi2)
 921         {
 922           emit_unop_insn (CODE_FOR_truncqipqi2, to, from, UNKNOWN);
 923           return;
 924         }
 925 #endif /* HAVE_truncqipqi2 */
 926       abort ();
 927     }
 928
 929   if (from_mode == PQImode)
 930     {
 931       if (to_mode != QImode)
 932         {
 933           from = convert_to_mode (QImode, from, unsignedp);
 934           from_mode = QImode;
 935         }
 936       else
 937         {
 938 #ifdef HAVE_extendpqiqi2
 939           if (HAVE_extendpqiqi2)
 940             {
 941               emit_unop_insn (CODE_FOR_extendpqiqi2, to, from, UNKNOWN);
 942               return;
 943             }
 944 #endif /* HAVE_extendpqiqi2 */
 945           abort ();
 946         }
 947     }
 948
 949   if (to_mode == PSImode)
 950     {
 951       if (from_mode != SImode)
 952         from = convert_to_mode (SImode, from, unsignedp);
 953
 954 #ifdef HAVE_truncsipsi2
 955       if (HAVE_truncsipsi2)
 956         {
 957           emit_unop_insn (CODE_FOR_truncsipsi2, to, from, UNKNOWN);
 958           return;
 959         }
 960 #endif /* HAVE_truncsipsi2 */
 961       abort ();
 962     }
 963
 964   if (from_mode == PSImode)
 965     {
 966       if (to_mode != SImode)
 967         {
 968           from = convert_to_mode (SImode, from, unsignedp);
 969           from_mode = SImode;
 970         }
 971       else
 972         {
 973 #ifdef HAVE_extendpsisi2
 974           if (! unsignedp && HAVE_extendpsisi2)
 975             {
 976               emit_unop_insn (CODE_FOR_extendpsisi2, to, from, UNKNOWN);
 977               return;
 978             }
 979 #endif /* HAVE_extendpsisi2 */
 980 #ifdef HAVE_zero_extendpsisi2
 981           if (unsignedp && HAVE_zero_extendpsisi2)
 982             {
 983               emit_unop_insn (CODE_FOR_zero_extendpsisi2, to, from, UNKNOWN);
 984               return;
 985             }
 986 #endif /* HAVE_zero_extendpsisi2 */
 987           abort ();
 988         }
 989     }
 990
 991   if (to_mode == PDImode)
 992     {
 993       if (from_mode != DImode)
 994         from = convert_to_mode (DImode, from, unsignedp);
 995
 996 #ifdef HAVE_truncdipdi2
 997       if (HAVE_truncdipdi2)
 998         {
 999           emit_unop_insn (CODE_FOR_truncdipdi2, to, from, UNKNOWN);
1000           return;
1001         }
1002 #endif /* HAVE_truncdipdi2 */
1003       abort ();
1004     }
1005
1006   if (from_mode == PDImode)
1007     {
1008       if (to_mode != DImode)
1009         {
1010           from = convert_to_mode (DImode, from, unsignedp);
1011           from_mode = DImode;
1012         }
1013       else
1014         {
1015 #ifdef HAVE_extendpdidi2
1016           if (HAVE_extendpdidi2)
1017             {
1018               emit_unop_insn (CODE_FOR_extendpdidi2, to, from, UNKNOWN);
1019               return;
1020             }
1021 #endif /* HAVE_extendpdidi2 */
1022           abort ();
1023         }
1024     }
1025
1026   /* Now follow all the conversions between integers
1027      no more than a word long.  */
1028
1029   /* For truncation, usually we can just refer to FROM in a narrower mode.  */
1030   if (GET_MODE_BITSIZE (to_mode) < GET_MODE_BITSIZE (from_mode)
1031       && TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (to_mode),
1032                                 GET_MODE_BITSIZE (from_mode)))
1033     {
1034       if (!((GET_CODE (from) == MEM
1035              && ! MEM_VOLATILE_P (from)
1036              && direct_load[(int) to_mode]
1037              && ! mode_dependent_address_p (XEXP (from, 0)))
1038             || GET_CODE (from) == REG
1039             || GET_CODE (from) == SUBREG))
1040         from = force_reg (from_mode, from);
1041       if (GET_CODE (from) == REG && REGNO (from) < FIRST_PSEUDO_REGISTER
1042           && ! HARD_REGNO_MODE_OK (REGNO (from), to_mode))
1043         from = copy_to_reg (from);
1044       emit_move_insn (to, gen_lowpart (to_mode, from));
1045       return;
1046     }
1047
1048   /* Handle extension.  */
1049   if (GET_MODE_BITSIZE (to_mode) > GET_MODE_BITSIZE (from_mode))
1050     {
1051       /* Convert directly if that works.  */
1052       if ((code = can_extend_p (to_mode, from_mode, unsignedp))
1053           != CODE_FOR_nothing)
1054         {
1055           if (flag_force_mem)
1056             from = force_not_mem (from);
1057
1058           emit_unop_insn (code, to, from, equiv_code);
1059           return;
1060         }
1061       else
1062         {
1063           enum machine_mode intermediate;
1064           rtx tmp;
1065           tree shift_amount;
1066
1067           /* Search for a mode to convert via.  */
1068           for (intermediate = from_mode; intermediate != VOIDmode;
1069                intermediate = GET_MODE_WIDER_MODE (intermediate))
1070             if (((can_extend_p (to_mode, intermediate, unsignedp)
1071                   != CODE_FOR_nothing)
1072                  || (GET_MODE_SIZE (to_mode) < GET_MODE_SIZE (intermediate)
1073                      && TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (to_mode),
1074                                                GET_MODE_BITSIZE (intermediate))))
1075                 && (can_extend_p (intermediate, from_mode, unsignedp)
1076                     != CODE_FOR_nothing))
1077               {
1078                 convert_move (to, convert_to_mode (intermediate, from,
1079                                                    unsignedp), unsignedp);
1080                 return;
1081               }
1082
1083           /* No suitable intermediate mode.
1084              Generate what we need with shifts.  */
1085           shift_amount = build_int_2 (GET_MODE_BITSIZE (to_mode)
1086                                       - GET_MODE_BITSIZE (from_mode), 0);
1087           from = gen_lowpart (to_mode, force_reg (from_mode, from));
1088           tmp = expand_shift (LSHIFT_EXPR, to_mode, from, shift_amount,
1089                               to, unsignedp);
1090           tmp = expand_shift (RSHIFT_EXPR, to_mode, tmp, shift_amount,
1091                               to, unsignedp);
1092           if (tmp != to)
1093             emit_move_insn (to, tmp);
1094           return;
1095         }
1096     }
1097
1098   /* Support special truncate insns for certain modes.  */
1099
1100   if (from_mode == DImode && to_mode == SImode)
1101     {
1102 #ifdef HAVE_truncdisi2
1103       if (HAVE_truncdisi2)
1104         {
1105           emit_unop_insn (CODE_FOR_truncdisi2, to, from, UNKNOWN);
1106           return;
1107         }
1108 #endif
1109       convert_move (to, force_reg (from_mode, from), unsignedp);
1110       return;
1111     }
1112
1113   if (from_mode == DImode && to_mode == HImode)
1114     {
1115 #ifdef HAVE_truncdihi2
1116       if (HAVE_truncdihi2)
1117         {
1118           emit_unop_insn (CODE_FOR_truncdihi2, to, from, UNKNOWN);
1119           return;
1120         }
1121 #endif
1122       convert_move (to, force_reg (from_mode, from), unsignedp);
1123       return;
1124     }
1125
1126   if (from_mode == DImode && to_mode == QImode)
1127     {
1128 #ifdef HAVE_truncdiqi2
1129       if (HAVE_truncdiqi2)
1130         {
1131           emit_unop_insn (CODE_FOR_truncdiqi2, to, from, UNKNOWN);
1132           return;
1133         }
1134 #endif
1135       convert_move (to, force_reg (from_mode, from), unsignedp);
1136       return;
1137     }
1138
1139   if (from_mode == SImode && to_mode == HImode)
1140     {
1141 #ifdef HAVE_truncsihi2
1142       if (HAVE_truncsihi2)
1143         {
1144           emit_unop_insn (CODE_FOR_truncsihi2, to, from, UNKNOWN);
1145           return;
1146         }
1147 #endif
1148       convert_move (to, force_reg (from_mode, from), unsignedp);
1149       return;
1150     }
1151
1152   if (from_mode == SImode && to_mode == QImode)
1153     {
1154 #ifdef HAVE_truncsiqi2
1155       if (HAVE_truncsiqi2)
1156         {
1157           emit_unop_insn (CODE_FOR_truncsiqi2, to, from, UNKNOWN);
1158           return;
1159         }
1160 #endif
1161       convert_move (to, force_reg (from_mode, from), unsignedp);
1162       return;
1163     }
1164
1165   if (from_mode == HImode && to_mode == QImode)
1166     {
1167 #ifdef HAVE_trunchiqi2
1168       if (HAVE_trunchiqi2)
1169         {
1170           emit_unop_insn (CODE_FOR_trunchiqi2, to, from, UNKNOWN);
1171           return;
1172         }
1173 #endif
1174       convert_move (to, force_reg (from_mode, from), unsignedp);
1175       return;
1176     }
1177
1178   if (from_mode == TImode && to_mode == DImode)
1179     {
1180 #ifdef HAVE_trunctidi2
1181       if (HAVE_trunctidi2)
1182         {
1183           emit_unop_insn (CODE_FOR_trunctidi2, to, from, UNKNOWN);
1184           return;
1185         }
1186 #endif
1187       convert_move (to, force_reg (from_mode, from), unsignedp);
1188       return;
1189     }
1190
1191   if (from_mode == TImode && to_mode == SImode)
1192     {
1193 #ifdef HAVE_trunctisi2
1194       if (HAVE_trunctisi2)
1195         {
1196           emit_unop_insn (CODE_FOR_trunctisi2, to, from, UNKNOWN);
1197           return;
1198         }
1199 #endif
1200       convert_move (to, force_reg (from_mode, from), unsignedp);
1201       return;
1202     }
1203
1204   if (from_mode == TImode && to_mode == HImode)
1205     {
1206 #ifdef HAVE_trunctihi2
1207       if (HAVE_trunctihi2)
1208         {
1209           emit_unop_insn (CODE_FOR_trunctihi2, to, from, UNKNOWN);
1210           return;
1211         }
1212 #endif
1213       convert_move (to, force_reg (from_mode, from), unsignedp);
1214       return;
1215     }
1216
1217   if (from_mode == TImode && to_mode == QImode)
1218     {
1219 #ifdef HAVE_trunctiqi2
1220       if (HAVE_trunctiqi2)
1221         {
1222           emit_unop_insn (CODE_FOR_trunctiqi2, to, from, UNKNOWN);
1223           return;
1224         }
1225 #endif
1226       convert_move (to, force_reg (from_mode, from), unsignedp);
1227       return;
1228     }
1229
1230   /* Handle truncation of volatile memrefs, and so on;
1231      the things that couldn't be truncated directly,
1232      and for which there was no special instruction.  */
1233   if (GET_MODE_BITSIZE (to_mode) < GET_MODE_BITSIZE (from_mode))
1234     {
1235       rtx temp = force_reg (to_mode, gen_lowpart (to_mode, from));
1236       emit_move_insn (to, temp);
1237       return;
1238     }
1239
1240   /* Mode combination is not recognized.  */
1241   abort ();
1242 }
1243
1244 /* Return an rtx for a value that would result
1245    from converting X to mode MODE.
1246    Both X and MODE may be floating, or both integer.
1247    UNSIGNEDP is nonzero if X is an unsigned value.
1248    This can be done by referring to a part of X in place
1249    or by copying to a new temporary with conversion.
1250
1251    This function *must not* call protect_from_queue
1252    except when putting X into an insn (in which case convert_move does it).  */
1253
1254 rtx
1255 convert_to_mode (mode, x, unsignedp)
1256      enum machine_mode mode;
1257      rtx x;
1258      int unsignedp;
1259 {
1260   return convert_modes (mode, VOIDmode, x, unsignedp);
1261 }
1262
1263 /* Return an rtx for a value that would result
1264    from converting X from mode OLDMODE to mode MODE.
1265    Both modes may be floating, or both integer.
1266    UNSIGNEDP is nonzero if X is an unsigned value.
1267
1268    This can be done by referring to a part of X in place
1269    or by copying to a new temporary with conversion.
1270
1271    You can give VOIDmode for OLDMODE, if you are sure X has a nonvoid mode.
1272
1273    This function *must not* call protect_from_queue
1274    except when putting X into an insn (in which case convert_move does it).  */
1275
1276 rtx
1277 convert_modes (mode, oldmode, x, unsignedp)
1278      enum machine_mode mode, oldmode;
1279      rtx x;
1280      int unsignedp;
1281 {
1282   rtx temp;
1283
1284   /* If FROM is a SUBREG that indicates that we have already done at least
1285      the required extension, strip it.  */
1286
1287   if (GET_CODE (x) == SUBREG && SUBREG_PROMOTED_VAR_P (x)
1288       && GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))) >= GET_MODE_SIZE (mode)
1289       && SUBREG_PROMOTED_UNSIGNED_P (x) == unsignedp)
1290     x = gen_lowpart (mode, x);
1291
1292   if (GET_MODE (x) != VOIDmode)
1293     oldmode = GET_MODE (x);
1294
1295   if (mode == oldmode)
1296     return x;
1297
1298   /* There is one case that we must handle specially: If we are converting
1299      a CONST_INT into a mode whose size is twice HOST_BITS_PER_WIDE_INT and
1300      we are to interpret the constant as unsigned, gen_lowpart will do
1301      the wrong if the constant appears negative.  What we want to do is
1302      make the high-order word of the constant zero, not all ones.  */
1303
1304   if (unsignedp && GET_MODE_CLASS (mode) == MODE_INT
1305       && GET_MODE_BITSIZE (mode) == 2 * HOST_BITS_PER_WIDE_INT
1306       && GET_CODE (x) == CONST_INT && INTVAL (x) < 0)
1307     {
1308       HOST_WIDE_INT val = INTVAL (x);
1309
1310       if (oldmode != VOIDmode
1311           && HOST_BITS_PER_WIDE_INT > GET_MODE_BITSIZE (oldmode))
1312         {
1313           int width = GET_MODE_BITSIZE (oldmode);
1314
1315           /* We need to zero extend VAL.  */
1316           val &= ((HOST_WIDE_INT) 1 << width) - 1;
1317         }
1318
1319       return immed_double_const (val, (HOST_WIDE_INT) 0, mode);
1320     }
1321
1322   /* We can do this with a gen_lowpart if both desired and current modes
1323      are integer, and this is either a constant integer, a register, or a
1324      non-volatile MEM.  Except for the constant case where MODE is no
1325      wider than HOST_BITS_PER_WIDE_INT, we must be narrowing the operand.  */
1326
1327   if ((GET_CODE (x) == CONST_INT
1328        && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
1329       || (GET_MODE_CLASS (mode) == MODE_INT
1330           && GET_MODE_CLASS (oldmode) == MODE_INT
1331           && (GET_CODE (x) == CONST_DOUBLE
1332               || (GET_MODE_SIZE (mode) <= GET_MODE_SIZE (oldmode)
1333                   && ((GET_CODE (x) == MEM && ! MEM_VOLATILE_P (x)
1334                        && direct_load[(int) mode])
1335                       || (GET_CODE (x) == REG
1336                           && TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (mode),
1337                                                     GET_MODE_BITSIZE (GET_MODE (x)))))))))
1338     {
1339       /* ?? If we don't know OLDMODE, we have to assume here that
1340          X does not need sign- or zero-extension.   This may not be
1341          the case, but it's the best we can do.  */
1342       if (GET_CODE (x) == CONST_INT && oldmode != VOIDmode
1343           && GET_MODE_SIZE (mode) > GET_MODE_SIZE (oldmode))
1344         {
1345           HOST_WIDE_INT val = INTVAL (x);
1346           int width = GET_MODE_BITSIZE (oldmode);
1347
1348           /* We must sign or zero-extend in this case.  Start by
1349              zero-extending, then sign extend if we need to.  */
1350           val &= ((HOST_WIDE_INT) 1 << width) - 1;
1351           if (! unsignedp
1352               && (val & ((HOST_WIDE_INT) 1 << (width - 1))))
1353             val |= (HOST_WIDE_INT) (-1) << width;
1354
1355           return GEN_INT (trunc_int_for_mode (val, mode));
1356         }
1357
1358       return gen_lowpart (mode, x);
1359     }
1360
1361   temp = gen_reg_rtx (mode);
1362   convert_move (temp, x, unsignedp);
1363   return temp;
1364 }
1365 \f
1366 /* This macro is used to determine what the largest unit size that
1367    move_by_pieces can use is.  */
1368
1369 /* MOVE_MAX_PIECES is the number of bytes at a time which we can
1370    move efficiently, as opposed to  MOVE_MAX which is the maximum
1371    number of bytes we can move with a single instruction.  */
1372
1373 #ifndef MOVE_MAX_PIECES
1374 #define MOVE_MAX_PIECES   MOVE_MAX
1375 #endif
1376
1377 /* Generate several move instructions to copy LEN bytes from block FROM to
1378    block TO.  (These are MEM rtx's with BLKmode).  The caller must pass FROM
1379    and TO through protect_from_queue before calling.
1380
1381    If PUSH_ROUNDING is defined and TO is NULL, emit_single_push_insn is
1382    used to push FROM to the stack.
1383
1384    ALIGN is maximum alignment we can assume.  */
1385
1386 void
1387 move_by_pieces (to, from, len, align)
1388      rtx to, from;
1389      unsigned HOST_WIDE_INT len;
1390      unsigned int align;
1391 {
1392   struct move_by_pieces data;
1393   rtx to_addr, from_addr = XEXP (from, 0);
1394   unsigned int max_size = MOVE_MAX_PIECES + 1;
1395   enum machine_mode mode = VOIDmode, tmode;
1396   enum insn_code icode;
1397
1398   data.offset = 0;
1399   data.from_addr = from_addr;
1400   if (to)
1401     {
1402       to_addr = XEXP (to, 0);
1403       data.to = to;
1404       data.autinc_to
1405         = (GET_CODE (to_addr) == PRE_INC || GET_CODE (to_addr) == PRE_DEC
1406            || GET_CODE (to_addr) == POST_INC || GET_CODE (to_addr) == POST_DEC);
1407       data.reverse
1408         = (GET_CODE (to_addr) == PRE_DEC || GET_CODE (to_addr) == POST_DEC);
1409     }
1410   else
1411     {
1412       to_addr = NULL_RTX;
1413       data.to = NULL_RTX;
1414       data.autinc_to = 1;
1415 #ifdef STACK_GROWS_DOWNWARD
1416       data.reverse = 1;
1417 #else
1418       data.reverse = 0;
1419 #endif
1420     }
1421   data.to_addr = to_addr;
1422   data.from = from;
1423   data.autinc_from
1424     = (GET_CODE (from_addr) == PRE_INC || GET_CODE (from_addr) == PRE_DEC
1425        || GET_CODE (from_addr) == POST_INC
1426        || GET_CODE (from_addr) == POST_DEC);
1427
1428   data.explicit_inc_from = 0;
1429   data.explicit_inc_to = 0;
1430   if (data.reverse) data.offset = len;
1431   data.len = len;
1432
1433   /* If copying requires more than two move insns,
1434      copy addresses to registers (to make displacements shorter)
1435      and use post-increment if available.  */
1436   if (!(data.autinc_from && data.autinc_to)
1437       && move_by_pieces_ninsns (len, align) > 2)
1438     {
1439       /* Find the mode of the largest move...  */
1440       for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
1441            tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
1442         if (GET_MODE_SIZE (tmode) < max_size)
1443           mode = tmode;
1444
1445       if (USE_LOAD_PRE_DECREMENT (mode) && data.reverse && ! data.autinc_from)
1446         {
1447           data.from_addr = copy_addr_to_reg (plus_constant (from_addr, len));
1448           data.autinc_from = 1;
1449           data.explicit_inc_from = -1;
1450         }
1451       if (USE_LOAD_POST_INCREMENT (mode) && ! data.autinc_from)
1452         {
1453           data.from_addr = copy_addr_to_reg (from_addr);
1454           data.autinc_from = 1;
1455           data.explicit_inc_from = 1;
1456         }
1457       if (!data.autinc_from && CONSTANT_P (from_addr))
1458         data.from_addr = copy_addr_to_reg (from_addr);
1459       if (USE_STORE_PRE_DECREMENT (mode) && data.reverse && ! data.autinc_to)
1460         {
1461           data.to_addr = copy_addr_to_reg (plus_constant (to_addr, len));
1462           data.autinc_to = 1;
1463           data.explicit_inc_to = -1;
1464         }
1465       if (USE_STORE_POST_INCREMENT (mode) && ! data.reverse && ! data.autinc_to)
1466         {
1467           data.to_addr = copy_addr_to_reg (to_addr);
1468           data.autinc_to = 1;
1469           data.explicit_inc_to = 1;
1470         }
1471       if (!data.autinc_to && CONSTANT_P (to_addr))
1472         data.to_addr = copy_addr_to_reg (to_addr);
1473     }
1474
1475   if (! SLOW_UNALIGNED_ACCESS (word_mode, align)
1476       || align > MOVE_MAX * BITS_PER_UNIT || align >= BIGGEST_ALIGNMENT)
1477     align = MOVE_MAX * BITS_PER_UNIT;
1478
1479   /* First move what we can in the largest integer mode, then go to
1480      successively smaller modes.  */
1481
1482   while (max_size > 1)
1483     {
1484       for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
1485            tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
1486         if (GET_MODE_SIZE (tmode) < max_size)
1487           mode = tmode;
1488
1489       if (mode == VOIDmode)
1490         break;
1491
1492       icode = mov_optab->handlers[(int) mode].insn_code;
1493       if (icode != CODE_FOR_nothing && align >= GET_MODE_ALIGNMENT (mode))
1494         move_by_pieces_1 (GEN_FCN (icode), mode, &data);
1495
1496       max_size = GET_MODE_SIZE (mode);
1497     }
1498
1499   /* The code above should have handled everything.  */
1500   if (data.len > 0)
1501     abort ();
1502 }
1503
1504 /* Return number of insns required to move L bytes by pieces.
1505    ALIGN (in bits) is maximum alignment we can assume.  */
1506
1507 static unsigned HOST_WIDE_INT
1508 move_by_pieces_ninsns (l, align)
1509      unsigned HOST_WIDE_INT l;
1510      unsigned int align;
1511 {
1512   unsigned HOST_WIDE_INT n_insns = 0;
1513   unsigned HOST_WIDE_INT max_size = MOVE_MAX + 1;
1514
1515   if (! SLOW_UNALIGNED_ACCESS (word_mode, align)
1516       || align > MOVE_MAX * BITS_PER_UNIT || align >= BIGGEST_ALIGNMENT)
1517     align = MOVE_MAX * BITS_PER_UNIT;
1518
1519   while (max_size > 1)
1520     {
1521       enum machine_mode mode = VOIDmode, tmode;
1522       enum insn_code icode;
1523
1524       for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
1525            tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
1526         if (GET_MODE_SIZE (tmode) < max_size)
1527           mode = tmode;
1528
1529       if (mode == VOIDmode)
1530         break;
1531
1532       icode = mov_optab->handlers[(int) mode].insn_code;
1533       if (icode != CODE_FOR_nothing && align >= GET_MODE_ALIGNMENT (mode))
1534         n_insns += l / GET_MODE_SIZE (mode), l %= GET_MODE_SIZE (mode);
1535
1536       max_size = GET_MODE_SIZE (mode);
1537     }
1538
1539   if (l)
1540     abort ();
1541   return n_insns;
1542 }
1543
1544 /* Subroutine of move_by_pieces.  Move as many bytes as appropriate
1545    with move instructions for mode MODE.  GENFUN is the gen_... function
1546    to make a move insn for that mode.  DATA has all the other info.  */
1547
1548 static void
1549 move_by_pieces_1 (genfun, mode, data)
1550      rtx (*genfun) PARAMS ((rtx, ...));
1551      enum machine_mode mode;
1552      struct move_by_pieces *data;
1553 {
1554   unsigned int size = GET_MODE_SIZE (mode);
1555   rtx to1 = NULL_RTX, from1;
1556
1557   while (data->len >= size)
1558     {
1559       if (data->reverse)
1560         data->offset -= size;
1561
1562       if (data->to)
1563         {
1564           if (data->autinc_to)
1565             to1 = adjust_automodify_address (data->to, mode, data->to_addr,
1566                                              data->offset);
1567           else
1568             to1 = adjust_address (data->to, mode, data->offset);
1569         }
1570
1571       if (data->autinc_from)
1572         from1 = adjust_automodify_address (data->from, mode, data->from_addr,
1573                                            data->offset);
1574       else
1575         from1 = adjust_address (data->from, mode, data->offset);
1576
1577       if (HAVE_PRE_DECREMENT && data->explicit_inc_to < 0)
1578         emit_insn (gen_add2_insn (data->to_addr, GEN_INT (-size)));
1579       if (HAVE_PRE_DECREMENT && data->explicit_inc_from < 0)
1580         emit_insn (gen_add2_insn (data->from_addr, GEN_INT (-size)));
1581
1582       if (data->to)
1583         emit_insn ((*genfun) (to1, from1));
1584       else
1585         {
1586 #ifdef PUSH_ROUNDING
1587           emit_single_push_insn (mode, from1, NULL);
1588 #else
1589           abort ();
1590 #endif
1591         }
1592
1593       if (HAVE_POST_INCREMENT && data->explicit_inc_to > 0)
1594         emit_insn (gen_add2_insn (data->to_addr, GEN_INT (size)));
1595       if (HAVE_POST_INCREMENT && data->explicit_inc_from > 0)
1596         emit_insn (gen_add2_insn (data->from_addr, GEN_INT (size)));
1597
1598       if (! data->reverse)
1599         data->offset += size;
1600
1601       data->len -= size;
1602     }
1603 }
1604 \f
1605 /* Emit code to move a block Y to a block X.
1606    This may be done with string-move instructions,
1607    with multiple scalar move instructions, or with a library call.
1608
1609    Both X and Y must be MEM rtx's (perhaps inside VOLATILE)
1610    with mode BLKmode.
1611    SIZE is an rtx that says how long they are.
1612    ALIGN is the maximum alignment we can assume they have.
1613
1614    Return the address of the new block, if memcpy is called and returns it,
1615    0 otherwise.  */
1616
1617 rtx
1618 emit_block_move (x, y, size)
1619      rtx x, y;
1620      rtx size;
1621 {
1622   rtx retval = 0;
1623 #ifdef TARGET_MEM_FUNCTIONS
1624   static tree fn;
1625   tree call_expr, arg_list;
1626 #endif
1627   unsigned int align = MIN (MEM_ALIGN (x), MEM_ALIGN (y));
1628
1629   if (GET_MODE (x) != BLKmode)
1630     abort ();
1631
1632   if (GET_MODE (y) != BLKmode)
1633     abort ();
1634
1635   x = protect_from_queue (x, 1);
1636   y = protect_from_queue (y, 0);
1637   size = protect_from_queue (size, 0);
1638
1639   if (GET_CODE (x) != MEM)
1640     abort ();
1641   if (GET_CODE (y) != MEM)
1642     abort ();
1643   if (size == 0)
1644     abort ();
1645
1646   if (GET_CODE (size) == CONST_INT && MOVE_BY_PIECES_P (INTVAL (size), align))
1647     move_by_pieces (x, y, INTVAL (size), align);
1648   else
1649     {
1650       /* Try the most limited insn first, because there's no point
1651          including more than one in the machine description unless
1652          the more limited one has some advantage.  */
1653
1654       rtx opalign = GEN_INT (align / BITS_PER_UNIT);
1655       enum machine_mode mode;
1656
1657       /* Since this is a move insn, we don't care about volatility.  */
1658       volatile_ok = 1;
1659
1660       for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
1661            mode = GET_MODE_WIDER_MODE (mode))
1662         {
1663           enum insn_code code = movstr_optab[(int) mode];
1664           insn_operand_predicate_fn pred;
1665
1666           if (code != CODE_FOR_nothing
1667               /* We don't need MODE to be narrower than BITS_PER_HOST_WIDE_INT
1668                  here because if SIZE is less than the mode mask, as it is
1669                  returned by the macro, it will definitely be less than the
1670                  actual mode mask.  */
1671               && ((GET_CODE (size) == CONST_INT
1672                    && ((unsigned HOST_WIDE_INT) INTVAL (size)
1673                        <= (GET_MODE_MASK (mode) >> 1)))
1674                   || GET_MODE_BITSIZE (mode) >= BITS_PER_WORD)
1675               && ((pred = insn_data[(int) code].operand[0].predicate) == 0
1676                   || (*pred) (x, BLKmode))
1677               && ((pred = insn_data[(int) code].operand[1].predicate) == 0
1678                   || (*pred) (y, BLKmode))
1679               && ((pred = insn_data[(int) code].operand[3].predicate) == 0
1680                   || (*pred) (opalign, VOIDmode)))
1681             {
1682               rtx op2;
1683               rtx last = get_last_insn ();
1684               rtx pat;
1685
1686               op2 = convert_to_mode (mode, size, 1);
1687               pred = insn_data[(int) code].operand[2].predicate;
1688               if (pred != 0 && ! (*pred) (op2, mode))
1689                 op2 = copy_to_mode_reg (mode, op2);
1690
1691               pat = GEN_FCN ((int) code) (x, y, op2, opalign);
1692               if (pat)
1693                 {
1694                   emit_insn (pat);
1695                   volatile_ok = 0;
1696                   return 0;
1697                 }
1698               else
1699                 delete_insns_since (last);
1700             }
1701         }
1702
1703       volatile_ok = 0;
1704
1705       /* X, Y, or SIZE may have been passed through protect_from_queue.
1706
1707          It is unsafe to save the value generated by protect_from_queue
1708          and reuse it later.  Consider what happens if emit_queue is
1709          called before the return value from protect_from_queue is used.
1710
1711          Expansion of the CALL_EXPR below will call emit_queue before
1712          we are finished emitting RTL for argument setup.  So if we are
1713          not careful we could get the wrong value for an argument.
1714
1715          To avoid this problem we go ahead and emit code to copy X, Y &
1716          SIZE into new pseudos.  We can then place those new pseudos
1717          into an RTL_EXPR and use them later, even after a call to
1718          emit_queue.
1719
1720          Note this is not strictly needed for library calls since they
1721          do not call emit_queue before loading their arguments.  However,
1722          we may need to have library calls call emit_queue in the future
1723          since failing to do so could cause problems for targets which
1724          define SMALL_REGISTER_CLASSES and pass arguments in registers.  */
1725       x = copy_to_mode_reg (Pmode, XEXP (x, 0));
1726       y = copy_to_mode_reg (Pmode, XEXP (y, 0));
1727
1728 #ifdef TARGET_MEM_FUNCTIONS
1729       size = copy_to_mode_reg (TYPE_MODE (sizetype), size);
1730 #else
1731       size = convert_to_mode (TYPE_MODE (integer_type_node), size,
1732                               TREE_UNSIGNED (integer_type_node));
1733       size = copy_to_mode_reg (TYPE_MODE (integer_type_node), size);
1734 #endif
1735
1736 #ifdef TARGET_MEM_FUNCTIONS
1737       /* It is incorrect to use the libcall calling conventions to call
1738          memcpy in this context.
1739
1740          This could be a user call to memcpy and the user may wish to
1741          examine the return value from memcpy.
1742
1743          For targets where libcalls and normal calls have different conventions
1744          for returning pointers, we could end up generating incorrect code.
1745
1746          So instead of using a libcall sequence we build up a suitable
1747          CALL_EXPR and expand the call in the normal fashion.  */
1748       if (fn == NULL_TREE)
1749         {
1750           tree fntype;
1751
1752           /* This was copied from except.c, I don't know if all this is
1753              necessary in this context or not.  */
1754           fn = get_identifier ("memcpy");
1755           fntype = build_pointer_type (void_type_node);
1756           fntype = build_function_type (fntype, NULL_TREE);
1757           fn = build_decl (FUNCTION_DECL, fn, fntype);
1758           ggc_add_tree_root (&fn, 1);
1759           DECL_EXTERNAL (fn) = 1;
1760           TREE_PUBLIC (fn) = 1;
1761           DECL_ARTIFICIAL (fn) = 1;
1762           TREE_NOTHROW (fn) = 1;
1763           make_decl_rtl (fn, NULL);
1764           assemble_external (fn);
1765         }
1766
1767       /* We need to make an argument list for the function call.
1768
1769          memcpy has three arguments, the first two are void * addresses and
1770          the last is a size_t byte count for the copy.  */
1771       arg_list
1772         = build_tree_list (NULL_TREE,
1773                            make_tree (build_pointer_type (void_type_node), x));
1774       TREE_CHAIN (arg_list)
1775         = build_tree_list (NULL_TREE,
1776                            make_tree (build_pointer_type (void_type_node), y));
1777       TREE_CHAIN (TREE_CHAIN (arg_list))
1778          = build_tree_list (NULL_TREE, make_tree (sizetype, size));
1779       TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (arg_list))) = NULL_TREE;
1780
1781       /* Now we have to build up the CALL_EXPR itself.  */
1782       call_expr = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
1783       call_expr = build (CALL_EXPR, TREE_TYPE (TREE_TYPE (fn)),
1784                          call_expr, arg_list, NULL_TREE);
1785       TREE_SIDE_EFFECTS (call_expr) = 1;
1786
1787       retval = expand_expr (call_expr, NULL_RTX, VOIDmode, 0);
1788 #else
1789       emit_library_call (bcopy_libfunc, LCT_NORMAL,
1790                          VOIDmode, 3, y, Pmode, x, Pmode,
1791                          convert_to_mode (TYPE_MODE (integer_type_node), size,
1792                                           TREE_UNSIGNED (integer_type_node)),
1793                          TYPE_MODE (integer_type_node));
1794 #endif
1795
1796       /* If we are initializing a readonly value, show the above call
1797          clobbered it.  Otherwise, a load from it may erroneously be hoisted
1798          from a loop.  */
1799       if (RTX_UNCHANGING_P (x))
1800         emit_insn (gen_rtx_CLOBBER (VOIDmode, x));
1801     }
1802
1803   return retval;
1804 }
1805 \f
1806 /* Copy all or part of a value X into registers starting at REGNO.
1807    The number of registers to be filled is NREGS.  */
1808
1809 void
1810 move_block_to_reg (regno, x, nregs, mode)
1811      int regno;
1812      rtx x;
1813      int nregs;
1814      enum machine_mode mode;
1815 {
1816   int i;
1817 #ifdef HAVE_load_multiple
1818   rtx pat;
1819   rtx last;
1820 #endif
1821
1822   if (nregs == 0)
1823     return;
1824
1825   if (CONSTANT_P (x) && ! LEGITIMATE_CONSTANT_P (x))
1826     x = validize_mem (force_const_mem (mode, x));
1827
1828   /* See if the machine can do this with a load multiple insn.  */
1829 #ifdef HAVE_load_multiple
1830   if (HAVE_load_multiple)
1831     {
1832       last = get_last_insn ();
1833       pat = gen_load_multiple (gen_rtx_REG (word_mode, regno), x,
1834                                GEN_INT (nregs));
1835       if (pat)
1836         {
1837           emit_insn (pat);
1838           return;
1839         }
1840       else
1841         delete_insns_since (last);
1842     }
1843 #endif
1844
1845   for (i = 0; i < nregs; i++)
1846     emit_move_insn (gen_rtx_REG (word_mode, regno + i),
1847                     operand_subword_force (x, i, mode));
1848 }
1849
1850 /* Copy all or part of a BLKmode value X out of registers starting at REGNO.
1851    The number of registers to be filled is NREGS.  SIZE indicates the number
1852    of bytes in the object X.  */
1853
1854 void
1855 move_block_from_reg (regno, x, nregs, size)
1856      int regno;
1857      rtx x;
1858      int nregs;
1859      int size;
1860 {
1861   int i;
1862 #ifdef HAVE_store_multiple
1863   rtx pat;
1864   rtx last;
1865 #endif
1866   enum machine_mode mode;
1867
1868   if (nregs == 0)
1869     return;
1870
1871   /* If SIZE is that of a mode no bigger than a word, just use that
1872      mode's store operation.  */
1873   if (size <= UNITS_PER_WORD
1874       && (mode = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0)) != BLKmode
1875       && !FUNCTION_ARG_REG_LITTLE_ENDIAN)
1876     {
1877       emit_move_insn (adjust_address (x, mode, 0), gen_rtx_REG (mode, regno));
1878       return;
1879     }
1880
1881   /* Blocks smaller than a word on a BYTES_BIG_ENDIAN machine must be aligned
1882      to the left before storing to memory.  Note that the previous test
1883      doesn't handle all cases (e.g. SIZE == 3).  */
1884   if (size < UNITS_PER_WORD
1885       && BYTES_BIG_ENDIAN
1886       && !FUNCTION_ARG_REG_LITTLE_ENDIAN)
1887     {
1888       rtx tem = operand_subword (x, 0, 1, BLKmode);
1889       rtx shift;
1890
1891       if (tem == 0)
1892         abort ();
1893
1894       shift = expand_shift (LSHIFT_EXPR, word_mode,
1895                             gen_rtx_REG (word_mode, regno),
1896                             build_int_2 ((UNITS_PER_WORD - size)
1897                                          * BITS_PER_UNIT, 0), NULL_RTX, 0);
1898       emit_move_insn (tem, shift);
1899       return;
1900     }
1901
1902   /* See if the machine can do this with a store multiple insn.  */
1903 #ifdef HAVE_store_multiple
1904   if (HAVE_store_multiple)
1905     {
1906       last = get_last_insn ();
1907       pat = gen_store_multiple (x, gen_rtx_REG (word_mode, regno),
1908                                 GEN_INT (nregs));
1909       if (pat)
1910         {
1911           emit_insn (pat);
1912           return;
1913         }
1914       else
1915         delete_insns_since (last);
1916     }
1917 #endif
1918
1919   for (i = 0; i < nregs; i++)
1920     {
1921       rtx tem = operand_subword (x, i, 1, BLKmode);
1922
1923       if (tem == 0)
1924         abort ();
1925
1926       emit_move_insn (tem, gen_rtx_REG (word_mode, regno + i));
1927     }
1928 }
1929
1930 /* Emit code to move a block SRC to a block DST, where DST is non-consecutive
1931    registers represented by a PARALLEL.  SSIZE represents the total size of
1932    block SRC in bytes, or -1 if not known.  */
1933 /* ??? If SSIZE % UNITS_PER_WORD != 0, we make the blatant assumption that
1934    the balance will be in what would be the low-order memory addresses, i.e.
1935    left justified for big endian, right justified for little endian.  This
1936    happens to be true for the targets currently using this support.  If this
1937    ever changes, a new target macro along the lines of FUNCTION_ARG_PADDING
1938    would be needed.  */
1939
1940 void
1941 emit_group_load (dst, orig_src, ssize)
1942      rtx dst, orig_src;
1943      int ssize;
1944 {
1945   rtx *tmps, src;
1946   int start, i;
1947
1948   if (GET_CODE (dst) != PARALLEL)
1949     abort ();
1950
1951   /* Check for a NULL entry, used to indicate that the parameter goes
1952      both on the stack and in registers.  */
1953   if (XEXP (XVECEXP (dst, 0, 0), 0))
1954     start = 0;
1955   else
1956     start = 1;
1957
1958   tmps = (rtx *) alloca (sizeof (rtx) * XVECLEN (dst, 0));
1959
1960   /* Process the pieces.  */
1961   for (i = start; i < XVECLEN (dst, 0); i++)
1962     {
1963       enum machine_mode mode = GET_MODE (XEXP (XVECEXP (dst, 0, i), 0));
1964       HOST_WIDE_INT bytepos = INTVAL (XEXP (XVECEXP (dst, 0, i), 1));
1965       unsigned int bytelen = GET_MODE_SIZE (mode);
1966       int shift = 0;
1967
1968       /* Handle trailing fragments that run over the size of the struct.  */
1969       if (ssize >= 0 && bytepos + (HOST_WIDE_INT) bytelen > ssize)
1970         {
1971           shift = (bytelen - (ssize - bytepos)) * BITS_PER_UNIT;
1972           bytelen = ssize - bytepos;
1973           if (bytelen <= 0)
1974             abort ();
1975         }
1976
1977       /* If we won't be loading directly from memory, protect the real source
1978          from strange tricks we might play; but make sure that the source can
1979          be loaded directly into the destination.  */
1980       src = orig_src;
1981       if (GET_CODE (orig_src) != MEM
1982           && (!CONSTANT_P (orig_src)
1983               || (GET_MODE (orig_src) != mode
1984                   && GET_MODE (orig_src) != VOIDmode)))
1985         {
1986           if (GET_MODE (orig_src) == VOIDmode)
1987             src = gen_reg_rtx (mode);
1988           else
1989             src = gen_reg_rtx (GET_MODE (orig_src));
1990
1991           emit_move_insn (src, orig_src);
1992         }
1993
1994       /* Optimize the access just a bit.  */
1995       if (GET_CODE (src) == MEM
1996           && MEM_ALIGN (src) >= GET_MODE_ALIGNMENT (mode)
1997           && bytepos * BITS_PER_UNIT % GET_MODE_ALIGNMENT (mode) == 0
1998           && bytelen == GET_MODE_SIZE (mode))
1999         {
2000           tmps[i] = gen_reg_rtx (mode);
2001           emit_move_insn (tmps[i], adjust_address (src, mode, bytepos));
2002         }
2003       else if (GET_CODE (src) == CONCAT)
2004         {
2005           if (bytepos == 0
2006               && bytelen == GET_MODE_SIZE (GET_MODE (XEXP (src, 0))))
2007             tmps[i] = XEXP (src, 0);
2008           else if (bytepos == (HOST_WIDE_INT) GET_MODE_SIZE (GET_MODE (XEXP (src, 0)))
2009                    && bytelen == GET_MODE_SIZE (GET_MODE (XEXP (src, 1))))
2010             tmps[i] = XEXP (src, 1);
2011           else if (bytepos == 0)
2012             {
2013               rtx mem = assign_stack_temp (GET_MODE (src),
2014                                            GET_MODE_SIZE (GET_MODE (src)), 0);
2015               emit_move_insn (mem, src);
2016               tmps[i] = adjust_address (mem, mode, 0);
2017             }
2018           else
2019             abort ();
2020         }
2021       else if (CONSTANT_P (src)
2022                || (GET_CODE (src) == REG && GET_MODE (src) == mode))
2023         tmps[i] = src;
2024       else
2025         tmps[i] = extract_bit_field (src, bytelen * BITS_PER_UNIT,
2026                                      bytepos * BITS_PER_UNIT, 1, NULL_RTX,
2027                                      mode, mode, ssize);
2028
2029       if (BYTES_BIG_ENDIAN && shift)
2030         expand_binop (mode, ashl_optab, tmps[i], GEN_INT (shift),
2031                       tmps[i], 0, OPTAB_WIDEN);
2032     }
2033
2034   emit_queue ();
2035
2036   /* Copy the extracted pieces into the proper (probable) hard regs.  */
2037   for (i = start; i < XVECLEN (dst, 0); i++)
2038     emit_move_insn (XEXP (XVECEXP (dst, 0, i), 0), tmps[i]);
2039 }
2040
2041 /* Emit code to move a block SRC to a block DST, where SRC is non-consecutive
2042    registers represented by a PARALLEL.  SSIZE represents the total size of
2043    block DST, or -1 if not known.  */
2044
2045 void
2046 emit_group_store (orig_dst, src, ssize)
2047      rtx orig_dst, src;
2048      int ssize;
2049 {
2050   rtx *tmps, dst;
2051   int start, i;
2052
2053   if (GET_CODE (src) != PARALLEL)
2054     abort ();
2055
2056   /* Check for a NULL entry, used to indicate that the parameter goes
2057      both on the stack and in registers.  */
2058   if (XEXP (XVECEXP (src, 0, 0), 0))
2059     start = 0;
2060   else
2061     start = 1;
2062
2063   tmps = (rtx *) alloca (sizeof (rtx) * XVECLEN (src, 0));
2064
2065   /* Copy the (probable) hard regs into pseudos.  */
2066   for (i = start; i < XVECLEN (src, 0); i++)
2067     {
2068       rtx reg = XEXP (XVECEXP (src, 0, i), 0);
2069       tmps[i] = gen_reg_rtx (GET_MODE (reg));
2070       emit_move_insn (tmps[i], reg);
2071     }
2072   emit_queue ();
2073
2074   /* If we won't be storing directly into memory, protect the real destination
2075      from strange tricks we might play.  */
2076   dst = orig_dst;
2077   if (GET_CODE (dst) == PARALLEL)
2078     {
2079       rtx temp;
2080
2081       /* We can get a PARALLEL dst if there is a conditional expression in
2082          a return statement.  In that case, the dst and src are the same,
2083          so no action is necessary.  */
2084       if (rtx_equal_p (dst, src))
2085         return;
2086
2087       /* It is unclear if we can ever reach here, but we may as well handle
2088          it.  Allocate a temporary, and split this into a store/load to/from
2089          the temporary.  */
2090
2091       temp = assign_stack_temp (GET_MODE (dst), ssize, 0);
2092       emit_group_store (temp, src, ssize);
2093       emit_group_load (dst, temp, ssize);
2094       return;
2095     }
2096   else if (GET_CODE (dst) != MEM)
2097     {
2098       dst = gen_reg_rtx (GET_MODE (orig_dst));
2099       /* Make life a bit easier for combine.  */
2100       emit_move_insn (dst, const0_rtx);
2101     }
2102
2103   /* Process the pieces.  */
2104   for (i = start; i < XVECLEN (src, 0); i++)
2105     {
2106       HOST_WIDE_INT bytepos = INTVAL (XEXP (XVECEXP (src, 0, i), 1));
2107       enum machine_mode mode = GET_MODE (tmps[i]);
2108       unsigned int bytelen = GET_MODE_SIZE (mode);
2109
2110       /* Handle trailing fragments that run over the size of the struct.  */
2111       if (ssize >= 0 && bytepos + (HOST_WIDE_INT) bytelen > ssize)
2112         {
2113           if (BYTES_BIG_ENDIAN)
2114             {
2115               int shift = (bytelen - (ssize - bytepos)) * BITS_PER_UNIT;
2116               expand_binop (mode, ashr_optab, tmps[i], GEN_INT (shift),
2117                             tmps[i], 0, OPTAB_WIDEN);
2118             }
2119           bytelen = ssize - bytepos;
2120         }
2121
2122       /* Optimize the access just a bit.  */
2123       if (GET_CODE (dst) == MEM
2124           && MEM_ALIGN (dst) >= GET_MODE_ALIGNMENT (mode)
2125           && bytepos * BITS_PER_UNIT % GET_MODE_ALIGNMENT (mode) == 0
2126           && bytelen == GET_MODE_SIZE (mode))
2127         emit_move_insn (adjust_address (dst, mode, bytepos), tmps[i]);
2128       else
2129         store_bit_field (dst, bytelen * BITS_PER_UNIT, bytepos * BITS_PER_UNIT,
2130                          mode, tmps[i], ssize);
2131     }
2132
2133   emit_queue ();
2134
2135   /* Copy from the pseudo into the (probable) hard reg.  */
2136   if (GET_CODE (dst) == REG)
2137     emit_move_insn (orig_dst, dst);
2138 }
2139
2140 /* Generate code to copy a BLKmode object of TYPE out of a
2141    set of registers starting with SRCREG into TGTBLK.  If TGTBLK
2142    is null, a stack temporary is created.  TGTBLK is returned.
2143
2144    The primary purpose of this routine is to handle functions
2145    that return BLKmode structures in registers.  Some machines
2146    (the PA for example) want to return all small structures
2147    in registers regardless of the structure's alignment.  */
2148
2149 rtx
2150 copy_blkmode_from_reg (tgtblk, srcreg, type)
2151      rtx tgtblk;
2152      rtx srcreg;
2153      tree type;
2154 {
2155   unsigned HOST_WIDE_INT bytes = int_size_in_bytes (type);
2156   rtx src = NULL, dst = NULL;
2157   unsigned HOST_WIDE_INT bitsize = MIN (TYPE_ALIGN (type), BITS_PER_WORD);
2158   unsigned HOST_WIDE_INT bitpos, xbitpos, big_endian_correction = 0;
2159
2160   if (tgtblk == 0)
2161     {
2162       tgtblk = assign_temp (build_qualified_type (type,
2163                                                   (TYPE_QUALS (type)
2164                                                    | TYPE_QUAL_CONST)),
2165                             0, 1, 1);
2166       preserve_temp_slots (tgtblk);
2167     }
2168
2169   /* This code assumes srcreg is at least a full word.  If it isn't, copy it
2170      into a new pseudo which is a full word.
2171
2172      If FUNCTION_ARG_REG_LITTLE_ENDIAN is set and convert_to_mode does a copy,
2173      the wrong part of the register gets copied so we fake a type conversion
2174      in place.  */
2175   if (GET_MODE (srcreg) != BLKmode
2176       && GET_MODE_SIZE (GET_MODE (srcreg)) < UNITS_PER_WORD)
2177     {
2178       if (FUNCTION_ARG_REG_LITTLE_ENDIAN)
2179         srcreg = simplify_gen_subreg (word_mode, srcreg, GET_MODE (srcreg), 0);
2180       else
2181         srcreg = convert_to_mode (word_mode, srcreg, TREE_UNSIGNED (type));
2182     }
2183
2184   /* Structures whose size is not a multiple of a word are aligned
2185      to the least significant byte (to the right).  On a BYTES_BIG_ENDIAN
2186      machine, this means we must skip the empty high order bytes when
2187      calculating the bit offset.  */
2188   if (BYTES_BIG_ENDIAN
2189       && !FUNCTION_ARG_REG_LITTLE_ENDIAN
2190       && bytes % UNITS_PER_WORD)
2191     big_endian_correction
2192       = (BITS_PER_WORD - ((bytes % UNITS_PER_WORD) * BITS_PER_UNIT));
2193
2194   /* Copy the structure BITSIZE bites at a time.
2195
2196      We could probably emit more efficient code for machines which do not use
2197      strict alignment, but it doesn't seem worth the effort at the current
2198      time.  */
2199   for (bitpos = 0, xbitpos = big_endian_correction;
2200        bitpos < bytes * BITS_PER_UNIT;
2201        bitpos += bitsize, xbitpos += bitsize)
2202     {
2203       /* We need a new source operand each time xbitpos is on a
2204          word boundary and when xbitpos == big_endian_correction
2205          (the first time through).  */
2206       if (xbitpos % BITS_PER_WORD == 0
2207           || xbitpos == big_endian_correction)
2208         src = operand_subword_force (srcreg, xbitpos / BITS_PER_WORD,
2209                                      GET_MODE (srcreg));
2210
2211       /* We need a new destination operand each time bitpos is on
2212          a word boundary.  */
2213       if (bitpos % BITS_PER_WORD == 0)
2214         dst = operand_subword (tgtblk, bitpos / BITS_PER_WORD, 1, BLKmode);
2215
2216       /* Use xbitpos for the source extraction (right justified) and
2217          xbitpos for the destination store (left justified).  */
2218       store_bit_field (dst, bitsize, bitpos % BITS_PER_WORD, word_mode,
2219                        extract_bit_field (src, bitsize,
2220                                           xbitpos % BITS_PER_WORD, 1,
2221                                           NULL_RTX, word_mode, word_mode,
2222                                           BITS_PER_WORD),
2223                        BITS_PER_WORD);
2224     }
2225
2226   return tgtblk;
2227 }
2228
2229 /* Add a USE expression for REG to the (possibly empty) list pointed
2230    to by CALL_FUSAGE.  REG must denote a hard register.  */
2231
2232 void
2233 use_reg (call_fusage, reg)
2234      rtx *call_fusage, reg;
2235 {
2236   if (GET_CODE (reg) != REG
2237       || REGNO (reg) >= FIRST_PSEUDO_REGISTER)
2238     abort ();
2239
2240   *call_fusage
2241     = gen_rtx_EXPR_LIST (VOIDmode,
2242                          gen_rtx_USE (VOIDmode, reg), *call_fusage);
2243 }
2244
2245 /* Add USE expressions to *CALL_FUSAGE for each of NREGS consecutive regs,
2246    starting at REGNO.  All of these registers must be hard registers.  */
2247
2248 void
2249 use_regs (call_fusage, regno, nregs)
2250      rtx *call_fusage;
2251      int regno;
2252      int nregs;
2253 {
2254   int i;
2255
2256   if (regno + nregs > FIRST_PSEUDO_REGISTER)
2257     abort ();
2258
2259   for (i = 0; i < nregs; i++)
2260     use_reg (call_fusage, gen_rtx_REG (reg_raw_mode[regno + i], regno + i));
2261 }
2262
2263 /* Add USE expressions to *CALL_FUSAGE for each REG contained in the
2264    PARALLEL REGS.  This is for calls that pass values in multiple
2265    non-contiguous locations.  The Irix 6 ABI has examples of this.  */
2266
2267 void
2268 use_group_regs (call_fusage, regs)
2269      rtx *call_fusage;
2270      rtx regs;
2271 {
2272   int i;
2273
2274   for (i = 0; i < XVECLEN (regs, 0); i++)
2275     {
2276       rtx reg = XEXP (XVECEXP (regs, 0, i), 0);
2277
2278       /* A NULL entry means the parameter goes both on the stack and in
2279          registers.  This can also be a MEM for targets that pass values
2280          partially on the stack and partially in registers.  */
2281       if (reg != 0 && GET_CODE (reg) == REG)
2282         use_reg (call_fusage, reg);
2283     }
2284 }
2285 \f
2286
2287 int
2288 can_store_by_pieces (len, constfun, constfundata, align)
2289      unsigned HOST_WIDE_INT len;
2290      rtx (*constfun) PARAMS ((PTR, HOST_WIDE_INT, enum machine_mode));
2291      PTR constfundata;
2292      unsigned int align;
2293 {
2294   unsigned HOST_WIDE_INT max_size, l;
2295   HOST_WIDE_INT offset = 0;
2296   enum machine_mode mode, tmode;
2297   enum insn_code icode;
2298   int reverse;
2299   rtx cst;
2300
2301   if (! MOVE_BY_PIECES_P (len, align))
2302     return 0;
2303
2304   if (! SLOW_UNALIGNED_ACCESS (word_mode, align)
2305       || align > MOVE_MAX * BITS_PER_UNIT || align >= BIGGEST_ALIGNMENT)
2306     align = MOVE_MAX * BITS_PER_UNIT;
2307
2308   /* We would first store what we can in the largest integer mode, then go to
2309      successively smaller modes.  */
2310
2311   for (reverse = 0;
2312        reverse <= (HAVE_PRE_DECREMENT || HAVE_POST_DECREMENT);
2313        reverse++)
2314     {
2315       l = len;
2316       mode = VOIDmode;
2317       max_size = MOVE_MAX_PIECES + 1;
2318       while (max_size > 1)
2319         {
2320           for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
2321                tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
2322             if (GET_MODE_SIZE (tmode) < max_size)
2323               mode = tmode;
2324
2325           if (mode == VOIDmode)
2326             break;
2327
2328           icode = mov_optab->handlers[(int) mode].insn_code;
2329           if (icode != CODE_FOR_nothing
2330               && align >= GET_MODE_ALIGNMENT (mode))
2331             {
2332               unsigned int size = GET_MODE_SIZE (mode);
2333
2334               while (l >= size)
2335                 {
2336                   if (reverse)
2337                     offset -= size;
2338
2339                   cst = (*constfun) (constfundata, offset, mode);
2340                   if (!LEGITIMATE_CONSTANT_P (cst))
2341                     return 0;
2342
2343                   if (!reverse)
2344                     offset += size;
2345
2346                   l -= size;
2347                 }
2348             }
2349
2350           max_size = GET_MODE_SIZE (mode);
2351         }
2352
2353       /* The code above should have handled everything.  */
2354       if (l != 0)
2355         abort ();
2356     }
2357
2358   return 1;
2359 }
2360
2361 /* Generate several move instructions to store LEN bytes generated by
2362    CONSTFUN to block TO.  (A MEM rtx with BLKmode).  CONSTFUNDATA is a
2363    pointer which will be passed as argument in every CONSTFUN call.
2364    ALIGN is maximum alignment we can assume.  */
2365
2366 void
2367 store_by_pieces (to, len, constfun, constfundata, align)
2368      rtx to;
2369      unsigned HOST_WIDE_INT len;
2370      rtx (*constfun) PARAMS ((PTR, HOST_WIDE_INT, enum machine_mode));
2371      PTR constfundata;
2372      unsigned int align;
2373 {
2374   struct store_by_pieces data;
2375
2376   if (! MOVE_BY_PIECES_P (len, align))
2377     abort ();
2378   to = protect_from_queue (to, 1);
2379   data.constfun = constfun;
2380   data.constfundata = constfundata;
2381   data.len = len;
2382   data.to = to;
2383   store_by_pieces_1 (&data, align);
2384 }
2385
2386 /* Generate several move instructions to clear LEN bytes of block TO.  (A MEM
2387    rtx with BLKmode).  The caller must pass TO through protect_from_queue
2388    before calling. ALIGN is maximum alignment we can assume.  */
2389
2390 static void
2391 clear_by_pieces (to, len, align)
2392      rtx to;
2393      unsigned HOST_WIDE_INT len;
2394      unsigned int align;
2395 {
2396   struct store_by_pieces data;
2397
2398   data.constfun = clear_by_pieces_1;
2399   data.constfundata = NULL;
2400   data.len = len;
2401   data.to = to;
2402   store_by_pieces_1 (&data, align);
2403 }
2404
2405 /* Callback routine for clear_by_pieces.
2406    Return const0_rtx unconditionally.  */
2407
2408 static rtx
2409 clear_by_pieces_1 (data, offset, mode)
2410      PTR data ATTRIBUTE_UNUSED;
2411      HOST_WIDE_INT offset ATTRIBUTE_UNUSED;
2412      enum machine_mode mode ATTRIBUTE_UNUSED;
2413 {
2414   return const0_rtx;
2415 }
2416
2417 /* Subroutine of clear_by_pieces and store_by_pieces.
2418    Generate several move instructions to store LEN bytes of block TO.  (A MEM
2419    rtx with BLKmode).  The caller must pass TO through protect_from_queue
2420    before calling.  ALIGN is maximum alignment we can assume.  */
2421
2422 static void
2423 store_by_pieces_1 (data, align)
2424      struct store_by_pieces *data;
2425      unsigned int align;
2426 {
2427   rtx to_addr = XEXP (data->to, 0);
2428   unsigned HOST_WIDE_INT max_size = MOVE_MAX_PIECES + 1;
2429   enum machine_mode mode = VOIDmode, tmode;
2430   enum insn_code icode;
2431
2432   data->offset = 0;
2433   data->to_addr = to_addr;
2434   data->autinc_to
2435     = (GET_CODE (to_addr) == PRE_INC || GET_CODE (to_addr) == PRE_DEC
2436        || GET_CODE (to_addr) == POST_INC || GET_CODE (to_addr) == POST_DEC);
2437
2438   data->explicit_inc_to = 0;
2439   data->reverse
2440     = (GET_CODE (to_addr) == PRE_DEC || GET_CODE (to_addr) == POST_DEC);
2441   if (data->reverse)
2442     data->offset = data->len;
2443
2444   /* If storing requires more than two move insns,
2445      copy addresses to registers (to make displacements shorter)
2446      and use post-increment if available.  */
2447   if (!data->autinc_to
2448       && move_by_pieces_ninsns (data->len, align) > 2)
2449     {
2450       /* Determine the main mode we'll be using.  */
2451       for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
2452            tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
2453         if (GET_MODE_SIZE (tmode) < max_size)
2454           mode = tmode;
2455
2456       if (USE_STORE_PRE_DECREMENT (mode) && data->reverse && ! data->autinc_to)
2457         {
2458           data->to_addr = copy_addr_to_reg (plus_constant (to_addr, data->len));
2459           data->autinc_to = 1;
2460           data->explicit_inc_to = -1;
2461         }
2462
2463       if (USE_STORE_POST_INCREMENT (mode) && ! data->reverse
2464           && ! data->autinc_to)
2465         {
2466           data->to_addr = copy_addr_to_reg (to_addr);
2467           data->autinc_to = 1;
2468           data->explicit_inc_to = 1;
2469         }
2470
2471       if ( !data->autinc_to && CONSTANT_P (to_addr))
2472         data->to_addr = copy_addr_to_reg (to_addr);
2473     }
2474
2475   if (! SLOW_UNALIGNED_ACCESS (word_mode, align)
2476       || align > MOVE_MAX * BITS_PER_UNIT || align >= BIGGEST_ALIGNMENT)
2477     align = MOVE_MAX * BITS_PER_UNIT;
2478
2479   /* First store what we can in the largest integer mode, then go to
2480      successively smaller modes.  */
2481
2482   while (max_size > 1)
2483     {
2484       for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
2485            tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
2486         if (GET_MODE_SIZE (tmode) < max_size)
2487           mode = tmode;
2488
2489       if (mode == VOIDmode)
2490         break;
2491
2492       icode = mov_optab->handlers[(int) mode].insn_code;
2493       if (icode != CODE_FOR_nothing && align >= GET_MODE_ALIGNMENT (mode))
2494         store_by_pieces_2 (GEN_FCN (icode), mode, data);
2495
2496       max_size = GET_MODE_SIZE (mode);
2497     }
2498
2499   /* The code above should have handled everything.  */
2500   if (data->len != 0)
2501     abort ();
2502 }
2503
2504 /* Subroutine of store_by_pieces_1.  Store as many bytes as appropriate
2505    with move instructions for mode MODE.  GENFUN is the gen_... function
2506    to make a move insn for that mode.  DATA has all the other info.  */
2507
2508 static void
2509 store_by_pieces_2 (genfun, mode, data)
2510      rtx (*genfun) PARAMS ((rtx, ...));
2511      enum machine_mode mode;
2512      struct store_by_pieces *data;
2513 {
2514   unsigned int size = GET_MODE_SIZE (mode);
2515   rtx to1, cst;
2516
2517   while (data->len >= size)
2518     {
2519       if (data->reverse)
2520         data->offset -= size;
2521
2522       if (data->autinc_to)
2523         to1 = adjust_automodify_address (data->to, mode, data->to_addr,
2524                                          data->offset);
2525       else
2526         to1 = adjust_address (data->to, mode, data->offset);
2527
2528       if (HAVE_PRE_DECREMENT && data->explicit_inc_to < 0)
2529         emit_insn (gen_add2_insn (data->to_addr,
2530                                   GEN_INT (-(HOST_WIDE_INT) size)));
2531
2532       cst = (*data->constfun) (data->constfundata, data->offset, mode);
2533       emit_insn ((*genfun) (to1, cst));
2534
2535       if (HAVE_POST_INCREMENT && data->explicit_inc_to > 0)
2536         emit_insn (gen_add2_insn (data->to_addr, GEN_INT (size)));
2537
2538       if (! data->reverse)
2539         data->offset += size;
2540
2541       data->len -= size;
2542     }
2543 }
2544 \f
2545 /* Write zeros through the storage of OBJECT.  If OBJECT has BLKmode, SIZE is
2546    its length in bytes.  */
2547
2548 rtx
2549 clear_storage (object, size)
2550      rtx object;
2551      rtx size;
2552 {
2553 #ifdef TARGET_MEM_FUNCTIONS
2554   static tree fn;
2555   tree call_expr, arg_list;
2556 #endif
2557   rtx retval = 0;
2558   unsigned int align = (GET_CODE (object) == MEM ? MEM_ALIGN (object)
2559                         : GET_MODE_ALIGNMENT (GET_MODE (object)));
2560
2561   /* If OBJECT is not BLKmode and SIZE is the same size as its mode,
2562      just move a zero.  Otherwise, do this a piece at a time.  */
2563   if (GET_MODE (object) != BLKmode
2564       && GET_CODE (size) == CONST_INT
2565       && GET_MODE_SIZE (GET_MODE (object)) == (unsigned int) INTVAL (size))
2566     emit_move_insn (object, CONST0_RTX (GET_MODE (object)));
2567   else
2568     {
2569       object = protect_from_queue (object, 1);
2570       size = protect_from_queue (size, 0);
2571
2572       if (GET_CODE (size) == CONST_INT
2573           && MOVE_BY_PIECES_P (INTVAL (size), align))
2574         clear_by_pieces (object, INTVAL (size), align);
2575       else
2576         {
2577           /* Try the most limited insn first, because there's no point
2578              including more than one in the machine description unless
2579              the more limited one has some advantage.  */
2580
2581           rtx opalign = GEN_INT (align / BITS_PER_UNIT);
2582           enum machine_mode mode;
2583
2584           for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
2585                mode = GET_MODE_WIDER_MODE (mode))
2586             {
2587               enum insn_code code = clrstr_optab[(int) mode];
2588               insn_operand_predicate_fn pred;
2589
2590               if (code != CODE_FOR_nothing
2591                   /* We don't need MODE to be narrower than
2592                      BITS_PER_HOST_WIDE_INT here because if SIZE is less than
2593                      the mode mask, as it is returned by the macro, it will
2594                      definitely be less than the actual mode mask.  */
2595                   && ((GET_CODE (size) == CONST_INT
2596                        && ((unsigned HOST_WIDE_INT) INTVAL (size)
2597                            <= (GET_MODE_MASK (mode) >> 1)))
2598                       || GET_MODE_BITSIZE (mode) >= BITS_PER_WORD)
2599                   && ((pred = insn_data[(int) code].operand[0].predicate) == 0
2600                       || (*pred) (object, BLKmode))
2601                   && ((pred = insn_data[(int) code].operand[2].predicate) == 0
2602                       || (*pred) (opalign, VOIDmode)))
2603                 {
2604                   rtx op1;
2605                   rtx last = get_last_insn ();
2606                   rtx pat;
2607
2608                   op1 = convert_to_mode (mode, size, 1);
2609                   pred = insn_data[(int) code].operand[1].predicate;
2610                   if (pred != 0 && ! (*pred) (op1, mode))
2611                     op1 = copy_to_mode_reg (mode, op1);
2612
2613                   pat = GEN_FCN ((int) code) (object, op1, opalign);
2614                   if (pat)
2615                     {
2616                       emit_insn (pat);
2617                       return 0;
2618                     }
2619                   else
2620                     delete_insns_since (last);
2621                 }
2622             }
2623
2624           /* OBJECT or SIZE may have been passed through protect_from_queue.
2625
2626              It is unsafe to save the value generated by protect_from_queue
2627              and reuse it later.  Consider what happens if emit_queue is
2628              called before the return value from protect_from_queue is used.
2629
2630              Expansion of the CALL_EXPR below will call emit_queue before
2631              we are finished emitting RTL for argument setup.  So if we are
2632              not careful we could get the wrong value for an argument.
2633
2634              To avoid this problem we go ahead and emit code to copy OBJECT
2635              and SIZE into new pseudos.  We can then place those new pseudos
2636              into an RTL_EXPR and use them later, even after a call to
2637              emit_queue.
2638
2639              Note this is not strictly needed for library calls since they
2640              do not call emit_queue before loading their arguments.  However,
2641              we may need to have library calls call emit_queue in the future
2642              since failing to do so could cause problems for targets which
2643              define SMALL_REGISTER_CLASSES and pass arguments in registers.  */
2644           object = copy_to_mode_reg (Pmode, XEXP (object, 0));
2645
2646 #ifdef TARGET_MEM_FUNCTIONS
2647           size = copy_to_mode_reg (TYPE_MODE (sizetype), size);
2648 #else
2649           size = convert_to_mode (TYPE_MODE (integer_type_node), size,
2650                                   TREE_UNSIGNED (integer_type_node));
2651           size = copy_to_mode_reg (TYPE_MODE (integer_type_node), size);
2652 #endif
2653
2654 #ifdef TARGET_MEM_FUNCTIONS
2655           /* It is incorrect to use the libcall calling conventions to call
2656              memset in this context.
2657
2658              This could be a user call to memset and the user may wish to
2659              examine the return value from memset.
2660
2661              For targets where libcalls and normal calls have different
2662              conventions for returning pointers, we could end up generating
2663              incorrect code.
2664
2665              So instead of using a libcall sequence we build up a suitable
2666              CALL_EXPR and expand the call in the normal fashion.  */
2667           if (fn == NULL_TREE)
2668             {
2669               tree fntype;
2670
2671               /* This was copied from except.c, I don't know if all this is
2672                  necessary in this context or not.  */
2673               fn = get_identifier ("memset");
2674               fntype = build_pointer_type (void_type_node);
2675               fntype = build_function_type (fntype, NULL_TREE);
2676               fn = build_decl (FUNCTION_DECL, fn, fntype);
2677               ggc_add_tree_root (&fn, 1);
2678               DECL_EXTERNAL (fn) = 1;
2679               TREE_PUBLIC (fn) = 1;
2680               DECL_ARTIFICIAL (fn) = 1;
2681               TREE_NOTHROW (fn) = 1;
2682               make_decl_rtl (fn, NULL);
2683               assemble_external (fn);
2684             }
2685
2686           /* We need to make an argument list for the function call.
2687
2688              memset has three arguments, the first is a void * addresses, the
2689              second an integer with the initialization value, the last is a
2690              size_t byte count for the copy.  */
2691           arg_list
2692             = build_tree_list (NULL_TREE,
2693                                make_tree (build_pointer_type (void_type_node),
2694                                           object));
2695           TREE_CHAIN (arg_list)
2696             = build_tree_list (NULL_TREE,
2697                                make_tree (integer_type_node, const0_rtx));
2698           TREE_CHAIN (TREE_CHAIN (arg_list))
2699             = build_tree_list (NULL_TREE, make_tree (sizetype, size));
2700           TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (arg_list))) = NULL_TREE;
2701
2702           /* Now we have to build up the CALL_EXPR itself.  */
2703           call_expr = build1 (ADDR_EXPR,
2704                               build_pointer_type (TREE_TYPE (fn)), fn);
2705           call_expr = build (CALL_EXPR, TREE_TYPE (TREE_TYPE (fn)),
2706                              call_expr, arg_list, NULL_TREE);
2707           TREE_SIDE_EFFECTS (call_expr) = 1;
2708
2709           retval = expand_expr (call_expr, NULL_RTX, VOIDmode, 0);
2710 #else
2711           emit_library_call (bzero_libfunc, LCT_NORMAL,
2712                              VOIDmode, 2, object, Pmode, size,
2713                              TYPE_MODE (integer_type_node));
2714 #endif
2715
2716           /* If we are initializing a readonly value, show the above call
2717              clobbered it.  Otherwise, a load from it may erroneously be
2718              hoisted from a loop.  */
2719           if (RTX_UNCHANGING_P (object))
2720             emit_insn (gen_rtx_CLOBBER (VOIDmode, object));
2721         }
2722     }
2723
2724   return retval;
2725 }
2726
2727 /* Generate code to copy Y into X.
2728    Both Y and X must have the same mode, except that
2729    Y can be a constant with VOIDmode.
2730    This mode cannot be BLKmode; use emit_block_move for that.
2731
2732    Return the last instruction emitted.  */
2733
2734 rtx
2735 emit_move_insn (x, y)
2736      rtx x, y;
2737 {
2738   enum machine_mode mode = GET_MODE (x);
2739   rtx y_cst = NULL_RTX;
2740   rtx last_insn;
2741
2742   x = protect_from_queue (x, 1);
2743   y = protect_from_queue (y, 0);
2744
2745   if (mode == BLKmode || (GET_MODE (y) != mode && GET_MODE (y) != VOIDmode))
2746     abort ();
2747
2748   /* Never force constant_p_rtx to memory.  */
2749   if (GET_CODE (y) == CONSTANT_P_RTX)
2750     ;
2751   else if (CONSTANT_P (y) && ! LEGITIMATE_CONSTANT_P (y))
2752     {
2753       y_cst = y;
2754       y = force_const_mem (mode, y);
2755     }
2756
2757   /* If X or Y are memory references, verify that their addresses are valid
2758      for the machine.  */
2759   if (GET_CODE (x) == MEM
2760       && ((! memory_address_p (GET_MODE (x), XEXP (x, 0))
2761            && ! push_operand (x, GET_MODE (x)))
2762           || (flag_force_addr
2763               && CONSTANT_ADDRESS_P (XEXP (x, 0)))))
2764     x = validize_mem (x);
2765
2766   if (GET_CODE (y) == MEM
2767       && (! memory_address_p (GET_MODE (y), XEXP (y, 0))
2768           || (flag_force_addr
2769               && CONSTANT_ADDRESS_P (XEXP (y, 0)))))
2770     y = validize_mem (y);
2771
2772   if (mode == BLKmode)
2773     abort ();
2774
2775   last_insn = emit_move_insn_1 (x, y);
2776
2777   if (y_cst && GET_CODE (x) == REG)
2778     set_unique_reg_note (last_insn, REG_EQUAL, y_cst);
2779
2780   return last_insn;
2781 }
2782
2783 /* Low level part of emit_move_insn.
2784    Called just like emit_move_insn, but assumes X and Y
2785    are basically valid.  */
2786
2787 rtx
2788 emit_move_insn_1 (x, y)
2789      rtx x, y;
2790 {
2791   enum machine_mode mode = GET_MODE (x);
2792   enum machine_mode submode;
2793   enum mode_class class = GET_MODE_CLASS (mode);
2794   unsigned int i;
2795
2796   if ((unsigned int) mode >= (unsigned int) MAX_MACHINE_MODE)
2797     abort ();
2798
2799   if (mov_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
2800     return
2801       emit_insn (GEN_FCN (mov_optab->handlers[(int) mode].insn_code) (x, y));
2802
2803   /* Expand complex moves by moving real part and imag part, if possible.  */
2804   else if ((class == MODE_COMPLEX_FLOAT || class == MODE_COMPLEX_INT)
2805            && BLKmode != (submode = mode_for_size ((GET_MODE_UNIT_SIZE (mode)
2806                                                     * BITS_PER_UNIT),
2807                                                    (class == MODE_COMPLEX_INT
2808                                                     ? MODE_INT : MODE_FLOAT),
2809                                                    0))
2810            && (mov_optab->handlers[(int) submode].insn_code
2811                != CODE_FOR_nothing))
2812     {
2813       /* Don't split destination if it is a stack push.  */
2814       int stack = push_operand (x, GET_MODE (x));
2815
2816 #ifdef PUSH_ROUNDING
2817       /* In case we output to the stack, but the size is smaller machine can
2818          push exactly, we need to use move instructions.  */
2819       if (stack
2820           && PUSH_ROUNDING (GET_MODE_SIZE (submode)) != GET_MODE_SIZE (submode))
2821         {
2822           rtx temp;
2823           int offset1, offset2;
2824
2825           /* Do not use anti_adjust_stack, since we don't want to update
2826              stack_pointer_delta.  */
2827           temp = expand_binop (Pmode,
2828 #ifdef STACK_GROWS_DOWNWARD
2829                                sub_optab,
2830 #else
2831                                add_optab,
2832 #endif
2833                                stack_pointer_rtx,
2834                                GEN_INT
2835                                  (PUSH_ROUNDING (GET_MODE_SIZE (GET_MODE (x)))),
2836                                stack_pointer_rtx,
2837                                0,
2838                                OPTAB_LIB_WIDEN);
2839           if (temp != stack_pointer_rtx)
2840             emit_move_insn (stack_pointer_rtx, temp);
2841 #ifdef STACK_GROWS_DOWNWARD
2842           offset1 = 0;
2843           offset2 = GET_MODE_SIZE (submode);
2844 #else
2845           offset1 = -PUSH_ROUNDING (GET_MODE_SIZE (GET_MODE (x)));
2846           offset2 = (-PUSH_ROUNDING (GET_MODE_SIZE (GET_MODE (x)))
2847                      + GET_MODE_SIZE (submode));
2848 #endif
2849           emit_move_insn (change_address (x, submode,
2850                                           gen_rtx_PLUS (Pmode,
2851                                                         stack_pointer_rtx,
2852                                                         GEN_INT (offset1))),
2853                           gen_realpart (submode, y));
2854           emit_move_insn (change_address (x, submode,
2855                                           gen_rtx_PLUS (Pmode,
2856                                                         stack_pointer_rtx,
2857                                                         GEN_INT (offset2))),
2858                           gen_imagpart (submode, y));
2859         }
2860       else
2861 #endif
2862       /* If this is a stack, push the highpart first, so it
2863          will be in the argument order.
2864
2865          In that case, change_address is used only to convert
2866          the mode, not to change the address.  */
2867       if (stack)
2868         {
2869           /* Note that the real part always precedes the imag part in memory
2870              regardless of machine's endianness.  */
2871 #ifdef STACK_GROWS_DOWNWARD
2872           emit_insn (GEN_FCN (mov_optab->handlers[(int) submode].insn_code)
2873                      (gen_rtx_MEM (submode, XEXP (x, 0)),
2874                       gen_imagpart (submode, y)));
2875           emit_insn (GEN_FCN (mov_optab->handlers[(int) submode].insn_code)
2876                      (gen_rtx_MEM (submode, XEXP (x, 0)),
2877                       gen_realpart (submode, y)));
2878 #else
2879           emit_insn (GEN_FCN (mov_optab->handlers[(int) submode].insn_code)
2880                      (gen_rtx_MEM (submode, XEXP (x, 0)),
2881                       gen_realpart (submode, y)));
2882           emit_insn (GEN_FCN (mov_optab->handlers[(int) submode].insn_code)
2883                      (gen_rtx_MEM (submode, XEXP (x, 0)),
2884                       gen_imagpart (submode, y)));
2885 #endif
2886         }
2887       else
2888         {
2889           rtx realpart_x, realpart_y;
2890           rtx imagpart_x, imagpart_y;
2891
2892           /* If this is a complex value with each part being smaller than a
2893              word, the usual calling sequence will likely pack the pieces into
2894              a single register.  Unfortunately, SUBREG of hard registers only
2895              deals in terms of words, so we have a problem converting input
2896              arguments to the CONCAT of two registers that is used elsewhere
2897              for complex values.  If this is before reload, we can copy it into
2898              memory and reload.  FIXME, we should see about using extract and
2899              insert on integer registers, but complex short and complex char
2900              variables should be rarely used.  */
2901           if (GET_MODE_BITSIZE (mode) < 2 * BITS_PER_WORD
2902               && (reload_in_progress | reload_completed) == 0)
2903             {
2904               int packed_dest_p = (REG_P (x) && REGNO (x) < FIRST_PSEUDO_REGISTER);
2905               int packed_src_p  = (REG_P (y) && REGNO (y) < FIRST_PSEUDO_REGISTER);
2906
2907               if (packed_dest_p || packed_src_p)
2908                 {
2909                   enum mode_class reg_class = ((class == MODE_COMPLEX_FLOAT)
2910                                                ? MODE_FLOAT : MODE_INT);
2911
2912                   enum machine_mode reg_mode
2913                     = mode_for_size (GET_MODE_BITSIZE (mode), reg_class, 1);
2914
2915                   if (reg_mode != BLKmode)
2916                     {
2917                       rtx mem = assign_stack_temp (reg_mode,
2918                                                    GET_MODE_SIZE (mode), 0);
2919                       rtx cmem = adjust_address (mem, mode, 0);
2920
2921                       cfun->cannot_inline
2922                         = N_("function using short complex types cannot be inline");
2923
2924                       if (packed_dest_p)
2925                         {
2926                           rtx sreg = gen_rtx_SUBREG (reg_mode, x, 0);
2927                           emit_move_insn_1 (cmem, y);
2928                           return emit_move_insn_1 (sreg, mem);
2929                         }
2930                       else
2931                         {
2932                           rtx sreg = gen_rtx_SUBREG (reg_mode, y, 0);
2933                           emit_move_insn_1 (mem, sreg);
2934                           return emit_move_insn_1 (x, cmem);
2935                         }
2936                     }
2937                 }
2938             }
2939
2940           realpart_x = gen_realpart (submode, x);
2941           realpart_y = gen_realpart (submode, y);
2942           imagpart_x = gen_imagpart (submode, x);
2943           imagpart_y = gen_imagpart (submode, y);
2944
2945           /* Show the output dies here.  This is necessary for SUBREGs
2946              of pseudos since we cannot track their lifetimes correctly;
2947              hard regs shouldn't appear here except as return values.
2948              We never want to emit such a clobber after reload.  */
2949           if (x != y
2950               && ! (reload_in_progress || reload_completed)
2951               && (GET_CODE (realpart_x) == SUBREG
2952                   || GET_CODE (imagpart_x) == SUBREG))
2953             {
2954               emit_insn (gen_rtx_CLOBBER (VOIDmode, x));
2955             }
2956
2957           emit_insn (GEN_FCN (mov_optab->handlers[(int) submode].insn_code)
2958                      (realpart_x, realpart_y));
2959           emit_insn (GEN_FCN (mov_optab->handlers[(int) submode].insn_code)
2960                      (imagpart_x, imagpart_y));
2961         }
2962
2963       return get_last_insn ();
2964     }
2965
2966   /* This will handle any multi-word mode that lacks a move_insn pattern.
2967      However, you will get better code if you define such patterns,
2968      even if they must turn into multiple assembler instructions.  */
2969   else if (GET_MODE_SIZE (mode) > UNITS_PER_WORD)
2970     {
2971       rtx last_insn = 0;
2972       rtx seq, inner;
2973       int need_clobber;
2974
2975 #ifdef PUSH_ROUNDING
2976
2977       /* If X is a push on the stack, do the push now and replace
2978          X with a reference to the stack pointer.  */
2979       if (push_operand (x, GET_MODE (x)))
2980         {
2981           rtx temp;
2982           enum rtx_code code;
2983
2984           /* Do not use anti_adjust_stack, since we don't want to update
2985              stack_pointer_delta.  */
2986           temp = expand_binop (Pmode,
2987 #ifdef STACK_GROWS_DOWNWARD
2988                                sub_optab,
2989 #else
2990                                add_optab,
2991 #endif
2992                                stack_pointer_rtx,
2993                                GEN_INT
2994                                  (PUSH_ROUNDING (GET_MODE_SIZE (GET_MODE (x)))),
2995                                stack_pointer_rtx,
2996                                0,
2997                                OPTAB_LIB_WIDEN);
2998           if (temp != stack_pointer_rtx)
2999             emit_move_insn (stack_pointer_rtx, temp);
3000
3001           code = GET_CODE (XEXP (x, 0));
3002           /* Just hope that small offsets off SP are OK.  */
3003           if (code == POST_INC)
3004             temp = gen_rtx_PLUS (Pmode, stack_pointer_rtx,
3005                                 GEN_INT (-(HOST_WIDE_INT)
3006                                            GET_MODE_SIZE (GET_MODE (x))));
3007           else if (code == POST_DEC)
3008             temp = gen_rtx_PLUS (Pmode, stack_pointer_rtx,
3009                                 GEN_INT (GET_MODE_SIZE (GET_MODE (x))));
3010           else
3011             temp = stack_pointer_rtx;
3012
3013           x = change_address (x, VOIDmode, temp);
3014         }
3015 #endif
3016
3017       /* If we are in reload, see if either operand is a MEM whose address
3018          is scheduled for replacement.  */
3019       if (reload_in_progress && GET_CODE (x) == MEM
3020           && (inner = find_replacement (&XEXP (x, 0))) != XEXP (x, 0))
3021         x = replace_equiv_address_nv (x, inner);
3022       if (reload_in_progress && GET_CODE (y) == MEM
3023           && (inner = find_replacement (&XEXP (y, 0))) != XEXP (y, 0))
3024         y = replace_equiv_address_nv (y, inner);
3025
3026       start_sequence ();
3027
3028       need_clobber = 0;
3029       for (i = 0;
3030            i < (GET_MODE_SIZE (mode) + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD;
3031            i++)
3032         {
3033           rtx xpart = operand_subword (x, i, 1, mode);
3034           rtx ypart = operand_subword (y, i, 1, mode);
3035
3036           /* If we can't get a part of Y, put Y into memory if it is a
3037              constant.  Otherwise, force it into a register.  If we still
3038              can't get a part of Y, abort.  */
3039           if (ypart == 0 && CONSTANT_P (y))
3040             {
3041               y = force_const_mem (mode, y);
3042               ypart = operand_subword (y, i, 1, mode);
3043             }
3044           else if (ypart == 0)
3045             ypart = operand_subword_force (y, i, mode);
3046
3047           if (xpart == 0 || ypart == 0)
3048             abort ();
3049
3050           need_clobber |= (GET_CODE (xpart) == SUBREG);
3051
3052           last_insn = emit_move_insn (xpart, ypart);
3053         }
3054
3055       seq = gen_sequence ();
3056       end_sequence ();
3057
3058       /* Show the output dies here.  This is necessary for SUBREGs
3059          of pseudos since we cannot track their lifetimes correctly;
3060          hard regs shouldn't appear here except as return values.
3061          We never want to emit such a clobber after reload.  */
3062       if (x != y
3063           && ! (reload_in_progress || reload_completed)
3064           && need_clobber != 0)
3065         {
3066           emit_insn (gen_rtx_CLOBBER (VOIDmode, x));
3067         }
3068
3069       emit_insn (seq);
3070
3071       return last_insn;
3072     }
3073   else
3074     abort ();
3075 }
3076 \f
3077 /* Pushing data onto the stack.  */
3078
3079 /* Push a block of length SIZE (perhaps variable)
3080    and return an rtx to address the beginning of the block.
3081    Note that it is not possible for the value returned to be a QUEUED.
3082    The value may be virtual_outgoing_args_rtx.
3083
3084    EXTRA is the number of bytes of padding to push in addition to SIZE.
3085    BELOW nonzero means this padding comes at low addresses;
3086    otherwise, the padding comes at high addresses.  */
3087
3088 rtx
3089 push_block (size, extra, below)
3090      rtx size;
3091      int extra, below;
3092 {
3093   rtx temp;
3094
3095   size = convert_modes (Pmode, ptr_mode, size, 1);
3096   if (CONSTANT_P (size))
3097     anti_adjust_stack (plus_constant (size, extra));
3098   else if (GET_CODE (size) == REG && extra == 0)
3099     anti_adjust_stack (size);
3100   else
3101     {
3102       temp = copy_to_mode_reg (Pmode, size);
3103       if (extra != 0)
3104         temp = expand_binop (Pmode, add_optab, temp, GEN_INT (extra),
3105                              temp, 0, OPTAB_LIB_WIDEN);
3106       anti_adjust_stack (temp);
3107     }
3108
3109 #ifndef STACK_GROWS_DOWNWARD
3110   if (0)
3111 #else
3112   if (1)
3113 #endif
3114     {
3115       temp = virtual_outgoing_args_rtx;
3116       if (extra != 0 && below)
3117         temp = plus_constant (temp, extra);
3118     }
3119   else
3120     {
3121       if (GET_CODE (size) == CONST_INT)
3122         temp = plus_constant (virtual_outgoing_args_rtx,
3123                               -INTVAL (size) - (below ? 0 : extra));
3124       else if (extra != 0 && !below)
3125         temp = gen_rtx_PLUS (Pmode, virtual_outgoing_args_rtx,
3126                              negate_rtx (Pmode, plus_constant (size, extra)));
3127       else
3128         temp = gen_rtx_PLUS (Pmode, virtual_outgoing_args_rtx,
3129                              negate_rtx (Pmode, size));
3130     }
3131
3132   return memory_address (GET_CLASS_NARROWEST_MODE (MODE_INT), temp);
3133 }
3134
3135 #ifdef PUSH_ROUNDING
3136
3137 /* Emit single push insn.  */
3138
3139 static void
3140 emit_single_push_insn (mode, x, type)
3141      rtx x;
3142      enum machine_mode mode;
3143      tree type;
3144 {
3145   rtx dest_addr;
3146   unsigned rounded_size = PUSH_ROUNDING (GET_MODE_SIZE (mode));
3147   rtx dest;
3148   enum insn_code icode;
3149   insn_operand_predicate_fn pred;
3150
3151   stack_pointer_delta += PUSH_ROUNDING (GET_MODE_SIZE (mode));
3152   /* If there is push pattern, use it.  Otherwise try old way of throwing
3153      MEM representing push operation to move expander.  */
3154   icode = push_optab->handlers[(int) mode].insn_code;
3155   if (icode != CODE_FOR_nothing)
3156     {
3157       if (((pred = insn_data[(int) icode].operand[0].predicate)
3158            && !((*pred) (x, mode))))
3159         x = force_reg (mode, x);
3160       emit_insn (GEN_FCN (icode) (x));
3161       return;
3162     }
3163   if (GET_MODE_SIZE (mode) == rounded_size)
3164     dest_addr = gen_rtx_fmt_e (STACK_PUSH_CODE, Pmode, stack_pointer_rtx);
3165   else
3166     {
3167 #ifdef STACK_GROWS_DOWNWARD
3168       dest_addr = gen_rtx_PLUS (Pmode, stack_pointer_rtx,
3169                                 GEN_INT (-(HOST_WIDE_INT) rounded_size));
3170 #else
3171       dest_addr = gen_rtx_PLUS (Pmode, stack_pointer_rtx,
3172                                 GEN_INT (rounded_size));
3173 #endif
3174       dest_addr = gen_rtx_PRE_MODIFY (Pmode, stack_pointer_rtx, dest_addr);
3175     }
3176
3177   dest = gen_rtx_MEM (mode, dest_addr);
3178
3179   if (type != 0)
3180     {
3181       set_mem_attributes (dest, type, 1);
3182
3183       if (flag_optimize_sibling_calls)
3184         /* Function incoming arguments may overlap with sibling call
3185            outgoing arguments and we cannot allow reordering of reads
3186            from function arguments with stores to outgoing arguments
3187            of sibling calls.  */
3188         set_mem_alias_set (dest, 0);
3189     }
3190   emit_move_insn (dest, x);
3191 }
3192 #endif
3193
3194 /* Generate code to push X onto the stack, assuming it has mode MODE and
3195    type TYPE.
3196    MODE is redundant except when X is a CONST_INT (since they don't
3197    carry mode info).
3198    SIZE is an rtx for the size of data to be copied (in bytes),
3199    needed only if X is BLKmode.
3200
3201    ALIGN (in bits) is maximum alignment we can assume.
3202
3203    If PARTIAL and REG are both nonzero, then copy that many of the first
3204    words of X into registers starting with REG, and push the rest of X.
3205    The amount of space pushed is decreased by PARTIAL words,
3206    rounded *down* to a multiple of PARM_BOUNDARY.
3207    REG must be a hard register in this case.
3208    If REG is zero but PARTIAL is not, take any all others actions for an
3209    argument partially in registers, but do not actually load any
3210    registers.
3211
3212    EXTRA is the amount in bytes of extra space to leave next to this arg.
3213    This is ignored if an argument block has already been allocated.
3214
3215    On a machine that lacks real push insns, ARGS_ADDR is the address of
3216    the bottom of the argument block for this call.  We use indexing off there
3217    to store the arg.  On machines with push insns, ARGS_ADDR is 0 when a
3218    argument block has not been preallocated.
3219
3220    ARGS_SO_FAR is the size of args previously pushed for this call.
3221
3222    REG_PARM_STACK_SPACE is nonzero if functions require stack space
3223    for arguments passed in registers.  If nonzero, it will be the number
3224    of bytes required.  */
3225
3226 void
3227 emit_push_insn (x, mode, type, size, align, partial, reg, extra,
3228                 args_addr, args_so_far, reg_parm_stack_space,
3229                 alignment_pad)
3230      rtx x;
3231      enum machine_mode mode;
3232      tree type;
3233      rtx size;
3234      unsigned int align;
3235      int partial;
3236      rtx reg;
3237      int extra;
3238      rtx args_addr;
3239      rtx args_so_far;
3240      int reg_parm_stack_space;
3241      rtx alignment_pad;
3242 {
3243   rtx xinner;
3244   enum direction stack_direction
3245 #ifdef STACK_GROWS_DOWNWARD
3246     = downward;
3247 #else
3248     = upward;
3249 #endif
3250
3251   /* Decide where to pad the argument: `downward' for below,
3252      `upward' for above, or `none' for don't pad it.
3253      Default is below for small data on big-endian machines; else above.  */
3254   enum direction where_pad = FUNCTION_ARG_PADDING (mode, type);
3255
3256   /* Invert direction if stack is post-decrement.
3257      FIXME: why?  */
3258   if (STACK_PUSH_CODE == POST_DEC)
3259     if (where_pad != none)
3260       where_pad = (where_pad == downward ? upward : downward);
3261
3262   xinner = x = protect_from_queue (x, 0);
3263
3264   if (mode == BLKmode)
3265     {
3266       /* Copy a block into the stack, entirely or partially.  */
3267
3268       rtx temp;
3269       int used = partial * UNITS_PER_WORD;
3270       int offset = used % (PARM_BOUNDARY / BITS_PER_UNIT);
3271       int skip;
3272
3273       if (size == 0)
3274         abort ();
3275
3276       used -= offset;
3277
3278       /* USED is now the # of bytes we need not copy to the stack
3279          because registers will take care of them.  */
3280
3281       if (partial != 0)
3282         xinner = adjust_address (xinner, BLKmode, used);
3283
3284       /* If the partial register-part of the arg counts in its stack size,
3285          skip the part of stack space corresponding to the registers.
3286          Otherwise, start copying to the beginning of the stack space,
3287          by setting SKIP to 0.  */
3288       skip = (reg_parm_stack_space == 0) ? 0 : used;
3289
3290 #ifdef PUSH_ROUNDING
3291       /* Do it with several push insns if that doesn't take lots of insns
3292          and if there is no difficulty with push insns that skip bytes
3293          on the stack for alignment purposes.  */
3294       if (args_addr == 0
3295           && PUSH_ARGS
3296           && GET_CODE (size) == CONST_INT
3297           && skip == 0
3298           && (MOVE_BY_PIECES_P ((unsigned) INTVAL (size) - used, align))
3299           /* Here we avoid the case of a structure whose weak alignment
3300              forces many pushes of a small amount of data,
3301              and such small pushes do rounding that causes trouble.  */
3302           && ((! SLOW_UNALIGNED_ACCESS (word_mode, align))
3303               || align >= BIGGEST_ALIGNMENT
3304               || (PUSH_ROUNDING (align / BITS_PER_UNIT)
3305                   == (align / BITS_PER_UNIT)))
3306           && PUSH_ROUNDING (INTVAL (size)) == INTVAL (size))
3307         {
3308           /* Push padding now if padding above and stack grows down,
3309              or if padding below and stack grows up.
3310              But if space already allocated, this has already been done.  */
3311           if (extra && args_addr == 0
3312               && where_pad != none && where_pad != stack_direction)
3313             anti_adjust_stack (GEN_INT (extra));
3314
3315           move_by_pieces (NULL, xinner, INTVAL (size) - used, align);
3316         }
3317       else
3318 #endif /* PUSH_ROUNDING  */
3319         {
3320           rtx target;
3321
3322           /* Otherwise make space on the stack and copy the data
3323              to the address of that space.  */
3324
3325           /* Deduct words put into registers from the size we must copy.  */
3326           if (partial != 0)
3327             {
3328               if (GET_CODE (size) == CONST_INT)
3329                 size = GEN_INT (INTVAL (size) - used);
3330               else
3331                 size = expand_binop (GET_MODE (size), sub_optab, size,
3332                                      GEN_INT (used), NULL_RTX, 0,
3333                                      OPTAB_LIB_WIDEN);
3334             }
3335
3336           /* Get the address of the stack space.
3337              In this case, we do not deal with EXTRA separately.
3338              A single stack adjust will do.  */
3339           if (! args_addr)
3340             {
3341               temp = push_block (size, extra, where_pad == downward);
3342               extra = 0;
3343             }
3344           else if (GET_CODE (args_so_far) == CONST_INT)
3345             temp = memory_address (BLKmode,
3346                                    plus_constant (args_addr,
3347                                                   skip + INTVAL (args_so_far)));
3348           else
3349             temp = memory_address (BLKmode,
3350                                    plus_constant (gen_rtx_PLUS (Pmode,
3351                                                                 args_addr,
3352                                                                 args_so_far),
3353                                                   skip));
3354           target = gen_rtx_MEM (BLKmode, temp);
3355
3356           if (type != 0)
3357             {
3358               set_mem_attributes (target, type, 1);
3359               /* Function incoming arguments may overlap with sibling call
3360                  outgoing arguments and we cannot allow reordering of reads
3361                  from function arguments with stores to outgoing arguments
3362                  of sibling calls.  */
3363               set_mem_alias_set (target, 0);
3364             }
3365           else
3366             set_mem_align (target, align);
3367
3368           /* TEMP is the address of the block.  Copy the data there.  */
3369           if (GET_CODE (size) == CONST_INT
3370               && MOVE_BY_PIECES_P ((unsigned) INTVAL (size), align))
3371             {
3372               move_by_pieces (target, xinner, INTVAL (size), align);
3373               goto ret;
3374             }
3375           else
3376             {
3377               rtx opalign = GEN_INT (align / BITS_PER_UNIT);
3378               enum machine_mode mode;
3379
3380               for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT);
3381                    mode != VOIDmode;
3382                    mode = GET_MODE_WIDER_MODE (mode))
3383                 {
3384                   enum insn_code code = movstr_optab[(int) mode];
3385                   insn_operand_predicate_fn pred;
3386
3387                   if (code != CODE_FOR_nothing
3388                       && ((GET_CODE (size) == CONST_INT
3389                            && ((unsigned HOST_WIDE_INT) INTVAL (size)
3390                                <= (GET_MODE_MASK (mode) >> 1)))
3391                           || GET_MODE_BITSIZE (mode) >= BITS_PER_WORD)
3392                       && (!(pred = insn_data[(int) code].operand[0].predicate)
3393                           || ((*pred) (target, BLKmode)))
3394                       && (!(pred = insn_data[(int) code].operand[1].predicate)
3395                           || ((*pred) (xinner, BLKmode)))
3396                       && (!(pred = insn_data[(int) code].operand[3].predicate)
3397                           || ((*pred) (opalign, VOIDmode))))
3398                     {
3399                       rtx op2 = convert_to_mode (mode, size, 1);
3400                       rtx last = get_last_insn ();
3401                       rtx pat;
3402
3403                       pred = insn_data[(int) code].operand[2].predicate;
3404                       if (pred != 0 && ! (*pred) (op2, mode))
3405                         op2 = copy_to_mode_reg (mode, op2);
3406
3407                       pat = GEN_FCN ((int) code) (target, xinner,
3408                                                   op2, opalign);
3409                       if (pat)
3410                         {
3411                           emit_insn (pat);
3412                           goto ret;
3413                         }
3414                       else
3415                         delete_insns_since (last);
3416                     }
3417                 }
3418             }
3419
3420           if (!ACCUMULATE_OUTGOING_ARGS)
3421             {
3422               /* If the source is referenced relative to the stack pointer,
3423                  copy it to another register to stabilize it.  We do not need
3424                  to do this if we know that we won't be changing sp.  */
3425
3426               if (reg_mentioned_p (virtual_stack_dynamic_rtx, temp)
3427                   || reg_mentioned_p (virtual_outgoing_args_rtx, temp))
3428                 temp = copy_to_reg (temp);
3429             }
3430
3431           /* Make inhibit_defer_pop nonzero around the library call
3432              to force it to pop the bcopy-arguments right away.  */
3433           NO_DEFER_POP;
3434 #ifdef TARGET_MEM_FUNCTIONS
3435           emit_library_call (memcpy_libfunc, LCT_NORMAL,
3436                              VOIDmode, 3, temp, Pmode, XEXP (xinner, 0), Pmode,
3437                              convert_to_mode (TYPE_MODE (sizetype),
3438                                               size, TREE_UNSIGNED (sizetype)),
3439                              TYPE_MODE (sizetype));
3440 #else
3441           emit_library_call (bcopy_libfunc, LCT_NORMAL,
3442                              VOIDmode, 3, XEXP (xinner, 0), Pmode, temp, Pmode,
3443                              convert_to_mode (TYPE_MODE (integer_type_node),
3444                                               size,
3445                                               TREE_UNSIGNED (integer_type_node)),
3446                              TYPE_MODE (integer_type_node));
3447 #endif
3448           OK_DEFER_POP;
3449         }
3450     }
3451   else if (partial > 0)
3452     {
3453       /* Scalar partly in registers.  */
3454
3455       int size = GET_MODE_SIZE (mode) / UNITS_PER_WORD;
3456       int i;
3457       int not_stack;
3458       /* # words of start of argument
3459          that we must make space for but need not store.  */
3460       int offset = partial % (PARM_BOUNDARY / BITS_PER_WORD);
3461       int args_offset = INTVAL (args_so_far);
3462       int skip;
3463
3464       /* Push padding now if padding above and stack grows down,
3465          or if padding below and stack grows up.
3466          But if space already allocated, this has already been done.  */
3467       if (extra && args_addr == 0
3468           && where_pad != none && where_pad != stack_direction)
3469         anti_adjust_stack (GEN_INT (extra));
3470
3471       /* If we make space by pushing it, we might as well push
3472          the real data.  Otherwise, we can leave OFFSET nonzero
3473          and leave the space uninitialized.  */
3474       if (args_addr == 0)
3475         offset = 0;
3476
3477       /* Now NOT_STACK gets the number of words that we don't need to
3478          allocate on the stack.  */
3479       not_stack = partial - offset;
3480
3481       /* If the partial register-part of the arg counts in its stack size,
3482          skip the part of stack space corresponding to the registers.
3483          Otherwise, start copying to the beginning of the stack space,
3484          by setting SKIP to 0.  */
3485       skip = (reg_parm_stack_space == 0) ? 0 : not_stack;
3486
3487       if (CONSTANT_P (x) && ! LEGITIMATE_CONSTANT_P (x))
3488         x = validize_mem (force_const_mem (mode, x));
3489
3490       /* If X is a hard register in a non-integer mode, copy it into a pseudo;
3491          SUBREGs of such registers are not allowed.  */
3492       if ((GET_CODE (x) == REG && REGNO (x) < FIRST_PSEUDO_REGISTER
3493            && GET_MODE_CLASS (GET_MODE (x)) != MODE_INT))
3494         x = copy_to_reg (x);
3495
3496       /* Loop over all the words allocated on the stack for this arg.  */
3497       /* We can do it by words, because any scalar bigger than a word
3498          has a size a multiple of a word.  */
3499 #ifndef PUSH_ARGS_REVERSED
3500       for (i = not_stack; i < size; i++)
3501 #else
3502       for (i = size - 1; i >= not_stack; i--)
3503 #endif
3504         if (i >= not_stack + offset)
3505           emit_push_insn (operand_subword_force (x, i, mode),
3506                           word_mode, NULL_TREE, NULL_RTX, align, 0, NULL_RTX,
3507                           0, args_addr,
3508                           GEN_INT (args_offset + ((i - not_stack + skip)
3509                                                   * UNITS_PER_WORD)),
3510                           reg_parm_stack_space, alignment_pad);
3511     }
3512   else
3513     {
3514       rtx addr;
3515       rtx target = NULL_RTX;
3516       rtx dest;
3517
3518       /* Push padding now if padding above and stack grows down,
3519          or if padding below and stack grows up.
3520          But if space already allocated, this has already been done.  */
3521       if (extra && args_addr == 0
3522           && where_pad != none && where_pad != stack_direction)
3523         anti_adjust_stack (GEN_INT (extra));
3524
3525 #ifdef PUSH_ROUNDING
3526       if (args_addr == 0 && PUSH_ARGS)
3527         emit_single_push_insn (mode, x, type);
3528       else
3529 #endif
3530         {
3531           if (GET_CODE (args_so_far) == CONST_INT)
3532             addr
3533               = memory_address (mode,
3534                                 plus_constant (args_addr,
3535                                                INTVAL (args_so_far)));
3536           else
3537             addr = memory_address (mode, gen_rtx_PLUS (Pmode, args_addr,
3538                                                        args_so_far));
3539           target = addr;
3540           dest = gen_rtx_MEM (mode, addr);
3541           if (type != 0)
3542             {
3543               set_mem_attributes (dest, type, 1);
3544               /* Function incoming arguments may overlap with sibling call
3545                  outgoing arguments and we cannot allow reordering of reads
3546                  from function arguments with stores to outgoing arguments
3547                  of sibling calls.  */
3548               set_mem_alias_set (dest, 0);
3549             }
3550
3551           emit_move_insn (dest, x);
3552         }
3553
3554     }
3555
3556  ret:
3557   /* If part should go in registers, copy that part
3558      into the appropriate registers.  Do this now, at the end,
3559      since mem-to-mem copies above may do function calls.  */
3560   if (partial > 0 && reg != 0)
3561     {
3562       /* Handle calls that pass values in multiple non-contiguous locations.
3563          The Irix 6 ABI has examples of this.  */
3564       if (GET_CODE (reg) == PARALLEL)
3565         emit_group_load (reg, x, -1);  /* ??? size? */
3566       else
3567         move_block_to_reg (REGNO (reg), x, partial, mode);
3568     }
3569
3570   if (extra && args_addr == 0 && where_pad == stack_direction)
3571     anti_adjust_stack (GEN_INT (extra));
3572
3573   if (alignment_pad && args_addr == 0)
3574     anti_adjust_stack (alignment_pad);
3575 }
3576 \f
3577 /* Return X if X can be used as a subtarget in a sequence of arithmetic
3578    operations.  */
3579
3580 static rtx
3581 get_subtarget (x)
3582      rtx x;
3583 {
3584   return ((x == 0
3585            /* Only registers can be subtargets.  */
3586            || GET_CODE (x) != REG
3587            /* If the register is readonly, it can't be set more than once.  */
3588            || RTX_UNCHANGING_P (x)
3589            /* Don't use hard regs to avoid extending their life.  */
3590            || REGNO (x) < FIRST_PSEUDO_REGISTER
3591            /* Avoid subtargets inside loops,
3592               since they hide some invariant expressions.  */
3593            || preserve_subexpressions_p ())
3594           ? 0 : x);
3595 }
3596
3597 /* Expand an assignment that stores the value of FROM into TO.
3598    If WANT_VALUE is nonzero, return an rtx for the value of TO.
3599    (This may contain a QUEUED rtx;
3600    if the value is constant, this rtx is a constant.)
3601    Otherwise, the returned value is NULL_RTX.
3602
3603    SUGGEST_REG is no longer actually used.
3604    It used to mean, copy the value through a register
3605    and return that register, if that is possible.
3606    We now use WANT_VALUE to decide whether to do this.  */
3607
3608 rtx
3609 expand_assignment (to, from, want_value, suggest_reg)
3610      tree to, from;
3611      int want_value;
3612      int suggest_reg ATTRIBUTE_UNUSED;
3613 {
3614   rtx to_rtx = 0;
3615   rtx result;
3616
3617   /* Don't crash if the lhs of the assignment was erroneous.  */
3618
3619   if (TREE_CODE (to) == ERROR_MARK)
3620     {
3621       result = expand_expr (from, NULL_RTX, VOIDmode, 0);
3622       return want_value ? result : NULL_RTX;
3623     }
3624
3625   /* Assignment of a structure component needs special treatment
3626      if the structure component's rtx is not simply a MEM.
3627      Assignment of an array element at a constant index, and assignment of
3628      an array element in an unaligned packed structure field, has the same
3629      problem.  */
3630
3631   if (TREE_CODE (to) == COMPONENT_REF || TREE_CODE (to) == BIT_FIELD_REF
3632       || TREE_CODE (to) == ARRAY_REF || TREE_CODE (to) == ARRAY_RANGE_REF)
3633     {
3634       enum machine_mode mode1;
3635       HOST_WIDE_INT bitsize, bitpos;
3636       rtx orig_to_rtx;
3637       tree offset;
3638       int unsignedp;
3639       int volatilep = 0;
3640       tree tem;
3641
3642       push_temp_slots ();
3643       tem = get_inner_reference (to, &bitsize, &bitpos, &offset, &mode1,
3644                                  &unsignedp, &volatilep);
3645
3646       /* If we are going to use store_bit_field and extract_bit_field,
3647          make sure to_rtx will be safe for multiple use.  */
3648
3649       if (mode1 == VOIDmode && want_value)
3650         tem = stabilize_reference (tem);
3651
3652       orig_to_rtx = to_rtx = expand_expr (tem, NULL_RTX, VOIDmode, 0);
3653
3654       if (offset != 0)
3655         {
3656           rtx offset_rtx = expand_expr (offset, NULL_RTX, VOIDmode, 0);
3657
3658           if (GET_CODE (to_rtx) != MEM)
3659             abort ();
3660
3661           if (GET_MODE (offset_rtx) != ptr_mode)
3662             offset_rtx = convert_to_mode (ptr_mode, offset_rtx, 0);
3663
3664 #ifdef POINTERS_EXTEND_UNSIGNED
3665           if (GET_MODE (offset_rtx) != Pmode)
3666             offset_rtx = convert_memory_address (Pmode, offset_rtx);
3667 #endif
3668
3669           /* A constant address in TO_RTX can have VOIDmode, we must not try
3670              to call force_reg for that case.  Avoid that case.  */
3671           if (GET_CODE (to_rtx) == MEM
3672               && GET_MODE (to_rtx) == BLKmode
3673               && GET_MODE (XEXP (to_rtx, 0)) != VOIDmode
3674               && bitsize > 0
3675               && (bitpos % bitsize) == 0
3676               && (bitsize % GET_MODE_ALIGNMENT (mode1)) == 0
3677               && MEM_ALIGN (to_rtx) == GET_MODE_ALIGNMENT (mode1))
3678             {
3679               rtx temp
3680                 = adjust_address (to_rtx, mode1, bitpos / BITS_PER_UNIT);
3681
3682               if (GET_CODE (XEXP (temp, 0)) == REG)
3683                 to_rtx = temp;
3684               else
3685                 to_rtx = (replace_equiv_address
3686                           (to_rtx, force_reg (GET_MODE (XEXP (temp, 0)),
3687                                               XEXP (temp, 0))));
3688               bitpos = 0;
3689             }
3690
3691           to_rtx = offset_address (to_rtx, offset_rtx,
3692                                    highest_pow2_factor (offset));
3693         }
3694
3695       if (GET_CODE (to_rtx) == MEM)
3696         {
3697           tree old_expr = MEM_EXPR (to_rtx);
3698
3699           /* If the field is at offset zero, we could have been given the
3700              DECL_RTX of the parent struct.  Don't munge it.  */
3701           to_rtx = shallow_copy_rtx (to_rtx);
3702
3703           set_mem_attributes (to_rtx, to, 0);
3704
3705           /* If we changed MEM_EXPR, that means we're now referencing
3706              the COMPONENT_REF, which means that MEM_OFFSET must be
3707              relative to that field.  But we've not yet reflected BITPOS
3708              in TO_RTX.  This will be done in store_field.  Adjust for
3709              that by biasing MEM_OFFSET by -bitpos.  */
3710           if (MEM_EXPR (to_rtx) != old_expr && MEM_OFFSET (to_rtx)
3711               && (bitpos / BITS_PER_UNIT) != 0)
3712             set_mem_offset (to_rtx, GEN_INT (INTVAL (MEM_OFFSET (to_rtx))
3713                                              - (bitpos / BITS_PER_UNIT)));
3714         }
3715
3716       /* Deal with volatile and readonly fields.  The former is only done
3717          for MEM.  Also set MEM_KEEP_ALIAS_SET_P if needed.  */
3718       if (volatilep && GET_CODE (to_rtx) == MEM)
3719         {
3720           if (to_rtx == orig_to_rtx)
3721             to_rtx = copy_rtx (to_rtx);
3722           MEM_VOLATILE_P (to_rtx) = 1;
3723         }
3724
3725       if (TREE_CODE (to) == COMPONENT_REF
3726           && TREE_READONLY (TREE_OPERAND (to, 1)))
3727         {
3728           if (to_rtx == orig_to_rtx)
3729             to_rtx = copy_rtx (to_rtx);
3730           RTX_UNCHANGING_P (to_rtx) = 1;
3731         }
3732
3733       if (! can_address_p (to))
3734         {
3735           if (to_rtx == orig_to_rtx)
3736             to_rtx = copy_rtx (to_rtx);
3737           MEM_KEEP_ALIAS_SET_P (to_rtx) = 1;
3738         }
3739
3740       result = store_field (to_rtx, bitsize, bitpos, mode1, from,
3741                             (want_value
3742                              /* Spurious cast for HPUX compiler.  */
3743                              ? ((enum machine_mode)
3744                                 TYPE_MODE (TREE_TYPE (to)))
3745                              : VOIDmode),
3746                             unsignedp, TREE_TYPE (tem), get_alias_set (to));
3747
3748       preserve_temp_slots (result);
3749       free_temp_slots ();
3750       pop_temp_slots ();
3751
3752       /* If the value is meaningful, convert RESULT to the proper mode.
3753          Otherwise, return nothing.  */
3754       return (want_value ? convert_modes (TYPE_MODE (TREE_TYPE (to)),
3755                                           TYPE_MODE (TREE_TYPE (from)),
3756                                           result,
3757                                           TREE_UNSIGNED (TREE_TYPE (to)))
3758               : NULL_RTX);
3759     }
3760
3761   /* If the rhs is a function call and its value is not an aggregate,
3762      call the function before we start to compute the lhs.
3763      This is needed for correct code for cases such as
3764      val = setjmp (buf) on machines where reference to val
3765      requires loading up part of an address in a separate insn.
3766
3767      Don't do this if TO is a VAR_DECL or PARM_DECL whose DECL_RTL is REG
3768      since it might be a promoted variable where the zero- or sign- extension
3769      needs to be done.  Handling this in the normal way is safe because no
3770      computation is done before the call.  */
3771   if (TREE_CODE (from) == CALL_EXPR && ! aggregate_value_p (from)
3772       && TREE_CODE (TYPE_SIZE (TREE_TYPE (from))) == INTEGER_CST
3773       && ! ((TREE_CODE (to) == VAR_DECL || TREE_CODE (to) == PARM_DECL)
3774             && GET_CODE (DECL_RTL (to)) == REG))
3775     {
3776       rtx value;
3777
3778       push_temp_slots ();
3779       value = expand_expr (from, NULL_RTX, VOIDmode, 0);
3780       if (to_rtx == 0)
3781         to_rtx = expand_expr (to, NULL_RTX, VOIDmode, EXPAND_WRITE);
3782
3783       /* Handle calls that return values in multiple non-contiguous locations.
3784          The Irix 6 ABI has examples of this.  */
3785       if (GET_CODE (to_rtx) == PARALLEL)
3786         emit_group_load (to_rtx, value, int_size_in_bytes (TREE_TYPE (from)));
3787       else if (GET_MODE (to_rtx) == BLKmode)
3788         emit_block_move (to_rtx, value, expr_size (from));
3789       else
3790         {
3791 #ifdef POINTERS_EXTEND_UNSIGNED
3792           if (POINTER_TYPE_P (TREE_TYPE (to))
3793               && GET_MODE (to_rtx) != GET_MODE (value))
3794             value = convert_memory_address (GET_MODE (to_rtx), value);
3795 #endif
3796           emit_move_insn (to_rtx, value);
3797         }
3798       preserve_temp_slots (to_rtx);
3799       free_temp_slots ();
3800       pop_temp_slots ();
3801       return want_value ? to_rtx : NULL_RTX;
3802     }
3803
3804   /* Ordinary treatment.  Expand TO to get a REG or MEM rtx.
3805      Don't re-expand if it was expanded already (in COMPONENT_REF case).  */
3806
3807   if (to_rtx == 0)
3808     to_rtx = expand_expr (to, NULL_RTX, VOIDmode, EXPAND_WRITE);
3809
3810   /* Don't move directly into a return register.  */
3811   if (TREE_CODE (to) == RESULT_DECL
3812       && (GET_CODE (to_rtx) == REG || GET_CODE (to_rtx) == PARALLEL))
3813     {
3814       rtx temp;
3815
3816       push_temp_slots ();
3817       temp = expand_expr (from, 0, GET_MODE (to_rtx), 0);
3818
3819       if (GET_CODE (to_rtx) == PARALLEL)
3820         emit_group_load (to_rtx, temp, int_size_in_bytes (TREE_TYPE (from)));
3821       else
3822         emit_move_insn (to_rtx, temp);
3823
3824       preserve_temp_slots (to_rtx);
3825       free_temp_slots ();
3826       pop_temp_slots ();
3827       return want_value ? to_rtx : NULL_RTX;
3828     }
3829
3830   /* In case we are returning the contents of an object which overlaps
3831      the place the value is being stored, use a safe function when copying
3832      a value through a pointer into a structure value return block.  */
3833   if (TREE_CODE (to) == RESULT_DECL && TREE_CODE (from) == INDIRECT_REF
3834       && current_function_returns_struct
3835       && !current_function_returns_pcc_struct)
3836     {
3837       rtx from_rtx, size;
3838
3839       push_temp_slots ();
3840       size = expr_size (from);
3841       from_rtx = expand_expr (from, NULL_RTX, VOIDmode, 0);
3842
3843 #ifdef TARGET_MEM_FUNCTIONS
3844       emit_library_call (memmove_libfunc, LCT_NORMAL,
3845                          VOIDmode, 3, XEXP (to_rtx, 0), Pmode,
3846                          XEXP (from_rtx, 0), Pmode,
3847                          convert_to_mode (TYPE_MODE (sizetype),
3848                                           size, TREE_UNSIGNED (sizetype)),
3849                          TYPE_MODE (sizetype));
3850 #else
3851       emit_library_call (bcopy_libfunc, LCT_NORMAL,
3852                          VOIDmode, 3, XEXP (from_rtx, 0), Pmode,
3853                          XEXP (to_rtx, 0), Pmode,
3854                          convert_to_mode (TYPE_MODE (integer_type_node),
3855                                           size, TREE_UNSIGNED (integer_type_node)),
3856                          TYPE_MODE (integer_type_node));
3857 #endif
3858
3859       preserve_temp_slots (to_rtx);
3860       free_temp_slots ();
3861       pop_temp_slots ();
3862       return want_value ? to_rtx : NULL_RTX;
3863     }
3864
3865   /* Compute FROM and store the value in the rtx we got.  */
3866
3867   push_temp_slots ();
3868   result = store_expr (from, to_rtx, want_value);
3869   preserve_temp_slots (result);
3870   free_temp_slots ();
3871   pop_temp_slots ();
3872   return want_value ? result : NULL_RTX;
3873 }
3874
3875 /* Generate code for computing expression EXP,
3876    and storing the value into TARGET.
3877    TARGET may contain a QUEUED rtx.
3878
3879    If WANT_VALUE is nonzero, return a copy of the value
3880    not in TARGET, so that we can be sure to use the proper
3881    value in a containing expression even if TARGET has something
3882    else stored in it.  If possible, we copy the value through a pseudo
3883    and return that pseudo.  Or, if the value is constant, we try to
3884    return the constant.  In some cases, we return a pseudo
3885    copied *from* TARGET.
3886
3887    If the mode is BLKmode then we may return TARGET itself.
3888    It turns out that in BLKmode it doesn't cause a problem.
3889    because C has no operators that could combine two different
3890    assignments into the same BLKmode object with different values
3891    with no sequence point.  Will other languages need this to
3892    be more thorough?
3893
3894    If WANT_VALUE is 0, we return NULL, to make sure
3895    to catch quickly any cases where the caller uses the value
3896    and fails to set WANT_VALUE.  */
3897
3898 rtx
3899 store_expr (exp, target, want_value)
3900      tree exp;
3901      rtx target;
3902      int want_value;
3903 {
3904   rtx temp;
3905   int dont_return_target = 0;
3906   int dont_store_target = 0;
3907
3908   if (TREE_CODE (exp) == COMPOUND_EXPR)
3909     {
3910       /* Perform first part of compound expression, then assign from second
3911          part.  */
3912       expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode, 0);
3913       emit_queue ();
3914       return store_expr (TREE_OPERAND (exp, 1), target, want_value);
3915     }
3916   else if (TREE_CODE (exp) == COND_EXPR && GET_MODE (target) == BLKmode)
3917     {
3918       /* For conditional expression, get safe form of the target.  Then
3919          test the condition, doing the appropriate assignment on either
3920          side.  This avoids the creation of unnecessary temporaries.
3921          For non-BLKmode, it is more efficient not to do this.  */
3922
3923       rtx lab1 = gen_label_rtx (), lab2 = gen_label_rtx ();
3924
3925       emit_queue ();
3926       target = protect_from_queue (target, 1);
3927
3928       do_pending_stack_adjust ();
3929       NO_DEFER_POP;
3930       jumpifnot (TREE_OPERAND (exp, 0), lab1);
3931       start_cleanup_deferral ();
3932       store_expr (TREE_OPERAND (exp, 1), target, 0);
3933       end_cleanup_deferral ();
3934       emit_queue ();
3935       emit_jump_insn (gen_jump (lab2));
3936       emit_barrier ();
3937       emit_label (lab1);
3938       start_cleanup_deferral ();
3939       store_expr (TREE_OPERAND (exp, 2), target, 0);
3940       end_cleanup_deferral ();
3941       emit_queue ();
3942       emit_label (lab2);
3943       OK_DEFER_POP;
3944
3945       return want_value ? target : NULL_RTX;
3946     }
3947   else if (queued_subexp_p (target))
3948     /* If target contains a postincrement, let's not risk
3949        using it as the place to generate the rhs.  */
3950     {
3951       if (GET_MODE (target) != BLKmode && GET_MODE (target) != VOIDmode)
3952         {
3953           /* Expand EXP into a new pseudo.  */
3954           temp = gen_reg_rtx (GET_MODE (target));
3955           temp = expand_expr (exp, temp, GET_MODE (target), 0);
3956         }
3957       else
3958         temp = expand_expr (exp, NULL_RTX, GET_MODE (target), 0);
3959
3960       /* If target is volatile, ANSI requires accessing the value
3961          *from* the target, if it is accessed.  So make that happen.
3962          In no case return the target itself.  */
3963       if (! MEM_VOLATILE_P (target) && want_value)
3964         dont_return_target = 1;
3965     }
3966   else if (want_value && GET_CODE (target) == MEM && ! MEM_VOLATILE_P (target)
3967            && GET_MODE (target) != BLKmode)
3968     /* If target is in memory and caller wants value in a register instead,
3969        arrange that.  Pass TARGET as target for expand_expr so that,
3970        if EXP is another assignment, WANT_VALUE will be nonzero for it.
3971        We know expand_expr will not use the target in that case.
3972        Don't do this if TARGET is volatile because we are supposed
3973        to write it and then read it.  */
3974     {
3975       temp = expand_expr (exp, target, GET_MODE (target), 0);
3976       if (GET_MODE (temp) != BLKmode && GET_MODE (temp) != VOIDmode)
3977         {
3978           /* If TEMP is already in the desired TARGET, only copy it from
3979              memory and don't store it there again.  */
3980           if (temp == target
3981               || (rtx_equal_p (temp, target)
3982                   && ! side_effects_p (temp) && ! side_effects_p (target)))
3983             dont_store_target = 1;
3984           temp = copy_to_reg (temp);
3985         }
3986       dont_return_target = 1;
3987     }
3988   else if (GET_CODE (target) == SUBREG && SUBREG_PROMOTED_VAR_P (target))
3989     /* If this is an scalar in a register that is stored in a wider mode
3990        than the declared mode, compute the result into its declared mode
3991        and then convert to the wider mode.  Our value is the computed
3992        expression.  */
3993     {
3994       /* If we don't want a value, we can do the conversion inside EXP,
3995          which will often result in some optimizations.  Do the conversion
3996          in two steps: first change the signedness, if needed, then
3997          the extend.  But don't do this if the type of EXP is a subtype
3998          of something else since then the conversion might involve
3999          more than just converting modes.  */
4000       if (! want_value && INTEGRAL_TYPE_P (TREE_TYPE (exp))
4001           && TREE_TYPE (TREE_TYPE (exp)) == 0)
4002         {
4003           if (TREE_UNSIGNED (TREE_TYPE (exp))
4004               != SUBREG_PROMOTED_UNSIGNED_P (target))
4005             exp
4006               = convert
4007                 (signed_or_unsigned_type (SUBREG_PROMOTED_UNSIGNED_P (target),
4008                                           TREE_TYPE (exp)),
4009                  exp);
4010
4011           exp = convert (type_for_mode (GET_MODE (SUBREG_REG (target)),
4012                                         SUBREG_PROMOTED_UNSIGNED_P (target)),
4013                          exp);
4014         }
4015
4016       temp = expand_expr (exp, NULL_RTX, VOIDmode, 0);
4017
4018       /* If TEMP is a volatile MEM and we want a result value, make
4019          the access now so it gets done only once.  Likewise if
4020          it contains TARGET.  */
4021       if (GET_CODE (temp) == MEM && want_value
4022           && (MEM_VOLATILE_P (temp)
4023               || reg_mentioned_p (SUBREG_REG (target), XEXP (temp, 0))))
4024         temp = copy_to_reg (temp);
4025
4026       /* If TEMP is a VOIDmode constant, use convert_modes to make
4027          sure that we properly convert it.  */
4028       if (CONSTANT_P (temp) && GET_MODE (temp) == VOIDmode)
4029         {
4030           temp = convert_modes (GET_MODE (target), TYPE_MODE (TREE_TYPE (exp)),
4031                                 temp, SUBREG_PROMOTED_UNSIGNED_P (target));
4032           temp = convert_modes (GET_MODE (SUBREG_REG (target)),
4033                                 GET_MODE (target), temp,
4034                                 SUBREG_PROMOTED_UNSIGNED_P (target));
4035         }
4036
4037       convert_move (SUBREG_REG (target), temp,
4038                     SUBREG_PROMOTED_UNSIGNED_P (target));
4039
4040       /* If we promoted a constant, change the mode back down to match
4041          target.  Otherwise, the caller might get confused by a result whose
4042          mode is larger than expected.  */
4043
4044       if (want_value && GET_MODE (temp) != GET_MODE (target))
4045         {
4046           if (GET_MODE (temp) != VOIDmode)
4047             {
4048               temp = gen_lowpart_SUBREG (GET_MODE (target), temp);
4049               SUBREG_PROMOTED_VAR_P (temp) = 1;
4050               SUBREG_PROMOTED_UNSIGNED_P (temp)
4051                 = SUBREG_PROMOTED_UNSIGNED_P (target);
4052             }
4053           else
4054             temp = convert_modes (GET_MODE (target),
4055                                   GET_MODE (SUBREG_REG (target)),
4056                                   temp, SUBREG_PROMOTED_UNSIGNED_P (target));
4057         }
4058
4059       return want_value ? temp : NULL_RTX;
4060     }
4061   else
4062     {
4063       temp = expand_expr (exp, target, GET_MODE (target), 0);
4064       /* Return TARGET if it's a specified hardware register.
4065          If TARGET is a volatile mem ref, either return TARGET
4066          or return a reg copied *from* TARGET; ANSI requires this.
4067
4068          Otherwise, if TEMP is not TARGET, return TEMP
4069          if it is constant (for efficiency),
4070          or if we really want the correct value.  */
4071       if (!(target && GET_CODE (target) == REG
4072             && REGNO (target) < FIRST_PSEUDO_REGISTER)
4073           && !(GET_CODE (target) == MEM && MEM_VOLATILE_P (target))
4074           && ! rtx_equal_p (temp, target)
4075           && (CONSTANT_P (temp) || want_value))
4076         dont_return_target = 1;
4077     }
4078
4079   /* If TEMP is a VOIDmode constant and the mode of the type of EXP is not
4080      the same as that of TARGET, adjust the constant.  This is needed, for
4081      example, in case it is a CONST_DOUBLE and we want only a word-sized
4082      value.  */
4083   if (CONSTANT_P (temp) && GET_MODE (temp) == VOIDmode
4084       && TREE_CODE (exp) != ERROR_MARK
4085       && GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp)))
4086     temp = convert_modes (GET_MODE (target), TYPE_MODE (TREE_TYPE (exp)),
4087                           temp, TREE_UNSIGNED (TREE_TYPE (exp)));
4088
4089   /* If value was not generated in the target, store it there.
4090      Convert the value to TARGET's type first if necessary.
4091      If TEMP and TARGET compare equal according to rtx_equal_p, but
4092      one or both of them are volatile memory refs, we have to distinguish
4093      two cases:
4094      - expand_expr has used TARGET.  In this case, we must not generate
4095        another copy.  This can be detected by TARGET being equal according
4096        to == .
4097      - expand_expr has not used TARGET - that means that the source just
4098        happens to have the same RTX form.  Since temp will have been created
4099        by expand_expr, it will compare unequal according to == .
4100        We must generate a copy in this case, to reach the correct number
4101        of volatile memory references.  */
4102
4103   if ((! rtx_equal_p (temp, target)
4104        || (temp != target && (side_effects_p (temp)
4105                               || side_effects_p (target))))
4106       && TREE_CODE (exp) != ERROR_MARK
4107       && ! dont_store_target)
4108     {
4109       target = protect_from_queue (target, 1);
4110       if (GET_MODE (temp) != GET_MODE (target)
4111           && GET_MODE (temp) != VOIDmode)
4112         {
4113           int unsignedp = TREE_UNSIGNED (TREE_TYPE (exp));
4114           if (dont_return_target)
4115             {
4116               /* In this case, we will return TEMP,
4117                  so make sure it has the proper mode.
4118                  But don't forget to store the value into TARGET.  */
4119               temp = convert_to_mode (GET_MODE (target), temp, unsignedp);
4120               emit_move_insn (target, temp);
4121             }
4122           else
4123             convert_move (target, temp, unsignedp);
4124         }
4125
4126       else if (GET_MODE (temp) == BLKmode && TREE_CODE (exp) == STRING_CST)
4127         {
4128           /* Handle copying a string constant into an array.  The string
4129              constant may be shorter than the array.  So copy just the string's
4130              actual length, and clear the rest.  First get the size of the data
4131              type of the string, which is actually the size of the target.  */
4132           rtx size = expr_size (exp);
4133
4134           if (GET_CODE (size) == CONST_INT
4135               && INTVAL (size) < TREE_STRING_LENGTH (exp))
4136             emit_block_move (target, temp, size);
4137           else
4138             {
4139               /* Compute the size of the data to copy from the string.  */
4140               tree copy_size
4141                 = size_binop (MIN_EXPR,
4142                               make_tree (sizetype, size),
4143                               size_int (TREE_STRING_LENGTH (exp)));
4144               rtx copy_size_rtx = expand_expr (copy_size, NULL_RTX,
4145                                                VOIDmode, 0);
4146               rtx label = 0;
4147
4148               /* Copy that much.  */
4149               copy_size_rtx = convert_to_mode (ptr_mode, copy_size_rtx, 0);
4150               emit_block_move (target, temp, copy_size_rtx);
4151
4152               /* Figure out how much is left in TARGET that we have to clear.
4153                  Do all calculations in ptr_mode.  */
4154               if (GET_CODE (copy_size_rtx) == CONST_INT)
4155                 {
4156                   size = plus_constant (size, -INTVAL (copy_size_rtx));
4157                   target = adjust_address (target, BLKmode,
4158                                            INTVAL (copy_size_rtx));
4159                 }
4160               else
4161                 {
4162                   size = expand_binop (ptr_mode, sub_optab, size,
4163                                        copy_size_rtx, NULL_RTX, 0,
4164                                        OPTAB_LIB_WIDEN);
4165
4166 #ifdef POINTERS_EXTEND_UNSIGNED
4167                   if (GET_MODE (copy_size_rtx) != Pmode)
4168                     copy_size_rtx = convert_memory_address (Pmode,
4169                                                             copy_size_rtx);
4170 #endif
4171
4172                   target = offset_address (target, copy_size_rtx,
4173                                            highest_pow2_factor (copy_size));
4174                   label = gen_label_rtx ();
4175                   emit_cmp_and_jump_insns (size, const0_rtx, LT, NULL_RTX,
4176                                            GET_MODE (size), 0, label);
4177                 }
4178
4179               if (size != const0_rtx)
4180                 clear_storage (target, size);
4181
4182               if (label)
4183                 emit_label (label);
4184             }
4185         }
4186       /* Handle calls that return values in multiple non-contiguous locations.
4187          The Irix 6 ABI has examples of this.  */
4188       else if (GET_CODE (target) == PARALLEL)
4189         emit_group_load (target, temp, int_size_in_bytes (TREE_TYPE (exp)));
4190       else if (GET_MODE (temp) == BLKmode)
4191         emit_block_move (target, temp, expr_size (exp));
4192       else
4193         emit_move_insn (target, temp);
4194     }
4195
4196   /* If we don't want a value, return NULL_RTX.  */
4197   if (! want_value)
4198     return NULL_RTX;
4199
4200   /* If we are supposed to return TEMP, do so as long as it isn't a MEM.
4201      ??? The latter test doesn't seem to make sense.  */
4202   else if (dont_return_target && GET_CODE (temp) != MEM)
4203     return temp;
4204
4205   /* Return TARGET itself if it is a hard register.  */
4206   else if (want_value && GET_MODE (target) != BLKmode
4207            && ! (GET_CODE (target) == REG
4208                  && REGNO (target) < FIRST_PSEUDO_REGISTER))
4209     return copy_to_reg (target);
4210
4211   else
4212     return target;
4213 }
4214 \f
4215 /* Return 1 if EXP just contains zeros.  */
4216
4217 static int
4218 is_zeros_p (exp)
4219      tree exp;
4220 {
4221   tree elt;
4222
4223   switch (TREE_CODE (exp))
4224     {
4225     case CONVERT_EXPR:
4226     case NOP_EXPR:
4227     case NON_LVALUE_EXPR:
4228     case VIEW_CONVERT_EXPR:
4229       return is_zeros_p (TREE_OPERAND (exp, 0));
4230
4231     case INTEGER_CST:
4232       return integer_zerop (exp);
4233
4234     case COMPLEX_CST:
4235       return
4236         is_zeros_p (TREE_REALPART (exp)) && is_zeros_p (TREE_IMAGPART (exp));
4237
4238     case REAL_CST:
4239       return REAL_VALUES_IDENTICAL (TREE_REAL_CST (exp), dconst0);
4240
4241     case CONSTRUCTOR:
4242       if (TREE_TYPE (exp) && TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
4243         return CONSTRUCTOR_ELTS (exp) == NULL_TREE;
4244       for (elt = CONSTRUCTOR_ELTS (exp); elt; elt = TREE_CHAIN (elt))
4245         if (! is_zeros_p (TREE_VALUE (elt)))
4246           return 0;
4247
4248       return 1;
4249
4250     default:
4251       return 0;
4252     }
4253 }
4254
4255 /* Return 1 if EXP contains mostly (3/4)  zeros.  */
4256
4257 static int
4258 mostly_zeros_p (exp)
4259      tree exp;
4260 {
4261   if (TREE_CODE (exp) == CONSTRUCTOR)
4262     {
4263       int elts = 0, zeros = 0;
4264       tree elt = CONSTRUCTOR_ELTS (exp);
4265       if (TREE_TYPE (exp) && TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
4266         {
4267           /* If there are no ranges of true bits, it is all zero.  */
4268           return elt == NULL_TREE;
4269         }
4270       for (; elt; elt = TREE_CHAIN (elt))
4271         {
4272           /* We do not handle the case where the index is a RANGE_EXPR,
4273              so the statistic will be somewhat inaccurate.
4274              We do make a more accurate count in store_constructor itself,
4275              so since this function is only used for nested array elements,
4276              this should be close enough.  */
4277           if (mostly_zeros_p (TREE_VALUE (elt)))
4278             zeros++;
4279           elts++;
4280         }
4281
4282       return 4 * zeros >= 3 * elts;
4283     }
4284
4285   return is_zeros_p (exp);
4286 }
4287 \f
4288 /* Helper function for store_constructor.
4289    TARGET, BITSIZE, BITPOS, MODE, EXP are as for store_field.
4290    TYPE is the type of the CONSTRUCTOR, not the element type.
4291    CLEARED is as for store_constructor.
4292    ALIAS_SET is the alias set to use for any stores.
4293
4294    This provides a recursive shortcut back to store_constructor when it isn't
4295    necessary to go through store_field.  This is so that we can pass through
4296    the cleared field to let store_constructor know that we may not have to
4297    clear a substructure if the outer structure has already been cleared.  */
4298
4299 static void
4300 store_constructor_field (target, bitsize, bitpos, mode, exp, type, cleared,
4301                          alias_set)
4302      rtx target;
4303      unsigned HOST_WIDE_INT bitsize;
4304      HOST_WIDE_INT bitpos;
4305      enum machine_mode mode;
4306      tree exp, type;
4307      int cleared;
4308      int alias_set;
4309 {
4310   if (TREE_CODE (exp) == CONSTRUCTOR
4311       && bitpos % BITS_PER_UNIT == 0
4312       /* If we have a non-zero bitpos for a register target, then we just
4313          let store_field do the bitfield handling.  This is unlikely to
4314          generate unnecessary clear instructions anyways.  */
4315       && (bitpos == 0 || GET_CODE (target) == MEM))
4316     {
4317       if (GET_CODE (target) == MEM)
4318         target
4319           = adjust_address (target,
4320                             GET_MODE (target) == BLKmode
4321                             || 0 != (bitpos
4322                                      % GET_MODE_ALIGNMENT (GET_MODE (target)))
4323                             ? BLKmode : VOIDmode, bitpos / BITS_PER_UNIT);
4324
4325
4326       /* Update the alias set, if required.  */
4327       if (GET_CODE (target) == MEM && ! MEM_KEEP_ALIAS_SET_P (target)
4328           && MEM_ALIAS_SET (target) != 0)
4329         {
4330           target = copy_rtx (target);
4331           set_mem_alias_set (target, alias_set);
4332         }
4333
4334       store_constructor (exp, target, cleared, bitsize / BITS_PER_UNIT);
4335     }
4336   else
4337     store_field (target, bitsize, bitpos, mode, exp, VOIDmode, 0, type,
4338                  alias_set);
4339 }
4340
4341 /* Store the value of constructor EXP into the rtx TARGET.
4342    TARGET is either a REG or a MEM; we know it cannot conflict, since
4343    safe_from_p has been called.
4344    CLEARED is true if TARGET is known to have been zero'd.
4345    SIZE is the number of bytes of TARGET we are allowed to modify: this
4346    may not be the same as the size of EXP if we are assigning to a field
4347    which has been packed to exclude padding bits.  */
4348
4349 static void
4350 store_constructor (exp, target, cleared, size)
4351      tree exp;
4352      rtx target;
4353      int cleared;
4354      HOST_WIDE_INT size;
4355 {
4356   tree type = TREE_TYPE (exp);
4357 #ifdef WORD_REGISTER_OPERATIONS
4358   HOST_WIDE_INT exp_size = int_size_in_bytes (type);
4359 #endif
4360
4361   if (TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
4362       || TREE_CODE (type) == QUAL_UNION_TYPE)
4363     {
4364       tree elt;
4365
4366       /* We either clear the aggregate or indicate the value is dead.  */
4367       if ((TREE_CODE (type) == UNION_TYPE
4368            || TREE_CODE (type) == QUAL_UNION_TYPE)
4369           && ! cleared
4370           && ! CONSTRUCTOR_ELTS (exp))
4371         /* If the constructor is empty, clear the union.  */
4372         {
4373           clear_storage (target, expr_size (exp));
4374           cleared = 1;
4375         }
4376
4377       /* If we are building a static constructor into a register,
4378          set the initial value as zero so we can fold the value into
4379          a constant.  But if more than one register is involved,
4380          this probably loses.  */
4381       else if (! cleared && GET_CODE (target) == REG && TREE_STATIC (exp)
4382                && GET_MODE_SIZE (GET_MODE (target)) <= UNITS_PER_WORD)
4383         {
4384           emit_move_insn (target, CONST0_RTX (GET_MODE (target)));
4385           cleared = 1;
4386         }
4387
4388       /* If the constructor has fewer fields than the structure
4389          or if we are initializing the structure to mostly zeros,
4390          clear the whole structure first.  Don't do this if TARGET is a
4391          register whose mode size isn't equal to SIZE since clear_storage
4392          can't handle this case.  */
4393       else if (! cleared && size > 0
4394                && ((list_length (CONSTRUCTOR_ELTS (exp))
4395                     != fields_length (type))
4396                    || mostly_zeros_p (exp))
4397                && (GET_CODE (target) != REG
4398                    || ((HOST_WIDE_INT) GET_MODE_SIZE (GET_MODE (target))
4399                        == size)))
4400         {
4401           clear_storage (target, GEN_INT (size));
4402           cleared = 1;
4403         }
4404
4405       if (! cleared)
4406         emit_insn (gen_rtx_CLOBBER (VOIDmode, target));
4407
4408       /* Store each element of the constructor into
4409          the corresponding field of TARGET.  */
4410
4411       for (elt = CONSTRUCTOR_ELTS (exp); elt; elt = TREE_CHAIN (elt))
4412         {
4413           tree field = TREE_PURPOSE (elt);
4414           tree value = TREE_VALUE (elt);
4415           enum machine_mode mode;
4416           HOST_WIDE_INT bitsize;
4417           HOST_WIDE_INT bitpos = 0;
4418           int unsignedp;
4419           tree offset;
4420           rtx to_rtx = target;
4421
4422           /* Just ignore missing fields.
4423              We cleared the whole structure, above,
4424              if any fields are missing.  */
4425           if (field == 0)
4426             continue;
4427
4428           if (cleared && is_zeros_p (value))
4429             continue;
4430
4431           if (host_integerp (DECL_SIZE (field), 1))
4432             bitsize = tree_low_cst (DECL_SIZE (field), 1);
4433           else
4434             bitsize = -1;
4435
4436           unsignedp = TREE_UNSIGNED (field);
4437           mode = DECL_MODE (field);
4438           if (DECL_BIT_FIELD (field))
4439             mode = VOIDmode;
4440
4441           offset = DECL_FIELD_OFFSET (field);
4442           if (host_integerp (offset, 0)
4443               && host_integerp (bit_position (field), 0))
4444             {
4445               bitpos = int_bit_position (field);
4446               offset = 0;
4447             }
4448           else
4449             bitpos = tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 0);
4450
4451           if (offset)
4452             {
4453               rtx offset_rtx;
4454
4455               if (contains_placeholder_p (offset))
4456                 offset = build (WITH_RECORD_EXPR, sizetype,
4457                                 offset, make_tree (TREE_TYPE (exp), target));
4458
4459               offset_rtx = expand_expr (offset, NULL_RTX, VOIDmode, 0);
4460               if (GET_CODE (to_rtx) != MEM)
4461                 abort ();
4462
4463               if (GET_MODE (offset_rtx) != ptr_mode)
4464                 offset_rtx = convert_to_mode (ptr_mode, offset_rtx, 0);
4465
4466 #ifdef POINTERS_EXTEND_UNSIGNED
4467               if (GET_MODE (offset_rtx) != Pmode)
4468                 offset_rtx = convert_memory_address (Pmode, offset_rtx);
4469 #endif
4470
4471               to_rtx = offset_address (to_rtx, offset_rtx,
4472                                        highest_pow2_factor (offset));
4473             }
4474
4475           if (TREE_READONLY (field))
4476             {
4477               if (GET_CODE (to_rtx) == MEM)
4478                 to_rtx = copy_rtx (to_rtx);
4479
4480               RTX_UNCHANGING_P (to_rtx) = 1;
4481             }
4482
4483 #ifdef WORD_REGISTER_OPERATIONS
4484           /* If this initializes a field that is smaller than a word, at the
4485              start of a word, try to widen it to a full word.
4486              This special case allows us to output C++ member function
4487              initializations in a form that the optimizers can understand.  */
4488           if (GET_CODE (target) == REG
4489               && bitsize < BITS_PER_WORD
4490               && bitpos % BITS_PER_WORD == 0
4491               && GET_MODE_CLASS (mode) == MODE_INT
4492               && TREE_CODE (value) == INTEGER_CST
4493               && exp_size >= 0
4494               && bitpos + BITS_PER_WORD <= exp_size * BITS_PER_UNIT)
4495             {
4496               tree type = TREE_TYPE (value);
4497
4498               if (TYPE_PRECISION (type) < BITS_PER_WORD)
4499                 {
4500                   type = type_for_size (BITS_PER_WORD, TREE_UNSIGNED (type));
4501                   value = convert (type, value);
4502                 }
4503
4504               if (BYTES_BIG_ENDIAN)
4505                 value
4506                   = fold (build (LSHIFT_EXPR, type, value,
4507                                  build_int_2 (BITS_PER_WORD - bitsize, 0)));
4508               bitsize = BITS_PER_WORD;
4509               mode = word_mode;
4510             }
4511 #endif
4512
4513           if (GET_CODE (to_rtx) == MEM && !MEM_KEEP_ALIAS_SET_P (to_rtx)
4514               && DECL_NONADDRESSABLE_P (field))
4515             {
4516               to_rtx = copy_rtx (to_rtx);
4517               MEM_KEEP_ALIAS_SET_P (to_rtx) = 1;
4518             }
4519
4520           store_constructor_field (to_rtx, bitsize, bitpos, mode,
4521                                    value, type, cleared,
4522                                    get_alias_set (TREE_TYPE (field)));
4523         }
4524     }
4525   else if (TREE_CODE (type) == ARRAY_TYPE)
4526     {
4527       tree elt;
4528       int i;
4529       int need_to_clear;
4530       tree domain = TYPE_DOMAIN (type);
4531       tree elttype = TREE_TYPE (type);
4532       int const_bounds_p = (TYPE_MIN_VALUE (domain)
4533                             && TYPE_MAX_VALUE (domain)
4534                             && host_integerp (TYPE_MIN_VALUE (domain), 0)
4535                             && host_integerp (TYPE_MAX_VALUE (domain), 0));
4536       HOST_WIDE_INT minelt = 0;
4537       HOST_WIDE_INT maxelt = 0;
4538
4539       /* If we have constant bounds for the range of the type, get them.  */
4540       if (const_bounds_p)
4541         {
4542           minelt = tree_low_cst (TYPE_MIN_VALUE (domain), 0);
4543           maxelt = tree_low_cst (TYPE_MAX_VALUE (domain), 0);
4544         }
4545
4546       /* If the constructor has fewer elements than the array,
4547          clear the whole array first.  Similarly if this is
4548          static constructor of a non-BLKmode object.  */
4549       if (cleared || (GET_CODE (target) == REG && TREE_STATIC (exp)))
4550         need_to_clear = 1;
4551       else
4552         {
4553           HOST_WIDE_INT count = 0, zero_count = 0;
4554           need_to_clear = ! const_bounds_p;
4555
4556           /* This loop is a more accurate version of the loop in
4557              mostly_zeros_p (it handles RANGE_EXPR in an index).
4558              It is also needed to check for missing elements.  */
4559           for (elt = CONSTRUCTOR_ELTS (exp);
4560                elt != NULL_TREE && ! need_to_clear;
4561                elt = TREE_CHAIN (elt))
4562             {
4563               tree index = TREE_PURPOSE (elt);
4564               HOST_WIDE_INT this_node_count;
4565
4566               if (index != NULL_TREE && TREE_CODE (index) == RANGE_EXPR)
4567                 {
4568                   tree lo_index = TREE_OPERAND (index, 0);
4569                   tree hi_index = TREE_OPERAND (index, 1);
4570
4571                   if (! host_integerp (lo_index, 1)
4572                       || ! host_integerp (hi_index, 1))
4573                     {
4574                       need_to_clear = 1;
4575                       break;
4576                     }
4577
4578                   this_node_count = (tree_low_cst (hi_index, 1)
4579                                      - tree_low_cst (lo_index, 1) + 1);
4580                 }
4581               else
4582                 this_node_count = 1;
4583
4584               count += this_node_count;
4585               if (mostly_zeros_p (TREE_VALUE (elt)))
4586                 zero_count += this_node_count;
4587             }
4588
4589           /* Clear the entire array first if there are any missing elements,
4590              or if the incidence of zero elements is >= 75%.  */
4591           if (! need_to_clear
4592               && (count < maxelt - minelt + 1 || 4 * zero_count >= 3 * count))
4593             need_to_clear = 1;
4594         }
4595
4596       if (need_to_clear && size > 0)
4597         {
4598           if (! cleared)
4599             clear_storage (target, GEN_INT (size));
4600           cleared = 1;
4601         }
4602       else if (REG_P (target))
4603         /* Inform later passes that the old value is dead.  */
4604         emit_insn (gen_rtx_CLOBBER (VOIDmode, target));
4605
4606       /* Store each element of the constructor into
4607          the corresponding element of TARGET, determined
4608          by counting the elements.  */
4609       for (elt = CONSTRUCTOR_ELTS (exp), i = 0;
4610            elt;
4611            elt = TREE_CHAIN (elt), i++)
4612         {
4613           enum machine_mode mode;
4614           HOST_WIDE_INT bitsize;
4615           HOST_WIDE_INT bitpos;
4616           int unsignedp;
4617           tree value = TREE_VALUE (elt);
4618           tree index = TREE_PURPOSE (elt);
4619           rtx xtarget = target;
4620
4621           if (cleared && is_zeros_p (value))
4622             continue;
4623
4624           unsignedp = TREE_UNSIGNED (elttype);
4625           mode = TYPE_MODE (elttype);
4626           if (mode == BLKmode)
4627             bitsize = (host_integerp (TYPE_SIZE (elttype), 1)
4628                        ? tree_low_cst (TYPE_SIZE (elttype), 1)
4629                        : -1);
4630           else
4631             bitsize = GET_MODE_BITSIZE (mode);
4632
4633           if (index != NULL_TREE && TREE_CODE (index) == RANGE_EXPR)
4634             {
4635               tree lo_index = TREE_OPERAND (index, 0);
4636               tree hi_index = TREE_OPERAND (index, 1);
4637               rtx index_r, pos_rtx, hi_r, loop_top, loop_end;
4638               struct nesting *loop;
4639               HOST_WIDE_INT lo, hi, count;
4640               tree position;
4641
4642               /* If the range is constant and "small", unroll the loop.  */
4643               if (const_bounds_p
4644                   && host_integerp (lo_index, 0)
4645                   && host_integerp (hi_index, 0)
4646                   && (lo = tree_low_cst (lo_index, 0),
4647                       hi = tree_low_cst (hi_index, 0),
4648                       count = hi - lo + 1,
4649                       (GET_CODE (target) != MEM
4650                        || count <= 2
4651                        || (host_integerp (TYPE_SIZE (elttype), 1)
4652                            && (tree_low_cst (TYPE_SIZE (elttype), 1) * count
4653                                <= 40 * 8)))))
4654                 {
4655                   lo -= minelt;  hi -= minelt;
4656                   for (; lo <= hi; lo++)
4657                     {
4658                       bitpos = lo * tree_low_cst (TYPE_SIZE (elttype), 0);
4659
4660                       if (GET_CODE (target) == MEM
4661                           && !MEM_KEEP_ALIAS_SET_P (target)
4662                           && TYPE_NONALIASED_COMPONENT (type))
4663                         {
4664                           target = copy_rtx (target);
4665                           MEM_KEEP_ALIAS_SET_P (target) = 1;
4666                         }
4667
4668                       store_constructor_field
4669                         (target, bitsize, bitpos, mode, value, type, cleared,
4670                          get_alias_set (elttype));
4671                     }
4672                 }
4673               else
4674                 {
4675                   hi_r = expand_expr (hi_index, NULL_RTX, VOIDmode, 0);
4676                   loop_top = gen_label_rtx ();
4677                   loop_end = gen_label_rtx ();
4678
4679                   unsignedp = TREE_UNSIGNED (domain);
4680
4681                   index = build_decl (VAR_DECL, NULL_TREE, domain);
4682
4683                   index_r
4684                     = gen_reg_rtx (promote_mode (domain, DECL_MODE (index),
4685                                                  &unsignedp, 0));
4686                   SET_DECL_RTL (index, index_r);
4687                   if (TREE_CODE (value) == SAVE_EXPR
4688                       && SAVE_EXPR_RTL (value) == 0)
4689                     {
4690                       /* Make sure value gets expanded once before the
4691                          loop.  */
4692                       expand_expr (value, const0_rtx, VOIDmode, 0);
4693                       emit_queue ();
4694                     }
4695                   store_expr (lo_index, index_r, 0);
4696                   loop = expand_start_loop (0);
4697
4698                   /* Assign value to element index.  */
4699                   position
4700                     = convert (ssizetype,
4701                                fold (build (MINUS_EXPR, TREE_TYPE (index),
4702                                             index, TYPE_MIN_VALUE (domain))));
4703                   position = size_binop (MULT_EXPR, position,
4704                                          convert (ssizetype,
4705                                                   TYPE_SIZE_UNIT (elttype)));
4706
4707                   pos_rtx = expand_expr (position, 0, VOIDmode, 0);
4708                   xtarget = offset_address (target, pos_rtx,
4709                                             highest_pow2_factor (position));
4710                   xtarget = adjust_address (xtarget, mode, 0);
4711                   if (TREE_CODE (value) == CONSTRUCTOR)
4712                     store_constructor (value, xtarget, cleared,
4713                                        bitsize / BITS_PER_UNIT);
4714                   else
4715                     store_expr (value, xtarget, 0);
4716
4717                   expand_exit_loop_if_false (loop,
4718                                              build (LT_EXPR, integer_type_node,
4719                                                     index, hi_index));
4720
4721                   expand_increment (build (PREINCREMENT_EXPR,
4722                                            TREE_TYPE (index),
4723                                            index, integer_one_node), 0, 0);
4724                   expand_end_loop ();
4725                   emit_label (loop_end);
4726                 }
4727             }
4728           else if ((index != 0 && ! host_integerp (index, 0))
4729                    || ! host_integerp (TYPE_SIZE (elttype), 1))
4730             {
4731               tree position;
4732
4733               if (index == 0)
4734                 index = ssize_int (1);
4735
4736               if (minelt)
4737                 index = convert (ssizetype,
4738                                  fold (build (MINUS_EXPR, index,
4739                                               TYPE_MIN_VALUE (domain))));
4740
4741               position = size_binop (MULT_EXPR, index,
4742                                      convert (ssizetype,
4743                                               TYPE_SIZE_UNIT (elttype)));
4744               xtarget = offset_address (target,
4745                                         expand_expr (position, 0, VOIDmode, 0),
4746                                         highest_pow2_factor (position));
4747               xtarget = adjust_address (xtarget, mode, 0);
4748               store_expr (value, xtarget, 0);
4749             }
4750           else
4751             {
4752               if (index != 0)
4753                 bitpos = ((tree_low_cst (index, 0) - minelt)
4754                           * tree_low_cst (TYPE_SIZE (elttype), 1));
4755               else
4756                 bitpos = (i * tree_low_cst (TYPE_SIZE (elttype), 1));
4757
4758               if (GET_CODE (target) == MEM && !MEM_KEEP_ALIAS_SET_P (target)
4759                   && TYPE_NONALIASED_COMPONENT (type))
4760                 {
4761                   target = copy_rtx (target);
4762                   MEM_KEEP_ALIAS_SET_P (target) = 1;
4763                 }
4764
4765               store_constructor_field (target, bitsize, bitpos, mode, value,
4766                                        type, cleared, get_alias_set (elttype));
4767
4768             }
4769         }
4770     }
4771
4772   /* Set constructor assignments.  */
4773   else if (TREE_CODE (type) == SET_TYPE)
4774     {
4775       tree elt = CONSTRUCTOR_ELTS (exp);
4776       unsigned HOST_WIDE_INT nbytes = int_size_in_bytes (type), nbits;
4777       tree domain = TYPE_DOMAIN (type);
4778       tree domain_min, domain_max, bitlength;
4779
4780       /* The default implementation strategy is to extract the constant
4781          parts of the constructor, use that to initialize the target,
4782          and then "or" in whatever non-constant ranges we need in addition.
4783
4784          If a large set is all zero or all ones, it is
4785          probably better to set it using memset (if available) or bzero.
4786          Also, if a large set has just a single range, it may also be
4787          better to first clear all the first clear the set (using
4788          bzero/memset), and set the bits we want.  */
4789
4790       /* Check for all zeros.  */
4791       if (elt == NULL_TREE && size > 0)
4792         {
4793           if (!cleared)
4794             clear_storage (target, GEN_INT (size));
4795           return;
4796         }
4797
4798       domain_min = convert (sizetype, TYPE_MIN_VALUE (domain));
4799       domain_max = convert (sizetype, TYPE_MAX_VALUE (domain));
4800       bitlength = size_binop (PLUS_EXPR,
4801                               size_diffop (domain_max, domain_min),
4802                               ssize_int (1));
4803
4804       nbits = tree_low_cst (bitlength, 1);
4805
4806       /* For "small" sets, or "medium-sized" (up to 32 bytes) sets that
4807          are "complicated" (more than one range), initialize (the
4808          constant parts) by copying from a constant.  */
4809       if (GET_MODE (target) != BLKmode || nbits <= 2 * BITS_PER_WORD
4810           || (nbytes <= 32 && TREE_CHAIN (elt) != NULL_TREE))
4811         {
4812           unsigned int set_word_size = TYPE_ALIGN (TREE_TYPE (exp));
4813           enum machine_mode mode = mode_for_size (set_word_size, MODE_INT, 1);
4814           char *bit_buffer = (char *) alloca (nbits);
4815           HOST_WIDE_INT word = 0;
4816           unsigned int bit_pos = 0;
4817           unsigned int ibit = 0;
4818           unsigned int offset = 0;  /* In bytes from beginning of set.  */
4819
4820           elt = get_set_constructor_bits (exp, bit_buffer, nbits);
4821           for (;;)
4822             {
4823               if (bit_buffer[ibit])
4824                 {
4825                   if (BYTES_BIG_ENDIAN)
4826                     word |= (1 << (set_word_size - 1 - bit_pos));
4827                   else
4828                     word |= 1 << bit_pos;
4829                 }
4830
4831               bit_pos++;  ibit++;
4832               if (bit_pos >= set_word_size || ibit == nbits)
4833                 {
4834                   if (word != 0 || ! cleared)
4835                     {
4836                       rtx datum = GEN_INT (word);
4837                       rtx to_rtx;
4838
4839                       /* The assumption here is that it is safe to use
4840                          XEXP if the set is multi-word, but not if
4841                          it's single-word.  */
4842                       if (GET_CODE (target) == MEM)
4843                         to_rtx = adjust_address (target, mode, offset);
4844                       else if (offset == 0)
4845                         to_rtx = target;
4846                       else
4847                         abort ();
4848                       emit_move_insn (to_rtx, datum);
4849                     }
4850
4851                   if (ibit == nbits)
4852                     break;
4853                   word = 0;
4854                   bit_pos = 0;
4855                   offset += set_word_size / BITS_PER_UNIT;
4856                 }
4857             }
4858         }
4859       else if (!cleared)
4860         /* Don't bother clearing storage if the set is all ones.  */
4861         if (TREE_CHAIN (elt) != NULL_TREE
4862             || (TREE_PURPOSE (elt) == NULL_TREE
4863                 ? nbits != 1
4864                 : ( ! host_integerp (TREE_VALUE (elt), 0)
4865                    || ! host_integerp (TREE_PURPOSE (elt), 0)
4866                    || (tree_low_cst (TREE_VALUE (elt), 0)
4867                        - tree_low_cst (TREE_PURPOSE (elt), 0) + 1
4868                        != (HOST_WIDE_INT) nbits))))
4869           clear_storage (target, expr_size (exp));
4870
4871       for (; elt != NULL_TREE; elt = TREE_CHAIN (elt))
4872         {
4873           /* Start of range of element or NULL.  */
4874           tree startbit = TREE_PURPOSE (elt);
4875           /* End of range of element, or element value.  */
4876           tree endbit   = TREE_VALUE (elt);
4877 #ifdef TARGET_MEM_FUNCTIONS
4878           HOST_WIDE_INT startb, endb;
4879 #endif
4880           rtx bitlength_rtx, startbit_rtx, endbit_rtx, targetx;
4881
4882           bitlength_rtx = expand_expr (bitlength,
4883                                        NULL_RTX, MEM, EXPAND_CONST_ADDRESS);
4884
4885           /* Handle non-range tuple element like [ expr ].  */
4886           if (startbit == NULL_TREE)
4887             {
4888               startbit = save_expr (endbit);
4889               endbit = startbit;
4890             }
4891
4892           startbit = convert (sizetype, startbit);
4893           endbit = convert (sizetype, endbit);
4894           if (! integer_zerop (domain_min))
4895             {
4896               startbit = size_binop (MINUS_EXPR, startbit, domain_min);
4897               endbit = size_binop (MINUS_EXPR, endbit, domain_min);
4898             }
4899           startbit_rtx = expand_expr (startbit, NULL_RTX, MEM,
4900                                       EXPAND_CONST_ADDRESS);
4901           endbit_rtx = expand_expr (endbit, NULL_RTX, MEM,
4902                                     EXPAND_CONST_ADDRESS);
4903
4904           if (REG_P (target))
4905             {
4906               targetx
4907                 = assign_temp
4908                   ((build_qualified_type (type_for_mode (GET_MODE (target), 0),
4909                                           TYPE_QUAL_CONST)),
4910                    0, 1, 1);
4911               emit_move_insn (targetx, target);
4912             }
4913
4914           else if (GET_CODE (target) == MEM)
4915             targetx = target;
4916           else
4917             abort ();
4918
4919 #ifdef TARGET_MEM_FUNCTIONS
4920           /* Optimization:  If startbit and endbit are
4921              constants divisible by BITS_PER_UNIT,
4922              call memset instead.  */
4923           if (TREE_CODE (startbit) == INTEGER_CST
4924               && TREE_CODE (endbit) == INTEGER_CST
4925               && (startb = TREE_INT_CST_LOW (startbit)) % BITS_PER_UNIT == 0
4926               && (endb = TREE_INT_CST_LOW (endbit) + 1) % BITS_PER_UNIT == 0)
4927             {
4928               emit_library_call (memset_libfunc, LCT_NORMAL,
4929                                  VOIDmode, 3,
4930                                  plus_constant (XEXP (targetx, 0),
4931                                                 startb / BITS_PER_UNIT),
4932                                  Pmode,
4933                                  constm1_rtx, TYPE_MODE (integer_type_node),
4934                                  GEN_INT ((endb - startb) / BITS_PER_UNIT),
4935                                  TYPE_MODE (sizetype));
4936             }
4937           else
4938 #endif
4939             emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "__setbits"),
4940                                LCT_NORMAL, VOIDmode, 4, XEXP (targetx, 0),
4941                                Pmode, bitlength_rtx, TYPE_MODE (sizetype),
4942                                startbit_rtx, TYPE_MODE (sizetype),
4943                                endbit_rtx, TYPE_MODE (sizetype));
4944
4945           if (REG_P (target))
4946             emit_move_insn (target, targetx);
4947         }
4948     }
4949
4950   else
4951     abort ();
4952 }
4953
4954 /* Store the value of EXP (an expression tree)
4955    into a subfield of TARGET which has mode MODE and occupies
4956    BITSIZE bits, starting BITPOS bits from the start of TARGET.
4957    If MODE is VOIDmode, it means that we are storing into a bit-field.
4958
4959    If VALUE_MODE is VOIDmode, return nothing in particular.
4960    UNSIGNEDP is not used in this case.
4961
4962    Otherwise, return an rtx for the value stored.  This rtx
4963    has mode VALUE_MODE if that is convenient to do.
4964    In this case, UNSIGNEDP must be nonzero if the value is an unsigned type.
4965
4966    TYPE is the type of the underlying object,
4967
4968    ALIAS_SET is the alias set for the destination.  This value will
4969    (in general) be different from that for TARGET, since TARGET is a
4970    reference to the containing structure.  */
4971
4972 static rtx
4973 store_field (target, bitsize, bitpos, mode, exp, value_mode, unsignedp, type,
4974              alias_set)
4975      rtx target;
4976      HOST_WIDE_INT bitsize;
4977      HOST_WIDE_INT bitpos;
4978      enum machine_mode mode;
4979      tree exp;
4980      enum machine_mode value_mode;
4981      int unsignedp;
4982      tree type;
4983      int alias_set;
4984 {
4985   HOST_WIDE_INT width_mask = 0;
4986
4987   if (TREE_CODE (exp) == ERROR_MARK)
4988     return const0_rtx;
4989
4990   /* If we have nothing to store, do nothing unless the expression has
4991      side-effects.  */
4992   if (bitsize == 0)
4993     return expand_expr (exp, const0_rtx, VOIDmode, 0);
4994   else if (bitsize >=0 && bitsize < HOST_BITS_PER_WIDE_INT)
4995     width_mask = ((HOST_WIDE_INT) 1 << bitsize) - 1;
4996
4997   /* If we are storing into an unaligned field of an aligned union that is
4998      in a register, we may have the mode of TARGET being an integer mode but
4999      MODE == BLKmode.  In that case, get an aligned object whose size and
5000      alignment are the same as TARGET and store TARGET into it (we can avoid
5001      the store if the field being stored is the entire width of TARGET).  Then
5002      call ourselves recursively to store the field into a BLKmode version of
5003      that object.  Finally, load from the object into TARGET.  This is not
5004      very efficient in general, but should only be slightly more expensive
5005      than the otherwise-required unaligned accesses.  Perhaps this can be
5006      cleaned up later.  */
5007
5008   if (mode == BLKmode
5009       && (GET_CODE (target) == REG || GET_CODE (target) == SUBREG))
5010     {
5011       rtx object
5012         = assign_temp
5013           (build_qualified_type (type, TYPE_QUALS (type) | TYPE_QUAL_CONST),
5014            0, 1, 1);
5015       rtx blk_object = adjust_address (object, BLKmode, 0);
5016
5017       if (bitsize != (HOST_WIDE_INT) GET_MODE_BITSIZE (GET_MODE (target)))
5018         emit_move_insn (object, target);
5019
5020       store_field (blk_object, bitsize, bitpos, mode, exp, VOIDmode, 0, type,
5021                    alias_set);
5022
5023       emit_move_insn (target, object);
5024
5025       /* We want to return the BLKmode version of the data.  */
5026       return blk_object;
5027     }
5028
5029   if (GET_CODE (target) == CONCAT)
5030     {
5031       /* We're storing into a struct containing a single __complex.  */
5032
5033       if (bitpos != 0)
5034         abort ();
5035       return store_expr (exp, target, 0);
5036     }
5037
5038   /* If the structure is in a register or if the component
5039      is a bit field, we cannot use addressing to access it.
5040      Use bit-field techniques or SUBREG to store in it.  */
5041
5042   if (mode == VOIDmode
5043       || (mode != BLKmode && ! direct_store[(int) mode]
5044           && GET_MODE_CLASS (mode) != MODE_COMPLEX_INT
5045           && GET_MODE_CLASS (mode) != MODE_COMPLEX_FLOAT)
5046       || GET_CODE (target) == REG
5047       || GET_CODE (target) == SUBREG
5048       /* If the field isn't aligned enough to store as an ordinary memref,
5049          store it as a bit field.  */
5050       || (mode != BLKmode && SLOW_UNALIGNED_ACCESS (mode, MEM_ALIGN (target))
5051           && (MEM_ALIGN (target) < GET_MODE_ALIGNMENT (mode)
5052               || bitpos % GET_MODE_ALIGNMENT (mode)))
5053       /* If the RHS and field are a constant size and the size of the
5054          RHS isn't the same size as the bitfield, we must use bitfield
5055          operations.  */
5056       || (bitsize >= 0
5057           && TREE_CODE (TYPE_SIZE (TREE_TYPE (exp))) == INTEGER_CST
5058           && compare_tree_int (TYPE_SIZE (TREE_TYPE (exp)), bitsize) != 0))
5059     {
5060       rtx temp = expand_expr (exp, NULL_RTX, VOIDmode, 0);
5061
5062       /* If BITSIZE is narrower than the size of the type of EXP
5063          we will be narrowing TEMP.  Normally, what's wanted are the
5064          low-order bits.  However, if EXP's type is a record and this is
5065          big-endian machine, we want the upper BITSIZE bits.  */
5066       if (BYTES_BIG_ENDIAN && GET_MODE_CLASS (GET_MODE (temp)) == MODE_INT
5067           && bitsize < (HOST_WIDE_INT) GET_MODE_BITSIZE (GET_MODE (temp))
5068           && TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
5069         temp = expand_shift (RSHIFT_EXPR, GET_MODE (temp), temp,
5070                              size_int (GET_MODE_BITSIZE (GET_MODE (temp))
5071                                        - bitsize),
5072                              temp, 1);
5073
5074       /* Unless MODE is VOIDmode or BLKmode, convert TEMP to
5075          MODE.  */
5076       if (mode != VOIDmode && mode != BLKmode
5077           && mode != TYPE_MODE (TREE_TYPE (exp)))
5078         temp = convert_modes (mode, TYPE_MODE (TREE_TYPE (exp)), temp, 1);
5079
5080       /* If the modes of TARGET and TEMP are both BLKmode, both
5081          must be in memory and BITPOS must be aligned on a byte
5082          boundary.  If so, we simply do a block copy.  */
5083       if (GET_MODE (target) == BLKmode && GET_MODE (temp) == BLKmode)
5084         {
5085           if (GET_CODE (target) != MEM || GET_CODE (temp) != MEM
5086               || bitpos % BITS_PER_UNIT != 0)
5087             abort ();
5088
5089           target = adjust_address (target, VOIDmode, bitpos / BITS_PER_UNIT);
5090           emit_block_move (target, temp,
5091                            GEN_INT ((bitsize + BITS_PER_UNIT - 1)
5092                                     / BITS_PER_UNIT));
5093
5094           return value_mode == VOIDmode ? const0_rtx : target;
5095         }
5096
5097       /* Store the value in the bitfield.  */
5098       store_bit_field (target, bitsize, bitpos, mode, temp,
5099                        int_size_in_bytes (type));
5100
5101       if (value_mode != VOIDmode)
5102         {
5103           /* The caller wants an rtx for the value.
5104              If possible, avoid refetching from the bitfield itself.  */
5105           if (width_mask != 0
5106               && ! (GET_CODE (target) == MEM && MEM_VOLATILE_P (target)))
5107             {
5108               tree count;
5109               enum machine_mode tmode;
5110
5111               if (unsignedp)
5112                 return expand_and (temp,
5113                                    GEN_INT
5114                                    (trunc_int_for_mode
5115                                     (width_mask,
5116                                      GET_MODE (temp) == VOIDmode
5117                                      ? value_mode
5118                                      : GET_MODE (temp))), NULL_RTX);
5119
5120               tmode = GET_MODE (temp);
5121               if (tmode == VOIDmode)
5122                 tmode = value_mode;
5123               count = build_int_2 (GET_MODE_BITSIZE (tmode) - bitsize, 0);
5124               temp = expand_shift (LSHIFT_EXPR, tmode, temp, count, 0, 0);
5125               return expand_shift (RSHIFT_EXPR, tmode, temp, count, 0, 0);
5126             }
5127
5128           return extract_bit_field (target, bitsize, bitpos, unsignedp,
5129                                     NULL_RTX, value_mode, VOIDmode,
5130                                     int_size_in_bytes (type));
5131         }
5132       return const0_rtx;
5133     }
5134   else
5135     {
5136       rtx addr = XEXP (target, 0);
5137       rtx to_rtx = target;
5138
5139       /* If a value is wanted, it must be the lhs;
5140          so make the address stable for multiple use.  */
5141
5142       if (value_mode != VOIDmode && GET_CODE (addr) != REG
5143           && ! CONSTANT_ADDRESS_P (addr)
5144           /* A frame-pointer reference is already stable.  */
5145           && ! (GET_CODE (addr) == PLUS
5146                 && GET_CODE (XEXP (addr, 1)) == CONST_INT
5147                 && (XEXP (addr, 0) == virtual_incoming_args_rtx
5148                     || XEXP (addr, 0) == virtual_stack_vars_rtx)))
5149         to_rtx = replace_equiv_address (to_rtx, copy_to_reg (addr));
5150
5151       /* Now build a reference to just the desired component.  */
5152
5153       to_rtx = adjust_address (target, mode, bitpos / BITS_PER_UNIT);
5154
5155       if (to_rtx == target)
5156         to_rtx = copy_rtx (to_rtx);
5157
5158       MEM_SET_IN_STRUCT_P (to_rtx, 1);
5159       if (!MEM_KEEP_ALIAS_SET_P (to_rtx) && MEM_ALIAS_SET (to_rtx) != 0)
5160         set_mem_alias_set (to_rtx, alias_set);
5161
5162       return store_expr (exp, to_rtx, value_mode != VOIDmode);
5163     }
5164 }
5165 \f
5166 /* Given an expression EXP that may be a COMPONENT_REF, a BIT_FIELD_REF,
5167    an ARRAY_REF, or an ARRAY_RANGE_REF, look for nested operations of these
5168    codes and find the ultimate containing object, which we return.
5169
5170    We set *PBITSIZE to the size in bits that we want, *PBITPOS to the
5171    bit position, and *PUNSIGNEDP to the signedness of the field.
5172    If the position of the field is variable, we store a tree
5173    giving the variable offset (in units) in *POFFSET.
5174    This offset is in addition to the bit position.
5175    If the position is not variable, we store 0 in *POFFSET.
5176
5177    If any of the extraction expressions is volatile,
5178    we store 1 in *PVOLATILEP.  Otherwise we don't change that.
5179
5180    If the field is a bit-field, *PMODE is set to VOIDmode.  Otherwise, it
5181    is a mode that can be used to access the field.  In that case, *PBITSIZE
5182    is redundant.
5183
5184    If the field describes a variable-sized object, *PMODE is set to
5185    VOIDmode and *PBITSIZE is set to -1.  An access cannot be made in
5186    this case, but the address of the object can be found.  */
5187
5188 tree
5189 get_inner_reference (exp, pbitsize, pbitpos, poffset, pmode,
5190                      punsignedp, pvolatilep)
5191      tree exp;
5192      HOST_WIDE_INT *pbitsize;
5193      HOST_WIDE_INT *pbitpos;
5194      tree *poffset;
5195      enum machine_mode *pmode;
5196      int *punsignedp;
5197      int *pvolatilep;
5198 {
5199   tree size_tree = 0;
5200   enum machine_mode mode = VOIDmode;
5201   tree offset = size_zero_node;
5202   tree bit_offset = bitsize_zero_node;
5203   tree placeholder_ptr = 0;
5204   tree tem;
5205
5206   /* First get the mode, signedness, and size.  We do this from just the
5207      outermost expression.  */
5208   if (TREE_CODE (exp) == COMPONENT_REF)
5209     {
5210       size_tree = DECL_SIZE (TREE_OPERAND (exp, 1));
5211       if (! DECL_BIT_FIELD (TREE_OPERAND (exp, 1)))
5212         mode = DECL_MODE (TREE_OPERAND (exp, 1));
5213
5214       *punsignedp = TREE_UNSIGNED (TREE_OPERAND (exp, 1));
5215     }
5216   else if (TREE_CODE (exp) == BIT_FIELD_REF)
5217     {
5218       size_tree = TREE_OPERAND (exp, 1);
5219       *punsignedp = TREE_UNSIGNED (exp);
5220     }
5221   else
5222     {
5223       mode = TYPE_MODE (TREE_TYPE (exp));
5224       *punsignedp = TREE_UNSIGNED (TREE_TYPE (exp));
5225
5226       if (mode == BLKmode)
5227         size_tree = TYPE_SIZE (TREE_TYPE (exp));
5228       else
5229         *pbitsize = GET_MODE_BITSIZE (mode);
5230     }
5231
5232   if (size_tree != 0)
5233     {
5234       if (! host_integerp (size_tree, 1))
5235         mode = BLKmode, *pbitsize = -1;
5236       else
5237         *pbitsize = tree_low_cst (size_tree, 1);
5238     }
5239
5240   /* Compute cumulative bit-offset for nested component-refs and array-refs,
5241      and find the ultimate containing object.  */
5242   while (1)
5243     {
5244       if (TREE_CODE (exp) == BIT_FIELD_REF)
5245         bit_offset = size_binop (PLUS_EXPR, bit_offset, TREE_OPERAND (exp, 2));
5246       else if (TREE_CODE (exp) == COMPONENT_REF)
5247         {
5248           tree field = TREE_OPERAND (exp, 1);
5249           tree this_offset = DECL_FIELD_OFFSET (field);
5250
5251           /* If this field hasn't been filled in yet, don't go
5252              past it.  This should only happen when folding expressions
5253              made during type construction.  */
5254           if (this_offset == 0)
5255             break;
5256           else if (! TREE_CONSTANT (this_offset)
5257                    && contains_placeholder_p (this_offset))
5258             this_offset = build (WITH_RECORD_EXPR, sizetype, this_offset, exp);
5259
5260           offset = size_binop (PLUS_EXPR, offset, this_offset);
5261           bit_offset = size_binop (PLUS_EXPR, bit_offset,
5262                                    DECL_FIELD_BIT_OFFSET (field));
5263
5264           /* ??? Right now we don't do anything with DECL_OFFSET_ALIGN.  */
5265         }
5266
5267       else if (TREE_CODE (exp) == ARRAY_REF
5268                || TREE_CODE (exp) == ARRAY_RANGE_REF)
5269         {
5270           tree index = TREE_OPERAND (exp, 1);
5271           tree array = TREE_OPERAND (exp, 0);
5272           tree domain = TYPE_DOMAIN (TREE_TYPE (array));
5273           tree low_bound = (domain ? TYPE_MIN_VALUE (domain) : 0);
5274           tree unit_size = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (array)));
5275
5276           /* We assume all arrays have sizes that are a multiple of a byte.
5277              First subtract the lower bound, if any, in the type of the
5278              index, then convert to sizetype and multiply by the size of the
5279              array element.  */
5280           if (low_bound != 0 && ! integer_zerop (low_bound))
5281             index = fold (build (MINUS_EXPR, TREE_TYPE (index),
5282                                  index, low_bound));
5283
5284           /* If the index has a self-referential type, pass it to a
5285              WITH_RECORD_EXPR; if the component size is, pass our
5286              component to one.  */
5287           if (! TREE_CONSTANT (index)
5288               && contains_placeholder_p (index))
5289             index = build (WITH_RECORD_EXPR, TREE_TYPE (index), index, exp);
5290           if (! TREE_CONSTANT (unit_size)
5291               && contains_placeholder_p (unit_size))
5292             unit_size = build (WITH_RECORD_EXPR, sizetype, unit_size, array);
5293
5294           offset = size_binop (PLUS_EXPR, offset,
5295                                size_binop (MULT_EXPR,
5296                                            convert (sizetype, index),
5297                                            unit_size));
5298         }
5299
5300       else if (TREE_CODE (exp) == PLACEHOLDER_EXPR)
5301         {
5302           tree new = find_placeholder (exp, &placeholder_ptr);
5303
5304           /* If we couldn't find the replacement, return the PLACEHOLDER_EXPR.
5305              We might have been called from tree optimization where we
5306              haven't set up an object yet.  */
5307           if (new == 0)
5308             break;
5309           else
5310             exp = new;
5311
5312           continue;
5313         }
5314       else if (TREE_CODE (exp) != NON_LVALUE_EXPR
5315                && TREE_CODE (exp) != VIEW_CONVERT_EXPR
5316                && ! ((TREE_CODE (exp) == NOP_EXPR
5317                       || TREE_CODE (exp) == CONVERT_EXPR)
5318                      && (TYPE_MODE (TREE_TYPE (exp))
5319                          == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))))))
5320         break;
5321
5322       /* If any reference in the chain is volatile, the effect is volatile.  */
5323       if (TREE_THIS_VOLATILE (exp))
5324         *pvolatilep = 1;
5325
5326       exp = TREE_OPERAND (exp, 0);
5327     }
5328
5329   /* If OFFSET is constant, see if we can return the whole thing as a
5330      constant bit position.  Otherwise, split it up.  */
5331   if (host_integerp (offset, 0)
5332       && 0 != (tem = size_binop (MULT_EXPR, convert (bitsizetype, offset),
5333                                  bitsize_unit_node))
5334       && 0 != (tem = size_binop (PLUS_EXPR, tem, bit_offset))
5335       && host_integerp (tem, 0))
5336     *pbitpos = tree_low_cst (tem, 0), *poffset = 0;
5337   else
5338     *pbitpos = tree_low_cst (bit_offset, 0), *poffset = offset;
5339
5340   *pmode = mode;
5341   return exp;
5342 }
5343
5344 /* Return 1 if T is an expression that get_inner_reference handles.  */
5345
5346 int
5347 handled_component_p (t)
5348      tree t;
5349 {
5350   switch (TREE_CODE (t))
5351     {
5352     case BIT_FIELD_REF:
5353     case COMPONENT_REF:
5354     case ARRAY_REF:
5355     case ARRAY_RANGE_REF:
5356     case NON_LVALUE_EXPR:
5357     case VIEW_CONVERT_EXPR:
5358       return 1;
5359
5360     case NOP_EXPR:
5361     case CONVERT_EXPR:
5362       return (TYPE_MODE (TREE_TYPE (t))
5363               == TYPE_MODE (TREE_TYPE (TREE_OPERAND (t, 0))));
5364
5365     default:
5366       return 0;
5367     }
5368 }
5369 \f
5370 /* Given an rtx VALUE that may contain additions and multiplications, return
5371    an equivalent value that just refers to a register, memory, or constant.
5372    This is done by generating instructions to perform the arithmetic and
5373    returning a pseudo-register containing the value.
5374
5375    The returned value may be a REG, SUBREG, MEM or constant.  */
5376
5377 rtx
5378 force_operand (value, target)
5379      rtx value, target;
5380 {
5381   optab binoptab = 0;
5382   /* Use a temporary to force order of execution of calls to
5383      `force_operand'.  */
5384   rtx tmp;
5385   rtx op2;
5386   /* Use subtarget as the target for operand 0 of a binary operation.  */
5387   rtx subtarget = get_subtarget (target);
5388
5389   /* Check for a PIC address load.  */
5390   if (flag_pic
5391       && (GET_CODE (value) == PLUS || GET_CODE (value) == MINUS)
5392       && XEXP (value, 0) == pic_offset_table_rtx
5393       && (GET_CODE (XEXP (value, 1)) == SYMBOL_REF
5394           || GET_CODE (XEXP (value, 1)) == LABEL_REF
5395           || GET_CODE (XEXP (value, 1)) == CONST))
5396     {
5397       if (!subtarget)
5398         subtarget = gen_reg_rtx (GET_MODE (value));
5399       emit_move_insn (subtarget, value);
5400       return subtarget;
5401     }
5402
5403   if (GET_CODE (value) == PLUS)
5404     binoptab = add_optab;
5405   else if (GET_CODE (value) == MINUS)
5406     binoptab = sub_optab;
5407   else if (GET_CODE (value) == MULT)
5408     {
5409       op2 = XEXP (value, 1);
5410       if (!CONSTANT_P (op2)
5411           && !(GET_CODE (op2) == REG && op2 != subtarget))
5412         subtarget = 0;
5413       tmp = force_operand (XEXP (value, 0), subtarget);
5414       return expand_mult (GET_MODE (value), tmp,
5415                           force_operand (op2, NULL_RTX),
5416                           target, 1);
5417     }
5418
5419   if (binoptab)
5420     {
5421       op2 = XEXP (value, 1);
5422       if (!CONSTANT_P (op2)
5423           && !(GET_CODE (op2) == REG && op2 != subtarget))
5424         subtarget = 0;
5425       if (binoptab == sub_optab && GET_CODE (op2) == CONST_INT)
5426         {
5427           binoptab = add_optab;
5428           op2 = negate_rtx (GET_MODE (value), op2);
5429         }
5430
5431       /* Check for an addition with OP2 a constant integer and our first
5432          operand a PLUS of a virtual register and something else.  In that
5433          case, we want to emit the sum of the virtual register and the
5434          constant first and then add the other value.  This allows virtual
5435          register instantiation to simply modify the constant rather than
5436          creating another one around this addition.  */
5437       if (binoptab == add_optab && GET_CODE (op2) == CONST_INT
5438           && GET_CODE (XEXP (value, 0)) == PLUS
5439           && GET_CODE (XEXP (XEXP (value, 0), 0)) == REG
5440           && REGNO (XEXP (XEXP (value, 0), 0)) >= FIRST_VIRTUAL_REGISTER
5441           && REGNO (XEXP (XEXP (value, 0), 0)) <= LAST_VIRTUAL_REGISTER)
5442         {
5443           rtx temp = expand_binop (GET_MODE (value), binoptab,
5444                                    XEXP (XEXP (value, 0), 0), op2,
5445                                    subtarget, 0, OPTAB_LIB_WIDEN);
5446           return expand_binop (GET_MODE (value), binoptab, temp,
5447                                force_operand (XEXP (XEXP (value, 0), 1), 0),
5448                                target, 0, OPTAB_LIB_WIDEN);
5449         }
5450
5451       tmp = force_operand (XEXP (value, 0), subtarget);
5452       return expand_binop (GET_MODE (value), binoptab, tmp,
5453                            force_operand (op2, NULL_RTX),
5454                            target, 0, OPTAB_LIB_WIDEN);
5455       /* We give UNSIGNEDP = 0 to expand_binop
5456          because the only operations we are expanding here are signed ones.  */
5457     }
5458
5459 #ifdef INSN_SCHEDULING
5460   /* On machines that have insn scheduling, we want all memory reference to be
5461      explicit, so we need to deal with such paradoxical SUBREGs.  */
5462   if (GET_CODE (value) == SUBREG && GET_CODE (SUBREG_REG (value)) == MEM
5463       && (GET_MODE_SIZE (GET_MODE (value))
5464           > GET_MODE_SIZE (GET_MODE (SUBREG_REG (value)))))
5465     value
5466       = simplify_gen_subreg (GET_MODE (value),
5467                              force_reg (GET_MODE (SUBREG_REG (value)),
5468                                         force_operand (SUBREG_REG (value),
5469                                                        NULL_RTX)),
5470                              GET_MODE (SUBREG_REG (value)),
5471                              SUBREG_BYTE (value));
5472 #endif
5473
5474   return value;
5475 }
5476 \f
5477 /* Subroutine of expand_expr: return nonzero iff there is no way that
5478    EXP can reference X, which is being modified.  TOP_P is nonzero if this
5479    call is going to be used to determine whether we need a temporary
5480    for EXP, as opposed to a recursive call to this function.
5481
5482    It is always safe for this routine to return zero since it merely
5483    searches for optimization opportunities.  */
5484
5485 int
5486 safe_from_p (x, exp, top_p)
5487      rtx x;
5488      tree exp;
5489      int top_p;
5490 {
5491   rtx exp_rtl = 0;
5492   int i, nops;
5493   static tree save_expr_list;
5494
5495   if (x == 0
5496       /* If EXP has varying size, we MUST use a target since we currently
5497          have no way of allocating temporaries of variable size
5498          (except for arrays that have TYPE_ARRAY_MAX_SIZE set).
5499          So we assume here that something at a higher level has prevented a
5500          clash.  This is somewhat bogus, but the best we can do.  Only
5501          do this when X is BLKmode and when we are at the top level.  */
5502       || (top_p && TREE_TYPE (exp) != 0 && COMPLETE_TYPE_P (TREE_TYPE (exp))
5503           && TREE_CODE (TYPE_SIZE (TREE_TYPE (exp))) != INTEGER_CST
5504           && (TREE_CODE (TREE_TYPE (exp)) != ARRAY_TYPE
5505               || TYPE_ARRAY_MAX_SIZE (TREE_TYPE (exp)) == NULL_TREE
5506               || TREE_CODE (TYPE_ARRAY_MAX_SIZE (TREE_TYPE (exp)))
5507               != INTEGER_CST)
5508           && GET_MODE (x) == BLKmode)
5509       /* If X is in the outgoing argument area, it is always safe.  */
5510       || (GET_CODE (x) == MEM
5511           && (XEXP (x, 0) == virtual_outgoing_args_rtx
5512               || (GET_CODE (XEXP (x, 0)) == PLUS
5513                   && XEXP (XEXP (x, 0), 0) == virtual_outgoing_args_rtx))))
5514     return 1;
5515
5516   /* If this is a subreg of a hard register, declare it unsafe, otherwise,
5517      find the underlying pseudo.  */
5518   if (GET_CODE (x) == SUBREG)
5519     {
5520       x = SUBREG_REG (x);
5521       if (GET_CODE (x) == REG && REGNO (x) < FIRST_PSEUDO_REGISTER)
5522         return 0;
5523     }
5524
5525   /* A SAVE_EXPR might appear many times in the expression passed to the
5526      top-level safe_from_p call, and if it has a complex subexpression,
5527      examining it multiple times could result in a combinatorial explosion.
5528      E.g. on an Alpha running at least 200MHz, a Fortran test case compiled
5529      with optimization took about 28 minutes to compile -- even though it was
5530      only a few lines long.  So we mark each SAVE_EXPR we see with TREE_PRIVATE
5531      and turn that off when we are done.  We keep a list of the SAVE_EXPRs
5532      we have processed.  Note that the only test of top_p was above.  */
5533
5534   if (top_p)
5535     {
5536       int rtn;
5537       tree t;
5538
5539       save_expr_list = 0;
5540
5541       rtn = safe_from_p (x, exp, 0);
5542
5543       for (t = save_expr_list; t != 0; t = TREE_CHAIN (t))
5544         TREE_PRIVATE (TREE_PURPOSE (t)) = 0;
5545
5546       return rtn;
5547     }
5548
5549   /* Now look at our tree code and possibly recurse.  */
5550   switch (TREE_CODE_CLASS (TREE_CODE (exp)))
5551     {
5552     case 'd':
5553       exp_rtl = DECL_RTL_SET_P (exp) ? DECL_RTL (exp) : NULL_RTX;
5554       break;
5555
5556     case 'c':
5557       return 1;
5558
5559     case 'x':
5560       if (TREE_CODE (exp) == TREE_LIST)
5561         return ((TREE_VALUE (exp) == 0
5562                  || safe_from_p (x, TREE_VALUE (exp), 0))
5563                 && (TREE_CHAIN (exp) == 0
5564                     || safe_from_p (x, TREE_CHAIN (exp), 0)));
5565       else if (TREE_CODE (exp) == ERROR_MARK)
5566         return 1;       /* An already-visited SAVE_EXPR? */
5567       else
5568         return 0;
5569
5570     case '1':
5571       return safe_from_p (x, TREE_OPERAND (exp, 0), 0);
5572
5573     case '2':
5574     case '<':
5575       return (safe_from_p (x, TREE_OPERAND (exp, 0), 0)
5576               && safe_from_p (x, TREE_OPERAND (exp, 1), 0));
5577
5578     case 'e':
5579     case 'r':
5580       /* Now do code-specific tests.  EXP_RTL is set to any rtx we find in
5581          the expression.  If it is set, we conflict iff we are that rtx or
5582          both are in memory.  Otherwise, we check all operands of the
5583          expression recursively.  */
5584
5585       switch (TREE_CODE (exp))
5586         {
5587         case ADDR_EXPR:
5588           /* If the operand is static or we are static, we can't conflict.
5589              Likewise if we don't conflict with the operand at all.  */
5590           if (staticp (TREE_OPERAND (exp, 0))
5591               || TREE_STATIC (exp)
5592               || safe_from_p (x, TREE_OPERAND (exp, 0), 0))
5593             return 1;
5594
5595           /* Otherwise, the only way this can conflict is if we are taking
5596              the address of a DECL a that address if part of X, which is
5597              very rare.  */
5598           exp = TREE_OPERAND (exp, 0);
5599           if (DECL_P (exp))
5600             {
5601               if (!DECL_RTL_SET_P (exp)
5602                   || GET_CODE (DECL_RTL (exp)) != MEM)
5603                 return 0;
5604               else
5605                 exp_rtl = XEXP (DECL_RTL (exp), 0);
5606             }
5607           break;
5608
5609         case INDIRECT_REF:
5610           if (GET_CODE (x) == MEM
5611               && alias_sets_conflict_p (MEM_ALIAS_SET (x),
5612                                         get_alias_set (exp)))
5613             return 0;
5614           break;
5615
5616         case CALL_EXPR:
5617           /* Assume that the call will clobber all hard registers and
5618              all of memory.  */
5619           if ((GET_CODE (x) == REG && REGNO (x) < FIRST_PSEUDO_REGISTER)
5620               || GET_CODE (x) == MEM)
5621             return 0;
5622           break;
5623
5624         case RTL_EXPR:
5625           /* If a sequence exists, we would have to scan every instruction
5626              in the sequence to see if it was safe.  This is probably not
5627              worthwhile.  */
5628           if (RTL_EXPR_SEQUENCE (exp))
5629             return 0;
5630
5631           exp_rtl = RTL_EXPR_RTL (exp);
5632           break;
5633
5634         case WITH_CLEANUP_EXPR:
5635           exp_rtl = WITH_CLEANUP_EXPR_RTL (exp);
5636           break;
5637
5638         case CLEANUP_POINT_EXPR:
5639           return safe_from_p (x, TREE_OPERAND (exp, 0), 0);
5640
5641         case SAVE_EXPR:
5642           exp_rtl = SAVE_EXPR_RTL (exp);
5643           if (exp_rtl)
5644             break;
5645
5646           /* If we've already scanned this, don't do it again.  Otherwise,
5647              show we've scanned it and record for clearing the flag if we're
5648              going on.  */
5649           if (TREE_PRIVATE (exp))
5650             return 1;
5651
5652           TREE_PRIVATE (exp) = 1;
5653           if (! safe_from_p (x, TREE_OPERAND (exp, 0), 0))
5654             {
5655               TREE_PRIVATE (exp) = 0;
5656               return 0;
5657             }
5658
5659           save_expr_list = tree_cons (exp, NULL_TREE, save_expr_list);
5660           return 1;
5661
5662         case BIND_EXPR:
5663           /* The only operand we look at is operand 1.  The rest aren't
5664              part of the expression.  */
5665           return safe_from_p (x, TREE_OPERAND (exp, 1), 0);
5666
5667         case METHOD_CALL_EXPR:
5668           /* This takes an rtx argument, but shouldn't appear here.  */
5669           abort ();
5670
5671         default:
5672           break;
5673         }
5674
5675       /* If we have an rtx, we do not need to scan our operands.  */
5676       if (exp_rtl)
5677         break;
5678
5679       nops = first_rtl_op (TREE_CODE (exp));
5680       for (i = 0; i < nops; i++)
5681         if (TREE_OPERAND (exp, i) != 0
5682             && ! safe_from_p (x, TREE_OPERAND (exp, i), 0))
5683           return 0;
5684
5685       /* If this is a language-specific tree code, it may require
5686          special handling.  */
5687       if ((unsigned int) TREE_CODE (exp)
5688           >= (unsigned int) LAST_AND_UNUSED_TREE_CODE
5689           && !(*lang_hooks.safe_from_p) (x, exp))
5690         return 0;
5691     }
5692
5693   /* If we have an rtl, find any enclosed object.  Then see if we conflict
5694      with it.  */
5695   if (exp_rtl)
5696     {
5697       if (GET_CODE (exp_rtl) == SUBREG)
5698         {
5699           exp_rtl = SUBREG_REG (exp_rtl);
5700           if (GET_CODE (exp_rtl) == REG
5701               && REGNO (exp_rtl) < FIRST_PSEUDO_REGISTER)
5702             return 0;
5703         }
5704
5705       /* If the rtl is X, then it is not safe.  Otherwise, it is unless both
5706          are memory and they conflict.  */
5707       return ! (rtx_equal_p (x, exp_rtl)
5708                 || (GET_CODE (x) == MEM && GET_CODE (exp_rtl) == MEM
5709                     && true_dependence (exp_rtl, GET_MODE (x), x,
5710                                         rtx_addr_varies_p)));
5711     }
5712
5713   /* If we reach here, it is safe.  */
5714   return 1;
5715 }
5716
5717 /* Subroutine of expand_expr: return rtx if EXP is a
5718    variable or parameter; else return 0.  */
5719
5720 static rtx
5721 var_rtx (exp)
5722      tree exp;
5723 {
5724   STRIP_NOPS (exp);
5725   switch (TREE_CODE (exp))
5726     {
5727     case PARM_DECL:
5728     case VAR_DECL:
5729       return DECL_RTL (exp);
5730     default:
5731       return 0;
5732     }
5733 }
5734
5735 #ifdef MAX_INTEGER_COMPUTATION_MODE
5736
5737 void
5738 check_max_integer_computation_mode (exp)
5739      tree exp;
5740 {
5741   enum tree_code code;
5742   enum machine_mode mode;
5743
5744   /* Strip any NOPs that don't change the mode.  */
5745   STRIP_NOPS (exp);
5746   code = TREE_CODE (exp);
5747
5748   /* We must allow conversions of constants to MAX_INTEGER_COMPUTATION_MODE.  */
5749   if (code == NOP_EXPR
5750       && TREE_CODE (TREE_OPERAND (exp, 0)) == INTEGER_CST)
5751     return;
5752
5753   /* First check the type of the overall operation.   We need only look at
5754      unary, binary and relational operations.  */
5755   if (TREE_CODE_CLASS (code) == '1'
5756       || TREE_CODE_CLASS (code) == '2'
5757       || TREE_CODE_CLASS (code) == '<')
5758     {
5759       mode = TYPE_MODE (TREE_TYPE (exp));
5760       if (GET_MODE_CLASS (mode) == MODE_INT
5761           && mode > MAX_INTEGER_COMPUTATION_MODE)
5762         internal_error ("unsupported wide integer operation");
5763     }
5764
5765   /* Check operand of a unary op.  */
5766   if (TREE_CODE_CLASS (code) == '1')
5767     {
5768       mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
5769       if (GET_MODE_CLASS (mode) == MODE_INT
5770           && mode > MAX_INTEGER_COMPUTATION_MODE)
5771         internal_error ("unsupported wide integer operation");
5772     }
5773
5774   /* Check operands of a binary/comparison op.  */
5775   if (TREE_CODE_CLASS (code) == '2' || TREE_CODE_CLASS (code) == '<')
5776     {
5777       mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
5778       if (GET_MODE_CLASS (mode) == MODE_INT
5779           && mode > MAX_INTEGER_COMPUTATION_MODE)
5780         internal_error ("unsupported wide integer operation");
5781
5782       mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 1)));
5783       if (GET_MODE_CLASS (mode) == MODE_INT
5784           && mode > MAX_INTEGER_COMPUTATION_MODE)
5785         internal_error ("unsupported wide integer operation");
5786     }
5787 }
5788 #endif
5789 \f
5790 /* Return the highest power of two that EXP is known to be a multiple of.
5791    This is used in updating alignment of MEMs in array references.  */
5792
5793 static HOST_WIDE_INT
5794 highest_pow2_factor (exp)
5795      tree exp;
5796 {
5797   HOST_WIDE_INT c0, c1;
5798
5799   switch (TREE_CODE (exp))
5800     {
5801     case INTEGER_CST:
5802       /* If the integer is expressable in a HOST_WIDE_INT, we can find the
5803          lowest bit that's a one.  If the result is zero, return
5804          BIGGEST_ALIGNMENT.  We need to handle this case since we can find it
5805          in a COND_EXPR, a MIN_EXPR, or a MAX_EXPR.  If the constant overlows,
5806          we have an erroneous program, so return BIGGEST_ALIGNMENT to avoid any
5807          later ICE.  */
5808       if (TREE_CONSTANT_OVERFLOW (exp)
5809           || integer_zerop (exp))
5810         return BIGGEST_ALIGNMENT;
5811       else if (host_integerp (exp, 0))
5812         {
5813           c0 = tree_low_cst (exp, 0);
5814           c0 = c0 < 0 ? - c0 : c0;
5815           return c0 & -c0;
5816         }
5817       break;
5818
5819     case PLUS_EXPR:  case MINUS_EXPR:  case MIN_EXPR:  case MAX_EXPR:
5820       c0 = highest_pow2_factor (TREE_OPERAND (exp, 0));
5821       c1 = highest_pow2_factor (TREE_OPERAND (exp, 1));
5822       return MIN (c0, c1);
5823
5824     case MULT_EXPR:
5825       c0 = highest_pow2_factor (TREE_OPERAND (exp, 0));
5826       c1 = highest_pow2_factor (TREE_OPERAND (exp, 1));
5827       return c0 * c1;
5828
5829     case ROUND_DIV_EXPR:  case TRUNC_DIV_EXPR:  case FLOOR_DIV_EXPR:
5830     case CEIL_DIV_EXPR:
5831       if (integer_pow2p (TREE_OPERAND (exp, 1))
5832           && host_integerp (TREE_OPERAND (exp, 1), 1))
5833         {
5834           c0 = highest_pow2_factor (TREE_OPERAND (exp, 0));
5835           c1 = tree_low_cst (TREE_OPERAND (exp, 1), 1);
5836           return MAX (1, c0 / c1);
5837         }
5838       break;
5839
5840     case NON_LVALUE_EXPR:  case NOP_EXPR:  case CONVERT_EXPR:
5841     case SAVE_EXPR: case WITH_RECORD_EXPR:
5842       return highest_pow2_factor (TREE_OPERAND (exp, 0));
5843
5844     case COMPOUND_EXPR:
5845       return highest_pow2_factor (TREE_OPERAND (exp, 1));
5846
5847     case COND_EXPR:
5848       c0 = highest_pow2_factor (TREE_OPERAND (exp, 1));
5849       c1 = highest_pow2_factor (TREE_OPERAND (exp, 2));
5850       return MIN (c0, c1);
5851
5852     default:
5853       break;
5854     }
5855
5856   return 1;
5857 }
5858 \f
5859 /* Return an object on the placeholder list that matches EXP, a
5860    PLACEHOLDER_EXPR.  An object "matches" if it is of the type of the
5861    PLACEHOLDER_EXPR or a pointer type to it.  For further information, see
5862    tree.def.  If no such object is found, return 0.  If PLIST is nonzero, it
5863    is a location which initially points to a starting location in the
5864    placeholder list (zero means start of the list) and where a pointer into
5865    the placeholder list at which the object is found is placed.  */
5866
5867 tree
5868 find_placeholder (exp, plist)
5869      tree exp;
5870      tree *plist;
5871 {
5872   tree type = TREE_TYPE (exp);
5873   tree placeholder_expr;
5874
5875   for (placeholder_expr
5876        = plist && *plist ? TREE_CHAIN (*plist) : placeholder_list;
5877        placeholder_expr != 0;
5878        placeholder_expr = TREE_CHAIN (placeholder_expr))
5879     {
5880       tree need_type = TYPE_MAIN_VARIANT (type);
5881       tree elt;
5882
5883       /* Find the outermost reference that is of the type we want.  If none,
5884          see if any object has a type that is a pointer to the type we
5885          want.  */
5886       for (elt = TREE_PURPOSE (placeholder_expr); elt != 0;
5887            elt = ((TREE_CODE (elt) == COMPOUND_EXPR
5888                    || TREE_CODE (elt) == COND_EXPR)
5889                   ? TREE_OPERAND (elt, 1)
5890                   : (TREE_CODE_CLASS (TREE_CODE (elt)) == 'r'
5891                      || TREE_CODE_CLASS (TREE_CODE (elt)) == '1'
5892                      || TREE_CODE_CLASS (TREE_CODE (elt)) == '2'
5893                      || TREE_CODE_CLASS (TREE_CODE (elt)) == 'e')
5894                   ? TREE_OPERAND (elt, 0) : 0))
5895         if (TYPE_MAIN_VARIANT (TREE_TYPE (elt)) == need_type)
5896           {
5897             if (plist)
5898               *plist = placeholder_expr;
5899             return elt;
5900           }
5901
5902       for (elt = TREE_PURPOSE (placeholder_expr); elt != 0;
5903            elt
5904            = ((TREE_CODE (elt) == COMPOUND_EXPR
5905                || TREE_CODE (elt) == COND_EXPR)
5906               ? TREE_OPERAND (elt, 1)
5907               : (TREE_CODE_CLASS (TREE_CODE (elt)) == 'r'
5908                  || TREE_CODE_CLASS (TREE_CODE (elt)) == '1'
5909                  || TREE_CODE_CLASS (TREE_CODE (elt)) == '2'
5910                  || TREE_CODE_CLASS (TREE_CODE (elt)) == 'e')
5911               ? TREE_OPERAND (elt, 0) : 0))
5912         if (POINTER_TYPE_P (TREE_TYPE (elt))
5913             && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (elt)))
5914                 == need_type))
5915           {
5916             if (plist)
5917               *plist = placeholder_expr;
5918             return build1 (INDIRECT_REF, need_type, elt);
5919           }
5920     }
5921
5922   return 0;
5923 }
5924 \f
5925 /* expand_expr: generate code for computing expression EXP.
5926    An rtx for the computed value is returned.  The value is never null.
5927    In the case of a void EXP, const0_rtx is returned.
5928
5929    The value may be stored in TARGET if TARGET is nonzero.
5930    TARGET is just a suggestion; callers must assume that
5931    the rtx returned may not be the same as TARGET.
5932
5933    If TARGET is CONST0_RTX, it means that the value will be ignored.
5934
5935    If TMODE is not VOIDmode, it suggests generating the
5936    result in mode TMODE.  But this is done only when convenient.
5937    Otherwise, TMODE is ignored and the value generated in its natural mode.
5938    TMODE is just a suggestion; callers must assume that
5939    the rtx returned may not have mode TMODE.
5940
5941    Note that TARGET may have neither TMODE nor MODE.  In that case, it
5942    probably will not be used.
5943
5944    If MODIFIER is EXPAND_SUM then when EXP is an addition
5945    we can return an rtx of the form (MULT (REG ...) (CONST_INT ...))
5946    or a nest of (PLUS ...) and (MINUS ...) where the terms are
5947    products as above, or REG or MEM, or constant.
5948    Ordinarily in such cases we would output mul or add instructions
5949    and then return a pseudo reg containing the sum.
5950
5951    EXPAND_INITIALIZER is much like EXPAND_SUM except that
5952    it also marks a label as absolutely required (it can't be dead).
5953    It also makes a ZERO_EXTEND or SIGN_EXTEND instead of emitting extend insns.
5954    This is used for outputting expressions used in initializers.
5955
5956    EXPAND_CONST_ADDRESS says that it is okay to return a MEM
5957    with a constant address even if that address is not normally legitimate.
5958    EXPAND_INITIALIZER and EXPAND_SUM also have this effect.  */
5959
5960 rtx
5961 expand_expr (exp, target, tmode, modifier)
5962      tree exp;
5963      rtx target;
5964      enum machine_mode tmode;
5965      enum expand_modifier modifier;
5966 {
5967   rtx op0, op1, temp;
5968   tree type = TREE_TYPE (exp);
5969   int unsignedp = TREE_UNSIGNED (type);
5970   enum machine_mode mode;
5971   enum tree_code code = TREE_CODE (exp);
5972   optab this_optab;
5973   rtx subtarget, original_target;
5974   int ignore;
5975   tree context;
5976
5977   /* Handle ERROR_MARK before anybody tries to access its type.  */
5978   if (TREE_CODE (exp) == ERROR_MARK || TREE_CODE (type) == ERROR_MARK)
5979     {
5980       op0 = CONST0_RTX (tmode);
5981       if (op0 != 0)
5982         return op0;
5983       return const0_rtx;
5984     }
5985
5986   mode = TYPE_MODE (type);
5987   /* Use subtarget as the target for operand 0 of a binary operation.  */
5988   subtarget = get_subtarget (target);
5989   original_target = target;
5990   ignore = (target == const0_rtx
5991             || ((code == NON_LVALUE_EXPR || code == NOP_EXPR
5992                  || code == CONVERT_EXPR || code == REFERENCE_EXPR
5993                  || code == COND_EXPR || code == VIEW_CONVERT_EXPR)
5994                 && TREE_CODE (type) == VOID_TYPE));
5995
5996   /* If we are going to ignore this result, we need only do something
5997      if there is a side-effect somewhere in the expression.  If there
5998      is, short-circuit the most common cases here.  Note that we must
5999      not call expand_expr with anything but const0_rtx in case this
6000      is an initial expansion of a size that contains a PLACEHOLDER_EXPR.  */
6001
6002   if (ignore)
6003     {
6004       if (! TREE_SIDE_EFFECTS (exp))
6005         return const0_rtx;
6006
6007       /* Ensure we reference a volatile object even if value is ignored, but
6008          don't do this if all we are doing is taking its address.  */
6009       if (TREE_THIS_VOLATILE (exp)
6010           && TREE_CODE (exp) != FUNCTION_DECL
6011           && mode != VOIDmode && mode != BLKmode
6012           && modifier != EXPAND_CONST_ADDRESS)
6013         {
6014           temp = expand_expr (exp, NULL_RTX, VOIDmode, modifier);
6015           if (GET_CODE (temp) == MEM)
6016             temp = copy_to_reg (temp);
6017           return const0_rtx;
6018         }
6019
6020       if (TREE_CODE_CLASS (code) == '1' || code == COMPONENT_REF
6021           || code == INDIRECT_REF || code == BUFFER_REF)
6022         return expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode,
6023                             modifier);
6024
6025       else if (TREE_CODE_CLASS (code) == '2' || TREE_CODE_CLASS (code) == '<'
6026                || code == ARRAY_REF || code == ARRAY_RANGE_REF)
6027         {
6028           expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode, modifier);
6029           expand_expr (TREE_OPERAND (exp, 1), const0_rtx, VOIDmode, modifier);
6030           return const0_rtx;
6031         }
6032       else if ((code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR)
6033                && ! TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 1)))
6034         /* If the second operand has no side effects, just evaluate
6035            the first.  */
6036         return expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode,
6037                             modifier);
6038       else if (code == BIT_FIELD_REF)
6039         {
6040           expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode, modifier);
6041           expand_expr (TREE_OPERAND (exp, 1), const0_rtx, VOIDmode, modifier);
6042           expand_expr (TREE_OPERAND (exp, 2), const0_rtx, VOIDmode, modifier);
6043           return const0_rtx;
6044         }
6045
6046       target = 0;
6047     }
6048
6049 #ifdef MAX_INTEGER_COMPUTATION_MODE
6050   /* Only check stuff here if the mode we want is different from the mode
6051      of the expression; if it's the same, check_max_integer_computiation_mode
6052      will handle it.  Do we really need to check this stuff at all?  */
6053
6054   if (target
6055       && GET_MODE (target) != mode
6056       && TREE_CODE (exp) != INTEGER_CST
6057       && TREE_CODE (exp) != PARM_DECL
6058       && TREE_CODE (exp) != ARRAY_REF
6059       && TREE_CODE (exp) != ARRAY_RANGE_REF
6060       && TREE_CODE (exp) != COMPONENT_REF
6061       && TREE_CODE (exp) != BIT_FIELD_REF
6062       && TREE_CODE (exp) != INDIRECT_REF
6063       && TREE_CODE (exp) != CALL_EXPR
6064       && TREE_CODE (exp) != VAR_DECL
6065       && TREE_CODE (exp) != RTL_EXPR)
6066     {
6067       enum machine_mode mode = GET_MODE (target);
6068
6069       if (GET_MODE_CLASS (mode) == MODE_INT
6070           && mode > MAX_INTEGER_COMPUTATION_MODE)
6071         internal_error ("unsupported wide integer operation");
6072     }
6073
6074   if (tmode != mode
6075       && TREE_CODE (exp) != INTEGER_CST
6076       && TREE_CODE (exp) != PARM_DECL
6077       && TREE_CODE (exp) != ARRAY_REF
6078       && TREE_CODE (exp) != ARRAY_RANGE_REF
6079       && TREE_CODE (exp) != COMPONENT_REF
6080       && TREE_CODE (exp) != BIT_FIELD_REF
6081       && TREE_CODE (exp) != INDIRECT_REF
6082       && TREE_CODE (exp) != VAR_DECL
6083       && TREE_CODE (exp) != CALL_EXPR
6084       && TREE_CODE (exp) != RTL_EXPR
6085       && GET_MODE_CLASS (tmode) == MODE_INT
6086       && tmode > MAX_INTEGER_COMPUTATION_MODE)
6087     internal_error ("unsupported wide integer operation");
6088
6089   check_max_integer_computation_mode (exp);
6090 #endif
6091
6092   /* If will do cse, generate all results into pseudo registers
6093      since 1) that allows cse to find more things
6094      and 2) otherwise cse could produce an insn the machine
6095      cannot support.  And exception is a CONSTRUCTOR into a multi-word
6096      MEM: that's much more likely to be most efficient into the MEM.  */
6097
6098   if (! cse_not_expected && mode != BLKmode && target
6099       && (GET_CODE (target) != REG || REGNO (target) < FIRST_PSEUDO_REGISTER)
6100       && ! (code == CONSTRUCTOR && GET_MODE_SIZE (mode) > UNITS_PER_WORD))
6101     target = subtarget;
6102
6103   switch (code)
6104     {
6105     case LABEL_DECL:
6106       {
6107         tree function = decl_function_context (exp);
6108         /* Handle using a label in a containing function.  */
6109         if (function != current_function_decl
6110             && function != inline_function_decl && function != 0)
6111           {
6112             struct function *p = find_function_data (function);
6113             p->expr->x_forced_labels
6114               = gen_rtx_EXPR_LIST (VOIDmode, label_rtx (exp),
6115                                    p->expr->x_forced_labels);
6116           }
6117         else
6118           {
6119             if (modifier == EXPAND_INITIALIZER)
6120               forced_labels = gen_rtx_EXPR_LIST (VOIDmode,
6121                                                  label_rtx (exp),
6122                                                  forced_labels);
6123           }
6124
6125         temp = gen_rtx_MEM (FUNCTION_MODE,
6126                             gen_rtx_LABEL_REF (Pmode, label_rtx (exp)));
6127         if (function != current_function_decl
6128             && function != inline_function_decl && function != 0)
6129           LABEL_REF_NONLOCAL_P (XEXP (temp, 0)) = 1;
6130         return temp;
6131       }
6132
6133     case PARM_DECL:
6134       if (DECL_RTL (exp) == 0)
6135         {
6136           error_with_decl (exp, "prior parameter's size depends on `%s'");
6137           return CONST0_RTX (mode);
6138         }
6139
6140       /* ... fall through ...  */
6141
6142     case VAR_DECL:
6143       /* If a static var's type was incomplete when the decl was written,
6144          but the type is complete now, lay out the decl now.  */
6145       if (DECL_SIZE (exp) == 0 && COMPLETE_TYPE_P (TREE_TYPE (exp))
6146           && (TREE_STATIC (exp) || DECL_EXTERNAL (exp)))
6147         {
6148           rtx value = DECL_RTL_IF_SET (exp);
6149
6150           layout_decl (exp, 0);
6151
6152           /* If the RTL was already set, update its mode and memory
6153              attributes.  */
6154           if (value != 0)
6155             {
6156               PUT_MODE (value, DECL_MODE (exp));
6157               SET_DECL_RTL (exp, 0);
6158               set_mem_attributes (value, exp, 1);
6159               SET_DECL_RTL (exp, value);
6160             }
6161         }
6162
6163       /* ... fall through ...  */
6164
6165     case FUNCTION_DECL:
6166     case RESULT_DECL:
6167       if (DECL_RTL (exp) == 0)
6168         abort ();
6169
6170       /* Ensure variable marked as used even if it doesn't go through
6171          a parser.  If it hasn't be used yet, write out an external
6172          definition.  */
6173       if (! TREE_USED (exp))
6174         {
6175           assemble_external (exp);
6176           TREE_USED (exp) = 1;
6177         }
6178
6179       /* Show we haven't gotten RTL for this yet.  */
6180       temp = 0;
6181
6182       /* Handle variables inherited from containing functions.  */
6183       context = decl_function_context (exp);
6184
6185       /* We treat inline_function_decl as an alias for the current function
6186          because that is the inline function whose vars, types, etc.
6187          are being merged into the current function.
6188          See expand_inline_function.  */
6189
6190       if (context != 0 && context != current_function_decl
6191           && context != inline_function_decl
6192           /* If var is static, we don't need a static chain to access it.  */
6193           && ! (GET_CODE (DECL_RTL (exp)) == MEM
6194                 && CONSTANT_P (XEXP (DECL_RTL (exp), 0))))
6195         {
6196           rtx addr;
6197
6198           /* Mark as non-local and addressable.  */
6199           DECL_NONLOCAL (exp) = 1;
6200           if (DECL_NO_STATIC_CHAIN (current_function_decl))
6201             abort ();
6202           mark_addressable (exp);
6203           if (GET_CODE (DECL_RTL (exp)) != MEM)
6204             abort ();
6205           addr = XEXP (DECL_RTL (exp), 0);
6206           if (GET_CODE (addr) == MEM)
6207             addr
6208               = replace_equiv_address (addr,
6209                                        fix_lexical_addr (XEXP (addr, 0), exp));
6210           else
6211             addr = fix_lexical_addr (addr, exp);
6212
6213           temp = replace_equiv_address (DECL_RTL (exp), addr);
6214         }
6215
6216       /* This is the case of an array whose size is to be determined
6217          from its initializer, while the initializer is still being parsed.
6218          See expand_decl.  */
6219
6220       else if (GET_CODE (DECL_RTL (exp)) == MEM
6221                && GET_CODE (XEXP (DECL_RTL (exp), 0)) == REG)
6222         temp = validize_mem (DECL_RTL (exp));
6223
6224       /* If DECL_RTL is memory, we are in the normal case and either
6225          the address is not valid or it is not a register and -fforce-addr
6226          is specified, get the address into a register.  */
6227
6228       else if (GET_CODE (DECL_RTL (exp)) == MEM
6229                && modifier != EXPAND_CONST_ADDRESS
6230                && modifier != EXPAND_SUM
6231                && modifier != EXPAND_INITIALIZER
6232                && (! memory_address_p (DECL_MODE (exp),
6233                                        XEXP (DECL_RTL (exp), 0))
6234                    || (flag_force_addr
6235                        && GET_CODE (XEXP (DECL_RTL (exp), 0)) != REG)))
6236         temp = replace_equiv_address (DECL_RTL (exp),
6237                                       copy_rtx (XEXP (DECL_RTL (exp), 0)));
6238
6239       /* If we got something, return it.  But first, set the alignment
6240          if the address is a register.  */
6241       if (temp != 0)
6242         {
6243           if (GET_CODE (temp) == MEM && GET_CODE (XEXP (temp, 0)) == REG)
6244             mark_reg_pointer (XEXP (temp, 0), DECL_ALIGN (exp));
6245
6246           return temp;
6247         }
6248
6249       /* If the mode of DECL_RTL does not match that of the decl, it
6250          must be a promoted value.  We return a SUBREG of the wanted mode,
6251          but mark it so that we know that it was already extended.  */
6252
6253       if (GET_CODE (DECL_RTL (exp)) == REG
6254           && GET_MODE (DECL_RTL (exp)) != DECL_MODE (exp))
6255         {
6256           /* Get the signedness used for this variable.  Ensure we get the
6257              same mode we got when the variable was declared.  */
6258           if (GET_MODE (DECL_RTL (exp))
6259               != promote_mode (type, DECL_MODE (exp), &unsignedp, 0))
6260             abort ();
6261
6262           temp = gen_lowpart_SUBREG (mode, DECL_RTL (exp));
6263           SUBREG_PROMOTED_VAR_P (temp) = 1;
6264           SUBREG_PROMOTED_UNSIGNED_P (temp) = unsignedp;
6265           return temp;
6266         }
6267
6268       return DECL_RTL (exp);
6269
6270     case INTEGER_CST:
6271       return immed_double_const (TREE_INT_CST_LOW (exp),
6272                                  TREE_INT_CST_HIGH (exp), mode);
6273
6274     case CONST_DECL:
6275       return expand_expr (DECL_INITIAL (exp), target, VOIDmode, 0);
6276
6277     case REAL_CST:
6278       /* If optimized, generate immediate CONST_DOUBLE
6279          which will be turned into memory by reload if necessary.
6280
6281          We used to force a register so that loop.c could see it.  But
6282          this does not allow gen_* patterns to perform optimizations with
6283          the constants.  It also produces two insns in cases like "x = 1.0;".
6284          On most machines, floating-point constants are not permitted in
6285          many insns, so we'd end up copying it to a register in any case.
6286
6287          Now, we do the copying in expand_binop, if appropriate.  */
6288       return immed_real_const (exp);
6289
6290     case COMPLEX_CST:
6291     case STRING_CST:
6292       if (! TREE_CST_RTL (exp))
6293         output_constant_def (exp, 1);
6294
6295       /* TREE_CST_RTL probably contains a constant address.
6296          On RISC machines where a constant address isn't valid,
6297          make some insns to get that address into a register.  */
6298       if (GET_CODE (TREE_CST_RTL (exp)) == MEM
6299           && modifier != EXPAND_CONST_ADDRESS
6300           && modifier != EXPAND_INITIALIZER
6301           && modifier != EXPAND_SUM
6302           && (! memory_address_p (mode, XEXP (TREE_CST_RTL (exp), 0))
6303               || (flag_force_addr
6304                   && GET_CODE (XEXP (TREE_CST_RTL (exp), 0)) != REG)))
6305         return replace_equiv_address (TREE_CST_RTL (exp),
6306                                       copy_rtx (XEXP (TREE_CST_RTL (exp), 0)));
6307       return TREE_CST_RTL (exp);
6308
6309     case EXPR_WITH_FILE_LOCATION:
6310       {
6311         rtx to_return;
6312         const char *saved_input_filename = input_filename;
6313         int saved_lineno = lineno;
6314         input_filename = EXPR_WFL_FILENAME (exp);
6315         lineno = EXPR_WFL_LINENO (exp);
6316         if (EXPR_WFL_EMIT_LINE_NOTE (exp))
6317           emit_line_note (input_filename, lineno);
6318         /* Possibly avoid switching back and forth here.  */
6319         to_return = expand_expr (EXPR_WFL_NODE (exp), target, tmode, modifier);
6320         input_filename = saved_input_filename;
6321         lineno = saved_lineno;
6322         return to_return;
6323       }
6324
6325     case SAVE_EXPR:
6326       context = decl_function_context (exp);
6327
6328       /* If this SAVE_EXPR was at global context, assume we are an
6329          initialization function and move it into our context.  */
6330       if (context == 0)
6331         SAVE_EXPR_CONTEXT (exp) = current_function_decl;
6332
6333       /* We treat inline_function_decl as an alias for the current function
6334          because that is the inline function whose vars, types, etc.
6335          are being merged into the current function.
6336          See expand_inline_function.  */
6337       if (context == current_function_decl || context == inline_function_decl)
6338         context = 0;
6339
6340       /* If this is non-local, handle it.  */
6341       if (context)
6342         {
6343           /* The following call just exists to abort if the context is
6344              not of a containing function.  */
6345           find_function_data (context);
6346
6347           temp = SAVE_EXPR_RTL (exp);
6348           if (temp && GET_CODE (temp) == REG)
6349             {
6350               put_var_into_stack (exp);
6351               temp = SAVE_EXPR_RTL (exp);
6352             }
6353           if (temp == 0 || GET_CODE (temp) != MEM)
6354             abort ();
6355           return
6356             replace_equiv_address (temp,
6357                                    fix_lexical_addr (XEXP (temp, 0), exp));
6358         }
6359       if (SAVE_EXPR_RTL (exp) == 0)
6360         {
6361           if (mode == VOIDmode)
6362             temp = const0_rtx;
6363           else
6364             temp = assign_temp (build_qualified_type (type,
6365                                                       (TYPE_QUALS (type)
6366                                                        | TYPE_QUAL_CONST)),
6367                                 3, 0, 0);
6368
6369           SAVE_EXPR_RTL (exp) = temp;
6370           if (!optimize && GET_CODE (temp) == REG)
6371             save_expr_regs = gen_rtx_EXPR_LIST (VOIDmode, temp,
6372                                                 save_expr_regs);
6373
6374           /* If the mode of TEMP does not match that of the expression, it
6375              must be a promoted value.  We pass store_expr a SUBREG of the
6376              wanted mode but mark it so that we know that it was already
6377              extended.  Note that `unsignedp' was modified above in
6378              this case.  */
6379
6380           if (GET_CODE (temp) == REG && GET_MODE (temp) != mode)
6381             {
6382               temp = gen_lowpart_SUBREG (mode, SAVE_EXPR_RTL (exp));
6383               SUBREG_PROMOTED_VAR_P (temp) = 1;
6384               SUBREG_PROMOTED_UNSIGNED_P (temp) = unsignedp;
6385             }
6386
6387           if (temp == const0_rtx)
6388             expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode, 0);
6389           else
6390             store_expr (TREE_OPERAND (exp, 0), temp, 0);
6391
6392           TREE_USED (exp) = 1;
6393         }
6394
6395       /* If the mode of SAVE_EXPR_RTL does not match that of the expression, it
6396          must be a promoted value.  We return a SUBREG of the wanted mode,
6397          but mark it so that we know that it was already extended.  */
6398
6399       if (GET_CODE (SAVE_EXPR_RTL (exp)) == REG
6400           && GET_MODE (SAVE_EXPR_RTL (exp)) != mode)
6401         {
6402           /* Compute the signedness and make the proper SUBREG.  */
6403           promote_mode (type, mode, &unsignedp, 0);
6404           temp = gen_lowpart_SUBREG (mode, SAVE_EXPR_RTL (exp));
6405           SUBREG_PROMOTED_VAR_P (temp) = 1;
6406           SUBREG_PROMOTED_UNSIGNED_P (temp) = unsignedp;
6407           return temp;
6408         }
6409
6410       return SAVE_EXPR_RTL (exp);
6411
6412     case UNSAVE_EXPR:
6413       {
6414         rtx temp;
6415         temp = expand_expr (TREE_OPERAND (exp, 0), target, tmode, modifier);
6416         TREE_OPERAND (exp, 0) = unsave_expr_now (TREE_OPERAND (exp, 0));
6417         return temp;
6418       }
6419
6420     case PLACEHOLDER_EXPR:
6421       {
6422         tree old_list = placeholder_list;
6423         tree placeholder_expr = 0;
6424
6425         exp = find_placeholder (exp, &placeholder_expr);
6426         if (exp == 0)
6427           abort ();
6428
6429         placeholder_list = TREE_CHAIN (placeholder_expr);
6430         temp = expand_expr (exp, original_target, tmode, modifier);
6431         placeholder_list = old_list;
6432         return temp;
6433       }
6434
6435       /* We can't find the object or there was a missing WITH_RECORD_EXPR.  */
6436       abort ();
6437
6438     case WITH_RECORD_EXPR:
6439       /* Put the object on the placeholder list, expand our first operand,
6440          and pop the list.  */
6441       placeholder_list = tree_cons (TREE_OPERAND (exp, 1), NULL_TREE,
6442                                     placeholder_list);
6443       target = expand_expr (TREE_OPERAND (exp, 0), original_target, tmode,
6444                             modifier);
6445       placeholder_list = TREE_CHAIN (placeholder_list);
6446       return target;
6447
6448     case GOTO_EXPR:
6449       if (TREE_CODE (TREE_OPERAND (exp, 0)) == LABEL_DECL)
6450         expand_goto (TREE_OPERAND (exp, 0));
6451       else
6452         expand_computed_goto (TREE_OPERAND (exp, 0));
6453       return const0_rtx;
6454
6455     case EXIT_EXPR:
6456       expand_exit_loop_if_false (NULL,
6457                                  invert_truthvalue (TREE_OPERAND (exp, 0)));
6458       return const0_rtx;
6459
6460     case LABELED_BLOCK_EXPR:
6461       if (LABELED_BLOCK_BODY (exp))
6462         expand_expr_stmt_value (LABELED_BLOCK_BODY (exp), 0, 1);
6463       /* Should perhaps use expand_label, but this is simpler and safer.  */
6464       do_pending_stack_adjust ();
6465       emit_label (label_rtx (LABELED_BLOCK_LABEL (exp)));
6466       return const0_rtx;
6467
6468     case EXIT_BLOCK_EXPR:
6469       if (EXIT_BLOCK_RETURN (exp))
6470         sorry ("returned value in block_exit_expr");
6471       expand_goto (LABELED_BLOCK_LABEL (EXIT_BLOCK_LABELED_BLOCK (exp)));
6472       return const0_rtx;
6473
6474     case LOOP_EXPR:
6475       push_temp_slots ();
6476       expand_start_loop (1);
6477       expand_expr_stmt_value (TREE_OPERAND (exp, 0), 0, 1);
6478       expand_end_loop ();
6479       pop_temp_slots ();
6480
6481       return const0_rtx;
6482
6483     case BIND_EXPR:
6484       {
6485         tree vars = TREE_OPERAND (exp, 0);
6486         int vars_need_expansion = 0;
6487
6488         /* Need to open a binding contour here because
6489            if there are any cleanups they must be contained here.  */
6490         expand_start_bindings (2);
6491
6492         /* Mark the corresponding BLOCK for output in its proper place.  */
6493         if (TREE_OPERAND (exp, 2) != 0
6494             && ! TREE_USED (TREE_OPERAND (exp, 2)))
6495           insert_block (TREE_OPERAND (exp, 2));
6496
6497         /* If VARS have not yet been expanded, expand them now.  */
6498         while (vars)
6499           {
6500             if (!DECL_RTL_SET_P (vars))
6501               {
6502                 vars_need_expansion = 1;
6503                 expand_decl (vars);
6504               }
6505             expand_decl_init (vars);
6506             vars = TREE_CHAIN (vars);
6507           }
6508
6509         temp = expand_expr (TREE_OPERAND (exp, 1), target, tmode, modifier);
6510
6511         expand_end_bindings (TREE_OPERAND (exp, 0), 0, 0);
6512
6513         return temp;
6514       }
6515
6516     case RTL_EXPR:
6517       if (RTL_EXPR_SEQUENCE (exp))
6518         {
6519           if (RTL_EXPR_SEQUENCE (exp) == const0_rtx)
6520             abort ();
6521           emit_insns (RTL_EXPR_SEQUENCE (exp));
6522           RTL_EXPR_SEQUENCE (exp) = const0_rtx;
6523         }
6524       preserve_rtl_expr_result (RTL_EXPR_RTL (exp));
6525       free_temps_for_rtl_expr (exp);
6526       return RTL_EXPR_RTL (exp);
6527
6528     case CONSTRUCTOR:
6529       /* If we don't need the result, just ensure we evaluate any
6530          subexpressions.  */
6531       if (ignore)
6532         {
6533           tree elt;
6534
6535           for (elt = CONSTRUCTOR_ELTS (exp); elt; elt = TREE_CHAIN (elt))
6536             expand_expr (TREE_VALUE (elt), const0_rtx, VOIDmode, 0);
6537
6538           return const0_rtx;
6539         }
6540
6541       /* All elts simple constants => refer to a constant in memory.  But
6542          if this is a non-BLKmode mode, let it store a field at a time
6543          since that should make a CONST_INT or CONST_DOUBLE when we
6544          fold.  Likewise, if we have a target we can use, it is best to
6545          store directly into the target unless the type is large enough
6546          that memcpy will be used.  If we are making an initializer and
6547          all operands are constant, put it in memory as well.  */
6548       else if ((TREE_STATIC (exp)
6549                 && ((mode == BLKmode
6550                      && ! (target != 0 && safe_from_p (target, exp, 1)))
6551                     || TREE_ADDRESSABLE (exp)
6552                     || (host_integerp (TYPE_SIZE_UNIT (type), 1)
6553                         && (! MOVE_BY_PIECES_P
6554                             (tree_low_cst (TYPE_SIZE_UNIT (type), 1),
6555                              TYPE_ALIGN (type)))
6556                         && ! mostly_zeros_p (exp))))
6557                || (modifier == EXPAND_INITIALIZER && TREE_CONSTANT (exp)))
6558         {
6559           rtx constructor = output_constant_def (exp, 1);
6560
6561           if (modifier != EXPAND_CONST_ADDRESS
6562               && modifier != EXPAND_INITIALIZER
6563               && modifier != EXPAND_SUM)
6564             constructor = validize_mem (constructor);
6565
6566           return constructor;
6567         }
6568       else
6569         {
6570           /* Handle calls that pass values in multiple non-contiguous
6571              locations.  The Irix 6 ABI has examples of this.  */
6572           if (target == 0 || ! safe_from_p (target, exp, 1)
6573               || GET_CODE (target) == PARALLEL)
6574             target
6575               = assign_temp (build_qualified_type (type,
6576                                                    (TYPE_QUALS (type)
6577                                                     | (TREE_READONLY (exp)
6578                                                        * TYPE_QUAL_CONST))),
6579                              0, TREE_ADDRESSABLE (exp), 1);
6580
6581           store_constructor (exp, target, 0,
6582                              int_size_in_bytes (TREE_TYPE (exp)));
6583           return target;
6584         }
6585
6586     case INDIRECT_REF:
6587       {
6588         tree exp1 = TREE_OPERAND (exp, 0);
6589         tree index;
6590         tree string = string_constant (exp1, &index);
6591
6592         /* Try to optimize reads from const strings.  */
6593         if (string
6594             && TREE_CODE (string) == STRING_CST
6595             && TREE_CODE (index) == INTEGER_CST
6596             && compare_tree_int (index, TREE_STRING_LENGTH (string)) < 0
6597             && GET_MODE_CLASS (mode) == MODE_INT
6598             && GET_MODE_SIZE (mode) == 1
6599             && modifier != EXPAND_WRITE)
6600           return
6601             GEN_INT (TREE_STRING_POINTER (string)[TREE_INT_CST_LOW (index)]);
6602
6603         op0 = expand_expr (exp1, NULL_RTX, VOIDmode, EXPAND_SUM);
6604         op0 = memory_address (mode, op0);
6605         temp = gen_rtx_MEM (mode, op0);
6606         set_mem_attributes (temp, exp, 0);
6607
6608         /* If we are writing to this object and its type is a record with
6609            readonly fields, we must mark it as readonly so it will
6610            conflict with readonly references to those fields.  */
6611         if (modifier == EXPAND_WRITE && readonly_fields_p (type))
6612           RTX_UNCHANGING_P (temp) = 1;
6613
6614         return temp;
6615       }
6616
6617     case ARRAY_REF:
6618       if (TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) != ARRAY_TYPE)
6619         abort ();
6620
6621       {
6622         tree array = TREE_OPERAND (exp, 0);
6623         tree domain = TYPE_DOMAIN (TREE_TYPE (array));
6624         tree low_bound = domain ? TYPE_MIN_VALUE (domain) : integer_zero_node;
6625         tree index = convert (sizetype, TREE_OPERAND (exp, 1));
6626         HOST_WIDE_INT i;
6627
6628         /* Optimize the special-case of a zero lower bound.
6629
6630            We convert the low_bound to sizetype to avoid some problems
6631            with constant folding.  (E.g. suppose the lower bound is 1,
6632            and its mode is QI.  Without the conversion,  (ARRAY
6633            +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
6634            +INDEX), which becomes (ARRAY+255+INDEX).  Oops!)  */
6635
6636         if (! integer_zerop (low_bound))
6637           index = size_diffop (index, convert (sizetype, low_bound));
6638
6639         /* Fold an expression like: "foo"[2].
6640            This is not done in fold so it won't happen inside &.
6641            Don't fold if this is for wide characters since it's too
6642            difficult to do correctly and this is a very rare case.  */
6643
6644         if (modifier != EXPAND_CONST_ADDRESS && modifier != EXPAND_INITIALIZER
6645             && TREE_CODE (array) == STRING_CST
6646             && TREE_CODE (index) == INTEGER_CST
6647             && compare_tree_int (index, TREE_STRING_LENGTH (array)) < 0
6648             && GET_MODE_CLASS (mode) == MODE_INT
6649             && GET_MODE_SIZE (mode) == 1)
6650           return
6651             GEN_INT (TREE_STRING_POINTER (array)[TREE_INT_CST_LOW (index)]);
6652
6653         /* If this is a constant index into a constant array,
6654            just get the value from the array.  Handle both the cases when
6655            we have an explicit constructor and when our operand is a variable
6656            that was declared const.  */
6657
6658         if (modifier != EXPAND_CONST_ADDRESS && modifier != EXPAND_INITIALIZER
6659             && TREE_CODE (array) == CONSTRUCTOR && ! TREE_SIDE_EFFECTS (array)
6660             && TREE_CODE (index) == INTEGER_CST
6661             && 0 > compare_tree_int (index,
6662                                      list_length (CONSTRUCTOR_ELTS
6663                                                   (TREE_OPERAND (exp, 0)))))
6664           {
6665             tree elem;
6666
6667             for (elem = CONSTRUCTOR_ELTS (TREE_OPERAND (exp, 0)),
6668                  i = TREE_INT_CST_LOW (index);
6669                  elem != 0 && i != 0; i--, elem = TREE_CHAIN (elem))
6670               ;
6671
6672             if (elem)
6673               return expand_expr (fold (TREE_VALUE (elem)), target, tmode,
6674                                   modifier);
6675           }
6676
6677         else if (optimize >= 1
6678                  && modifier != EXPAND_CONST_ADDRESS
6679                  && modifier != EXPAND_INITIALIZER
6680                  && TREE_READONLY (array) && ! TREE_SIDE_EFFECTS (array)
6681                  && TREE_CODE (array) == VAR_DECL && DECL_INITIAL (array)
6682                  && TREE_CODE (DECL_INITIAL (array)) != ERROR_MARK)
6683           {
6684             if (TREE_CODE (index) == INTEGER_CST)
6685               {
6686                 tree init = DECL_INITIAL (array);
6687
6688                 if (TREE_CODE (init) == CONSTRUCTOR)
6689                   {
6690                     tree elem;
6691
6692                     for (elem = CONSTRUCTOR_ELTS (init);
6693                          (elem
6694                           && !tree_int_cst_equal (TREE_PURPOSE (elem), index));
6695                          elem = TREE_CHAIN (elem))
6696                       ;
6697
6698                     if (elem && !TREE_SIDE_EFFECTS (TREE_VALUE (elem)))
6699                       return expand_expr (fold (TREE_VALUE (elem)), target,
6700                                           tmode, modifier);
6701                   }
6702                 else if (TREE_CODE (init) == STRING_CST
6703                          && 0 > compare_tree_int (index,
6704                                                   TREE_STRING_LENGTH (init)))
6705                   {
6706                     tree type = TREE_TYPE (TREE_TYPE (init));
6707                     enum machine_mode mode = TYPE_MODE (type);
6708
6709                     if (GET_MODE_CLASS (mode) == MODE_INT
6710                         && GET_MODE_SIZE (mode) == 1)
6711                       return (GEN_INT
6712                               (TREE_STRING_POINTER
6713                                (init)[TREE_INT_CST_LOW (index)]));
6714                   }
6715               }
6716           }
6717       }
6718       /* Fall through.  */
6719
6720     case COMPONENT_REF:
6721     case BIT_FIELD_REF:
6722     case ARRAY_RANGE_REF:
6723       /* If the operand is a CONSTRUCTOR, we can just extract the
6724          appropriate field if it is present.  Don't do this if we have
6725          already written the data since we want to refer to that copy
6726          and varasm.c assumes that's what we'll do.  */
6727       if (code == COMPONENT_REF
6728           && TREE_CODE (TREE_OPERAND (exp, 0)) == CONSTRUCTOR
6729           && TREE_CST_RTL (TREE_OPERAND (exp, 0)) == 0)
6730         {
6731           tree elt;
6732
6733           for (elt = CONSTRUCTOR_ELTS (TREE_OPERAND (exp, 0)); elt;
6734                elt = TREE_CHAIN (elt))
6735             if (TREE_PURPOSE (elt) == TREE_OPERAND (exp, 1)
6736                 /* We can normally use the value of the field in the
6737                    CONSTRUCTOR.  However, if this is a bitfield in
6738                    an integral mode that we can fit in a HOST_WIDE_INT,
6739                    we must mask only the number of bits in the bitfield,
6740                    since this is done implicitly by the constructor.  If
6741                    the bitfield does not meet either of those conditions,
6742                    we can't do this optimization.  */
6743                 && (! DECL_BIT_FIELD (TREE_PURPOSE (elt))
6744                     || ((GET_MODE_CLASS (DECL_MODE (TREE_PURPOSE (elt)))
6745                          == MODE_INT)
6746                         && (GET_MODE_BITSIZE (DECL_MODE (TREE_PURPOSE (elt)))
6747                             <= HOST_BITS_PER_WIDE_INT))))
6748               {
6749                 op0 = expand_expr (TREE_VALUE (elt), target, tmode, modifier);
6750                 if (DECL_BIT_FIELD (TREE_PURPOSE (elt)))
6751                   {
6752                     HOST_WIDE_INT bitsize
6753                       = TREE_INT_CST_LOW (DECL_SIZE (TREE_PURPOSE (elt)));
6754
6755                     if (TREE_UNSIGNED (TREE_TYPE (TREE_PURPOSE (elt))))
6756                       {
6757                         op1 = GEN_INT (((HOST_WIDE_INT) 1 << bitsize) - 1);
6758                         op0 = expand_and (op0, op1, target);
6759                       }
6760                     else
6761                       {
6762                         enum machine_mode imode
6763                           = TYPE_MODE (TREE_TYPE (TREE_PURPOSE (elt)));
6764                         tree count
6765                           = build_int_2 (GET_MODE_BITSIZE (imode) - bitsize,
6766                                          0);
6767
6768                         op0 = expand_shift (LSHIFT_EXPR, imode, op0, count,
6769                                             target, 0);
6770                         op0 = expand_shift (RSHIFT_EXPR, imode, op0, count,
6771                                             target, 0);
6772                       }
6773                   }
6774
6775                 return op0;
6776               }
6777         }
6778
6779       {
6780         enum machine_mode mode1;
6781         HOST_WIDE_INT bitsize, bitpos;
6782         tree offset;
6783         int volatilep = 0;
6784         tree tem = get_inner_reference (exp, &bitsize, &bitpos, &offset,
6785                                         &mode1, &unsignedp, &volatilep);
6786         rtx orig_op0;
6787
6788         /* If we got back the original object, something is wrong.  Perhaps
6789            we are evaluating an expression too early.  In any event, don't
6790            infinitely recurse.  */
6791         if (tem == exp)
6792           abort ();
6793
6794         /* If TEM's type is a union of variable size, pass TARGET to the inner
6795            computation, since it will need a temporary and TARGET is known
6796            to have to do.  This occurs in unchecked conversion in Ada.  */
6797
6798         orig_op0 = op0
6799           = expand_expr (tem,
6800                          (TREE_CODE (TREE_TYPE (tem)) == UNION_TYPE
6801                           && (TREE_CODE (TYPE_SIZE (TREE_TYPE (tem)))
6802                               != INTEGER_CST)
6803                           ? target : NULL_RTX),
6804                          VOIDmode,
6805                          (modifier == EXPAND_INITIALIZER
6806                           || modifier == EXPAND_CONST_ADDRESS)
6807                          ? modifier : EXPAND_NORMAL);
6808
6809         /* If this is a constant, put it into a register if it is a
6810            legitimate constant and OFFSET is 0 and memory if it isn't.  */
6811         if (CONSTANT_P (op0))
6812           {
6813             enum machine_mode mode = TYPE_MODE (TREE_TYPE (tem));
6814             if (mode != BLKmode && LEGITIMATE_CONSTANT_P (op0)
6815                 && offset == 0)
6816               op0 = force_reg (mode, op0);
6817             else
6818               op0 = validize_mem (force_const_mem (mode, op0));
6819           }
6820
6821         if (offset != 0)
6822           {
6823             rtx offset_rtx = expand_expr (offset, NULL_RTX, VOIDmode, 0);
6824
6825             /* If this object is in a register, put it into memory.
6826                This case can't occur in C, but can in Ada if we have
6827                unchecked conversion of an expression from a scalar type to
6828                an array or record type.  */
6829             if (GET_CODE (op0) == REG || GET_CODE (op0) == SUBREG
6830                 || GET_CODE (op0) == CONCAT || GET_CODE (op0) == ADDRESSOF)
6831               {
6832                 /* If the operand is a SAVE_EXPR, we can deal with this by
6833                    forcing the SAVE_EXPR into memory.  */
6834                 if (TREE_CODE (TREE_OPERAND (exp, 0)) == SAVE_EXPR)
6835                   {
6836                     put_var_into_stack (TREE_OPERAND (exp, 0));
6837                     op0 = SAVE_EXPR_RTL (TREE_OPERAND (exp, 0));
6838                   }
6839                 else
6840                   {
6841                     tree nt
6842                       = build_qualified_type (TREE_TYPE (tem),
6843                                               (TYPE_QUALS (TREE_TYPE (tem))
6844                                                | TYPE_QUAL_CONST));
6845                     rtx memloc = assign_temp (nt, 1, 1, 1);
6846
6847                     emit_move_insn (memloc, op0);
6848                     op0 = memloc;
6849                   }
6850               }
6851
6852             if (GET_CODE (op0) != MEM)
6853               abort ();
6854
6855             if (GET_MODE (offset_rtx) != ptr_mode)
6856               offset_rtx = convert_to_mode (ptr_mode, offset_rtx, 0);
6857
6858 #ifdef POINTERS_EXTEND_UNSIGNED
6859             if (GET_MODE (offset_rtx) != Pmode)
6860               offset_rtx = convert_memory_address (Pmode, offset_rtx);
6861 #endif
6862
6863             /* A constant address in OP0 can have VOIDmode, we must not try
6864                to call force_reg for that case.  Avoid that case.  */
6865             if (GET_CODE (op0) == MEM
6866                 && GET_MODE (op0) == BLKmode
6867                 && GET_MODE (XEXP (op0, 0)) != VOIDmode
6868                 && bitsize != 0
6869                 && (bitpos % bitsize) == 0
6870                 && (bitsize % GET_MODE_ALIGNMENT (mode1)) == 0
6871                 && MEM_ALIGN (op0) == GET_MODE_ALIGNMENT (mode1))
6872               {
6873                 rtx temp = adjust_address (op0, mode1, bitpos / BITS_PER_UNIT);
6874
6875                 if (GET_CODE (XEXP (temp, 0)) == REG)
6876                   op0 = temp;
6877                 else
6878                   op0 = (replace_equiv_address
6879                          (op0,
6880                           force_reg (GET_MODE (XEXP (temp, 0)),
6881                                      XEXP (temp, 0))));
6882                 bitpos = 0;
6883               }
6884
6885             op0 = offset_address (op0, offset_rtx,
6886                                   highest_pow2_factor (offset));
6887           }
6888
6889         /* Don't forget about volatility even if this is a bitfield.  */
6890         if (GET_CODE (op0) == MEM && volatilep && ! MEM_VOLATILE_P (op0))
6891           {
6892             if (op0 == orig_op0)
6893               op0 = copy_rtx (op0);
6894
6895             MEM_VOLATILE_P (op0) = 1;
6896           }
6897
6898         /* In cases where an aligned union has an unaligned object
6899            as a field, we might be extracting a BLKmode value from
6900            an integer-mode (e.g., SImode) object.  Handle this case
6901            by doing the extract into an object as wide as the field
6902            (which we know to be the width of a basic mode), then
6903            storing into memory, and changing the mode to BLKmode.  */
6904         if (mode1 == VOIDmode
6905             || GET_CODE (op0) == REG || GET_CODE (op0) == SUBREG
6906             || (mode1 != BLKmode && ! direct_load[(int) mode1]
6907                 && GET_MODE_CLASS (mode) != MODE_COMPLEX_INT
6908                 && GET_MODE_CLASS (mode) != MODE_COMPLEX_FLOAT
6909                 && modifier != EXPAND_CONST_ADDRESS
6910                 && modifier != EXPAND_INITIALIZER)
6911             /* If the field isn't aligned enough to fetch as a memref,
6912                fetch it as a bit field.  */
6913             || (mode1 != BLKmode
6914                 && SLOW_UNALIGNED_ACCESS (mode1, MEM_ALIGN (op0))
6915                 && ((TYPE_ALIGN (TREE_TYPE (tem))
6916                      < GET_MODE_ALIGNMENT (mode))
6917                     || (bitpos % GET_MODE_ALIGNMENT (mode) != 0)))
6918             /* If the type and the field are a constant size and the
6919                size of the type isn't the same size as the bitfield,
6920                we must use bitfield operations.  */
6921             || (bitsize >= 0
6922                 && (TREE_CODE (TYPE_SIZE (TREE_TYPE (exp)))
6923                     == INTEGER_CST)
6924                 && 0 != compare_tree_int (TYPE_SIZE (TREE_TYPE (exp)),
6925                                           bitsize)))
6926           {
6927             enum machine_mode ext_mode = mode;
6928
6929             if (ext_mode == BLKmode
6930                 && ! (target != 0 && GET_CODE (op0) == MEM
6931                       && GET_CODE (target) == MEM
6932                       && bitpos % BITS_PER_UNIT == 0))
6933               ext_mode = mode_for_size (bitsize, MODE_INT, 1);
6934
6935             if (ext_mode == BLKmode)
6936               {
6937                 /* In this case, BITPOS must start at a byte boundary and
6938                    TARGET, if specified, must be a MEM.  */
6939                 if (GET_CODE (op0) != MEM
6940                     || (target != 0 && GET_CODE (target) != MEM)
6941                     || bitpos % BITS_PER_UNIT != 0)
6942                   abort ();
6943
6944                 op0 = adjust_address (op0, VOIDmode, bitpos / BITS_PER_UNIT);
6945                 if (target == 0)
6946                   target = assign_temp (type, 0, 1, 1);
6947
6948                 emit_block_move (target, op0,
6949                                  GEN_INT ((bitsize + BITS_PER_UNIT - 1)
6950                                           / BITS_PER_UNIT));
6951
6952                 return target;
6953               }
6954
6955             op0 = validize_mem (op0);
6956
6957             if (GET_CODE (op0) == MEM && GET_CODE (XEXP (op0, 0)) == REG)
6958               mark_reg_pointer (XEXP (op0, 0), MEM_ALIGN (op0));
6959
6960             op0 = extract_bit_field (op0, bitsize, bitpos,
6961                                      unsignedp, target, ext_mode, ext_mode,
6962                                      int_size_in_bytes (TREE_TYPE (tem)));
6963
6964             /* If the result is a record type and BITSIZE is narrower than
6965                the mode of OP0, an integral mode, and this is a big endian
6966                machine, we must put the field into the high-order bits.  */
6967             if (TREE_CODE (type) == RECORD_TYPE && BYTES_BIG_ENDIAN
6968                 && GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT
6969                 && bitsize < (HOST_WIDE_INT) GET_MODE_BITSIZE (GET_MODE (op0)))
6970               op0 = expand_shift (LSHIFT_EXPR, GET_MODE (op0), op0,
6971                                   size_int (GET_MODE_BITSIZE (GET_MODE (op0))
6972                                             - bitsize),
6973                                   op0, 1);
6974
6975             if (mode == BLKmode)
6976               {
6977                 rtx new = assign_temp (build_qualified_type
6978                                        (type_for_mode (ext_mode, 0),
6979                                         TYPE_QUAL_CONST), 0, 1, 1);
6980
6981                 emit_move_insn (new, op0);
6982                 op0 = copy_rtx (new);
6983                 PUT_MODE (op0, BLKmode);
6984                 set_mem_attributes (op0, exp, 1);
6985               }
6986
6987             return op0;
6988           }
6989
6990         /* If the result is BLKmode, use that to access the object
6991            now as well.  */
6992         if (mode == BLKmode)
6993           mode1 = BLKmode;
6994
6995         /* Get a reference to just this component.  */
6996         if (modifier == EXPAND_CONST_ADDRESS
6997             || modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER)
6998           op0 = adjust_address_nv (op0, mode1, bitpos / BITS_PER_UNIT);
6999         else
7000           op0 = adjust_address (op0, mode1, bitpos / BITS_PER_UNIT);
7001
7002         if (op0 == orig_op0)
7003           op0 = copy_rtx (op0);
7004
7005         set_mem_attributes (op0, exp, 0);
7006         if (GET_CODE (XEXP (op0, 0)) == REG)
7007           mark_reg_pointer (XEXP (op0, 0), MEM_ALIGN (op0));
7008
7009         MEM_VOLATILE_P (op0) |= volatilep;
7010         if (mode == mode1 || mode1 == BLKmode || mode1 == tmode
7011             || modifier == EXPAND_CONST_ADDRESS
7012             || modifier == EXPAND_INITIALIZER)
7013           return op0;
7014         else if (target == 0)
7015           target = gen_reg_rtx (tmode != VOIDmode ? tmode : mode);
7016
7017         convert_move (target, op0, unsignedp);
7018         return target;
7019       }
7020
7021     case VTABLE_REF:
7022       {
7023         rtx insn, before = get_last_insn (), vtbl_ref;
7024
7025         /* Evaluate the interior expression.  */
7026         subtarget = expand_expr (TREE_OPERAND (exp, 0), target,
7027                                  tmode, modifier);
7028
7029         /* Get or create an instruction off which to hang a note.  */
7030         if (REG_P (subtarget))
7031           {
7032             target = subtarget;
7033             insn = get_last_insn ();
7034             if (insn == before)
7035               abort ();
7036             if (! INSN_P (insn))
7037               insn = prev_nonnote_insn (insn);
7038           }
7039         else
7040           {
7041             target = gen_reg_rtx (GET_MODE (subtarget));
7042             insn = emit_move_insn (target, subtarget);
7043           }
7044
7045         /* Collect the data for the note.  */
7046         vtbl_ref = XEXP (DECL_RTL (TREE_OPERAND (exp, 1)), 0);
7047         vtbl_ref = plus_constant (vtbl_ref,
7048                                   tree_low_cst (TREE_OPERAND (exp, 2), 0));
7049         /* Discard the initial CONST that was added.  */
7050         vtbl_ref = XEXP (vtbl_ref, 0);
7051
7052         REG_NOTES (insn)
7053           = gen_rtx_EXPR_LIST (REG_VTABLE_REF, vtbl_ref, REG_NOTES (insn));
7054
7055         return target;
7056       }
7057
7058       /* Intended for a reference to a buffer of a file-object in Pascal.
7059          But it's not certain that a special tree code will really be
7060          necessary for these.  INDIRECT_REF might work for them.  */
7061     case BUFFER_REF:
7062       abort ();
7063
7064     case IN_EXPR:
7065       {
7066         /* Pascal set IN expression.
7067
7068            Algorithm:
7069                rlo       = set_low - (set_low%bits_per_word);
7070                the_word  = set [ (index - rlo)/bits_per_word ];
7071                bit_index = index % bits_per_word;
7072                bitmask   = 1 << bit_index;
7073                return !!(the_word & bitmask);  */
7074
7075         tree set = TREE_OPERAND (exp, 0);
7076         tree index = TREE_OPERAND (exp, 1);
7077         int iunsignedp = TREE_UNSIGNED (TREE_TYPE (index));
7078         tree set_type = TREE_TYPE (set);
7079         tree set_low_bound = TYPE_MIN_VALUE (TYPE_DOMAIN (set_type));
7080         tree set_high_bound = TYPE_MAX_VALUE (TYPE_DOMAIN (set_type));
7081         rtx index_val = expand_expr (index, 0, VOIDmode, 0);
7082         rtx lo_r = expand_expr (set_low_bound, 0, VOIDmode, 0);
7083         rtx hi_r = expand_expr (set_high_bound, 0, VOIDmode, 0);
7084         rtx setval = expand_expr (set, 0, VOIDmode, 0);
7085         rtx setaddr = XEXP (setval, 0);
7086         enum machine_mode index_mode = TYPE_MODE (TREE_TYPE (index));
7087         rtx rlow;
7088         rtx diff, quo, rem, addr, bit, result;
7089
7090         /* If domain is empty, answer is no.  Likewise if index is constant
7091            and out of bounds.  */
7092         if (((TREE_CODE (set_high_bound) == INTEGER_CST
7093              && TREE_CODE (set_low_bound) == INTEGER_CST
7094              && tree_int_cst_lt (set_high_bound, set_low_bound))
7095              || (TREE_CODE (index) == INTEGER_CST
7096                  && TREE_CODE (set_low_bound) == INTEGER_CST
7097                  && tree_int_cst_lt (index, set_low_bound))
7098              || (TREE_CODE (set_high_bound) == INTEGER_CST
7099                  && TREE_CODE (index) == INTEGER_CST
7100                  && tree_int_cst_lt (set_high_bound, index))))
7101           return const0_rtx;
7102
7103         if (target == 0)
7104           target = gen_reg_rtx (tmode != VOIDmode ? tmode : mode);
7105
7106         /* If we get here, we have to generate the code for both cases
7107            (in range and out of range).  */
7108
7109         op0 = gen_label_rtx ();
7110         op1 = gen_label_rtx ();
7111
7112         if (! (GET_CODE (index_val) == CONST_INT
7113                && GET_CODE (lo_r) == CONST_INT))
7114           emit_cmp_and_jump_insns (index_val, lo_r, LT, NULL_RTX,
7115                                    GET_MODE (index_val), iunsignedp, op1);
7116
7117         if (! (GET_CODE (index_val) == CONST_INT
7118                && GET_CODE (hi_r) == CONST_INT))
7119           emit_cmp_and_jump_insns (index_val, hi_r, GT, NULL_RTX,
7120                                    GET_MODE (index_val), iunsignedp, op1);
7121
7122         /* Calculate the element number of bit zero in the first word
7123            of the set.  */
7124         if (GET_CODE (lo_r) == CONST_INT)
7125           rlow = GEN_INT (INTVAL (lo_r)
7126                           & ~((HOST_WIDE_INT) 1 << BITS_PER_UNIT));
7127         else
7128           rlow = expand_binop (index_mode, and_optab, lo_r,
7129                                GEN_INT (~((HOST_WIDE_INT) 1 << BITS_PER_UNIT)),
7130                                NULL_RTX, iunsignedp, OPTAB_LIB_WIDEN);
7131
7132         diff = expand_binop (index_mode, sub_optab, index_val, rlow,
7133                              NULL_RTX, iunsignedp, OPTAB_LIB_WIDEN);
7134
7135         quo = expand_divmod (0, TRUNC_DIV_EXPR, index_mode, diff,
7136                              GEN_INT (BITS_PER_UNIT), NULL_RTX, iunsignedp);
7137         rem = expand_divmod (1, TRUNC_MOD_EXPR, index_mode, index_val,
7138                              GEN_INT (BITS_PER_UNIT), NULL_RTX, iunsignedp);
7139
7140         addr = memory_address (byte_mode,
7141                                expand_binop (index_mode, add_optab, diff,
7142                                              setaddr, NULL_RTX, iunsignedp,
7143                                              OPTAB_LIB_WIDEN));
7144
7145         /* Extract the bit we want to examine.  */
7146         bit = expand_shift (RSHIFT_EXPR, byte_mode,
7147                             gen_rtx_MEM (byte_mode, addr),
7148                             make_tree (TREE_TYPE (index), rem),
7149                             NULL_RTX, 1);
7150         result = expand_binop (byte_mode, and_optab, bit, const1_rtx,
7151                                GET_MODE (target) == byte_mode ? target : 0,
7152                                1, OPTAB_LIB_WIDEN);
7153
7154         if (result != target)
7155           convert_move (target, result, 1);
7156
7157         /* Output the code to handle the out-of-range case.  */
7158         emit_jump (op0);
7159         emit_label (op1);
7160         emit_move_insn (target, const0_rtx);
7161         emit_label (op0);
7162         return target;
7163       }
7164
7165     case WITH_CLEANUP_EXPR:
7166       if (WITH_CLEANUP_EXPR_RTL (exp) == 0)
7167         {
7168           WITH_CLEANUP_EXPR_RTL (exp)
7169             = expand_expr (TREE_OPERAND (exp, 0), target, tmode, modifier);
7170           expand_decl_cleanup (NULL_TREE, TREE_OPERAND (exp, 1));
7171
7172           /* That's it for this cleanup.  */
7173           TREE_OPERAND (exp, 1) = 0;
7174         }
7175       return WITH_CLEANUP_EXPR_RTL (exp);
7176
7177     case CLEANUP_POINT_EXPR:
7178       {
7179         /* Start a new binding layer that will keep track of all cleanup
7180            actions to be performed.  */
7181         expand_start_bindings (2);
7182
7183         target_temp_slot_level = temp_slot_level;
7184
7185         op0 = expand_expr (TREE_OPERAND (exp, 0), target, tmode, modifier);
7186         /* If we're going to use this value, load it up now.  */
7187         if (! ignore)
7188           op0 = force_not_mem (op0);
7189         preserve_temp_slots (op0);
7190         expand_end_bindings (NULL_TREE, 0, 0);
7191       }
7192       return op0;
7193
7194     case CALL_EXPR:
7195       /* Check for a built-in function.  */
7196       if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
7197           && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
7198               == FUNCTION_DECL)
7199           && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
7200         {
7201           if (DECL_BUILT_IN_CLASS (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
7202               == BUILT_IN_FRONTEND)
7203             return (*lang_expand_expr) (exp, original_target, tmode, modifier);
7204           else
7205             return expand_builtin (exp, target, subtarget, tmode, ignore);
7206         }
7207
7208       return expand_call (exp, target, ignore);
7209
7210     case NON_LVALUE_EXPR:
7211     case NOP_EXPR:
7212     case CONVERT_EXPR:
7213     case REFERENCE_EXPR:
7214       if (TREE_OPERAND (exp, 0) == error_mark_node)
7215         return const0_rtx;
7216
7217       if (TREE_CODE (type) == UNION_TYPE)
7218         {
7219           tree valtype = TREE_TYPE (TREE_OPERAND (exp, 0));
7220
7221           /* If both input and output are BLKmode, this conversion isn't doing
7222              anything except possibly changing memory attribute.  */
7223           if (mode == BLKmode && TYPE_MODE (valtype) == BLKmode)
7224             {
7225               rtx result = expand_expr (TREE_OPERAND (exp, 0), target, tmode,
7226                                         modifier);
7227
7228               result = copy_rtx (result);
7229               set_mem_attributes (result, exp, 0);
7230               return result;
7231             }
7232
7233           if (target == 0)
7234             target = assign_temp (type, 0, 1, 1);
7235
7236           if (GET_CODE (target) == MEM)
7237             /* Store data into beginning of memory target.  */
7238             store_expr (TREE_OPERAND (exp, 0),
7239                         adjust_address (target, TYPE_MODE (valtype), 0), 0);
7240
7241           else if (GET_CODE (target) == REG)
7242             /* Store this field into a union of the proper type.  */
7243             store_field (target,
7244                          MIN ((int_size_in_bytes (TREE_TYPE
7245                                                   (TREE_OPERAND (exp, 0)))
7246                                * BITS_PER_UNIT),
7247                               (HOST_WIDE_INT) GET_MODE_BITSIZE (mode)),
7248                          0, TYPE_MODE (valtype), TREE_OPERAND (exp, 0),
7249                          VOIDmode, 0, type, 0);
7250           else
7251             abort ();
7252
7253           /* Return the entire union.  */
7254           return target;
7255         }
7256
7257       if (mode == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))))
7258         {
7259           op0 = expand_expr (TREE_OPERAND (exp, 0), target, VOIDmode,
7260                              modifier);
7261
7262           /* If the signedness of the conversion differs and OP0 is
7263              a promoted SUBREG, clear that indication since we now
7264              have to do the proper extension.  */
7265           if (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))) != unsignedp
7266               && GET_CODE (op0) == SUBREG)
7267             SUBREG_PROMOTED_VAR_P (op0) = 0;
7268
7269           return op0;
7270         }
7271
7272       op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, mode, 0);
7273       if (GET_MODE (op0) == mode)
7274         return op0;
7275
7276       /* If OP0 is a constant, just convert it into the proper mode.  */
7277       if (CONSTANT_P (op0))
7278         return
7279           convert_modes (mode, TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))),
7280                          op0, TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))));
7281
7282       if (modifier == EXPAND_INITIALIZER)
7283         return gen_rtx_fmt_e (unsignedp ? ZERO_EXTEND : SIGN_EXTEND, mode, op0);
7284
7285       if (target == 0)
7286         return
7287           convert_to_mode (mode, op0,
7288                            TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))));
7289       else
7290         convert_move (target, op0,
7291                       TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))));
7292       return target;
7293
7294     case VIEW_CONVERT_EXPR:
7295       op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, mode, modifier);
7296
7297       /* If the input and output modes are both the same, we are done.
7298          Otherwise, if neither mode is BLKmode and both are within a word, we
7299          can use gen_lowpart.  If neither is true, make sure the operand is
7300          in memory and convert the MEM to the new mode.  */
7301       if (TYPE_MODE (type) == GET_MODE (op0))
7302         ;
7303       else if (TYPE_MODE (type) != BLKmode && GET_MODE (op0) != BLKmode
7304                && GET_MODE_SIZE (TYPE_MODE (type)) <= UNITS_PER_WORD
7305                && GET_MODE_SIZE (GET_MODE (op0)) <= UNITS_PER_WORD)
7306         op0 = gen_lowpart (TYPE_MODE (type), op0);
7307       else if (GET_CODE (op0) != MEM)
7308         {
7309           /* If the operand is not a MEM, force it into memory.  Since we
7310              are going to be be changing the mode of the MEM, don't call
7311              force_const_mem for constants because we don't allow pool
7312              constants to change mode.  */
7313           tree inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
7314
7315           if (TREE_ADDRESSABLE (exp))
7316             abort ();
7317
7318           if (target == 0 || GET_MODE (target) != TYPE_MODE (inner_type))
7319             target
7320               = assign_stack_temp_for_type
7321                 (TYPE_MODE (inner_type),
7322                  GET_MODE_SIZE (TYPE_MODE (inner_type)), 0, inner_type);
7323
7324           emit_move_insn (target, op0);
7325           op0 = target;
7326         }
7327
7328       /* At this point, OP0 is in the correct mode.  If the output type is such
7329          that the operand is known to be aligned, indicate that it is.
7330          Otherwise, we need only be concerned about alignment for non-BLKmode
7331          results.  */
7332       if (GET_CODE (op0) == MEM)
7333         {
7334           op0 = copy_rtx (op0);
7335
7336           if (TYPE_ALIGN_OK (type))
7337             set_mem_align (op0, MAX (MEM_ALIGN (op0), TYPE_ALIGN (type)));
7338           else if (TYPE_MODE (type) != BLKmode && STRICT_ALIGNMENT
7339                    && MEM_ALIGN (op0) < GET_MODE_ALIGNMENT (TYPE_MODE (type)))
7340             {
7341               tree inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
7342               HOST_WIDE_INT temp_size
7343                 = MAX (int_size_in_bytes (inner_type),
7344                        (HOST_WIDE_INT) GET_MODE_SIZE (TYPE_MODE (type)));
7345               rtx new = assign_stack_temp_for_type (TYPE_MODE (type),
7346                                                     temp_size, 0, type);
7347               rtx new_with_op0_mode = adjust_address (new, GET_MODE (op0), 0);
7348
7349               if (TREE_ADDRESSABLE (exp))
7350                 abort ();
7351
7352               if (GET_MODE (op0) == BLKmode)
7353                 emit_block_move (new_with_op0_mode, op0,
7354                                  GEN_INT (GET_MODE_SIZE (TYPE_MODE (type))));
7355               else
7356                 emit_move_insn (new_with_op0_mode, op0);
7357
7358               op0 = new;
7359             }
7360
7361           op0 = adjust_address (op0, TYPE_MODE (type), 0);
7362         }
7363
7364       return op0;
7365
7366     case PLUS_EXPR:
7367       /* We come here from MINUS_EXPR when the second operand is a
7368          constant.  */
7369     plus_expr:
7370       this_optab = ! unsignedp && flag_trapv
7371                    && (GET_MODE_CLASS (mode) == MODE_INT)
7372                    ? addv_optab : add_optab;
7373
7374       /* If we are adding a constant, an RTL_EXPR that is sp, fp, or ap, and
7375          something else, make sure we add the register to the constant and
7376          then to the other thing.  This case can occur during strength
7377          reduction and doing it this way will produce better code if the
7378          frame pointer or argument pointer is eliminated.
7379
7380          fold-const.c will ensure that the constant is always in the inner
7381          PLUS_EXPR, so the only case we need to do anything about is if
7382          sp, ap, or fp is our second argument, in which case we must swap
7383          the innermost first argument and our second argument.  */
7384
7385       if (TREE_CODE (TREE_OPERAND (exp, 0)) == PLUS_EXPR
7386           && TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 1)) == INTEGER_CST
7387           && TREE_CODE (TREE_OPERAND (exp, 1)) == RTL_EXPR
7388           && (RTL_EXPR_RTL (TREE_OPERAND (exp, 1)) == frame_pointer_rtx
7389               || RTL_EXPR_RTL (TREE_OPERAND (exp, 1)) == stack_pointer_rtx
7390               || RTL_EXPR_RTL (TREE_OPERAND (exp, 1)) == arg_pointer_rtx))
7391         {
7392           tree t = TREE_OPERAND (exp, 1);
7393
7394           TREE_OPERAND (exp, 1) = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
7395           TREE_OPERAND (TREE_OPERAND (exp, 0), 0) = t;
7396         }
7397
7398       /* If the result is to be ptr_mode and we are adding an integer to
7399          something, we might be forming a constant.  So try to use
7400          plus_constant.  If it produces a sum and we can't accept it,
7401          use force_operand.  This allows P = &ARR[const] to generate
7402          efficient code on machines where a SYMBOL_REF is not a valid
7403          address.
7404
7405          If this is an EXPAND_SUM call, always return the sum.  */
7406       if (modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER
7407           || (mode == ptr_mode && (unsignedp || ! flag_trapv)))
7408         {
7409           if (TREE_CODE (TREE_OPERAND (exp, 0)) == INTEGER_CST
7410               && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
7411               && TREE_CONSTANT (TREE_OPERAND (exp, 1)))
7412             {
7413               rtx constant_part;
7414
7415               op1 = expand_expr (TREE_OPERAND (exp, 1), subtarget, VOIDmode,
7416                                  EXPAND_SUM);
7417               /* Use immed_double_const to ensure that the constant is
7418                  truncated according to the mode of OP1, then sign extended
7419                  to a HOST_WIDE_INT.  Using the constant directly can result
7420                  in non-canonical RTL in a 64x32 cross compile.  */
7421               constant_part
7422                 = immed_double_const (TREE_INT_CST_LOW (TREE_OPERAND (exp, 0)),
7423                                       (HOST_WIDE_INT) 0,
7424                                       TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 1))));
7425               op1 = plus_constant (op1, INTVAL (constant_part));
7426               if (modifier != EXPAND_SUM && modifier != EXPAND_INITIALIZER)
7427                 op1 = force_operand (op1, target);
7428               return op1;
7429             }
7430
7431           else if (TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST
7432                    && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_INT
7433                    && TREE_CONSTANT (TREE_OPERAND (exp, 0)))
7434             {
7435               rtx constant_part;
7436
7437               op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode,
7438                                  EXPAND_SUM);
7439               if (! CONSTANT_P (op0))
7440                 {
7441                   op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX,
7442                                      VOIDmode, modifier);
7443                   /* Don't go to both_summands if modifier
7444                      says it's not right to return a PLUS.  */
7445                   if (modifier != EXPAND_SUM && modifier != EXPAND_INITIALIZER)
7446                     goto binop2;
7447                   goto both_summands;
7448                 }
7449               /* Use immed_double_const to ensure that the constant is
7450                  truncated according to the mode of OP1, then sign extended
7451                  to a HOST_WIDE_INT.  Using the constant directly can result
7452                  in non-canonical RTL in a 64x32 cross compile.  */
7453               constant_part
7454                 = immed_double_const (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1)),
7455                                       (HOST_WIDE_INT) 0,
7456                                       TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))));
7457               op0 = plus_constant (op0, INTVAL (constant_part));
7458               if (modifier != EXPAND_SUM && modifier != EXPAND_INITIALIZER)
7459                 op0 = force_operand (op0, target);
7460               return op0;
7461             }
7462         }
7463
7464       /* No sense saving up arithmetic to be done
7465          if it's all in the wrong mode to form part of an address.
7466          And force_operand won't know whether to sign-extend or
7467          zero-extend.  */
7468       if ((modifier != EXPAND_SUM && modifier != EXPAND_INITIALIZER)
7469           || mode != ptr_mode)
7470         goto binop;
7471
7472       if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1), 1))
7473         subtarget = 0;
7474
7475       op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, modifier);
7476       op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, modifier);
7477
7478     both_summands:
7479       /* Make sure any term that's a sum with a constant comes last.  */
7480       if (GET_CODE (op0) == PLUS
7481           && CONSTANT_P (XEXP (op0, 1)))
7482         {
7483           temp = op0;
7484           op0 = op1;
7485           op1 = temp;
7486         }
7487       /* If adding to a sum including a constant,
7488          associate it to put the constant outside.  */
7489       if (GET_CODE (op1) == PLUS
7490           && CONSTANT_P (XEXP (op1, 1)))
7491         {
7492           rtx constant_term = const0_rtx;
7493
7494           temp = simplify_binary_operation (PLUS, mode, XEXP (op1, 0), op0);
7495           if (temp != 0)
7496             op0 = temp;
7497           /* Ensure that MULT comes first if there is one.  */
7498           else if (GET_CODE (op0) == MULT)
7499             op0 = gen_rtx_PLUS (mode, op0, XEXP (op1, 0));
7500           else
7501             op0 = gen_rtx_PLUS (mode, XEXP (op1, 0), op0);
7502
7503           /* Let's also eliminate constants from op0 if possible.  */
7504           op0 = eliminate_constant_term (op0, &constant_term);
7505
7506           /* CONSTANT_TERM and XEXP (op1, 1) are known to be constant, so
7507              their sum should be a constant.  Form it into OP1, since the
7508              result we want will then be OP0 + OP1.  */
7509
7510           temp = simplify_binary_operation (PLUS, mode, constant_term,
7511                                             XEXP (op1, 1));
7512           if (temp != 0)
7513             op1 = temp;
7514           else
7515             op1 = gen_rtx_PLUS (mode, constant_term, XEXP (op1, 1));
7516         }
7517
7518       /* Put a constant term last and put a multiplication first.  */
7519       if (CONSTANT_P (op0) || GET_CODE (op1) == MULT)
7520         temp = op1, op1 = op0, op0 = temp;
7521
7522       temp = simplify_binary_operation (PLUS, mode, op0, op1);
7523       return temp ? temp : gen_rtx_PLUS (mode, op0, op1);
7524
7525     case MINUS_EXPR:
7526       /* For initializers, we are allowed to return a MINUS of two
7527          symbolic constants.  Here we handle all cases when both operands
7528          are constant.  */
7529       /* Handle difference of two symbolic constants,
7530          for the sake of an initializer.  */
7531       if ((modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER)
7532           && really_constant_p (TREE_OPERAND (exp, 0))
7533           && really_constant_p (TREE_OPERAND (exp, 1)))
7534         {
7535           rtx op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode,
7536                                  modifier);
7537           rtx op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode,
7538                                  modifier);
7539
7540           /* If the last operand is a CONST_INT, use plus_constant of
7541              the negated constant.  Else make the MINUS.  */
7542           if (GET_CODE (op1) == CONST_INT)
7543             return plus_constant (op0, - INTVAL (op1));
7544           else
7545             return gen_rtx_MINUS (mode, op0, op1);
7546         }
7547       /* Convert A - const to A + (-const).  */
7548       if (TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST)
7549         {
7550           tree negated = fold (build1 (NEGATE_EXPR, type,
7551                                        TREE_OPERAND (exp, 1)));
7552
7553           if (TREE_UNSIGNED (type) || TREE_OVERFLOW (negated))
7554             /* If we can't negate the constant in TYPE, leave it alone and
7555                expand_binop will negate it for us.  We used to try to do it
7556                here in the signed version of TYPE, but that doesn't work
7557                on POINTER_TYPEs.  */;
7558           else
7559             {
7560               exp = build (PLUS_EXPR, type, TREE_OPERAND (exp, 0), negated);
7561               goto plus_expr;
7562             }
7563         }
7564       this_optab = ! unsignedp && flag_trapv
7565                    && (GET_MODE_CLASS(mode) == MODE_INT)
7566                    ? subv_optab : sub_optab;
7567       goto binop;
7568
7569     case MULT_EXPR:
7570       /* If first operand is constant, swap them.
7571          Thus the following special case checks need only
7572          check the second operand.  */
7573       if (TREE_CODE (TREE_OPERAND (exp, 0)) == INTEGER_CST)
7574         {
7575           tree t1 = TREE_OPERAND (exp, 0);
7576           TREE_OPERAND (exp, 0) = TREE_OPERAND (exp, 1);
7577           TREE_OPERAND (exp, 1) = t1;
7578         }
7579
7580       /* Attempt to return something suitable for generating an
7581          indexed address, for machines that support that.  */
7582
7583       if (modifier == EXPAND_SUM && mode == ptr_mode
7584           && TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST
7585           && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
7586         {
7587           op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode,
7588                              EXPAND_SUM);
7589
7590           /* Apply distributive law if OP0 is x+c.  */
7591           if (GET_CODE (op0) == PLUS
7592               && GET_CODE (XEXP (op0, 1)) == CONST_INT)
7593             return
7594               gen_rtx_PLUS
7595                 (mode,
7596                  gen_rtx_MULT
7597                  (mode, XEXP (op0, 0),
7598                   GEN_INT (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1)))),
7599                  GEN_INT (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1))
7600                           * INTVAL (XEXP (op0, 1))));
7601
7602           if (GET_CODE (op0) != REG)
7603             op0 = force_operand (op0, NULL_RTX);
7604           if (GET_CODE (op0) != REG)
7605             op0 = copy_to_mode_reg (mode, op0);
7606
7607           return
7608             gen_rtx_MULT (mode, op0,
7609                           GEN_INT (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1))));
7610         }
7611
7612       if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1), 1))
7613         subtarget = 0;
7614
7615       /* Check for multiplying things that have been extended
7616          from a narrower type.  If this machine supports multiplying
7617          in that narrower type with a result in the desired type,
7618          do it that way, and avoid the explicit type-conversion.  */
7619       if (TREE_CODE (TREE_OPERAND (exp, 0)) == NOP_EXPR
7620           && TREE_CODE (type) == INTEGER_TYPE
7621           && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
7622               < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp, 0))))
7623           && ((TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST
7624                && int_fits_type_p (TREE_OPERAND (exp, 1),
7625                                    TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
7626                /* Don't use a widening multiply if a shift will do.  */
7627                && ((GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 1))))
7628                     > HOST_BITS_PER_WIDE_INT)
7629                    || exact_log2 (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1))) < 0))
7630               ||
7631               (TREE_CODE (TREE_OPERAND (exp, 1)) == NOP_EXPR
7632                && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 1), 0)))
7633                    ==
7634                    TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))))
7635                /* If both operands are extended, they must either both
7636                   be zero-extended or both be sign-extended.  */
7637                && (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 1), 0)))
7638                    ==
7639                    TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))))))
7640         {
7641           enum machine_mode innermode
7642             = TYPE_MODE (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)));
7643           optab other_optab = (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
7644                         ? smul_widen_optab : umul_widen_optab);
7645           this_optab = (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
7646                         ? umul_widen_optab : smul_widen_optab);
7647           if (mode == GET_MODE_WIDER_MODE (innermode))
7648             {
7649               if (this_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
7650                 {
7651                   op0 = expand_expr (TREE_OPERAND (TREE_OPERAND (exp, 0), 0),
7652                                      NULL_RTX, VOIDmode, 0);
7653                   if (TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST)
7654                     op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX,
7655                                        VOIDmode, 0);
7656                   else
7657                     op1 = expand_expr (TREE_OPERAND (TREE_OPERAND (exp, 1), 0),
7658                                        NULL_RTX, VOIDmode, 0);
7659                   goto binop2;
7660                 }
7661               else if (other_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing
7662                        && innermode == word_mode)
7663                 {
7664                   rtx htem;
7665                   op0 = expand_expr (TREE_OPERAND (TREE_OPERAND (exp, 0), 0),
7666                                      NULL_RTX, VOIDmode, 0);
7667                   if (TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST)
7668                     op1 = convert_modes (innermode, mode,
7669                                          expand_expr (TREE_OPERAND (exp, 1),
7670                                                       NULL_RTX, VOIDmode, 0),
7671                                          unsignedp);
7672                   else
7673                     op1 = expand_expr (TREE_OPERAND (TREE_OPERAND (exp, 1), 0),
7674                                        NULL_RTX, VOIDmode, 0);
7675                   temp = expand_binop (mode, other_optab, op0, op1, target,
7676                                        unsignedp, OPTAB_LIB_WIDEN);
7677                   htem = expand_mult_highpart_adjust (innermode,
7678                                                       gen_highpart (innermode, temp),
7679                                                       op0, op1,
7680                                                       gen_highpart (innermode, temp),
7681                                                       unsignedp);
7682                   emit_move_insn (gen_highpart (innermode, temp), htem);
7683                   return temp;
7684                 }
7685             }
7686         }
7687       op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
7688       op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
7689       return expand_mult (mode, op0, op1, target, unsignedp);
7690
7691     case TRUNC_DIV_EXPR:
7692     case FLOOR_DIV_EXPR:
7693     case CEIL_DIV_EXPR:
7694     case ROUND_DIV_EXPR:
7695     case EXACT_DIV_EXPR:
7696       if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1), 1))
7697         subtarget = 0;
7698       /* Possible optimization: compute the dividend with EXPAND_SUM
7699          then if the divisor is constant can optimize the case
7700          where some terms of the dividend have coeffs divisible by it.  */
7701       op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
7702       op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
7703       return expand_divmod (0, code, mode, op0, op1, target, unsignedp);
7704
7705     case RDIV_EXPR:
7706       /* Emit a/b as a*(1/b).  Later we may manage CSE the reciprocal saving
7707          expensive divide.  If not, combine will rebuild the original
7708          computation.  */
7709       if (flag_unsafe_math_optimizations && optimize && !optimize_size
7710           && !real_onep (TREE_OPERAND (exp, 0)))
7711         return expand_expr (build (MULT_EXPR, type, TREE_OPERAND (exp, 0),
7712                                    build (RDIV_EXPR, type,
7713                                           build_real (type, dconst1),
7714                                           TREE_OPERAND (exp, 1))),
7715                             target, tmode, unsignedp);
7716       this_optab = sdiv_optab;
7717       goto binop;
7718
7719     case TRUNC_MOD_EXPR:
7720     case FLOOR_MOD_EXPR:
7721     case CEIL_MOD_EXPR:
7722     case ROUND_MOD_EXPR:
7723       if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1), 1))
7724         subtarget = 0;
7725       op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
7726       op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
7727       return expand_divmod (1, code, mode, op0, op1, target, unsignedp);
7728
7729     case FIX_ROUND_EXPR:
7730     case FIX_FLOOR_EXPR:
7731     case FIX_CEIL_EXPR:
7732       abort ();                 /* Not used for C.  */
7733
7734     case FIX_TRUNC_EXPR:
7735       op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode, 0);
7736       if (target == 0)
7737         target = gen_reg_rtx (mode);
7738       expand_fix (target, op0, unsignedp);
7739       return target;
7740
7741     case FLOAT_EXPR:
7742       op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode, 0);
7743       if (target == 0)
7744         target = gen_reg_rtx (mode);
7745       /* expand_float can't figure out what to do if FROM has VOIDmode.
7746          So give it the correct mode.  With -O, cse will optimize this.  */
7747       if (GET_MODE (op0) == VOIDmode)
7748         op0 = copy_to_mode_reg (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))),
7749                                 op0);
7750       expand_float (target, op0,
7751                     TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))));
7752       return target;
7753
7754     case NEGATE_EXPR:
7755       op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
7756       temp = expand_unop (mode,
7757                           ! unsignedp && flag_trapv
7758                           && (GET_MODE_CLASS(mode) == MODE_INT)
7759                           ? negv_optab : neg_optab, op0, target, 0);
7760       if (temp == 0)
7761         abort ();
7762       return temp;
7763
7764     case ABS_EXPR:
7765       op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
7766
7767       /* Handle complex values specially.  */
7768       if (GET_MODE_CLASS (mode) == MODE_COMPLEX_INT
7769           || GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT)
7770         return expand_complex_abs (mode, op0, target, unsignedp);
7771
7772       /* Unsigned abs is simply the operand.  Testing here means we don't
7773          risk generating incorrect code below.  */
7774       if (TREE_UNSIGNED (type))
7775         return op0;
7776
7777       return expand_abs (mode, op0, target, unsignedp,
7778                          safe_from_p (target, TREE_OPERAND (exp, 0), 1));
7779
7780     case MAX_EXPR:
7781     case MIN_EXPR:
7782       target = original_target;
7783       if (target == 0 || ! safe_from_p (target, TREE_OPERAND (exp, 1), 1)
7784           || (GET_CODE (target) == MEM && MEM_VOLATILE_P (target))
7785           || GET_MODE (target) != mode
7786           || (GET_CODE (target) == REG
7787               && REGNO (target) < FIRST_PSEUDO_REGISTER))
7788         target = gen_reg_rtx (mode);
7789       op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
7790       op0 = expand_expr (TREE_OPERAND (exp, 0), target, VOIDmode, 0);
7791
7792       /* First try to do it with a special MIN or MAX instruction.
7793          If that does not win, use a conditional jump to select the proper
7794          value.  */
7795       this_optab = (TREE_UNSIGNED (type)
7796                     ? (code == MIN_EXPR ? umin_optab : umax_optab)
7797                     : (code == MIN_EXPR ? smin_optab : smax_optab));
7798
7799       temp = expand_binop (mode, this_optab, op0, op1, target, unsignedp,
7800                            OPTAB_WIDEN);
7801       if (temp != 0)
7802         return temp;
7803
7804       /* At this point, a MEM target is no longer useful; we will get better
7805          code without it.  */
7806
7807       if (GET_CODE (target) == MEM)
7808         target = gen_reg_rtx (mode);
7809
7810       if (target != op0)
7811         emit_move_insn (target, op0);
7812
7813       op0 = gen_label_rtx ();
7814
7815       /* If this mode is an integer too wide to compare properly,
7816          compare word by word.  Rely on cse to optimize constant cases.  */
7817       if (GET_MODE_CLASS (mode) == MODE_INT
7818           && ! can_compare_p (GE, mode, ccp_jump))
7819         {
7820           if (code == MAX_EXPR)
7821             do_jump_by_parts_greater_rtx (mode, TREE_UNSIGNED (type),
7822                                           target, op1, NULL_RTX, op0);
7823           else
7824             do_jump_by_parts_greater_rtx (mode, TREE_UNSIGNED (type),
7825                                           op1, target, NULL_RTX, op0);
7826         }
7827       else
7828         {
7829           int unsignedp = TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 1)));
7830           do_compare_rtx_and_jump (target, op1, code == MAX_EXPR ? GE : LE,
7831                                    unsignedp, mode, NULL_RTX, NULL_RTX,
7832                                    op0);
7833         }
7834       emit_move_insn (target, op1);
7835       emit_label (op0);
7836       return target;
7837
7838     case BIT_NOT_EXPR:
7839       op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
7840       temp = expand_unop (mode, one_cmpl_optab, op0, target, 1);
7841       if (temp == 0)
7842         abort ();
7843       return temp;
7844
7845     case FFS_EXPR:
7846       op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
7847       temp = expand_unop (mode, ffs_optab, op0, target, 1);
7848       if (temp == 0)
7849         abort ();
7850       return temp;
7851
7852       /* ??? Can optimize bitwise operations with one arg constant.
7853          Can optimize (a bitwise1 n) bitwise2 (a bitwise3 b)
7854          and (a bitwise1 b) bitwise2 b (etc)
7855          but that is probably not worth while.  */
7856
7857       /* BIT_AND_EXPR is for bitwise anding.  TRUTH_AND_EXPR is for anding two
7858          boolean values when we want in all cases to compute both of them.  In
7859          general it is fastest to do TRUTH_AND_EXPR by computing both operands
7860          as actual zero-or-1 values and then bitwise anding.  In cases where
7861          there cannot be any side effects, better code would be made by
7862          treating TRUTH_AND_EXPR like TRUTH_ANDIF_EXPR; but the question is
7863          how to recognize those cases.  */
7864
7865     case TRUTH_AND_EXPR:
7866     case BIT_AND_EXPR:
7867       this_optab = and_optab;
7868       goto binop;
7869
7870     case TRUTH_OR_EXPR:
7871     case BIT_IOR_EXPR:
7872       this_optab = ior_optab;
7873       goto binop;
7874
7875     case TRUTH_XOR_EXPR:
7876     case BIT_XOR_EXPR:
7877       this_optab = xor_optab;
7878       goto binop;
7879
7880     case LSHIFT_EXPR:
7881     case RSHIFT_EXPR:
7882     case LROTATE_EXPR:
7883     case RROTATE_EXPR:
7884       if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1), 1))
7885         subtarget = 0;
7886       op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
7887       return expand_shift (code, mode, op0, TREE_OPERAND (exp, 1), target,
7888                            unsignedp);
7889
7890       /* Could determine the answer when only additive constants differ.  Also,
7891          the addition of one can be handled by changing the condition.  */
7892     case LT_EXPR:
7893     case LE_EXPR:
7894     case GT_EXPR:
7895     case GE_EXPR:
7896     case EQ_EXPR:
7897     case NE_EXPR:
7898     case UNORDERED_EXPR:
7899     case ORDERED_EXPR:
7900     case UNLT_EXPR:
7901     case UNLE_EXPR:
7902     case UNGT_EXPR:
7903     case UNGE_EXPR:
7904     case UNEQ_EXPR:
7905       temp = do_store_flag (exp, target, tmode != VOIDmode ? tmode : mode, 0);
7906       if (temp != 0)
7907         return temp;
7908
7909       /* For foo != 0, load foo, and if it is nonzero load 1 instead.  */
7910       if (code == NE_EXPR && integer_zerop (TREE_OPERAND (exp, 1))
7911           && original_target
7912           && GET_CODE (original_target) == REG
7913           && (GET_MODE (original_target)
7914               == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))))
7915         {
7916           temp = expand_expr (TREE_OPERAND (exp, 0), original_target,
7917                               VOIDmode, 0);
7918
7919           if (temp != original_target)
7920             temp = copy_to_reg (temp);
7921
7922           op1 = gen_label_rtx ();
7923           emit_cmp_and_jump_insns (temp, const0_rtx, EQ, NULL_RTX,
7924                                    GET_MODE (temp), unsignedp, op1);
7925           emit_move_insn (temp, const1_rtx);
7926           emit_label (op1);
7927           return temp;
7928         }
7929
7930       /* If no set-flag instruction, must generate a conditional
7931          store into a temporary variable.  Drop through
7932          and handle this like && and ||.  */
7933
7934     case TRUTH_ANDIF_EXPR:
7935     case TRUTH_ORIF_EXPR:
7936       if (! ignore
7937           && (target == 0 || ! safe_from_p (target, exp, 1)
7938               /* Make sure we don't have a hard reg (such as function's return
7939                  value) live across basic blocks, if not optimizing.  */
7940               || (!optimize && GET_CODE (target) == REG
7941                   && REGNO (target) < FIRST_PSEUDO_REGISTER)))
7942         target = gen_reg_rtx (tmode != VOIDmode ? tmode : mode);
7943
7944       if (target)
7945         emit_clr_insn (target);
7946
7947       op1 = gen_label_rtx ();
7948       jumpifnot (exp, op1);
7949
7950       if (target)
7951         emit_0_to_1_insn (target);
7952
7953       emit_label (op1);
7954       return ignore ? const0_rtx : target;
7955
7956     case TRUTH_NOT_EXPR:
7957       op0 = expand_expr (TREE_OPERAND (exp, 0), target, VOIDmode, 0);
7958       /* The parser is careful to generate TRUTH_NOT_EXPR
7959          only with operands that are always zero or one.  */
7960       temp = expand_binop (mode, xor_optab, op0, const1_rtx,
7961                            target, 1, OPTAB_LIB_WIDEN);
7962       if (temp == 0)
7963         abort ();
7964       return temp;
7965
7966     case COMPOUND_EXPR:
7967       expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode, 0);
7968       emit_queue ();
7969       return expand_expr (TREE_OPERAND (exp, 1),
7970                           (ignore ? const0_rtx : target),
7971                           VOIDmode, 0);
7972
7973     case COND_EXPR:
7974       /* If we would have a "singleton" (see below) were it not for a
7975          conversion in each arm, bring that conversion back out.  */
7976       if (TREE_CODE (TREE_OPERAND (exp, 1)) == NOP_EXPR
7977           && TREE_CODE (TREE_OPERAND (exp, 2)) == NOP_EXPR
7978           && (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 1), 0))
7979               == TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 2), 0))))
7980         {
7981           tree iftrue = TREE_OPERAND (TREE_OPERAND (exp, 1), 0);
7982           tree iffalse = TREE_OPERAND (TREE_OPERAND (exp, 2), 0);
7983
7984           if ((TREE_CODE_CLASS (TREE_CODE (iftrue)) == '2'
7985                && operand_equal_p (iffalse, TREE_OPERAND (iftrue, 0), 0))
7986               || (TREE_CODE_CLASS (TREE_CODE (iffalse)) == '2'
7987                   && operand_equal_p (iftrue, TREE_OPERAND (iffalse, 0), 0))
7988               || (TREE_CODE_CLASS (TREE_CODE (iftrue)) == '1'
7989                   && operand_equal_p (iffalse, TREE_OPERAND (iftrue, 0), 0))
7990               || (TREE_CODE_CLASS (TREE_CODE (iffalse)) == '1'
7991                   && operand_equal_p (iftrue, TREE_OPERAND (iffalse, 0), 0)))
7992             return expand_expr (build1 (NOP_EXPR, type,
7993                                         build (COND_EXPR, TREE_TYPE (iftrue),
7994                                                TREE_OPERAND (exp, 0),
7995                                                iftrue, iffalse)),
7996                                 target, tmode, modifier);
7997         }
7998
7999       {
8000         /* Note that COND_EXPRs whose type is a structure or union
8001            are required to be constructed to contain assignments of
8002            a temporary variable, so that we can evaluate them here
8003            for side effect only.  If type is void, we must do likewise.  */
8004
8005         /* If an arm of the branch requires a cleanup,
8006            only that cleanup is performed.  */
8007
8008         tree singleton = 0;
8009         tree binary_op = 0, unary_op = 0;
8010
8011         /* If this is (A ? 1 : 0) and A is a condition, just evaluate it and
8012            convert it to our mode, if necessary.  */
8013         if (integer_onep (TREE_OPERAND (exp, 1))
8014             && integer_zerop (TREE_OPERAND (exp, 2))
8015             && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == '<')
8016           {
8017             if (ignore)
8018               {
8019                 expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode,
8020                              modifier);
8021                 return const0_rtx;
8022               }
8023
8024             op0 = expand_expr (TREE_OPERAND (exp, 0), target, mode, modifier);
8025             if (GET_MODE (op0) == mode)
8026               return op0;
8027
8028             if (target == 0)
8029               target = gen_reg_rtx (mode);
8030             convert_move (target, op0, unsignedp);
8031             return target;
8032           }
8033
8034         /* Check for X ? A + B : A.  If we have this, we can copy A to the
8035            output and conditionally add B.  Similarly for unary operations.
8036            Don't do this if X has side-effects because those side effects
8037            might affect A or B and the "?" operation is a sequence point in
8038            ANSI.  (operand_equal_p tests for side effects.)  */
8039
8040         if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 1))) == '2'
8041             && operand_equal_p (TREE_OPERAND (exp, 2),
8042                                 TREE_OPERAND (TREE_OPERAND (exp, 1), 0), 0))
8043           singleton = TREE_OPERAND (exp, 2), binary_op = TREE_OPERAND (exp, 1);
8044         else if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 2))) == '2'
8045                  && operand_equal_p (TREE_OPERAND (exp, 1),
8046                                      TREE_OPERAND (TREE_OPERAND (exp, 2), 0), 0))
8047           singleton = TREE_OPERAND (exp, 1), binary_op = TREE_OPERAND (exp, 2);
8048         else if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 1))) == '1'
8049                  && operand_equal_p (TREE_OPERAND (exp, 2),
8050                                      TREE_OPERAND (TREE_OPERAND (exp, 1), 0), 0))
8051           singleton = TREE_OPERAND (exp, 2), unary_op = TREE_OPERAND (exp, 1);
8052         else if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 2))) == '1'
8053                  && operand_equal_p (TREE_OPERAND (exp, 1),
8054                                      TREE_OPERAND (TREE_OPERAND (exp, 2), 0), 0))
8055           singleton = TREE_OPERAND (exp, 1), unary_op = TREE_OPERAND (exp, 2);
8056
8057         /* If we are not to produce a result, we have no target.  Otherwise,
8058            if a target was specified use it; it will not be used as an
8059            intermediate target unless it is safe.  If no target, use a
8060            temporary.  */
8061
8062         if (ignore)
8063           temp = 0;
8064         else if (original_target
8065                  && (safe_from_p (original_target, TREE_OPERAND (exp, 0), 1)
8066                      || (singleton && GET_CODE (original_target) == REG
8067                          && REGNO (original_target) >= FIRST_PSEUDO_REGISTER
8068                          && original_target == var_rtx (singleton)))
8069                  && GET_MODE (original_target) == mode
8070 #ifdef HAVE_conditional_move
8071                  && (! can_conditionally_move_p (mode)
8072                      || GET_CODE (original_target) == REG
8073                      || TREE_ADDRESSABLE (type))
8074 #endif
8075                  && (GET_CODE (original_target) != MEM
8076                      || TREE_ADDRESSABLE (type)))
8077           temp = original_target;
8078         else if (TREE_ADDRESSABLE (type))
8079           abort ();
8080         else
8081           temp = assign_temp (type, 0, 0, 1);
8082
8083         /* If we had X ? A + C : A, with C a constant power of 2, and we can
8084            do the test of X as a store-flag operation, do this as
8085            A + ((X != 0) << log C).  Similarly for other simple binary
8086            operators.  Only do for C == 1 if BRANCH_COST is low.  */
8087         if (temp && singleton && binary_op
8088             && (TREE_CODE (binary_op) == PLUS_EXPR
8089                 || TREE_CODE (binary_op) == MINUS_EXPR
8090                 || TREE_CODE (binary_op) == BIT_IOR_EXPR
8091                 || TREE_CODE (binary_op) == BIT_XOR_EXPR)
8092             && (BRANCH_COST >= 3 ? integer_pow2p (TREE_OPERAND (binary_op, 1))
8093                 : integer_onep (TREE_OPERAND (binary_op, 1)))
8094             && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == '<')
8095           {
8096             rtx result;
8097             optab boptab = (TREE_CODE (binary_op) == PLUS_EXPR
8098                             ? (TYPE_TRAP_SIGNED (TREE_TYPE (binary_op))
8099                                ? addv_optab : add_optab)
8100                             : TREE_CODE (binary_op) == MINUS_EXPR
8101                               ? (TYPE_TRAP_SIGNED (TREE_TYPE (binary_op))
8102                                  ? subv_optab : sub_optab)
8103                             : TREE_CODE (binary_op) == BIT_IOR_EXPR ? ior_optab
8104                             : xor_optab);
8105
8106             /* If we had X ? A : A + 1, do this as A + (X == 0).
8107
8108                We have to invert the truth value here and then put it
8109                back later if do_store_flag fails.  We cannot simply copy
8110                TREE_OPERAND (exp, 0) to another variable and modify that
8111                because invert_truthvalue can modify the tree pointed to
8112                by its argument.  */
8113             if (singleton == TREE_OPERAND (exp, 1))
8114               TREE_OPERAND (exp, 0)
8115                 = invert_truthvalue (TREE_OPERAND (exp, 0));
8116
8117             result = do_store_flag (TREE_OPERAND (exp, 0),
8118                                     (safe_from_p (temp, singleton, 1)
8119                                      ? temp : NULL_RTX),
8120                                     mode, BRANCH_COST <= 1);
8121
8122             if (result != 0 && ! integer_onep (TREE_OPERAND (binary_op, 1)))
8123               result = expand_shift (LSHIFT_EXPR, mode, result,
8124                                      build_int_2 (tree_log2
8125                                                   (TREE_OPERAND
8126                                                    (binary_op, 1)),
8127                                                   0),
8128                                      (safe_from_p (temp, singleton, 1)
8129                                       ? temp : NULL_RTX), 0);
8130
8131             if (result)
8132               {
8133                 op1 = expand_expr (singleton, NULL_RTX, VOIDmode, 0);
8134                 return expand_binop (mode, boptab, op1, result, temp,
8135                                      unsignedp, OPTAB_LIB_WIDEN);
8136               }
8137             else if (singleton == TREE_OPERAND (exp, 1))
8138               TREE_OPERAND (exp, 0)
8139                 = invert_truthvalue (TREE_OPERAND (exp, 0));
8140           }
8141
8142         do_pending_stack_adjust ();
8143         NO_DEFER_POP;
8144         op0 = gen_label_rtx ();
8145
8146         if (singleton && ! TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 0)))
8147           {
8148             if (temp != 0)
8149               {
8150                 /* If the target conflicts with the other operand of the
8151                    binary op, we can't use it.  Also, we can't use the target
8152                    if it is a hard register, because evaluating the condition
8153                    might clobber it.  */
8154                 if ((binary_op
8155                      && ! safe_from_p (temp, TREE_OPERAND (binary_op, 1), 1))
8156                     || (GET_CODE (temp) == REG
8157                         && REGNO (temp) < FIRST_PSEUDO_REGISTER))
8158                   temp = gen_reg_rtx (mode);
8159                 store_expr (singleton, temp, 0);
8160               }
8161             else
8162               expand_expr (singleton,
8163                            ignore ? const0_rtx : NULL_RTX, VOIDmode, 0);
8164             if (singleton == TREE_OPERAND (exp, 1))
8165               jumpif (TREE_OPERAND (exp, 0), op0);
8166             else
8167               jumpifnot (TREE_OPERAND (exp, 0), op0);
8168
8169             start_cleanup_deferral ();
8170             if (binary_op && temp == 0)
8171               /* Just touch the other operand.  */
8172               expand_expr (TREE_OPERAND (binary_op, 1),
8173                            ignore ? const0_rtx : NULL_RTX, VOIDmode, 0);
8174             else if (binary_op)
8175               store_expr (build (TREE_CODE (binary_op), type,
8176                                  make_tree (type, temp),
8177                                  TREE_OPERAND (binary_op, 1)),
8178                           temp, 0);
8179             else
8180               store_expr (build1 (TREE_CODE (unary_op), type,
8181                                   make_tree (type, temp)),
8182                           temp, 0);
8183             op1 = op0;
8184           }
8185         /* Check for A op 0 ? A : FOO and A op 0 ? FOO : A where OP is any
8186            comparison operator.  If we have one of these cases, set the
8187            output to A, branch on A (cse will merge these two references),
8188            then set the output to FOO.  */
8189         else if (temp
8190                  && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == '<'
8191                  && integer_zerop (TREE_OPERAND (TREE_OPERAND (exp, 0), 1))
8192                  && operand_equal_p (TREE_OPERAND (TREE_OPERAND (exp, 0), 0),
8193                                      TREE_OPERAND (exp, 1), 0)
8194                  && (! TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 0))
8195                      || TREE_CODE (TREE_OPERAND (exp, 1)) == SAVE_EXPR)
8196                  && safe_from_p (temp, TREE_OPERAND (exp, 2), 1))
8197           {
8198             if (GET_CODE (temp) == REG
8199                 && REGNO (temp) < FIRST_PSEUDO_REGISTER)
8200               temp = gen_reg_rtx (mode);
8201             store_expr (TREE_OPERAND (exp, 1), temp, 0);
8202             jumpif (TREE_OPERAND (exp, 0), op0);
8203
8204             start_cleanup_deferral ();
8205             store_expr (TREE_OPERAND (exp, 2), temp, 0);
8206             op1 = op0;
8207           }
8208         else if (temp
8209                  && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == '<'
8210                  && integer_zerop (TREE_OPERAND (TREE_OPERAND (exp, 0), 1))
8211                  && operand_equal_p (TREE_OPERAND (TREE_OPERAND (exp, 0), 0),
8212                                      TREE_OPERAND (exp, 2), 0)
8213                  && (! TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 0))
8214                      || TREE_CODE (TREE_OPERAND (exp, 2)) == SAVE_EXPR)
8215                  && safe_from_p (temp, TREE_OPERAND (exp, 1), 1))
8216           {
8217             if (GET_CODE (temp) == REG
8218                 && REGNO (temp) < FIRST_PSEUDO_REGISTER)
8219               temp = gen_reg_rtx (mode);
8220             store_expr (TREE_OPERAND (exp, 2), temp, 0);
8221             jumpifnot (TREE_OPERAND (exp, 0), op0);
8222
8223             start_cleanup_deferral ();
8224             store_expr (TREE_OPERAND (exp, 1), temp, 0);
8225             op1 = op0;
8226           }
8227         else
8228           {
8229             op1 = gen_label_rtx ();
8230             jumpifnot (TREE_OPERAND (exp, 0), op0);
8231
8232             start_cleanup_deferral ();
8233
8234             /* One branch of the cond can be void, if it never returns. For
8235                example A ? throw : E  */
8236             if (temp != 0
8237                 && TREE_TYPE (TREE_OPERAND (exp, 1)) != void_type_node)
8238               store_expr (TREE_OPERAND (exp, 1), temp, 0);
8239             else
8240               expand_expr (TREE_OPERAND (exp, 1),
8241                            ignore ? const0_rtx : NULL_RTX, VOIDmode, 0);
8242             end_cleanup_deferral ();
8243             emit_queue ();
8244             emit_jump_insn (gen_jump (op1));
8245             emit_barrier ();
8246             emit_label (op0);
8247             start_cleanup_deferral ();
8248             if (temp != 0
8249                 && TREE_TYPE (TREE_OPERAND (exp, 2)) != void_type_node)
8250               store_expr (TREE_OPERAND (exp, 2), temp, 0);
8251             else
8252               expand_expr (TREE_OPERAND (exp, 2),
8253                            ignore ? const0_rtx : NULL_RTX, VOIDmode, 0);
8254           }
8255
8256         end_cleanup_deferral ();
8257
8258         emit_queue ();
8259         emit_label (op1);
8260         OK_DEFER_POP;
8261
8262         return temp;
8263       }
8264
8265     case TARGET_EXPR:
8266       {
8267         /* Something needs to be initialized, but we didn't know
8268            where that thing was when building the tree.  For example,
8269            it could be the return value of a function, or a parameter
8270            to a function which lays down in the stack, or a temporary
8271            variable which must be passed by reference.
8272
8273            We guarantee that the expression will either be constructed
8274            or copied into our original target.  */
8275
8276         tree slot = TREE_OPERAND (exp, 0);
8277         tree cleanups = NULL_TREE;
8278         tree exp1;
8279
8280         if (TREE_CODE (slot) != VAR_DECL)
8281           abort ();
8282
8283         if (! ignore)
8284           target = original_target;
8285
8286         /* Set this here so that if we get a target that refers to a
8287            register variable that's already been used, put_reg_into_stack
8288            knows that it should fix up those uses.  */
8289         TREE_USED (slot) = 1;
8290
8291         if (target == 0)
8292           {
8293             if (DECL_RTL_SET_P (slot))
8294               {
8295                 target = DECL_RTL (slot);
8296                 /* If we have already expanded the slot, so don't do
8297                    it again.  (mrs)  */
8298                 if (TREE_OPERAND (exp, 1) == NULL_TREE)
8299                   return target;
8300               }
8301             else
8302               {
8303                 target = assign_temp (type, 2, 0, 1);
8304                 /* All temp slots at this level must not conflict.  */
8305                 preserve_temp_slots (target);
8306                 SET_DECL_RTL (slot, target);
8307                 if (TREE_ADDRESSABLE (slot))
8308                   put_var_into_stack (slot);
8309
8310                 /* Since SLOT is not known to the called function
8311                    to belong to its stack frame, we must build an explicit
8312                    cleanup.  This case occurs when we must build up a reference
8313                    to pass the reference as an argument.  In this case,
8314                    it is very likely that such a reference need not be
8315                    built here.  */
8316
8317                 if (TREE_OPERAND (exp, 2) == 0)
8318                   TREE_OPERAND (exp, 2) = maybe_build_cleanup (slot);
8319                 cleanups = TREE_OPERAND (exp, 2);
8320               }
8321           }
8322         else
8323           {
8324             /* This case does occur, when expanding a parameter which
8325                needs to be constructed on the stack.  The target
8326                is the actual stack address that we want to initialize.
8327                The function we call will perform the cleanup in this case.  */
8328
8329             /* If we have already assigned it space, use that space,
8330                not target that we were passed in, as our target
8331                parameter is only a hint.  */
8332             if (DECL_RTL_SET_P (slot))
8333               {
8334                 target = DECL_RTL (slot);
8335                 /* If we have already expanded the slot, so don't do
8336                    it again.  (mrs)  */
8337                 if (TREE_OPERAND (exp, 1) == NULL_TREE)
8338                   return target;
8339               }
8340             else
8341               {
8342                 SET_DECL_RTL (slot, target);
8343                 /* If we must have an addressable slot, then make sure that
8344                    the RTL that we just stored in slot is OK.  */
8345                 if (TREE_ADDRESSABLE (slot))
8346                   put_var_into_stack (slot);
8347               }
8348           }
8349
8350         exp1 = TREE_OPERAND (exp, 3) = TREE_OPERAND (exp, 1);
8351         /* Mark it as expanded.  */
8352         TREE_OPERAND (exp, 1) = NULL_TREE;
8353
8354         store_expr (exp1, target, 0);
8355
8356         expand_decl_cleanup (NULL_TREE, cleanups);
8357
8358         return target;
8359       }
8360
8361     case INIT_EXPR:
8362       {
8363         tree lhs = TREE_OPERAND (exp, 0);
8364         tree rhs = TREE_OPERAND (exp, 1);
8365
8366         temp = expand_assignment (lhs, rhs, ! ignore, original_target != 0);
8367         return temp;
8368       }
8369
8370     case MODIFY_EXPR:
8371       {
8372         /* If lhs is complex, expand calls in rhs before computing it.
8373            That's so we don't compute a pointer and save it over a
8374            call.  If lhs is simple, compute it first so we can give it
8375            as a target if the rhs is just a call.  This avoids an
8376            extra temp and copy and that prevents a partial-subsumption
8377            which makes bad code.  Actually we could treat
8378            component_ref's of vars like vars.  */
8379
8380         tree lhs = TREE_OPERAND (exp, 0);
8381         tree rhs = TREE_OPERAND (exp, 1);
8382
8383         temp = 0;
8384
8385         /* Check for |= or &= of a bitfield of size one into another bitfield
8386            of size 1.  In this case, (unless we need the result of the
8387            assignment) we can do this more efficiently with a
8388            test followed by an assignment, if necessary.
8389
8390            ??? At this point, we can't get a BIT_FIELD_REF here.  But if
8391            things change so we do, this code should be enhanced to
8392            support it.  */
8393         if (ignore
8394             && TREE_CODE (lhs) == COMPONENT_REF
8395             && (TREE_CODE (rhs) == BIT_IOR_EXPR
8396                 || TREE_CODE (rhs) == BIT_AND_EXPR)
8397             && TREE_OPERAND (rhs, 0) == lhs
8398             && TREE_CODE (TREE_OPERAND (rhs, 1)) == COMPONENT_REF
8399             && integer_onep (DECL_SIZE (TREE_OPERAND (lhs, 1)))
8400             && integer_onep (DECL_SIZE (TREE_OPERAND (TREE_OPERAND (rhs, 1), 1))))
8401           {
8402             rtx label = gen_label_rtx ();
8403
8404             do_jump (TREE_OPERAND (rhs, 1),
8405                      TREE_CODE (rhs) == BIT_IOR_EXPR ? label : 0,
8406                      TREE_CODE (rhs) == BIT_AND_EXPR ? label : 0);
8407             expand_assignment (lhs, convert (TREE_TYPE (rhs),
8408                                              (TREE_CODE (rhs) == BIT_IOR_EXPR
8409                                               ? integer_one_node
8410                                               : integer_zero_node)),
8411                                0, 0);
8412             do_pending_stack_adjust ();
8413             emit_label (label);
8414             return const0_rtx;
8415           }
8416
8417         temp = expand_assignment (lhs, rhs, ! ignore, original_target != 0);
8418
8419         return temp;
8420       }
8421
8422     case RETURN_EXPR:
8423       if (!TREE_OPERAND (exp, 0))
8424         expand_null_return ();
8425       else
8426         expand_return (TREE_OPERAND (exp, 0));
8427       return const0_rtx;
8428
8429     case PREINCREMENT_EXPR:
8430     case PREDECREMENT_EXPR:
8431       return expand_increment (exp, 0, ignore);
8432
8433     case POSTINCREMENT_EXPR:
8434     case POSTDECREMENT_EXPR:
8435       /* Faster to treat as pre-increment if result is not used.  */
8436       return expand_increment (exp, ! ignore, ignore);
8437
8438     case ADDR_EXPR:
8439       /* Are we taking the address of a nested function?  */
8440       if (TREE_CODE (TREE_OPERAND (exp, 0)) == FUNCTION_DECL
8441           && decl_function_context (TREE_OPERAND (exp, 0)) != 0
8442           && ! DECL_NO_STATIC_CHAIN (TREE_OPERAND (exp, 0))
8443           && ! TREE_STATIC (exp))
8444         {
8445           op0 = trampoline_address (TREE_OPERAND (exp, 0));
8446           op0 = force_operand (op0, target);
8447         }
8448       /* If we are taking the address of something erroneous, just
8449          return a zero.  */
8450       else if (TREE_CODE (TREE_OPERAND (exp, 0)) == ERROR_MARK)
8451         return const0_rtx;
8452       /* If we are taking the address of a constant and are at the
8453          top level, we have to use output_constant_def since we can't
8454          call force_const_mem at top level.  */
8455       else if (cfun == 0
8456                && (TREE_CODE (TREE_OPERAND (exp, 0)) == CONSTRUCTOR
8457                    || (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0)))
8458                        == 'c')))
8459         op0 = XEXP (output_constant_def (TREE_OPERAND (exp, 0), 0), 0);
8460       else
8461         {
8462           /* We make sure to pass const0_rtx down if we came in with
8463              ignore set, to avoid doing the cleanups twice for something.  */
8464           op0 = expand_expr (TREE_OPERAND (exp, 0),
8465                              ignore ? const0_rtx : NULL_RTX, VOIDmode,
8466                              (modifier == EXPAND_INITIALIZER
8467                               ? modifier : EXPAND_CONST_ADDRESS));
8468
8469           /* If we are going to ignore the result, OP0 will have been set
8470              to const0_rtx, so just return it.  Don't get confused and
8471              think we are taking the address of the constant.  */
8472           if (ignore)
8473             return op0;
8474
8475           /* Pass 1 for MODIFY, so that protect_from_queue doesn't get
8476              clever and returns a REG when given a MEM.  */
8477           op0 = protect_from_queue (op0, 1);
8478
8479           /* We would like the object in memory.  If it is a constant, we can
8480              have it be statically allocated into memory.  For a non-constant,
8481              we need to allocate some memory and store the value into it.  */
8482
8483           if (CONSTANT_P (op0))
8484             op0 = force_const_mem (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))),
8485                                    op0);
8486           else if (GET_CODE (op0) == REG || GET_CODE (op0) == SUBREG
8487                    || GET_CODE (op0) == CONCAT || GET_CODE (op0) == ADDRESSOF
8488                    || GET_CODE (op0) == PARALLEL)
8489             {
8490               /* If the operand is a SAVE_EXPR, we can deal with this by
8491                  forcing the SAVE_EXPR into memory.  */
8492               if (TREE_CODE (TREE_OPERAND (exp, 0)) == SAVE_EXPR)
8493                 {
8494                   put_var_into_stack (TREE_OPERAND (exp, 0));
8495                   op0 = SAVE_EXPR_RTL (TREE_OPERAND (exp, 0));
8496                 }
8497               else
8498                 {
8499                   /* If this object is in a register, it can't be BLKmode.  */
8500                   tree inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
8501                   rtx memloc = assign_temp (inner_type, 1, 1, 1);
8502
8503                   if (GET_CODE (op0) == PARALLEL)
8504                     /* Handle calls that pass values in multiple
8505                        non-contiguous locations.  The Irix 6 ABI has examples
8506                        of this.  */
8507                     emit_group_store (memloc, op0,
8508                                       int_size_in_bytes (inner_type));
8509                   else
8510                     emit_move_insn (memloc, op0);
8511
8512                   op0 = memloc;
8513                 }
8514             }
8515
8516           if (GET_CODE (op0) != MEM)
8517             abort ();
8518
8519           mark_temp_addr_taken (op0);
8520           if (modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER)
8521             {
8522               op0 = XEXP (op0, 0);
8523 #ifdef POINTERS_EXTEND_UNSIGNED
8524               if (GET_MODE (op0) == Pmode && GET_MODE (op0) != mode
8525                   && mode == ptr_mode)
8526                 op0 = convert_memory_address (ptr_mode, op0);
8527 #endif
8528               return op0;
8529             }
8530
8531           /* If OP0 is not aligned as least as much as the type requires, we
8532              need to make a temporary, copy OP0 to it, and take the address of
8533              the temporary.  We want to use the alignment of the type, not of
8534              the operand.  Note that this is incorrect for FUNCTION_TYPE, but
8535              the test for BLKmode means that can't happen.  The test for
8536              BLKmode is because we never make mis-aligned MEMs with
8537              non-BLKmode.
8538
8539              We don't need to do this at all if the machine doesn't have
8540              strict alignment.  */
8541           if (STRICT_ALIGNMENT && GET_MODE (op0) == BLKmode
8542               && (TYPE_ALIGN (TREE_TYPE (TREE_OPERAND (exp, 0)))
8543                   > MEM_ALIGN (op0))
8544               && MEM_ALIGN (op0) < BIGGEST_ALIGNMENT)
8545             {
8546               tree inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
8547               rtx new
8548                 = assign_stack_temp_for_type
8549                   (TYPE_MODE (inner_type),
8550                    MEM_SIZE (op0) ? INTVAL (MEM_SIZE (op0))
8551                    : int_size_in_bytes (inner_type),
8552                    1, build_qualified_type (inner_type,
8553                                             (TYPE_QUALS (inner_type)
8554                                              | TYPE_QUAL_CONST)));
8555
8556               if (TYPE_ALIGN_OK (inner_type))
8557                 abort ();
8558
8559               emit_block_move (new, op0, expr_size (TREE_OPERAND (exp, 0)));
8560               op0 = new;
8561             }
8562
8563           op0 = force_operand (XEXP (op0, 0), target);
8564         }
8565
8566       if (flag_force_addr
8567           && GET_CODE (op0) != REG
8568           && modifier != EXPAND_CONST_ADDRESS
8569           && modifier != EXPAND_INITIALIZER
8570           && modifier != EXPAND_SUM)
8571         op0 = force_reg (Pmode, op0);
8572
8573       if (GET_CODE (op0) == REG
8574           && ! REG_USERVAR_P (op0))
8575         mark_reg_pointer (op0, TYPE_ALIGN (TREE_TYPE (type)));
8576
8577 #ifdef POINTERS_EXTEND_UNSIGNED
8578       if (GET_MODE (op0) == Pmode && GET_MODE (op0) != mode
8579           && mode == ptr_mode)
8580         op0 = convert_memory_address (ptr_mode, op0);
8581 #endif
8582
8583       return op0;
8584
8585     case ENTRY_VALUE_EXPR:
8586       abort ();
8587
8588     /* COMPLEX type for Extended Pascal & Fortran  */
8589     case COMPLEX_EXPR:
8590       {
8591         enum machine_mode mode = TYPE_MODE (TREE_TYPE (TREE_TYPE (exp)));
8592         rtx insns;
8593
8594         /* Get the rtx code of the operands.  */
8595         op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, 0);
8596         op1 = expand_expr (TREE_OPERAND (exp, 1), 0, VOIDmode, 0);
8597
8598         if (! target)
8599           target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
8600
8601         start_sequence ();
8602
8603         /* Move the real (op0) and imaginary (op1) parts to their location.  */
8604         emit_move_insn (gen_realpart (mode, target), op0);
8605         emit_move_insn (gen_imagpart (mode, target), op1);
8606
8607         insns = get_insns ();
8608         end_sequence ();
8609
8610         /* Complex construction should appear as a single unit.  */
8611         /* If TARGET is a CONCAT, we got insns like RD = RS, ID = IS,
8612            each with a separate pseudo as destination.
8613            It's not correct for flow to treat them as a unit.  */
8614         if (GET_CODE (target) != CONCAT)
8615           emit_no_conflict_block (insns, target, op0, op1, NULL_RTX);
8616         else
8617           emit_insns (insns);
8618
8619         return target;
8620       }
8621
8622     case REALPART_EXPR:
8623       op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, 0);
8624       return gen_realpart (mode, op0);
8625
8626     case IMAGPART_EXPR:
8627       op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, 0);
8628       return gen_imagpart (mode, op0);
8629
8630     case CONJ_EXPR:
8631       {
8632         enum machine_mode partmode = TYPE_MODE (TREE_TYPE (TREE_TYPE (exp)));
8633         rtx imag_t;
8634         rtx insns;
8635
8636         op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, 0);
8637
8638         if (! target)
8639           target = gen_reg_rtx (mode);
8640
8641         start_sequence ();
8642
8643         /* Store the realpart and the negated imagpart to target.  */
8644         emit_move_insn (gen_realpart (partmode, target),
8645                         gen_realpart (partmode, op0));
8646
8647         imag_t = gen_imagpart (partmode, target);
8648         temp = expand_unop (partmode,
8649                             ! unsignedp && flag_trapv
8650                             && (GET_MODE_CLASS(partmode) == MODE_INT)
8651                             ? negv_optab : neg_optab,
8652                             gen_imagpart (partmode, op0), imag_t, 0);
8653         if (temp != imag_t)
8654           emit_move_insn (imag_t, temp);
8655
8656         insns = get_insns ();
8657         end_sequence ();
8658
8659         /* Conjugate should appear as a single unit
8660            If TARGET is a CONCAT, we got insns like RD = RS, ID = - IS,
8661            each with a separate pseudo as destination.
8662            It's not correct for flow to treat them as a unit.  */
8663         if (GET_CODE (target) != CONCAT)
8664           emit_no_conflict_block (insns, target, op0, NULL_RTX, NULL_RTX);
8665         else
8666           emit_insns (insns);
8667
8668         return target;
8669       }
8670
8671     case TRY_CATCH_EXPR:
8672       {
8673         tree handler = TREE_OPERAND (exp, 1);
8674
8675         expand_eh_region_start ();
8676
8677         op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, 0);
8678
8679         expand_eh_region_end_cleanup (handler);
8680
8681         return op0;
8682       }
8683
8684     case TRY_FINALLY_EXPR:
8685       {
8686         tree try_block = TREE_OPERAND (exp, 0);
8687         tree finally_block = TREE_OPERAND (exp, 1);
8688         rtx finally_label = gen_label_rtx ();
8689         rtx done_label = gen_label_rtx ();
8690         rtx return_link = gen_reg_rtx (Pmode);
8691         tree cleanup = build (GOTO_SUBROUTINE_EXPR, void_type_node,
8692                               (tree) finally_label, (tree) return_link);
8693         TREE_SIDE_EFFECTS (cleanup) = 1;
8694
8695         /* Start a new binding layer that will keep track of all cleanup
8696            actions to be performed.  */
8697         expand_start_bindings (2);
8698
8699         target_temp_slot_level = temp_slot_level;
8700
8701         expand_decl_cleanup (NULL_TREE, cleanup);
8702         op0 = expand_expr (try_block, target, tmode, modifier);
8703
8704         preserve_temp_slots (op0);
8705         expand_end_bindings (NULL_TREE, 0, 0);
8706         emit_jump (done_label);
8707         emit_label (finally_label);
8708         expand_expr (finally_block, const0_rtx, VOIDmode, 0);
8709         emit_indirect_jump (return_link);
8710         emit_label (done_label);
8711         return op0;
8712       }
8713
8714     case GOTO_SUBROUTINE_EXPR:
8715       {
8716         rtx subr = (rtx) TREE_OPERAND (exp, 0);
8717         rtx return_link = *(rtx *) &TREE_OPERAND (exp, 1);
8718         rtx return_address = gen_label_rtx ();
8719         emit_move_insn (return_link,
8720                         gen_rtx_LABEL_REF (Pmode, return_address));
8721         emit_jump (subr);
8722         emit_label (return_address);
8723         return const0_rtx;
8724       }
8725
8726     case VA_ARG_EXPR:
8727       return expand_builtin_va_arg (TREE_OPERAND (exp, 0), type);
8728
8729     case EXC_PTR_EXPR:
8730       return get_exception_pointer (cfun);
8731
8732     case FDESC_EXPR:
8733       /* Function descriptors are not valid except for as
8734          initialization constants, and should not be expanded.  */
8735       abort ();
8736
8737     default:
8738       return (*lang_expand_expr) (exp, original_target, tmode, modifier);
8739     }
8740
8741   /* Here to do an ordinary binary operator, generating an instruction
8742      from the optab already placed in `this_optab'.  */
8743  binop:
8744   if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1), 1))
8745     subtarget = 0;
8746   op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
8747   op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
8748  binop2:
8749   temp = expand_binop (mode, this_optab, op0, op1, target,
8750                        unsignedp, OPTAB_LIB_WIDEN);
8751   if (temp == 0)
8752     abort ();
8753   return temp;
8754 }
8755 \f
8756 /* Return the tree node if a ARG corresponds to a string constant or zero
8757    if it doesn't.  If we return non-zero, set *PTR_OFFSET to the offset
8758    in bytes within the string that ARG is accessing.  The type of the
8759    offset will be `sizetype'.  */
8760
8761 tree
8762 string_constant (arg, ptr_offset)
8763      tree arg;
8764      tree *ptr_offset;
8765 {
8766   STRIP_NOPS (arg);
8767
8768   if (TREE_CODE (arg) == ADDR_EXPR
8769       && TREE_CODE (TREE_OPERAND (arg, 0)) == STRING_CST)
8770     {
8771       *ptr_offset = size_zero_node;
8772       return TREE_OPERAND (arg, 0);
8773     }
8774   else if (TREE_CODE (arg) == PLUS_EXPR)
8775     {
8776       tree arg0 = TREE_OPERAND (arg, 0);
8777       tree arg1 = TREE_OPERAND (arg, 1);
8778
8779       STRIP_NOPS (arg0);
8780       STRIP_NOPS (arg1);
8781
8782       if (TREE_CODE (arg0) == ADDR_EXPR
8783           && TREE_CODE (TREE_OPERAND (arg0, 0)) == STRING_CST)
8784         {
8785           *ptr_offset = convert (sizetype, arg1);
8786           return TREE_OPERAND (arg0, 0);
8787         }
8788       else if (TREE_CODE (arg1) == ADDR_EXPR
8789                && TREE_CODE (TREE_OPERAND (arg1, 0)) == STRING_CST)
8790         {
8791           *ptr_offset = convert (sizetype, arg0);
8792           return TREE_OPERAND (arg1, 0);
8793         }
8794     }
8795
8796   return 0;
8797 }
8798 \f
8799 /* Expand code for a post- or pre- increment or decrement
8800    and return the RTX for the result.
8801    POST is 1 for postinc/decrements and 0 for preinc/decrements.  */
8802
8803 static rtx
8804 expand_increment (exp, post, ignore)
8805      tree exp;
8806      int post, ignore;
8807 {
8808   rtx op0, op1;
8809   rtx temp, value;
8810   tree incremented = TREE_OPERAND (exp, 0);
8811   optab this_optab = add_optab;
8812   int icode;
8813   enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
8814   int op0_is_copy = 0;
8815   int single_insn = 0;
8816   /* 1 means we can't store into OP0 directly,
8817      because it is a subreg narrower than a word,
8818      and we don't dare clobber the rest of the word.  */
8819   int bad_subreg = 0;
8820
8821   /* Stabilize any component ref that might need to be
8822      evaluated more than once below.  */
8823   if (!post
8824       || TREE_CODE (incremented) == BIT_FIELD_REF
8825       || (TREE_CODE (incremented) == COMPONENT_REF
8826           && (TREE_CODE (TREE_OPERAND (incremented, 0)) != INDIRECT_REF
8827               || DECL_BIT_FIELD (TREE_OPERAND (incremented, 1)))))
8828     incremented = stabilize_reference (incremented);
8829   /* Nested *INCREMENT_EXPRs can happen in C++.  We must force innermost
8830      ones into save exprs so that they don't accidentally get evaluated
8831      more than once by the code below.  */
8832   if (TREE_CODE (incremented) == PREINCREMENT_EXPR
8833       || TREE_CODE (incremented) == PREDECREMENT_EXPR)
8834     incremented = save_expr (incremented);
8835
8836   /* Compute the operands as RTX.
8837      Note whether OP0 is the actual lvalue or a copy of it:
8838      I believe it is a copy iff it is a register or subreg
8839      and insns were generated in computing it.  */
8840
8841   temp = get_last_insn ();
8842   op0 = expand_expr (incremented, NULL_RTX, VOIDmode, 0);
8843
8844   /* If OP0 is a SUBREG made for a promoted variable, we cannot increment
8845      in place but instead must do sign- or zero-extension during assignment,
8846      so we copy it into a new register and let the code below use it as
8847      a copy.
8848
8849      Note that we can safely modify this SUBREG since it is know not to be
8850      shared (it was made by the expand_expr call above).  */
8851
8852   if (GET_CODE (op0) == SUBREG && SUBREG_PROMOTED_VAR_P (op0))
8853     {
8854       if (post)
8855         SUBREG_REG (op0) = copy_to_reg (SUBREG_REG (op0));
8856       else
8857         bad_subreg = 1;
8858     }
8859   else if (GET_CODE (op0) == SUBREG
8860            && GET_MODE_BITSIZE (GET_MODE (op0)) < BITS_PER_WORD)
8861     {
8862       /* We cannot increment this SUBREG in place.  If we are
8863          post-incrementing, get a copy of the old value.  Otherwise,
8864          just mark that we cannot increment in place.  */
8865       if (post)
8866         op0 = copy_to_reg (op0);
8867       else
8868         bad_subreg = 1;
8869     }
8870
8871   op0_is_copy = ((GET_CODE (op0) == SUBREG || GET_CODE (op0) == REG)
8872                  && temp != get_last_insn ());
8873   op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
8874
8875   /* Decide whether incrementing or decrementing.  */
8876   if (TREE_CODE (exp) == POSTDECREMENT_EXPR
8877       || TREE_CODE (exp) == PREDECREMENT_EXPR)
8878     this_optab = sub_optab;
8879
8880   /* Convert decrement by a constant into a negative increment.  */
8881   if (this_optab == sub_optab
8882       && GET_CODE (op1) == CONST_INT)
8883     {
8884       op1 = GEN_INT (-INTVAL (op1));
8885       this_optab = add_optab;
8886     }
8887
8888   if (TYPE_TRAP_SIGNED (TREE_TYPE (exp)))
8889     this_optab = this_optab == add_optab ? addv_optab : subv_optab;
8890
8891   /* For a preincrement, see if we can do this with a single instruction.  */
8892   if (!post)
8893     {
8894       icode = (int) this_optab->handlers[(int) mode].insn_code;
8895       if (icode != (int) CODE_FOR_nothing
8896           /* Make sure that OP0 is valid for operands 0 and 1
8897              of the insn we want to queue.  */
8898           && (*insn_data[icode].operand[0].predicate) (op0, mode)
8899           && (*insn_data[icode].operand[1].predicate) (op0, mode)
8900           && (*insn_data[icode].operand[2].predicate) (op1, mode))
8901         single_insn = 1;
8902     }
8903
8904   /* If OP0 is not the actual lvalue, but rather a copy in a register,
8905      then we cannot just increment OP0.  We must therefore contrive to
8906      increment the original value.  Then, for postincrement, we can return
8907      OP0 since it is a copy of the old value.  For preincrement, expand here
8908      unless we can do it with a single insn.
8909
8910      Likewise if storing directly into OP0 would clobber high bits
8911      we need to preserve (bad_subreg).  */
8912   if (op0_is_copy || (!post && !single_insn) || bad_subreg)
8913     {
8914       /* This is the easiest way to increment the value wherever it is.
8915          Problems with multiple evaluation of INCREMENTED are prevented
8916          because either (1) it is a component_ref or preincrement,
8917          in which case it was stabilized above, or (2) it is an array_ref
8918          with constant index in an array in a register, which is
8919          safe to reevaluate.  */
8920       tree newexp = build (((TREE_CODE (exp) == POSTDECREMENT_EXPR
8921                              || TREE_CODE (exp) == PREDECREMENT_EXPR)
8922                             ? MINUS_EXPR : PLUS_EXPR),
8923                            TREE_TYPE (exp),
8924                            incremented,
8925                            TREE_OPERAND (exp, 1));
8926
8927       while (TREE_CODE (incremented) == NOP_EXPR
8928              || TREE_CODE (incremented) == CONVERT_EXPR)
8929         {
8930           newexp = convert (TREE_TYPE (incremented), newexp);
8931           incremented = TREE_OPERAND (incremented, 0);
8932         }
8933
8934       temp = expand_assignment (incremented, newexp, ! post && ! ignore , 0);
8935       return post ? op0 : temp;
8936     }
8937
8938   if (post)
8939     {
8940       /* We have a true reference to the value in OP0.
8941          If there is an insn to add or subtract in this mode, queue it.
8942          Queueing the increment insn avoids the register shuffling
8943          that often results if we must increment now and first save
8944          the old value for subsequent use.  */
8945
8946 #if 0  /* Turned off to avoid making extra insn for indexed memref.  */
8947       op0 = stabilize (op0);
8948 #endif
8949
8950       icode = (int) this_optab->handlers[(int) mode].insn_code;
8951       if (icode != (int) CODE_FOR_nothing
8952           /* Make sure that OP0 is valid for operands 0 and 1
8953              of the insn we want to queue.  */
8954           && (*insn_data[icode].operand[0].predicate) (op0, mode)
8955           && (*insn_data[icode].operand[1].predicate) (op0, mode))
8956         {
8957           if (! (*insn_data[icode].operand[2].predicate) (op1, mode))
8958             op1 = force_reg (mode, op1);
8959
8960           return enqueue_insn (op0, GEN_FCN (icode) (op0, op0, op1));
8961         }
8962       if (icode != (int) CODE_FOR_nothing && GET_CODE (op0) == MEM)
8963         {
8964           rtx addr = (general_operand (XEXP (op0, 0), mode)
8965                       ? force_reg (Pmode, XEXP (op0, 0))
8966                       : copy_to_reg (XEXP (op0, 0)));
8967           rtx temp, result;
8968
8969           op0 = replace_equiv_address (op0, addr);
8970           temp = force_reg (GET_MODE (op0), op0);
8971           if (! (*insn_data[icode].operand[2].predicate) (op1, mode))
8972             op1 = force_reg (mode, op1);
8973
8974           /* The increment queue is LIFO, thus we have to `queue'
8975              the instructions in reverse order.  */
8976           enqueue_insn (op0, gen_move_insn (op0, temp));
8977           result = enqueue_insn (temp, GEN_FCN (icode) (temp, temp, op1));
8978           return result;
8979         }
8980     }
8981
8982   /* Preincrement, or we can't increment with one simple insn.  */
8983   if (post)
8984     /* Save a copy of the value before inc or dec, to return it later.  */
8985     temp = value = copy_to_reg (op0);
8986   else
8987     /* Arrange to return the incremented value.  */
8988     /* Copy the rtx because expand_binop will protect from the queue,
8989        and the results of that would be invalid for us to return
8990        if our caller does emit_queue before using our result.  */
8991     temp = copy_rtx (value = op0);
8992
8993   /* Increment however we can.  */
8994   op1 = expand_binop (mode, this_optab, value, op1, op0,
8995                       TREE_UNSIGNED (TREE_TYPE (exp)), OPTAB_LIB_WIDEN);
8996
8997   /* Make sure the value is stored into OP0.  */
8998   if (op1 != op0)
8999     emit_move_insn (op0, op1);
9000
9001   return temp;
9002 }
9003 \f
9004 /* At the start of a function, record that we have no previously-pushed
9005    arguments waiting to be popped.  */
9006
9007 void
9008 init_pending_stack_adjust ()
9009 {
9010   pending_stack_adjust = 0;
9011 }
9012
9013 /* When exiting from function, if safe, clear out any pending stack adjust
9014    so the adjustment won't get done.
9015
9016    Note, if the current function calls alloca, then it must have a
9017    frame pointer regardless of the value of flag_omit_frame_pointer.  */
9018
9019 void
9020 clear_pending_stack_adjust ()
9021 {
9022 #ifdef EXIT_IGNORE_STACK
9023   if (optimize > 0
9024       && (! flag_omit_frame_pointer || current_function_calls_alloca)
9025       && EXIT_IGNORE_STACK
9026       && ! (DECL_INLINE (current_function_decl) && ! flag_no_inline)
9027       && ! flag_inline_functions)
9028     {
9029       stack_pointer_delta -= pending_stack_adjust,
9030       pending_stack_adjust = 0;
9031     }
9032 #endif
9033 }
9034
9035 /* Pop any previously-pushed arguments that have not been popped yet.  */
9036
9037 void
9038 do_pending_stack_adjust ()
9039 {
9040   if (inhibit_defer_pop == 0)
9041     {
9042       if (pending_stack_adjust != 0)
9043         adjust_stack (GEN_INT (pending_stack_adjust));
9044       pending_stack_adjust = 0;
9045     }
9046 }
9047 \f
9048 /* Expand conditional expressions.  */
9049
9050 /* Generate code to evaluate EXP and jump to LABEL if the value is zero.
9051    LABEL is an rtx of code CODE_LABEL, in this function and all the
9052    functions here.  */
9053
9054 void
9055 jumpifnot (exp, label)
9056      tree exp;
9057      rtx label;
9058 {
9059   do_jump (exp, label, NULL_RTX);
9060 }
9061
9062 /* Generate code to evaluate EXP and jump to LABEL if the value is nonzero.  */
9063
9064 void
9065 jumpif (exp, label)
9066      tree exp;
9067      rtx label;
9068 {
9069   do_jump (exp, NULL_RTX, label);
9070 }
9071
9072 /* Generate code to evaluate EXP and jump to IF_FALSE_LABEL if
9073    the result is zero, or IF_TRUE_LABEL if the result is one.
9074    Either of IF_FALSE_LABEL and IF_TRUE_LABEL may be zero,
9075    meaning fall through in that case.
9076
9077    do_jump always does any pending stack adjust except when it does not
9078    actually perform a jump.  An example where there is no jump
9079    is when EXP is `(foo (), 0)' and IF_FALSE_LABEL is null.
9080
9081    This function is responsible for optimizing cases such as
9082    &&, || and comparison operators in EXP.  */
9083
9084 void
9085 do_jump (exp, if_false_label, if_true_label)
9086      tree exp;
9087      rtx if_false_label, if_true_label;
9088 {
9089   enum tree_code code = TREE_CODE (exp);
9090   /* Some cases need to create a label to jump to
9091      in order to properly fall through.
9092      These cases set DROP_THROUGH_LABEL nonzero.  */
9093   rtx drop_through_label = 0;
9094   rtx temp;
9095   int i;
9096   tree type;
9097   enum machine_mode mode;
9098
9099 #ifdef MAX_INTEGER_COMPUTATION_MODE
9100   check_max_integer_computation_mode (exp);
9101 #endif
9102
9103   emit_queue ();
9104
9105   switch (code)
9106     {
9107     case ERROR_MARK:
9108       break;
9109
9110     case INTEGER_CST:
9111       temp = integer_zerop (exp) ? if_false_label : if_true_label;
9112       if (temp)
9113         emit_jump (temp);
9114       break;
9115
9116 #if 0
9117       /* This is not true with #pragma weak  */
9118     case ADDR_EXPR:
9119       /* The address of something can never be zero.  */
9120       if (if_true_label)
9121         emit_jump (if_true_label);
9122       break;
9123 #endif
9124
9125     case NOP_EXPR:
9126       if (TREE_CODE (TREE_OPERAND (exp, 0)) == COMPONENT_REF
9127           || TREE_CODE (TREE_OPERAND (exp, 0)) == BIT_FIELD_REF
9128           || TREE_CODE (TREE_OPERAND (exp, 0)) == ARRAY_REF
9129           || TREE_CODE (TREE_OPERAND (exp, 0)) == ARRAY_RANGE_REF)
9130         goto normal;
9131     case CONVERT_EXPR:
9132       /* If we are narrowing the operand, we have to do the compare in the
9133          narrower mode.  */
9134       if ((TYPE_PRECISION (TREE_TYPE (exp))
9135            < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp, 0)))))
9136         goto normal;
9137     case NON_LVALUE_EXPR:
9138     case REFERENCE_EXPR:
9139     case ABS_EXPR:
9140     case NEGATE_EXPR:
9141     case LROTATE_EXPR:
9142     case RROTATE_EXPR:
9143       /* These cannot change zero->non-zero or vice versa.  */
9144       do_jump (TREE_OPERAND (exp, 0), if_false_label, if_true_label);
9145       break;
9146
9147     case WITH_RECORD_EXPR:
9148       /* Put the object on the placeholder list, recurse through our first
9149          operand, and pop the list.  */
9150       placeholder_list = tree_cons (TREE_OPERAND (exp, 1), NULL_TREE,
9151                                     placeholder_list);
9152       do_jump (TREE_OPERAND (exp, 0), if_false_label, if_true_label);
9153       placeholder_list = TREE_CHAIN (placeholder_list);
9154       break;
9155
9156 #if 0
9157       /* This is never less insns than evaluating the PLUS_EXPR followed by
9158          a test and can be longer if the test is eliminated.  */
9159     case PLUS_EXPR:
9160       /* Reduce to minus.  */
9161       exp = build (MINUS_EXPR, TREE_TYPE (exp),
9162                    TREE_OPERAND (exp, 0),
9163                    fold (build1 (NEGATE_EXPR, TREE_TYPE (TREE_OPERAND (exp, 1)),
9164                                  TREE_OPERAND (exp, 1))));
9165       /* Process as MINUS.  */
9166 #endif
9167
9168     case MINUS_EXPR:
9169       /* Non-zero iff operands of minus differ.  */
9170       do_compare_and_jump (build (NE_EXPR, TREE_TYPE (exp),
9171                                   TREE_OPERAND (exp, 0),
9172                                   TREE_OPERAND (exp, 1)),
9173                            NE, NE, if_false_label, if_true_label);
9174       break;
9175
9176     case BIT_AND_EXPR:
9177       /* If we are AND'ing with a small constant, do this comparison in the
9178          smallest type that fits.  If the machine doesn't have comparisons
9179          that small, it will be converted back to the wider comparison.
9180          This helps if we are testing the sign bit of a narrower object.
9181          combine can't do this for us because it can't know whether a
9182          ZERO_EXTRACT or a compare in a smaller mode exists, but we do.  */
9183
9184       if (! SLOW_BYTE_ACCESS
9185           && TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST
9186           && TYPE_PRECISION (TREE_TYPE (exp)) <= HOST_BITS_PER_WIDE_INT
9187           && (i = tree_floor_log2 (TREE_OPERAND (exp, 1))) >= 0
9188           && (mode = mode_for_size (i + 1, MODE_INT, 0)) != BLKmode
9189           && (type = type_for_mode (mode, 1)) != 0
9190           && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (exp))
9191           && (cmp_optab->handlers[(int) TYPE_MODE (type)].insn_code
9192               != CODE_FOR_nothing))
9193         {
9194           do_jump (convert (type, exp), if_false_label, if_true_label);
9195           break;
9196         }
9197       goto normal;
9198
9199     case TRUTH_NOT_EXPR:
9200       do_jump (TREE_OPERAND (exp, 0), if_true_label, if_false_label);
9201       break;
9202
9203     case TRUTH_ANDIF_EXPR:
9204       if (if_false_label == 0)
9205         if_false_label = drop_through_label = gen_label_rtx ();
9206       do_jump (TREE_OPERAND (exp, 0), if_false_label, NULL_RTX);
9207       start_cleanup_deferral ();
9208       do_jump (TREE_OPERAND (exp, 1), if_false_label, if_true_label);
9209       end_cleanup_deferral ();
9210       break;
9211
9212     case TRUTH_ORIF_EXPR:
9213       if (if_true_label == 0)
9214         if_true_label = drop_through_label = gen_label_rtx ();
9215       do_jump (TREE_OPERAND (exp, 0), NULL_RTX, if_true_label);
9216       start_cleanup_deferral ();
9217       do_jump (TREE_OPERAND (exp, 1), if_false_label, if_true_label);
9218       end_cleanup_deferral ();
9219       break;
9220
9221     case COMPOUND_EXPR:
9222       push_temp_slots ();
9223       expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode, 0);
9224       preserve_temp_slots (NULL_RTX);
9225       free_temp_slots ();
9226       pop_temp_slots ();
9227       emit_queue ();
9228       do_pending_stack_adjust ();
9229       do_jump (TREE_OPERAND (exp, 1), if_false_label, if_true_label);
9230       break;
9231
9232     case COMPONENT_REF:
9233     case BIT_FIELD_REF:
9234     case ARRAY_REF:
9235     case ARRAY_RANGE_REF:
9236       {
9237         HOST_WIDE_INT bitsize, bitpos;
9238         int unsignedp;
9239         enum machine_mode mode;
9240         tree type;
9241         tree offset;
9242         int volatilep = 0;
9243
9244         /* Get description of this reference.  We don't actually care
9245            about the underlying object here.  */
9246         get_inner_reference (exp, &bitsize, &bitpos, &offset, &mode,
9247                              &unsignedp, &volatilep);
9248
9249         type = type_for_size (bitsize, unsignedp);
9250         if (! SLOW_BYTE_ACCESS
9251             && type != 0 && bitsize >= 0
9252             && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (exp))
9253             && (cmp_optab->handlers[(int) TYPE_MODE (type)].insn_code
9254                 != CODE_FOR_nothing))
9255           {
9256             do_jump (convert (type, exp), if_false_label, if_true_label);
9257             break;
9258           }
9259         goto normal;
9260       }
9261
9262     case COND_EXPR:
9263       /* Do (a ? 1 : 0) and (a ? 0 : 1) as special cases.  */
9264       if (integer_onep (TREE_OPERAND (exp, 1))
9265           && integer_zerop (TREE_OPERAND (exp, 2)))
9266         do_jump (TREE_OPERAND (exp, 0), if_false_label, if_true_label);
9267
9268       else if (integer_zerop (TREE_OPERAND (exp, 1))
9269                && integer_onep (TREE_OPERAND (exp, 2)))
9270         do_jump (TREE_OPERAND (exp, 0), if_true_label, if_false_label);
9271
9272       else
9273         {
9274           rtx label1 = gen_label_rtx ();
9275           drop_through_label = gen_label_rtx ();
9276
9277           do_jump (TREE_OPERAND (exp, 0), label1, NULL_RTX);
9278
9279           start_cleanup_deferral ();
9280           /* Now the THEN-expression.  */
9281           do_jump (TREE_OPERAND (exp, 1),
9282                    if_false_label ? if_false_label : drop_through_label,
9283                    if_true_label ? if_true_label : drop_through_label);
9284           /* In case the do_jump just above never jumps.  */
9285           do_pending_stack_adjust ();
9286           emit_label (label1);
9287
9288           /* Now the ELSE-expression.  */
9289           do_jump (TREE_OPERAND (exp, 2),
9290                    if_false_label ? if_false_label : drop_through_label,
9291                    if_true_label ? if_true_label : drop_through_label);
9292           end_cleanup_deferral ();
9293         }
9294       break;
9295
9296     case EQ_EXPR:
9297       {
9298         tree inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
9299
9300         if (GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_COMPLEX_FLOAT
9301             || GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_COMPLEX_INT)
9302           {
9303             tree exp0 = save_expr (TREE_OPERAND (exp, 0));
9304             tree exp1 = save_expr (TREE_OPERAND (exp, 1));
9305             do_jump
9306               (fold
9307                (build (TRUTH_ANDIF_EXPR, TREE_TYPE (exp),
9308                        fold (build (EQ_EXPR, TREE_TYPE (exp),
9309                                     fold (build1 (REALPART_EXPR,
9310                                                   TREE_TYPE (inner_type),
9311                                                   exp0)),
9312                                     fold (build1 (REALPART_EXPR,
9313                                                   TREE_TYPE (inner_type),
9314                                                   exp1)))),
9315                        fold (build (EQ_EXPR, TREE_TYPE (exp),
9316                                     fold (build1 (IMAGPART_EXPR,
9317                                                   TREE_TYPE (inner_type),
9318                                                   exp0)),
9319                                     fold (build1 (IMAGPART_EXPR,
9320                                                   TREE_TYPE (inner_type),
9321                                                   exp1)))))),
9322                if_false_label, if_true_label);
9323           }
9324
9325         else if (integer_zerop (TREE_OPERAND (exp, 1)))
9326           do_jump (TREE_OPERAND (exp, 0), if_true_label, if_false_label);
9327
9328         else if (GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_INT
9329                  && !can_compare_p (EQ, TYPE_MODE (inner_type), ccp_jump))
9330           do_jump_by_parts_equality (exp, if_false_label, if_true_label);
9331         else
9332           do_compare_and_jump (exp, EQ, EQ, if_false_label, if_true_label);
9333         break;
9334       }
9335
9336     case NE_EXPR:
9337       {
9338         tree inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
9339
9340         if (GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_COMPLEX_FLOAT
9341             || GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_COMPLEX_INT)
9342           {
9343             tree exp0 = save_expr (TREE_OPERAND (exp, 0));
9344             tree exp1 = save_expr (TREE_OPERAND (exp, 1));
9345             do_jump
9346               (fold
9347                (build (TRUTH_ORIF_EXPR, TREE_TYPE (exp),
9348                        fold (build (NE_EXPR, TREE_TYPE (exp),
9349                                     fold (build1 (REALPART_EXPR,
9350                                                   TREE_TYPE (inner_type),
9351                                                   exp0)),
9352                                     fold (build1 (REALPART_EXPR,
9353                                                   TREE_TYPE (inner_type),
9354                                                   exp1)))),
9355                        fold (build (NE_EXPR, TREE_TYPE (exp),
9356                                     fold (build1 (IMAGPART_EXPR,
9357                                                   TREE_TYPE (inner_type),
9358                                                   exp0)),
9359                                     fold (build1 (IMAGPART_EXPR,
9360                                                   TREE_TYPE (inner_type),
9361                                                   exp1)))))),
9362                if_false_label, if_true_label);
9363           }
9364
9365         else if (integer_zerop (TREE_OPERAND (exp, 1)))
9366           do_jump (TREE_OPERAND (exp, 0), if_false_label, if_true_label);
9367
9368         else if (GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_INT
9369                  && !can_compare_p (NE, TYPE_MODE (inner_type), ccp_jump))
9370           do_jump_by_parts_equality (exp, if_true_label, if_false_label);
9371         else
9372           do_compare_and_jump (exp, NE, NE, if_false_label, if_true_label);
9373         break;
9374       }
9375
9376     case LT_EXPR:
9377       mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
9378       if (GET_MODE_CLASS (mode) == MODE_INT
9379           && ! can_compare_p (LT, mode, ccp_jump))
9380         do_jump_by_parts_greater (exp, 1, if_false_label, if_true_label);
9381       else
9382         do_compare_and_jump (exp, LT, LTU, if_false_label, if_true_label);
9383       break;
9384
9385     case LE_EXPR:
9386       mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
9387       if (GET_MODE_CLASS (mode) == MODE_INT
9388           && ! can_compare_p (LE, mode, ccp_jump))
9389         do_jump_by_parts_greater (exp, 0, if_true_label, if_false_label);
9390       else
9391         do_compare_and_jump (exp, LE, LEU, if_false_label, if_true_label);
9392       break;
9393
9394     case GT_EXPR:
9395       mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
9396       if (GET_MODE_CLASS (mode) == MODE_INT
9397           && ! can_compare_p (GT, mode, ccp_jump))
9398         do_jump_by_parts_greater (exp, 0, if_false_label, if_true_label);
9399       else
9400         do_compare_and_jump (exp, GT, GTU, if_false_label, if_true_label);
9401       break;
9402
9403     case GE_EXPR:
9404       mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
9405       if (GET_MODE_CLASS (mode) == MODE_INT
9406           && ! can_compare_p (GE, mode, ccp_jump))
9407         do_jump_by_parts_greater (exp, 1, if_true_label, if_false_label);
9408       else
9409         do_compare_and_jump (exp, GE, GEU, if_false_label, if_true_label);
9410       break;
9411
9412     case UNORDERED_EXPR:
9413     case ORDERED_EXPR:
9414       {
9415         enum rtx_code cmp, rcmp;
9416         int do_rev;
9417
9418         if (code == UNORDERED_EXPR)
9419           cmp = UNORDERED, rcmp = ORDERED;
9420         else
9421           cmp = ORDERED, rcmp = UNORDERED;
9422         mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
9423
9424         do_rev = 0;
9425         if (! can_compare_p (cmp, mode, ccp_jump)
9426             && (can_compare_p (rcmp, mode, ccp_jump)
9427                 /* If the target doesn't provide either UNORDERED or ORDERED
9428                    comparisons, canonicalize on UNORDERED for the library.  */
9429                 || rcmp == UNORDERED))
9430           do_rev = 1;
9431
9432         if (! do_rev)
9433           do_compare_and_jump (exp, cmp, cmp, if_false_label, if_true_label);
9434         else
9435           do_compare_and_jump (exp, rcmp, rcmp, if_true_label, if_false_label);
9436       }
9437       break;
9438
9439     {
9440       enum rtx_code rcode1;
9441       enum tree_code tcode2;
9442
9443       case UNLT_EXPR:
9444         rcode1 = UNLT;
9445         tcode2 = LT_EXPR;
9446         goto unordered_bcc;
9447       case UNLE_EXPR:
9448         rcode1 = UNLE;
9449         tcode2 = LE_EXPR;
9450         goto unordered_bcc;
9451       case UNGT_EXPR:
9452         rcode1 = UNGT;
9453         tcode2 = GT_EXPR;
9454         goto unordered_bcc;
9455       case UNGE_EXPR:
9456         rcode1 = UNGE;
9457         tcode2 = GE_EXPR;
9458         goto unordered_bcc;
9459       case UNEQ_EXPR:
9460         rcode1 = UNEQ;
9461         tcode2 = EQ_EXPR;
9462         goto unordered_bcc;
9463
9464       unordered_bcc:
9465         mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
9466         if (can_compare_p (rcode1, mode, ccp_jump))
9467           do_compare_and_jump (exp, rcode1, rcode1, if_false_label,
9468                                if_true_label);
9469         else
9470           {
9471             tree op0 = save_expr (TREE_OPERAND (exp, 0));
9472             tree op1 = save_expr (TREE_OPERAND (exp, 1));
9473             tree cmp0, cmp1;
9474
9475             /* If the target doesn't support combined unordered
9476                compares, decompose into UNORDERED + comparison.  */
9477             cmp0 = fold (build (UNORDERED_EXPR, TREE_TYPE (exp), op0, op1));
9478             cmp1 = fold (build (tcode2, TREE_TYPE (exp), op0, op1));
9479             exp = build (TRUTH_ORIF_EXPR, TREE_TYPE (exp), cmp0, cmp1);
9480             do_jump (exp, if_false_label, if_true_label);
9481           }
9482       }
9483       break;
9484
9485       /* Special case:
9486                 __builtin_expect (<test>, 0)    and
9487                 __builtin_expect (<test>, 1)
9488
9489          We need to do this here, so that <test> is not converted to a SCC
9490          operation on machines that use condition code registers and COMPARE
9491          like the PowerPC, and then the jump is done based on whether the SCC
9492          operation produced a 1 or 0.  */
9493     case CALL_EXPR:
9494       /* Check for a built-in function.  */
9495       if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR)
9496         {
9497           tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
9498           tree arglist = TREE_OPERAND (exp, 1);
9499
9500           if (TREE_CODE (fndecl) == FUNCTION_DECL
9501               && DECL_BUILT_IN (fndecl)
9502               && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_EXPECT
9503               && arglist != NULL_TREE
9504               && TREE_CHAIN (arglist) != NULL_TREE)
9505             {
9506               rtx seq = expand_builtin_expect_jump (exp, if_false_label,
9507                                                     if_true_label);
9508
9509               if (seq != NULL_RTX)
9510                 {
9511                   emit_insn (seq);
9512                   return;
9513                 }
9514             }
9515         }
9516       /* fall through and generate the normal code.  */
9517
9518     default:
9519     normal:
9520       temp = expand_expr (exp, NULL_RTX, VOIDmode, 0);
9521 #if 0
9522       /* This is not needed any more and causes poor code since it causes
9523          comparisons and tests from non-SI objects to have different code
9524          sequences.  */
9525       /* Copy to register to avoid generating bad insns by cse
9526          from (set (mem ...) (arithop))  (set (cc0) (mem ...)).  */
9527       if (!cse_not_expected && GET_CODE (temp) == MEM)
9528         temp = copy_to_reg (temp);
9529 #endif
9530       do_pending_stack_adjust ();
9531       /* Do any postincrements in the expression that was tested.  */
9532       emit_queue ();
9533
9534       if (GET_CODE (temp) == CONST_INT
9535           || (GET_CODE (temp) == CONST_DOUBLE && GET_MODE (temp) == VOIDmode)
9536           || GET_CODE (temp) == LABEL_REF)
9537         {
9538           rtx target = temp == const0_rtx ? if_false_label : if_true_label;
9539           if (target)
9540             emit_jump (target);
9541         }
9542       else if (GET_MODE_CLASS (GET_MODE (temp)) == MODE_INT
9543                && ! can_compare_p (NE, GET_MODE (temp), ccp_jump))
9544         /* Note swapping the labels gives us not-equal.  */
9545         do_jump_by_parts_equality_rtx (temp, if_true_label, if_false_label);
9546       else if (GET_MODE (temp) != VOIDmode)
9547         do_compare_rtx_and_jump (temp, CONST0_RTX (GET_MODE (temp)),
9548                                  NE, TREE_UNSIGNED (TREE_TYPE (exp)),
9549                                  GET_MODE (temp), NULL_RTX,
9550                                  if_false_label, if_true_label);
9551       else
9552         abort ();
9553     }
9554
9555   if (drop_through_label)
9556     {
9557       /* If do_jump produces code that might be jumped around,
9558          do any stack adjusts from that code, before the place
9559          where control merges in.  */
9560       do_pending_stack_adjust ();
9561       emit_label (drop_through_label);
9562     }
9563 }
9564 \f
9565 /* Given a comparison expression EXP for values too wide to be compared
9566    with one insn, test the comparison and jump to the appropriate label.
9567    The code of EXP is ignored; we always test GT if SWAP is 0,
9568    and LT if SWAP is 1.  */
9569
9570 static void
9571 do_jump_by_parts_greater (exp, swap, if_false_label, if_true_label)
9572      tree exp;
9573      int swap;
9574      rtx if_false_label, if_true_label;
9575 {
9576   rtx op0 = expand_expr (TREE_OPERAND (exp, swap), NULL_RTX, VOIDmode, 0);
9577   rtx op1 = expand_expr (TREE_OPERAND (exp, !swap), NULL_RTX, VOIDmode, 0);
9578   enum machine_mode mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
9579   int unsignedp = TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0)));
9580
9581   do_jump_by_parts_greater_rtx (mode, unsignedp, op0, op1, if_false_label, if_true_label);
9582 }
9583
9584 /* Compare OP0 with OP1, word at a time, in mode MODE.
9585    UNSIGNEDP says to do unsigned comparison.
9586    Jump to IF_TRUE_LABEL if OP0 is greater, IF_FALSE_LABEL otherwise.  */
9587
9588 void
9589 do_jump_by_parts_greater_rtx (mode, unsignedp, op0, op1, if_false_label, if_true_label)
9590      enum machine_mode mode;
9591      int unsignedp;
9592      rtx op0, op1;
9593      rtx if_false_label, if_true_label;
9594 {
9595   int nwords = (GET_MODE_SIZE (mode) / UNITS_PER_WORD);
9596   rtx drop_through_label = 0;
9597   int i;
9598
9599   if (! if_true_label || ! if_false_label)
9600     drop_through_label = gen_label_rtx ();
9601   if (! if_true_label)
9602     if_true_label = drop_through_label;
9603   if (! if_false_label)
9604     if_false_label = drop_through_label;
9605
9606   /* Compare a word at a time, high order first.  */
9607   for (i = 0; i < nwords; i++)
9608     {
9609       rtx op0_word, op1_word;
9610
9611       if (WORDS_BIG_ENDIAN)
9612         {
9613           op0_word = operand_subword_force (op0, i, mode);
9614           op1_word = operand_subword_force (op1, i, mode);
9615         }
9616       else
9617         {
9618           op0_word = operand_subword_force (op0, nwords - 1 - i, mode);
9619           op1_word = operand_subword_force (op1, nwords - 1 - i, mode);
9620         }
9621
9622       /* All but high-order word must be compared as unsigned.  */
9623       do_compare_rtx_and_jump (op0_word, op1_word, GT,
9624                                (unsignedp || i > 0), word_mode, NULL_RTX,
9625                                NULL_RTX, if_true_label);
9626
9627       /* Consider lower words only if these are equal.  */
9628       do_compare_rtx_and_jump (op0_word, op1_word, NE, unsignedp, word_mode,
9629                                NULL_RTX, NULL_RTX, if_false_label);
9630     }
9631
9632   if (if_false_label)
9633     emit_jump (if_false_label);
9634   if (drop_through_label)
9635     emit_label (drop_through_label);
9636 }
9637
9638 /* Given an EQ_EXPR expression EXP for values too wide to be compared
9639    with one insn, test the comparison and jump to the appropriate label.  */
9640
9641 static void
9642 do_jump_by_parts_equality (exp, if_false_label, if_true_label)
9643      tree exp;
9644      rtx if_false_label, if_true_label;
9645 {
9646   rtx op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode, 0);
9647   rtx op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
9648   enum machine_mode mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
9649   int nwords = (GET_MODE_SIZE (mode) / UNITS_PER_WORD);
9650   int i;
9651   rtx drop_through_label = 0;
9652
9653   if (! if_false_label)
9654     drop_through_label = if_false_label = gen_label_rtx ();
9655
9656   for (i = 0; i < nwords; i++)
9657     do_compare_rtx_and_jump (operand_subword_force (op0, i, mode),
9658                              operand_subword_force (op1, i, mode),
9659                              EQ, TREE_UNSIGNED (TREE_TYPE (exp)),
9660                              word_mode, NULL_RTX, if_false_label, NULL_RTX);
9661
9662   if (if_true_label)
9663     emit_jump (if_true_label);
9664   if (drop_through_label)
9665     emit_label (drop_through_label);
9666 }
9667 \f
9668 /* Jump according to whether OP0 is 0.
9669    We assume that OP0 has an integer mode that is too wide
9670    for the available compare insns.  */
9671
9672 void
9673 do_jump_by_parts_equality_rtx (op0, if_false_label, if_true_label)
9674      rtx op0;
9675      rtx if_false_label, if_true_label;
9676 {
9677   int nwords = GET_MODE_SIZE (GET_MODE (op0)) / UNITS_PER_WORD;
9678   rtx part;
9679   int i;
9680   rtx drop_through_label = 0;
9681
9682   /* The fastest way of doing this comparison on almost any machine is to
9683      "or" all the words and compare the result.  If all have to be loaded
9684      from memory and this is a very wide item, it's possible this may
9685      be slower, but that's highly unlikely.  */
9686
9687   part = gen_reg_rtx (word_mode);
9688   emit_move_insn (part, operand_subword_force (op0, 0, GET_MODE (op0)));
9689   for (i = 1; i < nwords && part != 0; i++)
9690     part = expand_binop (word_mode, ior_optab, part,
9691                          operand_subword_force (op0, i, GET_MODE (op0)),
9692                          part, 1, OPTAB_WIDEN);
9693
9694   if (part != 0)
9695     {
9696       do_compare_rtx_and_jump (part, const0_rtx, EQ, 1, word_mode,
9697                                NULL_RTX, if_false_label, if_true_label);
9698
9699       return;
9700     }
9701
9702   /* If we couldn't do the "or" simply, do this with a series of compares.  */
9703   if (! if_false_label)
9704     drop_through_label = if_false_label = gen_label_rtx ();
9705
9706   for (i = 0; i < nwords; i++)
9707     do_compare_rtx_and_jump (operand_subword_force (op0, i, GET_MODE (op0)),
9708                              const0_rtx, EQ, 1, word_mode, NULL_RTX,
9709                              if_false_label, NULL_RTX);
9710
9711   if (if_true_label)
9712     emit_jump (if_true_label);
9713
9714   if (drop_through_label)
9715     emit_label (drop_through_label);
9716 }
9717 \f
9718 /* Generate code for a comparison of OP0 and OP1 with rtx code CODE.
9719    (including code to compute the values to be compared)
9720    and set (CC0) according to the result.
9721    The decision as to signed or unsigned comparison must be made by the caller.
9722
9723    We force a stack adjustment unless there are currently
9724    things pushed on the stack that aren't yet used.
9725
9726    If MODE is BLKmode, SIZE is an RTX giving the size of the objects being
9727    compared.  */
9728
9729 rtx
9730 compare_from_rtx (op0, op1, code, unsignedp, mode, size)
9731      rtx op0, op1;
9732      enum rtx_code code;
9733      int unsignedp;
9734      enum machine_mode mode;
9735      rtx size;
9736 {
9737   rtx tem;
9738
9739   /* If one operand is constant, make it the second one.  Only do this
9740      if the other operand is not constant as well.  */
9741
9742   if (swap_commutative_operands_p (op0, op1))
9743     {
9744       tem = op0;
9745       op0 = op1;
9746       op1 = tem;
9747       code = swap_condition (code);
9748     }
9749
9750   if (flag_force_mem)
9751     {
9752       op0 = force_not_mem (op0);
9753       op1 = force_not_mem (op1);
9754     }
9755
9756   do_pending_stack_adjust ();
9757
9758   if (GET_CODE (op0) == CONST_INT && GET_CODE (op1) == CONST_INT
9759       && (tem = simplify_relational_operation (code, mode, op0, op1)) != 0)
9760     return tem;
9761
9762 #if 0
9763   /* There's no need to do this now that combine.c can eliminate lots of
9764      sign extensions.  This can be less efficient in certain cases on other
9765      machines.  */
9766
9767   /* If this is a signed equality comparison, we can do it as an
9768      unsigned comparison since zero-extension is cheaper than sign
9769      extension and comparisons with zero are done as unsigned.  This is
9770      the case even on machines that can do fast sign extension, since
9771      zero-extension is easier to combine with other operations than
9772      sign-extension is.  If we are comparing against a constant, we must
9773      convert it to what it would look like unsigned.  */
9774   if ((code == EQ || code == NE) && ! unsignedp
9775       && GET_MODE_BITSIZE (GET_MODE (op0)) <= HOST_BITS_PER_WIDE_INT)
9776     {
9777       if (GET_CODE (op1) == CONST_INT
9778           && (INTVAL (op1) & GET_MODE_MASK (GET_MODE (op0))) != INTVAL (op1))
9779         op1 = GEN_INT (INTVAL (op1) & GET_MODE_MASK (GET_MODE (op0)));
9780       unsignedp = 1;
9781     }
9782 #endif
9783
9784   emit_cmp_insn (op0, op1, code, size, mode, unsignedp);
9785
9786   return gen_rtx_fmt_ee (code, VOIDmode, cc0_rtx, const0_rtx);
9787 }
9788
9789 /* Like do_compare_and_jump but expects the values to compare as two rtx's.
9790    The decision as to signed or unsigned comparison must be made by the caller.
9791
9792    If MODE is BLKmode, SIZE is an RTX giving the size of the objects being
9793    compared.  */
9794
9795 void
9796 do_compare_rtx_and_jump (op0, op1, code, unsignedp, mode, size,
9797                          if_false_label, if_true_label)
9798      rtx op0, op1;
9799      enum rtx_code code;
9800      int unsignedp;
9801      enum machine_mode mode;
9802      rtx size;
9803      rtx if_false_label, if_true_label;
9804 {
9805   rtx tem;
9806   int dummy_true_label = 0;
9807
9808   /* Reverse the comparison if that is safe and we want to jump if it is
9809      false.  */
9810   if (! if_true_label && ! FLOAT_MODE_P (mode))
9811     {
9812       if_true_label = if_false_label;
9813       if_false_label = 0;
9814       code = reverse_condition (code);
9815     }
9816
9817   /* If one operand is constant, make it the second one.  Only do this
9818      if the other operand is not constant as well.  */
9819
9820   if (swap_commutative_operands_p (op0, op1))
9821     {
9822       tem = op0;
9823       op0 = op1;
9824       op1 = tem;
9825       code = swap_condition (code);
9826     }
9827
9828   if (flag_force_mem)
9829     {
9830       op0 = force_not_mem (op0);
9831       op1 = force_not_mem (op1);
9832     }
9833
9834   do_pending_stack_adjust ();
9835
9836   if (GET_CODE (op0) == CONST_INT && GET_CODE (op1) == CONST_INT
9837       && (tem = simplify_relational_operation (code, mode, op0, op1)) != 0)
9838     {
9839       if (tem == const_true_rtx)
9840         {
9841           if (if_true_label)
9842             emit_jump (if_true_label);
9843         }
9844       else
9845         {
9846           if (if_false_label)
9847             emit_jump (if_false_label);
9848         }
9849       return;
9850     }
9851
9852 #if 0
9853   /* There's no need to do this now that combine.c can eliminate lots of
9854      sign extensions.  This can be less efficient in certain cases on other
9855      machines.  */
9856
9857   /* If this is a signed equality comparison, we can do it as an
9858      unsigned comparison since zero-extension is cheaper than sign
9859      extension and comparisons with zero are done as unsigned.  This is
9860      the case even on machines that can do fast sign extension, since
9861      zero-extension is easier to combine with other operations than
9862      sign-extension is.  If we are comparing against a constant, we must
9863      convert it to what it would look like unsigned.  */
9864   if ((code == EQ || code == NE) && ! unsignedp
9865       && GET_MODE_BITSIZE (GET_MODE (op0)) <= HOST_BITS_PER_WIDE_INT)
9866     {
9867       if (GET_CODE (op1) == CONST_INT
9868           && (INTVAL (op1) & GET_MODE_MASK (GET_MODE (op0))) != INTVAL (op1))
9869         op1 = GEN_INT (INTVAL (op1) & GET_MODE_MASK (GET_MODE (op0)));
9870       unsignedp = 1;
9871     }
9872 #endif
9873
9874   if (! if_true_label)
9875     {
9876       dummy_true_label = 1;
9877       if_true_label = gen_label_rtx ();
9878     }
9879
9880   emit_cmp_and_jump_insns (op0, op1, code, size, mode, unsignedp,
9881                            if_true_label);
9882
9883   if (if_false_label)
9884     emit_jump (if_false_label);
9885   if (dummy_true_label)
9886     emit_label (if_true_label);
9887 }
9888
9889 /* Generate code for a comparison expression EXP (including code to compute
9890    the values to be compared) and a conditional jump to IF_FALSE_LABEL and/or
9891    IF_TRUE_LABEL.  One of the labels can be NULL_RTX, in which case the
9892    generated code will drop through.
9893    SIGNED_CODE should be the rtx operation for this comparison for
9894    signed data; UNSIGNED_CODE, likewise for use if data is unsigned.
9895
9896    We force a stack adjustment unless there are currently
9897    things pushed on the stack that aren't yet used.  */
9898
9899 static void
9900 do_compare_and_jump (exp, signed_code, unsigned_code, if_false_label,
9901                      if_true_label)
9902      tree exp;
9903      enum rtx_code signed_code, unsigned_code;
9904      rtx if_false_label, if_true_label;
9905 {
9906   rtx op0, op1;
9907   tree type;
9908   enum machine_mode mode;
9909   int unsignedp;
9910   enum rtx_code code;
9911
9912   /* Don't crash if the comparison was erroneous.  */
9913   op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode, 0);
9914   if (TREE_CODE (TREE_OPERAND (exp, 0)) == ERROR_MARK)
9915     return;
9916
9917   op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
9918   if (TREE_CODE (TREE_OPERAND (exp, 1)) == ERROR_MARK)
9919     return;
9920
9921   type = TREE_TYPE (TREE_OPERAND (exp, 0));
9922   mode = TYPE_MODE (type);
9923   if (TREE_CODE (TREE_OPERAND (exp, 0)) == INTEGER_CST
9924       && (TREE_CODE (TREE_OPERAND (exp, 1)) != INTEGER_CST
9925           || (GET_MODE_BITSIZE (mode)
9926               > GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp,
9927                                                                       1)))))))
9928     {
9929       /* op0 might have been replaced by promoted constant, in which
9930          case the type of second argument should be used.  */
9931       type = TREE_TYPE (TREE_OPERAND (exp, 1));
9932       mode = TYPE_MODE (type);
9933     }
9934   unsignedp = TREE_UNSIGNED (type);
9935   code = unsignedp ? unsigned_code : signed_code;
9936
9937 #ifdef HAVE_canonicalize_funcptr_for_compare
9938   /* If function pointers need to be "canonicalized" before they can
9939      be reliably compared, then canonicalize them.  */
9940   if (HAVE_canonicalize_funcptr_for_compare
9941       && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == POINTER_TYPE
9942       && (TREE_CODE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 0))))
9943           == FUNCTION_TYPE))
9944     {
9945       rtx new_op0 = gen_reg_rtx (mode);
9946
9947       emit_insn (gen_canonicalize_funcptr_for_compare (new_op0, op0));
9948       op0 = new_op0;
9949     }
9950
9951   if (HAVE_canonicalize_funcptr_for_compare
9952       && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 1))) == POINTER_TYPE
9953       && (TREE_CODE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 1))))
9954           == FUNCTION_TYPE))
9955     {
9956       rtx new_op1 = gen_reg_rtx (mode);
9957
9958       emit_insn (gen_canonicalize_funcptr_for_compare (new_op1, op1));
9959       op1 = new_op1;
9960     }
9961 #endif
9962
9963   /* Do any postincrements in the expression that was tested.  */
9964   emit_queue ();
9965
9966   do_compare_rtx_and_jump (op0, op1, code, unsignedp, mode,
9967                            ((mode == BLKmode)
9968                             ? expr_size (TREE_OPERAND (exp, 0)) : NULL_RTX),
9969                            if_false_label, if_true_label);
9970 }
9971 \f
9972 /* Generate code to calculate EXP using a store-flag instruction
9973    and return an rtx for the result.  EXP is either a comparison
9974    or a TRUTH_NOT_EXPR whose operand is a comparison.
9975
9976    If TARGET is nonzero, store the result there if convenient.
9977
9978    If ONLY_CHEAP is non-zero, only do this if it is likely to be very
9979    cheap.
9980
9981    Return zero if there is no suitable set-flag instruction
9982    available on this machine.
9983
9984    Once expand_expr has been called on the arguments of the comparison,
9985    we are committed to doing the store flag, since it is not safe to
9986    re-evaluate the expression.  We emit the store-flag insn by calling
9987    emit_store_flag, but only expand the arguments if we have a reason
9988    to believe that emit_store_flag will be successful.  If we think that
9989    it will, but it isn't, we have to simulate the store-flag with a
9990    set/jump/set sequence.  */
9991
9992 static rtx
9993 do_store_flag (exp, target, mode, only_cheap)
9994      tree exp;
9995      rtx target;
9996      enum machine_mode mode;
9997      int only_cheap;
9998 {
9999   enum rtx_code code;
10000   tree arg0, arg1, type;
10001   tree tem;
10002   enum machine_mode operand_mode;
10003   int invert = 0;
10004   int unsignedp;
10005   rtx op0, op1;
10006   enum insn_code icode;
10007   rtx subtarget = target;
10008   rtx result, label;
10009
10010   /* If this is a TRUTH_NOT_EXPR, set a flag indicating we must invert the
10011      result at the end.  We can't simply invert the test since it would
10012      have already been inverted if it were valid.  This case occurs for
10013      some floating-point comparisons.  */
10014
10015   if (TREE_CODE (exp) == TRUTH_NOT_EXPR)
10016     invert = 1, exp = TREE_OPERAND (exp, 0);
10017
10018   arg0 = TREE_OPERAND (exp, 0);
10019   arg1 = TREE_OPERAND (exp, 1);
10020
10021   /* Don't crash if the comparison was erroneous.  */
10022   if (arg0 == error_mark_node || arg1 == error_mark_node)
10023     return const0_rtx;
10024
10025   type = TREE_TYPE (arg0);
10026   operand_mode = TYPE_MODE (type);
10027   unsignedp = TREE_UNSIGNED (type);
10028
10029   /* We won't bother with BLKmode store-flag operations because it would mean
10030      passing a lot of information to emit_store_flag.  */
10031   if (operand_mode == BLKmode)
10032     return 0;
10033
10034   /* We won't bother with store-flag operations involving function pointers
10035      when function pointers must be canonicalized before comparisons.  */
10036 #ifdef HAVE_canonicalize_funcptr_for_compare
10037   if (HAVE_canonicalize_funcptr_for_compare
10038       && ((TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == POINTER_TYPE
10039            && (TREE_CODE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 0))))
10040                == FUNCTION_TYPE))
10041           || (TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 1))) == POINTER_TYPE
10042               && (TREE_CODE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 1))))
10043                   == FUNCTION_TYPE))))
10044     return 0;
10045 #endif
10046
10047   STRIP_NOPS (arg0);
10048   STRIP_NOPS (arg1);
10049
10050   /* Get the rtx comparison code to use.  We know that EXP is a comparison
10051      operation of some type.  Some comparisons against 1 and -1 can be
10052      converted to comparisons with zero.  Do so here so that the tests
10053      below will be aware that we have a comparison with zero.   These
10054      tests will not catch constants in the first operand, but constants
10055      are rarely passed as the first operand.  */
10056
10057   switch (TREE_CODE (exp))
10058     {
10059     case EQ_EXPR:
10060       code = EQ;
10061       break;
10062     case NE_EXPR:
10063       code = NE;
10064       break;
10065     case LT_EXPR:
10066       if (integer_onep (arg1))
10067         arg1 = integer_zero_node, code = unsignedp ? LEU : LE;
10068       else
10069         code = unsignedp ? LTU : LT;
10070       break;
10071     case LE_EXPR:
10072       if (! unsignedp && integer_all_onesp (arg1))
10073         arg1 = integer_zero_node, code = LT;
10074       else
10075         code = unsignedp ? LEU : LE;
10076       break;
10077     case GT_EXPR:
10078       if (! unsignedp && integer_all_onesp (arg1))
10079         arg1 = integer_zero_node, code = GE;
10080       else
10081         code = unsignedp ? GTU : GT;
10082       break;
10083     case GE_EXPR:
10084       if (integer_onep (arg1))
10085         arg1 = integer_zero_node, code = unsignedp ? GTU : GT;
10086       else
10087         code = unsignedp ? GEU : GE;
10088       break;
10089
10090     case UNORDERED_EXPR:
10091       code = UNORDERED;
10092       break;
10093     case ORDERED_EXPR:
10094       code = ORDERED;
10095       break;
10096     case UNLT_EXPR:
10097       code = UNLT;
10098       break;
10099     case UNLE_EXPR:
10100       code = UNLE;
10101       break;
10102     case UNGT_EXPR:
10103       code = UNGT;
10104       break;
10105     case UNGE_EXPR:
10106       code = UNGE;
10107       break;
10108     case UNEQ_EXPR:
10109       code = UNEQ;
10110       break;
10111
10112     default:
10113       abort ();
10114     }
10115
10116   /* Put a constant second.  */
10117   if (TREE_CODE (arg0) == REAL_CST || TREE_CODE (arg0) == INTEGER_CST)
10118     {
10119       tem = arg0; arg0 = arg1; arg1 = tem;
10120       code = swap_condition (code);
10121     }
10122
10123   /* If this is an equality or inequality test of a single bit, we can
10124      do this by shifting the bit being tested to the low-order bit and
10125      masking the result with the constant 1.  If the condition was EQ,
10126      we xor it with 1.  This does not require an scc insn and is faster
10127      than an scc insn even if we have it.  */
10128
10129   if ((code == NE || code == EQ)
10130       && TREE_CODE (arg0) == BIT_AND_EXPR && integer_zerop (arg1)
10131       && integer_pow2p (TREE_OPERAND (arg0, 1)))
10132     {
10133       tree inner = TREE_OPERAND (arg0, 0);
10134       int bitnum = tree_log2 (TREE_OPERAND (arg0, 1));
10135       int ops_unsignedp;
10136
10137       /* If INNER is a right shift of a constant and it plus BITNUM does
10138          not overflow, adjust BITNUM and INNER.  */
10139
10140       if (TREE_CODE (inner) == RSHIFT_EXPR
10141           && TREE_CODE (TREE_OPERAND (inner, 1)) == INTEGER_CST
10142           && TREE_INT_CST_HIGH (TREE_OPERAND (inner, 1)) == 0
10143           && bitnum < TYPE_PRECISION (type)
10144           && 0 > compare_tree_int (TREE_OPERAND (inner, 1),
10145                                    bitnum - TYPE_PRECISION (type)))
10146         {
10147           bitnum += TREE_INT_CST_LOW (TREE_OPERAND (inner, 1));
10148           inner = TREE_OPERAND (inner, 0);
10149         }
10150
10151       /* If we are going to be able to omit the AND below, we must do our
10152          operations as unsigned.  If we must use the AND, we have a choice.
10153          Normally unsigned is faster, but for some machines signed is.  */
10154       ops_unsignedp = (bitnum == TYPE_PRECISION (type) - 1 ? 1
10155 #ifdef LOAD_EXTEND_OP
10156                        : (LOAD_EXTEND_OP (operand_mode) == SIGN_EXTEND ? 0 : 1)
10157 #else
10158                        : 1
10159 #endif
10160                        );
10161
10162       if (! get_subtarget (subtarget)
10163           || GET_MODE (subtarget) != operand_mode
10164           || ! safe_from_p (subtarget, inner, 1))
10165         subtarget = 0;
10166
10167       op0 = expand_expr (inner, subtarget, VOIDmode, 0);
10168
10169       if (bitnum != 0)
10170         op0 = expand_shift (RSHIFT_EXPR, operand_mode, op0,
10171                             size_int (bitnum), subtarget, ops_unsignedp);
10172
10173       if (GET_MODE (op0) != mode)
10174         op0 = convert_to_mode (mode, op0, ops_unsignedp);
10175
10176       if ((code == EQ && ! invert) || (code == NE && invert))
10177         op0 = expand_binop (mode, xor_optab, op0, const1_rtx, subtarget,
10178                             ops_unsignedp, OPTAB_LIB_WIDEN);
10179
10180       /* Put the AND last so it can combine with more things.  */
10181       if (bitnum != TYPE_PRECISION (type) - 1)
10182         op0 = expand_and (op0, const1_rtx, subtarget);
10183
10184       return op0;
10185     }
10186
10187   /* Now see if we are likely to be able to do this.  Return if not.  */
10188   if (! can_compare_p (code, operand_mode, ccp_store_flag))
10189     return 0;
10190
10191   icode = setcc_gen_code[(int) code];
10192   if (icode == CODE_FOR_nothing
10193       || (only_cheap && insn_data[(int) icode].operand[0].mode != mode))
10194     {
10195       /* We can only do this if it is one of the special cases that
10196          can be handled without an scc insn.  */
10197       if ((code == LT && integer_zerop (arg1))
10198           || (! only_cheap && code == GE && integer_zerop (arg1)))
10199         ;
10200       else if (BRANCH_COST >= 0
10201                && ! only_cheap && (code == NE || code == EQ)
10202                && TREE_CODE (type) != REAL_TYPE
10203                && ((abs_optab->handlers[(int) operand_mode].insn_code
10204                     != CODE_FOR_nothing)
10205                    || (ffs_optab->handlers[(int) operand_mode].insn_code
10206                        != CODE_FOR_nothing)))
10207         ;
10208       else
10209         return 0;
10210     }
10211
10212   if (! get_subtarget (target)
10213       || GET_MODE (subtarget) != operand_mode
10214       || ! safe_from_p (subtarget, arg1, 1))
10215     subtarget = 0;
10216
10217   op0 = expand_expr (arg0, subtarget, VOIDmode, 0);
10218   op1 = expand_expr (arg1, NULL_RTX, VOIDmode, 0);
10219
10220   if (target == 0)
10221     target = gen_reg_rtx (mode);
10222
10223   /* Pass copies of OP0 and OP1 in case they contain a QUEUED.  This is safe
10224      because, if the emit_store_flag does anything it will succeed and
10225      OP0 and OP1 will not be used subsequently.  */
10226
10227   result = emit_store_flag (target, code,
10228                             queued_subexp_p (op0) ? copy_rtx (op0) : op0,
10229                             queued_subexp_p (op1) ? copy_rtx (op1) : op1,
10230                             operand_mode, unsignedp, 1);
10231
10232   if (result)
10233     {
10234       if (invert)
10235         result = expand_binop (mode, xor_optab, result, const1_rtx,
10236                                result, 0, OPTAB_LIB_WIDEN);
10237       return result;
10238     }
10239
10240   /* If this failed, we have to do this with set/compare/jump/set code.  */
10241   if (GET_CODE (target) != REG
10242       || reg_mentioned_p (target, op0) || reg_mentioned_p (target, op1))
10243     target = gen_reg_rtx (GET_MODE (target));
10244
10245   emit_move_insn (target, invert ? const0_rtx : const1_rtx);
10246   result = compare_from_rtx (op0, op1, code, unsignedp,
10247                              operand_mode, NULL_RTX);
10248   if (GET_CODE (result) == CONST_INT)
10249     return (((result == const0_rtx && ! invert)
10250              || (result != const0_rtx && invert))
10251             ? const0_rtx : const1_rtx);
10252
10253   /* The code of RESULT may not match CODE if compare_from_rtx
10254      decided to swap its operands and reverse the original code.
10255
10256      We know that compare_from_rtx returns either a CONST_INT or
10257      a new comparison code, so it is safe to just extract the
10258      code from RESULT.  */
10259   code = GET_CODE (result);
10260
10261   label = gen_label_rtx ();
10262   if (bcc_gen_fctn[(int) code] == 0)
10263     abort ();
10264
10265   emit_jump_insn ((*bcc_gen_fctn[(int) code]) (label));
10266   emit_move_insn (target, invert ? const1_rtx : const0_rtx);
10267   emit_label (label);
10268
10269   return target;
10270 }
10271 \f
10272
10273 /* Stubs in case we haven't got a casesi insn.  */
10274 #ifndef HAVE_casesi
10275 # define HAVE_casesi 0
10276 # define gen_casesi(a, b, c, d, e) (0)
10277 # define CODE_FOR_casesi CODE_FOR_nothing
10278 #endif
10279
10280 /* If the machine does not have a case insn that compares the bounds,
10281    this means extra overhead for dispatch tables, which raises the
10282    threshold for using them.  */
10283 #ifndef CASE_VALUES_THRESHOLD
10284 #define CASE_VALUES_THRESHOLD (HAVE_casesi ? 4 : 5)
10285 #endif /* CASE_VALUES_THRESHOLD */
10286
10287 unsigned int
10288 case_values_threshold ()
10289 {
10290   return CASE_VALUES_THRESHOLD;
10291 }
10292
10293 /* Attempt to generate a casesi instruction.  Returns 1 if successful,
10294    0 otherwise (i.e. if there is no casesi instruction).  */
10295 int
10296 try_casesi (index_type, index_expr, minval, range,
10297             table_label, default_label)
10298      tree index_type, index_expr, minval, range;
10299      rtx table_label ATTRIBUTE_UNUSED;
10300      rtx default_label;
10301 {
10302   enum machine_mode index_mode = SImode;
10303   int index_bits = GET_MODE_BITSIZE (index_mode);
10304   rtx op1, op2, index;
10305   enum machine_mode op_mode;
10306
10307   if (! HAVE_casesi)
10308     return 0;
10309
10310   /* Convert the index to SImode.  */
10311   if (GET_MODE_BITSIZE (TYPE_MODE (index_type)) > GET_MODE_BITSIZE (index_mode))
10312     {
10313       enum machine_mode omode = TYPE_MODE (index_type);
10314       rtx rangertx = expand_expr (range, NULL_RTX, VOIDmode, 0);
10315
10316       /* We must handle the endpoints in the original mode.  */
10317       index_expr = build (MINUS_EXPR, index_type,
10318                           index_expr, minval);
10319       minval = integer_zero_node;
10320       index = expand_expr (index_expr, NULL_RTX, VOIDmode, 0);
10321       emit_cmp_and_jump_insns (rangertx, index, LTU, NULL_RTX,
10322                                omode, 1, default_label);
10323       /* Now we can safely truncate.  */
10324       index = convert_to_mode (index_mode, index, 0);
10325     }
10326   else
10327     {
10328       if (TYPE_MODE (index_type) != index_mode)
10329         {
10330           index_expr = convert (type_for_size (index_bits, 0),
10331                                 index_expr);
10332           index_type = TREE_TYPE (index_expr);
10333         }
10334
10335       index = expand_expr (index_expr, NULL_RTX, VOIDmode, 0);
10336     }
10337   emit_queue ();
10338   index = protect_from_queue (index, 0);
10339   do_pending_stack_adjust ();
10340
10341   op_mode = insn_data[(int) CODE_FOR_casesi].operand[0].mode;
10342   if (! (*insn_data[(int) CODE_FOR_casesi].operand[0].predicate)
10343       (index, op_mode))
10344     index = copy_to_mode_reg (op_mode, index);
10345
10346   op1 = expand_expr (minval, NULL_RTX, VOIDmode, 0);
10347
10348   op_mode = insn_data[(int) CODE_FOR_casesi].operand[1].mode;
10349   op1 = convert_modes (op_mode, TYPE_MODE (TREE_TYPE (minval)),
10350                        op1, TREE_UNSIGNED (TREE_TYPE (minval)));
10351   if (! (*insn_data[(int) CODE_FOR_casesi].operand[1].predicate)
10352       (op1, op_mode))
10353     op1 = copy_to_mode_reg (op_mode, op1);
10354
10355   op2 = expand_expr (range, NULL_RTX, VOIDmode, 0);
10356
10357   op_mode = insn_data[(int) CODE_FOR_casesi].operand[2].mode;
10358   op2 = convert_modes (op_mode, TYPE_MODE (TREE_TYPE (range)),
10359                        op2, TREE_UNSIGNED (TREE_TYPE (range)));
10360   if (! (*insn_data[(int) CODE_FOR_casesi].operand[2].predicate)
10361       (op2, op_mode))
10362     op2 = copy_to_mode_reg (op_mode, op2);
10363
10364   emit_jump_insn (gen_casesi (index, op1, op2,
10365                               table_label, default_label));
10366   return 1;
10367 }
10368
10369 /* Attempt to generate a tablejump instruction; same concept.  */
10370 #ifndef HAVE_tablejump
10371 #define HAVE_tablejump 0
10372 #define gen_tablejump(x, y) (0)
10373 #endif
10374
10375 /* Subroutine of the next function.
10376
10377    INDEX is the value being switched on, with the lowest value
10378    in the table already subtracted.
10379    MODE is its expected mode (needed if INDEX is constant).
10380    RANGE is the length of the jump table.
10381    TABLE_LABEL is a CODE_LABEL rtx for the table itself.
10382
10383    DEFAULT_LABEL is a CODE_LABEL rtx to jump to if the
10384    index value is out of range.  */
10385
10386 static void
10387 do_tablejump (index, mode, range, table_label, default_label)
10388      rtx index, range, table_label, default_label;
10389      enum machine_mode mode;
10390 {
10391   rtx temp, vector;
10392
10393   /* Do an unsigned comparison (in the proper mode) between the index
10394      expression and the value which represents the length of the range.
10395      Since we just finished subtracting the lower bound of the range
10396      from the index expression, this comparison allows us to simultaneously
10397      check that the original index expression value is both greater than
10398      or equal to the minimum value of the range and less than or equal to
10399      the maximum value of the range.  */
10400
10401   emit_cmp_and_jump_insns (index, range, GTU, NULL_RTX, mode, 1,
10402                            default_label);
10403
10404   /* If index is in range, it must fit in Pmode.
10405      Convert to Pmode so we can index with it.  */
10406   if (mode != Pmode)
10407     index = convert_to_mode (Pmode, index, 1);
10408
10409   /* Don't let a MEM slip thru, because then INDEX that comes
10410      out of PIC_CASE_VECTOR_ADDRESS won't be a valid address,
10411      and break_out_memory_refs will go to work on it and mess it up.  */
10412 #ifdef PIC_CASE_VECTOR_ADDRESS
10413   if (flag_pic && GET_CODE (index) != REG)
10414     index = copy_to_mode_reg (Pmode, index);
10415 #endif
10416
10417   /* If flag_force_addr were to affect this address
10418      it could interfere with the tricky assumptions made
10419      about addresses that contain label-refs,
10420      which may be valid only very near the tablejump itself.  */
10421   /* ??? The only correct use of CASE_VECTOR_MODE is the one inside the
10422      GET_MODE_SIZE, because this indicates how large insns are.  The other
10423      uses should all be Pmode, because they are addresses.  This code
10424      could fail if addresses and insns are not the same size.  */
10425   index = gen_rtx_PLUS (Pmode,
10426                         gen_rtx_MULT (Pmode, index,
10427                                       GEN_INT (GET_MODE_SIZE (CASE_VECTOR_MODE))),
10428                         gen_rtx_LABEL_REF (Pmode, table_label));
10429 #ifdef PIC_CASE_VECTOR_ADDRESS
10430   if (flag_pic)
10431     index = PIC_CASE_VECTOR_ADDRESS (index);
10432   else
10433 #endif
10434     index = memory_address_noforce (CASE_VECTOR_MODE, index);
10435   temp = gen_reg_rtx (CASE_VECTOR_MODE);
10436   vector = gen_rtx_MEM (CASE_VECTOR_MODE, index);
10437   RTX_UNCHANGING_P (vector) = 1;
10438   convert_move (temp, vector, 0);
10439
10440   emit_jump_insn (gen_tablejump (temp, table_label));
10441
10442   /* If we are generating PIC code or if the table is PC-relative, the
10443      table and JUMP_INSN must be adjacent, so don't output a BARRIER.  */
10444   if (! CASE_VECTOR_PC_RELATIVE && ! flag_pic)
10445     emit_barrier ();
10446 }
10447
10448 int
10449 try_tablejump (index_type, index_expr, minval, range,
10450                table_label, default_label)
10451      tree index_type, index_expr, minval, range;
10452      rtx table_label, default_label;
10453 {
10454   rtx index;
10455
10456   if (! HAVE_tablejump)
10457     return 0;
10458
10459   index_expr = fold (build (MINUS_EXPR, index_type,
10460                             convert (index_type, index_expr),
10461                             convert (index_type, minval)));
10462   index = expand_expr (index_expr, NULL_RTX, VOIDmode, 0);
10463   emit_queue ();
10464   index = protect_from_queue (index, 0);
10465   do_pending_stack_adjust ();
10466
10467   do_tablejump (index, TYPE_MODE (index_type),
10468                 convert_modes (TYPE_MODE (index_type),
10469                                TYPE_MODE (TREE_TYPE (range)),
10470                                expand_expr (range, NULL_RTX,
10471                                             VOIDmode, 0),
10472                                TREE_UNSIGNED (TREE_TYPE (range))),
10473                 table_label, default_label);
10474   return 1;
10475 }