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                       BLOCK_DEAD (NOTE_BLOCK (insn)) = 1;
2885                       remove_insn (prev);
2886                       remove_insn (insn);
2887                     }
2888                   break;
2889                 }
2890               else if (NOTE_LINE_NUMBER (prev) == NOTE_INSN_BLOCK_END)
2891                 /* There's a nested block.  We need to leave the
2892                    current block in place since otherwise the debugger
2893                    wouldn't be able to show symbols from our block in
2894                    the nested block.  */
2895                 break;
2896             }
2897         }
2898     }
2899 }
2900
2901 \f
2902 /* Emit an insn of given code and pattern
2903    at a specified place within the doubly-linked list.  */
2904
2905 /* Make an instruction with body PATTERN
2906    and output it before the instruction BEFORE.  */
2907
2908 rtx
2909 emit_insn_before (pattern, before)
2910      register rtx pattern, before;
2911 {
2912   register rtx insn = before;
2913
2914   if (GET_CODE (pattern) == SEQUENCE)
2915     {
2916       register int i;
2917
2918       for (i = 0; i < XVECLEN (pattern, 0); i++)
2919         {
2920           insn = XVECEXP (pattern, 0, i);
2921           add_insn_before (insn, before);
2922         }
2923     }
2924   else
2925     {
2926       insn = make_insn_raw (pattern);
2927       add_insn_before (insn, before);
2928     }
2929
2930   return insn;
2931 }
2932
2933 /* Similar to emit_insn_before, but update basic block boundaries as well.  */
2934
2935 rtx
2936 emit_block_insn_before (pattern, before, block)
2937      rtx pattern, before;
2938      basic_block block;
2939 {
2940   rtx prev = PREV_INSN (before);
2941   rtx r = emit_insn_before (pattern, before);
2942   if (block && block->head == before)
2943     block->head = NEXT_INSN (prev);
2944   return r;
2945 }
2946
2947 /* Make an instruction with body PATTERN and code JUMP_INSN
2948    and output it before the instruction BEFORE.  */
2949
2950 rtx
2951 emit_jump_insn_before (pattern, before)
2952      register rtx pattern, before;
2953 {
2954   register rtx insn;
2955
2956   if (GET_CODE (pattern) == SEQUENCE)
2957     insn = emit_insn_before (pattern, before);
2958   else
2959     {
2960       insn = make_jump_insn_raw (pattern);
2961       add_insn_before (insn, before);
2962     }
2963
2964   return insn;
2965 }
2966
2967 /* Make an instruction with body PATTERN and code CALL_INSN
2968    and output it before the instruction BEFORE.  */
2969
2970 rtx
2971 emit_call_insn_before (pattern, before)
2972      register rtx pattern, before;
2973 {
2974   register rtx insn;
2975
2976   if (GET_CODE (pattern) == SEQUENCE)
2977     insn = emit_insn_before (pattern, before);
2978   else
2979     {
2980       insn = make_call_insn_raw (pattern);
2981       add_insn_before (insn, before);
2982       PUT_CODE (insn, CALL_INSN);
2983     }
2984
2985   return insn;
2986 }
2987
2988 /* Make an insn of code BARRIER
2989    and output it before the insn BEFORE.  */
2990
2991 rtx
2992 emit_barrier_before (before)
2993      register rtx before;
2994 {
2995   register rtx insn = rtx_alloc (BARRIER);
2996
2997   INSN_UID (insn) = cur_insn_uid++;
2998
2999   add_insn_before (insn, before);
3000   return insn;
3001 }
3002
3003 /* Emit the label LABEL before the insn BEFORE.  */
3004
3005 rtx
3006 emit_label_before (label, before)
3007      rtx label, before;
3008 {
3009   /* This can be called twice for the same label as a result of the
3010      confusion that follows a syntax error!  So make it harmless.  */
3011   if (INSN_UID (label) == 0)
3012     {
3013       INSN_UID (label) = cur_insn_uid++;
3014       add_insn_before (label, before);
3015     }
3016
3017   return label;
3018 }
3019
3020 /* Emit a note of subtype SUBTYPE before the insn BEFORE.  */
3021
3022 rtx
3023 emit_note_before (subtype, before)
3024      int subtype;
3025      rtx before;
3026 {
3027   register rtx note = rtx_alloc (NOTE);
3028   INSN_UID (note) = cur_insn_uid++;
3029   NOTE_SOURCE_FILE (note) = 0;
3030   NOTE_LINE_NUMBER (note) = subtype;
3031
3032   add_insn_before (note, before);
3033   return note;
3034 }
3035 \f
3036 /* Make an insn of code INSN with body PATTERN
3037    and output it after the insn AFTER.  */
3038
3039 rtx
3040 emit_insn_after (pattern, after)
3041      register rtx pattern, after;
3042 {
3043   register rtx insn = after;
3044
3045   if (GET_CODE (pattern) == SEQUENCE)
3046     {
3047       register int i;
3048
3049       for (i = 0; i < XVECLEN (pattern, 0); i++)
3050         {
3051           insn = XVECEXP (pattern, 0, i);
3052           add_insn_after (insn, after);
3053           after = insn;
3054         }
3055     }
3056   else
3057     {
3058       insn = make_insn_raw (pattern);
3059       add_insn_after (insn, after);
3060     }
3061
3062   return insn;
3063 }
3064
3065 /* Similar to emit_insn_after, except that line notes are to be inserted so
3066    as to act as if this insn were at FROM.  */
3067
3068 void
3069 emit_insn_after_with_line_notes (pattern, after, from)
3070      rtx pattern, after, from;
3071 {
3072   rtx from_line = find_line_note (from);
3073   rtx after_line = find_line_note (after);
3074   rtx insn = emit_insn_after (pattern, after);
3075
3076   if (from_line)
3077     emit_line_note_after (NOTE_SOURCE_FILE (from_line),
3078                           NOTE_LINE_NUMBER (from_line),
3079                           after);
3080
3081   if (after_line)
3082     emit_line_note_after (NOTE_SOURCE_FILE (after_line),
3083                           NOTE_LINE_NUMBER (after_line),
3084                           insn);
3085 }
3086
3087 /* Similar to emit_insn_after, but update basic block boundaries as well.  */
3088
3089 rtx
3090 emit_block_insn_after (pattern, after, block)
3091      rtx pattern, after;
3092      basic_block block;
3093 {
3094   rtx r = emit_insn_after (pattern, after);
3095   if (block && block->end == after)
3096     block->end = r;
3097   return r;
3098 }
3099
3100 /* Make an insn of code JUMP_INSN with body PATTERN
3101    and output it after the insn AFTER.  */
3102
3103 rtx
3104 emit_jump_insn_after (pattern, after)
3105      register rtx pattern, after;
3106 {
3107   register rtx insn;
3108
3109   if (GET_CODE (pattern) == SEQUENCE)
3110     insn = emit_insn_after (pattern, after);
3111   else
3112     {
3113       insn = make_jump_insn_raw (pattern);
3114       add_insn_after (insn, after);
3115     }
3116
3117   return insn;
3118 }
3119
3120 /* Make an insn of code BARRIER
3121    and output it after the insn AFTER.  */
3122
3123 rtx
3124 emit_barrier_after (after)
3125      register rtx after;
3126 {
3127   register rtx insn = rtx_alloc (BARRIER);
3128
3129   INSN_UID (insn) = cur_insn_uid++;
3130
3131   add_insn_after (insn, after);
3132   return insn;
3133 }
3134
3135 /* Emit the label LABEL after the insn AFTER.  */
3136
3137 rtx
3138 emit_label_after (label, after)
3139      rtx label, after;
3140 {
3141   /* This can be called twice for the same label
3142      as a result of the confusion that follows a syntax error!
3143      So make it harmless.  */
3144   if (INSN_UID (label) == 0)
3145     {
3146       INSN_UID (label) = cur_insn_uid++;
3147       add_insn_after (label, after);
3148     }
3149
3150   return label;
3151 }
3152
3153 /* Emit a note of subtype SUBTYPE after the insn AFTER.  */
3154
3155 rtx
3156 emit_note_after (subtype, after)
3157      int subtype;
3158      rtx after;
3159 {
3160   register rtx note = rtx_alloc (NOTE);
3161   INSN_UID (note) = cur_insn_uid++;
3162   NOTE_SOURCE_FILE (note) = 0;
3163   NOTE_LINE_NUMBER (note) = subtype;
3164   add_insn_after (note, after);
3165   return note;
3166 }
3167
3168 /* Emit a line note for FILE and LINE after the insn AFTER.  */
3169
3170 rtx
3171 emit_line_note_after (file, line, after)
3172      const char *file;
3173      int line;
3174      rtx after;
3175 {
3176   register rtx note;
3177
3178   if (no_line_numbers && line > 0)
3179     {
3180       cur_insn_uid++;
3181       return 0;
3182     }
3183
3184   note  = rtx_alloc (NOTE);
3185   INSN_UID (note) = cur_insn_uid++;
3186   NOTE_SOURCE_FILE (note) = file;
3187   NOTE_LINE_NUMBER (note) = line;
3188   add_insn_after (note, after);
3189   return note;
3190 }
3191 \f
3192 /* Make an insn of code INSN with pattern PATTERN
3193    and add it to the end of the doubly-linked list.
3194    If PATTERN is a SEQUENCE, take the elements of it
3195    and emit an insn for each element.
3196
3197    Returns the last insn emitted.  */
3198
3199 rtx
3200 emit_insn (pattern)
3201      rtx pattern;
3202 {
3203   rtx insn = last_insn;
3204
3205   if (GET_CODE (pattern) == SEQUENCE)
3206     {
3207       register int i;
3208
3209       for (i = 0; i < XVECLEN (pattern, 0); i++)
3210         {
3211           insn = XVECEXP (pattern, 0, i);
3212           add_insn (insn);
3213         }
3214     }
3215   else
3216     {
3217       insn = make_insn_raw (pattern);
3218       add_insn (insn);
3219     }
3220
3221   return insn;
3222 }
3223
3224 /* Emit the insns in a chain starting with INSN.
3225    Return the last insn emitted.  */
3226
3227 rtx
3228 emit_insns (insn)
3229      rtx insn;
3230 {
3231   rtx last = 0;
3232
3233   while (insn)
3234     {
3235       rtx next = NEXT_INSN (insn);
3236       add_insn (insn);
3237       last = insn;
3238       insn = next;
3239     }
3240
3241   return last;
3242 }
3243
3244 /* Emit the insns in a chain starting with INSN and place them in front of
3245    the insn BEFORE.  Return the last insn emitted.  */
3246
3247 rtx
3248 emit_insns_before (insn, before)
3249      rtx insn;
3250      rtx before;
3251 {
3252   rtx last = 0;
3253
3254   while (insn)
3255     {
3256       rtx next = NEXT_INSN (insn);
3257       add_insn_before (insn, before);
3258       last = insn;
3259       insn = next;
3260     }
3261
3262   return last;
3263 }
3264
3265 /* Emit the insns in a chain starting with FIRST and place them in back of
3266    the insn AFTER.  Return the last insn emitted.  */
3267
3268 rtx
3269 emit_insns_after (first, after)
3270      register rtx first;
3271      register rtx after;
3272 {
3273   register rtx last;
3274   register rtx after_after;
3275
3276   if (!after)
3277     abort ();
3278
3279   if (!first)
3280     return first;
3281
3282   for (last = first; NEXT_INSN (last); last = NEXT_INSN (last))
3283     continue;
3284
3285   after_after = NEXT_INSN (after);
3286
3287   NEXT_INSN (after) = first;
3288   PREV_INSN (first) = after;
3289   NEXT_INSN (last) = after_after;
3290   if (after_after)
3291     PREV_INSN (after_after) = last;
3292
3293   if (after == last_insn)
3294     last_insn = last;
3295   return last;
3296 }
3297
3298 /* Make an insn of code JUMP_INSN with pattern PATTERN
3299    and add it to the end of the doubly-linked list.  */
3300
3301 rtx
3302 emit_jump_insn (pattern)
3303      rtx pattern;
3304 {
3305   if (GET_CODE (pattern) == SEQUENCE)
3306     return emit_insn (pattern);
3307   else
3308     {
3309       register rtx insn = make_jump_insn_raw (pattern);
3310       add_insn (insn);
3311       return insn;
3312     }
3313 }
3314
3315 /* Make an insn of code CALL_INSN with pattern PATTERN
3316    and add it to the end of the doubly-linked list.  */
3317
3318 rtx
3319 emit_call_insn (pattern)
3320      rtx pattern;
3321 {
3322   if (GET_CODE (pattern) == SEQUENCE)
3323     return emit_insn (pattern);
3324   else
3325     {
3326       register rtx insn = make_call_insn_raw (pattern);
3327       add_insn (insn);
3328       PUT_CODE (insn, CALL_INSN);
3329       return insn;
3330     }
3331 }
3332
3333 /* Add the label LABEL to the end of the doubly-linked list.  */
3334
3335 rtx
3336 emit_label (label)
3337      rtx label;
3338 {
3339   /* This can be called twice for the same label
3340      as a result of the confusion that follows a syntax error!
3341      So make it harmless.  */
3342   if (INSN_UID (label) == 0)
3343     {
3344       INSN_UID (label) = cur_insn_uid++;
3345       add_insn (label);
3346     }
3347   return label;
3348 }
3349
3350 /* Make an insn of code BARRIER
3351    and add it to the end of the doubly-linked list.  */
3352
3353 rtx
3354 emit_barrier ()
3355 {
3356   register rtx barrier = rtx_alloc (BARRIER);
3357   INSN_UID (barrier) = cur_insn_uid++;
3358   add_insn (barrier);
3359   return barrier;
3360 }
3361
3362 /* Make an insn of code NOTE
3363    with data-fields specified by FILE and LINE
3364    and add it to the end of the doubly-linked list,
3365    but only if line-numbers are desired for debugging info.  */
3366
3367 rtx
3368 emit_line_note (file, line)
3369      const char *file;
3370      int line;
3371 {
3372   set_file_and_line_for_stmt (file, line);
3373
3374 #if 0
3375   if (no_line_numbers)
3376     return 0;
3377 #endif
3378
3379   return emit_note (file, line);
3380 }
3381
3382 /* Make an insn of code NOTE
3383    with data-fields specified by FILE and LINE
3384    and add it to the end of the doubly-linked list.
3385    If it is a line-number NOTE, omit it if it matches the previous one.  */
3386
3387 rtx
3388 emit_note (file, line)
3389      const char *file;
3390      int line;
3391 {
3392   register rtx note;
3393
3394   if (line > 0)
3395     {
3396       if (file && last_filename && !strcmp (file, last_filename)
3397           && line == last_linenum)
3398         return 0;
3399       last_filename = file;
3400       last_linenum = line;
3401     }
3402
3403   if (no_line_numbers && line > 0)
3404     {
3405       cur_insn_uid++;
3406       return 0;
3407     }
3408
3409   note = rtx_alloc (NOTE);
3410   INSN_UID (note) = cur_insn_uid++;
3411   NOTE_SOURCE_FILE (note) = file;
3412   NOTE_LINE_NUMBER (note) = line;
3413   add_insn (note);
3414   return note;
3415 }
3416
3417 /* Emit a NOTE, and don't omit it even if LINE is the previous note.  */
3418
3419 rtx
3420 emit_line_note_force (file, line)
3421      const char *file;
3422      int line;
3423 {
3424   last_linenum = -1;
3425   return emit_line_note (file, line);
3426 }
3427
3428 /* Cause next statement to emit a line note even if the line number
3429    has not changed.  This is used at the beginning of a function.  */
3430
3431 void
3432 force_next_line_note ()
3433 {
3434   last_linenum = -1;
3435 }
3436
3437 /* Place a note of KIND on insn INSN with DATUM as the datum. If a
3438    note of this type already exists, remove it first. */
3439
3440 void
3441 set_unique_reg_note (insn, kind, datum)
3442      rtx insn;
3443      enum reg_note kind;
3444      rtx datum;
3445 {
3446   rtx note = find_reg_note (insn, kind, NULL_RTX);
3447
3448   /* First remove the note if there already is one.  */
3449   if (note)
3450     remove_note (insn, note);
3451
3452   REG_NOTES (insn) = gen_rtx_EXPR_LIST (kind, datum, REG_NOTES (insn));
3453 }
3454 \f
3455 /* Return an indication of which type of insn should have X as a body.
3456    The value is CODE_LABEL, INSN, CALL_INSN or JUMP_INSN.  */
3457
3458 enum rtx_code
3459 classify_insn (x)
3460      rtx x;
3461 {
3462   if (GET_CODE (x) == CODE_LABEL)
3463     return CODE_LABEL;
3464   if (GET_CODE (x) == CALL)
3465     return CALL_INSN;
3466   if (GET_CODE (x) == RETURN)
3467     return JUMP_INSN;
3468   if (GET_CODE (x) == SET)
3469     {
3470       if (SET_DEST (x) == pc_rtx)
3471         return JUMP_INSN;
3472       else if (GET_CODE (SET_SRC (x)) == CALL)
3473         return CALL_INSN;
3474       else
3475         return INSN;
3476     }
3477   if (GET_CODE (x) == PARALLEL)
3478     {
3479       register int j;
3480       for (j = XVECLEN (x, 0) - 1; j >= 0; j--)
3481         if (GET_CODE (XVECEXP (x, 0, j)) == CALL)
3482           return CALL_INSN;
3483         else if (GET_CODE (XVECEXP (x, 0, j)) == SET
3484                  && SET_DEST (XVECEXP (x, 0, j)) == pc_rtx)
3485           return JUMP_INSN;
3486         else if (GET_CODE (XVECEXP (x, 0, j)) == SET
3487                  && GET_CODE (SET_SRC (XVECEXP (x, 0, j))) == CALL)
3488           return CALL_INSN;
3489     }
3490   return INSN;
3491 }
3492
3493 /* Emit the rtl pattern X as an appropriate kind of insn.
3494    If X is a label, it is simply added into the insn chain.  */
3495
3496 rtx
3497 emit (x)
3498      rtx x;
3499 {
3500   enum rtx_code code = classify_insn (x);
3501
3502   if (code == CODE_LABEL)
3503     return emit_label (x);
3504   else if (code == INSN)
3505     return emit_insn (x);
3506   else if (code == JUMP_INSN)
3507     {
3508       register rtx insn = emit_jump_insn (x);
3509       if (any_uncondjump_p (insn) || GET_CODE (x) == RETURN)
3510         return emit_barrier ();
3511       return insn;
3512     }
3513   else if (code == CALL_INSN)
3514     return emit_call_insn (x);
3515   else
3516     abort ();
3517 }
3518 \f
3519 /* Begin emitting insns to a sequence which can be packaged in an
3520    RTL_EXPR.  If this sequence will contain something that might cause
3521    the compiler to pop arguments to function calls (because those
3522    pops have previously been deferred; see INHIBIT_DEFER_POP for more
3523    details), use do_pending_stack_adjust before calling this function.
3524    That will ensure that the deferred pops are not accidentally
3525    emitted in the middle of this sequence.  */
3526
3527 void
3528 start_sequence ()
3529 {
3530   struct sequence_stack *tem;
3531
3532   tem = (struct sequence_stack *) xmalloc (sizeof (struct sequence_stack));
3533
3534   tem->next = seq_stack;
3535   tem->first = first_insn;
3536   tem->last = last_insn;
3537   tem->sequence_rtl_expr = seq_rtl_expr;
3538
3539   seq_stack = tem;
3540
3541   first_insn = 0;
3542   last_insn = 0;
3543 }
3544
3545 /* Similarly, but indicate that this sequence will be placed in T, an
3546    RTL_EXPR.  See the documentation for start_sequence for more
3547    information about how to use this function.  */
3548
3549 void
3550 start_sequence_for_rtl_expr (t)
3551      tree t;
3552 {
3553   start_sequence ();
3554
3555   seq_rtl_expr = t;
3556 }
3557
3558 /* Set up the insn chain starting with FIRST as the current sequence,
3559    saving the previously current one.  See the documentation for
3560    start_sequence for more information about how to use this function.  */
3561
3562 void
3563 push_to_sequence (first)
3564      rtx first;
3565 {
3566   rtx last;
3567
3568   start_sequence ();
3569
3570   for (last = first; last && NEXT_INSN (last); last = NEXT_INSN (last));
3571
3572   first_insn = first;
3573   last_insn = last;
3574 }
3575
3576 /* Set up the insn chain from a chain stort in FIRST to LAST.  */
3577
3578 void
3579 push_to_full_sequence (first, last)
3580      rtx first, last;
3581 {
3582   start_sequence ();
3583   first_insn = first;
3584   last_insn = last;
3585   /* We really should have the end of the insn chain here.  */
3586   if (last && NEXT_INSN (last))
3587     abort ();
3588 }
3589
3590 /* Set up the outer-level insn chain
3591    as the current sequence, saving the previously current one.  */
3592
3593 void
3594 push_topmost_sequence ()
3595 {
3596   struct sequence_stack *stack, *top = NULL;
3597
3598   start_sequence ();
3599
3600   for (stack = seq_stack; stack; stack = stack->next)
3601     top = stack;
3602
3603   first_insn = top->first;
3604   last_insn = top->last;
3605   seq_rtl_expr = top->sequence_rtl_expr;
3606 }
3607
3608 /* After emitting to the outer-level insn chain, update the outer-level
3609    insn chain, and restore the previous saved state.  */
3610
3611 void
3612 pop_topmost_sequence ()
3613 {
3614   struct sequence_stack *stack, *top = NULL;
3615
3616   for (stack = seq_stack; stack; stack = stack->next)
3617     top = stack;
3618
3619   top->first = first_insn;
3620   top->last = last_insn;
3621   /* ??? Why don't we save seq_rtl_expr here?  */
3622
3623   end_sequence ();
3624 }
3625
3626 /* After emitting to a sequence, restore previous saved state.
3627
3628    To get the contents of the sequence just made, you must call
3629    `gen_sequence' *before* calling here.
3630
3631    If the compiler might have deferred popping arguments while
3632    generating this sequence, and this sequence will not be immediately
3633    inserted into the instruction stream, use do_pending_stack_adjust
3634    before calling gen_sequence.  That will ensure that the deferred
3635    pops are inserted into this sequence, and not into some random
3636    location in the instruction stream.  See INHIBIT_DEFER_POP for more
3637    information about deferred popping of arguments.  */
3638
3639 void
3640 end_sequence ()
3641 {
3642   struct sequence_stack *tem = seq_stack;
3643
3644   first_insn = tem->first;
3645   last_insn = tem->last;
3646   seq_rtl_expr = tem->sequence_rtl_expr;
3647   seq_stack = tem->next;
3648
3649   free (tem);
3650 }
3651
3652 /* This works like end_sequence, but records the old sequence in FIRST
3653    and LAST.  */
3654
3655 void
3656 end_full_sequence (first, last)
3657      rtx *first, *last;
3658 {
3659   *first = first_insn;
3660   *last = last_insn;
3661   end_sequence();
3662 }
3663
3664 /* Return 1 if currently emitting into a sequence.  */
3665
3666 int
3667 in_sequence_p ()
3668 {
3669   return seq_stack != 0;
3670 }
3671
3672 /* Generate a SEQUENCE rtx containing the insns already emitted
3673    to the current sequence.
3674
3675    This is how the gen_... function from a DEFINE_EXPAND
3676    constructs the SEQUENCE that it returns.  */
3677
3678 rtx
3679 gen_sequence ()
3680 {
3681   rtx result;
3682   rtx tem;
3683   int i;
3684   int len;
3685
3686   /* Count the insns in the chain.  */
3687   len = 0;
3688   for (tem = first_insn; tem; tem = NEXT_INSN (tem))
3689     len++;
3690
3691   /* If only one insn, return it rather than a SEQUENCE.
3692      (Now that we cache SEQUENCE expressions, it isn't worth special-casing
3693      the case of an empty list.)
3694      We only return the pattern of an insn if its code is INSN and it
3695      has no notes.  This ensures that no information gets lost.  */
3696   if (len == 1
3697       && ! RTX_FRAME_RELATED_P (first_insn)
3698       && GET_CODE (first_insn) == INSN
3699       /* Don't throw away any reg notes. */
3700       && REG_NOTES (first_insn) == 0)
3701     return PATTERN (first_insn);
3702
3703   result = gen_rtx_SEQUENCE (VOIDmode, rtvec_alloc (len));
3704
3705   for (i = 0, tem = first_insn; tem; tem = NEXT_INSN (tem), i++)
3706     XVECEXP (result, 0, i) = tem;
3707
3708   return result;
3709 }
3710 \f
3711 /* Put the various virtual registers into REGNO_REG_RTX.  */
3712
3713 void
3714 init_virtual_regs (es)
3715      struct emit_status *es;
3716 {
3717   rtx *ptr = es->x_regno_reg_rtx;
3718   ptr[VIRTUAL_INCOMING_ARGS_REGNUM] = virtual_incoming_args_rtx;
3719   ptr[VIRTUAL_STACK_VARS_REGNUM] = virtual_stack_vars_rtx;
3720   ptr[VIRTUAL_STACK_DYNAMIC_REGNUM] = virtual_stack_dynamic_rtx;
3721   ptr[VIRTUAL_OUTGOING_ARGS_REGNUM] = virtual_outgoing_args_rtx;
3722   ptr[VIRTUAL_CFA_REGNUM] = virtual_cfa_rtx;
3723 }
3724
3725 void
3726 clear_emit_caches ()
3727 {
3728   int i;
3729
3730   /* Clear the start_sequence/gen_sequence cache.  */
3731   for (i = 0; i < SEQUENCE_RESULT_SIZE; i++)
3732     sequence_result[i] = 0;
3733   free_insn = 0;
3734 }
3735 \f
3736 /* Used by copy_insn_1 to avoid copying SCRATCHes more than once.  */
3737 static rtx copy_insn_scratch_in[MAX_RECOG_OPERANDS];
3738 static rtx copy_insn_scratch_out[MAX_RECOG_OPERANDS];
3739 static int copy_insn_n_scratches;
3740
3741 /* When an insn is being copied by copy_insn_1, this is nonzero if we have
3742    copied an ASM_OPERANDS.
3743    In that case, it is the original input-operand vector.  */
3744 static rtvec orig_asm_operands_vector;
3745
3746 /* When an insn is being copied by copy_insn_1, this is nonzero if we have
3747    copied an ASM_OPERANDS.
3748    In that case, it is the copied input-operand vector.  */
3749 static rtvec copy_asm_operands_vector;
3750
3751 /* Likewise for the constraints vector.  */
3752 static rtvec orig_asm_constraints_vector;
3753 static rtvec copy_asm_constraints_vector;
3754
3755 /* Recursively create a new copy of an rtx for copy_insn.
3756    This function differs from copy_rtx in that it handles SCRATCHes and
3757    ASM_OPERANDs properly.
3758    Normally, this function is not used directly; use copy_insn as front end.
3759    However, you could first copy an insn pattern with copy_insn and then use
3760    this function afterwards to properly copy any REG_NOTEs containing
3761    SCRATCHes.  */
3762
3763 rtx
3764 copy_insn_1 (orig)
3765      register rtx orig;
3766 {
3767   register rtx copy;
3768   register int i, j;
3769   register RTX_CODE code;
3770   register const char *format_ptr;
3771
3772   code = GET_CODE (orig);
3773
3774   switch (code)
3775     {
3776     case REG:
3777     case QUEUED:
3778     case CONST_INT:
3779     case CONST_DOUBLE:
3780     case SYMBOL_REF:
3781     case CODE_LABEL:
3782     case PC:
3783     case CC0:
3784     case ADDRESSOF:
3785       return orig;
3786
3787     case SCRATCH:
3788       for (i = 0; i < copy_insn_n_scratches; i++)
3789         if (copy_insn_scratch_in[i] == orig)
3790           return copy_insn_scratch_out[i];
3791       break;
3792
3793     case CONST:
3794       /* CONST can be shared if it contains a SYMBOL_REF.  If it contains
3795          a LABEL_REF, it isn't sharable.  */
3796       if (GET_CODE (XEXP (orig, 0)) == PLUS
3797           && GET_CODE (XEXP (XEXP (orig, 0), 0)) == SYMBOL_REF
3798           && GET_CODE (XEXP (XEXP (orig, 0), 1)) == CONST_INT)
3799         return orig;
3800       break;
3801
3802       /* A MEM with a constant address is not sharable.  The problem is that
3803          the constant address may need to be reloaded.  If the mem is shared,
3804          then reloading one copy of this mem will cause all copies to appear
3805          to have been reloaded.  */
3806
3807     default:
3808       break;
3809     }
3810
3811   copy = rtx_alloc (code);
3812
3813   /* Copy the various flags, and other information.  We assume that
3814      all fields need copying, and then clear the fields that should
3815      not be copied.  That is the sensible default behavior, and forces
3816      us to explicitly document why we are *not* copying a flag.  */
3817   memcpy (copy, orig, sizeof (struct rtx_def) - sizeof (rtunion));
3818
3819   /* We do not copy the USED flag, which is used as a mark bit during
3820      walks over the RTL.  */
3821   copy->used = 0;
3822
3823   /* We do not copy JUMP, CALL, or FRAME_RELATED for INSNs.  */
3824   if (GET_RTX_CLASS (code) == 'i')
3825     {
3826       copy->jump = 0;
3827       copy->call = 0;
3828       copy->frame_related = 0;
3829     }
3830
3831   format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
3832
3833   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
3834     {
3835       copy->fld[i] = orig->fld[i];
3836       switch (*format_ptr++)
3837         {
3838         case 'e':
3839           if (XEXP (orig, i) != NULL)
3840             XEXP (copy, i) = copy_insn_1 (XEXP (orig, i));
3841           break;
3842
3843         case 'E':
3844         case 'V':
3845           if (XVEC (orig, i) == orig_asm_constraints_vector)
3846             XVEC (copy, i) = copy_asm_constraints_vector;
3847           else if (XVEC (orig, i) == orig_asm_operands_vector)
3848             XVEC (copy, i) = copy_asm_operands_vector;
3849           else if (XVEC (orig, i) != NULL)
3850             {
3851               XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
3852               for (j = 0; j < XVECLEN (copy, i); j++)
3853                 XVECEXP (copy, i, j) = copy_insn_1 (XVECEXP (orig, i, j));
3854             }
3855           break;
3856
3857         case 't':
3858         case 'w':
3859         case 'i':
3860         case 's':
3861         case 'S':
3862         case 'u':
3863         case '0':
3864           /* These are left unchanged.  */
3865           break;
3866
3867         default:
3868           abort ();
3869         }
3870     }
3871
3872   if (code == SCRATCH)
3873     {
3874       i = copy_insn_n_scratches++;
3875       if (i >= MAX_RECOG_OPERANDS)
3876         abort ();
3877       copy_insn_scratch_in[i] = orig;
3878       copy_insn_scratch_out[i] = copy;
3879     }
3880   else if (code == ASM_OPERANDS)
3881     {
3882       orig_asm_operands_vector = ASM_OPERANDS_INPUT_VEC (orig);
3883       copy_asm_operands_vector = ASM_OPERANDS_INPUT_VEC (copy);
3884       orig_asm_constraints_vector = ASM_OPERANDS_INPUT_CONSTRAINT_VEC (orig);
3885       copy_asm_constraints_vector = ASM_OPERANDS_INPUT_CONSTRAINT_VEC (copy);
3886     }
3887
3888   return copy;
3889 }
3890
3891 /* Create a new copy of an rtx.
3892    This function differs from copy_rtx in that it handles SCRATCHes and
3893    ASM_OPERANDs properly.
3894    INSN doesn't really have to be a full INSN; it could be just the
3895    pattern.  */
3896 rtx
3897 copy_insn (insn)
3898      rtx insn;
3899 {
3900   copy_insn_n_scratches = 0;
3901   orig_asm_operands_vector = 0;
3902   orig_asm_constraints_vector = 0;
3903   copy_asm_operands_vector = 0;
3904   copy_asm_constraints_vector = 0;
3905   return copy_insn_1 (insn);
3906 }
3907
3908 /* Initialize data structures and variables in this file
3909    before generating rtl for each function.  */
3910
3911 void
3912 init_emit ()
3913 {
3914   struct function *f = cfun;
3915
3916   f->emit = (struct emit_status *) xmalloc (sizeof (struct emit_status));
3917   first_insn = NULL;
3918   last_insn = NULL;
3919   seq_rtl_expr = NULL;
3920   cur_insn_uid = 1;
3921   reg_rtx_no = LAST_VIRTUAL_REGISTER + 1;
3922   last_linenum = 0;
3923   last_filename = 0;
3924   first_label_num = label_num;
3925   last_label_num = 0;
3926   seq_stack = NULL;
3927
3928   clear_emit_caches ();
3929
3930   /* Init the tables that describe all the pseudo regs.  */
3931
3932   f->emit->regno_pointer_align_length = LAST_VIRTUAL_REGISTER + 101;
3933
3934   f->emit->regno_pointer_align
3935     = (unsigned char *) xcalloc (f->emit->regno_pointer_align_length,
3936                                  sizeof (unsigned char));
3937
3938   regno_reg_rtx
3939     = (rtx *) xcalloc (f->emit->regno_pointer_align_length * sizeof (rtx),
3940                        sizeof (rtx));
3941
3942   /* Put copies of all the virtual register rtx into regno_reg_rtx.  */
3943   init_virtual_regs (f->emit);
3944
3945   /* Indicate that the virtual registers and stack locations are
3946      all pointers.  */
3947   REG_POINTER (stack_pointer_rtx) = 1;
3948   REG_POINTER (frame_pointer_rtx) = 1;
3949   REG_POINTER (hard_frame_pointer_rtx) = 1;
3950   REG_POINTER (arg_pointer_rtx) = 1;
3951
3952   REG_POINTER (virtual_incoming_args_rtx) = 1;
3953   REG_POINTER (virtual_stack_vars_rtx) = 1;
3954   REG_POINTER (virtual_stack_dynamic_rtx) = 1;
3955   REG_POINTER (virtual_outgoing_args_rtx) = 1;
3956   REG_POINTER (virtual_cfa_rtx) = 1;
3957
3958 #ifdef STACK_BOUNDARY
3959   REGNO_POINTER_ALIGN (STACK_POINTER_REGNUM) = STACK_BOUNDARY;
3960   REGNO_POINTER_ALIGN (FRAME_POINTER_REGNUM) = STACK_BOUNDARY;
3961   REGNO_POINTER_ALIGN (HARD_FRAME_POINTER_REGNUM) = STACK_BOUNDARY;
3962   REGNO_POINTER_ALIGN (ARG_POINTER_REGNUM) = STACK_BOUNDARY;
3963
3964   REGNO_POINTER_ALIGN (VIRTUAL_INCOMING_ARGS_REGNUM) = STACK_BOUNDARY;
3965   REGNO_POINTER_ALIGN (VIRTUAL_STACK_VARS_REGNUM) = STACK_BOUNDARY;
3966   REGNO_POINTER_ALIGN (VIRTUAL_STACK_DYNAMIC_REGNUM) = STACK_BOUNDARY;
3967   REGNO_POINTER_ALIGN (VIRTUAL_OUTGOING_ARGS_REGNUM) = STACK_BOUNDARY;
3968   REGNO_POINTER_ALIGN (VIRTUAL_CFA_REGNUM) = BITS_PER_WORD;
3969 #endif
3970
3971 #ifdef INIT_EXPANDERS
3972   INIT_EXPANDERS;
3973 #endif
3974 }
3975
3976 /* Mark SS for GC.  */
3977
3978 static void
3979 mark_sequence_stack (ss)
3980      struct sequence_stack *ss;
3981 {
3982   while (ss)
3983     {
3984       ggc_mark_rtx (ss->first);
3985       ggc_mark_tree (ss->sequence_rtl_expr);
3986       ss = ss->next;
3987     }
3988 }
3989
3990 /* Mark ES for GC.  */
3991
3992 void
3993 mark_emit_status (es)
3994      struct emit_status *es;
3995 {
3996   rtx *r;
3997   int i;
3998
3999   if (es == 0)
4000     return;
4001
4002   for (i = es->regno_pointer_align_length, r = es->x_regno_reg_rtx;
4003        i > 0; --i, ++r)
4004     ggc_mark_rtx (*r);
4005
4006   mark_sequence_stack (es->sequence_stack);
4007   ggc_mark_tree (es->sequence_rtl_expr);
4008   ggc_mark_rtx (es->x_first_insn);
4009 }
4010
4011 /* Create some permanent unique rtl objects shared between all functions.
4012    LINE_NUMBERS is nonzero if line numbers are to be generated.  */
4013
4014 void
4015 init_emit_once (line_numbers)
4016      int line_numbers;
4017 {
4018   int i;
4019   enum machine_mode mode;
4020   enum machine_mode double_mode;
4021
4022   /* Initialize the CONST_INT hash table.  */
4023   const_int_htab = htab_create (37, const_int_htab_hash,
4024                                 const_int_htab_eq, NULL);
4025   ggc_add_root (&const_int_htab, 1, sizeof (const_int_htab),
4026                 rtx_htab_mark);
4027
4028   no_line_numbers = ! line_numbers;
4029
4030   /* Compute the word and byte modes.  */
4031
4032   byte_mode = VOIDmode;
4033   word_mode = VOIDmode;
4034   double_mode = VOIDmode;
4035
4036   for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
4037        mode = GET_MODE_WIDER_MODE (mode))
4038     {
4039       if (GET_MODE_BITSIZE (mode) == BITS_PER_UNIT
4040           && byte_mode == VOIDmode)
4041         byte_mode = mode;
4042
4043       if (GET_MODE_BITSIZE (mode) == BITS_PER_WORD
4044           && word_mode == VOIDmode)
4045         word_mode = mode;
4046     }
4047
4048   for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT); mode != VOIDmode;
4049        mode = GET_MODE_WIDER_MODE (mode))
4050     {
4051       if (GET_MODE_BITSIZE (mode) == DOUBLE_TYPE_SIZE
4052           && double_mode == VOIDmode)
4053         double_mode = mode;
4054     }
4055
4056   ptr_mode = mode_for_size (POINTER_SIZE, GET_MODE_CLASS (Pmode), 0);
4057
4058   /* Assign register numbers to the globally defined register rtx.
4059      This must be done at runtime because the register number field
4060      is in a union and some compilers can't initialize unions.  */
4061
4062   pc_rtx = gen_rtx (PC, VOIDmode);
4063   cc0_rtx = gen_rtx (CC0, VOIDmode);
4064   stack_pointer_rtx = gen_raw_REG (Pmode, STACK_POINTER_REGNUM);
4065   frame_pointer_rtx = gen_raw_REG (Pmode, FRAME_POINTER_REGNUM);
4066   if (hard_frame_pointer_rtx == 0)
4067     hard_frame_pointer_rtx = gen_raw_REG (Pmode,
4068                                           HARD_FRAME_POINTER_REGNUM);
4069   if (arg_pointer_rtx == 0)
4070     arg_pointer_rtx = gen_raw_REG (Pmode, ARG_POINTER_REGNUM);
4071   virtual_incoming_args_rtx =
4072     gen_raw_REG (Pmode, VIRTUAL_INCOMING_ARGS_REGNUM);
4073   virtual_stack_vars_rtx =
4074     gen_raw_REG (Pmode, VIRTUAL_STACK_VARS_REGNUM);
4075   virtual_stack_dynamic_rtx =
4076     gen_raw_REG (Pmode, VIRTUAL_STACK_DYNAMIC_REGNUM);
4077   virtual_outgoing_args_rtx =
4078     gen_raw_REG (Pmode, VIRTUAL_OUTGOING_ARGS_REGNUM);
4079   virtual_cfa_rtx = gen_raw_REG (Pmode, VIRTUAL_CFA_REGNUM);
4080
4081   /* These rtx must be roots if GC is enabled.  */
4082   ggc_add_rtx_root (global_rtl, GR_MAX);
4083
4084 #ifdef INIT_EXPANDERS
4085   /* This is to initialize {init|mark|free}_machine_status before the first
4086      call to push_function_context_to.  This is needed by the Chill front
4087      end which calls push_function_context_to before the first cal to
4088      init_function_start.  */
4089   INIT_EXPANDERS;
4090 #endif
4091
4092   /* Create the unique rtx's for certain rtx codes and operand values.  */
4093
4094   /* Don't use gen_rtx here since gen_rtx in this case
4095      tries to use these variables.  */
4096   for (i = - MAX_SAVED_CONST_INT; i <= MAX_SAVED_CONST_INT; i++)
4097     const_int_rtx[i + MAX_SAVED_CONST_INT] =
4098       gen_rtx_raw_CONST_INT (VOIDmode, i);
4099   ggc_add_rtx_root (const_int_rtx, 2 * MAX_SAVED_CONST_INT + 1);
4100
4101   if (STORE_FLAG_VALUE >= - MAX_SAVED_CONST_INT
4102       && STORE_FLAG_VALUE <= MAX_SAVED_CONST_INT)
4103     const_true_rtx = const_int_rtx[STORE_FLAG_VALUE + MAX_SAVED_CONST_INT];
4104   else
4105     const_true_rtx = gen_rtx_CONST_INT (VOIDmode, STORE_FLAG_VALUE);
4106
4107   dconst0 = REAL_VALUE_ATOF ("0", double_mode);
4108   dconst1 = REAL_VALUE_ATOF ("1", double_mode);
4109   dconst2 = REAL_VALUE_ATOF ("2", double_mode);
4110   dconstm1 = REAL_VALUE_ATOF ("-1", double_mode);
4111
4112   for (i = 0; i <= 2; i++)
4113     {
4114       for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT); mode != VOIDmode;
4115            mode = GET_MODE_WIDER_MODE (mode))
4116         {
4117           rtx tem = rtx_alloc (CONST_DOUBLE);
4118           union real_extract u;
4119
4120           memset ((char *) &u, 0, sizeof u);  /* Zero any holes in a structure.  */
4121           u.d = i == 0 ? dconst0 : i == 1 ? dconst1 : dconst2;
4122
4123           memcpy (&CONST_DOUBLE_LOW (tem), &u, sizeof u);
4124           CONST_DOUBLE_MEM (tem) = cc0_rtx;
4125           CONST_DOUBLE_CHAIN (tem) = NULL_RTX;
4126           PUT_MODE (tem, mode);
4127
4128           const_tiny_rtx[i][(int) mode] = tem;
4129         }
4130
4131       const_tiny_rtx[i][(int) VOIDmode] = GEN_INT (i);
4132
4133       for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
4134            mode = GET_MODE_WIDER_MODE (mode))
4135         const_tiny_rtx[i][(int) mode] = GEN_INT (i);
4136
4137       for (mode = GET_CLASS_NARROWEST_MODE (MODE_PARTIAL_INT);
4138            mode != VOIDmode;
4139            mode = GET_MODE_WIDER_MODE (mode))
4140         const_tiny_rtx[i][(int) mode] = GEN_INT (i);
4141     }
4142
4143   for (i = (int) CCmode; i < (int) MAX_MACHINE_MODE; ++i)
4144     if (GET_MODE_CLASS ((enum machine_mode) i) == MODE_CC)
4145       const_tiny_rtx[0][i] = const0_rtx;
4146
4147   const_tiny_rtx[0][(int) BImode] = const0_rtx;
4148   if (STORE_FLAG_VALUE == 1)
4149     const_tiny_rtx[1][(int) BImode] = const1_rtx;
4150
4151   /* For bounded pointers, `&const_tiny_rtx[0][0]' is not the same as
4152      `(rtx *) const_tiny_rtx'.  The former has bounds that only cover
4153      `const_tiny_rtx[0]', whereas the latter has bounds that cover all.  */
4154   ggc_add_rtx_root ((rtx *) const_tiny_rtx, sizeof const_tiny_rtx / sizeof (rtx));
4155   ggc_add_rtx_root (&const_true_rtx, 1);
4156
4157 #ifdef RETURN_ADDRESS_POINTER_REGNUM
4158   return_address_pointer_rtx
4159     = gen_raw_REG (Pmode, RETURN_ADDRESS_POINTER_REGNUM);
4160 #endif
4161
4162 #ifdef STRUCT_VALUE
4163   struct_value_rtx = STRUCT_VALUE;
4164 #else
4165   struct_value_rtx = gen_rtx_REG (Pmode, STRUCT_VALUE_REGNUM);
4166 #endif
4167
4168 #ifdef STRUCT_VALUE_INCOMING
4169   struct_value_incoming_rtx = STRUCT_VALUE_INCOMING;
4170 #else
4171 #ifdef STRUCT_VALUE_INCOMING_REGNUM
4172   struct_value_incoming_rtx
4173     = gen_rtx_REG (Pmode, STRUCT_VALUE_INCOMING_REGNUM);
4174 #else
4175   struct_value_incoming_rtx = struct_value_rtx;
4176 #endif
4177 #endif
4178
4179 #ifdef STATIC_CHAIN_REGNUM
4180   static_chain_rtx = gen_rtx_REG (Pmode, STATIC_CHAIN_REGNUM);
4181
4182 #ifdef STATIC_CHAIN_INCOMING_REGNUM
4183   if (STATIC_CHAIN_INCOMING_REGNUM != STATIC_CHAIN_REGNUM)
4184     static_chain_incoming_rtx
4185       = gen_rtx_REG (Pmode, STATIC_CHAIN_INCOMING_REGNUM);
4186   else
4187 #endif
4188     static_chain_incoming_rtx = static_chain_rtx;
4189 #endif
4190
4191 #ifdef STATIC_CHAIN
4192   static_chain_rtx = STATIC_CHAIN;
4193
4194 #ifdef STATIC_CHAIN_INCOMING
4195   static_chain_incoming_rtx = STATIC_CHAIN_INCOMING;
4196 #else
4197   static_chain_incoming_rtx = static_chain_rtx;
4198 #endif
4199 #endif
4200
4201   if (PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM)
4202     pic_offset_table_rtx = gen_rtx_REG (Pmode, PIC_OFFSET_TABLE_REGNUM);
4203
4204   ggc_add_rtx_root (&pic_offset_table_rtx, 1);
4205   ggc_add_rtx_root (&struct_value_rtx, 1);
4206   ggc_add_rtx_root (&struct_value_incoming_rtx, 1);
4207   ggc_add_rtx_root (&static_chain_rtx, 1);
4208   ggc_add_rtx_root (&static_chain_incoming_rtx, 1);
4209   ggc_add_rtx_root (&return_address_pointer_rtx, 1);
4210 }
4211 \f
4212 /* Query and clear/ restore no_line_numbers.  This is used by the
4213    switch / case handling in stmt.c to give proper line numbers in
4214    warnings about unreachable code.  */
4215
4216 int
4217 force_line_numbers ()
4218 {
4219   int old = no_line_numbers;
4220
4221   no_line_numbers = 0;
4222   if (old)
4223     force_next_line_note ();
4224   return old;
4225 }
4226
4227 void
4228 restore_line_number_status (old_value)
4229      int old_value;
4230 {
4231   no_line_numbers = old_value;
4232 }