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