LCOV - code coverage report
Current view: top level - gcc - tree.h (source / functions) Hit Total Coverage
Test: gcc.info Lines: 505 562 89.9 %
Date: 2020-04-04 11:58:09 Functions: 94 100 94.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Definitions for the ubiquitous 'tree' type for GNU compilers.
       2                 :            :    Copyright (C) 1989-2020 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_TREE_H
      21                 :            : #define GCC_TREE_H
      22                 :            : 
      23                 :            : #include "tree-core.h"
      24                 :            : 
      25                 :            : /* Convert a target-independent built-in function code to a combined_fn.  */
      26                 :            : 
      27                 :            : inline combined_fn
      28                 :   29260371 : as_combined_fn (built_in_function fn)
      29                 :            : {
      30                 :   29260371 :   return combined_fn (int (fn));
      31                 :            : }
      32                 :            : 
      33                 :            : /* Convert an internal function code to a combined_fn.  */
      34                 :            : 
      35                 :            : inline combined_fn
      36                 :    3384643 : as_combined_fn (internal_fn fn)
      37                 :            : {
      38                 :    3384643 :   return combined_fn (int (fn) + int (END_BUILTINS));
      39                 :            : }
      40                 :            : 
      41                 :            : /* Return true if CODE is a target-independent built-in function.  */
      42                 :            : 
      43                 :            : inline bool
      44                 :       8220 : builtin_fn_p (combined_fn code)
      45                 :            : {
      46                 :       6527 :   return int (code) < int (END_BUILTINS);
      47                 :            : }
      48                 :            : 
      49                 :            : /* Return the target-independent built-in function represented by CODE.
      50                 :            :    Only valid if builtin_fn_p (CODE).  */
      51                 :            : 
      52                 :            : inline built_in_function
      53                 :       5812 : as_builtin_fn (combined_fn code)
      54                 :            : {
      55                 :       5812 :   gcc_checking_assert (builtin_fn_p (code));
      56                 :       5812 :   return built_in_function (int (code));
      57                 :            : }
      58                 :            : 
      59                 :            : /* Return true if CODE is an internal function.  */
      60                 :            : 
      61                 :            : inline bool
      62                 :    9867954 : internal_fn_p (combined_fn code)
      63                 :            : {
      64                 :    8347231 :   return int (code) >= int (END_BUILTINS);
      65                 :            : }
      66                 :            : 
      67                 :            : /* Return the internal function represented by CODE.  Only valid if
      68                 :            :    internal_fn_p (CODE).  */
      69                 :            : 
      70                 :            : inline internal_fn
      71                 :    1522188 : as_internal_fn (combined_fn code)
      72                 :            : {
      73                 :      11698 :   gcc_checking_assert (internal_fn_p (code));
      74                 :    1522188 :   return internal_fn (int (code) - int (END_BUILTINS));
      75                 :            : }
      76                 :            : 
      77                 :            : /* Macros for initializing `tree_contains_struct'.  */
      78                 :            : #define MARK_TS_BASE(C)                                 \
      79                 :            :   (tree_contains_struct[C][TS_BASE] = true)
      80                 :            : 
      81                 :            : #define MARK_TS_TYPED(C)                                \
      82                 :            :   (MARK_TS_BASE (C),                                    \
      83                 :            :    tree_contains_struct[C][TS_TYPED] = true)
      84                 :            : 
      85                 :            : #define MARK_TS_COMMON(C)                               \
      86                 :            :   (MARK_TS_TYPED (C),                                   \
      87                 :            :    tree_contains_struct[C][TS_COMMON] = true)
      88                 :            : 
      89                 :            : #define MARK_TS_TYPE_COMMON(C)                          \
      90                 :            :   (MARK_TS_COMMON (C),                                  \
      91                 :            :    tree_contains_struct[C][TS_TYPE_COMMON] = true)
      92                 :            : 
      93                 :            : #define MARK_TS_TYPE_WITH_LANG_SPECIFIC(C)              \
      94                 :            :   (MARK_TS_TYPE_COMMON (C),                             \
      95                 :            :    tree_contains_struct[C][TS_TYPE_WITH_LANG_SPECIFIC] = true)
      96                 :            : 
      97                 :            : #define MARK_TS_TYPE_NON_COMMON(C)                      \
      98                 :            :   (MARK_TS_TYPE_WITH_LANG_SPECIFIC (C),                 \
      99                 :            :    tree_contains_struct[C][TS_TYPE_NON_COMMON] = true)  \
     100                 :            : 
     101                 :            : #define MARK_TS_DECL_MINIMAL(C)                         \
     102                 :            :   (MARK_TS_COMMON (C),                                  \
     103                 :            :    tree_contains_struct[C][TS_DECL_MINIMAL] = true)
     104                 :            : 
     105                 :            : #define MARK_TS_DECL_COMMON(C)                          \
     106                 :            :   (MARK_TS_DECL_MINIMAL (C),                            \
     107                 :            :    tree_contains_struct[C][TS_DECL_COMMON] = true)
     108                 :            : 
     109                 :            : #define MARK_TS_DECL_WRTL(C)                            \
     110                 :            :   (MARK_TS_DECL_COMMON (C),                             \
     111                 :            :    tree_contains_struct[C][TS_DECL_WRTL] = true)
     112                 :            : 
     113                 :            : #define MARK_TS_DECL_WITH_VIS(C)                        \
     114                 :            :   (MARK_TS_DECL_WRTL (C),                               \
     115                 :            :    tree_contains_struct[C][TS_DECL_WITH_VIS] = true)
     116                 :            : 
     117                 :            : #define MARK_TS_DECL_NON_COMMON(C)                      \
     118                 :            :   (MARK_TS_DECL_WITH_VIS (C),                           \
     119                 :            :    tree_contains_struct[C][TS_DECL_NON_COMMON] = true)
     120                 :            : 
     121                 :            : #define MARK_TS_EXP(C)                                  \
     122                 :            :   (MARK_TS_TYPED (C),                                   \
     123                 :            :    tree_contains_struct[C][TS_EXP] = true)
     124                 :            : 
     125                 :            : /* Returns the string representing CLASS.  */
     126                 :            : 
     127                 :            : #define TREE_CODE_CLASS_STRING(CLASS)\
     128                 :            :         tree_code_class_strings[(int) (CLASS)]
     129                 :            : 
     130                 :            : #define TREE_CODE_CLASS(CODE)   tree_code_type[(int) (CODE)]
     131                 :            : 
     132                 :            : /* Nonzero if NODE represents an exceptional code.  */
     133                 :            : 
     134                 :            : #define EXCEPTIONAL_CLASS_P(NODE)\
     135                 :            :         (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_exceptional)
     136                 :            : 
     137                 :            : /* Nonzero if NODE represents a constant.  */
     138                 :            : 
     139                 :            : #define CONSTANT_CLASS_P(NODE)\
     140                 :            :         (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_constant)
     141                 :            : 
     142                 :            : /* Nonzero if NODE represents a constant, or is a location wrapper
     143                 :            :    around such a node.  */
     144                 :            : 
     145                 :            : #define CONSTANT_CLASS_OR_WRAPPER_P(NODE)\
     146                 :            :         (CONSTANT_CLASS_P (tree_strip_any_location_wrapper (NODE)))
     147                 :            : 
     148                 :            : /* Nonzero if NODE represents a type.  */
     149                 :            : 
     150                 :            : #define TYPE_P(NODE)\
     151                 :            :         (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_type)
     152                 :            : 
     153                 :            : /* Nonzero if NODE represents a declaration.  */
     154                 :            : 
     155                 :            : #define DECL_P(NODE)\
     156                 :            :         (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_declaration)
     157                 :            : 
     158                 :            : /* True if NODE designates a variable declaration.  */
     159                 :            : #define VAR_P(NODE) \
     160                 :            :   (TREE_CODE (NODE) == VAR_DECL)
     161                 :            : 
     162                 :            : /* Nonzero if DECL represents a VAR_DECL or FUNCTION_DECL.  */
     163                 :            : 
     164                 :            : #define VAR_OR_FUNCTION_DECL_P(DECL)\
     165                 :            :   (TREE_CODE (DECL) == VAR_DECL || TREE_CODE (DECL) == FUNCTION_DECL)
     166                 :            : 
     167                 :            : /* Nonzero if NODE represents a INDIRECT_REF.  Keep these checks in
     168                 :            :    ascending code order.  */
     169                 :            : 
     170                 :            : #define INDIRECT_REF_P(NODE)\
     171                 :            :   (TREE_CODE (NODE) == INDIRECT_REF)
     172                 :            : 
     173                 :            : /* Nonzero if NODE represents a reference.  */
     174                 :            : 
     175                 :            : #define REFERENCE_CLASS_P(NODE)\
     176                 :            :         (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_reference)
     177                 :            : 
     178                 :            : /* Nonzero if NODE represents a comparison.  */
     179                 :            : 
     180                 :            : #define COMPARISON_CLASS_P(NODE)\
     181                 :            :         (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_comparison)
     182                 :            : 
     183                 :            : /* Nonzero if NODE represents a unary arithmetic expression.  */
     184                 :            : 
     185                 :            : #define UNARY_CLASS_P(NODE)\
     186                 :            :         (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_unary)
     187                 :            : 
     188                 :            : /* Nonzero if NODE represents a binary arithmetic expression.  */
     189                 :            : 
     190                 :            : #define BINARY_CLASS_P(NODE)\
     191                 :            :         (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_binary)
     192                 :            : 
     193                 :            : /* Nonzero if NODE represents a statement expression.  */
     194                 :            : 
     195                 :            : #define STATEMENT_CLASS_P(NODE)\
     196                 :            :         (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_statement)
     197                 :            : 
     198                 :            : /* Nonzero if NODE represents a function call-like expression with a
     199                 :            :    variable-length operand vector.  */
     200                 :            : 
     201                 :            : #define VL_EXP_CLASS_P(NODE)\
     202                 :            :         (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_vl_exp)
     203                 :            : 
     204                 :            : /* Nonzero if NODE represents any other expression.  */
     205                 :            : 
     206                 :            : #define EXPRESSION_CLASS_P(NODE)\
     207                 :            :         (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_expression)
     208                 :            : 
     209                 :            : /* Returns nonzero iff NODE represents a type or declaration.  */
     210                 :            : 
     211                 :            : #define IS_TYPE_OR_DECL_P(NODE)\
     212                 :            :         (TYPE_P (NODE) || DECL_P (NODE))
     213                 :            : 
     214                 :            : /* Returns nonzero iff CLASS is the tree-code class of an
     215                 :            :    expression.  */
     216                 :            : 
     217                 :            : #define IS_EXPR_CODE_CLASS(CLASS)\
     218                 :            :         ((CLASS) >= tcc_reference && (CLASS) <= tcc_expression)
     219                 :            : 
     220                 :            : /* Returns nonzero iff NODE is an expression of some kind.  */
     221                 :            : 
     222                 :            : #define EXPR_P(NODE) IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (NODE)))
     223                 :            : 
     224                 :            : #define TREE_CODE_LENGTH(CODE)  tree_code_length[(int) (CODE)]
     225                 :            : 
     226                 :            : 
     227                 :            : /* Helper macros for math builtins.  */
     228                 :            : 
     229                 :            : #define CASE_FLT_FN(FN) case FN: case FN##F: case FN##L
     230                 :            : #define CASE_FLT_FN_FLOATN_NX(FN)                          \
     231                 :            :   case FN##F16: case FN##F32: case FN##F64: case FN##F128: \
     232                 :            :   case FN##F32X: case FN##F64X: case FN##F128X
     233                 :            : #define CASE_FLT_FN_REENT(FN) case FN##_R: case FN##F_R: case FN##L_R
     234                 :            : #define CASE_INT_FN(FN) case FN: case FN##L: case FN##LL: case FN##IMAX
     235                 :            : 
     236                 :            : #define NULL_TREE (tree) NULL
     237                 :            : 
     238                 :            : /* Define accessors for the fields that all tree nodes have
     239                 :            :    (though some fields are not used for all kinds of nodes).  */
     240                 :            : 
     241                 :            : /* The tree-code says what kind of node it is.
     242                 :            :    Codes are defined in tree.def.  */
     243                 :            : #define TREE_CODE(NODE) ((enum tree_code) (NODE)->base.code)
     244                 :            : #define TREE_SET_CODE(NODE, VALUE) ((NODE)->base.code = (VALUE))
     245                 :            : 
     246                 :            : /* When checking is enabled, errors will be generated if a tree node
     247                 :            :    is accessed incorrectly. The macros die with a fatal error.  */
     248                 :            : #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
     249                 :            : 
     250                 :            : #define TREE_CHECK(T, CODE) \
     251                 :            : (tree_check ((T), __FILE__, __LINE__, __FUNCTION__, (CODE)))
     252                 :            : 
     253                 :            : #define TREE_NOT_CHECK(T, CODE) \
     254                 :            : (tree_not_check ((T), __FILE__, __LINE__, __FUNCTION__, (CODE)))
     255                 :            : 
     256                 :            : #define TREE_CHECK2(T, CODE1, CODE2) \
     257                 :            : (tree_check2 ((T), __FILE__, __LINE__, __FUNCTION__, (CODE1), (CODE2)))
     258                 :            : 
     259                 :            : #define TREE_NOT_CHECK2(T, CODE1, CODE2) \
     260                 :            : (tree_not_check2 ((T), __FILE__, __LINE__, __FUNCTION__, (CODE1), (CODE2)))
     261                 :            : 
     262                 :            : #define TREE_CHECK3(T, CODE1, CODE2, CODE3) \
     263                 :            : (tree_check3 ((T), __FILE__, __LINE__, __FUNCTION__, (CODE1), (CODE2), (CODE3)))
     264                 :            : 
     265                 :            : #define TREE_NOT_CHECK3(T, CODE1, CODE2, CODE3) \
     266                 :            : (tree_not_check3 ((T), __FILE__, __LINE__, __FUNCTION__, \
     267                 :            :                                (CODE1), (CODE2), (CODE3)))
     268                 :            : 
     269                 :            : #define TREE_CHECK4(T, CODE1, CODE2, CODE3, CODE4) \
     270                 :            : (tree_check4 ((T), __FILE__, __LINE__, __FUNCTION__, \
     271                 :            :                            (CODE1), (CODE2), (CODE3), (CODE4)))
     272                 :            : 
     273                 :            : #define TREE_NOT_CHECK4(T, CODE1, CODE2, CODE3, CODE4) \
     274                 :            : (tree_not_check4 ((T), __FILE__, __LINE__, __FUNCTION__, \
     275                 :            :                                (CODE1), (CODE2), (CODE3), (CODE4)))
     276                 :            : 
     277                 :            : #define TREE_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) \
     278                 :            : (tree_check5 ((T), __FILE__, __LINE__, __FUNCTION__, \
     279                 :            :                            (CODE1), (CODE2), (CODE3), (CODE4), (CODE5)))
     280                 :            : 
     281                 :            : #define TREE_NOT_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) \
     282                 :            : (tree_not_check5 ((T), __FILE__, __LINE__, __FUNCTION__, \
     283                 :            :                                (CODE1), (CODE2), (CODE3), (CODE4), (CODE5)))
     284                 :            : 
     285                 :            : #define CONTAINS_STRUCT_CHECK(T, STRUCT) \
     286                 :            : (contains_struct_check ((T), (STRUCT), __FILE__, __LINE__, __FUNCTION__))
     287                 :            : 
     288                 :            : #define TREE_CLASS_CHECK(T, CLASS) \
     289                 :            : (tree_class_check ((T), (CLASS), __FILE__, __LINE__, __FUNCTION__))
     290                 :            : 
     291                 :            : #define TREE_RANGE_CHECK(T, CODE1, CODE2) \
     292                 :            : (tree_range_check ((T), (CODE1), (CODE2), __FILE__, __LINE__, __FUNCTION__))
     293                 :            : 
     294                 :            : #define OMP_CLAUSE_SUBCODE_CHECK(T, CODE) \
     295                 :            : (omp_clause_subcode_check ((T), (CODE), __FILE__, __LINE__, __FUNCTION__))
     296                 :            : 
     297                 :            : #define OMP_CLAUSE_RANGE_CHECK(T, CODE1, CODE2) \
     298                 :            : (omp_clause_range_check ((T), (CODE1), (CODE2), \
     299                 :            :                                       __FILE__, __LINE__, __FUNCTION__))
     300                 :            : 
     301                 :            : /* These checks have to be special cased.  */
     302                 :            : #define EXPR_CHECK(T) \
     303                 :            : (expr_check ((T), __FILE__, __LINE__, __FUNCTION__))
     304                 :            : 
     305                 :            : /* These checks have to be special cased.  */
     306                 :            : #define NON_TYPE_CHECK(T) \
     307                 :            : (non_type_check ((T), __FILE__, __LINE__, __FUNCTION__))
     308                 :            : 
     309                 :            : /* These checks have to be special cased.  */
     310                 :            : #define ANY_INTEGRAL_TYPE_CHECK(T) \
     311                 :            : (any_integral_type_check ((T), __FILE__, __LINE__, __FUNCTION__))
     312                 :            : 
     313                 :            : #define TREE_INT_CST_ELT_CHECK(T, I) \
     314                 :            : (*tree_int_cst_elt_check ((T), (I), __FILE__, __LINE__, __FUNCTION__))
     315                 :            : 
     316                 :            : #define TREE_VEC_ELT_CHECK(T, I) \
     317                 :            : (*(CONST_CAST2 (tree *, typeof (T)*, \
     318                 :            :      tree_vec_elt_check ((T), (I), __FILE__, __LINE__, __FUNCTION__))))
     319                 :            : 
     320                 :            : #define OMP_CLAUSE_ELT_CHECK(T, I) \
     321                 :            : (*(omp_clause_elt_check ((T), (I), __FILE__, __LINE__, __FUNCTION__)))
     322                 :            : 
     323                 :            : /* Special checks for TREE_OPERANDs.  */
     324                 :            : #define TREE_OPERAND_CHECK(T, I) \
     325                 :            : (*(CONST_CAST2 (tree*, typeof (T)*, \
     326                 :            :      tree_operand_check ((T), (I), __FILE__, __LINE__, __FUNCTION__))))
     327                 :            : 
     328                 :            : #define TREE_OPERAND_CHECK_CODE(T, CODE, I) \
     329                 :            : (*(tree_operand_check_code ((T), (CODE), (I), \
     330                 :            :                                          __FILE__, __LINE__, __FUNCTION__)))
     331                 :            : 
     332                 :            : /* Nodes are chained together for many purposes.
     333                 :            :    Types are chained together to record them for being output to the debugger
     334                 :            :    (see the function `chain_type').
     335                 :            :    Decls in the same scope are chained together to record the contents
     336                 :            :    of the scope.
     337                 :            :    Statement nodes for successive statements used to be chained together.
     338                 :            :    Often lists of things are represented by TREE_LIST nodes that
     339                 :            :    are chained together.  */
     340                 :            : 
     341                 :            : #define TREE_CHAIN(NODE) \
     342                 :            : (CONTAINS_STRUCT_CHECK (NODE, TS_COMMON)->common.chain)
     343                 :            : 
     344                 :            : /* In all nodes that are expressions, this is the data type of the expression.
     345                 :            :    In POINTER_TYPE nodes, this is the type that the pointer points to.
     346                 :            :    In ARRAY_TYPE nodes, this is the type of the elements.
     347                 :            :    In VECTOR_TYPE nodes, this is the type of the elements.  */
     348                 :            : #define TREE_TYPE(NODE) \
     349                 :            : (CONTAINS_STRUCT_CHECK (NODE, TS_TYPED)->typed.type)
     350                 :            : 
     351                 :            : extern void tree_contains_struct_check_failed (const_tree,
     352                 :            :                                                const enum tree_node_structure_enum,
     353                 :            :                                                const char *, int, const char *)
     354                 :            :   ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
     355                 :            : 
     356                 :            : extern void tree_check_failed (const_tree, const char *, int, const char *,
     357                 :            :                                ...) ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
     358                 :            : extern void tree_not_check_failed (const_tree, const char *, int, const char *,
     359                 :            :                                    ...) ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
     360                 :            : extern void tree_class_check_failed (const_tree, const enum tree_code_class,
     361                 :            :                                      const char *, int, const char *)
     362                 :            :     ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
     363                 :            : extern void tree_range_check_failed (const_tree, const char *, int,
     364                 :            :                                      const char *, enum tree_code,
     365                 :            :                                      enum tree_code)
     366                 :            :     ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
     367                 :            : extern void tree_not_class_check_failed (const_tree,
     368                 :            :                                          const enum tree_code_class,
     369                 :            :                                          const char *, int, const char *)
     370                 :            :     ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
     371                 :            : extern void tree_int_cst_elt_check_failed (int, int, const char *,
     372                 :            :                                            int, const char *)
     373                 :            :     ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
     374                 :            : extern void tree_vec_elt_check_failed (int, int, const char *,
     375                 :            :                                        int, const char *)
     376                 :            :     ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
     377                 :            : extern void phi_node_elt_check_failed (int, int, const char *,
     378                 :            :                                        int, const char *)
     379                 :            :     ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
     380                 :            : extern void tree_operand_check_failed (int, const_tree,
     381                 :            :                                        const char *, int, const char *)
     382                 :            :     ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
     383                 :            : extern void omp_clause_check_failed (const_tree, const char *, int,
     384                 :            :                                      const char *, enum omp_clause_code)
     385                 :            :     ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
     386                 :            : extern void omp_clause_operand_check_failed (int, const_tree, const char *,
     387                 :            :                                              int, const char *)
     388                 :            :     ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
     389                 :            : extern void omp_clause_range_check_failed (const_tree, const char *, int,
     390                 :            :                                const char *, enum omp_clause_code,
     391                 :            :                                enum omp_clause_code)
     392                 :            :     ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
     393                 :            : 
     394                 :            : #else /* not ENABLE_TREE_CHECKING, or not gcc */
     395                 :            : 
     396                 :            : #define CONTAINS_STRUCT_CHECK(T, ENUM)          (T)
     397                 :            : #define TREE_CHECK(T, CODE)                     (T)
     398                 :            : #define TREE_NOT_CHECK(T, CODE)                 (T)
     399                 :            : #define TREE_CHECK2(T, CODE1, CODE2)            (T)
     400                 :            : #define TREE_NOT_CHECK2(T, CODE1, CODE2)        (T)
     401                 :            : #define TREE_CHECK3(T, CODE1, CODE2, CODE3)     (T)
     402                 :            : #define TREE_NOT_CHECK3(T, CODE1, CODE2, CODE3) (T)
     403                 :            : #define TREE_CHECK4(T, CODE1, CODE2, CODE3, CODE4) (T)
     404                 :            : #define TREE_NOT_CHECK4(T, CODE1, CODE2, CODE3, CODE4) (T)
     405                 :            : #define TREE_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) (T)
     406                 :            : #define TREE_NOT_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) (T)
     407                 :            : #define TREE_CLASS_CHECK(T, CODE)               (T)
     408                 :            : #define TREE_RANGE_CHECK(T, CODE1, CODE2)       (T)
     409                 :            : #define EXPR_CHECK(T)                           (T)
     410                 :            : #define NON_TYPE_CHECK(T)                       (T)
     411                 :            : #define TREE_INT_CST_ELT_CHECK(T, I)            ((T)->int_cst.val[I])
     412                 :            : #define TREE_VEC_ELT_CHECK(T, I)                ((T)->vec.a[I])
     413                 :            : #define TREE_OPERAND_CHECK(T, I)                ((T)->exp.operands[I])
     414                 :            : #define TREE_OPERAND_CHECK_CODE(T, CODE, I)     ((T)->exp.operands[I])
     415                 :            : #define OMP_CLAUSE_ELT_CHECK(T, i)              ((T)->omp_clause.ops[i])
     416                 :            : #define OMP_CLAUSE_RANGE_CHECK(T, CODE1, CODE2) (T)
     417                 :            : #define OMP_CLAUSE_SUBCODE_CHECK(T, CODE)       (T)
     418                 :            : #define ANY_INTEGRAL_TYPE_CHECK(T)              (T)
     419                 :            : 
     420                 :            : #define TREE_CHAIN(NODE) ((NODE)->common.chain)
     421                 :            : #define TREE_TYPE(NODE) ((NODE)->typed.type)
     422                 :            : 
     423                 :            : #endif
     424                 :            : 
     425                 :            : #define TREE_BLOCK(NODE)                (tree_block (NODE))
     426                 :            : #define TREE_SET_BLOCK(T, B)            (tree_set_block ((T), (B)))
     427                 :            : 
     428                 :            : #include "tree-check.h"
     429                 :            : 
     430                 :            : #define TYPE_CHECK(T)           TREE_CLASS_CHECK (T, tcc_type)
     431                 :            : #define DECL_MINIMAL_CHECK(T)   CONTAINS_STRUCT_CHECK (T, TS_DECL_MINIMAL)
     432                 :            : #define DECL_COMMON_CHECK(T)    CONTAINS_STRUCT_CHECK (T, TS_DECL_COMMON)
     433                 :            : #define DECL_WRTL_CHECK(T)      CONTAINS_STRUCT_CHECK (T, TS_DECL_WRTL)
     434                 :            : #define DECL_WITH_VIS_CHECK(T)  CONTAINS_STRUCT_CHECK (T, TS_DECL_WITH_VIS)
     435                 :            : #define DECL_NON_COMMON_CHECK(T) CONTAINS_STRUCT_CHECK (T, TS_DECL_NON_COMMON)
     436                 :            : #define CST_CHECK(T)            TREE_CLASS_CHECK (T, tcc_constant)
     437                 :            : #define STMT_CHECK(T)           TREE_CLASS_CHECK (T, tcc_statement)
     438                 :            : #define VL_EXP_CHECK(T)         TREE_CLASS_CHECK (T, tcc_vl_exp)
     439                 :            : #define FUNC_OR_METHOD_CHECK(T) TREE_CHECK2 (T, FUNCTION_TYPE, METHOD_TYPE)
     440                 :            : #define PTR_OR_REF_CHECK(T)     TREE_CHECK2 (T, POINTER_TYPE, REFERENCE_TYPE)
     441                 :            : 
     442                 :            : #define RECORD_OR_UNION_CHECK(T)        \
     443                 :            :   TREE_CHECK3 (T, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE)
     444                 :            : #define NOT_RECORD_OR_UNION_CHECK(T) \
     445                 :            :   TREE_NOT_CHECK3 (T, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE)
     446                 :            : #define ARRAY_OR_INTEGER_TYPE_CHECK(T)  \
     447                 :            :   TREE_CHECK2 (T, ARRAY_TYPE, INTEGER_TYPE)
     448                 :            : 
     449                 :            : #define NUMERICAL_TYPE_CHECK(T)                                 \
     450                 :            :   TREE_CHECK5 (T, INTEGER_TYPE, ENUMERAL_TYPE, BOOLEAN_TYPE, REAL_TYPE, \
     451                 :            :                FIXED_POINT_TYPE)
     452                 :            : 
     453                 :            : /* Here is how primitive or already-canonicalized types' hash codes
     454                 :            :    are made.  */
     455                 :            : #define TYPE_HASH(TYPE) (TYPE_UID (TYPE))
     456                 :            : 
     457                 :            : /* A simple hash function for an arbitrary tree node.  This must not be
     458                 :            :    used in hash tables which are saved to a PCH.  */
     459                 :            : #define TREE_HASH(NODE) ((size_t) (NODE) & 0777777)
     460                 :            : 
     461                 :            : /* Tests if CODE is a conversion expr (NOP_EXPR or CONVERT_EXPR).  */
     462                 :            : #define CONVERT_EXPR_CODE_P(CODE)                               \
     463                 :            :   ((CODE) == NOP_EXPR || (CODE) == CONVERT_EXPR)
     464                 :            : 
     465                 :            : /* Similarly, but accept an expression instead of a tree code.  */
     466                 :            : #define CONVERT_EXPR_P(EXP)     CONVERT_EXPR_CODE_P (TREE_CODE (EXP))
     467                 :            : 
     468                 :            : /* Generate case for NOP_EXPR, CONVERT_EXPR.  */
     469                 :            : 
     470                 :            : #define CASE_CONVERT                                            \
     471                 :            :   case NOP_EXPR:                                                \
     472                 :            :   case CONVERT_EXPR
     473                 :            : 
     474                 :            : /* Given an expression as a tree, strip any conversion that generates
     475                 :            :    no instruction.  Accepts both tree and const_tree arguments since
     476                 :            :    we are not modifying the tree itself.  */
     477                 :            : 
     478                 :            : #define STRIP_NOPS(EXP) \
     479                 :            :   (EXP) = tree_strip_nop_conversions (CONST_CAST_TREE (EXP))
     480                 :            : 
     481                 :            : /* Like STRIP_NOPS, but don't let the signedness change either.  */
     482                 :            : 
     483                 :            : #define STRIP_SIGN_NOPS(EXP) \
     484                 :            :   (EXP) = tree_strip_sign_nop_conversions (CONST_CAST_TREE (EXP))
     485                 :            : 
     486                 :            : /* Like STRIP_NOPS, but don't alter the TREE_TYPE either.  */
     487                 :            : 
     488                 :            : #define STRIP_TYPE_NOPS(EXP) \
     489                 :            :   while ((CONVERT_EXPR_P (EXP)                                  \
     490                 :            :           || TREE_CODE (EXP) == NON_LVALUE_EXPR)                \
     491                 :            :          && TREE_OPERAND (EXP, 0) != error_mark_node            \
     492                 :            :          && (TREE_TYPE (EXP)                                    \
     493                 :            :              == TREE_TYPE (TREE_OPERAND (EXP, 0))))             \
     494                 :            :     (EXP) = TREE_OPERAND (EXP, 0)
     495                 :            : 
     496                 :            : /* Remove unnecessary type conversions according to
     497                 :            :    tree_ssa_useless_type_conversion.  */
     498                 :            : 
     499                 :            : #define STRIP_USELESS_TYPE_CONVERSION(EXP) \
     500                 :            :   (EXP) = tree_ssa_strip_useless_type_conversions (EXP)
     501                 :            : 
     502                 :            : /* Remove any VIEW_CONVERT_EXPR or NON_LVALUE_EXPR that's purely
     503                 :            :    in use to provide a location_t.  */
     504                 :            : 
     505                 :            : #define STRIP_ANY_LOCATION_WRAPPER(EXP) \
     506                 :            :   (EXP) = tree_strip_any_location_wrapper (CONST_CAST_TREE (EXP))
     507                 :            : 
     508                 :            : /* Nonzero if TYPE represents a vector type.  */
     509                 :            : 
     510                 :            : #define VECTOR_TYPE_P(TYPE) (TREE_CODE (TYPE) == VECTOR_TYPE)
     511                 :            : 
     512                 :            : /* Nonzero if TYPE represents a vector of booleans.  */
     513                 :            : 
     514                 :            : #define VECTOR_BOOLEAN_TYPE_P(TYPE)                             \
     515                 :            :   (TREE_CODE (TYPE) == VECTOR_TYPE                      \
     516                 :            :    && TREE_CODE (TREE_TYPE (TYPE)) == BOOLEAN_TYPE)
     517                 :            : 
     518                 :            : /* Nonzero if TYPE represents an integral type.  Note that we do not
     519                 :            :    include COMPLEX types here.  Keep these checks in ascending code
     520                 :            :    order.  */
     521                 :            : 
     522                 :            : #define INTEGRAL_TYPE_P(TYPE)  \
     523                 :            :   (TREE_CODE (TYPE) == ENUMERAL_TYPE  \
     524                 :            :    || TREE_CODE (TYPE) == BOOLEAN_TYPE \
     525                 :            :    || TREE_CODE (TYPE) == INTEGER_TYPE)
     526                 :            : 
     527                 :            : /* Nonzero if TYPE represents an integral type, including complex
     528                 :            :    and vector integer types.  */
     529                 :            : 
     530                 :            : #define ANY_INTEGRAL_TYPE_P(TYPE)               \
     531                 :            :   (INTEGRAL_TYPE_P (TYPE)                       \
     532                 :            :    || ((TREE_CODE (TYPE) == COMPLEX_TYPE        \
     533                 :            :         || VECTOR_TYPE_P (TYPE))                \
     534                 :            :        && INTEGRAL_TYPE_P (TREE_TYPE (TYPE))))
     535                 :            : 
     536                 :            : /* Nonzero if TYPE represents a non-saturating fixed-point type.  */
     537                 :            : 
     538                 :            : #define NON_SAT_FIXED_POINT_TYPE_P(TYPE) \
     539                 :            :   (TREE_CODE (TYPE) == FIXED_POINT_TYPE && !TYPE_SATURATING (TYPE))
     540                 :            : 
     541                 :            : /* Nonzero if TYPE represents a saturating fixed-point type.  */
     542                 :            : 
     543                 :            : #define SAT_FIXED_POINT_TYPE_P(TYPE) \
     544                 :            :   (TREE_CODE (TYPE) == FIXED_POINT_TYPE && TYPE_SATURATING (TYPE))
     545                 :            : 
     546                 :            : /* Nonzero if TYPE represents a fixed-point type.  */
     547                 :            : 
     548                 :            : #define FIXED_POINT_TYPE_P(TYPE)        (TREE_CODE (TYPE) == FIXED_POINT_TYPE)
     549                 :            : 
     550                 :            : /* Nonzero if TYPE represents a scalar floating-point type.  */
     551                 :            : 
     552                 :            : #define SCALAR_FLOAT_TYPE_P(TYPE) (TREE_CODE (TYPE) == REAL_TYPE)
     553                 :            : 
     554                 :            : /* Nonzero if TYPE represents a complex floating-point type.  */
     555                 :            : 
     556                 :            : #define COMPLEX_FLOAT_TYPE_P(TYPE)      \
     557                 :            :   (TREE_CODE (TYPE) == COMPLEX_TYPE     \
     558                 :            :    && TREE_CODE (TREE_TYPE (TYPE)) == REAL_TYPE)
     559                 :            : 
     560                 :            : /* Nonzero if TYPE represents a vector integer type.  */
     561                 :            :                 
     562                 :            : #define VECTOR_INTEGER_TYPE_P(TYPE)                     \
     563                 :            :   (VECTOR_TYPE_P (TYPE)                                 \
     564                 :            :    && TREE_CODE (TREE_TYPE (TYPE)) == INTEGER_TYPE)
     565                 :            : 
     566                 :            : 
     567                 :            : /* Nonzero if TYPE represents a vector floating-point type.  */
     568                 :            : 
     569                 :            : #define VECTOR_FLOAT_TYPE_P(TYPE)       \
     570                 :            :   (VECTOR_TYPE_P (TYPE)                 \
     571                 :            :    && TREE_CODE (TREE_TYPE (TYPE)) == REAL_TYPE)
     572                 :            : 
     573                 :            : /* Nonzero if TYPE represents a floating-point type, including complex
     574                 :            :    and vector floating-point types.  The vector and complex check does
     575                 :            :    not use the previous two macros to enable early folding.  */
     576                 :            : 
     577                 :            : #define FLOAT_TYPE_P(TYPE)                      \
     578                 :            :   (SCALAR_FLOAT_TYPE_P (TYPE)                   \
     579                 :            :    || ((TREE_CODE (TYPE) == COMPLEX_TYPE        \
     580                 :            :         || VECTOR_TYPE_P (TYPE))                \
     581                 :            :        && SCALAR_FLOAT_TYPE_P (TREE_TYPE (TYPE))))
     582                 :            : 
     583                 :            : /* Nonzero if TYPE represents a decimal floating-point type.  */
     584                 :            : #define DECIMAL_FLOAT_TYPE_P(TYPE)              \
     585                 :            :   (SCALAR_FLOAT_TYPE_P (TYPE)                   \
     586                 :            :    && DECIMAL_FLOAT_MODE_P (TYPE_MODE (TYPE)))
     587                 :            : 
     588                 :            : /* Nonzero if TYPE is a record or union type.  */
     589                 :            : #define RECORD_OR_UNION_TYPE_P(TYPE)            \
     590                 :            :   (TREE_CODE (TYPE) == RECORD_TYPE              \
     591                 :            :    || TREE_CODE (TYPE) == UNION_TYPE            \
     592                 :            :    || TREE_CODE (TYPE) == QUAL_UNION_TYPE)
     593                 :            : 
     594                 :            : /* Nonzero if TYPE represents an aggregate (multi-component) type.
     595                 :            :    Keep these checks in ascending code order.  */
     596                 :            : 
     597                 :            : #define AGGREGATE_TYPE_P(TYPE) \
     598                 :            :   (TREE_CODE (TYPE) == ARRAY_TYPE || RECORD_OR_UNION_TYPE_P (TYPE))
     599                 :            : 
     600                 :            : /* Nonzero if TYPE represents a pointer or reference type.
     601                 :            :    (It should be renamed to INDIRECT_TYPE_P.)  Keep these checks in
     602                 :            :    ascending code order.  */
     603                 :            : 
     604                 :            : #define POINTER_TYPE_P(TYPE) \
     605                 :            :   (TREE_CODE (TYPE) == POINTER_TYPE || TREE_CODE (TYPE) == REFERENCE_TYPE)
     606                 :            : 
     607                 :            : /* Nonzero if TYPE represents a pointer to function.  */
     608                 :            : #define FUNCTION_POINTER_TYPE_P(TYPE) \
     609                 :            :   (POINTER_TYPE_P (TYPE) && TREE_CODE (TREE_TYPE (TYPE)) == FUNCTION_TYPE)
     610                 :            : 
     611                 :            : /* Nonzero if this type is a complete type.  */
     612                 :            : #define COMPLETE_TYPE_P(NODE) (TYPE_SIZE (NODE) != NULL_TREE)
     613                 :            : 
     614                 :            : /* Nonzero if this type is the (possibly qualified) void type.  */
     615                 :            : #define VOID_TYPE_P(NODE) (TREE_CODE (NODE) == VOID_TYPE)
     616                 :            : 
     617                 :            : /* Nonzero if this type is complete or is cv void.  */
     618                 :            : #define COMPLETE_OR_VOID_TYPE_P(NODE) \
     619                 :            :   (COMPLETE_TYPE_P (NODE) || VOID_TYPE_P (NODE))
     620                 :            : 
     621                 :            : /* Nonzero if this type is complete or is an array with unspecified bound.  */
     622                 :            : #define COMPLETE_OR_UNBOUND_ARRAY_TYPE_P(NODE) \
     623                 :            :   (COMPLETE_TYPE_P (TREE_CODE (NODE) == ARRAY_TYPE ? TREE_TYPE (NODE) : (NODE)))
     624                 :            : 
     625                 :            : #define FUNC_OR_METHOD_TYPE_P(NODE) \
     626                 :            :   (TREE_CODE (NODE) == FUNCTION_TYPE || TREE_CODE (NODE) == METHOD_TYPE)
     627                 :            : 
     628                 :            : /* Define many boolean fields that all tree nodes have.  */
     629                 :            : 
     630                 :            : /* In VAR_DECL, PARM_DECL and RESULT_DECL nodes, nonzero means address
     631                 :            :    of this is needed.  So it cannot be in a register.
     632                 :            :    In a FUNCTION_DECL it has no meaning.
     633                 :            :    In LABEL_DECL nodes, it means a goto for this label has been seen
     634                 :            :    from a place outside all binding contours that restore stack levels.
     635                 :            :    In an artificial SSA_NAME that points to a stack partition with at least
     636                 :            :    two variables, it means that at least one variable has TREE_ADDRESSABLE.
     637                 :            :    In ..._TYPE nodes, it means that objects of this type must be fully
     638                 :            :    addressable.  This means that pieces of this object cannot go into
     639                 :            :    register parameters, for example.  If this a function type, this
     640                 :            :    means that the value must be returned in memory.
     641                 :            :    In CONSTRUCTOR nodes, it means object constructed must be in memory.
     642                 :            :    In IDENTIFIER_NODEs, this means that some extern decl for this name
     643                 :            :    had its address taken.  That matters for inline functions.
     644                 :            :    In a STMT_EXPR, it means we want the result of the enclosed expression.  */
     645                 :            : #define TREE_ADDRESSABLE(NODE) ((NODE)->base.addressable_flag)
     646                 :            : 
     647                 :            : /* Set on a CALL_EXPR if the call is in a tail position, ie. just before the
     648                 :            :    exit of a function.  Calls for which this is true are candidates for tail
     649                 :            :    call optimizations.  */
     650                 :            : #define CALL_EXPR_TAILCALL(NODE) \
     651                 :            :   (CALL_EXPR_CHECK (NODE)->base.addressable_flag)
     652                 :            : 
     653                 :            : /* Set on a CALL_EXPR if the call has been marked as requiring tail call
     654                 :            :    optimization for correctness.  */
     655                 :            : #define CALL_EXPR_MUST_TAIL_CALL(NODE) \
     656                 :            :   (CALL_EXPR_CHECK (NODE)->base.static_flag)
     657                 :            : 
     658                 :            : /* Used as a temporary field on a CASE_LABEL_EXPR to indicate that the
     659                 :            :    CASE_LOW operand has been processed.  */
     660                 :            : #define CASE_LOW_SEEN(NODE) \
     661                 :            :   (CASE_LABEL_EXPR_CHECK (NODE)->base.addressable_flag)
     662                 :            : 
     663                 :            : #define PREDICT_EXPR_OUTCOME(NODE) \
     664                 :            :   ((enum prediction) (PREDICT_EXPR_CHECK (NODE)->base.addressable_flag))
     665                 :            : #define SET_PREDICT_EXPR_OUTCOME(NODE, OUTCOME) \
     666                 :            :   (PREDICT_EXPR_CHECK (NODE)->base.addressable_flag = (int) OUTCOME)
     667                 :            : #define PREDICT_EXPR_PREDICTOR(NODE) \
     668                 :            :   ((enum br_predictor)tree_to_shwi (TREE_OPERAND (PREDICT_EXPR_CHECK (NODE), 0)))
     669                 :            : 
     670                 :            : /* In a VAR_DECL, nonzero means allocate static storage.
     671                 :            :    In a FUNCTION_DECL, nonzero if function has been defined.
     672                 :            :    In a CONSTRUCTOR, nonzero means allocate static storage.  */
     673                 :            : #define TREE_STATIC(NODE) ((NODE)->base.static_flag)
     674                 :            : 
     675                 :            : /* In an ADDR_EXPR, nonzero means do not use a trampoline.  */
     676                 :            : #define TREE_NO_TRAMPOLINE(NODE) (ADDR_EXPR_CHECK (NODE)->base.static_flag)
     677                 :            : 
     678                 :            : /* In a TARGET_EXPR or WITH_CLEANUP_EXPR, means that the pertinent cleanup
     679                 :            :    should only be executed if an exception is thrown, not on normal exit
     680                 :            :    of its scope.  */
     681                 :            : #define CLEANUP_EH_ONLY(NODE) ((NODE)->base.static_flag)
     682                 :            : 
     683                 :            : /* In a TRY_CATCH_EXPR, means that the handler should be considered a
     684                 :            :    separate cleanup in honor_protect_cleanup_actions.  */
     685                 :            : #define TRY_CATCH_IS_CLEANUP(NODE) \
     686                 :            :   (TRY_CATCH_EXPR_CHECK (NODE)->base.static_flag)
     687                 :            : 
     688                 :            : /* Used as a temporary field on a CASE_LABEL_EXPR to indicate that the
     689                 :            :    CASE_HIGH operand has been processed.  */
     690                 :            : #define CASE_HIGH_SEEN(NODE) \
     691                 :            :   (CASE_LABEL_EXPR_CHECK (NODE)->base.static_flag)
     692                 :            : 
     693                 :            : /* Used to mark scoped enums.  */
     694                 :            : #define ENUM_IS_SCOPED(NODE) (ENUMERAL_TYPE_CHECK (NODE)->base.static_flag)
     695                 :            : 
     696                 :            : /* Determines whether an ENUMERAL_TYPE has defined the list of constants. */
     697                 :            : #define ENUM_IS_OPAQUE(NODE) (ENUMERAL_TYPE_CHECK (NODE)->base.private_flag)
     698                 :            : 
     699                 :            : /* In an expr node (usually a conversion) this means the node was made
     700                 :            :    implicitly and should not lead to any sort of warning.  In a decl node,
     701                 :            :    warnings concerning the decl should be suppressed.  This is used at
     702                 :            :    least for used-before-set warnings, and it set after one warning is
     703                 :            :    emitted.  */
     704                 :            : #define TREE_NO_WARNING(NODE) ((NODE)->base.nowarning_flag)
     705                 :            : 
     706                 :            : /* Nonzero if we should warn about the change in empty class parameter
     707                 :            :    passing ABI in this TU.  */
     708                 :            : #define TRANSLATION_UNIT_WARN_EMPTY_P(NODE) \
     709                 :            :   (TRANSLATION_UNIT_DECL_CHECK (NODE)->decl_common.decl_flag_0)
     710                 :            : 
     711                 :            : /* Nonzero if this type is "empty" according to the particular psABI.  */
     712                 :            : #define TYPE_EMPTY_P(NODE) (TYPE_CHECK (NODE)->type_common.empty_flag)
     713                 :            : 
     714                 :            : /* Used to indicate that this TYPE represents a compiler-generated entity.  */
     715                 :            : #define TYPE_ARTIFICIAL(NODE) (TYPE_CHECK (NODE)->base.nowarning_flag)
     716                 :            : 
     717                 :            : /* True if the type is indivisible at the source level, i.e. if its
     718                 :            :    component parts cannot be accessed directly.  This is used to suppress
     719                 :            :    normal GNU extensions for target-specific vector types.  */
     720                 :            : #define TYPE_INDIVISIBLE_P(NODE) (TYPE_CHECK (NODE)->type_common.indivisible_p)
     721                 :            : 
     722                 :            : /* In an IDENTIFIER_NODE, this means that assemble_name was called with
     723                 :            :    this string as an argument.  */
     724                 :            : #define TREE_SYMBOL_REFERENCED(NODE) \
     725                 :            :   (IDENTIFIER_NODE_CHECK (NODE)->base.static_flag)
     726                 :            : 
     727                 :            : /* Nonzero in a pointer or reference type means the data pointed to
     728                 :            :    by this type can alias anything.  */
     729                 :            : #define TYPE_REF_CAN_ALIAS_ALL(NODE) \
     730                 :            :   (PTR_OR_REF_CHECK (NODE)->base.static_flag)
     731                 :            : 
     732                 :            : /* In an INTEGER_CST, REAL_CST, COMPLEX_CST, or VECTOR_CST, this means
     733                 :            :    there was an overflow in folding.  */
     734                 :            : 
     735                 :            : #define TREE_OVERFLOW(NODE) (CST_CHECK (NODE)->base.public_flag)
     736                 :            : 
     737                 :            : /* TREE_OVERFLOW can only be true for EXPR of CONSTANT_CLASS_P.  */
     738                 :            : 
     739                 :            : #define TREE_OVERFLOW_P(EXPR) \
     740                 :            :  (CONSTANT_CLASS_P (EXPR) && TREE_OVERFLOW (EXPR))
     741                 :            : 
     742                 :            : /* In a VAR_DECL, FUNCTION_DECL, NAMESPACE_DECL or TYPE_DECL,
     743                 :            :    nonzero means name is to be accessible from outside this translation unit.
     744                 :            :    In an IDENTIFIER_NODE, nonzero means an external declaration
     745                 :            :    accessible from outside this translation unit was previously seen
     746                 :            :    for this name in an inner scope.  */
     747                 :            : #define TREE_PUBLIC(NODE) ((NODE)->base.public_flag)
     748                 :            : 
     749                 :            : /* In a _TYPE, indicates whether TYPE_CACHED_VALUES contains a vector
     750                 :            :    of cached values, or is something else.  */
     751                 :            : #define TYPE_CACHED_VALUES_P(NODE) (TYPE_CHECK (NODE)->base.public_flag)
     752                 :            : 
     753                 :            : /* In a SAVE_EXPR, indicates that the original expression has already
     754                 :            :    been substituted with a VAR_DECL that contains the value.  */
     755                 :            : #define SAVE_EXPR_RESOLVED_P(NODE) \
     756                 :            :   (SAVE_EXPR_CHECK (NODE)->base.public_flag)
     757                 :            : 
     758                 :            : /* Set on a CALL_EXPR if this stdarg call should be passed the argument
     759                 :            :    pack.  */
     760                 :            : #define CALL_EXPR_VA_ARG_PACK(NODE) \
     761                 :            :   (CALL_EXPR_CHECK (NODE)->base.public_flag)
     762                 :            : 
     763                 :            : /* In any expression, decl, or constant, nonzero means it has side effects or
     764                 :            :    reevaluation of the whole expression could produce a different value.
     765                 :            :    This is set if any subexpression is a function call, a side effect or a
     766                 :            :    reference to a volatile variable.  In a ..._DECL, this is set only if the
     767                 :            :    declaration said `volatile'.  This will never be set for a constant.  */
     768                 :            : #define TREE_SIDE_EFFECTS(NODE) \
     769                 :            :   (NON_TYPE_CHECK (NODE)->base.side_effects_flag)
     770                 :            : 
     771                 :            : /* In a LABEL_DECL, nonzero means this label had its address taken
     772                 :            :    and therefore can never be deleted and is a jump target for
     773                 :            :    computed gotos.  */
     774                 :            : #define FORCED_LABEL(NODE) (LABEL_DECL_CHECK (NODE)->base.side_effects_flag)
     775                 :            : 
     776                 :            : /* Whether a case or a user-defined label is allowed to fall through to.
     777                 :            :    This is used to implement -Wimplicit-fallthrough.  */
     778                 :            : #define FALLTHROUGH_LABEL_P(NODE) \
     779                 :            :   (LABEL_DECL_CHECK (NODE)->base.private_flag)
     780                 :            : 
     781                 :            : /* Set on the artificial label created for break; stmt from a switch.
     782                 :            :    This is used to implement -Wimplicit-fallthrough.  */
     783                 :            : #define SWITCH_BREAK_LABEL_P(NODE) \
     784                 :            :   (LABEL_DECL_CHECK (NODE)->base.protected_flag)
     785                 :            : 
     786                 :            : /* Nonzero means this expression is volatile in the C sense:
     787                 :            :    its address should be of type `volatile WHATEVER *'.
     788                 :            :    In other words, the declared item is volatile qualified.
     789                 :            :    This is used in _DECL nodes and _REF nodes.
     790                 :            :    On a FUNCTION_DECL node, this means the function does not
     791                 :            :    return normally.  This is the same effect as setting
     792                 :            :    the attribute noreturn on the function in C.
     793                 :            : 
     794                 :            :    In a ..._TYPE node, means this type is volatile-qualified.
     795                 :            :    But use TYPE_VOLATILE instead of this macro when the node is a type,
     796                 :            :    because eventually we may make that a different bit.
     797                 :            : 
     798                 :            :    If this bit is set in an expression, so is TREE_SIDE_EFFECTS.  */
     799                 :            : #define TREE_THIS_VOLATILE(NODE) ((NODE)->base.volatile_flag)
     800                 :            : 
     801                 :            : /* Nonzero means this node will not trap.  In an INDIRECT_REF, means
     802                 :            :    accessing the memory pointed to won't generate a trap.  However,
     803                 :            :    this only applies to an object when used appropriately: it doesn't
     804                 :            :    mean that writing a READONLY mem won't trap.
     805                 :            : 
     806                 :            :    In ARRAY_REF and ARRAY_RANGE_REF means that we know that the index
     807                 :            :    (or slice of the array) always belongs to the range of the array.
     808                 :            :    I.e. that the access will not trap, provided that the access to
     809                 :            :    the base to the array will not trap.  */
     810                 :            : #define TREE_THIS_NOTRAP(NODE) \
     811                 :            :   (TREE_CHECK5 (NODE, INDIRECT_REF, MEM_REF, TARGET_MEM_REF, ARRAY_REF, \
     812                 :            :                 ARRAY_RANGE_REF)->base.nothrow_flag)
     813                 :            : 
     814                 :            : /* In a VAR_DECL, PARM_DECL or FIELD_DECL, or any kind of ..._REF node,
     815                 :            :    nonzero means it may not be the lhs of an assignment.
     816                 :            :    Nonzero in a FUNCTION_DECL means this function should be treated
     817                 :            :    as "const" function (can only read its arguments).  */
     818                 :            : #define TREE_READONLY(NODE) (NON_TYPE_CHECK (NODE)->base.readonly_flag)
     819                 :            : 
     820                 :            : /* Value of expression is constant.  Always on in all ..._CST nodes.  May
     821                 :            :    also appear in an expression or decl where the value is constant.  */
     822                 :            : #define TREE_CONSTANT(NODE) (NON_TYPE_CHECK (NODE)->base.constant_flag)
     823                 :            : 
     824                 :            : /* Nonzero if NODE, a type, has had its sizes gimplified.  */
     825                 :            : #define TYPE_SIZES_GIMPLIFIED(NODE) \
     826                 :            :   (TYPE_CHECK (NODE)->base.constant_flag)
     827                 :            : 
     828                 :            : /* In a decl (most significantly a FIELD_DECL), means an unsigned field.  */
     829                 :            : #define DECL_UNSIGNED(NODE) \
     830                 :            :   (DECL_COMMON_CHECK (NODE)->base.u.bits.unsigned_flag)
     831                 :            : 
     832                 :            : /* In integral and pointer types, means an unsigned type.  */
     833                 :            : #define TYPE_UNSIGNED(NODE) (TYPE_CHECK (NODE)->base.u.bits.unsigned_flag)
     834                 :            : 
     835                 :            : /* Same as TYPE_UNSIGNED but converted to SIGNOP.  */
     836                 :            : #define TYPE_SIGN(NODE) ((signop) TYPE_UNSIGNED (NODE))
     837                 :            : 
     838                 :            : /* True if overflow wraps around for the given integral or pointer type.  That
     839                 :            :    is, TYPE_MAX + 1 == TYPE_MIN.  */
     840                 :            : #define TYPE_OVERFLOW_WRAPS(TYPE) \
     841                 :            :   (POINTER_TYPE_P (TYPE)                                        \
     842                 :            :    ? flag_wrapv_pointer                                         \
     843                 :            :    : (ANY_INTEGRAL_TYPE_CHECK(TYPE)->base.u.bits.unsigned_flag       \
     844                 :            :       || flag_wrapv))
     845                 :            : 
     846                 :            : /* True if overflow is undefined for the given integral or pointer type.
     847                 :            :    We may optimize on the assumption that values in the type never overflow.
     848                 :            : 
     849                 :            :    IMPORTANT NOTE: Any optimization based on TYPE_OVERFLOW_UNDEFINED
     850                 :            :    must issue a warning based on warn_strict_overflow.  In some cases
     851                 :            :    it will be appropriate to issue the warning immediately, and in
     852                 :            :    other cases it will be appropriate to simply set a flag and let the
     853                 :            :    caller decide whether a warning is appropriate or not.  */
     854                 :            : #define TYPE_OVERFLOW_UNDEFINED(TYPE)                           \
     855                 :            :   (POINTER_TYPE_P (TYPE)                                        \
     856                 :            :    ? !flag_wrapv_pointer                                        \
     857                 :            :    : (!ANY_INTEGRAL_TYPE_CHECK(TYPE)->base.u.bits.unsigned_flag      \
     858                 :            :       && !flag_wrapv && !flag_trapv))
     859                 :            : 
     860                 :            : /* True if overflow for the given integral type should issue a
     861                 :            :    trap.  */
     862                 :            : #define TYPE_OVERFLOW_TRAPS(TYPE) \
     863                 :            :   (!ANY_INTEGRAL_TYPE_CHECK(TYPE)->base.u.bits.unsigned_flag && flag_trapv)
     864                 :            : 
     865                 :            : /* True if an overflow is to be preserved for sanitization.  */
     866                 :            : #define TYPE_OVERFLOW_SANITIZED(TYPE)                   \
     867                 :            :   (INTEGRAL_TYPE_P (TYPE)                               \
     868                 :            :    && !TYPE_OVERFLOW_WRAPS (TYPE)                       \
     869                 :            :    && (flag_sanitize & SANITIZE_SI_OVERFLOW))
     870                 :            : 
     871                 :            : /* Nonzero in a VAR_DECL or STRING_CST means assembler code has been written.
     872                 :            :    Nonzero in a FUNCTION_DECL means that the function has been compiled.
     873                 :            :    This is interesting in an inline function, since it might not need
     874                 :            :    to be compiled separately.
     875                 :            :    Nonzero in a RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, ENUMERAL_TYPE
     876                 :            :    or TYPE_DECL if the debugging info for the type has been written.
     877                 :            :    In a BLOCK node, nonzero if reorder_blocks has already seen this block.
     878                 :            :    In an SSA_NAME node, nonzero if the SSA_NAME occurs in an abnormal
     879                 :            :    PHI node.  */
     880                 :            : #define TREE_ASM_WRITTEN(NODE) ((NODE)->base.asm_written_flag)
     881                 :            : 
     882                 :            : /* Nonzero in a _DECL if the name is used in its scope.
     883                 :            :    Nonzero in an expr node means inhibit warning if value is unused.
     884                 :            :    In IDENTIFIER_NODEs, this means that some extern decl for this name
     885                 :            :    was used.
     886                 :            :    In a BLOCK, this means that the block contains variables that are used.  */
     887                 :            : #define TREE_USED(NODE) ((NODE)->base.used_flag)
     888                 :            : 
     889                 :            : /* In a FUNCTION_DECL, nonzero means a call to the function cannot
     890                 :            :    throw an exception.  In a CALL_EXPR, nonzero means the call cannot
     891                 :            :    throw.  We can't easily check the node type here as the C++
     892                 :            :    frontend also uses this flag (for AGGR_INIT_EXPR).  */
     893                 :            : #define TREE_NOTHROW(NODE) ((NODE)->base.nothrow_flag)
     894                 :            : 
     895                 :            : /* In a CALL_EXPR, means that it's safe to use the target of the call
     896                 :            :    expansion as the return slot for a call that returns in memory.  */
     897                 :            : #define CALL_EXPR_RETURN_SLOT_OPT(NODE) \
     898                 :            :   (CALL_EXPR_CHECK (NODE)->base.private_flag)
     899                 :            : 
     900                 :            : /* In a RESULT_DECL, PARM_DECL and VAR_DECL, means that it is
     901                 :            :    passed by invisible reference (and the TREE_TYPE is a pointer to the true
     902                 :            :    type).  */
     903                 :            : #define DECL_BY_REFERENCE(NODE) \
     904                 :            :   (TREE_CHECK3 (NODE, VAR_DECL, PARM_DECL, \
     905                 :            :                 RESULT_DECL)->decl_common.decl_by_reference_flag)
     906                 :            : 
     907                 :            : /* In VAR_DECL and PARM_DECL, set when the decl has been used except for
     908                 :            :    being set.  */
     909                 :            : #define DECL_READ_P(NODE) \
     910                 :            :   (TREE_CHECK2 (NODE, VAR_DECL, PARM_DECL)->decl_common.decl_read_flag)
     911                 :            : 
     912                 :            : /* In VAR_DECL or RESULT_DECL, set when significant code movement precludes
     913                 :            :    attempting to share the stack slot with some other variable.  */
     914                 :            : #define DECL_NONSHAREABLE(NODE) \
     915                 :            :   (TREE_CHECK2 (NODE, VAR_DECL, \
     916                 :            :                 RESULT_DECL)->decl_common.decl_nonshareable_flag)
     917                 :            : 
     918                 :            : /* In a PARM_DECL, set for Fortran hidden string length arguments that some
     919                 :            :    buggy callers don't pass to the callee.  */
     920                 :            : #define DECL_HIDDEN_STRING_LENGTH(NODE) \
     921                 :            :   (TREE_CHECK (NODE, PARM_DECL)->decl_common.decl_nonshareable_flag)
     922                 :            : 
     923                 :            : /* In a CALL_EXPR, means that the call is the jump from a thunk to the
     924                 :            :    thunked-to function.  */
     925                 :            : #define CALL_FROM_THUNK_P(NODE) (CALL_EXPR_CHECK (NODE)->base.protected_flag)
     926                 :            : 
     927                 :            : /* In a CALL_EXPR, if the function being called is BUILT_IN_ALLOCA, means that
     928                 :            :    it has been built for the declaration of a variable-sized object.  */
     929                 :            : #define CALL_ALLOCA_FOR_VAR_P(NODE) \
     930                 :            :   (CALL_EXPR_CHECK (NODE)->base.protected_flag)
     931                 :            : 
     932                 :            : /* Used in classes in C++.  */
     933                 :            : #define TREE_PRIVATE(NODE) ((NODE)->base.private_flag)
     934                 :            : /* Used in classes in C++. */
     935                 :            : #define TREE_PROTECTED(NODE) ((NODE)->base.protected_flag)
     936                 :            : 
     937                 :            : /* True if reference type NODE is a C++ rvalue reference.  */
     938                 :            : #define TYPE_REF_IS_RVALUE(NODE) \
     939                 :            :   (REFERENCE_TYPE_CHECK (NODE)->base.private_flag)
     940                 :            : 
     941                 :            : /* Nonzero in a _DECL if the use of the name is defined as a
     942                 :            :    deprecated feature by __attribute__((deprecated)).  */
     943                 :            : #define TREE_DEPRECATED(NODE) \
     944                 :            :   ((NODE)->base.deprecated_flag)
     945                 :            : 
     946                 :            : /* Nonzero indicates an IDENTIFIER_NODE that names an anonymous
     947                 :            :    aggregate, (as created by anon_aggr_name_format).  */
     948                 :            : #define IDENTIFIER_ANON_P(NODE) \
     949                 :            :   (IDENTIFIER_NODE_CHECK (NODE)->base.private_flag)
     950                 :            : 
     951                 :            : /* Nonzero in an IDENTIFIER_NODE if the name is a local alias, whose
     952                 :            :    uses are to be substituted for uses of the TREE_CHAINed identifier.  */
     953                 :            : #define IDENTIFIER_TRANSPARENT_ALIAS(NODE) \
     954                 :            :   (IDENTIFIER_NODE_CHECK (NODE)->base.deprecated_flag)
     955                 :            : 
     956                 :            : /* In an aggregate type, indicates that the scalar fields of the type are
     957                 :            :    stored in reverse order from the target order.  This effectively
     958                 :            :    toggles BYTES_BIG_ENDIAN and WORDS_BIG_ENDIAN within the type.  */
     959                 :            : #define TYPE_REVERSE_STORAGE_ORDER(NODE) \
     960                 :            :   (TREE_CHECK4 (NODE, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, ARRAY_TYPE)->base.u.bits.saturating_flag)
     961                 :            : 
     962                 :            : /* In a non-aggregate type, indicates a saturating type.  */
     963                 :            : #define TYPE_SATURATING(NODE) \
     964                 :            :   (TREE_NOT_CHECK4 (NODE, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, ARRAY_TYPE)->base.u.bits.saturating_flag)
     965                 :            : 
     966                 :            : /* In a BIT_FIELD_REF and MEM_REF, indicates that the reference is to a group
     967                 :            :    of bits stored in reverse order from the target order.  This effectively
     968                 :            :    toggles both BYTES_BIG_ENDIAN and WORDS_BIG_ENDIAN for the reference.
     969                 :            : 
     970                 :            :    The overall strategy is to preserve the invariant that every scalar in
     971                 :            :    memory is associated with a single storage order, i.e. all accesses to
     972                 :            :    this scalar are done with the same storage order.  This invariant makes
     973                 :            :    it possible to factor out the storage order in most transformations, as
     974                 :            :    only the address and/or the value (in target order) matter for them.
     975                 :            :    But, of course, the storage order must be preserved when the accesses
     976                 :            :    themselves are rewritten or transformed.  */
     977                 :            : #define REF_REVERSE_STORAGE_ORDER(NODE) \
     978                 :            :   (TREE_CHECK2 (NODE, BIT_FIELD_REF, MEM_REF)->base.default_def_flag)
     979                 :            : 
     980                 :            :   /* In an ADDR_EXPR, indicates that this is a pointer to nested function
     981                 :            :    represented by a descriptor instead of a trampoline.  */
     982                 :            : #define FUNC_ADDR_BY_DESCRIPTOR(NODE) \
     983                 :            :   (TREE_CHECK (NODE, ADDR_EXPR)->base.default_def_flag)
     984                 :            : 
     985                 :            : /* In a CALL_EXPR, indicates that this is an indirect call for which
     986                 :            :    pointers to nested function are descriptors instead of trampolines.  */
     987                 :            : #define CALL_EXPR_BY_DESCRIPTOR(NODE) \
     988                 :            :   (TREE_CHECK (NODE, CALL_EXPR)->base.default_def_flag)
     989                 :            : 
     990                 :            : /* These flags are available for each language front end to use internally.  */
     991                 :            : #define TREE_LANG_FLAG_0(NODE) \
     992                 :            :   (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_0)
     993                 :            : #define TREE_LANG_FLAG_1(NODE) \
     994                 :            :   (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_1)
     995                 :            : #define TREE_LANG_FLAG_2(NODE) \
     996                 :            :   (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_2)
     997                 :            : #define TREE_LANG_FLAG_3(NODE) \
     998                 :            :   (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_3)
     999                 :            : #define TREE_LANG_FLAG_4(NODE) \
    1000                 :            :   (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_4)
    1001                 :            : #define TREE_LANG_FLAG_5(NODE) \
    1002                 :            :   (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_5)
    1003                 :            : #define TREE_LANG_FLAG_6(NODE) \
    1004                 :            :   (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_6)
    1005                 :            : 
    1006                 :            : /* Define additional fields and accessors for nodes representing constants.  */
    1007                 :            : 
    1008                 :            : #define TREE_INT_CST_NUNITS(NODE) \
    1009                 :            :   (INTEGER_CST_CHECK (NODE)->base.u.int_length.unextended)
    1010                 :            : #define TREE_INT_CST_EXT_NUNITS(NODE) \
    1011                 :            :   (INTEGER_CST_CHECK (NODE)->base.u.int_length.extended)
    1012                 :            : #define TREE_INT_CST_OFFSET_NUNITS(NODE) \
    1013                 :            :   (INTEGER_CST_CHECK (NODE)->base.u.int_length.offset)
    1014                 :            : #define TREE_INT_CST_ELT(NODE, I) TREE_INT_CST_ELT_CHECK (NODE, I)
    1015                 :            : #define TREE_INT_CST_LOW(NODE) \
    1016                 :            :   ((unsigned HOST_WIDE_INT) TREE_INT_CST_ELT (NODE, 0))
    1017                 :            : 
    1018                 :            : /* Return true if NODE is a POLY_INT_CST.  This is only ever true on
    1019                 :            :    targets with variable-sized modes.  */
    1020                 :            : #define POLY_INT_CST_P(NODE) \
    1021                 :            :   (NUM_POLY_INT_COEFFS > 1 && TREE_CODE (NODE) == POLY_INT_CST)
    1022                 :            : 
    1023                 :            : /* In a POLY_INT_CST node.  */
    1024                 :            : #define POLY_INT_CST_COEFF(NODE, I) \
    1025                 :            :   (POLY_INT_CST_CHECK (NODE)->poly_int_cst.coeffs[I])
    1026                 :            : 
    1027                 :            : #define TREE_REAL_CST_PTR(NODE) (REAL_CST_CHECK (NODE)->real_cst.real_cst_ptr)
    1028                 :            : #define TREE_REAL_CST(NODE) (*TREE_REAL_CST_PTR (NODE))
    1029                 :            : 
    1030                 :            : #define TREE_FIXED_CST_PTR(NODE) \
    1031                 :            :   (FIXED_CST_CHECK (NODE)->fixed_cst.fixed_cst_ptr)
    1032                 :            : #define TREE_FIXED_CST(NODE) (*TREE_FIXED_CST_PTR (NODE))
    1033                 :            : 
    1034                 :            : /* In a STRING_CST */
    1035                 :            : /* In C terms, this is sizeof, not strlen.  */
    1036                 :            : #define TREE_STRING_LENGTH(NODE) (STRING_CST_CHECK (NODE)->string.length)
    1037                 :            : #define TREE_STRING_POINTER(NODE) \
    1038                 :            :   ((const char *)(STRING_CST_CHECK (NODE)->string.str))
    1039                 :            : 
    1040                 :            : /* In a COMPLEX_CST node.  */
    1041                 :            : #define TREE_REALPART(NODE) (COMPLEX_CST_CHECK (NODE)->complex.real)
    1042                 :            : #define TREE_IMAGPART(NODE) (COMPLEX_CST_CHECK (NODE)->complex.imag)
    1043                 :            : 
    1044                 :            : /* In a VECTOR_CST node.  See generic.texi for details.  */
    1045                 :            : #define VECTOR_CST_NELTS(NODE) (TYPE_VECTOR_SUBPARTS (TREE_TYPE (NODE)))
    1046                 :            : #define VECTOR_CST_ELT(NODE,IDX) vector_cst_elt (NODE, IDX)
    1047                 :            : 
    1048                 :            : #define VECTOR_CST_LOG2_NPATTERNS(NODE) \
    1049                 :            :   (VECTOR_CST_CHECK (NODE)->base.u.vector_cst.log2_npatterns)
    1050                 :            : #define VECTOR_CST_NPATTERNS(NODE) \
    1051                 :            :   (1U << VECTOR_CST_LOG2_NPATTERNS (NODE))
    1052                 :            : #define VECTOR_CST_NELTS_PER_PATTERN(NODE) \
    1053                 :            :   (VECTOR_CST_CHECK (NODE)->base.u.vector_cst.nelts_per_pattern)
    1054                 :            : #define VECTOR_CST_DUPLICATE_P(NODE) \
    1055                 :            :   (VECTOR_CST_NELTS_PER_PATTERN (NODE) == 1)
    1056                 :            : #define VECTOR_CST_STEPPED_P(NODE) \
    1057                 :            :   (VECTOR_CST_NELTS_PER_PATTERN (NODE) == 3)
    1058                 :            : #define VECTOR_CST_ENCODED_ELTS(NODE) \
    1059                 :            :   (VECTOR_CST_CHECK (NODE)->vector.elts)
    1060                 :            : #define VECTOR_CST_ENCODED_ELT(NODE, ELT) \
    1061                 :            :   (VECTOR_CST_CHECK (NODE)->vector.elts[ELT])
    1062                 :            : 
    1063                 :            : /* Define fields and accessors for some special-purpose tree nodes.  */
    1064                 :            : 
    1065                 :            : #define IDENTIFIER_LENGTH(NODE) \
    1066                 :            :   (IDENTIFIER_NODE_CHECK (NODE)->identifier.id.len)
    1067                 :            : #define IDENTIFIER_POINTER(NODE) \
    1068                 :            :   ((const char *) IDENTIFIER_NODE_CHECK (NODE)->identifier.id.str)
    1069                 :            : #define IDENTIFIER_HASH_VALUE(NODE) \
    1070                 :            :   (IDENTIFIER_NODE_CHECK (NODE)->identifier.id.hash_value)
    1071                 :            : 
    1072                 :            : /* Translate a hash table identifier pointer to a tree_identifier
    1073                 :            :    pointer, and vice versa.  */
    1074                 :            : 
    1075                 :            : #define HT_IDENT_TO_GCC_IDENT(NODE) \
    1076                 :            :   ((tree) ((char *) (NODE) - sizeof (struct tree_common)))
    1077                 :            : #define GCC_IDENT_TO_HT_IDENT(NODE) (&((struct tree_identifier *) (NODE))->id)
    1078                 :            : 
    1079                 :            : /* In a TREE_LIST node.  */
    1080                 :            : #define TREE_PURPOSE(NODE) (TREE_LIST_CHECK (NODE)->list.purpose)
    1081                 :            : #define TREE_VALUE(NODE) (TREE_LIST_CHECK (NODE)->list.value)
    1082                 :            : 
    1083                 :            : /* In a TREE_VEC node.  */
    1084                 :            : #define TREE_VEC_LENGTH(NODE) (TREE_VEC_CHECK (NODE)->base.u.length)
    1085                 :            : #define TREE_VEC_END(NODE) \
    1086                 :            :   ((void) TREE_VEC_CHECK (NODE), &((NODE)->vec.a[(NODE)->vec.base.u.length]))
    1087                 :            : 
    1088                 :            : #define TREE_VEC_ELT(NODE,I) TREE_VEC_ELT_CHECK (NODE, I)
    1089                 :            : 
    1090                 :            : /* In a CONSTRUCTOR node.  */
    1091                 :            : #define CONSTRUCTOR_ELTS(NODE) (CONSTRUCTOR_CHECK (NODE)->constructor.elts)
    1092                 :            : #define CONSTRUCTOR_ELT(NODE,IDX) \
    1093                 :            :   (&(*CONSTRUCTOR_ELTS (NODE))[IDX])
    1094                 :            : #define CONSTRUCTOR_NELTS(NODE) \
    1095                 :            :   (vec_safe_length (CONSTRUCTOR_ELTS (NODE)))
    1096                 :            : #define CONSTRUCTOR_NO_CLEARING(NODE) \
    1097                 :            :   (CONSTRUCTOR_CHECK (NODE)->base.public_flag)
    1098                 :            : 
    1099                 :            : /* Iterate through the vector V of CONSTRUCTOR_ELT elements, yielding the
    1100                 :            :    value of each element (stored within VAL). IX must be a scratch variable
    1101                 :            :    of unsigned integer type.  */
    1102                 :            : #define FOR_EACH_CONSTRUCTOR_VALUE(V, IX, VAL) \
    1103                 :            :   for (IX = 0; (IX >= vec_safe_length (V)) \
    1104                 :            :                ? false \
    1105                 :            :                : ((VAL = (*(V))[IX].value), \
    1106                 :            :                true); \
    1107                 :            :        (IX)++)
    1108                 :            : 
    1109                 :            : /* Iterate through the vector V of CONSTRUCTOR_ELT elements, yielding both
    1110                 :            :    the value of each element (stored within VAL) and its index (stored
    1111                 :            :    within INDEX). IX must be a scratch variable of unsigned integer type.  */
    1112                 :            : #define FOR_EACH_CONSTRUCTOR_ELT(V, IX, INDEX, VAL) \
    1113                 :            :   for (IX = 0; (IX >= vec_safe_length (V)) \
    1114                 :            :                ? false \
    1115                 :            :                : (((void) (VAL = (*V)[IX].value)), \
    1116                 :            :                   (INDEX = (*V)[IX].index), \
    1117                 :            :                   true); \
    1118                 :            :        (IX)++)
    1119                 :            : 
    1120                 :            : /* Append a new constructor element to V, with the specified INDEX and VAL.  */
    1121                 :            : #define CONSTRUCTOR_APPEND_ELT(V, INDEX, VALUE) \
    1122                 :            :   do { \
    1123                 :            :     constructor_elt _ce___ = {INDEX, VALUE}; \
    1124                 :            :     vec_safe_push ((V), _ce___); \
    1125                 :            :   } while (0)
    1126                 :            : 
    1127                 :            : /* True if NODE, a FIELD_DECL, is to be processed as a bitfield for
    1128                 :            :    constructor output purposes.  */
    1129                 :            : #define CONSTRUCTOR_BITFIELD_P(NODE) \
    1130                 :            :   (DECL_BIT_FIELD (FIELD_DECL_CHECK (NODE)) && DECL_MODE (NODE) != BLKmode)
    1131                 :            : 
    1132                 :            : /* True if NODE is a clobber right hand side, an expression of indeterminate
    1133                 :            :    value that clobbers the LHS in a copy instruction.  We use a volatile
    1134                 :            :    empty CONSTRUCTOR for this, as it matches most of the necessary semantic.
    1135                 :            :    In particular the volatile flag causes us to not prematurely remove
    1136                 :            :    such clobber instructions.  */
    1137                 :            : #define TREE_CLOBBER_P(NODE) \
    1138                 :            :   (TREE_CODE (NODE) == CONSTRUCTOR && TREE_THIS_VOLATILE (NODE))
    1139                 :            : 
    1140                 :            : /* Define fields and accessors for some nodes that represent expressions.  */
    1141                 :            : 
    1142                 :            : /* Nonzero if NODE is an empty statement (NOP_EXPR <0>).  */
    1143                 :            : #define IS_EMPTY_STMT(NODE)     (TREE_CODE (NODE) == NOP_EXPR \
    1144                 :            :                                  && VOID_TYPE_P (TREE_TYPE (NODE)) \
    1145                 :            :                                  && integer_zerop (TREE_OPERAND (NODE, 0)))
    1146                 :            : 
    1147                 :            : /* In ordinary expression nodes.  */
    1148                 :            : #define TREE_OPERAND_LENGTH(NODE) tree_operand_length (NODE)
    1149                 :            : #define TREE_OPERAND(NODE, I) TREE_OPERAND_CHECK (NODE, I)
    1150                 :            : 
    1151                 :            : /* In a tcc_vl_exp node, operand 0 is an INT_CST node holding the operand
    1152                 :            :    length.  Its value includes the length operand itself; that is,
    1153                 :            :    the minimum valid length is 1.
    1154                 :            :    Note that we have to bypass the use of TREE_OPERAND to access
    1155                 :            :    that field to avoid infinite recursion in expanding the macros.  */
    1156                 :            : #define VL_EXP_OPERAND_LENGTH(NODE) \
    1157                 :            :   ((int)TREE_INT_CST_LOW (VL_EXP_CHECK (NODE)->exp.operands[0]))
    1158                 :            : 
    1159                 :            : /* Nonzero if gimple_debug_nonbind_marker_p() may possibly hold.  */
    1160                 :            : #define MAY_HAVE_DEBUG_MARKER_STMTS debug_nonbind_markers_p
    1161                 :            : /* Nonzero if gimple_debug_bind_p() (and thus
    1162                 :            :    gimple_debug_source_bind_p()) may possibly hold.  */
    1163                 :            : #define MAY_HAVE_DEBUG_BIND_STMTS flag_var_tracking_assignments
    1164                 :            : /* Nonzero if is_gimple_debug() may possibly hold.  */
    1165                 :            : #define MAY_HAVE_DEBUG_STMTS                                    \
    1166                 :            :   (MAY_HAVE_DEBUG_MARKER_STMTS || MAY_HAVE_DEBUG_BIND_STMTS)
    1167                 :            : 
    1168                 :            : /* In a LOOP_EXPR node.  */
    1169                 :            : #define LOOP_EXPR_BODY(NODE) TREE_OPERAND_CHECK_CODE (NODE, LOOP_EXPR, 0)
    1170                 :            : 
    1171                 :            : /* The source location of this expression.  Non-tree_exp nodes such as
    1172                 :            :    decls and constants can be shared among multiple locations, so
    1173                 :            :    return nothing.  */
    1174                 :            : #define EXPR_LOCATION(NODE) \
    1175                 :            :   (CAN_HAVE_LOCATION_P ((NODE)) ? (NODE)->exp.locus : UNKNOWN_LOCATION)
    1176                 :            : #define SET_EXPR_LOCATION(NODE, LOCUS) EXPR_CHECK ((NODE))->exp.locus = (LOCUS)
    1177                 :            : #define EXPR_HAS_LOCATION(NODE) (LOCATION_LOCUS (EXPR_LOCATION (NODE))  \
    1178                 :            :   != UNKNOWN_LOCATION)
    1179                 :            : /* The location to be used in a diagnostic about this expression.  Do not
    1180                 :            :    use this macro if the location will be assigned to other expressions.  */
    1181                 :            : #define EXPR_LOC_OR_LOC(NODE, LOCUS) (EXPR_HAS_LOCATION (NODE) \
    1182                 :            :                                       ? (NODE)->exp.locus : (LOCUS))
    1183                 :            : #define EXPR_FILENAME(NODE) LOCATION_FILE (EXPR_CHECK ((NODE))->exp.locus)
    1184                 :            : #define EXPR_LINENO(NODE) LOCATION_LINE (EXPR_CHECK (NODE)->exp.locus)
    1185                 :            : 
    1186                 :            : #define CAN_HAVE_RANGE_P(NODE) (CAN_HAVE_LOCATION_P (NODE))
    1187                 :            : #define EXPR_LOCATION_RANGE(NODE) (get_expr_source_range (EXPR_CHECK ((NODE))))
    1188                 :            : 
    1189                 :            : #define EXPR_HAS_RANGE(NODE) \
    1190                 :            :     (CAN_HAVE_RANGE_P (NODE) \
    1191                 :            :      ? EXPR_LOCATION_RANGE (NODE).m_start != UNKNOWN_LOCATION \
    1192                 :            :      : false)
    1193                 :            : 
    1194                 :            : /* True if a tree is an expression or statement that can have a
    1195                 :            :    location.  */
    1196                 :            : #define CAN_HAVE_LOCATION_P(NODE) ((NODE) && EXPR_P (NODE))
    1197                 :            : 
    1198                 :            : static inline source_range
    1199                 :  145773000 : get_expr_source_range (tree expr)
    1200                 :            : {
    1201                 :  145773000 :   location_t loc = EXPR_LOCATION (expr);
    1202                 :  145773000 :   return get_range_from_loc (line_table, loc);
    1203                 :            : }
    1204                 :            : 
    1205                 :            : extern void protected_set_expr_location (tree, location_t);
    1206                 :            : extern void protected_set_expr_location_if_unset (tree, location_t);
    1207                 :            : 
    1208                 :            : extern tree maybe_wrap_with_location (tree, location_t);
    1209                 :            : 
    1210                 :            : extern int suppress_location_wrappers;
    1211                 :            : 
    1212                 :            : /* A class for suppressing the creation of location wrappers.
    1213                 :            :    Location wrappers will not be created during the lifetime
    1214                 :            :    of an instance of this class.  */
    1215                 :            : 
    1216                 :            : class auto_suppress_location_wrappers
    1217                 :            : {
    1218                 :            :  public:
    1219                 :  186366000 :   auto_suppress_location_wrappers () { ++suppress_location_wrappers; }
    1220                 :      20724 :   ~auto_suppress_location_wrappers () { --suppress_location_wrappers; }
    1221                 :            : };
    1222                 :            : 
    1223                 :            : /* In a TARGET_EXPR node.  */
    1224                 :            : #define TARGET_EXPR_SLOT(NODE) TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 0)
    1225                 :            : #define TARGET_EXPR_INITIAL(NODE) TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 1)
    1226                 :            : #define TARGET_EXPR_CLEANUP(NODE) TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 2)
    1227                 :            : /* Don't elide the initialization of TARGET_EXPR_SLOT for this TARGET_EXPR
    1228                 :            :    on rhs of MODIFY_EXPR.  */
    1229                 :            : #define TARGET_EXPR_NO_ELIDE(NODE) (TARGET_EXPR_CHECK (NODE)->base.private_flag)
    1230                 :            : 
    1231                 :            : /* DECL_EXPR accessor. This gives access to the DECL associated with
    1232                 :            :    the given declaration statement.  */
    1233                 :            : #define DECL_EXPR_DECL(NODE)    TREE_OPERAND (DECL_EXPR_CHECK (NODE), 0)
    1234                 :            : 
    1235                 :            : #define EXIT_EXPR_COND(NODE)         TREE_OPERAND (EXIT_EXPR_CHECK (NODE), 0)
    1236                 :            : 
    1237                 :            : /* COMPOUND_LITERAL_EXPR accessors.  */
    1238                 :            : #define COMPOUND_LITERAL_EXPR_DECL_EXPR(NODE)           \
    1239                 :            :   TREE_OPERAND (COMPOUND_LITERAL_EXPR_CHECK (NODE), 0)
    1240                 :            : #define COMPOUND_LITERAL_EXPR_DECL(NODE)                        \
    1241                 :            :   DECL_EXPR_DECL (COMPOUND_LITERAL_EXPR_DECL_EXPR (NODE))
    1242                 :            : 
    1243                 :            : /* SWITCH_EXPR accessors. These give access to the condition and body.  */
    1244                 :            : #define SWITCH_COND(NODE)       TREE_OPERAND (SWITCH_EXPR_CHECK (NODE), 0)
    1245                 :            : #define SWITCH_BODY(NODE)       TREE_OPERAND (SWITCH_EXPR_CHECK (NODE), 1)
    1246                 :            : /* True if there are case labels for all possible values of SWITCH_COND, either
    1247                 :            :    because there is a default: case label or because the case label ranges cover
    1248                 :            :    all values.  */
    1249                 :            : #define SWITCH_ALL_CASES_P(NODE) (SWITCH_EXPR_CHECK (NODE)->base.private_flag)
    1250                 :            : 
    1251                 :            : /* CASE_LABEL_EXPR accessors. These give access to the high and low values
    1252                 :            :    of a case label, respectively.  */
    1253                 :            : #define CASE_LOW(NODE)                  TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 0)
    1254                 :            : #define CASE_HIGH(NODE)                 TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 1)
    1255                 :            : #define CASE_LABEL(NODE)                TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 2)
    1256                 :            : #define CASE_CHAIN(NODE)                TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 3)
    1257                 :            : 
    1258                 :            : /* The operands of a TARGET_MEM_REF.  Operands 0 and 1 have to match
    1259                 :            :    corresponding MEM_REF operands.  */
    1260                 :            : #define TMR_BASE(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 0))
    1261                 :            : #define TMR_OFFSET(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 1))
    1262                 :            : #define TMR_INDEX(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 2))
    1263                 :            : #define TMR_STEP(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 3))
    1264                 :            : #define TMR_INDEX2(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 4))
    1265                 :            : 
    1266                 :            : #define MR_DEPENDENCE_CLIQUE(NODE) \
    1267                 :            :   (TREE_CHECK2 (NODE, MEM_REF, TARGET_MEM_REF)->base.u.dependence_info.clique)
    1268                 :            : #define MR_DEPENDENCE_BASE(NODE) \
    1269                 :            :   (TREE_CHECK2 (NODE, MEM_REF, TARGET_MEM_REF)->base.u.dependence_info.base)
    1270                 :            : 
    1271                 :            : /* The operands of a BIND_EXPR.  */
    1272                 :            : #define BIND_EXPR_VARS(NODE) (TREE_OPERAND (BIND_EXPR_CHECK (NODE), 0))
    1273                 :            : #define BIND_EXPR_BODY(NODE) (TREE_OPERAND (BIND_EXPR_CHECK (NODE), 1))
    1274                 :            : #define BIND_EXPR_BLOCK(NODE) (TREE_OPERAND (BIND_EXPR_CHECK (NODE), 2))
    1275                 :            : 
    1276                 :            : /* GOTO_EXPR accessor. This gives access to the label associated with
    1277                 :            :    a goto statement.  */
    1278                 :            : #define GOTO_DESTINATION(NODE)  TREE_OPERAND (GOTO_EXPR_CHECK (NODE), 0)
    1279                 :            : 
    1280                 :            : /* ASM_EXPR accessors. ASM_STRING returns a STRING_CST for the
    1281                 :            :    instruction (e.g., "mov x, y"). ASM_OUTPUTS, ASM_INPUTS, and
    1282                 :            :    ASM_CLOBBERS represent the outputs, inputs, and clobbers for the
    1283                 :            :    statement.  */
    1284                 :            : #define ASM_STRING(NODE)        TREE_OPERAND (ASM_EXPR_CHECK (NODE), 0)
    1285                 :            : #define ASM_OUTPUTS(NODE)       TREE_OPERAND (ASM_EXPR_CHECK (NODE), 1)
    1286                 :            : #define ASM_INPUTS(NODE)        TREE_OPERAND (ASM_EXPR_CHECK (NODE), 2)
    1287                 :            : #define ASM_CLOBBERS(NODE)      TREE_OPERAND (ASM_EXPR_CHECK (NODE), 3)
    1288                 :            : #define ASM_LABELS(NODE)        TREE_OPERAND (ASM_EXPR_CHECK (NODE), 4)
    1289                 :            : /* Nonzero if we want to create an ASM_INPUT instead of an
    1290                 :            :    ASM_OPERAND with no operands.  */
    1291                 :            : #define ASM_INPUT_P(NODE) (ASM_EXPR_CHECK (NODE)->base.static_flag)
    1292                 :            : #define ASM_VOLATILE_P(NODE) (ASM_EXPR_CHECK (NODE)->base.public_flag)
    1293                 :            : /* Nonzero if we want to consider this asm as minimum length and cost
    1294                 :            :    for inlining decisions.  */
    1295                 :            : #define ASM_INLINE_P(NODE) (ASM_EXPR_CHECK (NODE)->base.protected_flag)
    1296                 :            : 
    1297                 :            : /* COND_EXPR accessors.  */
    1298                 :            : #define COND_EXPR_COND(NODE)    (TREE_OPERAND (COND_EXPR_CHECK (NODE), 0))
    1299                 :            : #define COND_EXPR_THEN(NODE)    (TREE_OPERAND (COND_EXPR_CHECK (NODE), 1))
    1300                 :            : #define COND_EXPR_ELSE(NODE)    (TREE_OPERAND (COND_EXPR_CHECK (NODE), 2))
    1301                 :            : 
    1302                 :            : /* Accessors for the chains of recurrences.  */
    1303                 :            : #define CHREC_LEFT(NODE)          TREE_OPERAND (POLYNOMIAL_CHREC_CHECK (NODE), 0)
    1304                 :            : #define CHREC_RIGHT(NODE)         TREE_OPERAND (POLYNOMIAL_CHREC_CHECK (NODE), 1)
    1305                 :            : #define CHREC_VARIABLE(NODE)      POLYNOMIAL_CHREC_CHECK (NODE)->base.u.chrec_var
    1306                 :            : 
    1307                 :            : /* LABEL_EXPR accessor. This gives access to the label associated with
    1308                 :            :    the given label expression.  */
    1309                 :            : #define LABEL_EXPR_LABEL(NODE)  TREE_OPERAND (LABEL_EXPR_CHECK (NODE), 0)
    1310                 :            : 
    1311                 :            : /* CATCH_EXPR accessors.  */
    1312                 :            : #define CATCH_TYPES(NODE)       TREE_OPERAND (CATCH_EXPR_CHECK (NODE), 0)
    1313                 :            : #define CATCH_BODY(NODE)        TREE_OPERAND (CATCH_EXPR_CHECK (NODE), 1)
    1314                 :            : 
    1315                 :            : /* EH_FILTER_EXPR accessors.  */
    1316                 :            : #define EH_FILTER_TYPES(NODE)   TREE_OPERAND (EH_FILTER_EXPR_CHECK (NODE), 0)
    1317                 :            : #define EH_FILTER_FAILURE(NODE) TREE_OPERAND (EH_FILTER_EXPR_CHECK (NODE), 1)
    1318                 :            : 
    1319                 :            : /* OBJ_TYPE_REF accessors.  */
    1320                 :            : #define OBJ_TYPE_REF_EXPR(NODE)   TREE_OPERAND (OBJ_TYPE_REF_CHECK (NODE), 0)
    1321                 :            : #define OBJ_TYPE_REF_OBJECT(NODE) TREE_OPERAND (OBJ_TYPE_REF_CHECK (NODE), 1)
    1322                 :            : #define OBJ_TYPE_REF_TOKEN(NODE)  TREE_OPERAND (OBJ_TYPE_REF_CHECK (NODE), 2)
    1323                 :            : 
    1324                 :            : /* ASSERT_EXPR accessors.  */
    1325                 :            : #define ASSERT_EXPR_VAR(NODE)   TREE_OPERAND (ASSERT_EXPR_CHECK (NODE), 0)
    1326                 :            : #define ASSERT_EXPR_COND(NODE)  TREE_OPERAND (ASSERT_EXPR_CHECK (NODE), 1)
    1327                 :            : 
    1328                 :            : /* CALL_EXPR accessors.  */
    1329                 :            : #define CALL_EXPR_FN(NODE) TREE_OPERAND (CALL_EXPR_CHECK (NODE), 1)
    1330                 :            : #define CALL_EXPR_STATIC_CHAIN(NODE) TREE_OPERAND (CALL_EXPR_CHECK (NODE), 2)
    1331                 :            : #define CALL_EXPR_ARG(NODE, I) TREE_OPERAND (CALL_EXPR_CHECK (NODE), (I) + 3)
    1332                 :            : #define call_expr_nargs(NODE) (VL_EXP_OPERAND_LENGTH (NODE) - 3)
    1333                 :            : #define CALL_EXPR_IFN(NODE) (CALL_EXPR_CHECK (NODE)->base.u.ifn)
    1334                 :            : 
    1335                 :            : /* CALL_EXPR_ARGP returns a pointer to the argument vector for NODE.
    1336                 :            :    We can't use &CALL_EXPR_ARG (NODE, 0) because that will complain if
    1337                 :            :    the argument count is zero when checking is enabled.  Instead, do
    1338                 :            :    the pointer arithmetic to advance past the 3 fixed operands in a
    1339                 :            :    CALL_EXPR.  That produces a valid pointer to just past the end of the
    1340                 :            :    operand array, even if it's not valid to dereference it.  */
    1341                 :            : #define CALL_EXPR_ARGP(NODE) \
    1342                 :            :   (&(TREE_OPERAND (CALL_EXPR_CHECK (NODE), 0)) + 3)
    1343                 :            : 
    1344                 :            : /* TM directives and accessors.  */
    1345                 :            : #define TRANSACTION_EXPR_BODY(NODE) \
    1346                 :            :   TREE_OPERAND (TRANSACTION_EXPR_CHECK (NODE), 0)
    1347                 :            : #define TRANSACTION_EXPR_OUTER(NODE) \
    1348                 :            :   (TRANSACTION_EXPR_CHECK (NODE)->base.static_flag)
    1349                 :            : #define TRANSACTION_EXPR_RELAXED(NODE) \
    1350                 :            :   (TRANSACTION_EXPR_CHECK (NODE)->base.public_flag)
    1351                 :            : 
    1352                 :            : /* OpenMP and OpenACC directive and clause accessors.  */
    1353                 :            : 
    1354                 :            : /* Generic accessors for OMP nodes that keep the body as operand 0, and clauses
    1355                 :            :    as operand 1.  */
    1356                 :            : #define OMP_BODY(NODE) \
    1357                 :            :   TREE_OPERAND (TREE_RANGE_CHECK (NODE, OACC_PARALLEL, OMP_MASTER), 0)
    1358                 :            : #define OMP_CLAUSES(NODE) \
    1359                 :            :   TREE_OPERAND (TREE_RANGE_CHECK (NODE, OACC_PARALLEL, OMP_SCAN), 1)
    1360                 :            : 
    1361                 :            : /* Generic accessors for OMP nodes that keep clauses as operand 0.  */
    1362                 :            : #define OMP_STANDALONE_CLAUSES(NODE) \
    1363                 :            :   TREE_OPERAND (TREE_RANGE_CHECK (NODE, OACC_CACHE, OMP_TARGET_EXIT_DATA), 0)
    1364                 :            : 
    1365                 :            : #define OACC_DATA_BODY(NODE) \
    1366                 :            :   TREE_OPERAND (OACC_DATA_CHECK (NODE), 0)
    1367                 :            : #define OACC_DATA_CLAUSES(NODE) \
    1368                 :            :   TREE_OPERAND (OACC_DATA_CHECK (NODE), 1)
    1369                 :            : 
    1370                 :            : #define OACC_HOST_DATA_BODY(NODE) \
    1371                 :            :   TREE_OPERAND (OACC_HOST_DATA_CHECK (NODE), 0)
    1372                 :            : #define OACC_HOST_DATA_CLAUSES(NODE) \
    1373                 :            :   TREE_OPERAND (OACC_HOST_DATA_CHECK (NODE), 1)
    1374                 :            : 
    1375                 :            : #define OACC_CACHE_CLAUSES(NODE) \
    1376                 :            :   TREE_OPERAND (OACC_CACHE_CHECK (NODE), 0)
    1377                 :            : 
    1378                 :            : #define OACC_DECLARE_CLAUSES(NODE) \
    1379                 :            :   TREE_OPERAND (OACC_DECLARE_CHECK (NODE), 0)
    1380                 :            : 
    1381                 :            : #define OACC_ENTER_DATA_CLAUSES(NODE) \
    1382                 :            :   TREE_OPERAND (OACC_ENTER_DATA_CHECK (NODE), 0)
    1383                 :            : 
    1384                 :            : #define OACC_EXIT_DATA_CLAUSES(NODE) \
    1385                 :            :   TREE_OPERAND (OACC_EXIT_DATA_CHECK (NODE), 0)
    1386                 :            : 
    1387                 :            : #define OACC_UPDATE_CLAUSES(NODE) \
    1388                 :            :   TREE_OPERAND (OACC_UPDATE_CHECK (NODE), 0)
    1389                 :            : 
    1390                 :            : #define OMP_PARALLEL_BODY(NODE)    TREE_OPERAND (OMP_PARALLEL_CHECK (NODE), 0)
    1391                 :            : #define OMP_PARALLEL_CLAUSES(NODE) TREE_OPERAND (OMP_PARALLEL_CHECK (NODE), 1)
    1392                 :            : 
    1393                 :            : #define OMP_TASK_BODY(NODE)        TREE_OPERAND (OMP_TASK_CHECK (NODE), 0)
    1394                 :            : #define OMP_TASK_CLAUSES(NODE)     TREE_OPERAND (OMP_TASK_CHECK (NODE), 1)
    1395                 :            : 
    1396                 :            : #define OMP_TASKREG_CHECK(NODE)   TREE_RANGE_CHECK (NODE, OMP_PARALLEL, OMP_TASK)
    1397                 :            : #define OMP_TASKREG_BODY(NODE)    TREE_OPERAND (OMP_TASKREG_CHECK (NODE), 0)
    1398                 :            : #define OMP_TASKREG_CLAUSES(NODE) TREE_OPERAND (OMP_TASKREG_CHECK (NODE), 1)
    1399                 :            : 
    1400                 :            : #define OMP_LOOPING_CHECK(NODE) TREE_RANGE_CHECK (NODE, OMP_FOR, OACC_LOOP)
    1401                 :            : #define OMP_FOR_BODY(NODE)         TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 0)
    1402                 :            : #define OMP_FOR_CLAUSES(NODE)      TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 1)
    1403                 :            : #define OMP_FOR_INIT(NODE)         TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 2)
    1404                 :            : #define OMP_FOR_COND(NODE)         TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 3)
    1405                 :            : #define OMP_FOR_INCR(NODE)         TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 4)
    1406                 :            : #define OMP_FOR_PRE_BODY(NODE)     TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 5)
    1407                 :            : #define OMP_FOR_ORIG_DECLS(NODE)   TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 6)
    1408                 :            : 
    1409                 :            : #define OMP_SECTIONS_BODY(NODE)    TREE_OPERAND (OMP_SECTIONS_CHECK (NODE), 0)
    1410                 :            : #define OMP_SECTIONS_CLAUSES(NODE) TREE_OPERAND (OMP_SECTIONS_CHECK (NODE), 1)
    1411                 :            : 
    1412                 :            : #define OMP_SECTION_BODY(NODE)     TREE_OPERAND (OMP_SECTION_CHECK (NODE), 0)
    1413                 :            : 
    1414                 :            : #define OMP_SINGLE_BODY(NODE)      TREE_OPERAND (OMP_SINGLE_CHECK (NODE), 0)
    1415                 :            : #define OMP_SINGLE_CLAUSES(NODE)   TREE_OPERAND (OMP_SINGLE_CHECK (NODE), 1)
    1416                 :            : 
    1417                 :            : #define OMP_MASTER_BODY(NODE)      TREE_OPERAND (OMP_MASTER_CHECK (NODE), 0)
    1418                 :            : 
    1419                 :            : #define OMP_TASKGROUP_BODY(NODE)   TREE_OPERAND (OMP_TASKGROUP_CHECK (NODE), 0)
    1420                 :            : #define OMP_TASKGROUP_CLAUSES(NODE) \
    1421                 :            :   TREE_OPERAND (OMP_TASKGROUP_CHECK (NODE), 1)
    1422                 :            : 
    1423                 :            : #define OMP_ORDERED_BODY(NODE)     TREE_OPERAND (OMP_ORDERED_CHECK (NODE), 0)
    1424                 :            : #define OMP_ORDERED_CLAUSES(NODE)  TREE_OPERAND (OMP_ORDERED_CHECK (NODE), 1)
    1425                 :            : 
    1426                 :            : #define OMP_CRITICAL_BODY(NODE)    TREE_OPERAND (OMP_CRITICAL_CHECK (NODE), 0)
    1427                 :            : #define OMP_CRITICAL_CLAUSES(NODE) TREE_OPERAND (OMP_CRITICAL_CHECK (NODE), 1)
    1428                 :            : #define OMP_CRITICAL_NAME(NODE)    TREE_OPERAND (OMP_CRITICAL_CHECK (NODE), 2)
    1429                 :            : 
    1430                 :            : #define OMP_TEAMS_BODY(NODE)       TREE_OPERAND (OMP_TEAMS_CHECK (NODE), 0)
    1431                 :            : #define OMP_TEAMS_CLAUSES(NODE)    TREE_OPERAND (OMP_TEAMS_CHECK (NODE), 1)
    1432                 :            : 
    1433                 :            : #define OMP_TARGET_DATA_BODY(NODE) \
    1434                 :            :   TREE_OPERAND (OMP_TARGET_DATA_CHECK (NODE), 0)
    1435                 :            : #define OMP_TARGET_DATA_CLAUSES(NODE)\
    1436                 :            :   TREE_OPERAND (OMP_TARGET_DATA_CHECK (NODE), 1)
    1437                 :            : 
    1438                 :            : #define OMP_TARGET_BODY(NODE)      TREE_OPERAND (OMP_TARGET_CHECK (NODE), 0)
    1439                 :            : #define OMP_TARGET_CLAUSES(NODE)   TREE_OPERAND (OMP_TARGET_CHECK (NODE), 1)
    1440                 :            : 
    1441                 :            : #define OMP_TARGET_UPDATE_CLAUSES(NODE)\
    1442                 :            :   TREE_OPERAND (OMP_TARGET_UPDATE_CHECK (NODE), 0)
    1443                 :            : 
    1444                 :            : #define OMP_TARGET_ENTER_DATA_CLAUSES(NODE)\
    1445                 :            :   TREE_OPERAND (OMP_TARGET_ENTER_DATA_CHECK (NODE), 0)
    1446                 :            : 
    1447                 :            : #define OMP_TARGET_EXIT_DATA_CLAUSES(NODE)\
    1448                 :            :   TREE_OPERAND (OMP_TARGET_EXIT_DATA_CHECK (NODE), 0)
    1449                 :            : 
    1450                 :            : #define OMP_SCAN_BODY(NODE)     TREE_OPERAND (OMP_SCAN_CHECK (NODE), 0)
    1451                 :            : #define OMP_SCAN_CLAUSES(NODE)  TREE_OPERAND (OMP_SCAN_CHECK (NODE), 1)
    1452                 :            : 
    1453                 :            : #define OMP_CLAUSE_SIZE(NODE)                                           \
    1454                 :            :   OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (OMP_CLAUSE_CHECK (NODE),  \
    1455                 :            :                                               OMP_CLAUSE_FROM,          \
    1456                 :            :                                               OMP_CLAUSE__CACHE_), 1)
    1457                 :            : 
    1458                 :            : #define OMP_CLAUSE_CHAIN(NODE)     TREE_CHAIN (OMP_CLAUSE_CHECK (NODE))
    1459                 :            : #define OMP_CLAUSE_DECL(NODE)                                           \
    1460                 :            :   OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (OMP_CLAUSE_CHECK (NODE),  \
    1461                 :            :                                               OMP_CLAUSE_PRIVATE,       \
    1462                 :            :                                               OMP_CLAUSE__SCANTEMP_), 0)
    1463                 :            : #define OMP_CLAUSE_HAS_LOCATION(NODE) \
    1464                 :            :   (LOCATION_LOCUS ((OMP_CLAUSE_CHECK (NODE))->omp_clause.locus)              \
    1465                 :            :   != UNKNOWN_LOCATION)
    1466                 :            : #define OMP_CLAUSE_LOCATION(NODE)  (OMP_CLAUSE_CHECK (NODE))->omp_clause.locus
    1467                 :            : 
    1468                 :            : /* True on an OMP_SECTION statement that was the last lexical member.
    1469                 :            :    This status is meaningful in the implementation of lastprivate.  */
    1470                 :            : #define OMP_SECTION_LAST(NODE) \
    1471                 :            :   (OMP_SECTION_CHECK (NODE)->base.private_flag)
    1472                 :            : 
    1473                 :            : /* True on an OMP_PARALLEL statement if it represents an explicit
    1474                 :            :    combined parallel work-sharing constructs.  */
    1475                 :            : #define OMP_PARALLEL_COMBINED(NODE) \
    1476                 :            :   (OMP_PARALLEL_CHECK (NODE)->base.private_flag)
    1477                 :            : 
    1478                 :            : /* True on an OMP_TEAMS statement if it represents an explicit
    1479                 :            :    combined teams distribute constructs.  */
    1480                 :            : #define OMP_TEAMS_COMBINED(NODE) \
    1481                 :            :   (OMP_TEAMS_CHECK (NODE)->base.private_flag)
    1482                 :            : 
    1483                 :            : /* True on an OMP_TARGET statement if it represents explicit
    1484                 :            :    combined target teams, target parallel or target simd constructs.  */
    1485                 :            : #define OMP_TARGET_COMBINED(NODE) \
    1486                 :            :   (OMP_TARGET_CHECK (NODE)->base.private_flag)
    1487                 :            : 
    1488                 :            : /* Memory order for OMP_ATOMIC*.  */
    1489                 :            : #define OMP_ATOMIC_MEMORY_ORDER(NODE) \
    1490                 :            :   (TREE_RANGE_CHECK (NODE, OMP_ATOMIC, \
    1491                 :            :                      OMP_ATOMIC_CAPTURE_NEW)->base.u.omp_atomic_memory_order)
    1492                 :            : 
    1493                 :            : /* True on a PRIVATE clause if its decl is kept around for debugging
    1494                 :            :    information only and its DECL_VALUE_EXPR is supposed to point
    1495                 :            :    to what it has been remapped to.  */
    1496                 :            : #define OMP_CLAUSE_PRIVATE_DEBUG(NODE) \
    1497                 :            :   (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_PRIVATE)->base.public_flag)
    1498                 :            : 
    1499                 :            : /* True on a PRIVATE clause if ctor needs access to outer region's
    1500                 :            :    variable.  */
    1501                 :            : #define OMP_CLAUSE_PRIVATE_OUTER_REF(NODE) \
    1502                 :            :   TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_PRIVATE))
    1503                 :            : 
    1504                 :            : /* True if a PRIVATE clause is for a C++ class IV on taskloop construct
    1505                 :            :    (thus should be private on the outer taskloop and firstprivate on
    1506                 :            :    task).  */
    1507                 :            : #define OMP_CLAUSE_PRIVATE_TASKLOOP_IV(NODE) \
    1508                 :            :   TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_PRIVATE))
    1509                 :            : 
    1510                 :            : /* True on a FIRSTPRIVATE clause if it has been added implicitly.  */
    1511                 :            : #define OMP_CLAUSE_FIRSTPRIVATE_IMPLICIT(NODE) \
    1512                 :            :   (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_FIRSTPRIVATE)->base.public_flag)
    1513                 :            : 
    1514                 :            : /* True on a FIRSTPRIVATE clause if only the reference and not what it refers
    1515                 :            :    to should be firstprivatized.  */
    1516                 :            : #define OMP_CLAUSE_FIRSTPRIVATE_NO_REFERENCE(NODE) \
    1517                 :            :   TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_FIRSTPRIVATE))
    1518                 :            : 
    1519                 :            : /* True on a LASTPRIVATE clause if a FIRSTPRIVATE clause for the same
    1520                 :            :    decl is present in the chain.  */
    1521                 :            : #define OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE(NODE) \
    1522                 :            :   (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LASTPRIVATE)->base.public_flag)
    1523                 :            : #define OMP_CLAUSE_LASTPRIVATE_STMT(NODE) \
    1524                 :            :   OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE,                   \
    1525                 :            :                                                 OMP_CLAUSE_LASTPRIVATE),\
    1526                 :            :                       1)
    1527                 :            : #define OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ(NODE) \
    1528                 :            :   (OMP_CLAUSE_CHECK (NODE))->omp_clause.gimple_reduction_init
    1529                 :            : 
    1530                 :            : /* True if a LASTPRIVATE clause is for a C++ class IV on taskloop or
    1531                 :            :    loop construct (thus should be lastprivate on the outer taskloop and
    1532                 :            :    firstprivate on task for the taskloop construct and carefully handled
    1533                 :            :    for loop construct).  */
    1534                 :            : #define OMP_CLAUSE_LASTPRIVATE_LOOP_IV(NODE) \
    1535                 :            :   TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LASTPRIVATE))
    1536                 :            : 
    1537                 :            : /* True if a LASTPRIVATE clause has CONDITIONAL: modifier.  */
    1538                 :            : #define OMP_CLAUSE_LASTPRIVATE_CONDITIONAL(NODE) \
    1539                 :            :   TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LASTPRIVATE))
    1540                 :            : 
    1541                 :            : /* True on a SHARED clause if a FIRSTPRIVATE clause for the same
    1542                 :            :    decl is present in the chain (this can happen only for taskloop
    1543                 :            :    with FIRSTPRIVATE/LASTPRIVATE on it originally.  */
    1544                 :            : #define OMP_CLAUSE_SHARED_FIRSTPRIVATE(NODE) \
    1545                 :            :   (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SHARED)->base.public_flag)
    1546                 :            : 
    1547                 :            : /* True on a SHARED clause if a scalar is not modified in the body and
    1548                 :            :    thus could be optimized as firstprivate.  */
    1549                 :            : #define OMP_CLAUSE_SHARED_READONLY(NODE) \
    1550                 :            :   TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SHARED))
    1551                 :            : 
    1552                 :            : #define OMP_CLAUSE_IF_MODIFIER(NODE)    \
    1553                 :            :   (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_IF)->omp_clause.subcode.if_modifier)
    1554                 :            : 
    1555                 :            : #define OMP_CLAUSE_FINAL_EXPR(NODE) \
    1556                 :            :   OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_FINAL), 0)
    1557                 :            : #define OMP_CLAUSE_IF_EXPR(NODE) \
    1558                 :            :   OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_IF), 0)
    1559                 :            : #define OMP_CLAUSE_NUM_THREADS_EXPR(NODE) \
    1560                 :            :   OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_THREADS),0)
    1561                 :            : #define OMP_CLAUSE_SCHEDULE_CHUNK_EXPR(NODE) \
    1562                 :            :   OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SCHEDULE), 0)
    1563                 :            : #define OMP_CLAUSE_NUM_TASKS_EXPR(NODE) \
    1564                 :            :   OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_TASKS), 0)
    1565                 :            : #define OMP_CLAUSE_HINT_EXPR(NODE) \
    1566                 :            :   OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_HINT), 0)
    1567                 :            : 
    1568                 :            : #define OMP_CLAUSE_GRAINSIZE_EXPR(NODE) \
    1569                 :            :   OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_GRAINSIZE),0)
    1570                 :            : 
    1571                 :            : #define OMP_CLAUSE_PRIORITY_EXPR(NODE) \
    1572                 :            :   OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_PRIORITY),0)
    1573                 :            : 
    1574                 :            : /* OpenACC clause expressions  */
    1575                 :            : #define OMP_CLAUSE_EXPR(NODE, CLAUSE) \
    1576                 :            :   OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, CLAUSE), 0)
    1577                 :            : #define OMP_CLAUSE_GANG_EXPR(NODE) \
    1578                 :            :   OMP_CLAUSE_OPERAND ( \
    1579                 :            :     OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_GANG), 0)
    1580                 :            : #define OMP_CLAUSE_GANG_STATIC_EXPR(NODE) \
    1581                 :            :   OMP_CLAUSE_OPERAND ( \
    1582                 :            :     OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_GANG), 1)
    1583                 :            : #define OMP_CLAUSE_ASYNC_EXPR(NODE) \
    1584                 :            :   OMP_CLAUSE_OPERAND ( \
    1585                 :            :     OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ASYNC), 0)
    1586                 :            : #define OMP_CLAUSE_WAIT_EXPR(NODE) \
    1587                 :            :   OMP_CLAUSE_OPERAND ( \
    1588                 :            :     OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_WAIT), 0)
    1589                 :            : #define OMP_CLAUSE_VECTOR_EXPR(NODE) \
    1590                 :            :   OMP_CLAUSE_OPERAND ( \
    1591                 :            :     OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_VECTOR), 0)
    1592                 :            : #define OMP_CLAUSE_WORKER_EXPR(NODE) \
    1593                 :            :   OMP_CLAUSE_OPERAND ( \
    1594                 :            :     OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_WORKER), 0)
    1595                 :            : #define OMP_CLAUSE_NUM_GANGS_EXPR(NODE) \
    1596                 :            :   OMP_CLAUSE_OPERAND ( \
    1597                 :            :     OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_GANGS), 0)
    1598                 :            : #define OMP_CLAUSE_NUM_WORKERS_EXPR(NODE) \
    1599                 :            :   OMP_CLAUSE_OPERAND ( \
    1600                 :            :     OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_WORKERS), 0)
    1601                 :            : #define OMP_CLAUSE_VECTOR_LENGTH_EXPR(NODE) \
    1602                 :            :   OMP_CLAUSE_OPERAND ( \
    1603                 :            :     OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_VECTOR_LENGTH), 0)
    1604                 :            : 
    1605                 :            : #define OMP_CLAUSE_DEPEND_KIND(NODE) \
    1606                 :            :   (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEPEND)->omp_clause.subcode.depend_kind)
    1607                 :            : 
    1608                 :            : #define OMP_CLAUSE_DEPEND_SINK_NEGATIVE(NODE) \
    1609                 :            :   TREE_PUBLIC (TREE_LIST_CHECK (NODE))
    1610                 :            : 
    1611                 :            : #define OMP_CLAUSE_MAP_KIND(NODE) \
    1612                 :            :   ((enum gomp_map_kind) OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP)->omp_clause.subcode.map_kind)
    1613                 :            : #define OMP_CLAUSE_SET_MAP_KIND(NODE, MAP_KIND) \
    1614                 :            :   (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP)->omp_clause.subcode.map_kind \
    1615                 :            :    = (unsigned int) (MAP_KIND))
    1616                 :            : 
    1617                 :            : /* Nonzero if this map clause is for array (rather than pointer) based array
    1618                 :            :    section with zero bias.  Both the non-decl OMP_CLAUSE_MAP and corresponding
    1619                 :            :    OMP_CLAUSE_MAP with GOMP_MAP_POINTER are marked with this flag.  */
    1620                 :            : #define OMP_CLAUSE_MAP_ZERO_BIAS_ARRAY_SECTION(NODE) \
    1621                 :            :   (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP)->base.public_flag)
    1622                 :            : /* Nonzero if this is a mapped array section, that might need special
    1623                 :            :    treatment if OMP_CLAUSE_SIZE is zero.  */
    1624                 :            : #define OMP_CLAUSE_MAP_MAYBE_ZERO_LENGTH_ARRAY_SECTION(NODE) \
    1625                 :            :   TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP))
    1626                 :            : /* Nonzero if this map clause is for an OpenACC compute construct's reduction
    1627                 :            :    variable.  */
    1628                 :            : #define OMP_CLAUSE_MAP_IN_REDUCTION(NODE) \
    1629                 :            :   TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP))
    1630                 :            : 
    1631                 :            : /* True on an OMP_CLAUSE_USE_DEVICE_PTR with an OpenACC 'if_present'
    1632                 :            :    clause.  */
    1633                 :            : #define OMP_CLAUSE_USE_DEVICE_PTR_IF_PRESENT(NODE) \
    1634                 :            :   (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_USE_DEVICE_PTR)->base.public_flag)
    1635                 :            : 
    1636                 :            : #define OMP_CLAUSE_PROC_BIND_KIND(NODE) \
    1637                 :            :   (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_PROC_BIND)->omp_clause.subcode.proc_bind_kind)
    1638                 :            : 
    1639                 :            : #define OMP_CLAUSE_DEVICE_TYPE_KIND(NODE) \
    1640                 :            :   (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEVICE_TYPE)->omp_clause.subcode.device_type_kind)
    1641                 :            : 
    1642                 :            : #define OMP_CLAUSE_COLLAPSE_EXPR(NODE) \
    1643                 :            :   OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_COLLAPSE), 0)
    1644                 :            : #define OMP_CLAUSE_COLLAPSE_ITERVAR(NODE) \
    1645                 :            :   OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_COLLAPSE), 1)
    1646                 :            : #define OMP_CLAUSE_COLLAPSE_COUNT(NODE) \
    1647                 :            :   OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_COLLAPSE), 2)
    1648                 :            : 
    1649                 :            : #define OMP_CLAUSE_ORDERED_EXPR(NODE) \
    1650                 :            :   OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ORDERED), 0)
    1651                 :            : 
    1652                 :            : #define OMP_CLAUSE_REDUCTION_CODE(NODE) \
    1653                 :            :   (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_REDUCTION, \
    1654                 :            :      OMP_CLAUSE_IN_REDUCTION)->omp_clause.subcode.reduction_code)
    1655                 :            : #define OMP_CLAUSE_REDUCTION_INIT(NODE) \
    1656                 :            :   OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_REDUCTION, \
    1657                 :            :                                               OMP_CLAUSE_IN_REDUCTION), 1)
    1658                 :            : #define OMP_CLAUSE_REDUCTION_MERGE(NODE) \
    1659                 :            :   OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_REDUCTION, \
    1660                 :            :                                               OMP_CLAUSE_IN_REDUCTION), 2)
    1661                 :            : #define OMP_CLAUSE_REDUCTION_GIMPLE_INIT(NODE) \
    1662                 :            :   (OMP_CLAUSE_CHECK (NODE))->omp_clause.gimple_reduction_init
    1663                 :            : #define OMP_CLAUSE_REDUCTION_GIMPLE_MERGE(NODE) \
    1664                 :            :   (OMP_CLAUSE_CHECK (NODE))->omp_clause.gimple_reduction_merge
    1665                 :            : #define OMP_CLAUSE_REDUCTION_PLACEHOLDER(NODE) \
    1666                 :            :   OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_REDUCTION, \
    1667                 :            :                                               OMP_CLAUSE_IN_REDUCTION), 3)
    1668                 :            : #define OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER(NODE) \
    1669                 :            :   OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_REDUCTION, \
    1670                 :            :                                               OMP_CLAUSE_IN_REDUCTION), 4)
    1671                 :            : 
    1672                 :            : /* True if a REDUCTION clause may reference the original list item (omp_orig)
    1673                 :            :    in its OMP_CLAUSE_REDUCTION_{,GIMPLE_}INIT.  */
    1674                 :            : #define OMP_CLAUSE_REDUCTION_OMP_ORIG_REF(NODE) \
    1675                 :            :   (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_REDUCTION, \
    1676                 :            :                            OMP_CLAUSE_IN_REDUCTION)->base.public_flag)
    1677                 :            : 
    1678                 :            : /* True if a REDUCTION clause has task reduction-modifier.  */
    1679                 :            : #define OMP_CLAUSE_REDUCTION_TASK(NODE) \
    1680                 :            :   TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_REDUCTION))
    1681                 :            : 
    1682                 :            : /* True if a REDUCTION clause has inscan reduction-modifier.  */
    1683                 :            : #define OMP_CLAUSE_REDUCTION_INSCAN(NODE) \
    1684                 :            :   TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_REDUCTION))
    1685                 :            : 
    1686                 :            : /* True if a LINEAR clause doesn't need copy in.  True for iterator vars which
    1687                 :            :    are always initialized inside of the loop construct, false otherwise.  */
    1688                 :            : #define OMP_CLAUSE_LINEAR_NO_COPYIN(NODE) \
    1689                 :            :   (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR)->base.public_flag)
    1690                 :            : 
    1691                 :            : /* True if a LINEAR clause doesn't need copy out.  True for iterator vars which
    1692                 :            :    are declared inside of the simd construct.  */
    1693                 :            : #define OMP_CLAUSE_LINEAR_NO_COPYOUT(NODE) \
    1694                 :            :   TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR))
    1695                 :            : 
    1696                 :            : /* True if a LINEAR clause has a stride that is variable.  */
    1697                 :            : #define OMP_CLAUSE_LINEAR_VARIABLE_STRIDE(NODE) \
    1698                 :            :   TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR))
    1699                 :            : 
    1700                 :            : /* True if a LINEAR clause is for an array or allocatable variable that
    1701                 :            :    needs special handling by the frontend.  */
    1702                 :            : #define OMP_CLAUSE_LINEAR_ARRAY(NODE) \
    1703                 :            :   (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR)->base.deprecated_flag)
    1704                 :            : 
    1705                 :            : #define OMP_CLAUSE_LINEAR_STEP(NODE) \
    1706                 :            :   OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR), 1)
    1707                 :            : 
    1708                 :            : #define OMP_CLAUSE_LINEAR_STMT(NODE) \
    1709                 :            :   OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR), 2)
    1710                 :            : 
    1711                 :            : #define OMP_CLAUSE_LINEAR_GIMPLE_SEQ(NODE) \
    1712                 :            :   (OMP_CLAUSE_CHECK (NODE))->omp_clause.gimple_reduction_init
    1713                 :            : 
    1714                 :            : #define OMP_CLAUSE_LINEAR_KIND(NODE) \
    1715                 :            :   (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR)->omp_clause.subcode.linear_kind)
    1716                 :            : 
    1717                 :            : #define OMP_CLAUSE_ALIGNED_ALIGNMENT(NODE) \
    1718                 :            :   OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ALIGNED), 1)
    1719                 :            : 
    1720                 :            : #define OMP_CLAUSE_NUM_TEAMS_EXPR(NODE) \
    1721                 :            :   OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_TEAMS), 0)
    1722                 :            : 
    1723                 :            : #define OMP_CLAUSE_THREAD_LIMIT_EXPR(NODE) \
    1724                 :            :   OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, \
    1725                 :            :                                                 OMP_CLAUSE_THREAD_LIMIT), 0)
    1726                 :            : 
    1727                 :            : #define OMP_CLAUSE_DEVICE_ID(NODE) \
    1728                 :            :   OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEVICE), 0)
    1729                 :            : 
    1730                 :            : #define OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR(NODE) \
    1731                 :            :   OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, \
    1732                 :            :                                                 OMP_CLAUSE_DIST_SCHEDULE), 0)
    1733                 :            : 
    1734                 :            : #define OMP_CLAUSE_SAFELEN_EXPR(NODE) \
    1735                 :            :   OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SAFELEN), 0)
    1736                 :            : 
    1737                 :            : #define OMP_CLAUSE_SIMDLEN_EXPR(NODE) \
    1738                 :            :   OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SIMDLEN), 0)
    1739                 :            : 
    1740                 :            : #define OMP_CLAUSE__SIMDUID__DECL(NODE) \
    1741                 :            :   OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE__SIMDUID_), 0)
    1742                 :            : 
    1743                 :            : #define OMP_CLAUSE_SCHEDULE_KIND(NODE) \
    1744                 :            :   (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SCHEDULE)->omp_clause.subcode.schedule_kind)
    1745                 :            : 
    1746                 :            : /* True if a SCHEDULE clause has the simd modifier on it.  */
    1747                 :            : #define OMP_CLAUSE_SCHEDULE_SIMD(NODE) \
    1748                 :            :   (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SCHEDULE)->base.public_flag)
    1749                 :            : 
    1750                 :            : #define OMP_CLAUSE_DEFAULT_KIND(NODE) \
    1751                 :            :   (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEFAULT)->omp_clause.subcode.default_kind)
    1752                 :            : 
    1753                 :            : #define OMP_CLAUSE_DEFAULTMAP_KIND(NODE) \
    1754                 :            :   (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEFAULTMAP)->omp_clause.subcode.defaultmap_kind)
    1755                 :            : #define OMP_CLAUSE_DEFAULTMAP_CATEGORY(NODE) \
    1756                 :            :   ((enum omp_clause_defaultmap_kind) \
    1757                 :            :    (OMP_CLAUSE_DEFAULTMAP_KIND (NODE) & OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK))
    1758                 :            : #define OMP_CLAUSE_DEFAULTMAP_BEHAVIOR(NODE) \
    1759                 :            :   ((enum omp_clause_defaultmap_kind) \
    1760                 :            :    (OMP_CLAUSE_DEFAULTMAP_KIND (NODE) & OMP_CLAUSE_DEFAULTMAP_MASK))
    1761                 :            : #define OMP_CLAUSE_DEFAULTMAP_SET_KIND(NODE, BEHAVIOR, CATEGORY) \
    1762                 :            :   (OMP_CLAUSE_DEFAULTMAP_KIND (NODE) \
    1763                 :            :    = (enum omp_clause_defaultmap_kind) (CATEGORY | BEHAVIOR))
    1764                 :            : 
    1765                 :            : #define OMP_CLAUSE_BIND_KIND(NODE) \
    1766                 :            :   (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_BIND)->omp_clause.subcode.bind_kind)
    1767                 :            : 
    1768                 :            : #define OMP_CLAUSE_TILE_LIST(NODE) \
    1769                 :            :   OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_TILE), 0)
    1770                 :            : #define OMP_CLAUSE_TILE_ITERVAR(NODE) \
    1771                 :            :   OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_TILE), 1)
    1772                 :            : #define OMP_CLAUSE_TILE_COUNT(NODE) \
    1773                 :            :   OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_TILE), 2)
    1774                 :            : 
    1775                 :            : #define OMP_CLAUSE__GRIDDIM__DIMENSION(NODE) \
    1776                 :            :   (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE__GRIDDIM_)\
    1777                 :            :    ->omp_clause.subcode.dimension)
    1778                 :            : #define OMP_CLAUSE__GRIDDIM__SIZE(NODE) \
    1779                 :            :   OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE__GRIDDIM_), 0)
    1780                 :            : #define OMP_CLAUSE__GRIDDIM__GROUP(NODE) \
    1781                 :            :   OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE__GRIDDIM_), 1)
    1782                 :            : 
    1783                 :            : /* _CONDTEMP_ holding temporary with iteration count.  */
    1784                 :            : #define OMP_CLAUSE__CONDTEMP__ITER(NODE) \
    1785                 :            :   (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE__CONDTEMP_)->base.public_flag)
    1786                 :            : 
    1787                 :            : /* _SCANTEMP_ holding temporary with pointer to thread's local array;
    1788                 :            :    allocation.  */
    1789                 :            : #define OMP_CLAUSE__SCANTEMP__ALLOC(NODE) \
    1790                 :            :   (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE__SCANTEMP_)->base.public_flag)
    1791                 :            : 
    1792                 :            : /* _SCANTEMP_ holding temporary with a control variable for deallocation;
    1793                 :            :    one boolean_type_node for test whether alloca was used, another one
    1794                 :            :    to pass to __builtin_stack_restore or free.  */
    1795                 :            : #define OMP_CLAUSE__SCANTEMP__CONTROL(NODE) \
    1796                 :            :   TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE__SCANTEMP_))
    1797                 :            : 
    1798                 :            : /* SSA_NAME accessors.  */
    1799                 :            : 
    1800                 :            : /* Whether SSA_NAME NODE is a virtual operand.  This simply caches the
    1801                 :            :    information in the underlying SSA_NAME_VAR for efficiency.  */
    1802                 :            : #define SSA_NAME_IS_VIRTUAL_OPERAND(NODE) \
    1803                 :            :   SSA_NAME_CHECK (NODE)->base.public_flag
    1804                 :            : 
    1805                 :            : /* Returns the IDENTIFIER_NODE giving the SSA name a name or NULL_TREE
    1806                 :            :    if there is no name associated with it.  */
    1807                 :            : #define SSA_NAME_IDENTIFIER(NODE)                               \
    1808                 :            :   (SSA_NAME_CHECK (NODE)->ssa_name.var != NULL_TREE          \
    1809                 :            :    ? (TREE_CODE ((NODE)->ssa_name.var) == IDENTIFIER_NODE    \
    1810                 :            :       ? (NODE)->ssa_name.var                                 \
    1811                 :            :       : DECL_NAME ((NODE)->ssa_name.var))                    \
    1812                 :            :    : NULL_TREE)
    1813                 :            : 
    1814                 :            : /* Returns the variable being referenced.  This can be NULL_TREE for
    1815                 :            :    temporaries not associated with any user variable.
    1816                 :            :    Once released, this is the only field that can be relied upon.  */
    1817                 :            : #define SSA_NAME_VAR(NODE)                                      \
    1818                 :            :   (SSA_NAME_CHECK (NODE)->ssa_name.var == NULL_TREE          \
    1819                 :            :    || TREE_CODE ((NODE)->ssa_name.var) == IDENTIFIER_NODE    \
    1820                 :            :    ? NULL_TREE : (NODE)->ssa_name.var)
    1821                 :            : 
    1822                 :            : #define SET_SSA_NAME_VAR_OR_IDENTIFIER(NODE,VAR) \
    1823                 :            :   do \
    1824                 :            :     { \
    1825                 :            :       tree var_ = (VAR); \
    1826                 :            :       SSA_NAME_CHECK (NODE)->ssa_name.var = var_; \
    1827                 :            :       SSA_NAME_IS_VIRTUAL_OPERAND (NODE) \
    1828                 :            :         = (var_ \
    1829                 :            :            && TREE_CODE (var_) == VAR_DECL \
    1830                 :            :            && VAR_DECL_IS_VIRTUAL_OPERAND (var_)); \
    1831                 :            :     } \
    1832                 :            :   while (0)
    1833                 :            : 
    1834                 :            : /* Returns the statement which defines this SSA name.  */
    1835                 :            : #define SSA_NAME_DEF_STMT(NODE) SSA_NAME_CHECK (NODE)->ssa_name.def_stmt
    1836                 :            : 
    1837                 :            : /* Returns the SSA version number of this SSA name.  Note that in
    1838                 :            :    tree SSA, version numbers are not per variable and may be recycled.  */
    1839                 :            : #define SSA_NAME_VERSION(NODE)  SSA_NAME_CHECK (NODE)->base.u.version
    1840                 :            : 
    1841                 :            : /* Nonzero if this SSA name occurs in an abnormal PHI.  SSA_NAMES are
    1842                 :            :    never output, so we can safely use the ASM_WRITTEN_FLAG for this
    1843                 :            :    status bit.  */
    1844                 :            : #define SSA_NAME_OCCURS_IN_ABNORMAL_PHI(NODE) \
    1845                 :            :     SSA_NAME_CHECK (NODE)->base.asm_written_flag
    1846                 :            : 
    1847                 :            : /* Nonzero if this SSA_NAME expression is currently on the free list of
    1848                 :            :    SSA_NAMES.  Using NOTHROW_FLAG seems reasonably safe since throwing
    1849                 :            :    has no meaning for an SSA_NAME.  */
    1850                 :            : #define SSA_NAME_IN_FREE_LIST(NODE) \
    1851                 :            :     SSA_NAME_CHECK (NODE)->base.nothrow_flag
    1852                 :            : 
    1853                 :            : /* Nonzero if this SSA_NAME is the default definition for the
    1854                 :            :    underlying symbol.  A default SSA name is created for symbol S if
    1855                 :            :    the very first reference to S in the function is a read operation.
    1856                 :            :    Default definitions are always created by an empty statement and
    1857                 :            :    belong to no basic block.  */
    1858                 :            : #define SSA_NAME_IS_DEFAULT_DEF(NODE) \
    1859                 :            :     SSA_NAME_CHECK (NODE)->base.default_def_flag
    1860                 :            : 
    1861                 :            : /* Nonzero if this SSA_NAME is known to point to memory that may not
    1862                 :            :    be written to.  This is set for default defs of function parameters
    1863                 :            :    that have a corresponding r or R specification in the functions
    1864                 :            :    fn spec attribute.  This is used by alias analysis.  */
    1865                 :            : #define SSA_NAME_POINTS_TO_READONLY_MEMORY(NODE) \
    1866                 :            :     SSA_NAME_CHECK (NODE)->base.deprecated_flag
    1867                 :            : 
    1868                 :            : /* Attributes for SSA_NAMEs for pointer-type variables.  */
    1869                 :            : #define SSA_NAME_PTR_INFO(N) \
    1870                 :            :    SSA_NAME_CHECK (N)->ssa_name.info.ptr_info
    1871                 :            : 
    1872                 :            : /* True if SSA_NAME_RANGE_INFO describes an anti-range.  */
    1873                 :            : #define SSA_NAME_ANTI_RANGE_P(N) \
    1874                 :            :     SSA_NAME_CHECK (N)->base.static_flag
    1875                 :            : 
    1876                 :            : /* The type of range described by SSA_NAME_RANGE_INFO.  */
    1877                 :            : #define SSA_NAME_RANGE_TYPE(N) \
    1878                 :            :     (SSA_NAME_ANTI_RANGE_P (N) ? VR_ANTI_RANGE : VR_RANGE)
    1879                 :            : 
    1880                 :            : /* Value range info attributes for SSA_NAMEs of non pointer-type variables.  */
    1881                 :            : #define SSA_NAME_RANGE_INFO(N) \
    1882                 :            :     SSA_NAME_CHECK (N)->ssa_name.info.range_info
    1883                 :            : 
    1884                 :            : /* Return the immediate_use information for an SSA_NAME. */
    1885                 :            : #define SSA_NAME_IMM_USE_NODE(NODE) SSA_NAME_CHECK (NODE)->ssa_name.imm_uses
    1886                 :            : 
    1887                 :            : #define OMP_CLAUSE_CODE(NODE)                                   \
    1888                 :            :         (OMP_CLAUSE_CHECK (NODE))->omp_clause.code
    1889                 :            : 
    1890                 :            : #define OMP_CLAUSE_SET_CODE(NODE, CODE)                         \
    1891                 :            :         ((OMP_CLAUSE_CHECK (NODE))->omp_clause.code = (CODE))
    1892                 :            : 
    1893                 :            : #define OMP_CLAUSE_OPERAND(NODE, I)                             \
    1894                 :            :         OMP_CLAUSE_ELT_CHECK (NODE, I)
    1895                 :            : 
    1896                 :            : /* In a BLOCK node.  */
    1897                 :            : #define BLOCK_VARS(NODE) (BLOCK_CHECK (NODE)->block.vars)
    1898                 :            : #define BLOCK_NONLOCALIZED_VARS(NODE) \
    1899                 :            :   (BLOCK_CHECK (NODE)->block.nonlocalized_vars)
    1900                 :            : #define BLOCK_NUM_NONLOCALIZED_VARS(NODE) \
    1901                 :            :   vec_safe_length (BLOCK_NONLOCALIZED_VARS (NODE))
    1902                 :            : #define BLOCK_NONLOCALIZED_VAR(NODE,N) (*BLOCK_NONLOCALIZED_VARS (NODE))[N]
    1903                 :            : #define BLOCK_SUBBLOCKS(NODE) (BLOCK_CHECK (NODE)->block.subblocks)
    1904                 :            : #define BLOCK_SUPERCONTEXT(NODE) (BLOCK_CHECK (NODE)->block.supercontext)
    1905                 :            : #define BLOCK_CHAIN(NODE) (BLOCK_CHECK (NODE)->block.chain)
    1906                 :            : #define BLOCK_ABSTRACT_ORIGIN(NODE) (BLOCK_CHECK (NODE)->block.abstract_origin)
    1907                 :            : #define BLOCK_ORIGIN(NODE) \
    1908                 :            :   (BLOCK_ABSTRACT_ORIGIN(NODE) ? BLOCK_ABSTRACT_ORIGIN(NODE) : (NODE))
    1909                 :            : #define BLOCK_DIE(NODE) (BLOCK_CHECK (NODE)->block.die)
    1910                 :            : 
    1911                 :            : /* True if BLOCK has the same ranges as its BLOCK_SUPERCONTEXT.  */
    1912                 :            : #define BLOCK_SAME_RANGE(NODE) (BLOCK_CHECK (NODE)->base.u.bits.nameless_flag)
    1913                 :            : 
    1914                 :            : /* True if BLOCK appears in cold section.  */
    1915                 :            : #define BLOCK_IN_COLD_SECTION_P(NODE) \
    1916                 :            :   (BLOCK_CHECK (NODE)->base.u.bits.atomic_flag)
    1917                 :            : 
    1918                 :            : /* An index number for this block.  These values are not guaranteed to
    1919                 :            :    be unique across functions -- whether or not they are depends on
    1920                 :            :    the debugging output format in use.  */
    1921                 :            : #define BLOCK_NUMBER(NODE) (BLOCK_CHECK (NODE)->block.block_num)
    1922                 :            : 
    1923                 :            : /* If block reordering splits a lexical block into discontiguous
    1924                 :            :    address ranges, we'll make a copy of the original block.
    1925                 :            : 
    1926                 :            :    Note that this is logically distinct from BLOCK_ABSTRACT_ORIGIN.
    1927                 :            :    In that case, we have one source block that has been replicated
    1928                 :            :    (through inlining or unrolling) into many logical blocks, and that
    1929                 :            :    these logical blocks have different physical variables in them.
    1930                 :            : 
    1931                 :            :    In this case, we have one logical block split into several
    1932                 :            :    non-contiguous address ranges.  Most debug formats can't actually
    1933                 :            :    represent this idea directly, so we fake it by creating multiple
    1934                 :            :    logical blocks with the same variables in them.  However, for those
    1935                 :            :    that do support non-contiguous regions, these allow the original
    1936                 :            :    logical block to be reconstructed, along with the set of address
    1937                 :            :    ranges.
    1938                 :            : 
    1939                 :            :    One of the logical block fragments is arbitrarily chosen to be
    1940                 :            :    the ORIGIN.  The other fragments will point to the origin via
    1941                 :            :    BLOCK_FRAGMENT_ORIGIN; the origin itself will have this pointer
    1942                 :            :    be null.  The list of fragments will be chained through
    1943                 :            :    BLOCK_FRAGMENT_CHAIN from the origin.  */
    1944                 :            : 
    1945                 :            : #define BLOCK_FRAGMENT_ORIGIN(NODE) (BLOCK_CHECK (NODE)->block.fragment_origin)
    1946                 :            : #define BLOCK_FRAGMENT_CHAIN(NODE) (BLOCK_CHECK (NODE)->block.fragment_chain)
    1947                 :            : 
    1948                 :            : /* For an inlined function, this gives the location where it was called
    1949                 :            :    from.  This is only set in the top level block, which corresponds to the
    1950                 :            :    inlined function scope.  This is used in the debug output routines.  */
    1951                 :            : 
    1952                 :            : #define BLOCK_SOURCE_LOCATION(NODE) (BLOCK_CHECK (NODE)->block.locus)
    1953                 :            : 
    1954                 :            : /* This gives the location of the end of the block, useful to attach
    1955                 :            :    code implicitly generated for outgoing paths.  */
    1956                 :            : 
    1957                 :            : #define BLOCK_SOURCE_END_LOCATION(NODE) (BLOCK_CHECK (NODE)->block.end_locus)
    1958                 :            : 
    1959                 :            : /* Define fields and accessors for nodes representing data types.  */
    1960                 :            : 
    1961                 :            : /* See tree.def for documentation of the use of these fields.
    1962                 :            :    Look at the documentation of the various ..._TYPE tree codes.
    1963                 :            : 
    1964                 :            :    Note that the type.values, type.minval, and type.maxval fields are
    1965                 :            :    overloaded and used for different macros in different kinds of types.
    1966                 :            :    Each macro must check to ensure the tree node is of the proper kind of
    1967                 :            :    type.  Note also that some of the front-ends also overload these fields,
    1968                 :            :    so they must be checked as well.  */
    1969                 :            : 
    1970                 :            : #define TYPE_UID(NODE) (TYPE_CHECK (NODE)->type_common.uid)
    1971                 :            : /* Type size in bits as a tree expression.  Need not be constant
    1972                 :            :    and may be null.  */
    1973                 :            : #define TYPE_SIZE(NODE) (TYPE_CHECK (NODE)->type_common.size)
    1974                 :            : /* Likewise, type size in bytes.  */
    1975                 :            : #define TYPE_SIZE_UNIT(NODE) (TYPE_CHECK (NODE)->type_common.size_unit)
    1976                 :            : #define TYPE_POINTER_TO(NODE) (TYPE_CHECK (NODE)->type_common.pointer_to)
    1977                 :            : #define TYPE_REFERENCE_TO(NODE) (TYPE_CHECK (NODE)->type_common.reference_to)
    1978                 :            : #define TYPE_PRECISION(NODE) (TYPE_CHECK (NODE)->type_common.precision)
    1979                 :            : #define TYPE_NAME(NODE) (TYPE_CHECK (NODE)->type_common.name)
    1980                 :            : #define TYPE_NEXT_VARIANT(NODE) (TYPE_CHECK (NODE)->type_common.next_variant)
    1981                 :            : #define TYPE_MAIN_VARIANT(NODE) (TYPE_CHECK (NODE)->type_common.main_variant)
    1982                 :            : #define TYPE_CONTEXT(NODE) (TYPE_CHECK (NODE)->type_common.context)
    1983                 :            : 
    1984                 :            : #define TYPE_MODE_RAW(NODE) (TYPE_CHECK (NODE)->type_common.mode)
    1985                 :            : #define TYPE_MODE(NODE) \
    1986                 :            :   (VECTOR_TYPE_P (TYPE_CHECK (NODE)) \
    1987                 :            :    ? vector_type_mode (NODE) : (NODE)->type_common.mode)
    1988                 :            : #define SCALAR_TYPE_MODE(NODE) \
    1989                 :            :   (as_a <scalar_mode> (TYPE_CHECK (NODE)->type_common.mode))
    1990                 :            : #define SCALAR_INT_TYPE_MODE(NODE) \
    1991                 :            :   (as_a <scalar_int_mode> (TYPE_CHECK (NODE)->type_common.mode))
    1992                 :            : #define SCALAR_FLOAT_TYPE_MODE(NODE) \
    1993                 :            :   (as_a <scalar_float_mode> (TYPE_CHECK (NODE)->type_common.mode))
    1994                 :            : #define SET_TYPE_MODE(NODE, MODE) \
    1995                 :            :   (TYPE_CHECK (NODE)->type_common.mode = (MODE))
    1996                 :            : 
    1997                 :            : extern machine_mode element_mode (const_tree);
    1998                 :            : extern machine_mode vector_type_mode (const_tree);
    1999                 :            : 
    2000                 :            : /* The "canonical" type for this type node, which is used by frontends to
    2001                 :            :    compare the type for equality with another type.  If two types are
    2002                 :            :    equal (based on the semantics of the language), then they will have
    2003                 :            :    equivalent TYPE_CANONICAL entries.
    2004                 :            : 
    2005                 :            :    As a special case, if TYPE_CANONICAL is NULL_TREE, and thus
    2006                 :            :    TYPE_STRUCTURAL_EQUALITY_P is true, then it cannot
    2007                 :            :    be used for comparison against other types.  Instead, the type is
    2008                 :            :    said to require structural equality checks, described in
    2009                 :            :    TYPE_STRUCTURAL_EQUALITY_P.
    2010                 :            : 
    2011                 :            :    For unqualified aggregate and function types the middle-end relies on
    2012                 :            :    TYPE_CANONICAL to tell whether two variables can be assigned
    2013                 :            :    to each other without a conversion.  The middle-end also makes sure
    2014                 :            :    to assign the same alias-sets to the type partition with equal
    2015                 :            :    TYPE_CANONICAL of their unqualified variants.  */
    2016                 :            : #define TYPE_CANONICAL(NODE) (TYPE_CHECK (NODE)->type_common.canonical)
    2017                 :            : /* Indicates that the type node requires structural equality
    2018                 :            :    checks.  The compiler will need to look at the composition of the
    2019                 :            :    type to determine whether it is equal to another type, rather than
    2020                 :            :    just comparing canonical type pointers.  For instance, we would need
    2021                 :            :    to look at the return and parameter types of a FUNCTION_TYPE
    2022                 :            :    node.  */
    2023                 :            : #define TYPE_STRUCTURAL_EQUALITY_P(NODE) (TYPE_CANONICAL (NODE) == NULL_TREE)
    2024                 :            : /* Sets the TYPE_CANONICAL field to NULL_TREE, indicating that the
    2025                 :            :    type node requires structural equality.  */
    2026                 :            : #define SET_TYPE_STRUCTURAL_EQUALITY(NODE) (TYPE_CANONICAL (NODE) = NULL_TREE)
    2027                 :            : 
    2028                 :            : #define TYPE_IBIT(NODE) (GET_MODE_IBIT (TYPE_MODE (NODE)))
    2029                 :            : #define TYPE_FBIT(NODE) (GET_MODE_FBIT (TYPE_MODE (NODE)))
    2030                 :            : 
    2031                 :            : /* The (language-specific) typed-based alias set for this type.
    2032                 :            :    Objects whose TYPE_ALIAS_SETs are different cannot alias each
    2033                 :            :    other.  If the TYPE_ALIAS_SET is -1, no alias set has yet been
    2034                 :            :    assigned to this type.  If the TYPE_ALIAS_SET is 0, objects of this
    2035                 :            :    type can alias objects of any type.  */
    2036                 :            : #define TYPE_ALIAS_SET(NODE) (TYPE_CHECK (NODE)->type_common.alias_set)
    2037                 :            : 
    2038                 :            : /* Nonzero iff the typed-based alias set for this type has been
    2039                 :            :    calculated.  */
    2040                 :            : #define TYPE_ALIAS_SET_KNOWN_P(NODE) \
    2041                 :            :   (TYPE_CHECK (NODE)->type_common.alias_set != -1)
    2042                 :            : 
    2043                 :            : /* A TREE_LIST of IDENTIFIER nodes of the attributes that apply
    2044                 :            :    to this type.  */
    2045                 :            : #define TYPE_ATTRIBUTES(NODE) (TYPE_CHECK (NODE)->type_common.attributes)
    2046                 :            : 
    2047                 :            : /* The alignment necessary for objects of this type.
    2048                 :            :    The value is an int, measured in bits and must be a power of two.
    2049                 :            :    We support also an "alignment" of zero.  */
    2050                 :            : #define TYPE_ALIGN(NODE) \
    2051                 :            :     (TYPE_CHECK (NODE)->type_common.align \
    2052                 :            :      ? ((unsigned)1) << ((NODE)->type_common.align - 1) : 0)
    2053                 :            : 
    2054                 :            : /* Specify that TYPE_ALIGN(NODE) is X.  */
    2055                 :            : #define SET_TYPE_ALIGN(NODE, X) \
    2056                 :            :     (TYPE_CHECK (NODE)->type_common.align = ffs_hwi (X))
    2057                 :            : 
    2058                 :            : /* 1 if the alignment for this type was requested by "aligned" attribute,
    2059                 :            :    0 if it is the default for this type.  */
    2060                 :            : #define TYPE_USER_ALIGN(NODE) (TYPE_CHECK (NODE)->base.u.bits.user_align)
    2061                 :            : 
    2062                 :            : /* The alignment for NODE, in bytes.  */
    2063                 :            : #define TYPE_ALIGN_UNIT(NODE) (TYPE_ALIGN (NODE) / BITS_PER_UNIT)
    2064                 :            : 
    2065                 :            : /* The minimum alignment necessary for objects of this type without
    2066                 :            :    warning.  The value is an int, measured in bits.  */
    2067                 :            : #define TYPE_WARN_IF_NOT_ALIGN(NODE) \
    2068                 :            :     (TYPE_CHECK (NODE)->type_common.warn_if_not_align \
    2069                 :            :      ? ((unsigned)1) << ((NODE)->type_common.warn_if_not_align - 1) : 0)
    2070                 :            : 
    2071                 :            : /* Specify that TYPE_WARN_IF_NOT_ALIGN(NODE) is X.  */
    2072                 :            : #define SET_TYPE_WARN_IF_NOT_ALIGN(NODE, X) \
    2073                 :            :     (TYPE_CHECK (NODE)->type_common.warn_if_not_align = ffs_hwi (X))
    2074                 :            : 
    2075                 :            : /* If your language allows you to declare types, and you want debug info
    2076                 :            :    for them, then you need to generate corresponding TYPE_DECL nodes.
    2077                 :            :    These "stub" TYPE_DECL nodes have no name, and simply point at the
    2078                 :            :    type node.  You then set the TYPE_STUB_DECL field of the type node
    2079                 :            :    to point back at the TYPE_DECL node.  This allows the debug routines
    2080                 :            :    to know that the two nodes represent the same type, so that we only
    2081                 :            :    get one debug info record for them.  */
    2082                 :            : #define TYPE_STUB_DECL(NODE) (TREE_CHAIN (TYPE_CHECK (NODE)))
    2083                 :            : 
    2084                 :            : /* In a RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE or ARRAY_TYPE, it means
    2085                 :            :    the type has BLKmode only because it lacks the alignment required for
    2086                 :            :    its size.  */
    2087                 :            : #define TYPE_NO_FORCE_BLK(NODE) \
    2088                 :            :   (TYPE_CHECK (NODE)->type_common.no_force_blk_flag)
    2089                 :            : 
    2090                 :            : /* Nonzero in a type considered volatile as a whole.  */
    2091                 :            : #define TYPE_VOLATILE(NODE) (TYPE_CHECK (NODE)->base.volatile_flag)
    2092                 :            : 
    2093                 :            : /* Nonzero in a type considered atomic as a whole.  */
    2094                 :            : #define TYPE_ATOMIC(NODE) (TYPE_CHECK (NODE)->base.u.bits.atomic_flag)
    2095                 :            : 
    2096                 :            : /* Means this type is const-qualified.  */
    2097                 :            : #define TYPE_READONLY(NODE) (TYPE_CHECK (NODE)->base.readonly_flag)
    2098                 :            : 
    2099                 :            : /* If nonzero, this type is `restrict'-qualified, in the C sense of
    2100                 :            :    the term.  */
    2101                 :            : #define TYPE_RESTRICT(NODE) (TYPE_CHECK (NODE)->type_common.restrict_flag)
    2102                 :            : 
    2103                 :            : /* If nonzero, type's name shouldn't be emitted into debug info.  */
    2104                 :            : #define TYPE_NAMELESS(NODE) (TYPE_CHECK (NODE)->base.u.bits.nameless_flag)
    2105                 :            : 
    2106                 :            : /* The address space the type is in.  */
    2107                 :            : #define TYPE_ADDR_SPACE(NODE) (TYPE_CHECK (NODE)->base.u.bits.address_space)
    2108                 :            : 
    2109                 :            : /* Encode/decode the named memory support as part of the qualifier.  If more
    2110                 :            :    than 8 qualifiers are added, these macros need to be adjusted.  */
    2111                 :            : #define ENCODE_QUAL_ADDR_SPACE(NUM) ((NUM & 0xFF) << 8)
    2112                 :            : #define DECODE_QUAL_ADDR_SPACE(X) (((X) >> 8) & 0xFF)
    2113                 :            : 
    2114                 :            : /* Return all qualifiers except for the address space qualifiers.  */
    2115                 :            : #define CLEAR_QUAL_ADDR_SPACE(X) ((X) & ~0xFF00)
    2116                 :            : 
    2117                 :            : /* Only keep the address space out of the qualifiers and discard the other
    2118                 :            :    qualifiers.  */
    2119                 :            : #define KEEP_QUAL_ADDR_SPACE(X) ((X) & 0xFF00)
    2120                 :            : 
    2121                 :            : /* The set of type qualifiers for this type.  */
    2122                 :            : #define TYPE_QUALS(NODE)                                        \
    2123                 :            :   ((int) ((TYPE_READONLY (NODE) * TYPE_QUAL_CONST)              \
    2124                 :            :           | (TYPE_VOLATILE (NODE) * TYPE_QUAL_VOLATILE)         \
    2125                 :            :           | (TYPE_ATOMIC (NODE) * TYPE_QUAL_ATOMIC)             \
    2126                 :            :           | (TYPE_RESTRICT (NODE) * TYPE_QUAL_RESTRICT)         \
    2127                 :            :           | (ENCODE_QUAL_ADDR_SPACE (TYPE_ADDR_SPACE (NODE)))))
    2128                 :            : 
    2129                 :            : /* The same as TYPE_QUALS without the address space qualifications.  */
    2130                 :            : #define TYPE_QUALS_NO_ADDR_SPACE(NODE)                          \
    2131                 :            :   ((int) ((TYPE_READONLY (NODE) * TYPE_QUAL_CONST)              \
    2132                 :            :           | (TYPE_VOLATILE (NODE) * TYPE_QUAL_VOLATILE)         \
    2133                 :            :           | (TYPE_ATOMIC (NODE) * TYPE_QUAL_ATOMIC)             \
    2134                 :            :           | (TYPE_RESTRICT (NODE) * TYPE_QUAL_RESTRICT)))
    2135                 :            : 
    2136                 :            : /* The same as TYPE_QUALS without the address space and atomic 
    2137                 :            :    qualifications.  */
    2138                 :            : #define TYPE_QUALS_NO_ADDR_SPACE_NO_ATOMIC(NODE)                \
    2139                 :            :   ((int) ((TYPE_READONLY (NODE) * TYPE_QUAL_CONST)              \
    2140                 :            :           | (TYPE_VOLATILE (NODE) * TYPE_QUAL_VOLATILE)         \
    2141                 :            :           | (TYPE_RESTRICT (NODE) * TYPE_QUAL_RESTRICT)))
    2142                 :            : 
    2143                 :            : /* These flags are available for each language front end to use internally.  */
    2144                 :            : #define TYPE_LANG_FLAG_0(NODE) (TYPE_CHECK (NODE)->type_common.lang_flag_0)
    2145                 :            : #define TYPE_LANG_FLAG_1(NODE) (TYPE_CHECK (NODE)->type_common.lang_flag_1)
    2146                 :            : #define TYPE_LANG_FLAG_2(NODE) (TYPE_CHECK (NODE)->type_common.lang_flag_2)
    2147                 :            : #define TYPE_LANG_FLAG_3(NODE) (TYPE_CHECK (NODE)->type_common.lang_flag_3)
    2148                 :            : #define TYPE_LANG_FLAG_4(NODE) (TYPE_CHECK (NODE)->type_common.lang_flag_4)
    2149                 :            : #define TYPE_LANG_FLAG_5(NODE) (TYPE_CHECK (NODE)->type_common.lang_flag_5)
    2150                 :            : #define TYPE_LANG_FLAG_6(NODE) (TYPE_CHECK (NODE)->type_common.lang_flag_6)
    2151                 :            : #define TYPE_LANG_FLAG_7(NODE) (TYPE_CHECK (NODE)->type_common.lang_flag_7)
    2152                 :            : 
    2153                 :            : /* Used to keep track of visited nodes in tree traversals.  This is set to
    2154                 :            :    0 by copy_node and make_node.  */
    2155                 :            : #define TREE_VISITED(NODE) ((NODE)->base.visited)
    2156                 :            : 
    2157                 :            : /* If set in an ARRAY_TYPE, indicates a string type (for languages
    2158                 :            :    that distinguish string from array of char).
    2159                 :            :    If set in a INTEGER_TYPE, indicates a character type.  */
    2160                 :            : #define TYPE_STRING_FLAG(NODE) \
    2161                 :            :         (ARRAY_OR_INTEGER_TYPE_CHECK (NODE)->type_common.string_flag)
    2162                 :            : 
    2163                 :            : /* If set for RECORD_TYPE or UNION_TYPE it indicates that the type conforms
    2164                 :            :    to the C++ one definition rule.  This is used for LTO canonical type
    2165                 :            :    computation.  */
    2166                 :            : #define TYPE_CXX_ODR_P(NODE) \
    2167                 :            :         (RECORD_OR_UNION_CHECK (NODE)->type_common.string_flag)
    2168                 :            : 
    2169                 :            : /* Nonzero in a VECTOR_TYPE if the frontends should not emit warnings
    2170                 :            :    about missing conversions to other vector types of the same size.  */
    2171                 :            : #define TYPE_VECTOR_OPAQUE(NODE) \
    2172                 :            :   (VECTOR_TYPE_CHECK (NODE)->base.default_def_flag)
    2173                 :            : 
    2174                 :            : /* Indicates that objects of this type must be initialized by calling a
    2175                 :            :    function when they are created.  */
    2176                 :            : #define TYPE_NEEDS_CONSTRUCTING(NODE) \
    2177                 :            :   (TYPE_CHECK (NODE)->type_common.needs_constructing_flag)
    2178                 :            : 
    2179                 :            : /* Indicates that a UNION_TYPE object should be passed the same way that
    2180                 :            :    the first union alternative would be passed, or that a RECORD_TYPE
    2181                 :            :    object should be passed the same way that the first (and only) member
    2182                 :            :    would be passed.  */
    2183                 :            : #define TYPE_TRANSPARENT_AGGR(NODE) \
    2184                 :            :   (RECORD_OR_UNION_CHECK (NODE)->type_common.transparent_aggr_flag)
    2185                 :            : 
    2186                 :            : /* For an ARRAY_TYPE, indicates that it is not permitted to take the
    2187                 :            :    address of a component of the type.  This is the counterpart of
    2188                 :            :    DECL_NONADDRESSABLE_P for arrays, see the definition of this flag.  */
    2189                 :            : #define TYPE_NONALIASED_COMPONENT(NODE) \
    2190                 :            :   (ARRAY_TYPE_CHECK (NODE)->type_common.transparent_aggr_flag)
    2191                 :            : 
    2192                 :            : /* For an ARRAY_TYPE, a RECORD_TYPE, a UNION_TYPE or a QUAL_UNION_TYPE
    2193                 :            :    whether the array is typeless storage or the type contains a member
    2194                 :            :    with this flag set.  Such types are exempt from type-based alias
    2195                 :            :    analysis.  For ARRAY_TYPEs with AGGREGATE_TYPE_P element types
    2196                 :            :    the flag should be inherited from the element type, can change
    2197                 :            :    when type is finalized and because of that should not be used in
    2198                 :            :    type hashing.  For ARRAY_TYPEs with non-AGGREGATE_TYPE_P element types
    2199                 :            :    the flag should not be changed after the array is created and should
    2200                 :            :    be used in type hashing.  */
    2201                 :            : #define TYPE_TYPELESS_STORAGE(NODE) \
    2202                 :            :   (TREE_CHECK4 (NODE, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, \
    2203                 :            :                 ARRAY_TYPE)->type_common.typeless_storage)
    2204                 :            : 
    2205                 :            : /* Indicated that objects of this type should be laid out in as
    2206                 :            :    compact a way as possible.  */
    2207                 :            : #define TYPE_PACKED(NODE) (TYPE_CHECK (NODE)->base.u.bits.packed_flag)
    2208                 :            : 
    2209                 :            : /* Used by type_contains_placeholder_p to avoid recomputation.
    2210                 :            :    Values are: 0 (unknown), 1 (false), 2 (true).  Never access
    2211                 :            :    this field directly.  */
    2212                 :            : #define TYPE_CONTAINS_PLACEHOLDER_INTERNAL(NODE) \
    2213                 :            :   (TYPE_CHECK (NODE)->type_common.contains_placeholder_bits)
    2214                 :            : 
    2215                 :            : /* Nonzero if RECORD_TYPE represents a final derivation of class.  */
    2216                 :            : #define TYPE_FINAL_P(NODE) \
    2217                 :            :   (RECORD_OR_UNION_CHECK (NODE)->base.default_def_flag)
    2218                 :            : 
    2219                 :            : /* The debug output functions use the symtab union field to store
    2220                 :            :    information specific to the debugging format.  The different debug
    2221                 :            :    output hooks store different types in the union field.  These three
    2222                 :            :    macros are used to access different fields in the union.  The debug
    2223                 :            :    hooks are responsible for consistently using only a specific
    2224                 :            :    macro.  */
    2225                 :            : 
    2226                 :            : /* Symtab field as an integer.  Used by stabs generator in dbxout.c to
    2227                 :            :    hold the type's number in the generated stabs.  */
    2228                 :            : #define TYPE_SYMTAB_ADDRESS(NODE) \
    2229                 :            :   (TYPE_CHECK (NODE)->type_common.symtab.address)
    2230                 :            : 
    2231                 :            : /* Symtab field as a pointer to a DWARF DIE.  Used by DWARF generator
    2232                 :            :    in dwarf2out.c to point to the DIE generated for the type.  */
    2233                 :            : #define TYPE_SYMTAB_DIE(NODE) \
    2234                 :            :   (TYPE_CHECK (NODE)->type_common.symtab.die)
    2235                 :            : 
    2236                 :            : /* The garbage collector needs to know the interpretation of the
    2237                 :            :    symtab field.  These constants represent the different types in the
    2238                 :            :    union.  */
    2239                 :            : 
    2240                 :            : #define TYPE_SYMTAB_IS_ADDRESS (0)
    2241                 :            : #define TYPE_SYMTAB_IS_DIE (1)
    2242                 :            : 
    2243                 :            : #define TYPE_LANG_SPECIFIC(NODE) \
    2244                 :            :   (TYPE_CHECK (NODE)->type_with_lang_specific.lang_specific)
    2245                 :            : 
    2246                 :            : #define TYPE_VALUES(NODE) (ENUMERAL_TYPE_CHECK (NODE)->type_non_common.values)
    2247                 :            : #define TYPE_DOMAIN(NODE) (ARRAY_TYPE_CHECK (NODE)->type_non_common.values)
    2248                 :            : #define TYPE_FIELDS(NODE)                               \
    2249                 :            :   (RECORD_OR_UNION_CHECK (NODE)->type_non_common.values)
    2250                 :            : #define TYPE_CACHED_VALUES(NODE) (TYPE_CHECK (NODE)->type_non_common.values)
    2251                 :            : #define TYPE_ARG_TYPES(NODE)                            \
    2252                 :            :   (FUNC_OR_METHOD_CHECK (NODE)->type_non_common.values)
    2253                 :            : #define TYPE_VALUES_RAW(NODE) (TYPE_CHECK (NODE)->type_non_common.values)
    2254                 :            : 
    2255                 :            : #define TYPE_MIN_VALUE(NODE)                            \
    2256                 :            :   (NUMERICAL_TYPE_CHECK (NODE)->type_non_common.minval)
    2257                 :            : #define TYPE_NEXT_PTR_TO(NODE)                          \
    2258                 :            :   (POINTER_TYPE_CHECK (NODE)->type_non_common.minval)
    2259                 :            : #define TYPE_NEXT_REF_TO(NODE)                          \
    2260                 :            :   (REFERENCE_TYPE_CHECK (NODE)->type_non_common.minval)
    2261                 :            : #define TYPE_VFIELD(NODE)                               \
    2262                 :            :   (RECORD_OR_UNION_CHECK (NODE)->type_non_common.minval)
    2263                 :            : #define TYPE_MIN_VALUE_RAW(NODE) (TYPE_CHECK (NODE)->type_non_common.minval)
    2264                 :            : 
    2265                 :            : #define TYPE_MAX_VALUE(NODE) \
    2266                 :            :   (NUMERICAL_TYPE_CHECK (NODE)->type_non_common.maxval)
    2267                 :            : #define TYPE_METHOD_BASETYPE(NODE)                      \
    2268                 :            :   (FUNC_OR_METHOD_CHECK (NODE)->type_non_common.maxval)
    2269                 :            : #define TYPE_OFFSET_BASETYPE(NODE)                      \
    2270                 :            :   (OFFSET_TYPE_CHECK (NODE)->type_non_common.maxval)
    2271                 :            : /* If non-NULL, this is an upper bound of the size (in bytes) of an
    2272                 :            :    object of the given ARRAY_TYPE_NON_COMMON.  This allows temporaries to be
    2273                 :            :    allocated.  */
    2274                 :            : #define TYPE_ARRAY_MAX_SIZE(ARRAY_TYPE) \
    2275                 :            :   (ARRAY_TYPE_CHECK (ARRAY_TYPE)->type_non_common.maxval)
    2276                 :            : #define TYPE_MAX_VALUE_RAW(NODE) (TYPE_CHECK (NODE)->type_non_common.maxval)
    2277                 :            : /* For record and union types, information about this type, as a base type
    2278                 :            :    for itself.  */
    2279                 :            : #define TYPE_BINFO(NODE) (RECORD_OR_UNION_CHECK (NODE)->type_non_common.maxval)
    2280                 :            : 
    2281                 :            : /* For types, used in a language-dependent way.  */
    2282                 :            : #define TYPE_LANG_SLOT_1(NODE) \
    2283                 :            :   (TYPE_CHECK (NODE)->type_non_common.lang_1)
    2284                 :            : 
    2285                 :            : /* Define accessor macros for information about type inheritance
    2286                 :            :    and basetypes.
    2287                 :            : 
    2288                 :            :    A "basetype" means a particular usage of a data type for inheritance
    2289                 :            :    in another type.  Each such basetype usage has its own "binfo"
    2290                 :            :    object to describe it.  The binfo object is a TREE_VEC node.
    2291                 :            : 
    2292                 :            :    Inheritance is represented by the binfo nodes allocated for a
    2293                 :            :    given type.  For example, given types C and D, such that D is
    2294                 :            :    inherited by C, 3 binfo nodes will be allocated: one for describing
    2295                 :            :    the binfo properties of C, similarly one for D, and one for
    2296                 :            :    describing the binfo properties of D as a base type for C.
    2297                 :            :    Thus, given a pointer to class C, one can get a pointer to the binfo
    2298                 :            :    of D acting as a basetype for C by looking at C's binfo's basetypes.  */
    2299                 :            : 
    2300                 :            : /* BINFO specific flags.  */
    2301                 :            : 
    2302                 :            : /* Nonzero means that the derivation chain is via a `virtual' declaration.  */
    2303                 :            : #define BINFO_VIRTUAL_P(NODE) (TREE_BINFO_CHECK (NODE)->base.static_flag)
    2304                 :            : 
    2305                 :            : /* Flags for language dependent use.  */
    2306                 :            : #define BINFO_FLAG_0(NODE) TREE_LANG_FLAG_0 (TREE_BINFO_CHECK (NODE))
    2307                 :            : #define BINFO_FLAG_1(NODE) TREE_LANG_FLAG_1 (TREE_BINFO_CHECK (NODE))
    2308                 :            : #define BINFO_FLAG_2(NODE) TREE_LANG_FLAG_2 (TREE_BINFO_CHECK (NODE))
    2309                 :            : #define BINFO_FLAG_3(NODE) TREE_LANG_FLAG_3 (TREE_BINFO_CHECK (NODE))
    2310                 :            : #define BINFO_FLAG_4(NODE) TREE_LANG_FLAG_4 (TREE_BINFO_CHECK (NODE))
    2311                 :            : #define BINFO_FLAG_5(NODE) TREE_LANG_FLAG_5 (TREE_BINFO_CHECK (NODE))
    2312                 :            : #define BINFO_FLAG_6(NODE) TREE_LANG_FLAG_6 (TREE_BINFO_CHECK (NODE))
    2313                 :            : 
    2314                 :            : /* The actual data type node being inherited in this basetype.  */
    2315                 :            : #define BINFO_TYPE(NODE) TREE_TYPE (TREE_BINFO_CHECK (NODE))
    2316                 :            : 
    2317                 :            : /* The offset where this basetype appears in its containing type.
    2318                 :            :    BINFO_OFFSET slot holds the offset (in bytes)
    2319                 :            :    from the base of the complete object to the base of the part of the
    2320                 :            :    object that is allocated on behalf of this `type'.
    2321                 :            :    This is always 0 except when there is multiple inheritance.  */
    2322                 :            : 
    2323                 :            : #define BINFO_OFFSET(NODE) (TREE_BINFO_CHECK (NODE)->binfo.offset)
    2324                 :            : #define BINFO_OFFSET_ZEROP(NODE) (integer_zerop (BINFO_OFFSET (NODE)))
    2325                 :            : 
    2326                 :            : /* The virtual function table belonging to this basetype.  Virtual
    2327                 :            :    function tables provide a mechanism for run-time method dispatching.
    2328                 :            :    The entries of a virtual function table are language-dependent.  */
    2329                 :            : 
    2330                 :            : #define BINFO_VTABLE(NODE) (TREE_BINFO_CHECK (NODE)->binfo.vtable)
    2331                 :            : 
    2332                 :            : /* The virtual functions in the virtual function table.  This is
    2333                 :            :    a TREE_LIST that is used as an initial approximation for building
    2334                 :            :    a virtual function table for this basetype.  */
    2335                 :            : #define BINFO_VIRTUALS(NODE) (TREE_BINFO_CHECK (NODE)->binfo.virtuals)
    2336                 :            : 
    2337                 :            : /* A vector of binfos for the direct basetypes inherited by this
    2338                 :            :    basetype.
    2339                 :            : 
    2340                 :            :    If this basetype describes type D as inherited in C, and if the
    2341                 :            :    basetypes of D are E and F, then this vector contains binfos for
    2342                 :            :    inheritance of E and F by C.  */
    2343                 :            : #define BINFO_BASE_BINFOS(NODE) (&TREE_BINFO_CHECK (NODE)->binfo.base_binfos)
    2344                 :            : 
    2345                 :            : /* The number of basetypes for NODE.  */
    2346                 :            : #define BINFO_N_BASE_BINFOS(NODE) (BINFO_BASE_BINFOS (NODE)->length ())
    2347                 :            : 
    2348                 :            : /* Accessor macro to get to the Nth base binfo of this binfo.  */
    2349                 :            : #define BINFO_BASE_BINFO(NODE,N) \
    2350                 :            :  ((*BINFO_BASE_BINFOS (NODE))[(N)])
    2351                 :            : #define BINFO_BASE_ITERATE(NODE,N,B) \
    2352                 :            :  (BINFO_BASE_BINFOS (NODE)->iterate ((N), &(B)))
    2353                 :            : #define BINFO_BASE_APPEND(NODE,T) \
    2354                 :            :  (BINFO_BASE_BINFOS (NODE)->quick_push ((T)))
    2355                 :            : 
    2356                 :            : /* For a BINFO record describing a virtual base class, i.e., one where
    2357                 :            :    TREE_VIA_VIRTUAL is set, this field assists in locating the virtual
    2358                 :            :    base.  The actual contents are language-dependent.  In the C++
    2359                 :            :    front-end this field is an INTEGER_CST giving an offset into the
    2360                 :            :    vtable where the offset to the virtual base can be found.  */
    2361                 :            : #define BINFO_VPTR_FIELD(NODE) (TREE_BINFO_CHECK (NODE)->binfo.vptr_field)
    2362                 :            : 
    2363                 :            : /* Indicates the accesses this binfo has to its bases. The values are
    2364                 :            :    access_public_node, access_protected_node or access_private_node.
    2365                 :            :    If this array is not present, public access is implied.  */
    2366                 :            : #define BINFO_BASE_ACCESSES(NODE) \
    2367                 :            :   (TREE_BINFO_CHECK (NODE)->binfo.base_accesses)
    2368                 :            : 
    2369                 :            : #define BINFO_BASE_ACCESS(NODE,N) \
    2370                 :            :   (*BINFO_BASE_ACCESSES (NODE))[(N)]
    2371                 :            : #define BINFO_BASE_ACCESS_APPEND(NODE,T) \
    2372                 :            :   BINFO_BASE_ACCESSES (NODE)->quick_push ((T))
    2373                 :            : 
    2374                 :            : /* The index in the VTT where this subobject's sub-VTT can be found.
    2375                 :            :    NULL_TREE if there is no sub-VTT.  */
    2376                 :            : #define BINFO_SUBVTT_INDEX(NODE) (TREE_BINFO_CHECK (NODE)->binfo.vtt_subvtt)
    2377                 :            : 
    2378                 :            : /* The index in the VTT where the vptr for this subobject can be
    2379                 :            :    found.  NULL_TREE if there is no secondary vptr in the VTT.  */
    2380                 :            : #define BINFO_VPTR_INDEX(NODE) (TREE_BINFO_CHECK (NODE)->binfo.vtt_vptr)
    2381                 :            : 
    2382                 :            : /* The BINFO_INHERITANCE_CHAIN points at the binfo for the base
    2383                 :            :    inheriting this base for non-virtual bases. For virtual bases it
    2384                 :            :    points either to the binfo for which this is a primary binfo, or to
    2385                 :            :    the binfo of the most derived type.  */
    2386                 :            : #define BINFO_INHERITANCE_CHAIN(NODE) \
    2387                 :            :         (TREE_BINFO_CHECK (NODE)->binfo.inheritance)
    2388                 :            : 
    2389                 :            : 
    2390                 :            : /* Define fields and accessors for nodes representing declared names.  */
    2391                 :            : 
    2392                 :            : /* Nonzero if DECL represents an SSA name or a variable that can possibly
    2393                 :            :    have an associated SSA name.  */
    2394                 :            : #define SSA_VAR_P(DECL)                                                 \
    2395                 :            :         (TREE_CODE (DECL) == VAR_DECL                                   \
    2396                 :            :          || TREE_CODE (DECL) == PARM_DECL                               \
    2397                 :            :          || TREE_CODE (DECL) == RESULT_DECL                             \
    2398                 :            :          || TREE_CODE (DECL) == SSA_NAME)
    2399                 :            : 
    2400                 :            : 
    2401                 :            : #define DECL_CHAIN(NODE) (TREE_CHAIN (DECL_MINIMAL_CHECK (NODE)))
    2402                 :            : 
    2403                 :            : /* This is the name of the object as written by the user.
    2404                 :            :    It is an IDENTIFIER_NODE.  */
    2405                 :            : #define DECL_NAME(NODE) (DECL_MINIMAL_CHECK (NODE)->decl_minimal.name)
    2406                 :            : 
    2407                 :            : /* The IDENTIFIER_NODE associated with the TYPE_NAME field.  */
    2408                 :            : #define TYPE_IDENTIFIER(NODE) \
    2409                 :            :   (TYPE_NAME (NODE) && DECL_P (TYPE_NAME (NODE)) \
    2410                 :            :    ? DECL_NAME (TYPE_NAME (NODE)) : TYPE_NAME (NODE))
    2411                 :            : 
    2412                 :            : /* Every ..._DECL node gets a unique number.  */
    2413                 :            : #define DECL_UID(NODE) (DECL_MINIMAL_CHECK (NODE)->decl_minimal.uid)
    2414                 :            : 
    2415                 :            : /* DEBUG_EXPR_DECLs get negative UID numbers, to catch erroneous
    2416                 :            :    uses.  */
    2417                 :            : #define DEBUG_TEMP_UID(NODE) (-DECL_UID (TREE_CHECK ((NODE), DEBUG_EXPR_DECL)))
    2418                 :            : 
    2419                 :            : /* Every ..._DECL node gets a unique number that stays the same even
    2420                 :            :    when the decl is copied by the inliner once it is set.  */
    2421                 :            : #define DECL_PT_UID(NODE) \
    2422                 :            :   (DECL_COMMON_CHECK (NODE)->decl_common.pt_uid == -1u \
    2423                 :            :    ? (NODE)->decl_minimal.uid : (NODE)->decl_common.pt_uid)
    2424                 :            : /* Initialize the ..._DECL node pt-uid to the decls uid.  */
    2425                 :            : #define SET_DECL_PT_UID(NODE, UID) \
    2426                 :            :   (DECL_COMMON_CHECK (NODE)->decl_common.pt_uid = (UID))
    2427                 :            : /* Whether the ..._DECL node pt-uid has been initialized and thus needs to
    2428                 :            :    be preserved when copyin the decl.  */
    2429                 :            : #define DECL_PT_UID_SET_P(NODE) \
    2430                 :            :   (DECL_COMMON_CHECK (NODE)->decl_common.pt_uid != -1u)
    2431                 :            : 
    2432                 :            : /* These two fields describe where in the source code the declaration
    2433                 :            :    was.  If the declaration appears in several places (as for a C
    2434                 :            :    function that is declared first and then defined later), this
    2435                 :            :    information should refer to the definition.  */
    2436                 :            : #define DECL_SOURCE_LOCATION(NODE) \
    2437                 :            :   (DECL_MINIMAL_CHECK (NODE)->decl_minimal.locus)
    2438                 :            : #define DECL_SOURCE_FILE(NODE) LOCATION_FILE (DECL_SOURCE_LOCATION (NODE))
    2439                 :            : #define DECL_SOURCE_LINE(NODE) LOCATION_LINE (DECL_SOURCE_LOCATION (NODE))
    2440                 :            : #define DECL_SOURCE_COLUMN(NODE) LOCATION_COLUMN (DECL_SOURCE_LOCATION (NODE))
    2441                 :            : /* This accessor returns TRUE if the decl it operates on was created
    2442                 :            :    by a front-end or back-end rather than by user code.  In this case
    2443                 :            :    builtin-ness is indicated by source location.  */
    2444                 :            : #define DECL_IS_BUILTIN(DECL) \
    2445                 :            :   (LOCATION_LOCUS (DECL_SOURCE_LOCATION (DECL)) <= BUILTINS_LOCATION)
    2446                 :            : 
    2447                 :            : /*  For FIELD_DECLs, this is the RECORD_TYPE, UNION_TYPE, or
    2448                 :            :     QUAL_UNION_TYPE node that the field is a member of.  For VAR_DECL,
    2449                 :            :     PARM_DECL, FUNCTION_DECL, LABEL_DECL, RESULT_DECL, and CONST_DECL
    2450                 :            :     nodes, this points to either the FUNCTION_DECL for the containing
    2451                 :            :     function, the RECORD_TYPE or UNION_TYPE for the containing type, or
    2452                 :            :     NULL_TREE or a TRANSLATION_UNIT_DECL if the given decl has "file
    2453                 :            :     scope".  In particular, for VAR_DECLs which are virtual table pointers
    2454                 :            :     (they have DECL_VIRTUAL set), we use DECL_CONTEXT to determine the type
    2455                 :            :     they belong to.  */
    2456                 :            : #define DECL_CONTEXT(NODE) (DECL_MINIMAL_CHECK (NODE)->decl_minimal.context)
    2457                 :            : #define DECL_FIELD_CONTEXT(NODE) \
    2458                 :            :   (FIELD_DECL_CHECK (NODE)->decl_minimal.context)
    2459                 :            : 
    2460                 :            : /* If nonzero, decl's name shouldn't be emitted into debug info.  */
    2461                 :            : #define DECL_NAMELESS(NODE) (DECL_MINIMAL_CHECK (NODE)->base.u.bits.nameless_flag)
    2462                 :            : 
    2463                 :            : /* For any sort of a ..._DECL node, this points to the original (abstract)
    2464                 :            :    decl node which this decl is an inlined/cloned instance of, or else it
    2465                 :            :    is NULL indicating that this decl is not an instance of some other decl.
    2466                 :            : 
    2467                 :            :    The C front-end also uses this in a nested declaration of an inline
    2468                 :            :    function, to point back to the definition.  */
    2469                 :            : #define DECL_ABSTRACT_ORIGIN(NODE) \
    2470                 :            :   (DECL_COMMON_CHECK (NODE)->decl_common.abstract_origin)
    2471                 :            : 
    2472                 :            : /* Like DECL_ABSTRACT_ORIGIN, but returns NODE if there's no abstract
    2473                 :            :    origin.  This is useful when setting the DECL_ABSTRACT_ORIGIN.  */
    2474                 :            : #define DECL_ORIGIN(NODE) \
    2475                 :            :   (DECL_ABSTRACT_ORIGIN (NODE) ? DECL_ABSTRACT_ORIGIN (NODE) : (NODE))
    2476                 :            : 
    2477                 :            : /* Nonzero for any sort of ..._DECL node means this decl node represents an
    2478                 :            :    inline instance of some original (abstract) decl from an inline function;
    2479                 :            :    suppress any warnings about shadowing some other variable.  FUNCTION_DECL
    2480                 :            :    nodes can also have their abstract origin set to themselves.  */
    2481                 :            : #define DECL_FROM_INLINE(NODE) \
    2482                 :            :   (DECL_ABSTRACT_ORIGIN (NODE) != NULL_TREE \
    2483                 :            :    && DECL_ABSTRACT_ORIGIN (NODE) != (NODE))
    2484                 :            : 
    2485                 :            : /* In a DECL this is the field where attributes are stored.  */
    2486                 :            : #define DECL_ATTRIBUTES(NODE) \
    2487                 :            :   (DECL_COMMON_CHECK (NODE)->decl_common.attributes)
    2488                 :            : 
    2489                 :            : /* For a FUNCTION_DECL, holds the tree of BINDINGs.
    2490                 :            :    For a TRANSLATION_UNIT_DECL, holds the namespace's BLOCK.
    2491                 :            :    For a VAR_DECL, holds the initial value.
    2492                 :            :    For a PARM_DECL, used for DECL_ARG_TYPE--default
    2493                 :            :    values for parameters are encoded in the type of the function,
    2494                 :            :    not in the PARM_DECL slot.
    2495                 :            :    For a FIELD_DECL, this is used for enumeration values and the C
    2496                 :            :    frontend uses it for temporarily storing bitwidth of bitfields.
    2497                 :            : 
    2498                 :            :    ??? Need to figure out some way to check this isn't a PARM_DECL.  */
    2499                 :            : #define DECL_INITIAL(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.initial)
    2500                 :            : 
    2501                 :            : /* Holds the size of the datum, in bits, as a tree expression.
    2502                 :            :    Need not be constant and may be null.  */
    2503                 :            : #define DECL_SIZE(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.size)
    2504                 :            : /* Likewise for the size in bytes.  */
    2505                 :            : #define DECL_SIZE_UNIT(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.size_unit)
    2506                 :            : /* Returns the alignment required for the datum, in bits.  It must
    2507                 :            :    be a power of two, but an "alignment" of zero is supported
    2508                 :            :    (e.g. as "uninitialized" sentinel).  */
    2509                 :            : #define DECL_ALIGN(NODE) \
    2510                 :            :     (DECL_COMMON_CHECK (NODE)->decl_common.align \
    2511                 :            :      ? ((unsigned)1) << ((NODE)->decl_common.align - 1) : 0)
    2512                 :            : /* Specify that DECL_ALIGN(NODE) is X.  */
    2513                 :            : #define SET_DECL_ALIGN(NODE, X) \
    2514                 :            :     (DECL_COMMON_CHECK (NODE)->decl_common.align = ffs_hwi (X))
    2515                 :            : 
    2516                 :            : /* The minimum alignment necessary for the datum, in bits, without
    2517                 :            :    warning.  */
    2518                 :            : #define DECL_WARN_IF_NOT_ALIGN(NODE) \
    2519                 :            :     (DECL_COMMON_CHECK (NODE)->decl_common.warn_if_not_align \
    2520                 :            :      ? ((unsigned)1) << ((NODE)->decl_common.warn_if_not_align - 1) : 0)
    2521                 :            : 
    2522                 :            : /* Specify that DECL_WARN_IF_NOT_ALIGN(NODE) is X.  */
    2523                 :            : #define SET_DECL_WARN_IF_NOT_ALIGN(NODE, X) \
    2524                 :            :     (DECL_COMMON_CHECK (NODE)->decl_common.warn_if_not_align = ffs_hwi (X))
    2525                 :            : 
    2526                 :            : /* The alignment of NODE, in bytes.  */
    2527                 :            : #define DECL_ALIGN_UNIT(NODE) (DECL_ALIGN (NODE) / BITS_PER_UNIT)
    2528                 :            : /* Set if the alignment of this DECL has been set by the user, for
    2529                 :            :    example with an 'aligned' attribute.  */
    2530                 :            : #define DECL_USER_ALIGN(NODE) \
    2531                 :            :   (DECL_COMMON_CHECK (NODE)->base.u.bits.user_align)
    2532                 :            : /* Holds the machine mode corresponding to the declaration of a variable or
    2533                 :            :    field.  Always equal to TYPE_MODE (TREE_TYPE (decl)) except for a
    2534                 :            :    FIELD_DECL.  */
    2535                 :            : #define DECL_MODE(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.mode)
    2536                 :            : #define SET_DECL_MODE(NODE, MODE) \
    2537                 :            :   (DECL_COMMON_CHECK (NODE)->decl_common.mode = (MODE))
    2538                 :            : 
    2539                 :            : /* For FUNCTION_DECL, if it is built-in, this identifies which built-in
    2540                 :            :    operation it is.  This is only intended for low-level accesses;
    2541                 :            :    normally DECL_FUNCTION_CODE, DECL_FE_FUNCTION_CODE or DECL_MD_FUNCTION
    2542                 :            :    should be used instead.  */
    2543                 :            : #define DECL_UNCHECKED_FUNCTION_CODE(NODE) \
    2544                 :            :   (FUNCTION_DECL_CHECK (NODE)->function_decl.function_code)
    2545                 :            : 
    2546                 :            : /* Test if FCODE is a function code for an alloca operation.  */
    2547                 :            : #define ALLOCA_FUNCTION_CODE_P(FCODE)                           \
    2548                 :            :   ((FCODE) == BUILT_IN_ALLOCA                                   \
    2549                 :            :    || (FCODE) == BUILT_IN_ALLOCA_WITH_ALIGN                     \
    2550                 :            :    || (FCODE) == BUILT_IN_ALLOCA_WITH_ALIGN_AND_MAX)
    2551                 :            : 
    2552                 :            : /* Generate case for an alloca operation.  */
    2553                 :            : #define CASE_BUILT_IN_ALLOCA                    \
    2554                 :            :   case BUILT_IN_ALLOCA:                         \
    2555                 :            :   case BUILT_IN_ALLOCA_WITH_ALIGN:              \
    2556                 :            :   case BUILT_IN_ALLOCA_WITH_ALIGN_AND_MAX
    2557                 :            : 
    2558                 :            : #define DECL_FUNCTION_PERSONALITY(NODE) \
    2559                 :            :   (FUNCTION_DECL_CHECK (NODE)->function_decl.personality)
    2560                 :            : 
    2561                 :            : /* Nonzero for a given ..._DECL node means that the name of this node should
    2562                 :            :    be ignored for symbolic debug purposes.  For a TYPE_DECL, this means that
    2563                 :            :    the associated type should be ignored.  For a FUNCTION_DECL, the body of
    2564                 :            :    the function should also be ignored.  */
    2565                 :            : #define DECL_IGNORED_P(NODE) \
    2566                 :            :   (DECL_COMMON_CHECK (NODE)->decl_common.ignored_flag)
    2567                 :            : 
    2568                 :            : /* Nonzero for a given ..._DECL node means that this node represents an
    2569                 :            :    "abstract instance" of the given declaration (e.g. in the original
    2570                 :            :    declaration of an inline function).  When generating symbolic debugging
    2571                 :            :    information, we mustn't try to generate any address information for nodes
    2572                 :            :    marked as "abstract instances" because we don't actually generate
    2573                 :            :    any code or allocate any data space for such instances.  */
    2574                 :            : #define DECL_ABSTRACT_P(NODE) \
    2575                 :            :   (DECL_COMMON_CHECK (NODE)->decl_common.abstract_flag)
    2576                 :            : 
    2577                 :            : /* Language-specific decl information.  */
    2578                 :            : #define DECL_LANG_SPECIFIC(NODE) \
    2579                 :            :   (DECL_COMMON_CHECK (NODE)->decl_common.lang_specific)
    2580                 :            : 
    2581                 :            : /* In a VAR_DECL or FUNCTION_DECL, nonzero means external reference:
    2582                 :            :    do not allocate storage, and refer to a definition elsewhere.  Note that
    2583                 :            :    this does not necessarily imply the entity represented by NODE
    2584                 :            :    has no program source-level definition in this translation unit.  For
    2585                 :            :    example, for a FUNCTION_DECL, DECL_SAVED_TREE may be non-NULL and
    2586                 :            :    DECL_EXTERNAL may be true simultaneously; that can be the case for
    2587                 :            :    a C99 "extern inline" function.  */
    2588                 :            : #define DECL_EXTERNAL(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.decl_flag_1)
    2589                 :            : 
    2590                 :            : /* Nonzero in a ..._DECL means this variable is ref'd from a nested function.
    2591                 :            :    For VAR_DECL nodes, PARM_DECL nodes, and FUNCTION_DECL nodes.
    2592                 :            : 
    2593                 :            :    For LABEL_DECL nodes, nonzero if nonlocal gotos to the label are permitted.
    2594                 :            : 
    2595                 :            :    Also set in some languages for variables, etc., outside the normal
    2596                 :            :    lexical scope, such as class instance variables.  */
    2597                 :            : #define DECL_NONLOCAL(NODE) \
    2598                 :            :   (DECL_COMMON_CHECK (NODE)->decl_common.nonlocal_flag)
    2599                 :            : 
    2600                 :            : /* Used in VAR_DECLs to indicate that the variable is a vtable.
    2601                 :            :    Used in FIELD_DECLs for vtable pointers.
    2602                 :            :    Used in FUNCTION_DECLs to indicate that the function is virtual.  */
    2603                 :            : #define DECL_VIRTUAL_P(NODE) \
    2604                 :            :   (DECL_COMMON_CHECK (NODE)->decl_common.virtual_flag)
    2605                 :            : 
    2606                 :            : /* Used to indicate that this DECL represents a compiler-generated entity.  */
    2607                 :            : #define DECL_ARTIFICIAL(NODE) \
    2608                 :            :   (DECL_COMMON_CHECK (NODE)->decl_common.artificial_flag)
    2609                 :            : 
    2610                 :            : /* Additional flags for language-specific uses.  */
    2611                 :            : #define DECL_LANG_FLAG_0(NODE) \
    2612                 :            :   (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_0)
    2613                 :            : #define DECL_LANG_FLAG_1(NODE) \
    2614                 :            :   (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_1)
    2615                 :            : #define DECL_LANG_FLAG_2(NODE) \
    2616                 :            :   (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_2)
    2617                 :            : #define DECL_LANG_FLAG_3(NODE) \
    2618                 :            :   (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_3)
    2619                 :            : #define DECL_LANG_FLAG_4(NODE) \
    2620                 :            :   (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_4)
    2621                 :            : #define DECL_LANG_FLAG_5(NODE) \
    2622                 :            :   (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_5)
    2623                 :            : #define DECL_LANG_FLAG_6(NODE) \
    2624                 :            :   (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_6)
    2625                 :            : #define DECL_LANG_FLAG_7(NODE) \
    2626                 :            :   (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_7)
    2627                 :            : #define DECL_LANG_FLAG_8(NODE) \
    2628                 :            :   (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_8)
    2629                 :            : 
    2630                 :            : /* Nonzero for a scope which is equal to file scope.  */
    2631                 :            : #define SCOPE_FILE_SCOPE_P(EXP) \
    2632                 :            :   (! (EXP) || TREE_CODE (EXP) == TRANSLATION_UNIT_DECL)
    2633                 :            : /* Nonzero for a decl which is at file scope.  */
    2634                 :            : #define DECL_FILE_SCOPE_P(EXP) SCOPE_FILE_SCOPE_P (DECL_CONTEXT (EXP))
    2635                 :            : /* Nonzero for a type which is at file scope.  */
    2636                 :            : #define TYPE_FILE_SCOPE_P(EXP) SCOPE_FILE_SCOPE_P (TYPE_CONTEXT (EXP))
    2637                 :            : 
    2638                 :            : /* Nonzero for a decl that is decorated using attribute used.
    2639                 :            :    This indicates to compiler tools that this decl needs to be preserved.  */
    2640                 :            : #define DECL_PRESERVE_P(DECL) \
    2641                 :            :   DECL_COMMON_CHECK (DECL)->decl_common.preserve_flag
    2642                 :            : 
    2643                 :            : /* For function local variables of COMPLEX and VECTOR types,
    2644                 :            :    indicates that the variable is not aliased, and that all
    2645                 :            :    modifications to the variable have been adjusted so that
    2646                 :            :    they are killing assignments.  Thus the variable may now
    2647                 :            :    be treated as a GIMPLE register, and use real instead of
    2648                 :            :    virtual ops in SSA form.  */
    2649                 :            : #define DECL_GIMPLE_REG_P(DECL) \
    2650                 :            :   DECL_COMMON_CHECK (DECL)->decl_common.gimple_reg_flag
    2651                 :            : 
    2652                 :            : extern tree decl_value_expr_lookup (tree);
    2653                 :            : extern void decl_value_expr_insert (tree, tree);
    2654                 :            : 
    2655                 :            : /* In a VAR_DECL or PARM_DECL, the location at which the value may be found,
    2656                 :            :    if transformations have made this more complicated than evaluating the
    2657                 :            :    decl itself.  */
    2658                 :            : #define DECL_HAS_VALUE_EXPR_P(NODE) \
    2659                 :            :   (TREE_CHECK3 (NODE, VAR_DECL, PARM_DECL, RESULT_DECL) \
    2660                 :            :    ->decl_common.decl_flag_2)
    2661                 :            : #define DECL_VALUE_EXPR(NODE) \
    2662                 :            :   (decl_value_expr_lookup (DECL_WRTL_CHECK (NODE)))
    2663                 :            : #define SET_DECL_VALUE_EXPR(NODE, VAL) \
    2664                 :            :   (decl_value_expr_insert (DECL_WRTL_CHECK (NODE), VAL))
    2665                 :            : 
    2666                 :            : /* Holds the RTL expression for the value of a variable or function.
    2667                 :            :    This value can be evaluated lazily for functions, variables with
    2668                 :            :    static storage duration, and labels.  */
    2669                 :            : #define DECL_RTL(NODE)                                  \
    2670                 :            :   (DECL_WRTL_CHECK (NODE)->decl_with_rtl.rtl         \
    2671                 :            :    ? (NODE)->decl_with_rtl.rtl                                       \
    2672                 :            :    : (make_decl_rtl (NODE), (NODE)->decl_with_rtl.rtl))
    2673                 :            : 
    2674                 :            : /* Set the DECL_RTL for NODE to RTL.  */
    2675                 :            : #define SET_DECL_RTL(NODE, RTL) set_decl_rtl (NODE, RTL)
    2676                 :            : 
    2677                 :            : /* Returns nonzero if NODE is a tree node that can contain RTL.  */
    2678                 :            : #define HAS_RTL_P(NODE) (CODE_CONTAINS_STRUCT (TREE_CODE (NODE), TS_DECL_WRTL))
    2679                 :            : 
    2680                 :            : /* Returns nonzero if the DECL_RTL for NODE has already been set.  */
    2681                 :            : #define DECL_RTL_SET_P(NODE) \
    2682                 :            :   (HAS_RTL_P (NODE) && DECL_WRTL_CHECK (NODE)->decl_with_rtl.rtl != NULL)
    2683                 :            : 
    2684                 :            : /* Copy the RTL from SRC_DECL to DST_DECL.  If the RTL was not set for
    2685                 :            :    SRC_DECL, it will not be set for DST_DECL; this is a lazy copy.  */
    2686                 :            : #define COPY_DECL_RTL(SRC_DECL, DST_DECL) \
    2687                 :            :   (DECL_WRTL_CHECK (DST_DECL)->decl_with_rtl.rtl \
    2688                 :            :    = DECL_WRTL_CHECK (SRC_DECL)->decl_with_rtl.rtl)
    2689                 :            : 
    2690                 :            : /* The DECL_RTL for NODE, if it is set, or NULL, if it is not set.  */
    2691                 :            : #define DECL_RTL_IF_SET(NODE) (DECL_RTL_SET_P (NODE) ? DECL_RTL (NODE) : NULL)
    2692                 :            : 
    2693                 :            : #if (GCC_VERSION >= 2007)
    2694                 :            : #define DECL_RTL_KNOWN_SET(decl) __extension__                          \
    2695                 :            : ({  tree const __d = (decl);                                            \
    2696                 :            :     gcc_checking_assert (DECL_RTL_SET_P (__d));                         \
    2697                 :            :     /* Dereference it so the compiler knows it can't be NULL even       \
    2698                 :            :        without assertion checking.  */                                  \
    2699                 :            :     &*DECL_RTL_IF_SET (__d); })
    2700                 :            : #else
    2701                 :            : #define DECL_RTL_KNOWN_SET(decl) (&*DECL_RTL_IF_SET (decl))
    2702                 :            : #endif
    2703                 :            : 
    2704                 :            : /* In VAR_DECL and PARM_DECL nodes, nonzero means declared `register'.  */
    2705                 :            : #define DECL_REGISTER(NODE) (DECL_WRTL_CHECK (NODE)->decl_common.decl_flag_0)
    2706                 :            : 
    2707                 :            : /* In a FIELD_DECL, this is the field position, counting in bytes, of the
    2708                 :            :    DECL_OFFSET_ALIGN-bit-sized word containing the bit closest to the beginning
    2709                 :            :    of the structure.  */
    2710                 :            : #define DECL_FIELD_OFFSET(NODE) (FIELD_DECL_CHECK (NODE)->field_decl.offset)
    2711                 :            : 
    2712                 :            : /* In a FIELD_DECL, this is the offset, in bits, of the first bit of the
    2713                 :            :    field from DECL_FIELD_OFFSET.  This field may be nonzero even for fields
    2714                 :            :    that are not bit fields (since DECL_OFFSET_ALIGN may be larger than the
    2715                 :            :    natural alignment of the field's type).  */
    2716                 :            : #define DECL_FIELD_BIT_OFFSET(NODE) \
    2717                 :            :   (FIELD_DECL_CHECK (NODE)->field_decl.bit_offset)
    2718                 :            : 
    2719                 :            : /* In a FIELD_DECL, this indicates whether the field was a bit-field and
    2720                 :            :    if so, the type that was originally specified for it.
    2721                 :            :    TREE_TYPE may have been modified (in finish_struct).  */
    2722                 :            : #define DECL_BIT_FIELD_TYPE(NODE) \
    2723                 :            :   (FIELD_DECL_CHECK (NODE)->field_decl.bit_field_type)
    2724                 :            : 
    2725                 :            : /* In a FIELD_DECL of a RECORD_TYPE, this is a pointer to the storage
    2726                 :            :    representative FIELD_DECL.  */
    2727                 :            : #define DECL_BIT_FIELD_REPRESENTATIVE(NODE) \
    2728                 :            :   (FIELD_DECL_CHECK (NODE)->field_decl.qualifier)
    2729                 :            : 
    2730                 :            : /* For a FIELD_DECL in a QUAL_UNION_TYPE, records the expression, which
    2731                 :            :    if nonzero, indicates that the field occupies the type.  */
    2732                 :            : #define DECL_QUALIFIER(NODE) (FIELD_DECL_CHECK (NODE)->field_decl.qualifier)
    2733                 :            : 
    2734                 :            : /* For FIELD_DECLs, off_align holds the number of low-order bits of
    2735                 :            :    DECL_FIELD_OFFSET which are known to be always zero.
    2736                 :            :    DECL_OFFSET_ALIGN thus returns the alignment that DECL_FIELD_OFFSET
    2737                 :            :    has.  */
    2738                 :            : #define DECL_OFFSET_ALIGN(NODE) \
    2739                 :            :   (((unsigned HOST_WIDE_INT)1) << FIELD_DECL_CHECK (NODE)->decl_common.off_align)
    2740                 :            : 
    2741                 :            : /* Specify that DECL_OFFSET_ALIGN(NODE) is X.  */
    2742                 :            : #define SET_DECL_OFFSET_ALIGN(NODE, X) \
    2743                 :            :   (FIELD_DECL_CHECK (NODE)->decl_common.off_align = ffs_hwi (X) - 1)
    2744                 :            : 
    2745                 :            : /* For FIELD_DECLS, DECL_FCONTEXT is the *first* baseclass in
    2746                 :            :    which this FIELD_DECL is defined.  This information is needed when
    2747                 :            :    writing debugging information about vfield and vbase decls for C++.  */
    2748                 :            : #define DECL_FCONTEXT(NODE) (FIELD_DECL_CHECK (NODE)->field_decl.fcontext)
    2749                 :            : 
    2750                 :            : /* In a FIELD_DECL, indicates this field should be bit-packed.  */
    2751                 :            : #define DECL_PACKED(NODE) (FIELD_DECL_CHECK (NODE)->base.u.bits.packed_flag)
    2752                 :            : 
    2753                 :            : /* Nonzero in a FIELD_DECL means it is a bit field, and must be accessed
    2754                 :            :    specially.  */
    2755                 :            : #define DECL_BIT_FIELD(NODE) (FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_1)
    2756                 :            : 
    2757                 :            : /* Used in a FIELD_DECL to indicate that we cannot form the address of
    2758                 :            :    this component.  This makes it possible for Type-Based Alias Analysis
    2759                 :            :    to disambiguate accesses to this field with indirect accesses using
    2760                 :            :    the field's type:
    2761                 :            : 
    2762                 :            :      struct S { int i; } s;
    2763                 :            :      int *p;
    2764                 :            : 
    2765                 :            :    If the flag is set on 'i', TBAA computes that s.i and *p never conflict.
    2766                 :            : 
    2767                 :            :    From the implementation's viewpoint, the alias set of the type of the
    2768                 :            :    field 'i' (int) will not be recorded as a subset of that of the type of
    2769                 :            :    's' (struct S) in record_component_aliases.  The counterpart is that
    2770                 :            :    accesses to s.i must not be given the alias set of the type of 'i'
    2771                 :            :    (int) but instead directly that of the type of 's' (struct S).  */
    2772                 :            : #define DECL_NONADDRESSABLE_P(NODE) \
    2773                 :            :   (FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_2)
    2774                 :            : 
    2775                 :            : /* Used in a FIELD_DECL to indicate that this field is padding.  */
    2776                 :            : #define DECL_PADDING_P(NODE) \
    2777                 :            :   (FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_3)
    2778                 :            : 
    2779                 :            : /* A numeric unique identifier for a LABEL_DECL.  The UID allocation is
    2780                 :            :    dense, unique within any one function, and may be used to index arrays.
    2781                 :            :    If the value is -1, then no UID has been assigned.  */
    2782                 :            : #define LABEL_DECL_UID(NODE) \
    2783                 :            :   (LABEL_DECL_CHECK (NODE)->label_decl.label_decl_uid)
    2784                 :            : 
    2785                 :            : /* In a LABEL_DECL, the EH region number for which the label is the
    2786                 :            :    post_landing_pad.  */
    2787                 :            : #define EH_LANDING_PAD_NR(NODE) \
    2788                 :            :   (LABEL_DECL_CHECK (NODE)->label_decl.eh_landing_pad_nr)
    2789                 :            : 
    2790                 :            : /* For a PARM_DECL, records the data type used to pass the argument,
    2791                 :            :    which may be different from the type seen in the program.  */
    2792                 :            : #define DECL_ARG_TYPE(NODE) (PARM_DECL_CHECK (NODE)->decl_common.initial)
    2793                 :            : 
    2794                 :            : /* For PARM_DECL, holds an RTL for the stack slot or register
    2795                 :            :    where the data was actually passed.  */
    2796                 :            : #define DECL_INCOMING_RTL(NODE) \
    2797                 :            :   (PARM_DECL_CHECK (NODE)->parm_decl.incoming_rtl)
    2798                 :            : 
    2799                 :            : /* Nonzero for a given ..._DECL node means that no warnings should be
    2800                 :            :    generated just because this node is unused.  */
    2801                 :            : #define DECL_IN_SYSTEM_HEADER(NODE) \
    2802                 :            :   (in_system_header_at (DECL_SOURCE_LOCATION (NODE)))
    2803                 :            : 
    2804                 :            : /* Used to indicate that the linkage status of this DECL is not yet known,
    2805                 :            :    so it should not be output now.  */
    2806                 :            : #define DECL_DEFER_OUTPUT(NODE) \
    2807                 :            :   (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.defer_output)
    2808                 :            : 
    2809                 :            : /* In a VAR_DECL that's static,
    2810                 :            :    nonzero if the space is in the text section.  */
    2811                 :            : #define DECL_IN_TEXT_SECTION(NODE) \
    2812                 :            :   (VAR_DECL_CHECK (NODE)->decl_with_vis.in_text_section)
    2813                 :            : 
    2814                 :            : /* In a VAR_DECL that's static,
    2815                 :            :    nonzero if it belongs to the global constant pool.  */
    2816                 :            : #define DECL_IN_CONSTANT_POOL(NODE) \
    2817                 :            :   (VAR_DECL_CHECK (NODE)->decl_with_vis.in_constant_pool)
    2818                 :            : 
    2819                 :            : /* Nonzero for a given ..._DECL node means that this node should be
    2820                 :            :    put in .common, if possible.  If a DECL_INITIAL is given, and it
    2821                 :            :    is not error_mark_node, then the decl cannot be put in .common.  */
    2822                 :            : #define DECL_COMMON(NODE) \
    2823                 :            :   (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.common_flag)
    2824                 :            : 
    2825                 :            : /* In a VAR_DECL, nonzero if the decl is a register variable with
    2826                 :            :    an explicit asm specification.  */
    2827                 :            : #define DECL_HARD_REGISTER(NODE)  \
    2828                 :            :   (VAR_DECL_CHECK (NODE)->decl_with_vis.hard_register)
    2829                 :            : 
    2830                 :            :   /* Used to indicate that this DECL has weak linkage.  */
    2831                 :            : #define DECL_WEAK(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.weak_flag)
    2832                 :            : 
    2833                 :            : /* Used to indicate that the DECL is a dllimport.  */
    2834                 :            : #define DECL_DLLIMPORT_P(NODE) \
    2835                 :            :   (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.dllimport_flag)
    2836                 :            : 
    2837                 :            : /* Used in a DECL to indicate that, even if it TREE_PUBLIC, it need
    2838                 :            :    not be put out unless it is needed in this translation unit.
    2839                 :            :    Entities like this are shared across translation units (like weak
    2840                 :            :    entities), but are guaranteed to be generated by any translation
    2841                 :            :    unit that needs them, and therefore need not be put out anywhere
    2842                 :            :    where they are not needed.  DECL_COMDAT is just a hint to the
    2843                 :            :    back-end; it is up to front-ends which set this flag to ensure
    2844                 :            :    that there will never be any harm, other than bloat, in putting out
    2845                 :            :    something which is DECL_COMDAT.  */
    2846                 :            : #define DECL_COMDAT(NODE) \
    2847                 :            :   (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.comdat_flag)
    2848                 :            : 
    2849                 :            : #define DECL_COMDAT_GROUP(NODE) \
    2850                 :            :   decl_comdat_group (NODE)
    2851                 :            : 
    2852                 :            : /* Used in TREE_PUBLIC decls to indicate that copies of this DECL in
    2853                 :            :    multiple translation units should be merged.  */
    2854                 :            : #define DECL_ONE_ONLY(NODE) (DECL_COMDAT_GROUP (NODE) != NULL_TREE \
    2855                 :            :                              && (TREE_PUBLIC (NODE) || DECL_EXTERNAL (NODE)))
    2856                 :            : 
    2857                 :            : /* The name of the object as the assembler will see it (but before any
    2858                 :            :    translations made by ASM_OUTPUT_LABELREF).  Often this is the same
    2859                 :            :    as DECL_NAME.  It is an IDENTIFIER_NODE.
    2860                 :            : 
    2861                 :            :    ASSEMBLER_NAME of TYPE_DECLS may store global name of type used for
    2862                 :            :    One Definition Rule based type merging at LTO.  It is computed only for
    2863                 :            :    LTO compilation and C++.  */
    2864                 :            : #define DECL_ASSEMBLER_NAME(NODE) decl_assembler_name (NODE)
    2865                 :            : 
    2866                 :            : /* Raw accessor for DECL_ASSEMBLE_NAME.  */
    2867                 :            : #define DECL_ASSEMBLER_NAME_RAW(NODE) \
    2868                 :            :   (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.assembler_name)
    2869                 :            : 
    2870                 :            : /* Return true if NODE is a NODE that can contain a DECL_ASSEMBLER_NAME.
    2871                 :            :    This is true of all DECL nodes except FIELD_DECL.  */
    2872                 :            : #define HAS_DECL_ASSEMBLER_NAME_P(NODE) \
    2873                 :            :   (CODE_CONTAINS_STRUCT (TREE_CODE (NODE), TS_DECL_WITH_VIS))
    2874                 :            : 
    2875                 :            : /* Returns nonzero if the DECL_ASSEMBLER_NAME for NODE has been set.  If zero,
    2876                 :            :    the NODE might still have a DECL_ASSEMBLER_NAME -- it just hasn't been set
    2877                 :            :    yet.  */
    2878                 :            : #define DECL_ASSEMBLER_NAME_SET_P(NODE) \
    2879                 :            :   (DECL_ASSEMBLER_NAME_RAW (NODE) != NULL_TREE)
    2880                 :            : 
    2881                 :            : /* Set the DECL_ASSEMBLER_NAME for NODE to NAME.  */
    2882                 :            : #define SET_DECL_ASSEMBLER_NAME(NODE, NAME) \
    2883                 :            :   overwrite_decl_assembler_name (NODE, NAME)
    2884                 :            : 
    2885                 :            : /* Copy the DECL_ASSEMBLER_NAME from SRC_DECL to DST_DECL.  Note that
    2886                 :            :    if SRC_DECL's DECL_ASSEMBLER_NAME has not yet been set, using this
    2887                 :            :    macro will not cause the DECL_ASSEMBLER_NAME to be set, but will
    2888                 :            :    clear DECL_ASSEMBLER_NAME of DST_DECL, if it was already set.  In
    2889                 :            :    other words, the semantics of using this macro, are different than
    2890                 :            :    saying:
    2891                 :            : 
    2892                 :            :      SET_DECL_ASSEMBLER_NAME(DST_DECL, DECL_ASSEMBLER_NAME (SRC_DECL))
    2893                 :            : 
    2894                 :            :    which will try to set the DECL_ASSEMBLER_NAME for SRC_DECL.  */
    2895                 :            : 
    2896                 :            : #define COPY_DECL_ASSEMBLER_NAME(SRC_DECL, DST_DECL)                    \
    2897                 :            :   SET_DECL_ASSEMBLER_NAME (DST_DECL, DECL_ASSEMBLER_NAME_RAW (SRC_DECL))
    2898                 :            : 
    2899                 :            : /* Records the section name in a section attribute.  Used to pass
    2900                 :            :    the name from decl_attributes to make_function_rtl and make_decl_rtl.  */
    2901                 :            : #define DECL_SECTION_NAME(NODE) decl_section_name (NODE)
    2902                 :            : 
    2903                 :            : /* Nonzero in a decl means that the gimplifier has seen (or placed)
    2904                 :            :    this variable in a BIND_EXPR.  */
    2905                 :            : #define DECL_SEEN_IN_BIND_EXPR_P(NODE) \
    2906                 :            :   (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.seen_in_bind_expr)
    2907                 :            : 
    2908                 :            : /* Value of the decls's visibility attribute */
    2909                 :            : #define DECL_VISIBILITY(NODE) \
    2910                 :            :   (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.visibility)
    2911                 :            : 
    2912                 :            : /* Nonzero means that the decl (or an enclosing scope) had its
    2913                 :            :    visibility specified rather than being inferred.  */
    2914                 :            : #define DECL_VISIBILITY_SPECIFIED(NODE) \
    2915                 :            :   (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.visibility_specified)
    2916                 :            : 
    2917                 :            : /* In a VAR_DECL, the model to use if the data should be allocated from
    2918                 :            :    thread-local storage.  */
    2919                 :            : #define DECL_TLS_MODEL(NODE) decl_tls_model (NODE)
    2920                 :            : 
    2921                 :            : /* In a VAR_DECL, nonzero if the data should be allocated from
    2922                 :            :    thread-local storage.  */
    2923                 :            : #define DECL_THREAD_LOCAL_P(NODE) \
    2924                 :            :   ((TREE_STATIC (NODE) || DECL_EXTERNAL (NODE)) && decl_tls_model (NODE) >= TLS_MODEL_REAL)
    2925                 :            : 
    2926                 :            : /* In a non-local VAR_DECL with static storage duration, true if the
    2927                 :            :    variable has an initialization priority.  If false, the variable
    2928                 :            :    will be initialized at the DEFAULT_INIT_PRIORITY.  */
    2929                 :            : #define DECL_HAS_INIT_PRIORITY_P(NODE) \
    2930                 :            :   (VAR_DECL_CHECK (NODE)->decl_with_vis.init_priority_p)
    2931                 :            : 
    2932                 :            : extern tree decl_debug_expr_lookup (tree);
    2933                 :            : extern void decl_debug_expr_insert (tree, tree);
    2934                 :            : 
    2935                 :            : /* For VAR_DECL, this is set to an expression that it was split from.  */
    2936                 :            : #define DECL_HAS_DEBUG_EXPR_P(NODE) \
    2937                 :            :   (VAR_DECL_CHECK (NODE)->decl_common.debug_expr_is_from)
    2938                 :            : #define DECL_DEBUG_EXPR(NODE) \
    2939                 :            :   (decl_debug_expr_lookup (VAR_DECL_CHECK (NODE)))
    2940                 :            : 
    2941                 :            : #define SET_DECL_DEBUG_EXPR(NODE, VAL) \
    2942                 :            :   (decl_debug_expr_insert (VAR_DECL_CHECK (NODE), VAL))
    2943                 :            : 
    2944                 :            : extern priority_type decl_init_priority_lookup (tree);
    2945                 :            : extern priority_type decl_fini_priority_lookup (tree);
    2946                 :            : extern void decl_init_priority_insert (tree, priority_type);
    2947                 :            : extern void decl_fini_priority_insert (tree, priority_type);
    2948                 :            : 
    2949                 :            : /* For a VAR_DECL or FUNCTION_DECL the initialization priority of
    2950                 :            :    NODE.  */
    2951                 :            : #define DECL_INIT_PRIORITY(NODE) \
    2952                 :            :   (decl_init_priority_lookup (NODE))
    2953                 :            : /* Set the initialization priority for NODE to VAL.  */
    2954                 :            : #define SET_DECL_INIT_PRIORITY(NODE, VAL) \
    2955                 :            :   (decl_init_priority_insert (NODE, VAL))
    2956                 :            : 
    2957                 :            : /* For a FUNCTION_DECL the finalization priority of NODE.  */
    2958                 :            : #define DECL_FINI_PRIORITY(NODE) \
    2959                 :            :   (decl_fini_priority_lookup (NODE))
    2960                 :            : /* Set the finalization priority for NODE to VAL.  */
    2961                 :            : #define SET_DECL_FINI_PRIORITY(NODE, VAL) \
    2962                 :            :   (decl_fini_priority_insert (NODE, VAL))
    2963                 :            : 
    2964                 :            : /* The initialization priority for entities for which no explicit
    2965                 :            :    initialization priority has been specified.  */
    2966                 :            : #define DEFAULT_INIT_PRIORITY 65535
    2967                 :            : 
    2968                 :            : /* The maximum allowed initialization priority.  */
    2969                 :            : #define MAX_INIT_PRIORITY 65535
    2970                 :            : 
    2971                 :            : /* The largest priority value reserved for use by system runtime
    2972                 :            :    libraries.  */
    2973                 :            : #define MAX_RESERVED_INIT_PRIORITY 100
    2974                 :            : 
    2975                 :            : /* In a VAR_DECL, nonzero if this is a global variable for VOPs.  */
    2976                 :            : #define VAR_DECL_IS_VIRTUAL_OPERAND(NODE) \
    2977                 :            :   (VAR_DECL_CHECK (NODE)->base.u.bits.saturating_flag)
    2978                 :            : 
    2979                 :            : /* In a VAR_DECL, nonzero if this is a non-local frame structure.  */
    2980                 :            : #define DECL_NONLOCAL_FRAME(NODE)  \
    2981                 :            :   (VAR_DECL_CHECK (NODE)->base.default_def_flag)
    2982                 :            : 
    2983                 :            : /* In a VAR_DECL, nonzero if this variable is not aliased by any pointer.  */
    2984                 :            : #define DECL_NONALIASED(NODE) \
    2985                 :            :   (VAR_DECL_CHECK (NODE)->base.nothrow_flag)
    2986                 :            : 
    2987                 :            : /* This field is used to reference anything in decl.result and is meant only
    2988                 :            :    for use by the garbage collector.  */
    2989                 :            : #define DECL_RESULT_FLD(NODE) \
    2990                 :            :   (DECL_NON_COMMON_CHECK (NODE)->decl_non_common.result)
    2991                 :            : 
    2992                 :            : /* The DECL_VINDEX is used for FUNCTION_DECLS in two different ways.
    2993                 :            :    Before the struct containing the FUNCTION_DECL is laid out,
    2994                 :            :    DECL_VINDEX may point to a FUNCTION_DECL in a base class which
    2995                 :            :    is the FUNCTION_DECL which this FUNCTION_DECL will replace as a virtual
    2996                 :            :    function.  When the class is laid out, this pointer is changed
    2997                 :            :    to an INTEGER_CST node which is suitable for use as an index
    2998                 :            :    into the virtual function table. */
    2999                 :            : #define DECL_VINDEX(NODE) \
    3000                 :            :   (FUNCTION_DECL_CHECK (NODE)->function_decl.vindex)
    3001                 :            : 
    3002                 :            : /* In FUNCTION_DECL, holds the decl for the return value.  */
    3003                 :            : #define DECL_RESULT(NODE) (FUNCTION_DECL_CHECK (NODE)->decl_non_common.result)
    3004                 :            : 
    3005                 :            : /* In a FUNCTION_DECL, nonzero if the function cannot be inlined.  */
    3006                 :            : #define DECL_UNINLINABLE(NODE) \
    3007                 :            :   (FUNCTION_DECL_CHECK (NODE)->function_decl.uninlinable)
    3008                 :            : 
    3009                 :            : /* In a FUNCTION_DECL, the saved representation of the body of the
    3010                 :            :    entire function.  */
    3011                 :            : #define DECL_SAVED_TREE(NODE) \
    3012                 :            :   (FUNCTION_DECL_CHECK (NODE)->function_decl.saved_tree)
    3013                 :            : 
    3014                 :            : /* Nonzero in a FUNCTION_DECL means this function should be treated
    3015                 :            :    as if it were a malloc, meaning it returns a pointer that is
    3016                 :            :    not an alias.  */
    3017                 :            : #define DECL_IS_MALLOC(NODE) \
    3018                 :            :   (FUNCTION_DECL_CHECK (NODE)->function_decl.malloc_flag)
    3019                 :            : 
    3020                 :            : /* Macro for direct set and get of function_decl.decl_type.  */
    3021                 :            : #define FUNCTION_DECL_DECL_TYPE(NODE) \
    3022                 :            :   (NODE->function_decl.decl_type)
    3023                 :            : 
    3024                 :            : /* Set decl_type of a DECL.  Set it to T when SET is true, or reset
    3025                 :            :    it to NONE.  */
    3026                 :            : 
    3027                 :            : static inline void
    3028                 :    1249651 : set_function_decl_type (tree decl, function_decl_type t, bool set)
    3029                 :            : {
    3030                 :    1249651 :   if (set)
    3031                 :            :     {
    3032                 :     731257 :       gcc_assert (FUNCTION_DECL_DECL_TYPE (decl) == NONE
    3033                 :            :                   || FUNCTION_DECL_DECL_TYPE (decl) == t);
    3034                 :     731257 :       decl->function_decl.decl_type = t;
    3035                 :            :     }
    3036                 :     518394 :   else if (FUNCTION_DECL_DECL_TYPE (decl) == t)
    3037                 :         10 :     FUNCTION_DECL_DECL_TYPE (decl) = NONE;
    3038                 :    1249651 : }
    3039                 :            : 
    3040                 :            : /* Nonzero in a FUNCTION_DECL means this function should be treated as
    3041                 :            :    C++ operator new, meaning that it returns a pointer for which we
    3042                 :            :    should not use type based aliasing.  */
    3043                 :            : #define DECL_IS_OPERATOR_NEW_P(NODE) \
    3044                 :            :   (FUNCTION_DECL_CHECK (NODE)->function_decl.decl_type == OPERATOR_NEW)
    3045                 :            : 
    3046                 :            : #define DECL_IS_REPLACEABLE_OPERATOR_NEW_P(NODE) \
    3047                 :            :   (DECL_IS_OPERATOR_NEW_P (NODE) && DECL_IS_MALLOC (NODE))
    3048                 :            : 
    3049                 :            : #define DECL_SET_IS_OPERATOR_NEW(NODE, VAL) \
    3050                 :            :   set_function_decl_type (FUNCTION_DECL_CHECK (NODE), OPERATOR_NEW, VAL)
    3051                 :            : 
    3052                 :            : /* Nonzero in a FUNCTION_DECL means this function should be treated as
    3053                 :            :    C++ operator delete.  */
    3054                 :            : #define DECL_IS_OPERATOR_DELETE_P(NODE) \
    3055                 :            :   (FUNCTION_DECL_CHECK (NODE)->function_decl.decl_type == OPERATOR_DELETE)
    3056                 :            : 
    3057                 :            : #define DECL_SET_IS_OPERATOR_DELETE(NODE, VAL) \
    3058                 :            :   set_function_decl_type (FUNCTION_DECL_CHECK (NODE), OPERATOR_DELETE, VAL)
    3059                 :            : 
    3060                 :            : /* Nonzero in a FUNCTION_DECL means this function may return more
    3061                 :            :    than once.  */
    3062                 :            : #define DECL_IS_RETURNS_TWICE(NODE) \
    3063                 :            :   (FUNCTION_DECL_CHECK (NODE)->function_decl.returns_twice_flag)
    3064                 :            : 
    3065                 :            : /* Nonzero in a FUNCTION_DECL means this function should be treated
    3066                 :            :    as "pure" function (like const function, but may read global memory).  */
    3067                 :            : #define DECL_PURE_P(NODE) (FUNCTION_DECL_CHECK (NODE)->function_decl.pure_flag)
    3068                 :            : 
    3069                 :            : /* Nonzero only if one of TREE_READONLY or DECL_PURE_P is nonzero AND
    3070                 :            :    the const or pure function may not terminate.  When this is nonzero
    3071                 :            :    for a const or pure function, it can be dealt with by cse passes
    3072                 :            :    but cannot be removed by dce passes since you are not allowed to
    3073                 :            :    change an infinite looping program into one that terminates without
    3074                 :            :    error.  */
    3075                 :            : #define DECL_LOOPING_CONST_OR_PURE_P(NODE) \
    3076                 :            :   (FUNCTION_DECL_CHECK (NODE)->function_decl.looping_const_or_pure_flag)
    3077                 :            : 
    3078                 :            : /* Nonzero in a FUNCTION_DECL means this function should be treated
    3079                 :            :    as "novops" function (function that does not read global memory,
    3080                 :            :    but may have arbitrary side effects).  */
    3081                 :            : #define DECL_IS_NOVOPS(NODE) \
    3082                 :            :   (FUNCTION_DECL_CHECK (NODE)->function_decl.novops_flag)
    3083                 :            : 
    3084                 :            : /* Used in FUNCTION_DECLs to indicate that they should be run automatically
    3085                 :            :    at the beginning or end of execution.  */
    3086                 :            : #define DECL_STATIC_CONSTRUCTOR(NODE) \
    3087                 :            :   (FUNCTION_DECL_CHECK (NODE)->function_decl.static_ctor_flag)
    3088                 :            : 
    3089                 :            : #define DECL_STATIC_DESTRUCTOR(NODE) \
    3090                 :            : (FUNCTION_DECL_CHECK (NODE)->function_decl.static_dtor_flag)
    3091                 :            : 
    3092                 :            : /* Used in FUNCTION_DECLs to indicate that function entry and exit should
    3093                 :            :    be instrumented with calls to support routines.  */
    3094                 :            : #define DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT(NODE) \
    3095                 :            :   (FUNCTION_DECL_CHECK (NODE)->function_decl.no_instrument_function_entry_exit)
    3096                 :            : 
    3097                 :            : /* Used in FUNCTION_DECLs to indicate that limit-stack-* should be
    3098                 :            :    disabled in this function.  */
    3099                 :            : #define DECL_NO_LIMIT_STACK(NODE) \
    3100                 :            :   (FUNCTION_DECL_CHECK (NODE)->function_decl.no_limit_stack)
    3101                 :            : 
    3102                 :            : /* In a FUNCTION_DECL indicates that a static chain is needed.  */
    3103                 :            : #define DECL_STATIC_CHAIN(NODE) \
    3104                 :            :   (FUNCTION_DECL_CHECK (NODE)->decl_with_vis.regdecl_flag)
    3105                 :            : 
    3106                 :            : /* Nonzero for a decl that cgraph has decided should be inlined into
    3107                 :            :    at least one call site.  It is not meaningful to look at this
    3108                 :            :    directly; always use cgraph_function_possibly_inlined_p.  */
    3109                 :            : #define DECL_POSSIBLY_INLINED(DECL) \
    3110                 :            :   FUNCTION_DECL_CHECK (DECL)->function_decl.possibly_inlined
    3111                 :            : 
    3112                 :            : /* Nonzero in a FUNCTION_DECL means that this function was declared inline,
    3113                 :            :    such as via the `inline' keyword in C/C++.  This flag controls the linkage
    3114                 :            :    semantics of 'inline'  */
    3115                 :            : #define DECL_DECLARED_INLINE_P(NODE) \
    3116                 :            :   (FUNCTION_DECL_CHECK (NODE)->function_decl.declared_inline_flag)
    3117                 :            : 
    3118                 :            : /* Nonzero in a FUNCTION_DECL means this function should not get
    3119                 :            :    -Winline warnings.  */
    3120                 :            : #define DECL_NO_INLINE_WARNING_P(NODE) \
    3121                 :            :   (FUNCTION_DECL_CHECK (NODE)->function_decl.no_inline_warning_flag)
    3122                 :            : 
    3123                 :            : /* Nonzero if a FUNCTION_CODE is a TM load/store.  */
    3124                 :            : #define BUILTIN_TM_LOAD_STORE_P(FN) \
    3125                 :            :   ((FN) >= BUILT_IN_TM_STORE_1 && (FN) <= BUILT_IN_TM_LOAD_RFW_LDOUBLE)
    3126                 :            : 
    3127                 :            : /* Nonzero if a FUNCTION_CODE is a TM load.  */
    3128                 :            : #define BUILTIN_TM_LOAD_P(FN) \
    3129                 :            :   ((FN) >= BUILT_IN_TM_LOAD_1 && (FN) <= BUILT_IN_TM_LOAD_RFW_LDOUBLE)
    3130                 :            : 
    3131                 :            : /* Nonzero if a FUNCTION_CODE is a TM store.  */
    3132                 :            : #define BUILTIN_TM_STORE_P(FN) \
    3133                 :            :   ((FN) >= BUILT_IN_TM_STORE_1 && (FN) <= BUILT_IN_TM_STORE_WAW_LDOUBLE)
    3134                 :            : 
    3135                 :            : #define CASE_BUILT_IN_TM_LOAD(FN)       \
    3136                 :            :   case BUILT_IN_TM_LOAD_##FN:           \
    3137                 :            :   case BUILT_IN_TM_LOAD_RAR_##FN:       \
    3138                 :            :   case BUILT_IN_TM_LOAD_RAW_##FN:       \
    3139                 :            :   case BUILT_IN_TM_LOAD_RFW_##FN
    3140                 :            : 
    3141                 :            : #define CASE_BUILT_IN_TM_STORE(FN)      \
    3142                 :            :   case BUILT_IN_TM_STORE_##FN:          \
    3143                 :            :   case BUILT_IN_TM_STORE_WAR_##FN:      \
    3144                 :            :   case BUILT_IN_TM_STORE_WAW_##FN
    3145                 :            : 
    3146                 :            : /* Nonzero in a FUNCTION_DECL that should be always inlined by the inliner
    3147                 :            :    disregarding size and cost heuristics.  This is equivalent to using
    3148                 :            :    the always_inline attribute without the required diagnostics if the
    3149                 :            :    function cannot be inlined.  */
    3150                 :            : #define DECL_DISREGARD_INLINE_LIMITS(NODE) \
    3151                 :            :   (FUNCTION_DECL_CHECK (NODE)->function_decl.disregard_inline_limits)
    3152                 :            : 
    3153                 :            : extern vec<tree, va_gc> **decl_debug_args_lookup (tree);
    3154                 :            : extern vec<tree, va_gc> **decl_debug_args_insert (tree);
    3155                 :            : 
    3156                 :            : /* Nonzero if a FUNCTION_DECL has DEBUG arguments attached to it.  */
    3157                 :            : #define DECL_HAS_DEBUG_ARGS_P(NODE) \
    3158                 :            :   (FUNCTION_DECL_CHECK (NODE)->function_decl.has_debug_args_flag)
    3159                 :            : 
    3160                 :            : /* For FUNCTION_DECL, this holds a pointer to a structure ("struct function")
    3161                 :            :    that describes the status of this function.  */
    3162                 :            : #define DECL_STRUCT_FUNCTION(NODE) \
    3163                 :            :   (FUNCTION_DECL_CHECK (NODE)->function_decl.f)
    3164                 :            : 
    3165                 :            : /* For a builtin function, identify which part of the compiler defined it.  */
    3166                 :            : #define DECL_BUILT_IN_CLASS(NODE) \
    3167                 :            :    ((built_in_class) FUNCTION_DECL_CHECK (NODE)->function_decl.built_in_class)
    3168                 :            : 
    3169                 :            : /* In FUNCTION_DECL, a chain of ..._DECL nodes.  */
    3170                 :            : #define DECL_ARGUMENTS(NODE) \
    3171                 :            :    (FUNCTION_DECL_CHECK (NODE)->function_decl.arguments)
    3172                 :            : 
    3173                 :            : /* In FUNCTION_DECL, the function specific target options to use when compiling
    3174                 :            :    this function.  */
    3175                 :            : #define DECL_FUNCTION_SPECIFIC_TARGET(NODE) \
    3176                 :            :    (FUNCTION_DECL_CHECK (NODE)->function_decl.function_specific_target)
    3177                 :            : 
    3178                 :            : /* In FUNCTION_DECL, the function specific optimization options to use when
    3179                 :            :    compiling this function.  */
    3180                 :            : #define DECL_FUNCTION_SPECIFIC_OPTIMIZATION(NODE) \
    3181                 :            :    (FUNCTION_DECL_CHECK (NODE)->function_decl.function_specific_optimization)
    3182                 :            : 
    3183                 :            : /* In FUNCTION_DECL, this is set if this function has other versions generated
    3184                 :            :    using "target" attributes.  The default version is the one which does not
    3185                 :            :    have any "target" attribute set. */
    3186                 :            : #define DECL_FUNCTION_VERSIONED(NODE)\
    3187                 :            :    (FUNCTION_DECL_CHECK (NODE)->function_decl.versioned_function)
    3188                 :            : 
    3189                 :            : /* In FUNCTION_DECL, this is set if this function is a C++ constructor.
    3190                 :            :    Devirtualization machinery uses this knowledge for determing type of the
    3191                 :            :    object constructed.  Also we assume that constructor address is not
    3192                 :            :    important.  */
    3193                 :            : #define DECL_CXX_CONSTRUCTOR_P(NODE)\
    3194                 :            :    (FUNCTION_DECL_CHECK (NODE)->decl_with_vis.cxx_constructor)
    3195                 :            : 
    3196                 :            : /* In FUNCTION_DECL, this is set if this function is a C++ destructor.
    3197                 :            :    Devirtualization machinery uses this to track types in destruction.  */
    3198                 :            : #define DECL_CXX_DESTRUCTOR_P(NODE)\
    3199                 :            :    (FUNCTION_DECL_CHECK (NODE)->decl_with_vis.cxx_destructor)
    3200                 :            : 
    3201                 :            : /* In FUNCTION_DECL, this is set if this function is a lambda function.  */
    3202                 :            : #define DECL_LAMBDA_FUNCTION_P(NODE) \
    3203                 :            :   (FUNCTION_DECL_CHECK (NODE)->function_decl.decl_type == LAMBDA_FUNCTION)
    3204                 :            : 
    3205                 :            : #define DECL_SET_LAMBDA_FUNCTION(NODE, VAL) \
    3206                 :            :   set_function_decl_type (FUNCTION_DECL_CHECK (NODE), LAMBDA_FUNCTION, VAL)
    3207                 :            : 
    3208                 :            : /* In FUNCTION_DECL that represent an virtual method this is set when
    3209                 :            :    the method is final.  */
    3210                 :            : #define DECL_FINAL_P(NODE)\
    3211                 :            :    (FUNCTION_DECL_CHECK (NODE)->decl_with_vis.final)
    3212                 :            : 
    3213                 :            : /* The source language of the translation-unit.  */
    3214                 :            : #define TRANSLATION_UNIT_LANGUAGE(NODE) \
    3215                 :            :   (TRANSLATION_UNIT_DECL_CHECK (NODE)->translation_unit_decl.language)
    3216                 :            : 
    3217                 :            : /* TRANSLATION_UNIT_DECL inherits from DECL_MINIMAL.  */
    3218                 :            : 
    3219                 :            : /* For a TYPE_DECL, holds the "original" type.  (TREE_TYPE has the copy.) */
    3220                 :            : #define DECL_ORIGINAL_TYPE(NODE) \
    3221                 :            :   (TYPE_DECL_CHECK (NODE)->decl_non_common.result)
    3222                 :            : 
    3223                 :            : /* In a TYPE_DECL nonzero means the detail info about this type is not dumped
    3224                 :            :    into stabs.  Instead it will generate cross reference ('x') of names.
    3225                 :            :    This uses the same flag as DECL_EXTERNAL.  */
    3226                 :            : #define TYPE_DECL_SUPPRESS_DEBUG(NODE) \
    3227                 :            :   (TYPE_DECL_CHECK (NODE)->decl_common.decl_flag_1)
    3228                 :            : 
    3229                 :            : /* Getter of the imported declaration associated to the
    3230                 :            :    IMPORTED_DECL node.  */
    3231                 :            : #define IMPORTED_DECL_ASSOCIATED_DECL(NODE) \
    3232                 :            : (DECL_INITIAL (IMPORTED_DECL_CHECK (NODE)))
    3233                 :            : 
    3234                 :            : /* Getter of the symbol declaration associated with the
    3235                 :            :    NAMELIST_DECL node.  */
    3236                 :            : #define NAMELIST_DECL_ASSOCIATED_DECL(NODE) \
    3237                 :            :   (DECL_INITIAL (NODE))
    3238                 :            : 
    3239                 :            : /* A STATEMENT_LIST chains statements together in GENERIC and GIMPLE.
    3240                 :            :    To reduce overhead, the nodes containing the statements are not trees.
    3241                 :            :    This avoids the overhead of tree_common on all linked list elements.
    3242                 :            : 
    3243                 :            :    Use the interface in tree-iterator.h to access this node.  */
    3244                 :            : 
    3245                 :            : #define STATEMENT_LIST_HEAD(NODE) \
    3246                 :            :   (STATEMENT_LIST_CHECK (NODE)->stmt_list.head)
    3247                 :            : #define STATEMENT_LIST_TAIL(NODE) \
    3248                 :            :   (STATEMENT_LIST_CHECK (NODE)->stmt_list.tail)
    3249                 :            : 
    3250                 :            : #define TREE_OPTIMIZATION(NODE) \
    3251                 :            :   (OPTIMIZATION_NODE_CHECK (NODE)->optimization.opts)
    3252                 :            : 
    3253                 :            : #define TREE_OPTIMIZATION_OPTABS(NODE) \
    3254                 :            :   (OPTIMIZATION_NODE_CHECK (NODE)->optimization.optabs)
    3255                 :            : 
    3256                 :            : #define TREE_OPTIMIZATION_BASE_OPTABS(NODE) \
    3257                 :            :   (OPTIMIZATION_NODE_CHECK (NODE)->optimization.base_optabs)
    3258                 :            : 
    3259                 :            : /* Return a tree node that encapsulates the optimization options in OPTS.  */
    3260                 :            : extern tree build_optimization_node (struct gcc_options *opts);
    3261                 :            : 
    3262                 :            : #define TREE_TARGET_OPTION(NODE) \
    3263                 :            :   (TARGET_OPTION_NODE_CHECK (NODE)->target_option.opts)
    3264                 :            : 
    3265                 :            : #define TREE_TARGET_GLOBALS(NODE) \
    3266                 :            :   (TARGET_OPTION_NODE_CHECK (NODE)->target_option.globals)
    3267                 :            : 
    3268                 :            : /* Return a tree node that encapsulates the target options in OPTS.  */
    3269                 :            : extern tree build_target_option_node (struct gcc_options *opts);
    3270                 :            : 
    3271                 :            : extern void prepare_target_option_nodes_for_pch (void);
    3272                 :            : 
    3273                 :            : #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
    3274                 :            : 
    3275                 :            : inline tree
    3276                 :>28980*10^7 : tree_check (tree __t, const char *__f, int __l, const char *__g, tree_code __c)
    3277                 :            : {
    3278                 :>13699*10^7 :   if (TREE_CODE (__t) != __c)
    3279                 :          0 :     tree_check_failed (__t, __f, __l, __g, __c, 0);
    3280                 :>21840*10^7 :   return __t;
    3281                 :            : }
    3282                 :            : 
    3283                 :            : inline tree
    3284                 :            : tree_not_check (tree __t, const char *__f, int __l, const char *__g,
    3285                 :            :                 enum tree_code __c)
    3286                 :            : {
    3287                 :            :   if (TREE_CODE (__t) == __c)
    3288                 :            :     tree_not_check_failed (__t, __f, __l, __g, __c, 0);
    3289                 :            :   return __t;
    3290                 :            : }
    3291                 :            : 
    3292                 :            : inline tree
    3293                 : 6285773644 : tree_check2 (tree __t, const char *__f, int __l, const char *__g,
    3294                 :            :              enum tree_code __c1, enum tree_code __c2)
    3295                 :            : {
    3296                 : 5624050354 :   if (TREE_CODE (__t) != __c1
    3297                 : 2264096456 :       && TREE_CODE (__t) != __c2)
    3298                 :          0 :     tree_check_failed (__t, __f, __l, __g, __c1, __c2, 0);
    3299                 : 5792431989 :   return __t;
    3300                 :            : }
    3301                 :            : 
    3302                 :            : inline tree
    3303                 : 9851471674 : tree_not_check2 (tree __t, const char *__f, int __l, const char *__g,
    3304                 :            :                  enum tree_code __c1, enum tree_code __c2)
    3305                 :            : {
    3306                 : 2037576549 :   if (TREE_CODE (__t) == __c1
    3307                 : 1829524356 :       || TREE_CODE (__t) == __c2)
    3308                 :          0 :     tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, 0);
    3309                 : 8304953380 :   return __t;
    3310                 :            : }
    3311                 :            : 
    3312                 :            : inline tree
    3313                 :12816626135 : tree_check3 (tree __t, const char *__f, int __l, const char *__g,
    3314                 :            :              enum tree_code __c1, enum tree_code __c2, enum tree_code __c3)
    3315                 :            : {
    3316                 :10743817870 :   if (TREE_CODE (__t) != __c1
    3317                 : 1126055700 :       && TREE_CODE (__t) != __c2
    3318                 :  828331497 :       && TREE_CODE (__t) != __c3)
    3319                 :          0 :     tree_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, 0);
    3320                 :11728991162 :   return __t;
    3321                 :            : }
    3322                 :            : 
    3323                 :            : inline tree
    3324                 :            : tree_not_check3 (tree __t, const char *__f, int __l, const char *__g,
    3325                 :            :                  enum tree_code __c1, enum tree_code __c2, enum tree_code __c3)
    3326                 :            : {
    3327                 :            :   if (TREE_CODE (__t) == __c1
    3328                 :            :       || TREE_CODE (__t) == __c2
    3329                 :            :       || TREE_CODE (__t) == __c3)
    3330                 :            :     tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, 0);
    3331                 :            :   return __t;
    3332                 :            : }
    3333                 :            : 
    3334                 :            : inline tree
    3335                 : 1745866526 : tree_check4 (tree __t, const char *__f, int __l, const char *__g,
    3336                 :            :              enum tree_code __c1, enum tree_code __c2, enum tree_code __c3,
    3337                 :            :              enum tree_code __c4)
    3338                 :            : {
    3339                 : 1745866526 :   if (TREE_CODE (__t) != __c1
    3340                 :  326113712 :       && TREE_CODE (__t) != __c2
    3341                 :  288561054 :       && TREE_CODE (__t) != __c3
    3342                 :  276062032 :       && TREE_CODE (__t) != __c4)
    3343                 :          0 :     tree_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, 0);
    3344                 : 1745866526 :   return __t;
    3345                 :            : }
    3346                 :            : 
    3347                 :            : inline tree
    3348                 :  242466792 : tree_not_check4 (tree __t, const char *__f, int __l, const char *__g,
    3349                 :            :                  enum tree_code __c1, enum tree_code __c2, enum tree_code __c3,
    3350                 :            :                  enum tree_code __c4)
    3351                 :            : {
    3352                 :  242466792 :   if (TREE_CODE (__t) == __c1
    3353                 :  242466792 :       || TREE_CODE (__t) == __c2
    3354                 :  242466792 :       || TREE_CODE (__t) == __c3
    3355                 :  242466792 :       || TREE_CODE (__t) == __c4)
    3356                 :          0 :     tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, 0);
    3357                 :  242466792 :   return __t;
    3358                 :            : }
    3359                 :            : 
    3360                 :            : inline tree
    3361                 : 3389997593 : tree_check5 (tree __t, const char *__f, int __l, const char *__g,
    3362                 :            :              enum tree_code __c1, enum tree_code __c2, enum tree_code __c3,
    3363                 :            :              enum tree_code __c4, enum tree_code __c5)
    3364                 :            : {
    3365                 : 3389997593 :   if (TREE_CODE (__t) != __c1
    3366                 :  648637056 :       && TREE_CODE (__t) != __c2
    3367                 :  222968302 :       && TREE_CODE (__t) != __c3
    3368                 :  187933915 :       && TREE_CODE (__t) != __c4
    3369                 :        395 :       && TREE_CODE (__t) != __c5)
    3370                 :          0 :     tree_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, __c5, 0);
    3371                 : 3389997593 :   return __t;
    3372                 :            : }
    3373                 :            : 
    3374                 :            : inline tree
    3375                 :            : tree_not_check5 (tree __t, const char *__f, int __l, const char *__g,
    3376                 :            :                  enum tree_code __c1, enum tree_code __c2, enum tree_code __c3,
    3377                 :            :                  enum tree_code __c4, enum tree_code __c5)
    3378                 :            : {
    3379                 :            :   if (TREE_CODE (__t) == __c1
    3380                 :            :       || TREE_CODE (__t) == __c2
    3381                 :            :       || TREE_CODE (__t) == __c3
    3382                 :            :       || TREE_CODE (__t) == __c4
    3383                 :            :       || TREE_CODE (__t) == __c5)
    3384                 :            :     tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, __c5, 0);
    3385                 :            :   return __t;
    3386                 :            : }
    3387                 :            : 
    3388                 :            : inline tree
    3389                 :>34245*10^7 : contains_struct_check (tree __t, const enum tree_node_structure_enum __s,
    3390                 :            :                        const char *__f, int __l, const char *__g)
    3391                 :            : {
    3392                 :>22428*10^7 :   if (tree_contains_struct[TREE_CODE (__t)][__s] != 1)
    3393                 :          0 :       tree_contains_struct_check_failed (__t, __s, __f, __l, __g);
    3394                 :>23500*10^7 :   return __t;
    3395                 :            : }
    3396                 :            : 
    3397                 :            : inline tree
    3398                 :>19651*10^7 : tree_class_check (tree __t, const enum tree_code_class __class,
    3399                 :            :                   const char *__f, int __l, const char *__g)
    3400                 :            : {
    3401                 :>11154*10^7 :   if (TREE_CODE_CLASS (TREE_CODE (__t)) != __class)
    3402                 :          0 :     tree_class_check_failed (__t, __class, __f, __l, __g);
    3403                 :>12929*10^7 :   return __t;
    3404                 :            : }
    3405                 :            : 
    3406                 :            : inline tree
    3407                 :    2724480 : tree_range_check (tree __t,
    3408                 :            :                   enum tree_code __code1, enum tree_code __code2,
    3409                 :            :                   const char *__f, int __l, const char *__g)
    3410                 :            : {
    3411                 :    2142905 :   if (TREE_CODE (__t) < __code1 || TREE_CODE (__t) > __code2)
    3412                 :          0 :     tree_range_check_failed (__t, __f, __l, __g, __code1, __code2);
    3413                 :    2701806 :   return __t;
    3414                 :            : }
    3415                 :            : 
    3416                 :            : inline tree
    3417                 :    2596284 : omp_clause_subcode_check (tree __t, enum omp_clause_code __code,
    3418                 :            :                           const char *__f, int __l, const char *__g)
    3419                 :            : {
    3420                 :    2596284 :   if (TREE_CODE (__t) != OMP_CLAUSE)
    3421                 :          0 :     tree_check_failed (__t, __f, __l, __g, OMP_CLAUSE, 0);
    3422                 :    2596284 :   if (__t->omp_clause.code != __code)
    3423                 :          0 :     omp_clause_check_failed (__t, __f, __l, __g, __code);
    3424                 :    2596284 :   return __t;
    3425                 :            : }
    3426                 :            : 
    3427                 :            : inline tree
    3428                 :    2794581 : omp_clause_range_check (tree __t,
    3429                 :            :                         enum omp_clause_code __code1,
    3430                 :            :                         enum omp_clause_code __code2,
    3431                 :            :                         const char *__f, int __l, const char *__g)
    3432                 :            : {
    3433                 :    2794581 :   if (TREE_CODE (__t) != OMP_CLAUSE)
    3434                 :          0 :     tree_check_failed (__t, __f, __l, __g, OMP_CLAUSE, 0);
    3435                 :    2794581 :   if ((int) __t->omp_clause.code < (int) __code1
    3436                 :    2794581 :       || (int) __t->omp_clause.code > (int) __code2)
    3437                 :          0 :     omp_clause_range_check_failed (__t, __f, __l, __g, __code1, __code2);
    3438                 :    2794581 :   return __t;
    3439                 :            : }
    3440                 :            : 
    3441                 :            : /* These checks have to be special cased.  */
    3442                 :            : 
    3443                 :            : inline tree
    3444                 :72262625606 : expr_check (tree __t, const char *__f, int __l, const char *__g)
    3445                 :            : {
    3446                 :72262625606 :   char const __c = TREE_CODE_CLASS (TREE_CODE (__t));
    3447                 :36624076697 :   if (!IS_EXPR_CODE_CLASS (__c))
    3448                 :          0 :     tree_class_check_failed (__t, tcc_expression, __f, __l, __g);
    3449                 :36773374669 :   return __t;
    3450                 :            : }
    3451                 :            : 
    3452                 :            : /* These checks have to be special cased.  */
    3453                 :            : 
    3454                 :            : inline tree
    3455                 :14648192781 : non_type_check (tree __t, const char *__f, int __l, const char *__g)
    3456                 :            : {
    3457                 : 8839236017 :   if (TYPE_P (__t))
    3458                 :          0 :     tree_not_class_check_failed (__t, tcc_type, __f, __l, __g);
    3459                 :10576321930 :   return __t;
    3460                 :            : }
    3461                 :            : 
    3462                 :            : inline const HOST_WIDE_INT *
    3463                 :24956364382 : tree_int_cst_elt_check (const_tree __t, int __i,
    3464                 :            :                         const char *__f, int __l, const char *__g)
    3465                 :            : {
    3466                 :24956364382 :   if (TREE_CODE (__t) != INTEGER_CST)
    3467                 :          0 :     tree_check_failed (__t, __f, __l, __g, INTEGER_CST, 0);
    3468                 :24956364382 :   if (__i < 0 || __i >= __t->base.u.int_length.extended)
    3469                 :          0 :     tree_int_cst_elt_check_failed (__i, __t->base.u.int_length.extended,
    3470                 :            :                                    __f, __l, __g);
    3471                 :24956364382 :   return &CONST_CAST_TREE (__t)->int_cst.val[__i];
    3472                 :            : }
    3473                 :            : 
    3474                 :            : inline HOST_WIDE_INT *
    3475                 : 6512533121 : tree_int_cst_elt_check (tree __t, int __i,
    3476                 :            :                         const char *__f, int __l, const char *__g)
    3477                 :            : {
    3478                 : 6512533121 :   if (TREE_CODE (__t) != INTEGER_CST)
    3479                 :          0 :     tree_check_failed (__t, __f, __l, __g, INTEGER_CST, 0);
    3480                 : 6512533121 :   if (__i < 0 || __i >= __t->base.u.int_length.extended)
    3481                 :          0 :     tree_int_cst_elt_check_failed (__i, __t->base.u.int_length.extended,
    3482                 :            :                                    __f, __l, __g);
    3483                 : 6512533121 :   return &CONST_CAST_TREE (__t)->int_cst.val[__i];
    3484                 :            : }
    3485                 :            : 
    3486                 :            : /* Workaround -Wstrict-overflow false positive during profiledbootstrap.  */
    3487                 :            : 
    3488                 :            : # if GCC_VERSION >= 4006
    3489                 :            : #pragma GCC diagnostic push
    3490                 :            : #pragma GCC diagnostic ignored "-Wstrict-overflow"
    3491                 :            : #endif
    3492                 :            : 
    3493                 :            : inline tree *
    3494                 :18724675548 : tree_vec_elt_check (tree __t, int __i,
    3495                 :            :                     const char *__f, int __l, const char *__g)
    3496                 :            : {
    3497                 :18724675548 :   if (TREE_CODE (__t) != TREE_VEC)
    3498                 :          0 :     tree_check_failed (__t, __f, __l, __g, TREE_VEC, 0);
    3499                 :18724675548 :   if (__i < 0 || __i >= __t->base.u.length)
    3500                 :          0 :     tree_vec_elt_check_failed (__i, __t->base.u.length, __f, __l, __g);
    3501                 :18724675548 :   return &CONST_CAST_TREE (__t)->vec.a[__i];
    3502                 :            : }
    3503                 :            : 
    3504                 :            : # if GCC_VERSION >= 4006
    3505                 :            : #pragma GCC diagnostic pop
    3506                 :            : #endif
    3507                 :            : 
    3508                 :            : inline tree *
    3509                 :    4314337 : omp_clause_elt_check (tree __t, int __i,
    3510                 :            :                       const char *__f, int __l, const char *__g)
    3511                 :            : {
    3512                 :    4314337 :   if (TREE_CODE (__t) != OMP_CLAUSE)
    3513                 :          0 :     tree_check_failed (__t, __f, __l, __g, OMP_CLAUSE, 0);
    3514                 :    4314337 :   if (__i < 0 || __i >= omp_clause_num_ops [__t->omp_clause.code])
    3515                 :          0 :     omp_clause_operand_check_failed (__i, __t, __f, __l, __g);
    3516                 :    4314337 :   return &__t->omp_clause.ops[__i];
    3517                 :            : }
    3518                 :            : 
    3519                 :            : /* These checks have to be special cased.  */
    3520                 :            : 
    3521                 :            : inline tree
    3522                 : 2586571717 : any_integral_type_check (tree __t, const char *__f, int __l, const char *__g)
    3523                 :            : {
    3524                 : 2587690204 :   if (!ANY_INTEGRAL_TYPE_P (__t))
    3525                 :          0 :     tree_check_failed (__t, __f, __l, __g, BOOLEAN_TYPE, ENUMERAL_TYPE,
    3526                 :            :                        INTEGER_TYPE, 0);
    3527                 : 2586571717 :   return __t;
    3528                 :            : }
    3529                 :            : 
    3530                 :            : inline const_tree
    3531                 :74752345346 : tree_check (const_tree __t, const char *__f, int __l, const char *__g,
    3532                 :            :             tree_code __c)
    3533                 :            : {
    3534                 :32170324584 :   if (TREE_CODE (__t) != __c)
    3535                 :          0 :     tree_check_failed (__t, __f, __l, __g, __c, 0);
    3536                 :48251163045 :   return __t;
    3537                 :            : }
    3538                 :            : 
    3539                 :            : inline const_tree
    3540                 :            : tree_not_check (const_tree __t, const char *__f, int __l, const char *__g,
    3541                 :            :                 enum tree_code __c)
    3542                 :            : {
    3543                 :            :   if (TREE_CODE (__t) == __c)
    3544                 :            :     tree_not_check_failed (__t, __f, __l, __g, __c, 0);
    3545                 :            :   return __t;
    3546                 :            : }
    3547                 :            : 
    3548                 :            : inline const_tree
    3549                 : 2442581275 : tree_check2 (const_tree __t, const char *__f, int __l, const char *__g,
    3550                 :            :              enum tree_code __c1, enum tree_code __c2)
    3551                 :            : {
    3552                 : 1969046162 :   if (TREE_CODE (__t) != __c1
    3553                 :  679410286 :       && TREE_CODE (__t) != __c2)
    3554                 :          0 :     tree_check_failed (__t, __f, __l, __g, __c1, __c2, 0);
    3555                 : 1403470280 :   return __t;
    3556                 :            : }
    3557                 :            : 
    3558                 :            : inline const_tree
    3559                 :  376761202 : tree_not_check2 (const_tree __t, const char *__f, int __l, const char *__g,
    3560                 :            :                  enum tree_code __c1, enum tree_code __c2)
    3561                 :            : {
    3562                 :  376761202 :   if (TREE_CODE (__t) == __c1
    3563                 :            :       || TREE_CODE (__t) == __c2)
    3564                 :            :     tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, 0);
    3565                 :  374533846 :   return __t;
    3566                 :            : }
    3567                 :            : 
    3568                 :            : inline const_tree
    3569                 : 1939861051 : tree_check3 (const_tree __t, const char *__f, int __l, const char *__g,
    3570                 :            :              enum tree_code __c1, enum tree_code __c2, enum tree_code __c3)
    3571                 :            : {
    3572                 : 1434869441 :   if (TREE_CODE (__t) != __c1
    3573                 :   63457159 :       && TREE_CODE (__t) != __c2
    3574                 :   40361504 :       && TREE_CODE (__t) != __c3)
    3575                 :          0 :     tree_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, 0);
    3576                 : 1664812751 :   return __t;
    3577                 :            : }
    3578                 :            : 
    3579                 :            : inline const_tree
    3580                 :            : tree_not_check3 (const_tree __t, const char *__f, int __l, const char *__g,
    3581                 :            :                  enum tree_code __c1, enum tree_code __c2, enum tree_code __c3)
    3582                 :            : {
    3583                 :            :   if (TREE_CODE (__t) == __c1
    3584                 :            :       || TREE_CODE (__t) == __c2
    3585                 :            :       || TREE_CODE (__t) == __c3)
    3586                 :            :     tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, 0);
    3587                 :            :   return __t;
    3588                 :            : }
    3589                 :            : 
    3590                 :            : inline const_tree
    3591                 :   59577800 : tree_check4 (const_tree __t, const char *__f, int __l, const char *__g,
    3592                 :            :              enum tree_code __c1, enum tree_code __c2, enum tree_code __c3,
    3593                 :            :              enum tree_code __c4)
    3594                 :            : {
    3595                 :   59577800 :   if (TREE_CODE (__t) != __c1
    3596                 :    1074950 :       && TREE_CODE (__t) != __c2
    3597                 :     703527 :       && TREE_CODE (__t) != __c3
    3598                 :     703527 :       && TREE_CODE (__t) != __c4)
    3599                 :          0 :     tree_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, 0);
    3600                 :   59577800 :   return __t;
    3601                 :            : }
    3602                 :            : 
    3603                 :            : inline const_tree
    3604                 :   12789290 : tree_not_check4 (const_tree __t, const char *__f, int __l, const char *__g,
    3605                 :            :                  enum tree_code __c1, enum tree_code __c2, enum tree_code __c3,
    3606                 :            :                  enum tree_code __c4)
    3607                 :            : {
    3608                 :   12789290 :   if (TREE_CODE (__t) == __c1
    3609                 :   12789290 :       || TREE_CODE (__t) == __c2
    3610                 :   12789290 :       || TREE_CODE (__t) == __c3
    3611                 :   12789290 :       || TREE_CODE (__t) == __c4)
    3612                 :          0 :     tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, 0);
    3613                 :   12789290 :   return __t;
    3614                 :            : }
    3615                 :            : 
    3616                 :            : inline const_tree
    3617                 :  751763150 : tree_check5 (const_tree __t, const char *__f, int __l, const char *__g,
    3618                 :            :              enum tree_code __c1, enum tree_code __c2, enum tree_code __c3,
    3619                 :            :              enum tree_code __c4, enum tree_code __c5)
    3620                 :            : {
    3621                 :  751763150 :   if (TREE_CODE (__t) != __c1
    3622                 :   94847030 :       && TREE_CODE (__t) != __c2
    3623                 :   90288920 :       && TREE_CODE (__t) != __c3
    3624                 :     141840 :       && TREE_CODE (__t) != __c4
    3625                 :          0 :       && TREE_CODE (__t) != __c5)
    3626                 :          0 :     tree_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, __c5, 0);
    3627                 :  751763150 :   return __t;
    3628                 :            : }
    3629                 :            : 
    3630                 :            : inline const_tree
    3631                 :            : tree_not_check5 (const_tree __t, const char *__f, int __l, const char *__g,
    3632                 :            :                  enum tree_code __c1, enum tree_code __c2, enum tree_code __c3,
    3633                 :            :                  enum tree_code __c4, enum tree_code __c5)
    3634                 :            : {
    3635                 :            :   if (TREE_CODE (__t) == __c1
    3636                 :            :       || TREE_CODE (__t) == __c2
    3637                 :            :       || TREE_CODE (__t) == __c3
    3638                 :            :       || TREE_CODE (__t) == __c4
    3639                 :            :       || TREE_CODE (__t) == __c5)
    3640                 :            :     tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, __c5, 0);
    3641                 :            :   return __t;
    3642                 :            : }
    3643                 :            : 
    3644                 :            : inline const_tree
    3645                 :87737808607 : contains_struct_check (const_tree __t, const enum tree_node_structure_enum __s,
    3646                 :            :                        const char *__f, int __l, const char *__g)
    3647                 :            : {
    3648                 :39880654316 :   if (tree_contains_struct[TREE_CODE (__t)][__s] != 1)
    3649                 :          0 :       tree_contains_struct_check_failed (__t, __s, __f, __l, __g);
    3650                 :46451636196 :   return __t;
    3651                 :            : }
    3652                 :            : 
    3653                 :            : inline const_tree
    3654                 :49911819253 : tree_class_check (const_tree __t, const enum tree_code_class __class,
    3655                 :            :                   const char *__f, int __l, const char *__g)
    3656                 :            : {
    3657                 :27397205090 :   if (TREE_CODE_CLASS (TREE_CODE (__t)) != __class)
    3658                 :          0 :     tree_class_check_failed (__t, __class, __f, __l, __g);
    3659                 :28043434256 :   return __t;
    3660                 :            : }
    3661                 :            : 
    3662                 :            : inline const_tree
    3663                 :            : tree_range_check (const_tree __t,
    3664                 :            :                   enum tree_code __code1, enum tree_code __code2,
    3665                 :            :                   const char *__f, int __l, const char *__g)
    3666                 :            : {
    3667                 :            :   if (TREE_CODE (__t) < __code1 || TREE_CODE (__t) > __code2)
    3668                 :            :     tree_range_check_failed (__t, __f, __l, __g, __code1, __code2);
    3669                 :            :   return __t;
    3670                 :            : }
    3671                 :            : 
    3672                 :            : inline const_tree
    3673                 :            : omp_clause_subcode_check (const_tree __t, enum omp_clause_code __code,
    3674                 :            :                           const char *__f, int __l, const char *__g)
    3675                 :            : {
    3676                 :            :   if (TREE_CODE (__t) != OMP_CLAUSE)
    3677                 :            :     tree_check_failed (__t, __f, __l, __g, OMP_CLAUSE, 0);
    3678                 :            :   if (__t->omp_clause.code != __code)
    3679                 :            :     omp_clause_check_failed (__t, __f, __l, __g, __code);
    3680                 :            :   return __t;
    3681                 :            : }
    3682                 :            : 
    3683                 :            : inline const_tree
    3684                 :            : omp_clause_range_check (const_tree __t,
    3685                 :            :                         enum omp_clause_code __code1,
    3686                 :            :                         enum omp_clause_code __code2,
    3687                 :            :                         const char *__f, int __l, const char *__g)
    3688                 :            : {
    3689                 :            :   if (TREE_CODE (__t) != OMP_CLAUSE)
    3690                 :            :     tree_check_failed (__t, __f, __l, __g, OMP_CLAUSE, 0);
    3691                 :            :   if ((int) __t->omp_clause.code < (int) __code1
    3692                 :            :       || (int) __t->omp_clause.code > (int) __code2)
    3693                 :            :     omp_clause_range_check_failed (__t, __f, __l, __g, __code1, __code2);
    3694                 :            :   return __t;
    3695                 :            : }
    3696                 :            : 
    3697                 :            : inline const_tree
    3698                 :12342028512 : expr_check (const_tree __t, const char *__f, int __l, const char *__g)
    3699                 :            : {
    3700                 :12342028512 :   char const __c = TREE_CODE_CLASS (TREE_CODE (__t));
    3701                 :12342028512 :   if (!IS_EXPR_CODE_CLASS (__c))
    3702                 :          0 :     tree_class_check_failed (__t, tcc_expression, __f, __l, __g);
    3703                 :12342028512 :   return __t;
    3704                 :            : }
    3705                 :            : 
    3706                 :            : inline const_tree
    3707                 : 3506101574 : non_type_check (const_tree __t, const char *__f, int __l, const char *__g)
    3708                 :            : {
    3709                 : 3414349674 :   if (TYPE_P (__t))
    3710                 :          0 :     tree_not_class_check_failed (__t, tcc_type, __f, __l, __g);
    3711                 : 3502287385 :   return __t;
    3712                 :            : }
    3713                 :            : 
    3714                 :            : # if GCC_VERSION >= 4006
    3715                 :            : #pragma GCC diagnostic push
    3716                 :            : #pragma GCC diagnostic ignored "-Wstrict-overflow"
    3717                 :            : #endif
    3718                 :            : 
    3719                 :            : inline const_tree *
    3720                 : 1961160016 : tree_vec_elt_check (const_tree __t, int __i,
    3721                 :            :                     const char *__f, int __l, const char *__g)
    3722                 :            : {
    3723                 : 1961160016 :   if (TREE_CODE (__t) != TREE_VEC)
    3724                 :          0 :     tree_check_failed (__t, __f, __l, __g, TREE_VEC, 0);
    3725                 : 1961160016 :   if (__i < 0 || __i >= __t->base.u.length)
    3726                 :          0 :     tree_vec_elt_check_failed (__i, __t->base.u.length, __f, __l, __g);
    3727                 : 1961160016 :   return CONST_CAST (const_tree *, &__t->vec.a[__i]);
    3728                 :            :   //return &__t->vec.a[__i];
    3729                 :            : }
    3730                 :            : 
    3731                 :            : # if GCC_VERSION >= 4006
    3732                 :            : #pragma GCC diagnostic pop
    3733                 :            : #endif
    3734                 :            : 
    3735                 :            : inline const_tree *
    3736                 :            : omp_clause_elt_check (const_tree __t, int __i,
    3737                 :            :                       const char *__f, int __l, const char *__g)
    3738                 :            : {
    3739                 :            :   if (TREE_CODE (__t) != OMP_CLAUSE)
    3740                 :            :     tree_check_failed (__t, __f, __l, __g, OMP_CLAUSE, 0);
    3741                 :            :   if (__i < 0 || __i >= omp_clause_num_ops [__t->omp_clause.code])
    3742                 :            :     omp_clause_operand_check_failed (__i, __t, __f, __l, __g);
    3743                 :            :   return CONST_CAST (const_tree *, &__t->omp_clause.ops[__i]);
    3744                 :            : }
    3745                 :            : 
    3746                 :            : inline const_tree
    3747                 :    1928790 : any_integral_type_check (const_tree __t, const char *__f, int __l,
    3748                 :            :                          const char *__g)
    3749                 :            : {
    3750                 :    1928790 :   if (!ANY_INTEGRAL_TYPE_P (__t))
    3751                 :          0 :     tree_check_failed (__t, __f, __l, __g, BOOLEAN_TYPE, ENUMERAL_TYPE,
    3752                 :            :                        INTEGER_TYPE, 0);
    3753                 :    1928790 :   return __t;
    3754                 :            : }
    3755                 :            : 
    3756                 :            : #endif
    3757                 :            : 
    3758                 :            : /* Compute the number of operands in an expression node NODE.  For
    3759                 :            :    tcc_vl_exp nodes like CALL_EXPRs, this is stored in the node itself,
    3760                 :            :    otherwise it is looked up from the node's code.  */
    3761                 :            : static inline int
    3762                 :92863765613 : tree_operand_length (const_tree node)
    3763                 :            : {
    3764                 :92863765613 :   if (VL_EXP_CLASS_P (node))
    3765                 : 2038339726 :     return VL_EXP_OPERAND_LENGTH (node);
    3766                 :            :   else
    3767                 :90825408663 :     return TREE_CODE_LENGTH (TREE_CODE (node));
    3768                 :            : }
    3769                 :            : 
    3770                 :            : #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
    3771                 :            : 
    3772                 :            : /* Special checks for TREE_OPERANDs.  */
    3773                 :            : inline tree *
    3774                 :70241756629 : tree_operand_check (tree __t, int __i,
    3775                 :            :                     const char *__f, int __l, const char *__g)
    3776                 :            : {
    3777                 :70241756629 :   const_tree __u = EXPR_CHECK (__t);
    3778                 :70241756629 :   if (__i < 0 || __i >= TREE_OPERAND_LENGTH (__u))
    3779                 :          0 :     tree_operand_check_failed (__i, __u, __f, __l, __g);
    3780                 :70241756629 :   return &CONST_CAST_TREE (__u)->exp.operands[__i];
    3781                 :            : }
    3782                 :            : 
    3783                 :            : inline tree *
    3784                 :   13108245 : tree_operand_check_code (tree __t, enum tree_code __code, int __i,
    3785                 :            :                          const char *__f, int __l, const char *__g)
    3786                 :            : {
    3787                 :   13108245 :   if (TREE_CODE (__t) != __code)
    3788                 :          0 :     tree_check_failed (__t, __f, __l, __g, __code, 0);
    3789                 :   13108245 :   if (__i < 0 || __i >= TREE_OPERAND_LENGTH (__t))
    3790                 :          0 :     tree_operand_check_failed (__i, __t, __f, __l, __g);
    3791                 :   13108245 :   return &__t->exp.operands[__i];
    3792                 :            : }
    3793                 :            : 
    3794                 :            : inline const_tree *
    3795                 :12342028505 : tree_operand_check (const_tree __t, int __i,
    3796                 :            :                     const char *__f, int __l, const char *__g)
    3797                 :            : {
    3798                 :12342028505 :   const_tree __u = EXPR_CHECK (__t);
    3799                 :12342028505 :   if (__i < 0 || __i >= TREE_OPERAND_LENGTH (__u))
    3800                 :          0 :     tree_operand_check_failed (__i, __u, __f, __l, __g);
    3801                 :12342028505 :   return CONST_CAST (const_tree *, &__u->exp.operands[__i]);
    3802                 :            : }
    3803                 :            : 
    3804                 :            : inline const_tree *
    3805                 :         32 : tree_operand_check_code (const_tree __t, enum tree_code __code, int __i,
    3806                 :            :                          const char *__f, int __l, const char *__g)
    3807                 :            : {
    3808                 :         32 :   if (TREE_CODE (__t) != __code)
    3809                 :          0 :     tree_check_failed (__t, __f, __l, __g, __code, 0);
    3810                 :         32 :   if (__i < 0 || __i >= TREE_OPERAND_LENGTH (__t))
    3811                 :          0 :     tree_operand_check_failed (__i, __t, __f, __l, __g);
    3812                 :         32 :   return CONST_CAST (const_tree *, &__t->exp.operands[__i]);
    3813                 :            : }
    3814                 :            : 
    3815                 :            : #endif
    3816                 :            : 
    3817                 :            : /* True iff an identifier matches a C string.  */
    3818                 :            : 
    3819                 :            : inline bool
    3820                 :    9559510 : id_equal (const_tree id, const char *str)
    3821                 :            : {
    3822                 :    9559510 :   return !strcmp (IDENTIFIER_POINTER (id), str);
    3823                 :            : }
    3824                 :            : 
    3825                 :            : inline bool
    3826                 :         39 : id_equal (const char *str, const_tree id)
    3827                 :            : {
    3828                 :         39 :   return !strcmp (str, IDENTIFIER_POINTER (id));
    3829                 :            : }
    3830                 :            : 
    3831                 :            : /* Return the number of elements in the VECTOR_TYPE given by NODE.  */
    3832                 :            : 
    3833                 :            : inline poly_uint64
    3834                 :  129457879 : TYPE_VECTOR_SUBPARTS (const_tree node)
    3835                 :            : {
    3836                 :  129457879 :   STATIC_ASSERT (NUM_POLY_INT_COEFFS <= 2);
    3837                 :  129457879 :   unsigned int precision = VECTOR_TYPE_CHECK (node)->type_common.precision;
    3838                 :  129457879 :   if (NUM_POLY_INT_COEFFS == 2)
    3839                 :            :     {
    3840                 :            :       /* See the corresponding code in SET_TYPE_VECTOR_SUBPARTS for a
    3841                 :            :          description of the encoding.  */
    3842                 :            :       poly_uint64 res = 0;
    3843                 :            :       res.coeffs[0] = HOST_WIDE_INT_1U << (precision & 0xff);
    3844                 :            :       if (precision & 0x100)
    3845                 :            :         res.coeffs[1] = HOST_WIDE_INT_1U << (precision & 0xff);
    3846                 :            :       return res;
    3847                 :            :     }
    3848                 :            :   else
    3849                 :  129457879 :     return HOST_WIDE_INT_1U << precision;
    3850                 :            : }
    3851                 :            : 
    3852                 :            : /* Set the number of elements in VECTOR_TYPE NODE to SUBPARTS, which must
    3853                 :            :    satisfy valid_vector_subparts_p.  */
    3854                 :            : 
    3855                 :            : inline void
    3856                 :   11096900 : SET_TYPE_VECTOR_SUBPARTS (tree node, poly_uint64 subparts)
    3857                 :            : {
    3858                 :   11096900 :   STATIC_ASSERT (NUM_POLY_INT_COEFFS <= 2);
    3859                 :   11096900 :   unsigned HOST_WIDE_INT coeff0 = subparts.coeffs[0];
    3860                 :   11096900 :   int index = exact_log2 (coeff0);
    3861                 :          0 :   gcc_assert (index >= 0);
    3862                 :   11096900 :   if (NUM_POLY_INT_COEFFS == 2)
    3863                 :            :     {
    3864                 :            :       /* We have two coefficients that are each in the range 1 << [0, 63],
    3865                 :            :          so supporting all combinations would require 6 bits per coefficient
    3866                 :            :          and 12 bits in total.  Since the precision field is only 10 bits
    3867                 :            :          in size, we need to be more restrictive than that.
    3868                 :            : 
    3869                 :            :          At present, coeff[1] is always either 0 (meaning that the number
    3870                 :            :          of units is constant) or equal to coeff[0] (meaning that the number
    3871                 :            :          of units is N + X * N for some target-dependent zero-based runtime
    3872                 :            :          parameter X).  We can therefore encode coeff[1] in a single bit.
    3873                 :            : 
    3874                 :            :          The most compact encoding would be to use mask 0x3f for coeff[0]
    3875                 :            :          and 0x40 for coeff[1], leaving 0x380 unused.  It's possible to
    3876                 :            :          get slightly more efficient code on some hosts if we instead
    3877                 :            :          treat the shift amount as an independent byte, so here we use
    3878                 :            :          0xff for coeff[0] and 0x100 for coeff[1].  */
    3879                 :            :       unsigned HOST_WIDE_INT coeff1 = subparts.coeffs[1];
    3880                 :            :       gcc_assert (coeff1 == 0 || coeff1 == coeff0);
    3881                 :            :       VECTOR_TYPE_CHECK (node)->type_common.precision
    3882                 :            :         = index + (coeff1 != 0 ? 0x100 : 0);
    3883                 :            :     }
    3884                 :            :   else
    3885                 :   11096900 :     VECTOR_TYPE_CHECK (node)->type_common.precision = index;
    3886                 :   11096900 : }
    3887                 :            : 
    3888                 :            : /* Return true if we can construct vector types with the given number
    3889                 :            :    of subparts.  */
    3890                 :            : 
    3891                 :            : static inline bool
    3892                 :       7479 : valid_vector_subparts_p (poly_uint64 subparts)
    3893                 :            : {
    3894                 :       7479 :   unsigned HOST_WIDE_INT coeff0 = subparts.coeffs[0];
    3895                 :       8082 :   if (!pow2p_hwi (coeff0))
    3896                 :          0 :     return false;
    3897                 :            :   if (NUM_POLY_INT_COEFFS == 2)
    3898                 :            :     {
    3899                 :            :       unsigned HOST_WIDE_INT coeff1 = subparts.coeffs[1];
    3900                 :            :       if (coeff1 != 0 && coeff1 != coeff0)
    3901                 :            :         return false;
    3902                 :            :     }
    3903                 :            :   return true;
    3904                 :            : }
    3905                 :            : 
    3906                 :            : /* Return the built-in function that DECL represents, given that it is known
    3907                 :            :    to be a FUNCTION_DECL with built-in class BUILT_IN_NORMAL.  */
    3908                 :            : inline built_in_function
    3909                 :  812908879 : DECL_FUNCTION_CODE (const_tree decl)
    3910                 :            : {
    3911                 :  812908879 :   const tree_function_decl &fndecl = FUNCTION_DECL_CHECK (decl)->function_decl;
    3912                 :  812908879 :   gcc_checking_assert (fndecl.built_in_class == BUILT_IN_NORMAL);
    3913                 :  812908879 :   return (built_in_function) fndecl.function_code;
    3914                 :            : }
    3915                 :            : 
    3916                 :            : /* Return the target-specific built-in function that DECL represents,
    3917                 :            :    given that it is known to be a FUNCTION_DECL with built-in class
    3918                 :            :    BUILT_IN_MD.  */
    3919                 :            : inline int
    3920                 :   39377089 : DECL_MD_FUNCTION_CODE (const_tree decl)
    3921                 :            : {
    3922                 :   39377089 :   const tree_function_decl &fndecl = FUNCTION_DECL_CHECK (decl)->function_decl;
    3923                 :   39377089 :   gcc_checking_assert (fndecl.built_in_class == BUILT_IN_MD);
    3924                 :   39377089 :   return fndecl.function_code;
    3925                 :            : }
    3926                 :            : 
    3927                 :            : /* Return the frontend-specific built-in function that DECL represents,
    3928                 :            :    given that it is known to be a FUNCTION_DECL with built-in class
    3929                 :            :    BUILT_IN_FRONTEND.  */
    3930                 :            : inline int
    3931                 :          0 : DECL_FE_FUNCTION_CODE (const_tree decl)
    3932                 :            : {
    3933                 :          0 :   const tree_function_decl &fndecl = FUNCTION_DECL_CHECK (decl)->function_decl;
    3934                 :          0 :   gcc_checking_assert (fndecl.built_in_class == BUILT_IN_FRONTEND);
    3935                 :          0 :   return fndecl.function_code;
    3936                 :            : }
    3937                 :            : 
    3938                 :            : /* Record that FUNCTION_DECL DECL represents built-in function FCODE of
    3939                 :            :    class FCLASS.  */
    3940                 :            : inline void
    3941                 :  442814821 : set_decl_built_in_function (tree decl, built_in_class fclass,
    3942                 :            :                             unsigned int fcode)
    3943                 :            : {
    3944                 :  442814821 :   tree_function_decl &fndecl = FUNCTION_DECL_CHECK (decl)->function_decl;
    3945                 :  442814821 :   fndecl.built_in_class = fclass;
    3946                 :  442814821 :   fndecl.function_code = fcode;
    3947                 :        128 : }
    3948                 :            : 
    3949                 :            : /* Record that FUNCTION_DECL NEWDECL represents the same built-in function
    3950                 :            :    as OLDDECL (or none, if OLDDECL doesn't represent a built-in function).  */
    3951                 :            : inline void
    3952                 :    2101599 : copy_decl_built_in_function (tree newdecl, const_tree olddecl)
    3953                 :            : {
    3954                 :    2101599 :   tree_function_decl &newfndecl = FUNCTION_DECL_CHECK (newdecl)->function_decl;
    3955                 :    2101599 :   const tree_function_decl &oldfndecl
    3956                 :    2101599 :     = FUNCTION_DECL_CHECK (olddecl)->function_decl;
    3957                 :    2101599 :   newfndecl.built_in_class = oldfndecl.built_in_class;
    3958                 :    2101599 :   newfndecl.function_code = oldfndecl.function_code;
    3959                 :    2101599 : }
    3960                 :            : 
    3961                 :            : /* In NON_LVALUE_EXPR and VIEW_CONVERT_EXPR, set when this node is merely a
    3962                 :            :    wrapper added to express a location_t on behalf of the node's child
    3963                 :            :    (e.g. by maybe_wrap_with_location).  */
    3964                 :            : 
    3965                 :            : #define EXPR_LOCATION_WRAPPER_P(NODE) \
    3966                 :            :   (TREE_CHECK2(NODE, NON_LVALUE_EXPR, VIEW_CONVERT_EXPR)->base.public_flag)
    3967                 :            : 
    3968                 :            : /* Test if EXP is merely a wrapper node, added to express a location_t
    3969                 :            :    on behalf of the node's child (e.g. by maybe_wrap_with_location).  */
    3970                 :            : 
    3971                 :            : inline bool
    3972                 :21604166824 : location_wrapper_p (const_tree exp)
    3973                 :            : {
    3974                 :            :   /* A wrapper node has code NON_LVALUE_EXPR or VIEW_CONVERT_EXPR, and
    3975                 :            :      the flag EXPR_LOCATION_WRAPPER_P is set.
    3976                 :            :      It normally has the same type as its operand, but it can have a
    3977                 :            :      different one if the type of the operand has changed (e.g. when
    3978                 :            :      merging duplicate decls).
    3979                 :            : 
    3980                 :            :      NON_LVALUE_EXPR is used for wrapping constants, apart from STRING_CST.
    3981                 :            :      VIEW_CONVERT_EXPR is used for wrapping non-constants and STRING_CST.  */
    3982                 :21604166824 :   if ((TREE_CODE (exp) == NON_LVALUE_EXPR
    3983                 :21604166824 :        || TREE_CODE (exp) == VIEW_CONVERT_EXPR)
    3984                 :22111141145 :       && EXPR_LOCATION_WRAPPER_P (exp))
    3985                 :  431892284 :     return true;
    3986                 :            :   return false;
    3987                 :            : }
    3988                 :            : 
    3989                 :            : /* Implementation of STRIP_ANY_LOCATION_WRAPPER.  */
    3990                 :            : 
    3991                 :            : inline tree
    3992                 :13173615423 : tree_strip_any_location_wrapper (tree exp)
    3993                 :            : {
    3994                 :13173615423 :   if (location_wrapper_p (exp))
    3995                 :  251267622 :     return TREE_OPERAND (exp, 0);
    3996                 :            :   else
    3997                 :            :     return exp;
    3998                 :            : }
    3999                 :            : 
    4000                 :            : #define error_mark_node                 global_trees[TI_ERROR_MARK]
    4001                 :            : 
    4002                 :            : #define intQI_type_node                 global_trees[TI_INTQI_TYPE]
    4003                 :            : #define intHI_type_node                 global_trees[TI_INTHI_TYPE]
    4004                 :            : #define intSI_type_node                 global_trees[TI_INTSI_TYPE]
    4005                 :            : #define intDI_type_node                 global_trees[TI_INTDI_TYPE]
    4006                 :            : #define intTI_type_node                 global_trees[TI_INTTI_TYPE]
    4007                 :            : 
    4008                 :            : #define unsigned_intQI_type_node        global_trees[TI_UINTQI_TYPE]
    4009                 :            : #define unsigned_intHI_type_node        global_trees[TI_UINTHI_TYPE]
    4010                 :            : #define unsigned_intSI_type_node        global_trees[TI_UINTSI_TYPE]
    4011                 :            : #define unsigned_intDI_type_node        global_trees[TI_UINTDI_TYPE]
    4012                 :            : #define unsigned_intTI_type_node        global_trees[TI_UINTTI_TYPE]
    4013                 :            : 
    4014                 :            : #define atomicQI_type_node      global_trees[TI_ATOMICQI_TYPE]
    4015                 :            : #define atomicHI_type_node      global_trees[TI_ATOMICHI_TYPE]
    4016                 :            : #define atomicSI_type_node      global_trees[TI_ATOMICSI_TYPE]
    4017                 :            : #define atomicDI_type_node      global_trees[TI_ATOMICDI_TYPE]
    4018                 :            : #define atomicTI_type_node      global_trees[TI_ATOMICTI_TYPE]
    4019                 :            : 
    4020                 :            : #define uint16_type_node                global_trees[TI_UINT16_TYPE]
    4021                 :            : #define uint32_type_node                global_trees[TI_UINT32_TYPE]
    4022                 :            : #define uint64_type_node                global_trees[TI_UINT64_TYPE]
    4023                 :            : 
    4024                 :            : #define void_node                       global_trees[TI_VOID]
    4025                 :            : 
    4026                 :            : #define integer_zero_node               global_trees[TI_INTEGER_ZERO]
    4027                 :            : #define integer_one_node                global_trees[TI_INTEGER_ONE]
    4028                 :            : #define integer_three_node              global_trees[TI_INTEGER_THREE]
    4029                 :            : #define integer_minus_one_node          global_trees[TI_INTEGER_MINUS_ONE]
    4030                 :            : #define size_zero_node                  global_trees[TI_SIZE_ZERO]
    4031                 :            : #define size_one_node                   global_trees[TI_SIZE_ONE]
    4032                 :            : #define bitsize_zero_node               global_trees[TI_BITSIZE_ZERO]
    4033                 :            : #define bitsize_one_node                global_trees[TI_BITSIZE_ONE]
    4034                 :            : #define bitsize_unit_node               global_trees[TI_BITSIZE_UNIT]
    4035                 :            : 
    4036                 :            : /* Base access nodes.  */
    4037                 :            : #define access_public_node              global_trees[TI_PUBLIC]
    4038                 :            : #define access_protected_node           global_trees[TI_PROTECTED]
    4039                 :            : #define access_private_node             global_trees[TI_PRIVATE]
    4040                 :            : 
    4041                 :            : #define null_pointer_node               global_trees[TI_NULL_POINTER]
    4042                 :            : 
    4043                 :            : #define float_type_node                 global_trees[TI_FLOAT_TYPE]
    4044                 :            : #define double_type_node                global_trees[TI_DOUBLE_TYPE]
    4045                 :            : #define long_double_type_node           global_trees[TI_LONG_DOUBLE_TYPE]
    4046                 :            : 
    4047                 :            : /* Nodes for particular _FloatN and _FloatNx types in sequence.  */
    4048                 :            : #define FLOATN_TYPE_NODE(IDX)           global_trees[TI_FLOATN_TYPE_FIRST + (IDX)]
    4049                 :            : #define FLOATN_NX_TYPE_NODE(IDX)        global_trees[TI_FLOATN_NX_TYPE_FIRST + (IDX)]
    4050                 :            : #define FLOATNX_TYPE_NODE(IDX)          global_trees[TI_FLOATNX_TYPE_FIRST + (IDX)]
    4051                 :            : 
    4052                 :            : /* Names for individual types (code should normally iterate over all
    4053                 :            :    such types; these are only for back-end use, or in contexts such as
    4054                 :            :    *.def where iteration is not possible).  */
    4055                 :            : #define float16_type_node               global_trees[TI_FLOAT16_TYPE]
    4056                 :            : #define float32_type_node               global_trees[TI_FLOAT32_TYPE]
    4057                 :            : #define float64_type_node               global_trees[TI_FLOAT64_TYPE]
    4058                 :            : #define float128_type_node              global_trees[TI_FLOAT128_TYPE]
    4059                 :            : #define float32x_type_node              global_trees[TI_FLOAT32X_TYPE]
    4060                 :            : #define float64x_type_node              global_trees[TI_FLOAT64X_TYPE]
    4061                 :            : #define float128x_type_node             global_trees[TI_FLOAT128X_TYPE]
    4062                 :            : 
    4063                 :            : #define float_ptr_type_node             global_trees[TI_FLOAT_PTR_TYPE]
    4064                 :            : #define double_ptr_type_node            global_trees[TI_DOUBLE_PTR_TYPE]
    4065                 :            : #define long_double_ptr_type_node       global_trees[TI_LONG_DOUBLE_PTR_TYPE]
    4066                 :            : #define integer_ptr_type_node           global_trees[TI_INTEGER_PTR_TYPE]
    4067                 :            : 
    4068                 :            : #define complex_integer_type_node       global_trees[TI_COMPLEX_INTEGER_TYPE]
    4069                 :            : #define complex_float_type_node         global_trees[TI_COMPLEX_FLOAT_TYPE]
    4070                 :            : #define complex_double_type_node        global_trees[TI_COMPLEX_DOUBLE_TYPE]
    4071                 :            : #define complex_long_double_type_node   global_trees[TI_COMPLEX_LONG_DOUBLE_TYPE]
    4072                 :            : 
    4073                 :            : #define COMPLEX_FLOATN_NX_TYPE_NODE(IDX)        global_trees[TI_COMPLEX_FLOATN_NX_TYPE_FIRST + (IDX)]
    4074                 :            : 
    4075                 :            : #define void_type_node                  global_trees[TI_VOID_TYPE]
    4076                 :            : /* The C type `void *'.  */
    4077                 :            : #define ptr_type_node                   global_trees[TI_PTR_TYPE]
    4078                 :            : /* The C type `const void *'.  */
    4079                 :            : #define const_ptr_type_node             global_trees[TI_CONST_PTR_TYPE]
    4080                 :            : /* The C type `size_t'.  */
    4081                 :            : #define size_type_node                  global_trees[TI_SIZE_TYPE]
    4082                 :            : #define pid_type_node                   global_trees[TI_PID_TYPE]
    4083                 :            : #define ptrdiff_type_node               global_trees[TI_PTRDIFF_TYPE]
    4084                 :            : #define va_list_type_node               global_trees[TI_VA_LIST_TYPE]
    4085                 :            : #define va_list_gpr_counter_field       global_trees[TI_VA_LIST_GPR_COUNTER_FIELD]
    4086                 :            : #define va_list_fpr_counter_field       global_trees[TI_VA_LIST_FPR_COUNTER_FIELD]
    4087                 :            : /* The C type `FILE *'.  */
    4088                 :            : #define fileptr_type_node               global_trees[TI_FILEPTR_TYPE]
    4089                 :            : /* The C type `const struct tm *'.  */
    4090                 :            : #define const_tm_ptr_type_node          global_trees[TI_CONST_TM_PTR_TYPE]
    4091                 :            : /* The C type `fenv_t *'.  */
    4092                 :            : #define fenv_t_ptr_type_node            global_trees[TI_FENV_T_PTR_TYPE]
    4093                 :            : #define const_fenv_t_ptr_type_node      global_trees[TI_CONST_FENV_T_PTR_TYPE]
    4094                 :            : /* The C type `fexcept_t *'.  */
    4095                 :            : #define fexcept_t_ptr_type_node         global_trees[TI_FEXCEPT_T_PTR_TYPE]
    4096                 :            : #define const_fexcept_t_ptr_type_node   global_trees[TI_CONST_FEXCEPT_T_PTR_TYPE]
    4097                 :            : #define pointer_sized_int_node          global_trees[TI_POINTER_SIZED_TYPE]
    4098                 :            : 
    4099                 :            : #define boolean_type_node               global_trees[TI_BOOLEAN_TYPE]
    4100                 :            : #define boolean_false_node              global_trees[TI_BOOLEAN_FALSE]
    4101                 :            : #define boolean_true_node               global_trees[TI_BOOLEAN_TRUE]
    4102                 :            : 
    4103                 :            : /* The decimal floating point types. */
    4104                 :            : #define dfloat32_type_node              global_trees[TI_DFLOAT32_TYPE]
    4105                 :            : #define dfloat64_type_node              global_trees[TI_DFLOAT64_TYPE]
    4106                 :            : #define dfloat128_type_node             global_trees[TI_DFLOAT128_TYPE]
    4107                 :            : 
    4108                 :            : /* The fixed-point types.  */
    4109                 :            : #define sat_short_fract_type_node       global_trees[TI_SAT_SFRACT_TYPE]
    4110                 :            : #define sat_fract_type_node             global_trees[TI_SAT_FRACT_TYPE]
    4111                 :            : #define sat_long_fract_type_node        global_trees[TI_SAT_LFRACT_TYPE]
    4112                 :            : #define sat_long_long_fract_type_node   global_trees[TI_SAT_LLFRACT_TYPE]
    4113                 :            : #define sat_unsigned_short_fract_type_node \
    4114                 :            :                                         global_trees[TI_SAT_USFRACT_TYPE]
    4115                 :            : #define sat_unsigned_fract_type_node    global_trees[TI_SAT_UFRACT_TYPE]
    4116                 :            : #define sat_unsigned_long_fract_type_node \
    4117                 :            :                                         global_trees[TI_SAT_ULFRACT_TYPE]
    4118                 :            : #define sat_unsigned_long_long_fract_type_node \
    4119                 :            :                                         global_trees[TI_SAT_ULLFRACT_TYPE]
    4120                 :            : #define short_fract_type_node           global_trees[TI_SFRACT_TYPE]
    4121                 :            : #define fract_type_node                 global_trees[TI_FRACT_TYPE]
    4122                 :            : #define long_fract_type_node            global_trees[TI_LFRACT_TYPE]
    4123                 :            : #define long_long_fract_type_node       global_trees[TI_LLFRACT_TYPE]
    4124                 :            : #define unsigned_short_fract_type_node  global_trees[TI_USFRACT_TYPE]
    4125                 :            : #define unsigned_fract_type_node        global_trees[TI_UFRACT_TYPE]
    4126                 :            : #define unsigned_long_fract_type_node   global_trees[TI_ULFRACT_TYPE]
    4127                 :            : #define unsigned_long_long_fract_type_node \
    4128                 :            :                                         global_trees[TI_ULLFRACT_TYPE]
    4129                 :            : #define sat_short_accum_type_node       global_trees[TI_SAT_SACCUM_TYPE]
    4130                 :            : #define sat_accum_type_node             global_trees[TI_SAT_ACCUM_TYPE]
    4131                 :            : #define sat_long_accum_type_node        global_trees[TI_SAT_LACCUM_TYPE]
    4132                 :            : #define sat_long_long_accum_type_node   global_trees[TI_SAT_LLACCUM_TYPE]
    4133                 :            : #define sat_unsigned_short_accum_type_node \
    4134                 :            :                                         global_trees[TI_SAT_USACCUM_TYPE]
    4135                 :            : #define sat_unsigned_accum_type_node    global_trees[TI_SAT_UACCUM_TYPE]
    4136                 :            : #define sat_unsigned_long_accum_type_node \
    4137                 :            :                                         global_trees[TI_SAT_ULACCUM_TYPE]
    4138                 :            : #define sat_unsigned_long_long_accum_type_node \
    4139                 :            :                                         global_trees[TI_SAT_ULLACCUM_TYPE]
    4140                 :            : #define short_accum_type_node           global_trees[TI_SACCUM_TYPE]
    4141                 :            : #define accum_type_node                 global_trees[TI_ACCUM_TYPE]
    4142                 :            : #define long_accum_type_node            global_trees[TI_LACCUM_TYPE]
    4143                 :            : #define long_long_accum_type_node       global_trees[TI_LLACCUM_TYPE]
    4144                 :            : #define unsigned_short_accum_type_node  global_trees[TI_USACCUM_TYPE]
    4145                 :            : #define unsigned_accum_type_node        global_trees[TI_UACCUM_TYPE]
    4146                 :            : #define unsigned_long_accum_type_node   global_trees[TI_ULACCUM_TYPE]
    4147                 :            : #define unsigned_long_long_accum_type_node \
    4148                 :            :                                         global_trees[TI_ULLACCUM_TYPE]
    4149                 :            : #define qq_type_node                    global_trees[TI_QQ_TYPE]
    4150                 :            : #define hq_type_node                    global_trees[TI_HQ_TYPE]
    4151                 :            : #define sq_type_node                    global_trees[TI_SQ_TYPE]
    4152                 :            : #define dq_type_node                    global_trees[TI_DQ_TYPE]
    4153                 :            : #define tq_type_node                    global_trees[TI_TQ_TYPE]
    4154                 :            : #define uqq_type_node                   global_trees[TI_UQQ_TYPE]
    4155                 :            : #define uhq_type_node                   global_trees[TI_UHQ_TYPE]
    4156                 :            : #define usq_type_node                   global_trees[TI_USQ_TYPE]
    4157                 :            : #define udq_type_node                   global_trees[TI_UDQ_TYPE]
    4158                 :            : #define utq_type_node                   global_trees[TI_UTQ_TYPE]
    4159                 :            : #define sat_qq_type_node                global_trees[TI_SAT_QQ_TYPE]
    4160                 :            : #define sat_hq_type_node                global_trees[TI_SAT_HQ_TYPE]
    4161                 :            : #define sat_sq_type_node                global_trees[TI_SAT_SQ_TYPE]
    4162                 :            : #define sat_dq_type_node                global_trees[TI_SAT_DQ_TYPE]
    4163                 :            : #define sat_tq_type_node                global_trees[TI_SAT_TQ_TYPE]
    4164                 :            : #define sat_uqq_type_node               global_trees[TI_SAT_UQQ_TYPE]
    4165                 :            : #define sat_uhq_type_node               global_trees[TI_SAT_UHQ_TYPE]
    4166                 :            : #define sat_usq_type_node               global_trees[TI_SAT_USQ_TYPE]
    4167                 :            : #define sat_udq_type_node               global_trees[TI_SAT_UDQ_TYPE]
    4168                 :            : #define sat_utq_type_node               global_trees[TI_SAT_UTQ_TYPE]
    4169                 :            : #define ha_type_node                    global_trees[TI_HA_TYPE]
    4170                 :            : #define sa_type_node                    global_trees[TI_SA_TYPE]
    4171                 :            : #define da_type_node                    global_trees[TI_DA_TYPE]
    4172                 :            : #define ta_type_node                    global_trees[TI_TA_TYPE]
    4173                 :            : #define uha_type_node                   global_trees[TI_UHA_TYPE]
    4174                 :            : #define usa_type_node                   global_trees[TI_USA_TYPE]
    4175                 :            : #define uda_type_node                   global_trees[TI_UDA_TYPE]
    4176                 :            : #define uta_type_node                   global_trees[TI_UTA_TYPE]
    4177                 :            : #define sat_ha_type_node                global_trees[TI_SAT_HA_TYPE]
    4178                 :            : #define sat_sa_type_node                global_trees[TI_SAT_SA_TYPE]
    4179                 :            : #define sat_da_type_node                global_trees[TI_SAT_DA_TYPE]
    4180                 :            : #define sat_ta_type_node                global_trees[TI_SAT_TA_TYPE]
    4181                 :            : #define sat_uha_type_node               global_trees[TI_SAT_UHA_TYPE]
    4182                 :            : #define sat_usa_type_node               global_trees[TI_SAT_USA_TYPE]
    4183                 :            : #define sat_uda_type_node               global_trees[TI_SAT_UDA_TYPE]
    4184                 :            : #define sat_uta_type_node               global_trees[TI_SAT_UTA_TYPE]
    4185                 :            : 
    4186                 :            : /* The node that should be placed at the end of a parameter list to
    4187                 :            :    indicate that the function does not take a variable number of
    4188                 :            :    arguments.  The TREE_VALUE will be void_type_node and there will be
    4189                 :            :    no TREE_CHAIN.  Language-independent code should not assume
    4190                 :            :    anything else about this node.  */
    4191                 :            : #define void_list_node                  global_trees[TI_VOID_LIST_NODE]
    4192                 :            : 
    4193                 :            : #define main_identifier_node            global_trees[TI_MAIN_IDENTIFIER]
    4194                 :            : #define MAIN_NAME_P(NODE) \
    4195                 :            :   (IDENTIFIER_NODE_CHECK (NODE) == main_identifier_node)
    4196                 :            : 
    4197                 :            : /* Optimization options (OPTIMIZATION_NODE) to use for default and current
    4198                 :            :    functions.  */
    4199                 :            : #define optimization_default_node       global_trees[TI_OPTIMIZATION_DEFAULT]
    4200                 :            : #define optimization_current_node       global_trees[TI_OPTIMIZATION_CURRENT]
    4201                 :            : 
    4202                 :            : /* Default/current target options (TARGET_OPTION_NODE).  */
    4203                 :            : #define target_option_default_node      global_trees[TI_TARGET_OPTION_DEFAULT]
    4204                 :            : #define target_option_current_node      global_trees[TI_TARGET_OPTION_CURRENT]
    4205                 :            : 
    4206                 :            : /* Default tree list option(), optimize() pragmas to be linked into the
    4207                 :            :    attribute list.  */
    4208                 :            : #define current_target_pragma           global_trees[TI_CURRENT_TARGET_PRAGMA]
    4209                 :            : #define current_optimize_pragma         global_trees[TI_CURRENT_OPTIMIZE_PRAGMA]
    4210                 :            : 
    4211                 :            : /* SCEV analyzer global shared trees.  */
    4212                 :            : #define chrec_not_analyzed_yet          NULL_TREE
    4213                 :            : #define chrec_dont_know                 global_trees[TI_CHREC_DONT_KNOW]
    4214                 :            : #define chrec_known                     global_trees[TI_CHREC_KNOWN]
    4215                 :            : 
    4216                 :            : #define char_type_node                  integer_types[itk_char]
    4217                 :            : #define signed_char_type_node           integer_types[itk_signed_char]
    4218                 :            : #define unsigned_char_type_node         integer_types[itk_unsigned_char]
    4219                 :            : #define short_integer_type_node         integer_types[itk_short]
    4220                 :            : #define short_unsigned_type_node        integer_types[itk_unsigned_short]
    4221                 :            : #define integer_type_node               integer_types[itk_int]
    4222                 :            : #define unsigned_type_node              integer_types[itk_unsigned_int]
    4223                 :            : #define long_integer_type_node          integer_types[itk_long]
    4224                 :            : #define long_unsigned_type_node         integer_types[itk_unsigned_long]
    4225                 :            : #define long_long_integer_type_node     integer_types[itk_long_long]
    4226                 :            : #define long_long_unsigned_type_node    integer_types[itk_unsigned_long_long]
    4227                 :            : 
    4228                 :            : /* True if NODE is an erroneous expression.  */
    4229                 :            : 
    4230                 :            : #define error_operand_p(NODE)                                   \
    4231                 :            :   ((NODE) == error_mark_node                                    \
    4232                 :            :    || ((NODE) && TREE_TYPE ((NODE)) == error_mark_node))
    4233                 :            : 
    4234                 :            : /* Return the number of elements encoded directly in a VECTOR_CST.  */
    4235                 :            : 
    4236                 :            : inline unsigned int
    4237                 :    6004906 : vector_cst_encoded_nelts (const_tree t)
    4238                 :            : {
    4239                 :    6004906 :   return VECTOR_CST_NPATTERNS (t) * VECTOR_CST_NELTS_PER_PATTERN (t);
    4240                 :            : }
    4241                 :            : 
    4242                 :            : extern tree decl_assembler_name (tree);
    4243                 :            : extern void overwrite_decl_assembler_name (tree decl, tree name);
    4244                 :            : extern tree decl_comdat_group (const_tree);
    4245                 :            : extern tree decl_comdat_group_id (const_tree);
    4246                 :            : extern const char *decl_section_name (const_tree);
    4247                 :            : extern void set_decl_section_name (tree, const char *);
    4248                 :            : extern enum tls_model decl_tls_model (const_tree);
    4249                 :            : extern void set_decl_tls_model (tree, enum tls_model);
    4250                 :            : 
    4251                 :            : /* Compute the number of bytes occupied by 'node'.  This routine only
    4252                 :            :    looks at TREE_CODE and, if the code is TREE_VEC, TREE_VEC_LENGTH.  */
    4253                 :            : 
    4254                 :            : extern size_t tree_size (const_tree);
    4255                 :            : 
    4256                 :            : /* Compute the number of bytes occupied by a tree with code CODE.
    4257                 :            :    This function cannot be used for TREE_VEC or INTEGER_CST nodes,
    4258                 :            :    which are of variable length.  */
    4259                 :            : extern size_t tree_code_size (enum tree_code);
    4260                 :            : 
    4261                 :            : /* Allocate and return a new UID from the DECL_UID namespace.  */
    4262                 :            : extern int allocate_decl_uid (void);
    4263                 :            : 
    4264                 :            : /* Lowest level primitive for allocating a node.
    4265                 :            :    The TREE_CODE is the only argument.  Contents are initialized
    4266                 :            :    to zero except for a few of the common fields.  */
    4267                 :            : 
    4268                 :            : extern tree make_node (enum tree_code CXX_MEM_STAT_INFO);
    4269                 :            : 
    4270                 :            : /* Free tree node.  */
    4271                 :            : 
    4272                 :            : extern void free_node (tree);
    4273                 :            : 
    4274                 :            : /* Make a copy of a node, with all the same contents.  */
    4275                 :            : 
    4276                 :            : extern tree copy_node (tree CXX_MEM_STAT_INFO);
    4277                 :            : 
    4278                 :            : /* Make a copy of a chain of TREE_LIST nodes.  */
    4279                 :            : 
    4280                 :            : extern tree copy_list (tree);
    4281                 :            : 
    4282                 :            : /* Make a CASE_LABEL_EXPR.  */
    4283                 :            : 
    4284                 :            : extern tree build_case_label (tree, tree, tree);
    4285                 :            : 
    4286                 :            : /* Make a BINFO.  */
    4287                 :            : extern tree make_tree_binfo (unsigned CXX_MEM_STAT_INFO);
    4288                 :            : 
    4289                 :            : /* Make an INTEGER_CST.  */
    4290                 :            : 
    4291                 :            : extern tree make_int_cst (int, int CXX_MEM_STAT_INFO);
    4292                 :            : 
    4293                 :            : /* Make a TREE_VEC.  */
    4294                 :            : 
    4295                 :            : extern tree make_tree_vec (int CXX_MEM_STAT_INFO);
    4296                 :            : 
    4297                 :            : /* Grow a TREE_VEC.  */
    4298                 :            : 
    4299                 :            : extern tree grow_tree_vec (tree v, int CXX_MEM_STAT_INFO);
    4300                 :            : 
    4301                 :            : /* Construct various types of nodes.  */
    4302                 :            : 
    4303                 :            : extern tree build_nt (enum tree_code, ...);
    4304                 :            : extern tree build_nt_call_vec (tree, vec<tree, va_gc> *);
    4305                 :            : 
    4306                 :            : extern tree build0 (enum tree_code, tree CXX_MEM_STAT_INFO);
    4307                 :            : extern tree build1 (enum tree_code, tree, tree CXX_MEM_STAT_INFO);
    4308                 :            : extern tree build2 (enum tree_code, tree, tree, tree CXX_MEM_STAT_INFO);
    4309                 :            : extern tree build3 (enum tree_code, tree, tree, tree, tree CXX_MEM_STAT_INFO);
    4310                 :            : extern tree build4 (enum tree_code, tree, tree, tree, tree,
    4311                 :            :                     tree CXX_MEM_STAT_INFO);
    4312                 :            : extern tree build5 (enum tree_code, tree, tree, tree, tree, tree,
    4313                 :            :                     tree CXX_MEM_STAT_INFO);
    4314                 :            : 
    4315                 :            : /* _loc versions of build[1-5].  */
    4316                 :            : 
    4317                 :            : static inline tree
    4318                 :  369168287 : build1_loc (location_t loc, enum tree_code code, tree type,
    4319                 :            :             tree arg1 CXX_MEM_STAT_INFO)
    4320                 :            : {
    4321                 :  369183263 :   tree t = build1 (code, type, arg1 PASS_MEM_STAT);
    4322                 :  369168287 :   if (CAN_HAVE_LOCATION_P (t))
    4323                 :  369168287 :     SET_EXPR_LOCATION (t, loc);
    4324                 :   65509618 :   return t;
    4325                 :            : }
    4326                 :            : 
    4327                 :            : static inline tree
    4328                 :  148073059 : build2_loc (location_t loc, enum tree_code code, tree type, tree arg0,
    4329                 :            :             tree arg1 CXX_MEM_STAT_INFO)
    4330                 :            : {
    4331                 :  137689579 :   tree t = build2 (code, type, arg0, arg1 PASS_MEM_STAT);
    4332                 :  148073059 :   if (CAN_HAVE_LOCATION_P (t))
    4333                 :  148073059 :     SET_EXPR_LOCATION (t, loc);
    4334                 :   39459658 :   return t;
    4335                 :            : }
    4336                 :            : 
    4337                 :            : static inline tree
    4338                 :   24675469 : build3_loc (location_t loc, enum tree_code code, tree type, tree arg0,
    4339                 :            :             tree arg1, tree arg2 CXX_MEM_STAT_INFO)
    4340                 :            : {
    4341                 :   25216707 :   tree t = build3 (code, type, arg0, arg1, arg2 PASS_MEM_STAT);
    4342                 :   24675469 :   if (CAN_HAVE_LOCATION_P (t))
    4343                 :   24675469 :     SET_EXPR_LOCATION (t, loc);
    4344                 :   11050991 :   return t;
    4345                 :            : }
    4346                 :            : 
    4347                 :            : static inline tree
    4348                 :    1505596 : build4_loc (location_t loc, enum tree_code code, tree type, tree arg0,
    4349                 :            :             tree arg1, tree arg2, tree arg3 CXX_MEM_STAT_INFO)
    4350                 :            : {
    4351                 :    1505596 :   tree t = build4 (code, type, arg0, arg1, arg2, arg3 PASS_MEM_STAT);
    4352                 :    1505596 :   if (CAN_HAVE_LOCATION_P (t))
    4353                 :    1505596 :     SET_EXPR_LOCATION (t, loc);
    4354                 :     709251 :   return t;
    4355                 :            : }
    4356                 :            : 
    4357                 :            : static inline tree
    4358                 :       4559 : build5_loc (location_t loc, enum tree_code code, tree type, tree arg0,
    4359                 :            :             tree arg1, tree arg2, tree arg3, tree arg4 CXX_MEM_STAT_INFO)
    4360                 :            : {
    4361                 :       4559 :   tree t = build5 (code, type, arg0, arg1, arg2, arg3,
    4362                 :            :                         arg4 PASS_MEM_STAT);
    4363                 :       4559 :   if (CAN_HAVE_LOCATION_P (t))
    4364                 :       4559 :     SET_EXPR_LOCATION (t, loc);
    4365                 :       4469 :   return t;
    4366                 :            : }
    4367                 :            : 
    4368                 :            : /* Constructs double_int from tree CST.  */
    4369                 :            : 
    4370                 :            : extern tree double_int_to_tree (tree, double_int);
    4371                 :            : 
    4372                 :            : extern tree wide_int_to_tree (tree type, const poly_wide_int_ref &cst);
    4373                 :            : extern tree force_fit_type (tree, const poly_wide_int_ref &, int, bool);
    4374                 :            : 
    4375                 :            : /* Create an INT_CST node with a CST value zero extended.  */
    4376                 :            : 
    4377                 :            : /* static inline */
    4378                 :            : extern tree build_int_cst (tree, poly_int64);
    4379                 :            : extern tree build_int_cstu (tree type, poly_uint64);
    4380                 :            : extern tree build_int_cst_type (tree, poly_int64);
    4381                 :            : extern tree make_vector (unsigned, unsigned CXX_MEM_STAT_INFO);
    4382                 :            : extern tree build_vector_from_ctor (tree, vec<constructor_elt, va_gc> *);
    4383                 :            : extern tree build_vector_from_val (tree, tree);
    4384                 :            : extern tree build_uniform_cst (tree, tree);
    4385                 :            : extern tree build_vec_series (tree, tree, tree);
    4386                 :            : extern tree build_index_vector (tree, poly_uint64, poly_uint64);
    4387                 :            : extern tree build_vector_a_then_b (tree, unsigned int, tree, tree);
    4388                 :            : extern void recompute_constructor_flags (tree);
    4389                 :            : extern void verify_constructor_flags (tree);
    4390                 :            : extern tree build_constructor (tree, vec<constructor_elt, va_gc> * CXX_MEM_STAT_INFO);
    4391                 :            : extern tree build_constructor_single (tree, tree, tree);
    4392                 :            : extern tree build_constructor_from_list (tree, tree);
    4393                 :            : extern tree build_constructor_va (tree, int, ...);
    4394                 :            : extern tree build_clobber (tree);
    4395                 :            : extern tree build_real_from_int_cst (tree, const_tree);
    4396                 :            : extern tree build_complex (tree, tree, tree);
    4397                 :            : extern tree build_complex_inf (tree, bool);
    4398                 :            : extern tree build_each_one_cst (tree);
    4399                 :            : extern tree build_one_cst (tree);
    4400                 :            : extern tree build_minus_one_cst (tree);
    4401                 :            : extern tree build_all_ones_cst (tree);
    4402                 :            : extern tree build_zero_cst (tree);
    4403                 :            : extern tree build_string (int, const char *);
    4404                 :            : extern tree build_poly_int_cst (tree, const poly_wide_int_ref &);
    4405                 :            : extern tree build_tree_list (tree, tree CXX_MEM_STAT_INFO);
    4406                 :            : extern tree build_tree_list_vec (const vec<tree, va_gc> * CXX_MEM_STAT_INFO);
    4407                 :            : extern tree build_decl (location_t, enum tree_code,
    4408                 :            :                         tree, tree CXX_MEM_STAT_INFO);
    4409                 :            : extern tree build_fn_decl (const char *, tree);
    4410                 :            : extern tree build_translation_unit_decl (tree);
    4411                 :            : extern tree build_block (tree, tree, tree, tree);
    4412                 :            : extern tree build_empty_stmt (location_t);
    4413                 :            : extern tree build_omp_clause (location_t, enum omp_clause_code);
    4414                 :            : 
    4415                 :            : extern tree build_vl_exp (enum tree_code, int CXX_MEM_STAT_INFO);
    4416                 :            : 
    4417                 :            : extern tree build_call_nary (tree, tree, int, ...);
    4418                 :            : extern tree build_call_valist (tree, tree, int, va_list);
    4419                 :            : #define build_call_array(T1,T2,N,T3)\
    4420                 :            :    build_call_array_loc (UNKNOWN_LOCATION, T1, T2, N, T3)
    4421                 :            : extern tree build_call_array_loc (location_t, tree, tree, int, const tree *);
    4422                 :            : extern tree build_call_vec (tree, tree, vec<tree, va_gc> *);
    4423                 :            : extern tree build_call_expr_loc_array (location_t, tree, int, tree *);
    4424                 :            : extern tree build_call_expr_loc_vec (location_t, tree, vec<tree, va_gc> *);
    4425                 :            : extern tree build_call_expr_loc (location_t, tree, int, ...);
    4426                 :            : extern tree build_call_expr (tree, int, ...);
    4427                 :            : extern tree build_call_expr_internal_loc (location_t, enum internal_fn,
    4428                 :            :                                           tree, int, ...);
    4429                 :            : extern tree build_call_expr_internal_loc_array (location_t, enum internal_fn,
    4430                 :            :                                                 tree, int, const tree *);
    4431                 :            : extern tree maybe_build_call_expr_loc (location_t, combined_fn, tree,
    4432                 :            :                                        int, ...);
    4433                 :            : extern tree build_alloca_call_expr (tree, unsigned int, HOST_WIDE_INT);
    4434                 :            : extern tree build_string_literal (int, const char *, tree = char_type_node,
    4435                 :            :                                   unsigned HOST_WIDE_INT = HOST_WIDE_INT_M1U);
    4436                 :            : 
    4437                 :            : /* Construct various nodes representing data types.  */
    4438                 :            : 
    4439                 :            : extern tree signed_or_unsigned_type_for (int, tree);
    4440                 :            : extern tree signed_type_for (tree);
    4441                 :            : extern tree unsigned_type_for (tree);
    4442                 :            : extern tree truth_type_for (tree);
    4443                 :            : extern tree build_pointer_type_for_mode (tree, machine_mode, bool);
    4444                 :            : extern tree build_pointer_type (tree);
    4445                 :            : extern tree build_reference_type_for_mode (tree, machine_mode, bool);
    4446                 :            : extern tree build_reference_type (tree);
    4447                 :            : extern tree build_vector_type_for_mode (tree, machine_mode);
    4448                 :            : extern tree build_vector_type (tree, poly_int64);
    4449                 :            : extern tree build_truth_vector_type_for_mode (poly_uint64, machine_mode);
    4450                 :            : extern tree build_opaque_vector_type (tree, poly_int64);
    4451                 :            : extern tree build_index_type (tree);
    4452                 :            : extern tree build_array_type (tree, tree, bool = false);
    4453                 :            : extern tree build_nonshared_array_type (tree, tree);
    4454                 :            : extern tree build_array_type_nelts (tree, poly_uint64);
    4455                 :            : extern tree build_function_type (tree, tree);
    4456                 :            : extern tree build_function_type_list (tree, ...);
    4457                 :            : extern tree build_varargs_function_type_list (tree, ...);
    4458                 :            : extern tree build_function_type_array (tree, int, tree *);
    4459                 :            : extern tree build_varargs_function_type_array (tree, int, tree *);
    4460                 :            : #define build_function_type_vec(RET, V) \
    4461                 :            :   build_function_type_array (RET, vec_safe_length (V), vec_safe_address (V))
    4462                 :            : #define build_varargs_function_type_vec(RET, V) \
    4463                 :            :   build_varargs_function_type_array (RET, vec_safe_length (V), \
    4464                 :            :                                      vec_safe_address (V))
    4465                 :            : extern tree build_method_type_directly (tree, tree, tree);
    4466                 :            : extern tree build_method_type (tree, tree);
    4467                 :            : extern tree build_offset_type (tree, tree);
    4468                 :            : extern tree build_complex_type (tree, bool named = false);
    4469                 :            : extern tree array_type_nelts (const_tree);
    4470                 :            : 
    4471                 :            : extern tree value_member (tree, tree);
    4472                 :            : extern tree purpose_member (const_tree, tree);
    4473                 :            : extern bool vec_member (const_tree, vec<tree, va_gc> *);
    4474                 :            : extern tree chain_index (int, tree);
    4475                 :            : 
    4476                 :            : /* Arguments may be null.  */
    4477                 :            : extern int tree_int_cst_equal (const_tree, const_tree);
    4478                 :            : 
    4479                 :            : /* The following predicates are safe to call with a null argument.  */
    4480                 :            : extern bool tree_fits_shwi_p (const_tree) ATTRIBUTE_PURE;
    4481                 :            : extern bool tree_fits_poly_int64_p (const_tree) ATTRIBUTE_PURE;
    4482                 :            : extern bool tree_fits_uhwi_p (const_tree) ATTRIBUTE_PURE;
    4483                 :            : extern bool tree_fits_poly_uint64_p (const_tree) ATTRIBUTE_PURE;
    4484                 :            : 
    4485                 :            : extern HOST_WIDE_INT tree_to_shwi (const_tree)
    4486                 :            :   ATTRIBUTE_NONNULL (1) ATTRIBUTE_PURE;
    4487                 :            : extern poly_int64 tree_to_poly_int64 (const_tree)
    4488                 :            :   ATTRIBUTE_NONNULL (1) ATTRIBUTE_PURE;
    4489                 :            : extern unsigned HOST_WIDE_INT tree_to_uhwi (const_tree)
    4490                 :            :   ATTRIBUTE_NONNULL (1) ATTRIBUTE_PURE;
    4491                 :            : extern poly_uint64 tree_to_poly_uint64 (const_tree)
    4492                 :            :   ATTRIBUTE_NONNULL (1) ATTRIBUTE_PURE;
    4493                 :            : #if !defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 4003)
    4494                 :            : extern inline __attribute__ ((__gnu_inline__)) HOST_WIDE_INT
    4495                 :            : tree_to_shwi (const_tree t)
    4496                 :            : {
    4497                 :            :   gcc_assert (tree_fits_shwi_p (t));
    4498                 :            :   return TREE_INT_CST_LOW (t);
    4499                 :            : }
    4500                 :            : 
    4501                 :            : extern inline __attribute__ ((__gnu_inline__)) unsigned HOST_WIDE_INT
    4502                 :            : tree_to_uhwi (const_tree t)
    4503                 :            : {
    4504                 :            :   gcc_assert (tree_fits_uhwi_p (t));
    4505                 :            :   return TREE_INT_CST_LOW (t);
    4506                 :            : }
    4507                 :            : #if NUM_POLY_INT_COEFFS == 1
    4508                 :            : extern inline __attribute__ ((__gnu_inline__)) poly_int64
    4509                 :            : tree_to_poly_int64 (const_tree t)
    4510                 :            : {
    4511                 :            :   gcc_assert (tree_fits_poly_int64_p (t));
    4512                 :            :   return TREE_INT_CST_LOW (t);
    4513                 :            : }
    4514                 :            : 
    4515                 :            : extern inline __attribute__ ((__gnu_inline__)) poly_uint64
    4516                 :            : tree_to_poly_uint64 (const_tree t)
    4517                 :            : {
    4518                 :            :   gcc_assert (tree_fits_poly_uint64_p (t));
    4519                 :            :   return TREE_INT_CST_LOW (t);
    4520                 :            : }
    4521                 :            : #endif
    4522                 :            : #endif
    4523                 :            : extern int tree_int_cst_sgn (const_tree);
    4524                 :            : extern int tree_int_cst_sign_bit (const_tree);
    4525                 :            : extern unsigned int tree_int_cst_min_precision (tree, signop);
    4526                 :            : extern tree strip_array_types (tree);
    4527                 :            : extern tree excess_precision_type (tree);
    4528                 :            : 
    4529                 :            : /* Desription of the reason why the argument of valid_constant_size_p
    4530                 :            :    is not a valid size.  */
    4531                 :            : enum cst_size_error {
    4532                 :            :   cst_size_ok,
    4533                 :            :   cst_size_not_constant,
    4534                 :            :   cst_size_negative,
    4535                 :            :   cst_size_too_big,
    4536                 :            :   cst_size_overflow
    4537                 :            : };
    4538                 :            : 
    4539                 :            : extern bool valid_constant_size_p (const_tree, cst_size_error * = NULL);
    4540                 :            : extern tree max_object_size ();
    4541                 :            : 
    4542                 :            : /* Return true if T holds a value that can be represented as a poly_int64
    4543                 :            :    without loss of precision.  Store the value in *VALUE if so.  */
    4544                 :            : 
    4545                 :            : inline bool
    4546                 :            : poly_int_tree_p (const_tree t, poly_int64_pod *value)
    4547                 :            : {
    4548                 :            :   if (tree_fits_poly_int64_p (t))
    4549                 :            :     {
    4550                 :            :       *value = tree_to_poly_int64 (t);
    4551                 :            :       return true;
    4552                 :            :     }
    4553                 :            :   return false;
    4554                 :            : }
    4555                 :            : 
    4556                 :            : /* Return true if T holds a value that can be represented as a poly_uint64
    4557                 :            :    without loss of precision.  Store the value in *VALUE if so.  */
    4558                 :            : 
    4559                 :            : inline bool
    4560                 :            : poly_int_tree_p (const_tree t, poly_uint64_pod *value)
    4561                 :            : {
    4562                 :            :   if (tree_fits_poly_uint64_p (t))
    4563                 :            :     {
    4564                 :            :       *value = tree_to_poly_uint64 (t);
    4565                 :            :       return true;
    4566                 :            :     }
    4567                 :            :   return false;
    4568                 :            : }
    4569                 :            : 
    4570                 :            : /* From expmed.c.  Since rtl.h is included after tree.h, we can't
    4571                 :            :    put the prototype here.  Rtl.h does declare the prototype if
    4572                 :            :    tree.h had been included.  */
    4573                 :            : 
    4574                 :            : extern tree make_tree (tree, rtx);
    4575                 :            : 
    4576                 :            : /* Returns true iff CAND and BASE have equivalent language-specific
    4577                 :            :    qualifiers.  */
    4578                 :            : 
    4579                 :            : extern bool check_lang_type (const_tree cand, const_tree base);
    4580                 :            : 
    4581                 :            : /* Returns true iff unqualified CAND and BASE are equivalent.  */
    4582                 :            : 
    4583                 :            : extern bool check_base_type (const_tree cand, const_tree base);
    4584                 :            : 
    4585                 :            : /* Check whether CAND is suitable to be returned from get_qualified_type
    4586                 :            :    (BASE, TYPE_QUALS).  */
    4587                 :            : 
    4588                 :            : extern bool check_qualified_type (const_tree, const_tree, int);
    4589                 :            : 
    4590                 :            : /* Return a version of the TYPE, qualified as indicated by the
    4591                 :            :    TYPE_QUALS, if one exists.  If no qualified version exists yet,
    4592                 :            :    return NULL_TREE.  */
    4593                 :            : 
    4594                 :            : extern tree get_qualified_type (tree, int);
    4595                 :            : 
    4596                 :            : /* Like get_qualified_type, but creates the type if it does not
    4597                 :            :    exist.  This function never returns NULL_TREE.  */
    4598                 :            : 
    4599                 :            : extern tree build_qualified_type (tree, int CXX_MEM_STAT_INFO);
    4600                 :            : 
    4601                 :            : /* Create a variant of type T with alignment ALIGN.  */
    4602                 :            : 
    4603                 :            : extern tree build_aligned_type (tree, unsigned int);
    4604                 :            : 
    4605                 :            : /* Like build_qualified_type, but only deals with the `const' and
    4606                 :            :    `volatile' qualifiers.  This interface is retained for backwards
    4607                 :            :    compatibility with the various front-ends; new code should use
    4608                 :            :    build_qualified_type instead.  */
    4609                 :            : 
    4610                 :            : #define build_type_variant(TYPE, CONST_P, VOLATILE_P)                   \
    4611                 :            :   build_qualified_type ((TYPE),                                         \
    4612                 :            :                         ((CONST_P) ? TYPE_QUAL_CONST : 0)               \
    4613                 :            :                         | ((VOLATILE_P) ? TYPE_QUAL_VOLATILE : 0))
    4614                 :            : 
    4615                 :            : /* Make a copy of a type node.  */
    4616                 :            : 
    4617                 :            : extern tree build_distinct_type_copy (tree CXX_MEM_STAT_INFO);
    4618                 :            : extern tree build_variant_type_copy (tree CXX_MEM_STAT_INFO);
    4619                 :            : 
    4620                 :            : /* Given a hashcode and a ..._TYPE node (for which the hashcode was made),
    4621                 :            :    return a canonicalized ..._TYPE node, so that duplicates are not made.
    4622                 :            :    How the hash code is computed is up to the caller, as long as any two
    4623                 :            :    callers that could hash identical-looking type nodes agree.  */
    4624                 :            : 
    4625                 :            : extern hashval_t type_hash_canon_hash (tree);
    4626                 :            : extern tree type_hash_canon (unsigned int, tree);
    4627                 :            : 
    4628                 :            : extern tree convert (tree, tree);
    4629                 :            : extern unsigned int expr_align (const_tree);
    4630                 :            : extern tree size_in_bytes_loc (location_t, const_tree);
    4631                 :            : inline tree
    4632                 :   12695318 : size_in_bytes (const_tree t)
    4633                 :            : {
    4634                 :   12695318 :   return size_in_bytes_loc (input_location, t);
    4635                 :            : }
    4636                 :            : 
    4637                 :            : extern HOST_WIDE_INT int_size_in_bytes (const_tree);
    4638                 :            : extern HOST_WIDE_INT max_int_size_in_bytes (const_tree);
    4639                 :            : extern tree bit_position (const_tree);
    4640                 :            : extern tree byte_position (const_tree);
    4641                 :            : extern HOST_WIDE_INT int_byte_position (const_tree);
    4642                 :            : 
    4643                 :            : /* Type for sizes of data-type.  */
    4644                 :            : 
    4645                 :            : #define sizetype sizetype_tab[(int) stk_sizetype]
    4646                 :            : #define bitsizetype sizetype_tab[(int) stk_bitsizetype]
    4647                 :            : #define ssizetype sizetype_tab[(int) stk_ssizetype]
    4648                 :            : #define sbitsizetype sizetype_tab[(int) stk_sbitsizetype]
    4649                 :            : #define size_int(L) size_int_kind (L, stk_sizetype)
    4650                 :            : #define ssize_int(L) size_int_kind (L, stk_ssizetype)
    4651                 :            : #define bitsize_int(L) size_int_kind (L, stk_bitsizetype)
    4652                 :            : #define sbitsize_int(L) size_int_kind (L, stk_sbitsizetype)
    4653                 :            : 
    4654                 :            : /* Log2 of BITS_PER_UNIT.  */
    4655                 :            : 
    4656                 :            : #if BITS_PER_UNIT == 8
    4657                 :            : #define LOG2_BITS_PER_UNIT 3
    4658                 :            : #elif BITS_PER_UNIT == 16
    4659                 :            : #define LOG2_BITS_PER_UNIT 4
    4660                 :            : #else
    4661                 :            : #error Unknown BITS_PER_UNIT
    4662                 :            : #endif
    4663                 :            : 
    4664                 :            : /* Concatenate two lists (chains of TREE_LIST nodes) X and Y
    4665                 :            :    by making the last node in X point to Y.
    4666                 :            :    Returns X, except if X is 0 returns Y.  */
    4667                 :            : 
    4668                 :            : extern tree chainon (tree, tree);
    4669                 :            : 
    4670                 :            : /* Make a new TREE_LIST node from specified PURPOSE, VALUE and CHAIN.  */
    4671                 :            : 
    4672                 :            : extern tree tree_cons (tree, tree, tree CXX_MEM_STAT_INFO);
    4673                 :            : 
    4674                 :            : /* Return the last tree node in a chain.  */
    4675                 :            : 
    4676                 :            : extern tree tree_last (tree);
    4677                 :            : 
    4678                 :            : /* Reverse the order of elements in a chain, and return the new head.  */
    4679                 :            : 
    4680                 :            : extern tree nreverse (tree);
    4681                 :            : 
    4682                 :            : /* Returns the length of a chain of nodes
    4683                 :            :    (number of chain pointers to follow before reaching a null pointer).  */
    4684                 :            : 
    4685                 :            : extern int list_length (const_tree);
    4686                 :            : 
    4687                 :            : /* Returns the first FIELD_DECL in a type.  */
    4688                 :            : 
    4689                 :            : extern tree first_field (const_tree);
    4690                 :            : 
    4691                 :            : /* Given an initializer INIT, return TRUE if INIT is zero or some
    4692                 :            :    aggregate of zeros.  Otherwise return FALSE.  If NONZERO is not
    4693                 :            :    null, set *NONZERO if and only if INIT is known not to be all
    4694                 :            :    zeros.  The combination of return value of false and *NONZERO
    4695                 :            :    false implies that INIT may but need not be all zeros.  Other
    4696                 :            :    combinations indicate definitive answers.  */
    4697                 :            : 
    4698                 :            : extern bool initializer_zerop (const_tree, bool * = NULL);
    4699                 :            : extern bool initializer_each_zero_or_onep (const_tree);
    4700                 :            : 
    4701                 :            : extern wide_int vector_cst_int_elt (const_tree, unsigned int);
    4702                 :            : extern tree vector_cst_elt (const_tree, unsigned int);
    4703                 :            : 
    4704                 :            : /* Given a vector VEC, return its first element if all elements are
    4705                 :            :    the same.  Otherwise return NULL_TREE.  */
    4706                 :            : 
    4707                 :            : extern tree uniform_vector_p (const_tree);
    4708                 :            : 
    4709                 :            : /* If the argument is INTEGER_CST, return it.  If the argument is vector
    4710                 :            :    with all elements the same INTEGER_CST, return that INTEGER_CST.  Otherwise
    4711                 :            :    return NULL_TREE.  */
    4712                 :            : 
    4713                 :            : extern tree uniform_integer_cst_p (tree);
    4714                 :            : 
    4715                 :            : extern int single_nonzero_element (const_tree);
    4716                 :            : 
    4717                 :            : /* Given a CONSTRUCTOR CTOR, return the element values as a vector.  */
    4718                 :            : 
    4719                 :            : extern vec<tree, va_gc> *ctor_to_vec (tree);
    4720                 :            : 
    4721                 :            : /* zerop (tree x) is nonzero if X is a constant of value 0.  */
    4722                 :            : 
    4723                 :            : extern bool zerop (const_tree);
    4724                 :            : 
    4725                 :            : /* integer_zerop (tree x) is nonzero if X is an integer constant of value 0.  */
    4726                 :            : 
    4727                 :            : extern bool integer_zerop (const_tree);
    4728                 :            : 
    4729                 :            : /* integer_onep (tree x) is nonzero if X is an integer constant of value 1.  */
    4730                 :            : 
    4731                 :            : extern bool integer_onep (const_tree);
    4732                 :            : 
    4733                 :            : /* integer_onep (tree x) is nonzero if X is an integer constant of value 1, or
    4734                 :            :    a vector or complex where each part is 1.  */
    4735                 :            : 
    4736                 :            : extern bool integer_each_onep (const_tree);
    4737                 :            : 
    4738                 :            : /* integer_all_onesp (tree x) is nonzero if X is an integer constant
    4739                 :            :    all of whose significant bits are 1.  */
    4740                 :            : 
    4741                 :            : extern bool integer_all_onesp (const_tree);
    4742                 :            : 
    4743                 :            : /* integer_minus_onep (tree x) is nonzero if X is an integer constant of
    4744                 :            :    value -1.  */
    4745                 :            : 
    4746                 :            : extern bool integer_minus_onep (const_tree);
    4747                 :            : 
    4748                 :            : /* integer_pow2p (tree x) is nonzero is X is an integer constant with
    4749                 :            :    exactly one bit 1.  */
    4750                 :            : 
    4751                 :            : extern bool integer_pow2p (const_tree);
    4752                 :            : 
    4753                 :            : /* integer_nonzerop (tree x) is nonzero if X is an integer constant
    4754                 :            :    with a nonzero value.  */
    4755                 :            : 
    4756                 :            : extern bool integer_nonzerop (const_tree);
    4757                 :            : 
    4758                 :            : /* integer_truep (tree x) is nonzero if X is an integer constant of value 1 or
    4759                 :            :    a vector where each element is an integer constant of value -1.  */
    4760                 :            : 
    4761                 :            : extern bool integer_truep (const_tree);
    4762                 :            : 
    4763                 :            : extern bool cst_and_fits_in_hwi (const_tree);
    4764                 :            : extern tree num_ending_zeros (const_tree);
    4765                 :            : 
    4766                 :            : /* fixed_zerop (tree x) is nonzero if X is a fixed-point constant of
    4767                 :            :    value 0.  */
    4768                 :            : 
    4769                 :            : extern bool fixed_zerop (const_tree);
    4770                 :            : 
    4771                 :            : /* staticp (tree x) is nonzero if X is a reference to data allocated
    4772                 :            :    at a fixed address in memory.  Returns the outermost data.  */
    4773                 :            : 
    4774                 :            : extern tree staticp (tree);
    4775                 :            : 
    4776                 :            : /* save_expr (EXP) returns an expression equivalent to EXP
    4777                 :            :    but it can be used multiple times within context CTX
    4778                 :            :    and only evaluate EXP once.  */
    4779                 :            : 
    4780                 :            : extern tree save_expr (tree);
    4781                 :            : 
    4782                 :            : /* Return true if T is function-invariant.  */
    4783                 :            : 
    4784                 :            : extern bool tree_invariant_p (tree);
    4785                 :            : 
    4786                 :            : /* Look inside EXPR into any simple arithmetic operations.  Return the
    4787                 :            :    outermost non-arithmetic or non-invariant node.  */
    4788                 :            : 
    4789                 :            : extern tree skip_simple_arithmetic (tree);
    4790                 :            : 
    4791                 :            : /* Look inside EXPR into simple arithmetic operations involving constants.
    4792                 :            :    Return the outermost non-arithmetic or non-constant node.  */
    4793                 :            : 
    4794                 :            : extern tree skip_simple_constant_arithmetic (tree);
    4795                 :            : 
    4796                 :            : /* Return which tree structure is used by T.  */
    4797                 :            : 
    4798                 :            : enum tree_node_structure_enum tree_node_structure (const_tree);
    4799                 :            : 
    4800                 :            : /* Return true if EXP contains a PLACEHOLDER_EXPR, i.e. if it represents a
    4801                 :            :    size or offset that depends on a field within a record.  */
    4802                 :            : 
    4803                 :            : extern bool contains_placeholder_p (const_tree);
    4804                 :            : 
    4805                 :            : /* This macro calls the above function but short-circuits the common
    4806                 :            :    case of a constant to save time.  Also check for null.  */
    4807                 :            : 
    4808                 :            : #define CONTAINS_PLACEHOLDER_P(EXP) \
    4809                 :            :   ((EXP) != 0 && ! TREE_CONSTANT (EXP) && contains_placeholder_p (EXP))
    4810                 :            : 
    4811                 :            : /* Return true if any part of the structure of TYPE involves a PLACEHOLDER_EXPR
    4812                 :            :    directly.  This includes size, bounds, qualifiers (for QUAL_UNION_TYPE) and
    4813                 :            :    field positions.  */
    4814                 :            : 
    4815                 :            : extern bool type_contains_placeholder_p (tree);
    4816                 :            : 
    4817                 :            : /* Given a tree EXP, find all occurrences of references to fields
    4818                 :            :    in a PLACEHOLDER_EXPR and place them in vector REFS without
    4819                 :            :    duplicates.  Also record VAR_DECLs and CONST_DECLs.  Note that
    4820                 :            :    we assume here that EXP contains only arithmetic expressions
    4821                 :            :    or CALL_EXPRs with PLACEHOLDER_EXPRs occurring only in their
    4822                 :            :    argument list.  */
    4823                 :            : 
    4824                 :            : extern void find_placeholder_in_expr (tree, vec<tree> *);
    4825                 :            : 
    4826                 :            : /* This macro calls the above function but short-circuits the common
    4827                 :            :    case of a constant to save time and also checks for NULL.  */
    4828                 :            : 
    4829                 :            : #define FIND_PLACEHOLDER_IN_EXPR(EXP, V) \
    4830                 :            : do {                                     \
    4831                 :            :   if((EXP) && !TREE_CONSTANT (EXP))      \
    4832                 :            :     find_placeholder_in_expr (EXP, V);   \
    4833                 :            : } while (0)
    4834                 :            : 
    4835                 :            : /* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
    4836                 :            :    return a tree with all occurrences of references to F in a
    4837                 :            :    PLACEHOLDER_EXPR replaced by R.  Also handle VAR_DECLs and
    4838                 :            :    CONST_DECLs.  Note that we assume here that EXP contains only
    4839                 :            :    arithmetic expressions or CALL_EXPRs with PLACEHOLDER_EXPRs
    4840                 :            :    occurring only in their argument list.  */
    4841                 :            : 
    4842                 :            : extern tree substitute_in_expr (tree, tree, tree);
    4843                 :            : 
    4844                 :            : /* This macro calls the above function but short-circuits the common
    4845                 :            :    case of a constant to save time and also checks for NULL.  */
    4846                 :            : 
    4847                 :            : #define SUBSTITUTE_IN_EXPR(EXP, F, R) \
    4848                 :            :   ((EXP) == 0 || TREE_CONSTANT (EXP) ? (EXP) : substitute_in_expr (EXP, F, R))
    4849                 :            : 
    4850                 :            : /* Similar, but look for a PLACEHOLDER_EXPR in EXP and find a replacement
    4851                 :            :    for it within OBJ, a tree that is an object or a chain of references.  */
    4852                 :            : 
    4853                 :            : extern tree substitute_placeholder_in_expr (tree, tree);
    4854                 :            : 
    4855                 :            : /* This macro calls the above function but short-circuits the common
    4856                 :            :    case of a constant to save time and also checks for NULL.  */
    4857                 :            : 
    4858                 :            : #define SUBSTITUTE_PLACEHOLDER_IN_EXPR(EXP, OBJ) \
    4859                 :            :   ((EXP) == 0 || TREE_CONSTANT (EXP) ? (EXP)    \
    4860                 :            :    : substitute_placeholder_in_expr (EXP, OBJ))
    4861                 :            : 
    4862                 :            : 
    4863                 :            : /* stabilize_reference (EXP) returns a reference equivalent to EXP
    4864                 :            :    but it can be used multiple times
    4865                 :            :    and only evaluate the subexpressions once.  */
    4866                 :            : 
    4867                 :            : extern tree stabilize_reference (tree);
    4868                 :            : 
    4869                 :            : /* Return EXP, stripped of any conversions to wider types
    4870                 :            :    in such a way that the result of converting to type FOR_TYPE
    4871                 :            :    is the same as if EXP were converted to FOR_TYPE.
    4872                 :            :    If FOR_TYPE is 0, it signifies EXP's type.  */
    4873                 :            : 
    4874                 :            : extern tree get_unwidened (tree, tree);
    4875                 :            : 
    4876                 :            : /* Return OP or a simpler expression for a narrower value
    4877                 :            :    which can be sign-extended or zero-extended to give back OP.
    4878                 :            :    Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
    4879                 :            :    or 0 if the value should be sign-extended.  */
    4880                 :            : 
    4881                 :            : extern tree get_narrower (tree, int *);
    4882                 :            : 
    4883                 :            : /* Return true if T is an expression that get_inner_reference handles.  */
    4884                 :            : 
    4885                 :            : static inline bool
    4886                 :19572854940 : handled_component_p (const_tree t)
    4887                 :            : {
    4888                 :19489754940 :   switch (TREE_CODE (t))
    4889                 :            :     {
    4890                 :            :     case COMPONENT_REF:
    4891                 :            :     case BIT_FIELD_REF:
    4892                 :            :     case ARRAY_REF:
    4893                 :            :     case ARRAY_RANGE_REF:
    4894                 :            :     case REALPART_EXPR:
    4895                 :            :     case IMAGPART_EXPR:
    4896                 :            :     case VIEW_CONVERT_EXPR:
    4897                 :            :       return true;
    4898                 :            : 
    4899                 : 9547074953 :     default:
    4900                 : 9547074953 :       return false;
    4901                 :            :     }
    4902                 :            : }
    4903                 :            : 
    4904                 :            : /* Return true T is a component with reverse storage order.  */
    4905                 :            : 
    4906                 :            : static inline bool
    4907                 : 2310988142 : reverse_storage_order_for_component_p (tree t)
    4908                 :            : {
    4909                 :            :   /* The storage order only applies to scalar components.  */
    4910                 : 2310988142 :   if (AGGREGATE_TYPE_P (TREE_TYPE (t)) || VECTOR_TYPE_P (TREE_TYPE (t)))
    4911                 :            :     return false;
    4912                 :            : 
    4913                 : 1771723176 :   if (TREE_CODE (t) == REALPART_EXPR || TREE_CODE (t) == IMAGPART_EXPR)
    4914                 :    6201628 :     t = TREE_OPERAND (t, 0);
    4915                 :            : 
    4916                 : 1771723176 :   switch (TREE_CODE (t))
    4917                 :            :     {
    4918                 : 1133651801 :     case ARRAY_REF:
    4919                 : 1133651801 :     case COMPONENT_REF:
    4920                 :            :       /* ??? Fortran can take COMPONENT_REF of a VOID_TYPE.  */
    4921                 :            :       /* ??? UBSan can take COMPONENT_REF of a REFERENCE_TYPE.  */
    4922                 : 2140058870 :       return AGGREGATE_TYPE_P (TREE_TYPE (TREE_OPERAND (t, 0)))
    4923                 : 2140058570 :              && TYPE_REVERSE_STORAGE_ORDER (TREE_TYPE (TREE_OPERAND (t, 0)));
    4924                 :            : 
    4925                 :  432087114 :     case BIT_FIELD_REF:
    4926                 :  432087114 :     case MEM_REF:
    4927                 :  862158256 :       return REF_REVERSE_STORAGE_ORDER (t);
    4928                 :            : 
    4929                 :            :     case ARRAY_RANGE_REF:
    4930                 :            :     case VIEW_CONVERT_EXPR:
    4931                 :            :     default:
    4932                 :            :       return false;
    4933                 :            :     }
    4934                 :            : 
    4935                 :            :   gcc_unreachable ();
    4936                 :            : }
    4937                 :            : 
    4938                 :            : /* Return true if T is a storage order barrier, i.e. a VIEW_CONVERT_EXPR
    4939                 :            :    that can modify the storage order of objects.  Note that, even if the
    4940                 :            :    TYPE_REVERSE_STORAGE_ORDER flag is set on both the inner type and the
    4941                 :            :    outer type, a VIEW_CONVERT_EXPR can modify the storage order because
    4942                 :            :    it can change the partition of the aggregate object into scalars.  */
    4943                 :            : 
    4944                 :            : static inline bool
    4945                 :   47470680 : storage_order_barrier_p (const_tree t)
    4946                 :            : {
    4947                 :   47470680 :   if (TREE_CODE (t) != VIEW_CONVERT_EXPR)
    4948                 :            :     return false;
    4949                 :            : 
    4950                 :    2780162 :   if (AGGREGATE_TYPE_P (TREE_TYPE (t))
    4951                 :    2708167 :       && TYPE_REVERSE_STORAGE_ORDER (TREE_TYPE (t)))
    4952                 :            :     return true;
    4953                 :            : 
    4954                 :    1437561 :   tree op = TREE_OPERAND (t, 0);
    4955                 :            : 
    4956                 :    2861889 :   if (AGGREGATE_TYPE_P (TREE_TYPE (op))
    4957                 :    2712716 :       && TYPE_REVERSE_STORAGE_ORDER (TREE_TYPE (op)))
    4958                 :          0 :     return true;
    4959                 :            : 
    4960                 :            :   return false;
    4961                 :            : }
    4962                 :            : 
    4963                 :            : /* Given a DECL or TYPE, return the scope in which it was declared, or
    4964                 :            :    NUL_TREE if there is no containing scope.  */
    4965                 :            : 
    4966                 :            : extern tree get_containing_scope (const_tree);
    4967                 :            : 
    4968                 :            : /* Returns the ultimate TRANSLATION_UNIT_DECL context of DECL or NULL.  */
    4969                 :            : 
    4970                 :            : extern const_tree get_ultimate_context (const_tree);
    4971                 :            : 
    4972                 :            : /* Return the FUNCTION_DECL which provides this _DECL with its context,
    4973                 :            :    or zero if none.  */
    4974                 :            : extern tree decl_function_context (const_tree);
    4975                 :            : 
    4976                 :            : /* Return the RECORD_TYPE, UNION_TYPE, or QUAL_UNION_TYPE which provides
    4977                 :            :    this _DECL with its context, or zero if none.  */
    4978                 :            : extern tree decl_type_context (const_tree);
    4979                 :            : 
    4980                 :            : /* Return true if EXPR is the real constant zero.  */
    4981                 :            : extern bool real_zerop (const_tree);
    4982                 :            : 
    4983                 :            : /* Initialize the iterator I with arguments from function FNDECL  */
    4984                 :            : 
    4985                 :            : static inline void
    4986                 :            : function_args_iter_init (function_args_iterator *i, const_tree fntype)
    4987                 :            : {
    4988                 :            :   i->next = TYPE_ARG_TYPES (fntype);
    4989                 :            : }
    4990                 :            : 
    4991                 :            : /* Return a pointer that holds the next argument if there are more arguments to
    4992                 :            :    handle, otherwise return NULL.  */
    4993                 :            : 
    4994                 :            : static inline tree *
    4995                 :            : function_args_iter_cond_ptr (function_args_iterator *i)
    4996                 :            : {
    4997                 :            :   return (i->next) ? &TREE_VALUE (i->next) : NULL;
    4998                 :            : }
    4999                 :            : 
    5000                 :            : /* Return the next argument if there are more arguments to handle, otherwise
    5001                 :            :    return NULL.  */
    5002                 :            : 
    5003                 :            : static inline tree
    5004                 :            : function_args_iter_cond (function_args_iterator *i)
    5005                 :            : {
    5006                 :            :   return (i->next) ? TREE_VALUE (i->next) : NULL_TREE;
    5007                 :            : }
    5008                 :            : 
    5009                 :            : /* Advance to the next argument.  */
    5010                 :            : static inline void
    5011                 :            : function_args_iter_next (function_args_iterator *i)
    5012                 :            : {
    5013                 :            :   gcc_assert (i->next != NULL_TREE);
    5014                 :            :   i->next = TREE_CHAIN (i->next);
    5015                 :            : }
    5016                 :            : 
    5017                 :            : /* We set BLOCK_SOURCE_LOCATION only to inlined function entry points.  */
    5018                 :            : 
    5019                 :            : static inline bool
    5020                 :   25269507 : inlined_function_outer_scope_p (const_tree block)
    5021                 :            : {
    5022                 :   25269507 :  return LOCATION_LOCUS (BLOCK_SOURCE_LOCATION (block)) != UNKNOWN_LOCATION;
    5023                 :            : }
    5024                 :            : 
    5025                 :            : /* Loop over all function arguments of FNTYPE.  In each iteration, PTR is set
    5026                 :            :    to point to the next tree element.  ITER is an instance of
    5027                 :            :    function_args_iterator used to iterate the arguments.  */
    5028                 :            : #define FOREACH_FUNCTION_ARGS_PTR(FNTYPE, PTR, ITER)                    \
    5029                 :            :   for (function_args_iter_init (&(ITER), (FNTYPE));                 \
    5030                 :            :        (PTR = function_args_iter_cond_ptr (&(ITER))) != NULL;               \
    5031                 :            :        function_args_iter_next (&(ITER)))
    5032                 :            : 
    5033                 :            : /* Loop over all function arguments of FNTYPE.  In each iteration, TREE is set
    5034                 :            :    to the next tree element.  ITER is an instance of function_args_iterator
    5035                 :            :    used to iterate the arguments.  */
    5036                 :            : #define FOREACH_FUNCTION_ARGS(FNTYPE, TREE, ITER)                       \
    5037                 :            :   for (function_args_iter_init (&(ITER), (FNTYPE));                 \
    5038                 :            :        (TREE = function_args_iter_cond (&(ITER))) != NULL_TREE;             \
    5039                 :            :        function_args_iter_next (&(ITER)))
    5040                 :            : 
    5041                 :            : /* In tree.c */
    5042                 :            : extern unsigned crc32_unsigned_n (unsigned, unsigned, unsigned);
    5043                 :            : extern unsigned crc32_string (unsigned, const char *);
    5044                 :            : inline unsigned
    5045                 :        102 : crc32_unsigned (unsigned chksum, unsigned value)
    5046                 :            : {
    5047                 :        102 :   return crc32_unsigned_n (chksum, value, 4);
    5048                 :            : }
    5049                 :            : inline unsigned
    5050                 :   15137012 : crc32_byte (unsigned chksum, char byte)
    5051                 :            : {
    5052                 :   15137012 :   return crc32_unsigned_n (chksum, byte, 1);
    5053                 :            : }
    5054                 :            : extern void clean_symbol_name (char *);
    5055                 :            : extern tree get_file_function_name (const char *);
    5056                 :            : extern tree get_callee_fndecl (const_tree);
    5057                 :            : extern combined_fn get_call_combined_fn (const_tree);
    5058                 :            : extern int type_num_arguments (const_tree);
    5059                 :            : extern tree type_argument_type (const_tree, unsigned) ATTRIBUTE_NONNULL (1);
    5060                 :            : extern bool associative_tree_code (enum tree_code);
    5061                 :            : extern bool commutative_tree_code (enum tree_code);
    5062                 :            : extern bool commutative_ternary_tree_code (enum tree_code);
    5063                 :            : extern bool operation_can_overflow (enum tree_code);
    5064                 :            : extern bool operation_no_trapping_overflow (tree, enum tree_code);
    5065                 :            : extern tree upper_bound_in_type (tree, tree);
    5066                 :            : extern tree lower_bound_in_type (tree, tree);
    5067                 :            : extern int operand_equal_for_phi_arg_p (const_tree, const_tree);
    5068                 :            : extern tree create_artificial_label (location_t);
    5069                 :            : extern const char *get_name (tree);
    5070                 :            : extern bool stdarg_p (const_tree);
    5071                 :            : extern bool prototype_p (const_tree);
    5072                 :            : extern bool is_typedef_decl (const_tree x);
    5073                 :            : extern bool typedef_variant_p (const_tree);
    5074                 :            : extern bool auto_var_p (const_tree);
    5075                 :            : extern bool auto_var_in_fn_p (const_tree, const_tree);
    5076                 :            : extern tree build_low_bits_mask (tree, unsigned);
    5077                 :            : extern bool tree_nop_conversion_p (const_tree, const_tree);
    5078                 :            : extern tree tree_strip_nop_conversions (tree);
    5079                 :            : extern tree tree_strip_sign_nop_conversions (tree);
    5080                 :            : extern const_tree strip_invariant_refs (const_tree);
    5081                 :            : extern tree lhd_gcc_personality (void);
    5082                 :            : extern void assign_assembler_name_if_needed (tree);
    5083                 :            : extern bool warn_deprecated_use (tree, tree);
    5084                 :            : extern void cache_integer_cst (tree);
    5085                 :            : extern const char *combined_fn_name (combined_fn);
    5086                 :            : 
    5087                 :            : /* Compare and hash for any structure which begins with a canonical
    5088                 :            :    pointer.  Assumes all pointers are interchangeable, which is sort
    5089                 :            :    of already assumed by gcc elsewhere IIRC.  */
    5090                 :            : 
    5091                 :            : static inline int
    5092                 :            : struct_ptr_eq (const void *a, const void *b)
    5093                 :            : {
    5094                 :            :   const void * const * x = (const void * const *) a;
    5095                 :            :   const void * const * y = (const void * const *) b;
    5096                 :            :   return *x == *y;
    5097                 :            : }
    5098                 :            : 
    5099                 :            : static inline hashval_t
    5100                 :            : struct_ptr_hash (const void *a)
    5101                 :            : {
    5102                 :            :   const void * const * x = (const void * const *) a;
    5103                 :            :   return (intptr_t)*x >> 4;
    5104                 :            : }
    5105                 :            : 
    5106                 :            : /* Return nonzero if CODE is a tree code that represents a truth value.  */
    5107                 :            : static inline bool
    5108                 :  112094541 : truth_value_p (enum tree_code code)
    5109                 :            : {
    5110                 :  112094541 :   return (TREE_CODE_CLASS (code) == tcc_comparison
    5111                 :  107103529 :           || code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR
    5112                 :  107056184 :           || code == TRUTH_OR_EXPR || code == TRUTH_ORIF_EXPR
    5113                 :  175626398 :           || code == TRUTH_XOR_EXPR || code == TRUTH_NOT_EXPR);
    5114                 :            : }
    5115                 :            : 
    5116                 :            : /* Return whether TYPE is a type suitable for an offset for
    5117                 :            :    a POINTER_PLUS_EXPR.  */
    5118                 :            : static inline bool
    5119                 :   88747917 : ptrofftype_p (tree type)
    5120                 :            : {
    5121                 :   88747917 :   return (INTEGRAL_TYPE_P (type)
    5122                 :   88747917 :           && TYPE_PRECISION (type) == TYPE_PRECISION (sizetype)
    5123                 :  177496080 :           && TYPE_UNSIGNED (type) == TYPE_UNSIGNED (sizetype));
    5124                 :            : }
    5125                 :            : 
    5126                 :            : /* Return true if the argument is a complete type or an array
    5127                 :            :    of unknown bound (whose type is incomplete but) whose elements
    5128                 :            :    have complete type.  */
    5129                 :            : static inline bool
    5130                 :     938754 : complete_or_array_type_p (const_tree type)
    5131                 :            : {
    5132                 :     938754 :   return COMPLETE_TYPE_P (type)
    5133                 :     938754 :          || (TREE_CODE (type) == ARRAY_TYPE
    5134                 :      51555 :              && COMPLETE_TYPE_P (TREE_TYPE (type)));
    5135                 :            : }
    5136                 :            : 
    5137                 :            : /* Return true if the value of T could be represented as a poly_widest_int.  */
    5138                 :            : 
    5139                 :            : inline bool
    5140                 : 6668065868 : poly_int_tree_p (const_tree t)
    5141                 :            : {
    5142                 : 5941327549 :   return (TREE_CODE (t) == INTEGER_CST || POLY_INT_CST_P (t));
    5143                 :            : }
    5144                 :            : 
    5145                 :            : /* Return the bit size of BIT_FIELD_REF T, in cases where it is known
    5146                 :            :    to be a poly_uint64.  (This is always true at the gimple level.)  */
    5147                 :            : 
    5148                 :            : inline poly_uint64
    5149                 :      37035 : bit_field_size (const_tree t)
    5150                 :            : {
    5151                 :      37035 :   return tree_to_poly_uint64 (TREE_OPERAND (t, 1));
    5152                 :            : }
    5153                 :            : 
    5154                 :            : /* Return the starting bit offset of BIT_FIELD_REF T, in cases where it is
    5155                 :            :    known to be a poly_uint64.  (This is always true at the gimple level.)  */
    5156                 :            : 
    5157                 :            : inline poly_uint64
    5158                 :     371720 : bit_field_offset (const_tree t)
    5159                 :            : {
    5160                 :     371720 :   return tree_to_poly_uint64 (TREE_OPERAND (t, 2));
    5161                 :            : }
    5162                 :            : 
    5163                 :            : extern tree strip_float_extensions (tree);
    5164                 :            : extern bool really_constant_p (const_tree);
    5165                 :            : extern bool ptrdiff_tree_p (const_tree, poly_int64_pod *);
    5166                 :            : extern bool decl_address_invariant_p (const_tree);
    5167                 :            : extern bool decl_address_ip_invariant_p (const_tree);
    5168                 :            : extern bool int_fits_type_p (const_tree, const_tree)
    5169                 :            :   ATTRIBUTE_NONNULL (1) ATTRIBUTE_NONNULL (2) ATTRIBUTE_PURE;
    5170                 :            : #ifndef GENERATOR_FILE
    5171                 :            : extern void get_type_static_bounds (const_tree, mpz_t, mpz_t);
    5172                 :            : #endif
    5173                 :            : extern bool variably_modified_type_p (tree, tree);
    5174                 :            : extern int tree_log2 (const_tree);
    5175                 :            : extern int tree_floor_log2 (const_tree);
    5176                 :            : extern unsigned int tree_ctz (const_tree);
    5177                 :            : extern int simple_cst_equal (const_tree, const_tree);
    5178                 :            : 
    5179                 :            : namespace inchash
    5180                 :            : {
    5181                 :            : 
    5182                 :            : extern void add_expr (const_tree, hash &, unsigned int = 0);
    5183                 :            : 
    5184                 :            : }
    5185                 :            : 
    5186                 :            : /* Compat version until all callers are converted. Return hash for
    5187                 :            :    TREE with SEED.  */
    5188                 :  123652991 : static inline hashval_t iterative_hash_expr(const_tree tree, hashval_t seed)
    5189                 :            : {
    5190                 :  106966588 :   inchash::hash hstate (seed);
    5191                 :  106966588 :   inchash::add_expr (tree, hstate);
    5192                 :  106966588 :   return hstate.end ();
    5193                 :            : }
    5194                 :            : 
    5195                 :            : extern int compare_tree_int (const_tree, unsigned HOST_WIDE_INT);
    5196                 :            : extern bool type_list_equal (const_tree, const_tree);
    5197                 :            : extern bool chain_member (const_tree, const_tree);
    5198                 :            : extern void dump_tree_statistics (void);
    5199                 :            : extern void recompute_tree_invariant_for_addr_expr (tree);
    5200                 :            : extern bool needs_to_live_in_memory (const_tree);
    5201                 :            : extern tree reconstruct_complex_type (tree, tree);
    5202                 :            : extern bool real_onep (const_tree);
    5203                 :            : extern bool real_minus_onep (const_tree);
    5204                 :            : extern void init_ttree (void);
    5205                 :            : extern void build_common_tree_nodes (bool);
    5206                 :            : extern void build_common_builtin_nodes (void);
    5207                 :            : extern tree build_nonstandard_integer_type (unsigned HOST_WIDE_INT, int);
    5208                 :            : extern tree build_nonstandard_boolean_type (unsigned HOST_WIDE_INT);
    5209                 :            : extern tree build_range_type (tree, tree, tree);
    5210                 :            : extern tree build_nonshared_range_type (tree, tree, tree);
    5211                 :            : extern bool subrange_type_for_debug_p (const_tree, tree *, tree *);
    5212                 :            : extern HOST_WIDE_INT int_cst_value (const_tree);
    5213                 :            : extern tree tree_block (tree);
    5214                 :            : extern void tree_set_block (tree, tree);
    5215                 :            : extern location_t *block_nonartificial_location (tree);
    5216                 :            : extern location_t tree_nonartificial_location (tree);
    5217                 :            : extern tree block_ultimate_origin (const_tree);
    5218                 :            : extern tree get_binfo_at_offset (tree, poly_int64, tree);
    5219                 :            : extern bool virtual_method_call_p (const_tree);
    5220                 :            : extern tree obj_type_ref_class (const_tree ref);
    5221                 :            : extern bool types_same_for_odr (const_tree type1, const_tree type2);
    5222                 :            : extern bool contains_bitfld_component_ref_p (const_tree);
    5223                 :            : extern bool block_may_fallthru (const_tree);
    5224                 :            : extern void using_eh_for_cleanups (void);
    5225                 :            : extern bool using_eh_for_cleanups_p (void);
    5226                 :            : extern const char *get_tree_code_name (enum tree_code);
    5227                 :            : extern void set_call_expr_flags (tree, int);
    5228                 :            : extern tree walk_tree_1 (tree*, walk_tree_fn, void*, hash_set<tree>*,
    5229                 :            :                          walk_tree_lh);
    5230                 :            : extern tree walk_tree_without_duplicates_1 (tree*, walk_tree_fn, void*,
    5231                 :            :                                             walk_tree_lh);
    5232                 :            : #define walk_tree(a,b,c,d) \
    5233                 :            :         walk_tree_1 (a, b, c, d, NULL)
    5234                 :            : #define walk_tree_without_duplicates(a,b,c) \
    5235                 :            :         walk_tree_without_duplicates_1 (a, b, c, NULL)
    5236                 :            : 
    5237                 :            : extern tree drop_tree_overflow (tree);
    5238                 :            : 
    5239                 :            : /* Given a memory reference expression T, return its base address.
    5240                 :            :    The base address of a memory reference expression is the main
    5241                 :            :    object being referenced.  */
    5242                 :            : extern tree get_base_address (tree t);
    5243                 :            : 
    5244                 :            : /* Return a tree of sizetype representing the size, in bytes, of the element
    5245                 :            :    of EXP, an ARRAY_REF or an ARRAY_RANGE_REF.  */
    5246                 :            : extern tree array_ref_element_size (tree);
    5247                 :            : 
    5248                 :            : /* Return a typenode for the "standard" C type with a given name.  */
    5249                 :            : extern tree get_typenode_from_name (const char *);
    5250                 :            : 
    5251                 :            : /* Return a tree representing the upper bound of the array mentioned in
    5252                 :            :    EXP, an ARRAY_REF or an ARRAY_RANGE_REF.  */
    5253                 :            : extern tree array_ref_up_bound (tree);
    5254                 :            : 
    5255                 :            : /* Return a tree representing the lower bound of the array mentioned in
    5256                 :            :    EXP, an ARRAY_REF or an ARRAY_RANGE_REF.  */
    5257                 :            : extern tree array_ref_low_bound (tree);
    5258                 :            : 
    5259                 :            : /* Returns true if REF is an array reference or a component reference
    5260                 :            :    to an array at the end of a structure.  If this is the case, the array
    5261                 :            :    may be allocated larger than its upper bound implies.  */
    5262                 :            : extern bool array_at_struct_end_p (tree);
    5263                 :            : 
    5264                 :            : /* Return a tree representing the offset, in bytes, of the field referenced
    5265                 :            :    by EXP.  This does not include any offset in DECL_FIELD_BIT_OFFSET.  */
    5266                 :            : extern tree component_ref_field_offset (tree);
    5267                 :            : 
    5268                 :            : /* Return the size of the member referenced by the COMPONENT_REF, using
    5269                 :            :    its initializer expression if necessary in order to determine the size
    5270                 :            :    of an initialized flexible array member.  The size might be zero for
    5271                 :            :    an object with an uninitialized flexible array member or null if it
    5272                 :            :    cannot be determined.  */
    5273                 :            : extern tree component_ref_size (tree, bool * = NULL);
    5274                 :            : 
    5275                 :            : extern int tree_map_base_eq (const void *, const void *);
    5276                 :            : extern unsigned int tree_map_base_hash (const void *);
    5277                 :            : extern int tree_map_base_marked_p (const void *);
    5278                 :            : extern void DEBUG_FUNCTION verify_type (const_tree t);
    5279                 :            : extern bool gimple_canonical_types_compatible_p (const_tree, const_tree,
    5280                 :            :                                                  bool trust_type_canonical = true);
    5281                 :            : extern bool type_with_interoperable_signedness (const_tree);
    5282                 :            : extern bitmap get_nonnull_args (const_tree);
    5283                 :            : extern int get_range_pos_neg (tree);
    5284                 :            : 
    5285                 :            : /* Return simplified tree code of type that is used for canonical type
    5286                 :            :    merging.  */
    5287                 :            : inline enum tree_code
    5288                 :   90420140 : tree_code_for_canonical_type_merging (enum tree_code code)
    5289                 :            : {
    5290                 :            :   /* By C standard, each enumerated type shall be compatible with char,
    5291                 :            :      a signed integer, or an unsigned integer.  The choice of type is
    5292                 :            :      implementation defined (in our case it depends on -fshort-enum).
    5293                 :            : 
    5294                 :            :      For this reason we make no distinction between ENUMERAL_TYPE and INTEGER
    5295                 :            :      type and compare only by their signedness and precision.  */
    5296                 :   89890940 :   if (code == ENUMERAL_TYPE)
    5297                 :            :     return INTEGER_TYPE;
    5298                 :            :   /* To allow inter-operability between languages having references and
    5299                 :            :      C, we consider reference types and pointers alike.  Note that this is
    5300                 :            :      not strictly necessary for C-Fortran 2008 interoperability because
    5301                 :            :      Fortran define C_PTR type that needs to be compatible with C pointers
    5302                 :            :      and we handle this one as ptr_type_node.  */
    5303                 :   89360960 :   if (code == REFERENCE_TYPE)
    5304                 :    4207241 :     return POINTER_TYPE;
    5305                 :            :   return code;
    5306                 :            : }
    5307                 :            : 
    5308                 :            : /* Return ture if get_alias_set care about TYPE_CANONICAL of given type.
    5309                 :            :    We don't define the types for pointers, arrays and vectors.  The reason is
    5310                 :            :    that pointers are handled specially: ptr_type_node accesses conflict with
    5311                 :            :    accesses to all other pointers.  This is done by alias.c.
    5312                 :            :    Because alias sets of arrays and vectors are the same as types of their
    5313                 :            :    elements, we can't compute canonical type either.  Otherwise we could go
    5314                 :            :    form void *[10] to int *[10] (because they are equivalent for canonical type
    5315                 :            :    machinery) and get wrong TBAA.  */
    5316                 :            : 
    5317                 :            : inline bool
    5318                 :  294571062 : canonical_type_used_p (const_tree t)
    5319                 :            : {
    5320                 :  211345550 :   return !(POINTER_TYPE_P (t)
    5321                 :  294571062 :            || TREE_CODE (t) == ARRAY_TYPE
    5322                 :            :            || TREE_CODE (t) == VECTOR_TYPE);
    5323                 :            : }
    5324                 :            : 
    5325                 :            : #define tree_map_eq tree_map_base_eq
    5326                 :            : extern unsigned int tree_map_hash (const void *);
    5327                 :            : #define tree_map_marked_p tree_map_base_marked_p
    5328                 :            : 
    5329                 :            : #define tree_decl_map_eq tree_map_base_eq
    5330                 :            : extern unsigned int tree_decl_map_hash (const void *);
    5331                 :            : #define tree_decl_map_marked_p tree_map_base_marked_p
    5332                 :            : 
    5333                 :            : struct tree_decl_map_cache_hasher : ggc_cache_ptr_hash<tree_decl_map>
    5334                 :            : {
    5335                 :  121146000 :   static hashval_t hash (tree_decl_map *m) { return tree_decl_map_hash (m); }
    5336                 :            :   static bool
    5337                 :  416599000 :   equal (tree_decl_map *a, tree_decl_map *b)
    5338                 :            :   {
    5339                 :  416599000 :     return tree_decl_map_eq (a, b);
    5340                 :            :   }
    5341                 :            : 
    5342                 :            :   static int
    5343                 :    3674680 :   keep_cache_entry (tree_decl_map *&m)
    5344                 :            :   {
    5345                 :    3674680 :     return ggc_marked_p (m->base.from);
    5346                 :            :   }
    5347                 :            : };
    5348                 :            : 
    5349                 :            : #define tree_int_map_eq tree_map_base_eq
    5350                 :            : #define tree_int_map_hash tree_map_base_hash
    5351                 :            : #define tree_int_map_marked_p tree_map_base_marked_p
    5352                 :            : 
    5353                 :            : #define tree_vec_map_eq tree_map_base_eq
    5354                 :            : #define tree_vec_map_hash tree_decl_map_hash
    5355                 :            : #define tree_vec_map_marked_p tree_map_base_marked_p
    5356                 :            : 
    5357                 :            : /* Hasher for tree decls.  Pointer equality is enough here, but the DECL_UID
    5358                 :            :    is a better hash than the pointer value and gives a predictable traversal
    5359                 :            :    order.  Additionally it can be used across PCH save/restore.  */
    5360                 :            : struct tree_decl_hash : ggc_ptr_hash <tree_node>
    5361                 :            : {
    5362                 :            :   static inline hashval_t hash (tree);
    5363                 :            : };
    5364                 :            : 
    5365                 :            : inline hashval_t
    5366                 :   32912669 : tree_decl_hash::hash (tree t)
    5367                 :            : {
    5368                 :   32912669 :   return DECL_UID (t);
    5369                 :            : }
    5370                 :            : 
    5371                 :            : /* Similarly for types.  Uses TYPE_UID as hash function.  */
    5372                 :            : struct tree_type_hash : ggc_ptr_hash <tree_node>
    5373                 :            : {
    5374                 :            :   static inline hashval_t hash (tree);
    5375                 :            : };
    5376                 :            : 
    5377                 :            : inline hashval_t
    5378                 :     238952 : tree_type_hash::hash (tree t)
    5379                 :            : {
    5380                 :     238952 :   return TYPE_UID (t);
    5381                 :            : }
    5382                 :            : 
    5383                 :            : /* Hash for SSA_NAMEs in the same function.  Pointer equality is enough
    5384                 :            :    here, but the SSA_NAME_VERSION is a better hash than the pointer
    5385                 :            :    value and gives a predictable traversal order.  */
    5386                 :            : struct tree_ssa_name_hash : ggc_ptr_hash <tree_node>
    5387                 :            : {
    5388                 :            :   static inline hashval_t hash (tree);
    5389                 :            : };
    5390                 :            : 
    5391                 :            : inline hashval_t
    5392                 :   36784657 : tree_ssa_name_hash::hash (tree t)
    5393                 :            : {
    5394                 :   36784657 :   return SSA_NAME_VERSION (t);
    5395                 :            : }
    5396                 :            : 
    5397                 :            : /* Hasher for general trees, based on their TREE_HASH.  */
    5398                 :            : struct tree_hash : ggc_ptr_hash <tree_node>
    5399                 :            : {
    5400                 :            :   static hashval_t hash (tree);
    5401                 :            : };
    5402                 :            : 
    5403                 :            : inline hashval_t
    5404                 :      38225 : tree_hash::hash (tree t)
    5405                 :            : {
    5406                 :      38225 :   return TREE_HASH (t);
    5407                 :            : }
    5408                 :            : 
    5409                 :            : /* A hash_map of two trees for use with GTY((cache)).  Garbage collection for
    5410                 :            :    such a map will not mark keys, and will mark values if the key is already
    5411                 :            :    marked.  */
    5412                 :            : struct tree_cache_traits
    5413                 :            :   : simple_cache_map_traits<default_hash_traits<tree>, tree> { };
    5414                 :            : typedef hash_map<tree,tree,tree_cache_traits> tree_cache_map;
    5415                 :            : 
    5416                 :            : /* Similarly, but use DECL_UID as hash function rather than pointer hashing.
    5417                 :            :    This is for hash_maps from decls to trees that need to work across PCH.  */
    5418                 :            : struct decl_tree_cache_traits
    5419                 :            :   : simple_cache_map_traits<tree_decl_hash, tree> { };
    5420                 :            : typedef hash_map<tree,tree,decl_tree_cache_traits> decl_tree_cache_map;
    5421                 :            : 
    5422                 :            : /* Similarly, but use TYPE_UID as hash function rather than pointer hashing.
    5423                 :            :    This is for hash_maps from types to trees that need to work across PCH.  */
    5424                 :            : struct type_tree_cache_traits
    5425                 :            :   : simple_cache_map_traits<tree_type_hash, tree> { };
    5426                 :            : typedef hash_map<tree,tree,type_tree_cache_traits> type_tree_cache_map;
    5427                 :            : 
    5428                 :            : /* Initialize the abstract argument list iterator object ITER with the
    5429                 :            :    arguments from CALL_EXPR node EXP.  */
    5430                 :            : static inline void
    5431                 :   34941057 : init_call_expr_arg_iterator (tree exp, call_expr_arg_iterator *iter)
    5432                 :            : {
    5433                 :   34941057 :   iter->t = exp;
    5434                 :   34941057 :   iter->n = call_expr_nargs (exp);
    5435                 :   34941057 :   iter->i = 0;
    5436                 :   34941057 : }
    5437                 :            : 
    5438                 :            : static inline void
    5439                 :     584150 : init_const_call_expr_arg_iterator (const_tree exp, const_call_expr_arg_iterator *iter)
    5440                 :            : {
    5441                 :     584150 :   iter->t = exp;
    5442                 :     584150 :   iter->n = call_expr_nargs (exp);
    5443                 :     584150 :   iter->i = 0;
    5444                 :     584150 : }
    5445                 :            : 
    5446                 :            : /* Return the next argument from abstract argument list iterator object ITER,
    5447                 :            :    and advance its state.  Return NULL_TREE if there are no more arguments.  */
    5448                 :            : static inline tree
    5449                 :   57726962 : next_call_expr_arg (call_expr_arg_iterator *iter)
    5450                 :            : {
    5451                 :   57726962 :   tree result;
    5452                 :   57726962 :   if (iter->i >= iter->n)
    5453                 :            :     return NULL_TREE;
    5454                 :   27163745 :   result = CALL_EXPR_ARG (iter->t, iter->i);
    5455                 :   27163745 :   iter->i++;
    5456                 :   27163745 :   return result;
    5457                 :            : }
    5458                 :            : 
    5459                 :            : static inline const_tree
    5460                 :    1195678 : next_const_call_expr_arg (const_call_expr_arg_iterator *iter)
    5461                 :            : {
    5462                 :    1195678 :   const_tree result;
    5463                 :    1195678 :   if (iter->i >= iter->n)
    5464                 :            :     return NULL_TREE;
    5465                 :     989933 :   result = CALL_EXPR_ARG (iter->t, iter->i);
    5466                 :     989933 :   iter->i++;
    5467                 :     989933 :   return result;
    5468                 :            : }
    5469                 :            : 
    5470                 :            : /* Initialize the abstract argument list iterator object ITER, then advance
    5471                 :            :    past and return the first argument.  Useful in for expressions, e.g.
    5472                 :            :      for (arg = first_call_expr_arg (exp, &iter); arg;
    5473                 :            :           arg = next_call_expr_arg (&iter))   */
    5474                 :            : static inline tree
    5475                 :   34941057 : first_call_expr_arg (tree exp, call_expr_arg_iterator *iter)
    5476                 :            : {
    5477                 :   34941057 :   init_call_expr_arg_iterator (exp, iter);
    5478                 :   34941057 :   return next_call_expr_arg (iter);
    5479                 :            : }
    5480                 :            : 
    5481                 :            : static inline const_tree
    5482                 :     257401 : first_const_call_expr_arg (const_tree exp, const_call_expr_arg_iterator *iter)
    5483                 :            : {
    5484                 :     257401 :   init_const_call_expr_arg_iterator (exp, iter);
    5485                 :     257401 :   return next_const_call_expr_arg (iter);
    5486                 :            : }
    5487                 :            : 
    5488                 :            : /* Test whether there are more arguments in abstract argument list iterator
    5489                 :            :    ITER, without changing its state.  */
    5490                 :            : static inline bool
    5491                 :      55528 : more_call_expr_args_p (const call_expr_arg_iterator *iter)
    5492                 :            : {
    5493                 :      55528 :   return (iter->i < iter->n);
    5494                 :            : }
    5495                 :            : 
    5496                 :            : /* Iterate through each argument ARG of CALL_EXPR CALL, using variable ITER
    5497                 :            :    (of type call_expr_arg_iterator) to hold the iteration state.  */
    5498                 :            : #define FOR_EACH_CALL_EXPR_ARG(arg, iter, call)                 \
    5499                 :            :   for ((arg) = first_call_expr_arg ((call), &(iter)); (arg);        \
    5500                 :            :        (arg) = next_call_expr_arg (&(iter)))
    5501                 :            : 
    5502                 :            : #define FOR_EACH_CONST_CALL_EXPR_ARG(arg, iter, call)                   \
    5503                 :            :   for ((arg) = first_const_call_expr_arg ((call), &(iter)); (arg);  \
    5504                 :            :        (arg) = next_const_call_expr_arg (&(iter)))
    5505                 :            : 
    5506                 :            : /* Return true if tree node T is a language-specific node.  */
    5507                 :            : static inline bool
    5508                 :   93009380 : is_lang_specific (const_tree t)
    5509                 :            : {
    5510                 :   93009380 :   return TREE_CODE (t) == LANG_TYPE || TREE_CODE (t) >= NUM_TREE_CODES;
    5511                 :            : }
    5512                 :            : 
    5513                 :            : /* Valid builtin number.  */
    5514                 :            : #define BUILTIN_VALID_P(FNCODE) \
    5515                 :            :   (IN_RANGE ((int)FNCODE, ((int)BUILT_IN_NONE) + 1, ((int) END_BUILTINS) - 1))
    5516                 :            : 
    5517                 :            : /* Return the tree node for an explicit standard builtin function or NULL.  */
    5518                 :            : static inline tree
    5519                 :   16227286 : builtin_decl_explicit (enum built_in_function fncode)
    5520                 :            : {
    5521                 :   15830281 :   gcc_checking_assert (BUILTIN_VALID_P (fncode));
    5522                 :            : 
    5523                 :   16212363 :   return builtin_info[(size_t)fncode].decl;
    5524                 :            : }
    5525                 :            : 
    5526                 :            : /* Return the tree node for an implicit builtin function or NULL.  */
    5527                 :            : static inline tree
    5528                 :     640344 : builtin_decl_implicit (enum built_in_function fncode)
    5529                 :            : {
    5530                 :     640344 :   size_t uns_fncode = (size_t)fncode;
    5531                 :     413286 :   gcc_checking_assert (BUILTIN_VALID_P (fncode));
    5532                 :            : 
    5533                 :     640344 :   if (!builtin_info[uns_fncode].implicit_p)
    5534                 :            :     return NULL_TREE;
    5535                 :            : 
    5536                 :     639250 :   return builtin_info[uns_fncode].decl;
    5537                 :            : }
    5538                 :            : 
    5539                 :            : /* Set explicit builtin function nodes and whether it is an implicit
    5540                 :            :    function.  */
    5541                 :            : 
    5542                 :            : static inline void
    5543                 :  176699918 : set_builtin_decl (enum built_in_function fncode, tree decl, bool implicit_p)
    5544                 :            : {
    5545                 :  176699918 :   size_t ufncode = (size_t)fncode;
    5546                 :            : 
    5547                 :  176699918 :   gcc_checking_assert (BUILTIN_VALID_P (fncode)
    5548                 :            :                        && (decl != NULL_TREE || !implicit_p));
    5549                 :            : 
    5550                 :  176699918 :   builtin_info[ufncode].decl = decl;
    5551                 :  176699918 :   builtin_info[ufncode].implicit_p = implicit_p;
    5552                 :  176699918 :   builtin_info[ufncode].declared_p = false;
    5553                 :  176698478 : }
    5554                 :            : 
    5555                 :            : /* Set the implicit flag for a builtin function.  */
    5556                 :            : 
    5557                 :            : static inline void
    5558                 :     567611 : set_builtin_decl_implicit_p (enum built_in_function fncode, bool implicit_p)
    5559                 :            : {
    5560                 :     567611 :   size_t uns_fncode = (size_t)fncode;
    5561                 :            : 
    5562                 :     567611 :   gcc_checking_assert (BUILTIN_VALID_P (fncode)
    5563                 :            :                        && builtin_info[uns_fncode].decl != NULL_TREE);
    5564                 :            : 
    5565                 :     567611 :   builtin_info[uns_fncode].implicit_p = implicit_p;
    5566                 :     567611 : }
    5567                 :            : 
    5568                 :            : /* Set the declared flag for a builtin function.  */
    5569                 :            : 
    5570                 :            : static inline void
    5571                 :    2095163 : set_builtin_decl_declared_p (enum built_in_function fncode, bool declared_p)
    5572                 :            : {
    5573                 :    2095163 :   size_t uns_fncode = (size_t)fncode;
    5574                 :            : 
    5575                 :    2095163 :   gcc_checking_assert (BUILTIN_VALID_P (fncode)
    5576                 :            :                        && builtin_info[uns_fncode].decl != NULL_TREE);
    5577                 :            : 
    5578                 :    2095163 :   builtin_info[uns_fncode].declared_p = declared_p;
    5579                 :    2095163 : }
    5580                 :            : 
    5581                 :            : /* Return whether the standard builtin function can be used as an explicit
    5582                 :            :    function.  */
    5583                 :            : 
    5584                 :            : static inline bool
    5585                 :    8667146 : builtin_decl_explicit_p (enum built_in_function fncode)
    5586                 :            : {
    5587                 :    8661734 :   gcc_checking_assert (BUILTIN_VALID_P (fncode));
    5588                 :    7577796 :   return (builtin_info[(size_t)fncode].decl != NULL_TREE);
    5589                 :            : }
    5590                 :            : 
    5591                 :            : /* Return whether the standard builtin function can be used implicitly.  */
    5592                 :            : 
    5593                 :            : static inline bool
    5594                 :      66095 : builtin_decl_implicit_p (enum built_in_function fncode)
    5595                 :            : {
    5596                 :      66095 :   size_t uns_fncode = (size_t)fncode;
    5597                 :            : 
    5598                 :      66095 :   gcc_checking_assert (BUILTIN_VALID_P (fncode));
    5599                 :      66095 :   return (builtin_info[uns_fncode].decl != NULL_TREE
    5600                 :      66095 :           && builtin_info[uns_fncode].implicit_p);
    5601                 :            : }
    5602                 :            : 
    5603                 :            : /* Return whether the standard builtin function was declared.  */
    5604                 :            : 
    5605                 :            : static inline bool
    5606                 :    2356860 : builtin_decl_declared_p (enum built_in_function fncode)
    5607                 :            : {
    5608                 :    2356860 :   size_t uns_fncode = (size_t)fncode;
    5609                 :            : 
    5610                 :    2356860 :   gcc_checking_assert (BUILTIN_VALID_P (fncode));
    5611                 :    2356860 :   return (builtin_info[uns_fncode].decl != NULL_TREE
    5612                 :    2356860 :           && builtin_info[uns_fncode].declared_p);
    5613                 :            : }
    5614                 :            : 
    5615                 :            : /* Determine if the function identified by FNDECL is one that
    5616                 :            :    makes sense to match by name, for those places where we detect
    5617                 :            :    "magic" functions by name.
    5618                 :            : 
    5619                 :            :    Return true if FNDECL has a name and is an extern fndecl at file scope.
    5620                 :            :    FNDECL must be a non-NULL decl.
    5621                 :            : 
    5622                 :            :    Avoid using this, as it's generally better to use attributes rather
    5623                 :            :    than to check for functions by name.  */
    5624                 :            : 
    5625                 :            : static inline bool
    5626                 : 1867390433 : maybe_special_function_p (const_tree fndecl)
    5627                 :            : {
    5628                 : 1867390433 :   tree name_decl = DECL_NAME (fndecl);
    5629                 : 1867390433 :   if (name_decl
    5630                 :            :       /* Exclude functions not at the file scope, or not `extern',
    5631                 :            :          since they are not the magic functions we would otherwise
    5632                 :            :          think they are.  */
    5633                 : 1867390433 :       && (DECL_CONTEXT (fndecl) == NULL_TREE
    5634                 :  940778571 :           || TREE_CODE (DECL_CONTEXT (fndecl)) == TRANSLATION_UNIT_DECL)
    5635                 : 3275488960 :       && TREE_PUBLIC (fndecl))
    5636                 : 1332065273 :     return true;
    5637                 :            :   return false;
    5638                 :            : }
    5639                 :            : 
    5640                 :            : /* Return true if T (assumed to be a DECL) is a global variable.
    5641                 :            :    A variable is considered global if its storage is not automatic.  */
    5642                 :            : 
    5643                 :            : static inline bool
    5644                 : 1442510566 : is_global_var (const_tree t)
    5645                 :            : {
    5646                 : 2755686936 :   return (TREE_STATIC (t) || DECL_EXTERNAL (t));
    5647                 :            : }
    5648                 :            : 
    5649                 :            : /* Return true if VAR may be aliased.  A variable is considered as
    5650                 :            :    maybe aliased if it has its address taken by the local TU
    5651                 :            :    or possibly by another TU and might be modified through a pointer.  */
    5652                 :            : 
    5653                 :            : static inline bool
    5654                 :  503129818 : may_be_aliased (const_tree var)
    5655                 :            : {
    5656                 :  503129818 :   return (TREE_CODE (var) != CONST_DECL
    5657                 :  502757808 :           && (TREE_PUBLIC (var)
    5658                 :  983512856 :               || DECL_EXTERNAL (var)
    5659                 :  480754628 :               || TREE_ADDRESSABLE (var))
    5660                 :  755430934 :           && !((TREE_STATIC (var) || TREE_PUBLIC (var) || DECL_EXTERNAL (var))
    5661                 :   28781033 :                && (TREE_READONLY (var)
    5662                 :   25807349 :                    || (TREE_CODE (var) == VAR_DECL
    5663                 :   53774710 :                        && DECL_NONALIASED (var)))));
    5664                 :            : }
    5665                 :            : 
    5666                 :            : /* Return pointer to optimization flags of FNDECL.  */
    5667                 :            : static inline struct cl_optimization *
    5668                 : 1431644799 : opts_for_fn (const_tree fndecl)
    5669                 :            : {
    5670                 : 1431644799 :   tree fn_opts = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (fndecl);
    5671                 : 1431644799 :   if (fn_opts == NULL_TREE)
    5672                 : 1347281939 :     fn_opts = optimization_default_node;
    5673                 : 1431644799 :   return TREE_OPTIMIZATION (fn_opts);
    5674                 :            : }
    5675                 :            : 
    5676                 :            : /* Return pointer to target flags of FNDECL.  */
    5677                 :            : static inline cl_target_option *
    5678                 :    3356208 : target_opts_for_fn (const_tree fndecl)
    5679                 :            : {
    5680                 :    3356208 :   tree fn_opts = DECL_FUNCTION_SPECIFIC_TARGET (fndecl);
    5681                 :    3356208 :   if (fn_opts == NULL_TREE)
    5682                 :    1837782 :     fn_opts = target_option_default_node;
    5683                 :    6712410 :   return fn_opts == NULL_TREE ? NULL : TREE_TARGET_OPTION (fn_opts);
    5684                 :            : }
    5685                 :            : 
    5686                 :            : /* opt flag for function FNDECL, e.g. opts_for_fn (fndecl, optimize) is
    5687                 :            :    the optimization level of function fndecl.  */
    5688                 :            : #define opt_for_fn(fndecl, opt) (opts_for_fn (fndecl)->x_##opt)
    5689                 :            : 
    5690                 :            : /* For anonymous aggregate types, we need some sort of name to
    5691                 :            :    hold on to.  In practice, this should not appear, but it should
    5692                 :            :    not be harmful if it does.  Identifiers returned will be
    5693                 :            :    IDENTIFIER_ANON_P.  */
    5694                 :            : extern tree make_anon_name ();
    5695                 :            : 
    5696                 :            : /* The tree and const_tree overload templates.   */
    5697                 :            : namespace wi
    5698                 :            : {
    5699                 :            :   class unextended_tree
    5700                 :            :   {
    5701                 :            :   private:
    5702                 :            :     const_tree m_t;
    5703                 :            : 
    5704                 :            :   public:
    5705                 :            :     unextended_tree () {}
    5706                 :  966022705 :     unextended_tree (const_tree t) : m_t (t) {}
    5707                 :            : 
    5708                 :            :     unsigned int get_precision () const;
    5709                 :            :     const HOST_WIDE_INT *get_val () const;
    5710                 :            :     unsigned int get_len () const;
    5711                 :            :     const_tree get_tree () const { return m_t; }
    5712                 :            :   };
    5713                 :            : 
    5714                 :            :   template <>
    5715                 :            :   struct int_traits <unextended_tree>
    5716                 :            :   {
    5717                 :            :     static const enum precision_type precision_type = VAR_PRECISION;
    5718                 :            :     static const bool host_dependent_precision = false;
    5719                 :            :     static const bool is_sign_extended = false;
    5720                 :            :   };
    5721                 :            : 
    5722                 :            :   template <int N>
    5723                 :            :   class extended_tree
    5724                 :            :   {
    5725                 :            :   private:
    5726                 :            :     const_tree m_t;
    5727                 :            : 
    5728                 :            :   public:
    5729                 :            :     extended_tree () {}
    5730                 :            :     extended_tree (const_tree);
    5731                 :            : 
    5732                 :            :     unsigned int get_precision () const;
    5733                 :            :     const HOST_WIDE_INT *get_val () const;
    5734                 :            :     unsigned int get_len () const;
    5735                 :            :     const_tree get_tree () const { return m_t; }
    5736                 :            :   };
    5737                 :            : 
    5738                 :            :   template <int N>
    5739                 :            :   struct int_traits <extended_tree <N> >
    5740                 :            :   {
    5741                 :            :     static const enum precision_type precision_type = CONST_PRECISION;
    5742                 :            :     static const bool host_dependent_precision = false;
    5743                 :            :     static const bool is_sign_extended = true;
    5744                 :            :     static const unsigned int precision = N;
    5745                 :            :   };
    5746                 :            : 
    5747                 :            :   typedef extended_tree <WIDE_INT_MAX_PRECISION> widest_extended_tree;
    5748                 :            :   typedef extended_tree <ADDR_MAX_PRECISION> offset_extended_tree;
    5749                 :            : 
    5750                 :            :   typedef const generic_wide_int <widest_extended_tree> tree_to_widest_ref;
    5751                 :            :   typedef const generic_wide_int <offset_extended_tree> tree_to_offset_ref;
    5752                 :            :   typedef const generic_wide_int<wide_int_ref_storage<false, false> >
    5753                 :            :     tree_to_wide_ref;
    5754                 :            : 
    5755                 :            :   tree_to_widest_ref to_widest (const_tree);
    5756                 :            :   tree_to_offset_ref to_offset (const_tree);
    5757                 :            :   tree_to_wide_ref to_wide (const_tree);
    5758                 :            :   wide_int to_wide (const_tree, unsigned int);
    5759                 :            : 
    5760                 :            :   typedef const poly_int <NUM_POLY_INT_COEFFS,
    5761                 :            :                           generic_wide_int <widest_extended_tree> >
    5762                 :            :     tree_to_poly_widest_ref;
    5763                 :            :   typedef const poly_int <NUM_POLY_INT_COEFFS,
    5764                 :            :                           generic_wide_int <offset_extended_tree> >
    5765                 :            :     tree_to_poly_offset_ref;
    5766                 :            :   typedef const poly_int <NUM_POLY_INT_COEFFS,
    5767                 :            :                           generic_wide_int <unextended_tree> >
    5768                 :            :     tree_to_poly_wide_ref;
    5769                 :            : 
    5770                 :            :   tree_to_poly_widest_ref to_poly_widest (const_tree);
    5771                 :            :   tree_to_poly_offset_ref to_poly_offset (const_tree);
    5772                 :            :   tree_to_poly_wide_ref to_poly_wide (const_tree);
    5773                 :            : 
    5774                 :            :   template <int N>
    5775                 :            :   struct ints_for <generic_wide_int <extended_tree <N> >, CONST_PRECISION>
    5776                 :            :   {
    5777                 :            :     typedef generic_wide_int <extended_tree <N> > extended;
    5778                 :            :     static extended zero (const extended &);
    5779                 :            :   };
    5780                 :            : 
    5781                 :            :   template <>
    5782                 :            :   struct ints_for <generic_wide_int <unextended_tree>, VAR_PRECISION>
    5783                 :            :   {
    5784                 :            :     typedef generic_wide_int <unextended_tree> unextended;
    5785                 :            :     static unextended zero (const unextended &);
    5786                 :            :   };
    5787                 :            : }
    5788                 :            : 
    5789                 :            : /* Used to convert a tree to a widest2_int like this:
    5790                 :            :    widest2_int foo = widest2_int_cst (some_tree).  */
    5791                 :            : typedef generic_wide_int <wi::extended_tree <WIDE_INT_MAX_PRECISION * 2> >
    5792                 :            :   widest2_int_cst;
    5793                 :            : 
    5794                 :            : /* Refer to INTEGER_CST T as though it were a widest_int.
    5795                 :            : 
    5796                 :            :    This function gives T's actual numerical value, influenced by the
    5797                 :            :    signedness of its type.  For example, a signed byte with just the
    5798                 :            :    top bit set would be -128 while an unsigned byte with the same
    5799                 :            :    bit pattern would be 128.
    5800                 :            : 
    5801                 :            :    This is the right choice when operating on groups of INTEGER_CSTs
    5802                 :            :    that might have different signedness or precision.  It is also the
    5803                 :            :    right choice in code that specifically needs an approximation of
    5804                 :            :    infinite-precision arithmetic instead of normal modulo arithmetic.
    5805                 :            : 
    5806                 :            :    The approximation of infinite precision is good enough for realistic
    5807                 :            :    numbers of additions and subtractions of INTEGER_CSTs (where
    5808                 :            :    "realistic" includes any number less than 1 << 31) but it cannot
    5809                 :            :    represent the result of multiplying the two largest supported
    5810                 :            :    INTEGER_CSTs.  The overflow-checking form of wi::mul provides a way
    5811                 :            :    of multiplying two arbitrary INTEGER_CSTs and checking that the
    5812                 :            :    result is representable as a widest_int.
    5813                 :            : 
    5814                 :            :    Note that any overflow checking done on these values is relative to
    5815                 :            :    the range of widest_int rather than the range of a TREE_TYPE.
    5816                 :            : 
    5817                 :            :    Calling this function should have no overhead in release builds,
    5818                 :            :    so it is OK to call it several times for the same tree.  If it is
    5819                 :            :    useful for readability reasons to reduce the number of calls,
    5820                 :            :    it is more efficient to use:
    5821                 :            : 
    5822                 :            :      wi::tree_to_widest_ref wt = wi::to_widest (t);
    5823                 :            : 
    5824                 :            :    instead of:
    5825                 :            : 
    5826                 :            :      widest_int wt = wi::to_widest (t).  */
    5827                 :            : 
    5828                 :            : inline wi::tree_to_widest_ref
    5829                 : 2499614867 : wi::to_widest (const_tree t)
    5830                 :            : {
    5831                 : 6731011776 :   return t;
    5832                 :            : }
    5833                 :            : 
    5834                 :            : /* Refer to INTEGER_CST T as though it were an offset_int.
    5835                 :            : 
    5836                 :            :    This function is an optimisation of wi::to_widest for cases
    5837                 :            :    in which T is known to be a bit or byte count in the range
    5838                 :            :    (-(2 ^ (N + BITS_PER_UNIT)), 2 ^ (N + BITS_PER_UNIT)), where N is
    5839                 :            :    the target's address size in bits.
    5840                 :            : 
    5841                 :            :    This is the right choice when operating on bit or byte counts as
    5842                 :            :    untyped numbers rather than M-bit values.  The wi::to_widest comments
    5843                 :            :    about addition, subtraction and multiplication apply here: sequences
    5844                 :            :    of 1 << 31 additions and subtractions do not induce overflow, but
    5845                 :            :    multiplying the largest sizes might.  Again,
    5846                 :            : 
    5847                 :            :      wi::tree_to_offset_ref wt = wi::to_offset (t);
    5848                 :            : 
    5849                 :            :    is more efficient than:
    5850                 :            : 
    5851                 :            :      offset_int wt = wi::to_offset (t).  */
    5852                 :            : 
    5853                 :            : inline wi::tree_to_offset_ref
    5854                 : 2279854253 : wi::to_offset (const_tree t)
    5855                 :            : {
    5856                 : 2341677282 :   return t;
    5857                 :            : }
    5858                 :            : 
    5859                 :            : /* Refer to INTEGER_CST T as though it were a wide_int.
    5860                 :            : 
    5861                 :            :    In contrast to the approximation of infinite-precision numbers given
    5862                 :            :    by wi::to_widest and wi::to_offset, this function treats T as a
    5863                 :            :    signless collection of N bits, where N is the precision of T's type.
    5864                 :            :    As with machine registers, signedness is determined by the operation
    5865                 :            :    rather than the operands; for example, there is a distinction between
    5866                 :            :    signed and unsigned division.
    5867                 :            : 
    5868                 :            :    This is the right choice when operating on values with the same type
    5869                 :            :    using normal modulo arithmetic.  The overflow-checking forms of things
    5870                 :            :    like wi::add check whether the result can be represented in T's type.
    5871                 :            : 
    5872                 :            :    Calling this function should have no overhead in release builds,
    5873                 :            :    so it is OK to call it several times for the same tree.  If it is
    5874                 :            :    useful for readability reasons to reduce the number of calls,
    5875                 :            :    it is more efficient to use:
    5876                 :            : 
    5877                 :            :      wi::tree_to_wide_ref wt = wi::to_wide (t);
    5878                 :            : 
    5879                 :            :    instead of:
    5880                 :            : 
    5881                 :            :      wide_int wt = wi::to_wide (t).  */
    5882                 :            : 
    5883                 :            : inline wi::tree_to_wide_ref
    5884                 : 4808231833 : wi::to_wide (const_tree t)
    5885                 :            : {
    5886                 : 9616468498 :   return wi::storage_ref (&TREE_INT_CST_ELT (t, 0), TREE_INT_CST_NUNITS (t),
    5887                 : 4808231833 :                           TYPE_PRECISION (TREE_TYPE (t)));
    5888                 :            : }
    5889                 :            : 
    5890                 :            : /* Convert INTEGER_CST T to a wide_int of precision PREC, extending or
    5891                 :            :    truncating as necessary.  When extending, use sign extension if T's
    5892                 :            :    type is signed and zero extension if T's type is unsigned.  */
    5893                 :            : 
    5894                 :            : inline wide_int
    5895                 :  472063757 : wi::to_wide (const_tree t, unsigned int prec)
    5896                 :            : {
    5897                 :  472063757 :   return wide_int::from (wi::to_wide (t), prec, TYPE_SIGN (TREE_TYPE (t)));
    5898                 :            : }
    5899                 :            : 
    5900                 :            : template <int N>
    5901                 :14639307528 : inline wi::extended_tree <N>::extended_tree (const_tree t)
    5902                 :14639307528 :   : m_t (t)
    5903                 :            : {
    5904                 :14639307528 :   gcc_checking_assert (TYPE_PRECISION (TREE_TYPE (t)) <= N);
    5905                 :14639307528 : }
    5906                 :            : 
    5907                 :            : template <int N>
    5908                 :            : inline unsigned int
    5909                 :17705066850 : wi::extended_tree <N>::get_precision () const
    5910                 :            : {
    5911                 :            :   return N;
    5912                 :            : }
    5913                 :            : 
    5914                 :            : template <int N>
    5915                 :            : inline const HOST_WIDE_INT *
    5916                 :14662372691 : wi::extended_tree <N>::get_val () const
    5917                 :            : {
    5918                 :14662372691 :   return &TREE_INT_CST_ELT (m_t, 0);
    5919                 :            : }
    5920                 :            : 
    5921                 :            : template <int N>
    5922                 :            : inline unsigned int
    5923                 :14664844953 : wi::extended_tree <N>::get_len () const
    5924                 :            : {
    5925                 :            :   if (N == ADDR_MAX_PRECISION)
    5926                 : 6650149779 :     return TREE_INT_CST_OFFSET_NUNITS (m_t);
    5927                 :            :   else if (N >= WIDE_INT_MAX_PRECISION)
    5928                 : 8013840513 :     return TREE_INT_CST_EXT_NUNITS (m_t);
    5929                 :            :   else
    5930                 :            :     /* This class is designed to be used for specific output precisions
    5931                 :            :        and needs to be as fast as possible, so there is no fallback for
    5932                 :            :        other casees.  */
    5933                 :            :     gcc_unreachable ();
    5934                 :            : }
    5935                 :            : 
    5936                 :            : inline unsigned int
    5937                 :            : wi::unextended_tree::get_precision () const
    5938                 :            : {
    5939                 :            :   return TYPE_PRECISION (TREE_TYPE (m_t));
    5940                 :            : }
    5941                 :            : 
    5942                 :            : inline const HOST_WIDE_INT *
    5943                 :  977860475 : wi::unextended_tree::get_val () const
    5944                 :            : {
    5945                 :  977860475 :   return &TREE_INT_CST_ELT (m_t, 0);
    5946                 :            : }
    5947                 :            : 
    5948                 :            : inline unsigned int
    5949                 :  977860475 : wi::unextended_tree::get_len () const
    5950                 :            : {
    5951                 :  977860475 :   return TREE_INT_CST_NUNITS (m_t);
    5952                 :            : }
    5953                 :            : 
    5954                 :            : /* Return the value of a POLY_INT_CST in its native precision.  */
    5955                 :            : 
    5956                 :            : inline wi::tree_to_poly_wide_ref
    5957                 :          0 : poly_int_cst_value (const_tree x)
    5958                 :            : {
    5959                 :          0 :   poly_int <NUM_POLY_INT_COEFFS, generic_wide_int <wi::unextended_tree> > res;
    5960                 :          0 :   for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
    5961                 :          0 :     res.coeffs[i] = POLY_INT_CST_COEFF (x, i);
    5962                 :          0 :   return res;
    5963                 :            : }
    5964                 :            : 
    5965                 :            : /* Access INTEGER_CST or POLY_INT_CST tree T as if it were a
    5966                 :            :    poly_widest_int.  See wi::to_widest for more details.  */
    5967                 :            : 
    5968                 :            : inline wi::tree_to_poly_widest_ref
    5969                 :   21224956 : wi::to_poly_widest (const_tree t)
    5970                 :            : {
    5971                 :   21224956 :   if (POLY_INT_CST_P (t))
    5972                 :            :     {
    5973                 :            :       poly_int <NUM_POLY_INT_COEFFS,
    5974                 :            :                 generic_wide_int <widest_extended_tree> > res;
    5975                 :            :       for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
    5976                 :            :         res.coeffs[i] = POLY_INT_CST_COEFF (t, i);
    5977                 :            :       return res;
    5978                 :            :     }
    5979                 :   21224956 :   return t;
    5980                 :            : }
    5981                 :            : 
    5982                 :            : /* Access INTEGER_CST or POLY_INT_CST tree T as if it were a
    5983                 :            :    poly_offset_int.  See wi::to_offset for more details.  */
    5984                 :            : 
    5985                 :            : inline wi::tree_to_poly_offset_ref
    5986                 : 4355388282 : wi::to_poly_offset (const_tree t)
    5987                 :            : {
    5988                 :  956613339 :   if (POLY_INT_CST_P (t))
    5989                 :            :     {
    5990                 :            :       poly_int <NUM_POLY_INT_COEFFS,
    5991                 :            :                 generic_wide_int <offset_extended_tree> > res;
    5992                 :            :       for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
    5993                 :            :         res.coeffs[i] = POLY_INT_CST_COEFF (t, i);
    5994                 :            :       return res;
    5995                 :            :     }
    5996                 : 3919137720 :   return t;
    5997                 :            : }
    5998                 :            : 
    5999                 :            : /* Access INTEGER_CST or POLY_INT_CST tree T as if it were a
    6000                 :            :    poly_wide_int.  See wi::to_wide for more details.  */
    6001                 :            : 
    6002                 :            : inline wi::tree_to_poly_wide_ref
    6003                 :  966022705 : wi::to_poly_wide (const_tree t)
    6004                 :            : {
    6005                 :  966022705 :   if (POLY_INT_CST_P (t))
    6006                 :            :     return poly_int_cst_value (t);
    6007                 :  966022705 :   return t;
    6008                 :            : }
    6009                 :            : 
    6010                 :            : template <int N>
    6011                 :            : inline generic_wide_int <wi::extended_tree <N> >
    6012                 :            : wi::ints_for <generic_wide_int <wi::extended_tree <N> >,
    6013                 :            :               wi::CONST_PRECISION>::zero (const extended &x)
    6014                 :            : {
    6015                 :            :   return build_zero_cst (TREE_TYPE (x.get_tree ()));
    6016                 :            : }
    6017                 :            : 
    6018                 :            : inline generic_wide_int <wi::unextended_tree>
    6019                 :            : wi::ints_for <generic_wide_int <wi::unextended_tree>,
    6020                 :            :               wi::VAR_PRECISION>::zero (const unextended &x)
    6021                 :            : {
    6022                 :            :   return build_zero_cst (TREE_TYPE (x.get_tree ()));
    6023                 :            : }
    6024                 :            : 
    6025                 :            : namespace wi
    6026                 :            : {
    6027                 :            :   template <typename T>
    6028                 :            :   bool fits_to_boolean_p (const T &x, const_tree);
    6029                 :            : 
    6030                 :            :   template <typename T>
    6031                 :            :   bool fits_to_tree_p (const T &x, const_tree);
    6032                 :            : 
    6033                 :            :   wide_int min_value (const_tree);
    6034                 :            :   wide_int max_value (const_tree);
    6035                 :            :   wide_int from_mpz (const_tree, mpz_t, bool);
    6036                 :            : }
    6037                 :            : 
    6038                 :            : template <typename T>
    6039                 :            : bool
    6040                 :    3071832 : wi::fits_to_boolean_p (const T &x, const_tree type)
    6041                 :            : {
    6042                 :            :   typedef typename poly_int_traits<T>::int_type int_type;
    6043                 :    3221904 :   return (known_eq (x, int_type (0))
    6044                 :    3804175 :           || known_eq (x, int_type (TYPE_UNSIGNED (type) ? 1 : -1)));
    6045                 :            : }
    6046                 :            : 
    6047                 :            : template <typename T>
    6048                 :            : bool
    6049                 :  819550286 : wi::fits_to_tree_p (const T &x, const_tree type)
    6050                 :            : {
    6051                 :            :   /* Non-standard boolean types can have arbitrary precision but various
    6052                 :            :      transformations assume that they can only take values 0 and +/-1.  */
    6053                 :  819550286 :   if (TREE_CODE (type) == BOOLEAN_TYPE)
    6054                 :    2540319 :     return fits_to_boolean_p (x, type);
    6055                 :            : 
    6056                 :  817010110 :   if (TYPE_UNSIGNED (type))
    6057                 :  722276652 :     return known_eq (x, zext (x, TYPE_PRECISION (type)));
    6058                 :            :   else
    6059                 :  101108940 :     return known_eq (x, sext (x, TYPE_PRECISION (type)));
    6060                 :            : }
    6061                 :            : 
    6062                 :            : /* Produce the smallest number that is represented in TYPE.  The precision
    6063                 :            :    and sign are taken from TYPE.  */
    6064                 :            : inline wide_int
    6065                 :   41604588 : wi::min_value (const_tree type)
    6066                 :            : {
    6067                 :   41604588 :   return min_value (TYPE_PRECISION (type), TYPE_SIGN (type));
    6068                 :            : }
    6069                 :            : 
    6070                 :            : /* Produce the largest number that is represented in TYPE.  The precision
    6071                 :            :    and sign are taken from TYPE.  */
    6072                 :            : inline wide_int
    6073                 :   41601062 : wi::max_value (const_tree type)
    6074                 :            : {
    6075                 :   41601062 :   return max_value (TYPE_PRECISION (type), TYPE_SIGN (type));
    6076                 :            : }
    6077                 :            : 
    6078                 :            : /* Return true if INTEGER_CST T1 is less than INTEGER_CST T2,
    6079                 :            :    extending both according to their respective TYPE_SIGNs.  */
    6080                 :            : 
    6081                 :            : inline bool
    6082                 :  808912350 : tree_int_cst_lt (const_tree t1, const_tree t2)
    6083                 :            : {
    6084                 :  808912350 :   return wi::to_widest (t1) < wi::to_widest (t2);
    6085                 :            : }
    6086                 :            : 
    6087                 :            : /* Return true if INTEGER_CST T1 is less than or equal to INTEGER_CST T2,
    6088                 :            :    extending both according to their respective TYPE_SIGNs.  */
    6089                 :            : 
    6090                 :            : inline bool
    6091                 :     243003 : tree_int_cst_le (const_tree t1, const_tree t2)
    6092                 :            : {
    6093                 :     243003 :   return wi::to_widest (t1) <= wi::to_widest (t2);
    6094                 :            : }
    6095                 :            : 
    6096                 :            : /* Returns -1 if T1 < T2, 0 if T1 == T2, and 1 if T1 > T2.  T1 and T2
    6097                 :            :    are both INTEGER_CSTs and their values are extended according to their
    6098                 :            :    respective TYPE_SIGNs.  */
    6099                 :            : 
    6100                 :            : inline int
    6101                 :  573747405 : tree_int_cst_compare (const_tree t1, const_tree t2)
    6102                 :            : {
    6103                 :  573747405 :   return wi::cmps (wi::to_widest (t1), wi::to_widest (t2));
    6104                 :            : }
    6105                 :            : 
    6106                 :            : /* FIXME - These declarations belong in builtins.h, expr.h and emit-rtl.h,
    6107                 :            :    but none of these files are allowed to be included from front ends.
    6108                 :            :    They should be split in two. One suitable for the FEs, the other suitable
    6109                 :            :    for the BE.  */
    6110                 :            : 
    6111                 :            : /* Assign the RTX to declaration.  */
    6112                 :            : extern void set_decl_rtl (tree, rtx);
    6113                 :            : extern bool complete_ctor_at_level_p (const_tree, HOST_WIDE_INT, const_tree);
    6114                 :            : 
    6115                 :            : /* Given an expression EXP that is a handled_component_p,
    6116                 :            :    look for the ultimate containing object, which is returned and specify
    6117                 :            :    the access position and size.  */
    6118                 :            : extern tree get_inner_reference (tree, poly_int64_pod *, poly_int64_pod *,
    6119                 :            :                                  tree *, machine_mode *, int *, int *, int *);
    6120                 :            : 
    6121                 :            : extern tree build_personality_function (const char *);
    6122                 :            : 
    6123                 :            : struct GTY(()) int_n_trees_t {
    6124                 :            :   /* These parts are initialized at runtime */
    6125                 :            :   tree signed_type;
    6126                 :            :   tree unsigned_type;
    6127                 :            : };
    6128                 :            : 
    6129                 :            : /* This is also in machmode.h */
    6130                 :            : extern bool int_n_enabled_p[NUM_INT_N_ENTS];
    6131                 :            : extern GTY(()) struct int_n_trees_t int_n_trees[NUM_INT_N_ENTS];
    6132                 :            : 
    6133                 :            : /* Like bit_position, but return as an integer.  It must be representable in
    6134                 :            :    that way (since it could be a signed value, we don't have the
    6135                 :            :    option of returning -1 like int_size_in_byte can.  */
    6136                 :            : 
    6137                 :            : inline HOST_WIDE_INT
    6138                 :   29498552 : int_bit_position (const_tree field)
    6139                 :            : {
    6140                 :   58997100 :   return ((wi::to_offset (DECL_FIELD_OFFSET (field)) << LOG2_BITS_PER_UNIT)
    6141                 :   29498552 :           + wi::to_offset (DECL_FIELD_BIT_OFFSET (field))).to_shwi ();
    6142                 :            : }
    6143                 :            : 
    6144                 :            : /* Return true if it makes sense to consider alias set for a type T.  */
    6145                 :            : 
    6146                 :            : inline bool
    6147                 :   27975060 : type_with_alias_set_p (const_tree t)
    6148                 :            : {
    6149                 :            :   /* Function and method types are never accessed as memory locations.  */
    6150                 :   27975060 :   if (TREE_CODE (t) == FUNCTION_TYPE || TREE_CODE (t) == METHOD_TYPE)
    6151                 :            :     return false;
    6152                 :            : 
    6153                 :   27772284 :   if (COMPLETE_TYPE_P (t))
    6154                 :            :     return true;
    6155                 :            : 
    6156                 :            :   /* Incomplete types cannot be accessed in general except for arrays
    6157                 :            :      where we can fetch its element despite we have no array bounds.  */
    6158                 :    1050412 :   if (TREE_CODE (t) == ARRAY_TYPE && COMPLETE_TYPE_P (TREE_TYPE (t)))
    6159                 :      25940 :     return true;
    6160                 :            : 
    6161                 :            :   return false;
    6162                 :            : }
    6163                 :            : 
    6164                 :            : extern location_t set_block (location_t loc, tree block);
    6165                 :            : 
    6166                 :            : extern void gt_ggc_mx (tree &);
    6167                 :            : extern void gt_pch_nx (tree &);
    6168                 :            : extern void gt_pch_nx (tree &, gt_pointer_operator, void *);
    6169                 :            : 
    6170                 :            : extern bool nonnull_arg_p (const_tree);
    6171                 :            : extern bool default_is_empty_record (const_tree);
    6172                 :            : extern bool flexible_array_type_p (const_tree);
    6173                 :            : extern HOST_WIDE_INT arg_int_size_in_bytes (const_tree);
    6174                 :            : extern tree arg_size_in_bytes (const_tree);
    6175                 :            : extern bool expr_type_first_operand_type_p (tree_code);
    6176                 :            : 
    6177                 :            : extern location_t
    6178                 :            : set_source_range (tree expr, location_t start, location_t finish);
    6179                 :            : 
    6180                 :            : extern location_t
    6181                 :            : set_source_range (tree expr, source_range src_range);
    6182                 :            : 
    6183                 :            : /* Return true if it makes sense to promote/demote from_type to to_type. */
    6184                 :            : inline bool
    6185                 :     165123 : desired_pro_or_demotion_p (const_tree to_type, const_tree from_type)
    6186                 :            : {
    6187                 :     165123 :   unsigned int to_type_precision = TYPE_PRECISION (to_type);
    6188                 :            : 
    6189                 :            :   /* OK to promote if to_type is no bigger than word_mode. */
    6190                 :     165123 :   if (to_type_precision <= GET_MODE_PRECISION (word_mode))
    6191                 :            :     return true;
    6192                 :            : 
    6193                 :            :   /* Otherwise, allow only if narrowing or same precision conversions. */
    6194                 :      16172 :   return to_type_precision <= TYPE_PRECISION (from_type);
    6195                 :            : }
    6196                 :            : 
    6197                 :            : /* Pointer type used to declare builtins before we have seen its real
    6198                 :            :    declaration.  */
    6199                 :            : class builtin_structptr_type
    6200                 :            : {
    6201                 :            : public:
    6202                 :            :   tree& node;
    6203                 :            :   tree& base;
    6204                 :            :   const char *str;
    6205                 :            : };
    6206                 :            : extern const builtin_structptr_type builtin_structptr_types[6];
    6207                 :            : 
    6208                 :            : /* Return true if type T has the same precision as its underlying mode.  */
    6209                 :            : 
    6210                 :            : inline bool
    6211                 :  140790746 : type_has_mode_precision_p (const_tree t)
    6212                 :            : {
    6213                 :  140790746 :   return known_eq (TYPE_PRECISION (t), GET_MODE_PRECISION (TYPE_MODE (t)));
    6214                 :            : }
    6215                 :            : 
    6216                 :            : /* Return true if a FUNCTION_DECL NODE is a GCC built-in function.
    6217                 :            : 
    6218                 :            :    Note that it is different from the DECL_IS_BUILTIN accessor.  For
    6219                 :            :    instance, user declared prototypes of C library functions are not
    6220                 :            :    DECL_IS_BUILTIN but may be fndecl_built_in_p.  */
    6221                 :            : 
    6222                 :            : inline bool
    6223                 : 1839130424 : fndecl_built_in_p (const_tree node)
    6224                 :            : {
    6225                 : 1839130424 :   return DECL_BUILT_IN_CLASS (node) != NOT_BUILT_IN;
    6226                 :            : }
    6227                 :            : 
    6228                 :            : /* Return true if a FUNCTION_DECL NODE is a GCC built-in function
    6229                 :            :    of class KLASS.  */
    6230                 :            : 
    6231                 :            : inline bool
    6232                 : 1485275256 : fndecl_built_in_p (const_tree node, built_in_class klass)
    6233                 :            : {
    6234                 : 1900611260 :   return fndecl_built_in_p (node) && DECL_BUILT_IN_CLASS (node) == klass;
    6235                 :            : }
    6236                 :            : 
    6237                 :            : /* Return true if a FUNCTION_DECL NODE is a GCC built-in function
    6238                 :            :    of class KLASS with name equal to NAME.  */
    6239                 :            : 
    6240                 :            : inline bool
    6241                 :   85594644 : fndecl_built_in_p (const_tree node, unsigned int name, built_in_class klass)
    6242                 :            : {
    6243                 :   85594644 :   return (fndecl_built_in_p (node, klass)
    6244                 :   85693285 :           && DECL_UNCHECKED_FUNCTION_CODE (node) == name);
    6245                 :            : }
    6246                 :            : 
    6247                 :            : /* Return true if a FUNCTION_DECL NODE is a GCC built-in function
    6248                 :            :    of BUILT_IN_NORMAL class with name equal to NAME.  */
    6249                 :            : 
    6250                 :            : inline bool
    6251                 :  586736934 : fndecl_built_in_p (const_tree node, built_in_function name)
    6252                 :            : {
    6253                 :  586736934 :   return (fndecl_built_in_p (node, BUILT_IN_NORMAL)
    6254                 :  586736934 :           && DECL_FUNCTION_CODE (node) == name);
    6255                 :            : }
    6256                 :            : 
    6257                 :            : /* A struct for encapsulating location information about an operator
    6258                 :            :    and the operation built from it.
    6259                 :            : 
    6260                 :            :    m_operator_loc is the location of the operator
    6261                 :            :    m_combined_loc is the location of the compound expression.
    6262                 :            : 
    6263                 :            :    For example, given "a && b" the, operator location is:
    6264                 :            :       a && b
    6265                 :            :         ^~
    6266                 :            :    and the combined location is:
    6267                 :            :       a && b
    6268                 :            :       ~~^~~~
    6269                 :            :    Capturing this information allows for class binary_op_rich_location
    6270                 :            :    to provide detailed information about e.g. type mismatches in binary
    6271                 :            :    operations where enough location information is available:
    6272                 :            : 
    6273                 :            :      arg_0 op arg_1
    6274                 :            :      ~~~~~ ^~ ~~~~~
    6275                 :            :        |        |
    6276                 :            :        |        arg1 type
    6277                 :            :        arg0 type
    6278                 :            : 
    6279                 :            :    falling back to just showing the combined location:
    6280                 :            : 
    6281                 :            :      arg_0 op arg_1
    6282                 :            :      ~~~~~~^~~~~~~~
    6283                 :            : 
    6284                 :            :    where it is not.  */
    6285                 :            : 
    6286                 :            : class op_location_t
    6287                 :            : {
    6288                 :            : public:
    6289                 :            :   location_t m_operator_loc;
    6290                 :            :   location_t m_combined_loc;
    6291                 :            : 
    6292                 :            :   /* 1-argument ctor, for constructing from a combined location.  */
    6293                 :   21669177 :   op_location_t (location_t combined_loc)
    6294                 :   21629281 :   : m_operator_loc (UNKNOWN_LOCATION), m_combined_loc (combined_loc)
    6295                 :            :   {}
    6296                 :            : 
    6297                 :            :   /* 2-argument ctor, for distinguishing between the operator's location
    6298                 :            :      and the combined location.  */
    6299                 :    9709201 :   op_location_t (location_t operator_loc, location_t combined_loc)
    6300                 :    9709201 :   : m_operator_loc (operator_loc), m_combined_loc (combined_loc)
    6301                 :            :   {}
    6302                 :            : 
    6303                 :            :   /* Implicitly convert back to a location_t, using the combined location.  */
    6304                 :   38073216 :   operator location_t () const { return m_combined_loc; }
    6305                 :            : };
    6306                 :            : 
    6307                 :            : #endif  /* GCC_TREE_H  */

Generated by: LCOV version 1.0

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 --enable-host-shared. GCC test suite is run with the built compiler.