GCC Middle and Back End API Reference
tree.h File Reference
#include "tree-core.h"
#include "options.h"
#include "tree-check.h"
Include dependency graph for tree.h:

Go to the source code of this file.

Data Structures

class  code_helper
 
class  auto_suppress_location_wrappers
 
class  tree_vec_range
 
struct  tree_decl_map_cache_hasher
 
struct  tree_vec_map_cache_hasher
 
struct  tree_decl_hash
 
struct  tree_type_hash
 
struct  tree_ssa_name_hash
 
struct  tree_hash
 
class  wi::unextended_tree
 
struct  wi::int_traits< unextended_tree >
 
class  wi::extended_tree< N >
 
struct  wi::int_traits< extended_tree< N > >
 
struct  wi::ints_for< generic_wide_int< extended_tree< N > >, INL_CONST_PRECISION >
 
struct  wi::ints_for< generic_wide_int< extended_tree< N > >, CONST_PRECISION >
 
struct  wi::ints_for< generic_wide_int< unextended_tree >, VAR_PRECISION >
 
struct  int_n_trees_t
 
class  builtin_structptr_type
 
class  op_location_t
 

Namespaces

namespace  inchash
 
namespace  wi
 

Macros

#define MARK_TS_BASE(C)    (tree_contains_struct[C][TS_BASE] = true)
 
#define MARK_TS_TYPED(C)
 
#define MARK_TS_COMMON(C)
 
#define MARK_TS_TYPE_COMMON(C)
 
#define MARK_TS_TYPE_WITH_LANG_SPECIFIC(C)
 
#define MARK_TS_TYPE_NON_COMMON(C)
 
#define MARK_TS_DECL_MINIMAL(C)
 
#define MARK_TS_DECL_COMMON(C)
 
#define MARK_TS_DECL_WRTL(C)
 
#define MARK_TS_DECL_WITH_VIS(C)
 
#define MARK_TS_DECL_NON_COMMON(C)
 
#define MARK_TS_EXP(C)
 
#define TREE_CODE_CLASS_STRING(CLASS)    tree_code_class_strings[(int) (CLASS)]
 
#define TREE_CODE_CLASS(CODE)    tree_code_type_tmpl <0>::tree_code_type[(int) (CODE)]
 
#define EXCEPTIONAL_CLASS_P(NODE)    (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_exceptional)
 
#define CONSTANT_CLASS_P(NODE)    (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_constant)
 
#define CONSTANT_CLASS_OR_WRAPPER_P(NODE)    (CONSTANT_CLASS_P (tree_strip_any_location_wrapper (NODE)))
 
#define TYPE_P(NODE)    (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_type)
 
#define DECL_P(NODE)    (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_declaration)
 
#define VAR_P(NODE)    (TREE_CODE (NODE) == VAR_DECL)
 
#define VAR_OR_FUNCTION_DECL_P(DECL)    (TREE_CODE (DECL) == VAR_DECL || TREE_CODE (DECL) == FUNCTION_DECL)
 
#define INDIRECT_REF_P(NODE)    (TREE_CODE (NODE) == INDIRECT_REF)
 
#define REFERENCE_CLASS_P(NODE)    (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_reference)
 
#define COMPARISON_CLASS_P(NODE)    (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_comparison)
 
#define UNARY_CLASS_P(NODE)    (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_unary)
 
#define BINARY_CLASS_P(NODE)    (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_binary)
 
#define STATEMENT_CLASS_P(NODE)    (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_statement)
 
#define VL_EXP_CLASS_P(NODE)    (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_vl_exp)
 
#define EXPRESSION_CLASS_P(NODE)    (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_expression)
 
#define IS_TYPE_OR_DECL_P(NODE)    (TYPE_P (NODE) || DECL_P (NODE))
 
#define IS_EXPR_CODE_CLASS(CLASS)    ((CLASS) >= tcc_reference && (CLASS) <= tcc_expression)
 
#define EXPR_P(NODE)   IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (NODE)))
 
#define TREE_CODE_LENGTH(CODE)    tree_code_length_tmpl <0>::tree_code_length[(int) (CODE)]
 
#define CASE_FLT_FN(FN)   case FN: case FN##F: case FN##L
 
#define CASE_FLT_FN_FLOATN_NX(FN)
 
#define CASE_FLT_FN_REENT(FN)   case FN##_R: case FN##F_R: case FN##L_R
 
#define CASE_INT_FN(FN)   case FN: case FN##L: case FN##LL: case FN##IMAX
 
#define NULL_TREE   (tree) NULL
 
#define TREE_CODE(NODE)   ((enum tree_code) (NODE)->base.code)
 
#define TREE_SET_CODE(NODE, VALUE)   ((NODE)->base.code = (VALUE))
 
#define CONTAINS_STRUCT_CHECK(T, ENUM)   (T)
 
#define TREE_CHECK(T, CODE)   (T)
 
#define TREE_NOT_CHECK(T, CODE)   (T)
 
#define TREE_CHECK2(T, CODE1, CODE2)   (T)
 
#define TREE_NOT_CHECK2(T, CODE1, CODE2)   (T)
 
#define TREE_CHECK3(T, CODE1, CODE2, CODE3)   (T)
 
#define TREE_NOT_CHECK3(T, CODE1, CODE2, CODE3)   (T)
 
#define TREE_CHECK4(T, CODE1, CODE2, CODE3, CODE4)   (T)
 
#define TREE_NOT_CHECK4(T, CODE1, CODE2, CODE3, CODE4)   (T)
 
#define TREE_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5)   (T)
 
#define TREE_NOT_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5)   (T)
 
#define TREE_CHECK6(T, CODE1, CODE2, CODE3, CODE4, CODE5, CODE6)   (T)
 
#define TREE_NOT_CHECK6(T, CODE1, CODE2, CODE3, CODE4, CODE5, CODE6)   (T)
 
#define TREE_CLASS_CHECK(T, CODE)   (T)
 
#define TREE_RANGE_CHECK(T, CODE1, CODE2)   (T)
 
#define EXPR_CHECK(T)   (T)
 
#define NON_TYPE_CHECK(T)   (T)
 
#define TREE_INT_CST_ELT_CHECK(T, I)   ((T)->int_cst.val[I])
 
#define TREE_VEC_ELT_CHECK(T, I)   ((T)->vec.a[I])
 
#define TREE_OPERAND_CHECK(T, I)   ((T)->exp.operands[I])
 
#define TREE_OPERAND_CHECK_CODE(T, CODE, I)   ((T)->exp.operands[I])
 
#define OMP_CLAUSE_ELT_CHECK(T, i)   ((T)->omp_clause.ops[i])
 
#define OMP_CLAUSE_RANGE_CHECK(T, CODE1, CODE2)   (T)
 
#define OMP_CLAUSE_SUBCODE_CHECK(T, CODE)   (T)
 
#define ANY_INTEGRAL_TYPE_CHECK(T)   (T)
 
#define TREE_CHAIN(NODE)   ((NODE)->common.chain)
 
#define TREE_TYPE(NODE)   ((NODE)->typed.type)
 
#define TREE_BLOCK(NODE)   (tree_block (NODE))
 
#define TREE_SET_BLOCK(T, B)   (tree_set_block ((T), (B)))
 
#define TYPE_CHECK(T)   TREE_CLASS_CHECK (T, tcc_type)
 
#define DECL_MINIMAL_CHECK(T)   CONTAINS_STRUCT_CHECK (T, TS_DECL_MINIMAL)
 
#define DECL_COMMON_CHECK(T)   CONTAINS_STRUCT_CHECK (T, TS_DECL_COMMON)
 
#define DECL_WRTL_CHECK(T)   CONTAINS_STRUCT_CHECK (T, TS_DECL_WRTL)
 
#define DECL_WITH_VIS_CHECK(T)   CONTAINS_STRUCT_CHECK (T, TS_DECL_WITH_VIS)
 
#define DECL_NON_COMMON_CHECK(T)   CONTAINS_STRUCT_CHECK (T, TS_DECL_NON_COMMON)
 
#define CST_CHECK(T)   TREE_CLASS_CHECK (T, tcc_constant)
 
#define STMT_CHECK(T)   TREE_CLASS_CHECK (T, tcc_statement)
 
#define VL_EXP_CHECK(T)   TREE_CLASS_CHECK (T, tcc_vl_exp)
 
#define FUNC_OR_METHOD_CHECK(T)   TREE_CHECK2 (T, FUNCTION_TYPE, METHOD_TYPE)
 
#define PTR_OR_REF_CHECK(T)   TREE_CHECK2 (T, POINTER_TYPE, REFERENCE_TYPE)
 
#define RECORD_OR_UNION_CHECK(T)    TREE_CHECK3 (T, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE)
 
#define NOT_RECORD_OR_UNION_CHECK(T)    TREE_NOT_CHECK3 (T, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE)
 
#define ARRAY_OR_INTEGER_TYPE_CHECK(T)    TREE_CHECK2 (T, ARRAY_TYPE, INTEGER_TYPE)
 
#define NUMERICAL_TYPE_CHECK(T)
 
#define TYPE_HASH(TYPE)   (TYPE_UID (TYPE))
 
#define TREE_HASH(NODE)   ((size_t) (NODE) & 0777777)
 
#define CONVERT_EXPR_CODE_P(CODE)    ((CODE) == NOP_EXPR || (CODE) == CONVERT_EXPR)
 
#define CONVERT_EXPR_P(EXP)   CONVERT_EXPR_CODE_P (TREE_CODE (EXP))
 
#define CASE_CONVERT
 
#define STRIP_NOPS(EXP)    (EXP) = tree_strip_nop_conversions (CONST_CAST_TREE (EXP))
 
#define STRIP_SIGN_NOPS(EXP)    (EXP) = tree_strip_sign_nop_conversions (CONST_CAST_TREE (EXP))
 
#define STRIP_TYPE_NOPS(EXP)
 
#define STRIP_USELESS_TYPE_CONVERSION(EXP)    (EXP) = tree_ssa_strip_useless_type_conversions (EXP)
 
#define STRIP_ANY_LOCATION_WRAPPER(EXP)    (EXP) = tree_strip_any_location_wrapper (CONST_CAST_TREE (EXP))
 
#define VECTOR_TYPE_P(TYPE)   (TREE_CODE (TYPE) == VECTOR_TYPE)
 
#define VECTOR_BOOLEAN_TYPE_P(TYPE)
 
#define INTEGRAL_TYPE_P(TYPE)
 
#define ANY_INTEGRAL_TYPE_P(TYPE)
 
#define BITINT_TYPE_P(TYPE)   (TREE_CODE (TYPE) == BITINT_TYPE)
 
#define NON_SAT_FIXED_POINT_TYPE_P(TYPE)    (TREE_CODE (TYPE) == FIXED_POINT_TYPE && !TYPE_SATURATING (TYPE))
 
#define SAT_FIXED_POINT_TYPE_P(TYPE)    (TREE_CODE (TYPE) == FIXED_POINT_TYPE && TYPE_SATURATING (TYPE))
 
#define FIXED_POINT_TYPE_P(TYPE)   (TREE_CODE (TYPE) == FIXED_POINT_TYPE)
 
#define SCALAR_FLOAT_TYPE_P(TYPE)   (TREE_CODE (TYPE) == REAL_TYPE)
 
#define COMPLEX_FLOAT_TYPE_P(TYPE)
 
#define VECTOR_INTEGER_TYPE_P(TYPE)
 
#define VECTOR_FLOAT_TYPE_P(TYPE)
 
#define FLOAT_TYPE_P(TYPE)
 
#define DECIMAL_FLOAT_TYPE_P(TYPE)
 
#define RECORD_OR_UNION_TYPE_P(TYPE)
 
#define AGGREGATE_TYPE_P(TYPE)    (TREE_CODE (TYPE) == ARRAY_TYPE || RECORD_OR_UNION_TYPE_P (TYPE))
 
#define POINTER_TYPE_P(TYPE)    (TREE_CODE (TYPE) == POINTER_TYPE || TREE_CODE (TYPE) == REFERENCE_TYPE)
 
#define FUNCTION_POINTER_TYPE_P(TYPE)    (POINTER_TYPE_P (TYPE) && TREE_CODE (TREE_TYPE (TYPE)) == FUNCTION_TYPE)
 
#define COMPLETE_TYPE_P(NODE)   (TYPE_SIZE (NODE) != NULL_TREE)
 
#define VOID_TYPE_P(NODE)   (TREE_CODE (NODE) == VOID_TYPE)
 
#define COMPLETE_OR_VOID_TYPE_P(NODE)    (COMPLETE_TYPE_P (NODE) || VOID_TYPE_P (NODE))
 
#define COMPLETE_OR_UNBOUND_ARRAY_TYPE_P(NODE)    (COMPLETE_TYPE_P (TREE_CODE (NODE) == ARRAY_TYPE ? TREE_TYPE (NODE) : (NODE)))
 
#define FUNC_OR_METHOD_TYPE_P(NODE)    (TREE_CODE (NODE) == FUNCTION_TYPE || TREE_CODE (NODE) == METHOD_TYPE)
 
#define OPAQUE_TYPE_P(NODE)    (TREE_CODE (NODE) == OPAQUE_TYPE)
 
#define TREE_ADDRESSABLE(NODE)   ((NODE)->base.addressable_flag)
 
#define CALL_EXPR_TAILCALL(NODE)    (CALL_EXPR_CHECK (NODE)->base.addressable_flag)
 
#define CALL_EXPR_MUST_TAIL_CALL(NODE)    (CALL_EXPR_CHECK (NODE)->base.static_flag)
 
#define CASE_LOW_SEEN(NODE)    (CASE_LABEL_EXPR_CHECK (NODE)->base.addressable_flag)
 
#define PREDICT_EXPR_OUTCOME(NODE)    ((enum prediction) (PREDICT_EXPR_CHECK (NODE)->base.addressable_flag))
 
#define SET_PREDICT_EXPR_OUTCOME(NODE, OUTCOME)    (PREDICT_EXPR_CHECK (NODE)->base.addressable_flag = (int) OUTCOME)
 
#define PREDICT_EXPR_PREDICTOR(NODE)    ((enum br_predictor)tree_to_shwi (TREE_OPERAND (PREDICT_EXPR_CHECK (NODE), 0)))
 
#define TREE_STATIC(NODE)   ((NODE)->base.static_flag)
 
#define TREE_NO_TRAMPOLINE(NODE)   (ADDR_EXPR_CHECK (NODE)->base.static_flag)
 
#define CLEANUP_EH_ONLY(NODE)   ((NODE)->base.static_flag)
 
#define TRY_CATCH_IS_CLEANUP(NODE)    (TRY_CATCH_EXPR_CHECK (NODE)->base.static_flag)
 
#define CASE_HIGH_SEEN(NODE)    (CASE_LABEL_EXPR_CHECK (NODE)->base.static_flag)
 
#define ENUM_IS_SCOPED(NODE)   (ENUMERAL_TYPE_CHECK (NODE)->base.static_flag)
 
#define ENUM_IS_OPAQUE(NODE)   (ENUMERAL_TYPE_CHECK (NODE)->base.private_flag)
 
#define TREE_NO_WARNING(NODE)   ((NODE)->base.nowarning_flag)
 
#define TRANSLATION_UNIT_WARN_EMPTY_P(NODE)    (TRANSLATION_UNIT_DECL_CHECK (NODE)->decl_common.decl_flag_0)
 
#define TYPE_EMPTY_P(NODE)   (TYPE_CHECK (NODE)->type_common.empty_flag)
 
#define TYPE_ARTIFICIAL(NODE)   (TYPE_CHECK (NODE)->base.nowarning_flag)
 
#define TYPE_INDIVISIBLE_P(NODE)   (TYPE_CHECK (NODE)->type_common.indivisible_p)
 
#define TYPE_NO_NAMED_ARGS_STDARG_P(NODE)    (FUNC_OR_METHOD_CHECK (NODE)->type_common.no_named_args_stdarg_p)
 
#define TYPE_INCLUDES_FLEXARRAY(NODE)    (RECORD_OR_UNION_CHECK (NODE)->type_common.no_named_args_stdarg_p)
 
#define TREE_SYMBOL_REFERENCED(NODE)    (IDENTIFIER_NODE_CHECK (NODE)->base.static_flag)
 
#define TYPE_REF_CAN_ALIAS_ALL(NODE)    (PTR_OR_REF_CHECK (NODE)->base.static_flag)
 
#define TREE_OVERFLOW(NODE)   (CST_CHECK (NODE)->base.public_flag)
 
#define TREE_OVERFLOW_P(EXPR)    (CONSTANT_CLASS_P (EXPR) && TREE_OVERFLOW (EXPR))
 
#define TREE_PUBLIC(NODE)   ((NODE)->base.public_flag)
 
#define TYPE_CACHED_VALUES_P(NODE)   (TYPE_CHECK (NODE)->base.public_flag)
 
#define SAVE_EXPR_RESOLVED_P(NODE)    (SAVE_EXPR_CHECK (NODE)->base.public_flag)
 
#define CALL_EXPR_VA_ARG_PACK(NODE)    (CALL_EXPR_CHECK (NODE)->base.public_flag)
 
#define TREE_SIDE_EFFECTS(NODE)    (NON_TYPE_CHECK (NODE)->base.side_effects_flag)
 
#define FORCED_LABEL(NODE)   (LABEL_DECL_CHECK (NODE)->base.side_effects_flag)
 
#define FALLTHROUGH_LABEL_P(NODE)    (LABEL_DECL_CHECK (NODE)->base.private_flag)
 
#define SWITCH_BREAK_LABEL_P(NODE)    (LABEL_DECL_CHECK (NODE)->base.protected_flag)
 
#define UNUSED_LABEL_P(NODE)    (LABEL_DECL_CHECK (NODE)->base.default_def_flag)
 
#define TREE_THIS_VOLATILE(NODE)   ((NODE)->base.volatile_flag)
 
#define TREE_THIS_NOTRAP(NODE)
 
#define TREE_READONLY(NODE)   (NON_TYPE_CHECK (NODE)->base.readonly_flag)
 
#define TREE_CONSTANT(NODE)   (NON_TYPE_CHECK (NODE)->base.constant_flag)
 
#define TYPE_SIZES_GIMPLIFIED(NODE)    (TYPE_CHECK (NODE)->base.constant_flag)
 
#define DECL_UNSIGNED(NODE)    (DECL_COMMON_CHECK (NODE)->base.u.bits.unsigned_flag)
 
#define TYPE_UNSIGNED(NODE)   (TYPE_CHECK (NODE)->base.u.bits.unsigned_flag)
 
#define TYPE_SIGN(NODE)   ((signop) TYPE_UNSIGNED (NODE))
 
#define TYPE_OVERFLOW_WRAPS(TYPE)
 
#define TYPE_OVERFLOW_UNDEFINED(TYPE)
 
#define TYPE_OVERFLOW_TRAPS(TYPE)    (!ANY_INTEGRAL_TYPE_CHECK(TYPE)->base.u.bits.unsigned_flag && flag_trapv)
 
#define TYPE_OVERFLOW_SANITIZED(TYPE)
 
#define TREE_ASM_WRITTEN(NODE)   ((NODE)->base.asm_written_flag)
 
#define TREE_USED(NODE)   ((NODE)->base.used_flag)
 
#define TREE_NOTHROW(NODE)   ((NODE)->base.nothrow_flag)
 
#define CALL_EXPR_RETURN_SLOT_OPT(NODE)    (CALL_EXPR_CHECK (NODE)->base.private_flag)
 
#define DECL_BY_REFERENCE(NODE)
 
#define DECL_READ_P(NODE)    (TREE_CHECK2 (NODE, VAR_DECL, PARM_DECL)->decl_common.decl_read_flag)
 
#define DECL_NONSHAREABLE(NODE)
 
#define DECL_HIDDEN_STRING_LENGTH(NODE)    (TREE_CHECK (NODE, PARM_DECL)->decl_common.decl_nonshareable_flag)
 
#define CALL_FROM_THUNK_P(NODE)   (CALL_EXPR_CHECK (NODE)->base.protected_flag)
 
#define CALL_ALLOCA_FOR_VAR_P(NODE)    (CALL_EXPR_CHECK (NODE)->base.protected_flag)
 
#define CALL_FROM_NEW_OR_DELETE_P(NODE)    (CALL_EXPR_CHECK (NODE)->base.protected_flag)
 
#define TREE_PRIVATE(NODE)   ((NODE)->base.private_flag)
 
#define TREE_PROTECTED(NODE)   ((NODE)->base.protected_flag)
 
#define TYPE_REF_IS_RVALUE(NODE)    (REFERENCE_TYPE_CHECK (NODE)->base.private_flag)
 
#define TREE_DEPRECATED(NODE)    ((NODE)->base.deprecated_flag)
 
#define TREE_UNAVAILABLE(NODE)    ((NODE)->base.u.bits.unavailable_flag)
 
#define IDENTIFIER_ANON_P(NODE)    (IDENTIFIER_NODE_CHECK (NODE)->base.private_flag)
 
#define IDENTIFIER_TRANSPARENT_ALIAS(NODE)    (IDENTIFIER_NODE_CHECK (NODE)->base.deprecated_flag)
 
#define TYPE_REVERSE_STORAGE_ORDER(NODE)    (TREE_CHECK4 (NODE, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, ARRAY_TYPE)->base.u.bits.saturating_flag)
 
#define TYPE_SATURATING(NODE)    (TREE_NOT_CHECK4 (NODE, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, ARRAY_TYPE)->base.u.bits.saturating_flag)
 
#define REF_REVERSE_STORAGE_ORDER(NODE)    (TREE_CHECK2 (NODE, BIT_FIELD_REF, MEM_REF)->base.default_def_flag)
 
#define FUNC_ADDR_BY_DESCRIPTOR(NODE)    (TREE_CHECK (NODE, ADDR_EXPR)->base.default_def_flag)
 
#define CALL_EXPR_BY_DESCRIPTOR(NODE)    (TREE_CHECK (NODE, CALL_EXPR)->base.default_def_flag)
 
#define TREE_LANG_FLAG_0(NODE)    (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_0)
 
#define TREE_LANG_FLAG_1(NODE)    (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_1)
 
#define TREE_LANG_FLAG_2(NODE)    (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_2)
 
#define TREE_LANG_FLAG_3(NODE)    (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_3)
 
#define TREE_LANG_FLAG_4(NODE)    (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_4)
 
#define TREE_LANG_FLAG_5(NODE)    (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_5)
 
#define TREE_LANG_FLAG_6(NODE)    (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_6)
 
#define TREE_INT_CST_NUNITS(NODE)    (INTEGER_CST_CHECK (NODE)->base.u.int_length.unextended)
 
#define TREE_INT_CST_EXT_NUNITS(NODE)    (INTEGER_CST_CHECK (NODE)->base.u.int_length.extended)
 
