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 Free Software Foundation, Inc.
   4
   5 This file is part of GNU CC.
   6
   7 GNU CC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU CC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU CC; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.  */
  21
  22
  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
  58 /* Commonly used modes.  */
  59
  60 enum machine_mode byte_mode;    /* Mode whose width is BITS_PER_UNIT.  */
  61 enum machine_mode word_mode;    /* Mode whose width is BITS_PER_WORD.  */
  62 enum machine_mode double_mode;  /* Mode whose width is DOUBLE_TYPE_SIZE.  */
  63 enum machine_mode ptr_mode;     /* Mode whose width is POINTER_SIZE.  */
  64
  65
  66 /* This is *not* reset after each function.  It gives each CODE_LABEL
  67    in the entire compilation a unique label number.  */
  68
  69 static int label_num = 1;
  70
  71 /* Highest label number in current function.
  72    Zero means use the value of label_num instead.
  73    This is nonzero only when belatedly compiling an inline function.  */
  74
  75 static int last_label_num;
  76
  77 /* Value label_num had when set_new_first_and_last_label_number was called.
  78    If label_num has not changed since then, last_label_num is valid.  */
  79
  80 static int base_label_num;
  81
  82 /* Nonzero means do not generate NOTEs for source line numbers.  */
  83
  84 static int no_line_numbers;
  85
  86 /* Commonly used rtx's, so that we only need space for one copy.
  87    These are initialized once for the entire compilation.
  88    All of these except perhaps the floating-point CONST_DOUBLEs
  89    are unique; no other rtx-object will be equal to any of these.  */
  90
  91 rtx global_rtl[GR_MAX];
  92
  93 /* We record floating-point CONST_DOUBLEs in each floating-point mode for
  94    the values of 0, 1, and 2.  For the integer entries and VOIDmode, we
  95    record a copy of const[012]_rtx.  */
  96
  97 rtx const_tiny_rtx[3][(int) MAX_MACHINE_MODE];
  98
  99 rtx const_true_rtx;
 100
 101 REAL_VALUE_TYPE dconst0;
 102 REAL_VALUE_TYPE dconst1;
 103 REAL_VALUE_TYPE dconst2;
 104 REAL_VALUE_TYPE dconstm1;
 105
 106 /* All references to the following fixed hard registers go through
 107    these unique rtl objects.  On machines where the frame-pointer and
 108    arg-pointer are the same register, they use the same unique object.
 109
 110    After register allocation, other rtl objects which used to be pseudo-regs
 111    may be clobbered to refer to the frame-pointer register.
 112    But references that were originally to the frame-pointer can be
 113    distinguished from the others because they contain frame_pointer_rtx.
 114
 115    When to use frame_pointer_rtx and hard_frame_pointer_rtx is a little
 116    tricky: until register elimination has taken place hard_frame_pointer_rtx
 117    should be used if it is being set, and frame_pointer_rtx otherwise.  After
 118    register elimination hard_frame_pointer_rtx should always be used.
 119    On machines where the two registers are same (most) then these are the
 120    same.
 121
 122    In an inline procedure, the stack and frame pointer rtxs may not be
 123    used for anything else.  */
 124 rtx struct_value_rtx;           /* (REG:Pmode STRUCT_VALUE_REGNUM) */
 125 rtx struct_value_incoming_rtx;  /* (REG:Pmode STRUCT_VALUE_INCOMING_REGNUM) */
 126 rtx static_chain_rtx;           /* (REG:Pmode STATIC_CHAIN_REGNUM) */
 127 rtx static_chain_incoming_rtx;  /* (REG:Pmode STATIC_CHAIN_INCOMING_REGNUM) */
 128 rtx pic_offset_table_rtx;       /* (REG:Pmode PIC_OFFSET_TABLE_REGNUM) */
 129
 130 /* This is used to implement __builtin_return_address for some machines.
 131    See for instance the MIPS port.  */
 132 rtx return_address_pointer_rtx; /* (REG:Pmode RETURN_ADDRESS_POINTER_REGNUM) */
 133
 134 /* We make one copy of (const_int C) where C is in
 135    [- MAX_SAVED_CONST_INT, MAX_SAVED_CONST_INT]
 136    to save space during the compilation and simplify comparisons of
 137    integers.  */
 138
 139 rtx const_int_rtx[MAX_SAVED_CONST_INT * 2 + 1];
 140
 141 /* A hash table storing CONST_INTs whose absolute value is greater
 142    than MAX_SAVED_CONST_INT.  */
 143
 144 static htab_t const_int_htab;
 145
 146 /* start_sequence and gen_sequence can make a lot of rtx expressions which are
 147    shortly thrown away.  We use two mechanisms to prevent this waste:
 148
 149    For sizes up to 5 elements, we keep a SEQUENCE and its associated
 150    rtvec for use by gen_sequence.  One entry for each size is
 151    sufficient because most cases are calls to gen_sequence followed by
 152    immediately emitting the SEQUENCE.  Reuse is safe since emitting a
 153    sequence is destructive on the insn in it anyway and hence can't be
 154    redone.
 155
 156    We do not bother to save this cached data over nested function calls.
 157    Instead, we just reinitialize them.  */
 158
 159 #define SEQUENCE_RESULT_SIZE 5
 160
 161 static rtx sequence_result[SEQUENCE_RESULT_SIZE];
 162
 163 /* During RTL generation, we also keep a list of free INSN rtl codes.  */
 164 static rtx free_insn;
 165
 166 #define first_insn (cfun->emit->x_first_insn)
 167 #define last_insn (cfun->emit->x_last_insn)
 168 #define cur_insn_uid (cfun->emit->x_cur_insn_uid)
 169 #define last_linenum (cfun->emit->x_last_linenum)
 170 #define last_filename (cfun->emit->x_last_filename)
 171 #define first_label_num (cfun->emit->x_first_label_num)
 172
 173 static rtx make_jump_insn_raw           PARAMS ((rtx));
 174 static rtx make_call_insn_raw           PARAMS ((rtx));
 175 static rtx find_line_note               PARAMS ((rtx));
 176 static void mark_sequence_stack         PARAMS ((struct sequence_stack *));
 177 static void unshare_all_rtl_1           PARAMS ((rtx));
 178 static void unshare_all_decls           PARAMS ((tree));
 179 static void reset_used_decls            PARAMS ((tree));
 180 static hashval_t const_int_htab_hash    PARAMS ((const void *));
 181 static int const_int_htab_eq            PARAMS ((const void *,
 182                                                  const void *));
 183 static int rtx_htab_mark_1              PARAMS ((void **, void *));
 184 static void rtx_htab_mark               PARAMS ((void *));
 185
 186 \f
 187 /* Returns a hash code for X (which is a really a CONST_INT).  */
 188
 189 static hashval_t
 190 const_int_htab_hash (x)
 191      const void *x;
 192 {
 193   return (hashval_t) INTVAL ((const struct rtx_def *) x);
 194 }
 195
 196 /* Returns non-zero if the value represented by X (which is really a
 197    CONST_INT) is the same as that given by Y (which is really a
 198    HOST_WIDE_INT *).  */
 199
 200 static int
 201 const_int_htab_eq (x, y)
 202      const void *x;
 203      const void *y;
 204 {
 205   return (INTVAL ((const struct rtx_def *) x) == *((const HOST_WIDE_INT *) y));
 206 }
 207
 208 /* Mark the hash-table element X (which is really a pointer to an
 209    rtx).  */
 210
 211 static int
 212 rtx_htab_mark_1 (x, data)
 213      void **x;
 214      void *data ATTRIBUTE_UNUSED;
 215 {
 216   ggc_mark_rtx (*x);
 217   return 1;
 218 }
 219
 220 /* Mark all the elements of HTAB (which is really an htab_t full of
 221    rtxs).  */
 222
 223 static void
 224 rtx_htab_mark (htab)
 225      void *htab;
 226 {
 227   htab_traverse (*((htab_t *) htab), rtx_htab_mark_1, NULL);
 228 }
 229
 230 /* Generate a new REG rtx.  Make sure ORIGINAL_REGNO is set properly, and
 231    don't attempt to share with the various global pieces of rtl (such as
 232    frame_pointer_rtx).  */
 233
 234 rtx
 235 gen_raw_REG (mode, regno)
 236      enum machine_mode mode;
 237      int regno;
 238 {
 239   rtx x = gen_rtx_raw_REG (mode, regno);
 240   ORIGINAL_REGNO (x) = regno;
 241   return x;
 242 }
 243
 244 /* There are some RTL codes that require special attention; the generation
 245    functions do the raw handling.  If you add to this list, modify
 246    special_rtx in gengenrtl.c as well.  */
 247
 248 rtx
 249 gen_rtx_CONST_INT (mode, arg)
 250      enum machine_mode mode ATTRIBUTE_UNUSED;
 251      HOST_WIDE_INT arg;
 252 {
 253   void **slot;
 254
 255   if (arg >= - MAX_SAVED_CONST_INT && arg <= MAX_SAVED_CONST_INT)
 256     return const_int_rtx[arg + MAX_SAVED_CONST_INT];
 257
 258 #if STORE_FLAG_VALUE != 1 && STORE_FLAG_VALUE != -1
 259   if (const_true_rtx && arg == STORE_FLAG_VALUE)
 260     return const_true_rtx;
 261 #endif
 262
 263   /* Look up the CONST_INT in the hash table.  */
 264   slot = htab_find_slot_with_hash (const_int_htab, &arg,
 265                                    (hashval_t) arg, INSERT);
 266   if (*slot == 0)
 267     *slot = gen_rtx_raw_CONST_INT (VOIDmode, arg);
 268
 269   return (rtx) *slot;
 270 }
 271
 272 /* CONST_DOUBLEs needs special handling because their length is known
 273    only at run-time.  */
 274
 275 rtx
 276 gen_rtx_CONST_DOUBLE (mode, arg0, arg1, arg2)
 277      enum machine_mode mode;
 278      rtx arg0;
 279      HOST_WIDE_INT arg1, arg2;
 280 {
 281   rtx r = rtx_alloc (CONST_DOUBLE);
 282   int i;
 283
 284   PUT_MODE (r, mode);
 285   XEXP (r, 0) = arg0;
 286   X0EXP (r, 1) = NULL_RTX;
 287   XWINT (r, 2) = arg1;
 288   XWINT (r, 3) = arg2;
 289
 290   for (i = GET_RTX_LENGTH (CONST_DOUBLE) - 1; i > 3; --i)
 291     XWINT (r, i) = 0;
 292
 293   return r;
 294 }
 295
 296 rtx
 297 gen_rtx_REG (mode, regno)
 298      enum machine_mode mode;
 299      int regno;
 300 {
 301   /* In case the MD file explicitly references the frame pointer, have
 302      all such references point to the same frame pointer.  This is
 303      used during frame pointer elimination to distinguish the explicit
 304      references to these registers from pseudos that happened to be
 305      assigned to them.
 306
 307      If we have eliminated the frame pointer or arg pointer, we will
 308      be using it as a normal register, for example as a spill
 309      register.  In such cases, we might be accessing it in a mode that
 310      is not Pmode and therefore cannot use the pre-allocated rtx.
 311
 312      Also don't do this when we are making new REGs in reload, since
 313      we don't want to get confused with the real pointers.  */
 314
 315   if (mode == Pmode && !reload_in_progress)
 316     {
 317       if (regno == FRAME_POINTER_REGNUM)
 318         return frame_pointer_rtx;
 319 #if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
 320       if (regno == HARD_FRAME_POINTER_REGNUM)
 321         return hard_frame_pointer_rtx;
 322 #endif
 323 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM && HARD_FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
 324       if (regno == ARG_POINTER_REGNUM)
 325         return arg_pointer_rtx;
 326 #endif
 327 #ifdef RETURN_ADDRESS_POINTER_REGNUM
 328       if (regno == RETURN_ADDRESS_POINTER_REGNUM)
 329         return return_address_pointer_rtx;
 330 #endif
 331       if (regno == STACK_POINTER_REGNUM)
 332         return stack_pointer_rtx;
 333     }
 334
 335   return gen_raw_REG (mode, regno);
 336 }
 337
 338 rtx
 339 gen_rtx_MEM (mode, addr)
 340      enum machine_mode mode;
 341      rtx addr;
 342 {
 343   rtx rt = gen_rtx_raw_MEM (mode, addr);
 344
 345   /* This field is not cleared by the mere allocation of the rtx, so
 346      we clear it here.  */
 347   MEM_ALIAS_SET (rt) = 0;
 348
 349   return rt;
 350 }
 351 \f
 352 /* rtx gen_rtx (code, mode, [element1, ..., elementn])
 353 **
 354 **          This routine generates an RTX of the size specified by
 355 **      <code>, which is an RTX code.   The RTX structure is initialized
 356 **      from the arguments <element1> through <elementn>, which are
 357 **      interpreted according to the specific RTX type's format.   The
 358 **      special machine mode associated with the rtx (if any) is specified
 359 **      in <mode>.
 360 **
 361 **          gen_rtx can be invoked in a way which resembles the lisp-like
 362 **      rtx it will generate.   For example, the following rtx structure:
 363 **
 364 **            (plus:QI (mem:QI (reg:SI 1))
 365 **                     (mem:QI (plusw:SI (reg:SI 2) (reg:SI 3))))
 366 **
 367 **              ...would be generated by the following C code:
 368 **
 369 **              gen_rtx (PLUS, QImode,
 370 **                  gen_rtx (MEM, QImode,
 371 **                      gen_rtx (REG, SImode, 1)),
 372 **                  gen_rtx (MEM, QImode,
 373 **                      gen_rtx (PLUS, SImode,
 374 **                          gen_rtx (REG, SImode, 2),
 375 **                          gen_rtx (REG, SImode, 3)))),
 376 */
 377
 378 /*VARARGS2*/
 379 rtx
 380 gen_rtx VPARAMS ((enum rtx_code code, enum machine_mode mode, ...))
 381 {
 382 #ifndef ANSI_PROTOTYPES
 383   enum rtx_code code;
 384   enum machine_mode mode;
 385 #endif
 386   va_list p;
 387   register int i;               /* Array indices...                     */
 388   register const char *fmt;     /* Current rtx's format...              */
 389   register rtx rt_val;          /* RTX to return to caller...           */
 390
 391   VA_START (p, mode);
 392
 393 #ifndef ANSI_PROTOTYPES
 394   code = va_arg (p, enum rtx_code);
 395   mode = va_arg (p, enum machine_mode);
 396 #endif
 397
 398   switch (code)
 399     {
 400     case CONST_INT:
 401       rt_val = gen_rtx_CONST_INT (mode, va_arg (p, HOST_WIDE_INT));
 402       break;
 403
 404     case CONST_DOUBLE:
 405       {
 406         rtx arg0 = va_arg (p, rtx);
 407         HOST_WIDE_INT arg1 = va_arg (p, HOST_WIDE_INT);
 408         HOST_WIDE_INT arg2 = va_arg (p, HOST_WIDE_INT);
 409         rt_val = gen_rtx_CONST_DOUBLE (mode, arg0, arg1, arg2);
 410       }
 411       break;
 412
 413     case REG:
 414       rt_val = gen_rtx_REG (mode, va_arg (p, int));
 415       break;
 416
 417     case MEM:
 418       rt_val = gen_rtx_MEM (mode, va_arg (p, rtx));
 419       break;
 420
 421     default:
 422       rt_val = rtx_alloc (code);        /* Allocate the storage space.  */
 423       rt_val->mode = mode;              /* Store the machine mode...  */
 424
 425       fmt = GET_RTX_FORMAT (code);      /* Find the right format...  */
 426       for (i = 0; i < GET_RTX_LENGTH (code); i++)
 427         {
 428           switch (*fmt++)
 429             {
 430             case '0':           /* Unused field.  */
 431               break;
 432
 433             case 'i':           /* An integer?  */
 434               XINT (rt_val, i) = va_arg (p, int);
 435               break;
 436
 437             case 'w':           /* A wide integer? */
 438               XWINT (rt_val, i) = va_arg (p, HOST_WIDE_INT);
 439               break;
 440
 441             case 's':           /* A string?  */
 442               XSTR (rt_val, i) = va_arg (p, char *);
 443               break;
 444
 445             case 'e':           /* An expression?  */
 446             case 'u':           /* An insn?  Same except when printing.  */
 447               XEXP (rt_val, i) = va_arg (p, rtx);
 448               break;
 449
 450             case 'E':           /* An RTX vector?  */
 451               XVEC (rt_val, i) = va_arg (p, rtvec);
 452               break;
 453
 454             case 'b':           /* A bitmap? */
 455               XBITMAP (rt_val, i) = va_arg (p, bitmap);
 456               break;
 457
 458             case 't':           /* A tree? */
 459               XTREE (rt_val, i) = va_arg (p, tree);
 460               break;
 461
 462             default:
 463               abort ();
 464             }
 465         }
 466       break;
 467     }
 468
 469   va_end (p);
 470   return rt_val;
 471 }
 472
 473 /* gen_rtvec (n, [rt1, ..., rtn])
 474 **
 475 **          This routine creates an rtvec and stores within it the
 476 **      pointers to rtx's which are its arguments.
 477 */
 478
 479 /*VARARGS1*/
 480 rtvec
 481 gen_rtvec VPARAMS ((int n, ...))
 482 {
 483 #ifndef ANSI_PROTOTYPES
 484   int n;
 485 #endif
 486   int i;
 487   va_list p;
 488   rtx *vector;
 489
 490   VA_START (p, n);
 491
 492 #ifndef ANSI_PROTOTYPES
 493   n = va_arg (p, int);
 494 #endif
 495
 496   if (n == 0)
 497     return NULL_RTVEC;          /* Don't allocate an empty rtvec...     */
 498
 499   vector = (rtx *) alloca (n * sizeof (rtx));
 500
 501   for (i = 0; i < n; i++)
 502     vector[i] = va_arg (p, rtx);
 503   va_end (p);
 504
 505   return gen_rtvec_v (n, vector);
 506 }
 507
 508 rtvec
 509 gen_rtvec_v (n, argp)
 510      int n;
 511      rtx *argp;
 512 {
 513   register int i;
 514   register rtvec rt_val;
 515
 516   if (n == 0)
 517     return NULL_RTVEC;          /* Don't allocate an empty rtvec...     */
 518
 519   rt_val = rtvec_alloc (n);     /* Allocate an rtvec...                 */
 520
 521   for (i = 0; i < n; i++)
 522     rt_val->elem[i] = *argp++;
 523
 524   return rt_val;
 525 }
 526
 527 \f
 528 /* Generate a REG rtx for a new pseudo register of mode MODE.
 529    This pseudo is assigned the next sequential register number.  */
 530
 531 rtx
 532 gen_reg_rtx (mode)
 533      enum machine_mode mode;
 534 {
 535   struct function *f = cfun;
 536   register rtx val;
 537
 538   /* Don't let anything called after initial flow analysis create new
 539      registers.  */
 540   if (no_new_pseudos)
 541     abort ();
 542
 543   if (generating_concat_p
 544       && (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT
 545           || GET_MODE_CLASS (mode) == MODE_COMPLEX_INT))
 546     {
 547       /* For complex modes, don't make a single pseudo.
 548          Instead, make a CONCAT of two pseudos.
 549          This allows noncontiguous allocation of the real and imaginary parts,
 550          which makes much better code.  Besides, allocating DCmode
 551          pseudos overstrains reload on some machines like the 386.  */
 552       rtx realpart, imagpart;
 553       int size = GET_MODE_UNIT_SIZE (mode);
 554       enum machine_mode partmode
 555         = mode_for_size (size * BITS_PER_UNIT,
 556                          (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT
 557                           ? MODE_FLOAT : MODE_INT),
 558                          0);
 559
 560       realpart = gen_reg_rtx (partmode);
 561       imagpart = gen_reg_rtx (partmode);
 562       return gen_rtx_CONCAT (mode, realpart, imagpart);
 563     }
 564
 565   /* Make sure regno_pointer_align and regno_reg_rtx are large enough
 566      to have an element for this pseudo reg number.  */
 567
 568   if (reg_rtx_no == f->emit->regno_pointer_align_length)
 569     {
 570       int old_size = f->emit->regno_pointer_align_length;
 571       rtx *new1;
 572       char *new;
 573       new = xrealloc (f->emit->regno_pointer_align, old_size * 2);
 574       memset (new + old_size, 0, old_size);
 575       f->emit->regno_pointer_align = (unsigned char *) new;
 576
 577       new1 = (rtx *) xrealloc (f->emit->x_regno_reg_rtx,
 578                                old_size * 2 * sizeof (rtx));
 579       memset (new1 + old_size, 0, old_size * sizeof (rtx));
 580       regno_reg_rtx = new1;
 581
 582       f->emit->regno_pointer_align_length = old_size * 2;
 583     }
 584
 585   val = gen_raw_REG (mode, reg_rtx_no);
 586   regno_reg_rtx[reg_rtx_no++] = val;
 587   return val;
 588 }
 589
 590 /* Identify REG (which may be a CONCAT) as a user register.  */
 591
 592 void
 593 mark_user_reg (reg)
 594      rtx reg;
 595 {
 596   if (GET_CODE (reg) == CONCAT)
 597     {
 598       REG_USERVAR_P (XEXP (reg, 0)) = 1;
 599       REG_USERVAR_P (XEXP (reg, 1)) = 1;
 600     }
 601   else if (GET_CODE (reg) == REG)
 602     REG_USERVAR_P (reg) = 1;
 603   else
 604     abort ();
 605 }
 606
 607 /* Identify REG as a probable pointer register and show its alignment
 608    as ALIGN, if nonzero.  */
 609
 610 void
 611 mark_reg_pointer (reg, align)
 612      rtx reg;
 613      int align;
 614 {
 615   if (! REG_POINTER (reg))
 616     {
 617       REG_POINTER (reg) = 1;
 618
 619       if (align)
 620         REGNO_POINTER_ALIGN (REGNO (reg)) = align;
 621     }
 622   else if (align && align < REGNO_POINTER_ALIGN (REGNO (reg)))
 623     /* We can no-longer be sure just how aligned this pointer is */
 624     REGNO_POINTER_ALIGN (REGNO (reg)) = align;
 625 }
 626
 627 /* Return 1 plus largest pseudo reg number used in the current function.  */
 628
 629 int
 630 max_reg_num ()
 631 {
 632   return reg_rtx_no;
 633 }
 634
 635 /* Return 1 + the largest label number used so far in the current function.  */
 636
 637 int
 638 max_label_num ()
 639 {
 640   if (last_label_num && label_num == base_label_num)
 641     return last_label_num;
 642   return label_num;
 643 }
 644
 645 /* Return first label number used in this function (if any were used).  */
 646
 647 int
 648 get_first_label_num ()
 649 {
 650   return first_label_num;
 651 }
 652 \f
 653 /* Return a value representing some low-order bits of X, where the number
 654    of low-order bits is given by MODE.  Note that no conversion is done
 655    between floating-point and fixed-point values, rather, the bit
 656    representation is returned.
 657
 658    This function handles the cases in common between gen_lowpart, below,
 659    and two variants in cse.c and combine.c.  These are the cases that can
 660    be safely handled at all points in the compilation.
 661
 662    If this is not a case we can handle, return 0.  */
 663
 664 rtx
 665 gen_lowpart_common (mode, x)
 666      enum machine_mode mode;
 667      register rtx x;
 668 {
 669   int word = 0;
 670
 671   if (GET_MODE (x) == mode)
 672     return x;
 673
 674   /* MODE must occupy no more words than the mode of X.  */
 675   if (GET_MODE (x) != VOIDmode
 676       && ((GET_MODE_SIZE (mode) + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD
 677           > ((GET_MODE_SIZE (GET_MODE (x)) + (UNITS_PER_WORD - 1))
 678              / UNITS_PER_WORD)))
 679     return 0;
 680
 681   if (WORDS_BIG_ENDIAN && GET_MODE_SIZE (GET_MODE (x)) > UNITS_PER_WORD)
 682     word = ((GET_MODE_SIZE (GET_MODE (x))
 683              - MAX (GET_MODE_SIZE (mode), UNITS_PER_WORD))
 684             / UNITS_PER_WORD);
 685
 686   if ((GET_CODE (x) == ZERO_EXTEND || GET_CODE (x) == SIGN_EXTEND)
 687       && (GET_MODE_CLASS (mode) == MODE_INT
 688           || GET_MODE_CLASS (mode) == MODE_PARTIAL_INT))
 689     {
 690       /* If we are getting the low-order part of something that has been
 691          sign- or zero-extended, we can either just use the object being
 692          extended or make a narrower extension.  If we want an even smaller
 693          piece than the size of the object being extended, call ourselves
 694          recursively.
 695
 696          This case is used mostly by combine and cse.  */
 697
 698       if (GET_MODE (XEXP (x, 0)) == mode)
 699         return XEXP (x, 0);
 700       else if (GET_MODE_SIZE (mode) < GET_MODE_SIZE (GET_MODE (XEXP (x, 0))))
 701         return gen_lowpart_common (mode, XEXP (x, 0));
 702       else if (GET_MODE_SIZE (mode) < GET_MODE_SIZE (GET_MODE (x)))
 703         return gen_rtx_fmt_e (GET_CODE (x), mode, XEXP (x, 0));
 704     }
 705   else if (GET_CODE (x) == SUBREG
 706            && (GET_MODE_SIZE (mode) <= GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)))
 707                || GET_MODE_SIZE (mode) <= UNITS_PER_WORD
 708                || GET_MODE_SIZE (mode) == GET_MODE_UNIT_SIZE (GET_MODE (x))))
 709     return (GET_MODE (SUBREG_REG (x)) == mode && SUBREG_WORD (x) == 0
 710             ? SUBREG_REG (x)
 711             : gen_rtx_SUBREG (mode, SUBREG_REG (x), SUBREG_WORD (x) + word));
 712   else if (GET_CODE (x) == REG)
 713     {
 714       /* Let the backend decide how many registers to skip.  This is needed
 715          in particular for Sparc64 where fp regs are smaller than a word.  */
 716       /* ??? Note that subregs are now ambiguous, in that those against
 717          pseudos are sized by the Word Size, while those against hard
 718          regs are sized by the underlying register size.  Better would be
 719          to always interpret the subreg offset parameter as bytes or bits.  */
 720
 721       if (WORDS_BIG_ENDIAN && REGNO (x) < FIRST_PSEUDO_REGISTER
 722           && GET_MODE_SIZE (GET_MODE (x)) > GET_MODE_SIZE (mode))
 723         word = (HARD_REGNO_NREGS (REGNO (x), GET_MODE (x))
 724                 - HARD_REGNO_NREGS (REGNO (x), mode));
 725
 726       /* If the register is not valid for MODE, return 0.  If we don't
 727          do this, there is no way to fix up the resulting REG later.
 728          But we do do this if the current REG is not valid for its
 729          mode.  This latter is a kludge, but is required due to the
 730          way that parameters are passed on some machines, most
 731          notably Sparc.  */
 732       if (REGNO (x) < FIRST_PSEUDO_REGISTER
 733           && ! HARD_REGNO_MODE_OK (REGNO (x) + word, mode)
 734           && HARD_REGNO_MODE_OK (REGNO (x), GET_MODE (x)))
 735         return 0;
 736       else if (REGNO (x) < FIRST_PSEUDO_REGISTER
 737                /* integrate.c can't handle parts of a return value register. */
 738                && (! REG_FUNCTION_VALUE_P (x)
 739                    || ! rtx_equal_function_value_matters)
 740 #ifdef CLASS_CANNOT_CHANGE_MODE
 741                && ! (CLASS_CANNOT_CHANGE_MODE_P (mode, GET_MODE (x))
 742                      && GET_MODE_CLASS (GET_MODE (x)) != MODE_COMPLEX_INT
 743                      && GET_MODE_CLASS (GET_MODE (x)) != MODE_COMPLEX_FLOAT
 744                      && (TEST_HARD_REG_BIT
 745                          (reg_class_contents[(int) CLASS_CANNOT_CHANGE_MODE],
 746                           REGNO (x))))
 747 #endif
 748                /* We want to keep the stack, frame, and arg pointers
 749                   special.  */
 750                && x != frame_pointer_rtx
 751 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
 752                && x != arg_pointer_rtx
 753 #endif
 754                && x != stack_pointer_rtx)
 755         return gen_rtx_REG (mode, REGNO (x) + word);
 756       else
 757         return gen_rtx_SUBREG (mode, x, word);
 758     }
 759   /* If X is a CONST_INT or a CONST_DOUBLE, extract the appropriate bits
 760      from the low-order part of the constant.  */
 761   else if ((GET_MODE_CLASS (mode) == MODE_INT
 762             || GET_MODE_CLASS (mode) == MODE_PARTIAL_INT)
 763            && GET_MODE (x) == VOIDmode
 764            && (GET_CODE (x) == CONST_INT || GET_CODE (x) == CONST_DOUBLE))
 765     {
 766       /* If MODE is twice the host word size, X is already the desired
 767          representation.  Otherwise, if MODE is wider than a word, we can't
 768          do this.  If MODE is exactly a word, return just one CONST_INT.  */
 769
 770       if (GET_MODE_BITSIZE (mode) >= 2 * HOST_BITS_PER_WIDE_INT)
 771         return x;
 772       else if (GET_MODE_BITSIZE (mode) > HOST_BITS_PER_WIDE_INT)
 773         return 0;
 774       else if (GET_MODE_BITSIZE (mode) == HOST_BITS_PER_WIDE_INT)
 775         return (GET_CODE (x) == CONST_INT ? x
 776                 : GEN_INT (CONST_DOUBLE_LOW (x)));
 777       else
 778         {
 779           /* MODE must be narrower than HOST_BITS_PER_WIDE_INT.  */
 780           HOST_WIDE_INT val = (GET_CODE (x) == CONST_INT ? INTVAL (x)
 781                                : CONST_DOUBLE_LOW (x));
 782
 783           /* Sign extend to HOST_WIDE_INT.  */
 784           val = trunc_int_for_mode (val, mode);
 785
 786           return (GET_CODE (x) == CONST_INT && INTVAL (x) == val ? x
 787                   : GEN_INT (val));
 788         }
 789     }
 790
 791 #ifndef REAL_ARITHMETIC
 792   /* If X is an integral constant but we want it in floating-point, it
 793      must be the case that we have a union of an integer and a floating-point
 794      value.  If the machine-parameters allow it, simulate that union here
 795      and return the result.  The two-word and single-word cases are
 796      different.  */
 797
 798   else if (((HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT
 799              && HOST_BITS_PER_WIDE_INT == BITS_PER_WORD)
 800             || flag_pretend_float)
 801            && GET_MODE_CLASS (mode) == MODE_FLOAT
 802            && GET_MODE_SIZE (mode) == UNITS_PER_WORD
 803            && GET_CODE (x) == CONST_INT
 804            && sizeof (float) * HOST_BITS_PER_CHAR == HOST_BITS_PER_WIDE_INT)
 805     {
 806       union {HOST_WIDE_INT i; float d; } u;
 807
 808       u.i = INTVAL (x);
 809       return CONST_DOUBLE_FROM_REAL_VALUE (u.d, mode);
 810     }
 811   else if (((HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT
 812              && HOST_BITS_PER_WIDE_INT == BITS_PER_WORD)
 813             || flag_pretend_float)
 814            && GET_MODE_CLASS (mode) == MODE_FLOAT
 815            && GET_MODE_SIZE (mode) == 2 * UNITS_PER_WORD
 816            && (GET_CODE (x) == CONST_INT || GET_CODE (x) == CONST_DOUBLE)
 817            && GET_MODE (x) == VOIDmode
 818            && (sizeof (double) * HOST_BITS_PER_CHAR
 819                == 2 * HOST_BITS_PER_WIDE_INT))
 820     {
 821       union {HOST_WIDE_INT i[2]; double d; } u;
 822       HOST_WIDE_INT low, high;
 823
 824       if (GET_CODE (x) == CONST_INT)
 825         low = INTVAL (x), high = low >> (HOST_BITS_PER_WIDE_INT -1);
 826       else
 827         low = CONST_DOUBLE_LOW (x), high = CONST_DOUBLE_HIGH (x);
 828
 829 #ifdef HOST_WORDS_BIG_ENDIAN
 830       u.i[0] = high, u.i[1] = low;
 831 #else
 832       u.i[0] = low, u.i[1] = high;
 833 #endif
 834
 835       return CONST_DOUBLE_FROM_REAL_VALUE (u.d, mode);
 836     }
 837
 838   /* Similarly, if this is converting a floating-point value into a
 839      single-word integer.  Only do this is the host and target parameters are
 840      compatible.  */
 841
 842   else if (((HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT
 843              && HOST_BITS_PER_WIDE_INT == BITS_PER_WORD)
 844             || flag_pretend_float)
 845            && (GET_MODE_CLASS (mode) == MODE_INT
 846                || GET_MODE_CLASS (mode) == MODE_PARTIAL_INT)
 847            && GET_CODE (x) == CONST_DOUBLE
 848            && GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT
 849            && GET_MODE_BITSIZE (mode) == BITS_PER_WORD)
 850     return operand_subword (x, word, 0, GET_MODE (x));
 851
 852   /* Similarly, if this is converting a floating-point value into a
 853      two-word integer, we can do this one word at a time and make an
 854      integer.  Only do this is the host and target parameters are
 855      compatible.  */
 856
 857   else if (((HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT
 858              && HOST_BITS_PER_WIDE_INT == BITS_PER_WORD)
 859             || flag_pretend_float)
 860            && (GET_MODE_CLASS (mode) == MODE_INT
 861                || GET_MODE_CLASS (mode) == MODE_PARTIAL_INT)
 862            && GET_CODE (x) == CONST_DOUBLE
 863            && GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT
 864            && GET_MODE_BITSIZE (mode) == 2 * BITS_PER_WORD)
 865     {
 866       rtx lowpart
 867         = operand_subword (x, word + WORDS_BIG_ENDIAN, 0, GET_MODE (x));
 868       rtx highpart
 869         = operand_subword (x, word + ! WORDS_BIG_ENDIAN, 0, GET_MODE (x));
 870
 871       if (lowpart && GET_CODE (lowpart) == CONST_INT
 872           && highpart && GET_CODE (highpart) == CONST_INT)
 873         return immed_double_const (INTVAL (lowpart), INTVAL (highpart), mode);
 874     }
 875 #else /* ifndef REAL_ARITHMETIC */
 876
 877   /* When we have a FP emulator, we can handle all conversions between
 878      FP and integer operands.  This simplifies reload because it
 879      doesn't have to deal with constructs like (subreg:DI
 880      (const_double:SF ...)) or (subreg:DF (const_int ...)).  */
 881
 882   else if (mode == SFmode
 883            && GET_CODE (x) == CONST_INT)
 884     {
 885       REAL_VALUE_TYPE r;
 886       HOST_WIDE_INT i;
 887
 888       i = INTVAL (x);
 889       r = REAL_VALUE_FROM_TARGET_SINGLE (i);
 890       return CONST_DOUBLE_FROM_REAL_VALUE (r, mode);
 891     }
 892   else if (mode == DFmode
 893            && (GET_CODE (x) == CONST_INT || GET_CODE (x) == CONST_DOUBLE)
 894            && GET_MODE (x) == VOIDmode)
 895     {
 896       REAL_VALUE_TYPE r;
 897       HOST_WIDE_INT i[2];
 898       HOST_WIDE_INT low, high;
 899
 900       if (GET_CODE (x) == CONST_INT)
 901         {
 902           low = INTVAL (x);
 903           high = low >> (HOST_BITS_PER_WIDE_INT - 1);
 904         }
 905       else
 906         {
 907           low = CONST_DOUBLE_LOW (x);
 908           high = CONST_DOUBLE_HIGH (x);
 909         }
 910
 911       /* REAL_VALUE_TARGET_DOUBLE takes the addressing order of the
 912          target machine.  */
 913       if (WORDS_BIG_ENDIAN)
 914         i[0] = high, i[1] = low;
 915       else
 916         i[0] = low, i[1] = high;
 917
 918       r = REAL_VALUE_FROM_TARGET_DOUBLE (i);
 919       return CONST_DOUBLE_FROM_REAL_VALUE (r, mode);
 920     }
 921   else if ((GET_MODE_CLASS (mode) == MODE_INT
 922             || GET_MODE_CLASS (mode) == MODE_PARTIAL_INT)
 923            && GET_CODE (x) == CONST_DOUBLE
 924            && GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
 925     {
 926       REAL_VALUE_TYPE r;
 927       long i[4];  /* Only the low 32 bits of each 'long' are used.  */
 928       int endian = WORDS_BIG_ENDIAN ? 1 : 0;
 929
 930       REAL_VALUE_FROM_CONST_DOUBLE (r, x);
 931       switch (GET_MODE (x))
 932         {
 933         case SFmode:
 934           REAL_VALUE_TO_TARGET_SINGLE (r, i[endian]);
 935           i[1 - endian] = 0;
 936           break;
 937         case DFmode:
 938           REAL_VALUE_TO_TARGET_DOUBLE (r, i);
 939           break;
 940 #if LONG_DOUBLE_TYPE_SIZE == 96
 941         case XFmode:
 942           REAL_VALUE_TO_TARGET_LONG_DOUBLE (r, i + endian);
 943           i[3-3*endian] = 0;
 944 #else
 945         case TFmode:
 946           REAL_VALUE_TO_TARGET_LONG_DOUBLE (r, i);
 947 #endif
 948           break;
 949         default:
 950           abort ();
 951         }
 952
 953       /* Now, pack the 32-bit elements of the array into a CONST_DOUBLE
 954          and return it.  */
 955 #if HOST_BITS_PER_WIDE_INT == 32
 956       return immed_double_const (i[endian], i[1 - endian], mode);
 957 #else
 958       {
 959         int c;
 960
 961         if (HOST_BITS_PER_WIDE_INT != 64)
 962           abort ();
 963
 964         for (c = 0; c < 4; c++)
 965           i[c] &= ~ (0L);
 966
 967         switch (GET_MODE (x))
 968           {
 969           case SFmode:
 970           case DFmode:
 971             return immed_double_const (((unsigned long) i[endian]) |
 972                                        (((HOST_WIDE_INT) i[1-endian]) << 32),
 973                                        0, mode);
 974           default:
 975             return immed_double_const (((unsigned long) i[endian*3]) |
 976                                        (((HOST_WIDE_INT) i[1+endian]) << 32),
 977                                        ((unsigned long) i[2-endian]) |
 978                                        (((HOST_WIDE_INT) i[3-endian*3]) << 32),
 979                                        mode);
 980           }
 981       }
 982 #endif
 983     }
 984 #endif /* ifndef REAL_ARITHMETIC */
 985
 986   /* Otherwise, we can't do this.  */
 987   return 0;
 988 }
 989 \f
 990 /* Return the real part (which has mode MODE) of a complex value X.
 991    This always comes at the low address in memory.  */
 992
 993 rtx
 994 gen_realpart (mode, x)
 995      enum machine_mode mode;
 996      register rtx x;
 997 {
 998   if (GET_CODE (x) == CONCAT && GET_MODE (XEXP (x, 0)) == mode)
 999     return XEXP (x, 0);
1000   else if (WORDS_BIG_ENDIAN
1001            && GET_MODE_BITSIZE (mode) < BITS_PER_WORD
1002            && REG_P (x)
1003            && REGNO (x) < FIRST_PSEUDO_REGISTER)
1004     internal_error
1005       ("Can't access real part of complex value in hard register");
1006   else if (WORDS_BIG_ENDIAN)
1007     return gen_highpart (mode, x);
1008   else
1009     return gen_lowpart (mode, x);
1010 }
1011
1012 /* Return the imaginary part (which has mode MODE) of a complex value X.
1013    This always comes at the high address in memory.  */
1014
1015 rtx
1016 gen_imagpart (mode, x)
1017      enum machine_mode mode;
1018      register rtx x;
1019 {
1020   if (GET_CODE (x) == CONCAT && GET_MODE (XEXP (x, 0)) == mode)
1021     return XEXP (x, 1);
1022   else if (WORDS_BIG_ENDIAN)
1023     return gen_lowpart (mode, x);
1024   else if (!WORDS_BIG_ENDIAN
1025            && GET_MODE_BITSIZE (mode) < BITS_PER_WORD
1026            && REG_P (x)
1027            && REGNO (x) < FIRST_PSEUDO_REGISTER)
1028     internal_error
1029       ("can't access imaginary part of complex value in hard register");
1030   else
1031     return gen_highpart (mode, x);
1032 }
1033
1034 /* Return 1 iff X, assumed to be a SUBREG,
1035    refers to the real part of the complex value in its containing reg.
1036    Complex values are always stored with the real part in the first word,
1037    regardless of WORDS_BIG_ENDIAN.  */
1038
1039 int
1040 subreg_realpart_p (x)
1041      rtx x;
1042 {
1043   if (GET_CODE (x) != SUBREG)
1044     abort ();
1045
1046   return ((unsigned int) SUBREG_WORD (x) * UNITS_PER_WORD
1047           < GET_MODE_UNIT_SIZE (GET_MODE (SUBREG_REG (x))));
1048 }
1049 \f
1050 /* Assuming that X is an rtx (e.g., MEM, REG or SUBREG) for a value,
1051    return an rtx (MEM, SUBREG, or CONST_INT) that refers to the
1052    least-significant part of X.
1053    MODE specifies how big a part of X to return;
1054    it usually should not be larger than a word.
1055    If X is a MEM whose address is a QUEUED, the value may be so also.  */
1056
1057 rtx
1058 gen_lowpart (mode, x)
1059      enum machine_mode mode;
1060      register rtx x;
1061 {
1062   rtx result = gen_lowpart_common (mode, x);
1063
1064   if (result)
1065     return result;
1066   else if (GET_CODE (x) == REG)
1067     {
1068       /* Must be a hard reg that's not valid in MODE.  */
1069       result = gen_lowpart_common (mode, copy_to_reg (x));
1070       if (result == 0)
1071         abort ();
1072       return result;
1073     }
1074   else if (GET_CODE (x) == MEM)
1075     {
1076       /* The only additional case we can do is MEM.  */
1077       register int offset = 0;
1078       if (WORDS_BIG_ENDIAN)
1079         offset = (MAX (GET_MODE_SIZE (GET_MODE (x)), UNITS_PER_WORD)
1080                   - MAX (GET_MODE_SIZE (mode), UNITS_PER_WORD));
1081
1082       if (BYTES_BIG_ENDIAN)
1083         /* Adjust the address so that the address-after-the-data
1084            is unchanged.  */
1085         offset -= (MIN (UNITS_PER_WORD, GET_MODE_SIZE (mode))
1086                    - MIN (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (x))));
1087
1088       return change_address (x, mode, plus_constant (XEXP (x, 0), offset));
1089     }
1090   else if (GET_CODE (x) == ADDRESSOF)
1091     return gen_lowpart (mode, force_reg (GET_MODE (x), x));
1092   else
1093     abort ();
1094 }
1095
1096 /* Like `gen_lowpart', but refer to the most significant part.
1097    This is used to access the imaginary part of a complex number.  */
1098
1099 rtx
1100 gen_highpart (mode, x)
1101      enum machine_mode mode;
1102      register rtx x;
1103 {
1104   /* This case loses if X is a subreg.  To catch bugs early,
1105      complain if an invalid MODE is used even in other cases.  */
1106   if (GET_MODE_SIZE (mode) > UNITS_PER_WORD
1107       && GET_MODE_SIZE (mode) != GET_MODE_UNIT_SIZE (GET_MODE (x)))
1108     abort ();
1109   if (GET_CODE (x) == CONST_DOUBLE
1110 #if !(TARGET_FLOAT_FORMAT != HOST_FLOAT_FORMAT || defined (REAL_IS_NOT_DOUBLE))
1111       && GET_MODE_CLASS (GET_MODE (x)) != MODE_FLOAT
1112 #endif
1113       )
1114     return GEN_INT (CONST_DOUBLE_HIGH (x) & GET_MODE_MASK (mode));
1115   else if (GET_CODE (x) == CONST_INT)
1116     {
1117       if (HOST_BITS_PER_WIDE_INT <= BITS_PER_WORD)
1118         return const0_rtx;
1119       return GEN_INT (INTVAL (x) >> (HOST_BITS_PER_WIDE_INT - BITS_PER_WORD));
1120     }
1121   else if (GET_CODE (x) == MEM)
1122     {
1123       register int offset = 0;
1124       if (! WORDS_BIG_ENDIAN)
1125         offset = (MAX (GET_MODE_SIZE (GET_MODE (x)), UNITS_PER_WORD)
1126                   - MAX (GET_MODE_SIZE (mode), UNITS_PER_WORD));
1127
1128       if (! BYTES_BIG_ENDIAN
1129           && GET_MODE_SIZE (mode) < UNITS_PER_WORD)
1130         offset -= (GET_MODE_SIZE (mode)
1131                    - MIN (UNITS_PER_WORD,
1132                           GET_MODE_SIZE (GET_MODE (x))));
1133
1134       return change_address (x, mode, plus_constant (XEXP (x, 0), offset));
1135     }
1136   else if (GET_CODE (x) == SUBREG)
1137     {
1138       /* The only time this should occur is when we are looking at a
1139          multi-word item with a SUBREG whose mode is the same as that of the
1140          item.  It isn't clear what we would do if it wasn't.  */
1141       if (SUBREG_WORD (x) != 0)
1142         abort ();
1143       return gen_highpart (mode, SUBREG_REG (x));
1144     }
1145   else if (GET_CODE (x) == REG)
1146     {
1147       int word;
1148
1149       /* Let the backend decide how many registers to skip.  This is needed
1150          in particular for sparc64 where fp regs are smaller than a word.  */
1151       /* ??? Note that subregs are now ambiguous, in that those against
1152          pseudos are sized by the word size, while those against hard
1153          regs are sized by the underlying register size.  Better would be
1154          to always interpret the subreg offset parameter as bytes or bits.  */
1155
1156       if (GET_MODE_SIZE (GET_MODE (x)) < GET_MODE_SIZE (mode))
1157         abort ();
1158       else if (WORDS_BIG_ENDIAN)
1159         word = 0;
1160       else if (REGNO (x) < FIRST_PSEUDO_REGISTER)
1161         word = (HARD_REGNO_NREGS (REGNO (x), GET_MODE (x))
1162                 - HARD_REGNO_NREGS (REGNO (x), mode));
1163       else
1164         word = ((GET_MODE_SIZE (GET_MODE (x))
1165                  - MAX (GET_MODE_SIZE (mode), UNITS_PER_WORD))
1166                 / UNITS_PER_WORD);
1167
1168       if (REGNO (x) < FIRST_PSEUDO_REGISTER
1169           /* integrate.c can't handle parts of a return value register.  */
1170           && (! REG_FUNCTION_VALUE_P (x)
1171               || ! rtx_equal_function_value_matters)
1172           /* We want to keep the stack, frame, and arg pointers special.  */
1173           && x != frame_pointer_rtx
1174 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
1175           && x != arg_pointer_rtx
1176 #endif
1177           && x != stack_pointer_rtx)
1178         return gen_rtx_REG (mode, REGNO (x) + word);
1179       else
1180         return gen_rtx_SUBREG (mode, x, word);
1181     }
1182   else
1183     abort ();
1184 }
1185
1186 /* Return 1 iff X, assumed to be a SUBREG,
1187    refers to the least significant part of its containing reg.
1188    If X is not a SUBREG, always return 1 (it is its own low part!).  */
1189
1190 int
1191 subreg_lowpart_p (x)
1192      rtx x;
1193 {
1194   if (GET_CODE (x) != SUBREG)
1195     return 1;
1196   else if (GET_MODE (SUBREG_REG (x)) == VOIDmode)
1197     return 0;
1198
1199   if (WORDS_BIG_ENDIAN
1200       && GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))) > UNITS_PER_WORD)
1201     return (SUBREG_WORD (x)
1202             == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)))
1203                  - MAX (GET_MODE_SIZE (GET_MODE (x)), UNITS_PER_WORD))
1204                 / UNITS_PER_WORD));
1205
1206   return SUBREG_WORD (x) == 0;
1207 }
1208 \f
1209 /* Return subword I of operand OP.
1210    The word number, I, is interpreted as the word number starting at the
1211    low-order address.  Word 0 is the low-order word if not WORDS_BIG_ENDIAN,
1212    otherwise it is the high-order word.
1213
1214    If we cannot extract the required word, we return zero.  Otherwise, an
1215    rtx corresponding to the requested word will be returned.
1216
1217    VALIDATE_ADDRESS is nonzero if the address should be validated.  Before
1218    reload has completed, a valid address will always be returned.  After
1219    reload, if a valid address cannot be returned, we return zero.
1220
1221    If VALIDATE_ADDRESS is zero, we simply form the required address; validating
1222    it is the responsibility of the caller.
1223
1224    MODE is the mode of OP in case it is a CONST_INT.  */
1225
1226 rtx
1227 operand_subword (op, i, validate_address, mode)
1228      rtx op;
1229      unsigned int i;
1230      int validate_address;
1231      enum machine_mode mode;
1232 {
1233   HOST_WIDE_INT val;
1234   int size_ratio = HOST_BITS_PER_WIDE_INT / BITS_PER_WORD;
1235
1236   if (mode == VOIDmode)
1237     mode = GET_MODE (op);
1238
1239   if (mode == VOIDmode)
1240     abort ();
1241
1242   /* If OP is narrower than a word, fail. */
1243   if (mode != BLKmode
1244       && (GET_MODE_SIZE (mode) < UNITS_PER_WORD))
1245     return 0;
1246
1247   /* If we want a word outside OP, return zero. */
1248   if (mode != BLKmode
1249       && (i + 1) * UNITS_PER_WORD > GET_MODE_SIZE (mode))
1250     return const0_rtx;
1251
1252   /* If OP is already an integer word, return it.  */
1253   if (GET_MODE_CLASS (mode) == MODE_INT
1254       && GET_MODE_SIZE (mode) == UNITS_PER_WORD)
1255     return op;
1256
1257   /* If OP is a REG or SUBREG, we can handle it very simply.  */
1258   if (GET_CODE (op) == REG)
1259     {
1260       /* ??? There is a potential problem with this code.  It does not
1261          properly handle extractions of a subword from a hard register
1262          that is larger than word_mode.  Presumably the check for
1263          HARD_REGNO_MODE_OK catches these most of these cases.  */
1264
1265       /* If OP is a hard register, but OP + I is not a hard register,
1266          then extracting a subword is impossible.
1267
1268          For example, consider if OP is the last hard register and it is
1269          larger than word_mode.  If we wanted word N (for N > 0) because a
1270          part of that hard register was known to contain a useful value,
1271          then OP + I would refer to a pseudo, not the hard register we
1272          actually wanted.  */
1273       if (REGNO (op) < FIRST_PSEUDO_REGISTER
1274           && REGNO (op) + i >= FIRST_PSEUDO_REGISTER)
1275         return 0;
1276
1277       /* If the register is not valid for MODE, return 0.  Note we
1278          have to check both OP and OP + I since they may refer to
1279          different parts of the register file.
1280
1281          Consider if OP refers to the last 96bit FP register and we want
1282          subword 3 because that subword is known to contain a value we
1283          needed.  */
1284       if (REGNO (op) < FIRST_PSEUDO_REGISTER
1285           && (! HARD_REGNO_MODE_OK (REGNO (op), word_mode)
1286               || ! HARD_REGNO_MODE_OK (REGNO (op) + i, word_mode)))
1287         return 0;
1288       else if (REGNO (op) >= FIRST_PSEUDO_REGISTER
1289                || (REG_FUNCTION_VALUE_P (op)
1290                    && rtx_equal_function_value_matters)
1291                /* We want to keep the stack, frame, and arg pointers
1292                   special.  */
1293                || op == frame_pointer_rtx
1294 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
1295                || op == arg_pointer_rtx
1296 #endif
1297                || op == stack_pointer_rtx)
1298         return gen_rtx_SUBREG (word_mode, op, i);
1299       else
1300         return gen_rtx_REG (word_mode, REGNO (op) + i);
1301     }
1302   else if (GET_CODE (op) == SUBREG)
1303     return gen_rtx_SUBREG (word_mode, SUBREG_REG (op), i + SUBREG_WORD (op));
1304   else if (GET_CODE (op) == CONCAT)
1305     {
1306       unsigned int partwords
1307         = GET_MODE_UNIT_SIZE (GET_MODE (op)) / UNITS_PER_WORD;
1308
1309       if (i < partwords)
1310         return operand_subword (XEXP (op, 0), i, validate_address, mode);
1311       return operand_subword (XEXP (op, 1), i - partwords,
1312                               validate_address, mode);
1313     }
1314
1315   /* Form a new MEM at the requested address.  */
1316   if (GET_CODE (op) == MEM)
1317     {
1318       rtx addr = plus_constant (XEXP (op, 0), i * UNITS_PER_WORD);
1319       rtx new;
1320
1321       if (validate_address)
1322         {
1323           if (reload_completed)
1324             {
1325               if (! strict_memory_address_p (word_mode, addr))
1326                 return 0;
1327             }
1328           else
1329             addr = memory_address (word_mode, addr);
1330         }
1331
1332       new = gen_rtx_MEM (word_mode, addr);
1333       MEM_COPY_ATTRIBUTES (new, op);
1334       return new;
1335     }
1336
1337   /* The only remaining cases are when OP is a constant.  If the host and
1338      target floating formats are the same, handling two-word floating
1339      constants are easy.  Note that REAL_VALUE_TO_TARGET_{SINGLE,DOUBLE}
1340      are defined as returning one or two 32 bit values, respectively,
1341      and not values of BITS_PER_WORD bits.  */
1342 #ifdef REAL_ARITHMETIC
1343   /* The output is some bits, the width of the target machine's word.
1344      A wider-word host can surely hold them in a CONST_INT. A narrower-word
1345      host can't.  */
1346   if (HOST_BITS_PER_WIDE_INT >= BITS_PER_WORD
1347       && GET_MODE_CLASS (mode) == MODE_FLOAT
1348       && GET_MODE_BITSIZE (mode) == 64
1349       && GET_CODE (op) == CONST_DOUBLE)
1350     {
1351       long k[2];
1352       REAL_VALUE_TYPE rv;
1353
1354       REAL_VALUE_FROM_CONST_DOUBLE (rv, op);
1355       REAL_VALUE_TO_TARGET_DOUBLE (rv, k);
1356
1357       /* We handle 32-bit and >= 64-bit words here.  Note that the order in
1358          which the words are written depends on the word endianness.
1359          ??? This is a potential portability problem and should
1360          be fixed at some point.
1361
1362          We must excercise caution with the sign bit.  By definition there
1363          are 32 significant bits in K; there may be more in a HOST_WIDE_INT.
1364          Consider a host with a 32-bit long and a 64-bit HOST_WIDE_INT.
1365          So we explicitly mask and sign-extend as necessary.  */
1366       if (BITS_PER_WORD == 32)
1367         {
1368           val = k[i];
1369           val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000;
1370           return GEN_INT (val);
1371         }
1372 #if HOST_BITS_PER_WIDE_INT >= 64
1373       else if (BITS_PER_WORD >= 64 && i == 0)
1374         {
1375           val = k[! WORDS_BIG_ENDIAN];
1376           val = (((val & 0xffffffff) ^ 0x80000000) - 0x80000000) << 32;
1377           val |= (HOST_WIDE_INT) k[WORDS_BIG_ENDIAN] & 0xffffffff;
1378           return GEN_INT (val);
1379         }
1380 #endif
1381       else if (BITS_PER_WORD == 16)
1382         {
1383           val = k[i >> 1];
1384           if ((i & 1) == !WORDS_BIG_ENDIAN)
1385             val >>= 16;
1386           val &= 0xffff;
1387           return GEN_INT (val);
1388         }
1389       else
1390         abort ();
1391     }
1392   else if (HOST_BITS_PER_WIDE_INT >= BITS_PER_WORD
1393            && GET_MODE_CLASS (mode) == MODE_FLOAT
1394            && GET_MODE_BITSIZE (mode) > 64
1395            && GET_CODE (op) == CONST_DOUBLE)
1396     {
1397       long k[4];
1398       REAL_VALUE_TYPE rv;
1399
1400       REAL_VALUE_FROM_CONST_DOUBLE (rv, op);
1401       REAL_VALUE_TO_TARGET_LONG_DOUBLE (rv, k);
1402
1403       if (BITS_PER_WORD == 32)
1404         {
1405           val = k[i];
1406           val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000;
1407           return GEN_INT (val);
1408         }
1409 #if HOST_BITS_PER_WIDE_INT >= 64
1410       else if (BITS_PER_WORD >= 64 && i <= 1)
1411         {
1412           val = k[i*2 + ! WORDS_BIG_ENDIAN];
1413           val = (((val & 0xffffffff) ^ 0x80000000) - 0x80000000) << 32;
1414           val |= (HOST_WIDE_INT) k[i*2 + WORDS_BIG_ENDIAN] & 0xffffffff;
1415           return GEN_INT (val);
1416         }
1417 #endif
1418       else
1419         abort ();
1420     }
1421 #else /* no REAL_ARITHMETIC */
1422   if (((HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT
1423         && HOST_BITS_PER_WIDE_INT == BITS_PER_WORD)
1424        || flag_pretend_float)
1425       && GET_MODE_CLASS (mode) == MODE_FLOAT
1426       && GET_MODE_SIZE (mode) == 2 * UNITS_PER_WORD
1427       && GET_CODE (op) == CONST_DOUBLE)
1428     {
1429       /* The constant is stored in the host's word-ordering,
1430          but we want to access it in the target's word-ordering.  Some
1431          compilers don't like a conditional inside macro args, so we have two
1432          copies of the return.  */
1433 #ifdef HOST_WORDS_BIG_ENDIAN
1434       return GEN_INT (i == WORDS_BIG_ENDIAN
1435                       ? CONST_DOUBLE_HIGH (op) : CONST_DOUBLE_LOW (op));
1436 #else
1437       return GEN_INT (i != WORDS_BIG_ENDIAN
1438                       ? CONST_DOUBLE_HIGH (op) : CONST_DOUBLE_LOW (op));
1439 #endif
1440     }
1441 #endif /* no REAL_ARITHMETIC */
1442
1443   /* Single word float is a little harder, since single- and double-word
1444      values often do not have the same high-order bits.  We have already
1445      verified that we want the only defined word of the single-word value.  */
1446 #ifdef REAL_ARITHMETIC
1447   if (GET_MODE_CLASS (mode) == MODE_FLOAT
1448       && GET_MODE_BITSIZE (mode) == 32
1449       && GET_CODE (op) == CONST_DOUBLE)
1450     {
1451       long l;
1452       REAL_VALUE_TYPE rv;
1453
1454       REAL_VALUE_FROM_CONST_DOUBLE (rv, op);
1455       REAL_VALUE_TO_TARGET_SINGLE (rv, l);
1456
1457       /* Sign extend from known 32-bit value to HOST_WIDE_INT.  */
1458       val = l;
1459       val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000;
1460
1461       if (BITS_PER_WORD == 16)
1462         {
1463           if ((i & 1) == !WORDS_BIG_ENDIAN)
1464             val >>= 16;
1465           val &= 0xffff;
1466         }
1467
1468       return GEN_INT (val);
1469     }
1470 #else
1471   if (((HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT
1472         && HOST_BITS_PER_WIDE_INT == BITS_PER_WORD)
1473        || flag_pretend_float)
1474       && sizeof (float) * 8 == HOST_BITS_PER_WIDE_INT
1475       && GET_MODE_CLASS (mode) == MODE_FLOAT
1476       && GET_MODE_SIZE (mode) == UNITS_PER_WORD
1477       && GET_CODE (op) == CONST_DOUBLE)
1478     {
1479       double d;
1480       union {float f; HOST_WIDE_INT i; } u;
1481
1482       REAL_VALUE_FROM_CONST_DOUBLE (d, op);
1483
1484       u.f = d;
1485       return GEN_INT (u.i);
1486     }
1487   if (((HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT
1488         && HOST_BITS_PER_WIDE_INT == BITS_PER_WORD)
1489        || flag_pretend_float)
1490       && sizeof (double) * 8 == HOST_BITS_PER_WIDE_INT
1491       && GET_MODE_CLASS (mode) == MODE_FLOAT
1492       && GET_MODE_SIZE (mode) == UNITS_PER_WORD
1493       && GET_CODE (op) == CONST_DOUBLE)
1494     {
1495       double d;
1496       union {double d; HOST_WIDE_INT i; } u;
1497
1498       REAL_VALUE_FROM_CONST_DOUBLE (d, op);
1499
1500       u.d = d;
1501       return GEN_INT (u.i);
1502     }
1503 #endif /* no REAL_ARITHMETIC */
1504
1505   /* The only remaining cases that we can handle are integers.
1506      Convert to proper endianness now since these cases need it.
1507      At this point, i == 0 means the low-order word.
1508
1509      We do not want to handle the case when BITS_PER_WORD <= HOST_BITS_PER_INT
1510      in general.  However, if OP is (const_int 0), we can just return
1511      it for any word.  */
1512
1513   if (op == const0_rtx)
1514     return op;
1515
1516   if (GET_MODE_CLASS (mode) != MODE_INT
1517       || (GET_CODE (op) != CONST_INT && GET_CODE (op) != CONST_DOUBLE)
1518       || BITS_PER_WORD > HOST_BITS_PER_WIDE_INT)
1519     return 0;
1520
1521   if (WORDS_BIG_ENDIAN)
1522     i = GET_MODE_SIZE (mode) / UNITS_PER_WORD - 1 - i;
1523
1524   /* Find out which word on the host machine this value is in and get
1525      it from the constant.  */
1526   val = (i / size_ratio == 0
1527          ? (GET_CODE (op) == CONST_INT ? INTVAL (op) : CONST_DOUBLE_LOW (op))
1528          : (GET_CODE (op) == CONST_INT
1529             ? (INTVAL (op) < 0 ? ~0 : 0) : CONST_DOUBLE_HIGH (op)));
1530
1531   /* Get the value we want into the low bits of val.  */
1532   if (BITS_PER_WORD < HOST_BITS_PER_WIDE_INT)
1533     val = ((val >> ((i % size_ratio) * BITS_PER_WORD)));
1534
1535   val = trunc_int_for_mode (val, word_mode);
1536
1537   return GEN_INT (val);
1538 }
1539
1540 /* Similar to `operand_subword', but never return 0.  If we can't extract
1541    the required subword, put OP into a register and try again.  If that fails,
1542    abort.  We always validate the address in this case.  It is not valid
1543    to call this function after reload; it is mostly meant for RTL
1544    generation.
1545
1546    MODE is the mode of OP, in case it is CONST_INT.  */
1547
1548 rtx
1549 operand_subword_force (op, i, mode)
1550      rtx op;
1551      unsigned int i;
1552      enum machine_mode mode;
1553 {
1554   rtx result = operand_subword (op, i, 1, mode);
1555
1556   if (result)
1557     return result;
1558
1559   if (mode != BLKmode && mode != VOIDmode)
1560     {
1561       /* If this is a register which can not be accessed by words, copy it
1562          to a pseudo register.  */
1563       if (GET_CODE (op) == REG)
1564         op = copy_to_reg (op);
1565       else
1566         op = force_reg (mode, op);
1567     }
1568
1569   result = operand_subword (op, i, 1, mode);
1570   if (result == 0)
1571     abort ();
1572
1573   return result;
1574 }
1575 \f
1576 /* Given a compare instruction, swap the operands.
1577    A test instruction is changed into a compare of 0 against the operand.  */
1578
1579 void
1580 reverse_comparison (insn)
1581      rtx insn;
1582 {
1583   rtx body = PATTERN (insn);
1584   rtx comp;
1585
1586   if (GET_CODE (body) == SET)
1587     comp = SET_SRC (body);
1588   else
1589     comp = SET_SRC (XVECEXP (body, 0, 0));
1590
1591   if (GET_CODE (comp) == COMPARE)
1592     {
1593       rtx op0 = XEXP (comp, 0);
1594       rtx op1 = XEXP (comp, 1);
1595       XEXP (comp, 0) = op1;
1596       XEXP (comp, 1) = op0;
1597     }
1598   else
1599     {
1600       rtx new = gen_rtx_COMPARE (VOIDmode,
1601                                  CONST0_RTX (GET_MODE (comp)), comp);
1602       if (GET_CODE (body) == SET)
1603         SET_SRC (body) = new;
1604       else
1605         SET_SRC (XVECEXP (body, 0, 0)) = new;
1606     }
1607 }
1608 \f
1609 /* Return a memory reference like MEMREF, but with its mode changed
1610    to MODE and its address changed to ADDR.
1611    (VOIDmode means don't change the mode.
1612    NULL for ADDR means don't change the address.)  */
1613
1614 rtx
1615 change_address (memref, mode, addr)
1616      rtx memref;
1617      enum machine_mode mode;
1618      rtx addr;
1619 {
1620   rtx new;
1621
1622   if (GET_CODE (memref) != MEM)
1623     abort ();
1624   if (mode == VOIDmode)
1625     mode = GET_MODE (memref);
1626   if (addr == 0)
1627     addr = XEXP (memref, 0);
1628
1629   /* If reload is in progress or has completed, ADDR must be valid.
1630      Otherwise, we can call memory_address to make it valid.  */
1631   if (reload_completed || reload_in_progress)
1632     {
1633       if (! memory_address_p (mode, addr))
1634         abort ();
1635     }
1636   else
1637     addr = memory_address (mode, addr);
1638
1639   if (rtx_equal_p (addr, XEXP (memref, 0)) && mode == GET_MODE (memref))
1640     return memref;
1641
1642   new = gen_rtx_MEM (mode, addr);
1643   MEM_COPY_ATTRIBUTES (new, memref);
1644   return new;
1645 }
1646 \f
1647 /* Return a newly created CODE_LABEL rtx with a unique label number.  */
1648
1649 rtx
1650 gen_label_rtx ()
1651 {
1652   register rtx label;
1653
1654   label = gen_rtx_CODE_LABEL (VOIDmode, 0, NULL_RTX,
1655                               NULL_RTX, label_num++, NULL_PTR, NULL_PTR);
1656
1657   LABEL_NUSES (label) = 0;
1658   LABEL_ALTERNATE_NAME (label) = NULL;
1659   return label;
1660 }
1661 \f
1662 /* For procedure integration.  */
1663
1664 /* Install new pointers to the first and last insns in the chain.
1665    Also, set cur_insn_uid to one higher than the last in use.
1666    Used for an inline-procedure after copying the insn chain.  */
1667
1668 void
1669 set_new_first_and_last_insn (first, last)
1670      rtx first, last;
1671 {
1672   rtx insn;
1673
1674   first_insn = first;
1675   last_insn = last;
1676   cur_insn_uid = 0;
1677
1678   for (insn = first; insn; insn = NEXT_INSN (insn))
1679     cur_insn_uid = MAX (cur_insn_uid, INSN_UID (insn));
1680
1681   cur_insn_uid++;
1682 }
1683
1684 /* Set the range of label numbers found in the current function.
1685    This is used when belatedly compiling an inline function.  */
1686
1687 void
1688 set_new_first_and_last_label_num (first, last)
1689      int first, last;
1690 {
1691   base_label_num = label_num;
1692   first_label_num = first;
1693   last_label_num = last;
1694 }
1695
1696 /* Set the last label number found in the current function.
1697    This is used when belatedly compiling an inline function.  */
1698
1699 void
1700 set_new_last_label_num (last)
1701      int last;
1702 {
1703   base_label_num = label_num;
1704   last_label_num = last;
1705 }
1706 \f
1707 /* Restore all variables describing the current status from the structure *P.
1708    This is used after a nested function.  */
1709
1710 void
1711 restore_emit_status (p)
1712      struct function *p ATTRIBUTE_UNUSED;
1713 {
1714   last_label_num = 0;
1715   clear_emit_caches ();
1716 }
1717
1718 /* Clear out all parts of the state in F that can safely be discarded
1719    after the function has been compiled, to let garbage collection
1720    reclaim the memory.  */
1721
1722 void
1723 free_emit_status (f)
1724      struct function *f;
1725 {
1726   free (f->emit->x_regno_reg_rtx);
1727   free (f->emit->regno_pointer_align);
1728   free (f->emit);
1729   f->emit = NULL;
1730 }
1731 \f
1732 /* Go through all the RTL insn bodies and copy any invalid shared
1733    structure.  This routine should only be called once.  */
1734
1735 void
1736 unshare_all_rtl (fndecl, insn)
1737      tree fndecl;
1738      rtx insn;
1739 {
1740   tree decl;
1741
1742   /* Make sure that virtual parameters are not shared.  */
1743   for (decl = DECL_ARGUMENTS (fndecl); decl; decl = TREE_CHAIN (decl))
1744     DECL_RTL (decl) = copy_rtx_if_shared (DECL_RTL (decl));
1745
1746   /* Make sure that virtual stack slots are not shared.  */
1747   unshare_all_decls (DECL_INITIAL (fndecl));
1748
1749   /* Unshare just about everything else.  */
1750   unshare_all_rtl_1 (insn);
1751
1752   /* Make sure the addresses of stack slots found outside the insn chain
1753      (such as, in DECL_RTL of a variable) are not shared
1754      with the insn chain.
1755
1756      This special care is necessary when the stack slot MEM does not
1757      actually appear in the insn chain.  If it does appear, its address
1758      is unshared from all else at that point.  */
1759   stack_slot_list = copy_rtx_if_shared (stack_slot_list);
1760 }
1761
1762 /* Go through all the RTL insn bodies and copy any invalid shared
1763    structure, again.  This is a fairly expensive thing to do so it
1764    should be done sparingly.  */
1765
1766 void
1767 unshare_all_rtl_again (insn)
1768      rtx insn;
1769 {
1770   rtx p;
1771   tree decl;
1772
1773   for (p = insn; p; p = NEXT_INSN (p))
1774     if (INSN_P (p))
1775       {
1776         reset_used_flags (PATTERN (p));
1777         reset_used_flags (REG_NOTES (p));
1778         reset_used_flags (LOG_LINKS (p));
1779       }
1780
1781   /* Make sure that virtual stack slots are not shared.  */
1782   reset_used_decls (DECL_INITIAL (cfun->decl));
1783
1784   /* Make sure that virtual parameters are not shared.  */
1785   for (decl = DECL_ARGUMENTS (cfun->decl); decl; decl = TREE_CHAIN (decl))
1786     reset_used_flags (DECL_RTL (decl));
1787
1788   reset_used_flags (stack_slot_list);
1789
1790   unshare_all_rtl (cfun->decl, insn);
1791 }
1792
1793 /* Go through all the RTL insn bodies and copy any invalid shared structure.
1794    Assumes the mark bits are cleared at entry.  */
1795
1796 static void
1797 unshare_all_rtl_1 (insn)
1798      rtx insn;
1799 {
1800   for (; insn; insn = NEXT_INSN (insn))
1801     if (INSN_P (insn))
1802       {
1803         PATTERN (insn) = copy_rtx_if_shared (PATTERN (insn));
1804         REG_NOTES (insn) = copy_rtx_if_shared (REG_NOTES (insn));
1805         LOG_LINKS (insn) = copy_rtx_if_shared (LOG_LINKS (insn));
1806       }
1807 }
1808
1809 /* Go through all virtual stack slots of a function and copy any
1810    shared structure.  */
1811 static void
1812 unshare_all_decls (blk)
1813      tree blk;
1814 {
1815   tree t;
1816
1817   /* Copy shared decls.  */
1818   for (t = BLOCK_VARS (blk); t; t = TREE_CHAIN (t))
1819     DECL_RTL (t) = copy_rtx_if_shared (DECL_RTL (t));
1820
1821   /* Now process sub-blocks.  */
1822   for (t = BLOCK_SUBBLOCKS (blk); t; t = TREE_CHAIN (t))
1823     unshare_all_decls (t);
1824 }
1825
1826 /* Go through all virtual stack slots of a function and mark them as
1827    not shared. */
1828 static void
1829 reset_used_decls (blk)
1830      tree blk;
1831 {
1832   tree t;
1833
1834   /* Mark decls.  */
1835   for (t = BLOCK_VARS (blk); t; t = TREE_CHAIN (t))
1836     reset_used_flags (DECL_RTL (t));
1837
1838   /* Now process sub-blocks.  */
1839   for (t = BLOCK_SUBBLOCKS (blk); t; t = TREE_CHAIN (t))
1840     reset_used_decls (t);
1841 }
1842
1843 /* Mark ORIG as in use, and return a copy of it if it was already in use.
1844    Recursively does the same for subexpressions.  */
1845
1846 rtx
1847 copy_rtx_if_shared (orig)
1848      rtx orig;
1849 {
1850   register rtx x = orig;
1851   register int i;
1852   register enum rtx_code code;
1853   register const char *format_ptr;
1854   int copied = 0;
1855
1856   if (x == 0)
1857     return 0;
1858
1859   code = GET_CODE (x);
1860
1861   /* These types may be freely shared.  */
1862
1863   switch (code)
1864     {
1865     case REG:
1866     case QUEUED:
1867     case CONST_INT:
1868     case CONST_DOUBLE:
1869     case SYMBOL_REF:
1870     case CODE_LABEL:
1871     case PC:
1872     case CC0:
1873     case SCRATCH:
1874       /* SCRATCH must be shared because they represent distinct values.  */
1875       return x;
1876
1877     case CONST:
1878       /* CONST can be shared if it contains a SYMBOL_REF.  If it contains
1879          a LABEL_REF, it isn't sharable.  */
1880       if (GET_CODE (XEXP (x, 0)) == PLUS
1881           && GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF
1882           && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT)
1883         return x;
1884       break;
1885
1886     case INSN:
1887     case JUMP_INSN:
1888     case CALL_INSN:
1889     case NOTE:
1890     case BARRIER:
1891       /* The chain of insns is not being copied.  */
1892       return x;
1893
1894     case MEM:
1895       /* A MEM is allowed to be shared if its address is constant.
1896
1897          We used to allow sharing of MEMs which referenced
1898          virtual_stack_vars_rtx or virtual_incoming_args_rtx, but
1899          that can lose.  instantiate_virtual_regs will not unshare
1900          the MEMs, and combine may change the structure of the address
1901          because it looks safe and profitable in one context, but
1902          in some other context it creates unrecognizable RTL.  */
1903       if (CONSTANT_ADDRESS_P (XEXP (x, 0)))
1904         return x;
1905
1906       break;
1907
1908     default:
1909       break;
1910     }
1911
1912   /* This rtx may not be shared.  If it has already been seen,
1913      replace it with a copy of itself.  */
1914
1915   if (x->used)
1916     {
1917       register rtx copy;
1918
1919       copy = rtx_alloc (code);
1920       memcpy (copy, x,
1921              (sizeof (*copy) - sizeof (copy->fld)
1922               + sizeof (copy->fld[0]) * GET_RTX_LENGTH (code)));
1923       x = copy;
1924       copied = 1;
1925     }
1926   x->used = 1;
1927
1928   /* Now scan the subexpressions recursively.
1929      We can store any replaced subexpressions directly into X
1930      since we know X is not shared!  Any vectors in X
1931      must be copied if X was copied.  */
1932
1933   format_ptr = GET_RTX_FORMAT (code);
1934
1935   for (i = 0; i < GET_RTX_LENGTH (code); i++)
1936     {
1937       switch (*format_ptr++)
1938         {
1939         case 'e':
1940           XEXP (x, i) = copy_rtx_if_shared (XEXP (x, i));
1941           break;
1942
1943         case 'E':
1944           if (XVEC (x, i) != NULL)
1945             {
1946               register int j;
1947               int len = XVECLEN (x, i);
1948
1949               if (copied && len > 0)
1950                 XVEC (x, i) = gen_rtvec_v (len, XVEC (x, i)->elem);
1951               for (j = 0; j < len; j++)
1952                 XVECEXP (x, i, j) = copy_rtx_if_shared (XVECEXP (x, i, j));
1953             }
1954           break;
1955         }
1956     }
1957   return x;
1958 }
1959
1960 /* Clear all the USED bits in X to allow copy_rtx_if_shared to be used
1961    to look for shared sub-parts.  */
1962
1963 void
1964 reset_used_flags (x)
1965      rtx x;
1966 {
1967   register int i, j;
1968   register enum rtx_code code;
1969   register const char *format_ptr;
1970
1971   if (x == 0)
1972     return;
1973
1974   code = GET_CODE (x);
1975
1976   /* These types may be freely shared so we needn't do any resetting
1977      for them.  */
1978
1979   switch (code)
1980     {
1981     case REG:
1982     case QUEUED:
1983     case CONST_INT:
1984     case CONST_DOUBLE:
1985     case SYMBOL_REF:
1986     case CODE_LABEL:
1987     case PC:
1988     case CC0:
1989       return;
1990
1991     case INSN:
1992     case JUMP_INSN:
1993     case CALL_INSN:
1994     case NOTE:
1995     case LABEL_REF:
1996     case BARRIER:
1997       /* The chain of insns is not being copied.  */
1998       return;
1999
2000     default:
2001       break;
2002     }
2003
2004   x->used = 0;
2005
2006   format_ptr = GET_RTX_FORMAT (code);
2007   for (i = 0; i < GET_RTX_LENGTH (code); i++)
2008     {
2009       switch (*format_ptr++)
2010         {
2011         case 'e':
2012           reset_used_flags (XEXP (x, i));
2013           break;
2014
2015         case 'E':
2016           for (j = 0; j < XVECLEN (x, i); j++)
2017             reset_used_flags (XVECEXP (x, i, j));
2018           break;
2019         }
2020     }
2021 }
2022 \f
2023 /* Copy X if necessary so that it won't be altered by changes in OTHER.
2024    Return X or the rtx for the pseudo reg the value of X was copied into.
2025    OTHER must be valid as a SET_DEST.  */
2026
2027 rtx
2028 make_safe_from (x, other)
2029      rtx x, other;
2030 {
2031   while (1)
2032     switch (GET_CODE (other))
2033       {
2034       case SUBREG:
2035         other = SUBREG_REG (other);
2036         break;
2037       case STRICT_LOW_PART:
2038       case SIGN_EXTEND:
2039       case ZERO_EXTEND:
2040         other = XEXP (other, 0);
2041         break;
2042       default:
2043         goto done;
2044       }
2045  done:
2046   if ((GET_CODE (other) == MEM
2047        && ! CONSTANT_P (x)
2048        && GET_CODE (x) != REG
2049        && GET_CODE (x) != SUBREG)
2050       || (GET_CODE (other) == REG
2051           && (REGNO (other) < FIRST_PSEUDO_REGISTER
2052               || reg_mentioned_p (other, x))))
2053     {
2054       rtx temp = gen_reg_rtx (GET_MODE (x));
2055       emit_move_insn (temp, x);
2056       return temp;
2057     }
2058   return x;
2059 }
2060 \f
2061 /* Emission of insns (adding them to the doubly-linked list).  */
2062
2063 /* Return the first insn of the current sequence or current function.  */
2064
2065 rtx
2066 get_insns ()
2067 {
2068   return first_insn;
2069 }
2070
2071 /* Return the last insn emitted in current sequence or current function.  */
2072
2073 rtx
2074 get_last_insn ()
2075 {
2076   return last_insn;
2077 }
2078
2079 /* Specify a new insn as the last in the chain.  */
2080
2081 void
2082 set_last_insn (insn)
2083      rtx insn;
2084 {
2085   if (NEXT_INSN (insn) != 0)
2086     abort ();
2087   last_insn = insn;
2088 }
2089
2090 /* Return the last insn emitted, even if it is in a sequence now pushed.  */
2091
2092 rtx
2093 get_last_insn_anywhere ()
2094 {
2095   struct sequence_stack *stack;
2096   if (last_insn)
2097     return last_insn;
2098   for (stack = seq_stack; stack; stack = stack->next)
2099     if (stack->last != 0)
2100       return stack->last;
2101   return 0;
2102 }
2103
2104 /* Return a number larger than any instruction's uid in this function.  */
2105
2106 int
2107 get_max_uid ()
2108 {
2109   return cur_insn_uid;
2110 }
2111
2112 /* Renumber instructions so that no instruction UIDs are wasted.  */
2113
2114 void
2115 renumber_insns (stream)
2116      FILE *stream;
2117 {
2118   rtx insn;
2119
2120   /* If we're not supposed to renumber instructions, don't.  */
2121   if (!flag_renumber_insns)
2122     return;
2123
2124   /* If there aren't that many instructions, then it's not really
2125      worth renumbering them.  */
2126   if (flag_renumber_insns == 1 && get_max_uid () < 25000)
2127     return;
2128
2129   cur_insn_uid = 1;
2130
2131   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
2132     {
2133       if (stream)
2134         fprintf (stream, "Renumbering insn %d to %d\n",
2135                  INSN_UID (insn), cur_insn_uid);
2136       INSN_UID (insn) = cur_insn_uid++;
2137     }
2138 }
2139 \f
2140 /* Return the next insn.  If it is a SEQUENCE, return the first insn
2141    of the sequence.  */
2142
2143 rtx
2144 next_insn (insn)
2145      rtx insn;
2146 {
2147   if (insn)
2148     {
2149       insn = NEXT_INSN (insn);
2150       if (insn && GET_CODE (insn) == INSN
2151           && GET_CODE (PATTERN (insn)) == SEQUENCE)
2152         insn = XVECEXP (PATTERN (insn), 0, 0);
2153     }
2154
2155   return insn;
2156 }
2157
2158 /* Return the previous insn.  If it is a SEQUENCE, return the last insn
2159    of the sequence.  */
2160
2161 rtx
2162 previous_insn (insn)
2163      rtx insn;
2164 {
2165   if (insn)
2166     {
2167       insn = PREV_INSN (insn);
2168       if (insn && GET_CODE (insn) == INSN
2169           && GET_CODE (PATTERN (insn)) == SEQUENCE)
2170         insn = XVECEXP (PATTERN (insn), 0, XVECLEN (PATTERN (insn), 0) - 1);
2171     }
2172
2173   return insn;
2174 }
2175
2176 /* Return the next insn after INSN that is not a NOTE.  This routine does not
2177    look inside SEQUENCEs.  */
2178
2179 rtx
2180 next_nonnote_insn (insn)
2181      rtx insn;
2182 {
2183   while (insn)
2184     {
2185       insn = NEXT_INSN (insn);
2186       if (insn == 0 || GET_CODE (insn) != NOTE)
2187         break;
2188     }
2189
2190   return insn;
2191 }
2192
2193 /* Return the previous insn before INSN that is not a NOTE.  This routine does
2194    not look inside SEQUENCEs.  */
2195
2196 rtx
2197 prev_nonnote_insn (insn)
2198      rtx insn;
2199 {
2200   while (insn)
2201     {
2202       insn = PREV_INSN (insn);
2203       if (insn == 0 || GET_CODE (insn) != NOTE)
2204         break;
2205     }
2206
2207   return insn;
2208 }
2209
2210 /* Return the next INSN, CALL_INSN or JUMP_INSN after INSN;
2211    or 0, if there is none.  This routine does not look inside
2212    SEQUENCEs.  */
2213
2214 rtx
2215 next_real_insn (insn)
2216      rtx insn;
2217 {
2218   while (insn)
2219     {
2220       insn = NEXT_INSN (insn);
2221       if (insn == 0 || GET_CODE (insn) == INSN
2222           || GET_CODE (insn) == CALL_INSN || GET_CODE (insn) == JUMP_INSN)
2223         break;
2224     }
2225
2226   return insn;
2227 }
2228
2229 /* Return the last INSN, CALL_INSN or JUMP_INSN before INSN;
2230    or 0, if there is none.  This routine does not look inside
2231    SEQUENCEs.  */
2232
2233 rtx
2234 prev_real_insn (insn)
2235      rtx insn;
2236 {
2237   while (insn)
2238     {
2239       insn = PREV_INSN (insn);
2240       if (insn == 0 || GET_CODE (insn) == INSN || GET_CODE (insn) == CALL_INSN
2241           || GET_CODE (insn) == JUMP_INSN)
2242         break;
2243     }
2244
2245   return insn;
2246 }
2247
2248 /* Find the next insn after INSN that really does something.  This routine
2249    does not look inside SEQUENCEs.  Until reload has completed, this is the
2250    same as next_real_insn.  */
2251
2252 int
2253 active_insn_p (insn)
2254      rtx insn;
2255 {
2256   return (GET_CODE (insn) == CALL_INSN || GET_CODE (insn) == JUMP_INSN
2257           || (GET_CODE (insn) == INSN
2258               && (! reload_completed
2259                   || (GET_CODE (PATTERN (insn)) != USE
2260                       && GET_CODE (PATTERN (insn)) != CLOBBER))));
2261 }
2262
2263 rtx
2264 next_active_insn (insn)
2265      rtx insn;
2266 {
2267   while (insn)
2268     {
2269       insn = NEXT_INSN (insn);
2270       if (insn == 0 || active_insn_p (insn))
2271         break;
2272     }
2273
2274   return insn;
2275 }
2276
2277 /* Find the last insn before INSN that really does something.  This routine
2278    does not look inside SEQUENCEs.  Until reload has completed, this is the
2279    same as prev_real_insn.  */
2280
2281 rtx
2282 prev_active_insn (insn)
2283      rtx insn;
2284 {
2285   while (insn)
2286     {
2287       insn = PREV_INSN (insn);
2288       if (insn == 0 || active_insn_p (insn))
2289         break;
2290     }
2291
2292   return insn;
2293 }
2294
2295 /* Return the next CODE_LABEL after the insn INSN, or 0 if there is none.  */
2296
2297 rtx
2298 next_label (insn)
2299      rtx insn;
2300 {
2301   while (insn)
2302     {
2303       insn = NEXT_INSN (insn);
2304       if (insn == 0 || GET_CODE (insn) == CODE_LABEL)
2305         break;
2306     }
2307
2308   return insn;
2309 }
2310
2311 /* Return the last CODE_LABEL before the insn INSN, or 0 if there is none.  */
2312
2313 rtx
2314 prev_label (insn)
2315      rtx insn;
2316 {
2317   while (insn)
2318     {
2319       insn = PREV_INSN (insn);
2320       if (insn == 0 || GET_CODE (insn) == CODE_LABEL)
2321         break;
2322     }
2323
2324   return insn;
2325 }
2326 \f
2327 #ifdef HAVE_cc0
2328 /* INSN uses CC0 and is being moved into a delay slot.  Set up REG_CC_SETTER
2329    and REG_CC_USER notes so we can find it.  */
2330
2331 void
2332 link_cc0_insns (insn)
2333      rtx insn;
2334 {
2335   rtx user = next_nonnote_insn (insn);
2336
2337   if (GET_CODE (user) == INSN && GET_CODE (PATTERN (user)) == SEQUENCE)
2338     user = XVECEXP (PATTERN (user), 0, 0);
2339
2340   REG_NOTES (user) = gen_rtx_INSN_LIST (REG_CC_SETTER, insn,
2341                                         REG_NOTES (user));
2342   REG_NOTES (insn) = gen_rtx_INSN_LIST (REG_CC_USER, user, REG_NOTES (insn));
2343 }
2344
2345 /* Return the next insn that uses CC0 after INSN, which is assumed to
2346    set it.  This is the inverse of prev_cc0_setter (i.e., prev_cc0_setter
2347    applied to the result of this function should yield INSN).
2348
2349    Normally, this is simply the next insn.  However, if a REG_CC_USER note
2350    is present, it contains the insn that uses CC0.
2351
2352    Return 0 if we can't find the insn.  */
2353
2354 rtx
2355 next_cc0_user (insn)
2356      rtx insn;
2357 {
2358   rtx note = find_reg_note (insn, REG_CC_USER, NULL_RTX);
2359
2360   if (note)
2361     return XEXP (note, 0);
2362
2363   insn = next_nonnote_insn (insn);
2364   if (insn && GET_CODE (insn) == INSN && GET_CODE (PATTERN (insn)) == SEQUENCE)
2365     insn = XVECEXP (PATTERN (insn), 0, 0);
2366
2367   if (insn && INSN_P (insn) && reg_mentioned_p (cc0_rtx, PATTERN (insn)))
2368     return insn;
2369
2370   return 0;
2371 }
2372
2373 /* Find the insn that set CC0 for INSN.  Unless INSN has a REG_CC_SETTER
2374    note, it is the previous insn.  */
2375
2376 rtx
2377 prev_cc0_setter (insn)
2378      rtx insn;
2379 {
2380   rtx note = find_reg_note (insn, REG_CC_SETTER, NULL_RTX);
2381
2382   if (note)
2383     return XEXP (note, 0);
2384
2385   insn = prev_nonnote_insn (insn);
2386   if (! sets_cc0_p (PATTERN (insn)))
2387     abort ();
2388
2389   return insn;
2390 }
2391 #endif
2392 \f
2393 /* Try splitting insns that can be split for better scheduling.
2394    PAT is the pattern which might split.
2395    TRIAL is the insn providing PAT.
2396    LAST is non-zero if we should return the last insn of the sequence produced.
2397
2398    If this routine succeeds in splitting, it returns the first or last
2399    replacement insn depending on the value of LAST.  Otherwise, it
2400    returns TRIAL.  If the insn to be returned can be split, it will be.  */
2401
2402 rtx
2403 try_split (pat, trial, last)
2404      rtx pat, trial;
2405      int last;
2406 {
2407   rtx before = PREV_INSN (trial);
2408   rtx after = NEXT_INSN (trial);
2409   rtx seq = split_insns (pat, trial);
2410   int has_barrier = 0;
2411   rtx tem;
2412
2413   /* If we are splitting a JUMP_INSN, it might be followed by a BARRIER.
2414      We may need to handle this specially.  */
2415   if (after && GET_CODE (after) == BARRIER)
2416     {
2417       has_barrier = 1;
2418       after = NEXT_INSN (after);
2419     }
2420
2421   if (seq)
2422     {
2423       /* SEQ can either be a SEQUENCE or the pattern of a single insn.
2424          The latter case will normally arise only when being done so that
2425          it, in turn, will be split (SFmode on the 29k is an example).  */
2426       if (GET_CODE (seq) == SEQUENCE)
2427         {
2428           int i;
2429
2430           /* Avoid infinite loop if any insn of the result matches
2431              the original pattern.  */
2432           for (i = 0; i < XVECLEN (seq, 0); i++)
2433             if (GET_CODE (XVECEXP (seq, 0, i)) == INSN
2434                 && rtx_equal_p (PATTERN (XVECEXP (seq, 0, i)), pat))
2435               return trial;
2436
2437           /* Mark labels.  */
2438           for (i = XVECLEN (seq, 0) - 1; i >= 0; i--)
2439             if (GET_CODE (XVECEXP (seq, 0, i)) == JUMP_INSN)
2440               mark_jump_label (PATTERN (XVECEXP (seq, 0, i)),
2441                                XVECEXP (seq, 0, i), 0, 0);
2442
2443           /* If we are splitting a CALL_INSN, look for the CALL_INSN
2444              in SEQ and copy our CALL_INSN_FUNCTION_USAGE to it.  */
2445           if (GET_CODE (trial) == CALL_INSN)
2446             for (i = XVECLEN (seq, 0) - 1; i >= 0; i--)
2447               if (GET_CODE (XVECEXP (seq, 0, i)) == CALL_INSN)
2448                 CALL_INSN_FUNCTION_USAGE (XVECEXP (seq, 0, i))
2449                   = CALL_INSN_FUNCTION_USAGE (trial);
2450
2451           tem = emit_insn_after (seq, before);
2452
2453           delete_insn (trial);
2454           if (has_barrier)
2455             emit_barrier_after (tem);
2456
2457           /* Recursively call try_split for each new insn created; by the
2458              time control returns here that insn will be fully split, so
2459              set LAST and continue from the insn after the one returned.
2460              We can't use next_active_insn here since AFTER may be a note.
2461              Ignore deleted insns, which can be occur if not optimizing.  */
2462           for (tem = NEXT_INSN (before); tem != after; tem = NEXT_INSN (tem))
2463             if (! INSN_DELETED_P (tem) && INSN_P (tem))
2464               tem = try_split (PATTERN (tem), tem, 1);
2465         }
2466       /* Avoid infinite loop if the result matches the original pattern.  */
2467       else if (rtx_equal_p (seq, pat))
2468         return trial;
2469       else
2470         {
2471           PATTERN (trial) = seq;
2472           INSN_CODE (trial) = -1;
2473           try_split (seq, trial, last);
2474         }
2475
2476       /* Return either the first or the last insn, depending on which was
2477          requested.  */
2478       return last
2479                 ? (after ? prev_active_insn (after) : last_insn)
2480                 : next_active_insn (before);
2481     }
2482
2483   return trial;
2484 }
2485 \f
2486 /* Make and return an INSN rtx, initializing all its slots.
2487    Store PATTERN in the pattern slots.  */
2488
2489 rtx
2490 make_insn_raw (pattern)
2491      rtx pattern;
2492 {
2493   register rtx insn;
2494
2495   insn = rtx_alloc (INSN);
2496
2497   INSN_UID (insn) = cur_insn_uid++;
2498   PATTERN (insn) = pattern;
2499   INSN_CODE (insn) = -1;
2500   LOG_LINKS (insn) = NULL;
2501   REG_NOTES (insn) = NULL;
2502
2503 #ifdef ENABLE_RTL_CHECKING
2504   if (insn
2505       && INSN_P (insn)
2506       && (returnjump_p (insn)
2507           || (GET_CODE (insn) == SET
2508               && SET_DEST (insn) == pc_rtx)))
2509     {
2510       warning ("ICE: emit_insn used where emit_jump_insn needed:\n");
2511       debug_rtx (insn);
2512     }
2513 #endif
2514
2515   return insn;
2516 }
2517
2518 /* Like `make_insn' but make a JUMP_INSN instead of an insn.  */
2519
2520 static rtx
2521 make_jump_insn_raw (pattern)
2522      rtx pattern;
2523 {
2524   register rtx insn;
2525
2526   insn = rtx_alloc (JUMP_INSN);
2527   INSN_UID (insn) = cur_insn_uid++;
2528
2529   PATTERN (insn) = pattern;
2530   INSN_CODE (insn) = -1;
2531   LOG_LINKS (insn) = NULL;
2532   REG_NOTES (insn) = NULL;
2533   JUMP_LABEL (insn) = NULL;
2534
2535   return insn;
2536 }
2537
2538 /* Like `make_insn' but make a CALL_INSN instead of an insn.  */
2539
2540 static rtx
2541 make_call_insn_raw (pattern)
2542      rtx pattern;
2543 {
2544   register rtx insn;
2545
2546   insn = rtx_alloc (CALL_INSN);
2547   INSN_UID (insn) = cur_insn_uid++;
2548
2549   PATTERN (insn) = pattern;
2550   INSN_CODE (insn) = -1;
2551   LOG_LINKS (insn) = NULL;
2552   REG_NOTES (insn) = NULL;
2553   CALL_INSN_FUNCTION_USAGE (insn) = NULL;
2554
2555   return insn;
2556 }
2557 \f
2558 /* Add INSN to the end of the doubly-linked list.
2559    INSN may be an INSN, JUMP_INSN, CALL_INSN, CODE_LABEL, BARRIER or NOTE.  */
2560
2561 void
2562 add_insn (insn)
2563      register rtx insn;
2564 {
2565   PREV_INSN (insn) = last_insn;
2566   NEXT_INSN (insn) = 0;
2567
2568   if (NULL != last_insn)
2569     NEXT_INSN (last_insn) = insn;
2570
2571   if (NULL == first_insn)
2572     first_insn = insn;
2573
2574   last_insn = insn;
2575 }
2576
2577 /* Add INSN into the doubly-linked list after insn AFTER.  This and
2578    the next should be the only functions called to insert an insn once
2579    delay slots have been filled since only they know how to update a
2580    SEQUENCE.  */
2581
2582 void
2583 add_insn_after (insn, after)
2584      rtx insn, after;
2585 {
2586   rtx next = NEXT_INSN (after);
2587
2588   if (optimize && INSN_DELETED_P (after))
2589     abort ();
2590
2591   NEXT_INSN (insn) = next;
2592   PREV_INSN (insn) = after;
2593
2594   if (next)
2595     {
2596       PREV_INSN (next) = insn;
2597       if (GET_CODE (next) == INSN && GET_CODE (PATTERN (next)) == SEQUENCE)
2598         PREV_INSN (XVECEXP (PATTERN (next), 0, 0)) = insn;
2599     }
2600   else if (last_insn == after)
2601     last_insn = insn;
2602   else
2603     {
2604       struct sequence_stack *stack = seq_stack;
2605       /* Scan all pending sequences too.  */
2606       for (; stack; stack = stack->next)
2607         if (after == stack->last)
2608           {
2609             stack->last = insn;
2610             break;
2611           }
2612
2613       if (stack == 0)
2614         abort ();
2615     }
2616
2617   NEXT_INSN (after) = insn;
2618   if (GET_CODE (after) == INSN && GET_CODE (PATTERN (after)) == SEQUENCE)
2619     {
2620       rtx sequence = PATTERN (after);
2621       NEXT_INSN (XVECEXP (sequence, 0, XVECLEN (sequence, 0) - 1)) = insn;
2622     }
2623 }
2624
2625 /* Add INSN into the doubly-linked list before insn BEFORE.  This and
2626    the previous should be the only functions called to insert an insn once
2627    delay slots have been filled since only they know how to update a
2628    SEQUENCE.  */
2629
2630 void
2631 add_insn_before (insn, before)
2632      rtx insn, before;
2633 {
2634   rtx prev = PREV_INSN (before);
2635
2636   if (optimize && INSN_DELETED_P (before))
2637     abort ();
2638
2639   PREV_INSN (insn) = prev;
2640   NEXT_INSN (insn) = before;
2641
2642   if (prev)
2643     {
2644       NEXT_INSN (prev) = insn;
2645       if (GET_CODE (prev) == INSN && GET_CODE (PATTERN (prev)) == SEQUENCE)
2646         {
2647           rtx sequence = PATTERN (prev);
2648           NEXT_INSN (XVECEXP (sequence, 0, XVECLEN (sequence, 0) - 1)) = insn;
2649         }
2650     }
2651   else if (first_insn == before)
2652     first_insn = insn;
2653   else
2654     {
2655       struct sequence_stack *stack = seq_stack;
2656       /* Scan all pending sequences too.  */
2657       for (; stack; stack = stack->next)
2658         if (before == stack->first)
2659           {
2660             stack->first = insn;
2661             break;
2662           }
2663
2664       if (stack == 0)
2665         abort ();
2666     }
2667
2668   PREV_INSN (before) = insn;
2669   if (GET_CODE (before) == INSN && GET_CODE (PATTERN (before)) == SEQUENCE)
2670     PREV_INSN (XVECEXP (PATTERN (before), 0, 0)) = insn;
2671 }
2672
2673 /* Remove an insn from its doubly-linked list.  This function knows how
2674    to handle sequences.  */
2675 void
2676 remove_insn (insn)
2677      rtx insn;
2678 {
2679   rtx next = NEXT_INSN (insn);
2680   rtx prev = PREV_INSN (insn);
2681   if (prev)
2682     {
2683       NEXT_INSN (prev) = next;
2684       if (GET_CODE (prev) == INSN && GET_CODE (PATTERN (prev)) == SEQUENCE)
2685         {
2686           rtx sequence = PATTERN (prev);
2687           NEXT_INSN (XVECEXP (sequence, 0, XVECLEN (sequence, 0) - 1)) = next;
2688         }
2689     }
2690   else if (first_insn == insn)
2691     first_insn = next;
2692   else
2693     {
2694       struct sequence_stack *stack = seq_stack;
2695       /* Scan all pending sequences too.  */
2696       for (; stack; stack = stack->next)
2697         if (insn == stack->first)
2698           {
2699             stack->first = next;
2700             break;
2701           }
2702
2703       if (stack == 0)
2704         abort ();
2705     }
2706
2707   if (next)
2708     {
2709       PREV_INSN (next) = prev;
2710       if (GET_CODE (next) == INSN && GET_CODE (PATTERN (next)) == SEQUENCE)
2711         PREV_INSN (XVECEXP (PATTERN (next), 0, 0)) = prev;
2712     }
2713   else if (last_insn == insn)
2714     last_insn = prev;
2715   else
2716     {
2717       struct sequence_stack *stack = seq_stack;
2718       /* Scan all pending sequences too.  */
2719       for (; stack; stack = stack->next)
2720         if (insn == stack->last)
2721           {
2722             stack->last = prev;
2723             break;
2724           }
2725
2726       if (stack == 0)
2727         abort ();
2728     }
2729 }
2730
2731 /* Delete all insns made since FROM.
2732    FROM becomes the new last instruction.  */
2733
2734 void
2735 delete_insns_since (from)
2736      rtx from;
2737 {
2738   if (from == 0)
2739     first_insn = 0;
2740   else
2741     NEXT_INSN (from) = 0;
2742   last_insn = from;
2743 }
2744
2745 /* This function is deprecated, please use sequences instead.
2746
2747    Move a consecutive bunch of insns to a different place in the chain.
2748    The insns to be moved are those between FROM and TO.
2749    They are moved to a new position after the insn AFTER.
2750    AFTER must not be FROM or TO or any insn in between.
2751
2752    This function does not know about SEQUENCEs and hence should not be
2753    called after delay-slot filling has been done.  */
2754
2755 void
2756 reorder_insns (from, to, after)
2757      rtx from, to, after;
2758 {
2759   /* Splice this bunch out of where it is now.  */
2760   if (PREV_INSN (from))
2761     NEXT_INSN (PREV_INSN (from)) = NEXT_INSN (to);
2762   if (NEXT_INSN (to))
2763     PREV_INSN (NEXT_INSN (to)) = PREV_INSN (from);
2764   if (last_insn == to)
2765     last_insn = PREV_INSN (from);
2766   if (first_insn == from)
2767     first_insn = NEXT_INSN (to);
2768
2769   /* Make the new neighbors point to it and it to them.  */
2770   if (NEXT_INSN (after))
2771     PREV_INSN (NEXT_INSN (after)) = to;
2772
2773   NEXT_INSN (to) = NEXT_INSN (after);
2774   PREV_INSN (from) = after;
2775   NEXT_INSN (after) = from;
2776   if (after == last_insn)
2777     last_insn = to;
2778 }
2779
2780 /* Return the line note insn preceding INSN.  */
2781
2782 static rtx
2783 find_line_note (insn)
2784      rtx insn;
2785 {
2786   if (no_line_numbers)
2787     return 0;
2788
2789   for (; insn; insn = PREV_INSN (insn))
2790     if (GET_CODE (insn) == NOTE
2791         && NOTE_LINE_NUMBER (insn) >= 0)
2792       break;
2793
2794   return insn;
2795 }
2796
2797 /* Like reorder_insns, but inserts line notes to preserve the line numbers
2798    of the moved insns when debugging.  This may insert a note between AFTER
2799    and FROM, and another one after TO.  */
2800
2801 void
2802 reorder_insns_with_line_notes (from, to, after)
2803      rtx from, to, after;
2804 {
2805   rtx from_line = find_line_note (from);
2806   rtx after_line = find_line_note (after);
2807
2808   reorder_insns (from, to, after);
2809
2810   if (from_line == after_line)
2811     return;
2812
2813   if (from_line)
2814     emit_line_note_after (NOTE_SOURCE_FILE (from_line),
2815                           NOTE_LINE_NUMBER (from_line),
2816                           after);
2817   if (after_line)
2818     emit_line_note_after (NOTE_SOURCE_FILE (after_line),
2819                           NOTE_LINE_NUMBER (after_line),
2820                           to);
2821 }
2822
2823 /* Remove unnecessary notes from the instruction stream.  */
2824
2825 void
2826 remove_unnecessary_notes ()
2827 {
2828   rtx insn;
2829   rtx next;
2830
2831   /* We must not remove the first instruction in the function because
2832      the compiler depends on the first instruction being a note.  */
2833   for (insn = NEXT_INSN (get_insns ()); insn; insn = next)
2834     {
2835       /* Remember what's next.  */
2836       next = NEXT_INSN (insn);
2837
2838       /* We're only interested in notes.  */
2839       if (GET_CODE (insn) != NOTE)
2840         continue;
2841
2842       /* By now, all notes indicating lexical blocks should have
2843          NOTE_BLOCK filled in.  */
2844       if ((NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG
2845            || NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END)
2846           && NOTE_BLOCK (insn) == NULL_TREE)
2847         abort ();
2848
2849       /* Remove NOTE_INSN_DELETED notes.  */
2850       if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED)
2851         remove_insn (insn);
2852       else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END)
2853         {
2854           /* Scan back to see if there are any non-note instructions
2855              between INSN and the beginning of this block.  If not,
2856              then there is no PC range in the generated code that will
2857              actually be in this block, so there's no point in
2858              remembering the existence of the block.  */
2859           rtx prev;
2860
2861           for (prev = PREV_INSN (insn); prev; prev = PREV_INSN (prev))
2862             {
2863               /* This block contains a real instruction.  Note that we
2864                  don't include labels; if the only thing in the block
2865                  is a label, then there are still no PC values that
2866                  lie within the block.  */
2867               if (INSN_P (prev))
2868                 break;
2869
2870               /* We're only interested in NOTEs.  */
2871               if (GET_CODE (prev) != NOTE)
2872                 continue;
2873
2874               if (NOTE_LINE_NUMBER (prev) == NOTE_INSN_BLOCK_BEG)
2875                 {
2876                   /* If the BLOCKs referred to by these notes don't
2877                      match, then something is wrong with our BLOCK
2878                      nesting structure.  */
2879                   if (NOTE_BLOCK (prev) != NOTE_BLOCK (insn))
2880                     abort ();
2881
2882                   if (debug_ignore_block (NOTE_BLOCK (insn)))
2883                     {
2884                       remove_insn (prev);
2885                       remove_insn (insn);
2886                     }
2887                   break;
2888                 }
2889               else if (NOTE_LINE_NUMBER (prev) == NOTE_INSN_BLOCK_END)
2890                 /* There's a nested block.  We need to leave the
2891                    current block in place since otherwise the debugger
2892                    wouldn't be able to show symbols from our block in
2893                    the nested block.  */
2894                 break;
2895             }
2896         }
2897     }
2898 }
2899
2900 \f
2901 /* Emit an insn of given code and pattern
2902    at a specified place within the doubly-linked list.  */
2903
2904 /* Make an instruction with body PATTERN
2905    and output it before the instruction BEFORE.  */
2906
2907 rtx
2908 emit_insn_before (pattern, before)
2909      register rtx pattern, before;
2910 {
2911   register rtx insn = before;
2912
2913   if (GET_CODE (pattern) == SEQUENCE)
2914     {
2915       register int i;
2916
2917       for (i = 0; i < XVECLEN (pattern, 0); i++)
2918         {
2919           insn = XVECEXP (pattern, 0, i);
2920           add_insn_before (insn, before);
2921         }
2922     }
2923   else
2924     {
2925       insn = make_insn_raw (pattern);
2926       add_insn_before (insn, before);
2927     }
2928
2929   return insn;
2930 }
2931
2932 /* Similar to emit_insn_before, but update basic block boundaries as well.  */
2933
2934 rtx
2935 emit_block_insn_before (pattern, before, block)
2936      rtx pattern, before;
2937      basic_block block;
2938 {
2939   rtx prev = PREV_INSN (before);
2940   rtx r = emit_insn_before (pattern, before);
2941   if (block && block->head == before)
2942     block->head = NEXT_INSN (prev);
2943   return r;
2944 }
2945
2946 /* Make an instruction with body PATTERN and code JUMP_INSN
2947    and output it before the instruction BEFORE.  */
2948
2949 rtx
2950 emit_jump_insn_before (pattern, before)
2951      register rtx pattern, before;
2952 {
2953   register rtx insn;
2954
2955   if (GET_CODE (pattern) == SEQUENCE)
2956     insn = emit_insn_before (pattern, before);
2957   else
2958     {
2959       insn = make_jump_insn_raw (pattern);
2960       add_insn_before (insn, before);
2961     }
2962
2963   return insn;
2964 }
2965
2966 /* Make an instruction with body PATTERN and code CALL_INSN
2967    and output it before the instruction BEFORE.  */
2968
2969 rtx
2970 emit_call_insn_before (pattern, before)
2971      register rtx pattern, before;
2972 {
2973   register rtx insn;
2974
2975   if (GET_CODE (pattern) == SEQUENCE)
2976     insn = emit_insn_before (pattern, before);
2977   else
2978     {
2979       insn = make_call_insn_raw (pattern);
2980       add_insn_before (insn, before);
2981       PUT_CODE (insn, CALL_INSN);
2982     }
2983
2984   return insn;
2985 }
2986
2987 /* Make an insn of code BARRIER
2988    and output it before the insn BEFORE.  */
2989
2990 rtx
2991 emit_barrier_before (before)
2992      register rtx before;
2993 {
2994   register rtx insn = rtx_alloc (BARRIER);
2995
2996   INSN_UID (insn) = cur_insn_uid++;
2997
2998   add_insn_before (insn, before);
2999   return insn;
3000 }
3001
3002 /* Emit the label LABEL before the insn BEFORE.  */
3003
3004 rtx
3005 emit_label_before (label, before)
3006      rtx label, before;
3007 {
3008   /* This can be called twice for the same label as a result of the
3009      confusion that follows a syntax error!  So make it harmless.  */
3010   if (INSN_UID (label) == 0)
3011     {
3012       INSN_UID (label) = cur_insn_uid++;
3013       add_insn_before (label, before);
3014     }
3015
3016   return label;
3017 }
3018
3019 /* Emit a note of subtype SUBTYPE before the insn BEFORE.  */
3020
3021 rtx
3022 emit_note_before (subtype, before)
3023      int subtype;
3024      rtx before;
3025 {
3026   register rtx note = rtx_alloc (NOTE);
3027   INSN_UID (note) = cur_insn_uid++;
3028   NOTE_SOURCE_FILE (note) = 0;
3029   NOTE_LINE_NUMBER (note) = subtype;
3030
3031   add_insn_before (note, before);
3032   return note;
3033 }
3034 \f
3035 /* Make an insn of code INSN with body PATTERN
3036    and output it after the insn AFTER.  */
3037
3038 rtx
3039 emit_insn_after (pattern, after)
3040      register rtx pattern, after;
3041 {
3042   register rtx insn = after;
3043
3044   if (GET_CODE (pattern) == SEQUENCE)
3045     {
3046       register int i;
3047
3048       for (i = 0; i < XVECLEN (pattern, 0); i++)
3049         {
3050           insn = XVECEXP (pattern, 0, i);
3051           add_insn_after (insn, after);
3052           after = insn;
3053         }
3054     }
3055   else
3056     {
3057       insn = make_insn_raw (pattern);
3058       add_insn_after (insn, after);
3059     }
3060
3061   return insn;
3062 }
3063
3064 /* Similar to emit_insn_after, except that line notes are to be inserted so
3065    as to act as if this insn were at FROM.  */
3066
3067 void
3068 emit_insn_after_with_line_notes (pattern, after, from)
3069      rtx pattern, after, from;
3070 {
3071   rtx from_line = find_line_note (from);
3072   rtx after_line = find_line_note (after);
3073   rtx insn = emit_insn_after (pattern, after);
3074
3075   if (from_line)
3076     emit_line_note_after (NOTE_SOURCE_FILE (from_line),
3077                           NOTE_LINE_NUMBER (from_line),
3078                           after);
3079
3080   if (after_line)
3081     emit_line_note_after (NOTE_SOURCE_FILE (after_line),
3082                           NOTE_LINE_NUMBER (after_line),
3083                           insn);
3084 }
3085
3086 /* Similar to emit_insn_after, but update basic block boundaries as well.  */
3087
3088 rtx
3089 emit_block_insn_after (pattern, after, block)
3090      rtx pattern, after;
3091      basic_block block;
3092 {
3093   rtx r = emit_insn_after (pattern, after);
3094   if (block && block->end == after)
3095     block->end = r;
3096   return r;
3097 }
3098
3099 /* Make an insn of code JUMP_INSN with body PATTERN
3100    and output it after the insn AFTER.  */
3101
3102 rtx
3103 emit_jump_insn_after (pattern, after)
3104      register rtx pattern, after;
3105 {
3106   register rtx insn;
3107
3108   if (GET_CODE (pattern) == SEQUENCE)
3109     insn = emit_insn_after (pattern, after);
3110   else
3111     {
3112       insn = make_jump_insn_raw (pattern);
3113       add_insn_after (insn, after);
3114     }
3115
3116   return insn;
3117 }
3118
3119 /* Make an insn of code BARRIER
3120    and output it after the insn AFTER.  */
3121
3122 rtx
3123 emit_barrier_after (after)
3124      register rtx after;
3125 {
3126   register rtx insn = rtx_alloc (BARRIER);
3127
3128   INSN_UID (insn) = cur_insn_uid++;
3129
3130   add_insn_after (insn, after);
3131   return insn;
3132 }
3133
3134 /* Emit the label LABEL after the insn AFTER.  */
3135
3136 rtx
3137 emit_label_after (label, after)
3138      rtx label, after;
3139 {
3140   /* This can be called twice for the same label
3141      as a result of the confusion that follows a syntax error!
3142      So make it harmless.  */
3143   if (INSN_UID (label) == 0)
3144     {
3145       INSN_UID (label) = cur_insn_uid++;
3146       add_insn_after (label, after);
3147     }
3148
3149   return label;
3150 }
3151
3152 /* Emit a note of subtype SUBTYPE after the insn AFTER.  */
3153
3154 rtx
3155 emit_note_after (subtype, after)
3156      int subtype;
3157      rtx after;
3158 {
3159   register rtx note = rtx_alloc (NOTE);
3160   INSN_UID (note) = cur_insn_uid++;
3161   NOTE_SOURCE_FILE (note) = 0;
3162   NOTE_LINE_NUMBER (note) = subtype;
3163   add_insn_after (note, after);
3164   return note;
3165 }
3166
3167 /* Emit a line note for FILE and LINE after the insn AFTER.  */
3168
3169 rtx
3170 emit_line_note_after (file, line, after)
3171      const char *file;
3172      int line;
3173      rtx after;
3174 {
3175   register rtx note;
3176
3177   if (no_line_numbers && line > 0)
3178     {
3179       cur_insn_uid++;
3180       return 0;
3181     }
3182
3183   note  = rtx_alloc (NOTE);
3184   INSN_UID (note) = cur_insn_uid++;
3185   NOTE_SOURCE_FILE (note) = file;
3186   NOTE_LINE_NUMBER (note) = line;
3187   add_insn_after (note, after);
3188   return note;
3189 }
3190 \f
3191 /* Make an insn of code INSN with pattern PATTERN
3192    and add it to the end of the doubly-linked list.
3193    If PATTERN is a SEQUENCE, take the elements of it
3194    and emit an insn for each element.
3195
3196    Returns the last insn emitted.  */
3197
3198 rtx
3199 emit_insn (pattern)
3200      rtx pattern;
3201 {
3202   rtx insn = last_insn;
3203
3204   if (GET_CODE (pattern) == SEQUENCE)
3205     {
3206       register int i;
3207
3208       for (i = 0; i < XVECLEN (pattern, 0); i++)
3209         {
3210           insn = XVECEXP (pattern, 0, i);
3211           add_insn (insn);
3212         }
3213     }
3214   else
3215     {
3216       insn = make_insn_raw (pattern);
3217       add_insn (insn);
3218     }
3219
3220   return insn;
3221 }
3222
3223 /* Emit the insns in a chain starting with INSN.
3224    Return the last insn emitted.  */
3225
3226 rtx
3227 emit_insns (insn)
3228      rtx insn;
3229 {
3230   rtx last = 0;
3231
3232   while (insn)
3233     {
3234       rtx next = NEXT_INSN (insn);
3235       add_insn (insn);
3236       last = insn;
3237       insn = next;
3238     }
3239
3240   return last;
3241 }
3242
3243 /* Emit the insns in a chain starting with INSN and place them in front of
3244    the insn BEFORE.  Return the last insn emitted.  */
3245
3246 rtx
3247 emit_insns_before (insn, before)
3248      rtx insn;
3249      rtx before;
3250 {
3251   rtx last = 0;
3252
3253   while (insn)
3254     {
3255       rtx next = NEXT_INSN (insn);
3256       add_insn_before (insn, before);
3257       last = insn;
3258       insn = next;
3259     }
3260
3261   return last;
3262 }
3263
3264 /* Emit the insns in a chain starting with FIRST and place them in back of
3265    the insn AFTER.  Return the last insn emitted.  */
3266
3267 rtx
3268 emit_insns_after (first, after)
3269      register rtx first;
3270      register rtx after;
3271 {
3272   register rtx last;
3273   register rtx after_after;
3274
3275   if (!after)
3276     abort ();
3277
3278   if (!first)
3279     return first;
3280
3281   for (last = first; NEXT_INSN (last); last = NEXT_INSN (last))
3282     continue;
3283
3284   after_after = NEXT_INSN (after);
3285
3286   NEXT_INSN (after) = first;
3287   PREV_INSN (first) = after;
3288   NEXT_INSN (last) = after_after;
3289   if (after_after)
3290     PREV_INSN (after_after) = last;
3291
3292   if (after == last_insn)
3293     last_insn = last;
3294   return last;
3295 }
3296
3297 /* Make an insn of code JUMP_INSN with pattern PATTERN
3298    and add it to the end of the doubly-linked list.  */
3299
3300 rtx
3301 emit_jump_insn (pattern)
3302      rtx pattern;
3303 {
3304   if (GET_CODE (pattern) == SEQUENCE)
3305     return emit_insn (pattern);
3306   else
3307     {
3308       register rtx insn = make_jump_insn_raw (pattern);
3309       add_insn (insn);
3310       return insn;
3311     }
3312 }
3313
3314 /* Make an insn of code CALL_INSN with pattern PATTERN
3315    and add it to the end of the doubly-linked list.  */
3316
3317 rtx
3318 emit_call_insn (pattern)
3319      rtx pattern;
3320 {
3321   if (GET_CODE (pattern) == SEQUENCE)
3322     return emit_insn (pattern);
3323   else
3324     {
3325       register rtx insn = make_call_insn_raw (pattern);
3326       add_insn (insn);
3327       PUT_CODE (insn, CALL_INSN);
3328       return insn;
3329     }
3330 }
3331
3332 /* Add the label LABEL to the end of the doubly-linked list.  */
3333
3334 rtx
3335 emit_label (label)
3336      rtx label;
3337 {
3338   /* This can be called twice for the same label
3339      as a result of the confusion that follows a syntax error!
3340      So make it harmless.  */
3341   if (INSN_UID (label) == 0)
3342     {
3343       INSN_UID (label) = cur_insn_uid++;
3344       add_insn (label);
3345     }
3346   return label;
3347 }
3348
3349 /* Make an insn of code BARRIER
3350    and add it to the end of the doubly-linked list.  */
3351
3352 rtx
3353 emit_barrier ()
3354 {
3355   register rtx barrier = rtx_alloc (BARRIER);
3356   INSN_UID (barrier) = cur_insn_uid++;
3357   add_insn (barrier);
3358   return barrier;
3359 }
3360
3361 /* Make an insn of code NOTE
3362    with data-fields specified by FILE and LINE
3363    and add it to the end of the doubly-linked list,
3364    but only if line-numbers are desired for debugging info.  */
3365
3366 rtx
3367 emit_line_note (file, line)
3368      const char *file;
3369      int line;
3370 {
3371   set_file_and_line_for_stmt (file, line);
3372
3373 #if 0
3374   if (no_line_numbers)
3375     return 0;
3376 #endif
3377
3378   return emit_note (file, line);
3379 }
3380
3381 /* Make an insn of code NOTE
3382    with data-fields specified by FILE and LINE
3383    and add it to the end of the doubly-linked list.
3384    If it is a line-number NOTE, omit it if it matches the previous one.  */
3385
3386 rtx
3387 emit_note (file, line)
3388      const char *file;
3389      int line;
3390 {
3391   register rtx note;
3392
3393   if (line > 0)
3394     {
3395       if (file && last_filename && !strcmp (file, last_filename)
3396           && line == last_linenum)
3397         return 0;
3398       last_filename = file;
3399       last_linenum = line;
3400     }
3401
3402   if (no_line_numbers && line > 0)
3403     {
3404       cur_insn_uid++;
3405       return 0;
3406     }
3407
3408   note = rtx_alloc (NOTE);
3409   INSN_UID (note) = cur_insn_uid++;
3410   NOTE_SOURCE_FILE (note) = file;
3411   NOTE_LINE_NUMBER (note) = line;
3412   add_insn (note);
3413   return note;
3414 }
3415
3416 /* Emit a NOTE, and don't omit it even if LINE is the previous note.  */
3417
3418 rtx
3419 emit_line_note_force (file, line)
3420      const char *file;
3421      int line;
3422 {
3423   last_linenum = -1;
3424   return emit_line_note (file, line);
3425 }
3426
3427 /* Cause next statement to emit a line note even if the line number
3428    has not changed.  This is used at the beginning of a function.  */
3429
3430 void
3431 force_next_line_note ()
3432 {
3433   last_linenum = -1;
3434 }
3435
3436 /* Place a note of KIND on insn INSN with DATUM as the datum. If a
3437    note of this type already exists, remove it first. */
3438
3439 void
3440 set_unique_reg_note (insn, kind, datum)
3441      rtx insn;
3442      enum reg_note kind;
3443      rtx datum;
3444 {
3445   rtx note = find_reg_note (insn, kind, NULL_RTX);
3446
3447   /* First remove the note if there already is one.  */
3448   if (note)
3449     remove_note (insn, note);
3450
3451   REG_NOTES (insn) = gen_rtx_EXPR_LIST (kind, datum, REG_NOTES (insn));
3452 }
3453 \f
3454 /* Return an indication of which type of insn should have X as a body.
3455    The value is CODE_LABEL, INSN, CALL_INSN or JUMP_INSN.  */
3456
3457 enum rtx_code
3458 classify_insn (x)
3459      rtx x;
3460 {
3461   if (GET_CODE (x) == CODE_LABEL)
3462     return CODE_LABEL;
3463   if (GET_CODE (x) == CALL)
3464     return CALL_INSN;
3465   if (GET_CODE (x) == RETURN)
3466     return JUMP_INSN;
3467   if (GET_CODE (x) == SET)
3468     {
3469       if (SET_DEST (x) == pc_rtx)
3470         return JUMP_INSN;
3471       else if (GET_CODE (SET_SRC (x)) == CALL)
3472         return CALL_INSN;
3473       else
3474         return INSN;
3475     }
3476   if (GET_CODE (x) == PARALLEL)
3477     {
3478       register int j;
3479       for (j = XVECLEN (x, 0) - 1; j >= 0; j--)
3480         if (GET_CODE (XVECEXP (x, 0, j)) == CALL)
3481           return CALL_INSN;
3482         else if (GET_CODE (XVECEXP (x, 0, j)) == SET
3483                  && SET_DEST (XVECEXP (x, 0, j)) == pc_rtx)
3484           return JUMP_INSN;
3485         else if (GET_CODE (XVECEXP (x, 0, j)) == SET
3486                  && GET_CODE (SET_SRC (XVECEXP (x, 0, j))) == CALL)
3487           return CALL_INSN;
3488     }
3489   return INSN;
3490 }
3491
3492 /* Emit the rtl pattern X as an appropriate kind of insn.
3493    If X is a label, it is simply added into the insn chain.  */
3494
3495 rtx
3496 emit (x)
3497      rtx x;
3498 {
3499   enum rtx_code code = classify_insn (x);
3500
3501   if (code == CODE_LABEL)
3502     return emit_label (x);
3503   else if (code == INSN)
3504     return emit_insn (x);
3505   else if (code == JUMP_INSN)
3506     {
3507       register rtx insn = emit_jump_insn (x);
3508       if (any_uncondjump_p (insn) || GET_CODE (x) == RETURN)
3509         return emit_barrier ();
3510       return insn;
3511     }
3512   else if (code == CALL_INSN)
3513     return emit_call_insn (x);
3514   else
3515     abort ();
3516 }
3517 \f
3518 /* Begin emitting insns to a sequence which can be packaged in an
3519    RTL_EXPR.  If this sequence will contain something that might cause
3520    the compiler to pop arguments to function calls (because those
3521    pops have previously been deferred; see INHIBIT_DEFER_POP for more
3522    details), use do_pending_stack_adjust before calling this function.
3523    That will ensure that the deferred pops are not accidentally
3524    emitted in the middle of this sequence.  */
3525
3526 void
3527 start_sequence ()
3528 {
3529   struct sequence_stack *tem;
3530
3531   tem = (struct sequence_stack *) xmalloc (sizeof (struct sequence_stack));
3532
3533   tem->next = seq_stack;
3534   tem->first = first_insn;
3535   tem->last = last_insn;
3536   tem->sequence_rtl_expr = seq_rtl_expr;
3537
3538   seq_stack = tem;
3539
3540   first_insn = 0;
3541   last_insn = 0;
3542 }
3543
3544 /* Similarly, but indicate that this sequence will be placed in T, an
3545    RTL_EXPR.  See the documentation for start_sequence for more
3546    information about how to use this function.  */
3547
3548 void
3549 start_sequence_for_rtl_expr (t)
3550      tree t;
3551 {
3552   start_sequence ();
3553
3554   seq_rtl_expr = t;
3555 }
3556
3557 /* Set up the insn chain starting with FIRST as the current sequence,
3558    saving the previously current one.  See the documentation for
3559    start_sequence for more information about how to use this function.  */
3560
3561 void
3562 push_to_sequence (first)
3563      rtx first;
3564 {
3565   rtx last;
3566
3567   start_sequence ();
3568
3569   for (last = first; last && NEXT_INSN (last); last = NEXT_INSN (last));
3570
3571   first_insn = first;
3572   last_insn = last;
3573 }
3574
3575 /* Set up the insn chain from a chain stort in FIRST to LAST.  */
3576
3577 void
3578 push_to_full_sequence (first, last)
3579      rtx first, last;
3580 {
3581   start_sequence ();
3582   first_insn = first;
3583   last_insn = last;
3584   /* We really should have the end of the insn chain here.  */
3585   if (last && NEXT_INSN (last))
3586     abort ();
3587 }
3588
3589 /* Set up the outer-level insn chain
3590    as the current sequence, saving the previously current one.  */
3591
3592 void
3593 push_topmost_sequence ()
3594 {
3595   struct sequence_stack *stack, *top = NULL;
3596
3597   start_sequence ();
3598
3599   for (stack = seq_stack; stack; stack = stack->next)
3600     top = stack;
3601
3602   first_insn = top->first;
3603   last_insn = top->last;
3604   seq_rtl_expr = top->sequence_rtl_expr;
3605 }
3606
3607 /* After emitting to the outer-level insn chain, update the outer-level
3608    insn chain, and restore the previous saved state.  */
3609
3610 void
3611 pop_topmost_sequence ()
3612 {
3613   struct sequence_stack *stack, *top = NULL;
3614
3615   for (stack = seq_stack; stack; stack = stack->next)
3616     top = stack;
3617
3618   top->first = first_insn;
3619   top->last = last_insn;
3620   /* ??? Why don't we save seq_rtl_expr here?  */
3621
3622   end_sequence ();
3623 }
3624
3625 /* After emitting to a sequence, restore previous saved state.
3626
3627    To get the contents of the sequence just made, you must call
3628    `gen_sequence' *before* calling here.
3629
3630    If the compiler might have deferred popping arguments while
3631    generating this sequence, and this sequence will not be immediately
3632    inserted into the instruction stream, use do_pending_stack_adjust
3633    before calling gen_sequence.  That will ensure that the deferred
3634    pops are inserted into this sequence, and not into some random
3635    location in the instruction stream.  See INHIBIT_DEFER_POP for more
3636    information about deferred popping of arguments.  */
3637
3638 void
3639 end_sequence ()
3640 {
3641   struct sequence_stack *tem = seq_stack;
3642
3643   first_insn = tem->first;
3644   last_insn = tem->last;
3645   seq_rtl_expr = tem->sequence_rtl_expr;
3646   seq_stack = tem->next;
3647
3648   free (tem);
3649 }
3650
3651 /* This works like end_sequence, but records the old sequence in FIRST
3652    and LAST.  */
3653
3654 void
3655 end_full_sequence (first, last)
3656      rtx *first, *last;
3657 {
3658   *first = first_insn;
3659   *last = last_insn;
3660   end_sequence();
3661 }
3662
3663 /* Return 1 if currently emitting into a sequence.  */
3664
3665 int
3666 in_sequence_p ()
3667 {
3668   return seq_stack != 0;
3669 }
3670
3671 /* Generate a SEQUENCE rtx containing the insns already emitted
3672    to the current sequence.
3673
3674    This is how the gen_... function from a DEFINE_EXPAND
3675    constructs the SEQUENCE that it returns.  */
3676
3677 rtx
3678 gen_sequence ()
3679 {
3680   rtx result;
3681   rtx tem;
3682   int i;
3683   int len;
3684
3685   /* Count the insns in the chain.  */
3686   len = 0;
3687   for (tem = first_insn; tem; tem = NEXT_INSN (tem))
3688     len++;
3689
3690   /* If only one insn, return it rather than a SEQUENCE.
3691      (Now that we cache SEQUENCE expressions, it isn't worth special-casing
3692      the case of an empty list.)
3693      We only return the pattern of an insn if its code is INSN and it
3694      has no notes.  This ensures that no information gets lost.  */
3695   if (len == 1
3696       && ! RTX_FRAME_RELATED_P (first_insn)
3697       && GET_CODE (first_insn) == INSN
3698       /* Don't throw away any reg notes. */
3699       && REG_NOTES (first_insn) == 0)
3700     return PATTERN (first_insn);
3701
3702   result = gen_rtx_SEQUENCE (VOIDmode, rtvec_alloc (len));
3703
3704   for (i = 0, tem = first_insn; tem; tem = NEXT_INSN (tem), i++)
3705     XVECEXP (result, 0, i) = tem;
3706
3707   return result;
3708 }
3709 \f
3710 /* Put the various virtual registers into REGNO_REG_RTX.  */
3711
3712 void
3713 init_virtual_regs (es)
3714      struct emit_status *es;
3715 {
3716   rtx *ptr = es->x_regno_reg_rtx;
3717   ptr[VIRTUAL_INCOMING_ARGS_REGNUM] = virtual_incoming_args_rtx;
3718   ptr[VIRTUAL_STACK_VARS_REGNUM] = virtual_stack_vars_rtx;
3719   ptr[VIRTUAL_STACK_DYNAMIC_REGNUM] = virtual_stack_dynamic_rtx;
3720   ptr[VIRTUAL_OUTGOING_ARGS_REGNUM] = virtual_outgoing_args_rtx;
3721   ptr[VIRTUAL_CFA_REGNUM] = virtual_cfa_rtx;
3722 }
3723
3724 void
3725 clear_emit_caches ()
3726 {
3727   int i;
3728
3729   /* Clear the start_sequence/gen_sequence cache.  */
3730   for (i = 0; i < SEQUENCE_RESULT_SIZE; i++)
3731     sequence_result[i] = 0;
3732   free_insn = 0;
3733 }
3734 \f
3735 /* Used by copy_insn_1 to avoid copying SCRATCHes more than once.  */
3736 static rtx copy_insn_scratch_in[MAX_RECOG_OPERANDS];
3737 static rtx copy_insn_scratch_out[MAX_RECOG_OPERANDS];
3738 static int copy_insn_n_scratches;
3739
3740 /* When an insn is being copied by copy_insn_1, this is nonzero if we have
3741    copied an ASM_OPERANDS.
3742    In that case, it is the original input-operand vector.  */
3743 static rtvec orig_asm_operands_vector;
3744
3745 /* When an insn is being copied by copy_insn_1, this is nonzero if we have
3746    copied an ASM_OPERANDS.
3747    In that case, it is the copied input-operand vector.  */
3748 static rtvec copy_asm_operands_vector;
3749
3750 /* Likewise for the constraints vector.  */
3751 static rtvec orig_asm_constraints_vector;
3752 static rtvec copy_asm_constraints_vector;
3753
3754 /* Recursively create a new copy of an rtx for copy_insn.
3755    This function differs from copy_rtx in that it handles SCRATCHes and
3756    ASM_OPERANDs properly.
3757    Normally, this function is not used directly; use copy_insn as front end.
3758    However, you could first copy an insn pattern with copy_insn and then use
3759    this function afterwards to properly copy any REG_NOTEs containing
3760    SCRATCHes.  */
3761
3762 rtx
3763 copy_insn_1 (orig)
3764      register rtx orig;
3765 {
3766   register rtx copy;
3767   register int i, j;
3768   register RTX_CODE code;
3769   register const char *format_ptr;
3770
3771   code = GET_CODE (orig);
3772
3773   switch (code)
3774     {
3775     case REG:
3776     case QUEUED:
3777     case CONST_INT:
3778     case CONST_DOUBLE:
3779     case SYMBOL_REF:
3780     case CODE_LABEL:
3781     case PC:
3782     case CC0:
3783     case ADDRESSOF:
3784       return orig;
3785
3786     case SCRATCH:
3787       for (i = 0; i < copy_insn_n_scratches; i++)
3788         if (copy_insn_scratch_in[i] == orig)
3789           return copy_insn_scratch_out[i];
3790       break;
3791
3792     case CONST:
3793       /* CONST can be shared if it contains a SYMBOL_REF.  If it contains
3794          a LABEL_REF, it isn't sharable.  */
3795       if (GET_CODE (XEXP (orig, 0)) == PLUS
3796           && GET_CODE (XEXP (XEXP (orig, 0), 0)) == SYMBOL_REF
3797           && GET_CODE (XEXP (XEXP (orig, 0), 1)) == CONST_INT)
3798         return orig;
3799       break;
3800
3801       /* A MEM with a constant address is not sharable.  The problem is that
3802          the constant address may need to be reloaded.  If the mem is shared,
3803          then reloading one copy of this mem will cause all copies to appear
3804          to have been reloaded.  */
3805
3806     default:
3807       break;
3808     }
3809
3810   copy = rtx_alloc (code);
3811
3812   /* Copy the various flags, and other information.  We assume that
3813      all fields need copying, and then clear the fields that should
3814      not be copied.  That is the sensible default behavior, and forces
3815      us to explicitly document why we are *not* copying a flag.  */
3816   memcpy (copy, orig, sizeof (struct rtx_def) - sizeof (rtunion));
3817
3818   /* We do not copy the USED flag, which is used as a mark bit during
3819      walks over the RTL.  */
3820   copy->used = 0;
3821
3822   /* We do not copy JUMP, CALL, or FRAME_RELATED for INSNs.  */
3823   if (GET_RTX_CLASS (code) == 'i')
3824     {
3825       copy->jump = 0;
3826       copy->call = 0;
3827       copy->frame_related = 0;
3828     }
3829
3830   format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
3831
3832   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
3833     {
3834       copy->fld[i] = orig->fld[i];
3835       switch (*format_ptr++)
3836         {
3837         case 'e':
3838           if (XEXP (orig, i) != NULL)
3839             XEXP (copy, i) = copy_insn_1 (XEXP (orig, i));
3840           break;
3841
3842         case 'E':
3843         case 'V':
3844           if (XVEC (orig, i) == orig_asm_constraints_vector)
3845             XVEC (copy, i) = copy_asm_constraints_vector;
3846           else if (XVEC (orig, i) == orig_asm_operands_vector)
3847             XVEC (copy, i) = copy_asm_operands_vector;
3848           else if (XVEC (orig, i) != NULL)
3849             {
3850               XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
3851               for (j = 0; j < XVECLEN (copy, i); j++)
3852                 XVECEXP (copy, i, j) = copy_insn_1 (XVECEXP (orig, i, j));
3853             }
3854           break;
3855
3856         case 't':
3857         case 'w':
3858         case 'i':
3859         case 's':
3860         case 'S':
3861         case 'u':
3862         case '0':
3863           /* These are left unchanged.  */
3864           break;
3865
3866         default:
3867           abort ();
3868         }
3869     }
3870
3871   if (code == SCRATCH)
3872     {
3873       i = copy_insn_n_scratches++;
3874       if (i >= MAX_RECOG_OPERANDS)
3875         abort ();
3876       copy_insn_scratch_in[i] = orig;
3877       copy_insn_scratch_out[i] = copy;
3878     }
3879   else if (code == ASM_OPERANDS)
3880     {
3881       orig_asm_operands_vector = ASM_OPERANDS_INPUT_VEC (orig);
3882       copy_asm_operands_vector = ASM_OPERANDS_INPUT_VEC (copy);
3883       orig_asm_constraints_vector = ASM_OPERANDS_INPUT_CONSTRAINT_VEC (orig);
3884       copy_asm_constraints_vector = ASM_OPERANDS_INPUT_CONSTRAINT_VEC (copy);
3885     }
3886
3887   return copy;
3888 }
3889
3890 /* Create a new copy of an rtx.
3891    This function differs from copy_rtx in that it handles SCRATCHes and
3892    ASM_OPERANDs properly.
3893    INSN doesn't really have to be a full INSN; it could be just the
3894    pattern.  */
3895 rtx
3896 copy_insn (insn)
3897      rtx insn;
3898 {
3899   copy_insn_n_scratches = 0;
3900   orig_asm_operands_vector = 0;
3901   orig_asm_constraints_vector = 0;
3902   copy_asm_operands_vector = 0;
3903   copy_asm_constraints_vector = 0;
3904   return copy_insn_1 (insn);
3905 }
3906
3907 /* Initialize data structures and variables in this file
3908    before generating rtl for each function.  */
3909
3910 void
3911 init_emit ()
3912 {
3913   struct function *f = cfun;
3914
3915   f->emit = (struct emit_status *) xmalloc (sizeof (struct emit_status));
3916   first_insn = NULL;
3917   last_insn = NULL;
3918   seq_rtl_expr = NULL;
3919   cur_insn_uid = 1;
3920   reg_rtx_no = LAST_VIRTUAL_REGISTER + 1;
3921   last_linenum = 0;
3922   last_filename = 0;
3923   first_label_num = label_num;
3924   last_label_num = 0;
3925   seq_stack = NULL;
3926
3927   clear_emit_caches ();
3928
3929   /* Init the tables that describe all the pseudo regs.  */
3930
3931   f->emit->regno_pointer_align_length = LAST_VIRTUAL_REGISTER + 101;
3932
3933   f->emit->regno_pointer_align
3934     = (unsigned char *) xcalloc (f->emit->regno_pointer_align_length,
3935                                  sizeof (unsigned char));
3936
3937   regno_reg_rtx
3938     = (rtx *) xcalloc (f->emit->regno_pointer_align_length * sizeof (rtx),
3939                        sizeof (rtx));
3940
3941   /* Put copies of all the virtual register rtx into regno_reg_rtx.  */
3942   init_virtual_regs (f->emit);
3943
3944   /* Indicate that the virtual registers and stack locations are
3945      all pointers.  */
3946   REG_POINTER (stack_pointer_rtx) = 1;
3947   REG_POINTER (frame_pointer_rtx) = 1;
3948   REG_POINTER (hard_frame_pointer_rtx) = 1;
3949   REG_POINTER (arg_pointer_rtx) = 1;
3950
3951   REG_POINTER (virtual_incoming_args_rtx) = 1;
3952   REG_POINTER (virtual_stack_vars_rtx) = 1;
3953   REG_POINTER (virtual_stack_dynamic_rtx) = 1;
3954   REG_POINTER (virtual_outgoing_args_rtx) = 1;
3955   REG_POINTER (virtual_cfa_rtx) = 1;
3956
3957 #ifdef STACK_BOUNDARY
3958   REGNO_POINTER_ALIGN (STACK_POINTER_REGNUM) = STACK_BOUNDARY;
3959   REGNO_POINTER_ALIGN (FRAME_POINTER_REGNUM) = STACK_BOUNDARY;
3960   REGNO_POINTER_ALIGN (HARD_FRAME_POINTER_REGNUM) = STACK_BOUNDARY;
3961   REGNO_POINTER_ALIGN (ARG_POINTER_REGNUM) = STACK_BOUNDARY;
3962
3963   REGNO_POINTER_ALIGN (VIRTUAL_INCOMING_ARGS_REGNUM) = STACK_BOUNDARY;
3964   REGNO_POINTER_ALIGN (VIRTUAL_STACK_VARS_REGNUM) = STACK_BOUNDARY;
3965   REGNO_POINTER_ALIGN (VIRTUAL_STACK_DYNAMIC_REGNUM) = STACK_BOUNDARY;
3966   REGNO_POINTER_ALIGN (VIRTUAL_OUTGOING_ARGS_REGNUM) = STACK_BOUNDARY;
3967   REGNO_POINTER_ALIGN (VIRTUAL_CFA_REGNUM) = BITS_PER_WORD;
3968 #endif
3969
3970 #ifdef INIT_EXPANDERS
3971   INIT_EXPANDERS;
3972 #endif
3973 }
3974
3975 /* Mark SS for GC.  */
3976
3977 static void
3978 mark_sequence_stack (ss)
3979      struct sequence_stack *ss;
3980 {
3981   while (ss)
3982     {
3983       ggc_mark_rtx (ss->first);
3984       ggc_mark_tree (ss->sequence_rtl_expr);
3985       ss = ss->next;
3986     }
3987 }
3988
3989 /* Mark ES for GC.  */
3990
3991 void
3992 mark_emit_status (es)
3993      struct emit_status *es;
3994 {
3995   rtx *r;
3996   int i;
3997
3998   if (es == 0)
3999     return;
4000
4001   for (i = es->regno_pointer_align_length, r = es->x_regno_reg_rtx;
4002        i > 0; --i, ++r)
4003     ggc_mark_rtx (*r);
4004
4005   mark_sequence_stack (es->sequence_stack);
4006   ggc_mark_tree (es->sequence_rtl_expr);
4007   ggc_mark_rtx (es->x_first_insn);
4008 }
4009
4010 /* Create some permanent unique rtl objects shared between all functions.
4011    LINE_NUMBERS is nonzero if line numbers are to be generated.  */
4012
4013 void
4014 init_emit_once (line_numbers)
4015      int line_numbers;
4016 {
4017   int i;
4018   enum machine_mode mode;
4019   enum machine_mode double_mode;
4020
4021   /* Initialize the CONST_INT hash table.  */
4022   const_int_htab = htab_create (37, const_int_htab_hash,
4023                                 const_int_htab_eq, NULL);
4024   ggc_add_root (&const_int_htab, 1, sizeof (const_int_htab),
4025                 rtx_htab_mark);
4026
4027   no_line_numbers = ! line_numbers;
4028
4029   /* Compute the word and byte modes.  */
4030
4031   byte_mode = VOIDmode;
4032   word_mode = VOIDmode;
4033   double_mode = VOIDmode;
4034
4035   for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
4036        mode = GET_MODE_WIDER_MODE (mode))
4037     {
4038       if (GET_MODE_BITSIZE (mode) == BITS_PER_UNIT
4039           && byte_mode == VOIDmode)
4040         byte_mode = mode;
4041
4042       if (GET_MODE_BITSIZE (mode) == BITS_PER_WORD
4043           && word_mode == VOIDmode)
4044         word_mode = mode;
4045     }
4046
4047   for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT); mode != VOIDmode;
4048        mode = GET_MODE_WIDER_MODE (mode))
4049     {
4050       if (GET_MODE_BITSIZE (mode) == DOUBLE_TYPE_SIZE
4051           && double_mode == VOIDmode)
4052         double_mode = mode;
4053     }
4054
4055   ptr_mode = mode_for_size (POINTER_SIZE, GET_MODE_CLASS (Pmode), 0);
4056
4057   /* Assign register numbers to the globally defined register rtx.
4058      This must be done at runtime because the register number field
4059      is in a union and some compilers can't initialize unions.  */
4060
4061   pc_rtx = gen_rtx (PC, VOIDmode);
4062   cc0_rtx = gen_rtx (CC0, VOIDmode);
4063   stack_pointer_rtx = gen_raw_REG (Pmode, STACK_POINTER_REGNUM);
4064   frame_pointer_rtx = gen_raw_REG (Pmode, FRAME_POINTER_REGNUM);
4065   if (hard_frame_pointer_rtx == 0)
4066     hard_frame_pointer_rtx = gen_raw_REG (Pmode,
4067                                           HARD_FRAME_POINTER_REGNUM);
4068   if (arg_pointer_rtx == 0)
4069     arg_pointer_rtx = gen_raw_REG (Pmode, ARG_POINTER_REGNUM);
4070   virtual_incoming_args_rtx =
4071     gen_raw_REG (Pmode, VIRTUAL_INCOMING_ARGS_REGNUM);
4072   virtual_stack_vars_rtx =
4073     gen_raw_REG (Pmode, VIRTUAL_STACK_VARS_REGNUM);
4074   virtual_stack_dynamic_rtx =
4075     gen_raw_REG (Pmode, VIRTUAL_STACK_DYNAMIC_REGNUM);
4076   virtual_outgoing_args_rtx =
4077     gen_raw_REG (Pmode, VIRTUAL_OUTGOING_ARGS_REGNUM);
4078   virtual_cfa_rtx = gen_raw_REG (Pmode, VIRTUAL_CFA_REGNUM);
4079
4080   /* These rtx must be roots if GC is enabled.  */
4081   ggc_add_rtx_root (global_rtl, GR_MAX);
4082
4083 #ifdef INIT_EXPANDERS
4084   /* This is to initialize {init|mark|free}_machine_status before the first
4085      call to push_function_context_to.  This is needed by the Chill front
4086      end which calls push_function_context_to before the first cal to
4087      init_function_start.  */
4088   INIT_EXPANDERS;
4089 #endif
4090
4091   /* Create the unique rtx's for certain rtx codes and operand values.  */
4092
4093   /* Don't use gen_rtx here since gen_rtx in this case
4094      tries to use these variables.  */
4095   for (i = - MAX_SAVED_CONST_INT; i <= MAX_SAVED_CONST_INT; i++)
4096     const_int_rtx[i + MAX_SAVED_CONST_INT] =
4097       gen_rtx_raw_CONST_INT (VOIDmode, i);
4098   ggc_add_rtx_root (const_int_rtx, 2 * MAX_SAVED_CONST_INT + 1);
4099
4100   if (STORE_FLAG_VALUE >= - MAX_SAVED_CONST_INT
4101       && STORE_FLAG_VALUE <= MAX_SAVED_CONST_INT)
4102     const_true_rtx = const_int_rtx[STORE_FLAG_VALUE + MAX_SAVED_CONST_INT];
4103   else
4104     const_true_rtx = gen_rtx_CONST_INT (VOIDmode, STORE_FLAG_VALUE);
4105
4106   dconst0 = REAL_VALUE_ATOF ("0", double_mode);
4107   dconst1 = REAL_VALUE_ATOF ("1", double_mode);
4108   dconst2 = REAL_VALUE_ATOF ("2", double_mode);
4109   dconstm1 = REAL_VALUE_ATOF ("-1", double_mode);
4110
4111   for (i = 0; i <= 2; i++)
4112     {
4113       for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT); mode != VOIDmode;
4114            mode = GET_MODE_WIDER_MODE (mode))
4115         {
4116           rtx tem = rtx_alloc (CONST_DOUBLE);
4117           union real_extract u;
4118
4119           memset ((char *) &u, 0, sizeof u);  /* Zero any holes in a structure.  */
4120           u.d = i == 0 ? dconst0 : i == 1 ? dconst1 : dconst2;
4121
4122           memcpy (&CONST_DOUBLE_LOW (tem), &u, sizeof u);
4123           CONST_DOUBLE_MEM (tem) = cc0_rtx;
4124           CONST_DOUBLE_CHAIN (tem) = NULL_RTX;
4125           PUT_MODE (tem, mode);
4126
4127           const_tiny_rtx[i][(int) mode] = tem;
4128         }
4129
4130       const_tiny_rtx[i][(int) VOIDmode] = GEN_INT (i);
4131
4132       for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
4133            mode = GET_MODE_WIDER_MODE (mode))
4134         const_tiny_rtx[i][(int) mode] = GEN_INT (i);
4135
4136       for (mode = GET_CLASS_NARROWEST_MODE (MODE_PARTIAL_INT);
4137            mode != VOIDmode;
4138            mode = GET_MODE_WIDER_MODE (mode))
4139         const_tiny_rtx[i][(int) mode] = GEN_INT (i);
4140     }
4141
4142   for (mode = CCmode; mode < MAX_MACHINE_MODE; ++mode)
4143     if (GET_MODE_CLASS (mode) == MODE_CC)
4144       const_tiny_rtx[0][(int) mode] = const0_rtx;
4145
4146   const_tiny_rtx[0][(int) BImode] = const0_rtx;
4147   if (STORE_FLAG_VALUE == 1)
4148     const_tiny_rtx[1][(int) BImode] = const1_rtx;
4149
4150   /* For bounded pointers, `&const_tiny_rtx[0][0]' is not the same as
4151      `(rtx *) const_tiny_rtx'.  The former has bounds that only cover
4152      `const_tiny_rtx[0]', whereas the latter has bounds that cover all.  */
4153   ggc_add_rtx_root ((rtx *) const_tiny_rtx, sizeof const_tiny_rtx / sizeof (rtx));
4154   ggc_add_rtx_root (&const_true_rtx, 1);
4155
4156 #ifdef RETURN_ADDRESS_POINTER_REGNUM
4157   return_address_pointer_rtx
4158     = gen_raw_REG (Pmode, RETURN_ADDRESS_POINTER_REGNUM);
4159 #endif
4160
4161 #ifdef STRUCT_VALUE
4162   struct_value_rtx = STRUCT_VALUE;
4163 #else
4164   struct_value_rtx = gen_rtx_REG (Pmode, STRUCT_VALUE_REGNUM);
4165 #endif
4166
4167 #ifdef STRUCT_VALUE_INCOMING
4168   struct_value_incoming_rtx = STRUCT_VALUE_INCOMING;
4169 #else
4170 #ifdef STRUCT_VALUE_INCOMING_REGNUM
4171   struct_value_incoming_rtx
4172     = gen_rtx_REG (Pmode, STRUCT_VALUE_INCOMING_REGNUM);
4173 #else
4174   struct_value_incoming_rtx = struct_value_rtx;
4175 #endif
4176 #endif
4177
4178 #ifdef STATIC_CHAIN_REGNUM
4179   static_chain_rtx = gen_rtx_REG (Pmode, STATIC_CHAIN_REGNUM);
4180
4181 #ifdef STATIC_CHAIN_INCOMING_REGNUM
4182   if (STATIC_CHAIN_INCOMING_REGNUM != STATIC_CHAIN_REGNUM)
4183     static_chain_incoming_rtx
4184       = gen_rtx_REG (Pmode, STATIC_CHAIN_INCOMING_REGNUM);
4185   else
4186 #endif
4187     static_chain_incoming_rtx = static_chain_rtx;
4188 #endif
4189
4190 #ifdef STATIC_CHAIN
4191   static_chain_rtx = STATIC_CHAIN;
4192
4193 #ifdef STATIC_CHAIN_INCOMING
4194   static_chain_incoming_rtx = STATIC_CHAIN_INCOMING;
4195 #else
4196   static_chain_incoming_rtx = static_chain_rtx;
4197 #endif
4198 #endif
4199
4200   if (PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM)
4201     pic_offset_table_rtx = gen_rtx_REG (Pmode, PIC_OFFSET_TABLE_REGNUM);
4202
4203   ggc_add_rtx_root (&pic_offset_table_rtx, 1);
4204   ggc_add_rtx_root (&struct_value_rtx, 1);
4205   ggc_add_rtx_root (&struct_value_incoming_rtx, 1);
4206   ggc_add_rtx_root (&static_chain_rtx, 1);
4207   ggc_add_rtx_root (&static_chain_incoming_rtx, 1);
4208   ggc_add_rtx_root (&return_address_pointer_rtx, 1);
4209 }
4210 \f
4211 /* Query and clear/ restore no_line_numbers.  This is used by the
4212    switch / case handling in stmt.c to give proper line numbers in
4213    warnings about unreachable code.  */
4214
4215 int
4216 force_line_numbers ()
4217 {
4218   int old = no_line_numbers;
4219
4220   no_line_numbers = 0;
4221   if (old)
4222     force_next_line_note ();
4223   return old;
4224 }
4225
4226 void
4227 restore_line_number_status (old_value)
4228      int old_value;
4229 {
4230   no_line_numbers = old_value;
4231 }