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