gcc/expr.c

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