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_INT:
 252     case CONST_DOUBLE:
 253     case CONST_FIXED:
 254     case CONST_VECTOR:
 255     case SYMBOL_REF:
 256     case CODE_LABEL:
 257     case PC:
 258     case CC0:
 259     case RETURN:
 260     case SIMPLE_RETURN:
 261     case SCRATCH:
 262       /* SCRATCH must be shared because they represent distinct values.  */
 263       return orig;
 264     case CLOBBER:
 265       if (REG_P (XEXP (orig, 0)) && REGNO (XEXP (orig, 0)) < FIRST_PSEUDO_REGISTER)
 266         return orig;
 267       break;
 268
 269     case CONST:
 270       if (shared_const_p (orig))
 271         return orig;
 272       break;
 273
 274       /* A MEM with a constant address is not sharable.  The problem is that
 275          the constant address may need to be reloaded.  If the mem is shared,
 276          then reloading one copy of this mem will cause all copies to appear
 277          to have been reloaded.  */
 278
 279     default:
 280       break;
 281     }
 282
 283   /* Copy the various flags, fields, and other information.  We assume
 284      that all fields need copying, and then clear the fields that should
 285      not be copied.  That is the sensible default behavior, and forces
 286      us to explicitly document why we are *not* copying a flag.  */
 287   copy = shallow_copy_rtx (orig);
 288
 289   /* We do not copy the USED flag, which is used as a mark bit during
 290      walks over the RTL.  */
 291   RTX_FLAG (copy, used) = 0;
 292
 293   format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
 294
 295   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
 296     switch (*format_ptr++)
 297       {
 298       case 'e':
 299         if (XEXP (orig, i) != NULL)
 300           XEXP (copy, i) = copy_rtx (XEXP (orig, i));
 301         break;
 302
 303       case 'E':
 304       case 'V':
 305         if (XVEC (orig, i) != NULL)
 306           {
 307             XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
 308             for (j = 0; j < XVECLEN (copy, i); j++)
 309               XVECEXP (copy, i, j) = copy_rtx (XVECEXP (orig, i, j));
 310           }
 311         break;
 312
 313       case 't':
 314       case 'w':
 315       case 'i':
 316       case 's':
 317       case 'S':
 318       case 'T':
 319       case 'u':
 320       case 'B':
 321       case '0':
 322         /* These are left unchanged.  */
 323         break;
 324
 325       default:
 326         gcc_unreachable ();
 327       }
 328   return copy;
 329 }
 330
 331 /* Create a new copy of an rtx.  Only copy just one level.  */
 332
 333 rtx
 334 shallow_copy_rtx_stat (const_rtx orig MEM_STAT_DECL)
 335 {
 336   const unsigned int size = rtx_size (orig);
 337   rtx const copy = ggc_alloc_zone_rtx_def_stat (&rtl_zone, size PASS_MEM_STAT);
 338   return (rtx) memcpy (copy, orig, size);
 339 }
 340 \f
 341 /* Nonzero when we are generating CONCATs.  */
 342 int generating_concat_p;
 343
 344 /* Nonzero when we are expanding trees to RTL.  */
 345 int currently_expanding_to_rtl;
 346
 347 \f
 348
 349 /* Same as rtx_equal_p, but call CB on each pair of rtx if CB is not NULL.
 350    When the callback returns true, we continue with the new pair.
 351    Whenever changing this function check if rtx_equal_p below doesn't need
 352    changing as well.  */
 353
 354 int
 355 rtx_equal_p_cb (const_rtx x, const_rtx y, rtx_equal_p_callback_function cb)
 356 {
 357   int i;
 358   int j;
 359   enum rtx_code code;
 360   const char *fmt;
 361   rtx nx, ny;
 362
 363   if (x == y)
 364     return 1;
 365   if (x == 0 || y == 0)
 366     return 0;
 367
 368   /* Invoke the callback first.  */
 369   if (cb != NULL
 370       && ((*cb) (&x, &y, &nx, &ny)))
 371     return rtx_equal_p_cb (nx, ny, cb);
 372
 373   code = GET_CODE (x);
 374   /* Rtx's of different codes cannot be equal.  */
 375   if (code != GET_CODE (y))
 376     return 0;
 377
 378   /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
 379      (REG:SI x) and (REG:HI x) are NOT equivalent.  */
 380
 381   if (GET_MODE (x) != GET_MODE (y))
 382     return 0;
 383
 384   /* MEMs referring to different address space are not equivalent.  */
 385   if (code == MEM && MEM_ADDR_SPACE (x) != MEM_ADDR_SPACE (y))
 386     return 0;
 387
 388   /* Some RTL can be compared nonrecursively.  */
 389   switch (code)
 390     {
 391     case REG:
 392       return (REGNO (x) == REGNO (y));
 393
 394     case LABEL_REF:
 395       return XEXP (x, 0) == XEXP (y, 0);
 396
 397     case SYMBOL_REF:
 398       return XSTR (x, 0) == XSTR (y, 0);
 399
 400     case DEBUG_EXPR:
 401     case VALUE:
 402     case SCRATCH:
 403     case CONST_DOUBLE:
 404     case CONST_INT:
 405     case CONST_FIXED:
 406       return 0;
 407
 408     case DEBUG_IMPLICIT_PTR:
 409       return DEBUG_IMPLICIT_PTR_DECL (x)
 410              == DEBUG_IMPLICIT_PTR_DECL (y);
 411
 412     case DEBUG_PARAMETER_REF:
 413       return DEBUG_PARAMETER_REF_DECL (x)
 414              == DEBUG_PARAMETER_REF_DECL (x);
 415
 416     case ENTRY_VALUE:
 417       return rtx_equal_p_cb (ENTRY_VALUE_EXP (x), ENTRY_VALUE_EXP (y), cb);
 418
 419     default:
 420       break;
 421     }
 422
 423   /* Compare the elements.  If any pair of corresponding elements
 424      fail to match, return 0 for the whole thing.  */
 425
 426   fmt = GET_RTX_FORMAT (code);
 427   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
 428     {
 429       switch (fmt[i])
 430         {
 431         case 'w':
 432           if (XWINT (x, i) != XWINT (y, i))
 433             return 0;
 434           break;
 435
 436         case 'n':
 437         case 'i':
 438           if (XINT (x, i) != XINT (y, i))
 439             {
 440 #ifndef GENERATOR_FILE
 441               if (((code == ASM_OPERANDS && i == 6)
 442                    || (code == ASM_INPUT && i == 1))
 443                   && locator_eq (XINT (x, i), XINT (y, i)))
 444                 break;
 445 #endif
 446               return 0;
 447             }
 448           break;
 449
 450         case 'V':
 451         case 'E':
 452           /* Two vectors must have the same length.  */
 453           if (XVECLEN (x, i) != XVECLEN (y, i))
 454             return 0;
 455
 456           /* And the corresponding elements must match.  */
 457           for (j = 0; j < XVECLEN (x, i); j++)
 458             if (rtx_equal_p_cb (XVECEXP (x, i, j),
 459                                 XVECEXP (y, i, j), cb) == 0)
 460               return 0;
 461           break;
 462
 463         case 'e':
 464           if (rtx_equal_p_cb (XEXP (x, i), XEXP (y, i), cb) == 0)
 465             return 0;
 466           break;
 467
 468         case 'S':
 469         case 's':
 470           if ((XSTR (x, i) || XSTR (y, i))
 471               && (! XSTR (x, i) || ! XSTR (y, i)
 472                   || strcmp (XSTR (x, i), XSTR (y, i))))
 473             return 0;
 474           break;
 475
 476         case 'u':
 477           /* These are just backpointers, so they don't matter.  */
 478           break;
 479
 480         case '0':
 481         case 't':
 482           break;
 483
 484           /* It is believed that rtx's at this level will never
 485              contain anything but integers and other rtx's,
 486              except for within LABEL_REFs and SYMBOL_REFs.  */
 487         default:
 488           gcc_unreachable ();
 489         }
 490     }
 491   return 1;
 492 }
 493
 494 /* Return 1 if X and Y are identical-looking rtx's.
 495    This is the Lisp function EQUAL for rtx arguments.
 496    Whenever changing this function check if rtx_equal_p_cb above doesn't need
 497    changing as well.  */
 498
 499 int
 500 rtx_equal_p (const_rtx x, const_rtx y)
 501 {
 502   int i;
 503   int j;
 504   enum rtx_code code;
 505   const char *fmt;
 506
 507   if (x == y)
 508     return 1;
 509   if (x == 0 || y == 0)
 510     return 0;
 511
 512   code = GET_CODE (x);
 513   /* Rtx's of different codes cannot be equal.  */
 514   if (code != GET_CODE (y))
 515     return 0;
 516
 517   /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
 518      (REG:SI x) and (REG:HI x) are NOT equivalent.  */
 519
 520   if (GET_MODE (x) != GET_MODE (y))
 521     return 0;
 522
 523   /* MEMs referring to different address space are not equivalent.  */
 524   if (code == MEM && MEM_ADDR_SPACE (x) != MEM_ADDR_SPACE (y))
 525     return 0;
 526
 527   /* Some RTL can be compared nonrecursively.  */
 528   switch (code)
 529     {
 530     case REG:
 531       return (REGNO (x) == REGNO (y));
 532
 533     case LABEL_REF:
 534       return XEXP (x, 0) == XEXP (y, 0);
 535
 536     case SYMBOL_REF:
 537       return XSTR (x, 0) == XSTR (y, 0);
 538
 539     case DEBUG_EXPR:
 540     case VALUE:
 541     case SCRATCH:
 542     case CONST_DOUBLE:
 543     case CONST_INT:
 544     case CONST_FIXED:
 545       return 0;
 546
 547     case DEBUG_IMPLICIT_PTR:
 548       return DEBUG_IMPLICIT_PTR_DECL (x)
 549              == DEBUG_IMPLICIT_PTR_DECL (y);
 550
 551     case DEBUG_PARAMETER_REF:
 552       return DEBUG_PARAMETER_REF_DECL (x)
 553              == DEBUG_PARAMETER_REF_DECL (y);
 554
 555     case ENTRY_VALUE:
 556       return rtx_equal_p (ENTRY_VALUE_EXP (x), ENTRY_VALUE_EXP (y));
 557
 558     default:
 559       break;
 560     }
 561
 562   /* Compare the elements.  If any pair of corresponding elements
 563      fail to match, return 0 for the whole thing.  */
 564
 565   fmt = GET_RTX_FORMAT (code);
 566   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
 567     {
 568       switch (fmt[i])
 569         {
 570         case 'w':
 571           if (XWINT (x, i) != XWINT (y, i))
 572             return 0;
 573           break;
 574
 575         case 'n':
 576         case 'i':
 577           if (XINT (x, i) != XINT (y, i))
 578             {
 579 #ifndef GENERATOR_FILE
 580               if (((code == ASM_OPERANDS && i == 6)
 581                    || (code == ASM_INPUT && i == 1))
 582                   && locator_eq (XINT (x, i), XINT (y, i)))
 583                 break;
 584 #endif
 585               return 0;
 586             }
 587           break;
 588
 589         case 'V':
 590         case 'E':
 591           /* Two vectors must have the same length.  */
 592           if (XVECLEN (x, i) != XVECLEN (y, i))
 593             return 0;
 594
 595           /* And the corresponding elements must match.  */
 596           for (j = 0; j < XVECLEN (x, i); j++)
 597             if (rtx_equal_p (XVECEXP (x, i, j),  XVECEXP (y, i, j)) == 0)
 598               return 0;
 599           break;
 600
 601         case 'e':
 602           if (rtx_equal_p (XEXP (x, i), XEXP (y, i)) == 0)
 603             return 0;
 604           break;
 605
 606         case 'S':
 607         case 's':
 608           if ((XSTR (x, i) || XSTR (y, i))
 609               && (! XSTR (x, i) || ! XSTR (y, i)
 610                   || strcmp (XSTR (x, i), XSTR (y, i))))
 611             return 0;
 612           break;
 613
 614         case 'u':
 615           /* These are just backpointers, so they don't matter.  */
 616           break;
 617
 618         case '0':
 619         case 't':
 620           break;
 621
 622           /* It is believed that rtx's at this level will never
 623              contain anything but integers and other rtx's,
 624              except for within LABEL_REFs and SYMBOL_REFs.  */
 625         default:
 626           gcc_unreachable ();
 627         }
 628     }
 629   return 1;
 630 }
 631
 632 /* Iteratively hash rtx X.  */
 633
 634 hashval_t
 635 iterative_hash_rtx (const_rtx x, hashval_t hash)
 636 {
 637   enum rtx_code code;
 638   enum machine_mode mode;
 639   int i, j;
 640   const char *fmt;
 641
 642   if (x == NULL_RTX)
 643     return hash;
 644   code = GET_CODE (x);
 645   hash = iterative_hash_object (code, hash);
 646   mode = GET_MODE (x);
 647   hash = iterative_hash_object (mode, hash);
 648   switch (code)
 649     {
 650     case REG:
 651       i = REGNO (x);
 652       return iterative_hash_object (i, hash);
 653     case CONST_INT:
 654       return iterative_hash_object (INTVAL (x), hash);
 655     case SYMBOL_REF:
 656       if (XSTR (x, 0))
 657         return iterative_hash (XSTR (x, 0), strlen (XSTR (x, 0)) + 1,
 658                                hash);
 659       return hash;
 660     case LABEL_REF:
 661     case DEBUG_EXPR:
 662     case VALUE:
 663     case SCRATCH:
 664     case CONST_DOUBLE:
 665     case CONST_FIXED:
 666     case DEBUG_IMPLICIT_PTR:
 667     case DEBUG_PARAMETER_REF:
 668       return hash;
 669     default:
 670       break;
 671     }
 672
 673   fmt = GET_RTX_FORMAT (code);
 674   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
 675     switch (fmt[i])
 676       {
 677       case 'w':
 678         hash = iterative_hash_object (XWINT (x, i), hash);
 679         break;
 680       case 'n':
 681       case 'i':
 682         hash = iterative_hash_object (XINT (x, i), hash);
 683         break;
 684       case 'V':
 685       case 'E':
 686         j = XVECLEN (x, i);
 687         hash = iterative_hash_object (j, hash);
 688         for (j = 0; j < XVECLEN (x, i); j++)
 689           hash = iterative_hash_rtx (XVECEXP (x, i, j), hash);
 690         break;
 691       case 'e':
 692         hash = iterative_hash_rtx (XEXP (x, i), hash);
 693         break;
 694       case 'S':
 695       case 's':
 696         if (XSTR (x, i))
 697           hash = iterative_hash (XSTR (x, 0), strlen (XSTR (x, 0)) + 1,
 698                                  hash);
 699         break;
 700       default:
 701         break;
 702       }
 703   return hash;
 704 }
 705
 706 void
 707 dump_rtx_statistics (void)
 708 {
 709   int i;
 710   int total_counts = 0;
 711   int total_sizes = 0;
 712
 713   if (! GATHER_STATISTICS)
 714     {
 715       fprintf (stderr, "No RTX statistics\n");
 716       return;
 717     }
 718
 719   fprintf (stderr, "\nRTX Kind               Count      Bytes\n");
 720   fprintf (stderr, "---------------------------------------\n");
 721   for (i = 0; i < LAST_AND_UNUSED_RTX_CODE; i++)
 722     if (rtx_alloc_counts[i])
 723       {
 724         fprintf (stderr, "%-20s %7d %10d\n", GET_RTX_NAME (i),
 725                  rtx_alloc_counts[i], rtx_alloc_sizes[i]);
 726         total_counts += rtx_alloc_counts[i];
 727         total_sizes += rtx_alloc_sizes[i];
 728       }
 729   if (rtvec_alloc_counts)
 730     {
 731       fprintf (stderr, "%-20s %7d %10d\n", "rtvec",
 732                rtvec_alloc_counts, rtvec_alloc_sizes);
 733       total_counts += rtvec_alloc_counts;
 734       total_sizes += rtvec_alloc_sizes;
 735     }
 736   fprintf (stderr, "---------------------------------------\n");
 737   fprintf (stderr, "%-20s %7d %10d\n",
 738            "Total", total_counts, total_sizes);
 739   fprintf (stderr, "---------------------------------------\n");
 740 }
 741 \f
 742 #if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007)
 743 void
 744 rtl_check_failed_bounds (const_rtx r, int n, const char *file, int line,
 745                          const char *func)
 746 {
 747   internal_error
 748     ("RTL check: access of elt %d of '%s' with last elt %d in %s, at %s:%d",
 749      n, GET_RTX_NAME (GET_CODE (r)), GET_RTX_LENGTH (GET_CODE (r)) - 1,
 750      func, trim_filename (file), line);
 751 }
 752
 753 void
 754 rtl_check_failed_type1 (const_rtx r, int n, int c1, const char *file, int line,
 755                         const char *func)
 756 {
 757   internal_error
 758     ("RTL check: expected elt %d type '%c', have '%c' (rtx %s) in %s, at %s:%d",
 759      n, c1, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
 760      func, trim_filename (file), line);
 761 }
 762
 763 void
 764 rtl_check_failed_type2 (const_rtx r, int n, int c1, int c2, const char *file,
 765                         int line, const char *func)
 766 {
 767   internal_error
 768     ("RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s) in %s, at %s:%d",
 769      n, c1, c2, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
 770      func, trim_filename (file), line);
 771 }
 772
 773 void
 774 rtl_check_failed_code1 (const_rtx r, enum rtx_code code, const char *file,
 775                         int line, const char *func)
 776 {
 777   internal_error ("RTL check: expected code '%s', have '%s' in %s, at %s:%d",
 778                   GET_RTX_NAME (code), GET_RTX_NAME (GET_CODE (r)), func,
 779                   trim_filename (file), line);
 780 }
 781
 782 void
 783 rtl_check_failed_code2 (const_rtx r, enum rtx_code code1, enum rtx_code code2,
 784                         const char *file, int line, const char *func)
 785 {
 786   internal_error
 787     ("RTL check: expected code '%s' or '%s', have '%s' in %s, at %s:%d",
 788      GET_RTX_NAME (code1), GET_RTX_NAME (code2), GET_RTX_NAME (GET_CODE (r)),
 789      func, trim_filename (file), line);
 790 }
 791
 792 void
 793 rtl_check_failed_code_mode (const_rtx r, enum rtx_code code, enum machine_mode mode,
 794                             bool not_mode, const char *file, int line,
 795                             const char *func)
 796 {
 797   internal_error ((not_mode
 798                    ? ("RTL check: expected code '%s' and not mode '%s', "
 799                       "have code '%s' and mode '%s' in %s, at %s:%d")
 800                    : ("RTL check: expected code '%s' and mode '%s', "
 801                       "have code '%s' and mode '%s' in %s, at %s:%d")),
 802                   GET_RTX_NAME (code), GET_MODE_NAME (mode),
 803                   GET_RTX_NAME (GET_CODE (r)), GET_MODE_NAME (GET_MODE (r)),
 804                   func, trim_filename (file), line);
 805 }
 806
 807 /* Report that line LINE of FILE tried to access the block symbol fields
 808    of a non-block symbol.  FUNC is the function that contains the line.  */
 809
 810 void
 811 rtl_check_failed_block_symbol (const char *file, int line, const char *func)
 812 {
 813   internal_error
 814     ("RTL check: attempt to treat non-block symbol as a block symbol "
 815      "in %s, at %s:%d", func, trim_filename (file), line);
 816 }
 817
 818 /* XXX Maybe print the vector?  */
 819 void
 820 rtvec_check_failed_bounds (const_rtvec r, int n, const char *file, int line,
 821                            const char *func)
 822 {
 823   internal_error
 824     ("RTL check: access of elt %d of vector with last elt %d in %s, at %s:%d",
 825      n, GET_NUM_ELEM (r) - 1, func, trim_filename (file), line);
 826 }
 827 #endif /* ENABLE_RTL_CHECKING */
 828
 829 #if defined ENABLE_RTL_FLAG_CHECKING
 830 void
 831 rtl_check_failed_flag (const char *name, const_rtx r, const char *file,
 832                        int line, const char *func)
 833 {
 834   internal_error
 835     ("RTL flag check: %s used with unexpected rtx code '%s' in %s, at %s:%d",
 836      name, GET_RTX_NAME (GET_CODE (r)), func, trim_filename (file), line);
 837 }
 838 #endif /* ENABLE_RTL_FLAG_CHECKING */