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