gcc/expr.c

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