#define TREE_INT_CST_ELT(NODE, I)   TREE_INT_CST_ELT_CHECK (NODE, I)
 
#define TREE_INT_CST_LOW(NODE)    ((unsigned HOST_WIDE_INT) TREE_INT_CST_ELT (NODE, 0))
 
#define POLY_INT_CST_P(NODE)    (NUM_POLY_INT_COEFFS > 1 && TREE_CODE (NODE) == POLY_INT_CST)
 
#define POLY_INT_CST_COEFF(NODE, I)    (POLY_INT_CST_CHECK (NODE)->poly_int_cst.coeffs[I])
 
#define TREE_REAL_CST_PTR(NODE)   (&REAL_CST_CHECK (NODE)->real_cst.value)
 
#define TREE_REAL_CST(NODE)   (*TREE_REAL_CST_PTR (NODE))
 
#define TREE_FIXED_CST_PTR(NODE)    (FIXED_CST_CHECK (NODE)->fixed_cst.fixed_cst_ptr)
 
#define TREE_FIXED_CST(NODE)   (*TREE_FIXED_CST_PTR (NODE))
 
#define TREE_STRING_LENGTH(NODE)   (STRING_CST_CHECK (NODE)->string.length)
 
#define TREE_STRING_POINTER(NODE)    ((const char *)(STRING_CST_CHECK (NODE)->string.str))
 
#define TREE_REALPART(NODE)   (COMPLEX_CST_CHECK (NODE)->complex.real)
 
#define TREE_IMAGPART(NODE)   (COMPLEX_CST_CHECK (NODE)->complex.imag)
 
#define VECTOR_CST_NELTS(NODE)   (TYPE_VECTOR_SUBPARTS (TREE_TYPE (NODE)))
 
#define VECTOR_CST_ELT(NODE, IDX)   vector_cst_elt (NODE, IDX)
 
#define VECTOR_CST_LOG2_NPATTERNS(NODE)    (VECTOR_CST_CHECK (NODE)->base.u.vector_cst.log2_npatterns)
 
#define VECTOR_CST_NPATTERNS(NODE)    (1U << VECTOR_CST_LOG2_NPATTERNS (NODE))
 
#define VECTOR_CST_NELTS_PER_PATTERN(NODE)    (VECTOR_CST_CHECK (NODE)->base.u.vector_cst.nelts_per_pattern)
 
#define VECTOR_CST_DUPLICATE_P(NODE)    (VECTOR_CST_NELTS_PER_PATTERN (NODE) == 1)
 
#define VECTOR_CST_STEPPED_P(NODE)    (VECTOR_CST_NELTS_PER_PATTERN (NODE) == 3)
 
#define VECTOR_CST_ENCODED_ELTS(NODE)    (VECTOR_CST_CHECK (NODE)->vector.elts)
 
#define VECTOR_CST_ENCODED_ELT(NODE, ELT)    (VECTOR_CST_CHECK (NODE)->vector.elts[ELT])
 
#define IDENTIFIER_LENGTH(NODE)    (IDENTIFIER_NODE_CHECK (NODE)->identifier.id.len)
 
#define IDENTIFIER_POINTER(NODE)    ((const char *) IDENTIFIER_NODE_CHECK (NODE)->identifier.id.str)
 
#define IDENTIFIER_HASH_VALUE(NODE)    (IDENTIFIER_NODE_CHECK (NODE)->identifier.id.hash_value)
 
#define HT_IDENT_TO_GCC_IDENT(NODE)    ((tree) ((char *) (NODE) - sizeof (struct tree_common)))
 
#define GCC_IDENT_TO_HT_IDENT(NODE)   (&((struct tree_identifier *) (NODE))->id)
 
#define TREE_PURPOSE(NODE)   (TREE_LIST_CHECK (NODE)->list.purpose)
 
#define TREE_VALUE(NODE)   (TREE_LIST_CHECK (NODE)->list.value)
 
#define TREE_VEC_LENGTH(NODE)   (TREE_VEC_CHECK (NODE)->base.u.length)
 
#define TREE_VEC_BEGIN(NODE)   (&TREE_VEC_CHECK (NODE)->vec.a[0])
 
#define TREE_VEC_END(NODE)    ((void) TREE_VEC_CHECK (NODE), &((NODE)->vec.a[(NODE)->base.u.length]))
 
#define TREE_VEC_ELT(NODE, I)   TREE_VEC_ELT_CHECK (NODE, I)
 
#define CONSTRUCTOR_ELTS(NODE)   (CONSTRUCTOR_CHECK (NODE)->constructor.elts)
 
#define CONSTRUCTOR_ELT(NODE, IDX)    (&(*CONSTRUCTOR_ELTS (NODE))[IDX])
 
#define CONSTRUCTOR_NELTS(NODE)    (vec_safe_length (CONSTRUCTOR_ELTS (NODE)))
 
#define CONSTRUCTOR_NO_CLEARING(NODE)    (CONSTRUCTOR_CHECK (NODE)->base.public_flag)
 
#define FOR_EACH_CONSTRUCTOR_VALUE(V, IX, VAL)
 
#define FOR_EACH_CONSTRUCTOR_ELT(V, IX, INDEX, VAL)
 
#define CONSTRUCTOR_APPEND_ELT(V, INDEX, VALUE)
 
#define CONSTRUCTOR_BITFIELD_P(NODE)
 
#define TREE_CLOBBER_P(NODE)    (TREE_CODE (NODE) == CONSTRUCTOR && TREE_THIS_VOLATILE (NODE))
 
#define CLOBBER_KIND(NODE)    (CONSTRUCTOR_CHECK (NODE)->base.u.bits.address_space)
 
#define IS_EMPTY_STMT(NODE)
 
#define TREE_OPERAND_LENGTH(NODE)   tree_operand_length (NODE)
 
#define TREE_OPERAND(NODE, I)   TREE_OPERAND_CHECK (NODE, I)
 
#define VL_EXP_OPERAND_LENGTH(NODE)    ((int)TREE_INT_CST_LOW (VL_EXP_CHECK (NODE)->exp.operands[0]))
 
#define MAY_HAVE_DEBUG_MARKER_STMTS   debug_nonbind_markers_p
 
#define MAY_HAVE_DEBUG_BIND_STMTS   flag_var_tracking_assignments
 
#define MAY_HAVE_DEBUG_STMTS    (MAY_HAVE_DEBUG_MARKER_STMTS || MAY_HAVE_DEBUG_BIND_STMTS)
 
#define LOOP_EXPR_BODY(NODE)   TREE_OPERAND_CHECK_CODE (NODE, LOOP_EXPR, 0)
 
#define EXPR_LOCATION(NODE)    (CAN_HAVE_LOCATION_P ((NODE)) ? (NODE)->exp.locus : UNKNOWN_LOCATION)
 
#define SET_EXPR_LOCATION(NODE, LOCUS)   EXPR_CHECK ((NODE))->exp.locus = (LOCUS)
 
#define EXPR_HAS_LOCATION(NODE)
 
#define EXPR_LOC_OR_LOC(NODE, LOCUS)
 
#define EXPR_FILENAME(NODE)   LOCATION_FILE (EXPR_CHECK ((NODE))->exp.locus)
 
#define EXPR_LINENO(NODE)   LOCATION_LINE (EXPR_CHECK (NODE)->exp.locus)
 
#define CAN_HAVE_RANGE_P(NODE)   (CAN_HAVE_LOCATION_P (NODE))
 
#define EXPR_LOCATION_RANGE(NODE)   (get_expr_source_range (EXPR_CHECK ((NODE))))
 
#define EXPR_HAS_RANGE(NODE)
 
#define CAN_HAVE_LOCATION_P(NODE)   ((NODE) && EXPR_P (NODE))
 
#define SET_EXPR_UID(t, v)   EXPR_CHECK ((t))->exp.condition_uid = (v)
 
#define EXPR_COND_UID(t)   EXPR_CHECK ((t))->exp.condition_uid
 
#define TARGET_EXPR_SLOT(NODE)   TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 0)
 
#define TARGET_EXPR_INITIAL(NODE)   TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 1)
 
#define TARGET_EXPR_CLEANUP(NODE)   TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 2)
 
#define TARGET_EXPR_NO_ELIDE(NODE)   (TARGET_EXPR_CHECK (NODE)->base.private_flag)
 
#define DECL_EXPR_DECL(NODE)   TREE_OPERAND (DECL_EXPR_CHECK (NODE), 0)
 
#define EXIT_EXPR_COND(NODE)   TREE_OPERAND (EXIT_EXPR_CHECK (NODE), 0)
 
#define COMPOUND_LITERAL_EXPR_DECL_EXPR(NODE)    TREE_OPERAND (COMPOUND_LITERAL_EXPR_CHECK (NODE), 0)
 
#define COMPOUND_LITERAL_EXPR_DECL(NODE)    DECL_EXPR_DECL (COMPOUND_LITERAL_EXPR_DECL_EXPR (NODE))
 
#define SWITCH_COND(NODE)   TREE_OPERAND (SWITCH_EXPR_CHECK (NODE), 0)
 
#define SWITCH_BODY(NODE)   TREE_OPERAND (SWITCH_EXPR_CHECK (NODE), 1)
 
#define SWITCH_ALL_CASES_P(NODE)   (SWITCH_EXPR_CHECK (NODE)->base.private_flag)
 
#define CASE_LOW(NODE)   TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 0)
 
#define CASE_HIGH(NODE)   TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 1)
 
#define CASE_LABEL(NODE)   TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 2)
 
#define CASE_CHAIN(NODE)   TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 3)
 
#define TMR_BASE(NODE)   (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 0))
 
#define TMR_OFFSET(NODE)   (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 1))
 
#define TMR_INDEX(NODE)   (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 2))
 
#define TMR_STEP(NODE)   (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 3))
 
#define TMR_INDEX2(NODE)   (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 4))
 
#define MR_DEPENDENCE_CLIQUE(NODE)    (TREE_CHECK2 (NODE, MEM_REF, TARGET_MEM_REF)->base.u.dependence_info.clique)
 
#define MR_DEPENDENCE_BASE(NODE)    (TREE_CHECK2 (NODE, MEM_REF, TARGET_MEM_REF)->base.u.dependence_info.base)
 
#define BIND_EXPR_VARS(NODE)   (TREE_OPERAND (BIND_EXPR_CHECK (NODE), 0))
 
#define BIND_EXPR_BODY(NODE)   (TREE_OPERAND (BIND_EXPR_CHECK (NODE), 1))
 
#define BIND_EXPR_BLOCK(NODE)   (TREE_OPERAND (BIND_EXPR_CHECK (NODE), 2))
 
#define GOTO_DESTINATION(NODE)   TREE_OPERAND (GOTO_EXPR_CHECK (NODE), 0)
 
#define ASM_STRING(NODE)   TREE_OPERAND (ASM_EXPR_CHECK (NODE), 0)
 
#define ASM_OUTPUTS(NODE)   TREE_OPERAND (ASM_EXPR_CHECK (NODE), 1)
 
#define ASM_INPUTS(NODE)   TREE_OPERAND (ASM_EXPR_CHECK (NODE), 2)
 
#define ASM_CLOBBERS(NODE)   TREE_OPERAND (ASM_EXPR_CHECK (NODE), 3)
 
#define ASM_LABELS(NODE)   TREE_OPERAND (ASM_EXPR_CHECK (NODE), 4)
 
#define ASM_INPUT_P(NODE)   (ASM_EXPR_CHECK (NODE)->base.static_flag)
 
#define ASM_VOLATILE_P(NODE)   (ASM_EXPR_CHECK (NODE)->base.public_flag)
 
#define ASM_INLINE_P(NODE)   (ASM_EXPR_CHECK (NODE)->base.protected_flag)
 
#define COND_EXPR_COND(NODE)   (TREE_OPERAND (COND_EXPR_CHECK (NODE), 0))
 
#define COND_EXPR_THEN(NODE)   (TREE_OPERAND (COND_EXPR_CHECK (NODE), 1))
 
#define COND_EXPR_ELSE(NODE)   (TREE_OPERAND (COND_EXPR_CHECK (NODE), 2))
 
#define CHREC_LEFT(NODE)   TREE_OPERAND (POLYNOMIAL_CHREC_CHECK (NODE), 0)
 
#define CHREC_RIGHT(NODE)   TREE_OPERAND (POLYNOMIAL_CHREC_CHECK (NODE), 1)
 
#define CHREC_VARIABLE(NODE)   POLYNOMIAL_CHREC_CHECK (NODE)->base.u.chrec_var
 
#define CHREC_NOWRAP(NODE)   POLYNOMIAL_CHREC_CHECK (NODE)->base.nothrow_flag
 
#define LABEL_EXPR_LABEL(NODE)   TREE_OPERAND (LABEL_EXPR_CHECK (NODE), 0)
 
#define CATCH_TYPES(NODE)   TREE_OPERAND (CATCH_EXPR_CHECK (NODE), 0)
 
#define CATCH_BODY(NODE)   TREE_OPERAND (CATCH_EXPR_CHECK (NODE), 1)
 
#define EH_FILTER_TYPES(NODE)   TREE_OPERAND (EH_FILTER_EXPR_CHECK (NODE), 0)
 
#define EH_FILTER_FAILURE(NODE)   TREE_OPERAND (EH_FILTER_EXPR_CHECK (NODE), 1)
 
#define OBJ_TYPE_REF_EXPR(NODE)   TREE_OPERAND (OBJ_TYPE_REF_CHECK (NODE), 0)
 
#define OBJ_TYPE_REF_OBJECT(NODE)   TREE_OPERAND (OBJ_TYPE_REF_CHECK (NODE), 1)
 
#define OBJ_TYPE_REF_TOKEN(NODE)   TREE_OPERAND (OBJ_TYPE_REF_CHECK (NODE), 2)
 
#define CALL_EXPR_FN(NODE)   TREE_OPERAND (CALL_EXPR_CHECK (NODE), 1)
 
#define CALL_EXPR_STATIC_CHAIN(NODE)   TREE_OPERAND (CALL_EXPR_CHECK (NODE), 2)
 
#define CALL_EXPR_ARG(NODE, I)   TREE_OPERAND (CALL_EXPR_CHECK (NODE), (I) + 3)
 
#define call_expr_nargs(NODE)   (VL_EXP_OPERAND_LENGTH (NODE) - 3)
 
#define CALL_EXPR_IFN(NODE)   (CALL_EXPR_CHECK (NODE)->base.u.ifn)
 
#define CALL_EXPR_ARGP(NODE)    (&(TREE_OPERAND (CALL_EXPR_CHECK (NODE), 0)) + 3)
 
#define TRANSACTION_EXPR_BODY(NODE)    TREE_OPERAND (TRANSACTION_EXPR_CHECK (NODE), 0)
 
#define TRANSACTION_EXPR_OUTER(NODE)    (TRANSACTION_EXPR_CHECK (NODE)->base.static_flag)
 
#define TRANSACTION_EXPR_RELAXED(NODE)    (TRANSACTION_EXPR_CHECK (NODE)->base.public_flag)
 
#define OMP_BODY(NODE)    TREE_OPERAND (TREE_RANGE_CHECK (NODE, OACC_PARALLEL, OMP_MASTER), 0)
 
#define OMP_CLAUSES(NODE)    TREE_OPERAND (TREE_RANGE_CHECK (NODE, OACC_PARALLEL, OMP_SCAN), 1)
 
#define OMP_STANDALONE_CLAUSES(NODE)    TREE_OPERAND (TREE_RANGE_CHECK (NODE, OACC_CACHE, OMP_TARGET_EXIT_DATA), 0)
 
#define OACC_DATA_BODY(NODE)    TREE_OPERAND (OACC_DATA_CHECK (NODE), 0)
 
#define OACC_DATA_CLAUSES(NODE)    TREE_OPERAND (OACC_DATA_CHECK (NODE), 1)
 
#define OACC_HOST_DATA_BODY(NODE)    TREE_OPERAND (OACC_HOST_DATA_CHECK (NODE), 0)
 
#define OACC_HOST_DATA_CLAUSES(NODE)    TREE_OPERAND (OACC_HOST_DATA_CHECK (NODE), 1)
 
#define OACC_CACHE_CLAUSES(NODE)    TREE_OPERAND (OACC_CACHE_CHECK (NODE), 0)
 
#define OACC_DECLARE_CLAUSES(NODE)    TREE_OPERAND (OACC_DECLARE_CHECK (NODE), 0)
 
#define OACC_ENTER_DATA_CLAUSES(NODE)    TREE_OPERAND (OACC_ENTER_DATA_CHECK (NODE), 0)
 
#define OACC_EXIT_DATA_CLAUSES(NODE)    TREE_OPERAND (OACC_EXIT_DATA_CHECK (NODE), 0)
 
#define OACC_UPDATE_CLAUSES(NODE)    TREE_OPERAND (OACC_UPDATE_CHECK (NODE), 0)
 
#define OMP_PARALLEL_BODY(NODE)   TREE_OPERAND (OMP_PARALLEL_CHECK (NODE), 0)
 
#define OMP_PARALLEL_CLAUSES(NODE)   TREE_OPERAND (OMP_PARALLEL_CHECK (NODE), 1)
 
#define OMP_TASK_BODY(NODE)   TREE_OPERAND (OMP_TASK_CHECK (NODE), 0)
 
#define OMP_TASK_CLAUSES(NODE)   TREE_OPERAND (OMP_TASK_CHECK (NODE), 1)
 
#define OMP_TASKREG_CHECK(NODE)   TREE_RANGE_CHECK (NODE, OMP_PARALLEL, OMP_TASK)
 
#define OMP_TASKREG_BODY(NODE)   TREE_OPERAND (OMP_TASKREG_CHECK (NODE), 0)
 
#define OMP_TASKREG_CLAUSES(NODE)   TREE_OPERAND (OMP_TASKREG_CHECK (NODE), 1)
 
#define OMP_LOOPING_CHECK(NODE)   TREE_RANGE_CHECK (NODE, OMP_FOR, OACC_LOOP)
 
#define OMP_FOR_BODY(NODE)   TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 0)
 
#define OMP_FOR_CLAUSES(NODE)   TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 1)
 
#define OMP_FOR_INIT(NODE)   TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 2)
 
#define OMP_FOR_COND(NODE)   TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 3)
 
#define OMP_FOR_INCR(NODE)   TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 4)
 
#define OMP_FOR_PRE_BODY(NODE)   TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 5)
 
#define OMP_FOR_ORIG_DECLS(NODE)   TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 6)
 
#define OMP_LOOPXFORM_CHECK(NODE)   TREE_RANGE_CHECK (NODE, OMP_TILE, OMP_UNROLL)
 
#define OMP_LOOPXFORM_LOWERED(NODE)    (OMP_LOOPXFORM_CHECK (NODE)->base.public_flag)
 
#define OMP_SECTIONS_BODY(NODE)   TREE_OPERAND (OMP_SECTIONS_CHECK (NODE), 0)
 
#define OMP_SECTIONS_CLAUSES(NODE)   TREE_OPERAND (OMP_SECTIONS_CHECK (NODE), 1)
 
#define OMP_SECTION_BODY(NODE)   TREE_OPERAND (OMP_SECTION_CHECK (NODE), 0)
 
#define OMP_STRUCTURED_BLOCK_BODY(NODE)    TREE_OPERAND (OMP_STRUCTURED_BLOCK_CHECK (NODE), 0)
 
#define OMP_SINGLE_BODY(NODE)   TREE_OPERAND (OMP_SINGLE_CHECK (NODE), 0)
 
#define OMP_SINGLE_CLAUSES(NODE)   TREE_OPERAND (OMP_SINGLE_CHECK (NODE), 1)
 
#define OMP_SCOPE_BODY(NODE)   TREE_OPERAND (OMP_SCOPE_CHECK (NODE), 0)
 
#define OMP_SCOPE_CLAUSES(NODE)   TREE_OPERAND (OMP_SCOPE_CHECK (NODE), 1)
 
#define OMP_MASTER_BODY(NODE)   TREE_OPERAND (OMP_MASTER_CHECK (NODE), 0)
 
#define OMP_MASKED_BODY(NODE)   TREE_OPERAND (OMP_MASKED_CHECK (NODE), 0)
 
#define OMP_MASKED_CLAUSES(NODE)   TREE_OPERAND (OMP_MASKED_CHECK (NODE), 1)
 
#define OMP_TASKGROUP_BODY(NODE)   TREE_OPERAND (OMP_TASKGROUP_CHECK (NODE), 0)
 
#define OMP_TASKGROUP_CLAUSES(NODE)    TREE_OPERAND (OMP_TASKGROUP_CHECK (NODE), 1)
 
#define OMP_ORDERED_BODY(NODE)   TREE_OPERAND (OMP_ORDERED_CHECK (NODE), 0)
 
#define OMP_ORDERED_CLAUSES(NODE)   TREE_OPERAND (OMP_ORDERED_CHECK (NODE), 1)
 
#define OMP_CRITICAL_BODY(NODE)   TREE_OPERAND (OMP_CRITICAL_CHECK (NODE), 0)
 
#define OMP_CRITICAL_CLAUSES(NODE)   TREE_OPERAND (OMP_CRITICAL_CHECK (NODE), 1)
 
#define OMP_CRITICAL_NAME(NODE)   TREE_OPERAND (OMP_CRITICAL_CHECK (NODE), 2)
 
#define OMP_TEAMS_BODY(NODE)   TREE_OPERAND (OMP_TEAMS_CHECK (NODE), 0)
 
#define OMP_TEAMS_CLAUSES(NODE)   TREE_OPERAND (OMP_TEAMS_CHECK (NODE), 1)
 
#define OMP_TARGET_DATA_BODY(NODE)    TREE_OPERAND (OMP_TARGET_DATA_CHECK (NODE), 0)
 
#define OMP_TARGET_DATA_CLAUSES(NODE)    TREE_OPERAND (OMP_TARGET_DATA_CHECK (NODE), 1)
 
#define OMP_TARGET_BODY(NODE)   TREE_OPERAND (OMP_TARGET_CHECK (NODE), 0)
 
#define OMP_TARGET_CLAUSES(NODE)   TREE_OPERAND (OMP_TARGET_CHECK (NODE), 1)
 
#define OMP_TARGET_UPDATE_CLAUSES(NODE)    TREE_OPERAND (OMP_TARGET_UPDATE_CHECK (NODE), 0)
 
#define OMP_TARGET_ENTER_DATA_CLAUSES(NODE)    TREE_OPERAND (OMP_TARGET_ENTER_DATA_CHECK (NODE), 0)
 
#define OMP_TARGET_EXIT_DATA_CLAUSES(NODE)    TREE_OPERAND (OMP_TARGET_EXIT_DATA_CHECK (NODE), 0)
 
#define OMP_SCAN_BODY(NODE)   TREE_OPERAND (OMP_SCAN_CHECK (NODE), 0)
 
