gcc/emit-rtl.c

   1 /* Emit RTL for the GNU C-Compiler expander.
   2    Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.  */
  21
  22
  23 /* Middle-to-low level generation of rtx code and insns.
  24
  25    This file contains the functions `gen_rtx', `gen_reg_rtx'
  26    and `gen_label_rtx' that are the usual ways of creating rtl
  27    expressions for most purposes.
  28
  29    It also has the functions for creating insns and linking
  30    them in the doubly-linked chain.
  31
  32    The patterns of the insns are created by machine-dependent
  33    routines in insn-emit.c, which is generated automatically from
  34    the machine description.  These routines use `gen_rtx' to make
  35    the individual rtx's of the pattern; what is machine dependent
  36    is the kind of rtx's they make and what arguments they use.  */
  37
  38 #include "config.h"
  39 #include "system.h"
  40 #include "coretypes.h"
  41 #include "tm.h"
  42 #include "toplev.h"
  43 #include "rtl.h"
  44 #include "tree.h"
  45 #include "tm_p.h"
  46 #include "flags.h"
  47 #include "function.h"
  48 #include "expr.h"
  49 #include "regs.h"
  50 #include "hard-reg-set.h"
  51 #include "hashtab.h"
  52 #include "insn-config.h"
  53 #include "recog.h"
  54 #include "real.h"
  55 #include "bitmap.h"
  56 #include "basic-block.h"
  57 #include "ggc.h"
  58 #include "debug.h"
  59 #include "langhooks.h"
  60
  61 /* Commonly used modes.  */
  62
  63 enum machine_mode byte_mode;    /* Mode whose width is BITS_PER_UNIT.  */
  64 enum machine_mode word_mode;    /* Mode whose width is BITS_PER_WORD.  */
  65 enum machine_mode double_mode;  /* Mode whose width is DOUBLE_TYPE_SIZE.  */
  66 enum machine_mode ptr_mode;     /* Mode whose width is POINTER_SIZE.  */
  67
  68
  69 /* This is *not* reset after each function.  It gives each CODE_LABEL
  70    in the entire compilation a unique label number.  */
  71
  72 static GTY(()) int label_num = 1;
  73
  74 /* Highest label number in current function.
  75    Zero means use the value of label_num instead.
  76    This is nonzero only when belatedly compiling an inline function.  */
  77
  78 static int last_label_num;
  79
  80 /* Value label_num had when set_new_first_and_last_label_number was called.
  81    If label_num has not changed since then, last_label_num is valid.  */
  82
  83 static int base_label_num;
  84
  85 /* Nonzero means do not generate NOTEs for source line numbers.  */
  86
  87 static int no_line_numbers;
  88
  89 /* Commonly used rtx's, so that we only need space for one copy.
  90    These are initialized once for the entire compilation.
  91    All of these are unique; no other rtx-object will be equal to any
  92    of these.  */
  93
  94 rtx global_rtl[GR_MAX];
  95
  96 /* Commonly used RTL for hard registers.  These objects are not necessarily
  97    unique, so we allocate them separately from global_rtl.  They are
  98    initialized once per compilation unit, then copied into regno_reg_rtx
  99    at the beginning of each function.  */
 100 static GTY(()) rtx static_regno_reg_rtx[FIRST_PSEUDO_REGISTER];
 101
 102 /* We record floating-point CONST_DOUBLEs in each floating-point mode for
 103    the values of 0, 1, and 2.  For the integer entries and VOIDmode, we
 104    record a copy of const[012]_rtx.  */
 105
 106 rtx const_tiny_rtx[3][(int) MAX_MACHINE_MODE];
 107
 108 rtx const_true_rtx;
 109
 110 REAL_VALUE_TYPE dconst0;
 111 REAL_VALUE_TYPE dconst1;
 112 REAL_VALUE_TYPE dconst2;
 113 REAL_VALUE_TYPE dconstm1;
 114 REAL_VALUE_TYPE dconstm2;
 115 REAL_VALUE_TYPE dconsthalf;
 116
 117 /* All references to the following fixed hard registers go through
 118    these unique rtl objects.  On machines where the frame-pointer and
 119    arg-pointer are the same register, they use the same unique object.
 120
 121    After register allocation, other rtl objects which used to be pseudo-regs
 122    may be clobbered to refer to the frame-pointer register.
 123    But references that were originally to the frame-pointer can be
 124    distinguished from the others because they contain frame_pointer_rtx.
 125
 126    When to use frame_pointer_rtx and hard_frame_pointer_rtx is a little
 127    tricky: until register elimination has taken place hard_frame_pointer_rtx
 128    should be used if it is being set, and frame_pointer_rtx otherwise.  After
 129    register elimination hard_frame_pointer_rtx should always be used.
 130    On machines where the two registers are same (most) then these are the
 131    same.
 132
 133    In an inline procedure, the stack and frame pointer rtxs may not be
 134    used for anything else.  */
 135 rtx struct_value_rtx;           /* (REG:Pmode STRUCT_VALUE_REGNUM) */
 136 rtx struct_value_incoming_rtx;  /* (REG:Pmode STRUCT_VALUE_INCOMING_REGNUM) */
 137 rtx static_chain_rtx;           /* (REG:Pmode STATIC_CHAIN_REGNUM) */
 138 rtx static_chain_incoming_rtx;  /* (REG:Pmode STATIC_CHAIN_INCOMING_REGNUM) */
 139 rtx pic_offset_table_rtx;       /* (REG:Pmode PIC_OFFSET_TABLE_REGNUM) */
 140
 141 /* This is used to implement __builtin_return_address for some machines.
 142    See for instance the MIPS port.  */
 143 rtx return_address_pointer_rtx; /* (REG:Pmode RETURN_ADDRESS_POINTER_REGNUM) */
 144
 145 /* We make one copy of (const_int C) where C is in
 146    [- MAX_SAVED_CONST_INT, MAX_SAVED_CONST_INT]
 147    to save space during the compilation and simplify comparisons of
 148    integers.  */
 149
 150 rtx const_int_rtx[MAX_SAVED_CONST_INT * 2 + 1];
 151
 152 /* A hash table storing CONST_INTs whose absolute value is greater
 153    than MAX_SAVED_CONST_INT.  */
 154
 155 static GTY ((if_marked ("ggc_marked_p"), param_is (struct rtx_def)))
 156      htab_t const_int_htab;
 157
 158 /* A hash table storing memory attribute structures.  */
 159 static GTY ((if_marked ("ggc_marked_p"), param_is (struct mem_attrs)))
 160      htab_t mem_attrs_htab;
 161
 162 /* A hash table storing register attribute structures.  */
 163 static GTY ((if_marked ("ggc_marked_p"), param_is (struct reg_attrs)))
 164      htab_t reg_attrs_htab;
 165
 166 /* A hash table storing all CONST_DOUBLEs.  */
 167 static GTY ((if_marked ("ggc_marked_p"), param_is (struct rtx_def)))
 168      htab_t const_double_htab;
 169
 170 #define first_insn (cfun->emit->x_first_insn)
 171 #define last_insn (cfun->emit->x_last_insn)
 172 #define cur_insn_uid (cfun->emit->x_cur_insn_uid)
 173 #define last_linenum (cfun->emit->x_last_linenum)
 174 #define last_filename (cfun->emit->x_last_filename)
 175 #define first_label_num (cfun->emit->x_first_label_num)
 176
 177 static rtx make_jump_insn_raw           PARAMS ((rtx));
 178 static rtx make_call_insn_raw           PARAMS ((rtx));
 179 static rtx find_line_note               PARAMS ((rtx));
 180 static rtx change_address_1             PARAMS ((rtx, enum machine_mode, rtx,
 181                                                  int));
 182 static void unshare_all_rtl_1           PARAMS ((rtx));
 183 static void unshare_all_decls           PARAMS ((tree));
 184 static void reset_used_decls            PARAMS ((tree));
 185 static void mark_label_nuses            PARAMS ((rtx));
 186 static hashval_t const_int_htab_hash    PARAMS ((const void *));
 187 static int const_int_htab_eq            PARAMS ((const void *,
 188                                                  const void *));
 189 static hashval_t const_double_htab_hash PARAMS ((const void *));
 190 static int const_double_htab_eq         PARAMS ((const void *,
 191                                                  const void *));
 192 static rtx lookup_const_double          PARAMS ((rtx));
 193 static hashval_t mem_attrs_htab_hash    PARAMS ((const void *));
 194 static int mem_attrs_htab_eq            PARAMS ((const void *,
 195                                                  const void *));
 196 static mem_attrs *get_mem_attrs         PARAMS ((HOST_WIDE_INT, tree, rtx,
 197                                                  rtx, unsigned int,
 198                                                  enum machine_mode));
 199 static hashval_t reg_attrs_htab_hash    PARAMS ((const void *));
 200 static int reg_attrs_htab_eq            PARAMS ((const void *,
 201                                                  const void *));
 202 static reg_attrs *get_reg_attrs         PARAMS ((tree, int));
 203 static tree component_ref_for_mem_expr  PARAMS ((tree));
 204 static rtx gen_const_vector_0           PARAMS ((enum machine_mode));
 205
 206 /* Probability of the conditional branch currently proceeded by try_split.
 207    Set to -1 otherwise.  */
 208 int split_branch_probability = -1;
 209 \f
 210 /* Returns a hash code for X (which is a really a CONST_INT).  */
 211
 212 static hashval_t
 213 const_int_htab_hash (x)
 214      const void *x;
 215 {
 216   return (hashval_t) INTVAL ((struct rtx_def *) x);
 217 }
 218
 219 /* Returns nonzero if the value represented by X (which is really a
 220    CONST_INT) is the same as that given by Y (which is really a
 221    HOST_WIDE_INT *).  */
 222
 223 static int
 224 const_int_htab_eq (x, y)
 225      const void *x;
 226      const void *y;
 227 {
 228   return (INTVAL ((rtx) x) == *((const HOST_WIDE_INT *) y));
 229 }
 230
 231 /* Returns a hash code for X (which is really a CONST_DOUBLE).  */
 232 static hashval_t
 233 const_double_htab_hash (x)
 234      const void *x;
 235 {
 236   rtx value = (rtx) x;
 237   hashval_t h;
 238
 239   if (GET_MODE (value) == VOIDmode)
 240     h = CONST_DOUBLE_LOW (value) ^ CONST_DOUBLE_HIGH (value);
 241   else
 242     {
 243       h = real_hash (CONST_DOUBLE_REAL_VALUE (value));
 244       /* MODE is used in the comparison, so it should be in the hash.  */
 245       h ^= GET_MODE (value);
 246     }
 247   return h;
 248 }
 249
 250 /* Returns nonzero if the value represented by X (really a ...)
 251    is the same as that represented by Y (really a ...) */
 252 static int
 253 const_double_htab_eq (x, y)
 254      const void *x;
 255      const void *y;
 256 {
 257   rtx a = (rtx)x, b = (rtx)y;
 258
 259   if (GET_MODE (a) != GET_MODE (b))
 260     return 0;
 261   if (GET_MODE (a) == VOIDmode)
 262     return (CONST_DOUBLE_LOW (a) == CONST_DOUBLE_LOW (b)
 263             && CONST_DOUBLE_HIGH (a) == CONST_DOUBLE_HIGH (b));
 264   else
 265     return real_identical (CONST_DOUBLE_REAL_VALUE (a),
 266                            CONST_DOUBLE_REAL_VALUE (b));
 267 }
 268
 269 /* Returns a hash code for X (which is a really a mem_attrs *).  */
 270
 271 static hashval_t
 272 mem_attrs_htab_hash (x)
 273      const void *x;
 274 {
 275   mem_attrs *p = (mem_attrs *) x;
 276
 277   return (p->alias ^ (p->align * 1000)
 278           ^ ((p->offset ? INTVAL (p->offset) : 0) * 50000)
 279           ^ ((p->size ? INTVAL (p->size) : 0) * 2500000)
 280           ^ (size_t) p->expr);
 281 }
 282
 283 /* Returns nonzero if the value represented by X (which is really a
 284    mem_attrs *) is the same as that given by Y (which is also really a
 285    mem_attrs *).  */
 286
 287 static int
 288 mem_attrs_htab_eq (x, y)
 289      const void *x;
 290      const void *y;
 291 {
 292   mem_attrs *p = (mem_attrs *) x;
 293   mem_attrs *q = (mem_attrs *) y;
 294
 295   return (p->alias == q->alias && p->expr == q->expr && p->offset == q->offset
 296           && p->size == q->size && p->align == q->align);
 297 }
 298
 299 /* Allocate a new mem_attrs structure and insert it into the hash table if
 300    one identical to it is not already in the table.  We are doing this for
 301    MEM of mode MODE.  */
 302
 303 static mem_attrs *
 304 get_mem_attrs (alias, expr, offset, size, align, mode)
 305      HOST_WIDE_INT alias;
 306      tree expr;
 307      rtx offset;
 308      rtx size;
 309      unsigned int align;
 310      enum machine_mode mode;
 311 {
 312   mem_attrs attrs;
 313   void **slot;
 314
 315   /* If everything is the default, we can just return zero.
 316      This must match what the corresponding MEM_* macros return when the
 317      field is not present.  */
 318   if (alias == 0 && expr == 0 && offset == 0
 319       && (size == 0
 320           || (mode != BLKmode && GET_MODE_SIZE (mode) == INTVAL (size)))
 321       && (STRICT_ALIGNMENT && mode != BLKmode
 322           ? align == GET_MODE_ALIGNMENT (mode) : align == BITS_PER_UNIT))
 323     return 0;
 324
 325   attrs.alias = alias;
 326   attrs.expr = expr;
 327   attrs.offset = offset;
 328   attrs.size = size;
 329   attrs.align = align;
 330
 331   slot = htab_find_slot (mem_attrs_htab, &attrs, INSERT);
 332   if (*slot == 0)
 333     {
 334       *slot = ggc_alloc (sizeof (mem_attrs));
 335       memcpy (*slot, &attrs, sizeof (mem_attrs));
 336     }
 337
 338   return *slot;
 339 }
 340
 341 /* Returns a hash code for X (which is a really a reg_attrs *).  */
 342
 343 static hashval_t
 344 reg_attrs_htab_hash (x)
 345      const void *x;
 346 {
 347   reg_attrs *p = (reg_attrs *) x;
 348
 349   return ((p->offset * 1000) ^ (long) p->decl);
 350 }
 351
 352 /* Returns non-zero if the value represented by X (which is really a
 353    reg_attrs *) is the same as that given by Y (which is also really a
 354    reg_attrs *).  */
 355
 356 static int
 357 reg_attrs_htab_eq (x, y)
 358      const void *x;
 359      const void *y;
 360 {
 361   reg_attrs *p = (reg_attrs *) x;
 362   reg_attrs *q = (reg_attrs *) y;
 363
 364   return (p->decl == q->decl && p->offset == q->offset);
 365 }
 366 /* Allocate a new reg_attrs structure and insert it into the hash table if
 367    one identical to it is not already in the table.  We are doing this for
 368    MEM of mode MODE.  */
 369
 370 static reg_attrs *
 371 get_reg_attrs (decl, offset)
 372      tree decl;
 373      int offset;
 374 {
 375   reg_attrs attrs;
 376   void **slot;
 377
 378   /* If everything is the default, we can just return zero.  */
 379   if (decl == 0 && offset == 0)
 380     return 0;
 381
 382   attrs.decl = decl;
 383   attrs.offset = offset;
 384
 385   slot = htab_find_slot (reg_attrs_htab, &attrs, INSERT);
 386   if (*slot == 0)
 387     {
 388       *slot = ggc_alloc (sizeof (reg_attrs));
 389       memcpy (*slot, &attrs, sizeof (reg_attrs));
 390     }
 391
 392   return *slot;
 393 }
 394
 395 /* Generate a new REG rtx.  Make sure ORIGINAL_REGNO is set properly, and
 396    don't attempt to share with the various global pieces of rtl (such as
 397    frame_pointer_rtx).  */
 398
 399 rtx
 400 gen_raw_REG (mode, regno)
 401      enum machine_mode mode;
 402      int regno;
 403 {
 404   rtx x = gen_rtx_raw_REG (mode, regno);
 405   ORIGINAL_REGNO (x) = regno;
 406   return x;
 407 }
 408
 409 /* There are some RTL codes that require special attention; the generation
 410    functions do the raw handling.  If you add to this list, modify
 411    special_rtx in gengenrtl.c as well.  */
 412
 413 rtx
 414 gen_rtx_CONST_INT (mode, arg)
 415      enum machine_mode mode ATTRIBUTE_UNUSED;
 416      HOST_WIDE_INT arg;
 417 {
 418   void **slot;
 419
 420   if (arg >= - MAX_SAVED_CONST_INT && arg <= MAX_SAVED_CONST_INT)
 421     return const_int_rtx[arg + MAX_SAVED_CONST_INT];
 422
 423 #if STORE_FLAG_VALUE != 1 && STORE_FLAG_VALUE != -1
 424   if (const_true_rtx && arg == STORE_FLAG_VALUE)
 425     return const_true_rtx;
 426 #endif
 427
 428   /* Look up the CONST_INT in the hash table.  */
 429   slot = htab_find_slot_with_hash (const_int_htab, &arg,
 430                                    (hashval_t) arg, INSERT);
 431   if (*slot == 0)
 432     *slot = gen_rtx_raw_CONST_INT (VOIDmode, arg);
 433
 434   return (rtx) *slot;
 435 }
 436
 437 rtx
 438 gen_int_mode (c, mode)
 439      HOST_WIDE_INT c;
 440      enum machine_mode mode;
 441 {
 442   return GEN_INT (trunc_int_for_mode (c, mode));
 443 }
 444
 445 /* CONST_DOUBLEs might be created from pairs of integers, or from
 446    REAL_VALUE_TYPEs.  Also, their length is known only at run time,
 447    so we cannot use gen_rtx_raw_CONST_DOUBLE.  */
 448
 449 /* Determine whether REAL, a CONST_DOUBLE, already exists in the
 450    hash table.  If so, return its counterpart; otherwise add it
 451    to the hash table and return it.  */
 452 static rtx
 453 lookup_const_double (real)
 454      rtx real;
 455 {
 456   void **slot = htab_find_slot (const_double_htab, real, INSERT);
 457   if (*slot == 0)
 458     *slot = real;
 459
 460   return (rtx) *slot;
 461 }
 462
 463 /* Return a CONST_DOUBLE rtx for a floating-point value specified by
 464    VALUE in mode MODE.  */
 465 rtx
 466 const_double_from_real_value (value, mode)
 467      REAL_VALUE_TYPE value;
 468      enum machine_mode mode;
 469 {
 470   rtx real = rtx_alloc (CONST_DOUBLE);
 471   PUT_MODE (real, mode);
 472
 473   memcpy (&CONST_DOUBLE_LOW (real), &value, sizeof (REAL_VALUE_TYPE));
 474
 475   return lookup_const_double (real);
 476 }
 477
 478 /* Return a CONST_DOUBLE or CONST_INT for a value specified as a pair
 479    of ints: I0 is the low-order word and I1 is the high-order word.
 480    Do not use this routine for non-integer modes; convert to
 481    REAL_VALUE_TYPE and use CONST_DOUBLE_FROM_REAL_VALUE.  */
 482
 483 rtx
 484 immed_double_const (i0, i1, mode)
 485      HOST_WIDE_INT i0, i1;
 486      enum machine_mode mode;
 487 {
 488   rtx value;
 489   unsigned int i;
 490
 491   if (mode != VOIDmode)
 492     {
 493       int width;
 494       if (GET_MODE_CLASS (mode) != MODE_INT
 495           && GET_MODE_CLASS (mode) != MODE_PARTIAL_INT
 496           /* We can get a 0 for an error mark.  */
 497           && GET_MODE_CLASS (mode) != MODE_VECTOR_INT
 498           && GET_MODE_CLASS (mode) != MODE_VECTOR_FLOAT)
 499         abort ();
 500
 501       /* We clear out all bits that don't belong in MODE, unless they and
 502          our sign bit are all one.  So we get either a reasonable negative
 503          value or a reasonable unsigned value for this mode.  */
 504       width = GET_MODE_BITSIZE (mode);
 505       if (width < HOST_BITS_PER_WIDE_INT
 506           && ((i0 & ((HOST_WIDE_INT) (-1) << (width - 1)))
 507               != ((HOST_WIDE_INT) (-1) << (width - 1))))
 508         i0 &= ((HOST_WIDE_INT) 1 << width) - 1, i1 = 0;
 509       else if (width == HOST_BITS_PER_WIDE_INT
 510                && ! (i1 == ~0 && i0 < 0))
 511         i1 = 0;
 512       else if (width > 2 * HOST_BITS_PER_WIDE_INT)
 513         /* We cannot represent this value as a constant.  */
 514         abort ();
 515
 516       /* If this would be an entire word for the target, but is not for
 517          the host, then sign-extend on the host so that the number will
 518          look the same way on the host that it would on the target.
 519
 520          For example, when building a 64 bit alpha hosted 32 bit sparc
 521          targeted compiler, then we want the 32 bit unsigned value -1 to be
 522          represented as a 64 bit value -1, and not as 0x00000000ffffffff.
 523          The latter confuses the sparc backend.  */
 524
 525       if (width < HOST_BITS_PER_WIDE_INT
 526           && (i0 & ((HOST_WIDE_INT) 1 << (width - 1))))
 527         i0 |= ((HOST_WIDE_INT) (-1) << width);
 528
 529       /* If MODE fits within HOST_BITS_PER_WIDE_INT, always use a
 530          CONST_INT.
 531
 532          ??? Strictly speaking, this is wrong if we create a CONST_INT for
 533          a large unsigned constant with the size of MODE being
 534          HOST_BITS_PER_WIDE_INT and later try to interpret that constant
 535          in a wider mode.  In that case we will mis-interpret it as a
 536          negative number.
 537
 538          Unfortunately, the only alternative is to make a CONST_DOUBLE for
 539          any constant in any mode if it is an unsigned constant larger
 540          than the maximum signed integer in an int on the host.  However,
 541          doing this will break everyone that always expects to see a
 542          CONST_INT for SImode and smaller.
 543
 544          We have always been making CONST_INTs in this case, so nothing
 545          new is being broken.  */
 546
 547       if (width <= HOST_BITS_PER_WIDE_INT)
 548         i1 = (i0 < 0) ? ~(HOST_WIDE_INT) 0 : 0;
 549     }
 550
 551   /* If this integer fits in one word, return a CONST_INT.  */
 552   if ((i1 == 0 && i0 >= 0) || (i1 == ~0 && i0 < 0))
 553     return GEN_INT (i0);
 554
 555   /* We use VOIDmode for integers.  */
 556   value = rtx_alloc (CONST_DOUBLE);
 557   PUT_MODE (value, VOIDmode);
 558
 559   CONST_DOUBLE_LOW (value) = i0;
 560   CONST_DOUBLE_HIGH (value) = i1;
 561
 562   for (i = 2; i < (sizeof CONST_DOUBLE_FORMAT - 1); i++)
 563     XWINT (value, i) = 0;
 564
 565   return lookup_const_double (value);
 566 }
 567
 568 rtx
 569 gen_rtx_REG (mode, regno)
 570      enum machine_mode mode;
 571      unsigned int regno;
 572 {
 573   /* In case the MD file explicitly references the frame pointer, have
 574      all such references point to the same frame pointer.  This is
 575      used during frame pointer elimination to distinguish the explicit
 576      references to these registers from pseudos that happened to be
 577      assigned to them.
 578
 579      If we have eliminated the frame pointer or arg pointer, we will
 580      be using it as a normal register, for example as a spill
 581      register.  In such cases, we might be accessing it in a mode that
 582      is not Pmode and therefore cannot use the pre-allocated rtx.
 583
 584      Also don't do this when we are making new REGs in reload, since
 585      we don't want to get confused with the real pointers.  */
 586
 587   if (mode == Pmode && !reload_in_progress)
 588     {
 589       if (regno == FRAME_POINTER_REGNUM
 590           && (!reload_completed || frame_pointer_needed))
 591         return frame_pointer_rtx;
 592 #if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
 593       if (regno == HARD_FRAME_POINTER_REGNUM
 594           && (!reload_completed || frame_pointer_needed))
 595         return hard_frame_pointer_rtx;
 596 #endif
 597 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM && HARD_FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
 598       if (regno == ARG_POINTER_REGNUM)
 599         return arg_pointer_rtx;
 600 #endif
 601 #ifdef RETURN_ADDRESS_POINTER_REGNUM
 602       if (regno == RETURN_ADDRESS_POINTER_REGNUM)
 603         return return_address_pointer_rtx;
 604 #endif
 605       if (regno == (unsigned) PIC_OFFSET_TABLE_REGNUM
 606           && fixed_regs[PIC_OFFSET_TABLE_REGNUM])
 607         return pic_offset_table_rtx;
 608       if (regno == STACK_POINTER_REGNUM)
 609         return stack_pointer_rtx;
 610     }
 611
 612 #if 0
 613   /* If the per-function register table has been set up, try to re-use
 614      an existing entry in that table to avoid useless generation of RTL.
 615
 616      This code is disabled for now until we can fix the various backends
 617      which depend on having non-shared hard registers in some cases.   Long
 618      term we want to re-enable this code as it can significantly cut down
 619      on the amount of useless RTL that gets generated.
 620
 621      We'll also need to fix some code that runs after reload that wants to
 622      set ORIGINAL_REGNO.  */
 623
 624   if (cfun
 625       && cfun->emit
 626       && regno_reg_rtx
 627       && regno < FIRST_PSEUDO_REGISTER
 628       && reg_raw_mode[regno] == mode)
 629     return regno_reg_rtx[regno];
 630 #endif
 631
 632   return gen_raw_REG (mode, regno);
 633 }
 634
 635 rtx
 636 gen_rtx_MEM (mode, addr)
 637      enum machine_mode mode;
 638      rtx addr;
 639 {
 640   rtx rt = gen_rtx_raw_MEM (mode, addr);
 641
 642   /* This field is not cleared by the mere allocation of the rtx, so
 643      we clear it here.  */
 644   MEM_ATTRS (rt) = 0;
 645
 646   return rt;
 647 }
 648
 649 rtx
 650 gen_rtx_SUBREG (mode, reg, offset)
 651      enum machine_mode mode;
 652      rtx reg;
 653      int offset;
 654 {
 655   /* This is the most common failure type.
 656      Catch it early so we can see who does it.  */
 657   if ((offset % GET_MODE_SIZE (mode)) != 0)
 658     abort ();
 659
 660   /* This check isn't usable right now because combine will
 661      throw arbitrary crap like a CALL into a SUBREG in
 662      gen_lowpart_for_combine so we must just eat it.  */
 663 #if 0
 664   /* Check for this too.  */
 665   if (offset >= GET_MODE_SIZE (GET_MODE (reg)))
 666     abort ();
 667 #endif
 668   return gen_rtx_raw_SUBREG (mode, reg, offset);
 669 }
 670
 671 /* Generate a SUBREG representing the least-significant part of REG if MODE
 672    is smaller than mode of REG, otherwise paradoxical SUBREG.  */
 673
 674 rtx
 675 gen_lowpart_SUBREG (mode, reg)
 676      enum machine_mode mode;
 677      rtx reg;
 678 {
 679   enum machine_mode inmode;
 680
 681   inmode = GET_MODE (reg);
 682   if (inmode == VOIDmode)
 683     inmode = mode;
 684   return gen_rtx_SUBREG (mode, reg,
 685                          subreg_lowpart_offset (mode, inmode));
 686 }
 687 \f
 688 /* rtx gen_rtx (code, mode, [element1, ..., elementn])
 689 **
 690 **          This routine generates an RTX of the size specified by
 691 **      <code>, which is an RTX code.   The RTX structure is initialized
 692 **      from the arguments <element1> through <elementn>, which are
 693 **      interpreted according to the specific RTX type's format.   The
 694 **      special machine mode associated with the rtx (if any) is specified
 695 **      in <mode>.
 696 **
 697 **          gen_rtx can be invoked in a way which resembles the lisp-like
 698 **      rtx it will generate.   For example, the following rtx structure:
 699 **
 700 **            (plus:QI (mem:QI (reg:SI 1))
 701 **                     (mem:QI (plusw:SI (reg:SI 2) (reg:SI 3))))
 702 **
 703 **              ...would be generated by the following C code:
 704 **
 705 **              gen_rtx (PLUS, QImode,
 706 **                  gen_rtx (MEM, QImode,
 707 **                      gen_rtx (REG, SImode, 1)),
 708 **                  gen_rtx (MEM, QImode,
 709 **                      gen_rtx (PLUS, SImode,
 710 **                          gen_rtx (REG, SImode, 2),
 711 **                          gen_rtx (REG, SImode, 3)))),
 712 */
 713
 714 /*VARARGS2*/
 715 rtx
 716 gen_rtx VPARAMS ((enum rtx_code code, enum machine_mode mode, ...))
 717 {
 718   int i;                /* Array indices...                     */
 719   const char *fmt;      /* Current rtx's format...              */
 720   rtx rt_val;           /* RTX to return to caller...           */
 721
 722   VA_OPEN (p, mode);
 723   VA_FIXEDARG (p, enum rtx_code, code);
 724   VA_FIXEDARG (p, enum machine_mode, mode);
 725
 726   switch (code)
 727     {
 728     case CONST_INT:
 729       rt_val = gen_rtx_CONST_INT (mode, va_arg (p, HOST_WIDE_INT));
 730       break;
 731
 732     case CONST_DOUBLE:
 733       {
 734         HOST_WIDE_INT arg0 = va_arg (p, HOST_WIDE_INT);
 735         HOST_WIDE_INT arg1 = va_arg (p, HOST_WIDE_INT);
 736
 737         rt_val = immed_double_const (arg0, arg1, mode);
 738       }
 739       break;
 740
 741     case REG:
 742       rt_val = gen_rtx_REG (mode, va_arg (p, int));
 743       break;
 744
 745     case MEM:
 746       rt_val = gen_rtx_MEM (mode, va_arg (p, rtx));
 747       break;
 748
 749     default:
 750       rt_val = rtx_alloc (code);        /* Allocate the storage space.  */
 751       rt_val->mode = mode;              /* Store the machine mode...  */
 752
 753       fmt = GET_RTX_FORMAT (code);      /* Find the right format...  */
 754       for (i = 0; i < GET_RTX_LENGTH (code); i++)
 755         {
 756           switch (*fmt++)
 757             {
 758             case '0':           /* Field with unknown use.  Zero it.  */
 759               XEXP (rt_val, 1) = NULL_RTX;
 760               break;
 761
 762             case 'i':           /* An integer?  */
 763               XINT (rt_val, i) = va_arg (p, int);
 764               break;
 765
 766             case 'w':           /* A wide integer? */
 767               XWINT (rt_val, i) = va_arg (p, HOST_WIDE_INT);
 768               break;
 769
 770             case 's':           /* A string?  */
 771               XSTR (rt_val, i) = va_arg (p, char *);
 772               break;
 773
 774             case 'e':           /* An expression?  */
 775             case 'u':           /* An insn?  Same except when printing.  */
 776               XEXP (rt_val, i) = va_arg (p, rtx);
 777               break;
 778
 779             case 'E':           /* An RTX vector?  */
 780               XVEC (rt_val, i) = va_arg (p, rtvec);
 781               break;
 782
 783             case 'b':           /* A bitmap? */
 784               XBITMAP (rt_val, i) = va_arg (p, bitmap);
 785               break;
 786
 787             case 't':           /* A tree? */
 788               XTREE (rt_val, i) = va_arg (p, tree);
 789               break;
 790
 791             default:
 792               abort ();
 793             }
 794         }
 795       break;
 796     }
 797
 798   VA_CLOSE (p);
 799   return rt_val;
 800 }
 801
 802 /* gen_rtvec (n, [rt1, ..., rtn])
 803 **
 804 **          This routine creates an rtvec and stores within it the
 805 **      pointers to rtx's which are its arguments.
 806 */
 807
 808 /*VARARGS1*/
 809 rtvec
 810 gen_rtvec VPARAMS ((int n, ...))
 811 {
 812   int i, save_n;
 813   rtx *vector;
 814
 815   VA_OPEN (p, n);
 816   VA_FIXEDARG (p, int, n);
 817
 818   if (n == 0)
 819     return NULL_RTVEC;          /* Don't allocate an empty rtvec...     */
 820
 821   vector = (rtx *) alloca (n * sizeof (rtx));
 822
 823   for (i = 0; i < n; i++)
 824     vector[i] = va_arg (p, rtx);
 825
 826   /* The definition of VA_* in K&R C causes `n' to go out of scope.  */
 827   save_n = n;
 828   VA_CLOSE (p);
 829
 830   return gen_rtvec_v (save_n, vector);
 831 }
 832
 833 rtvec
 834 gen_rtvec_v (n, argp)
 835      int n;
 836      rtx *argp;
 837 {
 838   int i;
 839   rtvec rt_val;
 840
 841   if (n == 0)
 842     return NULL_RTVEC;          /* Don't allocate an empty rtvec...     */
 843
 844   rt_val = rtvec_alloc (n);     /* Allocate an rtvec...                 */
 845
 846   for (i = 0; i < n; i++)
 847     rt_val->elem[i] = *argp++;
 848
 849   return rt_val;
 850 }
 851 \f
 852 /* Generate a REG rtx for a new pseudo register of mode MODE.
 853    This pseudo is assigned the next sequential register number.  */
 854
 855 rtx
 856 gen_reg_rtx (mode)
 857      enum machine_mode mode;
 858 {
 859   struct function *f = cfun;
 860   rtx val;
 861
 862   /* Don't let anything called after initial flow analysis create new
 863      registers.  */
 864   if (no_new_pseudos)
 865     abort ();
 866
 867   if (generating_concat_p
 868       && (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT
 869           || GET_MODE_CLASS (mode) == MODE_COMPLEX_INT))
 870     {
 871       /* For complex modes, don't make a single pseudo.
 872          Instead, make a CONCAT of two pseudos.
 873          This allows noncontiguous allocation of the real and imaginary parts,
 874          which makes much better code.  Besides, allocating DCmode
 875          pseudos overstrains reload on some machines like the 386.  */
 876       rtx realpart, imagpart;
 877       enum machine_mode partmode = GET_MODE_INNER (mode);
 878
 879       realpart = gen_reg_rtx (partmode);
 880       imagpart = gen_reg_rtx (partmode);
 881       return gen_rtx_CONCAT (mode, realpart, imagpart);
 882     }
 883
 884   /* Make sure regno_pointer_align, and regno_reg_rtx are large
 885      enough to have an element for this pseudo reg number.  */
 886
 887   if (reg_rtx_no == f->emit->regno_pointer_align_length)
 888     {
 889       int old_size = f->emit->regno_pointer_align_length;
 890       char *new;
 891       rtx *new1;
 892
 893       new = ggc_realloc (f->emit->regno_pointer_align, old_size * 2);
 894       memset (new + old_size, 0, old_size);
 895       f->emit->regno_pointer_align = (unsigned char *) new;
 896
 897       new1 = (rtx *) ggc_realloc (f->emit->x_regno_reg_rtx,
 898                                   old_size * 2 * sizeof (rtx));
 899       memset (new1 + old_size, 0, old_size * sizeof (rtx));
 900       regno_reg_rtx = new1;
 901
 902       f->emit->regno_pointer_align_length = old_size * 2;
 903     }
 904
 905   val = gen_raw_REG (mode, reg_rtx_no);
 906   regno_reg_rtx[reg_rtx_no++] = val;
 907   return val;
 908 }
 909
 910 /* Generate an register with same attributes as REG,
 911    but offsetted by OFFSET.  */
 912
 913 rtx
 914 gen_rtx_REG_offset (reg, mode, regno, offset)
 915      enum machine_mode mode;
 916      unsigned int regno;
 917      int offset;
 918      rtx reg;
 919 {
 920   rtx new = gen_rtx_REG (mode, regno);
 921   REG_ATTRS (new) = get_reg_attrs (REG_EXPR (reg),
 922                                    REG_OFFSET (reg) + offset);
 923   return new;
 924 }
 925
 926 /* Set the decl for MEM to DECL.  */
 927
 928 void
 929 set_reg_attrs_from_mem (reg, mem)
 930      rtx reg;
 931      rtx mem;
 932 {
 933   if (MEM_OFFSET (mem) && GET_CODE (MEM_OFFSET (mem)) == CONST_INT)
 934     REG_ATTRS (reg)
 935       = get_reg_attrs (MEM_EXPR (mem), INTVAL (MEM_OFFSET (mem)));
 936 }
 937
 938 /* Set the register attributes for registers contained in PARM_RTX.
 939    Use needed values from memory attributes of MEM.  */
 940
 941 void
 942 set_reg_attrs_for_parm (parm_rtx, mem)
 943      rtx parm_rtx;
 944      rtx mem;
 945 {
 946   if (GET_CODE (parm_rtx) == REG)
 947     set_reg_attrs_from_mem (parm_rtx, mem);
 948   else if (GET_CODE (parm_rtx) == PARALLEL)
 949     {
 950       /* Check for a NULL entry in the first slot, used to indicate that the
 951          parameter goes both on the stack and in registers.  */
 952       int i = XEXP (XVECEXP (parm_rtx, 0, 0), 0) ? 0 : 1;
 953       for (; i < XVECLEN (parm_rtx, 0); i++)
 954         {
 955           rtx x = XVECEXP (parm_rtx, 0, i);
 956           if (GET_CODE (XEXP (x, 0)) == REG)
 957             REG_ATTRS (XEXP (x, 0))
 958               = get_reg_attrs (MEM_EXPR (mem),
 959                                INTVAL (XEXP (x, 1)));
 960         }
 961     }
 962 }
 963
 964 /* Assign the RTX X to declaration T.  */
 965 void
 966 set_decl_rtl (t, x)
 967      tree t;
 968      rtx x;
 969 {
 970   DECL_CHECK (t)->decl.rtl = x;
 971
 972   if (!x)
 973     return;
 974   /* For register, we maitain the reverse information too.  */
 975   if (GET_CODE (x) == REG)
 976     REG_ATTRS (x) = get_reg_attrs (t, 0);
 977   else if (GET_CODE (x) == SUBREG)
 978     REG_ATTRS (SUBREG_REG (x))
 979       = get_reg_attrs (t, -SUBREG_BYTE (x));
 980   if (GET_CODE (x) == CONCAT)
 981     {
 982       if (REG_P (XEXP (x, 0)))
 983         REG_ATTRS (XEXP (x, 0)) = get_reg_attrs (t, 0);
 984       if (REG_P (XEXP (x, 1)))
 985         REG_ATTRS (XEXP (x, 1))
 986           = get_reg_attrs (t, GET_MODE_UNIT_SIZE (GET_MODE (XEXP (x, 0))));
 987     }
 988   if (GET_CODE (x) == PARALLEL)
 989     {
 990       int i;
 991       for (i = 0; i < XVECLEN (x, 0); i++)
 992         {
 993           rtx y = XVECEXP (x, 0, i);
 994           if (REG_P (XEXP (y, 0)))
 995             REG_ATTRS (XEXP (y, 0)) = get_reg_attrs (t, INTVAL (XEXP (y, 1)));
 996         }
 997     }
 998 }
 999
