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