#define OMP_SCAN_CLAUSES(NODE)   TREE_OPERAND (OMP_SCAN_CHECK (NODE), 1)
 
#define OMP_CLAUSE_SIZE(NODE)
 
#define OMP_CLAUSE_CHAIN(NODE)   TREE_CHAIN (OMP_CLAUSE_CHECK (NODE))
 
#define OMP_CLAUSE_DECL(NODE)
 
#define OMP_CLAUSE_HAS_LOCATION(NODE)
 
#define OMP_CLAUSE_LOCATION(NODE)   (OMP_CLAUSE_CHECK (NODE))->omp_clause.locus
 
#define OMP_FOR_NON_RECTANGULAR(NODE)    (OMP_LOOPING_CHECK (NODE)->base.private_flag)
 
#define OMP_SECTION_LAST(NODE)    (OMP_SECTION_CHECK (NODE)->base.private_flag)
 
#define OMP_PARALLEL_COMBINED(NODE)    (OMP_PARALLEL_CHECK (NODE)->base.private_flag)
 
#define OMP_TEAMS_COMBINED(NODE)    (OMP_TEAMS_CHECK (NODE)->base.private_flag)
 
#define OMP_TARGET_COMBINED(NODE)    (OMP_TARGET_CHECK (NODE)->base.private_flag)
 
#define OMP_MASTER_COMBINED(NODE)    (OMP_MASTER_CHECK (NODE)->base.private_flag)
 
#define OMP_MASKED_COMBINED(NODE)    (OMP_MASKED_CHECK (NODE)->base.private_flag)
 
#define OMP_ATOMIC_MEMORY_ORDER(NODE)
 
#define OMP_ATOMIC_WEAK(NODE)
 
#define OMP_CLAUSE_PRIVATE_DEBUG(NODE)    (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_PRIVATE)->base.public_flag)
 
#define OMP_CLAUSE_PRIVATE_OUTER_REF(NODE)    TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_PRIVATE))
 
#define OMP_CLAUSE_PRIVATE_TASKLOOP_IV(NODE)    TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_PRIVATE))
 
#define OMP_CLAUSE_FIRSTPRIVATE_IMPLICIT(NODE)    (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_FIRSTPRIVATE)->base.public_flag)
 
#define OMP_CLAUSE_FIRSTPRIVATE_NO_REFERENCE(NODE)    TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_FIRSTPRIVATE))
 
#define OMP_CLAUSE_FIRSTPRIVATE_IMPLICIT_TARGET(NODE)    TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_FIRSTPRIVATE))
 
#define OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE(NODE)    (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LASTPRIVATE)->base.public_flag)
 
#define OMP_CLAUSE_LASTPRIVATE_STMT(NODE)
 
#define OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ(NODE)    (OMP_CLAUSE_CHECK (NODE))->omp_clause.gimple_reduction_init
 
#define OMP_CLAUSE_LASTPRIVATE_LOOP_IV(NODE)    TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LASTPRIVATE))
 
#define OMP_CLAUSE_LASTPRIVATE_CONDITIONAL(NODE)    TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LASTPRIVATE))
 
#define OMP_CLAUSE_SHARED_FIRSTPRIVATE(NODE)    (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SHARED)->base.public_flag)
 
#define OMP_CLAUSE_SHARED_READONLY(NODE)    TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SHARED))
 
#define OMP_CLAUSE_IF_MODIFIER(NODE)    (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_IF)->omp_clause.subcode.if_modifier)
 
#define OMP_CLAUSE_FINAL_EXPR(NODE)    OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_FINAL), 0)
 
#define OMP_CLAUSE_IF_EXPR(NODE)    OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_IF), 0)
 
#define OMP_CLAUSE_SELF_EXPR(NODE)    OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SELF), 0)
 
#define OMP_CLAUSE_NUM_THREADS_EXPR(NODE)    OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_THREADS),0)
 
#define OMP_CLAUSE_SCHEDULE_CHUNK_EXPR(NODE)    OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SCHEDULE), 0)
 
#define OMP_CLAUSE_NUM_TASKS_EXPR(NODE)    OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_TASKS), 0)
 
#define OMP_CLAUSE_HINT_EXPR(NODE)    OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_HINT), 0)
 
#define OMP_CLAUSE_FILTER_EXPR(NODE)    OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_FILTER), 0)
 
#define OMP_CLAUSE_PARTIAL_EXPR(NODE)    OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_PARTIAL), 0)
 
#define OMP_CLAUSE_SIZES_LIST(NODE)    OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SIZES), 0)
 
#define OMP_CLAUSE_GRAINSIZE_EXPR(NODE)    OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_GRAINSIZE),0)
 
#define OMP_CLAUSE_PRIORITY_EXPR(NODE)    OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_PRIORITY),0)
 
#define OMP_CLAUSE_GRAINSIZE_STRICT(NODE)    TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_GRAINSIZE))
 
#define OMP_CLAUSE_NUM_TASKS_STRICT(NODE)    TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_TASKS))
 
#define OMP_CLAUSE_EXPR(NODE, CLAUSE)    OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, CLAUSE), 0)
 
#define OMP_CLAUSE_GANG_EXPR(NODE)
 
#define OMP_CLAUSE_GANG_STATIC_EXPR(NODE)
 
#define OMP_CLAUSE_ASYNC_EXPR(NODE)
 
#define OMP_CLAUSE_WAIT_EXPR(NODE)
 
#define OMP_CLAUSE_VECTOR_EXPR(NODE)
 
#define OMP_CLAUSE_WORKER_EXPR(NODE)
 
#define OMP_CLAUSE_NUM_GANGS_EXPR(NODE)
 
#define OMP_CLAUSE_NUM_WORKERS_EXPR(NODE)
 
#define OMP_CLAUSE_VECTOR_LENGTH_EXPR(NODE)
 
#define OMP_CLAUSE_DEPEND_KIND(NODE)    (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEPEND)->omp_clause.subcode.depend_kind)
 
#define OMP_CLAUSE_DOACROSS_KIND(NODE)    (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DOACROSS)->omp_clause.subcode.doacross_kind)
 
#define OMP_CLAUSE_DOACROSS_SINK_NEGATIVE(NODE)    TREE_PUBLIC (TREE_LIST_CHECK (NODE))
 
#define OMP_CLAUSE_DOACROSS_DEPEND(NODE)    TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DOACROSS))
 
#define OMP_CLAUSE_MAP_KIND(NODE)    ((enum gomp_map_kind) OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP)->omp_clause.subcode.map_kind)
 
#define OMP_CLAUSE_SET_MAP_KIND(NODE, MAP_KIND)
 
#define OMP_CLAUSE_MOTION_PRESENT(NODE)    (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_FROM, OMP_CLAUSE_TO)->base.deprecated_flag)
 
#define OMP_CLAUSE_MAP_ZERO_BIAS_ARRAY_SECTION(NODE)    (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP)->base.public_flag)
 
#define OMP_CLAUSE_MAP_MAYBE_ZERO_LENGTH_ARRAY_SECTION(NODE)    TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP))
 
#define OMP_CLAUSE_MAP_IN_REDUCTION(NODE)    TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP))
 
#define OMP_CLAUSE_MAP_IMPLICIT(NODE)    (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP)->base.default_def_flag)
 
#define OMP_CLAUSE_MAP_RUNTIME_IMPLICIT_P(NODE)    (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP)->base.deprecated_flag)
 
#define OMP_CLAUSE_ATTACHMENT_MAPPING_ERASED(NODE)    TREE_STATIC (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP))
 
#define OMP_CLAUSE_RELEASE_DESCRIPTOR(NODE)    TREE_NOTHROW (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP))
 
#define OMP_CLAUSE_MAP_DECL_MAKE_ADDRESSABLE(NODE)    (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP)->base.addressable_flag)
 
#define OMP_CLAUSE_MAP_READONLY(NODE)    TREE_READONLY (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP))
 
#define OMP_CLAUSE__CACHE__READONLY(NODE)    TREE_READONLY (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE__CACHE_))
 
#define OMP_CLAUSE_USE_DEVICE_PTR_IF_PRESENT(NODE)    (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_USE_DEVICE_PTR)->base.public_flag)
 
#define OMP_CLAUSE_PROC_BIND_KIND(NODE)    (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_PROC_BIND)->omp_clause.subcode.proc_bind_kind)
 
#define OMP_CLAUSE_DEVICE_TYPE_KIND(NODE)    (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEVICE_TYPE)->omp_clause.subcode.device_type_kind)
 
#define OMP_CLAUSE_INDIRECT_EXPR(NODE)    OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_INDIRECT), 0)
 
#define OMP_CLAUSE_DEVICE_ANCESTOR(NODE)    (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEVICE)->base.public_flag)
 
#define OMP_CLAUSE_COLLAPSE_EXPR(NODE)    OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_COLLAPSE), 0)
 
#define OMP_CLAUSE_COLLAPSE_ITERVAR(NODE)    OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_COLLAPSE), 1)
 
#define OMP_CLAUSE_COLLAPSE_COUNT(NODE)    OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_COLLAPSE), 2)
 
#define OMP_CLAUSE_ORDERED_EXPR(NODE)    OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ORDERED), 0)
 
#define OMP_CLAUSE_ORDERED_DOACROSS(NODE)    (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ORDERED)->base.public_flag)
 
#define OMP_CLAUSE_ORDER_UNCONSTRAINED(NODE)    (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ORDER)->base.public_flag)
 
#define OMP_CLAUSE_ORDER_REPRODUCIBLE(NODE)    TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ORDER))
 
#define OMP_CLAUSE_REDUCTION_CODE(NODE)
 
#define OMP_CLAUSE_REDUCTION_INIT(NODE)
 
#define OMP_CLAUSE_REDUCTION_MERGE(NODE)
 
#define OMP_CLAUSE_REDUCTION_GIMPLE_INIT(NODE)    (OMP_CLAUSE_CHECK (NODE))->omp_clause.gimple_reduction_init
 
#define OMP_CLAUSE_REDUCTION_GIMPLE_MERGE(NODE)    (OMP_CLAUSE_CHECK (NODE))->omp_clause.gimple_reduction_merge
 
#define OMP_CLAUSE_REDUCTION_PLACEHOLDER(NODE)
 
#define OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER(NODE)
 
#define OMP_CLAUSE_REDUCTION_OMP_ORIG_REF(NODE)
 
#define OMP_CLAUSE_REDUCTION_TASK(NODE)    TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_REDUCTION))
 
#define OMP_CLAUSE_REDUCTION_INSCAN(NODE)    TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_REDUCTION))
 
#define OMP_CLAUSE_LINEAR_NO_COPYIN(NODE)    (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR)->base.public_flag)
 
#define OMP_CLAUSE_LINEAR_NO_COPYOUT(NODE)    TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR))
 
#define OMP_CLAUSE_LINEAR_VARIABLE_STRIDE(NODE)    TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR))
 
#define OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER(NODE)    (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR)->base.addressable_flag)
 
#define OMP_CLAUSE_LINEAR_ARRAY(NODE)    (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR)->base.deprecated_flag)
 
#define OMP_CLAUSE_LINEAR_STEP(NODE)    OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR), 1)
 
#define OMP_CLAUSE_LINEAR_STMT(NODE)    OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR), 2)
 
#define OMP_CLAUSE_LINEAR_GIMPLE_SEQ(NODE)    (OMP_CLAUSE_CHECK (NODE))->omp_clause.gimple_reduction_init
 
#define OMP_CLAUSE_LINEAR_KIND(NODE)    (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR)->omp_clause.subcode.linear_kind)
 
#define OMP_CLAUSE_ALIGNED_ALIGNMENT(NODE)    OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ALIGNED), 1)
 
#define OMP_CLAUSE_ALLOCATE_ALLOCATOR(NODE)    OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ALLOCATE), 1)
 
#define OMP_CLAUSE_ALLOCATE_ALIGN(NODE)    OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ALLOCATE), 2)
 
#define OMP_CLAUSE_ALLOCATE_COMBINED(NODE)    (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ALLOCATE)->base.public_flag)
 
#define OMP_CLAUSE_NUM_TEAMS_UPPER_EXPR(NODE)    OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_TEAMS), 0)
 
#define OMP_CLAUSE_NUM_TEAMS_LOWER_EXPR(NODE)    OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_TEAMS), 1)
 
#define OMP_CLAUSE_THREAD_LIMIT_EXPR(NODE)
 
#define OMP_CLAUSE_DEVICE_ID(NODE)    OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEVICE), 0)
 
#define OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR(NODE)
 
#define OMP_CLAUSE_SAFELEN_EXPR(NODE)    OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SAFELEN), 0)
 
#define OMP_CLAUSE_SIMDLEN_EXPR(NODE)    OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SIMDLEN), 0)
 
#define OMP_CLAUSE__SIMDUID__DECL(NODE)    OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE__SIMDUID_), 0)
 
#define OMP_CLAUSE_SCHEDULE_KIND(NODE)    (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SCHEDULE)->omp_clause.subcode.schedule_kind)
 
#define OMP_CLAUSE_SCHEDULE_SIMD(NODE)    (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SCHEDULE)->base.public_flag)
 
#define OMP_CLAUSE_DEFAULT_KIND(NODE)    (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEFAULT)->omp_clause.subcode.default_kind)
 
#define OMP_CLAUSE_DEFAULTMAP_KIND(NODE)    (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEFAULTMAP)->omp_clause.subcode.defaultmap_kind)
 
#define OMP_CLAUSE_DEFAULTMAP_CATEGORY(NODE)
 
#define OMP_CLAUSE_DEFAULTMAP_BEHAVIOR(NODE)
 
#define OMP_CLAUSE_DEFAULTMAP_SET_KIND(NODE, BEHAVIOR, CATEGORY)
 
#define OMP_CLAUSE_BIND_KIND(NODE)    (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_BIND)->omp_clause.subcode.bind_kind)
 
#define OMP_CLAUSE_ENTER_TO(NODE)    (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ENTER)->base.public_flag)
 
#define OMP_CLAUSE_TILE_LIST(NODE)    OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_TILE), 0)
 
#define OMP_CLAUSE_TILE_ITERVAR(NODE)    OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_TILE), 1)
 
#define OMP_CLAUSE_TILE_COUNT(NODE)    OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_TILE), 2)
 
#define OMP_CLAUSE__CONDTEMP__ITER(NODE)    (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE__CONDTEMP_)->base.public_flag)
 
#define OMP_CLAUSE__SCANTEMP__ALLOC(NODE)    (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE__SCANTEMP_)->base.public_flag)
 
#define OMP_CLAUSE__SCANTEMP__CONTROL(NODE)    TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE__SCANTEMP_))
 
#define SSA_NAME_IS_VIRTUAL_OPERAND(NODE)    SSA_NAME_CHECK (NODE)->base.public_flag
 
#define SSA_NAME_IDENTIFIER(NODE)
 
#define SSA_NAME_VAR(NODE)
 
#define SET_SSA_NAME_VAR_OR_IDENTIFIER(NODE, VAR)
 
#define SSA_NAME_DEF_STMT(NODE)   SSA_NAME_CHECK (NODE)->ssa_name.def_stmt
 
#define SSA_NAME_VERSION(NODE)   SSA_NAME_CHECK (NODE)->base.u.version
 
#define SSA_NAME_OCCURS_IN_ABNORMAL_PHI(NODE)    SSA_NAME_CHECK (NODE)->base.asm_written_flag
 
#define SSA_NAME_IN_FREE_LIST(NODE)    SSA_NAME_CHECK (NODE)->base.nothrow_flag
 
#define SSA_NAME_IS_DEFAULT_DEF(NODE)    SSA_NAME_CHECK (NODE)->base.default_def_flag
 
#define SSA_NAME_POINTS_TO_READONLY_MEMORY(NODE)    SSA_NAME_CHECK (NODE)->base.deprecated_flag
 
#define SSA_NAME_PTR_INFO(N)    SSA_NAME_CHECK (N)->ssa_name.info.ptr_info
 
#define SSA_NAME_RANGE_INFO(N)    SSA_NAME_CHECK (N)->ssa_name.info.range_info
 
#define SSA_NAME_IMM_USE_NODE(NODE)   SSA_NAME_CHECK (NODE)->ssa_name.imm_uses
 
#define OMP_CLAUSE_CODE(NODE)    (OMP_CLAUSE_CHECK (NODE))->omp_clause.code
 
#define OMP_CLAUSE_SET_CODE(NODE, CODE)    ((OMP_CLAUSE_CHECK (NODE))->omp_clause.code = (CODE))
 
#define OMP_CLAUSE_OPERAND(NODE, I)    OMP_CLAUSE_ELT_CHECK (NODE, I)
 
#define BLOCK_VARS(NODE)   (BLOCK_CHECK (NODE)->block.vars)
 
#define BLOCK_NONLOCALIZED_VARS(NODE)    (BLOCK_CHECK (NODE)->block.nonlocalized_vars)
 
#define BLOCK_NUM_NONLOCALIZED_VARS(NODE)    vec_safe_length (BLOCK_NONLOCALIZED_VARS (NODE))
 
#define BLOCK_NONLOCALIZED_VAR(NODE, N)   (*BLOCK_NONLOCALIZED_VARS (NODE))[N]
 
#define BLOCK_SUBBLOCKS(NODE)   (BLOCK_CHECK (NODE)->block.subblocks)
 
#define BLOCK_SUPERCONTEXT(NODE)   (BLOCK_CHECK (NODE)->block.supercontext)
 
#define BLOCK_CHAIN(NODE)   (BLOCK_CHECK (NODE)->block.chain)
 
#define BLOCK_ABSTRACT_ORIGIN(NODE)   (BLOCK_CHECK (NODE)->block.abstract_origin)
 
#define BLOCK_ORIGIN(NODE)    (BLOCK_ABSTRACT_ORIGIN(NODE) ? BLOCK_ABSTRACT_ORIGIN(NODE) : (NODE))
 
#define BLOCK_DIE(NODE)   (BLOCK_CHECK (NODE)->block.die)
 
#define BLOCK_SAME_RANGE(NODE)   (BLOCK_CHECK (NODE)->base.u.bits.nameless_flag)
 
#define BLOCK_IN_COLD_SECTION_P(NODE)    (BLOCK_CHECK (NODE)->base.u.bits.atomic_flag)
 
#define BLOCK_NUMBER(NODE)   (BLOCK_CHECK (NODE)->block.block_num)
 
#define BLOCK_FRAGMENT_ORIGIN(NODE)   (BLOCK_CHECK (NODE)->block.fragment_origin)
 
#define BLOCK_FRAGMENT_CHAIN(NODE)   (BLOCK_CHECK (NODE)->block.fragment_chain)
 
#define BLOCK_SOURCE_LOCATION(NODE)   (BLOCK_CHECK (NODE)->block.locus)
 
#define BLOCK_SOURCE_END_LOCATION(NODE)   (BLOCK_CHECK (NODE)->block.end_locus)
 
#define TYPE_UID(NODE)   (TYPE_CHECK (NODE)->type_common.uid)
 
#define TYPE_SIZE(NODE)   (TYPE_CHECK (NODE)->type_common.size)
 
#define TYPE_SIZE_UNIT(NODE)   (TYPE_CHECK (NODE)->type_common.size_unit)
 
#define TYPE_POINTER_TO(NODE)   (TYPE_CHECK (NODE)->type_common.pointer_to)
 
#define TYPE_REFERENCE_TO(NODE)   (TYPE_CHECK (NODE)->type_common.reference_to)
 
#define TYPE_PRECISION(NODE)    (TREE_NOT_CHECK (TYPE_CHECK (NODE), VECTOR_TYPE)->type_common.precision)
 
#define TYPE_PRECISION_RAW(NODE)   (TYPE_CHECK (NODE)->type_common.precision)
 
#define TYPE_NAME(NODE)   (TYPE_CHECK (NODE)->type_common.name)
 
#define TYPE_NEXT_VARIANT(NODE)   (TYPE_CHECK (NODE)->type_common.next_variant)
 
#define TYPE_MAIN_VARIANT(NODE)   (TYPE_CHECK (NODE)->type_common.main_variant)
 
#define TYPE_CONTEXT(NODE)   (TYPE_CHECK (NODE)->type_common.context)
 
#define TYPE_MODE_RAW(NODE)   (TYPE_CHECK (NODE)->type_common.mode)
 
#define TYPE_MODE(NODE)
 
#define SCALAR_TYPE_MODE(NODE)    (as_a <scalar_mode> (TYPE_CHECK (NODE)->type_common.mode))
 
#define SCALAR_INT_TYPE_MODE(NODE)    (as_a <scalar_int_mode> (TYPE_CHECK (NODE)->type_common.mode))
 
#define SCALAR_FLOAT_TYPE_MODE(NODE)    (as_a <scalar_float_mode> (TYPE_CHECK (NODE)->type_common.mode))
 
#define SET_TYPE_MODE(NODE, MODE)    (TYPE_CHECK (NODE)->type_common.mode = (MODE))
 
#define TYPE_CANONICAL(NODE)   (TYPE_CHECK (NODE)->type_common.canonical)
 
#define TYPE_STRUCTURAL_EQUALITY_P(NODE)   (TYPE_CANONICAL (NODE) == NULL_TREE)
 
#define SET_TYPE_STRUCTURAL_EQUALITY(NODE)   (TYPE_CANONICAL (NODE) = NULL_TREE)
 
#define TYPE_IBIT(NODE)   (GET_MODE_IBIT (TYPE_MODE (NODE)))
 
#define TYPE_FBIT(NODE)   (GET_MODE_FBIT (TYPE_MODE (NODE)))
 
#define TYPE_ALIAS_SET(NODE)   (TYPE_CHECK (NODE)->type_common.alias_set)
 
#define TYPE_ALIAS_SET_KNOWN_P(NODE)    (TYPE_CHECK (NODE)->type_common.alias_set != -1)
 
#define TYPE_ATTRIBUTES(NODE)   (TYPE_CHECK (NODE)->type_common.attributes)
 
#define TYPE_ALIGN_RAW(NODE)    (TYPE_CHECK (NODE)->type_common.align)
 
#define TYPE_ALIGN(NODE)
 
#define SET_TYPE_ALIGN(NODE, X)    (TYPE_CHECK (NODE)->type_common.align = ffs_hwi (X))
 
#define TYPE_USER_ALIGN(NODE)   (TYPE_CHECK (NODE)->base.u.bits.user_align)
 
#define TYPE_ALIGN_UNIT(NODE)   (TYPE_ALIGN (NODE) / BITS_PER_UNIT)
 
#define TYPE_WARN_IF_NOT_ALIGN(NODE)
 
#define SET_TYPE_WARN_IF_NOT_ALIGN(NODE, X)    (TYPE_CHECK (NODE)->type_common.warn_if_not_align = ffs_hwi (X))
 
#define TYPE_STUB_DECL(NODE)   (TREE_CHAIN (TYPE_CHECK (NODE)))
 
