contrib/gcc-8.0/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 CONST:
 308       if (shared_const_p (orig))
 309         return orig;
 310       break;
 311
 312       /* A MEM with a constant address is not sharable.  The problem is that
 313          the constant address may need to be reloaded.  If the mem is shared,
 314          then reloading one copy of this mem will cause all copies to appear
 315          to have been reloaded.  */
 316
 317     default:
 318       break;
 319     }
 320
 321   /* Copy the various flags, fields, and other information.  We assume
 322      that all fields need copying, and then clear the fields that should
 323      not be copied.  That is the sensible default behavior, and forces
 324      us to explicitly document why we are *not* copying a flag.  */
 325   copy = shallow_copy_rtx (orig);
 326
 327   format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
 328
 329   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
 330     switch (*format_ptr++)
 331       {
 332       case 'e':
 333         if (XEXP (orig, i) != NULL)
 334           XEXP (copy, i) = copy_rtx (XEXP (orig, i));
 335         break;
 336
 337       case 'E':
 338       case 'V':
 339         if (XVEC (orig, i) != NULL)
 340           {
 341             XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
 342             for (j = 0; j < XVECLEN (copy, i); j++)
 343               XVECEXP (copy, i, j) = copy_rtx (XVECEXP (orig, i, j));
 344           }
 345         break;
 346
 347       case 't':
 348       case 'w':
 349       case 'i':
 350       case 'p':
 351       case 's':
 352       case 'S':
 353       case 'T':
 354       case 'u':
 355       case 'B':
 356       case '0':
 357         /* These are left unchanged.  */
 358         break;
 359
 360       default:
 361         gcc_unreachable ();
 362       }
 363   return copy;
 364 }
 365
 366 /* Create a new copy of an rtx.  Only copy just one level.  */
 367
 368 rtx
 369 shallow_copy_rtx (const_rtx orig MEM_STAT_DECL)
 370 {
 371   const unsigned int size = rtx_size (orig);
 372   rtx const copy = ggc_alloc_rtx_def_stat (size PASS_MEM_STAT);
 373   memcpy (copy, orig, size);
 374   switch (GET_CODE (orig))
 375     {
 376       /* RTX codes copy_rtx_if_shared_1 considers are shareable,
 377          the used flag is often used for other purposes.  */
 378     case REG:
 379     case DEBUG_EXPR:
 380     case VALUE:
 381     CASE_CONST_ANY:
 382     case SYMBOL_REF:
 383     case CODE_LABEL:
 384     case PC:
 385     case CC0:
 386     case RETURN:
 387     case SIMPLE_RETURN:
 388     case SCRATCH:
 389       break;
 390     default:
 391       /* For all other RTXes clear the used flag on the copy.  */
 392       RTX_FLAG (copy, used) = 0;
 393       break;
 394     }
 395   return copy;
 396 }
 397 \f
 398 /* Nonzero when we are generating CONCATs.  */
 399 int generating_concat_p;
 400
 401 /* Nonzero when we are expanding trees to RTL.  */
 402 int currently_expanding_to_rtl;
 403
 404 \f
 405
 406 /* Same as rtx_equal_p, but call CB on each pair of rtx if CB is not NULL.
 407    When the callback returns true, we continue with the new pair.
 408    Whenever changing this function check if rtx_equal_p below doesn't need
 409    changing as well.  */
 410
 411 int
 412 rtx_equal_p_cb (const_rtx x, const_rtx y, rtx_equal_p_callback_function cb)
 413 {
 414   int i;
 415   int j;
 416   enum rtx_code code;
 417   const char *fmt;
 418   rtx nx, ny;
 419
 420   if (x == y)
 421     return 1;
 422   if (x == 0 || y == 0)
 423     return 0;
 424
 425   /* Invoke the callback first.  */
 426   if (cb != NULL
 427       && ((*cb) (&x, &y, &nx, &ny)))
 428     return rtx_equal_p_cb (nx, ny, cb);
 429
 430   code = GET_CODE (x);
 431   /* Rtx's of different codes cannot be equal.  */
 432   if (code != GET_CODE (y))
 433     return 0;
 434
 435   /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
 436      (REG:SI x) and (REG:HI x) are NOT equivalent.  */
 437
 438   if (GET_MODE (x) != GET_MODE (y))
 439     return 0;
 440
 441   /* MEMs referring to different address space are not equivalent.  */
 442   if (code == MEM && MEM_ADDR_SPACE (x) != MEM_ADDR_SPACE (y))
 443     return 0;
 444
 445   /* Some RTL can be compared nonrecursively.  */
 446   switch (code)
 447     {
 448     case REG:
 449       return (REGNO (x) == REGNO (y));
 450
 451     case LABEL_REF:
 452       return label_ref_label (x) == label_ref_label (y);
 453
 454     case SYMBOL_REF:
 455       return XSTR (x, 0) == XSTR (y, 0);
 456
 457     case DEBUG_EXPR:
 458     case VALUE:
 459     case SCRATCH:
 460     CASE_CONST_UNIQUE:
 461       return 0;
 462
 463     case DEBUG_IMPLICIT_PTR:
 464       return DEBUG_IMPLICIT_PTR_DECL (x)
 465              == DEBUG_IMPLICIT_PTR_DECL (y);
 466
 467     case DEBUG_PARAMETER_REF:
 468       return DEBUG_PARAMETER_REF_DECL (x)
 469              == DEBUG_PARAMETER_REF_DECL (y);
 470
 471     case ENTRY_VALUE:
 472       return rtx_equal_p_cb (ENTRY_VALUE_EXP (x), ENTRY_VALUE_EXP (y), cb);
 473
 474     default:
 475       break;
 476     }
 477
 478   /* Compare the elements.  If any pair of corresponding elements
 479      fail to match, return 0 for the whole thing.  */
 480
 481   fmt = GET_RTX_FORMAT (code);
 482   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
 483     {
 484       switch (fmt[i])
 485         {
 486         case 'w':
 487           if (XWINT (x, i) != XWINT (y, i))
 488             return 0;
 489           break;
 490
 491         case 'n':
 492         case 'i':
 493           if (XINT (x, i) != XINT (y, i))
 494             {
 495 #ifndef GENERATOR_FILE
 496               if (((code == ASM_OPERANDS && i == 6)
 497                    || (code == ASM_INPUT && i == 1))
 498                   && XINT (x, i) == XINT (y, i))
 499                 break;
 500 #endif
 501               return 0;
 502             }
 503           break;
 504
 505         case 'p':
 506           if (maybe_ne (SUBREG_BYTE (x), SUBREG_BYTE (y)))
 507             return 0;
 508           break;
 509
 510         case 'V':
 511         case 'E':
 512           /* Two vectors must have the same length.  */
 513           if (XVECLEN (x, i) != XVECLEN (y, i))
 514             return 0;
 515
 516           /* And the corresponding elements must match.  */
 517           for (j = 0; j < XVECLEN (x, i); j++)
 518             if (rtx_equal_p_cb (XVECEXP (x, i, j),
 519                                 XVECEXP (y, i, j), cb) == 0)
 520               return 0;
 521           break;
 522
 523         case 'e':
 524           if (rtx_equal_p_cb (XEXP (x, i), XEXP (y, i), cb) == 0)
 525             return 0;
 526           break;
 527
 528         case 'S':
 529         case 's':
 530           if ((XSTR (x, i) || XSTR (y, i))
 531               && (! XSTR (x, i) || ! XSTR (y, i)
 532                   || strcmp (XSTR (x, i), XSTR (y, i))))
 533             return 0;
 534           break;
 535
 536         case 'u':
 537           /* These are just backpointers, so they don't matter.  */
 538           break;
 539
 540         case '0':
 541         case 't':
 542           break;
 543
 544           /* It is believed that rtx's at this level will never
 545              contain anything but integers and other rtx's,
 546              except for within LABEL_REFs and SYMBOL_REFs.  */
 547         default:
 548           gcc_unreachable ();
 549         }
 550     }
 551   return 1;
 552 }
 553
 554 /* Return 1 if X and Y are identical-looking rtx's.
 555    This is the Lisp function EQUAL for rtx arguments.
 556    Whenever changing this function check if rtx_equal_p_cb above doesn't need
 557    changing as well.  */
 558
 559 int
 560 rtx_equal_p (const_rtx x, const_rtx y)
 561 {
 562   int i;
 563   int j;
 564   enum rtx_code code;
 565   const char *fmt;
 566
 567   if (x == y)
 568     return 1;
 569   if (x == 0 || y == 0)
 570     return 0;
 571
 572   code = GET_CODE (x);
 573   /* Rtx's of different codes cannot be equal.  */
 574   if (code != GET_CODE (y))
 575     return 0;
 576
 577   /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
 578      (REG:SI x) and (REG:HI x) are NOT equivalent.  */
 579
 580   if (GET_MODE (x) != GET_MODE (y))
 581     return 0;
 582
 583   /* MEMs referring to different address space are not equivalent.  */
 584   if (code == MEM && MEM_ADDR_SPACE (x) != MEM_ADDR_SPACE (y))
 585     return 0;
 586
 587   /* Some RTL can be compared nonrecursively.  */
 588   switch (code)
 589     {
 590     case REG:
 591       return (REGNO (x) == REGNO (y));
 592
 593     case LABEL_REF:
 594       return label_ref_label (x) == label_ref_label (y);
 595
 596     case SYMBOL_REF:
 597       return XSTR (x, 0) == XSTR (y, 0);
 598
 599     case DEBUG_EXPR:
 600     case VALUE:
 601     case SCRATCH:
 602     CASE_CONST_UNIQUE:
 603       return 0;
 604
 605     case DEBUG_IMPLICIT_PTR:
 606       return DEBUG_IMPLICIT_PTR_DECL (x)
 607              == DEBUG_IMPLICIT_PTR_DECL (y);
 608
 609     case DEBUG_PARAMETER_REF:
 610       return DEBUG_PARAMETER_REF_DECL (x)
 611              == DEBUG_PARAMETER_REF_DECL (y);
 612
 613     case ENTRY_VALUE:
 614       return rtx_equal_p (ENTRY_VALUE_EXP (x), ENTRY_VALUE_EXP (y));
 615
 616     default:
 617       break;
 618     }
 619
 620   /* Compare the elements.  If any pair of corresponding elements
 621      fail to match, return 0 for the whole thing.  */
 622
 623   fmt = GET_RTX_FORMAT (code);
 624   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
 625     {
 626       switch (fmt[i])
 627         {
 628         case 'w':
 629           if (XWINT (x, i) != XWINT (y, i))
 630             return 0;
 631           break;
 632
 633         case 'n':
 634         case 'i':
 635           if (XINT (x, i) != XINT (y, i))
 636             {
 637 #ifndef GENERATOR_FILE
 638               if (((code == ASM_OPERANDS && i == 6)
 639                    || (code == ASM_INPUT && i == 1))
 640                   && XINT (x, i) == XINT (y, i))
 641                 break;
 642 #endif
 643               return 0;
 644             }
 645           break;
 646
 647         case 'p':
 648           if (maybe_ne (SUBREG_BYTE (x), SUBREG_BYTE (y)))
 649             return 0;
 650           break;
 651
 652         case 'V':
 653         case 'E':
 654           /* Two vectors must have the same length.  */
 655           if (XVECLEN (x, i) != XVECLEN (y, i))
 656             return 0;
 657
 658           /* And the corresponding elements must match.  */
 659           for (j = 0; j < XVECLEN (x, i); j++)
 660             if (rtx_equal_p (XVECEXP (x, i, j),  XVECEXP (y, i, j)) == 0)
 661               return 0;
 662           break;
 663
 664         case 'e':
 665           if (rtx_equal_p (XEXP (x, i), XEXP (y, i)) == 0)
 666             return 0;
 667           break;
 668
 669         case 'S':
 670         case 's':
 671           if ((XSTR (x, i) || XSTR (y, i))
 672               && (! XSTR (x, i) || ! XSTR (y, i)
 673                   || strcmp (XSTR (x, i), XSTR (y, i))))
 674             return 0;
 675           break;
 676
 677         case 'u':
 678           /* These are just backpointers, so they don't matter.  */
 679           break;
 680
 681         case '0':
 682         case 't':
 683           break;
 684
 685           /* It is believed that rtx's at this level will never
 686              contain anything but integers and other rtx's,
 687              except for within LABEL_REFs and SYMBOL_REFs.  */
 688         default:
 689           gcc_unreachable ();
 690         }
 691     }
 692   return 1;
 693 }
 694
 695 /* Return true if all elements of VEC are equal.  */
 696
 697 bool
 698 rtvec_all_equal_p (const_rtvec vec)
 699 {
 700   const_rtx first = RTVEC_ELT (vec, 0);
 701   /* Optimize the important special case of a vector of constants.
 702      The main use of this function is to detect whether every element
 703      of CONST_VECTOR is the same.  */
 704   switch (GET_CODE (first))
 705     {
 706     CASE_CONST_UNIQUE:
 707       for (int i = 1, n = GET_NUM_ELEM (vec); i < n; ++i)
 708         if (first != RTVEC_ELT (vec, i))
 709           return false;
 710       return true;
 711
 712     default:
 713       for (int i = 1, n = GET_NUM_ELEM (vec); i < n; ++i)
 714         if (!rtx_equal_p (first, RTVEC_ELT (vec, i)))
 715           return false;
 716       return true;
 717     }
 718 }
 719
 720 /* Return an indication of which type of insn should have X as a body.
 721    In generator files, this can be UNKNOWN if the answer is only known
 722    at (GCC) runtime.  Otherwise the value is CODE_LABEL, INSN, CALL_INSN
 723    or JUMP_INSN.  */
 724
 725 enum rtx_code
 726 classify_insn (rtx x)
 727 {
 728   if (LABEL_P (x))
 729     return CODE_LABEL;
 730   if (GET_CODE (x) == CALL)
 731     return CALL_INSN;
 732   if (ANY_RETURN_P (x))
 733     return JUMP_INSN;
 734   if (GET_CODE (x) == SET)
 735     {
 736       if (GET_CODE (SET_DEST (x)) == PC)
 737         return JUMP_INSN;
 738       else if (GET_CODE (SET_SRC (x)) == CALL)
 739         return CALL_INSN;
 740       else
 741         return INSN;
 742     }
 743   if (GET_CODE (x) == PARALLEL)
 744     {
 745       int j;
 746       bool has_return_p = false;
 747       for (j = XVECLEN (x, 0) - 1; j >= 0; j--)
 748         if (GET_CODE (XVECEXP (x, 0, j)) == CALL)
 749           return CALL_INSN;
 750         else if (ANY_RETURN_P (XVECEXP (x, 0, j)))
 751           has_return_p = true;
 752         else if (GET_CODE (XVECEXP (x, 0, j)) == SET
 753                  && GET_CODE (SET_DEST (XVECEXP (x, 0, j))) == PC)
 754           return JUMP_INSN;
 755         else if (GET_CODE (XVECEXP (x, 0, j)) == SET
 756                  && GET_CODE (SET_SRC (XVECEXP (x, 0, j))) == CALL)
 757           return CALL_INSN;
 758       if (has_return_p)
 759         return JUMP_INSN;
 760     }
 761 #ifdef GENERATOR_FILE
 762   if (GET_CODE (x) == MATCH_OPERAND
 763       || GET_CODE (x) == MATCH_OPERATOR
 764       || GET_CODE (x) == MATCH_PARALLEL
 765       || GET_CODE (x) == MATCH_OP_DUP
 766       || GET_CODE (x) == MATCH_DUP
 767       || GET_CODE (x) == PARALLEL)
 768     return UNKNOWN;
 769 #endif
 770   return INSN;
 771 }
 772
 773 void
 774 dump_rtx_statistics (void)
 775 {
 776   int i;
 777   int total_counts = 0;
 778   int total_sizes = 0;
 779
 780   if (! GATHER_STATISTICS)
 781     {
 782       fprintf (stderr, "No RTX statistics\n");
 783       return;
 784     }
 785
 786   fprintf (stderr, "\nRTX Kind               Count      Bytes\n");
 787   fprintf (stderr, "---------------------------------------\n");
 788   for (i = 0; i < LAST_AND_UNUSED_RTX_CODE; i++)
 789     if (rtx_alloc_counts[i])
 790       {
 791         fprintf (stderr, "%-20s %7d %10d\n", GET_RTX_NAME (i),
 792                  rtx_alloc_counts[i], rtx_alloc_sizes[i]);
 793         total_counts += rtx_alloc_counts[i];
 794         total_sizes += rtx_alloc_sizes[i];
 795       }
 796   if (rtvec_alloc_counts)
 797     {
 798       fprintf (stderr, "%-20s %7d %10d\n", "rtvec",
 799                rtvec_alloc_counts, rtvec_alloc_sizes);
 800       total_counts += rtvec_alloc_counts;
 801       total_sizes += rtvec_alloc_sizes;
 802     }
 803   fprintf (stderr, "---------------------------------------\n");
 804   fprintf (stderr, "%-20s %7d %10d\n",
 805            "Total", total_counts, total_sizes);
 806   fprintf (stderr, "---------------------------------------\n");
 807 }
 808 \f
 809 #if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007)
 810 void
 811 rtl_check_failed_bounds (const_rtx r, int n, const char *file, int line,
 812                          const char *func)
 813 {
 814   internal_error
 815     ("RTL check: access of elt %d of '%s' with last elt %d in %s, at %s:%d",
 816      n, GET_RTX_NAME (GET_CODE (r)), GET_RTX_LENGTH (GET_CODE (r)) - 1,
 817      func, trim_filename (file), line);
 818 }
 819
 820 void
 821 rtl_check_failed_type1 (const_rtx r, int n, int c1, const char *file, int line,
 822                         const char *func)
 823 {
 824   internal_error
 825     ("RTL check: expected elt %d type '%c', have '%c' (rtx %s) in %s, at %s:%d",
 826      n, c1, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
 827      func, trim_filename (file), line);
 828 }
 829
 830 void
 831 rtl_check_failed_type2 (const_rtx r, int n, int c1, int c2, const char *file,
 832                         int line, const char *func)
 833 {
 834   internal_error
 835     ("RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s) in %s, at %s:%d",
 836      n, c1, c2, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
 837      func, trim_filename (file), line);
 838 }
 839
 840 void
 841 rtl_check_failed_code1 (const_rtx r, enum rtx_code code, const char *file,
 842                         int line, const char *func)
 843 {
 844   internal_error ("RTL check: expected code '%s', have '%s' in %s, at %s:%d",
 845                   GET_RTX_NAME (code), GET_RTX_NAME (GET_CODE (r)), func,
 846                   trim_filename (file), line);
 847 }
 848
 849 void
 850 rtl_check_failed_code2 (const_rtx r, enum rtx_code code1, enum rtx_code code2,
 851                         const char *file, int line, const char *func)
 852 {
 853   internal_error
 854     ("RTL check: expected code '%s' or '%s', have '%s' in %s, at %s:%d",
 855      GET_RTX_NAME (code1), GET_RTX_NAME (code2), GET_RTX_NAME (GET_CODE (r)),
 856      func, trim_filename (file), line);
 857 }
 858
 859 void
 860 rtl_check_failed_code_mode (const_rtx r, enum rtx_code code, machine_mode mode,
 861                             bool not_mode, const char *file, int line,
 862                             const char *func)
 863 {
 864   internal_error ((not_mode
 865                    ? ("RTL check: expected code '%s' and not mode '%s', "
 866                       "have code '%s' and mode '%s' in %s, at %s:%d")
 867                    : ("RTL check: expected code '%s' and mode '%s', "
 868                       "have code '%s' and mode '%s' in %s, at %s:%d")),
 869                   GET_RTX_NAME (code), GET_MODE_NAME (mode),
 870                   GET_RTX_NAME (GET_CODE (r)), GET_MODE_NAME (GET_MODE (r)),
 871                   func, trim_filename (file), line);
 872 }
 873
 874 /* Report that line LINE of FILE tried to access the block symbol fields
 875    of a non-block symbol.  FUNC is the function that contains the line.  */
 876
 877 void
 878 rtl_check_failed_block_symbol (const char *file, int line, const char *func)
 879 {
 880   internal_error
 881     ("RTL check: attempt to treat non-block symbol as a block symbol "
 882      "in %s, at %s:%d", func, trim_filename (file), line);
 883 }
 884
 885 /* XXX Maybe print the vector?  */
 886 void
 887 cwi_check_failed_bounds (const_rtx x, int n, const char *file, int line,
 888                          const char *func)
 889 {
 890   internal_error
 891     ("RTL check: access of hwi elt %d of vector with last elt %d in %s, at %s:%d",
 892      n, CWI_GET_NUM_ELEM (x) - 1, func, trim_filename (file), line);
 893 }
 894
 895 /* XXX Maybe print the vector?  */
 896 void
 897 rtvec_check_failed_bounds (const_rtvec r, int n, const char *file, int line,
 898                            const char *func)
 899 {
 900   internal_error
 901     ("RTL check: access of elt %d of vector with last elt %d in %s, at %s:%d",
 902      n, GET_NUM_ELEM (r) - 1, func, trim_filename (file), line);
 903 }
 904 #endif /* ENABLE_RTL_CHECKING */
 905
 906 #if defined ENABLE_RTL_FLAG_CHECKING
 907 void
 908 rtl_check_failed_flag (const char *name, const_rtx r, const char *file,
 909                        int line, const char *func)
 910 {
 911   internal_error
 912     ("RTL flag check: %s used with unexpected rtx code '%s' in %s, at %s:%d",
 913      name, GET_RTX_NAME (GET_CODE (r)), func, trim_filename (file), line);
 914 }
 915 #endif /* ENABLE_RTL_FLAG_CHECKING */