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