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 GNU CC.
   6
   7 GNU CC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU CC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU CC; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 59 Temple Place - Suite 330,
  20 Boston, MA 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[(int) MAX_MACHINE_MODE + 1] = {
 121 #include "machmode.def"
 122   /* Add an extra field to avoid a core dump if someone tries to convert
 123      MAX_MACHINE_MODE to a string.   */
 124   ""
 125 };
 126
 127 #undef DEF_MACHMODE
 128
 129 /* Indexed by machine mode, gives the class mode for GET_MODE_CLASS.  */
 130
 131 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER)  CLASS,
 132
 133 const enum mode_class mode_class[(int) MAX_MACHINE_MODE] = {
 134 #include "machmode.def"
 135 };
 136
 137 #undef DEF_MACHMODE
 138
 139 /* Indexed by machine mode, gives the length of the mode, in bits.
 140    GET_MODE_BITSIZE uses this.  */
 141
 142 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER)  BITSIZE,
 143
 144 const unsigned int mode_bitsize[(int) MAX_MACHINE_MODE] = {
 145 #include "machmode.def"
 146 };
 147
 148 #undef DEF_MACHMODE
 149
 150 /* Indexed by machine mode, gives the length of the mode, in bytes.
 151    GET_MODE_SIZE uses this.  */
 152
 153 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER)  SIZE,
 154
 155 const unsigned int mode_size[(int) MAX_MACHINE_MODE] = {
 156 #include "machmode.def"
 157 };
 158
 159 #undef DEF_MACHMODE
 160
 161 /* Indexed by machine mode, gives the length of the mode's subunit.
 162    GET_MODE_UNIT_SIZE uses this.  */
 163
 164 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER)  UNIT,
 165
 166 const unsigned int mode_unit_size[(int) MAX_MACHINE_MODE] = {
 167 #include "machmode.def"         /* machine modes are documented here */
 168 };
 169
 170 #undef DEF_MACHMODE
 171
 172 /* Indexed by machine mode, gives next wider natural mode
 173    (QI -> HI -> SI -> DI, etc.)  Widening multiply instructions
 174    use this.  */
 175
 176 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER)  \
 177   (unsigned char) WIDER,
 178
 179 const unsigned char mode_wider_mode[(int) MAX_MACHINE_MODE] = {
 180 #include "machmode.def"         /* machine modes are documented here */
 181 };
 182
 183 #undef DEF_MACHMODE
 184
 185 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER)  \
 186   ((BITSIZE) >= HOST_BITS_PER_WIDE_INT) ? ~(unsigned HOST_WIDE_INT)0 : ((unsigned HOST_WIDE_INT) 1 << (BITSIZE)) - 1,
 187
 188 /* Indexed by machine mode, gives mask of significant bits in mode.  */
 189
 190 const unsigned HOST_WIDE_INT mode_mask_array[(int) MAX_MACHINE_MODE] = {
 191 #include "machmode.def"
 192 };
 193
 194 /* Indexed by mode class, gives the narrowest mode for each class.
 195    The Q modes are always of width 1 (2 for complex) - it is impossible
 196    for any mode to be narrower.
 197
 198    Note that we use QImode instead of BImode for MODE_INT, since
 199    otherwise the middle end will try to use it for bitfields in
 200    structures and the like, which we do not want.  Only the target
 201    md file should generate BImode widgets.  */
 202
 203 const enum machine_mode class_narrowest_mode[(int) MAX_MODE_CLASS] = {
 204     /* MODE_RANDOM */           VOIDmode,
 205     /* MODE_INT */              QImode,
 206     /* MODE_FLOAT */            QFmode,
 207     /* MODE_PARTIAL_INT */      PQImode,
 208     /* MODE_CC */               CCmode,
 209     /* MODE_COMPLEX_INT */      CQImode,
 210     /* MODE_COMPLEX_FLOAT */    QCmode,
 211     /* MODE_VECTOR_INT */       V2QImode,
 212     /* MODE_VECTOR_FLOAT */     V2SFmode
 213 };
 214
 215
 216 /* Indexed by rtx code, gives a sequence of operand-types for
 217    rtx's of that code.  The sequence is a C string in which
 218    each character describes one operand.  */
 219
 220 const char * const rtx_format[] = {
 221   /* "*" undefined.
 222          can cause a warning message
 223      "0" field is unused (or used in a phase-dependent manner)
 224          prints nothing
 225      "i" an integer
 226          prints the integer
 227      "n" like "i", but prints entries from `note_insn_name'
 228      "w" an integer of width HOST_BITS_PER_WIDE_INT
 229          prints the integer
 230      "s" a pointer to a string
 231          prints the string
 232      "S" like "s", but optional:
 233          the containing rtx may end before this operand
 234      "T" like "s", but treated specially by the RTL reader;
 235          only found in machine description patterns.
 236      "e" a pointer to an rtl expression
 237          prints the expression
 238      "E" a pointer to a vector that points to a number of rtl expressions
 239          prints a list of the rtl expressions
 240      "V" like "E", but optional:
 241          the containing rtx may end before this operand
 242      "u" a pointer to another insn
 243          prints the uid of the insn.
 244      "b" is a pointer to a bitmap header.
 245      "t" is a tree pointer. */
 246
 247 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS)   FORMAT ,
 248 #include "rtl.def"              /* rtl expressions are defined here */
 249 #undef DEF_RTL_EXPR
 250 };
 251
 252 /* Indexed by rtx code, gives a character representing the "class" of
 253    that rtx code.  See rtl.def for documentation on the defined classes.  */
 254
 255 const char rtx_class[] = {
 256 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS)   CLASS,
 257 #include "rtl.def"              /* rtl expressions are defined here */
 258 #undef DEF_RTL_EXPR
 259 };
 260
 261 /* Names for kinds of NOTEs and REG_NOTEs.  */
 262
 263 const char * const note_insn_name[NOTE_INSN_MAX - NOTE_INSN_BIAS] =
 264 {
 265   "", "NOTE_INSN_DELETED",
 266   "NOTE_INSN_BLOCK_BEG", "NOTE_INSN_BLOCK_END",
 267   "NOTE_INSN_LOOP_BEG", "NOTE_INSN_LOOP_END",
 268   "NOTE_INSN_LOOP_CONT", "NOTE_INSN_LOOP_VTOP",
 269   "NOTE_INSN_FUNCTION_END", "NOTE_INSN_SETJMP",
 270   "NOTE_INSN_PROLOGUE_END", "NOTE_INSN_EPILOGUE_BEG",
 271   "NOTE_INSN_DELETED_LABEL", "NOTE_INSN_FUNCTION_BEG",
 272   "NOTE_INSN_EH_REGION_BEG", "NOTE_INSN_EH_REGION_END",
 273   "NOTE_INSN_REPEATED_LINE_NUMBER", "NOTE_INSN_RANGE_BEG",
 274   "NOTE_INSN_RANGE_END", "NOTE_INSN_LIVE",
 275   "NOTE_INSN_BASIC_BLOCK", "NOTE_INSN_EXPECTED_VALUE"
 276 };
 277
 278 const char * const reg_note_name[] =
 279 {
 280   "", "REG_DEAD", "REG_INC", "REG_EQUIV", "REG_EQUAL",
 281   "REG_WAS_0", "REG_RETVAL", "REG_LIBCALL", "REG_NONNEG",
 282   "REG_NO_CONFLICT", "REG_UNUSED", "REG_CC_SETTER", "REG_CC_USER",
 283   "REG_LABEL", "REG_DEP_ANTI", "REG_DEP_OUTPUT", "REG_BR_PROB",
 284   "REG_EXEC_COUNT", "REG_NOALIAS", "REG_SAVE_AREA", "REG_BR_PRED",
 285   "REG_FRAME_RELATED_EXPR", "REG_EH_CONTEXT", "REG_EH_REGION",
 286   "REG_EH_RETHROW", "REG_SAVE_NOTE", "REG_MAYBE_DEAD", "REG_NORETURN",
 287   "REG_NON_LOCAL_GOTO"
 288 };
 289
 290 \f
 291 /* Allocate an rtx vector of N elements.
 292    Store the length, and initialize all elements to zero.  */
 293
 294 rtvec
 295 rtvec_alloc (n)
 296      int n;
 297 {
 298   rtvec rt;
 299
 300   rt = ggc_alloc_rtvec (n);
 301   /* clear out the vector */
 302   memset (&rt->elem[0], 0, n * sizeof (rtx));
 303
 304   PUT_NUM_ELEM (rt, n);
 305   return rt;
 306 }
 307
 308 /* Allocate an rtx of code CODE.  The CODE is stored in the rtx;
 309    all the rest is initialized to zero.  */
 310
 311 rtx
 312 rtx_alloc (code)
 313   RTX_CODE code;
 314 {
 315   rtx rt;
 316   int n = GET_RTX_LENGTH (code);
 317
 318   rt = ggc_alloc_rtx (n);
 319
 320   /* We want to clear everything up to the FLD array.  Normally, this
 321      is one int, but we don't want to assume that and it isn't very
 322      portable anyway; this is.  */
 323
 324   memset (rt, 0, sizeof (struct rtx_def) - sizeof (rtunion));
 325   PUT_CODE (rt, code);
 326   return rt;
 327 }
 328
 329 \f
 330 /* Create a new copy of an rtx.
 331    Recursively copies the operands of the rtx,
 332    except for those few rtx codes that are sharable.  */
 333
 334 rtx
 335 copy_rtx (orig)
 336      register rtx orig;
 337 {
 338   register rtx copy;
 339   register int i, j;
 340   register RTX_CODE code;
 341   register const char *format_ptr;
 342
 343   code = GET_CODE (orig);
 344
 345   switch (code)
 346     {
 347     case REG:
 348     case QUEUED:
 349     case CONST_INT:
 350     case CONST_DOUBLE:
 351     case SYMBOL_REF:
 352     case CODE_LABEL:
 353     case PC:
 354     case CC0:
 355     case SCRATCH:
 356       /* SCRATCH must be shared because they represent distinct values.  */
 357     case ADDRESSOF:
 358       return orig;
 359
 360     case CONST:
 361       /* CONST can be shared if it contains a SYMBOL_REF.  If it contains
 362          a LABEL_REF, it isn't sharable.  */
 363       if (GET_CODE (XEXP (orig, 0)) == PLUS
 364           && GET_CODE (XEXP (XEXP (orig, 0), 0)) == SYMBOL_REF
 365           && GET_CODE (XEXP (XEXP (orig, 0), 1)) == CONST_INT)
 366         return orig;
 367       break;
 368
 369       /* A MEM with a constant address is not sharable.  The problem is that
 370          the constant address may need to be reloaded.  If the mem is shared,
 371          then reloading one copy of this mem will cause all copies to appear
 372          to have been reloaded.  */
 373
 374     default:
 375       break;
 376     }
 377
 378   copy = rtx_alloc (code);
 379
 380   /* Copy the various flags, and other information.  We assume that
 381      all fields need copying, and then clear the fields that should
 382      not be copied.  That is the sensible default behavior, and forces
 383      us to explicitly document why we are *not* copying a flag.  */
 384   memcpy (copy, orig, sizeof (struct rtx_def) - sizeof (rtunion));
 385
 386   /* We do not copy the USED flag, which is used as a mark bit during
 387      walks over the RTL.  */
 388   copy->used = 0;
 389
 390   /* We do not copy FRAME_RELATED for INSNs.  */
 391   if (GET_RTX_CLASS (code) == 'i')
 392     copy->frame_related = 0;
 393   copy->jump = orig->jump;
 394   copy->call = orig->call;
 395
 396   format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
 397
 398   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
 399     {
 400       copy->fld[i] = orig->fld[i];
 401       switch (*format_ptr++)
 402         {
 403         case 'e':
 404           if (XEXP (orig, i) != NULL)
 405             XEXP (copy, i) = copy_rtx (XEXP (orig, i));
 406           break;
 407
 408         case 'E':
 409         case 'V':
 410           if (XVEC (orig, i) != NULL)
 411             {
 412               XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
 413               for (j = 0; j < XVECLEN (copy, i); j++)
 414                 XVECEXP (copy, i, j) = copy_rtx (XVECEXP (orig, i, j));
 415             }
 416           break;
 417
 418         case 't':
 419         case 'w':
 420         case 'i':
 421         case 's':
 422         case 'S':
 423         case 'u':
 424         case '0':
 425           /* These are left unchanged.  */
 426           break;
 427
 428         default:
 429           abort ();
 430         }
 431     }
 432   return copy;
 433 }
 434
 435 /* Similar to `copy_rtx' except that if MAY_SHARE is present, it is
 436    placed in the result directly, rather than being copied.  */
 437
 438 rtx
 439 copy_most_rtx (orig, may_share)
 440      register rtx orig;
 441      register rtx may_share;
 442 {
 443   register rtx copy;
 444   register int i, j;
 445   register RTX_CODE code;
 446   register const char *format_ptr;
 447
 448   if (orig == may_share)
 449     return orig;
 450
 451   code = GET_CODE (orig);
 452
 453   switch (code)
 454     {
 455     case REG:
 456     case QUEUED:
 457     case CONST_INT:
 458     case CONST_DOUBLE:
 459     case SYMBOL_REF:
 460     case CODE_LABEL:
 461     case PC:
 462     case CC0:
 463       return orig;
 464     default:
 465       break;
 466     }
 467
 468   copy = rtx_alloc (code);
 469   PUT_MODE (copy, GET_MODE (orig));
 470   copy->in_struct = orig->in_struct;
 471   copy->volatil = orig->volatil;
 472   copy->unchanging = orig->unchanging;
 473   copy->integrated = orig->integrated;
 474   copy->frame_related = orig->frame_related;
 475
 476   format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
 477
 478   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
 479     {
 480       switch (*format_ptr++)
 481         {
 482         case 'e':
 483           XEXP (copy, i) = XEXP (orig, i);
 484           if (XEXP (orig, i) != NULL && XEXP (orig, i) != may_share)
 485             XEXP (copy, i) = copy_most_rtx (XEXP (orig, i), may_share);
 486           break;
 487
 488         case 'u':
 489           XEXP (copy, i) = XEXP (orig, i);
 490           break;
 491
 492         case 'E':
 493         case 'V':
 494           XVEC (copy, i) = XVEC (orig, i);
 495           if (XVEC (orig, i) != NULL)
 496             {
 497               XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
 498               for (j = 0; j < XVECLEN (copy, i); j++)
 499                 XVECEXP (copy, i, j)
 500                   = copy_most_rtx (XVECEXP (orig, i, j), may_share);
 501             }
 502           break;
 503
 504         case 'w':
 505           XWINT (copy, i) = XWINT (orig, i);
 506           break;
 507
 508         case 'n':
 509         case 'i':
 510           XINT (copy, i) = XINT (orig, i);
 511           break;
 512
 513         case 't':
 514           XTREE (copy, i) = XTREE (orig, i);
 515           break;
 516
 517         case 's':
 518         case 'S':
 519           XSTR (copy, i) = XSTR (orig, i);
 520           break;
 521
 522         case '0':
 523           /* Copy this through the wide int field; that's safest. */
 524           X0WINT (copy, i) = X0WINT (orig, i);
 525           break;
 526
 527         default:
 528           abort ();
 529         }
 530     }
 531   return copy;
 532 }
 533
 534 /* Create a new copy of an rtx.  Only copy just one level.  */
 535 rtx
 536 shallow_copy_rtx (orig)
 537      rtx orig;
 538 {
 539   register int i;
 540   register RTX_CODE code = GET_CODE (orig);
 541   register rtx copy = rtx_alloc (code);
 542
 543   PUT_MODE (copy, GET_MODE (orig));
 544   copy->in_struct = orig->in_struct;
 545   copy->volatil = orig->volatil;
 546   copy->unchanging = orig->unchanging;
 547   copy->integrated = orig->integrated;
 548   copy->frame_related = orig->frame_related;
 549
 550   for (i = 0; i < GET_RTX_LENGTH (code); i++)
 551     copy->fld[i] = orig->fld[i];
 552
 553   return copy;
 554 }
 555 \f
 556 /* This is 1 until after the rtl generation pass.  */
 557 int rtx_equal_function_value_matters;
 558
 559 /* Nonzero when we are generating CONCATs.  */
 560 int generating_concat_p;
 561 \f
 562 /* Return 1 if X and Y are identical-looking rtx's.
 563    This is the Lisp function EQUAL for rtx arguments.  */
 564
 565 int
 566 rtx_equal_p (x, y)
 567      rtx x, y;
 568 {
 569   register int i;
 570   register int j;
 571   register enum rtx_code code;
 572   register const char *fmt;
 573
 574   if (x == y)
 575     return 1;
 576   if (x == 0 || y == 0)
 577     return 0;
 578
 579   code = GET_CODE (x);
 580   /* Rtx's of different codes cannot be equal.  */
 581   if (code != GET_CODE (y))
 582     return 0;
 583
 584   /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
 585      (REG:SI x) and (REG:HI x) are NOT equivalent.  */
 586
 587   if (GET_MODE (x) != GET_MODE (y))
 588     return 0;
 589
 590   /* Some RTL can be compared nonrecursively.  */
 591   switch (code)
 592     {
 593     case REG:
 594       /* Until rtl generation is complete, don't consider a reference to the
 595          return register of the current function the same as the return from a
 596          called function.  This eases the job of function integration.  Once the
 597          distinction is no longer 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 */