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