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