gcc/rtl.c

   1 /* RTL utility routines.
   2    Copyright (C) 1987, 1988, 1991, 1994, 1997, 1998, 1999, 2000, 2001, 2002
   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 unsigned char rtx_length[NUM_RTX_CODE] = {
 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[NUM_RTX_CODE] = {
 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, INNER)  NAME,
 119
 120 const char * const mode_name[NUM_MACHINE_MODES] = {
 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, INNER)  CLASS,
 129
 130 const enum mode_class mode_class[NUM_MACHINE_MODES] = {
 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, INNER)  BITSIZE,
 140
 141 const unsigned short mode_bitsize[NUM_MACHINE_MODES] = {
 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, INNER)  SIZE,
 151
 152 const unsigned char mode_size[NUM_MACHINE_MODES] = {
 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, INNER)  UNIT,
 162
 163 const unsigned char mode_unit_size[NUM_MACHINE_MODES] = {
 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, INNER)  \
 174   (unsigned char) WIDER,
 175
 176 const unsigned char mode_wider_mode[NUM_MACHINE_MODES] = {
 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, INNER)  \
 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[NUM_MACHINE_MODES] = {
 188 #include "machmode.def"
 189 };
 190
 191 #undef DEF_MACHMODE
 192
 193 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER, INNER) INNER,
 194
 195 /* Indexed by machine mode, gives the mode of the inner elements in a
 196    vector type.  */
 197
 198 const enum machine_mode inner_mode_array[NUM_MACHINE_MODES] = {
 199 #include "machmode.def"
 200 };
 201
 202 /* Indexed by mode class, gives the narrowest mode for each class.
 203    The Q modes are always of width 1 (2 for complex) - it is impossible
 204    for any mode to be narrower.
 205
 206    Note that we use QImode instead of BImode for MODE_INT, since
 207    otherwise the middle end will try to use it for bitfields in
 208    structures and the like, which we do not want.  Only the target
 209    md file should generate BImode widgets.  */
 210
 211 const enum machine_mode class_narrowest_mode[(int) MAX_MODE_CLASS] = {
 212     /* MODE_RANDOM */           VOIDmode,
 213     /* MODE_INT */              QImode,
 214     /* MODE_FLOAT */            QFmode,
 215     /* MODE_PARTIAL_INT */      PQImode,
 216     /* MODE_CC */               CCmode,
 217     /* MODE_COMPLEX_INT */      CQImode,
 218     /* MODE_COMPLEX_FLOAT */    QCmode,
 219     /* MODE_VECTOR_INT */       V2QImode,
 220     /* MODE_VECTOR_FLOAT */     V2SFmode
 221 };
 222
 223
 224 /* Indexed by rtx code, gives a sequence of operand-types for
 225    rtx's of that code.  The sequence is a C string in which
 226    each character describes one operand.  */
 227
 228 const char * const rtx_format[NUM_RTX_CODE] = {
 229   /* "*" undefined.
 230          can cause a warning message
 231      "0" field is unused (or used in a phase-dependent manner)
 232          prints nothing
 233      "i" an integer
 234          prints the integer
 235      "n" like "i", but prints entries from `note_insn_name'
 236      "w" an integer of width HOST_BITS_PER_WIDE_INT
 237          prints the integer
 238      "s" a pointer to a string
 239          prints the string
 240      "S" like "s", but optional:
 241          the containing rtx may end before this operand
 242      "T" like "s", but treated specially by the RTL reader;
 243          only found in machine description patterns.
 244      "e" a pointer to an rtl expression
 245          prints the expression
 246      "E" a pointer to a vector that points to a number of rtl expressions
 247          prints a list of the rtl expressions
 248      "V" like "E", but optional:
 249          the containing rtx may end before this operand
 250      "u" a pointer to another insn
 251          prints the uid of the insn.
 252      "b" is a pointer to a bitmap header.
 253      "t" is a tree pointer.  */
 254
 255 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS)   FORMAT ,
 256 #include "rtl.def"              /* rtl expressions are defined here */
 257 #undef DEF_RTL_EXPR
 258 };
 259
 260 /* Indexed by rtx code, gives a character representing the "class" of
 261    that rtx code.  See rtl.def for documentation on the defined classes.  */
 262
 263 const char rtx_class[NUM_RTX_CODE] = {
 264 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS)   CLASS,
 265 #include "rtl.def"              /* rtl expressions are defined here */
 266 #undef DEF_RTL_EXPR
 267 };
 268
 269 /* Names for kinds of NOTEs and REG_NOTEs.  */
 270
 271 const char * const note_insn_name[NOTE_INSN_MAX - NOTE_INSN_BIAS] =
 272 {
 273   "", "NOTE_INSN_DELETED",
 274   "NOTE_INSN_BLOCK_BEG", "NOTE_INSN_BLOCK_END",
 275   "NOTE_INSN_LOOP_BEG", "NOTE_INSN_LOOP_END",
 276   "NOTE_INSN_LOOP_CONT", "NOTE_INSN_LOOP_VTOP",
 277   "NOTE_INSN_LOOP_END_TOP_COND", "NOTE_INSN_FUNCTION_END",
 278   "NOTE_INSN_PROLOGUE_END", "NOTE_INSN_EPILOGUE_BEG",
 279   "NOTE_INSN_DELETED_LABEL", "NOTE_INSN_FUNCTION_BEG",
 280   "NOTE_INSN_EH_REGION_BEG", "NOTE_INSN_EH_REGION_END",
 281   "NOTE_INSN_REPEATED_LINE_NUMBER", "NOTE_INSN_RANGE_BEG",
 282   "NOTE_INSN_RANGE_END", "NOTE_INSN_LIVE",
 283   "NOTE_INSN_BASIC_BLOCK", "NOTE_INSN_EXPECTED_VALUE"
 284 };
 285
 286 const char * const reg_note_name[] =
 287 {
 288   "", "REG_DEAD", "REG_INC", "REG_EQUIV", "REG_EQUAL",
 289   "REG_WAS_0", "REG_RETVAL", "REG_LIBCALL", "REG_NONNEG",
 290   "REG_NO_CONFLICT", "REG_UNUSED", "REG_CC_SETTER", "REG_CC_USER",
 291   "REG_LABEL", "REG_DEP_ANTI", "REG_DEP_OUTPUT", "REG_BR_PROB",
 292   "REG_EXEC_COUNT", "REG_NOALIAS", "REG_SAVE_AREA", "REG_BR_PRED",
 293   "REG_FRAME_RELATED_EXPR", "REG_EH_CONTEXT", "REG_EH_REGION",
 294   "REG_SAVE_NOTE", "REG_MAYBE_DEAD", "REG_NORETURN",
 295   "REG_NON_LOCAL_GOTO", "REG_SETJMP", "REG_ALWAYS_RETURN",
 296   "REG_VTABLE_REF"
 297 };
 298
 299 \f
 300 /* Allocate an rtx vector of N elements.
 301    Store the length, and initialize all elements to zero.  */
 302
 303 rtvec
 304 rtvec_alloc (n)
 305      int n;
 306 {
 307   rtvec rt;
 308
 309   rt = ggc_alloc_rtvec (n);
 310   /* clear out the vector */
 311   memset (&rt->elem[0], 0, n * sizeof (rtx));
 312
 313   PUT_NUM_ELEM (rt, n);
 314   return rt;
 315 }
 316
 317 /* Allocate an rtx of code CODE.  The CODE is stored in the rtx;
 318    all the rest is initialized to zero.  */
 319
 320 rtx
 321 rtx_alloc (code)
 322   RTX_CODE code;
 323 {
 324   rtx rt;
 325   int n = GET_RTX_LENGTH (code);
 326
 327   rt = ggc_alloc_rtx (n);
 328
 329   /* We want to clear everything up to the FLD array.  Normally, this
 330      is one int, but we don't want to assume that and it isn't very
 331      portable anyway; this is.  */
 332
 333   memset (rt, 0, sizeof (struct rtx_def) - sizeof (rtunion));
 334   PUT_CODE (rt, code);
 335   return rt;
 336 }
 337
 338 \f
 339 /* Create a new copy of an rtx.
 340    Recursively copies the operands of the rtx,
 341    except for those few rtx codes that are sharable.  */
 342
 343 rtx
 344 copy_rtx (orig)
 345      rtx orig;
 346 {
 347   rtx copy;
 348   int i, j;
 349   RTX_CODE code;
 350   const char *format_ptr;
 351
 352   code = GET_CODE (orig);
 353
 354   switch (code)
 355     {
 356     case REG:
 357     case QUEUED:
 358     case CONST_INT:
 359     case CONST_DOUBLE:
 360     case CONST_VECTOR:
 361     case SYMBOL_REF:
 362     case CODE_LABEL:
 363     case PC:
 364     case CC0:
 365     case SCRATCH:
 366       /* SCRATCH must be shared because they represent distinct values.  */
 367     case ADDRESSOF:
 368       return orig;
 369
 370     case CONST:
 371       /* CONST can be shared if it contains a SYMBOL_REF.  If it contains
 372          a LABEL_REF, it isn't sharable.  */
 373       if (GET_CODE (XEXP (orig, 0)) == PLUS
 374           && GET_CODE (XEXP (XEXP (orig, 0), 0)) == SYMBOL_REF
 375           && GET_CODE (XEXP (XEXP (orig, 0), 1)) == CONST_INT)
 376         return orig;
 377       break;
 378
 379       /* A MEM with a constant address is not sharable.  The problem is that
 380          the constant address may need to be reloaded.  If the mem is shared,
 381          then reloading one copy of this mem will cause all copies to appear
 382          to have been reloaded.  */
 383
 384     default:
 385       break;
 386     }
 387
 388   copy = rtx_alloc (code);
 389
 390   /* Copy the various flags, and other information.  We assume that
 391      all fields need copying, and then clear the fields that should
 392      not be copied.  That is the sensible default behavior, and forces
 393      us to explicitly document why we are *not* copying a flag.  */
 394   memcpy (copy, orig, sizeof (struct rtx_def) - sizeof (rtunion));
 395
 396   /* We do not copy the USED flag, which is used as a mark bit during
 397      walks over the RTL.  */
 398   copy->used = 0;
 399
 400   /* We do not copy FRAME_RELATED for INSNs.  */
 401   if (GET_RTX_CLASS (code) == 'i')
 402     copy->frame_related = 0;
 403   copy->jump = orig->jump;
 404   copy->call = orig->call;
 405
 406   format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
 407
 408   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
 409     {
 410       copy->fld[i] = orig->fld[i];
 411       switch (*format_ptr++)
 412         {
 413         case 'e':
 414           if (XEXP (orig, i) != NULL)
 415             XEXP (copy, i) = copy_rtx (XEXP (orig, i));
 416           break;
 417
 418         case 'E':
 419         case 'V':
 420           if (XVEC (orig, i) != NULL)
 421             {
 422               XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
 423               for (j = 0; j < XVECLEN (copy, i); j++)
 424                 XVECEXP (copy, i, j) = copy_rtx (XVECEXP (orig, i, j));
 425             }
 426           break;
 427
 428         case 't':
 429         case 'w':
 430         case 'i':
 431         case 's':
 432         case 'S':
 433         case 'T':
 434         case 'u':
 435         case '0':
 436           /* These are left unchanged.  */
 437           break;
 438
 439         default:
 440           abort ();
 441         }
 442     }
 443   return copy;
 444 }
 445
 446 /* Create a new copy of an rtx.  Only copy just one level.  */
 447
 448 rtx
 449 shallow_copy_rtx (orig)
 450      rtx orig;
 451 {
 452   int i;
 453   RTX_CODE code = GET_CODE (orig);
 454   rtx copy = rtx_alloc (code);
 455
 456   PUT_MODE (copy, GET_MODE (orig));
 457   copy->in_struct = orig->in_struct;
 458   copy->volatil = orig->volatil;
 459   copy->unchanging = orig->unchanging;
 460   copy->integrated = orig->integrated;
 461   copy->frame_related = orig->frame_related;
 462
 463   for (i = 0; i < GET_RTX_LENGTH (code); i++)
 464     copy->fld[i] = orig->fld[i];
 465
 466   return copy;
 467 }
 468
 469 /* Return the alignment of MODE. This will be bounded by 1 and
 470    BIGGEST_ALIGNMENT.  */
 471
 472 unsigned int
 473 get_mode_alignment (mode)
 474      enum machine_mode mode;
 475 {
 476   unsigned int alignment;
 477
 478   if (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT
 479       || GET_MODE_CLASS (mode) == MODE_COMPLEX_INT)
 480     alignment = GET_MODE_UNIT_SIZE (mode);
 481   else
 482     alignment = GET_MODE_SIZE (mode);
 483
 484   /* Extract the LSB of the size.  */
 485   alignment = alignment & -alignment;
 486   alignment *= BITS_PER_UNIT;
 487
 488   alignment = MIN (BIGGEST_ALIGNMENT, MAX (1, alignment));
 489   return alignment;
 490 }
 491 \f
 492 /* This is 1 until after the rtl generation pass.  */
 493 int rtx_equal_function_value_matters;
 494
 495 /* Nonzero when we are generating CONCATs.  */
 496 int generating_concat_p;
 497 \f
 498 /* Return 1 if X and Y are identical-looking rtx's.
 499    This is the Lisp function EQUAL for rtx arguments.  */
 500
 501 int
 502 rtx_equal_p (x, y)
 503      rtx x, y;
 504 {
 505   int i;
 506   int j;
 507   enum rtx_code code;
 508   const char *fmt;
 509
 510   if (x == y)
 511     return 1;
 512   if (x == 0 || y == 0)
 513     return 0;
 514
 515   code = GET_CODE (x);
 516   /* Rtx's of different codes cannot be equal.  */
 517   if (code != GET_CODE (y))
 518     return 0;
 519
 520   /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
 521      (REG:SI x) and (REG:HI x) are NOT equivalent.  */
 522
 523   if (GET_MODE (x) != GET_MODE (y))
 524     return 0;
 525
 526   /* Some RTL can be compared nonrecursively.  */
 527   switch (code)
 528     {
 529     case REG:
 530       /* Until rtl generation is complete, don't consider a reference
 531          to the return register of the current function the same as
 532          the return from a called function.  This eases the job of
 533          function integration.  Once the distinction is no longer
 534          needed, they can be considered equivalent.  */
 535       return (REGNO (x) == REGNO (y)
 536               && (! rtx_equal_function_value_matters
 537                   || REG_FUNCTION_VALUE_P (x) == REG_FUNCTION_VALUE_P (y)));
 538
 539     case LABEL_REF:
 540       return XEXP (x, 0) == XEXP (y, 0);
 541
 542     case SYMBOL_REF:
 543       return XSTR (x, 0) == XSTR (y, 0);
 544
 545     case SCRATCH:
 546     case CONST_DOUBLE:
 547     case CONST_INT:
 548     case CONST_VECTOR:
 549       return 0;
 550
 551     default:
 552       break;
 553     }
 554
 555   /* Compare the elements.  If any pair of corresponding elements
 556      fail to match, return 0 for the whole things.  */
 557
 558   fmt = GET_RTX_FORMAT (code);
 559   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
 560     {
 561       switch (fmt[i])
 562         {
 563         case 'w':
 564           if (XWINT (x, i) != XWINT (y, i))
 565             return 0;
 566           break;
 567
 568         case 'n':
 569         case 'i':
 570           if (XINT (x, i) != XINT (y, i))
 571             return 0;
 572           break;
 573
 574         case 'V':
 575         case 'E':
 576           /* Two vectors must have the same length.  */
 577           if (XVECLEN (x, i) != XVECLEN (y, i))
 578             return 0;
 579
 580           /* And the corresponding elements must match.  */
 581           for (j = 0; j < XVECLEN (x, i); j++)
 582             if (rtx_equal_p (XVECEXP (x, i, j), XVECEXP (y, i, j)) == 0)
 583               return 0;
 584           break;
 585
 586         case 'e':
 587           if (rtx_equal_p (XEXP (x, i), XEXP (y, i)) == 0)
 588             return 0;
 589           break;
 590
 591         case 'S':
 592         case 's':
 593           if ((XSTR (x, i) || XSTR (y, i))
 594               && (! XSTR (x, i) || ! XSTR (y, i)
 595                   || strcmp (XSTR (x, i), XSTR (y, i))))
 596             return 0;
 597           break;
 598
 599         case 'u':
 600           /* These are just backpointers, so they don't matter.  */
 601           break;
 602
 603         case '0':
 604         case 't':
 605           break;
 606
 607           /* It is believed that rtx's at this level will never
 608              contain anything but integers and other rtx's,
 609              except for within LABEL_REFs and SYMBOL_REFs.  */
 610         default:
 611           abort ();
 612         }
 613     }
 614   return 1;
 615 }
 616 \f
 617 #if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007)
 618 void
 619 rtl_check_failed_bounds (r, n, file, line, func)
 620     rtx r;
 621     int n;
 622     const char *file;
 623     int line;
 624     const char *func;
 625 {
 626   internal_error
 627     ("RTL check: access of elt %d of `%s' with last elt %d in %s, at %s:%d",
 628      n, GET_RTX_NAME (GET_CODE (r)), GET_RTX_LENGTH (GET_CODE (r)) - 1,
 629      func, trim_filename (file), line);
 630 }
 631
 632 void
 633 rtl_check_failed_type1 (r, n, c1, file, line, func)
 634     rtx r;
 635     int n;
 636     int c1;
 637     const char *file;
 638     int line;
 639     const char *func;
 640 {
 641   internal_error
 642     ("RTL check: expected elt %d type '%c', have '%c' (rtx %s) in %s, at %s:%d",
 643      n, c1, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
 644      func, trim_filename (file), line);
 645 }
 646
 647 void
 648 rtl_check_failed_type2 (r, n, c1, c2, file, line, func)
 649     rtx r;
 650     int n;
 651     int c1;
 652     int c2;
 653     const char *file;
 654     int line;
 655     const char *func;
 656 {
 657   internal_error
 658     ("RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s) in %s, at %s:%d",
 659      n, c1, c2, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
 660      func, trim_filename (file), line);
 661 }
 662
 663 void
 664 rtl_check_failed_code1 (r, code, file, line, func)
 665     rtx r;
 666     enum rtx_code code;
 667     const char *file;
 668     int line;
 669     const char *func;
 670 {
 671   internal_error ("RTL check: expected code `%s', have `%s' in %s, at %s:%d",
 672                   GET_RTX_NAME (code), GET_RTX_NAME (GET_CODE (r)), func,
 673                   trim_filename (file), line);
 674 }
 675
 676 void
 677 rtl_check_failed_code2 (r, code1, code2, file, line, func)
 678     rtx r;
 679     enum rtx_code code1, code2;
 680     const char *file;
 681     int line;
 682     const char *func;
 683 {
 684   internal_error
 685     ("RTL check: expected code `%s' or `%s', have `%s' in %s, at %s:%d",
 686      GET_RTX_NAME (code1), GET_RTX_NAME (code2), GET_RTX_NAME (GET_CODE (r)),
 687      func, trim_filename (file), line);
 688 }
 689
 690 /* XXX Maybe print the vector?  */
 691 void
 692 rtvec_check_failed_bounds (r, n, file, line, func)
 693     rtvec r;
 694     int n;
 695     const char *file;
 696     int line;
 697     const char *func;
 698 {
 699   internal_error
 700     ("RTL check: access of elt %d of vector with last elt %d in %s, at %s:%d",
 701      n, GET_NUM_ELEM (r) - 1, func, trim_filename (file), line);
 702 }
 703 #endif /* ENABLE_RTL_CHECKING */