gcc/rtl.c

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