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   "REG_VTABLE_REF"
 286 };
 287
 288 \f
 289 /* Allocate an rtx vector of N elements.
 290    Store the length, and initialize all elements to zero.  */
 291
 292 rtvec
 293 rtvec_alloc (n)
 294      int n;
 295 {
 296   rtvec rt;
 297
 298   rt = ggc_alloc_rtvec (n);
 299   /* clear out the vector */
 300   memset (&rt->elem[0], 0, n * sizeof (rtx));
 301
 302   PUT_NUM_ELEM (rt, n);
 303   return rt;
 304 }
 305
 306 /* Allocate an rtx of code CODE.  The CODE is stored in the rtx;
 307    all the rest is initialized to zero.  */
 308
 309 rtx
 310 rtx_alloc (code)
 311   RTX_CODE code;
 312 {
 313   rtx rt;
 314   int n = GET_RTX_LENGTH (code);
 315
 316   rt = ggc_alloc_rtx (n);
 317
 318   /* We want to clear everything up to the FLD array.  Normally, this
 319      is one int, but we don't want to assume that and it isn't very
 320      portable anyway; this is.  */
 321
 322   memset (rt, 0, sizeof (struct rtx_def) - sizeof (rtunion));
 323   PUT_CODE (rt, code);
 324   return rt;
 325 }
 326
 327 \f
 328 /* Create a new copy of an rtx.
 329    Recursively copies the operands of the rtx,
 330    except for those few rtx codes that are sharable.  */
 331
 332 rtx
 333 copy_rtx (orig)
 334      rtx orig;
 335 {
 336   rtx copy;
 337   int i, j;
 338   RTX_CODE code;
 339   const char *format_ptr;
 340
 341   code = GET_CODE (orig);
 342
 343   switch (code)
 344     {
 345     case REG:
 346     case QUEUED:
 347     case CONST_INT:
 348     case CONST_DOUBLE:
 349     case SYMBOL_REF:
 350     case CODE_LABEL:
 351     case PC:
 352     case CC0:
 353     case SCRATCH:
 354       /* SCRATCH must be shared because they represent distinct values.  */
 355     case ADDRESSOF:
 356       return orig;
 357
 358     case CONST:
 359       /* CONST can be shared if it contains a SYMBOL_REF.  If it contains
 360          a LABEL_REF, it isn't sharable.  */
 361       if (GET_CODE (XEXP (orig, 0)) == PLUS
 362           && GET_CODE (XEXP (XEXP (orig, 0), 0)) == SYMBOL_REF
 363           && GET_CODE (XEXP (XEXP (orig, 0), 1)) == CONST_INT)
 364         return orig;
 365       break;
 366
 367       /* A MEM with a constant address is not sharable.  The problem is that
 368          the constant address may need to be reloaded.  If the mem is shared,
 369          then reloading one copy of this mem will cause all copies to appear
 370          to have been reloaded.  */
 371
 372     default:
 373       break;
 374     }
 375
 376   copy = rtx_alloc (code);
 377
 378   /* Copy the various flags, and other information.  We assume that
 379      all fields need copying, and then clear the fields that should
 380      not be copied.  That is the sensible default behavior, and forces
 381      us to explicitly document why we are *not* copying a flag.  */
 382   memcpy (copy, orig, sizeof (struct rtx_def) - sizeof (rtunion));
 383
 384   /* We do not copy the USED flag, which is used as a mark bit during
 385      walks over the RTL.  */
 386   copy->used = 0;
 387
 388   /* We do not copy FRAME_RELATED for INSNs.  */
 389   if (GET_RTX_CLASS (code) == 'i')
 390     copy->frame_related = 0;
 391   copy->jump = orig->jump;
 392   copy->call = orig->call;
 393
 394   format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
 395
 396   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
 397     {
 398       copy->fld[i] = orig->fld[i];
 399       switch (*format_ptr++)
 400         {
 401         case 'e':
 402           if (XEXP (orig, i) != NULL)
 403             XEXP (copy, i) = copy_rtx (XEXP (orig, i));
 404           break;
 405
 406         case 'E':
 407         case 'V':
 408           if (XVEC (orig, i) != NULL)
 409             {
 410               XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
 411               for (j = 0; j < XVECLEN (copy, i); j++)
 412                 XVECEXP (copy, i, j) = copy_rtx (XVECEXP (orig, i, j));
 413             }
 414           break;
 415
 416         case 't':
 417         case 'w':
 418         case 'i':
 419         case 's':
 420         case 'S':
 421         case 'T':
 422         case 'u':
 423         case '0':
 424           /* These are left unchanged.  */
 425           break;
 426
 427         default:
 428           abort ();
 429         }
 430     }
 431   return copy;
 432 }
 433
 434 /* Similar to `copy_rtx' except that if MAY_SHARE is present, it is
 435    placed in the result directly, rather than being copied.  */
 436
 437 rtx
 438 copy_most_rtx (orig, may_share)
 439      rtx orig;
 440      rtx may_share;
 441 {
 442   rtx copy;
 443   int i, j;
 444   RTX_CODE code;
 445   const char *format_ptr;
 446
 447   if (orig == may_share)
 448     return orig;
 449
 450   code = GET_CODE (orig);
 451
 452   switch (code)
 453     {
 454     case REG:
 455     case QUEUED:
 456     case CONST_INT:
 457     case CONST_DOUBLE:
 458     case SYMBOL_REF:
 459     case CODE_LABEL:
 460     case PC:
 461     case CC0:
 462       return orig;
 463     default:
 464       break;
 465     }
 466
 467   copy = rtx_alloc (code);
 468   PUT_MODE (copy, GET_MODE (orig));
 469   copy->in_struct = orig->in_struct;
 470   copy->volatil = orig->volatil;
 471   copy->unchanging = orig->unchanging;
 472   copy->integrated = orig->integrated;
 473   copy->frame_related = orig->frame_related;
 474
 475   format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
 476
 477   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
 478     {
 479       switch (*format_ptr++)
 480         {
 481         case 'e':
 482           XEXP (copy, i) = XEXP (orig, i);
 483           if (XEXP (orig, i) != NULL && XEXP (orig, i) != may_share)
 484             XEXP (copy, i) = copy_most_rtx (XEXP (orig, i), may_share);
 485           break;
 486
 487         case 'u':
 488           XEXP (copy, i) = XEXP (orig, i);
 489           break;
 490
 491         case 'E':
 492         case 'V':
 493           XVEC (copy, i) = XVEC (orig, i);
 494           if (XVEC (orig, i) != NULL)
 495             {
 496               XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
 497               for (j = 0; j < XVECLEN (copy, i); j++)
 498                 XVECEXP (copy, i, j)
 499                   = copy_most_rtx (XVECEXP (orig, i, j), may_share);
 500             }
 501           break;
 502
 503         case 'w':
 504           XWINT (copy, i) = XWINT (orig, i);
 505           break;
 506
 507         case 'n':
 508         case 'i':
 509           XINT (copy, i) = XINT (orig, i);
 510           break;
 511
 512         case 't':
 513           XTREE (copy, i) = XTREE (orig, i);
 514           break;
 515
 516         case 's':
 517         case 'S':
 518           XSTR (copy, i) = XSTR (orig, i);
 519           break;
 520
 521         case '0':
 522           /* Copy this through the wide int field; that's safest.  */
 523           X0WINT (copy, i) = X0WINT (orig, i);
 524           break;
 525
 526         default:
 527           abort ();
 528         }
 529     }
 530   return copy;
 531 }
 532
 533 /* Create a new copy of an rtx.  Only copy just one level.  */
 534 rtx
 535 shallow_copy_rtx (orig)
 536      rtx orig;
 537 {
 538   int i;
 539   RTX_CODE code = GET_CODE (orig);
 540   rtx copy = rtx_alloc (code);
 541
 542   PUT_MODE (copy, GET_MODE (orig));
 543   copy->in_struct = orig->in_struct;
 544   copy->volatil = orig->volatil;
 545   copy->unchanging = orig->unchanging;
 546   copy->integrated = orig->integrated;
 547   copy->frame_related = orig->frame_related;
 548
 549   for (i = 0; i < GET_RTX_LENGTH (code); i++)
 550     copy->fld[i] = orig->fld[i];
 551
 552   return copy;
 553 }
 554 \f
 555 /* This is 1 until after the rtl generation pass.  */
 556 int rtx_equal_function_value_matters;
 557
 558 /* Nonzero when we are generating CONCATs.  */
 559 int generating_concat_p;
 560 \f
 561 /* Return 1 if X and Y are identical-looking rtx's.
 562    This is the Lisp function EQUAL for rtx arguments.  */
 563
 564 int
 565 rtx_equal_p (x, y)
 566      rtx x, y;
 567 {
 568   int i;
 569   int j;
 570   enum rtx_code code;
 571   const char *fmt;
 572
 573   if (x == y)
 574     return 1;
 575   if (x == 0 || y == 0)
 576     return 0;
 577
 578   code = GET_CODE (x);
 579   /* Rtx's of different codes cannot be equal.  */
 580   if (code != GET_CODE (y))
 581     return 0;
 582
 583   /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
 584      (REG:SI x) and (REG:HI x) are NOT equivalent.  */
 585
 586   if (GET_MODE (x) != GET_MODE (y))
 587     return 0;
 588
 589   /* Some RTL can be compared nonrecursively.  */
 590   switch (code)
 591     {
 592     case REG:
 593       /* Until rtl generation is complete, don't consider a reference
 594          to the return register of the current function the same as
 595          the return from a called function.  This eases the job of
 596          function integration.  Once the distinction is no longer
 597          needed, they can be considered equivalent.  */
 598       return (REGNO (x) == REGNO (y)
 599               && (! rtx_equal_function_value_matters
 600                   || REG_FUNCTION_VALUE_P (x) == REG_FUNCTION_VALUE_P (y)));
 601
 602     case LABEL_REF:
 603       return XEXP (x, 0) == XEXP (y, 0);
 604
 605     case SYMBOL_REF:
 606       return XSTR (x, 0) == XSTR (y, 0);
 607
 608     case SCRATCH:
 609     case CONST_DOUBLE:
 610     case CONST_INT:
 611       return 0;
 612
 613     default:
 614       break;
 615     }
 616
 617   /* Compare the elements.  If any pair of corresponding elements
 618      fail to match, return 0 for the whole things.  */
 619
 620   fmt = GET_RTX_FORMAT (code);
 621   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
 622     {
 623       switch (fmt[i])
 624         {
 625         case 'w':
 626           if (XWINT (x, i) != XWINT (y, i))
 627             return 0;
 628           break;
 629
 630         case 'n':
 631         case 'i':
 632           if (XINT (x, i) != XINT (y, i))
 633             return 0;
 634           break;
 635
 636         case 'V':
 637         case 'E':
 638           /* Two vectors must have the same length.  */
 639           if (XVECLEN (x, i) != XVECLEN (y, i))
 640             return 0;
 641
 642           /* And the corresponding elements must match.  */
 643           for (j = 0; j < XVECLEN (x, i); j++)
 644             if (rtx_equal_p (XVECEXP (x, i, j), XVECEXP (y, i, j)) == 0)
 645               return 0;
 646           break;
 647
 648         case 'e':
 649           if (rtx_equal_p (XEXP (x, i), XEXP (y, i)) == 0)
 650             return 0;
 651           break;
 652
 653         case 'S':
 654         case 's':
 655           if (strcmp (XSTR (x, i), XSTR (y, i)))
 656             return 0;
 657           break;
 658
 659         case 'u':
 660           /* These are just backpointers, so they don't matter.  */
 661           break;
 662
 663         case '0':
 664         case 't':
 665           break;
 666
 667           /* It is believed that rtx's at this level will never
 668              contain anything but integers and other rtx's,
 669              except for within LABEL_REFs and SYMBOL_REFs.  */
 670         default:
 671           abort ();
 672         }
 673     }
 674   return 1;
 675 }
 676 \f
 677 #if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007)
 678 void
 679 rtl_check_failed_bounds (r, n, file, line, func)
 680     rtx r;
 681     int n;
 682     const char *file;
 683     int line;
 684     const char *func;
 685 {
 686   internal_error
 687     ("RTL check: access of elt %d of `%s' with last elt %d in %s, at %s:%d",
 688      n, GET_RTX_NAME (GET_CODE (r)), GET_RTX_LENGTH (GET_CODE (r)) - 1,
 689      func, trim_filename (file), line);
 690 }
 691
 692 void
 693 rtl_check_failed_type1 (r, n, c1, file, line, func)
 694     rtx r;
 695     int n;
 696     int c1;
 697     const char *file;
 698     int line;
 699     const char *func;
 700 {
 701   internal_error
 702     ("RTL check: expected elt %d type '%c', have '%c' (rtx %s) in %s, at %s:%d",
 703      n, c1, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
 704      func, trim_filename (file), line);
 705 }
 706
 707 void
 708 rtl_check_failed_type2 (r, n, c1, c2, file, line, func)
 709     rtx r;
 710     int n;
 711     int c1;
 712     int c2;
 713     const char *file;
 714     int line;
 715     const char *func;
 716 {
 717   internal_error
 718     ("RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s) in %s, at %s:%d",
 719      n, c1, c2, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
 720      func, trim_filename (file), line);
 721 }
 722
 723 void
 724 rtl_check_failed_code1 (r, code, file, line, func)
 725     rtx r;
 726     enum rtx_code code;
 727     const char *file;
 728     int line;
 729     const char *func;
 730 {
 731   internal_error ("RTL check: expected code `%s', have `%s' in %s, at %s:%d",
 732                   GET_RTX_NAME (code), GET_RTX_NAME (GET_CODE (r)), func,
 733                   trim_filename (file), line);
 734 }
 735
 736 void
 737 rtl_check_failed_code2 (r, code1, code2, file, line, func)
 738     rtx r;
 739     enum rtx_code code1, code2;
 740     const char *file;
 741     int line;
 742     const char *func;
 743 {
 744   internal_error
 745     ("RTL check: expected code `%s' or `%s', have `%s' in %s, at %s:%d",
 746      GET_RTX_NAME (code1), GET_RTX_NAME (code2), GET_RTX_NAME (GET_CODE (r)),
 747      func, trim_filename (file), line);
 748 }
 749
 750 /* XXX Maybe print the vector?  */
 751 void
 752 rtvec_check_failed_bounds (r, n, file, line, func)
 753     rtvec r;
 754     int n;
 755     const char *file;
 756     int line;
 757     const char *func;
 758 {
 759   internal_error
 760     ("RTL check: access of elt %d of vector with last elt %d in %s, at %s:%d",
 761      n, GET_NUM_ELEM (r) - 1, func, trim_filename (file), line);
 762 }
 763 #endif /* ENABLE_RTL_CHECKING */