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   arg_space_so_far = 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;
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;
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           move_by_pieces (gen_rtx_MEM (BLKmode, gen_push_operand ()), xinner,
3000                           INTVAL (size) - used, align);
3001
3002           if (current_function_check_memory_usage && ! in_check_memory_usage)
3003             {
3004               rtx temp;
3005
3006               in_check_memory_usage = 1;
3007               temp = get_push_address (INTVAL(size) - used);
3008               if (GET_CODE (x) == MEM && type && AGGREGATE_TYPE_P (type))
3009                 emit_library_call (chkr_copy_bitmap_libfunc, 1, VOIDmode, 3,
3010                                    temp, Pmode,
3011                                    XEXP (xinner, 0), Pmode,
3012                                    GEN_INT (INTVAL(size) - used),
3013                                    TYPE_MODE (sizetype));
3014               else
3015                 emit_library_call (chkr_set_right_libfunc, 1, VOIDmode, 3,
3016                                    temp, Pmode,
3017                                    GEN_INT (INTVAL(size) - used),
3018                                    TYPE_MODE (sizetype),
3019                                    GEN_INT (MEMORY_USE_RW),
3020                                    TYPE_MODE (integer_type_node));
3021               in_check_memory_usage = 0;
3022             }
3023         }
3024       else
3025 #endif /* PUSH_ROUNDING */
3026         {
3027           /* Otherwise make space on the stack and copy the data
3028              to the address of that space.  */
3029
3030           /* Deduct words put into registers from the size we must copy.  */
3031           if (partial != 0)
3032             {
3033               if (GET_CODE (size) == CONST_INT)
3034                 size = GEN_INT (INTVAL (size) - used);
3035               else
3036                 size = expand_binop (GET_MODE (size), sub_optab, size,
3037                                      GEN_INT (used), NULL_RTX, 0,
3038                                      OPTAB_LIB_WIDEN);
3039             }
3040
3041           /* Get the address of the stack space.
3042              In this case, we do not deal with EXTRA separately.
3043              A single stack adjust will do.  */
3044           if (! args_addr)
3045             {
3046               temp = push_block (size, extra, where_pad == downward);
3047               extra = 0;
3048             }
3049           else if (GET_CODE (args_so_far) == CONST_INT)
3050             temp = memory_address (BLKmode,
3051                                    plus_constant (args_addr,
3052                                                   skip + INTVAL (args_so_far)));
3053           else
3054             temp = memory_address (BLKmode,
3055                                    plus_constant (gen_rtx_PLUS (Pmode,
3056                                                                 args_addr,
3057                                                                 args_so_far),
3058                                                   skip));
3059           if (current_function_check_memory_usage && ! in_check_memory_usage)
3060             {
3061               rtx target;
3062
3063               in_check_memory_usage = 1;
3064               target = copy_to_reg (temp);
3065               if (GET_CODE (x) == MEM && type && AGGREGATE_TYPE_P (type))
3066                 emit_library_call (chkr_copy_bitmap_libfunc, 1, VOIDmode, 3,
3067                                    target, Pmode,
3068                                    XEXP (xinner, 0), Pmode,
3069                                    size, TYPE_MODE (sizetype));
3070               else
3071                 emit_library_call (chkr_set_right_libfunc, 1, VOIDmode, 3,
3072                                    target, Pmode,
3073                                    size, TYPE_MODE (sizetype),
3074                                    GEN_INT (MEMORY_USE_RW),
3075                                    TYPE_MODE (integer_type_node));
3076               in_check_memory_usage = 0;
3077             }
3078
3079           /* TEMP is the address of the block.  Copy the data there.  */
3080           if (GET_CODE (size) == CONST_INT
3081               && MOVE_BY_PIECES_P ((unsigned) INTVAL (size), align))
3082             {
3083               move_by_pieces (gen_rtx_MEM (BLKmode, temp), xinner,
3084                               INTVAL (size), align);
3085               goto ret;
3086             }
3087           else
3088             {
3089               rtx opalign = GEN_INT (align / BITS_PER_UNIT);
3090               enum machine_mode mode;
3091               rtx target = gen_rtx_MEM (BLKmode, temp);
3092
3093               for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT);
3094                    mode != VOIDmode;
3095                    mode = GET_MODE_WIDER_MODE (mode))
3096                 {
3097                   enum insn_code code = movstr_optab[(int) mode];
3098                   insn_operand_predicate_fn pred;
3099
3100                   if (code != CODE_FOR_nothing
3101                       && ((GET_CODE (size) == CONST_INT
3102                            && ((unsigned HOST_WIDE_INT) INTVAL (size)
3103                                <= (GET_MODE_MASK (mode) >> 1)))
3104                           || GET_MODE_BITSIZE (mode) >= BITS_PER_WORD)
3105                       && (!(pred = insn_data[(int) code].operand[0].predicate)
3106                           || ((*pred) (target, BLKmode)))
3107                       && (!(pred = insn_data[(int) code].operand[1].predicate)
3108                           || ((*pred) (xinner, BLKmode)))
3109                       && (!(pred = insn_data[(int) code].operand[3].predicate)
3110                           || ((*pred) (opalign, VOIDmode))))
3111                     {
3112                       rtx op2 = convert_to_mode (mode, size, 1);
3113                       rtx last = get_last_insn ();
3114                       rtx pat;
3115
3116                       pred = insn_data[(int) code].operand[2].predicate;
3117                       if (pred != 0 && ! (*pred) (op2, mode))
3118                         op2 = copy_to_mode_reg (mode, op2);
3119
3120                       pat = GEN_FCN ((int) code) (target, xinner,
3121                                                   op2, opalign);
3122                       if (pat)
3123                         {
3124                           emit_insn (pat);
3125                           goto ret;
3126                         }
3127                       else
3128                         delete_insns_since (last);
3129                     }
3130                 }
3131             }
3132
3133           if (!ACCUMULATE_OUTGOING_ARGS)
3134             {
3135               /* If the source is referenced relative to the stack pointer,
3136                  copy it to another register to stabilize it.  We do not need
3137                  to do this if we know that we won't be changing sp.  */
3138
3139               if (reg_mentioned_p (virtual_stack_dynamic_rtx, temp)
3140                   || reg_mentioned_p (virtual_outgoing_args_rtx, temp))
3141                 temp = copy_to_reg (temp);
3142             }
3143
3144           /* Make inhibit_defer_pop nonzero around the library call
3145              to force it to pop the bcopy-arguments right away.  */
3146           NO_DEFER_POP;
3147 #ifdef TARGET_MEM_FUNCTIONS
3148           emit_library_call (memcpy_libfunc, 0,
3149                              VOIDmode, 3, temp, Pmode, XEXP (xinner, 0), Pmode,
3150                              convert_to_mode (TYPE_MODE (sizetype),
3151                                               size, TREE_UNSIGNED (sizetype)),
3152                              TYPE_MODE (sizetype));
3153 #else
3154           emit_library_call (bcopy_libfunc, 0,
3155                              VOIDmode, 3, XEXP (xinner, 0), Pmode, temp, Pmode,
3156                              convert_to_mode (TYPE_MODE (integer_type_node),
3157                                               size,
3158                                               TREE_UNSIGNED (integer_type_node)),
3159                              TYPE_MODE (integer_type_node));
3160 #endif
3161           OK_DEFER_POP;
3162         }
3163     }
3164   else if (partial > 0)
3165     {
3166       /* Scalar partly in registers.  */
3167
3168       int size = GET_MODE_SIZE (mode) / UNITS_PER_WORD;
3169       int i;
3170       int not_stack;
3171       /* # words of start of argument
3172          that we must make space for but need not store.  */
3173       int offset = partial % (PARM_BOUNDARY / BITS_PER_WORD);
3174       int args_offset = INTVAL (args_so_far);
3175       int skip;
3176
3177       /* Push padding now if padding above and stack grows down,
3178          or if padding below and stack grows up.
3179          But if space already allocated, this has already been done.  */
3180       if (extra && args_addr == 0
3181           && where_pad != none && where_pad != stack_direction)
3182         anti_adjust_stack (GEN_INT (extra));
3183
3184       /* If we make space by pushing it, we might as well push
3185          the real data.  Otherwise, we can leave OFFSET nonzero
3186          and leave the space uninitialized.  */
3187       if (args_addr == 0)
3188         offset = 0;
3189
3190       /* Now NOT_STACK gets the number of words that we don't need to
3191          allocate on the stack.  */
3192       not_stack = partial - offset;
3193
3194       /* If the partial register-part of the arg counts in its stack size,
3195          skip the part of stack space corresponding to the registers.
3196          Otherwise, start copying to the beginning of the stack space,
3197          by setting SKIP to 0.  */
3198       skip = (reg_parm_stack_space == 0) ? 0 : not_stack;
3199
3200       if (CONSTANT_P (x) && ! LEGITIMATE_CONSTANT_P (x))
3201         x = validize_mem (force_const_mem (mode, x));
3202
3203       /* If X is a hard register in a non-integer mode, copy it into a pseudo;
3204          SUBREGs of such registers are not allowed.  */
3205       if ((GET_CODE (x) == REG && REGNO (x) < FIRST_PSEUDO_REGISTER
3206            && GET_MODE_CLASS (GET_MODE (x)) != MODE_INT))
3207         x = copy_to_reg (x);
3208
3209       /* Loop over all the words allocated on the stack for this arg.  */
3210       /* We can do it by words, because any scalar bigger than a word
3211          has a size a multiple of a word.  */
3212 #ifndef PUSH_ARGS_REVERSED
3213       for (i = not_stack; i < size; i++)
3214 #else
3215       for (i = size - 1; i >= not_stack; i--)
3216 #endif
3217         if (i >= not_stack + offset)
3218           emit_push_insn (operand_subword_force (x, i, mode),
3219                           word_mode, NULL_TREE, NULL_RTX, align, 0, NULL_RTX,
3220                           0, args_addr,
3221                           GEN_INT (args_offset + ((i - not_stack + skip)
3222                                                   * UNITS_PER_WORD)),
3223                           reg_parm_stack_space, alignment_pad);
3224     }
3225   else
3226     {
3227       rtx addr;
3228       rtx target = NULL_RTX;
3229
3230       /* Push padding now if padding above and stack grows down,
3231          or if padding below and stack grows up.
3232          But if space already allocated, this has already been done.  */
3233       if (extra && args_addr == 0
3234           && where_pad != none && where_pad != stack_direction)
3235         anti_adjust_stack (GEN_INT (extra));
3236
3237 #ifdef PUSH_ROUNDING
3238       if (args_addr == 0 && PUSH_ARGS)
3239         addr = gen_push_operand ();
3240       else
3241 #endif
3242         {
3243           if (GET_CODE (args_so_far) == CONST_INT)
3244             addr
3245               = memory_address (mode,
3246                                 plus_constant (args_addr,
3247                                                INTVAL (args_so_far)));
3248           else
3249             addr = memory_address (mode, gen_rtx_PLUS (Pmode, args_addr,
3250                                                        args_so_far));
3251           target = addr;
3252         }
3253
3254       emit_move_insn (gen_rtx_MEM (mode, addr), x);
3255
3256       if (current_function_check_memory_usage && ! in_check_memory_usage)
3257         {
3258           in_check_memory_usage = 1;
3259           if (target == 0)
3260             target = get_push_address (GET_MODE_SIZE (mode));
3261
3262           if (GET_CODE (x) == MEM && type && AGGREGATE_TYPE_P (type))
3263             emit_library_call (chkr_copy_bitmap_libfunc, 1, VOIDmode, 3,
3264                                target, Pmode,
3265                                XEXP (x, 0), Pmode,
3266                                GEN_INT (GET_MODE_SIZE (mode)),
3267                                TYPE_MODE (sizetype));
3268           else
3269             emit_library_call (chkr_set_right_libfunc, 1, VOIDmode, 3,
3270                                target, Pmode,
3271                                GEN_INT (GET_MODE_SIZE (mode)),
3272                                TYPE_MODE (sizetype),
3273                                GEN_INT (MEMORY_USE_RW),
3274                                TYPE_MODE (integer_type_node));
3275           in_check_memory_usage = 0;
3276         }
3277     }
3278
3279  ret:
3280   /* If part should go in registers, copy that part
3281      into the appropriate registers.  Do this now, at the end,
3282      since mem-to-mem copies above may do function calls.  */
3283   if (partial > 0 && reg != 0)
3284     {
3285       /* Handle calls that pass values in multiple non-contiguous locations.
3286          The Irix 6 ABI has examples of this.  */
3287       if (GET_CODE (reg) == PARALLEL)
3288         emit_group_load (reg, x, -1, align);  /* ??? size? */
3289       else
3290         move_block_to_reg (REGNO (reg), x, partial, mode);
3291     }
3292
3293   if (extra && args_addr == 0 && where_pad == stack_direction)
3294     anti_adjust_stack (GEN_INT (extra));
3295
3296   if (alignment_pad)
3297     anti_adjust_stack (alignment_pad);
3298 }
3299 \f
3300 /* Expand an assignment that stores the value of FROM into TO.
3301    If WANT_VALUE is nonzero, return an rtx for the value of TO.
3302    (This may contain a QUEUED rtx;
3303    if the value is constant, this rtx is a constant.)
3304    Otherwise, the returned value is NULL_RTX.
3305
3306    SUGGEST_REG is no longer actually used.
3307    It used to mean, copy the value through a register
3308    and return that register, if that is possible.
3309    We now use WANT_VALUE to decide whether to do this.  */
3310
3311 rtx
3312 expand_assignment (to, from, want_value, suggest_reg)
3313      tree to, from;
3314      int want_value;
3315      int suggest_reg ATTRIBUTE_UNUSED;
3316 {
3317   register rtx to_rtx = 0;
3318   rtx result;
3319
3320   /* Don't crash if the lhs of the assignment was erroneous.  */
3321
3322   if (TREE_CODE (to) == ERROR_MARK)
3323     {
3324       result = expand_expr (from, NULL_RTX, VOIDmode, 0);
3325       return want_value ? result : NULL_RTX;
3326     }
3327
3328   /* Assignment of a structure component needs special treatment
3329      if the structure component's rtx is not simply a MEM.
3330      Assignment of an array element at a constant index, and assignment of
3331      an array element in an unaligned packed structure field, has the same
3332      problem.  */
3333
3334   if (TREE_CODE (to) == COMPONENT_REF || TREE_CODE (to) == BIT_FIELD_REF
3335       || TREE_CODE (to) == ARRAY_REF)
3336     {
3337       enum machine_mode mode1;
3338       HOST_WIDE_INT bitsize, bitpos;
3339       tree offset;
3340       int unsignedp;
3341       int volatilep = 0;
3342       tree tem;
3343       unsigned int alignment;
3344
3345       push_temp_slots ();
3346       tem = get_inner_reference (to, &bitsize, &bitpos, &offset, &mode1,
3347                                  &unsignedp, &volatilep, &alignment);
3348
3349       /* If we are going to use store_bit_field and extract_bit_field,
3350          make sure to_rtx will be safe for multiple use.  */
3351
3352       if (mode1 == VOIDmode && want_value)
3353         tem = stabilize_reference (tem);
3354
3355       to_rtx = expand_expr (tem, NULL_RTX, VOIDmode, EXPAND_MEMORY_USE_DONT);
3356       if (offset != 0)
3357         {
3358           rtx offset_rtx = expand_expr (offset, NULL_RTX, VOIDmode, 0);
3359
3360           if (GET_CODE (to_rtx) != MEM)
3361             abort ();
3362
3363           if (GET_MODE (offset_rtx) != ptr_mode)
3364             {
3365 #ifdef POINTERS_EXTEND_UNSIGNED
3366               offset_rtx = convert_memory_address (ptr_mode, offset_rtx);
3367 #else
3368               offset_rtx = convert_to_mode (ptr_mode, offset_rtx, 0);
3369 #endif
3370             }
3371
3372           /* A constant address in TO_RTX can have VOIDmode, we must not try
3373              to call force_reg for that case.  Avoid that case.  */
3374           if (GET_CODE (to_rtx) == MEM
3375               && GET_MODE (to_rtx) == BLKmode
3376               && GET_MODE (XEXP (to_rtx, 0)) != VOIDmode
3377               && bitsize
3378               && (bitpos % bitsize) == 0
3379               && (bitsize % GET_MODE_ALIGNMENT (mode1)) == 0
3380               && alignment == GET_MODE_ALIGNMENT (mode1))
3381             {
3382               rtx temp = change_address (to_rtx, mode1,
3383                                          plus_constant (XEXP (to_rtx, 0),
3384                                                         (bitpos /
3385                                                          BITS_PER_UNIT)));
3386               if (GET_CODE (XEXP (temp, 0)) == REG)
3387                 to_rtx = temp;
3388               else
3389                 to_rtx = change_address (to_rtx, mode1,
3390                                          force_reg (GET_MODE (XEXP (temp, 0)),
3391                                                     XEXP (temp, 0)));
3392               bitpos = 0;
3393             }
3394
3395           to_rtx = change_address (to_rtx, VOIDmode,
3396                                    gen_rtx_PLUS (ptr_mode, XEXP (to_rtx, 0),
3397                                                  force_reg (ptr_mode,
3398                                                             offset_rtx)));
3399         }
3400
3401       if (volatilep)
3402         {
3403           if (GET_CODE (to_rtx) == MEM)
3404             {
3405               /* When the offset is zero, to_rtx is the address of the
3406                  structure we are storing into, and hence may be shared.
3407                  We must make a new MEM before setting the volatile bit.  */
3408               if (offset == 0)
3409                 to_rtx = copy_rtx (to_rtx);
3410
3411               MEM_VOLATILE_P (to_rtx) = 1;
3412             }
3413 #if 0  /* This was turned off because, when a field is volatile
3414           in an object which is not volatile, the object may be in a register,
3415           and then we would abort over here.  */
3416           else
3417             abort ();
3418 #endif
3419         }
3420
3421       if (TREE_CODE (to) == COMPONENT_REF
3422           && TREE_READONLY (TREE_OPERAND (to, 1)))
3423         {
3424           if (offset == 0)
3425             to_rtx = copy_rtx (to_rtx);
3426
3427           RTX_UNCHANGING_P (to_rtx) = 1;
3428         }
3429
3430       /* Check the access.  */
3431       if (current_function_check_memory_usage && GET_CODE (to_rtx) == MEM)
3432         {
3433           rtx to_addr;
3434           int size;
3435           int best_mode_size;
3436           enum machine_mode best_mode;
3437
3438           best_mode = get_best_mode (bitsize, bitpos,
3439                                      TYPE_ALIGN (TREE_TYPE (tem)),
3440                                      mode1, volatilep);
3441           if (best_mode == VOIDmode)
3442             best_mode = QImode;
3443
3444           best_mode_size = GET_MODE_BITSIZE (best_mode);
3445           to_addr = plus_constant (XEXP (to_rtx, 0), (bitpos / BITS_PER_UNIT));
3446           size = CEIL ((bitpos % best_mode_size) + bitsize, best_mode_size);
3447           size *= GET_MODE_SIZE (best_mode);
3448
3449           /* Check the access right of the pointer.  */
3450           if (size)
3451             emit_library_call (chkr_check_addr_libfunc, 1, VOIDmode, 3,
3452                                to_addr, Pmode,
3453                                GEN_INT (size), TYPE_MODE (sizetype),
3454                                GEN_INT (MEMORY_USE_WO),
3455                                TYPE_MODE (integer_type_node));
3456         }
3457
3458       /* If this is a varying-length object, we must get the address of
3459          the source and do an explicit block move.  */
3460       if (bitsize < 0)
3461         {
3462           unsigned int from_align;
3463           rtx from_rtx = expand_expr_unaligned (from, &from_align);
3464           rtx inner_to_rtx
3465             = change_address (to_rtx, VOIDmode,
3466                               plus_constant (XEXP (to_rtx, 0),
3467                                              bitpos / BITS_PER_UNIT));
3468
3469           emit_block_move (inner_to_rtx, from_rtx, expr_size (from),
3470                            MIN (alignment, from_align));
3471           free_temp_slots ();
3472           pop_temp_slots ();
3473           return to_rtx;
3474         }
3475       else
3476         {
3477           result = store_field (to_rtx, bitsize, bitpos, mode1, from,
3478                                 (want_value
3479                                  /* Spurious cast for HPUX compiler.  */
3480                                  ? ((enum machine_mode)
3481                                     TYPE_MODE (TREE_TYPE (to)))
3482                                  : VOIDmode),
3483                                 unsignedp,
3484                                 alignment,
3485                                 int_size_in_bytes (TREE_TYPE (tem)),
3486                                 get_alias_set (to));
3487
3488           preserve_temp_slots (result);
3489           free_temp_slots ();
3490           pop_temp_slots ();
3491
3492           /* If the value is meaningful, convert RESULT to the proper mode.
3493              Otherwise, return nothing.  */
3494           return (want_value ? convert_modes (TYPE_MODE (TREE_TYPE (to)),
3495                                               TYPE_MODE (TREE_TYPE (from)),
3496                                               result,
3497                                               TREE_UNSIGNED (TREE_TYPE (to)))
3498                   : NULL_RTX);
3499         }
3500     }
3501
3502   /* If the rhs is a function call and its value is not an aggregate,
3503      call the function before we start to compute the lhs.
3504      This is needed for correct code for cases such as
3505      val = setjmp (buf) on machines where reference to val
3506      requires loading up part of an address in a separate insn.
3507
3508      Don't do this if TO is a VAR_DECL or PARM_DECL whose DECL_RTL is REG
3509      since it might be a promoted variable where the zero- or sign- extension
3510      needs to be done.  Handling this in the normal way is safe because no
3511      computation is done before the call.  */
3512   if (TREE_CODE (from) == CALL_EXPR && ! aggregate_value_p (from)
3513       && TREE_CODE (TYPE_SIZE (TREE_TYPE (from))) == INTEGER_CST
3514       && ! ((TREE_CODE (to) == VAR_DECL || TREE_CODE (to) == PARM_DECL)
3515             && GET_CODE (DECL_RTL (to)) == REG))
3516     {
3517       rtx value;
3518
3519       push_temp_slots ();
3520       value = expand_expr (from, NULL_RTX, VOIDmode, 0);
3521       if (to_rtx == 0)
3522         to_rtx = expand_expr (to, NULL_RTX, VOIDmode, EXPAND_MEMORY_USE_WO);
3523
3524       /* Handle calls that return values in multiple non-contiguous locations.
3525          The Irix 6 ABI has examples of this.  */
3526       if (GET_CODE (to_rtx) == PARALLEL)
3527         emit_group_load (to_rtx, value, int_size_in_bytes (TREE_TYPE (from)),
3528                          TYPE_ALIGN (TREE_TYPE (from)));
3529       else if (GET_MODE (to_rtx) == BLKmode)
3530         emit_block_move (to_rtx, value, expr_size (from),
3531                          TYPE_ALIGN (TREE_TYPE (from)));
3532       else
3533         {
3534 #ifdef POINTERS_EXTEND_UNSIGNED
3535           if (TREE_CODE (TREE_TYPE (to)) == REFERENCE_TYPE
3536              || TREE_CODE (TREE_TYPE (to)) == POINTER_TYPE)
3537             value = convert_memory_address (GET_MODE (to_rtx), value);
3538 #endif
3539           emit_move_insn (to_rtx, value);
3540         }
3541       preserve_temp_slots (to_rtx);
3542       free_temp_slots ();
3543       pop_temp_slots ();
3544       return want_value ? to_rtx : NULL_RTX;
3545     }
3546
3547   /* Ordinary treatment.  Expand TO to get a REG or MEM rtx.
3548      Don't re-expand if it was expanded already (in COMPONENT_REF case).  */
3549
3550   if (to_rtx == 0)
3551     {
3552       to_rtx = expand_expr (to, NULL_RTX, VOIDmode, EXPAND_MEMORY_USE_WO);
3553       if (GET_CODE (to_rtx) == MEM)
3554         MEM_ALIAS_SET (to_rtx) = get_alias_set (to);
3555     }
3556
3557   /* Don't move directly into a return register.  */
3558   if (TREE_CODE (to) == RESULT_DECL
3559       && (GET_CODE (to_rtx) == REG || GET_CODE (to_rtx) == PARALLEL))
3560     {
3561       rtx temp;
3562
3563       push_temp_slots ();
3564       temp = expand_expr (from, 0, GET_MODE (to_rtx), 0);
3565
3566       if (GET_CODE (to_rtx) == PARALLEL)
3567         emit_group_load (to_rtx, temp, int_size_in_bytes (TREE_TYPE (from)),
3568                          TYPE_ALIGN (TREE_TYPE (from)));
3569       else
3570         emit_move_insn (to_rtx, temp);
3571
3572       preserve_temp_slots (to_rtx);
3573       free_temp_slots ();
3574       pop_temp_slots ();
3575       return want_value ? to_rtx : NULL_RTX;
3576     }
3577
3578   /* In case we are returning the contents of an object which overlaps
3579      the place the value is being stored, use a safe function when copying
3580      a value through a pointer into a structure value return block.  */
3581   if (TREE_CODE (to) == RESULT_DECL && TREE_CODE (from) == INDIRECT_REF
3582       && current_function_returns_struct
3583       && !current_function_returns_pcc_struct)
3584     {
3585       rtx from_rtx, size;
3586
3587       push_temp_slots ();
3588       size = expr_size (from);
3589       from_rtx = expand_expr (from, NULL_RTX, VOIDmode,
3590                               EXPAND_MEMORY_USE_DONT);
3591
3592       /* Copy the rights of the bitmap.  */
3593       if (current_function_check_memory_usage)
3594         emit_library_call (chkr_copy_bitmap_libfunc, 1, VOIDmode, 3,
3595                            XEXP (to_rtx, 0), Pmode,
3596                            XEXP (from_rtx, 0), Pmode,
3597                            convert_to_mode (TYPE_MODE (sizetype),
3598                                             size, TREE_UNSIGNED (sizetype)),
3599                            TYPE_MODE (sizetype));
3600
3601 #ifdef TARGET_MEM_FUNCTIONS
3602       emit_library_call (memcpy_libfunc, 0,
3603                          VOIDmode, 3, XEXP (to_rtx, 0), Pmode,
3604                          XEXP (from_rtx, 0), Pmode,
3605                          convert_to_mode (TYPE_MODE (sizetype),
3606                                           size, TREE_UNSIGNED (sizetype)),
3607                          TYPE_MODE (sizetype));
3608 #else
3609       emit_library_call (bcopy_libfunc, 0,
3610                          VOIDmode, 3, XEXP (from_rtx, 0), Pmode,
3611                          XEXP (to_rtx, 0), Pmode,
3612                          convert_to_mode (TYPE_MODE (integer_type_node),
3613                                           size, TREE_UNSIGNED (integer_type_node)),
3614                          TYPE_MODE (integer_type_node));
3615 #endif
3616
3617       preserve_temp_slots (to_rtx);
3618       free_temp_slots ();
3619       pop_temp_slots ();
3620       return want_value ? to_rtx : NULL_RTX;
3621     }
3622
3623   /* Compute FROM and store the value in the rtx we got.  */
3624
3625   push_temp_slots ();
3626   result = store_expr (from, to_rtx, want_value);
3627   preserve_temp_slots (result);
3628   free_temp_slots ();
3629   pop_temp_slots ();
3630   return want_value ? result : NULL_RTX;
3631 }
3632
3633 /* Generate code for computing expression EXP,
3634    and storing the value into TARGET.
3635    TARGET may contain a QUEUED rtx.
3636
3637    If WANT_VALUE is nonzero, return a copy of the value
3638    not in TARGET, so that we can be sure to use the proper
3639    value in a containing expression even if TARGET has something
3640    else stored in it.  If possible, we copy the value through a pseudo
3641    and return that pseudo.  Or, if the value is constant, we try to
3642    return the constant.  In some cases, we return a pseudo
3643    copied *from* TARGET.
3644
3645    If the mode is BLKmode then we may return TARGET itself.
3646    It turns out that in BLKmode it doesn't cause a problem.
3647    because C has no operators that could combine two different
3648    assignments into the same BLKmode object with different values
3649    with no sequence point.  Will other languages need this to
3650    be more thorough?
3651
3652    If WANT_VALUE is 0, we return NULL, to make sure
3653    to catch quickly any cases where the caller uses the value
3654    and fails to set WANT_VALUE.  */
3655
3656 rtx
3657 store_expr (exp, target, want_value)
3658      register tree exp;
3659      register rtx target;
3660      int want_value;
3661 {
3662   register rtx temp;
3663   int dont_return_target = 0;
3664
3665   if (TREE_CODE (exp) == COMPOUND_EXPR)
3666     {
3667       /* Perform first part of compound expression, then assign from second
3668          part.  */
3669       expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode, 0);
3670       emit_queue ();
3671       return store_expr (TREE_OPERAND (exp, 1), target, want_value);
3672     }
3673   else if (TREE_CODE (exp) == COND_EXPR && GET_MODE (target) == BLKmode)
3674     {
3675       /* For conditional expression, get safe form of the target.  Then
3676          test the condition, doing the appropriate assignment on either
3677          side.  This avoids the creation of unnecessary temporaries.
3678          For non-BLKmode, it is more efficient not to do this.  */
3679
3680       rtx lab1 = gen_label_rtx (), lab2 = gen_label_rtx ();
3681
3682       emit_queue ();
3683       target = protect_from_queue (target, 1);
3684
3685       do_pending_stack_adjust ();
3686       NO_DEFER_POP;
3687       jumpifnot (TREE_OPERAND (exp, 0), lab1);
3688       start_cleanup_deferral ();
3689       store_expr (TREE_OPERAND (exp, 1), target, 0);
3690       end_cleanup_deferral ();
3691       emit_queue ();
3692       emit_jump_insn (gen_jump (lab2));
3693       emit_barrier ();
3694       emit_label (lab1);
3695       start_cleanup_deferral ();
3696       store_expr (TREE_OPERAND (exp, 2), target, 0);
3697       end_cleanup_deferral ();
3698       emit_queue ();
3699       emit_label (lab2);
3700       OK_DEFER_POP;
3701
3702       return want_value ? target : NULL_RTX;
3703     }
3704   else if (queued_subexp_p (target))
3705     /* If target contains a postincrement, let's not risk
3706        using it as the place to generate the rhs.  */
3707     {
3708       if (GET_MODE (target) != BLKmode && GET_MODE (target) != VOIDmode)
3709         {
3710           /* Expand EXP into a new pseudo.  */
3711           temp = gen_reg_rtx (GET_MODE (target));
3712           temp = expand_expr (exp, temp, GET_MODE (target), 0);
3713         }
3714       else
3715         temp = expand_expr (exp, NULL_RTX, GET_MODE (target), 0);
3716
3717       /* If target is volatile, ANSI requires accessing the value
3718          *from* the target, if it is accessed.  So make that happen.
3719          In no case return the target itself.  */
3720       if (! MEM_VOLATILE_P (target) && want_value)
3721         dont_return_target = 1;
3722     }
3723   else if (want_value && GET_CODE (target) == MEM && ! MEM_VOLATILE_P (target)
3724            && GET_MODE (target) != BLKmode)
3725     /* If target is in memory and caller wants value in a register instead,
3726        arrange that.  Pass TARGET as target for expand_expr so that,
3727        if EXP is another assignment, WANT_VALUE will be nonzero for it.
3728        We know expand_expr will not use the target in that case.
3729        Don't do this if TARGET is volatile because we are supposed
3730        to write it and then read it.  */
3731     {
3732       temp = expand_expr (exp, target, GET_MODE (target), 0);
3733       if (GET_MODE (temp) != BLKmode && GET_MODE (temp) != VOIDmode)
3734         temp = copy_to_reg (temp);
3735       dont_return_target = 1;
3736     }
3737   else if (GET_CODE (target) == SUBREG && SUBREG_PROMOTED_VAR_P (target))
3738     /* If this is an scalar in a register that is stored in a wider mode
3739        than the declared mode, compute the result into its declared mode
3740        and then convert to the wider mode.  Our value is the computed
3741        expression.  */
3742     {
3743       /* If we don't want a value, we can do the conversion inside EXP,
3744          which will often result in some optimizations.  Do the conversion
3745          in two steps: first change the signedness, if needed, then
3746          the extend.  But don't do this if the type of EXP is a subtype
3747          of something else since then the conversion might involve
3748          more than just converting modes.  */
3749       if (! want_value && INTEGRAL_TYPE_P (TREE_TYPE (exp))
3750           && TREE_TYPE (TREE_TYPE (exp)) == 0)
3751         {
3752           if (TREE_UNSIGNED (TREE_TYPE (exp))
3753               != SUBREG_PROMOTED_UNSIGNED_P (target))
3754             exp
3755               = convert
3756                 (signed_or_unsigned_type (SUBREG_PROMOTED_UNSIGNED_P (target),
3757                                           TREE_TYPE (exp)),
3758                  exp);
3759
3760           exp = convert (type_for_mode (GET_MODE (SUBREG_REG (target)),
3761                                         SUBREG_PROMOTED_UNSIGNED_P (target)),
3762                          exp);
3763         }
3764
3765       temp = expand_expr (exp, NULL_RTX, VOIDmode, 0);
3766
3767       /* If TEMP is a volatile MEM and we want a result value, make
3768          the access now so it gets done only once.  Likewise if
3769          it contains TARGET.  */
3770       if (GET_CODE (temp) == MEM && want_value
3771           && (MEM_VOLATILE_P (temp)
3772               || reg_mentioned_p (SUBREG_REG (target), XEXP (temp, 0))))
3773         temp = copy_to_reg (temp);
3774
3775       /* If TEMP is a VOIDmode constant, use convert_modes to make
3776          sure that we properly convert it.  */
3777       if (CONSTANT_P (temp) && GET_MODE (temp) == VOIDmode)
3778         temp = convert_modes (GET_MODE (SUBREG_REG (target)),
3779                               TYPE_MODE (TREE_TYPE (exp)), temp,
3780                               SUBREG_PROMOTED_UNSIGNED_P (target));
3781
3782       convert_move (SUBREG_REG (target), temp,
3783                     SUBREG_PROMOTED_UNSIGNED_P (target));
3784
3785       /* If we promoted a constant, change the mode back down to match
3786          target.  Otherwise, the caller might get confused by a result whose
3787          mode is larger than expected.  */
3788
3789       if (want_value && GET_MODE (temp) != GET_MODE (target)
3790           && GET_MODE (temp) != VOIDmode)
3791         {
3792           temp = gen_rtx_SUBREG (GET_MODE (target), temp, 0);
3793           SUBREG_PROMOTED_VAR_P (temp) = 1;
3794           SUBREG_PROMOTED_UNSIGNED_P (temp)
3795             = SUBREG_PROMOTED_UNSIGNED_P (target);
3796         }
3797
3798       return want_value ? temp : NULL_RTX;
3799     }
3800   else
3801     {
3802       temp = expand_expr (exp, target, GET_MODE (target), 0);
3803       /* Return TARGET if it's a specified hardware register.
3804          If TARGET is a volatile mem ref, either return TARGET
3805          or return a reg copied *from* TARGET; ANSI requires this.
3806
3807          Otherwise, if TEMP is not TARGET, return TEMP
3808          if it is constant (for efficiency),
3809          or if we really want the correct value.  */
3810       if (!(target && GET_CODE (target) == REG
3811             && REGNO (target) < FIRST_PSEUDO_REGISTER)
3812           && !(GET_CODE (target) == MEM && MEM_VOLATILE_P (target))
3813           && ! rtx_equal_p (temp, target)
3814           && (CONSTANT_P (temp) || want_value))
3815         dont_return_target = 1;
3816     }
3817
3818   /* If TEMP is a VOIDmode constant and the mode of the type of EXP is not
3819      the same as that of TARGET, adjust the constant.  This is needed, for
3820      example, in case it is a CONST_DOUBLE and we want only a word-sized
3821      value.  */
3822   if (CONSTANT_P (temp) && GET_MODE (temp) == VOIDmode
3823       && TREE_CODE (exp) != ERROR_MARK
3824       && GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp)))
3825     temp = convert_modes (GET_MODE (target), TYPE_MODE (TREE_TYPE (exp)),
3826                           temp, TREE_UNSIGNED (TREE_TYPE (exp)));
3827
3828   if (current_function_check_memory_usage
3829       && GET_CODE (target) == MEM
3830       && AGGREGATE_TYPE_P (TREE_TYPE (exp)))
3831     {
3832       if (GET_CODE (temp) == MEM)
3833         emit_library_call (chkr_copy_bitmap_libfunc, 1, VOIDmode, 3,
3834                            XEXP (target, 0), Pmode,
3835                            XEXP (temp, 0), Pmode,
3836                            expr_size (exp), TYPE_MODE (sizetype));
3837       else
3838         emit_library_call (chkr_check_addr_libfunc, 1, VOIDmode, 3,
3839                            XEXP (target, 0), Pmode,
3840                            expr_size (exp), TYPE_MODE (sizetype),
3841                            GEN_INT (MEMORY_USE_WO),
3842                            TYPE_MODE (integer_type_node));
3843     }
3844
3845   /* If value was not generated in the target, store it there.
3846      Convert the value to TARGET's type first if nec.  */
3847   /* If TEMP and TARGET compare equal according to rtx_equal_p, but
3848      one or both of them are volatile memory refs, we have to distinguish
3849      two cases:
3850      - expand_expr has used TARGET.  In this case, we must not generate
3851        another copy.  This can be detected by TARGET being equal according
3852        to == .
3853      - expand_expr has not used TARGET - that means that the source just
3854        happens to have the same RTX form.  Since temp will have been created
3855        by expand_expr, it will compare unequal according to == .
3856        We must generate a copy in this case, to reach the correct number
3857        of volatile memory references.  */
3858
3859   if ((! rtx_equal_p (temp, target)
3860        || (temp != target && (side_effects_p (temp)
3861                               || side_effects_p (target))))
3862       && TREE_CODE (exp) != ERROR_MARK)
3863     {
3864       target = protect_from_queue (target, 1);
3865       if (GET_MODE (temp) != GET_MODE (target)
3866           && GET_MODE (temp) != VOIDmode)
3867         {
3868           int unsignedp = TREE_UNSIGNED (TREE_TYPE (exp));
3869           if (dont_return_target)
3870             {
3871               /* In this case, we will return TEMP,
3872                  so make sure it has the proper mode.
3873                  But don't forget to store the value into TARGET.  */
3874               temp = convert_to_mode (GET_MODE (target), temp, unsignedp);
3875               emit_move_insn (target, temp);
3876             }
3877           else
3878             convert_move (target, temp, unsignedp);
3879         }
3880
3881       else if (GET_MODE (temp) == BLKmode && TREE_CODE (exp) == STRING_CST)
3882         {
3883           /* Handle copying a string constant into an array.
3884              The string constant may be shorter than the array.
3885              So copy just the string's actual length, and clear the rest.  */
3886           rtx size;
3887           rtx addr;
3888
3889           /* Get the size of the data type of the string,
3890              which is actually the size of the target.  */
3891           size = expr_size (exp);
3892           if (GET_CODE (size) == CONST_INT
3893               && INTVAL (size) < TREE_STRING_LENGTH (exp))
3894             emit_block_move (target, temp, size, TYPE_ALIGN (TREE_TYPE (exp)));
3895           else
3896             {
3897               /* Compute the size of the data to copy from the string.  */
3898               tree copy_size
3899                 = size_binop (MIN_EXPR,
3900                               make_tree (sizetype, size),
3901                               size_int (TREE_STRING_LENGTH (exp)));
3902               rtx copy_size_rtx = expand_expr (copy_size, NULL_RTX,
3903                                                VOIDmode, 0);
3904               rtx label = 0;
3905
3906               /* Copy that much.  */
3907               emit_block_move (target, temp, copy_size_rtx,
3908                                TYPE_ALIGN (TREE_TYPE (exp)));
3909
3910               /* Figure out how much is left in TARGET that we have to clear.
3911                  Do all calculations in ptr_mode.  */
3912
3913               addr = XEXP (target, 0);
3914               addr = convert_modes (ptr_mode, Pmode, addr, 1);
3915
3916               if (GET_CODE (copy_size_rtx) == CONST_INT)
3917                 {
3918                   addr = plus_constant (addr, TREE_STRING_LENGTH (exp));
3919                   size = plus_constant (size, - TREE_STRING_LENGTH (exp));
3920                 }
3921               else
3922                 {
3923                   addr = force_reg (ptr_mode, addr);
3924                   addr = expand_binop (ptr_mode, add_optab, addr,
3925                                        copy_size_rtx, NULL_RTX, 0,
3926                                        OPTAB_LIB_WIDEN);
3927
3928                   size = expand_binop (ptr_mode, sub_optab, size,
3929                                        copy_size_rtx, NULL_RTX, 0,
3930                                        OPTAB_LIB_WIDEN);
3931
3932                   label = gen_label_rtx ();
3933                   emit_cmp_and_jump_insns (size, const0_rtx, LT, NULL_RTX,
3934                                            GET_MODE (size), 0, 0, label);
3935                 }
3936
3937               if (size != const0_rtx)
3938                 {
3939                   /* Be sure we can write on ADDR.  */
3940                   if (current_function_check_memory_usage)
3941                     emit_library_call (chkr_check_addr_libfunc, 1, VOIDmode, 3,
3942                                        addr, Pmode,
3943                                        size, TYPE_MODE (sizetype),
3944                                        GEN_INT (MEMORY_USE_WO),
3945                                        TYPE_MODE (integer_type_node));
3946 #ifdef TARGET_MEM_FUNCTIONS
3947                   emit_library_call (memset_libfunc, 0, VOIDmode, 3,
3948                                      addr, ptr_mode,
3949                                      const0_rtx, TYPE_MODE (integer_type_node),
3950                                      convert_to_mode (TYPE_MODE (sizetype),
3951                                                       size,
3952                                                       TREE_UNSIGNED (sizetype)),
3953                                      TYPE_MODE (sizetype));
3954 #else
3955                   emit_library_call (bzero_libfunc, 0, VOIDmode, 2,
3956                                      addr, ptr_mode,
3957                                      convert_to_mode (TYPE_MODE (integer_type_node),
3958                                                       size,
3959                                                       TREE_UNSIGNED (integer_type_node)),
3960                                      TYPE_MODE (integer_type_node));
3961 #endif
3962                 }
3963
3964               if (label)
3965                 emit_label (label);
3966             }
3967         }
3968       /* Handle calls that return values in multiple non-contiguous locations.
3969          The Irix 6 ABI has examples of this.  */
3970       else if (GET_CODE (target) == PARALLEL)
3971         emit_group_load (target, temp, int_size_in_bytes (TREE_TYPE (exp)),
3972                          TYPE_ALIGN (TREE_TYPE (exp)));
3973       else if (GET_MODE (temp) == BLKmode)
3974         emit_block_move (target, temp, expr_size (exp),
3975                          TYPE_ALIGN (TREE_TYPE (exp)));
3976       else
3977         emit_move_insn (target, temp);
3978     }
3979
3980   /* If we don't want a value, return NULL_RTX.  */
3981   if (! want_value)
3982     return NULL_RTX;
3983
3984   /* If we are supposed to return TEMP, do so as long as it isn't a MEM.
3985      ??? The latter test doesn't seem to make sense.  */
3986   else if (dont_return_target && GET_CODE (temp) != MEM)
3987     return temp;
3988
3989   /* Return TARGET itself if it is a hard register.  */
3990   else if (want_value && GET_MODE (target) != BLKmode
3991            && ! (GET_CODE (target) == REG
3992                  && REGNO (target) < FIRST_PSEUDO_REGISTER))
3993     return copy_to_reg (target);
3994
3995   else
3996     return target;
3997 }
3998 \f
3999 /* Return 1 if EXP just contains zeros.  */
4000
4001 static int
4002 is_zeros_p (exp)
4003      tree exp;
4004 {
4005   tree elt;
4006
4007   switch (TREE_CODE (exp))
4008     {
4009     case CONVERT_EXPR:
4010     case NOP_EXPR:
4011     case NON_LVALUE_EXPR:
4012       return is_zeros_p (TREE_OPERAND (exp, 0));
4013
4014     case INTEGER_CST:
4015       return integer_zerop (exp);
4016
4017     case COMPLEX_CST:
4018       return
4019         is_zeros_p (TREE_REALPART (exp)) && is_zeros_p (TREE_IMAGPART (exp));
4020
4021     case REAL_CST:
4022       return REAL_VALUES_IDENTICAL (TREE_REAL_CST (exp), dconst0);
4023
4024     case CONSTRUCTOR:
4025       if (TREE_TYPE (exp) && TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
4026         return CONSTRUCTOR_ELTS (exp) == NULL_TREE;
4027       for (elt = CONSTRUCTOR_ELTS (exp); elt; elt = TREE_CHAIN (elt))
4028         if (! is_zeros_p (TREE_VALUE (elt)))
4029           return 0;
4030
4031       return 1;
4032
4033     default:
4034       return 0;
4035     }
4036 }
4037
4038 /* Return 1 if EXP contains mostly (3/4)  zeros.  */
4039
4040 static int
4041 mostly_zeros_p (exp)
4042      tree exp;
4043 {
4044   if (TREE_CODE (exp) == CONSTRUCTOR)
4045     {
4046       int elts = 0, zeros = 0;
4047       tree elt = CONSTRUCTOR_ELTS (exp);
4048       if (TREE_TYPE (exp) && TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
4049         {
4050           /* If there are no ranges of true bits, it is all zero.  */
4051           return elt == NULL_TREE;
4052         }
4053       for (; elt; elt = TREE_CHAIN (elt))
4054         {
4055           /* We do not handle the case where the index is a RANGE_EXPR,
4056              so the statistic will be somewhat inaccurate.
4057              We do make a more accurate count in store_constructor itself,
4058              so since this function is only used for nested array elements,
4059              this should be close enough.  */
4060           if (mostly_zeros_p (TREE_VALUE (elt)))
4061             zeros++;
4062           elts++;
4063         }
4064
4065       return 4 * zeros >= 3 * elts;
4066     }
4067
4068   return is_zeros_p (exp);
4069 }
4070 \f
4071 /* Helper function for store_constructor.
4072    TARGET, BITSIZE, BITPOS, MODE, EXP are as for store_field.
4073    TYPE is the type of the CONSTRUCTOR, not the element type.
4074    ALIGN and CLEARED are as for store_constructor.
4075
4076    This provides a recursive shortcut back to store_constructor when it isn't
4077    necessary to go through store_field.  This is so that we can pass through
4078    the cleared field to let store_constructor know that we may not have to
4079    clear a substructure if the outer structure has already been cleared.  */
4080
4081 static void
4082 store_constructor_field (target, bitsize, bitpos,
4083                          mode, exp, type, align, cleared)
4084      rtx target;
4085      unsigned HOST_WIDE_INT bitsize;
4086      HOST_WIDE_INT bitpos;
4087      enum machine_mode mode;
4088      tree exp, type;
4089      unsigned int align;
4090      int cleared;
4091 {
4092   if (TREE_CODE (exp) == CONSTRUCTOR
4093       && bitpos % BITS_PER_UNIT == 0
4094       /* If we have a non-zero bitpos for a register target, then we just
4095          let store_field do the bitfield handling.  This is unlikely to
4096          generate unnecessary clear instructions anyways.  */
4097       && (bitpos == 0 || GET_CODE (target) == MEM))
4098     {
4099       if (bitpos != 0)
4100         target
4101           = change_address (target,
4102                             GET_MODE (target) == BLKmode
4103                             || 0 != (bitpos
4104                                      % GET_MODE_ALIGNMENT (GET_MODE (target)))
4105                             ? BLKmode : VOIDmode,
4106                             plus_constant (XEXP (target, 0),
4107                                            bitpos / BITS_PER_UNIT));
4108       store_constructor (exp, target, align, cleared, bitsize / BITS_PER_UNIT);
4109     }
4110   else
4111     store_field (target, bitsize, bitpos, mode, exp, VOIDmode, 0, align,
4112                  int_size_in_bytes (type), 0);
4113 }
4114
4115 /* Store the value of constructor EXP into the rtx TARGET.
4116    TARGET is either a REG or a MEM.
4117    ALIGN is the maximum known alignment for TARGET.
4118    CLEARED is true if TARGET is known to have been zero'd.
4119    SIZE is the number of bytes of TARGET we are allowed to modify: this
4120    may not be the same as the size of EXP if we are assigning to a field
4121    which has been packed to exclude padding bits.  */
4122
4123 static void
4124 store_constructor (exp, target, align, cleared, size)
4125      tree exp;
4126      rtx target;
4127      unsigned int align;
4128      int cleared;
4129      HOST_WIDE_INT size;
4130 {
4131   tree type = TREE_TYPE (exp);
4132 #ifdef WORD_REGISTER_OPERATIONS
4133   HOST_WIDE_INT exp_size = int_size_in_bytes (type);
4134 #endif
4135
4136   /* We know our target cannot conflict, since safe_from_p has been called.  */
4137 #if 0
4138   /* Don't try copying piece by piece into a hard register
4139      since that is vulnerable to being clobbered by EXP.
4140      Instead, construct in a pseudo register and then copy it all.  */
4141   if (GET_CODE (target) == REG && REGNO (target) < FIRST_PSEUDO_REGISTER)
4142     {
4143       rtx temp = gen_reg_rtx (GET_MODE (target));
4144       store_constructor (exp, temp, align, cleared, size);
4145       emit_move_insn (target, temp);
4146       return;
4147     }
4148 #endif
4149
4150   if (TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
4151       || TREE_CODE (type) == QUAL_UNION_TYPE)
4152     {
4153       register tree elt;
4154
4155       /* Inform later passes that the whole union value is dead.  */
4156       if ((TREE_CODE (type) == UNION_TYPE
4157            || TREE_CODE (type) == QUAL_UNION_TYPE)
4158           && ! cleared)
4159         {
4160           emit_insn (gen_rtx_CLOBBER (VOIDmode, target));
4161
4162           /* If the constructor is empty, clear the union.  */
4163           if (! CONSTRUCTOR_ELTS (exp)  && ! cleared)
4164             clear_storage (target, expr_size (exp), TYPE_ALIGN (type));
4165         }
4166
4167       /* If we are building a static constructor into a register,
4168          set the initial value as zero so we can fold the value into
4169          a constant.  But if more than one register is involved,
4170          this probably loses.  */
4171       else if (GET_CODE (target) == REG && TREE_STATIC (exp)
4172                && GET_MODE_SIZE (GET_MODE (target)) <= UNITS_PER_WORD)
4173         {
4174           if (! cleared)
4175             emit_move_insn (target, CONST0_RTX (GET_MODE (target)));
4176
4177           cleared = 1;
4178         }
4179
4180       /* If the constructor has fewer fields than the structure
4181          or if we are initializing the structure to mostly zeros,
4182          clear the whole structure first.  */
4183       else if (size > 0
4184                && ((list_length (CONSTRUCTOR_ELTS (exp))
4185                     != fields_length (type))
4186                    || mostly_zeros_p (exp)))
4187         {
4188           if (! cleared)
4189             clear_storage (target, GEN_INT (size), align);
4190
4191           cleared = 1;
4192         }
4193       else if (! cleared)
4194         /* Inform later passes that the old value is dead.  */
4195         emit_insn (gen_rtx_CLOBBER (VOIDmode, target));
4196
4197       /* Store each element of the constructor into
4198          the corresponding field of TARGET.  */
4199
4200       for (elt = CONSTRUCTOR_ELTS (exp); elt; elt = TREE_CHAIN (elt))
4201         {
4202           register tree field = TREE_PURPOSE (elt);
4203 #ifdef WORD_REGISTER_OPERATIONS
4204           tree value = TREE_VALUE (elt);
4205 #endif
4206           register enum machine_mode mode;
4207           HOST_WIDE_INT bitsize;
4208           HOST_WIDE_INT bitpos = 0;
4209           int unsignedp;
4210           tree offset;
4211           rtx to_rtx = target;
4212
4213           /* Just ignore missing fields.
4214              We cleared the whole structure, above,
4215              if any fields are missing.  */
4216           if (field == 0)
4217             continue;
4218
4219           if (cleared && is_zeros_p (TREE_VALUE (elt)))
4220             continue;
4221
4222           if (host_integerp (DECL_SIZE (field), 1))
4223             bitsize = tree_low_cst (DECL_SIZE (field), 1);
4224           else
4225             bitsize = -1;
4226
4227           unsignedp = TREE_UNSIGNED (field);
4228           mode = DECL_MODE (field);
4229           if (DECL_BIT_FIELD (field))
4230             mode = VOIDmode;
4231
4232           offset = DECL_FIELD_OFFSET (field);
4233           if (host_integerp (offset, 0)
4234               && host_integerp (bit_position (field), 0))
4235             {
4236               bitpos = int_bit_position (field);
4237               offset = 0;
4238             }
4239           else
4240             bitpos = tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 0);
4241
4242           if (offset)
4243             {
4244               rtx offset_rtx;
4245
4246               if (contains_placeholder_p (offset))
4247                 offset = build (WITH_RECORD_EXPR, bitsizetype,
4248                                 offset, make_tree (TREE_TYPE (exp), target));
4249
4250               offset = size_binop (EXACT_DIV_EXPR, offset, bitsize_unit_node);
4251               offset = convert (sizetype, offset);
4252
4253               offset_rtx = expand_expr (offset, NULL_RTX, VOIDmode, 0);
4254               if (GET_CODE (to_rtx) != MEM)
4255                 abort ();
4256
4257               if (GET_MODE (offset_rtx) != ptr_mode)
4258                 {
4259 #ifdef POINTERS_EXTEND_UNSIGNED
4260                   offset_rtx = convert_memory_address (ptr_mode, offset_rtx);
4261 #else
4262                   offset_rtx = convert_to_mode (ptr_mode, offset_rtx, 0);
4263 #endif
4264                 }
4265
4266               to_rtx
4267                 = change_address (to_rtx, VOIDmode,
4268                                   gen_rtx_PLUS (ptr_mode, XEXP (to_rtx, 0),
4269                                                 force_reg (ptr_mode,
4270                                                            offset_rtx)));
4271             }
4272
4273           if (TREE_READONLY (field))
4274             {
4275               if (GET_CODE (to_rtx) == MEM)
4276                 to_rtx = copy_rtx (to_rtx);
4277
4278               RTX_UNCHANGING_P (to_rtx) = 1;
4279             }
4280
4281 #ifdef WORD_REGISTER_OPERATIONS
4282           /* If this initializes a field that is smaller than a word, at the
4283              start of a word, try to widen it to a full word.
4284              This special case allows us to output C++ member function
4285              initializations in a form that the optimizers can understand.  */
4286           if (GET_CODE (target) == REG
4287               && bitsize < BITS_PER_WORD
4288               && bitpos % BITS_PER_WORD == 0
4289               && GET_MODE_CLASS (mode) == MODE_INT
4290               && TREE_CODE (value) == INTEGER_CST
4291               && exp_size >= 0
4292               && bitpos + BITS_PER_WORD <= exp_size * BITS_PER_UNIT)
4293             {
4294               tree type = TREE_TYPE (value);
4295               if (TYPE_PRECISION (type) < BITS_PER_WORD)
4296                 {
4297                   type = type_for_size (BITS_PER_WORD, TREE_UNSIGNED (type));
4298                   value = convert (type, value);
4299                 }
4300               if (BYTES_BIG_ENDIAN)
4301                 value
4302                   = fold (build (LSHIFT_EXPR, type, value,
4303                                  build_int_2 (BITS_PER_WORD - bitsize, 0)));
4304               bitsize = BITS_PER_WORD;
4305               mode = word_mode;
4306             }
4307 #endif
4308           store_constructor_field (to_rtx, bitsize, bitpos, mode,
4309                                    TREE_VALUE (elt), type,
4310                                    MIN (align,
4311                                         DECL_ALIGN (TREE_PURPOSE (elt))),
4312                                    cleared);
4313         }
4314     }
4315   else if (TREE_CODE (type) == ARRAY_TYPE)
4316     {
4317       register tree elt;
4318       register int i;
4319       int need_to_clear;
4320       tree domain = TYPE_DOMAIN (type);
4321       HOST_WIDE_INT minelt = TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain));
4322       HOST_WIDE_INT maxelt = TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain));
4323       tree elttype = TREE_TYPE (type);
4324
4325       /* If the constructor has fewer elements than the array,
4326          clear the whole array first.  Similarly if this is
4327          static constructor of a non-BLKmode object.  */
4328       if (cleared || (GET_CODE (target) == REG && TREE_STATIC (exp)))
4329         need_to_clear = 1;
4330       else
4331         {
4332           HOST_WIDE_INT count = 0, zero_count = 0;
4333           need_to_clear = 0;
4334           /* This loop is a more accurate version of the loop in
4335              mostly_zeros_p (it handles RANGE_EXPR in an index).
4336              It is also needed to check for missing elements.  */
4337           for (elt = CONSTRUCTOR_ELTS (exp);
4338                elt != NULL_TREE;
4339                elt = TREE_CHAIN (elt))
4340             {
4341               tree index = TREE_PURPOSE (elt);
4342               HOST_WIDE_INT this_node_count;
4343
4344               if (index != NULL_TREE && TREE_CODE (index) == RANGE_EXPR)
4345                 {
4346                   tree lo_index = TREE_OPERAND (index, 0);
4347                   tree hi_index = TREE_OPERAND (index, 1);
4348
4349                   if (! host_integerp (lo_index, 1)
4350                       || ! host_integerp (hi_index, 1))
4351                     {
4352                       need_to_clear = 1;
4353                       break;
4354                     }
4355
4356                   this_node_count = (tree_low_cst (hi_index, 1)
4357                                      - tree_low_cst (lo_index, 1) + 1);
4358                 }
4359               else
4360                 this_node_count = 1;
4361               count += this_node_count;
4362               if (mostly_zeros_p (TREE_VALUE (elt)))
4363                 zero_count += this_node_count;
4364             }
4365           /* Clear the entire array first if there are any missing elements,
4366              or if the incidence of zero elements is >= 75%.  */
4367           if (count < maxelt - minelt + 1
4368               || 4 * zero_count >= 3 * count)
4369             need_to_clear = 1;
4370         }
4371       if (need_to_clear && size > 0)
4372         {
4373           if (! cleared)
4374             clear_storage (target, GEN_INT (size), align);
4375           cleared = 1;
4376         }
4377       else
4378         /* Inform later passes that the old value is dead.  */
4379         emit_insn (gen_rtx_CLOBBER (VOIDmode, target));
4380
4381       /* Store each element of the constructor into
4382          the corresponding element of TARGET, determined
4383          by counting the elements.  */
4384       for (elt = CONSTRUCTOR_ELTS (exp), i = 0;
4385            elt;
4386            elt = TREE_CHAIN (elt), i++)
4387         {
4388           register enum machine_mode mode;
4389           HOST_WIDE_INT bitsize;
4390           HOST_WIDE_INT bitpos;
4391           int unsignedp;
4392           tree value = TREE_VALUE (elt);
4393           unsigned int align = TYPE_ALIGN (TREE_TYPE (value));
4394           tree index = TREE_PURPOSE (elt);
4395           rtx xtarget = target;
4396
4397           if (cleared && is_zeros_p (value))
4398             continue;
4399
4400           unsignedp = TREE_UNSIGNED (elttype);
4401           mode = TYPE_MODE (elttype);
4402           if (mode == BLKmode)
4403             bitsize = (host_integerp (TYPE_SIZE (elttype), 1)
4404                        ? tree_low_cst (TYPE_SIZE (elttype), 1)
4405                        : -1);
4406           else
4407             bitsize = GET_MODE_BITSIZE (mode);
4408
4409           if (index != NULL_TREE && TREE_CODE (index) == RANGE_EXPR)
4410             {
4411               tree lo_index = TREE_OPERAND (index, 0);
4412               tree hi_index = TREE_OPERAND (index, 1);
4413               rtx index_r, pos_rtx, addr, hi_r, loop_top, loop_end;
4414               struct nesting *loop;
4415               HOST_WIDE_INT lo, hi, count;
4416               tree position;
4417
4418               /* If the range is constant and "small", unroll the loop.  */
4419               if (host_integerp (lo_index, 0)
4420                   && host_integerp (hi_index, 0)
4421                   && (lo = tree_low_cst (lo_index, 0),
4422                       hi = tree_low_cst (hi_index, 0),
4423                       count = hi - lo + 1,
4424                       (GET_CODE (target) != MEM
4425                        || count <= 2
4426                        || (host_integerp (TYPE_SIZE (elttype), 1)
4427                            && (tree_low_cst (TYPE_SIZE (elttype), 1) * count
4428                                <= 40 * 8)))))
4429                 {
4430                   lo -= minelt;  hi -= minelt;
4431                   for (; lo <= hi; lo++)
4432                     {
4433                       bitpos = lo * tree_low_cst (TYPE_SIZE (elttype), 0);
4434                       store_constructor_field (target, bitsize, bitpos, mode,
4435                                                value, type, align, cleared);
4436                     }
4437                 }
4438               else
4439                 {
4440                   hi_r = expand_expr (hi_index, NULL_RTX, VOIDmode, 0);
4441                   loop_top = gen_label_rtx ();
4442                   loop_end = gen_label_rtx ();
4443
4444                   unsignedp = TREE_UNSIGNED (domain);
4445
4446                   index = build_decl (VAR_DECL, NULL_TREE, domain);
4447
4448                   DECL_RTL (index) = index_r
4449                     = gen_reg_rtx (promote_mode (domain, DECL_MODE (index),
4450                                                  &unsignedp, 0));
4451
4452                   if (TREE_CODE (value) == SAVE_EXPR
4453                       && SAVE_EXPR_RTL (value) == 0)
4454                     {
4455                       /* Make sure value gets expanded once before the
4456                          loop.  */
4457                       expand_expr (value, const0_rtx, VOIDmode, 0);
4458                       emit_queue ();
4459                     }
4460                   store_expr (lo_index, index_r, 0);
4461                   loop = expand_start_loop (0);
4462
4463                   /* Assign value to element index.  */
4464                   position
4465                     = convert (ssizetype,
4466                                fold (build (MINUS_EXPR, TREE_TYPE (index),
4467                                             index, TYPE_MIN_VALUE (domain))));
4468                   position = size_binop (MULT_EXPR, position,
4469                                          convert (ssizetype,
4470                                                   TYPE_SIZE_UNIT (elttype)));
4471
4472                   pos_rtx = expand_expr (position, 0, VOIDmode, 0);
4473                   addr = gen_rtx_PLUS (Pmode, XEXP (target, 0), pos_rtx);
4474                   xtarget = change_address (target, mode, addr);
4475                   if (TREE_CODE (value) == CONSTRUCTOR)
4476                     store_constructor (value, xtarget, align, cleared,
4477                                        bitsize / BITS_PER_UNIT);
4478                   else
4479                     store_expr (value, xtarget, 0);
4480
4481                   expand_exit_loop_if_false (loop,
4482                                              build (LT_EXPR, integer_type_node,
4483                                                     index, hi_index));
4484
4485                   expand_increment (build (PREINCREMENT_EXPR,
4486                                            TREE_TYPE (index),
4487                                            index, integer_one_node), 0, 0);
4488                   expand_end_loop ();
4489                   emit_label (loop_end);
4490                 }
4491             }
4492           else if ((index != 0 && ! host_integerp (index, 0))
4493                    || ! host_integerp (TYPE_SIZE (elttype), 1))
4494             {
4495               rtx pos_rtx, addr;
4496               tree position;
4497
4498               if (index == 0)
4499                 index = ssize_int (1);
4500
4501               if (minelt)
4502                 index = convert (ssizetype,
4503                                  fold (build (MINUS_EXPR, index,
4504                                               TYPE_MIN_VALUE (domain))));
4505
4506               position = size_binop (MULT_EXPR, index,
4507                                      convert (ssizetype,
4508                                               TYPE_SIZE_UNIT (elttype)));
4509               pos_rtx = expand_expr (position, 0, VOIDmode, 0);
4510               addr = gen_rtx_PLUS (Pmode, XEXP (target, 0), pos_rtx);
4511               xtarget = change_address (target, mode, addr);
4512               store_expr (value, xtarget, 0);
4513             }
4514           else
4515             {
4516               if (index != 0)
4517                 bitpos = ((tree_low_cst (index, 0) - minelt)
4518                           * tree_low_cst (TYPE_SIZE (elttype), 1));
4519               else
4520                 bitpos = (i * tree_low_cst (TYPE_SIZE (elttype), 1));
4521
4522               store_constructor_field (target, bitsize, bitpos, mode, value,
4523                                        type, align, cleared);
4524             }
4525         }
4526     }
4527
4528   /* Set constructor assignments */
4529   else if (TREE_CODE (type) == SET_TYPE)
4530     {
4531       tree elt = CONSTRUCTOR_ELTS (exp);
4532       unsigned HOST_WIDE_INT nbytes = int_size_in_bytes (type), nbits;
4533       tree domain = TYPE_DOMAIN (type);
4534       tree domain_min, domain_max, bitlength;
4535
4536       /* The default implementation strategy is to extract the constant
4537          parts of the constructor, use that to initialize the target,
4538          and then "or" in whatever non-constant ranges we need in addition.
4539
4540          If a large set is all zero or all ones, it is
4541          probably better to set it using memset (if available) or bzero.
4542          Also, if a large set has just a single range, it may also be
4543          better to first clear all the first clear the set (using
4544          bzero/memset), and set the bits we want.  */
4545
4546       /* Check for all zeros.  */
4547       if (elt == NULL_TREE && size > 0)
4548         {
4549           if (!cleared)
4550             clear_storage (target, GEN_INT (size), TYPE_ALIGN (type));
4551           return;
4552         }
4553
4554       domain_min = convert (sizetype, TYPE_MIN_VALUE (domain));
4555       domain_max = convert (sizetype, TYPE_MAX_VALUE (domain));
4556       bitlength = size_binop (PLUS_EXPR,
4557                               size_diffop (domain_max, domain_min),
4558                               ssize_int (1));
4559
4560       nbits = tree_low_cst (bitlength, 1);
4561
4562       /* For "small" sets, or "medium-sized" (up to 32 bytes) sets that
4563          are "complicated" (more than one range), initialize (the
4564          constant parts) by copying from a constant.  */
4565       if (GET_MODE (target) != BLKmode || nbits <= 2 * BITS_PER_WORD
4566           || (nbytes <= 32 && TREE_CHAIN (elt) != NULL_TREE))
4567         {
4568           unsigned int set_word_size = TYPE_ALIGN (TREE_TYPE (exp));
4569           enum machine_mode mode = mode_for_size (set_word_size, MODE_INT, 1);
4570           char *bit_buffer = (char *) alloca (nbits);
4571           HOST_WIDE_INT word = 0;
4572           unsigned int bit_pos = 0;
4573           unsigned int ibit = 0;
4574           unsigned int offset = 0;  /* In bytes from beginning of set.  */
4575
4576           elt = get_set_constructor_bits (exp, bit_buffer, nbits);
4577           for (;;)
4578             {
4579               if (bit_buffer[ibit])
4580                 {
4581                   if (BYTES_BIG_ENDIAN)
4582                     word |= (1 << (set_word_size - 1 - bit_pos));
4583                   else
4584                     word |= 1 << bit_pos;
4585                 }
4586
4587               bit_pos++;  ibit++;
4588               if (bit_pos >= set_word_size || ibit == nbits)
4589                 {
4590                   if (word != 0 || ! cleared)
4591                     {
4592                       rtx datum = GEN_INT (word);
4593                       rtx to_rtx;
4594
4595                       /* The assumption here is that it is safe to use
4596                          XEXP if the set is multi-word, but not if
4597                          it's single-word.  */
4598                       if (GET_CODE (target) == MEM)
4599                         {
4600                           to_rtx = plus_constant (XEXP (target, 0), offset);
4601                           to_rtx = change_address (target, mode, to_rtx);
4602                         }
4603                       else if (offset == 0)
4604                         to_rtx = target;
4605                       else
4606                         abort ();
4607                       emit_move_insn (to_rtx, datum);
4608                     }
4609
4610                   if (ibit == nbits)
4611                     break;
4612                   word = 0;
4613                   bit_pos = 0;
4614                   offset += set_word_size / BITS_PER_UNIT;
4615                 }
4616             }
4617         }
4618       else if (!cleared)
4619         /* Don't bother clearing storage if the set is all ones.  */
4620         if (TREE_CHAIN (elt) != NULL_TREE
4621             || (TREE_PURPOSE (elt) == NULL_TREE
4622                 ? nbits != 1
4623                 : ( ! host_integerp (TREE_VALUE (elt), 0)
4624                    || ! host_integerp (TREE_PURPOSE (elt), 0)
4625                    || (tree_low_cst (TREE_VALUE (elt), 0)
4626                        - tree_low_cst (TREE_PURPOSE (elt), 0) + 1
4627                        != (HOST_WIDE_INT) nbits))))
4628           clear_storage (target, expr_size (exp), TYPE_ALIGN (type));
4629
4630       for (; elt != NULL_TREE; elt = TREE_CHAIN (elt))
4631         {
4632           /* start of range of element or NULL */
4633           tree startbit = TREE_PURPOSE (elt);
4634           /* end of range of element, or element value */
4635           tree endbit   = TREE_VALUE (elt);
4636 #ifdef TARGET_MEM_FUNCTIONS
4637           HOST_WIDE_INT startb, endb;
4638 #endif
4639           rtx bitlength_rtx, startbit_rtx, endbit_rtx, targetx;
4640
4641           bitlength_rtx = expand_expr (bitlength,
4642                                        NULL_RTX, MEM, EXPAND_CONST_ADDRESS);
4643
4644           /* handle non-range tuple element like [ expr ]  */
4645           if (startbit == NULL_TREE)
4646             {
4647               startbit = save_expr (endbit);
4648               endbit = startbit;
4649             }
4650
4651           startbit = convert (sizetype, startbit);
4652           endbit = convert (sizetype, endbit);
4653           if (! integer_zerop (domain_min))
4654             {
4655               startbit = size_binop (MINUS_EXPR, startbit, domain_min);
4656               endbit = size_binop (MINUS_EXPR, endbit, domain_min);
4657             }
4658           startbit_rtx = expand_expr (startbit, NULL_RTX, MEM,
4659                                       EXPAND_CONST_ADDRESS);
4660           endbit_rtx = expand_expr (endbit, NULL_RTX, MEM,
4661                                     EXPAND_CONST_ADDRESS);
4662
4663           if (REG_P (target))
4664             {
4665               targetx = assign_stack_temp (GET_MODE (target),
4666                                            GET_MODE_SIZE (GET_MODE (target)),
4667                                            0);
4668               emit_move_insn (targetx, target);
4669             }
4670
4671           else if (GET_CODE (target) == MEM)
4672             targetx = target;
4673           else
4674             abort ();
4675
4676 #ifdef TARGET_MEM_FUNCTIONS
4677           /* Optimization:  If startbit and endbit are
4678              constants divisible by BITS_PER_UNIT,
4679              call memset instead.  */
4680           if (TREE_CODE (startbit) == INTEGER_CST
4681               && TREE_CODE (endbit) == INTEGER_CST
4682               && (startb = TREE_INT_CST_LOW (startbit)) % BITS_PER_UNIT == 0
4683               && (endb = TREE_INT_CST_LOW (endbit) + 1) % BITS_PER_UNIT == 0)
4684             {
4685               emit_library_call (memset_libfunc, 0,
4686                                  VOIDmode, 3,
4687                                  plus_constant (XEXP (targetx, 0),
4688                                                 startb / BITS_PER_UNIT),
4689                                  Pmode,
4690                                  constm1_rtx, TYPE_MODE (integer_type_node),
4691                                  GEN_INT ((endb - startb) / BITS_PER_UNIT),
4692                                  TYPE_MODE (sizetype));
4693             }
4694           else
4695 #endif
4696             emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "__setbits"),
4697                                0, VOIDmode, 4, XEXP (targetx, 0), Pmode,
4698                                bitlength_rtx, TYPE_MODE (sizetype),
4699                                startbit_rtx, TYPE_MODE (sizetype),
4700                                endbit_rtx, TYPE_MODE (sizetype));
4701
4702           if (REG_P (target))
4703             emit_move_insn (target, targetx);
4704         }
4705     }
4706
4707   else
4708     abort ();
4709 }
4710
4711 /* Store the value of EXP (an expression tree)
4712    into a subfield of TARGET which has mode MODE and occupies
4713    BITSIZE bits, starting BITPOS bits from the start of TARGET.
4714    If MODE is VOIDmode, it means that we are storing into a bit-field.
4715
4716    If VALUE_MODE is VOIDmode, return nothing in particular.
4717    UNSIGNEDP is not used in this case.
4718
4719    Otherwise, return an rtx for the value stored.  This rtx
4720    has mode VALUE_MODE if that is convenient to do.
4721    In this case, UNSIGNEDP must be nonzero if the value is an unsigned type.
4722
4723    ALIGN is the alignment that TARGET is known to have.
4724    TOTAL_SIZE is the size in bytes of the structure, or -1 if varying.
4725
4726    ALIAS_SET is the alias set for the destination.  This value will
4727    (in general) be different from that for TARGET, since TARGET is a
4728    reference to the containing structure.  */
4729
4730 static rtx
4731 store_field (target, bitsize, bitpos, mode, exp, value_mode,
4732              unsignedp, align, total_size, alias_set)
4733      rtx target;
4734      HOST_WIDE_INT bitsize;
4735      HOST_WIDE_INT bitpos;
4736      enum machine_mode mode;
4737      tree exp;
4738      enum machine_mode value_mode;
4739      int unsignedp;
4740      unsigned int align;
4741      HOST_WIDE_INT total_size;
4742      int alias_set;
4743 {
4744   HOST_WIDE_INT width_mask = 0;
4745
4746   if (TREE_CODE (exp) == ERROR_MARK)
4747     return const0_rtx;
4748
4749   if (bitsize < HOST_BITS_PER_WIDE_INT)
4750     width_mask = ((HOST_WIDE_INT) 1 << bitsize) - 1;
4751
4752   /* If we are storing into an unaligned field of an aligned union that is
4753      in a register, we may have the mode of TARGET being an integer mode but
4754      MODE == BLKmode.  In that case, get an aligned object whose size and
4755      alignment are the same as TARGET and store TARGET into it (we can avoid
4756      the store if the field being stored is the entire width of TARGET).  Then
4757      call ourselves recursively to store the field into a BLKmode version of
4758      that object.  Finally, load from the object into TARGET.  This is not
4759      very efficient in general, but should only be slightly more expensive
4760      than the otherwise-required unaligned accesses.  Perhaps this can be
4761      cleaned up later.  */
4762
4763   if (mode == BLKmode
4764       && (GET_CODE (target) == REG || GET_CODE (target) == SUBREG))
4765     {
4766       rtx object = assign_stack_temp (GET_MODE (target),
4767                                       GET_MODE_SIZE (GET_MODE (target)), 0);
4768       rtx blk_object = copy_rtx (object);
4769
4770       MEM_SET_IN_STRUCT_P (object, 1);
4771       MEM_SET_IN_STRUCT_P (blk_object, 1);
4772       PUT_MODE (blk_object, BLKmode);
4773
4774       if (bitsize != GET_MODE_BITSIZE (GET_MODE (target)))
4775         emit_move_insn (object, target);
4776
4777       store_field (blk_object, bitsize, bitpos, mode, exp, VOIDmode, 0,
4778                    align, total_size, alias_set);
4779
4780       /* Even though we aren't returning target, we need to
4781          give it the updated value.  */
4782       emit_move_insn (target, object);
4783
4784       return blk_object;
4785     }
4786
4787   if (GET_CODE (target) == CONCAT)
4788     {
4789       /* We're storing into a struct containing a single __complex.  */
4790
4791       if (bitpos != 0)
4792         abort ();
4793       return store_expr (exp, target, 0);
4794     }
4795
4796   /* If the structure is in a register or if the component
4797      is a bit field, we cannot use addressing to access it.
4798      Use bit-field techniques or SUBREG to store in it.  */
4799
4800   if (mode == VOIDmode
4801       || (mode != BLKmode && ! direct_store[(int) mode]
4802           && GET_MODE_CLASS (mode) != MODE_COMPLEX_INT
4803           && GET_MODE_CLASS (mode) != MODE_COMPLEX_FLOAT)
4804       || GET_CODE (target) == REG
4805       || GET_CODE (target) == SUBREG
4806       /* If the field isn't aligned enough to store as an ordinary memref,
4807          store it as a bit field.  */
4808       || (mode != BLKmode && SLOW_UNALIGNED_ACCESS (mode, align)
4809           && (align < GET_MODE_ALIGNMENT (mode)
4810               || bitpos % GET_MODE_ALIGNMENT (mode)))
4811       || (mode == BLKmode && SLOW_UNALIGNED_ACCESS (mode, align)
4812           && (TYPE_ALIGN (TREE_TYPE (exp)) > align
4813               || bitpos % TYPE_ALIGN (TREE_TYPE (exp)) != 0))
4814       /* If the RHS and field are a constant size and the size of the
4815          RHS isn't the same size as the bitfield, we must use bitfield
4816          operations.  */
4817       || (bitsize >= 0
4818           && TREE_CODE (TYPE_SIZE (TREE_TYPE (exp))) == INTEGER_CST
4819           && compare_tree_int (TYPE_SIZE (TREE_TYPE (exp)), bitsize) != 0))
4820     {
4821       rtx temp = expand_expr (exp, NULL_RTX, VOIDmode, 0);
4822
4823       /* If BITSIZE is narrower than the size of the type of EXP
4824          we will be narrowing TEMP.  Normally, what's wanted are the
4825          low-order bits.  However, if EXP's type is a record and this is
4826          big-endian machine, we want the upper BITSIZE bits.  */
4827       if (BYTES_BIG_ENDIAN && GET_MODE_CLASS (GET_MODE (temp)) == MODE_INT
4828           && bitsize < GET_MODE_BITSIZE (GET_MODE (temp))
4829           && TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
4830         temp = expand_shift (RSHIFT_EXPR, GET_MODE (temp), temp,
4831                              size_int (GET_MODE_BITSIZE (GET_MODE (temp))
4832                                        - bitsize),
4833                              temp, 1);
4834
4835       /* Unless MODE is VOIDmode or BLKmode, convert TEMP to
4836          MODE.  */
4837       if (mode != VOIDmode && mode != BLKmode
4838           && mode != TYPE_MODE (TREE_TYPE (exp)))
4839         temp = convert_modes (mode, TYPE_MODE (TREE_TYPE (exp)), temp, 1);
4840
4841       /* If the modes of TARGET and TEMP are both BLKmode, both
4842          must be in memory and BITPOS must be aligned on a byte
4843          boundary.  If so, we simply do a block copy.  */
4844       if (GET_MODE (target) == BLKmode && GET_MODE (temp) == BLKmode)
4845         {
4846           unsigned int exp_align = expr_align (exp);
4847
4848           if (GET_CODE (target) != MEM || GET_CODE (temp) != MEM
4849               || bitpos % BITS_PER_UNIT != 0)
4850             abort ();
4851
4852           target = change_address (target, VOIDmode,
4853                                    plus_constant (XEXP (target, 0),
4854                                                 bitpos / BITS_PER_UNIT));
4855
4856           /* Make sure that ALIGN is no stricter than the alignment of EXP.  */
4857           align = MIN (exp_align, align);
4858
4859           /* Find an alignment that is consistent with the bit position.  */
4860           while ((bitpos % align) != 0)
4861             align >>= 1;
4862
4863           emit_block_move (target, temp,
4864                            GEN_INT ((bitsize + BITS_PER_UNIT - 1)
4865                                     / BITS_PER_UNIT),
4866                            align);
4867
4868           return value_mode == VOIDmode ? const0_rtx : target;
4869         }
4870
4871       /* Store the value in the bitfield.  */
4872       store_bit_field (target, bitsize, bitpos, mode, temp, align, total_size);
4873       if (value_mode != VOIDmode)
4874         {
4875           /* The caller wants an rtx for the value.  */
4876           /* If possible, avoid refetching from the bitfield itself.  */
4877           if (width_mask != 0
4878               && ! (GET_CODE (target) == MEM && MEM_VOLATILE_P (target)))
4879             {
4880               tree count;
4881               enum machine_mode tmode;
4882
4883               if (unsignedp)
4884                 return expand_and (temp, GEN_INT (width_mask), NULL_RTX);
4885               tmode = GET_MODE (temp);
4886               if (tmode == VOIDmode)
4887                 tmode = value_mode;
4888               count = build_int_2 (GET_MODE_BITSIZE (tmode) - bitsize, 0);
4889               temp = expand_shift (LSHIFT_EXPR, tmode, temp, count, 0, 0);
4890               return expand_shift (RSHIFT_EXPR, tmode, temp, count, 0, 0);
4891             }
4892           return extract_bit_field (target, bitsize, bitpos, unsignedp,
4893                                     NULL_RTX, value_mode, 0, align,
4894                                     total_size);
4895         }
4896       return const0_rtx;
4897     }
4898   else
4899     {
4900       rtx addr = XEXP (target, 0);
4901       rtx to_rtx;
4902
4903       /* If a value is wanted, it must be the lhs;
4904          so make the address stable for multiple use.  */
4905
4906       if (value_mode != VOIDmode && GET_CODE (addr) != REG
4907           && ! CONSTANT_ADDRESS_P (addr)
4908           /* A frame-pointer reference is already stable.  */
4909           && ! (GET_CODE (addr) == PLUS
4910                 && GET_CODE (XEXP (addr, 1)) == CONST_INT
4911                 && (XEXP (addr, 0) == virtual_incoming_args_rtx
4912                     || XEXP (addr, 0) == virtual_stack_vars_rtx)))
4913         addr = copy_to_reg (addr);
4914
4915       /* Now build a reference to just the desired component.  */
4916
4917       to_rtx = copy_rtx (change_address (target, mode,
4918                                          plus_constant (addr,
4919                                                         (bitpos
4920                                                          / BITS_PER_UNIT))));
4921       MEM_SET_IN_STRUCT_P (to_rtx, 1);
4922       MEM_ALIAS_SET (to_rtx) = alias_set;
4923
4924       return store_expr (exp, to_rtx, value_mode != VOIDmode);
4925     }
4926 }
4927 \f
4928 /* Given an expression EXP that may be a COMPONENT_REF, a BIT_FIELD_REF,
4929    or an ARRAY_REF, look for nested COMPONENT_REFs, BIT_FIELD_REFs, or
4930    ARRAY_REFs and find the ultimate containing object, which we return.
4931
4932    We set *PBITSIZE to the size in bits that we want, *PBITPOS to the
4933    bit position, and *PUNSIGNEDP to the signedness of the field.
4934    If the position of the field is variable, we store a tree
4935    giving the variable offset (in units) in *POFFSET.
4936    This offset is in addition to the bit position.
4937    If the position is not variable, we store 0 in *POFFSET.
4938    We set *PALIGNMENT to the alignment of the address that will be
4939    computed.  This is the alignment of the thing we return if *POFFSET
4940    is zero, but can be more less strictly aligned if *POFFSET is nonzero.
4941
4942    If any of the extraction expressions is volatile,
4943    we store 1 in *PVOLATILEP.  Otherwise we don't change that.
4944
4945    If the field is a bit-field, *PMODE is set to VOIDmode.  Otherwise, it
4946    is a mode that can be used to access the field.  In that case, *PBITSIZE
4947    is redundant.
4948
4949    If the field describes a variable-sized object, *PMODE is set to
4950    VOIDmode and *PBITSIZE is set to -1.  An access cannot be made in
4951    this case, but the address of the object can be found.   */
4952
4953 tree
4954 get_inner_reference (exp, pbitsize, pbitpos, poffset, pmode,
4955                      punsignedp, pvolatilep, palignment)
4956      tree exp;
4957      HOST_WIDE_INT *pbitsize;
4958      HOST_WIDE_INT *pbitpos;
4959      tree *poffset;
4960      enum machine_mode *pmode;
4961      int *punsignedp;
4962      int *pvolatilep;
4963      unsigned int *palignment;
4964 {
4965   tree size_tree = 0;
4966   enum machine_mode mode = VOIDmode;
4967   tree offset = size_zero_node;
4968   tree bit_offset = bitsize_zero_node;
4969   unsigned int alignment = BIGGEST_ALIGNMENT;
4970   tree tem;
4971
4972   /* First get the mode, signedness, and size.  We do this from just the
4973      outermost expression.  */
4974   if (TREE_CODE (exp) == COMPONENT_REF)
4975     {
4976       size_tree = DECL_SIZE (TREE_OPERAND (exp, 1));
4977       if (! DECL_BIT_FIELD (TREE_OPERAND (exp, 1)))
4978         mode = DECL_MODE (TREE_OPERAND (exp, 1));
4979
4980       *punsignedp = TREE_UNSIGNED (TREE_OPERAND (exp, 1));
4981     }
4982   else if (TREE_CODE (exp) == BIT_FIELD_REF)
4983     {
4984       size_tree = TREE_OPERAND (exp, 1);
4985       *punsignedp = TREE_UNSIGNED (exp);
4986     }
4987   else
4988     {
4989       mode = TYPE_MODE (TREE_TYPE (exp));
4990       *punsignedp = TREE_UNSIGNED (TREE_TYPE (exp));
4991
4992       if (mode == BLKmode)
4993         size_tree = TYPE_SIZE (TREE_TYPE (exp));
4994       else
4995         *pbitsize = GET_MODE_BITSIZE (mode);
4996     }
4997
4998   if (size_tree != 0)
4999     {
5000       if (! host_integerp (size_tree, 1))
5001         mode = BLKmode, *pbitsize = -1;
5002       else
5003         *pbitsize = tree_low_cst (size_tree, 1);
5004     }
5005
5006   /* Compute cumulative bit-offset for nested component-refs and array-refs,
5007      and find the ultimate containing object.  */
5008   while (1)
5009     {
5010       if (TREE_CODE (exp) == BIT_FIELD_REF)
5011         bit_offset = size_binop (PLUS_EXPR, bit_offset, TREE_OPERAND (exp, 2));
5012       else if (TREE_CODE (exp) == COMPONENT_REF)
5013         {
5014           tree field = TREE_OPERAND (exp, 1);
5015           tree this_offset = DECL_FIELD_OFFSET (field);
5016
5017           /* If this field hasn't been filled in yet, don't go
5018              past it.  This should only happen when folding expressions
5019              made during type construction.  */
5020           if (this_offset == 0)
5021             break;
5022           else if (! TREE_CONSTANT (this_offset)
5023                    && contains_placeholder_p (this_offset))
5024             this_offset = build (WITH_RECORD_EXPR, sizetype, this_offset, exp);
5025
5026           offset = size_binop (PLUS_EXPR, offset, DECL_FIELD_OFFSET (field));
5027           bit_offset = size_binop (PLUS_EXPR, bit_offset,
5028                                    DECL_FIELD_BIT_OFFSET (field));
5029
5030           if (! host_integerp (offset, 0))
5031             alignment = MIN (alignment, DECL_OFFSET_ALIGN (field));
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
5039           /* We assume all arrays have sizes that are a multiple of a byte.
5040              First subtract the lower bound, if any, in the type of the
5041              index, then convert to sizetype and multiply by the size of the
5042              array element.  */
5043           if (low_bound != 0 && ! integer_zerop (low_bound))
5044             index = fold (build (MINUS_EXPR, TREE_TYPE (index),
5045                                  index, low_bound));
5046
5047           if (! TREE_CONSTANT (index)
5048               && contains_placeholder_p (index))
5049             index = build (WITH_RECORD_EXPR, TREE_TYPE (index), index, exp);
5050
5051           offset = size_binop (PLUS_EXPR, offset,
5052                                size_binop (MULT_EXPR,
5053                                            convert (sizetype, index),
5054                                            TYPE_SIZE_UNIT (TREE_TYPE (exp))));
5055         }
5056       else if (TREE_CODE (exp) != NON_LVALUE_EXPR
5057                && ! ((TREE_CODE (exp) == NOP_EXPR
5058                       || TREE_CODE (exp) == CONVERT_EXPR)
5059                      && (TYPE_MODE (TREE_TYPE (exp))
5060                          == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))))))
5061         break;
5062
5063       /* If any reference in the chain is volatile, the effect is volatile.  */
5064       if (TREE_THIS_VOLATILE (exp))
5065         *pvolatilep = 1;
5066
5067       /* If the offset is non-constant already, then we can't assume any
5068          alignment more than the alignment here.  */
5069       if (! TREE_CONSTANT (offset))
5070         alignment = MIN (alignment, TYPE_ALIGN (TREE_TYPE (exp)));
5071
5072       exp = TREE_OPERAND (exp, 0);
5073     }
5074
5075   if (DECL_P (exp))
5076     alignment = MIN (alignment, DECL_ALIGN (exp));
5077   else if (TREE_TYPE (exp) != 0)
5078     alignment = MIN (alignment, TYPE_ALIGN (TREE_TYPE (exp)));
5079
5080   /* If OFFSET is constant, see if we can return the whole thing as a
5081      constant bit position.  Otherwise, split it up.  */
5082   if (host_integerp (offset, 0)
5083       && 0 != (tem = size_binop (MULT_EXPR, convert (bitsizetype, offset),
5084                                  bitsize_unit_node))
5085       && 0 != (tem = size_binop (PLUS_EXPR, tem, bit_offset))
5086       && host_integerp (tem, 0))
5087     *pbitpos = tree_low_cst (tem, 0), *poffset = 0;
5088   else
5089     *pbitpos = tree_low_cst (bit_offset, 0), *poffset = offset;
5090
5091   *pmode = mode;
5092   *palignment = alignment;
5093   return exp;
5094 }
5095
5096 /* Subroutine of expand_exp: compute memory_usage from modifier.  */
5097
5098 static enum memory_use_mode
5099 get_memory_usage_from_modifier (modifier)
5100      enum expand_modifier modifier;
5101 {
5102   switch (modifier)
5103     {
5104     case EXPAND_NORMAL:
5105     case EXPAND_SUM:
5106       return MEMORY_USE_RO;
5107       break;
5108     case EXPAND_MEMORY_USE_WO:
5109       return MEMORY_USE_WO;
5110       break;
5111     case EXPAND_MEMORY_USE_RW:
5112       return MEMORY_USE_RW;
5113       break;
5114     case EXPAND_MEMORY_USE_DONT:
5115       /* EXPAND_CONST_ADDRESS and EXPAND_INITIALIZER are converted into
5116          MEMORY_USE_DONT, because they are modifiers to a call of
5117          expand_expr in the ADDR_EXPR case of expand_expr.  */
5118     case EXPAND_CONST_ADDRESS:
5119     case EXPAND_INITIALIZER:
5120       return MEMORY_USE_DONT;
5121     case EXPAND_MEMORY_USE_BAD:
5122     default:
5123       abort ();
5124     }
5125 }
5126 \f
5127 /* Given an rtx VALUE that may contain additions and multiplications,
5128    return an equivalent value that just refers to a register or memory.
5129    This is done by generating instructions to perform the arithmetic
5130    and returning a pseudo-register containing the value.
5131
5132    The returned value may be a REG, SUBREG, MEM or constant.  */
5133
5134 rtx
5135 force_operand (value, target)
5136      rtx value, target;
5137 {
5138   register optab binoptab = 0;
5139   /* Use a temporary to force order of execution of calls to
5140      `force_operand'.  */
5141   rtx tmp;
5142   register rtx op2;
5143   /* Use subtarget as the target for operand 0 of a binary operation.  */
5144   register rtx subtarget = (target != 0 && GET_CODE (target) == REG ? target : 0);
5145
5146   /* Check for a PIC address load.  */
5147   if (flag_pic
5148       && (GET_CODE (value) == PLUS || GET_CODE (value) == MINUS)
5149       && XEXP (value, 0) == pic_offset_table_rtx
5150       && (GET_CODE (XEXP (value, 1)) == SYMBOL_REF
5151           || GET_CODE (XEXP (value, 1)) == LABEL_REF
5152           || GET_CODE (XEXP (value, 1)) == CONST))
5153     {
5154       if (!subtarget)
5155         subtarget = gen_reg_rtx (GET_MODE (value));
5156       emit_move_insn (subtarget, value);
5157       return subtarget;
5158     }
5159
5160   if (GET_CODE (value) == PLUS)
5161     binoptab = add_optab;
5162   else if (GET_CODE (value) == MINUS)
5163     binoptab = sub_optab;
5164   else if (GET_CODE (value) == MULT)
5165     {
5166       op2 = XEXP (value, 1);
5167       if (!CONSTANT_P (op2)
5168           && !(GET_CODE (op2) == REG && op2 != subtarget))
5169         subtarget = 0;
5170       tmp = force_operand (XEXP (value, 0), subtarget);
5171       return expand_mult (GET_MODE (value), tmp,
5172                           force_operand (op2, NULL_RTX),
5173                           target, 0);
5174     }
5175
5176   if (binoptab)
5177     {
5178       op2 = XEXP (value, 1);
5179       if (!CONSTANT_P (op2)
5180           && !(GET_CODE (op2) == REG && op2 != subtarget))
5181         subtarget = 0;
5182       if (binoptab == sub_optab && GET_CODE (op2) == CONST_INT)
5183         {
5184           binoptab = add_optab;
5185           op2 = negate_rtx (GET_MODE (value), op2);
5186         }
5187
5188       /* Check for an addition with OP2 a constant integer and our first
5189          operand a PLUS of a virtual register and something else.  In that
5190          case, we want to emit the sum of the virtual register and the
5191          constant first and then add the other value.  This allows virtual
5192          register instantiation to simply modify the constant rather than
5193          creating another one around this addition.  */
5194       if (binoptab == add_optab && GET_CODE (op2) == CONST_INT
5195           && GET_CODE (XEXP (value, 0)) == PLUS
5196           && GET_CODE (XEXP (XEXP (value, 0), 0)) == REG
5197           && REGNO (XEXP (XEXP (value, 0), 0)) >= FIRST_VIRTUAL_REGISTER
5198           && REGNO (XEXP (XEXP (value, 0), 0)) <= LAST_VIRTUAL_REGISTER)
5199         {
5200           rtx temp = expand_binop (GET_MODE (value), binoptab,
5201                                    XEXP (XEXP (value, 0), 0), op2,
5202                                    subtarget, 0, OPTAB_LIB_WIDEN);
5203           return expand_binop (GET_MODE (value), binoptab, temp,
5204                                force_operand (XEXP (XEXP (value, 0), 1), 0),
5205                                target, 0, OPTAB_LIB_WIDEN);
5206         }
5207
5208       tmp = force_operand (XEXP (value, 0), subtarget);
5209       return expand_binop (GET_MODE (value), binoptab, tmp,
5210                            force_operand (op2, NULL_RTX),
5211                            target, 0, OPTAB_LIB_WIDEN);
5212       /* We give UNSIGNEDP = 0 to expand_binop
5213          because the only operations we are expanding here are signed ones.  */
5214     }
5215   return value;
5216 }
5217 \f
5218 /* Subroutine of expand_expr:
5219    save the non-copied parts (LIST) of an expr (LHS), and return a list
5220    which can restore these values to their previous values,
5221    should something modify their storage.  */
5222
5223 static tree
5224 save_noncopied_parts (lhs, list)
5225      tree lhs;
5226      tree list;
5227 {
5228   tree tail;
5229   tree parts = 0;
5230
5231   for (tail = list; tail; tail = TREE_CHAIN (tail))
5232     if (TREE_CODE (TREE_VALUE (tail)) == TREE_LIST)
5233       parts = chainon (parts, save_noncopied_parts (lhs, TREE_VALUE (tail)));
5234     else
5235       {
5236         tree part = TREE_VALUE (tail);
5237         tree part_type = TREE_TYPE (part);
5238         tree to_be_saved = build (COMPONENT_REF, part_type, lhs, part);
5239         rtx target = assign_temp (part_type, 0, 1, 1);
5240         if (! memory_address_p (TYPE_MODE (part_type), XEXP (target, 0)))
5241           target = change_address (target, TYPE_MODE (part_type), NULL_RTX);
5242         parts = tree_cons (to_be_saved,
5243                            build (RTL_EXPR, part_type, NULL_TREE,
5244                                   (tree) target),
5245                            parts);
5246         store_expr (TREE_PURPOSE (parts), RTL_EXPR_RTL (TREE_VALUE (parts)), 0);
5247       }
5248   return parts;
5249 }
5250
5251 /* Subroutine of expand_expr:
5252    record the non-copied parts (LIST) of an expr (LHS), and return a list
5253    which specifies the initial values of these parts.  */
5254
5255 static tree
5256 init_noncopied_parts (lhs, list)
5257      tree lhs;
5258      tree list;
5259 {
5260   tree tail;
5261   tree parts = 0;
5262
5263   for (tail = list; tail; tail = TREE_CHAIN (tail))
5264     if (TREE_CODE (TREE_VALUE (tail)) == TREE_LIST)
5265       parts = chainon (parts, init_noncopied_parts (lhs, TREE_VALUE (tail)));
5266     else if (TREE_PURPOSE (tail))
5267       {
5268         tree part = TREE_VALUE (tail);
5269         tree part_type = TREE_TYPE (part);
5270         tree to_be_initialized = build (COMPONENT_REF, part_type, lhs, part);
5271         parts = tree_cons (TREE_PURPOSE (tail), to_be_initialized, parts);
5272       }
5273   return parts;
5274 }
5275
5276 /* Subroutine of expand_expr: return nonzero iff there is no way that
5277    EXP can reference X, which is being modified.  TOP_P is nonzero if this
5278    call is going to be used to determine whether we need a temporary
5279    for EXP, as opposed to a recursive call to this function.
5280
5281    It is always safe for this routine to return zero since it merely
5282    searches for optimization opportunities.  */
5283
5284 static int
5285 safe_from_p (x, exp, top_p)
5286      rtx x;
5287      tree exp;
5288      int top_p;
5289 {
5290   rtx exp_rtl = 0;
5291   int i, nops;
5292   static int save_expr_count;
5293   static int save_expr_size = 0;
5294   static tree *save_expr_rewritten;
5295   static tree save_expr_trees[256];
5296
5297   if (x == 0
5298       /* If EXP has varying size, we MUST use a target since we currently
5299          have no way of allocating temporaries of variable size
5300          (except for arrays that have TYPE_ARRAY_MAX_SIZE set).
5301          So we assume here that something at a higher level has prevented a
5302          clash.  This is somewhat bogus, but the best we can do.  Only
5303          do this when X is BLKmode and when we are at the top level.  */
5304       || (top_p && TREE_TYPE (exp) != 0 && COMPLETE_TYPE_P (TREE_TYPE (exp))
5305           && TREE_CODE (TYPE_SIZE (TREE_TYPE (exp))) != INTEGER_CST
5306           && (TREE_CODE (TREE_TYPE (exp)) != ARRAY_TYPE
5307               || TYPE_ARRAY_MAX_SIZE (TREE_TYPE (exp)) == NULL_TREE
5308               || TREE_CODE (TYPE_ARRAY_MAX_SIZE (TREE_TYPE (exp)))
5309               != INTEGER_CST)
5310           && GET_MODE (x) == BLKmode))
5311     return 1;
5312
5313   if (top_p && save_expr_size == 0)
5314     {
5315       int rtn;
5316
5317       save_expr_count = 0;
5318       save_expr_size = sizeof (save_expr_trees) / sizeof (save_expr_trees[0]);
5319       save_expr_rewritten = &save_expr_trees[0];
5320
5321       rtn = safe_from_p (x, exp, 1);
5322
5323       for (i = 0; i < save_expr_count; ++i)
5324         {
5325           if (TREE_CODE (save_expr_trees[i]) != ERROR_MARK)
5326             abort ();
5327           TREE_SET_CODE (save_expr_trees[i], SAVE_EXPR);
5328         }
5329
5330       save_expr_size = 0;
5331
5332       return rtn;
5333     }
5334
5335   /* If this is a subreg of a hard register, declare it unsafe, otherwise,
5336      find the underlying pseudo.  */
5337   if (GET_CODE (x) == SUBREG)
5338     {
5339       x = SUBREG_REG (x);
5340       if (GET_CODE (x) == REG && REGNO (x) < FIRST_PSEUDO_REGISTER)
5341         return 0;
5342     }
5343
5344   /* If X is a location in the outgoing argument area, it is always safe.  */
5345   if (GET_CODE (x) == MEM
5346       && (XEXP (x, 0) == virtual_outgoing_args_rtx
5347           || (GET_CODE (XEXP (x, 0)) == PLUS
5348               && XEXP (XEXP (x, 0), 0) == virtual_outgoing_args_rtx)))
5349     return 1;
5350
5351   switch (TREE_CODE_CLASS (TREE_CODE (exp)))
5352     {
5353     case 'd':
5354       exp_rtl = DECL_RTL (exp);
5355       break;
5356
5357     case 'c':
5358       return 1;
5359
5360     case 'x':
5361       if (TREE_CODE (exp) == TREE_LIST)
5362         return ((TREE_VALUE (exp) == 0
5363                  || safe_from_p (x, TREE_VALUE (exp), 0))
5364                 && (TREE_CHAIN (exp) == 0
5365                     || safe_from_p (x, TREE_CHAIN (exp), 0)));
5366       else if (TREE_CODE (exp) == ERROR_MARK)
5367         return 1;       /* An already-visited SAVE_EXPR? */
5368       else
5369         return 0;
5370
5371     case '1':
5372       return safe_from_p (x, TREE_OPERAND (exp, 0), 0);
5373
5374     case '2':
5375     case '<':
5376       return (safe_from_p (x, TREE_OPERAND (exp, 0), 0)
5377               && safe_from_p (x, TREE_OPERAND (exp, 1), 0));
5378
5379     case 'e':
5380     case 'r':
5381       /* Now do code-specific tests.  EXP_RTL is set to any rtx we find in
5382          the expression.  If it is set, we conflict iff we are that rtx or
5383          both are in memory.  Otherwise, we check all operands of the
5384          expression recursively.  */
5385
5386       switch (TREE_CODE (exp))
5387         {
5388         case ADDR_EXPR:
5389           return (staticp (TREE_OPERAND (exp, 0))
5390                   || safe_from_p (x, TREE_OPERAND (exp, 0), 0)
5391                   || TREE_STATIC (exp));
5392
5393         case INDIRECT_REF:
5394           if (GET_CODE (x) == MEM)
5395             return 0;
5396           break;
5397
5398         case CALL_EXPR:
5399           exp_rtl = CALL_EXPR_RTL (exp);
5400           if (exp_rtl == 0)
5401             {
5402               /* Assume that the call will clobber all hard registers and
5403                  all of memory.  */
5404               if ((GET_CODE (x) == REG && REGNO (x) < FIRST_PSEUDO_REGISTER)
5405                   || GET_CODE (x) == MEM)
5406                 return 0;
5407             }
5408
5409           break;
5410
5411         case RTL_EXPR:
5412           /* If a sequence exists, we would have to scan every instruction
5413              in the sequence to see if it was safe.  This is probably not
5414              worthwhile.  */
5415           if (RTL_EXPR_SEQUENCE (exp))
5416             return 0;
5417
5418           exp_rtl = RTL_EXPR_RTL (exp);
5419           break;
5420
5421         case WITH_CLEANUP_EXPR:
5422           exp_rtl = RTL_EXPR_RTL (exp);
5423           break;
5424
5425         case CLEANUP_POINT_EXPR:
5426           return safe_from_p (x, TREE_OPERAND (exp, 0), 0);
5427
5428         case SAVE_EXPR:
5429           exp_rtl = SAVE_EXPR_RTL (exp);
5430           if (exp_rtl)
5431             break;
5432
5433           /* This SAVE_EXPR might appear many times in the top-level
5434              safe_from_p() expression, and if it has a complex
5435              subexpression, examining it multiple times could result
5436              in a combinatorial explosion.  E.g. on an Alpha
5437              running at least 200MHz, a Fortran test case compiled with
5438              optimization took about 28 minutes to compile -- even though
5439              it was only a few lines long, and the complicated line causing
5440              so much time to be spent in the earlier version of safe_from_p()
5441              had only 293 or so unique nodes.
5442
5443              So, turn this SAVE_EXPR into an ERROR_MARK for now, but remember
5444              where it is so we can turn it back in the top-level safe_from_p()
5445              when we're done.  */
5446
5447           /* For now, don't bother re-sizing the array. */
5448           if (save_expr_count >= save_expr_size)
5449             return 0;
5450           save_expr_rewritten[save_expr_count++] = exp;
5451
5452           nops = tree_code_length[(int) SAVE_EXPR];
5453           for (i = 0; i < nops; i++)
5454             {
5455               tree operand = TREE_OPERAND (exp, i);
5456               if (operand == NULL_TREE)
5457                 continue;
5458               TREE_SET_CODE (exp, ERROR_MARK);
5459               if (!safe_from_p (x, operand, 0))
5460                 return 0;
5461               TREE_SET_CODE (exp, SAVE_EXPR);
5462             }
5463           TREE_SET_CODE (exp, ERROR_MARK);
5464           return 1;
5465
5466         case BIND_EXPR:
5467           /* The only operand we look at is operand 1.  The rest aren't
5468              part of the expression.  */
5469           return safe_from_p (x, TREE_OPERAND (exp, 1), 0);
5470
5471         case METHOD_CALL_EXPR:
5472           /* This takes a rtx argument, but shouldn't appear here.  */
5473           abort ();
5474
5475         default:
5476           break;
5477         }
5478
5479       /* If we have an rtx, we do not need to scan our operands.  */
5480       if (exp_rtl)
5481         break;
5482
5483       nops = tree_code_length[(int) TREE_CODE (exp)];
5484       for (i = 0; i < nops; i++)
5485         if (TREE_OPERAND (exp, i) != 0
5486             && ! safe_from_p (x, TREE_OPERAND (exp, i), 0))
5487           return 0;
5488     }
5489
5490   /* If we have an rtl, find any enclosed object.  Then see if we conflict
5491      with it.  */
5492   if (exp_rtl)
5493     {
5494       if (GET_CODE (exp_rtl) == SUBREG)
5495         {
5496           exp_rtl = SUBREG_REG (exp_rtl);
5497           if (GET_CODE (exp_rtl) == REG
5498               && REGNO (exp_rtl) < FIRST_PSEUDO_REGISTER)
5499             return 0;
5500         }
5501
5502       /* If the rtl is X, then it is not safe.  Otherwise, it is unless both
5503          are memory and EXP is not readonly.  */
5504       return ! (rtx_equal_p (x, exp_rtl)
5505                 || (GET_CODE (x) == MEM && GET_CODE (exp_rtl) == MEM
5506                     && ! TREE_READONLY (exp)));
5507     }
5508
5509   /* If we reach here, it is safe.  */
5510   return 1;
5511 }
5512
5513 /* Subroutine of expand_expr: return nonzero iff EXP is an
5514    expression whose type is statically determinable.  */
5515
5516 static int
5517 fixed_type_p (exp)
5518      tree exp;
5519 {
5520   if (TREE_CODE (exp) == PARM_DECL
5521       || TREE_CODE (exp) == VAR_DECL
5522       || TREE_CODE (exp) == CALL_EXPR || TREE_CODE (exp) == TARGET_EXPR
5523       || TREE_CODE (exp) == COMPONENT_REF
5524       || TREE_CODE (exp) == ARRAY_REF)
5525     return 1;
5526   return 0;
5527 }
5528
5529 /* Subroutine of expand_expr: return rtx if EXP is a
5530    variable or parameter; else return 0.  */
5531
5532 static rtx
5533 var_rtx (exp)
5534      tree exp;
5535 {
5536   STRIP_NOPS (exp);
5537   switch (TREE_CODE (exp))
5538     {
5539     case PARM_DECL:
5540     case VAR_DECL:
5541       return DECL_RTL (exp);
5542     default:
5543       return 0;
5544     }
5545 }
5546
5547 #ifdef MAX_INTEGER_COMPUTATION_MODE
5548 void
5549 check_max_integer_computation_mode (exp)
5550     tree exp;
5551 {
5552   enum tree_code code;
5553   enum machine_mode mode;
5554
5555   /* Strip any NOPs that don't change the mode.  */
5556   STRIP_NOPS (exp);
5557   code = TREE_CODE (exp);
5558
5559   /* We must allow conversions of constants to MAX_INTEGER_COMPUTATION_MODE.  */
5560   if (code == NOP_EXPR
5561       && TREE_CODE (TREE_OPERAND (exp, 0)) == INTEGER_CST)
5562     return;
5563
5564   /* First check the type of the overall operation.   We need only look at
5565      unary, binary and relational operations.  */
5566   if (TREE_CODE_CLASS (code) == '1'
5567       || TREE_CODE_CLASS (code) == '2'
5568       || TREE_CODE_CLASS (code) == '<')
5569     {
5570       mode = TYPE_MODE (TREE_TYPE (exp));
5571       if (GET_MODE_CLASS (mode) == MODE_INT
5572           && mode > MAX_INTEGER_COMPUTATION_MODE)
5573         fatal ("unsupported wide integer operation");
5574     }
5575
5576   /* Check operand of a unary op.  */
5577   if (TREE_CODE_CLASS (code) == '1')
5578     {
5579       mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
5580       if (GET_MODE_CLASS (mode) == MODE_INT
5581           && mode > MAX_INTEGER_COMPUTATION_MODE)
5582         fatal ("unsupported wide integer operation");
5583     }
5584
5585   /* Check operands of a binary/comparison op.  */
5586   if (TREE_CODE_CLASS (code) == '2' || TREE_CODE_CLASS (code) == '<')
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       mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 1)));
5594       if (GET_MODE_CLASS (mode) == MODE_INT
5595           && mode > MAX_INTEGER_COMPUTATION_MODE)
5596         fatal ("unsupported wide integer operation");
5597     }
5598 }
5599 #endif
5600
5601 \f
5602 /* Utility function used by expand_expr to see if TYPE, a RECORD_TYPE,
5603    has any readonly fields.  If any of the fields have types that
5604    contain readonly fields, return true as well.  */
5605
5606 static int
5607 readonly_fields_p (type)
5608      tree type;
5609 {
5610   tree field;
5611
5612   for (field = TYPE_FIELDS (type); field != 0; field = TREE_CHAIN (field))
5613     if (TREE_CODE (field) == FIELD_DECL
5614         && (TREE_READONLY (field)
5615             || (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
5616                 && readonly_fields_p (TREE_TYPE (field)))))
5617       return 1;
5618
5619   return 0;
5620 }
5621 \f
5622 /* expand_expr: generate code for computing expression EXP.
5623    An rtx for the computed value is returned.  The value is never null.
5624    In the case of a void EXP, const0_rtx is returned.
5625
5626    The value may be stored in TARGET if TARGET is nonzero.
5627    TARGET is just a suggestion; callers must assume that
5628    the rtx returned may not be the same as TARGET.
5629
5630    If TARGET is CONST0_RTX, it means that the value will be ignored.
5631
5632    If TMODE is not VOIDmode, it suggests generating the
5633    result in mode TMODE.  But this is done only when convenient.
5634    Otherwise, TMODE is ignored and the value generated in its natural mode.
5635    TMODE is just a suggestion; callers must assume that
5636    the rtx returned may not have mode TMODE.
5637
5638    Note that TARGET may have neither TMODE nor MODE.  In that case, it
5639    probably will not be used.
5640
5641    If MODIFIER is EXPAND_SUM then when EXP is an addition
5642    we can return an rtx of the form (MULT (REG ...) (CONST_INT ...))
5643    or a nest of (PLUS ...) and (MINUS ...) where the terms are
5644    products as above, or REG or MEM, or constant.
5645    Ordinarily in such cases we would output mul or add instructions
5646    and then return a pseudo reg containing the sum.
5647
5648    EXPAND_INITIALIZER is much like EXPAND_SUM except that
5649    it also marks a label as absolutely required (it can't be dead).
5650    It also makes a ZERO_EXTEND or SIGN_EXTEND instead of emitting extend insns.
5651    This is used for outputting expressions used in initializers.
5652
5653    EXPAND_CONST_ADDRESS says that it is okay to return a MEM
5654    with a constant address even if that address is not normally legitimate.
5655    EXPAND_INITIALIZER and EXPAND_SUM also have this effect.  */
5656
5657 rtx
5658 expand_expr (exp, target, tmode, modifier)
5659      register tree exp;
5660      rtx target;
5661      enum machine_mode tmode;
5662      enum expand_modifier modifier;
5663 {
5664   register rtx op0, op1, temp;
5665   tree type = TREE_TYPE (exp);
5666   int unsignedp = TREE_UNSIGNED (type);
5667   register enum machine_mode mode;
5668   register enum tree_code code = TREE_CODE (exp);
5669   optab this_optab;
5670   rtx subtarget, original_target;
5671   int ignore;
5672   tree context;
5673   /* Used by check-memory-usage to make modifier read only.  */
5674   enum expand_modifier ro_modifier;
5675
5676   /* Handle ERROR_MARK before anybody tries to access its type. */
5677   if (TREE_CODE (exp) == ERROR_MARK)
5678     {
5679       op0 = CONST0_RTX (tmode);
5680       if (op0 != 0)
5681         return op0;
5682       return const0_rtx;
5683     }
5684
5685   mode = TYPE_MODE (type);
5686   /* Use subtarget as the target for operand 0 of a binary operation.  */
5687   subtarget = (target != 0 && GET_CODE (target) == REG ? target : 0);
5688   original_target = target;
5689   ignore = (target == const0_rtx
5690             || ((code == NON_LVALUE_EXPR || code == NOP_EXPR
5691                  || code == CONVERT_EXPR || code == REFERENCE_EXPR
5692                  || code == COND_EXPR)
5693                 && TREE_CODE (type) == VOID_TYPE));
5694
5695   /* Make a read-only version of the modifier.  */
5696   if (modifier == EXPAND_NORMAL || modifier == EXPAND_SUM
5697       || modifier == EXPAND_CONST_ADDRESS || modifier == EXPAND_INITIALIZER)
5698     ro_modifier = modifier;
5699   else
5700     ro_modifier = EXPAND_NORMAL;
5701
5702   /* Don't use hard regs as subtargets, because the combiner
5703      can only handle pseudo regs.  */
5704   if (subtarget && REGNO (subtarget) < FIRST_PSEUDO_REGISTER)
5705     subtarget = 0;
5706   /* Avoid subtargets inside loops,
5707      since they hide some invariant expressions.  */
5708   if (preserve_subexpressions_p ())
5709     subtarget = 0;
5710
5711   /* If we are going to ignore this result, we need only do something
5712      if there is a side-effect somewhere in the expression.  If there
5713      is, short-circuit the most common cases here.  Note that we must
5714      not call expand_expr with anything but const0_rtx in case this
5715      is an initial expansion of a size that contains a PLACEHOLDER_EXPR.  */
5716
5717   if (ignore)
5718     {
5719       if (! TREE_SIDE_EFFECTS (exp))
5720         return const0_rtx;
5721
5722       /* Ensure we reference a volatile object even if value is ignored, but
5723          don't do this if all we are doing is taking its address.  */
5724       if (TREE_THIS_VOLATILE (exp)
5725           && TREE_CODE (exp) != FUNCTION_DECL
5726           && mode != VOIDmode && mode != BLKmode
5727           && modifier != EXPAND_CONST_ADDRESS)
5728         {
5729           temp = expand_expr (exp, NULL_RTX, VOIDmode, ro_modifier);
5730           if (GET_CODE (temp) == MEM)
5731             temp = copy_to_reg (temp);
5732           return const0_rtx;
5733         }
5734
5735       if (TREE_CODE_CLASS (code) == '1' || code == COMPONENT_REF
5736           || code == INDIRECT_REF || code == BUFFER_REF)
5737         return expand_expr (TREE_OPERAND (exp, 0), const0_rtx,
5738                             VOIDmode, ro_modifier);
5739       else if (TREE_CODE_CLASS (code) == '2' || TREE_CODE_CLASS (code) == '<'
5740              || code == ARRAY_REF)
5741         {
5742           expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode, ro_modifier);
5743           expand_expr (TREE_OPERAND (exp, 1), const0_rtx, VOIDmode, ro_modifier);
5744           return const0_rtx;
5745         }
5746       else if ((code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR)
5747                && ! TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 1)))
5748         /* If the second operand has no side effects, just evaluate
5749            the first.  */
5750         return expand_expr (TREE_OPERAND (exp, 0), const0_rtx,
5751                             VOIDmode, ro_modifier);
5752       else if (code == BIT_FIELD_REF)
5753         {
5754           expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode, ro_modifier);
5755           expand_expr (TREE_OPERAND (exp, 1), const0_rtx, VOIDmode, ro_modifier);
5756           expand_expr (TREE_OPERAND (exp, 2), const0_rtx, VOIDmode, ro_modifier);
5757           return const0_rtx;
5758         }
5759 ;
5760       target = 0;
5761     }
5762
5763 #ifdef MAX_INTEGER_COMPUTATION_MODE
5764   /* Only check stuff here if the mode we want is different from the mode
5765      of the expression; if it's the same, check_max_integer_computiation_mode
5766      will handle it.  Do we really need to check this stuff at all?  */
5767
5768   if (target
5769       && GET_MODE (target) != mode
5770       && TREE_CODE (exp) != INTEGER_CST
5771       && TREE_CODE (exp) != PARM_DECL
5772       && TREE_CODE (exp) != ARRAY_REF
5773       && TREE_CODE (exp) != COMPONENT_REF
5774       && TREE_CODE (exp) != BIT_FIELD_REF
5775       && TREE_CODE (exp) != INDIRECT_REF
5776       && TREE_CODE (exp) != CALL_EXPR
5777       && TREE_CODE (exp) != VAR_DECL
5778       && TREE_CODE (exp) != RTL_EXPR)
5779     {
5780       enum machine_mode mode = GET_MODE (target);
5781
5782       if (GET_MODE_CLASS (mode) == MODE_INT
5783           && mode > MAX_INTEGER_COMPUTATION_MODE)
5784         fatal ("unsupported wide integer operation");
5785     }
5786
5787   if (tmode != mode
5788       && TREE_CODE (exp) != INTEGER_CST
5789       && TREE_CODE (exp) != PARM_DECL
5790       && TREE_CODE (exp) != ARRAY_REF
5791       && TREE_CODE (exp) != COMPONENT_REF
5792       && TREE_CODE (exp) != BIT_FIELD_REF
5793       && TREE_CODE (exp) != INDIRECT_REF
5794       && TREE_CODE (exp) != VAR_DECL
5795       && TREE_CODE (exp) != CALL_EXPR
5796       && TREE_CODE (exp) != RTL_EXPR
5797       && GET_MODE_CLASS (tmode) == MODE_INT
5798       && tmode > MAX_INTEGER_COMPUTATION_MODE)
5799     fatal ("unsupported wide integer operation");
5800
5801   check_max_integer_computation_mode (exp);
5802 #endif
5803
5804   /* If will do cse, generate all results into pseudo registers
5805      since 1) that allows cse to find more things
5806      and 2) otherwise cse could produce an insn the machine
5807      cannot support.  */
5808
5809   if (! cse_not_expected && mode != BLKmode && target
5810       && (GET_CODE (target) != REG || REGNO (target) < FIRST_PSEUDO_REGISTER))
5811     target = subtarget;
5812
5813   switch (code)
5814     {
5815     case LABEL_DECL:
5816       {
5817         tree function = decl_function_context (exp);
5818         /* Handle using a label in a containing function.  */
5819         if (function != current_function_decl
5820             && function != inline_function_decl && function != 0)
5821           {
5822             struct function *p = find_function_data (function);
5823             /* Allocate in the memory associated with the function
5824                that the label is in.  */
5825             push_obstacks (p->function_obstack,
5826                            p->function_maybepermanent_obstack);
5827
5828             p->expr->x_forced_labels
5829               = gen_rtx_EXPR_LIST (VOIDmode, label_rtx (exp),
5830                                    p->expr->x_forced_labels);
5831             pop_obstacks ();
5832           }
5833         else
5834           {
5835             if (modifier == EXPAND_INITIALIZER)
5836               forced_labels = gen_rtx_EXPR_LIST (VOIDmode,
5837                                                  label_rtx (exp),
5838                                                  forced_labels);
5839           }
5840
5841         temp = gen_rtx_MEM (FUNCTION_MODE,
5842                             gen_rtx_LABEL_REF (Pmode, label_rtx (exp)));
5843         if (function != current_function_decl
5844             && function != inline_function_decl && function != 0)
5845           LABEL_REF_NONLOCAL_P (XEXP (temp, 0)) = 1;
5846         return temp;
5847       }
5848
5849     case PARM_DECL:
5850       if (DECL_RTL (exp) == 0)
5851         {
5852           error_with_decl (exp, "prior parameter's size depends on `%s'");
5853           return CONST0_RTX (mode);
5854         }
5855
5856       /* ... fall through ...  */
5857
5858     case VAR_DECL:
5859       /* If a static var's type was incomplete when the decl was written,
5860          but the type is complete now, lay out the decl now.  */
5861       if (DECL_SIZE (exp) == 0 && COMPLETE_TYPE_P (TREE_TYPE (exp))
5862           && (TREE_STATIC (exp) || DECL_EXTERNAL (exp)))
5863         {
5864           push_obstacks_nochange ();
5865           end_temporary_allocation ();
5866           layout_decl (exp, 0);
5867           PUT_MODE (DECL_RTL (exp), DECL_MODE (exp));
5868           pop_obstacks ();
5869         }
5870
5871       /* Although static-storage variables start off initialized, according to
5872          ANSI C, a memcpy could overwrite them with uninitialized values.  So
5873          we check them too.  This also lets us check for read-only variables
5874          accessed via a non-const declaration, in case it won't be detected
5875          any other way (e.g., in an embedded system or OS kernel without
5876          memory protection).
5877
5878          Aggregates are not checked here; they're handled elsewhere.  */
5879       if (cfun && current_function_check_memory_usage
5880           && code == VAR_DECL
5881           && GET_CODE (DECL_RTL (exp)) == MEM
5882           && ! AGGREGATE_TYPE_P (TREE_TYPE (exp)))
5883         {
5884           enum memory_use_mode memory_usage;
5885           memory_usage = get_memory_usage_from_modifier (modifier);
5886
5887           if (memory_usage != MEMORY_USE_DONT)
5888             emit_library_call (chkr_check_addr_libfunc, 1, VOIDmode, 3,
5889                                XEXP (DECL_RTL (exp), 0), Pmode,
5890                                GEN_INT (int_size_in_bytes (type)),
5891                                TYPE_MODE (sizetype),
5892                                GEN_INT (memory_usage),
5893                                TYPE_MODE (integer_type_node));
5894         }
5895
5896       /* ... fall through ...  */
5897
5898     case FUNCTION_DECL:
5899     case RESULT_DECL:
5900       if (DECL_RTL (exp) == 0)
5901         abort ();
5902
5903       /* Ensure variable marked as used even if it doesn't go through
5904          a parser.  If it hasn't be used yet, write out an external
5905          definition.  */
5906       if (! TREE_USED (exp))
5907         {
5908           assemble_external (exp);
5909           TREE_USED (exp) = 1;
5910         }
5911
5912       /* Show we haven't gotten RTL for this yet.  */
5913       temp = 0;
5914
5915       /* Handle variables inherited from containing functions.  */
5916       context = decl_function_context (exp);
5917
5918       /* We treat inline_function_decl as an alias for the current function
5919          because that is the inline function whose vars, types, etc.
5920          are being merged into the current function.
5921          See expand_inline_function.  */
5922
5923       if (context != 0 && context != current_function_decl
5924           && context != inline_function_decl
5925           /* If var is static, we don't need a static chain to access it.  */
5926           && ! (GET_CODE (DECL_RTL (exp)) == MEM
5927                 && CONSTANT_P (XEXP (DECL_RTL (exp), 0))))
5928         {
5929           rtx addr;
5930
5931           /* Mark as non-local and addressable.  */
5932           DECL_NONLOCAL (exp) = 1;
5933           if (DECL_NO_STATIC_CHAIN (current_function_decl))
5934             abort ();
5935           mark_addressable (exp);
5936           if (GET_CODE (DECL_RTL (exp)) != MEM)
5937             abort ();
5938           addr = XEXP (DECL_RTL (exp), 0);
5939           if (GET_CODE (addr) == MEM)
5940             addr = gen_rtx_MEM (Pmode,
5941                                 fix_lexical_addr (XEXP (addr, 0), exp));
5942           else
5943             addr = fix_lexical_addr (addr, exp);
5944           temp = change_address (DECL_RTL (exp), mode, addr);
5945         }
5946
5947       /* This is the case of an array whose size is to be determined
5948          from its initializer, while the initializer is still being parsed.
5949          See expand_decl.  */
5950
5951       else if (GET_CODE (DECL_RTL (exp)) == MEM
5952                && GET_CODE (XEXP (DECL_RTL (exp), 0)) == REG)
5953         temp = change_address (DECL_RTL (exp), GET_MODE (DECL_RTL (exp)),
5954                                XEXP (DECL_RTL (exp), 0));
5955
5956       /* If DECL_RTL is memory, we are in the normal case and either
5957          the address is not valid or it is not a register and -fforce-addr
5958          is specified, get the address into a register.  */
5959
5960       else if (GET_CODE (DECL_RTL (exp)) == MEM
5961                && modifier != EXPAND_CONST_ADDRESS
5962                && modifier != EXPAND_SUM
5963                && modifier != EXPAND_INITIALIZER
5964                && (! memory_address_p (DECL_MODE (exp),
5965                                        XEXP (DECL_RTL (exp), 0))
5966                    || (flag_force_addr
5967                        && GET_CODE (XEXP (DECL_RTL (exp), 0)) != REG)))
5968         temp = change_address (DECL_RTL (exp), VOIDmode,
5969                                copy_rtx (XEXP (DECL_RTL (exp), 0)));
5970
5971       /* If we got something, return it.  But first, set the alignment
5972          the address is a register.  */
5973       if (temp != 0)
5974         {
5975           if (GET_CODE (temp) == MEM && GET_CODE (XEXP (temp, 0)) == REG)
5976             mark_reg_pointer (XEXP (temp, 0),
5977                               DECL_ALIGN (exp) / BITS_PER_UNIT);
5978
5979           return temp;
5980         }
5981
5982       /* If the mode of DECL_RTL does not match that of the decl, it
5983          must be a promoted value.  We return a SUBREG of the wanted mode,
5984          but mark it so that we know that it was already extended.  */
5985
5986       if (GET_CODE (DECL_RTL (exp)) == REG
5987           && GET_MODE (DECL_RTL (exp)) != mode)
5988         {
5989           /* Get the signedness used for this variable.  Ensure we get the
5990              same mode we got when the variable was declared.  */
5991           if (GET_MODE (DECL_RTL (exp))
5992               != promote_mode (type, DECL_MODE (exp), &unsignedp, 0))
5993             abort ();
5994
5995           temp = gen_rtx_SUBREG (mode, DECL_RTL (exp), 0);
5996           SUBREG_PROMOTED_VAR_P (temp) = 1;
5997           SUBREG_PROMOTED_UNSIGNED_P (temp) = unsignedp;
5998           return temp;
5999         }
6000
6001       return DECL_RTL (exp);
6002
6003     case INTEGER_CST:
6004       return immed_double_const (TREE_INT_CST_LOW (exp),
6005                                  TREE_INT_CST_HIGH (exp), mode);
6006
6007     case CONST_DECL:
6008       return expand_expr (DECL_INITIAL (exp), target, VOIDmode,
6009                           EXPAND_MEMORY_USE_BAD);
6010
6011     case REAL_CST:
6012       /* If optimized, generate immediate CONST_DOUBLE
6013          which will be turned into memory by reload if necessary.
6014
6015          We used to force a register so that loop.c could see it.  But
6016          this does not allow gen_* patterns to perform optimizations with
6017          the constants.  It also produces two insns in cases like "x = 1.0;".
6018          On most machines, floating-point constants are not permitted in
6019          many insns, so we'd end up copying it to a register in any case.
6020
6021          Now, we do the copying in expand_binop, if appropriate.  */
6022       return immed_real_const (exp);
6023
6024     case COMPLEX_CST:
6025     case STRING_CST:
6026       if (! TREE_CST_RTL (exp))
6027         output_constant_def (exp);
6028
6029       /* TREE_CST_RTL probably contains a constant address.
6030          On RISC machines where a constant address isn't valid,
6031          make some insns to get that address into a register.  */
6032       if (GET_CODE (TREE_CST_RTL (exp)) == MEM
6033           && modifier != EXPAND_CONST_ADDRESS
6034           && modifier != EXPAND_INITIALIZER
6035           && modifier != EXPAND_SUM
6036           && (! memory_address_p (mode, XEXP (TREE_CST_RTL (exp), 0))
6037               || (flag_force_addr
6038                   && GET_CODE (XEXP (TREE_CST_RTL (exp), 0)) != REG)))
6039         return change_address (TREE_CST_RTL (exp), VOIDmode,
6040                                copy_rtx (XEXP (TREE_CST_RTL (exp), 0)));
6041       return TREE_CST_RTL (exp);
6042
6043     case EXPR_WITH_FILE_LOCATION:
6044       {
6045         rtx to_return;
6046         char *saved_input_filename = input_filename;
6047         int saved_lineno = lineno;
6048         input_filename = EXPR_WFL_FILENAME (exp);
6049         lineno = EXPR_WFL_LINENO (exp);
6050         if (EXPR_WFL_EMIT_LINE_NOTE (exp))
6051           emit_line_note (input_filename, lineno);
6052         /* Possibly avoid switching back and force here */
6053         to_return = expand_expr (EXPR_WFL_NODE (exp), target, tmode, modifier);
6054         input_filename = saved_input_filename;
6055         lineno = saved_lineno;
6056         return to_return;
6057       }
6058
6059     case SAVE_EXPR:
6060       context = decl_function_context (exp);
6061
6062       /* If this SAVE_EXPR was at global context, assume we are an
6063          initialization function and move it into our context.  */
6064       if (context == 0)
6065         SAVE_EXPR_CONTEXT (exp) = current_function_decl;
6066
6067       /* We treat inline_function_decl as an alias for the current function
6068          because that is the inline function whose vars, types, etc.
6069          are being merged into the current function.
6070          See expand_inline_function.  */
6071       if (context == current_function_decl || context == inline_function_decl)
6072         context = 0;
6073
6074       /* If this is non-local, handle it.  */
6075       if (context)
6076         {
6077           /* The following call just exists to abort if the context is
6078              not of a containing function.  */
6079           find_function_data (context);
6080
6081           temp = SAVE_EXPR_RTL (exp);
6082           if (temp && GET_CODE (temp) == REG)
6083             {
6084               put_var_into_stack (exp);
6085               temp = SAVE_EXPR_RTL (exp);
6086             }
6087           if (temp == 0 || GET_CODE (temp) != MEM)
6088             abort ();
6089           return change_address (temp, mode,
6090                                  fix_lexical_addr (XEXP (temp, 0), exp));
6091         }
6092       if (SAVE_EXPR_RTL (exp) == 0)
6093         {
6094           if (mode == VOIDmode)
6095             temp = const0_rtx;
6096           else
6097             temp = assign_temp (type, 3, 0, 0);
6098
6099           SAVE_EXPR_RTL (exp) = temp;
6100           if (!optimize && GET_CODE (temp) == REG)
6101             save_expr_regs = gen_rtx_EXPR_LIST (VOIDmode, temp,
6102                                                 save_expr_regs);
6103
6104           /* If the mode of TEMP does not match that of the expression, it
6105              must be a promoted value.  We pass store_expr a SUBREG of the
6106              wanted mode but mark it so that we know that it was already
6107              extended.  Note that `unsignedp' was modified above in
6108              this case.  */
6109
6110           if (GET_CODE (temp) == REG && GET_MODE (temp) != mode)
6111             {
6112               temp = gen_rtx_SUBREG (mode, SAVE_EXPR_RTL (exp), 0);
6113               SUBREG_PROMOTED_VAR_P (temp) = 1;
6114               SUBREG_PROMOTED_UNSIGNED_P (temp) = unsignedp;
6115             }
6116
6117           if (temp == const0_rtx)
6118             expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode,
6119                          EXPAND_MEMORY_USE_BAD);
6120           else
6121             store_expr (TREE_OPERAND (exp, 0), temp, 0);
6122
6123           TREE_USED (exp) = 1;
6124         }
6125
6126       /* If the mode of SAVE_EXPR_RTL does not match that of the expression, it
6127          must be a promoted value.  We return a SUBREG of the wanted mode,
6128          but mark it so that we know that it was already extended.  */
6129
6130       if (GET_CODE (SAVE_EXPR_RTL (exp)) == REG
6131           && GET_MODE (SAVE_EXPR_RTL (exp)) != mode)
6132         {
6133           /* Compute the signedness and make the proper SUBREG.  */
6134           promote_mode (type, mode, &unsignedp, 0);
6135           temp = gen_rtx_SUBREG (mode, SAVE_EXPR_RTL (exp), 0);
6136           SUBREG_PROMOTED_VAR_P (temp) = 1;
6137           SUBREG_PROMOTED_UNSIGNED_P (temp) = unsignedp;
6138           return temp;
6139         }
6140
6141       return SAVE_EXPR_RTL (exp);
6142
6143     case UNSAVE_EXPR:
6144       {
6145         rtx temp;
6146         temp = expand_expr (TREE_OPERAND (exp, 0), target, tmode, modifier);
6147         TREE_OPERAND (exp, 0) = unsave_expr_now (TREE_OPERAND (exp, 0));
6148         return temp;
6149       }
6150
6151     case PLACEHOLDER_EXPR:
6152       {
6153         tree placeholder_expr;
6154
6155         /* If there is an object on the head of the placeholder list,
6156            see if some object in it of type TYPE or a pointer to it.  For
6157            further information, see tree.def.  */
6158         for (placeholder_expr = placeholder_list;
6159              placeholder_expr != 0;
6160              placeholder_expr = TREE_CHAIN (placeholder_expr))
6161           {
6162             tree need_type = TYPE_MAIN_VARIANT (type);
6163             tree object = 0;
6164             tree old_list = placeholder_list;
6165             tree elt;
6166
6167             /* Find the outermost reference that is of the type we want.
6168                If none, see if any object has a type that is a pointer to
6169                the type we want.  */
6170             for (elt = TREE_PURPOSE (placeholder_expr);
6171                  elt != 0 && object == 0;
6172                  elt
6173                  = ((TREE_CODE (elt) == COMPOUND_EXPR
6174                      || TREE_CODE (elt) == COND_EXPR)
6175                     ? TREE_OPERAND (elt, 1)
6176                     : (TREE_CODE_CLASS (TREE_CODE (elt)) == 'r'
6177                        || TREE_CODE_CLASS (TREE_CODE (elt)) == '1'
6178                        || TREE_CODE_CLASS (TREE_CODE (elt)) == '2'
6179                        || TREE_CODE_CLASS (TREE_CODE (elt)) == 'e')
6180                     ? TREE_OPERAND (elt, 0) : 0))
6181               if (TYPE_MAIN_VARIANT (TREE_TYPE (elt)) == need_type)
6182                 object = elt;
6183
6184             for (elt = TREE_PURPOSE (placeholder_expr);
6185                  elt != 0 && object == 0;
6186                  elt
6187                  = ((TREE_CODE (elt) == COMPOUND_EXPR
6188                      || TREE_CODE (elt) == COND_EXPR)
6189                     ? TREE_OPERAND (elt, 1)
6190                     : (TREE_CODE_CLASS (TREE_CODE (elt)) == 'r'
6191                        || TREE_CODE_CLASS (TREE_CODE (elt)) == '1'
6192                        || TREE_CODE_CLASS (TREE_CODE (elt)) == '2'
6193                        || TREE_CODE_CLASS (TREE_CODE (elt)) == 'e')
6194                     ? TREE_OPERAND (elt, 0) : 0))
6195               if (POINTER_TYPE_P (TREE_TYPE (elt))
6196                   && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (elt)))
6197                       == need_type))
6198                 object = build1 (INDIRECT_REF, need_type, elt);
6199
6200             if (object != 0)
6201               {
6202                 /* Expand this object skipping the list entries before
6203                    it was found in case it is also a PLACEHOLDER_EXPR.
6204                    In that case, we want to translate it using subsequent
6205                    entries.  */
6206                 placeholder_list = TREE_CHAIN (placeholder_expr);
6207                 temp = expand_expr (object, original_target, tmode,
6208                                     ro_modifier);
6209                 placeholder_list = old_list;
6210                 return temp;
6211               }
6212           }
6213       }
6214
6215       /* We can't find the object or there was a missing WITH_RECORD_EXPR.  */
6216       abort ();
6217
6218     case WITH_RECORD_EXPR:
6219       /* Put the object on the placeholder list, expand our first operand,
6220          and pop the list.  */
6221       placeholder_list = tree_cons (TREE_OPERAND (exp, 1), NULL_TREE,
6222                                     placeholder_list);
6223       target = expand_expr (TREE_OPERAND (exp, 0), original_target,
6224                             tmode, ro_modifier);
6225       placeholder_list = TREE_CHAIN (placeholder_list);
6226       return target;
6227
6228     case GOTO_EXPR:
6229       if (TREE_CODE (TREE_OPERAND (exp, 0)) == LABEL_DECL)
6230         expand_goto (TREE_OPERAND (exp, 0));
6231       else
6232         expand_computed_goto (TREE_OPERAND (exp, 0));
6233       return const0_rtx;
6234
6235     case EXIT_EXPR:
6236       expand_exit_loop_if_false (NULL_PTR,
6237                                  invert_truthvalue (TREE_OPERAND (exp, 0)));
6238       return const0_rtx;
6239
6240     case LABELED_BLOCK_EXPR:
6241       if (LABELED_BLOCK_BODY (exp))
6242         expand_expr_stmt (LABELED_BLOCK_BODY (exp));
6243       emit_label (label_rtx (LABELED_BLOCK_LABEL (exp)));
6244       return const0_rtx;
6245
6246     case EXIT_BLOCK_EXPR:
6247       if (EXIT_BLOCK_RETURN (exp))
6248         sorry ("returned value in block_exit_expr");
6249       expand_goto (LABELED_BLOCK_LABEL (EXIT_BLOCK_LABELED_BLOCK (exp)));
6250       return const0_rtx;
6251
6252     case LOOP_EXPR:
6253       push_temp_slots ();
6254       expand_start_loop (1);
6255       expand_expr_stmt (TREE_OPERAND (exp, 0));
6256       expand_end_loop ();
6257       pop_temp_slots ();
6258
6259       return const0_rtx;
6260
6261     case BIND_EXPR:
6262       {
6263         tree vars = TREE_OPERAND (exp, 0);
6264         int vars_need_expansion = 0;
6265
6266         /* Need to open a binding contour here because
6267            if there are any cleanups they must be contained here.  */
6268         expand_start_bindings (2);
6269
6270         /* Mark the corresponding BLOCK for output in its proper place.  */
6271         if (TREE_OPERAND (exp, 2) != 0
6272             && ! TREE_USED (TREE_OPERAND (exp, 2)))
6273           insert_block (TREE_OPERAND (exp, 2));
6274
6275         /* If VARS have not yet been expanded, expand them now.  */
6276         while (vars)
6277           {
6278             if (DECL_RTL (vars) == 0)
6279               {
6280                 vars_need_expansion = 1;
6281                 expand_decl (vars);
6282               }
6283             expand_decl_init (vars);
6284             vars = TREE_CHAIN (vars);
6285           }
6286
6287         temp = expand_expr (TREE_OPERAND (exp, 1), target, tmode, ro_modifier);
6288
6289         expand_end_bindings (TREE_OPERAND (exp, 0), 0, 0);
6290
6291         return temp;
6292       }
6293
6294     case RTL_EXPR:
6295       if (RTL_EXPR_SEQUENCE (exp))
6296         {
6297           if (RTL_EXPR_SEQUENCE (exp) == const0_rtx)
6298             abort ();
6299           emit_insns (RTL_EXPR_SEQUENCE (exp));
6300           RTL_EXPR_SEQUENCE (exp) = const0_rtx;
6301         }
6302       preserve_rtl_expr_result (RTL_EXPR_RTL (exp));
6303       free_temps_for_rtl_expr (exp);
6304       return RTL_EXPR_RTL (exp);
6305
6306     case CONSTRUCTOR:
6307       /* If we don't need the result, just ensure we evaluate any
6308          subexpressions.  */
6309       if (ignore)
6310         {
6311           tree elt;
6312           for (elt = CONSTRUCTOR_ELTS (exp); elt; elt = TREE_CHAIN (elt))
6313             expand_expr (TREE_VALUE (elt), const0_rtx, VOIDmode,
6314                          EXPAND_MEMORY_USE_BAD);
6315           return const0_rtx;
6316         }
6317
6318       /* All elts simple constants => refer to a constant in memory.  But
6319          if this is a non-BLKmode mode, let it store a field at a time
6320          since that should make a CONST_INT or CONST_DOUBLE when we
6321          fold.  Likewise, if we have a target we can use, it is best to
6322          store directly into the target unless the type is large enough
6323          that memcpy will be used.  If we are making an initializer and
6324          all operands are constant, put it in memory as well.  */
6325       else if ((TREE_STATIC (exp)
6326                 && ((mode == BLKmode
6327                      && ! (target != 0 && safe_from_p (target, exp, 1)))
6328                     || TREE_ADDRESSABLE (exp)
6329                     || (host_integerp (TYPE_SIZE_UNIT (type), 1)
6330                         && (! MOVE_BY_PIECES_P
6331                             (tree_low_cst (TYPE_SIZE_UNIT (type), 1),
6332                              TYPE_ALIGN (type)))
6333                         && ! mostly_zeros_p (exp))))
6334                || (modifier == EXPAND_INITIALIZER && TREE_CONSTANT (exp)))
6335         {
6336           rtx constructor = output_constant_def (exp);
6337
6338           if (modifier != EXPAND_CONST_ADDRESS
6339               && modifier != EXPAND_INITIALIZER
6340               && modifier != EXPAND_SUM
6341               && (! memory_address_p (GET_MODE (constructor),
6342                                       XEXP (constructor, 0))
6343                   || (flag_force_addr
6344                       && GET_CODE (XEXP (constructor, 0)) != REG)))
6345             constructor = change_address (constructor, VOIDmode,
6346                                           XEXP (constructor, 0));
6347           return constructor;
6348         }
6349
6350       else
6351         {
6352           /* Handle calls that pass values in multiple non-contiguous
6353              locations.  The Irix 6 ABI has examples of this.  */
6354           if (target == 0 || ! safe_from_p (target, exp, 1)
6355               || GET_CODE (target) == PARALLEL)
6356             {
6357               if (mode != BLKmode && ! TREE_ADDRESSABLE (exp))
6358                 target = gen_reg_rtx (tmode != VOIDmode ? tmode : mode);
6359               else
6360                 target = assign_temp (type, 0, 1, 1);
6361             }
6362
6363           if (TREE_READONLY (exp))
6364             {
6365               if (GET_CODE (target) == MEM)
6366                 target = copy_rtx (target);
6367
6368               RTX_UNCHANGING_P (target) = 1;
6369             }
6370
6371           store_constructor (exp, target, TYPE_ALIGN (TREE_TYPE (exp)), 0,
6372                              int_size_in_bytes (TREE_TYPE (exp)));
6373           return target;
6374         }
6375
6376     case INDIRECT_REF:
6377       {
6378         tree exp1 = TREE_OPERAND (exp, 0);
6379         tree exp2;
6380         tree index;
6381         tree string = string_constant (exp1, &index);
6382
6383         /* Try to optimize reads from const strings.  */
6384         if (string
6385             && TREE_CODE (string) == STRING_CST
6386             && TREE_CODE (index) == INTEGER_CST
6387             && compare_tree_int (index, TREE_STRING_LENGTH (string)) < 0
6388             && GET_MODE_CLASS (mode) == MODE_INT
6389             && GET_MODE_SIZE (mode) == 1
6390             && modifier != EXPAND_MEMORY_USE_WO)
6391           return
6392             GEN_INT (TREE_STRING_POINTER (string)[TREE_INT_CST_LOW (index)]);
6393
6394         op0 = expand_expr (exp1, NULL_RTX, VOIDmode, EXPAND_SUM);
6395         op0 = memory_address (mode, op0);
6396
6397         if (cfun && current_function_check_memory_usage
6398             && ! AGGREGATE_TYPE_P (TREE_TYPE (exp)))
6399           {
6400             enum memory_use_mode memory_usage;
6401             memory_usage = get_memory_usage_from_modifier (modifier);
6402
6403             if (memory_usage != MEMORY_USE_DONT)
6404               {
6405                 in_check_memory_usage = 1;
6406                 emit_library_call (chkr_check_addr_libfunc, 1, VOIDmode, 3,
6407                                    op0, Pmode,
6408                                    GEN_INT (int_size_in_bytes (type)),
6409                                    TYPE_MODE (sizetype),
6410                                    GEN_INT (memory_usage),
6411                                    TYPE_MODE (integer_type_node));
6412                 in_check_memory_usage = 0;
6413               }
6414           }
6415
6416         temp = gen_rtx_MEM (mode, op0);
6417         /* If address was computed by addition,
6418            mark this as an element of an aggregate.  */
6419         if (TREE_CODE (exp1) == PLUS_EXPR
6420             || (TREE_CODE (exp1) == SAVE_EXPR
6421                 && TREE_CODE (TREE_OPERAND (exp1, 0)) == PLUS_EXPR)
6422             || AGGREGATE_TYPE_P (TREE_TYPE (exp))
6423             || (TREE_CODE (exp1) == ADDR_EXPR
6424                 && (exp2 = TREE_OPERAND (exp1, 0))
6425                 && AGGREGATE_TYPE_P (TREE_TYPE (exp2))))
6426           MEM_SET_IN_STRUCT_P (temp, 1);
6427
6428         MEM_VOLATILE_P (temp) = TREE_THIS_VOLATILE (exp) | flag_volatile;
6429         MEM_ALIAS_SET (temp) = get_alias_set (exp);
6430
6431         /* It is incorrect to set RTX_UNCHANGING_P from TREE_READONLY
6432            here, because, in C and C++, the fact that a location is accessed
6433            through a pointer to const does not mean that the value there can
6434            never change.  Languages where it can never change should
6435            also set TREE_STATIC.  */
6436         RTX_UNCHANGING_P (temp) = TREE_READONLY (exp) & TREE_STATIC (exp);
6437
6438         /* If we are writing to this object and its type is a record with
6439            readonly fields, we must mark it as readonly so it will
6440            conflict with readonly references to those fields.  */
6441         if (modifier == EXPAND_MEMORY_USE_WO
6442             && TREE_CODE (type) == RECORD_TYPE && readonly_fields_p (type))
6443           RTX_UNCHANGING_P (temp) = 1;
6444
6445         return temp;
6446       }
6447
6448     case ARRAY_REF:
6449       if (TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) != ARRAY_TYPE)
6450         abort ();
6451
6452       {
6453         tree array = TREE_OPERAND (exp, 0);
6454         tree domain = TYPE_DOMAIN (TREE_TYPE (array));
6455         tree low_bound = domain ? TYPE_MIN_VALUE (domain) : integer_zero_node;
6456         tree index = convert (sizetype, TREE_OPERAND (exp, 1));
6457         HOST_WIDE_INT i;
6458
6459         /* Optimize the special-case of a zero lower bound.
6460
6461            We convert the low_bound to sizetype to avoid some problems
6462            with constant folding.  (E.g. suppose the lower bound is 1,
6463            and its mode is QI.  Without the conversion,  (ARRAY
6464            +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
6465            +INDEX), which becomes (ARRAY+255+INDEX).  Oops!)  */
6466
6467         if (! integer_zerop (low_bound))
6468           index = size_diffop (index, convert (sizetype, low_bound));
6469
6470         /* Fold an expression like: "foo"[2].
6471            This is not done in fold so it won't happen inside &.
6472            Don't fold if this is for wide characters since it's too
6473            difficult to do correctly and this is a very rare case.  */
6474
6475         if (TREE_CODE (array) == STRING_CST
6476             && TREE_CODE (index) == INTEGER_CST
6477             && compare_tree_int (index, TREE_STRING_LENGTH (array)) < 0
6478             && GET_MODE_CLASS (mode) == MODE_INT
6479             && GET_MODE_SIZE (mode) == 1)
6480           return
6481             GEN_INT (TREE_STRING_POINTER (array)[TREE_INT_CST_LOW (index)]);
6482
6483         /* If this is a constant index into a constant array,
6484            just get the value from the array.  Handle both the cases when
6485            we have an explicit constructor and when our operand is a variable
6486            that was declared const.  */
6487
6488         if (TREE_CODE (array) == CONSTRUCTOR && ! TREE_SIDE_EFFECTS (array)
6489             && TREE_CODE (index) == INTEGER_CST
6490             && 0 > compare_tree_int (index,
6491                                      list_length (CONSTRUCTOR_ELTS
6492                                                   (TREE_OPERAND (exp, 0)))))
6493           {
6494             tree elem;
6495
6496             for (elem = CONSTRUCTOR_ELTS (TREE_OPERAND (exp, 0)),
6497                  i = TREE_INT_CST_LOW (index);
6498                  elem != 0 && i != 0; i--, elem = TREE_CHAIN (elem))
6499               ;
6500
6501             if (elem)
6502               return expand_expr (fold (TREE_VALUE (elem)), target,
6503                                   tmode, ro_modifier);
6504           }
6505
6506         else if (optimize >= 1
6507                  && TREE_READONLY (array) && ! TREE_SIDE_EFFECTS (array)
6508                  && TREE_CODE (array) == VAR_DECL && DECL_INITIAL (array)
6509                  && TREE_CODE (DECL_INITIAL (array)) != ERROR_MARK)
6510           {
6511             if (TREE_CODE (index) == INTEGER_CST)
6512               {
6513                 tree init = DECL_INITIAL (array);
6514
6515                 if (TREE_CODE (init) == CONSTRUCTOR)
6516                   {
6517                     tree elem;
6518
6519                     for (elem = CONSTRUCTOR_ELTS (init);
6520                          (elem
6521                           && !tree_int_cst_equal (TREE_PURPOSE (elem), index));
6522                          elem = TREE_CHAIN (elem))
6523                       ;
6524
6525                     if (elem)
6526                       return expand_expr (fold (TREE_VALUE (elem)), target,
6527                                           tmode, ro_modifier);
6528                   }
6529                 else if (TREE_CODE (init) == STRING_CST
6530                          && 0 > compare_tree_int (index,
6531                                                   TREE_STRING_LENGTH (init)))
6532                   return (GEN_INT
6533                           (TREE_STRING_POINTER
6534                            (init)[TREE_INT_CST_LOW (index)]));
6535               }
6536           }
6537       }
6538
6539       /* ... fall through ... */
6540
6541     case COMPONENT_REF:
6542     case BIT_FIELD_REF:
6543       /* If the operand is a CONSTRUCTOR, we can just extract the
6544          appropriate field if it is present.  Don't do this if we have
6545          already written the data since we want to refer to that copy
6546          and varasm.c assumes that's what we'll do.  */
6547       if (code != ARRAY_REF
6548           && TREE_CODE (TREE_OPERAND (exp, 0)) == CONSTRUCTOR
6549           && TREE_CST_RTL (TREE_OPERAND (exp, 0)) == 0)
6550         {
6551           tree elt;
6552
6553           for (elt = CONSTRUCTOR_ELTS (TREE_OPERAND (exp, 0)); elt;
6554                elt = TREE_CHAIN (elt))
6555             if (TREE_PURPOSE (elt) == TREE_OPERAND (exp, 1)
6556                 /* We can normally use the value of the field in the
6557                    CONSTRUCTOR.  However, if this is a bitfield in
6558                    an integral mode that we can fit in a HOST_WIDE_INT,
6559                    we must mask only the number of bits in the bitfield,
6560                    since this is done implicitly by the constructor.  If
6561                    the bitfield does not meet either of those conditions,
6562                    we can't do this optimization.  */
6563                 && (! DECL_BIT_FIELD (TREE_PURPOSE (elt))
6564                     || ((GET_MODE_CLASS (DECL_MODE (TREE_PURPOSE (elt)))
6565                          == MODE_INT)
6566                         && (GET_MODE_BITSIZE (DECL_MODE (TREE_PURPOSE (elt)))
6567                             <= HOST_BITS_PER_WIDE_INT))))
6568               {
6569                 op0 =  expand_expr (TREE_VALUE (elt), target, tmode, modifier);
6570                 if (DECL_BIT_FIELD (TREE_PURPOSE (elt)))
6571                   {
6572                     HOST_WIDE_INT bitsize
6573                       = TREE_INT_CST_LOW (DECL_SIZE (TREE_PURPOSE (elt)));
6574
6575                     if (TREE_UNSIGNED (TREE_TYPE (TREE_PURPOSE (elt))))
6576                       {
6577                         op1 = GEN_INT (((HOST_WIDE_INT) 1 << bitsize) - 1);
6578                         op0 = expand_and (op0, op1, target);
6579                       }
6580                     else
6581                       {
6582                         enum machine_mode imode
6583                           = TYPE_MODE (TREE_TYPE (TREE_PURPOSE (elt)));
6584                         tree count
6585                           = build_int_2 (GET_MODE_BITSIZE (imode) - bitsize,
6586                                          0);
6587
6588                         op0 = expand_shift (LSHIFT_EXPR, imode, op0, count,
6589                                             target, 0);
6590                         op0 = expand_shift (RSHIFT_EXPR, imode, op0, count,
6591                                             target, 0);
6592                       }
6593                   }
6594
6595                 return op0;
6596               }
6597         }
6598
6599       {
6600         enum machine_mode mode1;
6601         HOST_WIDE_INT bitsize, bitpos;
6602         tree offset;
6603         int volatilep = 0;
6604         unsigned int alignment;
6605         tree tem = get_inner_reference (exp, &bitsize, &bitpos, &offset,
6606                                         &mode1, &unsignedp, &volatilep,
6607                                         &alignment);
6608
6609         /* If we got back the original object, something is wrong.  Perhaps
6610            we are evaluating an expression too early.  In any event, don't
6611            infinitely recurse.  */
6612         if (tem == exp)
6613           abort ();
6614
6615         /* If TEM's type is a union of variable size, pass TARGET to the inner
6616            computation, since it will need a temporary and TARGET is known
6617            to have to do.  This occurs in unchecked conversion in Ada.  */
6618
6619         op0 = expand_expr (tem,
6620                            (TREE_CODE (TREE_TYPE (tem)) == UNION_TYPE
6621                             && (TREE_CODE (TYPE_SIZE (TREE_TYPE (tem)))
6622                                 != INTEGER_CST)
6623                             ? target : NULL_RTX),
6624                            VOIDmode,
6625                            (modifier == EXPAND_INITIALIZER
6626                             || modifier == EXPAND_CONST_ADDRESS)
6627                            ? modifier : EXPAND_NORMAL);
6628
6629         /* If this is a constant, put it into a register if it is a
6630            legitimate constant and OFFSET is 0 and memory if it isn't.  */
6631         if (CONSTANT_P (op0))
6632           {
6633             enum machine_mode mode = TYPE_MODE (TREE_TYPE (tem));
6634             if (mode != BLKmode && LEGITIMATE_CONSTANT_P (op0)
6635                 && offset == 0)
6636               op0 = force_reg (mode, op0);
6637             else
6638               op0 = validize_mem (force_const_mem (mode, op0));
6639           }
6640
6641         if (offset != 0)
6642           {
6643             rtx offset_rtx = expand_expr (offset, NULL_RTX, VOIDmode, 0);
6644
6645             /* If this object is in memory, put it into a register.
6646                This case can't occur in C, but can in Ada if we have
6647                unchecked conversion of an expression from a scalar type to
6648                an array or record type.  */
6649             if (GET_CODE (op0) == REG || GET_CODE (op0) == SUBREG
6650                 || GET_CODE (op0) == CONCAT || GET_CODE (op0) == ADDRESSOF)
6651               {
6652                 rtx memloc = assign_temp (TREE_TYPE (tem), 1, 1, 1);
6653
6654                 mark_temp_addr_taken (memloc);
6655                 emit_move_insn (memloc, op0);
6656                 op0 = memloc;
6657               }
6658
6659             if (GET_CODE (op0) != MEM)
6660               abort ();
6661
6662             if (GET_MODE (offset_rtx) != ptr_mode)
6663               {
6664 #ifdef POINTERS_EXTEND_UNSIGNED
6665                 offset_rtx = convert_memory_address (ptr_mode, offset_rtx);
6666 #else
6667                 offset_rtx = convert_to_mode (ptr_mode, offset_rtx, 0);
6668 #endif
6669               }
6670
6671             /* A constant address in OP0 can have VOIDmode, we must not try
6672                to call force_reg for that case.  Avoid that case.  */
6673             if (GET_CODE (op0) == MEM
6674                 && GET_MODE (op0) == BLKmode
6675                 && GET_MODE (XEXP (op0, 0)) != VOIDmode
6676                 && bitsize != 0
6677                 && (bitpos % bitsize) == 0
6678                 && (bitsize % GET_MODE_ALIGNMENT (mode1)) == 0
6679                 && alignment == GET_MODE_ALIGNMENT (mode1))
6680               {
6681                 rtx temp = change_address (op0, mode1,
6682                                            plus_constant (XEXP (op0, 0),
6683                                                           (bitpos /
6684                                                            BITS_PER_UNIT)));
6685                 if (GET_CODE (XEXP (temp, 0)) == REG)
6686                   op0 = temp;
6687                 else
6688                   op0 = change_address (op0, mode1,
6689                                         force_reg (GET_MODE (XEXP (temp, 0)),
6690                                                    XEXP (temp, 0)));
6691                 bitpos = 0;
6692               }
6693
6694
6695             op0 = change_address (op0, VOIDmode,
6696                                   gen_rtx_PLUS (ptr_mode, XEXP (op0, 0),
6697                                                 force_reg (ptr_mode,
6698                                                            offset_rtx)));
6699           }
6700
6701         /* Don't forget about volatility even if this is a bitfield.  */
6702         if (GET_CODE (op0) == MEM && volatilep && ! MEM_VOLATILE_P (op0))
6703           {
6704             op0 = copy_rtx (op0);
6705             MEM_VOLATILE_P (op0) = 1;
6706           }
6707
6708         /* Check the access.  */
6709         if (current_function_check_memory_usage && GET_CODE (op0) == MEM)
6710           {
6711             enum memory_use_mode memory_usage;
6712             memory_usage = get_memory_usage_from_modifier (modifier);
6713
6714             if (memory_usage != MEMORY_USE_DONT)
6715               {
6716                 rtx to;
6717                 int size;
6718
6719                 to = plus_constant (XEXP (op0, 0), (bitpos / BITS_PER_UNIT));
6720                 size = (bitpos % BITS_PER_UNIT) + bitsize + BITS_PER_UNIT - 1;
6721
6722                 /* Check the access right of the pointer.  */
6723                 if (size > BITS_PER_UNIT)
6724                   emit_library_call (chkr_check_addr_libfunc, 1, VOIDmode, 3,
6725                                      to, Pmode,
6726                                      GEN_INT (size / BITS_PER_UNIT),
6727                                      TYPE_MODE (sizetype),
6728                                      GEN_INT (memory_usage),
6729                                      TYPE_MODE (integer_type_node));
6730               }
6731           }
6732
6733         /* In cases where an aligned union has an unaligned object
6734            as a field, we might be extracting a BLKmode value from
6735            an integer-mode (e.g., SImode) object.  Handle this case
6736            by doing the extract into an object as wide as the field
6737            (which we know to be the width of a basic mode), then
6738            storing into memory, and changing the mode to BLKmode.
6739            If we ultimately want the address (EXPAND_CONST_ADDRESS or
6740            EXPAND_INITIALIZER), then we must not copy to a temporary.  */
6741         if (mode1 == VOIDmode
6742             || GET_CODE (op0) == REG || GET_CODE (op0) == SUBREG
6743             || (modifier != EXPAND_CONST_ADDRESS
6744                 && modifier != EXPAND_INITIALIZER
6745                 && ((mode1 != BLKmode && ! direct_load[(int) mode1]
6746                      && GET_MODE_CLASS (mode) != MODE_COMPLEX_INT
6747                      && GET_MODE_CLASS (mode) != MODE_COMPLEX_FLOAT)
6748                     /* If the field isn't aligned enough to fetch as a memref,
6749                        fetch it as a bit field.  */
6750                     || (mode1 != BLKmode
6751                         && SLOW_UNALIGNED_ACCESS (mode1, alignment)
6752                         && ((TYPE_ALIGN (TREE_TYPE (tem))
6753                              < GET_MODE_ALIGNMENT (mode))
6754                             || (bitpos % GET_MODE_ALIGNMENT (mode) != 0)))
6755                     /* If the type and the field are a constant size and the
6756                        size of the type isn't the same size as the bitfield,
6757                        we must use bitfield operations.  */
6758                     || ((bitsize >= 0
6759                          && (TREE_CODE (TYPE_SIZE (TREE_TYPE (exp)))
6760                              == INTEGER_CST)
6761                          && 0 != compare_tree_int (TYPE_SIZE (TREE_TYPE (exp)),
6762                                                    bitsize)))))
6763             || (modifier != EXPAND_CONST_ADDRESS
6764                 && modifier != EXPAND_INITIALIZER
6765                 && mode == BLKmode
6766                 && SLOW_UNALIGNED_ACCESS (mode, alignment)
6767                 && (TYPE_ALIGN (type) > alignment
6768                     || bitpos % TYPE_ALIGN (type) != 0)))
6769           {
6770             enum machine_mode ext_mode = mode;
6771
6772             if (ext_mode == BLKmode
6773                 && ! (target != 0 && GET_CODE (op0) == MEM
6774                       && GET_CODE (target) == MEM
6775                       && bitpos % BITS_PER_UNIT == 0))
6776               ext_mode = mode_for_size (bitsize, MODE_INT, 1);
6777
6778             if (ext_mode == BLKmode)
6779               {
6780                 /* In this case, BITPOS must start at a byte boundary and
6781                    TARGET, if specified, must be a MEM.  */
6782                 if (GET_CODE (op0) != MEM
6783                     || (target != 0 && GET_CODE (target) != MEM)
6784                     || bitpos % BITS_PER_UNIT != 0)
6785                   abort ();
6786
6787                 op0 = change_address (op0, VOIDmode,
6788                                       plus_constant (XEXP (op0, 0),
6789                                                      bitpos / BITS_PER_UNIT));
6790                 if (target == 0)
6791                   target = assign_temp (type, 0, 1, 1);
6792
6793                 emit_block_move (target, op0,
6794                                  GEN_INT ((bitsize + BITS_PER_UNIT - 1)
6795                                           / BITS_PER_UNIT),
6796                                  BITS_PER_UNIT);
6797
6798                 return target;
6799               }
6800
6801             op0 = validize_mem (op0);
6802
6803             if (GET_CODE (op0) == MEM && GET_CODE (XEXP (op0, 0)) == REG)
6804               mark_reg_pointer (XEXP (op0, 0), alignment / BITS_PER_UNIT);
6805
6806             op0 = extract_bit_field (op0, bitsize, bitpos,
6807                                      unsignedp, target, ext_mode, ext_mode,
6808                                      alignment,
6809                                      int_size_in_bytes (TREE_TYPE (tem)));
6810
6811             /* If the result is a record type and BITSIZE is narrower than
6812                the mode of OP0, an integral mode, and this is a big endian
6813                machine, we must put the field into the high-order bits.  */
6814             if (TREE_CODE (type) == RECORD_TYPE && BYTES_BIG_ENDIAN
6815                 && GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT
6816                 && bitsize < GET_MODE_BITSIZE (GET_MODE (op0)))
6817               op0 = expand_shift (LSHIFT_EXPR, GET_MODE (op0), op0,
6818                                   size_int (GET_MODE_BITSIZE (GET_MODE (op0))
6819                                             - bitsize),
6820                                   op0, 1);
6821
6822             if (mode == BLKmode)
6823               {
6824                 rtx new = assign_stack_temp (ext_mode,
6825                                              bitsize / BITS_PER_UNIT, 0);
6826
6827                 emit_move_insn (new, op0);
6828                 op0 = copy_rtx (new);
6829                 PUT_MODE (op0, BLKmode);
6830                 MEM_SET_IN_STRUCT_P (op0, 1);
6831               }
6832
6833             return op0;
6834           }
6835
6836         /* If the result is BLKmode, use that to access the object
6837            now as well.  */
6838         if (mode == BLKmode)
6839           mode1 = BLKmode;
6840
6841         /* Get a reference to just this component.  */
6842         if (modifier == EXPAND_CONST_ADDRESS
6843             || modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER)
6844           op0 = gen_rtx_MEM (mode1, plus_constant (XEXP (op0, 0),
6845                                                    (bitpos / BITS_PER_UNIT)));
6846         else
6847           op0 = change_address (op0, mode1,
6848                                 plus_constant (XEXP (op0, 0),
6849                                                (bitpos / BITS_PER_UNIT)));
6850
6851         if (GET_CODE (op0) == MEM)
6852           MEM_ALIAS_SET (op0) = get_alias_set (exp);
6853
6854         if (GET_CODE (XEXP (op0, 0)) == REG)
6855           mark_reg_pointer (XEXP (op0, 0), alignment / BITS_PER_UNIT);
6856
6857         MEM_SET_IN_STRUCT_P (op0, 1);
6858         MEM_VOLATILE_P (op0) |= volatilep;
6859         if (mode == mode1 || mode1 == BLKmode || mode1 == tmode
6860             || modifier == EXPAND_CONST_ADDRESS
6861             || modifier == EXPAND_INITIALIZER)
6862           return op0;
6863         else if (target == 0)
6864           target = gen_reg_rtx (tmode != VOIDmode ? tmode : mode);
6865
6866         convert_move (target, op0, unsignedp);
6867         return target;
6868       }
6869
6870       /* Intended for a reference to a buffer of a file-object in Pascal.
6871          But it's not certain that a special tree code will really be
6872          necessary for these.  INDIRECT_REF might work for them.  */
6873     case BUFFER_REF:
6874       abort ();
6875
6876     case IN_EXPR:
6877       {
6878         /* Pascal set IN expression.
6879
6880            Algorithm:
6881                rlo       = set_low - (set_low%bits_per_word);
6882                the_word  = set [ (index - rlo)/bits_per_word ];
6883                bit_index = index % bits_per_word;
6884                bitmask   = 1 << bit_index;
6885                return !!(the_word & bitmask);  */
6886
6887         tree set = TREE_OPERAND (exp, 0);
6888         tree index = TREE_OPERAND (exp, 1);
6889         int iunsignedp = TREE_UNSIGNED (TREE_TYPE (index));
6890         tree set_type = TREE_TYPE (set);
6891         tree set_low_bound = TYPE_MIN_VALUE (TYPE_DOMAIN (set_type));
6892         tree set_high_bound = TYPE_MAX_VALUE (TYPE_DOMAIN (set_type));
6893         rtx index_val = expand_expr (index, 0, VOIDmode, 0);
6894         rtx lo_r = expand_expr (set_low_bound, 0, VOIDmode, 0);
6895         rtx hi_r = expand_expr (set_high_bound, 0, VOIDmode, 0);
6896         rtx setval = expand_expr (set, 0, VOIDmode, 0);
6897         rtx setaddr = XEXP (setval, 0);
6898         enum machine_mode index_mode = TYPE_MODE (TREE_TYPE (index));
6899         rtx rlow;
6900         rtx diff, quo, rem, addr, bit, result;
6901
6902         preexpand_calls (exp);
6903
6904         /* If domain is empty, answer is no.  Likewise if index is constant
6905            and out of bounds.  */
6906         if (((TREE_CODE (set_high_bound) == INTEGER_CST
6907              && TREE_CODE (set_low_bound) == INTEGER_CST
6908              && tree_int_cst_lt (set_high_bound, set_low_bound))
6909              || (TREE_CODE (index) == INTEGER_CST
6910                  && TREE_CODE (set_low_bound) == INTEGER_CST
6911                  && tree_int_cst_lt (index, set_low_bound))
6912              || (TREE_CODE (set_high_bound) == INTEGER_CST
6913                  && TREE_CODE (index) == INTEGER_CST
6914                  && tree_int_cst_lt (set_high_bound, index))))
6915           return const0_rtx;
6916
6917         if (target == 0)
6918           target = gen_reg_rtx (tmode != VOIDmode ? tmode : mode);
6919
6920         /* If we get here, we have to generate the code for both cases
6921            (in range and out of range).  */
6922
6923         op0 = gen_label_rtx ();
6924         op1 = gen_label_rtx ();
6925
6926         if (! (GET_CODE (index_val) == CONST_INT
6927                && GET_CODE (lo_r) == CONST_INT))
6928           {
6929             emit_cmp_and_jump_insns (index_val, lo_r, LT, NULL_RTX,
6930                                      GET_MODE (index_val), iunsignedp, 0, op1);
6931           }
6932
6933         if (! (GET_CODE (index_val) == CONST_INT
6934                && GET_CODE (hi_r) == CONST_INT))
6935           {
6936             emit_cmp_and_jump_insns (index_val, hi_r, GT, NULL_RTX,
6937                                      GET_MODE (index_val), iunsignedp, 0, op1);
6938           }
6939
6940         /* Calculate the element number of bit zero in the first word
6941            of the set.  */
6942         if (GET_CODE (lo_r) == CONST_INT)
6943           rlow = GEN_INT (INTVAL (lo_r)
6944                           & ~ ((HOST_WIDE_INT) 1 << BITS_PER_UNIT));
6945         else
6946           rlow = expand_binop (index_mode, and_optab, lo_r,
6947                                GEN_INT (~((HOST_WIDE_INT) 1 << BITS_PER_UNIT)),
6948                                NULL_RTX, iunsignedp, OPTAB_LIB_WIDEN);
6949
6950         diff = expand_binop (index_mode, sub_optab, index_val, rlow,
6951                              NULL_RTX, iunsignedp, OPTAB_LIB_WIDEN);
6952
6953         quo = expand_divmod (0, TRUNC_DIV_EXPR, index_mode, diff,
6954                              GEN_INT (BITS_PER_UNIT), NULL_RTX, iunsignedp);
6955         rem = expand_divmod (1, TRUNC_MOD_EXPR, index_mode, index_val,
6956                              GEN_INT (BITS_PER_UNIT), NULL_RTX, iunsignedp);
6957
6958         addr = memory_address (byte_mode,
6959                                expand_binop (index_mode, add_optab, diff,
6960                                              setaddr, NULL_RTX, iunsignedp,
6961                                              OPTAB_LIB_WIDEN));
6962
6963         /* Extract the bit we want to examine */
6964         bit = expand_shift (RSHIFT_EXPR, byte_mode,
6965                             gen_rtx_MEM (byte_mode, addr),
6966                             make_tree (TREE_TYPE (index), rem),
6967                             NULL_RTX, 1);
6968         result = expand_binop (byte_mode, and_optab, bit, const1_rtx,
6969                                GET_MODE (target) == byte_mode ? target : 0,
6970                                1, OPTAB_LIB_WIDEN);
6971
6972         if (result != target)
6973           convert_move (target, result, 1);
6974
6975         /* Output the code to handle the out-of-range case.  */
6976         emit_jump (op0);
6977         emit_label (op1);
6978         emit_move_insn (target, const0_rtx);
6979         emit_label (op0);
6980         return target;
6981       }
6982
6983     case WITH_CLEANUP_EXPR:
6984       if (RTL_EXPR_RTL (exp) == 0)
6985         {
6986           RTL_EXPR_RTL (exp)
6987             = expand_expr (TREE_OPERAND (exp, 0), target, tmode, ro_modifier);
6988           expand_decl_cleanup (NULL_TREE, TREE_OPERAND (exp, 2));
6989
6990           /* That's it for this cleanup.  */
6991           TREE_OPERAND (exp, 2) = 0;
6992         }
6993       return RTL_EXPR_RTL (exp);
6994
6995     case CLEANUP_POINT_EXPR:
6996       {
6997         /* Start a new binding layer that will keep track of all cleanup
6998            actions to be performed.  */
6999         expand_start_bindings (2);
7000
7001         target_temp_slot_level = temp_slot_level;
7002
7003         op0 = expand_expr (TREE_OPERAND (exp, 0), target, tmode, ro_modifier);
7004         /* If we're going to use this value, load it up now.  */
7005         if (! ignore)
7006           op0 = force_not_mem (op0);
7007         preserve_temp_slots (op0);
7008         expand_end_bindings (NULL_TREE, 0, 0);
7009       }
7010       return op0;
7011
7012     case CALL_EXPR:
7013       /* Check for a built-in function.  */
7014       if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
7015           && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
7016               == FUNCTION_DECL)
7017           && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
7018         return expand_builtin (exp, target, subtarget, tmode, ignore);
7019
7020       /* If this call was expanded already by preexpand_calls,
7021          just return the result we got.  */
7022       if (CALL_EXPR_RTL (exp) != 0)
7023         return CALL_EXPR_RTL (exp);
7024
7025       return expand_call (exp, target, ignore);
7026
7027     case NON_LVALUE_EXPR:
7028     case NOP_EXPR:
7029     case CONVERT_EXPR:
7030     case REFERENCE_EXPR:
7031       if (TREE_CODE (type) == UNION_TYPE)
7032         {
7033           tree valtype = TREE_TYPE (TREE_OPERAND (exp, 0));
7034
7035           /* If both input and output are BLKmode, this conversion
7036              isn't actually doing anything unless we need to make the
7037              alignment stricter.  */
7038           if (mode == BLKmode && TYPE_MODE (valtype) == BLKmode
7039               && (TYPE_ALIGN (type) <= TYPE_ALIGN (valtype)
7040                   || TYPE_ALIGN (type) >= BIGGEST_ALIGNMENT))
7041             return expand_expr (TREE_OPERAND (exp, 0), target, tmode,
7042                                 modifier);
7043
7044           if (target == 0)
7045             {
7046               if (mode != BLKmode)
7047                 target = gen_reg_rtx (tmode != VOIDmode ? tmode : mode);
7048               else
7049                 target = assign_temp (type, 0, 1, 1);
7050             }
7051
7052           if (GET_CODE (target) == MEM)
7053             /* Store data into beginning of memory target.  */
7054             store_expr (TREE_OPERAND (exp, 0),
7055                         change_address (target, TYPE_MODE (valtype), 0), 0);
7056
7057           else if (GET_CODE (target) == REG)
7058             /* Store this field into a union of the proper type.  */
7059             store_field (target,
7060                          MIN ((int_size_in_bytes (TREE_TYPE
7061                                                   (TREE_OPERAND (exp, 0)))
7062                                * BITS_PER_UNIT),
7063                               GET_MODE_BITSIZE (mode)),
7064                          0, TYPE_MODE (valtype), TREE_OPERAND (exp, 0),
7065                          VOIDmode, 0, 1, int_size_in_bytes (type), 0);
7066           else
7067             abort ();
7068
7069           /* Return the entire union.  */
7070           return target;
7071         }
7072
7073       if (mode == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))))
7074         {
7075           op0 = expand_expr (TREE_OPERAND (exp, 0), target, VOIDmode,
7076                              ro_modifier);
7077
7078           /* If the signedness of the conversion differs and OP0 is
7079              a promoted SUBREG, clear that indication since we now
7080              have to do the proper extension.  */
7081           if (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))) != unsignedp
7082               && GET_CODE (op0) == SUBREG)
7083             SUBREG_PROMOTED_VAR_P (op0) = 0;
7084
7085           return op0;
7086         }
7087
7088       op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, mode, 0);
7089       if (GET_MODE (op0) == mode)
7090         return op0;
7091
7092       /* If OP0 is a constant, just convert it into the proper mode.  */
7093       if (CONSTANT_P (op0))
7094         return
7095           convert_modes (mode, TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))),
7096                          op0, TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))));
7097
7098       if (modifier == EXPAND_INITIALIZER)
7099         return gen_rtx_fmt_e (unsignedp ? ZERO_EXTEND : SIGN_EXTEND, mode, op0);
7100
7101       if (target == 0)
7102         return
7103           convert_to_mode (mode, op0,
7104                            TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))));
7105       else
7106         convert_move (target, op0,
7107                       TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))));
7108       return target;
7109
7110     case PLUS_EXPR:
7111       /* We come here from MINUS_EXPR when the second operand is a
7112          constant.  */
7113     plus_expr:
7114       this_optab = add_optab;
7115
7116       /* If we are adding a constant, an RTL_EXPR that is sp, fp, or ap, and
7117          something else, make sure we add the register to the constant and
7118          then to the other thing.  This case can occur during strength
7119          reduction and doing it this way will produce better code if the
7120          frame pointer or argument pointer is eliminated.
7121
7122          fold-const.c will ensure that the constant is always in the inner
7123          PLUS_EXPR, so the only case we need to do anything about is if
7124          sp, ap, or fp is our second argument, in which case we must swap
7125          the innermost first argument and our second argument.  */
7126
7127       if (TREE_CODE (TREE_OPERAND (exp, 0)) == PLUS_EXPR
7128           && TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 1)) == INTEGER_CST
7129           && TREE_CODE (TREE_OPERAND (exp, 1)) == RTL_EXPR
7130           && (RTL_EXPR_RTL (TREE_OPERAND (exp, 1)) == frame_pointer_rtx
7131               || RTL_EXPR_RTL (TREE_OPERAND (exp, 1)) == stack_pointer_rtx
7132               || RTL_EXPR_RTL (TREE_OPERAND (exp, 1)) == arg_pointer_rtx))
7133         {
7134           tree t = TREE_OPERAND (exp, 1);
7135
7136           TREE_OPERAND (exp, 1) = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
7137           TREE_OPERAND (TREE_OPERAND (exp, 0), 0) = t;
7138         }
7139
7140       /* If the result is to be ptr_mode and we are adding an integer to
7141          something, we might be forming a constant.  So try to use
7142          plus_constant.  If it produces a sum and we can't accept it,
7143          use force_operand.  This allows P = &ARR[const] to generate
7144          efficient code on machines where a SYMBOL_REF is not a valid
7145          address.
7146
7147          If this is an EXPAND_SUM call, always return the sum.  */
7148       if (modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER
7149           || mode == ptr_mode)
7150         {
7151           if (TREE_CODE (TREE_OPERAND (exp, 0)) == INTEGER_CST
7152               && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
7153               && TREE_CONSTANT (TREE_OPERAND (exp, 1)))
7154             {
7155               rtx constant_part;
7156
7157               op1 = expand_expr (TREE_OPERAND (exp, 1), subtarget, VOIDmode,
7158                                  EXPAND_SUM);
7159               /* Use immed_double_const to ensure that the constant is
7160                  truncated according to the mode of OP1, then sign extended
7161                  to a HOST_WIDE_INT.  Using the constant directly can result
7162                  in non-canonical RTL in a 64x32 cross compile.  */
7163               constant_part
7164                 = immed_double_const (TREE_INT_CST_LOW (TREE_OPERAND (exp, 0)),
7165                                       (HOST_WIDE_INT) 0,
7166                                       TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 1))));
7167               op1 = plus_constant (op1, INTVAL (constant_part));
7168               if (modifier != EXPAND_SUM && modifier != EXPAND_INITIALIZER)
7169                 op1 = force_operand (op1, target);
7170               return op1;
7171             }
7172
7173           else if (TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST
7174                    && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_INT
7175                    && TREE_CONSTANT (TREE_OPERAND (exp, 0)))
7176             {
7177               rtx constant_part;
7178
7179               op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode,
7180                                  EXPAND_SUM);
7181               if (! CONSTANT_P (op0))
7182                 {
7183                   op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX,
7184                                      VOIDmode, modifier);
7185                   /* Don't go to both_summands if modifier
7186                      says it's not right to return a PLUS.  */
7187                   if (modifier != EXPAND_SUM && modifier != EXPAND_INITIALIZER)
7188                     goto binop2;
7189                   goto both_summands;
7190                 }
7191               /* Use immed_double_const to ensure that the constant is
7192                  truncated according to the mode of OP1, then sign extended
7193                  to a HOST_WIDE_INT.  Using the constant directly can result
7194                  in non-canonical RTL in a 64x32 cross compile.  */
7195               constant_part
7196                 = immed_double_const (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1)),
7197                                       (HOST_WIDE_INT) 0,
7198                                       TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))));
7199               op0 = plus_constant (op0, INTVAL (constant_part));
7200               if (modifier != EXPAND_SUM && modifier != EXPAND_INITIALIZER)
7201                 op0 = force_operand (op0, target);
7202               return op0;
7203             }
7204         }
7205
7206       /* No sense saving up arithmetic to be done
7207          if it's all in the wrong mode to form part of an address.
7208          And force_operand won't know whether to sign-extend or
7209          zero-extend.  */
7210       if ((modifier != EXPAND_SUM && modifier != EXPAND_INITIALIZER)
7211           || mode != ptr_mode)
7212         goto binop;
7213
7214       preexpand_calls (exp);
7215       if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1), 1))
7216         subtarget = 0;
7217
7218       op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, ro_modifier);
7219       op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, ro_modifier);
7220
7221     both_summands:
7222       /* Make sure any term that's a sum with a constant comes last.  */
7223       if (GET_CODE (op0) == PLUS
7224           && CONSTANT_P (XEXP (op0, 1)))
7225         {
7226           temp = op0;
7227           op0 = op1;
7228           op1 = temp;
7229         }
7230       /* If adding to a sum including a constant,
7231          associate it to put the constant outside.  */
7232       if (GET_CODE (op1) == PLUS
7233           && CONSTANT_P (XEXP (op1, 1)))
7234         {
7235           rtx constant_term = const0_rtx;
7236
7237           temp = simplify_binary_operation (PLUS, mode, XEXP (op1, 0), op0);
7238           if (temp != 0)
7239             op0 = temp;
7240           /* Ensure that MULT comes first if there is one.  */
7241           else if (GET_CODE (op0) == MULT)
7242             op0 = gen_rtx_PLUS (mode, op0, XEXP (op1, 0));
7243           else
7244             op0 = gen_rtx_PLUS (mode, XEXP (op1, 0), op0);
7245
7246           /* Let's also eliminate constants from op0 if possible.  */
7247           op0 = eliminate_constant_term (op0, &constant_term);
7248
7249           /* CONSTANT_TERM and XEXP (op1, 1) are known to be constant, so
7250              their sum should be a constant.  Form it into OP1, since the
7251              result we want will then be OP0 + OP1.  */
7252
7253           temp = simplify_binary_operation (PLUS, mode, constant_term,
7254                                             XEXP (op1, 1));
7255           if (temp != 0)
7256             op1 = temp;
7257           else
7258             op1 = gen_rtx_PLUS (mode, constant_term, XEXP (op1, 1));
7259         }
7260
7261       /* Put a constant term last and put a multiplication first.  */
7262       if (CONSTANT_P (op0) || GET_CODE (op1) == MULT)
7263         temp = op1, op1 = op0, op0 = temp;
7264
7265       temp = simplify_binary_operation (PLUS, mode, op0, op1);
7266       return temp ? temp : gen_rtx_PLUS (mode, op0, op1);
7267
7268     case MINUS_EXPR:
7269       /* For initializers, we are allowed to return a MINUS of two
7270          symbolic constants.  Here we handle all cases when both operands
7271          are constant.  */
7272       /* Handle difference of two symbolic constants,
7273          for the sake of an initializer.  */
7274       if ((modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER)
7275           && really_constant_p (TREE_OPERAND (exp, 0))
7276           && really_constant_p (TREE_OPERAND (exp, 1)))
7277         {
7278           rtx op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX,
7279                                  VOIDmode, ro_modifier);
7280           rtx op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX,
7281                                  VOIDmode, ro_modifier);
7282
7283           /* If the last operand is a CONST_INT, use plus_constant of
7284              the negated constant.  Else make the MINUS.  */
7285           if (GET_CODE (op1) == CONST_INT)
7286             return plus_constant (op0, - INTVAL (op1));
7287           else
7288             return gen_rtx_MINUS (mode, op0, op1);
7289         }
7290       /* Convert A - const to A + (-const).  */
7291       if (TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST)
7292         {
7293           tree negated = fold (build1 (NEGATE_EXPR, type,
7294                                        TREE_OPERAND (exp, 1)));
7295
7296           if (TREE_UNSIGNED (type) || TREE_OVERFLOW (negated))
7297             /* If we can't negate the constant in TYPE, leave it alone and
7298                expand_binop will negate it for us.  We used to try to do it
7299                here in the signed version of TYPE, but that doesn't work
7300                on POINTER_TYPEs.  */;
7301           else
7302             {
7303               exp = build (PLUS_EXPR, type, TREE_OPERAND (exp, 0), negated);
7304               goto plus_expr;
7305             }
7306         }
7307       this_optab = sub_optab;
7308       goto binop;
7309
7310     case MULT_EXPR:
7311       preexpand_calls (exp);
7312       /* If first operand is constant, swap them.
7313          Thus the following special case checks need only
7314          check the second operand.  */
7315       if (TREE_CODE (TREE_OPERAND (exp, 0)) == INTEGER_CST)
7316         {
7317           register tree t1 = TREE_OPERAND (exp, 0);
7318           TREE_OPERAND (exp, 0) = TREE_OPERAND (exp, 1);
7319           TREE_OPERAND (exp, 1) = t1;
7320         }
7321
7322       /* Attempt to return something suitable for generating an
7323          indexed address, for machines that support that.  */
7324
7325       if (modifier == EXPAND_SUM && mode == ptr_mode
7326           && TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST
7327           && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
7328         {
7329           op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode,
7330                              EXPAND_SUM);
7331
7332           /* Apply distributive law if OP0 is x+c.  */
7333           if (GET_CODE (op0) == PLUS
7334               && GET_CODE (XEXP (op0, 1)) == CONST_INT)
7335             return
7336               gen_rtx_PLUS
7337                 (mode,
7338                  gen_rtx_MULT
7339                  (mode, XEXP (op0, 0),
7340                   GEN_INT (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1)))),
7341                  GEN_INT (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1))
7342                           * INTVAL (XEXP (op0, 1))));
7343
7344           if (GET_CODE (op0) != REG)
7345             op0 = force_operand (op0, NULL_RTX);
7346           if (GET_CODE (op0) != REG)
7347             op0 = copy_to_mode_reg (mode, op0);
7348
7349           return
7350             gen_rtx_MULT (mode, op0,
7351                           GEN_INT (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1))));
7352         }
7353
7354       if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1), 1))
7355         subtarget = 0;
7356
7357       /* Check for multiplying things that have been extended
7358          from a narrower type.  If this machine supports multiplying
7359          in that narrower type with a result in the desired type,
7360          do it that way, and avoid the explicit type-conversion.  */
7361       if (TREE_CODE (TREE_OPERAND (exp, 0)) == NOP_EXPR
7362           && TREE_CODE (type) == INTEGER_TYPE
7363           && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
7364               < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp, 0))))
7365           && ((TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST
7366                && int_fits_type_p (TREE_OPERAND (exp, 1),
7367                                    TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
7368                /* Don't use a widening multiply if a shift will do.  */
7369                && ((GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 1))))
7370                     > HOST_BITS_PER_WIDE_INT)
7371                    || exact_log2 (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1))) < 0))
7372               ||
7373               (TREE_CODE (TREE_OPERAND (exp, 1)) == NOP_EXPR
7374                && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 1), 0)))
7375                    ==
7376                    TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))))
7377                /* If both operands are extended, they must either both
7378                   be zero-extended or both be sign-extended.  */
7379                && (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 1), 0)))
7380                    ==
7381                    TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))))))
7382         {
7383           enum machine_mode innermode
7384             = TYPE_MODE (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)));
7385           optab other_optab = (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
7386                         ? smul_widen_optab : umul_widen_optab);
7387           this_optab = (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))
7388                         ? umul_widen_optab : smul_widen_optab);
7389           if (mode == GET_MODE_WIDER_MODE (innermode))
7390             {
7391               if (this_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
7392                 {
7393                   op0 = expand_expr (TREE_OPERAND (TREE_OPERAND (exp, 0), 0),
7394                                      NULL_RTX, VOIDmode, 0);
7395                   if (TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST)
7396                     op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX,
7397                                        VOIDmode, 0);
7398                   else
7399                     op1 = expand_expr (TREE_OPERAND (TREE_OPERAND (exp, 1), 0),
7400                                        NULL_RTX, VOIDmode, 0);
7401                   goto binop2;
7402                 }
7403               else if (other_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing
7404                        && innermode == word_mode)
7405                 {
7406                   rtx htem;
7407                   op0 = expand_expr (TREE_OPERAND (TREE_OPERAND (exp, 0), 0),
7408                                      NULL_RTX, VOIDmode, 0);
7409                   if (TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST)
7410                     op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX,
7411                                        VOIDmode, 0);
7412                   else
7413                     op1 = expand_expr (TREE_OPERAND (TREE_OPERAND (exp, 1), 0),
7414                                        NULL_RTX, VOIDmode, 0);
7415                   temp = expand_binop (mode, other_optab, op0, op1, target,
7416                                        unsignedp, OPTAB_LIB_WIDEN);
7417                   htem = expand_mult_highpart_adjust (innermode,
7418                                                       gen_highpart (innermode, temp),
7419                                                       op0, op1,
7420                                                       gen_highpart (innermode, temp),
7421                                                       unsignedp);
7422                   emit_move_insn (gen_highpart (innermode, temp), htem);
7423                   return temp;
7424                 }
7425             }
7426         }
7427       op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
7428       op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
7429       return expand_mult (mode, op0, op1, target, unsignedp);
7430
7431     case TRUNC_DIV_EXPR:
7432     case FLOOR_DIV_EXPR:
7433     case CEIL_DIV_EXPR:
7434     case ROUND_DIV_EXPR:
7435     case EXACT_DIV_EXPR:
7436       preexpand_calls (exp);
7437       if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1), 1))
7438         subtarget = 0;
7439       /* Possible optimization: compute the dividend with EXPAND_SUM
7440          then if the divisor is constant can optimize the case
7441          where some terms of the dividend have coeffs divisible by it.  */
7442       op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
7443       op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
7444       return expand_divmod (0, code, mode, op0, op1, target, unsignedp);
7445
7446     case RDIV_EXPR:
7447       this_optab = flodiv_optab;
7448       goto binop;
7449
7450     case TRUNC_MOD_EXPR:
7451     case FLOOR_MOD_EXPR:
7452     case CEIL_MOD_EXPR:
7453     case ROUND_MOD_EXPR:
7454       preexpand_calls (exp);
7455       if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1), 1))
7456         subtarget = 0;
7457       op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
7458       op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
7459       return expand_divmod (1, code, mode, op0, op1, target, unsignedp);
7460
7461     case FIX_ROUND_EXPR:
7462     case FIX_FLOOR_EXPR:
7463     case FIX_CEIL_EXPR:
7464       abort ();                 /* Not used for C.  */
7465
7466     case FIX_TRUNC_EXPR:
7467       op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode, 0);
7468       if (target == 0)
7469         target = gen_reg_rtx (mode);
7470       expand_fix (target, op0, unsignedp);
7471       return target;
7472
7473     case FLOAT_EXPR:
7474       op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode, 0);
7475       if (target == 0)
7476         target = gen_reg_rtx (mode);
7477       /* expand_float can't figure out what to do if FROM has VOIDmode.
7478          So give it the correct mode.  With -O, cse will optimize this.  */
7479       if (GET_MODE (op0) == VOIDmode)
7480         op0 = copy_to_mode_reg (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))),
7481                                 op0);
7482       expand_float (target, op0,
7483                     TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))));
7484       return target;
7485
7486     case NEGATE_EXPR:
7487       op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
7488       temp = expand_unop (mode, neg_optab, op0, target, 0);
7489       if (temp == 0)
7490         abort ();
7491       return temp;
7492
7493     case ABS_EXPR:
7494       op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
7495
7496       /* Handle complex values specially.  */
7497       if (GET_MODE_CLASS (mode) == MODE_COMPLEX_INT
7498           || GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT)
7499         return expand_complex_abs (mode, op0, target, unsignedp);
7500
7501       /* Unsigned abs is simply the operand.  Testing here means we don't
7502          risk generating incorrect code below.  */
7503       if (TREE_UNSIGNED (type))
7504         return op0;
7505
7506       return expand_abs (mode, op0, target,
7507                          safe_from_p (target, TREE_OPERAND (exp, 0), 1));
7508
7509     case MAX_EXPR:
7510     case MIN_EXPR:
7511       target = original_target;
7512       if (target == 0 || ! safe_from_p (target, TREE_OPERAND (exp, 1), 1)
7513           || (GET_CODE (target) == MEM && MEM_VOLATILE_P (target))
7514           || GET_MODE (target) != mode
7515           || (GET_CODE (target) == REG
7516               && REGNO (target) < FIRST_PSEUDO_REGISTER))
7517         target = gen_reg_rtx (mode);
7518       op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
7519       op0 = expand_expr (TREE_OPERAND (exp, 0), target, VOIDmode, 0);
7520
7521       /* First try to do it with a special MIN or MAX instruction.
7522          If that does not win, use a conditional jump to select the proper
7523          value.  */
7524       this_optab = (TREE_UNSIGNED (type)
7525                     ? (code == MIN_EXPR ? umin_optab : umax_optab)
7526                     : (code == MIN_EXPR ? smin_optab : smax_optab));
7527
7528       temp = expand_binop (mode, this_optab, op0, op1, target, unsignedp,
7529                            OPTAB_WIDEN);
7530       if (temp != 0)
7531         return temp;
7532
7533       /* At this point, a MEM target is no longer useful; we will get better
7534          code without it.  */
7535
7536       if (GET_CODE (target) == MEM)
7537         target = gen_reg_rtx (mode);
7538
7539       if (target != op0)
7540         emit_move_insn (target, op0);
7541
7542       op0 = gen_label_rtx ();
7543
7544       /* If this mode is an integer too wide to compare properly,
7545          compare word by word.  Rely on cse to optimize constant cases.  */
7546       if (GET_MODE_CLASS (mode) == MODE_INT
7547           && ! can_compare_p (GE, mode, ccp_jump))
7548         {
7549           if (code == MAX_EXPR)
7550             do_jump_by_parts_greater_rtx (mode, TREE_UNSIGNED (type),
7551                                           target, op1, NULL_RTX, op0);
7552           else
7553             do_jump_by_parts_greater_rtx (mode, TREE_UNSIGNED (type),
7554                                           op1, target, NULL_RTX, op0);
7555         }
7556       else
7557         {
7558           int unsignedp = TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 1)));
7559           do_compare_rtx_and_jump (target, op1, code == MAX_EXPR ? GE : LE,
7560                                    unsignedp, mode, NULL_RTX, 0, NULL_RTX,
7561                                    op0);
7562         }
7563       emit_move_insn (target, op1);
7564       emit_label (op0);
7565       return target;
7566
7567     case BIT_NOT_EXPR:
7568       op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
7569       temp = expand_unop (mode, one_cmpl_optab, op0, target, 1);
7570       if (temp == 0)
7571         abort ();
7572       return temp;
7573
7574     case FFS_EXPR:
7575       op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
7576       temp = expand_unop (mode, ffs_optab, op0, target, 1);
7577       if (temp == 0)
7578         abort ();
7579       return temp;
7580
7581       /* ??? Can optimize bitwise operations with one arg constant.
7582          Can optimize (a bitwise1 n) bitwise2 (a bitwise3 b)
7583          and (a bitwise1 b) bitwise2 b (etc)
7584          but that is probably not worth while.  */
7585
7586       /* BIT_AND_EXPR is for bitwise anding.  TRUTH_AND_EXPR is for anding two
7587          boolean values when we want in all cases to compute both of them.  In
7588          general it is fastest to do TRUTH_AND_EXPR by computing both operands
7589          as actual zero-or-1 values and then bitwise anding.  In cases where
7590          there cannot be any side effects, better code would be made by
7591          treating TRUTH_AND_EXPR like TRUTH_ANDIF_EXPR; but the question is
7592          how to recognize those cases.  */
7593
7594     case TRUTH_AND_EXPR:
7595     case BIT_AND_EXPR:
7596       this_optab = and_optab;
7597       goto binop;
7598
7599     case TRUTH_OR_EXPR:
7600     case BIT_IOR_EXPR:
7601       this_optab = ior_optab;
7602       goto binop;
7603
7604     case TRUTH_XOR_EXPR:
7605     case BIT_XOR_EXPR:
7606       this_optab = xor_optab;
7607       goto binop;
7608
7609     case LSHIFT_EXPR:
7610     case RSHIFT_EXPR:
7611     case LROTATE_EXPR:
7612     case RROTATE_EXPR:
7613       preexpand_calls (exp);
7614       if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1), 1))
7615         subtarget = 0;
7616       op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
7617       return expand_shift (code, mode, op0, TREE_OPERAND (exp, 1), target,
7618                            unsignedp);
7619
7620       /* Could determine the answer when only additive constants differ.  Also,
7621          the addition of one can be handled by changing the condition.  */
7622     case LT_EXPR:
7623     case LE_EXPR:
7624     case GT_EXPR:
7625     case GE_EXPR:
7626     case EQ_EXPR:
7627     case NE_EXPR:
7628     case UNORDERED_EXPR:
7629     case ORDERED_EXPR:
7630     case UNLT_EXPR:
7631     case UNLE_EXPR:
7632     case UNGT_EXPR:
7633     case UNGE_EXPR:
7634     case UNEQ_EXPR:
7635       preexpand_calls (exp);
7636       temp = do_store_flag (exp, target, tmode != VOIDmode ? tmode : mode, 0);
7637       if (temp != 0)
7638         return temp;
7639
7640       /* For foo != 0, load foo, and if it is nonzero load 1 instead.  */
7641       if (code == NE_EXPR && integer_zerop (TREE_OPERAND (exp, 1))
7642           && original_target
7643           && GET_CODE (original_target) == REG
7644           && (GET_MODE (original_target)
7645               == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))))
7646         {
7647           temp = expand_expr (TREE_OPERAND (exp, 0), original_target,
7648                               VOIDmode, 0);
7649
7650           if (temp != original_target)
7651             temp = copy_to_reg (temp);
7652
7653           op1 = gen_label_rtx ();
7654           emit_cmp_and_jump_insns (temp, const0_rtx, EQ, NULL_RTX,
7655                                    GET_MODE (temp), unsignedp, 0, op1);
7656           emit_move_insn (temp, const1_rtx);
7657           emit_label (op1);
7658           return temp;
7659         }
7660
7661       /* If no set-flag instruction, must generate a conditional
7662          store into a temporary variable.  Drop through
7663          and handle this like && and ||.  */
7664
7665     case TRUTH_ANDIF_EXPR:
7666     case TRUTH_ORIF_EXPR:
7667       if (! ignore
7668           && (target == 0 || ! safe_from_p (target, exp, 1)
7669               /* Make sure we don't have a hard reg (such as function's return
7670                  value) live across basic blocks, if not optimizing.  */
7671               || (!optimize && GET_CODE (target) == REG
7672                   && REGNO (target) < FIRST_PSEUDO_REGISTER)))
7673         target = gen_reg_rtx (tmode != VOIDmode ? tmode : mode);
7674
7675       if (target)
7676         emit_clr_insn (target);
7677
7678       op1 = gen_label_rtx ();
7679       jumpifnot (exp, op1);
7680
7681       if (target)
7682         emit_0_to_1_insn (target);
7683
7684       emit_label (op1);
7685       return ignore ? const0_rtx : target;
7686
7687     case TRUTH_NOT_EXPR:
7688       op0 = expand_expr (TREE_OPERAND (exp, 0), target, VOIDmode, 0);
7689       /* The parser is careful to generate TRUTH_NOT_EXPR
7690          only with operands that are always zero or one.  */
7691       temp = expand_binop (mode, xor_optab, op0, const1_rtx,
7692                            target, 1, OPTAB_LIB_WIDEN);
7693       if (temp == 0)
7694         abort ();
7695       return temp;
7696
7697     case COMPOUND_EXPR:
7698       expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode, 0);
7699       emit_queue ();
7700       return expand_expr (TREE_OPERAND (exp, 1),
7701                           (ignore ? const0_rtx : target),
7702                           VOIDmode, 0);
7703
7704     case COND_EXPR:
7705       /* If we would have a "singleton" (see below) were it not for a
7706          conversion in each arm, bring that conversion back out.  */
7707       if (TREE_CODE (TREE_OPERAND (exp, 1)) == NOP_EXPR
7708           && TREE_CODE (TREE_OPERAND (exp, 2)) == NOP_EXPR
7709           && (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 1), 0))
7710               == TREE_TYPE (TREE_OPERAND (TREE_OPERAND (exp, 2), 0))))
7711         {
7712           tree true = TREE_OPERAND (TREE_OPERAND (exp, 1), 0);
7713           tree false = TREE_OPERAND (TREE_OPERAND (exp, 2), 0);
7714
7715           if ((TREE_CODE_CLASS (TREE_CODE (true)) == '2'
7716                && operand_equal_p (false, TREE_OPERAND (true, 0), 0))
7717               || (TREE_CODE_CLASS (TREE_CODE (false)) == '2'
7718                   && operand_equal_p (true, TREE_OPERAND (false, 0), 0))
7719               || (TREE_CODE_CLASS (TREE_CODE (true)) == '1'
7720                   && operand_equal_p (false, TREE_OPERAND (true, 0), 0))
7721               || (TREE_CODE_CLASS (TREE_CODE (false)) == '1'
7722                   && operand_equal_p (true, TREE_OPERAND (false, 0), 0)))
7723             return expand_expr (build1 (NOP_EXPR, type,
7724                                         build (COND_EXPR, TREE_TYPE (true),
7725                                                TREE_OPERAND (exp, 0),
7726                                                true, false)),
7727                                 target, tmode, modifier);
7728         }
7729
7730       {
7731         /* Note that COND_EXPRs whose type is a structure or union
7732            are required to be constructed to contain assignments of
7733            a temporary variable, so that we can evaluate them here
7734            for side effect only.  If type is void, we must do likewise.  */
7735
7736         /* If an arm of the branch requires a cleanup,
7737            only that cleanup is performed.  */
7738
7739         tree singleton = 0;
7740         tree binary_op = 0, unary_op = 0;
7741
7742         /* If this is (A ? 1 : 0) and A is a condition, just evaluate it and
7743            convert it to our mode, if necessary.  */
7744         if (integer_onep (TREE_OPERAND (exp, 1))
7745             && integer_zerop (TREE_OPERAND (exp, 2))
7746             && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == '<')
7747           {
7748             if (ignore)
7749               {
7750                 expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode,
7751                              ro_modifier);
7752                 return const0_rtx;
7753               }
7754
7755             op0 = expand_expr (TREE_OPERAND (exp, 0), target, mode, ro_modifier);
7756             if (GET_MODE (op0) == mode)
7757               return op0;
7758
7759             if (target == 0)
7760               target = gen_reg_rtx (mode);
7761             convert_move (target, op0, unsignedp);
7762             return target;
7763           }
7764
7765         /* Check for X ? A + B : A.  If we have this, we can copy A to the
7766            output and conditionally add B.  Similarly for unary operations.
7767            Don't do this if X has side-effects because those side effects
7768            might affect A or B and the "?" operation is a sequence point in
7769            ANSI.  (operand_equal_p tests for side effects.)  */
7770
7771         if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 1))) == '2'
7772             && operand_equal_p (TREE_OPERAND (exp, 2),
7773                                 TREE_OPERAND (TREE_OPERAND (exp, 1), 0), 0))
7774           singleton = TREE_OPERAND (exp, 2), binary_op = TREE_OPERAND (exp, 1);
7775         else if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 2))) == '2'
7776                  && operand_equal_p (TREE_OPERAND (exp, 1),
7777                                      TREE_OPERAND (TREE_OPERAND (exp, 2), 0), 0))
7778           singleton = TREE_OPERAND (exp, 1), binary_op = TREE_OPERAND (exp, 2);
7779         else if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 1))) == '1'
7780                  && operand_equal_p (TREE_OPERAND (exp, 2),
7781                                      TREE_OPERAND (TREE_OPERAND (exp, 1), 0), 0))
7782           singleton = TREE_OPERAND (exp, 2), unary_op = TREE_OPERAND (exp, 1);
7783         else if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 2))) == '1'
7784                  && operand_equal_p (TREE_OPERAND (exp, 1),
7785                                      TREE_OPERAND (TREE_OPERAND (exp, 2), 0), 0))
7786           singleton = TREE_OPERAND (exp, 1), unary_op = TREE_OPERAND (exp, 2);
7787
7788         /* If we are not to produce a result, we have no target.  Otherwise,
7789            if a target was specified use it; it will not be used as an
7790            intermediate target unless it is safe.  If no target, use a
7791            temporary.  */
7792
7793         if (ignore)
7794           temp = 0;
7795         else if (original_target
7796                  && (safe_from_p (original_target, TREE_OPERAND (exp, 0), 1)
7797                      || (singleton && GET_CODE (original_target) == REG
7798                          && REGNO (original_target) >= FIRST_PSEUDO_REGISTER
7799                          && original_target == var_rtx (singleton)))
7800                  && GET_MODE (original_target) == mode
7801 #ifdef HAVE_conditional_move
7802                  && (! can_conditionally_move_p (mode)
7803                      || GET_CODE (original_target) == REG
7804                      || TREE_ADDRESSABLE (type))
7805 #endif
7806                  && ! (GET_CODE (original_target) == MEM
7807                        && MEM_VOLATILE_P (original_target)))
7808           temp = original_target;
7809         else if (TREE_ADDRESSABLE (type))
7810           abort ();
7811         else
7812           temp = assign_temp (type, 0, 0, 1);
7813
7814         /* If we had X ? A + C : A, with C a constant power of 2, and we can
7815            do the test of X as a store-flag operation, do this as
7816            A + ((X != 0) << log C).  Similarly for other simple binary
7817            operators.  Only do for C == 1 if BRANCH_COST is low.  */
7818         if (temp && singleton && binary_op
7819             && (TREE_CODE (binary_op) == PLUS_EXPR
7820                 || TREE_CODE (binary_op) == MINUS_EXPR
7821                 || TREE_CODE (binary_op) == BIT_IOR_EXPR
7822                 || TREE_CODE (binary_op) == BIT_XOR_EXPR)
7823             && (BRANCH_COST >= 3 ? integer_pow2p (TREE_OPERAND (binary_op, 1))
7824                 : integer_onep (TREE_OPERAND (binary_op, 1)))
7825             && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == '<')
7826           {
7827             rtx result;
7828             optab boptab = (TREE_CODE (binary_op) == PLUS_EXPR ? add_optab
7829                             : TREE_CODE (binary_op) == MINUS_EXPR ? sub_optab
7830                             : TREE_CODE (binary_op) == BIT_IOR_EXPR ? ior_optab
7831                             : xor_optab);
7832
7833             /* If we had X ? A : A + 1, do this as A + (X == 0).
7834
7835                We have to invert the truth value here and then put it
7836                back later if do_store_flag fails.  We cannot simply copy
7837                TREE_OPERAND (exp, 0) to another variable and modify that
7838                because invert_truthvalue can modify the tree pointed to
7839                by its argument.  */
7840             if (singleton == TREE_OPERAND (exp, 1))
7841               TREE_OPERAND (exp, 0)
7842                 = invert_truthvalue (TREE_OPERAND (exp, 0));
7843
7844             result = do_store_flag (TREE_OPERAND (exp, 0),
7845                                     (safe_from_p (temp, singleton, 1)
7846                                      ? temp : NULL_RTX),
7847                                     mode, BRANCH_COST <= 1);
7848
7849             if (result != 0 && ! integer_onep (TREE_OPERAND (binary_op, 1)))
7850               result = expand_shift (LSHIFT_EXPR, mode, result,
7851                                      build_int_2 (tree_log2
7852                                                   (TREE_OPERAND
7853                                                    (binary_op, 1)),
7854                                                   0),
7855                                      (safe_from_p (temp, singleton, 1)
7856                                       ? temp : NULL_RTX), 0);
7857
7858             if (result)
7859               {
7860                 op1 = expand_expr (singleton, NULL_RTX, VOIDmode, 0);
7861                 return expand_binop (mode, boptab, op1, result, temp,
7862                                      unsignedp, OPTAB_LIB_WIDEN);
7863               }
7864             else if (singleton == TREE_OPERAND (exp, 1))
7865               TREE_OPERAND (exp, 0)
7866                 = invert_truthvalue (TREE_OPERAND (exp, 0));
7867           }
7868
7869         do_pending_stack_adjust ();
7870         NO_DEFER_POP;
7871         op0 = gen_label_rtx ();
7872
7873         if (singleton && ! TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 0)))
7874           {
7875             if (temp != 0)
7876               {
7877                 /* If the target conflicts with the other operand of the
7878                    binary op, we can't use it.  Also, we can't use the target
7879                    if it is a hard register, because evaluating the condition
7880                    might clobber it.  */
7881                 if ((binary_op
7882                      && ! safe_from_p (temp, TREE_OPERAND (binary_op, 1), 1))
7883                     || (GET_CODE (temp) == REG
7884                         && REGNO (temp) < FIRST_PSEUDO_REGISTER))
7885                   temp = gen_reg_rtx (mode);
7886                 store_expr (singleton, temp, 0);
7887               }
7888             else
7889               expand_expr (singleton,
7890                            ignore ? const0_rtx : NULL_RTX, VOIDmode, 0);
7891             if (singleton == TREE_OPERAND (exp, 1))
7892               jumpif (TREE_OPERAND (exp, 0), op0);
7893             else
7894               jumpifnot (TREE_OPERAND (exp, 0), op0);
7895
7896             start_cleanup_deferral ();
7897             if (binary_op && temp == 0)
7898               /* Just touch the other operand.  */
7899               expand_expr (TREE_OPERAND (binary_op, 1),
7900                            ignore ? const0_rtx : NULL_RTX, VOIDmode, 0);
7901             else if (binary_op)
7902               store_expr (build (TREE_CODE (binary_op), type,
7903                                  make_tree (type, temp),
7904                                  TREE_OPERAND (binary_op, 1)),
7905                           temp, 0);
7906             else
7907               store_expr (build1 (TREE_CODE (unary_op), type,
7908                                   make_tree (type, temp)),
7909                           temp, 0);
7910             op1 = op0;
7911           }
7912         /* Check for A op 0 ? A : FOO and A op 0 ? FOO : A where OP is any
7913            comparison operator.  If we have one of these cases, set the
7914            output to A, branch on A (cse will merge these two references),
7915            then set the output to FOO.  */
7916         else if (temp
7917                  && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == '<'
7918                  && integer_zerop (TREE_OPERAND (TREE_OPERAND (exp, 0), 1))
7919                  && operand_equal_p (TREE_OPERAND (TREE_OPERAND (exp, 0), 0),
7920                                      TREE_OPERAND (exp, 1), 0)
7921                  && (! TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 0))
7922                      || TREE_CODE (TREE_OPERAND (exp, 1)) == SAVE_EXPR)
7923                  && safe_from_p (temp, TREE_OPERAND (exp, 2), 1))
7924           {
7925             if (GET_CODE (temp) == REG && REGNO (temp) < FIRST_PSEUDO_REGISTER)
7926               temp = gen_reg_rtx (mode);
7927             store_expr (TREE_OPERAND (exp, 1), temp, 0);
7928             jumpif (TREE_OPERAND (exp, 0), op0);
7929
7930             start_cleanup_deferral ();
7931             store_expr (TREE_OPERAND (exp, 2), temp, 0);
7932             op1 = op0;
7933           }
7934         else if (temp
7935                  && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == '<'
7936                  && integer_zerop (TREE_OPERAND (TREE_OPERAND (exp, 0), 1))
7937                  && operand_equal_p (TREE_OPERAND (TREE_OPERAND (exp, 0), 0),
7938                                      TREE_OPERAND (exp, 2), 0)
7939                  && (! TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 0))
7940                      || TREE_CODE (TREE_OPERAND (exp, 2)) == SAVE_EXPR)
7941                  && safe_from_p (temp, TREE_OPERAND (exp, 1), 1))
7942           {
7943             if (GET_CODE (temp) == REG && REGNO (temp) < FIRST_PSEUDO_REGISTER)
7944               temp = gen_reg_rtx (mode);
7945             store_expr (TREE_OPERAND (exp, 2), temp, 0);
7946             jumpifnot (TREE_OPERAND (exp, 0), op0);
7947
7948             start_cleanup_deferral ();
7949             store_expr (TREE_OPERAND (exp, 1), temp, 0);
7950             op1 = op0;
7951           }
7952         else
7953           {
7954             op1 = gen_label_rtx ();
7955             jumpifnot (TREE_OPERAND (exp, 0), op0);
7956
7957             start_cleanup_deferral ();
7958
7959             /* One branch of the cond can be void, if it never returns. For
7960                example A ? throw : E  */
7961             if (temp != 0
7962                 && TREE_TYPE (TREE_OPERAND (exp, 1)) != void_type_node)
7963               store_expr (TREE_OPERAND (exp, 1), temp, 0);
7964             else
7965               expand_expr (TREE_OPERAND (exp, 1),
7966                            ignore ? const0_rtx : NULL_RTX, VOIDmode, 0);
7967             end_cleanup_deferral ();
7968             emit_queue ();
7969             emit_jump_insn (gen_jump (op1));
7970             emit_barrier ();
7971             emit_label (op0);
7972             start_cleanup_deferral ();
7973             if (temp != 0
7974                 && TREE_TYPE (TREE_OPERAND (exp, 2)) != void_type_node)
7975               store_expr (TREE_OPERAND (exp, 2), temp, 0);
7976             else
7977               expand_expr (TREE_OPERAND (exp, 2),
7978                            ignore ? const0_rtx : NULL_RTX, VOIDmode, 0);
7979           }
7980
7981         end_cleanup_deferral ();
7982
7983         emit_queue ();
7984         emit_label (op1);
7985         OK_DEFER_POP;
7986
7987         return temp;
7988       }
7989
7990     case TARGET_EXPR:
7991       {
7992         /* Something needs to be initialized, but we didn't know
7993            where that thing was when building the tree.  For example,
7994            it could be the return value of a function, or a parameter
7995            to a function which lays down in the stack, or a temporary
7996            variable which must be passed by reference.
7997
7998            We guarantee that the expression will either be constructed
7999            or copied into our original target.  */
8000
8001         tree slot = TREE_OPERAND (exp, 0);
8002         tree cleanups = NULL_TREE;
8003         tree exp1;
8004
8005         if (TREE_CODE (slot) != VAR_DECL)
8006           abort ();
8007
8008         if (! ignore)
8009           target = original_target;
8010
8011         /* Set this here so that if we get a target that refers to a
8012            register variable that's already been used, put_reg_into_stack
8013            knows that it should fix up those uses.  */
8014         TREE_USED (slot) = 1;
8015
8016         if (target == 0)
8017           {
8018             if (DECL_RTL (slot) != 0)
8019               {
8020                 target = DECL_RTL (slot);
8021                 /* If we have already expanded the slot, so don't do
8022                    it again.  (mrs)  */
8023                 if (TREE_OPERAND (exp, 1) == NULL_TREE)
8024                   return target;
8025               }
8026             else
8027               {
8028                 target = assign_temp (type, 2, 0, 1);
8029                 /* All temp slots at this level must not conflict.  */
8030                 preserve_temp_slots (target);
8031                 DECL_RTL (slot) = target;
8032                 if (TREE_ADDRESSABLE (slot))
8033                   {
8034                     TREE_ADDRESSABLE (slot) = 0;
8035                     mark_addressable (slot);
8036                   }
8037
8038                 /* Since SLOT is not known to the called function
8039                    to belong to its stack frame, we must build an explicit
8040                    cleanup.  This case occurs when we must build up a reference
8041                    to pass the reference as an argument.  In this case,
8042                    it is very likely that such a reference need not be
8043                    built here.  */
8044
8045                 if (TREE_OPERAND (exp, 2) == 0)
8046                   TREE_OPERAND (exp, 2) = maybe_build_cleanup (slot);
8047                 cleanups = TREE_OPERAND (exp, 2);
8048               }
8049           }
8050         else
8051           {
8052             /* This case does occur, when expanding a parameter which
8053                needs to be constructed on the stack.  The target
8054                is the actual stack address that we want to initialize.
8055                The function we call will perform the cleanup in this case.  */
8056
8057             /* If we have already assigned it space, use that space,
8058                not target that we were passed in, as our target
8059                parameter is only a hint.  */
8060             if (DECL_RTL (slot) != 0)
8061               {
8062                 target = DECL_RTL (slot);
8063                 /* If we have already expanded the slot, so don't do
8064                    it again.  (mrs)  */
8065                 if (TREE_OPERAND (exp, 1) == NULL_TREE)
8066                   return target;
8067               }
8068             else
8069               {
8070                 DECL_RTL (slot) = target;
8071                 /* If we must have an addressable slot, then make sure that
8072                    the RTL that we just stored in slot is OK.  */
8073                 if (TREE_ADDRESSABLE (slot))
8074                   {
8075                     TREE_ADDRESSABLE (slot) = 0;
8076                     mark_addressable (slot);
8077                   }
8078               }
8079           }
8080
8081         exp1 = TREE_OPERAND (exp, 3) = TREE_OPERAND (exp, 1);
8082         /* Mark it as expanded.  */
8083         TREE_OPERAND (exp, 1) = NULL_TREE;
8084
8085         store_expr (exp1, target, 0);
8086
8087         expand_decl_cleanup (NULL_TREE, cleanups);
8088
8089         return target;
8090       }
8091
8092     case INIT_EXPR:
8093       {
8094         tree lhs = TREE_OPERAND (exp, 0);
8095         tree rhs = TREE_OPERAND (exp, 1);
8096         tree noncopied_parts = 0;
8097         tree lhs_type = TREE_TYPE (lhs);
8098
8099         temp = expand_assignment (lhs, rhs, ! ignore, original_target != 0);
8100         if (TYPE_NONCOPIED_PARTS (lhs_type) != 0 && !fixed_type_p (rhs))
8101           noncopied_parts = init_noncopied_parts (stabilize_reference (lhs),
8102                                                   TYPE_NONCOPIED_PARTS (lhs_type));
8103         while (noncopied_parts != 0)
8104           {
8105             expand_assignment (TREE_VALUE (noncopied_parts),
8106                                TREE_PURPOSE (noncopied_parts), 0, 0);
8107             noncopied_parts = TREE_CHAIN (noncopied_parts);
8108           }
8109         return temp;
8110       }
8111
8112     case MODIFY_EXPR:
8113       {
8114         /* If lhs is complex, expand calls in rhs before computing it.
8115            That's so we don't compute a pointer and save it over a call.
8116            If lhs is simple, compute it first so we can give it as a
8117            target if the rhs is just a call.  This avoids an extra temp and copy
8118            and that prevents a partial-subsumption which makes bad code.
8119            Actually we could treat component_ref's of vars like vars.  */
8120
8121         tree lhs = TREE_OPERAND (exp, 0);
8122         tree rhs = TREE_OPERAND (exp, 1);
8123         tree noncopied_parts = 0;
8124         tree lhs_type = TREE_TYPE (lhs);
8125
8126         temp = 0;
8127
8128         if (TREE_CODE (lhs) != VAR_DECL
8129             && TREE_CODE (lhs) != RESULT_DECL
8130             && TREE_CODE (lhs) != PARM_DECL
8131             && ! (TREE_CODE (lhs) == INDIRECT_REF
8132                   && TYPE_READONLY (TREE_TYPE (TREE_OPERAND (lhs, 0)))))
8133           preexpand_calls (exp);
8134
8135         /* Check for |= or &= of a bitfield of size one into another bitfield
8136            of size 1.  In this case, (unless we need the result of the
8137            assignment) we can do this more efficiently with a
8138            test followed by an assignment, if necessary.
8139
8140            ??? At this point, we can't get a BIT_FIELD_REF here.  But if
8141            things change so we do, this code should be enhanced to
8142            support it.  */
8143         if (ignore
8144             && TREE_CODE (lhs) == COMPONENT_REF
8145             && (TREE_CODE (rhs) == BIT_IOR_EXPR
8146                 || TREE_CODE (rhs) == BIT_AND_EXPR)
8147             && TREE_OPERAND (rhs, 0) == lhs
8148             && TREE_CODE (TREE_OPERAND (rhs, 1)) == COMPONENT_REF
8149             && integer_onep (DECL_SIZE (TREE_OPERAND (lhs, 1)))
8150             && integer_onep (DECL_SIZE (TREE_OPERAND (TREE_OPERAND (rhs, 1), 1))))
8151           {
8152             rtx label = gen_label_rtx ();
8153
8154             do_jump (TREE_OPERAND (rhs, 1),
8155                      TREE_CODE (rhs) == BIT_IOR_EXPR ? label : 0,
8156                      TREE_CODE (rhs) == BIT_AND_EXPR ? label : 0);
8157             expand_assignment (lhs, convert (TREE_TYPE (rhs),
8158                                              (TREE_CODE (rhs) == BIT_IOR_EXPR
8159                                               ? integer_one_node
8160                                               : integer_zero_node)),
8161                                0, 0);
8162             do_pending_stack_adjust ();
8163             emit_label (label);
8164             return const0_rtx;
8165           }
8166
8167         if (TYPE_NONCOPIED_PARTS (lhs_type) != 0
8168             && ! (fixed_type_p (lhs) && fixed_type_p (rhs)))
8169           noncopied_parts = save_noncopied_parts (stabilize_reference (lhs),
8170                                                   TYPE_NONCOPIED_PARTS (lhs_type));
8171
8172         temp = expand_assignment (lhs, rhs, ! ignore, original_target != 0);
8173         while (noncopied_parts != 0)
8174           {
8175             expand_assignment (TREE_PURPOSE (noncopied_parts),
8176                                TREE_VALUE (noncopied_parts), 0, 0);
8177             noncopied_parts = TREE_CHAIN (noncopied_parts);
8178           }
8179         return temp;
8180       }
8181
8182     case RETURN_EXPR:
8183       if (!TREE_OPERAND (exp, 0))
8184         expand_null_return ();
8185       else
8186         expand_return (TREE_OPERAND (exp, 0));
8187       return const0_rtx;
8188
8189     case PREINCREMENT_EXPR:
8190     case PREDECREMENT_EXPR:
8191       return expand_increment (exp, 0, ignore);
8192
8193     case POSTINCREMENT_EXPR:
8194     case POSTDECREMENT_EXPR:
8195       /* Faster to treat as pre-increment if result is not used.  */
8196       return expand_increment (exp, ! ignore, ignore);
8197
8198     case ADDR_EXPR:
8199       /* If nonzero, TEMP will be set to the address of something that might
8200          be a MEM corresponding to a stack slot.  */
8201       temp = 0;
8202
8203       /* Are we taking the address of a nested function?  */
8204       if (TREE_CODE (TREE_OPERAND (exp, 0)) == FUNCTION_DECL
8205           && decl_function_context (TREE_OPERAND (exp, 0)) != 0
8206           && ! DECL_NO_STATIC_CHAIN (TREE_OPERAND (exp, 0))
8207           && ! TREE_STATIC (exp))
8208         {
8209           op0 = trampoline_address (TREE_OPERAND (exp, 0));
8210           op0 = force_operand (op0, target);
8211         }
8212       /* If we are taking the address of something erroneous, just
8213          return a zero.  */
8214       else if (TREE_CODE (TREE_OPERAND (exp, 0)) == ERROR_MARK)
8215         return const0_rtx;
8216       else
8217         {
8218           /* We make sure to pass const0_rtx down if we came in with
8219              ignore set, to avoid doing the cleanups twice for something.  */
8220           op0 = expand_expr (TREE_OPERAND (exp, 0),
8221                              ignore ? const0_rtx : NULL_RTX, VOIDmode,
8222                              (modifier == EXPAND_INITIALIZER
8223                               ? modifier : EXPAND_CONST_ADDRESS));
8224
8225           /* If we are going to ignore the result, OP0 will have been set
8226              to const0_rtx, so just return it.  Don't get confused and
8227              think we are taking the address of the constant.  */
8228           if (ignore)
8229             return op0;
8230
8231           op0 = protect_from_queue (op0, 0);
8232
8233           /* We would like the object in memory.  If it is a constant, we can
8234              have it be statically allocated into memory.  For a non-constant,
8235              we need to allocate some memory and store the value into it.  */
8236
8237           if (CONSTANT_P (op0))
8238             op0 = force_const_mem (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))),
8239                                    op0);
8240           else if (GET_CODE (op0) == MEM)
8241             {
8242               mark_temp_addr_taken (op0);
8243               temp = XEXP (op0, 0);
8244             }
8245
8246           else if (GET_CODE (op0) == REG || GET_CODE (op0) == SUBREG
8247                    || GET_CODE (op0) == CONCAT || GET_CODE (op0) == ADDRESSOF)
8248             {
8249               /* If this object is in a register, it must be not
8250                  be BLKmode.  */
8251               tree inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
8252               rtx memloc = assign_temp (inner_type, 1, 1, 1);
8253
8254               mark_temp_addr_taken (memloc);
8255               emit_move_insn (memloc, op0);
8256               op0 = memloc;
8257             }
8258
8259           if (GET_CODE (op0) != MEM)
8260             abort ();
8261
8262           if (modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER)
8263             {
8264               temp = XEXP (op0, 0);
8265 #ifdef POINTERS_EXTEND_UNSIGNED
8266               if (GET_MODE (temp) == Pmode && GET_MODE (temp) != mode
8267                   && mode == ptr_mode)
8268                 temp = convert_memory_address (ptr_mode, temp);
8269 #endif
8270               return temp;
8271             }
8272
8273           op0 = force_operand (XEXP (op0, 0), target);
8274         }
8275
8276       if (flag_force_addr && GET_CODE (op0) != REG)
8277         op0 = force_reg (Pmode, op0);
8278
8279       if (GET_CODE (op0) == REG
8280           && ! REG_USERVAR_P (op0))
8281         mark_reg_pointer (op0, TYPE_ALIGN (TREE_TYPE (type)) / BITS_PER_UNIT);
8282
8283       /* If we might have had a temp slot, add an equivalent address
8284          for it.  */
8285       if (temp != 0)
8286         update_temp_slot_address (temp, op0);
8287
8288 #ifdef POINTERS_EXTEND_UNSIGNED
8289       if (GET_MODE (op0) == Pmode && GET_MODE (op0) != mode
8290           && mode == ptr_mode)
8291         op0 = convert_memory_address (ptr_mode, op0);
8292 #endif
8293
8294       return op0;
8295
8296     case ENTRY_VALUE_EXPR:
8297       abort ();
8298
8299     /* COMPLEX type for Extended Pascal & Fortran  */
8300     case COMPLEX_EXPR:
8301       {
8302         enum machine_mode mode = TYPE_MODE (TREE_TYPE (TREE_TYPE (exp)));
8303         rtx insns;
8304
8305         /* Get the rtx code of the operands.  */
8306         op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, 0);
8307         op1 = expand_expr (TREE_OPERAND (exp, 1), 0, VOIDmode, 0);
8308
8309         if (! target)
8310           target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
8311
8312         start_sequence ();
8313
8314         /* Move the real (op0) and imaginary (op1) parts to their location.  */
8315         emit_move_insn (gen_realpart (mode, target), op0);
8316         emit_move_insn (gen_imagpart (mode, target), op1);
8317
8318         insns = get_insns ();
8319         end_sequence ();
8320
8321         /* Complex construction should appear as a single unit.  */
8322         /* If TARGET is a CONCAT, we got insns like RD = RS, ID = IS,
8323            each with a separate pseudo as destination.
8324            It's not correct for flow to treat them as a unit.  */
8325         if (GET_CODE (target) != CONCAT)
8326           emit_no_conflict_block (insns, target, op0, op1, NULL_RTX);
8327         else
8328           emit_insns (insns);
8329
8330         return target;
8331       }
8332
8333     case REALPART_EXPR:
8334       op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, 0);
8335       return gen_realpart (mode, op0);
8336
8337     case IMAGPART_EXPR:
8338       op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, 0);
8339       return gen_imagpart (mode, op0);
8340
8341     case CONJ_EXPR:
8342       {
8343         enum machine_mode partmode = TYPE_MODE (TREE_TYPE (TREE_TYPE (exp)));
8344         rtx imag_t;
8345         rtx insns;
8346
8347         op0  = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, 0);
8348
8349         if (! target)
8350           target = gen_reg_rtx (mode);
8351
8352         start_sequence ();
8353
8354         /* Store the realpart and the negated imagpart to target.  */
8355         emit_move_insn (gen_realpart (partmode, target),
8356                         gen_realpart (partmode, op0));
8357
8358         imag_t = gen_imagpart (partmode, target);
8359         temp = expand_unop (partmode, neg_optab,
8360                                gen_imagpart (partmode, op0), imag_t, 0);
8361         if (temp != imag_t)
8362           emit_move_insn (imag_t, temp);
8363
8364         insns = get_insns ();
8365         end_sequence ();
8366
8367         /* Conjugate should appear as a single unit
8368            If TARGET is a CONCAT, we got insns like RD = RS, ID = - IS,
8369            each with a separate pseudo as destination.
8370            It's not correct for flow to treat them as a unit.  */
8371         if (GET_CODE (target) != CONCAT)
8372           emit_no_conflict_block (insns, target, op0, NULL_RTX, NULL_RTX);
8373         else
8374           emit_insns (insns);
8375
8376         return target;
8377       }
8378
8379     case TRY_CATCH_EXPR:
8380       {
8381         tree handler = TREE_OPERAND (exp, 1);
8382
8383         expand_eh_region_start ();
8384
8385         op0 = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, 0);
8386
8387         expand_eh_region_end (handler);
8388
8389         return op0;
8390       }
8391
8392     case TRY_FINALLY_EXPR:
8393       {
8394         tree try_block = TREE_OPERAND (exp, 0);
8395         tree finally_block = TREE_OPERAND (exp, 1);
8396         rtx finally_label = gen_label_rtx ();
8397         rtx done_label = gen_label_rtx ();
8398         rtx return_link = gen_reg_rtx (Pmode);
8399         tree cleanup = build (GOTO_SUBROUTINE_EXPR, void_type_node,
8400                               (tree) finally_label, (tree) return_link);
8401         TREE_SIDE_EFFECTS (cleanup) = 1;
8402
8403         /* Start a new binding layer that will keep track of all cleanup
8404            actions to be performed.  */
8405         expand_start_bindings (2);
8406
8407         target_temp_slot_level = temp_slot_level;
8408
8409         expand_decl_cleanup (NULL_TREE, cleanup);
8410         op0 = expand_expr (try_block, target, tmode, modifier);
8411
8412         preserve_temp_slots (op0);
8413         expand_end_bindings (NULL_TREE, 0, 0);
8414         emit_jump (done_label);
8415         emit_label (finally_label);
8416         expand_expr (finally_block, const0_rtx, VOIDmode, 0);
8417         emit_indirect_jump (return_link);
8418         emit_label (done_label);
8419         return op0;
8420       }
8421
8422       case GOTO_SUBROUTINE_EXPR:
8423       {
8424         rtx subr = (rtx) TREE_OPERAND (exp, 0);
8425         rtx return_link = *(rtx *) &TREE_OPERAND (exp, 1);
8426         rtx return_address = gen_label_rtx ();
8427         emit_move_insn (return_link, gen_rtx_LABEL_REF (Pmode, return_address));
8428         emit_jump (subr);
8429         emit_label (return_address);
8430         return const0_rtx;
8431       }
8432
8433     case POPDCC_EXPR:
8434       {
8435         rtx dcc = get_dynamic_cleanup_chain ();
8436         emit_move_insn (dcc, validize_mem (gen_rtx_MEM (Pmode, dcc)));
8437         return const0_rtx;
8438       }
8439
8440     case POPDHC_EXPR:
8441       {
8442         rtx dhc = get_dynamic_handler_chain ();
8443         emit_move_insn (dhc, validize_mem (gen_rtx_MEM (Pmode, dhc)));
8444         return const0_rtx;
8445       }
8446
8447     case VA_ARG_EXPR:
8448       return expand_builtin_va_arg (TREE_OPERAND (exp, 0), type);
8449
8450     default:
8451       return (*lang_expand_expr) (exp, original_target, tmode, modifier);
8452     }
8453
8454   /* Here to do an ordinary binary operator, generating an instruction
8455      from the optab already placed in `this_optab'.  */
8456  binop:
8457   preexpand_calls (exp);
8458   if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1), 1))
8459     subtarget = 0;
8460   op0 = expand_expr (TREE_OPERAND (exp, 0), subtarget, VOIDmode, 0);
8461   op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
8462  binop2:
8463   temp = expand_binop (mode, this_optab, op0, op1, target,
8464                        unsignedp, OPTAB_LIB_WIDEN);
8465   if (temp == 0)
8466     abort ();
8467   return temp;
8468 }
8469 \f
8470 /* Similar to expand_expr, except that we don't specify a target, target
8471    mode, or modifier and we return the alignment of the inner type.  This is
8472    used in cases where it is not necessary to align the result to the
8473    alignment of its type as long as we know the alignment of the result, for
8474    example for comparisons of BLKmode values.  */
8475
8476 static rtx
8477 expand_expr_unaligned (exp, palign)
8478      register tree exp;
8479      unsigned int *palign;
8480 {
8481   register rtx op0;
8482   tree type = TREE_TYPE (exp);
8483   register enum machine_mode mode = TYPE_MODE (type);
8484
8485   /* Default the alignment we return to that of the type.  */
8486   *palign = TYPE_ALIGN (type);
8487
8488   /* The only cases in which we do anything special is if the resulting mode
8489      is BLKmode.  */
8490   if (mode != BLKmode)
8491     return expand_expr (exp, NULL_RTX, VOIDmode, EXPAND_NORMAL);
8492
8493   switch (TREE_CODE (exp))
8494     {
8495     case CONVERT_EXPR:
8496     case NOP_EXPR:
8497     case NON_LVALUE_EXPR:
8498       /* Conversions between BLKmode values don't change the underlying
8499          alignment or value.  */
8500       if (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == BLKmode)
8501         return expand_expr_unaligned (TREE_OPERAND (exp, 0), palign);
8502       break;
8503
8504     case ARRAY_REF:
8505       /* Much of the code for this case is copied directly from expand_expr.
8506          We need to duplicate it here because we will do something different
8507          in the fall-through case, so we need to handle the same exceptions
8508          it does.  */
8509       {
8510         tree array = TREE_OPERAND (exp, 0);
8511         tree domain = TYPE_DOMAIN (TREE_TYPE (array));
8512         tree low_bound = domain ? TYPE_MIN_VALUE (domain) : integer_zero_node;
8513         tree index = convert (sizetype, TREE_OPERAND (exp, 1));
8514         HOST_WIDE_INT i;
8515
8516         if (TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) != ARRAY_TYPE)
8517           abort ();
8518
8519         /* Optimize the special-case of a zero lower bound.
8520
8521            We convert the low_bound to sizetype to avoid some problems
8522            with constant folding.  (E.g. suppose the lower bound is 1,
8523            and its mode is QI.  Without the conversion,  (ARRAY
8524            +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
8525            +INDEX), which becomes (ARRAY+255+INDEX).  Oops!)  */
8526
8527         if (! integer_zerop (low_bound))
8528           index = size_diffop (index, convert (sizetype, low_bound));
8529
8530         /* If this is a constant index into a constant array,
8531            just get the value from the array.  Handle both the cases when
8532            we have an explicit constructor and when our operand is a variable
8533            that was declared const.  */
8534
8535         if (TREE_CODE (array) == CONSTRUCTOR && ! TREE_SIDE_EFFECTS (array)
8536             && 0 > compare_tree_int (index,
8537                                      list_length (CONSTRUCTOR_ELTS
8538                                                   (TREE_OPERAND (exp, 0)))))
8539           {
8540             tree elem;
8541
8542             for (elem = CONSTRUCTOR_ELTS (TREE_OPERAND (exp, 0)),
8543                  i = TREE_INT_CST_LOW (index);
8544                  elem != 0 && i != 0; i--, elem = TREE_CHAIN (elem))
8545               ;
8546
8547             if (elem)
8548               return expand_expr_unaligned (fold (TREE_VALUE (elem)), palign);
8549           }
8550
8551         else if (optimize >= 1
8552                  && TREE_READONLY (array) && ! TREE_SIDE_EFFECTS (array)
8553                  && TREE_CODE (array) == VAR_DECL && DECL_INITIAL (array)
8554                  && TREE_CODE (DECL_INITIAL (array)) != ERROR_MARK)
8555           {
8556             if (TREE_CODE (index) == INTEGER_CST)
8557               {
8558                 tree init = DECL_INITIAL (array);
8559
8560                 if (TREE_CODE (init) == CONSTRUCTOR)
8561                   {
8562                     tree elem;
8563
8564                     for (elem = CONSTRUCTOR_ELTS (init);
8565                          ! tree_int_cst_equal (TREE_PURPOSE (elem), index);
8566                          elem = TREE_CHAIN (elem))
8567                       ;
8568
8569                     if (elem)
8570                       return expand_expr_unaligned (fold (TREE_VALUE (elem)),
8571                                                     palign);
8572                   }
8573               }
8574           }
8575       }
8576
8577       /* ... fall through ... */
8578
8579     case COMPONENT_REF:
8580     case BIT_FIELD_REF:
8581       /* If the operand is a CONSTRUCTOR, we can just extract the
8582          appropriate field if it is present.  Don't do this if we have
8583          already written the data since we want to refer to that copy
8584          and varasm.c assumes that's what we'll do.  */
8585       if (TREE_CODE (exp) != ARRAY_REF
8586           && TREE_CODE (TREE_OPERAND (exp, 0)) == CONSTRUCTOR
8587           && TREE_CST_RTL (TREE_OPERAND (exp, 0)) == 0)
8588         {
8589           tree elt;
8590
8591           for (elt = CONSTRUCTOR_ELTS (TREE_OPERAND (exp, 0)); elt;
8592                elt = TREE_CHAIN (elt))
8593             if (TREE_PURPOSE (elt) == TREE_OPERAND (exp, 1))
8594               /* Note that unlike the case in expand_expr, we know this is
8595                  BLKmode and hence not an integer.  */
8596               return expand_expr_unaligned (TREE_VALUE (elt), palign);
8597         }
8598
8599       {
8600         enum machine_mode mode1;
8601         HOST_WIDE_INT bitsize, bitpos;
8602         tree offset;
8603         int volatilep = 0;
8604         unsigned int alignment;
8605         int unsignedp;
8606         tree tem = get_inner_reference (exp, &bitsize, &bitpos, &offset,
8607                                         &mode1, &unsignedp, &volatilep,
8608                                         &alignment);
8609
8610         /* If we got back the original object, something is wrong.  Perhaps
8611            we are evaluating an expression too early.  In any event, don't
8612            infinitely recurse.  */
8613         if (tem == exp)
8614           abort ();
8615
8616         op0 = expand_expr (tem, NULL_RTX, VOIDmode, EXPAND_NORMAL);
8617
8618         /* If this is a constant, put it into a register if it is a
8619            legitimate constant and OFFSET is 0 and memory if it isn't.  */
8620         if (CONSTANT_P (op0))
8621           {
8622             enum machine_mode inner_mode = TYPE_MODE (TREE_TYPE (tem));
8623
8624             if (inner_mode != BLKmode && LEGITIMATE_CONSTANT_P (op0)
8625                 && offset == 0)
8626               op0 = force_reg (inner_mode, op0);
8627             else
8628               op0 = validize_mem (force_const_mem (inner_mode, op0));
8629           }
8630
8631         if (offset != 0)
8632           {
8633             rtx offset_rtx = expand_expr (offset, NULL_RTX, VOIDmode, 0);
8634
8635             /* If this object is in a register, put it into memory.
8636                This case can't occur in C, but can in Ada if we have
8637                unchecked conversion of an expression from a scalar type to
8638                an array or record type.  */
8639             if (GET_CODE (op0) == REG || GET_CODE (op0) == SUBREG
8640                 || GET_CODE (op0) == CONCAT || GET_CODE (op0) == ADDRESSOF)
8641               {
8642                 rtx memloc = assign_temp (TREE_TYPE (tem), 1, 1, 1);
8643
8644                 mark_temp_addr_taken (memloc);
8645                 emit_move_insn (memloc, op0);
8646                 op0 = memloc;
8647               }
8648
8649             if (GET_CODE (op0) != MEM)
8650               abort ();
8651
8652             if (GET_MODE (offset_rtx) != ptr_mode)
8653               {
8654 #ifdef POINTERS_EXTEND_UNSIGNED
8655                 offset_rtx = convert_memory_address (ptr_mode, offset_rtx);
8656 #else
8657                 offset_rtx = convert_to_mode (ptr_mode, offset_rtx, 0);
8658 #endif
8659               }
8660
8661             op0 = change_address (op0, VOIDmode,
8662                                   gen_rtx_PLUS (ptr_mode, XEXP (op0, 0),
8663                                                 force_reg (ptr_mode,
8664                                                            offset_rtx)));
8665           }
8666
8667         /* Don't forget about volatility even if this is a bitfield.  */
8668         if (GET_CODE (op0) == MEM && volatilep && ! MEM_VOLATILE_P (op0))
8669           {
8670             op0 = copy_rtx (op0);
8671             MEM_VOLATILE_P (op0) = 1;
8672           }
8673
8674         /* Check the access.  */
8675         if (current_function_check_memory_usage && GET_CODE (op0) == MEM)
8676           {
8677             rtx to;
8678             int size;
8679
8680             to = plus_constant (XEXP (op0, 0), (bitpos / BITS_PER_UNIT));
8681             size = (bitpos % BITS_PER_UNIT) + bitsize + BITS_PER_UNIT - 1;
8682
8683             /* Check the access right of the pointer.  */
8684             if (size > BITS_PER_UNIT)
8685               emit_library_call (chkr_check_addr_libfunc, 1, VOIDmode, 3,
8686                                  to, ptr_mode, GEN_INT (size / BITS_PER_UNIT),
8687                                  TYPE_MODE (sizetype),
8688                                  GEN_INT (MEMORY_USE_RO),
8689                                  TYPE_MODE (integer_type_node));
8690           }
8691
8692         /* In cases where an aligned union has an unaligned object
8693            as a field, we might be extracting a BLKmode value from
8694            an integer-mode (e.g., SImode) object.  Handle this case
8695            by doing the extract into an object as wide as the field
8696            (which we know to be the width of a basic mode), then
8697            storing into memory, and changing the mode to BLKmode.
8698            If we ultimately want the address (EXPAND_CONST_ADDRESS or
8699            EXPAND_INITIALIZER), then we must not copy to a temporary.  */
8700         if (mode1 == VOIDmode
8701             || GET_CODE (op0) == REG || GET_CODE (op0) == SUBREG
8702             || (SLOW_UNALIGNED_ACCESS (mode1, alignment)
8703                 && (TYPE_ALIGN (type) > alignment
8704                     || bitpos % TYPE_ALIGN (type) != 0)))
8705           {
8706             enum machine_mode ext_mode = mode_for_size (bitsize, MODE_INT, 1);
8707
8708             if (ext_mode == BLKmode)
8709               {
8710                 /* In this case, BITPOS must start at a byte boundary.  */
8711                 if (GET_CODE (op0) != MEM
8712                     || bitpos % BITS_PER_UNIT != 0)
8713                   abort ();
8714
8715                 op0 = change_address (op0, VOIDmode,
8716                                       plus_constant (XEXP (op0, 0),
8717                                                      bitpos / BITS_PER_UNIT));
8718               }
8719             else
8720               {
8721                 rtx new = assign_stack_temp (ext_mode,
8722                                              bitsize / BITS_PER_UNIT, 0);
8723
8724                 op0 = extract_bit_field (validize_mem (op0), bitsize, bitpos,
8725                                          unsignedp, NULL_RTX, ext_mode,
8726                                          ext_mode, alignment,
8727                                          int_size_in_bytes (TREE_TYPE (tem)));
8728
8729                 /* If the result is a record type and BITSIZE is narrower than
8730                    the mode of OP0, an integral mode, and this is a big endian
8731                    machine, we must put the field into the high-order bits.  */
8732                 if (TREE_CODE (type) == RECORD_TYPE && BYTES_BIG_ENDIAN
8733                     && GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT
8734                     && bitsize < GET_MODE_BITSIZE (GET_MODE (op0)))
8735                   op0 = expand_shift (LSHIFT_EXPR, GET_MODE (op0), op0,
8736                                       size_int (GET_MODE_BITSIZE
8737                                                 (GET_MODE (op0))
8738                                                 - bitsize),
8739                                       op0, 1);
8740
8741
8742                 emit_move_insn (new, op0);
8743                 op0 = copy_rtx (new);
8744                 PUT_MODE (op0, BLKmode);
8745               }
8746           }
8747         else
8748           /* Get a reference to just this component.  */
8749           op0 = change_address (op0, mode1,
8750                                   plus_constant (XEXP (op0, 0),
8751                                                  (bitpos / BITS_PER_UNIT)));
8752
8753         MEM_ALIAS_SET (op0) = get_alias_set (exp);
8754
8755         /* Adjust the alignment in case the bit position is not
8756            a multiple of the alignment of the inner object.  */
8757         while (bitpos % alignment != 0)
8758           alignment >>= 1;
8759
8760         if (GET_CODE (XEXP (op0, 0)) == REG)
8761           mark_reg_pointer (XEXP (op0, 0), alignment / BITS_PER_UNIT);
8762
8763         MEM_IN_STRUCT_P (op0) = 1;
8764         MEM_VOLATILE_P (op0) |= volatilep;
8765
8766         *palign = alignment;
8767         return op0;
8768       }
8769
8770     default:
8771       break;
8772
8773     }
8774
8775   return expand_expr (exp, NULL_RTX, VOIDmode, EXPAND_NORMAL);
8776 }
8777 \f
8778 /* Return the tree node if a ARG corresponds to a string constant or zero
8779    if it doesn't.  If we return non-zero, set *PTR_OFFSET to the offset
8780    in bytes within the string that ARG is accessing.  The type of the
8781    offset will be `sizetype'.  */
8782
8783 tree
8784 string_constant (arg, ptr_offset)
8785      tree arg;
8786      tree *ptr_offset;
8787 {
8788   STRIP_NOPS (arg);
8789
8790   if (TREE_CODE (arg) == ADDR_EXPR
8791       && TREE_CODE (TREE_OPERAND (arg, 0)) == STRING_CST)
8792     {
8793       *ptr_offset = size_zero_node;
8794       return TREE_OPERAND (arg, 0);
8795     }
8796   else if (TREE_CODE (arg) == PLUS_EXPR)
8797     {
8798       tree arg0 = TREE_OPERAND (arg, 0);
8799       tree arg1 = TREE_OPERAND (arg, 1);
8800
8801       STRIP_NOPS (arg0);
8802       STRIP_NOPS (arg1);
8803
8804       if (TREE_CODE (arg0) == ADDR_EXPR
8805           && TREE_CODE (TREE_OPERAND (arg0, 0)) == STRING_CST)
8806         {
8807           *ptr_offset = convert (sizetype, arg1);
8808           return TREE_OPERAND (arg0, 0);
8809         }
8810       else if (TREE_CODE (arg1) == ADDR_EXPR
8811                && TREE_CODE (TREE_OPERAND (arg1, 0)) == STRING_CST)
8812         {
8813           *ptr_offset = convert (sizetype, arg0);
8814           return TREE_OPERAND (arg1, 0);
8815         }
8816     }
8817
8818   return 0;
8819 }
8820 \f
8821 /* Expand code for a post- or pre- increment or decrement
8822    and return the RTX for the result.
8823    POST is 1 for postinc/decrements and 0 for preinc/decrements.  */
8824
8825 static rtx
8826 expand_increment (exp, post, ignore)
8827      register tree exp;
8828      int post, ignore;
8829 {
8830   register rtx op0, op1;
8831   register rtx temp, value;
8832   register tree incremented = TREE_OPERAND (exp, 0);
8833   optab this_optab = add_optab;
8834   int icode;
8835   enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
8836   int op0_is_copy = 0;
8837   int single_insn = 0;
8838   /* 1 means we can't store into OP0 directly,
8839      because it is a subreg narrower than a word,
8840      and we don't dare clobber the rest of the word.  */
8841   int bad_subreg = 0;
8842
8843   /* Stabilize any component ref that might need to be
8844      evaluated more than once below.  */
8845   if (!post
8846       || TREE_CODE (incremented) == BIT_FIELD_REF
8847       || (TREE_CODE (incremented) == COMPONENT_REF
8848           && (TREE_CODE (TREE_OPERAND (incremented, 0)) != INDIRECT_REF
8849               || DECL_BIT_FIELD (TREE_OPERAND (incremented, 1)))))
8850     incremented = stabilize_reference (incremented);
8851   /* Nested *INCREMENT_EXPRs can happen in C++.  We must force innermost
8852      ones into save exprs so that they don't accidentally get evaluated
8853      more than once by the code below.  */
8854   if (TREE_CODE (incremented) == PREINCREMENT_EXPR
8855       || TREE_CODE (incremented) == PREDECREMENT_EXPR)
8856     incremented = save_expr (incremented);
8857
8858   /* Compute the operands as RTX.
8859      Note whether OP0 is the actual lvalue or a copy of it:
8860      I believe it is a copy iff it is a register or subreg
8861      and insns were generated in computing it.   */
8862
8863   temp = get_last_insn ();
8864   op0 = expand_expr (incremented, NULL_RTX, VOIDmode, EXPAND_MEMORY_USE_RW);
8865
8866   /* If OP0 is a SUBREG made for a promoted variable, we cannot increment
8867      in place but instead must do sign- or zero-extension during assignment,
8868      so we copy it into a new register and let the code below use it as
8869      a copy.
8870
8871      Note that we can safely modify this SUBREG since it is know not to be
8872      shared (it was made by the expand_expr call above).  */
8873
8874   if (GET_CODE (op0) == SUBREG && SUBREG_PROMOTED_VAR_P (op0))
8875     {
8876       if (post)
8877         SUBREG_REG (op0) = copy_to_reg (SUBREG_REG (op0));
8878       else
8879         bad_subreg = 1;
8880     }
8881   else if (GET_CODE (op0) == SUBREG
8882            && GET_MODE_BITSIZE (GET_MODE (op0)) < BITS_PER_WORD)
8883     {
8884       /* We cannot increment this SUBREG in place.  If we are
8885          post-incrementing, get a copy of the old value.  Otherwise,
8886          just mark that we cannot increment in place.  */
8887       if (post)
8888         op0 = copy_to_reg (op0);
8889       else
8890         bad_subreg = 1;
8891     }
8892
8893   op0_is_copy = ((GET_CODE (op0) == SUBREG || GET_CODE (op0) == REG)
8894                  && temp != get_last_insn ());
8895   op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode,
8896                      EXPAND_MEMORY_USE_BAD);
8897
8898   /* Decide whether incrementing or decrementing.  */
8899   if (TREE_CODE (exp) == POSTDECREMENT_EXPR
8900       || TREE_CODE (exp) == PREDECREMENT_EXPR)
8901     this_optab = sub_optab;
8902
8903   /* Convert decrement by a constant into a negative increment.  */
8904   if (this_optab == sub_optab
8905       && GET_CODE (op1) == CONST_INT)
8906     {
8907       op1 = GEN_INT (- INTVAL (op1));
8908       this_optab = add_optab;
8909     }
8910
8911   /* For a preincrement, see if we can do this with a single instruction.  */
8912   if (!post)
8913     {
8914       icode = (int) this_optab->handlers[(int) mode].insn_code;
8915       if (icode != (int) CODE_FOR_nothing
8916           /* Make sure that OP0 is valid for operands 0 and 1
8917              of the insn we want to queue.  */
8918           && (*insn_data[icode].operand[0].predicate) (op0, mode)
8919           && (*insn_data[icode].operand[1].predicate) (op0, mode)
8920           && (*insn_data[icode].operand[2].predicate) (op1, mode))
8921         single_insn = 1;
8922     }
8923
8924   /* If OP0 is not the actual lvalue, but rather a copy in a register,
8925      then we cannot just increment OP0.  We must therefore contrive to
8926      increment the original value.  Then, for postincrement, we can return
8927      OP0 since it is a copy of the old value.  For preincrement, expand here
8928      unless we can do it with a single insn.
8929
8930      Likewise if storing directly into OP0 would clobber high bits
8931      we need to preserve (bad_subreg).  */
8932   if (op0_is_copy || (!post && !single_insn) || bad_subreg)
8933     {
8934       /* This is the easiest way to increment the value wherever it is.
8935          Problems with multiple evaluation of INCREMENTED are prevented
8936          because either (1) it is a component_ref or preincrement,
8937          in which case it was stabilized above, or (2) it is an array_ref
8938          with constant index in an array in a register, which is
8939          safe to reevaluate.  */
8940       tree newexp = build (((TREE_CODE (exp) == POSTDECREMENT_EXPR
8941                              || TREE_CODE (exp) == PREDECREMENT_EXPR)
8942                             ? MINUS_EXPR : PLUS_EXPR),
8943                            TREE_TYPE (exp),
8944                            incremented,
8945                            TREE_OPERAND (exp, 1));
8946
8947       while (TREE_CODE (incremented) == NOP_EXPR
8948              || TREE_CODE (incremented) == CONVERT_EXPR)
8949         {
8950           newexp = convert (TREE_TYPE (incremented), newexp);
8951           incremented = TREE_OPERAND (incremented, 0);
8952         }
8953
8954       temp = expand_assignment (incremented, newexp, ! post && ! ignore , 0);
8955       return post ? op0 : temp;
8956     }
8957
8958   if (post)
8959     {
8960       /* We have a true reference to the value in OP0.
8961          If there is an insn to add or subtract in this mode, queue it.
8962          Queueing the increment insn avoids the register shuffling
8963          that often results if we must increment now and first save
8964          the old value for subsequent use.  */
8965
8966 #if 0  /* Turned off to avoid making extra insn for indexed memref.  */
8967       op0 = stabilize (op0);
8968 #endif
8969
8970       icode = (int) this_optab->handlers[(int) mode].insn_code;
8971       if (icode != (int) CODE_FOR_nothing
8972           /* Make sure that OP0 is valid for operands 0 and 1
8973              of the insn we want to queue.  */
8974           && (*insn_data[icode].operand[0].predicate) (op0, mode)
8975           && (*insn_data[icode].operand[1].predicate) (op0, mode))
8976         {
8977           if (! (*insn_data[icode].operand[2].predicate) (op1, mode))
8978             op1 = force_reg (mode, op1);
8979
8980           return enqueue_insn (op0, GEN_FCN (icode) (op0, op0, op1));
8981         }
8982       if (icode != (int) CODE_FOR_nothing && GET_CODE (op0) == MEM)
8983         {
8984           rtx addr = (general_operand (XEXP (op0, 0), mode)
8985                       ? force_reg (Pmode, XEXP (op0, 0))
8986                       : copy_to_reg (XEXP (op0, 0)));
8987           rtx temp, result;
8988
8989           op0 = change_address (op0, VOIDmode, addr);
8990           temp = force_reg (GET_MODE (op0), op0);
8991           if (! (*insn_data[icode].operand[2].predicate) (op1, mode))
8992             op1 = force_reg (mode, op1);
8993
8994           /* The increment queue is LIFO, thus we have to `queue'
8995              the instructions in reverse order.  */
8996           enqueue_insn (op0, gen_move_insn (op0, temp));
8997           result = enqueue_insn (temp, GEN_FCN (icode) (temp, temp, op1));
8998           return result;
8999         }
9000     }
9001
9002   /* Preincrement, or we can't increment with one simple insn.  */
9003   if (post)
9004     /* Save a copy of the value before inc or dec, to return it later.  */
9005     temp = value = copy_to_reg (op0);
9006   else
9007     /* Arrange to return the incremented value.  */
9008     /* Copy the rtx because expand_binop will protect from the queue,
9009        and the results of that would be invalid for us to return
9010        if our caller does emit_queue before using our result.  */
9011     temp = copy_rtx (value = op0);
9012
9013   /* Increment however we can.  */
9014   op1 = expand_binop (mode, this_optab, value, op1,
9015                       current_function_check_memory_usage ? NULL_RTX : op0,
9016                       TREE_UNSIGNED (TREE_TYPE (exp)), OPTAB_LIB_WIDEN);
9017   /* Make sure the value is stored into OP0.  */
9018   if (op1 != op0)
9019     emit_move_insn (op0, op1);
9020
9021   return temp;
9022 }
9023 \f
9024 /* Expand all function calls contained within EXP, innermost ones first.
9025    But don't look within expressions that have sequence points.
9026    For each CALL_EXPR, record the rtx for its value
9027    in the CALL_EXPR_RTL field.  */
9028
9029 static void
9030 preexpand_calls (exp)
9031      tree exp;
9032 {
9033   register int nops, i;
9034   int type = TREE_CODE_CLASS (TREE_CODE (exp));
9035
9036   if (! do_preexpand_calls)
9037     return;
9038
9039   /* Only expressions and references can contain calls.  */
9040
9041   if (type != 'e' && type != '<' && type != '1' && type != '2' && type != 'r')
9042     return;
9043
9044   switch (TREE_CODE (exp))
9045     {
9046     case CALL_EXPR:
9047       /* Do nothing if already expanded.  */
9048       if (CALL_EXPR_RTL (exp) != 0
9049           /* Do nothing if the call returns a variable-sized object.  */
9050           || TREE_CODE (TYPE_SIZE (TREE_TYPE(exp))) != INTEGER_CST
9051           /* Do nothing to built-in functions.  */
9052           || (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
9053               && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
9054                   == FUNCTION_DECL)
9055               && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))))
9056         return;
9057
9058       CALL_EXPR_RTL (exp) = expand_call (exp, NULL_RTX, 0);
9059       return;
9060
9061     case COMPOUND_EXPR:
9062     case COND_EXPR:
9063     case TRUTH_ANDIF_EXPR:
9064     case TRUTH_ORIF_EXPR:
9065       /* If we find one of these, then we can be sure
9066          the adjust will be done for it (since it makes jumps).
9067          Do it now, so that if this is inside an argument
9068          of a function, we don't get the stack adjustment
9069          after some other args have already been pushed.  */
9070       do_pending_stack_adjust ();
9071       return;
9072
9073     case BLOCK:
9074     case RTL_EXPR:
9075     case WITH_CLEANUP_EXPR:
9076     case CLEANUP_POINT_EXPR:
9077     case TRY_CATCH_EXPR:
9078       return;
9079
9080     case SAVE_EXPR:
9081       if (SAVE_EXPR_RTL (exp) != 0)
9082         return;
9083
9084     default:
9085       break;
9086     }
9087
9088   nops = tree_code_length[(int) TREE_CODE (exp)];
9089   for (i = 0; i < nops; i++)
9090     if (TREE_OPERAND (exp, i) != 0)
9091       {
9092         if (TREE_CODE (exp) == TARGET_EXPR && i == 2)
9093           /* We don't need to preexpand the cleanup for a TARGET_EXPR.
9094              It doesn't happen before the call is made.  */
9095           ;
9096         else
9097           {
9098             type = TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, i)));
9099             if (type == 'e' || type == '<' || type == '1' || type == '2'
9100                 || type == 'r')
9101               preexpand_calls (TREE_OPERAND (exp, i));
9102           }
9103       }
9104 }
9105 \f
9106 /* At the start of a function, record that we have no previously-pushed
9107    arguments waiting to be popped.  */
9108
9109 void
9110 init_pending_stack_adjust ()
9111 {
9112   pending_stack_adjust = 0;
9113 }
9114
9115 /* When exiting from function, if safe, clear out any pending stack adjust
9116    so the adjustment won't get done.
9117
9118    Note, if the current function calls alloca, then it must have a
9119    frame pointer regardless of the value of flag_omit_frame_pointer.  */
9120
9121 void
9122 clear_pending_stack_adjust ()
9123 {
9124 #ifdef EXIT_IGNORE_STACK
9125   if (optimize > 0
9126       && (! flag_omit_frame_pointer || current_function_calls_alloca)
9127       && EXIT_IGNORE_STACK
9128       && ! (DECL_INLINE (current_function_decl) && ! flag_no_inline)
9129       && ! flag_inline_functions)
9130     pending_stack_adjust = 0;
9131 #endif
9132 }
9133
9134 /* Pop any previously-pushed arguments that have not been popped yet.  */
9135
9136 void
9137 do_pending_stack_adjust ()
9138 {
9139   if (inhibit_defer_pop == 0)
9140     {
9141       if (pending_stack_adjust != 0)
9142         adjust_stack (GEN_INT (pending_stack_adjust));
9143       pending_stack_adjust = 0;
9144     }
9145 }
9146 \f
9147 /* Expand conditional expressions.  */
9148
9149 /* Generate code to evaluate EXP and jump to LABEL if the value is zero.
9150    LABEL is an rtx of code CODE_LABEL, in this function and all the
9151    functions here.  */
9152
9153 void
9154 jumpifnot (exp, label)
9155      tree exp;
9156      rtx label;
9157 {
9158   do_jump (exp, label, NULL_RTX);
9159 }
9160
9161 /* Generate code to evaluate EXP and jump to LABEL if the value is nonzero.  */
9162
9163 void
9164 jumpif (exp, label)
9165      tree exp;
9166      rtx label;
9167 {
9168   do_jump (exp, NULL_RTX, label);
9169 }
9170
9171 /* Generate code to evaluate EXP and jump to IF_FALSE_LABEL if
9172    the result is zero, or IF_TRUE_LABEL if the result is one.
9173    Either of IF_FALSE_LABEL and IF_TRUE_LABEL may be zero,
9174    meaning fall through in that case.
9175
9176    do_jump always does any pending stack adjust except when it does not
9177    actually perform a jump.  An example where there is no jump
9178    is when EXP is `(foo (), 0)' and IF_FALSE_LABEL is null.
9179
9180    This function is responsible for optimizing cases such as
9181    &&, || and comparison operators in EXP.  */
9182
9183 void
9184 do_jump (exp, if_false_label, if_true_label)
9185      tree exp;
9186      rtx if_false_label, if_true_label;
9187 {
9188   register enum tree_code code = TREE_CODE (exp);
9189   /* Some cases need to create a label to jump to
9190      in order to properly fall through.
9191      These cases set DROP_THROUGH_LABEL nonzero.  */
9192   rtx drop_through_label = 0;
9193   rtx temp;
9194   int i;
9195   tree type;
9196   enum machine_mode mode;
9197
9198 #ifdef MAX_INTEGER_COMPUTATION_MODE
9199   check_max_integer_computation_mode (exp);
9200 #endif
9201
9202   emit_queue ();
9203
9204   switch (code)
9205     {
9206     case ERROR_MARK:
9207       break;
9208
9209     case INTEGER_CST:
9210       temp = integer_zerop (exp) ? if_false_label : if_true_label;
9211       if (temp)
9212         emit_jump (temp);
9213       break;
9214
9215 #if 0
9216       /* This is not true with #pragma weak  */
9217     case ADDR_EXPR:
9218       /* The address of something can never be zero.  */
9219       if (if_true_label)
9220         emit_jump (if_true_label);
9221       break;
9222 #endif
9223
9224     case NOP_EXPR:
9225       if (TREE_CODE (TREE_OPERAND (exp, 0)) == COMPONENT_REF
9226           || TREE_CODE (TREE_OPERAND (exp, 0)) == BIT_FIELD_REF
9227           || TREE_CODE (TREE_OPERAND (exp, 0)) == ARRAY_REF)
9228         goto normal;
9229     case CONVERT_EXPR:
9230       /* If we are narrowing the operand, we have to do the compare in the
9231          narrower mode.  */
9232       if ((TYPE_PRECISION (TREE_TYPE (exp))
9233            < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp, 0)))))
9234         goto normal;
9235     case NON_LVALUE_EXPR:
9236     case REFERENCE_EXPR:
9237     case ABS_EXPR:
9238     case NEGATE_EXPR:
9239     case LROTATE_EXPR:
9240     case RROTATE_EXPR:
9241       /* These cannot change zero->non-zero or vice versa.  */
9242       do_jump (TREE_OPERAND (exp, 0), if_false_label, if_true_label);
9243       break;
9244
9245     case WITH_RECORD_EXPR:
9246       /* Put the object on the placeholder list, recurse through our first
9247          operand, and pop the list.  */
9248       placeholder_list = tree_cons (TREE_OPERAND (exp, 1), NULL_TREE,
9249                                     placeholder_list);
9250       do_jump (TREE_OPERAND (exp, 0), if_false_label, if_true_label);
9251       placeholder_list = TREE_CHAIN (placeholder_list);
9252       break;
9253
9254 #if 0
9255       /* This is never less insns than evaluating the PLUS_EXPR followed by
9256          a test and can be longer if the test is eliminated.  */
9257     case PLUS_EXPR:
9258       /* Reduce to minus.  */
9259       exp = build (MINUS_EXPR, TREE_TYPE (exp),
9260                    TREE_OPERAND (exp, 0),
9261                    fold (build1 (NEGATE_EXPR, TREE_TYPE (TREE_OPERAND (exp, 1)),
9262                                  TREE_OPERAND (exp, 1))));
9263       /* Process as MINUS.  */
9264 #endif
9265
9266     case MINUS_EXPR:
9267       /* Non-zero iff operands of minus differ.  */
9268       do_compare_and_jump (build (NE_EXPR, TREE_TYPE (exp),
9269                                   TREE_OPERAND (exp, 0),
9270                                   TREE_OPERAND (exp, 1)),
9271                            NE, NE, if_false_label, if_true_label);
9272       break;
9273
9274     case BIT_AND_EXPR:
9275       /* If we are AND'ing with a small constant, do this comparison in the
9276          smallest type that fits.  If the machine doesn't have comparisons
9277          that small, it will be converted back to the wider comparison.
9278          This helps if we are testing the sign bit of a narrower object.
9279          combine can't do this for us because it can't know whether a
9280          ZERO_EXTRACT or a compare in a smaller mode exists, but we do.  */
9281
9282       if (! SLOW_BYTE_ACCESS
9283           && TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST
9284           && TYPE_PRECISION (TREE_TYPE (exp)) <= HOST_BITS_PER_WIDE_INT
9285           && (i = tree_floor_log2 (TREE_OPERAND (exp, 1))) >= 0
9286           && (mode = mode_for_size (i + 1, MODE_INT, 0)) != BLKmode
9287           && (type = type_for_mode (mode, 1)) != 0
9288           && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (exp))
9289           && (cmp_optab->handlers[(int) TYPE_MODE (type)].insn_code
9290               != CODE_FOR_nothing))
9291         {
9292           do_jump (convert (type, exp), if_false_label, if_true_label);
9293           break;
9294         }
9295       goto normal;
9296
9297     case TRUTH_NOT_EXPR:
9298       do_jump (TREE_OPERAND (exp, 0), if_true_label, if_false_label);
9299       break;
9300
9301     case TRUTH_ANDIF_EXPR:
9302       if (if_false_label == 0)
9303         if_false_label = drop_through_label = gen_label_rtx ();
9304       do_jump (TREE_OPERAND (exp, 0), if_false_label, NULL_RTX);
9305       start_cleanup_deferral ();
9306       do_jump (TREE_OPERAND (exp, 1), if_false_label, if_true_label);
9307       end_cleanup_deferral ();
9308       break;
9309
9310     case TRUTH_ORIF_EXPR:
9311       if (if_true_label == 0)
9312         if_true_label = drop_through_label = gen_label_rtx ();
9313       do_jump (TREE_OPERAND (exp, 0), NULL_RTX, if_true_label);
9314       start_cleanup_deferral ();
9315       do_jump (TREE_OPERAND (exp, 1), if_false_label, if_true_label);
9316       end_cleanup_deferral ();
9317       break;
9318
9319     case COMPOUND_EXPR:
9320       push_temp_slots ();
9321       expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode, 0);
9322       preserve_temp_slots (NULL_RTX);
9323       free_temp_slots ();
9324       pop_temp_slots ();
9325       emit_queue ();
9326       do_pending_stack_adjust ();
9327       do_jump (TREE_OPERAND (exp, 1), if_false_label, if_true_label);
9328       break;
9329
9330     case COMPONENT_REF:
9331     case BIT_FIELD_REF:
9332     case ARRAY_REF:
9333       {
9334         HOST_WIDE_INT bitsize, bitpos;
9335         int unsignedp;
9336         enum machine_mode mode;
9337         tree type;
9338         tree offset;
9339         int volatilep = 0;
9340         unsigned int alignment;
9341
9342         /* Get description of this reference.  We don't actually care
9343            about the underlying object here.  */
9344         get_inner_reference (exp, &bitsize, &bitpos, &offset, &mode,
9345                              &unsignedp, &volatilep, &alignment);
9346
9347         type = type_for_size (bitsize, unsignedp);
9348         if (! SLOW_BYTE_ACCESS
9349             && type != 0 && bitsize >= 0
9350             && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (exp))
9351             && (cmp_optab->handlers[(int) TYPE_MODE (type)].insn_code
9352                 != CODE_FOR_nothing))
9353           {
9354             do_jump (convert (type, exp), if_false_label, if_true_label);
9355             break;
9356           }
9357         goto normal;
9358       }
9359
9360     case COND_EXPR:
9361       /* Do (a ? 1 : 0) and (a ? 0 : 1) as special cases.  */
9362       if (integer_onep (TREE_OPERAND (exp, 1))
9363           && integer_zerop (TREE_OPERAND (exp, 2)))
9364         do_jump (TREE_OPERAND (exp, 0), if_false_label, if_true_label);
9365
9366       else if (integer_zerop (TREE_OPERAND (exp, 1))
9367                && integer_onep (TREE_OPERAND (exp, 2)))
9368         do_jump (TREE_OPERAND (exp, 0), if_true_label, if_false_label);
9369
9370       else
9371         {
9372           register rtx label1 = gen_label_rtx ();
9373           drop_through_label = gen_label_rtx ();
9374
9375           do_jump (TREE_OPERAND (exp, 0), label1, NULL_RTX);
9376
9377           start_cleanup_deferral ();
9378           /* Now the THEN-expression.  */
9379           do_jump (TREE_OPERAND (exp, 1),
9380                    if_false_label ? if_false_label : drop_through_label,
9381                    if_true_label ? if_true_label : drop_through_label);
9382           /* In case the do_jump just above never jumps.  */
9383           do_pending_stack_adjust ();
9384           emit_label (label1);
9385
9386           /* Now the ELSE-expression.  */
9387           do_jump (TREE_OPERAND (exp, 2),
9388                    if_false_label ? if_false_label : drop_through_label,
9389                    if_true_label ? if_true_label : drop_through_label);
9390           end_cleanup_deferral ();
9391         }
9392       break;
9393
9394     case EQ_EXPR:
9395       {
9396         tree inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
9397
9398         if (GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_COMPLEX_FLOAT
9399             || GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_COMPLEX_INT)
9400           {
9401             tree exp0 = save_expr (TREE_OPERAND (exp, 0));
9402             tree exp1 = save_expr (TREE_OPERAND (exp, 1));
9403             do_jump
9404               (fold
9405                (build (TRUTH_ANDIF_EXPR, TREE_TYPE (exp),
9406                        fold (build (EQ_EXPR, TREE_TYPE (exp),
9407                                     fold (build1 (REALPART_EXPR,
9408                                                   TREE_TYPE (inner_type),
9409                                                   exp0)),
9410                                     fold (build1 (REALPART_EXPR,
9411                                                   TREE_TYPE (inner_type),
9412                                                   exp1)))),
9413                        fold (build (EQ_EXPR, TREE_TYPE (exp),
9414                                     fold (build1 (IMAGPART_EXPR,
9415                                                   TREE_TYPE (inner_type),
9416                                                   exp0)),
9417                                     fold (build1 (IMAGPART_EXPR,
9418                                                   TREE_TYPE (inner_type),
9419                                                   exp1)))))),
9420                if_false_label, if_true_label);
9421           }
9422
9423         else if (integer_zerop (TREE_OPERAND (exp, 1)))
9424           do_jump (TREE_OPERAND (exp, 0), if_true_label, if_false_label);
9425
9426         else if (GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_INT
9427                  && !can_compare_p (EQ, TYPE_MODE (inner_type), ccp_jump))
9428           do_jump_by_parts_equality (exp, if_false_label, if_true_label);
9429         else
9430           do_compare_and_jump (exp, EQ, EQ, if_false_label, if_true_label);
9431         break;
9432       }
9433
9434     case NE_EXPR:
9435       {
9436         tree inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
9437
9438         if (GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_COMPLEX_FLOAT
9439             || GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_COMPLEX_INT)
9440           {
9441             tree exp0 = save_expr (TREE_OPERAND (exp, 0));
9442             tree exp1 = save_expr (TREE_OPERAND (exp, 1));
9443             do_jump
9444               (fold
9445                (build (TRUTH_ORIF_EXPR, TREE_TYPE (exp),
9446                        fold (build (NE_EXPR, TREE_TYPE (exp),
9447                                     fold (build1 (REALPART_EXPR,
9448                                                   TREE_TYPE (inner_type),
9449                                                   exp0)),
9450                                     fold (build1 (REALPART_EXPR,
9451                                                   TREE_TYPE (inner_type),
9452                                                   exp1)))),
9453                        fold (build (NE_EXPR, TREE_TYPE (exp),
9454                                     fold (build1 (IMAGPART_EXPR,
9455                                                   TREE_TYPE (inner_type),
9456                                                   exp0)),
9457                                     fold (build1 (IMAGPART_EXPR,
9458                                                   TREE_TYPE (inner_type),
9459                                                   exp1)))))),
9460                if_false_label, if_true_label);
9461           }
9462
9463         else if (integer_zerop (TREE_OPERAND (exp, 1)))
9464           do_jump (TREE_OPERAND (exp, 0), if_false_label, if_true_label);
9465
9466         else if (GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_INT
9467                  && !can_compare_p (NE, TYPE_MODE (inner_type), ccp_jump))
9468           do_jump_by_parts_equality (exp, if_true_label, if_false_label);
9469         else
9470           do_compare_and_jump (exp, NE, NE, if_false_label, if_true_label);
9471         break;
9472       }
9473
9474     case LT_EXPR:
9475       mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
9476       if (GET_MODE_CLASS (mode) == MODE_INT
9477           && ! can_compare_p (LT, mode, ccp_jump))
9478         do_jump_by_parts_greater (exp, 1, if_false_label, if_true_label);
9479       else
9480         do_compare_and_jump (exp, LT, LTU, if_false_label, if_true_label);
9481       break;
9482
9483     case LE_EXPR:
9484       mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
9485       if (GET_MODE_CLASS (mode) == MODE_INT
9486           && ! can_compare_p (LE, mode, ccp_jump))
9487         do_jump_by_parts_greater (exp, 0, if_true_label, if_false_label);
9488       else
9489         do_compare_and_jump (exp, LE, LEU, if_false_label, if_true_label);
9490       break;
9491
9492     case GT_EXPR:
9493       mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
9494       if (GET_MODE_CLASS (mode) == MODE_INT
9495           && ! can_compare_p (GT, mode, ccp_jump))
9496         do_jump_by_parts_greater (exp, 0, if_false_label, if_true_label);
9497       else
9498         do_compare_and_jump (exp, GT, GTU, if_false_label, if_true_label);
9499       break;
9500
9501     case GE_EXPR:
9502       mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
9503       if (GET_MODE_CLASS (mode) == MODE_INT
9504           && ! can_compare_p (GE, mode, ccp_jump))
9505         do_jump_by_parts_greater (exp, 1, if_true_label, if_false_label);
9506       else
9507         do_compare_and_jump (exp, GE, GEU, if_false_label, if_true_label);
9508       break;
9509
9510     case UNORDERED_EXPR:
9511     case ORDERED_EXPR:
9512       {
9513         enum rtx_code cmp, rcmp;
9514         int do_rev;
9515
9516         if (code == UNORDERED_EXPR)
9517           cmp = UNORDERED, rcmp = ORDERED;
9518         else
9519           cmp = ORDERED, rcmp = UNORDERED;
9520         mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
9521
9522         do_rev = 0;
9523         if (! can_compare_p (cmp, mode, ccp_jump)
9524             && (can_compare_p (rcmp, mode, ccp_jump)
9525                 /* If the target doesn't provide either UNORDERED or ORDERED
9526                    comparisons, canonicalize on UNORDERED for the library.  */
9527                 || rcmp == UNORDERED))
9528           do_rev = 1;
9529
9530         if (! do_rev)
9531           do_compare_and_jump (exp, cmp, cmp, if_false_label, if_true_label);
9532         else
9533           do_compare_and_jump (exp, rcmp, rcmp, if_true_label, if_false_label);
9534       }
9535       break;
9536
9537     {
9538       enum rtx_code rcode1;
9539       enum tree_code tcode2;
9540
9541       case UNLT_EXPR:
9542         rcode1 = UNLT;
9543         tcode2 = LT_EXPR;
9544         goto unordered_bcc;
9545       case UNLE_EXPR:
9546         rcode1 = UNLE;
9547         tcode2 = LE_EXPR;
9548         goto unordered_bcc;
9549       case UNGT_EXPR:
9550         rcode1 = UNGT;
9551         tcode2 = GT_EXPR;
9552         goto unordered_bcc;
9553       case UNGE_EXPR:
9554         rcode1 = UNGE;
9555         tcode2 = GE_EXPR;
9556         goto unordered_bcc;
9557       case UNEQ_EXPR:
9558         rcode1 = UNEQ;
9559         tcode2 = EQ_EXPR;
9560         goto unordered_bcc;
9561
9562       unordered_bcc:
9563         mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
9564         if (can_compare_p (rcode1, mode, ccp_jump))
9565           do_compare_and_jump (exp, rcode1, rcode1, if_false_label,
9566                                if_true_label);
9567         else
9568           {
9569             tree op0 = save_expr (TREE_OPERAND (exp, 0));
9570             tree op1 = save_expr (TREE_OPERAND (exp, 1));
9571             tree cmp0, cmp1;
9572
9573             /* If the target doesn't support combined unordered
9574                compares, decompose into UNORDERED + comparison.  */
9575             cmp0 = fold (build (UNORDERED_EXPR, TREE_TYPE (exp), op0, op1));
9576             cmp1 = fold (build (tcode2, TREE_TYPE (exp), op0, op1));
9577             exp = build (TRUTH_ORIF_EXPR, TREE_TYPE (exp), cmp0, cmp1);
9578             do_jump (exp, if_false_label, if_true_label);
9579           }
9580       }
9581       break;
9582
9583     default:
9584     normal:
9585       temp = expand_expr (exp, NULL_RTX, VOIDmode, 0);
9586 #if 0
9587       /* This is not needed any more and causes poor code since it causes
9588          comparisons and tests from non-SI objects to have different code
9589          sequences.  */
9590       /* Copy to register to avoid generating bad insns by cse
9591          from (set (mem ...) (arithop))  (set (cc0) (mem ...)).  */
9592       if (!cse_not_expected && GET_CODE (temp) == MEM)
9593         temp = copy_to_reg (temp);
9594 #endif
9595       do_pending_stack_adjust ();
9596       /* Do any postincrements in the expression that was tested.  */
9597       emit_queue ();
9598
9599       if (GET_CODE (temp) == CONST_INT || GET_CODE (temp) == LABEL_REF)
9600         {
9601           rtx target = temp == const0_rtx ? if_false_label : if_true_label;
9602           if (target)
9603             emit_jump (target);
9604         }
9605       else if (GET_MODE_CLASS (GET_MODE (temp)) == MODE_INT
9606                && ! can_compare_p (NE, GET_MODE (temp), ccp_jump))
9607         /* Note swapping the labels gives us not-equal.  */
9608         do_jump_by_parts_equality_rtx (temp, if_true_label, if_false_label);
9609       else if (GET_MODE (temp) != VOIDmode)
9610         do_compare_rtx_and_jump (temp, CONST0_RTX (GET_MODE (temp)),
9611                                  NE, TREE_UNSIGNED (TREE_TYPE (exp)),
9612                                  GET_MODE (temp), NULL_RTX, 0,
9613                                  if_false_label, if_true_label);
9614       else
9615         abort ();
9616     }
9617
9618   if (drop_through_label)
9619     {
9620       /* If do_jump produces code that might be jumped around,
9621          do any stack adjusts from that code, before the place
9622          where control merges in.  */
9623       do_pending_stack_adjust ();
9624       emit_label (drop_through_label);
9625     }
9626 }
9627 \f
9628 /* Given a comparison expression EXP for values too wide to be compared
9629    with one insn, test the comparison and jump to the appropriate label.
9630    The code of EXP is ignored; we always test GT if SWAP is 0,
9631    and LT if SWAP is 1.  */
9632
9633 static void
9634 do_jump_by_parts_greater (exp, swap, if_false_label, if_true_label)
9635      tree exp;
9636      int swap;
9637      rtx if_false_label, if_true_label;
9638 {
9639   rtx op0 = expand_expr (TREE_OPERAND (exp, swap), NULL_RTX, VOIDmode, 0);
9640   rtx op1 = expand_expr (TREE_OPERAND (exp, !swap), NULL_RTX, VOIDmode, 0);
9641   enum machine_mode mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
9642   int unsignedp = TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0)));
9643
9644   do_jump_by_parts_greater_rtx (mode, unsignedp, op0, op1, if_false_label, if_true_label);
9645 }
9646
9647 /* Compare OP0 with OP1, word at a time, in mode MODE.
9648    UNSIGNEDP says to do unsigned comparison.
9649    Jump to IF_TRUE_LABEL if OP0 is greater, IF_FALSE_LABEL otherwise.  */
9650
9651 void
9652 do_jump_by_parts_greater_rtx (mode, unsignedp, op0, op1, if_false_label, if_true_label)
9653      enum machine_mode mode;
9654      int unsignedp;
9655      rtx op0, op1;
9656      rtx if_false_label, if_true_label;
9657 {
9658   int nwords = (GET_MODE_SIZE (mode) / UNITS_PER_WORD);
9659   rtx drop_through_label = 0;
9660   int i;
9661
9662   if (! if_true_label || ! if_false_label)
9663     drop_through_label = gen_label_rtx ();
9664   if (! if_true_label)
9665     if_true_label = drop_through_label;
9666   if (! if_false_label)
9667     if_false_label = drop_through_label;
9668
9669   /* Compare a word at a time, high order first.  */
9670   for (i = 0; i < nwords; i++)
9671     {
9672       rtx op0_word, op1_word;
9673
9674       if (WORDS_BIG_ENDIAN)
9675         {
9676           op0_word = operand_subword_force (op0, i, mode);
9677           op1_word = operand_subword_force (op1, i, mode);
9678         }
9679       else
9680         {
9681           op0_word = operand_subword_force (op0, nwords - 1 - i, mode);
9682           op1_word = operand_subword_force (op1, nwords - 1 - i, mode);
9683         }
9684
9685       /* All but high-order word must be compared as unsigned.  */
9686       do_compare_rtx_and_jump (op0_word, op1_word, GT,
9687                                (unsignedp || i > 0), word_mode, NULL_RTX, 0,
9688                                NULL_RTX, if_true_label);
9689
9690       /* Consider lower words only if these are equal.  */
9691       do_compare_rtx_and_jump (op0_word, op1_word, NE, unsignedp, word_mode,
9692                                NULL_RTX, 0, NULL_RTX, if_false_label);
9693     }
9694
9695   if (if_false_label)
9696     emit_jump (if_false_label);
9697   if (drop_through_label)
9698     emit_label (drop_through_label);
9699 }
9700
9701 /* Given an EQ_EXPR expression EXP for values too wide to be compared
9702    with one insn, test the comparison and jump to the appropriate label.  */
9703
9704 static void
9705 do_jump_by_parts_equality (exp, if_false_label, if_true_label)
9706      tree exp;
9707      rtx if_false_label, if_true_label;
9708 {
9709   rtx op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode, 0);
9710   rtx op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
9711   enum machine_mode mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
9712   int nwords = (GET_MODE_SIZE (mode) / UNITS_PER_WORD);
9713   int i;
9714   rtx drop_through_label = 0;
9715
9716   if (! if_false_label)
9717     drop_through_label = if_false_label = gen_label_rtx ();
9718
9719   for (i = 0; i < nwords; i++)
9720     do_compare_rtx_and_jump (operand_subword_force (op0, i, mode),
9721                              operand_subword_force (op1, i, mode),
9722                              EQ, TREE_UNSIGNED (TREE_TYPE (exp)),
9723                              word_mode, NULL_RTX, 0, if_false_label,
9724                              NULL_RTX);
9725
9726   if (if_true_label)
9727     emit_jump (if_true_label);
9728   if (drop_through_label)
9729     emit_label (drop_through_label);
9730 }
9731 \f
9732 /* Jump according to whether OP0 is 0.
9733    We assume that OP0 has an integer mode that is too wide
9734    for the available compare insns.  */
9735
9736 void
9737 do_jump_by_parts_equality_rtx (op0, if_false_label, if_true_label)
9738      rtx op0;
9739      rtx if_false_label, if_true_label;
9740 {
9741   int nwords = GET_MODE_SIZE (GET_MODE (op0)) / UNITS_PER_WORD;
9742   rtx part;
9743   int i;
9744   rtx drop_through_label = 0;
9745
9746   /* The fastest way of doing this comparison on almost any machine is to
9747      "or" all the words and compare the result.  If all have to be loaded
9748      from memory and this is a very wide item, it's possible this may
9749      be slower, but that's highly unlikely.  */
9750
9751   part = gen_reg_rtx (word_mode);
9752   emit_move_insn (part, operand_subword_force (op0, 0, GET_MODE (op0)));
9753   for (i = 1; i < nwords && part != 0; i++)
9754     part = expand_binop (word_mode, ior_optab, part,
9755                          operand_subword_force (op0, i, GET_MODE (op0)),
9756                          part, 1, OPTAB_WIDEN);
9757
9758   if (part != 0)
9759     {
9760       do_compare_rtx_and_jump (part, const0_rtx, EQ, 1, word_mode,
9761                                NULL_RTX, 0, if_false_label, if_true_label);
9762
9763       return;
9764     }
9765
9766   /* If we couldn't do the "or" simply, do this with a series of compares.  */
9767   if (! if_false_label)
9768     drop_through_label = if_false_label = gen_label_rtx ();
9769
9770   for (i = 0; i < nwords; i++)
9771     do_compare_rtx_and_jump (operand_subword_force (op0, i, GET_MODE (op0)),
9772                              const0_rtx, EQ, 1, word_mode, NULL_RTX, 0,
9773                              if_false_label, NULL_RTX);
9774
9775   if (if_true_label)
9776     emit_jump (if_true_label);
9777
9778   if (drop_through_label)
9779     emit_label (drop_through_label);
9780 }
9781 \f
9782 /* Generate code for a comparison of OP0 and OP1 with rtx code CODE.
9783    (including code to compute the values to be compared)
9784    and set (CC0) according to the result.
9785    The decision as to signed or unsigned comparison must be made by the caller.
9786
9787    We force a stack adjustment unless there are currently
9788    things pushed on the stack that aren't yet used.
9789
9790    If MODE is BLKmode, SIZE is an RTX giving the size of the objects being
9791    compared.
9792
9793    If ALIGN is non-zero, it is the alignment of this type; if zero, the
9794    size of MODE should be used.  */
9795
9796 rtx
9797 compare_from_rtx (op0, op1, code, unsignedp, mode, size, align)
9798      register rtx op0, op1;
9799      enum rtx_code code;
9800      int unsignedp;
9801      enum machine_mode mode;
9802      rtx size;
9803      unsigned int align;
9804 {
9805   rtx tem;
9806
9807   /* If one operand is constant, make it the second one.  Only do this
9808      if the other operand is not constant as well.  */
9809
9810   if ((CONSTANT_P (op0) && ! CONSTANT_P (op1))
9811       || (GET_CODE (op0) == CONST_INT && GET_CODE (op1) != CONST_INT))
9812     {
9813       tem = op0;
9814       op0 = op1;
9815       op1 = tem;
9816       code = swap_condition (code);
9817     }
9818
9819   if (flag_force_mem)
9820     {
9821       op0 = force_not_mem (op0);
9822       op1 = force_not_mem (op1);
9823     }
9824
9825   do_pending_stack_adjust ();
9826
9827   if (GET_CODE (op0) == CONST_INT && GET_CODE (op1) == CONST_INT
9828       && (tem = simplify_relational_operation (code, mode, op0, op1)) != 0)
9829     return tem;
9830
9831 #if 0
9832   /* There's no need to do this now that combine.c can eliminate lots of
9833      sign extensions.  This can be less efficient in certain cases on other
9834      machines.  */
9835
9836   /* If this is a signed equality comparison, we can do it as an
9837      unsigned comparison since zero-extension is cheaper than sign
9838      extension and comparisons with zero are done as unsigned.  This is
9839      the case even on machines that can do fast sign extension, since
9840      zero-extension is easier to combine with other operations than
9841      sign-extension is.  If we are comparing against a constant, we must
9842      convert it to what it would look like unsigned.  */
9843   if ((code == EQ || code == NE) && ! unsignedp
9844       && GET_MODE_BITSIZE (GET_MODE (op0)) <= HOST_BITS_PER_WIDE_INT)
9845     {
9846       if (GET_CODE (op1) == CONST_INT
9847           && (INTVAL (op1) & GET_MODE_MASK (GET_MODE (op0))) != INTVAL (op1))
9848         op1 = GEN_INT (INTVAL (op1) & GET_MODE_MASK (GET_MODE (op0)));
9849       unsignedp = 1;
9850     }
9851 #endif
9852
9853   emit_cmp_insn (op0, op1, code, size, mode, unsignedp, align);
9854
9855   return gen_rtx_fmt_ee (code, VOIDmode, cc0_rtx, const0_rtx);
9856 }
9857
9858 /* Like do_compare_and_jump but expects the values to compare as two rtx's.
9859    The decision as to signed or unsigned comparison must be made by the caller.
9860
9861    If MODE is BLKmode, SIZE is an RTX giving the size of the objects being
9862    compared.
9863
9864    If ALIGN is non-zero, it is the alignment of this type; if zero, the
9865    size of MODE should be used.  */
9866
9867 void
9868 do_compare_rtx_and_jump (op0, op1, code, unsignedp, mode, size, align,
9869                          if_false_label, if_true_label)
9870      register rtx op0, op1;
9871      enum rtx_code code;
9872      int unsignedp;
9873      enum machine_mode mode;
9874      rtx size;
9875      unsigned int align;
9876      rtx if_false_label, if_true_label;
9877 {
9878   rtx tem;
9879   int dummy_true_label = 0;
9880
9881   /* Reverse the comparison if that is safe and we want to jump if it is
9882      false.  */
9883   if (! if_true_label && ! FLOAT_MODE_P (mode))
9884     {
9885       if_true_label = if_false_label;
9886       if_false_label = 0;
9887       code = reverse_condition (code);
9888     }
9889
9890   /* If one operand is constant, make it the second one.  Only do this
9891      if the other operand is not constant as well.  */
9892
9893   if ((CONSTANT_P (op0) && ! CONSTANT_P (op1))
9894       || (GET_CODE (op0) == CONST_INT && GET_CODE (op1) != CONST_INT))
9895     {
9896       tem = op0;
9897       op0 = op1;
9898       op1 = tem;
9899       code = swap_condition (code);
9900     }
9901
9902   if (flag_force_mem)
9903     {
9904       op0 = force_not_mem (op0);
9905       op1 = force_not_mem (op1);
9906     }
9907
9908   do_pending_stack_adjust ();
9909
9910   if (GET_CODE (op0) == CONST_INT && GET_CODE (op1) == CONST_INT
9911       && (tem = simplify_relational_operation (code, mode, op0, op1)) != 0)
9912     {
9913       if (tem == const_true_rtx)
9914         {
9915           if (if_true_label)
9916             emit_jump (if_true_label);
9917         }
9918       else
9919         {
9920           if (if_false_label)
9921             emit_jump (if_false_label);
9922         }
9923       return;
9924     }
9925
9926 #if 0
9927   /* There's no need to do this now that combine.c can eliminate lots of
9928      sign extensions.  This can be less efficient in certain cases on other
9929      machines.  */
9930
9931   /* If this is a signed equality comparison, we can do it as an
9932      unsigned comparison since zero-extension is cheaper than sign
9933      extension and comparisons with zero are done as unsigned.  This is
9934      the case even on machines that can do fast sign extension, since
9935      zero-extension is easier to combine with other operations than
9936      sign-extension is.  If we are comparing against a constant, we must
9937      convert it to what it would look like unsigned.  */
9938   if ((code == EQ || code == NE) && ! unsignedp
9939       && GET_MODE_BITSIZE (GET_MODE (op0)) <= HOST_BITS_PER_WIDE_INT)
9940     {
9941       if (GET_CODE (op1) == CONST_INT
9942           && (INTVAL (op1) & GET_MODE_MASK (GET_MODE (op0))) != INTVAL (op1))
9943         op1 = GEN_INT (INTVAL (op1) & GET_MODE_MASK (GET_MODE (op0)));
9944       unsignedp = 1;
9945     }
9946 #endif
9947
9948   if (! if_true_label)
9949     {
9950       dummy_true_label = 1;
9951       if_true_label = gen_label_rtx ();
9952     }
9953
9954   emit_cmp_and_jump_insns (op0, op1, code, size, mode, unsignedp, align,
9955                            if_true_label);
9956
9957   if (if_false_label)
9958     emit_jump (if_false_label);
9959   if (dummy_true_label)
9960     emit_label (if_true_label);
9961 }
9962
9963 /* Generate code for a comparison expression EXP (including code to compute
9964    the values to be compared) and a conditional jump to IF_FALSE_LABEL and/or
9965    IF_TRUE_LABEL.  One of the labels can be NULL_RTX, in which case the
9966    generated code will drop through.
9967    SIGNED_CODE should be the rtx operation for this comparison for
9968    signed data; UNSIGNED_CODE, likewise for use if data is unsigned.
9969
9970    We force a stack adjustment unless there are currently
9971    things pushed on the stack that aren't yet used.  */
9972
9973 static void
9974 do_compare_and_jump (exp, signed_code, unsigned_code, if_false_label,
9975                      if_true_label)
9976      register tree exp;
9977      enum rtx_code signed_code, unsigned_code;
9978      rtx if_false_label, if_true_label;
9979 {
9980   unsigned int align0, align1;
9981   register rtx op0, op1;
9982   register tree type;
9983   register enum machine_mode mode;
9984   int unsignedp;
9985   enum rtx_code code;
9986
9987   /* Don't crash if the comparison was erroneous.  */
9988   op0 = expand_expr_unaligned (TREE_OPERAND (exp, 0), &align0);
9989   if (TREE_CODE (TREE_OPERAND (exp, 0)) == ERROR_MARK)
9990     return;
9991
9992   op1 = expand_expr_unaligned (TREE_OPERAND (exp, 1), &align1);
9993   type = TREE_TYPE (TREE_OPERAND (exp, 0));
9994   mode = TYPE_MODE (type);
9995   unsignedp = TREE_UNSIGNED (type);
9996   code = unsignedp ? unsigned_code : signed_code;
9997
9998 #ifdef HAVE_canonicalize_funcptr_for_compare
9999   /* If function pointers need to be "canonicalized" before they can
10000      be reliably compared, then canonicalize them.  */
10001   if (HAVE_canonicalize_funcptr_for_compare
10002       && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == POINTER_TYPE
10003       && (TREE_CODE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 0))))
10004           == FUNCTION_TYPE))
10005     {
10006       rtx new_op0 = gen_reg_rtx (mode);
10007
10008       emit_insn (gen_canonicalize_funcptr_for_compare (new_op0, op0));
10009       op0 = new_op0;
10010     }
10011
10012   if (HAVE_canonicalize_funcptr_for_compare
10013       && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 1))) == POINTER_TYPE
10014       && (TREE_CODE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 1))))
10015           == FUNCTION_TYPE))
10016     {
10017       rtx new_op1 = gen_reg_rtx (mode);
10018
10019       emit_insn (gen_canonicalize_funcptr_for_compare (new_op1, op1));
10020       op1 = new_op1;
10021     }
10022 #endif
10023
10024   /* Do any postincrements in the expression that was tested.  */
10025   emit_queue ();
10026
10027   do_compare_rtx_and_jump (op0, op1, code, unsignedp, mode,
10028                            ((mode == BLKmode)
10029                             ? expr_size (TREE_OPERAND (exp, 0)) : NULL_RTX),
10030                            MIN (align0, align1),
10031                            if_false_label, if_true_label);
10032 }
10033 \f
10034 /* Generate code to calculate EXP using a store-flag instruction
10035    and return an rtx for the result.  EXP is either a comparison
10036    or a TRUTH_NOT_EXPR whose operand is a comparison.
10037
10038    If TARGET is nonzero, store the result there if convenient.
10039
10040    If ONLY_CHEAP is non-zero, only do this if it is likely to be very
10041    cheap.
10042
10043    Return zero if there is no suitable set-flag instruction
10044    available on this machine.
10045
10046    Once expand_expr has been called on the arguments of the comparison,
10047    we are committed to doing the store flag, since it is not safe to
10048    re-evaluate the expression.  We emit the store-flag insn by calling
10049    emit_store_flag, but only expand the arguments if we have a reason
10050    to believe that emit_store_flag will be successful.  If we think that
10051    it will, but it isn't, we have to simulate the store-flag with a
10052    set/jump/set sequence.  */
10053
10054 static rtx
10055 do_store_flag (exp, target, mode, only_cheap)
10056      tree exp;
10057      rtx target;
10058      enum machine_mode mode;
10059      int only_cheap;
10060 {
10061   enum rtx_code code;
10062   tree arg0, arg1, type;
10063   tree tem;
10064   enum machine_mode operand_mode;
10065   int invert = 0;
10066   int unsignedp;
10067   rtx op0, op1;
10068   enum insn_code icode;
10069   rtx subtarget = target;
10070   rtx result, label;
10071
10072   /* If this is a TRUTH_NOT_EXPR, set a flag indicating we must invert the
10073      result at the end.  We can't simply invert the test since it would
10074      have already been inverted if it were valid.  This case occurs for
10075      some floating-point comparisons.  */
10076
10077   if (TREE_CODE (exp) == TRUTH_NOT_EXPR)
10078     invert = 1, exp = TREE_OPERAND (exp, 0);
10079
10080   arg0 = TREE_OPERAND (exp, 0);
10081   arg1 = TREE_OPERAND (exp, 1);
10082   type = TREE_TYPE (arg0);
10083   operand_mode = TYPE_MODE (type);
10084   unsignedp = TREE_UNSIGNED (type);
10085
10086   /* We won't bother with BLKmode store-flag operations because it would mean
10087      passing a lot of information to emit_store_flag.  */
10088   if (operand_mode == BLKmode)
10089     return 0;
10090
10091   /* We won't bother with store-flag operations involving function pointers
10092      when function pointers must be canonicalized before comparisons.  */
10093 #ifdef HAVE_canonicalize_funcptr_for_compare
10094   if (HAVE_canonicalize_funcptr_for_compare
10095       && ((TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == POINTER_TYPE
10096            && (TREE_CODE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 0))))
10097                == FUNCTION_TYPE))
10098           || (TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 1))) == POINTER_TYPE
10099               && (TREE_CODE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 1))))
10100                   == FUNCTION_TYPE))))
10101     return 0;
10102 #endif
10103
10104   STRIP_NOPS (arg0);
10105   STRIP_NOPS (arg1);
10106
10107   /* Get the rtx comparison code to use.  We know that EXP is a comparison
10108      operation of some type.  Some comparisons against 1 and -1 can be
10109      converted to comparisons with zero.  Do so here so that the tests
10110      below will be aware that we have a comparison with zero.   These
10111      tests will not catch constants in the first operand, but constants
10112      are rarely passed as the first operand.  */
10113
10114   switch (TREE_CODE (exp))
10115     {
10116     case EQ_EXPR:
10117       code = EQ;
10118       break;
10119     case NE_EXPR:
10120       code = NE;
10121       break;
10122     case LT_EXPR:
10123       if (integer_onep (arg1))
10124         arg1 = integer_zero_node, code = unsignedp ? LEU : LE;
10125       else
10126         code = unsignedp ? LTU : LT;
10127       break;
10128     case LE_EXPR:
10129       if (! unsignedp && integer_all_onesp (arg1))
10130         arg1 = integer_zero_node, code = LT;
10131       else
10132         code = unsignedp ? LEU : LE;
10133       break;
10134     case GT_EXPR:
10135       if (! unsignedp && integer_all_onesp (arg1))
10136         arg1 = integer_zero_node, code = GE;
10137       else
10138         code = unsignedp ? GTU : GT;
10139       break;
10140     case GE_EXPR:
10141       if (integer_onep (arg1))
10142         arg1 = integer_zero_node, code = unsignedp ? GTU : GT;
10143       else
10144         code = unsignedp ? GEU : GE;
10145       break;
10146
10147     case UNORDERED_EXPR:
10148       code = UNORDERED;
10149       break;
10150     case ORDERED_EXPR:
10151       code = ORDERED;
10152       break;
10153     case UNLT_EXPR:
10154       code = UNLT;
10155       break;
10156     case UNLE_EXPR:
10157       code = UNLE;
10158       break;
10159     case UNGT_EXPR:
10160       code = UNGT;
10161       break;
10162     case UNGE_EXPR:
10163       code = UNGE;
10164       break;
10165     case UNEQ_EXPR:
10166       code = UNEQ;
10167       break;
10168
10169     default:
10170       abort ();
10171     }
10172
10173   /* Put a constant second.  */
10174   if (TREE_CODE (arg0) == REAL_CST || TREE_CODE (arg0) == INTEGER_CST)
10175     {
10176       tem = arg0; arg0 = arg1; arg1 = tem;
10177       code = swap_condition (code);
10178     }
10179
10180   /* If this is an equality or inequality test of a single bit, we can
10181      do this by shifting the bit being tested to the low-order bit and
10182      masking the result with the constant 1.  If the condition was EQ,
10183      we xor it with 1.  This does not require an scc insn and is faster
10184      than an scc insn even if we have it.  */
10185
10186   if ((code == NE || code == EQ)
10187       && TREE_CODE (arg0) == BIT_AND_EXPR && integer_zerop (arg1)
10188       && integer_pow2p (TREE_OPERAND (arg0, 1)))
10189     {
10190       tree inner = TREE_OPERAND (arg0, 0);
10191       int bitnum = tree_log2 (TREE_OPERAND (arg0, 1));
10192       int ops_unsignedp;
10193
10194       /* If INNER is a right shift of a constant and it plus BITNUM does
10195          not overflow, adjust BITNUM and INNER.  */
10196
10197       if (TREE_CODE (inner) == RSHIFT_EXPR
10198           && TREE_CODE (TREE_OPERAND (inner, 1)) == INTEGER_CST
10199           && TREE_INT_CST_HIGH (TREE_OPERAND (inner, 1)) == 0
10200           && bitnum < TYPE_PRECISION (type)
10201           && 0 > compare_tree_int (TREE_OPERAND (inner, 1),
10202                                    bitnum - TYPE_PRECISION (type)))
10203         {
10204           bitnum += TREE_INT_CST_LOW (TREE_OPERAND (inner, 1));
10205           inner = TREE_OPERAND (inner, 0);
10206         }
10207
10208       /* If we are going to be able to omit the AND below, we must do our
10209          operations as unsigned.  If we must use the AND, we have a choice.
10210          Normally unsigned is faster, but for some machines signed is.  */
10211       ops_unsignedp = (bitnum == TYPE_PRECISION (type) - 1 ? 1
10212 #ifdef LOAD_EXTEND_OP
10213                        : (LOAD_EXTEND_OP (operand_mode) == SIGN_EXTEND ? 0 : 1)
10214 #else
10215                        : 1
10216 #endif
10217                        );
10218
10219       if (subtarget == 0 || GET_CODE (subtarget) != REG
10220           || GET_MODE (subtarget) != operand_mode
10221           || ! safe_from_p (subtarget, inner, 1))
10222         subtarget = 0;
10223
10224       op0 = expand_expr (inner, subtarget, VOIDmode, 0);
10225
10226       if (bitnum != 0)
10227         op0 = expand_shift (RSHIFT_EXPR, GET_MODE (op0), op0,
10228                             size_int (bitnum), subtarget, ops_unsignedp);
10229
10230       if (GET_MODE (op0) != mode)
10231         op0 = convert_to_mode (mode, op0, ops_unsignedp);
10232
10233       if ((code == EQ && ! invert) || (code == NE && invert))
10234         op0 = expand_binop (mode, xor_optab, op0, const1_rtx, subtarget,
10235                             ops_unsignedp, OPTAB_LIB_WIDEN);
10236
10237       /* Put the AND last so it can combine with more things.  */
10238       if (bitnum != TYPE_PRECISION (type) - 1)
10239         op0 = expand_and (op0, const1_rtx, subtarget);
10240
10241       return op0;
10242     }
10243
10244   /* Now see if we are likely to be able to do this.  Return if not.  */
10245   if (! can_compare_p (code, operand_mode, ccp_store_flag))
10246     return 0;
10247
10248   icode = setcc_gen_code[(int) code];
10249   if (icode == CODE_FOR_nothing
10250       || (only_cheap && insn_data[(int) icode].operand[0].mode != mode))
10251     {
10252       /* We can only do this if it is one of the special cases that
10253          can be handled without an scc insn.  */
10254       if ((code == LT && integer_zerop (arg1))
10255           || (! only_cheap && code == GE && integer_zerop (arg1)))
10256         ;
10257       else if (BRANCH_COST >= 0
10258                && ! only_cheap && (code == NE || code == EQ)
10259                && TREE_CODE (type) != REAL_TYPE
10260                && ((abs_optab->handlers[(int) operand_mode].insn_code
10261                     != CODE_FOR_nothing)
10262                    || (ffs_optab->handlers[(int) operand_mode].insn_code
10263                        != CODE_FOR_nothing)))
10264         ;
10265       else
10266         return 0;
10267     }
10268
10269   preexpand_calls (exp);
10270   if (subtarget == 0 || GET_CODE (subtarget) != REG
10271       || GET_MODE (subtarget) != operand_mode
10272       || ! safe_from_p (subtarget, arg1, 1))
10273     subtarget = 0;
10274
10275   op0 = expand_expr (arg0, subtarget, VOIDmode, 0);
10276   op1 = expand_expr (arg1, NULL_RTX, VOIDmode, 0);
10277
10278   if (target == 0)
10279     target = gen_reg_rtx (mode);
10280
10281   /* Pass copies of OP0 and OP1 in case they contain a QUEUED.  This is safe
10282      because, if the emit_store_flag does anything it will succeed and
10283      OP0 and OP1 will not be used subsequently.  */
10284
10285   result = emit_store_flag (target, code,
10286                             queued_subexp_p (op0) ? copy_rtx (op0) : op0,
10287                             queued_subexp_p (op1) ? copy_rtx (op1) : op1,
10288                             operand_mode, unsignedp, 1);
10289
10290   if (result)
10291     {
10292       if (invert)
10293         result = expand_binop (mode, xor_optab, result, const1_rtx,
10294                                result, 0, OPTAB_LIB_WIDEN);
10295       return result;
10296     }
10297
10298   /* If this failed, we have to do this with set/compare/jump/set code.  */
10299   if (GET_CODE (target) != REG
10300       || reg_mentioned_p (target, op0) || reg_mentioned_p (target, op1))
10301     target = gen_reg_rtx (GET_MODE (target));
10302
10303   emit_move_insn (target, invert ? const0_rtx : const1_rtx);
10304   result = compare_from_rtx (op0, op1, code, unsignedp,
10305                              operand_mode, NULL_RTX, 0);
10306   if (GET_CODE (result) == CONST_INT)
10307     return (((result == const0_rtx && ! invert)
10308              || (result != const0_rtx && invert))
10309             ? const0_rtx : const1_rtx);
10310
10311   label = gen_label_rtx ();
10312   if (bcc_gen_fctn[(int) code] == 0)
10313     abort ();
10314
10315   emit_jump_insn ((*bcc_gen_fctn[(int) code]) (label));
10316   emit_move_insn (target, invert ? const1_rtx : const0_rtx);
10317   emit_label (label);
10318
10319   return target;
10320 }
10321 \f
10322 /* Generate a tablejump instruction (used for switch statements).  */
10323
10324 #ifdef HAVE_tablejump
10325
10326 /* INDEX is the value being switched on, with the lowest value
10327    in the table already subtracted.
10328    MODE is its expected mode (needed if INDEX is constant).
10329    RANGE is the length of the jump table.
10330    TABLE_LABEL is a CODE_LABEL rtx for the table itself.
10331
10332    DEFAULT_LABEL is a CODE_LABEL rtx to jump to if the
10333    index value is out of range.  */
10334
10335 void
10336 do_tablejump (index, mode, range, table_label, default_label)
10337      rtx index, range, table_label, default_label;
10338      enum machine_mode mode;
10339 {
10340   register rtx temp, vector;
10341
10342   /* Do an unsigned comparison (in the proper mode) between the index
10343      expression and the value which represents the length of the range.
10344      Since we just finished subtracting the lower bound of the range
10345      from the index expression, this comparison allows us to simultaneously
10346      check that the original index expression value is both greater than
10347      or equal to the minimum value of the range and less than or equal to
10348      the maximum value of the range.  */
10349
10350   emit_cmp_and_jump_insns (index, range, GTU, NULL_RTX, mode, 1,
10351                            0, default_label);
10352
10353   /* If index is in range, it must fit in Pmode.
10354      Convert to Pmode so we can index with it.  */
10355   if (mode != Pmode)
10356     index = convert_to_mode (Pmode, index, 1);
10357
10358   /* Don't let a MEM slip thru, because then INDEX that comes
10359      out of PIC_CASE_VECTOR_ADDRESS won't be a valid address,
10360      and break_out_memory_refs will go to work on it and mess it up.  */
10361 #ifdef PIC_CASE_VECTOR_ADDRESS
10362   if (flag_pic && GET_CODE (index) != REG)
10363     index = copy_to_mode_reg (Pmode, index);
10364 #endif
10365
10366   /* If flag_force_addr were to affect this address
10367      it could interfere with the tricky assumptions made
10368      about addresses that contain label-refs,
10369      which may be valid only very near the tablejump itself.  */
10370   /* ??? The only correct use of CASE_VECTOR_MODE is the one inside the
10371      GET_MODE_SIZE, because this indicates how large insns are.  The other
10372      uses should all be Pmode, because they are addresses.  This code
10373      could fail if addresses and insns are not the same size.  */
10374   index = gen_rtx_PLUS (Pmode,
10375                         gen_rtx_MULT (Pmode, index,
10376                                       GEN_INT (GET_MODE_SIZE (CASE_VECTOR_MODE))),
10377                         gen_rtx_LABEL_REF (Pmode, table_label));
10378 #ifdef PIC_CASE_VECTOR_ADDRESS
10379   if (flag_pic)
10380     index = PIC_CASE_VECTOR_ADDRESS (index);
10381   else
10382 #endif
10383     index = memory_address_noforce (CASE_VECTOR_MODE, index);
10384   temp = gen_reg_rtx (CASE_VECTOR_MODE);
10385   vector = gen_rtx_MEM (CASE_VECTOR_MODE, index);
10386   RTX_UNCHANGING_P (vector) = 1;
10387   convert_move (temp, vector, 0);
10388
10389   emit_jump_insn (gen_tablejump (temp, table_label));
10390
10391   /* If we are generating PIC code or if the table is PC-relative, the
10392      table and JUMP_INSN must be adjacent, so don't output a BARRIER.  */
10393   if (! CASE_VECTOR_PC_RELATIVE && ! flag_pic)
10394     emit_barrier ();
10395 }
10396
10397 #endif /* HAVE_tablejump */