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