#define TYPE_NO_FORCE_BLK(NODE)    (TYPE_CHECK (NODE)->type_common.no_force_blk_flag)
 
#define TYPE_VOLATILE(NODE)   (TYPE_CHECK (NODE)->base.volatile_flag)
 
#define TYPE_ATOMIC(NODE)   (TYPE_CHECK (NODE)->base.u.bits.atomic_flag)
 
#define TYPE_READONLY(NODE)   (TYPE_CHECK (NODE)->base.readonly_flag)
 
#define TYPE_RESTRICT(NODE)   (TYPE_CHECK (NODE)->type_common.restrict_flag)
 
#define TYPE_NAMELESS(NODE)   (TYPE_CHECK (NODE)->base.u.bits.nameless_flag)
 
#define TYPE_ADDR_SPACE(NODE)   (TYPE_CHECK (NODE)->base.u.bits.address_space)
 
#define ENCODE_QUAL_ADDR_SPACE(NUM)   ((NUM & 0xFF) << 8)
 
#define DECODE_QUAL_ADDR_SPACE(X)   (((X) >> 8) & 0xFF)
 
#define CLEAR_QUAL_ADDR_SPACE(X)   ((X) & ~0xFF00)
 
#define KEEP_QUAL_ADDR_SPACE(X)   ((X) & 0xFF00)
 
#define TYPE_QUALS(NODE)
 
#define TYPE_QUALS_NO_ADDR_SPACE(NODE)
 
#define TYPE_QUALS_NO_ADDR_SPACE_NO_ATOMIC(NODE)
 
#define TYPE_LANG_FLAG_0(NODE)   (TYPE_CHECK (NODE)->type_common.lang_flag_0)
 
#define TYPE_LANG_FLAG_1(NODE)   (TYPE_CHECK (NODE)->type_common.lang_flag_1)
 
#define TYPE_LANG_FLAG_2(NODE)   (TYPE_CHECK (NODE)->type_common.lang_flag_2)
 
#define TYPE_LANG_FLAG_3(NODE)   (TYPE_CHECK (NODE)->type_common.lang_flag_3)
 
#define TYPE_LANG_FLAG_4(NODE)   (TYPE_CHECK (NODE)->type_common.lang_flag_4)
 
#define TYPE_LANG_FLAG_5(NODE)   (TYPE_CHECK (NODE)->type_common.lang_flag_5)
 
#define TYPE_LANG_FLAG_6(NODE)   (TYPE_CHECK (NODE)->type_common.lang_flag_6)
 
#define TYPE_LANG_FLAG_7(NODE)   (TYPE_CHECK (NODE)->type_common.lang_flag_7)
 
#define TREE_VISITED(NODE)   ((NODE)->base.visited)
 
#define TYPE_STRING_FLAG(NODE)    (ARRAY_OR_INTEGER_TYPE_CHECK (NODE)->type_common.string_flag)
 
#define TYPE_CXX_ODR_P(NODE)    (RECORD_OR_UNION_CHECK (NODE)->type_common.string_flag)
 
#define TYPE_VECTOR_OPAQUE(NODE)    (VECTOR_TYPE_CHECK (NODE)->base.default_def_flag)
 
#define TYPE_NEEDS_CONSTRUCTING(NODE)    (TYPE_CHECK (NODE)->type_common.needs_constructing_flag)
 
#define TYPE_TRANSPARENT_AGGR(NODE)    (RECORD_OR_UNION_CHECK (NODE)->type_common.transparent_aggr_flag)
 
#define TYPE_NONALIASED_COMPONENT(NODE)    (ARRAY_TYPE_CHECK (NODE)->type_common.transparent_aggr_flag)
 
#define TYPE_TYPELESS_STORAGE(NODE)
 
#define TYPE_PACKED(NODE)   (TYPE_CHECK (NODE)->base.u.bits.packed_flag)
 
#define TYPE_CONTAINS_PLACEHOLDER_INTERNAL(NODE)    (TYPE_CHECK (NODE)->type_common.contains_placeholder_bits)
 
#define TYPE_FINAL_P(NODE)    (RECORD_OR_UNION_CHECK (NODE)->base.default_def_flag)
 
#define TYPE_SYMTAB_ADDRESS(NODE)    (TYPE_CHECK (NODE)->type_common.symtab.address)
 
#define TYPE_SYMTAB_DIE(NODE)    (TYPE_CHECK (NODE)->type_common.symtab.die)
 
#define TYPE_SYMTAB_IS_ADDRESS   (0)
 
#define TYPE_SYMTAB_IS_DIE   (1)
 
#define TYPE_LANG_SPECIFIC(NODE)    (TYPE_CHECK (NODE)->type_with_lang_specific.lang_specific)
 
#define TYPE_VALUES(NODE)   (ENUMERAL_TYPE_CHECK (NODE)->type_non_common.values)
 
#define TYPE_DOMAIN(NODE)   (ARRAY_TYPE_CHECK (NODE)->type_non_common.values)
 
#define TYPE_FIELDS(NODE)    (RECORD_OR_UNION_CHECK (NODE)->type_non_common.values)
 
#define TYPE_CACHED_VALUES(NODE)   (TYPE_CHECK (NODE)->type_non_common.values)
 
#define TYPE_ARG_TYPES(NODE)    (FUNC_OR_METHOD_CHECK (NODE)->type_non_common.values)
 
#define TYPE_VALUES_RAW(NODE)   (TYPE_CHECK (NODE)->type_non_common.values)
 
#define TYPE_MIN_VALUE(NODE)    (NUMERICAL_TYPE_CHECK (NODE)->type_non_common.minval)
 
#define TYPE_NEXT_PTR_TO(NODE)    (POINTER_TYPE_CHECK (NODE)->type_non_common.minval)
 
#define TYPE_NEXT_REF_TO(NODE)    (REFERENCE_TYPE_CHECK (NODE)->type_non_common.minval)
 
#define TYPE_VFIELD(NODE)    (RECORD_OR_UNION_CHECK (NODE)->type_non_common.minval)
 
#define TYPE_MIN_VALUE_RAW(NODE)   (TYPE_CHECK (NODE)->type_non_common.minval)
 
#define TYPE_MAX_VALUE(NODE)    (NUMERICAL_TYPE_CHECK (NODE)->type_non_common.maxval)
 
#define TYPE_METHOD_BASETYPE(NODE)    (FUNC_OR_METHOD_CHECK (NODE)->type_non_common.maxval)
 
#define TYPE_OFFSET_BASETYPE(NODE)    (OFFSET_TYPE_CHECK (NODE)->type_non_common.maxval)
 
#define TYPE_ARRAY_MAX_SIZE(ARRAY_TYPE)    (ARRAY_TYPE_CHECK (ARRAY_TYPE)->type_non_common.maxval)
 
#define TYPE_MAX_VALUE_RAW(NODE)   (TYPE_CHECK (NODE)->type_non_common.maxval)
 
#define TYPE_BINFO(NODE)   (RECORD_OR_UNION_CHECK (NODE)->type_non_common.maxval)
 
#define TYPE_LANG_SLOT_1(NODE)    (TYPE_CHECK (NODE)->type_non_common.lang_1)
 
#define BINFO_VIRTUAL_P(NODE)   (TREE_BINFO_CHECK (NODE)->base.static_flag)
 
#define BINFO_FLAG_0(NODE)   TREE_LANG_FLAG_0 (TREE_BINFO_CHECK (NODE))
 
#define BINFO_FLAG_1(NODE)   TREE_LANG_FLAG_1 (TREE_BINFO_CHECK (NODE))
 
#define BINFO_FLAG_2(NODE)   TREE_LANG_FLAG_2 (TREE_BINFO_CHECK (NODE))
 
#define BINFO_FLAG_3(NODE)   TREE_LANG_FLAG_3 (TREE_BINFO_CHECK (NODE))
 
#define BINFO_FLAG_4(NODE)   TREE_LANG_FLAG_4 (TREE_BINFO_CHECK (NODE))
 
#define BINFO_FLAG_5(NODE)   TREE_LANG_FLAG_5 (TREE_BINFO_CHECK (NODE))
 
#define BINFO_FLAG_6(NODE)   TREE_LANG_FLAG_6 (TREE_BINFO_CHECK (NODE))
 
#define BINFO_TYPE(NODE)   TREE_TYPE (TREE_BINFO_CHECK (NODE))
 
#define BINFO_OFFSET(NODE)   (TREE_BINFO_CHECK (NODE)->binfo.offset)
 
#define BINFO_OFFSET_ZEROP(NODE)   (integer_zerop (BINFO_OFFSET (NODE)))
 
#define BINFO_VTABLE(NODE)   (TREE_BINFO_CHECK (NODE)->binfo.vtable)
 
#define BINFO_VIRTUALS(NODE)   (TREE_BINFO_CHECK (NODE)->binfo.virtuals)
 
#define BINFO_BASE_BINFOS(NODE)   (&TREE_BINFO_CHECK (NODE)->binfo.base_binfos)
 
#define BINFO_N_BASE_BINFOS(NODE)   (BINFO_BASE_BINFOS (NODE)->length ())
 
#define BINFO_BASE_BINFO(NODE, N)    ((*BINFO_BASE_BINFOS (NODE))[(N)])
 
#define BINFO_BASE_ITERATE(NODE, N, B)    (BINFO_BASE_BINFOS (NODE)->iterate ((N), &(B)))
 
#define BINFO_BASE_APPEND(NODE, T)    (BINFO_BASE_BINFOS (NODE)->quick_push ((T)))
 
#define BINFO_VPTR_FIELD(NODE)   (TREE_BINFO_CHECK (NODE)->binfo.vptr_field)
 
#define BINFO_BASE_ACCESSES(NODE)    (TREE_BINFO_CHECK (NODE)->binfo.base_accesses)
 
#define BINFO_BASE_ACCESS(NODE, N)    (*BINFO_BASE_ACCESSES (NODE))[(N)]
 
#define BINFO_BASE_ACCESS_APPEND(NODE, T)    BINFO_BASE_ACCESSES (NODE)->quick_push ((T))
 
#define BINFO_SUBVTT_INDEX(NODE)   (TREE_BINFO_CHECK (NODE)->binfo.vtt_subvtt)
 
#define BINFO_VPTR_INDEX(NODE)   (TREE_BINFO_CHECK (NODE)->binfo.vtt_vptr)
 
#define BINFO_INHERITANCE_CHAIN(NODE)    (TREE_BINFO_CHECK (NODE)->binfo.inheritance)
 
#define SSA_VAR_P(DECL)
 
#define DECL_CHAIN(NODE)   (TREE_CHAIN (DECL_MINIMAL_CHECK (NODE)))
 
#define DECL_NAME(NODE)   (DECL_MINIMAL_CHECK (NODE)->decl_minimal.name)
 
#define TYPE_IDENTIFIER(NODE)
 
#define DECL_UID(NODE)   (DECL_MINIMAL_CHECK (NODE)->decl_minimal.uid)
 
#define DEBUG_TEMP_UID(NODE)   (-DECL_UID (TREE_CHECK ((NODE), DEBUG_EXPR_DECL)))
 
#define DECL_PT_UID(NODE)
 
#define SET_DECL_PT_UID(NODE, UID)    (DECL_COMMON_CHECK (NODE)->decl_common.pt_uid = (UID))
 
#define DECL_PT_UID_SET_P(NODE)    (DECL_COMMON_CHECK (NODE)->decl_common.pt_uid != -1u)
 
#define DECL_SOURCE_LOCATION(NODE)    (DECL_MINIMAL_CHECK (NODE)->decl_minimal.locus)
 
#define DECL_SOURCE_FILE(NODE)   LOCATION_FILE (DECL_SOURCE_LOCATION (NODE))
 
#define DECL_SOURCE_LINE(NODE)   LOCATION_LINE (DECL_SOURCE_LOCATION (NODE))
 
#define DECL_SOURCE_COLUMN(NODE)   LOCATION_COLUMN (DECL_SOURCE_LOCATION (NODE))
 
#define DECL_IS_UNDECLARED_BUILTIN(DECL)    (DECL_SOURCE_LOCATION (DECL) <= BUILTINS_LOCATION)
 
#define DECL_CONTEXT(NODE)   (DECL_MINIMAL_CHECK (NODE)->decl_minimal.context)
 
#define DECL_FIELD_CONTEXT(NODE)    (FIELD_DECL_CHECK (NODE)->decl_minimal.context)
 
#define DECL_NAMELESS(NODE)   (DECL_MINIMAL_CHECK (NODE)->base.u.bits.nameless_flag)
 
#define DECL_ABSTRACT_ORIGIN(NODE)    (DECL_COMMON_CHECK (NODE)->decl_common.abstract_origin)
 
#define DECL_ORIGIN(NODE)    (DECL_ABSTRACT_ORIGIN (NODE) ? DECL_ABSTRACT_ORIGIN (NODE) : (NODE))
 
#define DECL_FROM_INLINE(NODE)
 
#define DECL_ATTRIBUTES(NODE)    (DECL_COMMON_CHECK (NODE)->decl_common.attributes)
 
#define DECL_INITIAL(NODE)   (DECL_COMMON_CHECK (NODE)->decl_common.initial)
 
#define DECL_SIZE(NODE)   (DECL_COMMON_CHECK (NODE)->decl_common.size)
 
#define DECL_SIZE_UNIT(NODE)   (DECL_COMMON_CHECK (NODE)->decl_common.size_unit)
 
#define DECL_ALIGN_RAW(NODE)   (DECL_COMMON_CHECK (NODE)->decl_common.align)
 
#define DECL_ALIGN(NODE)
 
#define SET_DECL_ALIGN(NODE, X)    (DECL_ALIGN_RAW (NODE) = ffs_hwi (X))
 
#define DECL_WARN_IF_NOT_ALIGN_RAW(NODE)    (DECL_COMMON_CHECK (NODE)->decl_common.warn_if_not_align)
 
#define DECL_WARN_IF_NOT_ALIGN(NODE)
 
#define SET_DECL_WARN_IF_NOT_ALIGN(NODE, X)    (DECL_WARN_IF_NOT_ALIGN_RAW (NODE) = ffs_hwi (X))
 
#define DECL_ALIGN_UNIT(NODE)   (DECL_ALIGN (NODE) / BITS_PER_UNIT)
 
#define DECL_USER_ALIGN(NODE)    (DECL_COMMON_CHECK (NODE)->base.u.bits.user_align)
 
#define DECL_MODE(NODE)   (DECL_COMMON_CHECK (NODE)->decl_common.mode)
 
#define SET_DECL_MODE(NODE, MODE)    (DECL_COMMON_CHECK (NODE)->decl_common.mode = (MODE))
 
#define DECL_UNCHECKED_FUNCTION_CODE(NODE)    (FUNCTION_DECL_CHECK (NODE)->function_decl.function_code)
 
#define ALLOCA_FUNCTION_CODE_P(FCODE)
 
#define CASE_BUILT_IN_ALLOCA
 
#define DECL_FUNCTION_PERSONALITY(NODE)    (FUNCTION_DECL_CHECK (NODE)->function_decl.personality)
 
#define DECL_IGNORED_P(NODE)    (DECL_COMMON_CHECK (NODE)->decl_common.ignored_flag)
 
#define DECL_ABSTRACT_P(NODE)    (DECL_COMMON_CHECK (NODE)->decl_common.abstract_flag)
 
#define DECL_LANG_SPECIFIC(NODE)    (DECL_COMMON_CHECK (NODE)->decl_common.lang_specific)
 
#define DECL_EXTERNAL(NODE)   (DECL_COMMON_CHECK (NODE)->decl_common.decl_flag_1)
 
#define DECL_NONLOCAL(NODE)    (DECL_COMMON_CHECK (NODE)->decl_common.nonlocal_flag)
 
#define DECL_VIRTUAL_P(NODE)    (DECL_COMMON_CHECK (NODE)->decl_common.virtual_flag)
 
#define DECL_ARTIFICIAL(NODE)    (DECL_COMMON_CHECK (NODE)->decl_common.artificial_flag)
 
#define DECL_LANG_FLAG_0(NODE)    (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_0)
 
#define DECL_LANG_FLAG_1(NODE)    (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_1)
 
#define DECL_LANG_FLAG_2(NODE)    (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_2)
 
#define DECL_LANG_FLAG_3(NODE)    (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_3)
 
#define DECL_LANG_FLAG_4(NODE)    (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_4)
 
#define DECL_LANG_FLAG_5(NODE)    (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_5)
 
#define DECL_LANG_FLAG_6(NODE)    (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_6)
 
#define DECL_LANG_FLAG_7(NODE)    (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_7)
 
#define DECL_LANG_FLAG_8(NODE)    (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_8)
 
#define SCOPE_FILE_SCOPE_P(EXP)    (! (EXP) || TREE_CODE (EXP) == TRANSLATION_UNIT_DECL)
 
#define DECL_FILE_SCOPE_P(EXP)   SCOPE_FILE_SCOPE_P (DECL_CONTEXT (EXP))
 
#define TYPE_FILE_SCOPE_P(EXP)   SCOPE_FILE_SCOPE_P (TYPE_CONTEXT (EXP))
 
#define DECL_PRESERVE_P(DECL)    DECL_COMMON_CHECK (DECL)->decl_common.preserve_flag
 
#define DECL_NOINIT_P(DECL)
 
#define DECL_PERSISTENT_P(DECL)
 
#define DECL_NOT_GIMPLE_REG_P(DECL)    DECL_COMMON_CHECK (DECL)->decl_common.not_gimple_reg_flag
 
#define DECL_HAS_VALUE_EXPR_P(NODE)
 
#define DECL_VALUE_EXPR(NODE)    (decl_value_expr_lookup (DECL_WRTL_CHECK (NODE)))
 
#define SET_DECL_VALUE_EXPR(NODE, VAL)    (decl_value_expr_insert (DECL_WRTL_CHECK (NODE), VAL))
 
#define DECL_RTL(NODE)
 
#define SET_DECL_RTL(NODE, RTL)   set_decl_rtl (NODE, RTL)
 
#define HAS_RTL_P(NODE)   (CODE_CONTAINS_STRUCT (TREE_CODE (NODE), TS_DECL_WRTL))
 
#define DECL_RTL_SET_P(NODE)    (HAS_RTL_P (NODE) && DECL_WRTL_CHECK (NODE)->decl_with_rtl.rtl != NULL)
 
#define COPY_DECL_RTL(SRC_DECL, DST_DECL)
 
#define DECL_RTL_IF_SET(NODE)   (DECL_RTL_SET_P (NODE) ? DECL_RTL (NODE) : NULL)
 
#define DECL_RTL_KNOWN_SET(decl)   (&*DECL_RTL_IF_SET (decl))
 
#define DECL_REGISTER(NODE)   (DECL_WRTL_CHECK (NODE)->decl_common.decl_flag_0)
 
#define DECL_FIELD_OFFSET(NODE)   (FIELD_DECL_CHECK (NODE)->field_decl.offset)
 
#define DECL_FIELD_BIT_OFFSET(NODE)    (FIELD_DECL_CHECK (NODE)->field_decl.bit_offset)
 
#define DECL_BIT_FIELD_TYPE(NODE)    (FIELD_DECL_CHECK (NODE)->field_decl.bit_field_type)
 
#define DECL_BIT_FIELD_REPRESENTATIVE(NODE)    (FIELD_DECL_CHECK (NODE)->field_decl.qualifier)
 
#define DECL_QUALIFIER(NODE)   (FIELD_DECL_CHECK (NODE)->field_decl.qualifier)
 
#define DECL_OFFSET_ALIGN(NODE)    (HOST_WIDE_INT_1U << FIELD_DECL_CHECK (NODE)->decl_common.off_align)
 
#define SET_DECL_OFFSET_ALIGN(NODE, X)    (FIELD_DECL_CHECK (NODE)->decl_common.off_align = ffs_hwi (X) - 1)
 
#define DECL_FCONTEXT(NODE)   (FIELD_DECL_CHECK (NODE)->field_decl.fcontext)
 
#define DECL_PACKED(NODE)   (FIELD_DECL_CHECK (NODE)->base.u.bits.packed_flag)
 
#define DECL_BIT_FIELD(NODE)   (FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_1)
 
#define DECL_FIELD_ABI_IGNORED(NODE)    (!DECL_BIT_FIELD (NODE) && (NODE)->decl_common.decl_flag_0)
 
#define SET_DECL_FIELD_ABI_IGNORED(NODE, VAL)
 
#define DECL_FIELD_CXX_ZERO_WIDTH_BIT_FIELD(NODE)    (DECL_BIT_FIELD (NODE) && (NODE)->decl_common.decl_flag_0)
 
#define SET_DECL_FIELD_CXX_ZERO_WIDTH_BIT_FIELD(NODE, VAL)
 
#define DECL_NONADDRESSABLE_P(NODE)    (FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_2)
 
#define DECL_PADDING_P(NODE)    (FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_3)
 
#define DECL_NOT_FLEXARRAY(NODE)    (FIELD_DECL_CHECK (NODE)->decl_common.decl_not_flexarray)
 
#define LABEL_DECL_UID(NODE)    (LABEL_DECL_CHECK (NODE)->label_decl.label_decl_uid)
 
#define EH_LANDING_PAD_NR(NODE)    (LABEL_DECL_CHECK (NODE)->label_decl.eh_landing_pad_nr)
 
#define DECL_ARG_TYPE(NODE)   (PARM_DECL_CHECK (NODE)->decl_common.initial)
 
#define DECL_INCOMING_RTL(NODE)    (PARM_DECL_CHECK (NODE)->parm_decl.incoming_rtl)
 
#define DECL_IN_SYSTEM_HEADER(NODE)    (in_system_header_at (DECL_SOURCE_LOCATION (NODE)))
 
#define DECL_DEFER_OUTPUT(NODE)    (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.defer_output)
 
#define DECL_IN_TEXT_SECTION(NODE)    (VAR_DECL_CHECK (NODE)->decl_with_vis.in_text_section)
 
#define DECL_IN_CONSTANT_POOL(NODE)    (VAR_DECL_CHECK (NODE)->decl_with_vis.in_constant_pool)
 
#define DECL_COMMON(NODE)    (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.common_flag)
 
#define DECL_HARD_REGISTER(NODE)    (VAR_DECL_CHECK (NODE)->decl_with_vis.hard_register)
 
#define DECL_WEAK(NODE)   (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.weak_flag)
 
#define DECL_DLLIMPORT_P(NODE)    (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.dllimport_flag)
 
#define DECL_COMDAT(NODE)    (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.comdat_flag)
 
#define DECL_COMDAT_GROUP(NODE)    decl_comdat_group (NODE)
 
#define DECL_ONE_ONLY(NODE)
 
#define DECL_ASSEMBLER_NAME(NODE)   decl_assembler_name (NODE)
 
#define DECL_ASSEMBLER_NAME_RAW(NODE)    (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.assembler_name)
 
