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                       \
 114     || (ENUM) == CONST_FIXED)                                           \
 115    ? RTX_HDR_SIZE + (sizeof FORMAT - 1) * sizeof (HOST_WIDE_INT)        \
 116    : RTX_HDR_SIZE + (sizeof FORMAT - 1) * sizeof (rtunion)),
 117
 118 #include "rtl.def"
 119 #undef DEF_RTL_EXPR
 120 };
 121
 122 /* Names for kinds of NOTEs and REG_NOTEs.  */
 123
 124 const char * const note_insn_name[NOTE_INSN_MAX] =
 125 {
 126 #define DEF_INSN_NOTE(NAME) #NAME,
 127 #include "insn-notes.def"
 128 #undef DEF_INSN_NOTE
 129 };
 130
 131 const char * const reg_note_name[REG_NOTE_MAX] =
 132 {
 133 #define DEF_REG_NOTE(NAME) #NAME,
 134 #include "reg-notes.def"
 135 #undef DEF_REG_NOTE
 136 };
 137
 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
 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   if (GATHER_STATISTICS)
 159     {
 160       rtvec_alloc_counts++;
 161       rtvec_alloc_sizes += n * sizeof (rtx);
 162     }
 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   if (GATHER_STATISTICS)
 208     {
 209       rtx_alloc_counts[code]++;
 210       rtx_alloc_sizes[code] += RTX_CODE_SIZE (code);
 211     }
 212
 213   return rt;
 214 }
 215
 216 \f
 217 /* Return true if ORIG is a sharable CONST.  */
 218
 219 bool
 220 shared_const_p (const_rtx orig)
 221 {
 222   gcc_assert (GET_CODE (orig) == CONST);
 223
 224   /* CONST can be shared if it contains a SYMBOL_REF.  If it contains
 225      a LABEL_REF, it isn't sharable.  */
 226   return (GET_CODE (XEXP (orig, 0)) == PLUS
 227           && GET_CODE (XEXP (XEXP (orig, 0), 0)) == SYMBOL_REF
 228           && CONST_INT_P(XEXP (XEXP (orig, 0), 1)));
 229 }
 230
 231
 232 /* Create a new copy of an rtx.
 233    Recursively copies the operands of the rtx,
 234    except for those few rtx codes that are sharable.  */
 235
 236 rtx
 237 copy_rtx (rtx orig)
 238 {
 239   rtx copy;
 240   int i, j;
 241   RTX_CODE code;
 242   const char *format_ptr;
 243
 244   code = GET_CODE (orig);
 245
 246   switch (code)
 247     {
 248     case REG:
 249     case DEBUG_EXPR:
 250     case VALUE:
 251     CASE_CONST_ANY:
 252     case SYMBOL_REF:
 253     case CODE_LABEL:
 254     case PC:
 255     case CC0:
 256     case RETURN:
 257     case SIMPLE_RETURN:
 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   format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
 291
 292   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
 293     switch (*format_ptr++)
 294       {
 295       case 'e':
 296         if (XEXP (orig, i) != NULL)
 297           XEXP (copy, i) = copy_rtx (XEXP (orig, i));
 298         break;
 299
 300       case 'E':
 301       case 'V':
 302         if (XVEC (orig, i) != NULL)
 303           {
 304             XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
 305             for (j = 0; j < XVECLEN (copy, i); j++)
 306               XVECEXP (copy, i, j) = copy_rtx (XVECEXP (orig, i, j));
 307           }
 308         break;
 309
 310       case 't':
 311       case 'w':
 312       case 'i':
 313       case 's':
 314       case 'S':
 315       case 'T':
 316       case 'u':
 317       case 'B':
 318       case '0':
 319         /* These are left unchanged.  */
 320         break;
 321
 322       default:
 323         gcc_unreachable ();
 324       }
 325   return copy;
 326 }
 327
 328 /* Create a new copy of an rtx.  Only copy just one level.  */
 329
 330 rtx
 331 shallow_copy_rtx_stat (const_rtx orig MEM_STAT_DECL)
 332 {
 333   const unsigned int size = rtx_size (orig);
 334   rtx const copy = ggc_alloc_zone_rtx_def_stat (&rtl_zone, size PASS_MEM_STAT);
 335   return (rtx) memcpy (copy, orig, size);
 336 }
 337 \f
 338 /* Nonzero when we are generating CONCATs.  */
 339 int generating_concat_p;
 340
 341 /* Nonzero when we are expanding trees to RTL.  */
 342 int currently_expanding_to_rtl;
 343
 344 \f
 345
 346 /* Same as rtx_equal_p, but call CB on each pair of rtx if CB is not NULL.
 347    When the callback returns true, we continue with the new pair.
 348    Whenever changing this function check if rtx_equal_p below doesn't need
 349    changing as well.  */
 350
 351 int
 352 rtx_equal_p_cb (const_rtx x, const_rtx y, rtx_equal_p_callback_function cb)
 353 {
 354   int i;
 355   int j;
 356   enum rtx_code code;
 357   const char *fmt;
 358   rtx nx, ny;
 359
 360   if (x == y)
 361     return 1;
 362   if (x == 0 || y == 0)
 363     return 0;
 364
 365   /* Invoke the callback first.  */
 366   if (cb != NULL
 367       && ((*cb) (&x, &y, &nx, &ny)))
 368     return rtx_equal_p_cb (nx, ny, cb);
 369
 370   code = GET_CODE (x);
 371   /* Rtx's of different codes cannot be equal.  */
 372   if (code != GET_CODE (y))
 373     return 0;
 374
 375   /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
 376      (REG:SI x) and (REG:HI x) are NOT equivalent.  */
 377
 378   if (GET_MODE (x) != GET_MODE (y))
 379     return 0;
 380
 381   /* MEMs referring to different address space are not equivalent.  */
 382   if (code == MEM && MEM_ADDR_SPACE (x) != MEM_ADDR_SPACE (y))
 383     return 0;
 384
 385   /* Some RTL can be compared nonrecursively.  */
 386   switch (code)
 387     {
 388     case REG:
 389       return (REGNO (x) == REGNO (y));
 390
 391     case LABEL_REF:
 392       return XEXP (x, 0) == XEXP (y, 0);
 393
 394     case SYMBOL_REF:
 395       return XSTR (x, 0) == XSTR (y, 0);
 396
 397     case DEBUG_EXPR:
 398     case VALUE:
 399     case SCRATCH:
 400     CASE_CONST_UNIQUE:
 401       return 0;
 402
 403     case DEBUG_IMPLICIT_PTR:
 404       return DEBUG_IMPLICIT_PTR_DECL (x)
 405              == DEBUG_IMPLICIT_PTR_DECL (y);
 406
 407     case DEBUG_PARAMETER_REF:
 408       return DEBUG_PARAMETER_REF_DECL (x)
 409              == DEBUG_PARAMETER_REF_DECL (x);
 410
 411     case ENTRY_VALUE:
 412       return rtx_equal_p_cb (ENTRY_VALUE_EXP (x), ENTRY_VALUE_EXP (y), cb);
 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                   && 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 referring 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_UNIQUE:
 538       return 0;
 539
 540     case DEBUG_IMPLICIT_PTR:
 541       return DEBUG_IMPLICIT_PTR_DECL (x)
 542              == DEBUG_IMPLICIT_PTR_DECL (y);
 543
 544     case DEBUG_PARAMETER_REF:
 545       return DEBUG_PARAMETER_REF_DECL (x)
 546              == DEBUG_PARAMETER_REF_DECL (y);
 547
 548     case ENTRY_VALUE:
 549       return rtx_equal_p (ENTRY_VALUE_EXP (x), ENTRY_VALUE_EXP (y));
 550
 551     default:
 552       break;
 553     }
 554
 555   /* Compare the elements.  If any pair of corresponding elements
 556      fail to match, return 0 for the whole thing.  */
 557
 558   fmt = GET_RTX_FORMAT (code);
 559   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
 560     {
 561       switch (fmt[i])
 562         {
 563         case 'w':
 564           if (XWINT (x, i) != XWINT (y, i))
 565             return 0;
 566           break;
 567
 568         case 'n':
 569         case 'i':
 570           if (XINT (x, i) != XINT (y, i))
 571             {
 572 #ifndef GENERATOR_FILE
 573               if (((code == ASM_OPERANDS && i == 6)
 574                    || (code == ASM_INPUT && i == 1))
 575                   && XINT (x, i) == XINT (y, i))
 576                 break;
 577 #endif
 578               return 0;
 579             }
 580           break;
 581
 582         case 'V':
 583         case 'E':
 584           /* Two vectors must have the same length.  */
 585           if (XVECLEN (x, i) != XVECLEN (y, i))
 586             return 0;
 587
 588           /* And the corresponding elements must match.  */
 589           for (j = 0; j < XVECLEN (x, i); j++)
 590             if (rtx_equal_p (XVECEXP (x, i, j),  XVECEXP (y, i, j)) == 0)
 591               return 0;
 592           break;
 593
 594         case 'e':
 595           if (rtx_equal_p (XEXP (x, i), XEXP (y, i)) == 0)
 596             return 0;
 597           break;
 598
 599         case 'S':
 600         case 's':
 601           if ((XSTR (x, i) || XSTR (y, i))
 602               && (! XSTR (x, i) || ! XSTR (y, i)
 603                   || strcmp (XSTR (x, i), XSTR (y, i))))
 604             return 0;
 605           break;
 606
 607         case 'u':
 608           /* These are just backpointers, so they don't matter.  */
 609           break;
 610
 611         case '0':
 612         case 't':
 613           break;
 614
 615           /* It is believed that rtx's at this level will never
 616              contain anything but integers and other rtx's,
 617              except for within LABEL_REFs and SYMBOL_REFs.  */
 618         default:
 619           gcc_unreachable ();
 620         }
 621     }
 622   return 1;
 623 }
 624
 625 /* Iteratively hash rtx X.  */
 626
 627 hashval_t
 628 iterative_hash_rtx (const_rtx x, hashval_t hash)
 629 {
 630   enum rtx_code code;
 631   enum machine_mode mode;
 632   int i, j;
 633   const char *fmt;
 634
 635   if (x == NULL_RTX)
 636     return hash;
 637   code = GET_CODE (x);
 638   hash = iterative_hash_object (code, hash);
 639   mode = GET_MODE (x);
 640   hash = iterative_hash_object (mode, hash);
 641   switch (code)
 642     {
 643     case REG:
 644       i = REGNO (x);
 645       return iterative_hash_object (i, hash);
 646     case CONST_INT:
 647       return iterative_hash_object (INTVAL (x), hash);
 648     case SYMBOL_REF:
 649       if (XSTR (x, 0))
 650         return iterative_hash (XSTR (x, 0), strlen (XSTR (x, 0)) + 1,
 651                                hash);
 652       return hash;
 653     case LABEL_REF:
 654     case DEBUG_EXPR:
 655     case VALUE:
 656     case SCRATCH:
 657     case CONST_DOUBLE:
 658     case CONST_FIXED:
 659     case DEBUG_IMPLICIT_PTR:
 660     case DEBUG_PARAMETER_REF:
 661       return hash;
 662     default:
 663       break;
 664     }
 665
 666   fmt = GET_RTX_FORMAT (code);
 667   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
 668     switch (fmt[i])
 669       {
 670       case 'w':
 671         hash = iterative_hash_object (XWINT (x, i), hash);
 672         break;
 673       case 'n':
 674       case 'i':
 675         hash = iterative_hash_object (XINT (x, i), hash);
 676         break;
 677       case 'V':
 678       case 'E':
 679         j = XVECLEN (x, i);
 680         hash = iterative_hash_object (j, hash);
 681         for (j = 0; j < XVECLEN (x, i); j++)
 682           hash = iterative_hash_rtx (XVECEXP (x, i, j), hash);
 683         break;
 684       case 'e':
 685         hash = iterative_hash_rtx (XEXP (x, i), hash);
 686         break;
 687       case 'S':
 688       case 's':
 689         if (XSTR (x, i))
 690           hash = iterative_hash (XSTR (x, 0), strlen (XSTR (x, 0)) + 1,
 691                                  hash);
 692         break;
 693       default:
 694         break;
 695       }
 696   return hash;
 697 }
 698
 699 void
 700 dump_rtx_statistics (void)
 701 {
 702   int i;
 703   int total_counts = 0;
 704   int total_sizes = 0;
 705
 706   if (! GATHER_STATISTICS)
 707     {
 708       fprintf (stderr, "No RTX statistics\n");
 709       return;
 710     }
 711
 712   fprintf (stderr, "\nRTX Kind               Count      Bytes\n");
 713   fprintf (stderr, "---------------------------------------\n");
 714   for (i = 0; i < LAST_AND_UNUSED_RTX_CODE; i++)
 715     if (rtx_alloc_counts[i])
 716       {
 717         fprintf (stderr, "%-20s %7d %10d\n", GET_RTX_NAME (i),
 718                  rtx_alloc_counts[i], rtx_alloc_sizes[i]);
 719         total_counts += rtx_alloc_counts[i];
 720         total_sizes += rtx_alloc_sizes[i];
 721       }
 722   if (rtvec_alloc_counts)
 723     {
 724       fprintf (stderr, "%-20s %7d %10d\n", "rtvec",
 725                rtvec_alloc_counts, rtvec_alloc_sizes);
 726       total_counts += rtvec_alloc_counts;
 727       total_sizes += rtvec_alloc_sizes;
 728     }
 729   fprintf (stderr, "---------------------------------------\n");
 730   fprintf (stderr, "%-20s %7d %10d\n",
 731            "Total", total_counts, total_sizes);
 732   fprintf (stderr, "---------------------------------------\n");
 733 }
 734 \f
 735 #if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007)
 736 void
 737 rtl_check_failed_bounds (const_rtx r, int n, const char *file, int line,
 738                          const char *func)
 739 {
 740   internal_error
 741     ("RTL check: access of elt %d of '%s' with last elt %d in %s, at %s:%d",
 742      n, GET_RTX_NAME (GET_CODE (r)), GET_RTX_LENGTH (GET_CODE (r)) - 1,
 743      func, trim_filename (file), line);
 744 }
 745
 746 void
 747 rtl_check_failed_type1 (const_rtx r, int n, int c1, const char *file, int line,
 748                         const char *func)
 749 {
 750   internal_error
 751     ("RTL check: expected elt %d type '%c', have '%c' (rtx %s) in %s, at %s:%d",
 752      n, c1, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
 753      func, trim_filename (file), line);
 754 }
 755
 756 void
 757 rtl_check_failed_type2 (const_rtx r, int n, int c1, int c2, const char *file,
 758                         int line, const char *func)
 759 {
 760   internal_error
 761     ("RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s) in %s, at %s:%d",
 762      n, c1, c2, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
 763      func, trim_filename (file), line);
 764 }
 765
 766 void
 767 rtl_check_failed_code1 (const_rtx r, enum rtx_code code, const char *file,
 768                         int line, const char *func)
 769 {
 770   internal_error ("RTL check: expected code '%s', have '%s' in %s, at %s:%d",
 771                   GET_RTX_NAME (code), GET_RTX_NAME (GET_CODE (r)), func,
 772                   trim_filename (file), line);
 773 }
 774
 775 void
 776 rtl_check_failed_code2 (const_rtx r, enum rtx_code code1, enum rtx_code code2,
 777                         const char *file, int line, const char *func)
 778 {
 779   internal_error
 780     ("RTL check: expected code '%s' or '%s', have '%s' in %s, at %s:%d",
 781      GET_RTX_NAME (code1), GET_RTX_NAME (code2), GET_RTX_NAME (GET_CODE (r)),
 782      func, trim_filename (file), line);
 783 }
 784
 785 void
 786 rtl_check_failed_code_mode (const_rtx r, enum rtx_code code, enum machine_mode mode,
 787                             bool not_mode, const char *file, int line,
 788                             const char *func)
 789 {
 790   internal_error ((not_mode
 791                    ? ("RTL check: expected code '%s' and not mode '%s', "
 792                       "have code '%s' and mode '%s' in %s, at %s:%d")
 793                    : ("RTL check: expected code '%s' and mode '%s', "
 794                       "have code '%s' and mode '%s' in %s, at %s:%d")),
 795                   GET_RTX_NAME (code), GET_MODE_NAME (mode),
 796                   GET_RTX_NAME (GET_CODE (r)), GET_MODE_NAME (GET_MODE (r)),
 797                   func, trim_filename (file), line);
 798 }
 799
 800 /* Report that line LINE of FILE tried to access the block symbol fields
 801    of a non-block symbol.  FUNC is the function that contains the line.  */
 802
 803 void
 804 rtl_check_failed_block_symbol (const char *file, int line, const char *func)
 805 {
 806   internal_error
 807     ("RTL check: attempt to treat non-block symbol as a block symbol "
 808      "in %s, at %s:%d", func, trim_filename (file), line);
 809 }
 810
 811 /* XXX Maybe print the vector?  */
 812 void
 813 rtvec_check_failed_bounds (const_rtvec r, int n, const char *file, int line,
 814                            const char *func)
 815 {
 816   internal_error
 817     ("RTL check: access of elt %d of vector with last elt %d in %s, at %s:%d",
 818      n, GET_NUM_ELEM (r) - 1, func, trim_filename (file), line);
 819 }
 820 #endif /* ENABLE_RTL_CHECKING */
 821
 822 #if defined ENABLE_RTL_FLAG_CHECKING
 823 void
 824 rtl_check_failed_flag (const char *name, const_rtx r, const char *file,
 825                        int line, const char *func)
 826 {
 827   internal_error
 828     ("RTL flag check: %s used with unexpected rtx code '%s' in %s, at %s:%d",
 829      name, GET_RTX_NAME (GET_CODE (r)), func, trim_filename (file), line);
 830 }
 831 #endif /* ENABLE_RTL_FLAG_CHECKING */