gcc/rtl.c

   1 /* RTL utility routines.
   2    Copyright (C) 1987-2014 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify it under
   7 the terms of the GNU General Public License as published by the Free
   8 Software Foundation; either version 3, or (at your option) any later
   9 version.
  10
  11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GCC; see the file COPYING3.  If not see
  18 <http://www.gnu.org/licenses/>.  */
  19
  20 /* This file is compiled twice: once for the generator programs
  21    once for the compiler.  */
  22 #ifdef GENERATOR_FILE
  23 #include "bconfig.h"
  24 #else
  25 #include "config.h"
  26 #endif
  27
  28 #include "system.h"
  29 #include "coretypes.h"
  30 #include "tm.h"
  31 #include "ggc.h"
  32 #include "rtl.h"
  33 #ifdef GENERATOR_FILE
  34 # include "errors.h"
  35 #else
  36 # include "rtlhash.h"
  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                       \
 113     || (ENUM) == CONST_FIXED || (ENUM) == CONST_WIDE_INT)               \
 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 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
 142 \f
 143 /* Allocate an rtx vector of N elements.
 144    Store the length, and initialize all elements to zero.  */
 145
 146 rtvec
 147 rtvec_alloc (int n)
 148 {
 149   rtvec rt;
 150
 151   rt = ggc_alloc_rtvec_sized (n);
 152   /* Clear out the vector.  */
 153   memset (&rt->elem[0], 0, n * sizeof (rtx));
 154
 155   PUT_NUM_ELEM (rt, n);
 156
 157   if (GATHER_STATISTICS)
 158     {
 159       rtvec_alloc_counts++;
 160       rtvec_alloc_sizes += n * sizeof (rtx);
 161     }
 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 (CONST_WIDE_INT_P (x))
 186     return (RTX_HDR_SIZE
 187             + sizeof (struct hwivec_def)
 188             + ((CONST_WIDE_INT_NUNITS (x) - 1)
 189                * sizeof (HOST_WIDE_INT)));
 190   if (GET_CODE (x) == SYMBOL_REF && SYMBOL_REF_HAS_BLOCK_INFO_P (x))
 191     return RTX_HDR_SIZE + sizeof (struct block_symbol);
 192   return RTX_CODE_SIZE (GET_CODE (x));
 193 }
 194
 195 /* Allocate an rtx of code CODE with EXTRA bytes in it.  The CODE is
 196    stored in the rtx; all the rest is initialized to zero.  */
 197
 198 rtx
 199 rtx_alloc_stat_v (RTX_CODE code MEM_STAT_DECL, int extra)
 200 {
 201   rtx rt = ggc_alloc_rtx_def_stat (RTX_CODE_SIZE (code) + extra
 202                                    PASS_MEM_STAT);
 203
 204   /* We want to clear everything up to the FLD array.  Normally, this
 205      is one int, but we don't want to assume that and it isn't very
 206      portable anyway; this is.  */
 207
 208   memset (rt, 0, RTX_HDR_SIZE);
 209   PUT_CODE (rt, code);
 210
 211   if (GATHER_STATISTICS)
 212     {
 213       rtx_alloc_counts[code]++;
 214       rtx_alloc_sizes[code] += RTX_CODE_SIZE (code);
 215     }
 216
 217   return rt;
 218 }
 219
 220 /* Allocate an rtx of code CODE.  The CODE is stored in the rtx;
 221    all the rest is initialized to zero.  */
 222
 223 rtx
 224 rtx_alloc_stat (RTX_CODE code MEM_STAT_DECL)
 225 {
 226   return rtx_alloc_stat_v (code PASS_MEM_STAT, 0);
 227 }
 228
 229 /* Write the wide constant X to OUTFILE.  */
 230
 231 void
 232 cwi_output_hex (FILE *outfile, const_rtx x)
 233 {
 234   int i = CWI_GET_NUM_ELEM (x);
 235   gcc_assert (i > 0);
 236   if (CWI_ELT (x, i - 1) == 0)
 237     /* The HOST_WIDE_INT_PRINT_HEX prepends a 0x only if the val is
 238        non zero.  We want all numbers to have a 0x prefix.  */
 239     fprintf (outfile, "0x");
 240   fprintf (outfile, HOST_WIDE_INT_PRINT_HEX, CWI_ELT (x, --i));
 241   while (--i >= 0)
 242     fprintf (outfile, HOST_WIDE_INT_PRINT_PADDED_HEX, CWI_ELT (x, i));
 243 }
 244
 245 \f
 246 /* Return true if ORIG is a sharable CONST.  */
 247
 248 bool
 249 shared_const_p (const_rtx orig)
 250 {
 251   gcc_assert (GET_CODE (orig) == CONST);
 252
 253   /* CONST can be shared if it contains a SYMBOL_REF.  If it contains
 254      a LABEL_REF, it isn't sharable.  */
 255   return (GET_CODE (XEXP (orig, 0)) == PLUS
 256           && GET_CODE (XEXP (XEXP (orig, 0), 0)) == SYMBOL_REF
 257           && CONST_INT_P (XEXP (XEXP (orig, 0), 1)));
 258 }
 259
 260
 261 /* Create a new copy of an rtx.
 262    Recursively copies the operands of the rtx,
 263    except for those few rtx codes that are sharable.  */
 264
 265 rtx
 266 copy_rtx (rtx orig)
 267 {
 268   rtx copy;
 269   int i, j;
 270   RTX_CODE code;
 271   const char *format_ptr;
 272
 273   code = GET_CODE (orig);
 274
 275   switch (code)
 276     {
 277     case REG:
 278     case DEBUG_EXPR:
 279     case VALUE:
 280     CASE_CONST_ANY:
 281     case SYMBOL_REF:
 282     case CODE_LABEL:
 283     case PC:
 284     case CC0:
 285     case RETURN:
 286     case SIMPLE_RETURN:
 287     case SCRATCH:
 288       /* SCRATCH must be shared because they represent distinct values.  */
 289       return orig;
 290     case CLOBBER:
 291       /* Share clobbers of hard registers (like cc0), but do not share pseudo reg
 292          clobbers or clobbers of hard registers that originated as pseudos.
 293          This is needed to allow safe register renaming.  */
 294       if (REG_P (XEXP (orig, 0)) && REGNO (XEXP (orig, 0)) < FIRST_PSEUDO_REGISTER
 295           && ORIGINAL_REGNO (XEXP (orig, 0)) == REGNO (XEXP (orig, 0)))
 296         return orig;
 297       break;
 298
 299     case CONST:
 300       if (shared_const_p (orig))
 301         return orig;
 302       break;
 303
 304       /* A MEM with a constant address is not sharable.  The problem is that
 305          the constant address may need to be reloaded.  If the mem is shared,
 306          then reloading one copy of this mem will cause all copies to appear
 307          to have been reloaded.  */
 308
 309     default:
 310       break;
 311     }
 312
 313   /* Copy the various flags, fields, and other information.  We assume
 314      that all fields need copying, and then clear the fields that should
 315      not be copied.  That is the sensible default behavior, and forces
 316      us to explicitly document why we are *not* copying a flag.  */
 317   copy = shallow_copy_rtx (orig);
 318
 319   /* We do not copy the USED flag, which is used as a mark bit during
 320      walks over the RTL.  */
 321   RTX_FLAG (copy, used) = 0;
 322
 323   format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
 324
 325   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
 326     switch (*format_ptr++)
 327       {
 328       case 'e':
 329         if (XEXP (orig, i) != NULL)
 330           XEXP (copy, i) = copy_rtx (XEXP (orig, i));
 331         break;
 332
 333       case 'E':
 334       case 'V':
 335         if (XVEC (orig, i) != NULL)
 336           {
 337             XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
 338             for (j = 0; j < XVECLEN (copy, i); j++)
 339               XVECEXP (copy, i, j) = copy_rtx (XVECEXP (orig, i, j));
 340           }
 341         break;
 342
 343       case 't':
 344       case 'w':
 345       case 'i':
 346       case 's':
 347       case 'S':
 348       case 'T':
 349       case 'u':
 350       case 'B':
 351       case '0':
 352         /* These are left unchanged.  */
 353         break;
 354
 355       default:
 356         gcc_unreachable ();
 357       }
 358   return copy;
 359 }
 360
 361 /* Create a new copy of an rtx.  Only copy just one level.  */
 362
 363 rtx
 364 shallow_copy_rtx_stat (const_rtx orig MEM_STAT_DECL)
 365 {
 366   const unsigned int size = rtx_size (orig);
 367   rtx const copy = ggc_alloc_rtx_def_stat (size PASS_MEM_STAT);
 368   return (rtx) memcpy (copy, orig, size);
 369 }
 370 \f
 371 /* Nonzero when we are generating CONCATs.  */
 372 int generating_concat_p;
 373
 374 /* Nonzero when we are expanding trees to RTL.  */
 375 int currently_expanding_to_rtl;
 376
 377 \f
 378
 379 /* Same as rtx_equal_p, but call CB on each pair of rtx if CB is not NULL.
 380    When the callback returns true, we continue with the new pair.
 381    Whenever changing this function check if rtx_equal_p below doesn't need
 382    changing as well.  */
 383
 384 int
 385 rtx_equal_p_cb (const_rtx x, const_rtx y, rtx_equal_p_callback_function cb)
 386 {
 387   int i;
 388   int j;
 389   enum rtx_code code;
 390   const char *fmt;
 391   rtx nx, ny;
 392
 393   if (x == y)
 394     return 1;
 395   if (x == 0 || y == 0)
 396     return 0;
 397
 398   /* Invoke the callback first.  */
 399   if (cb != NULL
 400       && ((*cb) (&x, &y, &nx, &ny)))
 401     return rtx_equal_p_cb (nx, ny, cb);
 402
 403   code = GET_CODE (x);
 404   /* Rtx's of different codes cannot be equal.  */
 405   if (code != GET_CODE (y))
 406     return 0;
 407
 408   /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
 409      (REG:SI x) and (REG:HI x) are NOT equivalent.  */
 410
 411   if (GET_MODE (x) != GET_MODE (y))
 412     return 0;
 413
 414   /* MEMs referring to different address space are not equivalent.  */
 415   if (code == MEM && MEM_ADDR_SPACE (x) != MEM_ADDR_SPACE (y))
 416     return 0;
 417
 418   /* Some RTL can be compared nonrecursively.  */
 419   switch (code)
 420     {
 421     case REG:
 422       return (REGNO (x) == REGNO (y));
 423
 424     case LABEL_REF:
 425       return LABEL_REF_LABEL (x) == LABEL_REF_LABEL (y);
 426
 427     case SYMBOL_REF:
 428       return XSTR (x, 0) == XSTR (y, 0);
 429
 430     case DEBUG_EXPR:
 431     case VALUE:
 432     case SCRATCH:
 433     CASE_CONST_UNIQUE:
 434       return 0;
 435
 436     case DEBUG_IMPLICIT_PTR:
 437       return DEBUG_IMPLICIT_PTR_DECL (x)
 438              == DEBUG_IMPLICIT_PTR_DECL (y);
 439
 440     case DEBUG_PARAMETER_REF:
 441       return DEBUG_PARAMETER_REF_DECL (x)
 442              == DEBUG_PARAMETER_REF_DECL (x);
 443
 444     case ENTRY_VALUE:
 445       return rtx_equal_p_cb (ENTRY_VALUE_EXP (x), ENTRY_VALUE_EXP (y), cb);
 446
 447     default:
 448       break;
 449     }
 450
 451   /* Compare the elements.  If any pair of corresponding elements
 452      fail to match, return 0 for the whole thing.  */
 453
 454   fmt = GET_RTX_FORMAT (code);
 455   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
 456     {
 457       switch (fmt[i])
 458         {
 459         case 'w':
 460           if (XWINT (x, i) != XWINT (y, i))
 461             return 0;
 462           break;
 463
 464         case 'n':
 465         case 'i':
 466           if (XINT (x, i) != XINT (y, i))
 467             {
 468 #ifndef GENERATOR_FILE
 469               if (((code == ASM_OPERANDS && i == 6)
 470                    || (code == ASM_INPUT && i == 1))
 471                   && XINT (x, i) == XINT (y, i))
 472                 break;
 473 #endif
 474               return 0;
 475             }
 476           break;
 477
 478         case 'V':
 479         case 'E':
 480           /* Two vectors must have the same length.  */
 481           if (XVECLEN (x, i) != XVECLEN (y, i))
 482             return 0;
 483
 484           /* And the corresponding elements must match.  */
 485           for (j = 0; j < XVECLEN (x, i); j++)
 486             if (rtx_equal_p_cb (XVECEXP (x, i, j),
 487                                 XVECEXP (y, i, j), cb) == 0)
 488               return 0;
 489           break;
 490
 491         case 'e':
 492           if (rtx_equal_p_cb (XEXP (x, i), XEXP (y, i), cb) == 0)
 493             return 0;
 494           break;
 495
 496         case 'S':
 497         case 's':
 498           if ((XSTR (x, i) || XSTR (y, i))
 499               && (! XSTR (x, i) || ! XSTR (y, i)
 500                   || strcmp (XSTR (x, i), XSTR (y, i))))
 501             return 0;
 502           break;
 503
 504         case 'u':
 505           /* These are just backpointers, so they don't matter.  */
 506           break;
 507
 508         case '0':
 509         case 't':
 510           break;
 511
 512           /* It is believed that rtx's at this level will never
 513              contain anything but integers and other rtx's,
 514              except for within LABEL_REFs and SYMBOL_REFs.  */
 515         default:
 516           gcc_unreachable ();
 517         }
 518     }
 519   return 1;
 520 }
 521
 522 /* Return 1 if X and Y are identical-looking rtx's.
 523    This is the Lisp function EQUAL for rtx arguments.
 524    Whenever changing this function check if rtx_equal_p_cb above doesn't need
 525    changing as well.  */
 526
 527 int
 528 rtx_equal_p (const_rtx x, const_rtx y)
 529 {
 530   int i;
 531   int j;
 532   enum rtx_code code;
 533   const char *fmt;
 534
 535   if (x == y)
 536     return 1;
 537   if (x == 0 || y == 0)
 538     return 0;
 539
 540   code = GET_CODE (x);
 541   /* Rtx's of different codes cannot be equal.  */
 542   if (code != GET_CODE (y))
 543     return 0;
 544
 545   /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
 546      (REG:SI x) and (REG:HI x) are NOT equivalent.  */
 547
 548   if (GET_MODE (x) != GET_MODE (y))
 549     return 0;
 550
 551   /* MEMs referring to different address space are not equivalent.  */
 552   if (code == MEM && MEM_ADDR_SPACE (x) != MEM_ADDR_SPACE (y))
 553     return 0;
 554
 555   /* Some RTL can be compared nonrecursively.  */
 556   switch (code)
 557     {
 558     case REG:
 559       return (REGNO (x) == REGNO (y));
 560
 561     case LABEL_REF:
 562       return LABEL_REF_LABEL (x) == LABEL_REF_LABEL (y);
 563
 564     case SYMBOL_REF:
 565       return XSTR (x, 0) == XSTR (y, 0);
 566
 567     case DEBUG_EXPR:
 568     case VALUE:
 569     case SCRATCH:
 570     CASE_CONST_UNIQUE:
 571       return 0;
 572
 573     case DEBUG_IMPLICIT_PTR:
 574       return DEBUG_IMPLICIT_PTR_DECL (x)
 575              == DEBUG_IMPLICIT_PTR_DECL (y);
 576
 577     case DEBUG_PARAMETER_REF:
 578       return DEBUG_PARAMETER_REF_DECL (x)
 579              == DEBUG_PARAMETER_REF_DECL (y);
 580
 581     case ENTRY_VALUE:
 582       return rtx_equal_p (ENTRY_VALUE_EXP (x), ENTRY_VALUE_EXP (y));
 583
 584     default:
 585       break;
 586     }
 587
 588   /* Compare the elements.  If any pair of corresponding elements
 589      fail to match, return 0 for the whole thing.  */
 590
 591   fmt = GET_RTX_FORMAT (code);
 592   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
 593     {
 594       switch (fmt[i])
 595         {
 596         case 'w':
 597           if (XWINT (x, i) != XWINT (y, i))
 598             return 0;
 599           break;
 600
 601         case 'n':
 602         case 'i':
 603           if (XINT (x, i) != XINT (y, i))
 604             {
 605 #ifndef GENERATOR_FILE
 606               if (((code == ASM_OPERANDS && i == 6)
 607                    || (code == ASM_INPUT && i == 1))
 608                   && XINT (x, i) == XINT (y, i))
 609                 break;
 610 #endif
 611               return 0;
 612             }
 613           break;
 614
 615         case 'V':
 616         case 'E':
 617           /* Two vectors must have the same length.  */
 618           if (XVECLEN (x, i) != XVECLEN (y, i))
 619             return 0;
 620
 621           /* And the corresponding elements must match.  */
 622           for (j = 0; j < XVECLEN (x, i); j++)
 623             if (rtx_equal_p (XVECEXP (x, i, j),  XVECEXP (y, i, j)) == 0)
 624               return 0;
 625           break;
 626
 627         case 'e':
 628           if (rtx_equal_p (XEXP (x, i), XEXP (y, i)) == 0)
 629             return 0;
 630           break;
 631
 632         case 'S':
 633         case 's':
 634           if ((XSTR (x, i) || XSTR (y, i))
 635               && (! XSTR (x, i) || ! XSTR (y, i)
 636                   || strcmp (XSTR (x, i), XSTR (y, i))))
 637             return 0;
 638           break;
 639
 640         case 'u':
 641           /* These are just backpointers, so they don't matter.  */
 642           break;
 643
 644         case '0':
 645         case 't':
 646           break;
 647
 648           /* It is believed that rtx's at this level will never
 649              contain anything but integers and other rtx's,
 650              except for within LABEL_REFs and SYMBOL_REFs.  */
 651         default:
 652           gcc_unreachable ();
 653         }
 654     }
 655   return 1;
 656 }
 657
 658 void
 659 dump_rtx_statistics (void)
 660 {
 661   int i;
 662   int total_counts = 0;
 663   int total_sizes = 0;
 664
 665   if (! GATHER_STATISTICS)
 666     {
 667       fprintf (stderr, "No RTX statistics\n");
 668       return;
 669     }
 670
 671   fprintf (stderr, "\nRTX Kind               Count      Bytes\n");
 672   fprintf (stderr, "---------------------------------------\n");
 673   for (i = 0; i < LAST_AND_UNUSED_RTX_CODE; i++)
 674     if (rtx_alloc_counts[i])
 675       {
 676         fprintf (stderr, "%-20s %7d %10d\n", GET_RTX_NAME (i),
 677                  rtx_alloc_counts[i], rtx_alloc_sizes[i]);
 678         total_counts += rtx_alloc_counts[i];
 679         total_sizes += rtx_alloc_sizes[i];
 680       }
 681   if (rtvec_alloc_counts)
 682     {
 683       fprintf (stderr, "%-20s %7d %10d\n", "rtvec",
 684                rtvec_alloc_counts, rtvec_alloc_sizes);
 685       total_counts += rtvec_alloc_counts;
 686       total_sizes += rtvec_alloc_sizes;
 687     }
 688   fprintf (stderr, "---------------------------------------\n");
 689   fprintf (stderr, "%-20s %7d %10d\n",
 690            "Total", total_counts, total_sizes);
 691   fprintf (stderr, "---------------------------------------\n");
 692 }
 693 \f
 694 #if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007)
 695 void
 696 rtl_check_failed_bounds (const_rtx r, int n, const char *file, int line,
 697                          const char *func)
 698 {
 699   internal_error
 700     ("RTL check: access of elt %d of '%s' with last elt %d in %s, at %s:%d",
 701      n, GET_RTX_NAME (GET_CODE (r)), GET_RTX_LENGTH (GET_CODE (r)) - 1,
 702      func, trim_filename (file), line);
 703 }
 704
 705 void
 706 rtl_check_failed_type1 (const_rtx r, int n, int c1, const char *file, int line,
 707                         const char *func)
 708 {
 709   internal_error
 710     ("RTL check: expected elt %d type '%c', have '%c' (rtx %s) in %s, at %s:%d",
 711      n, c1, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
 712      func, trim_filename (file), line);
 713 }
 714
 715 void
 716 rtl_check_failed_type2 (const_rtx r, int n, int c1, int c2, const char *file,
 717                         int line, const char *func)
 718 {
 719   internal_error
 720     ("RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s) in %s, at %s:%d",
 721      n, c1, c2, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
 722      func, trim_filename (file), line);
 723 }
 724
 725 void
 726 rtl_check_failed_code1 (const_rtx r, enum rtx_code code, const char *file,
 727                         int line, const char *func)
 728 {
 729   internal_error ("RTL check: expected code '%s', have '%s' in %s, at %s:%d",
 730                   GET_RTX_NAME (code), GET_RTX_NAME (GET_CODE (r)), func,
 731                   trim_filename (file), line);
 732 }
 733
 734 void
 735 rtl_check_failed_code2 (const_rtx r, enum rtx_code code1, enum rtx_code code2,
 736                         const char *file, int line, const char *func)
 737 {
 738   internal_error
 739     ("RTL check: expected code '%s' or '%s', have '%s' in %s, at %s:%d",
 740      GET_RTX_NAME (code1), GET_RTX_NAME (code2), GET_RTX_NAME (GET_CODE (r)),
 741      func, trim_filename (file), line);
 742 }
 743
 744 void
 745 rtl_check_failed_code_mode (const_rtx r, enum rtx_code code, machine_mode mode,
 746                             bool not_mode, const char *file, int line,
 747                             const char *func)
 748 {
 749   internal_error ((not_mode
 750                    ? ("RTL check: expected code '%s' and not mode '%s', "
 751                       "have code '%s' and mode '%s' in %s, at %s:%d")
 752                    : ("RTL check: expected code '%s' and mode '%s', "
 753                       "have code '%s' and mode '%s' in %s, at %s:%d")),
 754                   GET_RTX_NAME (code), GET_MODE_NAME (mode),
 755                   GET_RTX_NAME (GET_CODE (r)), GET_MODE_NAME (GET_MODE (r)),
 756                   func, trim_filename (file), line);
 757 }
 758
 759 /* Report that line LINE of FILE tried to access the block symbol fields
 760    of a non-block symbol.  FUNC is the function that contains the line.  */
 761
 762 void
 763 rtl_check_failed_block_symbol (const char *file, int line, const char *func)
 764 {
 765   internal_error
 766     ("RTL check: attempt to treat non-block symbol as a block symbol "
 767      "in %s, at %s:%d", func, trim_filename (file), line);
 768 }
 769
 770 /* XXX Maybe print the vector?  */
 771 void
 772 cwi_check_failed_bounds (const_rtx x, int n, const char *file, int line,
 773                          const char *func)
 774 {
 775   internal_error
 776     ("RTL check: access of hwi elt %d of vector with last elt %d in %s, at %s:%d",
 777      n, CWI_GET_NUM_ELEM (x) - 1, func, trim_filename (file), line);
 778 }
 779
 780 /* XXX Maybe print the vector?  */
 781 void
 782 rtvec_check_failed_bounds (const_rtvec r, int n, const char *file, int line,
 783                            const char *func)
 784 {
 785   internal_error
 786     ("RTL check: access of elt %d of vector with last elt %d in %s, at %s:%d",
 787      n, GET_NUM_ELEM (r) - 1, func, trim_filename (file), line);
 788 }
 789 #endif /* ENABLE_RTL_CHECKING */
 790
 791 #if defined ENABLE_RTL_FLAG_CHECKING
 792 void
 793 rtl_check_failed_flag (const char *name, const_rtx r, const char *file,
 794                        int line, const char *func)
 795 {
 796   internal_error
 797     ("RTL flag check: %s used with unexpected rtx code '%s' in %s, at %s:%d",
 798      name, GET_RTX_NAME (GET_CODE (r)), func, trim_filename (file), line);
 799 }
 800 #endif /* ENABLE_RTL_FLAG_CHECKING */