#define HAS_DECL_ASSEMBLER_NAME_P(NODE)    (CODE_CONTAINS_STRUCT (TREE_CODE (NODE), TS_DECL_WITH_VIS))
 
#define DECL_ASSEMBLER_NAME_SET_P(NODE)    (DECL_ASSEMBLER_NAME_RAW (NODE) != NULL_TREE)
 
#define SET_DECL_ASSEMBLER_NAME(NODE, NAME)    overwrite_decl_assembler_name (NODE, NAME)
 
#define COPY_DECL_ASSEMBLER_NAME(SRC_DECL, DST_DECL)    SET_DECL_ASSEMBLER_NAME (DST_DECL, DECL_ASSEMBLER_NAME_RAW (SRC_DECL))
 
#define DECL_SECTION_NAME(NODE)   decl_section_name (NODE)
 
#define DECL_SEEN_IN_BIND_EXPR_P(NODE)    (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.seen_in_bind_expr)
 
#define DECL_VISIBILITY(NODE)    (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.visibility)
 
#define DECL_VISIBILITY_SPECIFIED(NODE)    (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.visibility_specified)
 
#define DECL_TLS_MODEL(NODE)   decl_tls_model (NODE)
 
#define DECL_THREAD_LOCAL_P(NODE)    ((TREE_STATIC (NODE) || DECL_EXTERNAL (NODE)) && decl_tls_model (NODE) >= TLS_MODEL_REAL)
 
#define DECL_HAS_INIT_PRIORITY_P(NODE)    (VAR_DECL_CHECK (NODE)->decl_with_vis.init_priority_p)
 
#define DECL_HAS_DEBUG_EXPR_P(NODE)    (VAR_DECL_CHECK (NODE)->decl_common.debug_expr_is_from)
 
#define DECL_DEBUG_EXPR(NODE)    (decl_debug_expr_lookup (VAR_DECL_CHECK (NODE)))
 
#define SET_DECL_DEBUG_EXPR(NODE, VAL)    (decl_debug_expr_insert (VAR_DECL_CHECK (NODE), VAL))
 
#define DECL_INIT_PRIORITY(NODE)    (decl_init_priority_lookup (NODE))
 
#define SET_DECL_INIT_PRIORITY(NODE, VAL)    (decl_init_priority_insert (NODE, VAL))
 
#define DECL_FINI_PRIORITY(NODE)    (decl_fini_priority_lookup (NODE))
 
#define SET_DECL_FINI_PRIORITY(NODE, VAL)    (decl_fini_priority_insert (NODE, VAL))
 
#define DEFAULT_INIT_PRIORITY   65535
 
#define MAX_INIT_PRIORITY   65535
 
#define MAX_RESERVED_INIT_PRIORITY   100
 
#define VAR_DECL_IS_VIRTUAL_OPERAND(NODE)    (VAR_DECL_CHECK (NODE)->base.u.bits.saturating_flag)
 
#define DECL_NONLOCAL_FRAME(NODE)    (VAR_DECL_CHECK (NODE)->base.default_def_flag)
 
#define DECL_NONALIASED(NODE)    (VAR_DECL_CHECK (NODE)->base.nothrow_flag)
 
#define DECL_MERGEABLE(NODE)    (VAR_DECL_CHECK (NODE)->decl_common.decl_flag_3)
 
#define DECL_RESULT_FLD(NODE)    (DECL_NON_COMMON_CHECK (NODE)->decl_non_common.result)
 
#define DECL_VINDEX(NODE)    (FUNCTION_DECL_CHECK (NODE)->function_decl.vindex)
 
#define DECL_RESULT(NODE)   (FUNCTION_DECL_CHECK (NODE)->decl_non_common.result)
 
#define DECL_UNINLINABLE(NODE)    (FUNCTION_DECL_CHECK (NODE)->function_decl.uninlinable)
 
#define DECL_SAVED_TREE(NODE)    (FUNCTION_DECL_CHECK (NODE)->function_decl.saved_tree)
 
#define DECL_IS_MALLOC(NODE)    (FUNCTION_DECL_CHECK (NODE)->function_decl.malloc_flag)
 
#define FUNCTION_DECL_DECL_TYPE(NODE)    (NODE->function_decl.decl_type)
 
#define DECL_IS_REPLACEABLE_OPERATOR(NODE)    (FUNCTION_DECL_CHECK (NODE)->function_decl.replaceable_operator)
 
#define DECL_IS_OPERATOR_NEW_P(NODE)    (FUNCTION_DECL_DECL_TYPE (FUNCTION_DECL_CHECK (NODE)) == OPERATOR_NEW)
 
#define DECL_IS_REPLACEABLE_OPERATOR_NEW_P(NODE)    (DECL_IS_OPERATOR_NEW_P (NODE) && DECL_IS_REPLACEABLE_OPERATOR (NODE))
 
#define DECL_SET_IS_OPERATOR_NEW(NODE, VAL)    set_function_decl_type (FUNCTION_DECL_CHECK (NODE), OPERATOR_NEW, VAL)
 
#define DECL_IS_OPERATOR_DELETE_P(NODE)    (FUNCTION_DECL_DECL_TYPE (FUNCTION_DECL_CHECK (NODE)) == OPERATOR_DELETE)
 
#define DECL_SET_IS_OPERATOR_DELETE(NODE, VAL)    set_function_decl_type (FUNCTION_DECL_CHECK (NODE), OPERATOR_DELETE, VAL)
 
#define DECL_IS_RETURNS_TWICE(NODE)    (FUNCTION_DECL_CHECK (NODE)->function_decl.returns_twice_flag)
 
#define DECL_PURE_P(NODE)   (FUNCTION_DECL_CHECK (NODE)->function_decl.pure_flag)
 
#define DECL_LOOPING_CONST_OR_PURE_P(NODE)    (FUNCTION_DECL_CHECK (NODE)->function_decl.looping_const_or_pure_flag)
 
#define DECL_IS_NOVOPS(NODE)    (FUNCTION_DECL_CHECK (NODE)->function_decl.novops_flag)
 
#define DECL_STATIC_CONSTRUCTOR(NODE)    (FUNCTION_DECL_CHECK (NODE)->function_decl.static_ctor_flag)
 
#define DECL_STATIC_DESTRUCTOR(NODE)   (FUNCTION_DECL_CHECK (NODE)->function_decl.static_dtor_flag)
 
#define DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT(NODE)    (FUNCTION_DECL_CHECK (NODE)->function_decl.no_instrument_function_entry_exit)
 
#define DECL_NO_LIMIT_STACK(NODE)    (FUNCTION_DECL_CHECK (NODE)->function_decl.no_limit_stack)
 
#define DECL_STATIC_CHAIN(NODE)    (FUNCTION_DECL_CHECK (NODE)->decl_with_vis.regdecl_flag)
 
#define DECL_POSSIBLY_INLINED(DECL)    FUNCTION_DECL_CHECK (DECL)->function_decl.possibly_inlined
 
#define DECL_DECLARED_INLINE_P(NODE)    (FUNCTION_DECL_CHECK (NODE)->function_decl.declared_inline_flag)
 
#define DECL_NO_INLINE_WARNING_P(NODE)    (FUNCTION_DECL_CHECK (NODE)->function_decl.no_inline_warning_flag)
 
#define BUILTIN_TM_LOAD_STORE_P(FN)    ((FN) >= BUILT_IN_TM_STORE_1 && (FN) <= BUILT_IN_TM_LOAD_RFW_LDOUBLE)
 
#define BUILTIN_TM_LOAD_P(FN)    ((FN) >= BUILT_IN_TM_LOAD_1 && (FN) <= BUILT_IN_TM_LOAD_RFW_LDOUBLE)
 
#define BUILTIN_TM_STORE_P(FN)    ((FN) >= BUILT_IN_TM_STORE_1 && (FN) <= BUILT_IN_TM_STORE_WAW_LDOUBLE)
 
#define CASE_BUILT_IN_TM_LOAD(FN)
 
#define CASE_BUILT_IN_TM_STORE(FN)
 
#define DECL_DISREGARD_INLINE_LIMITS(NODE)    (FUNCTION_DECL_CHECK (NODE)->function_decl.disregard_inline_limits)
 
#define DECL_HAS_DEBUG_ARGS_P(NODE)    (FUNCTION_DECL_CHECK (NODE)->function_decl.has_debug_args_flag)
 
#define DECL_STRUCT_FUNCTION(NODE)    (FUNCTION_DECL_CHECK (NODE)->function_decl.f)
 
#define DECL_BUILT_IN_CLASS(NODE)    ((built_in_class) FUNCTION_DECL_CHECK (NODE)->function_decl.built_in_class)
 
#define DECL_ARGUMENTS(NODE)    (FUNCTION_DECL_CHECK (NODE)->function_decl.arguments)
 
#define DECL_FUNCTION_SPECIFIC_TARGET(NODE)    (FUNCTION_DECL_CHECK (NODE)->function_decl.function_specific_target)
 
#define DECL_FUNCTION_SPECIFIC_OPTIMIZATION(NODE)    (FUNCTION_DECL_CHECK (NODE)->function_decl.function_specific_optimization)
 
#define DECL_FUNCTION_VERSIONED(NODE)    (FUNCTION_DECL_CHECK (NODE)->function_decl.versioned_function)
 
#define DECL_CXX_CONSTRUCTOR_P(NODE)    (FUNCTION_DECL_CHECK (NODE)->decl_with_vis.cxx_constructor)
 
#define DECL_CXX_DESTRUCTOR_P(NODE)    (FUNCTION_DECL_CHECK (NODE)->decl_with_vis.cxx_destructor)
 
#define DECL_LAMBDA_FUNCTION_P(NODE)    (FUNCTION_DECL_DECL_TYPE (FUNCTION_DECL_CHECK (NODE)) == LAMBDA_FUNCTION)
 
#define DECL_SET_LAMBDA_FUNCTION(NODE, VAL)    set_function_decl_type (FUNCTION_DECL_CHECK (NODE), LAMBDA_FUNCTION, VAL)
 
#define DECL_FINAL_P(NODE)    (FUNCTION_DECL_CHECK (NODE)->decl_with_vis.final)
 
#define TRANSLATION_UNIT_LANGUAGE(NODE)    (TRANSLATION_UNIT_DECL_CHECK (NODE)->translation_unit_decl.language)
 
#define DECL_ORIGINAL_TYPE(NODE)    (TYPE_DECL_CHECK (NODE)->decl_non_common.result)
 
#define TYPE_DECL_SUPPRESS_DEBUG(NODE)    (TYPE_DECL_CHECK (NODE)->decl_common.decl_flag_1)
 
#define IMPORTED_DECL_ASSOCIATED_DECL(NODE)   (DECL_INITIAL (IMPORTED_DECL_CHECK (NODE)))
 
#define NAMELIST_DECL_ASSOCIATED_DECL(NODE)    (DECL_INITIAL (NODE))
 
#define STATEMENT_LIST_HEAD(NODE)    (STATEMENT_LIST_CHECK (NODE)->stmt_list.head)
 
#define STATEMENT_LIST_TAIL(NODE)    (STATEMENT_LIST_CHECK (NODE)->stmt_list.tail)
 
#define TREE_OPTIMIZATION(NODE)    (OPTIMIZATION_NODE_CHECK (NODE)->optimization.opts)
 
#define TREE_OPTIMIZATION_OPTABS(NODE)    (OPTIMIZATION_NODE_CHECK (NODE)->optimization.optabs)
 
#define TREE_OPTIMIZATION_BASE_OPTABS(NODE)    (OPTIMIZATION_NODE_CHECK (NODE)->optimization.base_optabs)
 
#define TREE_TARGET_OPTION(NODE)    (TARGET_OPTION_NODE_CHECK (NODE)->target_option.opts)
 
#define TREE_TARGET_GLOBALS(NODE)    (TARGET_OPTION_NODE_CHECK (NODE)->target_option.globals)
 
#define EXPR_LOCATION_WRAPPER_P(NODE)    (TREE_CHECK2(NODE, NON_LVALUE_EXPR, VIEW_CONVERT_EXPR)->base.public_flag)
 
#define error_mark_node   global_trees[TI_ERROR_MARK]
 
#define intQI_type_node   global_trees[TI_INTQI_TYPE]
 
#define intHI_type_node   global_trees[TI_INTHI_TYPE]
 
#define intSI_type_node   global_trees[TI_INTSI_TYPE]
 
#define intDI_type_node   global_trees[TI_INTDI_TYPE]
 
#define intTI_type_node   global_trees[TI_INTTI_TYPE]
 
#define unsigned_intQI_type_node   global_trees[TI_UINTQI_TYPE]
 
#define unsigned_intHI_type_node   global_trees[TI_UINTHI_TYPE]
 
#define unsigned_intSI_type_node   global_trees[TI_UINTSI_TYPE]
 
#define unsigned_intDI_type_node   global_trees[TI_UINTDI_TYPE]
 
#define unsigned_intTI_type_node   global_trees[TI_UINTTI_TYPE]
 
#define atomicQI_type_node   global_trees[TI_ATOMICQI_TYPE]
 
#define atomicHI_type_node   global_trees[TI_ATOMICHI_TYPE]
 
#define atomicSI_type_node   global_trees[TI_ATOMICSI_TYPE]
 
#define atomicDI_type_node   global_trees[TI_ATOMICDI_TYPE]
 
#define atomicTI_type_node   global_trees[TI_ATOMICTI_TYPE]
 
#define uint16_type_node   global_trees[TI_UINT16_TYPE]
 
#define uint32_type_node   global_trees[TI_UINT32_TYPE]
 
#define uint64_type_node   global_trees[TI_UINT64_TYPE]
 
#define uint128_type_node   global_trees[TI_UINT128_TYPE]
 
#define void_node   global_trees[TI_VOID]
 
#define integer_zero_node   global_trees[TI_INTEGER_ZERO]
 
#define integer_one_node   global_trees[TI_INTEGER_ONE]
 
#define integer_three_node   global_trees[TI_INTEGER_THREE]
 
#define integer_minus_one_node   global_trees[TI_INTEGER_MINUS_ONE]
 
#define size_zero_node   global_trees[TI_SIZE_ZERO]
 
#define size_one_node   global_trees[TI_SIZE_ONE]
 
#define bitsize_zero_node   global_trees[TI_BITSIZE_ZERO]
 
#define bitsize_one_node   global_trees[TI_BITSIZE_ONE]
 
#define bitsize_unit_node   global_trees[TI_BITSIZE_UNIT]
 
#define access_public_node   global_trees[TI_PUBLIC]
 
#define access_protected_node   global_trees[TI_PROTECTED]
 
#define access_private_node   global_trees[TI_PRIVATE]
 
#define null_pointer_node   global_trees[TI_NULL_POINTER]
 
#define float_type_node   global_trees[TI_FLOAT_TYPE]
 
#define double_type_node   global_trees[TI_DOUBLE_TYPE]
 
#define long_double_type_node   global_trees[TI_LONG_DOUBLE_TYPE]
 
#define bfloat16_type_node   global_trees[TI_BFLOAT16_TYPE]
 
#define FLOATN_TYPE_NODE(IDX)   global_trees[TI_FLOATN_TYPE_FIRST + (IDX)]
 
#define FLOATN_NX_TYPE_NODE(IDX)   global_trees[TI_FLOATN_NX_TYPE_FIRST + (IDX)]
 
#define FLOATNX_TYPE_NODE(IDX)   global_trees[TI_FLOATNX_TYPE_FIRST + (IDX)]
 
#define float16_type_node   global_trees[TI_FLOAT16_TYPE]
 
#define float32_type_node   global_trees[TI_FLOAT32_TYPE]
 
#define float64_type_node   global_trees[TI_FLOAT64_TYPE]
 
#define float128_type_node   global_trees[TI_FLOAT128_TYPE]
 
#define float32x_type_node   global_trees[TI_FLOAT32X_TYPE]
 
#define float64x_type_node   global_trees[TI_FLOAT64X_TYPE]
 
#define float128x_type_node   global_trees[TI_FLOAT128X_TYPE]
 
#define float128t_type_node   global_trees[TI_FLOAT128T_TYPE]
 
#define float_ptr_type_node   global_trees[TI_FLOAT_PTR_TYPE]
 
#define double_ptr_type_node   global_trees[TI_DOUBLE_PTR_TYPE]
 
#define long_double_ptr_type_node   global_trees[TI_LONG_DOUBLE_PTR_TYPE]
 
#define integer_ptr_type_node   global_trees[TI_INTEGER_PTR_TYPE]
 
#define complex_integer_type_node   global_trees[TI_COMPLEX_INTEGER_TYPE]
 
#define complex_float_type_node   global_trees[TI_COMPLEX_FLOAT_TYPE]
 
#define complex_double_type_node   global_trees[TI_COMPLEX_DOUBLE_TYPE]
 
#define complex_long_double_type_node   global_trees[TI_COMPLEX_LONG_DOUBLE_TYPE]
 
#define COMPLEX_FLOATN_NX_TYPE_NODE(IDX)   global_trees[TI_COMPLEX_FLOATN_NX_TYPE_FIRST + (IDX)]
 
#define void_type_node   global_trees[TI_VOID_TYPE]
 
#define ptr_type_node   global_trees[TI_PTR_TYPE]
 
#define const_ptr_type_node   global_trees[TI_CONST_PTR_TYPE]
 
#define size_type_node   global_trees[TI_SIZE_TYPE]
 
#define pid_type_node   global_trees[TI_PID_TYPE]
 
#define ptrdiff_type_node   global_trees[TI_PTRDIFF_TYPE]
 
#define va_list_type_node   global_trees[TI_VA_LIST_TYPE]
 
#define va_list_gpr_counter_field   global_trees[TI_VA_LIST_GPR_COUNTER_FIELD]
 
#define va_list_fpr_counter_field   global_trees[TI_VA_LIST_FPR_COUNTER_FIELD]
 
#define fileptr_type_node   global_trees[TI_FILEPTR_TYPE]
 
#define const_tm_ptr_type_node   global_trees[TI_CONST_TM_PTR_TYPE]
 
#define fenv_t_ptr_type_node   global_trees[TI_FENV_T_PTR_TYPE]
 
#define const_fenv_t_ptr_type_node   global_trees[TI_CONST_FENV_T_PTR_TYPE]
 
#define fexcept_t_ptr_type_node   global_trees[TI_FEXCEPT_T_PTR_TYPE]
 
#define const_fexcept_t_ptr_type_node   global_trees[TI_CONST_FEXCEPT_T_PTR_TYPE]
 
#define pointer_sized_int_node   global_trees[TI_POINTER_SIZED_TYPE]
 
#define boolean_type_node   global_trees[TI_BOOLEAN_TYPE]
 
#define boolean_false_node   global_trees[TI_BOOLEAN_FALSE]
 
#define boolean_true_node   global_trees[TI_BOOLEAN_TRUE]
 
#define dfloat32_type_node   global_trees[TI_DFLOAT32_TYPE]
 
#define dfloat64_type_node   global_trees[TI_DFLOAT64_TYPE]
 
#define dfloat128_type_node   global_trees[TI_DFLOAT128_TYPE]
 
#define sat_short_fract_type_node   global_trees[TI_SAT_SFRACT_TYPE]
 
#define sat_fract_type_node   global_trees[TI_SAT_FRACT_TYPE]
 
#define sat_long_fract_type_node   global_trees[TI_SAT_LFRACT_TYPE]
 
#define sat_long_long_fract_type_node   global_trees[TI_SAT_LLFRACT_TYPE]
 
#define sat_unsigned_short_fract_type_node    global_trees[TI_SAT_USFRACT_TYPE]
 
#define sat_unsigned_fract_type_node   global_trees[TI_SAT_UFRACT_TYPE]
 
#define sat_unsigned_long_fract_type_node    global_trees[TI_SAT_ULFRACT_TYPE]
 
#define sat_unsigned_long_long_fract_type_node    global_trees[TI_SAT_ULLFRACT_TYPE]
 
#define short_fract_type_node   global_trees[TI_SFRACT_TYPE]
 
#define fract_type_node   global_trees[TI_FRACT_TYPE]
 
#define long_fract_type_node   global_trees[TI_LFRACT_TYPE]
 
#define long_long_fract_type_node   global_trees[TI_LLFRACT_TYPE]
 
#define unsigned_short_fract_type_node   global_trees[TI_USFRACT_TYPE]
 
#define unsigned_fract_type_node   global_trees[TI_UFRACT_TYPE]
 
#define unsigned_long_fract_type_node   global_trees[TI_ULFRACT_TYPE]
 
#define unsigned_long_long_fract_type_node    global_trees[TI_ULLFRACT_TYPE]
 
#define sat_short_accum_type_node   global_trees[TI_SAT_SACCUM_TYPE]
 
#define sat_accum_type_node   global_trees[TI_SAT_ACCUM_TYPE]
 
#define sat_long_accum_type_node   global_trees[TI_SAT_LACCUM_TYPE]
 
#define sat_long_long_accum_type_node   global_trees[TI_SAT_LLACCUM_TYPE]
 
#define sat_unsigned_short_accum_type_node    global_trees[TI_SAT_USACCUM_TYPE]
 
#define sat_unsigned_accum_type_node   global_trees[TI_SAT_UACCUM_TYPE]
 
#define sat_unsigned_long_accum_type_node    global_trees[TI_SAT_ULACCUM_TYPE]
 
#define sat_unsigned_long_long_accum_type_node    global_trees[TI_SAT_ULLACCUM_TYPE]
 
#define short_accum_type_node   global_trees[TI_SACCUM_TYPE]
 
#define accum_type_node   global_trees[TI_ACCUM_TYPE]
 
#define long_accum_type_node   global_trees[TI_LACCUM_TYPE]
 
#define long_long_accum_type_node   global_trees[TI_LLACCUM_TYPE]
 
#define unsigned_short_accum_type_node   global_trees[TI_USACCUM_TYPE]
 
#define unsigned_accum_type_node   global_trees[TI_UACCUM_TYPE]
 
#define unsigned_long_accum_type_node   global_trees[TI_ULACCUM_TYPE]
 
#define unsigned_long_long_accum_type_node    global_trees[TI_ULLACCUM_TYPE]
 
#define qq_type_node   global_trees[TI_QQ_TYPE]
 
#define hq_type_node   global_trees[TI_HQ_TYPE]
 
#define sq_type_node   global_trees[TI_SQ_TYPE]
 
#define dq_type_node   global_trees[TI_DQ_TYPE]
 
#define tq_type_node   global_trees[TI_TQ_TYPE]
 
#define uqq_type_node   global_trees[TI_UQQ_TYPE]
 
#define uhq_type_node   global_trees[TI_UHQ_TYPE]
 
#define usq_type_node   global_trees[TI_USQ_TYPE]
 
#define udq_type_node   global_trees[TI_UDQ_TYPE]
 
