gcc/emit-rtl.c

   1 /* Emit RTL for the GNU C-Compiler expander.
   2    Copyright (C) 1987, 1988, 1992, 1993 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           || GET_MODE_CLASS (mode) == MODE_PARTIAL_INT))
 501     {
 502       /* If we are getting the low-order part of something that has been
 503          sign- or zero-extended, we can either just use the object being
 504          extended or make a narrower extension.  If we want an even smaller
 505          piece than the size of the object being extended, call ourselves
 506          recursively.
 507
 508          This case is used mostly by combine and cse.  */
 509
 510       if (GET_MODE (XEXP (x, 0)) == mode)
 511         return XEXP (x, 0);
 512       else if (GET_MODE_SIZE (mode) < GET_MODE_SIZE (GET_MODE (XEXP (x, 0))))
 513         return gen_lowpart_common (mode, XEXP (x, 0));
 514       else if (GET_MODE_SIZE (mode) < GET_MODE_SIZE (GET_MODE (x)))
 515         return gen_rtx (GET_CODE (x), mode, XEXP (x, 0));
 516     }
 517   else if (GET_CODE (x) == SUBREG
 518            && (GET_MODE_SIZE (mode) <= UNITS_PER_WORD
 519                || GET_MODE_SIZE (mode) == GET_MODE_UNIT_SIZE (GET_MODE (x))))
 520     return (GET_MODE (SUBREG_REG (x)) == mode && SUBREG_WORD (x) == 0
 521             ? SUBREG_REG (x)
 522             : gen_rtx (SUBREG, mode, SUBREG_REG (x), SUBREG_WORD (x)));
 523   else if (GET_CODE (x) == REG)
 524     {
 525       /* If the register is not valid for MODE, return 0.  If we don't
 526          do this, there is no way to fix up the resulting REG later.  */
 527       if (REGNO (x) < FIRST_PSEUDO_REGISTER
 528           && ! HARD_REGNO_MODE_OK (REGNO (x) + word, mode))
 529         return 0;
 530       else if (REGNO (x) < FIRST_PSEUDO_REGISTER
 531                /* integrate.c can't handle parts of a return value register. */
 532                && (! REG_FUNCTION_VALUE_P (x)
 533                    || ! rtx_equal_function_value_matters)
 534                /* We want to keep the stack, frame, and arg pointers
 535                   special.  */
 536                && REGNO (x) != FRAME_POINTER_REGNUM
 537 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
 538                && REGNO (x) != ARG_POINTER_REGNUM
 539 #endif
 540                && REGNO (x) != STACK_POINTER_REGNUM)
 541         return gen_rtx (REG, mode, REGNO (x) + word);
 542       else
 543         return gen_rtx (SUBREG, mode, x, word);
 544     }
 545
 546   /* If X is a CONST_INT or a CONST_DOUBLE, extract the appropriate bits
 547      from the low-order part of the constant.  */
 548   else if ((GET_MODE_CLASS (mode) == MODE_INT
 549             || GET_MODE_CLASS (mode) == MODE_PARTIAL_INT)
 550            && GET_MODE (x) == VOIDmode
 551            && (GET_CODE (x) == CONST_INT || GET_CODE (x) == CONST_DOUBLE))
 552     {
 553       /* If MODE is twice the host word size, X is already the desired
 554          representation.  Otherwise, if MODE is wider than a word, we can't
 555          do this.  If MODE is exactly a word, return just one CONST_INT.
 556          If MODE is smaller than a word, clear the bits that don't belong
 557          in our mode, unless they and our sign bit are all one.  So we get
 558          either a reasonable negative value or a reasonable unsigned value
 559          for this mode.  */
 560
 561       if (GET_MODE_BITSIZE (mode) == 2 * HOST_BITS_PER_WIDE_INT)
 562         return x;
 563       else if (GET_MODE_BITSIZE (mode) > HOST_BITS_PER_WIDE_INT)
 564         return 0;
 565       else if (GET_MODE_BITSIZE (mode) == HOST_BITS_PER_WIDE_INT)
 566         return (GET_CODE (x) == CONST_INT ? x
 567                 : GEN_INT (CONST_DOUBLE_LOW (x)));
 568       else
 569         {
 570           /* MODE must be narrower than HOST_BITS_PER_INT.  */
 571           int width = GET_MODE_BITSIZE (mode);
 572           HOST_WIDE_INT val = (GET_CODE (x) == CONST_INT ? INTVAL (x)
 573                                : CONST_DOUBLE_LOW (x));
 574
 575           if (((val & ((HOST_WIDE_INT) (-1) << (width - 1)))
 576                != ((HOST_WIDE_INT) (-1) << (width - 1))))
 577             val &= ((HOST_WIDE_INT) 1 << width) - 1;
 578
 579           return (GET_CODE (x) == CONST_INT && INTVAL (x) == val ? x
 580                   : GEN_INT (val));
 581         }
 582     }
 583
 584   /* If X is an integral constant but we want it in floating-point, it
 585      must be the case that we have a union of an integer and a floating-point
 586      value.  If the machine-parameters allow it, simulate that union here
 587      and return the result.  The two-word and single-word cases are
 588      different.  */
 589
 590   else if (((HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT
 591              && HOST_BITS_PER_WIDE_INT == BITS_PER_WORD)
 592             || flag_pretend_float)
 593            && GET_MODE_CLASS (mode) == MODE_FLOAT
 594            && GET_MODE_SIZE (mode) == UNITS_PER_WORD
 595            && GET_CODE (x) == CONST_INT
 596            && sizeof (float) * HOST_BITS_PER_CHAR == HOST_BITS_PER_WIDE_INT)
 597 #ifdef REAL_ARITHMETIC
 598     {
 599       REAL_VALUE_TYPE r;
 600       HOST_WIDE_INT i;
 601
 602       i = INTVAL (x);
 603       r = REAL_VALUE_FROM_TARGET_SINGLE (i);
 604       return immed_real_const_1 (r, mode);
 605     }
 606 #else
 607     {
 608       union {HOST_WIDE_INT i; float d; } u;
 609
 610       u.i = INTVAL (x);
 611       return immed_real_const_1 (u.d, mode);
 612     }
 613 #endif
 614   else if (((HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT
 615              && HOST_BITS_PER_WIDE_INT == BITS_PER_WORD)
 616             || flag_pretend_float)
 617            && GET_MODE_CLASS (mode) == MODE_FLOAT
 618            && GET_MODE_SIZE (mode) == 2 * UNITS_PER_WORD
 619            && (GET_CODE (x) == CONST_INT || GET_CODE (x) == CONST_DOUBLE)
 620            && GET_MODE (x) == VOIDmode
 621            && (sizeof (double) * HOST_BITS_PER_CHAR
 622                == 2 * HOST_BITS_PER_WIDE_INT))
 623 #ifdef REAL_ARITHMETIC
 624     {
 625       REAL_VALUE_TYPE r;
 626       HOST_WIDE_INT i[2];
 627       HOST_WIDE_INT low, high;
 628
 629       if (GET_CODE (x) == CONST_INT)
 630         low = INTVAL (x), high = low >> (HOST_BITS_PER_WIDE_INT -1);
 631       else
 632         low = CONST_DOUBLE_LOW (x), high = CONST_DOUBLE_HIGH (x);
 633
 634 /* TARGET_DOUBLE takes the addressing order of the target machine. */
 635 #ifdef WORDS_BIG_ENDIAN
 636       i[0] = high, i[1] = low;
 637 #else
 638       i[0] = low, i[1] = high;
 639 #endif
 640
 641       r = REAL_VALUE_FROM_TARGET_DOUBLE (i);
 642       return immed_real_const_1 (r, mode);
 643     }
 644 #else
 645     {
 646       union {HOST_WIDE_INT i[2]; double d; } u;
 647       HOST_WIDE_INT low, high;
 648
 649       if (GET_CODE (x) == CONST_INT)
 650         low = INTVAL (x), high = low >> (HOST_BITS_PER_WIDE_INT -1);
 651       else
 652         low = CONST_DOUBLE_LOW (x), high = CONST_DOUBLE_HIGH (x);
 653
 654 #ifdef HOST_WORDS_BIG_ENDIAN
 655       u.i[0] = high, u.i[1] = low;
 656 #else
 657       u.i[0] = low, u.i[1] = high;
 658 #endif
 659
 660       return immed_real_const_1 (u.d, mode);
 661     }
 662 #endif
 663   /* Similarly, if this is converting a floating-point value into a
 664      single-word integer.  Only do this is the host and target parameters are
 665      compatible.  */
 666
 667   else if (((HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT
 668              && HOST_BITS_PER_WIDE_INT == BITS_PER_WORD)
 669             || flag_pretend_float)
 670            && (GET_MODE_CLASS (mode) == MODE_INT
 671                || GET_MODE_CLASS (mode) == MODE_PARTIAL_INT)
 672            && GET_CODE (x) == CONST_DOUBLE
 673            && GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT
 674            && GET_MODE_BITSIZE (mode) == BITS_PER_WORD)
 675     return operand_subword (x, 0, 0, GET_MODE (x));
 676
 677   /* Similarly, if this is converting a floating-point value into a
 678      two-word integer, we can do this one word at a time and make an
 679      integer.  Only do this is the host and target parameters are
 680      compatible.  */
 681
 682   else if (((HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT
 683              && HOST_BITS_PER_WIDE_INT == BITS_PER_WORD)
 684             || flag_pretend_float)
 685            && (GET_MODE_CLASS (mode) == MODE_INT
 686                || GET_MODE_CLASS (mode) == MODE_PARTIAL_INT)
 687            && GET_CODE (x) == CONST_DOUBLE
 688            && GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT
 689            && GET_MODE_BITSIZE (mode) == 2 * BITS_PER_WORD)
 690     {
 691       rtx lowpart = operand_subword (x, WORDS_BIG_ENDIAN, 0, GET_MODE (x));
 692       rtx highpart = operand_subword (x, ! WORDS_BIG_ENDIAN, 0, GET_MODE (x));
 693
 694       if (lowpart && GET_CODE (lowpart) == CONST_INT
 695           && highpart && GET_CODE (highpart) == CONST_INT)
 696         return immed_double_const (INTVAL (lowpart), INTVAL (highpart), mode);
 697     }
 698
 699   /* Otherwise, we can't do this.  */
 700   return 0;
 701 }
 702 \f
 703 /* Return the real part (which has mode MODE) of a complex value X.
 704    This always comes at the low address in memory.  */
 705
 706 rtx
 707 gen_realpart (mode, x)
 708      enum machine_mode mode;
 709      register rtx x;
 710 {
 711   if (WORDS_BIG_ENDIAN)
 712     return gen_highpart (mode, x);
 713   else
 714     return gen_lowpart (mode, x);
 715 }
 716
 717 /* Return the imaginary part (which has mode MODE) of a complex value X.
 718    This always comes at the high address in memory.  */
 719
 720 rtx
 721 gen_imagpart (mode, x)
 722      enum machine_mode mode;
 723      register rtx x;
 724 {
 725   if (WORDS_BIG_ENDIAN)
 726     return gen_lowpart (mode, x);
 727   else
 728     return gen_highpart (mode, x);
 729 }
 730 \f
 731 /* Assuming that X is an rtx (e.g., MEM, REG or SUBREG) for a value,
 732    return an rtx (MEM, SUBREG, or CONST_INT) that refers to the
 733    least-significant part of X.
 734    MODE specifies how big a part of X to return;
 735    it usually should not be larger than a word.
 736    If X is a MEM whose address is a QUEUED, the value may be so also.  */
 737
 738 rtx
 739 gen_lowpart (mode, x)
 740      enum machine_mode mode;
 741      register rtx x;
 742 {
 743   rtx result = gen_lowpart_common (mode, x);
 744
 745   if (result)
 746     return result;
 747   else if (GET_CODE (x) == MEM)
 748     {
 749       /* The only additional case we can do is MEM.  */
 750       register int offset = 0;
 751       if (WORDS_BIG_ENDIAN)
 752         offset = (MAX (GET_MODE_SIZE (GET_MODE (x)), UNITS_PER_WORD)
 753                   - MAX (GET_MODE_SIZE (mode), UNITS_PER_WORD));
 754
 755       if (BYTES_BIG_ENDIAN)
 756         /* Adjust the address so that the address-after-the-data
 757            is unchanged.  */
 758         offset -= (MIN (UNITS_PER_WORD, GET_MODE_SIZE (mode))
 759                    - MIN (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (x))));
 760
 761       return change_address (x, mode, plus_constant (XEXP (x, 0), offset));
 762     }
 763   else
 764     abort ();
 765 }
 766
 767 /* Like `gen_lowpart', but refer to the most significant part.
 768    This is used to access the imaginary part of a complex number.  */
 769
 770 rtx
 771 gen_highpart (mode, x)
 772      enum machine_mode mode;
 773      register rtx x;
 774 {
 775   /* This case loses if X is a subreg.  To catch bugs early,
 776      complain if an invalid MODE is used even in other cases.  */
 777   if (GET_MODE_SIZE (mode) > UNITS_PER_WORD
 778       && GET_MODE_SIZE (mode) != GET_MODE_UNIT_SIZE (GET_MODE (x)))
 779     abort ();
 780   if (GET_CODE (x) == CONST_DOUBLE
 781 #if !(TARGET_FLOAT_FORMAT != HOST_FLOAT_FORMAT || defined (REAL_IS_NOT_DOUBLE))
 782       && GET_MODE_CLASS (GET_MODE (x)) != MODE_FLOAT
 783 #endif
 784       )
 785     return gen_rtx (CONST_INT, VOIDmode,
 786                     CONST_DOUBLE_HIGH (x) & GET_MODE_MASK (mode));
 787   else if (GET_CODE (x) == CONST_INT)
 788     return const0_rtx;
 789   else if (GET_CODE (x) == MEM)
 790     {
 791       register int offset = 0;
 792 #if !WORDS_BIG_ENDIAN
 793       offset = (MAX (GET_MODE_SIZE (GET_MODE (x)), UNITS_PER_WORD)
 794                 - MAX (GET_MODE_SIZE (mode), UNITS_PER_WORD));
 795 #endif
 796 #if !BYTES_BIG_ENDIAN
 797       if (GET_MODE_SIZE (mode) < UNITS_PER_WORD)
 798         offset -= (GET_MODE_SIZE (mode)
 799                    - MIN (UNITS_PER_WORD,
 800                           GET_MODE_SIZE (GET_MODE (x))));
 801 #endif
 802       return change_address (x, mode, plus_constant (XEXP (x, 0), offset));
 803     }
 804   else if (GET_CODE (x) == SUBREG)
 805     {
 806       /* The only time this should occur is when we are looking at a
 807          multi-word item with a SUBREG whose mode is the same as that of the
 808          item.  It isn't clear what we would do if it wasn't.  */
 809       if (SUBREG_WORD (x) != 0)
 810         abort ();
 811       return gen_highpart (mode, SUBREG_REG (x));
 812     }
 813   else if (GET_CODE (x) == REG)
 814     {
 815       int word = 0;
 816
 817 #if !WORDS_BIG_ENDIAN
 818       if (GET_MODE_SIZE (GET_MODE (x)) > UNITS_PER_WORD)
 819         word = ((GET_MODE_SIZE (GET_MODE (x))
 820                  - MAX (GET_MODE_SIZE (mode), UNITS_PER_WORD))
 821                 / UNITS_PER_WORD);
 822 #endif
 823       if (REGNO (x) < FIRST_PSEUDO_REGISTER
 824           /* We want to keep the stack, frame, and arg pointers special.  */
 825           && REGNO (x) != FRAME_POINTER_REGNUM
 826 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
 827           && REGNO (x) != ARG_POINTER_REGNUM
 828 #endif
 829           && REGNO (x) != STACK_POINTER_REGNUM)
 830         return gen_rtx (REG, mode, REGNO (x) + word);
 831       else
 832         return gen_rtx (SUBREG, mode, x, word);
 833     }
 834   else
 835     abort ();
 836 }
 837
 838 /* Return 1 iff X, assumed to be a SUBREG,
 839    refers to the least significant part of its containing reg.
 840    If X is not a SUBREG, always return 1 (it is its own low part!).  */
 841
 842 int
 843 subreg_lowpart_p (x)
 844      rtx x;
 845 {
 846   if (GET_CODE (x) != SUBREG)
 847     return 1;
 848
 849   if (WORDS_BIG_ENDIAN
 850       && GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))) > UNITS_PER_WORD)
 851     return (SUBREG_WORD (x)
 852             == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)))
 853                  - MAX (GET_MODE_SIZE (GET_MODE (x)), UNITS_PER_WORD))
 854                 / UNITS_PER_WORD));
 855
 856   return SUBREG_WORD (x) == 0;
 857 }
 858 \f
 859 /* Return subword I of operand OP.
 860    The word number, I, is interpreted as the word number starting at the
 861    low-order address.  Word 0 is the low-order word if not WORDS_BIG_ENDIAN,
 862    otherwise it is the high-order word.
 863
 864    If we cannot extract the required word, we return zero.  Otherwise, an
 865    rtx corresponding to the requested word will be returned.
 866
 867    VALIDATE_ADDRESS is nonzero if the address should be validated.  Before
 868    reload has completed, a valid address will always be returned.  After
 869    reload, if a valid address cannot be returned, we return zero.
 870
 871    If VALIDATE_ADDRESS is zero, we simply form the required address; validating
 872    it is the responsibility of the caller.
 873
 874    MODE is the mode of OP in case it is a CONST_INT.  */
 875
 876 rtx
 877 operand_subword (op, i, validate_address, mode)
 878      rtx op;
 879      int i;
 880      int validate_address;
 881      enum machine_mode mode;
 882 {
 883   HOST_WIDE_INT val;
 884   int size_ratio = HOST_BITS_PER_WIDE_INT / BITS_PER_WORD;
 885
 886   if (mode == VOIDmode)
 887     mode = GET_MODE (op);
 888
 889   if (mode == VOIDmode)
 890     abort ();
 891
 892   /* If OP is narrower than a word or if we want a word outside OP, fail.  */
 893   if (mode != BLKmode
 894       && (GET_MODE_SIZE (mode) < UNITS_PER_WORD
 895           || (i + 1) * UNITS_PER_WORD > GET_MODE_SIZE (mode)))
 896     return 0;
 897
 898   /* If OP is already an integer word, return it.  */
 899   if (GET_MODE_CLASS (mode) == MODE_INT
 900       && GET_MODE_SIZE (mode) == UNITS_PER_WORD)
 901     return op;
 902
 903   /* If OP is a REG or SUBREG, we can handle it very simply.  */
 904   if (GET_CODE (op) == REG)
 905     {
 906       /* If the register is not valid for MODE, return 0.  If we don't
 907          do this, there is no way to fix up the resulting REG later.  */
 908       if (REGNO (op) < FIRST_PSEUDO_REGISTER
 909           && ! HARD_REGNO_MODE_OK (REGNO (op) + i, word_mode))
 910         return 0;
 911       else if (REGNO (op) >= FIRST_PSEUDO_REGISTER
 912                || (REG_FUNCTION_VALUE_P (op)
 913                    && rtx_equal_function_value_matters)
 914                /* We want to keep the stack, frame, and arg pointers
 915                   special.  */
 916                || REGNO (op) == FRAME_POINTER_REGNUM
 917 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
 918                || REGNO (op) == ARG_POINTER_REGNUM
 919 #endif
 920                || REGNO (op) == STACK_POINTER_REGNUM)
 921         return gen_rtx (SUBREG, word_mode, op, i);
 922       else
 923         return gen_rtx (REG, word_mode, REGNO (op) + i);
 924     }
 925   else if (GET_CODE (op) == SUBREG)
 926     return gen_rtx (SUBREG, word_mode, SUBREG_REG (op), i + SUBREG_WORD (op));
 927
 928   /* Form a new MEM at the requested address.  */
 929   if (GET_CODE (op) == MEM)
 930     {
 931       rtx addr = plus_constant (XEXP (op, 0), i * UNITS_PER_WORD);
 932       rtx new;
 933
 934       if (validate_address)
 935         {
 936           if (reload_completed)
 937             {
 938               if (! strict_memory_address_p (word_mode, addr))
 939                 return 0;
 940             }
 941           else
 942             addr = memory_address (word_mode, addr);
 943         }
 944
 945       new = gen_rtx (MEM, word_mode, addr);
 946
 947       MEM_VOLATILE_P (new) = MEM_VOLATILE_P (op);
 948       MEM_IN_STRUCT_P (new) = MEM_IN_STRUCT_P (op);
 949       RTX_UNCHANGING_P (new) = RTX_UNCHANGING_P (op);
 950
 951       return new;
 952     }
 953
 954   /* The only remaining cases are when OP is a constant.  If the host and
 955      target floating formats are the same, handling two-word floating
 956      constants are easy.  Note that REAL_VALUE_TO_TARGET_{SINGLE,DOUBLE}
 957      are defined as returning 32 bit and 64-bit values, respectively,
 958      and not values of BITS_PER_WORD and 2 * BITS_PER_WORD bits.  */
 959 #ifdef REAL_ARITHMETIC
 960   if ((HOST_BITS_PER_WIDE_INT == BITS_PER_WORD)
 961       && GET_MODE_CLASS (mode) == MODE_FLOAT
 962       && GET_MODE_BITSIZE (mode) == 64
 963       && GET_CODE (op) == CONST_DOUBLE)
 964     {
 965       HOST_WIDE_INT k[2];
 966       REAL_VALUE_TYPE rv;
 967
 968       REAL_VALUE_FROM_CONST_DOUBLE (rv, op);
 969       REAL_VALUE_TO_TARGET_DOUBLE (rv, k);
 970
 971       /* We handle 32-bit and 64-bit host words here.  Note that the order in
 972          which the words are written depends on the word endianness.
 973
 974          ??? This is a potential portability problem and should
 975          be fixed at some point.  */
 976       if (HOST_BITS_PER_WIDE_INT == 32)
 977         return GEN_INT (k[i]);
 978       else if (HOST_BITS_PER_WIDE_INT == 64 && i == 0)
 979         return GEN_INT ((k[! WORDS_BIG_ENDIAN] << (HOST_BITS_PER_WIDE_INT / 2))
 980                         | k[WORDS_BIG_ENDIAN]);
 981       else
 982         abort ();
 983     }
 984 #else /* no REAL_ARITHMETIC */
 985   if (((HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT
 986         && HOST_BITS_PER_WIDE_INT == BITS_PER_WORD)
 987        || flag_pretend_float)
 988       && GET_MODE_CLASS (mode) == MODE_FLOAT
 989       && GET_MODE_SIZE (mode) == 2 * UNITS_PER_WORD
 990       && GET_CODE (op) == CONST_DOUBLE)
 991     {
 992       /* The constant is stored in the host's word-ordering,
 993          but we want to access it in the target's word-ordering.  Some
 994          compilers don't like a conditional inside macro args, so we have two
 995          copies of the return.  */
 996 #ifdef HOST_WORDS_BIG_ENDIAN
 997       return GEN_INT (i == WORDS_BIG_ENDIAN
 998                       ? CONST_DOUBLE_HIGH (op) : CONST_DOUBLE_LOW (op));
 999 #else
1000       return GEN_INT (i != WORDS_BIG_ENDIAN
1001                       ? CONST_DOUBLE_HIGH (op) : CONST_DOUBLE_LOW (op));
1002 #endif
1003     }
1004 #endif /* no REAL_ARITHMETIC */
1005
1006   /* Single word float is a little harder, since single- and double-word
1007      values often do not have the same high-order bits.  We have already
1008      verified that we want the only defined word of the single-word value.  */
1009 #ifdef REAL_ARITHMETIC
1010   if ((HOST_BITS_PER_WIDE_INT == BITS_PER_WORD)
1011       && GET_MODE_CLASS (mode) == MODE_FLOAT
1012       && GET_MODE_BITSIZE (mode) == 32
1013       && GET_CODE (op) == CONST_DOUBLE)
1014     {
1015       HOST_WIDE_INT l;
1016       REAL_VALUE_TYPE rv;
1017
1018       REAL_VALUE_FROM_CONST_DOUBLE (rv, op);
1019       REAL_VALUE_TO_TARGET_SINGLE (rv, l);
1020       return GEN_INT (l);
1021     }
1022 #else
1023   if (((HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT
1024         && HOST_BITS_PER_WIDE_INT == BITS_PER_WORD)
1025        || flag_pretend_float)
1026       && GET_MODE_CLASS (mode) == MODE_FLOAT
1027       && GET_MODE_SIZE (mode) == UNITS_PER_WORD
1028       && GET_CODE (op) == CONST_DOUBLE)
1029     {
1030       double d;
1031       union {float f; HOST_WIDE_INT i; } u;
1032
1033       REAL_VALUE_FROM_CONST_DOUBLE (d, op);
1034
1035       u.f = d;
1036       return GEN_INT (u.i);
1037     }
1038 #endif /* no REAL_ARITHMETIC */
1039
1040   /* The only remaining cases that we can handle are integers.
1041      Convert to proper endianness now since these cases need it.
1042      At this point, i == 0 means the low-order word.
1043
1044      We do not want to handle the case when BITS_PER_WORD <= HOST_BITS_PER_INT
1045      in general.  However, if OP is (const_int 0), we can just return
1046      it for any word.  */
1047
1048   if (op == const0_rtx)
1049     return op;
1050
1051   if (GET_MODE_CLASS (mode) != MODE_INT
1052       || (GET_CODE (op) != CONST_INT && GET_CODE (op) != CONST_DOUBLE)
1053       || BITS_PER_WORD > HOST_BITS_PER_INT)
1054     return 0;
1055
1056   if (WORDS_BIG_ENDIAN)
1057     i = GET_MODE_SIZE (mode) / UNITS_PER_WORD - 1 - i;
1058
1059   /* Find out which word on the host machine this value is in and get
1060      it from the constant.  */
1061   val = (i / size_ratio == 0
1062          ? (GET_CODE (op) == CONST_INT ? INTVAL (op) : CONST_DOUBLE_LOW (op))
1063          : (GET_CODE (op) == CONST_INT
1064             ? (INTVAL (op) < 0 ? ~0 : 0) : CONST_DOUBLE_HIGH (op)));
1065
1066   /* If BITS_PER_WORD is smaller than an int, get the appropriate bits.  */
1067   if (BITS_PER_WORD < HOST_BITS_PER_WIDE_INT)
1068     val = ((val >> ((i % size_ratio) * BITS_PER_WORD))
1069            & (((HOST_WIDE_INT) 1
1070                << (BITS_PER_WORD % HOST_BITS_PER_WIDE_INT)) - 1));
1071
1072   return GEN_INT (val);
1073 }
1074
1075 /* Similar to `operand_subword', but never return 0.  If we can't extract
1076    the required subword, put OP into a register and try again.  If that fails,
1077    abort.  We always validate the address in this case.  It is not valid
1078    to call this function after reload; it is mostly meant for RTL
1079    generation.
1080
1081    MODE is the mode of OP, in case it is CONST_INT.  */
1082
1083 rtx
1084 operand_subword_force (op, i, mode)
1085      rtx op;
1086      int i;
1087      enum machine_mode mode;
1088 {
1089   rtx result = operand_subword (op, i, 1, mode);
1090
1091   if (result)
1092     return result;
1093
1094   if (mode != BLKmode && mode != VOIDmode)
1095     op = force_reg (mode, op);
1096
1097   result = operand_subword (op, i, 1, mode);
1098   if (result == 0)
1099     abort ();
1100
1101   return result;
1102 }
1103 \f
1104 /* Given a compare instruction, swap the operands.
1105    A test instruction is changed into a compare of 0 against the operand.  */
1106
1107 void
1108 reverse_comparison (insn)
1109      rtx insn;
1110 {
1111   rtx body = PATTERN (insn);
1112   rtx comp;
1113
1114   if (GET_CODE (body) == SET)
1115     comp = SET_SRC (body);
1116   else
1117     comp = SET_SRC (XVECEXP (body, 0, 0));
1118
1119   if (GET_CODE (comp) == COMPARE)
1120     {
1121       rtx op0 = XEXP (comp, 0);
1122       rtx op1 = XEXP (comp, 1);
1123       XEXP (comp, 0) = op1;
1124       XEXP (comp, 1) = op0;
1125     }
1126   else
1127     {
1128       rtx new = gen_rtx (COMPARE, VOIDmode,
1129                          CONST0_RTX (GET_MODE (comp)), comp);
1130       if (GET_CODE (body) == SET)
1131         SET_SRC (body) = new;
1132       else
1133         SET_SRC (XVECEXP (body, 0, 0)) = new;
1134     }
1135 }
1136 \f
1137 /* Return a memory reference like MEMREF, but with its mode changed
1138    to MODE and its address changed to ADDR.
1139    (VOIDmode means don't change the mode.
1140    NULL for ADDR means don't change the address.)  */
1141
1142 rtx
1143 change_address (memref, mode, addr)
1144      rtx memref;
1145      enum machine_mode mode;
1146      rtx addr;
1147 {
1148   rtx new;
1149
1150   if (GET_CODE (memref) != MEM)
1151     abort ();
1152   if (mode == VOIDmode)
1153     mode = GET_MODE (memref);
1154   if (addr == 0)
1155     addr = XEXP (memref, 0);
1156
1157   /* If reload is in progress or has completed, ADDR must be valid.
1158      Otherwise, we can call memory_address to make it valid.  */
1159   if (reload_completed || reload_in_progress)
1160     {
1161       if (! memory_address_p (mode, addr))
1162         abort ();
1163     }
1164   else
1165     addr = memory_address (mode, addr);
1166
1167   new = gen_rtx (MEM, mode, addr);
1168   MEM_VOLATILE_P (new) = MEM_VOLATILE_P (memref);
1169   RTX_UNCHANGING_P (new) = RTX_UNCHANGING_P (memref);
1170   MEM_IN_STRUCT_P (new) = MEM_IN_STRUCT_P (memref);
1171   return new;
1172 }
1173 \f
1174 /* Return a newly created CODE_LABEL rtx with a unique label number.  */
1175
1176 rtx
1177 gen_label_rtx ()
1178 {
1179   register rtx label = gen_rtx (CODE_LABEL, VOIDmode, 0, 0, 0,
1180                                 label_num++, NULL_PTR);
1181   LABEL_NUSES (label) = 0;
1182   return label;
1183 }
1184 \f
1185 /* For procedure integration.  */
1186
1187 /* Return a newly created INLINE_HEADER rtx.  Should allocate this
1188    from a permanent obstack when the opportunity arises.  */
1189
1190 rtx
1191 gen_inline_header_rtx (first_insn, first_parm_insn, first_labelno,
1192                        last_labelno, max_parm_regnum, max_regnum, args_size,
1193                        pops_args, stack_slots, function_flags,
1194                        outgoing_args_size, original_arg_vector,
1195                        original_decl_initial)
1196      rtx first_insn, first_parm_insn;
1197      int first_labelno, last_labelno, max_parm_regnum, max_regnum, args_size;
1198      int pops_args;
1199      rtx stack_slots;
1200      int function_flags;
1201      int outgoing_args_size;
1202      rtvec original_arg_vector;
1203      rtx original_decl_initial;
1204 {
1205   rtx header = gen_rtx (INLINE_HEADER, VOIDmode,
1206                         cur_insn_uid++, NULL_RTX,
1207                         first_insn, first_parm_insn,
1208                         first_labelno, last_labelno,
1209                         max_parm_regnum, max_regnum, args_size, pops_args,
1210                         stack_slots, function_flags, outgoing_args_size,
1211                         original_arg_vector, original_decl_initial);
1212   return header;
1213 }
1214
1215 /* Install new pointers to the first and last insns in the chain.
1216    Used for an inline-procedure after copying the insn chain.  */
1217
1218 void
1219 set_new_first_and_last_insn (first, last)
1220      rtx first, last;
1221 {
1222   first_insn = first;
1223   last_insn = last;
1224 }
1225
1226 /* Set the range of label numbers found in the current function.
1227    This is used when belatedly compiling an inline function.  */
1228
1229 void
1230 set_new_first_and_last_label_num (first, last)
1231      int first, last;
1232 {
1233   base_label_num = label_num;
1234   first_label_num = first;
1235   last_label_num = last;
1236 }
1237 \f
1238 /* Save all variables describing the current status into the structure *P.
1239    This is used before starting a nested function.  */
1240
1241 void
1242 save_emit_status (p)
1243      struct function *p;
1244 {
1245   p->reg_rtx_no = reg_rtx_no;
1246   p->first_label_num = first_label_num;
1247   p->first_insn = first_insn;
1248   p->last_insn = last_insn;
1249   p->sequence_stack = sequence_stack;
1250   p->cur_insn_uid = cur_insn_uid;
1251   p->last_linenum = last_linenum;
1252   p->last_filename = last_filename;
1253   p->regno_pointer_flag = regno_pointer_flag;
1254   p->regno_pointer_flag_length = regno_pointer_flag_length;
1255   p->regno_reg_rtx = regno_reg_rtx;
1256 }
1257
1258 /* Restore all variables describing the current status from the structure *P.
1259    This is used after a nested function.  */
1260
1261 void
1262 restore_emit_status (p)
1263      struct function *p;
1264 {
1265   int i;
1266
1267   reg_rtx_no = p->reg_rtx_no;
1268   first_label_num = p->first_label_num;
1269   last_label_num = 0;
1270   first_insn = p->first_insn;
1271   last_insn = p->last_insn;
1272   sequence_stack = p->sequence_stack;
1273   cur_insn_uid = p->cur_insn_uid;
1274   last_linenum = p->last_linenum;
1275   last_filename = p->last_filename;
1276   regno_pointer_flag = p->regno_pointer_flag;
1277   regno_pointer_flag_length = p->regno_pointer_flag_length;
1278   regno_reg_rtx = p->regno_reg_rtx;
1279
1280   /* Clear our cache of rtx expressions for start_sequence and gen_sequence. */
1281   sequence_element_free_list = 0;
1282   for (i = 0; i < SEQUENCE_RESULT_SIZE; i++)
1283     sequence_result[i] = 0;
1284 }
1285 \f
1286 /* Go through all the RTL insn bodies and copy any invalid shared structure.
1287    It does not work to do this twice, because the mark bits set here
1288    are not cleared afterwards.  */
1289
1290 void
1291 unshare_all_rtl (insn)
1292      register rtx insn;
1293 {
1294   for (; insn; insn = NEXT_INSN (insn))
1295     if (GET_CODE (insn) == INSN || GET_CODE (insn) == JUMP_INSN
1296         || GET_CODE (insn) == CALL_INSN)
1297       {
1298         PATTERN (insn) = copy_rtx_if_shared (PATTERN (insn));
1299         REG_NOTES (insn) = copy_rtx_if_shared (REG_NOTES (insn));
1300         LOG_LINKS (insn) = copy_rtx_if_shared (LOG_LINKS (insn));
1301       }
1302
1303   /* Make sure the addresses of stack slots found outside the insn chain
1304      (such as, in DECL_RTL of a variable) are not shared
1305      with the insn chain.
1306
1307      This special care is necessary when the stack slot MEM does not
1308      actually appear in the insn chain.  If it does appear, its address
1309      is unshared from all else at that point.  */
1310
1311   copy_rtx_if_shared (stack_slot_list);
1312 }
1313
1314 /* Mark ORIG as in use, and return a copy of it if it was already in use.
1315    Recursively does the same for subexpressions.  */
1316
1317 rtx
1318 copy_rtx_if_shared (orig)
1319      rtx orig;
1320 {
1321   register rtx x = orig;
1322   register int i;
1323   register enum rtx_code code;
1324   register char *format_ptr;
1325   int copied = 0;
1326
1327   if (x == 0)
1328     return 0;
1329
1330   code = GET_CODE (x);
1331
1332   /* These types may be freely shared.  */
1333
1334   switch (code)
1335     {
1336     case REG:
1337     case QUEUED:
1338     case CONST_INT:
1339     case CONST_DOUBLE:
1340     case SYMBOL_REF:
1341     case CODE_LABEL:
1342     case PC:
1343     case CC0:
1344     case SCRATCH:
1345       /* SCRATCH must be shared because they represent distinct values. */
1346       return x;
1347
1348     case CONST:
1349       /* CONST can be shared if it contains a SYMBOL_REF.  If it contains
1350          a LABEL_REF, it isn't sharable.  */
1351       if (GET_CODE (XEXP (x, 0)) == PLUS
1352           && GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF
1353           && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT)
1354         return x;
1355       break;
1356
1357     case INSN:
1358     case JUMP_INSN:
1359     case CALL_INSN:
1360     case NOTE:
1361     case LABEL_REF:
1362     case BARRIER:
1363       /* The chain of insns is not being copied.  */
1364       return x;
1365
1366     case MEM:
1367       /* A MEM is allowed to be shared if its address is constant
1368          or is a constant plus one of the special registers.  */
1369       if (CONSTANT_ADDRESS_P (XEXP (x, 0))
1370           || XEXP (x, 0) == virtual_stack_vars_rtx
1371           || XEXP (x, 0) == virtual_incoming_args_rtx)
1372         return x;
1373
1374       if (GET_CODE (XEXP (x, 0)) == PLUS
1375           && (XEXP (XEXP (x, 0), 0) == virtual_stack_vars_rtx
1376               || XEXP (XEXP (x, 0), 0) == virtual_incoming_args_rtx)
1377           && CONSTANT_ADDRESS_P (XEXP (XEXP (x, 0), 1)))
1378         {
1379           /* This MEM can appear in more than one place,
1380              but its address better not be shared with anything else.  */
1381           if (! x->used)
1382             XEXP (x, 0) = copy_rtx_if_shared (XEXP (x, 0));
1383           x->used = 1;
1384           return x;
1385         }
1386     }
1387
1388   /* This rtx may not be shared.  If it has already been seen,
1389      replace it with a copy of itself.  */
1390
1391   if (x->used)
1392     {
1393       register rtx copy;
1394
1395       copy = rtx_alloc (code);
1396       bcopy (x, copy, (sizeof (*copy) - sizeof (copy->fld)
1397                        + sizeof (copy->fld[0]) * GET_RTX_LENGTH (code)));
1398       x = copy;
1399       copied = 1;
1400     }
1401   x->used = 1;
1402
1403   /* Now scan the subexpressions recursively.
1404      We can store any replaced subexpressions directly into X
1405      since we know X is not shared!  Any vectors in X
1406      must be copied if X was copied.  */
1407
1408   format_ptr = GET_RTX_FORMAT (code);
1409
1410   for (i = 0; i < GET_RTX_LENGTH (code); i++)
1411     {
1412       switch (*format_ptr++)
1413         {
1414         case 'e':
1415           XEXP (x, i) = copy_rtx_if_shared (XEXP (x, i));
1416           break;
1417
1418         case 'E':
1419           if (XVEC (x, i) != NULL)
1420             {
1421               register int j;
1422               int len = XVECLEN (x, i);
1423
1424               if (copied && len > 0)
1425                 XVEC (x, i) = gen_rtvec_v (len, &XVECEXP (x, i, 0));
1426               for (j = 0; j < len; j++)
1427                 XVECEXP (x, i, j) = copy_rtx_if_shared (XVECEXP (x, i, j));
1428             }
1429           break;
1430         }
1431     }
1432   return x;
1433 }
1434
1435 /* Clear all the USED bits in X to allow copy_rtx_if_shared to be used
1436    to look for shared sub-parts.  */
1437
1438 void
1439 reset_used_flags (x)
1440      rtx x;
1441 {
1442   register int i, j;
1443   register enum rtx_code code;
1444   register char *format_ptr;
1445   int copied = 0;
1446
1447   if (x == 0)
1448     return;
1449
1450   code = GET_CODE (x);
1451
1452   /* These types may be freely shared so we needn't do any reseting
1453      for them.  */
1454
1455   switch (code)
1456     {
1457     case REG:
1458     case QUEUED:
1459     case CONST_INT:
1460     case CONST_DOUBLE:
1461     case SYMBOL_REF:
1462     case CODE_LABEL:
1463     case PC:
1464     case CC0:
1465       return;
1466
1467     case INSN:
1468     case JUMP_INSN:
1469     case CALL_INSN:
1470     case NOTE:
1471     case LABEL_REF:
1472     case BARRIER:
1473       /* The chain of insns is not being copied.  */
1474       return;
1475     }
1476
1477   x->used = 0;
1478
1479   format_ptr = GET_RTX_FORMAT (code);
1480   for (i = 0; i < GET_RTX_LENGTH (code); i++)
1481     {
1482       switch (*format_ptr++)
1483         {
1484         case 'e':
1485           reset_used_flags (XEXP (x, i));
1486           break;
1487
1488         case 'E':
1489           for (j = 0; j < XVECLEN (x, i); j++)
1490             reset_used_flags (XVECEXP (x, i, j));
1491           break;
1492         }
1493     }
1494 }
1495 \f
1496 /* Copy X if necessary so that it won't be altered by changes in OTHER.
1497    Return X or the rtx for the pseudo reg the value of X was copied into.
1498    OTHER must be valid as a SET_DEST.  */
1499
1500 rtx
1501 make_safe_from (x, other)
1502      rtx x, other;
1503 {
1504   while (1)
1505     switch (GET_CODE (other))
1506       {
1507       case SUBREG:
1508         other = SUBREG_REG (other);
1509         break;
1510       case STRICT_LOW_PART:
1511       case SIGN_EXTEND:
1512       case ZERO_EXTEND:
1513         other = XEXP (other, 0);
1514         break;
1515       default:
1516         goto done;
1517       }
1518  done:
1519   if ((GET_CODE (other) == MEM
1520        && ! CONSTANT_P (x)
1521        && GET_CODE (x) != REG
1522        && GET_CODE (x) != SUBREG)
1523       || (GET_CODE (other) == REG
1524           && (REGNO (other) < FIRST_PSEUDO_REGISTER
1525               || reg_mentioned_p (other, x))))
1526     {
1527       rtx temp = gen_reg_rtx (GET_MODE (x));
1528       emit_move_insn (temp, x);
1529       return temp;
1530     }
1531   return x;
1532 }
1533 \f
1534 /* Emission of insns (adding them to the doubly-linked list).  */
1535
1536 /* Return the first insn of the current sequence or current function.  */
1537
1538 rtx
1539 get_insns ()
1540 {
1541   return first_insn;
1542 }
1543
1544 /* Return the last insn emitted in current sequence or current function.  */
1545
1546 rtx
1547 get_last_insn ()
1548 {
1549   return last_insn;
1550 }
1551
1552 /* Specify a new insn as the last in the chain.  */
1553
1554 void
1555 set_last_insn (insn)
1556      rtx insn;
1557 {
1558   if (NEXT_INSN (insn) != 0)
1559     abort ();
1560   last_insn = insn;
1561 }
1562
1563 /* Return the last insn emitted, even if it is in a sequence now pushed.  */
1564
1565 rtx
1566 get_last_insn_anywhere ()
1567 {
1568   struct sequence_stack *stack;
1569   if (last_insn)
1570     return last_insn;
1571   for (stack = sequence_stack; stack; stack = stack->next)
1572     if (stack->last != 0)
1573       return stack->last;
1574   return 0;
1575 }
1576
1577 /* Return a number larger than any instruction's uid in this function.  */
1578
1579 int
1580 get_max_uid ()
1581 {
1582   return cur_insn_uid;
1583 }
1584 \f
1585 /* Return the next insn.  If it is a SEQUENCE, return the first insn
1586    of the sequence.  */
1587
1588 rtx
1589 next_insn (insn)
1590      rtx insn;
1591 {
1592   if (insn)
1593     {
1594       insn = NEXT_INSN (insn);
1595       if (insn && GET_CODE (insn) == INSN
1596           && GET_CODE (PATTERN (insn)) == SEQUENCE)
1597         insn = XVECEXP (PATTERN (insn), 0, 0);
1598     }
1599
1600   return insn;
1601 }
1602
1603 /* Return the previous insn.  If it is a SEQUENCE, return the last insn
1604    of the sequence.  */
1605
1606 rtx
1607 previous_insn (insn)
1608      rtx insn;
1609 {
1610   if (insn)
1611     {
1612       insn = PREV_INSN (insn);
1613       if (insn && GET_CODE (insn) == INSN
1614           && GET_CODE (PATTERN (insn)) == SEQUENCE)
1615         insn = XVECEXP (PATTERN (insn), 0, XVECLEN (PATTERN (insn), 0) - 1);
1616     }
1617
1618   return insn;
1619 }
1620
1621 /* Return the next insn after INSN that is not a NOTE.  This routine does not
1622    look inside SEQUENCEs.  */
1623
1624 rtx
1625 next_nonnote_insn (insn)
1626      rtx insn;
1627 {
1628   while (insn)
1629     {
1630       insn = NEXT_INSN (insn);
1631       if (insn == 0 || GET_CODE (insn) != NOTE)
1632         break;
1633     }
1634
1635   return insn;
1636 }
1637
1638 /* Return the previous insn before INSN that is not a NOTE.  This routine does
1639    not look inside SEQUENCEs.  */
1640
1641 rtx
1642 prev_nonnote_insn (insn)
1643      rtx insn;
1644 {
1645   while (insn)
1646     {
1647       insn = PREV_INSN (insn);
1648       if (insn == 0 || GET_CODE (insn) != NOTE)
1649         break;
1650     }
1651
1652   return insn;
1653 }
1654
1655 /* Return the next INSN, CALL_INSN or JUMP_INSN after INSN;
1656    or 0, if there is none.  This routine does not look inside
1657    SEQUENCEs. */
1658
1659 rtx
1660 next_real_insn (insn)
1661      rtx insn;
1662 {
1663   while (insn)
1664     {
1665       insn = NEXT_INSN (insn);
1666       if (insn == 0 || GET_CODE (insn) == INSN
1667           || GET_CODE (insn) == CALL_INSN || GET_CODE (insn) == JUMP_INSN)
1668         break;
1669     }
1670
1671   return insn;
1672 }
1673
1674 /* Return the last INSN, CALL_INSN or JUMP_INSN before INSN;
1675    or 0, if there is none.  This routine does not look inside
1676    SEQUENCEs.  */
1677
1678 rtx
1679 prev_real_insn (insn)
1680      rtx insn;
1681 {
1682   while (insn)
1683     {
1684       insn = PREV_INSN (insn);
1685       if (insn == 0 || GET_CODE (insn) == INSN || GET_CODE (insn) == CALL_INSN
1686           || GET_CODE (insn) == JUMP_INSN)
1687         break;
1688     }
1689
1690   return insn;
1691 }
1692
1693 /* Find the next insn after INSN that really does something.  This routine
1694    does not look inside SEQUENCEs.  Until reload has completed, this is the
1695    same as next_real_insn.  */
1696
1697 rtx
1698 next_active_insn (insn)
1699      rtx insn;
1700 {
1701   while (insn)
1702     {
1703       insn = NEXT_INSN (insn);
1704       if (insn == 0
1705           || GET_CODE (insn) == CALL_INSN || GET_CODE (insn) == JUMP_INSN
1706           || (GET_CODE (insn) == INSN
1707               && (! reload_completed
1708                   || (GET_CODE (PATTERN (insn)) != USE
1709                       && GET_CODE (PATTERN (insn)) != CLOBBER))))
1710         break;
1711     }
1712
1713   return insn;
1714 }
1715
1716 /* Find the last insn before INSN that really does something.  This routine
1717    does not look inside SEQUENCEs.  Until reload has completed, this is the
1718    same as prev_real_insn.  */
1719
1720 rtx
1721 prev_active_insn (insn)
1722      rtx insn;
1723 {
1724   while (insn)
1725     {
1726       insn = PREV_INSN (insn);
1727       if (insn == 0
1728           || GET_CODE (insn) == CALL_INSN || GET_CODE (insn) == JUMP_INSN
1729           || (GET_CODE (insn) == INSN
1730               && (! reload_completed
1731                   || (GET_CODE (PATTERN (insn)) != USE
1732                       && GET_CODE (PATTERN (insn)) != CLOBBER))))
1733         break;
1734     }
1735
1736   return insn;
1737 }
1738
1739 /* Return the next CODE_LABEL after the insn INSN, or 0 if there is none.  */
1740
1741 rtx
1742 next_label (insn)
1743      rtx insn;
1744 {
1745   while (insn)
1746     {
1747       insn = NEXT_INSN (insn);
1748       if (insn == 0 || GET_CODE (insn) == CODE_LABEL)
1749         break;
1750     }
1751
1752   return insn;
1753 }
1754
1755 /* Return the last CODE_LABEL before the insn INSN, or 0 if there is none.  */
1756
1757 rtx
1758 prev_label (insn)
1759      rtx insn;
1760 {
1761   while (insn)
1762     {
1763       insn = PREV_INSN (insn);
1764       if (insn == 0 || GET_CODE (insn) == CODE_LABEL)
1765         break;
1766     }
1767
1768   return insn;
1769 }
1770 \f
1771 #ifdef HAVE_cc0
1772 /* INSN uses CC0 and is being moved into a delay slot.  Set up REG_CC_SETTER
1773    and REG_CC_USER notes so we can find it.  */
1774
1775 void
1776 link_cc0_insns (insn)
1777      rtx insn;
1778 {
1779   rtx user = next_nonnote_insn (insn);
1780
1781   if (GET_CODE (user) == INSN && GET_CODE (PATTERN (user)) == SEQUENCE)
1782     user = XVECEXP (PATTERN (user), 0, 0);
1783
1784   REG_NOTES (user) = gen_rtx (INSN_LIST, REG_CC_SETTER, insn,
1785                               REG_NOTES (user));
1786   REG_NOTES (insn) = gen_rtx (INSN_LIST, REG_CC_USER, user, REG_NOTES (insn));
1787 }
1788
1789 /* Return the next insn that uses CC0 after INSN, which is assumed to
1790    set it.  This is the inverse of prev_cc0_setter (i.e., prev_cc0_setter
1791    applied to the result of this function should yield INSN).
1792
1793    Normally, this is simply the next insn.  However, if a REG_CC_USER note
1794    is present, it contains the insn that uses CC0.
1795
1796    Return 0 if we can't find the insn.  */
1797
1798 rtx
1799 next_cc0_user (insn)
1800      rtx insn;
1801 {
1802   rtx note = find_reg_note (insn, REG_CC_USER, NULL_RTX);
1803
1804   if (note)
1805     return XEXP (note, 0);
1806
1807   insn = next_nonnote_insn (insn);
1808   if (insn && GET_CODE (insn) == INSN && GET_CODE (PATTERN (insn)) == SEQUENCE)
1809     insn = XVECEXP (PATTERN (insn), 0, 0);
1810
1811   if (insn && GET_RTX_CLASS (GET_CODE (insn)) == 'i'
1812       && reg_mentioned_p (cc0_rtx, PATTERN (insn)))
1813     return insn;
1814
1815   return 0;
1816 }
1817
1818 /* Find the insn that set CC0 for INSN.  Unless INSN has a REG_CC_SETTER
1819    note, it is the previous insn.  */
1820
1821 rtx
1822 prev_cc0_setter (insn)
1823      rtx insn;
1824 {
1825   rtx note = find_reg_note (insn, REG_CC_SETTER, NULL_RTX);
1826   rtx link;
1827
1828   if (note)
1829     return XEXP (note, 0);
1830
1831   insn = prev_nonnote_insn (insn);
1832   if (! sets_cc0_p (PATTERN (insn)))
1833     abort ();
1834
1835   return insn;
1836 }
1837 #endif
1838 \f
1839 /* Try splitting insns that can be split for better scheduling.
1840    PAT is the pattern which might split.
1841    TRIAL is the insn providing PAT.
1842    BACKWARDS is non-zero if we are scanning insns from last to first.
1843
1844    If this routine succeeds in splitting, it returns the first or last
1845    replacement insn depending on the value of BACKWARDS.  Otherwise, it
1846    returns TRIAL.  If the insn to be returned can be split, it will be.  */
1847
1848 rtx
1849 try_split (pat, trial, backwards)
1850      rtx pat, trial;
1851      int backwards;
1852 {
1853   rtx before = PREV_INSN (trial);
1854   rtx after = NEXT_INSN (trial);
1855   rtx seq = split_insns (pat, trial);
1856   int has_barrier = 0;
1857   rtx tem;
1858
1859   /* If we are splitting a JUMP_INSN, it might be followed by a BARRIER.
1860      We may need to handle this specially.  */
1861   if (after && GET_CODE (after) == BARRIER)
1862     {
1863       has_barrier = 1;
1864       after = NEXT_INSN (after);
1865     }
1866
1867   if (seq)
1868     {
1869       /* SEQ can either be a SEQUENCE or the pattern of a single insn.
1870          The latter case will normally arise only when being done so that
1871          it, in turn, will be split (SFmode on the 29k is an example).  */
1872       if (GET_CODE (seq) == SEQUENCE)
1873         {
1874           /* If we are splitting a JUMP_INSN, look for the JUMP_INSN in
1875              SEQ and copy our JUMP_LABEL to it.  If JUMP_LABEL is non-zero,
1876              increment the usage count so we don't delete the label.  */
1877           int i;
1878
1879           if (GET_CODE (trial) == JUMP_INSN)
1880             for (i = XVECLEN (seq, 0) - 1; i >= 0; i--)
1881               if (GET_CODE (XVECEXP (seq, 0, i)) == JUMP_INSN)
1882                 {
1883                   JUMP_LABEL (XVECEXP (seq, 0, i)) = JUMP_LABEL (trial);
1884
1885                   if (JUMP_LABEL (trial))
1886                     LABEL_NUSES (JUMP_LABEL (trial))++;
1887                 }
1888
1889           tem = emit_insn_after (seq, before);
1890
1891           delete_insn (trial);
1892           if (has_barrier)
1893             emit_barrier_after (tem);
1894         }
1895       /* Avoid infinite loop if the result matches the original pattern.  */
1896       else if (rtx_equal_p (seq, pat))
1897         return trial;
1898       else
1899         {
1900           PATTERN (trial) = seq;
1901           INSN_CODE (trial) = -1;
1902         }
1903
1904       /* Set TEM to the insn we should return.  */
1905       tem = backwards ? prev_active_insn (after) : next_active_insn (before);
1906       return try_split (PATTERN (tem), tem, backwards);
1907     }
1908
1909   return trial;
1910 }
1911 \f
1912 /* Make and return an INSN rtx, initializing all its slots.
1913    Store PATTERN in the pattern slots.  */
1914
1915 rtx
1916 make_insn_raw (pattern)
1917      rtx pattern;
1918 {
1919   register rtx insn;
1920
1921   insn = rtx_alloc (INSN);
1922   INSN_UID (insn) = cur_insn_uid++;
1923
1924   PATTERN (insn) = pattern;
1925   INSN_CODE (insn) = -1;
1926   LOG_LINKS (insn) = NULL;
1927   REG_NOTES (insn) = NULL;
1928
1929   return insn;
1930 }
1931
1932 /* Like `make_insn' but make a JUMP_INSN instead of an insn.  */
1933
1934 static rtx
1935 make_jump_insn_raw (pattern)
1936      rtx pattern;
1937 {
1938   register rtx insn;
1939
1940   insn = rtx_alloc (JUMP_INSN);
1941   INSN_UID (insn) = cur_insn_uid++;
1942
1943   PATTERN (insn) = pattern;
1944   INSN_CODE (insn) = -1;
1945   LOG_LINKS (insn) = NULL;
1946   REG_NOTES (insn) = NULL;
1947   JUMP_LABEL (insn) = NULL;
1948
1949   return insn;
1950 }
1951 \f
1952 /* Add INSN to the end of the doubly-linked list.
1953    INSN may be an INSN, JUMP_INSN, CALL_INSN, CODE_LABEL, BARRIER or NOTE.  */
1954
1955 void
1956 add_insn (insn)
1957      register rtx insn;
1958 {
1959   PREV_INSN (insn) = last_insn;
1960   NEXT_INSN (insn) = 0;
1961
1962   if (NULL != last_insn)
1963     NEXT_INSN (last_insn) = insn;
1964
1965   if (NULL == first_insn)
1966     first_insn = insn;
1967
1968   last_insn = insn;
1969 }
1970
1971 /* Add INSN into the doubly-linked list after insn AFTER.  This should be the
1972    only function called to insert an insn once delay slots have been filled
1973    since only it knows how to update a SEQUENCE.  */
1974
1975 void
1976 add_insn_after (insn, after)
1977      rtx insn, after;
1978 {
1979   rtx next = NEXT_INSN (after);
1980
1981   NEXT_INSN (insn) = next;
1982   PREV_INSN (insn) = after;
1983
1984   if (next)
1985     {
1986       PREV_INSN (next) = insn;
1987       if (GET_CODE (next) == INSN && GET_CODE (PATTERN (next)) == SEQUENCE)
1988         PREV_INSN (XVECEXP (PATTERN (next), 0, 0)) = insn;
1989     }
1990   else if (last_insn == after)
1991     last_insn = insn;
1992   else
1993     {
1994       struct sequence_stack *stack = sequence_stack;
1995       /* Scan all pending sequences too.  */
1996       for (; stack; stack = stack->next)
1997         if (after == stack->last)
1998           stack->last = insn;
1999     }
2000
2001   NEXT_INSN (after) = insn;
2002   if (GET_CODE (after) == INSN && GET_CODE (PATTERN (after)) == SEQUENCE)
2003     {
2004       rtx sequence = PATTERN (after);
2005       NEXT_INSN (XVECEXP (sequence, 0, XVECLEN (sequence, 0) - 1)) = insn;
2006     }
2007 }
2008
2009 /* Delete all insns made since FROM.
2010    FROM becomes the new last instruction.  */
2011
2012 void
2013 delete_insns_since (from)
2014      rtx from;
2015 {
2016   if (from == 0)
2017     first_insn = 0;
2018   else
2019     NEXT_INSN (from) = 0;
2020   last_insn = from;
2021 }
2022
2023 /* Move a consecutive bunch of insns to a different place in the chain.
2024    The insns to be moved are those between FROM and TO.
2025    They are moved to a new position after the insn AFTER.
2026    AFTER must not be FROM or TO or any insn in between.
2027
2028    This function does not know about SEQUENCEs and hence should not be
2029    called after delay-slot filling has been done.  */
2030
2031 void
2032 reorder_insns (from, to, after)
2033      rtx from, to, after;
2034 {
2035   /* Splice this bunch out of where it is now.  */
2036   if (PREV_INSN (from))
2037     NEXT_INSN (PREV_INSN (from)) = NEXT_INSN (to);
2038   if (NEXT_INSN (to))
2039     PREV_INSN (NEXT_INSN (to)) = PREV_INSN (from);
2040   if (last_insn == to)
2041     last_insn = PREV_INSN (from);
2042   if (first_insn == from)
2043     first_insn = NEXT_INSN (to);
2044
2045   /* Make the new neighbors point to it and it to them.  */
2046   if (NEXT_INSN (after))
2047     PREV_INSN (NEXT_INSN (after)) = to;
2048
2049   NEXT_INSN (to) = NEXT_INSN (after);
2050   PREV_INSN (from) = after;
2051   NEXT_INSN (after) = from;
2052   if (after == last_insn)
2053     last_insn = to;
2054 }
2055
2056 /* Return the line note insn preceding INSN.  */
2057
2058 static rtx
2059 find_line_note (insn)
2060      rtx insn;
2061 {
2062   if (no_line_numbers)
2063     return 0;
2064
2065   for (; insn; insn = PREV_INSN (insn))
2066     if (GET_CODE (insn) == NOTE
2067         && NOTE_LINE_NUMBER (insn) >= 0)
2068       break;
2069
2070   return insn;
2071 }
2072
2073 /* Like reorder_insns, but inserts line notes to preserve the line numbers
2074    of the moved insns when debugging.  This may insert a note between AFTER
2075    and FROM, and another one after TO.  */
2076
2077 void
2078 reorder_insns_with_line_notes (from, to, after)
2079      rtx from, to, after;
2080 {
2081   rtx from_line = find_line_note (from);
2082   rtx after_line = find_line_note (after);
2083
2084   reorder_insns (from, to, after);
2085
2086   if (from_line == after_line)
2087     return;
2088
2089   if (from_line)
2090     emit_line_note_after (NOTE_SOURCE_FILE (from_line),
2091                           NOTE_LINE_NUMBER (from_line),
2092                           after);
2093   if (after_line)
2094     emit_line_note_after (NOTE_SOURCE_FILE (after_line),
2095                           NOTE_LINE_NUMBER (after_line),
2096                           to);
2097 }
2098 \f
2099 /* Emit an insn of given code and pattern
2100    at a specified place within the doubly-linked list.  */
2101
2102 /* Make an instruction with body PATTERN
2103    and output it before the instruction BEFORE.  */
2104
2105 rtx
2106 emit_insn_before (pattern, before)
2107      register rtx pattern, before;
2108 {
2109   register rtx insn = before;
2110
2111   if (GET_CODE (pattern) == SEQUENCE)
2112     {
2113       register int i;
2114
2115       for (i = 0; i < XVECLEN (pattern, 0); i++)
2116         {
2117           insn = XVECEXP (pattern, 0, i);
2118           add_insn_after (insn, PREV_INSN (before));
2119         }
2120       if (XVECLEN (pattern, 0) < SEQUENCE_RESULT_SIZE)
2121         sequence_result[XVECLEN (pattern, 0)] = pattern;
2122     }
2123   else
2124     {
2125       insn = make_insn_raw (pattern);
2126       add_insn_after (insn, PREV_INSN (before));
2127     }
2128
2129   return insn;
2130 }
2131
2132 /* Make an instruction with body PATTERN and code JUMP_INSN
2133    and output it before the instruction BEFORE.  */
2134
2135 rtx
2136 emit_jump_insn_before (pattern, before)
2137      register rtx pattern, before;
2138 {
2139   register rtx insn;
2140
2141   if (GET_CODE (pattern) == SEQUENCE)
2142     insn = emit_insn_before (pattern, before);
2143   else
2144     {
2145       insn = make_jump_insn_raw (pattern);
2146       add_insn_after (insn, PREV_INSN (before));
2147     }
2148
2149   return insn;
2150 }
2151
2152 /* Make an instruction with body PATTERN and code CALL_INSN
2153    and output it before the instruction BEFORE.  */
2154
2155 rtx
2156 emit_call_insn_before (pattern, before)
2157      register rtx pattern, before;
2158 {
2159   rtx insn = emit_insn_before (pattern, before);
2160   PUT_CODE (insn, CALL_INSN);
2161   return insn;
2162 }
2163
2164 /* Make an insn of code BARRIER
2165    and output it before the insn AFTER.  */
2166
2167 rtx
2168 emit_barrier_before (before)
2169      register rtx before;
2170 {
2171   register rtx insn = rtx_alloc (BARRIER);
2172
2173   INSN_UID (insn) = cur_insn_uid++;
2174
2175   add_insn_after (insn, PREV_INSN (before));
2176   return insn;
2177 }
2178
2179 /* Emit a note of subtype SUBTYPE before the insn BEFORE.  */
2180
2181 rtx
2182 emit_note_before (subtype, before)
2183      int subtype;
2184      rtx before;
2185 {
2186   register rtx note = rtx_alloc (NOTE);
2187   INSN_UID (note) = cur_insn_uid++;
2188   NOTE_SOURCE_FILE (note) = 0;
2189   NOTE_LINE_NUMBER (note) = subtype;
2190
2191   add_insn_after (note, PREV_INSN (before));
2192   return note;
2193 }
2194 \f
2195 /* Make an insn of code INSN with body PATTERN
2196    and output it after the insn AFTER.  */
2197
2198 rtx
2199 emit_insn_after (pattern, after)
2200      register rtx pattern, after;
2201 {
2202   register rtx insn = after;
2203
2204   if (GET_CODE (pattern) == SEQUENCE)
2205     {
2206       register int i;
2207
2208       for (i = 0; i < XVECLEN (pattern, 0); i++)
2209         {
2210           insn = XVECEXP (pattern, 0, i);
2211           add_insn_after (insn, after);
2212           after = insn;
2213         }
2214       if (XVECLEN (pattern, 0) < SEQUENCE_RESULT_SIZE)
2215         sequence_result[XVECLEN (pattern, 0)] = pattern;
2216     }
2217   else
2218     {
2219       insn = make_insn_raw (pattern);
2220       add_insn_after (insn, after);
2221     }
2222
2223   return insn;
2224 }
2225
2226 /* Similar to emit_insn_after, except that line notes are to be inserted so
2227    as to act as if this insn were at FROM.  */
2228
2229 void
2230 emit_insn_after_with_line_notes (pattern, after, from)
2231      rtx pattern, after, from;
2232 {
2233   rtx from_line = find_line_note (from);
2234   rtx after_line = find_line_note (after);
2235   rtx insn = emit_insn_after (pattern, after);
2236
2237   if (from_line)
2238     emit_line_note_after (NOTE_SOURCE_FILE (from_line),
2239                           NOTE_LINE_NUMBER (from_line),
2240                           after);
2241
2242   if (after_line)
2243     emit_line_note_after (NOTE_SOURCE_FILE (after_line),
2244                           NOTE_LINE_NUMBER (after_line),
2245                           insn);
2246 }
2247
2248 /* Make an insn of code JUMP_INSN with body PATTERN
2249    and output it after the insn AFTER.  */
2250
2251 rtx
2252 emit_jump_insn_after (pattern, after)
2253      register rtx pattern, after;
2254 {
2255   register rtx insn;
2256
2257   if (GET_CODE (pattern) == SEQUENCE)
2258     insn = emit_insn_after (pattern, after);
2259   else
2260     {
2261       insn = make_jump_insn_raw (pattern);
2262       add_insn_after (insn, after);
2263     }
2264
2265   return insn;
2266 }
2267
2268 /* Make an insn of code BARRIER
2269    and output it after the insn AFTER.  */
2270
2271 rtx
2272 emit_barrier_after (after)
2273      register rtx after;
2274 {
2275   register rtx insn = rtx_alloc (BARRIER);
2276
2277   INSN_UID (insn) = cur_insn_uid++;
2278
2279   add_insn_after (insn, after);
2280   return insn;
2281 }
2282
2283 /* Emit the label LABEL after the insn AFTER.  */
2284
2285 rtx
2286 emit_label_after (label, after)
2287      rtx label, after;
2288 {
2289   /* This can be called twice for the same label
2290      as a result of the confusion that follows a syntax error!
2291      So make it harmless.  */
2292   if (INSN_UID (label) == 0)
2293     {
2294       INSN_UID (label) = cur_insn_uid++;
2295       add_insn_after (label, after);
2296     }
2297
2298   return label;
2299 }
2300
2301 /* Emit a note of subtype SUBTYPE after the insn AFTER.  */
2302
2303 rtx
2304 emit_note_after (subtype, after)
2305      int subtype;
2306      rtx after;
2307 {
2308   register rtx note = rtx_alloc (NOTE);
2309   INSN_UID (note) = cur_insn_uid++;
2310   NOTE_SOURCE_FILE (note) = 0;
2311   NOTE_LINE_NUMBER (note) = subtype;
2312   add_insn_after (note, after);
2313   return note;
2314 }
2315
2316 /* Emit a line note for FILE and LINE after the insn AFTER.  */
2317
2318 rtx
2319 emit_line_note_after (file, line, after)
2320      char *file;
2321      int line;
2322      rtx after;
2323 {
2324   register rtx note;
2325
2326   if (no_line_numbers && line > 0)
2327     {
2328       cur_insn_uid++;
2329       return 0;
2330     }
2331
2332   note  = rtx_alloc (NOTE);
2333   INSN_UID (note) = cur_insn_uid++;
2334   NOTE_SOURCE_FILE (note) = file;
2335   NOTE_LINE_NUMBER (note) = line;
2336   add_insn_after (note, after);
2337   return note;
2338 }
2339 \f
2340 /* Make an insn of code INSN with pattern PATTERN
2341    and add it to the end of the doubly-linked list.
2342    If PATTERN is a SEQUENCE, take the elements of it
2343    and emit an insn for each element.
2344
2345    Returns the last insn emitted.  */
2346
2347 rtx
2348 emit_insn (pattern)
2349      rtx pattern;
2350 {
2351   rtx insn = last_insn;
2352
2353   if (GET_CODE (pattern) == SEQUENCE)
2354     {
2355       register int i;
2356
2357       for (i = 0; i < XVECLEN (pattern, 0); i++)
2358         {
2359           insn = XVECEXP (pattern, 0, i);
2360           add_insn (insn);
2361         }
2362       if (XVECLEN (pattern, 0) < SEQUENCE_RESULT_SIZE)
2363         sequence_result[XVECLEN (pattern, 0)] = pattern;
2364     }
2365   else
2366     {
2367       insn = make_insn_raw (pattern);
2368       add_insn (insn);
2369     }
2370
2371   return insn;
2372 }
2373
2374 /* Emit the insns in a chain starting with INSN.
2375    Return the last insn emitted.  */
2376
2377 rtx
2378 emit_insns (insn)
2379      rtx insn;
2380 {
2381   rtx last = 0;
2382
2383   while (insn)
2384     {
2385       rtx next = NEXT_INSN (insn);
2386       add_insn (insn);
2387       last = insn;
2388       insn = next;
2389     }
2390
2391   return last;
2392 }
2393
2394 /* Emit the insns in a chain starting with INSN and place them in front of
2395    the insn BEFORE.  Return the last insn emitted.  */
2396
2397 rtx
2398 emit_insns_before (insn, before)
2399      rtx insn;
2400      rtx before;
2401 {
2402   rtx last = 0;
2403
2404   while (insn)
2405     {
2406       rtx next = NEXT_INSN (insn);
2407       add_insn_after (insn, PREV_INSN (before));
2408       last = insn;
2409       insn = next;
2410     }
2411
2412   return last;
2413 }
2414
2415 /* Emit the insns in a chain starting with FIRST and place them in back of
2416    the insn AFTER.  Return the last insn emitted.  */
2417
2418 rtx
2419 emit_insns_after (first, after)
2420      register rtx first;
2421      register rtx after;
2422 {
2423   register rtx last;
2424   register rtx after_after;
2425
2426   if (!after)
2427     abort ();
2428
2429   if (!first)
2430     return first;
2431
2432   for (last = first; NEXT_INSN (last); last = NEXT_INSN (last))
2433     continue;
2434
2435   after_after = NEXT_INSN (after);
2436
2437   NEXT_INSN (after) = first;
2438   PREV_INSN (first) = after;
2439   NEXT_INSN (last) = after_after;
2440   if (after_after)
2441     PREV_INSN (after_after) = last;
2442
2443   if (after == last_insn)
2444     last_insn = last;
2445   return last;
2446 }
2447
2448 /* Make an insn of code JUMP_INSN with pattern PATTERN
2449    and add it to the end of the doubly-linked list.  */
2450
2451 rtx
2452 emit_jump_insn (pattern)
2453      rtx pattern;
2454 {
2455   if (GET_CODE (pattern) == SEQUENCE)
2456     return emit_insn (pattern);
2457   else
2458     {
2459       register rtx insn = make_jump_insn_raw (pattern);
2460       add_insn (insn);
2461       return insn;
2462     }
2463 }
2464
2465 /* Make an insn of code CALL_INSN with pattern PATTERN
2466    and add it to the end of the doubly-linked list.  */
2467
2468 rtx
2469 emit_call_insn (pattern)
2470      rtx pattern;
2471 {
2472   if (GET_CODE (pattern) == SEQUENCE)
2473     return emit_insn (pattern);
2474   else
2475     {
2476       register rtx insn = make_insn_raw (pattern);
2477       add_insn (insn);
2478       PUT_CODE (insn, CALL_INSN);
2479       return insn;
2480     }
2481 }
2482
2483 /* Add the label LABEL to the end of the doubly-linked list.  */
2484
2485 rtx
2486 emit_label (label)
2487      rtx label;
2488 {
2489   /* This can be called twice for the same label
2490      as a result of the confusion that follows a syntax error!
2491      So make it harmless.  */
2492   if (INSN_UID (label) == 0)
2493     {
2494       INSN_UID (label) = cur_insn_uid++;
2495       add_insn (label);
2496     }
2497   return label;
2498 }
2499
2500 /* Make an insn of code BARRIER
2501    and add it to the end of the doubly-linked list.  */
2502
2503 rtx
2504 emit_barrier ()
2505 {
2506   register rtx barrier = rtx_alloc (BARRIER);
2507   INSN_UID (barrier) = cur_insn_uid++;
2508   add_insn (barrier);
2509   return barrier;
2510 }
2511
2512 /* Make an insn of code NOTE
2513    with data-fields specified by FILE and LINE
2514    and add it to the end of the doubly-linked list,
2515    but only if line-numbers are desired for debugging info.  */
2516
2517 rtx
2518 emit_line_note (file, line)
2519      char *file;
2520      int line;
2521 {
2522   emit_filename = file;
2523   emit_lineno = line;
2524
2525 #if 0
2526   if (no_line_numbers)
2527     return 0;
2528 #endif
2529
2530   return emit_note (file, line);
2531 }
2532
2533 /* Make an insn of code NOTE
2534    with data-fields specified by FILE and LINE
2535    and add it to the end of the doubly-linked list.
2536    If it is a line-number NOTE, omit it if it matches the previous one.  */
2537
2538 rtx
2539 emit_note (file, line)
2540      char *file;
2541      int line;
2542 {
2543   register rtx note;
2544
2545   if (line > 0)
2546     {
2547       if (file && last_filename && !strcmp (file, last_filename)
2548           && line == last_linenum)
2549         return 0;
2550       last_filename = file;
2551       last_linenum = line;
2552     }
2553
2554   if (no_line_numbers && line > 0)
2555     {
2556       cur_insn_uid++;
2557       return 0;
2558     }
2559
2560   note = rtx_alloc (NOTE);
2561   INSN_UID (note) = cur_insn_uid++;
2562   NOTE_SOURCE_FILE (note) = file;
2563   NOTE_LINE_NUMBER (note) = line;
2564   add_insn (note);
2565   return note;
2566 }
2567
2568 /* Emit a NOTE, and don't omit it even if LINE it the previous note.  */
2569
2570 rtx
2571 emit_line_note_force (file, line)
2572      char *file;
2573      int line;
2574 {
2575   last_linenum = -1;
2576   return emit_line_note (file, line);
2577 }
2578
2579 /* Cause next statement to emit a line note even if the line number
2580    has not changed.  This is used at the beginning of a function.  */
2581
2582 void
2583 force_next_line_note ()
2584 {
2585   last_linenum = -1;
2586 }
2587 \f
2588 /* Return an indication of which type of insn should have X as a body.
2589    The value is CODE_LABEL, INSN, CALL_INSN or JUMP_INSN.  */
2590
2591 enum rtx_code
2592 classify_insn (x)
2593      rtx x;
2594 {
2595   if (GET_CODE (x) == CODE_LABEL)
2596     return CODE_LABEL;
2597   if (GET_CODE (x) == CALL)
2598     return CALL_INSN;
2599   if (GET_CODE (x) == RETURN)
2600     return JUMP_INSN;
2601   if (GET_CODE (x) == SET)
2602     {
2603       if (SET_DEST (x) == pc_rtx)
2604         return JUMP_INSN;
2605       else if (GET_CODE (SET_SRC (x)) == CALL)
2606         return CALL_INSN;
2607       else
2608         return INSN;
2609     }
2610   if (GET_CODE (x) == PARALLEL)
2611     {
2612       register int j;
2613       for (j = XVECLEN (x, 0) - 1; j >= 0; j--)
2614         if (GET_CODE (XVECEXP (x, 0, j)) == CALL)
2615           return CALL_INSN;
2616         else if (GET_CODE (XVECEXP (x, 0, j)) == SET
2617                  && SET_DEST (XVECEXP (x, 0, j)) == pc_rtx)
2618           return JUMP_INSN;
2619         else if (GET_CODE (XVECEXP (x, 0, j)) == SET
2620                  && GET_CODE (SET_SRC (XVECEXP (x, 0, j))) == CALL)
2621           return CALL_INSN;
2622     }
2623   return INSN;
2624 }
2625
2626 /* Emit the rtl pattern X as an appropriate kind of insn.
2627    If X is a label, it is simply added into the insn chain.  */
2628
2629 rtx
2630 emit (x)
2631      rtx x;
2632 {
2633   enum rtx_code code = classify_insn (x);
2634
2635   if (code == CODE_LABEL)
2636     return emit_label (x);
2637   else if (code == INSN)
2638     return emit_insn (x);
2639   else if (code == JUMP_INSN)
2640     {
2641       register rtx insn = emit_jump_insn (x);
2642       if (simplejump_p (insn) || GET_CODE (x) == RETURN)
2643         return emit_barrier ();
2644       return insn;
2645     }
2646   else if (code == CALL_INSN)
2647     return emit_call_insn (x);
2648   else
2649     abort ();
2650 }
2651 \f
2652 /* Begin emitting insns to a sequence which can be packaged in an RTL_EXPR.  */
2653
2654 void
2655 start_sequence ()
2656 {
2657   struct sequence_stack *tem;
2658
2659   if (sequence_element_free_list)
2660     {
2661       /* Reuse a previously-saved struct sequence_stack.  */
2662       tem = sequence_element_free_list;
2663       sequence_element_free_list = tem->next;
2664     }
2665   else
2666     tem = (struct sequence_stack *) permalloc (sizeof (struct sequence_stack));
2667
2668   tem->next = sequence_stack;
2669   tem->first = first_insn;
2670   tem->last = last_insn;
2671
2672   sequence_stack = tem;
2673
2674   first_insn = 0;
2675   last_insn = 0;
2676 }
2677
2678 /* Set up the insn chain starting with FIRST
2679    as the current sequence, saving the previously current one.  */
2680
2681 void
2682 push_to_sequence (first)
2683      rtx first;
2684 {
2685   rtx last;
2686
2687   start_sequence ();
2688
2689   for (last = first; last && NEXT_INSN (last); last = NEXT_INSN (last));
2690
2691   first_insn = first;
2692   last_insn = last;
2693 }
2694
2695 /* Set up the outer-level insn chain
2696    as the current sequence, saving the previously current one.  */
2697
2698 void
2699 push_topmost_sequence ()
2700 {
2701   struct sequence_stack *stack, *top;
2702
2703   start_sequence ();
2704
2705   for (stack = sequence_stack; stack; stack = stack->next)
2706     top = stack;
2707
2708   first_insn = top->first;
2709   last_insn = top->last;
2710 }
2711
2712 /* After emitting to the outer-level insn chain, update the outer-level
2713    insn chain, and restore the previous saved state.  */
2714
2715 void
2716 pop_topmost_sequence ()
2717 {
2718   struct sequence_stack *stack, *top;
2719
2720   for (stack = sequence_stack; stack; stack = stack->next)
2721     top = stack;
2722
2723   top->first = first_insn;
2724   top->last = last_insn;
2725
2726   end_sequence ();
2727 }
2728
2729 /* After emitting to a sequence, restore previous saved state.
2730
2731    To get the contents of the sequence just made,
2732    you must call `gen_sequence' *before* calling here.  */
2733
2734 void
2735 end_sequence ()
2736 {
2737   struct sequence_stack *tem = sequence_stack;
2738
2739   first_insn = tem->first;
2740   last_insn = tem->last;
2741   sequence_stack = tem->next;
2742
2743   tem->next = sequence_element_free_list;
2744   sequence_element_free_list = tem;
2745 }
2746
2747 /* Return 1 if currently emitting into a sequence.  */
2748
2749 int
2750 in_sequence_p ()
2751 {
2752   return sequence_stack != 0;
2753 }
2754
2755 /* Generate a SEQUENCE rtx containing the insns already emitted
2756    to the current sequence.
2757
2758    This is how the gen_... function from a DEFINE_EXPAND
2759    constructs the SEQUENCE that it returns.  */
2760
2761 rtx
2762 gen_sequence ()
2763 {
2764   rtx result;
2765   rtx tem;
2766   rtvec newvec;
2767   int i;
2768   int len;
2769
2770   /* Count the insns in the chain.  */
2771   len = 0;
2772   for (tem = first_insn; tem; tem = NEXT_INSN (tem))
2773     len++;
2774
2775   /* If only one insn, return its pattern rather than a SEQUENCE.
2776      (Now that we cache SEQUENCE expressions, it isn't worth special-casing
2777      the case of an empty list.)  */
2778   if (len == 1
2779       && (GET_CODE (first_insn) == INSN
2780           || GET_CODE (first_insn) == JUMP_INSN
2781           || GET_CODE (first_insn) == CALL_INSN))
2782     return PATTERN (first_insn);
2783
2784   /* Put them in a vector.  See if we already have a SEQUENCE of the
2785      appropriate length around.  */
2786   if (len < SEQUENCE_RESULT_SIZE && (result = sequence_result[len]) != 0)
2787     sequence_result[len] = 0;
2788   else
2789     {
2790       /* Ensure that this rtl goes in saveable_obstack, since we may be
2791          caching it.  */
2792       push_obstacks_nochange ();
2793       rtl_in_saveable_obstack ();
2794       result = gen_rtx (SEQUENCE, VOIDmode, rtvec_alloc (len));
2795       pop_obstacks ();
2796     }
2797
2798   for (i = 0, tem = first_insn; tem; tem = NEXT_INSN (tem), i++)
2799     XVECEXP (result, 0, i) = tem;
2800
2801   return result;
2802 }
2803 \f
2804 /* Set up regno_reg_rtx, reg_rtx_no and regno_pointer_flag
2805    according to the chain of insns starting with FIRST.
2806
2807    Also set cur_insn_uid to exceed the largest uid in that chain.
2808
2809    This is used when an inline function's rtl is saved
2810    and passed to rest_of_compilation later.  */
2811
2812 static void restore_reg_data_1 ();
2813
2814 void
2815 restore_reg_data (first)
2816      rtx first;
2817 {
2818   register rtx insn;
2819   int i;
2820   register int max_uid = 0;
2821
2822   for (insn = first; insn; insn = NEXT_INSN (insn))
2823     {
2824       if (INSN_UID (insn) >= max_uid)
2825         max_uid = INSN_UID (insn);
2826
2827       switch (GET_CODE (insn))
2828         {
2829         case NOTE:
2830         case CODE_LABEL:
2831         case BARRIER:
2832           break;
2833
2834         case JUMP_INSN:
2835         case CALL_INSN:
2836         case INSN:
2837           restore_reg_data_1 (PATTERN (insn));
2838           break;
2839         }
2840     }
2841
2842   /* Don't duplicate the uids already in use.  */
2843   cur_insn_uid = max_uid + 1;
2844
2845   /* If any regs are missing, make them up.
2846
2847      ??? word_mode is not necessarily the right mode.  Most likely these REGs
2848      are never used.  At some point this should be checked.  */
2849
2850   for (i = FIRST_PSEUDO_REGISTER; i < reg_rtx_no; i++)
2851     if (regno_reg_rtx[i] == 0)
2852       regno_reg_rtx[i] = gen_rtx (REG, word_mode, i);
2853 }
2854
2855 static void
2856 restore_reg_data_1 (orig)
2857      rtx orig;
2858 {
2859   register rtx x = orig;
2860   register int i;
2861   register enum rtx_code code;
2862   register char *format_ptr;
2863
2864   code = GET_CODE (x);
2865
2866   switch (code)
2867     {
2868     case QUEUED:
2869     case CONST_INT:
2870     case CONST_DOUBLE:
2871     case SYMBOL_REF:
2872     case CODE_LABEL:
2873     case PC:
2874     case CC0:
2875     case LABEL_REF:
2876       return;
2877
2878     case REG:
2879       if (REGNO (x) >= FIRST_PSEUDO_REGISTER)
2880         {
2881           /* Make sure regno_pointer_flag and regno_reg_rtx are large
2882              enough to have an element for this pseudo reg number.  */
2883           if (REGNO (x) >= reg_rtx_no)
2884             {
2885               reg_rtx_no = REGNO (x);
2886
2887               if (reg_rtx_no >= regno_pointer_flag_length)
2888                 {
2889                   int newlen = MAX (regno_pointer_flag_length * 2,
2890                                     reg_rtx_no + 30);
2891                   rtx *new1;
2892                   char *new = (char *) oballoc (newlen);
2893                   bzero (new, newlen);
2894                   bcopy (regno_pointer_flag, new, regno_pointer_flag_length);
2895
2896                   new1 = (rtx *) oballoc (newlen * sizeof (rtx));
2897                   bzero (new1, newlen * sizeof (rtx));
2898                   bcopy (regno_reg_rtx, new1, regno_pointer_flag_length * sizeof (rtx));
2899
2900                   regno_pointer_flag = new;
2901                   regno_reg_rtx = new1;
2902                   regno_pointer_flag_length = newlen;
2903                 }
2904               reg_rtx_no ++;
2905             }
2906           regno_reg_rtx[REGNO (x)] = x;
2907         }
2908       return;
2909
2910     case MEM:
2911       if (GET_CODE (XEXP (x, 0)) == REG)
2912         mark_reg_pointer (XEXP (x, 0));
2913       restore_reg_data_1 (XEXP (x, 0));
2914       return;
2915     }
2916
2917   /* Now scan the subexpressions recursively.  */
2918
2919   format_ptr = GET_RTX_FORMAT (code);
2920
2921   for (i = 0; i < GET_RTX_LENGTH (code); i++)
2922     {
2923       switch (*format_ptr++)
2924         {
2925         case 'e':
2926           restore_reg_data_1 (XEXP (x, i));
2927           break;
2928
2929         case 'E':
2930           if (XVEC (x, i) != NULL)
2931             {
2932               register int j;
2933
2934               for (j = 0; j < XVECLEN (x, i); j++)
2935                 restore_reg_data_1 (XVECEXP (x, i, j));
2936             }
2937           break;
2938         }
2939     }
2940 }
2941 \f
2942 /* Initialize data structures and variables in this file
2943    before generating rtl for each function.  */
2944
2945 void
2946 init_emit ()
2947 {
2948   int i;
2949
2950   first_insn = NULL;
2951   last_insn = NULL;
2952   cur_insn_uid = 1;
2953   reg_rtx_no = LAST_VIRTUAL_REGISTER + 1;
2954   last_linenum = 0;
2955   last_filename = 0;
2956   first_label_num = label_num;
2957   last_label_num = 0;
2958   sequence_stack = NULL;
2959
2960   /* Clear the start_sequence/gen_sequence cache.  */
2961   sequence_element_free_list = 0;
2962   for (i = 0; i < SEQUENCE_RESULT_SIZE; i++)
2963     sequence_result[i] = 0;
2964
2965   /* Init the tables that describe all the pseudo regs.  */
2966
2967   regno_pointer_flag_length = LAST_VIRTUAL_REGISTER + 101;
2968
2969   regno_pointer_flag
2970     = (char *) oballoc (regno_pointer_flag_length);
2971   bzero (regno_pointer_flag, regno_pointer_flag_length);
2972
2973   regno_reg_rtx
2974     = (rtx *) oballoc (regno_pointer_flag_length * sizeof (rtx));
2975   bzero (regno_reg_rtx, regno_pointer_flag_length * sizeof (rtx));
2976
2977   /* Put copies of all the virtual register rtx into regno_reg_rtx.  */
2978   regno_reg_rtx[VIRTUAL_INCOMING_ARGS_REGNUM] = virtual_incoming_args_rtx;
2979   regno_reg_rtx[VIRTUAL_STACK_VARS_REGNUM] = virtual_stack_vars_rtx;
2980   regno_reg_rtx[VIRTUAL_STACK_DYNAMIC_REGNUM] = virtual_stack_dynamic_rtx;
2981   regno_reg_rtx[VIRTUAL_OUTGOING_ARGS_REGNUM] = virtual_outgoing_args_rtx;
2982
2983   /* Indicate that the virtual registers and stack locations are
2984      all pointers.  */
2985   REGNO_POINTER_FLAG (STACK_POINTER_REGNUM) = 1;
2986   REGNO_POINTER_FLAG (FRAME_POINTER_REGNUM) = 1;
2987   REGNO_POINTER_FLAG (ARG_POINTER_REGNUM) = 1;
2988
2989   REGNO_POINTER_FLAG (VIRTUAL_INCOMING_ARGS_REGNUM) = 1;
2990   REGNO_POINTER_FLAG (VIRTUAL_STACK_VARS_REGNUM) = 1;
2991   REGNO_POINTER_FLAG (VIRTUAL_STACK_DYNAMIC_REGNUM) = 1;
2992   REGNO_POINTER_FLAG (VIRTUAL_OUTGOING_ARGS_REGNUM) = 1;
2993
2994 #ifdef INIT_EXPANDERS
2995   INIT_EXPANDERS;
2996 #endif
2997 }
2998
2999 /* Create some permanent unique rtl objects shared between all functions.
3000    LINE_NUMBERS is nonzero if line numbers are to be generated.  */
3001
3002 void
3003 init_emit_once (line_numbers)
3004      int line_numbers;
3005 {
3006   int i;
3007   enum machine_mode mode;
3008
3009   no_line_numbers = ! line_numbers;
3010
3011   sequence_stack = NULL;
3012
3013   /* Create the unique rtx's for certain rtx codes and operand values.  */
3014
3015   pc_rtx = gen_rtx (PC, VOIDmode);
3016   cc0_rtx = gen_rtx (CC0, VOIDmode);
3017
3018   /* Don't use gen_rtx here since gen_rtx in this case
3019      tries to use these variables.  */
3020   for (i = - MAX_SAVED_CONST_INT; i <= MAX_SAVED_CONST_INT; i++)
3021     {
3022       const_int_rtx[i + MAX_SAVED_CONST_INT] = rtx_alloc (CONST_INT);
3023       PUT_MODE (const_int_rtx[i + MAX_SAVED_CONST_INT], VOIDmode);
3024       INTVAL (const_int_rtx[i + MAX_SAVED_CONST_INT]) = i;
3025     }
3026
3027   /* These four calls obtain some of the rtx expressions made above.  */
3028   const0_rtx = GEN_INT (0);
3029   const1_rtx = GEN_INT (1);
3030   const2_rtx = GEN_INT (2);
3031   constm1_rtx = GEN_INT (-1);
3032
3033   /* This will usually be one of the above constants, but may be a new rtx.  */
3034   const_true_rtx = GEN_INT (STORE_FLAG_VALUE);
3035
3036   dconst0 = REAL_VALUE_ATOF ("0", DFmode);
3037   dconst1 = REAL_VALUE_ATOF ("1", DFmode);
3038   dconst2 = REAL_VALUE_ATOF ("2", DFmode);
3039   dconstm1 = REAL_VALUE_ATOF ("-1", DFmode);
3040
3041   for (i = 0; i <= 2; i++)
3042     {
3043       for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT); mode != VOIDmode;
3044            mode = GET_MODE_WIDER_MODE (mode))
3045         {
3046           rtx tem = rtx_alloc (CONST_DOUBLE);
3047           union real_extract u;
3048
3049           bzero (&u, sizeof u);  /* Zero any holes in a structure.  */
3050           u.d = i == 0 ? dconst0 : i == 1 ? dconst1 : dconst2;
3051
3052           bcopy (&u, &CONST_DOUBLE_LOW (tem), sizeof u);
3053           CONST_DOUBLE_MEM (tem) = cc0_rtx;
3054           PUT_MODE (tem, mode);
3055
3056           const_tiny_rtx[i][(int) mode] = tem;
3057         }
3058
3059       const_tiny_rtx[i][(int) VOIDmode] = GEN_INT (i);
3060
3061       for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
3062            mode = GET_MODE_WIDER_MODE (mode))
3063         const_tiny_rtx[i][(int) mode] = GEN_INT (i);
3064
3065       for (mode = GET_CLASS_NARROWEST_MODE (MODE_PARTIAL_INT);
3066            mode != VOIDmode;
3067            mode = GET_MODE_WIDER_MODE (mode))
3068         const_tiny_rtx[i][(int) mode] = GEN_INT (i);
3069     }
3070
3071   for (mode = GET_CLASS_NARROWEST_MODE (MODE_CC); mode != VOIDmode;
3072        mode = GET_MODE_WIDER_MODE (mode))
3073     const_tiny_rtx[0][(int) mode] = const0_rtx;
3074
3075   stack_pointer_rtx = gen_rtx (REG, Pmode, STACK_POINTER_REGNUM);
3076   frame_pointer_rtx = gen_rtx (REG, Pmode, FRAME_POINTER_REGNUM);
3077
3078   if (FRAME_POINTER_REGNUM == ARG_POINTER_REGNUM)
3079     arg_pointer_rtx = frame_pointer_rtx;
3080   else if (STACK_POINTER_REGNUM == ARG_POINTER_REGNUM)
3081     arg_pointer_rtx = stack_pointer_rtx;
3082   else
3083     arg_pointer_rtx = gen_rtx (REG, Pmode, ARG_POINTER_REGNUM);
3084
3085   /* Create the virtual registers.  Do so here since the following objects
3086      might reference them.  */
3087
3088   virtual_incoming_args_rtx = gen_rtx (REG, Pmode,
3089                                        VIRTUAL_INCOMING_ARGS_REGNUM);
3090   virtual_stack_vars_rtx = gen_rtx (REG, Pmode,
3091                                     VIRTUAL_STACK_VARS_REGNUM);
3092   virtual_stack_dynamic_rtx = gen_rtx (REG, Pmode,
3093                                        VIRTUAL_STACK_DYNAMIC_REGNUM);
3094   virtual_outgoing_args_rtx = gen_rtx (REG, Pmode,
3095                                        VIRTUAL_OUTGOING_ARGS_REGNUM);
3096
3097 #ifdef STRUCT_VALUE
3098   struct_value_rtx = STRUCT_VALUE;
3099 #else
3100   struct_value_rtx = gen_rtx (REG, Pmode, STRUCT_VALUE_REGNUM);
3101 #endif
3102
3103 #ifdef STRUCT_VALUE_INCOMING
3104   struct_value_incoming_rtx = STRUCT_VALUE_INCOMING;
3105 #else
3106 #ifdef STRUCT_VALUE_INCOMING_REGNUM
3107   struct_value_incoming_rtx
3108     = gen_rtx (REG, Pmode, STRUCT_VALUE_INCOMING_REGNUM);
3109 #else
3110   struct_value_incoming_rtx = struct_value_rtx;
3111 #endif
3112 #endif
3113
3114 #ifdef STATIC_CHAIN_REGNUM
3115   static_chain_rtx = gen_rtx (REG, Pmode, STATIC_CHAIN_REGNUM);
3116
3117 #ifdef STATIC_CHAIN_INCOMING_REGNUM
3118   if (STATIC_CHAIN_INCOMING_REGNUM != STATIC_CHAIN_REGNUM)
3119     static_chain_incoming_rtx = gen_rtx (REG, Pmode, STATIC_CHAIN_INCOMING_REGNUM);
3120   else
3121 #endif
3122     static_chain_incoming_rtx = static_chain_rtx;
3123 #endif
3124
3125 #ifdef STATIC_CHAIN
3126   static_chain_rtx = STATIC_CHAIN;
3127
3128 #ifdef STATIC_CHAIN_INCOMING
3129   static_chain_incoming_rtx = STATIC_CHAIN_INCOMING;
3130 #else
3131   static_chain_incoming_rtx = static_chain_rtx;
3132 #endif
3133 #endif
3134
3135 #ifdef PIC_OFFSET_TABLE_REGNUM
3136   pic_offset_table_rtx = gen_rtx (REG, Pmode, PIC_OFFSET_TABLE_REGNUM);
3137 #endif
3138 }