gcc/emit-rtl.c

   1 /* Emit RTL for the GNU C-Compiler expander.
   2    Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001, 2002 Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.  */
  21
  22
  23 /* Middle-to-low level generation of rtx code and insns.
  24
  25    This file contains the functions `gen_rtx', `gen_reg_rtx'
  26    and `gen_label_rtx' that are the usual ways of creating rtl
  27    expressions for most purposes.
  28
  29    It also has the functions for creating insns and linking
  30    them in the doubly-linked chain.
  31
  32    The patterns of the insns are created by machine-dependent
  33    routines in insn-emit.c, which is generated automatically from
  34    the machine description.  These routines use `gen_rtx' to make
  35    the individual rtx's of the pattern; what is machine dependent
  36    is the kind of rtx's they make and what arguments they use.  */
  37
  38 #include "config.h"
  39 #include "system.h"
  40 #include "toplev.h"
  41 #include "rtl.h"
  42 #include "tree.h"
  43 #include "tm_p.h"
  44 #include "flags.h"
  45 #include "function.h"
  46 #include "expr.h"
  47 #include "regs.h"
  48 #include "hard-reg-set.h"
  49 #include "hashtab.h"
  50 #include "insn-config.h"
  51 #include "recog.h"
  52 #include "real.h"
  53 #include "obstack.h"
  54 #include "bitmap.h"
  55 #include "basic-block.h"
  56 #include "ggc.h"
  57 #include "debug.h"
  58 #include "langhooks.h"
  59
  60 /* Commonly used modes.  */
  61
  62 enum machine_mode byte_mode;    /* Mode whose width is BITS_PER_UNIT.  */
  63 enum machine_mode word_mode;    /* Mode whose width is BITS_PER_WORD.  */
  64 enum machine_mode double_mode;  /* Mode whose width is DOUBLE_TYPE_SIZE.  */
  65 enum machine_mode ptr_mode;     /* Mode whose width is POINTER_SIZE.  */
  66
  67
  68 /* This is *not* reset after each function.  It gives each CODE_LABEL
  69    in the entire compilation a unique label number.  */
  70
  71 static int label_num = 1;
  72
  73 /* Highest label number in current function.
  74    Zero means use the value of label_num instead.
  75    This is nonzero only when belatedly compiling an inline function.  */
  76
  77 static int last_label_num;
  78
  79 /* Value label_num had when set_new_first_and_last_label_number was called.
  80    If label_num has not changed since then, last_label_num is valid.  */
  81
  82 static int base_label_num;
  83
  84 /* Nonzero means do not generate NOTEs for source line numbers.  */
  85
  86 static int no_line_numbers;
  87
  88 /* Commonly used rtx's, so that we only need space for one copy.
  89    These are initialized once for the entire compilation.
  90    All of these except perhaps the floating-point CONST_DOUBLEs
  91    are unique; no other rtx-object will be equal to any of these.  */
  92
  93 rtx global_rtl[GR_MAX];
  94
  95 /* We record floating-point CONST_DOUBLEs in each floating-point mode for
  96    the values of 0, 1, and 2.  For the integer entries and VOIDmode, we
  97    record a copy of const[012]_rtx.  */
  98
  99 rtx const_tiny_rtx[3][(int) MAX_MACHINE_MODE];
 100
 101 rtx const_true_rtx;
 102
 103 REAL_VALUE_TYPE dconst0;
 104 REAL_VALUE_TYPE dconst1;
 105 REAL_VALUE_TYPE dconst2;
 106 REAL_VALUE_TYPE dconstm1;
 107
 108 /* All references to the following fixed hard registers go through
 109    these unique rtl objects.  On machines where the frame-pointer and
 110    arg-pointer are the same register, they use the same unique object.
 111
 112    After register allocation, other rtl objects which used to be pseudo-regs
 113    may be clobbered to refer to the frame-pointer register.
 114    But references that were originally to the frame-pointer can be
 115    distinguished from the others because they contain frame_pointer_rtx.
 116
 117    When to use frame_pointer_rtx and hard_frame_pointer_rtx is a little
 118    tricky: until register elimination has taken place hard_frame_pointer_rtx
 119    should be used if it is being set, and frame_pointer_rtx otherwise.  After
 120    register elimination hard_frame_pointer_rtx should always be used.
 121    On machines where the two registers are same (most) then these are the
 122    same.
 123
 124    In an inline procedure, the stack and frame pointer rtxs may not be
 125    used for anything else.  */
 126 rtx struct_value_rtx;           /* (REG:Pmode STRUCT_VALUE_REGNUM) */
 127 rtx struct_value_incoming_rtx;  /* (REG:Pmode STRUCT_VALUE_INCOMING_REGNUM) */
 128 rtx static_chain_rtx;           /* (REG:Pmode STATIC_CHAIN_REGNUM) */
 129 rtx static_chain_incoming_rtx;  /* (REG:Pmode STATIC_CHAIN_INCOMING_REGNUM) */
 130 rtx pic_offset_table_rtx;       /* (REG:Pmode PIC_OFFSET_TABLE_REGNUM) */
 131
 132 /* This is used to implement __builtin_return_address for some machines.
 133    See for instance the MIPS port.  */
 134 rtx return_address_pointer_rtx; /* (REG:Pmode RETURN_ADDRESS_POINTER_REGNUM) */
 135
 136 /* We make one copy of (const_int C) where C is in
 137    [- MAX_SAVED_CONST_INT, MAX_SAVED_CONST_INT]
 138    to save space during the compilation and simplify comparisons of
 139    integers.  */
 140
 141 rtx const_int_rtx[MAX_SAVED_CONST_INT * 2 + 1];
 142
 143 /* A hash table storing CONST_INTs whose absolute value is greater
 144    than MAX_SAVED_CONST_INT.  */
 145
 146 static htab_t const_int_htab;
 147
 148 /* A hash table storing memory attribute structures.  */
 149 static htab_t mem_attrs_htab;
 150
 151 /* start_sequence and gen_sequence can make a lot of rtx expressions which are
 152    shortly thrown away.  We use two mechanisms to prevent this waste:
 153
 154    For sizes up to 5 elements, we keep a SEQUENCE and its associated
 155    rtvec for use by gen_sequence.  One entry for each size is
 156    sufficient because most cases are calls to gen_sequence followed by
 157    immediately emitting the SEQUENCE.  Reuse is safe since emitting a
 158    sequence is destructive on the insn in it anyway and hence can't be
 159    redone.
 160
 161    We do not bother to save this cached data over nested function calls.
 162    Instead, we just reinitialize them.  */
 163
 164 #define SEQUENCE_RESULT_SIZE 5
 165
 166 static rtx sequence_result[SEQUENCE_RESULT_SIZE];
 167
 168 /* During RTL generation, we also keep a list of free INSN rtl codes.  */
 169 static rtx free_insn;
 170
 171 #define first_insn (cfun->emit->x_first_insn)
 172 #define last_insn (cfun->emit->x_last_insn)
 173 #define cur_insn_uid (cfun->emit->x_cur_insn_uid)
 174 #define last_linenum (cfun->emit->x_last_linenum)
 175 #define last_filename (cfun->emit->x_last_filename)
 176 #define first_label_num (cfun->emit->x_first_label_num)
 177
 178 static rtx make_jump_insn_raw           PARAMS ((rtx));
 179 static rtx make_call_insn_raw           PARAMS ((rtx));
 180 static rtx find_line_note               PARAMS ((rtx));
 181 static void mark_sequence_stack         PARAMS ((struct sequence_stack *));
 182 static rtx change_address_1             PARAMS ((rtx, enum machine_mode, rtx,
 183                                                  int));
 184 static void unshare_all_rtl_1           PARAMS ((rtx));
 185 static void unshare_all_decls           PARAMS ((tree));
 186 static void reset_used_decls            PARAMS ((tree));
 187 static void mark_label_nuses            PARAMS ((rtx));
 188 static hashval_t const_int_htab_hash    PARAMS ((const void *));
 189 static int const_int_htab_eq            PARAMS ((const void *,
 190                                                  const void *));
 191 static hashval_t mem_attrs_htab_hash    PARAMS ((const void *));
 192 static int mem_attrs_htab_eq            PARAMS ((const void *,
 193                                                  const void *));
 194 static void mem_attrs_mark              PARAMS ((const void *));
 195 static mem_attrs *get_mem_attrs         PARAMS ((HOST_WIDE_INT, tree, rtx,
 196                                                  rtx, unsigned int,
 197                                                  enum machine_mode));
 198 static tree component_ref_for_mem_expr  PARAMS ((tree));
 199 static rtx gen_const_vector_0           PARAMS ((enum machine_mode));
 200
 201 /* Probability of the conditional branch currently proceeded by try_split.
 202    Set to -1 otherwise.  */
 203 int split_branch_probability = -1;
 204 \f
 205 /* Returns a hash code for X (which is a really a CONST_INT).  */
 206
 207 static hashval_t
 208 const_int_htab_hash (x)
 209      const void *x;
 210 {
 211   return (hashval_t) INTVAL ((const struct rtx_def *) x);
 212 }
 213
 214 /* Returns non-zero if the value represented by X (which is really a
 215    CONST_INT) is the same as that given by Y (which is really a
 216    HOST_WIDE_INT *).  */
 217
 218 static int
 219 const_int_htab_eq (x, y)
 220      const void *x;
 221      const void *y;
 222 {
 223   return (INTVAL ((const struct rtx_def *) x) == *((const HOST_WIDE_INT *) y));
 224 }
 225
 226 /* Returns a hash code for X (which is a really a mem_attrs *).  */
 227
 228 static hashval_t
 229 mem_attrs_htab_hash (x)
 230      const void *x;
 231 {
 232   mem_attrs *p = (mem_attrs *) x;
 233
 234   return (p->alias ^ (p->align * 1000)
 235           ^ ((p->offset ? INTVAL (p->offset) : 0) * 50000)
 236           ^ ((p->size ? INTVAL (p->size) : 0) * 2500000)
 237           ^ (size_t) p->expr);
 238 }
 239
 240 /* Returns non-zero if the value represented by X (which is really a
 241    mem_attrs *) is the same as that given by Y (which is also really a
 242    mem_attrs *).  */
 243
 244 static int
 245 mem_attrs_htab_eq (x, y)
 246      const void *x;
 247      const void *y;
 248 {
 249   mem_attrs *p = (mem_attrs *) x;
 250   mem_attrs *q = (mem_attrs *) y;
 251
 252   return (p->alias == q->alias && p->expr == q->expr && p->offset == q->offset
 253           && p->size == q->size && p->align == q->align);
 254 }
 255
 256 /* This routine is called when we determine that we need a mem_attrs entry.
 257    It marks the associated decl and RTL as being used, if present.  */
 258
 259 static void
 260 mem_attrs_mark (x)
 261      const void *x;
 262 {
 263   mem_attrs *p = (mem_attrs *) x;
 264
 265   if (p->expr)
 266     ggc_mark_tree (p->expr);
 267
 268   if (p->offset)
 269     ggc_mark_rtx (p->offset);
 270
 271   if (p->size)
 272     ggc_mark_rtx (p->size);
 273 }
 274
 275 /* Allocate a new mem_attrs structure and insert it into the hash table if
 276    one identical to it is not already in the table.  We are doing this for
 277    MEM of mode MODE.  */
 278
 279 static mem_attrs *
 280 get_mem_attrs (alias, expr, offset, size, align, mode)
 281      HOST_WIDE_INT alias;
 282      tree expr;
 283      rtx offset;
 284      rtx size;
 285      unsigned int align;
 286      enum machine_mode mode;
 287 {
 288   mem_attrs attrs;
 289   void **slot;
 290
 291   /* If everything is the default, we can just return zero.  */
 292   if (alias == 0 && expr == 0 && offset == 0
 293       && (size == 0
 294           || (mode != BLKmode && GET_MODE_SIZE (mode) == INTVAL (size)))
 295       && (align == BITS_PER_UNIT
 296           || (STRICT_ALIGNMENT
 297               && mode != BLKmode && align == GET_MODE_ALIGNMENT (mode))))
 298     return 0;
 299
 300   attrs.alias = alias;
 301   attrs.expr = expr;
 302   attrs.offset = offset;
 303   attrs.size = size;
 304   attrs.align = align;
 305
 306   slot = htab_find_slot (mem_attrs_htab, &attrs, INSERT);
 307   if (*slot == 0)
 308     {
 309       *slot = ggc_alloc (sizeof (mem_attrs));
 310       memcpy (*slot, &attrs, sizeof (mem_attrs));
 311     }
 312
 313   return *slot;
 314 }
 315
 316 /* Generate a new REG rtx.  Make sure ORIGINAL_REGNO is set properly, and
 317    don't attempt to share with the various global pieces of rtl (such as
 318    frame_pointer_rtx).  */
 319
 320 rtx
 321 gen_raw_REG (mode, regno)
 322      enum machine_mode mode;
 323      int regno;
 324 {
 325   rtx x = gen_rtx_raw_REG (mode, regno);
 326   ORIGINAL_REGNO (x) = regno;
 327   return x;
 328 }
 329
 330 /* There are some RTL codes that require special attention; the generation
 331    functions do the raw handling.  If you add to this list, modify
 332    special_rtx in gengenrtl.c as well.  */
 333
 334 rtx
 335 gen_rtx_CONST_INT (mode, arg)
 336      enum machine_mode mode ATTRIBUTE_UNUSED;
 337      HOST_WIDE_INT arg;
 338 {
 339   void **slot;
 340
 341   if (arg >= - MAX_SAVED_CONST_INT && arg <= MAX_SAVED_CONST_INT)
 342     return const_int_rtx[arg + MAX_SAVED_CONST_INT];
 343
 344 #if STORE_FLAG_VALUE != 1 && STORE_FLAG_VALUE != -1
 345   if (const_true_rtx && arg == STORE_FLAG_VALUE)
 346     return const_true_rtx;
 347 #endif
 348
 349   /* Look up the CONST_INT in the hash table.  */
 350   slot = htab_find_slot_with_hash (const_int_htab, &arg,
 351                                    (hashval_t) arg, INSERT);
 352   if (*slot == 0)
 353     *slot = gen_rtx_raw_CONST_INT (VOIDmode, arg);
 354
 355   return (rtx) *slot;
 356 }
 357
 358 rtx
 359 gen_int_mode (c, mode)
 360      HOST_WIDE_INT c;
 361      enum machine_mode mode;
 362 {
 363   return GEN_INT (trunc_int_for_mode (c, mode));
 364 }
 365
 366 /* CONST_DOUBLEs needs special handling because their length is known
 367    only at run-time.  */
 368
 369 rtx
 370 gen_rtx_CONST_DOUBLE (mode, arg0, arg1)
 371      enum machine_mode mode;
 372      HOST_WIDE_INT arg0, arg1;
 373 {
 374   rtx r = rtx_alloc (CONST_DOUBLE);
 375   int i;
 376
 377   PUT_MODE (r, mode);
 378   X0EXP (r, 0) = NULL_RTX;
 379   XWINT (r, 1) = arg0;
 380   XWINT (r, 2) = arg1;
 381
 382   for (i = GET_RTX_LENGTH (CONST_DOUBLE) - 1; i > 2; --i)
 383     XWINT (r, i) = 0;
 384
 385   return r;
 386 }
 387
 388 rtx
 389 gen_rtx_REG (mode, regno)
 390      enum machine_mode mode;
 391      int regno;
 392 {
 393   /* In case the MD file explicitly references the frame pointer, have
 394      all such references point to the same frame pointer.  This is
 395      used during frame pointer elimination to distinguish the explicit
 396      references to these registers from pseudos that happened to be
 397      assigned to them.
 398
 399      If we have eliminated the frame pointer or arg pointer, we will
 400      be using it as a normal register, for example as a spill
 401      register.  In such cases, we might be accessing it in a mode that
 402      is not Pmode and therefore cannot use the pre-allocated rtx.
 403
 404      Also don't do this when we are making new REGs in reload, since
 405      we don't want to get confused with the real pointers.  */
 406
 407   if (mode == Pmode && !reload_in_progress)
 408     {
 409       if (regno == FRAME_POINTER_REGNUM)
 410         return frame_pointer_rtx;
 411 #if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
 412       if (regno == HARD_FRAME_POINTER_REGNUM)
 413         return hard_frame_pointer_rtx;
 414 #endif
 415 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM && HARD_FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
 416       if (regno == ARG_POINTER_REGNUM)
 417         return arg_pointer_rtx;
 418 #endif
 419 #ifdef RETURN_ADDRESS_POINTER_REGNUM
 420       if (regno == RETURN_ADDRESS_POINTER_REGNUM)
 421         return return_address_pointer_rtx;
 422 #endif
 423       if (regno == PIC_OFFSET_TABLE_REGNUM
 424           && fixed_regs[PIC_OFFSET_TABLE_REGNUM])
 425         return pic_offset_table_rtx;
 426       if (regno == STACK_POINTER_REGNUM)
 427         return stack_pointer_rtx;
 428     }
 429
 430   return gen_raw_REG (mode, regno);
 431 }
 432
 433 rtx
 434 gen_rtx_MEM (mode, addr)
 435      enum machine_mode mode;
 436      rtx addr;
 437 {
 438   rtx rt = gen_rtx_raw_MEM (mode, addr);
 439
 440   /* This field is not cleared by the mere allocation of the rtx, so
 441      we clear it here.  */
 442   MEM_ATTRS (rt) = 0;
 443
 444   return rt;
 445 }
 446
 447 rtx
 448 gen_rtx_SUBREG (mode, reg, offset)
 449      enum machine_mode mode;
 450      rtx reg;
 451      int offset;
 452 {
 453   /* This is the most common failure type.
 454      Catch it early so we can see who does it.  */
 455   if ((offset % GET_MODE_SIZE (mode)) != 0)
 456     abort ();
 457
 458   /* This check isn't usable right now because combine will
 459      throw arbitrary crap like a CALL into a SUBREG in
 460      gen_lowpart_for_combine so we must just eat it.  */
 461 #if 0
 462   /* Check for this too.  */
 463   if (offset >= GET_MODE_SIZE (GET_MODE (reg)))
 464     abort ();
 465 #endif
 466   return gen_rtx_fmt_ei (SUBREG, mode, reg, offset);
 467 }
 468
 469 /* Generate a SUBREG representing the least-significant part of REG if MODE
 470    is smaller than mode of REG, otherwise paradoxical SUBREG.  */
 471
 472 rtx
 473 gen_lowpart_SUBREG (mode, reg)
 474      enum machine_mode mode;
 475      rtx reg;
 476 {
 477   enum machine_mode inmode;
 478
 479   inmode = GET_MODE (reg);
 480   if (inmode == VOIDmode)
 481     inmode = mode;
 482   return gen_rtx_SUBREG (mode, reg,
 483                          subreg_lowpart_offset (mode, inmode));
 484 }
 485 \f
 486 /* rtx gen_rtx (code, mode, [element1, ..., elementn])
 487 **
 488 **          This routine generates an RTX of the size specified by
 489 **      <code>, which is an RTX code.   The RTX structure is initialized
 490 **      from the arguments <element1> through <elementn>, which are
 491 **      interpreted according to the specific RTX type's format.   The
 492 **      special machine mode associated with the rtx (if any) is specified
 493 **      in <mode>.
 494 **
 495 **          gen_rtx can be invoked in a way which resembles the lisp-like
 496 **      rtx it will generate.   For example, the following rtx structure:
 497 **
 498 **            (plus:QI (mem:QI (reg:SI 1))
 499 **                     (mem:QI (plusw:SI (reg:SI 2) (reg:SI 3))))
 500 **
 501 **              ...would be generated by the following C code:
 502 **
 503 **              gen_rtx (PLUS, QImode,
 504 **                  gen_rtx (MEM, QImode,
 505 **                      gen_rtx (REG, SImode, 1)),
 506 **                  gen_rtx (MEM, QImode,
 507 **                      gen_rtx (PLUS, SImode,
 508 **                          gen_rtx (REG, SImode, 2),
 509 **                          gen_rtx (REG, SImode, 3)))),
 510 */
 511
 512 /*VARARGS2*/
 513 rtx
 514 gen_rtx VPARAMS ((enum rtx_code code, enum machine_mode mode, ...))
 515 {
 516   int i;                /* Array indices...                     */
 517   const char *fmt;      /* Current rtx's format...              */
 518   rtx rt_val;           /* RTX to return to caller...           */
 519
 520   VA_OPEN (p, mode);
 521   VA_FIXEDARG (p, enum rtx_code, code);
 522   VA_FIXEDARG (p, enum machine_mode, mode);
 523
 524   switch (code)
 525     {
 526     case CONST_INT:
 527       rt_val = gen_rtx_CONST_INT (mode, va_arg (p, HOST_WIDE_INT));
 528       break;
 529
 530     case CONST_DOUBLE:
 531       {
 532         HOST_WIDE_INT arg0 = va_arg (p, HOST_WIDE_INT);
 533         HOST_WIDE_INT arg1 = va_arg (p, HOST_WIDE_INT);
 534
 535         rt_val = gen_rtx_CONST_DOUBLE (mode, arg0, arg1);
 536       }
 537       break;
 538
 539     case REG:
 540       rt_val = gen_rtx_REG (mode, va_arg (p, int));
 541       break;
 542
 543     case MEM:
 544       rt_val = gen_rtx_MEM (mode, va_arg (p, rtx));
 545       break;
 546
 547     default:
 548       rt_val = rtx_alloc (code);        /* Allocate the storage space.  */
 549       rt_val->mode = mode;              /* Store the machine mode...  */
 550
 551       fmt = GET_RTX_FORMAT (code);      /* Find the right format...  */
 552       for (i = 0; i < GET_RTX_LENGTH (code); i++)
 553         {
 554           switch (*fmt++)
 555             {
 556             case '0':           /* Unused field.  */
 557               break;
 558
 559             case 'i':           /* An integer?  */
 560               XINT (rt_val, i) = va_arg (p, int);
 561               break;
 562
 563             case 'w':           /* A wide integer? */
 564               XWINT (rt_val, i) = va_arg (p, HOST_WIDE_INT);
 565               break;
 566
 567             case 's':           /* A string?  */
 568               XSTR (rt_val, i) = va_arg (p, char *);
 569               break;
 570
 571             case 'e':           /* An expression?  */
 572             case 'u':           /* An insn?  Same except when printing.  */
 573               XEXP (rt_val, i) = va_arg (p, rtx);
 574               break;
 575
 576             case 'E':           /* An RTX vector?  */
 577               XVEC (rt_val, i) = va_arg (p, rtvec);
 578               break;
 579
 580             case 'b':           /* A bitmap? */
 581               XBITMAP (rt_val, i) = va_arg (p, bitmap);
 582               break;
 583
 584             case 't':           /* A tree? */
 585               XTREE (rt_val, i) = va_arg (p, tree);
 586               break;
 587
 588             default:
 589               abort ();
 590             }
 591         }
 592       break;
 593     }
 594
 595   VA_CLOSE (p);
 596   return rt_val;
 597 }
 598
 599 /* gen_rtvec (n, [rt1, ..., rtn])
 600 **
 601 **          This routine creates an rtvec and stores within it the
 602 **      pointers to rtx's which are its arguments.
 603 */
 604
 605 /*VARARGS1*/
 606 rtvec
 607 gen_rtvec VPARAMS ((int n, ...))
 608 {
 609   int i, save_n;
 610   rtx *vector;
 611
 612   VA_OPEN (p, n);
 613   VA_FIXEDARG (p, int, n);
 614
 615   if (n == 0)
 616     return NULL_RTVEC;          /* Don't allocate an empty rtvec...     */
 617
 618   vector = (rtx *) alloca (n * sizeof (rtx));
 619
 620   for (i = 0; i < n; i++)
 621     vector[i] = va_arg (p, rtx);
 622
 623   /* The definition of VA_* in K&R C causes `n' to go out of scope.  */
 624   save_n = n;
 625   VA_CLOSE (p);
 626
 627   return gen_rtvec_v (save_n, vector);
 628 }
 629
 630 rtvec
 631 gen_rtvec_v (n, argp)
 632      int n;
 633      rtx *argp;
 634 {
 635   int i;
 636   rtvec rt_val;
 637
 638   if (n == 0)
 639     return NULL_RTVEC;          /* Don't allocate an empty rtvec...     */
 640
 641   rt_val = rtvec_alloc (n);     /* Allocate an rtvec...                 */
 642
 643   for (i = 0; i < n; i++)
 644     rt_val->elem[i] = *argp++;
 645
 646   return rt_val;
 647 }
 648 \f
 649 /* Generate a REG rtx for a new pseudo register of mode MODE.
 650    This pseudo is assigned the next sequential register number.  */
 651
 652 rtx
 653 gen_reg_rtx (mode)
 654      enum machine_mode mode;
 655 {
 656   struct function *f = cfun;
 657   rtx val;
 658
 659   /* Don't let anything called after initial flow analysis create new
 660      registers.  */
 661   if (no_new_pseudos)
 662     abort ();
 663
 664   if (generating_concat_p
 665       && (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT
 666           || GET_MODE_CLASS (mode) == MODE_COMPLEX_INT))
 667     {
 668       /* For complex modes, don't make a single pseudo.
 669          Instead, make a CONCAT of two pseudos.
 670          This allows noncontiguous allocation of the real and imaginary parts,
 671          which makes much better code.  Besides, allocating DCmode
 672          pseudos overstrains reload on some machines like the 386.  */
 673       rtx realpart, imagpart;
 674       int size = GET_MODE_UNIT_SIZE (mode);
 675       enum machine_mode partmode
 676         = mode_for_size (size * BITS_PER_UNIT,
 677                          (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT
 678                           ? MODE_FLOAT : MODE_INT),
 679                          0);
 680
 681       realpart = gen_reg_rtx (partmode);
 682       imagpart = gen_reg_rtx (partmode);
 683       return gen_rtx_CONCAT (mode, realpart, imagpart);
 684     }
 685
 686   /* Make sure regno_pointer_align, regno_decl, and regno_reg_rtx are large
 687      enough to have an element for this pseudo reg number.  */
 688
 689   if (reg_rtx_no == f->emit->regno_pointer_align_length)
 690     {
 691       int old_size = f->emit->regno_pointer_align_length;
 692       char *new;
 693       rtx *new1;
 694       tree *new2;
 695
 696       new = xrealloc (f->emit->regno_pointer_align, old_size * 2);
 697       memset (new + old_size, 0, old_size);
 698       f->emit->regno_pointer_align = (unsigned char *) new;
 699
 700       new1 = (rtx *) xrealloc (f->emit->x_regno_reg_rtx,
 701                                old_size * 2 * sizeof (rtx));
 702       memset (new1 + old_size, 0, old_size * sizeof (rtx));
 703       regno_reg_rtx = new1;
 704
 705       new2 = (tree *) xrealloc (f->emit->regno_decl,
 706                                 old_size * 2 * sizeof (tree));
 707       memset (new2 + old_size, 0, old_size * sizeof (tree));
 708       f->emit->regno_decl = new2;
 709
 710       f->emit->regno_pointer_align_length = old_size * 2;
 711     }
 712
 713   val = gen_raw_REG (mode, reg_rtx_no);
 714   regno_reg_rtx[reg_rtx_no++] = val;
 715   return val;
 716 }
 717
 718 /* Identify REG (which may be a CONCAT) as a user register.  */
 719
 720 void
 721 mark_user_reg (reg)
 722      rtx reg;
 723 {
 724   if (GET_CODE (reg) == CONCAT)
 725     {
 726       REG_USERVAR_P (XEXP (reg, 0)) = 1;
 727       REG_USERVAR_P (XEXP (reg, 1)) = 1;
 728     }
 729   else if (GET_CODE (reg) == REG)
 730     REG_USERVAR_P (reg) = 1;
 731   else
 732     abort ();
 733 }
 734
 735 /* Identify REG as a probable pointer register and show its alignment
 736    as ALIGN, if nonzero.  */
 737
 738 void
 739 mark_reg_pointer (reg, align)
 740      rtx reg;
 741      int align;
 742 {
 743   if (! REG_POINTER (reg))
 744     {
 745       REG_POINTER (reg) = 1;
 746
 747       if (align)
 748         REGNO_POINTER_ALIGN (REGNO (reg)) = align;
 749     }
 750   else if (align && align < REGNO_POINTER_ALIGN (REGNO (reg)))
 751     /* We can no-longer be sure just how aligned this pointer is */
 752     REGNO_POINTER_ALIGN (REGNO (reg)) = align;
 753 }
 754
 755 /* Return 1 plus largest pseudo reg number used in the current function.  */
 756
 757 int
 758 max_reg_num ()
 759 {
 760   return reg_rtx_no;
 761 }
 762
 763 /* Return 1 + the largest label number used so far in the current function.  */
 764
 765 int
 766 max_label_num ()
 767 {
 768   if (last_label_num && label_num == base_label_num)
 769     return last_label_num;
 770   return label_num;
 771 }
 772
 773 /* Return first label number used in this function (if any were used).  */
 774
 775 int
 776 get_first_label_num ()
 777 {
 778   return first_label_num;
 779 }
 780 \f
 781 /* Return the final regno of X, which is a SUBREG of a hard
 782    register.  */
 783 int
 784 subreg_hard_regno (x, check_mode)
 785      rtx x;
 786      int check_mode;
 787 {
 788   enum machine_mode mode = GET_MODE (x);
 789   unsigned int byte_offset, base_regno, final_regno;
 790   rtx reg = SUBREG_REG (x);
 791
 792   /* This is where we attempt to catch illegal subregs
 793      created by the compiler.  */
 794   if (GET_CODE (x) != SUBREG
 795       || GET_CODE (reg) != REG)
 796     abort ();
 797   base_regno = REGNO (reg);
 798   if (base_regno >= FIRST_PSEUDO_REGISTER)
 799     abort ();
 800   if (check_mode && ! HARD_REGNO_MODE_OK (base_regno, GET_MODE (reg)))
 801     abort ();
 802
 803   /* Catch non-congruent offsets too.  */
 804   byte_offset = SUBREG_BYTE (x);
 805   if ((byte_offset % GET_MODE_SIZE (mode)) != 0)
 806     abort ();
 807
 808   final_regno = subreg_regno (x);
 809
 810   return final_regno;
 811 }
 812
 813 /* Return a value representing some low-order bits of X, where the number
 814    of low-order bits is given by MODE.  Note that no conversion is done
 815    between floating-point and fixed-point values, rather, the bit
 816    representation is returned.
 817
 818    This function handles the cases in common between gen_lowpart, below,
 819    and two variants in cse.c and combine.c.  These are the cases that can
 820    be safely handled at all points in the compilation.
 821
 822    If this is not a case we can handle, return 0.  */
 823
 824 rtx
 825 gen_lowpart_common (mode, x)
 826      enum machine_mode mode;
 827      rtx x;
 828 {
 829   int msize = GET_MODE_SIZE (mode);
 830   int xsize = GET_MODE_SIZE (GET_MODE (x));
 831   int offset = 0;
 832
 833   if (GET_MODE (x) == mode)
 834     return x;
 835
 836   /* MODE must occupy no more words than the mode of X.  */
 837   if (GET_MODE (x) != VOIDmode
 838       && ((msize + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD
 839           > ((xsize + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)))
 840     return 0;
 841
 842   offset = subreg_lowpart_offset (mode, GET_MODE (x));
 843
 844   if ((GET_CODE (x) == ZERO_EXTEND || GET_CODE (x) == SIGN_EXTEND)
 845       && (GET_MODE_CLASS (mode) == MODE_INT
 846           || GET_MODE_CLASS (mode) == MODE_PARTIAL_INT))
 847     {
 848       /* If we are getting the low-order part of something that has been
 849          sign- or zero-extended, we can either just use the object being
 850          extended or make a narrower extension.  If we want an even smaller
 851          piece than the size of the object being extended, call ourselves
 852          recursively.
 853
 854          This case is used mostly by combine and cse.  */
 855
 856       if (GET_MODE (XEXP (x, 0)) == mode)
 857         return XEXP (x, 0);
 858       else if (GET_MODE_SIZE (mode) < GET_MODE_SIZE (GET_MODE (XEXP (x, 0))))
 859         return gen_lowpart_common (mode, XEXP (x, 0));
 860       else if (GET_MODE_SIZE (mode) < GET_MODE_SIZE (GET_MODE (x)))
 861         return gen_rtx_fmt_e (GET_CODE (x), mode, XEXP (x, 0));
 862     }
 863   else if (GET_CODE (x) == SUBREG || GET_CODE (x) == REG
 864            || GET_CODE (x) == CONCAT)
 865     return simplify_gen_subreg (mode, x, GET_MODE (x), offset);
 866   /* If X is a CONST_INT or a CONST_DOUBLE, extract the appropriate bits
 867      from the low-order part of the constant.  */
 868   else if ((GET_MODE_CLASS (mode) == MODE_INT
 869             || GET_MODE_CLASS (mode) == MODE_PARTIAL_INT)
 870            && GET_MODE (x) == VOIDmode
 871            && (GET_CODE (x) == CONST_INT || GET_CODE (x) == CONST_DOUBLE))
 872     {
 873       /* If MODE is twice the host word size, X is already the desired
 874          representation.  Otherwise, if MODE is wider than a word, we can't
 875          do this.  If MODE is exactly a word, return just one CONST_INT.  */
 876
 877       if (GET_MODE_BITSIZE (mode) >= 2 * HOST_BITS_PER_WIDE_INT)
 878         return x;
 879       else if (GET_MODE_BITSIZE (mode) > HOST_BITS_PER_WIDE_INT)
 880         return 0;
 881       else if (GET_MODE_BITSIZE (mode) == HOST_BITS_PER_WIDE_INT)
 882         return (GET_CODE (x) == CONST_INT ? x
 883                 : GEN_INT (CONST_DOUBLE_LOW (x)));
 884       else
 885         {
 886           /* MODE must be narrower than HOST_BITS_PER_WIDE_INT.  */
 887           HOST_WIDE_INT val = (GET_CODE (x) == CONST_INT ? INTVAL (x)
 888                                : CONST_DOUBLE_LOW (x));
 889
 890           /* Sign extend to HOST_WIDE_INT.  */
 891           val = trunc_int_for_mode (val, mode);
 892
 893           return (GET_CODE (x) == CONST_INT && INTVAL (x) == val ? x
 894                   : GEN_INT (val));
 895         }
 896     }
 897
 898   /* The floating-point emulator can handle all conversions between
 899      FP and integer operands.  This simplifies reload because it
 900      doesn't have to deal with constructs like (subreg:DI
 901      (const_double:SF ...)) or (subreg:DF (const_int ...)).  */
 902   /* Single-precision floats are always 32-bits and double-precision
 903      floats are always 64-bits.  */
 904
 905   else if (GET_MODE_CLASS (mode) == MODE_FLOAT
 906            && GET_MODE_BITSIZE (mode) == 32
 907            && GET_CODE (x) == CONST_INT)
 908     {
 909       REAL_VALUE_TYPE r;
 910       HOST_WIDE_INT i;
 911
 912       i = INTVAL (x);
 913       r = REAL_VALUE_FROM_TARGET_SINGLE (i);
 914       return CONST_DOUBLE_FROM_REAL_VALUE (r, mode);
 915     }
 916   else if (GET_MODE_CLASS (mode) == MODE_FLOAT
 917            && GET_MODE_BITSIZE (mode) == 64
 918            && (GET_CODE (x) == CONST_INT || GET_CODE (x) == CONST_DOUBLE)
 919            && GET_MODE (x) == VOIDmode)
 920     {
 921       REAL_VALUE_TYPE r;
 922       HOST_WIDE_INT i[2];
 923       HOST_WIDE_INT low, high;
 924
 925       if (GET_CODE (x) == CONST_INT)
 926         {
 927           low = INTVAL (x);
 928           high = low >> (HOST_BITS_PER_WIDE_INT - 1);
 929         }
 930       else
 931         {
 932           low = CONST_DOUBLE_LOW (x);
 933           high = CONST_DOUBLE_HIGH (x);
 934         }
 935
 936 #if HOST_BITS_PER_WIDE_INT == 32
 937       /* REAL_VALUE_TARGET_DOUBLE takes the addressing order of the
 938          target machine.  */
 939       if (WORDS_BIG_ENDIAN)
 940         i[0] = high, i[1] = low;
 941       else
 942         i[0] = low, i[1] = high;
 943 #else
 944       i[0] = low;
 945 #endif
 946
 947       r = REAL_VALUE_FROM_TARGET_DOUBLE (i);
 948       return CONST_DOUBLE_FROM_REAL_VALUE (r, mode);
 949     }
 950   else if ((GET_MODE_CLASS (mode) == MODE_INT
 951             || GET_MODE_CLASS (mode) == MODE_PARTIAL_INT)
 952            && GET_CODE (x) == CONST_DOUBLE
 953            && GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
 954     {
 955       REAL_VALUE_TYPE r;
 956       long i[4];  /* Only the low 32 bits of each 'long' are used.  */
 957       int endian = WORDS_BIG_ENDIAN ? 1 : 0;
 958
 959       /* Convert 'r' into an array of four 32-bit words in target word
 960          order.  */
 961       REAL_VALUE_FROM_CONST_DOUBLE (r, x);
 962       switch (GET_MODE_BITSIZE (GET_MODE (x)))
 963         {
 964         case 32:
 965           REAL_VALUE_TO_TARGET_SINGLE (r, i[3 * endian]);
 966           i[1] = 0;
 967           i[2] = 0;
 968           i[3 - 3 * endian] = 0;
 969           break;
 970         case 64:
 971           REAL_VALUE_TO_TARGET_DOUBLE (r, i + 2 * endian);
 972           i[2 - 2 * endian] = 0;
 973           i[3 - 2 * endian] = 0;
 974           break;
 975         case 96:
 976           REAL_VALUE_TO_TARGET_LONG_DOUBLE (r, i + endian);
 977           i[3 - 3 * endian] = 0;
 978           break;
 979         case 128:
 980           REAL_VALUE_TO_TARGET_LONG_DOUBLE (r, i);
 981           break;
 982         default:
 983           abort ();
 984         }
 985       /* Now, pack the 32-bit elements of the array into a CONST_DOUBLE
 986          and return it.  */
 987 #if HOST_BITS_PER_WIDE_INT == 32
 988       return immed_double_const (i[3 * endian], i[1 + endian], mode);
 989 #else
 990       if (HOST_BITS_PER_WIDE_INT != 64)
 991         abort ();
 992
 993       return immed_double_const ((((unsigned long) i[3 * endian])
 994                                   | ((HOST_WIDE_INT) i[1 + endian] << 32)),
 995                                  (((unsigned long) i[2 - endian])
 996                                   | ((HOST_WIDE_INT) i[3 - 3 * endian] << 32)),
 997                                  mode);
 998 #endif
 999     }
1000
1001   /* Otherwise, we can't do this.  */
1002   return 0;
1003 }
1004 \f
1005 /* Return the real part (which has mode MODE) of a complex value X.
1006    This always comes at the low address in memory.  */
1007
1008 rtx
1009 gen_realpart (mode, x)
1010      enum machine_mode mode;
1011      rtx x;
1012 {
1013   if (WORDS_BIG_ENDIAN
1014       && GET_MODE_BITSIZE (mode) < BITS_PER_WORD
1015       && REG_P (x)
1016       && REGNO (x) < FIRST_PSEUDO_REGISTER)
1017     internal_error
1018       ("can't access real part of complex value in hard register");
1019   else if (WORDS_BIG_ENDIAN)
1020     return gen_highpart (mode, x);
1021   else
1022     return gen_lowpart (mode, x);
1023 }
1024
1025 /* Return the imaginary part (which has mode MODE) of a complex value X.
1026    This always comes at the high address in memory.  */
1027
1028 rtx
1029 gen_imagpart (mode, x)
1030      enum machine_mode mode;
1031      rtx x;
1032 {
1033   if (WORDS_BIG_ENDIAN)
1034     return gen_lowpart (mode, x);
1035   else if (! WORDS_BIG_ENDIAN
1036            && GET_MODE_BITSIZE (mode) < BITS_PER_WORD
1037            && REG_P (x)
1038            && REGNO (x) < FIRST_PSEUDO_REGISTER)
1039     internal_error
1040       ("can't access imaginary part of complex value in hard register");
1041   else
1042     return gen_highpart (mode, x);
1043 }
1044
1045 /* Return 1 iff X, assumed to be a SUBREG,
1046    refers to the real part of the complex value in its containing reg.
1047    Complex values are always stored with the real part in the first word,
1048    regardless of WORDS_BIG_ENDIAN.  */
1049
1050 int
1051 subreg_realpart_p (x)
1052      rtx x;
1053 {
1054   if (GET_CODE (x) != SUBREG)
1055     abort ();
1056
1057   return ((unsigned int) SUBREG_BYTE (x)
1058           < GET_MODE_UNIT_SIZE (GET_MODE (SUBREG_REG (x))));
1059 }
1060 \f
1061 /* Assuming that X is an rtx (e.g., MEM, REG or SUBREG) for a value,
1062    return an rtx (MEM, SUBREG, or CONST_INT) that refers to the
1063    least-significant part of X.
1064    MODE specifies how big a part of X to return;
1065    it usually should not be larger than a word.
1066    If X is a MEM whose address is a QUEUED, the value may be so also.  */
1067
1068 rtx
1069 gen_lowpart (mode, x)
1070      enum machine_mode mode;
1071      rtx x;
1072 {
1073   rtx result = gen_lowpart_common (mode, x);
1074
1075   if (result)
1076     return result;
1077   else if (GET_CODE (x) == REG)
1078     {
1079       /* Must be a hard reg that's not valid in MODE.  */
1080       result = gen_lowpart_common (mode, copy_to_reg (x));
1081       if (result == 0)
1082         abort ();
1083       return result;
1084     }
1085   else if (GET_CODE (x) == MEM)
1086     {
1087       /* The only additional case we can do is MEM.  */
1088       int offset = 0;
1089       if (WORDS_BIG_ENDIAN)
1090         offset = (MAX (GET_MODE_SIZE (GET_MODE (x)), UNITS_PER_WORD)
1091                   - MAX (GET_MODE_SIZE (mode), UNITS_PER_WORD));
1092
1093       if (BYTES_BIG_ENDIAN)
1094         /* Adjust the address so that the address-after-the-data
1095            is unchanged.  */
1096         offset -= (MIN (UNITS_PER_WORD, GET_MODE_SIZE (mode))
1097                    - MIN (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (x))));
1098
1099       return adjust_address (x, mode, offset);
1100     }
1101   else if (GET_CODE (x) == ADDRESSOF)
1102     return gen_lowpart (mode, force_reg (GET_MODE (x), x));
1103   else
1104     abort ();
1105 }
1106
1107 /* Like `gen_lowpart', but refer to the most significant part.
1108    This is used to access the imaginary part of a complex number.  */
1109
1110 rtx
1111 gen_highpart (mode, x)
1112      enum machine_mode mode;
1113      rtx x;
1114 {
1115   unsigned int msize = GET_MODE_SIZE (mode);
1116   rtx result;
1117
1118   /* This case loses if X is a subreg.  To catch bugs early,
1119      complain if an invalid MODE is used even in other cases.  */
1120   if (msize > UNITS_PER_WORD
1121       && msize != GET_MODE_UNIT_SIZE (GET_MODE (x)))
1122     abort ();
1123
1124   result = simplify_gen_subreg (mode, x, GET_MODE (x),
1125                                 subreg_highpart_offset (mode, GET_MODE (x)));
1126
1127   /* simplify_gen_subreg is not guaranteed to return a valid operand for
1128      the target if we have a MEM.  gen_highpart must return a valid operand,
1129      emitting code if necessary to do so.  */
1130   if (result != NULL_RTX && GET_CODE (result) == MEM)
1131     result = validize_mem (result);
1132
1133   if (!result)
1134     abort ();
1135   return result;
1136 }
1137
1138 /* Like gen_highpart_mode, but accept mode of EXP operand in case EXP can
1139    be VOIDmode constant.  */
1140 rtx
1141 gen_highpart_mode (outermode, innermode, exp)
1142      enum machine_mode outermode, innermode;
1143      rtx exp;
1144 {
1145   if (GET_MODE (exp) != VOIDmode)
1146     {
1147       if (GET_MODE (exp) != innermode)
1148         abort ();
1149       return gen_highpart (outermode, exp);
1150     }
1151   return simplify_gen_subreg (outermode, exp, innermode,
1152                               subreg_highpart_offset (outermode, innermode));
1153 }
1154
1155 /* Return offset in bytes to get OUTERMODE low part
1156    of the value in mode INNERMODE stored in memory in target format.  */
1157
1158 unsigned int
1159 subreg_lowpart_offset (outermode, innermode)
1160      enum machine_mode outermode, innermode;
1161 {
1162   unsigned int offset = 0;
1163   int difference = (GET_MODE_SIZE (innermode) - GET_MODE_SIZE (outermode));
1164
1165   if (difference > 0)
1166     {
1167       if (WORDS_BIG_ENDIAN)
1168         offset += (difference / UNITS_PER_WORD) * UNITS_PER_WORD;
1169       if (BYTES_BIG_ENDIAN)
1170         offset += difference % UNITS_PER_WORD;
1171     }
1172
1173   return offset;
1174 }
1175
1176 /* Return offset in bytes to get OUTERMODE high part
1177    of the value in mode INNERMODE stored in memory in target format.  */
1178 unsigned int
1179 subreg_highpart_offset (outermode, innermode)
1180      enum machine_mode outermode, innermode;
1181 {
1182   unsigned int offset = 0;
1183   int difference = (GET_MODE_SIZE (innermode) - GET_MODE_SIZE (outermode));
1184
1185   if (GET_MODE_SIZE (innermode) < GET_MODE_SIZE (outermode))
1186     abort ();
1187
1188   if (difference > 0)
1189     {
1190       if (! WORDS_BIG_ENDIAN)
1191         offset += (difference / UNITS_PER_WORD) * UNITS_PER_WORD;
1192       if (! BYTES_BIG_ENDIAN)
1193         offset += difference % UNITS_PER_WORD;
1194     }
1195
1196   return offset;
1197 }
1198
1199 /* Return 1 iff X, assumed to be a SUBREG,
1200    refers to the least significant part of its containing reg.
1201    If X is not a SUBREG, always return 1 (it is its own low part!).  */
1202
1203 int
1204 subreg_lowpart_p (x)
1205      rtx x;
1206 {
1207   if (GET_CODE (x) != SUBREG)
1208     return 1;
1209   else if (GET_MODE (SUBREG_REG (x)) == VOIDmode)
1210     return 0;
1211
1212   return (subreg_lowpart_offset (GET_MODE (x), GET_MODE (SUBREG_REG (x)))
1213           == SUBREG_BYTE (x));
1214 }
1215 \f
1216
1217 /* Helper routine for all the constant cases of operand_subword.
1218    Some places invoke this directly.  */
1219
1220 rtx
1221 constant_subword (op, offset, mode)
1222      rtx op;
1223      int offset;
1224      enum machine_mode mode;
1225 {
1226   int size_ratio = HOST_BITS_PER_WIDE_INT / BITS_PER_WORD;
1227   HOST_WIDE_INT val;
1228
1229   /* If OP is already an integer word, return it.  */
1230   if (GET_MODE_CLASS (mode) == MODE_INT
1231       && GET_MODE_SIZE (mode) == UNITS_PER_WORD)
1232     return op;
1233
1234   /* The output is some bits, the width of the target machine's word.
1235      A wider-word host can surely hold them in a CONST_INT. A narrower-word
1236      host can't.  */
1237   if (HOST_BITS_PER_WIDE_INT >= BITS_PER_WORD
1238       && GET_MODE_CLASS (mode) == MODE_FLOAT
1239       && GET_MODE_BITSIZE (mode) == 64
1240       && GET_CODE (op) == CONST_DOUBLE)
1241     {
1242       long k[2];
1243       REAL_VALUE_TYPE rv;
1244
1245       REAL_VALUE_FROM_CONST_DOUBLE (rv, op);
1246       REAL_VALUE_TO_TARGET_DOUBLE (rv, k);
1247
1248       /* We handle 32-bit and >= 64-bit words here.  Note that the order in
1249          which the words are written depends on the word endianness.
1250          ??? This is a potential portability problem and should
1251          be fixed at some point.
1252
1253          We must exercise caution with the sign bit.  By definition there
1254          are 32 significant bits in K; there may be more in a HOST_WIDE_INT.
1255          Consider a host with a 32-bit long and a 64-bit HOST_WIDE_INT.
1256          So we explicitly mask and sign-extend as necessary.  */
1257       if (BITS_PER_WORD == 32)
1258         {
1259           val = k[offset];
1260           val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000;
1261           return GEN_INT (val);
1262         }
1263 #if HOST_BITS_PER_WIDE_INT >= 64
1264       else if (BITS_PER_WORD >= 64 && offset == 0)
1265         {
1266           val = k[! WORDS_BIG_ENDIAN];
1267           val = (((val & 0xffffffff) ^ 0x80000000) - 0x80000000) << 32;
1268           val |= (HOST_WIDE_INT) k[WORDS_BIG_ENDIAN] & 0xffffffff;
1269           return GEN_INT (val);
1270         }
1271 #endif
1272       else if (BITS_PER_WORD == 16)
1273         {
1274           val = k[offset >> 1];
1275           if ((offset & 1) == ! WORDS_BIG_ENDIAN)
1276             val >>= 16;
1277           val = ((val & 0xffff) ^ 0x8000) - 0x8000;
1278           return GEN_INT (val);
1279         }
1280       else
1281         abort ();
1282     }
1283   else if (HOST_BITS_PER_WIDE_INT >= BITS_PER_WORD
1284            && GET_MODE_CLASS (mode) == MODE_FLOAT
1285            && GET_MODE_BITSIZE (mode) > 64
1286            && GET_CODE (op) == CONST_DOUBLE)
1287     {
1288       long k[4];
1289       REAL_VALUE_TYPE rv;
1290
1291       REAL_VALUE_FROM_CONST_DOUBLE (rv, op);
1292       REAL_VALUE_TO_TARGET_LONG_DOUBLE (rv, k);
1293
1294       if (BITS_PER_WORD == 32)
1295         {
1296           val = k[offset];
1297           val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000;
1298           return GEN_INT (val);
1299         }
1300 #if HOST_BITS_PER_WIDE_INT >= 64
1301       else if (BITS_PER_WORD >= 64 && offset <= 1)
1302         {
1303           val = k[offset * 2 + ! WORDS_BIG_ENDIAN];
1304           val = (((val & 0xffffffff) ^ 0x80000000) - 0x80000000) << 32;
1305           val |= (HOST_WIDE_INT) k[offset * 2 + WORDS_BIG_ENDIAN] & 0xffffffff;
1306           return GEN_INT (val);
1307         }
1308 #endif
1309       else
1310         abort ();
1311     }
1312
1313   /* Single word float is a little harder, since single- and double-word
1314      values often do not have the same high-order bits.  We have already
1315      verified that we want the only defined word of the single-word value.  */
1316   if (GET_MODE_CLASS (mode) == MODE_FLOAT
1317       && GET_MODE_BITSIZE (mode) == 32
1318       && GET_CODE (op) == CONST_DOUBLE)
1319     {
1320       long l;
1321       REAL_VALUE_TYPE rv;
1322
1323       REAL_VALUE_FROM_CONST_DOUBLE (rv, op);
1324       REAL_VALUE_TO_TARGET_SINGLE (rv, l);
1325
1326       /* Sign extend from known 32-bit value to HOST_WIDE_INT.  */
1327       val = l;
1328       val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000;
1329
1330       if (BITS_PER_WORD == 16)
1331         {
1332           if ((offset & 1) == ! WORDS_BIG_ENDIAN)
1333             val >>= 16;
1334           val = ((val & 0xffff) ^ 0x8000) - 0x8000;
1335         }
1336
1337       return GEN_INT (val);
1338     }
1339
1340   /* The only remaining cases that we can handle are integers.
1341      Convert to proper endianness now since these cases need it.
1342      At this point, offset == 0 means the low-order word.
1343
1344      We do not want to handle the case when BITS_PER_WORD <= HOST_BITS_PER_INT
1345      in general.  However, if OP is (const_int 0), we can just return
1346      it for any word.  */
1347
1348   if (op == const0_rtx)
1349     return op;
1350
1351   if (GET_MODE_CLASS (mode) != MODE_INT
1352       || (GET_CODE (op) != CONST_INT && GET_CODE (op) != CONST_DOUBLE)
1353       || BITS_PER_WORD > HOST_BITS_PER_WIDE_INT)
1354     return 0;
1355
1356   if (WORDS_BIG_ENDIAN)
1357     offset = GET_MODE_SIZE (mode) / UNITS_PER_WORD - 1 - offset;
1358
1359   /* Find out which word on the host machine this value is in and get
1360      it from the constant.  */
1361   val = (offset / size_ratio == 0
1362          ? (GET_CODE (op) == CONST_INT ? INTVAL (op) : CONST_DOUBLE_LOW (op))
1363          : (GET_CODE (op) == CONST_INT
1364             ? (INTVAL (op) < 0 ? ~0 : 0) : CONST_DOUBLE_HIGH (op)));
1365
1366   /* Get the value we want into the low bits of val.  */
1367   if (BITS_PER_WORD < HOST_BITS_PER_WIDE_INT)
1368     val = ((val >> ((offset % size_ratio) * BITS_PER_WORD)));
1369
1370   val = trunc_int_for_mode (val, word_mode);
1371
1372   return GEN_INT (val);
1373 }
1374
1375 /* Return subword OFFSET of operand OP.
1376    The word number, OFFSET, is interpreted as the word number starting
1377    at the low-order address.  OFFSET 0 is the low-order word if not
1378    WORDS_BIG_ENDIAN, otherwise it is the high-order word.
1379
1380    If we cannot extract the required word, we return zero.  Otherwise,
1381    an rtx corresponding to the requested word will be returned.
1382
1383    VALIDATE_ADDRESS is nonzero if the address should be validated.  Before
1384    reload has completed, a valid address will always be returned.  After
1385    reload, if a valid address cannot be returned, we return zero.
1386
1387    If VALIDATE_ADDRESS is zero, we simply form the required address; validating
1388    it is the responsibility of the caller.
1389
1390    MODE is the mode of OP in case it is a CONST_INT.
1391
1392    ??? This is still rather broken for some cases.  The problem for the
1393    moment is that all callers of this thing provide no 'goal mode' to
1394    tell us to work with.  This exists because all callers were written
1395    in a word based SUBREG world.
1396    Now use of this function can be deprecated by simplify_subreg in most
1397    cases.
1398  */
1399
1400 rtx
1401 operand_subword (op, offset, validate_address, mode)
1402      rtx op;
1403      unsigned int offset;
1404      int validate_address;
1405      enum machine_mode mode;
1406 {
1407   if (mode == VOIDmode)
1408     mode = GET_MODE (op);
1409
1410   if (mode == VOIDmode)
1411     abort ();
1412
1413   /* If OP is narrower than a word, fail.  */
1414   if (mode != BLKmode
1415       && (GET_MODE_SIZE (mode) < UNITS_PER_WORD))
1416     return 0;
1417
1418   /* If we want a word outside OP, return zero.  */
1419   if (mode != BLKmode
1420       && (offset + 1) * UNITS_PER_WORD > GET_MODE_SIZE (mode))
1421     return const0_rtx;
1422
1423   /* Form a new MEM at the requested address.  */
1424   if (GET_CODE (op) == MEM)
1425     {
1426       rtx new = adjust_address_nv (op, word_mode, offset * UNITS_PER_WORD);
1427
1428       if (! validate_address)
1429         return new;
1430
1431       else if (reload_completed)
1432         {
1433           if (! strict_memory_address_p (word_mode, XEXP (new, 0)))
1434             return 0;
1435         }
1436       else
1437         return replace_equiv_address (new, XEXP (new, 0));
1438     }
1439
1440   /* Rest can be handled by simplify_subreg.  */
1441   return simplify_gen_subreg (word_mode, op, mode, (offset * UNITS_PER_WORD));
1442 }
1443
1444 /* Similar to `operand_subword', but never return 0.  If we can't extract
1445    the required subword, put OP into a register and try again.  If that fails,
1446    abort.  We always validate the address in this case.
1447
1448    MODE is the mode of OP, in case it is CONST_INT.  */
1449
1450 rtx
1451 operand_subword_force (op, offset, mode)
1452      rtx op;
1453      unsigned int offset;
1454      enum machine_mode mode;
1455 {
1456   rtx result = operand_subword (op, offset, 1, mode);
1457
1458   if (result)
1459     return result;
1460
1461   if (mode != BLKmode && mode != VOIDmode)
1462     {
1463       /* If this is a register which can not be accessed by words, copy it
1464          to a pseudo register.  */
1465       if (GET_CODE (op) == REG)
1466         op = copy_to_reg (op);
1467       else
1468         op = force_reg (mode, op);
1469     }
1470
1471   result = operand_subword (op, offset, 1, mode);
1472   if (result == 0)
1473     abort ();
1474
1475   return result;
1476 }
1477 \f
1478 /* Given a compare instruction, swap the operands.
1479    A test instruction is changed into a compare of 0 against the operand.  */
1480
1481 void
1482 reverse_comparison (insn)
1483      rtx insn;
1484 {
1485   rtx body = PATTERN (insn);
1486   rtx comp;
1487
1488   if (GET_CODE (body) == SET)
1489     comp = SET_SRC (body);
1490   else
1491     comp = SET_SRC (XVECEXP (body, 0, 0));
1492
1493   if (GET_CODE (comp) == COMPARE)
1494     {
1495       rtx op0 = XEXP (comp, 0);
1496       rtx op1 = XEXP (comp, 1);
1497       XEXP (comp, 0) = op1;
1498       XEXP (comp, 1) = op0;
1499     }
1500   else
1501     {
1502       rtx new = gen_rtx_COMPARE (VOIDmode,
1503                                  CONST0_RTX (GET_MODE (comp)), comp);
1504       if (GET_CODE (body) == SET)
1505         SET_SRC (body) = new;
1506       else
1507         SET_SRC (XVECEXP (body, 0, 0)) = new;
1508     }
1509 }
1510 \f
1511 /* Within a MEM_EXPR, we care about either (1) a component ref of a decl,
1512    or (2) a component ref of something variable.  Represent the later with
1513    a NULL expression.  */
1514
1515 static tree
1516 component_ref_for_mem_expr (ref)
1517      tree ref;
1518 {
1519   tree inner = TREE_OPERAND (ref, 0);
1520
1521   if (TREE_CODE (inner) == COMPONENT_REF)
1522     inner = component_ref_for_mem_expr (inner);
1523   else
1524     {
1525       tree placeholder_ptr = 0;
1526
1527       /* Now remove any conversions: they don't change what the underlying
1528          object is.  Likewise for SAVE_EXPR.  Also handle PLACEHOLDER_EXPR.  */
1529       while (TREE_CODE (inner) == NOP_EXPR || TREE_CODE (inner) == CONVERT_EXPR
1530              || TREE_CODE (inner) == NON_LVALUE_EXPR
1531              || TREE_CODE (inner) == VIEW_CONVERT_EXPR
1532              || TREE_CODE (inner) == SAVE_EXPR
1533              || TREE_CODE (inner) == PLACEHOLDER_EXPR)
1534         if (TREE_CODE (inner) == PLACEHOLDER_EXPR)
1535           inner = find_placeholder (inner, &placeholder_ptr);
1536         else
1537           inner = TREE_OPERAND (inner, 0);
1538
1539       if (! DECL_P (inner))
1540         inner = NULL_TREE;
1541     }
1542
1543   if (inner == TREE_OPERAND (ref, 0))
1544     return ref;
1545   else
1546     return build (COMPONENT_REF, TREE_TYPE (ref), inner,
1547                   TREE_OPERAND (ref, 1));
1548 }
1549
1550 /* Given REF, a MEM, and T, either the type of X or the expression
1551    corresponding to REF, set the memory attributes.  OBJECTP is nonzero
1552    if we are making a new object of this type.  */
1553
1554 void
1555 set_mem_attributes (ref, t, objectp)
1556      rtx ref;
1557      tree t;
1558      int objectp;
1559 {
1560   HOST_WIDE_INT alias = MEM_ALIAS_SET (ref);
1561   tree expr = MEM_EXPR (ref);
1562   rtx offset = MEM_OFFSET (ref);
1563   rtx size = MEM_SIZE (ref);
1564   unsigned int align = MEM_ALIGN (ref);
1565   tree type;
1566
1567   /* It can happen that type_for_mode was given a mode for which there
1568      is no language-level type.  In which case it returns NULL, which
1569      we can see here.  */
1570   if (t == NULL_TREE)
1571     return;
1572
1573   type = TYPE_P (t) ? t : TREE_TYPE (t);
1574
1575   /* If we have already set DECL_RTL = ref, get_alias_set will get the
1576      wrong answer, as it assumes that DECL_RTL already has the right alias
1577      info.  Callers should not set DECL_RTL until after the call to
1578      set_mem_attributes.  */
1579   if (DECL_P (t) && ref == DECL_RTL_IF_SET (t))
1580     abort ();
1581
1582   /* Get the alias set from the expression or type (perhaps using a
1583      front-end routine) and use it.  */
1584   alias = get_alias_set (t);
1585
1586   MEM_VOLATILE_P (ref) = TYPE_VOLATILE (type);
1587   MEM_IN_STRUCT_P (ref) = AGGREGATE_TYPE_P (type);
1588   RTX_UNCHANGING_P (ref)
1589     |= ((lang_hooks.honor_readonly
1590          && (TYPE_READONLY (type) || TREE_READONLY (t)))
1591         || (! TYPE_P (t) && TREE_CONSTANT (t)));
1592
1593   /* If we are making an object of this type, or if this is a DECL, we know
1594      that it is a scalar if the type is not an aggregate.  */
1595   if ((objectp || DECL_P (t)) && ! AGGREGATE_TYPE_P (type))
1596     MEM_SCALAR_P (ref) = 1;
1597
1598   /* We can set the alignment from the type if we are making an object,
1599      this is an INDIRECT_REF, or if TYPE_ALIGN_OK.  */
1600   if (objectp || TREE_CODE (t) == INDIRECT_REF || TYPE_ALIGN_OK (type))
1601     align = MAX (align, TYPE_ALIGN (type));
1602
1603   /* If the size is known, we can set that.  */
1604   if (TYPE_SIZE_UNIT (type) && host_integerp (TYPE_SIZE_UNIT (type), 1))
1605     size = GEN_INT (tree_low_cst (TYPE_SIZE_UNIT (type), 1));
1606
1607   /* If T is not a type, we may be able to deduce some more information about
1608      the expression.  */
1609   if (! TYPE_P (t))
1610     {
1611       maybe_set_unchanging (ref, t);
1612       if (TREE_THIS_VOLATILE (t))
1613         MEM_VOLATILE_P (ref) = 1;
1614
1615       /* Now remove any conversions: they don't change what the underlying
1616          object is.  Likewise for SAVE_EXPR.  */
1617       while (TREE_CODE (t) == NOP_EXPR || TREE_CODE (t) == CONVERT_EXPR
1618              || TREE_CODE (t) == NON_LVALUE_EXPR
1619              || TREE_CODE (t) == VIEW_CONVERT_EXPR
1620              || TREE_CODE (t) == SAVE_EXPR)
1621         t = TREE_OPERAND (t, 0);
1622
1623       /* If this expression can't be addressed (e.g., it contains a reference
1624          to a non-addressable field), show we don't change its alias set.  */
1625       if (! can_address_p (t))
1626         MEM_KEEP_ALIAS_SET_P (ref) = 1;
1627
1628       /* If this is a decl, set the attributes of the MEM from it.  */
1629       if (DECL_P (t))
1630         {
1631           expr = t;
1632           offset = const0_rtx;
1633           size = (DECL_SIZE_UNIT (t)
1634                   && host_integerp (DECL_SIZE_UNIT (t), 1)
1635                   ? GEN_INT (tree_low_cst (DECL_SIZE_UNIT (t), 1)) : 0);
1636           align = DECL_ALIGN (t);
1637         }
1638
1639       /* If this is a constant, we know the alignment.  */
1640       else if (TREE_CODE_CLASS (TREE_CODE (t)) == 'c')
1641         {
1642           align = TYPE_ALIGN (type);
1643 #ifdef CONSTANT_ALIGNMENT
1644           align = CONSTANT_ALIGNMENT (t, align);
1645 #endif
1646         }
1647
1648       /* If this is a field reference and not a bit-field, record it.  */
1649       /* ??? There is some information that can be gleened from bit-fields,
1650          such as the word offset in the structure that might be modified.
1651          But skip it for now.  */
1652       else if (TREE_CODE (t) == COMPONENT_REF
1653                && ! DECL_BIT_FIELD (TREE_OPERAND (t, 1)))
1654         {
1655           expr = component_ref_for_mem_expr (t);
1656           offset = const0_rtx;
1657           /* ??? Any reason the field size would be different than
1658              the size we got from the type?  */
1659         }
1660
1661       /* If this is an array reference, look for an outer field reference.  */
1662       else if (TREE_CODE (t) == ARRAY_REF)
1663         {
1664           tree off_tree = size_zero_node;
1665
1666           do
1667             {
1668               off_tree
1669                 = fold (build (PLUS_EXPR, sizetype,
1670                                fold (build (MULT_EXPR, sizetype,
1671                                             TREE_OPERAND (t, 1),
1672                                             TYPE_SIZE_UNIT (TREE_TYPE (t)))),
1673                                off_tree));
1674               t = TREE_OPERAND (t, 0);
1675             }
1676           while (TREE_CODE (t) == ARRAY_REF);
1677
1678           if (TREE_CODE (t) == COMPONENT_REF)
1679             {
1680               expr = component_ref_for_mem_expr (t);
1681               if (host_integerp (off_tree, 1))
1682                 offset = GEN_INT (tree_low_cst (off_tree, 1));
1683               /* ??? Any reason the field size would be different than
1684                  the size we got from the type?  */
1685             }
1686         }
1687     }
1688
1689   /* Now set the attributes we computed above.  */
1690   MEM_ATTRS (ref)
1691     = get_mem_attrs (alias, expr, offset, size, align, GET_MODE (ref));
1692
1693   /* If this is already known to be a scalar or aggregate, we are done.  */
1694   if (MEM_IN_STRUCT_P (ref) || MEM_SCALAR_P (ref))
1695     return;
1696
1697   /* If it is a reference into an aggregate, this is part of an aggregate.
1698      Otherwise we don't know.  */
1699   else if (TREE_CODE (t) == COMPONENT_REF || TREE_CODE (t) == ARRAY_REF
1700            || TREE_CODE (t) == ARRAY_RANGE_REF
1701            || TREE_CODE (t) == BIT_FIELD_REF)
1702     MEM_IN_STRUCT_P (ref) = 1;
1703 }
1704
1705 /* Set the alias set of MEM to SET.  */
1706
1707 void
1708 set_mem_alias_set (mem, set)
1709      rtx mem;
1710      HOST_WIDE_INT set;
1711 {
1712 #ifdef ENABLE_CHECKING
1713   /* If the new and old alias sets don't conflict, something is wrong.  */
1714   if (!alias_sets_conflict_p (set, MEM_ALIAS_SET (mem)))
1715     abort ();
1716 #endif
1717
1718   MEM_ATTRS (mem) = get_mem_attrs (set, MEM_EXPR (mem), MEM_OFFSET (mem),
1719                                    MEM_SIZE (mem), MEM_ALIGN (mem),
1720                                    GET_MODE (mem));
1721 }
1722
1723 /* Set the alignment of MEM to ALIGN bits.  */
1724
1725 void
1726 set_mem_align (mem, align)
1727      rtx mem;
1728      unsigned int align;
1729 {
1730   MEM_ATTRS (mem) = get_mem_attrs (MEM_ALIAS_SET (mem), MEM_EXPR (mem),
1731                                    MEM_OFFSET (mem), MEM_SIZE (mem), align,
1732                                    GET_MODE (mem));
1733 }
1734
1735 /* Set the expr for MEM to EXPR.  */
1736
1737 void
1738 set_mem_expr (mem, expr)
1739      rtx mem;
1740      tree expr;
1741 {
1742   MEM_ATTRS (mem)
1743     = get_mem_attrs (MEM_ALIAS_SET (mem), expr, MEM_OFFSET (mem),
1744                      MEM_SIZE (mem), MEM_ALIGN (mem), GET_MODE (mem));
1745 }
1746
1747 /* Set the offset of MEM to OFFSET.  */
1748
1749 void
1750 set_mem_offset (mem, offset)
1751      rtx mem, offset;
1752 {
1753   MEM_ATTRS (mem) = get_mem_attrs (MEM_ALIAS_SET (mem), MEM_EXPR (mem),
1754                                    offset, MEM_SIZE (mem), MEM_ALIGN (mem),
1755                                    GET_MODE (mem));
1756 }
1757 \f
1758 /* Return a memory reference like MEMREF, but with its mode changed to MODE
1759    and its address changed to ADDR.  (VOIDmode means don't change the mode.
1760    NULL for ADDR means don't change the address.)  VALIDATE is nonzero if the
1761    returned memory location is required to be valid.  The memory
1762    attributes are not changed.  */
1763
1764 static rtx
1765 change_address_1 (memref, mode, addr, validate)
1766      rtx memref;
1767      enum machine_mode mode;
1768      rtx addr;
1769      int validate;
1770 {
1771   rtx new;
1772
1773   if (GET_CODE (memref) != MEM)
1774     abort ();
1775   if (mode == VOIDmode)
1776     mode = GET_MODE (memref);
1777   if (addr == 0)
1778     addr = XEXP (memref, 0);
1779
1780   if (validate)
1781     {
1782       if (reload_in_progress || reload_completed)
1783         {
1784           if (! memory_address_p (mode, addr))
1785             abort ();
1786         }
1787       else
1788         addr = memory_address (mode, addr);
1789     }
1790
1791   if (rtx_equal_p (addr, XEXP (memref, 0)) && mode == GET_MODE (memref))
1792     return memref;
1793
1794   new = gen_rtx_MEM (mode, addr);
1795   MEM_COPY_ATTRIBUTES (new, memref);
1796   return new;
1797 }
1798
1799 /* Like change_address_1 with VALIDATE nonzero, but we are not saying in what
1800    way we are changing MEMREF, so we only preserve the alias set.  */
1801
1802 rtx
1803 change_address (memref, mode, addr)
1804      rtx memref;
1805      enum machine_mode mode;
1806      rtx addr;
1807 {
1808   rtx new = change_address_1 (memref, mode, addr, 1);
1809   enum machine_mode mmode = GET_MODE (new);
1810
1811   MEM_ATTRS (new)
1812     = get_mem_attrs (MEM_ALIAS_SET (memref), 0, 0,
1813                      mmode == BLKmode ? 0 : GEN_INT (GET_MODE_SIZE (mmode)),
1814                      (mmode == BLKmode ? BITS_PER_UNIT
1815                       : GET_MODE_ALIGNMENT (mmode)),
1816                      mmode);
1817
1818   return new;
1819 }
1820
1821 /* Return a memory reference like MEMREF, but with its mode changed
1822    to MODE and its address offset by OFFSET bytes.  If VALIDATE is
1823    nonzero, the memory address is forced to be valid.
1824    If ADJUST is zero, OFFSET is only used to update MEM_ATTRS
1825    and caller is responsible for adjusting MEMREF base register.  */
1826
1827 rtx
1828 adjust_address_1 (memref, mode, offset, validate, adjust)
1829      rtx memref;
1830      enum machine_mode mode;
1831      HOST_WIDE_INT offset;
1832      int validate, adjust;
1833 {
1834   rtx addr = XEXP (memref, 0);
1835   rtx new;
1836   rtx memoffset = MEM_OFFSET (memref);
1837   rtx size = 0;
1838   unsigned int memalign = MEM_ALIGN (memref);
1839
1840   /* ??? Prefer to create garbage instead of creating shared rtl.
1841      This may happen even if offset is non-zero -- consider
1842      (plus (plus reg reg) const_int) -- so do this always.  */
1843   addr = copy_rtx (addr);
1844
1845   if (adjust)
1846     {
1847       /* If MEMREF is a LO_SUM and the offset is within the alignment of the
1848          object, we can merge it into the LO_SUM.  */
1849       if (GET_MODE (memref) != BLKmode && GET_CODE (addr) == LO_SUM
1850           && offset >= 0
1851           && (unsigned HOST_WIDE_INT) offset
1852               < GET_MODE_ALIGNMENT (GET_MODE (memref)) / BITS_PER_UNIT)
1853         addr = gen_rtx_LO_SUM (Pmode, XEXP (addr, 0),
1854                                plus_constant (XEXP (addr, 1), offset));
1855       else
1856         addr = plus_constant (addr, offset);
1857     }
1858
1859   new = change_address_1 (memref, mode, addr, validate);
1860
1861   /* Compute the new values of the memory attributes due to this adjustment.
1862      We add the offsets and update the alignment.  */
1863   if (memoffset)
1864     memoffset = GEN_INT (offset + INTVAL (memoffset));
1865
1866   /* Compute the new alignment by taking the MIN of the alignment and the
1867      lowest-order set bit in OFFSET, but don't change the alignment if OFFSET
1868      if zero.  */
1869   if (offset != 0)
1870     memalign
1871       = MIN (memalign,
1872              (unsigned HOST_WIDE_INT) (offset & -offset) * BITS_PER_UNIT);
1873
1874   /* We can compute the size in a number of ways.  */
1875   if (GET_MODE (new) != BLKmode)
1876     size = GEN_INT (GET_MODE_SIZE (GET_MODE (new)));
1877   else if (MEM_SIZE (memref))
1878     size = plus_constant (MEM_SIZE (memref), -offset);
1879
1880   MEM_ATTRS (new) = get_mem_attrs (MEM_ALIAS_SET (memref), MEM_EXPR (memref),
1881                                    memoffset, size, memalign, GET_MODE (new));
1882
1883   /* At some point, we should validate that this offset is within the object,
1884      if all the appropriate values are known.  */
1885   return new;
1886 }
1887
1888 /* Return a memory reference like MEMREF, but with its mode changed
1889    to MODE and its address changed to ADDR, which is assumed to be
1890    MEMREF offseted by OFFSET bytes.  If VALIDATE is
1891    nonzero, the memory address is forced to be valid.  */
1892
1893 rtx
1894 adjust_automodify_address_1 (memref, mode, addr, offset, validate)
1895      rtx memref;
1896      enum machine_mode mode;
1897      rtx addr;
1898      HOST_WIDE_INT offset;
1899      int validate;
1900 {
1901   memref = change_address_1 (memref, VOIDmode, addr, validate);
1902   return adjust_address_1 (memref, mode, offset, validate, 0);
1903 }
1904
1905 /* Return a memory reference like MEMREF, but whose address is changed by
1906    adding OFFSET, an RTX, to it.  POW2 is the highest power of two factor
1907    known to be in OFFSET (possibly 1).  */
1908
1909 rtx
1910 offset_address (memref, offset, pow2)
1911      rtx memref;
1912      rtx offset;
1913      HOST_WIDE_INT pow2;
1914 {
1915   rtx new, addr = XEXP (memref, 0);
1916
1917   new = simplify_gen_binary (PLUS, Pmode, addr, offset);
1918
1919   /* At this point we don't know _why_ the address is invalid.  It
1920      could have secondary memory refereces, multiplies or anything.
1921
1922      However, if we did go and rearrange things, we can wind up not
1923      being able to recognize the magic around pic_offset_table_rtx.
1924      This stuff is fragile, and is yet another example of why it is
1925      bad to expose PIC machinery too early.  */
1926   if (! memory_address_p (GET_MODE (memref), new)
1927       && GET_CODE (addr) == PLUS
1928       && XEXP (addr, 0) == pic_offset_table_rtx)
1929     {
1930       addr = force_reg (GET_MODE (addr), addr);
1931       new = simplify_gen_binary (PLUS, Pmode, addr, offset);
1932     }
1933
1934   update_temp_slot_address (XEXP (memref, 0), new);
1935   new = change_address_1 (memref, VOIDmode, new, 1);
1936
1937   /* Update the alignment to reflect the offset.  Reset the offset, which
1938      we don't know.  */
1939   MEM_ATTRS (new)
1940     = get_mem_attrs (MEM_ALIAS_SET (memref), MEM_EXPR (memref), 0, 0,
1941                      MIN (MEM_ALIGN (memref),
1942                           (unsigned HOST_WIDE_INT) pow2 * BITS_PER_UNIT),
1943                      GET_MODE (new));
1944   return new;
1945 }
1946
1947 /* Return a memory reference like MEMREF, but with its address changed to
1948    ADDR.  The caller is asserting that the actual piece of memory pointed
1949    to is the same, just the form of the address is being changed, such as
1950    by putting something into a register.  */
1951
1952 rtx
1953 replace_equiv_address (memref, addr)
1954      rtx memref;
1955      rtx addr;
1956 {
1957   /* change_address_1 copies the memory attribute structure without change
1958      and that's exactly what we want here.  */
1959   update_temp_slot_address (XEXP (memref, 0), addr);
1960   return change_address_1 (memref, VOIDmode, addr, 1);
1961 }
1962
1963 /* Likewise, but the reference is not required to be valid.  */
1964
1965 rtx
1966 replace_equiv_address_nv (memref, addr)
1967      rtx memref;
1968      rtx addr;
1969 {
1970   return change_address_1 (memref, VOIDmode, addr, 0);
1971 }
1972
1973 /* Return a memory reference like MEMREF, but with its mode widened to
1974    MODE and offset by OFFSET.  This would be used by targets that e.g.
1975    cannot issue QImode memory operations and have to use SImode memory
1976    operations plus masking logic.  */
1977
1978 rtx
1979 widen_memory_access (memref, mode, offset)
1980      rtx memref;
1981      enum machine_mode mode;
1982      HOST_WIDE_INT offset;
1983 {
1984   rtx new = adjust_address_1 (memref, mode, offset, 1, 1);
1985   tree expr = MEM_EXPR (new);
1986   rtx memoffset = MEM_OFFSET (new);
1987   unsigned int size = GET_MODE_SIZE (mode);
1988
1989   /* If we don't know what offset we were at within the expression, then
1990      we can't know if we've overstepped the bounds.  */
1991   if (! memoffset)
1992     expr = NULL_TREE;
1993
1994   while (expr)
1995     {
1996       if (TREE_CODE (expr) == COMPONENT_REF)
1997         {
1998           tree field = TREE_OPERAND (expr, 1);
1999
2000           if (! DECL_SIZE_UNIT (field))
2001             {
2002               expr = NULL_TREE;
2003               break;
2004             }
2005
2006           /* Is the field at least as large as the access?  If so, ok,
2007              otherwise strip back to the containing structure.  */
2008           if (TREE_CODE (DECL_SIZE_UNIT (field)) == INTEGER_CST
2009               && compare_tree_int (DECL_SIZE_UNIT (field), size) >= 0
2010               && INTVAL (memoffset) >= 0)
2011             break;
2012
2013           if (! host_integerp (DECL_FIELD_OFFSET (field), 1))
2014             {
2015               expr = NULL_TREE;
2016               break;
2017             }
2018
2019           expr = TREE_OPERAND (expr, 0);
2020           memoffset = (GEN_INT (INTVAL (memoffset)
2021                        + tree_low_cst (DECL_FIELD_OFFSET (field), 1)
2022                        + (tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
2023                           / BITS_PER_UNIT)));
2024         }
2025       /* Similarly for the decl.  */
2026       else if (DECL_P (expr)
2027                && DECL_SIZE_UNIT (expr)
2028                && compare_tree_int (DECL_SIZE_UNIT (expr), size) >= 0
2029                && (! memoffset || INTVAL (memoffset) >= 0))
2030         break;
2031       else
2032         {
2033           /* The widened memory access overflows the expression, which means
2034              that it could alias another expression.  Zap it.  */
2035           expr = NULL_TREE;
2036           break;
2037         }
2038     }
2039
2040   if (! expr)
2041     memoffset = NULL_RTX;
2042
2043   /* The widened memory may alias other stuff, so zap the alias set.  */
2044   /* ??? Maybe use get_alias_set on any remaining expression.  */
2045
2046   MEM_ATTRS (new) = get_mem_attrs (0, expr, memoffset, GEN_INT (size),
2047                                    MEM_ALIGN (new), mode);
2048
2049   return new;
2050 }
2051 \f
2052 /* Return a newly created CODE_LABEL rtx with a unique label number.  */
2053
2054 rtx
2055 gen_label_rtx ()
2056 {
2057   rtx label;
2058
2059   label = gen_rtx_CODE_LABEL (VOIDmode, 0, NULL_RTX,
2060                               NULL_RTX, label_num++, NULL, NULL);
2061
2062   LABEL_NUSES (label) = 0;
2063   LABEL_ALTERNATE_NAME (label) = NULL;
2064   return label;
2065 }
2066 \f
2067 /* For procedure integration.  */
2068
2069 /* Install new pointers to the first and last insns in the chain.
2070    Also, set cur_insn_uid to one higher than the last in use.
2071    Used for an inline-procedure after copying the insn chain.  */
2072
2073 void
2074 set_new_first_and_last_insn (first, last)
2075      rtx first, last;
2076 {
2077   rtx insn;
2078
2079   first_insn = first;
2080   last_insn = last;
2081   cur_insn_uid = 0;
2082
2083   for (insn = first; insn; insn = NEXT_INSN (insn))
2084     cur_insn_uid = MAX (cur_insn_uid, INSN_UID (insn));
2085
2086   cur_insn_uid++;
2087 }
2088
2089 /* Set the range of label numbers found in the current function.
2090    This is used when belatedly compiling an inline function.  */
2091
2092 void
2093 set_new_first_and_last_label_num (first, last)
2094      int first, last;
2095 {
2096   base_label_num = label_num;
2097   first_label_num = first;
2098   last_label_num = last;
2099 }
2100
2101 /* Set the last label number found in the current function.
2102    This is used when belatedly compiling an inline function.  */
2103
2104 void
2105 set_new_last_label_num (last)
2106      int last;
2107 {
2108   base_label_num = label_num;
2109   last_label_num = last;
2110 }
2111 \f
2112 /* Restore all variables describing the current status from the structure *P.
2113    This is used after a nested function.  */
2114
2115 void
2116 restore_emit_status (p)
2117      struct function *p ATTRIBUTE_UNUSED;
2118 {
2119   last_label_num = 0;
2120   clear_emit_caches ();
2121 }
2122
2123 /* Clear out all parts of the state in F that can safely be discarded
2124    after the function has been compiled, to let garbage collection
2125    reclaim the memory.  */
2126
2127 void
2128 free_emit_status (f)
2129      struct function *f;
2130 {
2131   free (f->emit->x_regno_reg_rtx);
2132   free (f->emit->regno_pointer_align);
2133   free (f->emit->regno_decl);
2134   free (f->emit);
2135   f->emit = NULL;
2136 }
2137 \f
2138 /* Go through all the RTL insn bodies and copy any invalid shared
2139    structure.  This routine should only be called once.  */
2140
2141 void
2142 unshare_all_rtl (fndecl, insn)
2143      tree fndecl;
2144      rtx insn;
2145 {
2146   tree decl;
2147
2148   /* Make sure that virtual parameters are not shared.  */
2149   for (decl = DECL_ARGUMENTS (fndecl); decl; decl = TREE_CHAIN (decl))
2150     SET_DECL_RTL (decl, copy_rtx_if_shared (DECL_RTL (decl)));
2151
2152   /* Make sure that virtual stack slots are not shared.  */
2153   unshare_all_decls (DECL_INITIAL (fndecl));
2154
2155   /* Unshare just about everything else.  */
2156   unshare_all_rtl_1 (insn);
2157
2158   /* Make sure the addresses of stack slots found outside the insn chain
2159      (such as, in DECL_RTL of a variable) are not shared
2160      with the insn chain.
2161
2162      This special care is necessary when the stack slot MEM does not
2163      actually appear in the insn chain.  If it does appear, its address
2164      is unshared from all else at that point.  */
2165   stack_slot_list = copy_rtx_if_shared (stack_slot_list);
2166 }
2167
2168 /* Go through all the RTL insn bodies and copy any invalid shared
2169    structure, again.  This is a fairly expensive thing to do so it
2170    should be done sparingly.  */
2171
2172 void
2173 unshare_all_rtl_again (insn)
2174      rtx insn;
2175 {
2176   rtx p;
2177   tree decl;
2178
2179   for (p = insn; p; p = NEXT_INSN (p))
2180     if (INSN_P (p))
2181       {
2182         reset_used_flags (PATTERN (p));
2183         reset_used_flags (REG_NOTES (p));
2184         reset_used_flags (LOG_LINKS (p));
2185       }
2186
2187   /* Make sure that virtual stack slots are not shared.  */
2188   reset_used_decls (DECL_INITIAL (cfun->decl));
2189
2190   /* Make sure that virtual parameters are not shared.  */
2191   for (decl = DECL_ARGUMENTS (cfun->decl); decl; decl = TREE_CHAIN (decl))
2192     reset_used_flags (DECL_RTL (decl));
2193
2194   reset_used_flags (stack_slot_list);
2195
2196   unshare_all_rtl (cfun->decl, insn);
2197 }
2198
2199 /* Go through all the RTL insn bodies and copy any invalid shared structure.
2200    Assumes the mark bits are cleared at entry.  */
2201
2202 static void
2203 unshare_all_rtl_1 (insn)
2204      rtx insn;
2205 {
2206   for (; insn; insn = NEXT_INSN (insn))
2207     if (INSN_P (insn))
2208       {
2209         PATTERN (insn) = copy_rtx_if_shared (PATTERN (insn));
2210         REG_NOTES (insn) = copy_rtx_if_shared (REG_NOTES (insn));
2211         LOG_LINKS (insn) = copy_rtx_if_shared (LOG_LINKS (insn));
2212       }
2213 }
2214
2215 /* Go through all virtual stack slots of a function and copy any
2216    shared structure.  */
2217 static void
2218 unshare_all_decls (blk)
2219      tree blk;
2220 {
2221   tree t;
2222
2223   /* Copy shared decls.  */
2224   for (t = BLOCK_VARS (blk); t; t = TREE_CHAIN (t))
2225     if (DECL_RTL_SET_P (t))
2226       SET_DECL_RTL (t, copy_rtx_if_shared (DECL_RTL (t)));
2227
2228   /* Now process sub-blocks.  */
2229   for (t = BLOCK_SUBBLOCKS (blk); t; t = TREE_CHAIN (t))
2230     unshare_all_decls (t);
2231 }
2232
2233 /* Go through all virtual stack slots of a function and mark them as
2234    not shared.  */
2235 static void
2236 reset_used_decls (blk)
2237      tree blk;
2238 {
2239   tree t;
2240
2241   /* Mark decls.  */
2242   for (t = BLOCK_VARS (blk); t; t = TREE_CHAIN (t))
2243     if (DECL_RTL_SET_P (t))
2244       reset_used_flags (DECL_RTL (t));
2245
2246   /* Now process sub-blocks.  */
2247   for (t = BLOCK_SUBBLOCKS (blk); t; t = TREE_CHAIN (t))
2248     reset_used_decls (t);
2249 }
2250
2251 /* Similar to `copy_rtx' except that if MAY_SHARE is present, it is
2252    placed in the result directly, rather than being copied.  MAY_SHARE is
2253    either a MEM of an EXPR_LIST of MEMs.  */
2254
2255 rtx
2256 copy_most_rtx (orig, may_share)
2257      rtx orig;
2258      rtx may_share;
2259 {
2260   rtx copy;
2261   int i, j;
2262   RTX_CODE code;
2263   const char *format_ptr;
2264
2265   if (orig == may_share
2266       || (GET_CODE (may_share) == EXPR_LIST
2267           && in_expr_list_p (may_share, orig)))
2268     return orig;
2269
2270   code = GET_CODE (orig);
2271
2272   switch (code)
2273     {
2274     case REG:
2275     case QUEUED:
2276     case CONST_INT:
2277     case CONST_DOUBLE:
2278     case CONST_VECTOR:
2279     case SYMBOL_REF:
2280     case CODE_LABEL:
2281     case PC:
2282     case CC0:
2283       return orig;
2284     default:
2285       break;
2286     }
2287
2288   copy = rtx_alloc (code);
2289   PUT_MODE (copy, GET_MODE (orig));
2290   RTX_FLAG (copy, in_struct) = RTX_FLAG (orig, in_struct);
2291   RTX_FLAG (copy, volatil) = RTX_FLAG (orig, volatil);
2292   RTX_FLAG (copy, unchanging) = RTX_FLAG (orig, unchanging);
2293   RTX_FLAG (copy, integrated) = RTX_FLAG (orig, integrated);
2294   RTX_FLAG (copy, frame_related) = RTX_FLAG (orig, frame_related);
2295
2296   format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
2297
2298   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
2299     {
2300       switch (*format_ptr++)
2301         {
2302         case 'e':
2303           XEXP (copy, i) = XEXP (orig, i);
2304           if (XEXP (orig, i) != NULL && XEXP (orig, i) != may_share)
2305             XEXP (copy, i) = copy_most_rtx (XEXP (orig, i), may_share);
2306           break;
2307
2308         case 'u':
2309           XEXP (copy, i) = XEXP (orig, i);
2310           break;
2311
2312         case 'E':
2313         case 'V':
2314           XVEC (copy, i) = XVEC (orig, i);
2315           if (XVEC (orig, i) != NULL)
2316             {
2317               XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
2318               for (j = 0; j < XVECLEN (copy, i); j++)
2319                 XVECEXP (copy, i, j)
2320                   = copy_most_rtx (XVECEXP (orig, i, j), may_share);
2321             }
2322           break;
2323
2324         case 'w':
2325           XWINT (copy, i) = XWINT (orig, i);
2326           break;
2327
2328         case 'n':
2329         case 'i':
2330           XINT (copy, i) = XINT (orig, i);
2331           break;
2332
2333         case 't':
2334           XTREE (copy, i) = XTREE (orig, i);
2335           break;
2336
2337         case 's':
2338         case 'S':
2339           XSTR (copy, i) = XSTR (orig, i);
2340           break;
2341
2342         case '0':
2343           /* Copy this through the wide int field; that's safest.  */
2344           X0WINT (copy, i) = X0WINT (orig, i);
2345           break;
2346
2347         default:
2348           abort ();
2349         }
2350     }
2351   return copy;
2352 }
2353
2354 /* Mark ORIG as in use, and return a copy of it if it was already in use.
2355    Recursively does the same for subexpressions.  */
2356
2357 rtx
2358 copy_rtx_if_shared (orig)
2359      rtx orig;
2360 {
2361   rtx x = orig;
2362   int i;
2363   enum rtx_code code;
2364   const char *format_ptr;
2365   int copied = 0;
2366
2367   if (x == 0)
2368     return 0;
2369
2370   code = GET_CODE (x);
2371
2372   /* These types may be freely shared.  */
2373
2374   switch (code)
2375     {
2376     case REG:
2377     case QUEUED:
2378     case CONST_INT:
2379     case CONST_DOUBLE:
2380     case CONST_VECTOR:
2381     case SYMBOL_REF:
2382     case CODE_LABEL:
2383     case PC:
2384     case CC0:
2385     case SCRATCH:
2386       /* SCRATCH must be shared because they represent distinct values.  */
2387       return x;
2388
2389     case CONST:
2390       /* CONST can be shared if it contains a SYMBOL_REF.  If it contains
2391          a LABEL_REF, it isn't sharable.  */
2392       if (GET_CODE (XEXP (x, 0)) == PLUS
2393           && GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF
2394           && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT)
2395         return x;
2396       break;
2397
2398     case INSN:
2399     case JUMP_INSN:
2400     case CALL_INSN:
2401     case NOTE:
2402     case BARRIER:
2403       /* The chain of insns is not being copied.  */
2404       return x;
2405
2406     case MEM:
2407       /* A MEM is allowed to be shared if its address is constant.
2408
2409          We used to allow sharing of MEMs which referenced
2410          virtual_stack_vars_rtx or virtual_incoming_args_rtx, but
2411          that can lose.  instantiate_virtual_regs will not unshare
2412          the MEMs, and combine may change the structure of the address
2413          because it looks safe and profitable in one context, but
2414          in some other context it creates unrecognizable RTL.  */
2415       if (CONSTANT_ADDRESS_P (XEXP (x, 0)))
2416         return x;
2417
2418       break;
2419
2420     default:
2421       break;
2422     }
2423
2424   /* This rtx may not be shared.  If it has already been seen,
2425      replace it with a copy of itself.  */
2426
2427   if (RTX_FLAG (x, used))
2428     {
2429       rtx copy;
2430
2431       copy = rtx_alloc (code);
2432       memcpy (copy, x,
2433              (sizeof (*copy) - sizeof (copy->fld)
2434               + sizeof (copy->fld[0]) * GET_RTX_LENGTH (code)));
2435       x = copy;
2436       copied = 1;
2437     }
2438   RTX_FLAG (x, used) = 1;
2439
2440   /* Now scan the subexpressions recursively.
2441      We can store any replaced subexpressions directly into X
2442      since we know X is not shared!  Any vectors in X
2443      must be copied if X was copied.  */
2444
2445   format_ptr = GET_RTX_FORMAT (code);
2446
2447   for (i = 0; i < GET_RTX_LENGTH (code); i++)
2448     {
2449       switch (*format_ptr++)
2450         {
2451         case 'e':
2452           XEXP (x, i) = copy_rtx_if_shared (XEXP (x, i));
2453           break;
2454
2455         case 'E':
2456           if (XVEC (x, i) != NULL)
2457             {
2458               int j;
2459               int len = XVECLEN (x, i);
2460
2461               if (copied && len > 0)
2462                 XVEC (x, i) = gen_rtvec_v (len, XVEC (x, i)->elem);
2463               for (j = 0; j < len; j++)
2464                 XVECEXP (x, i, j) = copy_rtx_if_shared (XVECEXP (x, i, j));
2465             }
2466           break;
2467         }
2468     }
2469   return x;
2470 }
2471
2472 /* Clear all the USED bits in X to allow copy_rtx_if_shared to be used
2473    to look for shared sub-parts.  */
2474
2475 void
2476 reset_used_flags (x)
2477      rtx x;
2478 {
2479   int i, j;
2480   enum rtx_code code;
2481   const char *format_ptr;
2482
2483   if (x == 0)
2484     return;
2485
2486   code = GET_CODE (x);
2487
2488   /* These types may be freely shared so we needn't do any resetting
2489      for them.  */
2490
2491   switch (code)
2492     {
2493     case REG:
2494     case QUEUED:
2495     case CONST_INT:
2496     case CONST_DOUBLE:
2497     case CONST_VECTOR:
2498     case SYMBOL_REF:
2499     case CODE_LABEL:
2500     case PC:
2501     case CC0:
2502       return;
2503
2504     case INSN:
2505     case JUMP_INSN:
2506     case CALL_INSN:
2507     case NOTE:
2508     case LABEL_REF:
2509     case BARRIER:
2510       /* The chain of insns is not being copied.  */
2511       return;
2512
2513     default:
2514       break;
2515     }
2516
2517   RTX_FLAG (x, used) = 0;
2518
2519   format_ptr = GET_RTX_FORMAT (code);
2520   for (i = 0; i < GET_RTX_LENGTH (code); i++)
2521     {
2522       switch (*format_ptr++)
2523         {
2524         case 'e':
2525           reset_used_flags (XEXP (x, i));
2526           break;
2527
2528         case 'E':
2529           for (j = 0; j < XVECLEN (x, i); j++)
2530             reset_used_flags (XVECEXP (x, i, j));
2531           break;
2532         }
2533     }
2534 }
2535 \f
2536 /* Copy X if necessary so that it won't be altered by changes in OTHER.
2537    Return X or the rtx for the pseudo reg the value of X was copied into.
2538    OTHER must be valid as a SET_DEST.  */
2539
2540 rtx
2541 make_safe_from (x, other)
2542      rtx x, other;
2543 {
2544   while (1)
2545     switch (GET_CODE (other))
2546       {
2547       case SUBREG:
2548         other = SUBREG_REG (other);
2549         break;
2550       case STRICT_LOW_PART:
2551       case SIGN_EXTEND:
2552       case ZERO_EXTEND:
2553         other = XEXP (other, 0);
2554         break;
2555       default:
2556         goto done;
2557       }
2558  done:
2559   if ((GET_CODE (other) == MEM
2560        && ! CONSTANT_P (x)
2561        && GET_CODE (x) != REG
2562        && GET_CODE (x) != SUBREG)
2563       || (GET_CODE (other) == REG
2564           && (REGNO (other) < FIRST_PSEUDO_REGISTER
2565               || reg_mentioned_p (other, x))))
2566     {
2567       rtx temp = gen_reg_rtx (GET_MODE (x));
2568       emit_move_insn (temp, x);
2569       return temp;
2570     }
2571   return x;
2572 }
2573 \f
2574 /* Emission of insns (adding them to the doubly-linked list).  */
2575
2576 /* Return the first insn of the current sequence or current function.  */
2577
2578 rtx
2579 get_insns ()
2580 {
2581   return first_insn;
2582 }
2583
2584 /* Specify a new insn as the first in the chain.  */
2585
2586 void
2587 set_first_insn (insn)
2588      rtx insn;
2589 {
2590   if (PREV_INSN (insn) != 0)
2591     abort ();
2592   first_insn = insn;
2593 }
2594
2595 /* Return the last insn emitted in current sequence or current function.  */
2596
2597 rtx
2598 get_last_insn ()
2599 {
2600   return last_insn;
2601 }
2602
2603 /* Specify a new insn as the last in the chain.  */
2604
2605 void
2606 set_last_insn (insn)
2607      rtx insn;
2608 {
2609   if (NEXT_INSN (insn) != 0)
2610     abort ();
2611   last_insn = insn;
2612 }
2613
2614 /* Return the last insn emitted, even if it is in a sequence now pushed.  */
2615
2616 rtx
2617 get_last_insn_anywhere ()
2618 {
2619   struct sequence_stack *stack;
2620   if (last_insn)
2621     return last_insn;
2622   for (stack = seq_stack; stack; stack = stack->next)
2623     if (stack->last != 0)
2624       return stack->last;
2625   return 0;
2626 }
2627
2628 /* Return a number larger than any instruction's uid in this function.  */
2629
2630 int
2631 get_max_uid ()
2632 {
2633   return cur_insn_uid;
2634 }
2635
2636 /* Renumber instructions so that no instruction UIDs are wasted.  */
2637
2638 void
2639 renumber_insns (stream)
2640      FILE *stream;
2641 {
2642   rtx insn;
2643
2644   /* If we're not supposed to renumber instructions, don't.  */
2645   if (!flag_renumber_insns)
2646     return;
2647
2648   /* If there aren't that many instructions, then it's not really
2649      worth renumbering them.  */
2650   if (flag_renumber_insns == 1 && get_max_uid () < 25000)
2651     return;
2652
2653   cur_insn_uid = 1;
2654
2655   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
2656     {
2657       if (stream)
2658         fprintf (stream, "Renumbering insn %d to %d\n",
2659                  INSN_UID (insn), cur_insn_uid);
2660       INSN_UID (insn) = cur_insn_uid++;
2661     }
2662 }
2663 \f
2664 /* Return the next insn.  If it is a SEQUENCE, return the first insn
2665    of the sequence.  */
2666
2667 rtx
2668 next_insn (insn)
2669      rtx insn;
2670 {
2671   if (insn)
2672     {
2673       insn = NEXT_INSN (insn);
2674       if (insn && GET_CODE (insn) == INSN
2675           && GET_CODE (PATTERN (insn)) == SEQUENCE)
2676         insn = XVECEXP (PATTERN (insn), 0, 0);
2677     }
2678
2679   return insn;
2680 }
2681
2682 /* Return the previous insn.  If it is a SEQUENCE, return the last insn
2683    of the sequence.  */
2684
2685 rtx
2686 previous_insn (insn)
2687      rtx insn;
2688 {
2689   if (insn)
2690     {
2691       insn = PREV_INSN (insn);
2692       if (insn && GET_CODE (insn) == INSN
2693           && GET_CODE (PATTERN (insn)) == SEQUENCE)
2694         insn = XVECEXP (PATTERN (insn), 0, XVECLEN (PATTERN (insn), 0) - 1);
2695     }
2696
2697   return insn;
2698 }
2699
2700 /* Return the next insn after INSN that is not a NOTE.  This routine does not
2701    look inside SEQUENCEs.  */
2702
2703 rtx
2704 next_nonnote_insn (insn)
2705      rtx insn;
2706 {
2707   while (insn)
2708     {
2709       insn = NEXT_INSN (insn);
2710       if (insn == 0 || GET_CODE (insn) != NOTE)
2711         break;
2712     }
2713
2714   return insn;
2715 }
2716
2717 /* Return the previous insn before INSN that is not a NOTE.  This routine does
2718    not look inside SEQUENCEs.  */
2719
2720 rtx
2721 prev_nonnote_insn (insn)
2722      rtx insn;
2723 {
2724   while (insn)
2725     {
2726       insn = PREV_INSN (insn);
2727       if (insn == 0 || GET_CODE (insn) != NOTE)
2728         break;
2729     }
2730
2731   return insn;
2732 }
2733
2734 /* Return the next INSN, CALL_INSN or JUMP_INSN after INSN;
2735    or 0, if there is none.  This routine does not look inside
2736    SEQUENCEs.  */
2737
2738 rtx
2739 next_real_insn (insn)
2740      rtx insn;
2741 {
2742   while (insn)
2743     {
2744       insn = NEXT_INSN (insn);
2745       if (insn == 0 || GET_CODE (insn) == INSN
2746           || GET_CODE (insn) == CALL_INSN || GET_CODE (insn) == JUMP_INSN)
2747         break;
2748     }
2749
2750   return insn;
2751 }
2752
2753 /* Return the last INSN, CALL_INSN or JUMP_INSN before INSN;
2754    or 0, if there is none.  This routine does not look inside
2755    SEQUENCEs.  */
2756
2757 rtx
2758 prev_real_insn (insn)
2759      rtx insn;
2760 {
2761   while (insn)
2762     {
2763       insn = PREV_INSN (insn);
2764       if (insn == 0 || GET_CODE (insn) == INSN || GET_CODE (insn) == CALL_INSN
2765           || GET_CODE (insn) == JUMP_INSN)
2766         break;
2767     }
2768
2769   return insn;
2770 }
2771
2772 /* Find the next insn after INSN that really does something.  This routine
2773    does not look inside SEQUENCEs.  Until reload has completed, this is the
2774    same as next_real_insn.  */
2775
2776 int
2777 active_insn_p (insn)
2778      rtx insn;
2779 {
2780   return (GET_CODE (insn) == CALL_INSN || GET_CODE (insn) == JUMP_INSN
2781           || (GET_CODE (insn) == INSN
2782               && (! reload_completed
2783                   || (GET_CODE (PATTERN (insn)) != USE
2784                       && GET_CODE (PATTERN (insn)) != CLOBBER))));
2785 }
2786
2787 rtx
2788 next_active_insn (insn)
2789      rtx insn;
2790 {
2791   while (insn)
2792     {
2793       insn = NEXT_INSN (insn);
2794       if (insn == 0 || active_insn_p (insn))
2795         break;
2796     }
2797
2798   return insn;
2799 }
2800
2801 /* Find the last insn before INSN that really does something.  This routine
2802    does not look inside SEQUENCEs.  Until reload has completed, this is the
2803    same as prev_real_insn.  */
2804
2805 rtx
2806 prev_active_insn (insn)
2807      rtx insn;
2808 {
2809   while (insn)
2810     {
2811       insn = PREV_INSN (insn);
2812       if (insn == 0 || active_insn_p (insn))
2813         break;
2814     }
2815
2816   return insn;
2817 }
2818
2819 /* Return the next CODE_LABEL after the insn INSN, or 0 if there is none.  */
2820
2821 rtx
2822 next_label (insn)
2823      rtx insn;
2824 {
2825   while (insn)
2826     {
2827       insn = NEXT_INSN (insn);
2828       if (insn == 0 || GET_CODE (insn) == CODE_LABEL)
2829         break;
2830     }
2831
2832   return insn;
2833 }
2834
2835 /* Return the last CODE_LABEL before the insn INSN, or 0 if there is none.  */
2836
2837 rtx
2838 prev_label (insn)
2839      rtx insn;
2840 {
2841   while (insn)
2842     {
2843       insn = PREV_INSN (insn);
2844       if (insn == 0 || GET_CODE (insn) == CODE_LABEL)
2845         break;
2846     }
2847
2848   return insn;
2849 }
2850 \f
2851 #ifdef HAVE_cc0
2852 /* INSN uses CC0 and is being moved into a delay slot.  Set up REG_CC_SETTER
2853    and REG_CC_USER notes so we can find it.  */
2854
2855 void
2856 link_cc0_insns (insn)
2857      rtx insn;
2858 {
2859   rtx user = next_nonnote_insn (insn);
2860
2861   if (GET_CODE (user) == INSN && GET_CODE (PATTERN (user)) == SEQUENCE)
2862     user = XVECEXP (PATTERN (user), 0, 0);
2863
2864   REG_NOTES (user) = gen_rtx_INSN_LIST (REG_CC_SETTER, insn,
2865                                         REG_NOTES (user));
2866   REG_NOTES (insn) = gen_rtx_INSN_LIST (REG_CC_USER, user, REG_NOTES (insn));
2867 }
2868
2869 /* Return the next insn that uses CC0 after INSN, which is assumed to
2870    set it.  This is the inverse of prev_cc0_setter (i.e., prev_cc0_setter
2871    applied to the result of this function should yield INSN).
2872
2873    Normally, this is simply the next insn.  However, if a REG_CC_USER note
2874    is present, it contains the insn that uses CC0.
2875
2876    Return 0 if we can't find the insn.  */
2877
2878 rtx
2879 next_cc0_user (insn)
2880      rtx insn;
2881 {
2882   rtx note = find_reg_note (insn, REG_CC_USER, NULL_RTX);
2883
2884   if (note)
2885     return XEXP (note, 0);
2886
2887   insn = next_nonnote_insn (insn);
2888   if (insn && GET_CODE (insn) == INSN && GET_CODE (PATTERN (insn)) == SEQUENCE)
2889     insn = XVECEXP (PATTERN (insn), 0, 0);
2890
2891   if (insn && INSN_P (insn) && reg_mentioned_p (cc0_rtx, PATTERN (insn)))
2892     return insn;
2893
2894   return 0;
2895 }
2896
2897 /* Find the insn that set CC0 for INSN.  Unless INSN has a REG_CC_SETTER
2898    note, it is the previous insn.  */
2899
2900 rtx
2901 prev_cc0_setter (insn)
2902      rtx insn;
2903 {
2904   rtx note = find_reg_note (insn, REG_CC_SETTER, NULL_RTX);
2905
2906   if (note)
2907     return XEXP (note, 0);
2908
2909   insn = prev_nonnote_insn (insn);
2910   if (! sets_cc0_p (PATTERN (insn)))
2911     abort ();
2912
2913   return insn;
2914 }
2915 #endif
2916
2917 /* Increment the label uses for all labels present in rtx.  */
2918
2919 static void
2920 mark_label_nuses (x)
2921      rtx x;
2922 {
2923   enum rtx_code code;
2924   int i, j;
2925   const char *fmt;
2926
2927   code = GET_CODE (x);
2928   if (code == LABEL_REF)
2929     LABEL_NUSES (XEXP (x, 0))++;
2930
2931   fmt = GET_RTX_FORMAT (code);
2932   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2933     {
2934       if (fmt[i] == 'e')
2935         mark_label_nuses (XEXP (x, i));
2936       else if (fmt[i] == 'E')
2937         for (j = XVECLEN (x, i) - 1; j >= 0; j--)
2938           mark_label_nuses (XVECEXP (x, i, j));
2939     }
2940 }
2941
2942 \f
2943 /* Try splitting insns that can be split for better scheduling.
2944    PAT is the pattern which might split.
2945    TRIAL is the insn providing PAT.
2946    LAST is non-zero if we should return the last insn of the sequence produced.
2947
2948    If this routine succeeds in splitting, it returns the first or last
2949    replacement insn depending on the value of LAST.  Otherwise, it
2950    returns TRIAL.  If the insn to be returned can be split, it will be.  */
2951
2952 rtx
2953 try_split (pat, trial, last)
2954      rtx pat, trial;
2955      int last;
2956 {
2957   rtx before = PREV_INSN (trial);
2958   rtx after = NEXT_INSN (trial);
2959   int has_barrier = 0;
2960   rtx tem;
2961   rtx note, seq;
2962   int probability;
2963
2964   if (any_condjump_p (trial)
2965       && (note = find_reg_note (trial, REG_BR_PROB, 0)))
2966     split_branch_probability = INTVAL (XEXP (note, 0));
2967   probability = split_branch_probability;
2968
2969   seq = split_insns (pat, trial);
2970
2971   split_branch_probability = -1;
2972
2973   /* If we are splitting a JUMP_INSN, it might be followed by a BARRIER.
2974      We may need to handle this specially.  */
2975   if (after && GET_CODE (after) == BARRIER)
2976     {
2977       has_barrier = 1;
2978       after = NEXT_INSN (after);
2979     }
2980
2981   if (seq)
2982     {
2983       /* SEQ can either be a SEQUENCE or the pattern of a single insn.
2984          The latter case will normally arise only when being done so that
2985          it, in turn, will be split (SFmode on the 29k is an example).  */
2986       if (GET_CODE (seq) == SEQUENCE)
2987         {
2988           int i, njumps = 0;
2989
2990           /* Avoid infinite loop if any insn of the result matches
2991              the original pattern.  */
2992           for (i = 0; i < XVECLEN (seq, 0); i++)
2993             if (GET_CODE (XVECEXP (seq, 0, i)) == INSN
2994                 && rtx_equal_p (PATTERN (XVECEXP (seq, 0, i)), pat))
2995               return trial;
2996
2997           /* Mark labels.  */
2998           for (i = XVECLEN (seq, 0) - 1; i >= 0; i--)
2999             if (GET_CODE (XVECEXP (seq, 0, i)) == JUMP_INSN)
3000               {
3001                 rtx insn = XVECEXP (seq, 0, i);
3002                 mark_jump_label (PATTERN (insn),
3003                                  XVECEXP (seq, 0, i), 0);
3004                 njumps++;
3005                 if (probability != -1
3006                     && any_condjump_p (insn)
3007                     && !find_reg_note (insn, REG_BR_PROB, 0))
3008                   {
3009                     /* We can preserve the REG_BR_PROB notes only if exactly
3010                        one jump is created, otherwise the machine description
3011                        is responsible for this step using
3012                        split_branch_probability variable.  */
3013                     if (njumps != 1)
3014                       abort ();
3015                     REG_NOTES (insn)
3016                       = gen_rtx_EXPR_LIST (REG_BR_PROB,
3017                                            GEN_INT (probability),
3018                                            REG_NOTES (insn));
3019                   }
3020               }
3021
3022           /* If we are splitting a CALL_INSN, look for the CALL_INSN
3023              in SEQ and copy our CALL_INSN_FUNCTION_USAGE to it.  */
3024           if (GET_CODE (trial) == CALL_INSN)
3025             for (i = XVECLEN (seq, 0) - 1; i >= 0; i--)
3026               if (GET_CODE (XVECEXP (seq, 0, i)) == CALL_INSN)
3027                 CALL_INSN_FUNCTION_USAGE (XVECEXP (seq, 0, i))
3028                   = CALL_INSN_FUNCTION_USAGE (trial);
3029
3030           /* Copy notes, particularly those related to the CFG.  */
3031           for (note = REG_NOTES (trial); note; note = XEXP (note, 1))
3032             {
3033               switch (REG_NOTE_KIND (note))
3034                 {
3035                 case REG_EH_REGION:
3036                   for (i = XVECLEN (seq, 0) - 1; i >= 0; i--)
3037                     {
3038                       rtx insn = XVECEXP (seq, 0, i);
3039                       if (GET_CODE (insn) == CALL_INSN
3040                           || (flag_non_call_exceptions
3041                               && may_trap_p (PATTERN (insn))))
3042                         REG_NOTES (insn)
3043                           = gen_rtx_EXPR_LIST (REG_EH_REGION,
3044                                                XEXP (note, 0),
3045                                                REG_NOTES (insn));
3046                     }
3047                   break;
3048
3049                 case REG_NORETURN:
3050                 case REG_SETJMP:
3051                 case REG_ALWAYS_RETURN:
3052                   for (i = XVECLEN (seq, 0) - 1; i >= 0; i--)
3053                     {
3054                       rtx insn = XVECEXP (seq, 0, i);
3055                       if (GET_CODE (insn) == CALL_INSN)
3056                         REG_NOTES (insn)
3057                           = gen_rtx_EXPR_LIST (REG_NOTE_KIND (note),
3058                                                XEXP (note, 0),
3059                                                REG_NOTES (insn));
3060                     }
3061                   break;
3062
3063                 case REG_NON_LOCAL_GOTO:
3064                   for (i = XVECLEN (seq, 0) - 1; i >= 0; i--)
3065                     {
3066                       rtx insn = XVECEXP (seq, 0, i);
3067                       if (GET_CODE (insn) == JUMP_INSN)
3068                         REG_NOTES (insn)
3069                           = gen_rtx_EXPR_LIST (REG_NOTE_KIND (note),
3070                                                XEXP (note, 0),
3071                                                REG_NOTES (insn));
3072                     }
3073                   break;
3074
3075                 default:
3076                   break;
3077                 }
3078             }
3079
3080           /* If there are LABELS inside the split insns increment the
3081              usage count so we don't delete the label.  */
3082           if (GET_CODE (trial) == INSN)
3083             for (i = XVECLEN (seq, 0) - 1; i >= 0; i--)
3084               if (GET_CODE (XVECEXP (seq, 0, i)) == INSN)
3085                 mark_label_nuses (PATTERN (XVECEXP (seq, 0, i)));
3086
3087           tem = emit_insn_after (seq, trial);
3088
3089           delete_insn (trial);
3090           if (has_barrier)
3091             emit_barrier_after (tem);
3092
3093           /* Recursively call try_split for each new insn created; by the
3094              time control returns here that insn will be fully split, so
3095              set LAST and continue from the insn after the one returned.
3096              We can't use next_active_insn here since AFTER may be a note.
3097              Ignore deleted insns, which can be occur if not optimizing.  */
3098           for (tem = NEXT_INSN (before); tem != after; tem = NEXT_INSN (tem))
3099             if (! INSN_DELETED_P (tem) && INSN_P (tem))
3100               tem = try_split (PATTERN (tem), tem, 1);
3101         }
3102       /* Avoid infinite loop if the result matches the original pattern.  */
3103       else if (rtx_equal_p (seq, pat))
3104         return trial;
3105       else
3106         {
3107           PATTERN (trial) = seq;
3108           INSN_CODE (trial) = -1;
3109           try_split (seq, trial, last);
3110         }
3111
3112       /* Return either the first or the last insn, depending on which was
3113          requested.  */
3114       return last
3115                 ? (after ? PREV_INSN (after) : last_insn)
3116                 : NEXT_INSN (before);
3117     }
3118
3119   return trial;
3120 }
3121 \f
3122 /* Make and return an INSN rtx, initializing all its slots.
3123    Store PATTERN in the pattern slots.  */
3124
3125 rtx
3126 make_insn_raw (pattern)
3127      rtx pattern;
3128 {
3129   rtx insn;
3130
3131   insn = rtx_alloc (INSN);
3132
3133   INSN_UID (insn) = cur_insn_uid++;
3134   PATTERN (insn) = pattern;
3135   INSN_CODE (insn) = -1;
3136   LOG_LINKS (insn) = NULL;
3137   REG_NOTES (insn) = NULL;
3138
3139 #ifdef ENABLE_RTL_CHECKING
3140   if (insn
3141       && INSN_P (insn)
3142       && (returnjump_p (insn)
3143           || (GET_CODE (insn) == SET
3144               && SET_DEST (insn) == pc_rtx)))
3145     {
3146       warning ("ICE: emit_insn used where emit_jump_insn needed:\n");
3147       debug_rtx (insn);
3148     }
3149 #endif
3150
3151   return insn;
3152 }
3153
3154 /* Like `make_insn' but make a JUMP_INSN instead of an insn.  */
3155
3156 static rtx
3157 make_jump_insn_raw (pattern)
3158      rtx pattern;
3159 {
3160   rtx insn;
3161
3162   insn = rtx_alloc (JUMP_INSN);
3163   INSN_UID (insn) = cur_insn_uid++;
3164
3165   PATTERN (insn) = pattern;
3166   INSN_CODE (insn) = -1;
3167   LOG_LINKS (insn) = NULL;
3168   REG_NOTES (insn) = NULL;
3169   JUMP_LABEL (insn) = NULL;
3170
3171   return insn;
3172 }
3173
3174 /* Like `make_insn' but make a CALL_INSN instead of an insn.  */
3175
3176 static rtx
3177 make_call_insn_raw (pattern)
3178      rtx pattern;
3179 {
3180   rtx insn;
3181
3182   insn = rtx_alloc (CALL_INSN);
3183   INSN_UID (insn) = cur_insn_uid++;
3184
3185   PATTERN (insn) = pattern;
3186   INSN_CODE (insn) = -1;
3187   LOG_LINKS (insn) = NULL;
3188   REG_NOTES (insn) = NULL;
3189   CALL_INSN_FUNCTION_USAGE (insn) = NULL;
3190
3191   return insn;
3192 }
3193 \f
3194 /* Add INSN to the end of the doubly-linked list.
3195    INSN may be an INSN, JUMP_INSN, CALL_INSN, CODE_LABEL, BARRIER or NOTE.  */
3196
3197 void
3198 add_insn (insn)
3199      rtx insn;
3200 {
3201   PREV_INSN (insn) = last_insn;
3202   NEXT_INSN (insn) = 0;
3203
3204   if (NULL != last_insn)
3205     NEXT_INSN (last_insn) = insn;
3206
3207   if (NULL == first_insn)
3208     first_insn = insn;
3209
3210   last_insn = insn;
3211 }
3212
3213 /* Add INSN into the doubly-linked list after insn AFTER.  This and
3214    the next should be the only functions called to insert an insn once
3215    delay slots have been filled since only they know how to update a
3216    SEQUENCE.  */
3217
3218 void
3219 add_insn_after (insn, after)
3220      rtx insn, after;
3221 {
3222   rtx next = NEXT_INSN (after);
3223   basic_block bb;
3224
3225   if (optimize && INSN_DELETED_P (after))
3226     abort ();
3227
3228   NEXT_INSN (insn) = next;
3229   PREV_INSN (insn) = after;
3230
3231   if (next)
3232     {
3233       PREV_INSN (next) = insn;
3234       if (GET_CODE (next) == INSN && GET_CODE (PATTERN (next)) == SEQUENCE)
3235         PREV_INSN (XVECEXP (PATTERN (next), 0, 0)) = insn;
3236     }
3237   else if (last_insn == after)
3238     last_insn = insn;
3239   else
3240     {
3241       struct sequence_stack *stack = seq_stack;
3242       /* Scan all pending sequences too.  */
3243       for (; stack; stack = stack->next)
3244         if (after == stack->last)
3245           {
3246             stack->last = insn;
3247             break;
3248           }
3249
3250       if (stack == 0)
3251         abort ();
3252     }
3253
3254   if (basic_block_for_insn
3255       && (unsigned int) INSN_UID (after) < basic_block_for_insn->num_elements
3256       && (bb = BLOCK_FOR_INSN (after)))
3257     {
3258       set_block_for_insn (insn, bb);
3259       if (INSN_P (insn))
3260         bb->flags |= BB_DIRTY;
3261       /* Should not happen as first in the BB is always
3262          either NOTE or LABEL.  */
3263       if (bb->end == after
3264           /* Avoid clobbering of structure when creating new BB.  */
3265           && GET_CODE (insn) != BARRIER
3266           && (GET_CODE (insn) != NOTE
3267               || NOTE_LINE_NUMBER (insn) != NOTE_INSN_BASIC_BLOCK))
3268         bb->end = insn;
3269     }
3270
3271   NEXT_INSN (after) = insn;
3272   if (GET_CODE (after) == INSN && GET_CODE (PATTERN (after)) == SEQUENCE)
3273     {
3274       rtx sequence = PATTERN (after);
3275       NEXT_INSN (XVECEXP (sequence, 0, XVECLEN (sequence, 0) - 1)) = insn;
3276     }
3277 }
3278
3279 /* Add INSN into the doubly-linked list before insn BEFORE.  This and
3280    the previous should be the only functions called to insert an insn once
3281    delay slots have been filled since only they know how to update a
3282    SEQUENCE.  */
3283
3284 void
3285 add_insn_before (insn, before)
3286      rtx insn, before;
3287 {
3288   rtx prev = PREV_INSN (before);
3289   basic_block bb;
3290
3291   if (optimize && INSN_DELETED_P (before))
3292     abort ();
3293
3294   PREV_INSN (insn) = prev;
3295   NEXT_INSN (insn) = before;
3296
3297   if (prev)
3298     {
3299       NEXT_INSN (prev) = insn;
3300       if (GET_CODE (prev) == INSN && GET_CODE (PATTERN (prev)) == SEQUENCE)
3301         {
3302           rtx sequence = PATTERN (prev);
3303           NEXT_INSN (XVECEXP (sequence, 0, XVECLEN (sequence, 0) - 1)) = insn;
3304         }
3305     }
3306   else if (first_insn == before)
3307     first_insn = insn;
3308   else
3309     {
3310       struct sequence_stack *stack = seq_stack;
3311       /* Scan all pending sequences too.  */
3312       for (; stack; stack = stack->next)
3313         if (before == stack->first)
3314           {
3315             stack->first = insn;
3316             break;
3317           }
3318
3319       if (stack == 0)
3320         abort ();
3321     }
3322
3323   if (basic_block_for_insn
3324       && (unsigned int) INSN_UID (before) < basic_block_for_insn->num_elements
3325       && (bb = BLOCK_FOR_INSN (before)))
3326     {
3327       set_block_for_insn (insn, bb);
3328       if (INSN_P (insn))
3329         bb->flags |= BB_DIRTY;
3330       /* Should not happen as first in the BB is always
3331          either NOTE or LABEl.  */
3332       if (bb->head == insn
3333           /* Avoid clobbering of structure when creating new BB.  */
3334           && GET_CODE (insn) != BARRIER
3335           && (GET_CODE (insn) != NOTE
3336               || NOTE_LINE_NUMBER (insn) != NOTE_INSN_BASIC_BLOCK))
3337         abort ();
3338     }
3339
3340   PREV_INSN (before) = insn;
3341   if (GET_CODE (before) == INSN && GET_CODE (PATTERN (before)) == SEQUENCE)
3342     PREV_INSN (XVECEXP (PATTERN (before), 0, 0)) = insn;
3343 }
3344
3345 /* Remove an insn from its doubly-linked list.  This function knows how
3346    to handle sequences.  */
3347 void
3348 remove_insn (insn)
3349      rtx insn;
3350 {
3351   rtx next = NEXT_INSN (insn);
3352   rtx prev = PREV_INSN (insn);
3353   basic_block bb;
3354
3355   if (prev)
3356     {
3357       NEXT_INSN (prev) = next;
3358       if (GET_CODE (prev) == INSN && GET_CODE (PATTERN (prev)) == SEQUENCE)
3359         {
3360           rtx sequence = PATTERN (prev);
3361           NEXT_INSN (XVECEXP (sequence, 0, XVECLEN (sequence, 0) - 1)) = next;
3362         }
3363     }
3364   else if (first_insn == insn)
3365     first_insn = next;
3366   else
3367     {
3368       struct sequence_stack *stack = seq_stack;
3369       /* Scan all pending sequences too.  */
3370       for (; stack; stack = stack->next)
3371         if (insn == stack->first)
3372           {
3373             stack->first = next;
3374             break;
3375           }
3376
3377       if (stack == 0)
3378         abort ();
3379     }
3380
3381   if (next)
3382     {
3383       PREV_INSN (next) = prev;
3384       if (GET_CODE (next) == INSN && GET_CODE (PATTERN (next)) == SEQUENCE)
3385         PREV_INSN (XVECEXP (PATTERN (next), 0, 0)) = prev;
3386     }
3387   else if (last_insn == insn)
3388     last_insn = prev;
3389   else
3390     {
3391       struct sequence_stack *stack = seq_stack;
3392       /* Scan all pending sequences too.  */
3393       for (; stack; stack = stack->next)
3394         if (insn == stack->last)
3395           {
3396             stack->last = prev;
3397             break;
3398           }
3399
3400       if (stack == 0)
3401         abort ();
3402     }
3403   if (basic_block_for_insn
3404       && (unsigned int) INSN_UID (insn) < basic_block_for_insn->num_elements
3405       && (bb = BLOCK_FOR_INSN (insn)))
3406     {
3407       if (INSN_P (insn))
3408         bb->flags |= BB_DIRTY;
3409       if (bb->head == insn)
3410         {
3411           /* Never ever delete the basic block note without deleting whole
3412              basic block.  */
3413           if (GET_CODE (insn) == NOTE)
3414             abort ();
3415           bb->head = next;
3416         }
3417       if (bb->end == insn)
3418         bb->end = prev;
3419     }
3420 }
3421
3422 /* Delete all insns made since FROM.
3423    FROM becomes the new last instruction.  */
3424
3425 void
3426 delete_insns_since (from)
3427      rtx from;
3428 {
3429   if (from == 0)
3430     first_insn = 0;
3431   else
3432     NEXT_INSN (from) = 0;
3433   last_insn = from;
3434 }
3435
3436 /* This function is deprecated, please use sequences instead.
3437
3438    Move a consecutive bunch of insns to a different place in the chain.
3439    The insns to be moved are those between FROM and TO.
3440    They are moved to a new position after the insn AFTER.
3441    AFTER must not be FROM or TO or any insn in between.
3442
3443    This function does not know about SEQUENCEs and hence should not be
3444    called after delay-slot filling has been done.  */
3445
3446 void
3447 reorder_insns_nobb (from, to, after)
3448      rtx from, to, after;
3449 {
3450   /* Splice this bunch out of where it is now.  */
3451   if (PREV_INSN (from))
3452     NEXT_INSN (PREV_INSN (from)) = NEXT_INSN (to);
3453   if (NEXT_INSN (to))
3454     PREV_INSN (NEXT_INSN (to)) = PREV_INSN (from);
3455   if (last_insn == to)
3456     last_insn = PREV_INSN (from);
3457   if (first_insn == from)
3458     first_insn = NEXT_INSN (to);
3459
3460   /* Make the new neighbors point to it and it to them.  */
3461   if (NEXT_INSN (after))
3462     PREV_INSN (NEXT_INSN (after)) = to;
3463
3464   NEXT_INSN (to) = NEXT_INSN (after);
3465   PREV_INSN (from) = after;
3466   NEXT_INSN (after) = from;
3467   if (after == last_insn)
3468     last_insn = to;
3469 }
3470
3471 /* Same as function above, but take care to update BB boundaries.  */
3472 void
3473 reorder_insns (from, to, after)
3474      rtx from, to, after;
3475 {
3476   rtx prev = PREV_INSN (from);
3477   basic_block bb, bb2;
3478
3479   reorder_insns_nobb (from, to, after);
3480
3481   if (basic_block_for_insn
3482       && (unsigned int) INSN_UID (after) < basic_block_for_insn->num_elements
3483       && (bb = BLOCK_FOR_INSN (after)))
3484     {
3485       rtx x;
3486       bb->flags |= BB_DIRTY;
3487
3488       if (basic_block_for_insn
3489           && ((unsigned int) INSN_UID (from)
3490               < basic_block_for_insn->num_elements)
3491           && (bb2 = BLOCK_FOR_INSN (from)))
3492         {
3493           if (bb2->end == to)
3494             bb2->end = prev;
3495           bb2->flags |= BB_DIRTY;
3496         }
3497
3498       if (bb->end == after)
3499         bb->end = to;
3500
3501       for (x = from; x != NEXT_INSN (to); x = NEXT_INSN (x))
3502         set_block_for_insn (x, bb);
3503     }
3504 }
3505
3506 /* Return the line note insn preceding INSN.  */
3507
3508 static rtx
3509 find_line_note (insn)
3510      rtx insn;
3511 {
3512   if (no_line_numbers)
3513     return 0;
3514
3515   for (; insn; insn = PREV_INSN (insn))
3516     if (GET_CODE (insn) == NOTE
3517         && NOTE_LINE_NUMBER (insn) >= 0)
3518       break;
3519
3520   return insn;
3521 }
3522
3523 /* Like reorder_insns, but inserts line notes to preserve the line numbers
3524    of the moved insns when debugging.  This may insert a note between AFTER
3525    and FROM, and another one after TO.  */
3526
3527 void
3528 reorder_insns_with_line_notes (from, to, after)
3529      rtx from, to, after;
3530 {
3531   rtx from_line = find_line_note (from);
3532   rtx after_line = find_line_note (after);
3533
3534   reorder_insns (from, to, after);
3535
3536   if (from_line == after_line)
3537     return;
3538
3539   if (from_line)
3540     emit_line_note_after (NOTE_SOURCE_FILE (from_line),
3541                           NOTE_LINE_NUMBER (from_line),
3542                           after);
3543   if (after_line)
3544     emit_line_note_after (NOTE_SOURCE_FILE (after_line),
3545                           NOTE_LINE_NUMBER (after_line),
3546                           to);
3547 }
3548
3549 /* Remove unnecessary notes from the instruction stream.  */
3550
3551 void
3552 remove_unnecessary_notes ()
3553 {
3554   rtx block_stack = NULL_RTX;
3555   rtx eh_stack = NULL_RTX;
3556   rtx insn;
3557   rtx next;
3558   rtx tmp;
3559
3560   /* We must not remove the first instruction in the function because
3561      the compiler depends on the first instruction being a note.  */
3562   for (insn = NEXT_INSN (get_insns ()); insn; insn = next)
3563     {
3564       /* Remember what's next.  */
3565       next = NEXT_INSN (insn);
3566
3567       /* We're only interested in notes.  */
3568       if (GET_CODE (insn) != NOTE)
3569         continue;
3570
3571       switch (NOTE_LINE_NUMBER (insn))
3572         {
3573         case NOTE_INSN_DELETED:
3574         case NOTE_INSN_LOOP_END_TOP_COND:
3575           remove_insn (insn);
3576           break;
3577
3578         case NOTE_INSN_EH_REGION_BEG:
3579           eh_stack = alloc_INSN_LIST (insn, eh_stack);
3580           break;
3581
3582         case NOTE_INSN_EH_REGION_END:
3583           /* Too many end notes.  */
3584           if (eh_stack == NULL_RTX)
3585             abort ();
3586           /* Mismatched nesting.  */
3587           if (NOTE_EH_HANDLER (XEXP (eh_stack, 0)) != NOTE_EH_HANDLER (insn))
3588             abort ();
3589           tmp = eh_stack;
3590           eh_stack = XEXP (eh_stack, 1);
3591           free_INSN_LIST_node (tmp);
3592           break;
3593
3594         case NOTE_INSN_BLOCK_BEG:
3595           /* By now, all notes indicating lexical blocks should have
3596              NOTE_BLOCK filled in.  */
3597           if (NOTE_BLOCK (insn) == NULL_TREE)
3598             abort ();
3599           block_stack = alloc_INSN_LIST (insn, block_stack);
3600           break;
3601
3602         case NOTE_INSN_BLOCK_END:
3603           /* Too many end notes.  */
3604           if (block_stack == NULL_RTX)
3605             abort ();
3606           /* Mismatched nesting.  */
3607           if (NOTE_BLOCK (XEXP (block_stack, 0)) != NOTE_BLOCK (insn))
3608             abort ();
3609           tmp = block_stack;
3610           block_stack = XEXP (block_stack, 1);
3611           free_INSN_LIST_node (tmp);
3612
3613           /* Scan back to see if there are any non-note instructions
3614              between INSN and the beginning of this block.  If not,
3615              then there is no PC range in the generated code that will
3616              actually be in this block, so there's no point in
3617              remembering the existence of the block.  */
3618           for (tmp = PREV_INSN (insn); tmp; tmp = PREV_INSN (tmp))
3619             {
3620               /* This block contains a real instruction.  Note that we
3621                  don't include labels; if the only thing in the block
3622                  is a label, then there are still no PC values that
3623                  lie within the block.  */
3624               if (INSN_P (tmp))
3625                 break;
3626
3627               /* We're only interested in NOTEs.  */
3628               if (GET_CODE (tmp) != NOTE)
3629                 continue;
3630
3631               if (NOTE_LINE_NUMBER (tmp) == NOTE_INSN_BLOCK_BEG)
3632                 {
3633                   /* We just verified that this BLOCK matches us with
3634                      the block_stack check above.  Never delete the
3635                      BLOCK for the outermost scope of the function; we
3636                      can refer to names from that scope even if the
3637                      block notes are messed up.  */
3638                   if (! is_body_block (NOTE_BLOCK (insn))
3639                       && (*debug_hooks->ignore_block) (NOTE_BLOCK (insn)))
3640                     {
3641                       remove_insn (tmp);
3642                       remove_insn (insn);
3643                     }
3644                   break;
3645                 }
3646               else if (NOTE_LINE_NUMBER (tmp) == NOTE_INSN_BLOCK_END)
3647                 /* There's a nested block.  We need to leave the
3648                    current block in place since otherwise the debugger
3649                    wouldn't be able to show symbols from our block in
3650                    the nested block.  */
3651                 break;
3652             }
3653         }
3654     }
3655
3656   /* Too many begin notes.  */
3657   if (block_stack || eh_stack)
3658     abort ();
3659 }
3660
3661 \f
3662 /* Emit an insn of given code and pattern
3663    at a specified place within the doubly-linked list.  */
3664
3665 /* Make an instruction with body PATTERN
3666    and output it before the instruction BEFORE.  */
3667
3668 rtx
3669 emit_insn_before (pattern, before)
3670      rtx pattern, before;
3671 {
3672   rtx insn = before;
3673
3674   if (GET_CODE (pattern) == SEQUENCE)
3675     {
3676       int i;
3677
3678       for (i = 0; i < XVECLEN (pattern, 0); i++)
3679         {
3680           insn = XVECEXP (pattern, 0, i);
3681           add_insn_before (insn, before);
3682         }
3683     }
3684   else
3685     {
3686       insn = make_insn_raw (pattern);
3687       add_insn_before (insn, before);
3688     }
3689
3690   return insn;
3691 }
3692
3693 /* Make an instruction with body PATTERN and code JUMP_INSN
3694    and output it before the instruction BEFORE.  */
3695
3696 rtx
3697 emit_jump_insn_before (pattern, before)
3698      rtx pattern, before;
3699 {
3700   rtx insn;
3701
3702   if (GET_CODE (pattern) == SEQUENCE)
3703     insn = emit_insn_before (pattern, before);
3704   else
3705     {
3706       insn = make_jump_insn_raw (pattern);
3707       add_insn_before (insn, before);
3708     }
3709
3710   return insn;
3711 }
3712
3713 /* Make an instruction with body PATTERN and code CALL_INSN
3714    and output it before the instruction BEFORE.  */
3715
3716 rtx
3717 emit_call_insn_before (pattern, before)
3718      rtx pattern, before;
3719 {
3720   rtx insn;
3721
3722   if (GET_CODE (pattern) == SEQUENCE)
3723     insn = emit_insn_before (pattern, before);
3724   else
3725     {
3726       insn = make_call_insn_raw (pattern);
3727       add_insn_before (insn, before);
3728       PUT_CODE (insn, CALL_INSN);
3729     }
3730
3731   return insn;
3732 }
3733
3734 /* Make an instruction with body PATTERN and code CALL_INSN
3735    and output it before the instruction BEFORE.  */
3736
3737 rtx
3738 emit_call_insn_after (pattern, before)
3739      rtx pattern, before;
3740 {
3741   rtx insn;
3742
3743   if (GET_CODE (pattern) == SEQUENCE)
3744     insn = emit_insn_after (pattern, before);
3745   else
3746     {
3747       insn = make_call_insn_raw (pattern);
3748       add_insn_after (insn, before);
3749       PUT_CODE (insn, CALL_INSN);
3750     }
3751
3752   return insn;
3753 }
3754
3755 /* Make an insn of code BARRIER
3756    and output it before the insn BEFORE.  */
3757
3758 rtx
3759 emit_barrier_before (before)
3760      rtx before;
3761 {
3762   rtx insn = rtx_alloc (BARRIER);
3763
3764   INSN_UID (insn) = cur_insn_uid++;
3765
3766   add_insn_before (insn, before);
3767   return insn;
3768 }
3769
3770 /* Emit the label LABEL before the insn BEFORE.  */
3771
3772 rtx
3773 emit_label_before (label, before)
3774      rtx label, before;
3775 {
3776   /* This can be called twice for the same label as a result of the
3777      confusion that follows a syntax error!  So make it harmless.  */
3778   if (INSN_UID (label) == 0)
3779     {
3780       INSN_UID (label) = cur_insn_uid++;
3781       add_insn_before (label, before);
3782     }
3783
3784   return label;
3785 }
3786
3787 /* Emit a note of subtype SUBTYPE before the insn BEFORE.  */
3788
3789 rtx
3790 emit_note_before (subtype, before)
3791      int subtype;
3792      rtx before;
3793 {
3794   rtx note = rtx_alloc (NOTE);
3795   INSN_UID (note) = cur_insn_uid++;
3796   NOTE_SOURCE_FILE (note) = 0;
3797   NOTE_LINE_NUMBER (note) = subtype;
3798
3799   add_insn_before (note, before);
3800   return note;
3801 }
3802 \f
3803 /* Make an insn of code INSN with body PATTERN
3804    and output it after the insn AFTER.  */
3805
3806 rtx
3807 emit_insn_after (pattern, after)
3808      rtx pattern, after;
3809 {
3810   rtx insn = after;
3811
3812   if (GET_CODE (pattern) == SEQUENCE)
3813     {
3814       int i;
3815
3816       for (i = 0; i < XVECLEN (pattern, 0); i++)
3817         {
3818           insn = XVECEXP (pattern, 0, i);
3819           add_insn_after (insn, after);
3820           after = insn;
3821         }
3822     }
3823   else
3824     {
3825       insn = make_insn_raw (pattern);
3826       add_insn_after (insn, after);
3827     }
3828
3829   return insn;
3830 }
3831
3832 /* Similar to emit_insn_after, except that line notes are to be inserted so
3833    as to act as if this insn were at FROM.  */
3834
3835 void
3836 emit_insn_after_with_line_notes (pattern, after, from)
3837      rtx pattern, after, from;
3838 {
3839   rtx from_line = find_line_note (from);
3840   rtx after_line = find_line_note (after);
3841   rtx insn = emit_insn_after (pattern, after);
3842
3843   if (from_line)
3844     emit_line_note_after (NOTE_SOURCE_FILE (from_line),
3845                           NOTE_LINE_NUMBER (from_line),
3846                           after);
3847
3848   if (after_line)
3849     emit_line_note_after (NOTE_SOURCE_FILE (after_line),
3850                           NOTE_LINE_NUMBER (after_line),
3851                           insn);
3852 }
3853
3854 /* Make an insn of code JUMP_INSN with body PATTERN
3855    and output it after the insn AFTER.  */
3856
3857 rtx
3858 emit_jump_insn_after (pattern, after)
3859      rtx pattern, after;
3860 {
3861   rtx insn;
3862
3863   if (GET_CODE (pattern) == SEQUENCE)
3864     insn = emit_insn_after (pattern, after);
3865   else
3866     {
3867       insn = make_jump_insn_raw (pattern);
3868       add_insn_after (insn, after);
3869     }
3870
3871   return insn;
3872 }
3873
3874 /* Make an insn of code BARRIER
3875    and output it after the insn AFTER.  */
3876
3877 rtx
3878 emit_barrier_after (after)
3879      rtx after;
3880 {
3881   rtx insn = rtx_alloc (BARRIER);
3882
3883   INSN_UID (insn) = cur_insn_uid++;
3884
3885   add_insn_after (insn, after);
3886   return insn;
3887 }
3888
3889 /* Emit the label LABEL after the insn AFTER.  */
3890
3891 rtx
3892 emit_label_after (label, after)
3893      rtx label, after;
3894 {
3895   /* This can be called twice for the same label
3896      as a result of the confusion that follows a syntax error!
3897      So make it harmless.  */
3898   if (INSN_UID (label) == 0)
3899     {
3900       INSN_UID (label) = cur_insn_uid++;
3901       add_insn_after (label, after);
3902     }
3903
3904   return label;
3905 }
3906
3907 /* Emit a note of subtype SUBTYPE after the insn AFTER.  */
3908
3909 rtx
3910 emit_note_after (subtype, after)
3911      int subtype;
3912      rtx after;
3913 {
3914   rtx note = rtx_alloc (NOTE);
3915   INSN_UID (note) = cur_insn_uid++;
3916   NOTE_SOURCE_FILE (note) = 0;
3917   NOTE_LINE_NUMBER (note) = subtype;
3918   add_insn_after (note, after);
3919   return note;
3920 }
3921
3922 /* Emit a line note for FILE and LINE after the insn AFTER.  */
3923
3924 rtx
3925 emit_line_note_after (file, line, after)
3926      const char *file;
3927      int line;
3928      rtx after;
3929 {
3930   rtx note;
3931
3932   if (no_line_numbers && line > 0)
3933     {
3934       cur_insn_uid++;
3935       return 0;
3936     }
3937
3938   note = rtx_alloc (NOTE);
3939   INSN_UID (note) = cur_insn_uid++;
3940   NOTE_SOURCE_FILE (note) = file;
3941   NOTE_LINE_NUMBER (note) = line;
3942   add_insn_after (note, after);
3943   return note;
3944 }
3945 \f
3946 /* Make an insn of code INSN with pattern PATTERN
3947    and add it to the end of the doubly-linked list.
3948    If PATTERN is a SEQUENCE, take the elements of it
3949    and emit an insn for each element.
3950
3951    Returns the last insn emitted.  */
3952
3953 rtx
3954 emit_insn (pattern)
3955      rtx pattern;
3956 {
3957   rtx insn = last_insn;
3958
3959   if (GET_CODE (pattern) == SEQUENCE)
3960     {
3961       int i;
3962
3963       for (i = 0; i < XVECLEN (pattern, 0); i++)
3964         {
3965           insn = XVECEXP (pattern, 0, i);
3966           add_insn (insn);
3967         }
3968     }
3969   else
3970     {
3971       insn = make_insn_raw (pattern);
3972       add_insn (insn);
3973     }
3974
3975   return insn;
3976 }
3977
3978 /* Emit the insns in a chain starting with INSN.
3979    Return the last insn emitted.  */
3980
3981 rtx
3982 emit_insns (insn)
3983      rtx insn;
3984 {
3985   rtx last = 0;
3986
3987   while (insn)
3988     {
3989       rtx next = NEXT_INSN (insn);
3990       add_insn (insn);
3991       last = insn;
3992       insn = next;
3993     }
3994
3995   return last;
3996 }
3997
3998 /* Emit the insns in a chain starting with INSN and place them in front of
3999    the insn BEFORE.  Return the last insn emitted.  */
4000
4001 rtx
4002 emit_insns_before (insn, before)
4003      rtx insn;
4004      rtx before;
4005 {
4006   rtx last = 0;
4007
4008   while (insn)
4009     {
4010       rtx next = NEXT_INSN (insn);
4011       add_insn_before (insn, before);
4012       last = insn;
4013       insn = next;
4014     }
4015
4016   return last;
4017 }
4018
4019 /* Emit the insns in a chain starting with FIRST and place them in back of
4020    the insn AFTER.  Return the last insn emitted.  */
4021
4022 rtx
4023 emit_insns_after (first, after)
4024      rtx first;
4025      rtx after;
4026 {
4027   rtx last;
4028   rtx after_after;
4029   basic_block bb;
4030
4031   if (!after)
4032     abort ();
4033
4034   if (!first)
4035     return after;
4036
4037   if (basic_block_for_insn
4038       && (unsigned int) INSN_UID (after) < basic_block_for_insn->num_elements
4039       && (bb = BLOCK_FOR_INSN (after)))
4040     {
4041       bb->flags |= BB_DIRTY;
4042       for (last = first; NEXT_INSN (last); last = NEXT_INSN (last))
4043         set_block_for_insn (last, bb);
4044       set_block_for_insn (last, bb);
4045       if (bb->end == after)
4046         bb->end = last;
4047     }
4048   else
4049     for (last = first; NEXT_INSN (last); last = NEXT_INSN (last))
4050       continue;
4051
4052   after_after = NEXT_INSN (after);
4053
4054   NEXT_INSN (after) = first;
4055   PREV_INSN (first) = after;
4056   NEXT_INSN (last) = after_after;
4057   if (after_after)
4058     PREV_INSN (after_after) = last;
4059
4060   if (after == last_insn)
4061     last_insn = last;
4062   return last;
4063 }
4064
4065 /* Make an insn of code JUMP_INSN with pattern PATTERN
4066    and add it to the end of the doubly-linked list.  */
4067
4068 rtx
4069 emit_jump_insn (pattern)
4070      rtx pattern;
4071 {
4072   if (GET_CODE (pattern) == SEQUENCE)
4073     return emit_insn (pattern);
4074   else
4075     {
4076       rtx insn = make_jump_insn_raw (pattern);
4077       add_insn (insn);
4078       return insn;
4079     }
4080 }
4081
4082 /* Make an insn of code CALL_INSN with pattern PATTERN
4083    and add it to the end of the doubly-linked list.  */
4084
4085 rtx
4086 emit_call_insn (pattern)
4087      rtx pattern;
4088 {
4089   if (GET_CODE (pattern) == SEQUENCE)
4090     return emit_insn (pattern);
4091   else
4092     {
4093       rtx insn = make_call_insn_raw (pattern);
4094       add_insn (insn);
4095       PUT_CODE (insn, CALL_INSN);
4096       return insn;
4097     }
4098 }
4099
4100 /* Add the label LABEL to the end of the doubly-linked list.  */
4101
4102 rtx
4103 emit_label (label)
4104      rtx label;
4105 {
4106   /* This can be called twice for the same label
4107      as a result of the confusion that follows a syntax error!
4108      So make it harmless.  */
4109   if (INSN_UID (label) == 0)
4110     {
4111       INSN_UID (label) = cur_insn_uid++;
4112       add_insn (label);
4113     }
4114   return label;
4115 }
4116
4117 /* Make an insn of code BARRIER
4118    and add it to the end of the doubly-linked list.  */
4119
4120 rtx
4121 emit_barrier ()
4122 {
4123   rtx barrier = rtx_alloc (BARRIER);
4124   INSN_UID (barrier) = cur_insn_uid++;
4125   add_insn (barrier);
4126   return barrier;
4127 }
4128
4129 /* Make an insn of code NOTE
4130    with data-fields specified by FILE and LINE
4131    and add it to the end of the doubly-linked list,
4132    but only if line-numbers are desired for debugging info.  */
4133
4134 rtx
4135 emit_line_note (file, line)
4136      const char *file;
4137      int line;
4138 {
4139   set_file_and_line_for_stmt (file, line);
4140
4141 #if 0
4142   if (no_line_numbers)
4143     return 0;
4144 #endif
4145
4146   return emit_note (file, line);
4147 }
4148
4149 /* Make an insn of code NOTE
4150    with data-fields specified by FILE and LINE
4151    and add it to the end of the doubly-linked list.
4152    If it is a line-number NOTE, omit it if it matches the previous one.  */
4153
4154 rtx
4155 emit_note (file, line)
4156      const char *file;
4157      int line;
4158 {
4159   rtx note;
4160
4161   if (line > 0)
4162     {
4163       if (file && last_filename && !strcmp (file, last_filename)
4164           && line == last_linenum)
4165         return 0;
4166       last_filename = file;
4167       last_linenum = line;
4168     }
4169
4170   if (no_line_numbers && line > 0)
4171     {
4172       cur_insn_uid++;
4173       return 0;
4174     }
4175
4176   note = rtx_alloc (NOTE);
4177   INSN_UID (note) = cur_insn_uid++;
4178   NOTE_SOURCE_FILE (note) = file;
4179   NOTE_LINE_NUMBER (note) = line;
4180   add_insn (note);
4181   return note;
4182 }
4183
4184 /* Emit a NOTE, and don't omit it even if LINE is the previous note.  */
4185
4186 rtx
4187 emit_line_note_force (file, line)
4188      const char *file;
4189      int line;
4190 {
4191   last_linenum = -1;
4192   return emit_line_note (file, line);
4193 }
4194
4195 /* Cause next statement to emit a line note even if the line number
4196    has not changed.  This is used at the beginning of a function.  */
4197
4198 void
4199 force_next_line_note ()
4200 {
4201   last_linenum = -1;
4202 }
4203
4204 /* Place a note of KIND on insn INSN with DATUM as the datum. If a
4205    note of this type already exists, remove it first.  */
4206
4207 rtx
4208 set_unique_reg_note (insn, kind, datum)
4209      rtx insn;
4210      enum reg_note kind;
4211      rtx datum;
4212 {
4213   rtx note = find_reg_note (insn, kind, NULL_RTX);
4214
4215   switch (kind)
4216     {
4217     case REG_EQUAL:
4218     case REG_EQUIV:
4219       /* Don't add REG_EQUAL/REG_EQUIV notes if the insn
4220          has multiple sets (some callers assume single_set
4221          means the insn only has one set, when in fact it
4222          means the insn only has one * useful * set).  */
4223       if (GET_CODE (PATTERN (insn)) == PARALLEL && multiple_sets (insn))
4224         {
4225           if (note)
4226             abort ();
4227           return NULL_RTX;
4228         }
4229
4230       /* Don't add ASM_OPERAND REG_EQUAL/REG_EQUIV notes.
4231          It serves no useful purpose and breaks eliminate_regs.  */
4232       if (GET_CODE (datum) == ASM_OPERANDS)
4233         return NULL_RTX;
4234       break;
4235
4236     default:
4237       break;
4238     }
4239
4240   if (note)
4241     {
4242       XEXP (note, 0) = datum;
4243       return note;
4244     }
4245
4246   REG_NOTES (insn) = gen_rtx_EXPR_LIST (kind, datum, REG_NOTES (insn));
4247   return REG_NOTES (insn);
4248 }
4249 \f
4250 /* Return an indication of which type of insn should have X as a body.
4251    The value is CODE_LABEL, INSN, CALL_INSN or JUMP_INSN.  */
4252
4253 enum rtx_code
4254 classify_insn (x)
4255      rtx x;
4256 {
4257   if (GET_CODE (x) == CODE_LABEL)
4258     return CODE_LABEL;
4259   if (GET_CODE (x) == CALL)
4260     return CALL_INSN;
4261   if (GET_CODE (x) == RETURN)
4262     return JUMP_INSN;
4263   if (GET_CODE (x) == SET)
4264     {
4265       if (SET_DEST (x) == pc_rtx)
4266         return JUMP_INSN;
4267       else if (GET_CODE (SET_SRC (x)) == CALL)
4268         return CALL_INSN;
4269       else
4270         return INSN;
4271     }
4272   if (GET_CODE (x) == PARALLEL)
4273     {
4274       int j;
4275       for (j = XVECLEN (x, 0) - 1; j >= 0; j--)
4276         if (GET_CODE (XVECEXP (x, 0, j)) == CALL)
4277           return CALL_INSN;
4278         else if (GET_CODE (XVECEXP (x, 0, j)) == SET
4279                  && SET_DEST (XVECEXP (x, 0, j)) == pc_rtx)
4280           return JUMP_INSN;
4281         else if (GET_CODE (XVECEXP (x, 0, j)) == SET
4282                  && GET_CODE (SET_SRC (XVECEXP (x, 0, j))) == CALL)
4283           return CALL_INSN;
4284     }
4285   return INSN;
4286 }
4287
4288 /* Emit the rtl pattern X as an appropriate kind of insn.
4289    If X is a label, it is simply added into the insn chain.  */
4290
4291 rtx
4292 emit (x)
4293      rtx x;
4294 {
4295   enum rtx_code code = classify_insn (x);
4296
4297   if (code == CODE_LABEL)
4298     return emit_label (x);
4299   else if (code == INSN)
4300     return emit_insn (x);
4301   else if (code == JUMP_INSN)
4302     {
4303       rtx insn = emit_jump_insn (x);
4304       if (any_uncondjump_p (insn) || GET_CODE (x) == RETURN)
4305         return emit_barrier ();
4306       return insn;
4307     }
4308   else if (code == CALL_INSN)
4309     return emit_call_insn (x);
4310   else
4311     abort ();
4312 }
4313 \f
4314 /* Begin emitting insns to a sequence which can be packaged in an
4315    RTL_EXPR.  If this sequence will contain something that might cause
4316    the compiler to pop arguments to function calls (because those
4317    pops have previously been deferred; see INHIBIT_DEFER_POP for more
4318    details), use do_pending_stack_adjust before calling this function.
4319    That will ensure that the deferred pops are not accidentally
4320    emitted in the middle of this sequence.  */
4321
4322 void
4323 start_sequence ()
4324 {
4325   struct sequence_stack *tem;
4326
4327   tem = (struct sequence_stack *) xmalloc (sizeof (struct sequence_stack));
4328
4329   tem->next = seq_stack;
4330   tem->first = first_insn;
4331   tem->last = last_insn;
4332   tem->sequence_rtl_expr = seq_rtl_expr;
4333
4334   seq_stack = tem;
4335
4336   first_insn = 0;
4337   last_insn = 0;
4338 }
4339
4340 /* Similarly, but indicate that this sequence will be placed in T, an
4341    RTL_EXPR.  See the documentation for start_sequence for more
4342    information about how to use this function.  */
4343
4344 void
4345 start_sequence_for_rtl_expr (t)
4346      tree t;
4347 {
4348   start_sequence ();
4349
4350   seq_rtl_expr = t;
4351 }
4352
4353 /* Set up the insn chain starting with FIRST as the current sequence,
4354    saving the previously current one.  See the documentation for
4355    start_sequence for more information about how to use this function.  */
4356
4357 void
4358 push_to_sequence (first)
4359      rtx first;
4360 {
4361   rtx last;
4362
4363   start_sequence ();
4364
4365   for (last = first; last && NEXT_INSN (last); last = NEXT_INSN (last));
4366
4367   first_insn = first;
4368   last_insn = last;
4369 }
4370
4371 /* Set up the insn chain from a chain stort in FIRST to LAST.  */
4372
4373 void
4374 push_to_full_sequence (first, last)
4375      rtx first, last;
4376 {
4377   start_sequence ();
4378   first_insn = first;
4379   last_insn = last;
4380   /* We really should have the end of the insn chain here.  */
4381   if (last && NEXT_INSN (last))
4382     abort ();
4383 }
4384
4385 /* Set up the outer-level insn chain
4386    as the current sequence, saving the previously current one.  */
4387
4388 void
4389 push_topmost_sequence ()
4390 {
4391   struct sequence_stack *stack, *top = NULL;
4392
4393   start_sequence ();
4394
4395   for (stack = seq_stack; stack; stack = stack->next)
4396     top = stack;
4397
4398   first_insn = top->first;
4399   last_insn = top->last;
4400   seq_rtl_expr = top->sequence_rtl_expr;
4401 }
4402
4403 /* After emitting to the outer-level insn chain, update the outer-level
4404    insn chain, and restore the previous saved state.  */
4405
4406 void
4407 pop_topmost_sequence ()
4408 {
4409   struct sequence_stack *stack, *top = NULL;
4410
4411   for (stack = seq_stack; stack; stack = stack->next)
4412     top = stack;
4413
4414   top->first = first_insn;
4415   top->last = last_insn;
4416   /* ??? Why don't we save seq_rtl_expr here?  */
4417
4418   end_sequence ();
4419 }
4420
4421 /* After emitting to a sequence, restore previous saved state.
4422
4423    To get the contents of the sequence just made, you must call
4424    `gen_sequence' *before* calling here.
4425
4426    If the compiler might have deferred popping arguments while
4427    generating this sequence, and this sequence will not be immediately
4428    inserted into the instruction stream, use do_pending_stack_adjust
4429    before calling gen_sequence.  That will ensure that the deferred
4430    pops are inserted into this sequence, and not into some random
4431    location in the instruction stream.  See INHIBIT_DEFER_POP for more
4432    information about deferred popping of arguments.  */
4433
4434 void
4435 end_sequence ()
4436 {
4437   struct sequence_stack *tem = seq_stack;
4438
4439   first_insn = tem->first;
4440   last_insn = tem->last;
4441   seq_rtl_expr = tem->sequence_rtl_expr;
4442   seq_stack = tem->next;
4443
4444   free (tem);
4445 }
4446
4447 /* This works like end_sequence, but records the old sequence in FIRST
4448    and LAST.  */
4449
4450 void
4451 end_full_sequence (first, last)
4452      rtx *first, *last;
4453 {
4454   *first = first_insn;
4455   *last = last_insn;
4456   end_sequence ();
4457 }
4458
4459 /* Return 1 if currently emitting into a sequence.  */
4460
4461 int
4462 in_sequence_p ()
4463 {
4464   return seq_stack != 0;
4465 }
4466
4467 /* Generate a SEQUENCE rtx containing the insns already emitted
4468    to the current sequence.
4469
4470    This is how the gen_... function from a DEFINE_EXPAND
4471    constructs the SEQUENCE that it returns.  */
4472
4473 rtx
4474 gen_sequence ()
4475 {
4476   rtx result;
4477   rtx tem;
4478   int i;
4479   int len;
4480
4481   /* Count the insns in the chain.  */
4482   len = 0;
4483   for (tem = first_insn; tem; tem = NEXT_INSN (tem))
4484     len++;
4485
4486   /* If only one insn, return it rather than a SEQUENCE.
4487      (Now that we cache SEQUENCE expressions, it isn't worth special-casing
4488      the case of an empty list.)
4489      We only return the pattern of an insn if its code is INSN and it
4490      has no notes.  This ensures that no information gets lost.  */
4491   if (len == 1
4492       && GET_CODE (first_insn) == INSN
4493       && ! RTX_FRAME_RELATED_P (first_insn)
4494       /* Don't throw away any reg notes.  */
4495       && REG_NOTES (first_insn) == 0)
4496     return PATTERN (first_insn);
4497
4498   result = gen_rtx_SEQUENCE (VOIDmode, rtvec_alloc (len));
4499
4500   for (i = 0, tem = first_insn; tem; tem = NEXT_INSN (tem), i++)
4501     XVECEXP (result, 0, i) = tem;
4502
4503   return result;
4504 }
4505 \f
4506 /* Put the various virtual registers into REGNO_REG_RTX.  */
4507
4508 void
4509 init_virtual_regs (es)
4510      struct emit_status *es;
4511 {
4512   rtx *ptr = es->x_regno_reg_rtx;
4513   ptr[VIRTUAL_INCOMING_ARGS_REGNUM] = virtual_incoming_args_rtx;
4514   ptr[VIRTUAL_STACK_VARS_REGNUM] = virtual_stack_vars_rtx;
4515   ptr[VIRTUAL_STACK_DYNAMIC_REGNUM] = virtual_stack_dynamic_rtx;
4516   ptr[VIRTUAL_OUTGOING_ARGS_REGNUM] = virtual_outgoing_args_rtx;
4517   ptr[VIRTUAL_CFA_REGNUM] = virtual_cfa_rtx;
4518 }
4519
4520 void
4521 clear_emit_caches ()
4522 {
4523   int i;
4524
4525   /* Clear the start_sequence/gen_sequence cache.  */
4526   for (i = 0; i < SEQUENCE_RESULT_SIZE; i++)
4527     sequence_result[i] = 0;
4528   free_insn = 0;
4529 }
4530 \f
4531 /* Used by copy_insn_1 to avoid copying SCRATCHes more than once.  */
4532 static rtx copy_insn_scratch_in[MAX_RECOG_OPERANDS];
4533 static rtx copy_insn_scratch_out[MAX_RECOG_OPERANDS];
4534 static int copy_insn_n_scratches;
4535
4536 /* When an insn is being copied by copy_insn_1, this is nonzero if we have
4537    copied an ASM_OPERANDS.
4538    In that case, it is the original input-operand vector.  */
4539 static rtvec orig_asm_operands_vector;
4540
4541 /* When an insn is being copied by copy_insn_1, this is nonzero if we have
4542    copied an ASM_OPERANDS.
4543    In that case, it is the copied input-operand vector.  */
4544 static rtvec copy_asm_operands_vector;
4545
4546 /* Likewise for the constraints vector.  */
4547 static rtvec orig_asm_constraints_vector;
4548 static rtvec copy_asm_constraints_vector;
4549
4550 /* Recursively create a new copy of an rtx for copy_insn.
4551    This function differs from copy_rtx in that it handles SCRATCHes and
4552    ASM_OPERANDs properly.
4553    Normally, this function is not used directly; use copy_insn as front end.
4554    However, you could first copy an insn pattern with copy_insn and then use
4555    this function afterwards to properly copy any REG_NOTEs containing
4556    SCRATCHes.  */
4557
4558 rtx
4559 copy_insn_1 (orig)
4560      rtx orig;
4561 {
4562   rtx copy;
4563   int i, j;
4564   RTX_CODE code;
4565   const char *format_ptr;
4566
4567   code = GET_CODE (orig);
4568
4569   switch (code)
4570     {
4571     case REG:
4572     case QUEUED:
4573     case CONST_INT:
4574     case CONST_DOUBLE:
4575     case CONST_VECTOR:
4576     case SYMBOL_REF:
4577     case CODE_LABEL:
4578     case PC:
4579     case CC0:
4580     case ADDRESSOF:
4581       return orig;
4582
4583     case SCRATCH:
4584       for (i = 0; i < copy_insn_n_scratches; i++)
4585         if (copy_insn_scratch_in[i] == orig)
4586           return copy_insn_scratch_out[i];
4587       break;
4588
4589     case CONST:
4590       /* CONST can be shared if it contains a SYMBOL_REF.  If it contains
4591          a LABEL_REF, it isn't sharable.  */
4592       if (GET_CODE (XEXP (orig, 0)) == PLUS
4593           && GET_CODE (XEXP (XEXP (orig, 0), 0)) == SYMBOL_REF
4594           && GET_CODE (XEXP (XEXP (orig, 0), 1)) == CONST_INT)
4595         return orig;
4596       break;
4597
4598       /* A MEM with a constant address is not sharable.  The problem is that
4599          the constant address may need to be reloaded.  If the mem is shared,
4600          then reloading one copy of this mem will cause all copies to appear
4601          to have been reloaded.  */
4602
4603     default:
4604       break;
4605     }
4606
4607   copy = rtx_alloc (code);
4608
4609   /* Copy the various flags, and other information.  We assume that
4610      all fields need copying, and then clear the fields that should
4611      not be copied.  That is the sensible default behavior, and forces
4612      us to explicitly document why we are *not* copying a flag.  */
4613   memcpy (copy, orig, sizeof (struct rtx_def) - sizeof (rtunion));
4614
4615   /* We do not copy the USED flag, which is used as a mark bit during
4616      walks over the RTL.  */
4617   RTX_FLAG (copy, used) = 0;
4618
4619   /* We do not copy JUMP, CALL, or FRAME_RELATED for INSNs.  */
4620   if (GET_RTX_CLASS (code) == 'i')
4621     {
4622       RTX_FLAG (copy, jump) = 0;
4623       RTX_FLAG (copy, call) = 0;
4624       RTX_FLAG (copy, frame_related) = 0;
4625     }
4626
4627   format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
4628
4629   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
4630     {
4631       copy->fld[i] = orig->fld[i];
4632       switch (*format_ptr++)
4633         {
4634         case 'e':
4635           if (XEXP (orig, i) != NULL)
4636             XEXP (copy, i) = copy_insn_1 (XEXP (orig, i));
4637           break;
4638
4639         case 'E':
4640         case 'V':
4641           if (XVEC (orig, i) == orig_asm_constraints_vector)
4642             XVEC (copy, i) = copy_asm_constraints_vector;
4643           else if (XVEC (orig, i) == orig_asm_operands_vector)
4644             XVEC (copy, i) = copy_asm_operands_vector;
4645           else if (XVEC (orig, i) != NULL)
4646             {
4647               XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
4648               for (j = 0; j < XVECLEN (copy, i); j++)
4649                 XVECEXP (copy, i, j) = copy_insn_1 (XVECEXP (orig, i, j));
4650             }
4651           break;
4652
4653         case 't':
4654         case 'w':
4655         case 'i':
4656         case 's':
4657         case 'S':
4658         case 'u':
4659         case '0':
4660           /* These are left unchanged.  */
4661           break;
4662
4663         default:
4664           abort ();
4665         }
4666     }
4667
4668   if (code == SCRATCH)
4669     {
4670       i = copy_insn_n_scratches++;
4671       if (i >= MAX_RECOG_OPERANDS)
4672         abort ();
4673       copy_insn_scratch_in[i] = orig;
4674       copy_insn_scratch_out[i] = copy;
4675     }
4676   else if (code == ASM_OPERANDS)
4677     {
4678       orig_asm_operands_vector = ASM_OPERANDS_INPUT_VEC (orig);
4679       copy_asm_operands_vector = ASM_OPERANDS_INPUT_VEC (copy);
4680       orig_asm_constraints_vector = ASM_OPERANDS_INPUT_CONSTRAINT_VEC (orig);
4681       copy_asm_constraints_vector = ASM_OPERANDS_INPUT_CONSTRAINT_VEC (copy);
4682     }
4683
4684   return copy;
4685 }
4686
4687 /* Create a new copy of an rtx.
4688    This function differs from copy_rtx in that it handles SCRATCHes and
4689    ASM_OPERANDs properly.
4690    INSN doesn't really have to be a full INSN; it could be just the
4691    pattern.  */
4692 rtx
4693 copy_insn (insn)
4694      rtx insn;
4695 {
4696   copy_insn_n_scratches = 0;
4697   orig_asm_operands_vector = 0;
4698   orig_asm_constraints_vector = 0;
4699   copy_asm_operands_vector = 0;
4700   copy_asm_constraints_vector = 0;
4701   return copy_insn_1 (insn);
4702 }
4703
4704 /* Initialize data structures and variables in this file
4705    before generating rtl for each function.  */
4706
4707 void
4708 init_emit ()
4709 {
4710   struct function *f = cfun;
4711
4712   f->emit = (struct emit_status *) xmalloc (sizeof (struct emit_status));
4713   first_insn = NULL;
4714   last_insn = NULL;
4715   seq_rtl_expr = NULL;
4716   cur_insn_uid = 1;
4717   reg_rtx_no = LAST_VIRTUAL_REGISTER + 1;
4718   last_linenum = 0;
4719   last_filename = 0;
4720   first_label_num = label_num;
4721   last_label_num = 0;
4722   seq_stack = NULL;
4723
4724   clear_emit_caches ();
4725
4726   /* Init the tables that describe all the pseudo regs.  */
4727
4728   f->emit->regno_pointer_align_length = LAST_VIRTUAL_REGISTER + 101;
4729
4730   f->emit->regno_pointer_align
4731     = (unsigned char *) xcalloc (f->emit->regno_pointer_align_length,
4732                                  sizeof (unsigned char));
4733
4734   regno_reg_rtx
4735     = (rtx *) xcalloc (f->emit->regno_pointer_align_length, sizeof (rtx));
4736
4737   f->emit->regno_decl
4738     = (tree *) xcalloc (f->emit->regno_pointer_align_length, sizeof (tree));
4739
4740   /* Put copies of all the virtual register rtx into regno_reg_rtx.  */
4741   init_virtual_regs (f->emit);
4742
4743   /* Indicate that the virtual registers and stack locations are
4744      all pointers.  */
4745   REG_POINTER (stack_pointer_rtx) = 1;
4746   REG_POINTER (frame_pointer_rtx) = 1;
4747   REG_POINTER (hard_frame_pointer_rtx) = 1;
4748   REG_POINTER (arg_pointer_rtx) = 1;
4749
4750   REG_POINTER (virtual_incoming_args_rtx) = 1;
4751   REG_POINTER (virtual_stack_vars_rtx) = 1;
4752   REG_POINTER (virtual_stack_dynamic_rtx) = 1;
4753   REG_POINTER (virtual_outgoing_args_rtx) = 1;
4754   REG_POINTER (virtual_cfa_rtx) = 1;
4755
4756 #ifdef STACK_BOUNDARY
4757   REGNO_POINTER_ALIGN (STACK_POINTER_REGNUM) = STACK_BOUNDARY;
4758   REGNO_POINTER_ALIGN (FRAME_POINTER_REGNUM) = STACK_BOUNDARY;
4759   REGNO_POINTER_ALIGN (HARD_FRAME_POINTER_REGNUM) = STACK_BOUNDARY;
4760   REGNO_POINTER_ALIGN (ARG_POINTER_REGNUM) = STACK_BOUNDARY;
4761
4762   REGNO_POINTER_ALIGN (VIRTUAL_INCOMING_ARGS_REGNUM) = STACK_BOUNDARY;
4763   REGNO_POINTER_ALIGN (VIRTUAL_STACK_VARS_REGNUM) = STACK_BOUNDARY;
4764   REGNO_POINTER_ALIGN (VIRTUAL_STACK_DYNAMIC_REGNUM) = STACK_BOUNDARY;
4765   REGNO_POINTER_ALIGN (VIRTUAL_OUTGOING_ARGS_REGNUM) = STACK_BOUNDARY;
4766   REGNO_POINTER_ALIGN (VIRTUAL_CFA_REGNUM) = BITS_PER_WORD;
4767 #endif
4768
4769 #ifdef INIT_EXPANDERS
4770   INIT_EXPANDERS;
4771 #endif
4772 }
4773
4774 /* Mark SS for GC.  */
4775
4776 static void
4777 mark_sequence_stack (ss)
4778      struct sequence_stack *ss;
4779 {
4780   while (ss)
4781     {
4782       ggc_mark_rtx (ss->first);
4783       ggc_mark_tree (ss->sequence_rtl_expr);
4784       ss = ss->next;
4785     }
4786 }
4787
4788 /* Mark ES for GC.  */
4789
4790 void
4791 mark_emit_status (es)
4792      struct emit_status *es;
4793 {
4794   rtx *r;
4795   tree *t;
4796   int i;
4797
4798   if (es == 0)
4799     return;
4800
4801   for (i = es->regno_pointer_align_length, r = es->x_regno_reg_rtx,
4802        t = es->regno_decl;
4803        i > 0; --i, ++r, ++t)
4804     {
4805       ggc_mark_rtx (*r);
4806       ggc_mark_tree (*t);
4807     }
4808
4809   mark_sequence_stack (es->sequence_stack);
4810   ggc_mark_tree (es->sequence_rtl_expr);
4811   ggc_mark_rtx (es->x_first_insn);
4812 }
4813
4814 /* Generate the constant 0.  */
4815
4816 static rtx
4817 gen_const_vector_0 (mode)
4818      enum machine_mode mode;
4819 {
4820   rtx tem;
4821   rtvec v;
4822   int units, i;
4823   enum machine_mode inner;
4824
4825   units = GET_MODE_NUNITS (mode);
4826   inner = GET_MODE_INNER (mode);
4827
4828   v = rtvec_alloc (units);
4829
4830   /* We need to call this function after we to set CONST0_RTX first.  */
4831   if (!CONST0_RTX (inner))
4832     abort ();
4833
4834   for (i = 0; i < units; ++i)
4835     RTVEC_ELT (v, i) = CONST0_RTX (inner);
4836
4837   tem = gen_rtx_CONST_VECTOR (mode, v);
4838   return tem;
4839 }
4840
4841 /* Create some permanent unique rtl objects shared between all functions.
4842    LINE_NUMBERS is nonzero if line numbers are to be generated.  */
4843
4844 void
4845 init_emit_once (line_numbers)
4846      int line_numbers;
4847 {
4848   int i;
4849   enum machine_mode mode;
4850   enum machine_mode double_mode;
4851
4852   /* Initialize the CONST_INT and memory attribute hash tables.  */
4853   const_int_htab = htab_create (37, const_int_htab_hash,
4854                                 const_int_htab_eq, NULL);
4855   ggc_add_deletable_htab (const_int_htab, 0, 0);
4856
4857   mem_attrs_htab = htab_create (37, mem_attrs_htab_hash,
4858                                 mem_attrs_htab_eq, NULL);
4859   ggc_add_deletable_htab (mem_attrs_htab, 0, mem_attrs_mark);
4860
4861   no_line_numbers = ! line_numbers;
4862
4863   /* Compute the word and byte modes.  */
4864
4865   byte_mode = VOIDmode;
4866   word_mode = VOIDmode;
4867   double_mode = VOIDmode;
4868
4869   for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
4870        mode = GET_MODE_WIDER_MODE (mode))
4871     {
4872       if (GET_MODE_BITSIZE (mode) == BITS_PER_UNIT
4873           && byte_mode == VOIDmode)
4874         byte_mode = mode;
4875
4876       if (GET_MODE_BITSIZE (mode) == BITS_PER_WORD
4877           && word_mode == VOIDmode)
4878         word_mode = mode;
4879     }
4880
4881   for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT); mode != VOIDmode;
4882        mode = GET_MODE_WIDER_MODE (mode))
4883     {
4884       if (GET_MODE_BITSIZE (mode) == DOUBLE_TYPE_SIZE
4885           && double_mode == VOIDmode)
4886         double_mode = mode;
4887     }
4888
4889   ptr_mode = mode_for_size (POINTER_SIZE, GET_MODE_CLASS (Pmode), 0);
4890
4891   /* Assign register numbers to the globally defined register rtx.
4892      This must be done at runtime because the register number field
4893      is in a union and some compilers can't initialize unions.  */
4894
4895   pc_rtx = gen_rtx (PC, VOIDmode);
4896   cc0_rtx = gen_rtx (CC0, VOIDmode);
4897   stack_pointer_rtx = gen_raw_REG (Pmode, STACK_POINTER_REGNUM);
4898   frame_pointer_rtx = gen_raw_REG (Pmode, FRAME_POINTER_REGNUM);
4899   if (hard_frame_pointer_rtx == 0)
4900     hard_frame_pointer_rtx = gen_raw_REG (Pmode,
4901                                           HARD_FRAME_POINTER_REGNUM);
4902   if (arg_pointer_rtx == 0)
4903     arg_pointer_rtx = gen_raw_REG (Pmode, ARG_POINTER_REGNUM);
4904   virtual_incoming_args_rtx =
4905     gen_raw_REG (Pmode, VIRTUAL_INCOMING_ARGS_REGNUM);
4906   virtual_stack_vars_rtx =
4907     gen_raw_REG (Pmode, VIRTUAL_STACK_VARS_REGNUM);
4908   virtual_stack_dynamic_rtx =
4909     gen_raw_REG (Pmode, VIRTUAL_STACK_DYNAMIC_REGNUM);
4910   virtual_outgoing_args_rtx =
4911     gen_raw_REG (Pmode, VIRTUAL_OUTGOING_ARGS_REGNUM);
4912   virtual_cfa_rtx = gen_raw_REG (Pmode, VIRTUAL_CFA_REGNUM);
4913
4914   /* These rtx must be roots if GC is enabled.  */
4915   ggc_add_rtx_root (global_rtl, GR_MAX);
4916
4917 #ifdef INIT_EXPANDERS
4918   /* This is to initialize {init|mark|free}_machine_status before the first
4919      call to push_function_context_to.  This is needed by the Chill front
4920      end which calls push_function_context_to before the first call to
4921      init_function_start.  */
4922   INIT_EXPANDERS;
4923 #endif
4924
4925   /* Create the unique rtx's for certain rtx codes and operand values.  */
4926
4927   /* Don't use gen_rtx here since gen_rtx in this case
4928      tries to use these variables.  */
4929   for (i = - MAX_SAVED_CONST_INT; i <= MAX_SAVED_CONST_INT; i++)
4930     const_int_rtx[i + MAX_SAVED_CONST_INT] =
4931       gen_rtx_raw_CONST_INT (VOIDmode, i);
4932   ggc_add_rtx_root (const_int_rtx, 2 * MAX_SAVED_CONST_INT + 1);
4933
4934   if (STORE_FLAG_VALUE >= - MAX_SAVED_CONST_INT
4935       && STORE_FLAG_VALUE <= MAX_SAVED_CONST_INT)
4936     const_true_rtx = const_int_rtx[STORE_FLAG_VALUE + MAX_SAVED_CONST_INT];
4937   else
4938     const_true_rtx = gen_rtx_CONST_INT (VOIDmode, STORE_FLAG_VALUE);
4939
4940   dconst0 = REAL_VALUE_ATOF ("0", double_mode);
4941   dconst1 = REAL_VALUE_ATOF ("1", double_mode);
4942   dconst2 = REAL_VALUE_ATOF ("2", double_mode);
4943   dconstm1 = REAL_VALUE_ATOF ("-1", double_mode);
4944
4945   for (i = 0; i <= 2; i++)
4946     {
4947       REAL_VALUE_TYPE *r =
4948         (i == 0 ? &dconst0 : i == 1 ? &dconst1 : &dconst2);
4949
4950       for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT); mode != VOIDmode;
4951            mode = GET_MODE_WIDER_MODE (mode))
4952         {
4953           rtx tem = rtx_alloc (CONST_DOUBLE);
4954
4955           /* Can't use CONST_DOUBLE_FROM_REAL_VALUE here; that uses the
4956              tables we're setting up right now.  */
4957           memcpy (&CONST_DOUBLE_LOW (tem), r, sizeof (REAL_VALUE_TYPE));
4958           CONST_DOUBLE_CHAIN (tem) = NULL_RTX;
4959           PUT_MODE (tem, mode);
4960
4961           const_tiny_rtx[i][(int) mode] = tem;
4962         }
4963
4964       const_tiny_rtx[i][(int) VOIDmode] = GEN_INT (i);
4965
4966       for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
4967            mode = GET_MODE_WIDER_MODE (mode))
4968         const_tiny_rtx[i][(int) mode] = GEN_INT (i);
4969
4970       for (mode = GET_CLASS_NARROWEST_MODE (MODE_PARTIAL_INT);
4971            mode != VOIDmode;
4972            mode = GET_MODE_WIDER_MODE (mode))
4973         const_tiny_rtx[i][(int) mode] = GEN_INT (i);
4974     }
4975
4976   for (mode = GET_CLASS_NARROWEST_MODE (MODE_VECTOR_INT);
4977        mode != VOIDmode;
4978        mode = GET_MODE_WIDER_MODE (mode))
4979     const_tiny_rtx[0][(int) mode] = gen_const_vector_0 (mode);
4980
4981   for (mode = GET_CLASS_NARROWEST_MODE (MODE_VECTOR_FLOAT);
4982        mode != VOIDmode;
4983        mode = GET_MODE_WIDER_MODE (mode))
4984     const_tiny_rtx[0][(int) mode] = gen_const_vector_0 (mode);
4985
4986   for (i = (int) CCmode; i < (int) MAX_MACHINE_MODE; ++i)
4987     if (GET_MODE_CLASS ((enum machine_mode) i) == MODE_CC)
4988       const_tiny_rtx[0][i] = const0_rtx;
4989
4990   const_tiny_rtx[0][(int) BImode] = const0_rtx;
4991   if (STORE_FLAG_VALUE == 1)
4992     const_tiny_rtx[1][(int) BImode] = const1_rtx;
4993
4994   /* For bounded pointers, `&const_tiny_rtx[0][0]' is not the same as
4995      `(rtx *) const_tiny_rtx'.  The former has bounds that only cover
4996      `const_tiny_rtx[0]', whereas the latter has bounds that cover all.  */
4997   ggc_add_rtx_root ((rtx *) const_tiny_rtx, sizeof const_tiny_rtx / sizeof (rtx));
4998   ggc_add_rtx_root (&const_true_rtx, 1);
4999
5000 #ifdef RETURN_ADDRESS_POINTER_REGNUM
5001   return_address_pointer_rtx
5002     = gen_raw_REG (Pmode, RETURN_ADDRESS_POINTER_REGNUM);
5003 #endif
5004
5005 #ifdef STRUCT_VALUE
5006   struct_value_rtx = STRUCT_VALUE;
5007 #else
5008   struct_value_rtx = gen_rtx_REG (Pmode, STRUCT_VALUE_REGNUM);
5009 #endif
5010
5011 #ifdef STRUCT_VALUE_INCOMING
5012   struct_value_incoming_rtx = STRUCT_VALUE_INCOMING;
5013 #else
5014 #ifdef STRUCT_VALUE_INCOMING_REGNUM
5015   struct_value_incoming_rtx
5016     = gen_rtx_REG (Pmode, STRUCT_VALUE_INCOMING_REGNUM);
5017 #else
5018   struct_value_incoming_rtx = struct_value_rtx;
5019 #endif
5020 #endif
5021
5022 #ifdef STATIC_CHAIN_REGNUM
5023   static_chain_rtx = gen_rtx_REG (Pmode, STATIC_CHAIN_REGNUM);
5024
5025 #ifdef STATIC_CHAIN_INCOMING_REGNUM
5026   if (STATIC_CHAIN_INCOMING_REGNUM != STATIC_CHAIN_REGNUM)
5027     static_chain_incoming_rtx
5028       = gen_rtx_REG (Pmode, STATIC_CHAIN_INCOMING_REGNUM);
5029   else
5030 #endif
5031     static_chain_incoming_rtx = static_chain_rtx;
5032 #endif
5033
5034 #ifdef STATIC_CHAIN
5035   static_chain_rtx = STATIC_CHAIN;
5036
5037 #ifdef STATIC_CHAIN_INCOMING
5038   static_chain_incoming_rtx = STATIC_CHAIN_INCOMING;
5039 #else
5040   static_chain_incoming_rtx = static_chain_rtx;
5041 #endif
5042 #endif
5043
5044   if (PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM)
5045     pic_offset_table_rtx = gen_raw_REG (Pmode, PIC_OFFSET_TABLE_REGNUM);
5046
5047   ggc_add_rtx_root (&pic_offset_table_rtx, 1);
5048   ggc_add_rtx_root (&struct_value_rtx, 1);
5049   ggc_add_rtx_root (&struct_value_incoming_rtx, 1);
5050   ggc_add_rtx_root (&static_chain_rtx, 1);
5051   ggc_add_rtx_root (&static_chain_incoming_rtx, 1);
5052   ggc_add_rtx_root (&return_address_pointer_rtx, 1);
5053 }
5054 \f
5055 /* Query and clear/ restore no_line_numbers.  This is used by the
5056    switch / case handling in stmt.c to give proper line numbers in
5057    warnings about unreachable code.  */
5058
5059 int
5060 force_line_numbers ()
5061 {
5062   int old = no_line_numbers;
5063
5064   no_line_numbers = 0;
5065   if (old)
5066     force_next_line_note ();
5067   return old;
5068 }
5069
5070 void
5071 restore_line_number_status (old_value)
5072      int old_value;
5073 {
5074   no_line_numbers = old_value;
5075 }
5076
5077 /* Produce exact duplicate of insn INSN after AFTER.
5078    Care updating of libcall regions if present.  */
5079
5080 rtx
5081 emit_copy_of_insn_after (insn, after)
5082      rtx insn, after;
5083 {
5084   rtx new;
5085   rtx note1, note2, link;
5086
5087   switch (GET_CODE (insn))
5088     {
5089     case INSN:
5090       new = emit_insn_after (copy_insn (PATTERN (insn)), after);
5091       break;
5092
5093     case JUMP_INSN:
5094       new = emit_jump_insn_after (copy_insn (PATTERN (insn)), after);
5095       break;
5096
5097     case CALL_INSN:
5098       new = emit_call_insn_after (copy_insn (PATTERN (insn)), after);
5099       if (CALL_INSN_FUNCTION_USAGE (insn))
5100         CALL_INSN_FUNCTION_USAGE (new)
5101           = copy_insn (CALL_INSN_FUNCTION_USAGE (insn));
5102       SIBLING_CALL_P (new) = SIBLING_CALL_P (insn);
5103       CONST_OR_PURE_CALL_P (new) = CONST_OR_PURE_CALL_P (insn);
5104       break;
5105
5106     default:
5107       abort ();
5108     }
5109
5110   /* Update LABEL_NUSES.  */
5111   mark_jump_label (PATTERN (new), new, 0);
5112
5113   /* Copy all REG_NOTES except REG_LABEL since mark_jump_label will
5114      make them.  */
5115   for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
5116     if (REG_NOTE_KIND (link) != REG_LABEL)
5117       {
5118         if (GET_CODE (link) == EXPR_LIST)
5119           REG_NOTES (new)
5120             = copy_insn_1 (gen_rtx_EXPR_LIST (REG_NOTE_KIND (link),
5121                                               XEXP (link, 0),
5122                                               REG_NOTES (new)));
5123         else
5124           REG_NOTES (new)
5125             = copy_insn_1 (gen_rtx_INSN_LIST (REG_NOTE_KIND (link),
5126                                               XEXP (link, 0),
5127                                               REG_NOTES (new)));
5128       }
5129
5130   /* Fix the libcall sequences.  */
5131   if ((note1 = find_reg_note (new, REG_RETVAL, NULL_RTX)) != NULL)
5132     {
5133       rtx p = new;
5134       while ((note2 = find_reg_note (p, REG_LIBCALL, NULL_RTX)) == NULL)
5135         p = PREV_INSN (p);
5136       XEXP (note1, 0) = p;
5137       XEXP (note2, 0) = new;
5138     }
5139   return new;
5140 }