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