#define utq_type_node   global_trees[TI_UTQ_TYPE]
 
#define sat_qq_type_node   global_trees[TI_SAT_QQ_TYPE]
 
#define sat_hq_type_node   global_trees[TI_SAT_HQ_TYPE]
 
#define sat_sq_type_node   global_trees[TI_SAT_SQ_TYPE]
 
#define sat_dq_type_node   global_trees[TI_SAT_DQ_TYPE]
 
#define sat_tq_type_node   global_trees[TI_SAT_TQ_TYPE]
 
#define sat_uqq_type_node   global_trees[TI_SAT_UQQ_TYPE]
 
#define sat_uhq_type_node   global_trees[TI_SAT_UHQ_TYPE]
 
#define sat_usq_type_node   global_trees[TI_SAT_USQ_TYPE]
 
#define sat_udq_type_node   global_trees[TI_SAT_UDQ_TYPE]
 
#define sat_utq_type_node   global_trees[TI_SAT_UTQ_TYPE]
 
#define ha_type_node   global_trees[TI_HA_TYPE]
 
#define sa_type_node   global_trees[TI_SA_TYPE]
 
#define da_type_node   global_trees[TI_DA_TYPE]
 
#define ta_type_node   global_trees[TI_TA_TYPE]
 
#define uha_type_node   global_trees[TI_UHA_TYPE]
 
#define usa_type_node   global_trees[TI_USA_TYPE]
 
#define uda_type_node   global_trees[TI_UDA_TYPE]
 
#define uta_type_node   global_trees[TI_UTA_TYPE]
 
#define sat_ha_type_node   global_trees[TI_SAT_HA_TYPE]
 
#define sat_sa_type_node   global_trees[TI_SAT_SA_TYPE]
 
#define sat_da_type_node   global_trees[TI_SAT_DA_TYPE]
 
#define sat_ta_type_node   global_trees[TI_SAT_TA_TYPE]
 
#define sat_uha_type_node   global_trees[TI_SAT_UHA_TYPE]
 
#define sat_usa_type_node   global_trees[TI_SAT_USA_TYPE]
 
#define sat_uda_type_node   global_trees[TI_SAT_UDA_TYPE]
 
#define sat_uta_type_node   global_trees[TI_SAT_UTA_TYPE]
 
#define void_list_node   global_trees[TI_VOID_LIST_NODE]
 
#define main_identifier_node   global_trees[TI_MAIN_IDENTIFIER]
 
#define MAIN_NAME_P(NODE)    (IDENTIFIER_NODE_CHECK (NODE) == main_identifier_node)
 
#define optimization_default_node   global_trees[TI_OPTIMIZATION_DEFAULT]
 
#define optimization_current_node   global_trees[TI_OPTIMIZATION_CURRENT]
 
#define target_option_default_node   global_trees[TI_TARGET_OPTION_DEFAULT]
 
#define target_option_current_node   global_trees[TI_TARGET_OPTION_CURRENT]
 
#define current_target_pragma   global_trees[TI_CURRENT_TARGET_PRAGMA]
 
#define current_optimize_pragma   global_trees[TI_CURRENT_OPTIMIZE_PRAGMA]
 
#define chrec_not_analyzed_yet   NULL_TREE
 
#define chrec_dont_know   global_trees[TI_CHREC_DONT_KNOW]
 
#define chrec_known   global_trees[TI_CHREC_KNOWN]
 
#define char_type_node   integer_types[itk_char]
 
#define signed_char_type_node   integer_types[itk_signed_char]
 
#define unsigned_char_type_node   integer_types[itk_unsigned_char]
 
#define short_integer_type_node   integer_types[itk_short]
 
#define short_unsigned_type_node   integer_types[itk_unsigned_short]
 
#define integer_type_node   integer_types[itk_int]
 
#define unsigned_type_node   integer_types[itk_unsigned_int]
 
#define long_integer_type_node   integer_types[itk_long]
 
#define long_unsigned_type_node   integer_types[itk_unsigned_long]
 
#define long_long_integer_type_node   integer_types[itk_long_long]
 
#define long_long_unsigned_type_node   integer_types[itk_unsigned_long_long]
 
#define build_call_array(T1, T2, N, T3)    build_call_array_loc (UNKNOWN_LOCATION, T1, T2, N, T3)
 
#define build_function_type_vec(RET, V)    build_function_type_array (RET, vec_safe_length (V), vec_safe_address (V))
 
#define build_varargs_function_type_vec(RET, V)
 
#define build_type_variant(TYPE, CONST_P, VOLATILE_P)
 
#define sizetype   sizetype_tab[(int) stk_sizetype]
 
#define bitsizetype   sizetype_tab[(int) stk_bitsizetype]
 
#define ssizetype   sizetype_tab[(int) stk_ssizetype]
 
#define sbitsizetype   sizetype_tab[(int) stk_sbitsizetype]
 
#define size_int(L)   size_int_kind (L, stk_sizetype)
 
#define ssize_int(L)   size_int_kind (L, stk_ssizetype)
 
#define bitsize_int(L)   size_int_kind (L, stk_bitsizetype)
 
#define sbitsize_int(L)   size_int_kind (L, stk_sbitsizetype)
 
#define CONTAINS_PLACEHOLDER_P(EXP)    ((EXP) != 0 && ! TREE_CONSTANT (EXP) && contains_placeholder_p (EXP))
 
#define FIND_PLACEHOLDER_IN_EXPR(EXP, V)
 
#define SUBSTITUTE_IN_EXPR(EXP, F, R)    ((EXP) == 0 || TREE_CONSTANT (EXP) ? (EXP) : substitute_in_expr (EXP, F, R))
 
#define SUBSTITUTE_PLACEHOLDER_IN_EXPR(EXP, OBJ)
 
#define FOREACH_FUNCTION_ARGS_PTR(FNTYPE, PTR, ITER)
 
#define FOREACH_FUNCTION_ARGS(FNTYPE, TREE, ITER)
 
#define walk_tree(a, b, c, d)    walk_tree_1 (a, b, c, d, NULL)
 
#define walk_tree_without_duplicates(a, b, c)    walk_tree_without_duplicates_1 (a, b, c, NULL)
 
#define tree_map_eq   tree_map_base_eq
 
#define tree_map_marked_p   tree_map_base_marked_p
 
#define tree_decl_map_eq   tree_map_base_eq
 
#define tree_decl_map_marked_p   tree_map_base_marked_p
 
#define tree_int_map_eq   tree_map_base_eq
 
#define tree_int_map_hash   tree_map_base_hash
 
#define tree_int_map_marked_p   tree_map_base_marked_p
 
#define tree_vec_map_eq   tree_map_base_eq
 
#define tree_vec_map_hash   tree_decl_map_hash
 
#define tree_vec_map_marked_p   tree_map_base_marked_p
 
#define FOR_EACH_CALL_EXPR_ARG(arg, iter, call)
 
#define FOR_EACH_CONST_CALL_EXPR_ARG(arg, iter, call)
 
#define BUILTIN_VALID_P(FNCODE)    (IN_RANGE ((int)FNCODE, ((int)BUILT_IN_NONE) + 1, ((int) END_BUILTINS) - 1))
 
#define BUILTIN_ASM_NAME_PTR(BUILTIN)    (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (builtin_decl_explicit (BUILTIN))))
 
#define opt_for_fn(fndecl, opt)   (opts_for_fn (fndecl)->x_##opt)
 

Typedefs

typedef extended_tree< WIDEST_INT_MAX_PRECISIONwi::widest_extended_tree
 
typedef extended_tree< ADDR_MAX_PRECISIONwi::offset_extended_tree
 
typedef const generic_wide_int< widest_extended_treewi::tree_to_widest_ref
 
typedef const generic_wide_int< offset_extended_treewi::tree_to_offset_ref
 
typedef const generic_wide_int< wide_int_ref_storage< false, false > > wi::tree_to_wide_ref
 
typedef const poly_int< NUM_POLY_INT_COEFFS, generic_wide_int< widest_extended_tree > > wi::tree_to_poly_widest_ref
 
typedef const poly_int< NUM_POLY_INT_COEFFS, generic_wide_int< offset_extended_tree > > wi::tree_to_poly_offset_ref
 
typedef const poly_int< NUM_POLY_INT_COEFFS, generic_wide_int< unextended_tree > > wi::tree_to_poly_wide_ref
 
typedef generic_wide_int< wi::extended_tree< WIDEST_INT_MAX_PRECISION *2 > > widest2_int_cst
 

Enumerations

enum  cst_size_error {
  cst_size_ok , cst_size_not_constant , cst_size_negative , cst_size_too_big ,
  cst_size_overflow
}
 
enum struct  special_array_member {
  none , int_0 , trail_0 , trail_1 ,
  trail_n , int_n
}
 
enum  access_mode {
  access_none = 0 , access_read_only = 1 , access_write_only = 2 , access_read_write = access_read_only | access_write_only ,
  access_deferred = 4
}
 

Functions

combined_fn as_combined_fn (built_in_function fn)
 
combined_fn as_combined_fn (internal_fn fn)
 
bool builtin_fn_p (combined_fn code)
 
built_in_function as_builtin_fn (combined_fn code)
 
bool internal_fn_p (combined_fn code)
 
internal_fn as_internal_fn (combined_fn code)
 
source_range get_expr_source_range (tree expr)
 
void protected_set_expr_location (tree, location_t)
 
void protected_set_expr_location_if_unset (tree, location_t)
 
ATTRIBUTE_WARN_UNUSED_RESULT tree protected_set_expr_location_unshare (tree, location_t)
 
WARN_UNUSED_RESULT tree maybe_wrap_with_location (tree, location_t)
 
unsigned int element_precision (const_tree)
 
machine_mode element_mode (const_tree)
 
machine_mode vector_type_mode (const_tree)
 
unsigned int vector_element_bits (const_tree)
 
tree vector_element_bits_tree (const_tree)
 
tree decl_value_expr_lookup (tree)
 
void decl_value_expr_insert (tree, tree)
 
tree decl_debug_expr_lookup (tree)
 
void decl_debug_expr_insert (tree, tree)
 
priority_type decl_init_priority_lookup (tree)
 
priority_type decl_fini_priority_lookup (tree)
 
void decl_init_priority_insert (tree, priority_type)
 
void decl_fini_priority_insert (tree, priority_type)
 
void set_function_decl_type (tree decl, function_decl_type t, bool set)
 
vec< tree, va_gc > ** decl_debug_args_lookup (tree)
 
vec< tree, va_gc > ** decl_debug_args_insert (tree)
 
tree build_optimization_node (struct gcc_options *opts, struct gcc_options *opts_set)
 
tree build_target_option_node (struct gcc_options *opts, struct gcc_options *opts_set)
 
void prepare_target_option_nodes_for_pch (void)
 
int tree_operand_length (const_tree node)
 
bool id_equal (const_tree id, const char *str)
 
bool id_equal (const char *str, const_tree id)
 
poly_uint64 TYPE_VECTOR_SUBPARTS (const_tree node)
 
void SET_TYPE_VECTOR_SUBPARTS (tree node, poly_uint64 subparts)
 
bool valid_vector_subparts_p (poly_uint64 subparts)
 
built_in_function DECL_FUNCTION_CODE (const_tree decl)
 
int DECL_MD_FUNCTION_CODE (const_tree decl)
 
int DECL_FE_FUNCTION_CODE (const_tree decl)
 
void set_decl_built_in_function (tree decl, built_in_class fclass, unsigned int fcode)
 
void copy_decl_built_in_function (tree newdecl, const_tree olddecl)
 
bool location_wrapper_p (const_tree exp)
 
tree tree_strip_any_location_wrapper (tree exp)
 
bool error_operand_p (const_tree t)
 
unsigned int vector_cst_encoded_nelts (const_tree t)
 
tree decl_assembler_name (tree)
 
void overwrite_decl_assembler_name (tree decl, tree name)
 
tree decl_comdat_group (const_tree)
 
tree decl_comdat_group_id (const_tree)
 
const char * decl_section_name (const_tree)
 
void set_decl_section_name (tree, const char *)
 
void set_decl_section_name (tree, const_tree)
 
enum tls_model decl_tls_model (const_tree)
 
void set_decl_tls_model (tree, enum tls_model)
 
size_t tree_size (const_tree)
 
size_t tree_code_size (enum tree_code)
 
int allocate_decl_uid (void)
 
tree make_node (enum tree_code CXX_MEM_STAT_INFO)
 
void free_node (tree)
 
tree copy_node (tree CXX_MEM_STAT_INFO)
 
tree copy_list (tree)
 
tree build_case_label (tree, tree, tree)
 
tree make_tree_binfo (unsigned CXX_MEM_STAT_INFO)
 
tree make_int_cst (int, int CXX_MEM_STAT_INFO)
 
tree make_tree_vec (int CXX_MEM_STAT_INFO)
 
tree grow_tree_vec (tree v, int CXX_MEM_STAT_INFO)
 
tree build_nt (enum tree_code,...)
 
tree build_nt_call_vec (tree, vec< tree, va_gc > *)
 
tree build0 (enum tree_code, tree CXX_MEM_STAT_INFO)
 
tree build1 (enum tree_code, tree, tree CXX_MEM_STAT_INFO)
 
tree build2 (enum tree_code, tree, tree, tree CXX_MEM_STAT_INFO)
 
tree build3 (enum tree_code, tree, tree, tree, tree CXX_MEM_STAT_INFO)
 
tree build4 (enum tree_code, tree, tree, tree, tree, tree CXX_MEM_STAT_INFO)
 
tree build5 (enum tree_code, tree, tree, tree, tree, tree, tree CXX_MEM_STAT_INFO)
 
tree build1_loc (location_t loc, enum tree_code code, tree type, tree arg1 CXX_MEM_STAT_INFO)
 
tree build2_loc (location_t loc, enum tree_code code, tree type, tree arg0, tree arg1 CXX_MEM_STAT_INFO)
 
tree build3_loc (location_t loc, enum tree_code code, tree type, tree arg0, tree arg1, tree arg2 CXX_MEM_STAT_INFO)
 
tree build4_loc (location_t loc, enum tree_code code, tree type, tree arg0, tree arg1, tree arg2, tree arg3 CXX_MEM_STAT_INFO)
 
tree build5_loc (location_t loc, enum tree_code code, tree type, tree arg0, tree arg1, tree arg2, tree arg3, tree arg4 CXX_MEM_STAT_INFO)
 
tree double_int_to_tree (tree, double_int)
 
tree wide_int_to_tree (tree type, const poly_wide_int_ref &cst)
 
tree force_fit_type (tree, const poly_wide_int_ref &, int, bool)
 
tree build_int_cst (tree, poly_int64)
 
tree build_int_cstu (tree type, poly_uint64)
 
tree build_int_cst_type (tree, poly_int64)
 
tree make_vector (unsigned, unsigned CXX_MEM_STAT_INFO)
 
tree build_vector_from_ctor (tree, const vec< constructor_elt, va_gc > *)
 
tree build_vector_from_val (tree, tree)
 
tree build_uniform_cst (tree, tree)
 
tree build_vec_series (tree, tree, tree)
 
tree build_index_vector (tree, poly_uint64, poly_uint64)
 
tree build_vector_a_then_b (tree, unsigned int, tree, tree)
 
void recompute_constructor_flags (tree)
 
void verify_constructor_flags (tree)
 
tree build_constructor (tree, vec< constructor_elt, va_gc > *CXX_MEM_STAT_INFO)
 
tree build_constructor_single (tree, tree, tree)
 
tree build_constructor_from_list (tree, tree)
 
tree build_constructor_from_vec (tree, const vec< tree, va_gc > *)
 
tree build_constructor_va (tree, int,...)
 
tree build_clobber (tree, enum clobber_kind=CLOBBER_UNDEF)
 
tree build_real_from_int_cst (tree, const_tree)
 
tree build_real_from_wide (tree, const wide_int_ref &, signop)
 
tree build_complex (tree, tree, tree)
 
tree build_complex_inf (tree, bool)
 
tree build_each_one_cst (tree)
 
tree build_one_cst (tree)
 
tree build_minus_one_cst (tree)
 
tree build_all_ones_cst (tree)
 
tree build_zero_cst (tree)
 
tree build_replicated_int_cst (tree, unsigned, HOST_WIDE_INT)
 
tree sign_mask_for (tree)
 
tree build_string (unsigned, const char *=NULL)
 
tree build_poly_int_cst (tree, const poly_wide_int_ref &)
 
tree build_tree_list (tree, tree CXX_MEM_STAT_INFO)
 
tree build_tree_list_vec (const vec< tree, va_gc > *CXX_MEM_STAT_INFO)
 
tree build_decl (location_t, enum tree_code, tree, tree CXX_MEM_STAT_INFO)
 
tree build_debug_expr_decl (tree type)
 
tree build_fn_decl (const char *, tree)
 
tree build_translation_unit_decl (tree)
 
tree build_block (tree, tree, tree, tree)
 
tree build_empty_stmt (location_t)
 
tree build_omp_clause (location_t, enum omp_clause_code)
 
tree build_vl_exp (enum tree_code, int CXX_MEM_STAT_INFO)
 
tree build_call_nary (tree, tree, int,...)
 
tree build_call_valist (tree, tree, int, va_list)
 
tree build_call_array_loc (location_t, tree, tree, int, const tree *)
 
tree build_call_vec (tree, tree, const vec< tree, va_gc > *)
 
tree build_call_expr_loc_array (location_t, tree, int, tree *)
 
tree build_call_expr_loc_vec (location_t, tree, vec< tree, va_gc > *)
 
tree build_call_expr_loc (location_t, tree, int,...)
 
tree build_call_expr (tree, int,...)
 
tree build_call_expr_internal_loc (location_t, enum internal_fn, tree, int,...)
 
tree build_call_expr_internal_loc_array (location_t, enum internal_fn, tree, int, const tree *)
 
tree maybe_build_call_expr_loc (location_t, combined_fn, tree, int,...)
 
tree build_alloca_call_expr (tree, unsigned int, HOST_WIDE_INT)
 
tree build_string_literal (unsigned, const char *=NULL, tree=char_type_node, unsigned HOST_WIDE_INT=HOST_WIDE_INT_M1U)
 
tree build_string_literal (const char *p)
 
tree build_string_literal (tree t)
 
tree signed_or_unsigned_type_for (int, tree)
 
tree signed_type_for (tree)
 
tree unsigned_type_for (tree)
 
bool is_truth_type_for (tree, tree)
 
bool tree_zero_one_valued_p (tree)
 
tree truth_type_for (tree)
 
tree build_pointer_type_for_mode (tree, machine_mode, bool)
 
tree build_pointer_type (tree)
 
tree build_reference_type_for_mode (tree, machine_mode, bool)
 
tree build_reference_type (tree)
 
tree build_vector_type_for_mode (tree, machine_mode)
 
tree build_vector_type (tree, poly_int64)
 
tree build_truth_vector_type_for_mode (poly_uint64, machine_mode)
 
tree build_opaque_vector_type (tree, poly_int64)
 
tree build_index_type (tree)
 
tree build_array_type_1 (tree, tree, bool, bool, bool)
 
tree build_array_type (tree, tree, bool=false)
 
tree build_nonshared_array_type (tree, tree)
 
tree build_array_type_nelts (tree, poly_uint64)
 
tree build_function_type (tree, tree, bool=false)
 
tree build_function_type_list (tree,...)
 
tree build_varargs_function_type_list (tree,...)
 
tree build_function_type_array (tree, int, tree *)
 
tree build_varargs_function_type_array (tree, int, tree *)
 
tree build_method_type_directly (tree, tree, tree)
 
tree build_method_type (tree, tree)
 
tree build_offset_type (tree, tree)
 
tree build_complex_type (tree, bool named=false)
 
tree array_type_nelts (const_tree)
 
tree value_member (tree, tree)
 
tree purpose_member (const_tree, tree)
 
bool vec_member (const_tree, vec< tree, va_gc > *)
 
tree chain_index (int, tree)
 
bool tree_int_cst_equal (const_tree, const_tree)
 
bool tree_fits_shwi_p (const_tree) ATTRIBUTE_PURE
 
bool tree_fits_poly_int64_p (const_tree) ATTRIBUTE_PURE
 
bool tree_fits_uhwi_p (const_tree) ATTRIBUTE_PURE
 
bool tree_fits_poly_uint64_p (const_tree) ATTRIBUTE_PURE
 
HOST_WIDE_INT tree_to_shwi (const_tree) ATTRIBUTE_NONNULL(1) ATTRIBUTE_PURE
 
poly_int64 tree_to_poly_int64 (const_tree) ATTRIBUTE_NONNULL(1) ATTRIBUTE_PURE
 
unsigned HOST_WIDE_INT tree_to_uhwi (const_tree) ATTRIBUTE_NONNULL(1) ATTRIBUTE_PURE
 
poly_uint64 tree_to_poly_uint64 (const_tree) ATTRIBUTE_NONNULL(1) ATTRIBUTE_PURE
 
int tree_int_cst_sgn (const_tree)
 
int tree_int_cst_sign_bit (const_tree)
 
unsigned int tree_int_cst_min_precision (tree, signop)
 
tree excess_precision_type (tree)
 
tree strip_array_types (tree type)
 
bool valid_constant_size_p (const_tree, cst_size_error *=NULL)
 
tree max_object_size ()
 
bool poly_int_tree_p (const_tree t, poly_int64 *value)
 
bool poly_int_tree_p (const_tree t, poly_uint64 *value)
 
tree make_tree (tree, rtx)
 
bool check_lang_type (const_tree cand, const_tree base)
 
bool check_base_type (const_tree cand, const_tree base)
 
bool check_qualified_type (const_tree, const_tree, int)
 
tree get_qualified_type (tree, int)
 
tree build_qualified_type (tree, int CXX_MEM_STAT_INFO)
 
tree build_aligned_type (tree, unsigned int)
 
tree build_distinct_type_copy (tree CXX_MEM_STAT_INFO)
 
tree build_variant_type_copy (tree CXX_MEM_STAT_INFO)
 
hashval_t type_hash_canon_hash (tree)
 
tree type_hash_canon (unsigned int, tree)
 
tree convert (tree, tree)
 
tree size_in_bytes_loc (location_t, const_tree)
 
tree size_in_bytes (const_tree t)
 
HOST_WIDE_INT int_size_in_bytes (const_tree)
 
HOST_WIDE_INT max_int_size_in_bytes (const_tree)
 
tree bit_position (const_tree)
 
tree byte_position (const_tree)
 
HOST_WIDE_INT int_byte_position (const_tree)
 
tree chainon (tree, tree)
 
tree tree_cons (tree, tree, tree CXX_MEM_STAT_INFO)
 
tree tree_last (tree)
 
tree nreverse (tree)
 
int list_length (const_tree)
 
tree first_field (const_tree) ATTRIBUTE_NONNULL(1)
 
