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