gcc/rtl.c

   1 /* RTL utility routines.
   2    Copyright (C) 1987-2015 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify it under
   7 the terms of the GNU General Public License as published by the Free
   8 Software Foundation; either version 3, or (at your option) any later
   9 version.
  10
  11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GCC; see the file COPYING3.  If not see
  18 <http://www.gnu.org/licenses/>.  */
  19
  20 /* This file is compiled twice: once for the generator programs
  21    once for the compiler.  */
  22 #ifdef GENERATOR_FILE
  23 #include "bconfig.h"
  24 #else
  25 #include "config.h"
  26 #endif
  27
  28 #include "system.h"
  29 #include "coretypes.h"
  30 #include "tm.h"
  31 #include "rtl.h"
  32 #ifdef GENERATOR_FILE
  33 # include "errors.h"
  34 #else
  35 # include "rtlhash.h"
  36 # include "diagnostic-core.h"
  37 #endif
  38
  39 \f
  40 /* Indexed by rtx code, gives number of operands for an rtx with that code.
  41    Does NOT include rtx header data (code and links).  */
  42
  43 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS)   sizeof FORMAT - 1 ,
  44
  45 const unsigned char rtx_length[NUM_RTX_CODE] = {
  46 #include "rtl.def"
  47 };
  48
  49 #undef DEF_RTL_EXPR
  50
  51 /* Indexed by rtx code, gives the name of that kind of rtx, as a C string.  */
  52
  53 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS)   NAME ,
  54
  55 const char * const rtx_name[NUM_RTX_CODE] = {
  56 #include "rtl.def"              /* rtl expressions are documented here */
  57 };
  58
  59 #undef DEF_RTL_EXPR
  60
  61 /* Indexed by rtx code, gives a sequence of operand-types for
  62    rtx's of that code.  The sequence is a C string in which
  63    each character describes one operand.  */
  64
  65 const char * const rtx_format[NUM_RTX_CODE] = {
  66   /* "*" undefined.
  67          can cause a warning message
  68      "0" field is unused (or used in a phase-dependent manner)
  69          prints nothing
  70      "i" an integer
  71          prints the integer
  72      "n" like "i", but prints entries from `note_insn_name'
  73      "w" an integer of width HOST_BITS_PER_WIDE_INT
  74          prints the integer
  75      "s" a pointer to a string
  76          prints the string
  77      "S" like "s", but optional:
  78          the containing rtx may end before this operand
  79      "T" like "s", but treated specially by the RTL reader;
  80          only found in machine description patterns.
  81      "e" a pointer to an rtl expression
  82          prints the expression
  83      "E" a pointer to a vector that points to a number of rtl expressions
  84          prints a list of the rtl expressions
  85      "V" like "E", but optional:
  86          the containing rtx may end before this operand
  87      "u" a pointer to another insn
  88          prints the uid of the insn.
  89      "b" is a pointer to a bitmap header.
  90      "B" is a basic block pointer.
  91      "t" is a tree pointer.
  92      "r" a register.  */
  93
  94 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS)   FORMAT ,
  95 #include "rtl.def"              /* rtl expressions are defined here */
  96 #undef DEF_RTL_EXPR
  97 };
  98
  99 /* Indexed by rtx code, gives a character representing the "class" of
 100    that rtx code.  See rtl.def for documentation on the defined classes.  */
 101
 102 const enum rtx_class rtx_class[NUM_RTX_CODE] = {
 103 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS)   CLASS,
 104 #include "rtl.def"              /* rtl expressions are defined here */
 105 #undef DEF_RTL_EXPR
 106 };
 107
 108 /* Indexed by rtx code, gives the size of the rtx in bytes.  */
 109
 110 const unsigned char rtx_code_size[NUM_RTX_CODE] = {
 111 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS)                         \
 112   (((ENUM) == CONST_INT || (ENUM) == CONST_DOUBLE                       \
 113     || (ENUM) == CONST_FIXED || (ENUM) == CONST_WIDE_INT)               \
 114    ? RTX_HDR_SIZE + (sizeof FORMAT - 1) * sizeof (HOST_WIDE_INT)        \
 115    : (ENUM) == REG                                                      \
 116    ? RTX_HDR_SIZE + sizeof (reg_info)                                   \
 117    : RTX_HDR_SIZE + (sizeof FORMAT - 1) * sizeof (rtunion)),
 118
 119 #include "rtl.def"
 120 #undef DEF_RTL_EXPR
 121 };
 122
 123 /* Names for kinds of NOTEs and REG_NOTEs.  */
 124
 125 const char * const note_insn_name[NOTE_INSN_MAX] =
 126 {
 127 #define DEF_INSN_NOTE(NAME) #NAME,
 128 #include "insn-notes.def"
 129 #undef DEF_INSN_NOTE
 130 };
 131
 132 const char * const reg_note_name[REG_NOTE_MAX] =
 133 {
 134 #define DEF_REG_NOTE(NAME) #NAME,
 135 #include "reg-notes.def"
 136 #undef DEF_REG_NOTE
 137 };
 138
 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
 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   if (GATHER_STATISTICS)
 160     {
 161       rtvec_alloc_counts++;
 162       rtvec_alloc_sizes += n * sizeof (rtx);
 163     }
 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 (CONST_WIDE_INT_P (x))
 188     return (RTX_HDR_SIZE
 189             + sizeof (struct hwivec_def)
 190             + ((CONST_WIDE_INT_NUNITS (x) - 1)
 191                * sizeof (HOST_WIDE_INT)));
 192   if (GET_CODE (x) == SYMBOL_REF && SYMBOL_REF_HAS_BLOCK_INFO_P (x))
 193     return RTX_HDR_SIZE + sizeof (struct block_symbol);
 194   return RTX_CODE_SIZE (GET_CODE (x));
 195 }
 196
 197 /* Allocate an rtx of code CODE with EXTRA bytes in it.  The CODE is
 198    stored in the rtx; all the rest is initialized to zero.  */
 199
 200 rtx
 201 rtx_alloc_stat_v (RTX_CODE code MEM_STAT_DECL, int extra)
 202 {
 203   rtx rt = ggc_alloc_rtx_def_stat (RTX_CODE_SIZE (code) + extra
 204                                    PASS_MEM_STAT);
 205
 206   /* We want to clear everything up to the FLD array.  Normally, this
 207      is one int, but we don't want to assume that and it isn't very
 208      portable anyway; this is.  */
 209
 210   memset (rt, 0, RTX_HDR_SIZE);
 211   PUT_CODE (rt, code);
 212
 213   if (GATHER_STATISTICS)
 214     {
 215       rtx_alloc_counts[code]++;
 216       rtx_alloc_sizes[code] += RTX_CODE_SIZE (code);
 217     }
 218
 219   return rt;
 220 }
 221
 222 /* Allocate an rtx of code CODE.  The CODE is stored in the rtx;
 223    all the rest is initialized to zero.  */
 224
 225 rtx
 226 rtx_alloc_stat (RTX_CODE code MEM_STAT_DECL)
 227 {
 228   return rtx_alloc_stat_v (code PASS_MEM_STAT, 0);
 229 }
 230
 231 /* Write the wide constant X to OUTFILE.  */
 232
 233 void
 234 cwi_output_hex (FILE *outfile, const_rtx x)
 235 {
 236   int i = CWI_GET_NUM_ELEM (x);
 237   gcc_assert (i > 0);
 238   if (CWI_ELT (x, i - 1) == 0)
 239     /* The HOST_WIDE_INT_PRINT_HEX prepends a 0x only if the val is
 240        non zero.  We want all numbers to have a 0x prefix.  */
 241     fprintf (outfile, "0x");
 242   fprintf (outfile, HOST_WIDE_INT_PRINT_HEX, CWI_ELT (x, --i));
 243   while (--i >= 0)
 244     fprintf (outfile, HOST_WIDE_INT_PRINT_PADDED_HEX, CWI_ELT (x, i));
 245 }
 246
 247 \f
 248 /* Return true if ORIG is a sharable CONST.  */
 249
 250 bool
 251 shared_const_p (const_rtx orig)
 252 {
 253   gcc_assert (GET_CODE (orig) == CONST);
 254
 255   /* CONST can be shared if it contains a SYMBOL_REF.  If it contains
 256      a LABEL_REF, it isn't sharable.  */
 257   return (GET_CODE (XEXP (orig, 0)) == PLUS
 258           && GET_CODE (XEXP (XEXP (orig, 0), 0)) == SYMBOL_REF
 259           && CONST_INT_P (XEXP (XEXP (orig, 0), 1)));
 260 }
 261
 262
 263 /* Create a new copy of an rtx.
 264    Recursively copies the operands of the rtx,
 265    except for those few rtx codes that are sharable.  */
 266
 267 rtx
 268 copy_rtx (rtx orig)
 269 {
 270   rtx copy;
 271   int i, j;
 272   RTX_CODE code;
 273   const char *format_ptr;
 274
 275   code = GET_CODE (orig);
 276
 277   switch (code)
 278     {
 279     case REG:
 280     case DEBUG_EXPR:
 281     case VALUE:
 282     CASE_CONST_ANY:
 283     case SYMBOL_REF:
 284     case CODE_LABEL:
 285     case PC:
 286     case CC0:
 287     case RETURN:
 288     case SIMPLE_RETURN:
 289     case SCRATCH:
 290       /* SCRATCH must be shared because they represent distinct values.  */
 291       return orig;
 292     case CLOBBER:
 293       /* Share clobbers of hard registers (like cc0), but do not share pseudo reg
 294          clobbers or clobbers of hard registers that originated as pseudos.
 295          This is needed to allow safe register renaming.  */
 296       if (REG_P (XEXP (orig, 0)) && REGNO (XEXP (orig, 0)) < FIRST_PSEUDO_REGISTER
 297           && ORIGINAL_REGNO (XEXP (orig, 0)) == REGNO (XEXP (orig, 0)))
 298         return orig;
 299       break;
 300
 301     case CONST:
 302       if (shared_const_p (orig))
 303         return orig;
 304       break;
 305
 306       /* A MEM with a constant address is not sharable.  The problem is that
 307          the constant address may need to be reloaded.  If the mem is shared,
 308          then reloading one copy of this mem will cause all copies to appear
 309          to have been reloaded.  */
 310
 311     default:
 312       break;
 313     }
 314
 315   /* Copy the various flags, fields, and other information.  We assume
 316      that all fields need copying, and then clear the fields that should
 317      not be copied.  That is the sensible default behavior, and forces
 318      us to explicitly document why we are *not* copying a flag.  */
 319   copy = shallow_copy_rtx (orig);
 320
 321   /* We do not copy the USED flag, which is used as a mark bit during
 322      walks over the RTL.  */
 323   RTX_FLAG (copy, used) = 0;
 324
 325   format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
 326
 327   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
 328     switch (*format_ptr++)
 329       {
 330       case 'e':
 331         if (XEXP (orig, i) != NULL)
 332           XEXP (copy, i) = copy_rtx (XEXP (orig, i));
 333         break;
 334
 335       case 'E':
 336       case 'V':
 337         if (XVEC (orig, i) != NULL)
 338           {
 339             XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
 340             for (j = 0; j < XVECLEN (copy, i); j++)
 341               XVECEXP (copy, i, j) = copy_rtx (XVECEXP (orig, i, j));
 342           }
 343         break;
 344
 345       case 't':
 346       case 'w':
 347       case 'i':
 348       case 's':
 349       case 'S':
 350       case 'T':
 351       case 'u':
 352       case 'B':
 353       case '0':
 354         /* These are left unchanged.  */
 355         break;
 356
 357       default:
 358         gcc_unreachable ();
 359       }
 360   return copy;
 361 }
 362
 363 /* Create a new copy of an rtx.  Only copy just one level.  */
 364
 365 rtx
 366 shallow_copy_rtx_stat (const_rtx orig MEM_STAT_DECL)
 367 {
 368   const unsigned int size = rtx_size (orig);
 369   rtx const copy = ggc_alloc_rtx_def_stat (size PASS_MEM_STAT);
 370   return (rtx) memcpy (copy, orig, size);
 371 }
 372 \f
 373 /* Nonzero when we are generating CONCATs.  */
 374 int generating_concat_p;
 375
 376 /* Nonzero when we are expanding trees to RTL.  */
 377 int currently_expanding_to_rtl;
 378
 379 \f
 380
 381 /* Same as rtx_equal_p, but call CB on each pair of rtx if CB is not NULL.
 382    When the callback returns true, we continue with the new pair.
 383    Whenever changing this function check if rtx_equal_p below doesn't need
 384    changing as well.  */
 385
 386 int
 387 rtx_equal_p_cb (const_rtx x, const_rtx y, rtx_equal_p_callback_function cb)
 388 {
 389   int i;
 390   int j;
 391   enum rtx_code code;
 392   const char *fmt;
 393   rtx nx, ny;
 394
 395   if (x == y)
 396     return 1;
 397   if (x == 0 || y == 0)
 398     return 0;
 399
 400   /* Invoke the callback first.  */
 401   if (cb != NULL
 402       && ((*cb) (&x, &y, &nx, &ny)))
 403     return rtx_equal_p_cb (nx, ny, cb);
 404
 405   code = GET_CODE (x);
 406   /* Rtx's of different codes cannot be equal.  */
 407   if (code != GET_CODE (y))
 408     return 0;
 409
 410   /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
 411      (REG:SI x) and (REG:HI x) are NOT equivalent.  */
 412
 413   if (GET_MODE (x) != GET_MODE (y))
 414     return 0;
 415
 416   /* MEMs referring to different address space are not equivalent.  */
 417   if (code == MEM && MEM_ADDR_SPACE (x) != MEM_ADDR_SPACE (y))
 418     return 0;
 419
 420   /* Some RTL can be compared nonrecursively.  */
 421   switch (code)
 422     {
 423     case REG:
 424       return (REGNO (x) == REGNO (y));
 425
 426     case LABEL_REF:
 427       return LABEL_REF_LABEL (x) == LABEL_REF_LABEL (y);
 428
 429     case SYMBOL_REF:
 430       return XSTR (x, 0) == XSTR (y, 0);
 431
 432     case DEBUG_EXPR:
 433     case VALUE:
 434     case SCRATCH:
 435     CASE_CONST_UNIQUE:
 436       return 0;
 437
 438     case DEBUG_IMPLICIT_PTR:
 439       return DEBUG_IMPLICIT_PTR_DECL (x)
 440              == DEBUG_IMPLICIT_PTR_DECL (y);
 441
 442     case DEBUG_PARAMETER_REF:
 443       return DEBUG_PARAMETER_REF_DECL (x)
 444              == DEBUG_PARAMETER_REF_DECL (x);
 445
 446     case ENTRY_VALUE:
 447       return rtx_equal_p_cb (ENTRY_VALUE_EXP (x), ENTRY_VALUE_EXP (y), cb);
 448
 449     default:
 450       break;
 451     }
 452
 453   /* Compare the elements.  If any pair of corresponding elements
 454      fail to match, return 0 for the whole thing.  */
 455
 456   fmt = GET_RTX_FORMAT (code);
 457   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
 458     {
 459       switch (fmt[i])
 460         {
 461         case 'w':
 462           if (XWINT (x, i) != XWINT (y, i))
 463             return 0;
 464           break;
 465
 466         case 'n':
 467         case 'i':
 468           if (XINT (x, i) != XINT (y, i))
 469             {
 470 #ifndef GENERATOR_FILE
 471               if (((code == ASM_OPERANDS && i == 6)
 472                    || (code == ASM_INPUT && i == 1))
 473                   && XINT (x, i) == XINT (y, i))
 474                 break;
 475 #endif
 476               return 0;
 477             }
 478           break;
 479
 480         case 'V':
 481         case 'E':
 482           /* Two vectors must have the same length.  */
 483           if (XVECLEN (x, i) != XVECLEN (y, i))
 484             return 0;
 485
 486           /* And the corresponding elements must match.  */
 487           for (j = 0; j < XVECLEN (x, i); j++)
 488             if (rtx_equal_p_cb (XVECEXP (x, i, j),
 489                                 XVECEXP (y, i, j), cb) == 0)
 490               return 0;
 491           break;
 492
 493         case 'e':
 494           if (rtx_equal_p_cb (XEXP (x, i), XEXP (y, i), cb) == 0)
 495             return 0;
 496           break;
 497
 498         case 'S':
 499         case 's':
 500           if ((XSTR (x, i) || XSTR (y, i))
 501               && (! XSTR (x, i) || ! XSTR (y, i)
 502                   || strcmp (XSTR (x, i), XSTR (y, i))))
 503             return 0;
 504           break;
 505
 506         case 'u':
 507           /* These are just backpointers, so they don't matter.  */
 508           break;
 509
 510         case '0':
 511         case 't':
 512           break;
 513
 514           /* It is believed that rtx's at this level will never
 515              contain anything but integers and other rtx's,
 516              except for within LABEL_REFs and SYMBOL_REFs.  */
 517         default:
 518           gcc_unreachable ();
 519         }
 520     }
 521   return 1;
 522 }
 523
 524 /* Return 1 if X and Y are identical-looking rtx's.
 525    This is the Lisp function EQUAL for rtx arguments.
 526    Whenever changing this function check if rtx_equal_p_cb above doesn't need
 527    changing as well.  */
 528
 529 int
 530 rtx_equal_p (const_rtx x, const_rtx y)
 531 {
 532   int i;
 533   int j;
 534   enum rtx_code code;
 535   const char *fmt;
 536
 537   if (x == y)
 538     return 1;
 539   if (x == 0 || y == 0)
 540     return 0;
 541
 542   code = GET_CODE (x);
 543   /* Rtx's of different codes cannot be equal.  */
 544   if (code != GET_CODE (y))
 545     return 0;
 546
 547   /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
 548      (REG:SI x) and (REG:HI x) are NOT equivalent.  */
 549
 550   if (GET_MODE (x) != GET_MODE (y))
 551     return 0;
 552
 553   /* MEMs referring to different address space are not equivalent.  */
 554   if (code == MEM && MEM_ADDR_SPACE (x) != MEM_ADDR_SPACE (y))
 555     return 0;
 556
 557   /* Some RTL can be compared nonrecursively.  */
 558   switch (code)
 559     {
 560     case REG:
 561       return (REGNO (x) == REGNO (y));
 562
 563     case LABEL_REF:
 564       return LABEL_REF_LABEL (x) == LABEL_REF_LABEL (y);
 565
 566     case SYMBOL_REF:
 567       return XSTR (x, 0) == XSTR (y, 0);
 568
 569     case DEBUG_EXPR:
 570     case VALUE:
 571     case SCRATCH:
 572     CASE_CONST_UNIQUE:
 573       return 0;
 574
 575     case DEBUG_IMPLICIT_PTR:
 576       return DEBUG_IMPLICIT_PTR_DECL (x)
 577              == DEBUG_IMPLICIT_PTR_DECL (y);
 578
 579     case DEBUG_PARAMETER_REF:
 580       return DEBUG_PARAMETER_REF_DECL (x)
 581              == DEBUG_PARAMETER_REF_DECL (y);
 582
 583     case ENTRY_VALUE:
 584       return rtx_equal_p (ENTRY_VALUE_EXP (x), ENTRY_VALUE_EXP (y));
 585
 586     default:
 587       break;
 588     }
 589
 590   /* Compare the elements.  If any pair of corresponding elements
 591      fail to match, return 0 for the whole thing.  */
 592
 593   fmt = GET_RTX_FORMAT (code);
 594   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
 595     {
 596       switch (fmt[i])
 597         {
 598         case 'w':
 599           if (XWINT (x, i) != XWINT (y, i))
 600             return 0;
 601           break;
 602
 603         case 'n':
 604         case 'i':
 605           if (XINT (x, i) != XINT (y, i))
 606             {
 607 #ifndef GENERATOR_FILE
 608               if (((code == ASM_OPERANDS && i == 6)
 609                    || (code == ASM_INPUT && i == 1))
 610                   && XINT (x, i) == XINT (y, i))
 611                 break;
 612 #endif
 613               return 0;
 614             }
 615           break;
 616
 617         case 'V':
 618         case 'E':
 619           /* Two vectors must have the same length.  */
 620           if (XVECLEN (x, i) != XVECLEN (y, i))
 621             return 0;
 622
 623           /* And the corresponding elements must match.  */
 624           for (j = 0; j < XVECLEN (x, i); j++)
 625             if (rtx_equal_p (XVECEXP (x, i, j),  XVECEXP (y, i, j)) == 0)
 626               return 0;
 627           break;
 628
 629         case 'e':
 630           if (rtx_equal_p (XEXP (x, i), XEXP (y, i)) == 0)
 631             return 0;
 632           break;
 633
 634         case 'S':
 635         case 's':
 636           if ((XSTR (x, i) || XSTR (y, i))
 637               && (! XSTR (x, i) || ! XSTR (y, i)
 638                   || strcmp (XSTR (x, i), XSTR (y, i))))
 639             return 0;
 640           break;
 641
 642         case 'u':
 643           /* These are just backpointers, so they don't matter.  */
 644           break;
 645
 646         case '0':
 647         case 't':
 648           break;
 649
 650           /* It is believed that rtx's at this level will never
 651              contain anything but integers and other rtx's,
 652              except for within LABEL_REFs and SYMBOL_REFs.  */
 653         default:
 654           gcc_unreachable ();
 655         }
 656     }
 657   return 1;
 658 }
 659
 660 /* Return an indication of which type of insn should have X as a body.
 661    In generator files, this can be UNKNOWN if the answer is only known
 662    at (GCC) runtime.  Otherwise the value is CODE_LABEL, INSN, CALL_INSN
 663    or JUMP_INSN.  */
 664
 665 enum rtx_code
 666 classify_insn (rtx x)
 667 {
 668   if (LABEL_P (x))
 669     return CODE_LABEL;
 670   if (GET_CODE (x) == CALL)
 671     return CALL_INSN;
 672   if (ANY_RETURN_P (x))
 673     return JUMP_INSN;
 674   if (GET_CODE (x) == SET)
 675     {
 676       if (GET_CODE (SET_DEST (x)) == PC)
 677         return JUMP_INSN;
 678       else if (GET_CODE (SET_SRC (x)) == CALL)
 679         return CALL_INSN;
 680       else
 681         return INSN;
 682     }
 683   if (GET_CODE (x) == PARALLEL)
 684     {
 685       int j;
 686       for (j = XVECLEN (x, 0) - 1; j >= 0; j--)
 687         if (GET_CODE (XVECEXP (x, 0, j)) == CALL)
 688           return CALL_INSN;
 689         else if (GET_CODE (XVECEXP (x, 0, j)) == SET
 690                  && GET_CODE (SET_DEST (XVECEXP (x, 0, j))) == PC)
 691           return JUMP_INSN;
 692         else if (GET_CODE (XVECEXP (x, 0, j)) == SET
 693                  && GET_CODE (SET_SRC (XVECEXP (x, 0, j))) == CALL)
 694           return CALL_INSN;
 695     }
 696 #ifdef GENERATOR_FILE
 697   if (GET_CODE (x) == MATCH_OPERAND
 698       || GET_CODE (x) == MATCH_OPERATOR
 699       || GET_CODE (x) == MATCH_PARALLEL
 700       || GET_CODE (x) == MATCH_OP_DUP
 701       || GET_CODE (x) == MATCH_DUP
 702       || GET_CODE (x) == PARALLEL)
 703     return UNKNOWN;
 704 #endif
 705   return INSN;
 706 }
 707
 708 void
 709 dump_rtx_statistics (void)
 710 {
 711   int i;
 712   int total_counts = 0;
 713   int total_sizes = 0;
 714
 715   if (! GATHER_STATISTICS)
 716     {
 717       fprintf (stderr, "No RTX statistics\n");
 718       return;
 719     }
 720
 721   fprintf (stderr, "\nRTX Kind               Count      Bytes\n");
 722   fprintf (stderr, "---------------------------------------\n");
 723   for (i = 0; i < LAST_AND_UNUSED_RTX_CODE; i++)
 724     if (rtx_alloc_counts[i])
 725       {
 726         fprintf (stderr, "%-20s %7d %10d\n", GET_RTX_NAME (i),
 727                  rtx_alloc_counts[i], rtx_alloc_sizes[i]);
 728         total_counts += rtx_alloc_counts[i];
 729         total_sizes += rtx_alloc_sizes[i];
 730       }
 731   if (rtvec_alloc_counts)
 732     {
 733       fprintf (stderr, "%-20s %7d %10d\n", "rtvec",
 734                rtvec_alloc_counts, rtvec_alloc_sizes);
 735       total_counts += rtvec_alloc_counts;
 736       total_sizes += rtvec_alloc_sizes;
 737     }
 738   fprintf (stderr, "---------------------------------------\n");
 739   fprintf (stderr, "%-20s %7d %10d\n",
 740            "Total", total_counts, total_sizes);
 741   fprintf (stderr, "---------------------------------------\n");
 742 }
 743 \f
 744 #if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007)
 745 void
 746 rtl_check_failed_bounds (const_rtx r, int n, const char *file, int line,
 747                          const char *func)
 748 {
 749   internal_error
 750     ("RTL check: access of elt %d of '%s' with last elt %d in %s, at %s:%d",
 751      n, GET_RTX_NAME (GET_CODE (r)), GET_RTX_LENGTH (GET_CODE (r)) - 1,
 752      func, trim_filename (file), line);
 753 }
 754
 755 void
 756 rtl_check_failed_type1 (const_rtx r, int n, int c1, const char *file, int line,
 757                         const char *func)
 758 {
 759   internal_error
 760     ("RTL check: expected elt %d type '%c', have '%c' (rtx %s) in %s, at %s:%d",
 761      n, c1, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
 762      func, trim_filename (file), line);
 763 }
 764
 765 void
 766 rtl_check_failed_type2 (const_rtx r, int n, int c1, int c2, const char *file,
 767                         int line, const char *func)
 768 {
 769   internal_error
 770     ("RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s) in %s, at %s:%d",
 771      n, c1, c2, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
 772      func, trim_filename (file), line);
 773 }
 774
 775 void
 776 rtl_check_failed_code1 (const_rtx r, enum rtx_code code, const char *file,
 777                         int line, const char *func)
 778 {
 779   internal_error ("RTL check: expected code '%s', have '%s' in %s, at %s:%d",
 780                   GET_RTX_NAME (code), GET_RTX_NAME (GET_CODE (r)), func,
 781                   trim_filename (file), line);
 782 }
 783
 784 void
 785 rtl_check_failed_code2 (const_rtx r, enum rtx_code code1, enum rtx_code code2,
 786                         const char *file, int line, const char *func)
 787 {
 788   internal_error
 789     ("RTL check: expected code '%s' or '%s', have '%s' in %s, at %s:%d",
 790      GET_RTX_NAME (code1), GET_RTX_NAME (code2), GET_RTX_NAME (GET_CODE (r)),
 791      func, trim_filename (file), line);
 792 }
 793
 794 void
 795 rtl_check_failed_code_mode (const_rtx r, enum rtx_code code, machine_mode mode,
 796                             bool not_mode, const char *file, int line,
 797                             const char *func)
 798 {
 799   internal_error ((not_mode
 800                    ? ("RTL check: expected code '%s' and not mode '%s', "
 801                       "have code '%s' and mode '%s' in %s, at %s:%d")
 802                    : ("RTL check: expected code '%s' and mode '%s', "
 803                       "have code '%s' and mode '%s' in %s, at %s:%d")),
 804                   GET_RTX_NAME (code), GET_MODE_NAME (mode),
 805                   GET_RTX_NAME (GET_CODE (r)), GET_MODE_NAME (GET_MODE (r)),
 806                   func, trim_filename (file), line);
 807 }
 808
 809 /* Report that line LINE of FILE tried to access the block symbol fields
 810    of a non-block symbol.  FUNC is the function that contains the line.  */
 811
 812 void
 813 rtl_check_failed_block_symbol (const char *file, int line, const char *func)
 814 {
 815   internal_error
 816     ("RTL check: attempt to treat non-block symbol as a block symbol "
 817      "in %s, at %s:%d", func, trim_filename (file), line);
 818 }
 819
 820 /* XXX Maybe print the vector?  */
 821 void
 822 cwi_check_failed_bounds (const_rtx x, int n, const char *file, int line,
 823                          const char *func)
 824 {
 825   internal_error
 826     ("RTL check: access of hwi elt %d of vector with last elt %d in %s, at %s:%d",
 827      n, CWI_GET_NUM_ELEM (x) - 1, func, trim_filename (file), line);
 828 }
 829
 830 /* XXX Maybe print the vector?  */
 831 void
 832 rtvec_check_failed_bounds (const_rtvec r, int n, const char *file, int line,
 833                            const char *func)
 834 {
 835   internal_error
 836     ("RTL check: access of elt %d of vector with last elt %d in %s, at %s:%d",
 837      n, GET_NUM_ELEM (r) - 1, func, trim_filename (file), line);
 838 }
 839 #endif /* ENABLE_RTL_CHECKING */
 840
 841 #if defined ENABLE_RTL_FLAG_CHECKING
 842 void
 843 rtl_check_failed_flag (const char *name, const_rtx r, const char *file,
 844                        int line, const char *func)
 845 {
 846   internal_error
 847     ("RTL flag check: %s used with unexpected rtx code '%s' in %s, at %s:%d",
 848      name, GET_RTX_NAME (GET_CODE (r)), func, trim_filename (file), line);
 849 }
 850 #endif /* ENABLE_RTL_FLAG_CHECKING */