gcc/expr.c

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