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 'T':
 424         case 'u':
 425         case '0':
 426           /* These are left unchanged.  */
 427           break;
 428
 429         default:
 430           abort ();
 431         }
 432     }
 433   return copy;
 434 }
 435
 436 /* Similar to `copy_rtx' except that if MAY_SHARE is present, it is
 437    placed in the result directly, rather than being copied.  */
 438
 439 rtx
 440 copy_most_rtx (orig, may_share)
 441      register rtx orig;
 442      register rtx may_share;
 443 {
 444   register rtx copy;
 445   register int i, j;
 446   register RTX_CODE code;
 447   register const char *format_ptr;
 448
 449   if (orig == may_share)
 450     return orig;
 451
 452   code = GET_CODE (orig);
 453
 454   switch (code)
 455     {
 456     case REG:
 457     case QUEUED:
 458     case CONST_INT:
 459     case CONST_DOUBLE:
 460     case SYMBOL_REF:
 461     case CODE_LABEL:
 462     case PC:
 463     case CC0:
 464       return orig;
 465     default:
 466       break;
 467     }
 468
 469   copy = rtx_alloc (code);
 470   PUT_MODE (copy, GET_MODE (orig));
 471   copy->in_struct = orig->in_struct;
 472   copy->volatil = orig->volatil;
 473   copy->unchanging = orig->unchanging;
 474   copy->integrated = orig->integrated;
 475   copy->frame_related = orig->frame_related;
 476
 477   format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
 478
 479   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
 480     {
 481       switch (*format_ptr++)
 482         {
 483         case 'e':
 484           XEXP (copy, i) = XEXP (orig, i);
 485           if (XEXP (orig, i) != NULL && XEXP (orig, i) != may_share)
 486             XEXP (copy, i) = copy_most_rtx (XEXP (orig, i), may_share);
 487           break;
 488
 489         case 'u':
 490           XEXP (copy, i) = XEXP (orig, i);
 491           break;
 492
 493         case 'E':
 494         case 'V':
 495           XVEC (copy, i) = XVEC (orig, i);
 496           if (XVEC (orig, i) != NULL)
 497             {
 498               XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
 499               for (j = 0; j < XVECLEN (copy, i); j++)
 500                 XVECEXP (copy, i, j)
 501                   = copy_most_rtx (XVECEXP (orig, i, j), may_share);
 502             }
 503           break;
 504
 505         case 'w':
 506           XWINT (copy, i) = XWINT (orig, i);
 507           break;
 508
 509         case 'n':
 510         case 'i':
 511           XINT (copy, i) = XINT (orig, i);
 512           break;
 513
 514         case 't':
 515           XTREE (copy, i) = XTREE (orig, i);
 516           break;
 517
 518         case 's':
 519         case 'S':
 520           XSTR (copy, i) = XSTR (orig, i);
 521           break;
 522
 523         case '0':
 524           /* Copy this through the wide int field; that's safest. */
 525           X0WINT (copy, i) = X0WINT (orig, i);
 526           break;
 527
 528         default:
 529           abort ();
 530         }
 531     }
 532   return copy;
 533 }
 534
 535 /* Create a new copy of an rtx.  Only copy just one level.  */
 536 rtx
 537 shallow_copy_rtx (orig)
 538      rtx orig;
 539 {
 540   register int i;
 541   register RTX_CODE code = GET_CODE (orig);
 542   register rtx copy = rtx_alloc (code);
 543
 544   PUT_MODE (copy, GET_MODE (orig));
 545   copy->in_struct = orig->in_struct;
 546   copy->volatil = orig->volatil;
 547   copy->unchanging = orig->unchanging;
 548   copy->integrated = orig->integrated;
 549   copy->frame_related = orig->frame_related;
 550
 551   for (i = 0; i < GET_RTX_LENGTH (code); i++)
 552     copy->fld[i] = orig->fld[i];
 553
 554   return copy;
 555 }
 556 \f
 557 /* This is 1 until after the rtl generation pass.  */
 558 int rtx_equal_function_value_matters;
 559
 560 /* Nonzero when we are generating CONCATs.  */
 561 int generating_concat_p;
 562 \f
 563 /* Return 1 if X and Y are identical-looking rtx's.
 564    This is the Lisp function EQUAL for rtx arguments.  */
 565
 566 int
 567 rtx_equal_p (x, y)
 568      rtx x, y;
 569 {
 570   register int i;
 571   register int j;
 572   register enum rtx_code code;
 573   register const char *fmt;
 574
 575   if (x == y)
 576     return 1;
 577   if (x == 0 || y == 0)
 578     return 0;
 579
 580   code = GET_CODE (x);
 581   /* Rtx's of different codes cannot be equal.  */
 582   if (code != GET_CODE (y))
 583     return 0;
 584
 585   /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
 586      (REG:SI x) and (REG:HI x) are NOT equivalent.  */
 587
 588   if (GET_MODE (x) != GET_MODE (y))
 589     return 0;
 590
 591   /* Some RTL can be compared nonrecursively.  */
 592   switch (code)
 593     {
 594     case REG:
 595       /* Until rtl generation is complete, don't consider a reference to the
 596          return register of the current function the same as the return from a
 597          called function.  This eases the job of function integration.  Once the
 598          distinction is no longer needed, they can be considered equivalent.  */
 599       return (REGNO (x) == REGNO (y)
 600               && (! rtx_equal_function_value_matters
 601                   || REG_FUNCTION_VALUE_P (x) == REG_FUNCTION_VALUE_P (y)));
 602
 603     case LABEL_REF:
 604       return XEXP (x, 0) == XEXP (y, 0);
 605
 606     case SYMBOL_REF:
 607       return XSTR (x, 0) == XSTR (y, 0);
 608
 609     case SCRATCH:
 610     case CONST_DOUBLE:
 611     case CONST_INT:
 612       return 0;
 613
 614     default:
 615       break;
 616     }
 617
 618   /* Compare the elements.  If any pair of corresponding elements
 619      fail to match, return 0 for the whole things.  */
 620
 621   fmt = GET_RTX_FORMAT (code);
 622   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
 623     {
 624       switch (fmt[i])
 625         {
 626         case 'w':
 627           if (XWINT (x, i) != XWINT (y, i))
 628             return 0;
 629           break;
 630
 631         case 'n':
 632         case 'i':
 633           if (XINT (x, i) != XINT (y, i))
 634             return 0;
 635           break;
 636
 637         case 'V':
 638         case 'E':
 639           /* Two vectors must have the same length.  */
 640           if (XVECLEN (x, i) != XVECLEN (y, i))
 641             return 0;
 642
 643           /* And the corresponding elements must match.  */
 644           for (j = 0; j < XVECLEN (x, i); j++)
 645             if (rtx_equal_p (XVECEXP (x, i, j), XVECEXP (y, i, j)) == 0)
 646               return 0;
 647           break;
 648
 649         case 'e':
 650           if (rtx_equal_p (XEXP (x, i), XEXP (y, i)) == 0)
 651             return 0;
 652           break;
 653
 654         case 'S':
 655         case 's':
 656           if (strcmp (XSTR (x, i), XSTR (y, i)))
 657             return 0;
 658           break;
 659
 660         case 'u':
 661           /* These are just backpointers, so they don't matter.  */
 662           break;
 663
 664         case '0':
 665         case 't':
 666           break;
 667
 668           /* It is believed that rtx's at this level will never
 669              contain anything but integers and other rtx's,
 670              except for within LABEL_REFs and SYMBOL_REFs.  */
 671         default:
 672           abort ();
 673         }
 674     }
 675   return 1;
 676 }
 677 \f
 678 #if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007)
 679 void
 680 rtl_check_failed_bounds (r, n, file, line, func)
 681     rtx r;
 682     int n;
 683     const char *file;
 684     int line;
 685     const char *func;
 686 {
 687   internal_error
 688     ("RTL check: access of elt %d of `%s' with last elt %d in %s, at %s:%d",
 689      n, GET_RTX_NAME (GET_CODE (r)), GET_RTX_LENGTH (GET_CODE (r)) - 1,
 690      func, trim_filename (file), line);
 691 }
 692
 693 void
 694 rtl_check_failed_type1 (r, n, c1, file, line, func)
 695     rtx r;
 696     int n;
 697     int c1;
 698     const char *file;
 699     int line;
 700     const char *func;
 701 {
 702   internal_error
 703     ("RTL check: expected elt %d type '%c', have '%c' (rtx %s) in %s, at %s:%d",
 704      n, c1, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
 705      func, trim_filename (file), line);
 706 }
 707
 708 void
 709 rtl_check_failed_type2 (r, n, c1, c2, file, line, func)
 710     rtx r;
 711     int n;
 712     int c1;
 713     int c2;
 714     const char *file;
 715     int line;
 716     const char *func;
 717 {
 718   internal_error
 719     ("RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s) in %s, at %s:%d",
 720      n, c1, c2, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
 721      func, trim_filename (file), line);
 722 }
 723
 724 void
 725 rtl_check_failed_code1 (r, code, file, line, func)
 726     rtx r;
 727     enum rtx_code code;
 728     const char *file;
 729     int line;
 730     const char *func;
 731 {
 732   internal_error ("RTL check: expected code `%s', have `%s' in %s, at %s:%d",
 733                   GET_RTX_NAME (code), GET_RTX_NAME (GET_CODE (r)), func,
 734                   trim_filename (file), line);
 735 }
 736
 737 void
 738 rtl_check_failed_code2 (r, code1, code2, file, line, func)
 739     rtx r;
 740     enum rtx_code code1, code2;
 741     const char *file;
 742     int line;
 743     const char *func;
 744 {
 745   internal_error
 746     ("RTL check: expected code `%s' or `%s', have `%s' in %s, at %s:%d",
 747      GET_RTX_NAME (code1), GET_RTX_NAME (code2), GET_RTX_NAME (GET_CODE (r)),
 748      func, trim_filename (file), line);
 749 }
 750
 751 /* XXX Maybe print the vector?  */
 752 void
 753 rtvec_check_failed_bounds (r, n, file, line, func)
 754     rtvec r;
 755     int n;
 756     const char *file;
 757     int line;
 758     const char *func;
 759 {
 760   internal_error
 761     ("RTL check: access of elt %d of vector with last elt %d in %s, at %s:%d",
 762      n, GET_NUM_ELEM (r) - 1, func, trim_filename (file), line);
 763 }
 764 #endif /* ENABLE_RTL_CHECKING */