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