gcc/rtl.cc

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