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 #ifdef GATHER_STATISTICS
 139 static int rtx_alloc_counts[(int) LAST_AND_UNUSED_RTX_CODE];
 140 static int rtx_alloc_sizes[(int) LAST_AND_UNUSED_RTX_CODE];
 141 static int rtvec_alloc_counts;
 142 static int rtvec_alloc_sizes;
 143 #endif
 144
 145 \f
 146 /* Allocate an rtx vector of N elements.
 147    Store the length, and initialize all elements to zero.  */
 148
 149 rtvec
 150 rtvec_alloc (int n)
 151 {
 152   rtvec rt;
 153
 154   rt = ggc_alloc_rtvec_sized (n);
 155   /* Clear out the vector.  */
 156   memset (&rt->elem[0], 0, n * sizeof (rtx));
 157
 158   PUT_NUM_ELEM (rt, n);
 159
 160 #ifdef GATHER_STATISTICS
 161   rtvec_alloc_counts++;
 162   rtvec_alloc_sizes += n * sizeof (rtx);
 163 #endif
 164
 165   return rt;
 166 }
 167
 168 /* Create a bitwise copy of VEC.  */
 169
 170 rtvec
 171 shallow_copy_rtvec (rtvec vec)
 172 {
 173   rtvec newvec;
 174   int n;
 175
 176   n = GET_NUM_ELEM (vec);
 177   newvec = rtvec_alloc (n);
 178   memcpy (&newvec->elem[0], &vec->elem[0], sizeof (rtx) * n);
 179   return newvec;
 180 }
 181
 182 /* Return the number of bytes occupied by rtx value X.  */
 183
 184 unsigned int
 185 rtx_size (const_rtx x)
 186 {
 187   if (GET_CODE (x) == SYMBOL_REF && SYMBOL_REF_HAS_BLOCK_INFO_P (x))
 188     return RTX_HDR_SIZE + sizeof (struct block_symbol);
 189   return RTX_CODE_SIZE (GET_CODE (x));
 190 }
 191
 192 /* Allocate an rtx of code CODE.  The CODE is stored in the rtx;
 193    all the rest is initialized to zero.  */
 194
 195 rtx
 196 rtx_alloc_stat (RTX_CODE code MEM_STAT_DECL)
 197 {
 198   rtx rt = ggc_alloc_zone_rtx_def_stat (&rtl_zone, RTX_CODE_SIZE (code)
 199                                         PASS_MEM_STAT);
 200
 201   /* We want to clear everything up to the FLD array.  Normally, this
 202      is one int, but we don't want to assume that and it isn't very
 203      portable anyway; this is.  */
 204
 205   memset (rt, 0, RTX_HDR_SIZE);
 206   PUT_CODE (rt, code);
 207
 208 #ifdef GATHER_STATISTICS
 209   rtx_alloc_counts[code]++;
 210   rtx_alloc_sizes[code] += RTX_CODE_SIZE (code);
 211 #endif
 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 #ifdef GATHER_STATISTICS
 710   int i;
 711   int total_counts = 0;
 712   int total_sizes = 0;
 713   fprintf (stderr, "\nRTX Kind               Count      Bytes\n");
 714   fprintf (stderr, "---------------------------------------\n");
 715   for (i = 0; i < LAST_AND_UNUSED_RTX_CODE; i++)
 716     if (rtx_alloc_counts[i])
 717       {
 718         fprintf (stderr, "%-20s %7d %10d\n", GET_RTX_NAME (i),
 719                  rtx_alloc_counts[i], rtx_alloc_sizes[i]);
 720         total_counts += rtx_alloc_counts[i];
 721         total_sizes += rtx_alloc_sizes[i];
 722       }
 723   if (rtvec_alloc_counts)
 724     {
 725       fprintf (stderr, "%-20s %7d %10d\n", "rtvec",
 726                rtvec_alloc_counts, rtvec_alloc_sizes);
 727       total_counts += rtvec_alloc_counts;
 728       total_sizes += rtvec_alloc_sizes;
 729     }
 730   fprintf (stderr, "---------------------------------------\n");
 731   fprintf (stderr, "%-20s %7d %10d\n",
 732            "Total", total_counts, total_sizes);
 733   fprintf (stderr, "---------------------------------------\n");
 734 #endif
 735 }
 736 \f
 737 #if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007)
 738 void
 739 rtl_check_failed_bounds (const_rtx r, int n, const char *file, int line,
 740                          const char *func)
 741 {
 742   internal_error
 743     ("RTL check: access of elt %d of '%s' with last elt %d in %s, at %s:%d",
 744      n, GET_RTX_NAME (GET_CODE (r)), GET_RTX_LENGTH (GET_CODE (r)) - 1,
 745      func, trim_filename (file), line);
 746 }
 747
 748 void
 749 rtl_check_failed_type1 (const_rtx r, int n, int c1, const char *file, int line,
 750                         const char *func)
 751 {
 752   internal_error
 753     ("RTL check: expected elt %d type '%c', have '%c' (rtx %s) in %s, at %s:%d",
 754      n, c1, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
 755      func, trim_filename (file), line);
 756 }
 757
 758 void
 759 rtl_check_failed_type2 (const_rtx r, int n, int c1, int c2, const char *file,
 760                         int line, const char *func)
 761 {
 762   internal_error
 763     ("RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s) in %s, at %s:%d",
 764      n, c1, c2, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
 765      func, trim_filename (file), line);
 766 }
 767
 768 void
 769 rtl_check_failed_code1 (const_rtx r, enum rtx_code code, const char *file,
 770                         int line, const char *func)
 771 {
 772   internal_error ("RTL check: expected code '%s', have '%s' in %s, at %s:%d",
 773                   GET_RTX_NAME (code), GET_RTX_NAME (GET_CODE (r)), func,
 774                   trim_filename (file), line);
 775 }
 776
 777 void
 778 rtl_check_failed_code2 (const_rtx r, enum rtx_code code1, enum rtx_code code2,
 779                         const char *file, int line, const char *func)
 780 {
 781   internal_error
 782     ("RTL check: expected code '%s' or '%s', have '%s' in %s, at %s:%d",
 783      GET_RTX_NAME (code1), GET_RTX_NAME (code2), GET_RTX_NAME (GET_CODE (r)),
 784      func, trim_filename (file), line);
 785 }
 786
 787 void
 788 rtl_check_failed_code_mode (const_rtx r, enum rtx_code code, enum machine_mode mode,
 789                             bool not_mode, const char *file, int line,
 790                             const char *func)
 791 {
 792   internal_error ((not_mode
 793                    ? ("RTL check: expected code '%s' and not mode '%s', "
 794                       "have code '%s' and mode '%s' in %s, at %s:%d")
 795                    : ("RTL check: expected code '%s' and mode '%s', "
 796                       "have code '%s' and mode '%s' in %s, at %s:%d")),
 797                   GET_RTX_NAME (code), GET_MODE_NAME (mode),
 798                   GET_RTX_NAME (GET_CODE (r)), GET_MODE_NAME (GET_MODE (r)),
 799                   func, trim_filename (file), line);
 800 }
 801
 802 /* Report that line LINE of FILE tried to access the block symbol fields
 803    of a non-block symbol.  FUNC is the function that contains the line.  */
 804
 805 void
 806 rtl_check_failed_block_symbol (const char *file, int line, const char *func)
 807 {
 808   internal_error
 809     ("RTL check: attempt to treat non-block symbol as a block symbol "
 810      "in %s, at %s:%d", func, trim_filename (file), line);
 811 }
 812
 813 /* XXX Maybe print the vector?  */
 814 void
 815 rtvec_check_failed_bounds (const_rtvec r, int n, const char *file, int line,
 816                            const char *func)
 817 {
 818   internal_error
 819     ("RTL check: access of elt %d of vector with last elt %d in %s, at %s:%d",
 820      n, GET_NUM_ELEM (r) - 1, func, trim_filename (file), line);
 821 }
 822 #endif /* ENABLE_RTL_CHECKING */
 823
 824 #if defined ENABLE_RTL_FLAG_CHECKING
 825 void
 826 rtl_check_failed_flag (const char *name, const_rtx r, const char *file,
 827                        int line, const char *func)
 828 {
 829   internal_error
 830     ("RTL flag check: %s used with unexpected rtx code '%s' in %s, at %s:%d",
 831      name, GET_RTX_NAME (GET_CODE (r)), func, trim_filename (file), line);
 832 }
 833 #endif /* ENABLE_RTL_FLAG_CHECKING */