#include "tree-core.h"
#include "options.h"
#include "tree-check.h"

Include dependency graph for tree.h:

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_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_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_PRECISION >	wi::widest_extended_tree

typedef extended_tree< ADDR_MAX_PRECISION >	wi::offset_extended_tree

typedef const generic_wide_int< widest_extended_tree >	wi::tree_to_widest_ref

typedef const generic_wide_int< offset_extended_tree >	wi::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)

tree *	function_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)

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)

Macro Definition Documentation

◆ access_private_node

#define access_private_node global_trees[TI_PRIVATE]

Referenced by build_common_tree_nodes(), and dequeue_and_dump().

◆ access_protected_node

#define access_protected_node global_trees[TI_PROTECTED]

Referenced by build_common_tree_nodes(), and dequeue_and_dump().

◆ 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]

Referenced by make_or_reuse_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

#define ANY_INTEGRAL_TYPE_P ( TYPE )

Value:

  (INTEGRAL_TYPE_P (TYPE)                       \
   || ((TREE_CODE (TYPE) == COMPLEX_TYPE        \
        || VECTOR_TYPE_P (TYPE))                \
       && INTEGRAL_TYPE_P (TREE_TYPE (TYPE))))

Nonzero if TYPE represents an integral type, including complex
and vector integer types.

Referenced by can_reassociate_type_p(), constant_after_peeling(), convert_mult_to_fma(), eliminate_using_constants(), expand_simple_operations(), expand_vector_operation(), final_value_replacement_loop(), find_trapping_overflow(), fold_binary_loc(), fold_binary_op_with_conditional_arg(), fold_comparison(), fold_cond_expr_with_comparison(), fold_negate_expr_1(), fold_plusminus_mult_expr(), follow_outer_ssa_edges(), legal_cast_p_1(), maybe_canonicalize_comparison_1(), negate_expr_p(), nowrap_type_p(), operation_no_trapping_overflow(), signed_or_unsigned_type_for(), tree_binary_nonnegative_warnv_p(), tree_binary_nonzero_warnv_p(), tree_unary_nonnegative_warnv_p(), vect_recog_absolute_difference(), vectorize_slp_instance_root_stmt(), and verify_gimple_assign_unary().

◆ 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)

Referenced by dump_generic_node(), and gimplify_asm_expr().

◆ 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)

Referenced by dump_generic_node(), and gimplify_asm_expr().

◆ 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)

Referenced by dump_generic_node(), and gimplify_asm_expr().

◆ 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)

Referenced by dump_generic_node(), and gimplify_asm_expr().

◆ atomicDI_type_node

#define atomicDI_type_node global_trees[TI_ATOMICDI_TYPE]

Referenced by build_common_tree_nodes(), and find_atomic_core_type().

◆ atomicHI_type_node

#define atomicHI_type_node global_trees[TI_ATOMICHI_TYPE]

Referenced by build_common_tree_nodes(), and find_atomic_core_type().

◆ atomicQI_type_node

#define atomicQI_type_node global_trees[TI_ATOMICQI_TYPE]

Referenced by build_common_tree_nodes(), and find_atomic_core_type().

◆ atomicSI_type_node

#define atomicSI_type_node global_trees[TI_ATOMICSI_TYPE]

Referenced by build_common_tree_nodes(), and find_atomic_core_type().

◆ atomicTI_type_node

#define atomicTI_type_node global_trees[TI_ATOMICTI_TYPE]

Referenced by build_common_tree_nodes(), and find_atomic_core_type().

◆ bfloat16_type_node

#define bfloat16_type_node global_trees[TI_BFLOAT16_TYPE]

Referenced by build_common_tree_nodes(), and excess_precision_type().

◆ BINARY_CLASS_P

#define BINARY_CLASS_P ( NODE ) (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_binary)

Nonzero if NODE represents a binary arithmetic expression.

Referenced by dr_equal_offsets_p1(), extract_muldiv_1(), get_base_value(), range_query::get_tree_range(), skip_simple_arithmetic(), skip_simple_constant_arithmetic(), substitute_placeholder_in_expr(), walk_gimple_omp_for(), and will_be_nonconstant_expr_predicate().

◆ BIND_EXPR_BLOCK

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

Referenced by copy_bind_expr(), copy_tree_r(), find_combined_omp_for(), and gimplify_bind_expr().

◆ BIND_EXPR_BODY

#define BIND_EXPR_BODY ( NODE ) (TREE_OPERAND (BIND_EXPR_CHECK (NODE), 1))

Referenced by block_may_fallthru(), create_task_copyfn(), dump_function_to_file(), dump_generic_node(), gimplify_bind_expr(), gimplify_omp_affinity(), gimplify_omp_depend(), gimplify_omp_for(), gimplify_omp_loop(), gimplify_scan_omp_clauses(), tree_invalid_nonnegative_warnv_p(), voidify_wrapper_expr(), and walk_tree_1().

◆ BIND_EXPR_VARS

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

The operands of a BIND_EXPR.

Referenced by copy_bind_expr(), dump_generic_node(), find_combined_omp_for(), gimplify_bind_expr(), and walk_tree_1().

◆ 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)))

Referenced by dequeue_and_dump(), get_binfo_at_offset(), lookup_binfo_at_offset(), record_target_from_binfo(), and subbinfo_with_vtable_at_offset().

◆ 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 ())

The number of basetypes for NODE.

Referenced by add_type_duplicate(), dequeue_and_dump(), get_odr_type(), register_odr_type(), streamer_write_tree_header(), and tree_size().

◆ 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))

The actual data type node being inherited in this basetype.

Referenced by add_type_duplicate(), dequeue_and_dump(), dump_generic_node(), get_binfo_at_offset(), get_odr_type(), polymorphic_type_binfo_p(), record_target_from_binfo(), and register_odr_type().

◆ 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)

The virtual function table belonging to this basetype.  Virtual
function tables provide a mechanism for run-time method dispatching.
The entries of a virtual function table are language-dependent.

Referenced by add_type_duplicate(), detect_type_change_from_memory_writes(), DFS::DFS_write_tree_body(), ipa_polymorphic_call_context::get_dynamic_type(), gimple_get_virt_method_for_binfo(), hash_tree(), lto_input_ts_binfo_tree_pointers(), polymorphic_type_binfo_p(), possible_polymorphic_call_targets(), record_target_from_binfo(), record_targets_from_bases(), subbinfo_with_vtable_at_offset(), type_possibly_instantiated_p(), verify_bb_vtables(), and write_ts_binfo_tree_pointers().

◆ BITINT_TYPE_P

#define BITINT_TYPE_P ( TYPE ) (TREE_CODE (TYPE) == BITINT_TYPE)

Nonzero if TYPE is bit-precise integer type.

◆ bitsize_int

#define bitsize_int ( L ) size_int_kind (L, stk_bitsizetype)

Referenced by build_common_tree_nodes(), dr_analyze_indices(), expand_expr_real_1(), expand_vector_comparison(), expand_vector_condition(), expand_vector_conversion(), expand_vector_piecewise(), expand_vector_ubsan_overflow(), finish_bitfield_representative(), fold_indirect_ref_1(), gimple_fold_indirect_ref(), gimplify_omp_atomic(), operand_compare::hash_operand(), initialize_sizetypes(), layout_type(), make_bit_field_ref(), maybe_rewrite_mem_ref_base(), optimize_vector_load(), place_field(), pos_from_bit(), simplify_bitfield_ref(), start_bitfield_representative(), undistribute_bitref_for_vector(), vect_add_slp_permutation(), vect_create_epilog_for_reduction(), vect_create_partial_epilog(), vect_expand_fold_left(), vector_element(), vector_element_bits_tree(), vectorizable_live_operation(), vectorizable_load(), vectorizable_simd_clone_call(), vectorizable_store(), and vn_reference_lookup_3().

◆ bitsize_one_node

#define bitsize_one_node global_trees[TI_BITSIZE_ONE]

Referenced by build_common_tree_nodes().

◆ bitsize_unit_node

#define bitsize_unit_node global_trees[TI_BITSIZE_UNIT]

Referenced by bit_from_pos(), build_common_tree_nodes(), byte_from_pos(), finalize_type_size(), layout_decl(), and place_field().

◆ bitsize_zero_node

#define bitsize_zero_node global_trees[TI_BITSIZE_ZERO]

Referenced by build_common_tree_nodes(), build_printable_array_type(), expand_vector_parallel(), field_byte_offset(), place_field(), place_union_field(), pos_from_bit(), ref_at_iteration(), simplify_vector_constructor(), start_record_layout(), vect_create_epilog_for_reduction(), and vectorizable_shift().

◆ bitsizetype

#define bitsizetype sizetype_tab[(int) stk_bitsizetype]

Referenced by bits_from_bytes(), dr_analyze_indices(), execute_update_addresses_taken(), get_bitfield_rep(), initialize_sizetypes(), lower_bitfield(), maybe_canonicalize_mem_ref_addr(), maybe_rewrite_mem_ref_base(), place_field(), size_diffop_loc(), vector_element(), vectorizable_store(), verify_gimple_assign_ternary(), and verify_types_in_gimple_reference().

◆ BLOCK_ABSTRACT_ORIGIN

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

A BLOCK, or FUNCTION_DECL of the function from which a block has been
inlined.  In a scope immediately enclosing an inlined leaf expression,
points to the outermost scope into which it has been inlined (thus
bypassing all intermediate BLOCK_SUPERCONTEXTs).

Referenced by block_nonartificial_location(), block_ultimate_origin(), clear_unused_block_pointer(), DFS::DFS_write_tree_body(), dump_block_node(), dump_scope_block(), expand_call_inline(), autofdo::get_function_decl_from_block(), optrecord_json_writer::inlining_chain_to_json(), lhd_print_error_function(), lto_input_ts_block_tree_pointers(), noncall_stmt_may_be_vtbl_ptr_store(), inlining_iterator::prepare_iteration(), print_node(), remap_block(), set_decl_origin_self(), set_inlining_locations(), tree_inlined_location(), and write_ts_block_tree_pointers().

◆ BLOCK_CHAIN

#define BLOCK_CHAIN ( NODE ) (BLOCK_CHECK (NODE)->block.chain)

Points to the next scope at the same level of nesting as scope NODE.

Referenced by all_blocks(), block_chainon(), blocks_nreverse(), blocks_nreverse_all(), build_block(), clear_block_marks(), clear_tree_used(), collect_block_tree_leafs(), collect_subblocks(), dump_block_node(), dump_scope_block(), dwarf2out_inline_entry(), expand_call_inline(), expand_used_vars_for_block(), fixup_vla_decls(), gen_field_die(), instantiate_decls_1(), lower_function_body(), lower_gimple_bind(), lto_input_ts_block_tree_pointers(), mark_scope_block_unused(), move_sese_region_to_fn(), prepend_lexical_block(), print_node(), remap_blocks(), remap_blocks_to_null(), remap_vla_decls(), remove_member_access_dummy_vars(), remove_unused_scope_block_p(), reorder_blocks(), reorder_blocks_1(), replace_block_vars_by_duplicates(), set_block_levels(), set_used_decls(), and setjmp_vars_warning().

◆ BLOCK_DIE

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

Referenced by equate_block_to_die(), and lookup_block_die().

◆ BLOCK_FRAGMENT_CHAIN

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

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

◆ 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]

Referenced by dump_scope_block(), and is_redundant_typedef().

◆ BLOCK_NONLOCALIZED_VARS

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

Referenced by dump_block_node(), free_node(), and remap_block().

◆ BLOCK_NUM_NONLOCALIZED_VARS

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

Referenced by dump_scope_block(), is_redundant_typedef(), process_scope_var(), and remove_unused_scope_block_p().

◆ 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

#define BLOCK_ORIGIN ( NODE ) (BLOCK_ABSTRACT_ORIGIN(NODE) ? BLOCK_ABSTRACT_ORIGIN(NODE) : (NODE))

Referenced by block_ultimate_origin(), lto_input_ts_block_tree_pointers(), remap_block(), and remove_unused_scope_block_p().

◆ 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)

For an inlined function, this gives the location where it was called
from.  This is only set in the top level block, which corresponds to the
inlined function scope.  This is used in the debug output routines.

Referenced by block_nonartificial_location(), dump_block_node(), dump_scope_block(), expand_call_inline(), autofdo::get_inline_stack(), autofdo::get_relative_location_for_stmt(), gimplify_bind_expr(), inlined_function_outer_scope_p(), optrecord_json_writer::inlining_chain_to_json(), lhd_print_error_function(), pack_ts_block_value_fields(), inlining_iterator::prepare_iteration(), remap_block(), remove_unused_scope_block_p(), set_inlining_locations(), tree_inlined_location(), unpack_ts_block_value_fields(), and verify_location().

◆ BLOCK_SUBBLOCKS

#define BLOCK_SUBBLOCKS ( NODE ) (BLOCK_CHECK (NODE)->block.subblocks)

A chain of BLOCKs (scopes) nested within the scope NODE.

Referenced by all_blocks(), blocks_nreverse_all(), build_block(), clear_block_marks(), clear_tree_used(), collect_block_tree_leafs(), collect_subblocks(), debug_find_var_in_block_tree(), dump_block_node(), dump_scope_block(), dwarf2out_inline_entry(), expand_call_inline(), expand_used_vars_for_block(), fixup_vla_decls(), gen_field_die(), instantiate_decls_1(), lower_function_body(), lower_gimple_bind(), lto_input_ts_block_tree_pointers(), mark_scope_block_unused(), move_sese_region_to_fn(), prepend_lexical_block(), print_node(), remap_blocks(), remap_blocks_to_null(), remap_vla_decls(), remove_member_access_dummy_vars(), remove_unused_scope_block_p(), reorder_blocks(), reorder_blocks_1(), replace_block_vars_by_duplicates(), set_block_levels(), set_decl_origin_self(), set_used_decls(), and setjmp_vars_warning().

◆ 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

#define BLOCK_VARS ( NODE ) (BLOCK_CHECK (NODE)->block.vars)

In a BLOCK (scope) node:
Variables declared in the scope NODE.

Referenced by adjust_context_and_scope(), build_block(), clear_tree_used(), debug_find_var_in_block_tree(), declare_inline_vars(), declare_vars(), DFS::DFS_write_tree_body(), dump_block_node(), dump_scope_block(), expand_call_inline(), expand_omp_target(), expand_omp_taskreg(), expand_thunk(), expand_used_vars_for_block(), finalize_nesting_tree_1(), find_combined_omp_for(), fixup_vla_decls(), gimplify_omp_affinity(), gimplify_omp_depend(), instantiate_decls_1(), is_redundant_typedef(), lower_gimple_bind(), lower_omp_critical(), lower_omp_for(), lower_omp_master(), lower_omp_ordered(), lower_omp_scope(), lower_omp_sections(), lower_omp_single(), lower_omp_taskgroup(), lower_omp_teams(), lto_input_ts_block_tree_pointers(), print_node(), process_scope_var(), remap_block(), remap_vla_decls(), remove_exit_barrier(), remove_member_access_dummy_vars(), remove_unused_scope_block_p(), replace_block_vars_by_duplicates(), ipa_param_body_adjustments::reset_debug_stmts(), set_decl_origin_self(), set_used_decls(), setjmp_vars_warning(), and write_ts_block_tree_pointers().

◆ 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(), 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]

◆ build_call_array

#define build_call_array	(	T1,
		T2,
		N,
		T3 ) build_call_array_loc (UNKNOWN_LOCATION, T1, T2, N, T3)

◆ build_function_type_vec

#define build_function_type_vec	(		RET,
			V ) build_function_type_array (RET, vec_safe_length (V), vec_safe_address (V))

◆ build_type_variant

#define build_type_variant	(	TYPE,
		CONST_P,
		VOLATILE_P )

Value:

  build_qualified_type ((TYPE),                                         \
                        ((CONST_P) ? TYPE_QUAL_CONST : 0)               \
                        | ((VOLATILE_P) ? TYPE_QUAL_VOLATILE : 0))

Like build_qualified_type, but only deals with the `const' and
`volatile' qualifiers.  This interface is retained for backwards
compatibility with the various front-ends; new code should use
build_qualified_type instead.

Referenced by build_common_tree_nodes(), build_string_literal(), fold_builtin_memcmp(), and gimple_load_first_char().

◆ build_varargs_function_type_vec

#define build_varargs_function_type_vec	(		RET,
			V )

Value:

build_varargs_function_type_array (RET, vec_safe_length (V), \

vec_safe_address (V))

build_varargs_function_type_array

tree build_varargs_function_type_array(tree, int, tree *)

Definition tree.cc:7653

vec_safe_address

T * vec_safe_address(vec< T, A, vl_embed > *v)

Definition vec.h:694

vec_safe_length

unsigned vec_safe_length(const vec< T, A, vl_embed > *v)

Definition vec.h:685

◆ BUILTIN_ASM_NAME_PTR

#define BUILTIN_ASM_NAME_PTR ( BUILTIN ) (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (builtin_decl_explicit (BUILTIN))))

Obtain a pointer to the identifier string holding the asm name for
BUILTIN, a BUILT_IN code.  This is handy if the target
mangles/overrides the function name that implements the
builtin.

Referenced by default_emit_call_builtin___clear_cache().

◆ BUILTIN_TM_LOAD_P

#define BUILTIN_TM_LOAD_P ( FN ) ((FN) >= BUILT_IN_TM_LOAD_1 && (FN) <= BUILT_IN_TM_LOAD_RFW_LDOUBLE)

Nonzero if a FUNCTION_CODE is a TM load.

Referenced by is_tm_load().

◆ BUILTIN_TM_LOAD_STORE_P

#define BUILTIN_TM_LOAD_STORE_P ( FN ) ((FN) >= BUILT_IN_TM_STORE_1 && (FN) <= BUILT_IN_TM_LOAD_RFW_LDOUBLE)

Nonzero if a FUNCTION_CODE is a TM load/store.

◆ BUILTIN_TM_STORE_P

#define BUILTIN_TM_STORE_P ( FN ) ((FN) >= BUILT_IN_TM_STORE_1 && (FN) <= BUILT_IN_TM_STORE_WAW_LDOUBLE)

Nonzero if a FUNCTION_CODE is a TM store.

Referenced by is_tm_store().

◆ BUILTIN_VALID_P

#define BUILTIN_VALID_P ( FNCODE ) (IN_RANGE ((int)FNCODE, ((int)BUILT_IN_NONE) + 1, ((int) END_BUILTINS) - 1))

Valid builtin number.

Referenced by builtin_decl_declared_p(), builtin_decl_explicit(), builtin_decl_explicit_p(), builtin_decl_implicit(), builtin_decl_implicit_p(), set_builtin_decl(), set_builtin_decl_declared_p(), and set_builtin_decl_implicit_p().

◆ CALL_ALLOCA_FOR_VAR_P

#define CALL_ALLOCA_FOR_VAR_P ( NODE ) (CALL_EXPR_CHECK (NODE)->base.protected_flag)

In a CALL_EXPR, if the function being called is BUILT_IN_ALLOCA, means that
it has been built for the declaration of a variable-sized object and, if the
function being called is BUILT_IN_MEMCPY, means that it has been built for
the assignment of a variable-sized object.

Referenced by expand_builtin_alloca(), expand_call_stmt(), gimple_build_call_from_tree(), gimplify_call_expr(), gimplify_parameters(), and gimplify_vla_decl().

◆ CALL_EXPR_ARG

#define CALL_EXPR_ARG	(		NODE,
			I ) TREE_OPERAND (CALL_EXPR_CHECK (NODE), (I) + 3)

◆ CALL_EXPR_ARGP

#define CALL_EXPR_ARGP ( NODE ) (&(TREE_OPERAND (CALL_EXPR_CHECK (NODE), 0)) + 3)

CALL_EXPR_ARGP returns a pointer to the argument vector for NODE.
We can't use &CALL_EXPR_ARG (NODE, 0) because that will complain if
the argument count is zero when checking is enabled.  Instead, do
the pointer arithmetic to advance past the 3 fixed operands in a
CALL_EXPR.  That produces a valid pointer to just past the end of the
operand array, even if it's not valid to dereference it.

Referenced by fold_call_expr(), gimplify_call_expr(), and rewrite_call_expr().

◆ CALL_EXPR_BY_DESCRIPTOR

#define CALL_EXPR_BY_DESCRIPTOR ( NODE ) (TREE_CHECK (NODE, CALL_EXPR)->base.default_def_flag)

In a CALL_EXPR, indicates that this is an indirect call for which
pointers to nested function are descriptors instead of trampolines.

Referenced by call_expr_flags(), expand_call(), expand_call_stmt(), gimple_build_call_from_tree(), pack_ts_base_value_fields(), and unpack_ts_base_value_fields().

◆ CALL_EXPR_FN

◆ CALL_EXPR_IFN

#define CALL_EXPR_IFN ( NODE ) (CALL_EXPR_CHECK (NODE)->base.u.ifn)

Referenced by build_call_expr_internal_loc_array(), call_expr_flags(), dump_generic_node(), get_call_combined_fn(), gimple_build_call_from_tree(), gimplify_call_expr(), gimplify_modify_expr(), operand_compare::hash_operand(), operand_compare::operand_equal_p(), streamer_read_tree_bitfields(), and streamer_write_tree_bitfields().

◆ CALL_EXPR_MUST_TAIL_CALL

#define CALL_EXPR_MUST_TAIL_CALL ( NODE ) (CALL_EXPR_CHECK (NODE)->base.static_flag)

Set on a CALL_EXPR if the call has been marked as requiring tail call
optimization for correctness.

Referenced by expand_call(), expand_call_stmt(), gimple_build_call_from_tree(), and maybe_complain_about_tail_call().

◆ call_expr_nargs

#define call_expr_nargs ( NODE ) (VL_EXP_OPERAND_LENGTH (NODE) - 3)

Referenced by call_nargs(), convert_to_integer_1(), convert_to_real_1(), dump_generic_node(), expand_builtin(), expand_builtin_assume_aligned(), expand_builtin_classify_type(), expand_builtin_expect(), expand_builtin_expect_with_probability(), expand_builtin_frame_address(), expand_builtin_prefetch(), expand_builtin_va_start(), expand_call(), expand_speculation_safe_value(), fold_binary_loc(), fold_builtin_next_arg(), fold_call_expr(), gimple_boolify(), gimple_build_call_from_tree(), gimplify_and_update_call_from_tree(), gimplify_call_expr(), gimplify_modify_expr(), goa_stabilize_expr(), integer_valued_real_p(), loc_list_from_tree_1(), maybe_emit_sprintf_chk_warning(), rewrite_call_expr(), simple_cst_equal(), streamer_write_tree_header(), tree_builtin_call_types_compatible_p(), tree_invalid_nonnegative_warnv_p(), and valid_gimple_call_p().

◆ CALL_EXPR_RETURN_SLOT_OPT

#define CALL_EXPR_RETURN_SLOT_OPT ( NODE ) (CALL_EXPR_CHECK (NODE)->base.private_flag)

In a CALL_EXPR, means that it's safe to use the target of the call
expansion as the return slot for a call that returns in memory.

Referenced by dump_generic_node(), expand_call(), expand_call_stmt(), gimple_build_call_from_tree(), gimplify_call_expr(), gimplify_modify_expr_rhs(), and store_field().

◆ CALL_EXPR_STATIC_CHAIN

#define CALL_EXPR_STATIC_CHAIN ( NODE ) TREE_OPERAND (CALL_EXPR_CHECK (NODE), 2)

Referenced by build_call_1(), build_nt_call_vec(), dump_generic_node(), expand_call(), expand_call_stmt(), gimple_build_call_from_tree(), gimplify_call_expr(), and print_node().

◆ CALL_EXPR_TAILCALL

#define CALL_EXPR_TAILCALL ( NODE ) (CALL_EXPR_CHECK (NODE)->base.addressable_flag)

Set on a CALL_EXPR if the call is in a tail position, ie. just before the
exit of a function.  Calls for which this is true are candidates for tail
call optimizations.

Referenced by dump_generic_node(), emit_block_op_via_libcall(), expand_builtin_atomic_fetch_op(), expand_builtin_memory_chk(), expand_builtin_memory_copy_args(), expand_builtin_memset_args(), expand_builtin_strcmp(), expand_builtin_strncmp(), expand_call(), expand_call_stmt(), gimple_build_call_from_tree(), gimplify_call_expr(), and set_storage_via_libcall().

◆ CALL_EXPR_VA_ARG_PACK

#define CALL_EXPR_VA_ARG_PACK ( NODE ) (CALL_EXPR_CHECK (NODE)->base.public_flag)

Set on a CALL_EXPR if this stdarg call should be passed the argument
pack.

Referenced by dump_generic_node(), expand_call_stmt(), expand_expr_real_1(), fold_call_expr(), gimple_build_call_from_tree(), and gimplify_call_expr().

◆ CALL_FROM_NEW_OR_DELETE_P

#define CALL_FROM_NEW_OR_DELETE_P ( NODE ) (CALL_EXPR_CHECK (NODE)->base.protected_flag)

In a CALL_EXPR, if the function being called is DECL_IS_OPERATOR_NEW_P or
DECL_IS_OPERATOR_DELETE_P, true for allocator calls from C++ new or delete
expressions.  Not set for C++20 destroying delete operators.

Referenced by gimple_build_call_from_tree().

◆ CALL_FROM_THUNK_P

#define CALL_FROM_THUNK_P ( NODE ) (CALL_EXPR_CHECK (NODE)->base.protected_flag)

In a CALL_EXPR, means that the call is the jump from a thunk to the
thunked-to function.  Be careful to avoid using this macro when one of the
next two applies instead.

Referenced by expand_call(), expand_call_stmt(), expand_expr_real_1(), gimple_build_call_from_tree(), and gimplify_call_expr().

◆ CAN_HAVE_LOCATION_P

#define CAN_HAVE_LOCATION_P ( NODE ) ((NODE) && EXPR_P (NODE))

True if a tree is an expression or statement that can have a
location.

Referenced by build1_loc(), build2_loc(), build3_loc(), build4_loc(), build5_loc(), expand_gimple_stmt_1(), fold_call_stmt(), gimple_assign_rhs_to_tree(), maybe_wrap_with_location(), protected_set_expr_location(), and protected_set_expr_location_unshare().

◆ CAN_HAVE_RANGE_P

#define CAN_HAVE_RANGE_P ( NODE ) (CAN_HAVE_LOCATION_P (NODE))

Referenced by gcc_rich_location::add_expr().

◆ CASE_BUILT_IN_ALLOCA

#define CASE_BUILT_IN_ALLOCA

Value:

  case BUILT_IN_ALLOCA:                         \
  case BUILT_IN_ALLOCA_WITH_ALIGN:              \
  case BUILT_IN_ALLOCA_WITH_ALIGN_AND_MAX

Generate case for an alloca operation.

Referenced by alloca_call_p(), builtin_fnspec(), builtin_safe_for_const_function_p(), evaluate_stmt(), expand_builtin(), get_mem_refs_of_builtin_call(), gimple_alloca_call_p(), gimplify_call_expr(), is_inexpensive_builtin(), mark_all_reaching_defs_necessary_1(), and mark_stmt_if_obviously_necessary().

◆ CASE_BUILT_IN_TM_LOAD

#define CASE_BUILT_IN_TM_LOAD ( FN )

Value:

  case BUILT_IN_TM_LOAD_##FN:           \
  case BUILT_IN_TM_LOAD_RAR_##FN:       \
  case BUILT_IN_TM_LOAD_RAW_##FN:       \
  case BUILT_IN_TM_LOAD_RFW_##FN

Referenced by builtin_fnspec(), find_func_aliases_for_builtin_call(), and is_tm_builtin().

◆ CASE_BUILT_IN_TM_STORE

#define CASE_BUILT_IN_TM_STORE ( FN )

Value:

  case BUILT_IN_TM_STORE_##FN:          \
  case BUILT_IN_TM_STORE_WAR_##FN:      \
  case BUILT_IN_TM_STORE_WAW_##FN

Referenced by builtin_fnspec(), find_func_aliases_for_builtin_call(), and is_tm_builtin().

◆ CASE_CHAIN

#define CASE_CHAIN ( NODE ) TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 3)

Referenced by build_case_label(), edge_to_cases_cleanup(), get_cases_for_edge(), gimple_redirect_edge_and_branch(), predicate::init_from_control_deps(), and verify_gimple_switch().

◆ CASE_CONVERT

#define CASE_CONVERT

Value:

case NOP_EXPR: \

case CONVERT_EXPR

Generate case for NOP_EXPR, CONVERT_EXPR.

Referenced by adjust_bool_pattern(), aff_combination_expand(), find_candidates_dom_walker::before_dom_children(), bit_value_unop(), check_bool_pattern(), chrec_apply(), chrec_fold_multiply(), chrec_fold_plus_1(), compare_constant(), computable_teams_clause(), compute_object_offset(), compute_reloc_for_constant(), const_hash_1(), const_unop(), convert_to_integer_1(), derive_constant_upper_bound_ops(), edge_info::derive_equivalences(), do_jump(), dump_condition(), dump_generic_node(), dump_unary_rhs(), eq_evolutions_p(), ipa_icf::sem_variable::equals(), estimate_operator_cost(), evolution_function_right_is_integer_cst(), expand_debug_expr(), expand_expr_real_2(), expand_simple_operations(), expand_vector_conversion(), expr_to_aff_combination(), extract_muldiv_1(), find_deriving_biv_for_expr(), find_equal_ptrs(), find_foldable_builtin_expect(), fold_truth_not_expr(), fold_unary_loc(), scev_dfs::follow_ssa_edge_expr(), force_expr_to_var_cost(), gimplify_expr(), init_range_entry(), initialize_matrix_A(), initializer_constant_valid_p_1(), instantiate_scev_r(), integer_valued_real_unary_p(), interpret_rhs_expr(), loc_list_from_tree_1(), make_range_step(), may_be_nonaddressable_p(), multiple_of_p(), omp_member_access_dummy_var(), op_code_prio(), operand_compare::operand_equal_p(), operator_is_linear(), output_addressed_constants(), possible_vector_mask_operation_p(), print_call_name(), simplify_using_ranges::simplify(), simplify_using_ranges::simplify_casted_compare(), split_constant_offset_1(), stabilize_reference(), stmt_cost(), supportable_narrowing_operation(), supportable_widening_operation(), target_align(), tree_ctz(), tree_nonzero_bits(), tree_to_aff_combination(), tree_unary_nonnegative_warnv_p(), value_replacement(), vect_check_gather_scatter(), vect_determine_precisions_from_users(), vect_simd_lane_linear(), verify_gimple_assign_unary(), and visit_nary_op().

◆ CASE_FLT_FN

#define CASE_FLT_FN ( FN ) case FN: case FN##F: case FN##L

Helper macros for math builtins.

Referenced by associated_internal_fn(), builtin_with_linkage_p(), can_test_argument_range(), convert_to_integer_1(), edom_only_function(), expand_builtin(), expand_builtin_int_roundingfn(), expand_builtin_int_roundingfn_2(), expand_builtin_mathfn_3(), expand_builtin_mathfn_ternary(), fold_builtin_0(), fold_builtin_1(), fold_builtin_2(), fold_builtin_3(), fold_builtin_interclass_mathfn(), get_no_error_domain(), interclass_mathfn_icode(), is_copysign_call_with_1(), and gimple_range_op_handler::maybe_builtin_call().

◆ CASE_FLT_FN_FLOATN_NX

#define CASE_FLT_FN_FLOATN_NX ( FN )

Value:

case FN##F16: case FN##F32: case FN##F64: case FN##F128: \

case FN##F32X: case FN##F64X: case FN##F128X

Referenced by builtin_with_linkage_p(), can_test_argument_range(), convert_to_integer_1(), edom_only_function(), expand_builtin(), expand_builtin_mathfn_ternary(), fold_builtin_0(), fold_builtin_1(), fold_const_call(), get_no_error_domain(), and is_copysign_call_with_1().

◆ CASE_FLT_FN_REENT

#define CASE_FLT_FN_REENT ( FN ) case FN##_R: case FN##F_R: case FN##L_R

Referenced by fold_builtin_2().

◆ CASE_HIGH

#define CASE_HIGH ( NODE ) TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 1)

Referenced by tree_switch_conversion::switch_decision_tree::analyze_switch_statement(), associate_equivalences_with_edges(), build_case_label(), tree_switch_conversion::switch_conversion::build_constructors(), gimple_outgoing_range::calc_switch_ranges(), simplify_using_ranges::cleanup_edges_and_switches(), tree_switch_conversion::switch_conversion::collect(), ipa_icf_gimple::func_checker::compare_gimple_switch(), convert_single_case_switch(), dequeue_and_dump(), dump_generic_node(), tree_switch_conversion::jump_table_cluster::emit(), expand_case(), expand_sjlj_dispatch_table(), find_case_label_for_value(), find_case_label_index(), find_case_label_range(), find_case_label_range(), find_case_label_ranges(), find_unswitching_predicates_for_bb(), gimple_lower_bitint(), gimple_switch_default_label(), gimple_switch_set_default_label(), group_case_labels_stmt(), predicate::init_from_control_deps(), preprocess_case_label_vec_for_gimple(), record_edge_info(), set_switch_stmt_execution_predicate(), simplify_gimple_switch(), simplify_using_ranges::simplify_switch_using_ranges(), and verify_gimple_switch().

◆ CASE_HIGH_SEEN

#define CASE_HIGH_SEEN ( NODE ) (CASE_LABEL_EXPR_CHECK (NODE)->base.static_flag)

Used as a temporary field on a CASE_LABEL_EXPR to indicate that the
CASE_HIGH operand has been processed.

◆ CASE_INT_FN

#define CASE_INT_FN ( FN ) case FN: case FN##L: case FN##LL: case FN##IMAX

Referenced by expand_builtin(), and instrument_builtin().

◆ CASE_LABEL

#define CASE_LABEL ( NODE ) TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 2)

Referenced by tree_switch_conversion::switch_decision_tree::analyze_switch_statement(), associate_equivalences_with_edges(), build_case_label(), tree_switch_conversion::switch_conversion::build_constructors(), case_label_p(), clean_up_after_unswitching(), cleanup_dead_labels(), tree_switch_conversion::case_bit_test::cmp(), ipa_icf_gimple::func_checker::compare_gimple_switch(), control_flow_regions::compute_regions(), convert_single_case_switch(), dequeue_and_dump(), diagnose_sb_2(), dump_gimple_switch(), evaluate_control_stmt_using_entry_checks(), expand_case(), expand_gimple_stmt_1(), expand_sjlj_dispatch_table(), back_threader::find_taken_edge_switch(), find_taken_edge_switch_expr(), find_unswitching_predicates_for_bb(), tree_switch_conversion::switch_conversion::gather_default_values(), get_cases_for_edge(), gimple_redirect_edge_and_branch(), gimple_switch_label_bb(), gimplify_case_label_expr(), gimplify_switch_expr(), group_case_labels_stmt(), lower_try_finally_switch(), preprocess_case_label_vec_for_gimple(), record_edge_info(), simplify_gimple_switch_label_vec(), simplify_using_ranges::simplify_switch_using_ranges(), jump_threader::thread_around_empty_blocks(), and jump_threader::thread_through_normal_block().

◆ CASE_LOW

#define CASE_LOW ( NODE ) TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 0)

CASE_LABEL_EXPR accessors. These give access to the high and low values
of a case label, respectively.

Referenced by tree_switch_conversion::switch_decision_tree::analyze_switch_statement(), associate_equivalences_with_edges(), build_case_label(), tree_switch_conversion::switch_conversion::build_constructors(), gimple_outgoing_range::calc_switch_ranges(), simplify_using_ranges::cleanup_edges_and_switches(), tree_switch_conversion::switch_conversion::collect(), compare_case_labels(), ipa_icf_gimple::func_checker::compare_gimple_switch(), convert_single_case_switch(), dequeue_and_dump(), dump_generic_node(), tree_switch_conversion::jump_table_cluster::emit(), evaluate_control_stmt_using_entry_checks(), expand_case(), expand_sjlj_dispatch_table(), find_case_label_for_value(), find_case_label_index(), find_case_label_range(), find_case_label_range(), find_case_label_ranges(), find_unswitching_predicates_for_bb(), tree_switch_conversion::switch_conversion::gather_default_values(), generate_loops_for_partition(), gimple_lower_bitint(), gimple_switch_default_label(), gimple_switch_set_default_label(), gimple_verify_flow_info(), group_case_labels_stmt(), predicate::init_from_control_deps(), label_cmp(), lower_try_finally_switch(), preprocess_case_label_vec_for_gimple(), record_edge_info(), set_switch_stmt_execution_predicate(), simplify_gimple_switch(), simplify_using_ranges::simplify_switch_using_ranges(), gimple_outgoing_range::switch_edge_range(), and verify_gimple_switch().

◆ CASE_LOW_SEEN

#define CASE_LOW_SEEN ( NODE ) (CASE_LABEL_EXPR_CHECK (NODE)->base.addressable_flag)

Used as a temporary field on a CASE_LABEL_EXPR to indicate that the
CASE_LOW operand has been processed.

◆ CATCH_BODY

#define CATCH_BODY ( NODE ) TREE_OPERAND (CATCH_EXPR_CHECK (NODE), 1)

Referenced by dump_generic_node(), gimplify_expr(), and try_catch_may_fallthru().

◆ CATCH_TYPES

#define CATCH_TYPES ( NODE ) TREE_OPERAND (CATCH_EXPR_CHECK (NODE), 0)

CATCH_EXPR accessors.

Referenced by dump_generic_node(), and gimplify_expr().

◆ char_type_node

#define char_type_node integer_types[itk_char]

Referenced by adjust_pointer_diff_expr(), ao_ref_init_from_ptr_and_range(), array_elt_at_offset(), asan_emit_stack_protection(), build_common_tree_nodes(), build_complex_type(), build_info(), build_info_type(), clear_padding_flush(), constant_byte_string(), strlen_pass::count_nonzero_bytes(), create_odr_indicator(), define_builtin_macros_for_type_sizes(), expand_builtin_init_dwarf_reg_sizes(), fold_binary_loc(), get_mem_refs_of_builtin_call(), get_memory_rtx(), get_trampoline_type(), get_typenode_from_name(), gimple_fold_builtin_memory_op(), gimple_get_alias_set(), gimple_signed_or_unsigned_type(), gimplify_adjust_omp_clauses_1(), strlen_pass::handle_builtin_memcmp(), strlen_pass::handle_integral_assign(), increment_start_addr(), instrument_expr(), is_char_type(), maybe_trim_constructor_store(), maybe_warn_nonstring_arg(), omp_resolve_clause_dependencies(), optimize_stdarg_builtin(), optimize_va_list_gpr_fpr_size(), output_comp_unit(), record_common_node(), resolve_addr_in_expr(), simplify_builtin_call(), stack_protect_classify_type(), loop_distribution::transform_reduction_loop(), ubsan_get_source_location_type(), ubsan_get_type_descriptor_type(), ubsan_source_location(), ubsan_type_descriptor(), vect_recog_rotate_pattern(), vectorizable_bswap(), and worker_single_copy().

◆ chrec_dont_know

#define chrec_dont_know global_trees[TI_CHREC_DONT_KNOW]

Referenced by add_other_self_distances(), scev_dfs::add_to_evolution(), scev_dfs::add_to_evolution_1(), analyze_evolution_in_loop(), analyze_initial_condition(), analyze_miv_subscript(), analyze_overlapping_iterations(), analyze_scalar_evolution_1(), analyze_scalar_evolution_in_loop(), analyze_siv_subscript(), analyze_siv_subscript_cst_affine(), analyze_subscript_affine_affine(), analyze_ziv_subscript(), automatically_generated_chrec_p(), build_common_tree_nodes(), build_polynomial_chrec(), canonicalize_loop_induction_variables(), chrec_apply(), chrec_contains_undetermined(), chrec_convert_1(), chrec_evaluate(), chrec_fold_automatically_generated_operands(), chrec_fold_multiply(), chrec_fold_multiply_poly_poly(), chrec_fold_plus_1(), chrec_fold_plus_poly_poly(), chrec_merge(), loop_distribution::classify_builtin_ldst(), compute_affine_dependence(), compute_alias_check_pairs(), compute_data_dependences_for_loop(), compute_overall_effect_of_inner_loop(), compute_overlap_steps_for_affine_1_2(), compute_overlap_steps_for_affine_univar(), compute_subscript_distance(), cond_if_else_store_replacement(), loop_distribution::data_dep_in_cycle_p(), determine_loop_nest_reuse(), dump_data_dependence_relation(), loop_distribution::execute(), final_value_replacement_loop(), find_data_references_in_bb(), find_data_references_in_loop(), find_loop_niter(), find_loop_niter_by_eval(), scev_dfs::follow_ssa_edge_expr(), scev_dfs::follow_ssa_edge_in_condition_phi(), scev_dfs::follow_ssa_edge_in_condition_phi_branch(), scev_dfs::follow_ssa_edge_inner_loop_phi(), scev_dfs::get_ev(), hide_evolution_in_other_loops_than_loop(), initialize_data_dependence_relation(), initialize_data_dependence_relation(), initialize_matrix_A(), instantiate_scev_binary(), instantiate_scev_convert(), instantiate_scev_name(), instantiate_scev_not(), instantiate_scev_poly(), instantiate_scev_r(), interpret_condition_phi(), interpret_expr(), interpret_rhs_expr(), known_dependences_p(), lambda_transform_legal_p(), loop_niter_by_eval(), max_stmt_executions_tree(), no_evolution_in_loop_p(), number_of_latch_executions(), loop_distribution::pg_add_dependence_edges(), prepare_perfect_loop_nest(), simplify_peeled_chrec(), pcom_worker::split_data_refs_to_components(), subscript_dependence_tester_1(), tree_if_conversion(), tree_loop_unroll_and_jam(), vect_analyze_data_ref_dependence(), vect_get_loop_niters(), and vect_slp_analyze_data_ref_dependence().

◆ chrec_known

#define chrec_known global_trees[TI_CHREC_KNOWN]

◆ CHREC_LEFT

#define CHREC_LEFT ( NODE ) TREE_OPERAND (POLYNOMIAL_CHREC_CHECK (NODE), 0)

Accessors for the chains of recurrences.

Referenced by add_multivariate_self_dist(), add_other_self_distances(), add_subscript_strides(), scev_dfs::add_to_evolution_1(), analyze_and_compute_bitwise_induction_effect(), loop_cand::analyze_induction_var(), can_use_analyze_subscript_affine_affine(), chrec_apply(), chrec_component_in_loop_num(), chrec_convert_1(), chrec_convert_aggressive(), chrec_evaluate(), chrec_fold_multiply(), chrec_fold_multiply_poly_poly(), chrec_fold_plus_1(), chrec_fold_plus_poly_poly(), chrec_is_positive(), chrec_replace_initial_condition(), compute_access_range(), compute_access_stride(), compute_overlap_steps_for_affine_1_2(), create_intersect_range_checks_index(), derive_simple_iv_with_niters(), dump_generic_node(), eq_evolutions_p(), evolution_function_is_affine_in_loop(), evolution_function_is_affine_multivariate_p(), evolution_function_is_invariant_rec_p(), evolution_function_is_univariate_p(), evolution_function_right_is_integer_cst(), gcd_of_steps_may_divide_p(), get_base_for_alignment_1(), hide_evolution_in_other_loops_than_loop(), initial_condition(), initialize_matrix_A(), instantiate_scev_poly(), is_multivariate_chrec(), is_multivariate_chrec_rec(), reset_evolution_in_loop(), simple_iv_with_niters(), and simplify_peeled_chrec().

◆ chrec_not_analyzed_yet

#define chrec_not_analyzed_yet NULL_TREE

SCEV analyzer global shared trees.

Referenced by analyze_evolution_in_loop(), analyze_initial_condition(), analyze_scalar_evolution(), chrec_fold_automatically_generated_operands(), chrec_merge(), get_instantiated_value_entry(), get_scalar_evolution(), instantiate_scev_name(), interpret_condition_phi(), new_scev_info_str(), and no_evolution_in_loop_p().

◆ CHREC_NOWRAP

#define CHREC_NOWRAP ( NODE ) POLYNOMIAL_CHREC_CHECK (NODE)->base.nothrow_flag

Nonzero if this chrec doesn't overflow (i.e., nonwrapping).

Referenced by dump_generic_node(), nonwrapping_chrec_p(), and record_nonwrapping_chrec().

◆ CHREC_RIGHT

#define CHREC_RIGHT ( NODE ) TREE_OPERAND (POLYNOMIAL_CHREC_CHECK (NODE), 1)

Referenced by add_multivariate_self_dist(), add_subscript_strides(), scev_dfs::add_to_evolution_1(), analyze_and_compute_bitwise_induction_effect(), loop_cand::analyze_induction_var(), analyze_siv_subscript_cst_affine(), analyze_subscript_affine_affine(), can_use_analyze_subscript_affine_affine(), chrec_apply(), chrec_component_in_loop_num(), chrec_convert_1(), chrec_convert_aggressive(), chrec_evaluate(), chrec_fold_multiply(), chrec_fold_multiply_poly_poly(), chrec_fold_plus_1(), chrec_fold_plus_poly_poly(), chrec_is_positive(), chrec_replace_initial_condition(), compute_access_range(), compute_access_stride(), compute_overlap_steps_for_affine_1_2(), create_intersect_range_checks_index(), derive_simple_iv_with_niters(), dump_generic_node(), eq_evolutions_p(), evolution_function_is_affine_in_loop(), evolution_function_is_affine_multivariate_p(), evolution_function_is_affine_p(), evolution_function_is_invariant_rec_p(), evolution_function_is_univariate_p(), evolution_function_right_is_integer_cst(), gcd_of_steps_may_divide_p(), get_base_for_alignment_1(), hide_evolution_in_other_loops_than_loop(), initialize_matrix_A(), instantiate_scev_poly(), is_multivariate_chrec(), is_multivariate_chrec_rec(), reset_evolution_in_loop(), scev_direction(), simple_iv_with_niters(), and simplify_peeled_chrec().

◆ CHREC_VARIABLE

#define CHREC_VARIABLE ( NODE ) POLYNOMIAL_CHREC_CHECK (NODE)->base.u.chrec_var

Referenced by add_multivariate_self_dist(), add_other_self_distances(), scev_dfs::add_to_evolution_1(), loop_cand::analyze_induction_var(), build_classic_dist_vector_1(), build_polynomial_chrec(), can_use_analyze_subscript_affine_affine(), chrec_apply(), chrec_component_in_loop_num(), chrec_convert_1(), chrec_convert_aggressive(), chrec_evaluate(), chrec_fold_multiply(), chrec_fold_multiply_poly_poly(), chrec_fold_plus_1(), chrec_fold_plus_poly_poly(), chrec_is_positive(), chrec_replace_initial_condition(), create_intersect_range_checks_index(), derive_simple_iv_with_niters(), dump_generic_node(), eq_evolutions_p(), evolution_function_is_affine_multivariate_p(), evolution_function_is_affine_p(), evolution_function_is_invariant_rec_p(), evolution_function_is_univariate_p(), get_chrec_loop(), instantiate_scev_poly(), is_multivariate_chrec(), is_multivariate_chrec_rec(), nb_vars_in_chrec(), reset_evolution_in_loop(), scev_is_linear_expression(), simple_iv_with_niters(), and siv_subscript_p().

◆ CLEANUP_EH_ONLY

#define CLEANUP_EH_ONLY ( NODE ) ((NODE)->base.static_flag)

In a TARGET_EXPR or WITH_CLEANUP_EXPR, means that the pertinent cleanup
should only be executed if an exception is thrown, not on normal exit
of its scope.

Referenced by gimplify_target_expr().

◆ CLEAR_QUAL_ADDR_SPACE

#define CLEAR_QUAL_ADDR_SPACE ( X ) ((X) & ~0xFF00)

Return all qualifiers except for the address space qualifiers.

◆ CLOBBER_KIND

#define CLOBBER_KIND ( NODE ) (CONSTRUCTOR_CHECK (NODE)->base.u.bits.address_space)

Return the clobber_kind of a CLOBBER CONSTRUCTOR.

Referenced by build_clobber(), dump_generic_node(), gimple_clobber_p(), streamer_read_tree_bitfields(), and streamer_write_tree_bitfields().

◆ COMPARISON_CLASS_P

#define COMPARISON_CLASS_P ( NODE ) (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_comparison)

Nonzero if NODE represents a comparison.

Referenced by add_iv_candidate_for_doloop(), arith_overflow_check_p(), bitwise_inverted_equal_p(), canonicalize_bool(), canonicalize_cond_expr_cond(), canonicalize_loop_induction_variables(), computable_teams_clause(), dump_generic_node(), eliminate_redundant_comparison(), expand_cond_expr_using_cmove(), extract_muldiv_1(), fold_binary_loc(), fold_builtin_expect(), fold_ternary_loc(), fold_unary_loc(), range_query::get_tree_range(), gimple_boolify(), gimple_cond_get_ops_from_tree(), gimple_expand_vec_cond_expr(), gimple_extract(), gimple_lower_bitint(), gimplify_modify_expr(), gimplify_omp_for(), initialize_expr_from_cond(), inverse_conditions_p(), is_gimple_condexpr_1(), maybe_push_res_to_seq(), number_of_latch_executions(), operand_compare::operand_equal_p(), parloops_is_simple_reduction(), parse_predicate(), predicate_statements(), record_conditions(), replace_stmt_with_simplification(), same_bool_result_p(), simplify_1b(), simplify_builtin_call(), spaceship_replacement(), tree_could_trap_p(), vec_init_loop_exit_info(), vect_embedded_comparison_type(), vect_get_loop_niters(), vect_get_operand_map(), vect_is_simple_cond(), vect_is_simple_use(), vect_mark_stmts_to_be_vectorized(), vect_recog_mask_conversion_pattern(), vect_recog_mixed_size_cond_pattern(), vectorizable_condition(), vectorizable_reduction(), walk_stmt_load_store_addr_ops(), and will_be_nonconstant_expr_predicate().

◆ COMPLETE_OR_UNBOUND_ARRAY_TYPE_P

#define COMPLETE_OR_UNBOUND_ARRAY_TYPE_P ( NODE ) (COMPLETE_TYPE_P (TREE_CODE (NODE) == ARRAY_TYPE ? TREE_TYPE (NODE) : (NODE)))

Nonzero if this type is complete or is an array with unspecified bound.

Referenced by expand_expr_real_1().

◆ COMPLETE_OR_VOID_TYPE_P

#define COMPLETE_OR_VOID_TYPE_P ( NODE ) (COMPLETE_TYPE_P (NODE) || VOID_TYPE_P (NODE))

Nonzero if this type is complete or is cv void.

◆ COMPLETE_TYPE_P

#define COMPLETE_TYPE_P ( NODE ) (TYPE_SIZE (NODE) != NULL_TREE)

Nonzero if this type is a complete type.

Referenced by add_pubtype(), add_type_duplicate(), array_type_nelts(), assign_temp(), build_complex_type(), build_function_type(), build_method_type_directly(), build_offset_type(), clear_padding_type(), clear_padding_union(), complete_or_array_type_p(), convert_to_integer_1(), create_tmp_var(), decl_attributes(), dump_type_inheritance_graph(), type_cache_hasher::equal(), expand_assignment(), expand_expr_real_1(), fully_constant_vn_reference_p(), gen_generic_params_dies(), get_alias_set(), get_odr_type(), gimple_canonical_types_compatible_p(), gimple_fold_builtin_clear_padding(), gimplify_asm_expr(), gimplify_expr(), initialize_argument_information(), initialize_data_dependence_relation(), maybe_add_sra_candidate(), odr_types_equivalent_p(), omp_mappable_type(), register_odr_type(), safe_from_p(), scan_sharing_clauses(), set_type_binfo(), type_variants_equivalent_p(), type_with_alias_set_p(), verify_type(), verify_type_variant(), vn_reference_eq(), and warn_types_mismatch().

◆ complex_double_type_node

#define complex_double_type_node global_trees[TI_COMPLEX_DOUBLE_TYPE]

Referenced by build_common_tree_nodes(), excess_precision_type(), fold_builtin_interclass_mathfn(), and init_optabs().

◆ complex_float_type_node

#define complex_float_type_node global_trees[TI_COMPLEX_FLOAT_TYPE]

Referenced by build_common_tree_nodes(), and excess_precision_type().

◆ COMPLEX_FLOAT_TYPE_P

#define COMPLEX_FLOAT_TYPE_P ( TYPE )

Value:

(TREE_CODE (TYPE) == COMPLEX_TYPE \

&& TREE_CODE (TREE_TYPE (TYPE)) == REAL_TYPE)

Nonzero if TYPE represents a complex floating-point type.

Referenced by builtin_mathfn_code(), const_binop(), fold_binary_loc(), reassociate_bb(), try_special_add_to_ops(), and valid_lattice_transition().

◆ COMPLEX_FLOATN_NX_TYPE_NODE

#define COMPLEX_FLOATN_NX_TYPE_NODE ( IDX ) global_trees[TI_COMPLEX_FLOATN_NX_TYPE_FIRST + (IDX)]

Referenced by build_common_tree_nodes(), and long_double_as_float128().

◆ complex_integer_type_node

#define complex_integer_type_node global_trees[TI_COMPLEX_INTEGER_TYPE]

Referenced by build_common_tree_nodes().

◆ complex_long_double_type_node

#define complex_long_double_type_node global_trees[TI_COMPLEX_LONG_DOUBLE_TYPE]

Referenced by build_common_tree_nodes(), excess_precision_type(), and long_double_as_float128().

◆ COMPOUND_LITERAL_EXPR_DECL

#define COMPOUND_LITERAL_EXPR_DECL ( NODE ) DECL_EXPR_DECL (COMPOUND_LITERAL_EXPR_DECL_EXPR (NODE))

Referenced by canonicalize_constructor_val(), decode_addr_const(), expand_expr_addr_expr_1(), loc_list_from_tree_1(), and staticp().

◆ COMPOUND_LITERAL_EXPR_DECL_EXPR

#define COMPOUND_LITERAL_EXPR_DECL_EXPR ( NODE ) TREE_OPERAND (COMPOUND_LITERAL_EXPR_CHECK (NODE), 0)

COMPOUND_LITERAL_EXPR accessors.

Referenced by gimplify_compound_literal_expr(), gimplify_modify_expr_rhs(), and optimize_compound_literals_in_ctor().

◆ COND_EXPR_COND

#define COND_EXPR_COND ( NODE ) (TREE_OPERAND (COND_EXPR_CHECK (NODE), 0))

COND_EXPR accessors.

Referenced by dump_generic_node(), gimplify_cond_expr(), and gimplify_pure_cond_expr().

◆ COND_EXPR_ELSE

#define COND_EXPR_ELSE ( NODE ) (TREE_OPERAND (COND_EXPR_CHECK (NODE), 2))

Referenced by block_may_fallthru(), dump_generic_node(), and gimplify_pure_cond_expr().

◆ COND_EXPR_THEN

#define COND_EXPR_THEN ( NODE ) (TREE_OPERAND (COND_EXPR_CHECK (NODE), 1))

Referenced by block_may_fallthru(), dump_generic_node(), and gimplify_pure_cond_expr().

◆ const_fenv_t_ptr_type_node

#define const_fenv_t_ptr_type_node global_trees[TI_CONST_FENV_T_PTR_TYPE]

◆ const_fexcept_t_ptr_type_node

#define const_fexcept_t_ptr_type_node global_trees[TI_CONST_FEXCEPT_T_PTR_TYPE]

◆ const_ptr_type_node

#define const_ptr_type_node global_trees[TI_CONST_PTR_TYPE]

The C type `const void *'.

Referenced by add_decls_addresses_to_decl_constructor(), asan_add_global(), asan_dynamic_init_call(), asan_global_struct(), build_common_builtin_nodes(), build_common_tree_nodes(), initialize_sanitizer_builtins(), and tree_ssa_prefetch_arrays().

◆ const_tm_ptr_type_node

#define const_tm_ptr_type_node global_trees[TI_CONST_TM_PTR_TYPE]

The C type `const struct tm *'.

◆ CONSTANT_CLASS_OR_WRAPPER_P

#define CONSTANT_CLASS_OR_WRAPPER_P ( NODE ) (CONSTANT_CLASS_P (tree_strip_any_location_wrapper (NODE)))

Nonzero if NODE represents a constant, or is a location wrapper
around such a node.

Referenced by convert_to_complex_maybe_fold(), convert_to_integer_maybe_fold(), convert_to_pointer_maybe_fold(), and convert_to_real_maybe_fold().

◆ CONSTANT_CLASS_P

#define CONSTANT_CLASS_P ( NODE ) (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_constant)

Nonzero if NODE represents a constant.

Referenced by build_complex(), build_vector_from_val(), call_may_clobber_ref_p_1(), tree_vector_builder::can_elide_p(), canonicalize_constructor_val(), chrec_convert_1(), loop_cand::classify_simple_reduction(), clean_up_after_unswitching(), const_binop(), const_hash_1(), const_unop(), constant_after_peeling(), constant_for_folding(), ana::constant_svalue::constant_svalue(), copy_tree_body_r(), create_waw_or_war_checks(), divmod_candidate_p(), eliminate_dom_walker::eliminate_avail(), expand_expr_addr_expr_1(), expand_vector_condition(), expand_vector_conversion(), expand_vector_piecewise(), final_value_replacement_loop(), fold(), fold_array_ctor_reference(), fold_binary_loc(), fold_builtin_constant_p(), fold_comparison(), fold_const_fold_left(), fold_const_reduction(), fold_const_vec_convert(), fold_ctor_reference(), fold_gimple_assign(), fold_ternary_loc(), fold_unary_loc(), follow_copies_to_constant(), for_each_index(), force_expr_to_var_cost(), get_base_constructor(), get_base_var(), get_computation_cost(), get_constraint_for_component_ref(), get_initial_defs_for_reduction(), get_object_alignment_2(), get_ref_base_and_extent(), gimple_build_vector(), gimple_build_vector_from_val(), gimple_fold_stmt_to_constant_1(), gimple_resimplify1(), gimple_resimplify2(), gimple_resimplify3(), gimple_simplify(), gimple_simplify(), gimple_simplify(), gimple_simplify(), gimple_simplify(), gimple_simplify(), gimple_switch_set_index(), gimplify_init_constructor(), gvn_uses_equal(), insert_debug_temp_for_var_def(), instantiate_scev_r(), is_gimple_address(), is_gimple_invariant_address(), is_gimple_ip_invariant_address(), is_gimple_mem_ref_addr(), is_inv_store_elimination_chain(), lower_vec_perm(), make_forwarders_with_degenerate_phis(), mangle_referenced_decls(), maybe_fold_reference(), maybe_wrap_with_location(), output_addressed_constants(), preserve_any_location_wrapper(), process_call_operands(), ptr_deref_may_alias_decl_p(), ptr_derefs_may_alias_p(), vn_walk_cb_data::push_partial_def(), read_complex_part(), recompute_tree_invariant_for_addr_expr(), reference_to_unused(), refs_may_alias_p_2(), remap_gimple_op_r(), replace_exp(), rtl_for_decl_init(), set_lattice_value(), set_mem_attributes_minus_bitpos(), simple_operand_p(), simplify_1b(), simplify_replace_tree(), simplify_vector_constructor(), substitute_in_expr(), transaction_invariant_address_p(), tree_invariant_p_1(), tree_single_nonzero_warnv_p(), tree_swap_operands_p(), unswitch_predicate::unswitch_predicate(), vect_check_store_rhs(), vect_create_constant_vectors(), vect_create_nonlinear_iv_vec_step(), vect_init_vector(), vect_is_simple_use(), vectorizable_conversion(), vectorizable_induction(), visit_reference_op_load(), and vn_reference_lookup_3().

◆ CONSTRUCTOR_APPEND_ELT

#define CONSTRUCTOR_APPEND_ELT	(	V,
		INDEX,
		VALUE )

Value:

  do { \
    constructor_elt _ce___ = {INDEX, VALUE}; \
    vec_safe_push ((V), _ce___); \
  } while (0)

Append a new constructor element to V, with the specified INDEX and VAL.

Referenced by add_decls_addresses_to_decl_constructor(), asan_add_global(), build_constructor_from_list(), build_constructor_from_vec(), build_constructor_va(), build_fn_info(), build_info(), build_vector_from_val(), coverage_obj_fn(), create_expression_by_pieces(), expand_expr_real_1(), expand_omp_for_generic(), fold_vec_perm(), gimple_build_vector(), lower_omp_target(), lower_vec_perm(), native_interpret_aggregate(), ubsan_create_data(), vectorizable_load(), vectorizable_simd_clone_call(), and vectorize_slp_instance_root_stmt().

◆ CONSTRUCTOR_BITFIELD_P

#define CONSTRUCTOR_BITFIELD_P ( NODE )

Value:

  (DECL_BIT_FIELD (FIELD_DECL_CHECK (NODE)) \
   && (DECL_MODE (NODE) != BLKmode \
       || TREE_CODE (TREE_TYPE (NODE)) == BITINT_TYPE))

True if NODE, a FIELD_DECL, is to be processed as a bitfield for
constructor output purposes.

Referenced by output_constructor().

◆ CONSTRUCTOR_ELT

#define CONSTRUCTOR_ELT	(		NODE,
			IDX ) (&(*CONSTRUCTOR_ELTS (NODE))[IDX])

Referenced by convert_local_reference_stmt(), convert_nonlocal_reference_stmt(), fold_array_ctor_reference(), fold_read_from_vector(), gimple_get_virt_method_for_vtable(), init_vn_nary_op_from_stmt(), optimize_vector_constructor(), store_constructor(), vect_slp_check_for_roots(), vector_element(), and vn_lookup_simplify_result().

◆ CONSTRUCTOR_ELTS

#define CONSTRUCTOR_ELTS ( NODE ) (CONSTRUCTOR_CHECK (NODE)->constructor.elts)

In a CONSTRUCTOR node.

Referenced by array_size_for_constructor(), build_constructor(), build_tm_store(), categorize_ctor_elements_1(), check_ctz_array(), compare_constant(), compute_reloc_for_constant(), const_hash_1(), convert_local_reference_stmt(), convert_nonlocal_reference_stmt(), copy_tree_r(), ctor_single_nonzero_element(), ctor_to_vec(), dequeue_and_dump(), DFS::DFS_write_tree_body(), dump_generic_node(), dwarf2out_decl(), ipa_icf::sem_variable::equals(), expand_debug_expr(), expand_expr_real_1(), find_constructor_constant_at_offset(), fold(), fold_gimple_assign(), fold_nonarray_ctor_reference(), fold_ternary_loc(), free_node(), get_array_ctor_element_at_index(), get_constraint_for_1(), operands_scanner::get_expr_operands(), get_initializer_for(), gimple_fold_stmt_to_constant_1(), gimplify_expr(), gimplify_init_constructor(), gimplify_init_ctor_eval(), gimplify_init_ctor_eval_range(), gimplify_init_ctor_preeval(), gimplify_modify_expr_to_memset(), operand_compare::hash_operand(), hash_tree(), initializer_constant_valid_for_bitfield_p(), initializer_constant_valid_p_1(), initializer_zerop(), loc_list_from_tree_1(), lto_input_ts_constructor_tree_pointers(), native_encode_initializer(), operand_compare::operand_equal_p(), optimize_compound_literals_in_ctor(), optimize_vector_constructor(), output_addressed_constants(), output_constant(), output_constructor(), print_node(), recompute_constructor_flags(), rtl_for_decl_init(), safe_from_p(), simple_cst_equal(), simplify_vector_constructor(), store_constructor(), streamer_read_tree_bitfields(), uniform_vector_p(), valid_gimple_rhs_p(), vec_cst_ctor_to_array(), vect_slp_check_for_roots(), verify_constructor_flags(), verify_gimple_assign_single(), walk_stmt_load_store_addr_ops(), walk_tree_1(), and write_ts_constructor_tree_pointers().

◆ CONSTRUCTOR_NELTS

#define CONSTRUCTOR_NELTS ( NODE ) (vec_safe_length (CONSTRUCTOR_ELTS (NODE)))

◆ CONSTRUCTOR_NO_CLEARING

#define CONSTRUCTOR_NO_CLEARING ( NODE ) (CONSTRUCTOR_CHECK (NODE)->base.public_flag)

Referenced by gimplify_init_constructor(), operand_compare::hash_operand(), native_encode_initializer(), and operand_compare::operand_equal_p().

◆ CONTAINS_PLACEHOLDER_P

#define CONTAINS_PLACEHOLDER_P ( EXP ) ((EXP) != 0 && ! TREE_CONSTANT (EXP) && contains_placeholder_p (EXP))

This macro calls the above function but short-circuits the common
case of a constant to save time.  Also check for null.

Referenced by contains_placeholder_p(), fold_range_test(), gimplify_one_sizepos(), type_contains_placeholder_1(), and variable_size().

◆ CONTAINS_STRUCT_CHECK

#define CONTAINS_STRUCT_CHECK	(		T,
			ENUM ) (T)

When checking is enabled, errors will be generated if a tree node
is accessed incorrectly. The macros die with a fatal error.

◆ CONVERT_EXPR_CODE_P

#define CONVERT_EXPR_CODE_P ( CODE ) ((CODE) == NOP_EXPR || (CODE) == CONVERT_EXPR)

Tests if CODE is a conversion expr (NOP_EXPR or CONVERT_EXPR).

Referenced by inchash::add_hashable_expr(), analyze_agg_content_value(), arith_overflow_check_p(), can_propagate_from(), check_reduction_path(), compute_complex_assign_jump_func(), cond_removal_in_builtin_zero_pattern(), constant_pointer_difference(), convert_atomic_bit_not(), convert_plusminus_to_widen(), edge_forwards_cmp_to_conditional_jump_through_empty_bb_p(), eliminate_dom_walker::eliminate_insert(), eliminate_dom_walker::eliminate_stmt(), eliminated_by_inlining_prob(), expand_call_inline(), expand_expr_force_mode(), expand_expr_real_1(), expand_expr_real_2(), expand_vector_operations_1(), expr_hash_elt::expr_hash_elt(), find_func_aliases(), fold_unary_ignore_overflow_loc(), fold_unary_loc(), forward_propagate_addr_expr_1(), forward_propagate_into_comparison_1(), get_bit_field_ref_def(), get_min_precision(), get_name_for_bit_test(), get_range_pos_neg(), gimple_assign_cast_p(), gimple_assign_unary_nop_p(), gimple_nop_conversion_p(), operand_compare::hash_operand(), hashable_expr_equal_p(), insert_into_preds_of_block(), ipa_analyze_indirect_call_uses(), is_cond_scalar_reduction(), legal_cast_p(), maybe_set_nonzero_bits(), optimize_va_list_gpr_fpr_size(), predict_loops(), recognize_single_bit_test(), replace_mult_candidate(), replace_profitable_candidates(), rewrite_bittest(), simple_cst_equal(), simplify_conversion_using_ranges(), simplify_rotate(), simplify_vector_constructor(), split_constant_offset_1(), strip_conversion(), strip_nop_cond_scalar_reduction(), supportable_widening_operation(), thread_private_new_memory(), type_conversion_p(), value_replacement(), valueized_wider_op(), vect_find_stmt_data_reference(), vect_is_extending_load(), vect_is_integer_truncation(), vect_is_simple_reduction(), vect_look_through_possible_promotion(), vect_nop_conversion_p(), vect_recog_bitfield_ref_pattern(), vect_recog_bool_pattern(), vect_recog_cast_forwprop_pattern(), vect_recog_popcount_clz_ctz_ffs_pattern(), vect_recog_widen_abd_pattern(), vectorizable_assignment(), vectorizable_conversion(), vectorizable_reduction(), and widening_mult_conversion_strippable_p().

◆ CONVERT_EXPR_P

#define CONVERT_EXPR_P ( EXP ) CONVERT_EXPR_CODE_P (TREE_CODE (EXP))

Similarly, but accept an expression instead of a tree code.

Referenced by aff_combination_expand(), backtrace_base_for_ref(), canonicalize_cond_expr_cond(), convert_to_integer_1(), data_ref_compare_tree(), decode_field_reference(), derive_simple_iv_with_niters(), determine_common_wider_type(), discover_nonconstant_array_refs_r(), do_jump(), dr_step_indicator(), dump_function_name(), fold_binary_loc(), fold_builtin_atomic_always_lock_free(), fold_builtin_expect(), fold_builtin_next_arg(), fold_unary_loc(), get_computation_aff_1(), get_memory_rtx(), get_min_precision(), get_range_pos_neg(), get_unwidened(), gimplify_conversion(), goa_lhs_expr_p(), is_aligning_offset(), narrowing_initializer_constant_valid_p(), operand_equal_for_comparison_p(), operand_compare::operand_equal_p(), output_constant(), really_constant_p(), scan_operand_equal_p(), set_mem_attributes_minus_bitpos(), simple_condition_p(), simple_iv_with_niters(), jump_threader::simplify_control_stmt_condition_1(), strip_float_extensions(), tree_nop_conversion(), tree_ssa_useless_type_conversion(), and vect_find_stmt_data_reference().

◆ COPY_DECL_ASSEMBLER_NAME

#define COPY_DECL_ASSEMBLER_NAME	(		SRC_DECL,
			DST_DECL ) SET_DECL_ASSEMBLER_NAME (DST_DECL, DECL_ASSEMBLER_NAME_RAW (SRC_DECL))

Copy the DECL_ASSEMBLER_NAME from SRC_DECL to DST_DECL.  Note that
if SRC_DECL's DECL_ASSEMBLER_NAME has not yet been set, using this
macro will not cause the DECL_ASSEMBLER_NAME to be set, but will
clear DECL_ASSEMBLER_NAME of DST_DECL, if it was already set.  In
other words, the semantics of using this macro, are different than
saying:

  SET_DECL_ASSEMBLER_NAME(DST_DECL, DECL_ASSEMBLER_NAME (SRC_DECL))

which will try to set the DECL_ASSEMBLER_NAME for SRC_DECL.

◆ COPY_DECL_RTL

#define COPY_DECL_RTL	(		SRC_DECL,
			DST_DECL )

Value:

(DECL_WRTL_CHECK (DST_DECL)->decl_with_rtl.rtl \

= DECL_WRTL_CHECK (SRC_DECL)->decl_with_rtl.rtl)

DECL_WRTL_CHECK

#define DECL_WRTL_CHECK(T)

Definition tree.h:524

Copy the RTL from SRC_DECL to DST_DECL.  If the RTL was not set for
SRC_DECL, it will not be set for DST_DECL; this is a lazy copy.

◆ CST_CHECK

#define CST_CHECK ( T ) TREE_CLASS_CHECK (T, tcc_constant)

◆ current_optimize_pragma

#define current_optimize_pragma global_trees[TI_CURRENT_OPTIMIZE_PRAGMA]

Referenced by decl_attributes().

◆ current_target_pragma

#define current_target_pragma global_trees[TI_CURRENT_TARGET_PRAGMA]

Default tree list option(), optimize() pragmas to be linked into the
attribute list.

Referenced by decl_attributes().

◆ da_type_node

#define da_type_node global_trees[TI_DA_TYPE]

◆ DEBUG_TEMP_UID

#define DEBUG_TEMP_UID ( NODE ) (-DECL_UID (TREE_CHECK ((NODE), DEBUG_EXPR_DECL)))

DEBUG_EXPR_DECLs get negative UID numbers, to catch erroneous
uses.

Referenced by cselib_hash_rtx(), dequeue_and_dump(), dump_decl_name(), dump_var(), loc_cmp(), print_insn(), rtx_writer::print_rtx_operand_code_0(), and print_value().

◆ DECIMAL_FLOAT_TYPE_P

#define DECIMAL_FLOAT_TYPE_P ( TYPE )

Value:

(SCALAR_FLOAT_TYPE_P (TYPE) \

&& DECIMAL_FLOAT_MODE_P (TYPE_MODE (TYPE)))

DECIMAL_FLOAT_MODE_P

#define DECIMAL_FLOAT_MODE_P(MODE)

Definition machmode.h:148

SCALAR_FLOAT_TYPE_P

#define SCALAR_FLOAT_TYPE_P(TYPE)

Definition tree.h:648

TYPE_MODE

#define TYPE_MODE(NODE)

Definition tree.h:2254

Nonzero if TYPE represents a decimal floating-point type.

Referenced by convert_to_real_1(), vrange_printer::print_real_value(), simplify_vector_constructor(), strip_float_extensions(), and frange::supports_p().

◆ DECL_ABSTRACT_ORIGIN

#define DECL_ABSTRACT_ORIGIN ( NODE ) (DECL_COMMON_CHECK (NODE)->decl_common.abstract_origin)

For any sort of a ..._DECL node, this points to the original (abstract)
decl node which this decl is an inlined/cloned instance of, or else it
is NULL indicating that this decl is not an instance of some other decl.

The C front-end also uses this in a nested declaration of an inline
function, to point back to the definition.

Referenced by analyze_functions(), check_global_declaration(), copy_decl_for_dup_finish(), decl_maybe_in_construction_p(), decl_ultimate_origin(), delete_omp_context(), dequeue_and_dump(), DFS::DFS_write_tree_body(), expand_call_inline(), expand_debug_source_expr(), autofdo::function_instance::get_function_instance_by_decl(), autofdo::string_table::get_index_by_decl(), install_var_field(), lower_send_clauses(), lower_send_shared_vars(), lto_input_ts_decl_common_tree_pointers(), lto_read_tree_1(), polymorphic_ctor_dtor_p(), print_node(), remap_ssa_name(), symbol_table::remove_unreachable_nodes(), ipa_param_body_adjustments::reset_debug_stmts(), tree_function_versioning(), and write_ts_decl_common_tree_pointers().

◆ DECL_ABSTRACT_P

#define DECL_ABSTRACT_P ( NODE ) (DECL_COMMON_CHECK (NODE)->decl_common.abstract_flag)

Nonzero for a given ..._DECL node means that this node represents an
"abstract instance" of the given declaration (e.g. in the original
declaration of an inline function).  When generating symbolic debugging
information, we mustn't try to generate any address information for nodes
marked as "abstract instances" because we don't actually generate
any code or allocate any data space for such instances.

Referenced by can_refer_decl_in_current_unit_p(), copy_decl_no_change(), decl_ultimate_origin(), gen_field_die(), symtab_node::get_partitioning_class(), hash_tree(), need_assembler_name_p(), pack_ts_decl_common_value_fields(), print_node(), symtab_node::real_symbol_p(), record_type_tag(), and unpack_ts_decl_common_value_fields().

◆ DECL_ALIGN

#define DECL_ALIGN ( NODE )

Value:

(DECL_ALIGN_RAW (NODE) \

? ((unsigned)1) << (DECL_ALIGN_RAW (NODE) - 1) : 0)

DECL_ALIGN_RAW

#define DECL_ALIGN_RAW(NODE)

Definition tree.h:2785

Returns the alignment required for the datum, in bits.  It must
be a power of two, but an "alignment" of zero is supported
(e.g. as "uninitialized" sentinel).

Referenced by align_variable(), asan_finish_file(), assemble_variable(), assign_parm_setup_block(), build_constant_desc(), ipa_icf::sem_item::compare_referenced_symbol_properties(), ipa_icf_gimple::func_checker::compare_variable_decl(), copy_var_decl(), defer_stack_allocation(), dequeue_and_dump(), do_type_align(), ensure_base_align(), expand_expr_real_1(), expand_one_var(), finish_taskreg_scan(), force_reg(), get_alignment_1(), get_mem_align_offset(), get_object_alignment_2(), get_variable_align(), gimple_compare_field_offset(), gimplify_decl_expr(), gimplify_init_constructor(), gimplify_parameters(), gimplify_target_expr(), gimplify_vla_decl(), ipa_icf::sem_item::hash_referenced_symbol_properties(), hash_tree(), hoist_adjacent_loads(), symtab_node::increase_alignment(), increase_alignment_1(), insert_field_into_struct(), install_var_field(), install_var_field(), layout_decl(), lookup_field_for_decl(), lower_omp_target(), lower_omp_task_reductions(), lower_rec_input_clauses(), ipa_icf::sem_variable::merge(), ompdevlow_adjust_simt_enter(), output_constant_def_contents(), output_object_block(), pack_ts_decl_common_value_fields(), place_block_symbol(), print_node(), scan_omp_target(), simple_decl_align_in_bits(), target_align(), unpack_ts_decl_common_value_fields(), and update_alignment_for_field().

◆ DECL_ALIGN_RAW

#define DECL_ALIGN_RAW ( NODE ) (DECL_COMMON_CHECK (NODE)->decl_common.align)

Referenced by asan_emit_stack_protection().

◆ DECL_ALIGN_UNIT

#define DECL_ALIGN_UNIT ( NODE ) (DECL_ALIGN (NODE) / BITS_PER_UNIT)

The alignment of NODE, in bytes.

Referenced by add_bit_offset_attribute(), asan_poison_variable(), asan_protect_global(), create_task_copyfn(), default_emutls_var_init(), emutls_common_1(), execute_omp_oacc_neuter_broadcast(), gimplify_bind_expr(), go_format_type(), lower_omp_target(), and lower_private_allocate().

◆ DECL_ARG_TYPE

#define DECL_ARG_TYPE ( NODE ) (PARM_DECL_CHECK (NODE)->decl_common.initial)

For a PARM_DECL, records the data type used to pass the argument,
which may be different from the type seen in the program.

Referenced by assign_parm_find_data_types(), assign_parms_augmented_arg_list(), assumption_copy_decl(), ipa_param_body_adjustments::common_initialization(), create_loop_fn(), create_omp_child_function(), dequeue_and_dump(), expand_omp_target(), expand_thunk(), get_chain_decl(), print_node(), rtl_for_decl_location(), self_referential_size(), setup_incoming_promotions(), split_complex_args(), and split_function().

◆ DECL_ARGUMENTS

#define DECL_ARGUMENTS ( NODE ) (FUNCTION_DECL_CHECK (NODE)->function_decl.arguments)

In FUNCTION_DECL, a chain of ..._DECL nodes.

Referenced by allocate_struct_function(), assign_parms_augmented_arg_list(), gimple_infer_range::check_assume_func(), check_for_nested_with_variably_modified(), compute_fn_summary(), consider_split(), copy_bb(), copy_fn(), count_formal_params(), count_num_arguments(), create_function_info_for(), create_loop_fn(), create_omp_child_function(), create_parallel_loop(), create_task_copyfn(), cgraph_node::create_virtual_clone(), cgraph_node::create_wrapper(), dequeue_and_dump(), dump_function_to_file(), duplicate_thunk_for_node(), eliminate_tail_call(), ipa_icf::sem_function::equals_private(), execute_lower_omp(), execute_update_addresses_taken(), expand_call(), expand_call_inline(), expand_omp_target(), expand_omp_taskreg(), expand_thunk(), finalize_nesting_tree_1(), find_param_by_name(), find_tail_calls(), find_var_candidates(), fold_builtin_next_arg(), for_all_parms(), function_to_dwarf_procedure(), get_omp_data_i_param(), ipcp_transformation::get_param_index(), get_parm_access(), cgraph_node::get_untransformed_body(), gimplify_body(), gimplify_call_expr(), init_parameter_lattice_values(), initialize_inlined_parameters(), initialize_parameter_reductions(), inline_forbidden_p(), input_function(), instantiate_decls(), intra_create_variable_infos(), ipa_get_callee_param_type(), ipa_merge_profiles(), ipa_polymorphic_call_context::ipa_polymorphic_call_context(), ipa_populate_param_decls(), ipa_sra_summarize_function(), loc_list_from_tree_1(), lower_assumption(), lto_output(), ipcp_transformation::maybe_create_parm_idx_map(), maybe_inline_call_in_expr(), maybe_remove_omp_member_access_dummy_vars(), maybe_warn_read_write_only(), ipa_param_adjustments::modify_call(), ipa_param_body_adjustments::modify_formal_parameters(), move_sese_region_to_fn(), nonnull_arg_p(), ok_for_auto_simd_clone(), output_function(), param_type_may_change_p(), parm_object_size(), print_node(), print_rtx_function(), push_function_arg_decls(), cgraph_node::release_body(), reset_debug_bindings(), self_referential_size(), setjmp_args_warning(), setup_incoming_promotions(), simd_clone_init_simd_arrays(), split_function(), strub_watermark_parm(), suitable_for_tail_call_opt_p(), tree_function_versioning(), tree_optimize_tail_calls_1(), unshare_all_rtl(), unshare_all_rtl_again(), update_parameter_components(), and vt_add_function_parameters().

◆ DECL_ARTIFICIAL

#define DECL_ARTIFICIAL ( NODE ) (DECL_COMMON_CHECK (NODE)->decl_common.artificial_flag)

Used to indicate that this DECL represents a compiler-generated entity.

Referenced by add_discr_value(), adjust_one_expanded_partition_var(), asan_add_global(), asan_emit_stack_protection(), asan_finish_file(), asan_global_struct(), asan_needs_odr_indicator_p(), asan_protect_stack_decl(), assign_parm_setup_reg(), assign_parms_augmented_arg_list(), build_constant_desc(), build_cxa_atexit_decl(), build_debug_expr_decl(), build_dso_handle_decl(), build_fn_decl(), build_info(), build_libfunc_function_visibility(), tree_switch_conversion::switch_conversion::build_one_array(), build_personality_function(), cgraph_build_static_cdtor_1(), rt_bb_visited::check(), check_global_declaration(), cleanup_dead_labels(), collect_fallthrough_labels(), ipa_param_body_adjustments::common_initialization(), contains_polymorphic_type_p(), copy_decl_for_dup_finish(), copy_var_decl(), coverage_begin_function(), create_access_replacement(), create_artificial_label(), create_asan_shadow_var(), create_assumption_fn(), create_dispatcher_calls(), function_reader::create_function(), create_loop_fn(), create_odr_indicator(), create_omp_child_function(), create_one_component_var(), create_tmp_var_raw(), create_vop_var(), cxx17_empty_base_field_p(), decompose_kernels_region_body(), default_assemble_visibility(), default_external_stack_protect_fail(), default_hidden_stack_protect_fail(), default_stack_protect_guard(), dequeue_and_dump(), determine_iv_cost(), symtab_node::dump_base(), dw2_output_indirect_constant_1(), emit_warn_switch_unreachable(), execute_lower_omp(), expand_builtin_fork_or_exec(), expand_expr_real_1(), expand_FALLTHROUGH_r(), expand_omp_target(), expand_one_register_var(), expand_thunk(), expand_used_vars(), field_at_offset(), varpool_node::finalize_decl(), fortran_common(), get_binfo_at_offset(), get_chain_decl(), get_debug_decl(), get_emutls_init_templ_addr(), get_spill_slot_decl(), get_vec_alignment_for_record_type(), gimple_can_merge_blocks_p(), gimple_init_gcov_profiler(), gimple_merge_blocks(), gimplify_bind_expr(), gimplify_decl_expr(), gimplify_function_tree(), gimplify_type_sizes(), hash_tree(), increase_alignment(), init_ic_make_global_vars(), ipa_devirt(), ipa_tm_create_version_alias(), is_odr_indicator(), lhd_omp_predetermined_mapping(), lhd_omp_predetermined_sharing(), lower_gimple_return(), lower_omp_critical(), lower_send_shared_vars(), make_debug_expr_from_rtl(), make_dispatcher_decl(), mark_functions_to_output(), maybe_build_inner_data_region(), maybe_remove_omp_member_access_dummy_vars(), maybe_wrap_with_location(), modified_type_die(), new_emutls_decl(), oacc_default_clause(), oacc_do_neutering(), oacc_privatization_candidate_p(), odr_types_equivalent_p(), omp_member_access_dummy_var(), omp_notice_variable(), omp_oacc_kernels_decompose_1(), omp_resolve_declare_variant(), output_comp_unit(), pack_ts_decl_common_value_fields(), push_dummy_function(), record_targets_from_bases(), remap_ssa_name(), remove_forwarder_block(), replace_block_by(), ipa_param_body_adjustments::reset_debug_stmts(), ipa_polymorphic_call_context::restrict_to_inner_class(), scan_omp_parallel(), scan_omp_target(), scan_omp_task(), scan_omp_teams(), self_referential_size(), skip_in_fields_list_p(), spaceship_replacement(), split_complex_args(), stmt_starts_bb_p(), tree_function_versioning(), try_speculative_devirtualization(), ubsan_create_data(), ubsan_expand_vptr_ifn(), ubsan_get_source_location_type(), ubsan_get_type_descriptor_type(), ubsan_type_descriptor(), unpack_ts_decl_common_value_fields(), vt_add_function_parameters(), weak_finish(), and wrapup_global_declaration_2().

◆ DECL_ASSEMBLER_NAME

#define DECL_ASSEMBLER_NAME ( NODE ) decl_assembler_name (NODE)

The name of the object as the assembler will see it (but before any
translations made by ASM_OUTPUT_LABELREF).  Often this is the same
as DECL_NAME.  It is an IDENTIFIER_NODE.

ASSEMBLER_NAME of TYPE_DECLS may store global name of type used for
One Definition Rule based type merging at LTO.  It is computed only for
LTO compilation and C++.

Referenced by add_type_duplicate(), asan_add_global(), asan_memfn_rtl(), symtab_node::asm_name(), assemble_alias(), varpool_node::assemble_aliases(), cgraph_node::assemble_thunks_and_aliases(), auto_simd_fail(), build_gcov_exit_decl(), build_info(), build_init_ctor(), build_libfunc_function_visibility(), build_var(), symbol_table::change_decl_assembler_name(), check_call(), clone_function_name(), clone_function_name(), clone_function_name_numbered(), symbol_table::compile(), copy_function_or_variable(), coverage_begin_function(), coverage_compute_lineno_checksum(), coverage_compute_profile_id(), create_odr_indicator(), create_specialized_node(), symbol_table::decl_assembler_name_equal(), default_assemble_visibility(), default_elf_asm_output_external(), default_unique_section(), dequeue_and_dump(), DFS::DFS_write_tree_body(), do_assemble_alias(), do_assemble_symver(), thunk_info::dump(), symtab_node::dump_base(), dump_function_header(), dump_odr_type(), dw2_output_indirect_constant_1(), odr_name_hasher::equal(), expand_all_functions(), expand_simd_clones(), find_or_create_vtbl_map_node(), fndecl_dealloc_argno(), autofdo::autofdo_source_profile::get_callsite_total_count(), symtab_node::get_comdat_group_id(), varpool_node::get_constructor(), get_emutls_init_templ_addr(), autofdo::string_table::get_index_by_decl(), compiler_logical_location::get_internal_name_for_tree(), get_named_text_section(), get_odr_name_for_type(), cgraph_node::get_untransformed_body(), gimple_call_return_array(), gimple_init_gcov_profiler(), globalize_decl(), go_output_fndecl(), asmname_hasher::hash(), hash_odr_name(), operand_compare::hash_operand(), hash_tree(), init_eh(), symbol_table::insert_to_assembler_name_hash(), ipa_impossible_devirt_target(), ipa_odr_summary_write(), ipa_pta_execute(), ipa_tm_create_version(), ipa_tm_create_version_alias(), is_pass_explicitly_enabled_or_disabled(), lower_assumption(), symtab_node::make_decl_local(), make_decl_rtl(), make_dispatcher_decl(), merge_weak(), methods_equal_p(), symtab_node::needed_p(), new_delete_mismatch_p(), new_emutls_decl(), notice_global_symbol(), ok_for_auto_simd_clone(), optimize_omp_library_calls(), optimize_weakref(), optrecord_json_writer::optinfo_to_json(), symbol_table::output_weakrefs(), cgraph_edge::possibly_call_in_translation_unit_p(), print_decl_identifier(), print_declaration(), produce_asm(), produce_asm_for_decls(), produce_memory_decl_rtl(), simd_clone_create(), simd_clone_mangle(), subbinfo_with_vtable_at_offset(), type_in_anonymous_namespace_p(), types_same_for_odr(), symbol_table::unlink_from_assembler_name_hash(), ipa_icf::sem_item_optimizer::update_hash_by_addr_refs(), valid_new_delete_pair_p(), symtab_node::verify_base(), vtbl_map_get_node(), weak_finish(), weak_finish_1(), wrapup_global_declaration_2(), write_symbol(), and write_ts_decl_with_vis_tree_pointers().

◆ DECL_ASSEMBLER_NAME_RAW

#define DECL_ASSEMBLER_NAME_RAW ( NODE ) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.assembler_name)

Raw accessor for DECL_ASSEMBLE_NAME.

Referenced by alias_get_name(), asan_memfn_rtl(), compare_base_decls(), ipa_icf_gimple::func_checker::compare_variable_decl(), decl_assembler_name(), dump_decl_name(), gimple_decl_printable_name(), lhd_overwrite_decl_assembler_name(), and overwrite_decl_assembler_name().

◆ DECL_ASSEMBLER_NAME_SET_P

#define DECL_ASSEMBLER_NAME_SET_P ( NODE ) (DECL_ASSEMBLER_NAME_RAW (NODE) != NULL_TREE)

Returns nonzero if the DECL_ASSEMBLER_NAME for NODE has been set.  If zero,
the NODE might still have a DECL_ASSEMBLER_NAME -- it just hasn't been set
yet.

Referenced by alias_get_name(), symtab_node::asm_name(), symbol_table::change_decl_assembler_name(), compare_base_decls(), decl_assembler_name(), dequeue_and_dump(), DFS::DFS_write_tree_body(), dump_decl_name(), dump_function_header(), dump_odr_type(), expand_omp_target(), expand_omp_taskreg(), get_function_name(), get_odr_name_for_type(), gimple_decl_printable_name(), hash_odr_name(), operand_compare::hash_operand(), hash_tree(), ipa_pta_execute(), is_pass_explicitly_enabled_or_disabled(), lower_assumption(), symtab_node::name(), need_assembler_name_p(), symtab_node::needed_p(), odr_type_p(), register_asm_p(), rest_of_decl_compilation(), type_in_anonymous_namespace_p(), type_with_linkage_p(), ipa_icf::sem_item_optimizer::update_hash_by_addr_refs(), and write_ts_decl_with_vis_tree_pointers().

◆ DECL_ATTRIBUTES

#define DECL_ATTRIBUTES ( NODE ) (DECL_COMMON_CHECK (NODE)->decl_common.attributes)

In a DECL this is the field where attributes are stored.

Referenced by varpool_node::add(), add_clobbers_to_eh_landing_pad(), add_decls_addresses_to_decl_constructor(), add_detected_attribute_1(), analyze_functions(), asan_poison_variables(), asan_protect_global(), assemble_alias(), assemble_external(), assemble_start_function(), auto_simd_check_stmt(), avoid_folding_inline_builtin(), block_nonartificial_location(), btf_collect_datasec(), build_decl_attribute_variant(), tree_switch_conversion::switch_conversion::build_one_array(), can_early_inline_edge_p(), can_inline_edge_by_limits_p(), can_strub_internally_p(), can_strub_p(), cgraph_externally_visible_p(), check_scan_store(), common_function_versions(), ipa_icf::sem_item::compare_referenced_symbol_properties(), symbol_table::compile(), computable_teams_clause(), compute_fn_summary(), compute_function_frequency(), copy_attributes_to_builtin(), copy_decl_for_dup_finish(), copy_var_decl(), cgraph_node::create(), cgraph_node::create_alias(), varpool_node::create_alias(), create_assumption_fn(), create_odr_indicator(), create_omp_child_function(), create_parallel_loop(), create_target_clone(), cgraph_node::create_version_clone_with_body(), cxx17_empty_base_field_p(), decl_attributes(), declare_weak(), decls_mismatched_attributes(), default_binds_local_p_3(), determine_versionability(), device_resident_p(), DFS::DFS_write_tree_body(), diag_attr_exclusions(), do_assemble_alias(), do_estimate_edge_time(), dump_function_to_file(), early_inliner(), symtab_node::equal_address_to(), ipa_icf::sem_function::equals_wpa(), error_unavailable_use(), execute_oacc_loop_designation(), execute_ranger_vrp(), execute_split_functions(), expand_call_inline(), expand_expr_real_1(), expand_oacc_for(), expand_omp_target(), expand_one_var(), expand_simd_clones(), expand_target_clones(), expand_used_vars(), varpool_node::externally_visible_p(), find_simtpriv_var_op(), flags_from_decl_or_type(), flatten_remove_node_hook(), fndecl_alloc_p(), fndecl_dealloc_argno(), function_and_variable_visibility(), function_attribute_inlinable_p(), gate_oacc_kernels(), get_alias_symbol(), get_attr_nonstring_decl(), cgraph_node::get_availability(), get_block_for_decl(), varpool_node::get_create(), get_section(), get_strub_attr_from_decl(), get_variable_section(), gimple_init_gcov_profiler(), gimplify_adjust_omp_clauses(), gimplify_adjust_omp_clauses_1(), gimplify_bind_expr(), gimplify_body(), gimplify_case_label_expr(), gimplify_label_expr(), gimplify_oacc_declare(), handle_alias_pairs(), hash_tree(), inline_always_inline_functions(), inline_forbidden_p_stmt(), input_node(), ipa_inline(), ipa_pta_execute(), is_asan_mark_p(), is_function_default_version(), is_oacc_declared(), is_odr_indicator(), is_var_need_auto_init(), likely_target_p(), lower_lastprivate_clauses(), lower_omp_scan(), lower_omp_target(), lower_rec_simd_input_clauses(), lto_input_ts_decl_common_tree_pointers(), lto_output_node(), symtab_node::make_decl_local(), make_split_prologue_seq(), matching_alloc_calls_p(), maybe_diag_alias_attributes(), ipa_icf::sem_function::merge(), ipa_icf::sem_item_optimizer::merge_classes(), merge_decl_attributes(), new_emutls_decl(), non_local_p(), symtab_node::noninterposable_alias(), symtab_node::noninterposable_alias(), note_simd_array_uses_cb(), oacc_get_fn_attrib(), oacc_replace_fn_attrib(), oacc_validate_dims(), oacc_verify_routine_clauses(), offloading_function_p(), ok_for_auto_simd_clone(), omp_construct_selector_matches(), omp_context_selector_matches(), omp_declare_target_fn_p(), omp_declare_target_var_p(), omp_discover_declare_target_tgt_fn_r(), omp_discover_declare_target_var_r(), omp_discover_implicit_declare_target(), omp_finish_file(), omp_lto_input_declare_variant_alt(), omp_lto_output_declare_variant_alt(), omp_mark_declare_variant(), omp_maybe_offloaded(), omp_notice_variable(), omp_resolve_declare_variant(), optimize_weakref(), ipa_icf::sem_function::parse(), possible_inline_candidate_p(), print_node(), process_common_attributes(), process_function_and_variable_attributes(), process_symver_attribute(), redirect_to_specific_clone(), refered_from_nonlocal_fn(), remap_type_1(), symbol_table::remove_unreachable_nodes(), resolve_unique_section(), rest_of_decl_compilation(), rest_of_handle_final(), sanitize_attrs_match_for_inline_p(), sanitize_coverage_p(), sanitize_flags_p(), scan_omp_1_op(), scan_sharing_clauses(), set_call_expr_flags(), set_strub_mode_to(), stack_protect_decl_phase(), strub_always_inline_p(), strub_set_fndt_mode_to(), switch_to_section(), tree_bb_level_predictions(), tree_inlinable_function_p(), tree_profiling(), tree_versionable_function_p(), unlikely_executed_stmt_p(), vect_recog_pow_pattern(), vectorizable_scan_store(), symtab_node::verify_base(), verify_node_partition(), visit_bb(), warn_deprecated_use(), and write_ts_decl_common_tree_pointers().

◆ DECL_BIT_FIELD

#define DECL_BIT_FIELD ( NODE ) (FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_1)

Nonzero in a FIELD_DECL means it is a bit field, and must be accessed
specially.

Referenced by adjacent_dr_p(), analyze_access_subtree(), build_debug_ref_for_model(), build_ref_for_model(), clear_padding_type(), ao_compare::compare_ao_refs(), compute_access_stride(), contains_bitfld_component_ref_p(), contains_vce_or_bfcref_p(), find_constructor_constant_at_offset(), find_single_drs(), fold_const_aggregate_ref_1(), fold_nonarray_ctor_reference(), fold_unary_loc(), get_inner_reference(), get_narrower(), go_format_type(), ao_compare::hash_ao_ref(), hash_tree(), layout_decl(), loc_list_from_tree_1(), native_encode_initializer(), native_interpret_aggregate(), nonoverlapping_component_refs_p_1(), odr_types_equivalent_p(), pack_ts_decl_common_value_fields(), place_field(), print_node(), ref_at_iteration(), set_mem_attributes_minus_bitpos(), slsr_process_ref(), sort_and_splice_var_accesses(), staticp(), store_constructor(), pcom_worker::suitable_component_p(), totally_scalarizable_type_p(), unpack_ts_decl_common_value_fields(), and vect_find_stmt_data_reference().

◆ DECL_BIT_FIELD_REPRESENTATIVE

#define DECL_BIT_FIELD_REPRESENTATIVE ( NODE ) (FIELD_DECL_CHECK (NODE)->field_decl.qualifier)

In a FIELD_DECL of a RECORD_TYPE, this is a pointer to the storage
representative FIELD_DECL.

Referenced by compute_access_stride(), DFS::DFS_write_tree_body(), finish_bitfield_layout(), fold_const_aggregate_ref_1(), get_bit_range(), get_bitfield_rep(), hash_tree(), instrument_derefs(), instrument_expr(), instrument_object_size(), lto_input_ts_field_decl_tree_pointers(), native_encode_initializer(), native_interpret_aggregate(), nonoverlapping_component_refs_p_1(), and write_ts_field_decl_tree_pointers().

◆ DECL_BIT_FIELD_TYPE

#define DECL_BIT_FIELD_TYPE ( NODE ) (FIELD_DECL_CHECK (NODE)->field_decl.bit_field_type)

In a FIELD_DECL, this indicates whether the field was a bit-field and
if so, the type that was originally specified for it.
TREE_TYPE may have been modified (in finish_struct).

Referenced by add_abstract_origin_attribute(), add_data_member_location_attribute(), bitfields_to_lower_p(), DFS::DFS_write_tree_body(), eliminate_dom_walker::eliminate_stmt(), expand_assignment(), expand_expr_real_1(), field_byte_offset(), field_type(), finish_bitfield_layout(), get_inner_reference(), gimple_lower_bitint(), hash_tree(), instrument_expr(), layout_decl(), lto_input_ts_field_decl_tree_pointers(), place_field(), print_node(), update_alignment_for_field(), and write_ts_field_decl_tree_pointers().

◆ DECL_BUILT_IN_CLASS

#define DECL_BUILT_IN_CLASS ( NODE ) ((built_in_class) FUNCTION_DECL_CHECK (NODE)->function_decl.built_in_class)

For a builtin function, identify which part of the compiler defined it.

Referenced by alloca_call_p(), associated_internal_fn(), builtin_safe_for_const_function_p(), builtin_with_linkage_p(), can_implement_as_sibling_call_p(), check_call(), check_defs(), decl_attributes(), eliminate_unnecessary_stmts(), emit_call_1(), expand_builtin(), expand_call_tm(), expand_expr_real_1(), expr_expected_value_1(), find_tm_replacement_function(), fndecl_built_in_p(), fndecl_built_in_p(), fold_builtin_call_array(), fold_call_expr(), fold_call_stmt(), gimple_builtin_call_types_compatible_p(), gimple_call_builtin_p(), gimple_call_builtin_p(), gimple_extract(), operand_compare::hash_operand(), hash_tree(), inline_forbidden_p_stmt(), is_inexpensive_builtin(), is_tm_builtin(), is_tm_ending_fndecl(), need_assembler_name_p(), old_insns_match_p(), operand_compare::operand_equal_p(), pack_ts_function_decl_value_fields(), print_node(), propagate_necessity(), scan_omp_1_stmt(), special_function_p(), strub_callable_builtin_p(), and tree_builtin_call_types_compatible_p().

◆ DECL_BY_REFERENCE

#define DECL_BY_REFERENCE ( NODE )

Value:

(TREE_CHECK3 (NODE, VAR_DECL, PARM_DECL, \

RESULT_DECL)->decl_common.decl_by_reference_flag)

TREE_CHECK3

#define TREE_CHECK3(T, CODE1, CODE2, CODE3)

Definition tree.h:490

In a RESULT_DECL, PARM_DECL and VAR_DECL, means that it is
passed by invisible reference (and the TREE_TYPE is a pointer to the true
type).

Referenced by aggregate_value_p(), assign_parms(), assumption_copy_decl(), ipa_icf_gimple::func_checker::compare_decl(), consider_split(), copy_decl_to_var(), copy_result_decl_to_var(), create_function_info_for(), decl_by_reference_p(), declare_return_variable(), dump_function_to_file(), expand_function_end(), expand_function_start(), expand_thunk(), expand_value_return(), get_debug_decl(), gimple_regimplify_operands(), hash_tree(), intra_create_variable_infos(), ipa_polymorphic_call_context::ipa_polymorphic_call_context(), lower_omp_target(), lower_send_shared_vars(), mark_nonssa_use(), maybe_add_sra_candidate(), needs_to_live_in_memory(), pack_ts_decl_common_value_fields(), points_to_local_or_readonly_memory_p(), print_node(), promote_decl_mode(), requires_barrier(), simd_clone_adjust(), split_function(), ssa_defined_default_def_p(), test_nonssa_use(), tree_function_versioning(), unpack_ts_decl_common_value_fields(), use_pointer_for_field(), use_register_for_decl(), verify_def(), and verify_gimple_return().

◆ DECL_CHAIN

#define DECL_CHAIN ( NODE ) (TREE_CHAIN (DECL_MINIMAL_CHECK (NODE)))

Referenced by access_and_field_type_match_p(), adjust_context_and_scope(), allocate_struct_function(), array_ref_flexible_size_p(), asan_add_global(), asan_global_struct(), assign_parm_find_data_types(), assign_parms(), assign_parms_augmented_arg_list(), build_fn_info(), build_fn_info_type(), build_info(), build_info_type(), build_user_friendly_ref_for_offset(), chain_member(), gimple_infer_range::check_assume_func(), check_for_nested_with_variably_modified(), clear_padding_type(), clear_padding_union(), clear_tree_used(), ipa_param_body_adjustments::common_initialization(), compute_fn_summary(), compute_record_mode(), consider_split(), contains_pointers_p(), contains_polymorphic_type_p(), convert_local_reference_stmt(), convert_nonlocal_reference_stmt(), copy_arguments_nochange(), copy_bb(), copy_fn(), copy_static_chain(), count_formal_params(), count_num_arguments(), count_type_elements(), create_function_info_for(), create_odr_indicator(), create_omp_child_function(), create_task_copyfn(), create_tmp_var_for(), declare_inline_vars(), declare_vars(), default_emutls_var_fields(), default_emutls_var_init(), delete_omp_context(), dequeue_and_dump(), dump_function_to_file(), dump_generic_node(), dump_gimple_bind(), dump_scope_block(), duplicate_thunk_for_node(), eliminate_tail_call(), ipa_icf::sem_function::equals_private(), execute_update_addresses_taken(), expand_call(), expand_call_inline(), expand_omp_target(), expand_omp_taskreg(), expand_thunk(), expand_used_vars_for_block(), fields_length(), finalize_nesting_tree_1(), find_assumption_locals_r(), find_tail_calls(), find_var_candidates(), finish_bitfield_layout(), finish_bitfield_representative(), finish_builtin_struct(), finish_taskreg_scan(), fixup_child_record_type(), fixup_vla_decls(), flexible_array_member_p(), flexible_array_type_p(), for_all_parms(), gen_formal_types_die(), get_binfo_at_offset(), get_local_debug_decl(), ipa_param_body_adjustments::get_new_param_chain(), get_nonlocal_debug_decl(), get_omp_data_i_param(), ipcp_transformation::get_param_index(), get_ref_base_and_extent(), get_vec_alignment_for_record_type(), gimple_add_tmp_var(), gimple_add_tmp_var_fn(), gimplify_bind_expr(), gimplify_body(), gimplify_type_sizes(), global_decl_processing(), hoist_adjacent_loads(), init_ic_make_global_vars(), init_parameter_lattice_values(), initialize_inlined_parameters(), initialize_parameter_reductions(), inline_forbidden_p(), insert_field_into_struct(), instantiate_decls(), instantiate_decls_1(), intra_create_variable_infos(), ipa_populate_param_decls(), ipa_sra_summarize_function(), is_empty_type(), is_redundant_typedef(), layout_type(), lhd_simulate_record_decl(), lookup_field_for_decl(), lower_assumption(), lower_gimple_bind(), lower_lastprivate_conditional_clauses(), lower_omp_task_reductions(), lower_send_shared_vars(), ipcp_transformation::maybe_create_parm_idx_map(), maybe_inline_call_in_expr(), maybe_remove_omp_member_access_dummy_vars(), ipa_param_adjustments::modify_call(), move_sese_region_to_fn(), native_encode_initializer(), native_interpret_aggregate(), nonnull_arg_p(), oacc_privatization_scan_decl_chain(), ok_for_auto_simd_clone(), omp_copy_decl_2(), omp_firstprivatize_type_sizes(), output_constructor(), output_constructor_regular_field(), place_field(), print_rtx_function(), print_struct_decl(), process_scope_var(), push_fields_onto_fieldstack(), push_function_arg_decls(), record_component_aliases(), record_targets_from_bases(), record_vars_into(), remap_decls(), remap_type_1(), remap_type_2(), remap_vla_decls(), remove_exit_barrier(), remove_member_access_dummy_vars(), remove_unused_scope_block_p(), replace_block_vars_by_duplicates(), replace_locals_stmt(), reset_debug_bindings(), ipa_param_body_adjustments::reset_debug_stmts(), ipa_polymorphic_call_context::restrict_to_inner_class(), scan_omp_1_stmt(), scan_omp_target(), self_referential_size(), set_decl_origin_self(), set_used_decls(), setjmp_args_warning(), setjmp_vars_warning(), setup_incoming_promotions(), setup_one_parameter(), simd_clone_init_simd_arrays(), split_function(), strub_watermark_parm(), suitable_for_tail_call_opt_p(), totally_scalarizable_type_p(), totally_scalarize_subtree(), tracked_record_parameter_p(), tree_function_versioning(), tree_optimize_tail_calls_1(), type_contains_placeholder_1(), type_internals_preclude_sra_p_1(), type_like_member_ptr_p(), ubsan_create_data(), ubsan_get_source_location_type(), ubsan_get_type_descriptor_type(), unshare_all_rtl(), unshare_all_rtl_again(), update_parameter_components(), variably_modified_type_p(), vec2chain(), vt_add_function_parameters(), and walk_tree_1().

◆ DECL_COMDAT

#define DECL_COMDAT ( NODE ) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.comdat_flag)

Used in a DECL to indicate that, even if it TREE_PUBLIC, it need
not be put out unless it is needed in this translation unit.
Entities like this are shared across translation units (like weak
entities), but are guaranteed to be generated by any translation
unit that needs them, and therefore need not be put out anywhere
where they are not needed.  DECL_COMDAT is just a hint to the
back-end; it is up to front-ends which set this flag to ensure
that there will never be any harm, other than bloat, in putting out
something which is DECL_COMDAT.

Referenced by can_refer_decl_in_current_unit_p(), cgraph_node::can_remove_if_no_direct_calls_and_refs_p(), varpool_node::can_remove_if_no_refs_p(), cgraph_externally_visible_p(), cgraph_node_cannot_be_local_p_1(), symtab_node::copy_visibility_from(), cgraph_node::create_version_clone_with_body(), cgraph_node::create_virtual_clone(), cross_module_call_p(), varpool_node::ctor_useable_for_folding_p(), decl_replaceable_p(), drop_profile(), symtab_node::dump_base(), varpool_node::externally_visible_p(), varpool_node::finalize_decl(), cgraph_node::finalize_function(), symtab_node::fixup_same_cpp_alias_visibility(), function_always_visible_to_compiler_p(), function_and_variable_visibility(), handle_missing_profiles(), hash_tree(), localize_node(), symtab_node::make_decl_local(), cgraph_node::make_local(), symtab_node::needed_p(), symtab_node::noninterposable_alias(), symtab_node::nonzero_address(), offline_size(), pack_ts_decl_with_vis_value_fields(), process_symver_attribute(), save_inline_function_body(), set_new_clone_decl_and_node_flags(), simd_clone_create(), tree_could_trap_p(), unpack_ts_decl_with_vis_value_fields(), and wrapup_global_declaration_2().

◆ DECL_COMDAT_GROUP

#define DECL_COMDAT_GROUP ( NODE ) decl_comdat_group (NODE)

Referenced by default_elf_asm_named_section(), default_elf_select_rtx_section(), default_function_rodata_section(), default_print_patchable_function_entry(), default_section_type_flags(), get_block_for_decl(), get_named_text_section(), ipa_tm_create_version(), ipa_icf::sem_function::merge(), ipa_icf::sem_variable::merge(), ipa_icf::redirect_all_callers(), resolve_unique_section(), switch_to_comdat_section(), and switch_to_exception_section().

◆ DECL_COMMON

#define DECL_COMMON ( NODE ) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.common_flag)

Nonzero for a given ..._DECL node means that this node should be
put in .common, if possible.  If a DECL_INITIAL is given, and it
is not error_mark_node, then the decl cannot be put in .common.

Referenced by array_ref_flexible_size_p(), asan_protect_global(), bss_initializer_p(), symtab_node::can_be_discarded_p(), symtab_node::copy_visibility_from(), decl_binds_to_current_def_p(), default_binds_local_p_3(), symtab_node::dump_base(), emutls_common_1(), function_and_variable_visibility(), get_ref_base_and_extent(), get_variable_section(), hash_tree(), lower_omp_critical(), symtab_node::make_decl_local(), make_decl_one_only(), make_decl_rtl(), new_emutls_decl(), notice_global_symbol(), pack_ts_decl_with_vis_value_fields(), print_node(), process_symver_attribute(), unpack_ts_decl_with_vis_value_fields(), and write_symbol().

◆ DECL_COMMON_CHECK

#define DECL_COMMON_CHECK ( T ) CONTAINS_STRUCT_CHECK (T, TS_DECL_COMMON)

◆ DECL_CONTEXT

#define DECL_CONTEXT ( NODE ) (DECL_MINIMAL_CHECK (NODE)->decl_minimal.context)

For FIELD_DECLs, this is the RECORD_TYPE, UNION_TYPE, or
QUAL_UNION_TYPE node that the field is a member of.  For VAR_DECL,
PARM_DECL, FUNCTION_DECL, LABEL_DECL, RESULT_DECL, and CONST_DECL
nodes, this points to either the FUNCTION_DECL for the containing
function, the RECORD_TYPE or UNION_TYPE for the containing type, or
NULL_TREE or a TRANSLATION_UNIT_DECL if the given decl has "file
scope".  In particular, for VAR_DECLs which are virtual table pointers
(they have DECL_VIRTUAL set), we use DECL_CONTEXT to determine the type
they belong to.

Referenced by access_fn_components_comparable_p(), add_src_coords_attributes(), adjust_assumption_stmt_r(), adjust_context_and_scope(), asan_global_struct(), auto_var_in_fn_p(), build_type_inheritance_graph(), ipa_param_body_adjustments::carry_over_param(), cgraph_build_static_cdtor_1(), cleanup_control_flow_bb(), ipa_param_body_adjustments::common_initialization(), ipa_icf::sem_item::compare_referenced_symbol_properties(), compare_virtual_tables(), convert_local_omp_clauses(), convert_nonlocal_omp_clauses(), copy_decl_for_dup_finish(), copy_tree_body_r(), copy_var_decl(), create_access_replacement(), create_artificial_label(), create_assumption_fn(), create_loop_fn(), create_omp_child_function(), create_task_copyfn(), create_tmp_var_for(), create_vop_var(), decl_address_invariant_p(), decl_class_context(), decl_function_context(), decl_type_context(), default_emutls_var_fields(), dequeue_and_dump(), devirt_variable_node_removal_hook(), DFS::DFS_write_tree_body(), duplicate_thunk_for_node(), expand_debug_source_expr(), expand_omp_target(), expand_omp_taskreg(), expand_thunk(), extr_type_from_vtbl_ptr_store(), cgraph_node::finalize_function(), finalize_nesting_tree_1(), find_assumption_locals_r(), finish_bitfield_representative(), fixup_child_record_type(), function_to_dwarf_procedure(), gen_variable_die(), get_chain_decl(), get_containing_scope(), get_descriptor_type(), get_emutls_init_templ_addr(), get_frame_type(), get_local_debug_decl(), get_nonlocal_debug_decl(), get_trampoline_type(), gimple_add_tmp_var(), gimple_add_tmp_var_fn(), gimplify_bind_expr(), gimplify_cond_expr(), gimplify_oacc_declare(), gimplify_omp_loop(), handle_warn_if_not_align(), hash_tree(), input_offload_tables(), insert_field_into_struct(), ipa_devirt(), ipa_tm_create_version_alias(), loc_list_from_tree_1(), lower_assumption(), lower_lastprivate_conditional_clauses(), lower_omp_target(), lower_omp_task_reductions(), lower_rec_input_clauses(), lto_input_ts_decl_minimal_tree_pointers(), make_dispatcher_decl(), mark_all_vars_used_1(), maybe_create_die_with_external_ref(), maybe_nonzero_address(), maybe_record_nested_function(), maybe_record_node(), maybe_special_function_p(), move_block_to_fn(), move_stmt_op(), move_stmt_r(), new_emutls_decl(), symtab_node::noninterposable_alias(), nonoverlapping_component_refs_p_1(), nonoverlapping_refs_since_match_p(), note_no_context_vars(), note_simd_array_uses_cb(), omp_copy_decl(), omp_copy_decl_2(), omp_default_clause(), omp_member_access_dummy_var(), omp_runtime_api_call(), possible_polymorphic_call_targets(), print_node(), remap_decl(), remap_gimple_op_r(), remap_type_1(), replace_by_duplicate_decl(), ipa_param_body_adjustments::reset_debug_stmts(), scan_omp_simd(), scan_sharing_clauses(), self_referential_size(), setjmp_or_longjmp_p(), start_bitfield_representative(), task_copyfn_remap_type(), tree_function_versioning(), tree_is_indexable(), ubsan_create_data(), ubsan_encode_value(), ubsan_get_source_location_type(), ubsan_get_type_descriptor_type(), verify_gimple_label(), vtable_pointer_value_to_binfo(), and write_ts_decl_minimal_tree_pointers().

◆ DECL_CXX_CONSTRUCTOR_P

#define DECL_CXX_CONSTRUCTOR_P ( NODE ) (FUNCTION_DECL_CHECK (NODE)->decl_with_vis.cxx_constructor)

In FUNCTION_DECL, this is set if this function is a C++ constructor.
Devirtualization machinery uses this knowledge for determing type of the
object constructed.  Also we assume that constructor address is not
important.

Referenced by symtab_node::address_can_be_compared_p(), check_stmt_for_type_change(), decl_maybe_in_construction_p(), ipa_icf::sem_function::equals_wpa(), ipa_icf::sem_function::get_hash(), hash_tree(), intra_create_variable_infos(), ipa_polymorphic_call_context::ipa_polymorphic_call_context(), noncall_stmt_may_be_vtbl_ptr_store(), pack_ts_decl_with_vis_value_fields(), param_type_may_change_p(), polymorphic_ctor_dtor_p(), unpack_ts_decl_with_vis_value_fields(), and ipa_icf::sem_item_optimizer::update_hash_by_addr_refs().

◆ DECL_CXX_DESTRUCTOR_P

#define DECL_CXX_DESTRUCTOR_P ( NODE ) (FUNCTION_DECL_CHECK (NODE)->decl_with_vis.cxx_destructor)

In FUNCTION_DECL, this is set if this function is a C++ destructor.
Devirtualization machinery uses this to track types in destruction.

Referenced by symtab_node::address_can_be_compared_p(), decl_maybe_in_construction_p(), ipa_icf::sem_function::equals_wpa(), ipa_icf::sem_function::get_hash(), hash_tree(), ipa_devirt(), ipa_polymorphic_call_context::ipa_polymorphic_call_context(), noncall_stmt_may_be_vtbl_ptr_store(), pack_ts_decl_with_vis_value_fields(), param_type_may_change_p(), polymorphic_ctor_dtor_p(), possible_polymorphic_call_targets(), record_target_from_binfo(), record_targets_from_bases(), and unpack_ts_decl_with_vis_value_fields().

◆ DECL_DEBUG_EXPR

#define DECL_DEBUG_EXPR ( NODE ) (decl_debug_expr_lookup (VAR_DECL_CHECK (NODE)))

Referenced by add_local_variables(), add_var_loc_to_decl(), default_tree_printer(), DFS::DFS_write_tree_body(), hash_tree(), track_expr_p(), var_debug_decl(), verify_expr_location_1(), and write_ts_decl_common_tree_pointers().

◆ DECL_DECLARED_INLINE_P

#define DECL_DECLARED_INLINE_P ( NODE ) (FUNCTION_DECL_CHECK (NODE)->function_decl.declared_inline_flag)

Nonzero in a FUNCTION_DECL means that this function was declared inline,
such as via the `inline' keyword in C/C++.  This flag controls the linkage
semantics of 'inline'

Referenced by avoid_folding_inline_builtin(), block_nonartificial_location(), can_inline_edge_by_limits_p(), ipa_icf::sem_item::compare_referenced_symbol_properties(), consider_split(), devirtualization_time_bonus(), dump_targets(), early_inline_small_functions(), edge_badness(), ipa_call_context::estimate_size_and_time(), execute_split_functions(), expand_call_inline(), cgraph_node::finalize_function(), symtab_node::fixup_same_cpp_alias_visibility(), function_always_visible_to_compiler_p(), cgraph_node::get_availability(), gimplify_function_tree(), ipa_icf::sem_item::hash_referenced_symbol_properties(), hash_tree(), ipa_tm_create_version(), lhd_warn_unused_global_decl(), pack_ts_function_decl_value_fields(), perform_estimation_of_a_value(), print_node(), process_function_and_variable_attributes(), recursive_inlining(), reference_to_unused(), self_referential_size(), tree_inlinable_function_p(), unpack_ts_function_decl_value_fields(), want_early_inline_function_p(), want_inline_self_recursive_call_p(), want_inline_small_function_p(), and wrapper_heuristics_may_apply().

◆ DECL_DEFER_OUTPUT

#define DECL_DEFER_OUTPUT ( NODE ) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.defer_output)

Used to indicate that the linkage status of this DECL is not yet known,
so it should not be output now.

Referenced by print_node(), rest_of_decl_compilation(), and wrapup_global_declaration_1().

◆ DECL_DISREGARD_INLINE_LIMITS

#define DECL_DISREGARD_INLINE_LIMITS ( NODE ) (FUNCTION_DECL_CHECK (NODE)->function_decl.disregard_inline_limits)

Nonzero in a FUNCTION_DECL that should be always inlined by the inliner
disregarding size and cost heuristics.  This is equivalent to using
the always_inline attribute without the required diagnostics if the
function cannot be inlined.

Referenced by avoid_folding_inline_builtin(), can_early_inline_edge_p(), can_inline_edge_by_limits_p(), ipa_icf::sem_item::compare_referenced_symbol_properties(), edge_badness(), execute_split_functions(), cgraph_node::finalize_function(), symtab_node::fixup_same_cpp_alias_visibility(), gimplify_function_tree(), ipa_icf::sem_item::hash_referenced_symbol_properties(), hash_tree(), inline_always_inline_functions(), inline_small_functions(), ipa_dump_fn_summary(), pack_ts_function_decl_value_fields(), record_cdtor_fn(), unpack_ts_function_decl_value_fields(), want_early_inline_function_p(), and want_inline_small_function_p().

◆ DECL_DLLIMPORT_P

#define DECL_DLLIMPORT_P ( NODE ) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.dllimport_flag)

Used to indicate that the DECL is a dllimport.

Referenced by symtab_node::copy_visibility_from(), decl_address_ip_invariant_p(), symtab_node::dump_base(), fixed_address_object_p(), hash_tree(), symtab_node::make_decl_local(), new_emutls_decl(), symtab_node::noninterposable_alias(), pack_ts_decl_with_vis_value_fields(), simd_clone_create(), staticp(), and unpack_ts_decl_with_vis_value_fields().

◆ DECL_EXPR_DECL

#define DECL_EXPR_DECL ( NODE ) TREE_OPERAND (DECL_EXPR_CHECK (NODE), 0)

DECL_EXPR accessor. This gives access to the DECL associated with
the given declaration statement.

Referenced by dump_generic_node(), find_decl_expr(), gimplify_compound_literal_expr(), gimplify_decl_expr(), gimplify_modify_expr_rhs(), gimplify_omp_for(), optimize_compound_literals_in_ctor(), safe_from_p(), and walk_tree_1().

◆ DECL_EXTERNAL

#define DECL_EXTERNAL ( NODE ) (DECL_COMMON_CHECK (NODE)->decl_common.decl_flag_1)

In a VAR_DECL or FUNCTION_DECL, nonzero means external reference:
do not allocate storage, and refer to a definition elsewhere.  Note that
this does not necessarily imply the entity represented by NODE
has no program source-level definition in this translation unit.  For
example, for a FUNCTION_DECL, DECL_SAVED_TREE may be non-NULL and
DECL_EXTERNAL may be true simultaneously; that can be the case for
a C99 "extern inline" function.

Referenced by add_type_duplicate(), analyze_functions(), asan_emit_stack_protection(), asan_protect_global(), varpool_node::assemble_decl(), assemble_external(), assemble_variable(), auto_var_p(), symtab_node::binds_to_current_def_p(), btf_collect_datasec(), build_builtin_function(), build_cxa_atexit_decl(), build_dso_handle_decl(), build_fn_decl(), build_gcov_exit_decl(), build_info(), build_init_ctor(), build_libfunc_function_visibility(), build_personality_function(), symtab_node::can_be_discarded_p(), can_escape(), can_refer_decl_in_current_unit_p(), cgraph_node::can_remove_if_no_direct_calls_and_refs_p(), cgraph_node::can_remove_if_no_direct_calls_p(), varpool_node::can_remove_if_no_refs_p(), cgraph_externally_visible_p(), symbol_table::change_decl_assembler_name(), check_decl(), check_global_declaration(), component_ref_size(), convert_local_omp_clauses(), convert_local_reference_op(), convert_local_reference_stmt(), convert_nonlocal_omp_clauses(), convert_nonlocal_reference_op(), convert_nonlocal_reference_stmt(), copy_decl_for_dup_finish(), symtab_node::copy_visibility_from(), coverage_compute_profile_id(), create_assumption_fn(), function_reader::create_function(), create_loop_fn(), create_omp_child_function(), create_tmp_var_raw(), create_variable_info_for_1(), cgraph_node::create_version_clone_with_body(), cgraph_node::create_virtual_clone(), create_vop_var(), ctor_for_folding(), varpool_node::ctor_useable_for_folding_p(), decl_address_invariant_p(), decl_address_ip_invariant_p(), decl_binds_to_current_def_p(), decl_in_symtab_p(), default_binds_local_p_3(), default_encode_section_info(), default_external_stack_protect_fail(), default_hidden_stack_protect_fail(), default_ref_may_alias_errno(), default_stack_protect_guard(), dequeue_and_dump(), determine_versionability(), DFS::DFS_write_tree_body(), drop_profile(), symtab_node::dump_base(), dump_final_callee_vcg(), edge_badness(), eliminate_local_variables_1(), execute_fixup_cfg(), cgraph_node::expand(), expand_builtin_fork_or_exec(), expand_debug_expr(), expand_expr_real_1(), expand_omp_target(), expand_omp_taskreg(), expand_one_var(), expand_thunk(), expand_used_vars(), varpool_node::externally_visible_p(), varpool_node::finalize_decl(), cgraph_node::finalize_function(), varpool_node::finalize_named_section_flags(), find_assumption_locals_r(), find_func_aliases_for_builtin_call(), fixed_address_object_p(), symtab_node::fixup_same_cpp_alias_visibility(), function_and_variable_visibility(), symtab_node::get(), cgraph_node::get_availability(), varpool_node::get_availability(), get_block_for_decl(), get_constraint_for_ssa_var(), varpool_node::get_create(), get_emutls_init_templ_addr(), symtab_node::get_partitioning_class(), get_ref_base_and_extent(), get_symbol_initial_value(), gimple_duplicate_bb(), gimple_init_gcov_profiler(), gimplify_bind_expr(), gimplify_decl_expr(), gimplify_function_tree(), gimplify_var_or_parm_decl(), handle_alias_pairs(), handle_lhs_call(), handle_missing_profiles(), hash_tree(), init_eh(), init_ic_make_global_vars(), inline_account_function_p(), input_overwrite_node(), input_varpool_node(), instrument_derefs(), ipa_devirt(), ipa_lower_emutls(), ipa_pta_execute(), ipa_tm_create_version(), ipa_tm_create_version_alias(), is_global_var(), layout_decl(), lhd_set_decl_assembler_name(), loc_list_from_tree_1(), local_tree_p(), lto_output_varpool_node(), symtab_node::make_decl_local(), make_decl_rtl(), make_dispatcher_decl(), make_heapvar(), cgraph_node::make_local(), mark_address(), mark_addressable(), mark_decl_referenced(), mark_functions_to_output(), mark_load(), mark_store(), may_be_aliased(), maybe_record_node(), maybe_remove_writeonly_store(), ipa_icf::sem_function::merge(), ipa_icf::sem_variable::merge(), need_assembler_name_p(), symtab_node::needed_p(), new_emutls_decl(), non_local_p(), symtab_node::noninterposable_alias(), symtab_node::nonzero_address(), notice_global_symbol(), oacc_privatization_candidate_p(), offline_size(), omp_discover_declare_target_tgt_fn_r(), optimize_omp_library_calls(), optimize_weakref(), symtab_node::output_to_lto_symbol_table_p(), pack_ts_decl_common_value_fields(), perform_estimation_of_a_value(), cgraph_edge::possibly_call_in_translation_unit_p(), symtab_node::prevailing_p(), print_decl_identifier(), print_declaration(), print_node(), process_function_and_variable_attributes(), process_references(), produce_memory_decl_rtl(), produce_symtab(), produce_symtab_extension(), ptrs_compare_unequal(), record_vars_into(), refered_from_nonlocal_fn(), refered_from_nonlocal_var(), reference_to_unused(), referenced_from_vtable_p(), remap_decls(), cgraph_node::remove(), symbol_table::remove_unreachable_nodes(), symbol_table::remove_unreferenced_decls(), rest_of_decl_compilation(), rtl_for_decl_location(), save_inline_function_body(), secname_for_decl(), set_decl_origin_self(), set_mem_attributes_minus_bitpos(), set_new_clone_decl_and_node_flags(), set_stack_check_libfunc(), set_uids_in_ptset(), simd_clone_create(), simple_operand_p(), staticp(), streamer_write_chain(), streamer_write_chain(), tree_could_trap_p(), tree_profiling(), try_speculative_devirtualization(), ubsan_create_data(), ubsan_expand_vptr_ifn(), ubsan_type_descriptor(), unpack_ts_decl_common_value_fields(), update_visibility_by_resolution_info(), symtab_node::used_from_object_file_p(), verify_expr_location_1(), cgraph_node::verify_node(), symtab_node::verify_symtab_nodes(), walk_polymorphic_call_targets(), weak_finish(), cgraph_node::will_be_removed_from_program_if_no_direct_calls_p(), wrapup_global_declaration_2(), and write_symbol().

◆ DECL_FCONTEXT

#define DECL_FCONTEXT ( NODE ) (FIELD_DECL_CHECK (NODE)->field_decl.fcontext)

For FIELD_DECLS, DECL_FCONTEXT is the *first* baseclass in
which this FIELD_DECL is defined.  This information is needed when
writing debugging information about vfield and vbase decls for C++.

Referenced by DFS::DFS_write_tree_body().

◆ DECL_FIELD_ABI_IGNORED

#define DECL_FIELD_ABI_IGNORED ( NODE ) (!DECL_BIT_FIELD (NODE) && (NODE)->decl_common.decl_flag_0)

In a FIELD_DECL, indicates this field should be ignored for ABI decisions
like passing/returning containing struct by value.
Set for C++17 empty base artificial FIELD_DECLs as well as
empty [[no_unique_address]] non-static data members.

Referenced by cxx17_empty_base_field_p(), hash_tree(), and pack_ts_decl_common_value_fields().

◆ DECL_FIELD_BIT_OFFSET

#define DECL_FIELD_BIT_OFFSET ( NODE ) (FIELD_DECL_CHECK (NODE)->field_decl.bit_offset)

In a FIELD_DECL, this is the offset, in bits, of the first bit of the
field from DECL_FIELD_OFFSET.  This field may be nonzero even for fields
that are not bit fields (since DECL_OFFSET_ALIGN may be larger than the
natural alignment of the field's type).

Referenced by adjust_offset_for_component_ref(), analyze_ref(), ao_ref_init_from_vn_reference(), bit_position(), bitpos_of_field(), byte_position(), clear_padding_type(), ao_compare::compare_ao_refs(), compute_object_offset(), copy_reference_ops_from_ref(), DFS::DFS_write_tree_body(), dr_analyze_indices(), eliminate_dom_walker::eliminate_stmt(), field_byte_offset(), finish_bitfield_representative(), fold_const_aggregate_ref_1(), fold_nonarray_ctor_reference(), get_addr_base_and_unit_offset_1(), get_bit_range(), get_bitfield_rep(), get_inner_reference(), get_mem_align_offset(), get_ref_base_and_extent(), get_vec_alignment_for_record_type(), gimple_compare_field_offset(), go_format_type(), ao_compare::hash_ao_ref(), operand_compare::hash_operand(), hash_tree(), init_eh(), instrument_expr(), int_bit_position(), lto_input_ts_field_decl_tree_pointers(), native_encode_initializer(), native_interpret_aggregate(), nonoverlapping_component_refs_p_1(), operand_compare::operand_equal_p(), place_field(), place_union_field(), print_node(), ref_at_iteration(), start_bitfield_representative(), strip_offset_1(), strip_zero_offset_components(), verify_type_variant(), widen_memory_access(), and write_ts_field_decl_tree_pointers().

◆ DECL_FIELD_CONTEXT

#define DECL_FIELD_CONTEXT ( NODE ) (FIELD_DECL_CHECK (NODE)->decl_minimal.context)

Referenced by finish_builtin_struct(), get_mem_align_offset(), init_eh(), layout_decl(), ncr_type_uid(), and nonoverlapping_component_refs_p().

◆ DECL_FIELD_CXX_ZERO_WIDTH_BIT_FIELD

#define DECL_FIELD_CXX_ZERO_WIDTH_BIT_FIELD ( NODE ) (DECL_BIT_FIELD (NODE) && (NODE)->decl_common.decl_flag_0)

In a FIELD_DECL, indicates C++ zero-width bitfield that used to be
removed from the IL since PR42217 until PR101539 and by that changed
the ABI on several targets.  This flag is provided so that the backends
can decide on the ABI with zero-width bitfields and emit -Wpsabi
warnings.

Referenced by hash_tree(), and pack_ts_decl_common_value_fields().

◆ DECL_FIELD_OFFSET

#define DECL_FIELD_OFFSET ( NODE ) (FIELD_DECL_CHECK (NODE)->field_decl.offset)

In a FIELD_DECL, this is the field position, counting in bytes, of the
DECL_OFFSET_ALIGN-bit-sized word containing the bit closest to the beginning
of the structure.

Referenced by access_and_field_type_match_p(), ao_ref_init_from_vn_reference(), bit_position(), bitpos_of_field(), byte_position(), ao_compare::compare_ao_refs(), component_ref_field_offset(), dequeue_and_dump(), DFS::DFS_write_tree_body(), field_byte_offset(), finish_bitfield_layout(), finish_bitfield_representative(), fixup_child_record_type(), fold_const_aggregate_ref_1(), fold_nonarray_ctor_reference(), get_bit_range(), get_bitfield_rep(), get_vec_alignment_for_record_type(), gimple_compare_field_offset(), gimplify_type_sizes(), go_format_type(), ao_compare::hash_ao_ref(), operand_compare::hash_operand(), hash_tree(), init_eh(), instrument_expr(), int_bit_position(), lto_input_ts_field_decl_tree_pointers(), native_interpret_aggregate(), nonoverlapping_component_refs_p_1(), omp_firstprivatize_type_sizes(), operand_compare::operand_equal_p(), place_field(), place_union_field(), print_node(), remap_decl(), remap_type_2(), start_bitfield_representative(), store_constructor(), strip_zero_offset_components(), task_copyfn_remap_type(), type_contains_placeholder_1(), type_internals_preclude_sra_p_1(), type_like_member_ptr_p(), variably_modified_type_p(), verify_type_variant(), walk_tree_1(), and write_ts_field_decl_tree_pointers().

◆ DECL_FILE_SCOPE_P

#define DECL_FILE_SCOPE_P ( EXP ) SCOPE_FILE_SCOPE_P (DECL_CONTEXT (EXP))

Nonzero for a decl which is at file scope.

Referenced by hash_tree(), lhd_set_decl_assembler_name(), and omp_default_clause().

◆ DECL_FINAL_P

#define DECL_FINAL_P ( NODE ) (FUNCTION_DECL_CHECK (NODE)->decl_with_vis.final)

In FUNCTION_DECL that represent an virtual method this is set when
the method is final.

Referenced by ipa_icf::sem_item::compare_referenced_symbol_properties(), hash_tree(), pack_ts_decl_with_vis_value_fields(), possible_polymorphic_call_targets(), and unpack_ts_decl_with_vis_value_fields().

◆ DECL_FINI_PRIORITY

#define DECL_FINI_PRIORITY ( NODE ) (decl_fini_priority_lookup (NODE))

For a FUNCTION_DECL the finalization priority of NODE.

Referenced by build_cdtor(), build_cxa_dtor_registrations(), compare_cdtor_tu_order(), and compare_dtor().

◆ DECL_FROM_INLINE

#define DECL_FROM_INLINE ( NODE )

Value:

(DECL_ABSTRACT_ORIGIN (NODE) != NULL_TREE \

&& DECL_ABSTRACT_ORIGIN (NODE) != (NODE))

DECL_ABSTRACT_ORIGIN

#define DECL_ABSTRACT_ORIGIN(NODE)

Definition tree.h:2746

NULL_TREE

#define NULL_TREE

Definition tree.h:317

Nonzero for any sort of ..._DECL node means this decl node represents an
inline instance of some original (abstract) decl from an inline function;
suppress any warnings about shadowing some other variable.  FUNCTION_DECL
nodes can also have their abstract origin set to themselves.

Referenced by decl_ultimate_origin(), autofdo::function_instance::get_function_instance_by_decl(), and autofdo::string_table::get_index_by_decl().

◆ DECL_FUNCTION_PERSONALITY

#define DECL_FUNCTION_PERSONALITY ( NODE ) (FUNCTION_DECL_CHECK (NODE)->function_decl.personality)

Referenced by cgraph_node::add_new_function(), can_inline_edge_by_limits_p(), can_inline_edge_p(), DFS::DFS_write_tree_body(), ipa_icf::sem_function::equals_wpa(), expand_call_inline(), get_personality_function(), hash_tree(), inline_call(), lto_input_ts_function_decl_tree_pointers(), record_eh_tables(), tree_function_versioning(), and write_ts_function_decl_tree_pointers().

◆ DECL_FUNCTION_SPECIFIC_OPTIMIZATION

#define DECL_FUNCTION_SPECIFIC_OPTIMIZATION ( NODE ) (FUNCTION_DECL_CHECK (NODE)->function_decl.function_specific_optimization)

In FUNCTION_DECL, the function specific optimization options to use when
compiling this function.

Referenced by build_cdtor(), build_cxa_dtor_registrations(), can_inline_edge_by_limits_p(), cgraph_build_static_cdtor_1(), create_assumption_fn(), create_loop_fn(), create_omp_child_function(), decl_attributes(), DFS::DFS_write_tree_body(), expand_omp_target(), ipa_icf::sem_function::get_hash(), hash_tree(), inline_call(), invoke_set_current_function_hook(), ipa_func_spec_opts_forbid_analysis_p(), lto_input_ts_function_decl_tree_pointers(), opts_for_fn(), print_node(), and write_ts_function_decl_tree_pointers().

◆ DECL_FUNCTION_SPECIFIC_TARGET

#define DECL_FUNCTION_SPECIFIC_TARGET ( NODE ) (FUNCTION_DECL_CHECK (NODE)->function_decl.function_specific_target)

In FUNCTION_DECL, the function specific target options to use when compiling
this function.

Referenced by build_cdtor(), build_cxa_dtor_registrations(), cgraph_build_static_cdtor_1(), create_assumption_fn(), create_loop_fn(), create_omp_child_function(), decl_attributes(), default_target_can_inline_p(), DFS::DFS_write_tree_body(), expand_omp_target(), ipa_icf::sem_function::get_hash(), hash_tree(), lto_input_ts_function_decl_tree_pointers(), print_node(), target_opts_for_fn(), and write_ts_function_decl_tree_pointers().

◆ DECL_FUNCTION_VERSIONED

#define DECL_FUNCTION_VERSIONED ( NODE ) (FUNCTION_DECL_CHECK (NODE)->function_decl.versioned_function)

In FUNCTION_DECL, this is set if this function has other versions generated
to support different architecture feature sets, e.g. using "target" or
"target_version" attributes.

Referenced by common_function_versions(), coverage_begin_function(), create_omp_child_function(), expand_omp_target(), expand_target_clones(), and is_function_default_version().

◆ DECL_HARD_REGISTER

#define DECL_HARD_REGISTER ( NODE ) (VAR_DECL_CHECK (NODE)->decl_with_vis.hard_register)

In a VAR_DECL, nonzero if the decl is a register variable with
an explicit asm specification.

Referenced by add_clobbers_to_eh_landing_pad(), varpool_node::assemble_decl(), compare_base_decls(), ipa_icf_gimple::func_checker::compare_variable_decl(), copy_reference_ops_from_ref(), create_variable_info_for(), decl_overlaps_hard_reg_set_p(), eliminate_dom_walker::eliminate_stmt(), expand_assignment(), expand_debug_expr(), expand_one_var(), varpool_node::externally_visible_p(), find_replaceable_in_bb(), symtab_node::get_partitioning_class(), gimple_expand_vec_set_extract_expr(), gimplify_bind_expr(), hash_tree(), symbol_table::insert_to_assembler_name_hash(), instrument_bool_enum_load(), instrument_derefs(), instrument_expr(), is_gimple_asm_val(), is_gimple_reg(), is_var_need_auto_init(), make_decl_rtl(), may_be_nonaddressable_p(), maybe_warn_operand(), new_var_info(), notice_global_symbol(), output_in_order(), symtab_node::output_to_lto_symbol_table_p(), symbol_table::output_variables(), pack_ts_decl_with_vis_value_fields(), ipa_icf::sem_variable::parse(), print_declaration(), process_alt_operands(), remove_unused_locals(), rtl_for_decl_location(), ssa_defined_default_def_p(), ssa_is_replaceable_p(), statement_sink_location(), unpack_ts_decl_with_vis_value_fields(), symtab_node::unregister(), and symtab_node::verify_base().

◆ DECL_HAS_DEBUG_ARGS_P

#define DECL_HAS_DEBUG_ARGS_P ( NODE ) (FUNCTION_DECL_CHECK (NODE)->function_decl.has_debug_args_flag)

Nonzero if a FUNCTION_DECL has DEBUG arguments attached to it.

Referenced by decl_debug_args_insert(), decl_debug_args_lookup(), expand_call_stmt(), prepare_call_arguments(), and tree_function_versioning().

◆ DECL_HAS_DEBUG_EXPR_P

#define DECL_HAS_DEBUG_EXPR_P ( NODE ) (VAR_DECL_CHECK (NODE)->decl_common.debug_expr_is_from)

For VAR_DECL, this is set to an expression that it was split from.

Referenced by add_local_variables(), add_var_loc_to_decl(), copy_node(), create_access_replacement(), create_one_component_var(), default_tree_printer(), DFS::DFS_write_tree_body(), gimplify_modify_expr(), hash_tree(), lto_input_ts_decl_common_tree_pointers(), pack_ts_decl_common_value_fields(), track_expr_p(), unpack_ts_decl_common_value_fields(), var_debug_decl(), verify_expr_location_1(), and write_ts_decl_common_tree_pointers().

◆ DECL_HAS_INIT_PRIORITY_P

#define DECL_HAS_INIT_PRIORITY_P ( NODE ) (VAR_DECL_CHECK (NODE)->decl_with_vis.init_priority_p)

In a non-local VAR_DECL with static storage duration, true if the
variable has an initialization priority.  If false, the variable
will be initialized at the DEFAULT_INIT_PRIORITY.

Referenced by copy_node().

◆ DECL_HAS_VALUE_EXPR_P

#define DECL_HAS_VALUE_EXPR_P ( NODE )

Value:

(TREE_CHECK3 (NODE, VAR_DECL, PARM_DECL, RESULT_DECL) \

->decl_common.decl_flag_2)

In a VAR_DECL or PARM_DECL, the location at which the value may be found,
if transformations have made this more complicated than evaluating the
decl itself.

Referenced by add_clobbers_to_eh_landing_pad(), add_decls_addresses_to_decl_constructor(), address_compare(), varpool_node::assemble_decl(), assign_parms(), varpool_node::can_remove_if_no_refs_p(), computable_teams_clause(), copy_node(), create_emultls_var(), create_task_copyfn(), DFS::DFS_write_tree_body(), expand_function_start(), expand_omp_regimplify_p(), expand_one_var(), varpool_node::finalize_named_section_flags(), find_simtpriv_var_op(), finish_taskreg_remap(), fixup_remapped_decl(), fixup_vla_decls(), fortran_common(), get_local_debug_decl(), get_nonlocal_debug_decl(), gimple_add_padding_init_for_auto_var(), gimple_duplicate_bb(), gimplify_adjust_omp_clauses(), gimplify_bind_expr(), gimplify_body(), gimplify_decl_expr(), gimplify_parameters(), gimplify_scan_omp_clauses(), gimplify_var_or_parm_decl(), gimplify_vla_decl(), hash_tree(), instantiate_decls(), instantiate_decls_1(), instantiate_expr(), loc_list_from_tree_1(), lookup_field_for_decl(), lower_lastprivate_clauses(), lower_omp_for_scan(), lower_omp_regimplify_p(), lower_omp_scan(), lower_omp_target(), lower_omp_task_reductions(), lower_private_allocate(), lower_rec_input_clauses(), lower_rec_simd_input_clauses(), lower_reduction_clauses(), lower_send_shared_vars(), lto_input_ts_decl_common_tree_pointers(), omp_finish_file(), omp_member_access_dummy_var(), omp_notice_variable(), ompdevlow_adjust_simt_enter(), output_in_order(), symbol_table::output_variables(), pack_ts_decl_common_value_fields(), print_declaration(), print_node(), record_reference(), remap_decls(), remap_vla_decls(), remove_dead_stmt(), remove_unused_scope_block_p(), replace_block_vars_by_duplicates(), rest_of_decl_compilation(), scan_sharing_clauses(), target_for_debug_bind(), unpack_ts_decl_common_value_fields(), use_pointer_for_field(), verify_expr_location_1(), vt_add_function_parameters(), wrapup_global_declaration_2(), and write_ts_decl_common_tree_pointers().

◆ DECL_HIDDEN_STRING_LENGTH

#define DECL_HIDDEN_STRING_LENGTH ( NODE ) (TREE_CHECK (NODE, PARM_DECL)->decl_common.decl_nonshareable_flag)

In a PARM_DECL, set for Fortran hidden string length arguments that some
buggy callers don't pass to the callee.

Referenced by expand_call(), pack_ts_decl_common_value_fields(), and unpack_ts_decl_common_value_fields().

◆ DECL_IGNORED_P

#define DECL_IGNORED_P ( NODE ) (DECL_COMMON_CHECK (NODE)->decl_common.ignored_flag)

Nonzero for a given ..._DECL node means that the name of this node should
be ignored for symbolic debug purposes.  For a TYPE_DECL, this means that
the associated type should be ignored.  For a FUNCTION_DECL, the body of
the function should also be ignored.

Referenced by add_var_loc_to_decl(), asan_add_global(), asan_emit_stack_protection(), asan_finish_file(), asan_global_struct(), assemble_start_function(), build_constant_desc(), tree_switch_conversion::switch_conversion::build_one_array(), cfg_layout_merge_blocks(), cgraph_build_static_cdtor_1(), rt_bb_visited::check(), ipa_param_body_adjustments::common_initialization(), copy_decl_for_dup_finish(), copy_var_decl(), create_access_replacement(), create_artificial_label(), create_asan_shadow_var(), create_assumption_fn(), function_reader::create_function(), create_loop_fn(), create_odr_indicator(), create_omp_child_function(), create_one_component_var(), create_tmp_var_raw(), create_vop_var(), default_external_stack_protect_fail(), default_hidden_stack_protect_fail(), default_stack_protect_guard(), defer_stack_allocation(), dump_decl_name(), duplicate_thunk_for_node(), dw2_output_indirect_constant_1(), dwarf2_debug_info_emitted_p(), dwarf2out_begin_prologue(), expand_call_inline(), expand_expr_real_1(), expand_omp_target(), expand_thunk(), expand_used_vars(), final_end_function(), final_scan_insn_1(), final_start_function_1(), fixup_reorder_chain(), get_chain_decl(), get_debug_decl(), get_emutls_init_templ_addr(), get_local_debug_decl(), get_spill_slot_decl(), gimple_can_coalesce_p(), gimple_duplicate_bb(), gimplify_bind_expr(), gimplify_body(), gimplify_function_tree(), gimplify_modify_expr(), gimplify_parameters(), gimplify_type_sizes(), gimplify_vla_decl(), hash_tree(), in_initial_view_p(), leader_merge(), loc_list_from_tree_1(), lookup_field_for_decl(), lower_omp_critical(), lower_rec_input_clauses(), maybe_wrap_with_location(), member_declared_type(), new_emutls_decl(), omp_member_access_dummy_var(), omp_resolve_declare_variant(), pack_ts_decl_common_value_fields(), populate_coalesce_list_for_outofssa(), print_node(), process_scope_var(), remap_decls(), remap_ssa_name(), remove_dead_stmt(), remove_unused_scope_block_p(), ipa_param_body_adjustments::reset_debug_stmts(), rest_of_handle_final(), rtl_merge_blocks(), self_referential_size(), set_component_ssa_name(), skip_in_fields_list_p(), split_complex_args(), target_for_debug_bind(), track_expr_p(), ubsan_create_data(), ubsan_expand_vptr_ifn(), ubsan_get_source_location_type(), ubsan_get_type_descriptor_type(), ubsan_type_descriptor(), unpack_ts_decl_common_value_fields(), use_register_for_decl(), and vt_add_function_parameters().

◆ DECL_IN_CONSTANT_POOL

#define DECL_IN_CONSTANT_POOL ( NODE ) (VAR_DECL_CHECK (NODE)->decl_with_vis.in_constant_pool)

In a VAR_DECL that's static,
nonzero if it belongs to the global constant pool.

Referenced by symtab_node::address_can_be_compared_p(), varpool_node::assemble_decl(), build_constant_desc(), symtab_node::can_increase_alignment_p(), constant_decl_p(), ctor_for_folding(), varpool_node::ctor_useable_for_folding_p(), expand_debug_expr(), varpool_node::get_availability(), symtab_node::get_partitioning_class(), get_symbol_initial_value(), gimplify_adjust_omp_clauses_1(), hash_tree(), ipa_print_constant_value(), make_decl_rtl(), ipa_icf::sem_variable::merge(), omp_default_clause(), output_constant_def_contents(), pack_ts_decl_with_vis_value_fields(), place_block_symbol(), print_node(), varpool_node::remove_initializer(), unpack_ts_decl_with_vis_value_fields(), and values_equal_for_ipcp_p().

◆ DECL_IN_SYSTEM_HEADER

#define DECL_IN_SYSTEM_HEADER ( NODE ) (in_system_header_at (DECL_SOURCE_LOCATION (NODE)))

Nonzero for a given ..._DECL node means that no warnings should be
generated just because this node is unused.

Referenced by check_global_declaration(), expand_call_inline(), lhd_warn_unused_global_decl(), print_node(), should_emit_struct_debug(), and tree_inlinable_function_p().

◆ DECL_IN_TEXT_SECTION

#define DECL_IN_TEXT_SECTION ( NODE ) (VAR_DECL_CHECK (NODE)->decl_with_vis.in_text_section)

In a VAR_DECL that's static,
nonzero if the space is in the text section.

Referenced by assemble_variable(), ipa_icf::sem_variable::equals_wpa(), and print_node().

◆ DECL_INCOMING_RTL

#define DECL_INCOMING_RTL ( NODE ) (PARM_DECL_CHECK (NODE)->parm_decl.incoming_rtl)

For PARM_DECL, holds an RTL for the stack slot or register
where the data was actually passed.

Referenced by add_stores(), add_var_loc_to_decl(), assign_parms(), assign_parms_unsplit_complex(), expand_call(), expand_debug_parm_decl(), expand_debug_source_expr(), initialize_argument_information(), instantiate_decls(), instantiate_expr(), function_reader::parse_param(), print_node(), print_param(), rtl_for_decl_location(), set_decl_incoming_rtl(), setup_incoming_promotions(), unshare_all_rtl(), and vt_add_function_parameter().

◆ DECL_INIT_PRIORITY

#define DECL_INIT_PRIORITY ( NODE ) (decl_init_priority_lookup (NODE))

For a VAR_DECL or FUNCTION_DECL the initialization priority of
NODE.

Referenced by build_cdtor(), compare_cdtor_tu_order(), compare_ctor(), and copy_node().

◆ DECL_INITIAL

#define DECL_INITIAL ( NODE ) (DECL_COMMON_CHECK (NODE)->decl_common.initial)

For a FUNCTION_DECL, holds the tree of BINDINGs.
For a TRANSLATION_UNIT_DECL, holds the namespace's BLOCK.
For a VAR_DECL, holds the initial value.
For a PARM_DECL, used for DECL_ARG_TYPE--default
values for parameters are encoded in the type of the function,
not in the PARM_DECL slot.
For a FIELD_DECL, this is used for enumeration values and the C
frontend uses it for temporarily storing bitwidth of bitfields.

??? Need to figure out some way to check this isn't a PARM_DECL.

Referenced by align_variable(), varpool_node::analyze(), asan_add_global(), asan_emit_stack_protection(), asan_finish_file(), assemble_variable(), assemble_variable_contents(), bss_initializer_p(), build_constant_desc(), build_gcov_info_var_registration(), tree_switch_conversion::switch_conversion::build_one_array(), categorize_decl_for_section(), cgraph_build_static_cdtor_1(), rt_bb_visited::check(), check_global_declaration(), component_ref_size(), compute_reloc_for_var(), coverage_obj_finish(), coverage_obj_fn(), create_assumption_fn(), create_dispatcher_calls(), function_reader::create_function(), create_loop_fn(), create_odr_indicator(), create_omp_child_function(), cgraph_node::create_virtual_clone(), cgraph_node::create_wrapper(), ctor_for_folding(), varpool_node::ctor_useable_for_folding_p(), decl_binds_to_current_def_p(), default_binds_local_p_3(), default_elf_select_section(), dequeue_and_dump(), varpool_node::dump(), dump_scope_blocks(), dump_variable(), duplicate_thunk_for_node(), dw2_output_indirect_constant_1(), emit_push_insn(), emutls_common_1(), ipa_icf::sem_variable::equals(), execute_lower_omp(), cgraph_node::expand(), expand_call_inline(), expand_expr_addr_expr_1(), expand_expr_real_1(), expand_omp_for_generic(), expand_omp_target(), expand_omp_taskreg(), expand_thunk(), expand_used_vars(), final_start_function_1(), finalize_nesting_tree_1(), symbol_table::first_static_initializer(), fold(), fold_indirect_ref_1(), function_and_variable_visibility(), gen_subprogram_die(), generate_setjmp_warnings(), generic_parameter_die(), get_callee_fndecl(), varpool_node::get_constructor(), get_emutls_init_templ_addr(), get_object_alignment_2(), get_symbol_initial_value(), get_variable_align(), get_variable_section(), gimple_init_gcov_profiler(), gimplify_compound_literal_expr(), gimplify_decl_expr(), gimplify_expr(), gimplify_function_tree(), gimplify_init_constructor(), gimplify_modify_expr_rhs(), go_output_typedef(), ipa_icf::sem_variable::init(), init_ic_make_global_vars(), init_lowered_empty_function(), input_constructor(), input_function(), instantiate_decls(), ipa_find_agg_cst_from_init(), ipa_merge_profiles(), ipa_odr_summary_write(), ipa_print_constant_value(), lhd_omp_get_decl_init(), lhd_simulate_enum_decl(), load_register_parameters(), lower_function_body(), lower_gimple_bind(), lower_omp_target(), lto_input_ts_block_tree_pointers(), lto_output(), lto_read_tree_1(), make_decl_one_only(), make_decl_rtl(), make_dispatcher_decl(), mark_all_vars_used_1(), mark_constants_in_pattern(), ipa_icf::sem_variable::merge(), move_sese_region_to_fn(), new_emutls_decl(), symbol_table::next_static_initializer(), symtab_node::noninterposable_alias(), notice_global_symbol(), number_blocks(), omp_finish_file(), omp_resolve_declare_variant(), optimize_compound_literals_in_ctor(), optimize_omp_library_calls(), output_addressed_constants(), output_constant_def_contents(), output_constructor(), output_function(), output_object_block(), place_block_symbol(), prepare_call_arguments(), print_declaration(), print_node(), process_function_and_variable_attributes(), process_symver_attribute(), record_references_in_initializer(), reemit_insn_block_notes(), cgraph_node::release_body(), varpool_node::remove(), varpool_node::remove_initializer(), symbol_table::remove_unreachable_nodes(), remove_unused_locals(), reorder_blocks(), ipa_param_body_adjustments::reset_debug_stmts(), rest_of_decl_compilation(), rest_of_handle_final(), rtl_for_decl_location(), safe_from_p(), self_referential_size(), set_writeonly_bit(), split_function(), tree_add_const_value_attribute_for_decl(), tree_function_versioning(), ubsan_create_data(), ubsan_type_descriptor(), unshare_all_rtl_again(), use_blocks_for_decl_p(), values_equal_for_ipcp_p(), verify_gimple_in_cfg(), and walk_tree_1().

◆ DECL_IS_MALLOC

#define DECL_IS_MALLOC ( NODE ) (FUNCTION_DECL_CHECK (NODE)->function_decl.malloc_flag)

Nonzero in a FUNCTION_DECL means this function should be treated
as if it were a malloc, meaning it returns a pointer that is
not an alias.

Referenced by ipa_param_adjustments::adjust_decl(), analyze_function(), cgraph_node::dump(), expr_expected_value_1(), flags_from_decl_or_type(), has_attribute(), hash_tree(), malloc_candidate_p_1(), pack_ts_function_decl_value_fields(), propagate_malloc(), set_call_expr_flags(), set_malloc_flag_1(), tree_function_versioning(), unpack_ts_function_decl_value_fields(), and cgraph_node::verify_node().

◆ DECL_IS_NOVOPS

#define DECL_IS_NOVOPS ( NODE ) (FUNCTION_DECL_CHECK (NODE)->function_decl.novops_flag)

Nonzero in a FUNCTION_DECL means this function should be treated
as "novops" function (function that does not read global memory,
but may have arbitrary side effects).

Referenced by flags_from_decl_or_type(), hash_tree(), pack_ts_function_decl_value_fields(), set_call_expr_flags(), tree_ssa_prefetch_arrays(), and unpack_ts_function_decl_value_fields().

◆ DECL_IS_OPERATOR_DELETE_P

#define DECL_IS_OPERATOR_DELETE_P ( NODE ) (FUNCTION_DECL_DECL_TYPE (FUNCTION_DECL_CHECK (NODE)) == OPERATOR_DELETE)

Nonzero in a FUNCTION_DECL means this function should be treated as
C++ operator delete.

Referenced by cgraph_node::dump(), find_func_aliases_for_call(), fndecl_dealloc_argno(), gimple_build_call_from_tree(), gimple_call_fnspec(), gimple_call_operator_delete_p(), mark_all_reaching_defs_necessary_1(), matching_alloc_calls_p(), pack_ts_function_decl_value_fields(), propagate_necessity(), and warn_dealloc_offset().

◆ DECL_IS_OPERATOR_NEW_P

#define DECL_IS_OPERATOR_NEW_P ( NODE ) (FUNCTION_DECL_DECL_TYPE (FUNCTION_DECL_CHECK (NODE)) == OPERATOR_NEW)

Nonzero in a FUNCTION_DECL means this function should be treated as
C++ operator new, meaning that it returns a pointer for which we
should not use type based aliasing.

Referenced by ipa_icf::sem_item::compare_referenced_symbol_properties(), cgraph_node::dump(), expand_call_inline(), expr_expected_value_1(), fndecl_alloc_p(), gimple_build_call_from_tree(), gimple_call_nonnull_result_p(), gimple_call_return_array(), ipa_icf::sem_item::hash_referenced_symbol_properties(), matching_alloc_calls_p(), tree_expr_nonzero_warnv_p(), and warn_dealloc_offset().

◆ DECL_IS_REPLACEABLE_OPERATOR

#define DECL_IS_REPLACEABLE_OPERATOR ( NODE ) (FUNCTION_DECL_CHECK (NODE)->function_decl.replaceable_operator)

Nonzero in a FUNCTION_DECL means this function is a replaceable
function (like replaceable operators new or delete).

Referenced by ipa_icf::sem_item::compare_referenced_symbol_properties(), cgraph_node::create_version_clone_with_body(), cgraph_node::dump(), fndecl_dealloc_argno(), gimple_call_fnspec(), pack_ts_function_decl_value_fields(), set_new_clone_decl_and_node_flags(), unpack_ts_function_decl_value_fields(), and warn_dealloc_offset().

◆ DECL_IS_REPLACEABLE_OPERATOR_NEW_P

#define DECL_IS_REPLACEABLE_OPERATOR_NEW_P ( NODE ) (DECL_IS_OPERATOR_NEW_P (NODE) && DECL_IS_REPLACEABLE_OPERATOR (NODE))

Referenced by eliminate_unnecessary_stmts(), gimple_call_fnspec(), gimple_call_return_array(), mark_all_reaching_defs_necessary_1(), mark_stmt_if_obviously_necessary(), and propagate_necessity().

◆ DECL_IS_RETURNS_TWICE

#define DECL_IS_RETURNS_TWICE ( NODE ) (FUNCTION_DECL_CHECK (NODE)->function_decl.returns_twice_flag)

Nonzero in a FUNCTION_DECL means this function may return more
than once.

Referenced by flags_from_decl_or_type(), hash_tree(), pack_ts_function_decl_value_fields(), set_call_expr_flags(), setjmp_call_p(), and unpack_ts_function_decl_value_fields().

◆ DECL_IS_UNDECLARED_BUILTIN

#define DECL_IS_UNDECLARED_BUILTIN ( DECL ) (DECL_SOURCE_LOCATION (DECL) <= BUILTINS_LOCATION)

This decl was created by a front-end or back-end rather than by
user code, and has not been explicitly declared by the user -- when
that happens the source location is updated to the user's
source.  This includes decls with no location (!).

Referenced by base_type_die(), dump_generic_node(), go_decl(), go_format_type(), go_type_decl(), and print_decl_identifier().

◆ DECL_LAMBDA_FUNCTION_P

#define DECL_LAMBDA_FUNCTION_P ( NODE ) (FUNCTION_DECL_DECL_TYPE (FUNCTION_DECL_CHECK (NODE)) == LAMBDA_FUNCTION)

In FUNCTION_DECL, this is set if this function is a lambda function.

Referenced by coverage_begin_function().

◆ DECL_LANG_FLAG_0

#define DECL_LANG_FLAG_0 ( NODE ) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_0)

Additional flags for language-specific uses.

Referenced by print_node().

◆ DECL_LANG_FLAG_1

#define DECL_LANG_FLAG_1 ( NODE ) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_1)

Referenced by print_node().

◆ DECL_LANG_FLAG_2

#define DECL_LANG_FLAG_2 ( NODE ) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_2)

Referenced by print_node().

◆ DECL_LANG_FLAG_3

#define DECL_LANG_FLAG_3 ( NODE ) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_3)

Referenced by print_node().

◆ DECL_LANG_FLAG_4

#define DECL_LANG_FLAG_4 ( NODE ) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_4)

Referenced by print_node().

◆ DECL_LANG_FLAG_5

#define DECL_LANG_FLAG_5 ( NODE ) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_5)

Referenced by print_node().

◆ DECL_LANG_FLAG_6

#define DECL_LANG_FLAG_6 ( NODE ) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_6)

Referenced by print_node().

◆ DECL_LANG_FLAG_7

#define DECL_LANG_FLAG_7 ( NODE ) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_7)

Referenced by print_node().

◆ DECL_LANG_FLAG_8

#define DECL_LANG_FLAG_8 ( NODE ) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_8)

Referenced by print_node().

◆ DECL_LANG_SPECIFIC

#define DECL_LANG_SPECIFIC ( NODE ) (DECL_COMMON_CHECK (NODE)->decl_common.lang_specific)

Language-specific decl information.

Referenced by ipa_param_adjustments::adjust_decl(), get_debug_decl(), ipa_tm_create_version_alias(), and ipa_param_body_adjustments::modify_formal_parameters().

◆ DECL_LOOPING_CONST_OR_PURE_P

#define DECL_LOOPING_CONST_OR_PURE_P ( NODE ) (FUNCTION_DECL_CHECK (NODE)->function_decl.looping_const_or_pure_flag)

Nonzero only if one of TREE_READONLY or DECL_PURE_P is nonzero AND
the const or pure function may not terminate.  When this is nonzero
for a const or pure function, it can be dealt with by cse passes
but cannot be removed by dce passes since you are not allowed to
change an infinite looping program into one that terminates without
error.

Referenced by cdtor_p(), flags_from_decl_or_type(), hash_tree(), ipa_make_function_const(), ipa_make_function_pure(), pack_ts_function_decl_value_fields(), set_call_expr_flags(), set_const_flag_1(), set_pure_flag_1(), unpack_ts_function_decl_value_fields(), and verify_gimple_call().

◆ DECL_MERGEABLE

#define DECL_MERGEABLE ( NODE ) (VAR_DECL_CHECK (NODE)->decl_common.decl_flag_3)

In a VAR_DECL, nonzero if this variable is not required to have a distinct
address from other variables with the same constant value.  In other words,
consider -fmerge-all-constants to be on for this VAR_DECL.

Referenced by symtab_node::address_can_be_compared_p(), categorize_decl_for_section(), and gimplify_init_constructor().

◆ DECL_MINIMAL_CHECK

#define DECL_MINIMAL_CHECK ( T ) CONTAINS_STRUCT_CHECK (T, TS_DECL_MINIMAL)

◆ DECL_MODE

#define DECL_MODE ( NODE ) (DECL_COMMON_CHECK (NODE)->decl_common.mode)

Holds the machine mode corresponding to the declaration of a variable or
field.  Always equal to TYPE_MODE (TREE_TYPE (decl)) except for a
FIELD_DECL.

Referenced by add_location_or_const_value_attribute(), add_stores(), assign_parm_find_stack_rtl(), assign_parms(), assign_parms_unsplit_complex(), avoid_type_punning_on_regs(), build_constant_desc(), compute_record_mode(), default_elf_select_section(), discover_nonconstant_array_refs_r(), dw_loc_list_1(), emit_note_insn_var_location(), expand_call(), expand_debug_source_expr(), expand_expr_real_1(), expand_function_start(), expand_gimple_basic_block(), expand_one_error_var(), expand_one_stack_var_at(), expand_one_var(), expand_value_return(), get_inner_reference(), gimple_can_coalesce_p(), hash_tree(), insert_debug_temp_for_var_def(), layout_decl(), loc_list_from_tree_1(), make_decl_rtl(), ipa_param_body_adjustments::mark_dead_statements(), ipa_param_adjustments::modify_call(), non_mem_decl_p(), pack_ts_decl_common_value_fields(), prepare_call_arguments(), prepare_decl_rtl(), print_node(), produce_memory_decl_rtl(), promote_decl_mode(), remap_ssa_name(), remove_unused_ivs(), ipa_param_body_adjustments::reset_debug_stmts(), rewrite_debug_stmt_uses(), rtl_for_decl_location(), set_reg_attrs_for_decl_rtl(), store_constructor(), store_field(), track_loc_p(), tracked_record_parameter_p(), tree_function_versioning(), and use_register_for_decl().

◆ DECL_NAME

#define DECL_NAME ( NODE ) (DECL_MINIMAL_CHECK (NODE)->decl_minimal.name)

This is the name of the object as written by the user.
It is an IDENTIFIER_NODE.

Referenced by add_desc_attribute(), add_discr_value(), announce_function(), asan_add_global(), asan_emit_stack_protection(), asan_memfn_rtl(), assemble_variable(), assumption_copy_decl(), base_type_die(), build_decl(), build_gcov_info_var_registration(), tree_switch_conversion::switch_conversion::build_one_array(), build_var(), called_as_built_in(), cgraph_externally_visible_p(), check_global_declaration(), combined_fn_name(), ipa_param_body_adjustments::common_initialization(), compute_function_frequency(), convert_gimple_call(), convert_nonlocal_reference_op(), copy_decl_to_var(), copy_result_decl_to_var(), coverage_obj_finish(), coverage_obj_init(), create_access_replacement(), create_field_for_decl(), create_function_info_for(), create_odr_indicator(), create_one_component_var(), cgraph_node::create_version_clone_with_body(), cgraph_node::create_virtual_clone(), default_tree_printer(), delete_vta_debug_insn(), dequeue_and_dump(), DFS::DFS_write_tree_body(), diagnose_tm_1(), dump_decl_name(), dump_function_name(), dump_generic_node(), dump_oacc_loop(), dump_var(), duplicate_thunk_for_node(), libfunc_decl_hasher::equal(), error_unavailable_use(), execute_split_functions(), expand_debug_expr(), expand_function_start(), expand_label(), expand_omp_target(), expand_stack_vars(), finalize_nesting_tree_1(), finalize_record_size(), find_param_by_name(), fixup_child_record_type(), gen_call_used_regs_seq(), generic_parameter_die(), get_chain_field(), get_debug_decl(), get_emutls_init_templ_addr(), get_frame_type(), get_name(), get_nl_goto_field(), ipa_param_body_adjustments::get_replacement_ssa_base(), gimple_add_init_for_auto_var(), gimple_decl_printable_name(), gimplify_adjust_omp_clauses(), gimplify_compound_literal_expr(), gimplify_decl_expr(), gimplify_init_constructor(), gimplify_modify_expr(), gimplify_modify_expr_rhs(), gimplify_scan_omp_clauses(), go_append_decl_name(), go_decl(), go_format_type(), go_output_fndecl(), go_output_typedef(), go_output_var(), go_type_decl(), handle_vtv_comdat_section(), libfunc_decl_hasher::hash(), hash_tree(), input_offload_tables(), install_var_field(), install_var_field(), ipa_propagate_frequency_1(), is_cxa_atexit(), is_cxa_pure_virtual_p(), is_ubsan_builtin_p(), lhd_decl_printable_name(), lhd_set_decl_assembler_name(), local_tree_p(), lookup_field_for_decl(), lower_oacc_reductions(), lower_omp_critical(), lower_omp_target(), lower_omp_task_reductions(), lto_input_ts_decl_minimal_tree_pointers(), make_decl_rtl(), make_fancy_decl_name(), malloc_candidate_p(), matching_alloc_calls_p(), maybe_special_function_p(), member_declared_type(), ipa_icf::sem_item_optimizer::merge_classes(), modified_type_die(), symtab_node::name(), need_assembler_name_p(), new_emutls_decl(), symtab_node::noninterposable_alias(), notice_global_symbol(), oacc_default_clause(), odr_types_equivalent_p(), omp_copy_decl_1(), omp_default_clause(), omp_is_private(), omp_notice_threadprivate_variable(), omp_notice_variable(), omp_resolve_declare_variant(), omp_runtime_api_call(), ompdevlow_adjust_simt_enter(), operand_compare::operand_equal_p(), optimize_omp_library_calls(), output_constructor(), output_constructor_bitfield(), function_reader::parse_mem_expr(), print_any_param_name(), print_decl_identifier(), print_insn(), print_node(), print_node_brief(), remap_ssa_name(), replace_by_duplicate_decl(), ipa_param_body_adjustments::reset_debug_stmts(), rtl_for_decl_location(), scan_omp_1_stmt(), setjmp_or_longjmp_p(), simd_clone_adjust_argument_types(), simd_clone_create(), simple_cst_equal(), skip_in_fields_list_p(), special_function_p(), strub_watermark_parm(), task_copyfn_remap_type(), tm_malloc_replacement(), gdbhooks.TreePrinter::to_string(), track_expr_p(), tree_conflicts_with_clobbers_p(), ubsan_type_descriptor(), update_alignment_for_field(), verify_bb_vtables(), walk_regimplify_phi(), warn_deprecated_use(), warn_types_mismatch(), warn_uninit(), and write_ts_decl_minimal_tree_pointers().

◆ DECL_NAMELESS

#define DECL_NAMELESS ( NODE ) (DECL_MINIMAL_CHECK (NODE)->base.u.bits.nameless_flag)

If nonzero, decl's name shouldn't be emitted into debug info.

Referenced by assign_parms_augmented_arg_list(), create_access_replacement(), create_assumption_fn(), create_omp_child_function(), create_tmp_var_raw(), dump_decl_name(), dump_generic_node(), dwarf2_name(), expand_omp_for_generic(), expand_omp_target(), instantiate_expr(), lower_omp_target(), lower_omp_taskreg(), member_declared_type(), oacc_do_neutering(), pack_ts_base_value_fields(), scan_omp_parallel(), scan_omp_target(), scan_omp_task(), scan_omp_teams(), unpack_ts_base_value_fields(), and vt_add_function_parameters().

◆ DECL_NO_INLINE_WARNING_P

#define DECL_NO_INLINE_WARNING_P ( NODE ) (FUNCTION_DECL_CHECK (NODE)->function_decl.no_inline_warning_flag)

Nonzero in a FUNCTION_DECL means this function should not get
-Winline warnings.

Referenced by expand_call_inline(), hash_tree(), ipa_icf::sem_function::merge(), pack_ts_function_decl_value_fields(), split_function(), tree_inlinable_function_p(), and unpack_ts_function_decl_value_fields().

◆ DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT

#define DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT ( NODE ) (FUNCTION_DECL_CHECK (NODE)->function_decl.no_instrument_function_entry_exit)

Used in FUNCTION_DECLs to indicate that function entry and exit should
be instrumented with calls to support routines.

Referenced by allocate_struct_function(), cgraph_build_static_cdtor_1(), ipa_icf::sem_function::equals_wpa(), expand_function_start(), gimplify_function_tree(), hash_tree(), pack_ts_function_decl_value_fields(), and unpack_ts_function_decl_value_fields().

◆ DECL_NO_LIMIT_STACK

#define DECL_NO_LIMIT_STACK ( NODE ) (FUNCTION_DECL_CHECK (NODE)->function_decl.no_limit_stack)

Used in FUNCTION_DECLs to indicate that limit-stack-* should be
disabled in this function.

Referenced by ipa_icf::sem_function::equals_wpa(), expand_function_start(), hash_tree(), pack_ts_function_decl_value_fields(), and unpack_ts_function_decl_value_fields().

◆ DECL_NOINIT_P

#define DECL_NOINIT_P ( DECL )

Value:

(DECL_P (DECL) \

&& (lookup_attribute ("noinit", DECL_ATTRIBUTES (DECL)) != NULL_TREE))

lookup_attribute

tree lookup_attribute(const char *attr_name, tree list)

Definition attribs.h:223

DECL_ATTRIBUTES

#define DECL_ATTRIBUTES(NODE)

Definition tree.h:2763

DECL_P

#define DECL_P(NODE)

Definition tree.h:231

Nonzero for a decl that is decorated with the "noinit" attribute.
decls with this attribute are placed into the ".noinit" section, so they are
not initialized by the target's startup code.

Referenced by default_elf_select_section(), default_unique_section(), and get_variable_section().

◆ DECL_NON_COMMON_CHECK

#define DECL_NON_COMMON_CHECK ( T ) CONTAINS_STRUCT_CHECK (T, TS_DECL_NON_COMMON)

◆ DECL_NONADDRESSABLE_P

#define DECL_NONADDRESSABLE_P ( NODE ) (FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_2)

Used in a FIELD_DECL to indicate that we cannot form the address of
this component.  This makes it possible for Type-Based Alias Analysis
to disambiguate accesses to this field with indirect accesses using
the field's type:

  struct S { int i; } s;
  int *p;

If the flag is set on 'i', TBAA computes that s.i and *p never conflict.

From the implementation's viewpoint, the alias set of the type of the
field 'i' (int) will not be recorded as a subset of that of the type of
's' (struct S) in record_component_aliases.  The counterpart is that
accesses to s.i must not be given the alias set of the type of 'i'
(int) but instead directly that of the type of 's' (struct S).

Referenced by analyze_ref(), ends_tbaa_access_path_p(), get_chain_field(), gimple_canonical_types_compatible_p(), hash_tree(), lookup_field_for_decl(), may_be_nonaddressable_p(), odr_types_equivalent_p(), pack_ts_decl_common_value_fields(), print_node(), record_component_aliases(), start_bitfield_representative(), store_constructor(), and unpack_ts_decl_common_value_fields().

◆ DECL_NONALIASED

#define DECL_NONALIASED ( NODE ) (VAR_DECL_CHECK (NODE)->base.nothrow_flag)

In a VAR_DECL, nonzero if this variable is not aliased by any pointer.

Referenced by build_var(), may_be_aliased(), and vect_analyze_data_refs().

◆ DECL_NONLOCAL

#define DECL_NONLOCAL ( NODE ) (DECL_COMMON_CHECK (NODE)->decl_common.nonlocal_flag)

Nonzero in a ..._DECL means this variable is ref'd from a nested function.
For VAR_DECL nodes, PARM_DECL nodes, and FUNCTION_DECL nodes.

For LABEL_DECL nodes, nonzero if nonlocal gotos to the label are permitted.

Also set in some languages for variables, etc., outside the normal
lexical scope, such as class instance variables.

Referenced by check_stmt(), cleanup_dead_labels(), convert_nl_goto_reference(), dump_generic_node(), dump_gimple_label(), expand_label(), find_duplicate(), get_loop_body_in_if_conv_order(), gimple_block_label(), gimple_merge_blocks(), gimple_verify_flow_info(), group_case_labels_stmt(), hash_tree(), label_rtx(), label_rtx_for_bb(), make_edges(), maybe_dead_abnormal_edge_p(), move_stmt_op(), move_stmt_r(), omp_copy_decl(), pack_ts_decl_common_value_fields(), print_node(), remove_bb(), remove_forwarder_block(), remove_forwarder_block_with_phi(), replace_block_by(), simple_operand_p(), single_block_loop_p(), stmt_starts_bb_p(), tree_forwarder_block_p(), tree_is_indexable(), unpack_ts_decl_common_value_fields(), and verify_gimple_label().

◆ DECL_NONLOCAL_FRAME

#define DECL_NONLOCAL_FRAME ( NODE ) (VAR_DECL_CHECK (NODE)->base.default_def_flag)

In a VAR_DECL, nonzero if this is a non-local frame structure.

Referenced by asan_expand_mark_ifn(), expand_one_var(), get_frame_type(), hash_tree(), layout_decl(), loc_list_from_tree_1(), pack_ts_decl_common_value_fields(), and unpack_ts_decl_common_value_fields().

◆ DECL_NONSHAREABLE

#define DECL_NONSHAREABLE ( NODE )

Value:

(TREE_CHECK2 (NODE, VAR_DECL, \

RESULT_DECL)->decl_common.decl_nonshareable_flag)

TREE_CHECK2

#define TREE_CHECK2(T, CODE1, CODE2)

Definition tree.h:488

In VAR_DECL or RESULT_DECL, set when significant code movement precludes
attempting to share the stack slot with some other variable.

Referenced by clear_tree_used(), expand_used_vars_for_block(), and gimple_duplicate_bb().

◆ DECL_NOT_FLEXARRAY

#define DECL_NOT_FLEXARRAY ( NODE ) (FIELD_DECL_CHECK (NODE)->decl_common.decl_not_flexarray)

Used in a FIELD_DECL to indicate whether this field is not a flexible
array member. This is only valid for the last array type field of a
structure.

Referenced by array_ref_flexible_size_p(), array_bounds_checker::check_array_ref(), component_ref_size(), pack_ts_decl_common_value_fields(), print_node(), and unpack_ts_decl_common_value_fields().

◆ DECL_NOT_GIMPLE_REG_P

#define DECL_NOT_GIMPLE_REG_P ( DECL ) DECL_COMMON_CHECK (DECL)->decl_common.not_gimple_reg_flag

For function local variables of COMPLEX and VECTOR types,
indicates that the variable is not aliased, and that all
modifications to the variable have been adjusted so that
they are killing assignments.  Thus the variable may now
be treated as a GIMPLE register, and use real instead of
virtual ops in SSA form.

Referenced by asan_add_global(), assumption_copy_decl(), copy_decl_to_var(), copy_result_decl_to_var(), copy_var_decl(), create_access_replacement(), declare_return_variable(), expand_thunk(), gimplify_parameters(), hash_tree(), is_gimple_reg(), lookup_tmp_var(), maybe_optimize_var(), pack_ts_decl_common_value_fields(), ipa_param_body_adjustments::reset_debug_stmts(), separate_decls_in_region_name(), setup_one_parameter(), and unpack_ts_decl_common_value_fields().

◆ DECL_OFFSET_ALIGN

#define DECL_OFFSET_ALIGN ( NODE ) (HOST_WIDE_INT_1U << FIELD_DECL_CHECK (NODE)->decl_common.off_align)

For FIELD_DECLs, off_align holds the number of low-order bits of
DECL_FIELD_OFFSET which are known to be always zero.
DECL_OFFSET_ALIGN thus returns the alignment that DECL_FIELD_OFFSET
has.

Referenced by component_ref_field_offset(), gimple_compare_field_offset(), gimplify_compound_lval(), gimplify_scan_omp_clauses(), hash_tree(), place_field(), print_node(), and start_bitfield_representative().

◆ DECL_ONE_ONLY

#define DECL_ONE_ONLY ( NODE )

Value:

(DECL_COMDAT_GROUP (NODE) != NULL_TREE \

&& (TREE_PUBLIC (NODE) || DECL_EXTERNAL (NODE)))

DECL_COMDAT_GROUP

#define DECL_COMDAT_GROUP(NODE)

Definition tree.h:3176

DECL_EXTERNAL

#define DECL_EXTERNAL(NODE)

Definition tree.h:2870

TREE_PUBLIC

#define TREE_PUBLIC(NODE)

Definition tree.h:857

Used in TREE_PUBLIC decls to indicate that copies of this DECL in
multiple translation units should be merged.

Referenced by asan_protect_global(), consider_split(), default_unique_section(), symtab_node::dump_base(), function_and_variable_visibility(), get_emutls_init_templ_addr(), symtab_node::get_partitioning_class(), ipa_tm_create_version(), ipa_tm_create_version_alias(), new_emutls_decl(), notice_global_symbol(), simd_clone_create(), update_visibility_by_resolution_info(), and write_symbol().

◆ DECL_ORIGIN

#define DECL_ORIGIN ( NODE ) (DECL_ABSTRACT_ORIGIN (NODE) ? DECL_ABSTRACT_ORIGIN (NODE) : (NODE))

Like DECL_ABSTRACT_ORIGIN, but returns NODE if there's no abstract
origin.  This is useful when setting the DECL_ABSTRACT_ORIGIN.

Referenced by block_ultimate_origin(), copy_debug_stmt(), copy_decl_for_dup_finish(), decl_ultimate_origin(), expand_call_inline(), expand_debug_source_expr(), lto_input_ts_block_tree_pointers(), ipa_param_adjustments::modify_call(), ipa_param_body_adjustments::reset_debug_stmts(), split_function(), and tree_function_versioning().

◆ DECL_ORIGINAL_TYPE

#define DECL_ORIGINAL_TYPE ( NODE ) (TYPE_DECL_CHECK (NODE)->decl_non_common.result)

TRANSLATION_UNIT_DECL inherits from DECL_MINIMAL.

For a TYPE_DECL, holds the "original" type.  (TREE_TYPE has the copy.)

Referenced by decl_attributes(), finalize_nesting_tree_1(), gimplify_decl_expr(), go_output_typedef(), is_typedef_decl(), modified_type_die(), nesting_copy_decl(), note_nonlocal_vla_type(), remap_decl(), and remap_vla_decls().

◆ DECL_P

#define DECL_P ( NODE ) (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_declaration)

Nonzero if NODE represents a declaration.

Referenced by add_desc_attribute(), operands_scanner::add_stmt_operand(), add_var_loc_to_decl(), addr_object_size(), addr_stridxptr(), address_compare(), alias_get_name(), alloc_iv(), ao_ref_from_mem(), ao_ref_init_from_vn_reference(), array_ref_flexible_size_p(), asan_emit_stack_protection(), asan_protect_stack_decl(), assemble_external(), assign_temp(), auto_var_in_fn_p(), avoid_type_punning_on_regs(), base_object_writable(), block_ultimate_origin(), build_access_from_expr_1(), call_may_clobber_ref_p_1(), can_escape(), can_sm_ref_p(), array_bounds_checker::check_addr_expr(), array_bounds_checker::check_array_ref(), check_ipa_load(), check_ipa_store(), check_load(), check_stmt_for_type_change(), check_store(), clobber_variable_part(), compare_base_decls(), component_ref_size(), compute_discriminator(), compute_objsize_r(), cond_if_else_store_replacement_1(), cond_store_replacement(), constant_after_peeling(), constant_byte_string(), contain_complex_addr_expr(), contains_remapped_vars(), convert_local_omp_clauses(), convert_local_reference_op(), convert_local_reference_stmt(), convert_nonlocal_omp_clauses(), convert_nonlocal_reference_stmt(), strlen_pass::count_nonzero_bytes(), create_access(), create_task_copyfn(), create_variable_info_for_1(), decl_attributes(), decl_binds_to_current_def_p(), decl_for_component_ref(), decl_maybe_in_construction_p(), decl_refs_may_alias_p(), decl_replaceable_p(), declare_return_variable(), default_binds_local_p_3(), default_elf_select_section(), default_encode_section_info(), default_function_value(), default_ref_may_alias_errno(), default_section_type_flags(), default_select_section(), default_tree_printer(), default_unique_section(), default_use_anchors_for_symbol_p(), dequeue_and_dump(), detect_type_change_from_memory_writes(), determine_known_aggregate_parts(), DFS::DFS(), diag_attr_exclusions(), diagnose_tm_1(), discover_nonconstant_array_refs(), discover_nonconstant_array_refs_r(), disqualify_base_of_expr(), dr_analyze_indices(), symtab_node::dump_base(), dump_defs_stack(), dump_enumerated_decls_push(), dump_generic_node(), dump_scope_block(), dump_tree_via_hooks(), eliminate_local_variables_1(), error_unavailable_use(), execute_update_addresses_taken(), expand_asm_stmt(), expand_assignment(), expand_call_inline(), expand_clobber(), expand_DEFERRED_INIT(), expand_expr_addr_expr_1(), expand_gimple_basic_block(), expand_omp_build_assign(), expand_omp_for_generic(), expand_omp_for_init_vars(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), expand_omp_regimplify_p(), expand_omp_simd(), expand_omp_taskloop_for_inner(), expand_stack_vars(), extr_type_from_vtbl_ptr_store(), extract_omp_for_update_vars(), find_func_aliases(), find_func_clobbers(), pcom_worker::find_looparound_phi(), find_var_from_fn(), flags_from_decl_or_type(), fold_comparison(), fold_const_aggregate_ref_1(), fold_gimple_assign(), for_each_index(), force_reg(), attr_access::free_lang_data(), gen_generic_params_dies(), get_access_for_expr(), get_addr_stridx(), get_attr_nonstring_decl(), get_base_decl(), get_base_loadstore(), get_callee_fndecl(), get_constraint_for_ssa_var(), get_default_value(), ipa_polymorphic_call_context::get_dynamic_type(), get_location(), get_location(), get_mem_align_offset(), get_name(), get_named_section(), get_object_alignment_2(), get_range_strlen_dynamic(), get_reaching_def(), get_ref_base_and_extent(), get_references_in_stmt(), get_section(), get_symbol_initial_value(), get_up_bounds_for_array_ref(), gimple_assign_load_p(), gimple_could_trap_p_1(), gimple_expand_vec_set_extract_expr(), gimple_fold_indirect_ref(), gimple_ior_addresses_taken_1(), gimplify_adjust_omp_clauses(), gimplify_adjust_omp_clauses_1(), gimplify_bind_expr(), gimplify_init_constructor(), gimplify_init_ctor_preeval(), gimplify_modify_expr(), gimplify_modify_expr_rhs(), gimplify_omp_for(), gimplify_scan_omp_clauses(), go_format_type(), handle_lhs_call(), has_attribute(), has_location(), operand_compare::hash_operand(), hash_tree(), indirect_ref_may_alias_decl_p(), access_ref::inform_access(), initialize_argument_information(), insert_debug_temp_for_var_def(), insert_phi_nodes_for(), instantiate_expr(), instrument_derefs(), instrument_expr(), instrument_object_size(), ipa_load_from_parm_agg(), ipa_polymorphic_call_context::ipa_polymorphic_call_context(), ipa_simd_modify_function_body(), leader_merge(), lhd_dwarf_name(), lower_oacc_head_mark(), lower_omp_1(), lower_omp_for(), lower_omp_regimplify_p(), lower_omp_target(), lower_omp_task_reductions(), lower_private_allocate(), lower_rec_input_clauses(), lower_rec_simd_input_clauses(), lower_reduction_clauses(), lto_input_ts_block_tree_pointers(), lto_read_tree_1(), lto_write_tree_1(), make_fancy_name_1(), map_decl_to_instance(), mark_def_sites(), matching_alloc_calls_p(), maybe_instrument_pointer_overflow(), maybe_make_indirect(), maybe_nonzero_address(), maybe_optimize_ubsan_ptr_ifn(), maybe_register_def(), maybe_replace_use(), maybe_replace_use_in_debug_stmt(), maybe_rewrite_mem_ref_base(), maybe_warn_operand(), maybe_warn_pass_by_reference(), maybe_wrap_with_location(), mem_dies_at_call(), move_stmt_op(), movement_possibility_1(), new_var_info(), non_mem_decl_p(), non_rewritable_lvalue_p(), non_rewritable_mem_ref_base(), nonoverlapping_memrefs_p(), oacc_resolve_clause_dependencies(), omp_accumulate_sibling_list(), omp_add_variable(), omp_build_struct_sibling_lists(), omp_find_stores_op(), omp_firstprivatize_variable(), omp_notice_variable(), omp_oacc_kernels_decompose_1(), omp_addr_tokenizer::omp_parse_structure_base(), omp_resolve_clause_dependencies(), operand_compare::operand_equal_p(), ref_always_accessed::operator()(), optimize_target_teams(), symbol_table::output_weakrefs(), pack_ts_base_value_fields(), path_comparable_for_same_access(), points_to_possible_sra_candidate_p(), prepare_block_for_update_1(), prepare_decl_rtl(), print_insn(), process_function_and_variable_attributes(), ptr_deref_may_alias_decl_p(), ptr_deref_may_alias_ref_p_1(), ptr_derefs_may_alias_p(), recompute_tree_invariant_for_addr_expr(), record_dynamic_alloc(), access_ref::ref_declared(), ref_may_alias_global_p_1(), ref_may_be_aliased(), ref_maybe_used_by_call_p_1(), ref_maybe_used_by_stmt_p(), reference_to_unused(), refs_local_or_readonly_memory_p(), refs_may_alias_p_2(), remap_decl(), remap_decls(), remap_gimple_stmt(), remap_type_3(), remap_vla_decls(), remove_unused_locals(), rewrite_debug_stmt_uses(), rewrite_stmt(), rewrite_update_phi_arguments(), rtx_addr_can_trap_p_1(), rtx_for_static_chain(), safe_from_p(), same_variable_part_p(), scan_omp_1_op(), scan_sharing_clauses(), scan_visit_addr(), self_referential_size(), separate_decls_in_region_debug(), ipa_polymorphic_call_context::set_by_decl(), ipa_polymorphic_call_context::set_by_invariant(), symtab_node::set_comdat_group(), set_mem_attributes_minus_bitpos(), set_reg_attrs_for_decl_rtl(), setup_one_parameter(), simple_operand_p(), sra_modify_call_arg(), stack_protect_epilogue(), stack_protect_prologue(), stmt_makes_single_store(), store_field(), strub_set_fndt_mode_to(), strub_target_support_p(), switch_to_section(), take_address_of(), track_expr_p(), tree_add_const_value_attribute(), tree_could_trap_p(), tree_expr_size(), tree_single_nonzero_warnv_p(), tree_swap_operands_p(), ubsan_encode_value(), unpack_ts_base_value_fields(), var_can_have_subvars(), var_debug_decl(), var_decl_component_p(), vect_build_slp_tree_1(), vect_get_datarefs_in_loop(), vectorizable_store(), verify_gimple_assign_single(), verify_sra_access_forest(), visit_conflict(), visit_op(), visit_reference_op_call(), visit_stmt(), vn_reference_lookup_3(), warn_dealloc_offset(), warn_deprecated_use(), warn_uninitialized_vars(), and widen_memory_access().

◆ DECL_PACKED

#define DECL_PACKED ( NODE ) (FIELD_DECL_CHECK (NODE)->base.u.bits.packed_flag)

In a FIELD_DECL, indicates this field should be bit-packed.

Referenced by hash_tree(), layout_decl(), pack_ts_decl_common_value_fields(), place_field(), print_node(), start_bitfield_representative(), unpack_ts_decl_common_value_fields(), and update_alignment_for_field().

◆ DECL_PADDING_P

#define DECL_PADDING_P ( NODE ) (FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_3)

Used in a FIELD_DECL to indicate that this field is padding.

Referenced by clear_padding_type(), clear_padding_union(), hash_tree(), is_empty_type(), native_encode_initializer(), native_interpret_aggregate(), pack_ts_decl_common_value_fields(), and unpack_ts_decl_common_value_fields().

◆ DECL_PERSISTENT_P

#define DECL_PERSISTENT_P ( DECL )

Value:

(DECL_P (DECL) \

&& (lookup_attribute ("persistent", DECL_ATTRIBUTES (DECL)) != NULL_TREE))

Nonzero for a decl that is decorated with the "persistent" attribute.
decls with this attribute are placed into the ".persistent" section, so they
are not initialized by the target's startup code.

Referenced by bss_initializer_p(), default_elf_select_section(), and default_unique_section().

◆ DECL_POSSIBLY_INLINED

#define DECL_POSSIBLY_INLINED ( DECL ) FUNCTION_DECL_CHECK (DECL)->function_decl.possibly_inlined

Nonzero for a decl that cgraph has decided should be inlined into
at least one call site.  It is not meaningful to look at this
directly; always use cgraph_function_possibly_inlined_p.

Referenced by cgraph_function_possibly_inlined_p(), hash_tree(), inline_call(), pack_ts_function_decl_value_fields(), tree_function_versioning(), and unpack_ts_function_decl_value_fields().

◆ DECL_PRESERVE_P

#define DECL_PRESERVE_P ( DECL ) DECL_COMMON_CHECK (DECL)->decl_common.preserve_flag

Nonzero for a decl that is decorated using attribute used.
This indicates to compiler tools that this decl needs to be preserved.

Referenced by assemble_start_function(), assemble_variable(), symtab_node::can_increase_alignment_p(), cgraph_build_static_cdtor_1(), cgraph_externally_visible_p(), check_decl(), function_reader::create_function(), expand_omp_target(), varpool_node::externally_visible_p(), varpool_node::finalize_decl(), get_emutls_init_templ_addr(), hash_tree(), is_improper(), new_emutls_decl(), optimize_weakref(), pack_ts_decl_common_value_fields(), print_node(), process_function_and_variable_attributes(), prune_offload_funcs(), and unpack_ts_decl_common_value_fields().

◆ DECL_PT_UID

#define DECL_PT_UID ( NODE )

Value:

(DECL_COMMON_CHECK (NODE)->decl_common.pt_uid == -1u \

? (NODE)->decl_minimal.uid : (NODE)->decl_common.pt_uid)

DECL_COMMON_CHECK

#define DECL_COMMON_CHECK(T)

Definition tree.h:523

Every ..._DECL node gets a unique number that stays the same even
when the decl is copied by the inliner once it is set.

Referenced by assumption_copy_decl(), copy_decl_to_var(), copy_node(), copy_result_decl_to_var(), dump_decl_name(), dump_variable(), get_constraint_for_ssa_var(), pt_solution_includes_1(), pt_solution_set_var(), ipa_param_body_adjustments::reset_debug_stmts(), same_addr_size_stores_p(), set_uids_in_ptset(), and update_alias_info_with_stack_vars().

◆ DECL_PT_UID_SET_P

#define DECL_PT_UID_SET_P ( NODE ) (DECL_COMMON_CHECK (NODE)->decl_common.pt_uid != -1u)

Whether the ..._DECL node pt-uid has been initialized and thus needs to
be preserved when copyin the decl.

Referenced by assumption_copy_decl(), copy_decl_to_var(), copy_node(), copy_result_decl_to_var(), get_constraint_for_ssa_var(), ipa_param_body_adjustments::reset_debug_stmts(), and set_uids_in_ptset().

◆ DECL_PURE_P

#define DECL_PURE_P ( NODE ) (FUNCTION_DECL_CHECK (NODE)->function_decl.pure_flag)

Nonzero in a FUNCTION_DECL means this function should be treated
as "pure" function (like const function, but may read global memory).
Note that being pure or const for a function is orthogonal to being
nothrow, i.e. it is valid to have DECL_PURE_P set and TREE_NOTHROW
cleared.

Referenced by cdtor_p(), flags_from_decl_or_type(), has_attribute(), hash_tree(), ipa_make_function_pure(), pack_ts_function_decl_value_fields(), set_call_expr_flags(), set_const_flag_1(), set_pure_flag_1(), unpack_ts_function_decl_value_fields(), and verify_gimple_call().

◆ DECL_QUALIFIER

#define DECL_QUALIFIER ( NODE ) (FIELD_DECL_CHECK (NODE)->field_decl.qualifier)

For a FIELD_DECL in a QUAL_UNION_TYPE, records the expression, which
if nonzero, indicates that the field occupies the type.

Referenced by place_union_field(), remap_decl(), remap_type_2(), type_contains_placeholder_1(), variably_modified_type_p(), and walk_tree_1().

◆ DECL_READ_P

#define DECL_READ_P ( NODE ) (TREE_CHECK2 (NODE, VAR_DECL, PARM_DECL)->decl_common.decl_read_flag)

In VAR_DECL and PARM_DECL, set when the decl has been used except for
being set.

Referenced by print_node().

◆ DECL_REGISTER

#define DECL_REGISTER ( NODE ) (DECL_WRTL_CHECK (NODE)->decl_common.decl_flag_0)

In VAR_DECL and PARM_DECL nodes, nonzero means declared `register'.

Referenced by assign_parms(), check_global_declaration(), dequeue_and_dump(), expand_function_end(), expand_function_start(), fold_builtin_next_arg(), gimplify_init_constructor(), gimplify_modify_expr_rhs(), hash_tree(), instrument_object_size(), make_decl_rtl(), maybe_instrument_pointer_overflow(), maybe_optimize_ubsan_ptr_ifn(), output_gimple_stmt(), pack_ts_decl_wrtl_value_fields(), print_declaration(), print_node(), register_asm_p(), rest_of_decl_compilation(), simple_operand_p(), tree_conflicts_with_clobbers_p(), unpack_ts_decl_wrtl_value_fields(), and use_register_for_decl().

◆ DECL_RESULT

#define DECL_RESULT ( NODE ) (FUNCTION_DECL_CHECK (NODE)->decl_non_common.result)

In FUNCTION_DECL, holds the decl for the return value.

Referenced by adjust_return_value_with_ops(), allocate_struct_function(), assign_parms(), assign_parms_augmented_arg_list(), cgraph_build_static_cdtor_1(), clobber_return_register(), consider_split(), copy_fn(), create_assumption_fn(), create_coalesce_list_for_region(), function_reader::create_function(), create_function_info_for(), create_loop_fn(), create_omp_child_function(), create_tailcall_accumulator(), cgraph_node::create_virtual_clone(), cgraph_node::create_wrapper(), declare_return_variable(), dump_function_to_file(), duplicate_thunk_for_node(), expand_builtin(), expand_call(), expand_function_end(), expand_function_start(), expand_gimple_stmt_1(), expand_omp_target(), expand_return(), expand_thunk(), expand_value_return(), find_tail_calls(), for_all_parms(), function_to_dwarf_procedure(), cgraph_node::get_untransformed_body(), gimple_regimplify_operands(), gimplify_return_expr(), init_function_start(), input_function(), instantiate_decls(), intra_create_variable_infos(), ipa_merge_profiles(), mark_nonssa_use(), output_function(), function_reader::parse_mem_expr(), points_to_local_or_readonly_memory_p(), process_assignment(), push_dummy_function(), cgraph_node::release_body(), symbol_table::remove_unreachable_nodes(), self_referential_size(), simd_clone_adjust(), split_function(), test_nonssa_use(), tree_function_versioning(), tree_optimize_tail_calls_1(), unshare_body(), unvisit_body(), and vt_add_function_parameters().

◆ DECL_RESULT_FLD

#define DECL_RESULT_FLD ( NODE ) (DECL_NON_COMMON_CHECK (NODE)->decl_non_common.result)

This field is used to reference anything in decl.result and is meant only
for use by the garbage collector.

Referenced by print_node().

◆ DECL_RTL

#define DECL_RTL ( NODE )

Value:

  (DECL_WRTL_CHECK (NODE)->decl_with_rtl.rtl            \
   ? (NODE)->decl_with_rtl.rtl                                  \
   : (make_decl_rtl (NODE), (NODE)->decl_with_rtl.rtl))

Holds the RTL expression for the value of a variable or function.
This value can be evaluated lazily for functions, variables with
static storage duration, and labels.

Referenced by asan_memfn_rtl(), asan_protect_global(), assemble_undefined_decl(), assemble_variable(), assign_parms(), assign_parms_unsplit_complex(), build_personality_function(), symtab_node::can_increase_alignment_p(), clobber_return_register(), compare_base_symbol_refs(), symtab_node::copy_visibility_from(), decl_overlaps_hard_reg_set_p(), decode_addr_const(), default_globalize_decl_name(), default_stack_protect_guard(), delegitimize_mem_from_attrs(), dump_tm_clone_pairs(), expand_asm_stmt(), expand_assignment(), expand_builtin(), expand_call(), expand_expr_real_1(), expand_expr_real_2(), expand_function_end(), expand_label(), expand_one_var(), expand_return(), expand_stack_vars(), expand_value_return(), gen_array_type_die(), gen_const_die(), get_alias_set(), get_fnname_from_decl(), get_personality_function(), globalize_decl(), init_one_libfunc_visibility(), initialize_argument_information(), instantiate_decls(), instantiate_decls_1(), instantiate_expr(), label_rtx(), symtab_node::make_decl_local(), make_decl_rtl(), make_decl_rtl_for_debug(), mark_weak(), non_mem_decl_p(), nonoverlapping_memrefs_p(), place_block_symbol(), print_node(), rest_of_handle_final(), rtx_for_function_call(), safe_from_p(), set_mem_attrs_for_spill(), set_parm_rtl(), set_rtl(), set_used_decls(), set_user_assembler_libfunc(), setjmp_args_warning(), setjmp_vars_warning(), stack_protect_epilogue(), stack_protect_prologue(), unshare_all_rtl(), and unshare_all_rtl_again().

◆ DECL_RTL_IF_SET

#define DECL_RTL_IF_SET ( NODE ) (DECL_RTL_SET_P (NODE) ? DECL_RTL (NODE) : NULL)

The DECL_RTL for NODE, if it is set, or NULL, if it is not set.

Referenced by add_scope_conflicts_1(), expand_clobber(), expand_debug_expr(), expand_used_vars(), layout_decl(), print_param(), rtl_for_decl_location(), safe_from_p(), set_mem_attributes_minus_bitpos(), track_expr_p(), visit_conflict(), visit_op(), and vt_add_function_parameter().

◆ DECL_RTL_KNOWN_SET

#define DECL_RTL_KNOWN_SET ( decl ) (&*DECL_RTL_IF_SET (decl))

Referenced by dv_as_rtx(), dv_from_rtx(), prepare_call_arguments(), set_dv_changed(), and var_track_values_to_stack().

◆ DECL_RTL_SET_P

#define DECL_RTL_SET_P ( NODE ) (HAS_RTL_P (NODE) && DECL_WRTL_CHECK (NODE)->decl_with_rtl.rtl != NULL)

Returns nonzero if the DECL_RTL for NODE has already been set.

Referenced by asan_protect_global(), assemble_variable(), assign_parms(), symtab_node::can_increase_alignment_p(), symbol_table::change_decl_assembler_name(), clobber_return_register(), symtab_node::copy_visibility_from(), delegitimize_mem_from_attrs(), delete_vta_debug_insn(), duplicate_thunk_for_node(), expand_debug_expr(), expand_debug_source_expr(), expand_expr_real_1(), expand_function_end(), expand_function_start(), expand_one_var(), get_alias_set(), instantiate_decls(), instantiate_decls_1(), instantiate_expr(), label_rtx(), symtab_node::make_decl_local(), make_decl_rtl(), make_decl_rtl_for_debug(), mark_weak(), non_mem_decl_p(), nonoverlapping_memrefs_p(), prepare_decl_rtl(), print_node(), relayout_decl(), symbol_table::remove_unreferenced_decls(), safe_from_p(), set_rtl(), set_used_decls(), setjmp_vars_warning(), simple_cst_equal(), track_expr_p(), and unshare_all_rtl().

◆ DECL_SAVED_TREE

#define DECL_SAVED_TREE ( NODE ) (FUNCTION_DECL_CHECK (NODE)->function_decl.saved_tree)

In a FUNCTION_DECL, the saved representation of the body of the
entire function.

Referenced by cgraph_build_static_cdtor_1(), copy_tree_body(), create_task_copyfn(), dequeue_and_dump(), dump_function_to_file(), expand_omp_target(), expand_omp_taskreg(), function_to_dwarf_procedure(), gimplify_body(), gimplify_function_tree(), init_lowered_empty_function(), input_function(), maybe_inline_call_in_expr(), omp_discover_declare_target_tgt_fn_r(), omp_discover_implicit_declare_target(), release_function_body(), rest_of_decl_compilation(), self_referential_size(), unshare_body(), and unvisit_body().

◆ DECL_SECTION_NAME

#define DECL_SECTION_NAME ( NODE ) decl_section_name (NODE)

Records the section name in a section attribute.  Used to pass
the name from decl_attributes to make_function_rtl and make_decl_rtl.

Referenced by asan_protect_global(), symtab_node::can_be_discarded_p(), symtab_node::can_increase_alignment_p(), decide_function_section(), default_function_rodata_section(), ipa_icf::sem_variable::equals_wpa(), function_and_variable_visibility(), function_section_1(), get_emutls_init_templ_addr(), get_named_section(), get_named_text_section(), get_variable_section(), hot_function_section(), make_decl_rtl(), ipa_icf::sem_function::merge(), ipa_icf::sem_variable::merge(), resolve_unique_section(), and secname_for_decl().

◆ DECL_SEEN_IN_BIND_EXPR_P

#define DECL_SEEN_IN_BIND_EXPR_P ( NODE ) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.seen_in_bind_expr)

Nonzero in a decl means that the gimplifier has seen (or placed)
this variable in a BIND_EXPR.

Referenced by computable_teams_clause(), copy_var_decl(), create_asan_shadow_var(), create_tmp_var_for(), declare_inline_vars(), declare_return_variable(), get_debug_decl(), get_frame_type(), gimple_add_tmp_var(), gimple_add_tmp_var_fn(), gimplify_bind_expr(), gimplify_compound_literal_expr(), gimplify_decl_expr(), gimplify_target_expr(), gimplify_var_or_parm_decl(), hash_tree(), lower_lastprivate_conditional_clauses(), pack_ts_decl_with_vis_value_fields(), ipa_param_body_adjustments::reset_debug_stmts(), scan_omp_simd(), setup_one_parameter(), and unpack_ts_decl_with_vis_value_fields().

◆ DECL_SET_IS_OPERATOR_DELETE

#define DECL_SET_IS_OPERATOR_DELETE	(		NODE,
			VAL ) set_function_decl_type (FUNCTION_DECL_CHECK (NODE), OPERATOR_DELETE, VAL)

Referenced by cgraph_node::create_version_clone_with_body(), set_new_clone_decl_and_node_flags(), and unpack_ts_function_decl_value_fields().

◆ DECL_SET_IS_OPERATOR_NEW

#define DECL_SET_IS_OPERATOR_NEW	(		NODE,
			VAL ) set_function_decl_type (FUNCTION_DECL_CHECK (NODE), OPERATOR_NEW, VAL)

Referenced by cgraph_node::create_version_clone_with_body(), and set_new_clone_decl_and_node_flags().

◆ DECL_SET_LAMBDA_FUNCTION

#define DECL_SET_LAMBDA_FUNCTION	(		NODE,
			VAL ) set_function_decl_type (FUNCTION_DECL_CHECK (NODE), LAMBDA_FUNCTION, VAL)

◆ DECL_SIZE

#define DECL_SIZE ( NODE ) (DECL_COMMON_CHECK (NODE)->decl_common.size)

Holds the size of the datum, in bits, as a tree expression.
Need not be constant and may be null.  May be less than TYPE_SIZE
for a C++ FIELD_DECL representing a base class subobject with its
own virtual base classes (which are laid out separately).

Referenced by add_abstract_origin_attribute(), add_prototyped_attribute(), align_variable(), ao_ref_from_mem(), ao_ref_init_from_vn_reference(), array_ref_flexible_size_p(), asan_protect_global(), assemble_variable(), build_user_friendly_ref_for_offset(), ao_compare::compare_ao_refs(), ipa_icf_gimple::func_checker::compare_decl(), compare_virtual_tables(), compute_record_mode(), coverage_end_function(), create_access(), create_variable_info_for_1(), dequeue_and_dump(), DFS::DFS_write_tree_body(), dw_sra_loc_expr(), ipa_icf::sem_variable::equals_wpa(), expand_expr_real_1(), field_byte_offset(), finish_bitfield_layout(), finish_bitfield_representative(), fixup_child_record_type(), fixup_remapped_decl(), fold_const_aggregate_ref_1(), fold_nonarray_ctor_reference(), force_constant_size(), get_access_for_expr(), get_binfo_at_offset(), get_bit_range(), get_bitfield_rep(), get_inner_reference(), get_narrower(), get_ref_base_and_extent(), gimple_canonical_types_compatible_p(), gimple_compare_field_offset(), gimplify_adjust_omp_clauses(), gimplify_adjust_omp_clauses_1(), gimplify_parameters(), gimplify_return_expr(), gimplify_target_expr(), gimplify_type_sizes(), gimplify_vla_decl(), ao_compare::hash_ao_ref(), hash_tree(), hoist_adjacent_loads(), indirect_ref_may_alias_decl_p(), inline_forbidden_p(), instrument_derefs(), instrument_expr(), layout_decl(), lower_omp_target(), lto_input_ts_decl_common_tree_pointers(), maybe_instrument_pointer_overflow(), maybe_rewrite_mem_ref_base(), maybe_warn_operand(), native_encode_initializer(), non_rewritable_lvalue_p(), non_rewritable_mem_ref_base(), nonoverlapping_component_refs_p_1(), omp_add_variable(), omp_notice_variable(), output_constructor_bitfield(), place_field(), print_node(), push_fields_onto_fieldstack(), record_targets_from_bases(), ref_at_iteration(), relayout_decl(), remap_decl(), remap_type_2(), ipa_polymorphic_call_context::restrict_to_inner_class(), same_addr_size_stores_p(), scan_sharing_clauses(), skip_in_fields_list_p(), split_complex_args(), start_bitfield_representative(), store_constructor(), store_field(), task_copyfn_remap_type(), totally_scalarizable_type_p(), totally_scalarize_subtree(), type_internals_preclude_sra_p_1(), ubsan_type_descriptor(), unshare_body(), unvisit_body(), update_alignment_for_field(), use_pointer_in_frame(), variably_modified_type_p(), walk_tree_1(), wrapup_global_declaration_1(), and write_ts_decl_common_tree_pointers().

◆ DECL_SIZE_UNIT

#define DECL_SIZE_UNIT ( NODE ) (DECL_COMMON_CHECK (NODE)->decl_common.size_unit)

Likewise for the size in bytes.

Referenced by add_decls_addresses_to_decl_constructor(), add_stack_var(), address_compare(), array_ref_flexible_size_p(), asan_add_global(), asan_expand_poison_ifn(), asan_poison_variable(), asan_protect_global(), assemble_noswitch_variable(), assemble_variable(), assemble_variable_contents(), btf_collect_datasec(), build_asan_poison_call_expr(), clear_padding_type(), clear_padding_union(), component_ref_sam_type(), component_ref_size(), constant_byte_string(), convert_gimple_call(), convert_local_reference_stmt(), convert_nonlocal_reference_stmt(), convert_tramp_reference_stmt(), coverage_end_function(), decl_init_size(), decompose_kernels_region_body(), default_emutls_var_init(), default_use_anchors_for_symbol_p(), defer_stack_allocation(), DFS::DFS_write_tree_body(), emutls_common_1(), expand_DEFERRED_INIT(), expand_one_stack_var_1(), expand_one_var(), finish_bitfield_representative(), fixup_child_record_type(), fixup_remapped_decl(), force_constant_size(), get_block_for_decl(), get_maxbound(), get_range_strlen_tree(), get_up_bounds_for_array_ref(), gimple_add_tmp_var(), gimple_add_tmp_var_fn(), gimplify_adjust_omp_clauses(), gimplify_adjust_omp_clauses_1(), gimplify_bind_expr(), gimplify_decl_expr(), gimplify_parameters(), gimplify_return_expr(), gimplify_scan_omp_clauses(), gimplify_type_sizes(), gimplify_vla_decl(), go_format_type(), hash_tree(), inbounds_memaccess_p(), layout_decl(), loc_list_from_tree_1(), lower_private_allocate(), lto_input_ts_decl_common_tree_pointers(), maybe_build_inner_data_region(), maybe_optimize_ubsan_ptr_ifn(), maybe_rewrite_mem_ref_base(), maybe_set_strlen_range(), native_encode_initializer(), non_rewritable_mem_ref_base(), omp_add_variable(), optimize_memcpy(), output_constructor_regular_field(), output_object_block(), place_block_symbol(), place_field(), place_union_field(), print_node(), relayout_decl(), remap_decl(), remap_type_2(), rtx_addr_can_trap_p_1(), set_mem_attributes_minus_bitpos(), split_complex_args(), start_bitfield_representative(), task_copyfn_remap_type(), tree_could_trap_p(), tree_expr_size(), ubsan_type_descriptor(), unshare_body(), unvisit_body(), variably_modified_type_p(), walk_tree_1(), widen_memory_access(), write_symbol(), and write_ts_decl_common_tree_pointers().

◆ DECL_SOURCE_COLUMN

#define DECL_SOURCE_COLUMN ( NODE ) LOCATION_COLUMN (DECL_SOURCE_LOCATION (NODE))

Referenced by dump_callgraph_transformation(), dump_loc(), dump_loc(), and cgraph_node::remove().

◆ DECL_SOURCE_FILE

#define DECL_SOURCE_FILE ( NODE ) LOCATION_FILE (DECL_SOURCE_LOCATION (NODE))

Referenced by check_global_declaration(), dump_callgraph_transformation(), dump_loc(), dump_loc(), dump_oacc_loop(), flag_instrument_functions_exclude_p(), cgraph_node::remove(), and should_emit_struct_debug().

◆ DECL_SOURCE_LINE

#define DECL_SOURCE_LINE ( NODE ) LOCATION_LINE (DECL_SOURCE_LOCATION (NODE))

Referenced by dump_callgraph_transformation(), dump_loc(), dump_loc(), dump_oacc_loop(), autofdo::get_combined_location(), and cgraph_node::remove().

◆ DECL_SOURCE_LOCATION

#define DECL_SOURCE_LOCATION ( NODE ) (DECL_MINIMAL_CHECK (NODE)->decl_minimal.locus)

These two fields describe where in the source code the declaration
was.  If the declaration appears in several places (as for a C
function that is declared first and then defined later), this
information should refer to the definition.

Referenced by add_linkage_name(), add_type_duplicate(), autofdo::afdo_annotate_cfg(), cgraph_node::analyze(), asan_add_global(), asan_emit_stack_protection(), assemble_alias(), assign_assembler_name_if_needed(), assign_parms_augmented_arg_list(), assumption_copy_decl(), autofdo::auto_profile(), branch_prob(), build_case_label(), build_decl(), c_strlen(), calls_builtin_apply_args_p(), can_strub_internally_p(), can_strub_p(), cgraph_build_static_cdtor_1(), array_bounds_checker::check_addr_expr(), array_bounds_checker::check_array_ref(), check_global_declaration(), common_function_versions(), compare_virtual_tables(), compute_strub_mode(), const_ok_for_output_1(), copy_decl_to_var(), copy_result_decl_to_var(), copy_var_decl(), coverage_begin_function(), coverage_compute_lineno_checksum(), coverage_compute_profile_id(), create_access_replacement(), create_assumption_fn(), create_dispatcher_calls(), create_omp_child_function(), create_one_component_var(), create_stack_guard(), create_task_copyfn(), cgraph_node::create_version_clone_with_body(), default_tree_printer(), dequeue_and_dump(), diag_attr_exclusions(), do_assemble_alias(), do_reload(), error_unavailable_use(), execute_oacc_device_lower(), execute_oacc_loop_designation(), cgraph_node::expand(), expand_builtin_fork_or_exec(), expand_builtin_init_trampoline(), expand_call_inline(), expand_function_start(), expand_omp_target(), expand_one_var(), expand_target_clones(), expand_thunk(), finalize_nesting_tree_1(), fixup_child_record_type(), fold_builtin_alloca_with_align(), frame_offset_overflow(), dump_user_location_t::from_function_decl(), get_chain_decl(), get_coverage_counts(), get_debug_decl(), get_descriptor_type(), get_emutls_init_templ_addr(), get_location(), get_location(), get_section(), get_spill_slot_decl(), get_trampoline_type(), get_variable_section(), gimplify_bind_expr(), gimplify_body(), gimplify_function_tree(), gimplify_omp_affinity(), gimplify_omp_depend(), globalize_reg(), go_output_var(), handle_alias_pairs(), has_location(), access_ref::inform_access(), init_function_start(), install_var_field(), ipa_devirt(), ipa_odr_summary_write(), ipa_tm_create_version_alias(), is_addr_local(), layout_decl(), lookup_field_for_decl(), make_item_for_dump_symtab_node(), make_node(), maybe_diag_alias_attributes(), maybe_diag_incompatible_alias(), maybe_warn_nonstring_arg(), maybe_warn_pass_by_reference(), maybe_warn_read_write_only(), new_emutls_decl(), new_oacc_loop_outer(), oacc_loop_fixed_partitions(), oacc_validate_dims(), omp_copy_decl(), omp_discover_declare_target_var_r(), omp_notice_variable(), omp_resolve_declare_variant(), ompdevlow_adjust_simt_enter(), output_stack_usage_1(), place_field(), print_decl_identifier(), print_node(), process_common_attributes(), process_function_and_variable_attributes(), process_symver_attribute(), record_dynamic_alloc(), ipa_param_body_adjustments::reset_debug_stmts(), rest_of_decl_compilation(), scan_omp_for(), set_strub_mode_to(), simd_clone_clauses_extract(), streamer_read_tree_bitfields(), streamer_write_tree_bitfields(), strub_target_support_p(), suggest_attribute(), switch_to_section(), tree_function_versioning(), tree_profiling(), verify_node_partition(), vt_find_locations(), warn_deprecated_use(), warn_odr(), warn_types_mismatch(), warn_uninit(), warn_uninitialized_vars(), and weak_finish().

◆ DECL_STATIC_CHAIN

#define DECL_STATIC_CHAIN ( NODE ) (FUNCTION_DECL_CHECK (NODE)->decl_with_vis.regdecl_flag)

In a FUNCTION_DECL indicates that a static chain is needed.

Referenced by build_init_call_stmt(), convert_all_function_calls(), convert_gimple_call(), convert_tramp_reference_op(), cgraph_node::dump(), expand_thunk(), finalize_nesting_tree_1(), get_chain_decl(), get_chain_field(), ipcp_transformation::get_param_index(), gimple_fold_call(), gimplify_call_expr(), hash_tree(), initializer_constant_valid_p_1(), ipa_icf::sem_function::merge(), pack_ts_function_decl_value_fields(), prepare_call_address(), print_node(), cgraph_edge::redirect_call_stmt_to_callee(), rtx_for_static_chain(), unpack_ts_function_decl_value_fields(), and verify_gimple_call().

◆ DECL_STATIC_CONSTRUCTOR

#define DECL_STATIC_CONSTRUCTOR ( NODE ) (FUNCTION_DECL_CHECK (NODE)->function_decl.static_ctor_flag)

Used in FUNCTION_DECLs to indicate that they should be run automatically
at the beginning or end of execution.

Referenced by build_cdtor(), cgraph_node::can_remove_if_no_direct_calls_and_refs_p(), cdtor_p(), cgraph_build_static_cdtor_1(), check_global_declaration(), compute_function_frequency(), cgraph_node::create_version_clone_with_body(), cgraph_node::dump(), symtab_node::dump_base(), function_and_variable_visibility(), hash_tree(), input_node(), ipa_cdtor_merge(), ipa_comdats(), lto_output_node(), symtab_node::needed_p(), symtab_node::noninterposable_alias(), cgraph_node::only_called_directly_or_aliased_p(), pack_ts_function_decl_value_fields(), ipa_icf::sem_function::parse(), record_cdtor_fn(), rest_of_handle_final(), set_const_flag_1(), symtab_node::set_init_priority(), set_new_clone_decl_and_node_flags(), set_pure_flag_1(), simd_clone_create(), and unpack_ts_function_decl_value_fields().

◆ DECL_STATIC_DESTRUCTOR

#define DECL_STATIC_DESTRUCTOR ( NODE ) (FUNCTION_DECL_CHECK (NODE)->function_decl.static_dtor_flag)

Referenced by build_cdtor(), build_cxa_dtor_registrations(), cgraph_node::can_remove_if_no_direct_calls_and_refs_p(), cdtor_p(), cgraph_build_static_cdtor_1(), check_global_declaration(), compare_cdtor_tu_order(), compute_function_frequency(), cgraph_node::create_version_clone_with_body(), cgraph_node::dump(), symtab_node::dump_base(), function_and_variable_visibility(), hash_tree(), input_node(), ipa_cdtor_merge(), ipa_comdats(), lto_output_node(), symtab_node::needed_p(), symtab_node::noninterposable_alias(), cgraph_node::only_called_directly_or_aliased_p(), pack_ts_function_decl_value_fields(), ipa_icf::sem_function::parse(), record_cdtor_fn(), rest_of_handle_final(), set_const_flag_1(), cgraph_node::set_fini_priority(), set_new_clone_decl_and_node_flags(), set_pure_flag_1(), simd_clone_create(), and unpack_ts_function_decl_value_fields().

◆ DECL_STRUCT_FUNCTION

#define DECL_STRUCT_FUNCTION ( NODE ) (FUNCTION_DECL_CHECK (NODE)->function_decl.f)

For FUNCTION_DECL, this holds a pointer to a structure ("struct function")
that describes the status of this function.

Referenced by cgraph_node::add_new_function(), autofdo::afdo_indirect_call(), allocate_struct_function(), cgraph_node::analyze(), analyze_function(), analyze_function_body(), analyze_functions(), autofdo::auto_profile(), can_early_inline_edge_p(), can_strub_internally_p(), gimple_infer_range::check_assume_func(), check_bb_profile(), ipa_icf_gimple::func_checker::compare_bb(), symbol_table::compile(), compute_bb_predicates(), compute_call_stmt_bb_frequency(), compute_fn_summary(), copy_body(), copy_cfg_body(), copy_fn(), copy_node(), coverage_obj_init(), symbol_table::create_edge(), create_function_info_for(), create_task_copyfn(), cgraph_node::create_virtual_clone(), decl_maybe_in_construction_p(), do_per_function(), do_per_function_toporder(), drop_profile(), dump_bb_info(), dump_function_header(), dump_function_to_file(), duplicate_thunk_for_node(), estimate_num_insns_fn(), estimated_stack_frame_size(), execute_all_ipa_transforms(), execute_split_functions(), cgraph_node::expand(), expand_all_functions(), expand_call_inline(), expand_omp_target(), expand_omp_taskreg(), expand_target_clones(), expand_thunk(), cgraph_node::finalize_function(), finalize_nesting_tree_1(), finalize_task_copyfn(), find_what_p_points_to(), fixup_call_stmt_edges(), ipa_icf::sem_item_optimizer::fixup_points_to_sets(), flatten_function(), ipa_icf_gimple::func_checker::func_checker(), function_and_variable_visibility(), cgraph_node::get_body(), cgraph_node::get_fun(), get_personality_function(), cgraph_node::get_untransformed_body(), gimple_body(), gimple_dump_bb_buff(), gimple_has_body_p(), gimple_set_body(), gimplify_function_tree(), go_early_global_decl(), handle_missing_profiles(), ipa_icf::sem_function::init(), initialize_cfun(), initialize_inlined_parameters(), inline_analyze_function(), inline_call(), inline_forbidden_p(), input_function(), ipa_sra_function_summaries::insert(), modref_summaries::insert(), modref_summaries_lto::insert(), instantiate_decls(), ipa_analyze_controlled_uses(), ipa_analyze_node(), ipa_fn_summary_generate(), ipa_merge_profiles(), ipa_profile_generate_summary(), ipa_pta_execute(), ipa_simd_modify_function_body(), ipa_sra_summarize_function(), ipa_tm_execute(), ipa_tm_scan_calls_clone(), ipa_tm_scan_irr_function(), ipa_tm_transform_clone(), ipa_tm_transform_transaction(), ipcp_update_vr(), lower_assumption(), lower_emutls_function_body(), lto_prepare_function_for_streaming(), maybe_inline_call_in_expr(), ipa_icf::sem_item_optimizer::merge_classes(), symtab_node::native_rtl_p(), symtab_node::noninterposable_alias(), ok_for_auto_simd_clone(), omp_discover_implicit_declare_target(), output_function(), param_type_may_change_p(), ipa_icf::sem_function::parse(), print_node(), symbol_table::process_new_functions(), process_symver_attribute(), record_vars_into(), cgraph_edge::redirect_call_stmt_to_callee(), release_function_body(), remap_gimple_stmt(), remap_vla_decls(), remove_exit_barrier(), replace_by_duplicate_decl(), replace_ssa_name(), rest_of_decl_compilation(), ipa_icf_gimple::func_checker::safe_for_total_scalarization_p(), cgraph_edge::set_call_stmt(), simd_clone_adjust(), strub_from_body_p(), tree_function_versioning(), tree_profiling(), tree_versionable_function_p(), update_call_expr(), and cgraph_node::verify_node().

◆ DECL_THREAD_LOCAL_P

#define DECL_THREAD_LOCAL_P ( NODE ) ((TREE_STATIC (NODE) || DECL_EXTERNAL (NODE)) && decl_tls_model (NODE) >= TLS_MODEL_REAL)

In a VAR_DECL, nonzero if the data should be allocated from
thread-local storage.

Referenced by align_variable(), asan_protect_global(), assemble_variable(), categorize_decl_for_section(), computable_teams_clause(), decl_address_invariant_p(), decl_address_ip_invariant_p(), default_encode_section_info(), default_section_type_flags(), delegitimize_mem_from_attrs(), do_assemble_alias(), varpool_node::externally_visible_p(), function_and_variable_visibility(), get_variable_align(), get_variable_section(), gimplify_omp_for(), gimplify_scan_omp_clauses(), instrument_derefs(), ipa_lower_emutls(), loc_list_from_tree_1(), lower_emutls_1(), lower_emutls_2(), omp_notice_variable(), print_node(), staticp(), and tls_mem_loc_descriptor().

◆ DECL_TLS_MODEL

#define DECL_TLS_MODEL ( NODE ) decl_tls_model (NODE)

In a VAR_DECL, the model to use if the data should be allocated from
thread-local storage.

Referenced by default_encode_section_info(), ipa_icf::sem_variable::equals_wpa(), varpool_node::externally_visible_p(), and print_node().

◆ DECL_UID

#define DECL_UID ( NODE ) (DECL_MINIMAL_CHECK (NODE)->decl_minimal.uid)

Every ..._DECL node gets a unique number.

Referenced by add_clobbers_to_eh_landing_pad(), add_location_or_const_value_attribute(), add_var_loc_to_decl(), adjust_simduid_builtins(), alias_get_name(), analyze_access_subtree(), analyze_all_variable_accesses(), avoid_type_punning_on_regs(), budget_for_propagation_access(), build_access_from_call_arg(), build_access_from_expr(), build_access_from_expr_1(), build_accesses_from_assign(), build_fake_var_decl(), build_outer_var_ref(), check_all_va_list_escapes(), compare_cdtor_tu_order(), compare_ctor(), compare_decls_by_uid(), compare_dtor(), compare_param_body_replacement(), compute_live_vars_1(), compute_live_vars_visit(), consider_split(), convert_local_omp_clauses(), convert_local_reference_op(), convert_nonlocal_omp_clauses(), convert_nonlocal_reference_op(), copy_node(), create_access(), create_task_copyfn(), cselib_hash_rtx(), data_ref_compare_tree(), decl_debug_args_insert(), decl_debug_args_lookup(), decl_debug_expr_insert(), decl_debug_expr_lookup(), decl_value_expr_insert(), decl_value_expr_lookup(), discover_nonconstant_array_refs(), discover_nonconstant_array_refs_r(), disqualify_candidate(), dump_access(), dump_decl_name(), dump_final_callee_vcg(), dump_function_header(), dump_function_name(), dump_function_to_file(), dump_generic_node(), dump_var(), dump_variable(), dv_uid(), eliminate_temp_copies(), eliminate_unnecessary_stmts(), dw_loc_list_hasher::equal(), registration_hasher::equal(), decl_die_hasher::equal(), decl_loc_hasher::equal(), equate_decl_number_to_die(), execute_update_addresses_taken(), expand_one_var(), find_replaceable_in_bb(), find_tail_calls(), find_va_list_reference(), finish_taskreg_scan(), finish_tm_clone_pairs(), ipa_icf::sem_item_optimizer::fixup_points_to_sets(), ipa_icf::sem_item_optimizer::fixup_pt_set(), get_access_for_expr(), get_component_var(), get_constraint_for_ssa_var(), ipcp_transformation::get_param_index(), get_var_info(), gimple_add_init_for_auto_var(), gimple_ior_addresses_taken_1(), gimplify_omp_for(), simd_array_to_simduid::hash(), ssa_name_var_hash::hash(), var_info_hasher::hash(), registration_hasher::hash(), omp_declare_variant_hasher::hash(), omp_declare_variant_alt_hasher::hash(), tree_decl_hash::hash(), tree_vec_map_cache_hasher::hash(), operand_compare::hash_operand(), initialize_parameter_reductions(), insert_phi_nodes_compare_var_infos(), insert_updated_phi_nodes_compare_uids(), install_var_field(), install_var_field(), is_used_p(), lookup_decl_die(), lookup_decl_loc(), lower_omp_regimplify_p(), lower_omp_target(), lower_send_clauses(), lto_output(), make_fancy_decl_name(), make_node(), mark_def_sites(), mark_for_renaming(), mark_nonssa_use(), marked_for_renaming(), maybe_add_sra_candidate(), ipcp_transformation::maybe_create_parm_idx_map(), maybe_optimize_var(), maybe_rewrite_mem_ref_base(), ipa_icf::sem_item_optimizer::merge_classes(), move_stmt_op(), new_label_mapper(), note_simd_array_uses(), omp_copy_decl_2(), omp_declare_variant_remove_hook(), omp_lto_input_declare_variant_alt(), omp_lto_output_declare_variant_alt(), omp_resolve_declare_variant(), omp_resolve_late_declare_variant(), optimize_va_list_gpr_fpr_size(), predcom_tmp_var(), print_insn(), print_node(), print_node_brief(), process_replaceable(), propagate_all_subaccesses(), reject(), remove_unused_locals(), scan_sharing_clauses(), separate_decls_in_region_debug(), separate_decls_in_region_name(), set_is_used(), set_ssa_default_def(), set_uids_in_ptset(), sort_and_splice_var_accesses(), sort_by_decl_uid(), sort_by_ssa_version_or_uid(), ipa_icf::sort_congruence_classes_by_decl_uid(), ipa_icf::sort_sem_items_by_decl_uid(), splay_tree_compare_decl_uid(), ssa_default_def(), stack_var_cmp(), take_address_of(), test_nonssa_use(), tree_decl_map_hash(), use_pointer_for_field(), va_list_counter_struct_op(), va_list_ptr_read(), va_list_ptr_write(), vect_transform_loops(), and warn_uninit().

◆ DECL_UNCHECKED_FUNCTION_CODE

#define DECL_UNCHECKED_FUNCTION_CODE ( NODE ) (FUNCTION_DECL_CHECK (NODE)->function_decl.function_code)

For FUNCTION_DECL, if it is built-in, this identifies which built-in
operation it is.  This is only intended for low-level accesses;
normally DECL_FUNCTION_CODE, DECL_FE_FUNCTION_CODE or DECL_MD_FUNCTION
should be used instead.

Referenced by fndecl_built_in_p(), hash_tree(), operand_compare::operand_equal_p(), and pack_ts_function_decl_value_fields().

◆ DECL_UNINLINABLE

#define DECL_UNINLINABLE ( NODE ) (FUNCTION_DECL_CHECK (NODE)->function_decl.uninlinable)

In a FUNCTION_DECL, nonzero if the function cannot be inlined.

Referenced by cgraph_build_static_cdtor_1(), cgraph_function_possibly_inlined_p(), ipa_icf::sem_item::compare_referenced_symbol_properties(), create_assumption_fn(), create_loop_fn(), create_nesting_tree(), create_omp_child_function(), cgraph_node::create_wrapper(), expand_omp_target(), ipa_icf::sem_item::hash_referenced_symbol_properties(), hash_tree(), pack_ts_function_decl_value_fields(), possible_inline_candidate_p(), print_node(), process_function_and_variable_attributes(), record_tm_replacement(), tree_inlinable_function_p(), and unpack_ts_function_decl_value_fields().

◆ DECL_UNSIGNED

#define DECL_UNSIGNED ( NODE ) (DECL_COMMON_CHECK (NODE)->base.u.bits.unsigned_flag)

In a decl (most significantly a FIELD_DECL), means an unsigned field.

Referenced by get_inner_reference(), get_narrower(), hash_tree(), layout_decl(), pack_ts_base_value_fields(), print_node(), and unpack_ts_base_value_fields().

◆ DECL_USER_ALIGN

#define DECL_USER_ALIGN ( NODE ) (DECL_COMMON_CHECK (NODE)->base.u.bits.user_align)

Set if the alignment of this DECL has been set by the user, for
example with an 'aligned' attribute.

Referenced by add_bit_offset_attribute(), align_variable(), assemble_start_function(), copy_var_decl(), do_type_align(), ensure_base_align(), expand_one_stack_var_at(), finish_taskreg_scan(), get_descriptor_type(), get_trampoline_type(), get_variable_align(), get_vec_alignment_for_record_type(), hash_tree(), increase_alignment(), increase_alignment_1(), init_eh(), install_var_field(), install_var_field(), layout_decl(), lookup_field_for_decl(), lower_omp_task_reductions(), new_emutls_decl(), omp_finish_file(), ompdevlow_adjust_simt_enter(), pack_ts_decl_common_value_fields(), print_node(), relayout_decl(), unpack_ts_decl_common_value_fields(), and update_alignment_for_field().

◆ DECL_VALUE_EXPR

#define DECL_VALUE_EXPR ( NODE ) (decl_value_expr_lookup (DECL_WRTL_CHECK (NODE)))

Referenced by add_decls_addresses_to_decl_constructor(), build_outer_var_ref(), copy_node(), create_task_copyfn(), DFS::DFS_write_tree_body(), finish_taskreg_remap(), fixup_remapped_decl(), fixup_vla_decls(), fortran_common(), gimple_add_padding_init_for_auto_var(), gimplify_adjust_omp_clauses(), gimplify_adjust_omp_clauses_1(), gimplify_bind_expr(), gimplify_scan_omp_clauses(), gimplify_var_or_parm_decl(), hash_tree(), instantiate_decls(), instantiate_decls_1(), instantiate_expr(), loc_list_from_tree_1(), lookup_field_for_decl(), lower_lastprivate_clauses(), lower_omp_for_scan(), lower_omp_regimplify_operands_p(), lower_omp_scan(), lower_omp_target(), lower_omp_task_reductions(), lower_rec_input_clauses(), lower_reduction_clauses(), lower_send_clauses(), lower_send_shared_vars(), new_emutls_decl(), omp_add_variable(), omp_finish_file(), omp_member_access_dummy_var(), omp_notice_variable(), print_declaration(), print_node(), record_reference(), remap_decls(), remap_vla_decls(), replace_block_vars_by_duplicates(), scan_sharing_clauses(), target_for_debug_bind(), verify_expr_location_1(), vt_add_function_parameters(), and write_ts_decl_common_tree_pointers().

◆ DECL_VINDEX

#define DECL_VINDEX ( NODE ) (FUNCTION_DECL_CHECK (NODE)->function_decl.vindex)

The DECL_VINDEX is used for FUNCTION_DECLS in two different ways.
Before the struct containing the FUNCTION_DECL is laid out,
DECL_VINDEX may point to a FUNCTION_DECL in a base class which
is the FUNCTION_DECL which this FUNCTION_DECL will replace as a virtual
function.  When the class is laid out, this pointer is changed
to an INTEGER_CST node which is suitable for use as an index
into the virtual function table.

Referenced by add_src_coords_attributes(), ipa_param_adjustments::adjust_decl(), decl_class_context(), DFS::DFS_write_tree_body(), and ipa_param_body_adjustments::modify_formal_parameters().

◆ DECL_VIRTUAL_P

#define DECL_VIRTUAL_P ( NODE ) (DECL_COMMON_CHECK (NODE)->decl_common.virtual_flag)

Used in VAR_DECLs to indicate that the variable is a vtable.
Used in FIELD_DECLs for vtable pointers.
Used in FUNCTION_DECLs to indicate that the function is virtual.

Referenced by symtab_node::address_can_be_compared_p(), ipa_ref::address_matters_p(), ipa_param_adjustments::adjust_decl(), align_variable(), build_type_inheritance_graph(), can_remove_node_now_p_1(), can_replace_by_local_alias_in_vtable(), ipa_icf::sem_item::compare_referenced_symbol_properties(), compare_virtual_tables(), compute_ltrans_boundary(), cgraph_node::create_version_clone_with_body(), ctor_for_folding(), varpool_node::ctor_useable_for_folding_p(), decl_function_context(), devirt_variable_node_removal_hook(), symtab_node::dump_base(), dump_inline_stats(), symtab_node::equal_address_to(), ipa_icf::sem_variable::equals_wpa(), extr_type_from_vtbl_ptr_store(), extract_object_class_type(), function_and_variable_visibility(), varpool_node::get_availability(), gimple_gen_ic_func_profiler(), gimple_get_virt_method_for_vtable(), handle_alias_pairs(), ipa_icf::sem_item::hash_referenced_symbol_properties(), hash_tree(), ipa_propagate_frequency(), is_vptr_store(), is_vtable_assignment_stmt(), ipa_icf::sem_function::merge(), ipa_param_body_adjustments::modify_formal_parameters(), noncall_stmt_may_be_vtbl_ptr_store(), symtab_node::noninterposable_alias(), odr_types_equivalent_p(), cgraph_node::only_called_directly_or_aliased_p(), pack_ts_decl_common_value_fields(), print_node(), referenced_from_vtable_p(), varpool_node::remove_initializer(), set_new_clone_decl_and_node_flags(), stmt_may_be_vtbl_ptr_store(), ipa_icf::symbol_compare_collection::symbol_compare_collection(), unpack_ts_decl_common_value_fields(), update_type_inheritance_graph(), and vtable_pointer_value_to_vtable().

◆ DECL_VISIBILITY

#define DECL_VISIBILITY ( NODE ) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.visibility)

Value of the decls's visibility attribute

Referenced by build_cxa_atexit_decl(), build_dso_handle_decl(), build_libfunc_function_visibility(), can_refer_decl_in_current_unit_p(), cgraph_externally_visible_p(), symtab_node::copy_visibility_from(), create_odr_indicator(), default_binds_local_p_3(), default_external_stack_protect_fail(), default_hidden_stack_protect_fail(), symtab_node::dump_base(), dw2_output_indirect_constant_1(), expand_builtin_fork_or_exec(), varpool_node::externally_visible_p(), symtab_node::fixup_same_cpp_alias_visibility(), get_emutls_init_templ_addr(), symtab_node::get_visibility_string(), hash_tree(), symtab_node::make_decl_local(), maybe_assemble_visibility(), new_emutls_decl(), output_comp_unit(), pack_ts_decl_with_vis_value_fields(), process_symver_attribute(), simd_clone_create(), ubsan_expand_vptr_ifn(), unpack_ts_decl_with_vis_value_fields(), symtab_node::verify_base(), and write_symbol().

◆ DECL_VISIBILITY_SPECIFIED

#define DECL_VISIBILITY_SPECIFIED ( NODE ) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.visibility_specified)

Nonzero means that the decl (or an enclosing scope) had its
visibility specified rather than being inferred.

Referenced by build_cxa_atexit_decl(), build_dso_handle_decl(), build_libfunc_function_visibility(), can_refer_decl_in_current_unit_p(), symtab_node::copy_visibility_from(), create_odr_indicator(), default_binds_local_p_3(), default_elf_asm_output_external(), default_external_stack_protect_fail(), default_hidden_stack_protect_fail(), symtab_node::dump_base(), expand_builtin_fork_or_exec(), get_emutls_init_templ_addr(), hash_tree(), symtab_node::make_decl_local(), new_emutls_decl(), output_comp_unit(), pack_ts_decl_with_vis_value_fields(), simd_clone_create(), ubsan_expand_vptr_ifn(), and unpack_ts_decl_with_vis_value_fields().

◆ DECL_WARN_IF_NOT_ALIGN

#define DECL_WARN_IF_NOT_ALIGN ( NODE )

Value:

(DECL_WARN_IF_NOT_ALIGN_RAW (NODE) \

? ((unsigned)1) << (DECL_WARN_IF_NOT_ALIGN_RAW (NODE) - 1) : 0)

DECL_WARN_IF_NOT_ALIGN_RAW

#define DECL_WARN_IF_NOT_ALIGN_RAW(NODE)

Definition tree.h:2798

Referenced by do_type_align(), handle_warn_if_not_align(), and print_node().

◆ DECL_WARN_IF_NOT_ALIGN_RAW

#define DECL_WARN_IF_NOT_ALIGN_RAW ( NODE ) (DECL_COMMON_CHECK (NODE)->decl_common.warn_if_not_align)

The minimum alignment necessary for the datum, in bits, without
warning.

◆ DECL_WEAK

#define DECL_WEAK ( NODE ) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.weak_flag)

Referenced by asan_needs_local_alias(), asan_needs_odr_indicator_p(), assemble_alias(), assemble_external(), symtab_node::can_be_discarded_p(), symtab_node::copy_visibility_from(), cgraph_node::create_version_clone_with_body(), cgraph_node::create_virtual_clone(), varpool_node::ctor_useable_for_folding_p(), decl_binds_to_current_def_p(), decl_replaceable_p(), default_binds_local_p_3(), symtab_node::dump_base(), varpool_node::externally_visible_p(), fde_needed_for_eh_p(), symtab_node::fixup_same_cpp_alias_visibility(), fold_builtin_expect(), function_and_variable_visibility(), get_emutls_init_templ_addr(), gimple_could_trap_p_1(), globalize_decl(), hash_tree(), ipa_tm_create_version(), symtab_node::make_decl_local(), make_decl_one_only(), make_decl_rtl(), mark_weak(), merge_weak(), new_emutls_decl(), symtab_node::noninterposable_alias(), symtab_node::nonzero_address(), notice_global_symbol(), optimize_weakref(), pack_ts_decl_with_vis_value_fields(), print_decl_identifier(), print_node(), process_common_attributes(), process_function_and_variable_attributes(), set_new_clone_decl_and_node_flags(), simd_clone_create(), simple_operand_p(), tree_could_trap_p(), unpack_ts_decl_with_vis_value_fields(), update_visibility_by_resolution_info(), and write_symbol().

◆ DECL_WITH_VIS_CHECK

#define DECL_WITH_VIS_CHECK ( T ) CONTAINS_STRUCT_CHECK (T, TS_DECL_WITH_VIS)

◆ DECL_WRTL_CHECK

#define DECL_WRTL_CHECK ( T ) CONTAINS_STRUCT_CHECK (T, TS_DECL_WRTL)

Referenced by function_reader::parse_param(), and set_decl_rtl().

◆ DECODE_QUAL_ADDR_SPACE

#define DECODE_QUAL_ADDR_SPACE ( X ) (((X) >> 8) & 0xFF)

Referenced by set_type_quals().

◆ DEFAULT_INIT_PRIORITY

#define DEFAULT_INIT_PRIORITY 65535

The initialization priority for entities for which no explicit
initialization priority has been specified.

◆ dfloat128_type_node

#define dfloat128_type_node global_trees[TI_DFLOAT128_TYPE]

Referenced by build_common_tree_nodes().

◆ dfloat32_type_node

#define dfloat32_type_node global_trees[TI_DFLOAT32_TYPE]

The decimal floating point types.

Referenced by build_common_tree_nodes().

◆ dfloat64_type_node

#define dfloat64_type_node global_trees[TI_DFLOAT64_TYPE]

Referenced by build_common_tree_nodes().

◆ double_ptr_type_node

#define double_ptr_type_node global_trees[TI_DOUBLE_PTR_TYPE]

Referenced by build_common_tree_nodes().

◆ double_type_node

#define double_type_node global_trees[TI_DOUBLE_TYPE]

Referenced by build_common_tree_nodes(), build_tm_load(), build_tm_store(), convert_to_real_1(), define_builtin_macros_for_type_sizes(), excess_precision_type(), expand_omp_for_init_vars(), fold_builtin_classify(), fold_builtin_interclass_mathfn(), gen_ctf_base_type(), initialize_sanitizer_builtins(), mathfn_built_in_2(), strip_float_extensions(), tm_log_emit_stmt(), and ubsan_type_descriptor().

◆ dq_type_node

#define dq_type_node global_trees[TI_DQ_TYPE]

◆ EH_FILTER_FAILURE

#define EH_FILTER_FAILURE ( NODE ) TREE_OPERAND (EH_FILTER_EXPR_CHECK (NODE), 1)

Referenced by dump_generic_node(), gimplify_expr(), and try_catch_may_fallthru().

◆ EH_FILTER_TYPES

#define EH_FILTER_TYPES ( NODE ) TREE_OPERAND (EH_FILTER_EXPR_CHECK (NODE), 0)

EH_FILTER_EXPR accessors.

Referenced by dump_generic_node(), and gimplify_expr().

◆ EH_LANDING_PAD_NR

#define EH_LANDING_PAD_NR ( NODE ) (LABEL_DECL_CHECK (NODE)->label_decl.eh_landing_pad_nr)

In a LABEL_DECL, the EH region number for which the label is the
post_landing_pad.

Referenced by cleanup_dead_labels(), cleanup_dead_labels_eh(), cleanup_empty_eh_unsplit(), dump_gimple_label(), duplicate_eh_regions_1(), emit_post_landing_pad(), gimple_merge_blocks(), gimple_verify_flow_info(), gsi_insert_finally_seq_after_call(), hash_tree(), pack_ts_decl_common_value_fields(), print_node(), redirect_eh_edge_1(), remove_eh_handler_splicer(), remove_eh_landing_pad(), remove_forwarder_block(), unpack_ts_decl_common_value_fields(), unsplit_eh(), and verify_gimple_label().

◆ ENCODE_QUAL_ADDR_SPACE

#define ENCODE_QUAL_ADDR_SPACE ( NUM ) ((NUM & 0xFF) << 8)

Encode/decode the named memory support as part of the qualifier.  If more
than 8 qualifiers are added, these macros need to be adjusted.

Referenced by build_ref_for_offset(), modified_type_die(), and move_hint_to_base().

◆ ENUM_IS_OPAQUE

#define ENUM_IS_OPAQUE ( NODE ) (ENUMERAL_TYPE_CHECK (NODE)->base.private_flag)

Determines whether an ENUMERAL_TYPE has defined the list of constants.

◆ ENUM_IS_SCOPED

#define ENUM_IS_SCOPED ( NODE ) (ENUMERAL_TYPE_CHECK (NODE)->base.static_flag)

Used to mark scoped enums.

◆ error_mark_node

#define error_mark_node global_trees[TI_ERROR_MARK]

Referenced by addr_object_size(), adjust_return_value(), align_variable(), attr_access::array_as_string(), array_ref_low_bound(), array_type_nelts(), assemble_variable(), assemble_variable_contents(), assign_parm_find_data_types(), associate_equivalences_with_edges(), bss_initializer_p(), build_common_tree_nodes(), build_dso_handle_decl(), build_function_type(), build_pointer_type_for_mode(), build_reference_type_for_mode(), build_vector_from_val(), can_sm_ref_p(), canonicalize_constructor_val(), check_stmt_for_type_change(), clear_padding_type(), clear_padding_union(), component_ref_size(), compute_object_offset(), compute_reloc_for_var(), constant_after_peeling(), constant_byte_string(), convert_to_complex_1(), convert_to_fixed(), convert_to_integer_1(), convert_to_pointer_1(), convert_to_real_1(), convert_to_vector(), copy_self_referential_tree_r(), strlen_pass::count_nonzero_bytes(), ctor_for_folding(), varpool_node::ctor_useable_for_folding_p(), decl_attributes(), decl_binds_to_current_def_p(), default_binds_local_p_3(), default_is_empty_record(), DFS::DFS_write_tree_body(), do_jump(), do_store_flag(), dump_function_declaration(), dump_generic_node(), dump_omp_context_selector(), emutls_common_1(), ipa_icf::sem_variable::equals(), error_operand_p(), evaluate_conditions_for_known_args(), evaluate_properties_for_edge(), tree_switch_conversion::switch_conversion::expand(), cgraph_node::expand(), expand_addsub_overflow(), expand_case(), expand_expr_real_1(), expand_expr_real_2(), expand_gimple_stmt_1(), expand_mul_overflow(), expand_one_var(), expand_return(), expr_callee_abi(), extr_type_from_vtbl_ptr_store(), finish_bitfield_representative(), fixup_remapped_decl(), fold_call_stmt(), fold_const_aggregate_ref_1(), fold_convert_loc(), force_value_to_type(), fully_constant_vn_reference_p(), function_and_variable_visibility(), gather_mem_refs_stmt(), get_alias_set(), get_base_constructor(), get_callee_fndecl(), varpool_node::get_constructor(), get_range_pos_neg(), get_symbol_constant_value(), get_symbol_initial_value(), get_variable_align(), get_variable_section(), gimple_assign_unary_nop_p(), gimple_get_virt_method_for_vtable(), gimplify_asm_expr(), gimplify_call_expr(), gimplify_decl_expr(), gimplify_expr(), gimplify_modify_expr(), gimplify_return_expr(), gimplify_save_expr(), gimplify_type_sizes(), gimplify_va_arg_expr(), handle_warn_if_not_align(), operand_compare::hash_operand(), init_lowered_empty_function(), initialize_argument_information(), initialize_inlined_parameters(), initializer_constant_valid_p_1(), insert_debug_temp_for_var_def(), insert_init_debug_bind(), int_size_in_bytes(), integer_valued_real_p(), ipa_comdats(), layout_decl(), layout_type(), lower_emutls_1(), lower_omp_for_scan(), lower_omp_task_reductions(), lower_rec_input_clauses(), lto_output(), make_decl_one_only(), make_decl_rtl(), make_dispatcher_decl(), ipa_param_body_adjustments::mark_dead_statements(), maybe_canonicalize_argtypes(), maybe_with_size_expr(), mem_ref_alloc(), mem_refs_may_alias_p(), narrowing_initializer_constant_valid_p(), new_emutls_decl(), symtab_node::noninterposable_alias(), notice_global_symbol(), omp_check_context_selector(), omp_copy_decl(), omp_firstprivatize_type_sizes(), omp_get_attachment(), omp_group_base(), omp_index_mapping_groups_1(), omp_mappable_type(), omp_resolve_declare_variant(), operand_compare::operand_equal_p(), optimize_range_tests(), optimize_range_tests_var_bound(), optimize_vec_cond_expr(), output_function(), param_change_prob(), place_field(), process_function_and_variable_attributes(), propagate_comdat_group(), vn_walk_cb_data::push_partial_def(), record_common_node(), record_edge_info(), ref_indep_loop_p(), cgraph_node::release_body(), release_ssa_name_fn(), remap_type_1(), ipa_param_body_adjustments::remap_with_debug_expressions(), varpool_node::remove(), varpool_node::remove_initializer(), symbol_table::remove_unreachable_nodes(), replace_with_mapped_expr(), rest_of_handle_final(), ipa_polymorphic_call_context::restrict_to_inner_class(), set_mem_attributes_minus_bitpos(), irange::set_varying(), setup_one_parameter(), simplify_vector_constructor(), size_binop_loc(), size_in_bytes_loc(), sm_seq_valid_bb(), stabilize_reference(), tree_add_const_value_attribute(), tree_expr_nonnegative_warnv_p(), tree_node_can_be_shared(), tree_nop_conversion(), tree_ssa_useless_type_conversion(), type_hash_canon_hash(), uniform_vector_p(), unpack_ts_function_decl_value_fields(), update_alignment_for_field(), update_range_test(), variably_modified_type_p(), vect_verify_full_masking_avx512(), irange::verify_range(), and verify_type_context().

◆ EXCEPTIONAL_CLASS_P

#define EXCEPTIONAL_CLASS_P ( NODE ) (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_exceptional)

Nonzero if NODE represents an exceptional code.

Referenced by maybe_wrap_with_location().

◆ EXIT_EXPR_COND

#define EXIT_EXPR_COND ( NODE ) TREE_OPERAND (EXIT_EXPR_CHECK (NODE), 0)

◆ EXPR_CHECK

#define EXPR_CHECK ( T ) (T)

Referenced by streamer_read_tree_bitfields().

◆ EXPR_COND_UID

#define EXPR_COND_UID ( t ) EXPR_CHECK ((t))->exp.condition_uid

Referenced by gimplify_cond_expr().

◆ EXPR_FILENAME

#define EXPR_FILENAME ( NODE ) LOCATION_FILE (EXPR_CHECK ((NODE))->exp.locus)

◆ EXPR_HAS_LOCATION

#define EXPR_HAS_LOCATION ( NODE )

Value:

(LOCATION_LOCUS (EXPR_LOCATION (NODE)) \

!= UNKNOWN_LOCATION)

LOCATION_LOCUS

#define LOCATION_LOCUS(LOC)

Definition input.h:184

UNKNOWN_LOCATION

#define UNKNOWN_LOCATION

Definition input.h:32

EXPR_LOCATION

#define EXPR_LOCATION(NODE)

Definition tree.h:1310

Referenced by array_bounds_checker::check_array_bounds(), dump_generic_node(), expand_builtin_strnlen(), fold_builtin_strlen(), fold_call_stmt(), gimple_or_expr_nonartificial_location(), gimplify_call_expr(), gimplify_cond_expr(), gimplify_expr(), has_location(), access_ref::inform_access(), make_item_for_dump_generic_expr(), print_node(), protected_set_expr_location_if_unset(), rexpr_location(), and binary_op_rich_location::use_operator_loc_p().

◆ EXPR_HAS_RANGE

#define EXPR_HAS_RANGE ( NODE )

Value:

    (CAN_HAVE_RANGE_P (NODE) \
     ? EXPR_LOCATION_RANGE (NODE).m_start != UNKNOWN_LOCATION \
     : false)

◆ EXPR_LINENO

#define EXPR_LINENO ( NODE ) LOCATION_LINE (EXPR_CHECK (NODE)->exp.locus)

◆ EXPR_LOC_OR_LOC

#define EXPR_LOC_OR_LOC	(		NODE,
			LOCUS )

Value:

(EXPR_HAS_LOCATION (NODE) \

? (NODE)->exp.locus : (LOCUS))

exp

double exp(double)

EXPR_HAS_LOCATION

#define EXPR_HAS_LOCATION(NODE)

Definition tree.h:1313

The location to be used in a diagnostic about this expression.  Do not
use this macro if the location will be assigned to other expressions.

Referenced by c_strlen(), do_warn_nonnull_compare(), dynamic_object_sizes_execute_one(), gimplify_asm_expr(), handle_printf_call(), internal_get_tmp_var(), and shortcut_cond_expr().

◆ EXPR_LOCATION

#define EXPR_LOCATION ( NODE ) (CAN_HAVE_LOCATION_P ((NODE)) ? (NODE)->exp.locus : UNKNOWN_LOCATION)

The source location of this expression.  Non-tree_exp nodes such as
decls and constants can be shared among multiple locations, so
return nothing.

Referenced by gcc_rich_location::add_expr(), add_to_predicate_list(), array_ref_element_size(), build_va_arg_indirect_ref(), canonicalize_constructor_val(), array_bounds_checker::check_array_bounds(), check_strncat_sizes(), component_ref_field_offset(), convert_to_complex_1(), convert_to_integer_1(), convert_to_pointer_1(), convert_to_real_1(), copy_tree_body_r(), create_artificial_child_access(), dr_analyze_indices(), dump_generic_node(), expand_builtin_bzero(), expand_builtin_cexpi(), expand_builtin_fork_or_exec(), expand_builtin_int_roundingfn(), expand_builtin_int_roundingfn_2(), expand_builtin_memcmp(), expand_builtin_memory_chk(), expand_builtin_memset_args(), expand_builtin_signbit(), expand_builtin_sincos(), expand_builtin_stpcpy_1(), expand_builtin_strcmp(), expand_builtin_strncmp(), expand_builtin_strncpy(), expand_builtin_strnlen(), expand_builtin_sync_operation(), expand_builtin_va_copy(), expand_builtin_va_start(), expand_call(), expand_expr_real_1(), expr_location_or(), fold(), fold_build_cleanup_point_expr(), fold_builtin_strlen(), fold_const_aggregate_ref_1(), fold_read_from_constant_string(), gen_phi_arg_condition(), get_expr_source_range(), get_location(), get_location(), get_narrower(), gimple_add_init_for_auto_var(), gimple_assign_rhs_to_tree(), gimple_boolify(), gimple_build_call_from_tree(), gimple_fold_stmt_to_constant_1(), gimplify_addr_expr(), gimplify_bind_expr(), gimplify_call_expr(), gimplify_case_label_expr(), gimplify_compound_lval(), gimplify_cond_expr(), gimplify_conversion(), gimplify_expr(), gimplify_label_expr(), gimplify_modify_expr(), gimplify_modify_expr_rhs(), gimplify_modify_expr_to_memcpy(), gimplify_modify_expr_to_memset(), gimplify_omp_atomic(), gimplify_omp_for(), gimplify_omp_loop(), gimplify_omp_task(), gimplify_scalar_mode_aggregate_compare(), gimplify_self_mod_expr(), gimplify_switch_expr(), gimplify_transaction(), gimplify_va_arg_expr(), gimplify_variable_sized_compare(), access_ref::inform_access(), initialize_argument_information(), initialize_parameter_reductions(), instrument_derefs(), ipa_write_jump_function(), make_item_for_dump_generic_expr(), make_range(), maybe_canonicalize_mem_ref_addr(), maybe_complain_about_tail_call(), maybe_fold_reference(), maybe_record_in_goto_queue(), negate_expr(), optimize_target_teams(), output_node_opt_summary(), prepare_target_mem_ref_lvalue(), preserve_any_location_wrapper(), print_node(), propagate_subaccesses_from_rhs(), protected_set_expr_location_unshare(), record_dynamic_alloc(), rexpr_location(), save_expr(), simple_cst_equal(), split_address_to_core_and_offset(), split_complex_args(), stabilize_reference(), store_constructor(), streamer_write_tree_bitfields(), tree_inlined_location(), tree_nonartificial_location(), tree_optimize_tail_calls_1(), verify_expr_location_1(), and verify_expr_no_block().

◆ EXPR_LOCATION_RANGE

#define EXPR_LOCATION_RANGE ( NODE ) (get_expr_source_range (EXPR_CHECK ((NODE))))

Referenced by print_node().

◆ EXPR_LOCATION_WRAPPER_P

#define EXPR_LOCATION_WRAPPER_P ( NODE ) (TREE_CHECK2(NODE, NON_LVALUE_EXPR, VIEW_CONVERT_EXPR)->base.public_flag)

In NON_LVALUE_EXPR and VIEW_CONVERT_EXPR, set when this node is merely a
wrapper added to express a location_t on behalf of the node's child
(e.g. by maybe_wrap_with_location).

Referenced by location_wrapper_p(), and maybe_wrap_with_location().

◆ EXPR_P

#define EXPR_P ( NODE ) IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (NODE)))

Returns nonzero iff NODE is an expression of some kind.

Referenced by clear_unused_block_pointer_1(), contains_abnormal_ssa_name_p_1(), copy_tree_body_r(), determine_base_object_1(), do_niy(), dump_generic_node(), eliminate_local_variables_1(), expr_invariant_in_loop_p(), expression_expensive_p(), find_ssa_undef(), find_trapping_overflow(), generic_expr_could_trap_p(), get_location(), get_location(), maybe_range_label_for_tree_type_mismatch::get_text(), gimple_assign_rhs_to_tree(), has_location(), access_ref::inform_access(), instantiate_expr(), lower_emutls_1(), lower_emutls_2(), lower_stmt(), mangle_referenced_decls(), gcc_rich_location::maybe_add_expr(), maybe_warn_operand(), move_stmt_op(), outermost_invariant_loop_for_expr(), prune_expr_location(), reference_to_unused(), remap_gimple_op_r(), simplify_replace_tree(), test_for_singularity(), unshare_expr_without_location(), vect_loop_versioning(), verify_expr_location_1(), verify_expr_no_block(), and wrap_refs().

◆ EXPRESSION_CLASS_P

#define EXPRESSION_CLASS_P ( NODE ) (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_expression)

Nonzero if NODE represents any other expression.

Referenced by extract_muldiv_1(), and substitute_placeholder_in_expr().

◆ FALLTHROUGH_LABEL_P

#define FALLTHROUGH_LABEL_P ( NODE ) (LABEL_DECL_CHECK (NODE)->base.private_flag)

Whether a case or a user-defined label is allowed to fall through to.
This is used to implement -Wimplicit-fallthrough.

Referenced by should_warn_for_implicit_fallthrough(), and warn_implicit_fallthrough_r().

◆ fenv_t_ptr_type_node

#define fenv_t_ptr_type_node global_trees[TI_FENV_T_PTR_TYPE]

The C type `fenv_t *'.

◆ fexcept_t_ptr_type_node

#define fexcept_t_ptr_type_node global_trees[TI_FEXCEPT_T_PTR_TYPE]

The C type `fexcept_t *'.

◆ fileptr_type_node

#define fileptr_type_node global_trees[TI_FILEPTR_TYPE]

The C type `FILE *'.

◆ FIND_PLACEHOLDER_IN_EXPR

#define FIND_PLACEHOLDER_IN_EXPR	(		EXP,
			V )

Value:

do {                                     \
  if((EXP) && !TREE_CONSTANT (EXP))      \
    find_placeholder_in_expr (EXP, V);   \
} while (0)

This macro calls the above function but short-circuits the common
case of a constant to save time and also checks for NULL.

Referenced by find_placeholder_in_expr().

◆ FIXED_POINT_TYPE_P

#define FIXED_POINT_TYPE_P ( TYPE ) (TREE_CODE (TYPE) == FIXED_POINT_TYPE)

Nonzero if TYPE represents a fixed-point type.

Referenced by build_complex_type(), fold_convert_const(), gimple_canonical_types_compatible_p(), odr_types_equivalent_p(), useless_type_conversion_p(), valid_fixed_convert_types_p(), verify_gimple_assign_binary(), verify_gimple_assign_ternary(), verify_type(), and verify_type_variant().

◆ float128_type_node

#define float128_type_node global_trees[TI_FLOAT128_TYPE]

Referenced by build_common_tree_nodes(), long_double_as_float128(), and mathfn_built_in_2().

◆ float128t_type_node

#define float128t_type_node global_trees[TI_FLOAT128T_TYPE]

Type used by certain backends for __float128, which in C++ should be
distinct type from _Float128 for backwards compatibility reasons.

Referenced by build_common_tree_nodes().

◆ float128x_type_node

#define float128x_type_node global_trees[TI_FLOAT128X_TYPE]

Referenced by mathfn_built_in_2().

◆ float16_type_node

#define float16_type_node global_trees[TI_FLOAT16_TYPE]

Names for individual types (code should normally iterate over all
such types; these are only for back-end use, or in contexts such as
*.def where iteration is not possible).

Referenced by excess_precision_type(), and mathfn_built_in_2().

◆ float32_type_node

#define float32_type_node global_trees[TI_FLOAT32_TYPE]

Referenced by mathfn_built_in_2().

◆ float32x_type_node

#define float32x_type_node global_trees[TI_FLOAT32X_TYPE]

Referenced by mathfn_built_in_2().

◆ float64_type_node

#define float64_type_node global_trees[TI_FLOAT64_TYPE]

Referenced by mathfn_built_in_2().

◆ float64x_type_node

#define float64x_type_node global_trees[TI_FLOAT64X_TYPE]

Referenced by get_no_error_domain(), and mathfn_built_in_2().

◆ float_ptr_type_node

#define float_ptr_type_node global_trees[TI_FLOAT_PTR_TYPE]

Referenced by build_common_tree_nodes().

◆ float_type_node

#define float_type_node global_trees[TI_FLOAT_TYPE]

Referenced by build_common_tree_nodes(), build_tm_load(), build_tm_store(), convert_to_real_1(), define_builtin_macros_for_type_sizes(), excess_precision_type(), gen_ctf_base_type(), initialize_sanitizer_builtins(), mathfn_built_in_2(), strip_float_extensions(), tm_log_emit_stmt(), and ubsan_type_descriptor().

◆ FLOAT_TYPE_P

#define FLOAT_TYPE_P ( TYPE )

Value:

  (SCALAR_FLOAT_TYPE_P (TYPE)                   \
   || ((TREE_CODE (TYPE) == COMPLEX_TYPE        \
        || VECTOR_TYPE_P (TYPE))                \
       && SCALAR_FLOAT_TYPE_P (TREE_TYPE (TYPE))))

Nonzero if TYPE represents a floating-point type, including complex
and vector floating-point types.  The vector and complex check does
not use the previous two macros to enable early folding.

Referenced by loop_cand::analyze_iloop_reduction_var(), can_reassociate_type_p(), convert_mult_to_fma(), convert_to_real_1(), do_hoist_insertion(), eliminate_using_constants(), execute_cse_reciprocals_1(), fold_binary_loc(), fold_binary_op_with_conditional_arg(), fold_cond_expr_with_comparison(), fold_truth_andor_1(), fold_truth_not_expr(), fp_expression_p(), gimple_could_trap_p_1(), complex_mul_pattern::matches(), may_reassociate_p(), maybe_resimplify_conditional_op(), negate_expr_p(), non_rewritable_lvalue_p(), process_assignment(), addsub_pattern::recognize(), record_conditions(), replace_stmt_with_simplification(), avail_exprs_stack::simplify_binary_operation(), simplify_vector_constructor(), split_tree(), ssa_is_replaceable_p(), stmt_could_throw_1_p(), stmt_could_throw_p(), strip_float_extensions(), tree_binary_nonnegative_warnv_p(), tree_could_trap_p(), tree_predict_by_opcode(), try_special_add_to_ops(), use_register_for_decl(), vect_build_slp_tree_2(), vectorizable_induction(), vectorizable_reduction(), visit_phi(), and vn_nary_may_trap().

◆ FLOATN_NX_TYPE_NODE

#define FLOATN_NX_TYPE_NODE ( IDX ) global_trees[TI_FLOATN_NX_TYPE_FIRST + (IDX)]

Referenced by build_common_tree_nodes().

◆ FLOATN_TYPE_NODE

#define FLOATN_TYPE_NODE ( IDX ) global_trees[TI_FLOATN_TYPE_FIRST + (IDX)]

Nodes for particular _FloatN and _FloatNx types in sequence.

◆ FLOATNX_TYPE_NODE

#define FLOATNX_TYPE_NODE ( IDX ) global_trees[TI_FLOATNX_TYPE_FIRST + (IDX)]

◆ FOR_EACH_CALL_EXPR_ARG

#define FOR_EACH_CALL_EXPR_ARG	(	arg,
		iter,
		call )

Value:

for ((arg) = first_call_expr_arg ((call), &(iter)); (arg); \

(arg) = next_call_expr_arg (&(iter)))

first_call_expr_arg

tree first_call_expr_arg(tree exp, call_expr_arg_iterator *iter)

Definition tree.h:5941

Iterate through each argument ARG of CALL_EXPR CALL, using variable ITER
(of type call_expr_arg_iterator) to hold the iteration state.

Referenced by dequeue_and_dump(), dump_generic_node(), expand_builtin(), expand_call(), expression_expensive_p(), and initialize_argument_information().

◆ FOR_EACH_CONST_CALL_EXPR_ARG

#define FOR_EACH_CONST_CALL_EXPR_ARG	(	arg,
		iter,
		call )

Value:

for ((arg) = first_const_call_expr_arg ((call), &(iter)); (arg); \

(arg) = next_const_call_expr_arg (&(iter)))

first_const_call_expr_arg

const_tree first_const_call_expr_arg(const_tree exp, const_call_expr_arg_iterator *iter)

Definition tree.h:5948

Referenced by contains_placeholder_p().

◆ FOR_EACH_CONSTRUCTOR_ELT

#define FOR_EACH_CONSTRUCTOR_ELT	(	V,
		IX,
		INDEX,
		VAL )

Value:

  for (IX = 0; (IX >= vec_safe_length (V)) \
               ? false \
               : (((void) (VAL = (*V)[IX].value)), \
                  (INDEX = (*V)[IX].index), \
                  true); \
       (IX)++)

Iterate through the vector V of CONSTRUCTOR_ELT elements, yielding both
the value of each element (stored within VAL) and its index (stored
within INDEX). IX must be a scratch variable of unsigned integer type.

Referenced by array_size_for_constructor(), categorize_ctor_elements_1(), check_ctz_array(), dequeue_and_dump(), DFS::DFS_write_tree_body(), dump_generic_node(), expand_expr_real_1(), find_constructor_constant_at_offset(), fold_nonarray_ctor_reference(), fold_ternary_loc(), get_array_ctor_element_at_index(), get_initializer_for(), gimplify_init_ctor_eval(), operand_compare::hash_operand(), hash_tree(), print_node(), store_constructor(), verify_gimple_assign_single(), and write_ts_constructor_tree_pointers().

◆ FOR_EACH_CONSTRUCTOR_VALUE

#define FOR_EACH_CONSTRUCTOR_VALUE	(	V,
		IX,
		VAL )

Value:

  for (IX = 0; (IX >= vec_safe_length (V)) \
               ? false \
               : ((VAL = (*(V))[IX].value), \
               true); \
       (IX)++)

Iterate through the vector V of CONSTRUCTOR_ELT elements, yielding the
value of each element (stored within VAL). IX must be a scratch variable
of unsigned integer type.

Referenced by build_vector_from_ctor(), compute_reloc_for_constant(), const_hash_1(), convert_local_reference_stmt(), convert_nonlocal_reference_stmt(), ctor_to_vec(), dwarf2out_decl(), expand_debug_expr(), expand_expr_real_1(), fold(), fold_gimple_assign(), get_constraint_for_1(), gimple_fold_stmt_to_constant_1(), gimplify_expr(), gimplify_init_constructor(), initializer_constant_valid_for_bitfield_p(), initializer_constant_valid_p_1(), initializer_zerop(), output_addressed_constants(), recompute_constructor_flags(), rtl_for_decl_init(), store_constructor(), uniform_vector_p(), valid_gimple_rhs_p(), vect_slp_check_for_roots(), verify_constructor_flags(), and walk_stmt_load_store_addr_ops().

◆ FORCED_LABEL

#define FORCED_LABEL ( NODE ) (LABEL_DECL_CHECK (NODE)->base.side_effects_flag)

In a LABEL_DECL, nonzero means this label had its address taken
and therefore can never be deleted and is a jump target for
computed gotos.

Referenced by can_strub_internally_p(), cleanup_dead_labels(), ipa_icf_gimple::func_checker::compare_gimple_label(), convert_nonlocal_reference_op(), expand_builtin(), expand_label(), find_duplicate(), force_labels_r(), get_loop_body_in_if_conv_order(), gimple_can_merge_blocks_p(), gimple_merge_blocks(), gimplify_expr(), group_case_labels_stmt(), label_rtx(), lower_builtin_setjmp(), make_edges(), mark_nonssa_use(), maybe_dead_abnormal_edge_p(), move_stmt_op(), move_stmt_r(), omp_copy_decl(), optimize_unreachable(), remove_bb(), remove_forwarder_block(), replace_block_by(), stmt_starts_bb_p(), test_nonssa_use(), tree_is_indexable(), and verify_gimple_label().

◆ FOREACH_FUNCTION_ARGS

#define FOREACH_FUNCTION_ARGS	(	FNTYPE,
		TREE,
		ITER )

Value:

  for (function_args_iter_init (&(ITER), (FNTYPE));                     \
       (TREE = function_args_iter_cond (&(ITER))) != NULL_TREE;         \
       function_args_iter_next (&(ITER)))

Loop over all function arguments of FNTYPE.  In each iteration, TREE is set
to the next tree element.  ITER is an instance of function_args_iterator
used to iterate the arguments.

Referenced by builtin_call_nomodifying_p(), go_format_type(), maybe_warn_pass_by_reference(), stdarg_p(), and type_argument_type().

◆ FOREACH_FUNCTION_ARGS_PTR

#define FOREACH_FUNCTION_ARGS_PTR	(	FNTYPE,
		PTR,
		ITER )

Value:

  for (function_args_iter_init (&(ITER), (FNTYPE));                     \
       (PTR = function_args_iter_cond_ptr (&(ITER))) != NULL;           \
       function_args_iter_next (&(ITER)))

Loop over all function arguments of FNTYPE.  In each iteration, PTR is set
to point to the next tree element.  ITER is an instance of
function_args_iterator used to iterate the arguments.

◆ fract_type_node

#define fract_type_node global_trees[TI_FRACT_TYPE]

Referenced by make_or_reuse_fract_type().

◆ FUNC_ADDR_BY_DESCRIPTOR

#define FUNC_ADDR_BY_DESCRIPTOR ( NODE ) (TREE_CHECK (NODE, ADDR_EXPR)->base.default_def_flag)

Referenced by convert_tramp_reference_op().

◆ FUNC_OR_METHOD_CHECK

#define FUNC_OR_METHOD_CHECK ( T ) TREE_CHECK2 (T, FUNCTION_TYPE, METHOD_TYPE)

◆ FUNC_OR_METHOD_TYPE_P

◆ FUNCTION_DECL_DECL_TYPE

#define FUNCTION_DECL_DECL_TYPE ( NODE ) (NODE->function_decl.decl_type)

Macro for direct set and get of function_decl.decl_type.

Referenced by hash_tree(), pack_ts_function_decl_value_fields(), set_function_decl_type(), and unpack_ts_function_decl_value_fields().

◆ FUNCTION_POINTER_TYPE_P

#define FUNCTION_POINTER_TYPE_P ( TYPE ) (POINTER_TYPE_P (TYPE) && TREE_CODE (TREE_TYPE (TYPE)) == FUNCTION_TYPE)

Nonzero if TYPE represents a pointer to function.

Referenced by can_propagate_from().

◆ GCC_IDENT_TO_HT_IDENT

#define GCC_IDENT_TO_HT_IDENT ( NODE ) (&((struct tree_identifier *) (NODE))->id)

Referenced by alloc_node().

◆ GOTO_DESTINATION

#define GOTO_DESTINATION ( NODE ) TREE_OPERAND (GOTO_EXPR_CHECK (NODE), 0)

GOTO_EXPR accessor. This gives access to the label associated with
a goto statement.

Referenced by dump_generic_node(), find_goto_label(), gimplify_cond_expr(), gimplify_expr(), and shortcut_cond_expr().

◆ ha_type_node

#define ha_type_node global_trees[TI_HA_TYPE]

◆ HAS_DECL_ASSEMBLER_NAME_P

#define HAS_DECL_ASSEMBLER_NAME_P ( NODE ) (CODE_CONTAINS_STRUCT (TREE_CODE (NODE), TS_DECL_WITH_VIS))

Return true if NODE is a NODE that can contain a DECL_ASSEMBLER_NAME.
This is true of all DECL nodes except FIELD_DECL.

Referenced by alias_get_name(), create_odr_indicator(), dequeue_and_dump(), dump_decl_name(), find_or_create_vtbl_map_node(), compiler_logical_location::get_internal_name_for_tree(), gimple_decl_printable_name(), need_assembler_name_p(), register_asm_p(), rest_of_decl_compilation(), vtbl_map_get_node(), and wrapup_global_declaration_1().

◆ HAS_RTL_P

#define HAS_RTL_P ( NODE ) (CODE_CONTAINS_STRUCT (TREE_CODE (NODE), TS_DECL_WRTL))

Returns nonzero if NODE is a tree node that can contain RTL.

Referenced by copy_decl_for_dup_finish(), prepare_decl_rtl(), and print_declaration().

◆ hq_type_node

#define hq_type_node global_trees[TI_HQ_TYPE]

◆ HT_IDENT_TO_GCC_IDENT

#define HT_IDENT_TO_GCC_IDENT ( NODE ) ((tree) ((char *) (NODE) - sizeof (struct tree_common)))

Translate a hash table identifier pointer to a tree_identifier
pointer, and vice versa.

Referenced by get_identifier(), get_identifier_with_length(), mark_ident(), maybe_delete_ident(), and maybe_get_identifier().

◆ IDENTIFIER_ANON_P

#define IDENTIFIER_ANON_P ( NODE ) (IDENTIFIER_NODE_CHECK (NODE)->base.private_flag)

Nonzero indicates an IDENTIFIER_NODE that names an anonymous
aggregate, (as created by anon_aggr_name_format).

Referenced by DFS::DFS_write_tree_body(), hash_tree(), make_anon_name(), and write_ts_decl_minimal_tree_pointers().

◆ IDENTIFIER_HASH_VALUE

#define IDENTIFIER_HASH_VALUE ( NODE ) (IDENTIFIER_NODE_CHECK (NODE)->identifier.id.hash_value)

Referenced by vtbl_map_hasher::equal(), vtbl_map_hasher::hash(), libfunc_decl_hasher::hash(), hash_odr_name(), operand_compare::hash_operand(), hash_tree(), init_one_libfunc_visibility(), set_user_assembler_libfunc(), type_hash_canon_hash(), and ipa_icf::sem_item_optimizer::update_hash_by_addr_refs().

◆ IDENTIFIER_LENGTH

#define IDENTIFIER_LENGTH ( NODE ) (IDENTIFIER_NODE_CHECK (NODE)->identifier.id.len)

Define fields and accessors for some special-purpose tree nodes.

Unlike STRING_CST, in C terms this is strlen, not sizeof.

Referenced by asan_emit_stack_protection(), build_string_literal(), canonicalize_attr_name(), cmp_attrib_identifiers(), cgraph_node::create_virtual_clone(), dequeue_and_dump(), dump_fancy_name(), find_same_attribute(), get_edit_distance(), edit_distance_traits< tree >::get_length(), get_strub_mode_from_attr(), go_append_string(), is_attribute_p(), lookup_attribute_by_prefix(), lookup_scoped_attribute_spec(), make_fancy_decl_name(), pp_tree_identifier(), private_lookup_attribute(), private_lookup_attribute(), scan_omp_1_stmt(), special_function_p(), strub_validate_fn_attr_parm(), tm_mangle(), valid_new_delete_pair_p(), and write_identifier().

◆ IDENTIFIER_POINTER

#define IDENTIFIER_POINTER ( NODE ) ((const char *) IDENTIFIER_NODE_CHECK (NODE)->identifier.id.str)

Referenced by add_desc_attribute(), add_discr_value(), gcc_rich_location::add_fixit_misspelled_id(), alias_get_name(), announce_function(), asan_add_global(), asan_emit_stack_protection(), symtab_node::asm_name(), assemble_end_function(), assemble_name_resolve(), attr_namespace_ignored_p(), auto_simd_fail(), base_type_die(), build_string_literal(), build_var(), called_as_built_in(), canonicalize_attr_name(), symbol_table::change_decl_assembler_name(), check_call(), clone_function_name(), clone_function_name(), clone_function_name_numbered(), clone_function_name_numbered(), cmp_attrib_identifiers(), combined_fn_name(), compute_fn_summary(), convert_gimple_call(), convert_nonlocal_reference_op(), copy_function_or_variable(), coverage_begin_function(), coverage_compute_lineno_checksum(), coverage_compute_profile_id(), create_odr_indicator(), create_one_component_var(), create_specialized_node(), cgraph_node::create_version_clone_with_body(), cgraph_node::create_virtual_clone(), symbol_table::decl_assembler_name_equal(), symbol_table::decl_assembler_name_hash(), default_assemble_visibility(), default_elf_asm_named_section(), default_elf_select_rtx_section(), default_tree_printer(), default_unique_section(), delete_vta_debug_insn(), dequeue_and_dump(), do_assemble_alias(), do_assemble_symver(), thunk_info::dump(), symtab_node::dump_base(), dump_fancy_name(), dump_function_header(), dump_function_to_file(), dump_generic_node(), dump_oacc_loop(), dump_odr_type(), dump_var(), dw2_force_const_mem(), dwarf2out_decl(), dwarf2out_register_external_die(), expand_all_functions(), expand_label(), expand_simd_clones(), final_scan_insn_1(), find_or_create_vtbl_map_node(), find_same_attribute(), fold_builtin_alloca_with_align(), gen_block_die(), gen_type_die(), generic_parameter_die(), autofdo::autofdo_source_profile::get_callsite_total_count(), varpool_node::get_constructor(), get_edit_distance(), get_frame_type(), get_function_name(), autofdo::string_table::get_index_by_decl(), compiler_logical_location::get_internal_name_for_tree(), get_name(), get_named_text_section(), get_odr_name_for_type(), edit_distance_traits< tree >::get_string(), get_strub_mode_from_attr(), cgraph_node::get_untransformed_body(), gimple_decl_printable_name(), gimplify_modify_expr(), go_append_decl_name(), go_append_string(), go_format_type(), go_output_fndecl(), go_output_typedef(), go_output_var(), handle_ignored_attributes_option(), id_equal(), access_ref::inform_access(), input_offload_tables(), ipa_comdats(), ipa_impossible_devirt_target(), ipa_odr_summary_write(), ipa_pta_execute(), is_attribute_p(), is_cxa_atexit(), is_pass_explicitly_enabled_or_disabled(), is_ubsan_builtin_p(), lhd_decl_printable_name(), lhd_set_decl_assembler_name(), lookup_attribute_by_prefix(), lookup_scoped_attribute_spec(), lower_oacc_reductions(), lower_omp_critical(), lower_omp_target(), lto_output_node(), lto_output_varpool_node(), make_decl_rtl(), make_dispatcher_decl(), make_fancy_decl_name(), malloc_candidate_p(), member_declared_type(), methods_equal_p(), modified_type_die(), new_delete_mismatch_p(), notice_global_symbol(), ok_for_auto_simd_clone(), omp_check_context_selector(), omp_context_name_list_prop(), omp_context_selector_matches(), omp_runtime_api_call(), operand_compare::operand_equal_p(), optrecord_json_writer::optinfo_to_json(), output_constructor(), pp_tree_identifier(), prefix_name(), print_any_param_name(), print_decl_identifier(), print_insn(), print_node(), print_node_brief(), private_lookup_attribute(), private_lookup_attribute(), process_symver_attribute(), produce_asm(), produce_asm_for_decls(), produce_memory_decl_rtl(), scan_omp_1_stmt(), setjmp_or_longjmp_p(), simd_clone_adjust_argument_types(), simd_clone_mangle(), special_function_p(), strub_validate_fn_attr_parm(), switch_to_comdat_section(), switch_to_eh_frame_section(), tm_malloc_replacement(), tm_mangle(), gdbhooks.TreePrinter::to_string(), gdbhooks.SymtabNodePrinter::to_string(), type_in_anonymous_namespace_p(), ubsan_type_descriptor(), valid_new_delete_pair_p(), symtab_node::verify_base(), verify_bb_vtables(), vtbl_map_get_node(), warn_uninit(), weak_finish(), weak_finish_1(), write_identifier(), and write_symbol().

◆ IDENTIFIER_TRANSPARENT_ALIAS

#define IDENTIFIER_TRANSPARENT_ALIAS ( NODE ) (IDENTIFIER_NODE_CHECK (NODE)->base.deprecated_flag)

Nonzero in an IDENTIFIER_NODE if the name is a local alias, whose
uses are to be substituted for uses of the TREE_CHAINed identifier.

Referenced by symbol_table::change_decl_assembler_name(), symbol_table::compile(), symtab_node::make_decl_local(), optimize_weakref(), ultimate_transparent_alias_target(), and ultimate_transparent_alias_target().

◆ IMPORTED_DECL_ASSOCIATED_DECL

#define IMPORTED_DECL_ASSOCIATED_DECL ( NODE ) (DECL_INITIAL (IMPORTED_DECL_CHECK (NODE)))

Getter of the imported declaration associated to the
IMPORTED_DECL node.

Referenced by print_node().

◆ INDIRECT_REF_P

#define INDIRECT_REF_P ( NODE ) (TREE_CODE (NODE) == INDIRECT_REF)

Nonzero if NODE represents a INDIRECT_REF.  Keep these checks in
ascending code order.

Referenced by build_fold_addr_expr_with_type_loc(), convert_local_omp_clauses(), convert_nonlocal_omp_clauses(), copy_tree_body_r(), decode_addr_const(), dr_analyze_alias(), find_func_clobbers(), fixup_vla_decls(), fold_addr_of_array_ref_difference(), fold_builtin_next_arg(), fold_comparison(), fold_read_from_constant_string(), get_base_loadstore(), get_constraint_for_component_ref(), get_mem_align_offset(), gimple_add_padding_init_for_auto_var(), gimplify_addr_expr(), gimplify_adjust_omp_clauses(), gimplify_adjust_omp_clauses_1(), gimplify_bind_expr(), gimplify_init_ctor_preeval_1(), gimplify_return_expr(), goa_lhs_expr_p(), loc_list_for_address_of_addr_expr_of_indirect_ref(), lower_omp_task_reductions(), lower_reduction_clauses(), lower_send_clauses(), mark_nonssa_use(), object_address_invariant_in_loop_p(), omp_accumulate_sibling_list(), omp_add_variable(), omp_build_struct_sibling_lists(), omp_get_base_pointer(), omp_notice_variable(), prepare_call_arguments(), recompute_tree_invariant_for_addr_expr(), reference_alias_ptr_type_1(), remap_vla_decls(), scan_sharing_clauses(), test_nonssa_use(), transaction_invariant_address_p(), verify_types_in_gimple_reference(), and vt_add_function_parameters().

◆ intDI_type_node

#define intDI_type_node global_trees[TI_INTDI_TYPE]

Referenced by build_common_tree_nodes(), gimple_signed_or_unsigned_type(), and lhd_type_for_size().

◆ integer_minus_one_node

#define integer_minus_one_node global_trees[TI_INTEGER_MINUS_ONE]

Referenced by build_common_tree_nodes(), dump_omp_clause(), expand_oacc_for(), fold_builtin_classify(), get_target_arguments(), gimple_lower_bitint(), instantiate_scev_not(), interpret_rhs_expr(), lower_oacc_private_marker(), lower_omp_for_scan(), oacc_loop_process(), object_sizes_execute(), omp_reduction_init_op(), optimize_spaceship(), optimize_target_teams(), and slsr_process_neg().

◆ integer_one_node

#define integer_one_node global_trees[TI_INTEGER_ONE]

Referenced by add_standard_iv_candidates(), analyze_siv_subscript_cst_affine(), attr_access::array_as_string(), asan_poison_variables(), build_common_tree_nodes(), constant_boolean_node(), create_add_imm_cand(), dr_analyze_indices(), tree_switch_conversion::bit_test_cluster::emit(), execute_omp_device_lower(), expand_omp_for_init_counts(), expand_omp_for_init_vars(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), expand_omp_target(), expand_omp_taskloop_for_inner(), find_taken_edge_cond_expr(), fold_binary_loc(), fold_builtin_classify(), fold_builtin_constant_p(), fold_builtin_unordered_cmp(), fold_comparison(), get_address_cost(), get_descriptor_type(), get_range_strlen_tree(), get_upper_bound_based_on_builtin_expr_with_prob(), gimple_call_alloc_size(), gimplify_adjust_omp_clauses(), gimplify_init_ctor_eval_range(), issue_prefetch_ref(), lower_builtin_setjmp(), lower_omp_for_scan(), lower_omp_ordered(), lower_rec_input_clauses(), make_region_seq(), match_single_bit_test(), move_sese_in_condition(), number_of_iterations_cltz_complement(), number_of_iterations_popcount(), oacc_xform_tile(), omp_extract_for_data(), omp_reduction_init_op(), optimize_spaceship(), preferred_mem_scale_factor(), scan_operand_equal_p(), simplify_using_ranges::simplify_div_or_mod_using_ranges(), slsr_process_cast(), slsr_process_copy(), slsr_process_phi(), store_constructor(), strlen_pass::strxcmp_eqz_result(), update_nonlocal_goto_save_area(), vect_recog_divmod_pattern(), vectorizable_reduction(), and vectorizable_simd_clone_call().

◆ integer_ptr_type_node

#define integer_ptr_type_node global_trees[TI_INTEGER_PTR_TYPE]

Referenced by build_common_tree_nodes().

◆ integer_three_node

#define integer_three_node global_trees[TI_INTEGER_THREE]

Referenced by build_common_tree_nodes(), expand_builtin_prefetch(), and issue_prefetch_ref().

◆ integer_type_node

#define integer_type_node integer_types[itk_int]

Referenced by add_async_clauses_and_wait(), add_standard_iv_candidates(), add_wait(), analyze_subscript_affine_affine(), asan_emit_stack_protection(), asan_expand_poison_ifn(), asan_init_shadow_ptr_types(), asan_poison_variable(), assign_filter_values(), attempt_builtin_powi(), build_array_type_1(), build_asan_poison_call_expr(), build_check_stmt(), build_cltz_expr(), build_common_builtin_nodes(), build_common_tree_nodes(), build_complex_type(), build_cxa_atexit_decl(), build_function_type(), build_int_cst(), build_libfunc_function_visibility(), build_personality_function(), build_popcount_expr(), build_predict_expr(), build_tm_abort_call(), compare_by_pieces(), cond_removal_in_builtin_zero_pattern(), constant_boolean_node(), convert_to_integer_1(), copy_bb(), function_reader::create_function(), create_parallel_loop(), ctf_debug_init(), default_ref_may_alias_errno(), define_builtin_macros_for_lp64(), define_builtin_macros_for_type_sizes(), do_mpfr_lgamma_r(), do_mpfr_remquo(), dump_generic_node(), emit_block_cmp_via_loop(), execute_omp_device_lower(), expand_DEFERRED_INIT(), expand_oacc_collapse_init(), expand_oacc_for(), expand_omp_atomic_cas(), expand_omp_atomic_load(), expand_omp_atomic_pipeline(), expand_omp_atomic_store(), expand_omp_for_static_nochunk(), expand_omp_target(), expand_sjlj_dispatch_table(), expand_task_call(), expand_unop(), expr_expected_value_1(), field_type(), fold_builtin_atomic_compare_exchange(), fold_builtin_bit_query(), fold_builtin_classify(), fold_builtin_classify_type(), fold_builtin_fpclassify(), fold_builtin_frexp(), fold_builtin_interclass_mathfn(), fold_builtin_isascii(), fold_builtin_isdigit(), fold_builtin_iseqsig(), fold_builtin_memcmp(), fold_builtin_strpbrk(), fold_builtin_toascii(), fold_strstr_to_strncmp(), force_expr_to_var_cost(), gen_counter_update(), gen_one_condition(), generate_memset_builtin(), get_target_argument_identifier_1(), get_target_argument_value(), get_target_arguments(), get_typenode_from_name(), gimple_add_init_for_auto_var(), gimple_builtin_call_types_compatible_p(), gimple_expand_vec_cond_expr(), gimple_fold_builtin_fprintf(), gimple_fold_builtin_fputs(), gimple_fold_builtin_printf(), gimple_fold_builtin_string_compare(), gimple_fold_builtin_strstr(), gimple_gen_interval_profiler(), gimple_init_gcov_profiler(), gimple_signed_or_unsigned_type(), init_eh(), initialize_argument_information(), initialize_sanitizer_builtins(), instrument_decisions(), instrument_nonnull_arg(), lhd_simulate_enum_decl(), lhd_type_for_size(), loc_list_from_tree_1(), lower_builtin_posix_memalign(), lower_eh_constructs_2(), lower_eh_dispatch(), lower_lastprivate_clauses(), lower_oacc_head_mark(), lower_oacc_head_tail(), lower_oacc_loop_marker(), lower_oacc_private_marker(), lower_oacc_reductions(), lower_omp_for_scan(), lower_omp_master(), lower_omp_ordered(), lower_omp_scan(), lower_omp_target(), lower_omp_task_reductions(), lower_rec_input_clauses(), lower_resx(), lower_try_finally_switch(), make_range(), make_trait_selector(), make_trait_set_selector(), merge_ranges(), move_sese_region_to_fn(), move_stmt_eh_region_tree_nr(), number_of_iterations_cltz(), number_of_iterations_cltz_complement(), number_of_iterations_popcount(), oacc_build_routine_dims(), oacc_dim_call(), oacc_entry_exit_single_gang(), oacc_thread_numbers(), oacc_validate_dims(), omp_clause_aligned_alignment(), optimize_range_tests_to_bit_test(), optimize_spaceship(), optimize_target_teams(), function_reader::parse_mem_expr(), prepare_cmp_insn(), range_check_type(), recognize_single_bit_test(), remap_eh_region_tree_nr(), scan_omp_simd(), set_storage_via_libcall(), simd_clone_compute_base_data_type(), simplify_count_trailing_zeroes(), simplify_using_ranges::simplify_div_or_mod_using_ranges(), sjlj_emit_dispatch_table(), sjlj_emit_function_enter(), sjlj_mark_call_sites(), store_constructor(), thunk_adjust(), transform_add_to_multiply(), tree_builtin_call_types_compatible_p(), tree_coverage_counter_addr(), tree_coverage_counter_ref(), ubsan_expand_vptr_ifn(), vect_get_loop_mask(), vect_recog_ctz_ffs_pattern(), vect_recog_popcount_clz_ctz_ffs_pattern(), vect_recog_rotate_pattern(), vectorizable_induction(), version_loop_by_alias_check(), and version_loop_for_if_conversion().

◆ integer_zero_node

#define integer_zero_node global_trees[TI_INTEGER_ZERO]

Referenced by add_standard_iv_candidates(), add_wait(), adjust_region_code_walk_stmt_fn(), affine_fn_op(), affine_fn_univar(), alloca_call_type(), alloca_type_and_limit::alloca_type_and_limit(), analyze_miv_subscript(), analyze_overlapping_iterations(), analyze_siv_subscript_cst_affine(), analyze_subscript_affine_affine(), analyze_ziv_subscript(), array_ref_low_bound(), build_common_tree_nodes(), build_instrumentation_call(), build_string_literal(), build_zero_cst(), build_zero_vector(), cheap_array_ref_low_bound(), rt_bb_visited::check(), compute_overlap_steps_for_affine_1_2(), compute_overlap_steps_for_affine_univar(), constant_boolean_node(), constant_byte_string(), convert_to_complex_1(), create_add_ssa_cand(), determine_base_object_1(), do_store_flag(), dom_opt_dom_walker::dom_opt_dom_walker(), dr_analyze_indices(), dump_omp_clause(), tree_switch_conversion::bit_test_cluster::emit(), execute_early_expand_coro_ifns(), execute_omp_device_lower(), expand_builtin_bzero(), expand_builtin_prefetch(), expand_DEFERRED_INIT(), expand_function_start(), expand_ifn_atomic_bit_test_and(), expand_ifn_atomic_op_fetch_cmp_0(), expand_oacc_collapse_init(), expand_oacc_for(), expand_omp_for(), expand_omp_target(), expand_task_call(), extract_cond_operands(), extract_muldiv_1(), finalize_nesting_tree_1(), find_taken_edge_cond_expr(), fold_binary_loc(), fold_builtin_1(), fold_builtin_bit_query(), fold_builtin_classify(), fold_builtin_constant_p(), fold_builtin_frexp(), fold_builtin_isascii(), fold_builtin_memcmp(), fold_builtin_next_arg(), fold_builtin_strpbrk(), fold_builtin_unordered_cmp(), fold_comparison(), fold_convert_loc(), fold_ignored_result(), fold_range_test(), get_stridx(), gimple_fold_builtin_bzero(), gimple_fold_builtin_fputs(), gimple_fold_builtin_strchr(), gimple_fold_builtin_string_compare(), gimple_fold_builtin_strstr(), gimple_fold_call(), gimple_merge_blocks(), gimple_stringops_transform(), gimplify_modify_expr_to_memset(), gimplify_variable_sized_compare(), strlen_pass::handle_builtin_string_cmp(), strlen_pass::handle_integral_assign(), initialize_argument_information(), insert_trap(), instrument_func_entry(), instrument_object_size(), issue_prefetch_ref(), jump_threader::jump_threader(), lower_builtin_posix_memalign(), lower_lastprivate_clauses(), lower_oacc_head_tail(), lower_oacc_private_marker(), lower_oacc_reductions(), lower_omp_for_scan(), lower_omp_master(), lower_omp_ordered(), lower_omp_task_reductions(), lower_omp_taskreg(), lower_rec_input_clauses(), lower_transaction(), make_range_step(), match_single_bit_test(), move_sese_in_condition(), new_oacc_loop(), oacc_entry_exit_single_gang(), oacc_set_fn_attrib(), oacc_thread_numbers(), omp_extract_for_data(), omp_find_combined_for(), omp_find_scan(), optimize_memcpy(), optimize_spaceship(), optimize_stack_restore(), optimize_stdarg_builtin(), dom_opt_dom_walker::optimize_stmt(), optimize_target_teams(), output_constructor(), output_constructor_bitfield(), push_to_worklist(), recognize_single_bit_test(), scan_omp_simd(), scan_omp_simd_scan(), scan_sharing_clauses(), size_in_bytes_loc(), stmt_kills_ref_p(), stmt_uses_0_or_null_in_undefined_way(), strlen_pass::strxcmp_eqz_result(), tree_transform_and_unroll_loop(), try_casesi(), ubsan_instrument_float_cast(), vec_cst_ctor_to_array(), vectorizable_simd_clone_call(), version_loop_for_if_conversion(), warn_implicit_fallthrough_r(), and warn_switch_unreachable_and_auto_init_r().

◆ INTEGRAL_TYPE_P

#define INTEGRAL_TYPE_P ( TYPE )

Value:

  (TREE_CODE (TYPE) == ENUMERAL_TYPE  \
   || TREE_CODE (TYPE) == BOOLEAN_TYPE \
   || TREE_CODE (TYPE) == INTEGER_TYPE \
   || TREE_CODE (TYPE) == BITINT_TYPE)

Nonzero if TYPE represents an integral type.  Note that we do not
include COMPLEX types here.  Keep these checks in ascending code
order.

Referenced by add_iv_candidate_for_biv(), add_scope_conflicts_2(), address_compare(), alloc_object_size(), tree_vector_builder::allow_steps_p(), analyze_access_subtree(), analyze_and_compute_bitwise_induction_effect(), apply_return_prediction(), ana::call_details::arg_is_integral_p(), arith_overflow_check_p(), tree_switch_conversion::switch_conversion::array_value_type(), attempt_builtin_powi(), bb_no_side_effects_p(), find_candidates_dom_walker::before_dom_children(), bitfields_to_lower_p(), bitmask_inv_cst_vector_p(), build_complex_type(), build_index_vector(), builtin_mathfn_code(), format_helper::can_represent_integral_type_p(), canonicalize_component_ref(), canonicalize_loop_ivs(), ccp_finalize(), strlen_pass::check_and_optimize_stmt(), chrec_apply(), chrec_evaluate(), chrec_fold_multiply(), chrec_fold_plus_1(), classify_builtin_st(), compare_access_positions(), compare_values_warnv(), computable_teams_clause(), compute_distributive_range(), cond_removal_in_builtin_zero_pattern(), constant_byte_string(), constant_type(), convert_mult_to_fma(), convert_plusminus_to_widen(), decode_field_reference(), derive_constant_upper_bound_ops(), edge_info::derive_equivalences(), determine_set_costs(), determine_value_range(), do_narrow(), dr_step_indicator(), dump_generic_node(), dump_ternary_rhs(), eliminate_dom_walker::eliminate_stmt(), evaluate_stmt(), expand_builtin_atomic_is_lock_free(), expand_case(), expand_expr_force_mode(), expand_expr_real_1(), expand_expr_real_2(), expand_fn_using_insn(), expand_omp_atomic(), expand_omp_atomic_cas(), expand_omp_atomic_pipeline(), expand_vector_addition(), expand_vector_conversion(), expand_vector_operations_1(), expr_not_equal_to(), extract_muldiv_1(), factor_out_conditional_operation(), final_range_test_p(), final_value_replacement_loop(), find_conditions(), find_var_cmp_const(), fold_binary_loc(), fold_bit_and_mask(), fold_builtin_expect(), fold_comparison(), fold_const_aggregate_ref_1(), fold_const_call_1(), fold_const_vec_convert(), fold_convert_const(), fold_convert_loc(), fold_convertible_p(), fold_negate_expr_1(), fold_nonarray_ctor_reference(), fold_range_test(), fold_using_range::fold_stmt(), fold_to_nonsharp_ineq_using_bound(), fold_truth_andor_1(), fold_unary_loc(), fold_view_convert_vector_encoding(), forward_propagate_addr_expr_1(), forward_propagate_into_gimple_cond(), fully_constant_vn_reference_p(), get_initial_def_for_reduction(), get_inner_reference(), get_iv(), get_maxval_strlen(), get_min_precision(), get_narrower(), get_offset_range(), get_range_pos_neg(), get_range_strlen_tree(), get_related_vectype_for_scalar_type(), get_size_range(), get_ubsan_type_info_for_type(), get_value_for_expr(), gimple_bitwise_inverted_equal_p(), gimple_build_round_up(), gimple_builtin_call_types_compatible_p(), gimple_canonical_types_compatible_p(), gimple_could_trap_p_1(), gimple_divmod_fixed_value_transform(), gimple_divmod_values_to_profile(), gimple_fold_builtin_memset(), gimple_lower_bitint(), gimple_mod_pow2_value_transform(), gimple_mod_subtract_transform(), gimple_signed_or_unsigned_type(), gimplify_expr(), gimplify_omp_atomic(), gimplify_omp_for(), gimplify_type_sizes(), if_convertible_gimple_assign_stmt_p(), infer_loop_bounds_from_signedness(), init_range_entry(), initializer_constant_valid_p_1(), insert_into_preds_of_block(), insert_trap(), instrument_mem_region_access(), instrument_si_overflow(), int_binop_types_match_p(), interpret_rhs_expr(), ipcp_update_vr(), is_handled_procedure_type(), is_strlen_related_p(), iv_can_overflow_p(), simplify_using_ranges::legacy_fold_cond_overflow(), lhd_omp_scalar_p(), hybrid_and_operator::lhs_op1_relation(), loc_list_from_tree_1(), lower_omp_target(), lower_rec_simd_input_clauses(), make_bit_field_ref(), make_range_step(), match_arith_overflow(), match_single_bit_test(), match_uaddc_usubc(), maybe_canonicalize_comparison_1(), maybe_optimize_guarding_check(), maybe_optimize_range_tests(), maybe_resimplify_conditional_op(), maybe_rewrite_mem_ref_base(), maybe_set_strlen_range(), maybe_update_mem_ref_hash_table(), minmax_replacement(), move_computations_worker(), narrowing_initializer_constant_valid_p(), native_encode_initializer(), native_interpret_aggregate(), needs_fold_left_reduction_p(), negate_expr_p(), non_rewritable_lvalue_p(), non_rewritable_mem_ref_base(), nop_conversion_for_offset_p(), odr_types_equivalent_p(), omp_reduction_init_op(), hybrid_and_operator::op1_range(), hybrid_or_operator::op1_range(), hybrid_and_operator::op2_range(), hybrid_or_operator::op2_range(), operator_not_equal::operand_check_p(), operator_equal::operand_check_p(), operator_lt::operand_check_p(), operator_le::operand_check_p(), operator_gt::operand_check_p(), operator_ge::operand_check_p(), operand_equal_for_comparison_p(), operation_no_trapping_overflow(), optab_for_tree_code(), optimize_atomic_op_fetch_cmp_0(), optimize_range_tests_1(), optimize_range_tests_to_bit_test(), optimize_range_tests_var_bound(), optimize_vector_load(), overflow_comparison_p_1(), parloops_needs_fold_left_reduction_p(), parm_object_size(), predicate_statements(), prepare_call_arguments(), print_int_bound(), print_node(), process_assignment(), process_bb(), propagate_bits_across_jump_function(), propagate_vr_across_jump_function(), ptrofftype_p(), vn_walk_cb_data::push_partial_def(), range_fits_type_p(), range_predecessor(), range_successor(), reassociate_bb(), record_biv_for_address_use(), record_nonwrapping_iv(), refine_bounds_using_guard(), refine_value_range_using_guard(), replace_phi_edge_with_variable(), return_prediction(), scan_operand_equal_p(), scev_analyzable_p(), scev_var_range_cant_overflow(), set_strlen_range(), irange::set_varying(), sign_bit_p(), signed_or_unsigned_type_for(), simd_clone_adjust(), simd_clone_adjust_argument_types(), simd_clone_adjust_return_type(), simple_integer_narrowing(), simple_iv_with_niters(), simplify_using_ranges::simplify(), simplify_builtin_call(), simplify_using_ranges::simplify_casted_compare(), simplify_using_ranges::simplify_compare_assign_using_ranges_1(), simplify_using_ranges::simplify_compare_using_ranges_1(), jump_threader::simplify_control_stmt_condition(), simplify_conversion_using_ranges(), simplify_gimple_switch(), simplify_peeled_chrec(), simplify_rotate(), simplify_using_ranges::simplify_truth_ops_using_ranges(), size_must_be_zero_p(), sort_and_splice_var_accesses(), spaceship_replacement(), split_constant_offset(), split_constant_offset_1(), ssa_name_has_boolean_range(), stmt_could_throw_1_p(), store_expr(), store_field(), subrange_type_for_debug_p(), irange::supports_p(), transform_add_to_multiply(), loop_distribution::transform_reduction_loop(), tree_builtin_call_types_compatible_p(), tree_could_trap_p(), tree_ctz(), tree_expr_nonzero_warnv_p(), tree_nonzero_bits(), tree_nop_conversion_p(), tree_single_nonzero_warnv_p(), tree_unary_nonnegative_warnv_p(), type_conversion_p(), type_like_member_ptr_p(), uaddc_cast(), hybrid_and_operator::update_bitmask(), hybrid_or_operator::update_bitmask(), hybrid_min_operator::update_bitmask(), hybrid_max_operator::update_bitmask(), update_range_test(), useless_type_conversion_p(), valid_fixed_convert_types_p(), valid_gimple_rhs_p(), validate_arg(), value_replacement(), irange::varying_compatible_p(), vect_build_slp_tree_2(), vect_check_gather_scatter(), vect_create_constant_vectors(), vect_find_stmt_data_reference(), vect_init_vector(), vect_is_extending_load(), vect_is_integer_truncation(), vect_is_nonlinear_iv_evolution(), vect_is_simple_cond(), vect_is_simple_iv_evolution(), vect_look_through_possible_promotion(), vect_narrowable_type_p(), vect_recog_average_pattern(), vect_recog_bit_insert_pattern(), vect_recog_bitfield_ref_pattern(), vect_recog_bool_pattern(), vect_recog_cast_forwprop_pattern(), vect_recog_ctz_ffs_pattern(), vect_recog_mask_conversion_pattern(), vect_recog_mixed_size_cond_pattern(), vect_recog_mulhs_pattern(), vect_recog_mult_pattern(), vect_recog_popcount_clz_ctz_ffs_pattern(), vect_recog_rotate_pattern(), vect_recog_vector_vector_shift_pattern(), vect_recog_widen_abd_pattern(), vect_widened_op_tree(), vectorizable_assignment(), vectorizable_conversion(), vectorizable_induction(), vectorizable_nonlinear_induction(), vectorizable_operation(), vectorizable_reduction(), verify_gimple_assign_binary(), verify_gimple_assign_ternary(), verify_gimple_assign_unary(), verify_gimple_comparison(), verify_gimple_switch(), verify_ssa(), verify_type(), verify_types_in_gimple_reference(), visit_nary_op(), vn_hash_type(), vn_nary_may_trap(), vn_reference_eq(), vn_reference_lookup_3(), vt_add_function_parameter(), hybrid_and_operator::wi_fold(), hybrid_or_operator::wi_fold(), hybrid_min_operator::wi_fold(), hybrid_max_operator::wi_fold(), and zero_one_minusone().

◆ intHI_type_node

#define intHI_type_node global_trees[TI_INTHI_TYPE]

Referenced by build_common_tree_nodes(), gimple_signed_or_unsigned_type(), and lhd_type_for_size().

◆ intQI_type_node

#define intQI_type_node global_trees[TI_INTQI_TYPE]

Referenced by build_common_tree_nodes(), gimple_signed_or_unsigned_type(), lhd_type_for_size(), vect_gen_loop_len_mask(), vectorizable_call(), vectorizable_condition(), vectorizable_load(), vectorizable_operation(), vectorizable_store(), and vectorize_fold_left_reduction().

◆ intSI_type_node

#define intSI_type_node global_trees[TI_INTSI_TYPE]

Referenced by build_common_tree_nodes(), gimple_signed_or_unsigned_type(), and lhd_type_for_size().

◆ intTI_type_node

#define intTI_type_node global_trees[TI_INTTI_TYPE]

Referenced by build_common_tree_nodes(), gimple_signed_or_unsigned_type(), and lhd_type_for_size().

◆ IS_EMPTY_STMT

#define IS_EMPTY_STMT ( NODE )

Value:

                                 (TREE_CODE (NODE) == NOP_EXPR \
                                 && VOID_TYPE_P (TREE_TYPE (NODE)) \
                                 && integer_zerop (TREE_OPERAND (NODE, 0)))

Define fields and accessors for some nodes that represent expressions.

Nonzero if NODE is an empty statement (NOP_EXPR <0>).

Referenced by dump_generic_node(), gimplify_expr(), is_gimple_stmt(), omit_one_operand_loc(), and voidify_wrapper_expr().

◆ IS_EXPR_CODE_CLASS

#define IS_EXPR_CODE_CLASS ( CLASS ) ((CLASS) >= tcc_reference && (CLASS) <= tcc_expression)

Returns nonzero iff CLASS is the tree-code class of an
expression.

Referenced by aff_combination_expand(), copy_tree_r(), data_ref_compare_tree(), dequeue_and_dump(), expand_simple_operations(), extract_single_var_from_expr(), find_deriving_biv_for_expr(), fold(), fold_binary_loc(), fold_ternary_loc(), fold_unary_loc(), gimple_resimplify1(), gimple_resimplify2(), gimple_resimplify3(), operand_compare::hash_operand(), make_range(), mark_all_vars_used_1(), tree_block(), and walk_tree_1().

◆ IS_TYPE_OR_DECL_P

#define IS_TYPE_OR_DECL_P ( NODE ) (TYPE_P (NODE) || DECL_P (NODE))

Returns nonzero iff NODE represents a type or declaration.

Referenced by convert_local_reference_op(), convert_nonlocal_reference_op(), convert_tramp_reference_op(), diagnose_tm_1(), discover_nonconstant_array_refs_r(), find_decl_expr(), find_released_ssa_name(), find_ssaname(), find_trapping_overflow(), finish_taskreg_remap(), gimplify_init_ctor_preeval_1(), lower_omp_regimplify_operands_p(), lower_omp_regimplify_p(), mark_all_vars_used_1(), record_reference(), replace_block_vars_by_duplicates_1(), tree_is_indexable(), tree_node_can_be_shared(), unshare_and_remap_1(), and update_vtable_references().

◆ KEEP_QUAL_ADDR_SPACE

#define KEEP_QUAL_ADDR_SPACE ( X ) ((X) & 0xFF00)

Only keep the address space out of the qualifiers and discard the other
qualifiers.

Referenced by get_related_vectype_for_scalar_type().

◆ LABEL_DECL_UID

#define LABEL_DECL_UID ( NODE ) (LABEL_DECL_CHECK (NODE)->label_decl.label_decl_uid)

A numeric unique identifier for a LABEL_DECL.  The UID allocation is
dense, unique within any one function, and may be used to index arrays.
If the value is -1, then no UID has been assigned.

Referenced by tree_switch_conversion::case_bit_test::cmp(), copy_decl_no_change(), dump_decl_name(), dump_generic_node(), gimple_set_bb(), hash_tree(), label_to_block(), make_node(), move_block_to_fn(), new_label_mapper(), print_node(), print_node_brief(), unpack_ts_decl_common_value_fields(), and verify_gimple_label().

◆ LABEL_EXPR_LABEL

#define LABEL_EXPR_LABEL ( NODE ) TREE_OPERAND (LABEL_EXPR_CHECK (NODE), 0)

LABEL_EXPR accessor. This gives access to the label associated with
the given label expression.

Referenced by gimplify_expr(), gimplify_label_expr(), and shortcut_cond_expr().

◆ long_accum_type_node

#define long_accum_type_node global_trees[TI_LACCUM_TYPE]

Referenced by make_or_reuse_accum_type().

◆ long_double_ptr_type_node

#define long_double_ptr_type_node global_trees[TI_LONG_DOUBLE_PTR_TYPE]

Referenced by build_common_tree_nodes().

◆ long_double_type_node

#define long_double_type_node global_trees[TI_LONG_DOUBLE_TYPE]

Referenced by build_common_tree_nodes(), build_tm_load(), build_tm_store(), define_builtin_macros_for_type_sizes(), excess_precision_type(), fold_const_call_1(), gen_ctf_base_type(), get_no_error_domain(), long_double_as_float128(), mathfn_built_in_2(), tm_log_emit_stmt(), and ubsan_type_descriptor().

◆ long_fract_type_node

#define long_fract_type_node global_trees[TI_LFRACT_TYPE]

Referenced by make_or_reuse_fract_type().

◆ long_integer_type_node

◆ long_long_accum_type_node

#define long_long_accum_type_node global_trees[TI_LLACCUM_TYPE]

Referenced by make_or_reuse_accum_type().

◆ long_long_fract_type_node

#define long_long_fract_type_node global_trees[TI_LLFRACT_TYPE]

Referenced by make_or_reuse_fract_type().

◆ long_long_integer_type_node

#define long_long_integer_type_node integer_types[itk_long_long]

Referenced by add_standard_iv_candidates(), build_cltz_expr(), build_common_tree_nodes(), build_complex_type(), build_popcount_expr(), cond_removal_in_builtin_zero_pattern(), convert_to_integer_1(), default_cxx_guard_type(), define_builtin_macros_for_type_sizes(), expand_omp_for_init_vars(), expand_omp_for_static_nochunk(), fold_builtin_bit_query(), get_typenode_from_name(), gimple_signed_or_unsigned_type(), and lhd_type_for_size().

◆ long_long_unsigned_type_node

#define long_long_unsigned_type_node integer_types[itk_unsigned_long_long]

Referenced by build_cltz_expr(), build_common_tree_nodes(), build_complex_type(), build_personality_function(), build_popcount_expr(), dump_generic_node(), expand_omp_for(), expand_omp_for_generic(), expand_omp_for_init_vars(), expand_omp_taskloop_for_inner(), expand_omp_taskloop_for_outer(), expand_task_call(), fold_builtin_bit_query(), get_typenode_from_name(), gimple_signed_or_unsigned_type(), lhd_type_for_size(), and omp_extract_for_data().

◆ long_unsigned_type_node

#define long_unsigned_type_node integer_types[itk_unsigned_long]

Referenced by build_common_tree_nodes(), build_complex_type(), dump_generic_node(), fold_builtin_bit_query(), get_typenode_from_name(), gimple_signed_or_unsigned_type(), and lhd_type_for_size().

◆ LOOP_EXPR_BODY

#define LOOP_EXPR_BODY ( NODE ) TREE_OPERAND_CHECK_CODE (NODE, LOOP_EXPR, 0)

In a LOOP_EXPR node.

Referenced by dump_generic_node(), and gimplify_loop_expr().

◆ main_identifier_node

#define main_identifier_node global_trees[TI_MAIN_IDENTIFIER]

◆ MAIN_NAME_P

#define MAIN_NAME_P ( NODE ) (IDENTIFIER_NODE_CHECK (NODE) == main_identifier_node)

Referenced by cgraph_externally_visible_p(), compute_function_frequency(), create_function_info_for(), execute_split_functions(), gen_call_used_regs_seq(), ipa_propagate_frequency_1(), and ipa_icf::sem_item_optimizer::merge_classes().

◆ MARK_TS_BASE

#define MARK_TS_BASE ( C ) (tree_contains_struct[C][TS_BASE] = true)

Macros for initializing `tree_contains_struct'.

Referenced by initialize_tree_contains_struct().

◆ MARK_TS_COMMON

#define MARK_TS_COMMON ( C )

Value:

(MARK_TS_TYPED (C), \

tree_contains_struct[C][TS_COMMON] = true)

tree_contains_struct

bool tree_contains_struct[MAX_TREE_CODES][64]

Definition tree.cc:234

MARK_TS_TYPED

#define MARK_TS_TYPED(C)

Definition tree.h:152

Referenced by initialize_tree_contains_struct().

◆ MARK_TS_DECL_COMMON

#define MARK_TS_DECL_COMMON ( C )

Value:

(MARK_TS_DECL_MINIMAL (C), \

tree_contains_struct[C][TS_DECL_COMMON] = true)

MARK_TS_DECL_MINIMAL

#define MARK_TS_DECL_MINIMAL(C)

Definition tree.h:172

Referenced by initialize_tree_contains_struct().

◆ MARK_TS_DECL_MINIMAL

#define MARK_TS_DECL_MINIMAL ( C )

Value:

(MARK_TS_COMMON (C), \

tree_contains_struct[C][TS_DECL_MINIMAL] = true)

MARK_TS_COMMON

#define MARK_TS_COMMON(C)

Definition tree.h:156

Referenced by initialize_tree_contains_struct().

◆ MARK_TS_DECL_NON_COMMON

#define MARK_TS_DECL_NON_COMMON ( C )

Value:

(MARK_TS_DECL_WITH_VIS (C), \

tree_contains_struct[C][TS_DECL_NON_COMMON] = true)

MARK_TS_DECL_WITH_VIS

#define MARK_TS_DECL_WITH_VIS(C)

Definition tree.h:184

Referenced by initialize_tree_contains_struct().

◆ MARK_TS_DECL_WITH_VIS

#define MARK_TS_DECL_WITH_VIS ( C )

Value:

(MARK_TS_DECL_WRTL (C), \

tree_contains_struct[C][TS_DECL_WITH_VIS] = true)

MARK_TS_DECL_WRTL

#define MARK_TS_DECL_WRTL(C)

Definition tree.h:180

Referenced by initialize_tree_contains_struct().

◆ MARK_TS_DECL_WRTL

#define MARK_TS_DECL_WRTL ( C )

Value:

(MARK_TS_DECL_COMMON (C), \

tree_contains_struct[C][TS_DECL_WRTL] = true)

MARK_TS_DECL_COMMON

#define MARK_TS_DECL_COMMON(C)

Definition tree.h:176

Referenced by initialize_tree_contains_struct().

◆ MARK_TS_EXP

#define MARK_TS_EXP ( C )

Value:

(MARK_TS_TYPED (C), \

tree_contains_struct[C][TS_EXP] = true)

◆ MARK_TS_TYPE_COMMON

#define MARK_TS_TYPE_COMMON ( C )

Value:

(MARK_TS_COMMON (C), \

tree_contains_struct[C][TS_TYPE_COMMON] = true)

Referenced by initialize_tree_contains_struct().

◆ MARK_TS_TYPE_NON_COMMON

#define MARK_TS_TYPE_NON_COMMON ( C )

Value:

(MARK_TS_TYPE_WITH_LANG_SPECIFIC (C), \

tree_contains_struct[C][TS_TYPE_NON_COMMON] = true) \

MARK_TS_TYPE_WITH_LANG_SPECIFIC

#define MARK_TS_TYPE_WITH_LANG_SPECIFIC(C)

Definition tree.h:164

◆ MARK_TS_TYPE_WITH_LANG_SPECIFIC

#define MARK_TS_TYPE_WITH_LANG_SPECIFIC ( C )

Value:

(MARK_TS_TYPE_COMMON (C), \

tree_contains_struct[C][TS_TYPE_WITH_LANG_SPECIFIC] = true)

MARK_TS_TYPE_COMMON

#define MARK_TS_TYPE_COMMON(C)

Definition tree.h:160

Referenced by initialize_tree_contains_struct().

◆ MARK_TS_TYPED

#define MARK_TS_TYPED ( C )

Value:

(MARK_TS_BASE (C), \

tree_contains_struct[C][TS_TYPED] = true)

MARK_TS_BASE

#define MARK_TS_BASE(C)

Definition tree.h:149

Referenced by initialize_tree_contains_struct().

◆ MAX_INIT_PRIORITY

#define MAX_INIT_PRIORITY 65535

The maximum allowed initialization priority.

Referenced by get_cdtor_priority_section().

◆ MAX_RESERVED_INIT_PRIORITY

#define MAX_RESERVED_INIT_PRIORITY 100

The largest priority value reserved for use by system runtime
libraries.

Referenced by asan_finish_file(), build_gcov_exit_decl(), build_init_ctor(), hwasan_finish_file(), and tsan_finish_file().

◆ MAY_HAVE_DEBUG_BIND_STMTS

#define MAY_HAVE_DEBUG_BIND_STMTS flag_var_tracking_assignments

Nonzero if gimple_debug_bind_p() (and thus
gimple_debug_source_bind_p()) may possibly hold.

Referenced by adjust_debug_stmts(), adjust_phi_and_debug_stmts(), adjust_vec_debug_stmts(), analyze_access_subtree(), generate_loops_for_partition(), gimple_merge_blocks(), gimple_replace_ssa_lhs(), input_function(), insert_debug_temp_for_var_def(), insert_debug_temps_for_defs(), ipa_param_adjustments::modify_call(), num_imm_uses(), propagate_threaded_block_debug_into(), reassoc_remove_stmt(), release_ssa_name_fn(), remove_dead_stmt(), remove_unused_ivs(), reset_debug_uses(), sese_insert_phis_for_liveouts(), slpeel_tree_duplicate_loop_to_edge_cfg(), spaceship_replacement(), split_function(), tail_merge_optimize(), target_for_debug_bind(), tree_function_versioning(), value_replacement(), vect_do_peeling(), vect_transform_loop(), and vect_transform_loop_stmt().

◆ MAY_HAVE_DEBUG_MARKER_STMTS

#define MAY_HAVE_DEBUG_MARKER_STMTS debug_nonbind_markers_p

Nonzero if gimple_debug_nonbind_marker_p() may possibly hold.

Referenced by allocate_struct_function(), input_function(), lower_function_body(), lower_stmt(), and make_blocks().

◆ MAY_HAVE_DEBUG_STMTS

#define MAY_HAVE_DEBUG_STMTS (MAY_HAVE_DEBUG_MARKER_STMTS || MAY_HAVE_DEBUG_BIND_STMTS)

Nonzero if is_gimple_debug() may possibly hold.

Referenced by ipa_param_body_adjustments::common_initialization(), ipa_param_body_adjustments::mark_dead_statements(), move_debug_stmts_from_forwarder(), ipa_param_body_adjustments::reset_debug_stmts(), and ssa_create_duplicates().

◆ MR_DEPENDENCE_BASE

#define MR_DEPENDENCE_BASE ( NODE ) (TREE_CHECK2 (NODE, MEM_REF, TARGET_MEM_REF)->base.u.dependence_info.base)

Referenced by ao_ref_init_from_vn_reference(), clear_dependence_clique(), ao_compare::compare_ao_refs(), copy_ref_info(), copy_reference_ops_from_ref(), copy_tree_body_r(), create_component_ref_by_pieces_1(), dr_analyze_indices(), dr_may_alias_p(), dump_mem_ref(), maybe_set_dependence_info(), operand_compare::operand_equal_p(), refs_may_alias_p_2(), remap_gimple_op_r(), streamer_read_tree_bitfields(), streamer_write_tree_bitfields(), vect_copy_ref_info(), and visit_loadstore().

◆ MR_DEPENDENCE_CLIQUE

◆ NAMELIST_DECL_ASSOCIATED_DECL

#define NAMELIST_DECL_ASSOCIATED_DECL ( NODE ) (DECL_INITIAL (NODE))

Getter of the symbol declaration associated with the
NAMELIST_DECL node.

Referenced by convert_local_reference_stmt(), and convert_nonlocal_reference_stmt().

◆ NON_SAT_FIXED_POINT_TYPE_P

#define NON_SAT_FIXED_POINT_TYPE_P ( TYPE ) (TREE_CODE (TYPE) == FIXED_POINT_TYPE && !TYPE_SATURATING (TYPE))

Nonzero if TYPE represents a non-saturating fixed-point type.

Referenced by can_reassociate_type_p().

◆ NON_TYPE_CHECK

#define NON_TYPE_CHECK ( T ) (T)

◆ NOT_RECORD_OR_UNION_CHECK

#define NOT_RECORD_OR_UNION_CHECK ( T ) TREE_NOT_CHECK3 (T, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE)

◆ null_pointer_node

#define null_pointer_node global_trees[TI_NULL_POINTER]

Referenced by analyze_function(), ao_ref_init_from_ptr_and_range(), build_common_tree_nodes(), build_cxa_dtor_registrations(), build_info(), tree_switch_conversion::switch_conversion::check_final_bb(), default_emutls_var_init(), dump_omp_clause(), execute_omp_device_lower(), execute_update_addresses_taken(), expand_omp_for_generic(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), expand_omp_sections(), expand_parallel_call(), expand_task_call(), expand_teams_call(), find_explicit_erroneous_behavior(), get_emutls_init_templ_addr(), get_last_alloca_addr(), get_target_arguments(), gimple_fold_builtin_realloc(), gimplify_omp_affinity(), gimplify_omp_depend(), gimplify_scan_omp_clauses(), initializer_constant_valid_p(), initializer_constant_valid_p_1(), lower_coro_builtin(), lower_eh_constructs_2(), lower_omp_target(), narrowing_initializer_constant_valid_p(), ompdevlow_adjust_simt_enter(), and stmt_uses_0_or_null_in_undefined_way().

◆ NULL_TREE

#define NULL_TREE (tree) NULL

◆ NUMERICAL_TYPE_CHECK

#define NUMERICAL_TYPE_CHECK ( T )

Value:

TREE_CHECK6 (T, INTEGER_TYPE, ENUMERAL_TYPE, BOOLEAN_TYPE, REAL_TYPE, \

FIXED_POINT_TYPE, BITINT_TYPE)

TREE_CHECK6

#define TREE_CHECK6(T, CODE1, CODE2, CODE3, CODE4, CODE5, CODE6)

Definition tree.h:496

◆ OACC_CACHE_CLAUSES

#define OACC_CACHE_CLAUSES ( NODE ) TREE_OPERAND (OACC_CACHE_CHECK (NODE), 0)

Referenced by dump_generic_node(), and gimplify_oacc_cache().

◆ OACC_DATA_BODY

#define OACC_DATA_BODY ( NODE ) TREE_OPERAND (OACC_DATA_CHECK (NODE), 0)

◆ OACC_DATA_CLAUSES

#define OACC_DATA_CLAUSES ( NODE ) TREE_OPERAND (OACC_DATA_CHECK (NODE), 1)

Referenced by dump_generic_node().

◆ OACC_DECLARE_CLAUSES

#define OACC_DECLARE_CLAUSES ( NODE ) TREE_OPERAND (OACC_DECLARE_CHECK (NODE), 0)

Referenced by dump_generic_node(), and gimplify_oacc_declare().

◆ OACC_ENTER_DATA_CLAUSES

#define OACC_ENTER_DATA_CLAUSES ( NODE ) TREE_OPERAND (OACC_ENTER_DATA_CHECK (NODE), 0)

Referenced by dump_generic_node().

◆ OACC_EXIT_DATA_CLAUSES

#define OACC_EXIT_DATA_CLAUSES ( NODE ) TREE_OPERAND (OACC_EXIT_DATA_CHECK (NODE), 0)

Referenced by dump_generic_node().

◆ OACC_HOST_DATA_BODY

#define OACC_HOST_DATA_BODY ( NODE ) TREE_OPERAND (OACC_HOST_DATA_CHECK (NODE), 0)

◆ OACC_HOST_DATA_CLAUSES

#define OACC_HOST_DATA_CLAUSES ( NODE ) TREE_OPERAND (OACC_HOST_DATA_CHECK (NODE), 1)

Referenced by dump_generic_node().

◆ OACC_UPDATE_CLAUSES

#define OACC_UPDATE_CLAUSES ( NODE ) TREE_OPERAND (OACC_UPDATE_CHECK (NODE), 0)

Referenced by dump_generic_node().

◆ OBJ_TYPE_REF_EXPR

#define OBJ_TYPE_REF_EXPR ( NODE ) TREE_OPERAND (OBJ_TYPE_REF_CHECK (NODE), 0)

OBJ_TYPE_REF accessors.

Referenced by dump_generic_node(), expand_expr_real_1(), fold_gimple_assign(), ipa_polymorphic_call_context::get_dynamic_type(), get_fi_for_callee(), gimple_fold_call(), gimple_fold_stmt_to_constant_1(), gimplify_expr(), operand_compare::hash_operand(), ipa_tm_insert_gettmclone_call(), operand_compare::operand_equal_p(), and prepare_call_arguments().

◆ OBJ_TYPE_REF_OBJECT

#define OBJ_TYPE_REF_OBJECT ( NODE ) TREE_OPERAND (OBJ_TYPE_REF_CHECK (NODE), 1)

Referenced by dump_generic_node(), eliminate_dom_walker::eliminate_stmt(), gimplify_expr(), operand_compare::hash_operand(), ipa_analyze_call_uses(), ipa_analyze_virtual_call_uses(), ipa_polymorphic_call_context::ipa_polymorphic_call_context(), operand_compare::operand_equal_p(), and walk_stmt_load_store_addr_ops().

◆ OBJ_TYPE_REF_TOKEN

#define OBJ_TYPE_REF_TOKEN ( NODE ) TREE_OPERAND (OBJ_TYPE_REF_CHECK (NODE), 2)

Referenced by cgraph_node::create_indirect_edge(), dump_generic_node(), eliminate_dom_walker::eliminate_stmt(), operand_compare::hash_operand(), ipa_analyze_call_uses(), ipa_analyze_virtual_call_uses(), operand_compare::operand_equal_p(), possible_polymorphic_call_target_p(), possible_polymorphic_call_targets(), and prepare_call_arguments().

◆ OMP_ATOMIC_MEMORY_ORDER

#define OMP_ATOMIC_MEMORY_ORDER ( NODE )

Value:

(TREE_RANGE_CHECK (NODE, OMP_ATOMIC, \

OMP_ATOMIC_CAPTURE_NEW)->base.u.omp_atomic_memory_order)

TREE_RANGE_CHECK

#define TREE_RANGE_CHECK(T, CODE1, CODE2)

Definition tree.h:499

Memory order for OMP_ATOMIC*.

Referenced by dump_generic_node(), gimplify_omp_atomic(), and lower_reduction_clauses().

◆ OMP_ATOMIC_WEAK

#define OMP_ATOMIC_WEAK ( NODE )

Value:

(TREE_RANGE_CHECK (NODE, OMP_ATOMIC, \

OMP_ATOMIC_CAPTURE_NEW)->base.public_flag)

Weak clause on OMP_ATOMIC*.

Referenced by dump_generic_node(), and gimplify_omp_atomic().

◆ OMP_BODY

#define OMP_BODY ( NODE ) TREE_OPERAND (TREE_RANGE_CHECK (NODE, OACC_PARALLEL, OMP_MASTER), 0)

OpenMP and OpenACC directive and clause accessors.

Generic accessors for OMP nodes that keep the body as operand 0, and clauses
as operand 1.

Referenced by dump_generic_node(), gimplify_expr(), gimplify_omp_for(), gimplify_omp_workshare(), and optimize_target_teams().

◆ OMP_CLAUSECACHEREADONLY

#define OMP_CLAUSE__CACHE__READONLY ( NODE ) TREE_READONLY (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE__CACHE_))

Same as above, for use in OpenACC cache directives.

Referenced by dump_omp_clause().

◆ OMP_CLAUSECONDTEMPITER

#define OMP_CLAUSE__CONDTEMP__ITER ( NODE ) (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE__CONDTEMP_)->base.public_flag)

_CONDTEMP_ holding temporary with iteration count.

Referenced by lower_lastprivate_conditional_clauses(), lower_omp_1(), lower_rec_input_clauses(), and scan_sharing_clauses().

◆ OMP_CLAUSESCANTEMPALLOC

#define OMP_CLAUSE__SCANTEMP__ALLOC ( NODE ) (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE__SCANTEMP_)->base.public_flag)

_SCANTEMP_ holding temporary with pointer to thread's local array;
allocation.

Referenced by expand_omp_for_static_nochunk(), expand_omp_scantemp_alloc(), lower_omp_for_scan(), and omp_extract_for_data().

◆ OMP_CLAUSESCANTEMPCONTROL

#define OMP_CLAUSE__SCANTEMP__CONTROL ( NODE ) TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE__SCANTEMP_))

_SCANTEMP_ holding temporary with a control variable for deallocation;
one boolean_type_node for test whether alloca was used, another one
to pass to __builtin_stack_restore or free.

Referenced by expand_omp_for_static_nochunk(), expand_omp_scantemp_alloc(), lower_omp_for_scan(), and omp_extract_for_data().

◆ OMP_CLAUSESIMDUIDDECL

#define OMP_CLAUSE__SIMDUID__DECL ( NODE ) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE__SIMDUID_), 0)

Referenced by dump_omp_clause(), expand_omp_simd(), lower_lastprivate_clauses(), lower_omp_scan(), and lower_rec_input_clauses().

◆ OMP_CLAUSE_ALIGNED_ALIGNMENT

#define OMP_CLAUSE_ALIGNED_ALIGNMENT ( NODE ) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ALIGNED), 1)

Referenced by convert_local_omp_clauses(), convert_nonlocal_omp_clauses(), dump_omp_clause(), gimplify_scan_omp_clauses(), omp_clause_aligned_alignment(), omp_construct_simd_compare(), omp_declare_simd_clauses_equal(), and simd_clone_clauses_extract().

◆ OMP_CLAUSE_ALLOCATE_ALIGN

#define OMP_CLAUSE_ALLOCATE_ALIGN ( NODE ) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ALLOCATE), 2)

Referenced by dump_omp_clause(), and scan_sharing_clauses().

◆ OMP_CLAUSE_ALLOCATE_ALLOCATOR

#define OMP_CLAUSE_ALLOCATE_ALLOCATOR ( NODE ) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ALLOCATE), 1)

Referenced by convert_local_omp_clauses(), convert_nonlocal_omp_clauses(), dump_omp_clause(), gimplify_adjust_omp_clauses(), gimplify_omp_for(), gimplify_scan_omp_clauses(), and scan_sharing_clauses().

◆ OMP_CLAUSE_ALLOCATE_COMBINED

#define OMP_CLAUSE_ALLOCATE_COMBINED ( NODE ) (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ALLOCATE)->base.public_flag)

True if an ALLOCATE clause was present on a combined or composite
construct and the code for splitting the clauses has already performed
checking if the listed variable has explicit privatization on the
construct.

◆ OMP_CLAUSE_ASYNC_EXPR

#define OMP_CLAUSE_ASYNC_EXPR ( NODE )

Value:

OMP_CLAUSE_OPERAND ( \

OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ASYNC), 0)

OMP_CLAUSE_ASYNC

@ OMP_CLAUSE_ASYNC

Definition tree-core.h:366

OMP_CLAUSE_OPERAND

#define OMP_CLAUSE_OPERAND(NODE, I)

Definition tree.h:2147

OMP_CLAUSE_SUBCODE_CHECK

#define OMP_CLAUSE_SUBCODE_CHECK(T, CODE)

Definition tree.h:508

Referenced by dump_omp_clause(), and expand_omp_target().

◆ OMP_CLAUSE_ATTACHMENT_MAPPING_ERASED

#define OMP_CLAUSE_ATTACHMENT_MAPPING_ERASED ( NODE ) TREE_STATIC (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP))

Nonzero for an attach/detach node whose decl was explicitly mapped on the
same directive.

Referenced by omp_accumulate_sibling_list(), and omp_resolve_clause_dependencies().

◆ OMP_CLAUSE_BIND_KIND

#define OMP_CLAUSE_BIND_KIND ( NODE ) (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_BIND)->omp_clause.subcode.bind_kind)

Referenced by dump_omp_clause(), and gimplify_omp_loop().

◆ OMP_CLAUSE_CHAIN

#define OMP_CLAUSE_CHAIN ( NODE ) TREE_CHAIN (OMP_CLAUSE_CHECK (NODE))

Referenced by add_async_clauses_and_wait(), add_parent_or_loop_num_clause(), add_taskreg_looptemp_clauses(), adjust_nested_loop_clauses(), build_omp_struct_comp_nodes(), check_oacc_kernel_gwv(), check_omp_nesting_restrictions(), convert_gimple_call(), convert_local_omp_clauses(), convert_local_reference_stmt(), convert_nonlocal_omp_clauses(), convert_nonlocal_reference_stmt(), convert_tramp_reference_stmt(), create_task_copyfn(), debug_mapping_group(), decompose_kernels_region_body(), DFS::DFS_write_tree_body(), dump_omp_clauses(), expand_omp_for_generic(), expand_omp_for_init_counts(), expand_omp_for_init_vars(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), expand_omp_ordered_source_sink(), expand_omp_scantemp_alloc(), expand_omp_sections(), expand_omp_simd(), expand_omp_target(), expand_omp_taskloop_for_inner(), expand_omp_taskloop_for_outer(), expand_task_call(), find_lastprivate_looptemp(), finish_taskreg_scan(), get_ws_args_for(), gimplify_adjust_omp_clauses(), gimplify_adjust_omp_clauses_1(), gimplify_bind_expr(), gimplify_oacc_declare(), gimplify_omp_affinity(), gimplify_omp_depend(), gimplify_omp_for(), gimplify_omp_loop(), gimplify_omp_ordered(), gimplify_omp_target_update(), gimplify_omp_task(), gimplify_omp_taskloop_expr(), gimplify_omp_workshare(), gimplify_scan_omp_clauses(), hash_tree(), lower_copyprivate_clauses(), lower_depend_clauses(), lower_lastprivate_clauses(), lower_lastprivate_conditional_clauses(), lower_oacc_head_mark(), lower_oacc_reductions(), lower_omp_1(), lower_omp_for(), lower_omp_for_lastprivate(), lower_omp_for_scan(), lower_omp_ordered_clauses(), lower_omp_scan(), lower_omp_scope(), lower_omp_sections(), lower_omp_target(), lower_rec_input_clauses(), lower_rec_simd_input_clauses(), lower_reduction_clauses(), lower_send_clauses(), lto_input_ts_omp_clause_tree_pointers(), make_region_seq(), maybe_build_inner_data_region(), oacc_build_routine_dims(), oacc_privatization_scan_clause_chain(), oacc_verify_routine_clauses(), omp_accumulate_sibling_list(), omp_build_struct_sibling_lists(), omp_construct_simd_compare(), omp_declare_simd_clauses_equal(), omp_directive_maps_explicitly(), omp_extract_for_data(), omp_find_clause(), omp_gather_mapping_groups_1(), omp_get_attachment(), omp_group_base(), omp_group_last(), omp_index_mapping_groups_1(), omp_oacc_kernels_decompose_1(), omp_reorder_mapping_groups(), omp_resolve_clause_dependencies(), omp_siblist_insert_node_after(), omp_siblist_move_concat_nodes_after(), omp_siblist_move_node_after(), omp_siblist_move_nodes_after(), omp_task_reduction_iterate(), omp_task_reductions_find_first(), optimize_target_teams(), scan_omp_for(), scan_omp_parallel(), scan_omp_simd(), scan_sharing_clauses(), simd_clone_clauses_extract(), transform_kernels_loop_clauses(), use_pointer_for_field(), visit_loops_in_gang_single_region(), walk_tree_1(), and write_ts_omp_clause_tree_pointers().

◆ OMP_CLAUSE_CODE

#define OMP_CLAUSE_CODE ( NODE ) (OMP_CLAUSE_CHECK (NODE))->omp_clause.code

Referenced by adjust_nested_loop_clauses(), build_omp_struct_comp_nodes(), check_oacc_kernel_gwv(), check_omp_nesting_restrictions(), convert_gimple_call(), convert_local_omp_clauses(), convert_nonlocal_omp_clauses(), convert_tramp_reference_stmt(), copy_tree_body_r(), create_task_copyfn(), decompose_kernels_region_body(), dequeue_and_dump(), DFS::DFS_write_tree_body(), dump_omp_clause(), expand_omp_for_generic(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), expand_omp_scantemp_alloc(), expand_omp_sections(), expand_omp_target(), finish_taskreg_scan(), gimplify_adjust_omp_clauses(), gimplify_adjust_omp_clauses_1(), gimplify_omp_affinity(), gimplify_omp_depend(), gimplify_omp_for(), gimplify_omp_loop(), gimplify_omp_ordered(), gimplify_omp_target_update(), gimplify_omp_task(), gimplify_omp_workshare(), gimplify_scan_omp_clauses(), hash_tree(), lower_copyprivate_clauses(), lower_depend_clauses(), lower_lastprivate_clauses(), lower_lastprivate_conditional_clauses(), lower_oacc_head_mark(), lower_oacc_reductions(), lower_omp_for(), lower_omp_for_scan(), lower_omp_ordered_clauses(), lower_omp_scan(), lower_omp_target(), lower_omp_task_reductions(), lower_rec_input_clauses(), lower_rec_simd_input_clauses(), lower_reduction_clauses(), lower_send_clauses(), lto_input_ts_omp_clause_tree_pointers(), oacc_build_routine_dims(), oacc_privatization_begin_diagnose_var(), oacc_privatization_scan_clause_chain(), oacc_resolve_clause_dependencies(), oacc_verify_routine_clauses(), omp_build_struct_sibling_lists(), omp_check_mapping_compatibility(), omp_construct_simd_compare(), omp_declare_simd_clauses_equal(), omp_extract_for_data(), omp_find_clause(), omp_gather_mapping_groups_1(), omp_group_last(), omp_map_clause_descriptor_p(), omp_oacc_kernels_decompose_1(), omp_resolve_clause_dependencies(), omp_segregate_mapping_groups(), optimize_target_teams(), pack_ts_omp_clause_value_fields(), print_node(), replace_locals_op(), scan_omp_1_stmt(), scan_omp_for(), scan_omp_simd_scan(), scan_sharing_clauses(), simd_clone_clauses_extract(), streamer_write_tree_header(), transform_kernels_loop_clauses(), tree_size(), unpack_ts_omp_clause_value_fields(), use_pointer_for_field(), user_omp_clause_code_name(), visit_loops_in_gang_single_region(), walk_tree_1(), and write_ts_omp_clause_tree_pointers().

◆ OMP_CLAUSE_COLLAPSE_COUNT

#define OMP_CLAUSE_COLLAPSE_COUNT ( NODE ) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_COLLAPSE), 2)

Referenced by omp_extract_for_data().

◆ OMP_CLAUSE_COLLAPSE_EXPR

#define OMP_CLAUSE_COLLAPSE_EXPR ( NODE ) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_COLLAPSE), 0)

Referenced by check_omp_nesting_restrictions(), dump_omp_clause(), gimplify_omp_for(), and omp_extract_for_data().

◆ OMP_CLAUSE_COLLAPSE_ITERVAR

#define OMP_CLAUSE_COLLAPSE_ITERVAR ( NODE ) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_COLLAPSE), 1)

Referenced by omp_extract_for_data().

◆ OMP_CLAUSE_DECL

#define OMP_CLAUSE_DECL ( NODE )

Value:

  OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (OMP_CLAUSE_CHECK (NODE),  \
                                              OMP_CLAUSE_PRIVATE,       \
                                              OMP_CLAUSE__SCANTEMP_), 0)

Referenced by add_taskreg_looptemp_clauses(), build_omp_struct_comp_nodes(), convert_gimple_call(), convert_local_omp_clauses(), convert_local_reference_stmt(), convert_nonlocal_omp_clauses(), convert_nonlocal_reference_stmt(), convert_tramp_reference_stmt(), copy_tree_body_r(), create_task_copyfn(), decompose_kernels_region_body(), determine_parallel_type(), dump_omp_clause(), expand_omp_for_generic(), expand_omp_for_init_counts(), expand_omp_for_init_vars(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), expand_omp_ordered_sink(), expand_omp_scantemp_alloc(), expand_omp_sections(), expand_omp_simd(), expand_omp_target(), expand_omp_taskloop_for_inner(), expand_omp_taskloop_for_outer(), expand_parallel_call(), expand_task_call(), expand_taskwait_call(), finish_taskreg_scan(), get_ws_args_for(), gimplify_adjust_omp_clauses(), gimplify_adjust_omp_clauses_1(), gimplify_oacc_declare(), gimplify_oacc_declare_1(), gimplify_omp_affinity(), gimplify_omp_depend(), gimplify_omp_for(), gimplify_omp_loop(), gimplify_omp_ordered(), gimplify_omp_taskloop_expr(), gimplify_scan_omp_clauses(), lower_copyprivate_clauses(), lower_depend_clauses(), lower_lastprivate_clauses(), lower_lastprivate_conditional_clauses(), lower_oacc_reductions(), lower_omp_1(), lower_omp_for(), lower_omp_for_lastprivate(), lower_omp_for_scan(), lower_omp_ordered_clauses(), lower_omp_scan(), lower_omp_scope(), lower_omp_sections(), lower_omp_target(), lower_omp_task_reductions(), lower_rec_input_clauses(), lower_reduction_clauses(), lower_send_clauses(), maybe_build_inner_data_region(), oacc_privatization_scan_clause_chain(), oacc_resolve_clause_dependencies(), omp_accumulate_sibling_list(), omp_build_struct_sibling_lists(), omp_check_mapping_compatibility(), omp_construct_simd_compare(), omp_declare_simd_clauses_equal(), omp_default_clause(), omp_extract_for_data(), omp_get_attachment(), omp_group_base(), omp_index_mapping_groups_1(), omp_oacc_kernels_decompose_1(), omp_resolve_clause_dependencies(), omp_task_reduction_iterate(), omp_tsort_mapping_groups_1(), scan_omp_for(), scan_omp_parallel(), scan_omp_simd_scan(), scan_sharing_clauses(), simd_clone_clauses_extract(), and use_pointer_for_field().

◆ OMP_CLAUSE_DEFAULT_KIND

#define OMP_CLAUSE_DEFAULT_KIND ( NODE ) (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEFAULT)->omp_clause.subcode.default_kind)

Referenced by dump_omp_clause(), gimplify_scan_omp_clauses(), hash_tree(), pack_ts_omp_clause_value_fields(), and unpack_ts_omp_clause_value_fields().

◆ OMP_CLAUSE_DEFAULTMAP_BEHAVIOR

#define OMP_CLAUSE_DEFAULTMAP_BEHAVIOR ( NODE )

Value:

((enum omp_clause_defaultmap_kind) \

(OMP_CLAUSE_DEFAULTMAP_KIND (NODE) & OMP_CLAUSE_DEFAULTMAP_MASK))

omp_clause_defaultmap_kind

Definition tree-core.h:568

OMP_CLAUSE_DEFAULTMAP_MASK

@ OMP_CLAUSE_DEFAULTMAP_MASK

Definition tree-core.h:586

OMP_CLAUSE_DEFAULTMAP_KIND

#define OMP_CLAUSE_DEFAULTMAP_KIND(NODE)

Definition tree.h:2019

Referenced by dump_omp_clause(), and gimplify_scan_omp_clauses().

◆ OMP_CLAUSE_DEFAULTMAP_CATEGORY

#define OMP_CLAUSE_DEFAULTMAP_CATEGORY ( NODE )

Value:

((enum omp_clause_defaultmap_kind) \

(OMP_CLAUSE_DEFAULTMAP_KIND (NODE) & OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK))

OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK

@ OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK

Definition tree-core.h:575

Referenced by dump_omp_clause(), and gimplify_scan_omp_clauses().

◆ OMP_CLAUSE_DEFAULTMAP_KIND

#define OMP_CLAUSE_DEFAULTMAP_KIND ( NODE ) (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEFAULTMAP)->omp_clause.subcode.defaultmap_kind)

◆ OMP_CLAUSE_DEFAULTMAP_SET_KIND

#define OMP_CLAUSE_DEFAULTMAP_SET_KIND	(	NODE,
		BEHAVIOR,
		CATEGORY )

Value:

(OMP_CLAUSE_DEFAULTMAP_KIND (NODE) \

= (enum omp_clause_defaultmap_kind) (CATEGORY | BEHAVIOR))

◆ OMP_CLAUSE_DEPEND_KIND

#define OMP_CLAUSE_DEPEND_KIND ( NODE ) (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEPEND)->omp_clause.subcode.depend_kind)

Referenced by dump_omp_clause(), gimplify_omp_depend(), gimplify_omp_task(), hash_tree(), lower_depend_clauses(), pack_ts_omp_clause_value_fields(), and unpack_ts_omp_clause_value_fields().

◆ OMP_CLAUSE_DEVICE_ANCESTOR

#define OMP_CLAUSE_DEVICE_ANCESTOR ( NODE ) (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEVICE)->base.public_flag)

True if there is a device clause with a device-modifier 'ancestor'.

Referenced by check_omp_nesting_restrictions(), dump_omp_clause(), expand_omp_target(), gimplify_scan_omp_clauses(), omp_discover_declare_target_fn_r(), omp_discover_declare_target_tgt_fn_r(), and scan_omp_1_stmt().

◆ OMP_CLAUSE_DEVICE_ID

#define OMP_CLAUSE_DEVICE_ID ( NODE ) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEVICE), 0)

Referenced by dump_omp_clause(), and expand_omp_target().

◆ OMP_CLAUSE_DEVICE_TYPE_KIND

#define OMP_CLAUSE_DEVICE_TYPE_KIND ( NODE ) (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEVICE_TYPE)->omp_clause.subcode.device_type_kind)

Referenced by dump_omp_clause().

◆ OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR

#define OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR ( NODE )

Value:

OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, \

OMP_CLAUSE_DIST_SCHEDULE), 0)

OMP_CLAUSE_DIST_SCHEDULE

@ OMP_CLAUSE_DIST_SCHEDULE

Definition tree-core.h:426

Referenced by convert_local_omp_clauses(), convert_nonlocal_omp_clauses(), dump_omp_clause(), and omp_extract_for_data().

◆ OMP_CLAUSE_DOACROSS_DEPEND

#define OMP_CLAUSE_DOACROSS_DEPEND ( NODE ) TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DOACROSS))

True if DOACROSS clause is spelled as DEPEND.

Referenced by check_omp_nesting_restrictions(), dump_omp_clause(), expand_omp_ordered_sink(), and gimplify_omp_ordered().

◆ OMP_CLAUSE_DOACROSS_KIND

#define OMP_CLAUSE_DOACROSS_KIND ( NODE ) (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DOACROSS)->omp_clause.subcode.doacross_kind)

Referenced by check_omp_nesting_restrictions(), dump_omp_clause(), expand_omp_ordered_source_sink(), gimplify_omp_ordered(), gimplify_scan_omp_clauses(), hash_tree(), lower_omp_ordered_clauses(), pack_ts_omp_clause_value_fields(), and unpack_ts_omp_clause_value_fields().

◆ OMP_CLAUSE_DOACROSS_SINK_NEGATIVE

#define OMP_CLAUSE_DOACROSS_SINK_NEGATIVE ( NODE ) TREE_PUBLIC (TREE_LIST_CHECK (NODE))

Referenced by dump_omp_clause(), and expand_omp_ordered_sink().

◆ OMP_CLAUSE_ELT_CHECK

#define OMP_CLAUSE_ELT_CHECK	(		T,
			i ) ((T)->omp_clause.ops[i])

◆ OMP_CLAUSE_ENTER_TO

#define OMP_CLAUSE_ENTER_TO ( NODE ) (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ENTER)->base.public_flag)

True if ENTER clause is spelled as TO.

Referenced by dump_omp_clause().

◆ OMP_CLAUSE_EXPR

#define OMP_CLAUSE_EXPR	(		NODE,
			CLAUSE ) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, CLAUSE), 0)

OpenACC clause expressions

Referenced by oacc_set_fn_attrib().

◆ OMP_CLAUSE_FILTER_EXPR

#define OMP_CLAUSE_FILTER_EXPR ( NODE ) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_FILTER), 0)

Referenced by dump_omp_clause(), and lower_omp_master().

◆ OMP_CLAUSE_FINAL_EXPR

#define OMP_CLAUSE_FINAL_EXPR ( NODE ) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_FINAL), 0)

Referenced by dump_omp_clause(), and expand_task_call().

◆ OMP_CLAUSE_FIRSTPRIVATE_IMPLICIT

#define OMP_CLAUSE_FIRSTPRIVATE_IMPLICIT ( NODE ) (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_FIRSTPRIVATE)->base.public_flag)

True on a FIRSTPRIVATE clause if it has been added implicitly.

Referenced by gimplify_adjust_omp_clauses(), gimplify_adjust_omp_clauses_1(), gimplify_scan_omp_clauses(), lower_omp_target(), and lower_send_clauses().

◆ OMP_CLAUSE_FIRSTPRIVATE_IMPLICIT_TARGET

#define OMP_CLAUSE_FIRSTPRIVATE_IMPLICIT_TARGET ( NODE ) TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_FIRSTPRIVATE))

True on a FIRSTPRIVATE clause with OMP_CLAUSE_FIRSTPRIVATE_IMPLICIT also
set if target construct is the only one that accepts the clause.

Referenced by gimplify_adjust_omp_clauses().

◆ OMP_CLAUSE_FIRSTPRIVATE_NO_REFERENCE

#define OMP_CLAUSE_FIRSTPRIVATE_NO_REFERENCE ( NODE ) TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_FIRSTPRIVATE))

True on a FIRSTPRIVATE clause if only the reference and not what it refers
to should be firstprivatized.

Referenced by gimplify_omp_for(), and lower_rec_input_clauses().

◆ OMP_CLAUSE_GANG_EXPR

#define OMP_CLAUSE_GANG_EXPR ( NODE )

Value:

OMP_CLAUSE_OPERAND ( \

OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_GANG), 0)

OMP_CLAUSE_GANG

@ OMP_CLAUSE_GANG

Definition tree-core.h:363

Referenced by dump_omp_clause(), and scan_omp_for().

◆ OMP_CLAUSE_GANG_STATIC_EXPR

#define OMP_CLAUSE_GANG_STATIC_EXPR ( NODE )

Value:

OMP_CLAUSE_OPERAND ( \

OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_GANG), 1)

Referenced by convert_local_omp_clauses(), convert_nonlocal_omp_clauses(), dump_omp_clause(), and lower_oacc_head_mark().

◆ OMP_CLAUSE_GRAINSIZE_EXPR

#define OMP_CLAUSE_GRAINSIZE_EXPR ( NODE ) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_GRAINSIZE),0)

Referenced by dump_omp_clause(), and expand_task_call().

◆ OMP_CLAUSE_GRAINSIZE_STRICT

#define OMP_CLAUSE_GRAINSIZE_STRICT ( NODE ) TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_GRAINSIZE))

Referenced by dump_omp_clause(), and expand_task_call().

◆ OMP_CLAUSE_HAS_LOCATION

#define OMP_CLAUSE_HAS_LOCATION ( NODE )

Value:

(LOCATION_LOCUS ((OMP_CLAUSE_CHECK (NODE))->omp_clause.locus) \

!= UNKNOWN_LOCATION)

◆ OMP_CLAUSE_HINT_EXPR

#define OMP_CLAUSE_HINT_EXPR ( NODE ) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_HINT), 0)

Referenced by dump_omp_clause().

◆ OMP_CLAUSE_IF_EXPR

#define OMP_CLAUSE_IF_EXPR ( NODE ) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_IF), 0)

Referenced by dump_omp_clause(), expand_omp_simd(), expand_omp_target(), expand_parallel_call(), expand_task_call(), and lower_rec_input_clauses().

◆ OMP_CLAUSE_IF_MODIFIER

#define OMP_CLAUSE_IF_MODIFIER ( NODE ) (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_IF)->omp_clause.subcode.if_modifier)

Referenced by dump_omp_clause(), and gimplify_scan_omp_clauses().

◆ OMP_CLAUSE_INDIRECT_EXPR

#define OMP_CLAUSE_INDIRECT_EXPR ( NODE ) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_INDIRECT), 0)

◆ OMP_CLAUSE_LASTPRIVATE_CONDITIONAL

#define OMP_CLAUSE_LASTPRIVATE_CONDITIONAL ( NODE ) TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LASTPRIVATE))

True if a LASTPRIVATE clause has CONDITIONAL: modifier.

Referenced by dump_omp_clause(), expand_omp_sections(), gimplify_adjust_omp_clauses(), gimplify_omp_for(), gimplify_scan_omp_clauses(), lower_lastprivate_clauses(), lower_lastprivate_conditional_clauses(), lower_rec_input_clauses(), and omp_extract_for_data().

◆ OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE

#define OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE ( NODE ) (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LASTPRIVATE)->base.public_flag)

True on a LASTPRIVATE clause if a FIRSTPRIVATE clause for the same
decl is present in the chain.

Referenced by gimplify_adjust_omp_clauses(), gimplify_adjust_omp_clauses_1(), gimplify_omp_for(), gimplify_omp_loop(), lower_lastprivate_clauses(), lower_rec_input_clauses(), lower_send_clauses(), and scan_sharing_clauses().

◆ OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ

#define OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ ( NODE ) (OMP_CLAUSE_CHECK (NODE))->omp_clause.gimple_reduction_init

Referenced by convert_local_omp_clauses(), convert_nonlocal_omp_clauses(), gimplify_omp_for(), gimplify_scan_omp_clauses(), lower_lastprivate_clauses(), replace_locals_op(), and scan_sharing_clauses().

◆ OMP_CLAUSE_LASTPRIVATE_LOOP_IV

#define OMP_CLAUSE_LASTPRIVATE_LOOP_IV ( NODE ) TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LASTPRIVATE))

True if a LASTPRIVATE clause is for a C++ class IV on taskloop or
loop construct (thus should be lastprivate on the outer taskloop and
firstprivate on task for the taskloop construct and carefully handled
for loop construct).

Referenced by gimplify_omp_for(), gimplify_omp_loop(), lower_lastprivate_clauses(), and lower_rec_input_clauses().

◆ OMP_CLAUSE_LASTPRIVATE_STMT

#define OMP_CLAUSE_LASTPRIVATE_STMT ( NODE )

Value:

  OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE,                   \
                                                OMP_CLAUSE_LASTPRIVATE),\
                      1)

Referenced by gimplify_omp_loop(), and gimplify_scan_omp_clauses().

◆ OMP_CLAUSE_LINEAR_ARRAY

#define OMP_CLAUSE_LINEAR_ARRAY ( NODE ) (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR)->base.deprecated_flag)

True if a LINEAR clause is for an array or allocatable variable that
needs special handling by the frontend.

Referenced by lower_rec_input_clauses().

◆ OMP_CLAUSE_LINEAR_GIMPLE_SEQ

#define OMP_CLAUSE_LINEAR_GIMPLE_SEQ ( NODE ) (OMP_CLAUSE_CHECK (NODE))->omp_clause.gimple_reduction_init

Referenced by convert_local_omp_clauses(), convert_nonlocal_omp_clauses(), gimplify_omp_for(), gimplify_scan_omp_clauses(), lower_lastprivate_clauses(), replace_locals_op(), and scan_sharing_clauses().

◆ OMP_CLAUSE_LINEAR_KIND

#define OMP_CLAUSE_LINEAR_KIND ( NODE ) (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR)->omp_clause.subcode.linear_kind)

Referenced by dump_omp_clause(), omp_construct_simd_compare(), and simd_clone_clauses_extract().

◆ OMP_CLAUSE_LINEAR_NO_COPYIN

#define OMP_CLAUSE_LINEAR_NO_COPYIN ( NODE ) (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR)->base.public_flag)

True if a LINEAR clause doesn't need copy in.  True for iterator vars which
are always initialized inside of the loop construct, false otherwise.

Referenced by expand_omp_for_generic(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), gimplify_adjust_omp_clauses(), gimplify_omp_for(), gimplify_scan_omp_clauses(), lower_lastprivate_clauses(), lower_omp_for(), and lower_rec_input_clauses().

◆ OMP_CLAUSE_LINEAR_NO_COPYOUT

#define OMP_CLAUSE_LINEAR_NO_COPYOUT ( NODE ) TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR))

True if a LINEAR clause doesn't need copy out.  True for iterator vars which
are declared inside of the simd construct.

Referenced by gimplify_adjust_omp_clauses(), gimplify_omp_for(), gimplify_scan_omp_clauses(), lower_lastprivate_clauses(), and lower_rec_input_clauses().

◆ OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER

#define OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER ( NODE ) (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR)->base.addressable_flag)

True for a LINEAR clause with old style modifier syntax
linear(modifier(list)) or linear(modifier(list):step).

Referenced by dump_omp_clause().

◆ OMP_CLAUSE_LINEAR_STEP

#define OMP_CLAUSE_LINEAR_STEP ( NODE ) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR), 1)

Referenced by convert_local_omp_clauses(), convert_nonlocal_omp_clauses(), dump_omp_clause(), expand_omp_for_generic(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), gimplify_omp_for(), gimplify_scan_omp_clauses(), lower_omp_for(), lower_rec_input_clauses(), omp_construct_simd_compare(), omp_declare_simd_clauses_equal(), and simd_clone_clauses_extract().

◆ OMP_CLAUSE_LINEAR_STMT

#define OMP_CLAUSE_LINEAR_STMT ( NODE ) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR), 2)

Referenced by gimplify_scan_omp_clauses().

◆ OMP_CLAUSE_LINEAR_VARIABLE_STRIDE

#define OMP_CLAUSE_LINEAR_VARIABLE_STRIDE ( NODE ) TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR))

True if a LINEAR clause has a stride that is variable.

Referenced by omp_construct_simd_compare(), and simd_clone_clauses_extract().

◆ OMP_CLAUSE_LOCATION

#define OMP_CLAUSE_LOCATION ( NODE ) (OMP_CLAUSE_CHECK (NODE))->omp_clause.locus

Referenced by add_parent_or_loop_num_clause(), adjust_nested_loop_clauses(), build_omp_clause(), build_omp_struct_comp_nodes(), check_omp_nesting_restrictions(), expand_omp_for_generic(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), expand_omp_target(), expand_parallel_call(), gimplify_adjust_omp_clauses(), gimplify_adjust_omp_clauses_1(), gimplify_oacc_declare_1(), gimplify_omp_affinity(), gimplify_omp_depend(), gimplify_omp_for(), gimplify_omp_loop(), gimplify_omp_ordered(), gimplify_omp_task(), gimplify_scan_omp_clauses(), lower_copyprivate_clauses(), lower_lastprivate_clauses(), lower_omp_for_scan(), lower_omp_ordered_clauses(), lower_omp_scan(), lower_omp_target(), lower_omp_task_reductions(), lower_rec_input_clauses(), lower_reduction_clauses(), lower_send_clauses(), oacc_privatization_scan_clause_chain(), oacc_resolve_clause_dependencies(), oacc_verify_routine_clauses(), omp_accumulate_sibling_list(), omp_build_struct_sibling_lists(), omp_oacc_kernels_decompose_1(), omp_reduction_init(), omp_resolve_clause_dependencies(), optimize_target_teams(), pack_ts_omp_clause_value_fields(), scan_omp_for(), scan_sharing_clauses(), simd_clone_clauses_extract(), transform_kernels_loop_clauses(), and unpack_ts_omp_clause_value_fields().

◆ OMP_CLAUSE_MAP_DECL_MAKE_ADDRESSABLE

#define OMP_CLAUSE_MAP_DECL_MAKE_ADDRESSABLE ( NODE ) (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP)->base.addressable_flag)

Flag that 'OMP_CLAUSE_DECL (NODE)' is to be made addressable during OMP
lowering.

Referenced by maybe_build_inner_data_region(), omp_oacc_kernels_decompose_1(), and scan_sharing_clauses().

◆ OMP_CLAUSE_MAP_IMPLICIT

#define OMP_CLAUSE_MAP_IMPLICIT ( NODE ) (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP)->base.default_def_flag)

Nonzero on map clauses added implicitly for reduction clauses on combined
or composite constructs.  They shall be removed if there is an explicit
map clause.

◆ OMP_CLAUSE_MAP_IN_REDUCTION

#define OMP_CLAUSE_MAP_IN_REDUCTION ( NODE ) TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP))

Nonzero if this map clause is for an OpenACC compute construct's reduction
variable or OpenMP map clause mentioned also in in_reduction clause on the
same construct.

Referenced by gimplify_adjust_omp_clauses(), gimplify_scan_omp_clauses(), lower_omp_target(), and scan_sharing_clauses().

◆ OMP_CLAUSE_MAP_KIND

#define OMP_CLAUSE_MAP_KIND ( NODE ) ((enum gomp_map_kind) OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP)->omp_clause.subcode.map_kind)

◆ OMP_CLAUSE_MAP_MAYBE_ZERO_LENGTH_ARRAY_SECTION

#define OMP_CLAUSE_MAP_MAYBE_ZERO_LENGTH_ARRAY_SECTION ( NODE ) TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP))

Nonzero if this is a mapped array section, that might need special
treatment if OMP_CLAUSE_SIZE is zero.

Referenced by gimplify_adjust_omp_clauses_1(), lower_omp_target(), omp_accumulate_sibling_list(), and omp_resolve_clause_dependencies().

◆ OMP_CLAUSE_MAP_READONLY

#define OMP_CLAUSE_MAP_READONLY ( NODE ) TREE_READONLY (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP))

Nonzero if OpenACC 'readonly' modifier set, used for 'copyin'.

Referenced by dump_omp_clause().

◆ OMP_CLAUSE_MAP_RUNTIME_IMPLICIT_P

#define OMP_CLAUSE_MAP_RUNTIME_IMPLICIT_P ( NODE ) (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP)->base.deprecated_flag)

Nonzero if this map clause is to be indicated to the runtime as 'implicit',
due to being created through implicit data-mapping rules in the middle-end.
NOTE: this is different than OMP_CLAUSE_MAP_IMPLICIT.

Referenced by dump_omp_clause(), gimplify_adjust_omp_clauses_1(), lower_omp_target(), and omp_tsort_mapping_groups().

◆ OMP_CLAUSE_MAP_ZERO_BIAS_ARRAY_SECTION

#define OMP_CLAUSE_MAP_ZERO_BIAS_ARRAY_SECTION ( NODE ) (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP)->base.public_flag)

Nonzero if this map clause is for array (rather than pointer) based array
section with zero bias.  Both the non-decl OMP_CLAUSE_MAP and corresponding
OMP_CLAUSE_MAP with GOMP_MAP_POINTER are marked with this flag.

Referenced by lower_omp_target(), and scan_sharing_clauses().

◆ OMP_CLAUSE_MOTION_PRESENT

#define OMP_CLAUSE_MOTION_PRESENT ( NODE ) (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_FROM, OMP_CLAUSE_TO)->base.deprecated_flag)

Referenced by dump_omp_clause(), and lower_omp_target().

◆ OMP_CLAUSE_NUM_GANGS_EXPR

#define OMP_CLAUSE_NUM_GANGS_EXPR ( NODE )

Value:

OMP_CLAUSE_OPERAND ( \

OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_GANGS), 0)

OMP_CLAUSE_NUM_GANGS

@ OMP_CLAUSE_NUM_GANGS

Definition tree-core.h:517

Referenced by dump_omp_clause().

◆ OMP_CLAUSE_NUM_TASKS_EXPR

#define OMP_CLAUSE_NUM_TASKS_EXPR ( NODE ) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_TASKS), 0)

Referenced by dump_omp_clause(), and expand_task_call().

◆ OMP_CLAUSE_NUM_TASKS_STRICT

#define OMP_CLAUSE_NUM_TASKS_STRICT ( NODE ) TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_TASKS))

Referenced by dump_omp_clause(), and expand_task_call().

◆ OMP_CLAUSE_NUM_TEAMS_LOWER_EXPR

#define OMP_CLAUSE_NUM_TEAMS_LOWER_EXPR ( NODE ) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_TEAMS), 1)

Referenced by dump_omp_clause(), gimplify_scan_omp_clauses(), lower_omp_teams(), and optimize_target_teams().

◆ OMP_CLAUSE_NUM_TEAMS_UPPER_EXPR

#define OMP_CLAUSE_NUM_TEAMS_UPPER_EXPR ( NODE ) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_TEAMS), 0)

Referenced by dump_omp_clause(), expand_teams_call(), get_target_arguments(), lower_omp_teams(), and optimize_target_teams().

◆ OMP_CLAUSE_NUM_THREADS_EXPR

#define OMP_CLAUSE_NUM_THREADS_EXPR ( NODE ) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_THREADS),0)

Referenced by create_parallel_loop(), dump_omp_clause(), and expand_parallel_call().

◆ OMP_CLAUSE_NUM_WORKERS_EXPR

#define OMP_CLAUSE_NUM_WORKERS_EXPR ( NODE )

Value:

OMP_CLAUSE_OPERAND ( \

OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_WORKERS), 0)

OMP_CLAUSE_NUM_WORKERS

@ OMP_CLAUSE_NUM_WORKERS

Definition tree-core.h:520

Referenced by dump_omp_clause().

◆ OMP_CLAUSE_OPERAND

◆ OMP_CLAUSE_ORDER_REPRODUCIBLE

#define OMP_CLAUSE_ORDER_REPRODUCIBLE ( NODE ) TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ORDER))

True for reproducible modifier on order(concurrent) clause.

Referenced by dump_omp_clause().

◆ OMP_CLAUSE_ORDER_UNCONSTRAINED

#define OMP_CLAUSE_ORDER_UNCONSTRAINED ( NODE ) (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ORDER)->base.public_flag)

True for unconstrained modifier on order(concurrent) clause.

Referenced by dump_omp_clause(), and omp_extract_for_data().

◆ OMP_CLAUSE_ORDERED_DOACROSS

#define OMP_CLAUSE_ORDERED_DOACROSS ( NODE ) (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ORDERED)->base.public_flag)

True on an OMP_CLAUSE_ORDERED if stand-alone ordered construct is nested
inside of work-sharing loop the clause is on.

Referenced by check_omp_nesting_restrictions(), gimplify_omp_for(), and omp_extract_for_data().

◆ OMP_CLAUSE_ORDERED_EXPR

#define OMP_CLAUSE_ORDERED_EXPR ( NODE ) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ORDERED), 0)

Referenced by check_omp_nesting_restrictions(), dump_omp_clause(), and omp_extract_for_data().

◆ OMP_CLAUSE_PRIORITY_EXPR

#define OMP_CLAUSE_PRIORITY_EXPR ( NODE ) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_PRIORITY),0)

Referenced by dump_omp_clause(), and expand_task_call().

◆ OMP_CLAUSE_PRIVATE_DEBUG

#define OMP_CLAUSE_PRIVATE_DEBUG ( NODE ) (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_PRIVATE)->base.public_flag)

True on a PRIVATE clause if its decl is kept around for debugging
information only and its DECL_VALUE_EXPR is supposed to point
to what it has been remapped to.

Referenced by gimplify_adjust_omp_clauses(), gimplify_adjust_omp_clauses_1(), lower_rec_input_clauses(), and scan_sharing_clauses().

◆ OMP_CLAUSE_PRIVATE_OUTER_REF

#define OMP_CLAUSE_PRIVATE_OUTER_REF ( NODE ) TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_PRIVATE))

True on a PRIVATE clause if ctor needs access to outer region's
variable.

Referenced by create_task_copyfn(), gimplify_adjust_omp_clauses_1(), gimplify_scan_omp_clauses(), lower_rec_input_clauses(), lower_send_clauses(), and scan_sharing_clauses().

◆ OMP_CLAUSE_PRIVATE_TASKLOOP_IV

#define OMP_CLAUSE_PRIVATE_TASKLOOP_IV ( NODE ) TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_PRIVATE))

True if a PRIVATE clause is for a C++ class IV on taskloop construct
(thus should be private on the outer taskloop and firstprivate on
task).

Referenced by gimplify_omp_for().

◆ OMP_CLAUSE_PROC_BIND_KIND

#define OMP_CLAUSE_PROC_BIND_KIND ( NODE ) (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_PROC_BIND)->omp_clause.subcode.proc_bind_kind)

Referenced by dump_omp_clause(), expand_parallel_call(), hash_tree(), pack_ts_omp_clause_value_fields(), and unpack_ts_omp_clause_value_fields().

◆ OMP_CLAUSE_RANGE_CHECK

#define OMP_CLAUSE_RANGE_CHECK	(	T,
		CODE1,
		CODE2 ) (T)

◆ OMP_CLAUSE_REDUCTION_CODE

#define OMP_CLAUSE_REDUCTION_CODE ( NODE )

Value:

(OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_REDUCTION, \

OMP_CLAUSE_IN_REDUCTION)->omp_clause.subcode.reduction_code)

OMP_CLAUSE_REDUCTION

@ OMP_CLAUSE_REDUCTION

Definition tree-core.h:272

OMP_CLAUSE_IN_REDUCTION

@ OMP_CLAUSE_IN_REDUCTION

Definition tree-core.h:278

Referenced by dump_omp_clause(), hash_tree(), lower_oacc_reductions(), lower_omp_for_scan(), lower_omp_scan(), lower_omp_task_reductions(), lower_rec_input_clauses(), lower_rec_simd_input_clauses(), lower_reduction_clauses(), omp_reduction_init(), pack_ts_omp_clause_value_fields(), scan_omp_for(), and unpack_ts_omp_clause_value_fields().

◆ OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER

#define OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER ( NODE )

Value:

OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_REDUCTION, \

OMP_CLAUSE_IN_REDUCTION), 4)

Referenced by convert_local_omp_clauses(), convert_nonlocal_omp_clauses(), gimplify_omp_loop(), gimplify_scan_omp_clauses(), lower_omp_task_reductions(), lower_rec_input_clauses(), and lower_reduction_clauses().

◆ OMP_CLAUSE_REDUCTION_GIMPLE_INIT

#define OMP_CLAUSE_REDUCTION_GIMPLE_INIT ( NODE ) (OMP_CLAUSE_CHECK (NODE))->omp_clause.gimple_reduction_init

Referenced by convert_local_omp_clauses(), convert_nonlocal_omp_clauses(), gimplify_scan_omp_clauses(), lower_omp_for_scan(), lower_omp_scan(), lower_rec_input_clauses(), replace_locals_op(), scan_sharing_clauses(), and write_ts_omp_clause_tree_pointers().

◆ OMP_CLAUSE_REDUCTION_GIMPLE_MERGE

#define OMP_CLAUSE_REDUCTION_GIMPLE_MERGE ( NODE ) (OMP_CLAUSE_CHECK (NODE))->omp_clause.gimple_reduction_merge

Referenced by convert_local_omp_clauses(), convert_nonlocal_omp_clauses(), gimplify_scan_omp_clauses(), lower_omp_for_scan(), lower_omp_scan(), lower_omp_task_reductions(), lower_rec_input_clauses(), lower_reduction_clauses(), replace_locals_op(), scan_sharing_clauses(), and write_ts_omp_clause_tree_pointers().

◆ OMP_CLAUSE_REDUCTION_INIT

#define OMP_CLAUSE_REDUCTION_INIT ( NODE )

Value:

OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_REDUCTION, \

OMP_CLAUSE_IN_REDUCTION), 1)

Referenced by gimplify_omp_loop(), and gimplify_scan_omp_clauses().

◆ OMP_CLAUSE_REDUCTION_INSCAN

#define OMP_CLAUSE_REDUCTION_INSCAN ( NODE ) TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_REDUCTION))

True if a REDUCTION clause has inscan reduction-modifier.

Referenced by dump_omp_clause(), gimplify_adjust_omp_clauses(), gimplify_omp_loop(), gimplify_scan_omp_clauses(), lower_omp_for_scan(), lower_omp_scan(), lower_rec_input_clauses(), scan_omp_1_stmt(), and scan_sharing_clauses().

◆ OMP_CLAUSE_REDUCTION_MERGE

#define OMP_CLAUSE_REDUCTION_MERGE ( NODE )

Value:

OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_REDUCTION, \

OMP_CLAUSE_IN_REDUCTION), 2)

Referenced by gimplify_omp_loop(), and gimplify_scan_omp_clauses().

◆ OMP_CLAUSE_REDUCTION_OMP_ORIG_REF

#define OMP_CLAUSE_REDUCTION_OMP_ORIG_REF ( NODE )

Value:

(OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_REDUCTION, \

OMP_CLAUSE_IN_REDUCTION)->base.public_flag)

True if a REDUCTION clause may reference the original list item (omp_orig)
in its OMP_CLAUSE_REDUCTION_{,GIMPLE_}INIT.

Referenced by lower_rec_input_clauses().

◆ OMP_CLAUSE_REDUCTION_PLACEHOLDER

#define OMP_CLAUSE_REDUCTION_PLACEHOLDER ( NODE )

Value:

OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_REDUCTION, \

OMP_CLAUSE_IN_REDUCTION), 3)

Referenced by convert_local_omp_clauses(), convert_nonlocal_omp_clauses(), gimplify_omp_loop(), gimplify_scan_omp_clauses(), lower_omp_for_scan(), lower_omp_scan(), lower_omp_task_reductions(), lower_rec_input_clauses(), lower_rec_simd_input_clauses(), lower_reduction_clauses(), and scan_sharing_clauses().

◆ OMP_CLAUSE_REDUCTION_TASK

#define OMP_CLAUSE_REDUCTION_TASK ( NODE ) TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_REDUCTION))

True if a REDUCTION clause has task reduction-modifier.

Referenced by dump_omp_clause(), gimplify_omp_loop(), gimplify_scan_omp_clauses(), lower_rec_input_clauses(), lower_reduction_clauses(), lower_send_clauses(), omp_task_reduction_iterate(), omp_task_reductions_find_first(), scan_omp_parallel(), and scan_sharing_clauses().

◆ OMP_CLAUSE_RELEASE_DESCRIPTOR

#define OMP_CLAUSE_RELEASE_DESCRIPTOR ( NODE ) TREE_NOTHROW (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP))

Nonzero if this is a release/delete node which refers to a (Fortran) array
descriptor.

Referenced by dump_omp_clause(), gimplify_scan_omp_clauses(), and omp_map_clause_descriptor_p().

◆ OMP_CLAUSE_SAFELEN_EXPR

#define OMP_CLAUSE_SAFELEN_EXPR ( NODE ) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SAFELEN), 0)

Referenced by dump_omp_clause(), expand_omp_simd(), gimplify_adjust_omp_clauses(), lower_rec_input_clauses(), and lower_rec_simd_input_clauses().

◆ OMP_CLAUSE_SCHEDULE_CHUNK_EXPR

#define OMP_CLAUSE_SCHEDULE_CHUNK_EXPR ( NODE ) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SCHEDULE), 0)

Referenced by convert_local_omp_clauses(), convert_nonlocal_omp_clauses(), create_parallel_loop(), dump_omp_clause(), and omp_extract_for_data().

◆ OMP_CLAUSE_SCHEDULE_KIND

#define OMP_CLAUSE_SCHEDULE_KIND ( NODE ) (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SCHEDULE)->omp_clause.subcode.schedule_kind)

Referenced by create_parallel_loop(), determine_parallel_type(), dump_omp_clause(), hash_tree(), omp_extract_for_data(), pack_ts_omp_clause_value_fields(), and unpack_ts_omp_clause_value_fields().

◆ OMP_CLAUSE_SCHEDULE_SIMD

#define OMP_CLAUSE_SCHEDULE_SIMD ( NODE ) (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SCHEDULE)->base.public_flag)

True if a SCHEDULE clause has the simd modifier on it.

Referenced by dump_omp_clause(), and omp_extract_for_data().

◆ OMP_CLAUSE_SELF_EXPR

#define OMP_CLAUSE_SELF_EXPR ( NODE ) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SELF), 0)

Referenced by dump_omp_clause(), and expand_omp_target().

◆ OMP_CLAUSE_SET_CODE

#define OMP_CLAUSE_SET_CODE	(		NODE,
			CODE ) ((OMP_CLAUSE_CHECK (NODE))->omp_clause.code = (CODE))

Referenced by build_omp_clause(), gimplify_adjust_omp_clauses(), and scan_sharing_clauses().

◆ OMP_CLAUSE_SET_MAP_KIND

#define OMP_CLAUSE_SET_MAP_KIND	(		NODE,
			MAP_KIND )

Value:

(OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP)->omp_clause.subcode.map_kind \

= (unsigned int) (MAP_KIND))

OMP_CLAUSE_MAP

@ OMP_CLAUSE_MAP

Definition tree-core.h:345

Referenced by build_omp_struct_comp_nodes(), convert_gimple_call(), convert_local_reference_stmt(), convert_nonlocal_reference_stmt(), convert_tramp_reference_stmt(), decompose_kernels_region_body(), gimplify_adjust_omp_clauses(), gimplify_adjust_omp_clauses_1(), gimplify_oacc_declare_1(), gimplify_omp_target_update(), maybe_build_inner_data_region(), omp_accumulate_sibling_list(), omp_build_struct_sibling_lists(), omp_oacc_kernels_decompose_1(), omp_resolve_clause_dependencies(), and unpack_ts_omp_clause_value_fields().

◆ OMP_CLAUSE_SHARED_FIRSTPRIVATE

#define OMP_CLAUSE_SHARED_FIRSTPRIVATE ( NODE ) (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SHARED)->base.public_flag)

True on a SHARED clause if a FIRSTPRIVATE clause for the same
decl is present in the chain (this can happen only for taskloop
with FIRSTPRIVATE/LASTPRIVATE on it originally.

Referenced by create_task_copyfn(), finish_taskreg_scan(), gimplify_omp_for(), lower_rec_input_clauses(), lower_send_clauses(), and scan_sharing_clauses().

◆ OMP_CLAUSE_SHARED_READONLY

#define OMP_CLAUSE_SHARED_READONLY ( NODE ) TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SHARED))

True on a SHARED clause if a scalar is not modified in the body and
thus could be optimized as firstprivate.

Referenced by convert_local_omp_clauses(), convert_nonlocal_omp_clauses(), gimplify_adjust_omp_clauses(), gimplify_adjust_omp_clauses_1(), and scan_sharing_clauses().

◆ OMP_CLAUSE_SIMDLEN_EXPR

#define OMP_CLAUSE_SIMDLEN_EXPR ( NODE ) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SIMDLEN), 0)

Referenced by dump_omp_clause(), expand_omp_simd(), lower_rec_input_clauses(), omp_construct_simd_compare(), omp_declare_simd_clauses_equal(), and simd_clone_clauses_extract().

◆ OMP_CLAUSE_SIZE

#define OMP_CLAUSE_SIZE ( NODE )

Value:

  OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (OMP_CLAUSE_CHECK (NODE),  \
                                              OMP_CLAUSE_FROM,          \
                                              OMP_CLAUSE__CACHE_), 1)

Referenced by build_omp_struct_comp_nodes(), convert_gimple_call(), convert_local_omp_clauses(), convert_local_reference_stmt(), convert_nonlocal_omp_clauses(), convert_nonlocal_reference_stmt(), convert_tramp_reference_stmt(), decompose_kernels_region_body(), dump_omp_clause(), gimplify_adjust_omp_clauses(), gimplify_adjust_omp_clauses_1(), gimplify_scan_omp_clauses(), lower_omp_target(), maybe_build_inner_data_region(), omp_accumulate_sibling_list(), omp_build_struct_sibling_lists(), omp_group_base(), omp_group_last(), omp_oacc_kernels_decompose_1(), omp_resolve_clause_dependencies(), and scan_sharing_clauses().

◆ OMP_CLAUSE_SUBCODE_CHECK

#define OMP_CLAUSE_SUBCODE_CHECK	(		T,
			CODE ) (T)

◆ OMP_CLAUSE_THREAD_LIMIT_EXPR

#define OMP_CLAUSE_THREAD_LIMIT_EXPR ( NODE )

Value:

OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, \

OMP_CLAUSE_THREAD_LIMIT), 0)

OMP_CLAUSE_THREAD_LIMIT

@ OMP_CLAUSE_THREAD_LIMIT

Definition tree-core.h:438

Referenced by dump_omp_clause(), expand_teams_call(), get_target_arguments(), lower_omp_teams(), and optimize_target_teams().

◆ OMP_CLAUSE_TILE_COUNT

#define OMP_CLAUSE_TILE_COUNT ( NODE ) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_TILE), 2)

Referenced by omp_extract_for_data().

◆ OMP_CLAUSE_TILE_ITERVAR

#define OMP_CLAUSE_TILE_ITERVAR ( NODE ) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_TILE), 1)

Referenced by omp_extract_for_data().

◆ OMP_CLAUSE_TILE_LIST

#define OMP_CLAUSE_TILE_LIST ( NODE ) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_TILE), 0)

Referenced by dump_omp_clause(), gimplify_omp_for(), and omp_extract_for_data().

◆ OMP_CLAUSE_USE_DEVICE_PTR_IF_PRESENT

#define OMP_CLAUSE_USE_DEVICE_PTR_IF_PRESENT ( NODE ) (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_USE_DEVICE_PTR)->base.public_flag)

True on an OMP_CLAUSE_USE_DEVICE_PTR with an OpenACC 'if_present'
clause.

Referenced by dump_omp_clause(), gimplify_omp_workshare(), and lower_omp_target().

◆ OMP_CLAUSE_VECTOR_EXPR

#define OMP_CLAUSE_VECTOR_EXPR ( NODE )

Value:

OMP_CLAUSE_OPERAND ( \

OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_VECTOR), 0)

OMP_CLAUSE_VECTOR

@ OMP_CLAUSE_VECTOR

Definition tree-core.h:514

Referenced by dump_omp_clause(), and scan_omp_for().

◆ OMP_CLAUSE_VECTOR_LENGTH_EXPR

#define OMP_CLAUSE_VECTOR_LENGTH_EXPR ( NODE )

Value:

OMP_CLAUSE_OPERAND ( \

OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_VECTOR_LENGTH), 0)

OMP_CLAUSE_VECTOR_LENGTH

@ OMP_CLAUSE_VECTOR_LENGTH

Definition tree-core.h:523

Referenced by dump_omp_clause().

◆ OMP_CLAUSE_WAIT_EXPR

#define OMP_CLAUSE_WAIT_EXPR ( NODE )

Value:

OMP_CLAUSE_OPERAND ( \

OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_WAIT), 0)

OMP_CLAUSE_WAIT

@ OMP_CLAUSE_WAIT

Definition tree-core.h:369

Referenced by dump_omp_clause(), and expand_omp_target().

◆ OMP_CLAUSE_WORKER_EXPR

#define OMP_CLAUSE_WORKER_EXPR ( NODE )

Value:

OMP_CLAUSE_OPERAND ( \

OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_WORKER), 0)

OMP_CLAUSE_WORKER

@ OMP_CLAUSE_WORKER

Definition tree-core.h:511

Referenced by dump_omp_clause(), and scan_omp_for().

◆ OMP_CLAUSES

#define OMP_CLAUSES ( NODE ) TREE_OPERAND (TREE_RANGE_CHECK (NODE, OACC_PARALLEL, OMP_SCAN), 1)

Referenced by dump_generic_node(), gimplify_omp_workshare(), omp_discover_declare_target_fn_r(), and omp_discover_declare_target_tgt_fn_r().

◆ OMP_CRITICAL_BODY

#define OMP_CRITICAL_BODY ( NODE ) TREE_OPERAND (OMP_CRITICAL_CHECK (NODE), 0)

◆ OMP_CRITICAL_CLAUSES

#define OMP_CRITICAL_CLAUSES ( NODE ) TREE_OPERAND (OMP_CRITICAL_CHECK (NODE), 1)

Referenced by dump_generic_node(), and gimplify_expr().

◆ OMP_CRITICAL_NAME

#define OMP_CRITICAL_NAME ( NODE ) TREE_OPERAND (OMP_CRITICAL_CHECK (NODE), 2)

Referenced by dump_generic_node(), and gimplify_expr().

◆ OMP_FOR_BODY

#define OMP_FOR_BODY ( NODE ) TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 0)

Referenced by dump_generic_node(), gimplify_omp_for(), and gimplify_omp_loop().

◆ OMP_FOR_CLAUSES

#define OMP_FOR_CLAUSES ( NODE ) TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 1)

Referenced by dump_generic_node(), gimplify_omp_for(), gimplify_omp_loop(), and gimplify_omp_taskloop_expr().

◆ OMP_FOR_COND

#define OMP_FOR_COND ( NODE ) TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 3)

Referenced by dump_generic_node(), and gimplify_omp_for().

◆ OMP_FOR_INCR

#define OMP_FOR_INCR ( NODE ) TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 4)

Referenced by dump_generic_node(), and gimplify_omp_for().

◆ OMP_FOR_INIT

#define OMP_FOR_INIT ( NODE ) TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 2)

Referenced by dump_generic_node(), find_combined_omp_for(), gimplify_omp_for(), and gimplify_omp_loop().

◆ OMP_FOR_NON_RECTANGULAR

#define OMP_FOR_NON_RECTANGULAR ( NODE ) (OMP_LOOPING_CHECK (NODE)->base.private_flag)

True on OMP_FOR and other OpenMP/OpenACC looping constructs if the loop nest
is non-rectangular.

Referenced by gimplify_omp_for().

◆ OMP_FOR_ORIG_DECLS

#define OMP_FOR_ORIG_DECLS ( NODE ) TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 6)

Referenced by gimplify_omp_for(), and gimplify_omp_loop().

◆ OMP_FOR_PRE_BODY

#define OMP_FOR_PRE_BODY ( NODE ) TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 5)

Referenced by dump_generic_node(), and gimplify_omp_for().

◆ OMP_LOOPING_CHECK

#define OMP_LOOPING_CHECK ( NODE ) TREE_RANGE_CHECK (NODE, OMP_FOR, OACC_LOOP)

◆ OMP_MASKED_BODY

#define OMP_MASKED_BODY ( NODE ) TREE_OPERAND (OMP_MASKED_CHECK (NODE), 0)

◆ OMP_MASKED_CLAUSES

#define OMP_MASKED_CLAUSES ( NODE ) TREE_OPERAND (OMP_MASKED_CHECK (NODE), 1)

Referenced by dump_generic_node(), and gimplify_expr().

◆ OMP_MASKED_COMBINED

#define OMP_MASKED_COMBINED ( NODE ) (OMP_MASKED_CHECK (NODE)->base.private_flag)

True on an OMP_MASKED statement if it represents an explicit
combined masked constructs.

◆ OMP_MASTER_BODY

#define OMP_MASTER_BODY ( NODE ) TREE_OPERAND (OMP_MASTER_CHECK (NODE), 0)

◆ OMP_MASTER_COMBINED

#define OMP_MASTER_COMBINED ( NODE ) (OMP_MASTER_CHECK (NODE)->base.private_flag)

True on an OMP_MASTER statement if it represents an explicit
combined master constructs.

◆ OMP_ORDERED_BODY

#define OMP_ORDERED_BODY ( NODE ) TREE_OPERAND (OMP_ORDERED_CHECK (NODE), 0)

Referenced by find_standalone_omp_ordered().

◆ OMP_ORDERED_CLAUSES

#define OMP_ORDERED_CLAUSES ( NODE ) TREE_OPERAND (OMP_ORDERED_CHECK (NODE), 1)

Referenced by dump_generic_node(), and gimplify_omp_ordered().

◆ OMP_PARALLEL_BODY

#define OMP_PARALLEL_BODY ( NODE ) TREE_OPERAND (OMP_PARALLEL_CHECK (NODE), 0)

Referenced by gimplify_omp_loop(), and gimplify_omp_parallel().

◆ OMP_PARALLEL_CLAUSES

#define OMP_PARALLEL_CLAUSES ( NODE ) TREE_OPERAND (OMP_PARALLEL_CHECK (NODE), 1)

Referenced by dump_generic_node(), gimplify_omp_for(), gimplify_omp_loop(), and gimplify_omp_parallel().

◆ OMP_PARALLEL_COMBINED

#define OMP_PARALLEL_COMBINED ( NODE ) (OMP_PARALLEL_CHECK (NODE)->base.private_flag)

True on an OMP_PARALLEL statement if it represents an explicit
combined parallel work-sharing constructs.

Referenced by gimplify_omp_loop(), and gimplify_omp_parallel().

◆ OMP_SCAN_BODY

#define OMP_SCAN_BODY ( NODE ) TREE_OPERAND (OMP_SCAN_CHECK (NODE), 0)

◆ OMP_SCAN_CLAUSES

#define OMP_SCAN_CLAUSES ( NODE ) TREE_OPERAND (OMP_SCAN_CHECK (NODE), 1)

Referenced by dump_generic_node(), and gimplify_expr().

◆ OMP_SCOPE_BODY

#define OMP_SCOPE_BODY ( NODE ) TREE_OPERAND (OMP_SCOPE_CHECK (NODE), 0)

◆ OMP_SCOPE_CLAUSES

#define OMP_SCOPE_CLAUSES ( NODE ) TREE_OPERAND (OMP_SCOPE_CHECK (NODE), 1)

Referenced by dump_generic_node().

◆ OMP_SECTION_BODY

#define OMP_SECTION_BODY ( NODE ) TREE_OPERAND (OMP_SECTION_CHECK (NODE), 0)

◆ OMP_SECTION_LAST

#define OMP_SECTION_LAST ( NODE ) (OMP_SECTION_CHECK (NODE)->base.private_flag)

True on an OMP_SECTION statement that was the last lexical member.
This status is meaningful in the implementation of lastprivate.

◆ OMP_SECTIONS_BODY

#define OMP_SECTIONS_BODY ( NODE ) TREE_OPERAND (OMP_SECTIONS_CHECK (NODE), 0)

◆ OMP_SECTIONS_CLAUSES

#define OMP_SECTIONS_CLAUSES ( NODE ) TREE_OPERAND (OMP_SECTIONS_CHECK (NODE), 1)

Referenced by dump_generic_node().

◆ OMP_SINGLE_BODY

#define OMP_SINGLE_BODY ( NODE ) TREE_OPERAND (OMP_SINGLE_CHECK (NODE), 0)

◆ OMP_SINGLE_CLAUSES

#define OMP_SINGLE_CLAUSES ( NODE ) TREE_OPERAND (OMP_SINGLE_CHECK (NODE), 1)

Referenced by dump_generic_node().

◆ OMP_STANDALONE_CLAUSES

#define OMP_STANDALONE_CLAUSES ( NODE ) TREE_OPERAND (TREE_RANGE_CHECK (NODE, OACC_CACHE, OMP_TARGET_EXIT_DATA), 0)

Generic accessors for OMP nodes that keep clauses as operand 0.

Referenced by gimplify_omp_target_update().

◆ OMP_STRUCTURED_BLOCK_BODY

#define OMP_STRUCTURED_BLOCK_BODY ( NODE ) TREE_OPERAND (OMP_STRUCTURED_BLOCK_CHECK (NODE), 0)

◆ OMP_TARGET_BODY

#define OMP_TARGET_BODY ( NODE ) TREE_OPERAND (OMP_TARGET_CHECK (NODE), 0)

Referenced by omp_discover_declare_target_fn_r().

◆ OMP_TARGET_CLAUSES

#define OMP_TARGET_CLAUSES ( NODE ) TREE_OPERAND (OMP_TARGET_CHECK (NODE), 1)

Referenced by dump_generic_node(), and optimize_target_teams().

◆ OMP_TARGET_COMBINED

#define OMP_TARGET_COMBINED ( NODE ) (OMP_TARGET_CHECK (NODE)->base.private_flag)

True on an OMP_TARGET statement if it represents explicit
combined target teams, target parallel or target simd constructs.

Referenced by gimplify_omp_workshare().

◆ OMP_TARGET_DATA_BODY

#define OMP_TARGET_DATA_BODY ( NODE ) TREE_OPERAND (OMP_TARGET_DATA_CHECK (NODE), 0)

◆ OMP_TARGET_DATA_CLAUSES

#define OMP_TARGET_DATA_CLAUSES ( NODE ) TREE_OPERAND (OMP_TARGET_DATA_CHECK (NODE), 1)

Referenced by dump_generic_node().

◆ OMP_TARGET_ENTER_DATA_CLAUSES

#define OMP_TARGET_ENTER_DATA_CLAUSES ( NODE ) TREE_OPERAND (OMP_TARGET_ENTER_DATA_CHECK (NODE), 0)

Referenced by dump_generic_node().

◆ OMP_TARGET_EXIT_DATA_CLAUSES

#define OMP_TARGET_EXIT_DATA_CLAUSES ( NODE ) TREE_OPERAND (OMP_TARGET_EXIT_DATA_CHECK (NODE), 0)

Referenced by dump_generic_node().

◆ OMP_TARGET_UPDATE_CLAUSES

#define OMP_TARGET_UPDATE_CLAUSES ( NODE ) TREE_OPERAND (OMP_TARGET_UPDATE_CHECK (NODE), 0)

Referenced by dump_generic_node().

◆ OMP_TASK_BODY

#define OMP_TASK_BODY ( NODE ) TREE_OPERAND (OMP_TASK_CHECK (NODE), 0)

Referenced by dump_generic_node(), and gimplify_omp_task().

◆ OMP_TASK_CLAUSES

#define OMP_TASK_CLAUSES ( NODE ) TREE_OPERAND (OMP_TASK_CHECK (NODE), 1)

Referenced by dump_generic_node(), and gimplify_omp_task().

◆ OMP_TASKGROUP_BODY

#define OMP_TASKGROUP_BODY ( NODE ) TREE_OPERAND (OMP_TASKGROUP_CHECK (NODE), 0)

◆ OMP_TASKGROUP_CLAUSES

#define OMP_TASKGROUP_CLAUSES ( NODE ) TREE_OPERAND (OMP_TASKGROUP_CHECK (NODE), 1)

Referenced by dump_generic_node(), and gimplify_expr().

◆ OMP_TASKREG_BODY

#define OMP_TASKREG_BODY ( NODE ) TREE_OPERAND (OMP_TASKREG_CHECK (NODE), 0)

◆ OMP_TASKREG_CHECK

#define OMP_TASKREG_CHECK ( NODE ) TREE_RANGE_CHECK (NODE, OMP_PARALLEL, OMP_TASK)

◆ OMP_TASKREG_CLAUSES

#define OMP_TASKREG_CLAUSES ( NODE ) TREE_OPERAND (OMP_TASKREG_CHECK (NODE), 1)

◆ OMP_TEAMS_BODY

#define OMP_TEAMS_BODY ( NODE ) TREE_OPERAND (OMP_TEAMS_CHECK (NODE), 0)

◆ OMP_TEAMS_CLAUSES

#define OMP_TEAMS_CLAUSES ( NODE ) TREE_OPERAND (OMP_TEAMS_CHECK (NODE), 1)

Referenced by dump_generic_node(), and optimize_target_teams().

◆ OMP_TEAMS_COMBINED

#define OMP_TEAMS_COMBINED ( NODE ) (OMP_TEAMS_CHECK (NODE)->base.private_flag)

True on an OMP_TEAMS statement if it represents an explicit
combined teams distribute constructs.

Referenced by gimplify_omp_workshare().

◆ OPAQUE_TYPE_P

#define OPAQUE_TYPE_P ( NODE ) (TREE_CODE (NODE) == OPAQUE_TYPE)

Referenced by is_var_need_auto_init(), verify_opaque_type(), and verify_type().

◆ opt_for_fn

#define opt_for_fn	(		fndecl,
			opt ) (opts_for_fn (fndecl)->x_##opt)

opt flag for function FNDECL, e.g. opts_for_fn (fndecl, optimize) is
the optimization level of function fndecl.

Referenced by cgraph_node::add_new_function(), ipcp_lattice< valtype >::add_value(), cgraph_node::analyze(), analyze_function(), analyze_function_body(), analyze_functions(), big_speedup_p(), caller_growth_limits(), can_inline_edge_by_limits_p(), can_inline_edge_p(), can_remove_node_now_p_1(), cgraph_edge::cannot_lead_to_return_p(), cgraph_node::cannot_return_p(), check_callers(), ipa_icf::sem_function::compare_polymorphic_p(), ipa_icf::sem_item::compare_referenced_symbol_properties(), ipa_icf::sem_function::compatible_parm_types_p(), compute_fn_summary(), compute_max_insns(), cgraph_node::create(), cgraph_node::create_clone(), symbol_table::create_edge(), cgraph_node::create_wrapper(), decompose_param_expr(), default_function_section(), determine_known_aggregate_parts(), determine_versionability(), devirtualization_time_bonus(), do_estimate_edge_time(), do_estimate_growth_1(), drop_profile(), cgraph_node::dump(), early_inline_small_functions(), early_inliner(), edge_badness(), ipa_icf::sem_function::equals_private(), ipa_icf::sem_function::equals_wpa(), estimate_edge_devirt_benefit(), expand_all_functions(), expand_call_inline(), modref_summary::finalize(), cgraph_node::finalize_function(), flatten_function(), fre_will_run_p(), function_and_variable_visibility(), generate_summary(), get_max_overall_size(), get_read_write_all_from_node(), good_cloning_opportunity_p(), gsi_insert_finally_seq_after_call(), ipa_icf::sem_item::hash_referenced_symbol_properties(), have_optimized_refs(), hint_time_bonus(), ignore_edge_for_nothrow(), ignore_edge_for_pure_const(), ignore_edge_p(), ignore_edge_p(), incorporate_penalties(), inline_account_function_p(), inline_analyze_function(), inline_call(), inline_insns_auto(), inline_insns_single(), inline_small_functions(), inline_transform(), funct_state_summary_t::insert(), ipa_sra_function_summaries::insert(), modref_summaries::insert(), modref_summaries_lto::insert(), modref_tree< T >::insert(), insert_init_debug_bind(), ipa_analyze_node(), ipa_compute_jump_functions_for_edge(), ipa_devirt(), ipa_fn_summary_generate(), ipa_func_spec_opts_forbid_analysis_p(), ipa_get_indirect_edge_target_1(), ipa_inline(), ipa_profile(), ipa_propagate_frequency(), ipa_reference_get_read_global(), ipa_reference_get_written_global(), ipa_sra_summarize_function(), ipcp_cloning_candidate_p(), ipcp_propagate_stage(), ipcp_store_vr_results(), ipcp_transform_function(), ipcp_update_vr(), ipcp_verify_propagated_values(), lenient_count_portion_handling(), cgraph_edge::maybe_hot_p(), modref_tree< T >::merge(), merge_aggregate_lattices(), offline_size(), cgraph_node::optimize_for_size_p(), possible_inline_candidate_p(), propagate(), propagate_aggs_across_jump_function(), propagate_bits(), propagate_constants_across_call(), propagate_constants_topo(), value_topo_info< valtype >::propagate_effects(), propagate_nothrow(), propagate_vals_across_arith_jfunc(), pure_const_generate_summary(), recursive_inlining(), remap_gimple_stmt(), symbol_table::remove_unreachable_nodes(), reset_debug_bindings(), cgraph_node::set_nothrow_flag(), set_switch_stmt_execution_predicate(), tp_first_run_node_cmp(), tree_inlinable_function_p(), try_make_edge_direct_virtual_call(), update_indirect_edges_after_inlining(), update_profiling_info(), cgraph_node::verify_node(), vrp_will_run_p(), walk_polymorphic_call_targets(), want_early_inline_function_p(), want_inline_self_recursive_call_p(), and want_inline_small_function_p().

◆ optimization_current_node

#define optimization_current_node global_trees[TI_OPTIMIZATION_CURRENT]

Referenced by decl_attributes(), invoke_set_current_function_hook(), process_options(), and target_reinit().

◆ optimization_default_node

#define optimization_default_node global_trees[TI_OPTIMIZATION_DEFAULT]

Optimization options (OPTIMIZATION_NODE) to use for default and current
functions.

Referenced by cgraph_build_static_cdtor(), decl_attributes(), invoke_set_current_function_hook(), opts_for_fn(), process_options(), and target_reinit().

◆ pid_type_node

#define pid_type_node global_trees[TI_PID_TYPE]

◆ pointer_sized_int_node

#define pointer_sized_int_node global_trees[TI_POINTER_SIZED_TYPE]

Referenced by add_taskreg_looptemp_clauses(), asan_emit_stack_protection(), asan_expand_check_ifn(), asan_expand_mark_ifn(), asan_expand_poison_ifn(), asan_finish_file(), asan_global_struct(), build_check_stmt(), build_common_tree_nodes(), create_task_copyfn(), expand_omp_scantemp_alloc(), expand_parallel_call(), initialize_sanitizer_builtins(), instrument_mem_ref(), instrument_object_size(), lower_omp_for(), lower_omp_scope(), lower_omp_sections(), lower_omp_target(), lower_omp_task_reductions(), lower_private_allocate(), lower_rec_input_clauses(), maybe_cast_to_ptrmode(), omp_build_struct_sibling_lists(), omp_finish_file(), optimize_range_tests_cmp_bitwise(), scan_omp_parallel(), simd_clone_adjust_argument_types(), simd_clone_adjust_return_type(), task_reduction_read(), ubsan_encode_value(), ubsan_expand_null_ifn(), ubsan_expand_objsize_ifn(), ubsan_expand_ptr_ifn(), and ubsan_expand_vptr_ifn().

◆ POINTER_TYPE_P

#define POINTER_TYPE_P ( TYPE ) (TREE_CODE (TYPE) == POINTER_TYPE || TREE_CODE (TYPE) == REFERENCE_TYPE)

Nonzero if TYPE represents a pointer or reference type.
(It should be renamed to INDIRECT_TYPE_P.)  Keep these checks in
ascending code order.

Referenced by add_autoinc_candidates(), add_candidate_1(), add_iv_candidate_for_biv(), add_iv_candidate_for_use(), add_scope_conflicts_2(), add_to_parts(), address_compare(), path_range_query::adjust_for_non_null_uses(), adjust_one_expanded_partition_var(), adjust_return_value_with_ops(), aff_combination_add_elt(), aff_combination_convert(), aff_combination_scale(), aff_combination_to_tree(), analyze_candidates_and_replace(), analyze_increments(), ao_ref_init_from_ptr_and_range(), ana::call_details::arg_is_pointer_p(), assert_loop_rolls_lt(), assign_parm_adjust_stack_rtl(), assign_parm_setup_reg(), find_candidates_dom_walker::before_dom_children(), strlen_pass::before_dom_children(), build2(), build_polynomial_chrec(), build_range_check(), build_sender_ref(), builtin_call_nomodifying_p(), builtin_mathfn_code(), cand_value_at(), canonical_type_used_p(), canonicalize_addr_expr(), canonicalize_base_object_address(), canonicalize_loop_ivs(), ccp_finalize(), check_access(), strlen_pass::check_and_optimize_stmt(), check_fnspec(), array_bounds_checker::check_mem_ref(), check_va_list_escapes(), chrec_apply(), chrec_convert_aggressive(), chrec_convert_rhs(), chrec_fold_plus(), chrec_fold_plus_poly_poly(), collect_object_sizes_for(), compare_values_warnv(), ipa_icf::sem_function::compatible_parm_types_p(), ipa_icf_gimple::func_checker::compatible_polymorphic_types_p(), compound_type_base(), compute_builtin_object_size(), compute_complex_ancestor_jump_func(), compute_complex_assign_jump_func(), compute_dependence_clique(), compute_new_first_bound(), compute_objsize_r(), compute_points_to_sets(), constant_byte_string(), constant_pointer_difference(), convert_affine_scev(), convert_to_integer_1(), create_add_on_incoming_edge(), create_iv(), create_mem_ref_raw(), create_tailcall_accumulator(), create_variable_info_for(), create_variable_info_for_1(), decl_attributes(), detect_type_change_ssa(), determine_base_object_1(), determine_known_aggregate_parts(), determine_parallel_type(), determine_set_costs(), DFS::DFS_write_tree_body(), do_compare_and_jump(), do_store_flag(), do_warn_nonnull_compare(), dse_optimize_call(), dump_alias_info(), dump_generic_node(), dump_mem_ref(), dump_ssaname_info(), dump_variable(), duplicate_ssa_name_fn(), duplicate_ssa_name_ptr_info(), duplicate_ssa_name_range_info(), eliminate_dom_walker::eliminate_stmt(), pointer_equiv_analyzer::enter(), evaluate_stmt(), execute_ranger_vrp(), expand_assignment(), expand_call(), expand_expr_addr_expr(), expand_expr_real_2(), expand_ifn_va_arg_1(), expand_oacc_collapse_init(), expand_oacc_collapse_vars(), expand_oacc_for(), expand_omp_atomic(), 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_ordered_source_sink(), expand_omp_simd(), expand_omp_taskloop_for_inner(), expand_omp_taskloop_for_outer(), expand_one_register_var(), expr_callee_abi(), expr_object_size(), extract_omp_for_update_vars(), final_value_replacement_loop(), finalize_nesting_tree_1(), find_bivs(), find_equal_ptrs(), find_inv_vars_cb(), find_tail_calls(), fini_copy_prop(), ipa_icf::sem_item_optimizer::fixup_points_to_sets(), fold_binary_loc(), fold_builtin_atomic_always_lock_free(), fold_builtin_constant_p(), fold_comparison(), fold_convert_const(), fold_convert_const_int_from_int(), fold_convert_loc(), fold_convertible_p(), fold_indirect_ref_1(), fold_to_nonsharp_ineq_using_bound(), fold_unary_loc(), follow_outer_ssa_edges(), forward_propagate_addr_expr_1(), generic_type_for(), get_alias_set(), modref_access_node::get_ao_ref(), get_base_for_alignment_1(), get_builtin_sync_mem(), get_computation_cost(), get_debug_computation_at(), get_initial_def_for_reduction(), get_iv(), get_memory_rtx(), get_nonzero_bits(), get_offset_range(), get_pointer_alignment_1(), get_ptr_info(), get_ref_size(), get_related_vectype_for_scalar_type(), get_ssa_name_ptr_info_nonnull(), get_ssa_name_range_info(), get_temp_reg(), get_type_static_bounds(), get_value_from_alignment(), gimple_build_call_from_tree(), gimple_canonical_types_compatible_p(), gimple_fold_builtin_fprintf(), gimple_fold_builtin_memory_op(), gimple_fold_builtin_memset(), gimple_fold_builtin_printf(), gimple_fold_builtin_sprintf(), gimple_fold_builtin_sprintf_chk(), gimple_fold_indirect_ref(), gimple_infer_range::gimple_infer_range(), gimple_lower_bitint(), gimple_parm_array_size(), gimple_range_global(), gimplify_bind_expr(), gimplify_init_ctor_preeval_1(), gimplify_modify_expr(), gimplify_omp_depend(), gimplify_omp_for(), gimplify_self_mod_expr(), gimplify_va_arg_expr(), go_format_type(), handle_component_ref(), handle_decl(), handle_printf_call(), handle_ssa_name(), hash_tree(), if_convertible_gimple_assign_stmt_p(), infer_nonnull_range_by_attribute(), infer_nonnull_range_by_dereference(), initializer_constant_valid_p_1(), insert_initializers(), install_var_field(), install_var_field(), instrument_mem_ref(), instrument_mem_region_access(), instrument_nonnull_arg(), instrument_nonnull_return(), instrument_object_size(), int_binop_types_match_p(), ipa_analyze_indirect_call_uses(), ipa_compute_jump_functions_for_edge(), ipa_polymorphic_call_context::ipa_polymorphic_call_context(), ipa_pta_execute(), ipcp_update_vr(), is_addr_local(), simplify_using_ranges::legacy_fold_cond_overflow(), loc_list_from_tree_1(), loop_exits_before_overflow(), lower_builtin_assume_aligned(), lower_lastprivate_clauses(), lower_oacc_reductions(), lower_omp_ordered_clauses(), lower_omp_target(), lower_rec_input_clauses(), lto_input_ts_type_non_common_tree_pointers(), make_bit_field_ref(), make_ssa_name_fn(), make_tree(), maybe_canonicalize_comparison_1(), maybe_diag_incompatible_alias(), maybe_emit_sprintf_chk_warning(), maybe_instrument_pointer_overflow(), maybe_invalidate(), maybe_set_nonzero_bits(), maybe_update_mem_ref_hash_table(), maybe_warn_operand(), maybe_warn_pass_by_reference(), ipa_icf::sem_item_optimizer::merge_classes(), ipa_param_adjustments::modify_call(), ipa_param_body_adjustments::modify_call_stmt(), modref_may_conflict(), move_pointer_to_base(), noncall_stmt_may_be_vtbl_ptr_store(), nonnull_arg_p(), note_nonlocal_vla_type(), nowrap_type_p(), number_of_iterations_cond(), number_of_iterations_exit_assumptions(), number_of_iterations_le(), number_of_iterations_lt_to_ne(), number_of_iterations_ne(), number_of_iterations_until_wrap(), odr_types_equivalent_p(), omp_adjust_for_condition(), omp_extract_for_data(), omp_reduction_init_op(), operator_cast::op1_range(), operator_cast::op1_range(), operator_cast::op1_range(), operator_cast::op1_range(), operand_compare::operand_equal_p(), optimize_atomic_op_fetch_cmp_0(), optimize_range_tests_cmp_bitwise(), optimize_stack_restore(), optimize_stdarg_builtin(), optimize_va_list_gpr_fpr_size(), output_constant(), parm_object_size(), parm_ref_data_pass_through_p(), pointer_may_wrap_p(), predicate_statements(), prepare_instrumented_value(), print_aff(), propagate_bits_across_jump_function(), propagate_subaccesses_from_rhs(), propagate_vr_across_jump_function(), propagate_with_phi(), ptr_deref_may_alias_decl_p(), ptr_derefs_may_alias_p(), push_fields_onto_fieldstack(), range_check_type(), path_range_query::range_defined_in_block(), range_fits_type_p(), fold_using_range::range_of_phi(), record_component_aliases(), record_group_use(), remap_ssa_name(), remap_vla_decls(), reset_evolution_in_loop(), reset_flow_sensitive_info(), flow_sensitive_info_storage::restore(), ipa_polymorphic_call_context::restrict_to_inner_class(), return_prediction(), reverse_storage_order_for_component_p(), rewrite_phi_with_iv(), rewrite_use_nonlinear_expr(), same_type_for_tbaa(), flow_sensitive_info_storage::save(), sbr_sparse_bitmap::sbr_sparse_bitmap(), scan_sharing_clauses(), scev_analyzable_p(), set_bitmask(), ranger_cache::set_global_range(), set_mem_attributes_minus_bitpos(), set_nonzero_bits(), set_ptr_nonnull(), set_range_info(), irange::set_varying(), signed_or_unsigned_type_for(), simd_clone_adjust(), simd_clone_adjust_argument_types(), simd_clone_adjust_return_type(), simd_clone_clauses_extract(), simd_clone_init_simd_arrays(), simd_clone_linear_addend(), simple_iv_with_niters(), simplify_using_ranges::simplify_casted_compare(), jump_threader::simplify_control_stmt_condition(), simplify_peeled_chrec(), slsr_process_add(), split_constant_offset_1(), std_canonical_va_list_type(), stmt_may_be_vtbl_ptr_store(), stmt_may_generate_copy(), stmt_uses_name_in_undefined_way(), substitute_placeholder_in_expr(), supported_pointer_equiv_p(), prange::supports_p(), prange::supports_type_p(), trailing_array(), tree_builtin_call_types_compatible_p(), tree_ctz(), tree_expr_nonzero_warnv_p(), tree_nop_conversion_p(), tree_optimize_tail_calls_1(), tree_predict_by_opcode(), tree_sign_nop_conversion(), type_contains_placeholder_1(), type_like_member_ptr_p(), type_must_have_pointers(), ubsan_expand_null_ifn(), ubsan_type_descriptor(), update_alias_info_with_stack_vars(), update_range_test(), used_types_insert(), useless_type_conversion_p(), validate_arg(), value_replacement(), irange::varying_compatible_p(), vect_check_gather_scatter(), vect_update_ivs_after_vectorizer(), vectorizable_reduction(), vectorizable_simd_clone_call(), verify_gimple_assign_binary(), verify_gimple_assign_unary(), verify_gimple_call(), verify_gimple_goto(), cgraph_node::verify_node(), verify_ssa(), verify_type_variant(), verify_types_in_gimple_reference(), pointer_equiv_analyzer::visit_edge(), VN_INFO(), walk_tree_1(), walk_type_fields(), warn_types_mismatch(), worker_single_copy(), and write_ts_type_non_common_tree_pointers().

◆ POLY_INT_CST_COEFF

#define POLY_INT_CST_COEFF	(		NODE,
			I ) (POLY_INT_CST_CHECK (NODE)->poly_int_cst.coeffs[I])

In a POLY_INT_CST node.

Referenced by build_new_poly_int_cst(), DFS::DFS_write_tree_body(), dump_generic_node(), operand_compare::hash_operand(), hash_tree(), lto_input_ts_poly_tree_pointers(), poly_int_cst_value(), print_node(), ptrdiff_tree_p(), wi::to_poly_offset(), wi::to_poly_widest(), tree_fits_poly_int64_p(), tree_fits_poly_uint64_p(), valid_constant_size_p(), and write_ts_poly_tree_pointers().

◆ POLY_INT_CST_P

#define POLY_INT_CST_P ( NODE ) (NUM_POLY_INT_COEFFS > 1 && TREE_CODE (NODE) == POLY_INT_CST)

Return true if NODE is a POLY_INT_CST.  This is only ever true on
targets with variable-sized modes.

Referenced by bits_from_bytes(), const_unop(), constant_multiple_of(), data_ref_compare_tree(), discover_nonconstant_array_refs_r(), fold_convert_const(), operand_compare::hash_operand(), multiple_of_p(), poly_int_tree_p(), ptrdiff_tree_p(), irange::set(), simple_cst_equal(), wi::to_poly_offset(), wi::to_poly_wide(), wi::to_poly_widest(), tree_fits_poly_int64_p(), tree_fits_poly_uint64_p(), and valid_constant_size_p().

◆ PREDICT_EXPR_OUTCOME

#define PREDICT_EXPR_OUTCOME ( NODE ) ((enum prediction) (PREDICT_EXPR_CHECK (NODE)->base.addressable_flag))

Referenced by dump_generic_node(), and gimplify_expr().

◆ PREDICT_EXPR_PREDICTOR

#define PREDICT_EXPR_PREDICTOR ( NODE ) ((enum br_predictor)tree_to_shwi (TREE_OPERAND (PREDICT_EXPR_CHECK (NODE), 0)))

Referenced by dump_generic_node(), and gimplify_expr().

◆ PTR_OR_REF_CHECK

#define PTR_OR_REF_CHECK ( T ) TREE_CHECK2 (T, POINTER_TYPE, REFERENCE_TYPE)

◆ ptr_type_node

#define ptr_type_node global_trees[TI_PTR_TYPE]

The C type `void *'.

Referenced by alias_set_subset_of(), alias_sets_conflict_p(), analyze_function_body(), build_common_builtin_nodes(), build_common_tree_nodes(), build_cxa_atexit_decl(), build_cxa_dtor_registrations(), build_dso_handle_decl(), build_instrumentation_call(), build_invariant_address(), build_omp_struct_comp_nodes(), build_personality_function(), build_stack_save_restore(), bump_vector_ptr(), canonicalize_constructor_val(), compute_avail(), cond_store_replacement(), create_function_info_for(), create_loop_fn(), create_omp_child_function(), create_stack_guard(), declare_return_variable(), default_emutls_var_fields(), default_stack_protect_guard(), detect_type_change_ssa(), determine_base_object_1(), dw2_output_indirect_constant_1(), emit_block_op_via_libcall(), evaluate_stmt(), expand_call_inline(), expand_omp_for_static_nochunk(), expand_omp_scantemp_alloc(), expand_omp_target(), expand_task_call(), finalize_nesting_tree_1(), forward_propagate_addr_expr_1(), gather_mem_refs_stmt(), generate_memcpy_builtin(), get_alias_set(), get_descriptor_type(), get_group_alias_ptr_type(), get_last_alloca_addr(), get_memory_rtx(), get_nl_goto_field(), get_target_argument_identifier(), get_target_argument_value(), get_target_arguments(), gimple_fold_builtin_memchr(), gimple_fold_builtin_memset(), gimple_fold_stmt_to_constant_1(), gimple_gen_ic_func_profiler(), gimple_gen_ic_profiler(), gimple_ic(), gimple_init_gcov_profiler(), gimplify_bind_expr(), gimplify_omp_depend(), handle_abnormal_edges(), handle_builtin_alloca(), increment_start_addr(), init_eh(), init_ic_make_global_vars(), initialize_data_dependence_relation(), initialize_sanitizer_builtins(), instrument_func_entry(), ipa_get_jf_ancestor_result(), ipa_tm_insert_gettmclone_call(), issue_prefetch_ref(), lower_builtin_posix_memalign(), lower_coro_builtin(), lower_depend_clauses(), lower_omp_critical(), lower_omp_for_scan(), lower_omp_target(), lower_omp_task_reductions(), lower_rec_input_clauses(), lower_resx(), lower_transaction(), make_bit_field_ref(), make_heapvar(), ipa_param_adjustments::modify_call(), push_target_argument_according_to_value(), record_component_aliases(), record_equivalences_from_stmt(), reference_alias_ptr_type(), scan_sharing_clauses(), set_stack_check_libfunc(), set_storage_via_libcall(), simd_clone_adjust(), sjlj_emit_function_enter(), std_build_builtin_va_list(), loop_distribution::transform_reduction_loop(), ubsan_source_location(), update_alias_info_with_stack_vars(), vect_create_cond_for_align_checks(), vectorizable_load(), vectorizable_store(), and vn_reference_lookup_3().

◆ ptrdiff_type_node

#define ptrdiff_type_node global_trees[TI_PTRDIFF_TYPE]

◆ qq_type_node

#define qq_type_node global_trees[TI_QQ_TYPE]

◆ RECORD_OR_UNION_CHECK

#define RECORD_OR_UNION_CHECK ( T ) TREE_CHECK3 (T, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE)

◆ RECORD_OR_UNION_TYPE_P

#define RECORD_OR_UNION_TYPE_P ( TYPE )

Value:

  (TREE_CODE (TYPE) == RECORD_TYPE              \
   || TREE_CODE (TYPE) == UNION_TYPE            \
   || TREE_CODE (TYPE) == QUAL_UNION_TYPE)

Nonzero if TYPE is a record or union type.

Referenced by addr_object_size(), array_elt_at_offset(), assign_parm_find_data_types(), build_type_attribute_qual_variant(), contains_polymorphic_type_p(), cxx17_empty_base_field_p(), DFS::DFS_write_tree_body(), diag_attr_exclusions(), get_maxbound(), go_format_type(), go_output_typedef(), go_output_var(), hash_tree(), inbounds_memaccess_p(), initialize_argument_information(), instrument_mem_ref(), is_empty_type(), layout_type(), load_register_parameters(), lto_input_ts_type_non_common_tree_pointers(), new_die(), nonoverlapping_refs_since_match_p(), oacc_default_clause(), odr_based_tbaa_p(), odr_types_equivalent_p(), output_constructor(), pack_ts_type_common_value_fields(), plausible_type_for_simd_clone(), register_odr_type(), simd_clone_compute_base_data_type(), type_with_linkage_p(), unpack_ts_type_common_value_fields(), use_register_for_decl(), verify_type(), verify_type_variant(), walk_tree_1(), and write_ts_type_non_common_tree_pointers().

◆ REF_REVERSE_STORAGE_ORDER

#define REF_REVERSE_STORAGE_ORDER ( NODE ) (TREE_CHECK2 (NODE, BIT_FIELD_REF, MEM_REF)->base.default_def_flag)

In a BIT_FIELD_REF and MEM_REF, indicates that the reference is to a group
of bits stored in reverse order from the target order.  This effectively
toggles both BYTES_BIG_ENDIAN and WORDS_BIG_ENDIAN for the reference.

The overall strategy is to preserve the invariant that every scalar in
memory is associated with a single storage order, i.e. all accesses to
this scalar are done with the same storage order.  This invariant makes
it possible to factor out the storage order in most transformations, as
only the address and/or the value (in target order) matter for them.
But, of course, the storage order must be preserved when the accesses
themselves are rewritten or transformed.

Referenced by build_ref_for_model(), build_ref_for_offset(), copy_reference_ops_from_ref(), copy_tree_body_r(), create_component_ref_by_pieces_1(), expand_assignment(), expand_expr_real_1(), fold_unary_loc(), gimple_extract(), gimplify_expr(), make_bit_field_ref(), may_be_nonaddressable_p(), maybe_build_generic_op(), ipa_param_adjustments::modify_call(), pack_ts_base_value_fields(), propagate_subaccesses_from_rhs(), remap_gimple_op_r(), reverse_storage_order_for_component_p(), sra_modify_expr(), stabilize_reference(), and unpack_ts_base_value_fields().

◆ REFERENCE_CLASS_P

#define REFERENCE_CLASS_P ( NODE ) (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_reference)

Nonzero if NODE represents a reference.

Referenced by cond_store_replacement(), copy_reference_ops_from_ref(), discover_nonconstant_array_refs(), discover_nonconstant_array_refs_r(), find_interesting_uses_stmt(), pcom_worker::find_looparound_phi(), find_placeholder_in_expr(), fold_gimple_assign(), fold_stmt_1(), gather_memory_references(), get_references_in_stmt(), gimplify_modify_expr_rhs(), infer_loop_bounds_from_array(), ref_always_accessed::operator()(), self_referential_component_ref_p(), stmt_makes_single_store(), substitute_in_expr(), substitute_placeholder_in_expr(), unmodified_parm_or_parm_agg_item(), vect_build_slp_tree_1(), vect_get_datarefs_in_loop(), visit_stmt(), and volatile_lvalue_p().

◆ sa_type_node

#define sa_type_node global_trees[TI_SA_TYPE]

◆ sat_accum_type_node

#define sat_accum_type_node global_trees[TI_SAT_ACCUM_TYPE]

Referenced by make_or_reuse_accum_type().

◆ sat_da_type_node

#define sat_da_type_node global_trees[TI_SAT_DA_TYPE]

◆ sat_dq_type_node

#define sat_dq_type_node global_trees[TI_SAT_DQ_TYPE]

◆ SAT_FIXED_POINT_TYPE_P

#define SAT_FIXED_POINT_TYPE_P ( TYPE ) (TREE_CODE (TYPE) == FIXED_POINT_TYPE && TYPE_SATURATING (TYPE))

Nonzero if TYPE represents a saturating fixed-point type.

Referenced by needs_fold_left_reduction_p(), parloops_needs_fold_left_reduction_p(), and split_tree().

◆ sat_fract_type_node

#define sat_fract_type_node global_trees[TI_SAT_FRACT_TYPE]

Referenced by make_or_reuse_fract_type().

◆ sat_ha_type_node

#define sat_ha_type_node global_trees[TI_SAT_HA_TYPE]

◆ sat_hq_type_node

#define sat_hq_type_node global_trees[TI_SAT_HQ_TYPE]

◆ sat_long_accum_type_node

#define sat_long_accum_type_node global_trees[TI_SAT_LACCUM_TYPE]

Referenced by make_or_reuse_accum_type().

◆ sat_long_fract_type_node

#define sat_long_fract_type_node global_trees[TI_SAT_LFRACT_TYPE]

Referenced by make_or_reuse_fract_type().

◆ sat_long_long_accum_type_node

#define sat_long_long_accum_type_node global_trees[TI_SAT_LLACCUM_TYPE]

Referenced by make_or_reuse_accum_type().

◆ sat_long_long_fract_type_node

#define sat_long_long_fract_type_node global_trees[TI_SAT_LLFRACT_TYPE]

Referenced by make_or_reuse_fract_type().

◆ sat_qq_type_node

#define sat_qq_type_node global_trees[TI_SAT_QQ_TYPE]

◆ sat_sa_type_node

#define sat_sa_type_node global_trees[TI_SAT_SA_TYPE]

◆ sat_short_accum_type_node

#define sat_short_accum_type_node global_trees[TI_SAT_SACCUM_TYPE]

Referenced by make_or_reuse_accum_type().

◆ sat_short_fract_type_node

#define sat_short_fract_type_node global_trees[TI_SAT_SFRACT_TYPE]

The fixed-point types.

Referenced by make_or_reuse_fract_type().

◆ sat_sq_type_node

#define sat_sq_type_node global_trees[TI_SAT_SQ_TYPE]

◆ sat_ta_type_node

#define sat_ta_type_node global_trees[TI_SAT_TA_TYPE]

◆ sat_tq_type_node

#define sat_tq_type_node global_trees[TI_SAT_TQ_TYPE]

◆ sat_uda_type_node

#define sat_uda_type_node global_trees[TI_SAT_UDA_TYPE]

◆ sat_udq_type_node

#define sat_udq_type_node global_trees[TI_SAT_UDQ_TYPE]

◆ sat_uha_type_node

#define sat_uha_type_node global_trees[TI_SAT_UHA_TYPE]

◆ sat_uhq_type_node

#define sat_uhq_type_node global_trees[TI_SAT_UHQ_TYPE]

◆ sat_unsigned_accum_type_node

#define sat_unsigned_accum_type_node global_trees[TI_SAT_UACCUM_TYPE]

Referenced by make_or_reuse_accum_type().

◆ sat_unsigned_fract_type_node

#define sat_unsigned_fract_type_node global_trees[TI_SAT_UFRACT_TYPE]

Referenced by make_or_reuse_fract_type().

◆ sat_unsigned_long_accum_type_node

#define sat_unsigned_long_accum_type_node global_trees[TI_SAT_ULACCUM_TYPE]

Referenced by make_or_reuse_accum_type().

◆ sat_unsigned_long_fract_type_node

#define sat_unsigned_long_fract_type_node global_trees[TI_SAT_ULFRACT_TYPE]

Referenced by make_or_reuse_fract_type().

◆ sat_unsigned_long_long_accum_type_node

#define sat_unsigned_long_long_accum_type_node global_trees[TI_SAT_ULLACCUM_TYPE]

Referenced by make_or_reuse_accum_type().

◆ sat_unsigned_long_long_fract_type_node

#define sat_unsigned_long_long_fract_type_node global_trees[TI_SAT_ULLFRACT_TYPE]

Referenced by make_or_reuse_fract_type().

◆ sat_unsigned_short_accum_type_node

#define sat_unsigned_short_accum_type_node global_trees[TI_SAT_USACCUM_TYPE]

Referenced by make_or_reuse_accum_type().

◆ sat_unsigned_short_fract_type_node

#define sat_unsigned_short_fract_type_node global_trees[TI_SAT_USFRACT_TYPE]

Referenced by make_or_reuse_fract_type().

◆ sat_uqq_type_node

#define sat_uqq_type_node global_trees[TI_SAT_UQQ_TYPE]

◆ sat_usa_type_node

#define sat_usa_type_node global_trees[TI_SAT_USA_TYPE]

◆ sat_usq_type_node

#define sat_usq_type_node global_trees[TI_SAT_USQ_TYPE]

◆ sat_uta_type_node

#define sat_uta_type_node global_trees[TI_SAT_UTA_TYPE]

◆ sat_utq_type_node

#define sat_utq_type_node global_trees[TI_SAT_UTQ_TYPE]

◆ SAVE_EXPR_RESOLVED_P

#define SAVE_EXPR_RESOLVED_P ( NODE ) (SAVE_EXPR_CHECK (NODE)->base.public_flag)

In a SAVE_EXPR, indicates that the original expression has already
been substituted with a VAR_DECL that contains the value.

Referenced by expand_expr_real_1(), get_memory_rtx(), and gimplify_save_expr().

◆ sbitsize_int

#define sbitsize_int ( L ) size_int_kind (L, stk_sbitsizetype)

◆ sbitsizetype

#define sbitsizetype sizetype_tab[(int) stk_sbitsizetype]

Referenced by initialize_sizetypes(), and size_diffop_loc().

◆ SCALAR_FLOAT_TYPE_MODE

#define SCALAR_FLOAT_TYPE_MODE ( NODE ) (as_a <scalar_float_mode> (TYPE_CHECK (NODE)->type_common.mode))

Referenced by expand_builtin_issignaling(), expand_builtin_signbit(), fold_convert_const_real_from_fixed(), native_encode_real(), native_interpret_expr(), native_interpret_real(), output_constant(), and simplify_using_ranges::simplify_float_conversion_using_ranges().

◆ SCALAR_FLOAT_TYPE_P

#define SCALAR_FLOAT_TYPE_P ( TYPE ) (TREE_CODE (TYPE) == REAL_TYPE)

Nonzero if TYPE represents a scalar floating-point type.

Referenced by scev_dfs::add_to_evolution(), scev_dfs::add_to_evolution_1(), base_type_die(), build_complex_type(), builtin_mathfn_code(), chrec_apply(), chrec_fold_multiply_poly_poly(), chrec_fold_plus_1(), chrec_fold_plus_poly_poly(), constant_type(), convert_to_integer_1(), convert_to_real_1(), do_mpc_arg2(), expand_complex_division(), expand_complex_multiplication(), expand_omp_atomic_cas(), expand_vector_conversion(), fold_builtin_carg(), fold_const_vec_convert(), fold_convert_const(), fold_negate_expr_1(), get_component_ssa_name(), get_initial_def_for_reduction(), get_related_vectype_for_scalar_type(), get_ubsan_type_info_for_type(), gimple_canonical_types_compatible_p(), gimple_lower_bitint(), initializer_constant_valid_p_1(), integer_valued_real_unary_p(), lhd_omp_scalar_p(), needs_fold_left_reduction_p(), negate_expr_p(), odr_types_equivalent_p(), omp_reduction_init_op(), optimize_atomic_compare_exchange_p(), optimize_spaceship(), parloops_needs_fold_left_reduction_p(), range_compatible_p(), frange::supports_p(), transform_add_to_multiply(), tree_unary_nonnegative_warnv_p(), useless_type_conversion_p(), valid_fixed_convert_types_p(), valid_lattice_transition(), vect_build_all_ones_mask(), vect_build_zero_merge_argument(), vect_is_simple_iv_evolution(), vectorizable_conversion(), vectorizable_induction(), vectorizable_reduction(), verify_gimple_assign_binary(), verify_gimple_assign_ternary(), verify_gimple_assign_unary(), verify_type(), and verify_type_variant().

◆ SCALAR_INT_TYPE_MODE

#define SCALAR_INT_TYPE_MODE ( NODE ) (as_a <scalar_int_mode> (TYPE_CHECK (NODE)->type_common.mode))

Referenced by tree_switch_conversion::switch_conversion::array_value_type(), build_cltz_expr(), cond_removal_in_builtin_zero_pattern(), convert_mult_to_widen(), do_compare_and_jump(), do_jump(), expand_addsub_overflow(), expand_arith_overflow(), expand_builtin_init_dwarf_reg_sizes(), expand_builtin_signbit(), expand_debug_expr(), expand_expr_real_1(), expand_expr_real_2(), expand_mul_overflow(), expand_neg_overflow(), expand_single_bit_test(), extract_muldiv_1(), fold_const_call_ss(), fold_nonarray_ctor_reference(), gimple_fold_builtin_memset(), instrument_bool_enum_load(), int_fits_type_p(), layout_type(), loc_list_from_tree_1(), make_tree(), match_arith_overflow(), mergeable_string_section(), narrowing_initializer_constant_valid_p(), native_encode_int(), native_interpret_int(), output_constant(), vn_walk_cb_data::push_partial_def(), reduce_to_bit_field_precision(), simplify_count_trailing_zeroes(), simplify_using_ranges::simplify_float_conversion_using_ranges(), try_casesi(), unextend(), vect_recog_ctz_ffs_pattern(), vect_recog_divmod_pattern(), vect_recog_mixed_size_cond_pattern(), vect_recog_popcount_clz_ctz_ffs_pattern(), vect_recog_rotate_pattern(), verify_gimple_assign_ternary(), and vn_reference_lookup_3().

◆ SCALAR_TYPE_MODE

#define SCALAR_TYPE_MODE ( NODE ) (as_a <scalar_mode> (TYPE_CHECK (NODE)->type_common.mode))

Referenced by adjust_bool_pattern(), append_pattern_def_seq(), build_index_vector(), build_minus_one_cst(), check_bool_pattern(), convert_plusminus_to_widen(), estimate_move_cost(), expand_expr_addr_expr_1(), expand_vector_comparison(), expand_vector_condition(), fold_builtin_bit_query(), fold_convert_const_fixed_from_fixed(), fold_convert_const_fixed_from_int(), fold_convert_const_fixed_from_real(), layout_type(), native_encode_complex(), native_encode_fixed(), native_encode_vector_part(), native_interpret_complex(), native_interpret_fixed(), output_constant(), signed_or_unsigned_type_for(), simd_clone_adjust(), simd_clone_adjust_argument_types(), simd_clone_adjust_return_type(), simd_clone_init_simd_arrays(), ubsan_encode_value(), undistribute_bitref_for_vector(), vect_create_epilog_for_reduction(), vect_recog_mixed_size_cond_pattern(), vect_truncate_gather_scatter_offset(), vector_vector_composition_type(), vectorizable_conversion(), vectorizable_reduction(), vectorizable_store(), and verify_gimple_assign_ternary().

◆ SCOPE_FILE_SCOPE_P

#define SCOPE_FILE_SCOPE_P ( EXP ) (! (EXP) || TREE_CODE (EXP) == TRANSLATION_UNIT_DECL)

Nonzero for a scope which is equal to file scope.

Referenced by expand_expr_real_1(), and verify_expr_location_1().

◆ SET_DECL_ALIGN

#define SET_DECL_ALIGN	(		NODE,
			X ) (DECL_ALIGN_RAW (NODE) = ffs_hwi (X))

Specify that DECL_ALIGN(NODE) is X.

Referenced by align_local_variable(), align_variable(), asan_finish_file(), asan_poison_variable(), assemble_variable(), assign_parm_setup_block(), build_constant_desc(), build_var(), copy_var_decl(), do_type_align(), ensure_base_align(), expand_one_stack_var_at(), finish_taskreg_scan(), fold_builtin_alloca_with_align(), get_chain_field(), get_descriptor_type(), get_nl_goto_field(), get_trampoline_type(), increase_alignment_1(), init_eh(), install_var_field(), install_var_field(), layout_decl(), lookup_field_for_decl(), lower_omp_task_reductions(), make_node(), omp_finish_file(), ompdevlow_adjust_simt_enter(), output_constant_def_contents(), relayout_decl(), scan_sharing_clauses(), and unpack_ts_decl_common_value_fields().

◆ SET_DECL_ASSEMBLER_NAME

#define SET_DECL_ASSEMBLER_NAME	(		NODE,
			NAME ) overwrite_decl_assembler_name (NODE, NAME)

Set the DECL_ASSEMBLER_NAME for NODE to NAME.

Referenced by asan_emit_stack_protection(), build_builtin_function(), build_cxa_atexit_decl(), symbol_table::change_decl_assembler_name(), cgraph_node::create_version_clone_with_body(), cgraph_node::create_virtual_clone(), duplicate_thunk_for_node(), dw2_output_indirect_constant_1(), get_emutls_init_templ_addr(), ipa_tm_create_version(), ipa_tm_create_version_alias(), lhd_set_decl_assembler_name(), lto_input_ts_decl_with_vis_tree_pointers(), make_decl_rtl(), new_emutls_decl(), symtab_node::noninterposable_alias(), process_symver_attribute(), push_dummy_function(), and simd_clone_create().

◆ SET_DECL_DEBUG_EXPR

#define SET_DECL_DEBUG_EXPR	(		NODE,
			VAL ) (decl_debug_expr_insert (VAR_DECL_CHECK (NODE), VAL))

Referenced by add_local_variables(), create_access_replacement(), create_one_component_var(), gimplify_modify_expr(), and lto_input_ts_decl_common_tree_pointers().

◆ SET_DECL_FIELD_ABI_IGNORED

#define SET_DECL_FIELD_ABI_IGNORED	(		NODE,
			VAL )

Value:

  do {                                                                  \
    gcc_checking_assert (!DECL_BIT_FIELD (NODE));                       \
    FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_0 = (VAL);           \
  } while (0)

Referenced by unpack_ts_decl_common_value_fields().

◆ SET_DECL_FIELD_CXX_ZERO_WIDTH_BIT_FIELD

#define SET_DECL_FIELD_CXX_ZERO_WIDTH_BIT_FIELD	(		NODE,
			VAL )

Value:

  do {                                                                  \
    gcc_checking_assert (DECL_BIT_FIELD (NODE));                        \
    FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_0 = (VAL);           \
  } while (0)

Referenced by unpack_ts_decl_common_value_fields().

◆ SET_DECL_FINI_PRIORITY

#define SET_DECL_FINI_PRIORITY	(		NODE,
			VAL ) (decl_fini_priority_insert (NODE, VAL))

Set the finalization priority for NODE to VAL.

◆ SET_DECL_INIT_PRIORITY

#define SET_DECL_INIT_PRIORITY	(		NODE,
			VAL ) (decl_init_priority_insert (NODE, VAL))

Set the initialization priority for NODE to VAL.

Referenced by copy_node().

◆ SET_DECL_MODE

◆ SET_DECL_OFFSET_ALIGN

#define SET_DECL_OFFSET_ALIGN	(		NODE,
			X ) (FIELD_DECL_CHECK (NODE)->decl_common.off_align = ffs_hwi (X) - 1)

Specify that DECL_OFFSET_ALIGN(NODE) is X.

Referenced by place_field(), place_union_field(), and start_bitfield_representative().

◆ SET_DECL_PT_UID

#define SET_DECL_PT_UID	(		NODE,
			UID ) (DECL_COMMON_CHECK (NODE)->decl_common.pt_uid = (UID))

Initialize the ..._DECL node pt-uid to the decls uid.

Referenced by assumption_copy_decl(), build_fake_var_decl(), copy_decl_to_var(), copy_node(), copy_result_decl_to_var(), fold_builtin_alloca_with_align(), make_node(), ipa_param_body_adjustments::reset_debug_stmts(), ipa_icf::set_alias_uids(), and set_uids_in_ptset().

◆ SET_DECL_RTL

#define SET_DECL_RTL	(		NODE,
			RTL ) set_decl_rtl (NODE, RTL)

Set the DECL_RTL for NODE to RTL.

Referenced by asan_memfn_rtl(), assign_parm_setup_reg(), assign_parms(), ipa_icf::clear_decl_rtl(), copy_decl_for_dup_finish(), cgraph_node::create_version_clone_with_body(), cgraph_node::create_virtual_clone(), delete_vta_debug_insn(), expand_debug_expr(), expand_expr_real_1(), expand_function_start(), expand_one_error_var(), force_expr_to_var_cost(), free_loop_data(), get_spill_slot_decl(), ipa_tm_create_version(), ipa_tm_create_version_alias(), label_rtx(), layout_decl(), make_debug_expr_from_rtl(), make_decl_rtl(), make_decl_rtl_for_debug(), symtab_node::noninterposable_alias(), prepare_decl_rtl(), relayout_decl(), ipa_param_body_adjustments::reset_debug_stmts(), set_rtl(), set_user_assembler_name(), simd_clone_create(), store_constructor(), ubsan_encode_value(), and unshare_all_rtl().

◆ SET_DECL_VALUE_EXPR

#define SET_DECL_VALUE_EXPR	(		NODE,
			VAL ) (decl_value_expr_insert (DECL_WRTL_CHECK (NODE), VAL))

◆ SET_DECL_WARN_IF_NOT_ALIGN

#define SET_DECL_WARN_IF_NOT_ALIGN	(		NODE,
			X ) (DECL_WARN_IF_NOT_ALIGN_RAW (NODE) = ffs_hwi (X))

Specify that DECL_WARN_IF_NOT_ALIGN(NODE) is X.

Referenced by do_type_align().

◆ SET_EXPR_LOCATION

#define SET_EXPR_LOCATION	(		NODE,
			LOCUS ) EXPR_CHECK ((NODE))->exp.locus = (LOCUS)

◆ SET_EXPR_UID

#define SET_EXPR_UID	(		t,
			v ) EXPR_CHECK ((t))->exp.condition_uid = (v)

COND_EXPR identificer/discriminator accessors.

Referenced by shortcut_cond_expr(), shortcut_cond_r(), and tag_shortcut_cond().

◆ SET_PREDICT_EXPR_OUTCOME

#define SET_PREDICT_EXPR_OUTCOME	(		NODE,
			OUTCOME ) (PREDICT_EXPR_CHECK (NODE)->base.addressable_flag = (int) OUTCOME)

Referenced by build_predict_expr().

◆ SET_SSA_NAME_VAR_OR_IDENTIFIER

#define SET_SSA_NAME_VAR_OR_IDENTIFIER	(		NODE,
			VAR )

Value:

  do \
    { \
      tree var_ = (VAR); \
      SSA_NAME_CHECK (NODE)->ssa_name.var = var_; \
      SSA_NAME_IS_VIRTUAL_OPERAND (NODE) \
        = (var_ \
           && TREE_CODE (var_) == VAR_DECL \
           && VAR_DECL_IS_VIRTUAL_OPERAND (var_)); \
    } \
  while (0)

Referenced by asan_expand_poison_ifn(), copy_ssa_name_fn(), expand_call_inline(), fixup_noreturn_call(), gimple_fold_call(), internal_get_tmp_var(), ipa_simd_modify_function_body(), make_ssa_name_fn(), make_temp_ssa_name(), cgraph_edge::redirect_call_stmt_to_callee(), remap_ssa_name(), replace_ssa_name_symbol(), and walk_regimplify_phi().

◆ SET_TYPE_ALIGN

#define SET_TYPE_ALIGN	(		NODE,
			X ) (TYPE_CHECK (NODE)->type_common.align = ffs_hwi (X))

Specify that TYPE_ALIGN(NODE) is X.

Referenced by build_aligned_type(), build_atomic_base(), build_common_tree_nodes(), build_qualified_type(), build_range_type_1(), expand_expr_addr_expr_1(), finalize_record_size(), finalize_type_size(), finish_builtin_struct(), finish_taskreg_scan(), initialize_sizetypes(), insert_field_into_struct(), layout_type(), lhd_simulate_enum_decl(), lower_omp_task_reductions(), make_node(), omp_finish_file(), std_gimplify_va_arg_expr(), and unpack_ts_type_common_value_fields().

◆ SET_TYPE_MODE

#define SET_TYPE_MODE	(		NODE,
			MODE ) (TYPE_CHECK (NODE)->type_common.mode = (MODE))

Referenced by build_common_tree_nodes(), build_pointer_type_for_mode(), build_range_type_1(), build_reference_type_for_mode(), compute_record_mode(), finalize_type_size(), initialize_sizetypes(), layout_type(), make_accum_type(), make_fract_type(), make_vector_type(), and unpack_ts_type_common_value_fields().

◆ SET_TYPE_STRUCTURAL_EQUALITY

#define SET_TYPE_STRUCTURAL_EQUALITY ( NODE ) (TYPE_CANONICAL (NODE) = NULL_TREE)

Sets the TYPE_CANONICAL field to NULL_TREE, indicating that the
type node requires structural equality.

Referenced by build_array_type_1(), build_complex_type(), build_distinct_type_copy(), build_function_type(), build_method_type_directly(), build_offset_type(), build_pointer_type_for_mode(), build_qualified_type(), build_range_type_1(), build_reference_type_for_mode(), build_type_attribute_qual_variant(), and make_vector_type().

◆ SET_TYPE_WARN_IF_NOT_ALIGN

#define SET_TYPE_WARN_IF_NOT_ALIGN	(		NODE,
			X ) (TYPE_CHECK (NODE)->type_common.warn_if_not_align = ffs_hwi (X))

Specify that TYPE_WARN_IF_NOT_ALIGN(NODE) is X.

Referenced by build_range_type_1(), finish_builtin_struct(), layout_type(), and place_field().

◆ short_accum_type_node

#define short_accum_type_node global_trees[TI_SACCUM_TYPE]

Referenced by make_or_reuse_accum_type().

◆ short_fract_type_node

#define short_fract_type_node global_trees[TI_SFRACT_TYPE]

Referenced by make_or_reuse_fract_type().

◆ short_integer_type_node

#define short_integer_type_node integer_types[itk_short]

Referenced by asan_init_shadow_ptr_types(), build_common_tree_nodes(), build_complex_type(), define_builtin_macros_for_type_sizes(), get_typenode_from_name(), gimple_signed_or_unsigned_type(), and lhd_type_for_size().

◆ short_unsigned_type_node

#define short_unsigned_type_node integer_types[itk_unsigned_short]

Referenced by build_common_tree_nodes(), build_complex_type(), get_typenode_from_name(), gimple_signed_or_unsigned_type(), lhd_type_for_size(), lower_omp_target(), ubsan_get_type_descriptor_type(), and ubsan_type_descriptor().

◆ signed_char_type_node

#define signed_char_type_node integer_types[itk_signed_char]

Referenced by asan_init_shadow_ptr_types(), build_common_tree_nodes(), build_complex_type(), get_typenode_from_name(), gimple_get_alias_set(), gimple_signed_or_unsigned_type(), lhd_type_for_size(), stack_protect_classify_type(), type_with_interoperable_signedness(), and vect_check_gather_scatter().

◆ size_int

#define size_int ( L ) size_int_kind (L, stk_sizetype)

Referenced by add_iv_candidate_for_biv(), add_iv_candidate_for_use(), attr_access::array_as_string(), array_ref_element_size(), asan_pp_string(), assign_parms(), build_alloca_call_expr(), build_array_type_nelts(), build_common_tree_nodes(), build_fn_info_type(), build_info(), build_info_type(), build_string_literal(), c_strlen(), clear_padding_emit_loop(), clear_padding_type(), component_ref_field_offset(), compute_access_stride(), compute_object_offset(), constant_byte_string(), constant_pointer_difference(), copy_reference_ops_from_call(), copy_reference_ops_from_ref(), coverage_end_function(), coverage_obj_finish(), create_ifn_alias_checks(), create_waw_or_war_checks(), decode_field_reference(), default_cxx_get_cookie_size(), expand_assignment(), expand_call_inline(), expand_expr_real_1(), expand_omp_for_generic(), expand_omp_for_ordered_loops(), expand_omp_for_static_nochunk(), expand_omp_scantemp_alloc(), expand_omp_target(), expand_thunk(), finish_bitfield_representative(), fold_binary_loc(), fold_build_pointer_plus_hwi_loc(), fold_truth_andor_1(), get_bit_range(), get_misalign_in_elems(), get_nl_goto_field(), get_range_strlen_tree(), get_segment_min_max(), get_trampoline_type(), gimplify_compound_lval(), gimplify_omp_depend(), gimplify_scan_omp_clauses(), handle_warn_if_not_align(), init_eh(), initialize_sizetypes(), instrument_expr(), interpret_rhs_expr(), issue_prefetch_ref(), layout_type(), locate_and_pad_parm(), lower_coro_builtin(), lower_depend_clauses(), lower_lastprivate_clauses(), lower_omp_target(), lower_omp_task_reductions(), lower_rec_input_clauses(), lower_vec_perm(), maybe_canonicalize_mem_ref_addr(), maybe_fold_tmr(), maybe_instrument_pointer_overflow(), native_interpret_aggregate(), omp_accumulate_sibling_list(), optimize_bit_field_compare(), pos_from_bit(), resolve_addr_in_expr(), simd_clone_adjust(), simd_clone_init_simd_arrays(), split_constant_offset_1(), std_gimplify_va_arg_expr(), store_expr(), unextend(), vect_check_gather_scatter(), vect_create_cond_for_align_checks(), vect_get_strided_load_store_ops(), vect_prune_runtime_alias_test_list(), vect_recog_gather_scatter_pattern(), vectorizable_condition(), vectorizable_load(), vectorizable_simd_clone_call(), and vectorizable_store().

◆ size_one_node

◆ size_type_node

#define size_type_node global_trees[TI_SIZE_TYPE]

The C type `size_t'.

◆ size_zero_node

#define size_zero_node global_trees[TI_SIZE_ZERO]

Referenced by arg_size_in_bytes(), build_common_tree_nodes(), build_empty_stmt(), build_index_type(), build_printable_array_type(), check_access(), check_for_plus_in_loops_1(), compare_step_with_zero(), component_ref_size(), compute_object_offset(), constant_pointer_difference(), create_intersect_range_checks_index(), create_waw_or_war_checks(), expand_omp_for_generic(), expand_omp_target(), find_interesting_uses_address(), fold_builtin_strcspn(), fold_builtin_strspn(), fold_indirect_ref_1(), get_inner_reference(), get_memory_rtx(), get_misalign_in_elems(), get_segment_min_max(), gimple_fold_indirect_ref(), gimplify_adjust_omp_clauses(), gimplify_adjust_omp_clauses_1(), gimplify_omp_depend(), strlen_pass::handle_builtin_strcat(), strlen_pass::handle_store(), layout_type(), lower_omp_for_scan(), lower_omp_target(), lower_omp_task_reductions(), omp_accumulate_sibling_list(), place_union_field(), simd_clone_adjust(), simplify_builtin_call(), size_for_offset(), size_in_bytes_loc(), size_initval(), size_unknown(), start_record_layout(), std_gimplify_va_arg_expr(), ubsan_get_type_descriptor_type(), vect_check_gather_scatter(), vect_compile_time_alias(), vect_create_cond_for_align_checks(), vect_enhance_data_refs_alignment(), vect_gen_prolog_loop_niters(), vect_get_data_ptr_increment(), vect_get_peeling_costs_all_drs(), vect_prune_runtime_alias_test_list(), and vect_setup_realignment().

◆ sizetype

#define sizetype sizetype_tab[(int) stk_sizetype]

Type for sizes of data-type.

Referenced by add_iv_candidate_for_biv(), add_iv_candidate_for_use(), add_to_parts(), addr_to_parts(), adjust_return_value_with_ops(), aff_combination_add_elt(), aff_combination_scale(), aff_combination_to_tree(), alloc_object_size(), array_ref_element_size(), assert_loop_rolls_lt(), build2(), tree_switch_conversion::switch_conversion::build_arrays(), tree_switch_conversion::switch_conversion::build_constructors(), build_index_type(), build_printable_array_type(), build_vl_exp(), bundle_sizes(), byte_from_pos(), c_strlen(), cand_value_at(), rt_bb_visited::check(), check_access(), chrec_convert_aggressive(), chrec_convert_rhs(), component_ref_field_offset(), compute_access_range(), compute_access_stride(), compute_alias_check_pairs(), compute_distributive_range(), compute_new_first_bound(), compute_object_offset(), compute_objsize(), cond_expr_object_size(), constant_byte_string(), constant_pointer_difference(), convert_affine_scev(), convert_to_ptrofftype_loc(), create_add_imm_cand(), create_add_on_incoming_edge(), create_add_ssa_cand(), create_expression_by_pieces(), create_mem_ref(), create_mul_imm_cand(), create_tailcall_accumulator(), create_waw_or_war_checks(), data_ref_segment_size(), default_cxx_get_cookie_size(), dr_analyze_innermost(), dump_generic_node(), emit_block_op_via_libcall(), expand_builtin_memcmp(), expand_builtin_strncmp(), expand_expr_real_1(), expand_expr_real_2(), expand_oacc_collapse_init(), expand_oacc_collapse_vars(), expand_oacc_for(), expand_omp_for_generic(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), expand_omp_ordered_sink(), expand_simple_operations(), expand_vec_perm_const(), expand_vector_ubsan_overflow(), expr_size(), expr_to_aff_combination(), field_byte_offset(), finalize_type_size(), find_inv_vars_cb(), fold_binary_loc(), fold_comparison(), fold_const_aggregate_ref_1(), fold_indirect_ref_1(), fold_read_from_constant_string(), fold_stmt_1(), fuse_memset_builtins(), get_addr_base_and_unit_offset_1(), get_address_cost(), get_debug_computation_at(), get_dr_vinfo_offset(), get_inner_reference(), get_inner_reference_aff(), get_iv(), get_memory_rtx(), get_offset_range(), get_ref_base_and_extent(), get_segment_min_max(), get_size_range(), get_stridx(), get_up_bounds_for_array_ref(), gimple_call_alloc_size(), gimple_convert_to_ptrofftype(), gimple_fold_builtin_memchr(), gimple_fold_builtin_stpcpy(), gimple_fold_builtin_strlen(), gimple_lower_bitint(), gimple_parm_array_size(), gimplify_omp_depend(), gimplify_omp_for(), handle_array_ref(), strlen_pass::handle_builtin_strcat(), strlen_pass::handle_builtin_strchr(), strlen_pass::handle_integral_assign(), idx_analyze_ref(), idx_find_step(), increment_start_addr(), init_offset_limit(), initialize_sizetypes(), instrument_object_size(), instrument_pointer_overflow(), issue_prefetch_ref(), layout_decl(), layout_type(), lower_oacc_reductions(), lower_omp_for_scan(), lower_omp_ordered_clauses(), lower_omp_target(), lower_rec_input_clauses(), lower_reduction_clauses(), maybe_fold_tmr(), maybe_instrument_pointer_overflow(), modified_type_die(), most_expensive_mult_to_index(), move_variant_to_index(), native_encode_initializer(), nop_conversion_for_offset_p(), number_of_iterations_cond(), number_of_iterations_le(), number_of_iterations_lt_to_ne(), object_sizes_set(), object_sizes_set_temp(), output_constructor_array_range(), output_constructor_regular_field(), parm_object_size(), place_field(), place_union_field(), pos_from_bit(), preferred_mem_scale_factor(), ptrofftype_p(), restructure_reference(), rewrite_phi_with_iv(), rewrite_use_nonlinear_expr(), rt_bb_visited::rt_bb_visited(), set_storage_via_libcall(), simd_clone_adjust(), simplify_builtin_call(), size_diffop_loc(), size_for_offset(), size_initval(), size_unknown(), slsr_process_cast(), slsr_process_copy(), slsr_process_phi(), slsr_process_ref(), split_constant_offset(), split_constant_offset_1(), std_gimplify_va_arg_expr(), store_expr(), store_one_arg(), strdup_object_size(), loop_distribution::transform_reduction_loop(), tree_optimize_tail_calls_1(), tree_to_aff_combination(), ubsan_expand_ptr_ifn(), ubsan_get_type_descriptor_type(), valid_constant_size_p(), valid_mem_ref_cand_p(), vect_check_gather_scatter(), vect_create_addr_base_for_vector_ref(), vect_get_strided_load_store_ops(), vect_recog_bitfield_ref_pattern(), vect_update_init_of_dr(), vect_update_inits_of_drs(), vect_vfa_segment_size(), vectorizable_load(), vectorizable_simd_clone_call(), vectorizable_store(), vn_reference_insert(), and vn_reference_lookup().

◆ sq_type_node

#define sq_type_node global_trees[TI_SQ_TYPE]

◆ SSA_NAME_DEF_STMT

#define SSA_NAME_DEF_STMT ( NODE ) SSA_NAME_CHECK (NODE)->ssa_name.def_stmt

Returns the statement which defines this SSA name.

Referenced by add_dependency(), add_exit_phi(), add_exit_phis(), add_exit_phis_var(), add_iv_candidate_for_biv(), add_scope_conflicts_2(), address_compare(), adjust_before_returns_twice_call(), adjust_bool_pattern(), adjust_debug_stmts_now(), adjust_imagpart_expr(), adjust_iv_update_pos(), strlen_pass::adjust_last_stmt(), adjust_pointer_diff_expr(), adjust_realpart_expr(), autofdo::afdo_propagate_circuit(), aff_combination_expand(), all_phi_incrs_profitable_1(), analyze_agg_content_value(), analyze_and_compute_bitop_with_inv_effect(), analyze_and_compute_bitwise_induction_effect(), loop_cand::analyze_iloop_reduction_var(), loop_cand::analyze_induction_var(), loop_cand::analyze_oloop_reduction_var(), analyze_scalar_evolution_1(), and_comparisons_1(), and_var_with_comparison(), and_var_with_comparison_1(), ao_ref_init_from_ptr_and_range(), apply_return_prediction(), arith_cast_equal_p(), asan_expand_poison_ifn(), assume_query::assume_query(), attempt_builtin_copysign(), base_cand_from_table(), ranger_cache::block_range(), branch_fixup(), build_and_add_sum(), build_bitint_stmt_ssa_conflicts(), build_new_reduction(), assume_query::calculate_op(), assume_query::calculate_phi(), can_reassociate_op_p(), can_skip_redundant_opnd(), cfun_returns(), chain_of_csts_start(), check_defs(), check_exit_phi(), check_for_plus_in_loops(), check_for_plus_in_loops_1(), array_bounds_checker::check_mem_ref(), check_name(), check_pow(), check_reduction_path(), check_scan_store(), check_stmt_for_type_change(), check_stmt_for_type_change(), chk_uses(), chrec_contains_symbols_defined_in_loop(), classify_builtin_st(), loop_cand::classify_simple_reduction(), clear_visited(), collect_object_sizes_for(), uninit_analysis::collect_phi_def_edges(), compute_added_num_insns(), compute_avail(), compute_builtin_object_size(), compute_complex_ancestor_jump_func(), compute_complex_assign_jump_func(), path_range_query::compute_exit_dependencies(), gori_compute::compute_logical_operands(), gori_compute::compute_operand1_and_operand2_range(), gori_compute::compute_operand_range(), gori_compute::compute_operand_range_switch(), path_range_query::compute_ranges_in_block(), gori_compute::condexpr_adjust(), consider_split(), constant_after_peeling(), constant_byte_string(), constant_pointer_difference(), convert_expand_mult_copysign(), convert_mult_to_fma(), convert_mult_to_highpart(), convert_plusminus_to_widen(), copy_phis_for_bb(), strlen_pass::count_nonzero_bytes(), strlen_pass::count_nonzero_bytes_addr(), cprop_operand(), create_call_for_reduction_1(), create_parallel_loop(), create_phi_basis_1(), decompose_param_expr(), defcodefor_name(), defined_in_sese_p(), path_range_query::defined_outside_path(), derive_constant_upper_bound_ops(), edge_info::derive_equivalences(), detach_value(), determine_known_aggregate_parts(), determine_max_movement(), difference_cannot_overflow_p(), do_invalidate(), dse_classify_store(), equiv_oracle::dump(), range_def_chain::dump(), gimple_ranger::dump_bb(), dump_replaceable_exprs(), easy_exit_values(), edge_forwards_cmp_to_conditional_jump_through_empty_bb_p(), eliminate_dom_walker::eliminate_avail(), rpo_elim::eliminate_avail(), eliminate_dom_walker::eliminate_insert(), eliminate_plus_minus_pair(), eliminate_redundant_comparison(), eliminate_dom_walker::eliminate_stmt(), eliminate_tail_call(), eliminate_temp_copies(), eliminate_unnecessary_stmts(), emit_warn_switch_unreachable(), estimate_threading_killed_stmts(), evaluate_stmt(), execute_cse_conv_1(), execute_cse_reciprocals_1(), execute_cse_sincos_1(), ranger_cache::exit_range(), expand_call_inline(), expand_case(), expand_complex_libcall(), expand_expr_real_1(), expand_expr_real_2(), expand_gimple_cond(), expand_omp_for_generic(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), expand_omp_sections(), expand_simple_operations(), expand_vector_condition(), expr_coherent_p(), expr_expected_value_1(), expr_invariant_in_loop_p(), expr_invariant_in_region_p(), extract_component(), factor_out_conditional_operation(), ranger_cache::fill_block_cache(), final_range_test_p(), final_value_replacement_loop(), find_conditions(), find_deps_in_bb_for_stmt(), find_deriving_biv_for_expr(), find_equal_ptrs(), find_foldable_builtin_expect(), find_insert_point(), find_interesting_uses_op(), find_inv_vars_cb(), find_loop_guard(), pcom_worker::find_looparound_phi(), find_or_create_guard_phi(), back_threader::find_paths_to_names(), find_reduc_addr(), find_replaceable_in_bb(), find_ssa_names_to_propagate(), find_subloop_latch_edge_by_ivs(), find_unswitching_predicates_for_bb(), find_uses_to_rename_use(), find_var_cmp_const(), find_vdef_in_loop(), fini_copy_prop(), fini_ssanames(), finish_update_gimple_call(), fixup_noreturn_call(), fold_builtin_alloca_with_align(), fold_strstr_to_strncmp(), follow_copies_to_constant(), follow_outer_ssa_edges(), scev_dfs::follow_ssa_edge_expr(), force_move_till_op(), fully_replaceable(), gen_conditions_for_pow_int_base(), gen_simplified_condition(), get_attr_nonstring_decl(), get_base_decl(), get_base_for_alignment_1(), get_bit_field_ref_def(), get_component_ssa_name(), scalar_cond_masked_key::get_cond_ops_from_tree(), get_continuation_for_phi(), get_copy_of_val(), get_cst_init_from_scev(), get_def(), range_def_chain::get_def_chain(), get_default_value(), ipa_polymorphic_call_context::get_dynamic_type(), get_gimple_for_ssa_name(), ranger_cache::get_global_range(), get_iv(), get_min_precision(), get_name_for_bit_test(), get_ops(), get_prop_source_stmt(), get_range_pos_neg(), get_range_strlen(), get_range_strlen_dynamic(), get_rank(), get_reassociation_width(), access_ref::get_ref(), get_representative_for(), get_ssa_def_if_simple_copy(), get_stridx(), get_unary_op(), get_upper_bound_based_on_builtin_expr_with_prob(), get_val_for(), get_value_locus_in_path(), gimple_assign_set_lhs(), gimple_build_valueize(), gimple_call_set_lhs(), gimple_expand_vec_cond_expr(), gimple_fold_call(), gimple_lower_bitint(), gimple_move_vops(), gimple_phi_set_result(), gimple_replace_ssa_lhs(), gimplify_modify_expr(), gimplify_size_expressions(), gori_calc_operands(), gori_name_helper(), phi_analyzer::group(), gsi_replace_with_seq_vops(), strlen_pass::handle_builtin_memcpy(), strlen_pass::handle_builtin_stxncpy_strncat(), remove_unreachable::handle_early(), handle_min_max_size(), strlen_pass::handle_pointer_plus(), handle_ssa_name(), hardcfr_sibcall_search_preds(), hoist_adjacent_loads(), hoist_defs_of_uses(), ifcvt_available_on_edge_p(), ifcvt_local_dce(), independent_of_stmt_p(), access_ref::inform_access(), init_range_entry(), input_gimple_stmt(), input_ssa_names(), insert_backedge_copies(), insert_debug_temp_for_var_def(), insert_initializers(), insert_into_preds_of_block(), insert_phi_nodes(), instantiate_scev_name(), instrument_object_size(), integer_valued_real_single_p(), tree_loop_interchange::interchange_loops(), internal_get_tmp_var(), interpret_rhs_expr(), invariant_in_sese_p_rec(), ipa_analyze_indirect_call_uses(), ipa_analyze_virtual_call_uses(), ipa_compute_jump_functions_for_edge(), ipa_load_from_parm_agg(), ipa_polymorphic_call_context::ipa_polymorphic_call_context(), is_addr_local(), is_cond_scalar_reduction(), is_degenerate_phi(), is_division_by_square(), is_inv_store_elimination_chain(), is_maybe_undefined(), is_strlen_related_p(), is_widening_mult_rhs_p(), likely_value(), linearize_expr(), linearize_expr_tree(), local_mem_dependence(), vec_info::lookup_def(), loop_closed_phi_def(), loop_combined_static_and_iv_p(), loop_invariant_op_p(), loop_iter_phi_semi_invariant_p(), loop_static_op_p(), lower_bitfield(), lower_vec_perm(), make_new_ssa_for_all_defs(), make_ssa_name_fn(), malloc_candidate_p_1(), tree_loop_interchange::map_inductions_to_loop(), mark_aliased_reaching_defs_necessary_1(), mark_all_reaching_defs_necessary_1(), mark_bivs(), mark_operand_necessary(), match_arith_overflow(), match_single_bit_test(), match_uaddc_usubc(), gori_compute::may_recompute_p(), maybe_add_asan_poison_write(), gori_map::maybe_add_gori(), maybe_get_single_definition(), maybe_optimize_guarding_check(), maybe_set_nonzero_bits(), maybe_set_strlen_range(), maybe_set_vectorized_backedge_value(), maybe_skip_until(), maybe_warn_operand(), minmax_replacement(), ipa_param_adjustments::modify_call(), multiple_of_p(), ncd_with_phi(), negate_value(), neuter_worker_single(), ssa_name_limit_t::next_phi(), predicate::normalize(), predicate::normalize(), number_of_iterations_cltz(), number_of_iterations_cltz_complement(), number_of_iterations_popcount(), object_sizes_set(), ompdevlow_adjust_simt_enter(), operand_equal_for_value_replacement(), phi_analyzer::operator[](), ops_equal_values_p(), optimize_atomic_bit_test_and(), optimize_atomic_op_fetch_cmp_0(), optimize_memcpy(), optimize_pow_to_exp(), optimize_range_tests_cmp_bitwise(), optimize_range_tests_to_bit_test(), optimize_range_tests_var_bound(), optimize_recip_sqrt(), optimize_stack_restore(), dom_opt_dom_walker::optimize_stmt(), optimize_vector_constructor(), optimize_vector_load(), or_comparisons_1(), or_var_with_comparison(), or_var_with_comparison_1(), outermost_invariant_loop(), outermost_invariant_loop_for_expr(), gori_compute::outgoing_edge_range_p(), output_ssa_names(), ovce_extract_ops(), overflow_comparison_p_1(), param_change_prob(), parloops_is_simple_reduction(), parse_predicate(), access_ref::phi(), phi_add_costs_1(), phi_dynamic_object_size(), phi_incr_cost_1(), phi_rank(), phi_translate_1(), phiprop_insert_phi(), predict_extra_loop_exits(), predict_loops(), gimple_ranger::prefill_name(), gimple_ranger::prefill_stmt_dependencies(), ipa_param_body_adjustments::prepare_debug_expressions(), prepare_def_site_for(), print_node(), process_bb(), phi_analyzer::process_phi(), propagate_necessity(), propagate_with_phi(), prune_clobbered_mems(), uninit_analysis::prune_phi_opnds(), path_range_query::range_defined_in_block(), ranger_cache::range_from_dom(), dom_ranger::range_in_bb(), ranger_cache::range_of_def(), gimple_ranger::range_of_expr(), ranger_cache::range_of_expr(), gimple_ranger::range_on_entry(), gimple_ranger::range_on_exit(), rank_ops_for_fma(), reassociate_bb(), recognize_bits_test(), recognize_single_bit_test(), record_edge_info(), record_equivalences_from_stmt(), record_increment(), record_invariant(), record_modified(), record_phi_increments_1(), record_temporary_equivalences(), jump_threader::record_temporary_equivalences_from_phis(), cgraph_edge::redirect_call_stmt_to_callee(), reduce_vector_comparison_to_scalar_comparison(), gori_compute::refine_using_relation(), range_def_chain::register_dependency(), equiv_oracle::register_initial_def(), fur_source::register_outgoing_edges(), relation_oracle::register_stmt(), fold_using_range::relation_fold_and_or(), release_defs_bitset(), remap_gimple_op_r(), remap_gimple_stmt(), remap_ssa_name(), remove_gimple_phi_args(), remove_prop_source_from_use(), remove_unused_ivs(), remove_visited_stmt_chain(), replace_locals_op(), replace_names_by_phis(), replace_phi_edge_with_variable(), replace_ssa_name(), repropagate_negates(), reserve_phi_args_for_new_edge(), ranger_cache::resolve_dom(), result_of_phi(), returning_call_p(), rewrite_add_phi_arguments(), rewrite_bittest(), rewrite_debug_stmt_uses(), rewrite_expr_tree(), rewrite_expr_tree_parallel(), rewrite_update_phi_arguments(), rhs_is_fed_for_value_replacement(), same_bool_comparison_p(), scan_operand_equal_p(), sccopy_visit_op(), scev_analyzable_p(), scev_var_range_cant_overflow(), sese_build_liveouts_use(), set_component_ssa_name(), set_cond_stmt_execution_predicate(), ranger_cache::set_global_range(), dom_opt_dom_walker::set_global_ranges_from_unreachable_edges(), set_var_live_on_entry(), should_break_up_subtract(), shrink_wrap_one_built_in_call_with_conds(), simple_dce_from_worklist(), simple_iv_increment_p(), simplify_1a(), predicate::simplify_4(), simplify_builtin_call(), simplify_using_ranges::simplify_casted_compare(), jump_threader::simplify_control_stmt_condition_1(), simplify_conversion_using_ranges(), simplify_gimple_switch(), simplify_permutation(), simplify_rotate(), ssa_propagation_engine::simulate_stmt(), single_trailing_store_in_bb(), sink_common_stores_to_bb(), sm_seq_valid_bb(), sort_by_operand_rank(), split_address_to_core_and_offset(), split_constant_offset_1(), split_function(), split_part_set_ssa_name_p(), ssa_defined_by_minus_one_stmt_p(), path_range_query::ssa_defined_in_bb(), ssa_semi_invariant_p(), ssa_undefined_value_p(), ssa_uniform_vector_p(), stmt_semi_invariant_p_1(), strip_bit_not(), strip_conversion(), strip_nop_cond_scalar_reduction(), thread_private_new_memory(), transaction_invariant_address_p(), loop_distribution::transform_reduction_loop(), transform_to_exit_first_loop(), transform_to_exit_first_loop_alt(), translate_vuse_through_block(), tree_function_versioning(), tree_optimize_tail_calls_1(), tree_single_nonnegative_warnv_p(), trivially_conflicts_p(), try_transform_to_exit_first_loop_alt(), uaddc_cast(), uaddc_ne0(), unadjusted_ptr_and_unit_offset(), undistribute_bitref_for_vector(), undistribute_ops_list(), loop_cand::undo_simple_reduction(), unmodified_parm(), unmodified_parm_or_parm_agg_item(), update_debug_stmt(), update_dep_bb(), update_ops(), update_phi_components(), update_range_test(), use_internal_fn(), va_list_counter_bump(), value_available_p(), valueize_op_1(), valueized_wider_op(), vect_check_gather_scatter(), vect_do_peeling(), vect_find_reusable_accumulator(), vect_find_stmt_data_reference(), vect_get_and_check_slp_defs(), vect_get_external_def_edge(), vect_get_loop_len(), vect_get_loop_mask(), vect_is_nonlinear_iv_evolution(), vect_is_simple_iv_evolution(), vect_is_simple_reduction(), vect_is_simple_use(), vect_loop_versioning(), vect_phi_first_order_recurrence_p(), vect_recog_bitfield_ref_pattern(), vect_recog_divmod_pattern(), vect_recog_popcount_clz_ctz_ffs_pattern(), vect_record_grouped_load_vectors(), vect_remove_slp_scalar_calls(), vect_schedule_scc(), vect_schedule_slp_node(), vect_simd_lane_linear(), vect_slp_check_for_roots(), vect_transform_slp_perm_load_1(), vector_element(), vectorizable_condition(), vectorizable_conversion(), vectorizable_induction(), vectorizable_live_operation(), vectorizable_load(), vectorizable_nonlinear_induction(), vectorizable_recurr(), vectorizable_scan_store(), vectorizable_store(), vectorize_fold_left_reduction(), verify_def(), verify_live_on_entry(), verify_ssa(), verify_ssa_name(), verify_use(), visit_nary_op(), visit_phi(), ccp_propagate::visit_phi(), visit_reference_op_call(), vn_reference_lookup_3(), vn_reference_maybe_forwprop_address(), vn_valueize_for_srt(), walk_aliased_vdefs_1(), walk_non_aliased_vuses(), walk_ssa_copies(), warn_dealloc_offset(), warn_uninit(), warn_uninitialized_phi(), worker_single_copy(), zero_one_minusone(), and zero_one_operation().

◆ SSA_NAME_IDENTIFIER

#define SSA_NAME_IDENTIFIER ( NODE )

Value:

  (SSA_NAME_CHECK (NODE)->ssa_name.var != NULL_TREE             \
   ? (TREE_CODE ((NODE)->ssa_name.var) == IDENTIFIER_NODE       \
      ? (NODE)->ssa_name.var                                    \
      : DECL_NAME ((NODE)->ssa_name.var))                       \
   : NULL_TREE)

Returns the IDENTIFIER_NODE giving the SSA name a name or NULL_TREE
if there is no name associated with it.

Referenced by add_field_for_name(), add_field_for_reduction(), copy_ssa_name_fn(), dump_function_to_file(), dump_generic_node(), fold_builtin_alloca_with_align(), get_name(), access_ref::inform_access(), install_var_field(), and remap_ssa_name().

◆ SSA_NAME_IMM_USE_NODE

#define SSA_NAME_IMM_USE_NODE ( NODE ) SSA_NAME_CHECK (NODE)->ssa_name.imm_uses

Return the immediate_use information for an SSA_NAME.

Referenced by first_imm_use_stmt(), first_readonly_imm_use(), has_single_use(), has_zero_uses(), init_ssa_name_imm_use(), link_imm_use(), num_imm_uses(), release_ssa_name_fn(), single_imm_use(), single_use(), and verify_imm_links().

◆ SSA_NAME_IN_FREE_LIST

#define SSA_NAME_IN_FREE_LIST ( NODE ) SSA_NAME_CHECK (NODE)->base.nothrow_flag

Nonzero if this SSA_NAME expression is currently on the free list of
SSA_NAMES.  Using NOTHROW_FLAG seems reasonably safe since throwing
has no meaning for an SSA_NAME.

Referenced by dump_alias_info(), eliminate_dom_walker::eliminate_stmt(), gimple_ranger::export_global_ranges(), find_released_ssa_name(), make_ssa_name_fn(), output_ssa_names(), print_node(), release_ssa_name_fn(), remove_unreachable::remove_and_update_globals(), remove_prop_source_from_use(), update_ssa(), relation_oracle::valid_equivs(), verify_ssa_name(), verify_ssaname_freelists(), vuse_ssa_val(), and vuse_valueize().

◆ SSA_NAME_IS_DEFAULT_DEF

#define SSA_NAME_IS_DEFAULT_DEF ( NODE ) SSA_NAME_CHECK (NODE)->base.default_def_flag

Nonzero if this SSA_NAME is the default definition for the
underlying symbol.  A default SSA name is created for symbol S if
the very first reference to S in the function is a read operation.
Default definitions are always created by an empty statement and
belong to no basic block.

Referenced by adjust_debug_stmts(), analyze_agg_content_value(), and_comparisons_1(), asan_expand_poison_ifn(), avoid_deep_ter_for_debug(), ranger_cache::block_range(), build_ssa_conflict_graph(), check_name(), chk_uses(), chrec_contains_symbols_defined_in_loop(), classify_builtin_st(), coalesce_bitint(), coalesce_partitions(), coalesce_with_default(), ipa_icf_gimple::func_checker::compare_ssa_name(), compute_added_num_insns(), compute_avail(), compute_complex_ancestor_jump_func(), compute_complex_assign_jump_func(), compute_dependence_clique(), path_range_query::compute_exit_dependencies(), compute_optimized_partition_bases(), decompose_param_expr(), dump_generic_node(), eliminate_dom_walker::eliminate_avail(), rpo_elim::eliminate_avail(), eliminate_dom_walker::eliminate_insert(), eliminate_dom_walker::eliminate_stmt(), eliminate_unnecessary_stmts(), evaluate_stmt(), execute_cse_conv_1(), execute_cse_sincos_1(), expand_debug_expr(), expand_expr_real_1(), expand_fn_using_insn(), find_what_p_points_to(), follow_outer_ssa_edges(), get_ancestor_addr_info(), get_component_ssa_name(), get_constraint_for_ssa_var(), get_continuation_for_phi(), range_def_chain::get_def_chain(), ipa_polymorphic_call_context::get_dynamic_type(), get_fi_for_callee(), get_scalar_evolution(), get_ssa_base_param(), get_ssa_def_if_simple_copy(), gimple_lower_bitint(), gimple_range_global(), hardcfr_sibcall_search_preds(), hash_tree(), hoist_adjacent_loads(), init_reassoc(), initialize_argument_information(), insert_phi_nodes(), instantiate_scev_name(), ipa_analyze_indirect_call_uses(), ipa_analyze_virtual_call_uses(), ipa_compute_jump_functions_for_edge(), ipa_get_stmt_member_ptr_load_param(), ipa_is_ssa_with_stmt_def(), ipa_load_from_parm_agg(), ipa_polymorphic_call_context::ipa_polymorphic_call_context(), ipa_simd_modify_function_body(), likely_value(), load_or_store_of_ptr_parameter(), vec_info::lookup_def(), loop_combined_static_and_iv_p(), loop_invariant_op_p(), loop_static_op_p(), make_ssa_name_fn(), tree_loop_interchange::map_inductions_to_loop(), match_simplify_replacement(), may_propagate_copy(), maybe_remove_writeonly_store(), maybe_replace_use_in_debug_stmt(), ipa_param_body_adjustments::modify_call_stmt(), or_comparisons_1(), output_ssa_names(), pack_ts_base_value_fields(), param_change_prob(), param_type_may_change_p(), parm_decl_cost(), partition_view_init(), phi_rank(), populate_coalesce_list_for_outofssa(), gimple_ranger::prefill_stmt_dependencies(), ipa_param_body_adjustments::prepare_debug_expressions(), process_bb(), propagate_with_phi(), record_modified(), equiv_oracle::register_initial_def(), release_ssa_name_fn(), remap_ssa_name(), remove_unreachable::remove_and_update_globals(), remove_prop_source_from_use(), remove_unused_locals(), replace_ssa_name(), returning_call_p(), rewrite_debug_stmt_uses(), set_component_ssa_name(), dom_opt_dom_walker::set_global_ranges_from_unreachable_edges(), set_rtl(), set_ssa_default_def(), setup_one_parameter(), simple_dce_from_worklist(), ssa_propagation_engine::simulate_stmt(), single_trailing_store_in_bb(), sink_clobbers(), slsr_process_phi(), split_part_set_ssa_name_p(), thread_private_new_memory(), unadjusted_ptr_and_unit_offset(), unmodified_parm(), unmodified_parm_1(), unmodified_parm_or_parm_agg_item(), unpack_ts_base_value_fields(), update_dep_bb(), update_range_test(), value_available_p(), vect_create_constant_vectors(), vect_get_and_check_slp_defs(), vect_get_external_def_edge(), vect_is_simple_use(), vect_phi_first_order_recurrence_p(), vect_schedule_slp_node(), vectorizable_live_operation(), verify_ssa_name(), verify_ssaname_freelists(), verify_use(), visit_loadstore(), visit_phi(), ccp_propagate::visit_phi(), visit_reference_op_call(), VN_INFO(), vn_reference_lookup_2(), vn_valueize_for_srt(), walk_ssa_copies(), and warn_uninit_phi_uses().

◆ SSA_NAME_IS_VIRTUAL_OPERAND

#define SSA_NAME_IS_VIRTUAL_OPERAND ( NODE ) SSA_NAME_CHECK (NODE)->base.public_flag

SSA_NAME accessors.

Whether SSA_NAME NODE is a virtual operand.  This simply caches the
information in the underlying SSA_NAME_VAR for efficiency.

Referenced by gimple_lower_bitint(), gimple_range_ssa_p(), mark_ssa_maybe_undefs(), neuter_worker_single(), virtual_operand_p(), visit_phi(), and worker_single_copy().

◆ SSA_NAME_OCCURS_IN_ABNORMAL_PHI

#define SSA_NAME_OCCURS_IN_ABNORMAL_PHI ( NODE ) SSA_NAME_CHECK (NODE)->base.asm_written_flag

Nonzero if this SSA name occurs in an abnormal PHI.  SSA_NAMES are
never output, so we can safely use the ASM_WRITTEN_FLAG for this
status bit.

Referenced by add_phi_arg(), associate_equivalences_with_edges(), rewrite_update_dom_walker::before_dom_children(), can_reassociate_op_p(), clean_up_loop_closed_phi(), combine_blocks(), compute_uninit_opnds_pos(), contains_abnormal_ssa_name_p_1(), convert_mult_to_widen(), create_expression_by_pieces(), create_new_def_for(), do_pre_regular_insertion(), dump_generic_node(), eliminate_dom_walker::eliminate_avail(), eliminate_redundant_comparison(), eliminate_redundant_computations(), evaluate_stmt(), execute_cse_conv_1(), expand_simple_operations(), factor_out_conditional_operation(), final_value_replacement_loop(), find_basis_for_base_expr(), find_bivs(), back_threader::find_paths_to_names(), find_phi_def(), get_component_ssa_name(), get_stridx_plus_constant(), get_value_for_expr(), gimple_lower_bitint(), gimple_merge_blocks(), gimple_range_ssa_p(), strlen_pass::handle_builtin_strchr(), strlen_pass::handle_builtin_strlen(), strlen_pass::handle_store(), if_convertible_gimple_assign_stmt_p(), ifcombine_ifandif(), init_range_entry(), instrument_object_size(), ipa_simd_modify_function_body(), match_arith_overflow(), may_propagate_copy(), may_propagate_copy_into_stmt(), maybe_push_res_to_seq(), movement_possibility_1(), new_stridx(), object_sizes_execute(), optimize_atomic_bit_test_and(), optimize_atomic_op_fetch_cmp_0(), optimize_vector_constructor(), print_node(), record_equivalences_from_phis(), remap_ssa_name(), remove_dead_phis(), replace_abnormal_ssa_names(), substitute_and_fold_engine::replace_phi_args_in(), ipa_param_body_adjustments::replace_removed_params_ssa_names(), replace_stmt_with_simplification(), replace_uses_by(), repropagate_negates(), rewrite_update_phi_arguments(), set_component_ssa_name(), set_ssa_val_to(), setup_one_parameter(), shrink_wrap_one_built_in_call_with_conds(), simplify_using_ranges::simplify_casted_compare(), simplify_conversion_using_ranges(), sink_clobbers(), spaceship_replacement(), split_constant_offset_1(), ssa_semi_invariant_p(), statement_sink_location(), stmt_may_generate_copy(), stmt_may_generate_copy(), stmt_references_abnormal_ssa_name(), stmt_semi_invariant_p_1(), unlink_stmt_vdef(), unsplit_eh(), update_ssa_across_abnormal_edges(), rvrp_folder::value_of_expr(), fvrp_folder::value_of_expr(), rvrp_folder::value_of_stmt(), fvrp_folder::value_of_stmt(), rvrp_folder::value_on_edge(), fvrp_folder::value_on_edge(), vectorizable_live_operation(), verify_use(), visit_nary_op(), visit_phi(), complex_propagate::visit_phi(), copy_prop::visit_phi(), complex_propagate::visit_stmt(), visit_stmt(), vn_reference_lookup_3(), vn_reference_maybe_forwprop_address(), and zero_length_string().

◆ SSA_NAME_POINTS_TO_READONLY_MEMORY

#define SSA_NAME_POINTS_TO_READONLY_MEMORY ( NODE ) SSA_NAME_CHECK (NODE)->base.deprecated_flag

Nonzero if this SSA_NAME is known to point to memory that may not
be written to.  This is set for default defs of function parameters
that have a corresponding r or R specification in the functions
fn spec attribute.  This is used by alias analysis.

Referenced by call_may_clobber_ref_p_1(), and refs_may_alias_p_2().

◆ SSA_NAME_PTR_INFO

#define SSA_NAME_PTR_INFO ( N ) SSA_NAME_CHECK (N)->ssa_name.info.ptr_info

Attributes for SSA_NAMEs for pointer-type variables.

Referenced by bump_vector_ptr(), call_may_clobber_ref_p_1(), copy_ref_info(), default_ref_may_alias_errno(), dr_analyze_alias(), dump_alias_info(), dump_points_to_info_for(), dump_ssaname_info(), duplicate_ssa_name_fn(), duplicate_ssa_name_ptr_info(), eliminate_dom_walker::eliminate_stmt(), fini_copy_prop(), ipa_icf::sem_item_optimizer::fixup_points_to_sets(), fold_builtin_alloca_with_align(), get_nonzero_bits(), get_pointer_alignment_1(), get_ptr_info(), get_ssa_name_ptr_info_nonnull(), gimple_range_global(), issue_prefetch_ref(), make_ssa_name_fn(), maybe_set_nonzero_bits(), ipa_icf::sem_item_optimizer::merge_classes(), predicate_load_or_store(), print_node(), ptr_deref_may_alias_decl_p(), ptr_deref_may_alias_global_p(), ptr_derefs_may_alias_p(), ptrs_compare_unequal(), ref_maybe_used_by_call_p_1(), remap_ssa_name(), reset_flow_sensitive_info(), flow_sensitive_info_storage::restore(), rewrite_use_nonlinear_expr(), same_addr_size_stores_p(), flow_sensitive_info_storage::save(), stmt_may_generate_copy(), update_alias_info_with_stack_vars(), vect_create_addr_base_for_vector_ref(), vect_duplicate_ssa_name_ptr_info(), and verify_ssa().

◆ SSA_NAME_RANGE_INFO

#define SSA_NAME_RANGE_INFO ( N ) SSA_NAME_CHECK (N)->ssa_name.info.range_info

Value range info attributes for SSA_NAMEs of non pointer-type variables.

Referenced by dump_ssaname_info(), eliminate_dom_walker::eliminate_stmt(), fini_copy_prop(), get_ssa_name_range_info(), gimple_range_global(), insert_into_preds_of_block(), make_ssa_name_fn(), ipa_icf::sem_item_optimizer::merge_classes(), range_info_alloc(), range_info_fits_p(), range_info_free(), range_info_get_range(), range_info_p(), range_info_set_range(), remap_ssa_name(), replace_phi_edge_with_variable(), reset_flow_sensitive_info(), flow_sensitive_info_storage::restore(), flow_sensitive_info_storage::save(), stmt_may_generate_copy(), value_replacement(), and verify_ssa().

◆ SSA_NAME_VAR

#define SSA_NAME_VAR ( NODE )

Value:

  (SSA_NAME_CHECK (NODE)->ssa_name.var == NULL_TREE             \
   || TREE_CODE ((NODE)->ssa_name.var) == IDENTIFIER_NODE       \
   ? NULL_TREE : (NODE)->ssa_name.var)

Returns the variable being referenced.  This can be NULL_TREE for
temporaries not associated with any user variable.
Once released, this is the only field that can be relied upon.

Referenced by _loop_vec_info::_loop_vec_info(), add_new_name_mapping(), adjust_one_expanded_partition_var(), adjust_simduid_builtins(), rewrite_dom_walker::after_dom_children(), analyze_agg_content_value(), asan_expand_poison_ifn(), rewrite_dom_walker::before_dom_children(), rewrite_update_dom_walker::before_dom_children(), build_ssa_conflict_graph(), coalesce_bitint(), coalesce_partitions(), coalesce_with_default(), collect_object_sizes_for(), ipa_icf_gimple::func_checker::compare_ssa_name(), compute_complex_ancestor_jump_func(), compute_complex_assign_jump_func(), compute_dependence_clique(), compute_optimized_partition_bases(), consider_split(), copy_ssa_name_fn(), create_parallel_loop(), defer_stack_allocation(), determine_iv_cost(), dump_default_def(), dump_defs_stack(), dump_function_to_file(), dump_generic_node(), dump_variable(), eliminate_tail_call(), eliminate_temp_copies(), eliminated_by_inlining_prob(), ssa_name_var_hash::equal(), execute_load_motion(), expand_asm_stmt(), expand_call_inline(), expand_debug_expr(), expand_expr_real_1(), expand_fn_using_insn(), expand_omp_taskreg(), operands_scanner::finalize_ssa_defs(), operands_scanner::finalize_ssa_uses(), find_assumption_locals_r(), find_replaceable_in_bb(), find_what_p_points_to(), fold_builtin_next_arg(), get_ancestor_addr_info(), get_attr_nonstring_decl(), get_base_decl(), get_component_ssa_name(), get_constraint_for_ssa_var(), ana::state_purge_map::get_data_for_ssa_name(), get_default_value(), get_fi_for_callee(), get_reaching_def(), get_references_in_stmt(), get_ssa_base_param(), gimple_can_coalesce_p(), gimple_lower_bitint(), gimple_parm_array_size(), gimple_range_global(), ssa_name_var_hash::hash(), access_ref::inform_access(), initialize_argument_information(), initialize_inlined_parameters(), initialize_root_vars_store_elim_2(), input_ssa_names(), ipa_analyze_indirect_call_uses(), ipa_analyze_virtual_call_uses(), ipa_compute_jump_functions_for_edge(), ipa_get_stmt_member_ptr_load_param(), ipa_load_from_parm_agg(), ipa_polymorphic_call_context::ipa_polymorphic_call_context(), ipa_simd_modify_function_body(), is_parm(), load_or_store_of_ptr_parameter(), tree_loop_interchange::map_inductions_to_loop(), mark_all_vars_used_1(), mark_nonssa_use(), mark_virtual_operand_for_renaming(), may_propagate_copy(), maybe_register_def(), maybe_replace_use(), maybe_replace_use_in_debug_stmt(), maybe_warn_operand(), ipa_param_body_adjustments::modify_call_stmt(), move_block_to_fn(), note_simd_array_uses(), omp_extract_for_data(), output_ssa_names(), param_type_may_change_p(), parm_decl_cost(), parm_object_size(), partition_view_init(), populate_coalesce_list_for_outofssa(), prepare_block_for_update_1(), prepare_decl_rtl(), print_node(), process_replaceable(), promote_ssa_mode(), remap_gimple_stmt(), remap_ssa_name(), remove_unused_ivs(), remove_unused_locals(), replace_block_by(), replace_ref_with(), ipa_param_body_adjustments::replace_removed_params_ssa_names(), replace_ssa_name(), rewrite_add_phi_arguments(), rewrite_update_phi_arguments(), rewrite_use_compare(), separate_decls_in_region_name(), set_component_ssa_name(), set_rtl(), set_ssa_default_def(), ssa_defined_default_def_p(), target_for_debug_bind(), test_nonssa_use(), transform_to_exit_first_loop(), uninit_undefined_value_p(), unmodified_parm_1(), update_phi_components(), update_ssa(), use_register_for_decl(), vect_create_addr_base_for_vector_ref(), vect_find_stmt_data_reference(), vect_simd_lane_linear(), vectorizable_call(), verify_def(), verify_gimple_call(), verify_gimple_phi(), verify_gimple_return(), verify_live_on_entry(), verify_ssa_name(), operands_scanner::verify_ssa_operands(), visit_loadstore(), VN_INFO(), vn_reference_lookup_2(), warn_uninit(), warn_uninit_phi_uses(), warn_uninitialized_phi(), and warn_uninitialized_vars().

◆ SSA_NAME_VERSION

#define SSA_NAME_VERSION ( NODE ) SSA_NAME_CHECK (NODE)->base.u.version

Returns the SSA version number of this SSA name.  Note that in
tree SSA, version numbers are not per variable and may be recycled.

Referenced by add_dependence(), pcom_worker::add_looparound_copies(), add_new_name_mapping(), equiv_oracle::add_partial_equiv(), infer_range_manager::add_range(), path_range_query::add_to_exit_dependencies(), add_to_repl_tbl(), addr_object_size(), eliminate_dom_walker::after_dom_children(), alias_get_name(), alloc_expression_id(), temporal_cache::always_current_p(), analyze_function_body(), substitute_and_fold_dom_walker::before_dom_children(), eliminate_dom_walker::before_dom_children(), strlen_pass::before_dom_children(), build_bitint_stmt_ssa_conflicts(), build_new_reduction(), call_object_size(), range_def_chain::chain_import_p(), check_all_va_list_escapes(), strlen_pass::check_and_optimize_stmt(), check_for_plus_in_loops(), check_for_plus_in_loops_1(), check_reduction_path(), check_va_list_escapes(), cleanup_empty_eh_merge_phis(), ssa_cache::clear_range(), ssa_lazy_cache::clear_range(), coalesce_bitint(), coalesce_partitions(), coalesce_with_default(), collect_object_sizes_for(), ipa_icf_gimple::func_checker::compare_ssa_name(), compare_ssa_versions(), compute_builtin_object_size(), hybrid_jt_simplifier::compute_exit_dependencies(), path_range_query::compute_exit_dependencies(), cond_expr_object_size(), consider_split(), create_coalesce_list_for_region(), create_expression_by_pieces(), temporal_cache::current_p(), data_ref_compare_tree(), range_def_chain::depend1(), range_def_chain::depend2(), do_pre_regular_insertion(), dse_classify_store(), dump_copy_of(), dump_generic_node(), dynamic_object_size(), eliminate_dom_walker::eliminate_avail(), eliminate_dom_walker::eliminate_push_avail(), rpo_elim::eliminate_push_avail(), eliminate_dom_walker::eliminate_stmt(), eliminate_unnecessary_stmts(), equiv_oracle::equiv_set(), path_oracle::equiv_set(), path_range_query::exit_dependency_p(), expand_gimple_basic_block(), expand_gimple_cond(), expand_vector_condition(), expr_expected_value_1(), expr_object_size(), find_equal_ptrs(), equiv_oracle::find_equiv_dom(), find_lattice_value(), back_threader::find_paths_to_names(), infer_range_manager::exit_range_head::find_ptr(), relation_chain_head::find_relation(), dom_oracle::find_relation_block(), find_replaceable_in_bb(), find_tail_calls(), find_uses_to_rename_use(), find_va_list_reference(), find_var_scev_info(), find_vdef_in_loop(), fwprop_invalidate_lattice(), fwprop_set_lattice_val(), fwprop_ssa_val(), gather_ssa_name_hash_map_from(), get_component_ssa_name(), get_copy_of_val(), range_def_chain::get_def_chain(), pointer_equiv_analyzer::get_equiv(), get_gimple_for_ssa_name(), range_def_chain::get_imports(), get_instantiated_value_entry(), infer_range_manager::get_nonzero(), ssa_cache::get_range(), ssa_lazy_cache::get_range(), get_range_strlen(), get_range_strlen_phi(), get_rank(), pointer_query::get_ref(), pointer_query::get_ref(), ssa_equiv_stack::get_replacement(), get_rtx_for_ssa_name(), get_ssa_name_ann(), get_stridx(), get_stridx_plus_constant(), get_value(), gimple_lower_bitint(), gimplify_size_expressions(), phi_analyzer::group(), strlen_pass::handle_builtin_memcpy(), strlen_pass::handle_builtin_strcpy(), remove_unreachable::handle_early(), strlen_pass::handle_pointer_plus(), range_def_chain::has_def_chain(), ssa_cache::has_range(), ssa_lazy_cache::has_range(), infer_range_manager::has_range_p(), has_VN_INFO(), pre_expr_d::hash(), vn_ssa_aux_hasher::hash(), tree_ssa_name_hash::hash(), operand_compare::hash_operand(), range_def_chain::in_chain_p(), independent_of_stmt_p(), init_parameter_lattice_values(), insert_into_preds_of_block(), install_var_field(), tree_loop_interchange::interchange_loops(), gori_map::is_export_p(), gori_map::is_import_p(), is_maybe_undefined(), phi_group::is_modifier_p(), is_new_name(), is_old_name(), path_oracle::killing_def(), ssa_equiv_stack::leave(), ssa_name_limit_t::leave_phi(), lookup_expression_id(), lto_indexable_tree_ref(), make_ssa_name_fn(), malloc_candidate_p_1(), tree_loop_interchange::map_inductions_to_loop(), mark_all_reaching_defs_necessary_1(), mark_operand_necessary(), mark_replaceable(), mark_ssa_maybe_undefs(), match_simplify_replacement(), gori_map::maybe_add_gori(), maybe_remove_writeonly_store(), maybe_skip_until(), back_threader::maybe_thread_block(), merge_object_sizes(), ssa_cache::merge_range(), ssa_lazy_cache::merge_range(), move_stmt(), name_info(), new_scev_info_str(), new_stridx(), oacc_entry_exit_ok_1(), oacc_entry_exit_single_gang(), phi_analyzer::operator[](), output_phi(), parm_object_size(), equiv_oracle::partial_equiv(), equiv_oracle::partial_equiv_set(), phi_dynamic_object_size(), phiprop_insert_phi(), phivn_valid_p(), plus_stmt_object_size(), populate_coalesce_list_for_outofssa(), predicate_for_phi_result(), prepare_def_site_for(), print_node(), phi_analyzer::process_phi(), process_replaceable(), propagate_rank(), propagate_unknowns(), propagate_with_phi(), uninit_analysis::prune_phi_opnds(), ssa_equiv_stack::push_replacement(), pointer_query::put_ref(), block_range_cache::query_block_ranges(), dom_oracle::query_relation(), path_oracle::query_relation(), range_entry_cmp(), record_invariant(), infer_range_manager::register_all_uses(), range_def_chain::register_dependency(), equiv_oracle::register_initial_def(), dom_oracle::register_relation(), equiv_oracle::register_relation(), path_oracle::register_relation(), dom_oracle::register_transitives(), release_defs_bitset(), release_free_names_and_compact_live_names(), release_ssa_name_after_update_ssa(), release_ssa_name_fn(), remove_unused_ivs(), replace_scc_by_value(), rewrite_expr_tree_parallel(), separate_decls_in_region_debug(), separate_decls_in_region_name(), sese_build_liveouts_use(), temporal_cache::set_always_current(), block_range_cache::set_bb_range(), set_component_ssa_name(), set_copy_of_val(), pointer_equiv_analyzer::set_global_equiv(), range_def_chain::set_import(), set_iv(), set_lattice_value(), dom_oracle::set_one_relation(), ssa_cache::set_range(), ssa_lazy_cache::set_range(), gori_map::set_range_invariant(), set_ssa_name_value(), temporal_cache::set_timestamp(), set_value_varying(), simple_dce_from_worklist(), pcom_worker::single_nonlooparound_use(), sm_seq_valid_bb(), sort_by_mach_mode(), sort_by_operand_rank(), sort_by_ssa_version_or_uid(), split_function(), SSA_VAL(), stack_var_cmp(), tree_swap_operands_p(), loop_cand::undo_simple_reduction(), unknown_object_size(), va_list_counter_bump(), va_list_counter_struct_op(), va_list_ptr_read(), va_list_ptr_write(), copy_folder::value_of_expr(), var_to_partition(), var_union(), vect_create_destination_var(), verify_def(), verify_phi_args(), verify_ssa(), verify_ssaname_freelists(), verify_use(), visit_bb(), complex_propagate::visit_phi(), ssa_name_limit_t::visit_phi(), visit_reference_op_call(), complex_propagate::visit_stmt(), VN_INFO(), vn_reference_compute_hash(), vn_reference_lookup_2(), vn_reference_lookup_3(), walk_aliased_vdefs_1(), will_be_nonconstant_expr_predicate(), will_be_nonconstant_predicate(), and zero_length_string().

◆ SSA_VAR_P

#define SSA_VAR_P ( DECL )

Value:

        (TREE_CODE (DECL) == VAR_DECL                                   \
         || TREE_CODE (DECL) == PARM_DECL                               \
         || TREE_CODE (DECL) == RESULT_DECL                             \
         || TREE_CODE (DECL) == SSA_NAME)

Define fields and accessors for nodes representing declared names.

Nonzero if DECL represents an SSA name or a variable that can possibly
have an associated SSA name.

Referenced by operands_scanner::add_stmt_operand(), eliminate_local_variables_1(), expand_oacc_for(), expand_omp_for_generic(), expand_omp_for_init_counts(), expand_omp_taskloop_for_outer(), force_expr_to_var_cost(), get_base_var(), gimple_call_nonnull_arg(), gimple_cond_get_ops_from_tree(), gimple_fold_builtin_memory_op(), gimple_switch_set_index(), instrument_object_size(), omp_extract_for_data(), optimize_atomic_compare_exchange_p(), replace_by_duplicate_decl(), same_addr_size_stores_p(), separate_decls_in_region_debug(), and volatile_lvalue_p().

◆ ssize_int

◆ ssizetype

◆ STATEMENT_CLASS_P

#define STATEMENT_CLASS_P ( NODE ) (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_statement)

Nonzero if NODE represents a statement expression.

◆ STATEMENT_LIST_HEAD

#define STATEMENT_LIST_HEAD ( NODE ) (STATEMENT_LIST_CHECK (NODE)->stmt_list.head)

A STATEMENT_LIST chains statements together in GENERIC and GIMPLE.
To reduce overhead, the nodes containing the statements are not trees.
This avoids the overhead of tree_common on all linked list elements.

Use the interface in tree-iterator.h to access this node.

Referenced by expr_first(), expr_single(), free_stmt_list(), tsi_delink(), tsi_link_after(), tsi_link_before(), and tsi_start().

◆ STATEMENT_LIST_TAIL

#define STATEMENT_LIST_TAIL ( NODE ) (STATEMENT_LIST_CHECK (NODE)->stmt_list.tail)

Referenced by expr_last(), free_stmt_list(), tsi_delink(), tsi_last(), tsi_link_after(), and tsi_link_before().

◆ STMT_CHECK

#define STMT_CHECK ( T ) TREE_CLASS_CHECK (T, tcc_statement)

◆ STRIP_ANY_LOCATION_WRAPPER

#define STRIP_ANY_LOCATION_WRAPPER ( EXP ) (EXP) = tree_strip_any_location_wrapper (CONST_CAST_TREE (EXP))

Remove any VIEW_CONVERT_EXPR or NON_LVALUE_EXPR that's purely
in use to provide a location_t.

Referenced by fixed_zerop(), operand_compare::hash_operand(), initializer_each_zero_or_onep(), integer_all_onesp(), integer_each_onep(), integer_minus_onep(), integer_nonzerop(), integer_onep(), integer_pow2p(), integer_truep(), integer_valued_real_p(), integer_zerop(), operand_compare::operand_equal_p(), real_minus_onep(), real_onep(), real_zerop(), tree_int_cst_equal(), and uniform_integer_cst_p().

◆ STRIP_NOPS

#define STRIP_NOPS ( EXP ) (EXP) = tree_strip_nop_conversions (CONST_CAST_TREE (EXP))

Given an expression as a tree, strip any conversion that generates
no instruction.  Accepts both tree and const_tree arguments since
we are not modifying the tree itself.

Referenced by add_iv_candidate_for_use(), scev_dfs::add_to_evolution_1(), alloc_iv(), backtrace_base_for_ref(), bitwise_equal_p(), bitwise_inverted_equal_p(), c_strlen(), canonicalize_base_object_address(), canonicalize_constructor_val(), compute_objsize_r(), const_binop(), constant_byte_string(), constant_multiple_of(), contain_complex_addr_expr(), decode_field_reference(), do_mpc_arg2(), do_mpfr_lgamma_r(), do_mpfr_remquo(), do_store_flag(), dr_analyze_indices(), dr_equal_offsets_p1(), dr_step_indicator(), dynamic_object_sizes_execute_one(), expand_builtin_atomic_fetch_op(), expand_builtin_object_size(), extract_base_bit_offset(), extract_bit_test_mask(), fold_binary_loc(), fold_builtin_constant_p(), fold_builtin_expect(), fold_builtin_frexp(), fold_builtin_modf(), fold_builtin_object_size(), fold_cond_expr_with_comparison(), fold_indirect_ref_1(), fold_ternary_loc(), fold_unary_loc(), force_expr_to_var_cost(), get_alias_set(), get_callee_fndecl(), get_initializer_for(), get_loop_invariant_expr(), get_name(), get_pointer_alignment_1(), get_shiftadd_cost(), gimple_fold_builtin(), gimple_fold_indirect_ref(), gimple_fold_stmt_to_constant_1(), gimple_get_virt_method_for_vtable(), gimplify_asm_expr(), operand_compare::hash_operand(), initializer_zerop(), loc_list_for_address_of_addr_expr_of_indirect_ref(), loc_list_from_tree_1(), symtab_node::maybe_create_reference(), maybe_warn_nonstring_arg(), native_encode_initializer(), no_evolution_in_loop_p(), omp_build_struct_sibling_lists(), omp_containing_struct(), omp_get_base_pointer(), omp_addr_tokenizer::omp_parse_access_method(), omp_addr_tokenizer::omp_parse_pointer(), operand_equal_for_comparison_p(), operand_compare::operand_equal_p(), optimize_bitfield_assignment_op(), optimize_range_tests_to_bit_test(), output_constructor(), output_ttype(), parm_decl_cost(), ptr_deref_may_alias_decl_p(), ptr_derefs_may_alias_p(), range_binop(), readonly_data_expr(), record_type_list(), rtl_for_decl_init(), simple_operand_p(), split_address_to_core_and_offset(), strip_offset_1(), tree_add_const_value_attribute(), tree_swap_operands_p(), tree_to_aff_combination(), vect_analyze_scalar_cycles_1(), vect_check_gather_scatter(), vect_find_stmt_data_reference(), and walk_ssa_copies().

◆ STRIP_SIGN_NOPS

#define STRIP_SIGN_NOPS ( EXP ) (EXP) = tree_strip_sign_nop_conversions (CONST_CAST_TREE (EXP))

Like STRIP_NOPS, but don't let the signedness change either.

Referenced by bound_difference(), fold_binary_loc(), fold_comparison(), fold_negate_expr(), fold_unary_loc(), gimplify_conversion(), negate_expr(), negate_expr_p(), refine_bounds_using_guard(), refine_value_range_using_guard(), and split_tree().

◆ STRIP_TYPE_NOPS

#define STRIP_TYPE_NOPS ( EXP )

Value:

  while ((CONVERT_EXPR_P (EXP)                                  \
          || TREE_CODE (EXP) == NON_LVALUE_EXPR)                \
         && TREE_OPERAND (EXP, 0) != error_mark_node            \
         && (TREE_TYPE (EXP)                                    \
             == TREE_TYPE (TREE_OPERAND (EXP, 0))))             \
    (EXP) = TREE_OPERAND (EXP, 0)

Like STRIP_NOPS, but don't alter the TREE_TYPE either.

Referenced by copy_tree_body_r(), gimplify_cond_expr(), remap_gimple_op_r(), and remap_gimple_stmt().

◆ STRIP_USELESS_TYPE_CONVERSION

#define STRIP_USELESS_TYPE_CONVERSION ( EXP ) (EXP) = tree_ssa_strip_useless_type_conversions (EXP)

Remove unnecessary type conversions according to
tree_ssa_useless_type_conversion.

Referenced by build_ref_for_offset(), data_ref_compare_tree(), declare_return_variable(), dr_analyze_indices(), eliminate_redundant_comparison(), fold_ctor_reference(), fold_gimple_assign(), scev_dfs::follow_ssa_edge_expr(), fully_constant_vn_reference_p(), gimplify_compound_lval(), gimplify_expr(), gimplify_modify_expr(), goa_lhs_expr_p(), increment_start_addr(), maybe_create_ssa_name(), new_strinfo(), setup_one_parameter(), and simplify_builtin_call().

◆ SUBSTITUTE_IN_EXPR

#define SUBSTITUTE_IN_EXPR	(	EXP,
		F,
		R ) ((EXP) == 0 \|\| TREE_CONSTANT (EXP) ? (EXP) : substitute_in_expr (EXP, F, R))

This macro calls the above function but short-circuits the common
case of a constant to save time and also checks for NULL.

Referenced by substitute_in_expr().

◆ SUBSTITUTE_PLACEHOLDER_IN_EXPR

#define SUBSTITUTE_PLACEHOLDER_IN_EXPR	(		EXP,
			OBJ )

Value:

((EXP) == 0 || TREE_CONSTANT (EXP) ? (EXP) \

: substitute_placeholder_in_expr (EXP, OBJ))

substitute_placeholder_in_expr

tree substitute_placeholder_in_expr(tree, tree)

Definition tree.cc:4560

This macro calls the above function but short-circuits the common
case of a constant to save time and also checks for NULL.

Referenced by array_ref_element_size(), array_ref_low_bound(), array_ref_up_bound(), component_ref_field_offset(), expr_size(), gimplify_variable_sized_compare(), maybe_with_size_expr(), and substitute_placeholder_in_expr().

◆ SWITCH_ALL_CASES_P

#define SWITCH_ALL_CASES_P ( NODE ) (SWITCH_EXPR_CHECK (NODE)->base.private_flag)

True if there are case labels for all possible values of SWITCH_COND, either
because there is a default: case label or because the case label ranges cover
all values.

Referenced by block_may_fallthru().

◆ SWITCH_BODY

#define SWITCH_BODY ( NODE ) TREE_OPERAND (SWITCH_EXPR_CHECK (NODE), 1)

Referenced by block_may_fallthru(), contains_label_1(), dump_generic_node(), and gimplify_switch_expr().

◆ SWITCH_BREAK_LABEL_P

#define SWITCH_BREAK_LABEL_P ( NODE ) (LABEL_DECL_CHECK (NODE)->base.protected_flag)

Set on the artificial label created for break; stmt from a switch.
This is used to implement -Wimplicit-fallthrough.

Referenced by collect_fallthrough_labels(), and gimplify_switch_expr().

◆ SWITCH_COND

#define SWITCH_COND ( NODE ) TREE_OPERAND (SWITCH_EXPR_CHECK (NODE), 0)

SWITCH_EXPR accessors. These give access to the condition and body.

Referenced by contains_label_1(), dump_generic_node(), and gimplify_switch_expr().

◆ ta_type_node

#define ta_type_node global_trees[TI_TA_TYPE]

◆ TARGET_EXPR_CLEANUP

#define TARGET_EXPR_CLEANUP ( NODE ) TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 2)

Referenced by gimplify_target_expr().

◆ TARGET_EXPR_INITIAL

#define TARGET_EXPR_INITIAL ( NODE ) TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 1)

Referenced by computable_teams_clause(), dump_generic_node(), gimplify_arg(), gimplify_modify_expr_rhs(), gimplify_target_expr(), goa_stabilize_expr(), and tree_invalid_nonnegative_warnv_p().

◆ TARGET_EXPR_NO_ELIDE

#define TARGET_EXPR_NO_ELIDE ( NODE ) (TARGET_EXPR_CHECK (NODE)->base.private_flag)

Don't elide the initialization of TARGET_EXPR_SLOT for this TARGET_EXPR
on rhs of MODIFY_EXPR.

Referenced by gimplify_modify_expr_rhs().

◆ TARGET_EXPR_SLOT

#define TARGET_EXPR_SLOT ( NODE ) TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 0)

In a TARGET_EXPR node.

Referenced by computable_teams_clause(), dump_generic_node(), gimplify_target_expr(), operand_compare::hash_operand(), tree_invalid_nonnegative_warnv_p(), and tree_single_nonzero_warnv_p().

◆ target_option_current_node

#define target_option_current_node global_trees[TI_TARGET_OPTION_CURRENT]

Referenced by decl_attributes().

◆ target_option_default_node

#define target_option_default_node global_trees[TI_TARGET_OPTION_DEFAULT]

Default/current target options (TARGET_OPTION_NODE).

Referenced by cgraph_build_static_cdtor(), decl_attributes(), default_target_can_inline_p(), and target_opts_for_fn().

◆ TMR_BASE

#define TMR_BASE ( NODE ) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 0))

The operands of a TARGET_MEM_REF.  Operands 0 and 1 have to match
corresponding MEM_REF operands.

Referenced by ao_ref_from_mem(), expand_debug_expr(), find_interesting_uses_address(), for_each_index(), get_address_description(), get_ref_base_and_extent(), operands_scanner::get_tmr_operands(), gimplify_expr(), mark_all_vars_used_1(), requires_barrier(), tree_mem_ref_addr(), and verify_types_in_gimple_reference().

◆ TMR_INDEX

#define TMR_INDEX ( NODE ) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 2))

Referenced by copy_reference_ops_from_ref(), dump_mem_ref(), find_interesting_uses_address(), for_each_index(), get_addr_base_and_unit_offset_1(), get_address_description(), get_object_alignment_2(), get_ref_base_and_extent(), operands_scanner::get_tmr_operands(), gimplify_expr(), indirect_ref_may_alias_decl_p(), indirect_refs_may_alias_p(), mark_all_vars_used_1(), tree_could_trap_p(), and tree_mem_ref_addr().

◆ TMR_INDEX2

◆ TMR_OFFSET

#define TMR_OFFSET ( NODE ) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 1))

Referenced by copy_reference_ops_from_ref(), expand_call_mem_ref(), get_addr_base_and_unit_offset_1(), get_address_description(), reference_alias_ptr_type_1(), tree_mem_ref_addr(), and verify_types_in_gimple_reference().

◆ TMR_STEP

#define TMR_STEP ( NODE ) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 3))

Referenced by copy_reference_ops_from_ref(), dump_mem_ref(), find_interesting_uses_address(), get_address_description(), get_object_alignment_2(), indirect_refs_may_alias_p(), and tree_mem_ref_addr().

◆ tq_type_node

#define tq_type_node global_trees[TI_TQ_TYPE]

◆ TRANSACTION_EXPR_BODY

#define TRANSACTION_EXPR_BODY ( NODE ) TREE_OPERAND (TRANSACTION_EXPR_CHECK (NODE), 0)

TM directives and accessors.

Referenced by dump_generic_node(), gimplify_transaction(), and voidify_wrapper_expr().

◆ TRANSACTION_EXPR_OUTER

#define TRANSACTION_EXPR_OUTER ( NODE ) (TRANSACTION_EXPR_CHECK (NODE)->base.static_flag)

Referenced by dump_generic_node(), and gimplify_transaction().

◆ TRANSACTION_EXPR_RELAXED

#define TRANSACTION_EXPR_RELAXED ( NODE ) (TRANSACTION_EXPR_CHECK (NODE)->base.public_flag)

Referenced by dump_generic_node(), and gimplify_transaction().

◆ TRANSLATION_UNIT_LANGUAGE

#define TRANSLATION_UNIT_LANGUAGE ( NODE ) (TRANSLATION_UNIT_DECL_CHECK (NODE)->translation_unit_decl.language)

The source language of the translation-unit.

Referenced by build_translation_unit_decl(), hash_tree(), is_cxx(), is_fortran(), pack_ts_translation_unit_decl_value_fields(), and unpack_ts_translation_unit_decl_value_fields().

◆ TRANSLATION_UNIT_WARN_EMPTY_P

#define TRANSLATION_UNIT_WARN_EMPTY_P ( NODE ) (TRANSLATION_UNIT_DECL_CHECK (NODE)->decl_common.decl_flag_0)

Nonzero if we should warn about the change in empty class parameter
passing ABI in this TU.

◆ TREE_ADDRESSABLE

#define TREE_ADDRESSABLE ( NODE ) ((NODE)->base.addressable_flag)

Define many boolean fields that all tree nodes have.

In VAR_DECL, PARM_DECL and RESULT_DECL nodes, nonzero means address
of this is needed.  So it cannot be in a register.
In a FUNCTION_DECL it has no meaning.
In LABEL_DECL nodes, it means a goto for this label has been seen
from a place outside all binding contours that restore stack levels.
In an artificial SSA_NAME that points to a stack partition with at least
two variables, it means that at least one variable has TREE_ADDRESSABLE.
In ..._TYPE nodes, it means that objects of this type must be fully
addressable.  This means that pieces of this object cannot go into
register parameters, for example.  If this a function type, this
means that the value must be returned in memory.
In CONSTRUCTOR nodes, it means object constructed must be in memory.
In IDENTIFIER_NODEs, this means that some extern decl for this name
had its address taken.  That matters for inline functions.
In a STMT_EXPR, it means we want the result of the enclosed expression.

Referenced by nontrapping_dom_walker::add_or_mark_expr(), add_stack_protection_conflicts(), aggregate_value_p(), asan_add_global(), asan_emit_stack_protection(), asan_protect_stack_decl(), assign_parms(), assign_parms_unsplit_complex(), assign_temp(), assumption_copy_decl(), avoid_type_punning_on_regs(), build_constant_desc(), build_var(), builtin_save_expr(), rt_bb_visited::check(), clear_addressable_bit(), cond_store_replacement(), convert_local_reference_op(), copy_decl_no_change(), copy_decl_to_var(), copy_result_decl_to_var(), copy_var_decl(), symtab_node::copy_visibility_from(), create_field_for_decl(), create_odr_indicator(), create_omp_child_function(), create_tmp_var(), create_tmp_var_for(), create_vop_var(), cgraph_node::create_wrapper(), declare_return_variable(), default_is_empty_record(), discover_nonconstant_array_refs_r(), dse_optimize_stmt(), dump_variable(), execute_update_addresses_taken(), expand_asm_stmt(), expand_assign_tm(), expand_call(), expand_constructor(), expand_debug_expr(), expand_debug_parm_decl(), expand_expr_real_1(), expand_expr_real_2(), expand_omp_build_assign(), expand_omp_for_generic(), expand_omp_for_init_vars(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), expand_omp_ordered_source_sink(), expand_omp_sections(), expand_omp_simd(), expand_omp_taskloop_for_inner(), expand_thunk(), extract_omp_for_update_vars(), finalize_must_preallocate(), finalize_nesting_tree_1(), gen_emutls_addr(), get_debug_decl(), get_frame_type(), get_nl_goto_field(), get_target_arguments(), gimple_add_tmp_var(), gimple_expand_vec_set_extract_expr(), gimple_fold_builtin_memory_op(), gimple_regimplify_operands(), gimplify_asm_expr(), gimplify_bind_expr(), gimplify_compound_literal_expr(), gimplify_cond_expr(), gimplify_decl_expr(), gimplify_init_constructor(), gimplify_init_ctor_preeval(), gimplify_init_ctor_preeval_1(), gimplify_modify_expr(), gimplify_modify_expr_rhs(), gimplify_omp_depend(), gimplify_parameters(), gimplify_scan_omp_clauses(), handle_rhs_call(), handle_simd_reference(), hash_tree(), immediate_const_ctor_p(), initialize_argument_information(), instrument_derefs(), instrument_object_size(), ipa_discover_variable_flags(), ipa_tm_create_version_alias(), is_asan_mark_p(), is_improper(), local_variable_can_escape(), lookup_field_for_decl(), lower_assumption(), lower_builtin_posix_memalign(), lower_depend_clauses(), lower_oacc_private_marker(), lower_omp_for_scan(), lower_omp_scan(), lower_omp_target(), lower_omp_task_reductions(), lower_omp_taskreg(), lower_rec_input_clauses(), lower_rec_simd_input_clauses(), symtab_node::make_decl_local(), mark_address_taken(), mark_addressable_1(), may_be_aliased(), maybe_add_sra_candidate(), maybe_build_inner_data_region(), maybe_instrument_pointer_overflow(), maybe_optimize_var(), maybe_rewrite_mem_ref_base(), ipa_icf::sem_variable::merge(), must_pass_in_stack_var_size(), must_pass_in_stack_var_size_or_pad(), needs_to_live_in_memory(), non_mem_decl_p(), oacc_privatization_candidate_p(), odr_types_equivalent_p(), omp_add_variable(), omp_copy_decl_2(), omp_oacc_kernels_decompose_1(), omp_resolve_clause_dependencies(), omp_shared_to_firstprivate_optimizable_decl_p(), ompdevlow_adjust_simt_enter(), optimize_compound_literals_in_ctor(), pack_ts_base_value_fields(), pass_by_reference(), precompute_arguments(), print_node(), reference_callee_copied(), remove_exit_barrier(), ipa_param_body_adjustments::reset_debug_stmts(), scan_sharing_clauses(), ipa_icf::set_addressable(), setup_one_parameter(), should_remove_lhs_p(), simd_clone_adjust(), simple_operand_p(), split_complex_args(), store_field(), suitable_for_tail_call_opt_p(), tm_log_add(), ubsan_encode_value(), unpack_ts_base_value_fields(), update_alias_info_with_stack_vars(), use_pointer_for_field(), use_register_for_decl(), vector_element(), verify_address(), verify_phi_args(), walk_regimplify_phi(), and walk_stmt_load_store_addr_ops().

◆ TREE_ASM_WRITTEN

#define TREE_ASM_WRITTEN ( NODE ) ((NODE)->base.asm_written_flag)

Nonzero in a VAR_DECL or STRING_CST means assembler code has been written.
Nonzero in a FUNCTION_DECL means that the function has been compiled.
This is interesting in an inline function, since it might not need
to be compiled separately.
Nonzero in a RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, ENUMERAL_TYPE
or TYPE_DECL if the debugging info for the type has been written.
In a BLOCK node, nonzero if reorder_blocks has already seen this block.
In an SSA_NAME node, nonzero if the SSA_NAME occurs in an abnormal
PHI node.

Referenced by add_string_csts(), all_blocks(), asan_emit_stack_protection(), asan_finish_file(), assemble_alias(), varpool_node::assemble_decl(), cgraph_node::assemble_thunks_and_aliases(), assemble_variable(), symtab_node::can_increase_alignment_p(), clear_block_marks(), copy_node(), count_string_csts(), cst_pool_loc_descr(), declare_inline_vars(), declare_weak(), do_assemble_alias(), symtab_node::dump_base(), dump_block_node(), execute_oacc_loop_designation(), cgraph_node::expand(), expand_thunk(), final_scan_insn_1(), final_start_function_1(), cgraph_node::finalize_function(), varpool_node::finalize_named_section_flags(), function_called_by_processed_nodes_p(), gen_field_die(), lookup_type_die(), lower_function_body(), lower_gimple_bind(), mark_constants_in_pattern(), mark_functions_to_output(), maybe_output_constant_def_contents(), ipa_icf::sem_variable::merge(), merge_weak(), output_constant_def_contents(), symbol_table::output_weakrefs(), pack_ts_base_value_fields(), print_node(), reference_to_unused(), cgraph_node::remove(), reorder_blocks_1(), cgraph_node::rtl_info(), unpack_ts_base_value_fields(), cgraph_node::verify_node(), and wrapup_global_declaration_2().

◆ TREE_BLOCK

#define TREE_BLOCK ( NODE ) (tree_block (NODE))

Referenced by clear_unused_block_pointer_1(), copy_tree_body_r(), DFS::DFS_write_tree_body(), gimple_build_call_from_tree(), gimplify_expr(), mark_all_vars_used_1(), move_stmt_op(), remap_gimple_op_r(), tree_inlined_location(), tree_nonartificial_location(), and write_ts_exp_tree_pointers().

◆ TREE_CHAIN

#define TREE_CHAIN ( NODE ) ((NODE)->common.chain)

Referenced by add_ehspec_entry(), alloc_object_size(), any_nonignored_attribute_p(), assemble_name_resolve(), assign_filter_values(), assign_parms_unsplit_complex(), attribute_list_contained(), attribute_value_equal(), bit_value_assume_aligned(), block_move_libcall_safe_for_call_parm(), build_adjusted_function_type(), build_builtin_expect_predicate(), build_constructor_from_list(), build_function_type_list_1(), build_method_type_directly(), ipa_param_adjustments::build_new_function_type(), build_tm_store(), build_tree_list_vec(), builtin_mathfn_code(), chain_index(), chainon(), symbol_table::change_decl_assembler_name(), rt_bb_visited::check(), check_fnspec(), check_unique_operand_names(), collect_one_action_chain(), comp_type_attributes(), ipa_icf_gimple::func_checker::compare_asm_inputs_outputs(), symbol_table::compile(), compute_fn_summary(), contains_placeholder_p(), copy_list(), copy_node(), copy_tree_r(), count_num_arguments(), create_omp_child_function(), cgraph_node::create_wrapper(), debug_find_var_in_block_tree(), debug_tree_chain(), decl_attributes(), decompose_kernels_region_body(), dequeue_and_dump(), DFS::DFS_write_tree_body(), diagnose_sb_0(), do_assemble_alias(), dump_block_node(), dump_function_declaration(), dump_function_to_file(), dump_generic_node(), dump_omp_clause(), dump_omp_context_selector(), dump_omp_iterators(), duplicate_one_attribute(), ipa_icf::sem_function::equals_wpa(), expand_call_inline(), expand_oacc_collapse_init(), expand_omp_atomic_store(), expand_omp_ordered_sink(), expand_omp_target(), expand_simd_clones(), field_at_offset(), find_param_by_name(), find_placeholder_in_expr(), finish_taskreg_scan(), first_field(), flatten_binds(), fndecl_alloc_p(), fndecl_dealloc_argno(), fold_builtin_atomic_compare_exchange(), ccp_folder::fold_stmt(), attr_access::free_lang_data(), function_args_iter_next(), function_attribute_inlinable_p(), function_to_dwarf_procedure(), gen_eh_region_allowed(), gen_eh_region_catch(), gen_generic_params_dies(), get_attr_str(), get_call_args(), get_nonnull_args(), get_parm_access(), get_target_clone_attr_len(), gimple_builtin_call_types_compatible_p(), gimple_call_alloc_size(), gimple_canonical_types_compatible_p(), gimplify_asm_expr(), gimplify_bind_expr(), gimplify_call_expr(), gimplify_init_ctor_preeval_1(), gimplify_omp_affinity(), gimplify_omp_depend(), gimplify_omp_for(), gimplify_omp_ordered(), gimplify_scan_omp_clauses(), globalize_decl(), go_format_type(), go_output_typedef(), strlen_pass::handle_builtin_strcat(), strlen_pass::handle_builtin_strcpy(), ehspec_hasher::hash(), operand_compare::hash_operand(), hash_tree(), infer_nonnull_range_by_attribute(), init_attr_rdwr_indices(), init_eh(), input_eh_region(), install_var_field(), instrument_builtin_call(), ipa_get_callee_param_type(), ipa_odr_summary_write(), last_field(), list_length(), loc_list_from_tree_1(), lookup_attribute_by_prefix(), lookup_ident_attribute(), lower_eh_dispatch(), lower_omp_ordered_clauses(), lto_input_eh_catch_list(), lto_input_ts_list_tree_pointers(), symtab_node::make_decl_local(), mark_transaction_restart_calls(), matching_alloc_calls_p(), maybe_build_inner_data_region(), maybe_canonicalize_argtypes(), maybe_warn_read_write_only(), merge_attributes(), merge_weak(), ipa_param_body_adjustments::modify_formal_parameters(), nonnull_arg_p(), nreverse(), oacc_do_neutering(), oacc_fn_attrib_level(), oacc_get_fn_dim_size(), oacc_replace_fn_attrib_attr(), oacc_validate_dims(), odr_or_derived_type_p(), odr_types_equivalent_p(), ok_for_auto_simd_clone(), omp_check_context_selector(), omp_construct_traits_to_codes(), omp_context_compute_score(), omp_context_selector_compare(), omp_context_selector_matches(), omp_context_selector_props_compare(), omp_context_selector_set_compare(), omp_discover_declare_target_tgt_fn_r(), omp_get_context_selector(), omp_get_context_selector_list(), omp_lto_input_declare_variant_alt(), omp_lto_output_declare_variant_alt(), omp_mark_declare_variant(), omp_resolve_declare_variant(), optimize_atomic_compare_exchange_p(), optimize_weakref(), parm_object_size(), prepare_call_arguments(), print_node(), private_lookup_attribute(), private_lookup_attribute(), process_pending_assemble_externals(), process_symver_attribute(), purpose_member(), push_function_arg_types(), rt_bb_visited::push_rtcfg_pair(), reconstruct_complex_type(), record_common_node(), record_type_list(), register_odr_type(), remove_attribute(), remove_attribute(), remove_attributes_matching(), remove_named_attribute_unsharing(), resolve_asm_operand_names(), resolve_operand_name_1(), restrict_type_identity_attributes_to(), rt_bb_visited::rt_bb_visited(), safe_from_p(), scan_omp_for(), set_strub_mode_to(), simd_clone_adjust_argument_types(), simple_cst_list_equal(), sorted_attr_string(), split_complex_types(), stack_protect_classify_type(), streamer_read_chain(), streamer_read_chain(), streamer_write_chain(), streamer_write_chain(), strub_set_fndt_mode_to(), substitute_in_expr(), substitute_placeholder_in_expr(), task_copyfn_remap_type(), tree_builtin_call_types_compatible_p(), tree_cons(), tree_function_versioning(), tree_last(), type_hash_canon_hash(), type_list_equal(), type_num_arguments(), ultimate_transparent_alias_target(), ultimate_transparent_alias_target(), useless_type_conversion_p(), value_member(), vect_build_one_gather_load_call(), vect_build_one_scatter_store_call(), verify_type(), verify_type_variant(), walk_tree_1(), walk_type_fields(), warn_types_mismatch(), weak_finish(), and write_ts_list_tree_pointers().

◆ TREE_CHECK

#define TREE_CHECK	(		T,
			CODE ) (T)

◆ TREE_CHECK2

#define TREE_CHECK2	(	T,
		CODE1,
		CODE2 ) (T)

◆ TREE_CHECK3

#define TREE_CHECK3	(	T,
		CODE1,
		CODE2,
		CODE3 ) (T)

◆ TREE_CHECK4

#define TREE_CHECK4	(	T,
		CODE1,
		CODE2,
		CODE3,
		CODE4 ) (T)

◆ TREE_CHECK5

#define TREE_CHECK5	(	T,
		CODE1,
		CODE2,
		CODE3,
		CODE4,
		CODE5 ) (T)

◆ TREE_CHECK6

#define TREE_CHECK6	(	T,
		CODE1,
		CODE2,
		CODE3,
		CODE4,
		CODE5,
		CODE6 ) (T)

◆ TREE_CLASS_CHECK

#define TREE_CLASS_CHECK	(		T,
			CODE ) (T)

◆ TREE_CLOBBER_P

#define TREE_CLOBBER_P ( NODE ) (TREE_CODE (NODE) == CONSTRUCTOR && TREE_THIS_VOLATILE (NODE))

True if NODE is a clobber right hand side, an expression of indeterminate
value that clobbers the LHS in a copy instruction.  We use a volatile
empty CONSTRUCTOR for this, as it matches most of the necessary semantic.
In particular the volatile flag causes us to not prematurely remove
such clobber instructions.

Referenced by const_with_all_bytes_same(), dump_generic_node(), expand_debug_expr(), expand_gimple_stmt_1(), find_func_aliases(), fold_gimple_assign(), gimple_clobber_p(), gimplify_modify_expr(), initialize_root_vars_store_elim_2(), initializer_zerop(), is_gimple_mem_rhs_or_call(), is_inv_store_elimination_chain(), ipa_icf_gimple::func_checker::operand_equal_p(), optimize_va_list_gpr_fpr_size(), vn_walk_cb_data::push_partial_def(), and replace_ref_with().

◆ TREE_CODE

#define TREE_CODE ( NODE ) ((enum tree_code) (NODE)->base.code)

Define accessors for the fields that all tree nodes have
(though some fields are not used for all kinds of nodes).

The tree-code says what kind of node it is.
Codes are defined in tree.def.

◆ TREE_CODE_CLASS

#define TREE_CODE_CLASS ( CODE ) tree_code_type_tmpl <0>::tree_code_type[(int) (CODE)]

Referenced by adjust_bool_pattern(), aff_combination_expand(), analyze_agg_content_value(), and_var_with_comparison_1(), arith_overflow_check_p(), build2(), build3(), build_and_record_new_cond(), build_nt(), build_vl_exp(), can_propagate_from(), ccmp_tree_comparison_p(), chain_of_csts_start(), check_bool_pattern(), check_retval_uses(), combine_cond_expr_cond(), compute_complex_assign_jump_func(), gori_compute::condexpr_adjust(), const_binop(), contains_placeholder_p(), convert_to_integer_1(), copy_if_shared_r(), copy_node(), copy_self_referential_tree_r(), copy_tree_r(), data_ref_compare_tree(), dequeue_and_dump(), edge_info::derive_equivalences(), dump_generic_node(), dump_unary_rhs(), edge_forwards_cmp_to_conditional_jump_through_empty_bb_p(), eliminate_redundant_comparison(), eval_subst(), expand_complex_operations_1(), expand_debug_expr(), expand_expr_real_1(), expand_gimple_cond(), expand_simple_operations(), expand_vec_cond_expr_p(), expand_vector_condition(), expand_vector_operation(), expand_vector_operations_1(), expression_expensive_p(), extract_muldiv_1(), extract_single_var_from_expr(), final_range_test_p(), find_deriving_biv_for_expr(), find_interesting_uses_stmt(), find_placeholder_in_expr(), fold(), fold_binary_loc(), fold_build3_loc(), fold_cond_expr_with_comparison(), fold_ignored_result(), fold_stmt_1(), fold_ternary_loc(), fold_truth_andor_1(), fold_truth_not_expr(), fold_unary_loc(), forward_propagate_into_comparison_1(), forward_propagate_into_gimple_cond(), fully_constant_vn_reference_p(), scalar_cond_masked_key::get_cond_ops_from_tree(), get_constraint_for_1(), get_def_for_expr_class(), operands_scanner::get_expr_operands(), get_expr_type(), get_stats_node_kind(), gimple_build_cond(), gimple_cond_get_ops_from_tree(), gimple_could_trap_p_1(), gimple_expand_vec_cond_expr(), gimple_fold_stmt_to_constant_1(), gimple_omp_for_set_cond(), gimple_resimplify1(), gimple_resimplify2(), gimple_resimplify3(), gimple_simplify(), gimple_simplify(), gimplify_expr(), goa_stabilize_expr(), operand_compare::hash_operand(), ifcombine_ifandif(), integer_valued_real_p(), interpret_rhs_expr(), ipa_get_jf_arith_result(), ipa_read_jump_function(), ipa_value_range_from_jfunc(), ipa_write_jump_function(), is_degenerate_phi(), is_feasible_trace(), lower_lastprivate_clauses(), lto_is_streamable(), make_node(), make_range(), mark_all_vars_used_1(), maybe_fold_comparisons_from_match_pd(), maybe_optimize_range_tests(), ipcp_bits_lattice::meet_with(), merge_truthop_with_opposite_arm(), mostly_copy_tree_r(), predicate::normalize(), predicate::normalize(), operand_compare::operand_equal_p(), operation_could_trap_p(), optimize_atomic_bit_test_and(), optimize_atomic_op_fetch_cmp_0(), optimize_bitfield_assignment_op(), or_var_with_comparison_1(), ovce_extract_ops(), parloops_is_simple_reduction(), parse_predicate(), possible_vector_mask_operation_p(), pred_equal_p(), predicate_bbs(), print_node(), print_node_brief(), print_vn_reference_ops(), propagate_bias_p(), propagate_vr_across_jump_function(), range_binop(), recalculate_side_effects(), replace_stmt_with_simplification(), safe_from_p(), same_bool_comparison_p(), simple_condition_p(), simple_cst_equal(), simplify_using_ranges::simplify(), simplify_using_ranges::simplify_compare_assign_using_ranges_1(), jump_threader::simplify_control_stmt_condition_1(), stabilize_reference_1(), stmt_cost(), stmt_could_throw_1_p(), substitute_in_expr(), substitute_placeholder_in_expr(), tree_block(), tree_code_size(), tree_could_trap_p(), tree_expr_nonnegative_warnv_p(), tree_expr_nonzero_warnv_p(), tree_node_structure_for_code(), tree_size(), truth_value_p(), twoval_comparison_p(), update_jump_functions_after_inlining(), valid_gimple_rhs_p(), value_replacement(), vect_build_slp_tree_1(), vect_comparison_type(), vect_determine_mask_precision(), vect_get_operand_map(), vect_mark_stmts_to_be_vectorized(), vect_recog_mask_conversion_pattern(), vector_compare_rtx(), vectorizable_comparison_1(), vectorizable_condition(), vectorizable_load(), vectorizable_operation(), verify_gimple_cond(), vn_get_stmt_kind(), vn_nary_may_trap(), vn_nary_op_compute_hash(), vn_nary_op_insert_pieces_predicated(), walk_tree_1(), and zero_one_minusone().

◆ TREE_CODE_CLASS_STRING

#define TREE_CODE_CLASS_STRING ( CLASS ) tree_code_class_strings[(int) (CLASS)]

Returns the string representing CLASS.

◆ TREE_CODE_LENGTH

◆ TREE_CONSTANT

#define TREE_CONSTANT ( NODE ) (NON_TYPE_CHECK (NODE)->base.constant_flag)

Value of expression is constant.  Always on in all ..._CST nodes.  May
also appear in an expression or decl where the value is constant.

Referenced by addr_object_size(), autofdo::afdo_propagate_circuit(), asan_add_global(), asan_finish_file(), assign_parms_augmented_arg_list(), build2(), build_new_poly_int_cst(), tree_switch_conversion::switch_conversion::build_one_array(), build_string(), build_string_literal(), categorize_decl_for_section(), constructor_static_from_elts_p(), copy_tree_body_r(), create_odr_indicator(), default_select_section(), detach_value(), evaluate_control_stmt_using_entry_checks(), expand_constructor(), expand_expr_real_2(), expr_expected_value(), expr_expected_value_1(), finalize_record_size(), finish_taskreg_scan(), fixup_remapped_decl(), fold_binary_loc(), fold_binary_op_with_conditional_arg(), fold_binary_to_constant(), fold_builtin_constant_p(), fold_builtin_expect(), fold_comparison(), fold_unary_loc(), fold_unary_to_constant(), gimplify_init_constructor(), gimplify_init_ctor_preeval(), gimplify_modify_expr_complex_part(), handle_simd_reference(), hash_tree(), immediate_const_ctor_p(), initializer_constant_valid_p_1(), is_variable_sized(), lower_oacc_reductions(), lower_omp_target(), lower_rec_input_clauses(), make_int_cst(), make_node(), make_vector(), omp_extract_for_data(), omp_finish_file(), omp_task_reduction_iterate(), operand_compare::operand_equal_p(), operation_could_trap_helper_p(), pack_ts_base_value_fields(), place_field(), predict_extra_loop_exits(), print_node(), really_constant_p(), recompute_constructor_flags(), recompute_tree_invariant_for_addr_expr(), remap_gimple_stmt(), return_prediction(), rtl_for_decl_init(), skip_simple_constant_arithmetic(), split_tree(), staticp(), tree_invariant_p_1(), tree_swap_operands_p(), ubsan_create_data(), ubsan_source_location(), ubsan_type_descriptor(), unpack_ts_base_value_fields(), variable_size(), verify_address(), verify_constructor_flags(), and verify_gimple_assign_ternary().

◆ tree_decl_map_eq

#define tree_decl_map_eq tree_map_base_eq

Referenced by tree_decl_map_cache_hasher::equal().

◆ tree_decl_map_marked_p

#define tree_decl_map_marked_p tree_map_base_marked_p

◆ TREE_DEPRECATED

#define TREE_DEPRECATED ( NODE ) ((NODE)->base.deprecated_flag)

Nonzero in a _DECL if the use of the name is defined as a
deprecated feature by __attribute__((deprecated)).

Referenced by decls_mismatched_attributes(), hash_tree(), pack_ts_base_value_fields(), print_node(), and unpack_ts_base_value_fields().

◆ TREE_FIXED_CST

◆ TREE_FIXED_CST_PTR

#define TREE_FIXED_CST_PTR ( NODE ) (FIXED_CST_CHECK (NODE)->fixed_cst.fixed_cst_ptr)

Referenced by build_fixed(), const_hash_1(), dequeue_and_dump(), dump_generic_node(), fold_relational_const(), operand_compare::hash_operand(), and unpack_ts_fixed_cst_value_fields().

◆ TREE_HASH

#define TREE_HASH ( NODE ) ((size_t) (NODE) & 0777777)

A simple hash function for an arbitrary tree node.  This must not be
used in hash tables which are saved to a PCH.

Referenced by add_ttypes_entry(), ttypes_filter_hasher::hash(), ehspec_hasher::hash(), and tree_hash::hash().

◆ TREE_IMAGPART

#define TREE_IMAGPART ( NODE ) (COMPLEX_CST_CHECK (NODE)->complex.imag)

Referenced by adjust_imagpart_expr(), build_complex(), categorize_ctor_elements_1(), compare_constant(), const_binop(), const_hash_1(), const_unop(), const_with_all_bytes_same(), DFS::DFS_write_tree_body(), do_mpc_arg2(), drop_tree_overflow(), dump_generic_node(), ipa_icf::sem_variable::equals(), expand_debug_expr(), expand_expr_real_1(), extract_component(), find_lattice_value(), fold_binary_loc(), fold_const_call_1(), fold_const_call_1(), fold_mult_zconjz(), fold_negate_expr_1(), fold_relational_const(), operand_compare::hash_operand(), hash_tree(), initializer_zerop(), integer_all_onesp(), integer_each_onep(), integer_minus_onep(), integer_nonzerop(), integer_onep(), integer_pow2p(), integer_zerop(), lto_input_ts_complex_tree_pointers(), maybe_trim_complex_store(), native_encode_complex(), negate_expr_p(), operand_compare::operand_equal_p(), output_constant(), print_node(), read_complex_part(), real_maybe_zerop(), real_minus_onep(), real_onep(), real_zerop(), tree_expr_finite_p(), valid_lattice_transition(), walk_tree_1(), and write_ts_complex_tree_pointers().

◆ TREE_INT_CST_ELT

◆ TREE_INT_CST_ELT_CHECK

#define TREE_INT_CST_ELT_CHECK	(		T,
			I ) ((T)->int_cst.val[I])

◆ TREE_INT_CST_EXT_NUNITS

#define TREE_INT_CST_EXT_NUNITS ( NODE ) (INTEGER_CST_CHECK (NODE)->base.u.int_length.extended)

Referenced by int_cst_hasher::equal(), wi::extended_tree< N >::get_len(), operand_compare::hash_operand(), make_int_cst(), output_constant(), pack_ts_int_cst_value_fields(), streamer_write_tree_header(), tree_size(), unpack_ts_int_cst_value_fields(), and wide_int_to_tree_1().

◆ TREE_INT_CST_LOW

#define TREE_INT_CST_LOW ( NODE ) ((unsigned HOST_WIDE_INT) TREE_INT_CST_ELT (NODE, 0))

Referenced by alloc_object_size(), analyze_ref(), apply_binop_and_append_stmt(), build_vector_type_for_mode(), ccp_finalize(), collect_one_action_chain(), compare_tree_int(), copy_reference_ops_from_ref(), decode_addr_const(), decrement_count(), decrement_power(), default_goacc_reduction(), edge_info::derive_equivalences(), do_jump(), dr_alignment(), dr_analyze_innermost(), dr_misalignment(), dump_generic_node(), dump_gimple_call(), dump_oacc_loop_part(), eliminate_dom_walker::eliminate_stmt(), emit_warn_switch_unreachable(), evaluate_stmt(), execute_early_expand_coro_ifns(), execute_oacc_device_lower(), execute_omp_oacc_neuter_broadcast(), cgraph_node::expand(), expand_block_edges(), expand_builtin_alloca(), expand_builtin_goacc_parlevel_id_size(), expand_DEFERRED_INIT(), expand_expr_real_1(), expand_expr_real_2(), expand_omp_target(), expand_UNIQUE(), expand_vector_divmod(), find_gang_private_vars(), fndecl_dealloc_argno(), fold_builtin_alloca_with_align(), cfn_goacc_dim::fold_range(), fold_read_from_constant_string(), ccp_folder::fold_stmt(), get_addr_base_and_unit_offset_1(), get_misalign_in_elems(), get_negative_load_store_type(), get_nonnull_args(), get_object_alignment_2(), get_pointer_alignment_1(), gimple_boolify(), gimple_call_alloc_size(), gimple_compare_field_offset(), gimple_fold_builtin_clear_padding(), gimple_fold_builtin_memset(), go_format_type(), handle_printf_call(), infer_nonnull_range_by_attribute(), int_cst_value(), int_size_in_bytes(), is_combined_permutation_identity(), locate_and_pad_parm(), lower_builtin_assume_aligned(), lower_coro_builtin(), lower_vec_perm(), make_fancy_name_1(), neuter_worker_single(), new_oacc_loop(), oacc_get_fn_dim_size(), oacc_get_ifn_dim_arg(), oacc_loop_discover_walk(), oacc_loop_xform_head_tail(), oacc_validate_dims(), oacc_xform_loop(), omp_sese_find_par(), omp_sese_split_blocks(), optimize_vector_load(), pad_below(), place_field(), vn_walk_cb_data::push_partial_def(), simd_clone_clauses_extract(), simplify_bitfield_ref(), simplify_permutation(), simplify_vector_constructor(), target_char_cast(), tree_call_nonnegative_warnv_p(), tree_to_shwi(), tree_to_uhwi(), vect_analyze_data_ref_access(), vect_analyze_data_ref_accesses(), vect_analyze_group_access_1(), vect_can_peel_nonlinear_iv_p(), vect_create_cond_for_align_checks(), vect_describe_gather_scatter_call(), vect_determine_precisions_from_users(), vect_dissolve_slp_only_groups(), vect_dr_misalign_for_aligned_access(), vect_enhance_data_refs_alignment(), vect_get_peeling_costs_all_drs(), vect_get_smallest_scalar_type(), vect_joust_widened_integer(), vect_peel_nonlinear_iv_init(), vect_peeling_supportable(), vect_recog_divmod_pattern(), vect_supportable_dr_alignment(), vect_update_misalignment_for_peel(), vector_element(), vn_reference_eq(), vn_reference_lookup_3(), and write_symbol().

◆ TREE_INT_CST_NUNITS

#define TREE_INT_CST_NUNITS ( NODE ) (INTEGER_CST_CHECK (NODE)->base.u.int_length.unextended)

Define additional fields and accessors for nodes representing constants.

Referenced by const_hash_1(), int_cst_hasher::equal(), fold_convert_const_fixed_from_int(), wi::unextended_tree::get_len(), wi::extended_tree< N >::get_len(), int_cst_hasher::hash(), make_int_cst(), streamer_write_integer_cst(), streamer_write_tree_header(), wi::to_wide(), type_hash_canon_hash(), and wide_int_to_tree_1().

◆ tree_int_map_eq

#define tree_int_map_eq tree_map_base_eq

◆ tree_int_map_hash

#define tree_int_map_hash tree_map_base_hash

◆ tree_int_map_marked_p

#define tree_int_map_marked_p tree_map_base_marked_p

◆ TREE_LANG_FLAG_0

#define TREE_LANG_FLAG_0 ( NODE ) (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_0)

These flags are available for each language front end to use internally.

Referenced by print_node().

◆ TREE_LANG_FLAG_1

#define TREE_LANG_FLAG_1 ( NODE ) (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_1)

Referenced by print_node().

◆ TREE_LANG_FLAG_2

#define TREE_LANG_FLAG_2 ( NODE ) (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_2)

Referenced by print_node().

◆ TREE_LANG_FLAG_3

#define TREE_LANG_FLAG_3 ( NODE ) (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_3)

Referenced by print_node().

◆ TREE_LANG_FLAG_4

#define TREE_LANG_FLAG_4 ( NODE ) (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_4)

Referenced by print_node().

◆ TREE_LANG_FLAG_5

#define TREE_LANG_FLAG_5 ( NODE ) (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_5)

Referenced by print_node().

◆ TREE_LANG_FLAG_6

#define TREE_LANG_FLAG_6 ( NODE ) (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_6)

Referenced by print_node().

◆ tree_map_eq

#define tree_map_eq tree_map_base_eq

Referenced by tm_clone_hasher::equal(), and move_sese_region_to_fn().

◆ tree_map_marked_p

#define tree_map_marked_p tree_map_base_marked_p

◆ TREE_NO_TRAMPOLINE

#define TREE_NO_TRAMPOLINE ( NODE ) (ADDR_EXPR_CHECK (NODE)->base.static_flag)

In an ADDR_EXPR, nonzero means do not use a trampoline.

Referenced by build_instrumentation_call(), convert_tramp_reference_op(), and initializer_constant_valid_p_1().

◆ TREE_NO_WARNING

#define TREE_NO_WARNING ( NODE ) ((NODE)->base.nowarning_flag)

In an expr node (usually a conversion) this means the node was made
implicitly and should not lead to any sort of warning.  In a decl node,
warnings concerning the decl should be suppressed.  This is used at
least for used-before-set warnings, and it set after one warning is
emitted.

Referenced by hash_tree(), pack_ts_base_value_fields(), and unpack_ts_base_value_fields().

◆ TREE_NOT_CHECK

#define TREE_NOT_CHECK	(		T,
			CODE ) (T)

◆ TREE_NOT_CHECK2

#define TREE_NOT_CHECK2	(	T,
		CODE1,
		CODE2 ) (T)

◆ TREE_NOT_CHECK3

#define TREE_NOT_CHECK3	(	T,
		CODE1,
		CODE2,
		CODE3 ) (T)

◆ TREE_NOT_CHECK4

#define TREE_NOT_CHECK4	(	T,
		CODE1,
		CODE2,
		CODE3,
		CODE4 ) (T)

◆ TREE_NOT_CHECK5

#define TREE_NOT_CHECK5	(	T,
		CODE1,
		CODE2,
		CODE3,
		CODE4,
		CODE5 ) (T)

◆ TREE_NOT_CHECK6

#define TREE_NOT_CHECK6	(	T,
		CODE1,
		CODE2,
		CODE3,
		CODE4,
		CODE5,
		CODE6 ) (T)

◆ TREE_NOTHROW

#define TREE_NOTHROW ( NODE ) ((NODE)->base.nothrow_flag)

In a FUNCTION_DECL, nonzero means a call to the function cannot
throw an exception.  In a CALL_EXPR, nonzero means the call cannot
throw.  We can't easily check the node type here as the C++
frontend also uses this flag (for AGGR_INIT_EXPR).

Referenced by cgraph_node::analyze(), analyze_function(), build_fn_decl(), build_info(), cgraph_node::create_wrapper(), default_external_stack_protect_fail(), default_hidden_stack_protect_fail(), expand_builtin_fork_or_exec(), expand_call(), expand_call_stmt(), flags_from_decl_or_type(), gimple_build_call_from_tree(), gimple_call_nonnull_result_p(), gimple_init_gcov_profiler(), gimplify_call_expr(), gimplify_modify_expr(), gsi_insert_finally_seq_after_call(), has_attribute(), hash_tree(), ignore_edge_for_nothrow(), cgraph_edge::make_speculative(), optimize_omp_library_calls(), pack_ts_base_value_fields(), print_node(), propagate_nothrow(), rt_bb_visited::rt_bb_visited(), self_referential_size(), set_call_expr_flags(), set_nothrow_flag_1(), set_nothrow_function_flags(), tm_malloc_replacement(), tree_expr_nonzero_warnv_p(), unpack_ts_base_value_fields(), and weak_finish().

◆ TREE_OPERAND

#define TREE_OPERAND	(		NODE,
			I ) TREE_OPERAND_CHECK (NODE, I)

Referenced by access_fn_component_p(), access_fn_components_comparable_p(), add_decls_addresses_to_decl_constructor(), add_iv_candidate_for_use(), add_scope_conflicts_2(), add_to_predicate_list(), add_type_duplicate(), add_var_loc_to_decl(), addr_object_size(), address_compare(), adjacent_dr_p(), adjust_imagpart_expr(), adjust_offset_for_component_ref(), adjust_offsets_for_equal_base_address(), adjust_realpart_expr(), adjust_references_in_caller(), aff_combination_expand(), aliasing_component_refs_p(), aliasing_component_refs_walk(), alloc_iv(), analyze_access_subtree(), analyze_function_body(), analyze_ref(), ao_ref_base_alias_ptr_type(), ao_ref_base_alias_set(), ao_ref_from_mem(), ao_ref_init_from_ptr_and_range(), ao_ref_init_from_vn_reference(), arith_overflow_check_p(), array_ref_element_size(), array_ref_flexible_size_p(), array_ref_low_bound(), array_ref_up_bound(), array_size_for_constructor(), asan_expand_mark_ifn(), assemble_asm(), associate_trees(), backtrace_base_for_ref(), ipcp_modif_dom_walker::before_dom_children(), bit_field_offset(), bit_field_size(), bitfields_to_lower_p(), bitwise_inverted_equal_p(), block_may_fallthru(), build2(), build_access_from_call_arg(), build_access_from_expr_1(), build_debug_ref_for_model(), build_fold_addr_expr_with_type_loc(), build_nt(), build_outer_var_ref(), build_reconstructed_reference(), build_ref_for_model(), build_ref_for_offset(), build_simple_mem_ref_loc(), builtin_setjmp_setup_bb(), byte_from_pos(), c_strlen(), call_may_clobber_ref_p_1(), cand_value_at(), canonicalize_addr_expr(), canonicalize_base_object_address(), canonicalize_bool(), canonicalize_component_ref(), canonicalize_cond_expr_cond(), canonicalize_constructor_val(), categorize_ctor_elements_1(), cheap_array_ref_low_bound(), array_bounds_checker::check_addr_expr(), check_all_va_list_escapes(), array_bounds_checker::check_array_ref(), gimple_infer_range::check_assume_func(), check_loadstore(), check_loadstore(), check_out_of_bounds_and_warn(), check_scan_store(), check_stmt_for_type_change(), check_va_list_escapes(), chrec_apply(), chrec_contains_symbols(), chrec_contains_symbols_defined_in_loop(), chrec_contains_undetermined(), chrec_convert_1(), chrec_fold_multiply(), chrec_fold_plus_1(), cleanup_control_flow_bb(), collect_object_sizes_for(), ao_compare::compare_ao_refs(), compare_constant(), component_ref_field_offset(), component_ref_sam_type(), component_ref_size(), component_ref_to_zero_sized_trailing_array_p(), component_uses_parent_alias_set_from(), compute_access_stride(), compute_complex_ancestor_jump_func(), compute_complex_assign_jump_func(), compute_object_offset(), compute_objsize_r(), compute_reloc_for_constant(), cond_store_replacement(), const_hash_1(), constant_after_peeling(), constant_byte_string(), constant_for_folding(), constant_multiple_of(), constant_pointer_difference(), contain_complex_addr_expr(), contains_bitfld_component_ref_p(), contains_placeholder_p(), contains_vce_or_bfcref_p(), contains_view_convert_expr_p(), convert_local_omp_clauses(), convert_local_reference_op(), convert_nonlocal_omp_clauses(), convert_nonlocal_reference_op(), convert_to_complex_1(), convert_to_integer_1(), convert_to_real_1(), convert_tramp_reference_op(), copy_ref_info(), copy_reference_ops_from_ref(), copy_self_referential_tree_r(), copy_tree_body_r(), strlen_pass::count_nonzero_bytes(), strlen_pass::count_nonzero_bytes_addr(), create_access_replacement(), create_component_ref_by_pieces_1(), create_iv(), create_specialized_node(), create_task_copyfn(), cgraph_node::create_virtual_clone(), data_ref_compare_tree(), decl_for_component_ref(), decode_addr_const(), decode_field_reference(), default_ref_may_alias_errno(), dequeue_and_dump(), derive_simple_iv_with_niters(), detect_type_change(), determine_base_object_1(), determine_common_wider_type(), determine_known_aggregate_parts(), DFS::DFS_write_tree_body(), diagnose_tm_1(), difference_cannot_overflow_p(), discover_nonconstant_array_refs_r(), distinctify_node_type(), do_jump(), do_niy(), do_warn_nonnull_compare(), dr_analyze_alias(), dr_analyze_indices(), dr_analyze_innermost(), dr_equal_offsets_p1(), dr_may_alias_p(), dr_step_indicator(), dump_function_name(), dump_generic_node(), dump_gimple_call(), dump_mem_address(), dump_mem_ref(), duplicate_insn_chain(), eliminate_dom_walker::eliminate_insert(), eliminate_local_variables_1(), eliminate_dom_walker::eliminate_stmt(), eliminated_by_inlining_prob(), ends_tbaa_access_path_p(), eq_evolutions_p(), mem_ref_hasher::equal(), ipa_icf::sem_variable::equals(), eval_subst(), evaluate_control_stmt_using_entry_checks(), evolution_function_is_invariant_rec_p(), evolution_function_right_is_integer_cst(), execute_early_expand_coro_ifns(), execute_oacc_device_lower(), execute_omp_device_lower(), execute_omp_oacc_neuter_broadcast(), execute_update_addresses_taken(), expand_asm_stmt(), expand_assignment(), expand_builtin(), expand_builtin_atomic_fetch_op(), expand_builtin_init_trampoline(), expand_call_mem_ref(), expand_complex_operations_1(), expand_cond_expr_using_cmove(), expand_debug_expr(), expand_DEFERRED_INIT(), expand_expr_addr_expr(), expand_expr_addr_expr_1(), expand_expr_real_1(), expand_expr_real_2(), expand_function_start(), expand_omp_atomic_cas(), expand_omp_atomic_mutex(), expand_omp_ordered_sink(), expand_omp_target(), expand_omp_taskreg(), expand_return(), expand_simple_operations(), expand_vec_cmp_expr(), expr_expected_value_1(), expr_first(), expr_invariant_in_loop_p(), expr_last(), expr_object_size(), expr_size(), expr_to_aff_combination(), expr_with_var_bounded_array_refs_p(), expression_expensive_p(), extr_type_from_vtbl_ptr_store(), extract_bit_test_mask(), extract_component(), extract_mem_content(), extract_muldiv_1(), extract_object_class_type(), extract_ops_from_tree(), extract_single_var_from_expr(), factor_out_conditional_operation(), find_constructor_constant_at_offset(), find_deriving_biv_for_expr(), find_equal_ptrs(), find_func_aliases_for_builtin_call(), find_func_clobbers(), find_gang_private_vars(), find_interesting_uses_address(), find_placeholder_in_expr(), find_reduc_addr(), find_single_drs(), find_taken_edge(), finish_bitfield_representative(), fixup_vla_decls(), fold(), fold_addr_of_array_ref_difference(), fold_array_ctor_reference(), fold_binary_loc(), fold_binary_op_with_conditional_arg(), fold_build_cleanup_point_expr(), fold_build_cond_expr(), fold_builtin_atomic_always_lock_free(), fold_builtin_atomic_compare_exchange(), fold_builtin_call_array(), fold_builtin_constant_p(), fold_builtin_expect(), fold_builtin_next_arg(), fold_call_stmt(), fold_comparison(), fold_cond_expr_with_comparison(), fold_const_aggregate_ref_1(), fold_convert_loc(), fold_gimple_assign(), fold_ignored_result(), fold_indirect_ref_1(), fold_indirect_ref_loc(), fold_mult_zconjz(), fold_negate_expr_1(), fold_plusminus_mult_expr(), fold_read_from_constant_string(), ccp_folder::fold_stmt(), fold_stmt_1(), fold_strstr_to_strncmp(), fold_ternary_loc(), fold_to_nonsharp_ineq_using_bound(), fold_truth_andor(), fold_truth_andor_1(), fold_truth_not_expr(), fold_unary_loc(), scev_dfs::follow_ssa_edge_expr(), for_each_index(), for_each_scev_op(), force_expr_to_var_cost(), force_move_till(), forward_propagate_addr_expr_1(), forward_propagate_into_comparison_1(), fully_constant_vn_reference_p(), function_to_dwarf_procedure(), gather_mem_refs_stmt(), gen_lsm_tmp_name(), gen_phi_arg_condition(), generic_expr_could_trap_p(), get_access_for_expr(), get_addr_base_and_unit_offset_1(), get_ancestor_addr_info(), get_array_ctor_element_at_index(), get_attr_nonstring_decl(), get_base_address(), get_base_constructor(), get_base_decl(), get_base_for_alignment(), get_base_loadstore(), get_base_value(), get_base_var(), get_bit_range(), get_bitfield_rep(), get_callee_fndecl(), get_computation_aff_1(), scalar_cond_masked_key::get_cond_ops_from_tree(), get_constraint_for_1(), get_constraint_for_component_ref(), ipa_polymorphic_call_context::get_dynamic_type(), operands_scanner::get_expr_operands(), get_inner_reference(), get_mem_align_offset(), operands_scanner::get_mem_ref_operands(), get_memory_rtx(), get_min_precision(), get_name(), get_narrower(), get_object_alignment_1(), get_object_alignment_2(), get_offset_range(), get_pointer_alignment_1(), get_range_pos_neg(), get_range_strlen_dynamic(), get_range_strlen_tree(), get_ref_base_and_extent(), get_ref_size(), get_shiftadd_cost(), get_single_symbol(), get_stridx(), get_stridx_plus_constant(), range_query::get_tree_range(), get_unwidened(), get_up_bounds_for_array_ref(), gimple_add_padding_init_for_auto_var(), gimple_assign_load_p(), gimple_boolify(), gimple_call_addr_fndecl(), gimple_duplicate_bb(), gimple_expand_vec_set_extract_expr(), gimple_extract(), gimple_fold_builtin_memory_op(), gimple_fold_builtin_memset(), gimple_fold_indirect_ref(), gimple_fold_stmt_to_constant_1(), gimple_get_virt_method_for_vtable(), gimple_lower_bitint(), gimple_range_base_of_assignment(), gimple_simplify(), gimplify_addr_expr(), gimplify_adjust_omp_clauses(), gimplify_adjust_omp_clauses_1(), gimplify_asm_expr(), gimplify_bind_expr(), gimplify_cleanup_point_expr(), gimplify_compound_expr(), gimplify_compound_lval(), gimplify_cond_expr(), gimplify_conversion(), gimplify_exit_expr(), gimplify_expr(), gimplify_init_constructor(), gimplify_init_ctor_eval(), gimplify_modify_expr(), gimplify_modify_expr_complex_part(), gimplify_modify_expr_rhs(), gimplify_modify_expr_to_memcpy(), gimplify_modify_expr_to_memset(), gimplify_oacc_declare(), gimplify_omp_affinity(), gimplify_omp_atomic(), gimplify_omp_depend(), gimplify_omp_for(), gimplify_omp_loop(), gimplify_return_expr(), gimplify_save_expr(), gimplify_scalar_mode_aggregate_compare(), gimplify_scan_omp_clauses(), gimplify_self_mod_expr(), gimplify_target_expr(), gimplify_va_arg_expr(), gimplify_variable_sized_compare(), goa_lhs_expr_p(), goa_stabilize_expr(), handle_array_ref(), strlen_pass::handle_assign(), handle_component_ref(), strlen_pass::handle_integral_assign(), handle_mem_ref(), strlen_pass::handle_store(), tm_memop_hasher::hash(), ao_compare::hash_ao_ref(), operand_compare::hash_operand(), hash_tree(), hoist_adjacent_loads(), idx_analyze_ref(), idx_record_use(), if_convertible_loop_p_1(), in_array_bounds_p(), inbounds_memaccess_p(), indirect_ref_may_alias_decl_p(), indirect_refs_may_alias_p(), access_ref::inform_access(), init_dont_simulate_again(), init_vn_nary_op_from_stmt(), initialize_data_dependence_relation(), initialize_expr_from_cond(), initialize_matrix_A(), initializer_constant_valid_for_bitfield_p(), initializer_constant_valid_p_1(), initializer_zerop(), input_gimple_stmt(), instantiate_scev_r(), instrument_derefs(), instrument_expr(), instrument_mem_ref(), instrument_null(), instrument_object_size(), int_expr_size(), integer_valued_real_invalid_p(), integer_valued_real_p(), integer_valued_real_single_p(), interpret_rhs_expr(), inverse_conditions_p(), ipa_analyze_virtual_call_uses(), ipa_find_agg_cst_from_init(), ipa_get_indirect_edge_target_1(), ipa_get_stmt_member_ptr_load_param(), ipa_load_from_parm_agg(), ipa_make_edge_direct_to_target(), ipa_polymorphic_call_context::ipa_polymorphic_call_context(), ipa_print_constant_value(), ipa_pta_execute(), ipa_set_jf_constant(), ipa_simd_modify_stmt_ops(), ipa_tm_insert_gettmclone_call(), ipa_tm_scan_irr_block(), ipa_write_jump_function(), is_addr_local(), is_aligning_offset(), is_asan_mark_p(), is_gimple_address(), is_gimple_condexpr_1(), is_gimple_invariant_address(), is_gimple_ip_invariant_address(), is_gimple_mem_ref_addr(), is_oacc_declared(), is_removable_cxa_atexit_call(), is_tm_irrevocable(), is_vptr_store(), is_vtable_assignment_stmt(), isra_get_ref_base_and_offset(), iv_elimination_compare_lt(), jump_function_from_stmt(), load_from_dereferenced_name(), load_from_unmodified_param_or_agg(), load_or_store_of_ptr_parameter(), loc_list_for_address_of_addr_expr_of_indirect_ref(), loc_list_from_tree_1(), local_var_based_p(), lower_coro_builtin(), lower_emutls_1(), lower_lastprivate_clauses(), lower_omp_1(), lower_omp_for(), lower_omp_scan(), lower_omp_target(), lower_omp_task_reductions(), lower_rec_input_clauses(), lower_reduction_clauses(), lower_send_clauses(), lower_stmt(), lto_input_ts_exp_tree_pointers(), make_bit_field_ref(), make_fancy_name_1(), make_range(), mark_addressable(), mark_nonssa_use(), match_uaddc_usubc(), may_be_nonaddressable_p(), may_move_till(), maybe_canonicalize_comparison_1(), maybe_canonicalize_mem_ref_addr(), maybe_dead_abnormal_edge_p(), maybe_diag_stxncpy_trunc(), maybe_fold_reference(), maybe_fold_tmr(), maybe_inline_call_in_expr(), maybe_instrument_pointer_overflow(), maybe_make_indirect(), maybe_optimize_arith_overflow(), maybe_optimize_ubsan_ptr_ifn(), maybe_push_res_to_seq(), maybe_rewrite_mem_ref_base(), maybe_set_dependence_info(), maybe_set_strlen_range(), maybe_warn_nonstring_arg(), maybe_warn_operand(), mem_ref_offset(), mem_ref_refers_to_non_mem_p(), merge_truthop_with_opposite_arm(), ipa_param_adjustments::modify_call(), ipa_param_body_adjustments::modify_expression(), move_fixed_address_to_symbol(), multiple_of_p(), narrowing_initializer_constant_valid_p(), native_encode_initializer(), negate_expr_p(), new_stridx(), non_null_loadstore(), non_rewritable_lvalue_p(), non_rewritable_mem_ref_base(), noncall_stmt_may_be_vtbl_ptr_store(), nonoverlapping_array_refs_p(), nonoverlapping_component_refs_p(), nonoverlapping_refs_since_match_p(), number_of_iterations_until_wrap(), oacc_entry_exit_ok_1(), oacc_resolve_clause_dependencies(), oacc_rewrite_var_decl(), object_address_invariant_in_loop_p(), object_sizes_get(), omp_accumulate_sibling_list(), omp_add_variable(), omp_build_struct_sibling_lists(), omp_containing_struct(), omp_discover_declare_target_tgt_fn_r(), omp_extract_for_data(), omp_find_stores_op(), omp_finish_file(), omp_get_base_pointer(), omp_get_for_step_from_incr(), omp_index_mapping_groups_1(), omp_mapped_by_containing_struct(), omp_member_access_dummy_var(), omp_notice_variable(), omp_addr_tokenizer::omp_parse_access_method(), omp_addr_tokenizer::omp_parse_component_selector(), omp_addr_tokenizer::omp_parse_pointer(), omp_addr_tokenizer::omp_parse_ref(), omp_addr_tokenizer::omp_parse_structured_expr(), omp_resolve_clause_dependencies(), omp_sese_split_blocks(), ompdevlow_adjust_simt_enter(), op1_range(), op_prio(), operand_equal_for_comparison_p(), operand_compare::operand_equal_p(), optimize_atomic_bit_test_and(), optimize_atomic_compare_exchange_p(), optimize_atomic_op_fetch_cmp_0(), optimize_count_trailing_zeroes(), optimize_memcpy(), optimize_range_tests_to_bit_test(), optimize_va_list_gpr_fpr_size(), optimize_vector_load(), outermost_invariant_loop_for_expr(), output_addressed_constants(), output_constant(), output_constructor_array_range(), output_constructor_bitfield(), output_gimple_stmt(), output_ttype(), param_change_prob(), parloops_is_simple_reduction(), parse_predicate(), path_comparable_for_same_access(), phiprop_insert_phi(), plus_stmt_object_size(), pointer_may_wrap_p(), points_to_local_or_readonly_memory_p(), points_to_possible_sra_candidate_p(), pos_from_bit(), predicate_scalar_phi(), predicate_statements(), prepare_call_arguments(), prepare_decl_rtl(), prepare_gimple_addressable(), prepare_target_mem_ref_lvalue(), preserve_any_location_wrapper(), print_call_name(), print_node(), process_call_operands(), propagate_controlled_uses(), propagate_necessity(), propagate_unknowns(), propagate_with_phi(), ptr_deref_may_alias_decl_p(), ptr_deref_may_alias_ref_p_1(), ptr_derefs_may_alias_p(), ptrs_compare_unequal(), fold_using_range::range_of_address(), readonly_data_expr(), really_constant_p(), recalculate_side_effects(), recompute_tree_invariant_for_addr_expr(), record_conditions(), record_reference(), record_target_from_binfo(), record_type_list(), ref_at_iteration(), ref_contains_union_access_p(), ref_may_alias_global_p_1(), ref_may_be_aliased(), ref_maybe_used_by_call_p_1(), ref_maybe_used_by_stmt_p(), reference_alias_ptr_type(), reference_alias_ptr_type_1(), refs_local_or_readonly_memory_p(), refs_may_alias_p_2(), remap_gimple_op_r(), remap_gimple_stmt(), remap_vla_decls(), remove_indirect_clobbers(), remove_unused_locals(), replace_locals_op(), replace_ref(), replace_stmt_with_simplification(), replace_trapping_overflow(), requires_barrier(), restructure_reference(), reverse_storage_order_for_component_p(), rewrite_use_address(), rtl_for_decl_init(), safe_from_p(), same_access_path_p(), same_addr_size_stores_p(), same_bool_comparison_p(), same_bool_result_p(), scan_omp_1_op(), scan_operand_equal_p(), scan_sharing_clauses(), scev_is_linear_expression(), self_inlining_addr_expr(), self_referential_component_ref_p(), self_referential_size(), self_reuse_distance(), set_bb_predicate(), ipa_polymorphic_call_context::set_by_invariant(), set_component_ref_size(), set_mem_attributes_minus_bitpos(), set_ssa_val_to(), shortcut_cond_expr(), shortcut_cond_r(), sign_bit_p(), simd_clone_adjust(), simd_clone_call_p(), simple_condition_p(), simple_cst_equal(), simple_iv_with_niters(), simplify_1b(), simplify_bitfield_ref(), simplify_builtin_call(), simplify_using_ranges::simplify_casted_compare(), jump_threader::simplify_control_stmt_condition_1(), simplify_count_trailing_zeroes(), simplify_permutation(), simplify_replace_tree(), simplify_using_outer_evolutions(), simplify_vector_constructor(), sink_clobbers(), skip_simple_arithmetic(), skip_simple_constant_arithmetic(), slsr_process_ref(), sort_and_splice_var_accesses(), spaceship_replacement(), split_address_to_core_and_offset(), split_constant_offset_1(), split_to_var_and_offset(), split_tree(), sra_modify_call_arg(), sra_modify_expr(), ssa_undefined_value_p(), stabilize_reference(), stabilize_reference_1(), staticp(), stmt_kills_ref_p(), stmt_may_be_vtbl_ptr_store(), storage_order_barrier_p(), store_constructor(), store_expr(), store_field(), store_kills_ref_p(), strdup_object_size(), strip_float_extensions(), strip_invariant_refs(), strip_offset_1(), strip_zero_offset_components(), substitute_in_expr(), substitute_placeholder_in_expr(), pcom_worker::suitable_component_p(), symtab_node_for_jfunc(), tag_shortcut_cond(), take_address_of(), target_align(), test_nonssa_use(), tm_memopt_transform_stmt(), track_expr_p(), trailing_array(), transaction_invariant_address_p(), loop_distribution::transform_reduction_loop(), tree_add_const_value_attribute(), tree_binary_nonnegative_warnv_p(), tree_contains_chrecs(), tree_could_throw_p(), tree_could_trap_p(), tree_ctz(), tree_expr_finite_p(), tree_expr_infinite_p(), tree_expr_maybe_infinite_p(), tree_expr_maybe_nan_p(), tree_expr_maybe_real_minus_zero_p(), tree_expr_maybe_signaling_nan_p(), tree_expr_nan_p(), tree_expr_nonnegative_warnv_p(), tree_expr_nonzero_warnv_p(), tree_expr_signaling_nan_p(), tree_invalid_nonnegative_warnv_p(), tree_invariant_p_1(), tree_nonzero_bits(), tree_nop_conversion(), tree_sign_nop_conversion(), tree_simplify_using_condition_1(), tree_single_nonnegative_warnv_p(), tree_single_nonzero_warnv_p(), tree_ssa_strip_useless_type_conversions(), tree_ssa_useless_type_conversion(), tree_strip_any_location_wrapper(), tree_strip_nop_conversions(), tree_strip_sign_nop_conversions(), tree_to_aff_combination(), try_catch_may_fallthru(), twoval_comparison_p(), type_possibly_instantiated_p(), typed_binop_from_tree(), uaddc_is_cplxpart(), unadjusted_ptr_and_unit_offset(), undistribute_bitref_for_vector(), uniform_vector_p(), unterminated_array(), update_range_test(), use_in_zero_equality(), va_list_counter_bump(), va_list_counter_struct_op(), valid_gimple_rhs_p(), valid_mem_ref_cand_p(), values_equal_for_ipcp_p(), var_decl_component_p(), var_is_used_for_virtual_call_p(), vect_build_slp_tree_1(), vect_build_slp_tree_2(), vect_check_gather_scatter(), vect_copy_ref_info(), vect_embedded_comparison_type(), vect_find_stmt_data_reference(), vect_get_and_check_slp_defs(), vect_get_datarefs_in_loop(), vect_is_simple_cond(), vect_is_simple_use(), vect_mark_stmts_to_be_vectorized(), vect_recog_bitfield_ref_pattern(), vect_recog_bool_pattern(), vect_recog_mask_conversion_pattern(), vect_recog_mixed_size_cond_pattern(), vectorizable_condition(), vectorizable_load(), vectorizable_scan_store(), vectorizable_simd_clone_call(), vectorizable_store(), verify_address(), verify_bb_vtables(), verify_gimple_assign_single(), verify_gimple_call(), verify_phi_args(), verify_types_in_gimple_reference(), view_converted_memref_p(), visit_loadstore(), visit_phi(), visit_reference_op_call(), visit_stmt(), vn_get_stmt_kind(), vn_reference_compute_hash(), vn_reference_eq(), vn_reference_fold_indirect(), vn_reference_lookup_2(), vn_reference_lookup_3(), vn_reference_may_trap(), vn_reference_maybe_forwprop_address(), voidify_wrapper_expr(), vt_add_function_parameters(), vtable_pointer_value_to_vtable(), walk_gimple_omp_for(), walk_stmt_load_store_addr_ops(), walk_tree_1(), warn_switch_unreachable_and_auto_init_r(), warn_uninit(), widen_memory_access(), will_be_nonconstant_expr_predicate(), wrap_refs(), and write_ts_exp_tree_pointers().

◆ TREE_OPERAND_CHECK

#define TREE_OPERAND_CHECK	(		T,
			I ) ((T)->exp.operands[I])

◆ TREE_OPERAND_CHECK_CODE

#define TREE_OPERAND_CHECK_CODE	(	T,
		CODE,
		I ) ((T)->exp.operands[I])

◆ TREE_OPERAND_LENGTH

#define TREE_OPERAND_LENGTH ( NODE ) tree_operand_length (NODE)

In ordinary expression nodes.

Referenced by chrec_contains_symbols(), chrec_contains_symbols_defined_in_loop(), chrec_contains_undetermined(), data_ref_compare_tree(), DFS::DFS_write_tree_body(), do_niy(), evolution_function_is_invariant_rec_p(), expand_simple_operations(), expr_invariant_in_loop_p(), extract_single_var_from_expr(), find_deriving_biv_for_expr(), find_placeholder_in_expr(), generic_expr_could_trap_p(), get_base_value(), operand_compare::hash_operand(), hash_tree(), lto_input_ts_exp_tree_pointers(), make_range(), outermost_invariant_loop_for_expr(), print_node(), process_call_operands(), recalculate_side_effects(), replace_trapping_overflow(), safe_from_p(), simplify_replace_tree(), substitute_in_expr(), substitute_placeholder_in_expr(), tree_contains_chrecs(), walk_tree_1(), and write_ts_exp_tree_pointers().

◆ TREE_OPTIMIZATION

#define TREE_OPTIMIZATION ( NODE ) (OPTIMIZATION_NODE_CHECK (NODE)->optimization.opts)

Referenced by build_optimization_node(), copy_node(), cl_option_hasher::equal(), free_node(), ipa_icf::sem_function::get_hash(), cl_option_hasher::hash(), hash_tree(), invoke_set_current_function_hook(), lto_input_ts_function_decl_tree_pointers(), make_node(), opts_for_fn(), print_node(), streamer_read_tree_bitfields(), streamer_write_tree_bitfields(), and target_reinit().

◆ TREE_OPTIMIZATION_BASE_OPTABS

#define TREE_OPTIMIZATION_BASE_OPTABS ( NODE ) (OPTIMIZATION_NODE_CHECK (NODE)->optimization.base_optabs)

Referenced by init_tree_optimization_optabs().

◆ TREE_OPTIMIZATION_OPTABS

#define TREE_OPTIMIZATION_OPTABS ( NODE ) (OPTIMIZATION_NODE_CHECK (NODE)->optimization.optabs)

Referenced by init_tree_optimization_optabs(), and invoke_set_current_function_hook().

◆ TREE_OVERFLOW

#define TREE_OVERFLOW ( NODE ) (CST_CHECK (NODE)->base.public_flag)

In an INTEGER_CST, REAL_CST, or COMPLEX_CST, this means
there was an overflow in folding.

◆ TREE_OVERFLOW_P

#define TREE_OVERFLOW_P ( EXPR ) (CONSTANT_CLASS_P (EXPR) && TREE_OVERFLOW (EXPR))

TREE_OVERFLOW can only be true for EXPR of CONSTANT_CLASS_P.

Referenced by canonicalize_constructor_val(), canonicalize_value(), fold_binary_loc(), get_single_symbol(), range_query::get_tree_range(), gimple_resimplify1(), gimple_resimplify2(), gimple_resimplify3(), gimplify_expr(), tree_vector_builder::note_representative(), propagate_vr_across_jump_function(), set_ssa_name_value(), split_tree(), and valid_constant_size_p().

◆ TREE_PRIVATE

#define TREE_PRIVATE ( NODE ) ((NODE)->base.private_flag)

Used in classes in C++.

Referenced by add_accessibility_attribute(), gimplify_omp_for(), hash_tree(), pack_ts_base_value_fields(), print_node(), and unpack_ts_base_value_fields().

◆ TREE_PROTECTED

#define TREE_PROTECTED ( NODE ) ((NODE)->base.protected_flag)

Used in classes in C++.

Referenced by add_accessibility_attribute(), hash_tree(), pack_ts_base_value_fields(), print_node(), and unpack_ts_base_value_fields().

◆ TREE_PUBLIC

#define TREE_PUBLIC ( NODE ) ((NODE)->base.public_flag)

In a VAR_DECL, FUNCTION_DECL, NAMESPACE_DECL or TYPE_DECL,
nonzero means name is to be accessible from outside this translation unit.
In an IDENTIFIER_NODE, nonzero means an external declaration
accessible from outside this translation unit was previously seen
for this name in an inner scope.

Referenced by cgraph_node::add_new_function(), add_pubname(), add_pubtype(), asan_add_global(), asan_emit_stack_protection(), asan_finish_file(), asan_needs_odr_indicator_p(), asan_protect_global(), assemble_alias(), assemble_external(), assemble_start_function(), assemble_variable(), build_builtin_function(), build_cxa_atexit_decl(), build_dso_handle_decl(), build_fn_decl(), build_gcov_exit_decl(), build_info(), build_init_ctor(), build_libfunc_function_visibility(), build_personality_function(), can_refer_decl_in_current_unit_p(), cgraph_build_static_cdtor_1(), cgraph_externally_visible_p(), check_decl(), check_global_declaration(), comdat_can_be_unshared_p_1(), symtab_node::comdat_local_p(), compare_base_symbol_refs(), symtab_node::copy_visibility_from(), coverage_compute_profile_id(), create_assumption_fn(), create_loop_fn(), create_odr_indicator(), create_omp_child_function(), cgraph_node::create_version_clone_with_body(), cgraph_node::create_virtual_clone(), ctor_for_folding(), decl_binds_to_current_def_p(), decl_replaceable_p(), declare_weak(), decls_mismatched_attributes(), default_binds_local_p_3(), default_elf_select_rtx_section(), default_encode_section_info(), default_external_stack_protect_fail(), default_hidden_stack_protect_fail(), default_stack_protect_guard(), default_use_anchors_for_symbol_p(), dequeue_and_dump(), symtab_node::dissolve_same_comdat_group_list(), do_assemble_alias(), symtab_node::dump_base(), dw2_force_const_mem(), dw2_output_indirect_constant_1(), expand_builtin_fork_or_exec(), expand_omp_target(), expand_simd_clones(), varpool_node::externally_visible_p(), symtab_node::fixup_same_cpp_alias_visibility(), fortran_common(), function_always_visible_to_compiler_p(), function_and_variable_visibility(), varpool_node::get_availability(), get_emutls_init_templ_addr(), get_variable_align(), get_variable_section(), gimple_init_gcov_profiler(), go_decl(), hash_tree(), init_eh(), init_ic_make_global_vars(), ipa_make_edge_direct_to_target(), ipa_pta_execute(), ipa_tm_create_version(), ipa_tm_create_version_alias(), is_improper(), lhd_set_decl_assembler_name(), local_tree_p(), localize_node(), lower_omp_critical(), symtab_node::make_decl_local(), make_decl_one_only(), make_decl_rtl(), make_dispatcher_decl(), may_be_aliased(), maybe_record_node(), maybe_special_function_p(), merge_weak(), need_assembler_name_p(), symtab_node::needed_p(), new_emutls_decl(), symtab_node::noninterposable_alias(), notice_global_symbol(), omp_runtime_api_call(), optimize_omp_library_calls(), optimize_weakref(), output_comp_unit(), symtab_node::output_to_lto_symbol_table_p(), output_ttype(), pack_ts_base_value_fields(), cgraph_edge::possibly_call_in_translation_unit_p(), symtab_node::prevailing_p(), print_decl_identifier(), print_declaration(), print_node(), process_function_and_variable_attributes(), process_symver_attribute(), refered_from_nonlocal_fn(), refered_from_nonlocal_var(), reference_to_unused(), save_inline_function_body(), secname_for_decl(), set_new_clone_decl_and_node_flags(), setjmp_or_longjmp_p(), simd_clone_create(), simple_operand_p(), type_in_anonymous_namespace_p(), ubsan_create_data(), ubsan_expand_vptr_ifn(), ubsan_type_descriptor(), unpack_ts_base_value_fields(), symtab_node::used_from_object_file_p(), symtab_node::verify_base(), weak_finish(), wrap_refs(), and wrapup_global_declaration_2().

◆ TREE_PURPOSE

#define TREE_PURPOSE ( NODE ) (TREE_LIST_CHECK (NODE)->list.purpose)

In a TREE_LIST node.

Referenced by attribute_ignored_p(), build_constructor_from_list(), build_tree_list(), rt_bb_visited::check(), check_unique_operand_names(), comp_type_attributes(), ipa_icf_gimple::func_checker::compare_asm_inputs_outputs(), copy_tree_body_r(), create_coalesce_list_for_region(), create_task_copyfn(), cxx11_attribute_p(), dequeue_and_dump(), device_resident_p(), DFS::DFS_write_tree_body(), dump_function_to_file(), dump_generic_node(), dump_omp_clause(), expand_asm_stmt(), expand_omp_ordered_sink(), find_func_aliases(), operands_scanner::get_asm_stmt_operands(), get_attribute_name(), get_attribute_namespace(), gimple_regimplify_operands(), gimplify_asm_expr(), gimplify_bind_expr(), gimplify_omp_affinity(), gimplify_omp_depend(), gimplify_omp_for(), gimplify_omp_loop(), gimplify_scan_omp_clauses(), go_output_typedef(), hash_tree(), ipa_odr_summary_write(), lookup_attribute_spec(), lookup_tramp_for_decl(), lower_omp_ordered_clauses(), lower_private_allocate(), lower_rec_input_clauses(), lto_input_ts_list_tree_pointers(), maybe_canonicalize_argtypes(), oacc_do_neutering(), oacc_fn_attrib_level(), oacc_replace_fn_attrib_attr(), oacc_validate_dims(), omp_discover_declare_target_tgt_fn_r(), omp_resolve_declare_variant(), print_node(), process_symver_attribute(), purpose_member(), rt_bb_visited::push_rtcfg_pair(), remove_attributes_matching(), remove_named_attribute_unsharing(), resolve_asm_operand_names(), resolve_operand_name_1(), substitute_in_expr(), substitute_placeholder_in_expr(), tree_cons(), type_list_equal(), verify_type(), walk_gimple_asm(), walk_stmt_load_store_addr_ops(), weak_finish(), and write_ts_list_tree_pointers().

◆ TREE_RANGE_CHECK

#define TREE_RANGE_CHECK	(	T,
		CODE1,
		CODE2 ) (T)

◆ TREE_READONLY

#define TREE_READONLY ( NODE ) (NON_TYPE_CHECK (NODE)->base.readonly_flag)

In a VAR_DECL, PARM_DECL or FIELD_DECL, or any kind of ..._REF node,
nonzero means it may not be the lhs of an assignment.
Nonzero in a FUNCTION_DECL means this function should be treated
as "const" function (can only read its arguments).

Referenced by symtab_node::address_can_be_compared_p(), analyze_functions(), asan_add_global(), asan_emit_stack_protection(), asan_pp_string(), assumption_copy_decl(), base_object_writable(), bss_initializer_p(), build2(), build3(), build_constant_desc(), build_gcov_info_var_registration(), tree_switch_conversion::switch_conversion::build_one_array(), build_string_literal(), call_may_clobber_ref_p_1(), can_sm_ref_p(), categorize_decl_for_section(), cdtor_p(), rt_bb_visited::check(), check_decl(), check_global_declaration(), comdat_can_be_unshared_p_1(), copy_decl_to_var(), copy_result_decl_to_var(), copy_tree_body_r(), create_access(), create_odr_indicator(), create_omp_child_function(), create_tmp_var_raw(), create_vop_var(), ctor_for_folding(), varpool_node::ctor_useable_for_folding_p(), decl_quals(), default_select_section(), varpool_node::dump(), dw2_output_indirect_constant_1(), emit_push_insn(), expand_expr_real_1(), expand_omp_target(), expand_thunk(), ipa_icf::sem_item_optimizer::filter_removed_items(), flags_from_decl_or_type(), fold_unary_loc(), get_callee_fndecl(), get_chain_decl(), get_debug_decl(), get_emutls_init_templ_addr(), gimplify_compound_literal_expr(), gimplify_decl_expr(), gimplify_init_constructor(), gimplify_modify_expr_rhs(), handle_unscalarized_data_in_subtree(), has_attribute(), hash_tree(), instrument_expr(), ipa_compute_jump_functions_for_edge(), ipa_discover_variable_flags(), ipa_find_agg_cst_from_init(), ipa_make_function_const(), ipa_make_function_pure(), ipa_tm_create_version_alias(), is_improper(), lhd_warn_unused_global_decl(), load_register_parameters(), lower_send_shared_vars(), may_be_aliased(), maybe_inline_call_in_expr(), mem_dies_at_call(), new_emutls_decl(), symtab_node::noninterposable_alias(), omp_build_component_ref(), pack_ts_base_value_fields(), parm_preserved_before_stmt_p(), print_node(), process_call_operands(), propagate_pure_const(), refs_local_or_readonly_memory_p(), remap_gimple_stmt(), requires_barrier(), ipa_param_body_adjustments::reset_debug_stmts(), scan_sharing_clauses(), self_referential_size(), set_call_expr_flags(), set_const_flag_1(), set_mem_attributes_minus_bitpos(), set_pure_flag_1(), set_readonly_bit(), setup_one_parameter(), sra_modify_assign(), sra_modify_expr(), stabilize_reference(), stabilize_reference_1(), substitute_in_expr(), substitute_placeholder_in_expr(), tree_add_const_value_attribute_for_decl(), tree_invariant_p_1(), ubsan_source_location(), ubsan_type_descriptor(), unpack_ts_base_value_fields(), use_pointer_for_field(), vect_setup_realignment(), verify_gimple_call(), worse_state(), and wrapup_global_declaration_2().

◆ TREE_REAL_CST

#define TREE_REAL_CST ( NODE ) (*TREE_REAL_CST_PTR (NODE))

Referenced by acceptable_pow_call(), associate_equivalences_with_edges(), check_pow(), compare_constant(), const_binop(), const_unop(), const_vector_from_tree(), decrement_power(), dump_generic_node(), ipa_icf::sem_variable::equals(), estimate_num_insns(), exact_inverse(), expand_complex_multiplication(), expand_expr_real_1(), expand_pow_as_sqrts(), fold_abs_const(), fold_binary_loc(), fold_convert_const(), fold_convert_const_fixed_from_real(), fold_convert_const_int_from_real(), fold_convert_const_real_from_real(), fold_negate_const(), fold_real_zero_addition_p(), gen_conditions_for_pow_cst_base(), gimple_expand_builtin_pow(), hash_tree(), initializer_zerop(), negate_expr_p(), operand_compare::operand_equal_p(), optimize_recip_sqrt(), output_constant(), pack_ts_real_cst_value_fields(), print_real_cst(), real_maybe_zerop(), real_minus_onep(), real_onep(), real_zerop(), record_equality(), simple_cst_equal(), some_nonzerop(), strip_float_extensions(), tree_call_nonnegative_warnv_p(), tree_expr_maybe_real_minus_zero_p(), tree_single_nonnegative_warnv_p(), valid_lattice_transition(), and vect_recog_pow_pattern().

◆ TREE_REAL_CST_PTR

#define TREE_REAL_CST_PTR ( NODE ) (&REAL_CST_CHECK (NODE)->real_cst.value)

◆ TREE_REALPART

#define TREE_REALPART ( NODE ) (COMPLEX_CST_CHECK (NODE)->complex.real)

In a COMPLEX_CST node.

Referenced by adjust_realpart_expr(), build_complex(), categorize_ctor_elements_1(), compare_constant(), const_binop(), const_hash_1(), const_unop(), const_with_all_bytes_same(), DFS::DFS_write_tree_body(), do_mpc_arg2(), drop_tree_overflow(), dump_generic_node(), ipa_icf::sem_variable::equals(), expand_debug_expr(), expand_expr_real_1(), extract_component(), find_lattice_value(), fold_binary_loc(), fold_const_call_1(), fold_const_call_1(), fold_mult_zconjz(), fold_negate_expr_1(), fold_relational_const(), operand_compare::hash_operand(), hash_tree(), initializer_zerop(), integer_all_onesp(), integer_each_onep(), integer_minus_onep(), integer_nonzerop(), integer_onep(), integer_pow2p(), integer_zerop(), lto_input_ts_complex_tree_pointers(), maybe_trim_complex_store(), native_encode_complex(), negate_expr_p(), operand_compare::operand_equal_p(), output_constant(), print_node(), read_complex_part(), real_maybe_zerop(), real_minus_onep(), real_onep(), real_zerop(), tree_expr_finite_p(), tree_floor_log2(), tree_log2(), valid_lattice_transition(), walk_tree_1(), and write_ts_complex_tree_pointers().

◆ TREE_SET_BLOCK

#define TREE_SET_BLOCK	(		T,
			B ) (tree_set_block ((T), (B)))

Referenced by clear_unused_block_pointer_1(), copy_tree_body_r(), lower_stmt(), lto_input_ts_exp_tree_pointers(), move_stmt_op(), and remap_gimple_op_r().

◆ TREE_SET_CODE

#define TREE_SET_CODE	(		NODE,
			VALUE ) ((NODE)->base.code = (VALUE))

◆ TREE_SIDE_EFFECTS

#define TREE_SIDE_EFFECTS ( NODE ) (NON_TYPE_CHECK (NODE)->base.side_effects_flag)

In any expression, decl, or constant, nonzero means it has side effects or
reevaluation of the whole expression could produce a different value.
This is set if any subexpression is a function call, a side effect or a
reference to a volatile variable.  In a ..._DECL, this is set only if the
declaration said `volatile'.  This will never be set for a constant.

Referenced by alloc_stmt_list(), append_to_statement_list(), build2(), build3(), build_cdtor(), build_cxa_dtor_registrations(), build_ref_for_offset(), c_strlen(), strlen_pass::check_and_optimize_stmt(), check_loadstore(), computable_teams_clause(), convert_to_integer_1(), copy_ref_info(), copy_tree_body_r(), create_task_copyfn(), ctor_for_folding(), do_jump(), do_mpfr_lgamma_r(), do_mpfr_remquo(), emit_push_insn(), expand_builtin_assume_aligned(), expand_builtin_strcmp(), expand_builtin_strncmp(), expand_builtin_va_copy(), expand_builtin_va_end(), expand_call_stmt(), expand_complex_move(), expand_expr_real_1(), expression_expensive_p(), fold_binary_loc(), fold_binary_op_with_conditional_arg(), fold_build_cleanup_point_expr(), fold_builtin_constant_p(), fold_builtin_frexp(), fold_builtin_modf(), fold_builtin_object_size(), fold_const_call(), fold_ignored_result(), fold_ternary_loc(), fold_truth_andor(), fold_truth_andor_1(), forward_propagate_addr_expr_1(), get_debug_decl(), gimple_fold_builtin_stxcpy_chk(), gimplify_call_expr(), gimplify_cond_expr(), gimplify_expr(), gimplify_init_constructor(), gimplify_init_ctor_eval(), gimplify_init_ctor_preeval(), gimplify_omp_depend(), gimplify_omp_for(), gimplify_scan_omp_clauses(), gimplify_transaction(), hash_tree(), load_register_parameters(), lookup_tmp_var(), make_node(), maybe_fold_tmr(), maybe_make_indirect(), merge_truthop_with_opposite_arm(), omit_one_operand_loc(), omit_two_operands_loc(), operand_compare::operand_equal_p(), optimize_bitfield_assignment_op(), pack_ts_base_value_fields(), print_node(), process_call_operands(), recalculate_side_effects(), recompute_constructor_flags(), recompute_tree_invariant_for_addr_expr(), remap_gimple_op_r(), save_expr(), setup_one_parameter(), shortcut_cond_expr(), simple_condition_p(), stabilize_reference(), stabilize_reference_1(), stabilize_va_list_loc(), store_constructor(), tree_invariant_p_1(), tsi_delink(), tsi_link_after(), tsi_link_before(), unpack_ts_base_value_fields(), use_register_for_decl(), verify_address(), verify_constructor_flags(), and voidify_wrapper_expr().

◆ TREE_STATIC

#define TREE_STATIC ( NODE ) ((NODE)->base.static_flag)

In a VAR_DECL, nonzero means allocate static storage.
In a FUNCTION_DECL, nonzero if function has been defined.
In a CONSTRUCTOR, nonzero means allocate static storage.

Referenced by add_var_loc_to_decl(), asan_add_global(), asan_emit_stack_protection(), asan_finish_file(), asan_pp_string(), assemble_external(), auto_var_p(), build_constant_desc(), build_gcov_info_var_registration(), tree_switch_conversion::switch_conversion::build_one_array(), build_string_literal(), build_var(), builtin_save_expr(), call_may_clobber_ref_p_1(), can_escape(), can_refer_decl_in_current_unit_p(), categorize_ctor_elements_1(), cgraph_build_static_cdtor_1(), symbol_table::change_decl_assembler_name(), rt_bb_visited::check(), check_decl(), compare_base_symbol_refs(), convert_local_omp_clauses(), convert_local_reference_op(), convert_local_reference_stmt(), convert_nonlocal_omp_clauses(), convert_nonlocal_reference_op(), convert_nonlocal_reference_stmt(), copy_decl_for_dup_finish(), symtab_node::copy_visibility_from(), coverage_obj_finish(), coverage_obj_init(), create_assumption_fn(), create_loop_fn(), create_odr_indicator(), create_omp_child_function(), create_tmp_var_raw(), create_vop_var(), ctor_for_folding(), decl_address_invariant_p(), decl_address_ip_invariant_p(), decl_in_symtab_p(), declare_inline_vars(), default_external_stack_protect_fail(), default_hidden_stack_protect_fail(), default_ref_may_alias_errno(), default_stack_protect_guard(), delegitimize_mem_from_attrs(), dw2_output_indirect_constant_1(), execute_fixup_cfg(), expand_constructor(), expand_debug_expr(), expand_expr_real_1(), expand_omp_for_generic(), expand_omp_target(), expand_omp_taskreg(), expand_one_var(), expand_used_vars(), varpool_node::finalize_decl(), find_placeholder_in_expr(), fixed_address_object_p(), force_expr_to_var_cost(), fortran_common(), gen_variable_die(), symtab_node::get(), get_constraint_for_ssa_var(), get_emutls_init_templ_addr(), get_symbol_initial_value(), gimple_add_tmp_var(), gimple_duplicate_bb(), gimple_init_gcov_profiler(), gimplify_bind_expr(), gimplify_decl_expr(), gimplify_function_tree(), gimplify_init_constructor(), gimplify_target_expr(), gimplify_var_or_parm_decl(), hash_tree(), initialize_argument_information(), initializer_constant_valid_p_1(), input_overwrite_node(), input_varpool_node(), instrument_derefs(), ipa_lower_emutls(), ipa_set_jf_constant(), is_global_var(), lhd_set_decl_assembler_name(), lower_omp_critical(), lower_omp_target(), lower_stmt(), symtab_node::make_decl_local(), make_decl_rtl(), mark_address(), mark_addressable(), mark_load(), mark_store(), may_be_aliased(), maybe_remove_writeonly_store(), maybe_wrap_with_location(), need_assembler_name_p(), new_emutls_decl(), oacc_privatization_candidate_p(), omp_default_clause(), omp_discover_declare_target_var_r(), omp_finish_file(), omp_resolve_declare_variant(), output_comp_unit(), pack_ts_base_value_fields(), print_declaration(), print_node(), produce_memory_decl_rtl(), ptrs_compare_unequal(), readonly_data_expr(), ref_maybe_used_by_call_p_1(), replace_locals_op(), rest_of_decl_compilation(), rtl_for_decl_location(), safe_from_p(), secname_for_decl(), self_referential_size(), set_mem_attributes_minus_bitpos(), set_uids_in_ptset(), simple_operand_p(), staticp(), store_constructor(), track_expr_p(), tree_add_const_value_attribute_for_decl(), tree_is_indexable(), ubsan_create_data(), ubsan_expand_vptr_ifn(), ubsan_source_location(), ubsan_type_descriptor(), unpack_ts_base_value_fields(), vect_can_force_dr_alignment_p(), verify_expr_location_1(), and wrapup_global_declaration_2().

◆ TREE_STRING_LENGTH

#define TREE_STRING_LENGTH ( NODE ) (STRING_CST_CHECK (NODE)->string.length)

In a STRING_CST

In C terms, this is sizeof, not strlen.

Referenced by address_compare(), array_size_for_constructor(), build_string(), c_strlen(), categorize_ctor_elements_1(), check_ctz_string(), check_string_literal(), compare_constant(), compute_objsize_r(), const_hash_1(), constant_byte_string(), strlen_pass::count_nonzero_bytes(), data_ref_compare_tree(), dequeue_and_dump(), dump_generic_node(), ipa_icf::sem_variable::equals(), expand_asm_loc(), expand_debug_expr(), expand_expr_real_1(), fold_read_from_constant_string(), get_constant_size(), get_strub_mode_from_attr(), getbyterep(), operand_compare::hash_operand(), hash_tree(), initializer_zerop(), mergeable_string_section(), native_encode_string(), omp_context_name_list_prop(), operand_compare::operand_equal_p(), output_constant(), print_node(), process_symver_attribute(), rtl_for_decl_init(), rtx_addr_can_trap_p_1(), simple_cst_equal(), simplify_builtin_call(), store_expr(), streamer_write_string_cst(), string_cst_read_str(), strub_validate_fn_attr_parm(), subtract_estimated_size(), tree_could_trap_p(), and tree_size().

◆ TREE_STRING_POINTER

#define TREE_STRING_POINTER ( NODE ) ((const char *)(STRING_CST_CHECK (NODE)->string.str))

Referenced by address_compare(), assemble_asm(), c_strlen(), check_ctz_string(), check_unique_operand_names(), ipa_icf_gimple::func_checker::compare_asm_inputs_outputs(), compare_constant(), const_hash_1(), strlen_pass::count_nonzero_bytes(), create_coalesce_list_for_region(), data_ref_compare_tree(), dequeue_and_dump(), dump_generic_node(), ipa_icf::sem_variable::equals(), error_unavailable_use(), expand_asm_loc(), expand_asm_stmt(), expand_debug_expr(), expand_expr_real_1(), find_func_aliases(), fold_read_from_constant_string(), get_alias_symbol(), operands_scanner::get_asm_stmt_operands(), get_attr_str(), get_strub_mode_from_attr(), get_target_clone_attr_len(), getbyterep(), gimple_asm_clobbers_memory_p(), gimple_regimplify_operands(), gimplify_asm_expr(), operand_compare::hash_operand(), hash_tree(), init_attr_rdwr_indices(), initializer_zerop(), input_gimple_stmt(), is_function_default_version(), maybe_warn_pass_by_reference(), maybe_warn_read_write_only(), mergeable_string_section(), native_encode_string(), omp_context_name_list_prop(), operand_compare::operand_equal_p(), output_constant(), print_node(), process_symver_attribute(), resolve_asm_operand_names(), resolve_operand_name_1(), rest_of_decl_compilation(), rtl_for_decl_init(), simple_cst_equal(), simplify_builtin_call(), sorted_attr_string(), store_expr(), streamer_write_string_cst(), string_cst_read_str(), strub_validate_fn_attr_parm(), walk_gimple_asm(), walk_stmt_load_store_addr_ops(), warn_deprecated_use(), warn_switch_unreachable_and_auto_init_r(), and warn_uninit().

◆ TREE_SYMBOL_REFERENCED

#define TREE_SYMBOL_REFERENCED ( NODE ) (IDENTIFIER_NODE_CHECK (NODE)->base.static_flag)

In an IDENTIFIER_NODE, this means that assemble_name was called with
this string as an argument.

Referenced by symbol_table::change_decl_assembler_name(), default_elf_asm_output_external(), do_assemble_alias(), dw2_force_const_mem(), ipa_tm_create_version(), ipa_tm_create_version_alias(), mark_referenced(), merge_weak(), symtab_node::needed_p(), process_pending_assemble_externals(), and weak_finish().

◆ TREE_TARGET_GLOBALS

#define TREE_TARGET_GLOBALS ( NODE ) (TARGET_OPTION_NODE_CHECK (NODE)->target_option.globals)

Referenced by prepare_target_option_nodes_for_pch().

◆ TREE_TARGET_OPTION

#define TREE_TARGET_OPTION ( NODE ) (TARGET_OPTION_NODE_CHECK (NODE)->target_option.opts)

Referenced by build_target_option_node(), copy_node(), cl_option_hasher::equal(), free_node(), ipa_icf::sem_function::get_hash(), cl_option_hasher::hash(), hash_tree(), make_node(), print_node(), streamer_read_tree_bitfields(), streamer_write_tree_bitfields(), and target_opts_for_fn().

◆ TREE_THIS_NOTRAP

#define TREE_THIS_NOTRAP ( NODE )

Value:

(TREE_CHECK5 (NODE, INDIRECT_REF, MEM_REF, TARGET_MEM_REF, ARRAY_REF, \

ARRAY_RANGE_REF)->base.nothrow_flag)

TREE_CHECK5

#define TREE_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5)

Definition tree.h:494

Nonzero means this node will not trap.  In an INDIRECT_REF, means
accessing the memory pointed to won't generate a trap.  However,
this only applies to an object when used appropriately: it doesn't
mean that writing a READONLY mem won't trap.

In ARRAY_REF and ARRAY_RANGE_REF means that we know that the index
(or slice of the array) always belongs to the range of the array.
I.e. that the access will not trap, provided that the access to
the base to the array will not trap.

Referenced by adjust_assumption_stmt_op(), build_receiver_ref(), build_receiver_ref(), build_simple_mem_ref_notrap(), copy_tree_body_r(), forward_propagate_addr_expr_1(), gimplify_bind_expr(), gimplify_expr(), gimplify_vla_decl(), lower_lastprivate_clauses(), lower_omp_scan(), lower_omp_target(), lower_private_allocate(), lower_rec_input_clauses(), lower_rec_simd_input_clauses(), remap_gimple_op_r(), substitute_in_expr(), substitute_placeholder_in_expr(), and tree_could_trap_p().

◆ TREE_THIS_VOLATILE

#define TREE_THIS_VOLATILE ( NODE ) ((NODE)->base.volatile_flag)

Nonzero means this expression is volatile in the C sense:
its address should be of type `volatile WHATEVER *'.
In other words, the declared item is volatile qualified.
This is used in _DECL nodes and _REF nodes.
On a FUNCTION_DECL node, this means the function does not
return normally.  This is the same effect as setting
the attribute noreturn on the function in C.

In a ..._TYPE node, means this type is volatile-qualified.
But use TYPE_VOLATILE instead of this macro when the node is a type,
because eventually we may make that a different bit.

If this bit is set in an expression, so is TREE_SIDE_EFFECTS.

Referenced by add_clobbers_to_eh_landing_pad(), operands_scanner::add_stmt_operand(), symtab_node::address_can_be_compared_p(), adjust_assumption_stmt_op(), analyze_agg_content_value(), ao_ref_init(), asan_add_global(), assumption_copy_decl(), bitfields_to_lower_p(), build2(), build3(), build_access_from_expr_1(), build_clobber(), build_ref_for_model(), build_ref_for_offset(), can_sm_ref_p(), check_decl(), check_global_declaration(), check_loadstore(), check_op(), comdat_can_be_unshared_p_1(), ao_compare::compare_ao_refs(), computable_teams_clause(), copy_decl_to_var(), copy_ref_info(), copy_result_decl_to_var(), copy_tree_body_r(), copy_var_decl(), create_odr_indicator(), create_stack_guard(), create_vop_var(), ctor_for_folding(), varpool_node::ctor_useable_for_folding_p(), decl_quals(), default_external_stack_protect_fail(), default_hidden_stack_protect_fail(), default_stack_protect_guard(), discover_nonconstant_array_refs_r(), dump_stack_clash_frame_info(), dump_variable(), execute_update_addresses_taken(), expand_builtin(), expand_call(), expand_call_inline(), expand_expr_real_1(), expand_thunk(), varpool_node::finalize_decl(), finish_taskreg_scan(), flags_from_decl_or_type(), fold_const_aggregate_ref_1(), forward_propagate_addr_expr_1(), gather_mem_refs_stmt(), generic_parameter_die(), get_callee_fndecl(), get_constraint_for_1(), get_debug_decl(), operands_scanner::get_expr_operands(), get_frame_field(), get_inner_reference(), operands_scanner::get_mem_ref_operands(), operands_scanner::get_tmr_operands(), gimple_fold_builtin_memset(), gimplify_bind_expr(), gimplify_compound_literal_expr(), gimplify_expr(), gimplify_function_tree(), gimplify_init_constructor(), gimplify_modify_expr(), gimplify_modify_expr_rhs(), has_attribute(), hash_tree(), input_gimple_stmt(), install_var_field(), install_var_field(), instrument_expr(), ipa_comdats(), ipa_load_from_parm_agg(), is_gimple_reg(), is_improper(), load_from_unmodified_param_or_agg(), lookup_field_for_decl(), lower_assumption(), lower_omp_task_reductions(), make_decl_rtl(), maybe_add_sra_candidate(), maybe_canonicalize_mem_ref_addr(), maybe_fold_tmr(), maybe_make_indirect(), non_rewritable_lvalue_p(), non_rewritable_mem_ref_base(), omp_build_component_ref(), ompdevlow_adjust_simt_enter(), optimize_atomic_compare_exchange_p(), optimize_bitfield_assignment_op(), output_gimple_stmt(), pack_ts_base_value_fields(), ipa_icf::sem_variable::parse(), print_node(), process_references(), recalculate_side_effects(), remap_gimple_op_r(), ipa_param_body_adjustments::reset_debug_stmts(), set_call_expr_flags(), set_mem_attributes_minus_bitpos(), set_noreturn_flag_1(), simple_operand_p(), sm_seq_valid_bb(), split_function(), stabilize_reference(), stabilize_reference_1(), stmt_makes_single_store(), suggest_attribute(), suitable_reference_p(), tree_add_const_value_attribute_for_decl(), tree_could_trap_p(), type_internals_preclude_sra_p_1(), unpack_ts_base_value_fields(), var_can_have_subvars(), vect_analyze_data_refs(), volatile_lvalue_p(), and wrap_refs().

◆ TREE_TYPE

#define TREE_TYPE ( NODE ) ((NODE)->typed.type)

◆ TREE_UNAVAILABLE

#define TREE_UNAVAILABLE ( NODE ) ((NODE)->base.u.bits.unavailable_flag)

Nonzero in a _DECL if the use of the name is defined as an
unavailable feature by __attribute__((unavailable)).

Referenced by print_node().

◆ TREE_USED

#define TREE_USED ( NODE ) ((NODE)->base.used_flag)

Nonzero in a _DECL if the name is used in its scope.
Nonzero in an expr node means inhibit warning if value is unused.
In IDENTIFIER_NODEs, this means that some extern decl for this name
was used.
In a BLOCK, this means that the block contains variables that are used.

Referenced by asan_add_global(), asan_emit_stack_protection(), assemble_alias(), assign_parm_setup_reg(), cgraph_build_static_cdtor_1(), rt_bb_visited::check(), check_global_declaration(), clear_tree_used(), clear_unused_block_pointer(), clear_unused_block_pointer_1(), ipa_param_body_adjustments::common_initialization(), copy_decl_for_dup_finish(), copy_var_decl(), create_assumption_fn(), create_loop_fn(), create_odr_indicator(), create_omp_child_function(), create_stack_guard(), create_tmp_var_raw(), create_vop_var(), default_external_stack_protect_fail(), default_hidden_stack_protect_fail(), default_stack_protect_guard(), dequeue_and_dump(), dump_scope_block(), expand_call_inline(), expand_expr_addr_expr_1(), expand_expr_real_1(), expand_omp_target(), expand_omp_taskreg(), expand_thunk(), expand_used_vars(), expand_used_vars_for_block(), fold_unary_loc(), get_chain_decl(), get_emutls_init_templ_addr(), get_spill_slot_decl(), gimplify_bind_expr(), gimplify_function_tree(), ipa_tm_create_version_alias(), lower_eh_must_not_throw(), lower_omp_for(), lower_omp_scope(), lower_omp_sections(), lower_omp_single(), lower_omp_teams(), make_dispatcher_decl(), mark_all_vars_used_1(), mark_scope_block_unused(), merge_weak(), need_assembler_name_p(), new_emutls_decl(), print_node(), reference_to_unused(), remap_block(), remove_unused_locals(), remove_unused_scope_block_p(), ipa_param_body_adjustments::reset_debug_stmts(), rtx_for_function_call(), weak_finish(), weak_finish_1(), and wrapup_global_declaration_2().

◆ TREE_VALUE

#define TREE_VALUE ( NODE ) (TREE_LIST_CHECK (NODE)->list.value)

Referenced by add_ehspec_entry(), alloc_object_size(), attr_access::array_as_string(), assign_filter_values(), attribute_list_contained(), attribute_value_equal(), bit_value_assume_aligned(), block_move_libcall_safe_for_call_parm(), build_adjusted_function_type(), build_builtin_expect_predicate(), build_constructor_from_list(), build_tm_store(), build_tree_list(), builtin_mathfn_code(), check_fnspec(), cleanup_dead_labels(), collect_one_action_chain(), common_function_versions(), ipa_icf_gimple::func_checker::compare_asm_inputs_outputs(), ipa_icf_gimple::func_checker::compare_gimple_asm(), contains_placeholder_p(), copy_tree_body_r(), count_num_arguments(), create_coalesce_list_for_region(), create_task_copyfn(), cgraph_node::create_version_clone_with_body(), decl_attributes(), decl_class_context(), decl_fnspec(), decl_function_context(), dequeue_and_dump(), device_resident_p(), DFS::DFS_write_tree_body(), diagnose_sb_0(), do_assemble_alias(), dump_function_declaration(), dump_function_to_file(), dump_generic_node(), dump_omp_clause(), eliminate_dom_walker::eliminate_stmt(), ipa_icf::sem_function::equals_wpa(), error_unavailable_use(), execute_oacc_loop_designation(), execute_update_addresses_taken(), expand_asm_stmt(), expand_builtin_int_roundingfn_2(), expand_complex_asm(), expand_expr_real_1(), expand_oacc_collapse_init(), expand_omp_atomic_store(), expand_simd_clones(), expand_target_clones(), find_func_aliases(), find_placeholder_in_expr(), fndecl_alloc_p(), fndecl_dealloc_argno(), fold_builtin_atomic_compare_exchange(), ccp_folder::fold_stmt(), fold_stmt_1(), attr_access::free_lang_data(), function_args_iter_cond(), function_args_iter_cond_ptr(), gen_eh_region_allowed(), gen_eh_region_catch(), gen_generic_params_dies(), get_alias_symbol(), operands_scanner::get_asm_stmt_operands(), get_attr_str(), get_attribute_name(), get_call_args(), get_nonnull_args(), get_strub_mode_from_attr(), get_target_clone_attr_len(), gimple_asm_clobbers_memory_p(), gimple_builtin_call_types_compatible_p(), gimple_call_alloc_size(), gimple_call_fnspec(), gimple_canonical_types_compatible_p(), gimple_fold_call(), gimple_redirect_edge_and_branch(), gimple_regimplify_operands(), gimplify_asm_expr(), gimplify_bind_expr(), gimplify_init_ctor_preeval_1(), gimplify_omp_affinity(), gimplify_omp_depend(), gimplify_omp_for(), gimplify_omp_loop(), gimplify_omp_ordered(), globalize_decl(), go_output_typedef(), strlen_pass::handle_builtin_strcat(), strlen_pass::handle_builtin_strcpy(), ehspec_hasher::hash(), operand_compare::hash_operand(), hash_tree(), infer_nonnull_range_by_attribute(), init_attr_rdwr_indices(), input_eh_region(), input_gimple_stmt(), instrument_builtin_call(), ipa_get_callee_param_type(), ipa_odr_summary_write(), is_function_default_version(), lookup_attribute_spec(), lookup_descr_for_decl(), lower_eh_dispatch(), lower_omp_ordered_clauses(), lower_omp_task_reductions(), lower_private_allocate(), lto_input_eh_catch_list(), lto_input_ts_list_tree_pointers(), make_gimple_asm_edges(), mark_transaction_restart_calls(), matching_alloc_calls_p(), maybe_canonicalize_argtypes(), maybe_remove_unused_call_args(), merge_weak(), ipa_param_body_adjustments::modify_gimple_stmt(), nonnull_arg_p(), oacc_do_neutering(), oacc_fn_attrib_level(), oacc_get_fn_dim_size(), oacc_validate_dims(), oacc_verify_routine_clauses(), obj_type_ref_class(), odr_or_derived_type_p(), odr_types_equivalent_p(), ok_for_auto_simd_clone(), omp_construct_selector_matches(), omp_discover_declare_target_tgt_fn_r(), omp_lto_input_declare_variant_alt(), omp_lto_output_declare_variant_alt(), omp_mark_declare_variant(), omp_notice_variable(), omp_resolve_declare_variant(), op_iter_next_def(), op_iter_next_tree(), optimize_atomic_compare_exchange_p(), prepare_call_arguments(), print_node(), process_pending_assemble_externals(), process_symver_attribute(), propagate_necessity(), push_function_arg_types(), rt_bb_visited::push_rtcfg_pair(), reconstruct_complex_type(), record_type_list(), cgraph_edge::redirect_call_stmt_to_callee(), remove_attributes_matching(), remove_named_attribute_unsharing(), resolve_asm_operand_names(), resolve_operand_name_1(), rest_of_decl_compilation(), restrict_type_identity_attributes_to(), rt_bb_visited::rt_bb_visited(), safe_from_p(), sanitize_flags_p(), scan_function(), scan_omp_1_op(), scan_omp_for(), simd_clone_clauses_extract(), simple_cst_list_equal(), sorted_attr_string(), split_complex_types(), sra_modify_function_body(), substitute_in_expr(), substitute_placeholder_in_expr(), tree_builtin_call_types_compatible_p(), tree_cons(), type_hash_canon_hash(), type_list_equal(), type_num_arguments(), useless_type_conversion_p(), value_member(), vect_build_one_gather_load_call(), vect_build_one_scatter_store_call(), verify_type(), walk_gimple_asm(), walk_stmt_load_store_addr_ops(), walk_tree_1(), walk_type_fields(), warn_deprecated_use(), warn_types_mismatch(), weak_finish(), and write_ts_list_tree_pointers().

◆ TREE_VEC_BEGIN

#define TREE_VEC_BEGIN ( NODE ) (&TREE_VEC_CHECK (NODE)->vec.a[0])

Referenced by tree_vec_range::begin().

◆ TREE_VEC_ELT

#define TREE_VEC_ELT	(		NODE,
			I ) TREE_VEC_ELT_CHECK (NODE, I)

◆ TREE_VEC_ELT_CHECK

#define TREE_VEC_ELT_CHECK	(		T,
			I ) ((T)->vec.a[I])

◆ TREE_VEC_END

#define TREE_VEC_END ( NODE ) ((void) TREE_VEC_CHECK (NODE), &((NODE)->vec.a[(NODE)->base.u.length]))

Referenced by tree_vec_range::end().

◆ TREE_VEC_LENGTH

#define TREE_VEC_LENGTH ( NODE ) (TREE_VEC_CHECK (NODE)->base.u.length)

In a TREE_VEC node.

Referenced by bundle_sizes(), simplify_using_ranges::cleanup_edges_and_switches(), dequeue_and_dump(), DFS::DFS_write_tree_body(), dump_generic_node(), emit_phi_nodes(), gen_generic_params_dies(), gimplify_omp_for(), gimplify_omp_loop(), grow_tree_vec(), operand_compare::hash_operand(), hash_tree(), lto_input_ts_vec_tree_pointers(), make_tree_vec(), object_sizes_get(), print_node(), propagate_unknowns(), streamer_write_tree_header(), template_parameter_pack_die(), tree_size(), verify_type(), walk_tree_1(), and write_ts_vec_tree_pointers().

◆ tree_vec_map_eq

#define tree_vec_map_eq tree_map_base_eq

◆ tree_vec_map_hash

#define tree_vec_map_hash tree_decl_map_hash

◆ tree_vec_map_marked_p

#define tree_vec_map_marked_p tree_map_base_marked_p

◆ TREE_VISITED

#define TREE_VISITED ( NODE ) ((NODE)->base.visited)

Used to keep track of visited nodes in tree traversals.  This is set to
0 by copy_node and make_node.

Referenced by copy_if_shared_r(), copy_node(), delete_trivially_dead_insns(), insn_live_p(), lower_gimple_bind(), print_node(), sink_common_stores_to_bb(), ssa_name_maybe_undef_p(), ssa_name_set_maybe_undef(), unmark_visited_r(), variably_modified_type_p(), verify_ssa(), and verify_use().

◆ TRY_CATCH_IS_CLEANUP

#define TRY_CATCH_IS_CLEANUP ( NODE ) (TRY_CATCH_EXPR_CHECK (NODE)->base.static_flag)

In a TRY_CATCH_EXPR, means that the handler should be considered a
separate cleanup in honor_protect_cleanup_actions.

Referenced by gimplify_expr().

◆ TYPE_ADDR_SPACE

#define TYPE_ADDR_SPACE ( NODE ) (TYPE_CHECK (NODE)->base.u.bits.address_space)

The address space the type is in.

Referenced by addr_offset_valid_p(), asan_protect_global(), build_array_type_1(), build_pointer_type_for_mode(), build_ref_for_model(), build_ref_for_offset(), build_reference_type_for_mode(), check_loadstore(), computation_cost(), compute_objsize_r(), const_unop(), convert_to_pointer_1(), create_mem_ref_raw(), dse_optimize_call(), dump_generic_node(), ipa_icf::sem_variable::equals_wpa(), expand_assignment(), expand_debug_expr(), expand_expr_addr_expr(), expand_expr_real_1(), expand_expr_real_2(), find_single_drs(), fold_convert_loc(), function_and_variable_visibility(), get_address_cost(), get_builtin_sync_mem(), get_memory_rtx(), get_related_vectype_for_scalar_type(), get_use_type(), get_variable_section(), gimple_canonical_types_compatible_p(), gimplify_modify_expr(), gimplify_modify_expr_to_memcpy(), gimplify_modify_expr_to_memset(), hash_tree(), instrument_derefs(), instrument_expr(), instrument_mem_ref(), make_decl_rtl(), make_tree(), mem_ref_valid_without_offset_p(), modified_type_die(), most_expensive_mult_to_index(), move_hint_to_base(), non_null_loadstore(), odr_types_equivalent_p(), operand_compare::operand_equal_p(), output_constant(), pack_ts_base_value_fields(), preferred_mem_scale_factor(), print_node(), print_node_brief(), produce_memory_decl_rtl(), promote_mode(), runtime_alias_check_p(), set_mem_attributes_minus_bitpos(), set_type_quals(), tree_nop_conversion_p(), ubsan_expand_null_ifn(), unpack_ts_base_value_fields(), useless_type_conversion_p(), valid_mem_ref_cand_p(), and verify_gimple_assign_unary().

◆ TYPE_ALIAS_SET

#define TYPE_ALIAS_SET ( NODE ) (TYPE_CHECK (NODE)->type_common.alias_set)

The (language-specific) typed-based alias set for this type.
Objects whose TYPE_ALIAS_SETs are different cannot alias each
other.  If the TYPE_ALIAS_SET is -1, no alias set has yet been
assigned to this type.  If the TYPE_ALIAS_SET is 0, objects of this
type can alias objects of any type.

Referenced by alias_set_subset_of(), alias_sets_conflict_p(), asan_init_shadow_ptr_types(), build_opaque_vector_type(), build_variant_type_copy(), get_alias_set(), make_node(), print_node(), and rt_bb_visited::rt_bb_visited().

◆ TYPE_ALIAS_SET_KNOWN_P

#define TYPE_ALIAS_SET_KNOWN_P ( NODE ) (TYPE_CHECK (NODE)->type_common.alias_set != -1)

Nonzero iff the typed-based alias set for this type has been
calculated.

Referenced by get_alias_set(), layout_type(), and verify_type_variant().

◆ TYPE_ALIGN

#define TYPE_ALIGN ( NODE )

Value:

(TYPE_ALIGN_RAW (NODE) \

? ((unsigned)1) << (TYPE_ALIGN_RAW(NODE) - 1) : 0)

TYPE_ALIGN_RAW

#define TYPE_ALIGN_RAW(NODE)

Definition tree.h:2320

The alignment necessary for objects of this type.
The value is an int, measured in bits and must be a power of two.
We support also an "alignment" of zero.

Referenced by align_local_variable(), align_variable(), assign_parm_adjust_stack_rtl(), assign_parm_setup_reg(), assign_parm_setup_stack(), assign_parms(), assign_parms_unsplit_complex(), build_aligned_type(), build_qualified_type(), build_range_type_1(), build_ref_for_offset(), build_var(), check_aligned_type(), check_base_type(), clear_padding_flush(), clear_padding_type(), compute_avail(), compute_record_mode(), copy_blkmode_from_reg(), copy_blkmode_to_reg(), default_preferred_vector_alignment(), defer_stack_allocation(), dequeue_and_dump(), do_type_align(), dump_generic_node(), dump_mem_ref(), type_cache_hasher::equal(), expand_builtin_va_copy(), expand_call(), expand_call_mem_ref(), expand_constructor(), expand_expr_addr_expr_1(), expand_expr_real_1(), expand_function_start(), expand_omp_for_static_nochunk(), expand_one_ssa_partition(), expand_one_var(), fill_vector_of_new_param_types(), finalize_record_size(), finalize_type_size(), finish_builtin_struct(), finish_taskreg_scan(), fold_builtin_atomic_always_lock_free(), fold_truth_andor_1(), fold_unary_loc(), gather_mem_refs_stmt(), get_chain_field(), get_descriptor_type(), get_mem_align_offset(), get_nl_goto_field(), get_object_alignment_2(), get_references_in_stmt(), get_temp_reg(), get_vec_alignment_for_array_type(), get_vec_alignment_for_type(), gimple_can_coalesce_p(), gimple_fold_builtin_clear_padding(), gimple_fold_builtin_memory_op(), gimple_fold_partial_load_store_mem_ref(), gimplify_expr(), gimplify_init_constructor(), go_format_type(), handle_warn_if_not_align(), hash_tree(), initialize_argument_information(), insert_field_into_struct(), install_var_field(), install_var_field(), layout_decl(), layout_type(), lhd_simulate_enum_decl(), lookup_field_for_decl(), lower_omp_target(), lower_omp_task_reductions(), lower_rec_input_clauses(), may_be_unaligned_p(), maybe_canonicalize_mem_ref_addr(), min_align_of_type(), ipa_param_adjustments::modify_call(), nonoverlapping_array_refs_p(), offset_int_type_size_in_bits(), omp_finish_file(), operand_compare::operand_equal_p(), optimize_bit_field_compare(), pack_ts_type_common_value_fields(), place_field(), print_node(), prune_ref_by_group_reuse(), replace_ref(), rewrite_use_address(), scan_sharing_clauses(), set_mem_attributes_minus_bitpos(), set_parm_rtl(), simple_type_align_in_bits(), simple_type_size_in_bits(), sjlj_build_landing_pads(), start_record_layout(), std_gimplify_va_arg_expr(), target_align(), type_variants_equivalent_p(), unpack_ts_type_common_value_fields(), update_alignment_for_field(), vectorizable_load(), vectorizable_store(), and verify_opaque_type().

◆ TYPE_ALIGN_RAW

#define TYPE_ALIGN_RAW ( NODE ) (TYPE_CHECK (NODE)->type_common.align)

Raw access to the alignment field.

◆ TYPE_ALIGN_UNIT

#define TYPE_ALIGN_UNIT ( NODE ) (TYPE_ALIGN (NODE) / BITS_PER_UNIT)

The alignment for NODE, in bytes.

Referenced by array_ref_element_size(), build_printable_array_type(), compute_alias_check_pairs(), copy_reference_ops_from_ref(), create_array_ref(), default_cxx_get_cookie_size(), expand_omp_atomic(), expand_omp_for_static_nochunk(), expand_omp_scantemp_alloc(), finalize_record_size(), finalize_type_size(), finish_taskreg_scan(), get_related_vectype_for_scalar_type(), gimplify_compound_lval(), gimplify_scan_omp_clauses(), go_format_type(), infer_loop_bounds_from_pointer_arith(), layout_type(), lower_coro_builtin(), lower_omp_target(), lower_omp_task_reductions(), lower_private_allocate(), oacc_do_neutering(), omp_clause_aligned_alignment(), ompdevlow_adjust_simt_enter(), and vect_known_alignment_in_bytes().

◆ TYPE_ARG_TYPES

#define TYPE_ARG_TYPES ( NODE ) (FUNC_OR_METHOD_CHECK (NODE)->type_non_common.values)

Referenced by block_move_libcall_safe_for_call_parm(), build_adjusted_function_type(), build_builtin_expect_predicate(), build_function_type(), build_method_type(), build_method_type_directly(), ipa_param_adjustments::build_new_function_type(), build_tm_store(), builtin_mathfn_code(), can_strub_internally_p(), check_fnspec(), ipa_param_body_adjustments::common_initialization(), count_num_arguments(), decl_class_context(), decl_function_context(), dequeue_and_dump(), DFS::DFS_write_tree_body(), dump_function_declaration(), eliminate_dom_walker::eliminate_stmt(), type_cache_hasher::equal(), ipa_icf::sem_function::equals_wpa(), expand_builtin_int_roundingfn_2(), expand_call(), expand_omp_atomic_store(), expand_simd_clones(), fold_builtin_atomic_compare_exchange(), ccp_folder::fold_stmt(), function_args_iter_init(), get_call_args(), gimple_builtin_call_types_compatible_p(), gimple_canonical_types_compatible_p(), gimple_fold_call(), gimplify_call_expr(), gimplify_init_ctor_preeval_1(), strlen_pass::handle_builtin_strcat(), strlen_pass::handle_builtin_strcpy(), hash_tree(), instrument_builtin_call(), ipa_get_callee_param_type(), lower_omp_task_reductions(), lower_resx(), lto_input_ts_type_non_common_tree_pointers(), make_dispatcher_decl(), maybe_diag_incompatible_alias(), maybe_remove_unused_call_args(), ipa_param_body_adjustments::modify_formal_parameters(), obj_type_ref_class(), odr_or_derived_type_p(), odr_types_equivalent_p(), ok_for_auto_simd_clone(), optimize_atomic_compare_exchange_p(), prepare_call_arguments(), print_node(), prototype_p(), push_function_arg_types(), reconstruct_complex_type(), cgraph_edge::redirect_call_stmt_to_callee(), remap_type_1(), rt_bb_visited::rt_bb_visited(), simd_clone_adjust_argument_types(), simd_clone_vector_of_formal_parm_types(), thunk_adjust(), tree_builtin_call_types_compatible_p(), type_hash_canon_hash(), type_num_arguments(), useless_type_conversion_p(), vect_build_one_gather_load_call(), vect_build_one_scatter_store_call(), verify_type(), verify_type_variant(), walk_type_fields(), warn_types_mismatch(), and write_ts_type_non_common_tree_pointers().

◆ TYPE_ARRAY_MAX_SIZE

#define TYPE_ARRAY_MAX_SIZE ( ARRAY_TYPE ) (ARRAY_TYPE_CHECK (ARRAY_TYPE)->type_non_common.maxval)

If non-NULL, this is an upper bound of the size (in bytes) of an
object of the given ARRAY_TYPE_NON_COMMON.  This allows temporaries to be
allocated.

Referenced by max_int_size_in_bytes(), safe_from_p(), verify_type(), and verify_type_variant().

◆ TYPE_ARTIFICIAL

#define TYPE_ARTIFICIAL ( NODE ) (TYPE_CHECK (NODE)->base.nowarning_flag)

Used to indicate that this TYPE represents a compiler-generated entity.

Referenced by asan_global_struct(), finalize_record_size(), hash_tree(), modified_type_die(), need_assembler_name_p(), oacc_do_neutering(), ompdevlow_adjust_simt_enter(), pack_ts_base_value_fields(), place_field(), scan_omp_parallel(), scan_omp_target(), scan_omp_task(), scan_omp_teams(), ubsan_create_data(), ubsan_get_source_location_type(), ubsan_get_type_descriptor_type(), unpack_ts_base_value_fields(), and verify_type_variant().

◆ TYPE_ATOMIC

#define TYPE_ATOMIC ( NODE ) (TYPE_CHECK (NODE)->base.u.bits.atomic_flag)

Nonzero in a type considered atomic as a whole.

Referenced by gimplify_adjust_omp_clauses(), gimplify_adjust_omp_clauses_1(), plausible_type_for_simd_clone(), print_node(), set_type_quals(), simd_clone_clauses_extract(), ubsan_type_descriptor(), and use_pointer_for_field().

◆ TYPE_ATTRIBUTES

#define TYPE_ATTRIBUTES ( NODE ) (TYPE_CHECK (NODE)->type_common.attributes)

A TREE_LIST of IDENTIFIER nodes of the attributes that apply
to this type.

Referenced by alloc_object_size(), build_adjusted_function_type(), build_pointer_type_for_mode(), build_reference_type_for_mode(), build_type_attribute_qual_variant(), check_aligned_type(), strlen_pass::check_and_optimize_call(), check_base_type(), comp_type_attributes(), compute_fn_summary(), decl_attributes(), decl_fnspec(), decls_mismatched_attributes(), DFS::DFS_write_tree_body(), diag_attr_exclusions(), do_warn_unused_result(), dump_function_to_file(), type_cache_hasher::equal(), error_unavailable_use(), evaluate_stmt(), flags_from_decl_or_type(), get_attrs_for(), get_nonnull_args(), get_parm_access(), get_strub_attr_from_type(), gimple_build_call_from_tree(), gimple_call_alloc_size(), gimple_call_fnspec(), gimple_call_nonnull_result_p(), handle_warn_if_not_align(), hash_tree(), infer_nonnull_range_by_attribute(), lto_input_ts_type_common_tree_pointers(), make_node(), make_vector_type(), maybe_warn_pass_by_reference(), maybe_warn_read_write_only(), merge_type_attributes(), nonnull_arg_p(), print_node(), reconstruct_complex_type(), remap_type_1(), strub_set_fndt_mode_to(), surely_varying_stmt_p(), tree_expr_nonzero_warnv_p(), type_hash_canon_hash(), unlikely_executed_stmt_p(), useless_type_conversion_p(), warn_deprecated_use(), and write_ts_type_common_tree_pointers().

◆ TYPE_BINFO

#define TYPE_BINFO ( NODE ) (RECORD_OR_UNION_CHECK (NODE)->type_non_common.maxval)

For record and union types, information about this type, as a base type
for itself.

Referenced by add_type_duplicate(), build_type_inheritance_graph(), compare_virtual_tables(), contains_polymorphic_type_p(), decl_maybe_in_construction_p(), dequeue_and_dump(), detect_type_change_from_memory_writes(), extr_type_from_vtbl_ptr_store(), ipa_polymorphic_call_context::get_dynamic_type(), get_odr_type(), inbounds_memaccess_p(), odr_types_equivalent_p(), polymorphic_type_binfo_p(), possible_placement_new(), possible_polymorphic_call_targets(), possible_polymorphic_call_targets_1(), record_known_type(), record_targets_from_bases(), register_odr_type(), ipa_polymorphic_call_context::restrict_to_inner_class(), set_type_binfo(), type_possibly_instantiated_p(), verify_bb_vtables(), verify_type(), verify_type_variant(), virtual_method_call_p(), and vtable_pointer_value_to_binfo().

◆ TYPE_CACHED_VALUES

#define TYPE_CACHED_VALUES ( NODE ) (TYPE_CHECK (NODE)->type_non_common.values)

Referenced by cache_integer_cst(), cache_wide_int_in_type_cache(), copy_node(), type_hash_canon(), and verify_type().

◆ TYPE_CACHED_VALUES_P

#define TYPE_CACHED_VALUES_P ( NODE ) (TYPE_CHECK (NODE)->base.public_flag)

In a _TYPE, indicates whether TYPE_CACHED_VALUES contains a vector
of cached values, or is something else.

Referenced by cache_integer_cst(), cache_wide_int_in_type_cache(), copy_node(), type_hash_canon(), and verify_type().

◆ TYPE_CANONICAL

#define TYPE_CANONICAL ( NODE ) (TYPE_CHECK (NODE)->type_common.canonical)

The "canonical" type for this type node, which is used by frontends to
compare the type for equality with another type.  If two types are
equal (based on the semantics of the language), then they will have
equivalent TYPE_CANONICAL entries.

As a special case, if TYPE_CANONICAL is NULL_TREE, and thus
TYPE_STRUCTURAL_EQUALITY_P is true, then it cannot
be used for comparison against other types.  Instead, the type is
said to require structural equality checks, described in
TYPE_STRUCTURAL_EQUALITY_P.

For unqualified aggregate and function types the middle-end relies on
TYPE_CANONICAL to tell whether two variables can be assigned
to each other without a conversion.  The middle-end also makes sure
to assign the same alias-sets to the type partition with equal
TYPE_CANONICAL of their unqualified variants.

Referenced by build_array_type_1(), build_complex_type(), build_distinct_type_copy(), build_duplicate_type(), build_function_type(), build_method_type_directly(), build_offset_type(), build_opaque_vector_type(), build_pointer_type_for_mode(), build_qualified_type(), build_reference_type_for_mode(), build_type_attribute_qual_variant(), build_variant_type_copy(), get_alias_set(), get_odr_type(), gimple_canonical_types_compatible_p(), go_output_typedef(), lto_input_ts_type_common_tree_pointers(), lto_read_body_or_constructor(), make_node(), make_vector_type(), maybe_canonicalize_argtypes(), ncr_type_uid(), obj_type_ref_class(), pack_ts_type_common_value_fields(), print_node(), same_strub_mode_in_variants_p(), same_type_for_tbaa(), set_type_canonical_for_odr_type(), types_equal_for_same_type_for_tbaa_p(), useless_type_conversion_p(), verify_opaque_type(), and verify_type().

◆ TYPE_CHECK

#define TYPE_CHECK ( T ) TREE_CLASS_CHECK (T, tcc_type)

◆ TYPE_CONTAINS_PLACEHOLDER_INTERNAL

#define TYPE_CONTAINS_PLACEHOLDER_INTERNAL ( NODE ) (TYPE_CHECK (NODE)->type_common.contains_placeholder_bits)

Used by type_contains_placeholder_p to avoid recomputation.
Values are: 0 (unknown), 1 (false), 2 (true).  Never access
this field directly.

Referenced by type_contains_placeholder_p().

◆ TYPE_CONTEXT

#define TYPE_CONTEXT ( NODE ) (TYPE_CHECK (NODE)->type_common.context)

Referenced by add_pubtype(), build_adjusted_function_type(), check_aligned_type(), check_base_type(), declare_in_namespace(), DFS::DFS_write_tree_body(), dump_type_inheritance_graph(), get_containing_scope(), hash_tree(), loc_list_from_tree_1(), lto_input_ts_type_common_tree_pointers(), maybe_create_die_with_external_ref(), new_die(), print_node(), type_with_linkage_p(), verify_type_variant(), and write_ts_type_common_tree_pointers().

◆ TYPE_CXX_ODR_P

#define TYPE_CXX_ODR_P ( NODE ) (RECORD_OR_UNION_CHECK (NODE)->type_common.string_flag)

If set for RECORD_TYPE or UNION_TYPE it indicates that the type conforms
to the C++ one definition rule.  This is used for LTO canonical type
computation.

Referenced by hash_tree(), need_assembler_name_p(), pack_ts_type_common_value_fields(), print_node(), unpack_ts_type_common_value_fields(), and verify_type_variant().

◆ TYPE_DECL_SUPPRESS_DEBUG

#define TYPE_DECL_SUPPRESS_DEBUG ( NODE ) (TYPE_DECL_CHECK (NODE)->decl_common.decl_flag_1)

In a TYPE_DECL nonzero means the detail info about this type is not dumped
into stabs.  Instead it will generate cross reference ('x') of names.
This uses the same flag as DECL_EXTERNAL.

Referenced by print_node().

◆ TYPE_DOMAIN

#define TYPE_DOMAIN ( NODE ) (ARRAY_TYPE_CHECK (NODE)->type_non_common.values)

Referenced by addr_object_size(), array_ref_flexible_size_p(), array_ref_low_bound(), array_ref_up_bound(), array_size_for_constructor(), array_type_nelts(), build_array_type_1(), build_fn_info(), build_info(), build_user_friendly_ref_for_offset(), canonicalize_addr_expr(), cheap_array_ref_low_bound(), array_bounds_checker::check_addr_expr(), component_ref_sam_type(), create_component_ref_by_pieces_1(), dequeue_and_dump(), DFS::DFS_write_tree_body(), dump_generic_node(), type_cache_hasher::equal(), expand_omp_target(), find_constructor_constant_at_offset(), flexible_array_member_p(), flexible_array_type_p(), fold_array_ctor_reference(), fold_indirect_ref_1(), get_array_ctor_element_at_index(), get_range_strlen_tree(), gimple_canonical_types_compatible_p(), gimple_fold_indirect_ref(), gimple_get_virt_method_for_vtable(), gimplify_init_ctor_eval(), gimplify_scan_omp_clauses(), gimplify_type_sizes(), go_format_type(), hash_tree(), is_empty_type(), layout_type(), lower_omp_task_reductions(), lower_rec_input_clauses(), lower_reduction_clauses(), lto_input_ts_type_non_common_tree_pointers(), maybe_warn_nonstring_arg(), native_encode_initializer(), native_interpret_aggregate(), note_nonlocal_vla_type(), odr_types_equivalent_p(), omp_firstprivatize_type_sizes(), output_constructor(), output_constructor_regular_field(), prepare_iteration_over_array_elts(), print_declaration(), print_node(), range_in_array_bounds_p(), reconstruct_complex_type(), remap_type_1(), remap_type_2(), rtl_for_decl_init(), simd_clone_adjust(), simd_clone_init_simd_arrays(), store_constructor(), totally_scalarizable_type_p(), totally_scalarize_subtree(), type_contains_placeholder_1(), type_hash_canon_hash(), ubsan_type_descriptor(), useless_type_conversion_p(), verify_type(), verify_type_variant(), vn_reference_may_trap(), walk_type_fields(), warn_types_mismatch(), and write_ts_type_non_common_tree_pointers().

◆ TYPE_EMPTY_P

#define TYPE_EMPTY_P ( NODE ) (TYPE_CHECK (NODE)->type_common.empty_flag)

Nonzero if this type is "empty" according to the particular psABI.

Referenced by aggregate_value_p(), arg_int_size_in_bytes(), arg_size_in_bytes(), assign_parm_setup_block(), assign_parm_setup_stack(), assign_parms(), compute_argument_addresses(), expand_function_end(), finalize_type_size(), hash_tree(), must_pass_in_stack_var_size_or_pad(), pack_ts_type_common_value_fields(), std_gimplify_va_arg_expr(), store_one_arg(), and unpack_ts_type_common_value_fields().

◆ TYPE_FBIT

#define TYPE_FBIT ( NODE ) (GET_MODE_FBIT (TYPE_MODE (NODE)))

◆ TYPE_FIELDS

#define TYPE_FIELDS ( NODE ) (RECORD_OR_UNION_CHECK (NODE)->type_non_common.values)

Referenced by access_and_field_type_match_p(), asan_add_global(), asan_global_struct(), build_fn_info(), build_info(), build_user_friendly_ref_for_offset(), clear_padding_type(), clear_padding_union(), compute_record_mode(), contains_pointers_p(), contains_polymorphic_type_p(), count_type_elements(), create_odr_indicator(), create_task_copyfn(), default_emutls_var_init(), delete_omp_context(), dequeue_and_dump(), DFS::DFS_write_tree_body(), type_cache_hasher::equal(), field_at_offset(), fields_length(), finalize_nesting_tree_1(), finish_bitfield_layout(), finish_builtin_struct(), finish_taskreg_scan(), first_field(), fixup_child_record_type(), flexible_array_type_p(), get_binfo_at_offset(), get_descriptor_type(), get_emutls_object_type(), get_trampoline_type(), gimple_canonical_types_compatible_p(), gimplify_type_sizes(), go_format_type(), hash_tree(), init_eh(), insert_field_into_struct(), install_var_field(), is_empty_type(), last_field(), layout_type(), lower_omp_task_reductions(), lower_send_shared_vars(), lto_input_ts_type_non_common_tree_pointers(), native_encode_initializer(), native_interpret_aggregate(), odr_types_equivalent_p(), omp_firstprivatize_type_sizes(), output_constructor(), print_node(), print_struct_decl(), push_fields_onto_fieldstack(), record_common_node(), record_component_aliases(), record_targets_from_bases(), register_odr_type(), remap_type_1(), remap_type_2(), ipa_polymorphic_call_context::restrict_to_inner_class(), scan_omp_parallel(), scan_omp_single(), scan_omp_target(), scan_omp_task(), scan_omp_teams(), stack_protect_classify_type(), task_copyfn_remap_type(), totally_scalarizable_type_p(), totally_scalarize_subtree(), tracked_record_parameter_p(), type_contains_placeholder_1(), type_internals_preclude_sra_p_1(), type_like_member_ptr_p(), ubsan_create_data(), ubsan_get_source_location_type(), ubsan_get_type_descriptor_type(), variably_modified_type_p(), verify_type(), verify_type_variant(), walk_tree_1(), and write_ts_type_non_common_tree_pointers().

◆ TYPE_FILE_SCOPE_P

#define TYPE_FILE_SCOPE_P ( EXP ) SCOPE_FILE_SCOPE_P (TYPE_CONTEXT (EXP))

Nonzero for a type which is at file scope.

Referenced by hash_tree(), and verify_type_variant().

◆ TYPE_FINAL_P

#define TYPE_FINAL_P ( NODE ) (RECORD_OR_UNION_CHECK (NODE)->base.default_def_flag)

Nonzero if RECORD_TYPE represents a final derivation of class.

Referenced by hash_tree(), pack_ts_type_common_value_fields(), possible_polymorphic_call_targets(), type_all_derivations_known_p(), type_known_to_have_no_derivations_p(), unpack_ts_type_common_value_fields(), and verify_type_variant().

◆ TYPE_HASH

#define TYPE_HASH ( TYPE ) (TYPE_UID (TYPE))

Here is how primitive or already-canonicalized types' hash codes
are made.

Referenced by type_hash_canon_hash().

◆ TYPE_IBIT

#define TYPE_IBIT ( NODE ) (GET_MODE_IBIT (TYPE_MODE (NODE)))

◆ TYPE_IDENTIFIER

#define TYPE_IDENTIFIER ( NODE )

Value:

(TYPE_NAME (NODE) && DECL_P (TYPE_NAME (NODE)) \

? DECL_NAME (TYPE_NAME (NODE)) : TYPE_NAME (NODE))

TYPE_NAME

#define TYPE_NAME(NODE)

Definition tree.h:2248

The IDENTIFIER_NODE associated with the TYPE_NAME field.

Referenced by dump_generic_node(), gen_block_die(), gen_type_die(), go_format_type(), go_output_typedef(), is_cxx_auto(), modified_type_die(), and subrange_type_for_debug_p().

◆ TYPE_INCLUDES_FLEXARRAY

#define TYPE_INCLUDES_FLEXARRAY ( NODE ) (RECORD_OR_UNION_CHECK (NODE)->type_common.no_named_args_stdarg_p)

True if this RECORD_TYPE or UNION_TYPE includes a flexible array member
as the last field recursively.

Referenced by addr_object_size(), pack_ts_type_common_value_fields(), print_node(), and unpack_ts_type_common_value_fields().

◆ TYPE_INDIVISIBLE_P

#define TYPE_INDIVISIBLE_P ( NODE ) (TYPE_CHECK (NODE)->type_common.indivisible_p)

True if the type is indivisible at the source level, i.e. if its
component parts cannot be accessed directly.  This is used to suppress
normal GNU extensions for target-specific vector types.

◆ TYPE_LANG_FLAG_0

#define TYPE_LANG_FLAG_0 ( NODE ) (TYPE_CHECK (NODE)->type_common.lang_flag_0)

These flags are available for each language front end to use internally.

Referenced by lto_variably_modified_type_p(), pack_ts_type_common_value_fields(), print_node(), and unpack_ts_type_common_value_fields().

◆ TYPE_LANG_FLAG_1

#define TYPE_LANG_FLAG_1 ( NODE ) (TYPE_CHECK (NODE)->type_common.lang_flag_1)

Referenced by print_node().

◆ TYPE_LANG_FLAG_2

#define TYPE_LANG_FLAG_2 ( NODE ) (TYPE_CHECK (NODE)->type_common.lang_flag_2)

Referenced by print_node().

◆ TYPE_LANG_FLAG_3

#define TYPE_LANG_FLAG_3 ( NODE ) (TYPE_CHECK (NODE)->type_common.lang_flag_3)

Referenced by print_node().

◆ TYPE_LANG_FLAG_4

#define TYPE_LANG_FLAG_4 ( NODE ) (TYPE_CHECK (NODE)->type_common.lang_flag_4)

Referenced by print_node().

◆ TYPE_LANG_FLAG_5

#define TYPE_LANG_FLAG_5 ( NODE ) (TYPE_CHECK (NODE)->type_common.lang_flag_5)

Referenced by print_node().

◆ TYPE_LANG_FLAG_6

#define TYPE_LANG_FLAG_6 ( NODE ) (TYPE_CHECK (NODE)->type_common.lang_flag_6)

Referenced by print_node().

◆ TYPE_LANG_FLAG_7

#define TYPE_LANG_FLAG_7 ( NODE ) (TYPE_CHECK (NODE)->type_common.lang_flag_7)

Referenced by print_node().

◆ TYPE_LANG_SLOT_1

#define TYPE_LANG_SLOT_1 ( NODE ) (TYPE_CHECK (NODE)->type_non_common.lang_1)

For types, used in a language-dependent way.

Referenced by verify_type().

◆ TYPE_LANG_SPECIFIC

#define TYPE_LANG_SPECIFIC ( NODE ) (TYPE_CHECK (NODE)->type_with_lang_specific.lang_specific)

◆ TYPE_MAIN_VARIANT

#define TYPE_MAIN_VARIANT ( NODE ) (TYPE_CHECK (NODE)->type_common.main_variant)

Referenced by access_and_field_type_match_p(), add_type_duplicate(), alias_ptr_types_compatible_p(), tree_switch_conversion::switch_conversion::array_value_type(), build_aligned_type(), build_complex_type(), build_distinct_type_copy(), build_method_type_directly(), build_offset_type(), build_opaque_vector_type(), build_printable_array_type(), build_type_attribute_qual_variant(), build_type_inheritance_graph(), build_variant_type_copy(), build_vector_from_val(), canonicalize_addr_expr(), canonicalize_component_ref(), check_stmt_for_type_change(), ipa_polymorphic_call_context::clear_outer_type(), constant_byte_string(), contains_polymorphic_type_p(), contains_type_p(), contains_vce_or_bfcref_p(), convert_to_complex_1(), create_access_replacement(), create_tmp_from_val(), decl_attributes(), decl_class_context(), decl_function_context(), decl_maybe_in_construction_p(), default_is_empty_record(), dequeue_and_dump(), detect_type_change_from_memory_writes(), DFS::DFS_write_tree_body(), do_mpfr_lgamma_r(), do_mpfr_remquo(), dump_generic_node(), dump_mem_ref(), dump_possible_polymorphic_call_targets(), odr_name_hasher::equal(), expand_omp_atomic(), expand_omp_atomic_cas(), expand_omp_atomic_pipeline(), expand_thunk(), expand_vector_conversion(), finalize_type_size(), fold_builtin_frexp(), fold_builtin_modf(), fold_convert_loc(), fold_convertible_p(), ccp_folder::fold_stmt(), fold_unary_loc(), force_decl_die(), get_alias_set(), ipa_polymorphic_call_context::get_dynamic_type(), get_nearest_type_subqualifiers(), get_odr_type(), get_qualified_type(), gimple_canonical_types_compatible_p(), gimple_fold_builtin_memory_op(), gimple_signed_or_unsigned_type(), gimplify_expr(), gimplify_init_constructor(), gimplify_init_ctor_eval(), gimplify_omp_atomic(), gimplify_omp_taskloop_expr(), gimplify_type_sizes(), handle_mem_ref(), hash_odr_name(), operand_compare::hash_operand(), hash_tree(), int_size_in_bytes(), internal_get_tmp_var(), ipa_polymorphic_call_context::ipa_polymorphic_call_context(), is_va_list_type(), layout_type(), lhd_types_compatible_p(), local_tree_p(), lower_coro_builtin(), lto_input_ts_type_common_tree_pointers(), lto_read_body_or_constructor(), lto_variably_modified_type_p(), make_node(), make_ssa_name_fn(), make_vector_type(), mathfn_built_in_2(), maybe_canonicalize_mem_ref_addr(), maybe_warn_nonstring_arg(), modified_type_die(), ipa_param_body_adjustments::modify_call_stmt(), need_assembler_name_p(), odr_or_derived_type_p(), odr_subtypes_equivalent_p(), odr_types_equivalent_p(), omp_firstprivatize_type_sizes(), operand_compare::operand_equal_p(), optimize_stdarg_builtin(), optimize_va_list_gpr_fpr_size(), pack_ts_type_common_value_fields(), possible_polymorphic_call_targets(), record_known_type(), reference_alias_ptr_type(), reference_alias_ptr_type_1(), register_odr_type(), remap_type_1(), ipa_polymorphic_call_context::restrict_to_inner_class(), rt_bb_visited::rt_bb_visited(), same_access_path_p(), same_strub_mode_in_variants_p(), same_type_for_tbaa(), ipa_polymorphic_call_context::set_by_decl(), should_emit_struct_debug(), size_in_bytes_loc(), stack_protect_classify_type(), std_canonical_va_list_type(), substitute_placeholder_in_expr(), tree_builtin_call_types_compatible_p(), type_hash_canon(), type_main_variant(), type_with_linkage_p(), types_equal_for_same_type_for_tbaa_p(), types_match(), types_must_be_same_for_odr(), types_odr_comparable(), types_same_for_odr(), ubsan_type_descriptor(), ipa_icf::sem_item_optimizer::update_hash_by_addr_refs(), used_types_insert(), useless_type_conversion_p(), verify_bb_vtables(), verify_opaque_type(), verify_type(), verify_type_variant(), vn_reference_op_eq(), warn_deprecated_use(), warn_odr(), warn_types_mismatch(), and write_ts_type_common_tree_pointers().

◆ TYPE_MAX_VALUE

#define TYPE_MAX_VALUE ( NODE ) (NUMERICAL_TYPE_CHECK (NODE)->type_non_common.maxval)

Referenced by access_ref::add_max_offset(), access_ref::add_offset(), addr_object_size(), adjusted_warn_limit(), array_ref_flexible_size_p(), array_ref_up_bound(), array_type_nelts(), assert_loop_rolls_lt(), assert_no_overflow_lt(), build_bitint_type(), build_common_tree_nodes(), build_fn_info(), build_info(), build_nonstandard_integer_type(), build_range_type_1(), array_bounds_checker::check_addr_expr(), component_ref_sam_type(), dequeue_and_dump(), derive_constant_upper_bound_ops(), determine_block_size(), dr_step_indicator(), dump_array_domain(), tree_switch_conversion::jump_table_cluster::emit(), type_cache_hasher::equal(), expand_omp_target(), flexible_array_member_p(), flexible_array_type_p(), fold_comparison(), fold_convert_const_int_from_real(), fold_div_compare(), pass_walloca::gate(), get_array_ctor_element_at_index(), get_offset_range(), get_range_strlen_tree(), get_size_range(), get_stridx(), get_type_static_bounds(), get_up_bounds_for_array_ref(), gimple_call_alloc_size(), gimple_canonical_types_compatible_p(), gimplify_scan_omp_clauses(), gimplify_type_sizes(), go_format_type(), handle_array_ref(), strlen_pass::handle_builtin_strlen(), handle_mem_ref(), access_ref::inform_access(), init_offset_limit(), instrument_bool_enum_load(), int_fits_type_p(), layout_decl(), layout_type(), lhd_simulate_enum_decl(), lower_omp_target(), lower_omp_task_reductions(), lower_rec_input_clauses(), lower_reduction_clauses(), make_range_step(), max_object_size(), maybe_canonicalize_comparison_1(), maybe_diag_stxncpy_trunc(), maybe_set_strlen_range(), maybe_warn_nonstring_arg(), merge_ranges(), native_encode_initializer(), native_interpret_aggregate(), note_nonlocal_vla_type(), number_of_iterations_le(), number_of_iterations_lt_to_ne(), number_of_iterations_ne(), number_of_iterations_until_wrap(), odr_types_equivalent_p(), access_ref::offset_bounded(), access_ref::offset_in_range(), omp_extract_for_data(), omp_firstprivatize_type_sizes(), omp_reduction_init_op(), optimize_range_tests_1(), optimize_range_tests_diff(), optimize_range_tests_to_bit_test(), optimize_range_tests_xor(), output_constructor_regular_field(), prepare_iteration_over_array_elts(), preprocess_case_label_vec_for_gimple(), print_node(), range_check_type(), range_in_array_bounds_p(), range_successor(), refine_bounds_using_guard(), remap_type_1(), remap_type_2(), rtl_for_decl_init(), set_component_ref_size(), set_min_and_max_values_for_integral_type(), irange::set_nonnegative(), set_switch_stmt_execution_predicate(), simd_clone_adjust(), simd_clone_init_simd_arrays(), size_initval(), size_unknown(), store_constructor(), subrange_type_for_debug_p(), test_for_singularity(), totally_scalarizable_type_p(), try_transform_to_exit_first_loop_alt(), type_contains_placeholder_1(), type_hash_canon(), type_hash_canon_hash(), ubsan_type_descriptor(), useless_type_conversion_p(), valid_constant_size_p(), variably_modified_type_p(), vect_do_peeling(), vect_min_prec_for_max_niters(), vectorizable_reduction(), verify_type_variant(), vn_reference_may_trap(), walk_tree_1(), and warn_types_mismatch().

◆ TYPE_MAX_VALUE_RAW

#define TYPE_MAX_VALUE_RAW ( NODE ) (TYPE_CHECK (NODE)->type_non_common.maxval)

Referenced by DFS::DFS_write_tree_body(), hash_tree(), lto_input_ts_type_non_common_tree_pointers(), verify_type(), and write_ts_type_non_common_tree_pointers().

◆ TYPE_METHOD_BASETYPE

◆ TYPE_MIN_VALUE

#define TYPE_MIN_VALUE ( NODE ) (NUMERICAL_TYPE_CHECK (NODE)->type_non_common.minval)

Referenced by array_ref_flexible_size_p(), array_ref_low_bound(), array_size_for_constructor(), array_type_nelts(), assert_loop_rolls_lt(), assert_no_overflow_lt(), build_common_tree_nodes(), build_range_type_1(), build_user_friendly_ref_for_offset(), canonicalize_addr_expr(), cheap_array_ref_low_bound(), array_bounds_checker::check_addr_expr(), component_ref_sam_type(), create_component_ref_by_pieces_1(), dequeue_and_dump(), determine_block_size(), dr_step_indicator(), dump_array_domain(), dump_generic_node(), type_cache_hasher::equal(), expand_neg_overflow(), expand_omp_for_generic(), expand_omp_taskloop_for_inner(), expand_omp_taskloop_for_outer(), find_constructor_constant_at_offset(), flexible_array_member_p(), fold_array_ctor_reference(), fold_comparison(), fold_convert_const_int_from_real(), fold_div_compare(), fold_indirect_ref_1(), get_array_ctor_element_at_index(), get_offset_range(), get_size_range(), get_type_static_bounds(), gimple_canonical_types_compatible_p(), gimple_fold_indirect_ref(), gimple_get_virt_method_for_vtable(), gimplify_type_sizes(), go_format_type(), access_ref::inform_access(), instrument_bool_enum_load(), int_fits_type_p(), layout_type(), simplify_using_ranges::legacy_fold_cond_overflow(), lhd_simulate_enum_decl(), make_range_step(), maybe_canonicalize_comparison_1(), merge_ranges(), native_encode_initializer(), note_nonlocal_vla_type(), number_of_iterations_le(), number_of_iterations_lt_to_ne(), number_of_iterations_ne(), odr_types_equivalent_p(), access_ref::offset_bounded(), omp_extract_for_data(), omp_firstprivatize_type_sizes(), omp_reduction_init_op(), optimize_range_tests_1(), optimize_range_tests_diff(), optimize_range_tests_to_bit_test(), optimize_range_tests_xor(), output_constructor(), prepare_iteration_over_array_elts(), preprocess_case_label_vec_for_gimple(), print_node(), range_check_type(), range_in_array_bounds_p(), range_predecessor(), refine_bounds_using_guard(), remap_type_1(), remap_type_2(), rtl_for_decl_init(), set_min_and_max_values_for_integral_type(), set_switch_stmt_execution_predicate(), store_constructor(), subrange_type_for_debug_p(), test_for_singularity(), totally_scalarizable_type_p(), type_contains_placeholder_1(), type_hash_canon(), type_hash_canon_hash(), useless_type_conversion_p(), variably_modified_type_p(), vect_emulate_mixed_dot_prod(), vectorizable_reduction(), verify_type_variant(), and walk_tree_1().

◆ TYPE_MIN_VALUE_RAW

#define TYPE_MIN_VALUE_RAW ( NODE ) (TYPE_CHECK (NODE)->type_non_common.minval)

Referenced by DFS::DFS_write_tree_body(), hash_tree(), lto_input_ts_type_non_common_tree_pointers(), and write_ts_type_non_common_tree_pointers().

◆ TYPE_MODE

#define TYPE_MODE ( NODE )

Value:

(VECTOR_TYPE_P (TYPE_CHECK (NODE)) \

? vector_type_mode (NODE) : (NODE)->type_common.mode)

vector_type_mode

machine_mode vector_type_mode(const_tree)

Definition tree.cc:13429

TYPE_CHECK

#define TYPE_CHECK(T)

Definition tree.h:521

Referenced by add_autoinc_candidates(), add_iv_candidate_for_doloop(), add_iv_candidate_for_use(), add_mask_and_len_args(), add_rshift(), addr_offset_valid_p(), adjust_bool_pattern(), adjust_pointer_diff_expr(), aggregate_value_p(), align_local_variable(), analyze_candidates_and_replace(), ao_ref_init_from_vn_reference(), apply_pass_by_reference_rules(), array_elt_at_offset(), tree_switch_conversion::switch_conversion::array_value_type(), asan_emit_stack_protection(), assign_parm_find_data_types(), assign_parm_setup_reg(), assign_parms(), assign_temp(), associated_internal_fn(), avoid_type_punning_on_regs(), base_type_die(), block_move_libcall_safe_for_call_parm(), tree_switch_conversion::switch_conversion::build_arrays(), build_constant_desc(), build_debug_expr_decl(), build_gt(), build_lt(), build_minus_one_cst(), build_one_cst(), build_pointer_type_for_mode(), build_range_type_1(), build_real(), build_real_from_wide(), build_real_truncate(), build_reference_type_for_mode(), build_sinatan_real(), build_truth_vector_type_for(), build_zero_cst(), can_duplicate_and_interleave_p(), check_load_store_for_partial_vectors(), check_pow(), check_scan_store(), check_target_format(), classify_builtin_st(), clear_padding_real_needs_padding_p(), compare_by_pieces(), compare_constant(), computation_cost(), compute_record_mode(), const_binop(), const_vector_from_tree(), const_vector_mask_from_tree(), convert_expand_mult_copysign(), convert_mult_to_highpart(), convert_optab_supported_p(), convert_to_fixed(), convert_to_integer_1(), convert_to_real_1(), copy_blkmode_to_reg(), copy_decl_for_dup_finish(), strlen_pass::count_nonzero_bytes(), create_convert_operand_from_type(), create_mem_ref_raw(), default_preferred_div_as_shifts_over_mult(), default_ref_may_alias_errno(), default_return_in_memory(), default_vector_alignment(), detach_value(), determine_iv_cost(), direct_optab_supported_p(), directly_supported_p(), discover_nonconstant_array_refs_r(), divmod_candidate_p(), do_compare_and_jump(), do_jump(), do_jump_1(), do_mpc_arg2(), do_mpc_ckconv(), do_mpfr_ckconv(), do_mpfr_lgamma_r(), do_mpfr_remquo(), do_negate(), do_plus_minus(), do_store_flag(), dump_generic_node(), dump_mem_ref(), element_mode(), emit_block_cmp_via_loop(), emit_block_op_via_libcall(), emit_library_call_value_1(), type_cache_hasher::equal(), ipa_icf::sem_variable::equals(), estimate_move_cost(), exact_inverse(), excess_precision_type(), execute_cse_reciprocals_1(), execute_update_addresses_taken(), expand_asm_stmt(), expand_assignment(), expand_BITINTTOFLOAT(), expand_builtin(), expand_builtin_cexpi(), expand_builtin_fabs(), expand_builtin_goacc_parlevel_id_size(), expand_builtin_int_roundingfn(), expand_builtin_int_roundingfn_2(), expand_builtin_interclass_mathfn(), expand_builtin_issignaling(), expand_builtin_mathfn_3(), expand_builtin_mathfn_ternary(), expand_builtin_memcmp(), expand_builtin_memset_args(), expand_builtin_powi(), expand_builtin_signbit(), expand_builtin_sincos(), expand_builtin_strcmp(), expand_builtin_strncmp(), expand_builtin_unop(), expand_call(), expand_cmpstrn_or_cmpmem(), expand_complex_libcall(), expand_cond_expr_using_cmove(), expand_constructor(), expand_convert_optab_fn(), expand_debug_expr(), expand_DEFERRED_INIT(), expand_direct_optab_fn(), expand_DIVMOD(), expand_doubleword_mod(), expand_expr_addr_expr(), expand_expr_force_mode(), expand_expr_real_1(), expand_expr_real_2(), expand_expr_real_gassign(), expand_FLOATTOBITINT(), expand_fn_using_insn(), expand_function_end(), expand_function_start(), expand_gather_load_optab_fn(), expand_gimple_basic_block(), expand_gimple_stmt_1(), expand_GOMP_SIMT_LAST_LANE(), expand_GOMP_SIMT_ORDERED_PRED(), expand_GOMP_SIMT_VOTE_ANY(), expand_GOMP_SIMT_XCHG_BFLY(), expand_GOMP_SIMT_XCHG_IDX(), expand_ifn_atomic_bit_test_and(), expand_ifn_atomic_op_fetch_cmp_0(), expand_load_lanes_optab_fn(), expand_omp_atomic(), expand_omp_atomic_cas(), expand_omp_atomic_fetch_op(), expand_omp_atomic_pipeline(), expand_omp_atomic_store(), expand_omp_for_init_vars(), expand_one_ssa_partition(), expand_one_stack_var_at(), expand_one_var(), expand_partial_load_optab_fn(), expand_partial_store_optab_fn(), expand_POPCOUNT(), expand_pow_as_sqrts(), expand_RAWMEMCHR(), expand_return(), expand_scatter_store_optab_fn(), expand_sjlj_dispatch_table(), expand_SPACESHIP(), expand_speculation_safe_value(), expand_store_lanes_optab_fn(), expand_UADDC(), expand_unop(), expand_vec_cmp_expr(), expand_vec_cond_expr_p(), expand_vec_cond_mask_optab_fn(), expand_vec_cond_optab_fn(), expand_vec_set_optab_fn(), expand_vector_comparison(), expand_vector_condition(), expand_vector_conversion(), expand_vector_divmod(), expand_vector_operation(), expand_vector_operations_1(), expand_vector_parallel(), expand_vector_scalar_condition(), expand_vector_ubsan_overflow(), expand_while_optab_fn(), expand_widen_pattern_expr(), expr_size(), expression_expensive_p(), fill_vector_of_new_param_types(), finalize_must_preallocate(), finalize_type_size(), find_bitfield_repr_type(), float_widen_lhs_range(), frange::flush_denormals_to_zero(), fold_binary_loc(), fold_builtin_classify(), fold_builtin_fpclassify(), fold_builtin_inf(), fold_builtin_interclass_mathfn(), fold_const_builtin_nan(), fold_const_call_1(), fold_const_call_1(), fold_const_call_1(), fold_convert_const_real_from_real(), fold_plusminus_mult_expr(), cfn_sqrt::fold_range(), cfn_sincos::fold_range(), fold_read_from_constant_string(), fold_unary_loc(), force_expr_to_var_cost(), frange_arithmetic(), frange_mpfr_arg1(), gen_conditions_for_pow_cst_base(), generate_rawmemchr_builtin(), generate_strlen_builtin_using_rawmemchr(), get_address_cost(), get_call_args(), get_computation_cost(), get_compute_type(), get_inner_reference(), get_multi_vector_move(), get_no_error_domain(), get_ref_base_and_extent(), get_related_vectype_for_scalar_type(), get_same_sized_vectype(), get_vectype_for_scalar_type(), gimple_assign_unary_nop_p(), gimple_can_coalesce_p(), gimple_canonical_types_compatible_p(), gimple_expand_builtin_cabs(), gimple_expand_builtin_pow(), gimple_expand_vec_cond_expr(), gimple_expand_vec_set_extract_expr(), gimple_fold_builtin_memory_op(), gimple_fold_partial_load_store_mem_ref(), gimple_regimplify_operands(), gimple_signed_or_unsigned_type(), gimplify_expr(), gimplify_scalar_mode_aggregate_compare(), strlen_pass::handle_builtin_memcmp(), strlen_pass::handle_integral_assign(), hash_tree(), hashable_expr_equal_p(), hoist_adjacent_loads(), ifcvt_can_use_mask_load_store(), init_optabs(), initialize_argument_information(), initialize_sizetypes(), initializer_constant_valid_p_1(), inline_expand_builtin_bytecmp(), inline_string_cmp(), insert_debug_temp_for_var_def(), insert_value_copy_on_edge(), instrument_si_overflow(), int_binop_types_match_p(), integer_valued_real_single_p(), interclass_mathfn_icode(), interleave_supported_p(), internal_check_ptrs_fn_supported_p(), internal_gather_scatter_fn_supported_p(), frange::internal_singleton_p(), is_char_type(), is_truth_type_for(), layout_decl(), layout_type(), load_register_parameters(), loc_list_from_tree_1(), long_double_as_float128(), lower_oacc_reductions(), lower_vec_perm(), make_debug_expr_from_rtl(), make_range_step(), make_tree(), match_arith_overflow(), match_uaddc_usubc(), may_be_unaligned_p(), maybe_emit_group_store(), maybe_optimize_mod_cmp(), maybe_optimize_pow2p_mod_cmp(), mem_ref_valid_without_offset_p(), merge_ranges(), mode_for_array(), most_expensive_mult_to_index(), multi_vector_optab_supported_p(), narrowing_initializer_constant_valid_p(), native_encode_real(), non_rewritable_lvalue_p(), nontemporal_store_p(), odr_types_equivalent_p(), omp_clause_aligned_alignment(), omp_reduction_init_op(), cfn_sqrt::op1_range(), cfn_sincos::op1_range(), operand_compare::operand_equal_p(), optimize_atomic_bit_test_and(), optimize_atomic_compare_exchange_p(), optimize_atomic_op_fetch_cmp_0(), optimize_bitfield_assignment_op(), optimize_pow_to_exp(), optimize_range_tests_diff(), optimize_range_tests_xor(), optimize_spaceship(), optimize_vector_constructor(), output_constant(), pass_by_reference(), perm_mask_for_reverse(), phi_incr_cost_1(), plausible_type_for_simd_clone(), precompute_arguments(), precompute_register_parameters(), predicate_statements(), prepare_call_arguments(), prepare_cmp_insn(), print_node(), vrange_printer::print_real_value(), process_assignment(), promote_ssa_mode(), propagate_with_phi(), vn_walk_cb_data::push_partial_def(), range_compatible_p(), real_from_mpfr(), real_max_representable(), real_minus_onep(), real_onep(), real_value_from_int_cst(), real_zerop(), reassociate_bb(), reconstruct_complex_type(), remap_type_1(), remove_unused_ivs(), replace_uncond_cands_and_profitable_phis(), rtl_for_decl_init(), rtl_for_decl_location(), scan_store_can_perm_p(), frange::set(), set_parm_rtl(), set_reg_attrs_for_decl_rtl(), set_storage_via_libcall(), setup_incoming_promotions(), signed_or_unsigned_type_for(), avail_exprs_stack::simplify_binary_operation(), simplify_builtin_call(), simplify_using_ranges::simplify_float_conversion_using_ranges(), simplify_vector_constructor(), sjlj_build_landing_pads(), sjlj_emit_dispatch_table(), sjlj_emit_function_enter(), sjlj_mark_call_sites(), sort_by_mach_mode(), spaceship_replacement(), statement_sink_location(), std_gimplify_va_arg_expr(), stmt_cost(), store_constructor(), store_expr(), store_field(), store_one_arg(), strip_float_extensions(), supportable_convert_operation(), supportable_half_widening_operation(), supportable_narrowing_operation(), supportable_widening_operation(), target_has_vecop_for_code(), target_supports_op_p(), loop_distribution::transform_reduction_loop(), tree_add_const_value_attribute(), tree_nop_conversion_p(), try_store_by_multiple_pieces(), try_tablejump(), type_for_widest_vector_mode(), type_has_mode_precision_p(), ubsan_instrument_float_cast(), ubsan_type_descriptor(), undistribute_bitref_for_vector(), use_register_for_decl(), useless_type_conversion_p(), valid_mem_ref_cand_p(), validate_test_and_branch(), vcond_eq_icode_p(), vcond_icode_p(), vec_cmp_eq_icode_p(), vec_cmp_icode_p(), vect_build_all_ones_mask(), vect_build_one_gather_load_call(), vect_build_one_scatter_store_call(), vect_build_zero_merge_argument(), vect_check_gather_scatter(), vect_create_epilog_for_reduction(), vect_create_partial_epilog(), vect_determine_mask_precision(), vect_emulated_vector_p(), vect_enhance_data_refs_alignment(), vect_find_reusable_accumulator(), vect_gen_perm_mask_checked(), vect_get_loop_mask(), vect_get_vector_types_for_stmt(), vect_grouped_load_supported(), vect_grouped_store_supported(), vect_lanes_optab_supported_p(), vect_maybe_permute_loop_masks(), vect_model_reduction_cost(), vect_recog_bitfield_ref_pattern(), vect_recog_bool_pattern(), vect_recog_cast_forwprop_pattern(), vect_recog_divmod_pattern(), vect_recog_mixed_size_cond_pattern(), vect_recog_mult_pattern(), vect_recog_rotate_pattern(), vect_recog_vector_vector_shift_pattern(), vect_set_loop_condition_partial_vectors_avx512(), vect_shift_permute_load_chain(), vect_slp_region(), vect_supportable_direct_optab_p(), vect_supportable_dr_alignment(), vect_supportable_shift(), vect_synth_mult_by_constant(), vect_transform_cycle_phi(), vect_transform_grouped_load(), vect_transform_slp_perm_load_1(), vect_verify_full_masking_avx512(), vector_alignment_reachable_p(), vector_compare_rtx(), vector_vector_composition_type(), vectorizable_assignment(), vectorizable_bswap(), vectorizable_comparison_1(), vectorizable_condition(), vectorizable_early_exit(), vectorizable_live_operation(), vectorizable_load(), vectorizable_nonlinear_induction(), vectorizable_operation(), vectorizable_recurr(), vectorizable_reduction(), vectorizable_shift(), vectorizable_simd_clone_call(), vectorizable_slp_permutation_1(), vectorizable_store(), vectorized_internal_fn_supported_p(), verify_gimple_assign_binary(), verify_gimple_assign_ternary(), verify_gimple_assign_unary(), verify_opaque_type(), verify_type(), verify_type_variant(), verify_types_in_gimple_reference(), visit_reference_op_load(), vn_reference_lookup_3(), and vt_add_function_parameter().

◆ TYPE_MODE_RAW

#define TYPE_MODE_RAW ( NODE ) (TYPE_CHECK (NODE)->type_common.mode)

Referenced by get_inner_reference(), and pack_ts_type_common_value_fields().

◆ TYPE_NAME

#define TYPE_NAME ( NODE ) (TYPE_CHECK (NODE)->type_common.name)

Referenced by add_calling_convention_attribute(), add_type_duplicate(), asan_global_struct(), base_type_die(), build_complex_type(), check_aligned_type(), check_base_type(), compare_virtual_tables(), decl_attributes(), dequeue_and_dump(), DFS::DFS_write_tree_body(), dump_generic_node(), dump_odr_type(), dump_type_inheritance_graph(), odr_name_hasher::equal(), type_cache_hasher::equal(), error_unavailable_use(), finalize_nesting_tree_1(), finalize_record_size(), find_or_create_vtbl_map_node(), finish_builtin_struct(), fixup_child_record_type(), free_odr_warning_data(), generic_parameter_die(), get_descriptor_type(), get_emutls_object_type(), get_frame_type(), get_odr_name_for_type(), get_trampoline_type(), gimplify_type_sizes(), go_format_type(), go_output_typedef(), go_output_var(), go_type_decl(), hash_odr_name(), operand_compare::hash_operand(), hash_tree(), initialize_sizetypes(), ipa_devirt(), ipa_odr_summary_write(), lto_input_ts_type_common_tree_pointers(), member_declared_type(), modified_type_die(), need_assembler_name_p(), note_nonlocal_vla_type(), oacc_do_neutering(), odr_subtypes_equivalent_p(), odr_type_p(), print_node(), print_node_brief(), print_struct_decl(), remap_decl(), remap_vla_decls(), scan_omp_parallel(), scan_omp_single(), scan_omp_target(), scan_omp_task(), scan_omp_teams(), separate_decls_in_region(), strip_naming_typedef(), task_copyfn_remap_type(), type_all_derivations_known_p(), type_in_anonymous_namespace_p(), type_with_linkage_p(), typedef_variant_p(), types_same_for_odr(), ubsan_create_data(), ubsan_get_source_location_type(), ubsan_get_type_descriptor_type(), ubsan_type_descriptor(), ipa_icf::sem_item_optimizer::update_hash_by_addr_refs(), used_types_insert(), vtbl_map_get_node(), warn_deprecated_use(), warn_odr(), warn_types_mismatch(), and write_ts_type_common_tree_pointers().

◆ TYPE_NAMELESS

#define TYPE_NAMELESS ( NODE ) (TYPE_CHECK (NODE)->base.u.bits.nameless_flag)

If nonzero, type's name shouldn't be emitted into debug info.

Referenced by member_declared_type(), and ompdevlow_adjust_simt_enter().

◆ TYPE_NEEDS_CONSTRUCTING

#define TYPE_NEEDS_CONSTRUCTING ( NODE ) (TYPE_CHECK (NODE)->type_common.needs_constructing_flag)

Indicates that objects of this type must be initialized by calling a
function when they are created.

Referenced by analyze_functions(), omp_add_variable(), print_node(), and verify_type_variant().

◆ TYPE_NEXT_PTR_TO

#define TYPE_NEXT_PTR_TO ( NODE ) (POINTER_TYPE_CHECK (NODE)->type_non_common.minval)

Referenced by build_pointer_type_for_mode(), one_pointer_to_useless_type_conversion_p(), and verify_type().

◆ TYPE_NEXT_REF_TO

#define TYPE_NEXT_REF_TO ( NODE ) (REFERENCE_TYPE_CHECK (NODE)->type_non_common.minval)

Referenced by build_reference_type_for_mode(), and verify_type().

◆ TYPE_NEXT_VARIANT

◆ TYPE_NO_FORCE_BLK

#define TYPE_NO_FORCE_BLK ( NODE ) (TYPE_CHECK (NODE)->type_common.no_force_blk_flag)

In a RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE or ARRAY_TYPE, it means
the type has BLKmode only because it lacks the alignment required for
its size.

Referenced by compute_record_mode(), layout_type(), and print_node().

◆ TYPE_NO_NAMED_ARGS_STDARG_P

#define TYPE_NO_NAMED_ARGS_STDARG_P ( NODE ) (FUNC_OR_METHOD_CHECK (NODE)->type_common.no_named_args_stdarg_p)

True if this is a stdarg function with no named arguments (C23
(...) prototype, where arguments can be accessed with va_start and
va_arg), as opposed to an unprototyped function.

Referenced by assign_parms(), build_function_type(), type_cache_hasher::equal(), expand_call(), gimple_canonical_types_compatible_p(), pack_ts_type_common_value_fields(), prototype_p(), reconstruct_complex_type(), stdarg_p(), and unpack_ts_type_common_value_fields().

◆ TYPE_NONALIASED_COMPONENT

#define TYPE_NONALIASED_COMPONENT ( NODE ) (ARRAY_TYPE_CHECK (NODE)->type_common.transparent_aggr_flag)

For an ARRAY_TYPE, indicates that it is not permitted to take the
address of a component of the type.  This is the counterpart of
DECL_NONADDRESSABLE_P for arrays, see the definition of this flag.

Referenced by ends_tbaa_access_path_p(), get_alias_set(), gimple_canonical_types_compatible_p(), hash_tree(), odr_types_equivalent_p(), pack_ts_type_common_value_fields(), print_node(), store_constructor(), unpack_ts_type_common_value_fields(), and verify_type_variant().

◆ TYPE_OFFSET_BASETYPE

#define TYPE_OFFSET_BASETYPE ( NODE ) (OFFSET_TYPE_CHECK (NODE)->type_non_common.maxval)

Referenced by build_offset_type(), compound_type_base(), type_cache_hasher::equal(), print_node(), reconstruct_complex_type(), type_hash_canon_hash(), useless_type_conversion_p(), verify_type(), verify_type_variant(), and walk_type_fields().

◆ TYPE_OVERFLOW_SANITIZED

#define TYPE_OVERFLOW_SANITIZED ( TYPE )

Value:

  (INTEGRAL_TYPE_P (TYPE)                               \
   && !TYPE_OVERFLOW_WRAPS (TYPE)                       \
   && (flag_sanitize & SANITIZE_SI_OVERFLOW))

True if an overflow is to be preserved for sanitization.

Referenced by extract_muldiv_1(), fold_binary_loc(), fold_negate_expr_1(), and negate_expr_p().

◆ TYPE_OVERFLOW_TRAPS

#define TYPE_OVERFLOW_TRAPS ( TYPE ) (!ANY_INTEGRAL_TYPE_CHECK(TYPE)->base.u.bits.unsigned_flag && flag_trapv)

True if overflow for the given integral type should issue a
trap.

Referenced by compute_distributive_range(), convert_mult_to_fma(), divmod_candidate_p(), expand_simple_operations(), expand_vector_operation(), fold_binary_op_with_conditional_arg(), fold_negate_expr_1(), gimple_could_trap_p_1(), is_widening_mult_p(), maybe_resimplify_conditional_op(), nop_conversion_for_offset_p(), operation_no_trapping_overflow(), optab_for_tree_code(), split_constant_offset_1(), stmt_could_throw_1_p(), tree_could_trap_p(), and vn_nary_may_trap().

◆ TYPE_OVERFLOW_UNDEFINED

#define TYPE_OVERFLOW_UNDEFINED ( TYPE )

Value:

  (POINTER_TYPE_P (TYPE)                                        \
   ? !flag_wrapv_pointer                                        \
   : (!ANY_INTEGRAL_TYPE_CHECK(TYPE)->base.u.bits.unsigned_flag \
      && !flag_wrapv && !flag_trapv))

True if overflow is undefined for the given integral or pointer type.
We may optimize on the assumption that values in the type never overflow.

IMPORTANT NOTE: Any optimization based on TYPE_OVERFLOW_UNDEFINED
must issue a warning based on warn_strict_overflow.  In some cases
it will be appropriate to issue the warning immediately, and in
other cases it will be appropriate to simply set a flag and let the
caller decide whether a warning is appropriate or not.

Referenced by address_compare(), bb_no_side_effects_p(), chrec_convert_1(), chrec_fold_multiply(), compare_values_warnv(), compute_distributive_range(), expr_to_aff_combination(), extract_muldiv_1(), final_value_replacement_loop(), fold_binary_loc(), fold_comparison(), if_convertible_gimple_assign_stmt_p(), infer_loop_bounds_from_signedness(), interpret_rhs_expr(), is_nonwrapping_integer_induction(), make_range_step(), maybe_canonicalize_comparison_1(), maybe_optimize_sub_cmp_0(), move_computations_worker(), multiple_of_p(), nowrap_type_p(), number_of_iterations_ne_max(), operator_addr_expr::op1_range(), operator_abs::op1_range(), operator_addr_expr::op1_range(), operator_plus::overflow_free_p(), operator_minus::overflow_free_p(), operator_mult::overflow_free_p(), predicate_statements(), strip_offset_1(), loop_distribution::transform_reduction_loop(), tree_binary_nonnegative_warnv_p(), tree_binary_nonzero_warnv_p(), tree_unary_nonnegative_warnv_p(), update_range_test(), vect_recog_absolute_difference(), vect_recog_over_widening_pattern(), vectorize_slp_instance_root_stmt(), visit_nary_op(), operator_abs::wi_fold(), operator_mult::wi_fold(), operator_div::wi_op_overflows(), and operator_mult::wi_op_overflows().

◆ TYPE_OVERFLOW_WRAPS

#define TYPE_OVERFLOW_WRAPS ( TYPE )

Value:

  (POINTER_TYPE_P (TYPE)                                        \
   ? flag_wrapv_pointer                                         \
   : (ANY_INTEGRAL_TYPE_CHECK(TYPE)->base.u.bits.unsigned_flag  \
      || flag_wrapv))

True if overflow wraps around for the given integral or pointer type.  That
is, TYPE_MAX + 1 == TYPE_MIN.

Referenced by adjust_op1_for_overflow(), can_reassociate_type_p(), chrec_apply(), chrec_evaluate(), do_narrow(), tree_switch_conversion::jump_table_cluster::emit(), expr_to_aff_combination(), extract_muldiv_1(), fold_binary_loc(), fold_bit_and_mask(), fold_cond_expr_with_comparison(), fold_negate_expr_1(), fold_plusminus_mult_expr(), pointer_plus_operator::fold_range(), fold_unary_loc(), follow_outer_ssa_edges(), instrument_si_overflow(), interpret_rhs_expr(), legal_cast_p_1(), operator_plus::lhs_op1_relation(), minus_op1_op2_relation_effect(), negate_expr_p(), operator_mult::op1_range(), overflow_comparison_p_1(), parloops_needs_fold_left_reduction_p(), fold_using_range::range_of_address(), phi_group::refine_using_relation(), value_range_with_overflow(), vect_build_slp_tree_2(), vect_recog_absolute_difference(), vect_synth_mult_by_constant(), visit_nary_op(), and pointer_plus_operator::wi_fold().

◆ TYPE_P

#define TYPE_P ( NODE ) (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_type)

Nonzero if NODE represents a type.

Referenced by add_pubtype(), aggregate_value_p(), analyze_functions(), computable_teams_clause(), copy_tree_body_r(), strlen_pass::count_nonzero_bytes(), decl_attributes(), decl_class_context(), decl_overlaps_hard_reg_set_p(), decompose_param_expr(), diagnose_tm_1_op(), dump_tree_via_hooks(), dump_type_inheritance_graph(), element_mode(), element_precision(), error_unavailable_use(), expand_omp_regimplify_p(), finalize_nrv_r(), find_non_realpart_uses(), find_var_from_fn(), flags_from_decl_or_type(), force_decl_die(), force_labels_r(), gen_generic_params_dies(), generic_parameter_die(), get_alias_set(), get_attrs_for(), get_containing_scope(), get_deref_alias_set(), get_deref_alias_set_1(), range_query::get_tree_range(), get_vec_alignment_for_type(), gimple_get_alias_set(), hash_tree(), Value_Range::init(), ipa_get_type(), ipa_simd_modify_stmt_ops(), is_tm_pure(), lower_private_allocate(), lto_read_body_or_constructor(), make_ssa_name_fn(), make_temp_ssa_name(), maybe_create_die_with_external_ref(), move_stmt_op(), note_simd_array_uses_cb(), omp_discover_declare_target_fn_r(), omp_discover_declare_target_tgt_fn_r(), omp_discover_declare_target_var_r(), output_ttype(), pack_ts_base_value_fields(), prepare_call_address(), print_node(), record_type_list(), remap_gimple_op_r(), remap_type_3(), replace_with_mapped_expr(), sbr_sparse_bitmap::sbr_sparse_bitmap(), sbr_vector::sbr_vector(), scan_omp_1_op(), set_mem_attributes_minus_bitpos(), tree_is_indexable(), types_match(), types_match(), types_same_for_odr(), unpack_ts_base_value_fields(), verify_type(), verify_type_context(), walk_make_indirect(), walk_tree_1(), and warn_deprecated_use().

◆ TYPE_PACKED

#define TYPE_PACKED ( NODE ) (TYPE_CHECK (NODE)->base.u.bits.packed_flag)

Indicated that objects of this type should be laid out in as
compact a way as possible.

Referenced by build_aligned_type(), finalize_record_size(), finish_record_layout(), get_vec_alignment_for_record_type(), hash_tree(), pack_ts_type_common_value_fields(), place_field(), print_node(), start_record_layout(), unpack_ts_type_common_value_fields(), and verify_type_variant().

◆ TYPE_POINTER_TO

#define TYPE_POINTER_TO ( NODE ) (TYPE_CHECK (NODE)->type_common.pointer_to)

Referenced by build_distinct_type_copy(), build_pointer_type_for_mode(), one_pointer_to_useless_type_conversion_p(), print_node(), remap_type_1(), and verify_bb_vtables().

◆ TYPE_PRECISION

#define TYPE_PRECISION ( NODE ) (TREE_NOT_CHECK (TYPE_CHECK (NODE), VECTOR_TYPE)->type_common.precision)

◆ TYPE_PRECISION_RAW

#define TYPE_PRECISION_RAW ( NODE ) (TYPE_CHECK (NODE)->type_common.precision)

Referenced by gimple_canonical_types_compatible_p(), hash_tree(), pack_ts_type_common_value_fields(), unpack_ts_type_common_value_fields(), and verify_type_variant().

◆ TYPE_QUALS

#define TYPE_QUALS ( NODE )

Value:

  ((int) ((TYPE_READONLY (NODE) * TYPE_QUAL_CONST)              \
          | (TYPE_VOLATILE (NODE) * TYPE_QUAL_VOLATILE)         \
          | (TYPE_ATOMIC (NODE) * TYPE_QUAL_ATOMIC)             \
          | (TYPE_RESTRICT (NODE) * TYPE_QUAL_RESTRICT)         \
          | (ENCODE_QUAL_ADDR_SPACE (TYPE_ADDR_SPACE (NODE)))))

The set of type qualifiers for this type.

Referenced by add_calling_convention_attribute(), attr_access::array_as_string(), build_complex_type(), build_opaque_vector_type(), build_ref_for_offset(), build_type_attribute_qual_variant(), build_type_attribute_variant(), canonicalize_component_ref(), check_aligned_type(), check_base_type(), check_qualified_type(), create_access_replacement(), decl_attributes(), dump_generic_node(), find_or_create_vtbl_map_node(), fold_unary_loc(), get_nearest_type_subqualifiers(), get_qualified_type(), get_related_vectype_for_scalar_type(), install_var_field(), install_var_field(), lhd_tree_dump_type_quals(), make_vector_type(), oacc_rewrite_var_decl(), reconstruct_complex_type(), remap_type_1(), tree_profiling(), type_variants_equivalent_p(), and vtbl_map_get_node().

◆ TYPE_QUALS_NO_ADDR_SPACE

#define TYPE_QUALS_NO_ADDR_SPACE ( NODE )

Value:

  ((int) ((TYPE_READONLY (NODE) * TYPE_QUAL_CONST)              \
          | (TYPE_VOLATILE (NODE) * TYPE_QUAL_VOLATILE)         \
          | (TYPE_ATOMIC (NODE) * TYPE_QUAL_ATOMIC)             \
          | (TYPE_RESTRICT (NODE) * TYPE_QUAL_RESTRICT)))

The same as TYPE_QUALS without the address space qualifications.

Referenced by declare_in_namespace(), and modified_type_die().

◆ TYPE_QUALS_NO_ADDR_SPACE_NO_ATOMIC

#define TYPE_QUALS_NO_ADDR_SPACE_NO_ATOMIC ( NODE )

Value:

  ((int) ((TYPE_READONLY (NODE) * TYPE_QUAL_CONST)              \
          | (TYPE_VOLATILE (NODE) * TYPE_QUAL_VOLATILE)         \
          | (TYPE_RESTRICT (NODE) * TYPE_QUAL_RESTRICT)))

The same as TYPE_QUALS without the address space and atomic 
qualifications.

◆ TYPE_READONLY

#define TYPE_READONLY ( NODE ) (TYPE_CHECK (NODE)->base.readonly_flag)

Means this type is const-qualified.

Referenced by btf_init_postprocess(), builtin_call_nomodifying_p(), flags_from_decl_or_type(), hash_tree(), lower_omp_target(), maybe_warn_nonstring_arg(), maybe_warn_pass_by_reference(), pack_ts_type_common_value_fields(), print_node(), set_type_quals(), simd_clone_adjust(), tree_profiling(), ubsan_type_descriptor(), and unpack_ts_type_common_value_fields().

◆ TYPE_REF_CAN_ALIAS_ALL

#define TYPE_REF_CAN_ALIAS_ALL ( NODE ) (PTR_OR_REF_CHECK (NODE)->base.static_flag)

Nonzero in a pointer or reference type means the data pointed to
by this type can alias anything.

Referenced by build_pointer_type_for_mode(), build_reference_type_for_mode(), dump_generic_node(), dump_mem_ref(), fold_indirect_ref_1(), gimple_fold_indirect_ref(), input_gimple_stmt(), maybe_canonicalize_mem_ref_addr(), reconstruct_complex_type(), ref_all_alias_ptr_type_p(), remap_type_1(), and verify_type_variant().

◆ TYPE_REF_IS_RVALUE

#define TYPE_REF_IS_RVALUE ( NODE ) (REFERENCE_TYPE_CHECK (NODE)->base.private_flag)

True if reference type NODE is a C++ rvalue reference.

Referenced by modified_type_die(), and verify_type_variant().

◆ TYPE_REFERENCE_TO

#define TYPE_REFERENCE_TO ( NODE ) (TYPE_CHECK (NODE)->type_common.reference_to)

Referenced by build_distinct_type_copy(), build_reference_type_for_mode(), print_node(), and remap_type_1().

◆ TYPE_RESTRICT

#define TYPE_RESTRICT ( NODE ) (TYPE_CHECK (NODE)->type_common.restrict_flag)

If nonzero, this type is `restrict'-qualified, in the C sense of
the term.

Referenced by ipa_icf::sem_function::compatible_parm_types_p(), ipa_icf_gimple::func_checker::compatible_types_p(), create_variable_info_for(), create_variable_info_for_1(), hash_tree(), install_var_field(), install_var_field(), pack_ts_type_common_value_fields(), print_node(), push_fields_onto_fieldstack(), set_type_quals(), ubsan_type_descriptor(), and unpack_ts_type_common_value_fields().

◆ TYPE_REVERSE_STORAGE_ORDER

#define TYPE_REVERSE_STORAGE_ORDER ( NODE ) (TREE_CHECK4 (NODE, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, ARRAY_TYPE)->base.u.bits.saturating_flag)

In an aggregate type, indicates that the scalar fields of the type are
stored in reverse order from the target order.  This effectively
toggles BYTES_BIG_ENDIAN and WORDS_BIG_ENDIAN within the type.

Referenced by categorize_ctor_elements_1(), compare_constant(), copy_reference_ops_from_ref(), expand_expr_real_1(), expand_expr_real_2(), finish_record_layout(), fold_ctor_reference(), gimple_canonical_types_compatible_p(), gimple_fold_builtin_memory_op(), hash_tree(), initializer_constant_valid_p_1(), may_be_nonaddressable_p(), output_constructor(), pack_ts_base_value_fields(), print_node(), propagate_subaccesses_from_rhs(), reverse_storage_order_for_component_p(), sra_modify_assign(), storage_order_barrier_p(), store_constructor(), store_field(), unpack_ts_base_value_fields(), useless_type_conversion_p(), verify_type_variant(), and vn_reference_lookup_3().

◆ TYPE_SATURATING

#define TYPE_SATURATING ( NODE ) (TREE_NOT_CHECK4 (NODE, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, ARRAY_TYPE)->base.u.bits.saturating_flag)

In a non-aggregate type, indicates a saturating type.

Referenced by const_binop(), const_binop(), dequeue_and_dump(), dump_generic_node(), type_cache_hasher::equal(), expand_expr_real_2(), fold_binary_loc(), fold_convert_const_fixed_from_fixed(), fold_convert_const_fixed_from_int(), fold_convert_const_fixed_from_real(), fold_negate_const(), hash_tree(), layout_type(), make_accum_type(), make_fract_type(), make_range_step(), optab_for_tree_code(), pack_ts_base_value_fields(), unpack_ts_base_value_fields(), useless_type_conversion_p(), verify_type_variant(), and visit_nary_op().

◆ TYPE_SIGN

#define TYPE_SIGN ( NODE ) ((signop) TYPE_UNSIGNED (NODE))

Same as TYPE_UNSIGNED but converted to SIGNOP.

Referenced by add_one(), adjust_op1_for_overflow(), all_ones_mask_p(), arith_overflowed_p(), bit_value_assume_aligned(), bit_value_binop(), bit_value_unop(), bitint_min_cst_precision(), bits_from_bytes(), build_gt(), build_lt(), format_helper::can_represent_integral_type_p(), check_for_binary_op_overflow(), check_reduction_path(), chrec_fold_multiply(), compare_nonzero_chars(), compare_values_warnv(), tree_switch_conversion::switch_conversion::contains_linear_function_p(), irange::contains_p(), create_add_imm_cand(), create_possibly_reversed_range(), determine_value_range(), do_warn_aggressive_loop_optimizations(), double_int_to_tree(), dr_step_indicator(), dump_generic_node(), tree_switch_conversion::bit_test_cluster::emit(), evaluate_stmt(), expand_vector_divmod(), expand_widen_pattern_expr(), extract_muldiv_1(), find_var_cmp_const(), fold_abs_const(), fold_const_call_ss(), fold_convert_const(), fold_convert_const_int_from_int(), fold_div_compare(), operator_cast::fold_pair(), fold_plusminus_mult_expr(), cfn_ffs::fold_range(), cfn_clz::fold_range(), operator_lt::fold_range(), operator_le::fold_range(), operator_gt::fold_range(), operator_ge::fold_range(), operator_lt::fold_range(), operator_le::fold_range(), operator_gt::fold_range(), operator_ge::fold_range(), fold_unary_loc(), force_fit_type(), get_array_ctor_element_at_index(), get_default_value(), get_legacy_range(), get_min_precision(), tree_switch_conversion::cluster::get_range(), get_ref_base_and_extent(), get_type_static_bounds(), get_unwidened(), induction_variable_may_overflow_p(), operator_cast::inside_domain_p(), int_const_binop(), int_fits_type_p(), irange::intersect(), irange::intersect(), irange::invert(), ipcp_get_parm_bits(), ipcp_store_vr_results(), irange::irange_contains_p(), irange::irange_single_pair_union(), irange_val_max(), irange_val_min(), is_nonwrapping_integer_induction(), is_widening_mult_rhs_p(), iv_can_overflow_p(), operator_plus::lhs_op1_relation(), operator_minus::lhs_op1_relation(), operator_rshift::lhs_op1_relation(), operator_cast::lhs_op1_relation(), operator_cast::lhs_op1_relation(), operator_cast::lhs_op1_relation(), operator_cast::lhs_op1_relation(), loop_niters_no_overflow(), lower_omp_ordered_clauses(), max_limit(), wi::max_value(), gimple_range_op_handler::maybe_non_standard(), ipcp_bits_lattice::meet_with(), min_limit(), wi::min_value(), minmax_from_comparison(), minmax_replacement(), minus_op1_op2_relation_effect(), irange::nonnegative_p(), irange::nonpositive_p(), nop_conversion_for_offset_p(), number_of_iterations_lt(), number_of_iterations_ne(), number_of_iterations_ne_max(), number_of_iterations_until_wrap(), omp_context_compute_score(), omp_reduction_init_op(), operator_lshift::op1_range(), operator_trunc_mod::op1_range(), operator_abs::op1_range(), operator_trunc_mod::op2_range(), irange::operator==(), optimize_range_tests_diff(), optimize_range_tests_to_bit_test(), optimize_range_tests_xor(), output_constant(), operator_plus::overflow_free_p(), operator_minus::overflow_free_p(), operator_mult::overflow_free_p(), print_aff(), print_int_bound(), print_node(), print_node_brief(), propagate_bits_across_jump_function(), range_compatible_p(), range_fits_type_p(), range_from_loop_direction(), range_negatives(), range_of_var_in_loop(), range_positives(), real_value_from_int_cst(), refine_value_range_using_guard(), replace_mult_candidate(), irange::set(), set_switch_stmt_execution_predicate(), irange::set_varying(), simple_cst_equal(), simple_iv_with_niters(), operator_bitwise_and::simple_op1_range_solver(), simplify_using_ranges::simplify(), simplify_using_ranges::simplify_casted_compare(), simplify_conversion_using_ranges(), simplify_rotate(), split_constant_offset(), split_to_var_and_offset(), subtract_one(), wi::to_wide(), tree_nonzero_bits(), ubsan_type_descriptor(), irange::union_(), irange::union_append(), update_known_bitmask(), value_range_from_overflowed_bounds(), value_range_with_overflow(), irange::varying_compatible_p(), vect_determine_precisions_from_range(), vect_determine_precisions_from_users(), vect_gen_vector_loop_niters(), vect_get_range_info(), vect_is_emulated_mixed_dot_prod(), vect_joust_widened_integer(), vect_look_through_possible_promotion(), vect_peel_nonlinear_iv_init(), vect_recog_cast_forwprop_pattern(), vect_recog_cond_expr_convert_pattern(), vect_recog_divmod_pattern(), vect_recog_dot_prod_pattern(), irange::verify_range(), cross_product_operator::wi_cross_product(), operator_widen_plus_signed::wi_fold(), operator_widen_plus_unsigned::wi_fold(), operator_widen_mult_signed::wi_fold(), operator_widen_mult_unsigned::wi_fold(), operator_trunc_mod::wi_fold(), operator_plus::wi_fold(), operator_abs::wi_fold(), operator_minus::wi_fold(), operator_mult::wi_fold(), operator_bitwise_xor::wi_fold(), operator_div::wi_fold(), operator_lshift::wi_fold(), operator_bitwise_and::wi_fold(), operator_bitwise_or::wi_fold(), operator_min::wi_fold(), operator_max::wi_fold(), range_operator::wi_fold_in_parts(), range_operator::wi_fold_in_parts_equiv(), wi_includes_zero_p(), operator_div::wi_op_overflows(), operator_lshift::wi_op_overflows(), operator_mult::wi_op_overflows(), operator_rshift::wi_op_overflows(), wi_set_zero_nonzero_bits(), and wide_int_to_tree_1().

◆ TYPE_SIZE

#define TYPE_SIZE ( NODE ) (TYPE_CHECK (NODE)->type_common.size)

Type size in bits as a tree expression.  Need not be constant and may
be greater than TYPE_SIZE for a C++ FIELD_DECL representing a base
class subobject with its own virtual base classes (which are laid out
separately).

Referenced by aliasing_component_refs_walk(), analyze_all_variable_accesses(), ao_ref_init_from_vn_reference(), array_ref_flexible_size_p(), array_type_nelts(), ipcp_modif_dom_walker::before_dom_children(), build_agg_jump_func_from_list(), build_printable_array_type(), build_range_type_1(), build_tm_load(), build_tm_store(), build_truth_vector_type_for(), build_user_friendly_ref_for_offset(), build_vector_type_for_mode(), check_stmt_for_type_change(), check_ts_and_push_padding_to_vec(), coalesce_bitint(), ipa_polymorphic_call_context::combine_with(), ao_compare::compare_ao_refs(), compare_type_sizes(), complete_ctor_at_level_p(), component_ref_to_zero_sized_trailing_array_p(), compute_avail(), compute_optimized_partition_bases(), compute_record_mode(), convert_mult_to_fma(), convert_to_integer_1(), convert_to_vector(), count_type_elements(), coverage_end_function(), create_variable_info_for_1(), decl_init_size(), decode_field_reference(), default_function_arg_padding(), default_vector_alignment(), dequeue_and_dump(), determine_known_aggregate_parts(), DFS::DFS_write_tree_body(), discover_nonconstant_array_refs_r(), do_vec_narrow_conversion(), dse_optimize_stmt(), dump_generic_node(), dump_mem_ref(), eliminate_dom_walker::eliminate_stmt(), evaluate_conditions_for_known_args(), excess_unit_span(), execute_update_addresses_taken(), expand_asm_stmt(), expand_assignment(), expand_expr_real_1(), expand_expr_real_2(), expand_omp_atomic_cas(), expand_vector_conversion(), expand_vector_parallel(), expand_vector_piecewise(), expand_vector_ubsan_overflow(), extract_component(), finalize_record_size(), finalize_type_size(), find_atomic_core_type(), fixup_remapped_decl(), flexible_array_type_p(), fold_convert_loc(), fold_convertible_p(), fold_ctor_reference(), fold_indirect_ref_1(), fold_nonarray_ctor_reference(), fold_ternary_loc(), fold_view_convert_vector_encoding(), force_value_to_type(), fully_constant_vn_reference_p(), gather_mem_refs_stmt(), gen_ctf_base_type(), get_constraint_for_1(), get_inner_reference(), get_reassociation_width(), get_ref_base_and_extent(), get_ubsan_type_info_for_type(), get_vec_alignment_for_array_type(), gimple_fold_indirect_ref(), gimple_get_alias_set(), gimple_get_virt_method_for_vtable(), gimple_lower_bitint(), gimplify_init_ctor_preeval(), gimplify_omp_atomic(), gimplify_type_sizes(), go_output_typedef(), ao_compare::hash_ao_ref(), hash_tree(), idx_find_step(), indirect_ref_may_alias_decl_p(), initialize_data_dependence_relation(), initialize_sizetypes(), internal_gather_scatter_fn_supported_p(), ipa_print_node_jump_functions_for_edge(), ipcp_get_aggregate_const(), layout_decl(), layout_type(), load_from_unmodified_param_or_agg(), lto_input_ts_type_common_tree_pointers(), make_bit_field_ref(), maybe_add_sra_candidate(), maybe_canonicalize_mem_ref_addr(), maybe_rewrite_mem_ref_base(), ipa_polymorphic_call_context::meet_with(), mode_for_array(), ipa_param_body_adjustments::modify_assignment(), ipa_param_body_adjustments::modify_expression(), must_pass_in_stack_var_size(), must_pass_in_stack_var_size_or_pad(), non_rewritable_lvalue_p(), non_rewritable_mem_ref_base(), nonoverlapping_refs_since_match_p(), not_size_aligned(), odr_types_equivalent_p(), offset_int_type_size_in_bits(), omp_firstprivatize_type_sizes(), operand_compare::operand_equal_p(), optimize_count_trailing_zeroes(), optimize_vector_load(), output_constructor_bitfield(), pass_by_reference(), place_field(), possible_placement_new(), prepare_iteration_over_array_elts(), print_node(), propagate_aggregate_lattice(), propagate_aggs_across_jump_function(), remap_type_1(), remap_type_2(), ipa_polymorphic_call_context::restrict_to_inner_class(), rt_bb_visited::rt_bb_visited(), ipa_icf_gimple::func_checker::safe_for_total_scalarization_p(), safe_from_p(), simple_type_size_in_bits(), simplify_bitfield_ref(), simplify_count_trailing_zeroes(), simplify_permutation(), simplify_vector_constructor(), sort_by_size_then_ssa_version_or_uid(), sra_modify_expr(), staticp(), std_gimplify_va_arg_expr(), stmt_kills_ref_p(), store_constructor(), store_field(), tm_log_emit_stmt(), totally_scalarizable_type_p(), type_contains_placeholder_1(), ubsan_type_descriptor(), undistribute_bitref_for_vector(), unmodified_parm_1(), update_alignment_for_field(), useless_type_conversion_p(), variably_modified_type_p(), vect_add_slp_permutation(), vect_build_slp_tree_1(), vect_build_slp_tree_2(), vect_check_gather_scatter(), vect_create_epilog_for_reduction(), vect_create_partial_epilog(), vect_expand_fold_left(), vect_gather_scatter_fn_p(), vect_is_simple_cond(), vect_model_reduction_cost(), vect_recog_bit_insert_pattern(), vect_recog_bitfield_ref_pattern(), vect_recog_bool_pattern(), vect_slp_is_lane_insert(), vector_element_bits(), vector_element_bits_tree(), vectorizable_bswap(), vectorizable_internal_function(), vectorizable_load(), vectorizable_shift(), vectorizable_simd_clone_call(), vectorizable_store(), verify_gimple_assign_ternary(), verify_opaque_type(), verify_type_variant(), verify_types_in_gimple_reference(), vn_reference_eq(), vn_reference_lookup_3(), walk_tree_1(), and write_ts_type_common_tree_pointers().

◆ TYPE_SIZE_UNIT

#define TYPE_SIZE_UNIT ( NODE ) (TYPE_CHECK (NODE)->type_common.size_unit)

Likewise, type size in bytes.

Referenced by add_stack_var(), addr_object_size(), adjacent_dr_p(), array_ref_element_size(), array_ref_flexible_size_p(), array_size_for_constructor(), assign_temp(), build_omp_struct_comp_nodes(), build_printable_array_type(), build_range_type_1(), bump_vector_ptr(), c_strlen(), call_may_clobber_ref_p_1(), canonicalize_addr_expr(), rt_bb_visited::check(), array_bounds_checker::check_addr_expr(), check_all_va_list_escapes(), check_fnspec(), array_bounds_checker::check_mem_ref(), check_string_literal(), component_ref_sam_type(), component_ref_size(), compute_access_range(), compute_alias_check_pairs(), compute_object_offset(), compute_trims(), constant_byte_string(), copy_reference_ops_from_ref(), strlen_pass::count_nonzero_bytes(), coverage_end_function(), create_component_ref_by_pieces_1(), create_task_copyfn(), create_tmp_var_for(), decl_init_size(), declare_return_variable(), decode_addr_const(), defer_stack_allocation(), DFS::DFS_write_tree_body(), dr_analyze_indices(), dr_group_sort_cmp(), dr_may_alias_p(), dump_generic_node(), emit_note_insn_var_location(), execute_omp_oacc_neuter_broadcast(), execute_update_addresses_taken(), cgraph_node::expand(), expand_assign_tm(), expand_builtin_va_copy(), expand_call(), expand_constructor(), expand_omp_atomic(), expand_omp_for_generic(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), expand_omp_scantemp_alloc(), expand_omp_sections(), expand_one_stack_var_1(), expand_thunk(), expand_vector_parallel(), field_at_offset(), finalize_record_size(), finalize_type_size(), find_constructor_constant_at_offset(), finish_taskreg_scan(), fixup_remapped_decl(), fold_array_ctor_reference(), fold_indirect_ref_1(), generate_strlen_builtin_using_rawmemchr(), generate_subtree_deferred_init(), get_addr_base_and_unit_offset_1(), get_misalign_in_elems(), get_negative_load_store_type(), get_range_strlen_dynamic(), get_range_strlen_tree(), get_ref_size(), get_stridx(), getbyterep(), gimple_add_init_for_auto_var(), gimple_fold_builtin_clear_padding(), gimple_fold_builtin_memory_op(), gimple_fold_indirect_ref(), gimple_get_virt_method_for_vtable(), gimple_lower_bitint(), gimple_parm_array_size(), gimplify_adjust_omp_clauses(), gimplify_adjust_omp_clauses_1(), gimplify_asm_expr(), gimplify_bind_expr(), gimplify_modify_expr(), gimplify_modify_expr_rhs(), gimplify_scan_omp_clauses(), gimplify_type_sizes(), gimplify_variable_sized_compare(), go_format_type(), handle_array_ref(), handle_simd_reference(), hash_tree(), initialize_ao_ref_for_dse(), initialize_argument_information(), initialize_data_dependence_relation(), initialize_sizetypes(), instrument_object_size(), int_size_in_bytes(), is_variable_sized(), layout_decl(), layout_type(), lhd_unit_size_without_reusable_padding(), lower_coro_builtin(), lower_lastprivate_clauses(), lower_omp_for_scan(), lower_omp_target(), lower_omp_task_reductions(), lower_rec_input_clauses(), lower_reduction_clauses(), lto_input_ts_type_common_tree_pointers(), maybe_rewrite_mem_ref_base(), maybe_set_strlen_range(), maybe_with_size_expr(), native_encode_int(), native_encode_string(), native_interpret_int(), native_interpret_vector(), native_interpret_vector_part(), non_rewritable_lvalue_p(), non_rewritable_mem_ref_base(), nonoverlapping_array_refs_p(), nonzero_bytes_for_type(), oacc_do_neutering(), odr_types_equivalent_p(), omp_accumulate_sibling_list(), omp_add_variable(), omp_adjust_for_condition(), omp_build_struct_sibling_lists(), omp_firstprivatize_type_sizes(), omp_notice_variable(), omp_resolve_clause_dependencies(), omp_task_reduction_iterate(), ompdevlow_adjust_simt_enter(), optimize_atomic_bit_test_and(), optimize_memcpy(), output_constructor_array_range(), output_constructor_regular_field(), parm_object_size(), pointer_may_wrap_p(), print_node(), vn_walk_cb_data::push_partial_def(), reduction_var_overflows_first(), ref_maybe_used_by_call_p_1(), remap_type_1(), remap_type_2(), rtx_addr_can_trap_p_1(), self_reuse_distance(), set_component_ref_size(), set_mem_attributes_minus_bitpos(), should_interchange_loops(), should_remove_lhs_p(), simd_clone_adjust(), simd_clone_linear_addend(), size_in_bytes_loc(), sort_size_descending(), sra_modify_deferred_init(), stack_protect_classify_type(), store_constructor(), pcom_worker::suitable_component_p(), task_reduction_read(), tm_log_add(), tm_log_emit_stmt(), loop_distribution::transform_reduction_loop(), tree_profiling(), type_contains_placeholder_1(), ubsan_type_descriptor(), variably_modified_type_p(), vect_analyze_data_ref_access(), vect_analyze_data_ref_accesses(), vect_analyze_group_access_1(), vect_create_cond_for_align_checks(), vect_create_data_ref_ptr(), vect_dr_misalign_for_aligned_access(), vect_enhance_data_refs_alignment(), vect_find_stmt_data_reference(), vect_gen_prolog_loop_niters(), vect_get_data_ptr_increment(), vect_get_peeling_costs_all_drs(), vect_get_scalar_dr_size(), vect_get_smallest_scalar_type(), vect_vfa_access_size(), vector_alignment_reachable_p(), vectorizable_load(), vectorizable_store(), verify_gimple_call(), verify_type_variant(), vn_reference_lookup_3(), rt_bb_visited::vword(), walk_tree_1(), and write_ts_type_common_tree_pointers().

◆ TYPE_SIZES_GIMPLIFIED

#define TYPE_SIZES_GIMPLIFIED ( NODE ) (TYPE_CHECK (NODE)->base.constant_flag)

Nonzero if NODE, a type, has had its sizes gimplified.

Referenced by gimplify_decl_expr(), gimplify_omp_depend(), gimplify_return_expr(), gimplify_target_expr(), gimplify_type_sizes(), and print_node().

◆ TYPE_STRING_FLAG

#define TYPE_STRING_FLAG ( NODE ) (ARRAY_OR_INTEGER_TYPE_CHECK (NODE)->type_common.string_flag)

If set in an ARRAY_TYPE, indicates a string type (for languages
that distinguish string from array of char).
If set in a INTEGER_TYPE, indicates a character type.

Referenced by base_type_die(), build_common_tree_nodes(), gimple_canonical_types_compatible_p(), hash_tree(), odr_types_equivalent_p(), pack_ts_type_common_value_fields(), print_node(), type_to_class(), unpack_ts_type_common_value_fields(), useless_type_conversion_p(), and verify_type_variant().

◆ TYPE_STRUCTURAL_EQUALITY_P

#define TYPE_STRUCTURAL_EQUALITY_P ( NODE ) (TYPE_CANONICAL (NODE) == NULL_TREE)

Indicates that the type node requires structural equality
checks.  The compiler will need to look at the composition of the
type to determine whether it is equal to another type, rather than
just comparing canonical type pointers.  For instance, we would need
to look at the return and parameter types of a FUNCTION_TYPE
node.

Referenced by build_array_type_1(), build_complex_type(), build_distinct_type_copy(), build_function_type(), build_method_type_directly(), build_offset_type(), build_pointer_type_for_mode(), build_qualified_type(), build_reference_type_for_mode(), build_type_attribute_qual_variant(), type_cache_hasher::equal(), get_alias_set(), get_odr_type(), lto_read_body_or_constructor(), make_vector_type(), maybe_canonicalize_argtypes(), obj_type_ref_class(), print_node(), record_component_aliases(), same_type_for_tbaa(), type_hash_canon_hash(), and types_equal_for_same_type_for_tbaa_p().

◆ TYPE_STUB_DECL

#define TYPE_STUB_DECL ( NODE ) (TREE_CHAIN (TYPE_CHECK (NODE)))

If your language allows you to declare types, and you want debug info
for them, then you need to generate corresponding TYPE_DECL nodes.
These "stub" TYPE_DECL nodes have no name, and simply point at the
type node.  You then set the TYPE_STUB_DECL field of the type node
to point back at the TYPE_DECL node.  This allows the debug routines
to know that the two nodes represent the same type, so that we only
get one debug info record for them.

Referenced by asan_global_struct(), error_unavailable_use(), finish_builtin_struct(), lhd_simulate_enum_decl(), remap_decl(), remap_type_1(), rest_of_type_compilation(), should_emit_struct_debug(), type_in_anonymous_namespace_p(), ubsan_create_data(), ubsan_get_source_location_type(), ubsan_get_type_descriptor_type(), and warn_deprecated_use().

◆ TYPE_SYMTAB_ADDRESS

#define TYPE_SYMTAB_ADDRESS ( NODE ) (TYPE_CHECK (NODE)->type_common.symtab.address)

The debug output functions use the symtab union field to store
information specific to the debugging format.  The different debug
output hooks store different types in the union field.  These three
macros are used to access different fields in the union.  The debug
hooks are responsible for consistently using only a specific
macro.

Symtab field as an integer.  Used by stabs generator in dbxout.cc to
hold the type's number in the generated stabs.

Referenced by copy_node(), and print_node().

◆ TYPE_SYMTAB_DIE

#define TYPE_SYMTAB_DIE ( NODE ) (TYPE_CHECK (NODE)->type_common.symtab.die)

Symtab field as a pointer to a DWARF DIE.  Used by DWARF generator
in dwarf2out.cc to point to the DIE generated for the type.

Referenced by copy_node(), dwarf2out_next_real_insn(), equate_type_number_to_die(), and lookup_type_die().

◆ TYPE_SYMTAB_IS_ADDRESS

#define TYPE_SYMTAB_IS_ADDRESS (0)

The garbage collector needs to know the interpretation of the
symtab field.  These constants represent the different types in the
union.

◆ TYPE_SYMTAB_IS_DIE

#define TYPE_SYMTAB_IS_DIE (1)

◆ TYPE_TRANSPARENT_AGGR

#define TYPE_TRANSPARENT_AGGR ( NODE ) (RECORD_OR_UNION_CHECK (NODE)->type_common.transparent_aggr_flag)

Indicates that a UNION_TYPE object should be passed the same way that
the first union alternative would be passed, or that a RECORD_TYPE
object should be passed the same way that the first (and only) member
would be passed.

Referenced by aggregate_value_p(), assign_parm_find_data_types(), hash_tree(), initialize_argument_information(), load_register_parameters(), pack_ts_type_common_value_fields(), pass_by_reference(), print_node(), unpack_ts_type_common_value_fields(), and verify_type_variant().

◆ TYPE_TYPELESS_STORAGE

#define TYPE_TYPELESS_STORAGE ( NODE )

Value:

(TREE_CHECK4 (NODE, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, \

ARRAY_TYPE)->type_common.typeless_storage)

TREE_CHECK4

#define TREE_CHECK4(T, CODE1, CODE2, CODE3, CODE4)

Definition tree.h:492

For an ARRAY_TYPE, a RECORD_TYPE, a UNION_TYPE or a QUAL_UNION_TYPE
whether the array is typeless storage or the type contains a member
with this flag set.  Such types are exempt from type-based alias
analysis.  For ARRAY_TYPEs with AGGREGATE_TYPE_P element types
the flag should be inherited from the element type, can change
when type is finalized and because of that should not be used in
type hashing.  For ARRAY_TYPEs with non-AGGREGATE_TYPE_P element types
the flag should not be changed after the array is created and should
be used in type hashing.

Referenced by build_array_type_1(), type_cache_hasher::equal(), finalize_type_size(), get_alias_set(), hash_tree(), layout_type(), pack_ts_type_common_value_fields(), place_field(), place_union_field(), type_hash_canon_hash(), and unpack_ts_type_common_value_fields().

◆ TYPE_UID

#define TYPE_UID ( NODE ) (TYPE_CHECK (NODE)->type_common.uid)

Define fields and accessors for nodes representing data types.

See tree.def for documentation of the use of these fields.
Look at the documentation of the various ..._TYPE tree codes.

Note that the type.values, type.minval, and type.maxval fields are
overloaded and used for different macros in different kinds of types.
Each macro must check to ensure the tree node is of the proper kind of
type.  Note also that some of the front-ends also overload these fields,
so they must be checked as well.

Referenced by build_poly_int_cst(), compare_access_positions(), copy_node(), create_variable_info_for_1(), decl_for_type_insert(), decl_for_type_lookup(), dump_generic_node(), polymorphic_call_target_hasher::hash(), int_cst_hasher::hash(), tree_type_hash::hash(), tree_type_map_cache_hasher::hash(), default_hash_traits< type_pair >::hash(), make_node(), ncr_type_uid(), odr_subtypes_equivalent_p(), type_hash_canon(), and ipa_icf::sem_item_optimizer::update_hash_by_addr_refs().

◆ TYPE_UNSIGNED

#define TYPE_UNSIGNED ( NODE ) (TYPE_CHECK (NODE)->base.u.bits.unsigned_flag)

In integral and pointer types, means an unsigned type.

◆ TYPE_USER_ALIGN

#define TYPE_USER_ALIGN ( NODE ) (TYPE_CHECK (NODE)->base.u.bits.user_align)

1 if the alignment for this type was requested by "aligned" attribute,
0 if it is the default for this type.

Referenced by build_aligned_type(), build_common_tree_nodes(), build_range_type_1(), check_aligned_type(), check_base_type(), do_type_align(), expand_expr_addr_expr_1(), finalize_type_size(), finish_builtin_struct(), hash_tree(), layout_type(), make_node(), min_align_of_type(), pack_ts_type_common_value_fields(), place_field(), print_node(), unpack_ts_type_common_value_fields(), update_alignment_for_field(), and verify_opaque_type().

◆ TYPE_VALUES

#define TYPE_VALUES ( NODE ) (ENUMERAL_TYPE_CHECK (NODE)->type_non_common.values)

Referenced by dequeue_and_dump(), type_cache_hasher::equal(), go_output_typedef(), ipa_odr_summary_write(), print_node(), verify_type(), and verify_type_variant().

◆ TYPE_VALUES_RAW

#define TYPE_VALUES_RAW ( NODE ) (TYPE_CHECK (NODE)->type_non_common.values)

Referenced by verify_type().

◆ TYPE_VECTOR_OPAQUE

#define TYPE_VECTOR_OPAQUE ( NODE ) (VECTOR_TYPE_CHECK (NODE)->base.default_def_flag)

Nonzero in a VECTOR_TYPE if the frontends should not emit warnings
about missing conversions to other vector types of the same size.

Referenced by build_opaque_vector_type().

◆ TYPE_VFIELD

#define TYPE_VFIELD ( NODE ) (RECORD_OR_UNION_CHECK (NODE)->type_non_common.minval)

Referenced by verify_type(), and verify_type_variant().

◆ TYPE_VOLATILE

#define TYPE_VOLATILE ( NODE ) (TYPE_CHECK (NODE)->base.volatile_flag)

Nonzero in a type considered volatile as a whole.

Referenced by assign_stack_temp_for_type(), can_implement_as_sibling_call_p(), maybe_make_indirect(), objects_must_conflict_p(), set_mem_attributes_minus_bitpos(), set_type_quals(), type_internals_preclude_sra_p_1(), and ubsan_type_descriptor().

◆ TYPE_WARN_IF_NOT_ALIGN

#define TYPE_WARN_IF_NOT_ALIGN ( NODE )

Value:

(TYPE_CHECK (NODE)->type_common.warn_if_not_align \

? ((unsigned)1) << ((NODE)->type_common.warn_if_not_align - 1) : 0)

The minimum alignment necessary for objects of this type without
warning.  The value is an int, measured in bits.

Referenced by build_range_type_1(), do_type_align(), finish_builtin_struct(), handle_warn_if_not_align(), layout_type(), place_field(), and print_node().

◆ uda_type_node

#define uda_type_node global_trees[TI_UDA_TYPE]

◆ udq_type_node

#define udq_type_node global_trees[TI_UDQ_TYPE]

◆ uha_type_node

#define uha_type_node global_trees[TI_UHA_TYPE]

◆ uhq_type_node

#define uhq_type_node global_trees[TI_UHQ_TYPE]

◆ uint128_type_node

#define uint128_type_node global_trees[TI_UINT128_TYPE]

Referenced by build_common_tree_nodes().

◆ uint16_type_node

#define uint16_type_node global_trees[TI_UINT16_TYPE]

Referenced by build_common_tree_nodes(), and initialize_sanitizer_builtins().

◆ uint32_type_node

#define uint32_type_node global_trees[TI_UINT32_TYPE]

Referenced by build_common_tree_nodes(), gen_counter_update(), and initialize_sanitizer_builtins().

◆ uint64_type_node

#define uint64_type_node global_trees[TI_UINT64_TYPE]

Referenced by build_common_tree_nodes(), and initialize_sanitizer_builtins().

◆ UNARY_CLASS_P

#define UNARY_CLASS_P ( NODE ) (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_unary)

Nonzero if NODE represents a unary arithmetic expression.

Referenced by dr_equal_offsets_p1(), expand_debug_expr(), extract_muldiv_1(), range_query::get_tree_range(), skip_simple_arithmetic(), skip_simple_constant_arithmetic(), substitute_placeholder_in_expr(), and will_be_nonconstant_expr_predicate().

◆ unsigned_accum_type_node

#define unsigned_accum_type_node global_trees[TI_UACCUM_TYPE]

Referenced by make_or_reuse_accum_type().

◆ unsigned_char_type_node

◆ unsigned_fract_type_node

#define unsigned_fract_type_node global_trees[TI_UFRACT_TYPE]

Referenced by make_or_reuse_fract_type().

◆ unsigned_intDI_type_node

#define unsigned_intDI_type_node global_trees[TI_UINTDI_TYPE]

Referenced by build_common_tree_nodes(), gimple_signed_or_unsigned_type(), and lhd_type_for_size().

◆ unsigned_intHI_type_node

#define unsigned_intHI_type_node global_trees[TI_UINTHI_TYPE]

Referenced by build_common_tree_nodes(), gimple_signed_or_unsigned_type(), and lhd_type_for_size().

◆ unsigned_intQI_type_node

#define unsigned_intQI_type_node global_trees[TI_UINTQI_TYPE]

Referenced by build_common_tree_nodes(), gimple_signed_or_unsigned_type(), lhd_type_for_size(), vectorizable_load(), and vectorizable_store().

◆ unsigned_intSI_type_node

#define unsigned_intSI_type_node global_trees[TI_UINTSI_TYPE]

Referenced by build_common_tree_nodes(), gimple_signed_or_unsigned_type(), and lhd_type_for_size().

◆ unsigned_intTI_type_node

#define unsigned_intTI_type_node global_trees[TI_UINTTI_TYPE]

Referenced by build_common_tree_nodes(), gimple_signed_or_unsigned_type(), and lhd_type_for_size().

◆ unsigned_long_accum_type_node

#define unsigned_long_accum_type_node global_trees[TI_ULACCUM_TYPE]

Referenced by make_or_reuse_accum_type().

◆ unsigned_long_fract_type_node

#define unsigned_long_fract_type_node global_trees[TI_ULFRACT_TYPE]

Referenced by make_or_reuse_fract_type().

◆ unsigned_long_long_accum_type_node

#define unsigned_long_long_accum_type_node global_trees[TI_ULLACCUM_TYPE]

Referenced by make_or_reuse_accum_type().

◆ unsigned_long_long_fract_type_node

#define unsigned_long_long_fract_type_node global_trees[TI_ULLFRACT_TYPE]

Referenced by make_or_reuse_fract_type().

◆ unsigned_short_accum_type_node

#define unsigned_short_accum_type_node global_trees[TI_USACCUM_TYPE]

Referenced by make_or_reuse_accum_type().

◆ unsigned_short_fract_type_node

#define unsigned_short_fract_type_node global_trees[TI_USFRACT_TYPE]

Referenced by make_or_reuse_fract_type().

◆ unsigned_type_node

#define unsigned_type_node integer_types[itk_unsigned_int]

Referenced by adjust_simduid_builtins(), asan_add_global(), build_cltz_expr(), build_common_tree_nodes(), build_complex_type(), build_personality_function(), build_popcount_expr(), create_odr_indicator(), dump_generic_node(), expand_omp_for_generic(), expand_omp_sections(), expand_omp_simd(), expand_omp_target(), expand_parallel_call(), expand_task_call(), expand_teams_call(), find_loop_niter(), fold_builtin_bit_query(), fold_builtin_isdigit(), get_target_argument_value(), get_typenode_from_name(), get_ws_args_for(), gimple_gen_interval_profiler(), gimple_init_gcov_profiler(), gimple_signed_or_unsigned_type(), inline_string_cmp(), lhd_type_for_size(), loop_niter_by_eval(), lower_lastprivate_clauses(), lower_lastprivate_conditional_clauses(), lower_oacc_head_tail(), lower_oacc_reductions(), lower_omp_for_scan(), lower_omp_scan(), lower_omp_sections(), lower_omp_teams(), lower_rec_input_clauses(), lower_rec_simd_input_clauses(), max_stmt_executions_tree(), number_of_iterations_cltz(), number_of_iterations_cltz_complement(), number_of_iterations_popcount(), oacc_dim_call(), oacc_launch_pack(), oacc_loop_process(), oacc_loop_xform_head_tail(), oacc_thread_numbers(), simd_clone_adjust(), ubsan_get_source_location_type(), ubsan_source_location(), and vectorizable_call().

◆ UNUSED_LABEL_P

#define UNUSED_LABEL_P ( NODE ) (LABEL_DECL_CHECK (NODE)->base.default_def_flag)

Set on label that is known not to be jumped to, it can be only
reached by falling through from previous statements.
This is used to implement -Wimplicit-fallthrough.

Referenced by collect_fallthrough_labels(), and gimplify_cond_expr().

◆ uqq_type_node

#define uqq_type_node global_trees[TI_UQQ_TYPE]

◆ usa_type_node

#define usa_type_node global_trees[TI_USA_TYPE]

◆ usq_type_node

#define usq_type_node global_trees[TI_USQ_TYPE]

◆ uta_type_node

#define uta_type_node global_trees[TI_UTA_TYPE]

◆ utq_type_node

#define utq_type_node global_trees[TI_UTQ_TYPE]

◆ va_list_fpr_counter_field

#define va_list_fpr_counter_field global_trees[TI_VA_LIST_FPR_COUNTER_FIELD]

Referenced by optimize_va_list_gpr_fpr_size(), and va_list_counter_struct_op().

◆ va_list_gpr_counter_field

#define va_list_gpr_counter_field global_trees[TI_VA_LIST_GPR_COUNTER_FIELD]

Referenced by optimize_va_list_gpr_fpr_size(), and va_list_counter_struct_op().

◆ va_list_type_node

#define va_list_type_node global_trees[TI_VA_LIST_TYPE]

Referenced by build_common_tree_nodes(), is_va_list_type(), std_canonical_va_list_type(), and std_fn_abi_va_list().

◆ VAR_DECL_IS_VIRTUAL_OPERAND

#define VAR_DECL_IS_VIRTUAL_OPERAND ( NODE ) (VAR_DECL_CHECK (NODE)->base.u.bits.saturating_flag)

In a VAR_DECL, nonzero if this is a global variable for VOPs.

Referenced by create_vop_var(), ana::state_purge_map::get_data_for_ssa_name(), mark_virtual_operand_for_renaming(), remap_ssa_name(), target_for_debug_bind(), and virtual_operand_p().

◆ VAR_OR_FUNCTION_DECL_P

#define VAR_OR_FUNCTION_DECL_P ( DECL ) (TREE_CODE (DECL) == VAR_DECL || TREE_CODE (DECL) == FUNCTION_DECL)

Nonzero if DECL represents a VAR_DECL or FUNCTION_DECL.

Referenced by can_refer_decl_in_current_unit_p(), canonicalize_constructor_val(), DFS::DFS_write_tree_body(), fold_builtin_expect(), make_decl_one_only(), mangle_referenced_decls(), symtab_node::maybe_create_reference(), need_assembler_name_p(), secname_for_decl(), simple_operand_p(), streamer_write_chain(), streamer_write_chain(), update_vtable_references(), and write_symbol().

◆ VAR_P

#define VAR_P ( NODE ) (TREE_CODE (NODE) == VAR_DECL)

True if NODE designates a variable declaration.

Referenced by add_clobbers_to_eh_landing_pad(), add_decls_addresses_to_decl_constructor(), add_local_decl(), add_local_variables(), add_location_or_const_value_attribute(), add_scope_conflicts_1(), add_var_loc_to_decl(), address_compare(), analyze_all_variable_accesses(), analyze_functions(), array_ref_flexible_size_p(), asan_protect_global(), varpool_node::assemble_decl(), assemble_variable(), assumption_copy_decl(), auto_var_p(), build_constant_desc(), build_ssa_conflict_graph(), builtin_save_expr(), call_may_clobber_ref_p_1(), can_be_nonlocal(), can_escape(), symtab_node::can_increase_alignment_p(), can_refer_decl_in_current_unit_p(), canonicalize_constructor_val(), categorize_decl_for_section(), symbol_table::change_decl_assembler_name(), check_all_va_list_escapes(), array_bounds_checker::check_array_ref(), check_global_declaration(), check_scan_store(), chrec_contains_symbols(), clear_tree_used(), coalesce_with_default(), compare_base_decls(), compare_base_symbol_refs(), compare_virtual_tables(), component_ref_size(), computable_teams_clause(), compute_live_vars_1(), compute_live_vars_visit(), consider_split(), constant_byte_string(), constant_decl_p(), convert_local_omp_clauses(), convert_local_reference_stmt(), convert_nonlocal_omp_clauses(), convert_nonlocal_reference_stmt(), copy_debug_stmt(), copy_decl_for_dup_finish(), copy_node(), copy_ref_info(), symtab_node::copy_visibility_from(), strlen_pass::count_nonzero_bytes(), varpool_node::create_alias(), create_variable_info_for(), ctor_for_folding(), decl_attributes(), decl_by_reference_p(), decl_in_symtab_p(), decl_init_priority_insert(), decl_maybe_in_construction_p(), decl_overlaps_hard_reg_set_p(), default_encode_section_info(), default_section_type_flags(), default_tree_printer(), delegitimize_mem_from_attrs(), dequeue_and_dump(), DFS::DFS_write_tree_body(), diag_attr_exclusions(), do_assemble_alias(), dwarf2out_type_decl(), emit_push_insn(), symtab_node::equal_address_to(), execute_fixup_cfg(), execute_update_addresses_taken(), expand_assignment(), expand_call_inline(), expand_debug_expr(), expand_expr_real_1(), expand_expr_real_2(), expand_fn_using_insn(), expand_omp_regimplify_p(), expand_omp_target(), expand_omp_taskreg(), expand_one_var(), expand_thunk(), expand_used_vars_for_block(), varpool_node::finalize_named_section_flags(), find_assumption_locals_r(), find_local_vars_to_propagate(), find_partitioned_var_uses_1(), find_replaceable_in_bb(), find_simtpriv_var_op(), find_tail_calls(), find_va_list_reference(), find_var_candidates(), finish_taskreg_remap(), fixed_address_object_p(), fixup_vla_decls(), fold_unary_loc(), force_constant_size(), force_expr_to_var_cost(), fortran_common(), fully_constant_vn_reference_p(), gen_variable_die(), generic_parameter_die(), get_alias_set(), get_block_for_decl(), get_component_ssa_name(), get_constraint_for_1(), get_constraint_for_ssa_var(), varpool_node::get_create(), symtab_node::get_create(), get_debug_decl(), get_default_value(), get_range_strlen_tree(), get_ref_base_and_extent(), get_symbol_initial_value(), gimple_can_coalesce_p(), gimple_duplicate_bb(), gimple_expand_vec_set_extract_expr(), gimple_get_virt_method_for_vtable(), gimple_lower_bitint(), gimplify_adjust_omp_clauses_1(), gimplify_asm_expr(), gimplify_bind_expr(), gimplify_compound_lval(), gimplify_decl_expr(), gimplify_init_constructor(), gimplify_modify_expr(), gimplify_modify_expr_rhs(), gimplify_oacc_declare(), gimplify_omp_for(), gimplify_one_sizepos(), gimplify_type_sizes(), gimplify_var_or_parm_decl(), handle_alias_pairs(), implicit_ptr_descriptor(), initialize_inlined_parameters(), install_var_field(), instantiate_decls_1(), instantiate_expr(), instrument_bool_enum_load(), instrument_derefs(), instrument_expr(), instrument_object_size(), ipa_compute_jump_functions_for_edge(), ipa_find_agg_cst_from_init(), ipa_set_jf_constant(), is_addr_local(), is_asan_mark_p(), is_gimple_asm_val(), is_gimple_reg(), is_gimple_variable(), lhd_set_decl_assembler_name(), lhd_warn_unused_global_decl(), load_register_parameters(), loc_list_from_tree_1(), lookup_field_for_decl(), lower_assumption(), lower_emutls_2(), lower_lastprivate_clauses(), lower_omp_regimplify_p(), lower_omp_scan(), lower_stmt(), lto_input_ts_decl_common_tree_pointers(), lto_input_var_decl_ref(), lto_output_var_decl_ref(), symtab_node::make_decl_local(), make_decl_one_only(), make_decl_rtl(), make_ssa_name_fn(), mark_address(), mark_address_taken(), mark_addressable(), mark_all_vars_used_1(), mark_decl_referenced(), mark_load(), mark_nonssa_use(), mark_store(), may_propagate_copy(), maybe_instrument_pointer_overflow(), maybe_optimize_ubsan_ptr_ifn(), maybe_register_def(), maybe_remove_writeonly_store(), maybe_set_strlen_range(), maybe_warn_operand(), move_stmt_op(), need_assembler_name_p(), nesting_copy_decl(), new_var_info(), note_no_context_vars(), note_nonlocal_vla_type(), note_simd_array_uses_cb(), notice_global_symbol(), oacc_privatization_candidate_p(), oacc_rewrite_var_decl(), omp_declare_target_var_p(), omp_default_clause(), omp_discover_declare_target_var_r(), omp_discover_implicit_declare_target(), omp_member_access_dummy_var(), omp_notice_variable(), ompdevlow_adjust_simt_enter(), optimize_va_list_gpr_fpr_size(), output_constant_def_contents(), output_gimple_stmt(), symtab_node::output_to_lto_symbol_table_p(), output_ttype(), pack_ts_decl_common_value_fields(), pack_ts_decl_with_vis_value_fields(), partition_view_init(), place_field(), populate_coalesce_list_for_outofssa(), print_call_name(), print_declaration(), process_alt_operands(), process_references(), symbol_table::process_same_body_aliases(), propagate_controlled_uses(), ptr_deref_may_alias_decl_p(), ptrs_compare_unequal(), readonly_data_expr(), record_reference(), record_type_list(), record_vars_into(), ref_maybe_used_by_call_p_1(), reference_to_unused(), referenced_from_vtable_p(), remap_decl(), remap_decls(), remap_ssa_name(), remap_vla_decls(), remove_dead_stmt(), remove_unused_locals(), remove_unused_scope_block_p(), replace_block_vars_by_duplicates(), replace_locals_op(), requires_barrier(), reset_debug_binding(), rest_of_decl_compilation(), rewrite_stmt(), rtl_for_decl_location(), set_decl_section_name(), set_decl_section_name(), set_mem_attributes_minus_bitpos(), set_rtl(), set_ssa_default_def(), set_uids_in_ptset(), setjmp_vars_warning(), ssa_default_def(), ssa_defined_default_def_p(), statement_sink_location(), target_for_debug_bind(), test_nonssa_use(), thunk_adjust(), tls_mem_loc_descriptor(), track_expr_p(), tree_add_const_value_attribute_for_decl(), tree_is_indexable(), unpack_ts_decl_common_value_fields(), unpack_ts_decl_with_vis_value_fields(), use_blocks_for_decl_p(), va_list_counter_struct_op(), va_list_ptr_read(), va_list_ptr_write(), var_debug_decl(), vect_analyze_data_refs(), vect_can_force_dr_alignment_p(), vectorizable_load(), vectorizable_store(), verify_address(), symtab_node::verify_base(), verify_bb_vtables(), verify_expr_location_1(), verify_live_on_entry(), verify_node_partition(), verify_phi_args(), verify_type(), virtual_operand_p(), visit_loadstore(), warn_uninit(), worker_single_copy(), wrap_refs(), wrapup_global_declaration_1(), wrapup_global_declaration_2(), write_symbol(), write_symbol_extension_info(), and write_ts_decl_common_tree_pointers().

◆ VECTOR_BOOLEAN_TYPE_P

#define VECTOR_BOOLEAN_TYPE_P ( TYPE )

Value:

(TREE_CODE (TYPE) == VECTOR_TYPE \

&& TREE_CODE (TREE_TYPE (TYPE)) == BOOLEAN_TYPE)

Nonzero if TYPE represents a vector of booleans.

Referenced by add_mask_and_len_args(), append_pattern_def_seq(), const_vector_from_tree(), do_compare_rtx_and_jump(), do_store_flag(), expand_expr_real_2(), expand_fn_using_insn(), expand_vec_cond_expr_p(), expand_vector_comparison(), expand_vector_condition(), expand_vector_operations_1(), expand_widen_pattern_expr(), gimple_expand_vec_cond_expr(), is_truth_type_for(), layout_type(), make_vector_type(), native_encode_vector_part(), native_interpret_vector_part(), simplify_vector_constructor(), store_constructor(), supportable_narrowing_operation(), supportable_widening_operation(), truth_type_for(), vect_build_all_ones_mask(), vect_check_scalar_mask(), vect_create_constant_vectors(), vect_create_destination_var(), vect_emulated_vector_p(), vect_get_vec_defs_for_operand(), vect_get_vector_types_for_stmt(), vect_init_pattern_stmt(), vect_init_vector(), vect_is_simple_cond(), vect_maybe_update_slp_op_vectype(), vect_slp_convert_to_external(), vector_element_bits(), vector_element_bits_tree(), vectorizable_assignment(), vectorizable_call(), vectorizable_comparison_1(), vectorizable_condition(), vectorizable_conversion(), vectorizable_live_operation(), vectorizable_live_operation_1(), vectorizable_operation(), vectorizable_simd_clone_call(), vectorizable_store(), verify_gimple_assign_binary(), verify_gimple_assign_ternary(), verify_gimple_assign_unary(), verify_gimple_comparison(), and vn_reference_eq().

◆ VECTOR_CST_DUPLICATE_P

#define VECTOR_CST_DUPLICATE_P ( NODE ) (VECTOR_CST_NELTS_PER_PATTERN (NODE) == 1)

Referenced by initializer_zerop(), integer_all_onesp(), integer_onep(), integer_zerop(), real_minus_onep(), real_onep(), and uniform_vector_p().

◆ VECTOR_CST_ELT

#define VECTOR_CST_ELT	(		NODE,
			IDX ) vector_cst_elt (NODE, IDX)

◆ VECTOR_CST_ENCODED_ELT

◆ VECTOR_CST_ENCODED_ELTS

#define VECTOR_CST_ENCODED_ELTS ( NODE ) (VECTOR_CST_CHECK (NODE)->vector.elts)

Referenced by tree_vector_builder::build().

◆ VECTOR_CST_LOG2_NPATTERNS

#define VECTOR_CST_LOG2_NPATTERNS ( NODE ) (VECTOR_CST_CHECK (NODE)->base.u.vector_cst.log2_npatterns)

Referenced by make_vector(), operand_compare::operand_equal_p(), and streamer_write_tree_header().

◆ VECTOR_CST_NELTS

#define VECTOR_CST_NELTS ( NODE ) (TYPE_VECTOR_SUBPARTS (TREE_TYPE (NODE)))

In a VECTOR_CST node.  See generic.texi for details.

Referenced by bitmask_inv_cst_vector_p(), build_vector_from_ctor(), categorize_ctor_elements_1(), const_binop(), const_unop(), dump_generic_node(), ipa_icf::sem_variable::equals(), expand_debug_expr(), expand_expr_real_1(), fold_const_fold_left(), fold_const_reduction(), fold_convert_const(), fold_relational_const(), fold_ternary_loc(), is_combined_permutation_identity(), native_encode_vector(), tree_vector_builder::nelts_of(), output_constant(), simplify_bitfield_ref(), single_nonzero_element(), and vec_cst_ctor_to_array().

◆ VECTOR_CST_NELTS_PER_PATTERN

#define VECTOR_CST_NELTS_PER_PATTERN ( NODE ) (VECTOR_CST_CHECK (NODE)->base.u.vector_cst.nelts_per_pattern)

Referenced by compare_constant(), const_hash_1(), const_vector_from_tree(), const_vector_mask_from_tree(), fold_vec_perm_cst(), fold_view_convert_vector_encoding(), operand_compare::hash_operand(), make_vector(), tree_vector_builder::nelts_per_pattern_of(), operand_compare::operand_equal_p(), print_node(), single_nonzero_element(), streamer_write_tree_header(), tree_to_vec_perm_builder(), and vector_cst_encoded_nelts().

◆ VECTOR_CST_NPATTERNS

◆ VECTOR_CST_STEPPED_P

#define VECTOR_CST_STEPPED_P ( NODE ) (VECTOR_CST_NELTS_PER_PATTERN (NODE) == 3)

Referenced by const_binop(), fold_view_convert_vector_encoding(), initializer_each_zero_or_onep(), operation_could_trap_helper_p(), vector_cst_elt(), and vector_cst_int_elt().

◆ VECTOR_FLOAT_TYPE_P

#define VECTOR_FLOAT_TYPE_P ( TYPE )

Value:

(VECTOR_TYPE_P (TYPE) \

&& TREE_CODE (TREE_TYPE (TYPE)) == REAL_TYPE)

Nonzero if TYPE represents a vector floating-point type.

Referenced by valid_lattice_transition(), and verify_gimple_assign_unary().

◆ VECTOR_INTEGER_TYPE_P

#define VECTOR_INTEGER_TYPE_P ( TYPE )

Value:

(VECTOR_TYPE_P (TYPE) \

&& TREE_CODE (TREE_TYPE (TYPE)) == INTEGER_TYPE)

Nonzero if TYPE represents a vector integer type.

Referenced by bitmask_inv_cst_vector_p(), expand_vector_operation(), expand_vector_operations_1(), fold_binary_loc(), simplify_permutation(), verify_gimple_assign_unary(), and verify_gimple_comparison().

◆ VECTOR_TYPE_P

#define VECTOR_TYPE_P ( TYPE ) (TREE_CODE (TYPE) == VECTOR_TYPE)

Nonzero if TYPE represents a vector type.

Referenced by build_uniform_cst(), compare_access_positions(), compare_type_sizes(), compound_type_base(), constant_boolean_node(), copy_decl_for_dup_finish(), determine_max_movement(), directly_supported_p(), do_binop(), do_cond(), do_store_flag(), do_vec_conversion(), element_mode(), estimate_move_cost(), execute_update_addresses_taken(), expand_debug_expr(), expand_expr_real_1(), expand_expr_real_2(), expand_gimple_basic_block(), expand_UBSAN_CHECK_ADD(), expand_UBSAN_CHECK_MUL(), expand_UBSAN_CHECK_SUB(), expand_vector_conversion(), expand_vector_operations_1(), fold_binary_loc(), fold_binary_op_with_conditional_arg(), fold_cond_expr_with_comparison(), fold_const_vec_convert(), fold_convert_const(), fold_convert_loc(), fold_convertible_p(), fold_indirect_ref_1(), fold_invert_truthvalue(), fold_read_from_vector(), fold_relational_const(), fold_ternary_loc(), fold_view_convert_expr(), get_inner_reference(), get_scalar_evolution(), gimple_canonical_types_compatible_p(), gimple_expand_vec_set_extract_expr(), handle_mem_ref(), initializer_constant_valid_p(), instrument_si_overflow(), invert_truthvalue_loc(), loop_has_vector_phi_nodes(), maybe_canonicalize_mem_ref_addr(), maybe_resimplify_conditional_op(), maybe_rewrite_mem_ref_base(), non_rewritable_lvalue_p(), non_rewritable_mem_ref_base(), note_nonlocal_vla_type(), odr_types_equivalent_p(), operand_compare::operand_equal_p(), optab_for_tree_code(), optimize_atomic_compare_exchange_p(), optimize_mask_stores(), propagate_subaccesses_from_rhs(), reassociate_bb(), reduce_vector_comparison_to_scalar_comparison(), reverse_storage_order_for_component_p(), sign_mask_for(), simd_clone_init_simd_arrays(), simplify_using_ranges::simplify_internal_call_using_ranges(), simplify_permutation(), simplify_vector_constructor(), store_constructor(), subparts_gt(), supportable_convert_operation(), supportable_half_widening_operation(), tree_simple_nonnegative_warnv_p(), type_for_widest_vector_mode(), type_has_components_p(), undistribute_bitref_for_vector(), uniform_integer_cst_p(), uniform_vector_p(), useless_type_conversion_p(), valid_gimple_rhs_p(), vect_build_one_gather_load_call(), vect_build_slp_tree_1(), vect_build_slp_tree_2(), vect_create_epilog_for_reduction(), vect_create_half_widening_stmts(), vect_init_vector(), vect_recog_gcond_pattern(), vect_slp_check_for_roots(), vect_transform_loop(), vector_element_bits(), vector_element_bits_tree(), vector_vector_composition_type(), vectorizable_load(), vectorizable_store(), vectorized_internal_fn_supported_p(), verify_gimple_assign_binary(), verify_gimple_assign_single(), verify_gimple_assign_ternary(), verify_gimple_assign_unary(), and verify_gimple_comparison().

◆ VL_EXP_CHECK

#define VL_EXP_CHECK ( T ) TREE_CLASS_CHECK (T, tcc_vl_exp)

◆ VL_EXP_CLASS_P

#define VL_EXP_CLASS_P ( NODE ) (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_vl_exp)

Nonzero if NODE represents a function call-like expression with a
variable-length operand vector.

Referenced by expand_expr_real_1(), extract_muldiv_1(), substitute_placeholder_in_expr(), and tree_operand_length().

◆ VL_EXP_OPERAND_LENGTH

#define VL_EXP_OPERAND_LENGTH ( NODE ) ((int)TREE_INT_CST_LOW (VL_EXP_CHECK (NODE)->exp.operands[0]))

In a tcc_vl_exp node, operand 0 is an INT_CST node holding the operand
length.  Its value includes the length operand itself; that is,
the minimum valid length is 1.
Note that we have to bypass the use of TREE_OPERAND to access
that field to avoid infinite recursion in expanding the macros.

Referenced by tree_operand_length(), and tree_size().

◆ void_list_node

#define void_list_node global_trees[TI_VOID_LIST_NODE]

The node that should be placed at the end of a parameter list to
indicate that the function does not take a variable number of
arguments.  The TREE_VALUE will be void_type_node and there will be
no TREE_CHAIN.  Language-independent code should not assume
anything else about this node.

Referenced by block_move_libcall_safe_for_call_parm(), build_adjusted_function_type(), build_common_builtin_nodes(), build_common_tree_nodes(), build_function_type_array_1(), build_function_type_list_1(), dump_function_declaration(), get_call_args(), ipa_get_callee_param_type(), lower_assumption(), lower_resx(), maybe_canonicalize_argtypes(), prepare_call_arguments(), and simd_clone_adjust_argument_types().

◆ void_node

#define void_node global_trees[TI_VOID]

Referenced by build_common_tree_nodes(), clear_line_info(), gimplify_call_expr(), gimplify_omp_affinity(), gimplify_omp_atomic(), gimplify_omp_depend(), and lower_rec_input_clauses().

◆ void_type_node

#define void_type_node global_trees[TI_VOID_TYPE]

Referenced by alloc_stmt_list(), asan_expand_mark_ifn(), assign_parm_find_data_types(), build3(), build_adjusted_function_type(), build_and_jump(), build_asan_poison_call_expr(), build_case_label(), build_common_builtin_nodes(), build_common_tree_nodes(), build_cxa_atexit_decl(), build_empty_stmt(), build_gcov_exit_decl(), build_info_type(), build_init_ctor(), build_predict_expr(), cgraph_build_static_cdtor_1(), count_num_arguments(), create_artificial_label(), create_loop_fn(), create_omp_child_function(), create_task_copyfn(), create_vop_var(), default_external_stack_protect_fail(), default_hidden_stack_protect_fail(), do_rpo_vn_1(), dump_generic_node(), eliminate_dom_walker::eliminate_stmt(), emit_library_call_value_1(), function_arg_info::end_marker(), evaluate_properties_for_edge(), expand_expr_real_2(), expand_omp_atomic_fetch_op(), expand_omp_for_generic(), expand_omp_target(), fold_builtin_addc_subc(), fold_builtin_arith_overflow(), fold_builtin_sincos(), force_gimple_operand_1(), free_odr_warning_data(), get_spill_slot_decl(), get_trampoline_type(), gimple_fold_call(), gimple_init_gcov_profiler(), gimple_push_cleanup(), gimplify_bind_expr(), gimplify_call_expr(), gimplify_cond_expr(), gimplify_decl_expr(), gimplify_exit_expr(), gimplify_init_constructor(), gimplify_modify_expr_rhs(), gimplify_omp_affinity(), gimplify_omp_atomic(), gimplify_omp_depend(), gimplify_omp_for(), gimplify_omp_loop(), gimplify_save_expr(), gimplify_scan_omp_clauses(), gimplify_target_expr(), gimplify_transaction(), handle_builtin_alloca(), initialize_sanitizer_builtins(), layout_decl(), lower_omp_master(), lower_omp_single_copy(), lower_omp_target(), lower_rec_input_clauses(), lower_reduction_clauses(), lto_output_decl_state_refs(), maybe_remove_unused_call_args(), maybe_warn_nonstring_arg(), move_hint_to_base(), omit_one_operand_loc(), unsupported_range::operator=(), optimize_stdarg_builtin(), optimize_va_list_gpr_fpr_size(), push_dummy_function(), cgraph_edge::redirect_call_stmt_to_callee(), rt_bb_visited::rt_bb_visited(), self_referential_size(), set_stack_check_libfunc(), ipcp_vr_lattice::set_to_bottom(), shortcut_cond_expr(), shortcut_cond_r(), simd_clone_adjust(), simd_clone_adjust_argument_types(), simd_clone_adjust_return_type(), simd_clone_clauses_extract(), stdarg_p(), tree_function_versioning(), tree_ssa_prefetch_arrays(), unsupported_range::type(), type_argument_type(), ubsan_encode_value(), ubsan_instrument_float_cast(), and voidify_wrapper_expr().

◆ VOID_TYPE_P

#define VOID_TYPE_P ( NODE ) (TREE_CODE (NODE) == VOID_TYPE)

Nonzero if this type is the (possibly qualified) void type.

Referenced by ipa_param_adjustments::adjust_decl(), aggregate_value_p(), assign_parm_find_data_types(), btf_collect_datasec(), btf_init_postprocess(), builtin_call_nomodifying_p(), builtin_mathfn_code(), consider_split(), convert_to_integer_1(), create_coalesce_list_for_region(), create_function_info_for(), declare_return_variable(), funct_state_summary_t::duplicate(), eliminate_dom_walker::eliminate_stmt(), estimate_move_cost(), expand_expr_real_2(), expand_return(), expand_thunk(), fixup_noreturn_call(), fold_binary_op_with_conditional_arg(), fold_builtin_atomic_always_lock_free(), fold_ternary_loc(), fold_truth_not_expr(), fold_unary_loc(), for_all_parms(), get_ref_base_and_extent(), gimple_build(), gimple_build(), gimple_build(), gimple_build(), gimple_builtin_call_types_compatible_p(), gimple_canonical_types_compatible_p(), gimple_fold_call(), gimplify_arg(), gimplify_call_expr(), gimplify_cond_expr(), gimplify_expr(), gimplify_modify_expr_rhs(), gimplify_return_expr(), gimplify_target_expr(), go_format_type(), goa_stabilize_expr(), instrument_object_size(), is_gimple_stmt(), maybe_diag_incompatible_alias(), maybe_rewrite_mem_ref_base(), non_rewritable_mem_ref_base(), parm_object_size(), plausible_type_for_simd_clone(), propagate_malloc(), cgraph_edge::redirect_call_stmt_to_callee(), ref_all_alias_ptr_type_p(), shortcut_cond_r(), split_function(), store_expr(), tree_builtin_call_types_compatible_p(), tree_function_versioning(), tree_invalid_nonnegative_warnv_p(), type_argument_type(), type_num_arguments(), voidify_wrapper_expr(), warn_function_const(), and warn_function_pure().

◆ walk_tree

#define walk_tree	(	a,
		b,
		c,
		d ) walk_tree_1 (a, b, c, d, NULL)

Referenced by add_candidate_1(), add_local_variables(), clear_unused_block_pointer(), computation_cost(), contains_label_1(), contains_label_p(), convert_local_omp_clauses(), convert_local_reference_op(), convert_nonlocal_omp_clauses(), convert_nonlocal_reference_op(), convert_tramp_reference_stmt(), copy_debug_stmt(), copy_if_shared(), copy_if_shared_r(), copy_phis_for_bb(), copy_tree_body(), copy_tree_body_r(), create_dispatcher_calls(), eliminate_local_variables_stmt(), expand_omp_build_assign(), expand_omp_build_cond(), expand_omp_simd(), extract_omp_for_update_vars(), find_inv_vars(), find_ssaname_in_store(), finish_taskreg_scan(), fixup_child_record_type(), fixup_remapped_decl(), function_and_variable_visibility(), get_symbol_initial_value(), gimplify_decl_expr(), gimplify_init_constructor(), gimplify_init_ctor_preeval(), gimplify_omp_for(), gimplify_omp_loop(), gimplify_scan_omp_clauses(), insert_debug_temp_for_var_def(), instantiate_decls(), instantiate_decls_1(), instantiate_expr(), ipa_simd_modify_stmt_ops(), lower_emutls_1(), lower_emutls_phi_arg(), lower_omp_1(), lto_output(), mark_all_vars_used(), maybe_optimize_arith_overflow(), optimize_target_teams(), optimize_va_list_gpr_fpr_size(), record_references_in_initializer(), remap_decl(), remap_decls(), remap_gimple_op_r(), remap_gimple_stmt(), remap_type_1(), remap_vla_decls(), ipa_param_body_adjustments::remap_with_debug_expressions(), replace_block_vars_by_duplicates(), replace_trapping_overflow(), rewrite_to_non_trapping_overflow(), rtl_for_decl_init(), scan_omp_op(), self_referential_size(), task_copyfn_remap_type(), tree_add_const_value_attribute(), tree_function_versioning(), tree_overlaps_hard_reg_set(), unmark_visited(), unshare_and_remap(), unshare_expr(), unshare_expr_without_location(), update_clone_info(), verify_expr_location_1(), verify_gimple_in_cfg(), verify_loop_structure(), walk_gimple_asm(), walk_gimple_omp_for(), and walk_gimple_op().

◆ walk_tree_without_duplicates

#define walk_tree_without_duplicates	(	a,
		b,
		c ) walk_tree_without_duplicates_1 (a, b, c, NULL)

Referenced by contains_abnormal_ssa_name_p(), debug_find_tree(), determine_base_object(), gimplify_omp_for(), gimplify_omp_loop(), omp_discover_declare_target_fn_r(), omp_discover_implicit_declare_target(), and walk_type_fields().

Typedef Documentation

◆ widest2_int_cst

typedef generic_wide_int<wi::extended_tree <WIDEST_INT_MAX_PRECISION * 2> > widest2_int_cst

Used to convert a tree to a widest2_int like this:
widest2_int foo = widest2_int_cst (some_tree).

Enumeration Type Documentation

◆ access_mode

enum access_mode

Kinds of access to pass-by-reference arguments to functions.

Enumerator
access_none
access_read_only
access_write_only
access_read_write
access_deferred

◆ cst_size_error

enum cst_size_error

Desription of the reason why the argument of valid_constant_size_p
is not a valid size.

Enumerator
cst_size_ok
cst_size_not_constant
cst_size_negative
cst_size_too_big
cst_size_overflow

◆ special_array_member

enum struct special_array_member

strong

Describes a "special" array member for a COMPONENT_REF.

Enumerator
none
int_0
trail_0
trail_1
trail_n
int_n

Function Documentation

◆ allocate_decl_uid()

int allocate_decl_uid ( void )

extern

Allocate and return a new UID from the DECL_UID namespace.

References next_decl_uid.

Referenced by build_fake_var_decl(), copy_node(), ipa_pta_execute(), and make_node().

◆ arg_int_size_in_bytes()

HOST_WIDE_INT arg_int_size_in_bytes ( const_tree type )

extern

Like int_size_in_bytes, but handle empty records specially.

References int_size_in_bytes(), and TYPE_EMPTY_P.

Referenced by copy_blkmode_to_reg(), hard_function_value(), and store_one_arg().

◆ arg_size_in_bytes()

tree arg_size_in_bytes ( const_tree type )

extern

Like size_in_bytes, but handle empty records specially.

References size_in_bytes(), size_zero_node, and TYPE_EMPTY_P.

Referenced by locate_and_pad_parm(), std_gimplify_va_arg_expr(), and store_one_arg().

◆ array_ref_element_size()

tree array_ref_element_size ( tree exp )

extern

Return a tree of sizetype representing the size, in bytes, of the element
of EXP, an ARRAY_REF or an ARRAY_RANGE_REF.

References exp(), EXPR_LOCATION, fold_convert_loc(), ggc_alloc(), size_binop_loc(), size_int, sizetype, SUBSTITUTE_PLACEHOLDER_IN_EXPR, TREE_OPERAND, TREE_TYPE, TYPE_ALIGN_UNIT, and TYPE_SIZE_UNIT.

Referenced by compute_object_offset(), constant_byte_string(), dump_generic_node(), ipa_icf::sem_variable::equals(), fold_addr_of_array_ref_difference(), fold_const_aggregate_ref_1(), get_addr_base_and_unit_offset_1(), get_inner_reference(), get_ref_base_and_extent(), get_up_bounds_for_array_ref(), gimplify_compound_lval(), gimplify_scan_omp_clauses(), idx_analyze_ref(), idx_find_step(), operand_compare::operand_equal_p(), and strip_offset_1().

◆ array_ref_flexible_size_p()

bool array_ref_flexible_size_p	(	tree	ref,
		bool *	is_trailing_array )

extern

Returns true if REF is an array reference, a component reference,
or a memory reference to an array whose actual size might be larger
than its upper bound implies.

Returns true if REF is an array reference, a component reference,
  or a memory reference to an array whose actual size might be larger
  than its upper bound implies, there are multiple cases:
  A. a ref to a flexible array member at the end of a structure;
  B. a ref to an array with a different type against the original decl;
     for example:

  short a[16] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
  (*((char(*)[16])&a[0]))[i+8]

  C. a ref to an array that was passed as a parameter;
     for example:

  int test (uint8_t *p, uint32_t t[1][1], int n) {
  for (int i = 0; i < 4; i++, p++)
    t[i][0] = ...;

  If non-null, set IS_TRAILING_ARRAY to true if the ref is the above case A.

References DECL_CHAIN, DECL_COMMON, DECL_NOT_FLEXARRAY, DECL_P, DECL_SIZE, DECL_SIZE_UNIT, gcc_assert, gcc_unreachable, get_addr_base_and_unit_offset(), get_base_address(), ggc_alloc(), handled_component_p(), known_le, last_field(), NULL_TREE, offset, wi::to_offset(), TREE_CODE, TREE_OPERAND, TREE_TYPE, TYPE_DOMAIN, TYPE_MAX_VALUE, TYPE_MIN_VALUE, TYPE_SIZE, TYPE_SIZE_UNIT, and VAR_P.

Referenced by addr_object_size(), component_ref_sam_type(), component_ref_to_zero_sized_trailing_array_p(), get_range_strlen_tree(), idx_infer_loop_bounds(), idx_within_array_bound(), maybe_set_strlen_range(), stmt_kills_ref_p(), and trailing_array().

◆ array_ref_low_bound()

tree array_ref_low_bound ( tree exp )

extern

Return a tree representing the lower bound of the array mentioned in
EXP, an ARRAY_REF or an ARRAY_RANGE_REF.

References build_int_cst(), error_mark_node, exp(), ggc_alloc(), integer_zero_node, SUBSTITUTE_PLACEHOLDER_IN_EXPR, TREE_OPERAND, TREE_TYPE, TYPE_DOMAIN, and TYPE_MIN_VALUE.

Referenced by check_out_of_bounds_and_warn(), compute_object_offset(), constant_byte_string(), copy_reference_ops_from_ref(), dump_generic_node(), ipa_icf::sem_variable::equals(), expand_expr_real_1(), expr_with_var_bounded_array_refs_p(), fold_const_aggregate_ref_1(), fold_read_from_constant_string(), get_addr_base_and_unit_offset_1(), get_inner_reference(), get_ref_base_and_extent(), gimplify_compound_lval(), gimplify_scan_omp_clauses(), handle_array_ref(), idx_find_step(), idx_infer_loop_bounds(), idx_within_array_bound(), in_array_bounds_p(), maybe_canonicalize_mem_ref_addr(), operand_compare::operand_equal_p(), optimize_count_trailing_zeroes(), and range_in_array_bounds_p().

◆ array_ref_up_bound()

tree array_ref_up_bound ( tree exp )

extern

Return a tree representing the upper bound of the array mentioned in
EXP, an ARRAY_REF or an ARRAY_RANGE_REF.

References exp(), ggc_alloc(), NULL_TREE, SUBSTITUTE_PLACEHOLDER_IN_EXPR, TREE_OPERAND, TREE_TYPE, TYPE_DOMAIN, and TYPE_MAX_VALUE.

Referenced by array_bounds_checker::check_array_ref(), idx_infer_loop_bounds(), idx_within_array_bound(), in_array_bounds_p(), and range_in_array_bounds_p().

◆ array_type_nelts()

tree array_type_nelts ( const_tree type )

extern

Return, as a tree node, the number of elements for TYPE (which is an
ARRAY_TYPE) minus one.  This counts only elements of the top array.

References build_int_cst(), COMPLETE_TYPE_P, error_mark_node, fold_build2, ggc_alloc(), integer_zerop(), TREE_TYPE, TYPE_DOMAIN, TYPE_MAX_VALUE, TYPE_MIN_VALUE, and TYPE_SIZE.

Referenced by count_type_elements(), and is_empty_type().

◆ as_builtin_fn()

built_in_function as_builtin_fn ( combined_fn code )

inline

Return the target-independent built-in function represented by CODE.
Only valid if builtin_fn_p (CODE).

References builtin_fn_p(), and gcc_checking_assert.

Referenced by associated_internal_fn(), combined_fn_name(), gimple_build(), gimple_build(), gimple_build(), gimple_build(), is_copysign_call_with_1(), maybe_build_call_expr_loc(), maybe_push_res_to_seq(), and code_helper::operator built_in_function().

◆ as_combined_fn() [1/2]

combined_fn as_combined_fn ( built_in_function fn )

inline

Definitions for the ubiquitous 'tree' type for GNU compilers.
   Copyright (C) 1989-2024 Free Software Foundation, Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.

Convert a target-independent built-in function code to a combined_fn.

Referenced by convert_conditional_op(), expand_bitquery(), expand_builtin_int_roundingfn_2(), fold_builtin_1(), fold_builtin_2(), fold_builtin_3(), fold_builtin_sincos(), fully_constant_vn_reference_p(), get_call_combined_fn(), gimple_call_combined_fn(), gimple_extract(), handle_builtin_alloca(), hwasan_check_func(), mathfn_built_in(), supportable_widening_operation(), try_conditional_simplification(), vect_create_epilog_for_reduction(), and vectorize_slp_instance_root_stmt().

◆ as_combined_fn() [2/2]

combined_fn as_combined_fn ( internal_fn fn )

inline

Convert an internal function code to a combined_fn.

References END_BUILTINS.

◆ as_internal_fn()

internal_fn as_internal_fn ( combined_fn code )

inline

Return the internal function represented by CODE.  Only valid if
internal_fn_p (CODE).

References END_BUILTINS, gcc_checking_assert, and internal_fn_p().

Referenced by associated_internal_fn(), combined_fn_name(), convert_conditional_op(), gimple_build(), gimple_build(), gimple_build(), gimple_build(), is_copysign_call_with_1(), maybe_build_call_expr_loc(), maybe_push_res_to_seq(), code_helper::operator internal_fn(), supportable_widening_operation(), vect_build_slp_tree_1(), vect_gimple_build(), vectorizable_call(), vectorizable_internal_function(), and widening_fn_p().

◆ assign_assembler_name_if_needed()

void assign_assembler_name_if_needed ( tree t )

extern

If T needs an assembler name, have one created for it.

References decl_assembler_name(), DECL_SOURCE_LOCATION, ggc_alloc(), input_location, and need_assembler_name_p().

Referenced by cgraph_node::analyze(), expand_omp_target(), expand_omp_taskreg(), and mangle_referenced_decls().

◆ associative_tree_code()

bool associative_tree_code ( enum tree_code code )

extern

Return true if CODE represents an associative tree code.  Otherwise
return false.

References ggc_alloc().

Referenced by loop_cand::analyze_iloop_reduction_var(), associative_binary_op_p(), may_reassociate_p(), parloops_is_simple_reduction(), reassociate_bb(), undistribute_ops_list(), vect_build_slp_tree_2(), and vect_slp_check_for_roots().

◆ auto_var_in_fn_p()

bool auto_var_in_fn_p	(	const_tree	var,
		const_tree	fn )

extern

Return true if VAR is an automatic variable defined in function FN.

References auto_var_p(), DECL_CONTEXT, DECL_P, ggc_alloc(), and TREE_CODE.

Referenced by add_clobbers_to_eh_landing_pad(), can_be_nonlocal(), ipa_icf_gimple::func_checker::compare_decl(), copy_tree_body_r(), decl_maybe_in_construction_p(), estimated_stack_frame_size(), find_func_clobbers(), find_return_bb(), find_tail_calls(), find_var_from_fn(), gimple_expand_vec_set_extract_expr(), ipa_pta_execute(), mark_nonssa_use(), maybe_nonzero_address(), optimize_atomic_compare_exchange_p(), output_gimple_stmt(), points_to_possible_sra_candidate_p(), refs_local_or_readonly_memory_p(), remap_gimple_op_r(), remap_gimple_stmt(), self_inlining_addr_expr(), set_uids_in_ptset(), setup_one_parameter(), and test_nonssa_use().

◆ auto_var_p()

bool auto_var_p ( const_tree var )

extern

Return true if VAR is an automatic variable.

References DECL_EXTERNAL, ggc_alloc(), TREE_CODE, TREE_STATIC, and VAR_P.

Referenced by nontrapping_dom_walker::add_or_mark_expr(), auto_var_in_fn_p(), cond_store_replacement(), gimple_add_init_for_auto_var(), ipa_pta_execute(), and is_var_need_auto_init().

◆ bit_field_offset()

poly_uint64 bit_field_offset ( const_tree t )

inline

Return the starting bit offset of BIT_FIELD_REF T, in cases where it is
known to be a poly_uint64.  (This is always true at the gimple level.)

References TREE_OPERAND, and tree_to_poly_uint64().

Referenced by copy_reference_ops_from_ref(), optimize_vector_load(), simplify_bitfield_ref(), simplify_vector_constructor(), sra_handled_bf_read_p(), undistribute_bitref_for_vector(), vect_build_slp_tree_2(), and vect_recog_bitfield_ref_pattern().

◆ bit_field_size()

poly_uint64 bit_field_size ( const_tree t )

inline

Return the bit size of BIT_FIELD_REF T, in cases where it is known
to be a poly_uint64.  (This is always true at the gimple level.)

References TREE_OPERAND, and tree_to_poly_uint64().

Referenced by optimize_vector_load(), simplify_bitfield_ref(), simplify_vector_constructor(), sra_handled_bf_read_p(), undistribute_bitref_for_vector(), vect_build_slp_tree_2(), and vect_recog_bitfield_ref_pattern().

◆ bit_position()

tree bit_position ( const_tree field )

extern

Return the bit position of FIELD, in bits from the start of the record.
This is a tree of type bitsizetype.

References bit_from_pos(), DECL_FIELD_BIT_OFFSET, and DECL_FIELD_OFFSET.

Referenced by add_data_member_location_attribute(), build_user_friendly_ref_for_offset(), compute_record_mode(), dequeue_and_dump(), field_byte_offset(), get_vec_alignment_for_record_type(), hoist_adjacent_loads(), store_constructor(), and type_internals_preclude_sra_p_1().

◆ bitmask_inv_cst_vector_p()

tree bitmask_inv_cst_vector_p ( tree t )

extern

Checks to see if T is a constant or a constant vector and if each element E
adheres to ~E + 1 == pow2 then return ~E otherwise NULL_TREE.

References wi::add(), wi::bit_not(), build_uniform_cst(), ggc_alloc(), INTEGRAL_TYPE_P, NULL_TREE, wi::popcount(), wi::to_wide(), TREE_CODE, TREE_TYPE, ty, uniform_integer_cst_p(), unsigned_type_for(), vector_cst_elt(), VECTOR_CST_NELTS, VECTOR_INTEGER_TYPE_P, and wide_int_to_tree().

◆ block_may_fallthru()

bool block_may_fallthru ( const_tree block )

extern

Try to determine if we can fall out of the bottom of BLOCK.  This guess
need not be 100% accurate; simply be conservative and return true if we
don't know.  This is used only to avoid stupidly generating extra code.
If we're wrong, we'll just delete the extra code later.

References BIND_EXPR_BODY, block_may_fallthru(), lang_hooks::block_may_fallthru, call_expr_flags(), COND_EXPR_ELSE, COND_EXPR_THEN, CONST_CAST_TREE, ECF_NORETURN, expr_last(), ggc_alloc(), SWITCH_ALL_CASES_P, SWITCH_BODY, TREE_CODE, TREE_OPERAND, and try_catch_may_fallthru().

Referenced by block_may_fallthru(), shortcut_cond_expr(), and try_catch_may_fallthru().

◆ block_nonartificial_location()

location_t * block_nonartificial_location ( tree block )

extern

If BLOCK is inlined from an __attribute__((__artificial__))
routine, return pointer to location from where it has been
called.

References BLOCK_ABSTRACT_ORIGIN, BLOCK_SOURCE_LOCATION, BLOCK_SUPERCONTEXT, DECL_ATTRIBUTES, DECL_DECLARED_INLINE_P, ggc_alloc(), lookup_attribute(), NULL, and TREE_CODE.

Referenced by gimple_nonartificial_location(), and tree_nonartificial_location().

◆ block_ultimate_origin()

tree block_ultimate_origin ( const_tree block )

extern

Determine the "ultimate origin" of a block.

References BLOCK_ABSTRACT_ORIGIN, BLOCK_ORIGIN, DECL_ORIGIN, DECL_P, gcc_checking_assert, and NULL_TREE.

Referenced by compute_discriminator(), dump_gimple_debug(), dump_scope_block(), gen_field_die(), inlined_polymorphic_ctor_dtor_block_p(), noncall_stmt_may_be_vtbl_ptr_store(), and remove_unused_scope_block_p().

◆ build0()

tree build0	(	enum	tree_code,
		tree	CXX_MEM_STAT_INFO )

extern

◆ build1()

tree build1	(	enum	tree_code,
		tree	,
		tree	CXX_MEM_STAT_INFO )

extern

Referenced by build1_loc().

◆ build1_loc()

tree build1_loc	(	location_t	loc,
		enum tree_code	code,
		tree	type,
		tree arg1	CXX_MEM_STAT_INFO )

inline

_loc versions of build[1-5].

References build1(), CAN_HAVE_LOCATION_P, ggc_alloc(), PASS_MEM_STAT, and SET_EXPR_LOCATION.

Referenced by build_cxa_dtor_registrations(), build_fold_addr_expr_with_type_loc(), build_fold_indirect_ref_loc(), canonicalize_constructor_val(), convert_to_real_1(), fold_binary_loc(), fold_build1_loc(), fold_build_cleanup_point_expr(), fold_builtin_addc_subc(), fold_builtin_arith_overflow(), fold_truth_not_expr(), fold_unary_loc(), forward_propagate_addr_expr_1(), gimple_call_set_fndecl(), gimple_fold_stmt_to_constant_1(), gimplify_expr(), maybe_wrap_with_location(), negate_expr(), non_lvalue_loc(), omit_one_operand_loc(), predicate_bbs(), and save_expr().

◆ build2()

tree build2	(	enum	tree_code,
		tree	,
		tree	,
		tree	CXX_MEM_STAT_INFO )

extern

Referenced by build2_loc().

◆ build2_loc()

tree build2_loc	(	location_t	loc,
		enum tree_code	code,
		tree	type,
		tree	arg0,
		tree arg1	CXX_MEM_STAT_INFO )

inline

References build2(), CAN_HAVE_LOCATION_P, ggc_alloc(), PASS_MEM_STAT, and SET_EXPR_LOCATION.

Referenced by adjust_bool_pattern(), associate_trees(), clear_padding_flush(), convert_to_complex_1(), convert_to_integer_1(), convert_to_real_1(), expand_omp_atomic_fetch_op(), fold_binary_loc(), fold_build2_loc(), fold_builtin_addc_subc(), fold_builtin_arith_overflow(), fold_range_test(), fold_truth_andor_1(), fold_truth_not_expr(), fold_unary_loc(), get_narrower(), gimple_fold_call(), gimple_simplify_phiopt(), gimplify_expr(), gimplify_omp_affinity(), gimplify_omp_atomic(), gimplify_omp_depend(), strlen_pass::handle_builtin_memcmp(), make_range_step(), maybe_optimize_arith_overflow(), omit_one_operand_loc(), omit_two_operands_loc(), optimize_bit_field_compare(), predicate_bbs(), prepare_target_mem_ref_lvalue(), and vect_recog_ctz_ffs_pattern().

◆ build3()

tree build3	(	enum	tree_code,
		tree	,
		tree	,
		tree	,
		tree	CXX_MEM_STAT_INFO )

extern

Referenced by build3_loc().

◆ build3_loc()

tree build3_loc	(	location_t	loc,
		enum tree_code	code,
		tree	type,
		tree	arg0,
		tree	arg1,
		tree arg2	CXX_MEM_STAT_INFO )

inline

References build3(), CAN_HAVE_LOCATION_P, ggc_alloc(), PASS_MEM_STAT, and SET_EXPR_LOCATION.

Referenced by fold_build3_loc(), fold_truth_not_expr(), fold_unary_loc(), gimplify_expr(), gimplify_omp_atomic(), gimplify_omp_depend(), make_bit_field_ref(), and maybe_canonicalize_mem_ref_addr().

◆ build4()

tree build4	(	enum	tree_code,
		tree	,
		tree	,
		tree	,
		tree	,
		tree	CXX_MEM_STAT_INFO )

extern

Referenced by build4_loc().

◆ build4_loc()

tree build4_loc	(	location_t	loc,
		enum tree_code	code,
		tree	type,
		tree	arg0,
		tree	arg1,
		tree	arg2,
		tree arg3	CXX_MEM_STAT_INFO )

inline

References build4(), CAN_HAVE_LOCATION_P, ggc_alloc(), PASS_MEM_STAT, and SET_EXPR_LOCATION.

Referenced by expand_vector_ubsan_overflow(), fold_indirect_ref_1(), and ubsan_expand_vptr_ifn().

◆ build5()

tree build5	(	enum	tree_code,
		tree	,
		tree	,
		tree	,
		tree	,
		tree	,
		tree	CXX_MEM_STAT_INFO )

extern

Referenced by build5_loc().

◆ build5_loc()

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 )

inline

References build5(), CAN_HAVE_LOCATION_P, ggc_alloc(), PASS_MEM_STAT, and SET_EXPR_LOCATION.

◆ build_aligned_type()

tree build_aligned_type	(	tree	type,
		unsigned int	align )

extern

Create a variant of type T with alignment ALIGN.

Create a variant of type T with alignment ALIGN which
is measured in bits.

References build_variant_type_copy(), check_aligned_type(), SET_TYPE_ALIGN, type(), TYPE_ALIGN, TYPE_MAIN_VARIANT, TYPE_NEXT_VARIANT, TYPE_PACKED, and TYPE_USER_ALIGN.

Referenced by build_ref_for_offset(), clear_padding_flush(), compute_avail(), copy_ref_info(), expand_call_mem_ref(), fill_vector_of_new_param_types(), fold_unary_loc(), gather_mem_refs_stmt(), get_references_in_stmt(), gimple_fold_builtin_memory_op(), gimple_fold_partial_load_store_mem_ref(), gimplify_expr(), ipa_param_adjustments::modify_call(), ref_at_iteration(), replace_ref(), rewrite_use_address(), vectorizable_load(), and vectorizable_store().

◆ build_all_ones_cst()

tree build_all_ones_cst ( tree type )

extern

Return an integer of type TYPE containing all 1's in as much precision as
it contains, or a complex or vector whose subparts are such integers.

References build_all_ones_cst(), build_complex(), build_minus_one_cst(), ggc_alloc(), TREE_CODE, and TREE_TYPE.

Referenced by analyze_and_compute_bitwise_induction_effect(), build_all_ones_cst(), do_compare(), eliminate_not_pairs(), eliminate_plus_minus_pair(), fold_while_ult(), get_range_strlen(), get_range_strlen(), get_range_strlen_dynamic(), get_range_strlen_dynamic(), get_range_strlen_phi(), get_range_strlen_tree(), lower_omp_for_scan(), native_interpret_vector_part(), neutral_op_for_reduction(), undistribute_bitref_for_vector(), vect_create_constant_vectors(), vect_gen_loop_len_mask(), vect_init_vector(), and vect_set_loop_condition_normal().

◆ build_alloca_call_expr()

tree build_alloca_call_expr	(	tree	size,
		unsigned int	align,
		HOST_WIDE_INT	max_size )

extern

Return a function call to the appropriate builtin alloca variant.

SIZE is the size to be allocated.  ALIGN, if non-zero, is the requested
alignment of the allocated area.  MAX_SIZE, if non-negative, is an upper
bound for SIZE in case it is not a fixed value.

References build_call_expr(), builtin_decl_explicit(), ggc_alloc(), and size_int.

Referenced by gimplify_parameters(), and gimplify_vla_decl().

◆ build_array_type()

tree build_array_type	(	tree	elt_type,
		tree	index_type,
		bool	typeless_storage )

extern

Wrapper around build_array_type_1 with SHARED set to true.

References build_array_type_1(), and ggc_alloc().

Referenced by attr_access::array_as_string(), asan_pp_string(), build_array_type_nelts(), build_fn_info_type(), build_info(), build_info_type(), tree_switch_conversion::switch_conversion::build_one_array(), build_printable_array_type(), build_string_literal(), coverage_counter_alloc(), coverage_end_function(), coverage_obj_finish(), get_descriptor_type(), get_memory_rtx(), get_nl_goto_field(), get_trampoline_type(), gimplify_omp_depend(), init_eh(), reconstruct_complex_type(), resolve_addr_in_expr(), store_expr(), and ubsan_get_type_descriptor_type().

◆ build_array_type_1()

tree build_array_type_1	(	tree	elt_type,
		tree	index_type,
		bool	typeless_storage,
		bool	shared,
		bool	set_canonical )

extern

Construct, lay out and return the type of arrays of elements with ELT_TYPE
and number of elements specified by the range of values of INDEX_TYPE.
If TYPELESS_STORAGE is true, TYPE_TYPELESS_STORAGE flag is set on the type.
If SHARED is true, reuse such a type that has already been constructed.
If SET_CANONICAL is true, compute TYPE_CANONICAL from the element type.

References build_array_type_1(), error(), gcc_unreachable, ggc_alloc(), type_hash::hash, integer_type_node, layout_type(), make_node(), NULL_TREE, SET_TYPE_STRUCTURAL_EQUALITY, TREE_CODE, TREE_TYPE, TYPE_ADDR_SPACE, TYPE_CANONICAL, TYPE_DOMAIN, type_hash_canon(), type_hash_canon_hash(), TYPE_STRUCTURAL_EQUALITY_P, and TYPE_TYPELESS_STORAGE.

Referenced by build_array_type(), build_array_type_1(), and build_nonshared_array_type().

◆ build_array_type_nelts()

tree build_array_type_nelts	(	tree	elt_type,
		poly_uint64	nelts )

extern

Return a representation of ELT_TYPE[NELTS], using indices of type
sizetype.

References build_array_type(), build_index_type(), ggc_alloc(), and size_int.

Referenced by asan_finish_file(), build_printable_array_type(), rt_bb_visited::check(), array_bounds_checker::check_mem_ref(), clear_padding_flush(), create_tmp_simd_array(), create_vector_array(), expand_omp_for_generic(), expand_omp_ordered_source_sink(), expand_vector_ubsan_overflow(), finish_bitfield_representative(), fold_builtin_alloca_with_align(), get_target_arguments(), gimple_fold_builtin_memory_op(), gimple_lower_bitint(), gimplify_omp_for(), lower_depend_clauses(), lower_omp_target(), lower_omp_task_reductions(), lower_rec_input_clauses(), lower_rec_simd_input_clauses(), maybe_trim_constructor_store(), omp_finish_file(), shrink_simd_arrays(), simd_clone_adjust(), simd_clone_adjust_return_type(), ubsan_expand_vptr_ifn(), ubsan_source_location(), ubsan_type_descriptor(), vector_element(), vectorizable_load(), vectorizable_store(), and rt_bb_visited::vtype().

◆ build_bitint_type()

tree build_bitint_type	(	unsigned HOST_WIDE_INT	precision,
		int	unsignedp )

extern

Builds a signed or unsigned _BitInt(PRECISION) type.

References inchash::add_expr(), bitint_type_cache, fixup_signed_type(), fixup_unsigned_type(), gcc_checking_assert, ggc_alloc(), make_node(), MAX_INT_CACHED_PREC, NULL, type_hash_canon(), TYPE_MAX_VALUE, TYPE_PRECISION, and vec_safe_grow_cleared().

Referenced by analyze_access_subtree(), gimple_lower_bitint(), omp_extract_for_data(), and signed_or_unsigned_type_for().

◆ build_block()

tree build_block	(	tree	vars,
		tree	subblocks,
		tree	supercontext,
		tree	chain )

extern

BLOCK nodes are used to represent the structure of binding contours
and declarations, once those contours have been exited and their contents
compiled.  This information is used for outputting debugging info.

References BLOCK_CHAIN, BLOCK_SUBBLOCKS, BLOCK_SUPERCONTEXT, BLOCK_VARS, ggc_alloc(), and make_node().

◆ build_builtin_unreachable()

tree build_builtin_unreachable ( location_t loc )

extern

Build a call to __builtin_unreachable, possibly rewritten by
-fsanitize=unreachable.  Use this rather than the above when practical.

References build_call_expr_loc(), NULL_TREE, and sanitize_unreachable_fn().

Referenced by fold_builtin_0().

◆ build_call_array_loc()

tree build_call_array_loc	(	location_t	loc,
		tree	return_type,
		tree	fn,
		int	nargs,
		const tree *	args )

extern

Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
FN and a null static chain slot.  NARGS is the number of call arguments
which are specified as a tree array ARGS.

References build_call_1(), CALL_EXPR_ARG, ggc_alloc(), i, process_call_operands(), and SET_EXPR_LOCATION.

Referenced by fold_build_call_array_loc(), and gimplify_call_expr().

◆ build_call_expr()

tree build_call_expr	(	tree	fndecl,
		int	n,
			... )

extern

Like build_call_expr_loc (UNKNOWN_LOCATION, ...).  Duplicated because
varargs macros aren't supported by all bootstrap compilers.

References ap, build_call_expr_loc_array(), ggc_alloc(), i, and UNKNOWN_LOCATION.

Referenced by asan_dynamic_init_call(), asan_finish_file(), build_alloca_call_expr(), build_cdtor(), build_cltz_expr(), build_gcov_exit_decl(), build_init_ctor(), build_popcount_expr(), convert_to_integer_1(), convert_to_real_1(), default_external_stack_protect_fail(), default_hidden_stack_protect_fail(), emit_block_op_via_libcall(), emutls_common_1(), expand_builtin_trap(), expand_DEFERRED_INIT(), expand_omp_atomic_mutex(), expand_omp_atomic_pipeline(), expand_omp_for_generic(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), expand_task_call(), expand_taskwait_call(), fold_builtin_interclass_mathfn(), hwasan_finish_file(), lower_rec_input_clauses(), set_storage_via_libcall(), sjlj_emit_function_enter(), strdup_object_size(), and tsan_finish_file().

◆ build_call_expr_internal_loc()

tree build_call_expr_internal_loc	(	location_t	loc,
		enum internal_fn	ifn,
		tree	type,
		int	n,
			... )

extern

Build internal call expression.  This is just like CALL_EXPR, except
its CALL_EXPR_FN is NULL.  It will get gimplified later into ordinary
internal function.

References ap, build_call_expr_internal_loc_array(), ggc_alloc(), and i.

Referenced by build_asan_poison_call_expr(), build_cltz_expr(), build_popcount_expr(), create_ifn_alias_checks(), expand_omp_atomic_pipeline(), expand_omp_simd(), fold_builtin_addc_subc(), fold_builtin_arith_overflow(), fold_builtin_bit_query(), gimple_add_init_for_auto_var(), gimplify_modify_expr(), gimplify_va_arg_expr(), lower_lastprivate_clauses(), lower_oacc_reductions(), and lower_rec_input_clauses().

◆ build_call_expr_internal_loc_array()

tree build_call_expr_internal_loc_array	(	location_t	,
		enum	internal_fn,
		tree	,
		int	,
		const tree *	)

extern

◆ build_call_expr_loc()

tree build_call_expr_loc	(	location_t	loc,
		tree	fndecl,
		int	n,
			... )

extern

Conveniently construct a function call expression.  FNDECL names the
function to be called, N is the number of arguments, and the "..."
parameters are the argument expressions.

References ap, build_call_expr_loc_array(), ggc_alloc(), and i.

Referenced by build_builtin_expect_predicate(), build_builtin_unreachable(), build_cxa_dtor_registrations(), build_tm_abort_call(), create_task_copyfn(), expand_omp_atomic_fetch_op(), fold_builtin_bit_query(), fold_builtin_carg(), fold_builtin_classify(), fold_builtin_sincos(), fold_builtin_strcspn(), fold_builtin_strpbrk(), fold_negate_expr_1(), gimplify_bind_expr(), gimplify_call_expr(), gimplify_omp_depend(), gimplify_va_arg_expr(), gimplify_variable_sized_compare(), instrument_object_size(), lower_omp_critical(), lower_omp_master(), lower_omp_single_copy(), lower_omp_target(), lower_rec_input_clauses(), optimize_stdarg_builtin(), ubsan_build_overflow_builtin(), and ubsan_instrument_float_cast().

◆ build_call_expr_loc_array()

tree build_call_expr_loc_array	(	location_t	loc,
		tree	fndecl,
		int	n,
		tree *	argarray )

extern

Conveniently construct a function call expression.  FNDECL names the
function to be called and N arguments are passed in the array
ARGARRAY.

References build1(), build_pointer_type(), fold_build_call_array_loc(), ggc_alloc(), and TREE_TYPE.

Referenced by build_call_expr(), build_call_expr_loc(), build_call_expr_loc_vec(), maybe_build_call_expr_loc(), and rewrite_call_expr_valist().

◆ build_call_expr_loc_vec()

tree build_call_expr_loc_vec	(	location_t	loc,
		tree	fndecl,
		vec< tree, va_gc > *	vec )

extern

Conveniently construct a function call expression.  FNDECL names the
function to be called and the arguments are passed in the vector
VEC.

References build_call_expr_loc_array(), vec_safe_address(), and vec_safe_length().

Referenced by expand_parallel_call(), expand_teams_call(), and self_referential_size().

◆ build_call_nary()

tree build_call_nary	(	tree	return_type,
		tree	fn,
		int	nargs,
			... )

extern

Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
FN and a null static chain slot.  NARGS is the number of call arguments
which are specified as "..." arguments.

References build_call_valist(), and ggc_alloc().

Referenced by expand_builtin_cexpi(), expand_ifn_atomic_bit_test_and(), and expand_ifn_atomic_op_fetch_cmp_0().

◆ build_call_valist()

tree build_call_valist	(	tree	return_type,
		tree	fn,
		int	nargs,
		va_list	args )

extern

Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
FN and a null static chain slot.  NARGS is the number of call arguments
which are specified as a va_list ARGS.

References build_call_1(), CALL_EXPR_ARG, ggc_alloc(), i, and process_call_operands().

Referenced by build_call_nary(), and build_call_nofold_loc().

◆ build_call_vec()

tree build_call_vec	(	tree	return_type,
		tree	fn,
		const vec< tree, va_gc > *	args )

extern

Like build_call_array, but takes a vec.

References build_call_1(), CALL_EXPR_ARG, FOR_EACH_VEC_SAFE_ELT, ggc_alloc(), process_call_operands(), and vec_safe_length().

Referenced by expand_builtin(), and expand_ifn_atomic_compare_exchange_into_call().

◆ build_case_label()

tree build_case_label	(	tree	low_value,
		tree	high_value,
		tree	label_decl )

extern

Make a CASE_LABEL_EXPR.

Create a CASE_LABEL_EXPR tree node and return it.

References CASE_CHAIN, CASE_HIGH, CASE_LABEL, CASE_LOW, DECL_SOURCE_LOCATION, ggc_alloc(), make_node(), NULL_TREE, SET_EXPR_LOCATION, TREE_TYPE, and void_type_node.

◆ build_clobber()

tree build_clobber	(	tree	type,
		enum clobber_kind	kind )

extern

Return a node of type TYPE for which TREE_CLOBBER_P is true.

References build_constructor(), CLOBBER_KIND, ggc_alloc(), NULL, and TREE_THIS_VOLATILE.

Referenced by add_clobbers_to_eh_landing_pad(), rt_bb_visited::check(), clobber_subtree(), detach_value(), execute_update_addresses_taken(), expand_call_inline(), expand_omp_for_generic(), gimplify_bind_expr(), gimplify_parameters(), gimplify_target_expr(), insert_clobber_before_stack_restore(), lower_depend_clauses(), lower_omp_scope(), lower_omp_single(), lower_omp_target(), lower_omp_taskreg(), lower_rec_input_clauses(), lower_rec_simd_input_clauses(), ompdevlow_adjust_simt_enter(), and vect_clobber_variable().

◆ build_common_builtin_nodes()

void build_common_builtin_nodes ( void )

extern

Call this function after instantiating all builtins that the language
front end cares about.  This will build the rest of the builtins
and internal functions that are relied upon by the tree optimizers and
the middle-end.

References build_function_type(), build_function_type_list(), build_pointer_type(), BUILT_IN_COMPLEX_DIV_MIN, BUILT_IN_COMPLEX_MUL_MIN, built_in_names, builtin_decl_explicit(), builtin_decl_explicit_p(), const_ptr_type_node, ECF_COLD, ECF_CONST, ECF_LEAF, ECF_MALLOC, ECF_NORETURN, ECF_NOTHROW, ECF_PURE, ECF_TM_PURE, ECF_XTHROW, GET_MODE_NAME, ggc_alloc(), global_options, init_internal_fns(), integer_type_node, local_define_builtin(), NULL, NULL_TREE, real_format::p, ptr_type_node, size_type_node, targetm, TREE_TYPE, type(), lang_hooks_for_types::type_for_mode, lang_hooks::types, UI_SJLJ, void_list_node, and void_type_node.

◆ build_common_tree_nodes()

void build_common_tree_nodes ( bool signed_char )

extern

Create nodes for all integer types (and error_mark_node) using the sizes
of C datatypes.  SIGNED_CHAR specifies whether char is signed.

Make fixed-point nodes based on sat/non-sat and signed/unsigned.

Make fixed-point type nodes based on four different widths.

Make fixed-point mode nodes based on sat/non-sat and signed/unsigned.

References access_private_node, access_protected_node, access_public_node, arm_bfloat_half_format, atomicDI_type_node, atomicHI_type_node, atomicQI_type_node, atomicSI_type_node, atomicTI_type_node, bfloat16_type_node, bitsize_int, bitsize_one_node, bitsize_unit_node, bitsize_zero_node, BOOL_TYPE_SIZE, boolean_false_node, boolean_true_node, boolean_type_node, build_atomic_base(), build_complex_type(), build_int_cst(), build_nonstandard_integer_type(), build_pointer_type(), build_tree_list(), build_type_variant, build_variant_type_copy(), builtin_structptr_types, ceil_log2(), char_type_node, CHAR_TYPE_SIZE, chrec_dont_know, chrec_known, complex_double_type_node, complex_float_type_node, COMPLEX_FLOATN_NX_TYPE_NODE, complex_integer_type_node, complex_long_double_type_node, const_ptr_type_node, DECIMAL128_TYPE_SIZE, DECIMAL32_TYPE_SIZE, DECIMAL64_TYPE_SIZE, dfloat128_type_node, dfloat32_type_node, dfloat64_type_node, double_ptr_type_node, double_type_node, DOUBLE_TYPE_SIZE, error_mark_node, float128_type_node, float128t_type_node, float_ptr_type_node, float_type_node, FLOAT_TYPE_SIZE, FLOATN_NX_TYPE_NODE, floatn_nx_types, gcc_assert, gcc_unreachable, get_identifier(), GET_MODE_BITSIZE(), GET_MODE_PRECISION(), ggc_alloc(), i, initialize_sizetypes(), int_n_data, int_n_enabled_p, int_n_trees, INT_TYPE_SIZE, intDI_type_node, integer_minus_one_node, integer_one_node, integer_ptr_type_node, integer_three_node, integer_type_node, integer_types, integer_zero_node, intHI_type_node, intQI_type_node, intSI_type_node, intTI_type_node, itk_intN_0, itk_unsigned_intN_0, layout_type(), long_double_ptr_type_node, long_double_type_node, LONG_DOUBLE_TYPE_SIZE, long_integer_type_node, long_long_integer_type_node, LONG_LONG_TYPE_SIZE, long_long_unsigned_type_node, LONG_TYPE_SIZE, long_unsigned_type_node, MAKE_FIXED_MODE_NODE, MAKE_FIXED_TYPE_NODE_FAMILY, make_node(), make_or_reuse_type(), make_signed_type(), make_unsigned_type(), null_pointer_node, NULL_TREE, NUM_FLOATN_NX_TYPES, POINTER_SIZE, pointer_sized_int_node, ptr_type_node, PTRDIFF_TYPE, ptrdiff_type_node, REAL_MODE_FORMAT, SA, SET_TYPE_ALIGN, SET_TYPE_MODE, short_integer_type_node, SHORT_TYPE_SIZE, short_unsigned_type_node, signed_char_type_node, int_n_trees_t::signed_type, size_int, size_one_node, SIZE_TYPE, size_type_node, size_zero_node, targetm, TREE_CODE, TREE_SET_CODE, TREE_TYPE, TYPE_MAX_VALUE, TYPE_MIN_VALUE, TYPE_PRECISION, TYPE_STRING_FLAG, TYPE_USER_ALIGN, uint128_type_node, uint16_type_node, uint32_type_node, uint64_type_node, unsigned_char_type_node, unsigned_intDI_type_node, unsigned_intHI_type_node, unsigned_intQI_type_node, unsigned_intSI_type_node, unsigned_intTI_type_node, int_n_trees_t::unsigned_type, unsigned_type_node, va_list_type_node, void_list_node, void_node, and void_type_node.

◆ build_complex()

tree build_complex	(	tree	type,
		tree	real,
		tree	imag )

extern

Return a newly constructed COMPLEX_CST node whose value is
specified by the real and imaginary parts REAL and IMAG.
Both REAL and IMAG should be constant nodes.  TYPE, if specified,
will be the type of the COMPLEX_CST; otherwise a new type will be made.

References build_complex_type(), CONSTANT_CLASS_P, gcc_assert, ggc_alloc(), make_node(), TREE_IMAGPART, TREE_OVERFLOW, TREE_REALPART, TREE_TYPE, and type().

Referenced by build_all_ones_cst(), build_complex_inf(), build_each_one_cst(), build_minus_one_cst(), build_one_cst(), build_zero_cst(), const_binop(), const_binop(), const_unop(), do_mpc_ckconv(), fold_const_call(), fold_const_call(), fold_const_call_1(), fold_const_call_1(), fold_negate_expr_1(), gimple_fold_call(), gimplify_init_constructor(), gimplify_modify_expr_complex_part(), maybe_optimize_arith_overflow(), and native_interpret_complex().

◆ build_complex_inf()

tree build_complex_inf	(	tree	type,
		bool	neg )

extern

Build a complex (inf +- 0i), such as for the result of cproj.
TYPE is the complex tree type of the result.  If NEG is true, the
imaginary zero is negative.

References build_complex(), build_real(), dconst0, dconstinf, ggc_alloc(), REAL_VALUE_TYPE, and TREE_TYPE.

◆ build_complex_type()

tree build_complex_type	(	tree	component_type,
		bool	named )

extern

Create a complex type whose components are COMPONENT_TYPE.

If NAMED is true, the type is given a TYPE_NAME.  We do not always
do so because this creates a DECL node and thus make the DECL_UIDs
dependent on the type canonicalization hashtable, which is GC-ed,
so the DECL_UIDs would not be stable wrt garbage collection.

References build_complex_type(), build_decl(), build_qualified_type(), char_type_node, COMPLETE_TYPE_P, FIXED_POINT_TYPE_P, gcc_assert, gcc_checking_assert, get_identifier(), ggc_alloc(), type_hash::hash, integer_type_node, INTEGRAL_TYPE_P, long_integer_type_node, long_long_integer_type_node, long_long_unsigned_type_node, long_unsigned_type_node, make_node(), NULL, SCALAR_FLOAT_TYPE_P, SET_TYPE_STRUCTURAL_EQUALITY, short_integer_type_node, short_unsigned_type_node, signed_char_type_node, TREE_TYPE, TYPE_CANONICAL, type_hash_canon(), type_hash_canon_hash(), TYPE_MAIN_VARIANT, TYPE_NAME, TYPE_QUALS, TYPE_STRUCTURAL_EQUALITY_P, UNKNOWN_LOCATION, unsigned_char_type_node, and unsigned_type_node.

Referenced by bitwise_type_for_mode(), build_common_tree_nodes(), build_complex(), build_complex_type(), convert_to_divmod(), expand_builtin_cexpi(), expand_doubleword_mod(), expand_omp_atomic_cas(), expand_omp_atomic_pipeline(), fold_builtin_addc_subc(), fold_builtin_arith_overflow(), fold_builtin_atomic_compare_exchange(), fold_builtin_sincos(), gimple_fold_call(), lower_omp_for_scan(), match_arith_overflow(), match_uaddc_usubc(), maybe_optimize_arith_overflow(), and signed_or_unsigned_type_for().

◆ build_constructor()

tree build_constructor	(	tree	,
		vec< constructor_elt, va_gc > *	CXX_MEM_STAT_INFO )

extern

◆ build_constructor_from_list()

tree build_constructor_from_list	(	tree	type,
		tree	vals )

extern

Return a new CONSTRUCTOR node whose type is TYPE and whose values
are in a list pointed to by VALS.

References build_constructor(), CONSTRUCTOR_APPEND_ELT, list_length(), NULL, TREE_CHAIN, TREE_PURPOSE, TREE_VALUE, and vec_alloc().

Referenced by rt_bb_visited::check().

◆ build_constructor_from_vec()

tree build_constructor_from_vec	(	tree	type,
		const vec< tree, va_gc > *	vals )

extern

Return a new CONSTRUCTOR node whose type is TYPE and whose values
are in a vector pointed to by VALS.  Note that the TREE_PURPOSE
fields in the constructor remain null.

References build_constructor(), CONSTRUCTOR_APPEND_ELT, NULL, and NULL_TREE.

◆ build_constructor_single()

tree build_constructor_single	(	tree	type,
		tree	index,
		tree	value )

extern

Build a CONSTRUCTOR node made of a single initializer, with the specified
INDEX and VALUE.

References build_constructor(), and vec_alloc().

◆ build_constructor_va()

tree build_constructor_va	(	tree	type,
		int	nelts,
			... )

extern

Return a new CONSTRUCTOR node whose type is TYPE.  NELTS is the number
of elements, provided as index/value pairs.

References build_constructor(), CONSTRUCTOR_APPEND_ELT, ggc_alloc(), NULL, and vec_alloc().

Referenced by asan_add_global(), create_odr_indicator(), ubsan_source_location(), ubsan_type_descriptor(), and vect_add_slp_permutation().

◆ build_debug_expr_decl()

tree build_debug_expr_decl ( tree type )

extern

Create and return a DEBUG_EXPR_DECL node of the given TYPE.

References DECL_ARTIFICIAL, ggc_alloc(), make_node(), SET_DECL_MODE, TREE_TYPE, type(), and TYPE_MODE.

Referenced by avoid_deep_ter_for_debug(), expand_gimple_basic_block(), insert_debug_temp_for_var_def(), ipa_simd_modify_stmt_ops(), make_new_ssa_for_def(), ipa_param_body_adjustments::mark_dead_statements(), ipa_param_adjustments::modify_call(), optimize_atomic_bit_test_and(), ipa_param_body_adjustments::prepare_debug_expressions(), remap_ssa_name(), remove_unused_ivs(), ipa_param_body_adjustments::reset_debug_stmts(), rewrite_debug_stmt_uses(), spaceship_replacement(), tree_function_versioning(), and value_replacement().

◆ build_decl()

tree build_decl	(	location_t	,
		enum	tree_code,
		tree	,
		tree	CXX_MEM_STAT_INFO )

extern

◆ build_distinct_type_copy()

tree build_distinct_type_copy ( tree CXX_MEM_STAT_INFO )

extern

Make a copy of a type node.

◆ build_each_one_cst()

tree build_each_one_cst ( tree type )

extern

Return the constant 1 in type TYPE.  If TYPE has several elements, each
element is set to 1.  In particular, this is 1 + i for complex types.

References build_complex(), build_one_cst(), ggc_alloc(), TREE_CODE, and TREE_TYPE.

◆ build_empty_stmt()

tree build_empty_stmt ( location_t loc )

extern

Build an empty statement at location LOC.

References build1(), ggc_alloc(), SET_EXPR_LOCATION, size_zero_node, and void_type_node.

Referenced by copy_tree_body_r(), fold_builtin_1(), and gimplify_call_expr().

◆ build_fn_decl()

tree build_fn_decl	(	const char *	name,
		tree	type )

extern

Builds and returns function declaration with NAME and TYPE.

References build_decl(), DECL_ARTIFICIAL, DECL_EXTERNAL, get_identifier(), ggc_alloc(), input_location, TREE_NOTHROW, and TREE_PUBLIC.

Referenced by expand_builtin_cexpi(), expand_builtin_int_roundingfn(), gimple_init_gcov_profiler(), and make_dispatcher_decl().

◆ build_function_type()

tree build_function_type	(	tree	value_type,
		tree	arg_types,
		bool	no_named_args_stdarg_p )

extern

Construct, lay out and return
the type of functions returning type VALUE_TYPE
given arguments of types ARG_TYPES.
ARG_TYPES is a chain of TREE_LIST nodes whose TREE_VALUEs
are data type nodes for the arguments of the function.
NO_NAMED_ARGS_STDARG_P is true if this is a prototyped
variable-arguments function with (...) prototype (no named arguments).
If such a type has already been constructed, reuse it.

References build_function_type(), COMPLETE_TYPE_P, error(), error_mark_node, gcc_assert, ggc_alloc(), type_hash::hash, integer_type_node, layout_type(), make_node(), maybe_canonicalize_argtypes(), NULL_TREE, SET_TYPE_STRUCTURAL_EQUALITY, TREE_CODE, TREE_TYPE, TYPE_ARG_TYPES, TYPE_CANONICAL, type_hash_canon(), type_hash_canon_hash(), TYPE_NO_NAMED_ARGS_STDARG_P, and TYPE_STRUCTURAL_EQUALITY_P.

Referenced by build_adjusted_function_type(), build_common_builtin_nodes(), build_function_type(), build_function_type_array_1(), build_function_type_list_1(), build_libfunc_function_visibility(), emit_library_call_value_1(), lower_assumption(), make_dispatcher_decl(), maybe_diag_incompatible_alias(), reconstruct_complex_type(), and self_referential_size().

◆ build_function_type_array()

tree build_function_type_array	(	tree	return_type,
		int	n,
		tree *	arg_types )

extern

Build a function type.  RETURN_TYPE is the type returned by the
function.  The function takes N named arguments, the types of which
are provided in ARG_TYPES.

References build_function_type_array_1(), and ggc_alloc().

Referenced by function_reader::create_function().

◆ build_function_type_list()

tree build_function_type_list	(	tree	return_type,
			... )

extern

Build a function type.  The RETURN_TYPE is the type returned by the
function.  If additional arguments are provided, they are
additional argument types.  The list of argument types must always
be terminated by NULL_TREE.

References build_function_type_list_1(), and ggc_alloc().

Referenced by build_common_builtin_nodes(), build_cxa_atexit_decl(), build_gcov_exit_decl(), build_info_type(), build_init_ctor(), build_personality_function(), cgraph_build_static_cdtor_1(), create_loop_fn(), create_omp_child_function(), default_external_stack_protect_fail(), default_hidden_stack_protect_fail(), expand_builtin_cexpi(), expand_builtin_int_roundingfn(), gimple_init_gcov_profiler(), init_eh(), initialize_sanitizer_builtins(), push_dummy_function(), rt_bb_visited::rt_bb_visited(), set_stack_check_libfunc(), and tree_ssa_prefetch_arrays().

◆ build_index_type()

tree build_index_type ( tree maxval )

extern

Create a type of integers to be the TYPE_DOMAIN of an ARRAY_TYPE.
MAXVAL should be the maximum value in the domain
(one less than the length of the array).

The maximum value that MAXVAL can have is INT_MAX for a HOST_WIDE_INT.
We don't enforce this limit, that is up to caller (e.g. language front end).
The limit exists because the result is a signed type and we don't handle
sizes that use more than one HOST_WIDE_INT.

References build_range_type(), ggc_alloc(), size_zero_node, and sizetype.

Referenced by attr_access::array_as_string(), asan_pp_string(), build_array_type_nelts(), tree_switch_conversion::switch_conversion::build_arrays(), build_fn_info_type(), build_info(), build_info_type(), build_string_literal(), coverage_end_function(), coverage_obj_finish(), get_descriptor_type(), get_nl_goto_field(), get_trampoline_type(), gimplify_omp_depend(), init_eh(), resolve_addr_in_expr(), and store_expr().

◆ build_index_vector()

tree build_index_vector	(	tree	vec_type,
		poly_uint64	base,
		poly_uint64	step )

extern

Return a vector with the same number of units and number of bits
as VEC_TYPE, but in which the elements are a linear series of unsigned
integers { BASE, BASE + STEP, BASE + STEP * 2, ... }.

References tree_vector_builder::build(), build_int_cstu(), build_nonstandard_integer_type(), build_vector_type(), GET_MODE_BITSIZE(), ggc_alloc(), i, INTEGRAL_TYPE_P, SCALAR_TYPE_MODE, TREE_TYPE, TYPE_UNSIGNED, and TYPE_VECTOR_SUBPARTS().

Referenced by vect_create_epilog_for_reduction(), vectorizable_call(), and vectorizable_induction().

◆ build_int_cst()

tree build_int_cst	(	tree	type,
		poly_int64	cst )

extern

Create an INT_CST node with a CST value zero extended.

static inline

Create a constant tree that contains CST sign-extended to TYPE.

References ggc_alloc(), integer_type_node, wi::shwi(), TYPE_PRECISION, and wide_int_to_tree().

◆ build_int_cst_type()

tree build_int_cst_type	(	tree	type,
		poly_int64	cst )

extern

Create a constant tree that contains CST sign-extended to TYPE.

References gcc_assert, ggc_alloc(), wi::shwi(), TYPE_PRECISION, and wide_int_to_tree().

Referenced by scev_dfs::add_to_evolution(), bit_value_assume_aligned(), canonicalize_loop_ivs(), chrec_fold_plus_1(), chrec_fold_plus_poly_poly(), decode_field_reference(), determine_exit_conditions(), fold_builtin_object_size(), fold_read_from_constant_string(), gimple_fold_builtin_memset(), gimple_gen_interval_profiler(), inverse(), optimize_bit_field_compare(), rewrite_bittest(), split_to_var_and_offset(), and try_transform_to_exit_first_loop_alt().

◆ build_int_cstu()

tree build_int_cstu	(	tree	type,
		poly_uint64	cst )

extern

Create a constant tree that contains CST zero-extended to TYPE.

References ggc_alloc(), TYPE_PRECISION, wi::uhwi(), and wide_int_to_tree().

Referenced by build_fn_info(), build_index_vector(), build_info(), do_jump(), expand_omp_for(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), get_value_from_alignment(), gimple_fold_builtin_snprintf(), gimple_fold_builtin_sprintf_chk(), infer_loop_bounds_from_pointer_arith(), lower_omp_target(), maybe_emit_sprintf_chk_warning(), propagate_bits_across_jump_function(), vect_create_cond_for_lower_bounds(), vectorizable_induction(), and vectorizable_load().

◆ build_low_bits_mask()

tree build_low_bits_mask	(	tree	type,
		unsigned	bits )

extern

Builds an integer constant in TYPE such that lowest BITS bits are ones
and the rest are zeros.

References gcc_assert, wi::mask(), TYPE_PRECISION, and wide_int_to_tree().

Referenced by iv_period(), number_of_iterations_ne(), and vect_recog_vector_vector_shift_pattern().

◆ build_method_type()

tree build_method_type	(	tree	basetype,
		tree	type )

extern

Construct, lay out and return the type of methods belonging to class
BASETYPE and whose arguments and values are described by TYPE.
If that type exists already, reuse it.
TYPE must be a FUNCTION_TYPE node.

References build_method_type_directly(), gcc_assert, ggc_alloc(), TREE_CODE, TREE_TYPE, and TYPE_ARG_TYPES.

◆ build_method_type_directly()

tree build_method_type_directly	(	tree	basetype,
		tree	rettype,
		tree	argtypes )

extern

Build a METHOD_TYPE for a member of BASETYPE.  The RETTYPE (a TYPE)
and ARGTYPES (a TREE_LIST) are the return type and arguments types
for the method.  An implicit additional parameter (of type
pointer-to-BASETYPE) is added to the ARGTYPES.

References build_method_type_directly(), build_pointer_type(), COMPLETE_TYPE_P, gcc_assert, ggc_alloc(), type_hash::hash, layout_type(), make_node(), maybe_canonicalize_argtypes(), NULL_TREE, SET_TYPE_STRUCTURAL_EQUALITY, TREE_CHAIN, tree_cons(), TREE_TYPE, TYPE_ARG_TYPES, TYPE_CANONICAL, type_hash_canon(), type_hash_canon_hash(), TYPE_MAIN_VARIANT, TYPE_METHOD_BASETYPE, and TYPE_STRUCTURAL_EQUALITY_P.

Referenced by build_method_type(), build_method_type_directly(), and reconstruct_complex_type().

◆ build_minus_one_cst()

tree build_minus_one_cst ( tree type )

extern

Return a constant of arithmetic type TYPE which is the
opposite of the multiplicative identity of the set TYPE.

References ALL_SCALAR_ACCUM_MODE_P, build_complex(), build_fixed(), build_int_cst(), build_minus_one_cst(), build_real(), build_vector_from_val(), build_zero_cst(), dconstm1, double_int_minus_one, fixed_from_double_int(), gcc_assert, gcc_unreachable, ggc_alloc(), SCALAR_TYPE_MODE, TREE_CODE, TREE_TYPE, and TYPE_MODE.

Referenced by build_all_ones_cst(), build_minus_one_cst(), expand_omp_ordered_sink(), fold_while_ult(), lower_omp_for_scan(), process_assignment(), split_tree(), try_special_add_to_ops(), ubsan_instrument_float_cast(), vect_get_loop_niters(), vect_set_loop_condition_partial_vectors(), vect_set_loop_condition_partial_vectors_avx512(), vect_set_loop_controls_directly(), vectorizable_early_exit(), vectorizable_load(), vectorizable_operation(), vectorizable_store(), vectorize_fold_left_reduction(), and zero_one_operation().

◆ build_nonshared_array_type()

tree build_nonshared_array_type	(	tree	elt_type,
		tree	index_type )

extern

Wrapper around build_array_type_1 with SHARED set to false.

References build_array_type_1(), and ggc_alloc().

◆ build_nonshared_range_type()

tree build_nonshared_range_type	(	tree	type,
		tree	lowval,
		tree	highval )

extern

Wrapper around build_range_type_1 with SHARED set to false.

References build_range_type_1(), and ggc_alloc().

◆ build_nonstandard_boolean_type()

tree build_nonstandard_boolean_type ( unsigned HOST_WIDE_INT precision )

extern

Builds a boolean type of precision PRECISION.
Used for boolean vectors to choose proper vector element size.

References fixup_signed_type(), ggc_alloc(), make_node(), MAX_BOOL_CACHED_PREC, MAX_INT_CACHED_PREC, nonstandard_boolean_type_cache, type(), and TYPE_PRECISION.

Referenced by build_truth_vector_type_for(), and build_truth_vector_type_for_mode().

◆ build_nonstandard_integer_type()

tree build_nonstandard_integer_type	(	unsigned HOST_WIDE_INT	precision,
		int	unsignedp )

extern

Builds a signed or unsigned integer type of precision PRECISION.
Used for C bitfields whose precision does not match that of
built-in target types.

References inchash::add_expr(), fixup_signed_type(), fixup_unsigned_type(), ggc_alloc(), make_node(), MAX_INT_CACHED_PREC, nonstandard_integer_type_cache, type_hash_canon(), TYPE_MAX_VALUE, and TYPE_PRECISION.

◆ build_nt()

tree build_nt	(	enum tree_code	code,
			... )

extern

Construct various types of nodes.

Similar except don't specify the TREE_TYPE
and leave the TREE_SIDE_EFFECTS as 0.
It is permissible for arguments to be null,
or even garbage if their values do not matter.

References gcc_assert, ggc_alloc(), i, make_node(), tcc_vl_exp, TREE_CODE_CLASS, TREE_CODE_LENGTH, and TREE_OPERAND.

Referenced by stabilize_reference(), and stabilize_reference_1().

◆ build_nt_call_vec()

tree build_nt_call_vec	(	tree	fn,
		vec< tree, va_gc > *	args )

extern

Similar to build_nt, but for creating a CALL_EXPR object with a
tree vec.

References build_vl_exp(), CALL_EXPR_ARG, CALL_EXPR_FN, CALL_EXPR_STATIC_CHAIN, FOR_EACH_VEC_SAFE_ELT, ggc_alloc(), NULL_TREE, and vec_safe_length().

◆ build_offset_type()

tree build_offset_type	(	tree	basetype,
		tree	type )

extern

Construct, lay out and return the type of offsets to a value
of type TYPE, within an object of type BASETYPE.
If a suitable offset type exists already, reuse it.

References build_offset_type(), COMPLETE_TYPE_P, gcc_unreachable, ggc_alloc(), type_hash::hash, layout_type(), make_node(), SET_TYPE_STRUCTURAL_EQUALITY, TREE_TYPE, type(), TYPE_CANONICAL, type_hash_canon(), type_hash_canon_hash(), TYPE_MAIN_VARIANT, TYPE_OFFSET_BASETYPE, and TYPE_STRUCTURAL_EQUALITY_P.

Referenced by build_offset_type(), and reconstruct_complex_type().

◆ build_omp_clause()

tree build_omp_clause	(	location_t	loc,
		enum omp_clause_code	code )

extern

Build an OMP clause with code CODE.  LOC is the location of the
clause.

References ggc_alloc(), ggc_internal_alloc(), OMP_CLAUSE_LOCATION, omp_clause_num_ops, OMP_CLAUSE_SET_CODE, record_node_allocation_statistics(), and TREE_SET_CODE.

Referenced by add_async_clauses_and_wait(), add_parent_or_loop_num_clause(), add_taskreg_looptemp_clauses(), adjust_nested_loop_clauses(), build_omp_struct_comp_nodes(), convert_gimple_call(), convert_local_reference_stmt(), convert_nonlocal_reference_stmt(), convert_tramp_reference_stmt(), create_parallel_loop(), decompose_kernels_region_body(), gimplify_adjust_omp_clauses(), gimplify_adjust_omp_clauses_1(), gimplify_oacc_declare_1(), gimplify_omp_depend(), gimplify_omp_for(), gimplify_omp_loop(), gimplify_omp_taskloop_expr(), lower_depend_clauses(), lower_lastprivate_conditional_clauses(), lower_omp_for(), lower_omp_for_scan(), lower_omp_scope(), lower_omp_sections(), lower_rec_input_clauses(), make_region_seq(), maybe_build_inner_data_region(), oacc_verify_routine_clauses(), omp_accumulate_sibling_list(), omp_oacc_kernels_decompose_1(), omp_resolve_clause_dependencies(), optimize_target_teams(), scan_omp_parallel(), scan_omp_simd(), scan_omp_simd_scan(), streamer_alloc_tree(), and transform_kernels_loop_clauses().

◆ build_one_cst()

tree build_one_cst ( tree type )

extern

Return a constant of arithmetic type TYPE which is the
multiplicative identity of the set TYPE.

References ALL_SCALAR_ACCUM_MODE_P, build_complex(), build_fixed(), build_int_cst(), build_one_cst(), build_real(), build_vector_from_val(), build_zero_cst(), dconst1, FCONST1, gcc_assert, gcc_unreachable, ggc_alloc(), TREE_CODE, TREE_TYPE, and TYPE_MODE.

Referenced by branch_fixup(), build_each_one_cst(), build_one_cst(), edge_info::derive_equivalences(), determine_exit_conditions(), execute_omp_device_lower(), expand_omp_for_init_counts(), expand_omp_for_init_vars(), expand_omp_sections(), expand_omp_simd(), expr_expected_value_1(), fold_binary_loc(), fold_negate_expr_1(), fold_plusminus_mult_expr(), gen_counter_update(), gimple_add_padding_init_for_auto_var(), gimple_fold_call(), strlen_pass::handle_builtin_memset(), insert_reciprocals(), lower_omp_for_scan(), lower_omp_task_reductions(), lower_omp_teams(), neutral_op_for_reduction(), omp_extract_for_data(), powi_as_mults(), rewrite_reciprocal(), simd_clone_adjust(), avail_exprs_stack::simplify_binary_operation(), simplify_using_ranges::simplify_switch_using_ranges(), spaceship_replacement(), tree_optimize_tail_calls_1(), try_transform_to_exit_first_loop_alt(), undistribute_bitref_for_vector(), vect_create_nonlinear_iv_init(), vect_do_peeling(), vect_gen_vector_loop_niters(), vect_recog_average_pattern(), vect_set_loop_condition_partial_vectors(), vect_set_loop_condition_partial_vectors_avx512(), vect_transform_loop(), and vectorizable_live_operation_1().

◆ build_opaque_vector_type()

tree build_opaque_vector_type	(	tree	innertype,
		poly_int64	nunits )

extern

Like build_vector_type, but builds a variant type with TYPE_VECTOR_OPAQUE
set.

References build_distinct_type_copy(), check_qualified_type(), ggc_alloc(), make_vector_type(), TYPE_ALIAS_SET, TYPE_CANONICAL, TYPE_MAIN_VARIANT, TYPE_NEXT_VARIANT, TYPE_QUALS, and TYPE_VECTOR_OPAQUE.

◆ build_optimization_node()

tree build_optimization_node	(	struct gcc_options *	opts,
		struct gcc_options *	opts_set )

extern

Return a tree node that encapsulates the optimization options in OPTS
and OPTS_SET.

Build an OPTIMIZATION_NODE based on the options in OPTS and OPTS_SET.

References cl_optimization_node, cl_option_hash_table, ggc_alloc(), make_node(), and TREE_OPTIMIZATION.

Referenced by inline_call(), lto_input_ts_function_decl_tree_pointers(), and process_options().

◆ build_personality_function()

tree build_personality_function ( const char * lang )

extern

Build a decl for a personality function given a language prefix.

References build_decl(), build_function_type_list(), DECL_ARTIFICIAL, DECL_EXTERNAL, DECL_RTL, gcc_unreachable, get_identifier(), ggc_alloc(), global_options, integer_type_node, long_long_unsigned_type_node, NULL, NULL_TREE, ptr_type_node, SET_SYMBOL_REF_DECL, TREE_PUBLIC, type(), UI_DWARF2, UI_NONE, UI_SEH, UI_SJLJ, UI_TARGET, UNKNOWN_LOCATION, unsigned_type_node, and XEXP.

Referenced by lhd_gcc_personality().

◆ build_pointer_type()

tree build_pointer_type ( tree to_type )

extern

By default build pointers in ptr_mode.

References build_pointer_type_for_mode(), and ggc_alloc().

Referenced by add_taskreg_looptemp_clauses(), apply_pass_by_reference_rules(), asan_init_shadow_ptr_types(), assign_parms_augmented_arg_list(), assumption_copy_decl(), build_call_expr_loc_array(), build_call_nofold_loc(), build_common_builtin_nodes(), build_common_tree_nodes(), build_cxa_atexit_decl(), build_fn_info_type(), build_fold_addr_expr_loc(), build_gcov_info_var_registration(), build_info_type(), build_init_ctor(), build_method_type_directly(), build_ref_for_offset(), build_string_literal(), canonicalize_addr_expr(), rt_bb_visited::check(), clear_padding_type(), copy_reference_ops_from_ref(), coverage_obj_init(), create_mem_ref_raw(), create_task_copyfn(), decl_attributes(), distinctify_node_type(), dummy_object(), eliminate_local_variables_1(), emit_library_call_value_1(), expand_builtin_cexpi(), expand_call(), expand_call_inline(), expand_call_stmt(), expand_debug_expr(), expand_function_end(), expand_ifn_atomic_compare_exchange_into_call(), find_interesting_uses_address(), finish_taskreg_scan(), fold_binary_loc(), fold_builtin_sincos(), force_expr_to_var_cost(), gen_emutls_addr(), get_alias_set(), get_chain_decl(), get_chain_field(), get_mem_refs_of_builtin_call(), get_trampoline_type(), get_use_type(), gimple_call_set_fndecl(), gimple_fold_builtin_clear_padding(), gimple_gen_ic_profiler(), gimple_init_gcov_profiler(), gimple_lower_bitint(), gimplify_addr(), gimplify_adjust_omp_clauses_1(), gimplify_bind_expr(), gimplify_cond_expr(), gimplify_parameters(), gimplify_va_arg_expr(), gimplify_vla_decl(), init_eh(), init_ic_make_global_vars(), initialize_sanitizer_builtins(), install_var_field(), instrument_bool_enum_load(), instrument_mem_ref(), instrument_object_size(), ipa_read_jump_function(), lookup_field_for_decl(), lower_copyprivate_clauses(), lower_coro_builtin(), lower_lastprivate_conditional_clauses(), lower_omp_for(), lower_omp_for_scan(), lower_omp_scope(), lower_omp_sections(), lower_omp_single_copy(), lower_omp_target(), lower_omp_task_reductions(), lower_private_allocate(), lower_rec_input_clauses(), lower_rec_simd_input_clauses(), lower_reduction_clauses(), maybe_diag_incompatible_alias(), maybe_instrument_pointer_overflow(), maybe_optimize_ubsan_ptr_ifn(), move_hint_to_base(), omp_resolve_clause_dependencies(), ompdevlow_adjust_simt_enter(), output_gimple_stmt(), prepare_call_arguments(), prepare_target_mem_ref_lvalue(), reference_alias_ptr_type(), rewrite_use_address(), rt_bb_visited::rt_bb_visited(), scan_omp_parallel(), separate_decls_in_region(), simd_clone_init_simd_arrays(), stabilize_va_list_loc(), std_gimplify_va_arg_expr(), thunk_adjust(), ubsan_create_data(), ubsan_get_source_location_type(), vect_create_addr_base_for_vector_ref(), and wrap_refs().

◆ build_pointer_type_for_mode()

tree build_pointer_type_for_mode	(	tree	to_type,
		machine_mode	mode,
		bool	can_alias_all )

extern

Constructors for pointer, array and function types.
(RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are
constructed by language-dependent code, not here.)

Construct, lay out and return the type of pointers to TO_TYPE with
mode MODE.  If MODE is VOIDmode, a pointer mode for the address
space of TO_TYPE will be picked.  If CAN_ALIAS_ALL is TRUE,
indicate this type can reference all of memory. If such a type has
already been constructed, reuse it.

References build_pointer_type_for_mode(), error_mark_node, ggc_alloc(), layout_type(), lookup_attribute(), make_node(), SET_TYPE_MODE, SET_TYPE_STRUCTURAL_EQUALITY, targetm, TREE_CODE, TREE_TYPE, TYPE_ADDR_SPACE, TYPE_ATTRIBUTES, TYPE_CANONICAL, TYPE_MODE, TYPE_NEXT_PTR_TO, TYPE_POINTER_TO, TYPE_REF_CAN_ALIAS_ALL, and TYPE_STRUCTURAL_EQUALITY_P.

Referenced by build_pointer_type(), build_pointer_type_for_mode(), expand_builtin_sincos(), expand_omp_atomic_mutex(), expand_omp_atomic_pipeline(), fold_builtin_memcmp(), gimple_fold_builtin_memory_op(), gimple_load_first_char(), strlen_pass::handle_builtin_memcmp(), reconstruct_complex_type(), remap_type_1(), and vect_create_data_ref_ptr().

◆ build_poly_int_cst()

tree build_poly_int_cst	(	tree	type,
		const poly_wide_int_ref &	values )

extern

Build a POLY_INT_CST node with type TYPE and with the elements in VALUES.
The elements must also have type TYPE.

References build_new_poly_int_cst(), poly_int< N, C >::coeffs, tree_poly_int_cst::coeffs, comp, poly_int< N, C >::from(), gcc_assert, ggc_alloc(), i, NULL_TREE, NUM_POLY_INT_COEFFS, poly_int_cst_hash_table, SIGNED, TYPE_PRECISION, TYPE_UID, and wide_int_to_tree_1().

Referenced by bits_from_bytes(), fold_convert_const(), and wide_int_to_tree().

◆ build_qualified_type()

tree build_qualified_type	(	tree	,
		int	CXX_MEM_STAT_INFO )

extern

Like get_qualified_type, but creates the type if it does not
exist.  This function never returns NULL_TREE.

◆ build_range_type()

tree build_range_type	(	tree	type,
		tree	lowval,
		tree	highval )

extern

Wrapper around build_range_type_1 with SHARED set to true.

References build_range_type_1(), and ggc_alloc().

Referenced by build_index_type(), build_printable_array_type(), get_memory_rtx(), and ubsan_get_type_descriptor_type().

◆ build_real_from_int_cst()

tree build_real_from_int_cst	(	tree	type,
		const_tree	i )

extern

Given a tree representing an integer constant I, return a tree
representing the same value as a floating-point constant of type TYPE.

References build_real(), ggc_alloc(), i, real_value_from_int_cst(), and TREE_OVERFLOW.

Referenced by chrec_apply(), expr_expected_value_1(), fold_convert_const(), gen_one_condition(), and get_upper_bound_based_on_builtin_expr_with_prob().

◆ build_real_from_wide()

tree build_real_from_wide	(	tree	type,
		const wide_int_ref &	i,
		signop	sgn )

extern

Return a new REAL_CST node whose type is TYPE
and whose value is the integer value I which has sign SGN.

References build_real(), ggc_alloc(), i, real_from_integer(), REAL_VALUE_TYPE, and TYPE_MODE.

Referenced by vectorizable_induction().

◆ build_reference_type()

tree build_reference_type ( tree to_type )

extern

Build the node for the type of references-to-TO_TYPE by default
in ptr_mode.

Referenced by build_ref_type_for(), fixup_child_record_type(), and get_alias_set().

◆ build_reference_type_for_mode()

tree build_reference_type_for_mode	(	tree	to_type,
		machine_mode	mode,
		bool	can_alias_all )

extern

Same as build_pointer_type_for_mode, but for REFERENCE_TYPE.

References build_reference_type_for_mode(), error_mark_node, ggc_alloc(), layout_type(), lookup_attribute(), make_node(), SET_TYPE_MODE, SET_TYPE_STRUCTURAL_EQUALITY, targetm, TREE_CODE, TREE_TYPE, TYPE_ADDR_SPACE, TYPE_ATTRIBUTES, TYPE_CANONICAL, TYPE_MODE, TYPE_NEXT_REF_TO, TYPE_REF_CAN_ALIAS_ALL, TYPE_REFERENCE_TO, and TYPE_STRUCTURAL_EQUALITY_P.

Referenced by build_reference_type_for_mode(), reconstruct_complex_type(), and remap_type_1().

◆ build_replicated_int_cst()

tree build_replicated_int_cst	(	tree	,
		unsigned	,
		HOST_WIDE_INT	)

extern

◆ build_string()

tree build_string	(	unsigned	len,
		const char *	str )

extern

Return a newly constructed STRING_CST node whose value is the LEN
characters at STR when STR is nonnull, or all zeros otherwise.
Note that for a C string literal, LEN should include the trailing NUL.
The TREE_TYPE is not initialized.

References ggc_alloc(), ggc_internal_alloc(), offsetof, record_node_allocation_statistics(), TREE_CONSTANT, TREE_SET_CODE, and TREE_STRING_LENGTH.

Referenced by asan_pp_string(), build_info(), build_string_literal(), default_asm_output_ident_directive(), detach_value(), expand_asm_stmt(), gimplify_asm_expr(), make_attribute(), resolve_addr_in_expr(), resolve_asm_operand_names(), set_call_expr_flags(), streamer_read_string_cst(), attr_access::to_external_string(), attr_access::to_internal_string(), ubsan_source_location(), ubsan_type_descriptor(), and rt_bb_visited::vset().

◆ build_string_literal() [1/3]

tree build_string_literal ( const char * p )

inline

References build_string_literal(), and ggc_alloc().

◆ build_string_literal() [2/3]

tree build_string_literal ( tree t )

inline

References build_string_literal(), IDENTIFIER_LENGTH, and IDENTIFIER_POINTER.

◆ build_string_literal() [3/3]

tree build_string_literal	(	unsigned	len,
		const char *	str,
		tree	eltype,
		unsigned HOST_WIDE_INT	size )

extern

Create a new constant string literal of type ELTYPE[SIZE] (or LEN
if SIZE == -1) and return a tree node representing char* pointer to
it as an ADDR_EXPR (ARRAY_REF (ELTYPE, ...)).  When STR is nonnull
the STRING_CST value is the LEN bytes at STR (the representation
of the string, which may be wide).  Otherwise it's all zeros.

References build1(), build4(), build_array_type(), build_index_type(), build_pointer_type(), build_string(), build_type_variant, ggc_alloc(), HOST_WIDE_INT_M1U, integer_zero_node, NULL_TREE, size_int, TREE_CONSTANT, TREE_READONLY, TREE_STATIC, TREE_TYPE, and type().

Referenced by build_string_literal(), build_string_literal(), constant_byte_string(), fold_builtin_FILE(), fold_builtin_FUNCTION(), gimple_add_init_for_auto_var(), gimple_fold_builtin_printf(), simplify_builtin_call(), and verify_bb_vtables().

◆ build_target_option_node()

tree build_target_option_node	(	struct gcc_options *	opts,
		struct gcc_options *	opts_set )

extern

Return a tree node that encapsulates the target options in OPTS and
OPTS_SET.

Build a TARGET_OPTION_NODE based on the options in OPTS and OPTS_SET.

References cl_option_hash_table, cl_target_option_node, ggc_alloc(), make_node(), and TREE_TARGET_OPTION.

Referenced by decl_attributes().

◆ build_translation_unit_decl()

tree build_translation_unit_decl ( tree name )

extern

Builds a new translation-unit decl with name NAME, queues it in the
global list of translation-unit decls and returns it.

References all_translation_units, build_decl(), ggc_alloc(), lang_hooks::name, NULL_TREE, TRANSLATION_UNIT_LANGUAGE, UNKNOWN_LOCATION, and vec_safe_push().

◆ build_tree_list()

tree build_tree_list	(	tree	,
		tree	CXX_MEM_STAT_INFO )

extern

◆ build_tree_list_vec()

tree build_tree_list_vec ( const vec< tree, va_gc > * CXX_MEM_STAT_INFO )

extern

◆ build_truth_vector_type_for_mode()

tree build_truth_vector_type_for_mode	(	poly_uint64	nunits,
		machine_mode	mask_mode )

extern

Build a truth vector with NUNITS units, giving it mode MASK_MODE.

References build_nonstandard_boolean_type(), gcc_assert, GET_MODE_PRECISION(), ggc_alloc(), make_vector_type(), vector_element_size, and VECTOR_MODE_P.

Referenced by build_truth_vector_type_for(), vect_double_mask_nunits(), and vect_halve_mask_nunits().

◆ build_uniform_cst()

tree build_uniform_cst	(	tree	type,
		tree	sc )

extern

If TYPE is not a vector type, just return SC, otherwise return
build_vector_from_val (TYPE, SC).

References build_vector_from_val(), sc, and VECTOR_TYPE_P.

Referenced by bitmask_inv_cst_vector_p().

◆ build_varargs_function_type_array()

tree build_varargs_function_type_array	(	tree	return_type,
		int	n,
		tree *	arg_types )

extern

Build a variable argument function type.  RETURN_TYPE is the type
returned by the function.  The function takes N named arguments, the
types of which are provided in ARG_TYPES.

References build_function_type_array_1(), and ggc_alloc().

◆ build_varargs_function_type_list()

tree build_varargs_function_type_list	(	tree	return_type,
			... )

extern

Build a variable argument function type.  The RETURN_TYPE is the
type returned by the function.  If additional arguments are provided,
they are additional argument types.  The list of argument types must
always be terminated by NULL_TREE.

References build_function_type_list_1(), and ggc_alloc().

Referenced by create_assumption_fn().

◆ build_variant_type_copy()

tree build_variant_type_copy ( tree CXX_MEM_STAT_INFO )

extern

◆ build_vec_series()

tree build_vec_series	(	tree	type,
		tree	base,
		tree	step )

extern

Build a vector series of type TYPE in which element I has the value
BASE + I * STEP.  The result is a constant if BASE and STEP are constant
and a VEC_SERIES_EXPR otherwise.

References build2(), build_vector_from_val(), ggc_alloc(), integer_zerop(), wi::to_wide(), TREE_CODE, TREE_TYPE, and wide_int_to_tree().

Referenced by const_binop().

◆ build_vector_a_then_b()

tree build_vector_a_then_b	(	tree	vec_type,
		unsigned int	num_a,
		tree	a,
		tree	b )

extern

Return a VECTOR_CST of type VEC_TYPE in which the first NUM_A
elements are A and the rest are B.

References a, b, count, gcc_assert, ggc_alloc(), i, known_le, and TYPE_VECTOR_SUBPARTS().

Referenced by fold_while_ult().

◆ build_vector_from_ctor()

tree build_vector_from_ctor	(	tree	type,
		const vec< constructor_elt, va_gc > *	v )

extern

Return a new VECTOR_CST node whose type is TYPE and whose values
are extracted from V, a vector of CONSTRUCTOR_ELT.

References build_zero_cst(), FOR_EACH_CONSTRUCTOR_VALUE, ggc_alloc(), i, poly_int< N, C >::to_constant(), TREE_CODE, TREE_TYPE, TYPE_VECTOR_SUBPARTS(), vec_safe_length(), VECTOR_CST_ELT, and VECTOR_CST_NELTS.

Referenced by expand_vector_condition(), expand_vector_conversion(), expand_vector_piecewise(), fold(), fold_gimple_assign(), gimplify_init_constructor(), lower_vec_perm(), and rtl_for_decl_init().

◆ build_vector_from_val()

tree build_vector_from_val	(	tree	vectype,
		tree	sc )

extern

Build a vector of type VECTYPE where all the elements are SCs.

References tree_vector_builder::build(), build_constructor(), CONSTANT_CLASS_P, CONSTRUCTOR_APPEND_ELT, error_mark_node, fold_build1, gcc_checking_assert, ggc_alloc(), i, NULL_TREE, sc, TREE_TYPE, TYPE_MAIN_VARIANT, TYPE_VECTOR_SUBPARTS(), types_compatible_p(), and vec_alloc().

Referenced by build_minus_one_cst(), build_one_cst(), build_uniform_cst(), build_vec_series(), build_zero_cst(), build_zero_vector(), const_unop(), constant_boolean_node(), expand_vector_operations_1(), gimple_build_vector_from_val(), sign_mask_for(), vect_build_all_ones_mask(), vect_build_zero_merge_argument(), vect_create_epilog_for_reduction(), vect_create_nonlinear_iv_vec_step(), vect_emulate_mixed_dot_prod(), vect_expand_fold_left(), vect_init_vector(), vect_transform_cycle_phi(), vectorizable_induction(), vectorizable_recurr(), and vectorizable_simd_clone_call().

◆ build_vector_type()

tree build_vector_type	(	tree	innertype,
		poly_int64	nunits )

extern

Similarly, but takes the inner type and number of units, which must be
a power of two.

References ggc_alloc(), and make_vector_type().

Referenced by build_index_vector(), build_word_mode_vector_type(), do_vec_conversion(), do_vec_narrow_conversion(), duplicate_and_interleave(), execute_update_addresses_taken(), expand_vector_conversion(), expand_vector_divmod(), non_rewritable_lvalue_p(), signed_or_unsigned_type_for(), simd_clone_adjust_argument_types(), simd_clone_adjust_return_type(), simplify_permutation(), simplify_vector_constructor(), vect_create_nonlinear_iv_init(), vect_create_partial_epilog(), vect_gen_perm_mask_any(), vect_transform_cycle_phi(), vect_update_nonlinear_iv(), vect_verify_full_masking_avx512(), vector_vector_composition_type(), and vectorizable_store().

◆ build_vector_type_for_mode()

tree build_vector_type_for_mode	(	tree	innertype,
		machine_mode	mode )

extern

Returns a vector tree node given a mode (integer, vector, or BLKmode) and
the inner type.

References gcc_assert, gcc_unreachable, GET_MODE_BITSIZE(), GET_MODE_CLASS, GET_MODE_NUNITS(), ggc_alloc(), make_vector_type(), TREE_INT_CST_LOW, and TYPE_SIZE.

Referenced by bitwise_type_for_mode(), get_related_vectype_for_scalar_type(), omp_clause_aligned_alignment(), signed_or_unsigned_type_for(), supportable_widening_operation(), type_for_widest_vector_mode(), undistribute_bitref_for_vector(), vect_transform_cycle_phi(), vectorizable_load(), vectorizable_store(), and vectorized_internal_fn_supported_p().

◆ build_vl_exp()

tree build_vl_exp	(	enum	tree_code,
		int	CXX_MEM_STAT_INFO )

extern

◆ build_zero_cst()

tree build_zero_cst ( tree type )

extern

Build 0 constant of type TYPE.  This is used by constructor folding
and thus the constant should be represented in memory by
zero(es).

References AGGREGATE_TYPE_P, build_complex(), build_constructor(), build_fixed(), build_int_cst(), build_real(), build_vector_from_val(), build_zero_cst(), dconst0, FCONST0, fold_convert, ggc_alloc(), integer_zero_node, NULL, TREE_CODE, TREE_TYPE, and TYPE_MODE.

Referenced by analyze_and_compute_bitop_with_inv_effect(), analyze_and_compute_bitwise_induction_effect(), loop_cand::analyze_induction_var(), branch_fixup(), build_cltz_expr(), build_minus_one_cst(), build_one_cst(), build_vect_cond_expr(), build_vector_from_ctor(), build_zero_cst(), c_strlen(), clear_padding_flush(), cond_store_replacement(), convert_atomic_bit_not(), default_preferred_else_value(), edge_info::derive_equivalences(), do_compare(), eliminate_duplicate_pair(), eliminate_not_pairs(), eliminate_plus_minus_pair(), tree_switch_conversion::bit_test_cluster::emit(), evaluate_stmt(), execute_omp_device_lower(), expand_complex_asm(), expand_debug_expr(), expand_DEFERRED_INIT(), expand_expr_real_1(), expand_omp_atomic_cas(), expand_omp_for_init_counts(), expand_omp_for_init_vars(), expand_omp_for_ordered_loops(), expand_omp_ordered_sink(), expand_omp_ordered_source_sink(), expand_omp_simd(), expand_omp_target(), expand_teams_call(), expand_thunk(), expand_vector_comparison(), expand_vector_condition(), expand_vector_conversion(), expand_vector_divmod(), fold_array_ctor_reference(), fold_binary_loc(), fold_builtin_bit_query(), fold_cond_expr_with_comparison(), fold_const_aggregate_ref_1(), fold_mult_zconjz(), fold_nonarray_ctor_reference(), fold_read_from_vector(), fold_strstr_to_strncmp(), fold_while_ult(), force_value_to_type(), forward_propagate_into_gimple_cond(), fully_constant_vn_reference_p(), gen_counter_update(), generate_strlen_builtin_using_rawmemchr(), get_bool_state(), get_compare_parts(), scalar_cond_masked_key::get_cond_ops_from_tree(), get_default_value(), get_legacy_range(), get_range_strlen_dynamic(), get_symbol_constant_value(), gimple_cond_get_ops_from_tree(), gimple_expand_vec_cond_expr(), gimple_fold_call(), gimple_fold_partial_load_store_mem_ref(), gimple_fold_stmt_to_constant_1(), gimple_lower_bitint(), gimplify_bind_expr(), gimplify_call_expr(), gimplify_expr(), gimplify_init_constructor(), gimplify_omp_affinity(), init_subtree_with_zero(), instrument_builtin(), instrument_builtin_call(), instrument_nonnull_arg(), instrument_nonnull_return(), instrument_si_overflow(), isolate_path(), lower_builtin_setjmp(), lower_lastprivate_clauses(), lower_omp_for_scan(), lower_omp_task_reductions(), lower_omp_teams(), lower_rec_input_clauses(), lower_reduction_clauses(), lower_vec_perm(), make_range_step(), match_single_bit_test(), match_uaddc_usubc(), maybe_optimize_arith_overflow(), ipa_param_body_adjustments::modify_assignment(), native_encode_initializer(), native_interpret_vector_part(), neutral_op_for_reduction(), number_of_iterations_cltz(), number_of_iterations_cltz_complement(), number_of_iterations_popcount(), object_sizes_execute(), omp_extract_for_data(), omp_reduction_init_op(), optimize_atomic_bit_test_and(), optimize_mask_stores(), optimize_range_tests_to_bit_test(), optimize_range_tests_var_bound(), optimize_vector_constructor(), propagate_tree_value_into_stmt(), range_includes_zero_p(), ref_at_iteration(), remap_ssa_name(), replace_stmt_with_simplification(), rewrite_use_address(), simd_clone_adjust(), simplify_using_ranges::simplify_abs_using_ranges(), avail_exprs_stack::simplify_binary_operation(), simplify_builtin_call(), simplify_using_ranges::simplify_div_or_mod_using_ranges(), simplify_vector_constructor(), spaceship_replacement(), tree_optimize_tail_calls_1(), ubsan_encode_value(), ubsan_expand_null_ifn(), ubsan_expand_objsize_ifn(), ubsan_expand_vptr_ifn(), undistribute_bitref_for_vector(), undistribute_ops_list(), vect_build_one_gather_load_call(), vect_build_slp_tree_2(), vect_create_constant_vectors(), vect_create_epilog_for_reduction(), vect_create_nonlinear_iv_init(), vect_do_peeling(), vect_gen_loop_len_mask(), vect_gen_while(), vect_get_strided_load_store_ops(), vect_init_vector(), vect_loop_versioning(), vect_peel_nonlinear_iv_init(), vect_recog_bitfield_ref_pattern(), vect_recog_ctz_ffs_pattern(), vect_recog_gather_scatter_pattern(), vect_remove_slp_scalar_calls(), vect_set_loop_condition_normal(), vect_set_loop_condition_partial_vectors(), vect_transform_loop(), vect_update_init_of_dr(), vector_element(), vectorizable_call(), vectorizable_early_exit(), vectorizable_live_operation(), vectorizable_load(), vectorizable_scan_store(), vectorizable_simd_clone_call(), vectorize_fold_left_reduction(), vn_reference_lookup_3(), warn_return_addr_local(), worker_single_copy(), and worker_single_simple().

◆ built_in_function_equal_p() [1/2]

bool built_in_function_equal_p	(	built_in_function	name0,
		built_in_function	name1 )

inline

Helper functions for fndecl_built_in_p.

References ggc_alloc().

Referenced by built_in_function_equal_p(), and fndecl_built_in_p().

◆ built_in_function_equal_p() [2/2]

template<typename... F>

bool built_in_function_equal_p	(	built_in_function	name0,
		built_in_function	name1,
		built_in_function	name2,
		F...	names )

inline

Recursive case for two or more names.

References built_in_function_equal_p(), ggc_alloc(), and names.

◆ builtin_decl_declared_p()

bool builtin_decl_declared_p ( enum built_in_function fncode )

inline

Return whether the standard builtin function was declared.

References BUILTIN_VALID_P, gcc_checking_assert, ggc_alloc(), and NULL_TREE.

Referenced by gimplify_addr_expr().

◆ builtin_decl_explicit()

tree builtin_decl_explicit ( enum built_in_function fncode )

inline

Return the tree node for an explicit standard builtin function or NULL.

References BUILTIN_VALID_P, gcc_checking_assert, and ggc_alloc().

◆ builtin_decl_explicit_p()

bool builtin_decl_explicit_p ( enum built_in_function fncode )

inline

Return whether the standard builtin function can be used as an explicit
function.

References BUILTIN_VALID_P, gcc_checking_assert, and NULL_TREE.

Referenced by build_common_builtin_nodes(), build_tm_load(), build_tm_store(), operand_compare::hash_operand(), optimize_stdarg_builtin(), tm_log_emit_stmt(), and tree_ssa_prefetch_arrays().

◆ builtin_decl_implicit()

tree builtin_decl_implicit ( enum built_in_function fncode )

inline

Return the tree node for an implicit builtin function or NULL.

References BUILTIN_VALID_P, gcc_checking_assert, ggc_alloc(), and NULL_TREE.

◆ builtin_decl_implicit_p()

bool builtin_decl_implicit_p ( enum built_in_function fncode )

inline

Return whether the standard builtin function can be used implicitly.

References BUILTIN_VALID_P, gcc_checking_assert, ggc_alloc(), and NULL_TREE.

Referenced by fold_builtin_sincos(), get_string_length(), strlen_pass::handle_builtin_strcat(), strlen_pass::handle_builtin_strcpy(), initialize_sanitizer_builtins(), and mathfn_built_in_1().

◆ builtin_decl_unreachable()

tree builtin_decl_unreachable ( )

extern

For BUILTIN_UNREACHABLE, use one of these or
gimple_build_builtin_unreachable instead of one of the above.

The built-in decl to use to mark code points believed to be unreachable.
Typically __builtin_unreachable, but __builtin_trap if
-fsanitize=unreachable -fsanitize-trap=unreachable.  If only
-fsanitize=unreachable, we rely on sanopt to replace calls with the
appropriate ubsan function.  When building a call directly, use
{gimple_},build_builtin_unreachable instead.

References builtin_decl_explicit(), ggc_alloc(), sanitize_flags_p(), and SANITIZE_UNREACHABLE.

Referenced by eliminate_dom_walker::eliminate_stmt(), gimple_get_virt_method_for_vtable(), ipa_impossible_devirt_target(), ipa_make_edge_direct_to_target(), redirect_to_unreachable(), walk_polymorphic_call_targets(), and walk_polymorphic_call_targets().

◆ builtin_fn_p()

bool builtin_fn_p ( combined_fn code )

inline

Return true if CODE is a target-independent built-in function.

References END_BUILTINS.

Referenced by as_builtin_fn(), combined_fn_name(), code_helper::is_builtin_fn(), and is_copysign_call_with_1().

◆ byte_position()

tree byte_position ( const_tree field )

extern

Return the byte position of FIELD, in bytes from the start of the record.
This is a tree of type sizetype.

References byte_from_pos(), DECL_FIELD_BIT_OFFSET, and DECL_FIELD_OFFSET.

Referenced by component_ref_size(), decl_init_size(), decode_addr_const(), field_at_offset(), field_byte_offset(), handle_component_ref(), handle_warn_if_not_align(), inbounds_memaccess_p(), int_byte_position(), ipa_get_stmt_member_ptr_load_param(), lower_omp_task_reductions(), and native_interpret_aggregate().

◆ cache_integer_cst()

tree cache_integer_cst	(	tree	t,
		bool	might_duplicate )

extern

Insert INTEGER_CST T into a cache of integer constants.  And return
the cached constant (which may or may not be T).  If MIGHT_DUPLICATE
is false, and T falls into the type's 'smaller values' range, there
cannot be an existing entry.  Otherwise, if MIGHT_DUPLICATE is true,
or the value is large, should an existing entry exist, it is
returned (rather than inserting T).

References gcc_assert, gcc_checking_assert, gcc_unreachable, ggc_alloc(), HOST_BITS_PER_WIDE_INT, int_cst_hash_table, integer_minus_onep(), integer_onep(), integer_zerop(), wi::ltu_p(), make_tree_vec(), wi::neg_p(), r, wi::to_wide(), TREE_CODE, TREE_INT_CST_ELT, TREE_OVERFLOW, tree_to_shwi(), tree_to_uhwi(), TREE_TYPE, TREE_VEC_ELT, TYPE_CACHED_VALUES, TYPE_CACHED_VALUES_P, TYPE_PRECISION, and TYPE_UNSIGNED.

◆ canonical_type_used_p()

bool canonical_type_used_p ( const_tree t )

inline

Return ture if get_alias_set care about TYPE_CANONICAL of given type.
We don't define the types for pointers, arrays and vectors.  The reason is
that pointers are handled specially: ptr_type_node accesses conflict with
accesses to all other pointers.  This is done by alias.cc.
Because alias sets of arrays and vectors are the same as types of their
elements, we can't compute canonical type either.  Otherwise we could go
form void *[10] to int *[10] (because they are equivalent for canonical type
machinery) and get wrong TBAA.

References ggc_alloc(), POINTER_TYPE_P, and TREE_CODE.

Referenced by get_alias_set(), gimple_canonical_types_compatible_p(), lto_read_body_or_constructor(), and record_component_aliases().

◆ chain_index()

tree chain_index	(	int	idx,
		tree	chain )

extern

Returns element number IDX (zero-origin) of chain CHAIN, or
NULL_TREE.

References TREE_CHAIN.

◆ chain_member()

bool chain_member	(	const_tree	elem,
		const_tree	chain )

extern

Return true if ELEM is part of the chain CHAIN.

References DECL_CHAIN.

◆ chainon()

tree chainon	(	tree	op1,
		tree	op2 )

extern

Log2 of BITS_PER_UNIT.

Concatenate two lists (chains of TREE_LIST nodes) X and Y
by making the last node in X point to Y.
Returns X, except if X is 0 returns Y.

Concatenate two chains of nodes (chained through TREE_CHAIN)
by modifying the last node in chain 1 to point to chain 2.
This is the Lisp primitive `nconc'.

References gcc_assert, and TREE_CHAIN.

Referenced by decl_attributes(), declare_inline_vars(), declare_vars(), finalize_nesting_tree_1(), gimple_bind_append_vars(), gimplify_asm_expr(), maybe_canonicalize_argtypes(), scan_omp_for(), and self_referential_size().

◆ check_base_type()

bool check_base_type	(	const_tree	cand,
		const_tree	base )

extern

Returns true iff unqualified CAND and BASE are equivalent.

References attribute_list_equal(), find_atomic_core_type(), ggc_alloc(), TYPE_ALIGN, TYPE_ATTRIBUTES, TYPE_CONTEXT, TYPE_NAME, TYPE_QUAL_ATOMIC, TYPE_QUALS, and TYPE_USER_ALIGN.

Referenced by check_qualified_type(), get_nearest_type_subqualifiers(), and modified_type_die().

◆ check_lang_type()

bool check_lang_type	(	const_tree	cand,
		const_tree	base )

extern

Returns true iff CAND and BASE have equivalent language-specific
qualifiers.

References ggc_alloc(), NULL, TREE_CODE, lang_hooks_for_types::type_hash_eq, and lang_hooks::types.

Referenced by check_aligned_type(), check_qualified_type(), and modified_type_die().

◆ check_qualified_type()

bool check_qualified_type	(	const_tree	cand,
		const_tree	base,
		int	type_quals )

extern

Check whether CAND is suitable to be returned from get_qualified_type
(BASE, TYPE_QUALS).

Returns true iff CAND is equivalent to BASE with TYPE_QUALS.

References check_base_type(), check_lang_type(), and TYPE_QUALS.

Referenced by build_opaque_vector_type(), and get_qualified_type().

◆ clean_symbol_name()

void clean_symbol_name ( char * p )

extern

P is a string that will be used in a symbol.  Mask out any characters
that are not valid in that context.

References ggc_alloc().

Referenced by compute_comp_unit_symbol(), create_loop_fn(), create_tmp_var_name(), and get_file_function_name().

◆ combined_fn_name()

const char * combined_fn_name ( combined_fn fn )

extern

Return the name of combined function FN, for debugging purposes.

References as_builtin_fn(), as_internal_fn(), builtin_decl_explicit(), builtin_fn_p(), DECL_NAME, IDENTIFIER_POINTER, and internal_fn_name().

◆ commutative_ternary_tree_code()

bool commutative_ternary_tree_code ( enum tree_code code )

extern

Return true if CODE represents a ternary tree code for which the
first two operands are commutative.  Otherwise return false.

References ggc_alloc().

Referenced by inchash::add_hashable_expr(), commutative_op(), commutative_ternary_op_p(), first_commutative_argument(), fold_stmt_1(), fold_ternary_loc(), gimple_simplify(), hashable_expr_equal_p(), and vn_nary_op_compute_hash().

◆ commutative_tree_code()

bool commutative_tree_code ( enum tree_code code )

extern

Return true if CODE represents a commutative tree code.  Otherwise
return false.

References ggc_alloc().

Referenced by inchash::add_hashable_expr(), analyze_agg_content_value(), check_scan_store(), pcom_worker::combinable_refs_p(), commutative_binary_op_p(), commutative_op(), cond_stmts_equal_p(), const_binop(), expand_omp_atomic_fetch_op(), first_commutative_argument(), fold_binary_loc(), fold_stmt_1(), gimple_simplify(), operand_compare::hash_operand(), hashable_expr_equal_p(), is_cond_scalar_reduction(), may_reassociate_p(), operand_compare::operand_equal_p(), parloops_is_simple_reduction(), parser::parse_expr(), reorder_operands(), vect_build_slp_tree_2(), vect_get_and_check_slp_defs(), vect_reassociating_reduction_p(), vectorizable_scan_store(), and vn_nary_op_compute_hash().

◆ compare_tree_int()

int compare_tree_int	(	const_tree	t,
		unsigned HOST_WIDE_INT	u )

extern

Compare the value of T, an INTEGER_CST, with U, an unsigned integer value.
Return -1, 0, or 1 if the value of T is less than, equal to, or greater
than U, respectively.

References tree_fits_uhwi_p(), TREE_INT_CST_LOW, and tree_int_cst_sgn().

Referenced by addr_object_size(), alloca_call_type(), analyze_siv_subscript_cst_affine(), check_for_plus_in_loops(), compare_nonzero_chars(), compare_nonzero_chars(), compute_builtin_object_size(), compute_trims(), decode_field_reference(), do_jump(), tree_switch_conversion::bit_test_cluster::emit(), emit_case_dispatch_table(), cgraph_node::expand(), expand_builtin_object_size(), expand_expr_real_1(), extract_bit_test_mask(), fold_binary_loc(), fold_builtin_object_size(), fold_read_from_constant_string(), get_bitfield_rep(), get_stridx_plus_constant(), gimple_fold_builtin_fputs(), gimple_fold_builtin_memory_op(), gimplify_parameters(), initialize_argument_information(), is_aligning_offset(), layout_decl(), layout_type(), maybe_optimize_mod_cmp(), non_rewritable_lvalue_p(), nonnull_arg_p(), normalize_offset(), operand_compare::operand_equal_p(), optimize_range_tests_to_bit_test(), plus_stmt_object_size(), predict_loops(), rtl_for_decl_init(), simplify_builtin_call(), size_for_offset(), ubsan_expand_null_ifn(), vect_analyze_data_ref_access(), vect_recog_divmod_pattern(), and verify_gimple_assign_single().

◆ complete_ctor_at_level_p()

bool complete_ctor_at_level_p	(	const_tree	type,
		HOST_WIDE_INT	num_elts,
		const_tree	last_type )

extern

TYPE is initialized by a constructor with NUM_ELTS elements, the last
of which had type LAST_TYPE.  Each element was itself a complete
initializer, in the sense that every meaningful byte was explicitly
given a value.  Return true if the same is true for the constructor
as a whole.

References count_type_elements(), gcc_assert, ggc_alloc(), simple_cst_equal(), TREE_CODE, and TYPE_SIZE.

Referenced by categorize_ctor_elements_1().

◆ complete_or_array_type_p()

bool complete_or_array_type_p ( const_tree type )

inline

Return true if the argument is a complete type or an array
of unknown bound (whose type is incomplete but) whose elements
have complete type.

References COMPLETE_TYPE_P, ggc_alloc(), TREE_CODE, and TREE_TYPE.

◆ component_ref_field_offset()

tree component_ref_field_offset ( tree exp )

extern

Return a tree representing the offset, in bytes, of the field referenced
by EXP.  This does not include any offset in DECL_FIELD_BIT_OFFSET.

References DECL_FIELD_OFFSET, DECL_OFFSET_ALIGN, exp(), EXPR_LOCATION, fold_convert_loc(), ggc_alloc(), size_binop_loc(), size_int, sizetype, SUBSTITUTE_PLACEHOLDER_IN_EXPR, TREE_OPERAND, and TREE_TYPE.

Referenced by adjust_offset_for_component_ref(), compute_object_offset(), copy_reference_ops_from_ref(), dr_analyze_indices(), dump_generic_node(), eliminate_dom_walker::eliminate_stmt(), get_addr_base_and_unit_offset_1(), get_bitfield_rep(), get_inner_reference(), get_mem_align_offset(), get_ref_base_and_extent(), gimplify_compound_lval(), gimplify_scan_omp_clauses(), idx_find_step(), ref_at_iteration(), strip_offset_1(), and widen_memory_access().

◆ component_ref_sam_type()

special_array_member component_ref_sam_type ( tree ref )

extern

Determines the special array member type for a COMPONENT_REF.

Determines the special array member type for the array reference REF.

References array_ref_flexible_size_p(), DECL_SIZE_UNIT, ggc_alloc(), int_0, int_n, integer_all_onesp(), integer_zerop(), none, wi::to_offset(), trail_0, trail_1, trail_n, TREE_CODE, tree_int_cst_lt(), TREE_OPERAND, TREE_TYPE, TYPE_DOMAIN, TYPE_MAX_VALUE, TYPE_MIN_VALUE, and TYPE_SIZE_UNIT.

Referenced by array_bounds_checker::check_array_ref(), and component_ref_size().

◆ component_ref_size()

tree component_ref_size	(	tree	ref,
		special_array_member *	sam )

extern

Return the size of the member referenced by the COMPONENT_REF, using
its initializer expression if necessary in order to determine the size
of an initialized flexible array member.  The size might be zero for
an object with an uninitialized flexible array member or null if it
cannot be determined.

Determines the size of the member referenced by the COMPONENT_REF
REF, using its initializer expression if necessary in order to
determine the size of an initialized flexible array member.
If non-null, set *SAM to the type of special array member.
Returns the size as sizetype (which might be zero for an object
with an uninitialized flexible array member) or null if the size
cannot be determined.

References byte_position(), component_ref_sam_type(), DECL_EXTERNAL, DECL_INITIAL, DECL_NOT_FLEXARRAY, DECL_P, DECL_SIZE_UNIT, error_mark_node, gcc_assert, get_addr_base_and_unit_offset(), get_initializer_for(), ggc_alloc(), int_0, int_n, known_lt, NULL_TREE, size_zero_node, trail_n, TREE_CODE, tree_fits_poly_int64_p(), tree_int_cst_equal(), TREE_OPERAND, tree_to_poly_int64(), TREE_TYPE, TYPE_SIZE_UNIT, useless_type_conversion_p(), VAR_P, and wide_int_to_tree().

Referenced by decl_init_size(), get_up_bounds_for_array_ref(), and set_component_ref_size().

◆ contains_bitfld_component_ref_p()

bool contains_bitfld_component_ref_p ( const_tree ref )

extern

Return true if REF has a COMPONENT_REF with a bit-field field declaration
somewhere in it.

References DECL_BIT_FIELD, ggc_alloc(), handled_component_p(), TREE_CODE, and TREE_OPERAND.

Referenced by analyze_agg_content_value(), decompose_param_expr(), load_from_unmodified_param_or_agg(), and sra_modify_assign().

◆ contains_placeholder_p()

bool contains_placeholder_p ( const_tree exp )

extern

Return true if EXP contains a PLACEHOLDER_EXPR, i.e. if it represents a
size or offset that depends on a field within a record.

References CONTAINS_PLACEHOLDER_P, exp(), FOR_EACH_CONST_CALL_EXPR_ARG, ggc_alloc(), tcc_binary, tcc_comparison, tcc_exceptional, tcc_expression, tcc_reference, tcc_unary, tcc_vl_exp, TREE_CHAIN, TREE_CODE, TREE_CODE_CLASS, TREE_CODE_LENGTH, TREE_OPERAND, and TREE_VALUE.

Referenced by save_expr().

◆ convert()

tree convert	(	tree	,
		tree	)

extern

Referenced by convert_to_complex_1(), convert_to_fixed(), convert_to_integer_1(), convert_to_real_1(), do_narrow(), and ipa_param_body_adjustments::modify_expression().

◆ copy_decl_built_in_function()

void copy_decl_built_in_function	(	tree	newdecl,
		const_tree	olddecl )

inline

Record that FUNCTION_DECL NEWDECL represents the same built-in function
as OLDDECL (or none, if OLDDECL doesn't represent a built-in function).

References ggc_alloc().

◆ copy_list()

tree copy_list ( tree list )

extern

Make a copy of a chain of TREE_LIST nodes.

Return a copy of a chain of nodes, chained through the TREE_CHAIN field.
For example, this can copy a list made of TREE_LIST nodes.

References copy_node(), and TREE_CHAIN.

Referenced by create_omp_child_function(), decl_attributes(), expand_omp_target(), init_attr_rdwr_indices(), and split_complex_types().

◆ copy_node()

tree copy_node ( tree CXX_MEM_STAT_INFO )

extern

Make a copy of a node, with all the same contents.

◆ copy_warning() [1/2]

void copy_warning	(	location_t	to,
		location_t	from )

extern

Copy warning disposition from one location to another.

Copy the no-warning disposition from one location to another.

References hash_map< KeyId, Value, Traits >::get(), ggc_alloc(), nowarn_map, NULL, hash_map< KeyId, Value, Traits >::put(), hash_map< KeyId, Value, Traits >::remove(), and RESERVED_LOCATION_P.

Referenced by copy_tree_body_r(), copy_var_decl(), create_access_replacement(), create_one_component_var(), expand_builtin_strcmp(), expand_builtin_strncmp(), expand_call_stmt(), fold_truth_not_expr(), gimple_build_call_from_tree(), gimple_fold_builtin_sprintf(), gimplify_cond_expr(), gimplify_expr(), gimplify_modify_expr(), gimplify_return_expr(), lookup_field_for_decl(), and remap_gimple_op_r().

◆ copy_warning() [2/2]

void copy_warning	(	tree	to,
		const_tree	from )

extern

Copy warning disposition from one expression to another.

Copy the warning disposition mapping from one expression to another.

References ggc_alloc().

◆ crc32_byte()

unsigned crc32_byte	(	unsigned	chksum,
		char	byte )

inline

References crc32_unsigned_n(), and ggc_alloc().

Referenced by coverage_compute_cfg_checksum(), and crc32_string().

◆ crc32_string()

unsigned crc32_string	(	unsigned	chksum,
		const char *	string )

extern

Generate a crc32 of a string.

References crc32_byte(), and ggc_alloc().

Referenced by coverage_checksum_string(), get_file_function_name(), and set_random_seed().

◆ crc32_unsigned()

unsigned crc32_unsigned	(	unsigned	chksum,
		unsigned	value )

inline

References crc32_unsigned_n(), and ggc_alloc().

Referenced by coverage_finish(), and read_counts_file().

◆ crc32_unsigned_n()

unsigned crc32_unsigned_n	(	unsigned	chksum,
		unsigned	value,
		unsigned	bytes )

extern

In tree.cc

Generate a crc32 of the low BYTES bytes of VALUE.

References ggc_alloc(), and SYNDROME.

Referenced by crc32_byte(), and crc32_unsigned().

◆ create_artificial_label()

tree create_artificial_label ( location_t loc )

extern

Create a nameless artificial label and put it in the current
function context.  The label has a location of LOC.  Returns the
newly created label.

References build_decl(), current_function_decl, DECL_ARTIFICIAL, DECL_CONTEXT, DECL_IGNORED_P, ggc_alloc(), NULL_TREE, and void_type_node.

Referenced by adjust_assumption_stmt_r(), build_and_jump(), build_instrumentation_call(), clear_padding_emit_loop(), convert_nl_goto_reference(), emit_post_landing_pad(), frob_into_branch_around(), tree_switch_conversion::switch_conversion::gen_inbound_check(), gimple_block_label(), gimplify_cond_expr(), gimplify_init_ctor_eval_range(), gimplify_loop_expr(), gimplify_omp_affinity(), gimplify_omp_depend(), gimplify_switch_expr(), handle_abnormal_edges(), lower_builtin_posix_memalign(), lower_builtin_setjmp(), lower_catch(), lower_eh_filter(), lower_gimple_return(), lower_lastprivate_clauses(), lower_omp_1(), lower_omp_for_scan(), lower_omp_ordered(), lower_omp_single_copy(), lower_omp_single_simple(), lower_omp_target(), lower_omp_task_reductions(), lower_omp_teams(), lower_rec_input_clauses(), lower_reduction_clauses(), lower_transaction(), lower_try_finally_copy(), lower_try_finally_fallthru_label(), lower_try_finally_nofallthru(), lower_try_finally_onedest(), lower_try_finally_switch(), maybe_add_implicit_barrier_cancel(), new_label_mapper(), omp_copy_decl(), replace_goto_queue_cond_clause(), scan_omp_simd(), and sjlj_emit_dispatch_table().

◆ cst_and_fits_in_hwi()

bool cst_and_fits_in_hwi ( const_tree x )

extern

Checks that X is integer constant that can be expressed in (unsigned)
HOST_WIDE_INT without loss of precision.

References ggc_alloc(), TREE_CODE, tree_fits_shwi_p(), and tree_fits_uhwi_p().

Referenced by add_autoinc_candidates(), adjust_nested_loop_clauses(), classify_builtin_st(), dump_mem_details(), find_or_create_group(), force_expr_to_var_cost(), gather_memory_references_ref(), idx_analyze_ref(), initialize_matrix_A(), int_cst_value(), inverse(), issue_prefetch_ref(), iv_elimination_compare_lt(), prune_ref_by_group_reuse(), prune_ref_by_self_reuse(), ptr_difference_const(), ptrdiff_tree_p(), should_issue_prefetch_p(), and strip_offset_1().

◆ ctor_to_vec()

vec< tree, va_gc > * ctor_to_vec ( tree ctor )

extern

Given a CONSTRUCTOR CTOR, return the element values as a vector.

Return the values of the elements of a CONSTRUCTOR as a vector of
trees.

References CONSTRUCTOR_ELTS, CONSTRUCTOR_NELTS, FOR_EACH_CONSTRUCTOR_VALUE, ggc_alloc(), and vec_alloc().

◆ decl_address_invariant_p()

bool decl_address_invariant_p ( const_tree op )

extern

Return whether OP is a DECL whose address is function-invariant.

References current_function_decl, DECL_CONTEXT, DECL_EXTERNAL, decl_function_context(), DECL_THREAD_LOCAL_P, ggc_alloc(), TREE_CODE, and TREE_STATIC.

Referenced by gimple_fold_stmt_to_constant_1(), is_gimple_invariant_address(), is_gimple_mem_ref_addr(), transaction_invariant_address_p(), and tree_invariant_p_1().

◆ decl_address_ip_invariant_p()

bool decl_address_ip_invariant_p ( const_tree op )

extern

Return whether OP is a DECL whose address is interprocedural-invariant.

References DECL_DLLIMPORT_P, DECL_EXTERNAL, DECL_THREAD_LOCAL_P, ggc_alloc(), TREE_CODE, and TREE_STATIC.

Referenced by is_gimple_ip_invariant_address(), and loc_list_from_tree_1().

◆ decl_assembler_name()

tree decl_assembler_name ( tree decl )

extern

The name of the object as the assembler will see it (but before any
translations made by ASM_OUTPUT_LABELREF).  Often this is the same
as DECL_NAME.  It is an IDENTIFIER_NODE.

References DECL_ASSEMBLER_NAME_RAW, DECL_ASSEMBLER_NAME_SET_P, and lang_hooks::set_decl_assembler_name.

Referenced by assign_assembler_name_if_needed(), and get_function_name().

◆ decl_comdat_group()

tree decl_comdat_group ( const_tree node )

extern

When the target supports COMDAT groups, this indicates which group the
DECL is associated with.  This can be either an IDENTIFIER_NODE or a
decl, in which case its DECL_ASSEMBLER_NAME identifies the group.

References symtab_node::get(), ggc_alloc(), and NULL.

◆ decl_comdat_group_id()

tree decl_comdat_group_id ( const_tree node )

extern

Likewise, but make sure it's been reduced to an IDENTIFIER_NODE.

References symtab_node::get(), ggc_alloc(), and NULL.

Referenced by ipa_tm_create_version_alias(), and write_symbol().

◆ decl_debug_args_insert()

vec< tree, va_gc > ** decl_debug_args_insert ( tree from )

extern

Insert a mapping FROM->empty vector of debug arguments in the value
expression hashtable.

References hash_table< Descriptor, Lazy, Allocator >::create_ggc(), debug_args_for_decl, decl_debug_args_lookup(), DECL_HAS_DEBUG_ARGS_P, DECL_UID, ggc_alloc(), and NULL.

Referenced by input_function(), ipa_param_adjustments::modify_call(), and tree_function_versioning().

◆ decl_debug_args_lookup()

vec< tree, va_gc > ** decl_debug_args_lookup ( tree from )

extern

Lookup a vector of debug arguments for FROM, and return it if we
find one.

References debug_args_for_decl, DECL_HAS_DEBUG_ARGS_P, DECL_UID, gcc_checking_assert, ggc_alloc(), and NULL.

Referenced by copy_debug_stmt(), decl_debug_args_insert(), expand_call_stmt(), expand_debug_source_expr(), output_function(), prepare_call_arguments(), split_function(), and tree_function_versioning().

◆ decl_debug_expr_insert()

void decl_debug_expr_insert	(	tree	from,
		tree	to )

extern

Insert a mapping FROM->TO in the debug expression hashtable.

References debug_expr_for_decl, DECL_UID, and ggc_alloc().

◆ decl_debug_expr_lookup()

tree decl_debug_expr_lookup ( tree from )

extern

Lookup a debug expression for FROM, and return it if we find one.

References debug_expr_for_decl, DECL_UID, ggc_alloc(), and NULL_TREE.

◆ DECL_FE_FUNCTION_CODE()

int DECL_FE_FUNCTION_CODE ( const_tree decl )

inline

Return the frontend-specific built-in function that DECL represents,
given that it is known to be a FUNCTION_DECL with built-in class
BUILT_IN_FRONTEND.

References BUILT_IN_FRONTEND, gcc_checking_assert, and ggc_alloc().

Referenced by print_node().

◆ decl_fini_priority_insert()

void decl_fini_priority_insert	(	tree	decl,
		priority_type	priority )

extern

Set the finalization priority for DECL to PRIORITY.

References DEFAULT_INIT_PRIORITY, cgraph_node::get(), cgraph_node::get_create(), and cgraph_node::set_fini_priority().

Referenced by cgraph_build_static_cdtor_1().

◆ decl_fini_priority_lookup()

priority_type decl_fini_priority_lookup ( tree decl )

extern

Return the finalization priority for DECL.

References DEFAULT_INIT_PRIORITY, cgraph_node::get(), and cgraph_node::get_fini_priority().

Referenced by rest_of_handle_final().

◆ DECL_FUNCTION_CODE()

built_in_function DECL_FUNCTION_CODE ( const_tree decl )

inline

Return the built-in function that DECL represents, given that it is known
to be a FUNCTION_DECL with built-in class BUILT_IN_NORMAL.

References BUILT_IN_NORMAL, gcc_checking_assert, and ggc_alloc().

Referenced by strlen_pass::adjust_last_stmt(), alloc_object_size(), alloca_call_p(), asan_memfn_rtl(), associated_internal_fn(), builtin_fnspec(), builtin_mathfn_code(), builtin_safe_for_const_function_p(), builtin_with_linkage_p(), can_implement_as_sibling_call_p(), can_test_argument_range(), strlen_pass::check_and_optimize_call(), check_bounds_or_overlap(), check_call(), check_defs(), check_fnspec(), check_omp_nesting_restrictions(), copy_attributes_to_builtin(), decl_attributes(), determine_versionability(), dse_optimize_redundant_stores(), dse_optimize_stmt(), edom_only_function(), eliminate_unnecessary_stmts(), emit_call_1(), estimate_num_insns(), evaluate_stmt(), expand_builtin(), expand_builtin_alloca(), expand_builtin_cexpi(), expand_builtin_fork_or_exec(), expand_builtin_frame_address(), expand_builtin_goacc_parlevel_id_size(), expand_builtin_int_roundingfn(), expand_builtin_int_roundingfn_2(), expand_builtin_mathfn_3(), expand_builtin_mathfn_ternary(), expand_builtin_memcmp(), expand_builtin_memset_args(), expand_builtin_sync_operation(), expand_call_stmt(), expand_call_tm(), expr_expected_value_1(), find_func_aliases_for_builtin_call(), find_func_clobbers(), find_tm_replacement_function(), fndecl_alloc_p(), fndecl_built_in_p(), fndecl_dealloc_argno(), fold_builtin_0(), fold_builtin_1(), fold_builtin_2(), fold_builtin_3(), fold_builtin_interclass_mathfn(), fold_builtin_varargs(), fully_constant_vn_reference_p(), gen_shrink_wrap_conditions(), get_call_combined_fn(), get_mem_refs_of_builtin_call(), get_string_length(), gimple_alloca_call_p(), gimple_build_call_from_tree(), gimple_builtin_call_types_compatible_p(), gimple_call_combined_fn(), gimple_call_return_array(), gimple_extract(), gimple_fold_builtin(), gimple_fold_builtin_string_compare(), gimple_stringops_transform(), gimplify_addr_expr(), gimplify_call_expr(), handle_builtin_alloca(), strlen_pass::handle_builtin_memset(), strlen_pass::handle_builtin_strlen(), handle_printf_call(), operand_compare::hash_operand(), initialize_ao_ref_for_dse(), inline_expand_builtin_bytecmp(), inline_forbidden_p_stmt(), instrument_builtin(), instrument_builtin_call(), interclass_mathfn_icode(), interesting_stringop_to_profile_p(), is_addr_local(), is_inexpensive_builtin(), is_simple_builtin(), is_strlen_related_p(), is_sync_builtin_call(), is_tm_builtin(), is_tm_ending_fndecl(), is_tm_load(), is_tm_simple_load(), is_tm_simple_store(), is_tm_store(), lower_coro_builtin(), lower_eh_constructs_2(), lower_omp_1(), lower_stmt(), mark_all_reaching_defs_necessary_1(), mark_stmt_if_obviously_necessary(), matching_alloc_calls_p(), maybe_diag_stxncpy_trunc(), maybe_instrument_call(), maybe_invalidate(), maybe_trim_memstar_call(), maybe_warn_nonstring_arg(), maybe_warn_operand(), maybe_warn_pass_by_reference(), move_stmt_r(), nonfreeing_call_p(), old_insns_match_p(), optimize_atomic_compare_exchange_p(), optimize_stack_restore(), optimize_stdarg_builtin(), optimize_va_list_gpr_fpr_size(), possible_polymorphic_call_target_p(), print_node(), propagate_necessity(), jump_threader::record_temporary_equivalences_from_stmts_at_dest(), remap_gimple_stmt(), scan_omp_1_stmt(), set_builtin_user_assembler_name(), simplify_builtin_call(), special_function_p(), stmt_kills_ref_p(), strub_callable_builtin_p(), tm_memopt_transform_stmt(), tm_region_init_1(), tree_builtin_call_types_compatible_p(), valid_builtin_call(), vect_recog_pow_pattern(), verify_gimple_call(), and visit_bb().

◆ decl_function_context()

tree decl_function_context ( const_tree decl )

extern

Return the FUNCTION_DECL which provides this _DECL with its context,
or zero if none.

Return the innermost context enclosing DECL that is
a FUNCTION_DECL, or zero if none.

References BLOCK_SUPERCONTEXT, DECL_CONTEXT, DECL_VIRTUAL_P, get_containing_scope(), ggc_alloc(), TREE_CODE, TREE_TYPE, TREE_VALUE, TYPE_ARG_TYPES, and TYPE_MAIN_VARIANT.

Referenced by analyze_functions(), can_implement_as_sibling_call_p(), computable_teams_clause(), convert_gimple_call(), convert_local_omp_clauses(), convert_local_reference_op(), convert_local_reference_stmt(), convert_nl_goto_reference(), convert_nonlocal_omp_clauses(), convert_nonlocal_reference_op(), convert_nonlocal_reference_stmt(), convert_tramp_reference_op(), copy_tree_body_r(), decl_address_invariant_p(), expand_expr_real_1(), expand_goto(), force_label_rtx(), get_nonlocal_debug_decl(), gimple_verify_flow_info(), gimplify_expr(), gimplify_label_expr(), gimplify_modify_expr(), gimplify_var_or_parm_decl(), instrument_derefs(), instrument_object_size(), lookup_field_for_decl(), new_die(), note_nonlocal_vla_type(), omp_copy_decl(), remap_gimple_op_r(), remap_vla_decls(), rest_of_decl_compilation(), tree_is_indexable(), type_all_derivations_known_p(), and verify_expr_location_1().

◆ decl_init_priority_insert()

void decl_init_priority_insert	(	tree	decl,
		priority_type	priority )

extern

Set the initialization priority for DECL to PRIORITY.

References DEFAULT_INIT_PRIORITY, symtab_node::get(), varpool_node::get_create(), cgraph_node::get_create(), ggc_alloc(), and VAR_P.

Referenced by cgraph_build_static_cdtor_1().

◆ decl_init_priority_lookup()

priority_type decl_init_priority_lookup ( tree decl )

extern

Return the initialization priority for DECL.

References DEFAULT_INIT_PRIORITY, symtab_node::get(), and ggc_alloc().

Referenced by rest_of_handle_final().

◆ DECL_MD_FUNCTION_CODE()

int DECL_MD_FUNCTION_CODE ( const_tree decl )

inline

Return the target-specific built-in function that DECL represents,
given that it is known to be a FUNCTION_DECL with built-in class
BUILT_IN_MD.

References BUILT_IN_MD, gcc_checking_assert, and ggc_alloc().

Referenced by print_node().

◆ decl_section_name()

const char * decl_section_name ( const_tree node )

extern

When the target supports named section, return its name as IDENTIFIER_NODE
or NULL if it is in no section.

References symtab_node::get(), ggc_alloc(), and NULL.

◆ decl_tls_model()

enum tls_model decl_tls_model ( const_tree node )

extern

Return TLS model of a variable NODE.

References varpool_node::get(), ggc_alloc(), and TLS_MODEL_NONE.

Referenced by function_and_variable_visibility().

◆ decl_type_context()

tree decl_type_context ( const_tree decl )

extern

Return the RECORD_TYPE, UNION_TYPE, or QUAL_UNION_TYPE which provides
this _DECL with its context, or zero if none.

Return the innermost context enclosing DECL that is
a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, or zero if none.
TYPE_DECLs and FUNCTION_DECLs are transparent to this function.

References BLOCK_SUPERCONTEXT, DECL_CONTEXT, gcc_unreachable, ggc_alloc(), NULL_TREE, and TREE_CODE.

Referenced by rest_of_decl_compilation().

◆ decl_value_expr_insert()

void decl_value_expr_insert	(	tree	from,
		tree	to )

extern

Insert a mapping FROM->TO in the value expression hashtable.

References DECL_UID, ggc_alloc(), protected_set_expr_location_unshare(), UNKNOWN_LOCATION, and value_expr_for_decl.

◆ decl_value_expr_lookup()

tree decl_value_expr_lookup ( tree from )

extern

Lookup a value expression for FROM, and return it if we find one.

References DECL_UID, ggc_alloc(), NULL_TREE, and value_expr_for_decl.

◆ default_is_empty_record()

bool default_is_empty_record ( const_tree type )

extern

Implement TARGET_EMPTY_RECORD_P.  Return true if TYPE is an empty type
that shouldn't be passed via stack.

References abi_version_at_least, error_mark_node, is_empty_type(), TREE_ADDRESSABLE, and TYPE_MAIN_VARIANT.

◆ desired_pro_or_demotion_p()

bool desired_pro_or_demotion_p	(	const_tree	to_type,
		const_tree	from_type )

inline

Return true if it makes sense to promote/demote from_type to to_type.

References GET_MODE_PRECISION(), ggc_alloc(), TYPE_PRECISION, and word_mode.

Referenced by simplify_using_ranges::simplify_casted_compare().

◆ double_int_to_tree()

tree double_int_to_tree	(	tree	type,
		double_int	cst )

extern

Constructs double_int from tree CST.

Constructs tree in type TYPE from with value given by CST.  Signedness
of CST is assumed to be the same as the signedness of TYPE.

References ggc_alloc(), TYPE_SIGN, and wide_int_to_tree().

Referenced by native_encode_fixed().

◆ drop_tree_overflow()

tree drop_tree_overflow ( tree t )

extern

Drops the TREE_OVERFLOW flag from T.

References copy_node(), count, drop_tree_overflow(), gcc_checking_assert, ggc_alloc(), i, poly_int_tree_p(), wi::to_poly_wide(), TREE_CODE, TREE_IMAGPART, TREE_OVERFLOW, TREE_REALPART, TREE_TYPE, VECTOR_CST_ELT, and wide_int_to_tree().

Referenced by canonicalize_constructor_val(), canonicalize_value(), drop_tree_overflow(), factor_out_conditional_operation(), fold_builtin_arith_overflow(), fold_const_call(), fold_const_call(), get_single_symbol(), range_query::get_tree_range(), gimple_fold_call(), gimple_resimplify1(), gimple_resimplify2(), gimple_resimplify3(), gimplify_expr(), maybe_optimize_arith_overflow(), propagate_vr_across_jump_function(), set_ssa_name_value(), and split_tree().

◆ dump_tree_statistics()

void dump_tree_statistics ( void )

extern

Print debugging information about tree nodes generated during the compile,
and any language-specific information.

References all_kinds, get_tree_code_name(), ggc_alloc(), i, MAX_TREE_CODES, phinodes_print_statistics(), mem_usage::print_dash_line(), print_debug_expr_statistics(), print_type_hash_statistics(), print_value_expr_statistics(), PRIu64, SIZE_AMOUNT, ssanames_print_statistics(), tree_code_counts, tree_codes_cmp(), TREE_MEM_USAGE_SPACES, tree_node_counts, tree_node_kind_names, tree_node_sizes, and tree_nodes_cmp().

Referenced by dump_memory_report().

◆ element_mode()

machine_mode element_mode ( const_tree t )

extern

Return the machine mode of T.  For vectors, returns the mode of the
inner type.  The main use case is to feed the result to HONOR_NANS,
avoiding the BLKmode that a direct TYPE_MODE (T) might return.

References ggc_alloc(), TREE_CODE, TREE_TYPE, TYPE_MODE, TYPE_P, and VECTOR_TYPE_P.

Referenced by default_vectorize_related_mode(), HONOR_INFINITIES(), HONOR_NANS(), HONOR_SIGN_DEPENDENT_ROUNDING(), HONOR_SIGNED_ZEROS(), HONOR_SNANS(), record_edge_info(), related_vector_mode(), sign_mask_for(), tree_expr_finite_p(), try_special_add_to_ops(), vect_truncate_gather_scatter_offset(), verify_gimple_assign_binary(), verify_gimple_assign_ternary(), and verify_gimple_assign_unary().

◆ element_precision()

unsigned int element_precision ( const_tree type )

extern

Return the precision of the type, or for a complex or vector type the
precision of the type of its elements.

References ggc_alloc(), TREE_CODE, TREE_TYPE, TYPE_P, and TYPE_PRECISION.

Referenced by convert_to_integer_1(), convert_to_real_1(), divmod_candidate_p(), fold_binary_loc(), fold_negate_expr_1(), get_nonzero_bits(), hashable_expr_equal_p(), loop_exits_before_overflow(), movement_possibility_1(), negate_expr_p(), operand_compare::operand_equal_p(), strip_float_extensions(), and verify_gimple_assign_unary().

◆ error_operand_p()

bool error_operand_p ( const_tree t )

inline

True if T is an erroneous expression.

References error_mark_node, and TREE_TYPE.

Referenced by aggregate_value_p(), computable_teams_clause(), convert_to_complex_1(), decl_attributes(), fold_builtin_1(), fold_builtin_2(), fold_builtin_3(), gimplify_compound_lval(), gimplify_expr(), gimplify_modify_expr(), gimplify_omp_affinity(), gimplify_omp_depend(), gimplify_scan_omp_clauses(), maybe_wrap_with_location(), omp_add_variable(), omp_build_struct_sibling_lists(), and omp_notice_variable().

◆ error_unavailable_use()

void error_unavailable_use	(	tree	node,
		tree	attr )

extern

Error out with an identifier which was marked 'unavailable'.

References DECL_ATTRIBUTES, DECL_NAME, DECL_P, DECL_SOURCE_LOCATION, error(), inform(), lookup_attribute(), msg, NULL_TREE, TREE_CODE, TREE_STRING_POINTER, TREE_TYPE, TREE_VALUE, TYPE_ATTRIBUTES, TYPE_NAME, TYPE_P, and TYPE_STUB_DECL.

◆ excess_precision_type()

tree excess_precision_type ( tree type )

extern

If TYPE is a real or complex floating-point type and the target
does not directly support arithmetic on TYPE then return the wider
type to be used for arithmetic on TYPE.  Otherwise, return
NULL_TREE.

References bfloat16_type_node, complex_double_type_node, complex_float_type_node, complex_long_double_type_node, double_type_node, EXCESS_PRECISION_FAST, EXCESS_PRECISION_FLOAT16, EXCESS_PRECISION_TYPE_FAST, EXCESS_PRECISION_TYPE_FLOAT16, EXCESS_PRECISION_TYPE_STANDARD, float16_type_node, float_type_node, FLT_EVAL_METHOD_PROMOTE_TO_DOUBLE, FLT_EVAL_METHOD_PROMOTE_TO_FLOAT, FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16, FLT_EVAL_METHOD_PROMOTE_TO_LONG_DOUBLE, FLT_EVAL_METHOD_UNPREDICTABLE, gcc_assert, gcc_unreachable, ggc_alloc(), long_double_type_node, NULL_TREE, targetm, TREE_CODE, TREE_TYPE, and TYPE_MODE.

◆ expr_type_first_operand_type_p()

bool expr_type_first_operand_type_p ( tree_code code )

extern

Return true if an expression with CODE has to have the same result type as
its first operand.

References ggc_alloc().

Referenced by ipa_get_jf_arith_result().

◆ find_placeholder_in_expr()

void find_placeholder_in_expr	(	tree	exp,
		vec< tree > *	refs )

extern

Given a tree EXP, find all occurrences of references to fields
in a PLACEHOLDER_EXPR and place them in vector REFS without
duplicates.  Also record VAR_DECLs and CONST_DECLs.  Note that
we assume here that EXP contains only arithmetic expressions
or CALL_EXPRs with PLACEHOLDER_EXPRs occurring only in their
argument list.

References exp(), FIND_PLACEHOLDER_IN_EXPR, gcc_unreachable, ggc_alloc(), i, push_without_duplicates(), REFERENCE_CLASS_P, refs, tcc_binary, tcc_comparison, tcc_constant, tcc_declaration, tcc_exceptional, tcc_expression, tcc_reference, tcc_unary, tcc_vl_exp, TREE_CHAIN, TREE_CODE, TREE_CODE_CLASS, TREE_CODE_LENGTH, TREE_OPERAND, TREE_OPERAND_LENGTH, TREE_STATIC, and TREE_VALUE.

Referenced by self_referential_size().

◆ first_call_expr_arg()

tree first_call_expr_arg	(	tree	exp,
		call_expr_arg_iterator *	iter )

inline

A hash_map of two trees for use with

References exp(), and ggc_alloc().

Referenced by maybe_inline_call_in_expr().

◆ first_const_call_expr_arg()

const_tree first_const_call_expr_arg	(	const_tree	exp,
		const_call_expr_arg_iterator *	iter )

inline

References exp(), and ggc_alloc().

Referenced by operand_compare::operand_equal_p(), and simple_cst_equal().

◆ first_field()

tree first_field ( const_tree type )

extern

Returns the first/last FIELD_DECL in a RECORD_TYPE.

Returns the first FIELD_DECL in the TYPE_FIELDS of the RECORD_TYPE or
UNION_TYPE TYPE, or NULL_TREE if none.

References ggc_alloc(), TREE_CHAIN, TREE_CODE, and TYPE_FIELDS.

Referenced by aggregate_value_p(), assign_parm_find_data_types(), get_vec_alignment_for_record_type(), initialize_argument_information(), load_register_parameters(), and pass_by_reference().

◆ fixed_zerop()

bool fixed_zerop ( const_tree expr )

extern

fixed_zerop (tree x) is nonzero if X is a fixed-point constant of
value 0.

Return true if EXPR is the fixed-point constant zero, or a location wrapper
for such a constant.

References ggc_alloc(), STRIP_ANY_LOCATION_WRAPPER, TREE_CODE, and TREE_FIXED_CST.

Referenced by initializer_zerop(), operation_could_trap_helper_p(), some_nonzerop(), and zerop().

◆ flexible_array_type_p()

bool flexible_array_type_p ( const_tree type )

extern

Determine whether TYPE is a structure with a flexible array member,
or a union containing such a structure (possibly recursively).

References DECL_CHAIN, flexible_array_type_p(), ggc_alloc(), last, NULL_TREE, TREE_CODE, TREE_TYPE, TYPE_DOMAIN, TYPE_FIELDS, TYPE_MAX_VALUE, and TYPE_SIZE.

Referenced by flexible_array_type_p().

◆ fndecl_built_in_p() [1/4]

bool fndecl_built_in_p ( const_tree node )

inline

Return true if a FUNCTION_DECL NODE is a GCC built-in function.

Note that it is different from the DECL_IS_UNDECLARED_BUILTIN
accessor, as this is impervious to user declaration.

References DECL_BUILT_IN_CLASS, and NOT_BUILT_IN.

Referenced by ipa_param_adjustments::adjust_decl(), builtin_mathfn_code(), calls_builtin_apply_args_p(), calls_builtin_va_start_p(), can_strub_internally_p(), cgraph_externally_visible_p(), cgraph_update_edges_for_call_stmt_node(), check_access(), compute_fn_summary(), copy_bb(), cgraph_node::create_clone(), decl_fnspec(), determine_versionability(), diag_attr_exclusions(), dump_gimple_call(), estimate_num_insns(), expand_call_stmt(), expand_expr_real_1(), find_func_aliases_for_call(), find_replaceable_in_bb(), find_tail_calls(), fndecl_alloc_p(), fndecl_built_in_p(), fndecl_built_in_p(), fndecl_built_in_p(), fndecl_dealloc_argno(), fold_binary_loc(), fold_builtin_call_array(), fold_builtin_expect(), fold_call_expr(), fold_call_stmt(), fold_marked_statements(), fully_constant_vn_reference_p(), gen_shrink_wrap_conditions(), get_call_combined_fn(), get_string_length(), get_upper_bound_based_on_builtin_expr_with_prob(), gimple_alloca_call_p(), gimple_boolify(), gimple_build_call_from_tree(), gimple_call_builtin_p(), gimple_call_combined_fn(), gimple_fold_stmt_to_constant_1(), gimplify_addr_expr(), gimplify_call_expr(), gimplify_modify_expr(), goa_stabilize_expr(), handle_lhs_call(), input_node(), ipa_get_indirect_edge_target_1(), ipa_read_edge_info(), is_simple_builtin(), is_tm_abort(), is_tm_irrevocable(), is_tm_load(), is_tm_simple_load(), is_tm_simple_store(), is_tm_store(), is_ubsan_builtin_p(), lower_coro_builtin(), lower_eh_constructs_2(), lower_omp_1(), lower_stmt(), mark_all_reaching_defs_necessary_1(), mark_stmt_if_obviously_necessary(), matching_alloc_calls_p(), maybe_warn_nonstring_arg(), ipa_param_body_adjustments::modify_formal_parameters(), move_stmt_r(), need_assembler_name_p(), operand_compare::operand_equal_p(), optimize_stack_restore(), dom_opt_dom_walker::optimize_stmt(), optimize_va_list_gpr_fpr_size(), symtab_node::output_to_lto_symbol_table_p(), possible_polymorphic_call_target_p(), print_node(), read_ipa_call_summary(), jump_threader::record_temporary_equivalences_from_stmts_at_dest(), cgraph_edge::redirect_call_stmt_to_callee(), remap_gimple_stmt(), scan_insn(), set_builtin_user_assembler_name(), setjmp_or_longjmp_p(), simplify_builtin_call(), simulate_builtin_function_decl(), split_function(), stmt_can_terminate_bb_p(), stmt_cost(), strip_predict_hints(), surely_varying_stmt_p(), tm_region_init_1(), try_make_edge_direct_virtual_call(), vectorizable_call(), cgraph_edge::verify_corresponds_to_fndecl(), verify_gimple_call(), cgraph_node::verify_node(), verify_strub(), and visit_bb().

◆ fndecl_built_in_p() [2/4]

bool fndecl_built_in_p	(	const_tree	node,
		built_in_class	klass )

inline

Return true if a FUNCTION_DECL NODE is a GCC built-in function
of class KLASS.

References DECL_BUILT_IN_CLASS, fndecl_built_in_p(), and ggc_alloc().

◆ fndecl_built_in_p() [3/4]

template<typename... F>

bool fndecl_built_in_p	(	const_tree	node,
		built_in_function	name1,
		F...	names )

inline

Return true if a FUNCTION_DECL NODE is a GCC built-in function
of BUILT_IN_NORMAL class with name equal to NAME1 (or other mentioned
NAMES).

References built_in_function_equal_p(), BUILT_IN_NORMAL, DECL_FUNCTION_CODE(), fndecl_built_in_p(), and names.

◆ fndecl_built_in_p() [4/4]

bool fndecl_built_in_p	(	const_tree	node,
		unsigned int	name,
		built_in_class	klass )

inline

Return true if a FUNCTION_DECL NODE is a GCC built-in function
of class KLASS with name equal to NAME.

References DECL_UNCHECKED_FUNCTION_CODE, fndecl_built_in_p(), and ggc_alloc().

◆ fndecl_dealloc_argno()

unsigned fndecl_dealloc_argno ( tree fndecl )

extern

Return the zero-based number corresponding to the argument being
deallocated if FNDECL is a deallocation function or an out-of-bounds
value if it isn't.

References BUILT_IN_NORMAL, DECL_ASSEMBLER_NAME, DECL_ATTRIBUTES, DECL_FUNCTION_CODE(), DECL_IS_OPERATOR_DELETE_P, DECL_IS_REPLACEABLE_OPERATOR, fndecl_built_in_p(), ggc_alloc(), id_equal(), lookup_attribute(), TREE_CHAIN, TREE_INT_CST_LOW, TREE_VALUE, and UINT_MAX.

◆ force_fit_type()

tree force_fit_type	(	tree	type,
		const poly_wide_int_ref &	cst,
		int	overflowable,
		bool	overflowed )

extern

We force the wide_int CST to the range of the type TYPE by sign or
zero extending it.  OVERFLOWABLE indicates if we are interested in
overflow of the value, when >0 we are only interested in signed
overflow, for <0 we are interested in any overflow.  OVERFLOWED
indicates whether overflow has already occurred.  CONST_OVERFLOWED
indicates whether constant overflow has already occurred.  We force
T's value to be within range of T's type (by setting to 0 or 1 all
the bits outside the type's range).  We set TREE_OVERFLOWED if,
     OVERFLOWED is nonzero,
     or OVERFLOWABLE is >0 and signed overflow occurs
     or OVERFLOWABLE is <0 and any overflow occurs
We return a new tree node for the extended wide_int.  The node
is shared if no overflow flags are set.

References build_new_int_cst(), build_new_poly_int_cst(), tree_poly_int_cst::coeffs, wi::fits_to_tree_p(), poly_int< N, C >::from(), ggc_alloc(), i, NUM_POLY_INT_COEFFS, SIGNED, TREE_OVERFLOW, TYPE_PRECISION, TYPE_SIGN, and wide_int_to_tree().

Referenced by const_binop(), fold_abs_const(), fold_convert_const_int_from_fixed(), fold_convert_const_int_from_int(), fold_convert_const_int_from_real(), fold_div_compare(), fold_negate_const(), fold_not_const(), fold_unary_loc(), int_const_binop(), and round_up_loc().

◆ free_node()

void free_node ( tree node )

extern

Free tree node.

References BINFO_BASE_ACCESSES, BLOCK_NONLOCALIZED_VARS, CODE_CONTAINS_STRUCT, CONSTRUCTOR_ELTS, gcc_checking_assert, get_stats_node_kind(), ggc_alloc(), ggc_free(), TREE_CODE, tree_code_counts, tree_node_counts, tree_node_sizes, TREE_OPTIMIZATION, tree_size(), TREE_TARGET_OPTION, and vec_free().

Referenced by type_hash_canon().

◆ function_args_iter_cond()

tree function_args_iter_cond ( function_args_iterator * i )

inline

Return the next argument if there are more arguments to handle, otherwise
return NULL.

References i, NULL_TREE, and TREE_VALUE.

Referenced by maybe_warn_nonstring_arg().

◆ function_args_iter_cond_ptr()

tree * function_args_iter_cond_ptr ( function_args_iterator * i )

inline

Return a pointer that holds the next argument if there are more arguments to
handle, otherwise return NULL.

References i, NULL, and TREE_VALUE.

◆ function_args_iter_init()

void function_args_iter_init	(	function_args_iterator *	i,
		const_tree	fntype )

inline

Initialize the iterator I with arguments from function FNDECL

References i, and TYPE_ARG_TYPES.

Referenced by maybe_warn_nonstring_arg().

◆ function_args_iter_next()

void function_args_iter_next ( function_args_iterator * i )

inline

Advance to the next argument.

References gcc_assert, i, NULL_TREE, and TREE_CHAIN.

Referenced by maybe_warn_nonstring_arg().

◆ get_attr_nonstring_decl()

tree get_attr_nonstring_decl	(	tree	expr,
		tree *	ref )

extern

If an expression refers to a character array or pointer declared
attribute nonstring, return a decl for that array or pointer and
if nonnull, set the second argument to the referenced enclosing
object or pointer.  Otherwise return null.

If EXPR refers to a character array or pointer declared attribute
nonstring, return a decl for that array or pointer and set *REF
to the referenced enclosing object or pointer.  Otherwise return
null.

References DECL_ATTRIBUTES, DECL_P, expr, get_attr_nonstring_decl(), ggc_alloc(), gimple_assign_rhs1(), gimple_assign_rhs_code(), is_gimple_assign(), lookup_attribute(), NULL_TREE, SSA_NAME_DEF_STMT, SSA_NAME_VAR, TREE_CODE, and TREE_OPERAND.

Referenced by get_attr_nonstring_decl(), gimple_fold_builtin_strncpy(), maybe_diag_stxncpy_trunc(), and maybe_warn_nonstring_arg().

◆ get_base_address()

tree get_base_address ( tree t )

extern

Given a memory reference expression T, return its base address.
The base address of a memory reference expression is the main
object being referenced.

Given a memory reference expression T, return its base address.
The base address of a memory reference expression is the main
object being referenced.  For instance, the base address for
'array[i].fld[j]' is 'array'.  You can think of this as stripping
away the offset part from a memory address.

This function calls handled_component_p to strip away all the inner
parts of the memory reference until it reaches the base object.

References ggc_alloc(), handled_component_p(), TREE_CODE, and TREE_OPERAND.

Referenced by nontrapping_dom_walker::add_or_mark_expr(), adjust_references_in_caller(), ao_ref_init_from_ptr_and_range(), array_ref_flexible_size_p(), avoid_type_punning_on_regs(), base_object_writable(), build_access_from_call_arg(), build_access_from_expr_1(), can_escape(), can_sm_ref_p(), canonicalize_constructor_val(), check_op(), compute_live_vars_visit(), cond_if_else_store_replacement_1(), cond_store_replacement(), copy_ref_info(), create_specialized_node(), cgraph_node::create_virtual_clone(), declare_return_variable(), dest_safe_for_nrv_p(), detect_type_change_from_memory_writes(), determine_base_object_1(), discover_nonconstant_array_refs(), discover_nonconstant_array_refs_r(), disqualify_base_of_expr(), dr_analyze_alias(), eliminate_local_variables_1(), eliminated_by_inlining_prob(), execute_fixup_cfg(), execute_update_addresses_taken(), find_func_aliases(), gather_memory_references_ref(), get_base_decl(), ipa_polymorphic_call_context::get_dynamic_type(), get_memory_rtx(), get_range_strlen_tree(), get_references_in_stmt(), gimple_duplicate_bb(), gimple_ior_addresses_taken_1(), gimple_range_base_of_assignment(), gimplify_asm_expr(), gimplify_init_constructor(), gimplify_scan_omp_clauses(), handle_lhs_call(), initialize_argument_information(), instrument_null(), is_addr_local(), is_asan_mark_p(), load_from_dereferenced_name(), load_or_store_of_ptr_parameter(), lower_omp_1(), lower_omp_target(), mark_address(), mark_address_taken(), mark_load(), mark_nonssa_use(), mark_store(), maybe_remove_writeonly_store(), maybe_set_strlen_range(), maybe_warn_operand(), mem_dies_at_call(), non_rewritable_mem_ref_base(), oacc_entry_exit_ok_1(), omp_notice_variable(), param_change_prob(), parm_preserved_before_stmt_p(), points_to_possible_sra_candidate_p(), ptr_deref_may_alias_decl_p(), ptr_derefs_may_alias_p(), ptrs_compare_unequal(), readonly_data_expr(), ref_may_alias_global_p(), refs_local_or_readonly_memory_p(), remove_unused_locals(), scan_sharing_clauses(), scan_visit_addr(), self_inlining_addr_expr(), set_mem_attributes_minus_bitpos(), sra_modify_call_arg(), strdup_object_size(), test_nonssa_use(), tls_mem_loc_descriptor(), tree_single_nonzero_warnv_p(), unadjusted_ptr_and_unit_offset(), va_list_counter_bump(), va_list_counter_struct_op(), vect_analyze_data_refs(), vect_get_datarefs_in_loop(), vectorizable_store(), visit_conflict(), visit_op(), visit_ref_for_mod_analysis(), and visit_reference_op_call().

◆ get_binfo_at_offset()

tree get_binfo_at_offset	(	tree	binfo,
		poly_int64	offset,
		tree	expected_type )

extern

Try to find a base info of BINFO that would have its field decl at offset
OFFSET within the BINFO type and which is of EXPECTED_TYPE.  If it can be
found, return, otherwise return NULL_TREE.

References BINFO_BASE_ITERATE, BINFO_OFFSET, BINFO_TYPE, DECL_ARTIFICIAL, DECL_CHAIN, DECL_SIZE, ggc_alloc(), i, int_bit_position(), lookup_binfo_at_offset(), NULL, NULL_TREE, offset, TREE_CODE, tree_to_shwi(), tree_to_uhwi(), TREE_TYPE, TYPE_FIELDS, and types_same_for_odr().

Referenced by possible_polymorphic_call_targets(), record_target_from_binfo(), record_targets_from_bases(), and ipa_polymorphic_call_context::restrict_to_inner_class().

◆ get_call_combined_fn()

combined_fn get_call_combined_fn ( const_tree call )

extern

If CALL_EXPR CALL calls a normal built-in function or an internal function,
return the associated function code, otherwise return CFN_LAST.

References as_combined_fn(), BUILT_IN_NORMAL, CALL_EXPR_FN, CALL_EXPR_IFN, CFN_LAST, DECL_FUNCTION_CODE(), fndecl_built_in_p(), gcc_assert, get_callee_fndecl(), ggc_alloc(), tree_builtin_call_types_compatible_p(), and TREE_CODE.

Referenced by expression_expensive_p(), fold_negate_expr_1(), integer_valued_real_p(), negate_expr_p(), tree_expr_finite_p(), tree_expr_maybe_nan_p(), tree_expr_maybe_real_minus_zero_p(), tree_expr_maybe_signaling_nan_p(), and tree_invalid_nonnegative_warnv_p().

◆ get_callee_fndecl()

tree get_callee_fndecl ( const_tree call )

extern

CALL is a CALL_EXPR.  Return the declaration for the function
called, or NULL_TREE if the called function cannot be
determined.

References CALL_EXPR_FN, DECL_INITIAL, DECL_P, error_mark_node, gcc_assert, ggc_alloc(), NULL_TREE, STRIP_NOPS, TREE_CODE, TREE_OPERAND, TREE_READONLY, and TREE_THIS_VOLATILE.

Referenced by get_call_combined_fn().

◆ get_containing_scope()

tree get_containing_scope ( const_tree t )

extern

Given a DECL or TYPE, return the scope in which it was declared, or
NUL_TREE if there is no containing scope.

Given a DECL or TYPE, return the scope in which it was declared, or
NULL_TREE if there is no containing scope.

References DECL_CONTEXT, TYPE_CONTEXT, and TYPE_P.

Referenced by decl_function_context(), and get_ultimate_context().

◆ get_expr_source_range()

source_range get_expr_source_range ( tree expr )

inline

References EXPR_LOCATION, ggc_alloc(), and line_table.

◆ get_file_function_name()

tree get_file_function_name ( const char * type )

extern

Generate a name for a special-purpose function.
The generated name may need to be unique across the whole link.
Changes to this function may also require corresponding changes to
xstrdup_mask_random.
TYPE is some string to identify the purpose of this function to the
linker or collect2; it must start with an uppercase letter,
one of:
I - for constructors
D - for destructors
N - for C++ anonymous namespaces
F - for DWARF unwind frame information.

References alloca, clean_symbol_name(), crc32_string(), FILE_FUNCTION_FORMAT, first_global_object_name, get_identifier(), get_random_seed(), ggc_alloc(), HOST_WIDE_INT_PRINT_HEX, input_location, LOCATION_FILE, startswith(), targetm, and weak_global_object_name.

Referenced by cgraph_build_static_cdtor_1(), self_referential_size(), and switch_to_eh_frame_section().

◆ get_inner_reference()

tree get_inner_reference	(	tree	exp,
		poly_int64 *	pbitsize,
		poly_int64 *	pbitpos,
		tree *	poffset,
		machine_mode *	pmode,
		int *	punsignedp,
		int *	preversep,
		int *	pvolatilep )

extern

Given an expression EXP that is a handled_component_p,
look for the ultimate containing object, which is returned and specify
the access position and size.

Given an expression EXP that may be a COMPONENT_REF, a BIT_FIELD_REF,
an ARRAY_REF, or an ARRAY_RANGE_REF, look for nested operations of these
codes and find the ultimate containing object, which we return.

We set *PBITSIZE to the size in bits that we want, *PBITPOS to the
bit position, *PUNSIGNEDP to the signedness and *PREVERSEP to the
storage order of the field.
If the position of the field is variable, we store a tree
giving the variable offset (in units) in *POFFSET.
This offset is in addition to the bit position.
If the position is not variable, we store 0 in *POFFSET.

If any of the extraction expressions is volatile,
we store 1 in *PVOLATILEP.  Otherwise we don't change that.

If the field is a non-BLKmode bit-field, *PMODE is set to VOIDmode.
Otherwise, it is a mode that can be used to access the field.

If the field describes a variable-sized object, *PMODE is set to
BLKmode and *PBITSIZE is set to -1.  An access cannot be made in
this case, but the address of the object can be found.

References array_ref_element_size(), array_ref_low_bound(), bits_to_bytes_round_down, build_int_cst(), component_ref_field_offset(), DECL_BIT_FIELD, DECL_BIT_FIELD_TYPE, DECL_FIELD_BIT_OFFSET, DECL_MODE, DECL_SIZE, DECL_UNSIGNED, exp(), fold_build2, fold_convert, poly_int< N, C >::force_shwi(), GET_MODE_BITSIZE(), ggc_alloc(), integer_zerop(), INTEGRAL_TYPE_P, mem_ref_offset(), expand_operand::mode, NULL_TREE, num_trailing_bits, offset, poly_int_tree_p(), reverse_storage_order_for_component_p(), wi::sext(), size_binop, size_zero_node, sizetype, wi::to_poly_offset(), poly_int< N, C >::to_shwi(), TREE_CODE, tree_fits_uhwi_p(), tree_int_cst_equal(), TREE_OPERAND, TREE_THIS_VOLATILE, tree_to_uhwi(), TREE_TYPE, TYPE_MODE, TYPE_MODE_RAW, TYPE_PRECISION, TYPE_SIZE, TYPE_UNSIGNED, VECTOR_MODE_P, and VECTOR_TYPE_P.

Referenced by decode_field_reference(), delegitimize_mem_from_attrs(), dr_analyze_innermost(), expand_assignment(), expand_debug_expr(), expand_expr_addr_expr_1(), expand_expr_real_1(), extract_base_bit_offset(), fold_comparison(), fold_unary_loc(), fortran_common(), get_base_for_alignment_1(), get_bit_range(), get_inner_reference_aff(), get_object_alignment_2(), instrument_bool_enum_load(), instrument_derefs(), instrument_expr(), instrument_object_size(), interpret_rhs_expr(), loc_list_for_address_of_addr_expr_of_indirect_ref(), loc_list_from_tree_1(), make_bit_field_ref(), maybe_instrument_pointer_overflow(), maybe_optimize_ubsan_ptr_ifn(), optimize_bit_field_compare(), fold_using_range::range_of_address(), scan_operand_equal_p(), slsr_process_ref(), split_address_to_core_and_offset(), split_constant_offset_1(), tree_to_aff_combination(), and vect_check_gather_scatter().

◆ get_name()

const char * get_name ( tree t )

extern

Given a tree, try to return a useful variable name that we can use
to prefix a temporary that is being assigned the value of the tree.
I.E. given  <temp> = &A, return A.

References DECL_NAME, DECL_P, get_name(), ggc_alloc(), IDENTIFIER_POINTER, NULL, SSA_NAME_IDENTIFIER, STRIP_NOPS, TREE_CODE, and TREE_OPERAND.

Referenced by alias_get_name(), create_tmp_from_val(), dt_operand::gen(), dt_simplify::gen(), dt_operand::gen_gimple_expr(), gen_lsm_tmp_name(), get_name(), gimplify_bind_expr(), gimplify_omp_for(), gimplify_parameters(), gimplify_vla_decl(), handle_simd_reference(), internal_get_tmp_var(), lower_omp_target(), lower_rec_input_clauses(), separate_decls_in_region_name(), take_address_of(), update_phi_components(), vect_create_addr_base_for_vector_ref(), vect_create_data_ref_ptr(), and vect_create_destination_var().

◆ get_narrower()

tree get_narrower	(	tree	op,
		int *	unsignedp_ptr )

extern

Return OP or a simpler expression for a narrower value
which can be sign-extended or zero-extended to give back OP.
Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
or 0 if the value should be sign-extended.

References build2_loc(), DECL_BIT_FIELD, DECL_SIZE, DECL_UNSIGNED, EXPR_LOCATION, fold_convert, FOR_EACH_VEC_ELT_REVERSE, get_narrower(), ggc_alloc(), i, INTEGRAL_TYPE_P, TREE_CODE, tree_fits_uhwi_p(), TREE_OPERAND, tree_to_uhwi(), TREE_TYPE, lang_hooks_for_types::type_for_size, TYPE_PRECISION, TYPE_UNSIGNED, and lang_hooks::types.

Referenced by get_narrower().

◆ get_nonnull_args()

bitmap get_nonnull_args ( const_tree fntype )

extern

Return a bitmap with a bit set corresponding to each argument in
a function call type FNTYPE declared with attribute nonnull,
or null if none of the function's argument are nonnull.  The caller
must free the bitmap.

References attrs, BITMAP_ALLOC, bitmap_clear(), bitmap_set_bit, ggc_alloc(), lookup_attribute(), NULL, NULL_TREE, TREE_CHAIN, TREE_CODE, TREE_INT_CST_LOW, TREE_VALUE, and TYPE_ATTRIBUTES.

Referenced by gimple_infer_range::gimple_infer_range(), and validate_arglist().

◆ get_qualified_type()

tree get_qualified_type	(	tree	type,
		int	type_quals )

extern

Return a version of the TYPE, qualified as indicated by the
TYPE_QUALS, if one exists.  If no qualified version exists yet,
return NULL_TREE.

References check_qualified_type(), ggc_alloc(), NULL_TREE, type(), TYPE_MAIN_VARIANT, TYPE_NEXT_VARIANT, and TYPE_QUALS.

Referenced by build_atomic_base(), build_qualified_type(), and modified_type_die().

◆ get_range_pos_neg()

int get_range_pos_neg ( tree arg )

extern

Return 1 if ARG interpreted as signed in its precision is known to be
always positive or 2 if ARG is known to be always negative, or 3 if
ARG may be positive or negative.

References CONVERT_EXPR_CODE_P, CONVERT_EXPR_P, error_mark_node, g, get_global_range_query(), ggc_alloc(), gimple_assign_rhs1(), gimple_assign_rhs_code(), INTEGRAL_TYPE_P, is_gimple_assign(), wi::neg_p(), r, wi::sext(), SIGNED, SSA_NAME_DEF_STMT, wi::to_wide(), TREE_CODE, TREE_OPERAND, TREE_TYPE, TYPE_PRECISION, and TYPE_UNSIGNED.

Referenced by expand_addsub_overflow(), expand_arith_overflow(), expand_expr_divmod(), expand_mul_overflow(), get_min_precision(), maybe_optimize_mod_cmp(), maybe_optimize_pow2p_mod_cmp(), and ubsan_expand_ptr_ifn().

◆ get_target_clone_attr_len()

int get_target_clone_attr_len ( tree arglist )

extern

Return length of attribute names string,
if arglist chain > 1, -1 otherwise.

References ggc_alloc(), TREE_CHAIN, TREE_STRING_POINTER, and TREE_VALUE.

Referenced by expand_target_clones().

◆ get_tree_code_name()

const char * get_tree_code_name ( enum tree_code code )

extern

Wrapper for tree_code_name to ensure that tree code is valid

References MAX_TREE_CODES, and tree_code_name.

Referenced by dequeue_and_dump(), DFS::DFS(), do_niy(), dump_binary_rhs(), dump_condition(), dump_generic_node(), dump_gimple_assign(), dump_gimple_cond(), dump_gimple_omp_for(), dump_ternary_rhs(), dump_tree_statistics(), dump_unary_rhs(), ipa_print_node_jump_functions_for_edge(), lto_tag_name(), lto_write_tree(), oacc_privatization_candidate_p(), expr_hash_elt::print(), print_lto_report(), print_node(), print_node_brief(), print_pre_expr(), print_vn_reference_ops(), split_at_bb_p(), vect_build_slp_tree_2(), vect_create_data_ref_ptr(), verify_gimple_assign_binary(), verify_gimple_assign_single(), verify_gimple_assign_ternary(), verify_gimple_assign_unary(), verify_types_in_gimple_reference(), and vn_nary_op_insert_pieces_predicated().

◆ get_type_static_bounds()

void get_type_static_bounds	(	const_tree	type,
		mpz_t	min,
		mpz_t	max )

extern

Stores bounds of an integer TYPE in MIN and MAX.  If TYPE has non-constant
bounds or is a POINTER_TYPE, the maximum and/or minimum values that can be
represented (assuming two's-complement arithmetic) within the bit
precision of the type are returned instead.

References ggc_alloc(), wi::max_value(), wi::min_value(), POINTER_TYPE_P, SIGNED, wi::to_mpz(), wi::to_wide(), TREE_CODE, TYPE_MAX_VALUE, TYPE_MIN_VALUE, TYPE_PRECISION, TYPE_SIGN, and TYPE_UNSIGNED.

Referenced by determine_value_range(), wi::from_mpz(), mpz_get_double_int(), and refine_value_range_using_guard().

◆ get_typenode_from_name()

tree get_typenode_from_name ( const char * name )

extern

Return a typenode for the "standard" C type with a given name.

References char_type_node, gcc_unreachable, ggc_alloc(), integer_type_node, long_integer_type_node, long_long_integer_type_node, long_long_unsigned_type_node, long_unsigned_type_node, NULL, NULL_TREE, short_integer_type_node, short_unsigned_type_node, signed_char_type_node, unsigned_char_type_node, and unsigned_type_node.

◆ get_ultimate_context()

const_tree get_ultimate_context ( const_tree decl )

extern

Returns the ultimate TRANSLATION_UNIT_DECL context of DECL or NULL.

References BLOCK_SUPERCONTEXT, get_containing_scope(), ggc_alloc(), and TREE_CODE.

Referenced by asan_add_global(), is_cxx(), and is_fortran().

◆ get_unwidened()

tree get_unwidened	(	tree	op,
		tree	for_type )

extern

Return EXP, stripped of any conversions to wider types
in such a way that the result of converting to type FOR_TYPE
is the same as if EXP were converted to FOR_TYPE.
If FOR_TYPE is 0, it signifies EXP's type.

Return OP, stripped of any conversions to wider types as much as is safe.
Converting the value back to OP's type makes a value equivalent to OP.

If FOR_TYPE is nonzero, we return a value which, if converted to
type FOR_TYPE, would be equivalent to converting OP to type FOR_TYPE.

OP must have integer, real or enumeral type.  Pointers are not allowed!

There are some cases where the obvious value we could return
would regenerate to OP if converted to OP's type,
but would not extend like OP to wider types.
If FOR_TYPE indicates such extension is contemplated, we eschew such values.
For example, if OP is (unsigned short)(signed char)-1,
we avoid returning (signed char)-1 if FOR_TYPE is int,
even though extending that to an unsigned short would regenerate OP,
since the result of extending (signed char)-1 to (int)
is different from (int) OP.

References CONVERT_EXPR_P, fold_convert, ggc_alloc(), MAX, wi::min_precision(), wi::to_wide(), TREE_CODE, TREE_OPERAND, TREE_TYPE, type(), lang_hooks_for_types::type_for_size, TYPE_PRECISION, TYPE_SIGN, TYPE_UNSIGNED, and lang_hooks::types.

Referenced by backtrace_base_for_ref(), canonicalize_component_ref(), and convert_to_integer_1().

◆ gimple_canonical_types_compatible_p()

bool gimple_canonical_types_compatible_p	(	const_tree	t1,
		const_tree	t2,
		bool	trust_type_canonical )

extern

Return true iff T1 and T2 are structurally identical for what
TBAA is concerned.  
This function is used both by lto.cc canonical type merging and by the
verifier.  If TRUST_TYPE_CANONICAL we do not look into structure of types
that have TYPE_CANONICAL defined and assume them equivalent.  This is useful
only for LTO because only in these cases TYPE_CANONICAL equivalence
correspond to one defined by gimple_canonical_types_compatible_p.

References canonical_type_used_p(), COMPLETE_TYPE_P, DECL_NONADDRESSABLE_P, DECL_SIZE, f1, f2, FIXED_POINT_TYPE_P, gcc_assert, gcc_checking_assert, ggc_alloc(), gimple_canonical_types_compatible_p(), gimple_compare_field_offset(), i1, i2, integer_zerop(), INTEGRAL_TYPE_P, NULL_TREE, odr_based_tbaa_p(), odr_type_p(), operand_equal_p(), POINTER_TYPE_P, SCALAR_FLOAT_TYPE_P, TREE_CHAIN, TREE_CODE, tree_code_for_canonical_type_merging(), TREE_TYPE, TREE_VALUE, TYPE_ADDR_SPACE, TYPE_ARG_TYPES, TYPE_CANONICAL, TYPE_DOMAIN, TYPE_FIELDS, TYPE_MAIN_VARIANT, TYPE_MAX_VALUE, TYPE_MIN_VALUE, TYPE_MODE, TYPE_NO_NAMED_ARGS_STDARG_P, TYPE_NONALIASED_COMPONENT, TYPE_PRECISION_RAW, TYPE_REVERSE_STORAGE_ORDER, TYPE_STRING_FLAG, TYPE_UNSIGNED, type_with_alias_set_p(), type_with_interoperable_signedness(), VECTOR_TYPE_P, and VOID_TYPE_P.

Referenced by gimple_canonical_types_compatible_p(), verify_type(), and verify_type_variant().

◆ grow_tree_vec()

tree grow_tree_vec	(	tree	v,
		int	CXX_MEM_STAT_INFO )

extern

Grow a TREE_VEC.

◆ gt_ggc_mx()

void gt_ggc_mx ( tree & )

extern

◆ gt_pch_nx() [1/2]

void gt_pch_nx ( tree & )

extern

◆ gt_pch_nx() [2/2]

void gt_pch_nx	(	tree &	,
		gt_pointer_operator	,
		void *	)

extern

◆ handled_component_p()

bool handled_component_p ( const_tree t )

inline

Return true if T is an expression that get_inner_reference handles.

References ggc_alloc(), and TREE_CODE.

Referenced by add_var_loc_to_decl(), addr_object_size(), aliasing_component_refs_p(), aliasing_component_refs_walk(), analyze_function_body(), ao_ref_base_alias_ptr_type(), ao_ref_base_alias_set(), array_ref_flexible_size_p(), avail_expr_hash(), ipcp_modif_dom_walker::before_dom_children(), build_reconstructed_reference(), build_simple_mem_ref_loc(), array_bounds_checker::check_addr_expr(), ao_compare::compare_ao_refs(), component_uses_parent_alias_set_from(), compute_reloc_for_constant(), cond_store_replacement(), constant_after_peeling(), contains_bitfld_component_ref_p(), contains_vce_or_bfcref_p(), contains_view_convert_expr_p(), convert_local_reference_op(), convert_nonlocal_reference_op(), create_access_replacement(), create_component_ref_by_pieces_1(), decl_refs_may_alias_p(), detect_type_change_from_memory_writes(), dr_analyze_indices(), dr_may_alias_p(), duplicate_insn_chain(), equal_mem_array_ref_p(), expand_assignment(), expand_debug_expr(), expand_DEFERRED_INIT(), expand_expr_real_1(), expr_with_var_bounded_array_refs_p(), find_func_clobbers(), find_interesting_uses_address(), fold_binary_loc(), fold_unary_loc(), forward_propagate_addr_expr_1(), get_base_address(), get_base_loadstore(), get_bit_range(), get_constraint_for_component_ref(), gimple_assign_load_p(), gimple_duplicate_bb(), gimplify_asm_expr(), gimplify_compound_lval(), gimplify_scan_omp_clauses(), indirect_ref_may_alias_decl_p(), indirect_refs_may_alias_p(), input_gimple_stmt(), interpret_rhs_expr(), is_gimple_address(), is_gimple_addressable(), load_from_unmodified_param_or_agg(), lower_omp_target(), mark_addressable(), maybe_canonicalize_mem_ref_addr(), symtab_node::maybe_create_reference(), maybe_fold_tmr(), maybe_instrument_pointer_overflow(), maybe_rewrite_mem_ref_base(), nonoverlapping_component_refs_p(), nonoverlapping_refs_since_match_p(), object_address_invariant_in_loop_p(), omp_find_stores_op(), output_addressed_constants(), output_gimple_stmt(), path_comparable_for_same_access(), prepare_decl_rtl(), prepare_gimple_addressable(), recompute_tree_invariant_for_addr_expr(), ref_contains_union_access_p(), ref_may_be_aliased(), reference_alias_ptr_type_1(), refs_may_alias_p_2(), requires_barrier(), self_reuse_distance(), set_mem_attributes_minus_bitpos(), slsr_process_ref(), stmt_kills_ref_p(), strip_invariant_refs(), take_address_of(), track_expr_p(), tree_invariant_p_1(), valid_gimple_rhs_p(), var_decl_component_p(), vect_copy_ref_info(), verify_address(), verify_gimple_assign_single(), verify_phi_args(), verify_types_in_gimple_reference(), visit_loadstore(), vn_reference_lookup_3(), walk_stmt_load_store_addr_ops(), and wrap_refs().

◆ id_equal() [1/2]

bool id_equal	(	const char *	str,
		const_tree	id )

inline

References id_equal().

◆ id_equal() [2/2]

bool id_equal	(	const_tree	id,
		const char *	str )

inline

True iff an identifier matches a C string.

References ggc_alloc(), and IDENTIFIER_POINTER.

Referenced by find_param_by_name(), fndecl_dealloc_argno(), gimple_call_return_array(), id_equal(), is_cxa_pure_virtual_p(), function_reader::parse_mem_expr(), and simd_clone_mangle().

◆ init_ttree()

void init_ttree ( void )

extern

Init tree.cc.

References cl_optimization_node, cl_option_hash_table, cl_target_option_node, hash_table< Descriptor, Lazy, Allocator >::create_ggc(), debug_expr_for_decl, ggc_alloc(), lang_hooks::init_ts, initialize_tree_contains_struct(), int_cst_hash_table, int_cst_node, make_int_cst(), make_node(), poly_int_cst_hash_table, TYPE_HASH_INITIAL_SIZE, type_hash_table, and value_expr_for_decl.

Referenced by general_init().

◆ initializer_each_zero_or_onep()

bool initializer_each_zero_or_onep ( const_tree expr )

extern

Return true if EXPR is an initializer expression in which every element
is a constant that is numerically equal to 0 or 1.  The elements do not
need to be equal to each other.

References ggc_alloc(), i, initializer_each_zero_or_onep(), integer_onep(), integer_zerop(), real_onep(), real_zerop(), STRIP_ANY_LOCATION_WRAPPER, TREE_CODE, TREE_TYPE, TYPE_VECTOR_SUBPARTS(), vector_cst_elt(), vector_cst_encoded_nelts(), and VECTOR_CST_STEPPED_P.

Referenced by initializer_each_zero_or_onep().

◆ initializer_zerop()

bool initializer_zerop	(	const_tree	init,
		bool *	nonzero )

extern

Given an initializer INIT, return TRUE if INIT is zero or some
aggregate of zeros.  Otherwise return FALSE.  If NONZERO is not
null, set *NONZERO if and only if INIT is known not to be all
zeros.  The combination of return value of false and *NONZERO
false implies that INIT may but need not be all zeros.  Other
combinations indicate definitive answers.

References CONSTRUCTOR_ELTS, fixed_zerop(), FOR_EACH_CONSTRUCTOR_VALUE, gcc_assert, ggc_alloc(), i, initializer_zerop(), INT_MAX, integer_zerop(), offset, REAL_VALUE_MINUS_ZERO, real_zerop(), STRIP_NOPS, TREE_CLOBBER_P, TREE_CODE, tree_fits_uhwi_p(), TREE_IMAGPART, TREE_OPERAND, TREE_REAL_CST, TREE_REALPART, TREE_STRING_LENGTH, TREE_STRING_POINTER, tree_to_uhwi(), VECTOR_CST_DUPLICATE_P, VECTOR_CST_ENCODED_ELT, and VECTOR_CST_NPATTERNS.

Referenced by all_zeros_p(), assemble_variable_contents(), bss_initializer_p(), categorize_ctor_elements_1(), categorize_decl_for_section(), const_vector_from_tree(), constant_byte_string(), dse_optimize_redundant_stores(), dse_optimize_stmt(), gimplify_init_ctor_eval(), strlen_pass::handle_store(), initializer_zerop(), lower_rec_input_clauses(), lower_vec_perm(), mostly_zeros_p(), scan_store_can_perm_p(), and store_constructor().

◆ inlined_function_outer_scope_p()

bool inlined_function_outer_scope_p ( const_tree block )

inline

Returns true if a BLOCK has a source location.
BLOCK_SOURCE_LOCATION is set only to inlined function entry points,
so the function returns true for all but the innermost and outermost
blocks into which an expression has been inlined.

References BLOCK_SOURCE_LOCATION, LOCATION_LOCUS, and UNKNOWN_LOCATION.

Referenced by clear_unused_block_pointer(), compute_discriminator(), expand_call_inline(), autofdo::get_function_decl_from_block(), input_function(), pack_ts_block_value_fields(), and remove_unused_scope_block_p().

◆ int_bit_position()

HOST_WIDE_INT int_bit_position ( const_tree field )

inline

Like bit_position, but return as an integer.  It must be representable in
that way (since it could be a signed value, we don't have the
option of returning -1 like int_size_in_byte can.

References DECL_FIELD_BIT_OFFSET, DECL_FIELD_OFFSET, ggc_alloc(), and wi::to_offset().

Referenced by build_ref_for_model(), find_constructor_constant_at_offset(), get_binfo_at_offset(), ipa_get_stmt_member_ptr_load_param(), output_constructor_bitfield(), record_targets_from_bases(), ipa_polymorphic_call_context::restrict_to_inner_class(), store_constructor(), totally_scalarizable_type_p(), totally_scalarize_subtree(), and type_internals_preclude_sra_p_1().

◆ int_byte_position()

HOST_WIDE_INT int_byte_position ( const_tree field )

extern

Likewise, but return as an integer.  It must be representable in
that way (since it could be a signed value, we don't have the
option of returning -1 like int_size_in_byte can.

References byte_position(), and tree_to_shwi().

Referenced by clear_padding_type(), field_at_offset(), loc_list_from_tree_1(), native_encode_initializer(), native_interpret_aggregate(), and output_constructor_regular_field().

◆ int_cst_value()

HOST_WIDE_INT int_cst_value ( const_tree x )

extern

Return value of a constant X and sign-extend it.

References cst_and_fits_in_hwi(), gcc_assert, ggc_alloc(), HOST_BITS_PER_WIDE_INT, HOST_WIDE_INT_M1U, TREE_INT_CST_LOW, TREE_TYPE, and TYPE_PRECISION.

Referenced by add_autoinc_candidates(), add_multivariate_self_dist(), adjust_nested_loop_clauses(), analyze_subscript_affine_affine(), build_classic_dist_vector_1(), classify_builtin_st(), compute_overlap_steps_for_affine_1_2(), dump_mem_details(), expand_vec_cond_optab_fn(), find_or_create_group(), force_expr_to_var_cost(), gen_generic_params_dies(), get_misalign_in_elems(), get_shiftadd_cost(), idx_analyze_ref(), infer_loop_bounds_from_pointer_arith(), initialize_matrix_A(), inverse(), issue_prefetch_ref(), iv_elimination_compare_lt(), prune_ref_by_group_reuse(), prune_ref_by_self_reuse(), ptr_difference_const(), ptrdiff_tree_p(), record_group_use(), should_issue_prefetch_p(), strip_offset_1(), vect_gen_prolog_loop_niters(), and vector_alignment_reachable_p().

◆ int_fits_type_p()

bool int_fits_type_p	(	const_tree	c,
		const_tree	type )

extern

Return true if integer constant C has a value that is permissible
for TYPE, an integral type.

References wi::fits_to_boolean_p(), wi::fits_to_tree_p(), GET_MODE_PRECISION(), ggc_alloc(), wi::neg_p(), SCALAR_INT_TYPE_MODE, SIGNED, wi::to_wide(), TREE_CODE, tree_int_cst_lt(), TREE_TYPE, TYPE_MAX_VALUE, TYPE_MIN_VALUE, TYPE_PRECISION, TYPE_SIGN, TYPE_UNSIGNED, UNSIGNED, and wi::zext().

Referenced by chrec_apply(), chrec_convert_1(), edge_info::derive_equivalences(), early_object_sizes_execute_one(), expand_case(), expand_expr_real_2(), factor_out_conditional_operation(), fold_builtin_object_size(), idx_infer_loop_bounds(), is_widening_mult_p(), make_range_step(), vn_walk_cb_data::push_partial_def(), simplify_using_ranges::simplify_casted_compare(), simplify_gimple_switch(), vect_recog_mixed_size_cond_pattern(), and vn_reference_lookup_3().

◆ int_size_in_bytes()

HOST_WIDE_INT int_size_in_bytes ( const_tree type )

extern

Return the size of TYPE (in bytes) as a wide integer
or return -1 if the size can vary or is larger than an integer.

References error_mark_node, tree_fits_uhwi_p(), TREE_INT_CST_LOW, TYPE_MAIN_VARIANT, and TYPE_SIZE_UNIT.

Referenced by add_decls_addresses_to_decl_constructor(), nontrapping_dom_walker::add_or_mark_expr(), analyze_ref(), arg_int_size_in_bytes(), array_elt_at_offset(), assign_parm_adjust_entry_rtl(), assign_parm_setup_block(), assign_parm_setup_stack(), assign_parms(), assign_parms_unsplit_complex(), base_type_die(), clear_padding_type(), clear_type_padding_in_mask(), compare_constant(), const_hash_1(), constant_byte_string(), copy_blkmode_from_reg(), default_function_arg_padding(), dw_loc_list_1(), ipa_icf::sem_variable::equals(), estimate_move_cost(), expand_assignment(), expand_call(), expand_expr_real_1(), expand_function_end(), expand_function_start(), expand_omp_atomic_cas(), expand_omp_atomic_pipeline(), expand_value_return(), finalize_must_preallocate(), flexible_array_member_p(), fold_builtin_atomic_compare_exchange(), fold_view_convert_expr(), get_constant_size(), get_mem_ref_of_assignment(), gimple_fold_builtin_clear_padding(), gimplify_init_constructor(), go_output_typedef(), strlen_pass::handle_store(), has_stmt_been_instrumented_p(), initialize_argument_information(), instrument_derefs(), instrument_expr(), instrument_object_size(), is_handled_procedure_type(), load_register_parameters(), loc_list_for_address_of_addr_expr_of_indirect_ref(), loc_list_from_tree_1(), maybe_emit_group_store(), mergeable_string_section(), must_pass_in_stack_var_size_or_pad(), native_encode_initializer(), native_interpret_aggregate(), offset_within_block_p(), omp_shared_to_firstprivate_optimizable_decl_p(), operand_compare::operand_equal_p(), optimize_atomic_compare_exchange_p(), output_constant(), output_constructor_array_range(), output_constructor_regular_field(), precompute_register_parameters(), function_arg_info::promoted_size_in_bytes(), rtx_addr_can_trap_p_1(), sjlj_build_landing_pads(), split_constant_offset_1(), store_constructor(), store_expr(), store_field(), store_one_arg(), store_unaligned_arguments_into_pseudos(), subrange_type_die(), subrange_type_for_debug_p(), tree_add_const_value_attribute(), and function_arg_info::type_size_in_bytes().

◆ integer_all_onesp()

bool integer_all_onesp ( const_tree expr )

extern

integer_all_onesp (tree x) is nonzero if X is an integer constant
all of whose significant bits are 1.

Return true if EXPR is an integer containing all 1's in as much precision
as it contains, or a complex or vector whose subparts are such integers,
or a location wrapper for such a constant.

References ggc_alloc(), integer_all_onesp(), wi::max_value(), STRIP_ANY_LOCATION_WRAPPER, wi::to_wide(), TREE_CODE, TREE_IMAGPART, TREE_REALPART, TREE_TYPE, TYPE_PRECISION, UNSIGNED, VECTOR_CST_DUPLICATE_P, VECTOR_CST_ENCODED_ELT, and VECTOR_CST_NPATTERNS.

Referenced by absorbing_element_p(), check_access(), chrec_apply(), component_ref_sam_type(), convert_to_integer_1(), do_store_flag(), eliminate_using_constants(), expand_builtin_memory_chk(), expand_vector_condition(), fold_ternary_loc(), strlen_pass::get_len_or_size(), get_maxval_strlen(), get_range_strlen(), get_range_strlen_phi(), get_range_strlen_tree(), gimple_fold_builtin_memory_chk(), gimple_fold_builtin_snprintf_chk(), gimple_fold_builtin_sprintf_chk(), gimple_fold_builtin_strcat_chk(), gimple_fold_builtin_strncat_chk(), gimple_fold_builtin_stxcpy_chk(), gimple_fold_builtin_stxncpy_chk(), gimple_fold_call(), gimple_fold_partial_load_store_mem_ref(), integer_all_onesp(), integer_minus_onep(), integer_truep(), maybe_diag_stxncpy_trunc(), maybe_emit_sprintf_chk_warning(), maybe_trim_memstar_call(), maybe_warn_nonstring_arg(), neutral_element_p(), number_of_iterations_lt(), optimize_range_tests_cmp_bitwise(), ovce_extract_ops(), size_initval_p(), size_unknown_p(), tree_predict_by_opcode(), ubsan_expand_objsize_ifn(), and visit_nary_op().

◆ integer_each_onep()

bool integer_each_onep ( const_tree expr )

extern

integer_onep (tree x) is nonzero if X is an integer constant of value 1, or
a vector or complex where each part is 1.

Return true if EXPR is the integer constant one.  For complex and vector,
return true if every piece is the integer constant one.
Also return true for location wrappers for such a constant.

References ggc_alloc(), integer_onep(), STRIP_ANY_LOCATION_WRAPPER, TREE_CODE, TREE_IMAGPART, and TREE_REALPART.

◆ integer_minus_onep()

bool integer_minus_onep ( const_tree expr )

extern

integer_minus_onep (tree x) is nonzero if X is an integer constant of
value -1.

Return true if EXPR is the integer constant minus one, or a location
wrapper for such a constant.

References ggc_alloc(), integer_all_onesp(), integer_zerop(), STRIP_ANY_LOCATION_WRAPPER, TREE_CODE, TREE_IMAGPART, and TREE_REALPART.

Referenced by bb_no_side_effects_p(), cache_integer_cst(), const_vector_mask_from_tree(), do_warn_nonnull_compare(), execute_oacc_device_lower(), execute_omp_oacc_neuter_broadcast(), expand_omp_ordered_sink(), extract_muldiv_1(), gimple_expand_vec_cond_expr(), is_empty_type(), lower_oacc_head_mark(), oacc_xform_loop(), omp_adjust_for_condition(), reassociate_bb(), spaceship_replacement(), ssa_defined_by_minus_one_stmt_p(), try_transform_to_exit_first_loop_alt(), and zero_one_operation().

◆ integer_nonzerop()

bool integer_nonzerop ( const_tree expr )

extern

integer_nonzerop (tree x) is nonzero if X is an integer constant
with a nonzero value.

Return true if EXPR is an integer constant other than zero or a
complex constant other than zero, or a location wrapper for such a
constant.

References ggc_alloc(), integer_nonzerop(), STRIP_ANY_LOCATION_WRAPPER, wi::to_wide(), TREE_CODE, TREE_IMAGPART, and TREE_REALPART.

◆ integer_onep()

bool integer_onep ( const_tree expr )

extern

integer_onep (tree x) is nonzero if X is an integer constant of value 1.

Return true if EXPR is the integer constant one or the corresponding
complex constant, or a location wrapper for such a constant.

References wi::eq_p(), ggc_alloc(), integer_onep(), integer_zerop(), STRIP_ANY_LOCATION_WRAPPER, wi::to_widest(), TREE_CODE, TREE_IMAGPART, TREE_REALPART, VECTOR_CST_DUPLICATE_P, VECTOR_CST_ENCODED_ELT, and VECTOR_CST_NPATTERNS.

Referenced by addr_for_mem_ref(), adjust_accumulator_values(), strlen_pass::adjust_last_stmt(), adjust_simduid_builtins(), autofdo::afdo_propagate_circuit(), and_comparisons_1(), and_var_with_comparison_1(), associate_equivalences_with_edges(), backtrace_base_for_ref(), build_range_check(), cache_integer_cst(), cand_value_at(), canonicalize_cond_expr_cond(), chrec_fold_multiply(), compare_values_warnv(), compute_invariantness(), const_vector_mask_from_tree(), constant_byte_string(), convert_to_fixed(), create_mem_ref(), create_mul_imm_cand(), create_mul_ssa_cand(), edge_info::derive_equivalences(), do_jump(), do_store_flag(), edge_forwards_cmp_to_conditional_jump_through_empty_bb_p(), eliminate_using_constants(), evaluate_conditions_for_known_args(), expand_expr_real_1(), expand_gimple_cond(), expand_ifn_atomic_bit_test_and(), expand_oacc_collapse_init(), 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_ordered_source_sink(), expand_omp_simd(), find_case_label_range(), fold_binary_loc(), fold_builtin_atomic_compare_exchange(), fold_comparison(), fold_negate_expr_1(), fold_stmt_1(), fold_ternary_loc(), fold_to_nonsharp_ineq_using_bound(), fold_truth_andor_1(), fold_truth_not_expr(), forward_propagate_into_gimple_cond(), get_stridx(), gimple_fold_call(), gimple_fold_stmt_to_constant_1(), gimplify_bind_expr(), strlen_pass::handle_builtin_memcpy(), init_range_entry(), initializer_each_zero_or_onep(), integer_each_onep(), integer_onep(), integer_truep(), ipa_analyze_indirect_call_uses(), is_lshift_by_1(), is_rshift_by_1(), is_true_predicate(), iv_elimination_compare_lt(), lower_rec_input_clauses(), make_range(), match_single_bit_test(), maybe_optimize_guarding_check(), maybe_optimize_range_tests(), merge_ranges(), negate_expr_p(), neutral_element_p(), number_of_iterations_lt(), number_of_iterations_ne(), number_of_iterations_ne_max(), number_of_iterations_until_wrap(), oacc_xform_loop(), omp_adjust_for_condition(), simplify_using_ranges::op_with_boolean_value_range_p(), optimize_atomic_bit_test_and(), optimize_atomic_compare_exchange_p(), optimize_range_tests_1(), optimize_range_tests_var_bound(), dom_opt_dom_walker::optimize_stmt(), or_comparisons_1(), or_var_with_comparison_1(), predict_extra_loop_exits(), range_entry_cmp(), recognize_single_bit_test(), record_control_iv(), record_edge_info(), remove_redundant_iv_tests(), return_prediction(), scan_sharing_clauses(), avail_exprs_stack::simplify_binary_operation(), simplify_using_ranges::simplify_div_or_mod_using_ranges(), size_binop_loc(), slsr_process_phi(), spaceship_replacement(), split_loop(), suitable_cond_bb(), dom_opt_dom_walker::test_for_singularity(), loop_distribution::transform_reduction_loop(), tree_predict_by_opcode(), update_range_test(), vect_analyze_loop(), vect_analyze_loop_form(), vect_create_constant_vectors(), vect_create_loop_vinfo(), vect_do_peeling(), vect_recog_average_pattern(), vect_recog_mulhs_pattern(), vect_set_loop_condition_normal(), vect_transform_loop(), and vectorizable_reduction().

◆ integer_pow2p()

bool integer_pow2p ( const_tree expr )

extern

integer_pow2p (tree x) is nonzero is X is an integer constant with
exactly one bit 1.

Return true if EXPR is an integer constant that is a power of 2 (i.e., has
only one bit on), or a location wrapper for such a constant.

References ggc_alloc(), integer_pow2p(), integer_zerop(), wi::popcount(), STRIP_ANY_LOCATION_WRAPPER, wi::to_wide(), TREE_CODE, TREE_IMAGPART, and TREE_REALPART.

Referenced by divmod_candidate_p(), do_store_flag(), expand_mul_overflow(), expand_vector_divmod(), expression_expensive_p(), fold_binary_loc(), fold_ternary_loc(), fold_truth_andor_1(), force_expr_to_var_cost(), get_debug_computation_at(), integer_pow2p(), maybe_optimize_mod_cmp(), multiple_of_p(), number_of_iterations_cltz(), optimize_range_tests_diff(), optimize_range_tests_xor(), recognize_single_bit_test(), simplify_using_ranges::simplify_div_or_mod_using_ranges(), and vect_recog_divmod_pattern().

◆ integer_truep()

bool integer_truep ( const_tree expr )

extern

integer_truep (tree x) is nonzero if X is an integer constant of value 1 or
a vector where each element is an integer constant of value -1.

Return true if EXPR is the integer constant one.  For vector,
return true if every piece is the integer constant minus one
(representing the value TRUE).
Also return true for location wrappers for such a constant.

References ggc_alloc(), integer_all_onesp(), integer_onep(), STRIP_ANY_LOCATION_WRAPPER, and TREE_CODE.

Referenced by can_interpret_as_conditional_op_p(), convert_mult_to_fma(), simplify_1b(), and visit_phi().

◆ integer_zerop()

bool integer_zerop ( const_tree expr )

extern

integer_zerop (tree x) is nonzero if X is an integer constant of value 0.

Return true if EXPR is the integer constant zero or a complex constant
of zero, or a location wrapper for such a constant.

References ggc_alloc(), integer_zerop(), STRIP_ANY_LOCATION_WRAPPER, wi::to_wide(), TREE_CODE, TREE_IMAGPART, TREE_REALPART, VECTOR_CST_DUPLICATE_P, VECTOR_CST_ENCODED_ELT, and VECTOR_CST_NPATTERNS.

◆ internal_fn_p()

bool internal_fn_p ( combined_fn code )

inline

Return true if CODE is an internal function.

References END_BUILTINS.

Referenced by as_internal_fn(), associated_internal_fn(), convert_conditional_op(), gimple_build(), gimple_build(), gimple_build(), gimple_build(), is_copysign_call_with_1(), code_helper::is_internal_fn(), maybe_build_call_expr_loc(), maybe_push_res_to_seq(), vect_build_slp_tree_1(), vectorizable_call(), vectorizable_internal_function(), and widening_fn_p().

◆ is_empty_type()

bool is_empty_type ( const_tree type )

extern

Returns true if TYPE is a type where it and all of its subobjects
(recursively) are of structure, union, or array type.

References array_type_nelts(), DECL_CHAIN, DECL_PADDING_P, ggc_alloc(), integer_minus_onep(), is_empty_type(), NULL_TREE, RECORD_OR_UNION_TYPE_P, TREE_CODE, TREE_TYPE, TYPE_DOMAIN, and TYPE_FIELDS.

Referenced by clear_padding_type(), default_is_empty_record(), find_tail_calls(), gimplify_expr(), gimplify_init_constructor(), gimplify_init_ctor_eval(), gimplify_modify_expr(), is_empty_type(), is_var_need_auto_init(), maybe_warn_operand(), native_interpret_aggregate(), and setup_one_parameter().

◆ is_global_var()

bool is_global_var ( const_tree t )

inline

Return true if T (assumed to be a DECL) is a global variable.
A variable is considered global if its storage is not automatic.

References DECL_EXTERNAL, and TREE_STATIC.

Referenced by address_compare(), assumption_copy_decl(), build_outer_var_ref(), call_may_clobber_ref_p_1(), computable_teams_clause(), copy_debug_stmt(), create_variable_info_for_1(), decl_maybe_in_construction_p(), declare_return_variable(), dump_variable(), eliminate_dom_walker::eliminate_stmt(), expand_debug_expr(), expand_expr_addr_expr_1(), expand_one_var(), find_local_vars_to_propagate(), finish_taskreg_scan(), gimplify_adjust_omp_clauses(), gimplify_adjust_omp_clauses_1(), gimplify_bind_expr(), gimplify_oacc_declare(), gimplify_omp_for(), gimplify_scan_omp_clauses(), handle_lhs_call(), instrument_derefs(), instrument_expr(), instrument_object_size(), ipa_compute_jump_functions_for_edge(), ipa_find_agg_cst_from_init(), is_addr_local(), local_var_based_p(), lookup_decl_in_outer_ctx(), lower_assumption(), lower_lastprivate_clauses(), lower_omp_target(), lower_rec_input_clauses(), lower_send_clauses(), mark_all_vars_used_1(), maybe_add_sra_candidate(), maybe_instrument_pointer_overflow(), maybe_optimize_ubsan_ptr_ifn(), maybe_optimize_var(), maybe_warn_operand(), mem_dies_at_call(), move_stmt_op(), movement_possibility_1(), needs_to_live_in_memory(), new_var_info(), note_no_context_vars(), oacc_default_clause(), omp_check_private(), omp_copy_decl(), omp_default_clause(), omp_discover_declare_target_var_r(), omp_notice_variable(), optimize_va_list_gpr_fpr_size(), pt_solution_includes_1(), pt_solution_set_var(), ref_may_alias_global_p_1(), ref_maybe_used_by_call_p_1(), ref_maybe_used_by_stmt_p(), remove_dead_stmt(), remove_unused_locals(), requires_barrier(), scan_sharing_clauses(), set_mem_attributes_minus_bitpos(), use_pointer_for_field(), and visit_loadstore().

◆ is_lang_specific()

bool is_lang_specific ( const_tree t )

inline

Return true if tree node T is a language-specific node.

References ggc_alloc(), NUM_TREE_CODES, and TREE_CODE.

Referenced by lto_is_streamable(), and verify_type().

◆ is_truth_type_for()

bool is_truth_type_for	(	tree	type,
		tree	truth_type )

extern

- For VECTOR_TYPEs:
 - The truth type must be a VECTOR_BOOLEAN_TYPE.
 - The number of elements must match (known_eq).
 - targetm.vectorize.get_mask_mode exists, and exactly
   the same mode as the truth type.
- Otherwise, the truth type must be a BOOLEAN_TYPE
  or useless_type_conversion_p to BOOLEAN_TYPE.

References boolean_type_node, ggc_alloc(), known_eq, targetm, TREE_CODE, TYPE_MODE, TYPE_VECTOR_SUBPARTS(), useless_type_conversion_p(), and VECTOR_BOOLEAN_TYPE_P.

Referenced by fold_binary_loc().

◆ is_typedef_decl()

bool is_typedef_decl ( const_tree x )

inline

Returns true if X is a typedef decl.

References DECL_ORIGINAL_TYPE, NULL_TREE, and TREE_CODE.

Referenced by typedef_variant_p().

◆ iterative_hash_expr()

hashval_t iterative_hash_expr	(	const_tree	tree,
		hashval_t	seed )

inline

Compat version until all callers are converted. Return hash for
TREE with SEED.

References inchash::add_expr(), and ggc_alloc().

Referenced by gather_mem_refs_stmt(), get_loop_invariant_expr(), asan_mem_ref_hasher::hash(), cand_chain_hasher::hash(), gimplify_hasher::hash(), log_entry_hasher::hash(), tm_memop_hasher::hash(), tree_operand_hash::hash(), innermost_loop_behavior_hash::hash(), vect_scalar_ops_slice_hash::hash(), make_forwarders_with_degenerate_phis(), and record_common_cand().

◆ last_field()

tree last_field ( const_tree type )

extern

Returns the last FIELD_DECL in the TYPE_FIELDS of the RECORD_TYPE or
UNION_TYPE TYPE, or NULL_TREE if none.

References ggc_alloc(), last, NULL_TREE, TREE_CHAIN, TREE_CODE, and TYPE_FIELDS.

Referenced by array_ref_flexible_size_p(), and decl_init_size().

◆ lhd_gcc_personality()

tree lhd_gcc_personality ( void )

extern

Return the GCC personality function decl.

References build_personality_function(), and gcc_eh_personality_decl.

◆ list_length()

int list_length ( const_tree t )

extern

Returns the length of a chain of nodes
(number of chain pointers to follow before reaching a null pointer).

Return the length of a chain of nodes chained through TREE_CHAIN.
We expect a null pointer to mark the end of the chain.
This is the Lisp primitive `length'.

References gcc_assert, and TREE_CHAIN.

Referenced by build_constructor_from_list(), can_strub_internally_p(), decl_attributes(), expand_call(), function_to_dwarf_procedure(), gimplify_asm_expr(), gimplify_omp_for(), global_decl_processing(), merge_attributes(), omp_construct_selector_matches(), omp_context_compute_score(), omp_context_selector_compare(), omp_context_selector_matches(), omp_context_selector_set_compare(), omp_extract_for_data(), and prepare_call_arguments().

◆ location_wrapper_p()

bool location_wrapper_p ( const_tree exp )

inline

Test if EXP is merely a wrapper node, added to express a location_t
on behalf of the node's child (e.g. by maybe_wrap_with_location).

References exp(), EXPR_LOCATION_WRAPPER_P, ggc_alloc(), and TREE_CODE.

Referenced by preserve_any_location_wrapper(), simple_cst_equal(), tree_nop_conversion(), and tree_strip_any_location_wrapper().

◆ lower_bound_in_type()

tree lower_bound_in_type	(	tree	outer,
		tree	inner )

extern

Returns the smallest value obtainable by casting something in INNER type to
OUTER type.

References build_int_cst(), ggc_alloc(), wi::mask(), TYPE_PRECISION, TYPE_UNSIGNED, and wide_int_to_tree().

Referenced by derive_simple_iv_with_niters(), determine_exit_conditions(), infer_loop_bounds_from_pointer_arith(), infer_loop_bounds_from_signedness(), loop_exits_before_overflow(), and scev_var_range_cant_overflow().

◆ make_anon_name()

tree make_anon_name ( )

extern

For anonymous aggregate types, we need some sort of name to
hold on to.  In practice, this should not appear, but it should
not be harmful if it does.  Identifiers returned will be
IDENTIFIER_ANON_P.

Create a unique anonymous identifier.  The identifier is still a
valid assembly label.

References anon_cnt, gcc_checking_assert, get_identifier_with_length(), ggc_alloc(), and IDENTIFIER_ANON_P.

◆ make_int_cst()

tree make_int_cst	(	int	,
		int	CXX_MEM_STAT_INFO )

extern

Make an INTEGER_CST.

◆ make_node()

tree make_node ( enum tree_code CXX_MEM_STAT_INFO )

extern

Lowest level primitive for allocating a node.
The TREE_CODE is the only argument.  Contents are initialized
to zero except for a few of the common fields.

◆ make_tree()

tree make_tree	(	tree	type,
		rtx	x )

extern

From expmed.cc.  Since rtl.h is included after tree.h, we can't
put the prototype here.  Rtl.h does declare the prototype if
tree.h had been included.

Return a tree node with data type TYPE, describing the value of X.
Usually this is an VAR_DECL, if there is no obvious better choice.
X may be an expression, however we only support those expressions
generated by loop.c.

References tree_vector_builder::build(), build2(), build_decl(), build_fold_addr_expr, build_real(), CONST_DOUBLE_LOW, CONST_DOUBLE_REAL_VALUE, CONST_POLY_INT_P, const_poly_int_value(), CONST_VECTOR_ELT, CONST_VECTOR_NELTS_PER_PATTERN, CONST_VECTOR_NPATTERNS, convert_memory_address_addr_space(), count, vector_builder< T, Shape, Derived >::encoded_nelts(), fold_build1, fold_build2, fold_convert, wide_int_storage::from_array(), GET_CODE, GET_MODE, ggc_alloc(), HOST_BITS_PER_WIDE_INT, i, make_tree(), NULL_TREE, POINTER_TYPE_P, RTL_LOCATION, SCALAR_INT_TYPE_MODE, signed_type_for(), STATIC_ASSERT, SYMBOL_REF_DECL, TARGET_SUPPORTS_WIDE_INT, TREE_CODE, TREE_TYPE, type(), TYPE_ADDR_SPACE, lang_hooks_for_types::type_for_mode, TYPE_MODE, lang_hooks::types, unsigned_type_for(), wide_int_to_tree(), and XEXP.

Referenced by assign_parm_setup_reg(), emit_block_op_via_libcall(), expand_asm_stmt(), expand_builtin_cexpi(), expand_call(), expand_DIVMOD(), expand_doubleword_mod(), expand_ifn_atomic_bit_test_and(), expand_ifn_atomic_compare_exchange_into_call(), expand_mul_overflow(), expand_sjlj_dispatch_table(), expand_vector_ubsan_overflow(), initialize_argument_information(), make_tree(), maybe_optimize_mod_cmp(), maybe_optimize_pow2p_mod_cmp(), set_storage_via_libcall(), sjlj_emit_function_enter(), and store_expr().

◆ make_tree_binfo()

tree make_tree_binfo ( unsigned CXX_MEM_STAT_INFO )

extern

Make a BINFO.

◆ make_tree_vec()

tree make_tree_vec ( int CXX_MEM_STAT_INFO )

extern

Make a TREE_VEC.

◆ make_vector()

tree make_vector	(	unsigned	,
		unsigned	CXX_MEM_STAT_INFO )

extern

◆ max_int_size_in_bytes()

HOST_WIDE_INT max_int_size_in_bytes ( const_tree type )

extern

Return the maximum size of TYPE (in bytes) as a wide integer
or return -1 if the size can vary or is larger than an integer.

References ggc_alloc(), lang_hooks_for_types::max_size, TREE_CODE, tree_fits_uhwi_p(), tree_to_uhwi(), TYPE_ARRAY_MAX_SIZE, and lang_hooks::types.

Referenced by assign_temp(), expand_asm_stmt(), force_constant_size(), gimplify_parameters(), gimplify_vla_decl(), and initialize_argument_information().

◆ max_object_size()

tree max_object_size ( void )

extern

Return the maximum object size.

References ptrdiff_type_node, and TYPE_MAX_VALUE.

Referenced by alloca_call_type(), check_access(), access_ref::dump(), pass_walloca::execute(), strlen_pass::get_len_or_size(), access_ref::get_ref(), get_size_range(), gimple_fold_builtin_strlen(), handle_ssa_name(), maybe_warn_for_bound(), maybe_warn_nonstring_arg(), strlen_pass::maybe_warn_overflow(), access_ref::merge_ref(), access_ref::set_max_size_range(), access_ref::size_remaining(), and warn_string_no_nul().

◆ may_be_aliased()

bool may_be_aliased ( const_tree var )

inline

Return true if VAR may be aliased.  A variable is considered as
maybe aliased if it has its address taken by the local TU
or possibly by another TU and might be modified through a pointer.

References DECL_EXTERNAL, DECL_NONALIASED, ggc_alloc(), TREE_ADDRESSABLE, TREE_CODE, TREE_PUBLIC, TREE_READONLY, and TREE_STATIC.

Referenced by call_may_clobber_ref_p_1(), can_escape(), dump_alias_info(), find_tail_calls(), instrument_expr(), mem_dies_at_call(), ptr_deref_may_alias_decl_p(), ref_may_be_aliased(), and ref_maybe_used_by_call_p_1().

◆ maybe_build_call_expr_loc()

tree maybe_build_call_expr_loc	(	location_t	loc,
		combined_fn	fn,
		tree	type,
		int	n,
			... )

extern

Return a function call to FN, if the target is guaranteed to support it,
or null otherwise.

N is the number of arguments, passed in the "...", and TYPE is the
type of the return value.

References ap, as_builtin_fn(), as_internal_fn(), build_call_expr_internal_loc_array(), build_call_expr_loc_array(), builtin_decl_implicit(), direct_internal_fn_p(), direct_internal_fn_supported_p(), direct_internal_fn_types(), ggc_alloc(), i, internal_fn_p(), NULL_TREE, and OPTIMIZE_FOR_BOTH.

◆ maybe_special_function_p()

bool maybe_special_function_p ( const_tree fndecl )

inline

Determine if the function identified by FNDECL is one that
makes sense to match by name, for those places where we detect
"magic" functions by name.

Return true if FNDECL has a name and is an extern fndecl at file scope.
FNDECL must be a non-NULL decl.

Avoid using this, as it's generally better to use attributes rather
than to check for functions by name.

References DECL_CONTEXT, DECL_NAME, ggc_alloc(), NULL_TREE, TREE_CODE, and TREE_PUBLIC.

Referenced by special_function_p().

◆ maybe_wrap_with_location()

WARN_UNUSED_RESULT tree maybe_wrap_with_location	(	tree	expr,
		location_t	loc )

extern

Return EXPR, potentially wrapped with a node expression LOC,
if !CAN_HAVE_LOCATION_P (expr).

NON_LVALUE_EXPR is used for wrapping constants, apart from STRING_CST.
VIEW_CONVERT_EXPR is used for wrapping non-constants and STRING_CST.

Wrapper nodes can be identified using location_wrapper_p.

References build1_loc(), CAN_HAVE_LOCATION_P, CONSTANT_CLASS_P, DECL_ARTIFICIAL, DECL_IGNORED_P, DECL_P, error_operand_p(), EXCEPTIONAL_CLASS_P, expr, EXPR_LOCATION_WRAPPER_P, gcc_assert, ggc_alloc(), NULL, suppress_location_wrappers, TREE_CODE, TREE_STATIC, TREE_TYPE, and UNKNOWN_LOCATION.

Referenced by preserve_any_location_wrapper().

◆ more_call_expr_args_p()

bool more_call_expr_args_p ( const call_expr_arg_iterator * iter )

inline

Test whether there are more arguments in abstract argument list iterator
ITER, without changing its state.

Referenced by dump_generic_node(), and print_node().

◆ needs_to_live_in_memory()

bool needs_to_live_in_memory ( const_tree t )

extern

Return true if T (assumed to be a DECL) must be assigned a memory
location.

References aggregate_value_p(), current_function_decl, DECL_BY_REFERENCE, ggc_alloc(), is_global_var(), TREE_ADDRESSABLE, and TREE_CODE.

Referenced by gimplify_modify_expr_rhs(), gimplify_target_expr(), is_gimple_reg(), and requires_barrier().

◆ nonnull_arg_p()

bool nonnull_arg_p ( const_tree arg )

extern

Return true if ARG is marked with the nonnull attribute in the
current function signature.

References attrs, cfun, compare_tree_int(), DECL_ARGUMENTS, DECL_CHAIN, gcc_assert, ggc_alloc(), lookup_attribute(), NULL_TREE, POINTER_TYPE_P, TREE_CHAIN, TREE_CODE, TREE_TYPE, TREE_VALUE, and TYPE_ATTRIBUTES.

Referenced by do_warn_nonnull_compare(), gimple_range_global(), and VN_INFO().

◆ nreverse()

tree nreverse ( tree t )

extern

Reverse the order of elements in a chain, and return the new head.

Reverse the order of elements in the chain T,
and return the new head of the chain (old last element).

References gcc_checking_assert, ggc_alloc(), TREE_CHAIN, and TREE_CODE.

Referenced by build_adjusted_function_type(), build_function_type_list_1(), rt_bb_visited::check(), declare_vars(), fixup_child_record_type(), init_attr_rdwr_indices(), initialize_inlined_parameters(), layout_type(), maybe_canonicalize_argtypes(), omp_oacc_kernels_decompose_1(), remap_decls(), remap_type_1(), scan_omp_target(), self_referential_size(), simd_clone_adjust_argument_types(), and task_copyfn_remap_type().

◆ num_ending_zeros()

tree num_ending_zeros ( const_tree x )

extern

Returns number of zeros at the end of binary representation of X.

References build_int_cst(), wi::ctz(), wi::to_wide(), and TREE_TYPE.

Referenced by iv_period(), and number_of_iterations_ne().

◆ obj_type_ref_class()

tree obj_type_ref_class	(	const_tree	ref,
		bool	for_dump_p )

extern

REF is OBJ_TYPE_REF, return the class the ref corresponds to.
FOR_DUMP_P is true when being called from the dump routines.

References gcc_assert, gcc_checking_assert, get_odr_type(), ggc_alloc(), TREE_CODE, TREE_TYPE, TREE_VALUE, TYPE_ARG_TYPES, TYPE_CANONICAL, and TYPE_STRUCTURAL_EQUALITY_P.

Referenced by cgraph_node::create_indirect_edge(), dump_generic_node(), eliminate_dom_walker::eliminate_stmt(), operand_compare::hash_operand(), ipa_analyze_call_uses(), ipa_analyze_virtual_call_uses(), ipa_polymorphic_call_context::ipa_polymorphic_call_context(), operand_compare::operand_equal_p(), possible_polymorphic_call_target_p(), possible_polymorphic_call_targets(), and virtual_method_call_p().

◆ operand_equal_for_phi_arg_p()

bool operand_equal_for_phi_arg_p	(	const_tree	arg0,
		const_tree	arg1 )

extern

Return true if two operands that are suitable for PHI nodes are
necessarily equal.  Specifically, both ARG0 and ARG1 must be either
SSA_NAME or invariant.  Note that this is strictly an optimization.
That is, callers of this function can directly call operand_equal_p
and get the same result, only slower.

References ggc_alloc(), operand_equal_p(), and TREE_CODE.

Referenced by connect_loop_phis(), match_simplify_replacement(), minmax_replacement(), operand_equal_for_value_replacement(), phi_alternatives_equal(), record_equivalences_from_phis(), rhs_is_fed_for_value_replacement(), same_phi_alternatives_1(), simplify_rotate(), single_non_singleton_phi_for_edges(), tree_transform_and_unroll_loop(), and value_replacement().

◆ operation_can_overflow()

bool operation_can_overflow ( enum tree_code code )

extern

Returns true if CODE can overflow.

References ggc_alloc().

Referenced by parloops_needs_fold_left_reduction_p(), and vectorize_slp_instance_root_stmt().

◆ operation_no_trapping_overflow()

bool operation_no_trapping_overflow	(	tree	type,
		enum tree_code	code )

extern

Returns true if CODE operating on operands of type TYPE doesn't overflow, or
ftrapv doesn't generate trapping insns for CODE.

References ANY_INTEGRAL_TYPE_P, gcc_checking_assert, ggc_alloc(), INTEGRAL_TYPE_P, and TYPE_OVERFLOW_TRAPS.

Referenced by find_trapping_overflow(), needs_fold_left_reduction_p(), and parloops_needs_fold_left_reduction_p().

◆ opts_for_fn()

struct cl_optimization * opts_for_fn ( const_tree fndecl )

inline

Return pointer to optimization flags of FNDECL.

References DECL_FUNCTION_SPECIFIC_OPTIMIZATION, ggc_alloc(), NULL_TREE, optimization_default_node, and TREE_OPTIMIZATION.

Referenced by can_inline_edge_by_limits_p(), ipa_icf::sem_function::equals_wpa(), inline_call(), and report_inline_failed_reason().

◆ overwrite_decl_assembler_name()

void overwrite_decl_assembler_name	(	tree	decl,
		tree	name )

extern

The DECL_ASSEMBLER_NAME_RAW of DECL is being explicitly set to NAME
(either of which may be NULL).  Inform the FE, if this changes the
name.

References DECL_ASSEMBLER_NAME_RAW, and lang_hooks::overwrite_decl_assembler_name.

◆ poly_int_cst_value()

wi::tree_to_poly_wide_ref poly_int_cst_value ( const_tree x )

inline

Return the value of a POLY_INT_CST in its native precision.

References poly_int< N, C >::coeffs, ggc_alloc(), wi::i, NUM_POLY_INT_COEFFS, and POLY_INT_CST_COEFF.

Referenced by bits_from_bytes(), const_unop(), expand_debug_expr(), expand_expr_real_1(), fold_convert_const(), simple_cst_equal(), and wi::to_poly_wide().

◆ poly_int_tree_p() [1/3]

bool poly_int_tree_p ( const_tree t )

inline

Return true if the value of T could be represented as a poly_widest_int.

References ggc_alloc(), POLY_INT_CST_P, and TREE_CODE.

◆ poly_int_tree_p() [2/3]

bool poly_int_tree_p	(	const_tree	t,
		poly_int64 *	value )

inline

Return true if T holds a value that can be represented as a poly_int64
without loss of precision.  Store the value in *VALUE if so.

References tree_fits_poly_int64_p(), and tree_to_poly_int64().

Referenced by add_candidate_1(), add_iv_candidate_for_use(), adjust_offset_for_component_ref(), ao_ref_from_mem(), ao_ref_init_from_ptr_and_size(), ao_ref_init_from_vn_reference(), asan_expand_mark_ifn(), assign_temp(), check_fnspec(), compare_sizes(), compare_values_warnv(), compute_record_mode(), const_binop(), const_binop(), convert_mult_to_fma(), copy_reference_ops_from_ref(), create_ifn_alias_checks(), create_intersect_range_checks_index(), declare_return_variable(), decode_addr_const(), defer_stack_allocation(), delegitimize_mem_from_attrs(), dr_may_alias_p(), drop_tree_overflow(), dse_optimize_stmt(), eliminate_dom_walker::eliminate_stmt(), execute_update_addresses_taken(), expand_call(), expand_expr_real_1(), expand_omp_simd(), expand_one_var(), extract_base_bit_offset(), fold_comparison(), fold_const_aggregate_ref_1(), fold_const_call(), fold_indirect_ref_1(), fold_negate_const(), fold_view_convert_vector_encoding(), force_expr_to_var_cost(), gather_mem_refs_stmt(), generate_memcpy_builtin(), get_access_for_expr(), get_addr_base_and_unit_offset_1(), get_bit_range(), get_computation_aff_1(), get_inner_reference(), get_loop_invariant_expr(), get_mem_align_offset(), get_ref_base_and_extent(), get_vec_alignment_for_array_type(), gimple_fold_builtin_memory_op(), gimple_fold_partial_load_store_mem_ref(), gimplify_decl_expr(), gimplify_modify_expr(), gimplify_omp_depend(), gimplify_return_expr(), gimplify_target_expr(), indirect_ref_may_alias_decl_p(), inline_forbidden_p(), instrument_derefs(), int_const_binop(), loc_list_from_tree_1(), lower_rec_input_clauses(), lower_rec_simd_input_clauses(), maybe_instrument_pointer_overflow(), maybe_warn_operand(), maybe_with_size_expr(), mode_for_array(), multiple_of_p(), must_pass_in_stack_var_size(), native_interpret_aggregate(), non_rewritable_lvalue_p(), nonoverlapping_component_refs_p_1(), optimize_memcpy(), parm_object_size(), pass_by_reference(), pointer_may_wrap_p(), poly_int_binop(), prune_runtime_alias_test_list(), rtx_addr_can_trap_p_1(), same_addr_size_stores_p(), set_mem_attributes_minus_bitpos(), size_binop_loc(), split_address_to_core_and_offset(), stmt_kills_ref_p(), store_constructor(), store_field(), tree_could_trap_p(), tree_to_aff_combination(), try_transform_to_exit_first_loop_alt(), valueize_refs_1(), vect_prune_runtime_alias_test_list(), vect_set_loop_condition_partial_vectors_avx512(), vect_set_loop_controls_directly(), vectorizable_with_step_bound_p(), verify_gimple_call(), verify_types_in_gimple_reference(), vn_reference_lookup_3(), vn_reference_maybe_forwprop_address(), and widen_memory_access().

◆ poly_int_tree_p() [3/3]

bool poly_int_tree_p	(	const_tree	t,
		poly_uint64 *	value )

inline

Return true if T holds a value that can be represented as a poly_uint64
without loss of precision.  Store the value in *VALUE if so.

References tree_fits_poly_uint64_p(), and tree_to_poly_uint64().

◆ prepare_target_option_nodes_for_pch()

void prepare_target_option_nodes_for_pch ( void )

extern

Clear TREE_TARGET_GLOBALS of all TARGET_OPTION_NODE trees,
so that they aren't saved during PCH writing.

References cl_option_hash_table, ggc_alloc(), NULL, TREE_CODE, and TREE_TARGET_GLOBALS.

◆ protected_set_expr_location()

void protected_set_expr_location	(	tree	t,
		location_t	loc )

extern

Like SET_EXPR_LOCATION, but make sure the tree can have a location.

LOC is the location to use in tree T.

References CAN_HAVE_LOCATION_P, expr_single(), ggc_alloc(), SET_EXPR_LOCATION, and TREE_CODE.

Referenced by gimplify_arg(), protected_set_expr_location_if_unset(), and stabilize_reference().

◆ protected_set_expr_location_if_unset()

void protected_set_expr_location_if_unset	(	tree	t,
		location_t	loc )

extern

Like PROTECTED_SET_EXPR_LOCATION, but only do that if T has
UNKNOWN_LOCATION.

References EXPR_HAS_LOCATION, expr_single(), and protected_set_expr_location().

◆ protected_set_expr_location_unshare()

ATTRIBUTE_WARN_UNUSED_RESULT tree protected_set_expr_location_unshare	(	tree	x,
		location_t	loc )

extern

Similar to protected_set_expr_location, but never modify x in place,
if location can and needs to be set, unshare it.

References CAN_HAVE_LOCATION_P, copy_node(), EXPR_LOCATION, ggc_alloc(), SET_EXPR_LOCATION, and TREE_CODE.

Referenced by decl_value_expr_insert(), fold_convert_loc(), and fold_ternary_loc().

◆ prototype_p()

bool prototype_p ( const_tree fntype )

extern

Return true if TYPE has a prototype.

References gcc_assert, NULL_TREE, TYPE_ARG_TYPES, and TYPE_NO_NAMED_ARGS_STDARG_P.

Referenced by ipa_param_adjustments::adjust_decl(), ipa_param_adjustments::build_new_function_type(), go_format_type(), maybe_diag_incompatible_alias(), odr_types_equivalent_p(), useless_type_conversion_p(), and warn_types_mismatch().

◆ ptrdiff_tree_p()

bool ptrdiff_tree_p	(	const_tree	t,
		poly_int64 *	value )

extern

Return true if T holds a polynomial pointer difference, storing it in
*VALUE if so.  A true return means that T's precision is no greater
than 64 bits, which is the largest address space we support, so *VALUE
never loses precision.  However, the signedness of the result does
not necessarily match the signedness of T: sometimes an unsigned type
like sizetype is used to encode a value that is actually negative.

References poly_int< N, C >::coeffs, cst_and_fits_in_hwi(), ggc_alloc(), i, int_cst_value(), NUM_POLY_INT_COEFFS, POLY_INT_CST_COEFF, POLY_INT_CST_P, and TREE_CODE.

Referenced by ao_ref_init_from_ptr_and_range(), get_address_cost(), strip_offset_1(), and unadjusted_ptr_and_unit_offset().

◆ ptrofftype_p()

bool ptrofftype_p ( tree type )

inline

Return whether TYPE is a type suitable for an offset for
a POINTER_PLUS_EXPR.

References INTEGRAL_TYPE_P, sizetype, TYPE_PRECISION, and TYPE_UNSIGNED.

Referenced by asan_mem_ref_get_end(), build2(), build_polynomial_chrec(), chrec_fold_plus_poly_poly(), convert_to_ptrofftype_loc(), get_string_length(), gimple_convert_to_ptrofftype(), maybe_cast_to_ptrmode(), reset_evolution_in_loop(), and verify_gimple_assign_binary().

◆ purpose_member()

tree purpose_member	(	const_tree	elem,
		tree	list )

extern

Return first list element whose TREE_PURPOSE is ELEM.
Return 0 if ELEM is not in LIST.

References NULL_TREE, TREE_CHAIN, and TREE_PURPOSE.

◆ real_maybe_zerop()

bool real_maybe_zerop ( const_tree expr )

extern

Return true if T could be a floating point zero.

References count, dconst0, ggc_alloc(), i, real_equal(), real_maybe_zerop(), TREE_CODE, TREE_IMAGPART, TREE_REAL_CST, TREE_REALPART, VECTOR_CST_ENCODED_ELT, and vector_cst_encoded_nelts().

Referenced by real_maybe_zerop(), and record_edge_info().

◆ real_minus_onep()

bool real_minus_onep ( const_tree expr )

extern

Return true if EXPR is the real constant minus one.  Trailing zeroes
matter for decimal float constants, so don't return true for them.
Also return true for location wrappers around such a constant.

References dconstm1, DECIMAL_FLOAT_MODE_P, ggc_alloc(), real_equal(), real_minus_onep(), real_zerop(), STRIP_ANY_LOCATION_WRAPPER, TREE_CODE, TREE_IMAGPART, TREE_REAL_CST, TREE_REALPART, TREE_TYPE, TYPE_MODE, VECTOR_CST_DUPLICATE_P, VECTOR_CST_ENCODED_ELT, and VECTOR_CST_NPATTERNS.

Referenced by constant_type(), fold_binary_loc(), real_minus_onep(), reassociate_bb(), tree_predict_by_opcode(), and zero_one_operation().

◆ real_onep()

bool real_onep ( const_tree expr )

extern

Return true if EXPR is the real constant one in real or complex form.
Trailing zeroes matter for decimal float constants, so don't return
true for them.
Also return true for location wrappers around such a constant.

References dconst1, DECIMAL_FLOAT_MODE_P, ggc_alloc(), real_equal(), real_onep(), real_zerop(), STRIP_ANY_LOCATION_WRAPPER, TREE_CODE, TREE_IMAGPART, TREE_REAL_CST, TREE_REALPART, TREE_TYPE, TYPE_MODE, VECTOR_CST_DUPLICATE_P, VECTOR_CST_ENCODED_ELT, and VECTOR_CST_NPATTERNS.

Referenced by constant_type(), eliminate_using_constants(), fold_binary_loc(), initializer_each_zero_or_onep(), is_copysign_call_with_1(), real_onep(), and tree_predict_by_opcode().

◆ real_zerop()

bool real_zerop ( const_tree expr )

extern

Return true if EXPR is the real constant zero.

Return true if EXPR is the real constant zero.  Trailing zeroes matter for
decimal float constants, so don't return true for them.
Also return true for location wrappers around such a constant.

References count, dconst0, DECIMAL_FLOAT_MODE_P, ggc_alloc(), i, real_equal(), real_zerop(), STRIP_ANY_LOCATION_WRAPPER, TREE_CODE, TREE_IMAGPART, TREE_REAL_CST, TREE_REALPART, TREE_TYPE, TYPE_MODE, VECTOR_CST_ENCODED_ELT, and vector_cst_encoded_nelts().

Referenced by const_with_all_bytes_same(), ctor_single_nonzero_element(), eliminate_using_constants(), fold_binary_loc(), fold_cond_expr_with_comparison(), fold_real_zero_addition_p(), operand_compare::hash_operand(), initializer_each_zero_or_onep(), initializer_zerop(), operand_compare::operand_equal_p(), real_minus_onep(), real_onep(), real_zerop(), single_nonzero_element(), tree_predict_by_opcode(), and zerop().

◆ really_constant_p()

bool really_constant_p ( const_tree exp )

extern

True if EXP is a constant or a cast of a constant.

References CONVERT_EXPR_P, exp(), ggc_alloc(), TREE_CODE, TREE_CONSTANT, and TREE_OPERAND.

Referenced by expand_expr_real_2().

◆ recompute_constructor_flags()

void recompute_constructor_flags ( tree c )

extern

Something has messed with the elements of CONSTRUCTOR C after it was built;
calculate TREE_CONSTANT and TREE_SIDE_EFFECTS.

References CONSTRUCTOR_ELTS, FOR_EACH_CONSTRUCTOR_VALUE, i, side_effects_p(), TREE_CONSTANT, and TREE_SIDE_EFFECTS.

Referenced by build_constructor(), and gimplify_init_constructor().

◆ recompute_tree_invariant_for_addr_expr()

void recompute_tree_invariant_for_addr_expr ( tree t )

extern

Low-level constructors for expressions.

A helper function for build1 and constant folders.  Set TREE_CONSTANT,
and TREE_SIDE_EFFECTS for an ADDR_EXPR.

References CONSTANT_CLASS_P, DECL_P, lang_hooks::expr_to_decl, gcc_assert, ggc_alloc(), handled_component_p(), INDIRECT_REF_P, NULL_TREE, staticp(), TREE_CODE, TREE_CONSTANT, TREE_OPERAND, TREE_SIDE_EFFECTS, TREE_TYPE, and UPDATE_FLAGS.

Referenced by substitute_and_fold_dom_walker::before_dom_children(), build_invariant_address(), convert_local_reference_op(), convert_nonlocal_reference_op(), copy_tree_body_r(), eliminate_dom_walker::eliminate_stmt(), expand_omp_regimplify_p(), gimplify_addr_expr(), lower_omp_for(), lower_omp_regimplify_p(), maybe_canonicalize_mem_ref_addr(), dom_opt_dom_walker::optimize_stmt(), remap_gimple_op_r(), replace_uses_by(), tidy_after_forward_propagate_addr(), and verify_address().

◆ reconstruct_complex_type()

tree reconstruct_complex_type	(	tree	type,
		tree	bottom )

extern

HACK.  GROSS.  This is absolutely disgusting.  I wish there was a
better way.

If we requested a pointer to a vector, build up the pointers that
we stripped off while looking for the inner type.  Similarly for
return values from functions.

The argument TYPE is the top of the chain, and BOTTOM is the
new type which we will point to.

References build_array_type(), build_function_type(), build_method_type_directly(), build_offset_type(), build_pointer_type_for_mode(), build_reference_type_for_mode(), build_type_attribute_qual_variant(), ggc_alloc(), reconstruct_complex_type(), TREE_CHAIN, TREE_CODE, TREE_TYPE, TREE_VALUE, TYPE_ARG_TYPES, TYPE_ATTRIBUTES, TYPE_DOMAIN, TYPE_MODE, TYPE_NO_NAMED_ARGS_STDARG_P, TYPE_OFFSET_BASETYPE, TYPE_QUALS, and TYPE_REF_CAN_ALIAS_ALL.

Referenced by reconstruct_complex_type().

◆ reverse_storage_order_for_component_p()

bool reverse_storage_order_for_component_p ( tree t )

inline

Return true T is a component with reverse storage order.

References AGGREGATE_TYPE_P, ggc_alloc(), POINTER_TYPE_P, REF_REVERSE_STORAGE_ORDER, TREE_CODE, TREE_OPERAND, TREE_TYPE, TYPE_REVERSE_STORAGE_ORDER, and VECTOR_TYPE_P.

◆ save_expr()

tree save_expr ( tree expr )

extern

save_expr (EXP) returns an expression equivalent to EXP
but it can be used multiple times within context CTX
and only evaluate EXP once.

Wrap a SAVE_EXPR around EXPR, if appropriate.
Do this to any expression which may be used in more than one place,
but must be evaluated only once.

Normally, expand_expr would reevaluate the expression each time.
Calling save_expr produces something that is evaluated and recorded
the first time expand_expr is called on it.  Subsequent calls to
expand_expr just reuse the recorded value.

The call to expand_expr that generates code that actually computes
the value is the first call *at compile time*.  Subsequent calls
*at compile time* generate code to use the saved value.
This produces correct result provided that *at run time* control
always flows through the insns made by the first expand_expr
before reaching the other places where the save_expr was evaluated.
You, the caller of save_expr, must make sure this is so.

Constants, and certain read-only nodes, are returned with no
SAVE_EXPR because that is safe.  Expressions containing placeholders
are not touched; see tree.def for an explanation of what these
are used for.

References build1_loc(), contains_placeholder_p(), expr, EXPR_LOCATION, ggc_alloc(), skip_simple_arithmetic(), TREE_CODE, tree_invariant_p_1(), TREE_SIDE_EFFECTS, and TREE_TYPE.

Referenced by builtin_save_expr(), c_strlen(), convert_to_complex_1(), convert_to_integer_1(), fold_builtin_addc_subc(), fold_builtin_arith_overflow(), fold_builtin_bit_query(), fold_builtin_expect(), fold_convert_loc(), fold_mult_zconjz(), fold_range_test(), gimplify_expr(), lower_reduction_clauses(), stabilize_reference_1(), stabilize_va_list_loc(), and variable_size().

◆ set_block()

location_t set_block	(	location_t	loc,
		tree	block )

extern

Combine LOC and BLOCK to a combined adhoc loc, retaining any range
information.

References get_discriminator_from_loc(), get_pure_location(), ggc_alloc(), and line_table.

Referenced by lto_location_cache::apply_location_cache(), gimple_set_block(), lto_location_cache::input_location_and_block(), move_block_to_fn(), and remap_location().

◆ set_builtin_decl()

void set_builtin_decl	(	enum built_in_function	fncode,
		tree	decl,
		bool	implicit_p )

inline

Set explicit builtin function nodes and whether it is an implicit
function.

References BUILTIN_VALID_P, gcc_checking_assert, ggc_alloc(), and NULL_TREE.

Referenced by local_define_builtin(), rt_bb_visited::rt_bb_visited(), and tree_ssa_prefetch_arrays().

◆ set_builtin_decl_declared_p()

void set_builtin_decl_declared_p	(	enum built_in_function	fncode,
		bool	declared_p )

inline

Set the declared flag for a builtin function.

References BUILTIN_VALID_P, gcc_checking_assert, ggc_alloc(), and NULL_TREE.

◆ set_builtin_decl_implicit_p()

void set_builtin_decl_implicit_p	(	enum built_in_function	fncode,
		bool	implicit_p )

inline

Set the implicit flag for a builtin function.

References BUILTIN_VALID_P, gcc_checking_assert, ggc_alloc(), and NULL_TREE.

Referenced by gimplify_addr_expr().

◆ set_call_expr_flags()

void set_call_expr_flags	(	tree	decl,
		int	flags )

extern

Modify DECL for given flags.
TM_PURE attribute is set only on types, so the function will modify
DECL's type when ECF_TM_PURE is used.

References apply_tm_attr(), build_string(), build_tree_list(), DECL_ATTRIBUTES, DECL_IS_MALLOC, DECL_IS_NOVOPS, DECL_IS_RETURNS_TWICE, DECL_LOOPING_CONST_OR_PURE_P, DECL_PURE_P, ECF_COLD, ECF_CONST, ECF_LEAF, ECF_LOOPING_CONST_OR_PURE, ECF_MALLOC, ECF_NORETURN, ECF_NOTHROW, ECF_NOVOPS, ECF_PURE, ECF_RET1, ECF_RETURNS_TWICE, ECF_TM_PURE, ECF_XTHROW, gcc_assert, get_identifier(), ggc_alloc(), NULL, NULL_TREE, tree_cons(), TREE_NOTHROW, TREE_READONLY, and TREE_THIS_VOLATILE.

Referenced by build_cxa_atexit_decl(), and local_define_builtin().

◆ set_decl_built_in_function()

void set_decl_built_in_function	(	tree	decl,
		built_in_class	fclass,
		unsigned int	fcode )

inline

Record that FUNCTION_DECL DECL represents built-in function FCODE of
class FCLASS.

References ggc_alloc().

Referenced by ipa_param_adjustments::adjust_decl(), build_builtin_function(), ipa_param_body_adjustments::modify_formal_parameters(), simd_clone_create(), split_function(), and unpack_ts_function_decl_value_fields().

◆ set_decl_rtl()

void set_decl_rtl	(	tree	t,
		rtx	x )

extern

FIXME - These declarations belong in builtins.h, expr.h and emit-rtl.h,
but none of these files are allowed to be included from front ends.
They should be split in two. One suitable for the FEs, the other suitable
for the BE.

Assign the RTX to declaration.

Assign the RTX X to declaration T.

References DECL_WRTL_CHECK, and set_reg_attrs_for_decl_rtl().

Referenced by initialize_argument_information().

◆ set_decl_section_name() [1/2]

void set_decl_section_name	(	tree	node,
		const char *	value )

extern

Set section name of NODE to VALUE (that is expected to be
identifier node)

References symtab_node::get(), varpool_node::get_create(), cgraph_node::get_create(), ggc_alloc(), NULL, and VAR_P.

Referenced by build_gcov_info_var_registration(), default_unique_section(), get_emutls_init_templ_addr(), new_emutls_decl(), and omp_finish_file().

◆ set_decl_section_name() [2/2]

void set_decl_section_name	(	tree	decl,
		const_tree	other )

extern

Set section name of NODE to match the section name of OTHER.

set_decl_section_name (decl, other) is equivalent to
set_decl_section_name (decl, DECL_SECTION_NAME (other)), but possibly more
efficient.

References symtab_node::get(), varpool_node::get_create(), cgraph_node::get_create(), ggc_alloc(), NULL, and VAR_P.

◆ set_decl_tls_model()

void set_decl_tls_model	(	tree	node,
		enum tls_model	model )

extern

Set TLS model of variable NODE to MODEL.

References varpool_node::get(), varpool_node::get_create(), ggc_alloc(), and TLS_MODEL_NONE.

Referenced by function_and_variable_visibility(), init_ic_make_global_vars(), and new_emutls_decl().

◆ set_function_decl_type()

void set_function_decl_type	(	tree	decl,
		function_decl_type	t,
		bool	set )

inline

Set decl_type of a DECL.  Set it to T when SET is true, or reset
it to NONE.

References FUNCTION_DECL_DECL_TYPE, gcc_assert, and ggc_alloc().

◆ set_source_range() [1/2]

location_t set_source_range	(	tree	expr,
		location_t	start,
		location_t	finish )

extern

◆ set_source_range() [2/2]

location_t set_source_range	(	tree	expr,
		source_range	src_range )

extern

◆ SET_TYPE_VECTOR_SUBPARTS()

void SET_TYPE_VECTOR_SUBPARTS	(	tree	node,
		poly_uint64	subparts )

inline

Set the number of elements in VECTOR_TYPE NODE to SUBPARTS, which must
satisfy valid_vector_subparts_p.

References exact_log2(), gcc_assert, ggc_alloc(), NUM_POLY_INT_COEFFS, and STATIC_ASSERT.

Referenced by make_vector_type().

◆ sign_mask_for()

tree sign_mask_for ( tree type )

extern

If floating-point type TYPE has an IEEE-style sign bit, return an
unsigned constant in which only the sign bit is set.  Return null
otherwise.

References build_vector_from_val(), element_mode(), ggc_alloc(), NULL_TREE, pow2p_hwi(), REAL_MODE_FORMAT, wi::set_bit_in_zero(), TREE_CODE, TREE_TYPE, unsigned_type_for(), VECTOR_TYPE_P, and wide_int_to_tree().

◆ signed_or_unsigned_type_for()

tree signed_or_unsigned_type_for	(	int	unsignedp,
		tree	type )

extern

Construct various nodes representing data types.

If TYPE is an integral or pointer type, return an integer type with
the same precision which is unsigned iff UNSIGNEDP is true, or itself
if TYPE is already an integer type of signedness UNSIGNEDP.
If TYPE is a floating-point type, return an integer type with the same
bitsize and with the signedness given by UNSIGNEDP; this is useful
when doing bit-level operations on a floating-point value.

References ANY_INTEGRAL_TYPE_P, build_bitint_type(), build_complex_type(), build_nonstandard_integer_type(), build_vector_type(), build_vector_type_for_mode(), GET_MODE_BITSIZE(), ggc_alloc(), INTEGRAL_TYPE_P, new_mode(), NULL_TREE, POINTER_TYPE_P, related_int_vector_mode(), SCALAR_TYPE_MODE, signed_or_unsigned_type_for(), TREE_CODE, TREE_TYPE, type(), TYPE_MODE, TYPE_PRECISION, TYPE_UNSIGNED, TYPE_VECTOR_SUBPARTS(), and VECTOR_MODE_P.

Referenced by signed_or_unsigned_type_for(), signed_type_for(), store_expr(), unsigned_type_for(), and vect_recog_dot_prod_pattern().

◆ signed_type_for()

tree signed_type_for ( tree type )

extern

If TYPE is an integral or pointer type, return an integer type with
the same precision which is signed, or itself if TYPE is already a
signed integer type.  If TYPE is a floating-point type, return a
signed integer type with the same bitsize as TYPE.

References signed_or_unsigned_type_for().

Referenced by affine_fn_op(), build_range_check(), convert_mult_to_highpart(), do_narrow(), expand_oacc_for(), expand_omp_for_generic(), expand_omp_for_init_counts(), expand_omp_for_init_vars(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), expand_omp_simd(), expand_omp_taskloop_for_inner(), expand_omp_taskloop_for_outer(), expand_single_bit_test(), fold_binary_loc(), fold_negate_expr_1(), fold_ternary_loc(), get_computation_cost(), get_offset_range(), lower_rec_input_clauses(), make_tree(), omp_extract_for_data(), signed_type_for_types(), size_diffop_loc(), unextend(), vect_create_cond_for_align_checks(), vect_emulate_mixed_dot_prod(), vect_recog_abd_pattern(), and vect_recog_dot_prod_pattern().

◆ simple_cst_equal()

int simple_cst_equal	(	const_tree	t1,
		const_tree	t2 )

extern

Return truthvalue of whether T1 is the same tree structure as T2.
Return 1 if they are the same.
Return 0 if they are understandably different.
Return -1 if either contains tree structure not understood by
this function.

References CALL_EXPR_FN, call_expr_nargs, CONSTRUCTOR_ELTS, CONVERT_EXPR_CODE_P, DECL_NAME, DECL_RTL_SET_P, EXPR_LOCATION, first_const_call_expr_arg(), FIXED_VALUES_IDENTICAL, poly_int< NUM_POLY_INT_COEFFS, widest_int >::from(), ggc_alloc(), i, known_eq, location_wrapper_p(), NULL_TREE, POLY_INT_CST_P, poly_int_cst_value(), real_identical(), simple_cst_equal(), tcc_binary, tcc_comparison, tcc_expression, tcc_reference, tcc_statement, tcc_unary, wi::to_widest(), TREE_CODE, TREE_CODE_CLASS, TREE_CODE_LENGTH, TREE_FIXED_CST, TREE_OPERAND, TREE_REAL_CST, TREE_STRING_LENGTH, TREE_STRING_POINTER, TREE_TYPE, TYPE_SIGN, and vec_safe_length().

Referenced by attribute_value_equal(), check_unique_operand_names(), complete_ctor_at_level_p(), count_type_elements(), decl_attributes(), finalize_record_size(), fold_truth_andor_1(), get_range_strlen_tree(), gimple_divmod_fixed_value_transform(), gimple_mod_pow2_value_transform(), gimplify_init_ctor_eval(), mode_for_array(), omp_construct_simd_compare(), omp_context_selector_props_compare(), omp_context_selector_set_compare(), omp_declare_simd_clauses_equal(), place_field(), push_without_duplicates(), restrict_type_identity_attributes_to(), simple_cst_equal(), simple_cst_list_equal(), and type_list_equal().

◆ single_nonzero_element()

int single_nonzero_element ( const_tree t )

extern

If VECTOR_CST T has a single nonzero element, return the index of that
element, otherwise return -1.

References ggc_alloc(), i, integer_zerop(), real_zerop(), vector_cst_elt(), vector_cst_encoded_nelts(), VECTOR_CST_NELTS, VECTOR_CST_NELTS_PER_PATTERN, and VECTOR_CST_NPATTERNS.

◆ size_in_bytes()

tree size_in_bytes ( const_tree t )

inline

References input_location, and size_in_bytes_loc().

Referenced by arg_size_in_bytes(), asan_expand_check_ifn(), asan_expand_mark_ifn(), build_check_stmt(), check_func(), default_cxx_get_cookie_size(), has_mem_ref_been_instrumented(), hwasan_check_func(), instrument_derefs(), instrument_mem_region_access(), instrument_object_size(), maybe_update_mem_ref_hash_table(), report_error_func(), subrange_type_die(), and tree_expr_size().

◆ size_in_bytes_loc()

tree size_in_bytes_loc	(	location_t	loc,
		const_tree	type )

extern

Return the size nominally occupied by an object of type TYPE
when it resides in memory.  The value is measured in units of bytes,
and its data type is that normally used for type sizes
(which is the first type created by make_signed_type or
make_unsigned_type).

References error_mark_node, lang_hooks_for_types::incomplete_type_error, integer_zero_node, NULL_TREE, size_zero_node, TYPE_MAIN_VARIANT, TYPE_SIZE_UNIT, and lang_hooks::types.

Referenced by size_in_bytes().

◆ skip_simple_arithmetic()

tree skip_simple_arithmetic ( tree expr )

extern

Look inside EXPR into any simple arithmetic operations.  Return the
outermost non-arithmetic or non-invariant node.

References BINARY_CLASS_P, expr, ggc_alloc(), TREE_CODE, tree_invariant_p(), TREE_OPERAND, and UNARY_CLASS_P.

Referenced by save_expr(), and tree_invariant_p().

◆ skip_simple_constant_arithmetic()

tree skip_simple_constant_arithmetic ( tree expr )

extern

Look inside EXPR into simple arithmetic operations involving constants.
Return the outermost non-arithmetic or non-constant node.

References BINARY_CLASS_P, expr, ggc_alloc(), TREE_CODE, TREE_CONSTANT, TREE_OPERAND, and UNARY_CLASS_P.

Referenced by self_referential_size().

◆ stabilize_reference()

tree stabilize_reference ( tree ref )

extern

stabilize_reference (EXP) returns a reference equivalent to EXP
but it can be used multiple times
and only evaluate the subexpressions once.

Stabilize a reference so that we can use it any number of times
without causing its operands to be evaluated more than once.
Returns the stabilized reference.  This works by means of save_expr,
so see the caveats in the comments about save_expr.

Also allows conversion expressions whose operands are references.
Any other kind of expression is returned unchanged.

References build_nt(), CASE_CONVERT, error_mark_node, EXPR_LOCATION, ggc_alloc(), NULL_TREE, protected_set_expr_location(), REF_REVERSE_STORAGE_ORDER, stabilize_reference(), stabilize_reference_1(), TREE_CODE, TREE_OPERAND, TREE_READONLY, TREE_SIDE_EFFECTS, TREE_THIS_VOLATILE, and TREE_TYPE.

Referenced by stabilize_reference().

◆ staticp()

tree staticp ( tree arg )

extern

staticp (tree x) is nonzero if X is a reference to data allocated
at a fixed address in memory.  Returns the outermost data.

If arg is static -- a reference to an object in static storage -- then
return the object.  This is not the same as the C meaning of `static'.
If arg isn't static, return NULL.

References COMPOUND_LITERAL_EXPR_DECL, DECL_BIT_FIELD, DECL_DLLIMPORT_P, DECL_EXTERNAL, DECL_THREAD_LOCAL_P, gcc_assert, ggc_alloc(), NULL, staticp(), TREE_CODE, TREE_CONSTANT, TREE_OPERAND, TREE_STATIC, TREE_TYPE, and TYPE_SIZE.

Referenced by initializer_constant_valid_p_1(), recompute_tree_invariant_for_addr_expr(), safe_from_p(), and staticp().

◆ stdarg_p()

bool stdarg_p ( const_tree fntype )

extern

Return true if TYPE has a variable argument list.

References FOREACH_FUNCTION_ARGS, ggc_alloc(), NULL_TREE, TYPE_NO_NAMED_ARGS_STDARG_P, and void_type_node.

Referenced by allocate_struct_function(), check_argument_count(), compute_fn_summary(), expand_thunk(), fold_builtin_next_arg(), go_format_type(), ipa_icf::sem_function::merge(), and tree_profiling().

◆ storage_order_barrier_p()

bool storage_order_barrier_p ( const_tree t )

inline

Return true if T is a storage order barrier, i.e. a VIEW_CONVERT_EXPR
that can modify the storage order of objects.  Note that, even if the
TYPE_REVERSE_STORAGE_ORDER flag is set on both the inner type and the
outer type, a VIEW_CONVERT_EXPR can modify the storage order because
it can change the partition of the aggregate object into scalars.

References AGGREGATE_TYPE_P, ggc_alloc(), TREE_CODE, TREE_OPERAND, TREE_TYPE, and TYPE_REVERSE_STORAGE_ORDER.

Referenced by build_access_from_expr_1(), build_accesses_from_assign(), copy_reference_ops_from_ref(), and vn_reference_lookup_3().

◆ strip_array_types()

tree strip_array_types ( tree type )

inline

Recursively examines the array elements of TYPE, until a non-array
element type is found.

References ggc_alloc(), TREE_CODE, TREE_TYPE, and type().

Referenced by array_bounds_checker::check_mem_ref(), get_vec_alignment_for_array_type(), gimple_fold_builtin_clear_padding(), gimplify_adjust_omp_clauses(), gimplify_adjust_omp_clauses_1(), place_field(), and ubsan_type_descriptor().

◆ strip_float_extensions()

tree strip_float_extensions ( tree exp )

extern

Avoid any floating point extensions from EXP.

References build_real_truncate(), CONVERT_EXPR_P, DECIMAL_FLOAT_TYPE_P, double_type_node, element_precision(), exact_real_truncate(), exp(), float_type_node, FLOAT_TYPE_P, ggc_alloc(), NULL, REAL_VALUE_TYPE, strip_float_extensions(), TREE_CODE, TREE_OPERAND, TREE_REAL_CST, TREE_TYPE, TYPE_MODE, and TYPE_PRECISION.

Referenced by convert_to_integer_1(), convert_to_real_1(), fold_binary_loc(), fold_negate_expr_1(), fold_unary_loc(), negate_expr_p(), and strip_float_extensions().

◆ strip_invariant_refs()

const_tree strip_invariant_refs ( const_tree op )

extern

Strip out all handled components that produce invariant
offsets.

References ggc_alloc(), handled_component_p(), is_gimple_constant(), NULL, NULL_TREE, TREE_CODE, and TREE_OPERAND.

Referenced by is_gimple_invariant_address(), is_gimple_ip_invariant_address(), is_gimple_min_lval(), and transaction_invariant_address_p().

◆ strip_zero_offset_components()

tree strip_zero_offset_components ( tree op )

extern

Strip handled components with zero offset from OP.

References DECL_FIELD_BIT_OFFSET, DECL_FIELD_OFFSET, ggc_alloc(), integer_zerop(), TREE_CODE, and TREE_OPERAND.

Referenced by vect_create_addr_base_for_vector_ref().

◆ struct_ptr_eq()

int struct_ptr_eq	(	const void *	a,
		const void *	b )

inline

Compare and hash for any structure which begins with a canonical
pointer.  Assumes all pointers are interchangeable, which is sort
of already assumed by gcc elsewhere IIRC.

References a, b, and y.

◆ struct_ptr_hash()

hashval_t struct_ptr_hash ( const void * a )

inline

References a, and ggc_alloc().

◆ subrange_type_for_debug_p()

bool subrange_type_for_debug_p	(	const_tree	type,
		tree *	lowval,
		tree *	highval )

extern

Return true if the debug information for TYPE, a subtype, should be emitted
as a subrange type.  If so, set LOWVAL to the low bound and HIGHVAL to the
high bound, respectively.  Sometimes doing so unnecessarily obfuscates the
debug info and doesn't reflect the source code.

References lang_hooks_for_types::get_subrange_bounds, ggc_alloc(), int_size_in_bytes(), INTEGRAL_TYPE_P, TREE_CODE, tree_int_cst_equal(), TREE_TYPE, TYPE_IDENTIFIER, TYPE_MAX_VALUE, TYPE_MIN_VALUE, and lang_hooks::types.

Referenced by modified_type_die().

◆ substitute_in_expr()

tree substitute_in_expr	(	tree	exp,
		tree	f,
		tree	r )

extern

Given a tree EXP, a FIELD_DECL F, and a replacement value R,
return a tree with all occurrences of references to F in a
PLACEHOLDER_EXPR replaced by R.  Also handle VAR_DECLs and
CONST_DECLs.  Note that we assume here that EXP contains only
arithmetic expressions or CALL_EXPRs with PLACEHOLDER_EXPRs
occurring only in their argument list.

References build4(), CONSTANT_CLASS_P, copy_node(), exp(), fold(), fold_build1, fold_build2, fold_build3, gcc_unreachable, ggc_alloc(), i, maybe_inline_call_in_expr(), NULL_TREE, operand_equal_p(), process_call_operands(), r, REFERENCE_CLASS_P, SUBSTITUTE_IN_EXPR, tcc_binary, tcc_comparison, tcc_constant, tcc_declaration, tcc_exceptional, tcc_expression, tcc_reference, tcc_unary, tcc_vl_exp, TREE_CHAIN, TREE_CODE, TREE_CODE_CLASS, TREE_CODE_LENGTH, tree_cons(), TREE_OPERAND, TREE_OPERAND_LENGTH, TREE_PURPOSE, TREE_READONLY, TREE_THIS_NOTRAP, TREE_TYPE, and TREE_VALUE.

Referenced by self_referential_size().

◆ substitute_placeholder_in_expr()

tree substitute_placeholder_in_expr	(	tree	exp,
		tree	obj )

extern

Similar, but look for a PLACEHOLDER_EXPR in EXP and find a replacement
for it within OBJ, a tree that is an object or a chain of references.

References BINARY_CLASS_P, build4(), copy_node(), exp(), EXPRESSION_CLASS_P, fold(), fold_build1, fold_build2, fold_build3, gcc_unreachable, ggc_alloc(), i, NULL_TREE, POINTER_TYPE_P, process_call_operands(), REFERENCE_CLASS_P, SUBSTITUTE_PLACEHOLDER_IN_EXPR, tcc_binary, tcc_comparison, tcc_constant, tcc_declaration, tcc_exceptional, tcc_expression, tcc_reference, tcc_statement, tcc_unary, tcc_vl_exp, TREE_CHAIN, TREE_CODE, TREE_CODE_CLASS, TREE_CODE_LENGTH, tree_cons(), TREE_OPERAND, TREE_OPERAND_LENGTH, TREE_PURPOSE, TREE_READONLY, TREE_THIS_NOTRAP, TREE_TYPE, TREE_VALUE, TYPE_MAIN_VARIANT, UNARY_CLASS_P, and VL_EXP_CLASS_P.

◆ suppress_warning()

void suppress_warning	(	tree	expr,
		opt_code	opt,
		bool	supp )

extern

Set the disposition for a warning (or all warnings by default)
at a location to disabled by default.

Enable, or by default disable, a warning for the expression.
The wildcard OPT of -1 controls all warnings.

References get_location(), ggc_alloc(), no_warning, RESERVED_LOCATION_P, set_no_warning_bit(), and suppress_warning_at().

◆ suppress_warning_at()

bool suppress_warning_at	(	location_t	loc,
		opt_code	opt = all_warnings,
		bool	supp = true )

extern

Set the disposition for a warning (or all warnings by default)
at a location to disabled by default.

References hash_map< KeyId, Value, Traits >::create_ggc(), gcc_checking_assert, hash_map< KeyId, Value, Traits >::get(), ggc_alloc(), no_warning, nowarn_map, NULL, hash_map< KeyId, Value, Traits >::put(), hash_map< KeyId, Value, Traits >::remove(), and RESERVED_LOCATION_P.

Referenced by suppress_warning(), and suppress_warning().

◆ target_opts_for_fn()

cl_target_option * target_opts_for_fn ( const_tree fndecl )

inline

Return pointer to target flags of FNDECL.

References DECL_FUNCTION_SPECIFIC_TARGET, ggc_alloc(), NULL, NULL_TREE, target_option_default_node, and TREE_TARGET_OPTION.

Referenced by ipa_icf::sem_function::equals_wpa(), and report_inline_failed_reason().

◆ tree_block()

tree tree_block ( tree t )

extern

References gcc_unreachable, IS_EXPR_CODE_CLASS, LOCATION_BLOCK, NULL, TREE_CODE, and TREE_CODE_CLASS.

Referenced by tree_code_size().

◆ tree_cc_finalize()

void tree_cc_finalize ( void )

extern

Referenced by toplev::finalize().

◆ tree_code_for_canonical_type_merging()

enum tree_code tree_code_for_canonical_type_merging ( enum tree_code code )

inline

Return simplified tree code of type that is used for canonical type
merging.

References ggc_alloc().

Referenced by gimple_canonical_types_compatible_p(), and type_with_interoperable_signedness().

◆ tree_code_size()

size_t tree_code_size ( enum tree_code code )

extern

Compute the number of bytes occupied by a tree with code CODE.
This function cannot be used for TREE_VEC or INTEGER_CST nodes,
which are of variable length.

Compute the number of bytes occupied by a tree with code CODE.
This function cannot be used for nodes that have variable sizes,
including TREE_VEC, INTEGER_CST, STRING_CST, and CALL_EXPR.

References gcc_checking_assert, gcc_unreachable, ggc_alloc(), lang_hooks::identifier_size, NUM_TREE_CODES, tcc_binary, tcc_comparison, tcc_constant, tcc_declaration, tcc_exceptional, tcc_expression, tcc_reference, tcc_statement, tcc_type, tcc_unary, tree_block(), TREE_CODE_CLASS, TREE_CODE_LENGTH, and lang_hooks::tree_size.

Referenced by make_node(), and tree_size().

◆ tree_cons()

tree tree_cons	(	tree	,
		tree	,
		tree	CXX_MEM_STAT_INFO )

extern

Make a new TREE_LIST node from specified PURPOSE, VALUE and CHAIN.

◆ tree_ctz()

unsigned int tree_ctz ( const_tree expr )

extern

Return number of known trailing zero bits in EXPR, or, if the value of
EXPR is known to be zero, the precision of it's type.

References CASE_CONVERT, CONST_CAST_TREE, wi::ctz(), ctz_hwi(), get_nonzero_bits(), get_pointer_alignment(), ggc_alloc(), INTEGRAL_TYPE_P, MAX, MIN, POINTER_TYPE_P, wi::to_wide(), TREE_CODE, tree_ctz(), tree_fits_uhwi_p(), tree_int_cst_sgn(), tree_log2(), TREE_OPERAND, tree_to_uhwi(), TREE_TYPE, and TYPE_PRECISION.

Referenced by expand_builtin_memcmp(), expand_builtin_memory_copy_args(), expand_builtin_memset_args(), get_object_alignment_2(), get_pointer_alignment_1(), highest_pow2_factor(), may_be_unaligned_p(), tree_ctz(), and vect_need_peeling_or_partial_vectors_p().

◆ tree_decl_map_hash()

unsigned int tree_decl_map_hash ( const void * item )

extern

Hash a from tree in a tree_decl_map.

References DECL_UID, and ggc_alloc().

Referenced by tree_decl_map_cache_hasher::hash().

◆ tree_fits_poly_int64_p()

bool tree_fits_poly_int64_p ( const_tree t )

extern

Return true if T is an INTEGER_CST or POLY_INT_CST whose numerical
value (extended according to TYPE_UNSIGNED) fits in a poly_int64.

References wi::fits_shwi_p(), ggc_alloc(), i, NULL_TREE, NUM_POLY_INT_COEFFS, POLY_INT_CST_COEFF, POLY_INT_CST_P, wi::to_wide(), wi::to_widest(), and TREE_CODE.

Referenced by address_compare(), component_ref_size(), expand_asm_stmt(), fold_indirect_ref_1(), poly_int_tree_p(), tree_to_vec_perm_builder(), and vn_reference_lookup_3().

◆ tree_fits_poly_uint64_p()

bool tree_fits_poly_uint64_p ( const_tree t )

extern

Return true if T is an INTEGER_CST or POLY_INT_CST whose numerical
value (extended according to TYPE_UNSIGNED) fits in a poly_uint64.

References wi::fits_uhwi_p(), ggc_alloc(), i, NULL_TREE, NUM_POLY_INT_COEFFS, POLY_INT_CST_COEFF, POLY_INT_CST_P, wi::to_widest(), and TREE_CODE.

Referenced by compute_record_mode(), gimple_add_tmp_var(), gimple_add_tmp_var_fn(), gimplify_asm_expr(), and poly_int_tree_p().

◆ tree_fits_shwi_p()

bool tree_fits_shwi_p ( const_tree t )

extern

The following predicates are safe to call with a null argument.

Return true if T is an INTEGER_CST whose numerical value (extended
according to TYPE_UNSIGNED) fits in a signed HOST_WIDE_INT.

References wi::fits_shwi_p(), ggc_alloc(), NULL_TREE, wi::to_widest(), and TREE_CODE.

Referenced by acceptable_pow_call(), add_src_coords_attributes(), add_subscript_strides(), analyze_and_compute_bitwise_induction_effect(), analyze_increments(), asan_expand_check_ifn(), bitpos_of_field(), check_omp_nesting_restrictions(), check_stmt_for_type_change(), compute_builtin_object_size(), cond_removal_in_builtin_zero_pattern(), constant_byte_string(), strlen_pass::count_nonzero_bytes_addr(), create_intersect_range_checks_index(), cst_and_fits_in_hwi(), dump_array_domain(), dump_generic_node(), dump_gimple_call_args(), expand_builtin_atomic_compare_exchange(), expand_builtin_eh_common(), expand_expr_real_2(), expr_with_var_bounded_array_refs_p(), extr_type_from_vtbl_ptr_store(), extract_muldiv_1(), field_at_offset(), fold_plusminus_mult_expr(), fortran_common(), fully_constant_vn_reference_p(), gcd_of_steps_may_divide_p(), get_stridx(), gimple_compare_field_offset(), gimple_fold_builtin_memory_op(), go_format_type(), go_output_typedef(), strlen_pass::handle_builtin_string_cmp(), has_mem_ref_been_instrumented(), instrument_mem_region_access(), int_expr_size(), is_comparison_with_loop_invariant_p(), is_lshift_by_1(), is_rshift_by_1(), loc_list_from_tree_1(), lower_omp_for_lastprivate(), make_bit_field_ref(), maybe_add_sra_candidate(), maybe_update_mem_ref_hash_table(), native_encode_initializer(), native_encode_string(), native_interpret_aggregate(), place_field(), possible_placement_new(), predict_iv_comparison(), prepare_call_arguments(), prepare_iteration_over_array_elts(), push_target_argument_according_to_value(), ipa_polymorphic_call_context::restrict_to_inner_class(), rtl_for_decl_init(), simd_clone_clauses_extract(), simplify_builtin_call(), simplify_rotate(), spaceship_replacement(), stmt_cost(), store_constructor(), strips_small_constant(), totally_scalarizable_type_p(), tree_add_const_value_attribute(), tree_to_shwi(), type_internals_preclude_sra_p_1(), vect_analyze_data_ref_accesses(), vect_analyze_group_access_1(), vect_analyze_loop_form(), vect_check_gather_scatter(), vect_recog_pow_pattern(), vect_simd_lane_linear(), vect_synth_mult_by_constant(), vectorizable_simd_clone_call(), vn_reference_fold_indirect(), vn_reference_lookup_3(), and vn_reference_maybe_forwprop_address().

◆ tree_fits_uhwi_p()

bool tree_fits_uhwi_p ( const_tree t )

extern

Return true if T is an INTEGER_CST whose numerical value (extended
according to TYPE_UNSIGNED) fits in an unsigned HOST_WIDE_INT.

References wi::fits_uhwi_p(), ggc_alloc(), NULL_TREE, wi::to_widest(), and TREE_CODE.

Referenced by add_abstract_origin_attribute(), add_data_member_location_attribute(), addr_object_size(), strlen_pass::adjust_last_stmt(), analyze_and_compute_bitop_with_inv_effect(), analyze_and_compute_bitwise_induction_effect(), asan_expand_mark_ifn(), bit_value_assume_aligned(), btf_collect_datasec(), build_tm_load(), build_tm_store(), build_user_friendly_ref_for_offset(), c_strlen(), categorize_ctor_elements_1(), check_access(), check_all_va_list_escapes(), tree_switch_conversion::switch_conversion::check_range(), check_strncat_sizes(), compare_tree_int(), compute_alias_check_pairs(), constant_byte_string(), convert_mult_to_highpart(), strlen_pass::count_nonzero_bytes(), count_type_elements(), create_expression_by_pieces(), create_ifn_alias_checks(), create_variable_info_for_1(), cst_and_fits_in_hwi(), default_use_anchors_for_symbol_p(), default_vector_alignment(), determine_block_size(), determine_known_aggregate_parts(), dump_generic_node(), dw_sra_loc_expr(), early_object_sizes_execute_one(), evaluate_stmt(), tree_switch_conversion::switch_conversion::expand(), expand_builtin_eh_return_data_regno(), expand_builtin_frame_address(), expand_builtin_memory_chk(), expand_builtin_memset_args(), expand_builtin_strncpy(), expand_constructor(), expand_DEFERRED_INIT(), expand_expr_real_1(), expand_omp_scantemp_alloc(), expand_omp_simd(), expand_vector_divmod(), expr_expected_value_1(), field_at_offset(), final_value_replacement_loop(), find_atomic_core_type(), finish_bitfield_layout(), finish_bitfield_representative(), fold_builtin_alloca_with_align(), fold_builtin_memcmp(), fold_const_aggregate_ref_1(), fold_read_from_constant_string(), fold_ternary_loc(), fold_unary_loc(), get_block_for_decl(), get_constraint_for_1(), get_inner_reference(), strlen_pass::get_len_or_size(), get_mem_align_offset(), get_narrower(), get_size_range(), get_stridx_plus_constant(), get_vec_alignment_for_record_type(), getbyterep(), gimple_fold_builtin_memchr(), gimple_fold_builtin_memory_op(), gimple_fold_builtin_memset(), gimple_fold_builtin_strcat_chk(), gimple_fold_builtin_string_compare(), gimple_fold_indirect_ref(), gimple_fold_partial_load_store_mem_ref(), go_output_typedef(), strlen_pass::handle_builtin_memcmp(), strlen_pass::handle_builtin_memcpy(), strlen_pass::handle_pointer_plus(), handle_printf_call(), strlen_pass::handle_store(), hoist_adjacent_loads(), init_offset_limit(), initialize_ao_ref_for_dse(), initialize_data_dependence_relation(), initializer_zerop(), inline_expand_builtin_bytecmp(), instrument_builtin_call(), instrument_expr(), int_size_in_bytes(), interpret_rhs_expr(), is_aligning_offset(), loc_list_from_tree_1(), locate_and_pad_parm(), lower_builtin_assume_aligned(), lower_vec_perm(), max_int_size_in_bytes(), maybe_emit_sprintf_chk_warning(), maybe_invalidate(), maybe_trim_memstar_call(), mode_for_size_tree(), native_encode_initializer(), native_interpret_aggregate(), nonzero_bytes_for_type(), not_size_aligned(), object_sizes_execute(), loop_distribution::pg_add_dependence_edges(), place_field(), predict_loops(), push_fields_onto_fieldstack(), ref_at_iteration(), ipa_polymorphic_call_context::restrict_to_inner_class(), ipa_icf_gimple::func_checker::safe_for_total_scalarization_p(), self_reuse_distance(), simple_type_size_in_bits(), simplify_builtin_call(), simplify_rotate(), size_t_cst_p(), sra_modify_expr(), stack_protect_classify_type(), store_constructor(), target_char_cst_p(), tm_log_add(), tm_log_emit_stmt(), tree_add_const_value_attribute(), tree_ctz(), tree_to_uhwi(), try_unroll_loop_completely(), type_internals_preclude_sra_p_1(), type_like_member_ptr_p(), ubsan_type_descriptor(), va_list_counter_bump(), valid_constant_size_p(), vect_analyze_data_ref_accesses(), vect_find_stmt_data_reference(), vect_get_smallest_scalar_type(), vect_peel_nonlinear_iv_init(), vect_recog_bit_insert_pattern(), vect_recog_bitfield_ref_pattern(), vect_recog_rotate_pattern(), vector_element(), vectorizable_nonlinear_induction(), verify_gimple_assign_ternary(), visit_nary_op(), and vn_reference_lookup_3().

◆ tree_floor_log2()

int tree_floor_log2 ( const_tree expr )

extern

Similar, but return the largest integer Y such that 2 ** Y is less
than or equal to EXPR.

References wi::floor_log2(), ggc_alloc(), wi::to_wide(), TREE_CODE, tree_log2(), and TREE_REALPART.

Referenced by do_jump(), inverse(), and tree_int_cst_min_precision().

◆ tree_inlined_location()

location_t tree_inlined_location	(	tree	exp,
		bool	system_header )

extern

Return the location into which EXP has been inlined.  Analogous
to tree_nonartificial_location() above but not limited to artificial
functions declared inline.  If SYSTEM_HEADER is true, return
the macro expansion point of the location if it's in a system header

References BLOCK_ABSTRACT_ORIGIN, BLOCK_SOURCE_LOCATION, BLOCK_SUPERCONTEXT, exp(), expansion_point_location_if_in_system_header(), EXPR_LOCATION, ggc_alloc(), TREE_BLOCK, TREE_CODE, and UNKNOWN_LOCATION.

◆ tree_int_cst_compare()

int tree_int_cst_compare	(	const_tree	t1,
		const_tree	t2 )

inline

Returns -1 if T1 < T2, 0 if T1 == T2, and 1 if T1 > T2.  T1 and T2
are both INTEGER_CSTs and their values are extended according to their
respective TYPE_SIGNs.

References wi::cmps(), and wi::to_widest().

Referenced by cluster_cmp(), compare_case_labels(), compare_step_with_zero(), compare_values_warnv(), create_intersect_range_checks_index(), data_ref_compare_tree(), find_case_label_for_value(), find_case_label_index(), find_case_label_ranges(), fold_comparison(), get_misalign_in_elems(), gimple_fold_builtin_strncat(), idx_infer_loop_bounds(), label_cmp(), maybe_optimize_ubsan_null_ifn(), object_sizes_set(), preprocess_case_label_vec_for_gimple(), range_cmp(), simplify_using_ranges::simplify_switch_using_ranges(), size_for_offset(), vect_analyze_data_ref_access(), vect_analyze_group_access_1(), vect_compile_time_alias(), vect_create_cond_for_align_checks(), vect_enhance_data_refs_alignment(), vect_gen_prolog_loop_niters(), vect_get_peeling_costs_all_drs(), and vect_setup_realignment().

◆ tree_int_cst_equal()

bool tree_int_cst_equal	(	const_tree	t1,
		const_tree	t2 )

extern

Arguments may be null.

True if integer constants T1 and T2
represent the same constant value.

References ggc_alloc(), STRIP_ANY_LOCATION_WRAPPER, wi::to_widest(), and TREE_CODE.

Referenced by adjacent_dr_p(), arith_overflow_check_p(), tree_switch_conversion::switch_conversion::build_constructors(), byte_from_pos(), c_strlen(), check_out_of_bounds_and_warn(), check_strncat_sizes(), coalesce_bitint(), tree_switch_conversion::switch_conversion::collect(), compare_constant(), ipa_icf_gimple::func_checker::compare_gimple_switch(), component_ref_size(), compute_optimized_partition_bases(), constant_byte_string(), convert_to_integer_1(), convert_to_vector(), type_cache_hasher::equal(), ipa_icf::sem_variable::equals(), expand_DEFERRED_INIT(), expand_expr_real_1(), expand_omp_atomic_cas(), expand_omp_for_static_chunk(), fold_convert_loc(), fold_convertible_p(), fold_relational_const(), get_inner_reference(), gimple_compare_field_offset(), gimple_fold_builtin_memory_op(), gimple_fold_indirect_ref(), gimple_lower_bitint(), internal_gather_scatter_fn_supported_p(), ipa_get_stmt_member_ptr_load_param(), tree_switch_conversion::simple_cluster::is_single_value_p(), is_value_included_in(), make_range_step(), maybe_canonicalize_comparison_1(), maybe_warn_for_bound(), maybe_warn_nonstring_arg(), merge_ranges(), nonoverlapping_array_refs_p(), nonoverlapping_component_refs_p_1(), nonoverlapping_refs_since_match_p(), omp_adjust_for_condition(), operand_compare::operand_equal_p(), optimize_range_tests_cmp_bitwise(), optimize_range_tests_diff(), optimize_range_tests_xor(), pos_from_bit(), preprocess_case_label_vec_for_gimple(), rt_bb_visited::push_rtcfg_pair(), simple_iv_with_niters(), simplify_using_ranges::simplify_switch_using_ranges(), ana::bounded_range::singleton_p(), size_diffop_loc(), split_loop(), store_kills_ref_p(), subrange_type_for_debug_p(), try_transform_to_exit_first_loop_alt(), useless_type_conversion_p(), value_replacement(), vect_analyze_data_ref_accesses(), vect_find_stmt_data_reference(), vn_reference_lookup_3(), and warn_for_access().

◆ tree_int_cst_le()

bool tree_int_cst_le	(	const_tree	t1,
		const_tree	t2 )

inline

Return true if INTEGER_CST T1 is less than or equal to INTEGER_CST T2,
extending both according to their respective TYPE_SIGNs.

References wi::to_widest().

Referenced by check_access(), if_chain::check_non_overlapping_cases(), check_out_of_bounds_and_warn(), gimple_fold_call(), strlen_pass::handle_builtin_memcpy(), strlen_pass::handle_builtin_strlen(), inbounds_memaccess_p(), instrument_object_size(), is_value_included_in(), maybe_canonicalize_mem_ref_addr(), maybe_optimize_mod_cmp(), maybe_optimize_ubsan_null_ifn(), maybe_warn_for_bound(), and value_replacement().

◆ tree_int_cst_lt()

bool tree_int_cst_lt	(	const_tree	t1,
		const_tree	t2 )

inline

Return true if INTEGER_CST T1 is less than INTEGER_CST T2,
extending both according to their respective TYPE_SIGNs.

References wi::to_widest().

Referenced by addr_object_size(), strlen_pass::adjust_last_stmt(), array_size_for_constructor(), tree_switch_conversion::switch_conversion::build_constructors(), can_remove_asan_check(), check_access(), check_out_of_bounds_and_warn(), check_strncat_sizes(), component_ref_sam_type(), create_iv(), default_cxx_get_cookie_size(), expand_builtin_memory_chk(), expand_builtin_strcmp(), expand_builtin_strncmp(), expand_builtin_strncpy(), expand_case(), extract_bit_test_mask(), find_loop_niter(), find_loop_niter_by_eval(), fold_binary_loc(), fold_relational_const(), get_array_ctor_element_at_index(), get_range_strlen_dynamic(), get_range_strlen_phi(), get_range_strlen_tree(), gimple_fold_builtin_strncpy(), gimple_fold_call(), gimple_verify_flow_info(), strlen_pass::handle_builtin_strlen(), in_array_bounds_p(), inbounds_memaccess_p(), instrument_object_size(), int_fits_type_p(), is_value_included_in(), layout_type(), make_range_step(), may_eliminate_iv(), maybe_warn_for_bound(), maybe_warn_nonstring_arg(), omp_extract_for_data(), range_in_array_bounds_p(), simplify_builtin_call(), simplify_using_ranges::simplify_div_or_mod_using_ranges(), size_diffop_loc(), spaceship_replacement(), value_replacement(), vect_is_simple_cond(), vect_transform_cycle_phi(), vectorizable_reduction(), verify_gimple_switch(), and vn_reference_may_trap().

◆ tree_int_cst_min_precision()

unsigned int tree_int_cst_min_precision	(	tree	value,
		signop	sgn )

extern

Return the minimum number of bits needed to represent VALUE in a
signed or unsigned type, UNSIGNEDP says which.

References fold_build1, ggc_alloc(), integer_zerop(), SIGNED, tree_floor_log2(), tree_int_cst_sgn(), and TREE_TYPE.

Referenced by tree_binary_nonnegative_warnv_p().

◆ tree_int_cst_sgn()

int tree_int_cst_sgn ( const_tree t )

extern

Return an indication of the sign of the integer constant T.
The return value is -1 if T < 0, 0 if T == 0, and 1 if T > 0.
Note that -1 will never be returned if T's type is unsigned.

References wi::neg_p(), wi::to_wide(), TREE_TYPE, and TYPE_UNSIGNED.

Referenced by bitint_min_cst_precision(), chrec_apply(), chrec_is_positive(), compare_tree_int(), compute_object_offset(), convert_to_integer_1(), dr_step_indicator(), dump_generic_node(), expand_builtin_object_size(), expand_omp_for_generic(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), expand_omp_ordered_sink(), expand_omp_simd(), expand_omp_taskloop_for_inner(), expand_omp_taskloop_for_outer(), expand_vector_divmod(), extract_bit_test_mask(), extract_muldiv_1(), fold_binary_loc(), fold_builtin_object_size(), fold_comparison(), fold_div_compare(), get_range_strlen_tree(), go_format_type(), instrument_object_size(), maybe_canonicalize_comparison_1(), maybe_optimize_mod_cmp(), maybe_optimize_pow2p_mod_cmp(), output_constant(), prune_runtime_alias_test_list(), return_prediction(), simplify_using_ranges::simplify_div_or_mod_using_ranges(), tree_binary_nonnegative_warnv_p(), tree_ctz(), tree_int_cst_min_precision(), tree_single_nonnegative_warnv_p(), valid_constant_size_p(), vect_create_data_ref_ptr(), vect_dr_misalign_for_aligned_access(), vect_get_data_ptr_increment(), vect_recog_divmod_pattern(), vectorizable_load(), and vectorizable_reduction().

◆ tree_int_cst_sign_bit()

int tree_int_cst_sign_bit ( const_tree t )

extern

Return the most significant (sign) bit of T.

References wi::extract_uhwi(), ggc_alloc(), wi::to_wide(), TREE_TYPE, and TYPE_PRECISION.

Referenced by create_intersect_range_checks_index(), derive_constant_upper_bound_ops(), derive_simple_iv_with_niters(), determine_exit_conditions(), get_cst_init_from_scev(), idx_infer_loop_bounds(), loop_exits_before_overflow(), multiple_of_p(), number_of_iterations_cond(), number_of_iterations_lt(), number_of_iterations_ne(), number_of_iterations_until_wrap(), record_nonwrapping_iv(), scev_direction(), scev_var_range_cant_overflow(), simple_iv_with_niters(), split_at_bb_p(), split_loop(), and warn_for_access().

◆ tree_invariant_p()

bool tree_invariant_p ( tree t )

extern

Return true if T is function-invariant.

References skip_simple_arithmetic(), and tree_invariant_p_1().

Referenced by skip_simple_arithmetic(), stabilize_reference_1(), and tree_invariant_p_1().

◆ tree_last()

tree tree_last ( tree chain )

extern

Return the last tree node in a chain.

Return the last node in a chain of nodes (chained through TREE_CHAIN).

References TREE_CHAIN.

Referenced by build_adjusted_function_type(), and fold_builtin_next_arg().

◆ tree_log2()

int tree_log2 ( const_tree expr )

extern

Return the power of two represented by a tree node known to be a
power of two.

References wi::exact_log2(), ggc_alloc(), wi::to_wide(), TREE_CODE, tree_log2(), and TREE_REALPART.

Referenced by expand_mul_overflow(), expand_vector_divmod(), fold_ternary_loc(), number_of_iterations_cltz(), optimize_atomic_bit_test_and(), recognize_single_bit_test(), simplify_using_ranges::simplify_div_or_mod_using_ranges(), tree_ctz(), tree_floor_log2(), tree_log2(), ubsan_expand_null_ifn(), and vect_recog_divmod_pattern().

◆ tree_map_base_eq()

int tree_map_base_eq	(	const void *	va,
		const void *	vb )

extern

Return true if the from tree in both tree maps are equal.

References a, b, and ggc_alloc().

◆ tree_map_base_hash()

unsigned int tree_map_base_hash ( const void * item )

extern

Hash a from tree in a tree_base_map.

References ggc_alloc().

◆ tree_map_base_marked_p()

bool tree_map_base_marked_p ( const void * p )

extern

Return true if this tree map structure is marked for garbage collection
purposes.  We simply return true if the from tree is marked, so that this
structure goes away when the from tree goes away.

References ggc_alloc(), and ggc_marked_p().

◆ tree_map_hash()

unsigned int tree_map_hash ( const void * item )

extern

Hash a from tree in a tree_map.

Referenced by tm_clone_hasher::hash(), and move_sese_region_to_fn().

◆ tree_node_structure()

enum tree_node_structure_enum tree_node_structure ( const_tree t )

Return which tree structure is used by T.

References TREE_CODE, and tree_node_structure_for_code().

◆ tree_nonartificial_location()

location_t tree_nonartificial_location ( tree exp )

extern

If EXP is inlined from an __attribute__((__artificial__))
function, return the location of the original call expression.

References block_nonartificial_location(), exp(), EXPR_LOCATION, ggc_alloc(), and TREE_BLOCK.

Referenced by gimple_or_expr_nonartificial_location().

◆ tree_nop_conversion_p()

bool tree_nop_conversion_p	(	const_tree	outer_type,
		const_tree	inner_type )

extern

Return true iff conversion from INNER_TYPE to OUTER_TYPE generates
no instruction.

References ADDR_SPACE_GENERIC, ggc_alloc(), INTEGRAL_TYPE_P, POINTER_TYPE_P, TREE_CODE, TREE_TYPE, TYPE_ADDR_SPACE, TYPE_MODE, and TYPE_PRECISION.

Referenced by bitwise_equal_p(), bitwise_inverted_equal_p(), check_reduction_path(), chrec_fold_multiply(), chrec_fold_plus_1(), expr_to_aff_combination(), scev_dfs::follow_ssa_edge_expr(), get_load_store_type(), gimple_bitwise_equal_p(), gimple_bitwise_inverted_equal_p(), gimple_nop_conversion_p(), operand_compare::operand_equal_p(), optimize_atomic_op_fetch_cmp_0(), simple_iv_with_niters(), strip_nop_cond_scalar_reduction(), tree_builtin_call_types_compatible_p(), tree_nop_conversion(), vect_nop_conversion_p(), vectorizable_assignment(), vectorizable_nonlinear_induction(), vectorizable_operation(), vectorizable_reduction(), vectorizable_shift(), and verify_gimple_assign_ternary().

◆ tree_operand_length()

int tree_operand_length ( const_tree node )

inline

Compute the number of operands in an expression node NODE.  For
tcc_vl_exp nodes like CALL_EXPRs, this is stored in the node itself,
otherwise it is looked up from the node's code.

References TREE_CODE, TREE_CODE_LENGTH, VL_EXP_CLASS_P, and VL_EXP_OPERAND_LENGTH.

◆ tree_set_block()

void tree_set_block	(	tree	t,
		tree	b )

extern

◆ tree_size()

size_t tree_size ( const_tree node )

extern

Compute the number of bytes occupied by 'node'.  This routine only
looks at TREE_CODE and, if the code is TREE_VEC, TREE_VEC_LENGTH.

Compute the number of bytes occupied by NODE.  This routine only
looks at TREE_CODE, except for those nodes that have variable sizes.

References BINFO_N_BASE_BINFOS, ggc_alloc(), offsetof, OMP_CLAUSE_CODE, omp_clause_num_ops, tcc_vl_exp, TREE_CODE, TREE_CODE_CLASS, tree_code_size(), TREE_INT_CST_EXT_NUNITS, TREE_STRING_LENGTH, TREE_VEC_LENGTH, vector_cst_encoded_nelts(), and VL_EXP_OPERAND_LENGTH.

Referenced by copy_node(), free_node(), optimize_load_redistribution_1(), release_ssa_name_fn(), vect_build_slp_instance(), vect_build_slp_tree(), and vect_build_slp_tree_2().

◆ tree_strip_any_location_wrapper()

tree tree_strip_any_location_wrapper ( tree exp )

inline

Implementation of STRIP_ANY_LOCATION_WRAPPER.

References exp(), location_wrapper_p(), and TREE_OPERAND.

Referenced by convert_to_integer_1(), and size_binop_loc().

◆ tree_strip_nop_conversions()

tree tree_strip_nop_conversions ( tree exp )

extern

Strip conversions from EXP according to tree_nop_conversion and
return the resulting expression.

References exp(), tree_nop_conversion(), and TREE_OPERAND.

◆ tree_strip_sign_nop_conversions()

tree tree_strip_sign_nop_conversions ( tree exp )

extern

Strip conversions from EXP according to tree_sign_nop_conversion
and return the resulting expression.

References exp(), TREE_OPERAND, and tree_sign_nop_conversion().

◆ tree_to_poly_int64()

poly_int64 tree_to_poly_int64 ( const_tree t )

extern

Referenced by address_compare(), ipcp_modif_dom_walker::before_dom_children(), component_ref_size(), convert_mult_to_fma(), get_reassociation_width(), ipcp_get_aggregate_const(), load_from_unmodified_param_or_agg(), poly_int_tree_p(), tree_to_vec_perm_builder(), unmodified_parm_1(), and vn_reference_lookup_3().

◆ tree_to_poly_uint64()

◆ tree_to_shwi()

HOST_WIDE_INT tree_to_shwi ( const_tree t )

extern

T is an INTEGER_CST whose numerical value (extended according to
TYPE_UNSIGNED) fits in a signed HOST_WIDE_INT.  Return that
HOST_WIDE_INT.

References gcc_assert, tree_fits_shwi_p(), and TREE_INT_CST_LOW.

Referenced by acceptable_pow_call(), add_data_member_location_attribute(), add_prototyped_attribute(), add_src_coords_attributes(), add_subscript_strides(), adjusted_warn_limit(), alloca_call_type(), analyze_and_compute_bitwise_induction_effect(), analyze_increments(), asan_expand_check_ifn(), asan_expand_mark_ifn(), bitpos_of_field(), build_agg_jump_func_from_list(), build_fn_info(), cache_integer_cst(), check_all_va_list_escapes(), check_ctz_array(), check_omp_nesting_restrictions(), check_stmt_for_type_change(), check_ts_and_push_padding_to_vec(), clear_padding_type(), clear_padding_union(), cond_removal_in_builtin_zero_pattern(), constant_byte_string(), strlen_pass::count_nonzero_bytes_addr(), create_access(), create_intersect_range_checks_index(), decode_addr_const(), dump_array_domain(), dump_generic_node(), dump_gimple_call_args(), emit_case_dispatch_table(), expand_builtin_atomic_compare_exchange(), expand_builtin_eh_common(), expand_builtin_object_size(), expand_call_mem_ref(), expand_expr_real_2(), expand_gather_load_optab_fn(), expand_HWASAN_MARK(), expand_ifn_atomic_compare_exchange(), expand_scatter_store_optab_fn(), extr_type_from_vtbl_ptr_store(), extract_muldiv_1(), field_at_offset(), fold_builtin_object_size(), fold_plusminus_mult_expr(), fortran_common(), fully_constant_vn_reference_p(), gcd_of_steps_may_divide_p(), get_binfo_at_offset(), get_references_in_stmt(), get_stridx(), gimple_fold_indirect_ref(), gimplify_adjust_omp_clauses(), gimplify_omp_for(), go_format_type(), go_output_typedef(), strlen_pass::handle_builtin_string_cmp(), has_mem_ref_been_instrumented(), access_ref::inform_access(), instrument_mem_region_access(), int_byte_position(), int_expr_size(), ipa_analyze_call_uses(), is_lshift_by_1(), is_rshift_by_1(), layout_decl(), loc_list_from_tree_1(), lookup_binfo_at_offset(), lower_omp_for_lastprivate(), make_bit_field_ref(), mark_reachable_handlers(), maybe_add_sra_candidate(), maybe_optimize_ubsan_null_ifn(), maybe_update_mem_ref_hash_table(), ipa_param_body_adjustments::modify_assignment(), ipa_param_body_adjustments::modify_expression(), move_sese_region_to_fn(), move_stmt_eh_region_tree_nr(), native_encode_initializer(), native_encode_string(), native_interpret_aggregate(), omp_extract_for_data(), optimize_count_trailing_zeroes(), output_constant(), output_constructor_array_range(), place_field(), predict_loops(), prepare_call_arguments(), prepare_iteration_over_array_elts(), propagate_aggregate_lattice(), propagate_aggs_across_jump_function(), push_target_argument_according_to_value(), record_targets_from_bases(), remap_eh_region_tree_nr(), replace_loop_annotate(), replace_loop_annotate_in_block(), ipa_polymorphic_call_context::restrict_to_inner_class(), rt_bb_visited::rt_bb_visited(), rtl_for_decl_init(), set_uid_loop_bbs(), simd_clone_clauses_extract(), simplify_builtin_call(), simplify_count_trailing_zeroes(), simplify_rotate(), spaceship_replacement(), stmt_cost(), store_constructor(), strips_small_constant(), totally_scalarizable_type_p(), tree_add_const_value_attribute(), try_vectorize_loop_1(), vect_analyze_data_ref_accesses(), vect_analyze_group_access_1(), vect_analyze_loop_form(), vect_check_gather_scatter(), vect_loop_dist_alias_call(), vect_loop_vectorized_call(), vect_recog_ctz_ffs_pattern(), vect_recog_popcount_clz_ctz_ffs_pattern(), vect_recog_pow_pattern(), vect_simd_lane_linear(), vect_synth_mult_by_constant(), vectorizable_simd_clone_call(), vn_reference_fold_indirect(), vn_reference_lookup_3(), and vn_reference_maybe_forwprop_address().

◆ tree_to_uhwi()

unsigned HOST_WIDE_INT tree_to_uhwi ( const_tree t )

extern

T is an INTEGER_CST whose numerical value (extended according to
TYPE_UNSIGNED) fits in an unsigned HOST_WIDE_INT.  Return that
HOST_WIDE_INT.

References gcc_assert, tree_fits_uhwi_p(), and TREE_INT_CST_LOW.

Referenced by add_abstract_origin_attribute(), add_data_member_location_attribute(), add_decls_addresses_to_decl_constructor(), strlen_pass::adjust_last_stmt(), alloca_call_type(), analyze_all_variable_accesses(), analyze_and_compute_bitop_with_inv_effect(), analyze_and_compute_bitwise_induction_effect(), asan_add_global(), asan_expand_mark_ifn(), asan_expand_poison_ifn(), asan_mark_p(), assemble_noswitch_variable(), assemble_variable(), assemble_variable_contents(), bit_value_assume_aligned(), btf_collect_datasec(), build_tm_load(), build_tm_store(), build_user_friendly_ref_for_offset(), c_strlen(), cache_integer_cst(), categorize_ctor_elements_1(), check_all_va_list_escapes(), tree_switch_conversion::switch_conversion::check_range(), check_string_literal(), clear_padding_type(), compute_alias_check_pairs(), compute_object_offset(), constant_byte_string(), convert_mult_to_highpart(), strlen_pass::count_nonzero_bytes(), count_type_elements(), create_expression_by_pieces(), create_ifn_alias_checks(), cgraph_node::create_indirect_edge(), create_task_copyfn(), tree_switch_conversion::switch_conversion::create_temp_arrays(), create_variable_info_for_1(), default_use_anchors_for_symbol_p(), default_vector_alignment(), determine_block_size(), determine_known_aggregate_parts(), dump_generic_node(), dw_sra_loc_expr(), early_object_sizes_execute_one(), eliminate_dom_walker::eliminate_stmt(), tree_switch_conversion::bit_test_cluster::emit(), emit_case_dispatch_table(), evaluate_stmt(), excess_unit_span(), execute_omp_oacc_neuter_broadcast(), execute_update_addresses_taken(), tree_switch_conversion::switch_conversion::expand(), expand_builtin_eh_return_data_regno(), expand_builtin_frame_address(), expand_builtin_memset_args(), expand_builtin_strncpy(), expand_constructor(), expand_DEFERRED_INIT(), expand_expr_real_2(), expand_ifn_atomic_op_fetch_cmp_0(), expand_omp_atomic(), expand_omp_for_generic(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), expand_omp_scantemp_alloc(), expand_omp_sections(), expand_omp_simd(), expand_single_bit_test(), expand_vector_conversion(), expand_vector_divmod(), expand_vector_parallel(), expand_vector_piecewise(), expand_vector_ubsan_overflow(), expr_expected_value_1(), extract_bit_test_mask(), field_at_offset(), final_value_replacement_loop(), find_atomic_core_type(), finish_bitfield_representative(), fold_builtin_alloca_with_align(), fold_builtin_memcmp(), fold_const_aggregate_ref_1(), fold_indirect_ref_1(), fold_ternary_loc(), fold_unary_loc(), pass_walloca::gate(), gen_ctf_base_type(), get_binfo_at_offset(), get_bit_range(), get_constraint_for_1(), get_inner_reference(), strlen_pass::get_len_or_size(), get_mem_align_offset(), get_narrower(), get_stridx_plus_constant(), get_ubsan_type_info_for_type(), get_vec_alignment_for_record_type(), getbyterep(), gimple_fold_builtin_memchr(), gimple_fold_builtin_memory_op(), gimple_fold_builtin_memset(), gimple_fold_builtin_string_compare(), gimple_fold_indirect_ref(), gimple_fold_partial_load_store_mem_ref(), gimple_get_alias_set(), gimple_get_virt_method_for_vtable(), gimple_lower_bitint(), gimplify_bind_expr(), go_output_typedef(), handle_builtin_alloca(), strlen_pass::handle_builtin_memcmp(), strlen_pass::handle_builtin_memcpy(), strlen_pass::handle_pointer_plus(), handle_printf_call(), strlen_pass::handle_store(), hoist_adjacent_loads(), init_eh(), init_offset_limit(), initialize_data_dependence_relation(), initializer_zerop(), inline_expand_builtin_bytecmp(), instrument_builtin_call(), instrument_expr(), interpret_rhs_expr(), ipa_analyze_virtual_call_uses(), ipa_print_node_jump_functions_for_edge(), is_aligning_offset(), iv_period(), loc_list_from_tree_1(), locate_and_pad_parm(), lower_lastprivate_clauses(), lower_omp_target(), lower_private_allocate(), max_int_size_in_bytes(), maybe_invalidate(), maybe_trim_memstar_call(), mode_for_size_tree(), native_encode_initializer(), native_encode_int(), native_interpret_aggregate(), native_interpret_int(), native_interpret_vector_part(), non_rewritable_lvalue_p(), nonfreeing_call_p(), nonzero_bytes_for_type(), not_size_aligned(), number_of_iterations_cltz(), number_of_iterations_cltz_complement(), number_of_iterations_ne(), number_of_iterations_popcount(), oacc_do_neutering(), oacc_xform_tile(), object_sizes_execute(), omp_accumulate_sibling_list(), omp_build_struct_sibling_lists(), omp_construct_simd_compare(), omp_group_base(), omp_group_last(), operand_compare::operand_equal_p(), optimize_atomic_bit_test_and(), optimize_count_trailing_zeroes(), optimize_range_tests_to_bit_test(), output_constructor_bitfield(), output_constructor_regular_field(), output_object_block(), place_block_symbol(), place_field(), possible_placement_new(), possible_polymorphic_call_target_p(), possible_polymorphic_call_targets(), predict_loops(), print_no_sanitize_attr_value(), push_fields_onto_fieldstack(), ref_at_iteration(), ipa_polymorphic_call_context::restrict_to_inner_class(), ipa_icf_gimple::func_checker::safe_for_total_scalarization_p(), self_reuse_distance(), simd_clone_adjust(), simd_clone_clauses_extract(), simd_clone_init_simd_arrays(), simple_type_size_in_bits(), simplify_builtin_call(), simplify_rotate(), size_t_cst_p(), sort_by_size_then_ssa_version_or_uid(), sort_size_descending(), sra_modify_expr(), stack_protect_classify_type(), store_constructor(), target_char_cst_p(), task_reduction_read(), tm_log_add(), tm_log_emit_stmt(), totally_scalarize_subtree(), tree_add_const_value_attribute(), tree_ctz(), tree_profiling(), try_unroll_loop_completely(), ubsan_expand_null_ifn(), ubsan_expand_vptr_ifn(), ubsan_type_descriptor(), undistribute_bitref_for_vector(), va_list_counter_bump(), vect_add_slp_permutation(), vect_analyze_data_ref_accesses(), vect_create_epilog_for_reduction(), vect_create_partial_epilog(), vect_expand_fold_left(), vect_find_stmt_data_reference(), vect_gather_scatter_fn_p(), vect_get_scalar_dr_size(), vect_model_reduction_cost(), vect_peel_nonlinear_iv_init(), vect_recog_bit_insert_pattern(), vect_recog_bitfield_ref_pattern(), vect_recog_rotate_pattern(), vect_vfa_access_size(), vector_element_bits(), vectorizable_live_operation(), vectorizable_live_operation_1(), vectorizable_load(), vectorizable_nonlinear_induction(), vectorizable_simd_clone_call(), vectorizable_store(), verify_gimple_assign_ternary(), visit_nary_op(), vn_reference_lookup_3(), vtable_pointer_value_to_vtable(), warn_for_access(), and widen_memory_access().

◆ tree_zero_one_valued_p()

bool tree_zero_one_valued_p ( tree )

extern

Referenced by match_uaddc_usubc(), and validate_test_and_branch().

◆ truth_type_for()

tree truth_type_for ( tree type )

extern

If TYPE is a vector type, return a signed integer vector type with the
same width and number of subparts. Otherwise return boolean_type_node.

References boolean_type_node, build_truth_vector_type_for(), ggc_alloc(), TREE_CODE, type(), and VECTOR_BOOLEAN_TYPE_P.

Referenced by and_comparisons_1(), build_mask_conversion(), expand_vector_divmod(), get_mask_type_for_scalar_type(), get_mask_type_for_scalar_type(), get_same_sized_vectype(), or_comparisons_1(), scan_store_can_perm_p(), vect_create_epilog_for_reduction(), vect_get_loop_mask(), vect_get_vec_defs_for_operand(), vect_is_simple_cond(), vect_recog_bitfield_ref_pattern(), vect_recog_gather_scatter_pattern(), vect_recog_gcond_pattern(), vect_transform_reduction(), vect_verify_full_masking(), vect_verify_full_masking_avx512(), vectorizable_condition(), vectorizable_load(), vectorizable_operation(), vectorizable_reduction(), vectorizable_scan_store(), vectorizable_store(), and vectorize_fold_left_reduction().

◆ truth_value_p()

bool truth_value_p ( enum tree_code code )

inline

Return nonzero if CODE is a tree code that represents a truth value.

References ggc_alloc(), tcc_comparison, and TREE_CODE_CLASS.

Referenced by canonicalize_cond_expr_cond(), find_func_aliases(), fold_binary_loc(), fold_ternary_loc(), gimple_boolify(), lower_rec_simd_input_clauses(), and tree_simple_nonnegative_warnv_p().

◆ type_argument_type()

tree type_argument_type	(	const_tree	fntype,
		unsigned	argno )

extern

Return the type of the function TYPE's argument ARGNO if known.
For vararg function's where ARGNO refers to one of the variadic
arguments return null.  Otherwise, return a void_type_node for
out-of-bounds ARGNO.

References FOREACH_FUNCTION_ARGS, ggc_alloc(), i, NULL_TREE, void_type_node, and VOID_TYPE_P.

◆ type_contains_placeholder_p()

bool type_contains_placeholder_p ( tree type )

extern

Return true if any part of the structure of TYPE involves a PLACEHOLDER_EXPR
directly.  This includes size, bounds, qualifiers (for QUAL_UNION_TYPE) and
field positions.

Wrapper around above function used to cache its result.

References type_contains_placeholder_1(), and TYPE_CONTAINS_PLACEHOLDER_INTERNAL.

Referenced by create_variable_info_for_1(), fold(), fold_ternary_loc(), totally_scalarizable_type_p(), and type_contains_placeholder_1().

◆ type_has_mode_precision_p()

bool type_has_mode_precision_p ( const_tree t )

inline

Return true if type T has the same precision as its underlying mode.

References GET_MODE_PRECISION(), known_eq, TYPE_MODE, and TYPE_PRECISION.

Referenced by add_iv_candidate_for_use(), convert_mult_to_fma(), convert_plusminus_to_widen(), convert_to_integer_1(), eliminate_dom_walker::eliminate_stmt(), expand_expr_real_1(), expand_expr_real_2(), expand_single_bit_test(), gimple_fold_builtin_memset(), maybe_rewrite_mem_ref_base(), non_rewritable_mem_ref_base(), process_assignment(), simplify_rotate(), loop_distribution::transform_reduction_loop(), vect_recog_ctz_ffs_pattern(), vect_recog_divmod_pattern(), vect_recog_mult_pattern(), vect_recog_popcount_clz_ctz_ffs_pattern(), vect_recog_vector_vector_shift_pattern(), vectorizable_assignment(), vectorizable_conversion(), vectorizable_induction(), vectorizable_operation(), vectorizable_reduction(), vectorizable_shift(), verify_gimple_assign_ternary(), verify_types_in_gimple_reference(), and vn_reference_lookup_3().

◆ type_hash_canon()

tree type_hash_canon	(	unsigned int	hashcode,
		tree	type )

extern

Given TYPE, and HASHCODE its hash code, return the canonical
object for an identical type if one already exists.
Otherwise, return TYPE, and record it as the canonical object.

To use this function, first create a type of the sort you want.
Then compute its hash code from the fields of the type that
make it different from other similar types.
Then call this function and use the value.

References free_node(), gcc_assert, ggc_alloc(), ggc_free(), type_hash::hash, int_cst_hash_table, layout_type(), next_type_uid, TREE_CODE, TREE_TYPE, type(), type_hash::type, TYPE_CACHED_VALUES, TYPE_CACHED_VALUES_P, type_hash_table, TYPE_MAIN_VARIANT, TYPE_MAX_VALUE, TYPE_MIN_VALUE, TYPE_UID, and TYPE_UNSIGNED.

Referenced by build_array_type_1(), build_bitint_type(), build_complex_type(), build_function_type(), build_method_type_directly(), build_nonstandard_integer_type(), build_offset_type(), build_range_type_1(), build_type_attribute_qual_variant(), and make_vector_type().

◆ type_hash_canon_hash()

hashval_t type_hash_canon_hash ( tree type )

extern

Given a hashcode and a ..._TYPE node (for which the hashcode was made),
return a canonicalized ..._TYPE node, so that duplicates are not made.
How the hash code is computed is up to the caller, as long as any two
callers that could hash identical-looking type nodes agree.

Hashing of types so that we don't make duplicates.
The entry point is `type_hash_canon'.

Generate the default hash code for TYPE.  This is designed for
speed, rather than maximum entropy.

References AGGREGATE_TYPE_P, error_mark_node, get_attribute_name(), ggc_alloc(), i, IDENTIFIER_HASH_VALUE, TREE_CHAIN, TREE_CODE, TREE_INT_CST_ELT, TREE_INT_CST_NUNITS, TREE_TYPE, TREE_VALUE, TYPE_ARG_TYPES, TYPE_ATTRIBUTES, TYPE_DOMAIN, TYPE_HASH, TYPE_MAX_VALUE, TYPE_METHOD_BASETYPE, TYPE_MIN_VALUE, TYPE_OFFSET_BASETYPE, TYPE_PRECISION, TYPE_STRUCTURAL_EQUALITY_P, TYPE_TYPELESS_STORAGE, TYPE_UNSIGNED, and TYPE_VECTOR_SUBPARTS().

Referenced by build_array_type_1(), build_complex_type(), build_function_type(), build_method_type_directly(), build_offset_type(), build_range_type_1(), build_type_attribute_qual_variant(), and make_vector_type().

◆ type_list_equal()

bool type_list_equal	(	const_tree	l1,
		const_tree	l2 )

extern

Given two lists of types
(chains of TREE_LIST nodes with types in the TREE_VALUE slots)
return 1 if the lists contain the same types in the same order.
Also, the TREE_PURPOSEs must match.

References ggc_alloc(), simple_cst_equal(), TREE_CHAIN, TREE_PURPOSE, TREE_TYPE, and TREE_VALUE.

Referenced by ehspec_hasher::equal(), and type_cache_hasher::equal().

◆ type_num_arguments()

int type_num_arguments ( const_tree fntype )

extern

Returns the number of arguments to the FUNCTION_TYPE or METHOD_TYPE
given by TYPE.  If the argument list accepts variable arguments,
then this function counts only the ordinary arguments.

References i, TREE_CHAIN, TREE_VALUE, TYPE_ARG_TYPES, and VOID_TYPE_P.

◆ TYPE_VECTOR_SUBPARTS()

poly_uint64 TYPE_VECTOR_SUBPARTS ( const_tree node )

inline

Return the number of elements in the VECTOR_TYPE given by NODE.

References poly_int< N, C >::coeffs, ggc_alloc(), HOST_WIDE_INT_1U, NUM_POLY_INT_COEFFS, and STATIC_ASSERT.

Referenced by add_mask_and_len_args(), build_index_vector(), build_truth_vector_type_for(), build_vector_a_then_b(), build_vector_from_ctor(), build_vector_from_val(), check_load_store_for_partial_vectors(), clear_padding_type(), const_binop(), const_binop(), const_unop(), count_type_elements(), default_builtin_vectorization_cost(), do_compare_rtx_and_jump(), do_store_flag(), do_vec_conversion(), do_vec_narrow_conversion(), dump_generic_node(), duplicate_and_interleave(), type_cache_hasher::equal(), expand_debug_expr(), expand_expr_real_2(), expand_fn_using_insn(), expand_vector_comparison(), expand_vector_condition(), expand_vector_conversion(), expand_vector_ubsan_overflow(), expand_while_optab_fn(), expand_widen_pattern_expr(), fold_convert_const(), fold_convertible_p(), fold_indirect_ref_1(), fold_read_from_vector(), fold_ternary_loc(), fold_vec_perm(), fold_vec_perm_cst(), fold_view_convert_vector_encoding(), fold_while_ult(), get_compute_type(), get_group_load_store_type(), get_initial_def_for_reduction(), get_initial_defs_for_reduction(), get_load_store_type(), get_misalign_in_elems(), get_negative_load_store_type(), get_vectype_for_scalar_type(), gimple_build_vector(), gimple_build_vector_from_val(), gimple_fold_indirect_ref(), gimple_fold_stmt_to_constant_1(), initializer_each_zero_or_onep(), interleave_supported_p(), internal_gather_scatter_fn_supported_p(), ipa_simd_modify_function_body(), is_combined_permutation_identity(), is_truth_type_for(), layout_type(), lower_vec_perm(), native_interpret_vector(), tree_vector_builder::new_vector(), nunits_for_known_piecewise_op(), operand_compare::operand_equal_p(), operation_could_trap_helper_p(), optimize_vector_constructor(), perm_mask_for_reverse(), print_node(), scan_store_can_perm_p(), tree_vector_builder::shape_nelts(), signed_or_unsigned_type_for(), simd_clone_init_simd_arrays(), simplify_permutation(), simplify_vector_constructor(), vect_optimize_slp_pass::start_choosing_layouts(), store_constructor(), subparts_gt(), supportable_half_widening_operation(), supportable_narrowing_operation(), supportable_widening_operation(), tree_to_vec_perm_builder(), type_for_widest_vector_mode(), type_hash_canon_hash(), undistribute_bitref_for_vector(), uniform_vector_p(), useless_type_conversion_p(), valid_mask_for_fold_vec_perm_cst_p(), vec_perm_indices_to_tree(), vect_add_slp_permutation(), vect_adjust_loop_lens_control(), vect_analyze_data_refs(), vect_analyze_loop_2(), vect_build_one_gather_load_call(), vect_build_one_scatter_store_call(), vect_build_slp_instance(), vect_build_slp_tree_1(), vect_build_slp_tree_2(), vect_check_scalar_mask(), vect_convert_mask_for_vectype(), vect_create_cond_for_align_checks(), vect_create_constant_vectors(), vect_create_epilog_for_reduction(), vect_create_nonlinear_iv_init(), vect_create_partial_epilog(), vect_determine_vectorization_factor(), vect_double_mask_nunits(), vect_dr_misalign_for_aligned_access(), vect_enhance_data_refs_alignment(), vect_find_reusable_accumulator(), vect_gen_perm_mask_any(), vect_get_loop_len(), vect_get_loop_mask(), vect_get_num_vectors(), vect_get_peeling_costs_all_drs(), vect_get_strided_load_store_ops(), vect_get_vector_types_for_stmt(), vect_grouped_load_supported(), vect_halve_mask_nunits(), vect_is_simple_cond(), vect_nunits_for_cost(), vect_permute_load_chain(), vect_permute_store_chain(), vect_prologue_cost_for_slp(), vect_recog_bool_pattern(), vect_recog_mask_conversion_pattern(), vect_recog_rotate_pattern(), vect_record_loop_len(), vect_record_max_nunits(), vect_set_loop_condition_partial_vectors_avx512(), vect_set_loop_controls_directly(), vect_shift_permute_load_chain(), vect_slp_check_for_roots(), vect_slp_prefer_store_lanes_p(), vect_supportable_dr_alignment(), vect_transform_cycle_phi(), vect_transform_loop(), vect_transform_loop_stmt(), vect_transform_slp_perm_load_1(), vect_update_max_nunits(), vect_update_nonlinear_iv(), vect_verify_full_masking(), vect_verify_full_masking_avx512(), vector_alignment_reachable_p(), vector_type_mode(), vector_vector_composition_type(), vectorizable_assignment(), vectorizable_bswap(), vectorizable_call(), vectorizable_comparison_1(), vectorizable_condition(), vectorizable_conversion(), vectorizable_induction(), vectorizable_live_operation(), vectorizable_load(), vectorizable_nonlinear_induction(), vectorizable_operation(), vectorizable_recurr(), vectorizable_reduction(), vectorizable_scan_store(), vectorizable_shift(), vectorizable_simd_clone_call(), vectorizable_slp_permutation_1(), vectorizable_store(), vectorize_fold_left_reduction(), verify_gimple_assign_binary(), verify_gimple_assign_single(), verify_gimple_assign_ternary(), verify_gimple_assign_unary(), verify_gimple_comparison(), vn_reference_eq(), and vn_reference_lookup_3().

◆ type_with_alias_set_p()

bool type_with_alias_set_p ( const_tree t )

inline

Return true if it makes sense to consider alias set for a type T.

References COMPLETE_TYPE_P, ggc_alloc(), TREE_CODE, and TREE_TYPE.

Referenced by get_alias_set(), gimple_canonical_types_compatible_p(), lto_read_body_or_constructor(), and verify_type_variant().

◆ type_with_interoperable_signedness()

bool type_with_interoperable_signedness ( const_tree type )

extern

The TYPE_CANONICAL merging machinery.  It should closely resemble
the middle-end types_compatible_p function.  It needs to avoid
claiming types are different for types that should be treated
the same with respect to TBAA.  Canonical types are also used
for IL consistency checks via the useless_type_conversion_p
predicate which does not handle all type kinds itself but falls
back to pointer-comparison of TYPE_CANONICAL for aggregates
for example.

Return true if TYPE_UNSIGNED of TYPE should be ignored for canonical
type calculation because we need to allow inter-operability between signed
and unsigned variants.

References ggc_alloc(), signed_char_type_node, size_type_node, TREE_CODE, tree_code_for_canonical_type_merging(), and TYPE_PRECISION.

Referenced by gimple_canonical_types_compatible_p().

◆ typedef_variant_p()

bool typedef_variant_p ( const_tree type )

inline

Returns true iff TYPE is a type variant created for a typedef.

References is_typedef_decl(), and TYPE_NAME.

◆ types_same_for_odr()

bool types_same_for_odr	(	const_tree	type1,
		const_tree	type2 )

extern

For languages with One Definition Rule, work out if
  types are the same based on their name.

  This is non-trivial for LTO where minor differences in
  the type representation may have prevented type merging
  to merge two copies of otherwise equivalent type.

  Until we start streaming mangled type names, this function works
  only for polymorphic types.

References DECL_ASSEMBLER_NAME, gcc_checking_assert, ggc_alloc(), type_in_anonymous_namespace_p(), TYPE_MAIN_VARIANT, TYPE_NAME, TYPE_P, and type_with_linkage_p().

Referenced by add_type_duplicate(), decl_maybe_in_construction_p(), ipa_polymorphic_call_context::equal_to(), get_binfo_at_offset(), ipa_polymorphic_call_context::get_dynamic_type(), lookup_binfo_at_offset(), odr_subtypes_equivalent_p(), operand_compare::operand_equal_p(), possible_polymorphic_call_targets(), record_known_type(), record_target_from_binfo(), record_targets_from_bases(), ipa_polymorphic_call_context::restrict_to_inner_class(), types_must_be_same_for_odr(), and warn_types_mismatch().

◆ uniform_integer_cst_p()

tree uniform_integer_cst_p ( tree t )

extern

If the argument is INTEGER_CST, return it.  If the argument is vector
with all elements the same INTEGER_CST, return that INTEGER_CST.  Otherwise
return NULL_TREE.

If the argument is INTEGER_CST, return it.  If the argument is vector
with all elements the same INTEGER_CST, return that INTEGER_CST.  Otherwise
return NULL_TREE.
Look through location wrappers.

References ggc_alloc(), NULL_TREE, STRIP_ANY_LOCATION_WRAPPER, TREE_CODE, TREE_TYPE, uniform_vector_p(), and VECTOR_TYPE_P.

Referenced by bitmask_inv_cst_vector_p(), and vect_recog_divmod_pattern().

◆ uniform_vector_p()

tree uniform_vector_p ( const_tree vec )

extern

Given a vector VEC, return its first element if all elements are
the same.  Otherwise return NULL_TREE.

Check if vector VEC consists of all the equal elements and
that the number of elements corresponds to the type of VEC.
The function returns first element of the vector
or NULL_TREE if the vector is not uniform.

References CONSTRUCTOR_ELTS, error_mark_node, FOR_EACH_CONSTRUCTOR_VALUE, gcc_assert, ggc_alloc(), i, NULL_TREE, operand_equal_p(), TREE_CODE, TREE_OPERAND, TREE_TYPE, TYPE_VECTOR_SUBPARTS(), uniform_vector_p(), VECTOR_CST_DUPLICATE_P, VECTOR_CST_ENCODED_ELT, VECTOR_CST_NPATTERNS, and VECTOR_TYPE_P.

Referenced by expand_vector_ubsan_overflow(), fold_real_zero_addition_p(), reduce_vector_comparison_to_scalar_comparison(), ssa_uniform_vector_p(), store_constructor(), uniform_integer_cst_p(), uniform_vector_p(), and vect_slp_check_for_roots().

◆ unsigned_type_for()

tree unsigned_type_for ( tree type )

extern

If TYPE is an integral or pointer type, return an integer type with
the same precision which is unsigned, or itself if TYPE is already an
unsigned integer type.  If TYPE is a floating-point type, return an
unsigned integer type with the same bitsize as TYPE.

References signed_or_unsigned_type_for().

Referenced by bitmask_inv_cst_vector_p(), tree_switch_conversion::switch_conversion::build_arrays(), build_cltz_expr(), build_popcount_expr(), build_range_check(), cand_value_at(), chrec_apply(), chrec_convert_1(), chrec_evaluate(), chrec_fold_multiply(), convert_mult_to_highpart(), convert_to_integer_1(), create_intersect_range_checks_index(), do_narrow(), tree_switch_conversion::jump_table_cluster::emit(), expand_omp_simd(), fold_bit_and_mask(), fold_cond_expr_with_comparison(), fold_negate_expr_1(), fold_plusminus_mult_expr(), cfn_ffs::fold_range(), fold_ternary_loc(), fold_unary_loc(), generic_type_for(), get_computation_aff_1(), get_debug_computation_at(), get_misalign_in_elems(), gimplify_omp_for(), ifcombine_ifandif(), interpret_rhs_expr(), iv_period(), loop_exits_before_overflow(), lower_lastprivate_conditional_clauses(), make_tree(), maybe_optimize_arith_overflow(), maybe_optimize_mod_cmp(), number_of_iterations_cond(), number_of_iterations_lt(), number_of_iterations_ne(), number_of_iterations_until_wrap(), operator_cast::op1_range(), operator_lshift::op1_range(), optimize_range_tests_diff(), optimize_range_tests_to_bit_test(), optimize_range_tests_var_bound(), range_check_type(), record_nonwrapping_iv(), replace_trapping_overflow(), rewrite_to_defined_overflow(), sign_mask_for(), simplify_using_ranges::simplify_internal_call_using_ranges(), strip_offset_1(), vect_convert_input(), vect_create_cond_for_lower_bounds(), vect_create_nonlinear_iv_init(), vect_peel_nonlinear_iv_init(), vect_recog_abd_pattern(), vect_recog_ctz_ffs_pattern(), vect_recog_rotate_pattern(), vect_synth_mult_by_constant(), vect_update_nonlinear_iv(), and vectorize_slp_instance_root_stmt().

◆ upper_bound_in_type()

tree upper_bound_in_type	(	tree	outer,
		tree	inner )

extern

Returns the largest value obtainable by casting something in INNER type to
OUTER type.

References gcc_unreachable, ggc_alloc(), wi::mask(), TYPE_PRECISION, TYPE_UNSIGNED, and wide_int_to_tree().

Referenced by derive_constant_upper_bound_ops(), derive_simple_iv_with_niters(), determine_exit_conditions(), infer_loop_bounds_from_pointer_arith(), infer_loop_bounds_from_signedness(), loop_exits_before_overflow(), and scev_var_range_cant_overflow().

◆ using_eh_for_cleanups()

void using_eh_for_cleanups ( void )

extern

This routine is called from front ends to indicate eh should be used for
cleanups.

◆ using_eh_for_cleanups_p()

bool using_eh_for_cleanups_p ( void )

extern

Query whether EH is used for cleanups.

References using_eh_for_cleanups_flag.

Referenced by lower_try_finally().

◆ valid_constant_size_p()

bool valid_constant_size_p	(	const_tree	size,
		cst_size_error *	perr )

extern

Return true if SIZE represents a constant size that is in bounds of
what the middle-end and the backend accepts (covering not more than
half of the address-space).
When PERR is non-null, set *PERR on failure to the description of
why SIZE is not valid.

References cst_size_negative, cst_size_not_constant, cst_size_overflow, cst_size_too_big, error(), ggc_alloc(), i, NUM_POLY_INT_COEFFS, POLY_INT_CST_COEFF, POLY_INT_CST_P, sizetype, wi::to_widest(), TREE_CODE, tree_fits_uhwi_p(), tree_int_cst_sgn(), TREE_OVERFLOW, TREE_OVERFLOW_P, TYPE_MAX_VALUE, and valid_constant_size_p().

Referenced by asan_protect_global(), assemble_variable(), expand_one_var(), and valid_constant_size_p().

◆ valid_new_delete_pair_p()

bool valid_new_delete_pair_p	(	tree	new_asm,
		tree	delete_asm,
		bool *	pcertain )

extern

Return true for a valid pair of new and delete operators.

Return true if NEW_ASM and DELETE_ASM name a valid pair of new and
delete operators.  Return false if they may or may not name such
a pair and, when nonnull, set *PCERTAIN to true if they certainly
do not.

References ggc_alloc(), IDENTIFIER_LENGTH, and IDENTIFIER_POINTER.

◆ valid_vector_subparts_p()

bool valid_vector_subparts_p ( poly_uint64 subparts )

inline

Return true if we can construct vector types with the given number
of subparts.

References ggc_alloc(), NUM_POLY_INT_COEFFS, and pow2p_hwi().

Referenced by execute_update_addresses_taken(), and non_rewritable_lvalue_p().

◆ value_member()

tree value_member	(	tree	elem,
		tree	list )

extern

Return first list element whose TREE_VALUE is ELEM.
Return 0 if ELEM is not in LIST.

References NULL_TREE, TREE_CHAIN, and TREE_VALUE.

Referenced by assemble_external().

◆ variably_modified_type_p()

bool variably_modified_type_p	(	tree	type,
		tree	fn )

extern

Returns true if T is, contains, or refers to a type with variable
size.  For METHOD_TYPEs and FUNCTION_TYPEs we exclude the
arguments, but not the return type.  If FN is nonzero, only return
true if a modifier of the type or position of FN is a variable or
parameter inside FN.

This concept is more general than that of C99 'variably modified types':
in C99, a struct type is never variably modified because a VLA may not
appear as a structure member.  However, in GNU C code like:

  struct S { int i[f()]; };

is valid, and other languages may define similar constructs.

Test if T is either variable (if FN is zero) or an expression containing
a variable in FN.  If TYPE isn't gimplified, return true also if
gimplify_one_sizepos would gimplify the expression into a local
variable.

References DECL_CHAIN, DECL_FIELD_OFFSET, DECL_QUALIFIER, DECL_SIZE, DECL_SIZE_UNIT, error_mark_node, ggc_alloc(), RETURN_TRUE_IF_VAR, TREE_CODE, lang_hooks::tree_inlining, TREE_TYPE, TREE_VISITED, TYPE_FIELDS, TYPE_MAX_VALUE, TYPE_MIN_VALUE, TYPE_SIZE, TYPE_SIZE_UNIT, lang_hooks_for_tree_inlining::var_mod_type_p, and variably_modified_type_p().

Referenced by check_for_nested_with_variably_modified(), compute_fn_summary(), create_task_copyfn(), finalize_nesting_tree_1(), fixup_child_record_type(), get_nonlocal_debug_decl(), ipa_icf::sem_function::hash_stmt(), lto_variably_modified_type_p(), need_assembler_name_p(), pack_ts_type_common_value_fields(), remap_type(), remap_vla_decls(), replace_locals_stmt(), variably_modified_type_p(), and verify_type().

◆ vec_member()

bool vec_member	(	const_tree	elem,
		vec< tree, va_gc > *	v )

extern

Return true if ELEM is in V.

References FOR_EACH_VEC_SAFE_ELT, and ggc_alloc().

◆ vector_cst_elt()

tree vector_cst_elt	(	const_tree	t,
		unsigned int	i )

extern

Return the value of element I of VECTOR_CST T.

References ggc_alloc(), i, TREE_TYPE, VECTOR_CST_ENCODED_ELT, vector_cst_encoded_nelts(), vector_cst_int_elt(), VECTOR_CST_NPATTERNS, VECTOR_CST_STEPPED_P, and wide_int_to_tree().

Referenced by bitmask_inv_cst_vector_p(), fold_vec_perm_cst(), initializer_each_zero_or_onep(), operation_could_trap_helper_p(), simplify_bitfield_ref(), single_nonzero_element(), and valid_mask_for_fold_vec_perm_cst_p().

◆ vector_cst_encoded_nelts()

unsigned int vector_cst_encoded_nelts ( const_tree t )

inline

Return the number of elements encoded directly in a VECTOR_CST.

References VECTOR_CST_NELTS_PER_PATTERN, and VECTOR_CST_NPATTERNS.

Referenced by compare_constant(), const_hash_1(), const_with_all_bytes_same(), DFS::DFS_write_tree_body(), dump_generic_node(), operand_compare::hash_operand(), hash_tree(), initializer_each_zero_or_onep(), lto_input_ts_vector_tree_pointers(), negate_expr_p(), operand_compare::operand_equal_p(), operation_could_trap_helper_p(), print_node(), real_maybe_zerop(), real_zerop(), single_nonzero_element(), tree_size(), tree_to_vec_perm_builder(), vector_cst_elt(), vector_cst_int_elt(), walk_tree_1(), and write_ts_vector_tree_pointers().

◆ vector_element_bits()

unsigned int vector_element_bits ( const_tree type )

extern

Return the size in bits of each element of vector type TYPE.

References gcc_checking_assert, tree_to_uhwi(), TREE_TYPE, TYPE_PRECISION, TYPE_SIZE, VECTOR_BOOLEAN_TYPE_P, and VECTOR_TYPE_P.

Referenced by do_negate(), do_plus_minus(), expand_vector_addition(), expand_vector_conversion(), expand_vector_piecewise(), store_constructor(), vect_gather_scatter_fn_p(), vect_is_simple_cond(), vect_recog_mask_conversion_pattern(), vector_element_bits_tree(), and vectorizable_operation().

◆ vector_element_bits_tree()

tree vector_element_bits_tree ( const_tree type )

extern

Calculate the size in bits of each element of vector type TYPE
and return the result as a tree of type bitsizetype.

References bitsize_int, gcc_checking_assert, TREE_TYPE, TYPE_SIZE, VECTOR_BOOLEAN_TYPE_P, vector_element_bits(), and VECTOR_TYPE_P.

Referenced by expand_vector_comparison(), expand_vector_condition(), vector_element(), and vectorizable_live_operation().

◆ vector_type_mode()

machine_mode vector_type_mode ( const_tree t )

extern

Vector types need to re-check the target flags each time we report
the machine mode.  We need to do this because attribute target can
change the result of vector_mode_supported_p and have_regs_of_mode
on a per-function basis.  Thus the TYPE_MODE of a VECTOR_TYPE can
change on a per-function basis.

??? Possibly a better solution is to run through all the types
referenced by a function and re-compute the TYPE_MODE once, rather
than make the TYPE_MODE macro call a function.

References opt_mode< T >::exists(), gcc_assert, GET_MODE_BITSIZE(), ggc_alloc(), have_regs_of_mode, int_mode_for_size(), is_int_mode(), targetm, TREE_CODE, TREE_TYPE, TYPE_VECTOR_SUBPARTS(), and VECTOR_MODE_P.

◆ verify_constructor_flags()

void verify_constructor_flags ( tree c )

extern

Make sure that TREE_CONSTANT and TREE_SIDE_EFFECTS are correct for
CONSTRUCTOR C.

References CONSTRUCTOR_ELTS, FOR_EACH_CONSTRUCTOR_VALUE, i, internal_error(), side_effects_p(), TREE_CONSTANT, and TREE_SIDE_EFFECTS.

◆ verify_type()

void DEBUG_FUNCTION verify_type ( const_tree t )

extern

Verify type T.

References COMPLETE_TYPE_P, debug_tree(), error(), error_found, FIXED_POINT_TYPE_P, FUNC_OR_METHOD_TYPE_P, ggc_alloc(), gimple_canonical_types_compatible_p(), i, INTEGRAL_TYPE_P, internal_error(), is_lang_specific(), NULL, OPAQUE_TYPE_P, RECORD_OR_UNION_TYPE_P, SCALAR_FLOAT_TYPE_P, TREE_CHAIN, TREE_CODE, TREE_PURPOSE, TREE_TYPE, TREE_VALUE, TREE_VEC_ELT, TREE_VEC_LENGTH, TYPE_ARG_TYPES, TYPE_ARRAY_MAX_SIZE, TYPE_BINFO, TYPE_CACHED_VALUES, TYPE_CACHED_VALUES_P, TYPE_CANONICAL, TYPE_DOMAIN, TYPE_FIELDS, TYPE_LANG_SLOT_1, TYPE_MAIN_VARIANT, TYPE_MAX_VALUE_RAW, TYPE_METHOD_BASETYPE, TYPE_MODE, TYPE_NEXT_PTR_TO, TYPE_NEXT_REF_TO, TYPE_OFFSET_BASETYPE, TYPE_P, TYPE_VALUES, TYPE_VALUES_RAW, TYPE_VFIELD, useless_type_conversion_p(), VAR_P, variably_modified_type_p(), verify_opaque_type(), and verify_type_variant().

◆ virtual_method_call_p()

bool virtual_method_call_p	(	const_tree	target,
		bool	for_dump_p )

extern

TARGET is a call target of GIMPLE call statement
(obtained by gimple_call_fn).  Return true if it is
OBJ_TYPE_REF representing an virtual call of C++ method.
(As opposed to OBJ_TYPE_REF representing objc calls
through a cast where middle-end devirtualization machinery
can't apply.)  FOR_DUMP_P is true when being called from
the dump routines.

References gcc_checking_assert, ggc_alloc(), obj_type_ref_class(), TREE_CODE, TREE_TYPE, and TYPE_BINFO.

Referenced by cgraph_node::create_indirect_edge(), dump_generic_node(), eliminate_dom_walker::eliminate_stmt(), fold_gimple_assign(), gimple_fold_call(), operand_compare::hash_operand(), ipa_analyze_call_uses(), operand_compare::operand_equal_p(), and tree_estimate_probability_bb().

◆ walk_tree_1()

tree walk_tree_1	(	tree *	tp,
		walk_tree_fn	func,
		void *	data,
		hash_set< tree > *	pset,
		walk_tree_lh	lh )

extern

Apply FUNC to all the sub-trees of TP in a pre-order traversal.  FUNC is
called with the DATA and the address of each sub-tree.  If FUNC returns a
non-NULL value, the traversal is stopped, and the value returned by FUNC
is returned.  If PSET is non-NULL it is used to record the nodes visited,
and to avoid visiting a node more than once.

References hash_set< KeyId, Lazy, Traits >::add(), BIND_EXPR_BODY, BIND_EXPR_VARS, CONSTRUCTOR_ELTS, DECL_CHAIN, DECL_EXPR_DECL, DECL_FIELD_OFFSET, DECL_INITIAL, DECL_QUALIFIER, DECL_SIZE, DECL_SIZE_UNIT, ggc_alloc(), i, IS_EXPR_CODE_CLASS, NULL_TREE, OMP_CLAUSE_CHAIN, OMP_CLAUSE_CODE, omp_clause_num_ops, OMP_CLAUSE_OPERAND, POINTER_TYPE_P, RECORD_OR_UNION_TYPE_P, TREE_CHAIN, TREE_CODE, TREE_CODE_CLASS, TREE_IMAGPART, TREE_OPERAND, TREE_OPERAND_LENGTH, TREE_REALPART, TREE_TYPE, TREE_VALUE, TREE_VEC_ELT, TREE_VEC_LENGTH, tsi_end_p(), tsi_next(), tsi_start(), tsi_stmt_ptr(), TYPE_FIELDS, TYPE_MAX_VALUE, TYPE_MIN_VALUE, TYPE_P, TYPE_SIZE, TYPE_SIZE_UNIT, vec_safe_iterate(), VECTOR_CST_ENCODED_ELT, vector_cst_encoded_nelts(), WALK_SUBTREE, WALK_SUBTREE_TAIL, and walk_type_fields().

Referenced by walk_tree_without_duplicates_1().

◆ walk_tree_without_duplicates_1()

tree walk_tree_without_duplicates_1	(	tree *	tp,
		walk_tree_fn	func,
		void *	data,
		walk_tree_lh	lh )

extern

Like walk_tree, but does not walk duplicate nodes more than once.

References ggc_alloc(), and walk_tree_1().

◆ warn_deprecated_use()

bool warn_deprecated_use	(	tree	node,
		tree	attr )

extern

Warn about a use of an identifier which was marked deprecated.  Returns
whether a warning was given.

References DECL_ATTRIBUTES, DECL_NAME, DECL_P, DECL_SOURCE_LOCATION, ggc_alloc(), inform(), lookup_attribute(), msg, NULL_TREE, TREE_CODE, TREE_STRING_POINTER, TREE_TYPE, TREE_VALUE, TYPE_ATTRIBUTES, TYPE_MAIN_VARIANT, TYPE_NAME, TYPE_P, TYPE_STUB_DECL, and warning().

◆ warning_suppressed_at()

bool warning_suppressed_at	(	location_t	loc,
		opt_code	opt )

extern

Return the disposition for a warning (or all warnings by default)
at a location.

Return the no-warning disposition for location LOC and option OPT
or for all/any otions by default.

References gcc_checking_assert, hash_map< KeyId, Value, Traits >::get(), ggc_alloc(), nowarn_map, and RESERVED_LOCATION_P.

◆ warning_suppressed_p()

bool warning_suppressed_p	(	const_tree	expr,
		opt_code	opt )

extern

Return the disposition for a warning (or all warnings by default)
for an expression.

Return true if warning OPT is suppressed for decl/expression EXPR.
By default tests the disposition for any warning.

References gcc_assert, get_no_warning_bit(), get_nowarn_spec(), and ggc_alloc().

◆ wide_int_to_tree()

tree wide_int_to_tree	(	tree	type,
		const poly_wide_int_ref &	value )

extern

Create a constant tree with value VALUE in type TYPE.

References build_poly_int_cst(), poly_int< N, C >::coeffs, poly_int< N, C >::is_constant(), and wide_int_to_tree_1().

Referenced by add_decls_addresses_to_decl_constructor(), add_elt_to_tree(), add_iv_candidate_for_use(), addr_to_parts(), aff_combination_add_elt(), aff_combination_add_product(), aff_combination_mult(), aff_combination_scale(), aff_combination_to_tree(), analyze_and_compute_bitwise_induction_effect(), tree_vector_builder::apply_step(), bit_value_assume_aligned(), bit_value_binop(), bit_value_unop(), bitmask_inv_cst_vector_p(), build_int_cst(), build_int_cst_type(), build_int_cstu(), build_low_bits_mask(), tree_switch_conversion::switch_conversion::build_one_array(), build_replicated_int_cst(), build_vec_series(), check_access(), check_for_binary_op_overflow(), clear_padding_type(), component_ref_size(), compute_avail(), compute_distributive_range(), compute_object_offset(), compute_objsize(), compute_objsize(), const_unop(), constant_byte_string(), constant_pointer_difference(), copy_tree_body_r(), create_add_on_incoming_edge(), create_intersect_range_checks_index(), create_mul_imm_cand(), decrement_count(), derive_constant_upper_bound_ops(), div_if_zero_remainder(), double_int_to_tree(), dr_analyze_indices(), dr_analyze_innermost(), drop_tree_overflow(), tree_switch_conversion::bit_test_cluster::emit(), evaluate_stmt(), execute_update_addresses_taken(), expand_call_mem_ref(), expand_case(), expand_DEFERRED_INIT(), expand_simple_operations(), expand_vector_condition(), extract_bit_test_mask(), extract_muldiv_1(), field_byte_offset(), find_case_label_range(), find_var_cmp_const(), fold_binary_loc(), fold_const_aggregate_ref_1(), fold_const_call_1(), fold_const_call_1(), fold_indirect_ref_1(), fold_ternary_loc(), force_fit_type(), forward_propagate_addr_expr_1(), get_address_cost(), get_debug_computation_at(), get_legacy_range(), get_maxbound(), get_range_strlen_dynamic(), get_range_strlen_tree(), get_size_range(), get_size_range(), get_up_bounds_for_array_ref(), gimple_call_alloc_size(), gimple_divmod_fixed_value_transform(), gimple_fold_builtin_strlen(), gimple_fold_indirect_ref(), gimple_stringops_transform(), handle_printf_call(), infer_loop_bounds_from_signedness(), insert_initializers(), ipcp_get_parm_bits(), layout_type(), prange::lbound(), irange::lbound(), simplify_using_ranges::legacy_fold_cond_overflow(), loop_exits_before_overflow(), lower_bound_in_type(), lower_omp_ordered_clauses(), lto_input_tree_1(), make_tree(), maskable_range_p(), match_arith_overflow(), max_stmt_executions_tree(), maybe_canonicalize_mem_ref_addr(), maybe_optimize_mod_cmp(), maybe_optimize_pow2p_mod_cmp(), maybe_rewrite_mem_ref_base(), maybe_trim_memstar_call(), minmax_replacement(), most_expensive_mult_to_index(), move_variant_to_index(), multiple_of_p(), n_of_executions_at_most(), native_encode_initializer(), native_interpret_aggregate(), native_interpret_int(), number_of_iterations_until_wrap(), omp_reduction_init_op(), optimize_range_tests_to_bit_test(), output_constant(), overflow_comparison_p_1(), preferred_mem_scale_factor(), record_nonwrapping_iv(), reduce_to_bit_field_precision(), remap_gimple_op_r(), replace_mult_candidate(), replace_ref(), restructure_reference(), rewrite_use_nonlinear_expr(), scan_omp_1_op(), set_min_and_max_values_for_integral_type(), set_strlen_range(), set_switch_stmt_execution_predicate(), sign_mask_for(), simple_iv_with_niters(), simplify_using_ranges::simplify_div_or_mod_using_ranges(), prange::singleton_p(), irange::singleton_p(), store_constructor(), test_for_singularity(), totally_scalarize_subtree(), tree_fold_binomial(), simplify_using_ranges::two_valued_val_range_p(), prange::ubound(), irange::ubound(), ubsan_expand_vptr_ifn(), upper_bound_in_type(), valid_mem_ref_cand_p(), valueized_wider_op(), vect_check_gather_scatter(), vect_convert_input(), vect_create_nonlinear_iv_step(), vect_emulate_mixed_dot_prod(), vect_get_loop_variant_data_ptr_increment(), vect_peel_nonlinear_iv_init(), vect_recog_bit_insert_pattern(), vect_recog_bitfield_ref_pattern(), vect_recog_divmod_pattern(), vector_cst_elt(), vectorizable_load(), vectorizable_simd_clone_call(), visit_nary_op(), vn_reference_fold_indirect(), vn_reference_insert(), vn_reference_lookup(), vn_reference_maybe_forwprop_address(), and rt_bb_visited::vwordidx().

◆ zerop()

bool zerop ( const_tree expr )

extern

zerop (tree x) is nonzero if X is a constant of value 0.

Return true if EXPR is the constant zero, whether it is integral, float or
fixed, and scalar, complex or vector.

References fixed_zerop(), integer_zerop(), and real_zerop().

Referenced by access_and_field_type_match_p(), asan_poison_variable(), build_asan_poison_call_expr(), ipa_get_jf_ancestor_result(), path_comparable_for_same_access(), some_nonzerop(), totally_scalarizable_type_p(), vect_recog_gcond_pattern(), and warn_uninit().

Variable Documentation

◆ all_warnings

constexpr opt_code all_warnings = N_OPTS

constexpr

Wildcard code that refers to all warnings.

Referenced by nowarn_spec_t::nowarn_spec_t().

◆ builtin_structptr_types

const builtin_structptr_type builtin_structptr_types[6]

extern

List of pointer types used to declare builtins before we have seen their
real declaration.

Keep the size up to date in tree.h !

Referenced by build_common_tree_nodes().

◆ int_n_enabled_p

bool int_n_enabled_p[NUM_INT_N_ENTS]

extern

This is also in machmode.h

This is also in tree.h.  genmodes.cc guarantees the're sorted from
smallest bitsize to largest bitsize.

Referenced by build_common_tree_nodes().

◆ int_n_trees

struct int_n_trees_t int_n_trees[NUM_INT_N_ENTS]

extern

Referenced by build_common_tree_nodes(), find_bitfield_repr_type(), gimple_signed_or_unsigned_type(), and lhd_type_for_size().

◆ no_warning

constexpr opt_code no_warning = opt_code ()

constexpr

Code that doesn't refer to any warning.  Has no effect on suppression
functions.

Referenced by check_bounds_or_overlap(), gimple_set_no_warning(), strlen_pass::handle_builtin_strcat(), strlen_pass::handle_builtin_strcpy(), strlen_pass::handle_builtin_stxncpy_strncat(), nowarn_spec_t::nowarn_spec_t(), suppress_warning(), suppress_warning(), and suppress_warning_at().

◆ suppress_location_wrappers

int suppress_location_wrappers

extern

Referenced by auto_suppress_location_wrappers::auto_suppress_location_wrappers(), maybe_wrap_with_location(), and auto_suppress_location_wrappers::~auto_suppress_location_wrappers().

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

#define OMP_CLAUSE_OPERAND	(		NODE,
			I ) OMP_CLAUSE_ELT_CHECK (NODE, I)

#define SET_DECL_MODE	(		NODE,
			MODE ) (DECL_COMMON_CHECK (NODE)->decl_common.mode = (MODE))

#define TREE_INT_CST_ELT	(		NODE,
			I ) TREE_INT_CST_ELT_CHECK (NODE, I)

#define VECTOR_CST_ENCODED_ELT	(		NODE,
			ELT ) (VECTOR_CST_CHECK (NODE)->vector.elts[ELT])

Data Structures

Namespaces

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ access_private_node

◆ access_protected_node

◆ access_public_node

◆ accum_type_node

◆ AGGREGATE_TYPE_P

◆ ALLOCA_FUNCTION_CODE_P

◆ ANY_INTEGRAL_TYPE_CHECK

◆ ANY_INTEGRAL_TYPE_P

◆ ARRAY_OR_INTEGER_TYPE_CHECK

◆ ASM_CLOBBERS

◆ ASM_INLINE_P

◆ ASM_INPUT_P

◆ ASM_INPUTS

◆ ASM_LABELS

◆ ASM_OUTPUTS

◆ ASM_STRING

◆ ASM_VOLATILE_P

◆ atomicDI_type_node

◆ atomicHI_type_node

◆ atomicQI_type_node

◆ atomicSI_type_node

◆ atomicTI_type_node

◆ bfloat16_type_node

◆ BINARY_CLASS_P

◆ BIND_EXPR_BLOCK

◆ BIND_EXPR_BODY

◆ BIND_EXPR_VARS

◆ BINFO_BASE_ACCESS

◆ BINFO_BASE_ACCESS_APPEND

◆ BINFO_BASE_ACCESSES

◆ BINFO_BASE_APPEND

◆ BINFO_BASE_BINFO

◆ BINFO_BASE_BINFOS

◆ BINFO_BASE_ITERATE

◆ BINFO_FLAG_0

◆ BINFO_FLAG_1

◆ BINFO_FLAG_2

◆ BINFO_FLAG_3

◆ BINFO_FLAG_4

◆ BINFO_FLAG_5

◆ BINFO_FLAG_6

◆ BINFO_INHERITANCE_CHAIN

◆ BINFO_N_BASE_BINFOS

◆ BINFO_OFFSET

◆ BINFO_OFFSET_ZEROP

◆ BINFO_SUBVTT_INDEX

◆ BINFO_TYPE

◆ BINFO_VIRTUAL_P

◆ BINFO_VIRTUALS

◆ BINFO_VPTR_FIELD

◆ BINFO_VPTR_INDEX

◆ BINFO_VTABLE

◆ BITINT_TYPE_P

◆ bitsize_int

◆ bitsize_one_node

◆ bitsize_unit_node

◆ bitsize_zero_node

◆ bitsizetype

◆ BLOCK_ABSTRACT_ORIGIN

◆ BLOCK_CHAIN

◆ BLOCK_DIE

◆ BLOCK_FRAGMENT_CHAIN

◆ BLOCK_FRAGMENT_ORIGIN

◆ BLOCK_IN_COLD_SECTION_P

◆ BLOCK_NONLOCALIZED_VAR

◆ BLOCK_NONLOCALIZED_VARS

◆ BLOCK_NUM_NONLOCALIZED_VARS

◆ BLOCK_NUMBER

◆ BLOCK_ORIGIN

◆ BLOCK_SAME_RANGE

◆ BLOCK_SOURCE_END_LOCATION

◆ BLOCK_SOURCE_LOCATION