tree last_field (const_tree) ATTRIBUTE_NONNULL(1)
 
bool initializer_zerop (const_tree, bool *=NULL)
 
bool initializer_each_zero_or_onep (const_tree)
 
tree vector_cst_elt (const_tree, unsigned int)
 
tree uniform_vector_p (const_tree)
 
tree uniform_integer_cst_p (tree)
 
int single_nonzero_element (const_tree)
 
vec< tree, va_gc > * ctor_to_vec (tree)
 
bool zerop (const_tree)
 
bool integer_zerop (const_tree)
 
bool integer_onep (const_tree)
 
bool integer_each_onep (const_tree)
 
bool integer_all_onesp (const_tree)
 
bool integer_minus_onep (const_tree)
 
bool integer_pow2p (const_tree)
 
tree bitmask_inv_cst_vector_p (tree)
 
bool integer_nonzerop (const_tree)
 
bool integer_truep (const_tree)
 
bool cst_and_fits_in_hwi (const_tree)
 
tree num_ending_zeros (const_tree)
 
bool fixed_zerop (const_tree)
 
tree staticp (tree)
 
tree save_expr (tree)
 
bool tree_invariant_p (tree)
 
tree skip_simple_arithmetic (tree)
 
tree skip_simple_constant_arithmetic (tree)
 
enum tree_node_structure_enum tree_node_structure (const_tree)
 
bool contains_placeholder_p (const_tree)
 
bool type_contains_placeholder_p (tree)
 
void find_placeholder_in_expr (tree, vec< tree > *)
 
tree substitute_in_expr (tree, tree, tree)
 
tree substitute_placeholder_in_expr (tree, tree)
 
tree stabilize_reference (tree)
 
tree get_unwidened (tree, tree)
 
tree get_narrower (tree, int *)
 
bool handled_component_p (const_tree t)
 
bool reverse_storage_order_for_component_p (tree t)
 
bool storage_order_barrier_p (const_tree t)
 
tree get_containing_scope (const_tree)
 
const_tree get_ultimate_context (const_tree)
 
tree decl_function_context (const_tree)
 
tree decl_type_context (const_tree)
 
bool real_zerop (const_tree)
 
void function_args_iter_init (function_args_iterator *i, const_tree fntype)
 
treefunction_args_iter_cond_ptr (function_args_iterator *i)
 
tree function_args_iter_cond (function_args_iterator *i)
 
void function_args_iter_next (function_args_iterator *i)
 
bool inlined_function_outer_scope_p (const_tree block)
 
unsigned crc32_unsigned_n (unsigned, unsigned, unsigned)
 
unsigned crc32_string (unsigned, const char *)
 
unsigned crc32_unsigned (unsigned chksum, unsigned value)
 
unsigned crc32_byte (unsigned chksum, char byte)
 
void clean_symbol_name (char *)
 
tree get_file_function_name (const char *)
 
tree get_callee_fndecl (const_tree)
 
combined_fn get_call_combined_fn (const_tree)
 
int type_num_arguments (const_tree)
 
tree type_argument_type (const_tree, unsigned) ATTRIBUTE_NONNULL(1)
 
bool associative_tree_code (enum tree_code)
 
bool commutative_tree_code (enum tree_code)
 
bool commutative_ternary_tree_code (enum tree_code)
 
bool operation_can_overflow (enum tree_code)
 
bool operation_no_trapping_overflow (tree, enum tree_code)
 
tree upper_bound_in_type (tree, tree)
 
tree lower_bound_in_type (tree, tree)
 
bool operand_equal_for_phi_arg_p (const_tree, const_tree)
 
tree create_artificial_label (location_t)
 
const char * get_name (tree)
 
bool stdarg_p (const_tree)
 
bool prototype_p (const_tree)
 
bool auto_var_p (const_tree)
 
bool auto_var_in_fn_p (const_tree, const_tree)
 
tree build_low_bits_mask (tree, unsigned)
 
bool tree_nop_conversion_p (const_tree, const_tree)
 
tree tree_strip_nop_conversions (tree)
 
tree tree_strip_sign_nop_conversions (tree)
 
const_tree strip_invariant_refs (const_tree)
 
tree strip_zero_offset_components (tree)
 
tree lhd_gcc_personality (void)
 
void assign_assembler_name_if_needed (tree)
 
bool warn_deprecated_use (tree, tree)
 
void error_unavailable_use (tree, tree)
 
tree cache_integer_cst (tree, bool might_duplicate=false)
 
const char * combined_fn_name (combined_fn)
 
bool is_typedef_decl (const_tree x)
 
bool typedef_variant_p (const_tree type)
 
int struct_ptr_eq (const void *a, const void *b)
 
hashval_t struct_ptr_hash (const void *a)
 
bool truth_value_p (enum tree_code code)
 
bool ptrofftype_p (tree type)
 
bool complete_or_array_type_p (const_tree type)
 
bool poly_int_tree_p (const_tree t)
 
poly_uint64 bit_field_size (const_tree t)
 
poly_uint64 bit_field_offset (const_tree t)
 
tree strip_float_extensions (tree)
 
bool really_constant_p (const_tree)
 
bool ptrdiff_tree_p (const_tree, poly_int64 *)
 
bool decl_address_invariant_p (const_tree)
 
bool decl_address_ip_invariant_p (const_tree)
 
bool int_fits_type_p (const_tree, const_tree) ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_PURE
 
void get_type_static_bounds (const_tree, mpz_t, mpz_t)
 
bool variably_modified_type_p (tree, tree)
 
int tree_log2 (const_tree)
 
int tree_floor_log2 (const_tree)
 
unsigned int tree_ctz (const_tree)
 
int simple_cst_equal (const_tree, const_tree)
 
void inchash::add_expr (const_tree t, inchash::hash &hstate, unsigned int flags)
 
hashval_t iterative_hash_expr (const_tree tree, hashval_t seed)
 
int compare_tree_int (const_tree, unsigned HOST_WIDE_INT)
 
bool type_list_equal (const_tree, const_tree)
 
bool chain_member (const_tree, const_tree)
 
void dump_tree_statistics (void)
 
void recompute_tree_invariant_for_addr_expr (tree)
 
bool needs_to_live_in_memory (const_tree)
 
tree reconstruct_complex_type (tree, tree)
 
bool real_onep (const_tree)
 
bool real_minus_onep (const_tree)
 
bool real_maybe_zerop (const_tree)
 
void init_ttree (void)
 
void build_common_tree_nodes (bool)
 
void build_common_builtin_nodes (void)
 
void tree_cc_finalize (void)
 
tree build_nonstandard_integer_type (unsigned HOST_WIDE_INT, int)
 
tree build_nonstandard_boolean_type (unsigned HOST_WIDE_INT)
 
tree build_bitint_type (unsigned HOST_WIDE_INT, int)
 
tree build_range_type (tree, tree, tree)
 
tree build_nonshared_range_type (tree, tree, tree)
 
bool subrange_type_for_debug_p (const_tree, tree *, tree *)
 
HOST_WIDE_INT int_cst_value (const_tree)
 
tree tree_block (tree)
 
void tree_set_block (tree, tree)
 
location_t * block_nonartificial_location (tree)
 
location_t tree_nonartificial_location (tree)
 
location_t tree_inlined_location (tree, bool=true)
 
tree block_ultimate_origin (const_tree)
 
tree get_binfo_at_offset (tree, poly_int64, tree)
 
bool virtual_method_call_p (const_tree, bool=false)
 
tree obj_type_ref_class (const_tree ref, bool=false)
 
bool types_same_for_odr (const_tree type1, const_tree type2)
 
bool contains_bitfld_component_ref_p (const_tree)
 
bool block_may_fallthru (const_tree)
 
void using_eh_for_cleanups (void)
 
bool using_eh_for_cleanups_p (void)
 
const char * get_tree_code_name (enum tree_code)
 
void set_call_expr_flags (tree, int)
 
tree walk_tree_1 (tree *, walk_tree_fn, void *, hash_set< tree > *, walk_tree_lh)
 
tree walk_tree_without_duplicates_1 (tree *, walk_tree_fn, void *, walk_tree_lh)
 
tree drop_tree_overflow (tree)
 
tree get_base_address (tree t)
 
tree array_ref_element_size (tree)
 
tree get_typenode_from_name (const char *)
 
tree array_ref_up_bound (tree)
 
tree array_ref_low_bound (tree)
 
bool array_ref_flexible_size_p (tree, bool *=NULL)
 
tree component_ref_field_offset (tree)
 
special_array_member component_ref_sam_type (tree)
 
tree component_ref_size (tree, special_array_member *=NULL)
 
bool is_access_with_size_p (const_tree)
 
tree get_ref_from_access_with_size (tree)
 
int tree_map_base_eq (const void *, const void *)
 
unsigned int tree_map_base_hash (const void *)
 
bool tree_map_base_marked_p (const void *)
 
void DEBUG_FUNCTION verify_type (const_tree t)
 
bool gimple_canonical_types_compatible_p (const_tree, const_tree, bool trust_type_canonical=true)
 
bool type_with_interoperable_signedness (const_tree)
 
bitmap get_nonnull_args (const_tree)
 
int get_range_pos_neg (tree)
 
bool valid_new_delete_pair_p (tree, tree, bool *=NULL)
 
enum tree_code tree_code_for_canonical_type_merging (enum tree_code code)
 
bool canonical_type_used_p (const_tree t)
 
unsigned int tree_map_hash (const void *)
 
unsigned int tree_decl_map_hash (const void *)
 
tree first_call_expr_arg (tree exp, call_expr_arg_iterator *iter)
 
const_tree first_const_call_expr_arg (const_tree exp, const_call_expr_arg_iterator *iter)
 
bool more_call_expr_args_p (const call_expr_arg_iterator *iter)
 
bool is_lang_specific (const_tree t)
 
tree builtin_decl_explicit (enum built_in_function fncode)
 
tree builtin_decl_implicit (enum built_in_function fncode)
 
tree builtin_decl_unreachable ()
 
tree build_builtin_unreachable (location_t)
 
void set_builtin_decl (enum built_in_function fncode, tree decl, bool implicit_p)
 
void set_builtin_decl_implicit_p (enum built_in_function fncode, bool implicit_p)
 
void set_builtin_decl_declared_p (enum built_in_function fncode, bool declared_p)
 
bool builtin_decl_explicit_p (enum built_in_function fncode)
 
bool builtin_decl_implicit_p (enum built_in_function fncode)
 
bool builtin_decl_declared_p (enum built_in_function fncode)
 
bool maybe_special_function_p (const_tree fndecl)
 
bool is_global_var (const_tree t)
 
bool may_be_aliased (const_tree var)
 
struct cl_optimization * opts_for_fn (const_tree fndecl)
 
cl_target_option * target_opts_for_fn (const_tree fndecl)
 
tree make_anon_name ()
 
tree_to_widest_ref wi::to_widest (const_tree)
 
tree_to_offset_ref wi::to_offset (const_tree)
 
tree_to_wide_ref wi::to_wide (const_tree)
 
wide_int wi::to_wide (const_tree, unsigned int)
 
tree_to_poly_widest_ref wi::to_poly_widest (const_tree)
 
tree_to_poly_offset_ref wi::to_poly_offset (const_tree)
 
tree_to_poly_wide_ref wi::to_poly_wide (const_tree)
 
wi::tree_to_poly_wide_ref poly_int_cst_value (const_tree x)
 
template<typename T >
bool wi::fits_to_boolean_p (const T &x, const_tree)
 
template<typename T >
bool wi::fits_to_tree_p (const T &x, const_tree)
 
wide_int wi::min_value (const_tree)
 
wide_int wi::max_value (const_tree)
 
wide_int wi::from_mpz (const_tree, mpz_t, bool)
 
bool tree_int_cst_lt (const_tree t1, const_tree t2)
 
bool tree_int_cst_le (const_tree t1, const_tree t2)
 
int tree_int_cst_compare (const_tree t1, const_tree t2)
 
void set_decl_rtl (tree, rtx)
 
bool complete_ctor_at_level_p (const_tree, HOST_WIDE_INT, const_tree)
 
tree get_inner_reference (tree, poly_int64 *, poly_int64 *, tree *, machine_mode *, int *, int *, int *)
 
tree build_personality_function (const char *)
 
HOST_WIDE_INT int_bit_position (const_tree field)
 
bool type_with_alias_set_p (const_tree t)
 
location_t set_block (location_t loc, tree block)
 
void gt_ggc_mx (tree &)
 
void gt_pch_nx (tree &)
 
void gt_pch_nx (tree &, gt_pointer_operator, void *)
 
bool nonnull_arg_p (const_tree)
 
bool is_empty_type (const_tree)
 
bool default_is_empty_record (const_tree)
 
bool flexible_array_type_p (const_tree)
 
HOST_WIDE_INT arg_int_size_in_bytes (const_tree)
 
tree arg_size_in_bytes (const_tree)
 
bool expr_type_first_operand_type_p (tree_code)
 
location_t set_source_range (tree expr, location_t start, location_t finish)
 
location_t set_source_range (tree expr, source_range src_range)
 
bool desired_pro_or_demotion_p (const_tree to_type, const_tree from_type)
 
bool type_has_mode_precision_p (const_tree t)
 
bool built_in_function_equal_p (built_in_function name0, built_in_function name1)
 
template<typename... F>
bool built_in_function_equal_p (built_in_function name0, built_in_function name1, built_in_function name2, F... names)
 
bool fndecl_built_in_p (const_tree node)
 
bool fndecl_built_in_p (const_tree node, built_in_class klass)
 
bool fndecl_built_in_p (const_tree node, unsigned int name, built_in_class klass)
 
template<typename... F>
bool fndecl_built_in_p (const_tree node, built_in_function name1, F... names)
 
bool warning_suppressed_at (location_t, opt_code=all_warnings)
 
bool suppress_warning_at (location_t, opt_code=all_warnings, bool=true)
 
void copy_warning (location_t, location_t)
 
bool warning_suppressed_p (const_tree, opt_code=all_warnings)
 
void suppress_warning (tree, opt_code=all_warnings, bool=true) ATTRIBUTE_NONNULL(1)
 
void copy_warning (tree, const_tree)
 
unsigned fndecl_dealloc_argno (tree)
 
tree get_attr_nonstring_decl (tree, tree *=NULL)
 
int get_target_clone_attr_len (tree)
 

Variables

int suppress_location_wrappers
 
bool int_n_enabled_p [NUM_INT_N_ENTS]
 
struct int_n_trees_t int_n_trees [NUM_INT_N_ENTS]
 
const builtin_structptr_type builtin_structptr_types [6]
 
constexpr opt_code no_warning = opt_code ()
 
constexpr opt_code all_warnings = N_OPTS
 

Macro Definition Documentation

◆ access_private_node

#define access_private_node   global_trees[TI_PRIVATE]

◆ access_protected_node

#define access_protected_node   global_trees[TI_PROTECTED]

◆ access_public_node

#define access_public_node   global_trees[TI_PUBLIC]
Base access nodes.   

Referenced by build_common_tree_nodes(), and dequeue_and_dump().

◆ accum_type_node

#define accum_type_node   global_trees[TI_ACCUM_TYPE]

◆ AGGREGATE_TYPE_P

#define AGGREGATE_TYPE_P ( TYPE)     (TREE_CODE (TYPE) == ARRAY_TYPE || RECORD_OR_UNION_TYPE_P (TYPE))
Nonzero if TYPE represents an aggregate (multi-component) type.
Keep these checks in ascending code order.   

Referenced by addr_object_size(), function_arg_info::aggregate_type_p(), aggregate_value_p(), analyze_agg_content_value(), assign_parms(), build_accesses_from_assign(), build_zero_cst(), ipa_param_body_adjustments::common_initialization(), copy_reference_ops_from_ref(), decode_field_reference(), determine_known_aggregate_parts(), type_cache_hasher::equal(), expand_builtin(), expand_call(), expand_expr_real_1(), finalize_type_size(), find_func_aliases(), find_local_vars_to_propagate(), fold_builtin_constant_p(), fold_ctor_reference(), get_alias_set(), get_constraint_for_component_ref(), gimple_fold_builtin_memory_op(), gimplify_expr(), gimplify_init_constructor(), gimplify_modify_expr_rhs(), go_format_type(), hash_tree(), init_function_start(), initializer_constant_valid_p(), initializer_constant_valid_p_1(), ipa_compute_jump_functions_for_edge(), is_gimple_reg_type(), layout_type(), load_from_unmodified_param_or_agg(), maybe_add_sra_candidate(), ipa_param_body_adjustments::modify_call_stmt(), noncall_stmt_may_be_vtbl_ptr_store(), oacc_default_clause(), odr_subtypes_equivalent_p(), output_constructor(), pack_ts_base_value_fields(), pack_ts_type_common_value_fields(), place_field(), place_union_field(), reverse_storage_order_for_component_p(), rtl_for_decl_init(), ipa_icf_gimple::func_checker::safe_for_total_scalarization_p(), sra_modify_assign(), stmt_may_be_vtbl_ptr_store(), storage_order_barrier_p(), store_field(), track_expr_p(), tree_add_const_value_attribute(), type_has_components_p(), type_hash_canon_hash(), type_internals_preclude_sra_p_1(), unpack_ts_base_value_fields(), unpack_ts_type_common_value_fields(), use_pointer_for_field(), use_pointer_in_frame(), useless_type_conversion_p(), verify_type_variant(), verify_types_in_gimple_reference(), and vn_reference_lookup_3().

◆ ALLOCA_FUNCTION_CODE_P

#define ALLOCA_FUNCTION_CODE_P ( FCODE)
Value:
((FCODE) == BUILT_IN_ALLOCA \
|| (FCODE) == BUILT_IN_ALLOCA_WITH_ALIGN \
|| (FCODE) == BUILT_IN_ALLOCA_WITH_ALIGN_AND_MAX)
Test if FCODE is a function code for an alloca operation.   

Referenced by alloc_object_size(), eliminate_unnecessary_stmts(), expand_builtin(), expand_call_stmt(), gimple_build_call_from_tree(), optimize_stack_restore(), propagate_necessity(), and special_function_p().

◆ ANY_INTEGRAL_TYPE_CHECK

#define ANY_INTEGRAL_TYPE_CHECK ( T)    (T)

◆ ANY_INTEGRAL_TYPE_P

◆ ARRAY_OR_INTEGER_TYPE_CHECK

#define ARRAY_OR_INTEGER_TYPE_CHECK ( T)     TREE_CHECK2 (T, ARRAY_TYPE, INTEGER_TYPE)

◆ ASM_CLOBBERS

#define ASM_CLOBBERS ( NODE)    TREE_OPERAND (ASM_EXPR_CHECK (NODE), 3)

◆ ASM_INLINE_P

#define ASM_INLINE_P ( NODE)    (ASM_EXPR_CHECK (NODE)->base.protected_flag)
Nonzero if we want to consider this asm as minimum length and cost
for inlining decisions.   

Referenced by gimplify_asm_expr().

◆ ASM_INPUT_P

#define ASM_INPUT_P ( NODE)    (ASM_EXPR_CHECK (NODE)->base.static_flag)
Nonzero if we want to create an ASM_INPUT instead of an
ASM_OPERAND with no operands.   

Referenced by gimplify_asm_expr().

◆ ASM_INPUTS

#define ASM_INPUTS ( NODE)    TREE_OPERAND (ASM_EXPR_CHECK (NODE), 2)

◆ ASM_LABELS

#define ASM_LABELS ( NODE)    TREE_OPERAND (ASM_EXPR_CHECK (NODE), 4)

Referenced by gimplify_asm_expr().

◆ ASM_OUTPUTS

#define ASM_OUTPUTS ( NODE)    TREE_OPERAND (ASM_EXPR_CHECK (NODE), 1)

◆ ASM_STRING

#define ASM_STRING ( NODE)    TREE_OPERAND (ASM_EXPR_CHECK (NODE), 0)
ASM_EXPR accessors. ASM_STRING returns a STRING_CST for the
instruction (e.g., "mov x, y"). ASM_OUTPUTS, ASM_INPUTS, and
ASM_CLOBBERS represent the outputs, inputs, and clobbers for the
statement.   

Referenced by dump_generic_node(), and gimplify_asm_expr().

◆ ASM_VOLATILE_P

#define ASM_VOLATILE_P ( NODE)    (ASM_EXPR_CHECK (NODE)->base.public_flag)

◆ atomicDI_type_node

#define atomicDI_type_node   global_trees[TI_ATOMICDI_TYPE]

◆ atomicHI_type_node

#define atomicHI_type_node   global_trees[TI_ATOMICHI_TYPE]

◆ atomicQI_type_node

#define atomicQI_type_node   global_trees[TI_ATOMICQI_TYPE]

◆ atomicSI_type_node

#define atomicSI_type_node   global_trees[TI_ATOMICSI_TYPE]

◆ atomicTI_type_node

#define atomicTI_type_node   global_trees[TI_ATOMICTI_TYPE]

◆ bfloat16_type_node

#define bfloat16_type_node   global_trees[TI_BFLOAT16_TYPE]

◆ BINARY_CLASS_P

◆ BIND_EXPR_BLOCK

#define BIND_EXPR_BLOCK ( NODE)    (TREE_OPERAND (BIND_EXPR_CHECK (NODE), 2))

◆ BIND_EXPR_BODY

◆ BIND_EXPR_VARS

#define BIND_EXPR_VARS ( NODE)    (TREE_OPERAND (BIND_EXPR_CHECK (NODE), 0))

◆ BINFO_BASE_ACCESS

#define BINFO_BASE_ACCESS ( NODE,
N )    (*BINFO_BASE_ACCESSES (NODE))[(N)]

◆ BINFO_BASE_ACCESS_APPEND

#define BINFO_BASE_ACCESS_APPEND ( NODE,
T )    BINFO_BASE_ACCESSES (NODE)->quick_push ((T))

◆ BINFO_BASE_ACCESSES

#define BINFO_BASE_ACCESSES ( NODE)     (TREE_BINFO_CHECK (NODE)->binfo.base_accesses)
Indicates the accesses this binfo has to its bases. The values are
access_public_node, access_protected_node or access_private_node.
If this array is not present, public access is implied.   

Referenced by dequeue_and_dump(), and free_node().

◆ BINFO_BASE_APPEND

#define BINFO_BASE_APPEND ( NODE,
T )    (BINFO_BASE_BINFOS (NODE)->quick_push ((T)))

◆ BINFO_BASE_BINFO

#define BINFO_BASE_BINFO ( NODE,
N )    ((*BINFO_BASE_BINFOS (NODE))[(N)])
Accessor macro to get to the Nth base binfo of this binfo.   

Referenced by add_type_duplicate(), get_odr_type(), and register_odr_type().

◆ BINFO_BASE_BINFOS

#define BINFO_BASE_BINFOS ( NODE)    (&TREE_BINFO_CHECK (NODE)->binfo.base_binfos)
A vector of binfos for the direct basetypes inherited by this
basetype.

