gcc/rtl.c

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