1000 /* Identify REG (which may be a CONCAT) as a user register.  */
1001
1002 void
1003 mark_user_reg (reg)
1004      rtx reg;
1005 {
1006   if (GET_CODE (reg) == CONCAT)
1007     {
1008       REG_USERVAR_P (XEXP (reg, 0)) = 1;
1009       REG_USERVAR_P (XEXP (reg, 1)) = 1;
1010     }
1011   else if (GET_CODE (reg) == REG)
1012     REG_USERVAR_P (reg) = 1;
1013   else
1014     abort ();
1015 }
1016
1017 /* Identify REG as a probable pointer register and show its alignment
1018    as ALIGN, if nonzero.  */
1019
1020 void
1021 mark_reg_pointer (reg, align)
1022      rtx reg;
1023      int align;
1024 {
1025   if (! REG_POINTER (reg))
1026     {
1027       REG_POINTER (reg) = 1;
1028
1029       if (align)
1030         REGNO_POINTER_ALIGN (REGNO (reg)) = align;
1031     }
1032   else if (align && align < REGNO_POINTER_ALIGN (REGNO (reg)))
1033     /* We can no-longer be sure just how aligned this pointer is */
1034     REGNO_POINTER_ALIGN (REGNO (reg)) = align;
1035 }
1036
1037 /* Return 1 plus largest pseudo reg number used in the current function.  */
1038
1039 int
1040 max_reg_num ()
1041 {
1042   return reg_rtx_no;
1043 }
1044
1045 /* Return 1 + the largest label number used so far in the current function.  */
1046
1047 int
1048 max_label_num ()
1049 {
1050   if (last_label_num && label_num == base_label_num)
1051     return last_label_num;
1052   return label_num;
1053 }
1054
1055 /* Return first label number used in this function (if any were used).  */
1056
1057 int
1058 get_first_label_num ()
1059 {
1060   return first_label_num;
1061 }
1062 \f
1063 /* Return the final regno of X, which is a SUBREG of a hard
1064    register.  */
1065 int
1066 subreg_hard_regno (x, check_mode)
1067      rtx x;
1068      int check_mode;
1069 {
1070   enum machine_mode mode = GET_MODE (x);
1071   unsigned int byte_offset, base_regno, final_regno;
1072   rtx reg = SUBREG_REG (x);
1073
1074   /* This is where we attempt to catch illegal subregs
1075      created by the compiler.  */
1076   if (GET_CODE (x) != SUBREG
1077       || GET_CODE (reg) != REG)
1078     abort ();
1079   base_regno = REGNO (reg);
1080   if (base_regno >= FIRST_PSEUDO_REGISTER)
1081     abort ();
1082   if (check_mode && ! HARD_REGNO_MODE_OK (base_regno, GET_MODE (reg)))
1083     abort ();
1084
1085   /* Catch non-congruent offsets too.  */
1086   byte_offset = SUBREG_BYTE (x);
1087   if ((byte_offset % GET_MODE_SIZE (mode)) != 0)
1088     abort ();
1089
1090   final_regno = subreg_regno (x);
1091
1092   return final_regno;
1093 }
1094
1095 /* Return a value representing some low-order bits of X, where the number
1096    of low-order bits is given by MODE.  Note that no conversion is done
1097    between floating-point and fixed-point values, rather, the bit
1098    representation is returned.
1099
1100    This function handles the cases in common between gen_lowpart, below,
1101    and two variants in cse.c and combine.c.  These are the cases that can
1102    be safely handled at all points in the compilation.
1103
1104    If this is not a case we can handle, return 0.  */
1105
1106 rtx
1107 gen_lowpart_common (mode, x)
1108      enum machine_mode mode;
1109      rtx x;
1110 {
1111   int msize = GET_MODE_SIZE (mode);
1112   int xsize = GET_MODE_SIZE (GET_MODE (x));
1113   int offset = 0;
1114
1115   if (GET_MODE (x) == mode)
1116     return x;
1117
1118   /* MODE must occupy no more words than the mode of X.  */
1119   if (GET_MODE (x) != VOIDmode
1120       && ((msize + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD
1121           > ((xsize + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)))
1122     return 0;
1123
1124   /* Don't allow generating paradoxical FLOAT_MODE subregs.  */
1125   if (GET_MODE_CLASS (mode) == MODE_FLOAT
1126       && GET_MODE (x) != VOIDmode && msize > xsize)
1127     return 0;
1128
1129   offset = subreg_lowpart_offset (mode, GET_MODE (x));
1130
1131   if ((GET_CODE (x) == ZERO_EXTEND || GET_CODE (x) == SIGN_EXTEND)
1132       && (GET_MODE_CLASS (mode) == MODE_INT
1133           || GET_MODE_CLASS (mode) == MODE_PARTIAL_INT))
1134     {
1135       /* If we are getting the low-order part of something that has been
1136          sign- or zero-extended, we can either just use the object being
1137          extended or make a narrower extension.  If we want an even smaller
1138          piece than the size of the object being extended, call ourselves
1139          recursively.
1140
1141          This case is used mostly by combine and cse.  */
1142
1143       if (GET_MODE (XEXP (x, 0)) == mode)
1144         return XEXP (x, 0);
1145       else if (GET_MODE_SIZE (mode) < GET_MODE_SIZE (GET_MODE (XEXP (x, 0))))
1146         return gen_lowpart_common (mode, XEXP (x, 0));
1147       else if (GET_MODE_SIZE (mode) < GET_MODE_SIZE (GET_MODE (x)))
1148         return gen_rtx_fmt_e (GET_CODE (x), mode, XEXP (x, 0));
1149     }
1150   else if (GET_CODE (x) == SUBREG || GET_CODE (x) == REG
1151            || GET_CODE (x) == CONCAT || GET_CODE (x) == CONST_VECTOR)
1152     return simplify_gen_subreg (mode, x, GET_MODE (x), offset);
1153   else if ((GET_MODE_CLASS (mode) == MODE_VECTOR_INT
1154             || GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT)
1155            && GET_MODE (x) == VOIDmode)
1156     return simplify_gen_subreg (mode, x, int_mode_for_mode (mode), offset);
1157   /* If X is a CONST_INT or a CONST_DOUBLE, extract the appropriate bits
1158      from the low-order part of the constant.  */
1159   else if ((GET_MODE_CLASS (mode) == MODE_INT
1160             || GET_MODE_CLASS (mode) == MODE_PARTIAL_INT)
1161            && GET_MODE (x) == VOIDmode
1162            && (GET_CODE (x) == CONST_INT || GET_CODE (x) == CONST_DOUBLE))
1163     {
1164       /* If MODE is twice the host word size, X is already the desired
1165          representation.  Otherwise, if MODE is wider than a word, we can't
1166          do this.  If MODE is exactly a word, return just one CONST_INT.  */
1167
1168       if (GET_MODE_BITSIZE (mode) >= 2 * HOST_BITS_PER_WIDE_INT)
1169         return x;
1170       else if (GET_MODE_BITSIZE (mode) > HOST_BITS_PER_WIDE_INT)
1171         return 0;
1172       else if (GET_MODE_BITSIZE (mode) == HOST_BITS_PER_WIDE_INT)
1173         return (GET_CODE (x) == CONST_INT ? x
1174                 : GEN_INT (CONST_DOUBLE_LOW (x)));
1175       else
1176         {
1177           /* MODE must be narrower than HOST_BITS_PER_WIDE_INT.  */
1178           HOST_WIDE_INT val = (GET_CODE (x) == CONST_INT ? INTVAL (x)
1179                                : CONST_DOUBLE_LOW (x));
1180
1181           /* Sign extend to HOST_WIDE_INT.  */
1182           val = trunc_int_for_mode (val, mode);
1183
1184           return (GET_CODE (x) == CONST_INT && INTVAL (x) == val ? x
1185                   : GEN_INT (val));
1186         }
1187     }
1188
1189   /* The floating-point emulator can handle all conversions between
1190      FP and integer operands.  This simplifies reload because it
1191      doesn't have to deal with constructs like (subreg:DI
1192      (const_double:SF ...)) or (subreg:DF (const_int ...)).  */
1193   /* Single-precision floats are always 32-bits and double-precision
1194      floats are always 64-bits.  */
1195
1196   else if (GET_MODE_CLASS (mode) == MODE_FLOAT
1197            && GET_MODE_BITSIZE (mode) == 32
1198            && GET_CODE (x) == CONST_INT)
1199     {
1200       REAL_VALUE_TYPE r;
1201       long i = INTVAL (x);
1202
1203       real_from_target (&r, &i, mode);
1204       return CONST_DOUBLE_FROM_REAL_VALUE (r, mode);
1205     }
1206   else if (GET_MODE_CLASS (mode) == MODE_FLOAT
1207            && GET_MODE_BITSIZE (mode) == 64
1208            && (GET_CODE (x) == CONST_INT || GET_CODE (x) == CONST_DOUBLE)
1209            && GET_MODE (x) == VOIDmode)
1210     {
1211       REAL_VALUE_TYPE r;
1212       HOST_WIDE_INT low, high;
1213       long i[2];
1214
1215       if (GET_CODE (x) == CONST_INT)
1216         {
1217           low = INTVAL (x);
1218           high = low >> (HOST_BITS_PER_WIDE_INT - 1);
1219         }
1220       else
1221         {
1222           low = CONST_DOUBLE_LOW (x);
1223           high = CONST_DOUBLE_HIGH (x);
1224         }
1225
1226       if (HOST_BITS_PER_WIDE_INT > 32)
1227         high = low >> 31 >> 1;
1228
1229       /* REAL_VALUE_TARGET_DOUBLE takes the addressing order of the
1230          target machine.  */
1231       if (WORDS_BIG_ENDIAN)
1232         i[0] = high, i[1] = low;
1233       else
1234         i[0] = low, i[1] = high;
1235
1236       real_from_target (&r, i, mode);
1237       return CONST_DOUBLE_FROM_REAL_VALUE (r, mode);
1238     }
1239   else if ((GET_MODE_CLASS (mode) == MODE_INT
1240             || GET_MODE_CLASS (mode) == MODE_PARTIAL_INT)
1241            && GET_CODE (x) == CONST_DOUBLE
1242            && GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
1243     {
1244       REAL_VALUE_TYPE r;
1245       long i[4];  /* Only the low 32 bits of each 'long' are used.  */
1246       int endian = WORDS_BIG_ENDIAN ? 1 : 0;
1247
1248       /* Convert 'r' into an array of four 32-bit words in target word
1249          order.  */
1250       REAL_VALUE_FROM_CONST_DOUBLE (r, x);
1251       switch (GET_MODE_BITSIZE (GET_MODE (x)))
1252         {
1253         case 32:
1254           REAL_VALUE_TO_TARGET_SINGLE (r, i[3 * endian]);
1255           i[1] = 0;
1256           i[2] = 0;
1257           i[3 - 3 * endian] = 0;
1258           break;
1259         case 64:
1260           REAL_VALUE_TO_TARGET_DOUBLE (r, i + 2 * endian);
1261           i[2 - 2 * endian] = 0;
1262           i[3 - 2 * endian] = 0;
1263           break;
1264         case 96:
1265           REAL_VALUE_TO_TARGET_LONG_DOUBLE (r, i + endian);
1266           i[3 - 3 * endian] = 0;
1267           break;
1268         case 128:
1269           REAL_VALUE_TO_TARGET_LONG_DOUBLE (r, i);
1270           break;
1271         default:
1272           abort ();
1273         }
1274       /* Now, pack the 32-bit elements of the array into a CONST_DOUBLE
1275          and return it.  */
1276 #if HOST_BITS_PER_WIDE_INT == 32
1277       return immed_double_const (i[3 * endian], i[1 + endian], mode);
1278 #else
1279       if (HOST_BITS_PER_WIDE_INT != 64)
1280         abort ();
1281
1282       return immed_double_const ((((unsigned long) i[3 * endian])
1283                                   | ((HOST_WIDE_INT) i[1 + endian] << 32)),
1284                                  (((unsigned long) i[2 - endian])
1285                                   | ((HOST_WIDE_INT) i[3 - 3 * endian] << 32)),
1286                                  mode);
1287 #endif
1288     }
1289
1290   /* Otherwise, we can't do this.  */
1291   return 0;
1292 }
1293 \f
1294 /* Return the real part (which has mode MODE) of a complex value X.
1295    This always comes at the low address in memory.  */
1296
1297 rtx
1298 gen_realpart (mode, x)
1299      enum machine_mode mode;
1300      rtx x;
1301 {
1302   if (WORDS_BIG_ENDIAN
1303       && GET_MODE_BITSIZE (mode) < BITS_PER_WORD
1304       && REG_P (x)
1305       && REGNO (x) < FIRST_PSEUDO_REGISTER)
1306     internal_error
1307       ("can't access real part of complex value in hard register");
1308   else if (WORDS_BIG_ENDIAN)
1309     return gen_highpart (mode, x);
1310   else
1311     return gen_lowpart (mode, x);
1312 }
1313
1314 /* Return the imaginary part (which has mode MODE) of a complex value X.
1315    This always comes at the high address in memory.  */
1316
1317 rtx
1318 gen_imagpart (mode, x)
1319      enum machine_mode mode;
1320      rtx x;
1321 {
1322   if (WORDS_BIG_ENDIAN)
1323     return gen_lowpart (mode, x);
1324   else if (! WORDS_BIG_ENDIAN
1325            && GET_MODE_BITSIZE (mode) < BITS_PER_WORD
1326            && REG_P (x)
1327            && REGNO (x) < FIRST_PSEUDO_REGISTER)
1328     internal_error
1329       ("can't access imaginary part of complex value in hard register");
1330   else
1331     return gen_highpart (mode, x);
1332 }
1333
1334 /* Return 1 iff X, assumed to be a SUBREG,
1335    refers to the real part of the complex value in its containing reg.
1336    Complex values are always stored with the real part in the first word,
1337    regardless of WORDS_BIG_ENDIAN.  */
1338
1339 int
1340 subreg_realpart_p (x)
1341      rtx x;
1342 {
1343   if (GET_CODE (x) != SUBREG)
1344     abort ();
1345
1346   return ((unsigned int) SUBREG_BYTE (x)
1347           < GET_MODE_UNIT_SIZE (GET_MODE (SUBREG_REG (x))));
1348 }
1349 \f
1350 /* Assuming that X is an rtx (e.g., MEM, REG or SUBREG) for a value,
1351    return an rtx (MEM, SUBREG, or CONST_INT) that refers to the
1352    least-significant part of X.
1353    MODE specifies how big a part of X to return;
1354    it usually should not be larger than a word.
1355    If X is a MEM whose address is a QUEUED, the value may be so also.  */
1356
1357 rtx
1358 gen_lowpart (mode, x)
1359      enum machine_mode mode;
1360      rtx x;
1361 {
1362   rtx result = gen_lowpart_common (mode, x);
1363
1364   if (result)
1365     return result;
1366   else if (GET_CODE (x) == REG)
1367     {
1368       /* Must be a hard reg that's not valid in MODE.  */
1369       result = gen_lowpart_common (mode, copy_to_reg (x));
1370       if (result == 0)
1371         abort ();
1372       return result;
1373     }
1374   else if (GET_CODE (x) == MEM)
1375     {
1376       /* The only additional case we can do is MEM.  */
1377       int offset = 0;
1378
1379       /* The following exposes the use of "x" to CSE.  */
1380       if (GET_MODE_SIZE (GET_MODE (x)) <= UNITS_PER_WORD
1381           && SCALAR_INT_MODE_P (GET_MODE (x))
1382           && ! no_new_pseudos)
1383         return gen_lowpart (mode, force_reg (GET_MODE (x), x));
1384
1385       if (WORDS_BIG_ENDIAN)
1386         offset = (MAX (GET_MODE_SIZE (GET_MODE (x)), UNITS_PER_WORD)
1387                   - MAX (GET_MODE_SIZE (mode), UNITS_PER_WORD));
1388
1389       if (BYTES_BIG_ENDIAN)
1390         /* Adjust the address so that the address-after-the-data
1391            is unchanged.  */
1392         offset -= (MIN (UNITS_PER_WORD, GET_MODE_SIZE (mode))
1393                    - MIN (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (x))));
1394
1395       return adjust_address (x, mode, offset);
1396     }
1397   else if (GET_CODE (x) == ADDRESSOF)
1398     return gen_lowpart (mode, force_reg (GET_MODE (x), x));
1399   else
1400     abort ();
1401 }
1402
1403 /* Like `gen_lowpart', but refer to the most significant part.
1404    This is used to access the imaginary part of a complex number.  */
1405
1406 rtx
1407 gen_highpart (mode, x)
1408      enum machine_mode mode;
1409      rtx x;
1410 {
1411   unsigned int msize = GET_MODE_SIZE (mode);
1412   rtx result;
1413
1414   /* This case loses if X is a subreg.  To catch bugs early,
1415      complain if an invalid MODE is used even in other cases.  */
1416   if (msize > UNITS_PER_WORD
1417       && msize != GET_MODE_UNIT_SIZE (GET_MODE (x)))
1418     abort ();
1419
1420   result = simplify_gen_subreg (mode, x, GET_MODE (x),
1421                                 subreg_highpart_offset (mode, GET_MODE (x)));
1422
1423   /* simplify_gen_subreg is not guaranteed to return a valid operand for
1424      the target if we have a MEM.  gen_highpart must return a valid operand,
1425      emitting code if necessary to do so.  */
1426   if (result != NULL_RTX && GET_CODE (result) == MEM)
1427     result = validize_mem (result);
1428
1429   if (!result)
1430     abort ();
1431   return result;
1432 }
1433
1434 /* Like gen_highpart, but accept mode of EXP operand in case EXP can
1435    be VOIDmode constant.  */
1436 rtx
1437 gen_highpart_mode (outermode, innermode, exp)
1438      enum machine_mode outermode, innermode;
1439      rtx exp;
1440 {
1441   if (GET_MODE (exp) != VOIDmode)
1442     {
1443       if (GET_MODE (exp) != innermode)
1444         abort ();
1445       return gen_highpart (outermode, exp);
1446     }
1447   return simplify_gen_subreg (outermode, exp, innermode,
1448                               subreg_highpart_offset (outermode, innermode));
1449 }
1450
1451 /* Return offset in bytes to get OUTERMODE low part
1452    of the value in mode INNERMODE stored in memory in target format.  */
1453
1454 unsigned int
1455 subreg_lowpart_offset (outermode, innermode)
1456      enum machine_mode outermode, innermode;
1457 {
1458   unsigned int offset = 0;
1459   int difference = (GET_MODE_SIZE (innermode) - GET_MODE_SIZE (outermode));
1460
1461   if (difference > 0)
1462     {
1463       if (WORDS_BIG_ENDIAN)
1464         offset += (difference / UNITS_PER_WORD) * UNITS_PER_WORD;
1465       if (BYTES_BIG_ENDIAN)
1466         offset += difference % UNITS_PER_WORD;
1467     }
1468
1469   return offset;
1470 }
1471
1472 /* Return offset in bytes to get OUTERMODE high part
1473    of the value in mode INNERMODE stored in memory in target format.  */
1474 unsigned int
1475 subreg_highpart_offset (outermode, innermode)
1476      enum machine_mode outermode, innermode;
1477 {
1478   unsigned int offset = 0;
1479   int difference = (GET_MODE_SIZE (innermode) - GET_MODE_SIZE (outermode));
1480
1481   if (GET_MODE_SIZE (innermode) < GET_MODE_SIZE (outermode))
1482     abort ();
1483
1484   if (difference > 0)
1485     {
1486       if (! WORDS_BIG_ENDIAN)
1487         offset += (difference / UNITS_PER_WORD) * UNITS_PER_WORD;
1488       if (! BYTES_BIG_ENDIAN)
1489         offset += difference % UNITS_PER_WORD;
1490     }
1491
1492   return offset;
1493 }
1494
1495 /* Return 1 iff X, assumed to be a SUBREG,
1496    refers to the least significant part of its containing reg.
1497    If X is not a SUBREG, always return 1 (it is its own low part!).  */
1498
1499 int
1500 subreg_lowpart_p (x)
1501      rtx x;
1502 {
1503   if (GET_CODE (x) != SUBREG)
1504     return 1;
1505   else if (GET_MODE (SUBREG_REG (x)) == VOIDmode)
1506     return 0;
1507
1508   return (subreg_lowpart_offset (GET_MODE (x), GET_MODE (SUBREG_REG (x)))
1509           == SUBREG_BYTE (x));
1510 }
1511 \f
1512
1513 /* Helper routine for all the constant cases of operand_subword.
1514    Some places invoke this directly.  */
1515
1516 rtx
1517 constant_subword (op, offset, mode)
1518      rtx op;
1519      int offset;
1520      enum machine_mode mode;
1521 {
1522   int size_ratio = HOST_BITS_PER_WIDE_INT / BITS_PER_WORD;
1523   HOST_WIDE_INT val;
1524
1525   /* If OP is already an integer word, return it.  */
1526   if (GET_MODE_CLASS (mode) == MODE_INT
1527       && GET_MODE_SIZE (mode) == UNITS_PER_WORD)
1528     return op;
1529
1530   /* The output is some bits, the width of the target machine's word.
1531      A wider-word host can surely hold them in a CONST_INT. A narrower-word
1532      host can't.  */
1533   if (HOST_BITS_PER_WIDE_INT >= BITS_PER_WORD
1534       && GET_MODE_CLASS (mode) == MODE_FLOAT
1535       && GET_MODE_BITSIZE (mode) == 64
1536       && GET_CODE (op) == CONST_DOUBLE)
1537     {
1538       long k[2];
1539       REAL_VALUE_TYPE rv;
1540
1541       REAL_VALUE_FROM_CONST_DOUBLE (rv, op);
1542       REAL_VALUE_TO_TARGET_DOUBLE (rv, k);
1543
1544       /* We handle 32-bit and >= 64-bit words here.  Note that the order in
1545          which the words are written depends on the word endianness.
1546          ??? This is a potential portability problem and should
1547          be fixed at some point.
1548
1549          We must exercise caution with the sign bit.  By definition there
1550          are 32 significant bits in K; there may be more in a HOST_WIDE_INT.
1551          Consider a host with a 32-bit long and a 64-bit HOST_WIDE_INT.
1552          So we explicitly mask and sign-extend as necessary.  */
1553       if (BITS_PER_WORD == 32)
1554         {
1555           val = k[offset];
1556           val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000;
1557           return GEN_INT (val);
1558         }
1559 #if HOST_BITS_PER_WIDE_INT >= 64
1560       else if (BITS_PER_WORD >= 64 && offset == 0)
1561         {
1562           val = k[! WORDS_BIG_ENDIAN];
1563           val = (((val & 0xffffffff) ^ 0x80000000) - 0x80000000) << 32;
1564           val |= (HOST_WIDE_INT) k[WORDS_BIG_ENDIAN] & 0xffffffff;
1565           return GEN_INT (val);
1566         }
1567 #endif
1568       else if (BITS_PER_WORD == 16)
1569         {
1570           val = k[offset >> 1];
1571           if ((offset & 1) == ! WORDS_BIG_ENDIAN)
1572             val >>= 16;
1573           val = ((val & 0xffff) ^ 0x8000) - 0x8000;
1574           return GEN_INT (val);
1575         }
1576       else
1577         abort ();
1578     }
1579   else if (HOST_BITS_PER_WIDE_INT >= BITS_PER_WORD
1580            && GET_MODE_CLASS (mode) == MODE_FLOAT
1581            && GET_MODE_BITSIZE (mode) > 64
1582            && GET_CODE (op) == CONST_DOUBLE)
1583     {
1584       long k[4];
1585       REAL_VALUE_TYPE rv;
1586
1587       REAL_VALUE_FROM_CONST_DOUBLE (rv, op);
1588       REAL_VALUE_TO_TARGET_LONG_DOUBLE (rv, k);
1589
1590       if (BITS_PER_WORD == 32)
1591         {
1592           val = k[offset];
1593           val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000;
1594           return GEN_INT (val);
1595         }
1596 #if HOST_BITS_PER_WIDE_INT >= 64
1597       else if (BITS_PER_WORD >= 64 && offset <= 1)
1598         {
1599           val = k[offset * 2 + ! WORDS_BIG_ENDIAN];
1600           val = (((val & 0xffffffff) ^ 0x80000000) - 0x80000000) << 32;
1601           val |= (HOST_WIDE_INT) k[offset * 2 + WORDS_BIG_ENDIAN] & 0xffffffff;
1602           return GEN_INT (val);
1603         }
1604 #endif
1605       else
1606         abort ();
1607     }
1608
1609   /* Single word float is a little harder, since single- and double-word
1610      values often do not have the same high-order bits.  We have already
1611      verified that we want the only defined word of the single-word value.  */
1612   if (GET_MODE_CLASS (mode) == MODE_FLOAT
1613       && GET_MODE_BITSIZE (mode) == 32
1614       && GET_CODE (op) == CONST_DOUBLE)
1615     {
1616       long l;
1617       REAL_VALUE_TYPE rv;
1618
1619       REAL_VALUE_FROM_CONST_DOUBLE (rv, op);
1620       REAL_VALUE_TO_TARGET_SINGLE (rv, l);
1621
1622       /* Sign extend from known 32-bit value to HOST_WIDE_INT.  */
1623       val = l;
1624       val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000;
1625
1626       if (BITS_PER_WORD == 16)
1627         {
1628           if ((offset & 1) == ! WORDS_BIG_ENDIAN)
1629             val >>= 16;
1630           val = ((val & 0xffff) ^ 0x8000) - 0x8000;
1631         }
1632
1633       return GEN_INT (val);
1634     }
1635
1636   /* The only remaining cases that we can handle are integers.
1637      Convert to proper endianness now since these cases need it.
1638      At this point, offset == 0 means the low-order word.
1639
1640      We do not want to handle the case when BITS_PER_WORD <= HOST_BITS_PER_INT
1641      in general.  However, if OP is (const_int 0), we can just return
1642      it for any word.  */
1643
1644   if (op == const0_rtx)
1645     return op;
1646
1647   if (GET_MODE_CLASS (mode) != MODE_INT
1648       || (GET_CODE (op) != CONST_INT && GET_CODE (op) != CONST_DOUBLE)
1649       || BITS_PER_WORD > HOST_BITS_PER_WIDE_INT)
1650     return 0;
1651
1652   if (WORDS_BIG_ENDIAN)
1653     offset = GET_MODE_SIZE (mode) / UNITS_PER_WORD - 1 - offset;
1654
1655   /* Find out which word on the host machine this value is in and get
1656      it from the constant.  */
1657   val = (offset / size_ratio == 0
1658          ? (GET_CODE (op) == CONST_INT ? INTVAL (op) : CONST_DOUBLE_LOW (op))
1659          : (GET_CODE (op) == CONST_INT
1660             ? (INTVAL (op) < 0 ? ~0 : 0) : CONST_DOUBLE_HIGH (op)));
1661
1662   /* Get the value we want into the low bits of val.  */
1663   if (BITS_PER_WORD < HOST_BITS_PER_WIDE_INT)
1664     val = ((val >> ((offset % size_ratio) * BITS_PER_WORD)));
1665
1666   val = trunc_int_for_mode (val, word_mode);
1667
1668   return GEN_INT (val);
1669 }
1670
1671 /* Return subword OFFSET of operand OP.
1672    The word number, OFFSET, is interpreted as the word number starting
1673    at the low-order address.  OFFSET 0 is the low-order word if not
1674    WORDS_BIG_ENDIAN, otherwise it is the high-order word.
1675
1676    If we cannot extract the required word, we return zero.  Otherwise,
1677    an rtx corresponding to the requested word will be returned.
1678
1679    VALIDATE_ADDRESS is nonzero if the address should be validated.  Before
1680    reload has completed, a valid address will always be returned.  After
1681    reload, if a valid address cannot be returned, we return zero.
1682
1683    If VALIDATE_ADDRESS is zero, we simply form the required address; validating
1684    it is the responsibility of the caller.
1685
1686    MODE is the mode of OP in case it is a CONST_INT.
1687
1688    ??? This is still rather broken for some cases.  The problem for the
1689    moment is that all callers of this thing provide no 'goal mode' to
1690    tell us to work with.  This exists because all callers were written
1691    in a word based SUBREG world.
1692    Now use of this function can be deprecated by simplify_subreg in most
1693    cases.
1694  */
1695
1696 rtx
1697 operand_subword (op, offset, validate_address, mode)
1698      rtx op;
1699      unsigned int offset;
1700      int validate_address;
1701      enum machine_mode mode;
1702 {
1703   if (mode == VOIDmode)
1704     mode = GET_MODE (op);
1705
1706   if (mode == VOIDmode)
1707     abort ();
1708
1709   /* If OP is narrower than a word, fail.  */
1710   if (mode != BLKmode
1711       && (GET_MODE_SIZE (mode) < UNITS_PER_WORD))
1712     return 0;
1713
1714   /* If we want a word outside OP, return zero.  */
1715   if (mode != BLKmode
1716       && (offset + 1) * UNITS_PER_WORD > GET_MODE_SIZE (mode))
1717     return const0_rtx;
1718
1719   /* Form a new MEM at the requested address.  */
1720   if (GET_CODE (op) == MEM)
1721     {
1722       rtx new = adjust_address_nv (op, word_mode, offset * UNITS_PER_WORD);
1723
1724       if (! validate_address)
1725         return new;
1726
1727       else if (reload_completed)
1728         {
1729           if (! strict_memory_address_p (word_mode, XEXP (new, 0)))
1730             return 0;
1731         }
1732       else
1733         return replace_equiv_address (new, XEXP (new, 0));
1734     }
1735
1736   /* Rest can be handled by simplify_subreg.  */
1737   return simplify_gen_subreg (word_mode, op, mode, (offset * UNITS_PER_WORD));
1738 }
1739
1740 /* Similar to `operand_subword', but never return 0.  If we can't extract
1741    the required subword, put OP into a register and try again.  If that fails,
1742    abort.  We always validate the address in this case.
1743
1744    MODE is the mode of OP, in case it is CONST_INT.  */
1745
1746 rtx
1747 operand_subword_force (op, offset, mode)
1748      rtx op;
1749      unsigned int offset;
1750      enum machine_mode mode;
1751 {
1752   rtx result = operand_subword (op, offset, 1, mode);
1753
1754   if (result)
1755     return result;
1756
1757   if (mode != BLKmode && mode != VOIDmode)
1758     {
1759       /* If this is a register which can not be accessed by words, copy it
1760          to a pseudo register.  */
1761       if (GET_CODE (op) == REG)
1762         op = copy_to_reg (op);
1763       else
1764         op = force_reg (mode, op);
1765     }
1766
1767   result = operand_subword (op, offset, 1, mode);
1768   if (result == 0)
1769     abort ();
1770
1771   return result;
1772 }
1773 \f
1774 /* Given a compare instruction, swap the operands.
1775    A test instruction is changed into a compare of 0 against the operand.  */
1776
1777 void
1778 reverse_comparison (insn)
1779      rtx insn;
1780 {
1781   rtx body = PATTERN (insn);
1782   rtx comp;
1783
1784   if (GET_CODE (body) == SET)
1785     comp = SET_SRC (body);
1786   else
1787     comp = SET_SRC (XVECEXP (body, 0, 0));
1788
1789   if (GET_CODE (comp) == COMPARE)
1790     {
1791       rtx op0 = XEXP (comp, 0);
1792       rtx op1 = XEXP (comp, 1);
1793       XEXP (comp, 0) = op1;
1794       XEXP (comp, 1) = op0;
1795     }
1796   else
1797     {
1798       rtx new = gen_rtx_COMPARE (VOIDmode,
1799                                  CONST0_RTX (GET_MODE (comp)), comp);
1800       if (GET_CODE (body) == SET)
1801         SET_SRC (body) = new;
1802       else
1803         SET_SRC (XVECEXP (body, 0, 0)) = new;
1804     }
1805 }
1806 \f
1807 /* Within a MEM_EXPR, we care about either (1) a component ref of a decl,
1808    or (2) a component ref of something variable.  Represent the later with
1809    a NULL expression.  */
1810
1811 static tree
1812 component_ref_for_mem_expr (ref)
1813      tree ref;
1814 {
1815   tree inner = TREE_OPERAND (ref, 0);
1816
1817   if (TREE_CODE (inner) == COMPONENT_REF)
1818     inner = component_ref_for_mem_expr (inner);
1819   else
1820     {
1821       tree placeholder_ptr = 0;
1822
1823       /* Now remove any conversions: they don't change what the underlying
1824          object is.  Likewise for SAVE_EXPR.  Also handle PLACEHOLDER_EXPR.  */
1825       while (TREE_CODE (inner) == NOP_EXPR || TREE_CODE (inner) == CONVERT_EXPR
1826              || TREE_CODE (inner) == NON_LVALUE_EXPR
1827              || TREE_CODE (inner) == VIEW_CONVERT_EXPR
1828              || TREE_CODE (inner) == SAVE_EXPR
1829              || TREE_CODE (inner) == PLACEHOLDER_EXPR)
1830         if (TREE_CODE (inner) == PLACEHOLDER_EXPR)
1831           inner = find_placeholder (inner, &placeholder_ptr);
1832         else
1833           inner = TREE_OPERAND (inner, 0);
1834
1835       if (! DECL_P (inner))
1836         inner = NULL_TREE;
1837     }
1838
1839   if (inner == TREE_OPERAND (ref, 0))
1840     return ref;
1841   else
1842     return build (COMPONENT_REF, TREE_TYPE (ref), inner,
1843                   TREE_OPERAND (ref, 1));
1844 }
1845
1846 /* Given REF, a MEM, and T, either the type of X or the expression
1847    corresponding to REF, set the memory attributes.  OBJECTP is nonzero
1848    if we are making a new object of this type.  BITPOS is nonzero if
1849    there is an offset outstanding on T that will be applied later.  */
1850
1851 void
1852 set_mem_attributes_minus_bitpos (ref, t, objectp, bitpos)
1853      rtx ref;
1854      tree t;
1855      int objectp;
1856      HOST_WIDE_INT bitpos;
1857 {
1858   HOST_WIDE_INT alias = MEM_ALIAS_SET (ref);
1859   tree expr = MEM_EXPR (ref);
1860   rtx offset = MEM_OFFSET (ref);
1861   rtx size = MEM_SIZE (ref);
1862   unsigned int align = MEM_ALIGN (ref);
1863   HOST_WIDE_INT apply_bitpos = 0;
1864   tree type;
1865
1866   /* It can happen that type_for_mode was given a mode for which there
1867      is no language-level type.  In which case it returns NULL, which
1868      we can see here.  */
1869   if (t == NULL_TREE)
1870     return;
1871
1872   type = TYPE_P (t) ? t : TREE_TYPE (t);
1873
1874   /* If we have already set DECL_RTL = ref, get_alias_set will get the
1875      wrong answer, as it assumes that DECL_RTL already has the right alias
1876      info.  Callers should not set DECL_RTL until after the call to
1877      set_mem_attributes.  */
1878   if (DECL_P (t) && ref == DECL_RTL_IF_SET (t))
1879     abort ();
1880
1881   /* Get the alias set from the expression or type (perhaps using a
1882      front-end routine) and use it.  */
1883   alias = get_alias_set (t);
1884
1885   MEM_VOLATILE_P (ref) = TYPE_VOLATILE (type);
1886   MEM_IN_STRUCT_P (ref) = AGGREGATE_TYPE_P (type);
1887   RTX_UNCHANGING_P (ref)
1888     |= ((lang_hooks.honor_readonly
1889          && (TYPE_READONLY (type) || TREE_READONLY (t)))
1890         || (! TYPE_P (t) && TREE_CONSTANT (t)));
1891
1892   /* If we are making an object of this type, or if this is a DECL, we know
1893      that it is a scalar if the type is not an aggregate.  */
1894   if ((objectp || DECL_P (t)) && ! AGGREGATE_TYPE_P (type))
1895     MEM_SCALAR_P (ref) = 1;
1896
1897   /* We can set the alignment from the type if we are making an object,
1898      this is an INDIRECT_REF, or if TYPE_ALIGN_OK.  */
1899   if (objectp || TREE_CODE (t) == INDIRECT_REF || TYPE_ALIGN_OK (type))
1900     align = MAX (align, TYPE_ALIGN (type));
1901
1902   /* If the size is known, we can set that.  */
1903   if (TYPE_SIZE_UNIT (type) && host_integerp (TYPE_SIZE_UNIT (type), 1))
1904     size = GEN_INT (tree_low_cst (TYPE_SIZE_UNIT (type), 1));
1905
1906   /* If T is not a type, we may be able to deduce some more information about
1907      the expression.  */
1908   if (! TYPE_P (t))
1909     {
1910       maybe_set_unchanging (ref, t);
1911       if (TREE_THIS_VOLATILE (t))
1912         MEM_VOLATILE_P (ref) = 1;
1913
1914       /* Now remove any conversions: they don't change what the underlying
1915          object is.  Likewise for SAVE_EXPR.  */
1916       while (TREE_CODE (t) == NOP_EXPR || TREE_CODE (t) == CONVERT_EXPR
1917              || TREE_CODE (t) == NON_LVALUE_EXPR
1918              || TREE_CODE (t) == VIEW_CONVERT_EXPR
1919              || TREE_CODE (t) == SAVE_EXPR)
1920         t = TREE_OPERAND (t, 0);
1921
1922       /* If this expression can't be addressed (e.g., it contains a reference
1923          to a non-addressable field), show we don't change its alias set.  */
1924       if (! can_address_p (t))
1925         MEM_KEEP_ALIAS_SET_P (ref) = 1;
1926
1927       /* If this is a decl, set the attributes of the MEM from it.  */
1928       if (DECL_P (t))
1929         {
1930           expr = t;
1931           offset = const0_rtx;
1932           apply_bitpos = bitpos;
1933           size = (DECL_SIZE_UNIT (t)
1934                   && host_integerp (DECL_SIZE_UNIT (t), 1)
1935                   ? GEN_INT (tree_low_cst (DECL_SIZE_UNIT (t), 1)) : 0);
1936           align = DECL_ALIGN (t);
1937         }
1938
1939       /* If this is a constant, we know the alignment.  */
1940       else if (TREE_CODE_CLASS (TREE_CODE (t)) == 'c')
1941         {
1942           align = TYPE_ALIGN (type);
1943 #ifdef CONSTANT_ALIGNMENT
1944           align = CONSTANT_ALIGNMENT (t, align);
1945 #endif
1946         }
1947
1948       /* If this is a field reference and not a bit-field, record it.  */
1949       /* ??? There is some information that can be gleened from bit-fields,
1950          such as the word offset in the structure that might be modified.
1951          But skip it for now.  */
1952       else if (TREE_CODE (t) == COMPONENT_REF
1953                && ! DECL_BIT_FIELD (TREE_OPERAND (t, 1)))
1954         {
1955           expr = component_ref_for_mem_expr (t);
1956           offset = const0_rtx;
1957           apply_bitpos = bitpos;
1958           /* ??? Any reason the field size would be different than
1959              the size we got from the type?  */
1960         }
1961
1962       /* If this is an array reference, look for an outer field reference.  */
1963       else if (TREE_CODE (t) == ARRAY_REF)
1964         {
1965           tree off_tree = size_zero_node;
1966
1967           do
1968             {
1969               tree index = TREE_OPERAND (t, 1);
1970               tree array = TREE_OPERAND (t, 0);
1971               tree domain = TYPE_DOMAIN (TREE_TYPE (array));
1972               tree low_bound = (domain ? TYPE_MIN_VALUE (domain) : 0);
1973               tree unit_size = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (array)));
1974
1975               /* We assume all arrays have sizes that are a multiple of a byte.
1976                  First subtract the lower bound, if any, in the type of the
1977                  index, then convert to sizetype and multiply by the size of the
1978                  array element.  */
1979               if (low_bound != 0 && ! integer_zerop (low_bound))
1980                 index = fold (build (MINUS_EXPR, TREE_TYPE (index),
1981                                      index, low_bound));
1982
1983               /* If the index has a self-referential type, pass it to a
1984                  WITH_RECORD_EXPR; if the component size is, pass our
1985                  component to one.  */
1986               if (! TREE_CONSTANT (index)
1987                   && contains_placeholder_p (index))
1988                 index = build (WITH_RECORD_EXPR, TREE_TYPE (index), index, t);
1989               if (! TREE_CONSTANT (unit_size)
1990                   && contains_placeholder_p (unit_size))
1991                 unit_size = build (WITH_RECORD_EXPR, sizetype,
1992                                    unit_size, array);
1993
1994               off_tree
1995                 = fold (build (PLUS_EXPR, sizetype,
1996                                fold (build (MULT_EXPR, sizetype,
1997                                             index,
1998                                             unit_size)),
1999                                off_tree));
2000               t = TREE_OPERAND (t, 0);
2001             }
2002           while (TREE_CODE (t) == ARRAY_REF);
2003
2004           if (DECL_P (t))
2005             {
2006               expr = t;
2007               offset = NULL;
2008               if (host_integerp (off_tree, 1))
2009                 {
2010                   HOST_WIDE_INT ioff = tree_low_cst (off_tree, 1);
2011                   HOST_WIDE_INT aoff = (ioff & -ioff) * BITS_PER_UNIT;
2012                   align = DECL_ALIGN (t);
2013                   if (aoff && (unsigned HOST_WIDE_INT) aoff < align)
2014                     align = aoff;
2015                   offset = GEN_INT (ioff);
2016                   apply_bitpos = bitpos;
2017                 }
2018             }
2019           else if (TREE_CODE (t) == COMPONENT_REF)
2020             {
2021               expr = component_ref_for_mem_expr (t);
2022               if (host_integerp (off_tree, 1))
2023                 {
2024                   offset = GEN_INT (tree_low_cst (off_tree, 1));
2025                   apply_bitpos = bitpos;
2026                 }
2027               /* ??? Any reason the field size would be different than
2028                  the size we got from the type?  */
2029             }
2030           else if (flag_argument_noalias > 1
2031                    && TREE_CODE (t) == INDIRECT_REF
2032                    && TREE_CODE (TREE_OPERAND (t, 0)) == PARM_DECL)
2033             {
2034               expr = t;
2035               offset = NULL;
2036             }
2037         }
2038
2039       /* If this is a Fortran indirect argument reference, record the
2040          parameter decl.  */
2041       else if (flag_argument_noalias > 1
2042                && TREE_CODE (t) == INDIRECT_REF
2043                && TREE_CODE (TREE_OPERAND (t, 0)) == PARM_DECL)
2044         {
2045           expr = t;
2046           offset = NULL;
2047         }
2048     }
2049
2050   /* If we modified OFFSET based on T, then subtract the outstanding
2051      bit position offset.  Similarly, increase the size of the accessed
2052      object to contain the negative offset.  */
2053   if (apply_bitpos)
2054     {
2055       offset = plus_constant (offset, -(apply_bitpos / BITS_PER_UNIT));
2056       if (size)
2057         size = plus_constant (size, apply_bitpos / BITS_PER_UNIT);
2058     }
2059
2060   /* Now set the attributes we computed above.  */
2061   MEM_ATTRS (ref)
2062     = get_mem_attrs (alias, expr, offset, size, align, GET_MODE (ref));
2063
2064   /* If this is already known to be a scalar or aggregate, we are done.  */
2065   if (MEM_IN_STRUCT_P (ref) || MEM_SCALAR_P (ref))
2066     return;
2067
2068   /* If it is a reference into an aggregate, this is part of an aggregate.
2069      Otherwise we don't know.  */
2070   else if (TREE_CODE (t) == COMPONENT_REF || TREE_CODE (t) == ARRAY_REF
2071            || TREE_CODE (t) == ARRAY_RANGE_REF
2072            || TREE_CODE (t) == BIT_FIELD_REF)
2073     MEM_IN_STRUCT_P (ref) = 1;
2074 }
2075
2076 void
2077 set_mem_attributes (ref, t, objectp)
2078      rtx ref;
2079      tree t;
2080      int objectp;
2081 {
2082   set_mem_attributes_minus_bitpos (ref, t, objectp, 0);
2083 }
2084
2085 /* Set the decl for MEM to DECL.  */
2086
2087 void
2088 set_mem_attrs_from_reg (mem, reg)
2089      rtx mem;
2090      rtx reg;
2091 {
2092   MEM_ATTRS (mem)
2093     = get_mem_attrs (MEM_ALIAS_SET (mem), REG_EXPR (reg),
2094                      GEN_INT (REG_OFFSET (reg)),
2095                      MEM_SIZE (mem), MEM_ALIGN (mem), GET_MODE (mem));
2096 }
2097
2098 /* Set the alias set of MEM to SET.  */
2099
2100 void
2101 set_mem_alias_set (mem, set)
2102      rtx mem;
2103      HOST_WIDE_INT set;
2104 {
2105 #ifdef ENABLE_CHECKING
2106   /* If the new and old alias sets don't conflict, something is wrong.  */
2107   if (!alias_sets_conflict_p (set, MEM_ALIAS_SET (mem)))
2108     abort ();
2109 #endif
2110
2111   MEM_ATTRS (mem) = get_mem_attrs (set, MEM_EXPR (mem), MEM_OFFSET (mem),
2112                                    MEM_SIZE (mem), MEM_ALIGN (mem),
2113                                    GET_MODE (mem));
2114 }
2115
2116 /* Set the alignment of MEM to ALIGN bits.  */
2117
2118 void
2119 set_mem_align (mem, align)
2120      rtx mem;
2121      unsigned int align;
2122 {
2123   MEM_ATTRS (mem) = get_mem_attrs (MEM_ALIAS_SET (mem), MEM_EXPR (mem),
2124                                    MEM_OFFSET (mem), MEM_SIZE (mem), align,
2125                                    GET_MODE (mem));
2126 }
2127
2128 /* Set the expr for MEM to EXPR.  */
2129
2130 void
2131 set_mem_expr (mem, expr)
2132      rtx mem;
2133      tree expr;
2134 {
2135   MEM_ATTRS (mem)
2136     = get_mem_attrs (MEM_ALIAS_SET (mem), expr, MEM_OFFSET (mem),
2137                      MEM_SIZE (mem), MEM_ALIGN (mem), GET_MODE (mem));
2138 }
2139
2140 /* Set the offset of MEM to OFFSET.  */
2141
2142 void
2143 set_mem_offset (mem, offset)
2144      rtx mem, offset;
2145 {
2146   MEM_ATTRS (mem) = get_mem_attrs (MEM_ALIAS_SET (mem), MEM_EXPR (mem),
2147                                    offset, MEM_SIZE (mem), MEM_ALIGN (mem),
2148                                    GET_MODE (mem));
2149 }
2150
2151 /* Set the size of MEM to SIZE.  */
2152
2153 void
2154 set_mem_size (mem, size)
2155      rtx mem, size;
2156 {
2157   MEM_ATTRS (mem) = get_mem_attrs (MEM_ALIAS_SET (mem), MEM_EXPR (mem),
2158                                    MEM_OFFSET (mem), size, MEM_ALIGN (mem),
2159                                    GET_MODE (mem));
2160 }
2161 \f
2162 /* Return a memory reference like MEMREF, but with its mode changed to MODE
2163    and its address changed to ADDR.  (VOIDmode means don't change the mode.
2164    NULL for ADDR means don't change the address.)  VALIDATE is nonzero if the
2165    returned memory location is required to be valid.  The memory
2166    attributes are not changed.  */
2167
2168 static rtx
2169 change_address_1 (memref, mode, addr, validate)
2170      rtx memref;
2171      enum machine_mode mode;
2172      rtx addr;
2173      int validate;
2174 {
2175   rtx new;
2176
2177   if (GET_CODE (memref) != MEM)
2178     abort ();
2179   if (mode == VOIDmode)
2180     mode = GET_MODE (memref);
2181   if (addr == 0)
2182     addr = XEXP (memref, 0);
2183
2184   if (validate)
2185     {
2186       if (reload_in_progress || reload_completed)
2187         {
2188           if (! memory_address_p (mode, addr))
2189             abort ();
2190         }
2191       else
2192         addr = memory_address (mode, addr);
2193     }
2194
2195   if (rtx_equal_p (addr, XEXP (memref, 0)) && mode == GET_MODE (memref))
2196     return memref;
2197
2198   new = gen_rtx_MEM (mode, addr);
2199   MEM_COPY_ATTRIBUTES (new, memref);
2200   return new;
2201 }
2202
2203 /* Like change_address_1 with VALIDATE nonzero, but we are not saying in what
2204    way we are changing MEMREF, so we only preserve the alias set.  */
2205
2206 rtx
2207 change_address (memref, mode, addr)
2208      rtx memref;
2209      enum machine_mode mode;
2210      rtx addr;
2211 {
2212   rtx new = change_address_1 (memref, mode, addr, 1);
2213   enum machine_mode mmode = GET_MODE (new);
2214
2215   MEM_ATTRS (new)
2216     = get_mem_attrs (MEM_ALIAS_SET (memref), 0, 0,
2217                      mmode == BLKmode ? 0 : GEN_INT (GET_MODE_SIZE (mmode)),
2218                      (mmode == BLKmode ? BITS_PER_UNIT
2219                       : GET_MODE_ALIGNMENT (mmode)),
2220                      mmode);
2221
2222   return new;
2223 }
2224
2225 /* Return a memory reference like MEMREF, but with its mode changed
2226    to MODE and its address offset by OFFSET bytes.  If VALIDATE is
2227    nonzero, the memory address is forced to be valid.
2228    If ADJUST is zero, OFFSET is only used to update MEM_ATTRS
2229    and caller is responsible for adjusting MEMREF base register.  */
2230
2231 rtx
2232 adjust_address_1 (memref, mode, offset, validate, adjust)
2233      rtx memref;
2234      enum machine_mode mode;
2235      HOST_WIDE_INT offset;
2236      int validate, adjust;
2237 {
2238   rtx addr = XEXP (memref, 0);
2239   rtx new;
2240   rtx memoffset = MEM_OFFSET (memref);
2241   rtx size = 0;
2242   unsigned int memalign = MEM_ALIGN (memref);
2243
2244   /* ??? Prefer to create garbage instead of creating shared rtl.
2245      This may happen even if offset is nonzero -- consider
2246      (plus (plus reg reg) const_int) -- so do this always.  */
2247   addr = copy_rtx (addr);
2248
2249   if (adjust)
2250     {
2251       /* If MEMREF is a LO_SUM and the offset is within the alignment of the
2252          object, we can merge it into the LO_SUM.  */
2253       if (GET_MODE (memref) != BLKmode && GET_CODE (addr) == LO_SUM
2254           && offset >= 0
2255           && (unsigned HOST_WIDE_INT) offset
2256               < GET_MODE_ALIGNMENT (GET_MODE (memref)) / BITS_PER_UNIT)
2257         addr = gen_rtx_LO_SUM (Pmode, XEXP (addr, 0),
2258                                plus_constant (XEXP (addr, 1), offset));
2259       else
2260         addr = plus_constant (addr, offset);
2261     }
2262
2263   new = change_address_1 (memref, mode, addr, validate);
2264
2265   /* Compute the new values of the memory attributes due to this adjustment.
2266      We add the offsets and update the alignment.  */
2267   if (memoffset)
2268     memoffset = GEN_INT (offset + INTVAL (memoffset));
2269
2270   /* Compute the new alignment by taking the MIN of the alignment and the
2271      lowest-order set bit in OFFSET, but don't change the alignment if OFFSET
2272      if zero.  */
2273   if (offset != 0)
2274     memalign
2275       = MIN (memalign,
2276              (unsigned HOST_WIDE_INT) (offset & -offset) * BITS_PER_UNIT);
2277
2278   /* We can compute the size in a number of ways.  */
2279   if (GET_MODE (new) != BLKmode)
2280     size = GEN_INT (GET_MODE_SIZE (GET_MODE (new)));
2281   else if (MEM_SIZE (memref))
2282     size = plus_constant (MEM_SIZE (memref), -offset);
2283
2284   MEM_ATTRS (new) = get_mem_attrs (MEM_ALIAS_SET (memref), MEM_EXPR (memref),
2285                                    memoffset, size, memalign, GET_MODE (new));
2286
2287   /* At some point, we should validate that this offset is within the object,
2288      if all the appropriate values are known.  */
2289   return new;
2290 }
2291
2292 /* Return a memory reference like MEMREF, but with its mode changed
2293    to MODE and its address changed to ADDR, which is assumed to be
2294    MEMREF offseted by OFFSET bytes.  If VALIDATE is
2295    nonzero, the memory address is forced to be valid.  */
2296
2297 rtx
2298 adjust_automodify_address_1 (memref, mode, addr, offset, validate)
2299      rtx memref;
2300      enum machine_mode mode;
2301      rtx addr;
2302      HOST_WIDE_INT offset;
2303      int validate;
2304 {
2305   memref = change_address_1 (memref, VOIDmode, addr, validate);
2306   return adjust_address_1 (memref, mode, offset, validate, 0);
2307 }
2308
2309 /* Return a memory reference like MEMREF, but whose address is changed by
2310    adding OFFSET, an RTX, to it.  POW2 is the highest power of two factor
2311    known to be in OFFSET (possibly 1).  */
2312
2313 rtx
2314 offset_address (memref, offset, pow2)
2315      rtx memref;
2316      rtx offset;
2317      HOST_WIDE_INT pow2;
2318 {
2319   rtx new, addr = XEXP (memref, 0);
2320
2321   new = simplify_gen_binary (PLUS, Pmode, addr, offset);
2322
2323   /* At this point we don't know _why_ the address is invalid.  It
2324      could have secondary memory refereces, multiplies or anything.
2325
2326      However, if we did go and rearrange things, we can wind up not
2327      being able to recognize the magic around pic_offset_table_rtx.
2328      This stuff is fragile, and is yet another example of why it is
2329      bad to expose PIC machinery too early.  */
2330   if (! memory_address_p (GET_MODE (memref), new)
2331       && GET_CODE (addr) == PLUS
2332       && XEXP (addr, 0) == pic_offset_table_rtx)
2333     {
2334       addr = force_reg (GET_MODE (addr), addr);
2335       new = simplify_gen_binary (PLUS, Pmode, addr, offset);
2336     }
2337
2338   update_temp_slot_address (XEXP (memref, 0), new);
2339   new = change_address_1 (memref, VOIDmode, new, 1);
2340
2341   /* Update the alignment to reflect the offset.  Reset the offset, which
2342      we don't know.  */
2343   MEM_ATTRS (new)
2344     = get_mem_attrs (MEM_ALIAS_SET (memref), MEM_EXPR (memref), 0, 0,
2345                      MIN (MEM_ALIGN (memref),
2346                           (unsigned HOST_WIDE_INT) pow2 * BITS_PER_UNIT),
2347                      GET_MODE (new));
2348   return new;
2349 }
2350
2351 /* Return a memory reference like MEMREF, but with its address changed to
2352    ADDR.  The caller is asserting that the actual piece of memory pointed
2353    to is the same, just the form of the address is being changed, such as
2354    by putting something into a register.  */
2355
2356 rtx
2357 replace_equiv_address (memref, addr)
2358      rtx memref;
2359      rtx addr;
2360 {
2361   /* change_address_1 copies the memory attribute structure without change
2362      and that's exactly what we want here.  */
2363   update_temp_slot_address (XEXP (memref, 0), addr);
2364   return change_address_1 (memref, VOIDmode, addr, 1);
2365 }
2366
2367 /* Likewise, but the reference is not required to be valid.  */
2368
2369 rtx
2370 replace_equiv_address_nv (memref, addr)
2371      rtx memref;
2372      rtx addr;
2373 {
2374   return change_address_1 (memref, VOIDmode, addr, 0);
2375 }
2376
2377 /* Return a memory reference like MEMREF, but with its mode widened to
2378    MODE and offset by OFFSET.  This would be used by targets that e.g.
2379    cannot issue QImode memory operations and have to use SImode memory
2380    operations plus masking logic.  */
2381
2382 rtx
2383 widen_memory_access (memref, mode, offset)
2384      rtx memref;
2385      enum machine_mode mode;
2386      HOST_WIDE_INT offset;
2387 {
2388   rtx new = adjust_address_1 (memref, mode, offset, 1, 1);
2389   tree expr = MEM_EXPR (new);
2390   rtx memoffset = MEM_OFFSET (new);
2391   unsigned int size = GET_MODE_SIZE (mode);
2392
2393   /* If we don't know what offset we were at within the expression, then
2394      we can't know if we've overstepped the bounds.  */
2395   if (! memoffset)
2396     expr = NULL_TREE;
2397
2398   while (expr)
2399     {
2400       if (TREE_CODE (expr) == COMPONENT_REF)
2401         {
2402           tree field = TREE_OPERAND (expr, 1);
2403
2404           if (! DECL_SIZE_UNIT (field))
2405             {
2406               expr = NULL_TREE;
2407               break;
2408             }
2409
2410           /* Is the field at least as large as the access?  If so, ok,
2411              otherwise strip back to the containing structure.  */
2412           if (TREE_CODE (DECL_SIZE_UNIT (field)) == INTEGER_CST
2413               && compare_tree_int (DECL_SIZE_UNIT (field), size) >= 0
2414               && INTVAL (memoffset) >= 0)
2415             break;
2416
2417           if (! host_integerp (DECL_FIELD_OFFSET (field), 1))
2418             {
2419               expr = NULL_TREE;
2420               break;
2421             }
2422
2423           expr = TREE_OPERAND (expr, 0);
2424           memoffset = (GEN_INT (INTVAL (memoffset)
2425                        + tree_low_cst (DECL_FIELD_OFFSET (field), 1)
2426                        + (tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
2427                           / BITS_PER_UNIT)));
2428         }
2429       /* Similarly for the decl.  */
2430       else if (DECL_P (expr)
2431                && DECL_SIZE_UNIT (expr)
2432                && TREE_CODE (DECL_SIZE_UNIT (expr)) == INTEGER_CST
2433                && compare_tree_int (DECL_SIZE_UNIT (expr), size) >= 0
2434                && (! memoffset || INTVAL (memoffset) >= 0))
2435         break;
2436       else
2437         {
2438           /* The widened memory access overflows the expression, which means
2439              that it could alias another expression.  Zap it.  */
2440           expr = NULL_TREE;
2441           break;
2442         }
2443     }
2444
2445   if (! expr)
2446     memoffset = NULL_RTX;
2447
2448   /* The widened memory may alias other stuff, so zap the alias set.  */
2449   /* ??? Maybe use get_alias_set on any remaining expression.  */
2450
2451   MEM_ATTRS (new) = get_mem_attrs (0, expr, memoffset, GEN_INT (size),
2452                                    MEM_ALIGN (new), mode);
2453
2454   return new;
2455 }
2456 \f
2457 /* Return a newly created CODE_LABEL rtx with a unique label number.  */
2458
2459 rtx
2460 gen_label_rtx ()
2461 {
2462   return gen_rtx_CODE_LABEL (VOIDmode, 0, NULL_RTX, NULL_RTX,
2463                              NULL, label_num++, NULL);
2464 }
2465 \f
2466 /* For procedure integration.  */
2467
2468 /* Install new pointers to the first and last insns in the chain.
2469    Also, set cur_insn_uid to one higher than the last in use.
2470    Used for an inline-procedure after copying the insn chain.  */
2471
2472 void
2473 set_new_first_and_last_insn (first, last)
2474      rtx first, last;
2475 {
2476   rtx insn;
2477
2478   first_insn = first;
2479   last_insn = last;
2480   cur_insn_uid = 0;
2481
2482   for (insn = first; insn; insn = NEXT_INSN (insn))
2483     cur_insn_uid = MAX (cur_insn_uid, INSN_UID (insn));
2484
2485   cur_insn_uid++;
2486 }
2487
2488 /* Set the range of label numbers found in the current function.
2489    This is used when belatedly compiling an inline function.  */
2490
2491 void
2492 set_new_first_and_last_label_num (first, last)
2493      int first, last;
2494 {
2495   base_label_num = label_num;
2496   first_label_num = first;
2497   last_label_num = last;
2498 }
2499
2500 /* Set the last label number found in the current function.
2501    This is used when belatedly compiling an inline function.  */
2502
2503 void
2504 set_new_last_label_num (last)
2505      int last;
2506 {
2507   base_label_num = label_num;
2508   last_label_num = last;
2509 }
2510 \f
2511 /* Restore all variables describing the current status from the structure *P.
2512    This is used after a nested function.  */
2513
2514 void
2515 restore_emit_status (p)
2516      struct function *p ATTRIBUTE_UNUSED;
2517 {
2518   last_label_num = 0;
2519 }
2520 \f
2521 /* Go through all the RTL insn bodies and copy any invalid shared
2522    structure.  This routine should only be called once.  */
2523
2524 void
2525 unshare_all_rtl (fndecl, insn)
2526      tree fndecl;
2527      rtx insn;
2528 {
2529   tree decl;
2530
2531   /* Make sure that virtual parameters are not shared.  */
2532   for (decl = DECL_ARGUMENTS (fndecl); decl; decl = TREE_CHAIN (decl))
2533     SET_DECL_RTL (decl, copy_rtx_if_shared (DECL_RTL (decl)));
2534
2535   /* Make sure that virtual stack slots are not shared.  */
2536   unshare_all_decls (DECL_INITIAL (fndecl));
2537
2538   /* Unshare just about everything else.  */
2539   unshare_all_rtl_1 (insn);
2540
2541   /* Make sure the addresses of stack slots found outside the insn chain
2542      (such as, in DECL_RTL of a variable) are not shared
2543      with the insn chain.
2544
2545      This special care is necessary when the stack slot MEM does not
2546      actually appear in the insn chain.  If it does appear, its address
2547      is unshared from all else at that point.  */
2548   stack_slot_list = copy_rtx_if_shared (stack_slot_list);
2549 }
2550
2551 /* Go through all the RTL insn bodies and copy any invalid shared
2552    structure, again.  This is a fairly expensive thing to do so it
2553    should be done sparingly.  */
2554
2555 void
2556 unshare_all_rtl_again (insn)
2557      rtx insn;
2558 {
2559   rtx p;
2560   tree decl;
2561
2562   for (p = insn; p; p = NEXT_INSN (p))
2563     if (INSN_P (p))
2564       {
2565         reset_used_flags (PATTERN (p));
2566         reset_used_flags (REG_NOTES (p));
2567         reset_used_flags (LOG_LINKS (p));
2568       }
2569
2570   /* Make sure that virtual stack slots are not shared.  */
2571   reset_used_decls (DECL_INITIAL (cfun->decl));
2572
2573   /* Make sure that virtual parameters are not shared.  */
2574   for (decl = DECL_ARGUMENTS (cfun->decl); decl; decl = TREE_CHAIN (decl))
2575     reset_used_flags (DECL_RTL (decl));
2576
2577   reset_used_flags (stack_slot_list);
2578
2579   unshare_all_rtl (cfun->decl, insn);
2580 }
2581
2582 /* Go through all the RTL insn bodies and copy any invalid shared structure.
2583    Assumes the mark bits are cleared at entry.  */
2584
2585 static void
2586 unshare_all_rtl_1 (insn)
2587      rtx insn;
2588 {
2589   for (; insn; insn = NEXT_INSN (insn))
2590     if (INSN_P (insn))
2591       {
2592         PATTERN (insn) = copy_rtx_if_shared (PATTERN (insn));
2593         REG_NOTES (insn) = copy_rtx_if_shared (REG_NOTES (insn));
2594         LOG_LINKS (insn) = copy_rtx_if_shared (LOG_LINKS (insn));
2595       }
2596 }
2597
2598 /* Go through all virtual stack slots of a function and copy any
2599    shared structure.  */
2600 static void
2601 unshare_all_decls (blk)
2602      tree blk;
2603 {
2604   tree t;
2605
2606   /* Copy shared decls.  */
2607   for (t = BLOCK_VARS (blk); t; t = TREE_CHAIN (t))
2608     if (DECL_RTL_SET_P (t))
2609       SET_DECL_RTL (t, copy_rtx_if_shared (DECL_RTL (t)));
2610
2611   /* Now process sub-blocks.  */
2612   for (t = BLOCK_SUBBLOCKS (blk); t; t = TREE_CHAIN (t))
2613     unshare_all_decls (t);
2614 }
2615
2616 /* Go through all virtual stack slots of a function and mark them as
2617    not shared.  */
2618 static void
2619 reset_used_decls (blk)
2620      tree blk;
2621 {
2622   tree t;
2623
2624   /* Mark decls.  */
2625   for (t = BLOCK_VARS (blk); t; t = TREE_CHAIN (t))
2626     if (DECL_RTL_SET_P (t))
2627       reset_used_flags (DECL_RTL (t));
2628
2629   /* Now process sub-blocks.  */
2630   for (t = BLOCK_SUBBLOCKS (blk); t; t = TREE_CHAIN (t))
2631     reset_used_decls (t);
2632 }
2633
2634 /* Similar to `copy_rtx' except that if MAY_SHARE is present, it is
2635    placed in the result directly, rather than being copied.  MAY_SHARE is
2636    either a MEM of an EXPR_LIST of MEMs.  */
2637
2638 rtx
2639 copy_most_rtx (orig, may_share)
2640      rtx orig;
2641      rtx may_share;
2642 {
2643   rtx copy;
2644   int i, j;
2645   RTX_CODE code;
2646   const char *format_ptr;
2647
2648   if (orig == may_share
2649       || (GET_CODE (may_share) == EXPR_LIST
2650           && in_expr_list_p (may_share, orig)))
2651     return orig;
2652
2653   code = GET_CODE (orig);
2654
2655   switch (code)
2656     {
2657     case REG:
2658     case QUEUED:
2659     case CONST_INT:
2660     case CONST_DOUBLE:
2661     case CONST_VECTOR:
2662     case SYMBOL_REF:
2663     case CODE_LABEL:
2664     case PC:
2665     case CC0:
2666       return orig;
2667     default:
2668       break;
2669     }
2670
2671   copy = rtx_alloc (code);
2672   PUT_MODE (copy, GET_MODE (orig));
2673   RTX_FLAG (copy, in_struct) = RTX_FLAG (orig, in_struct);
2674   RTX_FLAG (copy, volatil) = RTX_FLAG (orig, volatil);
2675   RTX_FLAG (copy, unchanging) = RTX_FLAG (orig, unchanging);
2676   RTX_FLAG (copy, integrated) = RTX_FLAG (orig, integrated);
2677   RTX_FLAG (copy, frame_related) = RTX_FLAG (orig, frame_related);
2678
2679   format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
2680
2681   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
2682     {
2683       switch (*format_ptr++)
2684         {
2685         case 'e':
2686           XEXP (copy, i) = XEXP (orig, i);
2687           if (XEXP (orig, i) != NULL && XEXP (orig, i) != may_share)
2688             XEXP (copy, i) = copy_most_rtx (XEXP (orig, i), may_share);
2689           break;
2690
2691         case 'u':
2692           XEXP (copy, i) = XEXP (orig, i);
2693           break;
2694
2695         case 'E':
2696         case 'V':
2697           XVEC (copy, i) = XVEC (orig, i);
2698           if (XVEC (orig, i) != NULL)
2699             {
2700               XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
2701               for (j = 0; j < XVECLEN (copy, i); j++)
2702                 XVECEXP (copy, i, j)
2703                   = copy_most_rtx (XVECEXP (orig, i, j), may_share);
2704             }
2705           break;
2706
2707         case 'w':
2708           XWINT (copy, i) = XWINT (orig, i);
2709           break;
2710
2711         case 'n':
2712         case 'i':
2713           XINT (copy, i) = XINT (orig, i);
2714           break;
2715
2716         case 't':
2717           XTREE (copy, i) = XTREE (orig, i);
2718           break;
2719
2720         case 's':
2721         case 'S':
2722           XSTR (copy, i) = XSTR (orig, i);
2723           break;
2724
2725         case '0':
2726           /* Copy this through the wide int field; that's safest.  */
2727           X0WINT (copy, i) = X0WINT (orig, i);
2728           break;
2729
2730         default:
2731           abort ();
2732         }
2733     }
2734   return copy;
2735 }
2736
2737 /* Mark ORIG as in use, and return a copy of it if it was already in use.
2738    Recursively does the same for subexpressions.  */
2739
2740 rtx
2741 copy_rtx_if_shared (orig)
2742      rtx orig;
2743 {
2744   rtx x = orig;
2745   int i;
2746   enum rtx_code code;
2747   const char *format_ptr;
2748   int copied = 0;
2749
2750   if (x == 0)
2751     return 0;
2752
2753   code = GET_CODE (x);
2754
2755   /* These types may be freely shared.  */
2756
2757   switch (code)
2758     {
2759     case REG:
2760     case QUEUED:
2761     case CONST_INT:
2762     case CONST_DOUBLE:
2763     case CONST_VECTOR:
2764     case SYMBOL_REF:
2765     case CODE_LABEL:
2766     case PC:
2767     case CC0:
2768     case SCRATCH:
2769       /* SCRATCH must be shared because they represent distinct values.  */
2770       return x;
2771
2772     case CONST:
2773       /* CONST can be shared if it contains a SYMBOL_REF.  If it contains
2774          a LABEL_REF, it isn't sharable.  */
2775       if (GET_CODE (XEXP (x, 0)) == PLUS
2776           && GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF
2777           && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT)
2778         return x;
2779       break;
2780
2781     case INSN:
2782     case JUMP_INSN:
2783     case CALL_INSN:
2784     case NOTE:
2785     case BARRIER:
2786       /* The chain of insns is not being copied.  */
2787       return x;
2788
2789     case MEM:
2790       /* A MEM is allowed to be shared if its address is constant.
2791
2792          We used to allow sharing of MEMs which referenced
2793          virtual_stack_vars_rtx or virtual_incoming_args_rtx, but
2794          that can lose.  instantiate_virtual_regs will not unshare
2795          the MEMs, and combine may change the structure of the address
2796          because it looks safe and profitable in one context, but
2797          in some other context it creates unrecognizable RTL.  */
2798       if (CONSTANT_ADDRESS_P (XEXP (x, 0)))
2799         return x;
2800
2801       break;
2802
2803     default:
2804       break;
2805     }
2806
2807   /* This rtx may not be shared.  If it has already been seen,
2808      replace it with a copy of itself.  */
2809
2810   if (RTX_FLAG (x, used))
2811     {
2812       rtx copy;
2813
2814       copy = rtx_alloc (code);
2815       memcpy (copy, x,
2816              (sizeof (*copy) - sizeof (copy->fld)
2817               + sizeof (copy->fld[0]) * GET_RTX_LENGTH (code)));
2818       x = copy;
2819       copied = 1;
2820     }
2821   RTX_FLAG (x, used) = 1;
2822
2823   /* Now scan the subexpressions recursively.
2824      We can store any replaced subexpressions directly into X
2825      since we know X is not shared!  Any vectors in X
2826      must be copied if X was copied.  */
2827
2828   format_ptr = GET_RTX_FORMAT (code);
2829
2830   for (i = 0; i < GET_RTX_LENGTH (code); i++)
2831     {
2832       switch (*format_ptr++)
2833         {
2834         case 'e':
2835           XEXP (x, i) = copy_rtx_if_shared (XEXP (x, i));
2836           break;
2837
2838         case 'E':
2839           if (XVEC (x, i) != NULL)
2840             {
2841               int j;
2842               int len = XVECLEN (x, i);
2843
2844               if (copied && len > 0)
2845                 XVEC (x, i) = gen_rtvec_v (len, XVEC (x, i)->elem);
2846               for (j = 0; j < len; j++)
2847                 XVECEXP (x, i, j) = copy_rtx_if_shared (XVECEXP (x, i, j));
2848             }
2849           break;
2850         }
2851     }
2852   return x;
2853 }
2854
2855 /* Clear all the USED bits in X to allow copy_rtx_if_shared to be used
2856    to look for shared sub-parts.  */
2857
2858 void
2859 reset_used_flags (x)
2860      rtx x;
2861 {
2862   int i, j;
2863   enum rtx_code code;
2864   const char *format_ptr;
2865
2866   if (x == 0)
2867     return;
2868
2869   code = GET_CODE (x);
2870
2871   /* These types may be freely shared so we needn't do any resetting
2872      for them.  */
2873
2874   switch (code)
2875     {
2876     case REG:
2877     case QUEUED:
2878     case CONST_INT:
2879     case CONST_DOUBLE:
2880     case CONST_VECTOR:
2881     case SYMBOL_REF:
2882     case CODE_LABEL:
2883     case PC:
2884     case CC0:
2885       return;
2886
2887     case INSN:
2888     case JUMP_INSN:
2889     case CALL_INSN:
2890     case NOTE:
2891     case LABEL_REF:
2892     case BARRIER:
2893       /* The chain of insns is not being copied.  */
2894       return;
2895
2896     default:
2897       break;
2898     }
2899
2900   RTX_FLAG (x, used) = 0;
2901
2902   format_ptr = GET_RTX_FORMAT (code);
2903   for (i = 0; i < GET_RTX_LENGTH (code); i++)
2904     {
2905       switch (*format_ptr++)
2906         {
2907         case 'e':
2908           reset_used_flags (XEXP (x, i));
2909           break;
2910
2911         case 'E':
2912           for (j = 0; j < XVECLEN (x, i); j++)
2913             reset_used_flags (XVECEXP (x, i, j));
2914           break;
2915         }
2916     }
2917 }
2918 \f
2919 /* Copy X if necessary so that it won't be altered by changes in OTHER.
2920    Return X or the rtx for the pseudo reg the value of X was copied into.
2921    OTHER must be valid as a SET_DEST.  */
2922
2923 rtx
2924 make_safe_from (x, other)
2925      rtx x, other;
2926 {
2927   while (1)
2928     switch (GET_CODE (other))
2929       {
2930       case SUBREG:
2931         other = SUBREG_REG (other);
2932         break;
2933       case STRICT_LOW_PART:
2934       case SIGN_EXTEND:
2935       case ZERO_EXTEND:
2936         other = XEXP (other, 0);
2937         break;
2938       default:
2939         goto done;
2940       }
2941  done:
2942   if ((GET_CODE (other) == MEM
2943        && ! CONSTANT_P (x)
2944        && GET_CODE (x) != REG
2945        && GET_CODE (x) != SUBREG)
2946       || (GET_CODE (other) == REG
2947           && (REGNO (other) < FIRST_PSEUDO_REGISTER
2948               || reg_mentioned_p (other, x))))
2949     {
2950       rtx temp = gen_reg_rtx (GET_MODE (x));
2951       emit_move_insn (temp, x);
2952       return temp;
2953     }
2954   return x;
2955 }
2956 \f
2957 /* Emission of insns (adding them to the doubly-linked list).  */
2958
2959 /* Return the first insn of the current sequence or current function.  */
2960
2961 rtx
2962 get_insns ()
2963 {
2964   return first_insn;
2965 }
2966
2967 /* Specify a new insn as the first in the chain.  */
2968
2969 void
2970 set_first_insn (insn)
2971      rtx insn;
2972 {
2973   if (PREV_INSN (insn) != 0)
2974     abort ();
2975   first_insn = insn;
2976 }
2977
2978 /* Return the last insn emitted in current sequence or current function.  */
2979
2980 rtx
2981 get_last_insn ()
2982 {
2983   return last_insn;
2984 }
2985
2986 /* Specify a new insn as the last in the chain.  */
2987
2988 void
2989 set_last_insn (insn)
2990      rtx insn;
2991 {
2992   if (NEXT_INSN (insn) != 0)
2993     abort ();
2994   last_insn = insn;
2995 }
2996
2997 /* Return the last insn emitted, even if it is in a sequence now pushed.  */
2998
2999 rtx
3000 get_last_insn_anywhere ()
3001 {
3002   struct sequence_stack *stack;
3003   if (last_insn)
3004     return last_insn;
3005   for (stack = seq_stack; stack; stack = stack->next)
3006     if (stack->last != 0)
3007       return stack->last;
3008   return 0;
3009 }
3010
3011 /* Return the first nonnote insn emitted in current sequence or current
3012    function.  This routine looks inside SEQUENCEs.  */
3013
3014 rtx
3015 get_first_nonnote_insn ()
3016 {
3017   rtx insn = first_insn;
3018
3019   while (insn)
3020     {
3021       insn = next_insn (insn);
3022       if (insn == 0 || GET_CODE (insn) != NOTE)
3023         break;
3024     }
3025
3026   return insn;
3027 }
3028
3029 /* Return the last nonnote insn emitted in current sequence or current
3030    function.  This routine looks inside SEQUENCEs.  */
3031
3032 rtx
3033 get_last_nonnote_insn ()
3034 {
3035   rtx insn = last_insn;
3036
3037   while (insn)
3038     {
3039       insn = previous_insn (insn);
3040       if (insn == 0 || GET_CODE (insn) != NOTE)
3041         break;
3042     }
3043
3044   return insn;
3045 }
3046
3047 /* Return a number larger than any instruction's uid in this function.  */
3048
3049 int
3050 get_max_uid ()
3051 {
3052   return cur_insn_uid;
3053 }
3054
3055 /* Renumber instructions so that no instruction UIDs are wasted.  */
3056
3057 void
3058 renumber_insns (stream)
3059      FILE *stream;
3060 {
3061   rtx insn;
3062
3063   /* If we're not supposed to renumber instructions, don't.  */
3064   if (!flag_renumber_insns)
3065     return;
3066
3067   /* If there aren't that many instructions, then it's not really
3068      worth renumbering them.  */
3069   if (flag_renumber_insns == 1 && get_max_uid () < 25000)
3070     return;
3071
3072   cur_insn_uid = 1;
3073
3074   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
3075     {
3076       if (stream)
3077         fprintf (stream, "Renumbering insn %d to %d\n",
3078                  INSN_UID (insn), cur_insn_uid);
3079       INSN_UID (insn) = cur_insn_uid++;
3080     }
3081 }
3082 \f
3083 /* Return the next insn.  If it is a SEQUENCE, return the first insn
3084    of the sequence.  */
3085
3086 rtx
3087 next_insn (insn)
3088      rtx insn;
3089 {
3090   if (insn)
3091     {
3092       insn = NEXT_INSN (insn);
3093       if (insn && GET_CODE (insn) == INSN
3094           && GET_CODE (PATTERN (insn)) == SEQUENCE)
3095         insn = XVECEXP (PATTERN (insn), 0, 0);
3096     }
3097
3098   return insn;
3099 }
3100
3101 /* Return the previous insn.  If it is a SEQUENCE, return the last insn
3102    of the sequence.  */
3103
3104 rtx
3105 previous_insn (insn)
3106      rtx insn;
3107 {
3108   if (insn)
3109     {
3110       insn = PREV_INSN (insn);
3111       if (insn && GET_CODE (insn) == INSN
3112           && GET_CODE (PATTERN (insn)) == SEQUENCE)
3113         insn = XVECEXP (PATTERN (insn), 0, XVECLEN (PATTERN (insn), 0) - 1);
3114     }
3115
3116   return insn;
3117 }
3118
3119 /* Return the next insn after INSN that is not a NOTE.  This routine does not
3120    look inside SEQUENCEs.  */
3121
3122 rtx
3123 next_nonnote_insn (insn)
3124      rtx insn;
3125 {
3126   while (insn)
3127     {
3128       insn = NEXT_INSN (insn);
3129       if (insn == 0 || GET_CODE (insn) != NOTE)
3130         break;
3131     }
3132
3133   return insn;
3134 }
3135
3136 /* Return the previous insn before INSN that is not a NOTE.  This routine does
3137    not look inside SEQUENCEs.  */
3138
3139 rtx
3140 prev_nonnote_insn (insn)
3141      rtx insn;
3142 {
3143   while (insn)
3144     {
3145       insn = PREV_INSN (insn);
3146       if (insn == 0 || GET_CODE (insn) != NOTE)
3147         break;
3148     }
3149
3150   return insn;
3151 }
3152
3153 /* Return the next INSN, CALL_INSN or JUMP_INSN after INSN;
3154    or 0, if there is none.  This routine does not look inside
3155    SEQUENCEs.  */
3156
3157 rtx
3158 next_real_insn (insn)
3159      rtx insn;
3160 {
3161   while (insn)
3162     {
3163       insn = NEXT_INSN (insn);
3164       if (insn == 0 || GET_CODE (insn) == INSN
3165           || GET_CODE (insn) == CALL_INSN || GET_CODE (insn) == JUMP_INSN)
3166         break;
3167     }
3168
3169   return insn;
3170 }
3171
3172 /* Return the last INSN, CALL_INSN or JUMP_INSN before INSN;
3173    or 0, if there is none.  This routine does not look inside
3174    SEQUENCEs.  */
3175
3176 rtx
3177 prev_real_insn (insn)
3178      rtx insn;
3179 {
3180   while (insn)
3181     {
3182       insn = PREV_INSN (insn);
3183       if (insn == 0 || GET_CODE (insn) == INSN || GET_CODE (insn) == CALL_INSN
3184           || GET_CODE (insn) == JUMP_INSN)
3185         break;
3186     }
3187
3188   return insn;
3189 }
3190
3191 /* Find the next insn after INSN that really does something.  This routine
3192    does not look inside SEQUENCEs.  Until reload has completed, this is the
3193    same as next_real_insn.  */
3194
3195 int
3196 active_insn_p (insn)
3197      rtx insn;
3198 {
3199   return (GET_CODE (insn) == CALL_INSN || GET_CODE (insn) == JUMP_INSN
3200           || (GET_CODE (insn) == INSN
3201               && (! reload_completed
3202                   || (GET_CODE (PATTERN (insn)) != USE
3203                       && GET_CODE (PATTERN (insn)) != CLOBBER))));
3204 }
3205
3206 rtx
3207 next_active_insn (insn)
3208      rtx insn;
3209 {
3210   while (insn)
3211     {
3212       insn = NEXT_INSN (insn);
3213       if (insn == 0 || active_insn_p (insn))
3214         break;
3215     }
3216
3217   return insn;
3218 }
3219
3220 /* Find the last insn before INSN that really does something.  This routine
3221    does not look inside SEQUENCEs.  Until reload has completed, this is the
3222    same as prev_real_insn.  */
3223
3224 rtx
3225 prev_active_insn (insn)
3226      rtx insn;
3227 {
3228   while (insn)
3229     {
3230       insn = PREV_INSN (insn);
3231       if (insn == 0 || active_insn_p (insn))
3232         break;
3233     }
3234
3235   return insn;
3236 }
3237
3238 /* Return the next CODE_LABEL after the insn INSN, or 0 if there is none.  */
3239
3240 rtx
3241 next_label (insn)
3242      rtx insn;
3243 {
3244   while (insn)
3245     {
3246       insn = NEXT_INSN (insn);
3247       if (insn == 0 || GET_CODE (insn) == CODE_LABEL)
3248         break;
3249     }
3250
3251   return insn;
3252 }
3253
3254 /* Return the last CODE_LABEL before the insn INSN, or 0 if there is none.  */
3255
3256 rtx
3257 prev_label (insn)
3258      rtx insn;
3259 {
3260   while (insn)
3261     {
3262       insn = PREV_INSN (insn);
3263       if (insn == 0 || GET_CODE (insn) == CODE_LABEL)
3264         break;
3265     }
3266
3267   return insn;
3268 }
3269 \f
3270 #ifdef HAVE_cc0
3271 /* INSN uses CC0 and is being moved into a delay slot.  Set up REG_CC_SETTER
3272    and REG_CC_USER notes so we can find it.  */
3273
3274 void
3275 link_cc0_insns (insn)
3276      rtx insn;
3277 {
3278   rtx user = next_nonnote_insn (insn);
3279
3280   if (GET_CODE (user) == INSN && GET_CODE (PATTERN (user)) == SEQUENCE)
3281     user = XVECEXP (PATTERN (user), 0, 0);
3282
3283   REG_NOTES (user) = gen_rtx_INSN_LIST (REG_CC_SETTER, insn,
3284                                         REG_NOTES (user));
3285   REG_NOTES (insn) = gen_rtx_INSN_LIST (REG_CC_USER, user, REG_NOTES (insn));
3286 }
3287
3288 /* Return the next insn that uses CC0 after INSN, which is assumed to
3289    set it.  This is the inverse of prev_cc0_setter (i.e., prev_cc0_setter
3290    applied to the result of this function should yield INSN).
3291
3292    Normally, this is simply the next insn.  However, if a REG_CC_USER note
3293    is present, it contains the insn that uses CC0.
3294
3295    Return 0 if we can't find the insn.  */
3296
3297 rtx
3298 next_cc0_user (insn)
3299      rtx insn;
3300 {
3301   rtx note = find_reg_note (insn, REG_CC_USER, NULL_RTX);
3302
3303   if (note)
3304     return XEXP (note, 0);
3305
3306   insn = next_nonnote_insn (insn);
3307   if (insn && GET_CODE (insn) == INSN && GET_CODE (PATTERN (insn)) == SEQUENCE)
3308     insn = XVECEXP (PATTERN (insn), 0, 0);
3309
3310   if (insn && INSN_P (insn) && reg_mentioned_p (cc0_rtx, PATTERN (insn)))
3311     return insn;
3312
3313   return 0;
3314 }
3315
3316 /* Find the insn that set CC0 for INSN.  Unless INSN has a REG_CC_SETTER
3317    note, it is the previous insn.  */
3318
3319 rtx
3320 prev_cc0_setter (insn)
3321      rtx insn;
3322 {
3323   rtx note = find_reg_note (insn, REG_CC_SETTER, NULL_RTX);
3324
3325   if (note)
3326     return XEXP (note, 0);
3327
3328   insn = prev_nonnote_insn (insn);
3329   if (! sets_cc0_p (PATTERN (insn)))
3330     abort ();
3331
3332   return insn;
3333 }
3334 #endif
3335
3336 /* Increment the label uses for all labels present in rtx.  */
3337
3338 static void
3339 mark_label_nuses (x)
3340      rtx x;
3341 {
3342   enum rtx_code code;
3343   int i, j;
3344   const char *fmt;
3345
3346   code = GET_CODE (x);
3347   if (code == LABEL_REF)
3348     LABEL_NUSES (XEXP (x, 0))++;
3349
3350   fmt = GET_RTX_FORMAT (code);
3351   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
3352     {
3353       if (fmt[i] == 'e')
3354         mark_label_nuses (XEXP (x, i));
3355       else if (fmt[i] == 'E')
3356         for (j = XVECLEN (x, i) - 1; j >= 0; j--)
3357           mark_label_nuses (XVECEXP (x, i, j));
3358     }
3359 }
3360
3361 \f
3362 /* Try splitting insns that can be split for better scheduling.
3363    PAT is the pattern which might split.
3364    TRIAL is the insn providing PAT.
3365    LAST is nonzero if we should return the last insn of the sequence produced.
3366
3367    If this routine succeeds in splitting, it returns the first or last
3368    replacement insn depending on the value of LAST.  Otherwise, it
3369    returns TRIAL.  If the insn to be returned can be split, it will be.  */
3370
3371 rtx
3372 try_split (pat, trial, last)
3373      rtx pat, trial;
3374      int last;
3375 {
3376   rtx before = PREV_INSN (trial);
3377   rtx after = NEXT_INSN (trial);
3378   int has_barrier = 0;
3379   rtx tem;
3380   rtx note, seq;
3381   int probability;
3382   rtx insn_last, insn;
3383   int njumps = 0;
3384
3385   if (any_condjump_p (trial)
3386       && (note = find_reg_note (trial, REG_BR_PROB, 0)))
3387     split_branch_probability = INTVAL (XEXP (note, 0));
3388   probability = split_branch_probability;
3389
3390   seq = split_insns (pat, trial);
3391
3392   split_branch_probability = -1;
3393
3394   /* If we are splitting a JUMP_INSN, it might be followed by a BARRIER.
3395      We may need to handle this specially.  */
3396   if (after && GET_CODE (after) == BARRIER)
3397     {
3398       has_barrier = 1;
3399       after = NEXT_INSN (after);
3400     }
3401
3402   if (!seq)
3403     return trial;
3404
3405   /* Avoid infinite loop if any insn of the result matches
3406      the original pattern.  */
3407   insn_last = seq;
3408   while (1)
3409     {
3410       if (INSN_P (insn_last)
3411           && rtx_equal_p (PATTERN (insn_last), pat))
3412         return trial;
3413       if (!NEXT_INSN (insn_last))
3414         break;
3415       insn_last = NEXT_INSN (insn_last);
3416     }
3417
3418   /* Mark labels.  */
3419   for (insn = insn_last; insn ; insn = PREV_INSN (insn))
3420     {
3421       if (GET_CODE (insn) == JUMP_INSN)
3422         {
3423           mark_jump_label (PATTERN (insn), insn, 0);
3424           njumps++;
3425           if (probability != -1
3426               && any_condjump_p (insn)
3427               && !find_reg_note (insn, REG_BR_PROB, 0))
3428             {
3429               /* We can preserve the REG_BR_PROB notes only if exactly
3430                  one jump is created, otherwise the machine description
3431                  is responsible for this step using
3432                  split_branch_probability variable.  */
3433               if (njumps != 1)
3434                 abort ();
3435               REG_NOTES (insn)
3436                 = gen_rtx_EXPR_LIST (REG_BR_PROB,
3437                                      GEN_INT (probability),
3438                                      REG_NOTES (insn));
3439             }
3440         }
3441     }
3442
3443   /* If we are splitting a CALL_INSN, look for the CALL_INSN
3444      in SEQ and copy our CALL_INSN_FUNCTION_USAGE to it.  */
3445   if (GET_CODE (trial) == CALL_INSN)
3446     {
3447       for (insn = insn_last; insn ; insn = PREV_INSN (insn))
3448         if (GET_CODE (insn) == CALL_INSN)
3449           {
3450             CALL_INSN_FUNCTION_USAGE (insn)
3451               = CALL_INSN_FUNCTION_USAGE (trial);
3452             SIBLING_CALL_P (insn) = SIBLING_CALL_P (trial);
3453           }
3454     }
3455
3456   /* Copy notes, particularly those related to the CFG.  */
3457   for (note = REG_NOTES (trial); note; note = XEXP (note, 1))
3458     {
3459       switch (REG_NOTE_KIND (note))
3460         {
3461         case REG_EH_REGION:
3462           insn = insn_last;
3463           while (insn != NULL_RTX)
3464             {
3465               if (GET_CODE (insn) == CALL_INSN
3466                   || (flag_non_call_exceptions
3467                       && may_trap_p (PATTERN (insn))))
3468                 REG_NOTES (insn)
3469                   = gen_rtx_EXPR_LIST (REG_EH_REGION,
3470                                        XEXP (note, 0),
3471                                        REG_NOTES (insn));
3472               insn = PREV_INSN (insn);
3473             }
3474           break;
3475
3476         case REG_NORETURN:
3477         case REG_SETJMP:
3478         case REG_ALWAYS_RETURN:
3479           insn = insn_last;
3480           while (insn != NULL_RTX)
3481             {
3482               if (GET_CODE (insn) == CALL_INSN)
3483                 REG_NOTES (insn)
3484                   = gen_rtx_EXPR_LIST (REG_NOTE_KIND (note),
3485                                        XEXP (note, 0),
3486                                        REG_NOTES (insn));
3487               insn = PREV_INSN (insn);
3488             }
3489           break;
3490
3491         case REG_NON_LOCAL_GOTO:
3492           insn = insn_last;
3493           while (insn != NULL_RTX)
3494             {
3495               if (GET_CODE (insn) == JUMP_INSN)
3496                 REG_NOTES (insn)
3497                   = gen_rtx_EXPR_LIST (REG_NOTE_KIND (note),
3498                                        XEXP (note, 0),
3499                                        REG_NOTES (insn));
3500               insn = PREV_INSN (insn);
3501             }
3502           break;
3503
3504         default:
3505           break;
3506         }
3507     }
3508
3509   /* If there are LABELS inside the split insns increment the
3510      usage count so we don't delete the label.  */
3511   if (GET_CODE (trial) == INSN)
3512     {
3513       insn = insn_last;
3514       while (insn != NULL_RTX)
3515         {
3516           if (GET_CODE (insn) == INSN)
3517             mark_label_nuses (PATTERN (insn));
3518
3519           insn = PREV_INSN (insn);
3520         }
3521     }
3522
3523   tem = emit_insn_after_scope (seq, trial, INSN_SCOPE (trial));
3524
3525   delete_insn (trial);
3526   if (has_barrier)
3527     emit_barrier_after (tem);
3528
3529   /* Recursively call try_split for each new insn created; by the
3530      time control returns here that insn will be fully split, so
3531      set LAST and continue from the insn after the one returned.
3532      We can't use next_active_insn here since AFTER may be a note.
3533      Ignore deleted insns, which can be occur if not optimizing.  */
3534   for (tem = NEXT_INSN (before); tem != after; tem = NEXT_INSN (tem))
3535     if (! INSN_DELETED_P (tem) && INSN_P (tem))
3536       tem = try_split (PATTERN (tem), tem, 1);
3537
3538   /* Return either the first or the last insn, depending on which was
3539      requested.  */
3540   return last
3541     ? (after ? PREV_INSN (after) : last_insn)
3542     : NEXT_INSN (before);
3543 }
3544 \f
3545 /* Make and return an INSN rtx, initializing all its slots.
3546    Store PATTERN in the pattern slots.  */
3547
3548 rtx
3549 make_insn_raw (pattern)
3550      rtx pattern;
3551 {
3552   rtx insn;
3553
3554   insn = rtx_alloc (INSN);
3555
3556   INSN_UID (insn) = cur_insn_uid++;
3557   PATTERN (insn) = pattern;
3558   INSN_CODE (insn) = -1;
3559   LOG_LINKS (insn) = NULL;
3560   REG_NOTES (insn) = NULL;
3561   INSN_SCOPE (insn) = NULL;
3562   BLOCK_FOR_INSN (insn) = NULL;
3563
3564 #ifdef ENABLE_RTL_CHECKING
3565   if (insn
3566       && INSN_P (insn)
3567       && (returnjump_p (insn)
3568           || (GET_CODE (insn) == SET
3569               && SET_DEST (insn) == pc_rtx)))
3570     {
3571       warning ("ICE: emit_insn used where emit_jump_insn needed:\n");
3572       debug_rtx (insn);
3573     }
3574 #endif
3575
3576   return insn;
3577 }
3578
3579 /* Like `make_insn_raw' but make a JUMP_INSN instead of an insn.  */
3580
3581 static rtx
3582 make_jump_insn_raw (pattern)
3583      rtx pattern;
3584 {
3585   rtx insn;
3586
3587   insn = rtx_alloc (JUMP_INSN);
3588   INSN_UID (insn) = cur_insn_uid++;
3589
3590   PATTERN (insn) = pattern;
3591   INSN_CODE (insn) = -1;
3592   LOG_LINKS (insn) = NULL;
3593   REG_NOTES (insn) = NULL;
3594   JUMP_LABEL (insn) = NULL;
3595   INSN_SCOPE (insn) = NULL;
3596   BLOCK_FOR_INSN (insn) = NULL;
3597
3598   return insn;
3599 }
3600
3601 /* Like `make_insn_raw' but make a CALL_INSN instead of an insn.  */
3602
3603 static rtx
3604 make_call_insn_raw (pattern)
3605      rtx pattern;
3606 {
3607   rtx insn;
3608
3609   insn = rtx_alloc (CALL_INSN);
3610   INSN_UID (insn) = cur_insn_uid++;
3611
3612   PATTERN (insn) = pattern;
3613   INSN_CODE (insn) = -1;
3614   LOG_LINKS (insn) = NULL;
3615   REG_NOTES (insn) = NULL;
3616   CALL_INSN_FUNCTION_USAGE (insn) = NULL;
3617   INSN_SCOPE (insn) = NULL;
3618   BLOCK_FOR_INSN (insn) = NULL;
3619
3620   return insn;
3621 }
3622 \f
3623 /* Add INSN to the end of the doubly-linked list.
3624    INSN may be an INSN, JUMP_INSN, CALL_INSN, CODE_LABEL, BARRIER or NOTE.  */
3625
3626 void
3627 add_insn (insn)
3628      rtx insn;
3629 {
3630   PREV_INSN (insn) = last_insn;
3631   NEXT_INSN (insn) = 0;
3632
3633   if (NULL != last_insn)
3634     NEXT_INSN (last_insn) = insn;
3635
3636   if (NULL == first_insn)
3637     first_insn = insn;
3638
3639   last_insn = insn;
3640 }
3641
3642 /* Add INSN into the doubly-linked list after insn AFTER.  This and
3643    the next should be the only functions called to insert an insn once
3644    delay slots have been filled since only they know how to update a
3645    SEQUENCE.  */
3646
3647 void
3648 add_insn_after (insn, after)
3649      rtx insn, after;
3650 {
3651   rtx next = NEXT_INSN (after);
3652   basic_block bb;
3653
3654   if (optimize && INSN_DELETED_P (after))
3655     abort ();
3656
3657   NEXT_INSN (insn) = next;
3658   PREV_INSN (insn) = after;
3659
3660   if (next)
3661     {
3662       PREV_INSN (next) = insn;
3663       if (GET_CODE (next) == INSN && GET_CODE (PATTERN (next)) == SEQUENCE)
3664         PREV_INSN (XVECEXP (PATTERN (next), 0, 0)) = insn;
3665     }
3666   else if (last_insn == after)
3667     last_insn = insn;
3668   else
3669     {
3670       struct sequence_stack *stack = seq_stack;
3671       /* Scan all pending sequences too.  */
3672       for (; stack; stack = stack->next)
3673         if (after == stack->last)
3674           {
3675             stack->last = insn;
3676             break;
3677           }
3678
3679       if (stack == 0)
3680         abort ();
3681     }
3682
3683   if (GET_CODE (after) != BARRIER
3684       && GET_CODE (insn) != BARRIER
3685       && (bb = BLOCK_FOR_INSN (after)))
3686     {
3687       set_block_for_insn (insn, bb);
3688       if (INSN_P (insn))
3689         bb->flags |= BB_DIRTY;
3690       /* Should not happen as first in the BB is always
3691          either NOTE or LABEL.  */
3692       if (bb->end == after
3693           /* Avoid clobbering of structure when creating new BB.  */
3694           && GET_CODE (insn) != BARRIER
3695           && (GET_CODE (insn) != NOTE
3696               || NOTE_LINE_NUMBER (insn) != NOTE_INSN_BASIC_BLOCK))
3697         bb->end = insn;
3698     }
3699
3700   NEXT_INSN (after) = insn;
3701   if (GET_CODE (after) == INSN && GET_CODE (PATTERN (after)) == SEQUENCE)
3702     {
3703       rtx sequence = PATTERN (after);
3704       NEXT_INSN (XVECEXP (sequence, 0, XVECLEN (sequence, 0) - 1)) = insn;
3705     }
3706 }
3707
3708 /* Add INSN into the doubly-linked list before insn BEFORE.  This and
3709    the previous should be the only functions called to insert an insn once
3710    delay slots have been filled since only they know how to update a
3711    SEQUENCE.  */
3712
3713 void
3714 add_insn_before (insn, before)
3715      rtx insn, before;
3716 {
3717   rtx prev = PREV_INSN (before);
3718   basic_block bb;
3719
3720   if (optimize && INSN_DELETED_P (before))
3721     abort ();
3722
3723   PREV_INSN (insn) = prev;
3724   NEXT_INSN (insn) = before;
3725
3726   if (prev)
3727     {
3728       NEXT_INSN (prev) = insn;
3729       if (GET_CODE (prev) == INSN && GET_CODE (PATTERN (prev)) == SEQUENCE)
3730         {
3731           rtx sequence = PATTERN (prev);
3732           NEXT_INSN (XVECEXP (sequence, 0, XVECLEN (sequence, 0) - 1)) = insn;
3733         }
3734     }
3735   else if (first_insn == before)
3736     first_insn = insn;
3737   else
3738     {
3739       struct sequence_stack *stack = seq_stack;
3740       /* Scan all pending sequences too.  */
3741       for (; stack; stack = stack->next)
3742         if (before == stack->first)
3743           {
3744             stack->first = insn;
3745             break;
3746           }
3747
3748       if (stack == 0)
3749         abort ();
3750     }
3751
3752   if (GET_CODE (before) != BARRIER
3753       && GET_CODE (insn) != BARRIER
3754       && (bb = BLOCK_FOR_INSN (before)))
3755     {
3756       set_block_for_insn (insn, bb);
3757       if (INSN_P (insn))
3758         bb->flags |= BB_DIRTY;
3759       /* Should not happen as first in the BB is always
3760          either NOTE or LABEl.  */
3761       if (bb->head == insn
3762           /* Avoid clobbering of structure when creating new BB.  */
3763           && GET_CODE (insn) != BARRIER
3764           && (GET_CODE (insn) != NOTE
3765               || NOTE_LINE_NUMBER (insn) != NOTE_INSN_BASIC_BLOCK))
3766         abort ();
3767     }
3768
3769   PREV_INSN (before) = insn;
3770   if (GET_CODE (before) == INSN && GET_CODE (PATTERN (before)) == SEQUENCE)
3771     PREV_INSN (XVECEXP (PATTERN (before), 0, 0)) = insn;
3772 }
3773
3774 /* Remove an insn from its doubly-linked list.  This function knows how
3775    to handle sequences.  */
3776 void
3777 remove_insn (insn)
3778      rtx insn;
3779 {
3780   rtx next = NEXT_INSN (insn);
3781   rtx prev = PREV_INSN (insn);
3782   basic_block bb;
3783
3784   if (prev)
3785     {
3786       NEXT_INSN (prev) = next;
3787       if (GET_CODE (prev) == INSN && GET_CODE (PATTERN (prev)) == SEQUENCE)
3788         {
3789           rtx sequence = PATTERN (prev);
3790           NEXT_INSN (XVECEXP (sequence, 0, XVECLEN (sequence, 0) - 1)) = next;
3791         }
3792     }
3793   else if (first_insn == insn)
3794     first_insn = next;
3795   else
3796     {
3797       struct sequence_stack *stack = seq_stack;
3798       /* Scan all pending sequences too.  */
3799       for (; stack; stack = stack->next)
3800         if (insn == stack->first)
3801           {
3802             stack->first = next;
3803             break;
3804           }
3805
3806       if (stack == 0)
3807         abort ();
3808     }
3809
3810   if (next)
3811     {
3812       PREV_INSN (next) = prev;
3813       if (GET_CODE (next) == INSN && GET_CODE (PATTERN (next)) == SEQUENCE)
3814         PREV_INSN (XVECEXP (PATTERN (next), 0, 0)) = prev;
3815     }
3816   else if (last_insn == insn)
3817     last_insn = prev;
3818   else
3819     {
3820       struct sequence_stack *stack = seq_stack;
3821       /* Scan all pending sequences too.  */
3822       for (; stack; stack = stack->next)
3823         if (insn == stack->last)
3824           {
3825             stack->last = prev;
3826             break;
3827           }
3828
3829       if (stack == 0)
3830         abort ();
3831     }
3832   if (GET_CODE (insn) != BARRIER
3833       && (bb = BLOCK_FOR_INSN (insn)))
3834     {
3835       if (INSN_P (insn))
3836         bb->flags |= BB_DIRTY;
3837       if (bb->head == insn)
3838         {
3839           /* Never ever delete the basic block note without deleting whole
3840              basic block.  */
3841           if (GET_CODE (insn) == NOTE)
3842             abort ();
3843           bb->head = next;
3844         }
3845       if (bb->end == insn)
3846         bb->end = prev;
3847     }
3848 }
3849
3850 /* Delete all insns made since FROM.
3851    FROM becomes the new last instruction.  */
3852
3853 void
3854 delete_insns_since (from)
3855      rtx from;
3856 {
3857   if (from == 0)
3858     first_insn = 0;
3859   else
3860     NEXT_INSN (from) = 0;
3861   last_insn = from;
3862 }
3863
3864 /* This function is deprecated, please use sequences instead.
3865
3866    Move a consecutive bunch of insns to a different place in the chain.
3867    The insns to be moved are those between FROM and TO.
3868    They are moved to a new position after the insn AFTER.
3869    AFTER must not be FROM or TO or any insn in between.
3870
3871    This function does not know about SEQUENCEs and hence should not be
3872    called after delay-slot filling has been done.  */
3873
3874 void
3875 reorder_insns_nobb (from, to, after)
3876      rtx from, to, after;
3877 {
3878   /* Splice this bunch out of where it is now.  */
3879   if (PREV_INSN (from))
3880     NEXT_INSN (PREV_INSN (from)) = NEXT_INSN (to);
3881   if (NEXT_INSN (to))
3882     PREV_INSN (NEXT_INSN (to)) = PREV_INSN (from);
3883   if (last_insn == to)
3884     last_insn = PREV_INSN (from);
3885   if (first_insn == from)
3886     first_insn = NEXT_INSN (to);
3887
3888   /* Make the new neighbors point to it and it to them.  */
3889   if (NEXT_INSN (after))
3890     PREV_INSN (NEXT_INSN (after)) = to;
3891
3892   NEXT_INSN (to) = NEXT_INSN (after);
3893   PREV_INSN (from) = after;
3894   NEXT_INSN (after) = from;
3895   if (after == last_insn)
3896     last_insn = to;
3897 }
3898
3899 /* Same as function above, but take care to update BB boundaries.  */
3900 void
3901 reorder_insns (from, to, after)
3902      rtx from, to, after;
3903 {
3904   rtx prev = PREV_INSN (from);
3905   basic_block bb, bb2;
3906
3907   reorder_insns_nobb (from, to, after);
3908
3909   if (GET_CODE (after) != BARRIER
3910       && (bb = BLOCK_FOR_INSN (after)))
3911     {
3912       rtx x;
3913       bb->flags |= BB_DIRTY;
3914
3915       if (GET_CODE (from) != BARRIER
3916           && (bb2 = BLOCK_FOR_INSN (from)))
3917         {
3918           if (bb2->end == to)
3919             bb2->end = prev;
3920           bb2->flags |= BB_DIRTY;
3921         }
3922
3923       if (bb->end == after)
3924         bb->end = to;
3925
3926       for (x = from; x != NEXT_INSN (to); x = NEXT_INSN (x))
3927         set_block_for_insn (x, bb);
3928     }
3929 }
3930
3931 /* Return the line note insn preceding INSN.  */
3932
3933 static rtx
3934 find_line_note (insn)
3935      rtx insn;
3936 {
3937   if (no_line_numbers)
3938     return 0;
3939
3940   for (; insn; insn = PREV_INSN (insn))
3941     if (GET_CODE (insn) == NOTE
3942         && NOTE_LINE_NUMBER (insn) >= 0)
3943       break;
3944
3945   return insn;
3946 }
3947
3948 /* Like reorder_insns, but inserts line notes to preserve the line numbers
3949    of the moved insns when debugging.  This may insert a note between AFTER
3950    and FROM, and another one after TO.  */
3951
3952 void
3953 reorder_insns_with_line_notes (from, to, after)
3954      rtx from, to, after;
3955 {
3956   rtx from_line = find_line_note (from);
3957   rtx after_line = find_line_note (after);
3958
3959   reorder_insns (from, to, after);
3960
3961   if (from_line == after_line)
3962     return;
3963
3964   if (from_line)
3965     emit_line_note_after (NOTE_SOURCE_FILE (from_line),
3966                           NOTE_LINE_NUMBER (from_line),
3967                           after);
3968   if (after_line)
3969     emit_line_note_after (NOTE_SOURCE_FILE (after_line),
3970                           NOTE_LINE_NUMBER (after_line),
3971                           to);
3972 }
3973
3974 /* Remove unnecessary notes from the instruction stream.  */
3975
3976 void
3977 remove_unnecessary_notes ()
3978 {
3979   rtx block_stack = NULL_RTX;
3980   rtx eh_stack = NULL_RTX;
3981   rtx insn;
3982   rtx next;
3983   rtx tmp;
3984
3985   /* We must not remove the first instruction in the function because
3986      the compiler depends on the first instruction being a note.  */
3987   for (insn = NEXT_INSN (get_insns ()); insn; insn = next)
3988     {
3989       /* Remember what's next.  */
3990       next = NEXT_INSN (insn);
3991
3992       /* We're only interested in notes.  */
3993       if (GET_CODE (insn) != NOTE)
3994         continue;
3995
3996       switch (NOTE_LINE_NUMBER (insn))
3997         {
3998         case NOTE_INSN_DELETED:
3999         case NOTE_INSN_LOOP_END_TOP_COND:
4000           remove_insn (insn);
4001           break;
4002
4003         case NOTE_INSN_EH_REGION_BEG:
4004           eh_stack = alloc_INSN_LIST (insn, eh_stack);
4005           break;
4006
4007         case NOTE_INSN_EH_REGION_END:
4008           /* Too many end notes.  */
4009           if (eh_stack == NULL_RTX)
4010             abort ();
4011           /* Mismatched nesting.  */
4012           if (NOTE_EH_HANDLER (XEXP (eh_stack, 0)) != NOTE_EH_HANDLER (insn))
4013             abort ();
4014           tmp = eh_stack;
4015           eh_stack = XEXP (eh_stack, 1);
4016           free_INSN_LIST_node (tmp);
4017           break;
4018
4019         case NOTE_INSN_BLOCK_BEG:
4020           /* By now, all notes indicating lexical blocks should have
4021              NOTE_BLOCK filled in.  */
4022           if (NOTE_BLOCK (insn) == NULL_TREE)
4023             abort ();
4024           block_stack = alloc_INSN_LIST (insn, block_stack);
4025           break;
4026
4027         case NOTE_INSN_BLOCK_END:
4028           /* Too many end notes.  */
4029           if (block_stack == NULL_RTX)
4030             abort ();
4031           /* Mismatched nesting.  */
4032           if (NOTE_BLOCK (XEXP (block_stack, 0)) != NOTE_BLOCK (insn))
4033             abort ();
4034           tmp = block_stack;
4035           block_stack = XEXP (block_stack, 1);
4036           free_INSN_LIST_node (tmp);
4037
4038           /* Scan back to see if there are any non-note instructions
4039              between INSN and the beginning of this block.  If not,
4040              then there is no PC range in the generated code that will
4041              actually be in this block, so there's no point in
4042              remembering the existence of the block.  */
4043           for (tmp = PREV_INSN (insn); tmp; tmp = PREV_INSN (tmp))
4044             {
4045               /* This block contains a real instruction.  Note that we
4046                  don't include labels; if the only thing in the block
4047                  is a label, then there are still no PC values that
4048                  lie within the block.  */
4049               if (INSN_P (tmp))
4050                 break;
4051
4052               /* We're only interested in NOTEs.  */
4053               if (GET_CODE (tmp) != NOTE)
4054                 continue;
4055
4056               if (NOTE_LINE_NUMBER (tmp) == NOTE_INSN_BLOCK_BEG)
4057                 {
4058                   /* We just verified that this BLOCK matches us with
4059                      the block_stack check above.  Never delete the
4060                      BLOCK for the outermost scope of the function; we
4061                      can refer to names from that scope even if the
4062                      block notes are messed up.  */
4063                   if (! is_body_block (NOTE_BLOCK (insn))
4064                       && (*debug_hooks->ignore_block) (NOTE_BLOCK (insn)))
4065                     {
4066                       remove_insn (tmp);
4067                       remove_insn (insn);
4068                     }
4069                   break;
4070                 }
4071               else if (NOTE_LINE_NUMBER (tmp) == NOTE_INSN_BLOCK_END)
4072                 /* There's a nested block.  We need to leave the
4073                    current block in place since otherwise the debugger
4074                    wouldn't be able to show symbols from our block in
4075                    the nested block.  */
4076                 break;
4077             }
4078         }
4079     }
4080
4081   /* Too many begin notes.  */
4082   if (block_stack || eh_stack)
4083     abort ();
4084 }
4085
4086 \f
4087 /* Emit insn(s) of given code and pattern
4088    at a specified place within the doubly-linked list.
4089
4090    All of the emit_foo global entry points accept an object
4091    X which is either an insn list or a PATTERN of a single
4092    instruction.
4093
4094    There are thus a few canonical ways to generate code and
4095    emit it at a specific place in the instruction stream.  For
4096    example, consider the instruction named SPOT and the fact that
4097    we would like to emit some instructions before SPOT.  We might
4098    do it like this:
4099
4100         start_sequence ();
4101         ... emit the new instructions ...
4102         insns_head = get_insns ();
4103         end_sequence ();
4104
4105         emit_insn_before (insns_head, SPOT);
4106
4107    It used to be common to generate SEQUENCE rtl instead, but that
4108    is a relic of the past which no longer occurs.  The reason is that
4109    SEQUENCE rtl results in much fragmented RTL memory since the SEQUENCE
4110    generated would almost certainly die right after it was created.  */
4111
4112 /* Make X be output before the instruction BEFORE.  */
4113
4114 rtx
4115 emit_insn_before (x, before)
4116      rtx x, before;
4117 {
4118   rtx last = before;
4119   rtx insn;
4120
4121 #ifdef ENABLE_RTL_CHECKING
4122   if (before == NULL_RTX)
4123     abort ();
4124 #endif
4125
4126   if (x == NULL_RTX)
4127     return last;
4128
4129   switch (GET_CODE (x))
4130     {
4131     case INSN:
4132     case JUMP_INSN:
4133     case CALL_INSN:
4134     case CODE_LABEL:
4135     case BARRIER:
4136     case NOTE:
4137       insn = x;
4138       while (insn)
4139         {
4140           rtx next = NEXT_INSN (insn);
4141           add_insn_before (insn, before);
4142           last = insn;
4143           insn = next;
4144         }
4145       break;
4146
4147 #ifdef ENABLE_RTL_CHECKING
4148     case SEQUENCE:
4149       abort ();
4150       break;
4151 #endif
4152
4153     default:
4154       last = make_insn_raw (x);
4155       add_insn_before (last, before);
4156       break;
4157     }
4158
4159   return last;
4160 }
4161
4162 /* Make an instruction with body X and code JUMP_INSN
4163    and output it before the instruction BEFORE.  */
4164
4165 rtx
4166 emit_jump_insn_before (x, before)
4167      rtx x, before;
4168 {
4169   rtx insn, last = NULL_RTX;
4170
4171 #ifdef ENABLE_RTL_CHECKING
4172   if (before == NULL_RTX)
4173     abort ();
4174 #endif
4175
4176   switch (GET_CODE (x))
4177     {
4178     case INSN:
4179     case JUMP_INSN:
4180     case CALL_INSN:
4181     case CODE_LABEL:
4182     case BARRIER:
4183     case NOTE:
4184       insn = x;
4185       while (insn)
4186         {
4187           rtx next = NEXT_INSN (insn);
4188           add_insn_before (insn, before);
4189           last = insn;
4190           insn = next;
4191         }
4192       break;
4193
4194 #ifdef ENABLE_RTL_CHECKING
4195     case SEQUENCE:
4196       abort ();
4197       break;
4198 #endif
4199
4200     default:
4201       last = make_jump_insn_raw (x);
4202       add_insn_before (last, before);
4203       break;
4204     }
4205
4206   return last;
4207 }
4208
4209 /* Make an instruction with body X and code CALL_INSN
4210    and output it before the instruction BEFORE.  */
4211
4212 rtx
4213 emit_call_insn_before (x, before)
4214      rtx x, before;
4215 {
4216   rtx last = NULL_RTX, insn;
4217
4218 #ifdef ENABLE_RTL_CHECKING
4219   if (before == NULL_RTX)
4220     abort ();
4221 #endif
4222
4223   switch (GET_CODE (x))
4224     {
4225     case INSN:
4226     case JUMP_INSN:
4227     case CALL_INSN:
4228     case CODE_LABEL:
4229     case BARRIER:
4230     case NOTE:
4231       insn = x;
4232       while (insn)
4233         {
4234           rtx next = NEXT_INSN (insn);
4235           add_insn_before (insn, before);
4236           last = insn;
4237           insn = next;
4238         }
4239       break;
4240
4241 #ifdef ENABLE_RTL_CHECKING
4242     case SEQUENCE:
4243       abort ();
4244       break;
4245 #endif
4246
4247     default:
4248       last = make_call_insn_raw (x);
4249       add_insn_before (last, before);
4250       break;
4251     }
4252
4253   return last;
4254 }
4255
4256 /* Make an insn of code BARRIER
4257    and output it before the insn BEFORE.  */
4258
4259 rtx
4260 emit_barrier_before (before)
4261      rtx before;
4262 {
4263   rtx insn = rtx_alloc (BARRIER);
4264
4265   INSN_UID (insn) = cur_insn_uid++;
4266
4267   add_insn_before (insn, before);
4268   return insn;
4269 }
4270
4271 /* Emit the label LABEL before the insn BEFORE.  */
4272
4273 rtx
4274 emit_label_before (label, before)
4275      rtx label, before;
4276 {
4277   /* This can be called twice for the same label as a result of the
4278      confusion that follows a syntax error!  So make it harmless.  */
4279   if (INSN_UID (label) == 0)
4280     {
4281       INSN_UID (label) = cur_insn_uid++;
4282       add_insn_before (label, before);
4283     }
4284
4285   return label;
4286 }
4287
4288 /* Emit a note of subtype SUBTYPE before the insn BEFORE.  */
4289
4290 rtx
4291 emit_note_before (subtype, before)
4292      int subtype;
4293      rtx before;
4294 {
4295   rtx note = rtx_alloc (NOTE);
4296   INSN_UID (note) = cur_insn_uid++;
4297   NOTE_SOURCE_FILE (note) = 0;
4298   NOTE_LINE_NUMBER (note) = subtype;
4299   BLOCK_FOR_INSN (note) = NULL;
4300
4301   add_insn_before (note, before);
4302   return note;
4303 }
4304 \f
4305 /* Helper for emit_insn_after, handles lists of instructions
4306    efficiently.  */
4307
4308 static rtx emit_insn_after_1 PARAMS ((rtx, rtx));
4309
4310 static rtx
4311 emit_insn_after_1 (first, after)
4312      rtx first, after;
4313 {
4314   rtx last;
4315   rtx after_after;
4316   basic_block bb;
4317
4318   if (GET_CODE (after) != BARRIER
4319       && (bb = BLOCK_FOR_INSN (after)))
4320     {
4321       bb->flags |= BB_DIRTY;
4322       for (last = first; NEXT_INSN (last); last = NEXT_INSN (last))
4323         if (GET_CODE (last) != BARRIER)
4324           set_block_for_insn (last, bb);
4325       if (GET_CODE (last) != BARRIER)
4326         set_block_for_insn (last, bb);
4327       if (bb->end == after)
4328         bb->end = last;
4329     }
4330   else
4331     for (last = first; NEXT_INSN (last); last = NEXT_INSN (last))
4332       continue;
4333
4334   after_after = NEXT_INSN (after);
4335
4336   NEXT_INSN (after) = first;
4337   PREV_INSN (first) = after;
4338   NEXT_INSN (last) = after_after;
4339   if (after_after)
4340     PREV_INSN (after_after) = last;
4341
4342   if (after == last_insn)
4343     last_insn = last;
4344   return last;
4345 }
4346
4347 /* Make X be output after the insn AFTER.  */
4348
4349 rtx
4350 emit_insn_after (x, after)
4351      rtx x, after;
4352 {
4353   rtx last = after;
4354
4355 #ifdef ENABLE_RTL_CHECKING
4356   if (after == NULL_RTX)
4357     abort ();
4358 #endif
4359
4360   if (x == NULL_RTX)
4361     return last;
4362
4363   switch (GET_CODE (x))
4364     {
4365     case INSN:
4366     case JUMP_INSN:
4367     case CALL_INSN:
4368     case CODE_LABEL:
4369     case BARRIER:
4370     case NOTE:
4371       last = emit_insn_after_1 (x, after);
4372       break;
4373
4374 #ifdef ENABLE_RTL_CHECKING
4375     case SEQUENCE:
4376       abort ();
4377       break;
4378 #endif
4379
4380     default:
4381       last = make_insn_raw (x);
4382       add_insn_after (last, after);
4383       break;
4384     }
4385
4386   return last;
4387 }
4388
4389 /* Similar to emit_insn_after, except that line notes are to be inserted so
4390    as to act as if this insn were at FROM.  */
4391
4392 void
4393 emit_insn_after_with_line_notes (x, after, from)
4394      rtx x, after, from;
4395 {
4396   rtx from_line = find_line_note (from);
4397   rtx after_line = find_line_note (after);
4398   rtx insn = emit_insn_after (x, after);
4399
4400   if (from_line)
4401     emit_line_note_after (NOTE_SOURCE_FILE (from_line),
4402                           NOTE_LINE_NUMBER (from_line),
4403                           after);
4404
4405   if (after_line)
4406     emit_line_note_after (NOTE_SOURCE_FILE (after_line),
4407                           NOTE_LINE_NUMBER (after_line),
4408                           insn);
4409 }
4410
4411 /* Make an insn of code JUMP_INSN with body X
4412    and output it after the insn AFTER.  */
4413
4414 rtx
4415 emit_jump_insn_after (x, after)
4416      rtx x, after;
4417 {
4418   rtx last;
4419
4420 #ifdef ENABLE_RTL_CHECKING
4421   if (after == NULL_RTX)
4422     abort ();
4423 #endif
4424
4425   switch (GET_CODE (x))
4426     {
4427     case INSN:
4428     case JUMP_INSN:
4429     case CALL_INSN:
4430     case CODE_LABEL:
4431     case BARRIER:
4432     case NOTE:
4433       last = emit_insn_after_1 (x, after);
4434       break;
4435
4436 #ifdef ENABLE_RTL_CHECKING
4437     case SEQUENCE:
4438       abort ();
4439       break;
4440 #endif
4441
4442     default:
4443       last = make_jump_insn_raw (x);
4444       add_insn_after (last, after);
4445       break;
4446     }
4447
4448   return last;
4449 }
4450
4451 /* Make an instruction with body X and code CALL_INSN
4452    and output it after the instruction AFTER.  */
4453
4454 rtx
4455 emit_call_insn_after (x, after)
4456      rtx x, after;
4457 {
4458   rtx last;
4459
4460 #ifdef ENABLE_RTL_CHECKING
4461   if (after == NULL_RTX)
4462     abort ();
4463 #endif
4464
4465   switch (GET_CODE (x))
4466     {
4467     case INSN:
4468     case JUMP_INSN:
4469     case CALL_INSN:
4470     case CODE_LABEL:
4471     case BARRIER:
4472     case NOTE:
4473       last = emit_insn_after_1 (x, after);
4474       break;
4475
4476 #ifdef ENABLE_RTL_CHECKING
4477     case SEQUENCE:
4478       abort ();
4479       break;
4480 #endif
4481
4482     default:
4483       last = make_call_insn_raw (x);
4484       add_insn_after (last, after);
4485       break;
4486     }
4487
4488   return last;
4489 }
4490
4491 /* Make an insn of code BARRIER
4492    and output it after the insn AFTER.  */
4493
4494 rtx
4495 emit_barrier_after (after)
4496      rtx after;
4497 {
4498   rtx insn = rtx_alloc (BARRIER);
4499
4500   INSN_UID (insn) = cur_insn_uid++;
4501
4502   add_insn_after (insn, after);
4503   return insn;
4504 }
4505
4506 /* Emit the label LABEL after the insn AFTER.  */
4507
4508 rtx
4509 emit_label_after (label, after)
4510      rtx label, after;
4511 {
4512   /* This can be called twice for the same label
4513      as a result of the confusion that follows a syntax error!
4514      So make it harmless.  */
4515   if (INSN_UID (label) == 0)
4516     {
4517       INSN_UID (label) = cur_insn_uid++;
4518       add_insn_after (label, after);
4519     }
4520
4521   return label;
4522 }
4523
4524 /* Emit a note of subtype SUBTYPE after the insn AFTER.  */
4525
4526 rtx
4527 emit_note_after (subtype, after)
4528      int subtype;
4529      rtx after;
4530 {
4531   rtx note = rtx_alloc (NOTE);
4532   INSN_UID (note) = cur_insn_uid++;
4533   NOTE_SOURCE_FILE (note) = 0;
4534   NOTE_LINE_NUMBER (note) = subtype;
4535   BLOCK_FOR_INSN (note) = NULL;
4536   add_insn_after (note, after);
4537   return note;
4538 }
4539
4540 /* Emit a line note for FILE and LINE after the insn AFTER.  */
4541
4542 rtx
4543 emit_line_note_after (file, line, after)
4544      const char *file;
4545      int line;
4546      rtx after;
4547 {
4548   rtx note;
4549
4550   if (no_line_numbers && line > 0)
4551     {
4552       cur_insn_uid++;
4553       return 0;
4554     }
4555
4556   note = rtx_alloc (NOTE);
4557   INSN_UID (note) = cur_insn_uid++;
4558   NOTE_SOURCE_FILE (note) = file;
4559   NOTE_LINE_NUMBER (note) = line;
4560   BLOCK_FOR_INSN (note) = NULL;
4561   add_insn_after (note, after);
4562   return note;
4563 }
4564 \f
4565 /* Like emit_insn_after, but set INSN_SCOPE according to SCOPE.  */
4566 rtx
4567 emit_insn_after_scope (pattern, after, scope)
4568      rtx pattern, after;
4569      tree scope;
4570 {
4571   rtx last = emit_insn_after (pattern, after);
4572
4573   after = NEXT_INSN (after);
4574   while (1)
4575     {
4576       if (active_insn_p (after))
4577         INSN_SCOPE (after) = scope;
4578       if (after == last)
4579         break;
4580       after = NEXT_INSN (after);
4581     }
4582   return last;
4583 }
4584
4585 /* Like emit_jump_insn_after, but set INSN_SCOPE according to SCOPE.  */
4586 rtx
4587 emit_jump_insn_after_scope (pattern, after, scope)
4588      rtx pattern, after;
4589      tree scope;
4590 {
4591   rtx last = emit_jump_insn_after (pattern, after);
4592
4593   after = NEXT_INSN (after);
4594   while (1)
4595     {
4596       if (active_insn_p (after))
4597         INSN_SCOPE (after) = scope;
4598       if (after == last)
4599         break;
4600       after = NEXT_INSN (after);
4601     }
4602   return last;
4603 }
4604
4605 /* Like emit_call_insn_after, but set INSN_SCOPE according to SCOPE.  */
4606 rtx
4607 emit_call_insn_after_scope (pattern, after, scope)
4608      rtx pattern, after;
4609      tree scope;
4610 {
4611   rtx last = emit_call_insn_after (pattern, after);
4612
4613   after = NEXT_INSN (after);
4614   while (1)
4615     {
4616       if (active_insn_p (after))
4617         INSN_SCOPE (after) = scope;
4618       if (after == last)
4619         break;
4620       after = NEXT_INSN (after);
4621     }
4622   return last;
4623 }
4624
4625 /* Like emit_insn_before, but set INSN_SCOPE according to SCOPE.  */
4626 rtx
4627 emit_insn_before_scope (pattern, before, scope)
4628      rtx pattern, before;
4629      tree scope;
4630 {
4631   rtx first = PREV_INSN (before);
4632   rtx last = emit_insn_before (pattern, before);
4633
4634   first = NEXT_INSN (first);
4635   while (1)
4636     {
4637       if (active_insn_p (first))
4638         INSN_SCOPE (first) = scope;
4639       if (first == last)
4640         break;
4641       first = NEXT_INSN (first);
4642     }
4643   return last;
4644 }
4645 \f
4646 /* Take X and emit it at the end of the doubly-linked
4647    INSN list.
4648
4649    Returns the last insn emitted.  */
4650
4651 rtx
4652 emit_insn (x)
4653      rtx x;
4654 {
4655   rtx last = last_insn;
4656   rtx insn;
4657
4658   if (x == NULL_RTX)
4659     return last;
4660
4661   switch (GET_CODE (x))
4662     {
4663     case INSN:
4664     case JUMP_INSN:
4665     case CALL_INSN:
4666     case CODE_LABEL:
4667     case BARRIER:
4668     case NOTE:
4669       insn = x;
4670       while (insn)
4671         {
4672           rtx next = NEXT_INSN (insn);
4673           add_insn (insn);
4674           last = insn;
4675           insn = next;
4676         }
4677       break;
4678
4679 #ifdef ENABLE_RTL_CHECKING
4680     case SEQUENCE:
4681       abort ();
4682       break;
4683 #endif
4684
4685     default:
4686       last = make_insn_raw (x);
4687       add_insn (last);
4688       break;
4689     }
4690
4691   return last;
4692 }
4693
4694 /* Make an insn of code JUMP_INSN with pattern X
4695    and add it to the end of the doubly-linked list.  */
4696
4697 rtx
4698 emit_jump_insn (x)
4699      rtx x;
4700 {
4701   rtx last = NULL_RTX, insn;
4702
4703   switch (GET_CODE (x))
4704     {
4705     case INSN:
4706     case JUMP_INSN:
4707     case CALL_INSN:
4708     case CODE_LABEL:
4709     case BARRIER:
4710     case NOTE:
4711       insn = x;
4712       while (insn)
4713         {
4714           rtx next = NEXT_INSN (insn);
4715           add_insn (insn);
4716           last = insn;
4717           insn = next;
4718         }
4719       break;
4720
4721 #ifdef ENABLE_RTL_CHECKING
4722     case SEQUENCE:
4723       abort ();
4724       break;
4725 #endif
4726
4727     default:
4728       last = make_jump_insn_raw (x);
4729       add_insn (last);
4730       break;
4731     }
4732
4733   return last;
4734 }
4735
4736 /* Make an insn of code CALL_INSN with pattern X
4737    and add it to the end of the doubly-linked list.  */
4738
4739 rtx
4740 emit_call_insn (x)
4741      rtx x;
4742 {
4743   rtx insn;
4744
4745   switch (GET_CODE (x))
4746     {
4747     case INSN:
4748     case JUMP_INSN:
4749     case CALL_INSN:
4750     case CODE_LABEL:
4751     case BARRIER:
4752     case NOTE:
4753       insn = emit_insn (x);
4754       break;
4755
4756 #ifdef ENABLE_RTL_CHECKING
4757     case SEQUENCE:
4758       abort ();
4759       break;
4760 #endif
4761
4762     default:
4763       insn = make_call_insn_raw (x);
4764       add_insn (insn);
4765       break;
4766     }
4767
4768   return insn;
4769 }
4770
4771 /* Add the label LABEL to the end of the doubly-linked list.  */
4772
4773 rtx
4774 emit_label (label)
4775      rtx label;
4776 {
4777   /* This can be called twice for the same label
4778      as a result of the confusion that follows a syntax error!
4779      So make it harmless.  */
4780   if (INSN_UID (label) == 0)
4781     {
4782       INSN_UID (label) = cur_insn_uid++;
4783       add_insn (label);
4784     }
4785   return label;
4786 }
4787
4788 /* Make an insn of code BARRIER
4789    and add it to the end of the doubly-linked list.  */
4790
4791 rtx
4792 emit_barrier ()
4793 {
4794   rtx barrier = rtx_alloc (BARRIER);
4795   INSN_UID (barrier) = cur_insn_uid++;
4796   add_insn (barrier);
4797   return barrier;
4798 }
4799
4800 /* Make an insn of code NOTE
4801    with data-fields specified by FILE and LINE
4802    and add it to the end of the doubly-linked list,
4803    but only if line-numbers are desired for debugging info.  */
4804
4805 rtx
4806 emit_line_note (file, line)
4807      const char *file;
4808      int line;
4809 {
4810   set_file_and_line_for_stmt (file, line);
4811
4812 #if 0
4813   if (no_line_numbers)
4814     return 0;
4815 #endif
4816
4817   return emit_note (file, line);
4818 }
4819
4820 /* Make an insn of code NOTE
4821    with data-fields specified by FILE and LINE
4822    and add it to the end of the doubly-linked list.
4823    If it is a line-number NOTE, omit it if it matches the previous one.  */
4824
4825 rtx
4826 emit_note (file, line)
4827      const char *file;
4828      int line;
4829 {
4830   rtx note;
4831
4832   if (line > 0)
4833     {
4834       if (file && last_filename && !strcmp (file, last_filename)
4835           && line == last_linenum)
4836         return 0;
4837       last_filename = file;
4838       last_linenum = line;
4839     }
4840
4841   if (no_line_numbers && line > 0)
4842     {
4843       cur_insn_uid++;
4844       return 0;
4845     }
4846
4847   note = rtx_alloc (NOTE);
4848   INSN_UID (note) = cur_insn_uid++;
4849   NOTE_SOURCE_FILE (note) = file;
4850   NOTE_LINE_NUMBER (note) = line;
4851   BLOCK_FOR_INSN (note) = NULL;
4852   add_insn (note);
4853   return note;
4854 }
4855
4856 /* Emit a NOTE, and don't omit it even if LINE is the previous note.  */
4857
4858 rtx
4859 emit_line_note_force (file, line)
4860      const char *file;
4861      int line;
4862 {
4863   last_linenum = -1;
4864   return emit_line_note (file, line);
4865 }
4866
4867 /* Cause next statement to emit a line note even if the line number
4868    has not changed.  This is used at the beginning of a function.  */
4869
4870 void
4871 force_next_line_note ()
4872 {
4873   last_linenum = -1;
4874 }
4875
4876 /* Place a note of KIND on insn INSN with DATUM as the datum. If a
4877    note of this type already exists, remove it first.  */
4878
4879 rtx
4880 set_unique_reg_note (insn, kind, datum)
4881      rtx insn;
4882      enum reg_note kind;
4883      rtx datum;
4884 {
4885   rtx note = find_reg_note (insn, kind, NULL_RTX);
4886
4887   switch (kind)
4888     {
4889     case REG_EQUAL:
4890     case REG_EQUIV:
4891       /* Don't add REG_EQUAL/REG_EQUIV notes if the insn
4892          has multiple sets (some callers assume single_set
4893          means the insn only has one set, when in fact it
4894          means the insn only has one * useful * set).  */
4895       if (GET_CODE (PATTERN (insn)) == PARALLEL && multiple_sets (insn))
4896         {
4897           if (note)
4898             abort ();
4899           return NULL_RTX;
4900         }
4901
4902       /* Don't add ASM_OPERAND REG_EQUAL/REG_EQUIV notes.
4903          It serves no useful purpose and breaks eliminate_regs.  */
4904       if (GET_CODE (datum) == ASM_OPERANDS)
4905         return NULL_RTX;
4906       break;
4907
4908     default:
4909       break;
4910     }
4911
4912   if (note)
4913     {
4914       XEXP (note, 0) = datum;
4915       return note;
4916     }
4917
4918   REG_NOTES (insn) = gen_rtx_EXPR_LIST (kind, datum, REG_NOTES (insn));
4919   return REG_NOTES (insn);
4920 }
4921 \f
4922 /* Return an indication of which type of insn should have X as a body.
4923    The value is CODE_LABEL, INSN, CALL_INSN or JUMP_INSN.  */
4924
4925 enum rtx_code
4926 classify_insn (x)
4927      rtx x;
4928 {
4929   if (GET_CODE (x) == CODE_LABEL)
4930     return CODE_LABEL;
4931   if (GET_CODE (x) == CALL)
4932     return CALL_INSN;
4933   if (GET_CODE (x) == RETURN)
4934     return JUMP_INSN;
4935   if (GET_CODE (x) == SET)
4936     {
4937       if (SET_DEST (x) == pc_rtx)
4938         return JUMP_INSN;
4939       else if (GET_CODE (SET_SRC (x)) == CALL)
4940         return CALL_INSN;
4941       else
4942         return INSN;
4943     }
4944   if (GET_CODE (x) == PARALLEL)
4945     {
4946       int j;
4947       for (j = XVECLEN (x, 0) - 1; j >= 0; j--)
4948         if (GET_CODE (XVECEXP (x, 0, j)) == CALL)
4949           return CALL_INSN;
4950         else if (GET_CODE (XVECEXP (x, 0, j)) == SET
4951                  && SET_DEST (XVECEXP (x, 0, j)) == pc_rtx)
4952           return JUMP_INSN;
4953         else if (GET_CODE (XVECEXP (x, 0, j)) == SET
4954                  && GET_CODE (SET_SRC (XVECEXP (x, 0, j))) == CALL)
4955           return CALL_INSN;
4956     }
4957   return INSN;
4958 }
4959
4960 /* Emit the rtl pattern X as an appropriate kind of insn.
4961    If X is a label, it is simply added into the insn chain.  */
4962
4963 rtx
4964 emit (x)
4965      rtx x;
4966 {
4967   enum rtx_code code = classify_insn (x);
4968
4969   if (code == CODE_LABEL)
4970     return emit_label (x);
4971   else if (code == INSN)
4972     return emit_insn (x);
4973   else if (code == JUMP_INSN)
4974     {
4975       rtx insn = emit_jump_insn (x);
4976       if (any_uncondjump_p (insn) || GET_CODE (x) == RETURN)
4977         return emit_barrier ();
4978       return insn;
4979     }
4980   else if (code == CALL_INSN)
4981     return emit_call_insn (x);
4982   else
4983     abort ();
4984 }
4985 \f
4986 /* Space for free sequence stack entries.  */
4987 static GTY ((deletable (""))) struct sequence_stack *free_sequence_stack;
4988
4989 /* Begin emitting insns to a sequence which can be packaged in an
4990    RTL_EXPR.  If this sequence will contain something that might cause
4991    the compiler to pop arguments to function calls (because those
4992    pops have previously been deferred; see INHIBIT_DEFER_POP for more
4993    details), use do_pending_stack_adjust before calling this function.
4994    That will ensure that the deferred pops are not accidentally
4995    emitted in the middle of this sequence.  */
4996
4997 void
4998 start_sequence ()
4999 {
5000   struct sequence_stack *tem;
5001
5002   if (free_sequence_stack != NULL)
5003     {
5004       tem = free_sequence_stack;
5005       free_sequence_stack = tem->next;
5006     }
5007   else
5008     tem = (struct sequence_stack *) ggc_alloc (sizeof (struct sequence_stack));
5009
5010   tem->next = seq_stack;
5011   tem->first = first_insn;
5012   tem->last = last_insn;
5013   tem->sequence_rtl_expr = seq_rtl_expr;
5014
5015   seq_stack = tem;
5016
5017   first_insn = 0;
5018   last_insn = 0;
5019 }
5020
5021 /* Similarly, but indicate that this sequence will be placed in T, an
5022    RTL_EXPR.  See the documentation for start_sequence for more
5023    information about how to use this function.  */
5024
5025 void
5026 start_sequence_for_rtl_expr (t)
5027      tree t;
5028 {
5029   start_sequence ();
5030
5031   seq_rtl_expr = t;
5032 }
5033
5034 /* Set up the insn chain starting with FIRST as the current sequence,
5035    saving the previously current one.  See the documentation for
5036    start_sequence for more information about how to use this function.  */
5037
5038 void
5039 push_to_sequence (first)
5040      rtx first;
5041 {
5042   rtx last;
5043
5044   start_sequence ();
5045
5046   for (last = first; last && NEXT_INSN (last); last = NEXT_INSN (last));
5047
5048   first_insn = first;
5049   last_insn = last;
5050 }
5051
5052 /* Set up the insn chain from a chain stort in FIRST to LAST.  */
5053
5054 void
5055 push_to_full_sequence (first, last)
5056      rtx first, last;
5057 {
5058   start_sequence ();
5059   first_insn = first;
5060   last_insn = last;
5061   /* We really should have the end of the insn chain here.  */
5062   if (last && NEXT_INSN (last))
5063     abort ();
5064 }
5065
5066 /* Set up the outer-level insn chain
5067    as the current sequence, saving the previously current one.  */
5068
5069 void
5070 push_topmost_sequence ()
5071 {
5072   struct sequence_stack *stack, *top = NULL;
5073
5074   start_sequence ();
5075
5076   for (stack = seq_stack; stack; stack = stack->next)
5077     top = stack;
5078
5079   first_insn = top->first;
5080   last_insn = top->last;
5081   seq_rtl_expr = top->sequence_rtl_expr;
5082 }
5083
5084 /* After emitting to the outer-level insn chain, update the outer-level
5085    insn chain, and restore the previous saved state.  */
5086
5087 void
5088 pop_topmost_sequence ()
5089 {
5090   struct sequence_stack *stack, *top = NULL;
5091
5092   for (stack = seq_stack; stack; stack = stack->next)
5093     top = stack;
5094
5095   top->first = first_insn;
5096   top->last = last_insn;
5097   /* ??? Why don't we save seq_rtl_expr here?  */
5098
5099   end_sequence ();
5100 }
5101
5102 /* After emitting to a sequence, restore previous saved state.
5103
5104    To get the contents of the sequence just made, you must call
5105    `get_insns' *before* calling here.
5106
5107    If the compiler might have deferred popping arguments while
5108    generating this sequence, and this sequence will not be immediately
5109    inserted into the instruction stream, use do_pending_stack_adjust
5110    before calling get_insns.  That will ensure that the deferred
5111    pops are inserted into this sequence, and not into some random
5112    location in the instruction stream.  See INHIBIT_DEFER_POP for more
5113    information about deferred popping of arguments.  */
5114
5115 void
5116 end_sequence ()
5117 {
5118   struct sequence_stack *tem = seq_stack;
5119
5120   first_insn = tem->first;
5121   last_insn = tem->last;
5122   seq_rtl_expr = tem->sequence_rtl_expr;
5123   seq_stack = tem->next;
5124
5125   memset (tem, 0, sizeof (*tem));
5126   tem->next = free_sequence_stack;
5127   free_sequence_stack = tem;
5128 }
5129
5130 /* This works like end_sequence, but records the old sequence in FIRST
5131    and LAST.  */
5132
5133 void
5134 end_full_sequence (first, last)
5135      rtx *first, *last;
5136 {
5137   *first = first_insn;
5138   *last = last_insn;
5139   end_sequence ();
5140 }
5141
5142 /* Return 1 if currently emitting into a sequence.  */
5143
5144 int
5145 in_sequence_p ()
5146 {
5147   return seq_stack != 0;
5148 }
5149 \f
5150 /* Put the various virtual registers into REGNO_REG_RTX.  */
5151
5152 void
5153 init_virtual_regs (es)
5154      struct emit_status *es;
5155 {
5156   rtx *ptr = es->x_regno_reg_rtx;
5157   ptr[VIRTUAL_INCOMING_ARGS_REGNUM] = virtual_incoming_args_rtx;
5158   ptr[VIRTUAL_STACK_VARS_REGNUM] = virtual_stack_vars_rtx;
5159   ptr[VIRTUAL_STACK_DYNAMIC_REGNUM] = virtual_stack_dynamic_rtx;
5160   ptr[VIRTUAL_OUTGOING_ARGS_REGNUM] = virtual_outgoing_args_rtx;
5161   ptr[VIRTUAL_CFA_REGNUM] = virtual_cfa_rtx;
5162 }
5163
5164 \f
5165 /* Used by copy_insn_1 to avoid copying SCRATCHes more than once.  */
5166 static rtx copy_insn_scratch_in[MAX_RECOG_OPERANDS];
5167 static rtx copy_insn_scratch_out[MAX_RECOG_OPERANDS];
5168 static int copy_insn_n_scratches;
5169
5170 /* When an insn is being copied by copy_insn_1, this is nonzero if we have
5171    copied an ASM_OPERANDS.
5172    In that case, it is the original input-operand vector.  */
5173 static rtvec orig_asm_operands_vector;
5174
5175 /* When an insn is being copied by copy_insn_1, this is nonzero if we have
5176    copied an ASM_OPERANDS.
5177    In that case, it is the copied input-operand vector.  */
5178 static rtvec copy_asm_operands_vector;
5179
5180 /* Likewise for the constraints vector.  */
5181 static rtvec orig_asm_constraints_vector;
5182 static rtvec copy_asm_constraints_vector;
5183
5184 /* Recursively create a new copy of an rtx for copy_insn.
5185    This function differs from copy_rtx in that it handles SCRATCHes and
5186    ASM_OPERANDs properly.
5187    Normally, this function is not used directly; use copy_insn as front end.
5188    However, you could first copy an insn pattern with copy_insn and then use
5189    this function afterwards to properly copy any REG_NOTEs containing
5190    SCRATCHes.  */
5191
5192 rtx
5193 copy_insn_1 (orig)
5194      rtx orig;
5195 {
5196   rtx copy;
5197   int i, j;
5198   RTX_CODE code;
5199   const char *format_ptr;
5200
5201   code = GET_CODE (orig);
5202
5203   switch (code)
5204     {
5205     case REG:
5206     case QUEUED:
5207     case CONST_INT:
5208     case CONST_DOUBLE:
5209     case CONST_VECTOR:
5210     case SYMBOL_REF:
5211     case CODE_LABEL:
5212     case PC:
5213     case CC0:
5214     case ADDRESSOF:
5215       return orig;
5216
5217     case SCRATCH:
5218       for (i = 0; i < copy_insn_n_scratches; i++)
5219         if (copy_insn_scratch_in[i] == orig)
5220           return copy_insn_scratch_out[i];
5221       break;
5222
5223     case CONST:
5224       /* CONST can be shared if it contains a SYMBOL_REF.  If it contains
5225          a LABEL_REF, it isn't sharable.  */
5226       if (GET_CODE (XEXP (orig, 0)) == PLUS
5227           && GET_CODE (XEXP (XEXP (orig, 0), 0)) == SYMBOL_REF
5228           && GET_CODE (XEXP (XEXP (orig, 0), 1)) == CONST_INT)
5229         return orig;
5230       break;
5231
5232       /* A MEM with a constant address is not sharable.  The problem is that
5233          the constant address may need to be reloaded.  If the mem is shared,
5234          then reloading one copy of this mem will cause all copies to appear
5235          to have been reloaded.  */
5236
5237     default:
5238       break;
5239     }
5240
5241   copy = rtx_alloc (code);
5242
5243   /* Copy the various flags, and other information.  We assume that
5244      all fields need copying, and then clear the fields that should
5245      not be copied.  That is the sensible default behavior, and forces
5246      us to explicitly document why we are *not* copying a flag.  */
5247   memcpy (copy, orig, sizeof (struct rtx_def) - sizeof (rtunion));
5248
5249   /* We do not copy the USED flag, which is used as a mark bit during
5250      walks over the RTL.  */
5251   RTX_FLAG (copy, used) = 0;
5252
5253   /* We do not copy JUMP, CALL, or FRAME_RELATED for INSNs.  */
5254   if (GET_RTX_CLASS (code) == 'i')
5255     {
5256       RTX_FLAG (copy, jump) = 0;
5257       RTX_FLAG (copy, call) = 0;
5258       RTX_FLAG (copy, frame_related) = 0;
5259     }
5260
5261   format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
5262
5263   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
5264     {
5265       copy->fld[i] = orig->fld[i];
5266       switch (*format_ptr++)
5267         {
5268         case 'e':
5269           if (XEXP (orig, i) != NULL)
5270             XEXP (copy, i) = copy_insn_1 (XEXP (orig, i));
5271           break;
5272
5273         case 'E':
5274         case 'V':
5275           if (XVEC (orig, i) == orig_asm_constraints_vector)
5276             XVEC (copy, i) = copy_asm_constraints_vector;
5277           else if (XVEC (orig, i) == orig_asm_operands_vector)
5278             XVEC (copy, i) = copy_asm_operands_vector;
5279           else if (XVEC (orig, i) != NULL)
5280             {
5281               XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
5282               for (j = 0; j < XVECLEN (copy, i); j++)
5283                 XVECEXP (copy, i, j) = copy_insn_1 (XVECEXP (orig, i, j));
5284             }
5285           break;
5286
5287         case 't':
5288         case 'w':
5289         case 'i':
5290         case 's':
5291         case 'S':
5292         case 'u':
5293         case '0':
5294           /* These are left unchanged.  */
5295           break;
5296
5297         default:
5298           abort ();
5299         }
5300     }
5301
5302   if (code == SCRATCH)
5303     {
5304       i = copy_insn_n_scratches++;
5305       if (i >= MAX_RECOG_OPERANDS)
5306         abort ();
5307       copy_insn_scratch_in[i] = orig;
5308       copy_insn_scratch_out[i] = copy;
5309     }
5310   else if (code == ASM_OPERANDS)
5311     {
5312       orig_asm_operands_vector = ASM_OPERANDS_INPUT_VEC (orig);
5313       copy_asm_operands_vector = ASM_OPERANDS_INPUT_VEC (copy);
5314       orig_asm_constraints_vector = ASM_OPERANDS_INPUT_CONSTRAINT_VEC (orig);
5315       copy_asm_constraints_vector = ASM_OPERANDS_INPUT_CONSTRAINT_VEC (copy);
5316     }
5317
5318   return copy;
5319 }
5320
5321 /* Create a new copy of an rtx.
5322    This function differs from copy_rtx in that it handles SCRATCHes and
5323    ASM_OPERANDs properly.
5324    INSN doesn't really have to be a full INSN; it could be just the
5325    pattern.  */
5326 rtx
5327 copy_insn (insn)
5328      rtx insn;
5329 {
5330   copy_insn_n_scratches = 0;
5331   orig_asm_operands_vector = 0;
5332   orig_asm_constraints_vector = 0;
5333   copy_asm_operands_vector = 0;
5334   copy_asm_constraints_vector = 0;
5335   return copy_insn_1 (insn);
5336 }
5337
5338 /* Initialize data structures and variables in this file
5339    before generating rtl for each function.  */
5340
5341 void
5342 init_emit ()
5343 {
5344   struct function *f = cfun;
5345
5346   f->emit = (struct emit_status *) ggc_alloc (sizeof (struct emit_status));
5347   first_insn = NULL;
5348   last_insn = NULL;
5349   seq_rtl_expr = NULL;
5350   cur_insn_uid = 1;
5351   reg_rtx_no = LAST_VIRTUAL_REGISTER + 1;
5352   last_linenum = 0;
5353   last_filename = 0;
5354   first_label_num = label_num;
5355   last_label_num = 0;
5356   seq_stack = NULL;
5357
5358   /* Init the tables that describe all the pseudo regs.  */
5359
5360   f->emit->regno_pointer_align_length = LAST_VIRTUAL_REGISTER + 101;
5361
5362   f->emit->regno_pointer_align
5363     = (unsigned char *) ggc_alloc_cleared (f->emit->regno_pointer_align_length
5364                                            * sizeof (unsigned char));
5365
5366   regno_reg_rtx
5367     = (rtx *) ggc_alloc (f->emit->regno_pointer_align_length * sizeof (rtx));
5368
5369   /* Put copies of all the hard registers into regno_reg_rtx.  */
5370   memcpy (regno_reg_rtx,
5371           static_regno_reg_rtx,
5372           FIRST_PSEUDO_REGISTER * sizeof (rtx));
5373
5374   /* Put copies of all the virtual register rtx into regno_reg_rtx.  */
5375   init_virtual_regs (f->emit);
5376
5377   /* Indicate that the virtual registers and stack locations are
5378      all pointers.  */
5379   REG_POINTER (stack_pointer_rtx) = 1;
5380   REG_POINTER (frame_pointer_rtx) = 1;
5381   REG_POINTER (hard_frame_pointer_rtx) = 1;
5382   REG_POINTER (arg_pointer_rtx) = 1;
5383
5384   REG_POINTER (virtual_incoming_args_rtx) = 1;
5385   REG_POINTER (virtual_stack_vars_rtx) = 1;
5386   REG_POINTER (virtual_stack_dynamic_rtx) = 1;
5387   REG_POINTER (virtual_outgoing_args_rtx) = 1;
5388   REG_POINTER (virtual_cfa_rtx) = 1;
5389
5390 #ifdef STACK_BOUNDARY
5391   REGNO_POINTER_ALIGN (STACK_POINTER_REGNUM) = STACK_BOUNDARY;
5392   REGNO_POINTER_ALIGN (FRAME_POINTER_REGNUM) = STACK_BOUNDARY;
5393   REGNO_POINTER_ALIGN (HARD_FRAME_POINTER_REGNUM) = STACK_BOUNDARY;
5394   REGNO_POINTER_ALIGN (ARG_POINTER_REGNUM) = STACK_BOUNDARY;
5395
5396   REGNO_POINTER_ALIGN (VIRTUAL_INCOMING_ARGS_REGNUM) = STACK_BOUNDARY;
5397   REGNO_POINTER_ALIGN (VIRTUAL_STACK_VARS_REGNUM) = STACK_BOUNDARY;
5398   REGNO_POINTER_ALIGN (VIRTUAL_STACK_DYNAMIC_REGNUM) = STACK_BOUNDARY;
5399   REGNO_POINTER_ALIGN (VIRTUAL_OUTGOING_ARGS_REGNUM) = STACK_BOUNDARY;
5400   REGNO_POINTER_ALIGN (VIRTUAL_CFA_REGNUM) = BITS_PER_WORD;
5401 #endif
5402
5403 #ifdef INIT_EXPANDERS
5404   INIT_EXPANDERS;
5405 #endif
5406 }
5407
5408 /* Generate the constant 0.  */
5409
5410 static rtx
5411 gen_const_vector_0 (mode)
5412      enum machine_mode mode;
5413 {
5414   rtx tem;
5415   rtvec v;
5416   int units, i;
5417   enum machine_mode inner;
5418
5419   units = GET_MODE_NUNITS (mode);
5420   inner = GET_MODE_INNER (mode);
5421
5422   v = rtvec_alloc (units);
5423
5424   /* We need to call this function after we to set CONST0_RTX first.  */
5425   if (!CONST0_RTX (inner))
5426     abort ();
5427
5428   for (i = 0; i < units; ++i)
5429     RTVEC_ELT (v, i) = CONST0_RTX (inner);
5430
5431   tem = gen_rtx_raw_CONST_VECTOR (mode, v);
5432   return tem;
5433 }
5434
5435 /* Generate a vector like gen_rtx_raw_CONST_VEC, but use the zero vector when
5436    all elements are zero.  */
5437 rtx
5438 gen_rtx_CONST_VECTOR (mode, v)
5439      enum machine_mode mode;
5440      rtvec v;
5441 {
5442   rtx inner_zero = CONST0_RTX (GET_MODE_INNER (mode));
5443   int i;
5444
5445   for (i = GET_MODE_NUNITS (mode) - 1; i >= 0; i--)
5446     if (RTVEC_ELT (v, i) != inner_zero)
5447       return gen_rtx_raw_CONST_VECTOR (mode, v);
5448   return CONST0_RTX (mode);
5449 }
5450
5451 /* Create some permanent unique rtl objects shared between all functions.
5452    LINE_NUMBERS is nonzero if line numbers are to be generated.  */
5453
5454 void
5455 init_emit_once (line_numbers)
5456      int line_numbers;
5457 {
5458   int i;
5459   enum machine_mode mode;
5460   enum machine_mode double_mode;
5461
5462   /* Initialize the CONST_INT, CONST_DOUBLE, and memory attribute hash
5463      tables.  */
5464   const_int_htab = htab_create_ggc (37, const_int_htab_hash,
5465                                     const_int_htab_eq, NULL);
5466
5467   const_double_htab = htab_create_ggc (37, const_double_htab_hash,
5468                                        const_double_htab_eq, NULL);
5469
5470   mem_attrs_htab = htab_create_ggc (37, mem_attrs_htab_hash,
5471                                     mem_attrs_htab_eq, NULL);
5472   reg_attrs_htab = htab_create_ggc (37, reg_attrs_htab_hash,
5473                                     reg_attrs_htab_eq, NULL);
5474
5475   no_line_numbers = ! line_numbers;
5476
5477   /* Compute the word and byte modes.  */
5478
5479   byte_mode = VOIDmode;
5480   word_mode = VOIDmode;
5481   double_mode = VOIDmode;
5482
5483   for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
5484        mode = GET_MODE_WIDER_MODE (mode))
5485     {
5486       if (GET_MODE_BITSIZE (mode) == BITS_PER_UNIT
5487           && byte_mode == VOIDmode)
5488         byte_mode = mode;
5489
5490       if (GET_MODE_BITSIZE (mode) == BITS_PER_WORD
5491           && word_mode == VOIDmode)
5492         word_mode = mode;
5493     }
5494
5495   for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT); mode != VOIDmode;
5496        mode = GET_MODE_WIDER_MODE (mode))
5497     {
5498       if (GET_MODE_BITSIZE (mode) == DOUBLE_TYPE_SIZE
5499           && double_mode == VOIDmode)
5500         double_mode = mode;
5501     }
5502
5503   ptr_mode = mode_for_size (POINTER_SIZE, GET_MODE_CLASS (Pmode), 0);
5504
5505   /* Assign register numbers to the globally defined register rtx.
5506      This must be done at runtime because the register number field
5507      is in a union and some compilers can't initialize unions.  */
5508
5509   pc_rtx = gen_rtx (PC, VOIDmode);
5510   cc0_rtx = gen_rtx (CC0, VOIDmode);
5511   stack_pointer_rtx = gen_raw_REG (Pmode, STACK_POINTER_REGNUM);
5512   frame_pointer_rtx = gen_raw_REG (Pmode, FRAME_POINTER_REGNUM);
5513   if (hard_frame_pointer_rtx == 0)
5514     hard_frame_pointer_rtx = gen_raw_REG (Pmode,
5515                                           HARD_FRAME_POINTER_REGNUM);
5516   if (arg_pointer_rtx == 0)
5517     arg_pointer_rtx = gen_raw_REG (Pmode, ARG_POINTER_REGNUM);
5518   virtual_incoming_args_rtx =
5519     gen_raw_REG (Pmode, VIRTUAL_INCOMING_ARGS_REGNUM);
5520   virtual_stack_vars_rtx =
5521     gen_raw_REG (Pmode, VIRTUAL_STACK_VARS_REGNUM);
5522   virtual_stack_dynamic_rtx =
5523     gen_raw_REG (Pmode, VIRTUAL_STACK_DYNAMIC_REGNUM);
5524   virtual_outgoing_args_rtx =
5525     gen_raw_REG (Pmode, VIRTUAL_OUTGOING_ARGS_REGNUM);
5526   virtual_cfa_rtx = gen_raw_REG (Pmode, VIRTUAL_CFA_REGNUM);
5527
5528   /* Initialize RTL for commonly used hard registers.  These are
5529      copied into regno_reg_rtx as we begin to compile each function.  */
5530   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
5531     static_regno_reg_rtx[i] = gen_raw_REG (reg_raw_mode[i], i);
5532
5533 #ifdef INIT_EXPANDERS
5534   /* This is to initialize {init|mark|free}_machine_status before the first
5535      call to push_function_context_to.  This is needed by the Chill front
5536      end which calls push_function_context_to before the first call to
5537      init_function_start.  */
5538   INIT_EXPANDERS;
5539 #endif
5540
5541   /* Create the unique rtx's for certain rtx codes and operand values.  */
5542
5543   /* Don't use gen_rtx here since gen_rtx in this case
5544      tries to use these variables.  */
5545   for (i = - MAX_SAVED_CONST_INT; i <= MAX_SAVED_CONST_INT; i++)
5546     const_int_rtx[i + MAX_SAVED_CONST_INT] =
5547       gen_rtx_raw_CONST_INT (VOIDmode, (HOST_WIDE_INT) i);
5548
5549   if (STORE_FLAG_VALUE >= - MAX_SAVED_CONST_INT
5550       && STORE_FLAG_VALUE <= MAX_SAVED_CONST_INT)
5551     const_true_rtx = const_int_rtx[STORE_FLAG_VALUE + MAX_SAVED_CONST_INT];
5552   else
5553     const_true_rtx = gen_rtx_CONST_INT (VOIDmode, STORE_FLAG_VALUE);
5554
5555   REAL_VALUE_FROM_INT (dconst0,   0,  0, double_mode);
5556   REAL_VALUE_FROM_INT (dconst1,   1,  0, double_mode);
5557   REAL_VALUE_FROM_INT (dconst2,   2,  0, double_mode);
5558   REAL_VALUE_FROM_INT (dconstm1, -1, -1, double_mode);
5559   REAL_VALUE_FROM_INT (dconstm2, -2, -1, double_mode);
5560
5561   dconsthalf = dconst1;
5562   dconsthalf.exp--;
5563
5564   for (i = 0; i <= 2; i++)
5565     {
5566       REAL_VALUE_TYPE *r =
5567         (i == 0 ? &dconst0 : i == 1 ? &dconst1 : &dconst2);
5568
5569       for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT); mode != VOIDmode;
5570            mode = GET_MODE_WIDER_MODE (mode))
5571         const_tiny_rtx[i][(int) mode] =
5572           CONST_DOUBLE_FROM_REAL_VALUE (*r, mode);
5573
5574       const_tiny_rtx[i][(int) VOIDmode] = GEN_INT (i);
5575
5576       for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
5577            mode = GET_MODE_WIDER_MODE (mode))
5578         const_tiny_rtx[i][(int) mode] = GEN_INT (i);
5579
5580       for (mode = GET_CLASS_NARROWEST_MODE (MODE_PARTIAL_INT);
5581            mode != VOIDmode;
5582            mode = GET_MODE_WIDER_MODE (mode))
5583         const_tiny_rtx[i][(int) mode] = GEN_INT (i);
5584     }
5585
5586   for (mode = GET_CLASS_NARROWEST_MODE (MODE_VECTOR_INT);
5587        mode != VOIDmode;
5588        mode = GET_MODE_WIDER_MODE (mode))
5589     const_tiny_rtx[0][(int) mode] = gen_const_vector_0 (mode);
5590
5591   for (mode = GET_CLASS_NARROWEST_MODE (MODE_VECTOR_FLOAT);
5592        mode != VOIDmode;
5593        mode = GET_MODE_WIDER_MODE (mode))
5594     const_tiny_rtx[0][(int) mode] = gen_const_vector_0 (mode);
5595
5596   for (i = (int) CCmode; i < (int) MAX_MACHINE_MODE; ++i)
5597     if (GET_MODE_CLASS ((enum machine_mode) i) == MODE_CC)
5598       const_tiny_rtx[0][i] = const0_rtx;
5599
5600   const_tiny_rtx[0][(int) BImode] = const0_rtx;
5601   if (STORE_FLAG_VALUE == 1)
5602     const_tiny_rtx[1][(int) BImode] = const1_rtx;
5603
5604 #ifdef RETURN_ADDRESS_POINTER_REGNUM
5605   return_address_pointer_rtx
5606     = gen_raw_REG (Pmode, RETURN_ADDRESS_POINTER_REGNUM);
5607 #endif
5608
5609 #ifdef STRUCT_VALUE
5610   struct_value_rtx = STRUCT_VALUE;
5611 #else
5612   struct_value_rtx = gen_rtx_REG (Pmode, STRUCT_VALUE_REGNUM);
5613 #endif
5614
5615 #ifdef STRUCT_VALUE_INCOMING
5616   struct_value_incoming_rtx = STRUCT_VALUE_INCOMING;
5617 #else
5618 #ifdef STRUCT_VALUE_INCOMING_REGNUM
5619   struct_value_incoming_rtx
5620     = gen_rtx_REG (Pmode, STRUCT_VALUE_INCOMING_REGNUM);
5621 #else
5622   struct_value_incoming_rtx = struct_value_rtx;
5623 #endif
5624 #endif
5625
5626 #ifdef STATIC_CHAIN_REGNUM
5627   static_chain_rtx = gen_rtx_REG (Pmode, STATIC_CHAIN_REGNUM);
5628
5629 #ifdef STATIC_CHAIN_INCOMING_REGNUM
5630   if (STATIC_CHAIN_INCOMING_REGNUM != STATIC_CHAIN_REGNUM)
5631     static_chain_incoming_rtx
5632       = gen_rtx_REG (Pmode, STATIC_CHAIN_INCOMING_REGNUM);
5633   else
5634 #endif
5635     static_chain_incoming_rtx = static_chain_rtx;
5636 #endif
5637
5638 #ifdef STATIC_CHAIN
5639   static_chain_rtx = STATIC_CHAIN;
5640
5641 #ifdef STATIC_CHAIN_INCOMING
5642   static_chain_incoming_rtx = STATIC_CHAIN_INCOMING;
5643 #else
5644   static_chain_incoming_rtx = static_chain_rtx;
5645 #endif
5646 #endif
5647
5648   if ((unsigned) PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM)
5649     pic_offset_table_rtx = gen_raw_REG (Pmode, PIC_OFFSET_TABLE_REGNUM);
5650 }
5651 \f
5652 /* Query and clear/ restore no_line_numbers.  This is used by the
5653    switch / case handling in stmt.c to give proper line numbers in
5654    warnings about unreachable code.  */
5655
5656 int
5657 force_line_numbers ()
5658 {
5659   int old = no_line_numbers;
5660
5661   no_line_numbers = 0;
5662   if (old)
5663     force_next_line_note ();
5664   return old;
5665 }
5666
5667 void
5668 restore_line_number_status (old_value)
5669      int old_value;
5670 {
5671   no_line_numbers = old_value;
5672 }
5673
5674 /* Produce exact duplicate of insn INSN after AFTER.
5675    Care updating of libcall regions if present.  */
5676
5677 rtx
5678 emit_copy_of_insn_after (insn, after)
5679      rtx insn, after;
5680 {
5681   rtx new;
5682   rtx note1, note2, link;
5683
5684   switch (GET_CODE (insn))
5685     {
5686     case INSN:
5687       new = emit_insn_after (copy_insn (PATTERN (insn)), after);
5688       break;
5689
5690     case JUMP_INSN:
5691       new = emit_jump_insn_after (copy_insn (PATTERN (insn)), after);
5692       break;
5693
5694     case CALL_INSN:
5695       new = emit_call_insn_after (copy_insn (PATTERN (insn)), after);
5696       if (CALL_INSN_FUNCTION_USAGE (insn))
5697         CALL_INSN_FUNCTION_USAGE (new)
5698           = copy_insn (CALL_INSN_FUNCTION_USAGE (insn));
5699       SIBLING_CALL_P (new) = SIBLING_CALL_P (insn);
5700       CONST_OR_PURE_CALL_P (new) = CONST_OR_PURE_CALL_P (insn);
5701       break;
5702
5703     default:
5704       abort ();
5705     }
5706
5707   /* Update LABEL_NUSES.  */
5708   mark_jump_label (PATTERN (new), new, 0);
5709
5710   INSN_SCOPE (new) = INSN_SCOPE (insn);
5711
5712   /* Copy all REG_NOTES except REG_LABEL since mark_jump_label will
5713      make them.  */
5714   for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
5715     if (REG_NOTE_KIND (link) != REG_LABEL)
5716       {
5717         if (GET_CODE (link) == EXPR_LIST)
5718           REG_NOTES (new)
5719             = copy_insn_1 (gen_rtx_EXPR_LIST (REG_NOTE_KIND (link),
5720                                               XEXP (link, 0),
5721                                               REG_NOTES (new)));
5722         else
5723           REG_NOTES (new)
5724             = copy_insn_1 (gen_rtx_INSN_LIST (REG_NOTE_KIND (link),
5725                                               XEXP (link, 0),
5726                                               REG_NOTES (new)));
5727       }
5728
5729   /* Fix the libcall sequences.  */
5730   if ((note1 = find_reg_note (new, REG_RETVAL, NULL_RTX)) != NULL)
5731     {
5732       rtx p = new;
5733       while ((note2 = find_reg_note (p, REG_LIBCALL, NULL_RTX)) == NULL)
5734         p = PREV_INSN (p);
5735       XEXP (note1, 0) = p;
5736       XEXP (note2, 0) = new;
5737     }
5738   INSN_CODE (new) = INSN_CODE (insn);
5739   return new;
5740 }
5741
5742 #include "gt-emit-rtl.h"