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