LCOV - code coverage report
Current view: top level - gcc - rtl.h (source / functions) Coverage Total Hit
Test: gcc.info Lines: 93.9 % 358 336
Test Date: 2024-09-28 13:20:55 Functions: 92.3 % 65 60
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: - 0 0

             Branch data     Line data    Source code
       1                 :             : /* Register Transfer Language (RTL) definitions for GCC
       2                 :             :    Copyright (C) 1987-2024 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                 :             : #ifndef GCC_RTL_H
      21                 :             : #define GCC_RTL_H
      22                 :             : 
      23                 :             : /* This file is occasionally included by generator files which expect
      24                 :             :    machmode.h and other files to exist and would not normally have been
      25                 :             :    included by coretypes.h.  */
      26                 :             : #ifdef GENERATOR_FILE
      27                 :             : #include "real.h"
      28                 :             : #include "fixed-value.h"
      29                 :             : #include "statistics.h"
      30                 :             : #include "vec.h"
      31                 :             : #include "hash-table.h"
      32                 :             : #include "hash-set.h"
      33                 :             : #include "input.h"
      34                 :             : #include "is-a.h"
      35                 :             : #endif  /* GENERATOR_FILE */
      36                 :             : 
      37                 :             : #include "hard-reg-set.h"
      38                 :             : 
      39                 :             : class predefined_function_abi;
      40                 :             : 
      41                 :             : /* Value used by some passes to "recognize" noop moves as valid
      42                 :             :  instructions.  */
      43                 :             : #define NOOP_MOVE_INSN_CODE     INT_MAX
      44                 :             : 
      45                 :             : /* Register Transfer Language EXPRESSIONS CODES */
      46                 :             : 
      47                 :             : #define RTX_CODE        enum rtx_code
      48                 :             : enum rtx_code : unsigned {
      49                 :             : 
      50                 :             : #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS)   ENUM ,
      51                 :             : #include "rtl.def"            /* rtl expressions are documented here */
      52                 :             : #undef DEF_RTL_EXPR
      53                 :             : 
      54                 :             :   LAST_AND_UNUSED_RTX_CODE};    /* A convenient way to get a value for
      55                 :             :                                    NUM_RTX_CODE.
      56                 :             :                                    Assumes default enum value assignment.  */
      57                 :             : 
      58                 :             : /* The cast here, saves many elsewhere.  */
      59                 :             : #define NUM_RTX_CODE ((int) LAST_AND_UNUSED_RTX_CODE)
      60                 :             : 
      61                 :             : /* Similar, but since generator files get more entries... */
      62                 :             : #ifdef GENERATOR_FILE
      63                 :             : # define NON_GENERATOR_NUM_RTX_CODE ((int) MATCH_OPERAND)
      64                 :             : #endif
      65                 :             : 
      66                 :             : #define RTX_CODE_BITSIZE 8
      67                 :             : 
      68                 :             : /* Register Transfer Language EXPRESSIONS CODE CLASSES */
      69                 :             : 
      70                 :             : enum rtx_class  {
      71                 :             :   /* We check bit 0-1 of some rtx class codes in the predicates below.  */
      72                 :             : 
      73                 :             :   /* Bit 0 = comparison if 0, arithmetic is 1
      74                 :             :      Bit 1 = 1 if commutative.  */
      75                 :             :   RTX_COMPARE,          /* 0 */
      76                 :             :   RTX_COMM_COMPARE,
      77                 :             :   RTX_BIN_ARITH,
      78                 :             :   RTX_COMM_ARITH,
      79                 :             : 
      80                 :             :   /* Must follow the four preceding values.  */
      81                 :             :   RTX_UNARY,            /* 4 */
      82                 :             : 
      83                 :             :   RTX_EXTRA,
      84                 :             :   RTX_MATCH,
      85                 :             :   RTX_INSN,
      86                 :             : 
      87                 :             :   /* Bit 0 = 1 if constant.  */
      88                 :             :   RTX_OBJ,              /* 8 */
      89                 :             :   RTX_CONST_OBJ,
      90                 :             : 
      91                 :             :   RTX_TERNARY,
      92                 :             :   RTX_BITFIELD_OPS,
      93                 :             :   RTX_AUTOINC
      94                 :             : };
      95                 :             : 
      96                 :             : #define RTX_OBJ_MASK (~1)
      97                 :             : #define RTX_OBJ_RESULT (RTX_OBJ & RTX_OBJ_MASK)
      98                 :             : #define RTX_COMPARE_MASK (~1)
      99                 :             : #define RTX_COMPARE_RESULT (RTX_COMPARE & RTX_COMPARE_MASK)
     100                 :             : #define RTX_ARITHMETIC_MASK (~1)
     101                 :             : #define RTX_ARITHMETIC_RESULT (RTX_COMM_ARITH & RTX_ARITHMETIC_MASK)
     102                 :             : #define RTX_BINARY_MASK (~3)
     103                 :             : #define RTX_BINARY_RESULT (RTX_COMPARE & RTX_BINARY_MASK)
     104                 :             : #define RTX_COMMUTATIVE_MASK (~2)
     105                 :             : #define RTX_COMMUTATIVE_RESULT (RTX_COMM_COMPARE & RTX_COMMUTATIVE_MASK)
     106                 :             : #define RTX_NON_COMMUTATIVE_RESULT (RTX_COMPARE & RTX_COMMUTATIVE_MASK)
     107                 :             : 
     108                 :             : extern const unsigned char rtx_length[NUM_RTX_CODE];
     109                 :             : #define GET_RTX_LENGTH(CODE)            (rtx_length[(int) (CODE)])
     110                 :             : 
     111                 :             : extern const char * const rtx_name[NUM_RTX_CODE];
     112                 :             : #define GET_RTX_NAME(CODE)              (rtx_name[(int) (CODE)])
     113                 :             : 
     114                 :             : extern const char * const rtx_format[NUM_RTX_CODE];
     115                 :             : #define GET_RTX_FORMAT(CODE)            (rtx_format[(int) (CODE)])
     116                 :             : 
     117                 :             : extern const enum rtx_class rtx_class[NUM_RTX_CODE];
     118                 :             : #define GET_RTX_CLASS(CODE)             (rtx_class[(int) (CODE)])
     119                 :             : 
     120                 :             : /* True if CODE is part of the insn chain (i.e. has INSN_UID, PREV_INSN
     121                 :             :    and NEXT_INSN fields).  */
     122                 :             : #define INSN_CHAIN_CODE_P(CODE) IN_RANGE (CODE, DEBUG_INSN, NOTE)
     123                 :             : 
     124                 :             : extern const unsigned char rtx_code_size[NUM_RTX_CODE];
     125                 :             : extern const unsigned char rtx_next[NUM_RTX_CODE];
     126                 :             : 
     127                 :             : /* The flags and bitfields of an ADDR_DIFF_VEC.  BASE is the base label
     128                 :             :    relative to which the offsets are calculated, as explained in rtl.def.  */
     129                 :             : struct addr_diff_vec_flags
     130                 :             : {
     131                 :             :   /* Set at the start of shorten_branches - ONLY WHEN OPTIMIZING - : */
     132                 :             :   unsigned min_align: 8;
     133                 :             :   /* Flags: */
     134                 :             :   unsigned base_after_vec: 1; /* BASE is after the ADDR_DIFF_VEC.  */
     135                 :             :   unsigned min_after_vec: 1;  /* minimum address target label is
     136                 :             :                                  after the ADDR_DIFF_VEC.  */
     137                 :             :   unsigned max_after_vec: 1;  /* maximum address target label is
     138                 :             :                                  after the ADDR_DIFF_VEC.  */
     139                 :             :   unsigned min_after_base: 1; /* minimum address target label is
     140                 :             :                                  after BASE.  */
     141                 :             :   unsigned max_after_base: 1; /* maximum address target label is
     142                 :             :                                  after BASE.  */
     143                 :             :   /* Set by the actual branch shortening process - ONLY WHEN OPTIMIZING - : */
     144                 :             :   unsigned offset_unsigned: 1; /* offsets have to be treated as unsigned.  */
     145                 :             :   unsigned : 2;
     146                 :             :   unsigned scale : 8;
     147                 :             : };
     148                 :             : 
     149                 :             : /* Structure used to describe the attributes of a MEM.  These are hashed
     150                 :             :    so MEMs that the same attributes share a data structure.  This means
     151                 :             :    they cannot be modified in place.  */
     152                 :             : class GTY(()) mem_attrs
     153                 :             : {
     154                 :             : public:
     155                 :             :   mem_attrs ();
     156                 :             : 
     157                 :             :   /* The expression that the MEM accesses, or null if not known.
     158                 :             :      This expression might be larger than the memory reference itself.
     159                 :             :      (In other words, the MEM might access only part of the object.)  */
     160                 :             :   tree expr;
     161                 :             : 
     162                 :             :   /* The offset of the memory reference from the start of EXPR.
     163                 :             :      Only valid if OFFSET_KNOWN_P.  */
     164                 :             :   poly_int64 offset;
     165                 :             : 
     166                 :             :   /* The size of the memory reference in bytes.  Only valid if
     167                 :             :      SIZE_KNOWN_P.  */
     168                 :             :   poly_int64 size;
     169                 :             : 
     170                 :             :   /* The alias set of the memory reference.  */
     171                 :             :   alias_set_type alias;
     172                 :             : 
     173                 :             :   /* The alignment of the reference in bits.  Always a multiple of
     174                 :             :      BITS_PER_UNIT.  Note that EXPR may have a stricter alignment
     175                 :             :      than the memory reference itself.  */
     176                 :             :   unsigned int align;
     177                 :             : 
     178                 :             :   /* The address space that the memory reference uses.  */
     179                 :             :   unsigned char addrspace;
     180                 :             : 
     181                 :             :   /* True if OFFSET is known.  */
     182                 :             :   bool offset_known_p;
     183                 :             : 
     184                 :             :   /* True if SIZE is known.  */
     185                 :             :   bool size_known_p;
     186                 :             : };
     187                 :             : 
     188                 :             : /* Structure used to describe the attributes of a REG in similar way as
     189                 :             :    mem_attrs does for MEM above.  Note that the OFFSET field is calculated
     190                 :             :    in the same way as for mem_attrs, rather than in the same way as a
     191                 :             :    SUBREG_BYTE.  For example, if a big-endian target stores a byte
     192                 :             :    object in the low part of a 4-byte register, the OFFSET field
     193                 :             :    will be -3 rather than 0.  */
     194                 :             : 
     195                 :             : class GTY((for_user)) reg_attrs {
     196                 :             : public:
     197                 :             :   tree decl;                    /* decl corresponding to REG.  */
     198                 :             :   poly_int64 offset;            /* Offset from start of DECL.  */
     199                 :             : };
     200                 :             : 
     201                 :             : /* Common union for an element of an rtx.  */
     202                 :             : 
     203                 :             : union rtunion
     204                 :             : {
     205                 :             :   int rt_int;
     206                 :             :   unsigned int rt_uint;
     207                 :             :   poly_uint16 rt_subreg;
     208                 :             :   const char *rt_str;
     209                 :             :   rtx rt_rtx;
     210                 :             :   rtvec rt_rtvec;
     211                 :             :   machine_mode rt_type;
     212                 :             :   addr_diff_vec_flags rt_addr_diff_vec_flags;
     213                 :             :   struct cselib_val *rt_cselib;
     214                 :             :   tree rt_tree;
     215                 :             :   basic_block rt_bb;
     216                 :             :   mem_attrs *rt_mem;
     217                 :             :   class constant_descriptor_rtx *rt_constant;
     218                 :             :   struct dw_cfi_node *rt_cfi;
     219                 :             : };
     220                 :             : 
     221                 :             : /* Describes the properties of a REG.  */
     222                 :             : struct GTY(()) reg_info {
     223                 :             :   /* The value of REGNO.  */
     224                 :             :   unsigned int regno;
     225                 :             : 
     226                 :             :   /* The value of REG_NREGS.  */
     227                 :             :   unsigned int nregs : 8;
     228                 :             :   unsigned int unused : 24;
     229                 :             : 
     230                 :             :   /* The value of REG_ATTRS.  */
     231                 :             :   reg_attrs *attrs;
     232                 :             : };
     233                 :             : 
     234                 :             : /* This structure remembers the position of a SYMBOL_REF within an
     235                 :             :    object_block structure.  A SYMBOL_REF only provides this information
     236                 :             :    if SYMBOL_REF_HAS_BLOCK_INFO_P is true.  */
     237                 :             : struct GTY(()) block_symbol {
     238                 :             :   /* The usual SYMBOL_REF fields.  */
     239                 :             :   rtunion GTY ((skip)) fld[2];
     240                 :             : 
     241                 :             :   /* The block that contains this object.  */
     242                 :             :   struct object_block *block;
     243                 :             : 
     244                 :             :   /* The offset of this object from the start of its block.  It is negative
     245                 :             :      if the symbol has not yet been assigned an offset.  */
     246                 :             :   HOST_WIDE_INT offset;
     247                 :             : };
     248                 :             : 
     249                 :             : /* Describes a group of objects that are to be placed together in such
     250                 :             :    a way that their relative positions are known.  */
     251                 :             : struct GTY((for_user)) object_block {
     252                 :             :   /* The section in which these objects should be placed.  */
     253                 :             :   section *sect;
     254                 :             : 
     255                 :             :   /* The alignment of the first object, measured in bits.  */
     256                 :             :   unsigned int alignment;
     257                 :             : 
     258                 :             :   /* The total size of the objects, measured in bytes.  */
     259                 :             :   HOST_WIDE_INT size;
     260                 :             : 
     261                 :             :   /* The SYMBOL_REFs for each object.  The vector is sorted in
     262                 :             :      order of increasing offset and the following conditions will
     263                 :             :      hold for each element X:
     264                 :             : 
     265                 :             :          SYMBOL_REF_HAS_BLOCK_INFO_P (X)
     266                 :             :          !SYMBOL_REF_ANCHOR_P (X)
     267                 :             :          SYMBOL_REF_BLOCK (X) == [address of this structure]
     268                 :             :          SYMBOL_REF_BLOCK_OFFSET (X) >= 0.  */
     269                 :             :   vec<rtx, va_gc> *objects;
     270                 :             : 
     271                 :             :   /* All the anchor SYMBOL_REFs used to address these objects, sorted
     272                 :             :      in order of increasing offset, and then increasing TLS model.
     273                 :             :      The following conditions will hold for each element X in this vector:
     274                 :             : 
     275                 :             :          SYMBOL_REF_HAS_BLOCK_INFO_P (X)
     276                 :             :          SYMBOL_REF_ANCHOR_P (X)
     277                 :             :          SYMBOL_REF_BLOCK (X) == [address of this structure]
     278                 :             :          SYMBOL_REF_BLOCK_OFFSET (X) >= 0.  */
     279                 :             :   vec<rtx, va_gc> *anchors;
     280                 :             : };
     281                 :             : 
     282                 :             : struct GTY((variable_size)) hwivec_def {
     283                 :             :   HOST_WIDE_INT elem[1];
     284                 :             : };
     285                 :             : 
     286                 :             : /* Number of elements of the HWIVEC if RTX is a CONST_WIDE_INT.  */
     287                 :             : #define CWI_GET_NUM_ELEM(RTX)                                   \
     288                 :             :   ((int)RTL_FLAG_CHECK1("CWI_GET_NUM_ELEM", (RTX), CONST_WIDE_INT)->u2.num_elem)
     289                 :             : #define CWI_PUT_NUM_ELEM(RTX, NUM)                                      \
     290                 :             :   (RTL_FLAG_CHECK1("CWI_PUT_NUM_ELEM", (RTX), CONST_WIDE_INT)->u2.num_elem = (NUM))
     291                 :             : 
     292                 :             : struct GTY((variable_size)) const_poly_int_def {
     293                 :             :   trailing_wide_ints<NUM_POLY_INT_COEFFS> coeffs;
     294                 :             : };
     295                 :             : 
     296                 :             : /* RTL expression ("rtx").  */
     297                 :             : 
     298                 :             : /* The GTY "desc" and "tag" options below are a kludge: we need a desc
     299                 :             :    field for gengtype to recognize that inheritance is occurring,
     300                 :             :    so that all subclasses are redirected to the traversal hook for the
     301                 :             :    base class.
     302                 :             :    However, all of the fields are in the base class, and special-casing
     303                 :             :    is at work.  Hence we use desc and tag of 0, generating a switch
     304                 :             :    statement of the form:
     305                 :             :      switch (0)
     306                 :             :        {
     307                 :             :        case 0: // all the work happens here
     308                 :             :       }
     309                 :             :    in order to work with the existing special-casing in gengtype.  */
     310                 :             : 
     311                 :             : struct GTY((desc("0"), tag("0"),
     312                 :             :             chain_next ("RTX_NEXT (&%h)"),
     313                 :             :             chain_prev ("RTX_PREV (&%h)"))) rtx_def {
     314                 :             :   /* The kind of value the expression has.  */
     315                 :             :   ENUM_BITFIELD(machine_mode) mode : MACHINE_MODE_BITSIZE;
     316                 :             : 
     317                 :             :   /* The kind of expression this is.  */
     318                 :             :   ENUM_BITFIELD(rtx_code) code: RTX_CODE_BITSIZE;
     319                 :             : 
     320                 :             :   /* 1 in a MEM if we should keep the alias set for this mem unchanged
     321                 :             :      when we access a component.
     322                 :             :      1 in a JUMP_INSN if it is a crossing jump.
     323                 :             :      1 in a CALL_INSN if it is a sibling call.
     324                 :             :      1 in a SET that is for a return.
     325                 :             :      In a CODE_LABEL, part of the two-bit alternate entry field.
     326                 :             :      1 in a CONCAT is VAL_EXPR_IS_COPIED in var-tracking.cc.
     327                 :             :      1 in a VALUE is SP_BASED_VALUE_P in cselib.cc.
     328                 :             :      1 in a SUBREG generated by LRA for reload insns.
     329                 :             :      1 in a REG if this is a static chain register.
     330                 :             :      Dumped as "/j" in RTL dumps.  */
     331                 :             :   unsigned int jump : 1;
     332                 :             :   /* In a CODE_LABEL, part of the two-bit alternate entry field.
     333                 :             :      1 in a MEM if it cannot trap.
     334                 :             :      1 in a CALL_INSN logically equivalent to
     335                 :             :        ECF_LOOPING_CONST_OR_PURE and DECL_LOOPING_CONST_OR_PURE_P.
     336                 :             :      1 in a VALUE is SP_DERIVED_VALUE_P in cselib.cc.
     337                 :             :      Dumped as "/c" in RTL dumps.  */
     338                 :             :   unsigned int call : 1;
     339                 :             :   /* 1 in a REG, MEM, or CONCAT if the value is set at most once, anywhere.
     340                 :             :      1 in a SUBREG used for SUBREG_PROMOTED_UNSIGNED_P.
     341                 :             :      1 in a SYMBOL_REF if it addresses something in the per-function
     342                 :             :      constants pool.
     343                 :             :      1 in a CALL_INSN logically equivalent to ECF_CONST and TREE_READONLY.
     344                 :             :      1 in a NOTE, or EXPR_LIST for a const call.
     345                 :             :      1 in a JUMP_INSN of an annulling branch.
     346                 :             :      1 in a CONCAT is VAL_EXPR_IS_CLOBBERED in var-tracking.cc.
     347                 :             :      1 in a preserved VALUE is PRESERVED_VALUE_P in cselib.cc.
     348                 :             :      1 in a clobber temporarily created for LRA.
     349                 :             :      Dumped as "/u" in RTL dumps.  */
     350                 :             :   unsigned int unchanging : 1;
     351                 :             :   /* 1 in a MEM or ASM_OPERANDS expression if the memory reference is volatile.
     352                 :             :      1 in an INSN, CALL_INSN, JUMP_INSN, CODE_LABEL, BARRIER, or NOTE
     353                 :             :      if it has been deleted.
     354                 :             :      1 in a REG expression if corresponds to a variable declared by the user,
     355                 :             :      0 for an internally generated temporary.
     356                 :             :      1 in a SUBREG used for SUBREG_PROMOTED_UNSIGNED_P.
     357                 :             :      1 in a LABEL_REF, REG_LABEL_TARGET or REG_LABEL_OPERAND note for a
     358                 :             :      non-local label.
     359                 :             :      In a SYMBOL_REF, this flag is used for machine-specific purposes.
     360                 :             :      In a PREFETCH, this flag indicates that it should be considered a
     361                 :             :      scheduling barrier.
     362                 :             :      1 in a CONCAT is VAL_NEEDS_RESOLUTION in var-tracking.cc.
     363                 :             :      Dumped as "/v" in RTL dumps.  */
     364                 :             :   unsigned int volatil : 1;
     365                 :             :   /* 1 in a REG if the register is used only in exit code a loop.
     366                 :             :      1 in a SUBREG expression if was generated from a variable with a
     367                 :             :      promoted mode.
     368                 :             :      1 in a CODE_LABEL if the label is used for nonlocal gotos
     369                 :             :      and must not be deleted even if its count is zero.
     370                 :             :      1 in an INSN, JUMP_INSN or CALL_INSN if this insn must be scheduled
     371                 :             :      together with the preceding insn.  Valid only within sched.
     372                 :             :      1 in an INSN, JUMP_INSN, or CALL_INSN if insn is in a delay slot and
     373                 :             :      from the target of a branch.  Valid from reorg until end of compilation;
     374                 :             :      cleared before used.
     375                 :             : 
     376                 :             :      The name of the field is historical.  It used to be used in MEMs
     377                 :             :      to record whether the MEM accessed part of a structure.
     378                 :             :      Dumped as "/s" in RTL dumps.  */
     379                 :             :   unsigned int in_struct : 1;
     380                 :             :   /* At the end of RTL generation, 1 if this rtx is used.  This is used for
     381                 :             :      copying shared structure.  See `unshare_all_rtl'.
     382                 :             :      In a REG, this is not needed for that purpose, and used instead
     383                 :             :      in `leaf_renumber_regs_insn'.
     384                 :             :      1 in a SYMBOL_REF, means that emit_library_call
     385                 :             :      has used it as the function.
     386                 :             :      1 in a CONCAT is VAL_HOLDS_TRACK_EXPR in var-tracking.cc.
     387                 :             :      1 in a VALUE or DEBUG_EXPR is VALUE_RECURSED_INTO in var-tracking.cc.  */
     388                 :             :   unsigned int used : 1;
     389                 :             :   /* 1 in an INSN or a SET if this rtx is related to the call frame,
     390                 :             :      either changing how we compute the frame address or saving and
     391                 :             :      restoring registers in the prologue and epilogue.
     392                 :             :      1 in a REG or MEM if it is a pointer.
     393                 :             :      1 in a SYMBOL_REF if it addresses something in the per-function
     394                 :             :      constant string pool.
     395                 :             :      1 in a VALUE is VALUE_CHANGED in var-tracking.cc.
     396                 :             :      Dumped as "/f" in RTL dumps.  */
     397                 :             :   unsigned frame_related : 1;
     398                 :             :   /* 1 in a REG or PARALLEL that is the current function's return value.
     399                 :             :      1 in a SYMBOL_REF for a weak symbol.
     400                 :             :      1 in a CALL_INSN logically equivalent to ECF_PURE and DECL_PURE_P.
     401                 :             :      1 in a CONCAT is VAL_EXPR_HAS_REVERSE in var-tracking.cc.
     402                 :             :      1 in a VALUE or DEBUG_EXPR is NO_LOC_P in var-tracking.cc.
     403                 :             :      Dumped as "/i" in RTL dumps.  */
     404                 :             :   unsigned return_val : 1;
     405                 :             : 
     406                 :             :   union {
     407                 :             :     /* The final union field is aligned to 64 bits on LP64 hosts,
     408                 :             :        giving a 32-bit gap after the fields above.  We optimize the
     409                 :             :        layout for that case and use the gap for extra code-specific
     410                 :             :        information.  */
     411                 :             : 
     412                 :             :     /* The ORIGINAL_REGNO of a REG.  */
     413                 :             :     unsigned int original_regno;
     414                 :             : 
     415                 :             :     /* The INSN_UID of an RTX_INSN-class code.  */
     416                 :             :     int insn_uid;
     417                 :             : 
     418                 :             :     /* The SYMBOL_REF_FLAGS of a SYMBOL_REF.  */
     419                 :             :     unsigned int symbol_ref_flags;
     420                 :             : 
     421                 :             :     /* The PAT_VAR_LOCATION_STATUS of a VAR_LOCATION.  */
     422                 :             :     enum var_init_status var_location_status;
     423                 :             : 
     424                 :             :     /* In a CONST_WIDE_INT (aka hwivec_def), this is the number of
     425                 :             :        HOST_WIDE_INTs in the hwivec_def.  */
     426                 :             :     unsigned int num_elem;
     427                 :             : 
     428                 :             :     /* Information about a CONST_VECTOR.  */
     429                 :             :     struct
     430                 :             :     {
     431                 :             :       /* The value of CONST_VECTOR_NPATTERNS.  */
     432                 :             :       unsigned int npatterns : 16;
     433                 :             : 
     434                 :             :       /* The value of CONST_VECTOR_NELTS_PER_PATTERN.  */
     435                 :             :       unsigned int nelts_per_pattern : 8;
     436                 :             : 
     437                 :             :       /* For future expansion.  */
     438                 :             :       unsigned int unused : 8;
     439                 :             :     } const_vector;
     440                 :             :   } GTY ((skip)) u2;
     441                 :             : 
     442                 :             :   /* The first element of the operands of this rtx.
     443                 :             :      The number of operands and their types are controlled
     444                 :             :      by the `code' field, according to rtl.def.  */
     445                 :             :   union u {
     446                 :             :     rtunion fld[1];
     447                 :             :     HOST_WIDE_INT hwint[1];
     448                 :             :     struct reg_info reg;
     449                 :             :     struct block_symbol block_sym;
     450                 :             :     struct real_value rv;
     451                 :             :     struct fixed_value fv;
     452                 :             :     struct hwivec_def hwiv;
     453                 :             :     struct const_poly_int_def cpi;
     454                 :             :   } GTY ((special ("rtx_def"), desc ("GET_CODE (&%0)"))) u;
     455                 :             : };
     456                 :             : 
     457                 :             : /* A node for constructing singly-linked lists of rtx.  */
     458                 :             : 
     459                 :             : struct GTY(()) rtx_expr_list : public rtx_def
     460                 :             : {
     461                 :             : private:
     462                 :             :   /* No extra fields, but adds invariant: (GET_CODE (X) == EXPR_LIST).  */
     463                 :             : 
     464                 :             : public:
     465                 :             :   /* Get next in list.  */
     466                 :             :   rtx_expr_list *next () const;
     467                 :             : 
     468                 :             :   /* Get at the underlying rtx.  */
     469                 :             :   rtx element () const;
     470                 :             : };
     471                 :             : 
     472                 :             : template <>
     473                 :             : template <>
     474                 :             : inline bool
     475                 :   858695306 : is_a_helper <rtx_expr_list *>::test (rtx rt)
     476                 :             : {
     477                 :   858695306 :   return rt->code == EXPR_LIST;
     478                 :             : }
     479                 :             : 
     480                 :             : struct GTY(()) rtx_insn_list : public rtx_def
     481                 :             : {
     482                 :             : private:
     483                 :             :   /* No extra fields, but adds invariant: (GET_CODE (X) == INSN_LIST).
     484                 :             : 
     485                 :             :      This is an instance of:
     486                 :             : 
     487                 :             :        DEF_RTL_EXPR(INSN_LIST, "insn_list", "ue", RTX_EXTRA)
     488                 :             : 
     489                 :             :      i.e. a node for constructing singly-linked lists of rtx_insn *, where
     490                 :             :      the list is "external" to the insn (as opposed to the doubly-linked
     491                 :             :      list embedded within rtx_insn itself).  */
     492                 :             : 
     493                 :             : public:
     494                 :             :   /* Get next in list.  */
     495                 :             :   rtx_insn_list *next () const;
     496                 :             : 
     497                 :             :   /* Get at the underlying instruction.  */
     498                 :             :   rtx_insn *insn () const;
     499                 :             : 
     500                 :             : };
     501                 :             : 
     502                 :             : template <>
     503                 :             : template <>
     504                 :             : inline bool
     505                 :  2101928931 : is_a_helper <rtx_insn_list *>::test (rtx rt)
     506                 :             : {
     507                 :  2101928931 :   return rt->code == INSN_LIST;
     508                 :             : }
     509                 :             : 
     510                 :             : /* A node with invariant GET_CODE (X) == SEQUENCE i.e. a vector of rtx,
     511                 :             :    typically (but not always) of rtx_insn *, used in the late passes.  */
     512                 :             : 
     513                 :             : struct GTY(()) rtx_sequence : public rtx_def
     514                 :             : {
     515                 :             : private:
     516                 :             :   /* No extra fields, but adds invariant: (GET_CODE (X) == SEQUENCE).  */
     517                 :             : 
     518                 :             : public:
     519                 :             :   /* Get number of elements in sequence.  */
     520                 :             :   int len () const;
     521                 :             : 
     522                 :             :   /* Get i-th element of the sequence.  */
     523                 :             :   rtx element (int index) const;
     524                 :             : 
     525                 :             :   /* Get i-th element of the sequence, with a checked cast to
     526                 :             :      rtx_insn *.  */
     527                 :             :   rtx_insn *insn (int index) const;
     528                 :             : };
     529                 :             : 
     530                 :             : template <>
     531                 :             : template <>
     532                 :             : inline bool
     533                 :   740203612 : is_a_helper <rtx_sequence *>::test (rtx rt)
     534                 :             : {
     535                 :   740203612 :   return rt->code == SEQUENCE;
     536                 :             : }
     537                 :             : 
     538                 :             : template <>
     539                 :             : template <>
     540                 :             : inline bool
     541                 :           0 : is_a_helper <const rtx_sequence *>::test (const_rtx rt)
     542                 :             : {
     543                 :           0 :   return rt->code == SEQUENCE;
     544                 :             : }
     545                 :             : 
     546                 :             : struct GTY(()) rtx_insn : public rtx_def
     547                 :             : {
     548                 :             : public:
     549                 :             :   /* No extra fields, but adds the invariant:
     550                 :             : 
     551                 :             :      (INSN_P (X)
     552                 :             :       || NOTE_P (X)
     553                 :             :       || JUMP_TABLE_DATA_P (X)
     554                 :             :       || BARRIER_P (X)
     555                 :             :       || LABEL_P (X))
     556                 :             : 
     557                 :             :      i.e. that we must be able to use the following:
     558                 :             :       INSN_UID ()
     559                 :             :       NEXT_INSN ()
     560                 :             :       PREV_INSN ()
     561                 :             :     i.e. we have an rtx that has an INSN_UID field and can be part of
     562                 :             :     a linked list of insns.
     563                 :             :   */
     564                 :             : 
     565                 :             :   /* Returns true if this insn has been deleted.  */
     566                 :             : 
     567                 :  1967886020 :   bool deleted () const { return volatil; }
     568                 :             : 
     569                 :             :   /* Mark this insn as deleted.  */
     570                 :             : 
     571                 :   113362100 :   void set_deleted () { volatil = true; }
     572                 :             : 
     573                 :             :   /* Mark this insn as not deleted.  */
     574                 :             : 
     575                 :       11501 :   void set_undeleted () { volatil = false; }
     576                 :             : };
     577                 :             : 
     578                 :             : /* Subclasses of rtx_insn.  */
     579                 :             : 
     580                 :             : struct GTY(()) rtx_debug_insn : public rtx_insn
     581                 :             : {
     582                 :             :   /* No extra fields, but adds the invariant:
     583                 :             :        DEBUG_INSN_P (X) aka (GET_CODE (X) == DEBUG_INSN)
     584                 :             :      i.e. an annotation for tracking variable assignments.
     585                 :             : 
     586                 :             :      This is an instance of:
     587                 :             :        DEF_RTL_EXPR(DEBUG_INSN, "debug_insn", "uuBeiie", RTX_INSN)
     588                 :             :      from rtl.def.  */
     589                 :             : };
     590                 :             : 
     591                 :             : struct GTY(()) rtx_nonjump_insn : public rtx_insn
     592                 :             : {
     593                 :             :   /* No extra fields, but adds the invariant:
     594                 :             :        NONJUMP_INSN_P (X) aka (GET_CODE (X) == INSN)
     595                 :             :      i.e an instruction that cannot jump.
     596                 :             : 
     597                 :             :      This is an instance of:
     598                 :             :        DEF_RTL_EXPR(INSN, "insn", "uuBeiie", RTX_INSN)
     599                 :             :      from rtl.def.  */
     600                 :             : };
     601                 :             : 
     602                 :             : struct GTY(()) rtx_jump_insn : public rtx_insn
     603                 :             : {
     604                 :             : public:
     605                 :             :   /* No extra fields, but adds the invariant:
     606                 :             :        JUMP_P (X) aka (GET_CODE (X) == JUMP_INSN)
     607                 :             :      i.e. an instruction that can possibly jump.
     608                 :             : 
     609                 :             :      This is an instance of:
     610                 :             :        DEF_RTL_EXPR(JUMP_INSN, "jump_insn", "uuBeiie0", RTX_INSN)
     611                 :             :      from rtl.def.  */
     612                 :             : 
     613                 :             :   /* Returns jump target of this instruction.  The returned value is not
     614                 :             :      necessarily a code label: it may also be a RETURN or SIMPLE_RETURN
     615                 :             :      expression.  Also, when the code label is marked "deleted", it is
     616                 :             :      replaced by a NOTE.  In some cases the value is NULL_RTX.  */
     617                 :             : 
     618                 :             :   inline rtx jump_label () const;
     619                 :             : 
     620                 :             :   /* Returns jump target cast to rtx_code_label *.  */
     621                 :             : 
     622                 :             :   inline rtx_code_label *jump_target () const;
     623                 :             : 
     624                 :             :   /* Set jump target.  */
     625                 :             : 
     626                 :             :   inline void set_jump_target (rtx_code_label *);
     627                 :             : };
     628                 :             : 
     629                 :             : struct GTY(()) rtx_call_insn : public rtx_insn
     630                 :             : {
     631                 :             :   /* No extra fields, but adds the invariant:
     632                 :             :        CALL_P (X) aka (GET_CODE (X) == CALL_INSN)
     633                 :             :      i.e. an instruction that can possibly call a subroutine
     634                 :             :      but which will not change which instruction comes next
     635                 :             :      in the current function.
     636                 :             : 
     637                 :             :      This is an instance of:
     638                 :             :        DEF_RTL_EXPR(CALL_INSN, "call_insn", "uuBeiiee", RTX_INSN)
     639                 :             :      from rtl.def.  */
     640                 :             : };
     641                 :             : 
     642                 :             : struct GTY(()) rtx_jump_table_data : public rtx_insn
     643                 :             : {
     644                 :             :   /* No extra fields, but adds the invariant:
     645                 :             :        JUMP_TABLE_DATA_P (X) aka (GET_CODE (INSN) == JUMP_TABLE_DATA)
     646                 :             :      i.e. a data for a jump table, considered an instruction for
     647                 :             :      historical reasons.
     648                 :             : 
     649                 :             :      This is an instance of:
     650                 :             :        DEF_RTL_EXPR(JUMP_TABLE_DATA, "jump_table_data", "uuBe0000", RTX_INSN)
     651                 :             :      from rtl.def.  */
     652                 :             : 
     653                 :             :   /* This can be either:
     654                 :             : 
     655                 :             :        (a) a table of absolute jumps, in which case PATTERN (this) is an
     656                 :             :            ADDR_VEC with arg 0 a vector of labels, or
     657                 :             : 
     658                 :             :        (b) a table of relative jumps (e.g. for -fPIC), in which case
     659                 :             :            PATTERN (this) is an ADDR_DIFF_VEC, with arg 0 a LABEL_REF and
     660                 :             :            arg 1 the vector of labels.
     661                 :             : 
     662                 :             :      This method gets the underlying vec.  */
     663                 :             : 
     664                 :             :   inline rtvec get_labels () const;
     665                 :             :   inline scalar_int_mode get_data_mode () const;
     666                 :             : };
     667                 :             : 
     668                 :             : struct GTY(()) rtx_barrier : public rtx_insn
     669                 :             : {
     670                 :             :   /* No extra fields, but adds the invariant:
     671                 :             :        BARRIER_P (X) aka (GET_CODE (X) == BARRIER)
     672                 :             :      i.e. a marker that indicates that control will not flow through.
     673                 :             : 
     674                 :             :      This is an instance of:
     675                 :             :        DEF_RTL_EXPR(BARRIER, "barrier", "uu00000", RTX_EXTRA)
     676                 :             :      from rtl.def.  */
     677                 :             : };
     678                 :             : 
     679                 :             : struct GTY(()) rtx_code_label : public rtx_insn
     680                 :             : {
     681                 :             :   /* No extra fields, but adds the invariant:
     682                 :             :        LABEL_P (X) aka (GET_CODE (X) == CODE_LABEL)
     683                 :             :      i.e. a label in the assembler.
     684                 :             : 
     685                 :             :      This is an instance of:
     686                 :             :        DEF_RTL_EXPR(CODE_LABEL, "code_label", "uuB00is", RTX_EXTRA)
     687                 :             :      from rtl.def.  */
     688                 :             : };
     689                 :             : 
     690                 :             : struct GTY(()) rtx_note : public rtx_insn
     691                 :             : {
     692                 :             :   /* No extra fields, but adds the invariant:
     693                 :             :        NOTE_P(X) aka (GET_CODE (X) == NOTE)
     694                 :             :      i.e. a note about the corresponding source code.
     695                 :             : 
     696                 :             :      This is an instance of:
     697                 :             :        DEF_RTL_EXPR(NOTE, "note", "uuB0ni", RTX_EXTRA)
     698                 :             :      from rtl.def.  */
     699                 :             : };
     700                 :             : 
     701                 :             : /* The size in bytes of an rtx header (code, mode and flags).  */
     702                 :             : #define RTX_HDR_SIZE offsetof (struct rtx_def, u)
     703                 :             : 
     704                 :             : /* The size in bytes of an rtx with code CODE.  */
     705                 :             : #define RTX_CODE_SIZE(CODE) rtx_code_size[CODE]
     706                 :             : 
     707                 :             : #define NULL_RTX (rtx) 0
     708                 :             : 
     709                 :             : /* The "next" and "previous" RTX, relative to this one.  */
     710                 :             : 
     711                 :             : #define RTX_NEXT(X) (rtx_next[GET_CODE (X)] == 0 ? NULL                 \
     712                 :             :                      : *(rtx *)(((char *)X) + rtx_next[GET_CODE (X)]))
     713                 :             : 
     714                 :             : /* FIXME: the "NEXT_INSN (PREV_INSN (X)) == X" condition shouldn't be needed.
     715                 :             :  */
     716                 :             : #define RTX_PREV(X) ((INSN_P (X)                        \
     717                 :             :                       || NOTE_P (X)                     \
     718                 :             :                       || JUMP_TABLE_DATA_P (X)          \
     719                 :             :                       || BARRIER_P (X)                  \
     720                 :             :                       || LABEL_P (X))                   \
     721                 :             :                      && PREV_INSN (as_a <rtx_insn *> (X)) != NULL \
     722                 :             :                      && NEXT_INSN (PREV_INSN (as_a <rtx_insn *> (X))) == X \
     723                 :             :                      ? PREV_INSN (as_a <rtx_insn *> (X)) : NULL)
     724                 :             : 
     725                 :             : /* Define macros to access the `code' field of the rtx.  */
     726                 :             : 
     727                 :             : #define GET_CODE(RTX)       ((enum rtx_code) (RTX)->code)
     728                 :             : #define PUT_CODE(RTX, CODE) ((RTX)->code = (CODE))
     729                 :             : 
     730                 :             : #define GET_MODE(RTX)           ((machine_mode) (RTX)->mode)
     731                 :             : #define PUT_MODE_RAW(RTX, MODE) ((RTX)->mode = (MODE))
     732                 :             : 
     733                 :             : /* RTL vector.  These appear inside RTX's when there is a need
     734                 :             :    for a variable number of things.  The principle use is inside
     735                 :             :    PARALLEL expressions.  */
     736                 :             : 
     737                 :             : struct GTY(()) rtvec_def {
     738                 :             :   int num_elem;         /* number of elements */
     739                 :             :   rtx GTY ((length ("%h.num_elem"))) elem[1];
     740                 :             : };
     741                 :             : 
     742                 :             : #define NULL_RTVEC (rtvec) 0
     743                 :             : 
     744                 :             : #define GET_NUM_ELEM(RTVEC)             ((RTVEC)->num_elem)
     745                 :             : #define PUT_NUM_ELEM(RTVEC, NUM)        ((RTVEC)->num_elem = (NUM))
     746                 :             : 
     747                 :             : /* Predicate yielding nonzero iff X is an rtx for a register.  */
     748                 :             : #define REG_P(X) (GET_CODE (X) == REG)
     749                 :             : 
     750                 :             : /* Predicate yielding nonzero iff X is an rtx for a memory location.  */
     751                 :             : #define MEM_P(X) (GET_CODE (X) == MEM)
     752                 :             : 
     753                 :             : #if TARGET_SUPPORTS_WIDE_INT
     754                 :             : 
     755                 :             : /* Match CONST_*s that can represent compile-time constant integers.  */
     756                 :             : #define CASE_CONST_SCALAR_INT \
     757                 :             :    case CONST_INT: \
     758                 :             :    case CONST_WIDE_INT
     759                 :             : 
     760                 :             : /* Match CONST_*s for which pointer equality corresponds to value
     761                 :             :    equality.  */
     762                 :             : #define CASE_CONST_UNIQUE \
     763                 :             :    case CONST_INT: \
     764                 :             :    case CONST_WIDE_INT: \
     765                 :             :    case CONST_POLY_INT: \
     766                 :             :    case CONST_DOUBLE: \
     767                 :             :    case CONST_FIXED
     768                 :             : 
     769                 :             : /* Match all CONST_* rtxes.  */
     770                 :             : #define CASE_CONST_ANY \
     771                 :             :    case CONST_INT: \
     772                 :             :    case CONST_WIDE_INT: \
     773                 :             :    case CONST_POLY_INT: \
     774                 :             :    case CONST_DOUBLE: \
     775                 :             :    case CONST_FIXED: \
     776                 :             :    case CONST_VECTOR
     777                 :             : 
     778                 :             : #else
     779                 :             : 
     780                 :             : /* Match CONST_*s that can represent compile-time constant integers.  */
     781                 :             : #define CASE_CONST_SCALAR_INT \
     782                 :             :    case CONST_INT: \
     783                 :             :    case CONST_DOUBLE
     784                 :             : 
     785                 :             : /* Match CONST_*s for which pointer equality corresponds to value
     786                 :             :    equality.  */
     787                 :             : #define CASE_CONST_UNIQUE \
     788                 :             :    case CONST_INT: \
     789                 :             :    case CONST_DOUBLE: \
     790                 :             :    case CONST_FIXED
     791                 :             : 
     792                 :             : /* Match all CONST_* rtxes.  */
     793                 :             : #define CASE_CONST_ANY \
     794                 :             :    case CONST_INT: \
     795                 :             :    case CONST_DOUBLE: \
     796                 :             :    case CONST_FIXED: \
     797                 :             :    case CONST_VECTOR
     798                 :             : #endif
     799                 :             : 
     800                 :             : /* Predicate yielding nonzero iff X is an rtx for a constant integer.  */
     801                 :             : #define CONST_INT_P(X) (GET_CODE (X) == CONST_INT)
     802                 :             : 
     803                 :             : /* Predicate yielding nonzero iff X is an rtx for a constant integer.  */
     804                 :             : #define CONST_WIDE_INT_P(X) (GET_CODE (X) == CONST_WIDE_INT)
     805                 :             : 
     806                 :             : /* Predicate yielding nonzero iff X is an rtx for a polynomial constant
     807                 :             :    integer.  */
     808                 :             : #define CONST_POLY_INT_P(X) \
     809                 :             :   (NUM_POLY_INT_COEFFS > 1 && GET_CODE (X) == CONST_POLY_INT)
     810                 :             : 
     811                 :             : /* Predicate yielding nonzero iff X is an rtx for a constant fixed-point.  */
     812                 :             : #define CONST_FIXED_P(X) (GET_CODE (X) == CONST_FIXED)
     813                 :             : 
     814                 :             : /* Predicate yielding true iff X is an rtx for a double-int
     815                 :             :    or floating point constant.  */
     816                 :             : #define CONST_DOUBLE_P(X) (GET_CODE (X) == CONST_DOUBLE)
     817                 :             : 
     818                 :             : /* Predicate yielding true iff X is an rtx for a double-int.  */
     819                 :             : #define CONST_DOUBLE_AS_INT_P(X) \
     820                 :             :   (GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) == VOIDmode)
     821                 :             : 
     822                 :             : /* Predicate yielding true iff X is an rtx for a integer const.  */
     823                 :             : #if TARGET_SUPPORTS_WIDE_INT
     824                 :             : #define CONST_SCALAR_INT_P(X) \
     825                 :             :   (CONST_INT_P (X) || CONST_WIDE_INT_P (X))
     826                 :             : #else
     827                 :             : #define CONST_SCALAR_INT_P(X) \
     828                 :             :   (CONST_INT_P (X) || CONST_DOUBLE_AS_INT_P (X))
     829                 :             : #endif
     830                 :             : 
     831                 :             : /* Predicate yielding true iff X is an rtx for a double-int.  */
     832                 :             : #define CONST_DOUBLE_AS_FLOAT_P(X) \
     833                 :             :   (GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) != VOIDmode)
     834                 :             : 
     835                 :             : /* Predicate yielding nonzero iff X is an rtx for a constant vector.  */
     836                 :             : #define CONST_VECTOR_P(X) (GET_CODE (X) == CONST_VECTOR)
     837                 :             : 
     838                 :             : /* Predicate yielding nonzero iff X is a label insn.  */
     839                 :             : #define LABEL_P(X) (GET_CODE (X) == CODE_LABEL)
     840                 :             : 
     841                 :             : /* Predicate yielding nonzero iff X is a jump insn.  */
     842                 :             : #define JUMP_P(X) (GET_CODE (X) == JUMP_INSN)
     843                 :             : 
     844                 :             : /* Predicate yielding nonzero iff X is a call insn.  */
     845                 :             : #define CALL_P(X) (GET_CODE (X) == CALL_INSN)
     846                 :             : 
     847                 :             : /* 1 if RTX is a call_insn for a fake call.
     848                 :             :    CALL_INSN use "used" flag to indicate it's a fake call.  */
     849                 :             : #define FAKE_CALL_P(RTX)                                        \
     850                 :             :   (RTL_FLAG_CHECK1 ("FAKE_CALL_P", (RTX), CALL_INSN)->used)
     851                 :             : 
     852                 :             : /* Predicate yielding nonzero iff X is an insn that cannot jump.  */
     853                 :             : #define NONJUMP_INSN_P(X) (GET_CODE (X) == INSN)
     854                 :             : 
     855                 :             : /* Predicate yielding nonzero iff X is a debug note/insn.  */
     856                 :             : #define DEBUG_INSN_P(X) (GET_CODE (X) == DEBUG_INSN)
     857                 :             : 
     858                 :             : /* Predicate yielding nonzero iff X is an insn that is not a debug insn.  */
     859                 :             : #define NONDEBUG_INSN_P(X) (NONJUMP_INSN_P (X) || JUMP_P (X) || CALL_P (X))
     860                 :             : 
     861                 :             : /* Nonzero if DEBUG_MARKER_INSN_P may possibly hold.  */
     862                 :             : #define MAY_HAVE_DEBUG_MARKER_INSNS debug_nonbind_markers_p
     863                 :             : /* Nonzero if DEBUG_BIND_INSN_P may possibly hold.  */
     864                 :             : #define MAY_HAVE_DEBUG_BIND_INSNS flag_var_tracking_assignments
     865                 :             : /* Nonzero if DEBUG_INSN_P may possibly hold.  */
     866                 :             : #define MAY_HAVE_DEBUG_INSNS                                    \
     867                 :             :   (MAY_HAVE_DEBUG_MARKER_INSNS || MAY_HAVE_DEBUG_BIND_INSNS)
     868                 :             : 
     869                 :             : /* Predicate yielding nonzero iff X is a real insn.  */
     870                 :             : #define INSN_P(X) (NONDEBUG_INSN_P (X) || DEBUG_INSN_P (X))
     871                 :             : 
     872                 :             : /* Predicate yielding nonzero iff X is a note insn.  */
     873                 :             : #define NOTE_P(X) (GET_CODE (X) == NOTE)
     874                 :             : 
     875                 :             : /* Predicate yielding nonzero iff X is a barrier insn.  */
     876                 :             : #define BARRIER_P(X) (GET_CODE (X) == BARRIER)
     877                 :             : 
     878                 :             : /* Predicate yielding nonzero iff X is a data for a jump table.  */
     879                 :             : #define JUMP_TABLE_DATA_P(INSN) (GET_CODE (INSN) == JUMP_TABLE_DATA)
     880                 :             : 
     881                 :             : /* Predicate yielding nonzero iff RTX is a subreg.  */
     882                 :             : #define SUBREG_P(RTX) (GET_CODE (RTX) == SUBREG)
     883                 :             : 
     884                 :             : /* Predicate yielding true iff RTX is a symbol ref.  */
     885                 :             : #define SYMBOL_REF_P(RTX) (GET_CODE (RTX) == SYMBOL_REF)
     886                 :             : 
     887                 :             : template <>
     888                 :             : template <>
     889                 :             : inline bool
     890                 : >15358*10^7 : is_a_helper <rtx_insn *>::test (rtx rt)
     891                 :             : {
     892                 : >15358*10^7 :   return (INSN_P (rt)
     893                 : >15358*10^7 :           || NOTE_P (rt)
     894                 : 19427965078 :           || JUMP_TABLE_DATA_P (rt)
     895                 : 19423310749 :           || BARRIER_P (rt)
     896                 : >16550*10^7 :           || LABEL_P (rt));
     897                 :             : }
     898                 :             : 
     899                 :             : template <>
     900                 :             : template <>
     901                 :             : inline bool
     902                 :    97605883 : is_a_helper <const rtx_insn *>::test (const_rtx rt)
     903                 :             : {
     904                 :    97605883 :   return (INSN_P (rt)
     905                 :    97605883 :           || NOTE_P (rt)
     906                 :         225 :           || JUMP_TABLE_DATA_P (rt)
     907                 :         225 :           || BARRIER_P (rt)
     908                 :    97606100 :           || LABEL_P (rt));
     909                 :             : }
     910                 :             : 
     911                 :             : template <>
     912                 :             : template <>
     913                 :             : inline bool
     914                 :    40798664 : is_a_helper <rtx_debug_insn *>::test (rtx rt)
     915                 :             : {
     916                 :    40798664 :   return DEBUG_INSN_P (rt);
     917                 :             : }
     918                 :             : 
     919                 :             : template <>
     920                 :             : template <>
     921                 :             : inline bool
     922                 :             : is_a_helper <rtx_nonjump_insn *>::test (rtx rt)
     923                 :             : {
     924                 :             :   return NONJUMP_INSN_P (rt);
     925                 :             : }
     926                 :             : 
     927                 :             : template <>
     928                 :             : template <>
     929                 :             : inline bool
     930                 :    16576387 : is_a_helper <rtx_jump_insn *>::test (rtx rt)
     931                 :             : {
     932                 :    16576387 :   return JUMP_P (rt);
     933                 :             : }
     934                 :             : 
     935                 :             : template <>
     936                 :             : template <>
     937                 :             : inline bool
     938                 :    45552233 : is_a_helper <rtx_jump_insn *>::test (rtx_insn *insn)
     939                 :             : {
     940                 :    45552233 :   return JUMP_P (insn);
     941                 :             : }
     942                 :             : 
     943                 :             : template <>
     944                 :             : template <>
     945                 :             : inline bool
     946                 :     6028700 : is_a_helper <rtx_call_insn *>::test (rtx rt)
     947                 :             : {
     948                 :     6028700 :   return CALL_P (rt);
     949                 :             : }
     950                 :             : 
     951                 :             : template <>
     952                 :             : template <>
     953                 :             : inline bool
     954                 :   470013926 : is_a_helper <rtx_call_insn *>::test (rtx_insn *insn)
     955                 :             : {
     956                 :   470013926 :   return CALL_P (insn);
     957                 :             : }
     958                 :             : 
     959                 :             : template <>
     960                 :             : template <>
     961                 :             : inline bool
     962                 :       16537 : is_a_helper <rtx_jump_table_data *>::test (rtx rt)
     963                 :             : {
     964                 :       16537 :   return JUMP_TABLE_DATA_P (rt);
     965                 :             : }
     966                 :             : 
     967                 :             : template <>
     968                 :             : template <>
     969                 :             : inline bool
     970                 :   126232823 : is_a_helper <rtx_jump_table_data *>::test (rtx_insn *insn)
     971                 :             : {
     972                 :   126232823 :   return JUMP_TABLE_DATA_P (insn);
     973                 :             : }
     974                 :             : 
     975                 :             : template <>
     976                 :             : template <>
     977                 :             : inline bool
     978                 :    10403421 : is_a_helper <rtx_barrier *>::test (rtx rt)
     979                 :             : {
     980                 :    10403421 :   return BARRIER_P (rt);
     981                 :             : }
     982                 :             : 
     983                 :             : template <>
     984                 :             : template <>
     985                 :             : inline bool
     986                 :    22366378 : is_a_helper <rtx_code_label *>::test (rtx rt)
     987                 :             : {
     988                 :    22366378 :   return LABEL_P (rt);
     989                 :             : }
     990                 :             : 
     991                 :             : template <>
     992                 :             : template <>
     993                 :             : inline bool
     994                 :   356549114 : is_a_helper <rtx_code_label *>::test (rtx_insn *insn)
     995                 :             : {
     996                 :   356549114 :   return LABEL_P (insn);
     997                 :             : }
     998                 :             : 
     999                 :             : template <>
    1000                 :             : template <>
    1001                 :             : inline bool
    1002                 :   143625658 : is_a_helper <rtx_note *>::test (rtx rt)
    1003                 :             : {
    1004                 :   143625658 :   return NOTE_P (rt);
    1005                 :             : }
    1006                 :             : 
    1007                 :             : template <>
    1008                 :             : template <>
    1009                 :             : inline bool
    1010                 :    48896437 : is_a_helper <rtx_note *>::test (rtx_insn *insn)
    1011                 :             : {
    1012                 :    48896437 :   return NOTE_P (insn);
    1013                 :             : }
    1014                 :             : 
    1015                 :             : /* Predicate yielding nonzero iff X is a return or simple_return.  */
    1016                 :             : #define ANY_RETURN_P(X) \
    1017                 :             :   (GET_CODE (X) == RETURN || GET_CODE (X) == SIMPLE_RETURN)
    1018                 :             : 
    1019                 :             : /* 1 if X is a unary operator.  */
    1020                 :             : 
    1021                 :             : #define UNARY_P(X)   \
    1022                 :             :   (GET_RTX_CLASS (GET_CODE (X)) == RTX_UNARY)
    1023                 :             : 
    1024                 :             : /* 1 if X is a binary operator.  */
    1025                 :             : 
    1026                 :             : #define BINARY_P(X)   \
    1027                 :             :   ((GET_RTX_CLASS (GET_CODE (X)) & RTX_BINARY_MASK) == RTX_BINARY_RESULT)
    1028                 :             : 
    1029                 :             : /* 1 if X is an arithmetic operator.  */
    1030                 :             : 
    1031                 :             : #define ARITHMETIC_P(X)   \
    1032                 :             :   ((GET_RTX_CLASS (GET_CODE (X)) & RTX_ARITHMETIC_MASK)                     \
    1033                 :             :     == RTX_ARITHMETIC_RESULT)
    1034                 :             : 
    1035                 :             : /* 1 if X is an arithmetic operator.  */
    1036                 :             : 
    1037                 :             : #define COMMUTATIVE_ARITH_P(X)   \
    1038                 :             :   (GET_RTX_CLASS (GET_CODE (X)) == RTX_COMM_ARITH)
    1039                 :             : 
    1040                 :             : /* 1 if X is a commutative arithmetic operator or a comparison operator.
    1041                 :             :    These two are sometimes selected together because it is possible to
    1042                 :             :    swap the two operands.  */
    1043                 :             : 
    1044                 :             : #define SWAPPABLE_OPERANDS_P(X)   \
    1045                 :             :   ((1 << GET_RTX_CLASS (GET_CODE (X)))                                    \
    1046                 :             :     & ((1 << RTX_COMM_ARITH) | (1 << RTX_COMM_COMPARE)                  \
    1047                 :             :        | (1 << RTX_COMPARE)))
    1048                 :             : 
    1049                 :             : /* 1 if X is a non-commutative operator.  */
    1050                 :             : 
    1051                 :             : #define NON_COMMUTATIVE_P(X)   \
    1052                 :             :   ((GET_RTX_CLASS (GET_CODE (X)) & RTX_COMMUTATIVE_MASK)            \
    1053                 :             :     == RTX_NON_COMMUTATIVE_RESULT)
    1054                 :             : 
    1055                 :             : /* 1 if X is a commutative operator on integers.  */
    1056                 :             : 
    1057                 :             : #define COMMUTATIVE_P(X)   \
    1058                 :             :   ((GET_RTX_CLASS (GET_CODE (X)) & RTX_COMMUTATIVE_MASK)            \
    1059                 :             :     == RTX_COMMUTATIVE_RESULT)
    1060                 :             : 
    1061                 :             : /* 1 if X is a relational operator.  */
    1062                 :             : 
    1063                 :             : #define COMPARISON_P(X)   \
    1064                 :             :   ((GET_RTX_CLASS (GET_CODE (X)) & RTX_COMPARE_MASK) == RTX_COMPARE_RESULT)
    1065                 :             : 
    1066                 :             : /* 1 if X is a constant value that is an integer.  */
    1067                 :             : 
    1068                 :             : #define CONSTANT_P(X)   \
    1069                 :             :   (GET_RTX_CLASS (GET_CODE (X)) == RTX_CONST_OBJ)
    1070                 :             : 
    1071                 :             : /* 1 if X is a LABEL_REF.  */
    1072                 :             : #define LABEL_REF_P(X)  \
    1073                 :             :   (GET_CODE (X) == LABEL_REF)
    1074                 :             : 
    1075                 :             : /* 1 if X can be used to represent an object.  */
    1076                 :             : #define OBJECT_P(X)                                                     \
    1077                 :             :   ((GET_RTX_CLASS (GET_CODE (X)) & RTX_OBJ_MASK) == RTX_OBJ_RESULT)
    1078                 :             : 
    1079                 :             : /* General accessor macros for accessing the fields of an rtx.  */
    1080                 :             : 
    1081                 :             : #if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007)
    1082                 :             : /* The bit with a star outside the statement expr and an & inside is
    1083                 :             :    so that N can be evaluated only once.  */
    1084                 :             : #define RTL_CHECK1(RTX, N, C1) __extension__                            \
    1085                 :             : (*({ __typeof (RTX) const _rtx = (RTX); const int _n = (N);             \
    1086                 :             :      const enum rtx_code _code = GET_CODE (_rtx);                       \
    1087                 :             :      if (_n < 0 || _n >= GET_RTX_LENGTH (_code))                  \
    1088                 :             :        rtl_check_failed_bounds (_rtx, _n, __FILE__, __LINE__,           \
    1089                 :             :                                 __FUNCTION__);                          \
    1090                 :             :      if (GET_RTX_FORMAT (_code)[_n] != C1)                              \
    1091                 :             :        rtl_check_failed_type1 (_rtx, _n, C1, __FILE__, __LINE__,        \
    1092                 :             :                                __FUNCTION__);                           \
    1093                 :             :      &_rtx->u.fld[_n]; }))
    1094                 :             : 
    1095                 :             : #define RTL_CHECK2(RTX, N, C1, C2) __extension__                        \
    1096                 :             : (*({ __typeof (RTX) const _rtx = (RTX); const int _n = (N);             \
    1097                 :             :      const enum rtx_code _code = GET_CODE (_rtx);                       \
    1098                 :             :      if (_n < 0 || _n >= GET_RTX_LENGTH (_code))                  \
    1099                 :             :        rtl_check_failed_bounds (_rtx, _n, __FILE__, __LINE__,           \
    1100                 :             :                                 __FUNCTION__);                          \
    1101                 :             :      if (GET_RTX_FORMAT (_code)[_n] != C1                               \
    1102                 :             :          && GET_RTX_FORMAT (_code)[_n] != C2)                           \
    1103                 :             :        rtl_check_failed_type2 (_rtx, _n, C1, C2, __FILE__, __LINE__,    \
    1104                 :             :                                __FUNCTION__);                           \
    1105                 :             :      &_rtx->u.fld[_n]; }))
    1106                 :             : 
    1107                 :             : #define RTL_CHECKC1(RTX, N, C) __extension__                            \
    1108                 :             : (*({ __typeof (RTX) const _rtx = (RTX); const int _n = (N);             \
    1109                 :             :      if (GET_CODE (_rtx) != (C))                                        \
    1110                 :             :        rtl_check_failed_code1 (_rtx, (C), __FILE__, __LINE__,           \
    1111                 :             :                                __FUNCTION__);                           \
    1112                 :             :      &_rtx->u.fld[_n]; }))
    1113                 :             : 
    1114                 :             : #define RTL_CHECKC2(RTX, N, C1, C2) __extension__                       \
    1115                 :             : (*({ __typeof (RTX) const _rtx = (RTX); const int _n = (N);             \
    1116                 :             :      const enum rtx_code _code = GET_CODE (_rtx);                       \
    1117                 :             :      if (_code != (C1) && _code != (C2))                                \
    1118                 :             :        rtl_check_failed_code2 (_rtx, (C1), (C2), __FILE__, __LINE__,    \
    1119                 :             :                                __FUNCTION__); \
    1120                 :             :      &_rtx->u.fld[_n]; }))
    1121                 :             : 
    1122                 :             : #define RTL_CHECKC3(RTX, N, C1, C2, C3) __extension__                   \
    1123                 :             : (*({ __typeof (RTX) const _rtx = (RTX); const int _n = (N);             \
    1124                 :             :      const enum rtx_code _code = GET_CODE (_rtx);                       \
    1125                 :             :      if (_code != (C1) && _code != (C2) && _code != (C3))               \
    1126                 :             :        rtl_check_failed_code3 (_rtx, (C1), (C2), (C3), __FILE__,        \
    1127                 :             :                                __LINE__, __FUNCTION__);                 \
    1128                 :             :      &_rtx->u.fld[_n]; }))
    1129                 :             : 
    1130                 :             : #define RTVEC_ELT(RTVEC, I) __extension__                               \
    1131                 :             : (*({ __typeof (RTVEC) const _rtvec = (RTVEC); const int _i = (I);       \
    1132                 :             :      if (_i < 0 || _i >= GET_NUM_ELEM (_rtvec))                           \
    1133                 :             :        rtvec_check_failed_bounds (_rtvec, _i, __FILE__, __LINE__,       \
    1134                 :             :                                   __FUNCTION__);                        \
    1135                 :             :      &_rtvec->elem[_i]; }))
    1136                 :             : 
    1137                 :             : #define XWINT(RTX, N) __extension__                                     \
    1138                 :             : (*({ __typeof (RTX) const _rtx = (RTX); const int _n = (N);             \
    1139                 :             :      const enum rtx_code _code = GET_CODE (_rtx);                       \
    1140                 :             :      if (_n < 0 || _n >= GET_RTX_LENGTH (_code))                  \
    1141                 :             :        rtl_check_failed_bounds (_rtx, _n, __FILE__, __LINE__,           \
    1142                 :             :                                 __FUNCTION__);                          \
    1143                 :             :      if (GET_RTX_FORMAT (_code)[_n] != 'w')                             \
    1144                 :             :        rtl_check_failed_type1 (_rtx, _n, 'w', __FILE__, __LINE__,       \
    1145                 :             :                                __FUNCTION__);                           \
    1146                 :             :      &_rtx->u.hwint[_n]; }))
    1147                 :             : 
    1148                 :             : #define CWI_ELT(RTX, I) __extension__                                   \
    1149                 :             : (*({ __typeof (RTX) const _cwi = (RTX);                                 \
    1150                 :             :      int _max = CWI_GET_NUM_ELEM (_cwi);                                \
    1151                 :             :      const int _i = (I);                                                \
    1152                 :             :      if (_i < 0 || _i >= _max)                                            \
    1153                 :             :        cwi_check_failed_bounds (_cwi, _i, __FILE__, __LINE__,           \
    1154                 :             :                                 __FUNCTION__);                          \
    1155                 :             :      &_cwi->u.hwiv.elem[_i]; }))
    1156                 :             : 
    1157                 :             : #define XCWINT(RTX, N, C) __extension__                                 \
    1158                 :             : (*({ __typeof (RTX) const _rtx = (RTX);                                 \
    1159                 :             :      if (GET_CODE (_rtx) != (C))                                        \
    1160                 :             :        rtl_check_failed_code1 (_rtx, (C), __FILE__, __LINE__,           \
    1161                 :             :                                __FUNCTION__);                           \
    1162                 :             :      &_rtx->u.hwint[N]; }))
    1163                 :             : 
    1164                 :             : #define XCMWINT(RTX, N, C, M) __extension__                             \
    1165                 :             : (*({ __typeof (RTX) const _rtx = (RTX);                                 \
    1166                 :             :      if (GET_CODE (_rtx) != (C) || GET_MODE (_rtx) != (M))              \
    1167                 :             :        rtl_check_failed_code_mode (_rtx, (C), (M), false, __FILE__,     \
    1168                 :             :                                    __LINE__, __FUNCTION__);             \
    1169                 :             :      &_rtx->u.hwint[N]; }))
    1170                 :             : 
    1171                 :             : #define XCNMPRV(RTX, C, M) __extension__                                \
    1172                 :             : ({ __typeof (RTX) const _rtx = (RTX);                                   \
    1173                 :             :    if (GET_CODE (_rtx) != (C) || GET_MODE (_rtx) == (M))                \
    1174                 :             :      rtl_check_failed_code_mode (_rtx, (C), (M), true, __FILE__,        \
    1175                 :             :                                  __LINE__, __FUNCTION__);               \
    1176                 :             :    &_rtx->u.rv; })
    1177                 :             : 
    1178                 :             : #define XCNMPFV(RTX, C, M) __extension__                                \
    1179                 :             : ({ __typeof (RTX) const _rtx = (RTX);                                   \
    1180                 :             :    if (GET_CODE (_rtx) != (C) || GET_MODE (_rtx) == (M))                \
    1181                 :             :      rtl_check_failed_code_mode (_rtx, (C), (M), true, __FILE__,        \
    1182                 :             :                                  __LINE__, __FUNCTION__);               \
    1183                 :             :    &_rtx->u.fv; })
    1184                 :             : 
    1185                 :             : #define REG_CHECK(RTX) __extension__                                    \
    1186                 :             : ({ __typeof (RTX) const _rtx = (RTX);                                   \
    1187                 :             :    if (GET_CODE (_rtx) != REG)                                          \
    1188                 :             :      rtl_check_failed_code1 (_rtx, REG,  __FILE__, __LINE__,            \
    1189                 :             :                              __FUNCTION__);                             \
    1190                 :             :    &_rtx->u.reg; })
    1191                 :             : 
    1192                 :             : #define BLOCK_SYMBOL_CHECK(RTX) __extension__                           \
    1193                 :             : ({ __typeof (RTX) const _symbol = (RTX);                                \
    1194                 :             :    const unsigned int flags = SYMBOL_REF_FLAGS (_symbol);               \
    1195                 :             :    if ((flags & SYMBOL_FLAG_HAS_BLOCK_INFO) == 0)                   \
    1196                 :             :      rtl_check_failed_block_symbol (__FILE__, __LINE__,                 \
    1197                 :             :                                     __FUNCTION__);                      \
    1198                 :             :    &_symbol->u.block_sym; })
    1199                 :             : 
    1200                 :             : #define HWIVEC_CHECK(RTX,C) __extension__                               \
    1201                 :             : ({ __typeof (RTX) const _symbol = (RTX);                                \
    1202                 :             :    RTL_CHECKC1 (_symbol, 0, C);                                         \
    1203                 :             :    &_symbol->u.hwiv; })
    1204                 :             : 
    1205                 :             : extern void rtl_check_failed_bounds (const_rtx, int, const char *, int,
    1206                 :             :                                      const char *)
    1207                 :             :     ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
    1208                 :             : extern void rtl_check_failed_type1 (const_rtx, int, int, const char *, int,
    1209                 :             :                                     const char *)
    1210                 :             :     ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
    1211                 :             : extern void rtl_check_failed_type2 (const_rtx, int, int, int, const char *,
    1212                 :             :                                     int, const char *)
    1213                 :             :     ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
    1214                 :             : extern void rtl_check_failed_code1 (const_rtx, enum rtx_code, const char *,
    1215                 :             :                                     int, const char *)
    1216                 :             :     ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
    1217                 :             : extern void rtl_check_failed_code2 (const_rtx, enum rtx_code, enum rtx_code,
    1218                 :             :                                     const char *, int, const char *)
    1219                 :             :     ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
    1220                 :             : extern void rtl_check_failed_code3 (const_rtx, enum rtx_code, enum rtx_code,
    1221                 :             :                                     enum rtx_code, const char *, int,
    1222                 :             :                                     const char *)
    1223                 :             :     ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
    1224                 :             : extern void rtl_check_failed_code_mode (const_rtx, enum rtx_code, machine_mode,
    1225                 :             :                                         bool, const char *, int, const char *)
    1226                 :             :     ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
    1227                 :             : extern void rtl_check_failed_block_symbol (const char *, int, const char *)
    1228                 :             :     ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
    1229                 :             : extern void cwi_check_failed_bounds (const_rtx, int, const char *, int,
    1230                 :             :                                      const char *)
    1231                 :             :     ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
    1232                 :             : extern void rtvec_check_failed_bounds (const_rtvec, int, const char *, int,
    1233                 :             :                                        const char *)
    1234                 :             :     ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
    1235                 :             : 
    1236                 :             : #else   /* not ENABLE_RTL_CHECKING */
    1237                 :             : 
    1238                 :             : #define RTL_CHECK1(RTX, N, C1)      ((RTX)->u.fld[N])
    1239                 :             : #define RTL_CHECK2(RTX, N, C1, C2)  ((RTX)->u.fld[N])
    1240                 :             : #define RTL_CHECKC1(RTX, N, C)      ((RTX)->u.fld[N])
    1241                 :             : #define RTL_CHECKC2(RTX, N, C1, C2) ((RTX)->u.fld[N])
    1242                 :             : #define RTL_CHECKC3(RTX, N, C1, C2, C3) ((RTX)->u.fld[N])
    1243                 :             : #define RTVEC_ELT(RTVEC, I)         ((RTVEC)->elem[I])
    1244                 :             : #define XWINT(RTX, N)               ((RTX)->u.hwint[N])
    1245                 :             : #define CWI_ELT(RTX, I)             ((RTX)->u.hwiv.elem[I])
    1246                 :             : #define XCWINT(RTX, N, C)           ((RTX)->u.hwint[N])
    1247                 :             : #define XCMWINT(RTX, N, C, M)       ((RTX)->u.hwint[N])
    1248                 :             : #define XCNMWINT(RTX, N, C, M)      ((RTX)->u.hwint[N])
    1249                 :             : #define XCNMPRV(RTX, C, M)          (&(RTX)->u.rv)
    1250                 :             : #define XCNMPFV(RTX, C, M)          (&(RTX)->u.fv)
    1251                 :             : #define REG_CHECK(RTX)              (&(RTX)->u.reg)
    1252                 :             : #define BLOCK_SYMBOL_CHECK(RTX)     (&(RTX)->u.block_sym)
    1253                 :             : #define HWIVEC_CHECK(RTX,C)         (&(RTX)->u.hwiv)
    1254                 :             : 
    1255                 :             : #endif
    1256                 :             : 
    1257                 :             : /* General accessor macros for accessing the flags of an rtx.  */
    1258                 :             : 
    1259                 :             : /* Access an individual rtx flag, with no checking of any kind.  */
    1260                 :             : #define RTX_FLAG(RTX, FLAG)     ((RTX)->FLAG)
    1261                 :             : 
    1262                 :             : #if defined ENABLE_RTL_FLAG_CHECKING && (GCC_VERSION >= 2007)
    1263                 :             : #define RTL_FLAG_CHECK1(NAME, RTX, C1) __extension__                    \
    1264                 :             : ({ __typeof (RTX) const _rtx = (RTX);                                   \
    1265                 :             :    if (GET_CODE (_rtx) != C1)                                           \
    1266                 :             :      rtl_check_failed_flag  (NAME, _rtx, __FILE__, __LINE__,            \
    1267                 :             :                              __FUNCTION__);                             \
    1268                 :             :    _rtx; })
    1269                 :             : 
    1270                 :             : #define RTL_FLAG_CHECK2(NAME, RTX, C1, C2) __extension__                \
    1271                 :             : ({ __typeof (RTX) const _rtx = (RTX);                                   \
    1272                 :             :    if (GET_CODE (_rtx) != C1 && GET_CODE(_rtx) != C2)                   \
    1273                 :             :      rtl_check_failed_flag  (NAME,_rtx, __FILE__, __LINE__,             \
    1274                 :             :                               __FUNCTION__);                            \
    1275                 :             :    _rtx; })
    1276                 :             : 
    1277                 :             : #define RTL_FLAG_CHECK3(NAME, RTX, C1, C2, C3) __extension__            \
    1278                 :             : ({ __typeof (RTX) const _rtx = (RTX);                                   \
    1279                 :             :    if (GET_CODE (_rtx) != C1 && GET_CODE(_rtx) != C2                    \
    1280                 :             :        && GET_CODE (_rtx) != C3)                                        \
    1281                 :             :      rtl_check_failed_flag  (NAME, _rtx, __FILE__, __LINE__,            \
    1282                 :             :                              __FUNCTION__);                             \
    1283                 :             :    _rtx; })
    1284                 :             : 
    1285                 :             : #define RTL_FLAG_CHECK4(NAME, RTX, C1, C2, C3, C4) __extension__        \
    1286                 :             : ({ __typeof (RTX) const _rtx = (RTX);                                   \
    1287                 :             :    if (GET_CODE (_rtx) != C1 && GET_CODE(_rtx) != C2                    \
    1288                 :             :        && GET_CODE (_rtx) != C3 && GET_CODE(_rtx) != C4)                \
    1289                 :             :      rtl_check_failed_flag  (NAME, _rtx, __FILE__, __LINE__,            \
    1290                 :             :                               __FUNCTION__);                            \
    1291                 :             :    _rtx; })
    1292                 :             : 
    1293                 :             : #define RTL_FLAG_CHECK5(NAME, RTX, C1, C2, C3, C4, C5) __extension__    \
    1294                 :             : ({ __typeof (RTX) const _rtx = (RTX);                                   \
    1295                 :             :    if (GET_CODE (_rtx) != C1 && GET_CODE (_rtx) != C2                   \
    1296                 :             :        && GET_CODE (_rtx) != C3 && GET_CODE (_rtx) != C4                \
    1297                 :             :        && GET_CODE (_rtx) != C5)                                        \
    1298                 :             :      rtl_check_failed_flag  (NAME, _rtx, __FILE__, __LINE__,            \
    1299                 :             :                              __FUNCTION__);                             \
    1300                 :             :    _rtx; })
    1301                 :             : 
    1302                 :             : #define RTL_FLAG_CHECK6(NAME, RTX, C1, C2, C3, C4, C5, C6)              \
    1303                 :             :   __extension__                                                         \
    1304                 :             : ({ __typeof (RTX) const _rtx = (RTX);                                   \
    1305                 :             :    if (GET_CODE (_rtx) != C1 && GET_CODE (_rtx) != C2                   \
    1306                 :             :        && GET_CODE (_rtx) != C3 && GET_CODE (_rtx) != C4                \
    1307                 :             :        && GET_CODE (_rtx) != C5 && GET_CODE (_rtx) != C6)               \
    1308                 :             :      rtl_check_failed_flag  (NAME,_rtx, __FILE__, __LINE__,             \
    1309                 :             :                              __FUNCTION__);                             \
    1310                 :             :    _rtx; })
    1311                 :             : 
    1312                 :             : #define RTL_FLAG_CHECK7(NAME, RTX, C1, C2, C3, C4, C5, C6, C7)          \
    1313                 :             :   __extension__                                                         \
    1314                 :             : ({ __typeof (RTX) const _rtx = (RTX);                                   \
    1315                 :             :    if (GET_CODE (_rtx) != C1 && GET_CODE (_rtx) != C2                   \
    1316                 :             :        && GET_CODE (_rtx) != C3 && GET_CODE (_rtx) != C4                \
    1317                 :             :        && GET_CODE (_rtx) != C5 && GET_CODE (_rtx) != C6                \
    1318                 :             :        && GET_CODE (_rtx) != C7)                                        \
    1319                 :             :      rtl_check_failed_flag  (NAME, _rtx, __FILE__, __LINE__,            \
    1320                 :             :                              __FUNCTION__);                             \
    1321                 :             :    _rtx; })
    1322                 :             : 
    1323                 :             : #define RTL_INSN_CHAIN_FLAG_CHECK(NAME, RTX)                            \
    1324                 :             :   __extension__                                                         \
    1325                 :             : ({ __typeof (RTX) const _rtx = (RTX);                                   \
    1326                 :             :    if (!INSN_CHAIN_CODE_P (GET_CODE (_rtx)))                            \
    1327                 :             :      rtl_check_failed_flag (NAME, _rtx, __FILE__, __LINE__,             \
    1328                 :             :                             __FUNCTION__);                              \
    1329                 :             :    _rtx; })
    1330                 :             : 
    1331                 :             : extern void rtl_check_failed_flag (const char *, const_rtx, const char *,
    1332                 :             :                                    int, const char *)
    1333                 :             :     ATTRIBUTE_NORETURN ATTRIBUTE_COLD
    1334                 :             :     ;
    1335                 :             : 
    1336                 :             : #else   /* not ENABLE_RTL_FLAG_CHECKING */
    1337                 :             : 
    1338                 :             : #define RTL_FLAG_CHECK1(NAME, RTX, C1)                                  (RTX)
    1339                 :             : #define RTL_FLAG_CHECK2(NAME, RTX, C1, C2)                              (RTX)
    1340                 :             : #define RTL_FLAG_CHECK3(NAME, RTX, C1, C2, C3)                          (RTX)
    1341                 :             : #define RTL_FLAG_CHECK4(NAME, RTX, C1, C2, C3, C4)                      (RTX)
    1342                 :             : #define RTL_FLAG_CHECK5(NAME, RTX, C1, C2, C3, C4, C5)                  (RTX)
    1343                 :             : #define RTL_FLAG_CHECK6(NAME, RTX, C1, C2, C3, C4, C5, C6)              (RTX)
    1344                 :             : #define RTL_FLAG_CHECK7(NAME, RTX, C1, C2, C3, C4, C5, C6, C7)          (RTX)
    1345                 :             : #define RTL_INSN_CHAIN_FLAG_CHECK(NAME, RTX)                            (RTX)
    1346                 :             : #endif
    1347                 :             : 
    1348                 :             : #define XINT(RTX, N)    (RTL_CHECK2 (RTX, N, 'i', 'n').rt_int)
    1349                 :             : #define XUINT(RTX, N)   (RTL_CHECK2 (RTX, N, 'i', 'n').rt_uint)
    1350                 :             : #define XSTR(RTX, N)    (RTL_CHECK2 (RTX, N, 's', 'S').rt_str)
    1351                 :             : #define XEXP(RTX, N)    (RTL_CHECK2 (RTX, N, 'e', 'u').rt_rtx)
    1352                 :             : #define XVEC(RTX, N)    (RTL_CHECK2 (RTX, N, 'E', 'V').rt_rtvec)
    1353                 :             : #define XMODE(RTX, N)   (RTL_CHECK1 (RTX, N, 'M').rt_type)
    1354                 :             : #define XTREE(RTX, N)   (RTL_CHECK1 (RTX, N, 't').rt_tree)
    1355                 :             : #define XBBDEF(RTX, N)  (RTL_CHECK1 (RTX, N, 'B').rt_bb)
    1356                 :             : #define XTMPL(RTX, N)   (RTL_CHECK1 (RTX, N, 'T').rt_str)
    1357                 :             : #define XCFI(RTX, N)    (RTL_CHECK1 (RTX, N, 'C').rt_cfi)
    1358                 :             : 
    1359                 :             : #define XVECEXP(RTX, N, M)      RTVEC_ELT (XVEC (RTX, N), M)
    1360                 :             : #define XVECLEN(RTX, N)         GET_NUM_ELEM (XVEC (RTX, N))
    1361                 :             : 
    1362                 :             : /* These are like XINT, etc. except that they expect a '0' field instead
    1363                 :             :    of the normal type code.  */
    1364                 :             : 
    1365                 :             : #define X0INT(RTX, N)      (RTL_CHECK1 (RTX, N, '0').rt_int)
    1366                 :             : #define X0UINT(RTX, N)     (RTL_CHECK1 (RTX, N, '0').rt_uint)
    1367                 :             : #define X0STR(RTX, N)      (RTL_CHECK1 (RTX, N, '0').rt_str)
    1368                 :             : #define X0EXP(RTX, N)      (RTL_CHECK1 (RTX, N, '0').rt_rtx)
    1369                 :             : #define X0VEC(RTX, N)      (RTL_CHECK1 (RTX, N, '0').rt_rtvec)
    1370                 :             : #define X0MODE(RTX, N)     (RTL_CHECK1 (RTX, N, '0').rt_type)
    1371                 :             : #define X0TREE(RTX, N)     (RTL_CHECK1 (RTX, N, '0').rt_tree)
    1372                 :             : #define X0BBDEF(RTX, N)    (RTL_CHECK1 (RTX, N, '0').rt_bb)
    1373                 :             : #define X0ADVFLAGS(RTX, N) (RTL_CHECK1 (RTX, N, '0').rt_addr_diff_vec_flags)
    1374                 :             : #define X0CSELIB(RTX, N)   (RTL_CHECK1 (RTX, N, '0').rt_cselib)
    1375                 :             : #define X0MEMATTR(RTX, N)  (RTL_CHECKC1 (RTX, N, MEM).rt_mem)
    1376                 :             : #define X0CONSTANT(RTX, N) (RTL_CHECK1 (RTX, N, '0').rt_constant)
    1377                 :             : 
    1378                 :             : /* Access a '0' field with any type.  */
    1379                 :             : #define X0ANY(RTX, N)      RTL_CHECK1 (RTX, N, '0')
    1380                 :             : 
    1381                 :             : #define XCINT(RTX, N, C)      (RTL_CHECKC1 (RTX, N, C).rt_int)
    1382                 :             : #define XCUINT(RTX, N, C)     (RTL_CHECKC1 (RTX, N, C).rt_uint)
    1383                 :             : #define XCSUBREG(RTX, N, C)   (RTL_CHECKC1 (RTX, N, C).rt_subreg)
    1384                 :             : #define XCSTR(RTX, N, C)      (RTL_CHECKC1 (RTX, N, C).rt_str)
    1385                 :             : #define XCEXP(RTX, N, C)      (RTL_CHECKC1 (RTX, N, C).rt_rtx)
    1386                 :             : #define XCVEC(RTX, N, C)      (RTL_CHECKC1 (RTX, N, C).rt_rtvec)
    1387                 :             : #define XCMODE(RTX, N, C)     (RTL_CHECKC1 (RTX, N, C).rt_type)
    1388                 :             : #define XCTREE(RTX, N, C)     (RTL_CHECKC1 (RTX, N, C).rt_tree)
    1389                 :             : #define XCBBDEF(RTX, N, C)    (RTL_CHECKC1 (RTX, N, C).rt_bb)
    1390                 :             : #define XCCFI(RTX, N, C)      (RTL_CHECKC1 (RTX, N, C).rt_cfi)
    1391                 :             : #define XCCSELIB(RTX, N, C)   (RTL_CHECKC1 (RTX, N, C).rt_cselib)
    1392                 :             : 
    1393                 :             : #define XCVECEXP(RTX, N, M, C)  RTVEC_ELT (XCVEC (RTX, N, C), M)
    1394                 :             : #define XCVECLEN(RTX, N, C)     GET_NUM_ELEM (XCVEC (RTX, N, C))
    1395                 :             : 
    1396                 :             : #define XC2EXP(RTX, N, C1, C2)      (RTL_CHECKC2 (RTX, N, C1, C2).rt_rtx)
    1397                 :             : #define XC3EXP(RTX, N, C1, C2, C3)  (RTL_CHECKC3 (RTX, N, C1, C2, C3).rt_rtx)
    1398                 :             : 
    1399                 :             : 
    1400                 :             : /* Methods of rtx_expr_list.  */
    1401                 :             : 
    1402                 :   124436527 : inline rtx_expr_list *rtx_expr_list::next () const
    1403                 :             : {
    1404                 :   124436527 :   rtx tmp = XEXP (this, 1);
    1405                 :   124436527 :   return safe_as_a <rtx_expr_list *> (tmp);
    1406                 :             : }
    1407                 :             : 
    1408                 :   136720058 : inline rtx rtx_expr_list::element () const
    1409                 :             : {
    1410                 :   136720058 :   return XEXP (this, 0);
    1411                 :             : }
    1412                 :             : 
    1413                 :             : /* Methods of rtx_insn_list.  */
    1414                 :             : 
    1415                 :  1560144355 : inline rtx_insn_list *rtx_insn_list::next () const
    1416                 :             : {
    1417                 :  1560144355 :   rtx tmp = XEXP (this, 1);
    1418                 :  1560144355 :   return safe_as_a <rtx_insn_list *> (tmp);
    1419                 :             : }
    1420                 :             : 
    1421                 :  1020722016 : inline rtx_insn *rtx_insn_list::insn () const
    1422                 :             : {
    1423                 :  1018882877 :   rtx tmp = XEXP (this, 0);
    1424                 :  1020722016 :   return safe_as_a <rtx_insn *> (tmp);
    1425                 :             : }
    1426                 :             : 
    1427                 :             : /* Methods of rtx_sequence.  */
    1428                 :             : 
    1429                 :           0 : inline int rtx_sequence::len () const
    1430                 :             : {
    1431                 :           0 :   return XVECLEN (this, 0);
    1432                 :             : }
    1433                 :             : 
    1434                 :           0 : inline rtx rtx_sequence::element (int index) const
    1435                 :             : {
    1436                 :           0 :   return XVECEXP (this, 0, index);
    1437                 :             : }
    1438                 :             : 
    1439                 :           0 : inline rtx_insn *rtx_sequence::insn (int index) const
    1440                 :             : {
    1441                 :           0 :   return as_a <rtx_insn *> (XVECEXP (this, 0, index));
    1442                 :             : }
    1443                 :             : 
    1444                 :             : /* ACCESS MACROS for particular fields of insns.  */
    1445                 :             : 
    1446                 :             : /* Holds a unique number for each insn.
    1447                 :             :    These are not necessarily sequentially increasing.  */
    1448                 :  6833564648 : inline int INSN_UID (const_rtx insn)
    1449                 :             : {
    1450                 :  6833564648 :   return RTL_INSN_CHAIN_FLAG_CHECK ("INSN_UID",
    1451                 :  6833564648 :                                     (insn))->u2.insn_uid;
    1452                 :             : }
    1453                 : 51813867884 : inline int& INSN_UID (rtx insn)
    1454                 :             : {
    1455                 : 51813867884 :   return RTL_INSN_CHAIN_FLAG_CHECK ("INSN_UID",
    1456                 : 51813867884 :                                     (insn))->u2.insn_uid;
    1457                 :             : }
    1458                 :             : 
    1459                 :             : /* Chain insns together in sequence.  */
    1460                 :             : 
    1461                 :             : /* For now these are split in two: an rvalue form:
    1462                 :             :      PREV_INSN/NEXT_INSN
    1463                 :             :    and an lvalue form:
    1464                 :             :      SET_NEXT_INSN/SET_PREV_INSN.  */
    1465                 :             : 
    1466                 : 38985702509 : inline rtx_insn *PREV_INSN (const rtx_insn *insn)
    1467                 :             : {
    1468                 : 28701207750 :   rtx prev = XEXP (insn, 0);
    1469                 : 38956752863 :   return safe_as_a <rtx_insn *> (prev);
    1470                 :             : }
    1471                 :             : 
    1472                 :             : inline rtx& SET_PREV_INSN (rtx_insn *insn)
    1473                 :             : {
    1474                 :             :   return XEXP (insn, 0);
    1475                 :             : }
    1476                 :             : 
    1477                 : >11577*10^7 : inline rtx_insn *NEXT_INSN (const rtx_insn *insn)
    1478                 :             : {
    1479                 : 37062961307 :   rtx next = XEXP (insn, 1);
    1480                 : >11518*10^7 :   return safe_as_a <rtx_insn *> (next);
    1481                 :             : }
    1482                 :             : 
    1483                 :             : inline rtx& SET_NEXT_INSN (rtx_insn *insn)
    1484                 :             : {
    1485                 :             :   return XEXP (insn, 1);
    1486                 :             : }
    1487                 :             : 
    1488                 :      727230 : inline basic_block BLOCK_FOR_INSN (const_rtx insn)
    1489                 :             : {
    1490                 :      727230 :   return XBBDEF (insn, 2);
    1491                 :             : }
    1492                 :             : 
    1493                 :   144081592 : inline basic_block& BLOCK_FOR_INSN (rtx insn)
    1494                 :             : {
    1495                 :   144081592 :   return XBBDEF (insn, 2);
    1496                 :             : }
    1497                 :             : 
    1498                 :   389838367 : inline void set_block_for_insn (rtx_insn *insn, basic_block bb)
    1499                 :             : {
    1500                 :   389838236 :   BLOCK_FOR_INSN (insn) = bb;
    1501                 :      114866 : }
    1502                 :             : 
    1503                 :             : /* The body of an insn.  */
    1504                 : 26213606766 : inline rtx PATTERN (const_rtx insn)
    1505                 :             : {
    1506                 : 25785475181 :   return XEXP (insn, 3);
    1507                 :             : }
    1508                 :             : 
    1509                 :  2749352627 : inline rtx& PATTERN (rtx insn)
    1510                 :             : {
    1511                 :  2412271294 :   return XEXP (insn, 3);
    1512                 :             : }
    1513                 :             : 
    1514                 :   293280588 : inline unsigned int INSN_LOCATION (const rtx_insn *insn)
    1515                 :             : {
    1516                 :   206592409 :   return XUINT (insn, 4);
    1517                 :             : }
    1518                 :             : 
    1519                 :             : inline unsigned int& INSN_LOCATION (rtx_insn *insn)
    1520                 :             : {
    1521                 :             :   return XUINT (insn, 4);
    1522                 :             : }
    1523                 :             : 
    1524                 :    89238256 : inline bool INSN_HAS_LOCATION (const rtx_insn *insn)
    1525                 :             : {
    1526                 :    89238256 :   return LOCATION_LOCUS (INSN_LOCATION (insn)) != UNKNOWN_LOCATION;
    1527                 :             : }
    1528                 :             : 
    1529                 :             : /* LOCATION of an RTX if relevant.  */
    1530                 :             : #define RTL_LOCATION(X) (INSN_P (X) ? \
    1531                 :             :                          INSN_LOCATION (as_a <rtx_insn *> (X)) \
    1532                 :             :                          : UNKNOWN_LOCATION)
    1533                 :             : 
    1534                 :             : /* Code number of instruction, from when it was recognized.
    1535                 :             :    -1 means this instruction has not been recognized yet.  */
    1536                 :             : #define INSN_CODE(INSN) XINT (INSN, 5)
    1537                 :             : 
    1538                 :       69334 : inline rtvec rtx_jump_table_data::get_labels () const
    1539                 :             : {
    1540                 :       69334 :   rtx pat = PATTERN (this);
    1541                 :       69334 :   if (GET_CODE (pat) == ADDR_VEC)
    1542                 :       64398 :     return XVEC (pat, 0);
    1543                 :             :   else
    1544                 :        4936 :     return XVEC (pat, 1); /* presumably an ADDR_DIFF_VEC */
    1545                 :             : }
    1546                 :             : 
    1547                 :             : /* Return the mode of the data in the table, which is always a scalar
    1548                 :             :    integer.  */
    1549                 :             : 
    1550                 :             : inline scalar_int_mode
    1551                 :       16522 : rtx_jump_table_data::get_data_mode () const
    1552                 :             : {
    1553                 :       16522 :   return as_a <scalar_int_mode> (GET_MODE (PATTERN (this)));
    1554                 :             : }
    1555                 :             : 
    1556                 :             : /* If LABEL is followed by a jump table, return the table, otherwise
    1557                 :             :    return null.  */
    1558                 :             : 
    1559                 :             : inline rtx_jump_table_data *
    1560                 :    12672062 : jump_table_for_label (const rtx_code_label *label)
    1561                 :             : {
    1562                 :    12672062 :   return safe_dyn_cast <rtx_jump_table_data *> (NEXT_INSN (label));
    1563                 :             : }
    1564                 :             : 
    1565                 :             : #define RTX_FRAME_RELATED_P(RTX)                                        \
    1566                 :             :   (RTL_FLAG_CHECK6 ("RTX_FRAME_RELATED_P", (RTX), DEBUG_INSN, INSN,   \
    1567                 :             :                     CALL_INSN, JUMP_INSN, BARRIER, SET)->frame_related)
    1568                 :             : 
    1569                 :             : /* 1 if JUMP RTX is a crossing jump.  */
    1570                 :             : #define CROSSING_JUMP_P(RTX) \
    1571                 :             :   (RTL_FLAG_CHECK1 ("CROSSING_JUMP_P", (RTX), JUMP_INSN)->jump)
    1572                 :             : 
    1573                 :             : /* 1 if RTX is a call to a const function.  Built from ECF_CONST and
    1574                 :             :    TREE_READONLY.  */
    1575                 :             : #define RTL_CONST_CALL_P(RTX)                                   \
    1576                 :             :   (RTL_FLAG_CHECK1 ("RTL_CONST_CALL_P", (RTX), CALL_INSN)->unchanging)
    1577                 :             : 
    1578                 :             : /* 1 if RTX is a call to a pure function.  Built from ECF_PURE and
    1579                 :             :    DECL_PURE_P.  */
    1580                 :             : #define RTL_PURE_CALL_P(RTX)                                    \
    1581                 :             :   (RTL_FLAG_CHECK1 ("RTL_PURE_CALL_P", (RTX), CALL_INSN)->return_val)
    1582                 :             : 
    1583                 :             : /* 1 if RTX is a call to a const or pure function.  */
    1584                 :             : #define RTL_CONST_OR_PURE_CALL_P(RTX) \
    1585                 :             :   (RTL_CONST_CALL_P (RTX) || RTL_PURE_CALL_P (RTX))
    1586                 :             : 
    1587                 :             : /* 1 if RTX is a call to a looping const or pure function.  Built from
    1588                 :             :    ECF_LOOPING_CONST_OR_PURE and DECL_LOOPING_CONST_OR_PURE_P.  */
    1589                 :             : #define RTL_LOOPING_CONST_OR_PURE_CALL_P(RTX)                           \
    1590                 :             :   (RTL_FLAG_CHECK1 ("CONST_OR_PURE_CALL_P", (RTX), CALL_INSN)->call)
    1591                 :             : 
    1592                 :             : /* 1 if RTX is a call_insn for a sibling call.  */
    1593                 :             : #define SIBLING_CALL_P(RTX)                                             \
    1594                 :             :   (RTL_FLAG_CHECK1 ("SIBLING_CALL_P", (RTX), CALL_INSN)->jump)
    1595                 :             : 
    1596                 :             : /* 1 if RTX is a jump_insn, call_insn, or insn that is an annulling branch.  */
    1597                 :             : #define INSN_ANNULLED_BRANCH_P(RTX)                                     \
    1598                 :             :   (RTL_FLAG_CHECK1 ("INSN_ANNULLED_BRANCH_P", (RTX), JUMP_INSN)->unchanging)
    1599                 :             : 
    1600                 :             : /* 1 if RTX is an insn in a delay slot and is from the target of the branch.
    1601                 :             :    If the branch insn has INSN_ANNULLED_BRANCH_P set, this insn should only be
    1602                 :             :    executed if the branch is taken.  For annulled branches with this bit
    1603                 :             :    clear, the insn should be executed only if the branch is not taken.  */
    1604                 :             : #define INSN_FROM_TARGET_P(RTX)                                         \
    1605                 :             :   (RTL_FLAG_CHECK3 ("INSN_FROM_TARGET_P", (RTX), INSN, JUMP_INSN, \
    1606                 :             :                     CALL_INSN)->in_struct)
    1607                 :             : 
    1608                 :             : /* In an ADDR_DIFF_VEC, the flags for RTX for use by branch shortening.
    1609                 :             :    See the comments for ADDR_DIFF_VEC in rtl.def.  */
    1610                 :             : #define ADDR_DIFF_VEC_FLAGS(RTX) X0ADVFLAGS (RTX, 4)
    1611                 :             : 
    1612                 :             : /* In a VALUE, the value cselib has assigned to RTX.
    1613                 :             :    This is a "struct cselib_val", see cselib.h.  */
    1614                 :             : #define CSELIB_VAL_PTR(RTX) X0CSELIB (RTX, 0)
    1615                 :             : 
    1616                 :             : /* Holds a list of notes on what this insn does to various REGs.
    1617                 :             :    It is a chain of EXPR_LIST rtx's, where the second operand is the
    1618                 :             :    chain pointer and the first operand is the REG being described.
    1619                 :             :    The mode field of the EXPR_LIST contains not a real machine mode
    1620                 :             :    but a value from enum reg_note.  */
    1621                 :             : #define REG_NOTES(INSN) XEXP(INSN, 6)
    1622                 :             : 
    1623                 :             : /* In an ENTRY_VALUE this is the DECL_INCOMING_RTL of the argument in
    1624                 :             :    question.  */
    1625                 :             : #define ENTRY_VALUE_EXP(RTX) (RTL_CHECKC1 (RTX, 0, ENTRY_VALUE).rt_rtx)
    1626                 :             : 
    1627                 :             : enum reg_note
    1628                 :             : {
    1629                 :             : #define DEF_REG_NOTE(NAME) NAME,
    1630                 :             : #include "reg-notes.def"
    1631                 :             : #undef DEF_REG_NOTE
    1632                 :             :   REG_NOTE_MAX
    1633                 :             : };
    1634                 :             : 
    1635                 :             : /* Define macros to extract and insert the reg-note kind in an EXPR_LIST.  */
    1636                 :             : #define REG_NOTE_KIND(LINK) ((enum reg_note) GET_MODE (LINK))
    1637                 :             : #define PUT_REG_NOTE_KIND(LINK, KIND) \
    1638                 :             :   PUT_MODE_RAW (LINK, (machine_mode) (KIND))
    1639                 :             : 
    1640                 :             : /* Names for REG_NOTE's in EXPR_LIST insn's.  */
    1641                 :             : 
    1642                 :             : extern const char * const reg_note_name[];
    1643                 :             : #define GET_REG_NOTE_NAME(MODE) (reg_note_name[(int) (MODE)])
    1644                 :             : 
    1645                 :             : /* This field is only present on CALL_INSNs.  It holds a chain of EXPR_LIST of
    1646                 :             :    USE, CLOBBER and SET expressions.
    1647                 :             :      USE expressions list the registers filled with arguments that
    1648                 :             :    are passed to the function.
    1649                 :             :      CLOBBER expressions document the registers explicitly clobbered
    1650                 :             :    by this CALL_INSN.
    1651                 :             :      SET expressions say that the return value of the call (the SET_DEST)
    1652                 :             :    is equivalent to a value available before the call (the SET_SRC).
    1653                 :             :    This kind of SET is used when the return value is predictable in
    1654                 :             :    advance.  It is purely an optimisation hint; unlike USEs and CLOBBERs,
    1655                 :             :    it does not affect register liveness.
    1656                 :             : 
    1657                 :             :      Pseudo registers cannot be mentioned in this list.  */
    1658                 :             : #define CALL_INSN_FUNCTION_USAGE(INSN)  XEXP(INSN, 7)
    1659                 :             : 
    1660                 :             : /* The label-number of a code-label.  The assembler label
    1661                 :             :    is made from `L' and the label-number printed in decimal.
    1662                 :             :    Label numbers are unique in a compilation.  */
    1663                 :             : #define CODE_LABEL_NUMBER(INSN) XINT (INSN, 5)
    1664                 :             : 
    1665                 :             : /* In a NOTE that is a line number, this is a string for the file name that the
    1666                 :             :    line is in.  We use the same field to record block numbers temporarily in
    1667                 :             :    NOTE_INSN_BLOCK_BEG and NOTE_INSN_BLOCK_END notes.  (We avoid lots of casts
    1668                 :             :    between ints and pointers if we use a different macro for the block number.)
    1669                 :             :    */
    1670                 :             : 
    1671                 :             : /* Opaque data.  */
    1672                 :             : #define NOTE_DATA(INSN)         RTL_CHECKC1 (INSN, 3, NOTE)
    1673                 :             : #define NOTE_DELETED_LABEL_NAME(INSN) XCSTR (INSN, 3, NOTE)
    1674                 :             : #define SET_INSN_DELETED(INSN) set_insn_deleted (INSN);
    1675                 :             : #define NOTE_BLOCK(INSN)        XCTREE (INSN, 3, NOTE)
    1676                 :             : #define NOTE_EH_HANDLER(INSN)   XCINT (INSN, 3, NOTE)
    1677                 :             : #define NOTE_BASIC_BLOCK(INSN)  XCBBDEF (INSN, 3, NOTE)
    1678                 :             : #define NOTE_VAR_LOCATION(INSN) XCEXP (INSN, 3, NOTE)
    1679                 :             : #define NOTE_MARKER_LOCATION(INSN) XCUINT (INSN, 3, NOTE)
    1680                 :             : #define NOTE_CFI(INSN)          XCCFI (INSN, 3, NOTE)
    1681                 :             : #define NOTE_LABEL_NUMBER(INSN) XCINT (INSN, 3, NOTE)
    1682                 :             : 
    1683                 :             : /* In a NOTE that is a line number, this is the line number.
    1684                 :             :    Other kinds of NOTEs are identified by negative numbers here.  */
    1685                 :             : #define NOTE_KIND(INSN) XCINT (INSN, 4, NOTE)
    1686                 :             : 
    1687                 :             : /* Nonzero if INSN is a note marking the beginning of a basic block.  */
    1688                 :             : #define NOTE_INSN_BASIC_BLOCK_P(INSN) \
    1689                 :             :   (NOTE_P (INSN) && NOTE_KIND (INSN) == NOTE_INSN_BASIC_BLOCK)
    1690                 :             : 
    1691                 :             : /* Nonzero if INSN is a debug nonbind marker note,
    1692                 :             :    for which NOTE_MARKER_LOCATION can be used.  */
    1693                 :             : #define NOTE_MARKER_P(INSN)                             \
    1694                 :             :   (NOTE_P (INSN) &&                                     \
    1695                 :             :    (NOTE_KIND (INSN) == NOTE_INSN_BEGIN_STMT            \
    1696                 :             :     || NOTE_KIND (INSN) == NOTE_INSN_INLINE_ENTRY))
    1697                 :             : 
    1698                 :             : /* Variable declaration and the location of a variable.  */
    1699                 :             : #define PAT_VAR_LOCATION_DECL(PAT) (XCTREE ((PAT), 0, VAR_LOCATION))
    1700                 :             : #define PAT_VAR_LOCATION_LOC(PAT) (XCEXP ((PAT), 1, VAR_LOCATION))
    1701                 :             : 
    1702                 :             : /* Initialization status of the variable in the location.  Status
    1703                 :             :    can be unknown, uninitialized or initialized.  See enumeration
    1704                 :             :    type below.  */
    1705                 :             : #define PAT_VAR_LOCATION_STATUS(PAT) \
    1706                 :             :   (RTL_FLAG_CHECK1 ("PAT_VAR_LOCATION_STATUS", PAT, VAR_LOCATION) \
    1707                 :             :    ->u2.var_location_status)
    1708                 :             : 
    1709                 :             : /* Accessors for a NOTE_INSN_VAR_LOCATION.  */
    1710                 :             : #define NOTE_VAR_LOCATION_DECL(NOTE) \
    1711                 :             :   PAT_VAR_LOCATION_DECL (NOTE_VAR_LOCATION (NOTE))
    1712                 :             : #define NOTE_VAR_LOCATION_LOC(NOTE) \
    1713                 :             :   PAT_VAR_LOCATION_LOC (NOTE_VAR_LOCATION (NOTE))
    1714                 :             : #define NOTE_VAR_LOCATION_STATUS(NOTE) \
    1715                 :             :   PAT_VAR_LOCATION_STATUS (NOTE_VAR_LOCATION (NOTE))
    1716                 :             : 
    1717                 :             : /* Evaluate to TRUE if INSN is a debug insn that denotes a variable
    1718                 :             :    location/value tracking annotation.  */
    1719                 :             : #define DEBUG_BIND_INSN_P(INSN)                 \
    1720                 :             :   (DEBUG_INSN_P (INSN)                          \
    1721                 :             :    && (GET_CODE (PATTERN (INSN))                \
    1722                 :             :        == VAR_LOCATION))
    1723                 :             : /* Evaluate to TRUE if INSN is a debug insn that denotes a program
    1724                 :             :    source location marker.  */
    1725                 :             : #define DEBUG_MARKER_INSN_P(INSN)               \
    1726                 :             :   (DEBUG_INSN_P (INSN)                          \
    1727                 :             :    && (GET_CODE (PATTERN (INSN))                \
    1728                 :             :        != VAR_LOCATION))
    1729                 :             : /* Evaluate to the marker kind.  */
    1730                 :             : #define INSN_DEBUG_MARKER_KIND(INSN)              \
    1731                 :             :   (GET_CODE (PATTERN (INSN)) == DEBUG_MARKER      \
    1732                 :             :    ? (GET_MODE (PATTERN (INSN)) == VOIDmode       \
    1733                 :             :       ? NOTE_INSN_BEGIN_STMT                      \
    1734                 :             :       : GET_MODE (PATTERN (INSN)) == BLKmode      \
    1735                 :             :       ? NOTE_INSN_INLINE_ENTRY                    \
    1736                 :             :       : (enum insn_note)-1)                       \
    1737                 :             :    : (enum insn_note)-1)
    1738                 :             : /* Create patterns for debug markers.  These and the above abstract
    1739                 :             :    the representation, so that it's easier to get rid of the abuse of
    1740                 :             :    the mode to hold the marker kind.  Other marker types are
    1741                 :             :    envisioned, so a single bit flag won't do; maybe separate RTL codes
    1742                 :             :    wouldn't be a problem.  */
    1743                 :             : #define GEN_RTX_DEBUG_MARKER_BEGIN_STMT_PAT() \
    1744                 :             :   gen_rtx_DEBUG_MARKER (VOIDmode)
    1745                 :             : #define GEN_RTX_DEBUG_MARKER_INLINE_ENTRY_PAT() \
    1746                 :             :   gen_rtx_DEBUG_MARKER (BLKmode)
    1747                 :             : 
    1748                 :             : /* The VAR_LOCATION rtx in a DEBUG_INSN.  */
    1749                 :             : #define INSN_VAR_LOCATION(INSN) \
    1750                 :             :   (RTL_FLAG_CHECK1 ("INSN_VAR_LOCATION", PATTERN (INSN), VAR_LOCATION))
    1751                 :             : /* A pointer to the VAR_LOCATION rtx in a DEBUG_INSN.  */
    1752                 :             : #define INSN_VAR_LOCATION_PTR(INSN) \
    1753                 :             :   (&PATTERN (INSN))
    1754                 :             : 
    1755                 :             : /* Accessors for a tree-expanded var location debug insn.  */
    1756                 :             : #define INSN_VAR_LOCATION_DECL(INSN) \
    1757                 :             :   PAT_VAR_LOCATION_DECL (INSN_VAR_LOCATION (INSN))
    1758                 :             : #define INSN_VAR_LOCATION_LOC(INSN) \
    1759                 :             :   PAT_VAR_LOCATION_LOC (INSN_VAR_LOCATION (INSN))
    1760                 :             : #define INSN_VAR_LOCATION_STATUS(INSN) \
    1761                 :             :   PAT_VAR_LOCATION_STATUS (INSN_VAR_LOCATION (INSN))
    1762                 :             : 
    1763                 :             : /* Expand to the RTL that denotes an unknown variable location in a
    1764                 :             :    DEBUG_INSN.  */
    1765                 :             : #define gen_rtx_UNKNOWN_VAR_LOC() (gen_rtx_CLOBBER (VOIDmode, const0_rtx))
    1766                 :             : 
    1767                 :             : /* Determine whether X is such an unknown location.  */
    1768                 :             : #define VAR_LOC_UNKNOWN_P(X) \
    1769                 :             :   (GET_CODE (X) == CLOBBER && XEXP ((X), 0) == const0_rtx)
    1770                 :             : 
    1771                 :             : /* 1 if RTX is emitted after a call, but it should take effect before
    1772                 :             :    the call returns.  */
    1773                 :             : #define NOTE_DURING_CALL_P(RTX)                         \
    1774                 :             :   (RTL_FLAG_CHECK1 ("NOTE_VAR_LOCATION_DURING_CALL_P", (RTX), NOTE)->call)
    1775                 :             : 
    1776                 :             : /* DEBUG_EXPR_DECL corresponding to a DEBUG_EXPR RTX.  */
    1777                 :             : #define DEBUG_EXPR_TREE_DECL(RTX) XCTREE (RTX, 0, DEBUG_EXPR)
    1778                 :             : 
    1779                 :             : /* VAR_DECL/PARM_DECL DEBUG_IMPLICIT_PTR takes address of.  */
    1780                 :             : #define DEBUG_IMPLICIT_PTR_DECL(RTX) XCTREE (RTX, 0, DEBUG_IMPLICIT_PTR)
    1781                 :             : 
    1782                 :             : /* PARM_DECL DEBUG_PARAMETER_REF references.  */
    1783                 :             : #define DEBUG_PARAMETER_REF_DECL(RTX) XCTREE (RTX, 0, DEBUG_PARAMETER_REF)
    1784                 :             : 
    1785                 :             : /* Codes that appear in the NOTE_KIND field for kinds of notes
    1786                 :             :    that are not line numbers.  These codes are all negative.
    1787                 :             : 
    1788                 :             :    Notice that we do not try to use zero here for any of
    1789                 :             :    the special note codes because sometimes the source line
    1790                 :             :    actually can be zero!  This happens (for example) when we
    1791                 :             :    are generating code for the per-translation-unit constructor
    1792                 :             :    and destructor routines for some C++ translation unit.  */
    1793                 :             : 
    1794                 :             : enum insn_note
    1795                 :             : {
    1796                 :             : #define DEF_INSN_NOTE(NAME) NAME,
    1797                 :             : #include "insn-notes.def"
    1798                 :             : #undef DEF_INSN_NOTE
    1799                 :             : 
    1800                 :             :   NOTE_INSN_MAX
    1801                 :             : };
    1802                 :             : 
    1803                 :             : /* Names for NOTE insn's other than line numbers.  */
    1804                 :             : 
    1805                 :             : extern const char * const note_insn_name[NOTE_INSN_MAX];
    1806                 :             : #define GET_NOTE_INSN_NAME(NOTE_CODE) \
    1807                 :             :   (note_insn_name[(NOTE_CODE)])
    1808                 :             : 
    1809                 :             : /* The name of a label, in case it corresponds to an explicit label
    1810                 :             :    in the input source code.  */
    1811                 :             : #define LABEL_NAME(RTX) XCSTR (RTX, 6, CODE_LABEL)
    1812                 :             : 
    1813                 :             : /* In jump.cc, each label contains a count of the number
    1814                 :             :    of LABEL_REFs that point at it, so unused labels can be deleted.  */
    1815                 :             : #define LABEL_NUSES(RTX) XCINT (RTX, 4, CODE_LABEL)
    1816                 :             : 
    1817                 :             : /* Labels carry a two-bit field composed of the ->jump and ->call
    1818                 :             :    bits.  This field indicates whether the label is an alternate
    1819                 :             :    entry point, and if so, what kind.  */
    1820                 :             : enum label_kind
    1821                 :             : {
    1822                 :             :   LABEL_NORMAL = 0,     /* ordinary label */
    1823                 :             :   LABEL_STATIC_ENTRY,   /* alternate entry point, not exported */
    1824                 :             :   LABEL_GLOBAL_ENTRY,   /* alternate entry point, exported */
    1825                 :             :   LABEL_WEAK_ENTRY      /* alternate entry point, exported as weak symbol */
    1826                 :             : };
    1827                 :             : 
    1828                 :             : #if defined ENABLE_RTL_FLAG_CHECKING && (GCC_VERSION > 2007)
    1829                 :             : 
    1830                 :             : /* Retrieve the kind of LABEL.  */
    1831                 :             : #define LABEL_KIND(LABEL) __extension__                                 \
    1832                 :             : ({ __typeof (LABEL) const _label = (LABEL);                             \
    1833                 :             :    if (! LABEL_P (_label))                                              \
    1834                 :             :      rtl_check_failed_flag ("LABEL_KIND", _label, __FILE__, __LINE__, \
    1835                 :             :                             __FUNCTION__);                              \
    1836                 :             :    (enum label_kind) ((_label->jump << 1) | _label->call); })
    1837                 :             : 
    1838                 :             : /* Set the kind of LABEL.  */
    1839                 :             : #define SET_LABEL_KIND(LABEL, KIND) do {                                \
    1840                 :             :    __typeof (LABEL) const _label = (LABEL);                             \
    1841                 :             :    const unsigned int _kind = (KIND);                                   \
    1842                 :             :    if (! LABEL_P (_label))                                              \
    1843                 :             :      rtl_check_failed_flag ("SET_LABEL_KIND", _label, __FILE__, __LINE__, \
    1844                 :             :                             __FUNCTION__);                              \
    1845                 :             :    _label->jump = ((_kind >> 1) & 1);                                      \
    1846                 :             :    _label->call = (_kind & 1);                                           \
    1847                 :             : } while (0)
    1848                 :             : 
    1849                 :             : #else
    1850                 :             : 
    1851                 :             : /* Retrieve the kind of LABEL.  */
    1852                 :             : #define LABEL_KIND(LABEL) \
    1853                 :             :    ((enum label_kind) (((LABEL)->jump << 1) | (LABEL)->call))
    1854                 :             : 
    1855                 :             : /* Set the kind of LABEL.  */
    1856                 :             : #define SET_LABEL_KIND(LABEL, KIND) do {                                \
    1857                 :             :    rtx const _label = (LABEL);                                          \
    1858                 :             :    const unsigned int _kind = (KIND);                                   \
    1859                 :             :    _label->jump = ((_kind >> 1) & 1);                                      \
    1860                 :             :    _label->call = (_kind & 1);                                           \
    1861                 :             : } while (0)
    1862                 :             : 
    1863                 :             : #endif /* rtl flag checking */
    1864                 :             : 
    1865                 :             : #define LABEL_ALT_ENTRY_P(LABEL) (LABEL_KIND (LABEL) != LABEL_NORMAL)
    1866                 :             : 
    1867                 :             : /* In jump.cc, each JUMP_INSN can point to a label that it can jump to,
    1868                 :             :    so that if the JUMP_INSN is deleted, the label's LABEL_NUSES can
    1869                 :             :    be decremented and possibly the label can be deleted.  */
    1870                 :             : #define JUMP_LABEL(INSN)   XCEXP (INSN, 7, JUMP_INSN)
    1871                 :             : 
    1872                 :     7834448 : inline rtx_insn *JUMP_LABEL_AS_INSN (const rtx_insn *insn)
    1873                 :             : {
    1874                 :     7834448 :   return safe_as_a <rtx_insn *> (JUMP_LABEL (insn));
    1875                 :             : }
    1876                 :             : 
    1877                 :             : /* Methods of rtx_jump_insn.  */
    1878                 :             : 
    1879                 :     7393303 : inline rtx rtx_jump_insn::jump_label () const
    1880                 :             : {
    1881                 :     7393303 :   return JUMP_LABEL (this);
    1882                 :             : }
    1883                 :             : 
    1884                 :           0 : inline rtx_code_label *rtx_jump_insn::jump_target () const
    1885                 :             : {
    1886                 :           0 :   return safe_as_a <rtx_code_label *> (JUMP_LABEL (this));
    1887                 :             : }
    1888                 :             : 
    1889                 :       57172 : inline void rtx_jump_insn::set_jump_target (rtx_code_label *target)
    1890                 :             : {
    1891                 :       57172 :   JUMP_LABEL (this) = target;
    1892                 :             : }
    1893                 :             : 
    1894                 :             : /* Once basic blocks are found, each CODE_LABEL starts a chain that
    1895                 :             :    goes through all the LABEL_REFs that jump to that label.  The chain
    1896                 :             :    eventually winds up at the CODE_LABEL: it is circular.  */
    1897                 :             : #define LABEL_REFS(LABEL) XCEXP (LABEL, 3, CODE_LABEL)
    1898                 :             : 
    1899                 :             : /* Get the label that a LABEL_REF references.  */
    1900                 :             : inline rtx_insn *
    1901                 :    82763606 : label_ref_label (const_rtx ref)
    1902                 :             : {
    1903                 :    82729061 :   return as_a<rtx_insn *> (XCEXP (ref, 0, LABEL_REF));
    1904                 :             : }
    1905                 :             : 
    1906                 :             : /* Set the label that LABEL_REF ref refers to.  */
    1907                 :             : 
    1908                 :             : inline void
    1909                 :    30584500 : set_label_ref_label (rtx ref, rtx_insn *label)
    1910                 :             : {
    1911                 :    30584500 :   XCEXP (ref, 0, LABEL_REF) = label;
    1912                 :             : }
    1913                 :             : 
    1914                 :             : /* For a REG rtx, REGNO extracts the register number.  REGNO can only
    1915                 :             :    be used on RHS.  Use SET_REGNO to change the value.  */
    1916                 :             : #define REGNO(RTX) (rhs_regno(RTX))
    1917                 :             : #define SET_REGNO(RTX, N) (df_ref_change_reg_with_loc (RTX, N))
    1918                 :             : 
    1919                 :             : /* Return the number of consecutive registers in a REG.  This is always
    1920                 :             :    1 for pseudo registers and is determined by TARGET_HARD_REGNO_NREGS for
    1921                 :             :    hard registers.  */
    1922                 :             : #define REG_NREGS(RTX) (REG_CHECK (RTX)->nregs)
    1923                 :             : 
    1924                 :             : /* ORIGINAL_REGNO holds the number the register originally had; for a
    1925                 :             :    pseudo register turned into a hard reg this will hold the old pseudo
    1926                 :             :    register number.  */
    1927                 :             : #define ORIGINAL_REGNO(RTX) \
    1928                 :             :   (RTL_FLAG_CHECK1 ("ORIGINAL_REGNO", (RTX), REG)->u2.original_regno)
    1929                 :             : 
    1930                 :             : /* Force the REGNO macro to only be used on the lhs.  */
    1931                 :             : inline unsigned int
    1932                 : 70620497682 : rhs_regno (const_rtx x)
    1933                 :             : {
    1934                 : 60502319819 :   return REG_CHECK (x)->regno;
    1935                 :             : }
    1936                 :             : 
    1937                 :             : /* Return the final register in REG X plus one.  */
    1938                 :             : inline unsigned int
    1939                 : 11951751189 : END_REGNO (const_rtx x)
    1940                 :             : {
    1941                 : 11844619685 :   return REGNO (x) + REG_NREGS (x);
    1942                 :             : }
    1943                 :             : 
    1944                 :             : /* Change the REGNO and REG_NREGS of REG X to the specified values,
    1945                 :             :    bypassing the df machinery.  */
    1946                 :             : inline void
    1947                 :  1591065820 : set_regno_raw (rtx x, unsigned int regno, unsigned int nregs)
    1948                 :             : {
    1949                 :  1591065820 :   reg_info *reg = REG_CHECK (x);
    1950                 :  1591065820 :   reg->regno = regno;
    1951                 :  1591065820 :   reg->nregs = nregs;
    1952                 :             : }
    1953                 :             : 
    1954                 :             : /* 1 if RTX is a reg or parallel that is the current function's return
    1955                 :             :    value.  */
    1956                 :             : #define REG_FUNCTION_VALUE_P(RTX)                                       \
    1957                 :             :   (RTL_FLAG_CHECK2 ("REG_FUNCTION_VALUE_P", (RTX), REG, PARALLEL)->return_val)
    1958                 :             : 
    1959                 :             : /* 1 if RTX is a reg that corresponds to a variable declared by the user.  */
    1960                 :             : #define REG_USERVAR_P(RTX)                                              \
    1961                 :             :   (RTL_FLAG_CHECK1 ("REG_USERVAR_P", (RTX), REG)->volatil)
    1962                 :             : 
    1963                 :             : /* 1 if RTX is a reg that holds a pointer value.  */
    1964                 :             : #define REG_POINTER(RTX)                                                \
    1965                 :             :   (RTL_FLAG_CHECK1 ("REG_POINTER", (RTX), REG)->frame_related)
    1966                 :             : 
    1967                 :             : /* 1 if RTX is a mem that holds a pointer value.  */
    1968                 :             : #define MEM_POINTER(RTX)                                                \
    1969                 :             :   (RTL_FLAG_CHECK1 ("MEM_POINTER", (RTX), MEM)->frame_related)
    1970                 :             : 
    1971                 :             : /* 1 if the given register REG corresponds to a hard register.  */
    1972                 :             : #define HARD_REGISTER_P(REG) HARD_REGISTER_NUM_P (REGNO (REG))
    1973                 :             : 
    1974                 :             : /* 1 if the given register number REG_NO corresponds to a hard register.  */
    1975                 :             : #define HARD_REGISTER_NUM_P(REG_NO) ((REG_NO) < FIRST_PSEUDO_REGISTER)
    1976                 :             : 
    1977                 :             : /* 1 if the given register REG corresponds to a virtual register.  */
    1978                 :             : #define VIRTUAL_REGISTER_P(REG) VIRTUAL_REGISTER_NUM_P (REGNO (REG))
    1979                 :             : 
    1980                 :             : /* 1 if the given register number REG_NO corresponds to a virtual register.  */
    1981                 :             : #define VIRTUAL_REGISTER_NUM_P(REG_NO)                                  \
    1982                 :             :   IN_RANGE (REG_NO, FIRST_VIRTUAL_REGISTER, LAST_VIRTUAL_REGISTER)
    1983                 :             : 
    1984                 :             : /* For a CONST_INT rtx, INTVAL extracts the integer.  */
    1985                 :             : #define INTVAL(RTX) XCWINT (RTX, 0, CONST_INT)
    1986                 :             : #define UINTVAL(RTX) ((unsigned HOST_WIDE_INT) INTVAL (RTX))
    1987                 :             : 
    1988                 :             : /* For a CONST_WIDE_INT, CONST_WIDE_INT_NUNITS is the number of
    1989                 :             :    elements actually needed to represent the constant.
    1990                 :             :    CONST_WIDE_INT_ELT gets one of the elements.  0 is the least
    1991                 :             :    significant HOST_WIDE_INT.  */
    1992                 :             : #define CONST_WIDE_INT_VEC(RTX) HWIVEC_CHECK (RTX, CONST_WIDE_INT)
    1993                 :             : #define CONST_WIDE_INT_NUNITS(RTX) CWI_GET_NUM_ELEM (RTX)
    1994                 :             : #define CONST_WIDE_INT_ELT(RTX, N) CWI_ELT (RTX, N)
    1995                 :             : 
    1996                 :             : /* For a CONST_POLY_INT, CONST_POLY_INT_COEFFS gives access to the
    1997                 :             :    individual coefficients, in the form of a trailing_wide_ints structure.  */
    1998                 :             : #define CONST_POLY_INT_COEFFS(RTX) \
    1999                 :             :   (RTL_FLAG_CHECK1("CONST_POLY_INT_COEFFS", (RTX), \
    2000                 :             :                    CONST_POLY_INT)->u.cpi.coeffs)
    2001                 :             : 
    2002                 :             : /* For a CONST_DOUBLE:
    2003                 :             : #if TARGET_SUPPORTS_WIDE_INT == 0
    2004                 :             :    For a VOIDmode, there are two integers CONST_DOUBLE_LOW is the
    2005                 :             :      low-order word and ..._HIGH the high-order.
    2006                 :             : #endif
    2007                 :             :    For a float, there is a REAL_VALUE_TYPE structure, and
    2008                 :             :      CONST_DOUBLE_REAL_VALUE(r) is a pointer to it.  */
    2009                 :             : #define CONST_DOUBLE_LOW(r) XCMWINT (r, 0, CONST_DOUBLE, VOIDmode)
    2010                 :             : #define CONST_DOUBLE_HIGH(r) XCMWINT (r, 1, CONST_DOUBLE, VOIDmode)
    2011                 :             : #define CONST_DOUBLE_REAL_VALUE(r) \
    2012                 :             :   ((const struct real_value *) XCNMPRV (r, CONST_DOUBLE, VOIDmode))
    2013                 :             : 
    2014                 :             : #define CONST_FIXED_VALUE(r) \
    2015                 :             :   ((const struct fixed_value *) XCNMPFV (r, CONST_FIXED, VOIDmode))
    2016                 :             : #define CONST_FIXED_VALUE_HIGH(r) \
    2017                 :             :   ((HOST_WIDE_INT) (CONST_FIXED_VALUE (r)->data.high))
    2018                 :             : #define CONST_FIXED_VALUE_LOW(r) \
    2019                 :             :   ((HOST_WIDE_INT) (CONST_FIXED_VALUE (r)->data.low))
    2020                 :             : 
    2021                 :             : /* For a CONST_VECTOR, return element #n.  */
    2022                 :             : #define CONST_VECTOR_ELT(RTX, N) const_vector_elt (RTX, N)
    2023                 :             : 
    2024                 :             : /* See rtl.texi for a description of these macros.  */
    2025                 :             : #define CONST_VECTOR_NPATTERNS(RTX) \
    2026                 :             :  (RTL_FLAG_CHECK1 ("CONST_VECTOR_NPATTERNS", (RTX), CONST_VECTOR) \
    2027                 :             :   ->u2.const_vector.npatterns)
    2028                 :             : 
    2029                 :             : #define CONST_VECTOR_NELTS_PER_PATTERN(RTX) \
    2030                 :             :  (RTL_FLAG_CHECK1 ("CONST_VECTOR_NELTS_PER_PATTERN", (RTX), CONST_VECTOR) \
    2031                 :             :   ->u2.const_vector.nelts_per_pattern)
    2032                 :             : 
    2033                 :             : #define CONST_VECTOR_DUPLICATE_P(RTX) \
    2034                 :             :   (CONST_VECTOR_NELTS_PER_PATTERN (RTX) == 1)
    2035                 :             : 
    2036                 :             : #define CONST_VECTOR_STEPPED_P(RTX) \
    2037                 :             :   (CONST_VECTOR_NELTS_PER_PATTERN (RTX) == 3)
    2038                 :             : 
    2039                 :             : #define CONST_VECTOR_ENCODED_ELT(RTX, N) XCVECEXP (RTX, 0, N, CONST_VECTOR)
    2040                 :             : 
    2041                 :             : /* Return the number of elements encoded directly in a CONST_VECTOR.  */
    2042                 :             : 
    2043                 :             : inline unsigned int
    2044                 :     6790731 : const_vector_encoded_nelts (const_rtx x)
    2045                 :             : {
    2046                 :     6790731 :   return CONST_VECTOR_NPATTERNS (x) * CONST_VECTOR_NELTS_PER_PATTERN (x);
    2047                 :             : }
    2048                 :             : 
    2049                 :             : /* For a CONST_VECTOR, return the number of elements in a vector.  */
    2050                 :             : #define CONST_VECTOR_NUNITS(RTX) GET_MODE_NUNITS (GET_MODE (RTX))
    2051                 :             : 
    2052                 :             : /* For a SUBREG rtx, SUBREG_REG extracts the value we want a subreg of.
    2053                 :             :    SUBREG_BYTE extracts the byte-number.  */
    2054                 :             : 
    2055                 :             : #define SUBREG_REG(RTX) XCEXP (RTX, 0, SUBREG)
    2056                 :             : #define SUBREG_BYTE(RTX) XCSUBREG (RTX, 1, SUBREG)
    2057                 :             : 
    2058                 :             : /* in rtlanal.cc */
    2059                 :             : /* Return the right cost to give to an operation
    2060                 :             :    to make the cost of the corresponding register-to-register instruction
    2061                 :             :    N times that of a fast register-to-register instruction.  */
    2062                 :             : #define COSTS_N_INSNS(N) ((N) * 4)
    2063                 :             : 
    2064                 :             : /* Maximum cost of an rtl expression.  This value has the special meaning
    2065                 :             :    not to use an rtx with this cost under any circumstances.  */
    2066                 :             : #define MAX_COST INT_MAX
    2067                 :             : 
    2068                 :             : /* Return true if CODE always has VOIDmode.  */
    2069                 :             : 
    2070                 :             : inline bool
    2071                 :             : always_void_p (enum rtx_code code)
    2072                 :             : {
    2073                 :             :   return code == SET;
    2074                 :             : }
    2075                 :             : 
    2076                 :             : /* A structure to hold all available cost information about an rtl
    2077                 :             :    expression.  */
    2078                 :             : struct full_rtx_costs
    2079                 :             : {
    2080                 :             :   int speed;
    2081                 :             :   int size;
    2082                 :             : };
    2083                 :             : 
    2084                 :             : /* Initialize a full_rtx_costs structure C to the maximum cost.  */
    2085                 :             : inline void
    2086                 :     1774800 : init_costs_to_max (struct full_rtx_costs *c)
    2087                 :             : {
    2088                 :     1774800 :   c->speed = MAX_COST;
    2089                 :     1774800 :   c->size = MAX_COST;
    2090                 :             : }
    2091                 :             : 
    2092                 :             : /* Initialize a full_rtx_costs structure C to zero cost.  */
    2093                 :             : inline void
    2094                 :           0 : init_costs_to_zero (struct full_rtx_costs *c)
    2095                 :             : {
    2096                 :           0 :   c->speed = 0;
    2097                 :           0 :   c->size = 0;
    2098                 :             : }
    2099                 :             : 
    2100                 :             : /* Compare two full_rtx_costs structures A and B, returning true
    2101                 :             :    if A < B when optimizing for speed.  */
    2102                 :             : inline bool
    2103                 :     2015410 : costs_lt_p (struct full_rtx_costs *a, struct full_rtx_costs *b,
    2104                 :             :             bool speed)
    2105                 :             : {
    2106                 :     2015410 :   if (speed)
    2107                 :     1357984 :     return (a->speed < b->speed
    2108                 :     1377372 :             || (a->speed == b->speed && a->size < b->size));
    2109                 :             :   else
    2110                 :      657426 :     return (a->size < b->size
    2111                 :      661239 :             || (a->size == b->size && a->speed < b->speed));
    2112                 :             : }
    2113                 :             : 
    2114                 :             : /* Increase both members of the full_rtx_costs structure C by the
    2115                 :             :    cost of N insns.  */
    2116                 :             : inline void
    2117                 :         377 : costs_add_n_insns (struct full_rtx_costs *c, int n)
    2118                 :             : {
    2119                 :         377 :   c->speed += COSTS_N_INSNS (n);
    2120                 :         377 :   c->size += COSTS_N_INSNS (n);
    2121                 :             : }
    2122                 :             : 
    2123                 :             : /* Describes the shape of a subreg:
    2124                 :             : 
    2125                 :             :    inner_mode == the mode of the SUBREG_REG
    2126                 :             :    offset     == the SUBREG_BYTE
    2127                 :             :    outer_mode == the mode of the SUBREG itself.  */
    2128                 :             : class subreg_shape {
    2129                 :             : public:
    2130                 :             :   subreg_shape (machine_mode, poly_uint16, machine_mode);
    2131                 :             :   bool operator == (const subreg_shape &) const;
    2132                 :             :   bool operator != (const subreg_shape &) const;
    2133                 :             :   unsigned HOST_WIDE_INT unique_id () const;
    2134                 :             : 
    2135                 :             :   machine_mode inner_mode;
    2136                 :             :   poly_uint16 offset;
    2137                 :             :   machine_mode outer_mode;
    2138                 :             : };
    2139                 :             : 
    2140                 :             : inline
    2141                 :     3177810 : subreg_shape::subreg_shape (machine_mode inner_mode_in,
    2142                 :             :                             poly_uint16 offset_in,
    2143                 :             :                             machine_mode outer_mode_in)
    2144                 :             :   : inner_mode (inner_mode_in), offset (offset_in), outer_mode (outer_mode_in)
    2145                 :             : {}
    2146                 :             : 
    2147                 :             : inline bool
    2148                 :    10536099 : subreg_shape::operator == (const subreg_shape &other) const
    2149                 :             : {
    2150                 :    10536099 :   return (inner_mode == other.inner_mode
    2151                 :     3827694 :           && known_eq (offset, other.offset)
    2152                 :    13955536 :           && outer_mode == other.outer_mode);
    2153                 :             : }
    2154                 :             : 
    2155                 :             : inline bool
    2156                 :             : subreg_shape::operator != (const subreg_shape &other) const
    2157                 :             : {
    2158                 :             :   return !operator == (other);
    2159                 :             : }
    2160                 :             : 
    2161                 :             : /* Return an integer that uniquely identifies this shape.  Structures
    2162                 :             :    like rtx_def assume that a mode can fit in an 8-bit bitfield and no
    2163                 :             :    current mode is anywhere near being 65536 bytes in size, so the
    2164                 :             :    id comfortably fits in an int.  */
    2165                 :             : 
    2166                 :             : inline unsigned HOST_WIDE_INT
    2167                 :    11185634 : subreg_shape::unique_id () const
    2168                 :             : {
    2169                 :    11185634 :   { STATIC_ASSERT (MAX_MACHINE_MODE <= (1 << MACHINE_MODE_BITSIZE)); }
    2170                 :    11185634 :   { STATIC_ASSERT (NUM_POLY_INT_COEFFS <= 3); }
    2171                 :    11185634 :   { STATIC_ASSERT (sizeof (offset.coeffs[0]) <= 2); }
    2172                 :    11185634 :   int res = (int) inner_mode + ((int) outer_mode << 8);
    2173                 :    11185634 :   for (int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
    2174                 :    11185634 :     res += (HOST_WIDE_INT) offset.coeffs[i] << ((1 + i) * 16);
    2175                 :     3177810 :   return res;
    2176                 :             : }
    2177                 :             : 
    2178                 :             : /* Return the shape of a SUBREG rtx.  */
    2179                 :             : 
    2180                 :             : inline subreg_shape
    2181                 :     3177810 : shape_of_subreg (const_rtx x)
    2182                 :             : {
    2183                 :     3177810 :   return subreg_shape (GET_MODE (SUBREG_REG (x)),
    2184                 :     3177810 :                        SUBREG_BYTE (x), GET_MODE (x));
    2185                 :             : }
    2186                 :             : 
    2187                 :             : /* Information about an address.  This structure is supposed to be able
    2188                 :             :    to represent all supported target addresses.  Please extend it if it
    2189                 :             :    is not yet general enough.  */
    2190                 :             : struct address_info {
    2191                 :             :   /* The mode of the value being addressed, or VOIDmode if this is
    2192                 :             :      a load-address operation with no known address mode.  */
    2193                 :             :   machine_mode mode;
    2194                 :             : 
    2195                 :             :   /* The address space.  */
    2196                 :             :   addr_space_t as;
    2197                 :             : 
    2198                 :             :   /* True if this is an RTX_AUTOINC address.  */
    2199                 :             :   bool autoinc_p;
    2200                 :             : 
    2201                 :             :   /* A pointer to the top-level address.  */
    2202                 :             :   rtx *outer;
    2203                 :             : 
    2204                 :             :   /* A pointer to the inner address, after all address mutations
    2205                 :             :      have been stripped from the top-level address.  It can be one
    2206                 :             :      of the following:
    2207                 :             : 
    2208                 :             :      - A {PRE,POST}_{INC,DEC} of *BASE.  SEGMENT, INDEX and DISP are null.
    2209                 :             : 
    2210                 :             :      - A {PRE,POST}_MODIFY of *BASE.  In this case either INDEX or DISP
    2211                 :             :        points to the step value, depending on whether the step is variable
    2212                 :             :        or constant respectively.  SEGMENT is null.
    2213                 :             : 
    2214                 :             :      - A plain sum of the form SEGMENT + BASE + INDEX + DISP,
    2215                 :             :        with null fields evaluating to 0.  */
    2216                 :             :   rtx *inner;
    2217                 :             : 
    2218                 :             :   /* Components that make up *INNER.  Each one may be null or nonnull.
    2219                 :             :      When nonnull, their meanings are as follows:
    2220                 :             : 
    2221                 :             :      - *SEGMENT is the "segment" of memory to which the address refers.
    2222                 :             :        This value is entirely target-specific and is only called a "segment"
    2223                 :             :        because that's its most typical use.  It contains exactly one UNSPEC,
    2224                 :             :        pointed to by SEGMENT_TERM.  The contents of *SEGMENT do not need
    2225                 :             :        reloading.
    2226                 :             : 
    2227                 :             :      - *BASE is a variable expression representing a base address.
    2228                 :             :        It contains exactly one "term", pointed to by BASE_TERM.
    2229                 :             :        This term can be one of the following:
    2230                 :             : 
    2231                 :             :        (1) a REG, or a SUBREG of a REG
    2232                 :             :        (2) an eliminated REG (a PLUS of (1) and a constant)
    2233                 :             :        (3) a MEM, or a SUBREG of a MEM
    2234                 :             :        (4) a SCRATCH
    2235                 :             : 
    2236                 :             :        This term is the one that base_reg_class constrains.
    2237                 :             : 
    2238                 :             :      - *INDEX is a variable expression representing an index value.
    2239                 :             :        It may be a scaled expression, such as a MULT.  It has exactly
    2240                 :             :        one "term", pointed to by INDEX_TERM.  The possible terms are
    2241                 :             :        the same as for BASE.  This term is the one that index_reg_class
    2242                 :             :        constrains.
    2243                 :             : 
    2244                 :             :      - *DISP is a constant, possibly mutated.  DISP_TERM points to the
    2245                 :             :        unmutated RTX_CONST_OBJ.  */
    2246                 :             :   rtx *segment;
    2247                 :             :   rtx *base;
    2248                 :             :   rtx *index;
    2249                 :             :   rtx *disp;
    2250                 :             : 
    2251                 :             :   rtx *segment_term;
    2252                 :             :   rtx *base_term;
    2253                 :             :   rtx *index_term;
    2254                 :             :   rtx *disp_term;
    2255                 :             : 
    2256                 :             :   /* In a {PRE,POST}_MODIFY address, this points to a second copy
    2257                 :             :      of BASE_TERM, otherwise it is null.  */
    2258                 :             :   rtx *base_term2;
    2259                 :             : 
    2260                 :             :   /* ADDRESS if this structure describes an address operand, MEM if
    2261                 :             :      it describes a MEM address.  */
    2262                 :             :   enum rtx_code addr_outer_code;
    2263                 :             : 
    2264                 :             :   /* If BASE is nonnull, this is the code of the rtx that contains it.  */
    2265                 :             :   enum rtx_code base_outer_code;
    2266                 :             : };
    2267                 :             : 
    2268                 :             : /* This is used to bundle an rtx and a mode together so that the pair
    2269                 :             :    can be used with the wi:: routines.  If we ever put modes into rtx
    2270                 :             :    integer constants, this should go away and then just pass an rtx in.  */
    2271                 :             : typedef std::pair <rtx, machine_mode> rtx_mode_t;
    2272                 :             : 
    2273                 :             : namespace wi
    2274                 :             : {
    2275                 :             :   template <>
    2276                 :             :   struct int_traits <rtx_mode_t>
    2277                 :             :   {
    2278                 :             :     static const enum precision_type precision_type = VAR_PRECISION;
    2279                 :             :     static const bool host_dependent_precision = false;
    2280                 :             :     /* This ought to be true, except for the special case that BImode
    2281                 :             :        is canonicalized to STORE_FLAG_VALUE, which might be 1.  */
    2282                 :             :     static const bool is_sign_extended = false;
    2283                 :             :     static const bool needs_write_val_arg = false;
    2284                 :             :     static unsigned int get_precision (const rtx_mode_t &);
    2285                 :             :     static wi::storage_ref decompose (HOST_WIDE_INT *, unsigned int,
    2286                 :             :                                       const rtx_mode_t &);
    2287                 :             :   };
    2288                 :             : }
    2289                 :             : 
    2290                 :             : inline unsigned int
    2291                 :  1103239940 : wi::int_traits <rtx_mode_t>::get_precision (const rtx_mode_t &x)
    2292                 :             : {
    2293                 :  1103239940 :   return GET_MODE_PRECISION (as_a <scalar_mode> (x.second));
    2294                 :             : }
    2295                 :             : 
    2296                 :             : inline wi::storage_ref
    2297                 :   563390644 : wi::int_traits <rtx_mode_t>::decompose (HOST_WIDE_INT *,
    2298                 :             :                                         unsigned int precision,
    2299                 :             :                                         const rtx_mode_t &x)
    2300                 :             : {
    2301                 :   563390644 :   gcc_checking_assert (precision == get_precision (x));
    2302                 :   563390644 :   switch (GET_CODE (x.first))
    2303                 :             :     {
    2304                 :   562632839 :     case CONST_INT:
    2305                 :   562632839 :       if (precision < HOST_BITS_PER_WIDE_INT)
    2306                 :             :         /* Nonzero BImodes are stored as STORE_FLAG_VALUE, which on many
    2307                 :             :            targets is 1 rather than -1.  */
    2308                 :   195765709 :         gcc_checking_assert (INTVAL (x.first)
    2309                 :             :                              == sext_hwi (INTVAL (x.first), precision)
    2310                 :             :                              || (x.second == BImode && INTVAL (x.first) == 1));
    2311                 :             : 
    2312                 :   562632839 :       return wi::storage_ref (&INTVAL (x.first), 1, precision);
    2313                 :             : 
    2314                 :      757805 :     case CONST_WIDE_INT:
    2315                 :      757805 :       return wi::storage_ref (&CONST_WIDE_INT_ELT (x.first, 0),
    2316                 :      757805 :                               CONST_WIDE_INT_NUNITS (x.first), precision);
    2317                 :             : 
    2318                 :             : #if TARGET_SUPPORTS_WIDE_INT == 0
    2319                 :             :     case CONST_DOUBLE:
    2320                 :             :       return wi::storage_ref (&CONST_DOUBLE_LOW (x.first), 2, precision);
    2321                 :             : #endif
    2322                 :             : 
    2323                 :           0 :     default:
    2324                 :           0 :       gcc_unreachable ();
    2325                 :             :     }
    2326                 :             : }
    2327                 :             : 
    2328                 :             : namespace wi
    2329                 :             : {
    2330                 :             :   hwi_with_prec shwi (HOST_WIDE_INT, machine_mode mode);
    2331                 :             :   wide_int min_value (machine_mode, signop);
    2332                 :             :   wide_int max_value (machine_mode, signop);
    2333                 :             : }
    2334                 :             : 
    2335                 :             : inline wi::hwi_with_prec
    2336                 :      270358 : wi::shwi (HOST_WIDE_INT val, machine_mode mode)
    2337                 :             : {
    2338                 :      270358 :   return shwi (val, GET_MODE_PRECISION (as_a <scalar_mode> (mode)));
    2339                 :             : }
    2340                 :             : 
    2341                 :             : /* Produce the smallest number that is represented in MODE.  The precision
    2342                 :             :    is taken from MODE and the sign from SGN.  */
    2343                 :             : inline wide_int
    2344                 :       99035 : wi::min_value (machine_mode mode, signop sgn)
    2345                 :             : {
    2346                 :       99035 :   return min_value (GET_MODE_PRECISION (as_a <scalar_mode> (mode)), sgn);
    2347                 :             : }
    2348                 :             : 
    2349                 :             : /* Produce the largest number that is represented in MODE.  The precision
    2350                 :             :    is taken from MODE and the sign from SGN.  */
    2351                 :             : inline wide_int
    2352                 :       78001 : wi::max_value (machine_mode mode, signop sgn)
    2353                 :             : {
    2354                 :       78001 :   return max_value (GET_MODE_PRECISION (as_a <scalar_mode> (mode)), sgn);
    2355                 :             : }
    2356                 :             : 
    2357                 :             : namespace wi
    2358                 :             : {
    2359                 :             :   typedef poly_int<NUM_POLY_INT_COEFFS,
    2360                 :             :                    generic_wide_int <wide_int_ref_storage <false, false> > >
    2361                 :             :     rtx_to_poly_wide_ref;
    2362                 :             :   rtx_to_poly_wide_ref to_poly_wide (const_rtx, machine_mode);
    2363                 :             : }
    2364                 :             : 
    2365                 :             : /* Return the value of a CONST_POLY_INT in its native precision.  */
    2366                 :             : 
    2367                 :             : inline wi::rtx_to_poly_wide_ref
    2368                 :             : const_poly_int_value (const_rtx x)
    2369                 :             : {
    2370                 :             :   poly_int<NUM_POLY_INT_COEFFS, WIDE_INT_REF_FOR (wide_int)> res;
    2371                 :             :   for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
    2372                 :             :     res.coeffs[i] = CONST_POLY_INT_COEFFS (x)[i];
    2373                 :             :   return res;
    2374                 :             : }
    2375                 :             : 
    2376                 :             : /* Return true if X is a scalar integer or a CONST_POLY_INT.  The value
    2377                 :             :    can then be extracted using wi::to_poly_wide.  */
    2378                 :             : 
    2379                 :             : inline bool
    2380                 :    88591487 : poly_int_rtx_p (const_rtx x)
    2381                 :             : {
    2382                 :    53498903 :   return CONST_SCALAR_INT_P (x) || CONST_POLY_INT_P (x);
    2383                 :             : }
    2384                 :             : 
    2385                 :             : /* Access X (which satisfies poly_int_rtx_p) as a poly_wide_int.
    2386                 :             :    MODE is the mode of X.  */
    2387                 :             : 
    2388                 :             : inline wi::rtx_to_poly_wide_ref
    2389                 :     9135178 : wi::to_poly_wide (const_rtx x, machine_mode mode)
    2390                 :             : {
    2391                 :     9135178 :   if (CONST_POLY_INT_P (x))
    2392                 :             :     return const_poly_int_value (x);
    2393                 :     9135178 :   return rtx_mode_t (const_cast<rtx> (x), mode);
    2394                 :             : }
    2395                 :             : 
    2396                 :             : /* Return the value of X as a poly_int64.  */
    2397                 :             : 
    2398                 :             : inline poly_int64
    2399                 :     8418828 : rtx_to_poly_int64 (const_rtx x)
    2400                 :             : {
    2401                 :     8418828 :   if (CONST_POLY_INT_P (x))
    2402                 :             :     {
    2403                 :             :       poly_int64 res;
    2404                 :             :       for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
    2405                 :             :         res.coeffs[i] = CONST_POLY_INT_COEFFS (x)[i].to_shwi ();
    2406                 :             :       return res;
    2407                 :             :     }
    2408                 :     7518769 :   return INTVAL (x);
    2409                 :             : }
    2410                 :             : 
    2411                 :             : /* Return true if arbitrary value X is an integer constant that can
    2412                 :             :    be represented as a poly_int64.  Store the value in *RES if so,
    2413                 :             :    otherwise leave it unmodified.  */
    2414                 :             : 
    2415                 :             : inline bool
    2416                 :  3335387985 : poly_int_rtx_p (const_rtx x, poly_int64 *res)
    2417                 :             : {
    2418                 :  2152122086 :   if (CONST_INT_P (x))
    2419                 :             :     {
    2420                 :  1958715421 :       *res = INTVAL (x);
    2421                 :  1915203328 :       return true;
    2422                 :             :     }
    2423                 :             :   if (CONST_POLY_INT_P (x))
    2424                 :             :     {
    2425                 :             :       for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
    2426                 :             :         if (!wi::fits_shwi_p (CONST_POLY_INT_COEFFS (x)[i]))
    2427                 :             :           return false;
    2428                 :             :       for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
    2429                 :             :         res->coeffs[i] = CONST_POLY_INT_COEFFS (x)[i].to_shwi ();
    2430                 :             :       return true;
    2431                 :             :     }
    2432                 :             :   return false;
    2433                 :             : }
    2434                 :             : 
    2435                 :             : extern void init_rtlanal (void);
    2436                 :             : extern int rtx_cost (rtx, machine_mode, enum rtx_code, int, bool);
    2437                 :             : extern int address_cost (rtx, machine_mode, addr_space_t, bool);
    2438                 :             : extern void get_full_rtx_cost (rtx, machine_mode, enum rtx_code, int,
    2439                 :             :                                struct full_rtx_costs *);
    2440                 :             : extern bool native_encode_rtx (machine_mode, rtx, vec<target_unit> &,
    2441                 :             :                                unsigned int, unsigned int);
    2442                 :             : extern rtx native_decode_rtx (machine_mode, const vec<target_unit> &,
    2443                 :             :                               unsigned int);
    2444                 :             : extern rtx native_decode_vector_rtx (machine_mode, const vec<target_unit> &,
    2445                 :             :                                      unsigned int, unsigned int, unsigned int);
    2446                 :             : extern poly_uint64 subreg_lsb (const_rtx);
    2447                 :             : extern poly_uint64 subreg_size_lsb (poly_uint64, poly_uint64, poly_uint64);
    2448                 :             : extern poly_uint64 subreg_size_offset_from_lsb (poly_uint64, poly_uint64,
    2449                 :             :                                                 poly_uint64);
    2450                 :             : extern bool read_modify_subreg_p (const_rtx);
    2451                 :             : 
    2452                 :             : /* Given a subreg's OUTER_MODE, INNER_MODE, and SUBREG_BYTE, return the
    2453                 :             :    bit offset at which the subreg begins (counting from the least significant
    2454                 :             :    bit of the operand).  */
    2455                 :             : 
    2456                 :             : inline poly_uint64
    2457                 :     3159566 : subreg_lsb_1 (machine_mode outer_mode, machine_mode inner_mode,
    2458                 :             :               poly_uint64 subreg_byte)
    2459                 :             : {
    2460                 :     9478698 :   return subreg_size_lsb (GET_MODE_SIZE (outer_mode),
    2461                 :     3159566 :                           GET_MODE_SIZE (inner_mode), subreg_byte);
    2462                 :             : }
    2463                 :             : 
    2464                 :             : /* Return the subreg byte offset for a subreg whose outer mode is
    2465                 :             :    OUTER_MODE, whose inner mode is INNER_MODE, and where there are
    2466                 :             :    LSB_SHIFT *bits* between the lsb of the outer value and the lsb of
    2467                 :             :    the inner value.  This is the inverse of subreg_lsb_1 (which converts
    2468                 :             :    byte offsets to bit shifts).  */
    2469                 :             : 
    2470                 :             : inline poly_uint64
    2471                 :        3490 : subreg_offset_from_lsb (machine_mode outer_mode,
    2472                 :             :                         machine_mode inner_mode,
    2473                 :             :                         poly_uint64 lsb_shift)
    2474                 :             : {
    2475                 :       10470 :   return subreg_size_offset_from_lsb (GET_MODE_SIZE (outer_mode),
    2476                 :        3490 :                                       GET_MODE_SIZE (inner_mode), lsb_shift);
    2477                 :             : }
    2478                 :             : 
    2479                 :             : extern unsigned int subreg_regno_offset (unsigned int, machine_mode,
    2480                 :             :                                          poly_uint64, machine_mode);
    2481                 :             : extern bool subreg_offset_representable_p (unsigned int, machine_mode,
    2482                 :             :                                            poly_uint64, machine_mode);
    2483                 :             : extern unsigned int subreg_regno (const_rtx);
    2484                 :             : extern int simplify_subreg_regno (unsigned int, machine_mode,
    2485                 :             :                                   poly_uint64, machine_mode);
    2486                 :             : extern int lowpart_subreg_regno (unsigned int, machine_mode,
    2487                 :             :                                  machine_mode);
    2488                 :             : extern unsigned int subreg_nregs (const_rtx);
    2489                 :             : extern unsigned int subreg_nregs_with_regno (unsigned int, const_rtx);
    2490                 :             : extern unsigned HOST_WIDE_INT nonzero_bits (const_rtx, machine_mode);
    2491                 :             : extern unsigned int num_sign_bit_copies (const_rtx, machine_mode);
    2492                 :             : extern bool constant_pool_constant_p (rtx);
    2493                 :             : extern bool truncated_to_mode (machine_mode, const_rtx);
    2494                 :             : extern int low_bitmask_len (machine_mode, unsigned HOST_WIDE_INT);
    2495                 :             : extern void split_double (rtx, rtx *, rtx *);
    2496                 :             : extern rtx *strip_address_mutations (rtx *, enum rtx_code * = 0);
    2497                 :             : extern void decompose_address (struct address_info *, rtx *,
    2498                 :             :                                machine_mode, addr_space_t, enum rtx_code);
    2499                 :             : extern void decompose_lea_address (struct address_info *, rtx *);
    2500                 :             : extern void decompose_mem_address (struct address_info *, rtx);
    2501                 :             : extern void update_address (struct address_info *);
    2502                 :             : extern HOST_WIDE_INT get_index_scale (const struct address_info *);
    2503                 :             : extern enum rtx_code get_index_code (const struct address_info *);
    2504                 :             : 
    2505                 :             : /* 1 if RTX is a subreg containing a reg that is already known to be
    2506                 :             :    sign- or zero-extended from the mode of the subreg to the mode of
    2507                 :             :    the reg.  SUBREG_PROMOTED_UNSIGNED_P gives the signedness of the
    2508                 :             :    extension.
    2509                 :             : 
    2510                 :             :    When used as a LHS, is means that this extension must be done
    2511                 :             :    when assigning to SUBREG_REG.  */
    2512                 :             : 
    2513                 :             : #define SUBREG_PROMOTED_VAR_P(RTX)                                      \
    2514                 :             :   (RTL_FLAG_CHECK1 ("SUBREG_PROMOTED", (RTX), SUBREG)->in_struct)
    2515                 :             : 
    2516                 :             : /* Valid for subregs which are SUBREG_PROMOTED_VAR_P().  In that case
    2517                 :             :    this gives the necessary extensions:
    2518                 :             :    0  - signed (SPR_SIGNED)
    2519                 :             :    1  - normal unsigned (SPR_UNSIGNED)
    2520                 :             :    2  - value is both sign and unsign extended for mode
    2521                 :             :         (SPR_SIGNED_AND_UNSIGNED).
    2522                 :             :    -1 - pointer unsigned, which most often can be handled like unsigned
    2523                 :             :         extension, except for generating instructions where we need to
    2524                 :             :         emit special code (ptr_extend insns) on some architectures
    2525                 :             :         (SPR_POINTER). */
    2526                 :             : 
    2527                 :             : const int SRP_POINTER = -1;
    2528                 :             : const int SRP_SIGNED = 0;
    2529                 :             : const int SRP_UNSIGNED = 1;
    2530                 :             : const int SRP_SIGNED_AND_UNSIGNED = 2;
    2531                 :             : 
    2532                 :             : /* Sets promoted mode for SUBREG_PROMOTED_VAR_P().  */
    2533                 :             : #define SUBREG_PROMOTED_SET(RTX, VAL)                                   \
    2534                 :             : do {                                                                    \
    2535                 :             :   rtx const _rtx = RTL_FLAG_CHECK1 ("SUBREG_PROMOTED_SET",            \
    2536                 :             :                                     (RTX), SUBREG);                     \
    2537                 :             :   switch (VAL)                                                          \
    2538                 :             :   {                                                                     \
    2539                 :             :     case SRP_POINTER:                                                   \
    2540                 :             :       _rtx->volatil = 0;                                             \
    2541                 :             :       _rtx->unchanging = 0;                                          \
    2542                 :             :       break;                                                            \
    2543                 :             :     case SRP_SIGNED:                                                    \
    2544                 :             :       _rtx->volatil = 0;                                             \
    2545                 :             :       _rtx->unchanging = 1;                                          \
    2546                 :             :       break;                                                            \
    2547                 :             :     case SRP_UNSIGNED:                                                  \
    2548                 :             :       _rtx->volatil = 1;                                             \
    2549                 :             :       _rtx->unchanging = 0;                                          \
    2550                 :             :       break;                                                            \
    2551                 :             :     case SRP_SIGNED_AND_UNSIGNED:                                       \
    2552                 :             :       _rtx->volatil = 1;                                             \
    2553                 :             :       _rtx->unchanging = 1;                                          \
    2554                 :             :       break;                                                            \
    2555                 :             :   }                                                                     \
    2556                 :             : } while (0)
    2557                 :             : 
    2558                 :             : /* Gets the value stored in promoted mode for SUBREG_PROMOTED_VAR_P(),
    2559                 :             :    including SRP_SIGNED_AND_UNSIGNED if promoted for
    2560                 :             :    both signed and unsigned.  */
    2561                 :             : #define SUBREG_PROMOTED_GET(RTX)        \
    2562                 :             :   (2 * (RTL_FLAG_CHECK1 ("SUBREG_PROMOTED_GET", (RTX), SUBREG)->volatil)\
    2563                 :             :    + (RTX)->unchanging - 1)
    2564                 :             : 
    2565                 :             : /* Returns sign of promoted mode for SUBREG_PROMOTED_VAR_P().  */
    2566                 :             : #define SUBREG_PROMOTED_SIGN(RTX)       \
    2567                 :             :   ((RTL_FLAG_CHECK1 ("SUBREG_PROMOTED_SIGN", (RTX), SUBREG)->volatil) ? 1\
    2568                 :             :    : (RTX)->unchanging - 1)
    2569                 :             : 
    2570                 :             : /* Predicate to check if RTX of SUBREG_PROMOTED_VAR_P() is promoted
    2571                 :             :    for SIGNED type.  */
    2572                 :             : #define SUBREG_PROMOTED_SIGNED_P(RTX)   \
    2573                 :             :   (RTL_FLAG_CHECK1 ("SUBREG_PROMOTED_SIGNED_P", (RTX), SUBREG)->unchanging)
    2574                 :             : 
    2575                 :             : /* Predicate to check if RTX of SUBREG_PROMOTED_VAR_P() is promoted
    2576                 :             :    for UNSIGNED type.  */
    2577                 :             : #define SUBREG_PROMOTED_UNSIGNED_P(RTX) \
    2578                 :             :   (RTL_FLAG_CHECK1 ("SUBREG_PROMOTED_UNSIGNED_P", (RTX), SUBREG)->volatil)
    2579                 :             : 
    2580                 :             : /* Checks if RTX of SUBREG_PROMOTED_VAR_P() is promoted for given SIGN.  */
    2581                 :             : #define SUBREG_CHECK_PROMOTED_SIGN(RTX, SIGN)   \
    2582                 :             : ((SIGN) == SRP_POINTER ? SUBREG_PROMOTED_GET (RTX) == SRP_POINTER       \
    2583                 :             :  : (SIGN) == SRP_SIGNED ? SUBREG_PROMOTED_SIGNED_P (RTX)                \
    2584                 :             :  : SUBREG_PROMOTED_UNSIGNED_P (RTX))
    2585                 :             : 
    2586                 :             : /* True if the REG is the static chain register for some CALL_INSN.  */
    2587                 :             : #define STATIC_CHAIN_REG_P(RTX) \
    2588                 :             :   (RTL_FLAG_CHECK1 ("STATIC_CHAIN_REG_P", (RTX), REG)->jump)
    2589                 :             : 
    2590                 :             : /* True if the subreg was generated by LRA for reload insns.  Such
    2591                 :             :    subregs are valid only during LRA.  */
    2592                 :             : #define LRA_SUBREG_P(RTX)       \
    2593                 :             :   (RTL_FLAG_CHECK1 ("LRA_SUBREG_P", (RTX), SUBREG)->jump)
    2594                 :             : 
    2595                 :             : /* Access various components of an ASM_OPERANDS rtx.  */
    2596                 :             : 
    2597                 :             : #define ASM_OPERANDS_TEMPLATE(RTX) XCSTR (RTX, 0, ASM_OPERANDS)
    2598                 :             : #define ASM_OPERANDS_OUTPUT_CONSTRAINT(RTX) XCSTR (RTX, 1, ASM_OPERANDS)
    2599                 :             : #define ASM_OPERANDS_OUTPUT_IDX(RTX) XCINT (RTX, 2, ASM_OPERANDS)
    2600                 :             : #define ASM_OPERANDS_INPUT_VEC(RTX) XCVEC (RTX, 3, ASM_OPERANDS)
    2601                 :             : #define ASM_OPERANDS_INPUT_CONSTRAINT_VEC(RTX) XCVEC (RTX, 4, ASM_OPERANDS)
    2602                 :             : #define ASM_OPERANDS_INPUT(RTX, N) XCVECEXP (RTX, 3, N, ASM_OPERANDS)
    2603                 :             : #define ASM_OPERANDS_INPUT_LENGTH(RTX) XCVECLEN (RTX, 3, ASM_OPERANDS)
    2604                 :             : #define ASM_OPERANDS_INPUT_CONSTRAINT_EXP(RTX, N) \
    2605                 :             :   XCVECEXP (RTX, 4, N, ASM_OPERANDS)
    2606                 :             : #define ASM_OPERANDS_INPUT_CONSTRAINT(RTX, N) \
    2607                 :             :   XSTR (XCVECEXP (RTX, 4, N, ASM_OPERANDS), 0)
    2608                 :             : #define ASM_OPERANDS_INPUT_MODE(RTX, N)  \
    2609                 :             :   GET_MODE (XCVECEXP (RTX, 4, N, ASM_OPERANDS))
    2610                 :             : #define ASM_OPERANDS_LABEL_VEC(RTX) XCVEC (RTX, 5, ASM_OPERANDS)
    2611                 :             : #define ASM_OPERANDS_LABEL_LENGTH(RTX) XCVECLEN (RTX, 5, ASM_OPERANDS)
    2612                 :             : #define ASM_OPERANDS_LABEL(RTX, N) XCVECEXP (RTX, 5, N, ASM_OPERANDS)
    2613                 :             : #define ASM_OPERANDS_SOURCE_LOCATION(RTX) XCUINT (RTX, 6, ASM_OPERANDS)
    2614                 :             : #define ASM_INPUT_SOURCE_LOCATION(RTX) XCUINT (RTX, 1, ASM_INPUT)
    2615                 :             : 
    2616                 :             : /* 1 if RTX is a mem that is statically allocated in read-only memory.  */
    2617                 :             : #define MEM_READONLY_P(RTX) \
    2618                 :             :   (RTL_FLAG_CHECK1 ("MEM_READONLY_P", (RTX), MEM)->unchanging)
    2619                 :             : 
    2620                 :             : /* 1 if RTX is a mem and we should keep the alias set for this mem
    2621                 :             :    unchanged when we access a component.  Set to 1, or example, when we
    2622                 :             :    are already in a non-addressable component of an aggregate.  */
    2623                 :             : #define MEM_KEEP_ALIAS_SET_P(RTX)                                       \
    2624                 :             :   (RTL_FLAG_CHECK1 ("MEM_KEEP_ALIAS_SET_P", (RTX), MEM)->jump)
    2625                 :             : 
    2626                 :             : /* 1 if RTX is a mem or asm_operand for a volatile reference.  */
    2627                 :             : #define MEM_VOLATILE_P(RTX)                                             \
    2628                 :             :   (RTL_FLAG_CHECK3 ("MEM_VOLATILE_P", (RTX), MEM, ASM_OPERANDS,               \
    2629                 :             :                     ASM_INPUT)->volatil)
    2630                 :             : 
    2631                 :             : /* 1 if RTX is a mem that cannot trap.  */
    2632                 :             : #define MEM_NOTRAP_P(RTX) \
    2633                 :             :   (RTL_FLAG_CHECK1 ("MEM_NOTRAP_P", (RTX), MEM)->call)
    2634                 :             : 
    2635                 :             : /* The memory attribute block.  We provide access macros for each value
    2636                 :             :    in the block and provide defaults if none specified.  */
    2637                 :             : #define MEM_ATTRS(RTX) X0MEMATTR (RTX, 1)
    2638                 :             : 
    2639                 :             : /* The register attribute block.  We provide access macros for each value
    2640                 :             :    in the block and provide defaults if none specified.  */
    2641                 :             : #define REG_ATTRS(RTX) (REG_CHECK (RTX)->attrs)
    2642                 :             : 
    2643                 :             : #ifndef GENERATOR_FILE
    2644                 :             : /* For a MEM rtx, the alias set.  If 0, this MEM is not in any alias
    2645                 :             :    set, and may alias anything.  Otherwise, the MEM can only alias
    2646                 :             :    MEMs in a conflicting alias set.  This value is set in a
    2647                 :             :    language-dependent manner in the front-end, and should not be
    2648                 :             :    altered in the back-end.  These set numbers are tested with
    2649                 :             :    alias_sets_conflict_p.  */
    2650                 :             : #define MEM_ALIAS_SET(RTX) (get_mem_attrs (RTX)->alias)
    2651                 :             : 
    2652                 :             : /* For a MEM rtx, the decl it is known to refer to, if it is known to
    2653                 :             :    refer to part of a DECL.  It may also be a COMPONENT_REF.  */
    2654                 :             : #define MEM_EXPR(RTX) (get_mem_attrs (RTX)->expr)
    2655                 :             : 
    2656                 :             : /* For a MEM rtx, true if its MEM_OFFSET is known.  */
    2657                 :             : #define MEM_OFFSET_KNOWN_P(RTX) (get_mem_attrs (RTX)->offset_known_p)
    2658                 :             : 
    2659                 :             : /* For a MEM rtx, the offset from the start of MEM_EXPR.  */
    2660                 :             : #define MEM_OFFSET(RTX) (get_mem_attrs (RTX)->offset)
    2661                 :             : 
    2662                 :             : /* For a MEM rtx, the address space.  */
    2663                 :             : #define MEM_ADDR_SPACE(RTX) (get_mem_attrs (RTX)->addrspace)
    2664                 :             : 
    2665                 :             : /* For a MEM rtx, true if its MEM_SIZE is known.  */
    2666                 :             : #define MEM_SIZE_KNOWN_P(RTX) (get_mem_attrs (RTX)->size_known_p)
    2667                 :             : 
    2668                 :             : /* For a MEM rtx, the size in bytes of the MEM.  */
    2669                 :             : #define MEM_SIZE(RTX) (get_mem_attrs (RTX)->size)
    2670                 :             : 
    2671                 :             : /* For a MEM rtx, the alignment in bits.  We can use the alignment of the
    2672                 :             :    mode as a default when STRICT_ALIGNMENT, but not if not.  */
    2673                 :             : #define MEM_ALIGN(RTX) (get_mem_attrs (RTX)->align)
    2674                 :             : #else
    2675                 :             : #define MEM_ADDR_SPACE(RTX) ADDR_SPACE_GENERIC
    2676                 :             : #endif
    2677                 :             : 
    2678                 :             : /* For a REG rtx, the decl it is known to refer to, if it is known to
    2679                 :             :    refer to part of a DECL.  */
    2680                 :             : #define REG_EXPR(RTX) (REG_ATTRS (RTX) == 0 ? 0 : REG_ATTRS (RTX)->decl)
    2681                 :             : 
    2682                 :             : /* For a REG rtx, the offset from the start of REG_EXPR, if known, as an
    2683                 :             :    HOST_WIDE_INT.  */
    2684                 :             : #define REG_OFFSET(RTX) (REG_ATTRS (RTX) == 0 ? 0 : REG_ATTRS (RTX)->offset)
    2685                 :             : 
    2686                 :             : /* Copy the attributes that apply to memory locations from RHS to LHS.  */
    2687                 :             : #define MEM_COPY_ATTRIBUTES(LHS, RHS)                           \
    2688                 :             :   (MEM_VOLATILE_P (LHS) = MEM_VOLATILE_P (RHS),                 \
    2689                 :             :    MEM_NOTRAP_P (LHS) = MEM_NOTRAP_P (RHS),                     \
    2690                 :             :    MEM_READONLY_P (LHS) = MEM_READONLY_P (RHS),                 \
    2691                 :             :    MEM_KEEP_ALIAS_SET_P (LHS) = MEM_KEEP_ALIAS_SET_P (RHS),     \
    2692                 :             :    MEM_POINTER (LHS) = MEM_POINTER (RHS),                       \
    2693                 :             :    MEM_ATTRS (LHS) = MEM_ATTRS (RHS))
    2694                 :             : 
    2695                 :             : /* 1 if RTX is a label_ref for a nonlocal label.  */
    2696                 :             : /* Likewise in an expr_list for a REG_LABEL_OPERAND or
    2697                 :             :    REG_LABEL_TARGET note.  */
    2698                 :             : #define LABEL_REF_NONLOCAL_P(RTX)                                       \
    2699                 :             :   (RTL_FLAG_CHECK1 ("LABEL_REF_NONLOCAL_P", (RTX), LABEL_REF)->volatil)
    2700                 :             : 
    2701                 :             : /* 1 if RTX is a code_label that should always be considered to be needed.  */
    2702                 :             : #define LABEL_PRESERVE_P(RTX)                                           \
    2703                 :             :   (RTL_FLAG_CHECK2 ("LABEL_PRESERVE_P", (RTX), CODE_LABEL, NOTE)->in_struct)
    2704                 :             : 
    2705                 :             : /* During sched, 1 if RTX is an insn that must be scheduled together
    2706                 :             :    with the preceding insn.  */
    2707                 :             : #define SCHED_GROUP_P(RTX)                                              \
    2708                 :             :   (RTL_FLAG_CHECK4 ("SCHED_GROUP_P", (RTX), DEBUG_INSN, INSN,         \
    2709                 :             :                     JUMP_INSN, CALL_INSN)->in_struct)
    2710                 :             : 
    2711                 :             : /* For a SET rtx, SET_DEST is the place that is set
    2712                 :             :    and SET_SRC is the value it is set to.  */
    2713                 :             : #define SET_DEST(RTX) XC2EXP (RTX, 0, SET, CLOBBER)
    2714                 :             : #define SET_SRC(RTX) XCEXP (RTX, 1, SET)
    2715                 :             : #define SET_IS_RETURN_P(RTX)                                            \
    2716                 :             :   (RTL_FLAG_CHECK1 ("SET_IS_RETURN_P", (RTX), SET)->jump)
    2717                 :             : 
    2718                 :             : /* For a TRAP_IF rtx, TRAP_CONDITION is an expression.  */
    2719                 :             : #define TRAP_CONDITION(RTX) XCEXP (RTX, 0, TRAP_IF)
    2720                 :             : #define TRAP_CODE(RTX) XCEXP (RTX, 1, TRAP_IF)
    2721                 :             : 
    2722                 :             : /* For a COND_EXEC rtx, COND_EXEC_TEST is the condition to base
    2723                 :             :    conditionally executing the code on, COND_EXEC_CODE is the code
    2724                 :             :    to execute if the condition is true.  */
    2725                 :             : #define COND_EXEC_TEST(RTX) XCEXP (RTX, 0, COND_EXEC)
    2726                 :             : #define COND_EXEC_CODE(RTX) XCEXP (RTX, 1, COND_EXEC)
    2727                 :             : 
    2728                 :             : /* 1 if RTX is a symbol_ref that addresses this function's rtl
    2729                 :             :    constants pool.  */
    2730                 :             : #define CONSTANT_POOL_ADDRESS_P(RTX)                                    \
    2731                 :             :   (RTL_FLAG_CHECK1 ("CONSTANT_POOL_ADDRESS_P", (RTX), SYMBOL_REF)->unchanging)
    2732                 :             : 
    2733                 :             : /* 1 if RTX is a symbol_ref that addresses a value in the file's
    2734                 :             :    tree constant pool.  This information is private to varasm.cc.  */
    2735                 :             : #define TREE_CONSTANT_POOL_ADDRESS_P(RTX)                               \
    2736                 :             :   (RTL_FLAG_CHECK1 ("TREE_CONSTANT_POOL_ADDRESS_P",                   \
    2737                 :             :                     (RTX), SYMBOL_REF)->frame_related)
    2738                 :             : 
    2739                 :             : /* Used if RTX is a symbol_ref, for machine-specific purposes.  */
    2740                 :             : #define SYMBOL_REF_FLAG(RTX)                                            \
    2741                 :             :   (RTL_FLAG_CHECK1 ("SYMBOL_REF_FLAG", (RTX), SYMBOL_REF)->volatil)
    2742                 :             : 
    2743                 :             : /* 1 if RTX is a symbol_ref that has been the library function in
    2744                 :             :    emit_library_call.  */
    2745                 :             : #define SYMBOL_REF_USED(RTX)                                            \
    2746                 :             :   (RTL_FLAG_CHECK1 ("SYMBOL_REF_USED", (RTX), SYMBOL_REF)->used)
    2747                 :             : 
    2748                 :             : /* 1 if RTX is a symbol_ref for a weak symbol.  */
    2749                 :             : #define SYMBOL_REF_WEAK(RTX)                                            \
    2750                 :             :   (RTL_FLAG_CHECK1 ("SYMBOL_REF_WEAK", (RTX), SYMBOL_REF)->return_val)
    2751                 :             : 
    2752                 :             : /* A pointer attached to the SYMBOL_REF; either SYMBOL_REF_DECL or
    2753                 :             :    SYMBOL_REF_CONSTANT.  */
    2754                 :             : #define SYMBOL_REF_DATA(RTX) X0ANY ((RTX), 1)
    2755                 :             : 
    2756                 :             : /* Set RTX's SYMBOL_REF_DECL to DECL.  RTX must not be a constant
    2757                 :             :    pool symbol.  */
    2758                 :             : #define SET_SYMBOL_REF_DECL(RTX, DECL) \
    2759                 :             :   (gcc_assert (!CONSTANT_POOL_ADDRESS_P (RTX)), X0TREE ((RTX), 1) = (DECL))
    2760                 :             : 
    2761                 :             : /* The tree (decl or constant) associated with the symbol, or null.  */
    2762                 :             : #define SYMBOL_REF_DECL(RTX) \
    2763                 :             :   (CONSTANT_POOL_ADDRESS_P (RTX) ? NULL : X0TREE ((RTX), 1))
    2764                 :             : 
    2765                 :             : /* Set RTX's SYMBOL_REF_CONSTANT to C.  RTX must be a constant pool symbol.  */
    2766                 :             : #define SET_SYMBOL_REF_CONSTANT(RTX, C) \
    2767                 :             :   (gcc_assert (CONSTANT_POOL_ADDRESS_P (RTX)), X0CONSTANT ((RTX), 1) = (C))
    2768                 :             : 
    2769                 :             : /* The rtx constant pool entry for a symbol, or null.  */
    2770                 :             : #define SYMBOL_REF_CONSTANT(RTX) \
    2771                 :             :   (CONSTANT_POOL_ADDRESS_P (RTX) ? X0CONSTANT ((RTX), 1) : NULL)
    2772                 :             : 
    2773                 :             : /* A set of flags on a symbol_ref that are, in some respects, redundant with
    2774                 :             :    information derivable from the tree decl associated with this symbol.
    2775                 :             :    Except that we build a *lot* of SYMBOL_REFs that aren't associated with a
    2776                 :             :    decl.  In some cases this is a bug.  But beyond that, it's nice to cache
    2777                 :             :    this information to avoid recomputing it.  Finally, this allows space for
    2778                 :             :    the target to store more than one bit of information, as with
    2779                 :             :    SYMBOL_REF_FLAG.  */
    2780                 :             : #define SYMBOL_REF_FLAGS(RTX) \
    2781                 :             :   (RTL_FLAG_CHECK1 ("SYMBOL_REF_FLAGS", (RTX), SYMBOL_REF) \
    2782                 :             :    ->u2.symbol_ref_flags)
    2783                 :             : 
    2784                 :             : /* These flags are common enough to be defined for all targets.  They
    2785                 :             :    are computed by the default version of targetm.encode_section_info.  */
    2786                 :             : 
    2787                 :             : /* Set if this symbol is a function.  */
    2788                 :             : #define SYMBOL_FLAG_FUNCTION    (1 << 0)
    2789                 :             : #define SYMBOL_REF_FUNCTION_P(RTX) \
    2790                 :             :   ((SYMBOL_REF_FLAGS (RTX) & SYMBOL_FLAG_FUNCTION) != 0)
    2791                 :             : /* Set if targetm.binds_local_p is true.  */
    2792                 :             : #define SYMBOL_FLAG_LOCAL       (1 << 1)
    2793                 :             : #define SYMBOL_REF_LOCAL_P(RTX) \
    2794                 :             :   ((SYMBOL_REF_FLAGS (RTX) & SYMBOL_FLAG_LOCAL) != 0)
    2795                 :             : /* Set if targetm.in_small_data_p is true.  */
    2796                 :             : #define SYMBOL_FLAG_SMALL       (1 << 2)
    2797                 :             : #define SYMBOL_REF_SMALL_P(RTX) \
    2798                 :             :   ((SYMBOL_REF_FLAGS (RTX) & SYMBOL_FLAG_SMALL) != 0)
    2799                 :             : /* The three-bit field at [5:3] is true for TLS variables; use
    2800                 :             :    SYMBOL_REF_TLS_MODEL to extract the field as an enum tls_model.  */
    2801                 :             : #define SYMBOL_FLAG_TLS_SHIFT   3
    2802                 :             : #define SYMBOL_REF_TLS_MODEL(RTX) \
    2803                 :             :   ((enum tls_model) ((SYMBOL_REF_FLAGS (RTX) >> SYMBOL_FLAG_TLS_SHIFT) & 7))
    2804                 :             : /* Set if this symbol is not defined in this translation unit.  */
    2805                 :             : #define SYMBOL_FLAG_EXTERNAL    (1 << 6)
    2806                 :             : #define SYMBOL_REF_EXTERNAL_P(RTX) \
    2807                 :             :   ((SYMBOL_REF_FLAGS (RTX) & SYMBOL_FLAG_EXTERNAL) != 0)
    2808                 :             : /* Set if this symbol has a block_symbol structure associated with it.  */
    2809                 :             : #define SYMBOL_FLAG_HAS_BLOCK_INFO (1 << 7)
    2810                 :             : #define SYMBOL_REF_HAS_BLOCK_INFO_P(RTX) \
    2811                 :             :   ((SYMBOL_REF_FLAGS (RTX) & SYMBOL_FLAG_HAS_BLOCK_INFO) != 0)
    2812                 :             : /* Set if this symbol is a section anchor.  SYMBOL_REF_ANCHOR_P implies
    2813                 :             :    SYMBOL_REF_HAS_BLOCK_INFO_P.  */
    2814                 :             : #define SYMBOL_FLAG_ANCHOR      (1 << 8)
    2815                 :             : #define SYMBOL_REF_ANCHOR_P(RTX) \
    2816                 :             :   ((SYMBOL_REF_FLAGS (RTX) & SYMBOL_FLAG_ANCHOR) != 0)
    2817                 :             : 
    2818                 :             : /* Subsequent bits are available for the target to use.  */
    2819                 :             : #define SYMBOL_FLAG_MACH_DEP_SHIFT      9
    2820                 :             : #define SYMBOL_FLAG_MACH_DEP            (1 << SYMBOL_FLAG_MACH_DEP_SHIFT)
    2821                 :             : 
    2822                 :             : /* If SYMBOL_REF_HAS_BLOCK_INFO_P (RTX), this is the object_block
    2823                 :             :    structure to which the symbol belongs, or NULL if it has not been
    2824                 :             :    assigned a block.  */
    2825                 :             : #define SYMBOL_REF_BLOCK(RTX) (BLOCK_SYMBOL_CHECK (RTX)->block)
    2826                 :             : 
    2827                 :             : /* If SYMBOL_REF_HAS_BLOCK_INFO_P (RTX), this is the offset of RTX from
    2828                 :             :    the first object in SYMBOL_REF_BLOCK (RTX).  The value is negative if
    2829                 :             :    RTX has not yet been assigned to a block, or it has not been given an
    2830                 :             :    offset within that block.  */
    2831                 :             : #define SYMBOL_REF_BLOCK_OFFSET(RTX) (BLOCK_SYMBOL_CHECK (RTX)->offset)
    2832                 :             : 
    2833                 :             : /* True if RTX is flagged to be a scheduling barrier.  */
    2834                 :             : #define PREFETCH_SCHEDULE_BARRIER_P(RTX)                                        \
    2835                 :             :   (RTL_FLAG_CHECK1 ("PREFETCH_SCHEDULE_BARRIER_P", (RTX), PREFETCH)->volatil)
    2836                 :             : 
    2837                 :             : /* Indicate whether the machine has any sort of auto increment addressing.
    2838                 :             :    If not, we can avoid checking for REG_INC notes.  */
    2839                 :             : 
    2840                 :             : #if (defined (HAVE_PRE_INCREMENT) || defined (HAVE_PRE_DECREMENT) \
    2841                 :             :      || defined (HAVE_POST_INCREMENT) || defined (HAVE_POST_DECREMENT) \
    2842                 :             :      || defined (HAVE_PRE_MODIFY_DISP) || defined (HAVE_POST_MODIFY_DISP) \
    2843                 :             :      || defined (HAVE_PRE_MODIFY_REG) || defined (HAVE_POST_MODIFY_REG))
    2844                 :             : #define AUTO_INC_DEC 1
    2845                 :             : #else
    2846                 :             : #define AUTO_INC_DEC 0
    2847                 :             : #endif
    2848                 :             : 
    2849                 :             : /* Define a macro to look for REG_INC notes,
    2850                 :             :    but save time on machines where they never exist.  */
    2851                 :             : 
    2852                 :             : #if AUTO_INC_DEC
    2853                 :             : #define FIND_REG_INC_NOTE(INSN, REG)                    \
    2854                 :             :   ((REG) != NULL_RTX && REG_P ((REG))                   \
    2855                 :             :    ? find_regno_note ((INSN), REG_INC, REGNO (REG))     \
    2856                 :             :    : find_reg_note ((INSN), REG_INC, (REG)))
    2857                 :             : #else
    2858                 :             : #define FIND_REG_INC_NOTE(INSN, REG) 0
    2859                 :             : #endif
    2860                 :             : 
    2861                 :             : #ifndef HAVE_PRE_INCREMENT
    2862                 :             : #define HAVE_PRE_INCREMENT 0
    2863                 :             : #endif
    2864                 :             : 
    2865                 :             : #ifndef HAVE_PRE_DECREMENT
    2866                 :             : #define HAVE_PRE_DECREMENT 0
    2867                 :             : #endif
    2868                 :             : 
    2869                 :             : #ifndef HAVE_POST_INCREMENT
    2870                 :             : #define HAVE_POST_INCREMENT 0
    2871                 :             : #endif
    2872                 :             : 
    2873                 :             : #ifndef HAVE_POST_DECREMENT
    2874                 :             : #define HAVE_POST_DECREMENT 0
    2875                 :             : #endif
    2876                 :             : 
    2877                 :             : #ifndef HAVE_POST_MODIFY_DISP
    2878                 :             : #define HAVE_POST_MODIFY_DISP 0
    2879                 :             : #endif
    2880                 :             : 
    2881                 :             : #ifndef HAVE_POST_MODIFY_REG
    2882                 :             : #define HAVE_POST_MODIFY_REG 0
    2883                 :             : #endif
    2884                 :             : 
    2885                 :             : #ifndef HAVE_PRE_MODIFY_DISP
    2886                 :             : #define HAVE_PRE_MODIFY_DISP 0
    2887                 :             : #endif
    2888                 :             : 
    2889                 :             : #ifndef HAVE_PRE_MODIFY_REG
    2890                 :             : #define HAVE_PRE_MODIFY_REG 0
    2891                 :             : #endif
    2892                 :             : 
    2893                 :             : 
    2894                 :             : /* Some architectures do not have complete pre/post increment/decrement
    2895                 :             :    instruction sets, or only move some modes efficiently.  These macros
    2896                 :             :    allow us to tune autoincrement generation.  */
    2897                 :             : 
    2898                 :             : #ifndef USE_LOAD_POST_INCREMENT
    2899                 :             : #define USE_LOAD_POST_INCREMENT(MODE)   HAVE_POST_INCREMENT
    2900                 :             : #endif
    2901                 :             : 
    2902                 :             : #ifndef USE_LOAD_POST_DECREMENT
    2903                 :             : #define USE_LOAD_POST_DECREMENT(MODE)   HAVE_POST_DECREMENT
    2904                 :             : #endif
    2905                 :             : 
    2906                 :             : #ifndef USE_LOAD_PRE_INCREMENT
    2907                 :             : #define USE_LOAD_PRE_INCREMENT(MODE)    HAVE_PRE_INCREMENT
    2908                 :             : #endif
    2909                 :             : 
    2910                 :             : #ifndef USE_LOAD_PRE_DECREMENT
    2911                 :             : #define USE_LOAD_PRE_DECREMENT(MODE)    HAVE_PRE_DECREMENT
    2912                 :             : #endif
    2913                 :             : 
    2914                 :             : #ifndef USE_STORE_POST_INCREMENT
    2915                 :             : #define USE_STORE_POST_INCREMENT(MODE)  HAVE_POST_INCREMENT
    2916                 :             : #endif
    2917                 :             : 
    2918                 :             : #ifndef USE_STORE_POST_DECREMENT
    2919                 :             : #define USE_STORE_POST_DECREMENT(MODE)  HAVE_POST_DECREMENT
    2920                 :             : #endif
    2921                 :             : 
    2922                 :             : #ifndef USE_STORE_PRE_INCREMENT
    2923                 :             : #define USE_STORE_PRE_INCREMENT(MODE)   HAVE_PRE_INCREMENT
    2924                 :             : #endif
    2925                 :             : 
    2926                 :             : #ifndef USE_STORE_PRE_DECREMENT
    2927                 :             : #define USE_STORE_PRE_DECREMENT(MODE)   HAVE_PRE_DECREMENT
    2928                 :             : #endif
    2929                 :             : 
    2930                 :             : /* Nonzero when we are generating CONCATs.  */
    2931                 :             : extern int generating_concat_p;
    2932                 :             : 
    2933                 :             : /* Nonzero when we are expanding trees to RTL.  */
    2934                 :             : extern int currently_expanding_to_rtl;
    2935                 :             : 
    2936                 :             : /* Generally useful functions.  */
    2937                 :             : 
    2938                 :             : #ifndef GENERATOR_FILE
    2939                 :             : /* Return the cost of SET X.  SPEED_P is true if optimizing for speed
    2940                 :             :    rather than size.  */
    2941                 :             : 
    2942                 :             : inline int
    2943                 :    43028589 : set_rtx_cost (rtx x, bool speed_p)
    2944                 :             : {
    2945                 :    42617859 :   return rtx_cost (x, VOIDmode, INSN, 4, speed_p);
    2946                 :             : }
    2947                 :             : 
    2948                 :             : /* Like set_rtx_cost, but return both the speed and size costs in C.  */
    2949                 :             : 
    2950                 :             : inline void
    2951                 :     2138598 : get_full_set_rtx_cost (rtx x, struct full_rtx_costs *c)
    2952                 :             : {
    2953                 :     2015410 :   get_full_rtx_cost (x, VOIDmode, INSN, 4, c);
    2954                 :             : }
    2955                 :             : 
    2956                 :             : /* Return the cost of moving X into a register, relative to the cost
    2957                 :             :    of a register move.  SPEED_P is true if optimizing for speed rather
    2958                 :             :    than size.  */
    2959                 :             : 
    2960                 :             : inline int
    2961                 :  2708239789 : set_src_cost (rtx x, machine_mode mode, bool speed_p)
    2962                 :             : {
    2963                 :  2707920806 :   return rtx_cost (x, mode, SET, 1, speed_p);
    2964                 :             : }
    2965                 :             : 
    2966                 :             : /* Like set_src_cost, but return both the speed and size costs in C.  */
    2967                 :             : 
    2968                 :             : inline void
    2969                 :         377 : get_full_set_src_cost (rtx x, machine_mode mode, struct full_rtx_costs *c)
    2970                 :             : {
    2971                 :         377 :   get_full_rtx_cost (x, mode, SET, 1, c);
    2972                 :             : }
    2973                 :             : #endif
    2974                 :             : 
    2975                 :             : /* A convenience macro to validate the arguments of a zero_extract
    2976                 :             :    expression.  It determines whether SIZE lies inclusively within
    2977                 :             :    [1, RANGE], POS lies inclusively within between [0, RANGE - 1]
    2978                 :             :    and the sum lies inclusively within [1, RANGE].  RANGE must be
    2979                 :             :    >= 1, but SIZE and POS may be negative.  */
    2980                 :             : #define EXTRACT_ARGS_IN_RANGE(SIZE, POS, RANGE) \
    2981                 :             :   (IN_RANGE ((POS), 0, (unsigned HOST_WIDE_INT) (RANGE) - 1) \
    2982                 :             :    && IN_RANGE ((SIZE), 1, (unsigned HOST_WIDE_INT) (RANGE) \
    2983                 :             :                            - (unsigned HOST_WIDE_INT)(POS)))
    2984                 :             : 
    2985                 :             : /* In explow.cc */
    2986                 :             : extern HOST_WIDE_INT trunc_int_for_mode (HOST_WIDE_INT, machine_mode);
    2987                 :             : extern poly_int64 trunc_int_for_mode (poly_int64, machine_mode);
    2988                 :             : extern rtx plus_constant (machine_mode, rtx, poly_int64, bool = false);
    2989                 :             : extern HOST_WIDE_INT get_stack_check_protect (void);
    2990                 :             : 
    2991                 :             : /* In rtl.cc */
    2992                 :             : extern rtx rtx_alloc (RTX_CODE CXX_MEM_STAT_INFO);
    2993                 :             : inline rtx
    2994                 :  2458811071 : rtx_init (rtx rt, RTX_CODE code)
    2995                 :             : {
    2996                 :  2458811071 :   memset (rt, 0, RTX_HDR_SIZE);
    2997                 :  2458811071 :   PUT_CODE (rt, code);
    2998                 :  2457097717 :   return rt;
    2999                 :             : }
    3000                 :             : #define rtx_alloca(code) \
    3001                 :             :   rtx_init ((rtx) alloca (RTX_CODE_SIZE ((code))), (code))
    3002                 :             : extern rtx rtx_alloc_stat_v (RTX_CODE MEM_STAT_DECL, int);
    3003                 :             : #define rtx_alloc_v(c, SZ) rtx_alloc_stat_v (c MEM_STAT_INFO, SZ)
    3004                 :             : #define const_wide_int_alloc(NWORDS)                            \
    3005                 :             :   rtx_alloc_v (CONST_WIDE_INT,                                  \
    3006                 :             :                (sizeof (struct hwivec_def)                      \
    3007                 :             :                 + ((NWORDS)-1) * sizeof (HOST_WIDE_INT)))       \
    3008                 :             : 
    3009                 :             : extern rtvec rtvec_alloc (size_t);
    3010                 :             : extern rtvec shallow_copy_rtvec (rtvec);
    3011                 :             : extern bool shared_const_p (const_rtx);
    3012                 :             : extern rtx copy_rtx (rtx);
    3013                 :             : extern enum rtx_code classify_insn (rtx);
    3014                 :             : extern void dump_rtx_statistics (void);
    3015                 :             : 
    3016                 :             : /* In emit-rtl.cc */
    3017                 :             : extern rtx copy_rtx_if_shared (rtx);
    3018                 :             : 
    3019                 :             : /* In rtl.cc */
    3020                 :             : extern unsigned int rtx_size (const_rtx);
    3021                 :             : extern rtx shallow_copy_rtx (const_rtx CXX_MEM_STAT_INFO);
    3022                 :             : 
    3023                 :             : typedef bool (*rtx_equal_p_callback_function) (const_rtx *, const_rtx *,
    3024                 :             :                                                rtx *, rtx *);
    3025                 :             : extern bool rtx_equal_p (const_rtx, const_rtx,
    3026                 :             :                          rtx_equal_p_callback_function = NULL);
    3027                 :             : 
    3028                 :             : extern bool rtvec_all_equal_p (const_rtvec);
    3029                 :             : extern bool rtvec_series_p (rtvec, int);
    3030                 :             : 
    3031                 :             : /* Return true if X is a vector constant with a duplicated element value.  */
    3032                 :             : 
    3033                 :             : inline bool
    3034                 :   270906507 : const_vec_duplicate_p (const_rtx x)
    3035                 :             : {
    3036                 :   270906507 :   return (GET_CODE (x) == CONST_VECTOR
    3037                 :      549775 :           && CONST_VECTOR_NPATTERNS (x) == 1
    3038                 :      525952 :           && CONST_VECTOR_DUPLICATE_P (x));
    3039                 :             : }
    3040                 :             : 
    3041                 :             : /* Return true if X is a vector constant with a duplicated element value.
    3042                 :             :    Store the duplicated element in *ELT if so.  */
    3043                 :             : 
    3044                 :             : template <typename T>
    3045                 :             : inline bool
    3046                 :   269964983 : const_vec_duplicate_p (T x, T *elt)
    3047                 :             : {
    3048                 :   270606422 :   if (const_vec_duplicate_p (x))
    3049                 :             :     {
    3050                 :      498238 :       *elt = CONST_VECTOR_ENCODED_ELT (x, 0);
    3051                 :      498238 :       return true;
    3052                 :             :     }
    3053                 :             :   return false;
    3054                 :             : }
    3055                 :             : 
    3056                 :             : /* Return true if X is a vector with a duplicated element value, either
    3057                 :             :    constant or nonconstant.  Store the duplicated element in *ELT if so.  */
    3058                 :             : 
    3059                 :             : template <typename T>
    3060                 :             : inline bool
    3061                 :    94332791 : vec_duplicate_p (T x, T *elt)
    3062                 :             : {
    3063                 :    94332791 :   if (GET_CODE (x) == VEC_DUPLICATE
    3064                 :      143215 :       && !VECTOR_MODE_P (GET_MODE (XEXP (x, 0))))
    3065                 :             :     {
    3066                 :      143201 :       *elt = XEXP (x, 0);
    3067                 :      143201 :       return true;
    3068                 :             :     }
    3069                 :    94332791 :   return const_vec_duplicate_p (x, elt);
    3070                 :             : }
    3071                 :             : 
    3072                 :             : /* If X is a vector constant with a duplicated element value, return that
    3073                 :             :    element value, otherwise return X.  */
    3074                 :             : 
    3075                 :             : template <typename T>
    3076                 :             : inline T
    3077                 :      941368 : unwrap_const_vec_duplicate (T x)
    3078                 :             : {
    3079                 :      945984 :   if (const_vec_duplicate_p (x))
    3080                 :        4616 :     x = CONST_VECTOR_ELT (x, 0);
    3081                 :      941368 :   return x;
    3082                 :             : }
    3083                 :             : 
    3084                 :             : /* In emit-rtl.cc.  */
    3085                 :             : extern wide_int const_vector_int_elt (const_rtx, unsigned int);
    3086                 :             : extern rtx const_vector_elt (const_rtx, unsigned int);
    3087                 :             : extern bool const_vec_series_p_1 (const_rtx, rtx *, rtx *);
    3088                 :             : 
    3089                 :             : /* Return true if X is an integer constant vector that contains a linear
    3090                 :             :    series of the form:
    3091                 :             : 
    3092                 :             :    { B, B + S, B + 2 * S, B + 3 * S, ... }
    3093                 :             : 
    3094                 :             :    for a nonzero S.  Store B and S in *BASE_OUT and *STEP_OUT on sucess.  */
    3095                 :             : 
    3096                 :             : inline bool
    3097                 :     3452204 : const_vec_series_p (const_rtx x, rtx *base_out, rtx *step_out)
    3098                 :             : {
    3099                 :     3452204 :   if (GET_CODE (x) == CONST_VECTOR
    3100                 :        2970 :       && CONST_VECTOR_NPATTERNS (x) == 1
    3101                 :     3454729 :       && !CONST_VECTOR_DUPLICATE_P (x))
    3102                 :        2525 :     return const_vec_series_p_1 (x, base_out, step_out);
    3103                 :             :   return false;
    3104                 :             : }
    3105                 :             : 
    3106                 :             : /* Return true if X is a vector that contains a linear series of the
    3107                 :             :    form:
    3108                 :             : 
    3109                 :             :    { B, B + S, B + 2 * S, B + 3 * S, ... }
    3110                 :             : 
    3111                 :             :    where B and S are constant or nonconstant.  Store B and S in
    3112                 :             :    *BASE_OUT and *STEP_OUT on sucess.  */
    3113                 :             : 
    3114                 :             : inline bool
    3115                 :     3452684 : vec_series_p (const_rtx x, rtx *base_out, rtx *step_out)
    3116                 :             : {
    3117                 :     3452684 :   if (GET_CODE (x) == VEC_SERIES)
    3118                 :             :     {
    3119                 :         480 :       *base_out = XEXP (x, 0);
    3120                 :         480 :       *step_out = XEXP (x, 1);
    3121                 :         480 :       return true;
    3122                 :             :     }
    3123                 :     3452204 :   return const_vec_series_p (x, base_out, step_out);
    3124                 :             : }
    3125                 :             : 
    3126                 :             : /* Return true if CONST_VECTORs X and Y, which are known to have the same mode,
    3127                 :             :    also have the same encoding.  This means that they are equal whenever their
    3128                 :             :    operands are equal.  */
    3129                 :             : 
    3130                 :             : inline bool
    3131                 :     7456556 : same_vector_encodings_p (const_rtx x, const_rtx y)
    3132                 :             : {
    3133                 :             :   /* Don't be fussy about the encoding of constant-length vectors,
    3134                 :             :      since XVECEXP (X, 0) and XVECEXP (Y, 0) list all the elements anyway.  */
    3135                 :     7456556 :   if (poly_uint64 (CONST_VECTOR_NUNITS (x)).is_constant ())
    3136                 :     7456556 :     return true;
    3137                 :             : 
    3138                 :             :   return (CONST_VECTOR_NPATTERNS (x) == CONST_VECTOR_NPATTERNS (y)
    3139                 :             :           && (CONST_VECTOR_NELTS_PER_PATTERN (x)
    3140                 :             :               == CONST_VECTOR_NELTS_PER_PATTERN (y)));
    3141                 :             : }
    3142                 :             : 
    3143                 :             : /* Return the unpromoted (outer) mode of SUBREG_PROMOTED_VAR_P subreg X.  */
    3144                 :             : 
    3145                 :             : inline scalar_int_mode
    3146                 :           7 : subreg_unpromoted_mode (rtx x)
    3147                 :             : {
    3148                 :           7 :   gcc_checking_assert (SUBREG_PROMOTED_VAR_P (x));
    3149                 :           7 :   return as_a <scalar_int_mode> (GET_MODE (x));
    3150                 :             : }
    3151                 :             : 
    3152                 :             : /* Return the promoted (inner) mode of SUBREG_PROMOTED_VAR_P subreg X.  */
    3153                 :             : 
    3154                 :             : inline scalar_int_mode
    3155                 :          10 : subreg_promoted_mode (rtx x)
    3156                 :             : {
    3157                 :          10 :   gcc_checking_assert (SUBREG_PROMOTED_VAR_P (x));
    3158                 :          10 :   return as_a <scalar_int_mode> (GET_MODE (SUBREG_REG (x)));
    3159                 :             : }
    3160                 :             : 
    3161                 :             : /* In emit-rtl.cc */
    3162                 :             : extern rtvec gen_rtvec_v (int, rtx *);
    3163                 :             : extern rtvec gen_rtvec_v (int, rtx_insn **);
    3164                 :             : extern rtx gen_reg_rtx (machine_mode);
    3165                 :             : extern rtx gen_rtx_REG_offset (rtx, machine_mode, unsigned int, poly_int64);
    3166                 :             : extern rtx gen_reg_rtx_offset (rtx, machine_mode, int);
    3167                 :             : extern rtx gen_reg_rtx_and_attrs (rtx);
    3168                 :             : extern rtx_code_label *gen_label_rtx (void);
    3169                 :             : extern rtx gen_lowpart_common (machine_mode, rtx);
    3170                 :             : 
    3171                 :             : /* In cse.cc */
    3172                 :             : extern rtx gen_lowpart_if_possible (machine_mode, rtx);
    3173                 :             : 
    3174                 :             : /* In emit-rtl.cc */
    3175                 :             : extern rtx gen_highpart (machine_mode, rtx);
    3176                 :             : extern rtx gen_highpart_mode (machine_mode, machine_mode, rtx);
    3177                 :             : extern rtx operand_subword (rtx, poly_uint64, int, machine_mode);
    3178                 :             : 
    3179                 :             : /* In emit-rtl.cc */
    3180                 :             : extern rtx operand_subword_force (rtx, poly_uint64, machine_mode);
    3181                 :             : extern bool subreg_lowpart_p (const_rtx);
    3182                 :             : extern poly_uint64 subreg_size_lowpart_offset (poly_uint64, poly_uint64);
    3183                 :             : 
    3184                 :             : /* Return true if a subreg of mode OUTERMODE would only access part of
    3185                 :             :    an inner register with mode INNERMODE.  The other bits of the inner
    3186                 :             :    register would then be "don't care" on read.  The behavior for writes
    3187                 :             :    depends on REGMODE_NATURAL_SIZE; bits in the same REGMODE_NATURAL_SIZE-d
    3188                 :             :    chunk would be clobbered but other bits would be preserved.  */
    3189                 :             : 
    3190                 :             : inline bool
    3191                 :   787651777 : partial_subreg_p (machine_mode outermode, machine_mode innermode)
    3192                 :             : {
    3193                 :             :   /* Modes involved in a subreg must be ordered.  In particular, we must
    3194                 :             :      always know at compile time whether the subreg is paradoxical.  */
    3195                 :   768583686 :   poly_int64 outer_prec = GET_MODE_PRECISION (outermode);
    3196                 :   787651777 :   poly_int64 inner_prec = GET_MODE_PRECISION (innermode);
    3197                 :   787651777 :   gcc_checking_assert (ordered_p (outer_prec, inner_prec));
    3198                 :   784518791 :   return maybe_lt (outer_prec, inner_prec);
    3199                 :             : }
    3200                 :             : 
    3201                 :             : /* Likewise return true if X is a subreg that is smaller than the inner
    3202                 :             :    register.  Use read_modify_subreg_p to test whether writing to such
    3203                 :             :    a subreg preserves any part of the inner register.  */
    3204                 :             : 
    3205                 :             : inline bool
    3206                 :    45395442 : partial_subreg_p (const_rtx x)
    3207                 :             : {
    3208                 :    45395442 :   if (GET_CODE (x) != SUBREG)
    3209                 :             :     return false;
    3210                 :     8617620 :   return partial_subreg_p (GET_MODE (x), GET_MODE (SUBREG_REG (x)));
    3211                 :             : }
    3212                 :             : 
    3213                 :             : /* Return true if a subreg with the given outer and inner modes is
    3214                 :             :    paradoxical.  */
    3215                 :             : 
    3216                 :             : inline bool
    3217                 :   253045544 : paradoxical_subreg_p (machine_mode outermode, machine_mode innermode)
    3218                 :             : {
    3219                 :             :   /* Modes involved in a subreg must be ordered.  In particular, we must
    3220                 :             :      always know at compile time whether the subreg is paradoxical.  */
    3221                 :   231069876 :   poly_int64 outer_prec = GET_MODE_PRECISION (outermode);
    3222                 :   253045544 :   poly_int64 inner_prec = GET_MODE_PRECISION (innermode);
    3223                 :   253045544 :   gcc_checking_assert (ordered_p (outer_prec, inner_prec));
    3224                 :   250117912 :   return maybe_gt (outer_prec, inner_prec);
    3225                 :             : }
    3226                 :             : 
    3227                 :             : /* Return true if X is a paradoxical subreg, false otherwise.  */
    3228                 :             : 
    3229                 :             : inline bool
    3230                 :   377412530 : paradoxical_subreg_p (const_rtx x)
    3231                 :             : {
    3232                 :   377412530 :   if (GET_CODE (x) != SUBREG)
    3233                 :             :     return false;
    3234                 :    36524855 :   return paradoxical_subreg_p (GET_MODE (x), GET_MODE (SUBREG_REG (x)));
    3235                 :             : }
    3236                 :             : 
    3237                 :             : /* Return the SUBREG_BYTE for an OUTERMODE lowpart of an INNERMODE value.  */
    3238                 :             : 
    3239                 :             : inline poly_uint64
    3240                 :   201142269 : subreg_lowpart_offset (machine_mode outermode, machine_mode innermode)
    3241                 :             : {
    3242                 :   603426807 :   return subreg_size_lowpart_offset (GET_MODE_SIZE (outermode),
    3243                 :   201142269 :                                      GET_MODE_SIZE (innermode));
    3244                 :             : }
    3245                 :             : 
    3246                 :             : /* Given that a subreg has outer mode OUTERMODE and inner mode INNERMODE,
    3247                 :             :    return the smaller of the two modes if they are different sizes,
    3248                 :             :    otherwise return the outer mode.  */
    3249                 :             : 
    3250                 :             : inline machine_mode
    3251                 :    12347495 : narrower_subreg_mode (machine_mode outermode, machine_mode innermode)
    3252                 :             : {
    3253                 :    12347495 :   return paradoxical_subreg_p (outermode, innermode) ? innermode : outermode;
    3254                 :             : }
    3255                 :             : 
    3256                 :             : /* Given that a subreg has outer mode OUTERMODE and inner mode INNERMODE,
    3257                 :             :    return the mode that is big enough to hold both the outer and inner
    3258                 :             :    values.  Prefer the outer mode in the event of a tie.  */
    3259                 :             : 
    3260                 :             : inline machine_mode
    3261                 :    66579491 : wider_subreg_mode (machine_mode outermode, machine_mode innermode)
    3262                 :             : {
    3263                 :    62572502 :   return partial_subreg_p (outermode, innermode) ? innermode : outermode;
    3264                 :             : }
    3265                 :             : 
    3266                 :             : /* Likewise for subreg X.  */
    3267                 :             : 
    3268                 :             : inline machine_mode
    3269                 :     8858954 : wider_subreg_mode (const_rtx x)
    3270                 :             : {
    3271                 :    11118783 :   return wider_subreg_mode (GET_MODE (x), GET_MODE (SUBREG_REG (x)));
    3272                 :             : }
    3273                 :             : 
    3274                 :             : extern poly_uint64 subreg_size_highpart_offset (poly_uint64, poly_uint64);
    3275                 :             : 
    3276                 :             : /* Return the SUBREG_BYTE for an OUTERMODE highpart of an INNERMODE value.  */
    3277                 :             : 
    3278                 :             : inline poly_uint64
    3279                 :       50833 : subreg_highpart_offset (machine_mode outermode, machine_mode innermode)
    3280                 :             : {
    3281                 :      152499 :   return subreg_size_highpart_offset (GET_MODE_SIZE (outermode),
    3282                 :       50833 :                                       GET_MODE_SIZE (innermode));
    3283                 :             : }
    3284                 :             : 
    3285                 :             : extern poly_int64 byte_lowpart_offset (machine_mode, machine_mode);
    3286                 :             : extern poly_int64 subreg_memory_offset (machine_mode, machine_mode,
    3287                 :             :                                         poly_uint64);
    3288                 :             : extern poly_int64 subreg_memory_offset (const_rtx);
    3289                 :             : extern rtx make_safe_from (rtx, rtx);
    3290                 :             : extern rtx convert_memory_address_addr_space_1 (scalar_int_mode, rtx,
    3291                 :             :                                                 addr_space_t, bool, bool);
    3292                 :             : extern rtx convert_memory_address_addr_space (scalar_int_mode, rtx,
    3293                 :             :                                               addr_space_t);
    3294                 :             : #define convert_memory_address(to_mode,x) \
    3295                 :             :         convert_memory_address_addr_space ((to_mode), (x), ADDR_SPACE_GENERIC)
    3296                 :             : extern const char *get_insn_name (int);
    3297                 :             : extern rtx_insn *get_last_insn_anywhere (void);
    3298                 :             : extern rtx_insn *get_first_nonnote_insn (void);
    3299                 :             : extern rtx_insn *get_last_nonnote_insn (void);
    3300                 :             : extern void start_sequence (void);
    3301                 :             : extern void push_to_sequence (rtx_insn *);
    3302                 :             : extern void push_to_sequence2 (rtx_insn *, rtx_insn *);
    3303                 :             : extern void end_sequence (void);
    3304                 :             : #if TARGET_SUPPORTS_WIDE_INT == 0
    3305                 :             : extern double_int rtx_to_double_int (const_rtx);
    3306                 :             : #endif
    3307                 :             : extern void cwi_output_hex (FILE *, const_rtx);
    3308                 :             : #if TARGET_SUPPORTS_WIDE_INT == 0
    3309                 :             : extern rtx immed_double_const (HOST_WIDE_INT, HOST_WIDE_INT,
    3310                 :             :                                machine_mode);
    3311                 :             : #endif
    3312                 :             : extern rtx immed_wide_int_const (const poly_wide_int_ref &, machine_mode);
    3313                 :             : 
    3314                 :             : /* In varasm.cc  */
    3315                 :             : extern rtx force_const_mem (machine_mode, rtx);
    3316                 :             : 
    3317                 :             : /* In varasm.cc  */
    3318                 :             : 
    3319                 :             : struct function;
    3320                 :             : extern rtx get_pool_constant (const_rtx);
    3321                 :             : extern rtx get_pool_constant_mark (rtx, bool *);
    3322                 :             : extern fixed_size_mode get_pool_mode (const_rtx);
    3323                 :             : extern rtx simplify_subtraction (rtx);
    3324                 :             : extern void decide_function_section (tree);
    3325                 :             : 
    3326                 :             : /* In emit-rtl.cc */
    3327                 :             : extern rtx_insn *emit_insn_before (rtx, rtx_insn *);
    3328                 :             : extern rtx_insn *emit_insn_before_noloc (rtx, rtx_insn *, basic_block);
    3329                 :             : extern rtx_insn *emit_insn_before_setloc (rtx, rtx_insn *, location_t);
    3330                 :             : extern rtx_jump_insn *emit_jump_insn_before (rtx, rtx_insn *);
    3331                 :             : extern rtx_jump_insn *emit_jump_insn_before_noloc (rtx, rtx_insn *);
    3332                 :             : extern rtx_jump_insn *emit_jump_insn_before_setloc (rtx, rtx_insn *,
    3333                 :             :                                                     location_t);
    3334                 :             : extern rtx_insn *emit_call_insn_before (rtx, rtx_insn *);
    3335                 :             : extern rtx_insn *emit_call_insn_before_noloc (rtx, rtx_insn *);
    3336                 :             : extern rtx_insn *emit_call_insn_before_setloc (rtx, rtx_insn *, location_t);
    3337                 :             : extern rtx_insn *emit_debug_insn_before (rtx, rtx_insn *);
    3338                 :             : extern rtx_insn *emit_debug_insn_before_noloc (rtx, rtx_insn *);
    3339                 :             : extern rtx_insn *emit_debug_insn_before_setloc (rtx, rtx_insn *, location_t);
    3340                 :             : extern rtx_barrier *emit_barrier_before (rtx_insn *);
    3341                 :             : extern rtx_code_label *emit_label_before (rtx_code_label *, rtx_insn *);
    3342                 :             : extern rtx_note *emit_note_before (enum insn_note, rtx_insn *);
    3343                 :             : extern rtx_insn *emit_insn_after (rtx, rtx_insn *);
    3344                 :             : extern rtx_insn *emit_insn_after_noloc (rtx, rtx_insn *, basic_block);
    3345                 :             : extern rtx_insn *emit_insn_after_setloc (rtx, rtx_insn *, location_t);
    3346                 :             : extern rtx_jump_insn *emit_jump_insn_after (rtx, rtx_insn *);
    3347                 :             : extern rtx_jump_insn *emit_jump_insn_after_noloc (rtx, rtx_insn *);
    3348                 :             : extern rtx_jump_insn *emit_jump_insn_after_setloc (rtx, rtx_insn *, location_t);
    3349                 :             : extern rtx_insn *emit_call_insn_after (rtx, rtx_insn *);
    3350                 :             : extern rtx_insn *emit_call_insn_after_noloc (rtx, rtx_insn *);
    3351                 :             : extern rtx_insn *emit_call_insn_after_setloc (rtx, rtx_insn *, location_t);
    3352                 :             : extern rtx_insn *emit_debug_insn_after (rtx, rtx_insn *);
    3353                 :             : extern rtx_insn *emit_debug_insn_after_noloc (rtx, rtx_insn *);
    3354                 :             : extern rtx_insn *emit_debug_insn_after_setloc (rtx, rtx_insn *, location_t);
    3355                 :             : extern rtx_barrier *emit_barrier_after (rtx_insn *);
    3356                 :             : extern rtx_insn *emit_label_after (rtx_insn *, rtx_insn *);
    3357                 :             : extern rtx_note *emit_note_after (enum insn_note, rtx_insn *);
    3358                 :             : extern rtx_insn *emit_insn (rtx);
    3359                 :             : extern rtx_insn *emit_debug_insn (rtx);
    3360                 :             : extern rtx_insn *emit_jump_insn (rtx);
    3361                 :             : extern rtx_insn *emit_likely_jump_insn (rtx);
    3362                 :             : extern rtx_insn *emit_unlikely_jump_insn (rtx);
    3363                 :             : extern rtx_insn *emit_call_insn (rtx);
    3364                 :             : extern rtx_code_label *emit_label (rtx);
    3365                 :             : extern rtx_jump_table_data *emit_jump_table_data (rtx);
    3366                 :             : extern rtx_barrier *emit_barrier (void);
    3367                 :             : extern rtx_note *emit_note (enum insn_note);
    3368                 :             : extern rtx_note *emit_note_copy (rtx_note *);
    3369                 :             : extern rtx_insn *gen_clobber (rtx);
    3370                 :             : extern rtx_insn *emit_clobber (rtx);
    3371                 :             : extern rtx_insn *gen_use (rtx);
    3372                 :             : extern rtx_insn *emit_use (rtx);
    3373                 :             : extern rtx_insn *make_insn_raw (rtx);
    3374                 :             : extern void add_function_usage_to (rtx, rtx);
    3375                 :             : extern rtx_call_insn *last_call_insn (void);
    3376                 :             : extern rtx_insn *previous_insn (rtx_insn *);
    3377                 :             : extern rtx_insn *next_insn (rtx_insn *);
    3378                 :             : extern rtx_insn *prev_nonnote_insn (rtx_insn *);
    3379                 :             : extern rtx_insn *next_nonnote_insn (rtx_insn *);
    3380                 :             : extern rtx_insn *prev_nondebug_insn (rtx_insn *);
    3381                 :             : extern rtx_insn *next_nondebug_insn (rtx_insn *);
    3382                 :             : extern rtx_insn *prev_nonnote_nondebug_insn (rtx_insn *);
    3383                 :             : extern rtx_insn *prev_nonnote_nondebug_insn_bb (rtx_insn *);
    3384                 :             : extern rtx_insn *next_nonnote_nondebug_insn (rtx_insn *);
    3385                 :             : extern rtx_insn *next_nonnote_nondebug_insn_bb (rtx_insn *);
    3386                 :             : extern rtx_insn *prev_real_insn (rtx_insn *);
    3387                 :             : extern rtx_insn *next_real_insn (rtx_insn *);
    3388                 :             : extern rtx_insn *prev_real_nondebug_insn (rtx_insn *);
    3389                 :             : extern rtx_insn *next_real_nondebug_insn (rtx);
    3390                 :             : extern rtx_insn *prev_active_insn (rtx_insn *);
    3391                 :             : extern rtx_insn *next_active_insn (rtx_insn *);
    3392                 :             : extern bool active_insn_p (const rtx_insn *);
    3393                 :             : 
    3394                 :             : /* In emit-rtl.cc  */
    3395                 :             : extern int insn_line (const rtx_insn *);
    3396                 :             : extern const char * insn_file (const rtx_insn *);
    3397                 :             : extern tree insn_scope (const rtx_insn *);
    3398                 :             : extern expanded_location insn_location (const rtx_insn *);
    3399                 :             : extern int insn_discriminator (const rtx_insn *);
    3400                 :             : extern location_t prologue_location, epilogue_location;
    3401                 :             : 
    3402                 :             : /* In jump.cc */
    3403                 :             : extern enum rtx_code reverse_condition (enum rtx_code);
    3404                 :             : extern enum rtx_code reverse_condition_maybe_unordered (enum rtx_code);
    3405                 :             : extern enum rtx_code swap_condition (enum rtx_code);
    3406                 :             : extern enum rtx_code unsigned_condition (enum rtx_code);
    3407                 :             : extern enum rtx_code signed_condition (enum rtx_code);
    3408                 :             : extern void mark_jump_label (rtx, rtx_insn *, int);
    3409                 :             : 
    3410                 :             : /* Return true if integer comparison operator CODE interprets its operands
    3411                 :             :    as unsigned.  */
    3412                 :             : 
    3413                 :             : inline bool
    3414                 :     4211491 : unsigned_condition_p (enum rtx_code code)
    3415                 :             : {
    3416                 :     4211491 :   return unsigned_condition (code) == code;
    3417                 :             : }
    3418                 :             : 
    3419                 :             : /* In jump.cc */
    3420                 :             : extern rtx_insn *delete_related_insns (rtx);
    3421                 :             : 
    3422                 :             : /* In recog.cc  */
    3423                 :             : extern rtx *find_constant_term_loc (rtx *);
    3424                 :             : 
    3425                 :             : /* In emit-rtl.cc  */
    3426                 :             : extern rtx_insn *try_split (rtx, rtx_insn *, int);
    3427                 :             : 
    3428                 :             : /* In insn-recog.cc (generated by genrecog).  */
    3429                 :             : extern rtx_insn *split_insns (rtx, rtx_insn *);
    3430                 :             : 
    3431                 :             : /* In simplify-rtx.cc  */
    3432                 :             : 
    3433                 :             : /* A class that records the context in which a simplification
    3434                 :             :    is being mode.  */
    3435                 :   432298357 : class simplify_context
    3436                 :             : {
    3437                 :             : public:
    3438                 :             :   rtx simplify_unary_operation (rtx_code, machine_mode, rtx, machine_mode);
    3439                 :             :   rtx simplify_binary_operation (rtx_code, machine_mode, rtx, rtx);
    3440                 :             :   rtx simplify_ternary_operation (rtx_code, machine_mode, machine_mode,
    3441                 :             :                                   rtx, rtx, rtx);
    3442                 :             :   rtx simplify_relational_operation (rtx_code, machine_mode, machine_mode,
    3443                 :             :                                      rtx, rtx);
    3444                 :             :   rtx simplify_subreg (machine_mode, rtx, machine_mode, poly_uint64);
    3445                 :             : 
    3446                 :             :   rtx lowpart_subreg (machine_mode, rtx, machine_mode);
    3447                 :             : 
    3448                 :             :   rtx simplify_merge_mask (rtx, rtx, int);
    3449                 :             : 
    3450                 :             :   rtx simplify_gen_unary (rtx_code, machine_mode, rtx, machine_mode);
    3451                 :             :   rtx simplify_gen_binary (rtx_code, machine_mode, rtx, rtx);
    3452                 :             :   rtx simplify_gen_ternary (rtx_code, machine_mode, machine_mode,
    3453                 :             :                             rtx, rtx, rtx);
    3454                 :             :   rtx simplify_gen_relational (rtx_code, machine_mode, machine_mode, rtx, rtx);
    3455                 :             :   rtx simplify_gen_subreg (machine_mode, rtx, machine_mode, poly_uint64);
    3456                 :             :   rtx simplify_gen_vec_select (rtx, unsigned int);
    3457                 :             : 
    3458                 :             :   /* Tracks the level of MEM nesting for the value being simplified:
    3459                 :             :      0 means the value is not in a MEM, >0 means it is.  This is needed
    3460                 :             :      because the canonical representation of multiplication is different
    3461                 :             :      inside a MEM than outside.  */
    3462                 :             :   unsigned int mem_depth = 0;
    3463                 :             : 
    3464                 :             :   /* Tracks number of simplify_associative_operation calls performed during
    3465                 :             :      outermost simplify* call.  */
    3466                 :             :   unsigned int assoc_count = 0;
    3467                 :             : 
    3468                 :             :   /* Limit for the above number, return NULL from
    3469                 :             :      simplify_associative_operation after we reach that assoc_count.  */
    3470                 :             :   static const unsigned int max_assoc_count = 64;
    3471                 :             : 
    3472                 :             : private:
    3473                 :             :   rtx simplify_truncation (machine_mode, rtx, machine_mode);
    3474                 :             :   rtx simplify_byte_swapping_operation (rtx_code, machine_mode, rtx, rtx);
    3475                 :             :   rtx simplify_associative_operation (rtx_code, machine_mode, rtx, rtx);
    3476                 :             :   rtx simplify_distributive_operation (rtx_code, machine_mode, rtx, rtx);
    3477                 :             :   rtx simplify_logical_relational_operation (rtx_code, machine_mode, rtx, rtx);
    3478                 :             :   rtx simplify_binary_operation_series (rtx_code, machine_mode, rtx, rtx);
    3479                 :             :   rtx simplify_distribute_over_subregs (rtx_code, machine_mode, rtx, rtx);
    3480                 :             :   rtx simplify_shift_const_int (rtx_code, machine_mode, rtx, unsigned int);
    3481                 :             :   rtx simplify_plus_minus (rtx_code, machine_mode, rtx, rtx);
    3482                 :             :   rtx simplify_cond_clz_ctz (rtx, rtx_code, rtx, rtx);
    3483                 :             : 
    3484                 :             :   rtx simplify_unary_operation_1 (rtx_code, machine_mode, rtx);
    3485                 :             :   rtx simplify_binary_operation_1 (rtx_code, machine_mode, rtx, rtx, rtx, rtx);
    3486                 :             :   rtx simplify_ternary_operation_1 (rtx_code, machine_mode, machine_mode,
    3487                 :             :                                     rtx, rtx, rtx);
    3488                 :             :   rtx simplify_relational_operation_1 (rtx_code, machine_mode, machine_mode,
    3489                 :             :                                        rtx, rtx);
    3490                 :             : };
    3491                 :             : 
    3492                 :             : inline rtx
    3493                 :    18343276 : simplify_unary_operation (rtx_code code, machine_mode mode, rtx op,
    3494                 :             :                           machine_mode op_mode)
    3495                 :             : {
    3496                 :    18342988 :   return simplify_context ().simplify_unary_operation (code, mode, op,
    3497                 :      739120 :                                                        op_mode);
    3498                 :             : }
    3499                 :             : 
    3500                 :             : inline rtx
    3501                 :   183015612 : simplify_binary_operation (rtx_code code, machine_mode mode, rtx op0, rtx op1)
    3502                 :             : {
    3503                 :   183014108 :   return simplify_context ().simplify_binary_operation (code, mode, op0, op1);
    3504                 :             : }
    3505                 :             : 
    3506                 :             : inline rtx
    3507                 :    30683264 : simplify_ternary_operation (rtx_code code, machine_mode mode,
    3508                 :             :                             machine_mode op0_mode, rtx op0, rtx op1, rtx op2)
    3509                 :             : {
    3510                 :    30683264 :   return simplify_context ().simplify_ternary_operation (code, mode, op0_mode,
    3511                 :       58212 :                                                          op0, op1, op2);
    3512                 :             : }
    3513                 :             : 
    3514                 :             : inline rtx
    3515                 :    55343507 : simplify_relational_operation (rtx_code code, machine_mode mode,
    3516                 :             :                                machine_mode op_mode, rtx op0, rtx op1)
    3517                 :             : {
    3518                 :    55343507 :   return simplify_context ().simplify_relational_operation (code, mode,
    3519                 :      176740 :                                                             op_mode, op0, op1);
    3520                 :             : }
    3521                 :             : 
    3522                 :             : inline rtx
    3523                 :    19831168 : simplify_subreg (machine_mode outermode, rtx op, machine_mode innermode,
    3524                 :             :                  poly_uint64 byte)
    3525                 :             : {
    3526                 :    19831168 :   return simplify_context ().simplify_subreg (outermode, op, innermode, byte);
    3527                 :             : }
    3528                 :             : 
    3529                 :             : inline rtx
    3530                 :      809343 : simplify_gen_unary (rtx_code code, machine_mode mode, rtx op,
    3531                 :             :                     machine_mode op_mode)
    3532                 :             : {
    3533                 :     1600993 :   return simplify_context ().simplify_gen_unary (code, mode, op, op_mode);
    3534                 :             : }
    3535                 :             : 
    3536                 :             : inline rtx
    3537                 :    33078230 : simplify_gen_binary (rtx_code code, machine_mode mode, rtx op0, rtx op1)
    3538                 :             : {
    3539                 :    77738862 :   return simplify_context ().simplify_gen_binary (code, mode, op0, op1);
    3540                 :             : }
    3541                 :             : 
    3542                 :             : inline rtx
    3543                 :     1941463 : simplify_gen_ternary (rtx_code code, machine_mode mode, machine_mode op0_mode,
    3544                 :             :                       rtx op0, rtx op1, rtx op2)
    3545                 :             : {
    3546                 :     1941463 :   return simplify_context ().simplify_gen_ternary (code, mode, op0_mode,
    3547                 :        2659 :                                                    op0, op1, op2);
    3548                 :             : }
    3549                 :             : 
    3550                 :             : inline rtx
    3551                 :     2663605 : simplify_gen_relational (rtx_code code, machine_mode mode,
    3552                 :             :                          machine_mode op_mode, rtx op0, rtx op1)
    3553                 :             : {
    3554                 :     4771380 :   return simplify_context ().simplify_gen_relational (code, mode, op_mode,
    3555                 :      534200 :                                                       op0, op1);
    3556                 :             : }
    3557                 :             : 
    3558                 :             : inline rtx
    3559                 :    10037571 : simplify_gen_subreg (machine_mode outermode, rtx op, machine_mode innermode,
    3560                 :             :                      poly_uint64 byte)
    3561                 :             : {
    3562                 :     9732508 :   return simplify_context ().simplify_gen_subreg (outermode, op,
    3563                 :      868873 :                                                   innermode, byte);
    3564                 :             : }
    3565                 :             : 
    3566                 :             : inline rtx
    3567                 :      476761 : simplify_gen_vec_select (rtx op, unsigned int index)
    3568                 :             : {
    3569                 :      476761 :   return simplify_context ().simplify_gen_vec_select (op, index);
    3570                 :             : }
    3571                 :             : 
    3572                 :             : inline rtx
    3573                 :    28883508 : lowpart_subreg (machine_mode outermode, rtx op, machine_mode innermode)
    3574                 :             : {
    3575                 :    29233098 :   return simplify_context ().lowpart_subreg (outermode, op, innermode);
    3576                 :             : }
    3577                 :             : 
    3578                 :             : extern rtx simplify_const_unary_operation (enum rtx_code, machine_mode,
    3579                 :             :                                            rtx, machine_mode);
    3580                 :             : extern rtx simplify_const_binary_operation (enum rtx_code, machine_mode,
    3581                 :             :                                             rtx, rtx);
    3582                 :             : extern rtx simplify_const_relational_operation (enum rtx_code,
    3583                 :             :                                                 machine_mode, rtx, rtx);
    3584                 :             : extern rtx simplify_replace_fn_rtx (rtx, const_rtx,
    3585                 :             :                                     rtx (*fn) (rtx, const_rtx, void *), void *);
    3586                 :             : extern rtx simplify_replace_rtx (rtx, const_rtx, rtx);
    3587                 :             : extern rtx simplify_rtx (const_rtx);
    3588                 :             : extern rtx avoid_constant_pool_reference (rtx);
    3589                 :             : extern rtx delegitimize_mem_from_attrs (rtx);
    3590                 :             : extern bool mode_signbit_p (machine_mode, const_rtx);
    3591                 :             : extern bool val_signbit_p (machine_mode, unsigned HOST_WIDE_INT);
    3592                 :             : extern bool val_signbit_known_set_p (machine_mode,
    3593                 :             :                                      unsigned HOST_WIDE_INT);
    3594                 :             : extern bool val_signbit_known_clear_p (machine_mode,
    3595                 :             :                                        unsigned HOST_WIDE_INT);
    3596                 :             : extern bool reverse_rotate_by_imm_p (machine_mode, unsigned int, rtx);
    3597                 :             : 
    3598                 :             : /* In reginfo.cc  */
    3599                 :             : extern machine_mode choose_hard_reg_mode (unsigned int, unsigned int,
    3600                 :             :                                           const predefined_function_abi *);
    3601                 :             : extern const HARD_REG_SET &simplifiable_subregs (const subreg_shape &);
    3602                 :             : 
    3603                 :             : /* In emit-rtl.cc  */
    3604                 :             : extern rtx set_for_reg_notes (rtx);
    3605                 :             : extern rtx set_unique_reg_note (rtx, enum reg_note, rtx);
    3606                 :             : extern rtx set_dst_reg_note (rtx, enum reg_note, rtx, rtx);
    3607                 :             : extern void set_insn_deleted (rtx_insn *);
    3608                 :             : 
    3609                 :             : /* Functions in rtlanal.cc */
    3610                 :             : 
    3611                 :             : extern rtx single_set_2 (const rtx_insn *, const_rtx);
    3612                 :             : extern rtx simple_regno_set (rtx, unsigned int);
    3613                 :             : extern bool contains_symbol_ref_p (const_rtx);
    3614                 :             : extern bool contains_symbolic_reference_p (const_rtx);
    3615                 :             : extern bool contains_constant_pool_address_p (const_rtx);
    3616                 :             : extern void add_auto_inc_notes (rtx_insn *, rtx);
    3617                 :             : 
    3618                 :             : /* Handle the cheap and common cases inline for performance.  */
    3619                 :             : 
    3620                 :  5932447859 : inline rtx single_set (const rtx_insn *insn)
    3621                 :             : {
    3622                 :  5932447859 :   if (!INSN_P (insn))
    3623                 :             :     return NULL_RTX;
    3624                 :             : 
    3625                 :  5797390936 :   if (GET_CODE (PATTERN (insn)) == SET)
    3626                 :             :     return PATTERN (insn);
    3627                 :             : 
    3628                 :             :   /* Defer to the more expensive case.  */
    3629                 :  1643717826 :   return single_set_2 (insn, PATTERN (insn));
    3630                 :             : }
    3631                 :             : 
    3632                 :             : extern scalar_int_mode get_address_mode (rtx mem);
    3633                 :             : extern bool rtx_addr_can_trap_p (const_rtx);
    3634                 :             : extern bool nonzero_address_p (const_rtx);
    3635                 :             : extern bool rtx_unstable_p (const_rtx);
    3636                 :             : extern bool rtx_varies_p (const_rtx, bool);
    3637                 :             : extern bool rtx_addr_varies_p (const_rtx, bool);
    3638                 :             : extern rtx get_call_rtx_from (const rtx_insn *);
    3639                 :             : extern tree get_call_fndecl (const rtx_insn *);
    3640                 :             : extern HOST_WIDE_INT get_integer_term (const_rtx);
    3641                 :             : extern rtx get_related_value (const_rtx);
    3642                 :             : extern bool offset_within_block_p (const_rtx, HOST_WIDE_INT);
    3643                 :             : extern void split_const (rtx, rtx *, rtx *);
    3644                 :             : extern rtx strip_offset (rtx, poly_int64 *);
    3645                 :             : extern poly_int64 get_args_size (const_rtx);
    3646                 :             : extern bool unsigned_reg_p (rtx);
    3647                 :             : extern bool reg_mentioned_p (const_rtx, const_rtx);
    3648                 :             : extern int count_occurrences (const_rtx, const_rtx, int);
    3649                 :             : extern bool reg_referenced_p (const_rtx, const_rtx);
    3650                 :             : extern bool reg_used_between_p (const_rtx, const rtx_insn *, const rtx_insn *);
    3651                 :             : extern bool reg_set_between_p (const_rtx, const rtx_insn *, const rtx_insn *);
    3652                 :             : extern int commutative_operand_precedence (rtx);
    3653                 :             : extern bool swap_commutative_operands_p (rtx, rtx);
    3654                 :             : extern bool modified_between_p (const_rtx, const rtx_insn *, const rtx_insn *);
    3655                 :             : extern bool no_labels_between_p (const rtx_insn *, const rtx_insn *);
    3656                 :             : extern bool modified_in_p (const_rtx, const_rtx);
    3657                 :             : extern bool reg_set_p (const_rtx, const_rtx);
    3658                 :             : extern bool multiple_sets (const_rtx);
    3659                 :             : extern bool set_noop_p (const_rtx);
    3660                 :             : extern bool noop_move_p (const rtx_insn *);
    3661                 :             : extern bool refers_to_regno_p (unsigned int, unsigned int, const_rtx, rtx *);
    3662                 :             : extern bool reg_overlap_mentioned_p (const_rtx, const_rtx);
    3663                 :             : extern const_rtx set_of (const_rtx, const_rtx);
    3664                 :             : extern void record_hard_reg_sets (rtx, const_rtx, void *);
    3665                 :             : extern void record_hard_reg_uses (rtx *, void *);
    3666                 :             : extern void find_all_hard_regs (const_rtx, HARD_REG_SET *);
    3667                 :             : extern void find_all_hard_reg_sets (const rtx_insn *, HARD_REG_SET *, bool);
    3668                 :             : extern void note_pattern_stores (const_rtx,
    3669                 :             :                                  void (*) (rtx, const_rtx, void *), void *);
    3670                 :             : extern void note_stores (const rtx_insn *,
    3671                 :             :                          void (*) (rtx, const_rtx, void *), void *);
    3672                 :             : extern void note_uses (rtx *, void (*) (rtx *, void *), void *);
    3673                 :             : extern bool dead_or_set_p (const rtx_insn *, const_rtx);
    3674                 :             : extern bool dead_or_set_regno_p (const rtx_insn *, unsigned int);
    3675                 :             : extern rtx find_reg_note (const_rtx, enum reg_note, const_rtx);
    3676                 :             : extern rtx find_regno_note (const_rtx, enum reg_note, unsigned int);
    3677                 :             : extern rtx find_reg_equal_equiv_note (const_rtx);
    3678                 :             : extern rtx find_constant_src (const rtx_insn *);
    3679                 :             : extern bool find_reg_fusage (const_rtx, enum rtx_code, const_rtx);
    3680                 :             : extern bool find_regno_fusage (const_rtx, enum rtx_code, unsigned int);
    3681                 :             : extern rtx alloc_reg_note (enum reg_note, rtx, rtx);
    3682                 :             : extern void add_reg_note (rtx, enum reg_note, rtx);
    3683                 :             : extern void add_int_reg_note (rtx_insn *, enum reg_note, int);
    3684                 :             : extern void add_args_size_note (rtx_insn *, poly_int64);
    3685                 :             : extern void add_shallow_copy_of_reg_note (rtx_insn *, rtx);
    3686                 :             : extern rtx duplicate_reg_note (rtx);
    3687                 :             : extern void remove_note (rtx_insn *, const_rtx);
    3688                 :             : extern bool remove_reg_equal_equiv_notes (rtx_insn *, bool = false);
    3689                 :             : extern void remove_reg_equal_equiv_notes_for_regno (unsigned int);
    3690                 :             : extern bool side_effects_p (const_rtx);
    3691                 :             : extern bool volatile_refs_p (const_rtx);
    3692                 :             : extern bool volatile_insn_p (const_rtx);
    3693                 :             : extern bool may_trap_p_1 (const_rtx, unsigned);
    3694                 :             : extern bool may_trap_p (const_rtx);
    3695                 :             : extern bool may_trap_or_fault_p (const_rtx);
    3696                 :             : extern bool can_throw_internal (const_rtx);
    3697                 :             : extern bool can_throw_external (const_rtx);
    3698                 :             : extern bool insn_could_throw_p (const_rtx);
    3699                 :             : extern bool insn_nothrow_p (const_rtx);
    3700                 :             : extern bool can_nonlocal_goto (const rtx_insn *);
    3701                 :             : extern void copy_reg_eh_region_note_forward (rtx, rtx_insn *, rtx);
    3702                 :             : extern void copy_reg_eh_region_note_backward (rtx, rtx_insn *, rtx);
    3703                 :             : extern rtx replace_rtx (rtx, rtx, rtx, bool = false);
    3704                 :             : extern void replace_label (rtx *, rtx, rtx, bool);
    3705                 :             : extern void replace_label_in_insn (rtx_insn *, rtx_insn *, rtx_insn *, bool);
    3706                 :             : extern bool rtx_referenced_p (const_rtx, const_rtx);
    3707                 :             : extern bool tablejump_p (const rtx_insn *, rtx_insn **, rtx_jump_table_data **);
    3708                 :             : extern rtx tablejump_casesi_pattern (const rtx_insn *insn);
    3709                 :             : extern bool computed_jump_p (const rtx_insn *);
    3710                 :             : extern bool tls_referenced_p (const_rtx);
    3711                 :             : extern bool contains_mem_rtx_p (rtx x);
    3712                 :             : extern bool register_asm_p (const_rtx);
    3713                 :             : 
    3714                 :             : /* Overload for refers_to_regno_p for checking a single register.  */
    3715                 :             : inline bool
    3716                 :   134794347 : refers_to_regno_p (unsigned int regnum, const_rtx x, rtx* loc = NULL)
    3717                 :             : {
    3718                 :   134794347 :   return refers_to_regno_p (regnum, regnum + 1, x, loc);
    3719                 :             : }
    3720                 :             : 
    3721                 :             : /* Callback for for_each_inc_dec, to process the autoinc operation OP
    3722                 :             :    within MEM that sets DEST to SRC + SRCOFF, or SRC if SRCOFF is
    3723                 :             :    NULL.  The callback is passed the same opaque ARG passed to
    3724                 :             :    for_each_inc_dec.  Return zero to continue looking for other
    3725                 :             :    autoinc operations or any other value to interrupt the traversal and
    3726                 :             :    return that value to the caller of for_each_inc_dec.  */
    3727                 :             : typedef int (*for_each_inc_dec_fn) (rtx mem, rtx op, rtx dest, rtx src,
    3728                 :             :                                     rtx srcoff, void *arg);
    3729                 :             : extern int for_each_inc_dec (rtx, for_each_inc_dec_fn, void *arg);
    3730                 :             : 
    3731                 :             : extern rtx regno_use_in (unsigned int, rtx);
    3732                 :             : extern bool auto_inc_p (const_rtx);
    3733                 :             : extern bool in_insn_list_p (const rtx_insn_list *, const rtx_insn *);
    3734                 :             : extern void remove_node_from_insn_list (const rtx_insn *, rtx_insn_list **);
    3735                 :             : extern bool loc_mentioned_in_p (rtx *, const_rtx);
    3736                 :             : extern rtx_insn *find_first_parameter_load (rtx_insn *, rtx_insn *);
    3737                 :             : extern bool keep_with_call_p (const rtx_insn *);
    3738                 :             : extern bool label_is_jump_target_p (const_rtx, const rtx_insn *);
    3739                 :             : extern int pattern_cost (rtx, bool);
    3740                 :             : extern int insn_cost (rtx_insn *, bool);
    3741                 :             : extern unsigned seq_cost (const rtx_insn *, bool);
    3742                 :             : 
    3743                 :             : /* Given an insn and condition, return a canonical description of
    3744                 :             :    the test being made.  */
    3745                 :             : extern rtx canonicalize_condition (rtx_insn *, rtx, int, rtx_insn **, rtx,
    3746                 :             :                                    int, int);
    3747                 :             : 
    3748                 :             : /* Given a JUMP_INSN, return a canonical description of the test
    3749                 :             :    being made.  */
    3750                 :             : extern rtx get_condition (rtx_insn *, rtx_insn **, int, int);
    3751                 :             : 
    3752                 :             : /* Information about a subreg of a hard register.  */
    3753                 :             : struct subreg_info
    3754                 :             : {
    3755                 :             :   /* Offset of first hard register involved in the subreg.  */
    3756                 :             :   int offset;
    3757                 :             :   /* Number of hard registers involved in the subreg.  In the case of
    3758                 :             :      a paradoxical subreg, this is the number of registers that would
    3759                 :             :      be modified by writing to the subreg; some of them may be don't-care
    3760                 :             :      when reading from the subreg.  */
    3761                 :             :   int nregs;
    3762                 :             :   /* Whether this subreg can be represented as a hard reg with the new
    3763                 :             :      mode (by adding OFFSET to the original hard register).  */
    3764                 :             :   bool representable_p;
    3765                 :             : };
    3766                 :             : 
    3767                 :             : extern void subreg_get_info (unsigned int, machine_mode,
    3768                 :             :                              poly_uint64, machine_mode,
    3769                 :             :                              struct subreg_info *);
    3770                 :             : 
    3771                 :             : /* lists.cc */
    3772                 :             : 
    3773                 :             : extern void free_EXPR_LIST_list (rtx_expr_list **);
    3774                 :             : extern void free_INSN_LIST_list (rtx_insn_list **);
    3775                 :             : extern void free_EXPR_LIST_node (rtx);
    3776                 :             : extern void free_INSN_LIST_node (rtx);
    3777                 :             : extern rtx_insn_list *alloc_INSN_LIST (rtx, rtx);
    3778                 :             : extern rtx_insn_list *copy_INSN_LIST (rtx_insn_list *);
    3779                 :             : extern rtx_insn_list *concat_INSN_LIST (rtx_insn_list *, rtx_insn_list *);
    3780                 :             : extern rtx_expr_list *alloc_EXPR_LIST (int, rtx, rtx);
    3781                 :             : extern void remove_free_INSN_LIST_elem (rtx_insn *, rtx_insn_list **);
    3782                 :             : extern rtx remove_list_elem (rtx, rtx *);
    3783                 :             : extern rtx_insn *remove_free_INSN_LIST_node (rtx_insn_list **);
    3784                 :             : extern rtx remove_free_EXPR_LIST_node (rtx_expr_list **);
    3785                 :             : 
    3786                 :             : 
    3787                 :             : /* reginfo.cc */
    3788                 :             : 
    3789                 :             : /* Resize reg info.  */
    3790                 :             : extern bool resize_reg_info (void);
    3791                 :             : /* Free up register info memory.  */
    3792                 :             : extern void free_reg_info (void);
    3793                 :             : extern void init_subregs_of_mode (void);
    3794                 :             : extern void finish_subregs_of_mode (void);
    3795                 :             : extern void reginfo_cc_finalize (void);
    3796                 :             : 
    3797                 :             : /* recog.cc */
    3798                 :             : extern rtx extract_asm_operands (rtx);
    3799                 :             : extern int asm_noperands (const_rtx);
    3800                 :             : extern const char *decode_asm_operands (rtx, rtx *, rtx **, const char **,
    3801                 :             :                                         machine_mode *, location_t *);
    3802                 :             : extern void get_referenced_operands (const char *, bool *, unsigned int);
    3803                 :             : 
    3804                 :             : extern enum reg_class reg_preferred_class (int);
    3805                 :             : extern enum reg_class reg_alternate_class (int);
    3806                 :             : extern enum reg_class reg_allocno_class (int);
    3807                 :             : extern void setup_reg_classes (int, enum reg_class, enum reg_class,
    3808                 :             :                                enum reg_class);
    3809                 :             : 
    3810                 :             : extern void split_all_insns (void);
    3811                 :             : extern void split_all_insns_noflow (void);
    3812                 :             : 
    3813                 :             : #define MAX_SAVED_CONST_INT 64
    3814                 :             : extern GTY(()) rtx const_int_rtx[MAX_SAVED_CONST_INT * 2 + 1];
    3815                 :             : 
    3816                 :             : #define const0_rtx      (const_int_rtx[MAX_SAVED_CONST_INT])
    3817                 :             : #define const1_rtx      (const_int_rtx[MAX_SAVED_CONST_INT+1])
    3818                 :             : #define const2_rtx      (const_int_rtx[MAX_SAVED_CONST_INT+2])
    3819                 :             : #define constm1_rtx     (const_int_rtx[MAX_SAVED_CONST_INT-1])
    3820                 :             : extern GTY(()) rtx const_true_rtx;
    3821                 :             : 
    3822                 :             : extern GTY(()) rtx const_tiny_rtx[4][(int) MAX_MACHINE_MODE];
    3823                 :             : 
    3824                 :             : /* Returns a constant 0 rtx in mode MODE.  Integer modes are treated the
    3825                 :             :    same as VOIDmode.  */
    3826                 :             : 
    3827                 :             : #define CONST0_RTX(MODE) (const_tiny_rtx[0][(int) (MODE)])
    3828                 :             : 
    3829                 :             : /* Likewise, for the constants 1 and 2 and -1.  */
    3830                 :             : 
    3831                 :             : #define CONST1_RTX(MODE) (const_tiny_rtx[1][(int) (MODE)])
    3832                 :             : #define CONST2_RTX(MODE) (const_tiny_rtx[2][(int) (MODE)])
    3833                 :             : #define CONSTM1_RTX(MODE) (const_tiny_rtx[3][(int) (MODE)])
    3834                 :             : 
    3835                 :             : extern GTY(()) rtx pc_rtx;
    3836                 :             : extern GTY(()) rtx ret_rtx;
    3837                 :             : extern GTY(()) rtx simple_return_rtx;
    3838                 :             : extern GTY(()) rtx_insn *invalid_insn_rtx;
    3839                 :             : 
    3840                 :             : /* If HARD_FRAME_POINTER_REGNUM is defined, then a special dummy reg
    3841                 :             :    is used to represent the frame pointer.  This is because the
    3842                 :             :    hard frame pointer and the automatic variables are separated by an amount
    3843                 :             :    that cannot be determined until after register allocation.  We can assume
    3844                 :             :    that in this case ELIMINABLE_REGS will be defined, one action of which
    3845                 :             :    will be to eliminate FRAME_POINTER_REGNUM into HARD_FRAME_POINTER_REGNUM.  */
    3846                 :             : #ifndef HARD_FRAME_POINTER_REGNUM
    3847                 :             : #define HARD_FRAME_POINTER_REGNUM FRAME_POINTER_REGNUM
    3848                 :             : #endif
    3849                 :             : 
    3850                 :             : #ifndef HARD_FRAME_POINTER_IS_FRAME_POINTER
    3851                 :             : #define HARD_FRAME_POINTER_IS_FRAME_POINTER \
    3852                 :             :   (HARD_FRAME_POINTER_REGNUM == FRAME_POINTER_REGNUM)
    3853                 :             : #endif
    3854                 :             : 
    3855                 :             : #ifndef HARD_FRAME_POINTER_IS_ARG_POINTER
    3856                 :             : #define HARD_FRAME_POINTER_IS_ARG_POINTER \
    3857                 :             :   (HARD_FRAME_POINTER_REGNUM == ARG_POINTER_REGNUM)
    3858                 :             : #endif
    3859                 :             : 
    3860                 :             : /* Index labels for global_rtl.  */
    3861                 :             : enum global_rtl_index
    3862                 :             : {
    3863                 :             :   GR_STACK_POINTER,
    3864                 :             :   GR_FRAME_POINTER,
    3865                 :             : /* For register elimination to work properly these hard_frame_pointer_rtx,
    3866                 :             :    frame_pointer_rtx, and arg_pointer_rtx must be the same if they refer to
    3867                 :             :    the same register.  */
    3868                 :             : #if FRAME_POINTER_REGNUM == ARG_POINTER_REGNUM
    3869                 :             :   GR_ARG_POINTER = GR_FRAME_POINTER,
    3870                 :             : #endif
    3871                 :             : #if HARD_FRAME_POINTER_IS_FRAME_POINTER
    3872                 :             :   GR_HARD_FRAME_POINTER = GR_FRAME_POINTER,
    3873                 :             : #else
    3874                 :             :   GR_HARD_FRAME_POINTER,
    3875                 :             : #endif
    3876                 :             : #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
    3877                 :             : #if HARD_FRAME_POINTER_IS_ARG_POINTER
    3878                 :             :   GR_ARG_POINTER = GR_HARD_FRAME_POINTER,
    3879                 :             : #else
    3880                 :             :   GR_ARG_POINTER,
    3881                 :             : #endif
    3882                 :             : #endif
    3883                 :             :   GR_VIRTUAL_INCOMING_ARGS,
    3884                 :             :   GR_VIRTUAL_STACK_ARGS,
    3885                 :             :   GR_VIRTUAL_STACK_DYNAMIC,
    3886                 :             :   GR_VIRTUAL_OUTGOING_ARGS,
    3887                 :             :   GR_VIRTUAL_CFA,
    3888                 :             :   GR_VIRTUAL_PREFERRED_STACK_BOUNDARY,
    3889                 :             : 
    3890                 :             :   GR_MAX
    3891                 :             : };
    3892                 :             : 
    3893                 :             : /* Target-dependent globals.  */
    3894                 :             : struct GTY(()) target_rtl {
    3895                 :             :   /* All references to the hard registers in global_rtl_index go through
    3896                 :             :      these unique rtl objects.  On machines where the frame-pointer and
    3897                 :             :      arg-pointer are the same register, they use the same unique object.
    3898                 :             : 
    3899                 :             :      After register allocation, other rtl objects which used to be pseudo-regs
    3900                 :             :      may be clobbered to refer to the frame-pointer register.
    3901                 :             :      But references that were originally to the frame-pointer can be
    3902                 :             :      distinguished from the others because they contain frame_pointer_rtx.
    3903                 :             : 
    3904                 :             :      When to use frame_pointer_rtx and hard_frame_pointer_rtx is a little
    3905                 :             :      tricky: until register elimination has taken place hard_frame_pointer_rtx
    3906                 :             :      should be used if it is being set, and frame_pointer_rtx otherwise.  After
    3907                 :             :      register elimination hard_frame_pointer_rtx should always be used.
    3908                 :             :      On machines where the two registers are same (most) then these are the
    3909                 :             :      same.  */
    3910                 :             :   rtx x_global_rtl[GR_MAX];
    3911                 :             : 
    3912                 :             :   /* A unique representation of (REG:Pmode PIC_OFFSET_TABLE_REGNUM).  */
    3913                 :             :   rtx x_pic_offset_table_rtx;
    3914                 :             : 
    3915                 :             :   /* A unique representation of (REG:Pmode RETURN_ADDRESS_POINTER_REGNUM).
    3916                 :             :      This is used to implement __builtin_return_address for some machines;
    3917                 :             :      see for instance the MIPS port.  */
    3918                 :             :   rtx x_return_address_pointer_rtx;
    3919                 :             : 
    3920                 :             :   /* Commonly used RTL for hard registers.  These objects are not
    3921                 :             :      necessarily unique, so we allocate them separately from global_rtl.
    3922                 :             :      They are initialized once per compilation unit, then copied into
    3923                 :             :      regno_reg_rtx at the beginning of each function.  */
    3924                 :             :   rtx x_initial_regno_reg_rtx[FIRST_PSEUDO_REGISTER];
    3925                 :             : 
    3926                 :             :   /* A sample (mem:M stack_pointer_rtx) rtx for each mode M.  */
    3927                 :             :   rtx x_top_of_stack[MAX_MACHINE_MODE];
    3928                 :             : 
    3929                 :             :   /* Static hunks of RTL used by the aliasing code; these are treated
    3930                 :             :      as persistent to avoid unnecessary RTL allocations.  */
    3931                 :             :   rtx x_static_reg_base_value[FIRST_PSEUDO_REGISTER];
    3932                 :             : 
    3933                 :             :   /* The default memory attributes for each mode.  */
    3934                 :             :   class mem_attrs *x_mode_mem_attrs[(int) MAX_MACHINE_MODE];
    3935                 :             : 
    3936                 :             :   /* Track if RTL has been initialized.  */
    3937                 :             :   bool target_specific_initialized;
    3938                 :             : };
    3939                 :             : 
    3940                 :             : extern GTY(()) struct target_rtl default_target_rtl;
    3941                 :             : #if SWITCHABLE_TARGET
    3942                 :             : extern struct target_rtl *this_target_rtl;
    3943                 :             : #else
    3944                 :             : #define this_target_rtl (&default_target_rtl)
    3945                 :             : #endif
    3946                 :             : 
    3947                 :             : #define global_rtl                              \
    3948                 :             :   (this_target_rtl->x_global_rtl)
    3949                 :             : #define pic_offset_table_rtx \
    3950                 :             :   (this_target_rtl->x_pic_offset_table_rtx)
    3951                 :             : #define return_address_pointer_rtx \
    3952                 :             :   (this_target_rtl->x_return_address_pointer_rtx)
    3953                 :             : #define top_of_stack \
    3954                 :             :   (this_target_rtl->x_top_of_stack)
    3955                 :             : #define mode_mem_attrs \
    3956                 :             :   (this_target_rtl->x_mode_mem_attrs)
    3957                 :             : 
    3958                 :             : /* All references to certain hard regs, except those created
    3959                 :             :    by allocating pseudo regs into them (when that's possible),
    3960                 :             :    go through these unique rtx objects.  */
    3961                 :             : #define stack_pointer_rtx       (global_rtl[GR_STACK_POINTER])
    3962                 :             : #define frame_pointer_rtx       (global_rtl[GR_FRAME_POINTER])
    3963                 :             : #define hard_frame_pointer_rtx  (global_rtl[GR_HARD_FRAME_POINTER])
    3964                 :             : #define arg_pointer_rtx         (global_rtl[GR_ARG_POINTER])
    3965                 :             : 
    3966                 :             : #ifndef GENERATOR_FILE
    3967                 :             : /* Return the attributes of a MEM rtx.  */
    3968                 :             : inline const class mem_attrs *
    3969                 : 10528046747 : get_mem_attrs (const_rtx x)
    3970                 :             : {
    3971                 : 10528046747 :   class mem_attrs *attrs;
    3972                 :             : 
    3973                 :  3768487899 :   attrs = MEM_ATTRS (x);
    3974                 :  8862239766 :   if (!attrs)
    3975                 :   383614452 :     attrs = mode_mem_attrs[(int) GET_MODE (x)];
    3976                 :  8735261030 :   return attrs;
    3977                 :             : }
    3978                 :             : #endif
    3979                 :             : 
    3980                 :             : /* Include the RTL generation functions.  */
    3981                 :             : 
    3982                 :             : #ifndef GENERATOR_FILE
    3983                 :             : #include "genrtl.h"
    3984                 :             : #undef gen_rtx_ASM_INPUT
    3985                 :             : #define gen_rtx_ASM_INPUT(MODE, ARG0)                           \
    3986                 :             :   gen_rtx_fmt_si (ASM_INPUT, (MODE), (ARG0), 0)
    3987                 :             : #define gen_rtx_ASM_INPUT_loc(MODE, ARG0, LOC)                  \
    3988                 :             :   gen_rtx_fmt_si (ASM_INPUT, (MODE), (ARG0), (LOC))
    3989                 :             : #endif
    3990                 :             : 
    3991                 :             : /* There are some RTL codes that require special attention; the
    3992                 :             :    generation functions included above do the raw handling.  If you
    3993                 :             :    add to this list, modify special_rtx in gengenrtl.cc as well.  */
    3994                 :             : 
    3995                 :             : extern rtx_expr_list *gen_rtx_EXPR_LIST (machine_mode, rtx, rtx);
    3996                 :             : extern rtx_insn_list *gen_rtx_INSN_LIST (machine_mode, rtx, rtx);
    3997                 :             : extern rtx_insn *
    3998                 :             : gen_rtx_INSN (machine_mode mode, rtx_insn *prev_insn, rtx_insn *next_insn,
    3999                 :             :               basic_block bb, rtx pattern, int location, int code,
    4000                 :             :               rtx reg_notes);
    4001                 :             : extern rtx gen_rtx_CONST_INT (machine_mode, HOST_WIDE_INT);
    4002                 :             : extern rtx gen_rtx_CONST_VECTOR (machine_mode, rtvec);
    4003                 :             : extern void set_mode_and_regno (rtx, machine_mode, unsigned int);
    4004                 :             : extern rtx init_raw_REG (rtx, machine_mode, unsigned int);
    4005                 :             : extern rtx gen_raw_REG (machine_mode, unsigned int);
    4006                 :             : #define alloca_raw_REG(mode, regno) \
    4007                 :             :   init_raw_REG (rtx_alloca (REG), (mode), (regno))
    4008                 :             : extern rtx gen_rtx_REG (machine_mode, unsigned int);
    4009                 :             : extern rtx gen_rtx_SUBREG (machine_mode, rtx, poly_uint64);
    4010                 :             : extern rtx gen_rtx_MEM (machine_mode, rtx);
    4011                 :             : extern rtx gen_rtx_VAR_LOCATION (machine_mode, tree, rtx,
    4012                 :             :                                  enum var_init_status);
    4013                 :             : 
    4014                 :             : #ifdef GENERATOR_FILE
    4015                 :             : #define PUT_MODE(RTX, MODE) PUT_MODE_RAW (RTX, MODE)
    4016                 :             : #else
    4017                 :             : inline void
    4018                 :  1289980107 : PUT_MODE (rtx x, machine_mode mode)
    4019                 :             : {
    4020                 :  1289980107 :   if (REG_P (x))
    4021                 :   326048609 :     set_mode_and_regno (x, mode, REGNO (x));
    4022                 :             :   else
    4023                 :   963931498 :     PUT_MODE_RAW (x, mode);
    4024                 :  1289980107 : }
    4025                 :             : #endif
    4026                 :             : 
    4027                 :             : #define GEN_INT(N)  gen_rtx_CONST_INT (VOIDmode, (N))
    4028                 :             : 
    4029                 :             : /* Virtual registers are used during RTL generation to refer to locations into
    4030                 :             :    the stack frame when the actual location isn't known until RTL generation
    4031                 :             :    is complete.  The routine instantiate_virtual_regs replaces these with
    4032                 :             :    the proper value, which is normally {frame,arg,stack}_pointer_rtx plus
    4033                 :             :    a constant.  */
    4034                 :             : 
    4035                 :             : #define FIRST_VIRTUAL_REGISTER  (FIRST_PSEUDO_REGISTER)
    4036                 :             : 
    4037                 :             : /* This points to the first word of the incoming arguments passed on the stack,
    4038                 :             :    either by the caller or by the callee when pretending it was passed by the
    4039                 :             :    caller.  */
    4040                 :             : 
    4041                 :             : #define virtual_incoming_args_rtx       (global_rtl[GR_VIRTUAL_INCOMING_ARGS])
    4042                 :             : 
    4043                 :             : #define VIRTUAL_INCOMING_ARGS_REGNUM    (FIRST_VIRTUAL_REGISTER)
    4044                 :             : 
    4045                 :             : /* If FRAME_GROWS_DOWNWARD, this points to immediately above the first
    4046                 :             :    variable on the stack.  Otherwise, it points to the first variable on
    4047                 :             :    the stack.  */
    4048                 :             : 
    4049                 :             : #define virtual_stack_vars_rtx          (global_rtl[GR_VIRTUAL_STACK_ARGS])
    4050                 :             : 
    4051                 :             : #define VIRTUAL_STACK_VARS_REGNUM       ((FIRST_VIRTUAL_REGISTER) + 1)
    4052                 :             : 
    4053                 :             : /* This points to the location of dynamically-allocated memory on the stack
    4054                 :             :    immediately after the stack pointer has been adjusted by the amount
    4055                 :             :    desired.  */
    4056                 :             : 
    4057                 :             : #define virtual_stack_dynamic_rtx       (global_rtl[GR_VIRTUAL_STACK_DYNAMIC])
    4058                 :             : 
    4059                 :             : #define VIRTUAL_STACK_DYNAMIC_REGNUM    ((FIRST_VIRTUAL_REGISTER) + 2)
    4060                 :             : 
    4061                 :             : /* This points to the location in the stack at which outgoing arguments should
    4062                 :             :    be written when the stack is pre-pushed (arguments pushed using push
    4063                 :             :    insns always use sp).  */
    4064                 :             : 
    4065                 :             : #define virtual_outgoing_args_rtx       (global_rtl[GR_VIRTUAL_OUTGOING_ARGS])
    4066                 :             : 
    4067                 :             : #define VIRTUAL_OUTGOING_ARGS_REGNUM    ((FIRST_VIRTUAL_REGISTER) + 3)
    4068                 :             : 
    4069                 :             : /* This points to the Canonical Frame Address of the function.  This
    4070                 :             :    should correspond to the CFA produced by INCOMING_FRAME_SP_OFFSET,
    4071                 :             :    but is calculated relative to the arg pointer for simplicity; the
    4072                 :             :    frame pointer nor stack pointer are necessarily fixed relative to
    4073                 :             :    the CFA until after reload.  */
    4074                 :             : 
    4075                 :             : #define virtual_cfa_rtx                 (global_rtl[GR_VIRTUAL_CFA])
    4076                 :             : 
    4077                 :             : #define VIRTUAL_CFA_REGNUM              ((FIRST_VIRTUAL_REGISTER) + 4)
    4078                 :             : 
    4079                 :             : #define LAST_VIRTUAL_POINTER_REGISTER   ((FIRST_VIRTUAL_REGISTER) + 4)
    4080                 :             : 
    4081                 :             : /* This is replaced by crtl->preferred_stack_boundary / BITS_PER_UNIT
    4082                 :             :    when finalized.  */
    4083                 :             : 
    4084                 :             : #define virtual_preferred_stack_boundary_rtx \
    4085                 :             :         (global_rtl[GR_VIRTUAL_PREFERRED_STACK_BOUNDARY])
    4086                 :             : 
    4087                 :             : #define VIRTUAL_PREFERRED_STACK_BOUNDARY_REGNUM \
    4088                 :             :                                         ((FIRST_VIRTUAL_REGISTER) + 5)
    4089                 :             : 
    4090                 :             : #define LAST_VIRTUAL_REGISTER           ((FIRST_VIRTUAL_REGISTER) + 5)
    4091                 :             : 
    4092                 :             : /* Nonzero if REGNUM is a pointer into the stack frame.  */
    4093                 :             : #define REGNO_PTR_FRAME_P(REGNUM)               \
    4094                 :             :   ((REGNUM) == STACK_POINTER_REGNUM             \
    4095                 :             :    || (REGNUM) == FRAME_POINTER_REGNUM          \
    4096                 :             :    || (REGNUM) == HARD_FRAME_POINTER_REGNUM     \
    4097                 :             :    || (REGNUM) == ARG_POINTER_REGNUM            \
    4098                 :             :    || VIRTUAL_REGISTER_NUM_P (REGNUM))
    4099                 :             : 
    4100                 :             : /* REGNUM never really appearing in the INSN stream.  */
    4101                 :             : #define INVALID_REGNUM                  (~(unsigned int) 0)
    4102                 :             : 
    4103                 :             : /* REGNUM for which no debug information can be generated.  */
    4104                 :             : #define IGNORED_DWARF_REGNUM            (INVALID_REGNUM - 1)
    4105                 :             : 
    4106                 :             : extern rtx output_constant_def (tree, int);
    4107                 :             : extern rtx lookup_constant_def (tree);
    4108                 :             : 
    4109                 :             : /* Nonzero after end of reload pass.
    4110                 :             :    Set to 1 or 0 by reload1.cc.  */
    4111                 :             : 
    4112                 :             : extern int reload_completed;
    4113                 :             : 
    4114                 :             : /* Nonzero after thread_prologue_and_epilogue_insns has run.  */
    4115                 :             : extern int epilogue_completed;
    4116                 :             : 
    4117                 :             : /* Set to 1 while reload_as_needed is operating.
    4118                 :             :    Required by some machines to handle any generated moves differently.  */
    4119                 :             : 
    4120                 :             : extern int reload_in_progress;
    4121                 :             : 
    4122                 :             : /* Set to true while in IRA.  */
    4123                 :             : extern bool ira_in_progress;
    4124                 :             : 
    4125                 :             : /* Set to true while in LRA.  */
    4126                 :             : extern bool lra_in_progress;
    4127                 :             : 
    4128                 :             : /* This macro indicates whether you may create a new
    4129                 :             :    pseudo-register.  */
    4130                 :             : 
    4131                 :             : #define can_create_pseudo_p() (!reload_in_progress && !reload_completed)
    4132                 :             : 
    4133                 :             : #ifdef STACK_REGS
    4134                 :             : /* Nonzero after end of regstack pass.
    4135                 :             :    Set to 1 or 0 by reg-stack.cc.  */
    4136                 :             : extern int regstack_completed;
    4137                 :             : #endif
    4138                 :             : 
    4139                 :             : /* If this is nonzero, we do not bother generating VOLATILE
    4140                 :             :    around volatile memory references, and we are willing to
    4141                 :             :    output indirect addresses.  If cse is to follow, we reject
    4142                 :             :    indirect addresses so a useful potential cse is generated;
    4143                 :             :    if it is used only once, instruction combination will produce
    4144                 :             :    the same indirect address eventually.  */
    4145                 :             : extern int cse_not_expected;
    4146                 :             : 
    4147                 :             : /* Translates rtx code to tree code, for those codes needed by
    4148                 :             :    real_arithmetic.  The function returns an int because the caller may not
    4149                 :             :    know what `enum tree_code' means.  */
    4150                 :             : 
    4151                 :             : extern int rtx_to_tree_code (enum rtx_code);
    4152                 :             : 
    4153                 :             : /* In cse.cc */
    4154                 :             : extern int delete_trivially_dead_insns (rtx_insn *, int);
    4155                 :             : extern bool exp_equiv_p (const_rtx, const_rtx, int, bool);
    4156                 :             : 
    4157                 :             : typedef bool (*hash_rtx_callback_function) (const_rtx, machine_mode, rtx *,
    4158                 :             :                                             machine_mode *);
    4159                 :             : extern unsigned hash_rtx (const_rtx, machine_mode, int *, int *,
    4160                 :             :                           bool, hash_rtx_callback_function = NULL);
    4161                 :             : 
    4162                 :             : /* In dse.cc */
    4163                 :             : extern bool check_for_inc_dec (rtx_insn *insn);
    4164                 :             : 
    4165                 :             : /* In jump.cc */
    4166                 :             : extern bool comparison_dominates_p (enum rtx_code, enum rtx_code);
    4167                 :             : extern bool jump_to_label_p (const rtx_insn *);
    4168                 :             : extern bool condjump_p (const rtx_insn *);
    4169                 :             : extern bool any_condjump_p (const rtx_insn *);
    4170                 :             : extern bool any_uncondjump_p (const rtx_insn *);
    4171                 :             : extern rtx pc_set (const rtx_insn *);
    4172                 :             : extern rtx condjump_label (const rtx_insn *);
    4173                 :             : extern bool simplejump_p (const rtx_insn *);
    4174                 :             : extern bool returnjump_p (const rtx_insn *);
    4175                 :             : extern bool eh_returnjump_p (rtx_insn *);
    4176                 :             : extern bool onlyjump_p (const rtx_insn *);
    4177                 :             : extern bool invert_jump_1 (rtx_jump_insn *, rtx);
    4178                 :             : extern bool invert_jump (rtx_jump_insn *, rtx, int);
    4179                 :             : extern bool rtx_renumbered_equal_p (const_rtx, const_rtx);
    4180                 :             : extern int true_regnum (const_rtx);
    4181                 :             : extern unsigned int reg_or_subregno (const_rtx);
    4182                 :             : extern bool redirect_jump_1 (rtx_insn *, rtx);
    4183                 :             : extern void redirect_jump_2 (rtx_jump_insn *, rtx, rtx, int, int);
    4184                 :             : extern bool redirect_jump (rtx_jump_insn *, rtx, int);
    4185                 :             : extern void rebuild_jump_labels (rtx_insn *);
    4186                 :             : extern void rebuild_jump_labels_chain (rtx_insn *);
    4187                 :             : extern rtx reversed_comparison (const_rtx, machine_mode);
    4188                 :             : extern enum rtx_code reversed_comparison_code (const_rtx, const rtx_insn *);
    4189                 :             : extern enum rtx_code reversed_comparison_code_parts (enum rtx_code, const_rtx,
    4190                 :             :                                                      const_rtx, const rtx_insn *);
    4191                 :             : extern void delete_for_peephole (rtx_insn *, rtx_insn *);
    4192                 :             : extern bool condjump_in_parallel_p (const rtx_insn *);
    4193                 :             : 
    4194                 :             : /* In emit-rtl.cc.  */
    4195                 :             : extern int max_reg_num (void);
    4196                 :             : extern int max_label_num (void);
    4197                 :             : extern int get_first_label_num (void);
    4198                 :             : extern void maybe_set_first_label_num (rtx_code_label *);
    4199                 :             : extern void delete_insns_since (rtx_insn *);
    4200                 :             : extern void mark_reg_pointer (rtx, int);
    4201                 :             : extern void mark_user_reg (rtx);
    4202                 :             : extern void reset_used_flags (rtx);
    4203                 :             : extern void set_used_flags (rtx);
    4204                 :             : extern void reorder_insns (rtx_insn *, rtx_insn *, rtx_insn *);
    4205                 :             : extern void reorder_insns_nobb (rtx_insn *, rtx_insn *, rtx_insn *);
    4206                 :             : extern int get_max_insn_count (void);
    4207                 :             : extern bool in_sequence_p (void);
    4208                 :             : extern void init_emit (void);
    4209                 :             : extern void init_emit_regs (void);
    4210                 :             : extern void init_derived_machine_modes (void);
    4211                 :             : extern void init_emit_once (void);
    4212                 :             : extern void push_topmost_sequence (void);
    4213                 :             : extern void pop_topmost_sequence (void);
    4214                 :             : extern void set_new_first_and_last_insn (rtx_insn *, rtx_insn *);
    4215                 :             : extern void unshare_all_rtl (void);
    4216                 :             : extern void unshare_all_rtl_again (rtx_insn *);
    4217                 :             : extern void unshare_all_rtl_in_chain (rtx_insn *);
    4218                 :             : extern void verify_rtl_sharing (void);
    4219                 :             : extern void add_insn (rtx_insn *);
    4220                 :             : extern void add_insn_before (rtx_insn *, rtx_insn *, basic_block);
    4221                 :             : extern void add_insn_after (rtx_insn *, rtx_insn *, basic_block);
    4222                 :             : extern void remove_insn (rtx_insn *);
    4223                 :             : extern rtx_insn *emit (rtx, bool = true);
    4224                 :             : extern void emit_insn_at_entry (rtx);
    4225                 :             : extern rtx gen_lowpart_SUBREG (machine_mode, rtx);
    4226                 :             : extern rtx gen_const_mem (machine_mode, rtx);
    4227                 :             : extern rtx gen_frame_mem (machine_mode, rtx);
    4228                 :             : extern rtx gen_tmp_stack_mem (machine_mode, rtx);
    4229                 :             : extern bool validate_subreg (machine_mode, machine_mode,
    4230                 :             :                              const_rtx, poly_uint64);
    4231                 :             : 
    4232                 :             : /* In combine.cc  */
    4233                 :             : extern unsigned int extended_count (const_rtx, machine_mode, bool);
    4234                 :             : extern rtx remove_death (unsigned int, rtx_insn *);
    4235                 :             : extern rtx make_compound_operation (rtx, enum rtx_code);
    4236                 :             : 
    4237                 :             : /* In sched-rgn.cc.  */
    4238                 :             : extern void schedule_insns (void);
    4239                 :             : 
    4240                 :             : /* In sched-ebb.cc.  */
    4241                 :             : extern void schedule_ebbs (void);
    4242                 :             : 
    4243                 :             : /* In sel-sched-dump.cc.  */
    4244                 :             : extern void sel_sched_fix_param (const char *param, const char *val);
    4245                 :             : 
    4246                 :             : /* In print-rtl.cc */
    4247                 :             : extern const char *print_rtx_head;
    4248                 :             : extern void debug (const rtx_def &ref);
    4249                 :             : extern void debug (const rtx_def *ptr);
    4250                 :             : extern void debug_rtx (const_rtx);
    4251                 :             : extern void debug_rtx_list (const rtx_insn *, int);
    4252                 :             : extern void debug_rtx_range (const rtx_insn *, const rtx_insn *);
    4253                 :             : extern const rtx_insn *debug_rtx_find (const rtx_insn *, int);
    4254                 :             : extern void print_mem_expr (FILE *, const_tree);
    4255                 :             : extern void print_rtl (FILE *, const_rtx);
    4256                 :             : extern void print_simple_rtl (FILE *, const_rtx);
    4257                 :             : extern void print_rtl_single (FILE *, const_rtx);
    4258                 :             : extern void print_rtl_single_with_indent (FILE *, const_rtx, int);
    4259                 :             : extern void print_inline_rtx (FILE *, const_rtx, int);
    4260                 :             : 
    4261                 :             : /* In stmt.cc */
    4262                 :             : extern void expand_null_return (void);
    4263                 :             : extern void expand_naked_return (void);
    4264                 :             : extern void emit_jump (rtx);
    4265                 :             : 
    4266                 :             : /* Memory operation built-ins differ by return value.  Mapping
    4267                 :             :    of the enum values is following:
    4268                 :             :    - RETURN_BEGIN - return destination, e.g. memcpy
    4269                 :             :    - RETURN_END - return destination + n, e.g. mempcpy
    4270                 :             :    - RETURN_END_MINUS_ONE - return a pointer to the terminating
    4271                 :             :     null byte of the string, e.g. strcpy
    4272                 :             : */
    4273                 :             : 
    4274                 :             : enum memop_ret
    4275                 :             : {
    4276                 :             :   RETURN_BEGIN,
    4277                 :             :   RETURN_END,
    4278                 :             :   RETURN_END_MINUS_ONE
    4279                 :             : };
    4280                 :             : 
    4281                 :             : /* In expr.cc */
    4282                 :             : extern rtx move_by_pieces (rtx, rtx, unsigned HOST_WIDE_INT,
    4283                 :             :                            unsigned int, memop_ret);
    4284                 :             : extern poly_int64 find_args_size_adjust (rtx_insn *);
    4285                 :             : extern poly_int64 fixup_args_size_notes (rtx_insn *, rtx_insn *, poly_int64);
    4286                 :             : 
    4287                 :             : /* In expmed.cc */
    4288                 :             : extern void init_expmed (void);
    4289                 :             : extern void expand_inc (rtx, rtx);
    4290                 :             : extern void expand_dec (rtx, rtx);
    4291                 :             : 
    4292                 :             : /* In lower-subreg.cc */
    4293                 :             : extern void init_lower_subreg (void);
    4294                 :             : 
    4295                 :             : /* In gcse.cc */
    4296                 :             : extern bool can_copy_p (machine_mode);
    4297                 :             : extern bool can_assign_to_reg_without_clobbers_p (rtx, machine_mode);
    4298                 :             : extern rtx_insn *prepare_copy_insn (rtx, rtx);
    4299                 :             : 
    4300                 :             : /* In cprop.cc */
    4301                 :             : extern rtx fis_get_condition (rtx_insn *);
    4302                 :             : 
    4303                 :             : /* In ira.cc */
    4304                 :             : extern HARD_REG_SET eliminable_regset;
    4305                 :             : extern void mark_elimination (int, int);
    4306                 :             : 
    4307                 :             : /* In reginfo.cc */
    4308                 :             : extern bool reg_classes_intersect_p (reg_class_t, reg_class_t);
    4309                 :             : extern bool reg_class_subset_p (reg_class_t, reg_class_t);
    4310                 :             : extern void globalize_reg (tree, int);
    4311                 :             : extern void init_reg_modes_target (void);
    4312                 :             : extern void init_regs (void);
    4313                 :             : extern void reinit_regs (void);
    4314                 :             : extern void init_fake_stack_mems (void);
    4315                 :             : extern void save_register_info (void);
    4316                 :             : extern void init_reg_sets (void);
    4317                 :             : extern void regclass (rtx, int);
    4318                 :             : extern void reg_scan (rtx_insn *, unsigned int);
    4319                 :             : extern void fix_register (const char *, int, int);
    4320                 :             : extern const HARD_REG_SET *valid_mode_changes_for_regno (unsigned int);
    4321                 :             : 
    4322                 :             : /* In reload1.cc */
    4323                 :             : extern bool function_invariant_p (const_rtx);
    4324                 :             : 
    4325                 :             : /* In calls.cc */
    4326                 :             : enum libcall_type
    4327                 :             : {
    4328                 :             :   LCT_NORMAL = 0,
    4329                 :             :   LCT_CONST = 1,
    4330                 :             :   LCT_PURE = 2,
    4331                 :             :   LCT_NORETURN = 3,
    4332                 :             :   LCT_THROW = 4,
    4333                 :             :   LCT_RETURNS_TWICE = 5
    4334                 :             : };
    4335                 :             : 
    4336                 :             : extern rtx emit_library_call_value_1 (int, rtx, rtx, enum libcall_type,
    4337                 :             :                                       machine_mode, int, rtx_mode_t *);
    4338                 :             : 
    4339                 :             : /* Output a library call and discard the returned value.  FUN is the
    4340                 :             :    address of the function, as a SYMBOL_REF rtx, and OUTMODE is the mode
    4341                 :             :    of the (discarded) return value.  FN_TYPE is LCT_NORMAL for `normal'
    4342                 :             :    calls, LCT_CONST for `const' calls, LCT_PURE for `pure' calls, or
    4343                 :             :    another LCT_ value for other types of library calls.
    4344                 :             : 
    4345                 :             :    There are different overloads of this function for different numbers
    4346                 :             :    of arguments.  In each case the argument value is followed by its mode.  */
    4347                 :             : 
    4348                 :             : inline void
    4349                 :           0 : emit_library_call (rtx fun, libcall_type fn_type, machine_mode outmode)
    4350                 :             : {
    4351                 :           0 :   emit_library_call_value_1 (0, fun, NULL_RTX, fn_type, outmode, 0, NULL);
    4352                 :           0 : }
    4353                 :             : 
    4354                 :             : inline void
    4355                 :           0 : emit_library_call (rtx fun, libcall_type fn_type, machine_mode outmode,
    4356                 :             :                    rtx arg1, machine_mode arg1_mode)
    4357                 :             : {
    4358                 :           0 :   rtx_mode_t args[] = { rtx_mode_t (arg1, arg1_mode) };
    4359                 :           0 :   emit_library_call_value_1 (0, fun, NULL_RTX, fn_type, outmode, 1, args);
    4360                 :           0 : }
    4361                 :             : 
    4362                 :             : inline void
    4363                 :         178 : emit_library_call (rtx fun, libcall_type fn_type, machine_mode outmode,
    4364                 :             :                    rtx arg1, machine_mode arg1_mode,
    4365                 :             :                    rtx arg2, machine_mode arg2_mode)
    4366                 :             : {
    4367                 :         178 :   rtx_mode_t args[] = {
    4368                 :             :     rtx_mode_t (arg1, arg1_mode),
    4369                 :             :     rtx_mode_t (arg2, arg2_mode)
    4370                 :         178 :   };
    4371                 :         178 :   emit_library_call_value_1 (0, fun, NULL_RTX, fn_type, outmode, 2, args);
    4372                 :         178 : }
    4373                 :             : 
    4374                 :             : inline void
    4375                 :         423 : emit_library_call (rtx fun, libcall_type fn_type, machine_mode outmode,
    4376                 :             :                    rtx arg1, machine_mode arg1_mode,
    4377                 :             :                    rtx arg2, machine_mode arg2_mode,
    4378                 :             :                    rtx arg3, machine_mode arg3_mode)
    4379                 :             : {
    4380                 :         423 :   rtx_mode_t args[] = {
    4381                 :             :     rtx_mode_t (arg1, arg1_mode),
    4382                 :             :     rtx_mode_t (arg2, arg2_mode),
    4383                 :             :     rtx_mode_t (arg3, arg3_mode)
    4384                 :         423 :   };
    4385                 :         423 :   emit_library_call_value_1 (0, fun, NULL_RTX, fn_type, outmode, 3, args);
    4386                 :         423 : }
    4387                 :             : 
    4388                 :             : inline void
    4389                 :             : emit_library_call (rtx fun, libcall_type fn_type, machine_mode outmode,
    4390                 :             :                    rtx arg1, machine_mode arg1_mode,
    4391                 :             :                    rtx arg2, machine_mode arg2_mode,
    4392                 :             :                    rtx arg3, machine_mode arg3_mode,
    4393                 :             :                    rtx arg4, machine_mode arg4_mode)
    4394                 :             : {
    4395                 :             :   rtx_mode_t args[] = {
    4396                 :             :     rtx_mode_t (arg1, arg1_mode),
    4397                 :             :     rtx_mode_t (arg2, arg2_mode),
    4398                 :             :     rtx_mode_t (arg3, arg3_mode),
    4399                 :             :     rtx_mode_t (arg4, arg4_mode)
    4400                 :             :   };
    4401                 :             :   emit_library_call_value_1 (0, fun, NULL_RTX, fn_type, outmode, 4, args);
    4402                 :             : }
    4403                 :             : 
    4404                 :             : /* Like emit_library_call, but return the value produced by the call.
    4405                 :             :    Use VALUE to store the result if it is nonnull, otherwise pick a
    4406                 :             :    convenient location.  */
    4407                 :             : 
    4408                 :             : inline rtx
    4409                 :          16 : emit_library_call_value (rtx fun, rtx value, libcall_type fn_type,
    4410                 :             :                          machine_mode outmode)
    4411                 :             : {
    4412                 :          16 :   return emit_library_call_value_1 (1, fun, value, fn_type, outmode, 0, NULL);
    4413                 :             : }
    4414                 :             : 
    4415                 :             : inline rtx
    4416                 :       40043 : emit_library_call_value (rtx fun, rtx value, libcall_type fn_type,
    4417                 :             :                          machine_mode outmode,
    4418                 :             :                          rtx arg1, machine_mode arg1_mode)
    4419                 :             : {
    4420                 :       40043 :   rtx_mode_t args[] = { rtx_mode_t (arg1, arg1_mode) };
    4421                 :       40043 :   return emit_library_call_value_1 (1, fun, value, fn_type, outmode, 1, args);
    4422                 :             : }
    4423                 :             : 
    4424                 :             : inline rtx
    4425                 :       74675 : emit_library_call_value (rtx fun, rtx value, libcall_type fn_type,
    4426                 :             :                          machine_mode outmode,
    4427                 :             :                          rtx arg1, machine_mode arg1_mode,
    4428                 :             :                          rtx arg2, machine_mode arg2_mode)
    4429                 :             : {
    4430                 :       74675 :   rtx_mode_t args[] = {
    4431                 :             :     rtx_mode_t (arg1, arg1_mode),
    4432                 :             :     rtx_mode_t (arg2, arg2_mode)
    4433                 :       74675 :   };
    4434                 :       74675 :   return emit_library_call_value_1 (1, fun, value, fn_type, outmode, 2, args);
    4435                 :             : }
    4436                 :             : 
    4437                 :             : inline rtx
    4438                 :         902 : emit_library_call_value (rtx fun, rtx value, libcall_type fn_type,
    4439                 :             :                          machine_mode outmode,
    4440                 :             :                          rtx arg1, machine_mode arg1_mode,
    4441                 :             :                          rtx arg2, machine_mode arg2_mode,
    4442                 :             :                          rtx arg3, machine_mode arg3_mode)
    4443                 :             : {
    4444                 :         902 :   rtx_mode_t args[] = {
    4445                 :             :     rtx_mode_t (arg1, arg1_mode),
    4446                 :             :     rtx_mode_t (arg2, arg2_mode),
    4447                 :             :     rtx_mode_t (arg3, arg3_mode)
    4448                 :         902 :   };
    4449                 :         902 :   return emit_library_call_value_1 (1, fun, value, fn_type, outmode, 3, args);
    4450                 :             : }
    4451                 :             : 
    4452                 :             : inline rtx
    4453                 :             : emit_library_call_value (rtx fun, rtx value, libcall_type fn_type,
    4454                 :             :                          machine_mode outmode,
    4455                 :             :                          rtx arg1, machine_mode arg1_mode,
    4456                 :             :                          rtx arg2, machine_mode arg2_mode,
    4457                 :             :                          rtx arg3, machine_mode arg3_mode,
    4458                 :             :                          rtx arg4, machine_mode arg4_mode)
    4459                 :             : {
    4460                 :             :   rtx_mode_t args[] = {
    4461                 :             :     rtx_mode_t (arg1, arg1_mode),
    4462                 :             :     rtx_mode_t (arg2, arg2_mode),
    4463                 :             :     rtx_mode_t (arg3, arg3_mode),
    4464                 :             :     rtx_mode_t (arg4, arg4_mode)
    4465                 :             :   };
    4466                 :             :   return emit_library_call_value_1 (1, fun, value, fn_type, outmode, 4, args);
    4467                 :             : }
    4468                 :             : 
    4469                 :             : /* In varasm.cc */
    4470                 :             : extern void init_varasm_once (void);
    4471                 :             : 
    4472                 :             : extern rtx make_debug_expr_from_rtl (const_rtx);
    4473                 :             : 
    4474                 :             : /* In read-rtl.cc */
    4475                 :             : #ifdef GENERATOR_FILE
    4476                 :             : extern bool read_rtx (const char *, vec<rtx> *);
    4477                 :             : #endif
    4478                 :             : 
    4479                 :             : /* In alias.cc */
    4480                 :             : extern rtx canon_rtx (rtx);
    4481                 :             : extern rtx get_addr (rtx);
    4482                 :             : extern bool read_dependence (const_rtx, const_rtx);
    4483                 :             : extern bool true_dependence (const_rtx, machine_mode, const_rtx);
    4484                 :             : extern bool canon_true_dependence (const_rtx, machine_mode, rtx,
    4485                 :             :                                    const_rtx, rtx);
    4486                 :             : extern bool anti_dependence (const_rtx, const_rtx);
    4487                 :             : extern bool canon_anti_dependence (const_rtx, bool,
    4488                 :             :                                    const_rtx, machine_mode, rtx);
    4489                 :             : extern bool output_dependence (const_rtx, const_rtx);
    4490                 :             : extern bool canon_output_dependence (const_rtx, bool,
    4491                 :             :                                      const_rtx, machine_mode, rtx);
    4492                 :             : extern bool may_alias_p (const_rtx, const_rtx);
    4493                 :             : extern void init_alias_target (void);
    4494                 :             : extern void init_alias_analysis (void);
    4495                 :             : extern void end_alias_analysis (void);
    4496                 :             : extern void vt_equate_reg_base_value (const_rtx, const_rtx);
    4497                 :             : extern bool memory_modified_in_insn_p (const_rtx, const_rtx);
    4498                 :             : extern bool may_be_sp_based_p (rtx);
    4499                 :             : extern rtx gen_hard_reg_clobber (machine_mode, unsigned int);
    4500                 :             : extern rtx get_reg_known_value (unsigned int);
    4501                 :             : extern bool get_reg_known_equiv_p (unsigned int);
    4502                 :             : extern rtx get_reg_base_value (unsigned int);
    4503                 :             : extern rtx extract_mem_from_operand (rtx);
    4504                 :             : 
    4505                 :             : #ifdef STACK_REGS
    4506                 :             : extern bool stack_regs_mentioned (const_rtx insn);
    4507                 :             : #endif
    4508                 :             : 
    4509                 :             : /* In toplev.cc */
    4510                 :             : extern GTY(()) rtx stack_limit_rtx;
    4511                 :             : 
    4512                 :             : /* In var-tracking.cc */
    4513                 :             : extern unsigned int variable_tracking_main (void);
    4514                 :             : extern void delete_vta_debug_insns (bool);
    4515                 :             : 
    4516                 :             : /* In stor-layout.cc.  */
    4517                 :             : extern void get_mode_bounds (scalar_int_mode, int,
    4518                 :             :                              scalar_int_mode, rtx *, rtx *);
    4519                 :             : 
    4520                 :             : /* In loop-iv.cc  */
    4521                 :             : extern rtx canon_condition (rtx);
    4522                 :             : extern void simplify_using_condition (rtx, rtx *, bitmap);
    4523                 :             : 
    4524                 :             : /* In final.cc  */
    4525                 :             : extern void compute_alignments (void);
    4526                 :             : extern void update_alignments (vec<rtx> &);
    4527                 :             : extern int asm_str_count (const char *templ);
    4528                 :             : 
    4529                 :             : struct rtl_hooks
    4530                 :             : {
    4531                 :             :   rtx (*gen_lowpart) (machine_mode, rtx);
    4532                 :             :   rtx (*gen_lowpart_no_emit) (machine_mode, rtx);
    4533                 :             :   rtx (*reg_nonzero_bits) (const_rtx, scalar_int_mode, scalar_int_mode,
    4534                 :             :                            unsigned HOST_WIDE_INT *);
    4535                 :             :   rtx (*reg_num_sign_bit_copies) (const_rtx, scalar_int_mode, scalar_int_mode,
    4536                 :             :                                   unsigned int *);
    4537                 :             :   bool (*reg_truncated_to_mode) (machine_mode, const_rtx);
    4538                 :             : 
    4539                 :             :   /* Whenever you add entries here, make sure you adjust rtlhooks-def.h.  */
    4540                 :             : };
    4541                 :             : 
    4542                 :             : /* Each pass can provide its own.  */
    4543                 :             : extern struct rtl_hooks rtl_hooks;
    4544                 :             : 
    4545                 :             : /* ... but then it has to restore these.  */
    4546                 :             : extern const struct rtl_hooks general_rtl_hooks;
    4547                 :             : 
    4548                 :             : /* Keep this for the nonce.  */
    4549                 :             : #define gen_lowpart rtl_hooks.gen_lowpart
    4550                 :             : 
    4551                 :             : extern void insn_locations_init (void);
    4552                 :             : extern void insn_locations_finalize (void);
    4553                 :             : extern void set_curr_insn_location (location_t);
    4554                 :             : extern location_t curr_insn_location (void);
    4555                 :             : extern void set_insn_locations (rtx_insn *, location_t);
    4556                 :             : 
    4557                 :             : /* rtl-error.cc */
    4558                 :             : extern void _fatal_insn_not_found (const_rtx, const char *, int, const char *)
    4559                 :             :      ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
    4560                 :             : extern void _fatal_insn (const char *, const_rtx, const char *, int, const char *)
    4561                 :             :      ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
    4562                 :             : 
    4563                 :             : #define fatal_insn(msgid, insn) \
    4564                 :             :         _fatal_insn (msgid, insn, __FILE__, __LINE__, __FUNCTION__)
    4565                 :             : #define fatal_insn_not_found(insn) \
    4566                 :             :         _fatal_insn_not_found (insn, __FILE__, __LINE__, __FUNCTION__)
    4567                 :             : 
    4568                 :             : /* reginfo.cc */
    4569                 :             : extern tree GTY(()) global_regs_decl[FIRST_PSEUDO_REGISTER];
    4570                 :             : 
    4571                 :             : /* Information about the function that is propagated by the RTL backend.
    4572                 :             :    Available only for functions that has been already assembled.  */
    4573                 :             : 
    4574                 :             : struct GTY(()) cgraph_rtl_info {
    4575                 :             :   unsigned int preferred_incoming_stack_boundary;
    4576                 :             : 
    4577                 :             :   /* Which registers the function clobbers, either directly or by
    4578                 :             :      calling another function.  */
    4579                 :             :   HARD_REG_SET function_used_regs;
    4580                 :             : };
    4581                 :             : 
    4582                 :             : /* If loads from memories of mode MODE always sign or zero extend,
    4583                 :             :    return SIGN_EXTEND or ZERO_EXTEND as appropriate.  Return UNKNOWN
    4584                 :             :    otherwise.  */
    4585                 :             : 
    4586                 :             : inline rtx_code
    4587                 :    18090897 : load_extend_op (machine_mode mode)
    4588                 :             : {
    4589                 :    18090897 :   scalar_int_mode int_mode;
    4590                 :    18090897 :   if (is_a <scalar_int_mode> (mode, &int_mode)
    4591                 :             :       && GET_MODE_PRECISION (int_mode) < BITS_PER_WORD)
    4592                 :             :     return LOAD_EXTEND_OP (int_mode);
    4593                 :             :   return UNKNOWN;
    4594                 :             : }
    4595                 :             : 
    4596                 :             : /* If X is a PLUS of a base and a constant offset, add the constant to *OFFSET
    4597                 :             :    and return the base.  Return X otherwise.  */
    4598                 :             : 
    4599                 :             : inline rtx
    4600                 :    98051574 : strip_offset_and_add (rtx x, poly_int64 *offset)
    4601                 :             : {
    4602                 :    98051574 :   if (GET_CODE (x) == PLUS)
    4603                 :             :     {
    4604                 :    50954443 :       poly_int64 suboffset;
    4605                 :    50954443 :       x = strip_offset (x, &suboffset);
    4606                 :   101908886 :       *offset = poly_uint64 (*offset) + suboffset;
    4607                 :             :     }
    4608                 :    98051574 :   return x;
    4609                 :             : }
    4610                 :             : 
    4611                 :             : /* Return true if X is an operation that always operates on the full
    4612                 :             :    registers for WORD_REGISTER_OPERATIONS architectures.  */
    4613                 :             : 
    4614                 :             : inline bool
    4615                 :             : word_register_operation_p (const_rtx x)
    4616                 :             : {
    4617                 :             :   switch (GET_CODE (x))
    4618                 :             :     {
    4619                 :             :     case CONST_INT:
    4620                 :             :     case ROTATE:
    4621                 :             :     case ROTATERT:
    4622                 :             :     case SIGN_EXTRACT:
    4623                 :             :     case ZERO_EXTRACT:
    4624                 :             :       return false;
    4625                 :             :     
    4626                 :             :     default:
    4627                 :             :       return true;
    4628                 :             :     }
    4629                 :             : }
    4630                 :             : 
    4631                 :             : /* Holds an rtx comparison to simplify passing many parameters pertaining to a
    4632                 :             :    single comparison.  */
    4633                 :             : 
    4634                 :             : struct rtx_comparison {
    4635                 :             :   rtx_code code;
    4636                 :             :   rtx op0, op1;
    4637                 :             :   machine_mode mode;
    4638                 :             : };
    4639                 :             : 
    4640                 :             : /* gtype-desc.cc.  */
    4641                 :             : extern void gt_ggc_mx (rtx &);
    4642                 :             : extern void gt_pch_nx (rtx &);
    4643                 :             : extern void gt_pch_nx (rtx &, gt_pointer_operator, void *);
    4644                 :             : 
    4645                 :             : #endif /* ! GCC_RTL_H */
        

Generated by: LCOV version 2.1-beta

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto,rust,m2 --enable-host-shared. GCC test suite is run with the built compiler.