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 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 refering 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 ENTRY_VALUE:
 552       return rtx_equal_p (ENTRY_VALUE_EXP (x), ENTRY_VALUE_EXP (y));
 553
 554     default:
 555       break;
 556     }
 557
 558   /* Compare the elements.  If any pair of corresponding elements
 559      fail to match, return 0 for the whole thing.  */
 560
 561   fmt = GET_RTX_FORMAT (code);
 562   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
 563     {
 564       switch (fmt[i])
 565         {
 566         case 'w':
 567           if (XWINT (x, i) != XWINT (y, i))
 568             return 0;
 569           break;
 570
 571         case 'n':
 572         case 'i':
 573           if (XINT (x, i) != XINT (y, i))
 574             {
 575 #ifndef GENERATOR_FILE
 576               if (((code == ASM_OPERANDS && i == 6)
 577                    || (code == ASM_INPUT && i == 1))
 578                   && locator_eq (XINT (x, i), XINT (y, i)))
 579                 break;
 580 #endif
 581               return 0;
 582             }
 583           break;
 584
 585         case 'V':
 586         case 'E':
 587           /* Two vectors must have the same length.  */
 588           if (XVECLEN (x, i) != XVECLEN (y, i))
 589             return 0;
 590
 591           /* And the corresponding elements must match.  */
 592           for (j = 0; j < XVECLEN (x, i); j++)
 593             if (rtx_equal_p (XVECEXP (x, i, j),  XVECEXP (y, i, j)) == 0)
 594               return 0;
 595           break;
 596
 597         case 'e':
 598           if (rtx_equal_p (XEXP (x, i), XEXP (y, i)) == 0)
 599             return 0;
 600           break;
 601
 602         case 'S':
 603         case 's':
 604           if ((XSTR (x, i) || XSTR (y, i))
 605               && (! XSTR (x, i) || ! XSTR (y, i)
 606                   || strcmp (XSTR (x, i), XSTR (y, i))))
 607             return 0;
 608           break;
 609
 610         case 'u':
 611           /* These are just backpointers, so they don't matter.  */
 612           break;
 613
 614         case '0':
 615         case 't':
 616           break;
 617
 618           /* It is believed that rtx's at this level will never
 619              contain anything but integers and other rtx's,
 620              except for within LABEL_REFs and SYMBOL_REFs.  */
 621         default:
 622           gcc_unreachable ();
 623         }
 624     }
 625   return 1;
 626 }
 627
 628 /* Iteratively hash rtx X.  */
 629
 630 hashval_t
 631 iterative_hash_rtx (const_rtx x, hashval_t hash)
 632 {
 633   enum rtx_code code;
 634   enum machine_mode mode;
 635   int i, j;
 636   const char *fmt;
 637
 638   if (x == NULL_RTX)
 639     return hash;
 640   code = GET_CODE (x);
 641   hash = iterative_hash_object (code, hash);
 642   mode = GET_MODE (x);
 643   hash = iterative_hash_object (mode, hash);
 644   switch (code)
 645     {
 646     case REG:
 647       i = REGNO (x);
 648       return iterative_hash_object (i, hash);
 649     case CONST_INT:
 650       return iterative_hash_object (INTVAL (x), hash);
 651     case SYMBOL_REF:
 652       if (XSTR (x, 0))
 653         return iterative_hash (XSTR (x, 0), strlen (XSTR (x, 0)) + 1,
 654                                hash);
 655       return hash;
 656     case LABEL_REF:
 657     case DEBUG_EXPR:
 658     case VALUE:
 659     case SCRATCH:
 660     case CONST_DOUBLE:
 661     case CONST_FIXED:
 662     case DEBUG_IMPLICIT_PTR:
 663       return hash;
 664     default:
 665       break;
 666     }
 667
 668   fmt = GET_RTX_FORMAT (code);
 669   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
 670     switch (fmt[i])
 671       {
 672       case 'w':
 673         hash = iterative_hash_object (XWINT (x, i), hash);
 674         break;
 675       case 'n':
 676       case 'i':
 677         hash = iterative_hash_object (XINT (x, i), hash);
 678         break;
 679       case 'V':
 680       case 'E':
 681         j = XVECLEN (x, i);
 682         hash = iterative_hash_object (j, hash);
 683         for (j = 0; j < XVECLEN (x, i); j++)
 684           hash = iterative_hash_rtx (XVECEXP (x, i, j), hash);
 685         break;
 686       case 'e':
 687         hash = iterative_hash_rtx (XEXP (x, i), hash);
 688         break;
 689       case 'S':
 690       case 's':
 691         if (XSTR (x, i))
 692           hash = iterative_hash (XSTR (x, 0), strlen (XSTR (x, 0)) + 1,
 693                                  hash);
 694         break;
 695       default:
 696         break;
 697       }
 698   return hash;
 699 }
 700
 701 void
 702 dump_rtx_statistics (void)
 703 {
 704 #ifdef GATHER_STATISTICS
 705   int i;
 706   int total_counts = 0;
 707   int total_sizes = 0;
 708   fprintf (stderr, "\nRTX Kind               Count      Bytes\n");
 709   fprintf (stderr, "---------------------------------------\n");
 710   for (i = 0; i < LAST_AND_UNUSED_RTX_CODE; i++)
 711     if (rtx_alloc_counts[i])
 712       {
 713         fprintf (stderr, "%-20s %7d %10d\n", GET_RTX_NAME (i),
 714                  rtx_alloc_counts[i], rtx_alloc_sizes[i]);
 715         total_counts += rtx_alloc_counts[i];
 716         total_sizes += rtx_alloc_sizes[i];
 717       }
 718   if (rtvec_alloc_counts)
 719     {
 720       fprintf (stderr, "%-20s %7d %10d\n", "rtvec",
 721                rtvec_alloc_counts, rtvec_alloc_sizes);
 722       total_counts += rtvec_alloc_counts;
 723       total_sizes += rtvec_alloc_sizes;
 724     }
 725   fprintf (stderr, "---------------------------------------\n");
 726   fprintf (stderr, "%-20s %7d %10d\n",
 727            "Total", total_counts, total_sizes);
 728   fprintf (stderr, "---------------------------------------\n");
 729 #endif
 730 }
 731 \f
 732 #if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007)
 733 void
 734 rtl_check_failed_bounds (const_rtx r, int n, const char *file, int line,
 735                          const char *func)
 736 {
 737   internal_error
 738     ("RTL check: access of elt %d of '%s' with last elt %d in %s, at %s:%d",
 739      n, GET_RTX_NAME (GET_CODE (r)), GET_RTX_LENGTH (GET_CODE (r)) - 1,
 740      func, trim_filename (file), line);
 741 }
 742
 743 void
 744 rtl_check_failed_type1 (const_rtx r, int n, int c1, const char *file, int line,
 745                         const char *func)
 746 {
 747   internal_error
 748     ("RTL check: expected elt %d type '%c', have '%c' (rtx %s) in %s, at %s:%d",
 749      n, c1, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
 750      func, trim_filename (file), line);
 751 }
 752
 753 void
 754 rtl_check_failed_type2 (const_rtx r, int n, int c1, int c2, const char *file,
 755                         int line, const char *func)
 756 {
 757   internal_error
 758     ("RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s) in %s, at %s:%d",
 759      n, c1, c2, 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_code1 (const_rtx r, enum rtx_code code, const char *file,
 765                         int line, const char *func)
 766 {
 767   internal_error ("RTL check: expected code '%s', have '%s' in %s, at %s:%d",
 768                   GET_RTX_NAME (code), GET_RTX_NAME (GET_CODE (r)), func,
 769                   trim_filename (file), line);
 770 }
 771
 772 void
 773 rtl_check_failed_code2 (const_rtx r, enum rtx_code code1, enum rtx_code code2,
 774                         const char *file, int line, const char *func)
 775 {
 776   internal_error
 777     ("RTL check: expected code '%s' or '%s', have '%s' in %s, at %s:%d",
 778      GET_RTX_NAME (code1), GET_RTX_NAME (code2), GET_RTX_NAME (GET_CODE (r)),
 779      func, trim_filename (file), line);
 780 }
 781
 782 void
 783 rtl_check_failed_code_mode (const_rtx r, enum rtx_code code, enum machine_mode mode,
 784                             bool not_mode, const char *file, int line,
 785                             const char *func)
 786 {
 787   internal_error ((not_mode
 788                    ? ("RTL check: expected code '%s' and not mode '%s', "
 789                       "have code '%s' and mode '%s' in %s, at %s:%d")
 790                    : ("RTL check: expected code '%s' and mode '%s', "
 791                       "have code '%s' and mode '%s' in %s, at %s:%d")),
 792                   GET_RTX_NAME (code), GET_MODE_NAME (mode),
 793                   GET_RTX_NAME (GET_CODE (r)), GET_MODE_NAME (GET_MODE (r)),
 794                   func, trim_filename (file), line);
 795 }
 796
 797 /* Report that line LINE of FILE tried to access the block symbol fields
 798    of a non-block symbol.  FUNC is the function that contains the line.  */
 799
 800 void
 801 rtl_check_failed_block_symbol (const char *file, int line, const char *func)
 802 {
 803   internal_error
 804     ("RTL check: attempt to treat non-block symbol as a block symbol "
 805      "in %s, at %s:%d", func, trim_filename (file), line);
 806 }
 807
 808 /* XXX Maybe print the vector?  */
 809 void
 810 rtvec_check_failed_bounds (const_rtvec r, int n, const char *file, int line,
 811                            const char *func)
 812 {
 813   internal_error
 814     ("RTL check: access of elt %d of vector with last elt %d in %s, at %s:%d",
 815      n, GET_NUM_ELEM (r) - 1, func, trim_filename (file), line);
 816 }
 817 #endif /* ENABLE_RTL_CHECKING */
 818
 819 #if defined ENABLE_RTL_FLAG_CHECKING
 820 void
 821 rtl_check_failed_flag (const char *name, const_rtx r, const char *file,
 822                        int line, const char *func)
 823 {
 824   internal_error
 825     ("RTL flag check: %s used with unexpected rtx code '%s' in %s, at %s:%d",
 826      name, GET_RTX_NAME (GET_CODE (r)), func, trim_filename (file), line);
 827 }
 828 #endif /* ENABLE_RTL_FLAG_CHECKING */