If this basetype describes type D as inherited in C, and if the
basetypes of D are E and F, then this vector contains binfos for
inheritance of E and F by C.   

Referenced by DFS::DFS_write_tree_body(), hash_tree(), lto_input_ts_binfo_tree_pointers(), make_tree_binfo(), print_node(), and write_ts_binfo_tree_pointers().

◆ BINFO_BASE_ITERATE

#define BINFO_BASE_ITERATE ( NODE,
N,
B )    (BINFO_BASE_BINFOS (NODE)->iterate ((N), &(B)))

◆ BINFO_FLAG_0

#define BINFO_FLAG_0 ( NODE)    TREE_LANG_FLAG_0 (TREE_BINFO_CHECK (NODE))
Flags for language dependent use.   

◆ BINFO_FLAG_1

#define BINFO_FLAG_1 ( NODE)    TREE_LANG_FLAG_1 (TREE_BINFO_CHECK (NODE))

◆ BINFO_FLAG_2

#define BINFO_FLAG_2 ( NODE)    TREE_LANG_FLAG_2 (TREE_BINFO_CHECK (NODE))

◆ BINFO_FLAG_3

#define BINFO_FLAG_3 ( NODE)    TREE_LANG_FLAG_3 (TREE_BINFO_CHECK (NODE))

◆ BINFO_FLAG_4

#define BINFO_FLAG_4 ( NODE)    TREE_LANG_FLAG_4 (TREE_BINFO_CHECK (NODE))

◆ BINFO_FLAG_5

#define BINFO_FLAG_5 ( NODE)    TREE_LANG_FLAG_5 (TREE_BINFO_CHECK (NODE))

◆ BINFO_FLAG_6

#define BINFO_FLAG_6 ( NODE)    TREE_LANG_FLAG_6 (TREE_BINFO_CHECK (NODE))

◆ BINFO_INHERITANCE_CHAIN

#define BINFO_INHERITANCE_CHAIN ( NODE)     (TREE_BINFO_CHECK (NODE)->binfo.inheritance)
The BINFO_INHERITANCE_CHAIN points at the binfo for the base
inheriting this base for non-virtual bases. For virtual bases it
points either to the binfo for which this is a primary binfo, or to
the binfo of the most derived type.   

Referenced by print_node().

◆ BINFO_N_BASE_BINFOS

#define BINFO_N_BASE_BINFOS ( NODE)    (BINFO_BASE_BINFOS (NODE)->length ())

◆ BINFO_OFFSET

#define BINFO_OFFSET ( NODE)    (TREE_BINFO_CHECK (NODE)->binfo.offset)
The offset where this basetype appears in its containing type.
BINFO_OFFSET slot holds the offset (in bytes)
from the base of the complete object to the base of the part of the
object that is allocated on behalf of this `type'.
This is always 0 except when there is multiple inheritance.   

Referenced by add_data_member_location_attribute(), add_type_duplicate(), DFS::DFS_write_tree_body(), extr_type_from_vtbl_ptr_store(), get_binfo_at_offset(), hash_tree(), lookup_binfo_at_offset(), lto_input_ts_binfo_tree_pointers(), print_node(), record_target_from_binfo(), and write_ts_binfo_tree_pointers().

◆ BINFO_OFFSET_ZEROP

#define BINFO_OFFSET_ZEROP ( NODE)    (integer_zerop (BINFO_OFFSET (NODE)))

◆ BINFO_SUBVTT_INDEX

#define BINFO_SUBVTT_INDEX ( NODE)    (TREE_BINFO_CHECK (NODE)->binfo.vtt_subvtt)
The index in the VTT where this subobject's sub-VTT can be found.
NULL_TREE if there is no sub-VTT.   

◆ BINFO_TYPE

#define BINFO_TYPE ( NODE)    TREE_TYPE (TREE_BINFO_CHECK (NODE))

◆ BINFO_VIRTUAL_P

#define BINFO_VIRTUAL_P ( NODE)    (TREE_BINFO_CHECK (NODE)->base.static_flag)
Define accessor macros for information about type inheritance
and basetypes.

A "basetype" means a particular usage of a data type for inheritance
in another type.  Each such basetype usage has its own "binfo"
object to describe it.  The binfo object is a TREE_VEC node.

Inheritance is represented by the binfo nodes allocated for a
given type.  For example, given types C and D, such that D is
inherited by C, 3 binfo nodes will be allocated: one for describing
the binfo properties of C, similarly one for D, and one for
describing the binfo properties of D as a base type for C.
Thus, given a pointer to class C, one can get a pointer to the binfo
of D acting as a basetype for C by looking at C's binfo's basetypes.   
BINFO specific flags.   
Nonzero means that the derivation chain is via a `virtual' declaration.   

Referenced by add_data_member_location_attribute(), and dequeue_and_dump().

◆ BINFO_VIRTUALS

#define BINFO_VIRTUALS ( NODE)    (TREE_BINFO_CHECK (NODE)->binfo.virtuals)
The virtual functions in the virtual function table.  This is
a TREE_LIST that is used as an initial approximation for building
a virtual function table for this basetype.   

Referenced by print_node().

◆ BINFO_VPTR_FIELD

#define BINFO_VPTR_FIELD ( NODE)    (TREE_BINFO_CHECK (NODE)->binfo.vptr_field)
For a BINFO record describing a virtual base class, i.e., one where
TREE_VIA_VIRTUAL is set, this field assists in locating the virtual
base.  The actual contents are language-dependent.  In the C++
front-end this field is an INTEGER_CST giving an offset into the
vtable where the offset to the virtual base can be found.   

Referenced by add_data_member_location_attribute().

◆ BINFO_VPTR_INDEX

#define BINFO_VPTR_INDEX ( NODE)    (TREE_BINFO_CHECK (NODE)->binfo.vtt_vptr)
The index in the VTT where the vptr for this subobject can be
found.  NULL_TREE if there is no secondary vptr in the VTT.   

◆ BINFO_VTABLE

#define BINFO_VTABLE ( NODE)    (TREE_BINFO_CHECK (NODE)->binfo.vtable)

◆ BITINT_TYPE_P

#define BITINT_TYPE_P ( TYPE)    (TREE_CODE (TYPE) == BITINT_TYPE)
Nonzero if TYPE is bit-precise integer type.   

◆ bitsize_int

◆ bitsize_one_node

#define bitsize_one_node   global_trees[TI_BITSIZE_ONE]

Referenced by build_common_tree_nodes().

◆ bitsize_unit_node

◆ bitsize_zero_node

◆ bitsizetype

◆ BLOCK_ABSTRACT_ORIGIN

#define BLOCK_ABSTRACT_ORIGIN ( NODE)    (BLOCK_CHECK (NODE)->block.abstract_origin)

◆ BLOCK_CHAIN

◆ BLOCK_DIE

#define BLOCK_DIE ( NODE)    (BLOCK_CHECK (NODE)->block.die)

◆ BLOCK_FRAGMENT_CHAIN

#define BLOCK_FRAGMENT_CHAIN ( NODE)    (BLOCK_CHECK (NODE)->block.fragment_chain)

◆ BLOCK_FRAGMENT_ORIGIN

#define BLOCK_FRAGMENT_ORIGIN ( NODE)    (BLOCK_CHECK (NODE)->block.fragment_origin)
If block reordering splits a lexical block into discontiguous
address ranges, we'll make a copy of the original block.

Note that this is logically distinct from BLOCK_ABSTRACT_ORIGIN.
In that case, we have one source block that has been replicated
(through inlining or unrolling) into many logical blocks, and that
these logical blocks have different physical variables in them.

In this case, we have one logical block split into several
non-contiguous address ranges.  Most debug formats can't actually
represent this idea directly, so we fake it by creating multiple
logical blocks with the same variables in them.  However, for those
that do support non-contiguous regions, these allow the original
logical block to be reconstructed, along with the set of address
ranges.

One of the logical block fragments is arbitrarily chosen to be
the ORIGIN.  The other fragments will point to the origin via
BLOCK_FRAGMENT_ORIGIN; the origin itself will have this pointer
be null.  The list of fragments will be chained through
BLOCK_FRAGMENT_CHAIN from the origin.   

Referenced by block_fragments_nreverse(), blocks_nreverse_all(), dump_block_node(), dump_scope_block(), dwarf2out_inline_entry(), and reorder_blocks_1().

◆ BLOCK_IN_COLD_SECTION_P

#define BLOCK_IN_COLD_SECTION_P ( NODE)     (BLOCK_CHECK (NODE)->base.u.bits.atomic_flag)
True if BLOCK appears in cold section.   

Referenced by final_scan_insn_1().

◆ BLOCK_NONLOCALIZED_VAR

#define BLOCK_NONLOCALIZED_VAR ( NODE,
N )   (*BLOCK_NONLOCALIZED_VARS (NODE))[N]

◆ BLOCK_NONLOCALIZED_VARS

#define BLOCK_NONLOCALIZED_VARS ( NODE)     (BLOCK_CHECK (NODE)->block.nonlocalized_vars)

◆ BLOCK_NUM_NONLOCALIZED_VARS

#define BLOCK_NUM_NONLOCALIZED_VARS ( NODE)     vec_safe_length (BLOCK_NONLOCALIZED_VARS (NODE))

◆ BLOCK_NUMBER

#define BLOCK_NUMBER ( NODE)    (BLOCK_CHECK (NODE)->block.block_num)
An index number for this block.  These values are not guaranteed to
be unique across functions -- whether or not they are depends on
the debugging output format in use.   

Referenced by add_ranges(), change_scope(), choose_inner_scope(), lto_location_cache::cmp_loc(), dump_block_node(), dump_scope_block(), final_scan_insn_1(), number_blocks(), print_insn(), and set_block_levels().

◆ BLOCK_ORIGIN

◆ BLOCK_SAME_RANGE

#define BLOCK_SAME_RANGE ( NODE)    (BLOCK_CHECK (NODE)->base.u.bits.nameless_flag)
True if BLOCK has the same ranges as its BLOCK_SUPERCONTEXT.   

Referenced by block_fragments_nreverse(), blocks_nreverse_all(), and reorder_blocks_1().

◆ BLOCK_SOURCE_END_LOCATION

#define BLOCK_SOURCE_END_LOCATION ( NODE)    (BLOCK_CHECK (NODE)->block.end_locus)
This gives the location of the end of the block, useful to attach
code implicitly generated for outgoing paths.   

Referenced by gimplify_bind_expr().

◆ BLOCK_SOURCE_LOCATION

#define BLOCK_SOURCE_LOCATION ( NODE)    (BLOCK_CHECK (NODE)->block.locus)

◆ BLOCK_SUBBLOCKS

◆ BLOCK_SUPERCONTEXT

#define BLOCK_SUPERCONTEXT ( NODE)    (BLOCK_CHECK (NODE)->block.supercontext)
The scope enclosing the scope NODE, or FUNCTION_DECL for the "outermost"
function scope.  Inlined functions are chained by this so that given
expression E and its TREE_BLOCK(E) B, BLOCK_SUPERCONTEXT(B) is the scope
in which E has been made or into which E has been inlined.    

Referenced by adjust_context_and_scope(), block_fragments_nreverse(), block_nonartificial_location(), build_block(), cgraph_build_static_cdtor_1(), change_scope(), clear_unused_block_pointer(), compute_discriminator(), create_assumption_fn(), create_loop_fn(), create_omp_child_function(), decl_function_context(), decl_maybe_in_construction_p(), decl_type_context(), DFS::DFS_write_tree_body(), dump_block_node(), dwarf2out_inline_entry(), expand_omp_target(), expand_thunk(), fold_builtin_alloca_with_align(), gen_field_die(), gen_subprogram_die(), autofdo::get_inline_stack(), autofdo::get_relative_location_for_stmt(), get_ultimate_context(), init_lowered_empty_function(), optrecord_json_writer::inlining_chain_to_json(), lhd_print_error_function(), lower_gimple_bind(), lto_input_ts_block_tree_pointers(), maybe_create_die_with_external_ref(), move_sese_region_to_fn(), move_stmt_op(), noncall_stmt_may_be_vtbl_ptr_store(), param_type_may_change_p(), inlining_iterator::prepare_iteration(), prepend_lexical_block(), print_node(), reemit_insn_block_notes(), remove_exit_barrier(), remove_unused_scope_block_p(), reorder_blocks_1(), self_referential_size(), set_inlining_locations(), tree_function_versioning(), tree_inlined_location(), and write_ts_block_tree_pointers().

◆ BLOCK_VARS

◆ boolean_false_node

#define boolean_false_node   global_trees[TI_BOOLEAN_FALSE]

Referenced by and_comparisons_1(), and_var_with_comparison_1(), build_and_record_new_cond(), rt_bb_visited::build_block_check(), build_common_tree_nodes(), build_instrumentation_call(), canonicalize_bool(), rt_bb_visited::check(), constant_boolean_node(), determine_exit_conditions(), do_while_loop_p(), evaluate_control_stmt_using_entry_checks(), execute_sm(), execute_sm_if_changed(), expand_complex_div_wide(), expand_omp_for_init_vars(), expand_omp_for_ordered_loops(), expand_omp_for_static_nochunk(), expand_omp_ordered_sink(), expand_vector_operations(), find_assumption_locals_r(), fold_binary_loc(), fold_builtin_arith_overflow(), fold_builtin_atomic_always_lock_free(), dom_opt_dom_walker::fold_cond(), simplify_using_ranges::fold_cond_with_ops(), gimple_cond_false_p(), gimple_cond_make_false(), gimple_cond_make_true(), gimple_cond_true_p(), gimple_push_cleanup(), gimplify_expr(), gimplify_function_tree(), gimplify_omp_depend(), gimplify_omp_loop_xform(), handle_abnormal_edges(), if_convertible_loop_p_1(), ifcombine_ifandif(), init_range_entry(), rt_bb_visited::insert_exit_check_on_edge(), insert_related_predicates_on_edge(), instrument_bool_enum_load(), is_false_predicate(), simplify_using_ranges::legacy_fold_cond_overflow(), lower_assumption(), lower_lastprivate_clauses(), lower_omp_1(), lower_omp_task_reductions(), lower_rec_input_clauses(), maybe_add_implicit_barrier_cancel(), maybe_optimize_range_tests(), number_of_iterations_cltz(), number_of_iterations_cltz_complement(), number_of_iterations_cond(), number_of_iterations_exit_assumptions(), number_of_iterations_lt_to_ne(), number_of_iterations_ne(), number_of_iterations_popcount(), omp_sese_split_blocks(), optimize_atomic_op_fetch_cmp_0(), optimize_range_tests_var_bound(), or_var_with_comparison_1(), process_bb(), record_common_node(), record_conditions(), remap_gimple_stmt(), rt_bb_visited::rt_bb_visited(), set_uid_loop_bbs(), jump_threader::simplify_control_stmt_condition_1(), simplify_loop_version(), update_range_test(), vect_loop_versioning(), vectorizable_scan_store(), vectorizable_simd_clone_call(), and VN_INFO().

◆ boolean_true_node

#define boolean_true_node   global_trees[TI_BOOLEAN_TRUE]

Referenced by and_var_with_comparison_1(), assert_loop_rolls_lt(), build_and_record_new_cond(), build_common_tree_nodes(), canonicalize_bool(), constant_boolean_node(), copy_edges_for_bb(), determine_exit_conditions(), do_split_loop_on_cond(), do_while_loop_p(), evaluate_control_stmt_using_entry_checks(), expand_builtin_atomic_always_lock_free(), expand_builtin_atomic_is_lock_free(), expand_complex_comparison(), expand_omp_for_init_vars(), expand_omp_for_ordered_loops(), expand_omp_ordered_sink(), expand_task_call(), expr_expected_value_1(), fold_binary_loc(), fold_builtin_arith_overflow(), fold_builtin_atomic_always_lock_free(), fold_builtin_atomic_is_lock_free(), dom_opt_dom_walker::fold_cond(), simplify_using_ranges::fold_cond_with_ops(), gen_simplified_condition(), gimple_cond_false_p(), gimple_cond_make_true(), gimple_cond_true_p(), gimple_push_cleanup(), gimplify_expr(), gimplify_function_tree(), handle_abnormal_edges(), ifcombine_ifandif(), init_bb_predicate(), rt_bb_visited::insert_exit_check_on_edge(), insert_related_predicates_on_edge(), instrument_bool_enum_load(), is_true_predicate(), simplify_using_ranges::legacy_fold_cond_overflow(), lower_omp_single_simple(), lower_omp_task_reductions(), lower_rec_input_clauses(), number_of_iterations_cltz_complement(), number_of_iterations_cond(), number_of_iterations_exit_assumptions(), number_of_iterations_lt_to_ne(), number_of_iterations_popcount(), sm_set_flag_if_changed::operator()(), optimize_range_tests_var_bound(), or_comparisons_1(), or_var_with_comparison_1(), predicate_bbs(), process_bb(), record_common_node(), record_conditions(), reset_bb_predicate(), jump_threader::simplify_control_stmt_condition_1(), simplify_loop_version(), tree_simplify_using_condition_1(), try_vectorize_loop_1(), update_range_test(), vect_get_loop_niters(), vect_loop_versioning(), vectorizable_scan_store(), vectorizable_simd_clone_call(), rt_bb_visited::vindex(), VN_INFO(), and worker_single_simple().

◆ boolean_type_node

#define boolean_type_node   global_trees[TI_BOOLEAN_TYPE]

Referenced by access_with_size_object_size(), add_to_dst_predicate_list(), adjust_imagpart_expr(), and_comparisons_1(), assert_loop_rolls_lt(), assert_no_overflow_lt(), build_and_record_new_cond(), build_cltz_expr(), build_common_tree_nodes(), c_strlen(), canonicalize_bool(), chain_cond_expr(), compare_values_warnv(), const_binop(), constant_boolean_node(), copy_prop_visit_cond_stmt(), create_assumption_fn(), create_ifn_alias_checks(), create_intersect_range_checks(), create_intersect_range_checks_index(), create_runtime_alias_checks(), create_waw_or_war_checks(), derive_constant_upper_bound_ops(), edge_info::derive_equivalences(), determine_exit_conditions(), do_compare(), dr_known_forward_stride_p(), eliminate_redundant_computations(), tree_switch_conversion::bit_test_cluster::emit(), evaluate_conditions_for_known_args(), execute_sm_if_changed_flag_set(), expand_builtin(), expand_complex_comparison(), expand_complex_div_wide(), expand_ifn_atomic_compare_exchange_into_call(), expand_ifn_atomic_op_fetch_cmp_0(), expand_oacc_for(), expand_omp_atomic_cas(), expand_omp_atomic_pipeline(), expand_omp_for_generic(), expand_omp_for_init_counts(), expand_omp_for_init_vars(), expand_omp_for_ordered_loops(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), expand_omp_ordered_sink(), expand_omp_simd(), expand_omp_target(), expand_omp_taskloop_for_inner(), expand_vector_comparison(), expand_vector_condition(), expr_hash_elt::expr_hash_elt(), extract_omp_for_update_vars(), find_unswitching_predicates_for_bb(), fold_binary_loc(), fold_builtin_arith_overflow(), fold_builtin_bit_query(), simplify_using_ranges::fold_cond_with_ops(), fold_or_predicates(), operator_bitwise_not::fold_range(), forward_propagate_into_gimple_cond(), gen_counter_update(), gen_one_condition(), gen_parallel_loop(), gen_simplified_condition(), get_expr_type(), get_segment_min_max(), gimple_boolify(), gimple_extract(), gimple_fold_builtin_acc_on_device(), gimple_push_cleanup(), gimple_range_type(), gimple_simplify_phiopt(), gimplify_call_expr(), gimplify_function_tree(), gimplify_omp_affinity(), gimplify_omp_depend(), gimplify_omp_loop_xform(), gori_stmt_info::gori_stmt_info(), strlen_pass::handle_builtin_memcmp(), ifcombine_ifandif(), init_range_entry(), initialize_expr_from_cond(), rt_bb_visited::insert_exit_check_on_edge(), insert_related_predicates_on_edge(), instrument_builtin_call(), ipa_get_jf_arith_result(), is_gimple_logical_p(), is_truth_type_for(), loop_exits_before_overflow(), loop_niter_by_eval(), lower_assumption(), lower_coro_builtin(), lower_lastprivate_clauses(), lower_omp_for_lastprivate(), lower_omp_for_scan(), lower_omp_master(), lower_omp_ordered(), lower_omp_single_copy(), lower_omp_target(), lower_omp_task_reductions(), lower_rec_input_clauses(), lower_reduction_clauses(), lower_vec_perm(), match_arith_overflow(), may_propagate_copy_into_stmt(), minmax_replacement(), move_computations_worker(), n_of_executions_at_most(), number_of_iterations_cltz(), number_of_iterations_cltz_complement(), number_of_iterations_cond(), number_of_iterations_exit_assumptions(), number_of_iterations_le(), number_of_iterations_lt(), number_of_iterations_lt_to_ne(), number_of_iterations_ne(), number_of_iterations_popcount(), number_of_iterations_until_wrap(), oacc_build_routine_dims(), omp_apply_tile(), omp_extract_for_data(), omp_sese_split_blocks(), operator_bitwise_and::op1_range(), operator_bitwise_not::op1_range(), operator_bitwise_or::op1_range(), operator_bitwise_xor::op1_range(), optimize_atomic_op_fetch_cmp_0(), optimize_range_tests_1(), optimize_range_tests_to_bit_test(), optimize_range_tests_var_bound(), dom_opt_dom_walker::optimize_stmt(), or_comparisons_1(), predicate_bbs(), predicate_statements(), process_bb(), range_entry_cmp(), range_is_either_true_or_false(), record_common_node(), record_edge_info(), fold_using_range::relation_fold_and_or(), remap_gimple_stmt(), rt_bb_visited::rt_bb_visited(), simd_clone_adjust(), simd_clone_adjust_argument_types(), simple_iv_with_niters(), simplify_using_ranges::simplify(), simplify_1b(), avail_exprs_stack::simplify_binary_operation(), simplify_builtin_call(), jump_threader::simplify_control_stmt_condition_1(), simplify_using_initial_conditions(), simplify_using_outer_evolutions(), spaceship_replacement(), split_loop(), tree_predict_by_opcode(), tree_simplify_using_condition_1(), truth_type_for(), ubsan_instrument_float_cast(), loop_cand::undo_simple_reduction(), unswitch_predicate::unswitch_predicate(), update_range_test(), value_replacement(), vect_create_cond_for_align_checks(), vect_create_cond_for_lower_bounds(), vect_create_cond_for_niters_checks(), vect_create_cond_for_unequal_addrs(), vect_create_epilog_for_reduction(), vect_do_peeling(), vect_get_loop_niters(), vect_loop_versioning(), vect_recog_bitfield_ref_pattern(),