gcc/emit-rtl.c

   1 /* Emit RTL for the GNU C-Compiler expander.
   2    Copyright (C) 1987, 1988, 1992 Free Software Foundation, Inc.
   3
   4 This file is part of GNU CC.
   5
   6 GNU CC is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU CC is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU CC; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20
  21 /* Middle-to-low level generation of rtx code and insns.
  22
  23    This file contains the functions `gen_rtx', `gen_reg_rtx'
  24    and `gen_label_rtx' that are the usual ways of creating rtl
  25    expressions for most purposes.
  26
  27    It also has the functions for creating insns and linking
  28    them in the doubly-linked chain.
  29
  30    The patterns of the insns are created by machine-dependent
  31    routines in insn-emit.c, which is generated automatically from
  32    the machine description.  These routines use `gen_rtx' to make
  33    the individual rtx's of the pattern; what is machine dependent
  34    is the kind of rtx's they make and what arguments they use.  */
  35
  36 #include "config.h"
  37 #include "gvarargs.h"
  38 #include "rtl.h"
  39 #include "flags.h"
  40 #include "function.h"
  41 #include "expr.h"
  42 #include "regs.h"
  43 #include "insn-config.h"
  44 #include "real.h"
  45 #include <stdio.h>
  46
  47 /* This is reset to LAST_VIRTUAL_REGISTER + 1 at the start of each function.
  48    After rtl generation, it is 1 plus the largest register number used.  */
  49
  50 int reg_rtx_no = LAST_VIRTUAL_REGISTER + 1;
  51
  52 /* This is *not* reset after each function.  It gives each CODE_LABEL
  53    in the entire compilation a unique label number.  */
  54
  55 static int label_num = 1;
  56
  57 /* Lowest label number in current function.  */
  58
  59 static int first_label_num;
  60
  61 /* Highest label number in current function.
  62    Zero means use the value of label_num instead.
  63    This is nonzero only when belatedly compiling an inline function.  */
  64
  65 static int last_label_num;
  66
  67 /* Value label_num had when set_new_first_and_last_label_number was called.
  68    If label_num has not changed since then, last_label_num is valid.  */
  69
  70 static int base_label_num;
  71
  72 /* Nonzero means do not generate NOTEs for source line numbers.  */
  73
  74 static int no_line_numbers;
  75
  76 /* Commonly used rtx's, so that we only need space for one copy.
  77    These are initialized once for the entire compilation.
  78    All of these except perhaps the floating-point CONST_DOUBLEs
  79    are unique; no other rtx-object will be equal to any of these.  */
  80
  81 rtx pc_rtx;                     /* (PC) */
  82 rtx cc0_rtx;                    /* (CC0) */
  83 rtx cc1_rtx;                    /* (CC1) (not actually used nowadays) */
  84 rtx const0_rtx;                 /* (CONST_INT 0) */
  85 rtx const1_rtx;                 /* (CONST_INT 1) */
  86 rtx const2_rtx;                 /* (CONST_INT 2) */
  87 rtx constm1_rtx;                /* (CONST_INT -1) */
  88 rtx const_true_rtx;             /* (CONST_INT STORE_FLAG_VALUE) */
  89
  90 /* We record floating-point CONST_DOUBLEs in each floating-point mode for
  91    the values of 0, 1, and 2.  For the integer entries and VOIDmode, we
  92    record a copy of const[012]_rtx.  */
  93
  94 rtx const_tiny_rtx[3][(int) MAX_MACHINE_MODE];
  95
  96 REAL_VALUE_TYPE dconst0;
  97 REAL_VALUE_TYPE dconst1;
  98 REAL_VALUE_TYPE dconst2;
  99 REAL_VALUE_TYPE dconstm1;
 100
 101 /* All references to the following fixed hard registers go through
 102    these unique rtl objects.  On machines where the frame-pointer and
 103    arg-pointer are the same register, they use the same unique object.
 104
 105    After register allocation, other rtl objects which used to be pseudo-regs
 106    may be clobbered to refer to the frame-pointer register.
 107    But references that were originally to the frame-pointer can be
 108    distinguished from the others because they contain frame_pointer_rtx.
 109
 110    In an inline procedure, the stack and frame pointer rtxs may not be
 111    used for anything else.  */
 112 rtx stack_pointer_rtx;          /* (REG:Pmode STACK_POINTER_REGNUM) */
 113 rtx frame_pointer_rtx;          /* (REG:Pmode FRAME_POINTER_REGNUM) */
 114 rtx arg_pointer_rtx;            /* (REG:Pmode ARG_POINTER_REGNUM) */
 115 rtx struct_value_rtx;           /* (REG:Pmode STRUCT_VALUE_REGNUM) */
 116 rtx struct_value_incoming_rtx;  /* (REG:Pmode STRUCT_VALUE_INCOMING_REGNUM) */
 117 rtx static_chain_rtx;           /* (REG:Pmode STATIC_CHAIN_REGNUM) */
 118 rtx static_chain_incoming_rtx;  /* (REG:Pmode STATIC_CHAIN_INCOMING_REGNUM) */
 119 rtx pic_offset_table_rtx;       /* (REG:Pmode PIC_OFFSET_TABLE_REGNUM) */
 120
 121 rtx virtual_incoming_args_rtx;  /* (REG:Pmode VIRTUAL_INCOMING_ARGS_REGNUM) */
 122 rtx virtual_stack_vars_rtx;     /* (REG:Pmode VIRTUAL_STACK_VARS_REGNUM) */
 123 rtx virtual_stack_dynamic_rtx;  /* (REG:Pmode VIRTUAL_STACK_DYNAMIC_REGNUM) */
 124 rtx virtual_outgoing_args_rtx;  /* (REG:Pmode VIRTUAL_OUTGOING_ARGS_REGNUM) */
 125
 126 /* We make one copy of (const_int C) where C is in
 127    [- MAX_SAVED_CONST_INT, MAX_SAVED_CONST_INT]
 128    to save space during the compilation and simplify comparisons of
 129    integers.  */
 130
 131 #define MAX_SAVED_CONST_INT 64
 132
 133 static rtx const_int_rtx[MAX_SAVED_CONST_INT * 2 + 1];
 134
 135 /* The ends of the doubly-linked chain of rtl for the current function.
 136    Both are reset to null at the start of rtl generation for the function.
 137
 138    start_sequence saves both of these on `sequence_stack' and then
 139    starts a new, nested sequence of insns.  */
 140
 141 static rtx first_insn = NULL;
 142 static rtx last_insn = NULL;
 143
 144 /* INSN_UID for next insn emitted.
 145    Reset to 1 for each function compiled.  */
 146
 147 static int cur_insn_uid = 1;
 148
 149 /* Line number and source file of the last line-number NOTE emitted.
 150    This is used to avoid generating duplicates.  */
 151
 152 static int last_linenum = 0;
 153 static char *last_filename = 0;
 154
 155 /* A vector indexed by pseudo reg number.  The allocated length
 156    of this vector is regno_pointer_flag_length.  Since this
 157    vector is needed during the expansion phase when the total
 158    number of registers in the function is not yet known,
 159    it is copied and made bigger when necessary.  */
 160
 161 char *regno_pointer_flag;
 162 int regno_pointer_flag_length;
 163
 164 /* Indexed by pseudo register number, gives the rtx for that pseudo.
 165    Allocated in parallel with regno_pointer_flag.  */
 166
 167 rtx *regno_reg_rtx;
 168
 169 /* Stack of pending (incomplete) sequences saved by `start_sequence'.
 170    Each element describes one pending sequence.
 171    The main insn-chain is saved in the last element of the chain,
 172    unless the chain is empty.  */
 173
 174 struct sequence_stack *sequence_stack;
 175
 176 /* start_sequence and gen_sequence can make a lot of rtx expressions which are
 177    shortly thrown away.  We use two mechanisms to prevent this waste:
 178
 179    First, we keep a list of the expressions used to represent the sequence
 180    stack in sequence_element_free_list.
 181
 182    Second, for sizes up to 5 elements, we keep a SEQUENCE and its associated
 183    rtvec for use by gen_sequence.  One entry for each size is sufficient
 184    because most cases are calls to gen_sequence followed by immediately
 185    emitting the SEQUENCE.  Reuse is safe since emitting a sequence is
 186    destructive on the insn in it anyway and hence can't be redone.
 187
 188    We do not bother to save this cached data over nested function calls.
 189    Instead, we just reinitialize them.  */
 190
 191 #define SEQUENCE_RESULT_SIZE 5
 192
 193 static struct sequence_stack *sequence_element_free_list;
 194 static rtx sequence_result[SEQUENCE_RESULT_SIZE];
 195
 196 extern int rtx_equal_function_value_matters;
 197
 198 /* Filename and line number of last line-number note,
 199    whether we actually emitted it or not.  */
 200 extern char *emit_filename;
 201 extern int emit_lineno;
 202
 203 rtx change_address ();
 204 void init_emit ();
 205 \f
 206 /* rtx gen_rtx (code, mode, [element1, ..., elementn])
 207 **
 208 **          This routine generates an RTX of the size specified by
 209 **      <code>, which is an RTX code.   The RTX structure is initialized
 210 **      from the arguments <element1> through <elementn>, which are
 211 **      interpreted according to the specific RTX type's format.   The
 212 **      special machine mode associated with the rtx (if any) is specified
 213 **      in <mode>.
 214 **
 215 **          gen_rtx() can be invoked in a way which resembles the lisp-like
 216 **      rtx it will generate.   For example, the following rtx structure:
 217 **
 218 **            (plus:QI (mem:QI (reg:SI 1))
 219 **                     (mem:QI (plusw:SI (reg:SI 2) (reg:SI 3))))
 220 **
 221 **              ...would be generated by the following C code:
 222 **
 223 **              gen_rtx (PLUS, QImode,
 224 **                  gen_rtx (MEM, QImode,
 225 **                      gen_rtx (REG, SImode, 1)),
 226 **                  gen_rtx (MEM, QImode,
 227 **                      gen_rtx (PLUS, SImode,
 228 **                          gen_rtx (REG, SImode, 2),
 229 **                          gen_rtx (REG, SImode, 3)))),
 230 */
 231
 232 /*VARARGS2*/
 233 rtx
 234 gen_rtx (va_alist)
 235      va_dcl
 236 {
 237   va_list p;
 238   enum rtx_code code;
 239   enum machine_mode mode;
 240   register int i;               /* Array indices...                     */
 241   register char *fmt;           /* Current rtx's format...              */
 242   register rtx rt_val;          /* RTX to return to caller...           */
 243
 244   va_start (p);
 245   code = va_arg (p, enum rtx_code);
 246   mode = va_arg (p, enum machine_mode);
 247
 248   if (code == CONST_INT)
 249     {
 250       HOST_WIDE_INT arg = va_arg (p, HOST_WIDE_INT);
 251
 252       if (arg >= - MAX_SAVED_CONST_INT && arg <= MAX_SAVED_CONST_INT)
 253         return const_int_rtx[arg + MAX_SAVED_CONST_INT];
 254
 255       if (const_true_rtx && arg == STORE_FLAG_VALUE)
 256         return const_true_rtx;
 257
 258       rt_val = rtx_alloc (code);
 259       INTVAL (rt_val) = arg;
 260     }
 261   else if (code == REG)
 262     {
 263       int regno = va_arg (p, int);
 264
 265       /* In case the MD file explicitly references the frame pointer, have
 266          all such references point to the same frame pointer.  This is used
 267          during frame pointer elimination to distinguish the explicit
 268          references to these registers from pseudos that happened to be
 269          assigned to them.
 270
 271          If we have eliminated the frame pointer or arg pointer, we will
 272          be using it as a normal register, for example as a spill register.
 273          In such cases, we might be accessing it in a mode that is not
 274          Pmode and therefore cannot use the pre-allocated rtx.
 275
 276          Also don't do this when we are making new REGs in reload,
 277          since we don't want to get confused with the real pointers.  */
 278
 279       if (frame_pointer_rtx && regno == FRAME_POINTER_REGNUM && mode == Pmode
 280           && ! reload_in_progress)
 281         return frame_pointer_rtx;
 282 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
 283       if (arg_pointer_rtx && regno == ARG_POINTER_REGNUM && mode == Pmode
 284           && ! reload_in_progress)
 285         return arg_pointer_rtx;
 286 #endif
 287       if (stack_pointer_rtx && regno == STACK_POINTER_REGNUM && mode == Pmode
 288           && ! reload_in_progress)
 289         return stack_pointer_rtx;
 290       else
 291         {
 292           rt_val = rtx_alloc (code);
 293           rt_val->mode = mode;
 294           REGNO (rt_val) = regno;
 295           return rt_val;
 296         }
 297     }
 298   else
 299     {
 300       rt_val = rtx_alloc (code);        /* Allocate the storage space.  */
 301       rt_val->mode = mode;              /* Store the machine mode...  */
 302
 303       fmt = GET_RTX_FORMAT (code);      /* Find the right format...  */
 304       for (i = 0; i < GET_RTX_LENGTH (code); i++)
 305         {
 306           switch (*fmt++)
 307             {
 308             case '0':           /* Unused field.  */
 309               break;
 310
 311             case 'i':           /* An integer?  */
 312               XINT (rt_val, i) = va_arg (p, int);
 313               break;
 314
 315             case 'w':           /* A wide integer? */
 316               XWINT (rt_val, i) = va_arg (p, HOST_WIDE_INT);
 317               break;
 318
 319             case 's':           /* A string?  */
 320               XSTR (rt_val, i) = va_arg (p, char *);
 321               break;
 322
 323             case 'e':           /* An expression?  */
 324             case 'u':           /* An insn?  Same except when printing.  */
 325               XEXP (rt_val, i) = va_arg (p, rtx);
 326               break;
 327
 328             case 'E':           /* An RTX vector?  */
 329               XVEC (rt_val, i) = va_arg (p, rtvec);
 330               break;
 331
 332             default:
 333               abort();
 334             }
 335         }
 336     }
 337   va_end (p);
 338   return rt_val;                /* Return the new RTX...                */
 339 }
 340
 341 /* gen_rtvec (n, [rt1, ..., rtn])
 342 **
 343 **          This routine creates an rtvec and stores within it the
 344 **      pointers to rtx's which are its arguments.
 345 */
 346
 347 /*VARARGS1*/
 348 rtvec
 349 gen_rtvec (va_alist)
 350      va_dcl
 351 {
 352   int n, i;
 353   va_list p;
 354   rtx *vector;
 355
 356   va_start (p);
 357   n = va_arg (p, int);
 358
 359   if (n == 0)
 360     return NULL_RTVEC;          /* Don't allocate an empty rtvec...     */
 361
 362   vector = (rtx *) alloca (n * sizeof (rtx));
 363   for (i = 0; i < n; i++)
 364     vector[i] = va_arg (p, rtx);
 365   va_end (p);
 366
 367   return gen_rtvec_v (n, vector);
 368 }
 369
 370 rtvec
 371 gen_rtvec_v (n, argp)
 372      int n;
 373      rtx *argp;
 374 {
 375   register int i;
 376   register rtvec rt_val;
 377
 378   if (n == 0)
 379     return NULL_RTVEC;          /* Don't allocate an empty rtvec...     */
 380
 381   rt_val = rtvec_alloc (n);     /* Allocate an rtvec...                 */
 382
 383   for (i = 0; i < n; i++)
 384     rt_val->elem[i].rtx = *argp++;
 385
 386   return rt_val;
 387 }
 388 \f
 389 /* Generate a REG rtx for a new pseudo register of mode MODE.
 390    This pseudo is assigned the next sequential register number.  */
 391
 392 rtx
 393 gen_reg_rtx (mode)
 394      enum machine_mode mode;
 395 {
 396   register rtx val;
 397
 398   /* Don't let anything called by or after reload create new registers
 399      (actually, registers can't be created after flow, but this is a good
 400      approximation).  */
 401
 402   if (reload_in_progress || reload_completed)
 403     abort ();
 404
 405   /* Make sure regno_pointer_flag and regno_reg_rtx are large
 406      enough to have an element for this pseudo reg number.  */
 407
 408   if (reg_rtx_no == regno_pointer_flag_length)
 409     {
 410       rtx *new1;
 411       char *new =
 412         (char *) oballoc (regno_pointer_flag_length * 2);
 413       bzero (new, regno_pointer_flag_length * 2);
 414       bcopy (regno_pointer_flag, new, regno_pointer_flag_length);
 415       regno_pointer_flag = new;
 416
 417       new1 = (rtx *) oballoc (regno_pointer_flag_length * 2 * sizeof (rtx));
 418       bzero (new1, regno_pointer_flag_length * 2 * sizeof (rtx));
 419       bcopy (regno_reg_rtx, new1, regno_pointer_flag_length * sizeof (rtx));
 420       regno_reg_rtx = new1;
 421
 422       regno_pointer_flag_length *= 2;
 423     }
 424
 425   val = gen_rtx (REG, mode, reg_rtx_no);
 426   regno_reg_rtx[reg_rtx_no++] = val;
 427   return val;
 428 }
 429
 430 /* Identify REG as a probable pointer register.  */
 431
 432 void
 433 mark_reg_pointer (reg)
 434      rtx reg;
 435 {
 436   REGNO_POINTER_FLAG (REGNO (reg)) = 1;
 437 }
 438
 439 /* Return 1 plus largest pseudo reg number used in the current function.  */
 440
 441 int
 442 max_reg_num ()
 443 {
 444   return reg_rtx_no;
 445 }
 446
 447 /* Return 1 + the largest label number used so far in the current function.  */
 448
 449 int
 450 max_label_num ()
 451 {
 452   if (last_label_num && label_num == base_label_num)
 453     return last_label_num;
 454   return label_num;
 455 }
 456
 457 /* Return first label number used in this function (if any were used).  */
 458
 459 int
 460 get_first_label_num ()
 461 {
 462   return first_label_num;
 463 }
 464 \f
 465 /* Return a value representing some low-order bits of X, where the number
 466    of low-order bits is given by MODE.  Note that no conversion is done
 467    between floating-point and fixed-point values, rather, the bit
 468    representation is returned.
 469
 470    This function handles the cases in common between gen_lowpart, below,
 471    and two variants in cse.c and combine.c.  These are the cases that can
 472    be safely handled at all points in the compilation.
 473
 474    If this is not a case we can handle, return 0.  */
 475
 476 rtx
 477 gen_lowpart_common (mode, x)
 478      enum machine_mode mode;
 479      register rtx x;
 480 {
 481   int word = 0;
 482
 483   if (GET_MODE (x) == mode)
 484     return x;
 485
 486   /* MODE must occupy no more words than the mode of X.  */
 487   if (GET_MODE (x) != VOIDmode
 488       && ((GET_MODE_SIZE (mode) + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD
 489           > ((GET_MODE_SIZE (GET_MODE (x)) + (UNITS_PER_WORD - 1))
 490              / UNITS_PER_WORD)))
 491     return 0;
 492
 493   if (WORDS_BIG_ENDIAN && GET_MODE_SIZE (GET_MODE (x)) > UNITS_PER_WORD)
 494     word = ((GET_MODE_SIZE (GET_MODE (x))
 495              - MAX (GET_MODE_SIZE (mode), UNITS_PER_WORD))
 496             / UNITS_PER_WORD);
 497
 498   if ((GET_CODE (x) == ZERO_EXTEND || GET_CODE (x) == SIGN_EXTEND)
 499       && GET_MODE_CLASS (mode) == MODE_INT)
 500     {
 501       /* If we are getting the low-order part of something that has been
 502          sign- or zero-extended, we can either just use the object being
 503          extended or make a narrower extension.  If we want an even smaller
 504          piece than the size of the object being extended, call ourselves
 505          recursively.
 506
 507          This case is used mostly by combine and cse.  */
 508
 509       if (GET_MODE (XEXP (x, 0)) == mode)
 510         return XEXP (x, 0);
 511       else if (GET_MODE_SIZE (mode) < GET_MODE_SIZE (GET_MODE (XEXP (x, 0))))
 512         return gen_lowpart_common (mode, XEXP (x, 0));
 513       else if (GET_MODE_SIZE (mode) < GET_MODE_SIZE (GET_MODE (x)))
 514         return gen_rtx (GET_CODE (x), mode, XEXP (x, 0));
 515     }
 516   else if (GET_CODE (x) == SUBREG
 517            && (GET_MODE_SIZE (mode) <= UNITS_PER_WORD
 518                || GET_MODE_SIZE (mode) == GET_MODE_UNIT_SIZE (GET_MODE (x))))
 519     return (GET_MODE (SUBREG_REG (x)) == mode && SUBREG_WORD (x) == 0
 520             ? SUBREG_REG (x)
 521             : gen_rtx (SUBREG, mode, SUBREG_REG (x), SUBREG_WORD (x)));
 522   else if (GET_CODE (x) == REG)
 523     {
 524       /* If the register is not valid for MODE, return 0.  If we don't
 525          do this, there is no way to fix up the resulting REG later.  */
 526       if (REGNO (x) < FIRST_PSEUDO_REGISTER
 527           && ! HARD_REGNO_MODE_OK (REGNO (x) + word, mode))
 528         return 0;
 529       else if (REGNO (x) < FIRST_PSEUDO_REGISTER
 530                /* integrate.c can't handle parts of a return value register. */
 531                && (! REG_FUNCTION_VALUE_P (x)
 532                    || ! rtx_equal_function_value_matters))
 533         return gen_rtx (REG, mode, REGNO (x) + word);
 534       else
 535         return gen_rtx (SUBREG, mode, x, word);
 536     }
 537
 538   /* If X is a CONST_INT or a CONST_DOUBLE, extract the appropriate bits
 539      from the low-order part of the constant.  */
 540   else if (GET_MODE_CLASS (mode) == MODE_INT && GET_MODE (x) == VOIDmode
 541            && (GET_CODE (x) == CONST_INT || GET_CODE (x) == CONST_DOUBLE))
 542     {
 543       /* If MODE is twice the host word size, X is already the desired
 544          representation.  Otherwise, if MODE is wider than a word, we can't
 545          do this.  If MODE is exactly a word, return just one CONST_INT.
 546          If MODE is smaller than a word, clear the bits that don't belong
 547          in our mode, unless they and our sign bit are all one.  So we get
 548          either a reasonable negative value or a reasonable unsigned value
 549          for this mode.  */
 550
 551       if (GET_MODE_BITSIZE (mode) == 2 * HOST_BITS_PER_WIDE_INT)
 552         return x;
 553       else if (GET_MODE_BITSIZE (mode) > HOST_BITS_PER_WIDE_INT)
 554         return 0;
 555       else if (GET_MODE_BITSIZE (mode) == HOST_BITS_PER_WIDE_INT)
 556         return (GET_CODE (x) == CONST_INT ? x
 557                 : GEN_INT (CONST_DOUBLE_LOW (x)));
 558       else
 559         {
 560           /* MODE must be narrower than HOST_BITS_PER_INT.  */
 561           int width = GET_MODE_BITSIZE (mode);
 562           HOST_WIDE_INT val = (GET_CODE (x) == CONST_INT ? INTVAL (x)
 563                                : CONST_DOUBLE_LOW (x));
 564
 565           if (((val & ((HOST_WIDE_INT) (-1) << (width - 1)))
 566                != ((HOST_WIDE_INT) (-1) << (width - 1))))
 567             val &= ((HOST_WIDE_INT) 1 << width) - 1;
 568
 569           return (GET_CODE (x) == CONST_INT && INTVAL (x) == val ? x
 570                   : GEN_INT (val));
 571         }
 572     }
 573
 574   /* If X is an integral constant but we want it in floating-point, it
 575      must be the case that we have a union of an integer and a floating-point
 576      value.  If the machine-parameters allow it, simulate that union here
 577      and return the result.  The two-word and single-word cases are
 578      different.  */
 579
 580   else if (((HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT
 581              && HOST_BITS_PER_WIDE_INT == BITS_PER_WORD)
 582             || flag_pretend_float)
 583            && GET_MODE_CLASS (mode) == MODE_FLOAT
 584            && GET_MODE_SIZE (mode) == UNITS_PER_WORD
 585            && GET_CODE (x) == CONST_INT
 586            && sizeof (float) * HOST_BITS_PER_CHAR == HOST_BITS_PER_WIDE_INT)
 587     {
 588       union {HOST_WIDE_INT i; float d; } u;
 589
 590       u.i = INTVAL (x);
 591       return immed_real_const_1 (u.d, mode);
 592     }
 593
 594   else if (((HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT
 595              && HOST_BITS_PER_WIDE_INT == BITS_PER_WORD)
 596             || flag_pretend_float)
 597            && GET_MODE_CLASS (mode) == MODE_FLOAT
 598            && GET_MODE_SIZE (mode) == 2 * UNITS_PER_WORD
 599            && (GET_CODE (x) == CONST_INT || GET_CODE (x) == CONST_DOUBLE)
 600            && GET_MODE (x) == VOIDmode
 601            && (sizeof (double) * HOST_BITS_PER_CHAR
 602                == 2 * HOST_BITS_PER_WIDE_INT))
 603     {
 604       union {HOST_WIDE_INT i[2]; double d; } u;
 605       HOST_WIDE_INT low, high;
 606
 607       if (GET_CODE (x) == CONST_INT)
 608         low = INTVAL (x), high = low >> (HOST_BITS_PER_WIDE_INT -1);
 609       else
 610         low = CONST_DOUBLE_LOW (x), high = CONST_DOUBLE_HIGH (x);
 611
 612 #ifdef HOST_WORDS_BIG_ENDIAN
 613       u.i[0] = high, u.i[1] = low;
 614 #else
 615       u.i[0] = low, u.i[1] = high;
 616 #endif
 617
 618       return immed_real_const_1 (u.d, mode);
 619     }
 620
 621   /* Similarly, if this is converting a floating-point value into a
 622      single-word integer.  Only do this is the host and target parameters are
 623      compatible.  */
 624
 625   else if (((HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT
 626              && HOST_BITS_PER_WIDE_INT == BITS_PER_WORD)
 627             || flag_pretend_float)
 628            && GET_MODE_CLASS (mode) == MODE_INT
 629            && GET_CODE (x) == CONST_DOUBLE
 630            && GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT
 631            && GET_MODE_BITSIZE (mode) == BITS_PER_WORD)
 632     return operand_subword (x, 0, 0, GET_MODE (x));
 633
 634   /* Similarly, if this is converting a floating-point value into a
 635      two-word integer, we can do this one word at a time and make an
 636      integer.  Only do this is the host and target parameters are
 637      compatible.  */
 638
 639   else if (((HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT
 640              && HOST_BITS_PER_WIDE_INT == BITS_PER_WORD)
 641             || flag_pretend_float)
 642            && GET_MODE_CLASS (mode) == MODE_INT
 643            && GET_CODE (x) == CONST_DOUBLE
 644            && GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT
 645            && GET_MODE_BITSIZE (mode) == 2 * BITS_PER_WORD)
 646     {
 647       rtx lowpart = operand_subword (x, WORDS_BIG_ENDIAN, 0, GET_MODE (x));
 648       rtx highpart = operand_subword (x, ! WORDS_BIG_ENDIAN, 0, GET_MODE (x));
 649
 650       if (lowpart && GET_CODE (lowpart) == CONST_INT
 651           && highpart && GET_CODE (highpart) == CONST_INT)
 652         return immed_double_const (INTVAL (lowpart), INTVAL (highpart), mode);
 653     }
 654
 655   /* Otherwise, we can't do this.  */
 656   return 0;
 657 }
 658 \f
 659 /* Assuming that X is an rtx (e.g., MEM, REG or SUBREG) for a value,
 660    return an rtx (MEM, SUBREG, or CONST_INT) that refers to the
 661    least-significant part of X.
 662    MODE specifies how big a part of X to return;
 663    it usually should not be larger than a word.
 664    If X is a MEM whose address is a QUEUED, the value may be so also.  */
 665
 666 rtx
 667 gen_lowpart (mode, x)
 668      enum machine_mode mode;
 669      register rtx x;
 670 {
 671   rtx result = gen_lowpart_common (mode, x);
 672
 673   if (result)
 674     return result;
 675   else if (GET_CODE (x) == MEM)
 676     {
 677       /* The only additional case we can do is MEM.  */
 678       register int offset = 0;
 679       if (WORDS_BIG_ENDIAN)
 680         offset = (MAX (GET_MODE_SIZE (GET_MODE (x)), UNITS_PER_WORD)
 681                   - MAX (GET_MODE_SIZE (mode), UNITS_PER_WORD));
 682
 683       if (BYTES_BIG_ENDIAN)
 684         /* Adjust the address so that the address-after-the-data
 685            is unchanged.  */
 686         offset -= (MIN (UNITS_PER_WORD, GET_MODE_SIZE (mode))
 687                    - MIN (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (x))));
 688
 689       return change_address (x, mode, plus_constant (XEXP (x, 0), offset));
 690     }
 691   else
 692     abort ();
 693 }
 694
 695 /* Return 1 iff X, assumed to be a SUBREG,
 696    refers to the least significant part of its containing reg.
 697    If X is not a SUBREG, always return 1 (it is its own low part!).  */
 698
 699 int
 700 subreg_lowpart_p (x)
 701      rtx x;
 702 {
 703   if (GET_CODE (x) != SUBREG)
 704     return 1;
 705
 706   if (WORDS_BIG_ENDIAN
 707       && GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))) > UNITS_PER_WORD)
 708     return (SUBREG_WORD (x)
 709             == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)))
 710                  - MAX (GET_MODE_SIZE (GET_MODE (x)), UNITS_PER_WORD))
 711                 / UNITS_PER_WORD));
 712
 713   return SUBREG_WORD (x) == 0;
 714 }
 715 \f
 716 /* Return subword I of operand OP.
 717    The word number, I, is interpreted as the word number starting at the
 718    low-order address.  Word 0 is the low-order word if not WORDS_BIG_ENDIAN,
 719    otherwise it is the high-order word.
 720
 721    If we cannot extract the required word, we return zero.  Otherwise, an
 722    rtx corresponding to the requested word will be returned.
 723
 724    VALIDATE_ADDRESS is nonzero if the address should be validated.  Before
 725    reload has completed, a valid address will always be returned.  After
 726    reload, if a valid address cannot be returned, we return zero.
 727
 728    If VALIDATE_ADDRESS is zero, we simply form the required address; validating
 729    it is the responsibility of the caller.
 730
 731    MODE is the mode of OP in case it is a CONST_INT.  */
 732
 733 rtx
 734 operand_subword (op, i, validate_address, mode)
 735      rtx op;
 736      int i;
 737      int validate_address;
 738      enum machine_mode mode;
 739 {
 740   HOST_WIDE_INT val;
 741   int size_ratio = HOST_BITS_PER_WIDE_INT / BITS_PER_WORD;
 742
 743   if (mode == VOIDmode)
 744     mode = GET_MODE (op);
 745
 746   if (mode == VOIDmode)
 747     abort ();
 748
 749   /* If OP is narrower than a word or if we want a word outside OP, fail.  */
 750   if (mode != BLKmode
 751       && (GET_MODE_SIZE (mode) < UNITS_PER_WORD
 752           || (i + 1) * UNITS_PER_WORD > GET_MODE_SIZE (mode)))
 753     return 0;
 754
 755   /* If OP is already an integer word, return it.  */
 756   if (GET_MODE_CLASS (mode) == MODE_INT
 757       && GET_MODE_SIZE (mode) == UNITS_PER_WORD)
 758     return op;
 759
 760   /* If OP is a REG or SUBREG, we can handle it very simply.  */
 761   if (GET_CODE (op) == REG)
 762     {
 763       /* If the register is not valid for MODE, return 0.  If we don't
 764          do this, there is no way to fix up the resulting REG later.  */
 765       if (REGNO (op) < FIRST_PSEUDO_REGISTER
 766           && ! HARD_REGNO_MODE_OK (REGNO (op) + i, word_mode))
 767         return 0;
 768       else if (REGNO (op) >= FIRST_PSEUDO_REGISTER
 769                || (REG_FUNCTION_VALUE_P (op)
 770                    && rtx_equal_function_value_matters))
 771         return gen_rtx (SUBREG, word_mode, op, i);
 772       else
 773         return gen_rtx (REG, word_mode, REGNO (op) + i);
 774     }
 775   else if (GET_CODE (op) == SUBREG)
 776     return gen_rtx (SUBREG, word_mode, SUBREG_REG (op), i + SUBREG_WORD (op));
 777
 778   /* Form a new MEM at the requested address.  */
 779   if (GET_CODE (op) == MEM)
 780     {
 781       rtx addr = plus_constant (XEXP (op, 0), i * UNITS_PER_WORD);
 782       rtx new;
 783
 784       if (validate_address)
 785         {
 786           if (reload_completed)
 787             {
 788               if (! strict_memory_address_p (word_mode, addr))
 789                 return 0;
 790             }
 791           else
 792             addr = memory_address (word_mode, addr);
 793         }
 794
 795       new = gen_rtx (MEM, word_mode, addr);
 796
 797       MEM_VOLATILE_P (new) = MEM_VOLATILE_P (op);
 798       MEM_IN_STRUCT_P (new) = MEM_IN_STRUCT_P (op);
 799       RTX_UNCHANGING_P (new) = RTX_UNCHANGING_P (op);
 800
 801       return new;
 802     }
 803
 804   /* The only remaining cases are when OP is a constant.  If the host and
 805      target floating formats are the same, handling two-word floating
 806      constants are easy.  */
 807   if (((HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT
 808         && HOST_BITS_PER_WIDE_INT == BITS_PER_WORD)
 809        || flag_pretend_float)
 810       && GET_MODE_CLASS (mode) == MODE_FLOAT
 811       && GET_MODE_SIZE (mode) == 2 * UNITS_PER_WORD
 812       && GET_CODE (op) == CONST_DOUBLE)
 813     {
 814       /* The constant is stored in the host's word-ordering,
 815          but we want to access it in the target's word-ordering.  Some
 816          compilers don't like a conditional inside macro args, so we have two
 817          copies of the return.  */
 818 #ifdef HOST_WORDS_BIG_ENDIAN
 819       return GEN_INT (i == WORDS_BIG_ENDIAN
 820                       ? CONST_DOUBLE_HIGH (op) : CONST_DOUBLE_LOW (op));
 821 #else
 822       return GEN_INT (i != WORDS_BIG_ENDIAN
 823                       ? CONST_DOUBLE_HIGH (op) : CONST_DOUBLE_LOW (op));
 824 #endif
 825     }
 826
 827   /* Single word float is a little harder, since single- and double-word
 828      values often do not have the same high-order bits.  We have already
 829      verified that we want the only defined word of the single-word value.  */
 830   if (((HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT
 831         && HOST_BITS_PER_WIDE_INT == BITS_PER_WORD)
 832        || flag_pretend_float)
 833       && GET_MODE_CLASS (mode) == MODE_FLOAT
 834       && GET_MODE_SIZE (mode) == UNITS_PER_WORD
 835       && GET_CODE (op) == CONST_DOUBLE)
 836     {
 837       double d;
 838       union {float f; HOST_WIDE_INT i; } u;
 839
 840       REAL_VALUE_FROM_CONST_DOUBLE (d, op);
 841
 842       u.f = d;
 843       return GEN_INT (u.i);
 844     }
 845
 846   /* The only remaining cases that we can handle are integers.
 847      Convert to proper endianness now since these cases need it.
 848      At this point, i == 0 means the low-order word.
 849
 850      Note that it must be that BITS_PER_WORD <= HOST_BITS_PER_INT.
 851      This is because if it were greater, it could only have been two
 852      times greater since we do not support making wider constants.  In
 853      that case, it MODE would have already been the proper size and
 854      it would have been handled above.  This means we do not have to
 855      worry about the case where we would be returning a CONST_DOUBLE.  */
 856
 857   if (GET_MODE_CLASS (mode) != MODE_INT
 858       || (GET_CODE (op) != CONST_INT && GET_CODE (op) != CONST_DOUBLE))
 859     return 0;
 860
 861   if (WORDS_BIG_ENDIAN)
 862     i = GET_MODE_SIZE (mode) / UNITS_PER_WORD - 1 - i;
 863
 864   /* Find out which word on the host machine this value is in and get
 865      it from the constant.  */
 866   val = (i / size_ratio == 0
 867          ? (GET_CODE (op) == CONST_INT ? INTVAL (op) : CONST_DOUBLE_LOW (op))
 868          : (GET_CODE (op) == CONST_INT
 869             ? (INTVAL (op) < 0 ? ~0 : 0) : CONST_DOUBLE_HIGH (op)));
 870
 871   /* If BITS_PER_WORD is smaller than an int, get the appropriate bits.  */
 872   if (BITS_PER_WORD < HOST_BITS_PER_WIDE_INT)
 873     val = ((val >> ((i % size_ratio) * BITS_PER_WORD))
 874            & (((HOST_WIDE_INT) 1
 875                << (BITS_PER_WORD % HOST_BITS_PER_WIDE_INT)) - 1));
 876
 877   return GEN_INT (val);
 878 }
 879
 880 /* Similar to `operand_subword', but never return 0.  If we can't extract
 881    the required subword, put OP into a register and try again.  If that fails,
 882    abort.  We always validate the address in this case.  It is not valid
 883    to call this function after reload; it is mostly meant for RTL
 884    generation.
 885
 886    MODE is the mode of OP, in case it is CONST_INT.  */
 887
 888 rtx
 889 operand_subword_force (op, i, mode)
 890      rtx op;
 891      int i;
 892      enum machine_mode mode;
 893 {
 894   rtx result = operand_subword (op, i, 1, mode);
 895
 896   if (result)
 897     return result;
 898
 899   if (mode != BLKmode && mode != VOIDmode)
 900     op = force_reg (mode, op);
 901
 902   result = operand_subword (op, i, 1, mode);
 903   if (result == 0)
 904     abort ();
 905
 906   return result;
 907 }
 908 \f
 909 /* Given a compare instruction, swap the operands.
 910    A test instruction is changed into a compare of 0 against the operand.  */
 911
 912 void
 913 reverse_comparison (insn)
 914      rtx insn;
 915 {
 916   rtx body = PATTERN (insn);
 917   rtx comp;
 918
 919   if (GET_CODE (body) == SET)
 920     comp = SET_SRC (body);
 921   else
 922     comp = SET_SRC (XVECEXP (body, 0, 0));
 923
 924   if (GET_CODE (comp) == COMPARE)
 925     {
 926       rtx op0 = XEXP (comp, 0);
 927       rtx op1 = XEXP (comp, 1);
 928       XEXP (comp, 0) = op1;
 929       XEXP (comp, 1) = op0;
 930     }
 931   else
 932     {
 933       rtx new = gen_rtx (COMPARE, VOIDmode,
 934                          CONST0_RTX (GET_MODE (comp)), comp);
 935       if (GET_CODE (body) == SET)
 936         SET_SRC (body) = new;
 937       else
 938         SET_SRC (XVECEXP (body, 0, 0)) = new;
 939     }
 940 }
 941 \f
 942 /* Return a memory reference like MEMREF, but with its mode changed
 943    to MODE and its address changed to ADDR.
 944    (VOIDmode means don't change the mode.
 945    NULL for ADDR means don't change the address.)  */
 946
 947 rtx
 948 change_address (memref, mode, addr)
 949      rtx memref;
 950      enum machine_mode mode;
 951      rtx addr;
 952 {
 953   rtx new;
 954
 955   if (GET_CODE (memref) != MEM)
 956     abort ();
 957   if (mode == VOIDmode)
 958     mode = GET_MODE (memref);
 959   if (addr == 0)
 960     addr = XEXP (memref, 0);
 961
 962   /* If reload is in progress or has completed, ADDR must be valid.
 963      Otherwise, we can call memory_address to make it valid.  */
 964   if (reload_completed || reload_in_progress)
 965     {
 966       if (! memory_address_p (mode, addr))
 967         abort ();
 968     }
 969   else
 970     addr = memory_address (mode, addr);
 971
 972   new = gen_rtx (MEM, mode, addr);
 973   MEM_VOLATILE_P (new) = MEM_VOLATILE_P (memref);
 974   RTX_UNCHANGING_P (new) = RTX_UNCHANGING_P (memref);
 975   MEM_IN_STRUCT_P (new) = MEM_IN_STRUCT_P (memref);
 976   return new;
 977 }
 978 \f
 979 /* Return a newly created CODE_LABEL rtx with a unique label number.  */
 980
 981 rtx
 982 gen_label_rtx ()
 983 {
 984   register rtx label = gen_rtx (CODE_LABEL, VOIDmode, 0, 0, 0,
 985                                 label_num++, NULL_PTR);
 986   LABEL_NUSES (label) = 0;
 987   return label;
 988 }
 989 \f
 990 /* For procedure integration.  */
 991
 992 /* Return a newly created INLINE_HEADER rtx.  Should allocate this
 993    from a permanent obstack when the opportunity arises.  */
 994
 995 rtx
 996 gen_inline_header_rtx (first_insn, first_parm_insn, first_labelno,
 997                        last_labelno, max_parm_regnum, max_regnum, args_size,
 998                        pops_args, stack_slots, function_flags,
 999                        outgoing_args_size, original_arg_vector,
1000                        original_decl_initial)
1001      rtx first_insn, first_parm_insn;
1002      int first_labelno, last_labelno, max_parm_regnum, max_regnum, args_size;
1003      int pops_args;
1004      rtx stack_slots;
1005      int function_flags;
1006      int outgoing_args_size;
1007      rtvec original_arg_vector;
1008      rtx original_decl_initial;
1009 {
1010   rtx header = gen_rtx (INLINE_HEADER, VOIDmode,
1011                         cur_insn_uid++, NULL_RTX,
1012                         first_insn, first_parm_insn,
1013                         first_labelno, last_labelno,
1014                         max_parm_regnum, max_regnum, args_size, pops_args,
1015                         stack_slots, function_flags, outgoing_args_size,
1016                         original_arg_vector, original_decl_initial);
1017   return header;
1018 }
1019
1020 /* Install new pointers to the first and last insns in the chain.
1021    Used for an inline-procedure after copying the insn chain.  */
1022
1023 void
1024 set_new_first_and_last_insn (first, last)
1025      rtx first, last;
1026 {
1027   first_insn = first;
1028   last_insn = last;
1029 }
1030
1031 /* Set the range of label numbers found in the current function.
1032    This is used when belatedly compiling an inline function.  */
1033
1034 void
1035 set_new_first_and_last_label_num (first, last)
1036      int first, last;
1037 {
1038   base_label_num = label_num;
1039   first_label_num = first;
1040   last_label_num = last;
1041 }
1042 \f
1043 /* Save all variables describing the current status into the structure *P.
1044    This is used before starting a nested function.  */
1045
1046 void
1047 save_emit_status (p)
1048      struct function *p;
1049 {
1050   p->reg_rtx_no = reg_rtx_no;
1051   p->first_label_num = first_label_num;
1052   p->first_insn = first_insn;
1053   p->last_insn = last_insn;
1054   p->sequence_stack = sequence_stack;
1055   p->cur_insn_uid = cur_insn_uid;
1056   p->last_linenum = last_linenum;
1057   p->last_filename = last_filename;
1058   p->regno_pointer_flag = regno_pointer_flag;
1059   p->regno_pointer_flag_length = regno_pointer_flag_length;
1060   p->regno_reg_rtx = regno_reg_rtx;
1061 }
1062
1063 /* Restore all variables describing the current status from the structure *P.
1064    This is used after a nested function.  */
1065
1066 void
1067 restore_emit_status (p)
1068      struct function *p;
1069 {
1070   int i;
1071
1072   reg_rtx_no = p->reg_rtx_no;
1073   first_label_num = p->first_label_num;
1074   first_insn = p->first_insn;
1075   last_insn = p->last_insn;
1076   sequence_stack = p->sequence_stack;
1077   cur_insn_uid = p->cur_insn_uid;
1078   last_linenum = p->last_linenum;
1079   last_filename = p->last_filename;
1080   regno_pointer_flag = p->regno_pointer_flag;
1081   regno_pointer_flag_length = p->regno_pointer_flag_length;
1082   regno_reg_rtx = p->regno_reg_rtx;
1083
1084   /* Clear our cache of rtx expressions for start_sequence and gen_sequence. */
1085   sequence_element_free_list = 0;
1086   for (i = 0; i < SEQUENCE_RESULT_SIZE; i++)
1087     sequence_result[i] = 0;
1088 }
1089 \f
1090 /* Go through all the RTL insn bodies and copy any invalid shared structure.
1091    It does not work to do this twice, because the mark bits set here
1092    are not cleared afterwards.  */
1093
1094 void
1095 unshare_all_rtl (insn)
1096      register rtx insn;
1097 {
1098   for (; insn; insn = NEXT_INSN (insn))
1099     if (GET_CODE (insn) == INSN || GET_CODE (insn) == JUMP_INSN
1100         || GET_CODE (insn) == CALL_INSN)
1101       {
1102         PATTERN (insn) = copy_rtx_if_shared (PATTERN (insn));
1103         REG_NOTES (insn) = copy_rtx_if_shared (REG_NOTES (insn));
1104         LOG_LINKS (insn) = copy_rtx_if_shared (LOG_LINKS (insn));
1105       }
1106
1107   /* Make sure the addresses of stack slots found outside the insn chain
1108      (such as, in DECL_RTL of a variable) are not shared
1109      with the insn chain.
1110
1111      This special care is necessary when the stack slot MEM does not
1112      actually appear in the insn chain.  If it does appear, its address
1113      is unshared from all else at that point.  */
1114
1115   copy_rtx_if_shared (stack_slot_list);
1116 }
1117
1118 /* Mark ORIG as in use, and return a copy of it if it was already in use.
1119    Recursively does the same for subexpressions.  */
1120
1121 rtx
1122 copy_rtx_if_shared (orig)
1123      rtx orig;
1124 {
1125   register rtx x = orig;
1126   register int i;
1127   register enum rtx_code code;
1128   register char *format_ptr;
1129   int copied = 0;
1130
1131   if (x == 0)
1132     return 0;
1133
1134   code = GET_CODE (x);
1135
1136   /* These types may be freely shared.  */
1137
1138   switch (code)
1139     {
1140     case REG:
1141     case QUEUED:
1142     case CONST_INT:
1143     case CONST_DOUBLE:
1144     case SYMBOL_REF:
1145     case CODE_LABEL:
1146     case PC:
1147     case CC0:
1148     case SCRATCH:
1149       /* SCRATCH must be shared because they represent distinct values. */
1150       return x;
1151
1152     case INSN:
1153     case JUMP_INSN:
1154     case CALL_INSN:
1155     case NOTE:
1156     case LABEL_REF:
1157     case BARRIER:
1158       /* The chain of insns is not being copied.  */
1159       return x;
1160
1161     case MEM:
1162       /* A MEM is allowed to be shared if its address is constant
1163          or is a constant plus one of the special registers.  */
1164       if (CONSTANT_ADDRESS_P (XEXP (x, 0))
1165           || XEXP (x, 0) == virtual_stack_vars_rtx
1166           || XEXP (x, 0) == virtual_incoming_args_rtx)
1167         return x;
1168
1169       if (GET_CODE (XEXP (x, 0)) == PLUS
1170           && (XEXP (XEXP (x, 0), 0) == virtual_stack_vars_rtx
1171               || XEXP (XEXP (x, 0), 0) == virtual_incoming_args_rtx)
1172           && CONSTANT_ADDRESS_P (XEXP (XEXP (x, 0), 1)))
1173         {
1174           /* This MEM can appear in more than one place,
1175              but its address better not be shared with anything else.  */
1176           if (! x->used)
1177             XEXP (x, 0) = copy_rtx_if_shared (XEXP (x, 0));
1178           x->used = 1;
1179           return x;
1180         }
1181     }
1182
1183   /* This rtx may not be shared.  If it has already been seen,
1184      replace it with a copy of itself.  */
1185
1186   if (x->used)
1187     {
1188       register rtx copy;
1189
1190       copy = rtx_alloc (code);
1191       bcopy (x, copy, (sizeof (*copy) - sizeof (copy->fld)
1192                        + sizeof (copy->fld[0]) * GET_RTX_LENGTH (code)));
1193       x = copy;
1194       copied = 1;
1195     }
1196   x->used = 1;
1197
1198   /* Now scan the subexpressions recursively.
1199      We can store any replaced subexpressions directly into X
1200      since we know X is not shared!  Any vectors in X
1201      must be copied if X was copied.  */
1202
1203   format_ptr = GET_RTX_FORMAT (code);
1204
1205   for (i = 0; i < GET_RTX_LENGTH (code); i++)
1206     {
1207       switch (*format_ptr++)
1208         {
1209         case 'e':
1210           XEXP (x, i) = copy_rtx_if_shared (XEXP (x, i));
1211           break;
1212
1213         case 'E':
1214           if (XVEC (x, i) != NULL)
1215             {
1216               register int j;
1217
1218               if (copied)
1219                 XVEC (x, i) = gen_rtvec_v (XVECLEN (x, i), &XVECEXP (x, i, 0));
1220               for (j = 0; j < XVECLEN (x, i); j++)
1221                 XVECEXP (x, i, j)
1222                   = copy_rtx_if_shared (XVECEXP (x, i, j));
1223             }
1224           break;
1225         }
1226     }
1227   return x;
1228 }
1229
1230 /* Clear all the USED bits in X to allow copy_rtx_if_shared to be used
1231    to look for shared sub-parts.  */
1232
1233 void
1234 reset_used_flags (x)
1235      rtx x;
1236 {
1237   register int i, j;
1238   register enum rtx_code code;
1239   register char *format_ptr;
1240   int copied = 0;
1241
1242   if (x == 0)
1243     return;
1244
1245   code = GET_CODE (x);
1246
1247   /* These types may be freely shared so we needn't do any reseting
1248      for them.  */
1249
1250   switch (code)
1251     {
1252     case REG:
1253     case QUEUED:
1254     case CONST_INT:
1255     case CONST_DOUBLE:
1256     case SYMBOL_REF:
1257     case CODE_LABEL:
1258     case PC:
1259     case CC0:
1260       return;
1261
1262     case INSN:
1263     case JUMP_INSN:
1264     case CALL_INSN:
1265     case NOTE:
1266     case LABEL_REF:
1267     case BARRIER:
1268       /* The chain of insns is not being copied.  */
1269       return;
1270     }
1271
1272   x->used = 0;
1273
1274   format_ptr = GET_RTX_FORMAT (code);
1275   for (i = 0; i < GET_RTX_LENGTH (code); i++)
1276     {
1277       switch (*format_ptr++)
1278         {
1279         case 'e':
1280           reset_used_flags (XEXP (x, i));
1281           break;
1282
1283         case 'E':
1284           for (j = 0; j < XVECLEN (x, i); j++)
1285             reset_used_flags (XVECEXP (x, i, j));
1286           break;
1287         }
1288     }
1289 }
1290 \f
1291 /* Copy X if necessary so that it won't be altered by changes in OTHER.
1292    Return X or the rtx for the pseudo reg the value of X was copied into.
1293    OTHER must be valid as a SET_DEST.  */
1294
1295 rtx
1296 make_safe_from (x, other)
1297      rtx x, other;
1298 {
1299   while (1)
1300     switch (GET_CODE (other))
1301       {
1302       case SUBREG:
1303         other = SUBREG_REG (other);
1304         break;
1305       case STRICT_LOW_PART:
1306       case SIGN_EXTEND:
1307       case ZERO_EXTEND:
1308         other = XEXP (other, 0);
1309         break;
1310       default:
1311         goto done;
1312       }
1313  done:
1314   if ((GET_CODE (other) == MEM
1315        && ! CONSTANT_P (x)
1316        && GET_CODE (x) != REG
1317        && GET_CODE (x) != SUBREG)
1318       || (GET_CODE (other) == REG
1319           && (REGNO (other) < FIRST_PSEUDO_REGISTER
1320               || reg_mentioned_p (other, x))))
1321     {
1322       rtx temp = gen_reg_rtx (GET_MODE (x));
1323       emit_move_insn (temp, x);
1324       return temp;
1325     }
1326   return x;
1327 }
1328 \f
1329 /* Emission of insns (adding them to the doubly-linked list).  */
1330
1331 /* Return the first insn of the current sequence or current function.  */
1332
1333 rtx
1334 get_insns ()
1335 {
1336   return first_insn;
1337 }
1338
1339 /* Return the last insn emitted in current sequence or current function.  */
1340
1341 rtx
1342 get_last_insn ()
1343 {
1344   return last_insn;
1345 }
1346
1347 /* Specify a new insn as the last in the chain.  */
1348
1349 void
1350 set_last_insn (insn)
1351      rtx insn;
1352 {
1353   if (NEXT_INSN (insn) != 0)
1354     abort ();
1355   last_insn = insn;
1356 }
1357
1358 /* Return the last insn emitted, even if it is in a sequence now pushed.  */
1359
1360 rtx
1361 get_last_insn_anywhere ()
1362 {
1363   struct sequence_stack *stack;
1364   if (last_insn)
1365     return last_insn;
1366   for (stack = sequence_stack; stack; stack = stack->next)
1367     if (stack->last != 0)
1368       return stack->last;
1369   return 0;
1370 }
1371
1372 /* Return a number larger than any instruction's uid in this function.  */
1373
1374 int
1375 get_max_uid ()
1376 {
1377   return cur_insn_uid;
1378 }
1379 \f
1380 /* Return the next insn.  If it is a SEQUENCE, return the first insn
1381    of the sequence.  */
1382
1383 rtx
1384 next_insn (insn)
1385      rtx insn;
1386 {
1387   if (insn)
1388     {
1389       insn = NEXT_INSN (insn);
1390       if (insn && GET_CODE (insn) == INSN
1391           && GET_CODE (PATTERN (insn)) == SEQUENCE)
1392         insn = XVECEXP (PATTERN (insn), 0, 0);
1393     }
1394
1395   return insn;
1396 }
1397
1398 /* Return the previous insn.  If it is a SEQUENCE, return the last insn
1399    of the sequence.  */
1400
1401 rtx
1402 previous_insn (insn)
1403      rtx insn;
1404 {
1405   if (insn)
1406     {
1407       insn = PREV_INSN (insn);
1408       if (insn && GET_CODE (insn) == INSN
1409           && GET_CODE (PATTERN (insn)) == SEQUENCE)
1410         insn = XVECEXP (PATTERN (insn), 0, XVECLEN (PATTERN (insn), 0) - 1);
1411     }
1412
1413   return insn;
1414 }
1415
1416 /* Return the next insn after INSN that is not a NOTE.  This routine does not
1417    look inside SEQUENCEs.  */
1418
1419 rtx
1420 next_nonnote_insn (insn)
1421      rtx insn;
1422 {
1423   while (insn)
1424     {
1425       insn = NEXT_INSN (insn);
1426       if (insn == 0 || GET_CODE (insn) != NOTE)
1427         break;
1428     }
1429
1430   return insn;
1431 }
1432
1433 /* Return the previous insn before INSN that is not a NOTE.  This routine does
1434    not look inside SEQUENCEs.  */
1435
1436 rtx
1437 prev_nonnote_insn (insn)
1438      rtx insn;
1439 {
1440   while (insn)
1441     {
1442       insn = PREV_INSN (insn);
1443       if (insn == 0 || GET_CODE (insn) != NOTE)
1444         break;
1445     }
1446
1447   return insn;
1448 }
1449
1450 /* Return the next INSN, CALL_INSN or JUMP_INSN after INSN;
1451    or 0, if there is none.  This routine does not look inside
1452    SEQUENCEs. */
1453
1454 rtx
1455 next_real_insn (insn)
1456      rtx insn;
1457 {
1458   while (insn)
1459     {
1460       insn = NEXT_INSN (insn);
1461       if (insn == 0 || GET_CODE (insn) == INSN
1462           || GET_CODE (insn) == CALL_INSN || GET_CODE (insn) == JUMP_INSN)
1463         break;
1464     }
1465
1466   return insn;
1467 }
1468
1469 /* Return the last INSN, CALL_INSN or JUMP_INSN before INSN;
1470    or 0, if there is none.  This routine does not look inside
1471    SEQUENCEs.  */
1472
1473 rtx
1474 prev_real_insn (insn)
1475      rtx insn;
1476 {
1477   while (insn)
1478     {
1479       insn = PREV_INSN (insn);
1480       if (insn == 0 || GET_CODE (insn) == INSN || GET_CODE (insn) == CALL_INSN
1481           || GET_CODE (insn) == JUMP_INSN)
1482         break;
1483     }
1484
1485   return insn;
1486 }
1487
1488 /* Find the next insn after INSN that really does something.  This routine
1489    does not look inside SEQUENCEs.  Until reload has completed, this is the
1490    same as next_real_insn.  */
1491
1492 rtx
1493 next_active_insn (insn)
1494      rtx insn;
1495 {
1496   while (insn)
1497     {
1498       insn = NEXT_INSN (insn);
1499       if (insn == 0
1500           || GET_CODE (insn) == CALL_INSN || GET_CODE (insn) == JUMP_INSN
1501           || (GET_CODE (insn) == INSN
1502               && (! reload_completed
1503                   || (GET_CODE (PATTERN (insn)) != USE
1504                       && GET_CODE (PATTERN (insn)) != CLOBBER))))
1505         break;
1506     }
1507
1508   return insn;
1509 }
1510
1511 /* Find the last insn before INSN that really does something.  This routine
1512    does not look inside SEQUENCEs.  Until reload has completed, this is the
1513    same as prev_real_insn.  */
1514
1515 rtx
1516 prev_active_insn (insn)
1517      rtx insn;
1518 {
1519   while (insn)
1520     {
1521       insn = PREV_INSN (insn);
1522       if (insn == 0
1523           || GET_CODE (insn) == CALL_INSN || GET_CODE (insn) == JUMP_INSN
1524           || (GET_CODE (insn) == INSN
1525               && (! reload_completed
1526                   || (GET_CODE (PATTERN (insn)) != USE
1527                       && GET_CODE (PATTERN (insn)) != CLOBBER))))
1528         break;
1529     }
1530
1531   return insn;
1532 }
1533
1534 /* Return the next CODE_LABEL after the insn INSN, or 0 if there is none.  */
1535
1536 rtx
1537 next_label (insn)
1538      rtx insn;
1539 {
1540   while (insn)
1541     {
1542       insn = NEXT_INSN (insn);
1543       if (insn == 0 || GET_CODE (insn) == CODE_LABEL)
1544         break;
1545     }
1546
1547   return insn;
1548 }
1549
1550 /* Return the last CODE_LABEL before the insn INSN, or 0 if there is none.  */
1551
1552 rtx
1553 prev_label (insn)
1554      rtx insn;
1555 {
1556   while (insn)
1557     {
1558       insn = PREV_INSN (insn);
1559       if (insn == 0 || GET_CODE (insn) == CODE_LABEL)
1560         break;
1561     }
1562
1563   return insn;
1564 }
1565 \f
1566 #ifdef HAVE_cc0
1567 /* INSN uses CC0 and is being moved into a delay slot.  Set up REG_CC_SETTER
1568    and REG_CC_USER notes so we can find it.  */
1569
1570 void
1571 link_cc0_insns (insn)
1572      rtx insn;
1573 {
1574   rtx user = next_nonnote_insn (insn);
1575
1576   if (GET_CODE (user) == INSN && GET_CODE (PATTERN (user)) == SEQUENCE)
1577     user = XVECEXP (PATTERN (user), 0, 0);
1578
1579   REG_NOTES (user) = gen_rtx (INSN_LIST, REG_CC_SETTER, insn,
1580                               REG_NOTES (user));
1581   REG_NOTES (insn) = gen_rtx (INSN_LIST, REG_CC_USER, user, REG_NOTES (insn));
1582 }
1583
1584 /* Return the next insn that uses CC0 after INSN, which is assumed to
1585    set it.  This is the inverse of prev_cc0_setter (i.e., prev_cc0_setter
1586    applied to the result of this function should yield INSN).
1587
1588    Normally, this is simply the next insn.  However, if a REG_CC_USER note
1589    is present, it contains the insn that uses CC0.
1590
1591    Return 0 if we can't find the insn.  */
1592
1593 rtx
1594 next_cc0_user (insn)
1595      rtx insn;
1596 {
1597   rtx note = find_reg_note (insn, REG_CC_USER, NULL_RTX);
1598
1599   if (note)
1600     return XEXP (note, 0);
1601
1602   insn = next_nonnote_insn (insn);
1603   if (insn && GET_CODE (insn) == INSN && GET_CODE (PATTERN (insn)) == SEQUENCE)
1604     insn = XVECEXP (PATTERN (insn), 0, 0);
1605
1606   if (insn && GET_RTX_CLASS (GET_CODE (insn)) == 'i'
1607       && reg_mentioned_p (cc0_rtx, PATTERN (insn)))
1608     return insn;
1609
1610   return 0;
1611 }
1612
1613 /* Find the insn that set CC0 for INSN.  Unless INSN has a REG_CC_SETTER
1614    note, it is the previous insn.  */
1615
1616 rtx
1617 prev_cc0_setter (insn)
1618      rtx insn;
1619 {
1620   rtx note = find_reg_note (insn, REG_CC_SETTER, NULL_RTX);
1621   rtx link;
1622
1623   if (note)
1624     return XEXP (note, 0);
1625
1626   insn = prev_nonnote_insn (insn);
1627   if (! sets_cc0_p (PATTERN (insn)))
1628     abort ();
1629
1630   return insn;
1631 }
1632 #endif
1633 \f
1634 /* Try splitting insns that can be split for better scheduling.
1635    PAT is the pattern which might split.
1636    TRIAL is the insn providing PAT.
1637    BACKWARDS is non-zero if we are scanning insns from last to first.
1638
1639    If this routine succeeds in splitting, it returns the first or last
1640    replacement insn depending on the value of BACKWARDS.  Otherwise, it
1641    returns TRIAL.  If the insn to be returned can be split, it will be.  */
1642
1643 rtx
1644 try_split (pat, trial, backwards)
1645      rtx pat, trial;
1646      int backwards;
1647 {
1648   rtx before = PREV_INSN (trial);
1649   rtx after = NEXT_INSN (trial);
1650   rtx seq = split_insns (pat, trial);
1651   int has_barrier = 0;
1652   rtx tem;
1653
1654   /* If we are splitting a JUMP_INSN, it might be followed by a BARRIER.
1655      We may need to handle this specially.  */
1656   if (after && GET_CODE (after) == BARRIER)
1657     {
1658       has_barrier = 1;
1659       after = NEXT_INSN (after);
1660     }
1661
1662   if (seq)
1663     {
1664       /* SEQ can either be a SEQUENCE or the pattern of a single insn.
1665          The latter case will normally arise only when being done so that
1666          it, in turn, will be split (SFmode on the 29k is an example).  */
1667       if (GET_CODE (seq) == SEQUENCE)
1668         {
1669           /* If we are splitting a JUMP_INSN, look for the JUMP_INSN in
1670              SEQ and copy our JUMP_LABEL to it.  If JUMP_LABEL is non-zero,
1671              increment the usage count so we don't delete the label.  */
1672           int i;
1673
1674           if (GET_CODE (trial) == JUMP_INSN)
1675             for (i = XVECLEN (seq, 0) - 1; i >= 0; i--)
1676               if (GET_CODE (XVECEXP (seq, 0, i)) == JUMP_INSN)
1677                 {
1678                   JUMP_LABEL (XVECEXP (seq, 0, i)) = JUMP_LABEL (trial);
1679
1680                   if (JUMP_LABEL (trial))
1681                     LABEL_NUSES (JUMP_LABEL (trial))++;
1682                 }
1683
1684           tem = emit_insn_after (seq, before);
1685
1686           delete_insn (trial);
1687           if (has_barrier)
1688             emit_barrier_after (tem);
1689         }
1690       /* Avoid infinite loop if the result matches the original pattern.  */
1691       else if (rtx_equal_p (seq, pat))
1692         return trial;
1693       else
1694         {
1695           PATTERN (trial) = seq;
1696           INSN_CODE (trial) = -1;
1697         }
1698
1699       /* Set TEM to the insn we should return.  */
1700       tem = backwards ? prev_active_insn (after) : next_active_insn (before);
1701       return try_split (PATTERN (tem), tem, backwards);
1702     }
1703
1704   return trial;
1705 }
1706 \f
1707 /* Make and return an INSN rtx, initializing all its slots.
1708    Store PATTERN in the pattern slots.  */
1709
1710 rtx
1711 make_insn_raw (pattern)
1712      rtx pattern;
1713 {
1714   register rtx insn;
1715
1716   insn = rtx_alloc(INSN);
1717   INSN_UID(insn) = cur_insn_uid++;
1718
1719   PATTERN (insn) = pattern;
1720   INSN_CODE (insn) = -1;
1721   LOG_LINKS(insn) = NULL;
1722   REG_NOTES(insn) = NULL;
1723
1724   return insn;
1725 }
1726
1727 /* Like `make_insn' but make a JUMP_INSN instead of an insn.  */
1728
1729 static rtx
1730 make_jump_insn_raw (pattern)
1731      rtx pattern;
1732 {
1733   register rtx insn;
1734
1735   insn = rtx_alloc (JUMP_INSN);
1736   INSN_UID(insn) = cur_insn_uid++;
1737
1738   PATTERN (insn) = pattern;
1739   INSN_CODE (insn) = -1;
1740   LOG_LINKS(insn) = NULL;
1741   REG_NOTES(insn) = NULL;
1742   JUMP_LABEL(insn) = NULL;
1743
1744   return insn;
1745 }
1746 \f
1747 /* Add INSN to the end of the doubly-linked list.
1748    INSN may be an INSN, JUMP_INSN, CALL_INSN, CODE_LABEL, BARRIER or NOTE.  */
1749
1750 void
1751 add_insn (insn)
1752      register rtx insn;
1753 {
1754   PREV_INSN (insn) = last_insn;
1755   NEXT_INSN (insn) = 0;
1756
1757   if (NULL != last_insn)
1758     NEXT_INSN (last_insn) = insn;
1759
1760   if (NULL == first_insn)
1761     first_insn = insn;
1762
1763   last_insn = insn;
1764 }
1765
1766 /* Add INSN into the doubly-linked list after insn AFTER.  This should be the
1767    only function called to insert an insn once delay slots have been filled
1768    since only it knows how to update a SEQUENCE.  */
1769
1770 void
1771 add_insn_after (insn, after)
1772      rtx insn, after;
1773 {
1774   rtx next = NEXT_INSN (after);
1775
1776   NEXT_INSN (insn) = next;
1777   PREV_INSN (insn) = after;
1778
1779   if (next)
1780     {
1781       PREV_INSN (next) = insn;
1782       if (GET_CODE (next) == INSN && GET_CODE (PATTERN (next)) == SEQUENCE)
1783         PREV_INSN (XVECEXP (PATTERN (next), 0, 0)) = insn;
1784     }
1785   else if (last_insn == after)
1786     last_insn = insn;
1787   else
1788     {
1789       struct sequence_stack *stack = sequence_stack;
1790       /* Scan all pending sequences too.  */
1791       for (; stack; stack = stack->next)
1792         if (after == stack->last)
1793           stack->last = insn;
1794     }
1795
1796   NEXT_INSN (after) = insn;
1797   if (GET_CODE (after) == INSN && GET_CODE (PATTERN (after)) == SEQUENCE)
1798     {
1799       rtx sequence = PATTERN (after);
1800       NEXT_INSN (XVECEXP (sequence, 0, XVECLEN (sequence, 0) - 1)) = insn;
1801     }
1802 }
1803
1804 /* Delete all insns made since FROM.
1805    FROM becomes the new last instruction.  */
1806
1807 void
1808 delete_insns_since (from)
1809      rtx from;
1810 {
1811   if (from == 0)
1812     first_insn = 0;
1813   else
1814     NEXT_INSN (from) = 0;
1815   last_insn = from;
1816 }
1817
1818 /* Move a consecutive bunch of insns to a different place in the chain.
1819    The insns to be moved are those between FROM and TO.
1820    They are moved to a new position after the insn AFTER.
1821    AFTER must not be FROM or TO or any insn in between.
1822
1823    This function does not know about SEQUENCEs and hence should not be
1824    called after delay-slot filling has been done.  */
1825
1826 void
1827 reorder_insns (from, to, after)
1828      rtx from, to, after;
1829 {
1830   /* Splice this bunch out of where it is now.  */
1831   if (PREV_INSN (from))
1832     NEXT_INSN (PREV_INSN (from)) = NEXT_INSN (to);
1833   if (NEXT_INSN (to))
1834     PREV_INSN (NEXT_INSN (to)) = PREV_INSN (from);
1835   if (last_insn == to)
1836     last_insn = PREV_INSN (from);
1837   if (first_insn == from)
1838     first_insn = NEXT_INSN (to);
1839
1840   /* Make the new neighbors point to it and it to them.  */
1841   if (NEXT_INSN (after))
1842     PREV_INSN (NEXT_INSN (after)) = to;
1843
1844   NEXT_INSN (to) = NEXT_INSN (after);
1845   PREV_INSN (from) = after;
1846   NEXT_INSN (after) = from;
1847   if (after == last_insn)
1848     last_insn = to;
1849 }
1850
1851 /* Return the line note insn preceding INSN.  */
1852
1853 static rtx
1854 find_line_note (insn)
1855      rtx insn;
1856 {
1857   if (no_line_numbers)
1858     return 0;
1859
1860   for (; insn; insn = PREV_INSN (insn))
1861     if (GET_CODE (insn) == NOTE
1862         && NOTE_LINE_NUMBER (insn) >= 0)
1863       break;
1864
1865   return insn;
1866 }
1867
1868 /* Like reorder_insns, but inserts line notes to preserve the line numbers
1869    of the moved insns when debugging.  This may insert a note between AFTER
1870    and FROM, and another one after TO.  */
1871
1872 void
1873 reorder_insns_with_line_notes (from, to, after)
1874      rtx from, to, after;
1875 {
1876   rtx from_line = find_line_note (from);
1877   rtx after_line = find_line_note (after);
1878
1879   reorder_insns (from, to, after);
1880
1881   if (from_line == after_line)
1882     return;
1883
1884   if (from_line)
1885     emit_line_note_after (NOTE_SOURCE_FILE (from_line),
1886                           NOTE_LINE_NUMBER (from_line),
1887                           after);
1888   if (after_line)
1889     emit_line_note_after (NOTE_SOURCE_FILE (after_line),
1890                           NOTE_LINE_NUMBER (after_line),
1891                           to);
1892 }
1893 \f
1894 /* Emit an insn of given code and pattern
1895    at a specified place within the doubly-linked list.  */
1896
1897 /* Make an instruction with body PATTERN
1898    and output it before the instruction BEFORE.  */
1899
1900 rtx
1901 emit_insn_before (pattern, before)
1902      register rtx pattern, before;
1903 {
1904   register rtx insn = before;
1905
1906   if (GET_CODE (pattern) == SEQUENCE)
1907     {
1908       register int i;
1909
1910       for (i = 0; i < XVECLEN (pattern, 0); i++)
1911         {
1912           insn = XVECEXP (pattern, 0, i);
1913           add_insn_after (insn, PREV_INSN (before));
1914         }
1915       if (XVECLEN (pattern, 0) < SEQUENCE_RESULT_SIZE)
1916         sequence_result[XVECLEN (pattern, 0)] = pattern;
1917     }
1918   else
1919     {
1920       insn = make_insn_raw (pattern);
1921       add_insn_after (insn, PREV_INSN (before));
1922     }
1923
1924   return insn;
1925 }
1926
1927 /* Make an instruction with body PATTERN and code JUMP_INSN
1928    and output it before the instruction BEFORE.  */
1929
1930 rtx
1931 emit_jump_insn_before (pattern, before)
1932      register rtx pattern, before;
1933 {
1934   register rtx insn;
1935
1936   if (GET_CODE (pattern) == SEQUENCE)
1937     insn = emit_insn_before (pattern, before);
1938   else
1939     {
1940       insn = make_jump_insn_raw (pattern, NULL_RTVEC);
1941       add_insn_after (insn, PREV_INSN (before));
1942     }
1943
1944   return insn;
1945 }
1946
1947 /* Make an instruction with body PATTERN and code CALL_INSN
1948    and output it before the instruction BEFORE.  */
1949
1950 rtx
1951 emit_call_insn_before (pattern, before)
1952      register rtx pattern, before;
1953 {
1954   rtx insn = emit_insn_before (pattern, before);
1955   PUT_CODE (insn, CALL_INSN);
1956   return insn;
1957 }
1958
1959 /* Make an insn of code BARRIER
1960    and output it before the insn AFTER.  */
1961
1962 rtx
1963 emit_barrier_before (before)
1964      register rtx before;
1965 {
1966   register rtx insn = rtx_alloc (BARRIER);
1967
1968   INSN_UID (insn) = cur_insn_uid++;
1969
1970   add_insn_after (insn, PREV_INSN (before));
1971   return insn;
1972 }
1973
1974 /* Emit a note of subtype SUBTYPE before the insn BEFORE.  */
1975
1976 rtx
1977 emit_note_before (subtype, before)
1978      int subtype;
1979      rtx before;
1980 {
1981   register rtx note = rtx_alloc (NOTE);
1982   INSN_UID (note) = cur_insn_uid++;
1983   NOTE_SOURCE_FILE (note) = 0;
1984   NOTE_LINE_NUMBER (note) = subtype;
1985
1986   add_insn_after (note, PREV_INSN (before));
1987   return note;
1988 }
1989 \f
1990 /* Make an insn of code INSN with body PATTERN
1991    and output it after the insn AFTER.  */
1992
1993 rtx
1994 emit_insn_after (pattern, after)
1995      register rtx pattern, after;
1996 {
1997   register rtx insn = after;
1998
1999   if (GET_CODE (pattern) == SEQUENCE)
2000     {
2001       register int i;
2002
2003       for (i = 0; i < XVECLEN (pattern, 0); i++)
2004         {
2005           insn = XVECEXP (pattern, 0, i);
2006           add_insn_after (insn, after);
2007           after = insn;
2008         }
2009       if (XVECLEN (pattern, 0) < SEQUENCE_RESULT_SIZE)
2010         sequence_result[XVECLEN (pattern, 0)] = pattern;
2011     }
2012   else
2013     {
2014       insn = make_insn_raw (pattern);
2015       add_insn_after (insn, after);
2016     }
2017
2018   return insn;
2019 }
2020
2021 /* Make an insn of code JUMP_INSN with body PATTERN
2022    and output it after the insn AFTER.  */
2023
2024 rtx
2025 emit_jump_insn_after (pattern, after)
2026      register rtx pattern, after;
2027 {
2028   register rtx insn;
2029
2030   if (GET_CODE (pattern) == SEQUENCE)
2031     insn = emit_insn_after (pattern, after);
2032   else
2033     {
2034       insn = make_jump_insn_raw (pattern, NULL_RTVEC);
2035       add_insn_after (insn, after);
2036     }
2037
2038   return insn;
2039 }
2040
2041 /* Make an insn of code BARRIER
2042    and output it after the insn AFTER.  */
2043
2044 rtx
2045 emit_barrier_after (after)
2046      register rtx after;
2047 {
2048   register rtx insn = rtx_alloc (BARRIER);
2049
2050   INSN_UID (insn) = cur_insn_uid++;
2051
2052   add_insn_after (insn, after);
2053   return insn;
2054 }
2055
2056 /* Emit the label LABEL after the insn AFTER.  */
2057
2058 rtx
2059 emit_label_after (label, after)
2060      rtx label, after;
2061 {
2062   /* This can be called twice for the same label
2063      as a result of the confusion that follows a syntax error!
2064      So make it harmless.  */
2065   if (INSN_UID (label) == 0)
2066     {
2067       INSN_UID (label) = cur_insn_uid++;
2068       add_insn_after (label, after);
2069     }
2070
2071   return label;
2072 }
2073
2074 /* Emit a note of subtype SUBTYPE after the insn AFTER.  */
2075
2076 rtx
2077 emit_note_after (subtype, after)
2078      int subtype;
2079      rtx after;
2080 {
2081   register rtx note = rtx_alloc (NOTE);
2082   INSN_UID (note) = cur_insn_uid++;
2083   NOTE_SOURCE_FILE (note) = 0;
2084   NOTE_LINE_NUMBER (note) = subtype;
2085   add_insn_after (note, after);
2086   return note;
2087 }
2088
2089 /* Emit a line note for FILE and LINE after the insn AFTER.  */
2090
2091 rtx
2092 emit_line_note_after (file, line, after)
2093      char *file;
2094      int line;
2095      rtx after;
2096 {
2097   register rtx note;
2098
2099   if (no_line_numbers && line > 0)
2100     {
2101       cur_insn_uid++;
2102       return 0;
2103     }
2104
2105   note  = rtx_alloc (NOTE);
2106   INSN_UID (note) = cur_insn_uid++;
2107   NOTE_SOURCE_FILE (note) = file;
2108   NOTE_LINE_NUMBER (note) = line;
2109   add_insn_after (note, after);
2110   return note;
2111 }
2112 \f
2113 /* Make an insn of code INSN with pattern PATTERN
2114    and add it to the end of the doubly-linked list.
2115    If PATTERN is a SEQUENCE, take the elements of it
2116    and emit an insn for each element.
2117
2118    Returns the last insn emitted.  */
2119
2120 rtx
2121 emit_insn (pattern)
2122      rtx pattern;
2123 {
2124   rtx insn = last_insn;
2125
2126   if (GET_CODE (pattern) == SEQUENCE)
2127     {
2128       register int i;
2129
2130       for (i = 0; i < XVECLEN (pattern, 0); i++)
2131         {
2132           insn = XVECEXP (pattern, 0, i);
2133           add_insn (insn);
2134         }
2135       if (XVECLEN (pattern, 0) < SEQUENCE_RESULT_SIZE)
2136         sequence_result[XVECLEN (pattern, 0)] = pattern;
2137     }
2138   else
2139     {
2140       insn = make_insn_raw (pattern);
2141       add_insn (insn);
2142     }
2143
2144   return insn;
2145 }
2146
2147 /* Emit the insns in a chain starting with INSN.
2148    Return the last insn emitted.  */
2149
2150 rtx
2151 emit_insns (insn)
2152      rtx insn;
2153 {
2154   rtx last = 0;
2155
2156   while (insn)
2157     {
2158       rtx next = NEXT_INSN (insn);
2159       add_insn (insn);
2160       last = insn;
2161       insn = next;
2162     }
2163
2164   return last;
2165 }
2166
2167 /* Emit the insns in a chain starting with INSN and place them in front of
2168    the insn BEFORE.  Return the last insn emitted.  */
2169
2170 rtx
2171 emit_insns_before (insn, before)
2172      rtx insn;
2173      rtx before;
2174 {
2175   rtx last = 0;
2176
2177   while (insn)
2178     {
2179       rtx next = NEXT_INSN (insn);
2180       add_insn_after (insn, PREV_INSN (before));
2181       last = insn;
2182       insn = next;
2183     }
2184
2185   return last;
2186 }
2187
2188 /* Emit the insns in a chain starting with FIRST and place them in back of
2189    the insn AFTER.  Return the last insn emitted.  */
2190
2191 rtx
2192 emit_insns_after (first, after)
2193      register rtx first;
2194      register rtx after;
2195 {
2196   register rtx last;
2197   register rtx after_after;
2198
2199   if (!after)
2200     abort ();
2201
2202   if (!first)
2203     return first;
2204
2205   for (last = first; NEXT_INSN (last); last = NEXT_INSN (last))
2206     continue;
2207
2208   after_after = NEXT_INSN (after);
2209
2210   NEXT_INSN (after) = first;
2211   PREV_INSN (first) = after;
2212   NEXT_INSN (last) = after_after;
2213   if (after_after)
2214     PREV_INSN (after_after) = last;
2215
2216   return last;
2217 }
2218
2219 /* Make an insn of code JUMP_INSN with pattern PATTERN
2220    and add it to the end of the doubly-linked list.  */
2221
2222 rtx
2223 emit_jump_insn (pattern)
2224      rtx pattern;
2225 {
2226   if (GET_CODE (pattern) == SEQUENCE)
2227     return emit_insn (pattern);
2228   else
2229     {
2230       register rtx insn = make_jump_insn_raw (pattern, NULL_RTVEC);
2231       add_insn (insn);
2232       return insn;
2233     }
2234 }
2235
2236 /* Make an insn of code CALL_INSN with pattern PATTERN
2237    and add it to the end of the doubly-linked list.  */
2238
2239 rtx
2240 emit_call_insn (pattern)
2241      rtx pattern;
2242 {
2243   if (GET_CODE (pattern) == SEQUENCE)
2244     return emit_insn (pattern);
2245   else
2246     {
2247       register rtx insn = make_insn_raw (pattern);
2248       add_insn (insn);
2249       PUT_CODE (insn, CALL_INSN);
2250       return insn;
2251     }
2252 }
2253
2254 /* Add the label LABEL to the end of the doubly-linked list.  */
2255
2256 rtx
2257 emit_label (label)
2258      rtx label;
2259 {
2260   /* This can be called twice for the same label
2261      as a result of the confusion that follows a syntax error!
2262      So make it harmless.  */
2263   if (INSN_UID (label) == 0)
2264     {
2265       INSN_UID (label) = cur_insn_uid++;
2266       add_insn (label);
2267     }
2268   return label;
2269 }
2270
2271 /* Make an insn of code BARRIER
2272    and add it to the end of the doubly-linked list.  */
2273
2274 rtx
2275 emit_barrier ()
2276 {
2277   register rtx barrier = rtx_alloc (BARRIER);
2278   INSN_UID (barrier) = cur_insn_uid++;
2279   add_insn (barrier);
2280   return barrier;
2281 }
2282
2283 /* Make an insn of code NOTE
2284    with data-fields specified by FILE and LINE
2285    and add it to the end of the doubly-linked list,
2286    but only if line-numbers are desired for debugging info.  */
2287
2288 rtx
2289 emit_line_note (file, line)
2290      char *file;
2291      int line;
2292 {
2293   emit_filename = file;
2294   emit_lineno = line;
2295
2296 #if 0
2297   if (no_line_numbers)
2298     return 0;
2299 #endif
2300
2301   return emit_note (file, line);
2302 }
2303
2304 /* Make an insn of code NOTE
2305    with data-fields specified by FILE and LINE
2306    and add it to the end of the doubly-linked list.
2307    If it is a line-number NOTE, omit it if it matches the previous one.  */
2308
2309 rtx
2310 emit_note (file, line)
2311      char *file;
2312      int line;
2313 {
2314   register rtx note;
2315
2316   if (line > 0)
2317     {
2318       if (file && last_filename && !strcmp (file, last_filename)
2319           && line == last_linenum)
2320         return 0;
2321       last_filename = file;
2322       last_linenum = line;
2323     }
2324
2325   if (no_line_numbers && line > 0)
2326     {
2327       cur_insn_uid++;
2328       return 0;
2329     }
2330
2331   note = rtx_alloc (NOTE);
2332   INSN_UID (note) = cur_insn_uid++;
2333   NOTE_SOURCE_FILE (note) = file;
2334   NOTE_LINE_NUMBER (note) = line;
2335   add_insn (note);
2336   return note;
2337 }
2338
2339 /* Emit a NOTE, and don't omit it even if LINE it the previous note.  */
2340
2341 rtx
2342 emit_line_note_force (file, line)
2343      char *file;
2344      int line;
2345 {
2346   last_linenum = -1;
2347   return emit_line_note (file, line);
2348 }
2349
2350 /* Cause next statement to emit a line note even if the line number
2351    has not changed.  This is used at the beginning of a function.  */
2352
2353 void
2354 force_next_line_note ()
2355 {
2356   last_linenum = -1;
2357 }
2358 \f
2359 /* Return an indication of which type of insn should have X as a body.
2360    The value is CODE_LABEL, INSN, CALL_INSN or JUMP_INSN.  */
2361
2362 enum rtx_code
2363 classify_insn (x)
2364      rtx x;
2365 {
2366   if (GET_CODE (x) == CODE_LABEL)
2367     return CODE_LABEL;
2368   if (GET_CODE (x) == CALL)
2369     return CALL_INSN;
2370   if (GET_CODE (x) == RETURN)
2371     return JUMP_INSN;
2372   if (GET_CODE (x) == SET)
2373     {
2374       if (SET_DEST (x) == pc_rtx)
2375         return JUMP_INSN;
2376       else if (GET_CODE (SET_SRC (x)) == CALL)
2377         return CALL_INSN;
2378       else
2379         return INSN;
2380     }
2381   if (GET_CODE (x) == PARALLEL)
2382     {
2383       register int j;
2384       for (j = XVECLEN (x, 0) - 1; j >= 0; j--)
2385         if (GET_CODE (XVECEXP (x, 0, j)) == CALL)
2386           return CALL_INSN;
2387         else if (GET_CODE (XVECEXP (x, 0, j)) == SET
2388                  && SET_DEST (XVECEXP (x, 0, j)) == pc_rtx)
2389           return JUMP_INSN;
2390         else if (GET_CODE (XVECEXP (x, 0, j)) == SET
2391                  && GET_CODE (SET_SRC (XVECEXP (x, 0, j))) == CALL)
2392           return CALL_INSN;
2393     }
2394   return INSN;
2395 }
2396
2397 /* Emit the rtl pattern X as an appropriate kind of insn.
2398    If X is a label, it is simply added into the insn chain.  */
2399
2400 rtx
2401 emit (x)
2402      rtx x;
2403 {
2404   enum rtx_code code = classify_insn (x);
2405
2406   if (code == CODE_LABEL)
2407     return emit_label (x);
2408   else if (code == INSN)
2409     return emit_insn (x);
2410   else if (code == JUMP_INSN)
2411     {
2412       register rtx insn = emit_jump_insn (x);
2413       if (simplejump_p (insn) || GET_CODE (x) == RETURN)
2414         return emit_barrier ();
2415       return insn;
2416     }
2417   else if (code == CALL_INSN)
2418     return emit_call_insn (x);
2419   else
2420     abort ();
2421 }
2422 \f
2423 /* Begin emitting insns to a sequence which can be packaged in an RTL_EXPR.  */
2424
2425 void
2426 start_sequence ()
2427 {
2428   struct sequence_stack *tem;
2429
2430   if (sequence_element_free_list)
2431     {
2432       /* Reuse a previously-saved struct sequence_stack.  */
2433       tem = sequence_element_free_list;
2434       sequence_element_free_list = tem->next;
2435     }
2436   else
2437     tem = (struct sequence_stack *) permalloc (sizeof (struct sequence_stack));
2438
2439   tem->next = sequence_stack;
2440   tem->first = first_insn;
2441   tem->last = last_insn;
2442
2443   sequence_stack = tem;
2444
2445   first_insn = 0;
2446   last_insn = 0;
2447 }
2448
2449 /* Set up the insn chain starting with FIRST
2450    as the current sequence, saving the previously current one.  */
2451
2452 void
2453 push_to_sequence (first)
2454      rtx first;
2455 {
2456   rtx last;
2457
2458   start_sequence ();
2459
2460   for (last = first; last && NEXT_INSN (last); last = NEXT_INSN (last));
2461
2462   first_insn = first;
2463   last_insn = last;
2464 }
2465
2466 /* After emitting to a sequence, restore previous saved state.
2467
2468    To get the contents of the sequence just made,
2469    you must call `gen_sequence' *before* calling here.  */
2470
2471 void
2472 end_sequence ()
2473 {
2474   struct sequence_stack *tem = sequence_stack;
2475
2476   first_insn = tem->first;
2477   last_insn = tem->last;
2478   sequence_stack = tem->next;
2479
2480   tem->next = sequence_element_free_list;
2481   sequence_element_free_list = tem;
2482 }
2483
2484 /* Return 1 if currently emitting into a sequence.  */
2485
2486 int
2487 in_sequence_p ()
2488 {
2489   return sequence_stack != 0;
2490 }
2491
2492 /* Generate a SEQUENCE rtx containing the insns already emitted
2493    to the current sequence.
2494
2495    This is how the gen_... function from a DEFINE_EXPAND
2496    constructs the SEQUENCE that it returns.  */
2497
2498 rtx
2499 gen_sequence ()
2500 {
2501   rtx result;
2502   rtx tem;
2503   rtvec newvec;
2504   int i;
2505   int len;
2506
2507   /* Count the insns in the chain.  */
2508   len = 0;
2509   for (tem = first_insn; tem; tem = NEXT_INSN (tem))
2510     len++;
2511
2512   /* If only one insn, return its pattern rather than a SEQUENCE.
2513      (Now that we cache SEQUENCE expressions, it isn't worth special-casing
2514      the case of an empty list.)  */
2515   if (len == 1
2516       && (GET_CODE (first_insn) == INSN
2517           || GET_CODE (first_insn) == JUMP_INSN
2518           || GET_CODE (first_insn) == CALL_INSN))
2519     return PATTERN (first_insn);
2520
2521   /* Put them in a vector.  See if we already have a SEQUENCE of the
2522      appropriate length around.  */
2523   if (len < SEQUENCE_RESULT_SIZE && (result = sequence_result[len]) != 0)
2524     sequence_result[len] = 0;
2525   else
2526     {
2527       /* Ensure that this rtl goes in saveable_obstack, since we may be
2528          caching it.  */
2529       int in_current_obstack = rtl_in_saveable_obstack ();
2530       result = gen_rtx (SEQUENCE, VOIDmode, rtvec_alloc (len));
2531       if (in_current_obstack)
2532         rtl_in_current_obstack ();
2533     }
2534
2535   for (i = 0, tem = first_insn; tem; tem = NEXT_INSN (tem), i++)
2536     XVECEXP (result, 0, i) = tem;
2537
2538   return result;
2539 }
2540 \f
2541 /* Set up regno_reg_rtx, reg_rtx_no and regno_pointer_flag
2542    according to the chain of insns starting with FIRST.
2543
2544    Also set cur_insn_uid to exceed the largest uid in that chain.
2545
2546    This is used when an inline function's rtl is saved
2547    and passed to rest_of_compilation later.  */
2548
2549 static void restore_reg_data_1 ();
2550
2551 void
2552 restore_reg_data (first)
2553      rtx first;
2554 {
2555   register rtx insn;
2556   int i;
2557   register int max_uid = 0;
2558
2559   for (insn = first; insn; insn = NEXT_INSN (insn))
2560     {
2561       if (INSN_UID (insn) >= max_uid)
2562         max_uid = INSN_UID (insn);
2563
2564       switch (GET_CODE (insn))
2565         {
2566         case NOTE:
2567         case CODE_LABEL:
2568         case BARRIER:
2569           break;
2570
2571         case JUMP_INSN:
2572         case CALL_INSN:
2573         case INSN:
2574           restore_reg_data_1 (PATTERN (insn));
2575           break;
2576         }
2577     }
2578
2579   /* Don't duplicate the uids already in use.  */
2580   cur_insn_uid = max_uid + 1;
2581
2582   /* If any regs are missing, make them up.
2583
2584      ??? word_mode is not necessarily the right mode.  Most likely these REGs
2585      are never used.  At some point this should be checked.  */
2586
2587   for (i = FIRST_PSEUDO_REGISTER; i < reg_rtx_no; i++)
2588     if (regno_reg_rtx[i] == 0)
2589       regno_reg_rtx[i] = gen_rtx (REG, word_mode, i);
2590 }
2591
2592 static void
2593 restore_reg_data_1 (orig)
2594      rtx orig;
2595 {
2596   register rtx x = orig;
2597   register int i;
2598   register enum rtx_code code;
2599   register char *format_ptr;
2600
2601   code = GET_CODE (x);
2602
2603   switch (code)
2604     {
2605     case QUEUED:
2606     case CONST_INT:
2607     case CONST_DOUBLE:
2608     case SYMBOL_REF:
2609     case CODE_LABEL:
2610     case PC:
2611     case CC0:
2612     case LABEL_REF:
2613       return;
2614
2615     case REG:
2616       if (REGNO (x) >= FIRST_PSEUDO_REGISTER)
2617         {
2618           /* Make sure regno_pointer_flag and regno_reg_rtx are large
2619              enough to have an element for this pseudo reg number.  */
2620           if (REGNO (x) >= reg_rtx_no)
2621             {
2622               reg_rtx_no = REGNO (x);
2623
2624               if (reg_rtx_no >= regno_pointer_flag_length)
2625                 {
2626                   int newlen = MAX (regno_pointer_flag_length * 2,
2627                                     reg_rtx_no + 30);
2628                   rtx *new1;
2629                   char *new = (char *) oballoc (newlen);
2630                   bzero (new, newlen);
2631                   bcopy (regno_pointer_flag, new, regno_pointer_flag_length);
2632
2633                   new1 = (rtx *) oballoc (newlen * sizeof (rtx));
2634                   bzero (new1, newlen * sizeof (rtx));
2635                   bcopy (regno_reg_rtx, new1, regno_pointer_flag_length * sizeof (rtx));
2636
2637                   regno_pointer_flag = new;
2638                   regno_reg_rtx = new1;
2639                   regno_pointer_flag_length = newlen;
2640                 }
2641               reg_rtx_no ++;
2642             }
2643           regno_reg_rtx[REGNO (x)] = x;
2644         }
2645       return;
2646
2647     case MEM:
2648       if (GET_CODE (XEXP (x, 0)) == REG)
2649         mark_reg_pointer (XEXP (x, 0));
2650       restore_reg_data_1 (XEXP (x, 0));
2651       return;
2652     }
2653
2654   /* Now scan the subexpressions recursively.  */
2655
2656   format_ptr = GET_RTX_FORMAT (code);
2657
2658   for (i = 0; i < GET_RTX_LENGTH (code); i++)
2659     {
2660       switch (*format_ptr++)
2661         {
2662         case 'e':
2663           restore_reg_data_1 (XEXP (x, i));
2664           break;
2665
2666         case 'E':
2667           if (XVEC (x, i) != NULL)
2668             {
2669               register int j;
2670
2671               for (j = 0; j < XVECLEN (x, i); j++)
2672                 restore_reg_data_1 (XVECEXP (x, i, j));
2673             }
2674           break;
2675         }
2676     }
2677 }
2678 \f
2679 /* Initialize data structures and variables in this file
2680    before generating rtl for each function.  */
2681
2682 void
2683 init_emit ()
2684 {
2685   int i;
2686
2687   first_insn = NULL;
2688   last_insn = NULL;
2689   cur_insn_uid = 1;
2690   reg_rtx_no = LAST_VIRTUAL_REGISTER + 1;
2691   last_linenum = 0;
2692   last_filename = 0;
2693   first_label_num = label_num;
2694   last_label_num = 0;
2695
2696   /* Clear the start_sequence/gen_sequence cache.  */
2697   sequence_element_free_list = 0;
2698   for (i = 0; i < SEQUENCE_RESULT_SIZE; i++)
2699     sequence_result[i] = 0;
2700
2701   /* Init the tables that describe all the pseudo regs.  */
2702
2703   regno_pointer_flag_length = LAST_VIRTUAL_REGISTER + 101;
2704
2705   regno_pointer_flag
2706     = (char *) oballoc (regno_pointer_flag_length);
2707   bzero (regno_pointer_flag, regno_pointer_flag_length);
2708
2709   regno_reg_rtx
2710     = (rtx *) oballoc (regno_pointer_flag_length * sizeof (rtx));
2711   bzero (regno_reg_rtx, regno_pointer_flag_length * sizeof (rtx));
2712
2713   /* Put copies of all the virtual register rtx into regno_reg_rtx.  */
2714   regno_reg_rtx[VIRTUAL_INCOMING_ARGS_REGNUM] = virtual_incoming_args_rtx;
2715   regno_reg_rtx[VIRTUAL_STACK_VARS_REGNUM] = virtual_stack_vars_rtx;
2716   regno_reg_rtx[VIRTUAL_STACK_DYNAMIC_REGNUM] = virtual_stack_dynamic_rtx;
2717   regno_reg_rtx[VIRTUAL_OUTGOING_ARGS_REGNUM] = virtual_outgoing_args_rtx;
2718
2719   /* Indicate that the virtual registers and stack locations are
2720      all pointers.  */
2721   REGNO_POINTER_FLAG (STACK_POINTER_REGNUM) = 1;
2722   REGNO_POINTER_FLAG (FRAME_POINTER_REGNUM) = 1;
2723   REGNO_POINTER_FLAG (ARG_POINTER_REGNUM) = 1;
2724
2725   REGNO_POINTER_FLAG (VIRTUAL_INCOMING_ARGS_REGNUM) = 1;
2726   REGNO_POINTER_FLAG (VIRTUAL_STACK_VARS_REGNUM) = 1;
2727   REGNO_POINTER_FLAG (VIRTUAL_STACK_DYNAMIC_REGNUM) = 1;
2728   REGNO_POINTER_FLAG (VIRTUAL_OUTGOING_ARGS_REGNUM) = 1;
2729 }
2730
2731 /* Create some permanent unique rtl objects shared between all functions.
2732    LINE_NUMBERS is nonzero if line numbers are to be generated.  */
2733
2734 void
2735 init_emit_once (line_numbers)
2736      int line_numbers;
2737 {
2738   int i;
2739   enum machine_mode mode;
2740
2741   no_line_numbers = ! line_numbers;
2742
2743   sequence_stack = NULL;
2744
2745   /* Create the unique rtx's for certain rtx codes and operand values.  */
2746
2747   pc_rtx = gen_rtx (PC, VOIDmode);
2748   cc0_rtx = gen_rtx (CC0, VOIDmode);
2749
2750   /* Don't use gen_rtx here since gen_rtx in this case
2751      tries to use these variables.  */
2752   for (i = - MAX_SAVED_CONST_INT; i <= MAX_SAVED_CONST_INT; i++)
2753     {
2754       const_int_rtx[i + MAX_SAVED_CONST_INT] = rtx_alloc (CONST_INT);
2755       PUT_MODE (const_int_rtx[i + MAX_SAVED_CONST_INT], VOIDmode);
2756       INTVAL (const_int_rtx[i + MAX_SAVED_CONST_INT]) = i;
2757     }
2758
2759   /* These four calls obtain some of the rtx expressions made above.  */
2760   const0_rtx = GEN_INT (0);
2761   const1_rtx = GEN_INT (1);
2762   const2_rtx = GEN_INT (2);
2763   constm1_rtx = GEN_INT (-1);
2764
2765   /* This will usually be one of the above constants, but may be a new rtx.  */
2766   const_true_rtx = GEN_INT (STORE_FLAG_VALUE);
2767
2768   dconst0 = REAL_VALUE_ATOF ("0");
2769   dconst1 = REAL_VALUE_ATOF ("1");
2770   dconst2 = REAL_VALUE_ATOF ("2");
2771   dconstm1 = REAL_VALUE_ATOF ("-1");
2772
2773   for (i = 0; i <= 2; i++)
2774     {
2775       for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT); mode != VOIDmode;
2776            mode = GET_MODE_WIDER_MODE (mode))
2777         {
2778           rtx tem = rtx_alloc (CONST_DOUBLE);
2779           union real_extract u;
2780
2781           bzero (&u, sizeof u);  /* Zero any holes in a structure.  */
2782           u.d = i == 0 ? dconst0 : i == 1 ? dconst1 : dconst2;
2783
2784           bcopy (&u, &CONST_DOUBLE_LOW (tem), sizeof u);
2785           CONST_DOUBLE_MEM (tem) = cc0_rtx;
2786           PUT_MODE (tem, mode);
2787
2788           const_tiny_rtx[i][(int) mode] = tem;
2789         }
2790
2791       const_tiny_rtx[i][(int) VOIDmode] = GEN_INT (i);
2792
2793       for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
2794            mode = GET_MODE_WIDER_MODE (mode))
2795         const_tiny_rtx[i][(int) mode] = GEN_INT (i);
2796     }
2797
2798   for (mode = GET_CLASS_NARROWEST_MODE (MODE_CC); mode != VOIDmode;
2799        mode = GET_MODE_WIDER_MODE (mode))
2800     const_tiny_rtx[0][(int) mode] = const0_rtx;
2801
2802   stack_pointer_rtx = gen_rtx (REG, Pmode, STACK_POINTER_REGNUM);
2803   frame_pointer_rtx = gen_rtx (REG, Pmode, FRAME_POINTER_REGNUM);
2804
2805   if (FRAME_POINTER_REGNUM == ARG_POINTER_REGNUM)
2806     arg_pointer_rtx = frame_pointer_rtx;
2807   else if (STACK_POINTER_REGNUM == ARG_POINTER_REGNUM)
2808     arg_pointer_rtx = stack_pointer_rtx;
2809   else
2810     arg_pointer_rtx = gen_rtx (REG, Pmode, ARG_POINTER_REGNUM);
2811
2812   /* Create the virtual registers.  Do so here since the following objects
2813      might reference them.  */
2814
2815   virtual_incoming_args_rtx = gen_rtx (REG, Pmode,
2816                                        VIRTUAL_INCOMING_ARGS_REGNUM);
2817   virtual_stack_vars_rtx = gen_rtx (REG, Pmode,
2818                                     VIRTUAL_STACK_VARS_REGNUM);
2819   virtual_stack_dynamic_rtx = gen_rtx (REG, Pmode,
2820                                        VIRTUAL_STACK_DYNAMIC_REGNUM);
2821   virtual_outgoing_args_rtx = gen_rtx (REG, Pmode,
2822                                        VIRTUAL_OUTGOING_ARGS_REGNUM);
2823
2824 #ifdef STRUCT_VALUE
2825   struct_value_rtx = STRUCT_VALUE;
2826 #else
2827   struct_value_rtx = gen_rtx (REG, Pmode, STRUCT_VALUE_REGNUM);
2828 #endif
2829
2830 #ifdef STRUCT_VALUE_INCOMING
2831   struct_value_incoming_rtx = STRUCT_VALUE_INCOMING;
2832 #else
2833 #ifdef STRUCT_VALUE_INCOMING_REGNUM
2834   struct_value_incoming_rtx
2835     = gen_rtx (REG, Pmode, STRUCT_VALUE_INCOMING_REGNUM);
2836 #else
2837   struct_value_incoming_rtx = struct_value_rtx;
2838 #endif
2839 #endif
2840
2841 #ifdef STATIC_CHAIN_REGNUM
2842   static_chain_rtx = gen_rtx (REG, Pmode, STATIC_CHAIN_REGNUM);
2843
2844 #ifdef STATIC_CHAIN_INCOMING_REGNUM
2845   if (STATIC_CHAIN_INCOMING_REGNUM != STATIC_CHAIN_REGNUM)
2846     static_chain_incoming_rtx = gen_rtx (REG, Pmode, STATIC_CHAIN_INCOMING_REGNUM);
2847   else
2848 #endif
2849     static_chain_incoming_rtx = static_chain_rtx;
2850 #endif
2851
2852 #ifdef STATIC_CHAIN
2853   static_chain_rtx = STATIC_CHAIN;
2854
2855 #ifdef STATIC_CHAIN_INCOMING
2856   static_chain_incoming_rtx = STATIC_CHAIN_INCOMING;
2857 #else
2858   static_chain_incoming_rtx = static_chain_rtx;
2859 #endif
2860 #endif
2861
2862 #ifdef PIC_OFFSET_TABLE_REGNUM
2863   pic_offset_table_rtx = gen_rtx (REG, Pmode, PIC_OFFSET_TABLE_REGNUM);
2864 #endif
2865 }