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     case DEBUG_IMPLICIT_PTR:
 411       return DEBUG_IMPLICIT_PTR_DECL (x)
 412              == DEBUG_IMPLICIT_PTR_DECL (y);
 413
 414     default:
 415       break;
 416     }
 417
 418   /* Compare the elements.  If any pair of corresponding elements
 419      fail to match, return 0 for the whole thing.  */
 420
 421   fmt = GET_RTX_FORMAT (code);
 422   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
 423     {
 424       switch (fmt[i])
 425         {
 426         case 'w':
 427           if (XWINT (x, i) != XWINT (y, i))
 428             return 0;
 429           break;
 430
 431         case 'n':
 432         case 'i':
 433           if (XINT (x, i) != XINT (y, i))
 434             return 0;
 435           break;
 436
 437         case 'V':
 438         case 'E':
 439           /* Two vectors must have the same length.  */
 440           if (XVECLEN (x, i) != XVECLEN (y, i))
 441             return 0;
 442
 443           /* And the corresponding elements must match.  */
 444           for (j = 0; j < XVECLEN (x, i); j++)
 445             if (rtx_equal_p_cb (XVECEXP (x, i, j),
 446                                 XVECEXP (y, i, j), cb) == 0)
 447               return 0;
 448           break;
 449
 450         case 'e':
 451           if (rtx_equal_p_cb (XEXP (x, i), XEXP (y, i), cb) == 0)
 452             return 0;
 453           break;
 454
 455         case 'S':
 456         case 's':
 457           if ((XSTR (x, i) || XSTR (y, i))
 458               && (! XSTR (x, i) || ! XSTR (y, i)
 459                   || strcmp (XSTR (x, i), XSTR (y, i))))
 460             return 0;
 461           break;
 462
 463         case 'u':
 464           /* These are just backpointers, so they don't matter.  */
 465           break;
 466
 467         case '0':
 468         case 't':
 469           break;
 470
 471           /* It is believed that rtx's at this level will never
 472              contain anything but integers and other rtx's,
 473              except for within LABEL_REFs and SYMBOL_REFs.  */
 474         default:
 475           gcc_unreachable ();
 476         }
 477     }
 478   return 1;
 479 }
 480
 481 /* Return 1 if X and Y are identical-looking rtx's.
 482    This is the Lisp function EQUAL for rtx arguments.
 483    Whenever changing this function check if rtx_equal_p_cb above doesn't need
 484    changing as well.  */
 485
 486 int
 487 rtx_equal_p (const_rtx x, const_rtx y)
 488 {
 489   int i;
 490   int j;
 491   enum rtx_code code;
 492   const char *fmt;
 493
 494   if (x == y)
 495     return 1;
 496   if (x == 0 || y == 0)
 497     return 0;
 498
 499   code = GET_CODE (x);
 500   /* Rtx's of different codes cannot be equal.  */
 501   if (code != GET_CODE (y))
 502     return 0;
 503
 504   /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
 505      (REG:SI x) and (REG:HI x) are NOT equivalent.  */
 506
 507   if (GET_MODE (x) != GET_MODE (y))
 508     return 0;
 509
 510   /* MEMs refering to different address space are not equivalent.  */
 511   if (code == MEM && MEM_ADDR_SPACE (x) != MEM_ADDR_SPACE (y))
 512     return 0;
 513
 514   /* Some RTL can be compared nonrecursively.  */
 515   switch (code)
 516     {
 517     case REG:
 518       return (REGNO (x) == REGNO (y));
 519
 520     case LABEL_REF:
 521       return XEXP (x, 0) == XEXP (y, 0);
 522
 523     case SYMBOL_REF:
 524       return XSTR (x, 0) == XSTR (y, 0);
 525
 526     case DEBUG_EXPR:
 527     case VALUE:
 528     case SCRATCH:
 529     case CONST_DOUBLE:
 530     case CONST_INT:
 531     case CONST_FIXED:
 532       return 0;
 533
 534     case DEBUG_IMPLICIT_PTR:
 535       return DEBUG_IMPLICIT_PTR_DECL (x)
 536              == DEBUG_IMPLICIT_PTR_DECL (y);
 537
 538     default:
 539       break;
 540     }
 541
 542   /* Compare the elements.  If any pair of corresponding elements
 543      fail to match, return 0 for the whole thing.  */
 544
 545   fmt = GET_RTX_FORMAT (code);
 546   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
 547     {
 548       switch (fmt[i])
 549         {
 550         case 'w':
 551           if (XWINT (x, i) != XWINT (y, i))
 552             return 0;
 553           break;
 554
 555         case 'n':
 556         case 'i':
 557           if (XINT (x, i) != XINT (y, i))
 558             return 0;
 559           break;
 560
 561         case 'V':
 562         case 'E':
 563           /* Two vectors must have the same length.  */
 564           if (XVECLEN (x, i) != XVECLEN (y, i))
 565             return 0;
 566
 567           /* And the corresponding elements must match.  */
 568           for (j = 0; j < XVECLEN (x, i); j++)
 569             if (rtx_equal_p (XVECEXP (x, i, j),  XVECEXP (y, i, j)) == 0)
 570               return 0;
 571           break;
 572
 573         case 'e':
 574           if (rtx_equal_p (XEXP (x, i), XEXP (y, i)) == 0)
 575             return 0;
 576           break;
 577
 578         case 'S':
 579         case 's':
 580           if ((XSTR (x, i) || XSTR (y, i))
 581               && (! XSTR (x, i) || ! XSTR (y, i)
 582                   || strcmp (XSTR (x, i), XSTR (y, i))))
 583             return 0;
 584           break;
 585
 586         case 'u':
 587           /* These are just backpointers, so they don't matter.  */
 588           break;
 589
 590         case '0':
 591         case 't':
 592           break;
 593
 594           /* It is believed that rtx's at this level will never
 595              contain anything but integers and other rtx's,
 596              except for within LABEL_REFs and SYMBOL_REFs.  */
 597         default:
 598           gcc_unreachable ();
 599         }
 600     }
 601   return 1;
 602 }
 603
 604 void
 605 dump_rtx_statistics (void)
 606 {
 607 #ifdef GATHER_STATISTICS
 608   int i;
 609   int total_counts = 0;
 610   int total_sizes = 0;
 611   fprintf (stderr, "\nRTX Kind               Count      Bytes\n");
 612   fprintf (stderr, "---------------------------------------\n");
 613   for (i = 0; i < LAST_AND_UNUSED_RTX_CODE; i++)
 614     if (rtx_alloc_counts[i])
 615       {
 616         fprintf (stderr, "%-20s %7d %10d\n", GET_RTX_NAME (i),
 617                  rtx_alloc_counts[i], rtx_alloc_sizes[i]);
 618         total_counts += rtx_alloc_counts[i];
 619         total_sizes += rtx_alloc_sizes[i];
 620       }
 621   if (rtvec_alloc_counts)
 622     {
 623       fprintf (stderr, "%-20s %7d %10d\n", "rtvec",
 624                rtvec_alloc_counts, rtvec_alloc_sizes);
 625       total_counts += rtvec_alloc_counts;
 626       total_sizes += rtvec_alloc_sizes;
 627     }
 628   fprintf (stderr, "---------------------------------------\n");
 629   fprintf (stderr, "%-20s %7d %10d\n",
 630            "Total", total_counts, total_sizes);
 631   fprintf (stderr, "---------------------------------------\n");
 632 #endif
 633 }
 634 \f
 635 #if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007)
 636 void
 637 rtl_check_failed_bounds (const_rtx r, int n, const char *file, int line,
 638                          const char *func)
 639 {
 640   internal_error
 641     ("RTL check: access of elt %d of '%s' with last elt %d in %s, at %s:%d",
 642      n, GET_RTX_NAME (GET_CODE (r)), GET_RTX_LENGTH (GET_CODE (r)) - 1,
 643      func, trim_filename (file), line);
 644 }
 645
 646 void
 647 rtl_check_failed_type1 (const_rtx r, int n, int c1, const char *file, int line,
 648                         const char *func)
 649 {
 650   internal_error
 651     ("RTL check: expected elt %d type '%c', have '%c' (rtx %s) in %s, at %s:%d",
 652      n, c1, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
 653      func, trim_filename (file), line);
 654 }
 655
 656 void
 657 rtl_check_failed_type2 (const_rtx r, int n, int c1, int c2, const char *file,
 658                         int line, const char *func)
 659 {
 660   internal_error
 661     ("RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s) in %s, at %s:%d",
 662      n, c1, c2, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
 663      func, trim_filename (file), line);
 664 }
 665
 666 void
 667 rtl_check_failed_code1 (const_rtx r, enum rtx_code code, const char *file,
 668                         int line, const char *func)
 669 {
 670   internal_error ("RTL check: expected code '%s', have '%s' in %s, at %s:%d",
 671                   GET_RTX_NAME (code), GET_RTX_NAME (GET_CODE (r)), func,
 672                   trim_filename (file), line);
 673 }
 674
 675 void
 676 rtl_check_failed_code2 (const_rtx r, enum rtx_code code1, enum rtx_code code2,
 677                         const char *file, int line, const char *func)
 678 {
 679   internal_error
 680     ("RTL check: expected code '%s' or '%s', have '%s' in %s, at %s:%d",
 681      GET_RTX_NAME (code1), GET_RTX_NAME (code2), GET_RTX_NAME (GET_CODE (r)),
 682      func, trim_filename (file), line);
 683 }
 684
 685 void
 686 rtl_check_failed_code_mode (const_rtx r, enum rtx_code code, enum machine_mode mode,
 687                             bool not_mode, const char *file, int line,
 688                             const char *func)
 689 {
 690   internal_error ((not_mode
 691                    ? ("RTL check: expected code '%s' and not mode '%s', "
 692                       "have code '%s' and mode '%s' in %s, at %s:%d")
 693                    : ("RTL check: expected code '%s' and mode '%s', "
 694                       "have code '%s' and mode '%s' in %s, at %s:%d")),
 695                   GET_RTX_NAME (code), GET_MODE_NAME (mode),
 696                   GET_RTX_NAME (GET_CODE (r)), GET_MODE_NAME (GET_MODE (r)),
 697                   func, trim_filename (file), line);
 698 }
 699
 700 /* Report that line LINE of FILE tried to access the block symbol fields
 701    of a non-block symbol.  FUNC is the function that contains the line.  */
 702
 703 void
 704 rtl_check_failed_block_symbol (const char *file, int line, const char *func)
 705 {
 706   internal_error
 707     ("RTL check: attempt to treat non-block symbol as a block symbol "
 708      "in %s, at %s:%d", func, trim_filename (file), line);
 709 }
 710
 711 /* XXX Maybe print the vector?  */
 712 void
 713 rtvec_check_failed_bounds (const_rtvec r, int n, const char *file, int line,
 714                            const char *func)
 715 {
 716   internal_error
 717     ("RTL check: access of elt %d of vector with last elt %d in %s, at %s:%d",
 718      n, GET_NUM_ELEM (r) - 1, func, trim_filename (file), line);
 719 }
 720 #endif /* ENABLE_RTL_CHECKING */
 721
 722 #if defined ENABLE_RTL_FLAG_CHECKING
 723 void
 724 rtl_check_failed_flag (const char *name, const_rtx r, const char *file,
 725                        int line, const char *func)
 726 {
 727   internal_error
 728     ("RTL flag check: %s used with unexpected rtx code '%s' in %s, at %s:%d",
 729      name, GET_RTX_NAME (GET_CODE (r)), func, trim_filename (file), line);
 730 }
 731 #endif /* ENABLE_RTL_FLAG_CHECKING */