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 "diagnostic-core.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_sized (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 = ggc_alloc_zone_rtx_def_stat (&rtl_zone, RTX_CODE_SIZE (code)
 197                                         PASS_MEM_STAT);
 198
 199   /* We want to clear everything up to the FLD array.  Normally, this
 200      is one int, but we don't want to assume that and it isn't very
 201      portable anyway; this is.  */
 202
 203   memset (rt, 0, RTX_HDR_SIZE);
 204   PUT_CODE (rt, code);
 205
 206 #ifdef GATHER_STATISTICS
 207   rtx_alloc_counts[code]++;
 208   rtx_alloc_sizes[code] += RTX_CODE_SIZE (code);
 209 #endif
 210
 211   return rt;
 212 }
 213
 214 \f
 215 /* Return true if ORIG is a sharable CONST.  */
 216
 217 bool
 218 shared_const_p (const_rtx orig)
 219 {
 220   gcc_assert (GET_CODE (orig) == CONST);
 221
 222   /* CONST can be shared if it contains a SYMBOL_REF.  If it contains
 223      a LABEL_REF, it isn't sharable.  */
 224   return (GET_CODE (XEXP (orig, 0)) == PLUS
 225           && GET_CODE (XEXP (XEXP (orig, 0), 0)) == SYMBOL_REF
 226           && CONST_INT_P(XEXP (XEXP (orig, 0), 1)));
 227 }
 228
 229
 230 /* Create a new copy of an rtx.
 231    Recursively copies the operands of the rtx,
 232    except for those few rtx codes that are sharable.  */
 233
 234 rtx
 235 copy_rtx (rtx orig)
 236 {
 237   rtx copy;
 238   int i, j;
 239   RTX_CODE code;
 240   const char *format_ptr;
 241
 242   code = GET_CODE (orig);
 243
 244   switch (code)
 245     {
 246     case REG:
 247     case DEBUG_EXPR:
 248     case VALUE:
 249     case CONST_INT:
 250     case CONST_DOUBLE:
 251     case CONST_FIXED:
 252     case CONST_VECTOR:
 253     case SYMBOL_REF:
 254     case CODE_LABEL:
 255     case PC:
 256     case CC0:
 257     case SCRATCH:
 258       /* SCRATCH must be shared because they represent distinct values.  */
 259       return orig;
 260     case CLOBBER:
 261       if (REG_P (XEXP (orig, 0)) && REGNO (XEXP (orig, 0)) < FIRST_PSEUDO_REGISTER)
 262         return orig;
 263       break;
 264
 265     case CONST:
 266       if (shared_const_p (orig))
 267         return orig;
 268       break;
 269
 270       /* A MEM with a constant address is not sharable.  The problem is that
 271          the constant address may need to be reloaded.  If the mem is shared,
 272          then reloading one copy of this mem will cause all copies to appear
 273          to have been reloaded.  */
 274
 275     default:
 276       break;
 277     }
 278
 279   /* Copy the various flags, fields, and other information.  We assume
 280      that all fields need copying, and then clear the fields that should
 281      not be copied.  That is the sensible default behavior, and forces
 282      us to explicitly document why we are *not* copying a flag.  */
 283   copy = shallow_copy_rtx (orig);
 284
 285   /* We do not copy the USED flag, which is used as a mark bit during
 286      walks over the RTL.  */
 287   RTX_FLAG (copy, used) = 0;
 288
 289   /* We do not copy FRAME_RELATED for INSNs.  */
 290   if (INSN_P (orig))
 291     RTX_FLAG (copy, frame_related) = 0;
 292   RTX_FLAG (copy, jump) = RTX_FLAG (orig, jump);
 293   RTX_FLAG (copy, call) = RTX_FLAG (orig, call);
 294
 295   format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
 296
 297   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
 298     switch (*format_ptr++)
 299       {
 300       case 'e':
 301         if (XEXP (orig, i) != NULL)
 302           XEXP (copy, i) = copy_rtx (XEXP (orig, i));
 303         break;
 304
 305       case 'E':
 306       case 'V':
 307         if (XVEC (orig, i) != NULL)
 308           {
 309             XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
 310             for (j = 0; j < XVECLEN (copy, i); j++)
 311               XVECEXP (copy, i, j) = copy_rtx (XVECEXP (orig, i, j));
 312           }
 313         break;
 314
 315       case 't':
 316       case 'w':
 317       case 'i':
 318       case 's':
 319       case 'S':
 320       case 'T':
 321       case 'u':
 322       case 'B':
 323       case '0':
 324         /* These are left unchanged.  */
 325         break;
 326
 327       default:
 328         gcc_unreachable ();
 329       }
 330   return copy;
 331 }
 332
 333 /* Create a new copy of an rtx.  Only copy just one level.  */
 334
 335 rtx
 336 shallow_copy_rtx_stat (const_rtx orig MEM_STAT_DECL)
 337 {
 338   const unsigned int size = rtx_size (orig);
 339   rtx const copy = ggc_alloc_zone_rtx_def_stat (&rtl_zone, size PASS_MEM_STAT);
 340   return (rtx) memcpy (copy, orig, size);
 341 }
 342 \f
 343 /* Nonzero when we are generating CONCATs.  */
 344 int generating_concat_p;
 345
 346 /* Nonzero when we are expanding trees to RTL.  */
 347 int currently_expanding_to_rtl;
 348
 349 \f
 350
 351 /* Same as rtx_equal_p, but call CB on each pair of rtx if CB is not NULL.
 352    When the callback returns true, we continue with the new pair.
 353    Whenever changing this function check if rtx_equal_p below doesn't need
 354    changing as well.  */
 355
 356 int
 357 rtx_equal_p_cb (const_rtx x, const_rtx y, rtx_equal_p_callback_function cb)
 358 {
 359   int i;
 360   int j;
 361   enum rtx_code code;
 362   const char *fmt;
 363   rtx nx, ny;
 364
 365   if (x == y)
 366     return 1;
 367   if (x == 0 || y == 0)
 368     return 0;
 369
 370   /* Invoke the callback first.  */
 371   if (cb != NULL
 372       && ((*cb) (&x, &y, &nx, &ny)))
 373     return rtx_equal_p_cb (nx, ny, cb);
 374
 375   code = GET_CODE (x);
 376   /* Rtx's of different codes cannot be equal.  */
 377   if (code != GET_CODE (y))
 378     return 0;
 379
 380   /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
 381      (REG:SI x) and (REG:HI x) are NOT equivalent.  */
 382
 383   if (GET_MODE (x) != GET_MODE (y))
 384     return 0;
 385
 386   /* MEMs refering to different address space are not equivalent.  */
 387   if (code == MEM && MEM_ADDR_SPACE (x) != MEM_ADDR_SPACE (y))
 388     return 0;
 389
 390   /* Some RTL can be compared nonrecursively.  */
 391   switch (code)
 392     {
 393     case REG:
 394       return (REGNO (x) == REGNO (y));
 395
 396     case LABEL_REF:
 397       return XEXP (x, 0) == XEXP (y, 0);
 398
 399     case SYMBOL_REF:
 400       return XSTR (x, 0) == XSTR (y, 0);
 401
 402     case DEBUG_EXPR:
 403     case VALUE:
 404     case SCRATCH:
 405     case CONST_DOUBLE:
 406     case CONST_INT:
 407     case CONST_FIXED:
 408       return 0;
 409
 410     default:
 411       break;
 412     }
 413
 414   /* Compare the elements.  If any pair of corresponding elements
 415      fail to match, return 0 for the whole thing.  */
 416
 417   fmt = GET_RTX_FORMAT (code);
 418   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
 419     {
 420       switch (fmt[i])
 421         {
 422         case 'w':
 423           if (XWINT (x, i) != XWINT (y, i))
 424             return 0;
 425           break;
 426
 427         case 'n':
 428         case 'i':
 429           if (XINT (x, i) != XINT (y, i))
 430             return 0;
 431           break;
 432
 433         case 'V':
 434         case 'E':
 435           /* Two vectors must have the same length.  */
 436           if (XVECLEN (x, i) != XVECLEN (y, i))
 437             return 0;
 438
 439           /* And the corresponding elements must match.  */
 440           for (j = 0; j < XVECLEN (x, i); j++)
 441             if (rtx_equal_p_cb (XVECEXP (x, i, j),
 442                                 XVECEXP (y, i, j), cb) == 0)
 443               return 0;
 444           break;
 445
 446         case 'e':
 447           if (rtx_equal_p_cb (XEXP (x, i), XEXP (y, i), cb) == 0)
 448             return 0;
 449           break;
 450
 451         case 'S':
 452         case 's':
 453           if ((XSTR (x, i) || XSTR (y, i))
 454               && (! XSTR (x, i) || ! XSTR (y, i)
 455                   || strcmp (XSTR (x, i), XSTR (y, i))))
 456             return 0;
 457           break;
 458
 459         case 'u':
 460           /* These are just backpointers, so they don't matter.  */
 461           break;
 462
 463         case '0':
 464         case 't':
 465           break;
 466
 467           /* It is believed that rtx's at this level will never
 468              contain anything but integers and other rtx's,
 469              except for within LABEL_REFs and SYMBOL_REFs.  */
 470         default:
 471           gcc_unreachable ();
 472         }
 473     }
 474   return 1;
 475 }
 476
 477 /* Return 1 if X and Y are identical-looking rtx's.
 478    This is the Lisp function EQUAL for rtx arguments.
 479    Whenever changing this function check if rtx_equal_p_cb above doesn't need
 480    changing as well.  */
 481
 482 int
 483 rtx_equal_p (const_rtx x, const_rtx y)
 484 {
 485   int i;
 486   int j;
 487   enum rtx_code code;
 488   const char *fmt;
 489
 490   if (x == y)
 491     return 1;
 492   if (x == 0 || y == 0)
 493     return 0;
 494
 495   code = GET_CODE (x);
 496   /* Rtx's of different codes cannot be equal.  */
 497   if (code != GET_CODE (y))
 498     return 0;
 499
 500   /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
 501      (REG:SI x) and (REG:HI x) are NOT equivalent.  */
 502
 503   if (GET_MODE (x) != GET_MODE (y))
 504     return 0;
 505
 506   /* MEMs refering to different address space are not equivalent.  */
 507   if (code == MEM && MEM_ADDR_SPACE (x) != MEM_ADDR_SPACE (y))
 508     return 0;
 509
 510   /* Some RTL can be compared nonrecursively.  */
 511   switch (code)
 512     {
 513     case REG:
 514       return (REGNO (x) == REGNO (y));
 515
 516     case LABEL_REF:
 517       return XEXP (x, 0) == XEXP (y, 0);
 518
 519     case SYMBOL_REF:
 520       return XSTR (x, 0) == XSTR (y, 0);
 521
 522     case DEBUG_EXPR:
 523     case VALUE:
 524     case SCRATCH:
 525     case CONST_DOUBLE:
 526     case CONST_INT:
 527     case CONST_FIXED:
 528       return 0;
 529
 530     default:
 531       break;
 532     }
 533
 534   /* Compare the elements.  If any pair of corresponding elements
 535      fail to match, return 0 for the whole thing.  */
 536
 537   fmt = GET_RTX_FORMAT (code);
 538   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
 539     {
 540       switch (fmt[i])
 541         {
 542         case 'w':
 543           if (XWINT (x, i) != XWINT (y, i))
 544             return 0;
 545           break;
 546
 547         case 'n':
 548         case 'i':
 549           if (XINT (x, i) != XINT (y, i))
 550             return 0;
 551           break;
 552
 553         case 'V':
 554         case 'E':
 555           /* Two vectors must have the same length.  */
 556           if (XVECLEN (x, i) != XVECLEN (y, i))
 557             return 0;
 558
 559           /* And the corresponding elements must match.  */
 560           for (j = 0; j < XVECLEN (x, i); j++)
 561             if (rtx_equal_p (XVECEXP (x, i, j),  XVECEXP (y, i, j)) == 0)
 562               return 0;
 563           break;
 564
 565         case 'e':
 566           if (rtx_equal_p (XEXP (x, i), XEXP (y, i)) == 0)
 567             return 0;
 568           break;
 569
 570         case 'S':
 571         case 's':
 572           if ((XSTR (x, i) || XSTR (y, i))
 573               && (! XSTR (x, i) || ! XSTR (y, i)
 574                   || strcmp (XSTR (x, i), XSTR (y, i))))
 575             return 0;
 576           break;
 577
 578         case 'u':
 579           /* These are just backpointers, so they don't matter.  */
 580           break;
 581
 582         case '0':
 583         case 't':
 584           break;
 585
 586           /* It is believed that rtx's at this level will never
 587              contain anything but integers and other rtx's,
 588              except for within LABEL_REFs and SYMBOL_REFs.  */
 589         default:
 590           gcc_unreachable ();
 591         }
 592     }
 593   return 1;
 594 }
 595
 596 void
 597 dump_rtx_statistics (void)
 598 {
 599 #ifdef GATHER_STATISTICS
 600   int i;
 601   int total_counts = 0;
 602   int total_sizes = 0;
 603   fprintf (stderr, "\nRTX Kind               Count      Bytes\n");
 604   fprintf (stderr, "---------------------------------------\n");
 605   for (i = 0; i < LAST_AND_UNUSED_RTX_CODE; i++)
 606     if (rtx_alloc_counts[i])
 607       {
 608         fprintf (stderr, "%-20s %7d %10d\n", GET_RTX_NAME (i),
 609                  rtx_alloc_counts[i], rtx_alloc_sizes[i]);
 610         total_counts += rtx_alloc_counts[i];
 611         total_sizes += rtx_alloc_sizes[i];
 612       }
 613   if (rtvec_alloc_counts)
 614     {
 615       fprintf (stderr, "%-20s %7d %10d\n", "rtvec",
 616                rtvec_alloc_counts, rtvec_alloc_sizes);
 617       total_counts += rtvec_alloc_counts;
 618       total_sizes += rtvec_alloc_sizes;
 619     }
 620   fprintf (stderr, "---------------------------------------\n");
 621   fprintf (stderr, "%-20s %7d %10d\n",
 622            "Total", total_counts, total_sizes);
 623   fprintf (stderr, "---------------------------------------\n");
 624 #endif
 625 }
 626 \f
 627 #if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007)
 628 void
 629 rtl_check_failed_bounds (const_rtx r, int n, const char *file, int line,
 630                          const char *func)
 631 {
 632   internal_error
 633     ("RTL check: access of elt %d of '%s' with last elt %d in %s, at %s:%d",
 634      n, GET_RTX_NAME (GET_CODE (r)), GET_RTX_LENGTH (GET_CODE (r)) - 1,
 635      func, trim_filename (file), line);
 636 }
 637
 638 void
 639 rtl_check_failed_type1 (const_rtx r, int n, int c1, const char *file, int line,
 640                         const char *func)
 641 {
 642   internal_error
 643     ("RTL check: expected elt %d type '%c', have '%c' (rtx %s) in %s, at %s:%d",
 644      n, c1, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
 645      func, trim_filename (file), line);
 646 }
 647
 648 void
 649 rtl_check_failed_type2 (const_rtx r, int n, int c1, int c2, const char *file,
 650                         int line, const char *func)
 651 {
 652   internal_error
 653     ("RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s) in %s, at %s:%d",
 654      n, c1, c2, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
 655      func, trim_filename (file), line);
 656 }
 657
 658 void
 659 rtl_check_failed_code1 (const_rtx r, enum rtx_code code, const char *file,
 660                         int line, const char *func)
 661 {
 662   internal_error ("RTL check: expected code '%s', have '%s' in %s, at %s:%d",
 663                   GET_RTX_NAME (code), GET_RTX_NAME (GET_CODE (r)), func,
 664                   trim_filename (file), line);
 665 }
 666
 667 void
 668 rtl_check_failed_code2 (const_rtx r, enum rtx_code code1, enum rtx_code code2,
 669                         const char *file, int line, const char *func)
 670 {
 671   internal_error
 672     ("RTL check: expected code '%s' or '%s', have '%s' in %s, at %s:%d",
 673      GET_RTX_NAME (code1), GET_RTX_NAME (code2), GET_RTX_NAME (GET_CODE (r)),
 674      func, trim_filename (file), line);
 675 }
 676
 677 void
 678 rtl_check_failed_code_mode (const_rtx r, enum rtx_code code, enum machine_mode mode,
 679                             bool not_mode, const char *file, int line,
 680                             const char *func)
 681 {
 682   internal_error ((not_mode
 683                    ? ("RTL check: expected code '%s' and not mode '%s', "
 684                       "have code '%s' and mode '%s' in %s, at %s:%d")
 685                    : ("RTL check: expected code '%s' and mode '%s', "
 686                       "have code '%s' and mode '%s' in %s, at %s:%d")),
 687                   GET_RTX_NAME (code), GET_MODE_NAME (mode),
 688                   GET_RTX_NAME (GET_CODE (r)), GET_MODE_NAME (GET_MODE (r)),
 689                   func, trim_filename (file), line);
 690 }
 691
 692 /* Report that line LINE of FILE tried to access the block symbol fields
 693    of a non-block symbol.  FUNC is the function that contains the line.  */
 694
 695 void
 696 rtl_check_failed_block_symbol (const char *file, int line, const char *func)
 697 {
 698   internal_error
 699     ("RTL check: attempt to treat non-block symbol as a block symbol "
 700      "in %s, at %s:%d", func, trim_filename (file), line);
 701 }
 702
 703 /* XXX Maybe print the vector?  */
 704 void
 705 rtvec_check_failed_bounds (const_rtvec r, int n, const char *file, int line,
 706                            const char *func)
 707 {
 708   internal_error
 709     ("RTL check: access of elt %d of vector with last elt %d in %s, at %s:%d",
 710      n, GET_NUM_ELEM (r) - 1, func, trim_filename (file), line);
 711 }
 712 #endif /* ENABLE_RTL_CHECKING */
 713
 714 #if defined ENABLE_RTL_FLAG_CHECKING
 715 void
 716 rtl_check_failed_flag (const char *name, const_rtx r, const char *file,
 717                        int line, const char *func)
 718 {
 719   internal_error
 720     ("RTL flag check: %s used with unexpected rtx code '%s' in %s, at %s:%d",
 721      name, GET_RTX_NAME (GET_CODE (r)), func, trim_filename (file), line);
 722 }
 723 #endif /* ENABLE_RTL_FLAG_CHECKING */