gcc/rtl.c

   1 /* RTL utility routines.
   2    Copyright (C) 1987-2018 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      "p" is a poly_uint16 offset.  */
  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 || (ENUM) == CONST_WIDE_INT)               \
 115    ? RTX_HDR_SIZE + (sizeof FORMAT - 1) * sizeof (HOST_WIDE_INT)        \
 116    : (ENUM) == REG                                                      \
 117    ? RTX_HDR_SIZE + sizeof (reg_info)                                   \
 118    : RTX_HDR_SIZE + (sizeof FORMAT - 1) * sizeof (rtunion)),
 119
 120 #include "rtl.def"
 121 #undef DEF_RTL_EXPR
 122 };
 123
 124 /* Names for kinds of NOTEs and REG_NOTEs.  */
 125
 126 const char * const note_insn_name[NOTE_INSN_MAX] =
 127 {
 128 #define DEF_INSN_NOTE(NAME) #NAME,
 129 #include "insn-notes.def"
 130 #undef DEF_INSN_NOTE
 131 };
 132
 133 const char * const reg_note_name[REG_NOTE_MAX] =
 134 {
 135 #define DEF_REG_NOTE(NAME) #NAME,
 136 #include "reg-notes.def"
 137 #undef DEF_REG_NOTE
 138 };
 139
 140 static int rtx_alloc_counts[(int) LAST_AND_UNUSED_RTX_CODE];
 141 static int rtx_alloc_sizes[(int) LAST_AND_UNUSED_RTX_CODE];
 142 static int rtvec_alloc_counts;
 143 static int rtvec_alloc_sizes;
 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   if (GATHER_STATISTICS)
 161     {
 162       rtvec_alloc_counts++;
 163       rtvec_alloc_sizes += n * sizeof (rtx);
 164     }
 165
 166   return rt;
 167 }
 168
 169 /* Create a bitwise copy of VEC.  */
 170
 171 rtvec
 172 shallow_copy_rtvec (rtvec vec)
 173 {
 174   rtvec newvec;
 175   int n;
 176
 177   n = GET_NUM_ELEM (vec);
 178   newvec = rtvec_alloc (n);
 179   memcpy (&newvec->elem[0], &vec->elem[0], sizeof (rtx) * n);
 180   return newvec;
 181 }
 182
 183 /* Return the number of bytes occupied by rtx value X.  */
 184
 185 unsigned int
 186 rtx_size (const_rtx x)
 187 {
 188   if (CONST_WIDE_INT_P (x))
 189     return (RTX_HDR_SIZE
 190             + sizeof (struct hwivec_def)
 191             + ((CONST_WIDE_INT_NUNITS (x) - 1)
 192                * sizeof (HOST_WIDE_INT)));
 193   if (CONST_POLY_INT_P (x))
 194     return (RTX_HDR_SIZE
 195             + sizeof (struct const_poly_int_def)
 196             + CONST_POLY_INT_COEFFS (x).extra_size ());
 197   if (GET_CODE (x) == SYMBOL_REF && SYMBOL_REF_HAS_BLOCK_INFO_P (x))
 198     return RTX_HDR_SIZE + sizeof (struct block_symbol);
 199   return RTX_CODE_SIZE (GET_CODE (x));
 200 }
 201
 202 /* Allocate an rtx of code CODE with EXTRA bytes in it.  The CODE is
 203    stored in the rtx; all the rest is initialized to zero.  */
 204
 205 rtx
 206 rtx_alloc_stat_v (RTX_CODE code MEM_STAT_DECL, int extra)
 207 {
 208   rtx rt = ggc_alloc_rtx_def_stat (RTX_CODE_SIZE (code) + extra
 209                                    PASS_MEM_STAT);
 210
 211   /* We want to clear everything up to the FLD array.  Normally, this
 212      is one int, but we don't want to assume that and it isn't very
 213      portable anyway; this is.  */
 214
 215   memset (rt, 0, RTX_HDR_SIZE);
 216   PUT_CODE (rt, code);
 217
 218   if (GATHER_STATISTICS)
 219     {
 220       rtx_alloc_counts[code]++;
 221       rtx_alloc_sizes[code] += RTX_CODE_SIZE (code);
 222     }
 223
 224   return rt;
 225 }
 226
 227 /* Allocate an rtx of code CODE.  The CODE is stored in the rtx;
 228    all the rest is initialized to zero.  */
 229
 230 rtx
 231 rtx_alloc (RTX_CODE code MEM_STAT_DECL)
 232 {
 233   return rtx_alloc_stat_v (code PASS_MEM_STAT, 0);
 234 }
 235
 236 /* Write the wide constant X to OUTFILE.  */
 237
 238 void
 239 cwi_output_hex (FILE *outfile, const_rtx x)
 240 {
 241   int i = CWI_GET_NUM_ELEM (x);
 242   gcc_assert (i > 0);
 243   if (CWI_ELT (x, i - 1) == 0)
 244     /* The HOST_WIDE_INT_PRINT_HEX prepends a 0x only if the val is
 245        non zero.  We want all numbers to have a 0x prefix.  */
 246     fprintf (outfile, "0x");
 247   fprintf (outfile, HOST_WIDE_INT_PRINT_HEX, CWI_ELT (x, --i));
 248   while (--i >= 0)
 249     fprintf (outfile, HOST_WIDE_INT_PRINT_PADDED_HEX, CWI_ELT (x, i));
 250 }
 251
 252 \f
 253 /* Return true if ORIG is a sharable CONST.  */
 254
 255 bool
 256 shared_const_p (const_rtx orig)
 257 {
 258   gcc_assert (GET_CODE (orig) == CONST);
 259
 260   /* CONST can be shared if it contains a SYMBOL_REF.  If it contains
 261      a LABEL_REF, it isn't sharable.  */
 262   poly_int64 offset;
 263   return (GET_CODE (XEXP (orig, 0)) == PLUS
 264           && GET_CODE (XEXP (XEXP (orig, 0), 0)) == SYMBOL_REF
 265           && poly_int_rtx_p (XEXP (XEXP (orig, 0), 1), &offset));
 266 }
 267
 268
 269 /* Create a new copy of an rtx.
 270    Recursively copies the operands of the rtx,
 271    except for those few rtx codes that are sharable.  */
 272
 273 rtx
 274 copy_rtx (rtx orig)
 275 {
 276   rtx copy;
 277   int i, j;
 278   RTX_CODE code;
 279   const char *format_ptr;
 280
 281   code = GET_CODE (orig);
 282
 283   switch (code)
 284     {
 285     case REG:
 286     case DEBUG_EXPR:
 287     case VALUE:
 288     CASE_CONST_ANY:
 289     case SYMBOL_REF:
 290     case CODE_LABEL:
 291     case PC:
 292     case CC0:
 293     case RETURN:
 294     case SIMPLE_RETURN:
 295     case SCRATCH:
 296       /* SCRATCH must be shared because they represent distinct values.  */
 297       return orig;
 298     case CLOBBER:
 299       /* Share clobbers of hard registers (like cc0), but do not share pseudo reg
 300          clobbers or clobbers of hard registers that originated as pseudos.
 301          This is needed to allow safe register renaming.  */
 302       if (REG_P (XEXP (orig, 0)) && REGNO (XEXP (orig, 0)) < FIRST_PSEUDO_REGISTER
 303           && ORIGINAL_REGNO (XEXP (orig, 0)) == REGNO (XEXP (orig, 0)))
 304         return orig;
 305       break;
 306
 307     case CLOBBER_HIGH:
 308         gcc_assert (REG_P (XEXP (orig, 0)));
 309         return orig;
 310
 311     case CONST:
 312       if (shared_const_p (orig))
 313         return orig;
 314       break;
 315
 316       /* A MEM with a constant address is not sharable.  The problem is that
 317          the constant address may need to be reloaded.  If the mem is shared,
 318          then reloading one copy of this mem will cause all copies to appear
 319          to have been reloaded.  */
 320
 321     default:
 322       break;
 323     }
 324
 325   /* Copy the various flags, fields, and other information.  We assume
 326      that all fields need copying, and then clear the fields that should
 327      not be copied.  That is the sensible default behavior, and forces
 328      us to explicitly document why we are *not* copying a flag.  */
 329   copy = shallow_copy_rtx (orig);
 330
 331   format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
 332
 333   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
 334     switch (*format_ptr++)
 335       {
 336       case 'e':
 337         if (XEXP (orig, i) != NULL)
 338           XEXP (copy, i) = copy_rtx (XEXP (orig, i));
 339         break;
 340
 341       case 'E':
 342       case 'V':
 343         if (XVEC (orig, i) != NULL)
 344           {
 345             XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
 346             for (j = 0; j < XVECLEN (copy, i); j++)
 347               XVECEXP (copy, i, j) = copy_rtx (XVECEXP (orig, i, j));
 348           }
 349         break;
 350
 351       case 't':
 352       case 'w':
 353       case 'i':
 354       case 'p':
 355       case 's':
 356       case 'S':
 357       case 'T':
 358       case 'u':
 359       case 'B':
 360       case '0':
 361         /* These are left unchanged.  */
 362         break;
 363
 364       default:
 365         gcc_unreachable ();
 366       }
 367   return copy;
 368 }
 369
 370 /* Create a new copy of an rtx.  Only copy just one level.  */
 371
 372 rtx
 373 shallow_copy_rtx (const_rtx orig MEM_STAT_DECL)
 374 {
 375   const unsigned int size = rtx_size (orig);
 376   rtx const copy = ggc_alloc_rtx_def_stat (size PASS_MEM_STAT);
 377   memcpy (copy, orig, size);
 378   switch (GET_CODE (orig))
 379     {
 380       /* RTX codes copy_rtx_if_shared_1 considers are shareable,
 381          the used flag is often used for other purposes.  */
 382     case REG:
 383     case DEBUG_EXPR:
 384     case VALUE:
 385     CASE_CONST_ANY:
 386     case SYMBOL_REF:
 387     case CODE_LABEL:
 388     case PC:
 389     case CC0:
 390     case RETURN:
 391     case SIMPLE_RETURN:
 392     case SCRATCH:
 393       break;
 394     default:
 395       /* For all other RTXes clear the used flag on the copy.  */
 396       RTX_FLAG (copy, used) = 0;
 397       break;
 398     }
 399   return copy;
 400 }
 401 \f
 402 /* Nonzero when we are generating CONCATs.  */
 403 int generating_concat_p;
 404
 405 /* Nonzero when we are expanding trees to RTL.  */
 406 int currently_expanding_to_rtl;
 407
 408 \f
 409
 410 /* Same as rtx_equal_p, but call CB on each pair of rtx if CB is not NULL.
 411    When the callback returns true, we continue with the new pair.
 412    Whenever changing this function check if rtx_equal_p below doesn't need
 413    changing as well.  */
 414
 415 int
 416 rtx_equal_p_cb (const_rtx x, const_rtx y, rtx_equal_p_callback_function cb)
 417 {
 418   int i;
 419   int j;
 420   enum rtx_code code;
 421   const char *fmt;
 422   rtx nx, ny;
 423
 424   if (x == y)
 425     return 1;
 426   if (x == 0 || y == 0)
 427     return 0;
 428
 429   /* Invoke the callback first.  */
 430   if (cb != NULL
 431       && ((*cb) (&x, &y, &nx, &ny)))
 432     return rtx_equal_p_cb (nx, ny, cb);
 433
 434   code = GET_CODE (x);
 435   /* Rtx's of different codes cannot be equal.  */
 436   if (code != GET_CODE (y))
 437     return 0;
 438
 439   /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
 440      (REG:SI x) and (REG:HI x) are NOT equivalent.  */
 441
 442   if (GET_MODE (x) != GET_MODE (y))
 443     return 0;
 444
 445   /* MEMs referring to different address space are not equivalent.  */
 446   if (code == MEM && MEM_ADDR_SPACE (x) != MEM_ADDR_SPACE (y))
 447     return 0;
 448
 449   /* Some RTL can be compared nonrecursively.  */
 450   switch (code)
 451     {
 452     case REG:
 453       return (REGNO (x) == REGNO (y));
 454
 455     case LABEL_REF:
 456       return label_ref_label (x) == label_ref_label (y);
 457
 458     case SYMBOL_REF:
 459       return XSTR (x, 0) == XSTR (y, 0);
 460
 461     case DEBUG_EXPR:
 462     case VALUE:
 463     case SCRATCH:
 464     CASE_CONST_UNIQUE:
 465       return 0;
 466
 467     case DEBUG_IMPLICIT_PTR:
 468       return DEBUG_IMPLICIT_PTR_DECL (x)
 469              == DEBUG_IMPLICIT_PTR_DECL (y);
 470
 471     case DEBUG_PARAMETER_REF:
 472       return DEBUG_PARAMETER_REF_DECL (x)
 473              == DEBUG_PARAMETER_REF_DECL (y);
 474
 475     case ENTRY_VALUE:
 476       return rtx_equal_p_cb (ENTRY_VALUE_EXP (x), ENTRY_VALUE_EXP (y), cb);
 477
 478     default:
 479       break;
 480     }
 481
 482   /* Compare the elements.  If any pair of corresponding elements
 483      fail to match, return 0 for the whole thing.  */
 484
 485   fmt = GET_RTX_FORMAT (code);
 486   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
 487     {
 488       switch (fmt[i])
 489         {
 490         case 'w':
 491           if (XWINT (x, i) != XWINT (y, i))
 492             return 0;
 493           break;
 494
 495         case 'n':
 496         case 'i':
 497           if (XINT (x, i) != XINT (y, i))
 498             {
 499 #ifndef GENERATOR_FILE
 500               if (((code == ASM_OPERANDS && i == 6)
 501                    || (code == ASM_INPUT && i == 1))
 502                   && XINT (x, i) == XINT (y, i))
 503                 break;
 504 #endif
 505               return 0;
 506             }
 507           break;
 508
 509         case 'p':
 510           if (maybe_ne (SUBREG_BYTE (x), SUBREG_BYTE (y)))
 511             return 0;
 512           break;
 513
 514         case 'V':
 515         case 'E':
 516           /* Two vectors must have the same length.  */
 517           if (XVECLEN (x, i) != XVECLEN (y, i))
 518             return 0;
 519
 520           /* And the corresponding elements must match.  */
 521           for (j = 0; j < XVECLEN (x, i); j++)
 522             if (rtx_equal_p_cb (XVECEXP (x, i, j),
 523                                 XVECEXP (y, i, j), cb) == 0)
 524               return 0;
 525           break;
 526
 527         case 'e':
 528           if (rtx_equal_p_cb (XEXP (x, i), XEXP (y, i), cb) == 0)
 529             return 0;
 530           break;
 531
 532         case 'S':
 533         case 's':
 534           if ((XSTR (x, i) || XSTR (y, i))
 535               && (! XSTR (x, i) || ! XSTR (y, i)
 536                   || strcmp (XSTR (x, i), XSTR (y, i))))
 537             return 0;
 538           break;
 539
 540         case 'u':
 541           /* These are just backpointers, so they don't matter.  */
 542           break;
 543
 544         case '0':
 545         case 't':
 546           break;
 547
 548           /* It is believed that rtx's at this level will never
 549              contain anything but integers and other rtx's,
 550              except for within LABEL_REFs and SYMBOL_REFs.  */
 551         default:
 552           gcc_unreachable ();
 553         }
 554     }
 555   return 1;
 556 }
 557
 558 /* Return 1 if X and Y are identical-looking rtx's.
 559    This is the Lisp function EQUAL for rtx arguments.
 560    Whenever changing this function check if rtx_equal_p_cb above doesn't need
 561    changing as well.  */
 562
 563 int
 564 rtx_equal_p (const_rtx x, const_rtx y)
 565 {
 566   int i;
 567   int j;
 568   enum rtx_code code;
 569   const char *fmt;
 570
 571   if (x == y)
 572     return 1;
 573   if (x == 0 || y == 0)
 574     return 0;
 575
 576   code = GET_CODE (x);
 577   /* Rtx's of different codes cannot be equal.  */
 578   if (code != GET_CODE (y))
 579     return 0;
 580
 581   /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
 582      (REG:SI x) and (REG:HI x) are NOT equivalent.  */
 583
 584   if (GET_MODE (x) != GET_MODE (y))
 585     return 0;
 586
 587   /* MEMs referring to different address space are not equivalent.  */
 588   if (code == MEM && MEM_ADDR_SPACE (x) != MEM_ADDR_SPACE (y))
 589     return 0;
 590
 591   /* Some RTL can be compared nonrecursively.  */
 592   switch (code)
 593     {
 594     case REG:
 595       return (REGNO (x) == REGNO (y));
 596
 597     case LABEL_REF:
 598       return label_ref_label (x) == label_ref_label (y);
 599
 600     case SYMBOL_REF:
 601       return XSTR (x, 0) == XSTR (y, 0);
 602
 603     case DEBUG_EXPR:
 604     case VALUE:
 605     case SCRATCH:
 606     CASE_CONST_UNIQUE:
 607       return 0;
 608
 609     case DEBUG_IMPLICIT_PTR:
 610       return DEBUG_IMPLICIT_PTR_DECL (x)
 611              == DEBUG_IMPLICIT_PTR_DECL (y);
 612
 613     case DEBUG_PARAMETER_REF:
 614       return DEBUG_PARAMETER_REF_DECL (x)
 615              == DEBUG_PARAMETER_REF_DECL (y);
 616
 617     case ENTRY_VALUE:
 618       return rtx_equal_p (ENTRY_VALUE_EXP (x), ENTRY_VALUE_EXP (y));
 619
 620     default:
 621       break;
 622     }
 623
 624   /* Compare the elements.  If any pair of corresponding elements
 625      fail to match, return 0 for the whole thing.  */
 626
 627   fmt = GET_RTX_FORMAT (code);
 628   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
 629     {
 630       switch (fmt[i])
 631         {
 632         case 'w':
 633           if (XWINT (x, i) != XWINT (y, i))
 634             return 0;
 635           break;
 636
 637         case 'n':
 638         case 'i':
 639           if (XINT (x, i) != XINT (y, i))
 640             {
 641 #ifndef GENERATOR_FILE
 642               if (((code == ASM_OPERANDS && i == 6)
 643                    || (code == ASM_INPUT && i == 1))
 644                   && XINT (x, i) == XINT (y, i))
 645                 break;
 646 #endif
 647               return 0;
 648             }
 649           break;
 650
 651         case 'p':
 652           if (maybe_ne (SUBREG_BYTE (x), SUBREG_BYTE (y)))
 653             return 0;
 654           break;
 655
 656         case 'V':
 657         case 'E':
 658           /* Two vectors must have the same length.  */
 659           if (XVECLEN (x, i) != XVECLEN (y, i))
 660             return 0;
 661
 662           /* And the corresponding elements must match.  */
 663           for (j = 0; j < XVECLEN (x, i); j++)
 664             if (rtx_equal_p (XVECEXP (x, i, j),  XVECEXP (y, i, j)) == 0)
 665               return 0;
 666           break;
 667
 668         case 'e':
 669           if (rtx_equal_p (XEXP (x, i), XEXP (y, i)) == 0)
 670             return 0;
 671           break;
 672
 673         case 'S':
 674         case 's':
 675           if ((XSTR (x, i) || XSTR (y, i))
 676               && (! XSTR (x, i) || ! XSTR (y, i)
 677                   || strcmp (XSTR (x, i), XSTR (y, i))))
 678             return 0;
 679           break;
 680
 681         case 'u':
 682           /* These are just backpointers, so they don't matter.  */
 683           break;
 684
 685         case '0':
 686         case 't':
 687           break;
 688
 689           /* It is believed that rtx's at this level will never
 690              contain anything but integers and other rtx's,
 691              except for within LABEL_REFs and SYMBOL_REFs.  */
 692         default:
 693           gcc_unreachable ();
 694         }
 695     }
 696   return 1;
 697 }
 698
 699 /* Return true if all elements of VEC are equal.  */
 700
 701 bool
 702 rtvec_all_equal_p (const_rtvec vec)
 703 {
 704   const_rtx first = RTVEC_ELT (vec, 0);
 705   /* Optimize the important special case of a vector of constants.
 706      The main use of this function is to detect whether every element
 707      of CONST_VECTOR is the same.  */
 708   switch (GET_CODE (first))
 709     {
 710     CASE_CONST_UNIQUE:
 711       for (int i = 1, n = GET_NUM_ELEM (vec); i < n; ++i)
 712         if (first != RTVEC_ELT (vec, i))
 713           return false;
 714       return true;
 715
 716     default:
 717       for (int i = 1, n = GET_NUM_ELEM (vec); i < n; ++i)
 718         if (!rtx_equal_p (first, RTVEC_ELT (vec, i)))
 719           return false;
 720       return true;
 721     }
 722 }
 723
 724 /* Return an indication of which type of insn should have X as a body.
 725    In generator files, this can be UNKNOWN if the answer is only known
 726    at (GCC) runtime.  Otherwise the value is CODE_LABEL, INSN, CALL_INSN
 727    or JUMP_INSN.  */
 728
 729 enum rtx_code
 730 classify_insn (rtx x)
 731 {
 732   if (LABEL_P (x))
 733     return CODE_LABEL;
 734   if (GET_CODE (x) == CALL)
 735     return CALL_INSN;
 736   if (ANY_RETURN_P (x))
 737     return JUMP_INSN;
 738   if (GET_CODE (x) == SET)
 739     {
 740       if (GET_CODE (SET_DEST (x)) == PC)
 741         return JUMP_INSN;
 742       else if (GET_CODE (SET_SRC (x)) == CALL)
 743         return CALL_INSN;
 744       else
 745         return INSN;
 746     }
 747   if (GET_CODE (x) == PARALLEL)
 748     {
 749       int j;
 750       bool has_return_p = false;
 751       for (j = XVECLEN (x, 0) - 1; j >= 0; j--)
 752         if (GET_CODE (XVECEXP (x, 0, j)) == CALL)
 753           return CALL_INSN;
 754         else if (ANY_RETURN_P (XVECEXP (x, 0, j)))
 755           has_return_p = true;
 756         else if (GET_CODE (XVECEXP (x, 0, j)) == SET
 757                  && GET_CODE (SET_DEST (XVECEXP (x, 0, j))) == PC)
 758           return JUMP_INSN;
 759         else if (GET_CODE (XVECEXP (x, 0, j)) == SET
 760                  && GET_CODE (SET_SRC (XVECEXP (x, 0, j))) == CALL)
 761           return CALL_INSN;
 762       if (has_return_p)
 763         return JUMP_INSN;
 764     }
 765 #ifdef GENERATOR_FILE
 766   if (GET_CODE (x) == MATCH_OPERAND
 767       || GET_CODE (x) == MATCH_OPERATOR
 768       || GET_CODE (x) == MATCH_PARALLEL
 769       || GET_CODE (x) == MATCH_OP_DUP
 770       || GET_CODE (x) == MATCH_DUP
 771       || GET_CODE (x) == PARALLEL)
 772     return UNKNOWN;
 773 #endif
 774   return INSN;
 775 }
 776
 777 void
 778 dump_rtx_statistics (void)
 779 {
 780   int i;
 781   int total_counts = 0;
 782   int total_sizes = 0;
 783
 784   if (! GATHER_STATISTICS)
 785     {
 786       fprintf (stderr, "No RTX statistics\n");
 787       return;
 788     }
 789
 790   fprintf (stderr, "\nRTX Kind               Count      Bytes\n");
 791   fprintf (stderr, "---------------------------------------\n");
 792   for (i = 0; i < LAST_AND_UNUSED_RTX_CODE; i++)
 793     if (rtx_alloc_counts[i])
 794       {
 795         fprintf (stderr, "%-20s %7d %10d\n", GET_RTX_NAME (i),
 796                  rtx_alloc_counts[i], rtx_alloc_sizes[i]);
 797         total_counts += rtx_alloc_counts[i];
 798         total_sizes += rtx_alloc_sizes[i];
 799       }
 800   if (rtvec_alloc_counts)
 801     {
 802       fprintf (stderr, "%-20s %7d %10d\n", "rtvec",
 803                rtvec_alloc_counts, rtvec_alloc_sizes);
 804       total_counts += rtvec_alloc_counts;
 805       total_sizes += rtvec_alloc_sizes;
 806     }
 807   fprintf (stderr, "---------------------------------------\n");
 808   fprintf (stderr, "%-20s %7d %10d\n",
 809            "Total", total_counts, total_sizes);
 810   fprintf (stderr, "---------------------------------------\n");
 811 }
 812 \f
 813 #if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007)
 814 void
 815 rtl_check_failed_bounds (const_rtx r, int n, const char *file, int line,
 816                          const char *func)
 817 {
 818   internal_error
 819     ("RTL check: access of elt %d of '%s' with last elt %d in %s, at %s:%d",
 820      n, GET_RTX_NAME (GET_CODE (r)), GET_RTX_LENGTH (GET_CODE (r)) - 1,
 821      func, trim_filename (file), line);
 822 }
 823
 824 void
 825 rtl_check_failed_type1 (const_rtx r, int n, int c1, const char *file, int line,
 826                         const char *func)
 827 {
 828   internal_error
 829     ("RTL check: expected elt %d type '%c', have '%c' (rtx %s) in %s, at %s:%d",
 830      n, c1, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
 831      func, trim_filename (file), line);
 832 }
 833
 834 void
 835 rtl_check_failed_type2 (const_rtx r, int n, int c1, int c2, const char *file,
 836                         int line, const char *func)
 837 {
 838   internal_error
 839     ("RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s) in %s, at %s:%d",
 840      n, c1, c2, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
 841      func, trim_filename (file), line);
 842 }
 843
 844 void
 845 rtl_check_failed_code1 (const_rtx r, enum rtx_code code, const char *file,
 846                         int line, const char *func)
 847 {
 848   internal_error ("RTL check: expected code '%s', have '%s' in %s, at %s:%d",
 849                   GET_RTX_NAME (code), GET_RTX_NAME (GET_CODE (r)), func,
 850                   trim_filename (file), line);
 851 }
 852
 853 void
 854 rtl_check_failed_code2 (const_rtx r, enum rtx_code code1, enum rtx_code code2,
 855                         const char *file, int line, const char *func)
 856 {
 857   internal_error
 858     ("RTL check: expected code '%s' or '%s', have '%s' in %s, at %s:%d",
 859      GET_RTX_NAME (code1), GET_RTX_NAME (code2), GET_RTX_NAME (GET_CODE (r)),
 860      func, trim_filename (file), line);
 861 }
 862
 863 void
 864 rtl_check_failed_code3 (const_rtx r, enum rtx_code code1, enum rtx_code code2,
 865                         enum rtx_code code3, const char *file, int line,
 866                         const char *func)
 867 {
 868   internal_error
 869     ("RTL check: expected code '%s', '%s' or '%s', have '%s' in %s, at %s:%d",
 870      GET_RTX_NAME (code1), GET_RTX_NAME (code2), GET_RTX_NAME (code3),
 871      GET_RTX_NAME (GET_CODE (r)), func, trim_filename (file), line);
 872 }
 873
 874 void
 875 rtl_check_failed_code_mode (const_rtx r, enum rtx_code code, machine_mode mode,
 876                             bool not_mode, const char *file, int line,
 877                             const char *func)
 878 {
 879   internal_error ((not_mode
 880                    ? ("RTL check: expected code '%s' and not mode '%s', "
 881                       "have code '%s' and mode '%s' in %s, at %s:%d")
 882                    : ("RTL check: expected code '%s' and mode '%s', "
 883                       "have code '%s' and mode '%s' in %s, at %s:%d")),
 884                   GET_RTX_NAME (code), GET_MODE_NAME (mode),
 885                   GET_RTX_NAME (GET_CODE (r)), GET_MODE_NAME (GET_MODE (r)),
 886                   func, trim_filename (file), line);
 887 }
 888
 889 /* Report that line LINE of FILE tried to access the block symbol fields
 890    of a non-block symbol.  FUNC is the function that contains the line.  */
 891
 892 void
 893 rtl_check_failed_block_symbol (const char *file, int line, const char *func)
 894 {
 895   internal_error
 896     ("RTL check: attempt to treat non-block symbol as a block symbol "
 897      "in %s, at %s:%d", func, trim_filename (file), line);
 898 }
 899
 900 /* XXX Maybe print the vector?  */
 901 void
 902 cwi_check_failed_bounds (const_rtx x, int n, const char *file, int line,
 903                          const char *func)
 904 {
 905   internal_error
 906     ("RTL check: access of hwi elt %d of vector with last elt %d in %s, at %s:%d",
 907      n, CWI_GET_NUM_ELEM (x) - 1, func, trim_filename (file), line);
 908 }
 909
 910 /* XXX Maybe print the vector?  */
 911 void
 912 rtvec_check_failed_bounds (const_rtvec r, int n, const char *file, int line,
 913                            const char *func)
 914 {
 915   internal_error
 916     ("RTL check: access of elt %d of vector with last elt %d in %s, at %s:%d",
 917      n, GET_NUM_ELEM (r) - 1, func, trim_filename (file), line);
 918 }
 919 #endif /* ENABLE_RTL_CHECKING */
 920
 921 #if defined ENABLE_RTL_FLAG_CHECKING
 922 void
 923 rtl_check_failed_flag (const char *name, const_rtx r, const char *file,
 924                        int line, const char *func)
 925 {
 926   internal_error
 927     ("RTL flag check: %s used with unexpected rtx code '%s' in %s, at %s:%d",
 928      name, GET_RTX_NAME (GET_CODE (r)), func, trim_filename (file), line);
 929 }
 930 #endif /* ENABLE_RTL_FLAG_CHECKING */