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 /* Return offset in bytes to get OUTERMODE low part
1155    of the value in mode INNERMODE stored in memory in target format.  */
1156
1157 unsigned int
1158 subreg_lowpart_offset (outermode, innermode)
1159      enum machine_mode outermode, innermode;
1160 {
1161   unsigned int offset = 0;
1162   int difference = (GET_MODE_SIZE (innermode) - GET_MODE_SIZE (outermode));
1163
1164   if (difference > 0)
1165     {
1166       if (WORDS_BIG_ENDIAN)
1167         offset += (difference / UNITS_PER_WORD) * UNITS_PER_WORD;
1168       if (BYTES_BIG_ENDIAN)
1169         offset += difference % UNITS_PER_WORD;
1170     }
1171
1172   return offset;
1173 }
1174
1175 /* Return offset in bytes to get OUTERMODE high part
1176    of the value in mode INNERMODE stored in memory in target format.  */
1177 unsigned int
1178 subreg_highpart_offset (outermode, innermode)
1179      enum machine_mode outermode, innermode;
1180 {
1181   unsigned int offset = 0;
1182   int difference = (GET_MODE_SIZE (innermode) - GET_MODE_SIZE (outermode));
1183
1184   if (GET_MODE_SIZE (innermode) < GET_MODE_SIZE (outermode))
1185      abort ();
1186
1187   if (difference > 0)
1188     {
1189       if (! WORDS_BIG_ENDIAN)
1190         offset += (difference / UNITS_PER_WORD) * UNITS_PER_WORD;
1191       if (! BYTES_BIG_ENDIAN)
1192         offset += difference % UNITS_PER_WORD;
1193     }
1194
1195   return offset;
1196 }
1197
1198 /* Return 1 iff X, assumed to be a SUBREG,
1199    refers to the least significant part of its containing reg.
1200    If X is not a SUBREG, always return 1 (it is its own low part!).  */
1201
1202 int
1203 subreg_lowpart_p (x)
1204      rtx x;
1205 {
1206   if (GET_CODE (x) != SUBREG)
1207     return 1;
1208   else if (GET_MODE (SUBREG_REG (x)) == VOIDmode)
1209     return 0;
1210
1211   return (subreg_lowpart_offset (GET_MODE (x), GET_MODE (SUBREG_REG (x)))
1212           == SUBREG_BYTE (x));
1213 }
1214 \f
1215
1216 /* Helper routine for all the constant cases of operand_subword.
1217    Some places invoke this directly.  */
1218
1219 rtx
1220 constant_subword (op, offset, mode)
1221      rtx op;
1222      int offset;
1223      enum machine_mode mode;
1224 {
1225   int size_ratio = HOST_BITS_PER_WIDE_INT / BITS_PER_WORD;
1226   HOST_WIDE_INT val;
1227
1228   /* If OP is already an integer word, return it.  */
1229   if (GET_MODE_CLASS (mode) == MODE_INT
1230       && GET_MODE_SIZE (mode) == UNITS_PER_WORD)
1231     return op;
1232
1233   /* The output is some bits, the width of the target machine's word.
1234      A wider-word host can surely hold them in a CONST_INT. A narrower-word
1235      host can't.  */
1236   if (HOST_BITS_PER_WIDE_INT >= BITS_PER_WORD
1237       && GET_MODE_CLASS (mode) == MODE_FLOAT
1238       && GET_MODE_BITSIZE (mode) == 64
1239       && GET_CODE (op) == CONST_DOUBLE)
1240     {
1241       long k[2];
1242       REAL_VALUE_TYPE rv;
1243
1244       REAL_VALUE_FROM_CONST_DOUBLE (rv, op);
1245       REAL_VALUE_TO_TARGET_DOUBLE (rv, k);
1246
1247       /* We handle 32-bit and >= 64-bit words here.  Note that the order in
1248          which the words are written depends on the word endianness.
1249          ??? This is a potential portability problem and should
1250          be fixed at some point.
1251
1252          We must exercise caution with the sign bit.  By definition there
1253          are 32 significant bits in K; there may be more in a HOST_WIDE_INT.
1254          Consider a host with a 32-bit long and a 64-bit HOST_WIDE_INT.
1255          So we explicitly mask and sign-extend as necessary.  */
1256       if (BITS_PER_WORD == 32)
1257         {
1258           val = k[offset];
1259           val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000;
1260           return GEN_INT (val);
1261         }
1262 #if HOST_BITS_PER_WIDE_INT >= 64
1263       else if (BITS_PER_WORD >= 64 && offset == 0)
1264         {
1265           val = k[! WORDS_BIG_ENDIAN];
1266           val = (((val & 0xffffffff) ^ 0x80000000) - 0x80000000) << 32;
1267           val |= (HOST_WIDE_INT) k[WORDS_BIG_ENDIAN] & 0xffffffff;
1268           return GEN_INT (val);
1269         }
1270 #endif
1271       else if (BITS_PER_WORD == 16)
1272         {
1273           val = k[offset >> 1];
1274           if ((offset & 1) == ! WORDS_BIG_ENDIAN)
1275             val >>= 16;
1276           val = ((val & 0xffff) ^ 0x8000) - 0x8000;
1277           return GEN_INT (val);
1278         }
1279       else
1280         abort ();
1281     }
1282   else if (HOST_BITS_PER_WIDE_INT >= BITS_PER_WORD
1283            && GET_MODE_CLASS (mode) == MODE_FLOAT
1284            && GET_MODE_BITSIZE (mode) > 64
1285            && GET_CODE (op) == CONST_DOUBLE)
1286     {
1287       long k[4];
1288       REAL_VALUE_TYPE rv;
1289
1290       REAL_VALUE_FROM_CONST_DOUBLE (rv, op);
1291       REAL_VALUE_TO_TARGET_LONG_DOUBLE (rv, k);
1292
1293       if (BITS_PER_WORD == 32)
1294         {
1295           val = k[offset];
1296           val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000;
1297           return GEN_INT (val);
1298         }
1299 #if HOST_BITS_PER_WIDE_INT >= 64
1300       else if (BITS_PER_WORD >= 64 && offset <= 1)
1301         {
1302           val = k[offset * 2 + ! WORDS_BIG_ENDIAN];
1303           val = (((val & 0xffffffff) ^ 0x80000000) - 0x80000000) << 32;
1304           val |= (HOST_WIDE_INT) k[offset * 2 + WORDS_BIG_ENDIAN] & 0xffffffff;
1305           return GEN_INT (val);
1306         }
1307 #endif
1308       else
1309         abort ();
1310     }
1311
1312   /* Single word float is a little harder, since single- and double-word
1313      values often do not have the same high-order bits.  We have already
1314      verified that we want the only defined word of the single-word value.  */
1315   if (GET_MODE_CLASS (mode) == MODE_FLOAT
1316       && GET_MODE_BITSIZE (mode) == 32
1317       && GET_CODE (op) == CONST_DOUBLE)
1318     {
1319       long l;
1320       REAL_VALUE_TYPE rv;
1321
1322       REAL_VALUE_FROM_CONST_DOUBLE (rv, op);
1323       REAL_VALUE_TO_TARGET_SINGLE (rv, l);
1324
1325       /* Sign extend from known 32-bit value to HOST_WIDE_INT.  */
1326       val = l;
1327       val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000;
1328
1329       if (BITS_PER_WORD == 16)
1330         {
1331           if ((offset & 1) == ! WORDS_BIG_ENDIAN)
1332             val >>= 16;
1333           val = ((val & 0xffff) ^ 0x8000) - 0x8000;
1334         }
1335
1336       return GEN_INT (val);
1337     }
1338
1339   /* The only remaining cases that we can handle are integers.
1340      Convert to proper endianness now since these cases need it.
1341      At this point, offset == 0 means the low-order word.
1342
1343      We do not want to handle the case when BITS_PER_WORD <= HOST_BITS_PER_INT
1344      in general.  However, if OP is (const_int 0), we can just return
1345      it for any word.  */
1346
1347   if (op == const0_rtx)
1348     return op;
1349
1350   if (GET_MODE_CLASS (mode) != MODE_INT
1351       || (GET_CODE (op) != CONST_INT && GET_CODE (op) != CONST_DOUBLE)
1352       || BITS_PER_WORD > HOST_BITS_PER_WIDE_INT)
1353     return 0;
1354
1355   if (WORDS_BIG_ENDIAN)
1356     offset = GET_MODE_SIZE (mode) / UNITS_PER_WORD - 1 - offset;
1357
1358   /* Find out which word on the host machine this value is in and get
1359      it from the constant.  */
1360   val = (offset / size_ratio == 0
1361          ? (GET_CODE (op) == CONST_INT ? INTVAL (op) : CONST_DOUBLE_LOW (op))
1362          : (GET_CODE (op) == CONST_INT
1363             ? (INTVAL (op) < 0 ? ~0 : 0) : CONST_DOUBLE_HIGH (op)));
1364
1365   /* Get the value we want into the low bits of val.  */
1366   if (BITS_PER_WORD < HOST_BITS_PER_WIDE_INT)
1367     val = ((val >> ((offset % size_ratio) * BITS_PER_WORD)));
1368
1369   val = trunc_int_for_mode (val, word_mode);
1370
1371   return GEN_INT (val);
1372 }
1373
1374 /* Return subword OFFSET of operand OP.
1375    The word number, OFFSET, is interpreted as the word number starting
1376    at the low-order address.  OFFSET 0 is the low-order word if not
1377    WORDS_BIG_ENDIAN, otherwise it is the high-order word.
1378
1379    If we cannot extract the required word, we return zero.  Otherwise,
1380    an rtx corresponding to the requested word will be returned.
1381
1382    VALIDATE_ADDRESS is nonzero if the address should be validated.  Before
1383    reload has completed, a valid address will always be returned.  After
1384    reload, if a valid address cannot be returned, we return zero.
1385
1386    If VALIDATE_ADDRESS is zero, we simply form the required address; validating
1387    it is the responsibility of the caller.
1388
1389    MODE is the mode of OP in case it is a CONST_INT.
1390
1391    ??? This is still rather broken for some cases.  The problem for the
1392    moment is that all callers of this thing provide no 'goal mode' to
1393    tell us to work with.  This exists because all callers were written
1394    in a word based SUBREG world.
1395    Now use of this function can be deprecated by simplify_subreg in most
1396    cases.
1397  */
1398
1399 rtx
1400 operand_subword (op, offset, validate_address, mode)
1401      rtx op;
1402      unsigned int offset;
1403      int validate_address;
1404      enum machine_mode mode;
1405 {
1406   if (mode == VOIDmode)
1407     mode = GET_MODE (op);
1408
1409   if (mode == VOIDmode)
1410     abort ();
1411
1412   /* If OP is narrower than a word, fail.  */
1413   if (mode != BLKmode
1414       && (GET_MODE_SIZE (mode) < UNITS_PER_WORD))
1415     return 0;
1416
1417   /* If we want a word outside OP, return zero.  */
1418   if (mode != BLKmode
1419       && (offset + 1) * UNITS_PER_WORD > GET_MODE_SIZE (mode))
1420     return const0_rtx;
1421
1422   /* Form a new MEM at the requested address.  */
1423   if (GET_CODE (op) == MEM)
1424     {
1425       rtx new = adjust_address_nv (op, word_mode, offset * UNITS_PER_WORD);
1426
1427       if (! validate_address)
1428         return new;
1429
1430       else if (reload_completed)
1431         {
1432           if (! strict_memory_address_p (word_mode, XEXP (new, 0)))
1433             return 0;
1434         }
1435       else
1436         return replace_equiv_address (new, XEXP (new, 0));
1437     }
1438
1439   /* Rest can be handled by simplify_subreg.  */
1440   return simplify_gen_subreg (word_mode, op, mode, (offset * UNITS_PER_WORD));
1441 }
1442
1443 /* Similar to `operand_subword', but never return 0.  If we can't extract
1444    the required subword, put OP into a register and try again.  If that fails,
1445    abort.  We always validate the address in this case.
1446
1447    MODE is the mode of OP, in case it is CONST_INT.  */
1448
1449 rtx
1450 operand_subword_force (op, offset, mode)
1451      rtx op;
1452      unsigned int offset;
1453      enum machine_mode mode;
1454 {
1455   rtx result = operand_subword (op, offset, 1, mode);
1456
1457   if (result)
1458     return result;
1459
1460   if (mode != BLKmode && mode != VOIDmode)
1461     {
1462       /* If this is a register which can not be accessed by words, copy it
1463          to a pseudo register.  */
1464       if (GET_CODE (op) == REG)
1465         op = copy_to_reg (op);
1466       else
1467         op = force_reg (mode, op);
1468     }
1469
1470   result = operand_subword (op, offset, 1, mode);
1471   if (result == 0)
1472     abort ();
1473
1474   return result;
1475 }
1476 \f
1477 /* Given a compare instruction, swap the operands.
1478    A test instruction is changed into a compare of 0 against the operand.  */
1479
1480 void
1481 reverse_comparison (insn)
1482      rtx insn;
1483 {
1484   rtx body = PATTERN (insn);
1485   rtx comp;
1486
1487   if (GET_CODE (body) == SET)
1488     comp = SET_SRC (body);
1489   else
1490     comp = SET_SRC (XVECEXP (body, 0, 0));
1491
1492   if (GET_CODE (comp) == COMPARE)
1493     {
1494       rtx op0 = XEXP (comp, 0);
1495       rtx op1 = XEXP (comp, 1);
1496       XEXP (comp, 0) = op1;
1497       XEXP (comp, 1) = op0;
1498     }
1499   else
1500     {
1501       rtx new = gen_rtx_COMPARE (VOIDmode,
1502                                  CONST0_RTX (GET_MODE (comp)), comp);
1503       if (GET_CODE (body) == SET)
1504         SET_SRC (body) = new;
1505       else
1506         SET_SRC (XVECEXP (body, 0, 0)) = new;
1507     }
1508 }
1509 \f
1510 /* Within a MEM_EXPR, we care about either (1) a component ref of a decl,
1511    or (2) a component ref of something variable.  Represent the later with
1512    a NULL expression.  */
1513
1514 static tree
1515 component_ref_for_mem_expr (ref)
1516      tree ref;
1517 {
1518   tree inner = TREE_OPERAND (ref, 0);
1519
1520   if (TREE_CODE (inner) == COMPONENT_REF)
1521     inner = component_ref_for_mem_expr (inner);
1522   else
1523     {
1524       tree placeholder_ptr = 0;
1525
1526       /* Now remove any conversions: they don't change what the underlying
1527          object is.  Likewise for SAVE_EXPR.  Also handle PLACEHOLDER_EXPR.  */
1528       while (TREE_CODE (inner) == NOP_EXPR || TREE_CODE (inner) == CONVERT_EXPR
1529              || TREE_CODE (inner) == NON_LVALUE_EXPR
1530              || TREE_CODE (inner) == VIEW_CONVERT_EXPR
1531              || TREE_CODE (inner) == SAVE_EXPR
1532              || TREE_CODE (inner) == PLACEHOLDER_EXPR)
1533           if (TREE_CODE (inner) == PLACEHOLDER_EXPR)
1534             inner = find_placeholder (inner, &placeholder_ptr);
1535           else
1536             inner = TREE_OPERAND (inner, 0);
1537
1538       if (! DECL_P (inner))
1539         inner = NULL_TREE;
1540     }
1541
1542   if (inner == TREE_OPERAND (ref, 0))
1543     return ref;
1544   else
1545     return build (COMPONENT_REF, TREE_TYPE (ref), inner,
1546                   TREE_OPERAND (ref, 1));
1547 }
1548
1549 /* Given REF, a MEM, and T, either the type of X or the expression
1550    corresponding to REF, set the memory attributes.  OBJECTP is nonzero
1551    if we are making a new object of this type.  */
1552
1553 void
1554 set_mem_attributes (ref, t, objectp)
1555      rtx ref;
1556      tree t;
1557      int objectp;
1558 {
1559   HOST_WIDE_INT alias = MEM_ALIAS_SET (ref);
1560   tree expr = MEM_EXPR (ref);
1561   rtx offset = MEM_OFFSET (ref);
1562   rtx size = MEM_SIZE (ref);
1563   unsigned int align = MEM_ALIGN (ref);
1564   tree type;
1565
1566   /* It can happen that type_for_mode was given a mode for which there
1567      is no language-level type.  In which case it returns NULL, which
1568      we can see here.  */
1569   if (t == NULL_TREE)
1570     return;
1571
1572   type = TYPE_P (t) ? t : TREE_TYPE (t);
1573
1574   /* If we have already set DECL_RTL = ref, get_alias_set will get the
1575      wrong answer, as it assumes that DECL_RTL already has the right alias
1576      info.  Callers should not set DECL_RTL until after the call to
1577      set_mem_attributes.  */
1578   if (DECL_P (t) && ref == DECL_RTL_IF_SET (t))
1579     abort ();
1580
1581   /* Get the alias set from the expression or type (perhaps using a
1582      front-end routine) and use it.  */
1583   alias = get_alias_set (t);
1584
1585   MEM_VOLATILE_P (ref) = TYPE_VOLATILE (type);
1586   MEM_IN_STRUCT_P (ref) = AGGREGATE_TYPE_P (type);
1587   RTX_UNCHANGING_P (ref)
1588     |= ((lang_hooks.honor_readonly
1589          && (TYPE_READONLY (type) || TREE_READONLY (t)))
1590         || (! TYPE_P (t) && TREE_CONSTANT (t)));
1591
1592   /* If we are making an object of this type, or if this is a DECL, we know
1593      that it is a scalar if the type is not an aggregate.  */
1594   if ((objectp || DECL_P (t)) && ! AGGREGATE_TYPE_P (type))
1595     MEM_SCALAR_P (ref) = 1;
1596
1597   /* We can set the alignment from the type if we are making an object,
1598      this is an INDIRECT_REF, or if TYPE_ALIGN_OK.  */
1599   if (objectp || TREE_CODE (t) == INDIRECT_REF || TYPE_ALIGN_OK (type))
1600     align = MAX (align, TYPE_ALIGN (type));
1601
1602   /* If the size is known, we can set that.  */
1603   if (TYPE_SIZE_UNIT (type) && host_integerp (TYPE_SIZE_UNIT (type), 1))
1604     size = GEN_INT (tree_low_cst (TYPE_SIZE_UNIT (type), 1));
1605
1606   /* If T is not a type, we may be able to deduce some more information about
1607      the expression.  */
1608   if (! TYPE_P (t))
1609     {
1610       maybe_set_unchanging (ref, t);
1611       if (TREE_THIS_VOLATILE (t))
1612         MEM_VOLATILE_P (ref) = 1;
1613
1614       /* Now remove any conversions: they don't change what the underlying
1615          object is.  Likewise for SAVE_EXPR.  */
1616       while (TREE_CODE (t) == NOP_EXPR || TREE_CODE (t) == CONVERT_EXPR
1617              || TREE_CODE (t) == NON_LVALUE_EXPR
1618              || TREE_CODE (t) == VIEW_CONVERT_EXPR
1619              || TREE_CODE (t) == SAVE_EXPR)
1620         t = TREE_OPERAND (t, 0);
1621
1622       /* If this expression can't be addressed (e.g., it contains a reference
1623          to a non-addressable field), show we don't change its alias set.  */
1624       if (! can_address_p (t))
1625         MEM_KEEP_ALIAS_SET_P (ref) = 1;
1626
1627       /* If this is a decl, set the attributes of the MEM from it.  */
1628       if (DECL_P (t))
1629         {
1630           expr = t;
1631           offset = const0_rtx;
1632           size = (DECL_SIZE_UNIT (t)
1633                   && host_integerp (DECL_SIZE_UNIT (t), 1)
1634                   ? GEN_INT (tree_low_cst (DECL_SIZE_UNIT (t), 1)) : 0);
1635           align =  DECL_ALIGN (t);
1636         }
1637
1638       /* If this is a constant, we know the alignment.  */
1639       else if (TREE_CODE_CLASS (TREE_CODE (t)) == 'c')
1640         {
1641           align = TYPE_ALIGN (type);
1642 #ifdef CONSTANT_ALIGNMENT
1643           align = CONSTANT_ALIGNMENT (t, align);
1644 #endif
1645         }
1646
1647       /* If this is a field reference and not a bit-field, record it.  */
1648       /* ??? There is some information that can be gleened from bit-fields,
1649          such as the word offset in the structure that might be modified.
1650          But skip it for now.  */
1651       else if (TREE_CODE (t) == COMPONENT_REF
1652                && ! DECL_BIT_FIELD (TREE_OPERAND (t, 1)))
1653         {
1654           expr = component_ref_for_mem_expr (t);
1655           offset = const0_rtx;
1656           /* ??? Any reason the field size would be different than
1657              the size we got from the type?  */
1658         }
1659
1660       /* If this is an array reference, look for an outer field reference.  */
1661       else if (TREE_CODE (t) == ARRAY_REF)
1662         {
1663           tree off_tree = size_zero_node;
1664
1665           do
1666             {
1667               off_tree
1668                 = fold (build (PLUS_EXPR, sizetype,
1669                                fold (build (MULT_EXPR, sizetype,
1670                                             TREE_OPERAND (t, 1),
1671                                             TYPE_SIZE_UNIT (TREE_TYPE (t)))),
1672                                off_tree));
1673               t = TREE_OPERAND (t, 0);
1674             }
1675           while (TREE_CODE (t) == ARRAY_REF);
1676
1677           if (TREE_CODE (t) == COMPONENT_REF)
1678             {
1679               expr = component_ref_for_mem_expr (t);
1680               if (host_integerp (off_tree, 1))
1681                 offset = GEN_INT (tree_low_cst (off_tree, 1));
1682               /* ??? Any reason the field size would be different than
1683                  the size we got from the type?  */
1684             }
1685         }
1686     }
1687
1688   /* Now set the attributes we computed above.  */
1689   MEM_ATTRS (ref)
1690     = get_mem_attrs (alias, expr, offset, size, align, GET_MODE (ref));
1691
1692   /* If this is already known to be a scalar or aggregate, we are done.  */
1693   if (MEM_IN_STRUCT_P (ref) || MEM_SCALAR_P (ref))
1694     return;
1695
1696   /* If it is a reference into an aggregate, this is part of an aggregate.
1697      Otherwise we don't know.  */
1698   else if (TREE_CODE (t) == COMPONENT_REF || TREE_CODE (t) == ARRAY_REF
1699            || TREE_CODE (t) == ARRAY_RANGE_REF
1700            || TREE_CODE (t) == BIT_FIELD_REF)
1701     MEM_IN_STRUCT_P (ref) = 1;
1702 }
1703
1704 /* Set the alias set of MEM to SET.  */
1705
1706 void
1707 set_mem_alias_set (mem, set)
1708      rtx mem;
1709      HOST_WIDE_INT set;
1710 {
1711 #ifdef ENABLE_CHECKING
1712   /* If the new and old alias sets don't conflict, something is wrong.  */
1713   if (!alias_sets_conflict_p (set, MEM_ALIAS_SET (mem)))
1714     abort ();
1715 #endif
1716
1717   MEM_ATTRS (mem) = get_mem_attrs (set, MEM_EXPR (mem), MEM_OFFSET (mem),
1718                                    MEM_SIZE (mem), MEM_ALIGN (mem),
1719                                    GET_MODE (mem));
1720 }
1721
1722 /* Set the alignment of MEM to ALIGN bits.  */
1723
1724 void
1725 set_mem_align (mem, align)
1726      rtx mem;
1727      unsigned int align;
1728 {
1729   MEM_ATTRS (mem) = get_mem_attrs (MEM_ALIAS_SET (mem), MEM_EXPR (mem),
1730                                    MEM_OFFSET (mem), MEM_SIZE (mem), align,
1731                                    GET_MODE (mem));
1732 }
1733
1734 /* Set the expr for MEM to EXPR.  */
1735
1736 void
1737 set_mem_expr (mem, expr)
1738      rtx mem;
1739      tree expr;
1740 {
1741   MEM_ATTRS (mem)
1742     = get_mem_attrs (MEM_ALIAS_SET (mem), expr, MEM_OFFSET (mem),
1743                      MEM_SIZE (mem), MEM_ALIGN (mem), GET_MODE (mem));
1744 }
1745
1746 /* Set the offset of MEM to OFFSET.  */
1747
1748 void
1749 set_mem_offset (mem, offset)
1750      rtx mem, offset;
1751 {
1752   MEM_ATTRS (mem) = get_mem_attrs (MEM_ALIAS_SET (mem), MEM_EXPR (mem),
1753                                    offset, MEM_SIZE (mem), MEM_ALIGN (mem),
1754                                    GET_MODE (mem));
1755 }
1756 \f
1757 /* Return a memory reference like MEMREF, but with its mode changed to MODE
1758    and its address changed to ADDR.  (VOIDmode means don't change the mode.
1759    NULL for ADDR means don't change the address.)  VALIDATE is nonzero if the
1760    returned memory location is required to be valid.  The memory
1761    attributes are not changed.  */
1762
1763 static rtx
1764 change_address_1 (memref, mode, addr, validate)
1765      rtx memref;
1766      enum machine_mode mode;
1767      rtx addr;
1768      int validate;
1769 {
1770   rtx new;
1771
1772   if (GET_CODE (memref) != MEM)
1773     abort ();
1774   if (mode == VOIDmode)
1775     mode = GET_MODE (memref);
1776   if (addr == 0)
1777     addr = XEXP (memref, 0);
1778
1779   if (validate)
1780     {
1781       if (reload_in_progress || reload_completed)
1782         {
1783           if (! memory_address_p (mode, addr))
1784             abort ();
1785         }
1786       else
1787         addr = memory_address (mode, addr);
1788     }
1789
1790   if (rtx_equal_p (addr, XEXP (memref, 0)) && mode == GET_MODE (memref))
1791     return memref;
1792
1793   new = gen_rtx_MEM (mode, addr);
1794   MEM_COPY_ATTRIBUTES (new, memref);
1795   return new;
1796 }
1797
1798 /* Like change_address_1 with VALIDATE nonzero, but we are not saying in what
1799    way we are changing MEMREF, so we only preserve the alias set.  */
1800
1801 rtx
1802 change_address (memref, mode, addr)
1803      rtx memref;
1804      enum machine_mode mode;
1805      rtx addr;
1806 {
1807   rtx new = change_address_1 (memref, mode, addr, 1);
1808   enum machine_mode mmode = GET_MODE (new);
1809
1810   MEM_ATTRS (new)
1811     = get_mem_attrs (MEM_ALIAS_SET (memref), 0, 0,
1812                      mmode == BLKmode ? 0 : GEN_INT (GET_MODE_SIZE (mmode)),
1813                      (mmode == BLKmode ? BITS_PER_UNIT
1814                       : GET_MODE_ALIGNMENT (mmode)),
1815                      mmode);
1816
1817   return new;
1818 }
1819
1820 /* Return a memory reference like MEMREF, but with its mode changed
1821    to MODE and its address offset by OFFSET bytes.  If VALIDATE is
1822    nonzero, the memory address is forced to be valid.
1823    If ADJUST is zero, OFFSET is only used to update MEM_ATTRS
1824    and caller is responsible for adjusting MEMREF base register.  */
1825
1826 rtx
1827 adjust_address_1 (memref, mode, offset, validate, adjust)
1828      rtx memref;
1829      enum machine_mode mode;
1830      HOST_WIDE_INT offset;
1831      int validate, adjust;
1832 {
1833   rtx addr = XEXP (memref, 0);
1834   rtx new;
1835   rtx memoffset = MEM_OFFSET (memref);
1836   rtx size = 0;
1837   unsigned int memalign = MEM_ALIGN (memref);
1838
1839   /* ??? Prefer to create garbage instead of creating shared rtl.
1840      This may happen even if offset is non-zero -- consider
1841      (plus (plus reg reg) const_int) -- so do this always.  */
1842   addr = copy_rtx (addr);
1843
1844   if (adjust)
1845     {
1846       /* If MEMREF is a LO_SUM and the offset is within the alignment of the
1847          object, we can merge it into the LO_SUM.  */
1848       if (GET_MODE (memref) != BLKmode && GET_CODE (addr) == LO_SUM
1849           && offset >= 0
1850           && (unsigned HOST_WIDE_INT) offset
1851               < GET_MODE_ALIGNMENT (GET_MODE (memref)) / BITS_PER_UNIT)
1852         addr = gen_rtx_LO_SUM (Pmode, XEXP (addr, 0),
1853                                plus_constant (XEXP (addr, 1), offset));
1854       else
1855         addr = plus_constant (addr, offset);
1856     }
1857
1858   new = change_address_1 (memref, mode, addr, validate);
1859
1860   /* Compute the new values of the memory attributes due to this adjustment.
1861      We add the offsets and update the alignment.  */
1862   if (memoffset)
1863     memoffset = GEN_INT (offset + INTVAL (memoffset));
1864
1865   /* Compute the new alignment by taking the MIN of the alignment and the
1866      lowest-order set bit in OFFSET, but don't change the alignment if OFFSET
1867      if zero.  */
1868   if (offset != 0)
1869     memalign = MIN (memalign,
1870                     (unsigned int) (offset & -offset) * BITS_PER_UNIT);
1871
1872   /* We can compute the size in a number of ways.  */
1873   if (GET_MODE (new) != BLKmode)
1874     size = GEN_INT (GET_MODE_SIZE (GET_MODE (new)));
1875   else if (MEM_SIZE (memref))
1876     size = plus_constant (MEM_SIZE (memref), -offset);
1877
1878   MEM_ATTRS (new) = get_mem_attrs (MEM_ALIAS_SET (memref), MEM_EXPR (memref),
1879                                    memoffset, size, memalign, GET_MODE (new));
1880
1881   /* At some point, we should validate that this offset is within the object,
1882      if all the appropriate values are known.  */
1883   return new;
1884 }
1885
1886 /* Return a memory reference like MEMREF, but with its mode changed
1887    to MODE and its address changed to ADDR, which is assumed to be
1888    MEMREF offseted by OFFSET bytes.  If VALIDATE is
1889    nonzero, the memory address is forced to be valid.  */
1890
1891 rtx
1892 adjust_automodify_address_1 (memref, mode, addr, offset, validate)
1893      rtx memref;
1894      enum machine_mode mode;
1895      rtx addr;
1896      HOST_WIDE_INT offset;
1897      int validate;
1898 {
1899   memref = change_address_1 (memref, VOIDmode, addr, validate);
1900   return adjust_address_1 (memref, mode, offset, validate, 0);
1901 }
1902
1903 /* Return a memory reference like MEMREF, but whose address is changed by
1904    adding OFFSET, an RTX, to it.  POW2 is the highest power of two factor
1905    known to be in OFFSET (possibly 1).  */
1906
1907 rtx
1908 offset_address (memref, offset, pow2)
1909      rtx memref;
1910      rtx offset;
1911      HOST_WIDE_INT pow2;
1912 {
1913   rtx new, addr = XEXP (memref, 0);
1914
1915   new = simplify_gen_binary (PLUS, Pmode, addr, offset);
1916
1917   /* At this point we don't know _why_ the address is invalid.  It
1918      could have secondary memory refereces, multiplies or anything.
1919
1920      However, if we did go and rearrange things, we can wind up not
1921      being able to recognize the magic around pic_offset_table_rtx.
1922      This stuff is fragile, and is yet another example of why it is
1923      bad to expose PIC machinery too early.  */
1924   if (! memory_address_p (GET_MODE (memref), new)
1925       && GET_CODE (addr) == PLUS
1926       && XEXP (addr, 0) == pic_offset_table_rtx)
1927     {
1928       addr = force_reg (GET_MODE (addr), addr);
1929       new = simplify_gen_binary (PLUS, Pmode, addr, offset);
1930     }
1931
1932   update_temp_slot_address (XEXP (memref, 0), new);
1933   new = change_address_1 (memref, VOIDmode, new, 1);
1934
1935   /* Update the alignment to reflect the offset.  Reset the offset, which
1936      we don't know.  */
1937   MEM_ATTRS (new)
1938     = get_mem_attrs (MEM_ALIAS_SET (memref), MEM_EXPR (memref), 0, 0,
1939                      MIN (MEM_ALIGN (memref),
1940                           (unsigned int) pow2 * BITS_PER_UNIT),
1941                      GET_MODE (new));
1942   return new;
1943 }
1944
1945 /* Return a memory reference like MEMREF, but with its address changed to
1946    ADDR.  The caller is asserting that the actual piece of memory pointed
1947    to is the same, just the form of the address is being changed, such as
1948    by putting something into a register.  */
1949
1950 rtx
1951 replace_equiv_address (memref, addr)
1952      rtx memref;
1953      rtx addr;
1954 {
1955   /* change_address_1 copies the memory attribute structure without change
1956      and that's exactly what we want here.  */
1957   update_temp_slot_address (XEXP (memref, 0), addr);
1958   return change_address_1 (memref, VOIDmode, addr, 1);
1959 }
1960
1961 /* Likewise, but the reference is not required to be valid.  */
1962
1963 rtx
1964 replace_equiv_address_nv (memref, addr)
1965      rtx memref;
1966      rtx addr;
1967 {
1968   return change_address_1 (memref, VOIDmode, addr, 0);
1969 }
1970
1971 /* Return a memory reference like MEMREF, but with its mode widened to
1972    MODE and offset by OFFSET.  This would be used by targets that e.g.
1973    cannot issue QImode memory operations and have to use SImode memory
1974    operations plus masking logic.  */
1975
1976 rtx
1977 widen_memory_access (memref, mode, offset)
1978      rtx memref;
1979      enum machine_mode mode;
1980      HOST_WIDE_INT offset;
1981 {
1982   rtx new = adjust_address_1 (memref, mode, offset, 1, 1);
1983   tree expr = MEM_EXPR (new);
1984   rtx memoffset = MEM_OFFSET (new);
1985   unsigned int size = GET_MODE_SIZE (mode);
1986
1987   /* If we don't know what offset we were at within the expression, then
1988      we can't know if we've overstepped the bounds.  */
1989   if (! memoffset && offset != 0)
1990     expr = NULL_TREE;
1991
1992   while (expr)
1993     {
1994       if (TREE_CODE (expr) == COMPONENT_REF)
1995         {
1996           tree field = TREE_OPERAND (expr, 1);
1997
1998           if (! DECL_SIZE_UNIT (field))
1999             {
2000               expr = NULL_TREE;
2001               break;
2002             }
2003
2004           /* Is the field at least as large as the access?  If so, ok,
2005              otherwise strip back to the containing structure.  */
2006           if (TREE_CODE (DECL_SIZE_UNIT (field)) == INTEGER_CST
2007               && compare_tree_int (DECL_SIZE_UNIT (field), size) >= 0
2008               && INTVAL (memoffset) >= 0)
2009             break;
2010
2011           if (! host_integerp (DECL_FIELD_OFFSET (field), 1))
2012             {
2013               expr = NULL_TREE;
2014               break;
2015             }
2016
2017           expr = TREE_OPERAND (expr, 0);
2018           memoffset = (GEN_INT (INTVAL (memoffset)
2019                        + tree_low_cst (DECL_FIELD_OFFSET (field), 1)
2020                        + (tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
2021                           / BITS_PER_UNIT)));
2022         }
2023       /* Similarly for the decl.  */
2024       else if (DECL_P (expr)
2025                && DECL_SIZE_UNIT (expr)
2026                && compare_tree_int (DECL_SIZE_UNIT (expr), size) >= 0
2027                && (! memoffset || INTVAL (memoffset) >= 0))
2028         break;
2029       else
2030         {
2031           /* The widened memory access overflows the expression, which means
2032              that it could alias another expression.  Zap it.  */
2033           expr = NULL_TREE;
2034           break;
2035         }
2036     }
2037
2038   if (! expr)
2039     memoffset = NULL_RTX;
2040
2041   /* The widened memory may alias other stuff, so zap the alias set.  */
2042   /* ??? Maybe use get_alias_set on any remaining expression.  */
2043
2044   MEM_ATTRS (new) = get_mem_attrs (0, expr, memoffset, GEN_INT (size),
2045                                    MEM_ALIGN (new), mode);
2046
2047   return new;
2048 }
2049 \f
2050 /* Return a newly created CODE_LABEL rtx with a unique label number.  */
2051
2052 rtx
2053 gen_label_rtx ()
2054 {
2055   rtx label;
2056
2057   label = gen_rtx_CODE_LABEL (VOIDmode, 0, NULL_RTX,
2058                               NULL_RTX, label_num++, NULL, NULL);
2059
2060   LABEL_NUSES (label) = 0;
2061   LABEL_ALTERNATE_NAME (label) = NULL;
2062   return label;
2063 }
2064 \f
2065 /* For procedure integration.  */
2066
2067 /* Install new pointers to the first and last insns in the chain.
2068    Also, set cur_insn_uid to one higher than the last in use.
2069    Used for an inline-procedure after copying the insn chain.  */
2070
2071 void
2072 set_new_first_and_last_insn (first, last)
2073      rtx first, last;
2074 {
2075   rtx insn;
2076
2077   first_insn = first;
2078   last_insn = last;
2079   cur_insn_uid = 0;
2080
2081   for (insn = first; insn; insn = NEXT_INSN (insn))
2082     cur_insn_uid = MAX (cur_insn_uid, INSN_UID (insn));
2083
2084   cur_insn_uid++;
2085 }
2086
2087 /* Set the range of label numbers found in the current function.
2088    This is used when belatedly compiling an inline function.  */
2089
2090 void
2091 set_new_first_and_last_label_num (first, last)
2092      int first, last;
2093 {
2094   base_label_num = label_num;
2095   first_label_num = first;
2096   last_label_num = last;
2097 }
2098
2099 /* Set the last label number found in the current function.
2100    This is used when belatedly compiling an inline function.  */
2101
2102 void
2103 set_new_last_label_num (last)
2104      int last;
2105 {
2106   base_label_num = label_num;
2107   last_label_num = last;
2108 }
2109 \f
2110 /* Restore all variables describing the current status from the structure *P.
2111    This is used after a nested function.  */
2112
2113 void
2114 restore_emit_status (p)
2115      struct function *p ATTRIBUTE_UNUSED;
2116 {
2117   last_label_num = 0;
2118   clear_emit_caches ();
2119 }
2120
2121 /* Clear out all parts of the state in F that can safely be discarded
2122    after the function has been compiled, to let garbage collection
2123    reclaim the memory.  */
2124
2125 void
2126 free_emit_status (f)
2127      struct function *f;
2128 {
2129   free (f->emit->x_regno_reg_rtx);
2130   free (f->emit->regno_pointer_align);
2131   free (f->emit->regno_decl);
2132   free (f->emit);
2133   f->emit = NULL;
2134 }
2135 \f
2136 /* Go through all the RTL insn bodies and copy any invalid shared
2137    structure.  This routine should only be called once.  */
2138
2139 void
2140 unshare_all_rtl (fndecl, insn)
2141      tree fndecl;
2142      rtx insn;
2143 {
2144   tree decl;
2145
2146   /* Make sure that virtual parameters are not shared.  */
2147   for (decl = DECL_ARGUMENTS (fndecl); decl; decl = TREE_CHAIN (decl))
2148     SET_DECL_RTL (decl, copy_rtx_if_shared (DECL_RTL (decl)));
2149
2150   /* Make sure that virtual stack slots are not shared.  */
2151   unshare_all_decls (DECL_INITIAL (fndecl));
2152
2153   /* Unshare just about everything else.  */
2154   unshare_all_rtl_1 (insn);
2155
2156   /* Make sure the addresses of stack slots found outside the insn chain
2157      (such as, in DECL_RTL of a variable) are not shared
2158      with the insn chain.
2159
2160      This special care is necessary when the stack slot MEM does not
2161      actually appear in the insn chain.  If it does appear, its address
2162      is unshared from all else at that point.  */
2163   stack_slot_list = copy_rtx_if_shared (stack_slot_list);
2164 }
2165
2166 /* Go through all the RTL insn bodies and copy any invalid shared
2167    structure, again.  This is a fairly expensive thing to do so it
2168    should be done sparingly.  */
2169
2170 void
2171 unshare_all_rtl_again (insn)
2172      rtx insn;
2173 {
2174   rtx p;
2175   tree decl;
2176
2177   for (p = insn; p; p = NEXT_INSN (p))
2178     if (INSN_P (p))
2179       {
2180         reset_used_flags (PATTERN (p));
2181         reset_used_flags (REG_NOTES (p));
2182         reset_used_flags (LOG_LINKS (p));
2183       }
2184
2185   /* Make sure that virtual stack slots are not shared.  */
2186   reset_used_decls (DECL_INITIAL (cfun->decl));
2187
2188   /* Make sure that virtual parameters are not shared.  */
2189   for (decl = DECL_ARGUMENTS (cfun->decl); decl; decl = TREE_CHAIN (decl))
2190     reset_used_flags (DECL_RTL (decl));
2191
2192   reset_used_flags (stack_slot_list);
2193
2194   unshare_all_rtl (cfun->decl, insn);
2195 }
2196
2197 /* Go through all the RTL insn bodies and copy any invalid shared structure.
2198    Assumes the mark bits are cleared at entry.  */
2199
2200 static void
2201 unshare_all_rtl_1 (insn)
2202      rtx insn;
2203 {
2204   for (; insn; insn = NEXT_INSN (insn))
2205     if (INSN_P (insn))
2206       {
2207         PATTERN (insn) = copy_rtx_if_shared (PATTERN (insn));
2208         REG_NOTES (insn) = copy_rtx_if_shared (REG_NOTES (insn));
2209         LOG_LINKS (insn) = copy_rtx_if_shared (LOG_LINKS (insn));
2210       }
2211 }
2212
2213 /* Go through all virtual stack slots of a function and copy any
2214    shared structure.  */
2215 static void
2216 unshare_all_decls (blk)
2217      tree blk;
2218 {
2219   tree t;
2220
2221   /* Copy shared decls.  */
2222   for (t = BLOCK_VARS (blk); t; t = TREE_CHAIN (t))
2223     if (DECL_RTL_SET_P (t))
2224       SET_DECL_RTL (t, copy_rtx_if_shared (DECL_RTL (t)));
2225
2226   /* Now process sub-blocks.  */
2227   for (t = BLOCK_SUBBLOCKS (blk); t; t = TREE_CHAIN (t))
2228     unshare_all_decls (t);
2229 }
2230
2231 /* Go through all virtual stack slots of a function and mark them as
2232    not shared.  */
2233 static void
2234 reset_used_decls (blk)
2235      tree blk;
2236 {
2237   tree t;
2238
2239   /* Mark decls.  */
2240   for (t = BLOCK_VARS (blk); t; t = TREE_CHAIN (t))
2241     if (DECL_RTL_SET_P (t))
2242       reset_used_flags (DECL_RTL (t));
2243
2244   /* Now process sub-blocks.  */
2245   for (t = BLOCK_SUBBLOCKS (blk); t; t = TREE_CHAIN (t))
2246     reset_used_decls (t);
2247 }
2248
2249 /* Similar to `copy_rtx' except that if MAY_SHARE is present, it is
2250    placed in the result directly, rather than being copied.  MAY_SHARE is
2251    either a MEM of an EXPR_LIST of MEMs.  */
2252
2253 rtx
2254 copy_most_rtx (orig, may_share)
2255      rtx orig;
2256      rtx may_share;
2257 {
2258   rtx copy;
2259   int i, j;
2260   RTX_CODE code;
2261   const char *format_ptr;
2262
2263   if (orig == may_share
2264       || (GET_CODE (may_share) == EXPR_LIST
2265           && in_expr_list_p (may_share, orig)))
2266     return orig;
2267
2268   code = GET_CODE (orig);
2269
2270   switch (code)
2271     {
2272     case REG:
2273     case QUEUED:
2274     case CONST_INT:
2275     case CONST_DOUBLE:
2276     case CONST_VECTOR:
2277     case SYMBOL_REF:
2278     case CODE_LABEL:
2279     case PC:
2280     case CC0:
2281       return orig;
2282     default:
2283       break;
2284     }
2285
2286   copy = rtx_alloc (code);
2287   PUT_MODE (copy, GET_MODE (orig));
2288   copy->in_struct = orig->in_struct;
2289   copy->volatil = orig->volatil;
2290   copy->unchanging = orig->unchanging;
2291   copy->integrated = orig->integrated;
2292   copy->frame_related = orig->frame_related;
2293
2294   format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
2295
2296   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
2297     {
2298       switch (*format_ptr++)
2299         {
2300         case 'e':
2301           XEXP (copy, i) = XEXP (orig, i);
2302           if (XEXP (orig, i) != NULL && XEXP (orig, i) != may_share)
2303             XEXP (copy, i) = copy_most_rtx (XEXP (orig, i), may_share);
2304           break;
2305
2306         case 'u':
2307           XEXP (copy, i) = XEXP (orig, i);
2308           break;
2309
2310         case 'E':
2311         case 'V':
2312           XVEC (copy, i) = XVEC (orig, i);
2313           if (XVEC (orig, i) != NULL)
2314             {
2315               XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
2316               for (j = 0; j < XVECLEN (copy, i); j++)
2317                 XVECEXP (copy, i, j)
2318                   = copy_most_rtx (XVECEXP (orig, i, j), may_share);
2319             }
2320           break;
2321
2322         case 'w':
2323           XWINT (copy, i) = XWINT (orig, i);
2324           break;
2325
2326         case 'n':
2327         case 'i':
2328           XINT (copy, i) = XINT (orig, i);
2329           break;
2330
2331         case 't':
2332           XTREE (copy, i) = XTREE (orig, i);
2333           break;
2334
2335         case 's':
2336         case 'S':
2337           XSTR (copy, i) = XSTR (orig, i);
2338           break;
2339
2340         case '0':
2341           /* Copy this through the wide int field; that's safest.  */
2342           X0WINT (copy, i) = X0WINT (orig, i);
2343           break;
2344
2345         default:
2346           abort ();
2347         }
2348     }
2349   return copy;
2350 }
2351
2352 /* Mark ORIG as in use, and return a copy of it if it was already in use.
2353    Recursively does the same for subexpressions.  */
2354
2355 rtx
2356 copy_rtx_if_shared (orig)
2357      rtx orig;
2358 {
2359   rtx x = orig;
2360   int i;
2361   enum rtx_code code;
2362   const char *format_ptr;
2363   int copied = 0;
2364
2365   if (x == 0)
2366     return 0;
2367
2368   code = GET_CODE (x);
2369
2370   /* These types may be freely shared.  */
2371
2372   switch (code)
2373     {
2374     case REG:
2375     case QUEUED:
2376     case CONST_INT:
2377     case CONST_DOUBLE:
2378     case CONST_VECTOR:
2379     case SYMBOL_REF:
2380     case CODE_LABEL:
2381     case PC:
2382     case CC0:
2383     case SCRATCH:
2384       /* SCRATCH must be shared because they represent distinct values.  */
2385       return x;
2386
2387     case CONST:
2388       /* CONST can be shared if it contains a SYMBOL_REF.  If it contains
2389          a LABEL_REF, it isn't sharable.  */
2390       if (GET_CODE (XEXP (x, 0)) == PLUS
2391           && GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF
2392           && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT)
2393         return x;
2394       break;
2395
2396     case INSN:
2397     case JUMP_INSN:
2398     case CALL_INSN:
2399     case NOTE:
2400     case BARRIER:
2401       /* The chain of insns is not being copied.  */
2402       return x;
2403
2404     case MEM:
2405       /* A MEM is allowed to be shared if its address is constant.
2406
2407          We used to allow sharing of MEMs which referenced
2408          virtual_stack_vars_rtx or virtual_incoming_args_rtx, but
2409          that can lose.  instantiate_virtual_regs will not unshare
2410          the MEMs, and combine may change the structure of the address
2411          because it looks safe and profitable in one context, but
2412          in some other context it creates unrecognizable RTL.  */
2413       if (CONSTANT_ADDRESS_P (XEXP (x, 0)))
2414         return x;
2415
2416       break;
2417
2418     default:
2419       break;
2420     }
2421
2422   /* This rtx may not be shared.  If it has already been seen,
2423      replace it with a copy of itself.  */
2424
2425   if (x->used)
2426     {
2427       rtx copy;
2428
2429       copy = rtx_alloc (code);
2430       memcpy (copy, x,
2431              (sizeof (*copy) - sizeof (copy->fld)
2432               + sizeof (copy->fld[0]) * GET_RTX_LENGTH (code)));
2433       x = copy;
2434       copied = 1;
2435     }
2436   x->used = 1;
2437
2438   /* Now scan the subexpressions recursively.
2439      We can store any replaced subexpressions directly into X
2440      since we know X is not shared!  Any vectors in X
2441      must be copied if X was copied.  */
2442
2443   format_ptr = GET_RTX_FORMAT (code);
2444
2445   for (i = 0; i < GET_RTX_LENGTH (code); i++)
2446     {
2447       switch (*format_ptr++)
2448         {
2449         case 'e':
2450           XEXP (x, i) = copy_rtx_if_shared (XEXP (x, i));
2451           break;
2452
2453         case 'E':
2454           if (XVEC (x, i) != NULL)
2455             {
2456               int j;
2457               int len = XVECLEN (x, i);
2458
2459               if (copied && len > 0)
2460                 XVEC (x, i) = gen_rtvec_v (len, XVEC (x, i)->elem);
2461               for (j = 0; j < len; j++)
2462                 XVECEXP (x, i, j) = copy_rtx_if_shared (XVECEXP (x, i, j));
2463             }
2464           break;
2465         }
2466     }
2467   return x;
2468 }
2469
2470 /* Clear all the USED bits in X to allow copy_rtx_if_shared to be used
2471    to look for shared sub-parts.  */
2472
2473 void
2474 reset_used_flags (x)
2475      rtx x;
2476 {
2477   int i, j;
2478   enum rtx_code code;
2479   const char *format_ptr;
2480
2481   if (x == 0)
2482     return;
2483
2484   code = GET_CODE (x);
2485
2486   /* These types may be freely shared so we needn't do any resetting
2487      for them.  */
2488
2489   switch (code)
2490     {
2491     case REG:
2492     case QUEUED:
2493     case CONST_INT:
2494     case CONST_DOUBLE:
2495     case CONST_VECTOR:
2496     case SYMBOL_REF:
2497     case CODE_LABEL:
2498     case PC:
2499     case CC0:
2500       return;
2501
2502     case INSN:
2503     case JUMP_INSN:
2504     case CALL_INSN:
2505     case NOTE:
2506     case LABEL_REF:
2507     case BARRIER:
2508       /* The chain of insns is not being copied.  */
2509       return;
2510
2511     default:
2512       break;
2513     }
2514
2515   x->used = 0;
2516
2517   format_ptr = GET_RTX_FORMAT (code);
2518   for (i = 0; i < GET_RTX_LENGTH (code); i++)
2519     {
2520       switch (*format_ptr++)
2521         {
2522         case 'e':
2523           reset_used_flags (XEXP (x, i));
2524           break;
2525
2526         case 'E':
2527           for (j = 0; j < XVECLEN (x, i); j++)
2528             reset_used_flags (XVECEXP (x, i, j));
2529           break;
2530         }
2531     }
2532 }
2533 \f
2534 /* Copy X if necessary so that it won't be altered by changes in OTHER.
2535    Return X or the rtx for the pseudo reg the value of X was copied into.
2536    OTHER must be valid as a SET_DEST.  */
2537
2538 rtx
2539 make_safe_from (x, other)
2540      rtx x, other;
2541 {
2542   while (1)
2543     switch (GET_CODE (other))
2544       {
2545       case SUBREG:
2546         other = SUBREG_REG (other);
2547         break;
2548       case STRICT_LOW_PART:
2549       case SIGN_EXTEND:
2550       case ZERO_EXTEND:
2551         other = XEXP (other, 0);
2552         break;
2553       default:
2554         goto done;
2555       }
2556  done:
2557   if ((GET_CODE (other) == MEM
2558        && ! CONSTANT_P (x)
2559        && GET_CODE (x) != REG
2560        && GET_CODE (x) != SUBREG)
2561       || (GET_CODE (other) == REG
2562           && (REGNO (other) < FIRST_PSEUDO_REGISTER
2563               || reg_mentioned_p (other, x))))
2564     {
2565       rtx temp = gen_reg_rtx (GET_MODE (x));
2566       emit_move_insn (temp, x);
2567       return temp;
2568     }
2569   return x;
2570 }
2571 \f
2572 /* Emission of insns (adding them to the doubly-linked list).  */
2573
2574 /* Return the first insn of the current sequence or current function.  */
2575
2576 rtx
2577 get_insns ()
2578 {
2579   return first_insn;
2580 }
2581
2582 /* Specify a new insn as the first in the chain.  */
2583
2584 void
2585 set_first_insn (insn)
2586      rtx insn;
2587 {
2588   if (PREV_INSN (insn) != 0)
2589     abort ();
2590   first_insn = insn;
2591 }
2592
2593 /* Return the last insn emitted in current sequence or current function.  */
2594
2595 rtx
2596 get_last_insn ()
2597 {
2598   return last_insn;
2599 }
2600
2601 /* Specify a new insn as the last in the chain.  */
2602
2603 void
2604 set_last_insn (insn)
2605      rtx insn;
2606 {
2607   if (NEXT_INSN (insn) != 0)
2608     abort ();
2609   last_insn = insn;
2610 }
2611
2612 /* Return the last insn emitted, even if it is in a sequence now pushed.  */
2613
2614 rtx
2615 get_last_insn_anywhere ()
2616 {
2617   struct sequence_stack *stack;
2618   if (last_insn)
2619     return last_insn;
2620   for (stack = seq_stack; stack; stack = stack->next)
2621     if (stack->last != 0)
2622       return stack->last;
2623   return 0;
2624 }
2625
2626 /* Return a number larger than any instruction's uid in this function.  */
2627
2628 int
2629 get_max_uid ()
2630 {
2631   return cur_insn_uid;
2632 }
2633
2634 /* Renumber instructions so that no instruction UIDs are wasted.  */
2635
2636 void
2637 renumber_insns (stream)
2638      FILE *stream;
2639 {
2640   rtx insn;
2641
2642   /* If we're not supposed to renumber instructions, don't.  */
2643   if (!flag_renumber_insns)
2644     return;
2645
2646   /* If there aren't that many instructions, then it's not really
2647      worth renumbering them.  */
2648   if (flag_renumber_insns == 1 && get_max_uid () < 25000)
2649     return;
2650
2651   cur_insn_uid = 1;
2652
2653   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
2654     {
2655       if (stream)
2656         fprintf (stream, "Renumbering insn %d to %d\n",
2657                  INSN_UID (insn), cur_insn_uid);
2658       INSN_UID (insn) = cur_insn_uid++;
2659     }
2660 }
2661 \f
2662 /* Return the next insn.  If it is a SEQUENCE, return the first insn
2663    of the sequence.  */
2664
2665 rtx
2666 next_insn (insn)
2667      rtx insn;
2668 {
2669   if (insn)
2670     {
2671       insn = NEXT_INSN (insn);
2672       if (insn && GET_CODE (insn) == INSN
2673           && GET_CODE (PATTERN (insn)) == SEQUENCE)
2674         insn = XVECEXP (PATTERN (insn), 0, 0);
2675     }
2676
2677   return insn;
2678 }
2679
2680 /* Return the previous insn.  If it is a SEQUENCE, return the last insn
2681    of the sequence.  */
2682
2683 rtx
2684 previous_insn (insn)
2685      rtx insn;
2686 {
2687   if (insn)
2688     {
2689       insn = PREV_INSN (insn);
2690       if (insn && GET_CODE (insn) == INSN
2691           && GET_CODE (PATTERN (insn)) == SEQUENCE)
2692         insn = XVECEXP (PATTERN (insn), 0, XVECLEN (PATTERN (insn), 0) - 1);
2693     }
2694
2695   return insn;
2696 }
2697
2698 /* Return the next insn after INSN that is not a NOTE.  This routine does not
2699    look inside SEQUENCEs.  */
2700
2701 rtx
2702 next_nonnote_insn (insn)
2703      rtx insn;
2704 {
2705   while (insn)
2706     {
2707       insn = NEXT_INSN (insn);
2708       if (insn == 0 || GET_CODE (insn) != NOTE)
2709         break;
2710     }
2711
2712   return insn;
2713 }
2714
2715 /* Return the previous insn before INSN that is not a NOTE.  This routine does
2716    not look inside SEQUENCEs.  */
2717
2718 rtx
2719 prev_nonnote_insn (insn)
2720      rtx insn;
2721 {
2722   while (insn)
2723     {
2724       insn = PREV_INSN (insn);
2725       if (insn == 0 || GET_CODE (insn) != NOTE)
2726         break;
2727     }
2728
2729   return insn;
2730 }
2731
2732 /* Return the next INSN, CALL_INSN or JUMP_INSN after INSN;
2733    or 0, if there is none.  This routine does not look inside
2734    SEQUENCEs.  */
2735
2736 rtx
2737 next_real_insn (insn)
2738      rtx insn;
2739 {
2740   while (insn)
2741     {
2742       insn = NEXT_INSN (insn);
2743       if (insn == 0 || GET_CODE (insn) == INSN
2744           || GET_CODE (insn) == CALL_INSN || GET_CODE (insn) == JUMP_INSN)
2745         break;
2746     }
2747
2748   return insn;
2749 }
2750
2751 /* Return the last INSN, CALL_INSN or JUMP_INSN before INSN;
2752    or 0, if there is none.  This routine does not look inside
2753    SEQUENCEs.  */
2754
2755 rtx
2756 prev_real_insn (insn)
2757      rtx insn;
2758 {
2759   while (insn)
2760     {
2761       insn = PREV_INSN (insn);
2762       if (insn == 0 || GET_CODE (insn) == INSN || GET_CODE (insn) == CALL_INSN
2763           || GET_CODE (insn) == JUMP_INSN)
2764         break;
2765     }
2766
2767   return insn;
2768 }
2769
2770 /* Find the next insn after INSN that really does something.  This routine
2771    does not look inside SEQUENCEs.  Until reload has completed, this is the
2772    same as next_real_insn.  */
2773
2774 int
2775 active_insn_p (insn)
2776      rtx insn;
2777 {
2778   return (GET_CODE (insn) == CALL_INSN || GET_CODE (insn) == JUMP_INSN
2779           || (GET_CODE (insn) == INSN
2780               && (! reload_completed
2781                   || (GET_CODE (PATTERN (insn)) != USE
2782                       && GET_CODE (PATTERN (insn)) != CLOBBER))));
2783 }
2784
2785 rtx
2786 next_active_insn (insn)
2787      rtx insn;
2788 {
2789   while (insn)
2790     {
2791       insn = NEXT_INSN (insn);
2792       if (insn == 0 || active_insn_p (insn))
2793         break;
2794     }
2795
2796   return insn;
2797 }
2798
2799 /* Find the last insn before INSN that really does something.  This routine
2800    does not look inside SEQUENCEs.  Until reload has completed, this is the
2801    same as prev_real_insn.  */
2802
2803 rtx
2804 prev_active_insn (insn)
2805      rtx insn;
2806 {
2807   while (insn)
2808     {
2809       insn = PREV_INSN (insn);
2810       if (insn == 0 || active_insn_p (insn))
2811         break;
2812     }
2813
2814   return insn;
2815 }
2816
2817 /* Return the next CODE_LABEL after the insn INSN, or 0 if there is none.  */
2818
2819 rtx
2820 next_label (insn)
2821      rtx insn;
2822 {
2823   while (insn)
2824     {
2825       insn = NEXT_INSN (insn);
2826       if (insn == 0 || GET_CODE (insn) == CODE_LABEL)
2827         break;
2828     }
2829
2830   return insn;
2831 }
2832
2833 /* Return the last CODE_LABEL before the insn INSN, or 0 if there is none.  */
2834
2835 rtx
2836 prev_label (insn)
2837      rtx insn;
2838 {
2839   while (insn)
2840     {
2841       insn = PREV_INSN (insn);
2842       if (insn == 0 || GET_CODE (insn) == CODE_LABEL)
2843         break;
2844     }
2845
2846   return insn;
2847 }
2848 \f
2849 #ifdef HAVE_cc0
2850 /* INSN uses CC0 and is being moved into a delay slot.  Set up REG_CC_SETTER
2851    and REG_CC_USER notes so we can find it.  */
2852
2853 void
2854 link_cc0_insns (insn)
2855      rtx insn;
2856 {
2857   rtx user = next_nonnote_insn (insn);
2858
2859   if (GET_CODE (user) == INSN && GET_CODE (PATTERN (user)) == SEQUENCE)
2860     user = XVECEXP (PATTERN (user), 0, 0);
2861
2862   REG_NOTES (user) = gen_rtx_INSN_LIST (REG_CC_SETTER, insn,
2863                                         REG_NOTES (user));
2864   REG_NOTES (insn) = gen_rtx_INSN_LIST (REG_CC_USER, user, REG_NOTES (insn));
2865 }
2866
2867 /* Return the next insn that uses CC0 after INSN, which is assumed to
2868    set it.  This is the inverse of prev_cc0_setter (i.e., prev_cc0_setter
2869    applied to the result of this function should yield INSN).
2870
2871    Normally, this is simply the next insn.  However, if a REG_CC_USER note
2872    is present, it contains the insn that uses CC0.
2873
2874    Return 0 if we can't find the insn.  */
2875
2876 rtx
2877 next_cc0_user (insn)
2878      rtx insn;
2879 {
2880   rtx note = find_reg_note (insn, REG_CC_USER, NULL_RTX);
2881
2882   if (note)
2883     return XEXP (note, 0);
2884
2885   insn = next_nonnote_insn (insn);
2886   if (insn && GET_CODE (insn) == INSN && GET_CODE (PATTERN (insn)) == SEQUENCE)
2887     insn = XVECEXP (PATTERN (insn), 0, 0);
2888
2889   if (insn && INSN_P (insn) && reg_mentioned_p (cc0_rtx, PATTERN (insn)))
2890     return insn;
2891
2892   return 0;
2893 }
2894
2895 /* Find the insn that set CC0 for INSN.  Unless INSN has a REG_CC_SETTER
2896    note, it is the previous insn.  */
2897
2898 rtx
2899 prev_cc0_setter (insn)
2900      rtx insn;
2901 {
2902   rtx note = find_reg_note (insn, REG_CC_SETTER, NULL_RTX);
2903
2904   if (note)
2905     return XEXP (note, 0);
2906
2907   insn = prev_nonnote_insn (insn);
2908   if (! sets_cc0_p (PATTERN (insn)))
2909     abort ();
2910
2911   return insn;
2912 }
2913 #endif
2914
2915 /* Increment the label uses for all labels present in rtx.  */
2916
2917 static void
2918 mark_label_nuses(x)
2919     rtx x;
2920 {
2921   enum rtx_code code;
2922   int i, j;
2923   const char *fmt;
2924
2925   code = GET_CODE (x);
2926   if (code == LABEL_REF)
2927     LABEL_NUSES (XEXP (x, 0))++;
2928
2929   fmt = GET_RTX_FORMAT (code);
2930   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2931     {
2932       if (fmt[i] == 'e')
2933         mark_label_nuses (XEXP (x, i));
2934       else if (fmt[i] == 'E')
2935         for (j = XVECLEN (x, i) - 1; j >= 0; j--)
2936           mark_label_nuses (XVECEXP (x, i, j));
2937     }
2938 }
2939
2940 \f
2941 /* Try splitting insns that can be split for better scheduling.
2942    PAT is the pattern which might split.
2943    TRIAL is the insn providing PAT.
2944    LAST is non-zero if we should return the last insn of the sequence produced.
2945
2946    If this routine succeeds in splitting, it returns the first or last
2947    replacement insn depending on the value of LAST.  Otherwise, it
2948    returns TRIAL.  If the insn to be returned can be split, it will be.  */
2949
2950 rtx
2951 try_split (pat, trial, last)
2952      rtx pat, trial;
2953      int last;
2954 {
2955   rtx before = PREV_INSN (trial);
2956   rtx after = NEXT_INSN (trial);
2957   int has_barrier = 0;
2958   rtx tem;
2959   rtx note, seq;
2960   int probability;
2961
2962   if (any_condjump_p (trial)
2963       && (note = find_reg_note (trial, REG_BR_PROB, 0)))
2964     split_branch_probability = INTVAL (XEXP (note, 0));
2965   probability = split_branch_probability;
2966
2967   seq = split_insns (pat, trial);
2968
2969   split_branch_probability = -1;
2970
2971   /* If we are splitting a JUMP_INSN, it might be followed by a BARRIER.
2972      We may need to handle this specially.  */
2973   if (after && GET_CODE (after) == BARRIER)
2974     {
2975       has_barrier = 1;
2976       after = NEXT_INSN (after);
2977     }
2978
2979   if (seq)
2980     {
2981       /* SEQ can either be a SEQUENCE or the pattern of a single insn.
2982          The latter case will normally arise only when being done so that
2983          it, in turn, will be split (SFmode on the 29k is an example).  */
2984       if (GET_CODE (seq) == SEQUENCE)
2985         {
2986           int i, njumps = 0;
2987
2988           /* Avoid infinite loop if any insn of the result matches
2989              the original pattern.  */
2990           for (i = 0; i < XVECLEN (seq, 0); i++)
2991             if (GET_CODE (XVECEXP (seq, 0, i)) == INSN
2992                 && rtx_equal_p (PATTERN (XVECEXP (seq, 0, i)), pat))
2993               return trial;
2994
2995           /* Mark labels.  */
2996           for (i = XVECLEN (seq, 0) - 1; i >= 0; i--)
2997             if (GET_CODE (XVECEXP (seq, 0, i)) == JUMP_INSN)
2998               {
2999                 rtx insn = XVECEXP (seq, 0, i);
3000                 mark_jump_label (PATTERN (insn),
3001                                  XVECEXP (seq, 0, i), 0);
3002                 njumps++;
3003                 if (probability != -1
3004                     && any_condjump_p (insn)
3005                     && !find_reg_note (insn, REG_BR_PROB, 0))
3006                   {
3007                     /* We can preserve the REG_BR_PROB notes only if exactly
3008                        one jump is created, otherwise the machine description
3009                        is responsible for this step using
3010                        split_branch_probability variable.  */
3011                     if (njumps != 1)
3012                       abort ();
3013                     REG_NOTES (insn)
3014                       = gen_rtx_EXPR_LIST (REG_BR_PROB,
3015                                            GEN_INT (probability),
3016                                            REG_NOTES (insn));
3017                   }
3018               }
3019
3020           /* If we are splitting a CALL_INSN, look for the CALL_INSN
3021              in SEQ and copy our CALL_INSN_FUNCTION_USAGE to it.  */
3022           if (GET_CODE (trial) == CALL_INSN)
3023             for (i = XVECLEN (seq, 0) - 1; i >= 0; i--)
3024               if (GET_CODE (XVECEXP (seq, 0, i)) == CALL_INSN)
3025                 CALL_INSN_FUNCTION_USAGE (XVECEXP (seq, 0, i))
3026                   = CALL_INSN_FUNCTION_USAGE (trial);
3027
3028           /* Copy notes, particularly those related to the CFG.  */
3029           for (note = REG_NOTES (trial); note ; note = XEXP (note, 1))
3030             {
3031               switch (REG_NOTE_KIND (note))
3032                 {
3033                 case REG_EH_REGION:
3034                   for (i = XVECLEN (seq, 0) - 1; i >= 0; i--)
3035                     {
3036                       rtx insn = XVECEXP (seq, 0, i);
3037                       if (GET_CODE (insn) == CALL_INSN
3038                           || (flag_non_call_exceptions
3039                               && may_trap_p (PATTERN (insn))))
3040                         REG_NOTES (insn)
3041                           = gen_rtx_EXPR_LIST (REG_EH_REGION,
3042                                                XEXP (note, 0),
3043                                                REG_NOTES (insn));
3044                     }
3045                   break;
3046
3047                 case REG_NORETURN:
3048                 case REG_SETJMP:
3049                 case REG_ALWAYS_RETURN:
3050                   for (i = XVECLEN (seq, 0) - 1; i >= 0; i--)
3051                     {
3052                       rtx insn = XVECEXP (seq, 0, i);
3053                       if (GET_CODE (insn) == CALL_INSN)
3054                         REG_NOTES (insn)
3055                           = gen_rtx_EXPR_LIST (REG_NOTE_KIND (note),
3056                                                XEXP (note, 0),
3057                                                REG_NOTES (insn));
3058                     }
3059                   break;
3060
3061                 case REG_NON_LOCAL_GOTO:
3062                   for (i = XVECLEN (seq, 0) - 1; i >= 0; i--)
3063                     {
3064                       rtx insn = XVECEXP (seq, 0, i);
3065                       if (GET_CODE (insn) == JUMP_INSN)
3066                         REG_NOTES (insn)
3067                           = gen_rtx_EXPR_LIST (REG_NOTE_KIND (note),
3068                                                XEXP (note, 0),
3069                                                REG_NOTES (insn));
3070                     }
3071                   break;
3072
3073                 default:
3074                   break;
3075                 }
3076             }
3077
3078           /* If there are LABELS inside the split insns increment the
3079              usage count so we don't delete the label.  */
3080           if (GET_CODE (trial) == INSN)
3081             for (i = XVECLEN (seq, 0) - 1; i >= 0; i--)
3082               if (GET_CODE (XVECEXP (seq, 0, i)) == INSN)
3083                 mark_label_nuses (PATTERN (XVECEXP (seq, 0, i)));
3084
3085           tem = emit_insn_after (seq, trial);
3086
3087           delete_insn (trial);
3088           if (has_barrier)
3089             emit_barrier_after (tem);
3090
3091           /* Recursively call try_split for each new insn created; by the
3092              time control returns here that insn will be fully split, so
3093              set LAST and continue from the insn after the one returned.
3094              We can't use next_active_insn here since AFTER may be a note.
3095              Ignore deleted insns, which can be occur if not optimizing.  */
3096           for (tem = NEXT_INSN (before); tem != after; tem = NEXT_INSN (tem))
3097             if (! INSN_DELETED_P (tem) && INSN_P (tem))
3098               tem = try_split (PATTERN (tem), tem, 1);
3099         }
3100       /* Avoid infinite loop if the result matches the original pattern.  */
3101       else if (rtx_equal_p (seq, pat))
3102         return trial;
3103       else
3104         {
3105           PATTERN (trial) = seq;
3106           INSN_CODE (trial) = -1;
3107           try_split (seq, trial, last);
3108         }
3109
3110       /* Return either the first or the last insn, depending on which was
3111          requested.  */
3112       return last
3113                 ? (after ? PREV_INSN (after) : last_insn)
3114                 : NEXT_INSN (before);
3115     }
3116
3117   return trial;
3118 }
3119 \f
3120 /* Make and return an INSN rtx, initializing all its slots.
3121    Store PATTERN in the pattern slots.  */
3122
3123 rtx
3124 make_insn_raw (pattern)
3125      rtx pattern;
3126 {
3127   rtx insn;
3128
3129   insn = rtx_alloc (INSN);
3130
3131   INSN_UID (insn) = cur_insn_uid++;
3132   PATTERN (insn) = pattern;
3133   INSN_CODE (insn) = -1;
3134   LOG_LINKS (insn) = NULL;
3135   REG_NOTES (insn) = NULL;
3136
3137 #ifdef ENABLE_RTL_CHECKING
3138   if (insn
3139       && INSN_P (insn)
3140       && (returnjump_p (insn)
3141           || (GET_CODE (insn) == SET
3142               && SET_DEST (insn) == pc_rtx)))
3143     {
3144       warning ("ICE: emit_insn used where emit_jump_insn needed:\n");
3145       debug_rtx (insn);
3146     }
3147 #endif
3148
3149   return insn;
3150 }
3151
3152 /* Like `make_insn' but make a JUMP_INSN instead of an insn.  */
3153
3154 static rtx
3155 make_jump_insn_raw (pattern)
3156      rtx pattern;
3157 {
3158   rtx insn;
3159
3160   insn = rtx_alloc (JUMP_INSN);
3161   INSN_UID (insn) = cur_insn_uid++;
3162
3163   PATTERN (insn) = pattern;
3164   INSN_CODE (insn) = -1;
3165   LOG_LINKS (insn) = NULL;
3166   REG_NOTES (insn) = NULL;
3167   JUMP_LABEL (insn) = NULL;
3168
3169   return insn;
3170 }
3171
3172 /* Like `make_insn' but make a CALL_INSN instead of an insn.  */
3173
3174 static rtx
3175 make_call_insn_raw (pattern)
3176      rtx pattern;
3177 {
3178   rtx insn;
3179
3180   insn = rtx_alloc (CALL_INSN);
3181   INSN_UID (insn) = cur_insn_uid++;
3182
3183   PATTERN (insn) = pattern;
3184   INSN_CODE (insn) = -1;
3185   LOG_LINKS (insn) = NULL;
3186   REG_NOTES (insn) = NULL;
3187   CALL_INSN_FUNCTION_USAGE (insn) = NULL;
3188
3189   return insn;
3190 }
3191 \f
3192 /* Add INSN to the end of the doubly-linked list.
3193    INSN may be an INSN, JUMP_INSN, CALL_INSN, CODE_LABEL, BARRIER or NOTE.  */
3194
3195 void
3196 add_insn (insn)
3197      rtx insn;
3198 {
3199   PREV_INSN (insn) = last_insn;
3200   NEXT_INSN (insn) = 0;
3201
3202   if (NULL != last_insn)
3203     NEXT_INSN (last_insn) = insn;
3204
3205   if (NULL == first_insn)
3206     first_insn = insn;
3207
3208   last_insn = insn;
3209 }
3210
3211 /* Add INSN into the doubly-linked list after insn AFTER.  This and
3212    the next should be the only functions called to insert an insn once
3213    delay slots have been filled since only they know how to update a
3214    SEQUENCE.  */
3215
3216 void
3217 add_insn_after (insn, after)
3218      rtx insn, after;
3219 {
3220   rtx next = NEXT_INSN (after);
3221   basic_block bb;
3222
3223   if (optimize && INSN_DELETED_P (after))
3224     abort ();
3225
3226   NEXT_INSN (insn) = next;
3227   PREV_INSN (insn) = after;
3228
3229   if (next)
3230     {
3231       PREV_INSN (next) = insn;
3232       if (GET_CODE (next) == INSN && GET_CODE (PATTERN (next)) == SEQUENCE)
3233         PREV_INSN (XVECEXP (PATTERN (next), 0, 0)) = insn;
3234     }
3235   else if (last_insn == after)
3236     last_insn = insn;
3237   else
3238     {
3239       struct sequence_stack *stack = seq_stack;
3240       /* Scan all pending sequences too.  */
3241       for (; stack; stack = stack->next)
3242         if (after == stack->last)
3243           {
3244             stack->last = insn;
3245             break;
3246           }
3247
3248       if (stack == 0)
3249         abort ();
3250     }
3251
3252   if (basic_block_for_insn
3253       && (unsigned int)INSN_UID (after) < basic_block_for_insn->num_elements
3254       && (bb = BLOCK_FOR_INSN (after)))
3255     {
3256       set_block_for_insn (insn, bb);
3257       if (INSN_P (insn))
3258         bb->flags |= BB_DIRTY;
3259       /* Should not happen as first in the BB is always
3260          either NOTE or LABEL.  */
3261       if (bb->end == after
3262           /* Avoid clobbering of structure when creating new BB.  */
3263           && GET_CODE (insn) != BARRIER
3264           && (GET_CODE (insn) != NOTE
3265               || NOTE_LINE_NUMBER (insn) != NOTE_INSN_BASIC_BLOCK))
3266         bb->end = insn;
3267     }
3268
3269   NEXT_INSN (after) = insn;
3270   if (GET_CODE (after) == INSN && GET_CODE (PATTERN (after)) == SEQUENCE)
3271     {
3272       rtx sequence = PATTERN (after);
3273       NEXT_INSN (XVECEXP (sequence, 0, XVECLEN (sequence, 0) - 1)) = insn;
3274     }
3275 }
3276
3277 /* Add INSN into the doubly-linked list before insn BEFORE.  This and
3278    the previous should be the only functions called to insert an insn once
3279    delay slots have been filled since only they know how to update a
3280    SEQUENCE.  */
3281
3282 void
3283 add_insn_before (insn, before)
3284      rtx insn, before;
3285 {
3286   rtx prev = PREV_INSN (before);
3287   basic_block bb;
3288
3289   if (optimize && INSN_DELETED_P (before))
3290     abort ();
3291
3292   PREV_INSN (insn) = prev;
3293   NEXT_INSN (insn) = before;
3294
3295   if (prev)
3296     {
3297       NEXT_INSN (prev) = insn;
3298       if (GET_CODE (prev) == INSN && GET_CODE (PATTERN (prev)) == SEQUENCE)
3299         {
3300           rtx sequence = PATTERN (prev);
3301           NEXT_INSN (XVECEXP (sequence, 0, XVECLEN (sequence, 0) - 1)) = insn;
3302         }
3303     }
3304   else if (first_insn == before)
3305     first_insn = insn;
3306   else
3307     {
3308       struct sequence_stack *stack = seq_stack;
3309       /* Scan all pending sequences too.  */
3310       for (; stack; stack = stack->next)
3311         if (before == stack->first)
3312           {
3313             stack->first = insn;
3314             break;
3315           }
3316
3317       if (stack == 0)
3318         abort ();
3319     }
3320
3321   if (basic_block_for_insn
3322       && (unsigned int)INSN_UID (before) < basic_block_for_insn->num_elements
3323       && (bb = BLOCK_FOR_INSN (before)))
3324     {
3325       set_block_for_insn (insn, bb);
3326       if (INSN_P (insn))
3327         bb->flags |= BB_DIRTY;
3328       /* Should not happen as first in the BB is always
3329          either NOTE or LABEl.  */
3330       if (bb->head == insn
3331           /* Avoid clobbering of structure when creating new BB.  */
3332           && GET_CODE (insn) != BARRIER
3333           && (GET_CODE (insn) != NOTE
3334               || NOTE_LINE_NUMBER (insn) != NOTE_INSN_BASIC_BLOCK))
3335         abort ();
3336     }
3337
3338   PREV_INSN (before) = insn;
3339   if (GET_CODE (before) == INSN && GET_CODE (PATTERN (before)) == SEQUENCE)
3340     PREV_INSN (XVECEXP (PATTERN (before), 0, 0)) = insn;
3341 }
3342
3343 /* Remove an insn from its doubly-linked list.  This function knows how
3344    to handle sequences.  */
3345 void
3346 remove_insn (insn)
3347      rtx insn;
3348 {
3349   rtx next = NEXT_INSN (insn);
3350   rtx prev = PREV_INSN (insn);
3351   basic_block bb;
3352
3353   if (prev)
3354     {
3355       NEXT_INSN (prev) = next;
3356       if (GET_CODE (prev) == INSN && GET_CODE (PATTERN (prev)) == SEQUENCE)
3357         {
3358           rtx sequence = PATTERN (prev);
3359           NEXT_INSN (XVECEXP (sequence, 0, XVECLEN (sequence, 0) - 1)) = next;
3360         }
3361     }
3362   else if (first_insn == insn)
3363     first_insn = next;
3364   else
3365     {
3366       struct sequence_stack *stack = seq_stack;
3367       /* Scan all pending sequences too.  */
3368       for (; stack; stack = stack->next)
3369         if (insn == stack->first)
3370           {
3371             stack->first = next;
3372             break;
3373           }
3374
3375       if (stack == 0)
3376         abort ();
3377     }
3378
3379   if (next)
3380     {
3381       PREV_INSN (next) = prev;
3382       if (GET_CODE (next) == INSN && GET_CODE (PATTERN (next)) == SEQUENCE)
3383         PREV_INSN (XVECEXP (PATTERN (next), 0, 0)) = prev;
3384     }
3385   else if (last_insn == insn)
3386     last_insn = prev;
3387   else
3388     {
3389       struct sequence_stack *stack = seq_stack;
3390       /* Scan all pending sequences too.  */
3391       for (; stack; stack = stack->next)
3392         if (insn == stack->last)
3393           {
3394             stack->last = prev;
3395             break;
3396           }
3397
3398       if (stack == 0)
3399         abort ();
3400     }
3401   if (basic_block_for_insn
3402       && (unsigned int)INSN_UID (insn) < basic_block_for_insn->num_elements
3403       && (bb = BLOCK_FOR_INSN (insn)))
3404     {
3405       if (INSN_P (insn))
3406         bb->flags |= BB_DIRTY;
3407       if (bb->head == insn)
3408         {
3409           /* Never ever delete the basic block note without deleting whole basic
3410              block.  */
3411           if (GET_CODE (insn) == NOTE)
3412             abort ();
3413           bb->head = next;
3414         }
3415       if (bb->end == insn)
3416         bb->end = prev;
3417     }
3418 }
3419
3420 /* Delete all insns made since FROM.
3421    FROM becomes the new last instruction.  */
3422
3423 void
3424 delete_insns_since (from)
3425      rtx from;
3426 {
3427   if (from == 0)
3428     first_insn = 0;
3429   else
3430     NEXT_INSN (from) = 0;
3431   last_insn = from;
3432 }
3433
3434 /* This function is deprecated, please use sequences instead.
3435
3436    Move a consecutive bunch of insns to a different place in the chain.
3437    The insns to be moved are those between FROM and TO.
3438    They are moved to a new position after the insn AFTER.
3439    AFTER must not be FROM or TO or any insn in between.
3440
3441    This function does not know about SEQUENCEs and hence should not be
3442    called after delay-slot filling has been done.  */
3443
3444 void
3445 reorder_insns_nobb (from, to, after)
3446      rtx from, to, after;
3447 {
3448   /* Splice this bunch out of where it is now.  */
3449   if (PREV_INSN (from))
3450     NEXT_INSN (PREV_INSN (from)) = NEXT_INSN (to);
3451   if (NEXT_INSN (to))
3452     PREV_INSN (NEXT_INSN (to)) = PREV_INSN (from);
3453   if (last_insn == to)
3454     last_insn = PREV_INSN (from);
3455   if (first_insn == from)
3456     first_insn = NEXT_INSN (to);
3457
3458   /* Make the new neighbors point to it and it to them.  */
3459   if (NEXT_INSN (after))
3460     PREV_INSN (NEXT_INSN (after)) = to;
3461
3462   NEXT_INSN (to) = NEXT_INSN (after);
3463   PREV_INSN (from) = after;
3464   NEXT_INSN (after) = from;
3465   if (after == last_insn)
3466     last_insn = to;
3467 }
3468
3469 /* Same as function above, but take care to update BB boundaries.  */
3470 void
3471 reorder_insns (from, to, after)
3472      rtx from, to, after;
3473 {
3474   rtx prev = PREV_INSN (from);
3475   basic_block bb, bb2;
3476
3477   reorder_insns_nobb (from, to, after);
3478
3479   if (basic_block_for_insn
3480       && (unsigned int)INSN_UID (after) < basic_block_for_insn->num_elements
3481       && (bb = BLOCK_FOR_INSN (after)))
3482     {
3483       rtx x;
3484       bb->flags |= BB_DIRTY;
3485
3486       if (basic_block_for_insn
3487           && (unsigned int)INSN_UID (from) < basic_block_for_insn->num_elements
3488           && (bb2 = BLOCK_FOR_INSN (from)))
3489         {
3490           if (bb2->end == to)
3491             bb2->end = prev;
3492           bb2->flags |= BB_DIRTY;
3493         }
3494
3495       if (bb->end == after)
3496         bb->end = to;
3497
3498       for (x = from; x != NEXT_INSN (to); x = NEXT_INSN (x))
3499         set_block_for_insn (x, bb);
3500     }
3501 }
3502
3503 /* Return the line note insn preceding INSN.  */
3504
3505 static rtx
3506 find_line_note (insn)
3507      rtx insn;
3508 {
3509   if (no_line_numbers)
3510     return 0;
3511
3512   for (; insn; insn = PREV_INSN (insn))
3513     if (GET_CODE (insn) == NOTE
3514         && NOTE_LINE_NUMBER (insn) >= 0)
3515       break;
3516
3517   return insn;
3518 }
3519
3520 /* Like reorder_insns, but inserts line notes to preserve the line numbers
3521    of the moved insns when debugging.  This may insert a note between AFTER
3522    and FROM, and another one after TO.  */
3523
3524 void
3525 reorder_insns_with_line_notes (from, to, after)
3526      rtx from, to, after;
3527 {
3528   rtx from_line = find_line_note (from);
3529   rtx after_line = find_line_note (after);
3530
3531   reorder_insns (from, to, after);
3532
3533   if (from_line == after_line)
3534     return;
3535
3536   if (from_line)
3537     emit_line_note_after (NOTE_SOURCE_FILE (from_line),
3538                           NOTE_LINE_NUMBER (from_line),
3539                           after);
3540   if (after_line)
3541     emit_line_note_after (NOTE_SOURCE_FILE (after_line),
3542                           NOTE_LINE_NUMBER (after_line),
3543                           to);
3544 }
3545
3546 /* Remove unnecessary notes from the instruction stream.  */
3547
3548 void
3549 remove_unnecessary_notes ()
3550 {
3551   rtx block_stack = NULL_RTX;
3552   rtx eh_stack = NULL_RTX;
3553   rtx insn;
3554   rtx next;
3555   rtx tmp;
3556
3557   /* We must not remove the first instruction in the function because
3558      the compiler depends on the first instruction being a note.  */
3559   for (insn = NEXT_INSN (get_insns ()); insn; insn = next)
3560     {
3561       /* Remember what's next.  */
3562       next = NEXT_INSN (insn);
3563
3564       /* We're only interested in notes.  */
3565       if (GET_CODE (insn) != NOTE)
3566         continue;
3567
3568       switch (NOTE_LINE_NUMBER (insn))
3569         {
3570         case NOTE_INSN_DELETED:
3571         case NOTE_INSN_LOOP_END_TOP_COND:
3572           remove_insn (insn);
3573           break;
3574
3575         case NOTE_INSN_EH_REGION_BEG:
3576           eh_stack = alloc_INSN_LIST (insn, eh_stack);
3577           break;
3578
3579         case NOTE_INSN_EH_REGION_END:
3580           /* Too many end notes.  */
3581           if (eh_stack == NULL_RTX)
3582             abort ();
3583           /* Mismatched nesting.  */
3584           if (NOTE_EH_HANDLER (XEXP (eh_stack, 0)) != NOTE_EH_HANDLER (insn))
3585             abort ();
3586           tmp = eh_stack;
3587           eh_stack = XEXP (eh_stack, 1);
3588           free_INSN_LIST_node (tmp);
3589           break;
3590
3591         case NOTE_INSN_BLOCK_BEG:
3592           /* By now, all notes indicating lexical blocks should have
3593              NOTE_BLOCK filled in.  */
3594           if (NOTE_BLOCK (insn) == NULL_TREE)
3595             abort ();
3596           block_stack = alloc_INSN_LIST (insn, block_stack);
3597           break;
3598
3599         case NOTE_INSN_BLOCK_END:
3600           /* Too many end notes.  */
3601           if (block_stack == NULL_RTX)
3602             abort ();
3603           /* Mismatched nesting.  */
3604           if (NOTE_BLOCK (XEXP (block_stack, 0)) != NOTE_BLOCK (insn))
3605             abort ();
3606           tmp = block_stack;
3607           block_stack = XEXP (block_stack, 1);
3608           free_INSN_LIST_node (tmp);
3609
3610           /* Scan back to see if there are any non-note instructions
3611              between INSN and the beginning of this block.  If not,
3612              then there is no PC range in the generated code that will
3613              actually be in this block, so there's no point in
3614              remembering the existence of the block.  */
3615           for (tmp = PREV_INSN (insn); tmp ; tmp = PREV_INSN (tmp))
3616             {
3617               /* This block contains a real instruction.  Note that we
3618                  don't include labels; if the only thing in the block
3619                  is a label, then there are still no PC values that
3620                  lie within the block.  */
3621               if (INSN_P (tmp))
3622                 break;
3623
3624               /* We're only interested in NOTEs.  */
3625               if (GET_CODE (tmp) != NOTE)
3626                 continue;
3627
3628               if (NOTE_LINE_NUMBER (tmp) == NOTE_INSN_BLOCK_BEG)
3629                 {
3630                   /* We just verified that this BLOCK matches us with
3631                      the block_stack check above.  Never delete the
3632                      BLOCK for the outermost scope of the function; we
3633                      can refer to names from that scope even if the
3634                      block notes are messed up.  */
3635                   if (! is_body_block (NOTE_BLOCK (insn))
3636                       && (*debug_hooks->ignore_block) (NOTE_BLOCK (insn)))
3637                     {
3638                       remove_insn (tmp);
3639                       remove_insn (insn);
3640                     }
3641                   break;
3642                 }
3643               else if (NOTE_LINE_NUMBER (tmp) == NOTE_INSN_BLOCK_END)
3644                 /* There's a nested block.  We need to leave the
3645                    current block in place since otherwise the debugger
3646                    wouldn't be able to show symbols from our block in
3647                    the nested block.  */
3648                 break;
3649             }
3650         }
3651     }
3652
3653   /* Too many begin notes.  */
3654   if (block_stack || eh_stack)
3655     abort ();
3656 }
3657
3658 \f
3659 /* Emit an insn of given code and pattern
3660    at a specified place within the doubly-linked list.  */
3661
3662 /* Make an instruction with body PATTERN
3663    and output it before the instruction BEFORE.  */
3664
3665 rtx
3666 emit_insn_before (pattern, before)
3667      rtx pattern, before;
3668 {
3669   rtx insn = before;
3670
3671   if (GET_CODE (pattern) == SEQUENCE)
3672     {
3673       int i;
3674
3675       for (i = 0; i < XVECLEN (pattern, 0); i++)
3676         {
3677           insn = XVECEXP (pattern, 0, i);
3678           add_insn_before (insn, before);
3679         }
3680     }
3681   else
3682     {
3683       insn = make_insn_raw (pattern);
3684       add_insn_before (insn, before);
3685     }
3686
3687   return insn;
3688 }
3689
3690 /* Make an instruction with body PATTERN and code JUMP_INSN
3691    and output it before the instruction BEFORE.  */
3692
3693 rtx
3694 emit_jump_insn_before (pattern, before)
3695      rtx pattern, before;
3696 {
3697   rtx insn;
3698
3699   if (GET_CODE (pattern) == SEQUENCE)
3700     insn = emit_insn_before (pattern, before);
3701   else
3702     {
3703       insn = make_jump_insn_raw (pattern);
3704       add_insn_before (insn, before);
3705     }
3706
3707   return insn;
3708 }
3709
3710 /* Make an instruction with body PATTERN and code CALL_INSN
3711    and output it before the instruction BEFORE.  */
3712
3713 rtx
3714 emit_call_insn_before (pattern, before)
3715      rtx pattern, before;
3716 {
3717   rtx insn;
3718
3719   if (GET_CODE (pattern) == SEQUENCE)
3720     insn = emit_insn_before (pattern, before);
3721   else
3722     {
3723       insn = make_call_insn_raw (pattern);
3724       add_insn_before (insn, before);
3725       PUT_CODE (insn, CALL_INSN);
3726     }
3727
3728   return insn;
3729 }
3730
3731 /* Make an insn of code BARRIER
3732    and output it before the insn BEFORE.  */
3733
3734 rtx
3735 emit_barrier_before (before)
3736      rtx before;
3737 {
3738   rtx insn = rtx_alloc (BARRIER);
3739
3740   INSN_UID (insn) = cur_insn_uid++;
3741
3742   add_insn_before (insn, before);
3743   return insn;
3744 }
3745
3746 /* Emit the label LABEL before the insn BEFORE.  */
3747
3748 rtx
3749 emit_label_before (label, before)
3750      rtx label, before;
3751 {
3752   /* This can be called twice for the same label as a result of the
3753      confusion that follows a syntax error!  So make it harmless.  */
3754   if (INSN_UID (label) == 0)
3755     {
3756       INSN_UID (label) = cur_insn_uid++;
3757       add_insn_before (label, before);
3758     }
3759
3760   return label;
3761 }
3762
3763 /* Emit a note of subtype SUBTYPE before the insn BEFORE.  */
3764
3765 rtx
3766 emit_note_before (subtype, before)
3767      int subtype;
3768      rtx before;
3769 {
3770   rtx note = rtx_alloc (NOTE);
3771   INSN_UID (note) = cur_insn_uid++;
3772   NOTE_SOURCE_FILE (note) = 0;
3773   NOTE_LINE_NUMBER (note) = subtype;
3774
3775   add_insn_before (note, before);
3776   return note;
3777 }
3778 \f
3779 /* Make an insn of code INSN with body PATTERN
3780    and output it after the insn AFTER.  */
3781
3782 rtx
3783 emit_insn_after (pattern, after)
3784      rtx pattern, after;
3785 {
3786   rtx insn = after;
3787
3788   if (GET_CODE (pattern) == SEQUENCE)
3789     {
3790       int i;
3791
3792       for (i = 0; i < XVECLEN (pattern, 0); i++)
3793         {
3794           insn = XVECEXP (pattern, 0, i);
3795           add_insn_after (insn, after);
3796           after = insn;
3797         }
3798     }
3799   else
3800     {
3801       insn = make_insn_raw (pattern);
3802       add_insn_after (insn, after);
3803     }
3804
3805   return insn;
3806 }
3807
3808 /* Similar to emit_insn_after, except that line notes are to be inserted so
3809    as to act as if this insn were at FROM.  */
3810
3811 void
3812 emit_insn_after_with_line_notes (pattern, after, from)
3813      rtx pattern, after, from;
3814 {
3815   rtx from_line = find_line_note (from);
3816   rtx after_line = find_line_note (after);
3817   rtx insn = emit_insn_after (pattern, after);
3818
3819   if (from_line)
3820     emit_line_note_after (NOTE_SOURCE_FILE (from_line),
3821                           NOTE_LINE_NUMBER (from_line),
3822                           after);
3823
3824   if (after_line)
3825     emit_line_note_after (NOTE_SOURCE_FILE (after_line),
3826                           NOTE_LINE_NUMBER (after_line),
3827                           insn);
3828 }
3829
3830 /* Make an insn of code JUMP_INSN with body PATTERN
3831    and output it after the insn AFTER.  */
3832
3833 rtx
3834 emit_jump_insn_after (pattern, after)
3835      rtx pattern, after;
3836 {
3837   rtx insn;
3838
3839   if (GET_CODE (pattern) == SEQUENCE)
3840     insn = emit_insn_after (pattern, after);
3841   else
3842     {
3843       insn = make_jump_insn_raw (pattern);
3844       add_insn_after (insn, after);
3845     }
3846
3847   return insn;
3848 }
3849
3850 /* Make an insn of code BARRIER
3851    and output it after the insn AFTER.  */
3852
3853 rtx
3854 emit_barrier_after (after)
3855      rtx after;
3856 {
3857   rtx insn = rtx_alloc (BARRIER);
3858
3859   INSN_UID (insn) = cur_insn_uid++;
3860
3861   add_insn_after (insn, after);
3862   return insn;
3863 }
3864
3865 /* Emit the label LABEL after the insn AFTER.  */
3866
3867 rtx
3868 emit_label_after (label, after)
3869      rtx label, after;
3870 {
3871   /* This can be called twice for the same label
3872      as a result of the confusion that follows a syntax error!
3873      So make it harmless.  */
3874   if (INSN_UID (label) == 0)
3875     {
3876       INSN_UID (label) = cur_insn_uid++;
3877       add_insn_after (label, after);
3878     }
3879
3880   return label;
3881 }
3882
3883 /* Emit a note of subtype SUBTYPE after the insn AFTER.  */
3884
3885 rtx
3886 emit_note_after (subtype, after)
3887      int subtype;
3888      rtx after;
3889 {
3890   rtx note = rtx_alloc (NOTE);
3891   INSN_UID (note) = cur_insn_uid++;
3892   NOTE_SOURCE_FILE (note) = 0;
3893   NOTE_LINE_NUMBER (note) = subtype;
3894   add_insn_after (note, after);
3895   return note;
3896 }
3897
3898 /* Emit a line note for FILE and LINE after the insn AFTER.  */
3899
3900 rtx
3901 emit_line_note_after (file, line, after)
3902      const char *file;
3903      int line;
3904      rtx after;
3905 {
3906   rtx note;
3907
3908   if (no_line_numbers && line > 0)
3909     {
3910       cur_insn_uid++;
3911       return 0;
3912     }
3913
3914   note  = rtx_alloc (NOTE);
3915   INSN_UID (note) = cur_insn_uid++;
3916   NOTE_SOURCE_FILE (note) = file;
3917   NOTE_LINE_NUMBER (note) = line;
3918   add_insn_after (note, after);
3919   return note;
3920 }
3921 \f
3922 /* Make an insn of code INSN with pattern PATTERN
3923    and add it to the end of the doubly-linked list.
3924    If PATTERN is a SEQUENCE, take the elements of it
3925    and emit an insn for each element.
3926
3927    Returns the last insn emitted.  */
3928
3929 rtx
3930 emit_insn (pattern)
3931      rtx pattern;
3932 {
3933   rtx insn = last_insn;
3934
3935   if (GET_CODE (pattern) == SEQUENCE)
3936     {
3937       int i;
3938
3939       for (i = 0; i < XVECLEN (pattern, 0); i++)
3940         {
3941           insn = XVECEXP (pattern, 0, i);
3942           add_insn (insn);
3943         }
3944     }
3945   else
3946     {
3947       insn = make_insn_raw (pattern);
3948       add_insn (insn);
3949     }
3950
3951   return insn;
3952 }
3953
3954 /* Emit the insns in a chain starting with INSN.
3955    Return the last insn emitted.  */
3956
3957 rtx
3958 emit_insns (insn)
3959      rtx insn;
3960 {
3961   rtx last = 0;
3962
3963   while (insn)
3964     {
3965       rtx next = NEXT_INSN (insn);
3966       add_insn (insn);
3967       last = insn;
3968       insn = next;
3969     }
3970
3971   return last;
3972 }
3973
3974 /* Emit the insns in a chain starting with INSN and place them in front of
3975    the insn BEFORE.  Return the last insn emitted.  */
3976
3977 rtx
3978 emit_insns_before (insn, before)
3979      rtx insn;
3980      rtx before;
3981 {
3982   rtx last = 0;
3983
3984   while (insn)
3985     {
3986       rtx next = NEXT_INSN (insn);
3987       add_insn_before (insn, before);
3988       last = insn;
3989       insn = next;
3990     }
3991
3992   return last;
3993 }
3994
3995 /* Emit the insns in a chain starting with FIRST and place them in back of
3996    the insn AFTER.  Return the last insn emitted.  */
3997
3998 rtx
3999 emit_insns_after (first, after)
4000      rtx first;
4001      rtx after;
4002 {
4003   rtx last;
4004   rtx after_after;
4005   basic_block bb;
4006
4007   if (!after)
4008     abort ();
4009
4010   if (!first)
4011     return after;
4012
4013   if (basic_block_for_insn
4014       && (unsigned int)INSN_UID (after) < basic_block_for_insn->num_elements
4015       && (bb = BLOCK_FOR_INSN (after)))
4016     {
4017       bb->flags |= BB_DIRTY;
4018       for (last = first; NEXT_INSN (last); last = NEXT_INSN (last))
4019         set_block_for_insn (last, bb);
4020       set_block_for_insn (last, bb);
4021       if (bb->end == after)
4022         bb->end = last;
4023     }
4024   else
4025     for (last = first; NEXT_INSN (last); last = NEXT_INSN (last))
4026       continue;
4027
4028   after_after = NEXT_INSN (after);
4029
4030   NEXT_INSN (after) = first;
4031   PREV_INSN (first) = after;
4032   NEXT_INSN (last) = after_after;
4033   if (after_after)
4034     PREV_INSN (after_after) = last;
4035
4036   if (after == last_insn)
4037     last_insn = last;
4038   return last;
4039 }
4040
4041 /* Make an insn of code JUMP_INSN with pattern PATTERN
4042    and add it to the end of the doubly-linked list.  */
4043
4044 rtx
4045 emit_jump_insn (pattern)
4046      rtx pattern;
4047 {
4048   if (GET_CODE (pattern) == SEQUENCE)
4049     return emit_insn (pattern);
4050   else
4051     {
4052       rtx insn = make_jump_insn_raw (pattern);
4053       add_insn (insn);
4054       return insn;
4055     }
4056 }
4057
4058 /* Make an insn of code CALL_INSN with pattern PATTERN
4059    and add it to the end of the doubly-linked list.  */
4060
4061 rtx
4062 emit_call_insn (pattern)
4063      rtx pattern;
4064 {
4065   if (GET_CODE (pattern) == SEQUENCE)
4066     return emit_insn (pattern);
4067   else
4068     {
4069       rtx insn = make_call_insn_raw (pattern);
4070       add_insn (insn);
4071       PUT_CODE (insn, CALL_INSN);
4072       return insn;
4073     }
4074 }
4075
4076 /* Add the label LABEL to the end of the doubly-linked list.  */
4077
4078 rtx
4079 emit_label (label)
4080      rtx label;
4081 {
4082   /* This can be called twice for the same label
4083      as a result of the confusion that follows a syntax error!
4084      So make it harmless.  */
4085   if (INSN_UID (label) == 0)
4086     {
4087       INSN_UID (label) = cur_insn_uid++;
4088       add_insn (label);
4089     }
4090   return label;
4091 }
4092
4093 /* Make an insn of code BARRIER
4094    and add it to the end of the doubly-linked list.  */
4095
4096 rtx
4097 emit_barrier ()
4098 {
4099   rtx barrier = rtx_alloc (BARRIER);
4100   INSN_UID (barrier) = cur_insn_uid++;
4101   add_insn (barrier);
4102   return barrier;
4103 }
4104
4105 /* Make an insn of code NOTE
4106    with data-fields specified by FILE and LINE
4107    and add it to the end of the doubly-linked list,
4108    but only if line-numbers are desired for debugging info.  */
4109
4110 rtx
4111 emit_line_note (file, line)
4112      const char *file;
4113      int line;
4114 {
4115   set_file_and_line_for_stmt (file, line);
4116
4117 #if 0
4118   if (no_line_numbers)
4119     return 0;
4120 #endif
4121
4122   return emit_note (file, line);
4123 }
4124
4125 /* Make an insn of code NOTE
4126    with data-fields specified by FILE and LINE
4127    and add it to the end of the doubly-linked list.
4128    If it is a line-number NOTE, omit it if it matches the previous one.  */
4129
4130 rtx
4131 emit_note (file, line)
4132      const char *file;
4133      int line;
4134 {
4135   rtx note;
4136
4137   if (line > 0)
4138     {
4139       if (file && last_filename && !strcmp (file, last_filename)
4140           && line == last_linenum)
4141         return 0;
4142       last_filename = file;
4143       last_linenum = line;
4144     }
4145
4146   if (no_line_numbers && line > 0)
4147     {
4148       cur_insn_uid++;
4149       return 0;
4150     }
4151
4152   note = rtx_alloc (NOTE);
4153   INSN_UID (note) = cur_insn_uid++;
4154   NOTE_SOURCE_FILE (note) = file;
4155   NOTE_LINE_NUMBER (note) = line;
4156   add_insn (note);
4157   return note;
4158 }
4159
4160 /* Emit a NOTE, and don't omit it even if LINE is the previous note.  */
4161
4162 rtx
4163 emit_line_note_force (file, line)
4164      const char *file;
4165      int line;
4166 {
4167   last_linenum = -1;
4168   return emit_line_note (file, line);
4169 }
4170
4171 /* Cause next statement to emit a line note even if the line number
4172    has not changed.  This is used at the beginning of a function.  */
4173
4174 void
4175 force_next_line_note ()
4176 {
4177   last_linenum = -1;
4178 }
4179
4180 /* Place a note of KIND on insn INSN with DATUM as the datum. If a
4181    note of this type already exists, remove it first.  */
4182
4183 rtx
4184 set_unique_reg_note (insn, kind, datum)
4185      rtx insn;
4186      enum reg_note kind;
4187      rtx datum;
4188 {
4189   rtx note = find_reg_note (insn, kind, NULL_RTX);
4190
4191   switch (kind)
4192     {
4193     case REG_EQUAL:
4194     case REG_EQUIV:
4195       /* Don't add REG_EQUAL/REG_EQUIV notes if the insn
4196          has multiple sets (some callers assume single_set
4197          means the insn only has one set, when in fact it
4198          means the insn only has one * useful * set).  */
4199       if (GET_CODE (PATTERN (insn)) == PARALLEL && multiple_sets (insn))
4200         {
4201           if (note)
4202             abort ();
4203           return NULL_RTX;
4204         }
4205
4206       /* Don't add ASM_OPERAND REG_EQUAL/REG_EQUIV notes.
4207          It serves no useful purpose and breaks eliminate_regs.  */
4208       if (GET_CODE (datum) == ASM_OPERANDS)
4209         return NULL_RTX;
4210       break;
4211
4212     default:
4213       break;
4214     }
4215
4216   if (note)
4217     {
4218       XEXP (note, 0) = datum;
4219       return note;
4220     }
4221
4222   REG_NOTES (insn) = gen_rtx_EXPR_LIST (kind, datum, REG_NOTES (insn));
4223   return REG_NOTES (insn);
4224 }
4225 \f
4226 /* Return an indication of which type of insn should have X as a body.
4227    The value is CODE_LABEL, INSN, CALL_INSN or JUMP_INSN.  */
4228
4229 enum rtx_code
4230 classify_insn (x)
4231      rtx x;
4232 {
4233   if (GET_CODE (x) == CODE_LABEL)
4234     return CODE_LABEL;
4235   if (GET_CODE (x) == CALL)
4236     return CALL_INSN;
4237   if (GET_CODE (x) == RETURN)
4238     return JUMP_INSN;
4239   if (GET_CODE (x) == SET)
4240     {
4241       if (SET_DEST (x) == pc_rtx)
4242         return JUMP_INSN;
4243       else if (GET_CODE (SET_SRC (x)) == CALL)
4244         return CALL_INSN;
4245       else
4246         return INSN;
4247     }
4248   if (GET_CODE (x) == PARALLEL)
4249     {
4250       int j;
4251       for (j = XVECLEN (x, 0) - 1; j >= 0; j--)
4252         if (GET_CODE (XVECEXP (x, 0, j)) == CALL)
4253           return CALL_INSN;
4254         else if (GET_CODE (XVECEXP (x, 0, j)) == SET
4255                  && SET_DEST (XVECEXP (x, 0, j)) == pc_rtx)
4256           return JUMP_INSN;
4257         else if (GET_CODE (XVECEXP (x, 0, j)) == SET
4258                  && GET_CODE (SET_SRC (XVECEXP (x, 0, j))) == CALL)
4259           return CALL_INSN;
4260     }
4261   return INSN;
4262 }
4263
4264 /* Emit the rtl pattern X as an appropriate kind of insn.
4265    If X is a label, it is simply added into the insn chain.  */
4266
4267 rtx
4268 emit (x)
4269      rtx x;
4270 {
4271   enum rtx_code code = classify_insn (x);
4272
4273   if (code == CODE_LABEL)
4274     return emit_label (x);
4275   else if (code == INSN)
4276     return emit_insn (x);
4277   else if (code == JUMP_INSN)
4278     {
4279       rtx insn = emit_jump_insn (x);
4280       if (any_uncondjump_p (insn) || GET_CODE (x) == RETURN)
4281         return emit_barrier ();
4282       return insn;
4283     }
4284   else if (code == CALL_INSN)
4285     return emit_call_insn (x);
4286   else
4287     abort ();
4288 }
4289 \f
4290 /* Begin emitting insns to a sequence which can be packaged in an
4291    RTL_EXPR.  If this sequence will contain something that might cause
4292    the compiler to pop arguments to function calls (because those
4293    pops have previously been deferred; see INHIBIT_DEFER_POP for more
4294    details), use do_pending_stack_adjust before calling this function.
4295    That will ensure that the deferred pops are not accidentally
4296    emitted in the middle of this sequence.  */
4297
4298 void
4299 start_sequence ()
4300 {
4301   struct sequence_stack *tem;
4302
4303   tem = (struct sequence_stack *) xmalloc (sizeof (struct sequence_stack));
4304
4305   tem->next = seq_stack;
4306   tem->first = first_insn;
4307   tem->last = last_insn;
4308   tem->sequence_rtl_expr = seq_rtl_expr;
4309
4310   seq_stack = tem;
4311
4312   first_insn = 0;
4313   last_insn = 0;
4314 }
4315
4316 /* Similarly, but indicate that this sequence will be placed in T, an
4317    RTL_EXPR.  See the documentation for start_sequence for more
4318    information about how to use this function.  */
4319
4320 void
4321 start_sequence_for_rtl_expr (t)
4322      tree t;
4323 {
4324   start_sequence ();
4325
4326   seq_rtl_expr = t;
4327 }
4328
4329 /* Set up the insn chain starting with FIRST as the current sequence,
4330    saving the previously current one.  See the documentation for
4331    start_sequence for more information about how to use this function.  */
4332
4333 void
4334 push_to_sequence (first)
4335      rtx first;
4336 {
4337   rtx last;
4338
4339   start_sequence ();
4340
4341   for (last = first; last && NEXT_INSN (last); last = NEXT_INSN (last));
4342
4343   first_insn = first;
4344   last_insn = last;
4345 }
4346
4347 /* Set up the insn chain from a chain stort in FIRST to LAST.  */
4348
4349 void
4350 push_to_full_sequence (first, last)
4351      rtx first, last;
4352 {
4353   start_sequence ();
4354   first_insn = first;
4355   last_insn = last;
4356   /* We really should have the end of the insn chain here.  */
4357   if (last && NEXT_INSN (last))
4358     abort ();
4359 }
4360
4361 /* Set up the outer-level insn chain
4362    as the current sequence, saving the previously current one.  */
4363
4364 void
4365 push_topmost_sequence ()
4366 {
4367   struct sequence_stack *stack, *top = NULL;
4368
4369   start_sequence ();
4370
4371   for (stack = seq_stack; stack; stack = stack->next)
4372     top = stack;
4373
4374   first_insn = top->first;
4375   last_insn = top->last;
4376   seq_rtl_expr = top->sequence_rtl_expr;
4377 }
4378
4379 /* After emitting to the outer-level insn chain, update the outer-level
4380    insn chain, and restore the previous saved state.  */
4381
4382 void
4383 pop_topmost_sequence ()
4384 {
4385   struct sequence_stack *stack, *top = NULL;
4386
4387   for (stack = seq_stack; stack; stack = stack->next)
4388     top = stack;
4389
4390   top->first = first_insn;
4391   top->last = last_insn;
4392   /* ??? Why don't we save seq_rtl_expr here?  */
4393
4394   end_sequence ();
4395 }
4396
4397 /* After emitting to a sequence, restore previous saved state.
4398
4399    To get the contents of the sequence just made, you must call
4400    `gen_sequence' *before* calling here.
4401
4402    If the compiler might have deferred popping arguments while
4403    generating this sequence, and this sequence will not be immediately
4404    inserted into the instruction stream, use do_pending_stack_adjust
4405    before calling gen_sequence.  That will ensure that the deferred
4406    pops are inserted into this sequence, and not into some random
4407    location in the instruction stream.  See INHIBIT_DEFER_POP for more
4408    information about deferred popping of arguments.  */
4409
4410 void
4411 end_sequence ()
4412 {
4413   struct sequence_stack *tem = seq_stack;
4414
4415   first_insn = tem->first;
4416   last_insn = tem->last;
4417   seq_rtl_expr = tem->sequence_rtl_expr;
4418   seq_stack = tem->next;
4419
4420   free (tem);
4421 }
4422
4423 /* This works like end_sequence, but records the old sequence in FIRST
4424    and LAST.  */
4425
4426 void
4427 end_full_sequence (first, last)
4428      rtx *first, *last;
4429 {
4430   *first = first_insn;
4431   *last = last_insn;
4432   end_sequence();
4433 }
4434
4435 /* Return 1 if currently emitting into a sequence.  */
4436
4437 int
4438 in_sequence_p ()
4439 {
4440   return seq_stack != 0;
4441 }
4442
4443 /* Generate a SEQUENCE rtx containing the insns already emitted
4444    to the current sequence.
4445
4446    This is how the gen_... function from a DEFINE_EXPAND
4447    constructs the SEQUENCE that it returns.  */
4448
4449 rtx
4450 gen_sequence ()
4451 {
4452   rtx result;
4453   rtx tem;
4454   int i;
4455   int len;
4456
4457   /* Count the insns in the chain.  */
4458   len = 0;
4459   for (tem = first_insn; tem; tem = NEXT_INSN (tem))
4460     len++;
4461
4462   /* If only one insn, return it rather than a SEQUENCE.
4463      (Now that we cache SEQUENCE expressions, it isn't worth special-casing
4464      the case of an empty list.)
4465      We only return the pattern of an insn if its code is INSN and it
4466      has no notes.  This ensures that no information gets lost.  */
4467   if (len == 1
4468       && ! RTX_FRAME_RELATED_P (first_insn)
4469       && GET_CODE (first_insn) == INSN
4470       /* Don't throw away any reg notes.  */
4471       && REG_NOTES (first_insn) == 0)
4472     return PATTERN (first_insn);
4473
4474   result = gen_rtx_SEQUENCE (VOIDmode, rtvec_alloc (len));
4475
4476   for (i = 0, tem = first_insn; tem; tem = NEXT_INSN (tem), i++)
4477     XVECEXP (result, 0, i) = tem;
4478
4479   return result;
4480 }
4481 \f
4482 /* Put the various virtual registers into REGNO_REG_RTX.  */
4483
4484 void
4485 init_virtual_regs (es)
4486      struct emit_status *es;
4487 {
4488   rtx *ptr = es->x_regno_reg_rtx;
4489   ptr[VIRTUAL_INCOMING_ARGS_REGNUM] = virtual_incoming_args_rtx;
4490   ptr[VIRTUAL_STACK_VARS_REGNUM] = virtual_stack_vars_rtx;
4491   ptr[VIRTUAL_STACK_DYNAMIC_REGNUM] = virtual_stack_dynamic_rtx;
4492   ptr[VIRTUAL_OUTGOING_ARGS_REGNUM] = virtual_outgoing_args_rtx;
4493   ptr[VIRTUAL_CFA_REGNUM] = virtual_cfa_rtx;
4494 }
4495
4496 void
4497 clear_emit_caches ()
4498 {
4499   int i;
4500
4501   /* Clear the start_sequence/gen_sequence cache.  */
4502   for (i = 0; i < SEQUENCE_RESULT_SIZE; i++)
4503     sequence_result[i] = 0;
4504   free_insn = 0;
4505 }
4506 \f
4507 /* Used by copy_insn_1 to avoid copying SCRATCHes more than once.  */
4508 static rtx copy_insn_scratch_in[MAX_RECOG_OPERANDS];
4509 static rtx copy_insn_scratch_out[MAX_RECOG_OPERANDS];
4510 static int copy_insn_n_scratches;
4511
4512 /* When an insn is being copied by copy_insn_1, this is nonzero if we have
4513    copied an ASM_OPERANDS.
4514    In that case, it is the original input-operand vector.  */
4515 static rtvec orig_asm_operands_vector;
4516
4517 /* When an insn is being copied by copy_insn_1, this is nonzero if we have
4518    copied an ASM_OPERANDS.
4519    In that case, it is the copied input-operand vector.  */
4520 static rtvec copy_asm_operands_vector;
4521
4522 /* Likewise for the constraints vector.  */
4523 static rtvec orig_asm_constraints_vector;
4524 static rtvec copy_asm_constraints_vector;
4525
4526 /* Recursively create a new copy of an rtx for copy_insn.
4527    This function differs from copy_rtx in that it handles SCRATCHes and
4528    ASM_OPERANDs properly.
4529    Normally, this function is not used directly; use copy_insn as front end.
4530    However, you could first copy an insn pattern with copy_insn and then use
4531    this function afterwards to properly copy any REG_NOTEs containing
4532    SCRATCHes.  */
4533
4534 rtx
4535 copy_insn_1 (orig)
4536      rtx orig;
4537 {
4538   rtx copy;
4539   int i, j;
4540   RTX_CODE code;
4541   const char *format_ptr;
4542
4543   code = GET_CODE (orig);
4544
4545   switch (code)
4546     {
4547     case REG:
4548     case QUEUED:
4549     case CONST_INT:
4550     case CONST_DOUBLE:
4551     case CONST_VECTOR:
4552     case SYMBOL_REF:
4553     case CODE_LABEL:
4554     case PC:
4555     case CC0:
4556     case ADDRESSOF:
4557       return orig;
4558
4559     case SCRATCH:
4560       for (i = 0; i < copy_insn_n_scratches; i++)
4561         if (copy_insn_scratch_in[i] == orig)
4562           return copy_insn_scratch_out[i];
4563       break;
4564
4565     case CONST:
4566       /* CONST can be shared if it contains a SYMBOL_REF.  If it contains
4567          a LABEL_REF, it isn't sharable.  */
4568       if (GET_CODE (XEXP (orig, 0)) == PLUS
4569           && GET_CODE (XEXP (XEXP (orig, 0), 0)) == SYMBOL_REF
4570           && GET_CODE (XEXP (XEXP (orig, 0), 1)) == CONST_INT)
4571         return orig;
4572       break;
4573
4574       /* A MEM with a constant address is not sharable.  The problem is that
4575          the constant address may need to be reloaded.  If the mem is shared,
4576          then reloading one copy of this mem will cause all copies to appear
4577          to have been reloaded.  */
4578
4579     default:
4580       break;
4581     }
4582
4583   copy = rtx_alloc (code);
4584
4585   /* Copy the various flags, and other information.  We assume that
4586      all fields need copying, and then clear the fields that should
4587      not be copied.  That is the sensible default behavior, and forces
4588      us to explicitly document why we are *not* copying a flag.  */
4589   memcpy (copy, orig, sizeof (struct rtx_def) - sizeof (rtunion));
4590
4591   /* We do not copy the USED flag, which is used as a mark bit during
4592      walks over the RTL.  */
4593   copy->used = 0;
4594
4595   /* We do not copy JUMP, CALL, or FRAME_RELATED for INSNs.  */
4596   if (GET_RTX_CLASS (code) == 'i')
4597     {
4598       copy->jump = 0;
4599       copy->call = 0;
4600       copy->frame_related = 0;
4601     }
4602
4603   format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
4604
4605   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
4606     {
4607       copy->fld[i] = orig->fld[i];
4608       switch (*format_ptr++)
4609         {
4610         case 'e':
4611           if (XEXP (orig, i) != NULL)
4612             XEXP (copy, i) = copy_insn_1 (XEXP (orig, i));
4613           break;
4614
4615         case 'E':
4616         case 'V':
4617           if (XVEC (orig, i) == orig_asm_constraints_vector)
4618             XVEC (copy, i) = copy_asm_constraints_vector;
4619           else if (XVEC (orig, i) == orig_asm_operands_vector)
4620             XVEC (copy, i) = copy_asm_operands_vector;
4621           else if (XVEC (orig, i) != NULL)
4622             {
4623               XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
4624               for (j = 0; j < XVECLEN (copy, i); j++)
4625                 XVECEXP (copy, i, j) = copy_insn_1 (XVECEXP (orig, i, j));
4626             }
4627           break;
4628
4629         case 't':
4630         case 'w':
4631         case 'i':
4632         case 's':
4633         case 'S':
4634         case 'u':
4635         case '0':
4636           /* These are left unchanged.  */
4637           break;
4638
4639         default:
4640           abort ();
4641         }
4642     }
4643
4644   if (code == SCRATCH)
4645     {
4646       i = copy_insn_n_scratches++;
4647       if (i >= MAX_RECOG_OPERANDS)
4648         abort ();
4649       copy_insn_scratch_in[i] = orig;
4650       copy_insn_scratch_out[i] = copy;
4651     }
4652   else if (code == ASM_OPERANDS)
4653     {
4654       orig_asm_operands_vector = ASM_OPERANDS_INPUT_VEC (orig);
4655       copy_asm_operands_vector = ASM_OPERANDS_INPUT_VEC (copy);
4656       orig_asm_constraints_vector = ASM_OPERANDS_INPUT_CONSTRAINT_VEC (orig);
4657       copy_asm_constraints_vector = ASM_OPERANDS_INPUT_CONSTRAINT_VEC (copy);
4658     }
4659
4660   return copy;
4661 }
4662
4663 /* Create a new copy of an rtx.
4664    This function differs from copy_rtx in that it handles SCRATCHes and
4665    ASM_OPERANDs properly.
4666    INSN doesn't really have to be a full INSN; it could be just the
4667    pattern.  */
4668 rtx
4669 copy_insn (insn)
4670      rtx insn;
4671 {
4672   copy_insn_n_scratches = 0;
4673   orig_asm_operands_vector = 0;
4674   orig_asm_constraints_vector = 0;
4675   copy_asm_operands_vector = 0;
4676   copy_asm_constraints_vector = 0;
4677   return copy_insn_1 (insn);
4678 }
4679
4680 /* Initialize data structures and variables in this file
4681    before generating rtl for each function.  */
4682
4683 void
4684 init_emit ()
4685 {
4686   struct function *f = cfun;
4687
4688   f->emit = (struct emit_status *) xmalloc (sizeof (struct emit_status));
4689   first_insn = NULL;
4690   last_insn = NULL;
4691   seq_rtl_expr = NULL;
4692   cur_insn_uid = 1;
4693   reg_rtx_no = LAST_VIRTUAL_REGISTER + 1;
4694   last_linenum = 0;
4695   last_filename = 0;
4696   first_label_num = label_num;
4697   last_label_num = 0;
4698   seq_stack = NULL;
4699
4700   clear_emit_caches ();
4701
4702   /* Init the tables that describe all the pseudo regs.  */
4703
4704   f->emit->regno_pointer_align_length = LAST_VIRTUAL_REGISTER + 101;
4705
4706   f->emit->regno_pointer_align
4707     = (unsigned char *) xcalloc (f->emit->regno_pointer_align_length,
4708                                  sizeof (unsigned char));
4709
4710   regno_reg_rtx
4711     = (rtx *) xcalloc (f->emit->regno_pointer_align_length, sizeof (rtx));
4712
4713   f->emit->regno_decl
4714     = (tree *) xcalloc (f->emit->regno_pointer_align_length, sizeof (tree));
4715
4716   /* Put copies of all the virtual register rtx into regno_reg_rtx.  */
4717   init_virtual_regs (f->emit);
4718
4719   /* Indicate that the virtual registers and stack locations are
4720      all pointers.  */
4721   REG_POINTER (stack_pointer_rtx) = 1;
4722   REG_POINTER (frame_pointer_rtx) = 1;
4723   REG_POINTER (hard_frame_pointer_rtx) = 1;
4724   REG_POINTER (arg_pointer_rtx) = 1;
4725
4726   REG_POINTER (virtual_incoming_args_rtx) = 1;
4727   REG_POINTER (virtual_stack_vars_rtx) = 1;
4728   REG_POINTER (virtual_stack_dynamic_rtx) = 1;
4729   REG_POINTER (virtual_outgoing_args_rtx) = 1;
4730   REG_POINTER (virtual_cfa_rtx) = 1;
4731
4732 #ifdef STACK_BOUNDARY
4733   REGNO_POINTER_ALIGN (STACK_POINTER_REGNUM) = STACK_BOUNDARY;
4734   REGNO_POINTER_ALIGN (FRAME_POINTER_REGNUM) = STACK_BOUNDARY;
4735   REGNO_POINTER_ALIGN (HARD_FRAME_POINTER_REGNUM) = STACK_BOUNDARY;
4736   REGNO_POINTER_ALIGN (ARG_POINTER_REGNUM) = STACK_BOUNDARY;
4737
4738   REGNO_POINTER_ALIGN (VIRTUAL_INCOMING_ARGS_REGNUM) = STACK_BOUNDARY;
4739   REGNO_POINTER_ALIGN (VIRTUAL_STACK_VARS_REGNUM) = STACK_BOUNDARY;
4740   REGNO_POINTER_ALIGN (VIRTUAL_STACK_DYNAMIC_REGNUM) = STACK_BOUNDARY;
4741   REGNO_POINTER_ALIGN (VIRTUAL_OUTGOING_ARGS_REGNUM) = STACK_BOUNDARY;
4742   REGNO_POINTER_ALIGN (VIRTUAL_CFA_REGNUM) = BITS_PER_WORD;
4743 #endif
4744
4745 #ifdef INIT_EXPANDERS
4746   INIT_EXPANDERS;
4747 #endif
4748 }
4749
4750 /* Mark SS for GC.  */
4751
4752 static void
4753 mark_sequence_stack (ss)
4754      struct sequence_stack *ss;
4755 {
4756   while (ss)
4757     {
4758       ggc_mark_rtx (ss->first);
4759       ggc_mark_tree (ss->sequence_rtl_expr);
4760       ss = ss->next;
4761     }
4762 }
4763
4764 /* Mark ES for GC.  */
4765
4766 void
4767 mark_emit_status (es)
4768      struct emit_status *es;
4769 {
4770   rtx *r;
4771   tree *t;
4772   int i;
4773
4774   if (es == 0)
4775     return;
4776
4777   for (i = es->regno_pointer_align_length, r = es->x_regno_reg_rtx,
4778        t = es->regno_decl;
4779        i > 0; --i, ++r, ++t)
4780     {
4781       ggc_mark_rtx (*r);
4782       ggc_mark_tree (*t);
4783     }
4784
4785   mark_sequence_stack (es->sequence_stack);
4786   ggc_mark_tree (es->sequence_rtl_expr);
4787   ggc_mark_rtx (es->x_first_insn);
4788 }
4789
4790 /* Generate the constant 0.  */
4791
4792 static rtx
4793 gen_const_vector_0 (mode)
4794      enum machine_mode mode;
4795 {
4796   rtx tem;
4797   rtvec v;
4798   int units, i;
4799   enum machine_mode inner;
4800
4801   units = GET_MODE_NUNITS (mode);
4802   inner = GET_MODE_INNER (mode);
4803
4804   v = rtvec_alloc (units);
4805
4806   /* We need to call this function after we to set CONST0_RTX first.  */
4807   if (!CONST0_RTX (inner))
4808     abort ();
4809
4810   for (i = 0; i < units; ++i)
4811     RTVEC_ELT (v, i) = CONST0_RTX (inner);
4812
4813   tem = gen_rtx_CONST_VECTOR (mode, v);
4814   return tem;
4815 }
4816
4817 /* Create some permanent unique rtl objects shared between all functions.
4818    LINE_NUMBERS is nonzero if line numbers are to be generated.  */
4819
4820 void
4821 init_emit_once (line_numbers)
4822      int line_numbers;
4823 {
4824   int i;
4825   enum machine_mode mode;
4826   enum machine_mode double_mode;
4827
4828   /* Initialize the CONST_INT and memory attribute hash tables.  */
4829   const_int_htab = htab_create (37, const_int_htab_hash,
4830                                 const_int_htab_eq, NULL);
4831   ggc_add_deletable_htab (const_int_htab, 0, 0);
4832
4833   mem_attrs_htab = htab_create (37, mem_attrs_htab_hash,
4834                                 mem_attrs_htab_eq, NULL);
4835   ggc_add_deletable_htab (mem_attrs_htab, 0, mem_attrs_mark);
4836
4837   no_line_numbers = ! line_numbers;
4838
4839   /* Compute the word and byte modes.  */
4840
4841   byte_mode = VOIDmode;
4842   word_mode = VOIDmode;
4843   double_mode = VOIDmode;
4844
4845   for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
4846        mode = GET_MODE_WIDER_MODE (mode))
4847     {
4848       if (GET_MODE_BITSIZE (mode) == BITS_PER_UNIT
4849           && byte_mode == VOIDmode)
4850         byte_mode = mode;
4851
4852       if (GET_MODE_BITSIZE (mode) == BITS_PER_WORD
4853           && word_mode == VOIDmode)
4854         word_mode = mode;
4855     }
4856
4857   for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT); mode != VOIDmode;
4858        mode = GET_MODE_WIDER_MODE (mode))
4859     {
4860       if (GET_MODE_BITSIZE (mode) == DOUBLE_TYPE_SIZE
4861           && double_mode == VOIDmode)
4862         double_mode = mode;
4863     }
4864
4865   ptr_mode = mode_for_size (POINTER_SIZE, GET_MODE_CLASS (Pmode), 0);
4866
4867   /* Assign register numbers to the globally defined register rtx.
4868      This must be done at runtime because the register number field
4869      is in a union and some compilers can't initialize unions.  */
4870
4871   pc_rtx = gen_rtx (PC, VOIDmode);
4872   cc0_rtx = gen_rtx (CC0, VOIDmode);
4873   stack_pointer_rtx = gen_raw_REG (Pmode, STACK_POINTER_REGNUM);
4874   frame_pointer_rtx = gen_raw_REG (Pmode, FRAME_POINTER_REGNUM);
4875   if (hard_frame_pointer_rtx == 0)
4876     hard_frame_pointer_rtx = gen_raw_REG (Pmode,
4877                                           HARD_FRAME_POINTER_REGNUM);
4878   if (arg_pointer_rtx == 0)
4879     arg_pointer_rtx = gen_raw_REG (Pmode, ARG_POINTER_REGNUM);
4880   virtual_incoming_args_rtx =
4881     gen_raw_REG (Pmode, VIRTUAL_INCOMING_ARGS_REGNUM);
4882   virtual_stack_vars_rtx =
4883     gen_raw_REG (Pmode, VIRTUAL_STACK_VARS_REGNUM);
4884   virtual_stack_dynamic_rtx =
4885     gen_raw_REG (Pmode, VIRTUAL_STACK_DYNAMIC_REGNUM);
4886   virtual_outgoing_args_rtx =
4887     gen_raw_REG (Pmode, VIRTUAL_OUTGOING_ARGS_REGNUM);
4888   virtual_cfa_rtx = gen_raw_REG (Pmode, VIRTUAL_CFA_REGNUM);
4889
4890   /* These rtx must be roots if GC is enabled.  */
4891   ggc_add_rtx_root (global_rtl, GR_MAX);
4892
4893 #ifdef INIT_EXPANDERS
4894   /* This is to initialize {init|mark|free}_machine_status before the first
4895      call to push_function_context_to.  This is needed by the Chill front
4896      end which calls push_function_context_to before the first call to
4897      init_function_start.  */
4898   INIT_EXPANDERS;
4899 #endif
4900
4901   /* Create the unique rtx's for certain rtx codes and operand values.  */
4902
4903   /* Don't use gen_rtx here since gen_rtx in this case
4904      tries to use these variables.  */
4905   for (i = - MAX_SAVED_CONST_INT; i <= MAX_SAVED_CONST_INT; i++)
4906     const_int_rtx[i + MAX_SAVED_CONST_INT] =
4907       gen_rtx_raw_CONST_INT (VOIDmode, i);
4908   ggc_add_rtx_root (const_int_rtx, 2 * MAX_SAVED_CONST_INT + 1);
4909
4910   if (STORE_FLAG_VALUE >= - MAX_SAVED_CONST_INT
4911       && STORE_FLAG_VALUE <= MAX_SAVED_CONST_INT)
4912     const_true_rtx = const_int_rtx[STORE_FLAG_VALUE + MAX_SAVED_CONST_INT];
4913   else
4914     const_true_rtx = gen_rtx_CONST_INT (VOIDmode, STORE_FLAG_VALUE);
4915
4916   dconst0 = REAL_VALUE_ATOF ("0", double_mode);
4917   dconst1 = REAL_VALUE_ATOF ("1", double_mode);
4918   dconst2 = REAL_VALUE_ATOF ("2", double_mode);
4919   dconstm1 = REAL_VALUE_ATOF ("-1", double_mode);
4920
4921   for (i = 0; i <= 2; i++)
4922     {
4923       for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT); mode != VOIDmode;
4924            mode = GET_MODE_WIDER_MODE (mode))
4925         {
4926           rtx tem = rtx_alloc (CONST_DOUBLE);
4927           union real_extract u;
4928
4929           /* Zero any holes in a structure.  */
4930           memset ((char *) &u, 0, sizeof u);
4931           u.d = i == 0 ? dconst0 : i == 1 ? dconst1 : dconst2;
4932
4933           /* Avoid trailing garbage in the rtx.  */
4934           if (sizeof (u) < sizeof (HOST_WIDE_INT))
4935             CONST_DOUBLE_LOW (tem) = 0;
4936           if (sizeof (u) < 2 * sizeof (HOST_WIDE_INT))
4937             CONST_DOUBLE_HIGH (tem) = 0;
4938
4939           memcpy (&CONST_DOUBLE_LOW (tem), &u, sizeof u);
4940           CONST_DOUBLE_CHAIN (tem) = NULL_RTX;
4941           PUT_MODE (tem, mode);
4942
4943           const_tiny_rtx[i][(int) mode] = tem;
4944         }
4945
4946       const_tiny_rtx[i][(int) VOIDmode] = GEN_INT (i);
4947
4948       for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
4949            mode = GET_MODE_WIDER_MODE (mode))
4950         const_tiny_rtx[i][(int) mode] = GEN_INT (i);
4951
4952       for (mode = GET_CLASS_NARROWEST_MODE (MODE_PARTIAL_INT);
4953            mode != VOIDmode;
4954            mode = GET_MODE_WIDER_MODE (mode))
4955         const_tiny_rtx[i][(int) mode] = GEN_INT (i);
4956     }
4957
4958   for (mode = GET_CLASS_NARROWEST_MODE (MODE_VECTOR_INT);
4959        mode != VOIDmode;
4960        mode = GET_MODE_WIDER_MODE (mode))
4961     const_tiny_rtx[0][(int) mode] = gen_const_vector_0 (mode);
4962
4963   for (mode = GET_CLASS_NARROWEST_MODE (MODE_VECTOR_FLOAT);
4964        mode != VOIDmode;
4965        mode = GET_MODE_WIDER_MODE (mode))
4966     const_tiny_rtx[0][(int) mode] = gen_const_vector_0 (mode);
4967
4968   for (i = (int) CCmode; i < (int) MAX_MACHINE_MODE; ++i)
4969     if (GET_MODE_CLASS ((enum machine_mode) i) == MODE_CC)
4970       const_tiny_rtx[0][i] = const0_rtx;
4971
4972   const_tiny_rtx[0][(int) BImode] = const0_rtx;
4973   if (STORE_FLAG_VALUE == 1)
4974     const_tiny_rtx[1][(int) BImode] = const1_rtx;
4975
4976   /* For bounded pointers, `&const_tiny_rtx[0][0]' is not the same as
4977      `(rtx *) const_tiny_rtx'.  The former has bounds that only cover
4978      `const_tiny_rtx[0]', whereas the latter has bounds that cover all.  */
4979   ggc_add_rtx_root ((rtx *) const_tiny_rtx, sizeof const_tiny_rtx / sizeof (rtx));
4980   ggc_add_rtx_root (&const_true_rtx, 1);
4981
4982 #ifdef RETURN_ADDRESS_POINTER_REGNUM
4983   return_address_pointer_rtx
4984     = gen_raw_REG (Pmode, RETURN_ADDRESS_POINTER_REGNUM);
4985 #endif
4986
4987 #ifdef STRUCT_VALUE
4988   struct_value_rtx = STRUCT_VALUE;
4989 #else
4990   struct_value_rtx = gen_rtx_REG (Pmode, STRUCT_VALUE_REGNUM);
4991 #endif
4992
4993 #ifdef STRUCT_VALUE_INCOMING
4994   struct_value_incoming_rtx = STRUCT_VALUE_INCOMING;
4995 #else
4996 #ifdef STRUCT_VALUE_INCOMING_REGNUM
4997   struct_value_incoming_rtx
4998     = gen_rtx_REG (Pmode, STRUCT_VALUE_INCOMING_REGNUM);
4999 #else
5000   struct_value_incoming_rtx = struct_value_rtx;
5001 #endif
5002 #endif
5003
5004 #ifdef STATIC_CHAIN_REGNUM
5005   static_chain_rtx = gen_rtx_REG (Pmode, STATIC_CHAIN_REGNUM);
5006
5007 #ifdef STATIC_CHAIN_INCOMING_REGNUM
5008   if (STATIC_CHAIN_INCOMING_REGNUM != STATIC_CHAIN_REGNUM)
5009     static_chain_incoming_rtx
5010       = gen_rtx_REG (Pmode, STATIC_CHAIN_INCOMING_REGNUM);
5011   else
5012 #endif
5013     static_chain_incoming_rtx = static_chain_rtx;
5014 #endif
5015
5016 #ifdef STATIC_CHAIN
5017   static_chain_rtx = STATIC_CHAIN;
5018
5019 #ifdef STATIC_CHAIN_INCOMING
5020   static_chain_incoming_rtx = STATIC_CHAIN_INCOMING;
5021 #else
5022   static_chain_incoming_rtx = static_chain_rtx;
5023 #endif
5024 #endif
5025
5026   if (PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM)
5027     pic_offset_table_rtx = gen_raw_REG (Pmode, PIC_OFFSET_TABLE_REGNUM);
5028
5029   ggc_add_rtx_root (&pic_offset_table_rtx, 1);
5030   ggc_add_rtx_root (&struct_value_rtx, 1);
5031   ggc_add_rtx_root (&struct_value_incoming_rtx, 1);
5032   ggc_add_rtx_root (&static_chain_rtx, 1);
5033   ggc_add_rtx_root (&static_chain_incoming_rtx, 1);
5034   ggc_add_rtx_root (&return_address_pointer_rtx, 1);
5035 }
5036 \f
5037 /* Query and clear/ restore no_line_numbers.  This is used by the
5038    switch / case handling in stmt.c to give proper line numbers in
5039    warnings about unreachable code.  */
5040
5041 int
5042 force_line_numbers ()
5043 {
5044   int old = no_line_numbers;
5045
5046   no_line_numbers = 0;
5047   if (old)
5048     force_next_line_note ();
5049   return old;
5050 }
5051
5052 void
5053 restore_line_number_status (old_value)
5054      int old_value;
5055 {
5056   no_line_numbers = old_value;
5057 }