gcc/rtl.c

   1 /* RTL utility routines.
   2    Copyright (C) 1987, 1988, 1991, 1994, 1997, 1998, 1999, 2000, 2001, 2002
   3    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 #include "config.h"
  23 #include "system.h"
  24 #include "rtl.h"
  25 #include "real.h"
  26 #include "ggc.h"
  27 #include "errors.h"
  28
  29 \f
  30 /* Calculate the format for CONST_DOUBLE.  This depends on the relative
  31    widths of HOST_WIDE_INT and REAL_VALUE_TYPE.
  32
  33    We need to go out to 0wwwww, since real.c assumes 16 bits per element
  34    in REAL_VALUE_TYPE.
  35
  36    This is duplicated in gengenrtl.c.
  37
  38    A number of places assume that there are always at least two 'w'
  39    slots in a CONST_DOUBLE, so we provide them even if one would suffice.  */
  40
  41 #if MAX_LONG_DOUBLE_TYPE_SIZE == 96
  42 # define REAL_WIDTH     \
  43      (11*8 + HOST_BITS_PER_WIDE_INT)/HOST_BITS_PER_WIDE_INT
  44 #else
  45 # if MAX_LONG_DOUBLE_TYPE_SIZE == 128
  46 #  define REAL_WIDTH    \
  47       (19*8 + HOST_BITS_PER_WIDE_INT)/HOST_BITS_PER_WIDE_INT
  48 # else
  49 #  if HOST_FLOAT_FORMAT != TARGET_FLOAT_FORMAT
  50 #   define REAL_WIDTH   \
  51        (7*8 + HOST_BITS_PER_WIDE_INT)/HOST_BITS_PER_WIDE_INT
  52 #  endif
  53 # endif
  54 #endif
  55
  56 #ifndef REAL_WIDTH
  57 # if HOST_BITS_PER_WIDE_INT*2 >= MAX_LONG_DOUBLE_TYPE_SIZE
  58 #  define REAL_WIDTH    2
  59 # else
  60 #  if HOST_BITS_PER_WIDE_INT*3 >= MAX_LONG_DOUBLE_TYPE_SIZE
  61 #   define REAL_WIDTH   3
  62 #  else
  63 #   if HOST_BITS_PER_WIDE_INT*4 >= MAX_LONG_DOUBLE_TYPE_SIZE
  64 #    define REAL_WIDTH  4
  65 #   endif
  66 #  endif
  67 # endif
  68 #endif /* REAL_WIDTH */
  69
  70 #if REAL_WIDTH == 1
  71 # define CONST_DOUBLE_FORMAT    "0ww"
  72 #else
  73 # if REAL_WIDTH == 2
  74 #  define CONST_DOUBLE_FORMAT   "0ww"
  75 # else
  76 #  if REAL_WIDTH == 3
  77 #   define CONST_DOUBLE_FORMAT  "0www"
  78 #  else
  79 #   if REAL_WIDTH == 4
  80 #    define CONST_DOUBLE_FORMAT "0wwww"
  81 #   else
  82 #    if REAL_WIDTH == 5
  83 #     define CONST_DOUBLE_FORMAT        "0wwwww"
  84 #    else
  85 #     define CONST_DOUBLE_FORMAT        /* nothing - will cause syntax error */
  86 #    endif
  87 #   endif
  88 #  endif
  89 # endif
  90 #endif
  91
  92 /* Indexed by rtx code, gives number of operands for an rtx with that code.
  93    Does NOT include rtx header data (code and links).  */
  94
  95 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS)   sizeof FORMAT - 1 ,
  96
  97 const unsigned char rtx_length[NUM_RTX_CODE] = {
  98 #include "rtl.def"
  99 };
 100
 101 #undef DEF_RTL_EXPR
 102
 103 /* Indexed by rtx code, gives the name of that kind of rtx, as a C string.  */
 104
 105 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS)   NAME ,
 106
 107 const char * const rtx_name[NUM_RTX_CODE] = {
 108 #include "rtl.def"              /* rtl expressions are documented here */
 109 };
 110
 111 #undef DEF_RTL_EXPR
 112
 113 /* Indexed by machine mode, gives the name of that machine mode.
 114    This name does not include the letters "mode".  */
 115
 116 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER)  NAME,
 117
 118 const char * const mode_name[NUM_MACHINE_MODES] = {
 119 #include "machmode.def"
 120 };
 121
 122 #undef DEF_MACHMODE
 123
 124 /* Indexed by machine mode, gives the class mode for GET_MODE_CLASS.  */
 125
 126 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER)  CLASS,
 127
 128 const enum mode_class mode_class[NUM_MACHINE_MODES] = {
 129 #include "machmode.def"
 130 };
 131
 132 #undef DEF_MACHMODE
 133
 134 /* Indexed by machine mode, gives the length of the mode, in bits.
 135    GET_MODE_BITSIZE uses this.  */
 136
 137 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER)  BITSIZE,
 138
 139 const unsigned short mode_bitsize[NUM_MACHINE_MODES] = {
 140 #include "machmode.def"
 141 };
 142
 143 #undef DEF_MACHMODE
 144
 145 /* Indexed by machine mode, gives the length of the mode, in bytes.
 146    GET_MODE_SIZE uses this.  */
 147
 148 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER)  SIZE,
 149
 150 const unsigned char mode_size[NUM_MACHINE_MODES] = {
 151 #include "machmode.def"
 152 };
 153
 154 #undef DEF_MACHMODE
 155
 156 /* Indexed by machine mode, gives the length of the mode's subunit.
 157    GET_MODE_UNIT_SIZE uses this.  */
 158
 159 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER)  UNIT,
 160
 161 const unsigned char mode_unit_size[NUM_MACHINE_MODES] = {
 162 #include "machmode.def"         /* machine modes are documented here */
 163 };
 164
 165 #undef DEF_MACHMODE
 166
 167 /* Indexed by machine mode, gives next wider natural mode
 168    (QI -> HI -> SI -> DI, etc.)  Widening multiply instructions
 169    use this.  */
 170
 171 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER)  \
 172   (unsigned char) WIDER,
 173
 174 const unsigned char mode_wider_mode[NUM_MACHINE_MODES] = {
 175 #include "machmode.def"         /* machine modes are documented here */
 176 };
 177
 178 #undef DEF_MACHMODE
 179
 180 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER)  \
 181   ((BITSIZE) >= HOST_BITS_PER_WIDE_INT) ? ~(unsigned HOST_WIDE_INT) 0 : ((unsigned HOST_WIDE_INT) 1 << (BITSIZE)) - 1,
 182
 183 /* Indexed by machine mode, gives mask of significant bits in mode.  */
 184
 185 const unsigned HOST_WIDE_INT mode_mask_array[NUM_MACHINE_MODES] = {
 186 #include "machmode.def"
 187 };
 188
 189 #undef DEF_MACHMODE
 190
 191 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER) INNER,
 192
 193 /* Indexed by machine mode, gives the mode of the inner elements in a
 194    vector type.  */
 195
 196 const enum machine_mode inner_mode_array[NUM_MACHINE_MODES] = {
 197 #include "machmode.def"
 198 };
 199
 200 /* Indexed by mode class, gives the narrowest mode for each class.
 201    The Q modes are always of width 1 (2 for complex) - it is impossible
 202    for any mode to be narrower.
 203
 204    Note that we use QImode instead of BImode for MODE_INT, since
 205    otherwise the middle end will try to use it for bitfields in
 206    structures and the like, which we do not want.  Only the target
 207    md file should generate BImode widgets.  */
 208
 209 const enum machine_mode class_narrowest_mode[(int) MAX_MODE_CLASS] = {
 210     /* MODE_RANDOM */           VOIDmode,
 211     /* MODE_INT */              QImode,
 212     /* MODE_FLOAT */            QFmode,
 213     /* MODE_PARTIAL_INT */      PQImode,
 214     /* MODE_CC */               CCmode,
 215     /* MODE_COMPLEX_INT */      CQImode,
 216     /* MODE_COMPLEX_FLOAT */    QCmode,
 217     /* MODE_VECTOR_INT */       V2QImode,
 218     /* MODE_VECTOR_FLOAT */     V2SFmode
 219 };
 220
 221
 222 /* Indexed by rtx code, gives a sequence of operand-types for
 223    rtx's of that code.  The sequence is a C string in which
 224    each character describes one operand.  */
 225
 226 const char * const rtx_format[NUM_RTX_CODE] = {
 227   /* "*" undefined.
 228          can cause a warning message
 229      "0" field is unused (or used in a phase-dependent manner)
 230          prints nothing
 231      "i" an integer
 232          prints the integer
 233      "n" like "i", but prints entries from `note_insn_name'
 234      "w" an integer of width HOST_BITS_PER_WIDE_INT
 235          prints the integer
 236      "s" a pointer to a string
 237          prints the string
 238      "S" like "s", but optional:
 239          the containing rtx may end before this operand
 240      "T" like "s", but treated specially by the RTL reader;
 241          only found in machine description patterns.
 242      "e" a pointer to an rtl expression
 243          prints the expression
 244      "E" a pointer to a vector that points to a number of rtl expressions
 245          prints a list of the rtl expressions
 246      "V" like "E", but optional:
 247          the containing rtx may end before this operand
 248      "u" a pointer to another insn
 249          prints the uid of the insn.
 250      "b" is a pointer to a bitmap header.
 251      "t" is a tree pointer.  */
 252
 253 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS)   FORMAT ,
 254 #include "rtl.def"              /* rtl expressions are defined here */
 255 #undef DEF_RTL_EXPR
 256 };
 257
 258 /* Indexed by rtx code, gives a character representing the "class" of
 259    that rtx code.  See rtl.def for documentation on the defined classes.  */
 260
 261 const char rtx_class[NUM_RTX_CODE] = {
 262 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS)   CLASS,
 263 #include "rtl.def"              /* rtl expressions are defined here */
 264 #undef DEF_RTL_EXPR
 265 };
 266
 267 /* Names for kinds of NOTEs and REG_NOTEs.  */
 268
 269 const char * const note_insn_name[NOTE_INSN_MAX - NOTE_INSN_BIAS] =
 270 {
 271   "", "NOTE_INSN_DELETED",
 272   "NOTE_INSN_BLOCK_BEG", "NOTE_INSN_BLOCK_END",
 273   "NOTE_INSN_LOOP_BEG", "NOTE_INSN_LOOP_END",
 274   "NOTE_INSN_LOOP_CONT", "NOTE_INSN_LOOP_VTOP",
 275   "NOTE_INSN_LOOP_END_TOP_COND", "NOTE_INSN_FUNCTION_END",
 276   "NOTE_INSN_PROLOGUE_END", "NOTE_INSN_EPILOGUE_BEG",
 277   "NOTE_INSN_DELETED_LABEL", "NOTE_INSN_FUNCTION_BEG",
 278   "NOTE_INSN_EH_REGION_BEG", "NOTE_INSN_EH_REGION_END",
 279   "NOTE_INSN_REPEATED_LINE_NUMBER", "NOTE_INSN_RANGE_BEG",
 280   "NOTE_INSN_RANGE_END", "NOTE_INSN_LIVE",
 281   "NOTE_INSN_BASIC_BLOCK", "NOTE_INSN_EXPECTED_VALUE"
 282 };
 283
 284 const char * const reg_note_name[] =
 285 {
 286   "", "REG_DEAD", "REG_INC", "REG_EQUIV", "REG_EQUAL",
 287   "REG_WAS_0", "REG_RETVAL", "REG_LIBCALL", "REG_NONNEG",
 288   "REG_NO_CONFLICT", "REG_UNUSED", "REG_CC_SETTER", "REG_CC_USER",
 289   "REG_LABEL", "REG_DEP_ANTI", "REG_DEP_OUTPUT", "REG_BR_PROB",
 290   "REG_EXEC_COUNT", "REG_NOALIAS", "REG_SAVE_AREA", "REG_BR_PRED",
 291   "REG_FRAME_RELATED_EXPR", "REG_EH_CONTEXT", "REG_EH_REGION",
 292   "REG_SAVE_NOTE", "REG_MAYBE_DEAD", "REG_NORETURN",
 293   "REG_NON_LOCAL_GOTO", "REG_SETJMP", "REG_ALWAYS_RETURN",
 294   "REG_VTABLE_REF"
 295 };
 296
 297 \f
 298 /* Allocate an rtx vector of N elements.
 299    Store the length, and initialize all elements to zero.  */
 300
 301 rtvec
 302 rtvec_alloc (n)
 303      int n;
 304 {
 305   rtvec rt;
 306
 307   rt = ggc_alloc_rtvec (n);
 308   /* clear out the vector */
 309   memset (&rt->elem[0], 0, n * sizeof (rtx));
 310
 311   PUT_NUM_ELEM (rt, n);
 312   return rt;
 313 }
 314
 315 /* Allocate an rtx of code CODE.  The CODE is stored in the rtx;
 316    all the rest is initialized to zero.  */
 317
 318 rtx
 319 rtx_alloc (code)
 320   RTX_CODE code;
 321 {
 322   rtx rt;
 323   int n = GET_RTX_LENGTH (code);
 324
 325   rt = ggc_alloc_rtx (n);
 326
 327   /* We want to clear everything up to the FLD array.  Normally, this
 328      is one int, but we don't want to assume that and it isn't very
 329      portable anyway; this is.  */
 330
 331   memset (rt, 0, sizeof (struct rtx_def) - sizeof (rtunion));
 332   PUT_CODE (rt, code);
 333   return rt;
 334 }
 335
 336 \f
 337 /* Create a new copy of an rtx.
 338    Recursively copies the operands of the rtx,
 339    except for those few rtx codes that are sharable.  */
 340
 341 rtx
 342 copy_rtx (orig)
 343      rtx orig;
 344 {
 345   rtx copy;
 346   int i, j;
 347   RTX_CODE code;
 348   const char *format_ptr;
 349
 350   code = GET_CODE (orig);
 351
 352   switch (code)
 353     {
 354     case REG:
 355     case QUEUED:
 356     case CONST_INT:
 357     case CONST_DOUBLE:
 358     case CONST_VECTOR:
 359     case SYMBOL_REF:
 360     case CODE_LABEL:
 361     case PC:
 362     case CC0:
 363     case SCRATCH:
 364       /* SCRATCH must be shared because they represent distinct values.  */
 365     case ADDRESSOF:
 366       return orig;
 367
 368     case CONST:
 369       /* CONST can be shared if it contains a SYMBOL_REF.  If it contains
 370          a LABEL_REF, it isn't sharable.  */
 371       if (GET_CODE (XEXP (orig, 0)) == PLUS
 372           && GET_CODE (XEXP (XEXP (orig, 0), 0)) == SYMBOL_REF
 373           && GET_CODE (XEXP (XEXP (orig, 0), 1)) == CONST_INT)
 374         return orig;
 375       break;
 376
 377       /* A MEM with a constant address is not sharable.  The problem is that
 378          the constant address may need to be reloaded.  If the mem is shared,
 379          then reloading one copy of this mem will cause all copies to appear
 380          to have been reloaded.  */
 381
 382     default:
 383       break;
 384     }
 385
 386   copy = rtx_alloc (code);
 387
 388   /* Copy the various flags, and other information.  We assume that
 389      all fields need copying, and then clear the fields that should
 390      not be copied.  That is the sensible default behavior, and forces
 391      us to explicitly document why we are *not* copying a flag.  */
 392   memcpy (copy, orig, sizeof (struct rtx_def) - sizeof (rtunion));
 393
 394   /* We do not copy the USED flag, which is used as a mark bit during
 395      walks over the RTL.  */
 396   copy->used = 0;
 397
 398   /* We do not copy FRAME_RELATED for INSNs.  */
 399   if (GET_RTX_CLASS (code) == 'i')
 400     copy->frame_related = 0;
 401   copy->jump = orig->jump;
 402   copy->call = orig->call;
 403
 404   format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
 405
 406   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
 407     {
 408       copy->fld[i] = orig->fld[i];
 409       switch (*format_ptr++)
 410         {
 411         case 'e':
 412           if (XEXP (orig, i) != NULL)
 413             XEXP (copy, i) = copy_rtx (XEXP (orig, i));
 414           break;
 415
 416         case 'E':
 417         case 'V':
 418           if (XVEC (orig, i) != NULL)
 419             {
 420               XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
 421               for (j = 0; j < XVECLEN (copy, i); j++)
 422                 XVECEXP (copy, i, j) = copy_rtx (XVECEXP (orig, i, j));
 423             }
 424           break;
 425
 426         case 't':
 427         case 'w':
 428         case 'i':
 429         case 's':
 430         case 'S':
 431         case 'T':
 432         case 'u':
 433         case '0':
 434           /* These are left unchanged.  */
 435           break;
 436
 437         default:
 438           abort ();
 439         }
 440     }
 441   return copy;
 442 }
 443
 444 /* Similar to `copy_rtx' except that if MAY_SHARE is present, it is
 445    placed in the result directly, rather than being copied.  */
 446
 447 rtx
 448 copy_most_rtx (orig, may_share)
 449      rtx orig;
 450      rtx may_share;
 451 {
 452   rtx copy;
 453   int i, j;
 454   RTX_CODE code;
 455   const char *format_ptr;
 456
 457   if (orig == may_share)
 458     return orig;
 459
 460   code = GET_CODE (orig);
 461
 462   switch (code)
 463     {
 464     case REG:
 465     case QUEUED:
 466     case CONST_INT:
 467     case CONST_DOUBLE:
 468     case CONST_VECTOR:
 469     case SYMBOL_REF:
 470     case CODE_LABEL:
 471     case PC:
 472     case CC0:
 473       return orig;
 474     default:
 475       break;
 476     }
 477
 478   copy = rtx_alloc (code);
 479   PUT_MODE (copy, GET_MODE (orig));
 480   copy->in_struct = orig->in_struct;
 481   copy->volatil = orig->volatil;
 482   copy->unchanging = orig->unchanging;
 483   copy->integrated = orig->integrated;
 484   copy->frame_related = orig->frame_related;
 485
 486   format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
 487
 488   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
 489     {
 490       switch (*format_ptr++)
 491         {
 492         case 'e':
 493           XEXP (copy, i) = XEXP (orig, i);
 494           if (XEXP (orig, i) != NULL && XEXP (orig, i) != may_share)
 495             XEXP (copy, i) = copy_most_rtx (XEXP (orig, i), may_share);
 496           break;
 497
 498         case 'u':
 499           XEXP (copy, i) = XEXP (orig, i);
 500           break;
 501
 502         case 'E':
 503         case 'V':
 504           XVEC (copy, i) = XVEC (orig, i);
 505           if (XVEC (orig, i) != NULL)
 506             {
 507               XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
 508               for (j = 0; j < XVECLEN (copy, i); j++)
 509                 XVECEXP (copy, i, j)
 510                   = copy_most_rtx (XVECEXP (orig, i, j), may_share);
 511             }
 512           break;
 513
 514         case 'w':
 515           XWINT (copy, i) = XWINT (orig, i);
 516           break;
 517
 518         case 'n':
 519         case 'i':
 520           XINT (copy, i) = XINT (orig, i);
 521           break;
 522
 523         case 't':
 524           XTREE (copy, i) = XTREE (orig, i);
 525           break;
 526
 527         case 's':
 528         case 'S':
 529           XSTR (copy, i) = XSTR (orig, i);
 530           break;
 531
 532         case '0':
 533           /* Copy this through the wide int field; that's safest.  */
 534           X0WINT (copy, i) = X0WINT (orig, i);
 535           break;
 536
 537         default:
 538           abort ();
 539         }
 540     }
 541   return copy;
 542 }
 543
 544 /* Create a new copy of an rtx.  Only copy just one level.  */
 545
 546 rtx
 547 shallow_copy_rtx (orig)
 548      rtx orig;
 549 {
 550   int i;
 551   RTX_CODE code = GET_CODE (orig);
 552   rtx copy = rtx_alloc (code);
 553
 554   PUT_MODE (copy, GET_MODE (orig));
 555   copy->in_struct = orig->in_struct;
 556   copy->volatil = orig->volatil;
 557   copy->unchanging = orig->unchanging;
 558   copy->integrated = orig->integrated;
 559   copy->frame_related = orig->frame_related;
 560
 561   for (i = 0; i < GET_RTX_LENGTH (code); i++)
 562     copy->fld[i] = orig->fld[i];
 563
 564   return copy;
 565 }
 566
 567 /* Return the alignment of MODE. This will be bounded by 1 and
 568    BIGGEST_ALIGNMENT.  */
 569
 570 unsigned int
 571 get_mode_alignment (mode)
 572      enum machine_mode mode;
 573 {
 574   unsigned int alignment;
 575
 576   if (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT
 577       || GET_MODE_CLASS (mode) == MODE_COMPLEX_INT)
 578     alignment = GET_MODE_UNIT_SIZE (mode);
 579   else
 580     alignment = GET_MODE_SIZE (mode);
 581
 582   /* Extract the LSB of the size.  */
 583   alignment = alignment & -alignment;
 584   alignment *= BITS_PER_UNIT;
 585
 586   alignment = MIN (BIGGEST_ALIGNMENT, MAX (1, alignment));
 587   return alignment;
 588 }
 589 \f
 590 /* This is 1 until after the rtl generation pass.  */
 591 int rtx_equal_function_value_matters;
 592
 593 /* Nonzero when we are generating CONCATs.  */
 594 int generating_concat_p;
 595 \f
 596 /* Return 1 if X and Y are identical-looking rtx's.
 597    This is the Lisp function EQUAL for rtx arguments.  */
 598
 599 int
 600 rtx_equal_p (x, y)
 601      rtx x, y;
 602 {
 603   int i;
 604   int j;
 605   enum rtx_code code;
 606   const char *fmt;
 607
 608   if (x == y)
 609     return 1;
 610   if (x == 0 || y == 0)
 611     return 0;
 612
 613   code = GET_CODE (x);
 614   /* Rtx's of different codes cannot be equal.  */
 615   if (code != GET_CODE (y))
 616     return 0;
 617
 618   /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
 619      (REG:SI x) and (REG:HI x) are NOT equivalent.  */
 620
 621   if (GET_MODE (x) != GET_MODE (y))
 622     return 0;
 623
 624   /* Some RTL can be compared nonrecursively.  */
 625   switch (code)
 626     {
 627     case REG:
 628       /* Until rtl generation is complete, don't consider a reference
 629          to the return register of the current function the same as
 630          the return from a called function.  This eases the job of
 631          function integration.  Once the distinction is no longer
 632          needed, they can be considered equivalent.  */
 633       return (REGNO (x) == REGNO (y)
 634               && (! rtx_equal_function_value_matters
 635                   || REG_FUNCTION_VALUE_P (x) == REG_FUNCTION_VALUE_P (y)));
 636
 637     case LABEL_REF:
 638       return XEXP (x, 0) == XEXP (y, 0);
 639
 640     case SYMBOL_REF:
 641       return XSTR (x, 0) == XSTR (y, 0);
 642
 643     case SCRATCH:
 644     case CONST_DOUBLE:
 645     case CONST_INT:
 646     case CONST_VECTOR:
 647       return 0;
 648
 649     default:
 650       break;
 651     }
 652
 653   /* Compare the elements.  If any pair of corresponding elements
 654      fail to match, return 0 for the whole things.  */
 655
 656   fmt = GET_RTX_FORMAT (code);
 657   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
 658     {
 659       switch (fmt[i])
 660         {
 661         case 'w':
 662           if (XWINT (x, i) != XWINT (y, i))
 663             return 0;
 664           break;
 665
 666         case 'n':
 667         case 'i':
 668           if (XINT (x, i) != XINT (y, i))
 669             return 0;
 670           break;
 671
 672         case 'V':
 673         case 'E':
 674           /* Two vectors must have the same length.  */
 675           if (XVECLEN (x, i) != XVECLEN (y, i))
 676             return 0;
 677
 678           /* And the corresponding elements must match.  */
 679           for (j = 0; j < XVECLEN (x, i); j++)
 680             if (rtx_equal_p (XVECEXP (x, i, j), XVECEXP (y, i, j)) == 0)
 681               return 0;
 682           break;
 683
 684         case 'e':
 685           if (rtx_equal_p (XEXP (x, i), XEXP (y, i)) == 0)
 686             return 0;
 687           break;
 688
 689         case 'S':
 690         case 's':
 691           if ((XSTR (x, i) || XSTR (y, i))
 692               && (! XSTR (x, i) || ! XSTR (y, i)
 693                   || strcmp (XSTR (x, i), XSTR (y, i))))
 694             return 0;
 695           break;
 696
 697         case 'u':
 698           /* These are just backpointers, so they don't matter.  */
 699           break;
 700
 701         case '0':
 702         case 't':
 703           break;
 704
 705           /* It is believed that rtx's at this level will never
 706              contain anything but integers and other rtx's,
 707              except for within LABEL_REFs and SYMBOL_REFs.  */
 708         default:
 709           abort ();
 710         }
 711     }
 712   return 1;
 713 }
 714 \f
 715 #if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007)
 716 void
 717 rtl_check_failed_bounds (r, n, file, line, func)
 718     rtx r;
 719     int n;
 720     const char *file;
 721     int line;
 722     const char *func;
 723 {
 724   internal_error
 725     ("RTL check: access of elt %d of `%s' with last elt %d in %s, at %s:%d",
 726      n, GET_RTX_NAME (GET_CODE (r)), GET_RTX_LENGTH (GET_CODE (r)) - 1,
 727      func, trim_filename (file), line);
 728 }
 729
 730 void
 731 rtl_check_failed_type1 (r, n, c1, file, line, func)
 732     rtx r;
 733     int n;
 734     int c1;
 735     const char *file;
 736     int line;
 737     const char *func;
 738 {
 739   internal_error
 740     ("RTL check: expected elt %d type '%c', have '%c' (rtx %s) in %s, at %s:%d",
 741      n, c1, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
 742      func, trim_filename (file), line);
 743 }
 744
 745 void
 746 rtl_check_failed_type2 (r, n, c1, c2, file, line, func)
 747     rtx r;
 748     int n;
 749     int c1;
 750     int c2;
 751     const char *file;
 752     int line;
 753     const char *func;
 754 {
 755   internal_error
 756     ("RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s) in %s, at %s:%d",
 757      n, c1, c2, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
 758      func, trim_filename (file), line);
 759 }
 760
 761 void
 762 rtl_check_failed_code1 (r, code, file, line, func)
 763     rtx r;
 764     enum rtx_code code;
 765     const char *file;
 766     int line;
 767     const char *func;
 768 {
 769   internal_error ("RTL check: expected code `%s', have `%s' in %s, at %s:%d",
 770                   GET_RTX_NAME (code), GET_RTX_NAME (GET_CODE (r)), func,
 771                   trim_filename (file), line);
 772 }
 773
 774 void
 775 rtl_check_failed_code2 (r, code1, code2, file, line, func)
 776     rtx r;
 777     enum rtx_code code1, code2;
 778     const char *file;
 779     int line;
 780     const char *func;
 781 {
 782   internal_error
 783     ("RTL check: expected code `%s' or `%s', have `%s' in %s, at %s:%d",
 784      GET_RTX_NAME (code1), GET_RTX_NAME (code2), GET_RTX_NAME (GET_CODE (r)),
 785      func, trim_filename (file), line);
 786 }
 787
 788 /* XXX Maybe print the vector?  */
 789 void
 790 rtvec_check_failed_bounds (r, n, file, line, func)
 791     rtvec r;
 792     int n;
 793     const char *file;
 794     int line;
 795     const char *func;
 796 {
 797   internal_error
 798     ("RTL check: access of elt %d of vector with last elt %d in %s, at %s:%d",
 799      n, GET_NUM_ELEM (r) - 1, func, trim_filename (file), line);
 800 }
 801 #endif /* ENABLE_RTL_CHECKING */