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 (cfun->emit->x_first_insn)
 160 #define last_insn (cfun->emit->x_last_insn)
 161 #define cur_insn_uid (cfun->emit->x_cur_insn_uid)
 162 #define last_linenum (cfun->emit->x_last_linenum)
 163 #define last_filename (cfun->emit->x_last_filename)
 164 #define first_label_num (cfun->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 = cfun;
 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, NULL_PTR);
1527
1528   LABEL_NUSES (label) = 0;
1529   LABEL_ALTERNATE_NAME (label) = NULL;
1530   return label;
1531 }
1532 \f
1533 /* For procedure integration.  */
1534
1535 /* Install new pointers to the first and last insns in the chain.
1536    Also, set cur_insn_uid to one higher than the last in use.
1537    Used for an inline-procedure after copying the insn chain.  */
1538
1539 void
1540 set_new_first_and_last_insn (first, last)
1541      rtx first, last;
1542 {
1543   rtx insn;
1544
1545   first_insn = first;
1546   last_insn = last;
1547   cur_insn_uid = 0;
1548
1549   for (insn = first; insn; insn = NEXT_INSN (insn))
1550     cur_insn_uid = MAX (cur_insn_uid, INSN_UID (insn));
1551
1552   cur_insn_uid++;
1553 }
1554
1555 /* Set the range of label numbers found in the current function.
1556    This is used when belatedly compiling an inline function.  */
1557
1558 void
1559 set_new_first_and_last_label_num (first, last)
1560      int first, last;
1561 {
1562   base_label_num = label_num;
1563   first_label_num = first;
1564   last_label_num = last;
1565 }
1566
1567 /* Set the last label number found in the current function.
1568    This is used when belatedly compiling an inline function.  */
1569
1570 void
1571 set_new_last_label_num (last)
1572      int last;
1573 {
1574   base_label_num = label_num;
1575   last_label_num = last;
1576 }
1577 \f
1578 /* Restore all variables describing the current status from the structure *P.
1579    This is used after a nested function.  */
1580
1581 void
1582 restore_emit_status (p)
1583      struct function *p ATTRIBUTE_UNUSED;
1584 {
1585   last_label_num = 0;
1586   clear_emit_caches ();
1587 }
1588
1589 /* Clear out all parts of the state in F that can safely be discarded
1590    after the function has been compiled, to let garbage collection
1591    reclaim the memory.  */
1592
1593 void
1594 free_emit_status (f)
1595      struct function *f;
1596 {
1597   free (f->emit->x_regno_reg_rtx);
1598   free (f->emit->regno_pointer_flag);
1599   free (f->emit->regno_pointer_align);
1600   free (f->emit);
1601   f->emit = NULL;
1602 }
1603 \f
1604 /* Go through all the RTL insn bodies and copy any invalid shared structure.
1605    It does not work to do this twice, because the mark bits set here
1606    are not cleared afterwards.  */
1607
1608 void
1609 unshare_all_rtl (insn)
1610      register rtx insn;
1611 {
1612   for (; insn; insn = NEXT_INSN (insn))
1613     if (GET_CODE (insn) == INSN || GET_CODE (insn) == JUMP_INSN
1614         || GET_CODE (insn) == CALL_INSN)
1615       {
1616         PATTERN (insn) = copy_rtx_if_shared (PATTERN (insn));
1617         REG_NOTES (insn) = copy_rtx_if_shared (REG_NOTES (insn));
1618         LOG_LINKS (insn) = copy_rtx_if_shared (LOG_LINKS (insn));
1619       }
1620
1621   /* Make sure the addresses of stack slots found outside the insn chain
1622      (such as, in DECL_RTL of a variable) are not shared
1623      with the insn chain.
1624
1625      This special care is necessary when the stack slot MEM does not
1626      actually appear in the insn chain.  If it does appear, its address
1627      is unshared from all else at that point.  */
1628
1629   copy_rtx_if_shared (stack_slot_list);
1630 }
1631
1632 /* Mark ORIG as in use, and return a copy of it if it was already in use.
1633    Recursively does the same for subexpressions.  */
1634
1635 rtx
1636 copy_rtx_if_shared (orig)
1637      rtx orig;
1638 {
1639   register rtx x = orig;
1640   register int i;
1641   register enum rtx_code code;
1642   register const char *format_ptr;
1643   int copied = 0;
1644
1645   if (x == 0)
1646     return 0;
1647
1648   code = GET_CODE (x);
1649
1650   /* These types may be freely shared.  */
1651
1652   switch (code)
1653     {
1654     case REG:
1655     case QUEUED:
1656     case CONST_INT:
1657     case CONST_DOUBLE:
1658     case SYMBOL_REF:
1659     case CODE_LABEL:
1660     case PC:
1661     case CC0:
1662     case SCRATCH:
1663       /* SCRATCH must be shared because they represent distinct values.  */
1664       return x;
1665
1666     case CONST:
1667       /* CONST can be shared if it contains a SYMBOL_REF.  If it contains
1668          a LABEL_REF, it isn't sharable.  */
1669       if (GET_CODE (XEXP (x, 0)) == PLUS
1670           && GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF
1671           && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT)
1672         return x;
1673       break;
1674
1675     case INSN:
1676     case JUMP_INSN:
1677     case CALL_INSN:
1678     case NOTE:
1679     case BARRIER:
1680       /* The chain of insns is not being copied.  */
1681       return x;
1682
1683     case MEM:
1684       /* A MEM is allowed to be shared if its address is constant.
1685
1686          We used to allow sharing of MEMs which referenced
1687          virtual_stack_vars_rtx or virtual_incoming_args_rtx, but
1688          that can lose.  instantiate_virtual_regs will not unshare
1689          the MEMs, and combine may change the structure of the address
1690          because it looks safe and profitable in one context, but
1691          in some other context it creates unrecognizable RTL.  */
1692       if (CONSTANT_ADDRESS_P (XEXP (x, 0)))
1693         return x;
1694
1695       break;
1696
1697     default:
1698       break;
1699     }
1700
1701   /* This rtx may not be shared.  If it has already been seen,
1702      replace it with a copy of itself.  */
1703
1704   if (x->used)
1705     {
1706       register rtx copy;
1707
1708       copy = rtx_alloc (code);
1709       bcopy ((char *) x, (char *) copy,
1710              (sizeof (*copy) - sizeof (copy->fld)
1711               + sizeof (copy->fld[0]) * GET_RTX_LENGTH (code)));
1712       x = copy;
1713       copied = 1;
1714     }
1715   x->used = 1;
1716
1717   /* Now scan the subexpressions recursively.
1718      We can store any replaced subexpressions directly into X
1719      since we know X is not shared!  Any vectors in X
1720      must be copied if X was copied.  */
1721
1722   format_ptr = GET_RTX_FORMAT (code);
1723
1724   for (i = 0; i < GET_RTX_LENGTH (code); i++)
1725     {
1726       switch (*format_ptr++)
1727         {
1728         case 'e':
1729           XEXP (x, i) = copy_rtx_if_shared (XEXP (x, i));
1730           break;
1731
1732         case 'E':
1733           if (XVEC (x, i) != NULL)
1734             {
1735               register int j;
1736               int len = XVECLEN (x, i);
1737
1738               if (copied && len > 0)
1739                 XVEC (x, i) = gen_rtvec_v (len, XVEC (x, i)->elem);
1740               for (j = 0; j < len; j++)
1741                 XVECEXP (x, i, j) = copy_rtx_if_shared (XVECEXP (x, i, j));
1742             }
1743           break;
1744         }
1745     }
1746   return x;
1747 }
1748
1749 /* Clear all the USED bits in X to allow copy_rtx_if_shared to be used
1750    to look for shared sub-parts.  */
1751
1752 void
1753 reset_used_flags (x)
1754      rtx x;
1755 {
1756   register int i, j;
1757   register enum rtx_code code;
1758   register const char *format_ptr;
1759
1760   if (x == 0)
1761     return;
1762
1763   code = GET_CODE (x);
1764
1765   /* These types may be freely shared so we needn't do any resetting
1766      for them.  */
1767
1768   switch (code)
1769     {
1770     case REG:
1771     case QUEUED:
1772     case CONST_INT:
1773     case CONST_DOUBLE:
1774     case SYMBOL_REF:
1775     case CODE_LABEL:
1776     case PC:
1777     case CC0:
1778       return;
1779
1780     case INSN:
1781     case JUMP_INSN:
1782     case CALL_INSN:
1783     case NOTE:
1784     case LABEL_REF:
1785     case BARRIER:
1786       /* The chain of insns is not being copied.  */
1787       return;
1788
1789     default:
1790       break;
1791     }
1792
1793   x->used = 0;
1794
1795   format_ptr = GET_RTX_FORMAT (code);
1796   for (i = 0; i < GET_RTX_LENGTH (code); i++)
1797     {
1798       switch (*format_ptr++)
1799         {
1800         case 'e':
1801           reset_used_flags (XEXP (x, i));
1802           break;
1803
1804         case 'E':
1805           for (j = 0; j < XVECLEN (x, i); j++)
1806             reset_used_flags (XVECEXP (x, i, j));
1807           break;
1808         }
1809     }
1810 }
1811 \f
1812 /* Copy X if necessary so that it won't be altered by changes in OTHER.
1813    Return X or the rtx for the pseudo reg the value of X was copied into.
1814    OTHER must be valid as a SET_DEST.  */
1815
1816 rtx
1817 make_safe_from (x, other)
1818      rtx x, other;
1819 {
1820   while (1)
1821     switch (GET_CODE (other))
1822       {
1823       case SUBREG:
1824         other = SUBREG_REG (other);
1825         break;
1826       case STRICT_LOW_PART:
1827       case SIGN_EXTEND:
1828       case ZERO_EXTEND:
1829         other = XEXP (other, 0);
1830         break;
1831       default:
1832         goto done;
1833       }
1834  done:
1835   if ((GET_CODE (other) == MEM
1836        && ! CONSTANT_P (x)
1837        && GET_CODE (x) != REG
1838        && GET_CODE (x) != SUBREG)
1839       || (GET_CODE (other) == REG
1840           && (REGNO (other) < FIRST_PSEUDO_REGISTER
1841               || reg_mentioned_p (other, x))))
1842     {
1843       rtx temp = gen_reg_rtx (GET_MODE (x));
1844       emit_move_insn (temp, x);
1845       return temp;
1846     }
1847   return x;
1848 }
1849 \f
1850 /* Emission of insns (adding them to the doubly-linked list).  */
1851
1852 /* Return the first insn of the current sequence or current function.  */
1853
1854 rtx
1855 get_insns ()
1856 {
1857   return first_insn;
1858 }
1859
1860 /* Return the last insn emitted in current sequence or current function.  */
1861
1862 rtx
1863 get_last_insn ()
1864 {
1865   return last_insn;
1866 }
1867
1868 /* Specify a new insn as the last in the chain.  */
1869
1870 void
1871 set_last_insn (insn)
1872      rtx insn;
1873 {
1874   if (NEXT_INSN (insn) != 0)
1875     abort ();
1876   last_insn = insn;
1877 }
1878
1879 /* Return the last insn emitted, even if it is in a sequence now pushed.  */
1880
1881 rtx
1882 get_last_insn_anywhere ()
1883 {
1884   struct sequence_stack *stack;
1885   if (last_insn)
1886     return last_insn;
1887   for (stack = seq_stack; stack; stack = stack->next)
1888     if (stack->last != 0)
1889       return stack->last;
1890   return 0;
1891 }
1892
1893 /* Return a number larger than any instruction's uid in this function.  */
1894
1895 int
1896 get_max_uid ()
1897 {
1898   return cur_insn_uid;
1899 }
1900
1901 /* Renumber instructions so that no instruction UIDs are wasted.  */
1902
1903 void
1904 renumber_insns (stream)
1905      FILE *stream;
1906 {
1907   rtx insn;
1908
1909   /* If we're not supposed to renumber instructions, don't.  */
1910   if (!flag_renumber_insns)
1911     return;
1912
1913   /* If there aren't that many instructions, then it's not really
1914      worth renumbering them.  */
1915   if (flag_renumber_insns == 1 && get_max_uid () < 25000)
1916     return;
1917
1918   cur_insn_uid = 1;
1919
1920   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
1921     {
1922       if (stream)
1923         fprintf (stream, "Renumbering insn %d to %d\n",
1924                  INSN_UID (insn), cur_insn_uid);
1925       INSN_UID (insn) = cur_insn_uid++;
1926     }
1927 }
1928 \f
1929 /* Return the next insn.  If it is a SEQUENCE, return the first insn
1930    of the sequence.  */
1931
1932 rtx
1933 next_insn (insn)
1934      rtx insn;
1935 {
1936   if (insn)
1937     {
1938       insn = NEXT_INSN (insn);
1939       if (insn && GET_CODE (insn) == INSN
1940           && GET_CODE (PATTERN (insn)) == SEQUENCE)
1941         insn = XVECEXP (PATTERN (insn), 0, 0);
1942     }
1943
1944   return insn;
1945 }
1946
1947 /* Return the previous insn.  If it is a SEQUENCE, return the last insn
1948    of the sequence.  */
1949
1950 rtx
1951 previous_insn (insn)
1952      rtx insn;
1953 {
1954   if (insn)
1955     {
1956       insn = PREV_INSN (insn);
1957       if (insn && GET_CODE (insn) == INSN
1958           && GET_CODE (PATTERN (insn)) == SEQUENCE)
1959         insn = XVECEXP (PATTERN (insn), 0, XVECLEN (PATTERN (insn), 0) - 1);
1960     }
1961
1962   return insn;
1963 }
1964
1965 /* Return the next insn after INSN that is not a NOTE.  This routine does not
1966    look inside SEQUENCEs.  */
1967
1968 rtx
1969 next_nonnote_insn (insn)
1970      rtx insn;
1971 {
1972   while (insn)
1973     {
1974       insn = NEXT_INSN (insn);
1975       if (insn == 0 || GET_CODE (insn) != NOTE)
1976         break;
1977     }
1978
1979   return insn;
1980 }
1981
1982 /* Return the previous insn before INSN that is not a NOTE.  This routine does
1983    not look inside SEQUENCEs.  */
1984
1985 rtx
1986 prev_nonnote_insn (insn)
1987      rtx insn;
1988 {
1989   while (insn)
1990     {
1991       insn = PREV_INSN (insn);
1992       if (insn == 0 || GET_CODE (insn) != NOTE)
1993         break;
1994     }
1995
1996   return insn;
1997 }
1998
1999 /* Return the next INSN, CALL_INSN or JUMP_INSN after INSN;
2000    or 0, if there is none.  This routine does not look inside
2001    SEQUENCEs.  */
2002
2003 rtx
2004 next_real_insn (insn)
2005      rtx insn;
2006 {
2007   while (insn)
2008     {
2009       insn = NEXT_INSN (insn);
2010       if (insn == 0 || GET_CODE (insn) == INSN
2011           || GET_CODE (insn) == CALL_INSN || GET_CODE (insn) == JUMP_INSN)
2012         break;
2013     }
2014
2015   return insn;
2016 }
2017
2018 /* Return the last INSN, CALL_INSN or JUMP_INSN before INSN;
2019    or 0, if there is none.  This routine does not look inside
2020    SEQUENCEs.  */
2021
2022 rtx
2023 prev_real_insn (insn)
2024      rtx insn;
2025 {
2026   while (insn)
2027     {
2028       insn = PREV_INSN (insn);
2029       if (insn == 0 || GET_CODE (insn) == INSN || GET_CODE (insn) == CALL_INSN
2030           || GET_CODE (insn) == JUMP_INSN)
2031         break;
2032     }
2033
2034   return insn;
2035 }
2036
2037 /* Find the next insn after INSN that really does something.  This routine
2038    does not look inside SEQUENCEs.  Until reload has completed, this is the
2039    same as next_real_insn.  */
2040
2041 rtx
2042 next_active_insn (insn)
2043      rtx insn;
2044 {
2045   while (insn)
2046     {
2047       insn = NEXT_INSN (insn);
2048       if (insn == 0
2049           || GET_CODE (insn) == CALL_INSN || GET_CODE (insn) == JUMP_INSN
2050           || (GET_CODE (insn) == INSN
2051               && (! reload_completed
2052                   || (GET_CODE (PATTERN (insn)) != USE
2053                       && GET_CODE (PATTERN (insn)) != CLOBBER))))
2054         break;
2055     }
2056
2057   return insn;
2058 }
2059
2060 /* Find the last insn before INSN that really does something.  This routine
2061    does not look inside SEQUENCEs.  Until reload has completed, this is the
2062    same as prev_real_insn.  */
2063
2064 rtx
2065 prev_active_insn (insn)
2066      rtx insn;
2067 {
2068   while (insn)
2069     {
2070       insn = PREV_INSN (insn);
2071       if (insn == 0
2072           || GET_CODE (insn) == CALL_INSN || GET_CODE (insn) == JUMP_INSN
2073           || (GET_CODE (insn) == INSN
2074               && (! reload_completed
2075                   || (GET_CODE (PATTERN (insn)) != USE
2076                       && GET_CODE (PATTERN (insn)) != CLOBBER))))
2077         break;
2078     }
2079
2080   return insn;
2081 }
2082
2083 /* Return the next CODE_LABEL after the insn INSN, or 0 if there is none.  */
2084
2085 rtx
2086 next_label (insn)
2087      rtx insn;
2088 {
2089   while (insn)
2090     {
2091       insn = NEXT_INSN (insn);
2092       if (insn == 0 || GET_CODE (insn) == CODE_LABEL)
2093         break;
2094     }
2095
2096   return insn;
2097 }
2098
2099 /* Return the last CODE_LABEL before the insn INSN, or 0 if there is none.  */
2100
2101 rtx
2102 prev_label (insn)
2103      rtx insn;
2104 {
2105   while (insn)
2106     {
2107       insn = PREV_INSN (insn);
2108       if (insn == 0 || GET_CODE (insn) == CODE_LABEL)
2109         break;
2110     }
2111
2112   return insn;
2113 }
2114 \f
2115 #ifdef HAVE_cc0
2116 /* INSN uses CC0 and is being moved into a delay slot.  Set up REG_CC_SETTER
2117    and REG_CC_USER notes so we can find it.  */
2118
2119 void
2120 link_cc0_insns (insn)
2121      rtx insn;
2122 {
2123   rtx user = next_nonnote_insn (insn);
2124
2125   if (GET_CODE (user) == INSN && GET_CODE (PATTERN (user)) == SEQUENCE)
2126     user = XVECEXP (PATTERN (user), 0, 0);
2127
2128   REG_NOTES (user) = gen_rtx_INSN_LIST (REG_CC_SETTER, insn,
2129                                         REG_NOTES (user));
2130   REG_NOTES (insn) = gen_rtx_INSN_LIST (REG_CC_USER, user, REG_NOTES (insn));
2131 }
2132
2133 /* Return the next insn that uses CC0 after INSN, which is assumed to
2134    set it.  This is the inverse of prev_cc0_setter (i.e., prev_cc0_setter
2135    applied to the result of this function should yield INSN).
2136
2137    Normally, this is simply the next insn.  However, if a REG_CC_USER note
2138    is present, it contains the insn that uses CC0.
2139
2140    Return 0 if we can't find the insn.  */
2141
2142 rtx
2143 next_cc0_user (insn)
2144      rtx insn;
2145 {
2146   rtx note = find_reg_note (insn, REG_CC_USER, NULL_RTX);
2147
2148   if (note)
2149     return XEXP (note, 0);
2150
2151   insn = next_nonnote_insn (insn);
2152   if (insn && GET_CODE (insn) == INSN && GET_CODE (PATTERN (insn)) == SEQUENCE)
2153     insn = XVECEXP (PATTERN (insn), 0, 0);
2154
2155   if (insn && GET_RTX_CLASS (GET_CODE (insn)) == 'i'
2156       && reg_mentioned_p (cc0_rtx, PATTERN (insn)))
2157     return insn;
2158
2159   return 0;
2160 }
2161
2162 /* Find the insn that set CC0 for INSN.  Unless INSN has a REG_CC_SETTER
2163    note, it is the previous insn.  */
2164
2165 rtx
2166 prev_cc0_setter (insn)
2167      rtx insn;
2168 {
2169   rtx note = find_reg_note (insn, REG_CC_SETTER, NULL_RTX);
2170
2171   if (note)
2172     return XEXP (note, 0);
2173
2174   insn = prev_nonnote_insn (insn);
2175   if (! sets_cc0_p (PATTERN (insn)))
2176     abort ();
2177
2178   return insn;
2179 }
2180 #endif
2181 \f
2182 /* Try splitting insns that can be split for better scheduling.
2183    PAT is the pattern which might split.
2184    TRIAL is the insn providing PAT.
2185    LAST is non-zero if we should return the last insn of the sequence produced.
2186
2187    If this routine succeeds in splitting, it returns the first or last
2188    replacement insn depending on the value of LAST.  Otherwise, it
2189    returns TRIAL.  If the insn to be returned can be split, it will be.  */
2190
2191 rtx
2192 try_split (pat, trial, last)
2193      rtx pat, trial;
2194      int last;
2195 {
2196   rtx before = PREV_INSN (trial);
2197   rtx after = NEXT_INSN (trial);
2198   rtx seq = split_insns (pat, trial);
2199   int has_barrier = 0;
2200   rtx tem;
2201
2202   /* If we are splitting a JUMP_INSN, it might be followed by a BARRIER.
2203      We may need to handle this specially.  */
2204   if (after && GET_CODE (after) == BARRIER)
2205     {
2206       has_barrier = 1;
2207       after = NEXT_INSN (after);
2208     }
2209
2210   if (seq)
2211     {
2212       /* SEQ can either be a SEQUENCE or the pattern of a single insn.
2213          The latter case will normally arise only when being done so that
2214          it, in turn, will be split (SFmode on the 29k is an example).  */
2215       if (GET_CODE (seq) == SEQUENCE)
2216         {
2217           /* If we are splitting a JUMP_INSN, look for the JUMP_INSN in
2218              SEQ and copy our JUMP_LABEL to it.  If JUMP_LABEL is non-zero,
2219              increment the usage count so we don't delete the label.  */
2220           int i;
2221
2222           if (GET_CODE (trial) == JUMP_INSN)
2223             for (i = XVECLEN (seq, 0) - 1; i >= 0; i--)
2224               if (GET_CODE (XVECEXP (seq, 0, i)) == JUMP_INSN)
2225                 {
2226                   JUMP_LABEL (XVECEXP (seq, 0, i)) = JUMP_LABEL (trial);
2227
2228                   if (JUMP_LABEL (trial))
2229                     LABEL_NUSES (JUMP_LABEL (trial))++;
2230                 }
2231
2232           tem = emit_insn_after (seq, before);
2233
2234           delete_insn (trial);
2235           if (has_barrier)
2236             emit_barrier_after (tem);
2237
2238           /* Recursively call try_split for each new insn created; by the
2239              time control returns here that insn will be fully split, so
2240              set LAST and continue from the insn after the one returned.
2241              We can't use next_active_insn here since AFTER may be a note.
2242              Ignore deleted insns, which can be occur if not optimizing.  */
2243           for (tem = NEXT_INSN (before); tem != after;
2244                tem = NEXT_INSN (tem))
2245             if (! INSN_DELETED_P (tem)
2246                 && GET_RTX_CLASS (GET_CODE (tem)) == 'i')
2247               tem = try_split (PATTERN (tem), tem, 1);
2248         }
2249       /* Avoid infinite loop if the result matches the original pattern.  */
2250       else if (rtx_equal_p (seq, pat))
2251         return trial;
2252       else
2253         {
2254           PATTERN (trial) = seq;
2255           INSN_CODE (trial) = -1;
2256           try_split (seq, trial, last);
2257         }
2258
2259       /* Return either the first or the last insn, depending on which was
2260          requested.  */
2261       return last ? prev_active_insn (after) : next_active_insn (before);
2262     }
2263
2264   return trial;
2265 }
2266 \f
2267 /* Make and return an INSN rtx, initializing all its slots.
2268    Store PATTERN in the pattern slots.  */
2269
2270 rtx
2271 make_insn_raw (pattern)
2272      rtx pattern;
2273 {
2274   register rtx insn;
2275
2276   /* If in RTL generation phase, see if FREE_INSN can be used.  */
2277   if (!ggc_p && free_insn != 0 && rtx_equal_function_value_matters)
2278     {
2279       insn = free_insn;
2280       free_insn = NEXT_INSN (free_insn);
2281       PUT_CODE (insn, INSN);
2282     }
2283   else
2284     insn = rtx_alloc (INSN);
2285
2286   INSN_UID (insn) = cur_insn_uid++;
2287   PATTERN (insn) = pattern;
2288   INSN_CODE (insn) = -1;
2289   LOG_LINKS (insn) = NULL;
2290   REG_NOTES (insn) = NULL;
2291
2292   return insn;
2293 }
2294
2295 /* Like `make_insn' but make a JUMP_INSN instead of an insn.  */
2296
2297 static rtx
2298 make_jump_insn_raw (pattern)
2299      rtx pattern;
2300 {
2301   register rtx insn;
2302
2303   insn = rtx_alloc (JUMP_INSN);
2304   INSN_UID (insn) = cur_insn_uid++;
2305
2306   PATTERN (insn) = pattern;
2307   INSN_CODE (insn) = -1;
2308   LOG_LINKS (insn) = NULL;
2309   REG_NOTES (insn) = NULL;
2310   JUMP_LABEL (insn) = NULL;
2311
2312   return insn;
2313 }
2314
2315 /* Like `make_insn' but make a CALL_INSN instead of an insn.  */
2316
2317 static rtx
2318 make_call_insn_raw (pattern)
2319      rtx pattern;
2320 {
2321   register rtx insn;
2322
2323   insn = rtx_alloc (CALL_INSN);
2324   INSN_UID (insn) = cur_insn_uid++;
2325
2326   PATTERN (insn) = pattern;
2327   INSN_CODE (insn) = -1;
2328   LOG_LINKS (insn) = NULL;
2329   REG_NOTES (insn) = NULL;
2330   CALL_INSN_FUNCTION_USAGE (insn) = NULL;
2331
2332   return insn;
2333 }
2334 \f
2335 /* Add INSN to the end of the doubly-linked list.
2336    INSN may be an INSN, JUMP_INSN, CALL_INSN, CODE_LABEL, BARRIER or NOTE.  */
2337
2338 void
2339 add_insn (insn)
2340      register rtx insn;
2341 {
2342   PREV_INSN (insn) = last_insn;
2343   NEXT_INSN (insn) = 0;
2344
2345   if (NULL != last_insn)
2346     NEXT_INSN (last_insn) = insn;
2347
2348   if (NULL == first_insn)
2349     first_insn = insn;
2350
2351   last_insn = insn;
2352 }
2353
2354 /* Add INSN into the doubly-linked list after insn AFTER.  This and
2355    the next should be the only functions called to insert an insn once
2356    delay slots have been filled since only they know how to update a
2357    SEQUENCE.  */
2358
2359 void
2360 add_insn_after (insn, after)
2361      rtx insn, after;
2362 {
2363   rtx next = NEXT_INSN (after);
2364
2365   if (optimize && INSN_DELETED_P (after))
2366     abort ();
2367
2368   NEXT_INSN (insn) = next;
2369   PREV_INSN (insn) = after;
2370
2371   if (next)
2372     {
2373       PREV_INSN (next) = insn;
2374       if (GET_CODE (next) == INSN && GET_CODE (PATTERN (next)) == SEQUENCE)
2375         PREV_INSN (XVECEXP (PATTERN (next), 0, 0)) = insn;
2376     }
2377   else if (last_insn == after)
2378     last_insn = insn;
2379   else
2380     {
2381       struct sequence_stack *stack = seq_stack;
2382       /* Scan all pending sequences too.  */
2383       for (; stack; stack = stack->next)
2384         if (after == stack->last)
2385           {
2386             stack->last = insn;
2387             break;
2388           }
2389
2390       if (stack == 0)
2391         abort ();
2392     }
2393
2394   NEXT_INSN (after) = insn;
2395   if (GET_CODE (after) == INSN && GET_CODE (PATTERN (after)) == SEQUENCE)
2396     {
2397       rtx sequence = PATTERN (after);
2398       NEXT_INSN (XVECEXP (sequence, 0, XVECLEN (sequence, 0) - 1)) = insn;
2399     }
2400 }
2401
2402 /* Add INSN into the doubly-linked list before insn BEFORE.  This and
2403    the previous should be the only functions called to insert an insn once
2404    delay slots have been filled since only they know how to update a
2405    SEQUENCE.  */
2406
2407 void
2408 add_insn_before (insn, before)
2409      rtx insn, before;
2410 {
2411   rtx prev = PREV_INSN (before);
2412
2413   if (optimize && INSN_DELETED_P (before))
2414     abort ();
2415
2416   PREV_INSN (insn) = prev;
2417   NEXT_INSN (insn) = before;
2418
2419   if (prev)
2420     {
2421       NEXT_INSN (prev) = insn;
2422       if (GET_CODE (prev) == INSN && GET_CODE (PATTERN (prev)) == SEQUENCE)
2423         {
2424           rtx sequence = PATTERN (prev);
2425           NEXT_INSN (XVECEXP (sequence, 0, XVECLEN (sequence, 0) - 1)) = insn;
2426         }
2427     }
2428   else if (first_insn == before)
2429     first_insn = insn;
2430   else
2431     {
2432       struct sequence_stack *stack = seq_stack;
2433       /* Scan all pending sequences too.  */
2434       for (; stack; stack = stack->next)
2435         if (before == stack->first)
2436           {
2437             stack->first = insn;
2438             break;
2439           }
2440
2441       if (stack == 0)
2442         abort ();
2443     }
2444
2445   PREV_INSN (before) = insn;
2446   if (GET_CODE (before) == INSN && GET_CODE (PATTERN (before)) == SEQUENCE)
2447     PREV_INSN (XVECEXP (PATTERN (before), 0, 0)) = insn;
2448 }
2449
2450 /* Remove an insn from its doubly-linked list.  This function knows how
2451    to handle sequences.  */
2452 void
2453 remove_insn (insn)
2454      rtx insn;
2455 {
2456   rtx next = NEXT_INSN (insn);
2457   rtx prev = PREV_INSN (insn);
2458   if (prev)
2459     {
2460       NEXT_INSN (prev) = next;
2461       if (GET_CODE (prev) == INSN && GET_CODE (PATTERN (prev)) == SEQUENCE)
2462         {
2463           rtx sequence = PATTERN (prev);
2464           NEXT_INSN (XVECEXP (sequence, 0, XVECLEN (sequence, 0) - 1)) = next;
2465         }
2466     }
2467   else if (first_insn == insn)
2468     first_insn = next;
2469   else
2470     {
2471       struct sequence_stack *stack = seq_stack;
2472       /* Scan all pending sequences too.  */
2473       for (; stack; stack = stack->next)
2474         if (insn == stack->first)
2475           {
2476             stack->first = next;
2477             break;
2478           }
2479
2480       if (stack == 0)
2481         abort ();
2482     }
2483
2484   if (next)
2485     {
2486       PREV_INSN (next) = prev;
2487       if (GET_CODE (next) == INSN && GET_CODE (PATTERN (next)) == SEQUENCE)
2488         PREV_INSN (XVECEXP (PATTERN (next), 0, 0)) = prev;
2489     }
2490   else if (last_insn == insn)
2491     last_insn = prev;
2492   else
2493     {
2494       struct sequence_stack *stack = seq_stack;
2495       /* Scan all pending sequences too.  */
2496       for (; stack; stack = stack->next)
2497         if (insn == stack->last)
2498           {
2499             stack->last = prev;
2500             break;
2501           }
2502
2503       if (stack == 0)
2504         abort ();
2505     }
2506 }
2507
2508 /* Delete all insns made since FROM.
2509    FROM becomes the new last instruction.  */
2510
2511 void
2512 delete_insns_since (from)
2513      rtx from;
2514 {
2515   if (from == 0)
2516     first_insn = 0;
2517   else
2518     NEXT_INSN (from) = 0;
2519   last_insn = from;
2520 }
2521
2522 /* This function is deprecated, please use sequences instead.
2523
2524    Move a consecutive bunch of insns to a different place in the chain.
2525    The insns to be moved are those between FROM and TO.
2526    They are moved to a new position after the insn AFTER.
2527    AFTER must not be FROM or TO or any insn in between.
2528
2529    This function does not know about SEQUENCEs and hence should not be
2530    called after delay-slot filling has been done.  */
2531
2532 void
2533 reorder_insns (from, to, after)
2534      rtx from, to, after;
2535 {
2536   /* Splice this bunch out of where it is now.  */
2537   if (PREV_INSN (from))
2538     NEXT_INSN (PREV_INSN (from)) = NEXT_INSN (to);
2539   if (NEXT_INSN (to))
2540     PREV_INSN (NEXT_INSN (to)) = PREV_INSN (from);
2541   if (last_insn == to)
2542     last_insn = PREV_INSN (from);
2543   if (first_insn == from)
2544     first_insn = NEXT_INSN (to);
2545
2546   /* Make the new neighbors point to it and it to them.  */
2547   if (NEXT_INSN (after))
2548     PREV_INSN (NEXT_INSN (after)) = to;
2549
2550   NEXT_INSN (to) = NEXT_INSN (after);
2551   PREV_INSN (from) = after;
2552   NEXT_INSN (after) = from;
2553   if (after == last_insn)
2554     last_insn = to;
2555 }
2556
2557 /* Return the line note insn preceding INSN.  */
2558
2559 static rtx
2560 find_line_note (insn)
2561      rtx insn;
2562 {
2563   if (no_line_numbers)
2564     return 0;
2565
2566   for (; insn; insn = PREV_INSN (insn))
2567     if (GET_CODE (insn) == NOTE
2568         && NOTE_LINE_NUMBER (insn) >= 0)
2569       break;
2570
2571   return insn;
2572 }
2573
2574 /* Like reorder_insns, but inserts line notes to preserve the line numbers
2575    of the moved insns when debugging.  This may insert a note between AFTER
2576    and FROM, and another one after TO.  */
2577
2578 void
2579 reorder_insns_with_line_notes (from, to, after)
2580      rtx from, to, after;
2581 {
2582   rtx from_line = find_line_note (from);
2583   rtx after_line = find_line_note (after);
2584
2585   reorder_insns (from, to, after);
2586
2587   if (from_line == after_line)
2588     return;
2589
2590   if (from_line)
2591     emit_line_note_after (NOTE_SOURCE_FILE (from_line),
2592                           NOTE_LINE_NUMBER (from_line),
2593                           after);
2594   if (after_line)
2595     emit_line_note_after (NOTE_SOURCE_FILE (after_line),
2596                           NOTE_LINE_NUMBER (after_line),
2597                           to);
2598 }
2599
2600 /* Remove unncessary notes from the instruction stream.  */
2601
2602 void
2603 remove_unncessary_notes ()
2604 {
2605   rtx insn;
2606   rtx next;
2607
2608   /* Remove NOTE_INSN_DELETED notes.  We must not remove the first
2609      instruction in the function because the compiler depends on the
2610      first instruction being a note.  */
2611   for (insn = NEXT_INSN (get_insns ()); insn; insn = next)
2612     {
2613       /* Remember what's next.  */
2614       next = NEXT_INSN (insn);
2615
2616       /* We're only interested in notes.  */
2617       if (GET_CODE (insn) != NOTE)
2618         continue;
2619
2620       if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED)
2621         remove_insn (insn);
2622     }
2623 }
2624
2625 \f
2626 /* Emit an insn of given code and pattern
2627    at a specified place within the doubly-linked list.  */
2628
2629 /* Make an instruction with body PATTERN
2630    and output it before the instruction BEFORE.  */
2631
2632 rtx
2633 emit_insn_before (pattern, before)
2634      register rtx pattern, before;
2635 {
2636   register rtx insn = before;
2637
2638   if (GET_CODE (pattern) == SEQUENCE)
2639     {
2640       register int i;
2641
2642       for (i = 0; i < XVECLEN (pattern, 0); i++)
2643         {
2644           insn = XVECEXP (pattern, 0, i);
2645           add_insn_before (insn, before);
2646         }
2647       if (!ggc_p && XVECLEN (pattern, 0) < SEQUENCE_RESULT_SIZE)
2648         sequence_result[XVECLEN (pattern, 0)] = pattern;
2649     }
2650   else
2651     {
2652       insn = make_insn_raw (pattern);
2653       add_insn_before (insn, before);
2654     }
2655
2656   return insn;
2657 }
2658
2659 /* Similar to emit_insn_before, but update basic block boundaries as well.  */
2660
2661 rtx
2662 emit_block_insn_before (pattern, before, block)
2663      rtx pattern, before;
2664      basic_block block;
2665 {
2666   rtx prev = PREV_INSN (before);
2667   rtx r = emit_insn_before (pattern, before);
2668   if (block && block->head == before)
2669     block->head = NEXT_INSN (prev);
2670   return r;
2671 }
2672
2673 /* Make an instruction with body PATTERN and code JUMP_INSN
2674    and output it before the instruction BEFORE.  */
2675
2676 rtx
2677 emit_jump_insn_before (pattern, before)
2678      register rtx pattern, before;
2679 {
2680   register rtx insn;
2681
2682   if (GET_CODE (pattern) == SEQUENCE)
2683     insn = emit_insn_before (pattern, before);
2684   else
2685     {
2686       insn = make_jump_insn_raw (pattern);
2687       add_insn_before (insn, before);
2688     }
2689
2690   return insn;
2691 }
2692
2693 /* Make an instruction with body PATTERN and code CALL_INSN
2694    and output it before the instruction BEFORE.  */
2695
2696 rtx
2697 emit_call_insn_before (pattern, before)
2698      register rtx pattern, before;
2699 {
2700   register rtx insn;
2701
2702   if (GET_CODE (pattern) == SEQUENCE)
2703     insn = emit_insn_before (pattern, before);
2704   else
2705     {
2706       insn = make_call_insn_raw (pattern);
2707       add_insn_before (insn, before);
2708       PUT_CODE (insn, CALL_INSN);
2709     }
2710
2711   return insn;
2712 }
2713
2714 /* Make an insn of code BARRIER
2715    and output it before the insn BEFORE.  */
2716
2717 rtx
2718 emit_barrier_before (before)
2719      register rtx before;
2720 {
2721   register rtx insn = rtx_alloc (BARRIER);
2722
2723   INSN_UID (insn) = cur_insn_uid++;
2724
2725   add_insn_before (insn, before);
2726   return insn;
2727 }
2728
2729 /* Emit the label LABEL before the insn BEFORE.  */
2730
2731 rtx
2732 emit_label_before (label, before)
2733      rtx label, before;
2734 {
2735   /* This can be called twice for the same label as a result of the
2736      confusion that follows a syntax error!  So make it harmless.  */
2737   if (INSN_UID (label) == 0)
2738     {
2739       INSN_UID (label) = cur_insn_uid++;
2740       add_insn_before (label, before);
2741     }
2742
2743   return label;
2744 }
2745
2746 /* Emit a note of subtype SUBTYPE before the insn BEFORE.  */
2747
2748 rtx
2749 emit_note_before (subtype, before)
2750      int subtype;
2751      rtx before;
2752 {
2753   register rtx note = rtx_alloc (NOTE);
2754   INSN_UID (note) = cur_insn_uid++;
2755   NOTE_SOURCE_FILE (note) = 0;
2756   NOTE_LINE_NUMBER (note) = subtype;
2757
2758   add_insn_before (note, before);
2759   return note;
2760 }
2761 \f
2762 /* Make an insn of code INSN with body PATTERN
2763    and output it after the insn AFTER.  */
2764
2765 rtx
2766 emit_insn_after (pattern, after)
2767      register rtx pattern, after;
2768 {
2769   register rtx insn = after;
2770
2771   if (GET_CODE (pattern) == SEQUENCE)
2772     {
2773       register int i;
2774
2775       for (i = 0; i < XVECLEN (pattern, 0); i++)
2776         {
2777           insn = XVECEXP (pattern, 0, i);
2778           add_insn_after (insn, after);
2779           after = insn;
2780         }
2781       if (!ggc_p && XVECLEN (pattern, 0) < SEQUENCE_RESULT_SIZE)
2782         sequence_result[XVECLEN (pattern, 0)] = pattern;
2783     }
2784   else
2785     {
2786       insn = make_insn_raw (pattern);
2787       add_insn_after (insn, after);
2788     }
2789
2790   return insn;
2791 }
2792
2793 /* Similar to emit_insn_after, except that line notes are to be inserted so
2794    as to act as if this insn were at FROM.  */
2795
2796 void
2797 emit_insn_after_with_line_notes (pattern, after, from)
2798      rtx pattern, after, from;
2799 {
2800   rtx from_line = find_line_note (from);
2801   rtx after_line = find_line_note (after);
2802   rtx insn = emit_insn_after (pattern, after);
2803
2804   if (from_line)
2805     emit_line_note_after (NOTE_SOURCE_FILE (from_line),
2806                           NOTE_LINE_NUMBER (from_line),
2807                           after);
2808
2809   if (after_line)
2810     emit_line_note_after (NOTE_SOURCE_FILE (after_line),
2811                           NOTE_LINE_NUMBER (after_line),
2812                           insn);
2813 }
2814
2815 /* Similar to emit_insn_after, but update basic block boundaries as well.  */
2816
2817 rtx
2818 emit_block_insn_after (pattern, after, block)
2819      rtx pattern, after;
2820      basic_block block;
2821 {
2822   rtx r = emit_insn_after (pattern, after);
2823   if (block && block->end == after)
2824     block->end = r;
2825   return r;
2826 }
2827
2828 /* Make an insn of code JUMP_INSN with body PATTERN
2829    and output it after the insn AFTER.  */
2830
2831 rtx
2832 emit_jump_insn_after (pattern, after)
2833      register rtx pattern, after;
2834 {
2835   register rtx insn;
2836
2837   if (GET_CODE (pattern) == SEQUENCE)
2838     insn = emit_insn_after (pattern, after);
2839   else
2840     {
2841       insn = make_jump_insn_raw (pattern);
2842       add_insn_after (insn, after);
2843     }
2844
2845   return insn;
2846 }
2847
2848 /* Make an insn of code BARRIER
2849    and output it after the insn AFTER.  */
2850
2851 rtx
2852 emit_barrier_after (after)
2853      register rtx after;
2854 {
2855   register rtx insn = rtx_alloc (BARRIER);
2856
2857   INSN_UID (insn) = cur_insn_uid++;
2858
2859   add_insn_after (insn, after);
2860   return insn;
2861 }
2862
2863 /* Emit the label LABEL after the insn AFTER.  */
2864
2865 rtx
2866 emit_label_after (label, after)
2867      rtx label, after;
2868 {
2869   /* This can be called twice for the same label
2870      as a result of the confusion that follows a syntax error!
2871      So make it harmless.  */
2872   if (INSN_UID (label) == 0)
2873     {
2874       INSN_UID (label) = cur_insn_uid++;
2875       add_insn_after (label, after);
2876     }
2877
2878   return label;
2879 }
2880
2881 /* Emit a note of subtype SUBTYPE after the insn AFTER.  */
2882
2883 rtx
2884 emit_note_after (subtype, after)
2885      int subtype;
2886      rtx after;
2887 {
2888   register rtx note = rtx_alloc (NOTE);
2889   INSN_UID (note) = cur_insn_uid++;
2890   NOTE_SOURCE_FILE (note) = 0;
2891   NOTE_LINE_NUMBER (note) = subtype;
2892   add_insn_after (note, after);
2893   return note;
2894 }
2895
2896 /* Emit a line note for FILE and LINE after the insn AFTER.  */
2897
2898 rtx
2899 emit_line_note_after (file, line, after)
2900      char *file;
2901      int line;
2902      rtx after;
2903 {
2904   register rtx note;
2905
2906   if (no_line_numbers && line > 0)
2907     {
2908       cur_insn_uid++;
2909       return 0;
2910     }
2911
2912   note  = rtx_alloc (NOTE);
2913   INSN_UID (note) = cur_insn_uid++;
2914   NOTE_SOURCE_FILE (note) = file;
2915   NOTE_LINE_NUMBER (note) = line;
2916   add_insn_after (note, after);
2917   return note;
2918 }
2919 \f
2920 /* Make an insn of code INSN with pattern PATTERN
2921    and add it to the end of the doubly-linked list.
2922    If PATTERN is a SEQUENCE, take the elements of it
2923    and emit an insn for each element.
2924
2925    Returns the last insn emitted.  */
2926
2927 rtx
2928 emit_insn (pattern)
2929      rtx pattern;
2930 {
2931   rtx insn = last_insn;
2932
2933   if (GET_CODE (pattern) == SEQUENCE)
2934     {
2935       register int i;
2936
2937       for (i = 0; i < XVECLEN (pattern, 0); i++)
2938         {
2939           insn = XVECEXP (pattern, 0, i);
2940           add_insn (insn);
2941         }
2942       if (!ggc_p && XVECLEN (pattern, 0) < SEQUENCE_RESULT_SIZE)
2943         sequence_result[XVECLEN (pattern, 0)] = pattern;
2944     }
2945   else
2946     {
2947       insn = make_insn_raw (pattern);
2948       add_insn (insn);
2949     }
2950
2951   return insn;
2952 }
2953
2954 /* Emit the insns in a chain starting with INSN.
2955    Return the last insn emitted.  */
2956
2957 rtx
2958 emit_insns (insn)
2959      rtx insn;
2960 {
2961   rtx last = 0;
2962
2963   while (insn)
2964     {
2965       rtx next = NEXT_INSN (insn);
2966       add_insn (insn);
2967       last = insn;
2968       insn = next;
2969     }
2970
2971   return last;
2972 }
2973
2974 /* Emit the insns in a chain starting with INSN and place them in front of
2975    the insn BEFORE.  Return the last insn emitted.  */
2976
2977 rtx
2978 emit_insns_before (insn, before)
2979      rtx insn;
2980      rtx before;
2981 {
2982   rtx last = 0;
2983
2984   while (insn)
2985     {
2986       rtx next = NEXT_INSN (insn);
2987       add_insn_before (insn, before);
2988       last = insn;
2989       insn = next;
2990     }
2991
2992   return last;
2993 }
2994
2995 /* Emit the insns in a chain starting with FIRST and place them in back of
2996    the insn AFTER.  Return the last insn emitted.  */
2997
2998 rtx
2999 emit_insns_after (first, after)
3000      register rtx first;
3001      register rtx after;
3002 {
3003   register rtx last;
3004   register rtx after_after;
3005
3006   if (!after)
3007     abort ();
3008
3009   if (!first)
3010     return first;
3011
3012   for (last = first; NEXT_INSN (last); last = NEXT_INSN (last))
3013     continue;
3014
3015   after_after = NEXT_INSN (after);
3016
3017   NEXT_INSN (after) = first;
3018   PREV_INSN (first) = after;
3019   NEXT_INSN (last) = after_after;
3020   if (after_after)
3021     PREV_INSN (after_after) = last;
3022
3023   if (after == last_insn)
3024     last_insn = last;
3025   return last;
3026 }
3027
3028 /* Make an insn of code JUMP_INSN with pattern PATTERN
3029    and add it to the end of the doubly-linked list.  */
3030
3031 rtx
3032 emit_jump_insn (pattern)
3033      rtx pattern;
3034 {
3035   if (GET_CODE (pattern) == SEQUENCE)
3036     return emit_insn (pattern);
3037   else
3038     {
3039       register rtx insn = make_jump_insn_raw (pattern);
3040       add_insn (insn);
3041       return insn;
3042     }
3043 }
3044
3045 /* Make an insn of code CALL_INSN with pattern PATTERN
3046    and add it to the end of the doubly-linked list.  */
3047
3048 rtx
3049 emit_call_insn (pattern)
3050      rtx pattern;
3051 {
3052   if (GET_CODE (pattern) == SEQUENCE)
3053     return emit_insn (pattern);
3054   else
3055     {
3056       register rtx insn = make_call_insn_raw (pattern);
3057       add_insn (insn);
3058       PUT_CODE (insn, CALL_INSN);
3059       return insn;
3060     }
3061 }
3062
3063 /* Add the label LABEL to the end of the doubly-linked list.  */
3064
3065 rtx
3066 emit_label (label)
3067      rtx label;
3068 {
3069   /* This can be called twice for the same label
3070      as a result of the confusion that follows a syntax error!
3071      So make it harmless.  */
3072   if (INSN_UID (label) == 0)
3073     {
3074       INSN_UID (label) = cur_insn_uid++;
3075       add_insn (label);
3076     }
3077   return label;
3078 }
3079
3080 /* Make an insn of code BARRIER
3081    and add it to the end of the doubly-linked list.  */
3082
3083 rtx
3084 emit_barrier ()
3085 {
3086   register rtx barrier = rtx_alloc (BARRIER);
3087   INSN_UID (barrier) = cur_insn_uid++;
3088   add_insn (barrier);
3089   return barrier;
3090 }
3091
3092 /* Make an insn of code NOTE
3093    with data-fields specified by FILE and LINE
3094    and add it to the end of the doubly-linked list,
3095    but only if line-numbers are desired for debugging info.  */
3096
3097 rtx
3098 emit_line_note (file, line)
3099      char *file;
3100      int line;
3101 {
3102   set_file_and_line_for_stmt (file, line);
3103
3104 #if 0
3105   if (no_line_numbers)
3106     return 0;
3107 #endif
3108
3109   return emit_note (file, line);
3110 }
3111
3112 /* Make an insn of code NOTE
3113    with data-fields specified by FILE and LINE
3114    and add it to the end of the doubly-linked list.
3115    If it is a line-number NOTE, omit it if it matches the previous one.  */
3116
3117 rtx
3118 emit_note (file, line)
3119      char *file;
3120      int line;
3121 {
3122   register rtx note;
3123
3124   if (line > 0)
3125     {
3126       if (file && last_filename && !strcmp (file, last_filename)
3127           && line == last_linenum)
3128         return 0;
3129       last_filename = file;
3130       last_linenum = line;
3131     }
3132
3133   if (no_line_numbers && line > 0)
3134     {
3135       cur_insn_uid++;
3136       return 0;
3137     }
3138
3139   note = rtx_alloc (NOTE);
3140   INSN_UID (note) = cur_insn_uid++;
3141   NOTE_SOURCE_FILE (note) = file;
3142   NOTE_LINE_NUMBER (note) = line;
3143   add_insn (note);
3144   return note;
3145 }
3146
3147 /* Emit a NOTE, and don't omit it even if LINE is the previous note.  */
3148
3149 rtx
3150 emit_line_note_force (file, line)
3151      char *file;
3152      int line;
3153 {
3154   last_linenum = -1;
3155   return emit_line_note (file, line);
3156 }
3157
3158 /* Cause next statement to emit a line note even if the line number
3159    has not changed.  This is used at the beginning of a function.  */
3160
3161 void
3162 force_next_line_note ()
3163 {
3164   last_linenum = -1;
3165 }
3166
3167 /* Place a note of KIND on insn INSN with DATUM as the datum. If a
3168    note of this type already exists, remove it first. */
3169
3170 void
3171 set_unique_reg_note (insn, kind, datum)
3172      rtx insn;
3173      enum reg_note kind;
3174      rtx datum;
3175 {
3176   rtx note = find_reg_note (insn, kind, NULL_RTX);
3177
3178   /* First remove the note if there already is one.  */
3179   if (note)
3180     remove_note (insn, note);
3181
3182   REG_NOTES (insn) = gen_rtx_EXPR_LIST (kind, datum, REG_NOTES (insn));
3183 }
3184 \f
3185 /* Return an indication of which type of insn should have X as a body.
3186    The value is CODE_LABEL, INSN, CALL_INSN or JUMP_INSN.  */
3187
3188 enum rtx_code
3189 classify_insn (x)
3190      rtx x;
3191 {
3192   if (GET_CODE (x) == CODE_LABEL)
3193     return CODE_LABEL;
3194   if (GET_CODE (x) == CALL)
3195     return CALL_INSN;
3196   if (GET_CODE (x) == RETURN)
3197     return JUMP_INSN;
3198   if (GET_CODE (x) == SET)
3199     {
3200       if (SET_DEST (x) == pc_rtx)
3201         return JUMP_INSN;
3202       else if (GET_CODE (SET_SRC (x)) == CALL)
3203         return CALL_INSN;
3204       else
3205         return INSN;
3206     }
3207   if (GET_CODE (x) == PARALLEL)
3208     {
3209       register int j;
3210       for (j = XVECLEN (x, 0) - 1; j >= 0; j--)
3211         if (GET_CODE (XVECEXP (x, 0, j)) == CALL)
3212           return CALL_INSN;
3213         else if (GET_CODE (XVECEXP (x, 0, j)) == SET
3214                  && SET_DEST (XVECEXP (x, 0, j)) == pc_rtx)
3215           return JUMP_INSN;
3216         else if (GET_CODE (XVECEXP (x, 0, j)) == SET
3217                  && GET_CODE (SET_SRC (XVECEXP (x, 0, j))) == CALL)
3218           return CALL_INSN;
3219     }
3220   return INSN;
3221 }
3222
3223 /* Emit the rtl pattern X as an appropriate kind of insn.
3224    If X is a label, it is simply added into the insn chain.  */
3225
3226 rtx
3227 emit (x)
3228      rtx x;
3229 {
3230   enum rtx_code code = classify_insn (x);
3231
3232   if (code == CODE_LABEL)
3233     return emit_label (x);
3234   else if (code == INSN)
3235     return emit_insn (x);
3236   else if (code == JUMP_INSN)
3237     {
3238       register rtx insn = emit_jump_insn (x);
3239       if (simplejump_p (insn) || GET_CODE (x) == RETURN)
3240         return emit_barrier ();
3241       return insn;
3242     }
3243   else if (code == CALL_INSN)
3244     return emit_call_insn (x);
3245   else
3246     abort ();
3247 }
3248 \f
3249 /* Begin emitting insns to a sequence which can be packaged in an
3250    RTL_EXPR.  If this sequence will contain something that might cause
3251    the compiler to pop arguments to function calls (because those
3252    pops have previously been deferred; see INHIBIT_DEFER_POP for more
3253    details), use do_pending_stack_adjust before calling this function.
3254    That will ensure that the deferred pops are not accidentally
3255    emitted in the middel of this sequence.  */
3256
3257 void
3258 start_sequence ()
3259 {
3260   struct sequence_stack *tem;
3261
3262   tem = (struct sequence_stack *) xmalloc (sizeof (struct sequence_stack));
3263
3264   tem->next = seq_stack;
3265   tem->first = first_insn;
3266   tem->last = last_insn;
3267   tem->sequence_rtl_expr = seq_rtl_expr;
3268
3269   seq_stack = tem;
3270
3271   first_insn = 0;
3272   last_insn = 0;
3273 }
3274
3275 /* Similarly, but indicate that this sequence will be placed in T, an
3276    RTL_EXPR.  See the documentation for start_sequence for more
3277    information about how to use this function.  */
3278
3279 void
3280 start_sequence_for_rtl_expr (t)
3281      tree t;
3282 {
3283   start_sequence ();
3284
3285   seq_rtl_expr = t;
3286 }
3287
3288 /* Set up the insn chain starting with FIRST as the current sequence,
3289    saving the previously current one.  See the documentation for
3290    start_sequence for more information about how to use this function.  */
3291
3292 void
3293 push_to_sequence (first)
3294      rtx first;
3295 {
3296   rtx last;
3297
3298   start_sequence ();
3299
3300   for (last = first; last && NEXT_INSN (last); last = NEXT_INSN (last));
3301
3302   first_insn = first;
3303   last_insn = last;
3304 }
3305
3306 /* Set up the outer-level insn chain
3307    as the current sequence, saving the previously current one.  */
3308
3309 void
3310 push_topmost_sequence ()
3311 {
3312   struct sequence_stack *stack, *top = NULL;
3313
3314   start_sequence ();
3315
3316   for (stack = seq_stack; stack; stack = stack->next)
3317     top = stack;
3318
3319   first_insn = top->first;
3320   last_insn = top->last;
3321   seq_rtl_expr = top->sequence_rtl_expr;
3322 }
3323
3324 /* After emitting to the outer-level insn chain, update the outer-level
3325    insn chain, and restore the previous saved state.  */
3326
3327 void
3328 pop_topmost_sequence ()
3329 {
3330   struct sequence_stack *stack, *top = NULL;
3331
3332   for (stack = seq_stack; stack; stack = stack->next)
3333     top = stack;
3334
3335   top->first = first_insn;
3336   top->last = last_insn;
3337   /* ??? Why don't we save seq_rtl_expr here?  */
3338
3339   end_sequence ();
3340 }
3341
3342 /* After emitting to a sequence, restore previous saved state.
3343
3344    To get the contents of the sequence just made, you must call
3345    `gen_sequence' *before* calling here.
3346
3347    If the compiler might have deferred popping arguments while
3348    generating this sequence, and this sequence will not be immediately
3349    inserted into the instruction stream, use do_pending_stack_adjust
3350    before calling gen_sequence.  That will ensure that the deferred
3351    pops are inserted into this sequence, and not into some random
3352    location in the instruction stream.  See INHIBIT_DEFER_POP for more
3353    information about deferred popping of arguments.  */
3354
3355 void
3356 end_sequence ()
3357 {
3358   struct sequence_stack *tem = seq_stack;
3359
3360   first_insn = tem->first;
3361   last_insn = tem->last;
3362   seq_rtl_expr = tem->sequence_rtl_expr;
3363   seq_stack = tem->next;
3364
3365   free (tem);
3366 }
3367
3368 /* Return 1 if currently emitting into a sequence.  */
3369
3370 int
3371 in_sequence_p ()
3372 {
3373   return seq_stack != 0;
3374 }
3375
3376 /* Generate a SEQUENCE rtx containing the insns already emitted
3377    to the current sequence.
3378
3379    This is how the gen_... function from a DEFINE_EXPAND
3380    constructs the SEQUENCE that it returns.  */
3381
3382 rtx
3383 gen_sequence ()
3384 {
3385   rtx result;
3386   rtx tem;
3387   int i;
3388   int len;
3389
3390   /* Count the insns in the chain.  */
3391   len = 0;
3392   for (tem = first_insn; tem; tem = NEXT_INSN (tem))
3393     len++;
3394
3395   /* If only one insn, return it rather than a SEQUENCE.
3396      (Now that we cache SEQUENCE expressions, it isn't worth special-casing
3397      the case of an empty list.)
3398      We only return the pattern of an insn if its code is INSN and it
3399      has no notes.  This ensures that no information gets lost.  */
3400   if (len == 1
3401       && ! RTX_FRAME_RELATED_P (first_insn)
3402       && GET_CODE (first_insn) == INSN
3403       /* Don't throw away any reg notes. */
3404       && REG_NOTES (first_insn) == 0)
3405     {
3406       if (!ggc_p)
3407         {
3408           NEXT_INSN (first_insn) = free_insn;
3409           free_insn = first_insn;
3410         }
3411       return PATTERN (first_insn);
3412     }
3413
3414   /* Put them in a vector.  See if we already have a SEQUENCE of the
3415      appropriate length around.  */
3416   if (!ggc_p && len < SEQUENCE_RESULT_SIZE
3417       && (result = sequence_result[len]) != 0)
3418     sequence_result[len] = 0;
3419   else
3420     {
3421       /* Ensure that this rtl goes in saveable_obstack, since we may
3422          cache it.  */
3423       push_obstacks_nochange ();
3424       rtl_in_saveable_obstack ();
3425       result = gen_rtx_SEQUENCE (VOIDmode, rtvec_alloc (len));
3426       pop_obstacks ();
3427     }
3428
3429   for (i = 0, tem = first_insn; tem; tem = NEXT_INSN (tem), i++)
3430     XVECEXP (result, 0, i) = tem;
3431
3432   return result;
3433 }
3434 \f
3435 /* Put the various virtual registers into REGNO_REG_RTX.  */
3436
3437 void
3438 init_virtual_regs (es)
3439      struct emit_status *es;
3440 {
3441   rtx *ptr = es->x_regno_reg_rtx;
3442   ptr[VIRTUAL_INCOMING_ARGS_REGNUM] = virtual_incoming_args_rtx;
3443   ptr[VIRTUAL_STACK_VARS_REGNUM] = virtual_stack_vars_rtx;
3444   ptr[VIRTUAL_STACK_DYNAMIC_REGNUM] = virtual_stack_dynamic_rtx;
3445   ptr[VIRTUAL_OUTGOING_ARGS_REGNUM] = virtual_outgoing_args_rtx;
3446   ptr[VIRTUAL_CFA_REGNUM] = virtual_cfa_rtx;
3447 }
3448
3449 void
3450 clear_emit_caches ()
3451 {
3452   int i;
3453
3454   /* Clear the start_sequence/gen_sequence cache.  */
3455   for (i = 0; i < SEQUENCE_RESULT_SIZE; i++)
3456     sequence_result[i] = 0;
3457   free_insn = 0;
3458 }
3459 \f
3460 /* Used by copy_insn_1 to avoid copying SCRATCHes more than once.  */
3461 static rtx copy_insn_scratch_in[MAX_RECOG_OPERANDS];
3462 static rtx copy_insn_scratch_out[MAX_RECOG_OPERANDS];
3463 static int copy_insn_n_scratches;
3464
3465 /* When an insn is being copied by copy_insn_1, this is nonzero if we have
3466    copied an ASM_OPERANDS.
3467    In that case, it is the original input-operand vector.  */
3468 static rtvec orig_asm_operands_vector;
3469
3470 /* When an insn is being copied by copy_insn_1, this is nonzero if we have
3471    copied an ASM_OPERANDS.
3472    In that case, it is the copied input-operand vector.  */
3473 static rtvec copy_asm_operands_vector;
3474
3475 /* Likewise for the constraints vector.  */
3476 static rtvec orig_asm_constraints_vector;
3477 static rtvec copy_asm_constraints_vector;
3478
3479 /* Recursively create a new copy of an rtx for copy_insn.
3480    This function differs from copy_rtx in that it handles SCRATCHes and
3481    ASM_OPERANDs properly.
3482    Normally, this function is not used directly; use copy_insn as front end.
3483    However, you could first copy an insn pattern with copy_insn and then use
3484    this function afterwards to properly copy any REG_NOTEs containing
3485    SCRATCHes.  */
3486
3487 rtx
3488 copy_insn_1 (orig)
3489      register rtx orig;
3490 {
3491   register rtx copy;
3492   register int i, j;
3493   register RTX_CODE code;
3494   register const char *format_ptr;
3495
3496   code = GET_CODE (orig);
3497
3498   switch (code)
3499     {
3500     case REG:
3501     case QUEUED:
3502     case CONST_INT:
3503     case CONST_DOUBLE:
3504     case SYMBOL_REF:
3505     case CODE_LABEL:
3506     case PC:
3507     case CC0:
3508     case ADDRESSOF:
3509       return orig;
3510
3511     case SCRATCH:
3512       for (i = 0; i < copy_insn_n_scratches; i++)
3513         if (copy_insn_scratch_in[i] == orig)
3514           return copy_insn_scratch_out[i];
3515       break;
3516
3517     case CONST:
3518       /* CONST can be shared if it contains a SYMBOL_REF.  If it contains
3519          a LABEL_REF, it isn't sharable.  */
3520       if (GET_CODE (XEXP (orig, 0)) == PLUS
3521           && GET_CODE (XEXP (XEXP (orig, 0), 0)) == SYMBOL_REF
3522           && GET_CODE (XEXP (XEXP (orig, 0), 1)) == CONST_INT)
3523         return orig;
3524       break;
3525
3526       /* A MEM with a constant address is not sharable.  The problem is that
3527          the constant address may need to be reloaded.  If the mem is shared,
3528          then reloading one copy of this mem will cause all copies to appear
3529          to have been reloaded.  */
3530
3531     default:
3532       break;
3533     }
3534
3535   copy = rtx_alloc (code);
3536
3537   /* Copy the various flags, and other information.  We assume that
3538      all fields need copying, and then clear the fields that should
3539      not be copied.  That is the sensible default behavior, and forces
3540      us to explicitly document why we are *not* copying a flag.  */
3541   memcpy (copy, orig, sizeof (struct rtx_def) - sizeof (rtunion));
3542
3543   /* We do not copy the USED flag, which is used as a mark bit during
3544      walks over the RTL.  */
3545   copy->used = 0;
3546
3547   /* We do not copy JUMP, CALL, or FRAME_RELATED for INSNs.  */
3548   if (GET_RTX_CLASS (code) == 'i')
3549     {
3550       copy->jump = 0;
3551       copy->call = 0;
3552       copy->frame_related = 0;
3553     }
3554
3555   format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
3556
3557   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
3558     {
3559       copy->fld[i] = orig->fld[i];
3560       switch (*format_ptr++)
3561         {
3562         case 'e':
3563           if (XEXP (orig, i) != NULL)
3564             XEXP (copy, i) = copy_insn_1 (XEXP (orig, i));
3565           break;
3566
3567         case 'E':
3568         case 'V':
3569           if (XVEC (orig, i) == orig_asm_constraints_vector)
3570             XVEC (copy, i) = copy_asm_constraints_vector;
3571           else if (XVEC (orig, i) == orig_asm_operands_vector)
3572             XVEC (copy, i) = copy_asm_operands_vector;
3573           else if (XVEC (orig, i) != NULL)
3574             {
3575               XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
3576               for (j = 0; j < XVECLEN (copy, i); j++)
3577                 XVECEXP (copy, i, j) = copy_insn_1 (XVECEXP (orig, i, j));
3578             }
3579           break;
3580
3581         case 'b':
3582           {
3583             bitmap new_bits = BITMAP_OBSTACK_ALLOC (rtl_obstack);
3584             bitmap_copy (new_bits, XBITMAP (orig, i));
3585             XBITMAP (copy, i) = new_bits;
3586             break;
3587           }
3588
3589         case 't':
3590         case 'w':
3591         case 'i':
3592         case 's':
3593         case 'S':
3594         case 'u':
3595         case '0':
3596           /* These are left unchanged.  */
3597           break;
3598
3599         default:
3600           abort ();
3601         }
3602     }
3603
3604   if (code == SCRATCH)
3605     {
3606       i = copy_insn_n_scratches++;
3607       if (i >= MAX_RECOG_OPERANDS)
3608         abort ();
3609       copy_insn_scratch_in[i] = orig;
3610       copy_insn_scratch_out[i] = copy;
3611     }
3612   else if (code == ASM_OPERANDS)
3613     {
3614       orig_asm_operands_vector = XVEC (orig, 3);
3615       copy_asm_operands_vector = XVEC (copy, 3);
3616       orig_asm_constraints_vector = XVEC (orig, 4);
3617       copy_asm_constraints_vector = XVEC (copy, 4);
3618     }
3619
3620   return copy;
3621 }
3622
3623 /* Create a new copy of an rtx.
3624    This function differs from copy_rtx in that it handles SCRATCHes and
3625    ASM_OPERANDs properly.
3626    INSN doesn't really have to be a full INSN; it could be just the
3627    pattern.  */
3628 rtx
3629 copy_insn (insn)
3630      rtx insn;
3631 {
3632   copy_insn_n_scratches = 0;
3633   orig_asm_operands_vector = 0;
3634   orig_asm_constraints_vector = 0;
3635   copy_asm_operands_vector = 0;
3636   copy_asm_constraints_vector = 0;
3637   return copy_insn_1 (insn);
3638 }
3639
3640 /* Initialize data structures and variables in this file
3641    before generating rtl for each function.  */
3642
3643 void
3644 init_emit ()
3645 {
3646   struct function *f = cfun;
3647
3648   f->emit = (struct emit_status *) xmalloc (sizeof (struct emit_status));
3649   first_insn = NULL;
3650   last_insn = NULL;
3651   seq_rtl_expr = NULL;
3652   cur_insn_uid = 1;
3653   reg_rtx_no = LAST_VIRTUAL_REGISTER + 1;
3654   last_linenum = 0;
3655   last_filename = 0;
3656   first_label_num = label_num;
3657   last_label_num = 0;
3658   seq_stack = NULL;
3659
3660   clear_emit_caches ();
3661
3662   /* Init the tables that describe all the pseudo regs.  */
3663
3664   f->emit->regno_pointer_flag_length = LAST_VIRTUAL_REGISTER + 101;
3665
3666   f->emit->regno_pointer_flag
3667     = (char *) xcalloc (f->emit->regno_pointer_flag_length, sizeof (char));
3668
3669   f->emit->regno_pointer_align
3670     = (char *) xcalloc (f->emit->regno_pointer_flag_length,
3671                         sizeof (char));
3672
3673   regno_reg_rtx
3674     = (rtx *) xcalloc (f->emit->regno_pointer_flag_length * sizeof (rtx),
3675                        sizeof (rtx));
3676
3677   /* Put copies of all the virtual register rtx into regno_reg_rtx.  */
3678   init_virtual_regs (f->emit);
3679
3680   /* Indicate that the virtual registers and stack locations are
3681      all pointers.  */
3682   REGNO_POINTER_FLAG (STACK_POINTER_REGNUM) = 1;
3683   REGNO_POINTER_FLAG (FRAME_POINTER_REGNUM) = 1;
3684   REGNO_POINTER_FLAG (HARD_FRAME_POINTER_REGNUM) = 1;
3685   REGNO_POINTER_FLAG (ARG_POINTER_REGNUM) = 1;
3686
3687   REGNO_POINTER_FLAG (VIRTUAL_INCOMING_ARGS_REGNUM) = 1;
3688   REGNO_POINTER_FLAG (VIRTUAL_STACK_VARS_REGNUM) = 1;
3689   REGNO_POINTER_FLAG (VIRTUAL_STACK_DYNAMIC_REGNUM) = 1;
3690   REGNO_POINTER_FLAG (VIRTUAL_OUTGOING_ARGS_REGNUM) = 1;
3691   REGNO_POINTER_FLAG (VIRTUAL_CFA_REGNUM) = 1;
3692
3693 #ifdef STACK_BOUNDARY
3694   REGNO_POINTER_ALIGN (STACK_POINTER_REGNUM) = STACK_BOUNDARY / BITS_PER_UNIT;
3695   REGNO_POINTER_ALIGN (FRAME_POINTER_REGNUM) = STACK_BOUNDARY / BITS_PER_UNIT;
3696   REGNO_POINTER_ALIGN (HARD_FRAME_POINTER_REGNUM)
3697     = STACK_BOUNDARY / BITS_PER_UNIT;
3698   REGNO_POINTER_ALIGN (ARG_POINTER_REGNUM) = STACK_BOUNDARY / BITS_PER_UNIT;
3699
3700   REGNO_POINTER_ALIGN (VIRTUAL_INCOMING_ARGS_REGNUM)
3701     = STACK_BOUNDARY / BITS_PER_UNIT;
3702   REGNO_POINTER_ALIGN (VIRTUAL_STACK_VARS_REGNUM)
3703     = STACK_BOUNDARY / BITS_PER_UNIT;
3704   REGNO_POINTER_ALIGN (VIRTUAL_STACK_DYNAMIC_REGNUM)
3705     = STACK_BOUNDARY / BITS_PER_UNIT;
3706   REGNO_POINTER_ALIGN (VIRTUAL_OUTGOING_ARGS_REGNUM)
3707     = STACK_BOUNDARY / BITS_PER_UNIT;
3708   REGNO_POINTER_ALIGN (VIRTUAL_CFA_REGNUM) = UNITS_PER_WORD;
3709 #endif
3710
3711 #ifdef INIT_EXPANDERS
3712   INIT_EXPANDERS;
3713 #endif
3714 }
3715
3716 /* Mark SS for GC.  */
3717
3718 static void
3719 mark_sequence_stack (ss)
3720      struct sequence_stack *ss;
3721 {
3722   while (ss)
3723     {
3724       ggc_mark_rtx (ss->first);
3725       ggc_mark_tree (ss->sequence_rtl_expr);
3726       ss = ss->next;
3727     }
3728 }
3729
3730 /* Mark ES for GC.  */
3731
3732 void
3733 mark_emit_status (es)
3734      struct emit_status *es;
3735 {
3736   rtx *r;
3737   int i;
3738
3739   if (es == 0)
3740     return;
3741
3742   for (i = es->regno_pointer_flag_length, r = es->x_regno_reg_rtx;
3743        i > 0; --i, ++r)
3744     ggc_mark_rtx (*r);
3745
3746   mark_sequence_stack (es->sequence_stack);
3747   ggc_mark_tree (es->sequence_rtl_expr);
3748   ggc_mark_rtx (es->x_first_insn);
3749 }
3750
3751 /* Create some permanent unique rtl objects shared between all functions.
3752    LINE_NUMBERS is nonzero if line numbers are to be generated.  */
3753
3754 void
3755 init_emit_once (line_numbers)
3756      int line_numbers;
3757 {
3758   int i;
3759   enum machine_mode mode;
3760   enum machine_mode double_mode;
3761
3762   no_line_numbers = ! line_numbers;
3763
3764   /* Compute the word and byte modes.  */
3765
3766   byte_mode = VOIDmode;
3767   word_mode = VOIDmode;
3768   double_mode = VOIDmode;
3769
3770   for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
3771        mode = GET_MODE_WIDER_MODE (mode))
3772     {
3773       if (GET_MODE_BITSIZE (mode) == BITS_PER_UNIT
3774           && byte_mode == VOIDmode)
3775         byte_mode = mode;
3776
3777       if (GET_MODE_BITSIZE (mode) == BITS_PER_WORD
3778           && word_mode == VOIDmode)
3779         word_mode = mode;
3780     }
3781
3782 #ifndef DOUBLE_TYPE_SIZE
3783 #define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
3784 #endif
3785
3786   for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT); mode != VOIDmode;
3787        mode = GET_MODE_WIDER_MODE (mode))
3788     {
3789       if (GET_MODE_BITSIZE (mode) == DOUBLE_TYPE_SIZE
3790           && double_mode == VOIDmode)
3791         double_mode = mode;
3792     }
3793
3794   ptr_mode = mode_for_size (POINTER_SIZE, GET_MODE_CLASS (Pmode), 0);
3795
3796   /* Assign register numbers to the globally defined register rtx.
3797      This must be done at runtime because the register number field
3798      is in a union and some compilers can't initialize unions.  */
3799
3800   pc_rtx = gen_rtx (PC, VOIDmode);
3801   cc0_rtx = gen_rtx (CC0, VOIDmode);
3802   stack_pointer_rtx = gen_rtx_raw_REG (Pmode, STACK_POINTER_REGNUM);
3803   frame_pointer_rtx = gen_rtx_raw_REG (Pmode, FRAME_POINTER_REGNUM);
3804   if (hard_frame_pointer_rtx == 0)
3805     hard_frame_pointer_rtx = gen_rtx_raw_REG (Pmode,
3806                                               HARD_FRAME_POINTER_REGNUM);
3807   if (arg_pointer_rtx == 0)
3808     arg_pointer_rtx = gen_rtx_raw_REG (Pmode, ARG_POINTER_REGNUM);
3809   virtual_incoming_args_rtx =
3810     gen_rtx_raw_REG (Pmode, VIRTUAL_INCOMING_ARGS_REGNUM);
3811   virtual_stack_vars_rtx =
3812     gen_rtx_raw_REG (Pmode, VIRTUAL_STACK_VARS_REGNUM);
3813   virtual_stack_dynamic_rtx =
3814     gen_rtx_raw_REG (Pmode, VIRTUAL_STACK_DYNAMIC_REGNUM);
3815   virtual_outgoing_args_rtx =
3816     gen_rtx_raw_REG (Pmode, VIRTUAL_OUTGOING_ARGS_REGNUM);
3817   virtual_cfa_rtx = gen_rtx_raw_REG (Pmode, VIRTUAL_CFA_REGNUM);
3818
3819   /* These rtx must be roots if GC is enabled.  */
3820   if (ggc_p)
3821     ggc_add_rtx_root (global_rtl, GR_MAX);
3822
3823 #ifdef INIT_EXPANDERS
3824   /* This is to initialize save_machine_status and restore_machine_status before
3825      the first call to push_function_context_to.  This is needed by the Chill
3826      front end which calls push_function_context_to before the first cal to
3827      init_function_start.  */
3828   INIT_EXPANDERS;
3829 #endif
3830
3831   /* Create the unique rtx's for certain rtx codes and operand values.  */
3832
3833   /* Don't use gen_rtx here since gen_rtx in this case
3834      tries to use these variables.  */
3835   for (i = - MAX_SAVED_CONST_INT; i <= MAX_SAVED_CONST_INT; i++)
3836     const_int_rtx[i + MAX_SAVED_CONST_INT] =
3837       gen_rtx_raw_CONST_INT (VOIDmode, i);
3838   if (ggc_p)
3839     ggc_add_rtx_root (const_int_rtx, 2 * MAX_SAVED_CONST_INT + 1);
3840
3841   if (STORE_FLAG_VALUE >= - MAX_SAVED_CONST_INT
3842       && STORE_FLAG_VALUE <= MAX_SAVED_CONST_INT)
3843     const_true_rtx = const_int_rtx[STORE_FLAG_VALUE + MAX_SAVED_CONST_INT];
3844   else
3845     const_true_rtx = gen_rtx_CONST_INT (VOIDmode, STORE_FLAG_VALUE);
3846
3847   dconst0 = REAL_VALUE_ATOF ("0", double_mode);
3848   dconst1 = REAL_VALUE_ATOF ("1", double_mode);
3849   dconst2 = REAL_VALUE_ATOF ("2", double_mode);
3850   dconstm1 = REAL_VALUE_ATOF ("-1", double_mode);
3851
3852   for (i = 0; i <= 2; i++)
3853     {
3854       for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT); mode != VOIDmode;
3855            mode = GET_MODE_WIDER_MODE (mode))
3856         {
3857           rtx tem = rtx_alloc (CONST_DOUBLE);
3858           union real_extract u;
3859
3860           bzero ((char *) &u, sizeof u);  /* Zero any holes in a structure.  */
3861           u.d = i == 0 ? dconst0 : i == 1 ? dconst1 : dconst2;
3862
3863           bcopy ((char *) &u, (char *) &CONST_DOUBLE_LOW (tem), sizeof u);
3864           CONST_DOUBLE_MEM (tem) = cc0_rtx;
3865           PUT_MODE (tem, mode);
3866
3867           const_tiny_rtx[i][(int) mode] = tem;
3868         }
3869
3870       const_tiny_rtx[i][(int) VOIDmode] = GEN_INT (i);
3871
3872       for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
3873            mode = GET_MODE_WIDER_MODE (mode))
3874         const_tiny_rtx[i][(int) mode] = GEN_INT (i);
3875
3876       for (mode = GET_CLASS_NARROWEST_MODE (MODE_PARTIAL_INT);
3877            mode != VOIDmode;
3878            mode = GET_MODE_WIDER_MODE (mode))
3879         const_tiny_rtx[i][(int) mode] = GEN_INT (i);
3880     }
3881
3882   for (mode = CCmode; mode < MAX_MACHINE_MODE; ++mode)
3883     if (GET_MODE_CLASS (mode) == MODE_CC)
3884       const_tiny_rtx[0][(int) mode] = const0_rtx;
3885
3886   ggc_add_rtx_root (&const_tiny_rtx[0][0], sizeof(const_tiny_rtx)/sizeof(rtx));
3887   ggc_add_rtx_root (&const_true_rtx, 1);
3888
3889 #ifdef RETURN_ADDRESS_POINTER_REGNUM
3890   return_address_pointer_rtx
3891     = gen_rtx_raw_REG (Pmode, RETURN_ADDRESS_POINTER_REGNUM);
3892 #endif
3893
3894 #ifdef STRUCT_VALUE
3895   struct_value_rtx = STRUCT_VALUE;
3896 #else
3897   struct_value_rtx = gen_rtx_REG (Pmode, STRUCT_VALUE_REGNUM);
3898 #endif
3899
3900 #ifdef STRUCT_VALUE_INCOMING
3901   struct_value_incoming_rtx = STRUCT_VALUE_INCOMING;
3902 #else
3903 #ifdef STRUCT_VALUE_INCOMING_REGNUM
3904   struct_value_incoming_rtx
3905     = gen_rtx_REG (Pmode, STRUCT_VALUE_INCOMING_REGNUM);
3906 #else
3907   struct_value_incoming_rtx = struct_value_rtx;
3908 #endif
3909 #endif
3910
3911 #ifdef STATIC_CHAIN_REGNUM
3912   static_chain_rtx = gen_rtx_REG (Pmode, STATIC_CHAIN_REGNUM);
3913
3914 #ifdef STATIC_CHAIN_INCOMING_REGNUM
3915   if (STATIC_CHAIN_INCOMING_REGNUM != STATIC_CHAIN_REGNUM)
3916     static_chain_incoming_rtx
3917       = gen_rtx_REG (Pmode, STATIC_CHAIN_INCOMING_REGNUM);
3918   else
3919 #endif
3920     static_chain_incoming_rtx = static_chain_rtx;
3921 #endif
3922
3923 #ifdef STATIC_CHAIN
3924   static_chain_rtx = STATIC_CHAIN;
3925
3926 #ifdef STATIC_CHAIN_INCOMING
3927   static_chain_incoming_rtx = STATIC_CHAIN_INCOMING;
3928 #else
3929   static_chain_incoming_rtx = static_chain_rtx;
3930 #endif
3931 #endif
3932
3933 #ifdef PIC_OFFSET_TABLE_REGNUM
3934   pic_offset_table_rtx = gen_rtx_REG (Pmode, PIC_OFFSET_TABLE_REGNUM);
3935 #endif
3936
3937   ggc_add_rtx_root (&pic_offset_table_rtx, 1);
3938   ggc_add_rtx_root (&struct_value_rtx, 1);
3939   ggc_add_rtx_root (&struct_value_incoming_rtx, 1);
3940   ggc_add_rtx_root (&static_chain_rtx, 1);
3941   ggc_add_rtx_root (&static_chain_incoming_rtx, 1);
3942   ggc_add_rtx_root (&return_address_pointer_rtx, 1);
3943 }
3944 \f
3945 /* Query and clear/ restore no_line_numbers.  This is used by the
3946    switch / case handling in stmt.c to give proper line numbers in
3947    warnings about unreachable code.  */
3948
3949 int
3950 force_line_numbers ()
3951 {
3952   int old = no_line_numbers;
3953
3954   no_line_numbers = 0;
3955   if (old)
3956     force_next_line_note ();
3957   return old;
3958 }
3959
3960 void
3961 restore_line_number_status (old_value)
3962      int old_value;
3963 {
3964   no_line_numbers = old_value;
3965 }