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 0wwwww, 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    "0ww"
  74 #else
  75 # if REAL_WIDTH == 2
  76 #  define CONST_DOUBLE_FORMAT   "0ww"
  77 # else
  78 #  if REAL_WIDTH == 3
  79 #   define CONST_DOUBLE_FORMAT  "0www"
  80 #  else
  81 #   if REAL_WIDTH == 4
  82 #    define CONST_DOUBLE_FORMAT "0wwww"
  83 #   else
  84 #    if REAL_WIDTH == 5
  85 #     define CONST_DOUBLE_FORMAT        "0wwwww"
  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
 535 rtx
 536 shallow_copy_rtx (orig)
 537      rtx orig;
 538 {
 539   int i;
 540   RTX_CODE code = GET_CODE (orig);
 541   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
 556 /* Return the alignment of MODE. This will be bounded by 1 and
 557    BIGGEST_ALIGNMENT.  */
 558
 559 unsigned int
 560 get_mode_alignment (mode)
 561      enum machine_mode mode;
 562 {
 563   unsigned int alignment = GET_MODE_UNIT_SIZE (mode);
 564
 565   /* Extract the LSB of the size.  */
 566   alignment = alignment & -alignment;
 567   alignment *= BITS_PER_UNIT;
 568
 569   alignment = MIN (BIGGEST_ALIGNMENT, MAX (1, alignment));
 570   return alignment;
 571 }
 572 \f
 573 /* This is 1 until after the rtl generation pass.  */
 574 int rtx_equal_function_value_matters;
 575
 576 /* Nonzero when we are generating CONCATs.  */
 577 int generating_concat_p;
 578 \f
 579 /* Return 1 if X and Y are identical-looking rtx's.
 580    This is the Lisp function EQUAL for rtx arguments.  */
 581
 582 int
 583 rtx_equal_p (x, y)
 584      rtx x, y;
 585 {
 586   int i;
 587   int j;
 588   enum rtx_code code;
 589   const char *fmt;
 590
 591   if (x == y)
 592     return 1;
 593   if (x == 0 || y == 0)
 594     return 0;
 595
 596   code = GET_CODE (x);
 597   /* Rtx's of different codes cannot be equal.  */
 598   if (code != GET_CODE (y))
 599     return 0;
 600
 601   /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
 602      (REG:SI x) and (REG:HI x) are NOT equivalent.  */
 603
 604   if (GET_MODE (x) != GET_MODE (y))
 605     return 0;
 606
 607   /* Some RTL can be compared nonrecursively.  */
 608   switch (code)
 609     {
 610     case REG:
 611       /* Until rtl generation is complete, don't consider a reference
 612          to the return register of the current function the same as
 613          the return from a called function.  This eases the job of
 614          function integration.  Once the distinction is no longer
 615          needed, they can be considered equivalent.  */
 616       return (REGNO (x) == REGNO (y)
 617               && (! rtx_equal_function_value_matters
 618                   || REG_FUNCTION_VALUE_P (x) == REG_FUNCTION_VALUE_P (y)));
 619
 620     case LABEL_REF:
 621       return XEXP (x, 0) == XEXP (y, 0);
 622
 623     case SYMBOL_REF:
 624       return XSTR (x, 0) == XSTR (y, 0);
 625
 626     case SCRATCH:
 627     case CONST_DOUBLE:
 628     case CONST_INT:
 629       return 0;
 630
 631     default:
 632       break;
 633     }
 634
 635   /* Compare the elements.  If any pair of corresponding elements
 636      fail to match, return 0 for the whole things.  */
 637
 638   fmt = GET_RTX_FORMAT (code);
 639   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
 640     {
 641       switch (fmt[i])
 642         {
 643         case 'w':
 644           if (XWINT (x, i) != XWINT (y, i))
 645             return 0;
 646           break;
 647
 648         case 'n':
 649         case 'i':
 650           if (XINT (x, i) != XINT (y, i))
 651             return 0;
 652           break;
 653
 654         case 'V':
 655         case 'E':
 656           /* Two vectors must have the same length.  */
 657           if (XVECLEN (x, i) != XVECLEN (y, i))
 658             return 0;
 659
 660           /* And the corresponding elements must match.  */
 661           for (j = 0; j < XVECLEN (x, i); j++)
 662             if (rtx_equal_p (XVECEXP (x, i, j), XVECEXP (y, i, j)) == 0)
 663               return 0;
 664           break;
 665
 666         case 'e':
 667           if (rtx_equal_p (XEXP (x, i), XEXP (y, i)) == 0)
 668             return 0;
 669           break;
 670
 671         case 'S':
 672         case 's':
 673           if ((XSTR (x, i) || XSTR (y, i))
 674               && (! XSTR (x, i) || ! XSTR (y, i)
 675                   || strcmp (XSTR (x, i), XSTR (y, i))))
 676             return 0;
 677           break;
 678
 679         case 'u':
 680           /* These are just backpointers, so they don't matter.  */
 681           break;
 682
 683         case '0':
 684         case 't':
 685           break;
 686
 687           /* It is believed that rtx's at this level will never
 688              contain anything but integers and other rtx's,
 689              except for within LABEL_REFs and SYMBOL_REFs.  */
 690         default:
 691           abort ();
 692         }
 693     }
 694   return 1;
 695 }
 696 \f
 697 #if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007)
 698 void
 699 rtl_check_failed_bounds (r, n, file, line, func)
 700     rtx r;
 701     int n;
 702     const char *file;
 703     int line;
 704     const char *func;
 705 {
 706   internal_error
 707     ("RTL check: access of elt %d of `%s' with last elt %d in %s, at %s:%d",
 708      n, GET_RTX_NAME (GET_CODE (r)), GET_RTX_LENGTH (GET_CODE (r)) - 1,
 709      func, trim_filename (file), line);
 710 }
 711
 712 void
 713 rtl_check_failed_type1 (r, n, c1, file, line, func)
 714     rtx r;
 715     int n;
 716     int c1;
 717     const char *file;
 718     int line;
 719     const char *func;
 720 {
 721   internal_error
 722     ("RTL check: expected elt %d type '%c', have '%c' (rtx %s) in %s, at %s:%d",
 723      n, c1, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
 724      func, trim_filename (file), line);
 725 }
 726
 727 void
 728 rtl_check_failed_type2 (r, n, c1, c2, file, line, func)
 729     rtx r;
 730     int n;
 731     int c1;
 732     int c2;
 733     const char *file;
 734     int line;
 735     const char *func;
 736 {
 737   internal_error
 738     ("RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s) in %s, at %s:%d",
 739      n, c1, c2, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
 740      func, trim_filename (file), line);
 741 }
 742
 743 void
 744 rtl_check_failed_code1 (r, code, file, line, func)
 745     rtx r;
 746     enum rtx_code code;
 747     const char *file;
 748     int line;
 749     const char *func;
 750 {
 751   internal_error ("RTL check: expected code `%s', have `%s' in %s, at %s:%d",
 752                   GET_RTX_NAME (code), GET_RTX_NAME (GET_CODE (r)), func,
 753                   trim_filename (file), line);
 754 }
 755
 756 void
 757 rtl_check_failed_code2 (r, code1, code2, file, line, func)
 758     rtx r;
 759     enum rtx_code code1, code2;
 760     const char *file;
 761     int line;
 762     const char *func;
 763 {
 764   internal_error
 765     ("RTL check: expected code `%s' or `%s', have `%s' in %s, at %s:%d",
 766      GET_RTX_NAME (code1), GET_RTX_NAME (code2), GET_RTX_NAME (GET_CODE (r)),
 767      func, trim_filename (file), line);
 768 }
 769
 770 /* XXX Maybe print the vector?  */
 771 void
 772 rtvec_check_failed_bounds (r, n, file, line, func)
 773     rtvec r;
 774     int n;
 775     const char *file;
 776     int line;
 777     const char *func;
 778 {
 779   internal_error
 780     ("RTL check: access of elt %d of vector with last elt %d in %s, at %s:%d",
 781      n, GET_NUM_ELEM (r) - 1, func, trim_filename (file), line);
 782 }
 783 #endif /* ENABLE_RTL_CHECKING */