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 /* Iteratively hash rtx X.  */
 605
 606 hashval_t
 607 iterative_hash_rtx (const_rtx x, hashval_t hash)
 608 {
 609   enum rtx_code code;
 610   enum machine_mode mode;
 611   int i, j;
 612   const char *fmt;
 613
 614   if (x == NULL_RTX)
 615     return hash;
 616   code = GET_CODE (x);
 617   hash = iterative_hash_object (code, hash);
 618   mode = GET_MODE (x);
 619   hash = iterative_hash_object (mode, hash);
 620   switch (code)
 621     {
 622     case REG:
 623       i = REGNO (x);
 624       return iterative_hash_object (i, hash);
 625     case CONST_INT:
 626       return iterative_hash_object (INTVAL (x), hash);
 627     case SYMBOL_REF:
 628       if (XSTR (x, 0))
 629         return iterative_hash (XSTR (x, 0), strlen (XSTR (x, 0)) + 1,
 630                                hash);
 631       return hash;
 632     case LABEL_REF:
 633     case DEBUG_EXPR:
 634     case VALUE:
 635     case SCRATCH:
 636     case CONST_DOUBLE:
 637     case CONST_FIXED:
 638     case DEBUG_IMPLICIT_PTR:
 639       return hash;
 640     default:
 641       break;
 642     }
 643
 644   fmt = GET_RTX_FORMAT (code);
 645   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
 646     switch (fmt[i])
 647       {
 648       case 'w':
 649         hash = iterative_hash_object (XWINT (x, i), hash);
 650         break;
 651       case 'n':
 652       case 'i':
 653         hash = iterative_hash_object (XINT (x, i), hash);
 654         break;
 655       case 'V':
 656       case 'E':
 657         j = XVECLEN (x, i);
 658         hash = iterative_hash_object (j, hash);
 659         for (j = 0; j < XVECLEN (x, i); j++)
 660           hash = iterative_hash_rtx (XVECEXP (x, i, j), hash);
 661         break;
 662       case 'e':
 663         hash = iterative_hash_rtx (XEXP (x, i), hash);
 664         break;
 665       case 'S':
 666       case 's':
 667         if (XSTR (x, i))
 668           hash = iterative_hash (XSTR (x, 0), strlen (XSTR (x, 0)) + 1,
 669                                  hash);
 670         break;
 671       default:
 672         break;
 673       }
 674   return hash;
 675 }
 676
 677 void
 678 dump_rtx_statistics (void)
 679 {
 680 #ifdef GATHER_STATISTICS
 681   int i;
 682   int total_counts = 0;
 683   int total_sizes = 0;
 684   fprintf (stderr, "\nRTX Kind               Count      Bytes\n");
 685   fprintf (stderr, "---------------------------------------\n");
 686   for (i = 0; i < LAST_AND_UNUSED_RTX_CODE; i++)
 687     if (rtx_alloc_counts[i])
 688       {
 689         fprintf (stderr, "%-20s %7d %10d\n", GET_RTX_NAME (i),
 690                  rtx_alloc_counts[i], rtx_alloc_sizes[i]);
 691         total_counts += rtx_alloc_counts[i];
 692         total_sizes += rtx_alloc_sizes[i];
 693       }
 694   if (rtvec_alloc_counts)
 695     {
 696       fprintf (stderr, "%-20s %7d %10d\n", "rtvec",
 697                rtvec_alloc_counts, rtvec_alloc_sizes);
 698       total_counts += rtvec_alloc_counts;
 699       total_sizes += rtvec_alloc_sizes;
 700     }
 701   fprintf (stderr, "---------------------------------------\n");
 702   fprintf (stderr, "%-20s %7d %10d\n",
 703            "Total", total_counts, total_sizes);
 704   fprintf (stderr, "---------------------------------------\n");
 705 #endif
 706 }
 707 \f
 708 #if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007)
 709 void
 710 rtl_check_failed_bounds (const_rtx r, int n, const char *file, int line,
 711                          const char *func)
 712 {
 713   internal_error
 714     ("RTL check: access of elt %d of '%s' with last elt %d in %s, at %s:%d",
 715      n, GET_RTX_NAME (GET_CODE (r)), GET_RTX_LENGTH (GET_CODE (r)) - 1,
 716      func, trim_filename (file), line);
 717 }
 718
 719 void
 720 rtl_check_failed_type1 (const_rtx r, int n, int c1, const char *file, int line,
 721                         const char *func)
 722 {
 723   internal_error
 724     ("RTL check: expected elt %d type '%c', have '%c' (rtx %s) in %s, at %s:%d",
 725      n, c1, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
 726      func, trim_filename (file), line);
 727 }
 728
 729 void
 730 rtl_check_failed_type2 (const_rtx r, int n, int c1, int c2, const char *file,
 731                         int line, const char *func)
 732 {
 733   internal_error
 734     ("RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s) in %s, at %s:%d",
 735      n, c1, c2, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
 736      func, trim_filename (file), line);
 737 }
 738
 739 void
 740 rtl_check_failed_code1 (const_rtx r, enum rtx_code code, const char *file,
 741                         int line, const char *func)
 742 {
 743   internal_error ("RTL check: expected code '%s', have '%s' in %s, at %s:%d",
 744                   GET_RTX_NAME (code), GET_RTX_NAME (GET_CODE (r)), func,
 745                   trim_filename (file), line);
 746 }
 747
 748 void
 749 rtl_check_failed_code2 (const_rtx r, enum rtx_code code1, enum rtx_code code2,
 750                         const char *file, int line, const char *func)
 751 {
 752   internal_error
 753     ("RTL check: expected code '%s' or '%s', have '%s' in %s, at %s:%d",
 754      GET_RTX_NAME (code1), GET_RTX_NAME (code2), GET_RTX_NAME (GET_CODE (r)),
 755      func, trim_filename (file), line);
 756 }
 757
 758 void
 759 rtl_check_failed_code_mode (const_rtx r, enum rtx_code code, enum machine_mode mode,
 760                             bool not_mode, const char *file, int line,
 761                             const char *func)
 762 {
 763   internal_error ((not_mode
 764                    ? ("RTL check: expected code '%s' and not mode '%s', "
 765                       "have code '%s' and mode '%s' in %s, at %s:%d")
 766                    : ("RTL check: expected code '%s' and mode '%s', "
 767                       "have code '%s' and mode '%s' in %s, at %s:%d")),
 768                   GET_RTX_NAME (code), GET_MODE_NAME (mode),
 769                   GET_RTX_NAME (GET_CODE (r)), GET_MODE_NAME (GET_MODE (r)),
 770                   func, trim_filename (file), line);
 771 }
 772
 773 /* Report that line LINE of FILE tried to access the block symbol fields
 774    of a non-block symbol.  FUNC is the function that contains the line.  */
 775
 776 void
 777 rtl_check_failed_block_symbol (const char *file, int line, const char *func)
 778 {
 779   internal_error
 780     ("RTL check: attempt to treat non-block symbol as a block symbol "
 781      "in %s, at %s:%d", func, trim_filename (file), line);
 782 }
 783
 784 /* XXX Maybe print the vector?  */
 785 void
 786 rtvec_check_failed_bounds (const_rtvec r, int n, const char *file, int line,
 787                            const char *func)
 788 {
 789   internal_error
 790     ("RTL check: access of elt %d of vector with last elt %d in %s, at %s:%d",
 791      n, GET_NUM_ELEM (r) - 1, func, trim_filename (file), line);
 792 }
 793 #endif /* ENABLE_RTL_CHECKING */
 794
 795 #if defined ENABLE_RTL_FLAG_CHECKING
 796 void
 797 rtl_check_failed_flag (const char *name, const_rtx r, const char *file,
 798                        int line, const char *func)
 799 {
 800   internal_error
 801     ("RTL flag check: %s used with unexpected rtx code '%s' in %s, at %s:%d",
 802      name, GET_RTX_NAME (GET_CODE (r)), func, trim_filename (file), line);
 803 }
 804 #endif /* ENABLE_RTL_FLAG_CHECKING */