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
  28 \f
  29 /* Calculate the format for CONST_DOUBLE.  This depends on the relative
  30    widths of HOST_WIDE_INT and REAL_VALUE_TYPE.
  31
  32    We need to go out to e0wwwww, since REAL_ARITHMETIC assumes 16-bits
  33    per element in REAL_VALUE_TYPE.
  34
  35    This is duplicated in gengenrtl.c.
  36
  37    A number of places assume that there are always at least two 'w'
  38    slots in a CONST_DOUBLE, so we provide them even if one would suffice.  */
  39
  40 #ifdef REAL_ARITHMETIC
  41 # if MAX_LONG_DOUBLE_TYPE_SIZE == 96
  42 #  define REAL_WIDTH    \
  43      (11*8 + HOST_BITS_PER_WIDE_INT)/HOST_BITS_PER_WIDE_INT
  44 # else
  45 #  if MAX_LONG_DOUBLE_TYPE_SIZE == 128
  46 #   define REAL_WIDTH   \
  47       (19*8 + HOST_BITS_PER_WIDE_INT)/HOST_BITS_PER_WIDE_INT
  48 #  else
  49 #   if HOST_FLOAT_FORMAT != TARGET_FLOAT_FORMAT
  50 #    define REAL_WIDTH  \
  51        (7*8 + HOST_BITS_PER_WIDE_INT)/HOST_BITS_PER_WIDE_INT
  52 #   endif
  53 #  endif
  54 # endif
  55 #endif /* REAL_ARITHMETIC */
  56
  57 #ifndef REAL_WIDTH
  58 # if HOST_BITS_PER_WIDE_INT*2 >= MAX_LONG_DOUBLE_TYPE_SIZE
  59 #  define REAL_WIDTH    2
  60 # else
  61 #  if HOST_BITS_PER_WIDE_INT*3 >= MAX_LONG_DOUBLE_TYPE_SIZE
  62 #   define REAL_WIDTH   3
  63 #  else
  64 #   if HOST_BITS_PER_WIDE_INT*4 >= MAX_LONG_DOUBLE_TYPE_SIZE
  65 #    define REAL_WIDTH  4
  66 #   endif
  67 #  endif
  68 # endif
  69 #endif /* REAL_WIDTH */
  70
  71 #if REAL_WIDTH == 1
  72 # define CONST_DOUBLE_FORMAT    "e0ww"
  73 #else
  74 # if REAL_WIDTH == 2
  75 #  define CONST_DOUBLE_FORMAT   "e0ww"
  76 # else
  77 #  if REAL_WIDTH == 3
  78 #   define CONST_DOUBLE_FORMAT  "e0www"
  79 #  else
  80 #   if REAL_WIDTH == 4
  81 #    define CONST_DOUBLE_FORMAT "e0wwww"
  82 #   else
  83 #    if REAL_WIDTH == 5
  84 #     define CONST_DOUBLE_FORMAT        "e0wwwww"
  85 #    else
  86 #     define CONST_DOUBLE_FORMAT        /* nothing - will cause syntax error */
  87 #    endif
  88 #   endif
  89 #  endif
  90 # endif
  91 #endif
  92
  93 /* Indexed by rtx code, gives number of operands for an rtx with that code.
  94    Does NOT include rtx header data (code and links).  */
  95
  96 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS)   sizeof FORMAT - 1 ,
  97
  98 const int rtx_length[NUM_RTX_CODE + 1] = {
  99 #include "rtl.def"
 100 };
 101
 102 #undef DEF_RTL_EXPR
 103
 104 /* Indexed by rtx code, gives the name of that kind of rtx, as a C string.  */
 105
 106 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS)   NAME ,
 107
 108 const char * const rtx_name[] = {
 109 #include "rtl.def"              /* rtl expressions are documented here */
 110 };
 111
 112 #undef DEF_RTL_EXPR
 113
 114 /* Indexed by machine mode, gives the name of that machine mode.
 115    This name does not include the letters "mode".  */
 116
 117 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER)  NAME,
 118
 119 const char * const mode_name[(int) MAX_MACHINE_MODE + 1] = {
 120 #include "machmode.def"
 121   /* Add an extra field to avoid a core dump if someone tries to convert
 122      MAX_MACHINE_MODE to a string.   */
 123   ""
 124 };
 125
 126 #undef DEF_MACHMODE
 127
 128 /* Indexed by machine mode, gives the class mode for GET_MODE_CLASS.  */
 129
 130 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER)  CLASS,
 131
 132 const enum mode_class mode_class[(int) MAX_MACHINE_MODE] = {
 133 #include "machmode.def"
 134 };
 135
 136 #undef DEF_MACHMODE
 137
 138 /* Indexed by machine mode, gives the length of the mode, in bits.
 139    GET_MODE_BITSIZE uses this.  */
 140
 141 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER)  BITSIZE,
 142
 143 const unsigned int mode_bitsize[(int) MAX_MACHINE_MODE] = {
 144 #include "machmode.def"
 145 };
 146
 147 #undef DEF_MACHMODE
 148
 149 /* Indexed by machine mode, gives the length of the mode, in bytes.
 150    GET_MODE_SIZE uses this.  */
 151
 152 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER)  SIZE,
 153
 154 const unsigned int mode_size[(int) MAX_MACHINE_MODE] = {
 155 #include "machmode.def"
 156 };
 157
 158 #undef DEF_MACHMODE
 159
 160 /* Indexed by machine mode, gives the length of the mode's subunit.
 161    GET_MODE_UNIT_SIZE uses this.  */
 162
 163 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER)  UNIT,
 164
 165 const unsigned int mode_unit_size[(int) MAX_MACHINE_MODE] = {
 166 #include "machmode.def"         /* machine modes are documented here */
 167 };
 168
 169 #undef DEF_MACHMODE
 170
 171 /* Indexed by machine mode, gives next wider natural mode
 172    (QI -> HI -> SI -> DI, etc.)  Widening multiply instructions
 173    use this.  */
 174
 175 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER)  \
 176   (unsigned char) WIDER,
 177
 178 const unsigned char mode_wider_mode[(int) MAX_MACHINE_MODE] = {
 179 #include "machmode.def"         /* machine modes are documented here */
 180 };
 181
 182 #undef DEF_MACHMODE
 183
 184 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER)  \
 185   ((BITSIZE) >= HOST_BITS_PER_WIDE_INT) ? ~(unsigned HOST_WIDE_INT)0 : ((unsigned HOST_WIDE_INT) 1 << (BITSIZE)) - 1,
 186
 187 /* Indexed by machine mode, gives mask of significant bits in mode.  */
 188
 189 const unsigned HOST_WIDE_INT mode_mask_array[(int) MAX_MACHINE_MODE] = {
 190 #include "machmode.def"
 191 };
 192
 193 /* Indexed by mode class, gives the narrowest mode for each class.
 194    The Q modes are always of width 1 (2 for complex) - it is impossible
 195    for any mode to be narrower.
 196
 197    Note that we use QImode instead of BImode for MODE_INT, since
 198    otherwise the middle end will try to use it for bitfields in
 199    structures and the like, which we do not want.  Only the target
 200    md file should generate BImode widgets.  */
 201
 202 const enum machine_mode class_narrowest_mode[(int) MAX_MODE_CLASS] = {
 203     /* MODE_RANDOM */           VOIDmode,
 204     /* MODE_INT */              QImode,
 205     /* MODE_FLOAT */            QFmode,
 206     /* MODE_PARTIAL_INT */      PQImode,
 207     /* MODE_CC */               CCmode,
 208     /* MODE_COMPLEX_INT */      CQImode,
 209     /* MODE_COMPLEX_FLOAT */    QCmode,
 210     /* MODE_VECTOR_INT */       V2QImode,
 211     /* MODE_VECTOR_FLOAT */     V2SFmode
 212 };
 213
 214
 215 /* Indexed by rtx code, gives a sequence of operand-types for
 216    rtx's of that code.  The sequence is a C string in which
 217    each character describes one operand.  */
 218
 219 const char * const rtx_format[] = {
 220   /* "*" undefined.
 221          can cause a warning message
 222      "0" field is unused (or used in a phase-dependent manner)
 223          prints nothing
 224      "i" an integer
 225          prints the integer
 226      "n" like "i", but prints entries from `note_insn_name'
 227      "w" an integer of width HOST_BITS_PER_WIDE_INT
 228          prints the integer
 229      "s" a pointer to a string
 230          prints the string
 231      "S" like "s", but optional:
 232          the containing rtx may end before this operand
 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", "NOTE_INSN_SETJMP",
 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_EH_RETHROW", "REG_SAVE_NOTE", "REG_MAYBE_DEAD", "REG_NORETURN",
 284   "REG_NON_LOCAL_GOTO"
 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 'u':
 421         case '0':
 422           /* These are left unchanged.  */
 423           break;
 424
 425         default:
 426           abort ();
 427         }
 428     }
 429   return copy;
 430 }
 431
 432 /* Similar to `copy_rtx' except that if MAY_SHARE is present, it is
 433    placed in the result directly, rather than being copied.  */
 434
 435 rtx
 436 copy_most_rtx (orig, may_share)
 437      register rtx orig;
 438      register rtx may_share;
 439 {
 440   register rtx copy;
 441   register int i, j;
 442   register RTX_CODE code;
 443   register const char *format_ptr;
 444
 445   if (orig == may_share)
 446     return orig;
 447
 448   code = GET_CODE (orig);
 449
 450   switch (code)
 451     {
 452     case REG:
 453     case QUEUED:
 454     case CONST_INT:
 455     case CONST_DOUBLE:
 456     case SYMBOL_REF:
 457     case CODE_LABEL:
 458     case PC:
 459     case CC0:
 460       return orig;
 461     default:
 462       break;
 463     }
 464
 465   copy = rtx_alloc (code);
 466   PUT_MODE (copy, GET_MODE (orig));
 467   copy->in_struct = orig->in_struct;
 468   copy->volatil = orig->volatil;
 469   copy->unchanging = orig->unchanging;
 470   copy->integrated = orig->integrated;
 471   copy->frame_related = orig->frame_related;
 472
 473   format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
 474
 475   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
 476     {
 477       switch (*format_ptr++)
 478         {
 479         case 'e':
 480           XEXP (copy, i) = XEXP (orig, i);
 481           if (XEXP (orig, i) != NULL && XEXP (orig, i) != may_share)
 482             XEXP (copy, i) = copy_most_rtx (XEXP (orig, i), may_share);
 483           break;
 484
 485         case 'u':
 486           XEXP (copy, i) = XEXP (orig, i);
 487           break;
 488
 489         case 'E':
 490         case 'V':
 491           XVEC (copy, i) = XVEC (orig, i);
 492           if (XVEC (orig, i) != NULL)
 493             {
 494               XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
 495               for (j = 0; j < XVECLEN (copy, i); j++)
 496                 XVECEXP (copy, i, j)
 497                   = copy_most_rtx (XVECEXP (orig, i, j), may_share);
 498             }
 499           break;
 500
 501         case 'w':
 502           XWINT (copy, i) = XWINT (orig, i);
 503           break;
 504
 505         case 'n':
 506         case 'i':
 507           XINT (copy, i) = XINT (orig, i);
 508           break;
 509
 510         case 't':
 511           XTREE (copy, i) = XTREE (orig, i);
 512           break;
 513
 514         case 's':
 515         case 'S':
 516           XSTR (copy, i) = XSTR (orig, i);
 517           break;
 518
 519         case '0':
 520           /* Copy this through the wide int field; that's safest. */
 521           X0WINT (copy, i) = X0WINT (orig, i);
 522           break;
 523
 524         default:
 525           abort ();
 526         }
 527     }
 528   return copy;
 529 }
 530
 531 /* Create a new copy of an rtx.  Only copy just one level.  */
 532 rtx
 533 shallow_copy_rtx (orig)
 534      rtx orig;
 535 {
 536   register int i;
 537   register RTX_CODE code = GET_CODE (orig);
 538   register rtx copy = rtx_alloc (code);
 539
 540   PUT_MODE (copy, GET_MODE (orig));
 541   copy->in_struct = orig->in_struct;
 542   copy->volatil = orig->volatil;
 543   copy->unchanging = orig->unchanging;
 544   copy->integrated = orig->integrated;
 545   copy->frame_related = orig->frame_related;
 546
 547   for (i = 0; i < GET_RTX_LENGTH (code); i++)
 548     copy->fld[i] = orig->fld[i];
 549
 550   return copy;
 551 }
 552 \f
 553 /* This is 1 until after the rtl generation pass.  */
 554 int rtx_equal_function_value_matters;
 555
 556 /* Nonzero when we are generating CONCATs.  */
 557 int generating_concat_p;
 558 \f
 559 /* Return 1 if X and Y are identical-looking rtx's.
 560    This is the Lisp function EQUAL for rtx arguments.  */
 561
 562 int
 563 rtx_equal_p (x, y)
 564      rtx x, y;
 565 {
 566   register int i;
 567   register int j;
 568   register enum rtx_code code;
 569   register const char *fmt;
 570
 571   if (x == y)
 572     return 1;
 573   if (x == 0 || y == 0)
 574     return 0;
 575
 576   code = GET_CODE (x);
 577   /* Rtx's of different codes cannot be equal.  */
 578   if (code != GET_CODE (y))
 579     return 0;
 580
 581   /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
 582      (REG:SI x) and (REG:HI x) are NOT equivalent.  */
 583
 584   if (GET_MODE (x) != GET_MODE (y))
 585     return 0;
 586
 587   /* Some RTL can be compared nonrecursively.  */
 588   switch (code)
 589     {
 590     case REG:
 591       /* Until rtl generation is complete, don't consider a reference to the
 592          return register of the current function the same as the return from a
 593          called function.  This eases the job of function integration.  Once the
 594          distinction is no longer needed, they can be considered equivalent.  */
 595       return (REGNO (x) == REGNO (y)
 596               && (! rtx_equal_function_value_matters
 597                   || REG_FUNCTION_VALUE_P (x) == REG_FUNCTION_VALUE_P (y)));
 598
 599     case LABEL_REF:
 600       return XEXP (x, 0) == XEXP (y, 0);
 601
 602     case SYMBOL_REF:
 603       return XSTR (x, 0) == XSTR (y, 0);
 604
 605     case SCRATCH:
 606     case CONST_DOUBLE:
 607     case CONST_INT:
 608       return 0;
 609
 610     default:
 611       break;
 612     }
 613
 614   /* Compare the elements.  If any pair of corresponding elements
 615      fail to match, return 0 for the whole things.  */
 616
 617   fmt = GET_RTX_FORMAT (code);
 618   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
 619     {
 620       switch (fmt[i])
 621         {
 622         case 'w':
 623           if (XWINT (x, i) != XWINT (y, i))
 624             return 0;
 625           break;
 626
 627         case 'n':
 628         case 'i':
 629           if (XINT (x, i) != XINT (y, i))
 630             return 0;
 631           break;
 632
 633         case 'V':
 634         case 'E':
 635           /* Two vectors must have the same length.  */
 636           if (XVECLEN (x, i) != XVECLEN (y, i))
 637             return 0;
 638
 639           /* And the corresponding elements must match.  */
 640           for (j = 0; j < XVECLEN (x, i); j++)
 641             if (rtx_equal_p (XVECEXP (x, i, j), XVECEXP (y, i, j)) == 0)
 642               return 0;
 643           break;
 644
 645         case 'e':
 646           if (rtx_equal_p (XEXP (x, i), XEXP (y, i)) == 0)
 647             return 0;
 648           break;
 649
 650         case 'S':
 651         case 's':
 652           if (strcmp (XSTR (x, i), XSTR (y, i)))
 653             return 0;
 654           break;
 655
 656         case 'u':
 657           /* These are just backpointers, so they don't matter.  */
 658           break;
 659
 660         case '0':
 661         case 't':
 662           break;
 663
 664           /* It is believed that rtx's at this level will never
 665              contain anything but integers and other rtx's,
 666              except for within LABEL_REFs and SYMBOL_REFs.  */
 667         default:
 668           abort ();
 669         }
 670     }
 671   return 1;
 672 }
 673 \f
 674 #if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007)
 675 void
 676 rtl_check_failed_bounds (r, n, file, line, func)
 677     rtx r;
 678     int n;
 679     const char *file;
 680     int line;
 681     const char *func;
 682 {
 683   internal_error
 684     ("RTL check: access of elt %d of `%s' with last elt %d in %s, at %s:%d",
 685      n, GET_RTX_NAME (GET_CODE (r)), GET_RTX_LENGTH (GET_CODE (r)) - 1,
 686      func, trim_filename (file), line);
 687 }
 688
 689 void
 690 rtl_check_failed_type1 (r, n, c1, file, line, func)
 691     rtx r;
 692     int n;
 693     int c1;
 694     const char *file;
 695     int line;
 696     const char *func;
 697 {
 698   internal_error
 699     ("RTL check: expected elt %d type '%c', have '%c' (rtx %s) in %s, at %s:%d",
 700      n, c1, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
 701      func, trim_filename (file), line);
 702 }
 703
 704 void
 705 rtl_check_failed_type2 (r, n, c1, c2, file, line, func)
 706     rtx r;
 707     int n;
 708     int c1;
 709     int c2;
 710     const char *file;
 711     int line;
 712     const char *func;
 713 {
 714   internal_error
 715     ("RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s) in %s, at %s:%d",
 716      n, c1, c2, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
 717      func, trim_filename (file), line);
 718 }
 719
 720 void
 721 rtl_check_failed_code1 (r, code, file, line, func)
 722     rtx r;
 723     enum rtx_code code;
 724     const char *file;
 725     int line;
 726     const char *func;
 727 {
 728   internal_error ("RTL check: expected code `%s', have `%s' in %s, at %s:%d",
 729                   GET_RTX_NAME (code), GET_RTX_NAME (GET_CODE (r)), func,
 730                   trim_filename (file), line);
 731 }
 732
 733 void
 734 rtl_check_failed_code2 (r, code1, code2, file, line, func)
 735     rtx r;
 736     enum rtx_code code1, code2;
 737     const char *file;
 738     int line;
 739     const char *func;
 740 {
 741   internal_error
 742     ("RTL check: expected code `%s' or `%s', have `%s' in %s, at %s:%d",
 743      GET_RTX_NAME (code1), GET_RTX_NAME (code2), GET_RTX_NAME (GET_CODE (r)),
 744      func, trim_filename (file), line);
 745 }
 746
 747 /* XXX Maybe print the vector?  */
 748 void
 749 rtvec_check_failed_bounds (r, n, file, line, func)
 750     rtvec r;
 751     int n;
 752     const char *file;
 753     int line;
 754     const char *func;
 755 {
 756   internal_error
 757     ("RTL check: access of elt %d of vector with last elt %d in %s, at %s:%d",
 758      n, GET_NUM_ELEM (r) - 1, func, trim_filename (file), line);
 759 }
 760 #endif /* ENABLE_RTL_CHECKING */