gcc/rtl.c

   1 /* RTL utility routines.
   2    Copyright (C) 1987, 1988, 1991, 1994, 1997, 1998, 1999, 2000, 2001, 2002,
   3    2003, 2004, 2005, 2006, 2007, 2008, 2009 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 3, 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 COPYING3.  If not see
  19 <http://www.gnu.org/licenses/>.  */
  20
  21 /* This file is compiled twice: once for the generator programs
  22    once for the compiler.  */
  23 #ifdef GENERATOR_FILE
  24 #include "bconfig.h"
  25 #else
  26 #include "config.h"
  27 #endif
  28
  29 #include "system.h"
  30 #include "coretypes.h"
  31 #include "tm.h"
  32 #include "rtl.h"
  33 #include "real.h"
  34 #include "ggc.h"
  35 #ifdef GENERATOR_FILE
  36 # include "errors.h"
  37 #else
  38 # include "toplev.h"
  39 #endif
  40
  41 \f
  42 /* Indexed by rtx code, gives number of operands for an rtx with that code.
  43    Does NOT include rtx header data (code and links).  */
  44
  45 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS)   sizeof FORMAT - 1 ,
  46
  47 const unsigned char rtx_length[NUM_RTX_CODE] = {
  48 #include "rtl.def"
  49 };
  50
  51 #undef DEF_RTL_EXPR
  52
  53 /* Indexed by rtx code, gives the name of that kind of rtx, as a C string.  */
  54
  55 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS)   NAME ,
  56
  57 const char * const rtx_name[NUM_RTX_CODE] = {
  58 #include "rtl.def"              /* rtl expressions are documented here */
  59 };
  60
  61 #undef DEF_RTL_EXPR
  62
  63 /* Indexed by rtx code, gives a sequence of operand-types for
  64    rtx's of that code.  The sequence is a C string in which
  65    each character describes one operand.  */
  66
  67 const char * const rtx_format[NUM_RTX_CODE] = {
  68   /* "*" undefined.
  69          can cause a warning message
  70      "0" field is unused (or used in a phase-dependent manner)
  71          prints nothing
  72      "i" an integer
  73          prints the integer
  74      "n" like "i", but prints entries from `note_insn_name'
  75      "w" an integer of width HOST_BITS_PER_WIDE_INT
  76          prints the integer
  77      "s" a pointer to a string
  78          prints the string
  79      "S" like "s", but optional:
  80          the containing rtx may end before this operand
  81      "T" like "s", but treated specially by the RTL reader;
  82          only found in machine description patterns.
  83      "e" a pointer to an rtl expression
  84          prints the expression
  85      "E" a pointer to a vector that points to a number of rtl expressions
  86          prints a list of the rtl expressions
  87      "V" like "E", but optional:
  88          the containing rtx may end before this operand
  89      "u" a pointer to another insn
  90          prints the uid of the insn.
  91      "b" is a pointer to a bitmap header.
  92      "B" is a basic block pointer.
  93      "t" is a tree pointer.  */
  94
  95 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS)   FORMAT ,
  96 #include "rtl.def"              /* rtl expressions are defined here */
  97 #undef DEF_RTL_EXPR
  98 };
  99
 100 /* Indexed by rtx code, gives a character representing the "class" of
 101    that rtx code.  See rtl.def for documentation on the defined classes.  */
 102
 103 const enum rtx_class rtx_class[NUM_RTX_CODE] = {
 104 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS)   CLASS,
 105 #include "rtl.def"              /* rtl expressions are defined here */
 106 #undef DEF_RTL_EXPR
 107 };
 108
 109 /* Indexed by rtx code, gives the size of the rtx in bytes.  */
 110
 111 const unsigned char rtx_code_size[NUM_RTX_CODE] = {
 112 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS)                         \
 113   ((ENUM) == CONST_INT || (ENUM) == CONST_DOUBLE || (ENUM) == CONST_FIXED\
 114    ? RTX_HDR_SIZE + (sizeof FORMAT - 1) * sizeof (HOST_WIDE_INT)        \
 115    : RTX_HDR_SIZE + (sizeof FORMAT - 1) * sizeof (rtunion)),
 116
 117 #include "rtl.def"
 118 #undef DEF_RTL_EXPR
 119 };
 120
 121 /* Names for kinds of NOTEs and REG_NOTEs.  */
 122
 123 const char * const note_insn_name[NOTE_INSN_MAX] =
 124 {
 125 #define DEF_INSN_NOTE(NAME) #NAME,
 126 #include "insn-notes.def"
 127 #undef DEF_INSN_NOTE
 128 };
 129
 130 const char * const reg_note_name[REG_NOTE_MAX] =
 131 {
 132 #define DEF_REG_NOTE(NAME) #NAME,
 133 #include "reg-notes.def"
 134 #undef DEF_REG_NOTE
 135 };
 136
 137 #ifdef GATHER_STATISTICS
 138 static int rtx_alloc_counts[(int) LAST_AND_UNUSED_RTX_CODE];
 139 static int rtx_alloc_sizes[(int) LAST_AND_UNUSED_RTX_CODE];
 140 static int rtvec_alloc_counts;
 141 static int rtvec_alloc_sizes;
 142 #endif
 143
 144 \f
 145 /* Allocate an rtx vector of N elements.
 146    Store the length, and initialize all elements to zero.  */
 147
 148 rtvec
 149 rtvec_alloc (int n)
 150 {
 151   rtvec rt;
 152
 153   rt = ggc_alloc_rtvec (n);
 154   /* Clear out the vector.  */
 155   memset (&rt->elem[0], 0, n * sizeof (rtx));
 156
 157   PUT_NUM_ELEM (rt, n);
 158
 159 #ifdef GATHER_STATISTICS
 160   rtvec_alloc_counts++;
 161   rtvec_alloc_sizes += n * sizeof (rtx);
 162 #endif
 163
 164   return rt;
 165 }
 166
 167 /* Return the number of bytes occupied by rtx value X.  */
 168
 169 unsigned int
 170 rtx_size (const_rtx x)
 171 {
 172   if (GET_CODE (x) == SYMBOL_REF && SYMBOL_REF_HAS_BLOCK_INFO_P (x))
 173     return RTX_HDR_SIZE + sizeof (struct block_symbol);
 174   return RTX_CODE_SIZE (GET_CODE (x));
 175 }
 176
 177 /* Allocate an rtx of code CODE.  The CODE is stored in the rtx;
 178    all the rest is initialized to zero.  */
 179
 180 rtx
 181 rtx_alloc_stat (RTX_CODE code MEM_STAT_DECL)
 182 {
 183   rtx rt;
 184
 185   rt = (rtx) ggc_alloc_zone_pass_stat (RTX_CODE_SIZE (code), &rtl_zone);
 186
 187   /* We want to clear everything up to the FLD array.  Normally, this
 188      is one int, but we don't want to assume that and it isn't very
 189      portable anyway; this is.  */
 190
 191   memset (rt, 0, RTX_HDR_SIZE);
 192   PUT_CODE (rt, code);
 193
 194 #ifdef GATHER_STATISTICS
 195   rtx_alloc_counts[code]++;
 196   rtx_alloc_sizes[code] += RTX_CODE_SIZE (code);
 197 #endif
 198
 199   return rt;
 200 }
 201
 202 \f
 203 /* Return true if ORIG is a sharable CONST.  */
 204
 205 bool
 206 shared_const_p (const_rtx orig)
 207 {
 208   gcc_assert (GET_CODE (orig) == CONST);
 209
 210   /* CONST can be shared if it contains a SYMBOL_REF.  If it contains
 211      a LABEL_REF, it isn't sharable.  */
 212   return (GET_CODE (XEXP (orig, 0)) == PLUS
 213           && GET_CODE (XEXP (XEXP (orig, 0), 0)) == SYMBOL_REF
 214           && CONST_INT_P(XEXP (XEXP (orig, 0), 1)));
 215 }
 216
 217
 218 /* Create a new copy of an rtx.
 219    Recursively copies the operands of the rtx,
 220    except for those few rtx codes that are sharable.  */
 221
 222 rtx
 223 copy_rtx (rtx orig)
 224 {
 225   rtx copy;
 226   int i, j;
 227   RTX_CODE code;
 228   const char *format_ptr;
 229
 230   code = GET_CODE (orig);
 231
 232   switch (code)
 233     {
 234     case REG:
 235     case CONST_INT:
 236     case CONST_DOUBLE:
 237     case CONST_FIXED:
 238     case CONST_VECTOR:
 239     case SYMBOL_REF:
 240     case CODE_LABEL:
 241     case PC:
 242     case CC0:
 243     case SCRATCH:
 244       /* SCRATCH must be shared because they represent distinct values.  */
 245       return orig;
 246     case CLOBBER:
 247       if (REG_P (XEXP (orig, 0)) && REGNO (XEXP (orig, 0)) < FIRST_PSEUDO_REGISTER)
 248         return orig;
 249       break;
 250
 251     case CONST:
 252       if (shared_const_p (orig))
 253         return orig;
 254       break;
 255
 256       /* A MEM with a constant address is not sharable.  The problem is that
 257          the constant address may need to be reloaded.  If the mem is shared,
 258          then reloading one copy of this mem will cause all copies to appear
 259          to have been reloaded.  */
 260
 261     default:
 262       break;
 263     }
 264
 265   /* Copy the various flags, fields, and other information.  We assume
 266      that all fields need copying, and then clear the fields that should
 267      not be copied.  That is the sensible default behavior, and forces
 268      us to explicitly document why we are *not* copying a flag.  */
 269   copy = shallow_copy_rtx (orig);
 270
 271   /* We do not copy the USED flag, which is used as a mark bit during
 272      walks over the RTL.  */
 273   RTX_FLAG (copy, used) = 0;
 274
 275   /* We do not copy FRAME_RELATED for INSNs.  */
 276   if (INSN_P (orig))
 277     RTX_FLAG (copy, frame_related) = 0;
 278   RTX_FLAG (copy, jump) = RTX_FLAG (orig, jump);
 279   RTX_FLAG (copy, call) = RTX_FLAG (orig, call);
 280
 281   format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
 282
 283   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
 284     switch (*format_ptr++)
 285       {
 286       case 'e':
 287         if (XEXP (orig, i) != NULL)
 288           XEXP (copy, i) = copy_rtx (XEXP (orig, i));
 289         break;
 290
 291       case 'E':
 292       case 'V':
 293         if (XVEC (orig, i) != NULL)
 294           {
 295             XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
 296             for (j = 0; j < XVECLEN (copy, i); j++)
 297               XVECEXP (copy, i, j) = copy_rtx (XVECEXP (orig, i, j));
 298           }
 299         break;
 300
 301       case 't':
 302       case 'w':
 303       case 'i':
 304       case 's':
 305       case 'S':
 306       case 'T':
 307       case 'u':
 308       case 'B':
 309       case '0':
 310         /* These are left unchanged.  */
 311         break;
 312
 313       default:
 314         gcc_unreachable ();
 315       }
 316   return copy;
 317 }
 318
 319 /* Create a new copy of an rtx.  Only copy just one level.  */
 320
 321 rtx
 322 shallow_copy_rtx_stat (const_rtx orig MEM_STAT_DECL)
 323 {
 324   const unsigned int size = rtx_size (orig);
 325   rtx const copy = (rtx) ggc_alloc_zone_pass_stat (size, &rtl_zone);
 326   return (rtx) memcpy (copy, orig, size);
 327 }
 328 \f
 329 /* Nonzero when we are generating CONCATs.  */
 330 int generating_concat_p;
 331
 332 /* Nonzero when we are expanding trees to RTL.  */
 333 int currently_expanding_to_rtl;
 334
 335 \f
 336
 337 /* Same as rtx_equal_p, but call CB on each pair of rtx if CB is not NULL.
 338    When the callback returns true, we continue with the new pair.
 339    Whenever changing this function check if rtx_equal_p below doesn't need
 340    changing as well.  */
 341
 342 int
 343 rtx_equal_p_cb (const_rtx x, const_rtx y, rtx_equal_p_callback_function cb)
 344 {
 345   int i;
 346   int j;
 347   enum rtx_code code;
 348   const char *fmt;
 349   rtx nx, ny;
 350
 351   if (x == y)
 352     return 1;
 353   if (x == 0 || y == 0)
 354     return 0;
 355
 356   /* Invoke the callback first.  */
 357   if (cb != NULL
 358       && ((*cb) (&x, &y, &nx, &ny)))
 359     return rtx_equal_p_cb (nx, ny, cb);
 360
 361   code = GET_CODE (x);
 362   /* Rtx's of different codes cannot be equal.  */
 363   if (code != GET_CODE (y))
 364     return 0;
 365
 366   /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
 367      (REG:SI x) and (REG:HI x) are NOT equivalent.  */
 368
 369   if (GET_MODE (x) != GET_MODE (y))
 370     return 0;
 371
 372   /* Some RTL can be compared nonrecursively.  */
 373   switch (code)
 374     {
 375     case REG:
 376       return (REGNO (x) == REGNO (y));
 377
 378     case LABEL_REF:
 379       return XEXP (x, 0) == XEXP (y, 0);
 380
 381     case SYMBOL_REF:
 382       return XSTR (x, 0) == XSTR (y, 0);
 383
 384     case VALUE:
 385     case SCRATCH:
 386     case CONST_DOUBLE:
 387     case CONST_INT:
 388     case CONST_FIXED:
 389       return 0;
 390
 391     default:
 392       break;
 393     }
 394
 395   /* Compare the elements.  If any pair of corresponding elements
 396      fail to match, return 0 for the whole thing.  */
 397
 398   fmt = GET_RTX_FORMAT (code);
 399   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
 400     {
 401       switch (fmt[i])
 402         {
 403         case 'w':
 404           if (XWINT (x, i) != XWINT (y, i))
 405             return 0;
 406           break;
 407
 408         case 'n':
 409         case 'i':
 410           if (XINT (x, i) != XINT (y, i))
 411             return 0;
 412           break;
 413
 414         case 'V':
 415         case 'E':
 416           /* Two vectors must have the same length.  */
 417           if (XVECLEN (x, i) != XVECLEN (y, i))
 418             return 0;
 419
 420           /* And the corresponding elements must match.  */
 421           for (j = 0; j < XVECLEN (x, i); j++)
 422             if (rtx_equal_p_cb (XVECEXP (x, i, j),
 423                                 XVECEXP (y, i, j), cb) == 0)
 424               return 0;
 425           break;
 426
 427         case 'e':
 428           if (rtx_equal_p_cb (XEXP (x, i), XEXP (y, i), cb) == 0)
 429             return 0;
 430           break;
 431
 432         case 'S':
 433         case 's':
 434           if ((XSTR (x, i) || XSTR (y, i))
 435               && (! XSTR (x, i) || ! XSTR (y, i)
 436                   || strcmp (XSTR (x, i), XSTR (y, i))))
 437             return 0;
 438           break;
 439
 440         case 'u':
 441           /* These are just backpointers, so they don't matter.  */
 442           break;
 443
 444         case '0':
 445         case 't':
 446           break;
 447
 448           /* It is believed that rtx's at this level will never
 449              contain anything but integers and other rtx's,
 450              except for within LABEL_REFs and SYMBOL_REFs.  */
 451         default:
 452           gcc_unreachable ();
 453         }
 454     }
 455   return 1;
 456 }
 457
 458 /* Return 1 if X and Y are identical-looking rtx's.
 459    This is the Lisp function EQUAL for rtx arguments.
 460    Whenever changing this function check if rtx_equal_p_cb above doesn't need
 461    changing as well.  */
 462
 463 int
 464 rtx_equal_p (const_rtx x, const_rtx y)
 465 {
 466   int i;
 467   int j;
 468   enum rtx_code code;
 469   const char *fmt;
 470
 471   if (x == y)
 472     return 1;
 473   if (x == 0 || y == 0)
 474     return 0;
 475
 476   code = GET_CODE (x);
 477   /* Rtx's of different codes cannot be equal.  */
 478   if (code != GET_CODE (y))
 479     return 0;
 480
 481   /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
 482      (REG:SI x) and (REG:HI x) are NOT equivalent.  */
 483
 484   if (GET_MODE (x) != GET_MODE (y))
 485     return 0;
 486
 487   /* Some RTL can be compared nonrecursively.  */
 488   switch (code)
 489     {
 490     case REG:
 491       return (REGNO (x) == REGNO (y));
 492
 493     case LABEL_REF:
 494       return XEXP (x, 0) == XEXP (y, 0);
 495
 496     case SYMBOL_REF:
 497       return XSTR (x, 0) == XSTR (y, 0);
 498
 499     case VALUE:
 500     case SCRATCH:
 501     case CONST_DOUBLE:
 502     case CONST_INT:
 503     case CONST_FIXED:
 504       return 0;
 505
 506     default:
 507       break;
 508     }
 509
 510   /* Compare the elements.  If any pair of corresponding elements
 511      fail to match, return 0 for the whole thing.  */
 512
 513   fmt = GET_RTX_FORMAT (code);
 514   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
 515     {
 516       switch (fmt[i])
 517         {
 518         case 'w':
 519           if (XWINT (x, i) != XWINT (y, i))
 520             return 0;
 521           break;
 522
 523         case 'n':
 524         case 'i':
 525           if (XINT (x, i) != XINT (y, i))
 526             return 0;
 527           break;
 528
 529         case 'V':
 530         case 'E':
 531           /* Two vectors must have the same length.  */
 532           if (XVECLEN (x, i) != XVECLEN (y, i))
 533             return 0;
 534
 535           /* And the corresponding elements must match.  */
 536           for (j = 0; j < XVECLEN (x, i); j++)
 537             if (rtx_equal_p (XVECEXP (x, i, j),  XVECEXP (y, i, j)) == 0)
 538               return 0;
 539           break;
 540
 541         case 'e':
 542           if (rtx_equal_p (XEXP (x, i), XEXP (y, i)) == 0)
 543             return 0;
 544           break;
 545
 546         case 'S':
 547         case 's':
 548           if ((XSTR (x, i) || XSTR (y, i))
 549               && (! XSTR (x, i) || ! XSTR (y, i)
 550                   || strcmp (XSTR (x, i), XSTR (y, i))))
 551             return 0;
 552           break;
 553
 554         case 'u':
 555           /* These are just backpointers, so they don't matter.  */
 556           break;
 557
 558         case '0':
 559         case 't':
 560           break;
 561
 562           /* It is believed that rtx's at this level will never
 563              contain anything but integers and other rtx's,
 564              except for within LABEL_REFs and SYMBOL_REFs.  */
 565         default:
 566           gcc_unreachable ();
 567         }
 568     }
 569   return 1;
 570 }
 571
 572 void
 573 dump_rtx_statistics (void)
 574 {
 575 #ifdef GATHER_STATISTICS
 576   int i;
 577   int total_counts = 0;
 578   int total_sizes = 0;
 579   fprintf (stderr, "\nRTX Kind               Count      Bytes\n");
 580   fprintf (stderr, "---------------------------------------\n");
 581   for (i = 0; i < LAST_AND_UNUSED_RTX_CODE; i++)
 582     if (rtx_alloc_counts[i])
 583       {
 584         fprintf (stderr, "%-20s %7d %10d\n", GET_RTX_NAME (i),
 585                  rtx_alloc_counts[i], rtx_alloc_sizes[i]);
 586         total_counts += rtx_alloc_counts[i];
 587         total_sizes += rtx_alloc_sizes[i];
 588       }
 589   if (rtvec_alloc_counts)
 590     {
 591       fprintf (stderr, "%-20s %7d %10d\n", "rtvec",
 592                rtvec_alloc_counts, rtvec_alloc_sizes);
 593       total_counts += rtvec_alloc_counts;
 594       total_sizes += rtvec_alloc_sizes;
 595     }
 596   fprintf (stderr, "---------------------------------------\n");
 597   fprintf (stderr, "%-20s %7d %10d\n",
 598            "Total", total_counts, total_sizes);
 599   fprintf (stderr, "---------------------------------------\n");
 600 #endif
 601 }
 602 \f
 603 #if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007)
 604 void
 605 rtl_check_failed_bounds (const_rtx r, int n, const char *file, int line,
 606                          const char *func)
 607 {
 608   internal_error
 609     ("RTL check: access of elt %d of '%s' with last elt %d in %s, at %s:%d",
 610      n, GET_RTX_NAME (GET_CODE (r)), GET_RTX_LENGTH (GET_CODE (r)) - 1,
 611      func, trim_filename (file), line);
 612 }
 613
 614 void
 615 rtl_check_failed_type1 (const_rtx r, int n, int c1, const char *file, int line,
 616                         const char *func)
 617 {
 618   internal_error
 619     ("RTL check: expected elt %d type '%c', have '%c' (rtx %s) in %s, at %s:%d",
 620      n, c1, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
 621      func, trim_filename (file), line);
 622 }
 623
 624 void
 625 rtl_check_failed_type2 (const_rtx r, int n, int c1, int c2, const char *file,
 626                         int line, const char *func)
 627 {
 628   internal_error
 629     ("RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s) in %s, at %s:%d",
 630      n, c1, c2, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
 631      func, trim_filename (file), line);
 632 }
 633
 634 void
 635 rtl_check_failed_code1 (const_rtx r, enum rtx_code code, const char *file,
 636                         int line, const char *func)
 637 {
 638   internal_error ("RTL check: expected code '%s', have '%s' in %s, at %s:%d",
 639                   GET_RTX_NAME (code), GET_RTX_NAME (GET_CODE (r)), func,
 640                   trim_filename (file), line);
 641 }
 642
 643 void
 644 rtl_check_failed_code2 (const_rtx r, enum rtx_code code1, enum rtx_code code2,
 645                         const char *file, int line, const char *func)
 646 {
 647   internal_error
 648     ("RTL check: expected code '%s' or '%s', have '%s' in %s, at %s:%d",
 649      GET_RTX_NAME (code1), GET_RTX_NAME (code2), GET_RTX_NAME (GET_CODE (r)),
 650      func, trim_filename (file), line);
 651 }
 652
 653 void
 654 rtl_check_failed_code_mode (const_rtx r, enum rtx_code code, enum machine_mode mode,
 655                             bool not_mode, const char *file, int line,
 656                             const char *func)
 657 {
 658   internal_error ((not_mode
 659                    ? ("RTL check: expected code '%s' and not mode '%s', "
 660                       "have code '%s' and mode '%s' in %s, at %s:%d")
 661                    : ("RTL check: expected code '%s' and mode '%s', "
 662                       "have code '%s' and mode '%s' in %s, at %s:%d")),
 663                   GET_RTX_NAME (code), GET_MODE_NAME (mode),
 664                   GET_RTX_NAME (GET_CODE (r)), GET_MODE_NAME (GET_MODE (r)),
 665                   func, trim_filename (file), line);
 666 }
 667
 668 /* Report that line LINE of FILE tried to access the block symbol fields
 669    of a non-block symbol.  FUNC is the function that contains the line.  */
 670
 671 void
 672 rtl_check_failed_block_symbol (const char *file, int line, const char *func)
 673 {
 674   internal_error
 675     ("RTL check: attempt to treat non-block symbol as a block symbol "
 676      "in %s, at %s:%d", func, trim_filename (file), line);
 677 }
 678
 679 /* XXX Maybe print the vector?  */
 680 void
 681 rtvec_check_failed_bounds (const_rtvec r, int n, const char *file, int line,
 682                            const char *func)
 683 {
 684   internal_error
 685     ("RTL check: access of elt %d of vector with last elt %d in %s, at %s:%d",
 686      n, GET_NUM_ELEM (r) - 1, func, trim_filename (file), line);
 687 }
 688 #endif /* ENABLE_RTL_CHECKING */
 689
 690 #if defined ENABLE_RTL_FLAG_CHECKING
 691 void
 692 rtl_check_failed_flag (const char *name, const_rtx r, const char *file,
 693                        int line, const char *func)
 694 {
 695   internal_error
 696     ("RTL flag check: %s used with unexpected rtx code '%s' in %s, at %s:%d",
 697      name, GET_RTX_NAME (GET_CODE (r)), func, trim_filename (file), line);
 698 }
 699 #endif /* ENABLE_RTL_FLAG_CHECKING */