gcc/emit-rtl.c

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