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