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

Include dependency graph for tree.h:

This graph shows which files directly or indirectly include this file:

Macros
#define	MARK_TS_BASE(C)
#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_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	TREE_CODE_CLASS_STRING(CLASS) tree_code_class_strings[(int) (CLASS)]
#define	TREE_CODE_CLASS(CODE) 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	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[(int) (CODE)]
#define	BUILTIN_EXP10_P(FN)
#define	BUILTIN_EXPONENT_P(FN)
#define	BUILTIN_SQRT_P(FN) ((FN) == BUILT_IN_SQRT \|\| (FN) == BUILT_IN_SQRTF \|\| (FN) == BUILT_IN_SQRTL)
#define	BUILTIN_CBRT_P(FN) ((FN) == BUILT_IN_CBRT \|\| (FN) == BUILT_IN_CBRTF \|\| (FN) == BUILT_IN_CBRTL)
#define	BUILTIN_ROOT_P(FN) (BUILTIN_SQRT_P (FN) \|\| BUILTIN_CBRT_P (FN))
#define	CASE_FLT_FN(FN) case FN: case FN##F: case FN##L
#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	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_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_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	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	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	VECTOR_TYPE_P(TYPE) (TREE_CODE (TYPE) == VECTOR_TYPE)
#define	INTEGRAL_TYPE_P(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	POINTER_BOUNDS_TYPE_P(NODE) (TREE_CODE (NODE) == POINTER_BOUNDS_TYPE)
#define	POINTER_BOUNDS_P(NODE) (POINTER_BOUNDS_TYPE_P (TREE_TYPE (NODE)))
#define	BOUNDED_TYPE_P(type) (POINTER_TYPE_P (type))
#define	BOUNDED_P(node) BOUNDED_TYPE_P (TREE_TYPE (node))
#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	TREE_ADDRESSABLE(NODE) ((NODE)->base.addressable_flag)
#define	CALL_EXPR_TAILCALL(NODE) (CALL_EXPR_CHECK (NODE)->base.addressable_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_low_cst (TREE_OPERAND (PREDICT_EXPR_CHECK (NODE), 0), 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	TYPE_ARTIFICIAL(NODE) (TYPE_CHECK (NODE)->base.nowarning_flag)
#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	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_OVERFLOW_WRAPS(TYPE) (TYPE_UNSIGNED (TYPE) \|\| flag_wrapv)
#define	TYPE_OVERFLOW_UNDEFINED(TYPE) (!TYPE_UNSIGNED (TYPE) && !flag_wrapv && !flag_trapv && flag_strict_overflow)
#define	TYPE_OVERFLOW_TRAPS(TYPE) (!TYPE_UNSIGNED (TYPE) && flag_trapv)
#define	POINTER_TYPE_OVERFLOW_UNDEFINED (flag_strict_overflow)
#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	CILK_SPAWN_FN(NODE) TREE_OPERAND (CILK_SPAWN_STMT_CHECK (NODE), 0)
#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	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	TYPE_ALIGN_OK(NODE) (TYPE_CHECK (NODE)->base.nothrow_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	IDENTIFIER_TRANSPARENT_ALIAS(NODE) (IDENTIFIER_NODE_CHECK (NODE)->base.deprecated_flag)
#define	TYPE_SATURATING(NODE) (TYPE_CHECK (NODE)->base.u.bits.saturating_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(NODE) (INTEGER_CST_CHECK (NODE)->int_cst.int_cst)
#define	TREE_INT_CST_LOW(NODE) (TREE_INT_CST (NODE).low)
#define	TREE_INT_CST_HIGH(NODE) (TREE_INT_CST (NODE).high)
#define	INT_CST_LT(A, B)
#define	INT_CST_LT_UNSIGNED(A, B)
#define	TREE_REAL_CST_PTR(NODE) (REAL_CST_CHECK (NODE)->real_cst.real_cst_ptr)
#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_ELTS(NODE) (VECTOR_CST_CHECK (NODE)->vector.elts)
#define	VECTOR_CST_ELT(NODE, IDX) (VECTOR_CST_CHECK (NODE)->vector.elts[IDX])
#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_END(NODE) ((void) TREE_VEC_CHECK (NODE), &((NODE)->vec.a[(NODE)->vec.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	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) (DECL_BIT_FIELD (FIELD_DECL_CHECK (NODE)) && DECL_MODE (NODE) != BLKmode)
#define	TREE_CLOBBER_P(NODE) (TREE_CODE (NODE) == CONSTRUCTOR && TREE_THIS_VOLATILE (NODE))
#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_STMTS (flag_var_tracking_assignments)
#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_HERE(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_LOCATION_P(NODE) ((NODE) && EXPR_P (NODE))
#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	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_LABELS(NODE) TREE_OPERAND (SWITCH_EXPR_CHECK (NODE), 2)
#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	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 ((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	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_VAR(NODE) TREE_OPERAND (POLYNOMIAL_CHREC_CHECK (NODE), 0)
#define	CHREC_LEFT(NODE) TREE_OPERAND (POLYNOMIAL_CHREC_CHECK (NODE), 1)
#define	CHREC_RIGHT(NODE) TREE_OPERAND (POLYNOMIAL_CHREC_CHECK (NODE), 2)
#define	CHREC_VARIABLE(NODE) TREE_INT_CST_LOW (CHREC_VAR (NODE))
#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	ASSERT_EXPR_VAR(NODE) TREE_OPERAND (ASSERT_EXPR_CHECK (NODE), 0)
#define	ASSERT_EXPR_COND(NODE) TREE_OPERAND (ASSERT_EXPR_CHECK (NODE), 1)
#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_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, OMP_PARALLEL, OMP_CRITICAL), 0)
#define	OMP_CLAUSES(NODE) TREE_OPERAND (TREE_RANGE_CHECK (NODE, OMP_PARALLEL, OMP_SINGLE), 1)
#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_LOOP_CHECK(NODE) TREE_RANGE_CHECK (NODE, OMP_FOR, OMP_DISTRIBUTE)
#define	OMP_FOR_BODY(NODE) TREE_OPERAND (OMP_LOOP_CHECK (NODE), 0)
#define	OMP_FOR_CLAUSES(NODE) TREE_OPERAND (OMP_LOOP_CHECK (NODE), 1)
#define	OMP_FOR_INIT(NODE) TREE_OPERAND (OMP_LOOP_CHECK (NODE), 2)
#define	OMP_FOR_COND(NODE) TREE_OPERAND (OMP_LOOP_CHECK (NODE), 3)
#define	OMP_FOR_INCR(NODE) TREE_OPERAND (OMP_LOOP_CHECK (NODE), 4)
#define	OMP_FOR_PRE_BODY(NODE) TREE_OPERAND (OMP_LOOP_CHECK (NODE), 5)
#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_SINGLE_BODY(NODE) TREE_OPERAND (OMP_SINGLE_CHECK (NODE), 0)
#define	OMP_SINGLE_CLAUSES(NODE) TREE_OPERAND (OMP_SINGLE_CHECK (NODE), 1)
#define	OMP_MASTER_BODY(NODE) TREE_OPERAND (OMP_MASTER_CHECK (NODE), 0)
#define	OMP_TASKGROUP_BODY(NODE) TREE_OPERAND (OMP_TASKGROUP_CHECK (NODE), 0)
#define	OMP_ORDERED_BODY(NODE) TREE_OPERAND (OMP_ORDERED_CHECK (NODE), 0)
#define	OMP_CRITICAL_BODY(NODE) TREE_OPERAND (OMP_CRITICAL_CHECK (NODE), 0)
#define	OMP_CRITICAL_NAME(NODE) TREE_OPERAND (OMP_CRITICAL_CHECK (NODE), 1)
#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_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_SECTION_LAST(NODE) (OMP_SECTION_CHECK (NODE)->base.private_flag)
#define	OMP_PARALLEL_COMBINED(NODE) (OMP_PARALLEL_CHECK (NODE)->base.private_flag)
#define	OMP_ATOMIC_SEQ_CST(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_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_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_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_DEPEND_KIND(NODE) (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEPEND)->omp_clause.subcode.depend_kind)
#define	OMP_CLAUSE_MAP_KIND(NODE) (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP)->omp_clause.subcode.map_kind)
#define	OMP_CLAUSE_MAP_ZERO_BIAS_ARRAY_SECTION(NODE) (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP)->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_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_REDUCTION_CODE(NODE) (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_REDUCTION)->omp_clause.subcode.reduction_code)
#define	OMP_CLAUSE_REDUCTION_INIT(NODE) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_REDUCTION), 1)
#define	OMP_CLAUSE_REDUCTION_MERGE(NODE) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_REDUCTION), 2)
#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) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_REDUCTION), 3)
#define	OMP_CLAUSE_REDUCTION_OMP_ORIG_REF(NODE) (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_REDUCTION)->base.public_flag)
#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_STEP(NODE) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR), 1)
#define	OMP_CLAUSE_ALIGNED_ALIGNMENT(NODE) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ALIGNED), 1)
#define	OMP_CLAUSE_NUM_TEAMS_EXPR(NODE) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_TEAMS), 0)
#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_DEFAULT_KIND(NODE) (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEFAULT)->omp_clause.subcode.default_kind)
#define	SSA_NAME_IDENTIFIER(NODE)
#define	SSA_NAME_VAR(NODE)
#define	SET_SSA_NAME_VAR_OR_IDENTIFIER(NODE, VAR) do { SSA_NAME_CHECK (NODE)->ssa_name.var = (VAR); } while (0)
#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_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_ABSTRACT(NODE) (BLOCK_CHECK (NODE)->block.abstract_flag)
#define	BLOCK_SAME_RANGE(NODE) (BLOCK_CHECK (NODE)->base.u.bits.nameless_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	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) (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(NODE)
#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(NODE) (TYPE_CHECK (NODE)->type_common.align)
#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_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_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_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	TREE_VISITED(NODE) ((NODE)->base.visited)
#define	TYPE_STRING_FLAG(NODE) (TYPE_CHECK (NODE)->type_common.string_flag)
#define	TYPE_VECTOR_SUBPARTS(VECTOR_TYPE)
#define	SET_TYPE_VECTOR_SUBPARTS(VECTOR_TYPE, X) (VECTOR_TYPE_CHECK (VECTOR_TYPE)->type_common.precision = exact_log2 (X))
#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_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_POINTER(NODE) (TYPE_CHECK (NODE)->type_common.symtab.pointer)
#define	TYPE_SYMTAB_DIE(NODE) (TYPE_CHECK (NODE)->type_common.symtab.die)
#define	TYPE_SYMTAB_IS_ADDRESS (0)
#define	TYPE_SYMTAB_IS_POINTER (1)
#define	TYPE_SYMTAB_IS_DIE (2)
#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_METHODS(NODE) (RECORD_OR_UNION_CHECK (NODE)->type_non_common.maxval)
#define	TYPE_VFIELD(NODE) (RECORD_OR_UNION_CHECK (NODE)->type_non_common.minval)
#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_MAXVAL(NODE) (TYPE_CHECK (NODE)->type_non_common.maxval)
#define	TYPE_MINVAL(NODE) (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_MIN_VALUE(NODE) (NUMERICAL_TYPE_CHECK (NODE)->type_non_common.minval)
#define	TYPE_MAX_VALUE(NODE) (NUMERICAL_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_BINFO(NODE) (RECORD_OR_UNION_CHECK (NODE)->type_non_common.binfo)
#define	TYPE_LANG_SLOT_1(NODE) (NOT_RECORD_OR_UNION_CHECK (NODE)->type_non_common.binfo)
#define	BINFO_VIRTUAL_P(NODE) (TREE_BINFO_CHECK (NODE)->base.static_flag)
#define	BINFO_MARKED(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	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_BUILTIN(DECL) (LOCATION_LOCUS (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(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.align)
#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	DECL_FUNCTION_CODE(NODE) (FUNCTION_DECL_CHECK (NODE)->function_decl.function_code)
#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(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_GIMPLE_REG_P(DECL) DECL_COMMON_CHECK (DECL)->decl_common.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(NODE1, NODE2)
#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) (((unsigned HOST_WIDE_INT)1) << 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_NONADDRESSABLE_P(NODE) (FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_2)
#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_WITH_VIS_CHECK (NODE)->decl_with_vis.comdat_group)
#define	DECL_ONE_ONLY(NODE) (DECL_COMDAT_GROUP (NODE) != NULL_TREE)
#define	DECL_ASSEMBLER_NAME(NODE) decl_assembler_name (NODE)
#define	HAS_DECL_ASSEMBLER_NAME_P(NODE) (CODE_CONTAINS_STRUCT (TREE_CODE (NODE), TS_DECL_WITH_VIS))
#define	DECL_ASSEMBLER_NAME_SET_P(NODE)
#define	SET_DECL_ASSEMBLER_NAME(NODE, NAME) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.assembler_name = (NAME))
#define	COPY_DECL_ASSEMBLER_NAME(DECL1, DECL2)
#define	DECL_SECTION_NAME(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.section_name)
#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) (VAR_DECL_CHECK (NODE)->decl_with_vis.tls_model)
#define	DECL_THREAD_LOCAL_P(NODE) (VAR_DECL_CHECK (NODE)->decl_with_vis.tls_model >= TLS_MODEL_REAL)
#define	DECL_HAS_INIT_PRIORITY_P(NODE) (VAR_DECL_CHECK (NODE)->decl_with_vis.init_priority_p)
#define	DECL_HAS_IMPLICIT_SECTION_NAME_P(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.implicit_section_name_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_RESULT_FLD(NODE) (DECL_NON_COMMON_CHECK (NODE)->decl_non_common.result)
#define	DECL_VINDEX(NODE) (DECL_NON_COMMON_CHECK (NODE)->decl_non_common.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)->decl_non_common.saved_tree)
#define	DECL_IS_MALLOC(NODE) (FUNCTION_DECL_CHECK (NODE)->function_decl.malloc_flag)
#define	DECL_IS_OPERATOR_NEW(NODE) (FUNCTION_DECL_CHECK (NODE)->function_decl.operator_new_flag)
#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)->function_decl.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(NODE) (DECL_BUILT_IN_CLASS (NODE) != NOT_BUILT_IN)
#define	DECL_BUILT_IN_CLASS(NODE) (FUNCTION_DECL_CHECK (NODE)->function_decl.built_in_class)
#define	DECL_ARGUMENTS(NODE) (FUNCTION_DECL_CHECK (NODE)->decl_non_common.arguments)
#define	DECL_ARGUMENT_FLD(NODE) (DECL_NON_COMMON_CHECK (NODE)->decl_non_common.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_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	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	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	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	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	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	pointer_bounds_type_node global_trees[TI_POINTER_BOUNDS_TYPE]
#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	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	dfloat32_ptr_type_node global_trees[TI_DFLOAT32_PTR_TYPE]
#define	dfloat64_ptr_type_node global_trees[TI_DFLOAT64_PTR_TYPE]
#define	dfloat128_ptr_type_node global_trees[TI_DFLOAT128_PTR_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	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	int128_integer_type_node integer_types[itk_int128]
#define	int128_unsigned_type_node integer_types[itk_unsigned_int128]
#define	NULL_TREE (tree) NULL
#define	error_operand_p(NODE)
#define	make_node(t) make_node_stat (t MEM_STAT_INFO)
#define	copy_node(t) copy_node_stat (t MEM_STAT_INFO)
#define	make_tree_binfo(t) make_tree_binfo_stat (t MEM_STAT_INFO)
#define	make_tree_vec(t) make_tree_vec_stat (t MEM_STAT_INFO)
#define	build0(c, t) build0_stat (c,t MEM_STAT_INFO)
#define	build1(c, t1, t2) build1_stat (c,t1,t2 MEM_STAT_INFO)
#define	build2(c, t1, t2, t3) build2_stat (c,t1,t2,t3 MEM_STAT_INFO)
#define	build3(c, t1, t2, t3, t4) build3_stat (c,t1,t2,t3,t4 MEM_STAT_INFO)
#define	build4(c, t1, t2, t3, t4, t5) build4_stat (c,t1,t2,t3,t4,t5 MEM_STAT_INFO)
#define	build5(c, t1, t2, t3, t4, t5, t6) build5_stat (c,t1,t2,t3,t4,t5,t6 MEM_STAT_INFO)
#define	build1_loc(l, c, t1, t2) build1_stat_loc (l,c,t1,t2 MEM_STAT_INFO)
#define	build2_loc(l, c, t1, t2, t3) build2_stat_loc (l,c,t1,t2,t3 MEM_STAT_INFO)
#define	build3_loc(l, c, t1, t2, t3, t4) build3_stat_loc (l,c,t1,t2,t3,t4 MEM_STAT_INFO)
#define	build4_loc(l, c, t1, t2, t3, t4, t5) build4_stat_loc (l,c,t1,t2,t3,t4,t5 MEM_STAT_INFO)
#define	build5_loc(l, c, t1, t2, t3, t4, t5, t6) build5_stat_loc (l,c,t1,t2,t3,t4,t5,t6 MEM_STAT_INFO)
#define	build_var_debug_value(t1, t2) build_var_debug_value_stat (t1,t2 MEM_STAT_INFO)
#define	make_vector(n) make_vector_stat (n MEM_STAT_INFO)
#define	build_vector(t, v) build_vector_stat (t, v MEM_STAT_INFO)
#define	build_tree_list(t, q) build_tree_list_stat (t, q MEM_STAT_INFO)
#define	build_tree_list_vec(v) build_tree_list_vec_stat (v MEM_STAT_INFO)
#define	build_decl(l, c, t, q) build_decl_stat (l, c, t, q MEM_STAT_INFO)
#define	build_vl_exp(c, n) build_vl_exp_stat (c, n MEM_STAT_INFO)
#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	make_signed_fract_type(P) make_fract_type (P, 0, 0)
#define	make_unsigned_fract_type(P) make_fract_type (P, 1, 0)
#define	make_sat_signed_fract_type(P) make_fract_type (P, 0, 1)
#define	make_sat_unsigned_fract_type(P) make_fract_type (P, 1, 1)
#define	make_signed_accum_type(P) make_accum_type (P, 0, 0)
#define	make_unsigned_accum_type(P) make_accum_type (P, 1, 0)
#define	make_sat_signed_accum_type(P) make_accum_type (P, 0, 1)
#define	make_sat_unsigned_accum_type(P) make_accum_type (P, 1, 1)
#define	make_or_reuse_signed_fract_type(P) make_or_reuse_fract_type (P, 0, 0)
#define	make_or_reuse_unsigned_fract_type(P) make_or_reuse_fract_type (P, 1, 0)
#define	make_or_reuse_sat_signed_fract_type(P) make_or_reuse_fract_type (P, 0, 1)
#define	make_or_reuse_sat_unsigned_fract_type(P) make_or_reuse_fract_type (P, 1, 1)
#define	make_or_reuse_signed_accum_type(P) make_or_reuse_accum_type (P, 0, 0)
#define	make_or_reuse_unsigned_accum_type(P) make_or_reuse_accum_type (P, 1, 0)
#define	make_or_reuse_sat_signed_accum_type(P) make_or_reuse_accum_type (P, 0, 1)
#define	make_or_reuse_sat_unsigned_accum_type(P) make_or_reuse_accum_type (P, 1, 1)
#define	build_type_variant(TYPE, CONST_P, VOLATILE_P)
#define	non_lvalue(T) non_lvalue_loc (UNKNOWN_LOCATION, T)
#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_binop(CODE, T1, T2) size_binop_loc (UNKNOWN_LOCATION, CODE, T1, T2)
#define	size_diffop(T1, T2) size_diffop_loc (UNKNOWN_LOCATION, T1, T2)
#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	round_up(T, N) round_up_loc (UNKNOWN_LOCATION, T, N)
#define	round_down(T, N) round_down_loc (UNKNOWN_LOCATION, T, N)
#define	BITS_PER_UNIT_LOG
#define	tree_cons(t, q, w) tree_cons_stat (t,q,w MEM_STAT_INFO)
#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	fold_unary(CODE, T1, T2) fold_unary_loc (UNKNOWN_LOCATION, CODE, T1, T2)
#define	fold_unary_ignore_overflow(CODE, T1, T2) fold_unary_ignore_overflow_loc (UNKNOWN_LOCATION, CODE, T1, T2)
#define	fold_binary(CODE, T1, T2, T3) fold_binary_loc (UNKNOWN_LOCATION, CODE, T1, T2, T3)
#define	fold_ternary(CODE, T1, T2, T3, T4) fold_ternary_loc (UNKNOWN_LOCATION, CODE, T1, T2, T3, T4)
#define	fold_build1(c, t1, t2) fold_build1_stat_loc (UNKNOWN_LOCATION, c, t1, t2 MEM_STAT_INFO)
#define	fold_build1_loc(l, c, t1, t2) fold_build1_stat_loc (l, c, t1, t2 MEM_STAT_INFO)
#define	fold_build2(c, t1, t2, t3) fold_build2_stat_loc (UNKNOWN_LOCATION, c, t1, t2, t3 MEM_STAT_INFO)
#define	fold_build2_loc(l, c, t1, t2, t3) fold_build2_stat_loc (l, c, t1, t2, t3 MEM_STAT_INFO)
#define	fold_build3(c, t1, t2, t3, t4) fold_build3_stat_loc (UNKNOWN_LOCATION, c, t1, t2, t3, t4 MEM_STAT_INFO)
#define	fold_build3_loc(l, c, t1, t2, t3, t4) fold_build3_stat_loc (l, c, t1, t2, t3, t4 MEM_STAT_INFO)
#define	fold_build_call_array(T1, T2, N, T4) fold_build_call_array_loc (UNKNOWN_LOCATION, T1, T2, N, T4)
#define	fold_build_call_array_initializer(T1, T2, N, T4) fold_build_call_array_initializer_loc (UNKNOWN_LOCATION, T1, T2, N, T4)
#define	fold_convert(T1, T2) fold_convert_loc (UNKNOWN_LOCATION, T1, T2)
#define	omit_one_operand(T1, T2, T3) omit_one_operand_loc (UNKNOWN_LOCATION, T1, T2, T3)
#define	omit_two_operands(T1, T2, T3, T4) omit_two_operands_loc (UNKNOWN_LOCATION, T1, T2, T3, T4)
#define	invert_truthvalue(T) invert_truthvalue_loc (UNKNOWN_LOCATION, T)
#define	build_fold_addr_expr(T) build_fold_addr_expr_loc (UNKNOWN_LOCATION, (T))
#define	build_fold_addr_expr_with_type(T, TYPE) build_fold_addr_expr_with_type_loc (UNKNOWN_LOCATION, (T), TYPE)
#define	build_fold_indirect_ref(T) build_fold_indirect_ref_loc (UNKNOWN_LOCATION, T)
#define	fold_indirect_ref(T) fold_indirect_ref_loc (UNKNOWN_LOCATION, T)
#define	build_simple_mem_ref(T) build_simple_mem_ref_loc (UNKNOWN_LOCATION, T)
#define	convert_to_ptrofftype(t) convert_to_ptrofftype_loc (UNKNOWN_LOCATION, t)
#define	fold_build_pointer_plus(p, o) fold_build_pointer_plus_loc (UNKNOWN_LOCATION, p, o)
#define	fold_build_pointer_plus_hwi(p, o) fold_build_pointer_plus_hwi_loc (UNKNOWN_LOCATION, p, o)
#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_priority_map_eq tree_map_base_eq
#define	tree_priority_map_hash tree_map_base_hash
#define	tree_priority_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	ANON_AGGRNAME_FORMAT "._%d"
#define	ANON_AGGRNAME_P(ID_NODE)

Functions
void	protected_set_expr_location (tree, location_t)
enum machine_mode	vector_type_mode (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)
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)
void	init_tree_optimization_optabs (tree)
tree	build_target_option_node (struct gcc_options *opts)
static int	tree_operand_length ()
tree	decl_assembler_name (tree)
bool	decl_assembler_name_equal (tree decl, const_tree asmname)
hashval_t	decl_assembler_name_hash (const_tree asmname)
size_t	tree_size (const_tree)
size_t	tree_code_size (enum tree_code)
int	allocate_decl_uid (void)
tree	make_node_stat (enum tree_code MEM_STAT_DECL)
tree	copy_node_stat (tree MEM_STAT_DECL)
tree	copy_list (tree)
tree	build_case_label (tree, tree, tree)
tree	make_tree_binfo_stat (unsigned MEM_STAT_DECL)
tree	make_tree_vec_stat (int MEM_STAT_DECL)
tree	get_identifier (const char *)
tree	get_identifier_with_length (const char *, size_t)
tree	maybe_get_identifier (const char *)
tree	build_nt (enum tree_code,...)
tree	build_nt_call_vec (tree, vec< tree, va_gc > *)
tree	build0_stat (enum tree_code, tree MEM_STAT_DECL)
tree	build1_stat (enum tree_code, tree, tree MEM_STAT_DECL)
tree	build2_stat (enum tree_code, tree, tree, tree MEM_STAT_DECL)
tree	build3_stat (enum tree_code, tree, tree, tree, tree MEM_STAT_DECL)
tree	build4_stat (enum tree_code, tree, tree, tree, tree, tree MEM_STAT_DECL)
tree	build5_stat (enum tree_code, tree, tree, tree, tree, tree, tree MEM_STAT_DECL)
static tree	build1_stat_loc (location_t loc, enum tree_code code, tree type, tree arg1 MEM_STAT_DECL)
static tree	build2_stat_loc (location_t loc, enum tree_code code, tree type, tree arg0, tree arg1 MEM_STAT_DECL)
static tree	build3_stat_loc (location_t loc, enum tree_code code, tree type, tree arg0, tree arg1, tree arg2 MEM_STAT_DECL)
static tree	build4_stat_loc (location_t loc, enum tree_code code, tree type, tree arg0, tree arg1, tree arg2, tree arg3 MEM_STAT_DECL)
static tree	build5_stat_loc (location_t loc, enum tree_code code, tree type, tree arg0, tree arg1, tree arg2, tree arg3, tree arg4 MEM_STAT_DECL)
tree	build_var_debug_value_stat (tree, tree MEM_STAT_DECL)
static double_int	tree_to_double_int ()
tree	double_int_to_tree (tree, double_int)
bool	double_int_fits_to_tree_p (const_tree, double_int)
tree	force_fit_type_double (tree, double_int, int, bool)
static tree	build_int_cstu ()
tree	build_int_cst (tree, HOST_WIDE_INT)
tree	build_int_cst_type (tree, HOST_WIDE_INT)
tree	build_int_cst_wide (tree, unsigned HOST_WIDE_INT, HOST_WIDE_INT)
tree	make_vector_stat (unsigned MEM_STAT_DECL)
tree	build_vector_stat (tree, tree *MEM_STAT_DECL)
tree	build_vector_from_ctor (tree, vec< constructor_elt, va_gc > *)
tree	build_vector_from_val (tree, tree)
tree	build_constructor (tree, vec< constructor_elt, va_gc > *)
tree	build_constructor_single (tree, tree, tree)
tree	build_constructor_from_list (tree, tree)
tree	build_constructor_va (tree, int,...)
tree	build_real_from_int_cst (tree, const_tree)
tree	build_complex (tree, tree, 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_string (int, const char *)
tree	build_tree_list_stat (tree, tree MEM_STAT_DECL)
tree	build_tree_list_vec_stat (const vec< tree, va_gc > *MEM_STAT_DECL)
tree	build_decl_stat (location_t, enum tree_code, tree, tree MEM_STAT_DECL)
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_stat (enum tree_code, int MEM_STAT_DECL)
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, vec< tree, va_gc > *)
tree	make_signed_type (int)
tree	make_unsigned_type (int)
tree	signed_or_unsigned_type_for (int, tree)
tree	signed_type_for (tree)
tree	unsigned_type_for (tree)
tree	truth_type_for (tree)
void	initialize_sizetypes (void)
void	fixup_unsigned_type (tree)
tree	build_pointer_type_for_mode (tree, enum machine_mode, bool)
tree	build_pointer_type (tree)
tree	build_reference_type_for_mode (tree, enum machine_mode, bool)
tree	build_reference_type (tree)
tree	build_vector_type_for_mode (tree, enum machine_mode)
tree	build_vector_type (tree innertype, int nunits)
tree	build_opaque_vector_type (tree innertype, int nunits)
tree	build_type_no_quals (tree)
tree	build_index_type (tree)
tree	build_array_type (tree, tree)
tree	build_nonshared_array_type (tree, tree)
tree	build_array_type_nelts (tree, unsigned HOST_WIDE_INT)
tree	build_function_type (tree, tree)
tree	build_function_type_list (tree,...)
tree	build_function_decl_skip_args (tree, bitmap, bool)
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)
tree	array_type_nelts (const_tree)
bool	in_array_bounds_p (tree)
bool	range_in_array_bounds_p (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)
int	attribute_list_equal (const_tree, const_tree)
int	attribute_list_contained (const_tree, const_tree)
int	tree_int_cst_equal (const_tree, const_tree)
int	tree_int_cst_lt (const_tree, const_tree)
int	tree_int_cst_compare (const_tree, const_tree)
int	host_integerp (const_tree, int) ATTRIBUTE_PURE
HOST_WIDE_INT	tree_low_cst (const_tree, int)
HOST_WIDE_INT	size_low_cst (const_tree)
int	tree_int_cst_sgn (const_tree)
int	tree_int_cst_sign_bit (const_tree)
unsigned int	tree_int_cst_min_precision (tree, bool)
bool	tree_expr_nonnegative_p (tree)
bool	tree_expr_nonnegative_warnv_p (tree, bool *)
bool	may_negate_without_overflow_p (const_tree)
tree	strip_array_types (tree)
tree	excess_precision_type (tree)
bool	valid_constant_size_p (const_tree)
unsigned int	element_precision (const_tree)
tree	make_fract_type (int, int, int)
tree	make_accum_type (int, int, int)
tree	make_tree (tree, rtx)
tree	build_type_attribute_variant (tree, tree)
tree	build_decl_attribute_variant (tree, tree)
tree	build_type_attribute_qual_variant (tree, tree, int)
void	omp_remove_redundant_declare_simd_attrs (tree)
int	comp_type_attributes (const_tree, const_tree)
tree	merge_decl_attributes (tree, tree)
tree	merge_type_attributes (tree, tree)
tree	private_lookup_attribute (const char *, size_t, tree)
static tree	lookup_attribute ()
bool	private_is_attribute_p (const char *, size_t, const_tree)
static bool	is_attribute_p ()
tree	remove_attribute (const char *, tree)
tree	merge_attributes (tree, tree)
bool	check_qualified_type (const_tree, const_tree, int)
tree	get_qualified_type (tree, int)
tree	build_qualified_type (tree, int)
tree	build_aligned_type (tree, unsigned int)
tree	build_distinct_type_copy (tree)
tree	build_variant_type_copy (tree)
void	finish_builtin_struct (tree, const char *, tree, tree)
void	layout_type (tree)
record_layout_info	start_record_layout (tree)
tree	bit_from_pos (tree, tree)
tree	byte_from_pos (tree, tree)
void	pos_from_bit (tree , tree , unsigned int, tree)
void	normalize_offset (tree , tree , unsigned int)
tree	rli_size_unit_so_far (record_layout_info)
tree	rli_size_so_far (record_layout_info)
void	normalize_rli (record_layout_info)
void	place_field (record_layout_info, tree)
void	compute_record_mode (tree)
void	finish_record_layout (record_layout_info, int)
tree	type_hash_canon (unsigned int, tree)
void	layout_decl (tree, unsigned)
void	relayout_decl (tree)
enum machine_mode	mode_for_size_tree (const_tree, enum mode_class, int)
tree	non_lvalue_loc (location_t, tree)
tree	convert (tree, tree)
unsigned int	expr_align (const_tree)
tree	expr_first (tree)
tree	expr_last (tree)
tree	size_in_bytes (const_tree)
HOST_WIDE_INT	int_size_in_bytes (const_tree)
HOST_WIDE_INT	max_int_size_in_bytes (const_tree)
tree	tree_expr_size (const_tree)
tree	bit_position (const_tree)
HOST_WIDE_INT	int_bit_position (const_tree)
tree	byte_position (const_tree)
HOST_WIDE_INT	int_byte_position (const_tree)
tree	size_int_kind (HOST_WIDE_INT, enum size_type_kind)
tree	size_binop_loc (location_t, enum tree_code, tree, tree)
tree	size_diffop_loc (location_t, tree, tree)
tree	round_up_loc (location_t, tree, int)
tree	round_down_loc (location_t, tree, int)
void	finalize_size_functions (void)
tree	chainon (tree, tree)
tree	tree_cons_stat (tree, tree, tree MEM_STAT_DECL)
tree	tree_last (tree)
tree	nreverse (tree)
int	list_length (const_tree)
int	fields_length (const_tree)
tree	first_field (const_tree)
bool	initializer_zerop (const_tree)
tree	uniform_vector_p (const_tree)
vec< tree, va_gc > *	ctor_to_vec (tree)
bool	categorize_ctor_elements (const_tree, HOST_WIDE_INT , HOST_WIDE_INT , bool *)
bool	complete_ctor_at_level_p (const_tree, HOST_WIDE_INT, const_tree)
int	integer_zerop (const_tree)
int	integer_onep (const_tree)
int	integer_all_onesp (const_tree)
int	integer_minus_onep (const_tree)
int	integer_pow2p (const_tree)
int	integer_nonzerop (const_tree)
bool	cst_and_fits_in_hwi (const_tree)
tree	num_ending_zeros (const_tree)
int	fixed_zerop (const_tree)
tree	staticp (tree)
tree	save_expr (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	variable_size (tree)
tree	stabilize_reference (tree)
tree	stabilize_reference_1 (tree)
tree	get_unwidened (tree, tree)
tree	get_narrower (tree, int *)
static bool	handled_component_p ()
tree	get_inner_reference (tree, HOST_WIDE_INT , HOST_WIDE_INT , tree , enum machine_mode , int , int , bool)
tree	array_ref_element_size (tree)
bool	array_at_struct_end_p (tree)
tree	array_ref_low_bound (tree)
tree	array_ref_up_bound (tree)
tree	component_ref_field_offset (tree)
tree	get_containing_scope (const_tree)
tree	decl_function_context (const_tree)
tree	decl_type_context (const_tree)
int	real_zerop (const_tree)
static void	function_args_iter_init ()
static tree *	function_args_iter_cond_ptr ()
static tree	function_args_iter_cond ()
static void	function_args_iter_next ()
static bool	inlined_function_outer_scope_p ()
unsigned	crc32_string (unsigned, const char *)
unsigned	crc32_byte (unsigned, char)
unsigned	crc32_unsigned (unsigned, unsigned)
void	clean_symbol_name (char *)
tree	get_file_function_name (const char *)
tree	get_callee_fndecl (const_tree)
int	type_num_arguments (const_tree)
bool	associative_tree_code (enum tree_code)
bool	commutative_tree_code (enum tree_code)
bool	commutative_ternary_tree_code (enum tree_code)
tree	upper_bound_in_type (tree, tree)
tree	lower_bound_in_type (tree, tree)
int	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 (tree)
bool	is_typedef_decl (tree x)
bool	typedef_variant_p (tree)
bool	auto_var_in_fn_p (const_tree, const_tree)
tree	build_low_bits_mask (tree, unsigned)
tree	tree_strip_nop_conversions (tree)
tree	tree_strip_sign_nop_conversions (tree)
const_tree	strip_invariant_refs (const_tree)
tree	lhd_gcc_personality (void)
void	assign_assembler_name_if_neeeded (tree)
void	warn_deprecated_use (tree, tree)
void	cache_integer_cst (tree)
void	change_decl_assembler_name (tree, tree)
tree	unshare_expr (tree)
tree	unshare_expr_without_location (tree)
void	expand_label (tree)
void	expand_goto (tree)
rtx	expand_stack_save (void)
void	expand_stack_restore (tree)
void	expand_return (tree)
static int	struct_ptr_eq ()
static hashval_t	struct_ptr_hash ()
int	native_encode_expr (const_tree, unsigned char *, int)
tree	native_interpret_expr (tree, const unsigned char *, int)
tree	fold (tree)
tree	fold_unary_loc (location_t, enum tree_code, tree, tree)
tree	fold_unary_ignore_overflow_loc (location_t, enum tree_code, tree, tree)
tree	fold_binary_loc (location_t, enum tree_code, tree, tree, tree)
tree	fold_ternary_loc (location_t, enum tree_code, tree, tree, tree, tree)
tree	fold_build1_stat_loc (location_t, enum tree_code, tree, tree MEM_STAT_DECL)
tree	fold_build2_stat_loc (location_t, enum tree_code, tree, tree, tree MEM_STAT_DECL)
tree	fold_build3_stat_loc (location_t, enum tree_code, tree, tree, tree, tree MEM_STAT_DECL)
tree	fold_build1_initializer_loc (location_t, enum tree_code, tree, tree)
tree	fold_build2_initializer_loc (location_t, enum tree_code, tree, tree, tree)
tree	fold_build3_initializer_loc (location_t, enum tree_code, tree, tree, tree, tree)
tree	fold_build_call_array_loc (location_t, tree, tree, int, tree *)
tree	fold_build_call_array_initializer_loc (location_t, tree, tree, int, tree *)
bool	fold_convertible_p (const_tree, const_tree)
tree	fold_convert_loc (location_t, tree, tree)
tree	fold_single_bit_test (location_t, enum tree_code, tree, tree, tree)
tree	fold_ignored_result (tree)
tree	fold_abs_const (tree, tree)
tree	fold_indirect_ref_1 (location_t, tree, tree)
void	fold_defer_overflow_warnings (void)
void	fold_undefer_overflow_warnings (bool, const_gimple, int)
void	fold_undefer_and_ignore_overflow_warnings (void)
bool	fold_deferring_overflow_warnings_p (void)
tree	fold_fma (location_t, tree, tree, tree, tree)
int	operand_equal_p (const_tree, const_tree, unsigned int)
int	multiple_of_p (tree, const_tree, const_tree)
tree	omit_one_operand_loc (location_t, tree, tree, tree)
tree	omit_two_operands_loc (location_t, tree, tree, tree, tree)
tree	invert_truthvalue_loc (location_t, tree)
tree	fold_unary_to_constant (enum tree_code, tree, tree)
tree	fold_binary_to_constant (enum tree_code, tree, tree, tree)
tree	fold_read_from_constant_string (tree)
tree	int_const_binop (enum tree_code, const_tree, const_tree)
tree	build_fold_addr_expr_loc (location_t, tree)
tree	build_fold_addr_expr_with_type_loc (location_t, tree, tree)
tree	fold_build_cleanup_point_expr (tree type, tree expr)
tree	fold_strip_sign_ops (tree)
tree	build_fold_indirect_ref_loc (location_t, tree)
tree	fold_indirect_ref_loc (location_t, tree)
tree	build_simple_mem_ref_loc (location_t, tree)
double_int	mem_ref_offset (const_tree)
tree	build_invariant_address (tree, tree, HOST_WIDE_INT)
tree	constant_boolean_node (bool, tree)
tree	div_if_zero_remainder (enum tree_code, const_tree, const_tree)
bool	tree_swap_operands_p (const_tree, const_tree, bool)
enum tree_code	swap_tree_comparison (enum tree_code)
bool	ptr_difference_const (tree, tree, HOST_WIDE_INT *)
enum tree_code	invert_tree_comparison (enum tree_code, bool)
bool	tree_expr_nonzero_p (tree)
bool	tree_unary_nonzero_warnv_p (enum tree_code, tree, tree, bool *)
bool	tree_binary_nonzero_warnv_p (enum tree_code, tree, tree, tree op1, bool *)
bool	tree_single_nonzero_warnv_p (tree, bool *)
bool	tree_unary_nonnegative_warnv_p (enum tree_code, tree, tree, bool *)
bool	tree_binary_nonnegative_warnv_p (enum tree_code, tree, tree, tree, bool *)
bool	tree_single_nonnegative_warnv_p (tree t, bool *strict_overflow_p)
bool	tree_invalid_nonnegative_warnv_p (tree t, bool *strict_overflow_p)
bool	tree_call_nonnegative_warnv_p (tree, tree, tree, tree, bool *)
bool	tree_expr_nonzero_warnv_p (tree, bool *)
bool	fold_real_zero_addition_p (const_tree, const_tree, int)
tree	combine_comparisons (location_t, enum tree_code, enum tree_code, enum tree_code, tree, tree, tree)
void	debug_fold_checksum (const_tree)
static bool	truth_value_p ()
static bool	ptrofftype_p ()
static tree	convert_to_ptrofftype_loc ()
static tree	fold_build_pointer_plus_loc ()
static tree	fold_build_pointer_plus_hwi_loc ()
bool	avoid_folding_inline_builtin (tree)
tree	fold_call_expr (location_t, tree, bool)
tree	fold_builtin_fputs (location_t, tree, tree, bool, bool, tree)
tree	fold_builtin_strcpy (location_t, tree, tree, tree, tree)
tree	fold_builtin_strncpy (location_t, tree, tree, tree, tree, tree)
tree	fold_builtin_memory_chk (location_t, tree, tree, tree, tree, tree, tree, bool, enum built_in_function)
tree	fold_builtin_stxcpy_chk (location_t, tree, tree, tree, tree, tree, bool, enum built_in_function)
tree	fold_builtin_stxncpy_chk (location_t, tree, tree, tree, tree, tree, bool, enum built_in_function)
tree	fold_builtin_snprintf_chk (location_t, tree, tree, enum built_in_function)
bool	fold_builtin_next_arg (tree, bool)
enum built_in_function	builtin_mathfn_code (const_tree)
tree	fold_builtin_call_array (location_t, tree, tree, int, tree *)
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	mathfn_built_in (tree, enum built_in_function fn)
tree	c_strlen (tree, int)
tree	build_string_literal (int, const char *)
bool	validate_arglist (const_tree,...)
rtx	builtin_memset_read_str (void *, HOST_WIDE_INT, enum machine_mode)
bool	is_builtin_fn (tree)
bool	get_object_alignment_1 (tree, unsigned int , unsigned HOST_WIDE_INT )
unsigned int	get_object_alignment (tree)
bool	get_pointer_alignment_1 (tree, unsigned int , unsigned HOST_WIDE_INT )
unsigned int	get_pointer_alignment (tree)
tree	fold_call_stmt (gimple, bool)
tree	gimple_fold_builtin_snprintf_chk (gimple, tree, enum built_in_function)
tree	make_range (tree, int , tree , tree , bool )
tree	make_range_step (location_t, enum tree_code, tree, tree, tree, tree , tree , int , bool )
tree	build_range_check (location_t, tree, tree, int, tree, tree)
bool	merge_ranges (int , tree , tree *, int, tree, tree, int, tree, tree)
void	set_builtin_user_assembler_name (tree decl, const char *asmspec)
bool	is_simple_builtin (tree)
bool	is_inexpensive_builtin (tree)
tree	strip_float_extensions (tree)
int	really_constant_p (const_tree)
bool	decl_address_invariant_p (const_tree)
bool	decl_address_ip_invariant_p (const_tree)
bool	int_fits_type_p (const_tree, const_tree)
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)
int	simple_cst_equal (const_tree, const_tree)
hashval_t	iterative_hash_expr (const_tree, hashval_t)
hashval_t	iterative_hash_exprs_commutative (const_tree, const_tree, hashval_t)
hashval_t	iterative_hash_host_wide_int (HOST_WIDE_INT, hashval_t)
hashval_t	iterative_hash_hashval_t (hashval_t, hashval_t)
int	compare_tree_int (const_tree, unsigned HOST_WIDE_INT)
int	type_list_equal (const_tree, const_tree)
int	chain_member (const_tree, const_tree)
int	simple_cst_list_equal (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)
int	real_onep (const_tree)
int	real_twop (const_tree)
int	real_minus_onep (const_tree)
void	init_ttree (void)
void	build_common_tree_nodes (bool, bool)
void	build_common_builtin_nodes (void)
tree	build_nonstandard_integer_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)
HOST_WIDEST_INT	widest_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)
tree	block_ultimate_origin (const_tree)
tree	get_binfo_at_offset (tree, HOST_WIDE_INT, tree)
bool	virtual_method_call_p (tree)
tree	obj_type_ref_class (tree ref)
bool	types_same_for_odr (tree type1, tree type2)
bool	contains_bitfld_component_ref_p (const_tree)
bool	type_in_anonymous_namespace_p (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)
tree	build_addr (tree, tree)
void	expand_main_function (void)
void	expand_function_end (void)
void	expand_function_start (tree)
void	stack_protect_prologue (void)
void	stack_protect_epilogue (void)
void	init_dummy_function_start (void)
void	expand_dummy_function_end (void)
void	allocate_struct_function (tree, bool)
void	push_struct_function (tree fndecl)
void	init_function_start (tree)
bool	use_register_for_decl (const_tree)
void	generate_setjmp_warnings (void)
void	init_temp_slots (void)
void	free_temp_slots (void)
void	pop_temp_slots (void)
void	push_temp_slots (void)
void	preserve_temp_slots (rtx)
int	aggregate_value_p (const_tree, const_tree)
void	push_function_context (void)
void	pop_function_context (void)
gimple_seq	gimplify_parameters (void)
void	debug_tree (tree)
void	debug_raw (const tree_node &ref)
void	debug_raw (const tree_node *ptr)
void	debug (const tree_node &ref)
void	debug (const tree_node *ptr)
void	debug_verbose (const tree_node &ref)
void	debug_verbose (const tree_node *ptr)
void	debug_head (const tree_node &ref)
void	debug_head (const tree_node *ptr)
void	debug_body (const tree_node &ref)
void	debug_body (const tree_node *ptr)
void	debug_vec_tree (vec< tree, va_gc > *)
void	debug (vec< tree, va_gc > &ref)
void	debug (vec< tree, va_gc > *ptr)
void	debug_raw (vec< tree, va_gc > &ref)
void	debug_raw (vec< tree, va_gc > *ptr)
bool	debug_find_tree (tree, tree)
tree	build_duplicate_type (tree)
int	flags_from_decl_or_type (const_tree)
int	call_expr_flags (const_tree)
void	set_call_expr_flags (tree, int)
int	setjmp_call_p (const_tree)
bool	gimple_alloca_call_p (const_gimple)
bool	alloca_call_p (const_tree)
bool	must_pass_in_stack_var_size (enum machine_mode, const_tree)
bool	must_pass_in_stack_var_size_or_pad (enum machine_mode, const_tree)
struct attribute_spec *	lookup_attribute_spec (const_tree)
struct attribute_spec *	lookup_scoped_attribute_spec (const_tree, const_tree)
void	init_attributes (void)
tree	decl_attributes (tree *, tree, int)
bool	cxx11_attribute_p (const_tree)
tree	get_attribute_name (const_tree)
tree	get_attribute_namespace (const_tree)
void	apply_tm_attr (tree, tree)
void	set_min_and_max_values_for_integral_type (tree, int, bool)
void	fixup_signed_type (tree)
void	internal_reference_types (void)
unsigned int	update_alignment_for_field (record_layout_info, tree, unsigned int)
tree	tree_output_constant_def (tree)
void	make_decl_rtl (tree)
rtx	make_decl_rtl_for_debug (tree)
void	make_decl_one_only (tree, tree)
int	supports_one_only (void)
void	resolve_unique_section (tree, int, int)
void	mark_referenced (tree)
void	mark_decl_referenced (tree)
void	notice_global_symbol (tree)
void	set_user_assembler_name (tree, const char *)
void	process_pending_assemble_externals (void)
bool	decl_replaceable_p (tree)
bool	decl_binds_to_current_def_p (tree)
enum tls_model	decl_default_tls_model (const_tree)
void	declare_weak (tree)
void	merge_weak (tree, tree)
void	assemble_alias (tree, tree)
tree	initializer_constant_valid_p (tree, tree)
bool	initializer_constant_valid_for_bitfield_p (tree)
bool	constructor_static_from_elts_p (const_tree)
void	expand_computed_goto (tree)
bool	parse_output_constraint (const char *, int, int, int, bool , bool , bool )
bool	parse_input_constraint (const char *, int, int, int, int, const char const , bool , bool *)
void	expand_asm_stmt (gimple)
tree	resolve_asm_operand_names (tree, tree, tree, tree)
tree	walk_tree_1 (tree , walk_tree_fn, void , struct pointer_set_t *, walk_tree_lh)
tree	walk_tree_without_duplicates_1 (tree , walk_tree_fn, void , walk_tree_lh)
void	set_decl_rtl (tree, rtx)
void	set_decl_incoming_rtl (tree, rtx, bool)
tree	get_base_address (tree t)
void	mark_addressable (tree)
int	tree_map_base_eq (const void , const void )
unsigned int	tree_map_base_hash (const void *)
int	tree_map_base_marked_p (const void *)
bool	list_equal_p (const_tree, const_tree)
unsigned int	tree_map_hash (const void *)
unsigned int	tree_decl_map_hash (const void *)
bool	ssa_name_nonnegative_p (const_tree)
void	init_object_sizes (void)
void	fini_object_sizes (void)
unsigned HOST_WIDE_INT	compute_builtin_object_size (tree, int)
int	can_move_by_pieces (unsigned HOST_WIDE_INT, unsigned int)
bool	addr_expr_of_non_mem_decl_p (tree)
unsigned HOST_WIDE_INT	highest_pow2_factor (const_tree)
tree	build_personality_function (const char *)
tree	build_tm_abort_call (location_t, bool)
bool	is_tm_safe (const_tree)
bool	is_tm_pure (const_tree)
bool	is_tm_may_cancel_outer (tree)
bool	is_tm_ending_fndecl (tree)
void	record_tm_replacement (tree, tree)
void	tm_malloc_replacement (tree)
static bool	is_tm_safe_or_pure ()
void	init_inline_once (void)
static void	init_call_expr_arg_iterator ()
static void	init_const_call_expr_arg_iterator ()
static tree	next_call_expr_arg ()
static const_tree	next_const_call_expr_arg ()
static tree	first_call_expr_arg ()
static const_tree	first_const_call_expr_arg ()
static bool	more_call_expr_args_p ()
static bool	more_const_call_expr_args_p ()
static bool	is_lang_specific ()
void	save_vtable_map_decl (tree)
static tree	builtin_decl_explicit ()
static tree	builtin_decl_implicit ()
static void	set_builtin_decl ()
static void	set_builtin_decl_implicit_p ()
static bool	builtin_decl_explicit_p ()
static bool	builtin_decl_implicit_p ()
static bool	is_global_var ()
static bool	may_be_aliased ()

Variables
int	folding_initializer
bool	force_folding_builtin_constant_p

Macro Definition Documentation

#define access_private_node global_trees[TI_PRIVATE]

#define access_protected_node global_trees[TI_PROTECTED]

#define access_public_node global_trees[TI_PUBLIC]

Base access nodes.

#define accum_type_node global_trees[TI_ACCUM_TYPE]

#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 build_access_from_expr_1(), build_one_cst(), and lookup_decl().

#define ANON_AGGRNAME_FORMAT "._%d"

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.

#define ANON_AGGRNAME_P ( ID_NODE )

Value:

(IDENTIFIER_POINTER (ID_NODE)[0] == '.' \

&& IDENTIFIER_POINTER (ID_NODE)[1] == '_')

Referenced by DFS_write_tree_body(), and write_ts_common_tree_pointers().

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

#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.

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

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

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

#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.

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

#define ASSERT_EXPR_COND ( NODE ) TREE_OPERAND (ASSERT_EXPR_CHECK (NODE), 1)

Referenced by process_assert_insertions_for().

#define ASSERT_EXPR_VAR ( NODE ) TREE_OPERAND (ASSERT_EXPR_CHECK (NODE), 0)

ASSERT_EXPR accessors.

Referenced by interpret_loop_phi(), and process_assert_insertions_for().

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

Nonzero if NODE represents a binary arithmetic expression.

Referenced by decl_address_ip_invariant_p().

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

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

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

The operands of a BIND_EXPR.

#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_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.

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

#define BINFO_BASE_BINFO	(	NODE,
		N
	)	((*BINFO_BASE_BINFOS (NODE))[(N)])

Accessor macro to get to the Nth base binfo of this binfo.

#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 lto_input_ts_block_tree_pointers(), and write_ts_vec_tree_pointers().

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

Referenced by maybe_record_node(), and new_alias_set().

#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_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.

#define BINFO_MARKED ( NODE ) TREE_LANG_FLAG_0 (TREE_BINFO_CHECK (NODE))

Flags for language dependent use.

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

The number of basetypes for NODE.

#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 write_ts_vec_tree_pointers().

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

#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.

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

The actual data type node being inherited in this basetype.

Referenced by maybe_record_node(), new_alias_set(), and walk_tree_without_duplicates_1().

#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.

#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.

#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.

#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.

#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 hash_type_name(), and maybe_record_node().

#define BITS_PER_UNIT_LOG

Value:

((BITS_PER_UNIT > 1) + (BITS_PER_UNIT > 2) + (BITS_PER_UNIT > 4) \
   + (BITS_PER_UNIT > 8) + (BITS_PER_UNIT > 16) + (BITS_PER_UNIT > 32) \
   + (BITS_PER_UNIT > 64) + (BITS_PER_UNIT > 128) + (BITS_PER_UNIT > 256))

Type for sizes of data-type.

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

Referenced by dr_analyze_indices(), finish_bitfield_layout(), and gimple_get_virt_method_for_binfo().

#define bitsize_one_node global_trees[TI_BITSIZE_ONE]

#define bitsize_unit_node global_trees[TI_BITSIZE_UNIT]

Referenced by relayout_decl().

#define bitsize_zero_node global_trees[TI_BITSIZE_ZERO]

#define bitsizetype sizetype_tab[(int) stk_bitsizetype]

Referenced by dr_analyze_indices(), and relayout_decl().

#define BLOCK_ABSTRACT ( NODE ) (BLOCK_CHECK (NODE)->block.abstract_flag)

Referenced by mark_all_vars_used().

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

Referenced by lhd_complain_wrong_lang_p(), lhd_print_error_function(), and uses_local_type_r().

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

Referenced by lto_input_ts_vec_tree_pointers(), pad_below(), regno_clobbered_at_setjmp(), setjmp_vars_warning(), and verify_rtx_sharing().

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

Referenced by premark_types_used_by_global_vars().

#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.

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

#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_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_top_level_skeleton_die_attrs(), asm_str_count(), gen_call_site_die(), gen_subprogram_die(), generate_setjmp_warnings(), mark_all_vars_used(), and member_declared_type().

#define BLOCK_SAME_RANGE ( NODE ) (BLOCK_CHECK (NODE)->base.u.bits.nameless_flag)

True if BLOCK has the same ranges as its BLOCK_SUPERCONTEXT.

#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 lhd_print_error_function(), and mark_all_vars_used().

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

Referenced by lto_input_ts_vec_tree_pointers(), setjmp_vars_warning(), and verify_rtx_sharing().

#define BLOCK_SUPERCONTEXT ( NODE ) (BLOCK_CHECK (NODE)->block.supercontext)

Referenced by add_debug_prefix_map(), dump_block_node(), lhd_print_error_function(), lto_input_ts_vec_tree_pointers(), and member_declared_type().

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

In a BLOCK node.

Referenced by canonicalize_component_ref(), expand_task_call(), free_lang_data_in_binfo(), get_formal_tmp_var(), init_inline_once(), lower_omp_sections(), maybe_add_implicit_barrier_cancel(), uses_local_type_r(), and verify_rtx_sharing().

#define boolean_false_node global_trees[TI_BOOLEAN_FALSE]

Referenced by and_var_with_comparison_1(), associate_equivalences_with_edges(), can_unroll_loop_p(), check_array_bounds(), ifcombine_ifandif(), number_of_iterations_lt_to_ne(), process_assert_insertions_for(), same_bool_result_p(), and simplify_using_outer_evolutions().

#define boolean_true_node global_trees[TI_BOOLEAN_TRUE]

Referenced by and_var_with_comparison_1(), associate_equivalences_with_edges(), can_unroll_loop_p(), check_array_bounds(), expand_builtin_atomic_exchange(), get_memmodel(), ifcombine_ifandif(), or_var_with_comparison(), or_var_with_comparison_1(), and tree_unswitch_single_loop().

#define boolean_type_node global_trees[TI_BOOLEAN_TYPE]

Referenced by create_bb(), derive_constant_upper_bound_assign(), ifcombine_ifandif(), instrument_builtin_call(), number_of_iterations_lt_to_ne(), optimize_stmt(), or_comparisons_1(), shortcut_cond_expr(), tree_simplify_using_condition(), and vect_create_cond_for_alias_checks().

#define BOUNDED_P ( node ) BOUNDED_TYPE_P (TREE_TYPE (node))

Nonzero for objects with bounded type.

#define BOUNDED_TYPE_P ( type ) (POINTER_TYPE_P (type))

Nonzero if this type supposes bounds existence.

#define build0	(	c,
		t
	)	build0_stat (c,t MEM_STAT_INFO)

Referenced by build_type_attribute_qual_variant().

#define build1	(	c,
		t1,
		t2
	)	build1_stat (c,t1,t2 MEM_STAT_INFO)

Referenced by complex_visit_phi(), expand_builtin_va_copy(), expand_complex_conjugate(), gimplify_init_ctor_eval(), infer_value_range(), initializer_constant_valid_p_1(), nesting_copy_decl(), tree_ssa_strip_useless_type_conversions(), update_complex_components_on_edge(), and vec_cst_ctor_to_array().

#define build1_loc	(	l,
		c,
		t1,
		t2
	)	build1_stat_loc (l,c,t1,t2 MEM_STAT_INFO)

#define build2	(	c,
		t1,
		t2,
		t3
	)	build2_stat (c,t1,t2,t3 MEM_STAT_INFO)

Referenced by assign_parms(), default_member_type_forces_blk(), fold_build_cond_expr(), fold_mathfn_compare(), forward_propagate_addr_expr(), get_frame_arg(), gimplify_init_ctor_preeval_1(), gimplify_return_expr(), infer_value_range(), instrument_builtin_call(), is_gimple_val(), lookup_tmp_var(), stringop_block_profile(), tree_to_aff_combination(), and vect_permute_store_chain().

#define build2_loc	(	l,
		c,
		t1,
		t2,
		t3
	)	build2_stat_loc (l,c,t1,t2,t3 MEM_STAT_INFO)

Referenced by exact_inverse(), and expand_omp_sections().

#define build3	(	c,
		t1,
		t2,
		t3,
		t4
	)	build3_stat (c,t1,t2,t3,t4 MEM_STAT_INFO)

Referenced by create_phi_for_local_result(), get_frame_field(), and remap_vla_decls().

#define build3_loc	(	l,
		c,
		t1,
		t2,
		t3,
		t4
	)	build3_stat_loc (l,c,t1,t2,t3,t4 MEM_STAT_INFO)

#define build4	(	c,
		t1,
		t2,
		t3,
		t4,
		t5
	)	build4_stat (c,t1,t2,t3,t4,t5 MEM_STAT_INFO)

Referenced by coverage_counter_alloc(), expand_builtin_va_copy(), gimple_get_virt_method_for_binfo(), and gimplify_modify_expr_to_memset().

#define build4_loc	(	l,
		c,
		t1,
		t2,
		t3,
		t4,
		t5
	)	build4_stat_loc (l,c,t1,t2,t3,t4,t5 MEM_STAT_INFO)

#define build5	(	c,
		t1,
		t2,
		t3,
		t4,
		t5,
		t6
	)	build5_stat (c,t1,t2,t3,t4,t5,t6 MEM_STAT_INFO)

#define build5_loc	(	l,
		c,
		t1,
		t2,
		t3,
		t4,
		t5,
		t6
	)	build5_stat_loc (l,c,t1,t2,t3,t4,t5,t6 MEM_STAT_INFO)

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

#define build_decl	(	l,
		c,
		t,
		q
	)	build_decl_stat (l, c, t, q MEM_STAT_INFO)

Referenced by build3_stat(), build_sender_ref(), copy_decl_no_change(), coverage_obj_init(), create_tmp_var_name(), default_function_arg_round_boundary(), default_stack_protect_guard(), finalize_task_copyfn(), get_emutls_object_name(), get_frame_field(), lhd_omp_predetermined_sharing(), ubsan_source_location_type(), and use_register_for_decl().

#define build_fold_addr_expr ( T ) build_fold_addr_expr_loc (UNKNOWN_LOCATION, (T))

Referenced by build1_stat(), compute_antic(), constant_pointer_difference(), create_call_for_reduction(), expand_builtin_prefetch(), gimple_call_reset_alias_info(), instrument_builtin_call(), loop_has_blocks_with_irreducible_flag(), object_address_invariant_in_loop_p(), split_constant_offset(), and tree_to_aff_combination().

#define build_fold_addr_expr_with_type	(	T,
		TYPE
	)	build_fold_addr_expr_with_type_loc (UNKNOWN_LOCATION, (T), TYPE)

#define build_fold_indirect_ref ( T ) build_fold_indirect_ref_loc (UNKNOWN_LOCATION, T)

Referenced by assign_parms(), fold_builtin_sprintf_chk_1(), and gimplify_return_expr().

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

#define build_simple_mem_ref ( T ) build_simple_mem_ref_loc (UNKNOWN_LOCATION, T)

Referenced by ao_ref_from_mem(), create_phi_for_local_result(), get_frame_field(), loop_has_blocks_with_irreducible_flag(), and omp_copy_decl_2().

#define build_tree_list	(	t,
		q
	)	build_tree_list_stat (t, q MEM_STAT_INFO)

#define build_tree_list_vec ( v ) build_tree_list_vec_stat (v MEM_STAT_INFO)

#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 expand_builtin_va_copy().

#define build_var_debug_value	(	t1,
		t2
	)	build_var_debug_value_stat (t1,t2 MEM_STAT_INFO)

#define build_varargs_function_type_vec	(	RET,
		V
	)

Value:

build_varargs_function_type_array (RET, vec_safe_length (V), \

vec_safe_address (V))

#define build_vector	(	t,
		v
	)	build_vector_stat (t, v MEM_STAT_INFO)

Referenced by vect_get_mask_element().

#define build_vl_exp	(	c,
		n
	)	build_vl_exp_stat (c, n MEM_STAT_INFO)

#define BUILTIN_CBRT_P ( FN ) ((FN) == BUILT_IN_CBRT || (FN) == BUILT_IN_CBRTF || (FN) == BUILT_IN_CBRTL)

Referenced by integer_valued_real_p().

#define BUILTIN_EXP10_P ( FN )

Value:

((FN) == BUILT_IN_EXP10 || (FN) == BUILT_IN_EXP10F || (FN) == BUILT_IN_EXP10L \

|| (FN) == BUILT_IN_POW10 || (FN) == BUILT_IN_POW10F || (FN) == BUILT_IN_POW10L)

Helper macros for math builtins.

Referenced by fold_builtin_tan().

#define BUILTIN_EXPONENT_P ( FN )

Value:

(BUILTIN_EXP10_P (FN) \
  || (FN) == BUILT_IN_EXP || (FN) == BUILT_IN_EXPF || (FN) == BUILT_IN_EXPL \
  || (FN) == BUILT_IN_EXP2 || (FN) == BUILT_IN_EXP2F || (FN) == BUILT_IN_EXP2L)

Referenced by integer_valued_real_p().

#define BUILTIN_ROOT_P ( FN ) (BUILTIN_SQRT_P (FN) || BUILTIN_CBRT_P (FN))

#define BUILTIN_SQRT_P ( FN ) ((FN) == BUILT_IN_SQRT || (FN) == BUILT_IN_SQRTF || (FN) == BUILT_IN_SQRTL)

Referenced by integer_valued_real_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.

#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.

#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.

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

Valid builtin number.

Referenced by truth_value_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.

Referenced by assign_parms(), and gimplify_return_expr().

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

#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_builtin_2(), and maybe_with_size_expr().

#define CALL_EXPR_FN ( NODE ) TREE_OPERAND (CALL_EXPR_CHECK (NODE), 1)

CALL_EXPR accessors.

Referenced by finish_update_gimple_call(), get_unwidened(), instantiate_decls(), integer_valued_real_p(), and maybe_with_size_expr().

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

Referenced by expand_builtin_strncmp(), finish_update_gimple_call(), and fold_builtin_2().

#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 maybe_with_size_expr().

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

Referenced by maybe_with_size_expr().

#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 expand_builtin_memset_args(), and maybe_with_size_expr().

#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.

#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.

Referenced by maybe_with_size_expr().

#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 expr_location_or(), and tree_operand_length().

#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

#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

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

Referenced by assign_discriminators(), and build_minus_one_cst().

#define CASE_CONVERT

Value:

case NOP_EXPR: \

case CONVERT_EXPR

Generate case for NOP_EXPR, CONVERT_EXPR.

Referenced by add_bound_info(), adjust_related_strinfos(), check_bool_pattern(), compute_object_offset(), eq_evolutions_p(), and instantiate_scev_3().

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

Referenced by convert_to_integer(), oecount_hasher::equal(), expand_builtin_sincos(), fold_builtin_classify(), fold_builtin_sincos(), fold_overflow_warning(), gen_conditions_for_pow(), and maybe_record_sincos().

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

Referenced by fold_builtin_classify().

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

Referenced by associate_equivalences_with_edges(), build_minus_one_cst(), compare_names(), and preprocess_case_label_vec_for_gimple().

#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.

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

Referenced by fold_builtin_cbrt().

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

Referenced by associate_equivalences_with_edges(), build_minus_one_cst(), create_temp_arrays(), maybe_record_in_goto_queue(), and preprocess_case_label_vec_for_gimple().

#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 associate_equivalences_with_edges(), build_minus_one_cst(), compare_names(), cprop_into_successor_phis(), create_temp_arrays(), get_vr_for_comparison(), gimplify_decl_expr(), and preprocess_case_label_vec_for_gimple().

#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.

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

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

VDEF_EXPR accessors are specified in tree-flow.h, along with the other accessors for SSA operands. CATCH_EXPR accessors.

#define char_type_node integer_types[itk_char]

Referenced by add_gnat_descriptive_type_attribute(), build_nonshared_array_type(), constant_pointer_difference(), expand_builtin_prefetch(), and expand_builtin_va_copy().

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

Referenced by analyze_ziv_subscript(), chrec_contains_undetermined(), chrec_evaluate(), chrec_replace_initial_condition(), evolution_function_is_invariant_p(), evolution_function_is_invariant_rec_p(), hide_evolution_in_other_loops_than_loop(), and initialize_matrix_A().

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

Referenced by analyze_ziv_subscript(), chrec_contains_undetermined(), chrec_evaluate(), chrec_replace_initial_condition(), evolution_function_is_invariant_rec_p(), hide_evolution_in_other_loops_than_loop(), initialize_matrix_A(), and lambda_vector_equal().

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

Accessors for the chains of recurrences.

#define CHREC_VARIABLE ( NODE ) TREE_INT_CST_LOW (CHREC_VAR (NODE))

Referenced by analyze_overlapping_iterations(), analyze_ziv_subscript(), chrec_contains_undetermined(), chrec_evaluate(), chrec_fold_automatically_generated_operands(), evolution_function_is_invariant_p(), evolution_function_is_invariant_rec_p(), and hide_evolution_in_other_loops_than_loop().

#define CILK_SPAWN_FN ( NODE ) TREE_OPERAND (CILK_SPAWN_STMT_CHECK (NODE), 0)

Cilk keywords accessors.

#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.

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

Return all qualifiers except for the address space qualifiers.

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

Nonzero if NODE represents a comparison.

Referenced by dump_dominator_optimization_stats(), and vect_build_slp_tree_1().

#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.

#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.

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

Nonzero if this type is a complete type.

Referenced by build_qualified_type(), create_tmp_var_raw(), and initialize_argument_information().

#define complex_double_type_node global_trees[TI_COMPLEX_DOUBLE_TYPE]

Referenced by maybe_canonicalize_argtypes().

#define complex_float_type_node global_trees[TI_COMPLEX_FLOAT_TYPE]

#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.

#define complex_integer_type_node global_trees[TI_COMPLEX_INTEGER_TYPE]

#define complex_long_double_type_node global_trees[TI_COMPLEX_LONG_DOUBLE_TYPE]

Referenced by maybe_canonicalize_argtypes().

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

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

COMPOUND_LITERAL_EXPR accessors.

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

COND_EXPR accessors.

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

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

#define const_ptr_type_node global_trees[TI_CONST_PTR_TYPE]

The C type `const void *'.

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

Nonzero if NODE represents a constant.

Referenced by dump_gimple_statistics(), init_block_clear_fn(), is_gimple_ip_invariant(), make_overflow_infinity(), needs_overflow_infinity(), negative_overflow_infinity(), optimize_compound_literals_in_ctor(), positive_overflow_infinity(), vect_init_vector_1(), and vrp_val_is_min().

#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 build_vector_from_val().

#define CONSTRUCTOR_BITFIELD_P ( NODE ) (DECL_BIT_FIELD (FIELD_DECL_CHECK (NODE)) && DECL_MODE (NODE) != BLKmode)

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

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

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

In a CONSTRUCTOR node.

Referenced by add_data_member_location_attribute(), count_type_elements(), expand_expr_real_1(), initializer_constant_valid_p_1(), insert_int(), make_pass_tm_init(), mark_constant_pool(), tree_low_cst(), type_hash_add(), and write_ts_block_tree_pointers().

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

#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 build_type_attribute_qual_variant(), save_expr(), skip_simple_arithmetic(), and tree_invariant_p().

#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.

#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 gimple_call_fnspec(), infer_value_range(), native_encode_real(), recognize_single_bit_test(), simplify_rotate(), and vect_create_vectorized_demotion_stmts().

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

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

Referenced by expand_builtin_prefetch(), gimplify_omp_task(), and initializer_constant_valid_p_1().

#define convert_to_ptrofftype ( t ) convert_to_ptrofftype_loc (UNKNOWN_LOCATION, t)

Referenced by create_iv().

#define COPY_DECL_ASSEMBLER_NAME	(	DECL1,
		DECL2
	)

Value:

(DECL_ASSEMBLER_NAME_SET_P (DECL1)                                    \
   ? (void) SET_DECL_ASSEMBLER_NAME (DECL2,                             \
                                     DECL_ASSEMBLER_NAME (DECL1))       \
   : (void) 0)

Copy the DECL_ASSEMBLER_NAME from DECL1 to DECL2. Note that if DECL1's DECL_ASSEMBLER_NAME has not yet been set, using this macro will not cause the DECL_ASSEMBLER_NAME of either DECL to be set. In other words, the semantics of using this macro, are different than saying:

SET_DECL_ASSEMBLER_NAME(DECL2, DECL_ASSEMBLER_NAME (DECL1))

which will try to set the DECL_ASSEMBLER_NAME for DECL1.

#define COPY_DECL_RTL	(	NODE1,
		NODE2
	)

Value:

(DECL_WRTL_CHECK (NODE2)->decl_with_rtl.rtl \

= DECL_WRTL_CHECK (NODE1)->decl_with_rtl.rtl)

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

#define copy_node ( t ) copy_node_stat (t MEM_STAT_INFO)

Referenced by assign_assembler_name_if_neeeded(), canonicalize_component_ref(), copy_tree_body_r(), finalize_task_copyfn(), needs_overflow_infinity(), protected_set_expr_location_unshare(), remap_gimple_op_r(), and use_register_for_decl().

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

#define current_optimize_pragma global_trees[TI_CURRENT_OPTIMIZE_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().

#define da_type_node global_trees[TI_DA_TYPE]

#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 print_insn(), and print_value().

#define DECIMAL_FLOAT_TYPE_P ( TYPE )

Value:

(SCALAR_FLOAT_TYPE_P (TYPE) \

&& DECIMAL_FLOAT_MODE_P (TYPE_MODE (TYPE)))

Nonzero if TYPE represents a decimal floating-point type.

#define DECL_ABSTRACT ( 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 add_abstract_origin_attribute(), local_scope_p(), pack_ts_fixed_cst_value_fields(), and unpack_ts_fixed_cst_value_fields().

#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 build_sender_ref(), lower_reduction_clauses(), and new_omp_context().

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

Holds the alignment required for the datum, in bits.

Referenced by align_variable(), allocate_decl_uid(), assign_parms(), default_function_section(), force_reg(), get_mode_alignment(), gimplify_init_ctor_eval(), gimplify_return_expr(), lookup_field_for_decl(), lookup_tramp_for_decl(), normalize_offset(), and tree_nrv().

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

The alignment of NODE, in bytes.

#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 loc_descriptor_from_tree(), and use_register_for_decl().

#define DECL_ARGUMENT_FLD ( NODE ) (DECL_NON_COMMON_CHECK (NODE)->decl_non_common.arguments)

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

In FUNCTION_DECL, a chain of ..._DECL nodes. VAR_DECL and PARM_DECL reserve the arguments slot for language-specific uses.

Referenced by add_linkage_name(), comp_type_attributes(), create_function_info_for(), delete_unreachable_blocks_update_callgraph(), DFS(), gate_intra_sra(), ipa_unregister_cgraph_hooks(), local_scope_p(), locate_and_pad_parm(), remap_vla_decls(), and walk_all_functions().

#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_abstract_origin_attribute(), apply_return_prediction(), assign_parm_remove_parallels(), avoid_complex_debug_insns(), complex_visit_phi(), create_tmp_var_name(), default_stack_protect_guard(), gen_array_type_die(), ipa_modify_call_arguments(), pack_ts_fixed_cst_value_fields(), remap_ssa_name(), rewrite_use_nonlinear_expr(), unpack_ts_fixed_cst_value_fields(), and use_register_for_decl().

#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.

Referenced by eq_node(), gimple_init_edge_profiler(), hash_type_name(), hot_function_section(), init_alias_vars(), maybe_init_pretty_print(), output_cfg(), output_weakrefs(), print_generic_expr(), set_block_origin_self(), wrapup_global_declarations(), and write_ts_decl_common_tree_pointers().

#define DECL_ASSEMBLER_NAME_SET_P ( NODE )

Value:

(HAS_DECL_ASSEMBLER_NAME_P (NODE) \

&& DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.assembler_name != 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 init_alias_vars(), maybe_init_pretty_print(), print_generic_expr(), and write_ts_decl_common_tree_pointers().

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

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

Referenced by apply_return_prediction(), build4_stat(), build_fn_decl(), cgraph_create_empty_node(), dump_possible_polymorphic_call_targets(), free_lang_data_in_cgraph(), gimple_init_edge_profiler(), lto_input_ts_vector_tree_pointers(), output_constructor_bitfield(), process_common_attributes(), varpool_output_variables(), and write_ts_vector_tree_pointers().

#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 build_function_decl_skip_args(), count_type_elements(), dependence_level(), extract_int(), and make_fancy_name().

#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.

#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_location_or_const_value_attribute(), debug_rli(), fortran_common(), and single_element_loc_list_p().

#define DECL_BUILT_IN ( NODE ) (DECL_BUILT_IN_CLASS (NODE) != NOT_BUILT_IN)

In a FUNCTION_DECL, nonzero means a built in function of a standard library or more generally a built in function that is recognized by optimizers and expanders.

Note that it is different from the DECL_IS_BUILTIN accessor. For instance, user declared prototypes of C library functions are not DECL_IS_BUILTIN but may be DECL_BUILT_IN.

Referenced by attribute_value_equal(), check_builtin_call(), dump_function_to_file(), and free_lang_data_in_binfo().

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

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

Referenced by add_dependency(), attribute_value_equal(), build_type_no_quals(), check_builtin_call(), check_call(), constant_pointer_difference(), dump_function_to_file(), emit_call_1(), get_vector_of_formal_parm_types(), init_object_sizes(), is_tm_load(), is_tm_store(), lhd_omp_predetermined_sharing(), mark_stmt_if_obviously_necessary(), maybe_with_size_expr(), old_insns_match_p(), and unpack_ts_function_decl_value_fields().

#define DECL_BY_REFERENCE ( NODE )

Value:

(TREE_CHECK3 (NODE, VAR_DECL, PARM_DECL, \

RESULT_DECL)->decl_common.decl_by_reference_flag)

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 create_function_info_for(), instantiate_decls(), and resolve_operand_name_1().

#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 default_elf_select_section().

#define DECL_COMDAT_GROUP ( NODE ) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.comdat_group)

Referenced by globalize_decl(), lto_input_ts_decl_common_tree_pointers(), and write_ts_decl_common_tree_pointers().

#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 make_decl_rtl_for_debug(), and vect_load_lanes_supported().

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

#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 cgraph_call_node_duplication_hooks(), comp_type_attributes(), convert_local_omp_clauses(), copy_decl_no_change(), DFS_write_tree_body(), finalize_task_copyfn(), gen_array_type_die(), get_emutls_object_name(), lto_input_ts_common_tree_pointers(), referred_to_p(), remap_decl(), replace_ssa_name(), tree_nrv(), ubsan_source_location_type(), and write_ts_common_tree_pointers().

#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.

#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.

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

#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 process_common_attributes().

#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 set_random_seed().

#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 ipa_reverse_postorder().

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

Used to indicate that the DECL is a dllimport.

#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.

#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 canonicalize_component_ref(), cgraph_set_const_flag_1(), cgraph_set_nothrow_flag_1(), clone_inlined_nodes(), create_function_info_for(), create_tmp_var_name(), default_stack_protect_guard(), emit_local(), gimple_redirect_edge_and_branch(), lhd_omp_predetermined_sharing(), lto_out_decl_state_written_size(), lto_output_varpool_node(), make_decl_rtl_for_debug(), maybe_catch_exception(), maybe_lookup_decl(), set_block_origin_self(), streamer_write_builtin(), unpack_ts_fixed_cst_value_fields(), varpool_remove_unreferenced_decls(), vect_load_lanes_supported(), and write_symbol().

#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++.

#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 compute_object_offset(), count_type_elements(), dr_analyze_indices(), get_addr_base_and_unit_offset_1(), insert_vi_for_tree(), and recalculate_side_effects().

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

#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 comp_type_attributes(), compute_object_offset(), count_type_elements(), finalize_task_copyfn(), insert_vi_for_tree(), recalculate_side_effects(), and remap_decl().

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

Nonzero for a decl which is at file scope.

#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.

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

For a FUNCTION_DECL the finalization priority of NODE.

Referenced by build_cdtor().

#define DECL_FROM_INLINE ( NODE )

Value:

(DECL_ABSTRACT_ORIGIN (NODE) != NULL_TREE \

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

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.

#define DECL_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. Note, however, that this field is overloaded, with DECL_BUILT_IN_CLASS as the discriminant, so the latter must always be checked before any access to the former.

Referenced by add_dependency(), build_type_no_quals(), check_call(), constant_pointer_difference(), dump_function_to_file(), emit_call_1(), oecount_hasher::equal(), estimate_move_cost(), expand_builtin_sincos(), fold_builtin_cbrt(), get_mem_ref_of_assignment(), get_vector_of_formal_parm_types(), handle_rhs_call(), init_object_sizes(), is_tm_load(), is_tm_store(), mark_stmt_if_obviously_necessary(), maybe_with_size_expr(), method_class_type(), old_insns_match_p(), record_temporary_equivalences_from_stmts_at_dest(), round_trampoline_addr(), scan_omp_target(), setjmp_call_p(), tree_int_cst_sign_bit(), and unpack_ts_function_decl_value_fields().

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

Referenced by write_ts_decl_non_common_tree_pointers().

#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 blocks_nreverse_all(), report_inline_failed_reason(), and write_ts_decl_non_common_tree_pointers().

#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 write_ts_decl_non_common_tree_pointers().

#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 using "target" attributes. The default version is the one which does not have any "target" attribute set.

#define DECL_GIMPLE_REG_P ( DECL ) DECL_COMMON_CHECK (DECL)->decl_common.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 assign_parms(), make_blocks(), non_rewritable_mem_ref_base(), separate_decls_in_region_name(), and unpack_ts_fixed_cst_value_fields().

#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 eq_assembler_name(), non_rewritable_mem_ref_base(), unpack_ts_decl_wrtl_value_fields(), and warn_uninitialized_vars().

#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 check_aligned_type(), and check_qualified_type().

#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 complex_visit_phi(), and shared_hash_find_slot_1().

#define DECL_HAS_IMPLICIT_SECTION_NAME_P ( NODE ) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.implicit_section_name_p)

Specify whether the section name was set by user or by compiler via -ffunction-sections.

Referenced by get_named_text_section(), and vect_load_lanes_supported().

#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_stat().

#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. This should only be used for debugging; once this field has been set, the decl itself may not legitimately appear in the function.

Referenced by assign_parms(), canonicalize_component_ref(), gimple_redirect_edge_and_branch(), gimple_replace_ssa_lhs(), gimplify_return_expr(), lower_omp_target(), move_stmt_eh_region_nr(), nesting_copy_decl(), and remove_exit_barrier().

#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 rewrite_update_dom_walker::after_dom_children(), assign_parms(), coalesce_partitions(), complex_visit_phi(), create_tmp_var_name(), default_stack_protect_guard(), dwarf2_build_local_stub(), gimple_redirect_edge_and_branch(), gimplify_return_expr(), new_die(), pack_ts_fixed_cst_value_fields(), set_component_ssa_name(), unpack_ts_fixed_cst_value_fields(), use_register_for_decl(), and want_pubnames().

#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 unpack_ts_decl_wrtl_value_fields(), and vect_load_lanes_supported().

#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.

#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.

#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 ceiling(), and loc_descriptor_from_tree().

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

For a VAR_DECL or FUNCTION_DECL the initialization priority of NODE.

Referenced by copy_node_stat().

#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 add_bit_offset_attribute(), align_variable(), assemble_string(), canonicalize_component_ref(), choose_inner_scope(), comp_type_attributes(), coverage_obj_init(), decode_reg_name(), macinfo_entry_hasher::equal(), free_lang_data_in_binfo(), generate_setjmp_warnings(), get_unwidened(), ipa_get_parm_lattices(), local_scope_p(), make_decl_rtl_for_debug(), maybe_catch_exception(), member_declared_type(), varpool_node_for_decl(), and varpool_remove_initializer().

#define DECL_IS_BUILTIN ( DECL ) (LOCATION_LOCUS (DECL_SOURCE_LOCATION (DECL)) <= BUILTINS_LOCATION)

This accessor returns TRUE if the decl it operates on was created by a front-end or back-end rather than by user code. In this case builtin-ness is indicated by source location.

Referenced by gen_lexical_block_die().

#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.

#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).

#define DECL_IS_OPERATOR_NEW ( NODE ) (FUNCTION_DECL_CHECK (NODE)->function_decl.operator_new_flag)

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.

#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.

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

Additional flags for language-specific uses.

#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 DECL_LANG_SPECIFIC ( NODE ) (DECL_COMMON_CHECK (NODE)->decl_common.lang_specific)

Language-specific decl information.

#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.

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

#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 allocate_decl_uid(), assign_parms_setup_varargs(), avoid_complex_debug_insns(), count_type_elements(), ipa_modify_call_arguments(), pack_ts_fixed_cst_value_fields(), promote_mode(), remap_ssa_name(), resolve_operand_name_1(), rewrite_use_nonlinear_expr(), set_reg_attrs_from_value(), unpack_ts_fixed_cst_value_fields(), and use_register_for_decl().

#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 rewrite_update_dom_walker::after_dom_children(), asan_clear_shadow(), build2_stat(), build_sender_ref(), complex_visit_phi(), coverage_obj_init(), decl_overlaps_hard_reg_set_p(), DFS_write_tree_body(), expand_computed_goto(), expand_stack_vars(), finalize_task_copyfn(), go_append_string(), go_output_typedef(), lhd_set_decl_assembler_name(), lookup_tramp_for_decl(), lto_input_ts_common_tree_pointers(), make_decl_rtl_for_debug(), maybe_catch_exception(), no_c99_libc_has_function(), output_constant(), print_generic_expr(), print_insn(), ubsan_type_descriptor(), and write_ts_common_tree_pointers().

#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.

#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.

#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.

#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.

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

#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 lookup_field_for_decl(), new_alias_set(), and objects_must_conflict_p().

#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(), debug_cfg_stats(), expand_computed_goto(), pack_ts_fixed_cst_value_fields(), phi_alternatives_equal(), unpack_ts_fixed_cst_value_fields(), and verify_expr_location_1().

#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.

#define DECL_NONSHAREABLE ( NODE )

Value:

(TREE_CHECK2 (NODE, VAR_DECL, \

RESULT_DECL)->decl_common.decl_nonshareable_flag)

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

Referenced by gimple_redirect_edge_and_branch().

#define DECL_OFFSET_ALIGN ( NODE ) (((unsigned HOST_WIDE_INT)1) << 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.

#define DECL_ONE_ONLY ( NODE ) (DECL_COMDAT_GROUP (NODE) != NULL_TREE)

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

Referenced by dw2_size_of_call_site_table(), hot_function_section(), and make_decl_rtl_for_debug().

#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 ipa_modify_call_arguments().

#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 gen_lexical_block_die(), lto_input_ts_decl_minimal_tree_pointers(), remap_decl(), and write_ts_decl_minimal_tree_pointers().

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

Nonzero if NODE represents a declaration.

Referenced by add_new_name_mapping(), add_stack_var_conflict(), array_ref_element_size(), asan_clear_shadow(), avoid_complex_debug_insns(), build_access_from_expr(), build_tree_list_vec_stat(), comp_type_attributes(), create_block_symbol(), debug_currdefs(), debug_tree(), default_elf_select_section(), dump_tree_ssa_stats(), expand_stack_vars(), find_def_blocks_for(), force_reg(), get_ssa_def_if_simple_copy(), get_unwidened(), gimplify_init_ctor_eval(), hash_scc(), initialize_argument_information(), insert_float(), insert_phi_nodes(), loop_has_blocks_with_irreducible_flag(), lower_omp_target(), make_constraint_from(), maybe_optimize_var(), maybe_register_def(), nesting_copy_decl(), new_die(), parm_ref_data_preserved_p(), print_insn(), refs_independent_p(), remap_decl(), remove_exit_barrier(), rewrite_add_phi_arguments(), rewrite_debug_stmt_uses(), separate_decls_in_region_stmt(), stmt_references_abnormal_ssa_name(), sub_costs(), and verify_gimple_label().

#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 debug_rli().

#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.

#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 pack_ts_fixed_cst_value_fields(), process_common_attributes(), unpack_ts_fixed_cst_value_fields(), and vect_load_lanes_supported().

#define DECL_PT_UID ( NODE )

Value:

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

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

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

#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.

#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).

#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 comp_type_attributes(), and remap_decl().

#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.

#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_unsplit_complex(), and decl_overlaps_hard_reg_set_p().

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

In FUNCTION_DECL, holds the decl for the return value.

Referenced by assign_parms_unsplit_complex(), comp_type_attributes(), copy_decl_no_change(), create_function_info_for(), expand_value_return(), init_dummy_function_start(), resolve_operand_name_1(), and set_cfun().

#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.

#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 add_name_attribute(), array_ref_element_size(), assemble_asm(), assign_parms_unsplit_complex(), compute_argument_addresses(), emit_local(), expand_computed_goto(), gen_int_to_fp_nondecimal_conv_libfunc(), init_dummy_function_start(), initialize_argument_information(), locate_and_pad_parm(), make_decl_rtl_for_debug(), resolve_operand_name_1(), and verify_rtx_sharing().

#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_stack_var_conflict(), and mode_for_array().

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

#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 array_ref_element_size(), emit_local(), init_dummy_function_start(), sub_costs(), and verify_rtx_sharing().

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

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

Referenced by delete_unreachable_blocks_update_callgraph(), and store_child_info().

#define DECL_SECTION_NAME ( NODE ) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.section_name)

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 create_block_symbol(), default_function_section(), get_named_text_section(), lto_input_ts_decl_common_tree_pointers(), resolve_unique_section(), vect_load_lanes_supported(), and write_ts_decl_common_tree_pointers().

#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 canonicalize_component_ref().

#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.

Referenced by add_location_or_const_value_attribute(), assign_parms(), build_function_decl_skip_args(), comp_type_attributes(), count_type_elements(), coverage_end_function(), debug_rli(), emit_local(), finalize_task_copyfn(), fortran_common(), get_or_create_ssa_default_def(), gimplify_return_expr(), lto_input_ts_vector_tree_pointers(), output_constant(), remap_decl(), set_random_seed(), tree_block(), use_register_for_decl(), and write_ts_vector_tree_pointers().

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

Likewise for the size in bytes.

Referenced by assemble_string(), assign_parms(), build_tree_list_vec_stat(), canonicalize_component_ref(), comp_type_attributes(), coverage_end_function(), extract_int(), finalize_task_copyfn(), gimplify_return_expr(), lto_input_ts_vector_tree_pointers(), remap_decl(), use_register_for_decl(), and write_ts_vector_tree_pointers().

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

#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_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 build2_stat(), build_minus_one_cst(), build_sender_ref(), complex_visit_phi(), copy_decl_no_change(), finalize_nesting_tree_1(), finalize_task_copyfn(), free_histograms(), gen_array_type_die(), get_frame_field(), get_frame_size(), mode_for_array(), process_common_attributes(), and process_function_and_variable_attributes().

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

In a FUNCTION_DECL indicates that a static chain is needed.

Referenced by convert_gimple_call(), output_constant_pool(), and remap_vla_decls().

#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 cgraph_node_cannot_be_local_p_1().

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

Referenced by cgraph_node_cannot_be_local_p_1().

#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_process_new_functions(), delete_unreachable_blocks_update_callgraph(), gen_array_type_die(), init_alias_vars(), ipa_analyze_call_uses(), lower_emutls_phi_arg(), maybe_init_pretty_print(), gcc::pass_manager::pass_manager(), predicate_for_phi_result(), and report_inline_failed_reason().

#define DECL_THREAD_LOCAL_P ( NODE ) (VAR_DECL_CHECK (NODE)->decl_with_vis.tls_model >= TLS_MODEL_REAL)

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

Referenced by align_variable(), and emit_local().

#define DECL_TLS_MODEL ( NODE ) (VAR_DECL_CHECK (NODE)->decl_with_vis.tls_model)

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

Referenced by unpack_ts_decl_wrtl_value_fields().

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

Every ..._DECL node gets a unique number.

Referenced by add_accessibility_attribute(), add_new_name_mapping(), adjust_simduid_builtins(), analyze_caller_dereference_legality(), build_access_from_expr_1(), build_cdtor(), check_aligned_type(), check_qualified_type(), child_would_conflict_in_lacc(), create_one_component_var(), find_replaceable_in_bb(), get_addr_base_and_unit_offset(), get_AT_file(), get_local_debug_decl(), gimple_pop_condition(), hash_node(), ipa_reference_get_not_written_global(), is_fortran(), is_java(), lhd_set_decl_assembler_name(), lower_omp_target(), make_node_stat(), maybe_optimize_var(), non_rewritable_mem_ref_base(), note_simd_array_uses(), partition_view_bitmap(), print_insn(), remove_AT(), separate_decls_in_region_name(), separate_decls_in_region_stmt(), set_block_origin_self(), set_register_defs(), ssa_default_def(), and vect_analyze_data_ref_access().

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

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

Referenced by process_common_attributes().

#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 build_function_decl_skip_args().

#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 align_variable(), normalize_offset(), pack_ts_fixed_cst_value_fields(), and unpack_ts_fixed_cst_value_fields().

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

Referenced by canonicalize_component_ref(), gimple_replace_ssa_lhs(), move_stmt_eh_region_nr(), nesting_copy_decl(), and omp_copy_decl_2().

#define DECL_VINDEX ( NODE ) (DECL_NON_COMMON_CHECK (NODE)->decl_non_common.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. C++ also uses this field in namespaces, hence the DECL_NON_COMMON_CHECK.

Referenced by lto_input_ts_decl_minimal_tree_pointers(), and write_ts_decl_minimal_tree_pointers().

#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 contains_hot_call_p(), is_vptr_store(), pack_ts_fixed_cst_value_fields(), and unpack_ts_fixed_cst_value_fields().

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

Value of the decls's visibility attribute

Referenced by default_stack_protect_guard().

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

Nonzero means that the decl had its visibility specified rather than being inferred.

Referenced by default_stack_protect_guard().

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

Used to indicate that this DECL has weak linkage.

Referenced by make_decl_rtl_for_debug(), process_common_attributes(), and write_global_stream().

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

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

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

Referenced by lookup_ident_attribute().

#define DEFAULT_INIT_PRIORITY 65535

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

#define dfloat128_ptr_type_node global_trees[TI_DFLOAT128_PTR_TYPE]

#define dfloat128_type_node global_trees[TI_DFLOAT128_TYPE]

#define dfloat32_ptr_type_node global_trees[TI_DFLOAT32_PTR_TYPE]

#define dfloat32_type_node global_trees[TI_DFLOAT32_TYPE]

The decimal floating point types.

#define dfloat64_ptr_type_node global_trees[TI_DFLOAT64_PTR_TYPE]

#define dfloat64_type_node global_trees[TI_DFLOAT64_TYPE]

#define double_ptr_type_node global_trees[TI_DOUBLE_PTR_TYPE]

#define double_type_node global_trees[TI_DOUBLE_TYPE]

Referenced by convert_to_real(), and maybe_canonicalize_argtypes().

#define dq_type_node global_trees[TI_DQ_TYPE]

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

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

EH_FILTER_EXPR accessors.

#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 do_return_redirection(), lower_eh_constructs(), make_goto_expr_edges(), mark_reachable_handlers(), phi_alternatives_equal(), unpack_ts_decl_common_value_fields(), and verify_expr_location_1().

#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.

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

Determines whether an ENUMERAL_TYPE has defined the list of constants.

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

Used to mark scoped enums.

#define error_operand_p ( NODE )

Value:

((NODE) == error_mark_node \

|| ((NODE) && TREE_TYPE ((NODE)) == error_mark_node))

True if NODE is an erroneous expression.

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

Nonzero if NODE represents an exceptional code.

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

#define EXPR_CHECK ( T ) (T)

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

#define EXPR_HAS_LOCATION ( NODE )

Value:

(LOCATION_LOCUS (EXPR_LOCATION (NODE)) \

!= UNKNOWN_LOCATION)

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

#define EXPR_LOC_OR_HERE ( NODE )

Value:

(EXPR_HAS_LOCATION (NODE) \

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

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 get_pointer_alignment(), and lookup_tmp_var().

#define EXPR_LOC_OR_LOC	(	NODE,
		LOCUS
	)

Value:

(EXPR_HAS_LOCATION (NODE) \

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

#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 default_pch_valid_p(), expand_builtin_bzero(), expand_builtin_memset_args(), expand_builtin_strncmp(), expr_location_or(), gimplify_expr(), maybe_with_size_expr(), record_in_goto_queue_label(), round_trampoline_addr(), and use_register_for_decl().

#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 tree_upper_hasher::hash(), ipa_set_jf_known_type(), TB_current_chain_node(), unshare_body(), and vrp_meet_1().

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

Nonzero if NODE represents any other expression.

#define fileptr_type_node global_trees[TI_FILEPTR_TYPE]

The C type `FILE *'.

#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 contains_placeholder_p().

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

Nonzero if TYPE represents a fixed-point type.

#define float_ptr_type_node global_trees[TI_FLOAT_PTR_TYPE]

#define float_type_node global_trees[TI_FLOAT_TYPE]

Referenced by convert_to_real(), and maybe_canonicalize_argtypes().

#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 convert_to_real(), fold_comparison(), and init_scc_vn().

#define fold_binary	(	CODE,
		T1,
		T2,
		T3
	)	fold_binary_loc (UNKNOWN_LOCATION, CODE, T1, T2, T3)

Referenced by derive_constant_upper_bound_assign(), and update_range_test().

#define fold_build1	(	c,
		t1,
		t2
	)	fold_build1_stat_loc (UNKNOWN_LOCATION, c, t1, t2 MEM_STAT_INFO)

Referenced by compute_object_offset(), create_iv(), gimple_get_virt_method_for_binfo(), gimple_val_nonnegative_real_p(), instantiate_scev_binary(), instantiate_scev_not(), read_replacements_section(), tm_mangle(), update_range_test(), and value_range_constant_singleton().

#define fold_build1_loc	(	l,
		c,
		t1,
		t2
	)	fold_build1_stat_loc (l, c, t1, t2 MEM_STAT_INFO)

Referenced by convert_to_pointer(), expand_omp_sections(), fold_builtin_constant_p(), merge_ranges(), native_interpret_expr(), operand_equal_for_comparison_p(), and sra_modify_expr().

#define fold_build2	(	c,
		t1,
		t2,
		t3
	)	fold_build2_stat_loc (UNKNOWN_LOCATION, c, t1, t2, t3 MEM_STAT_INFO)

#define fold_build2_loc	(	l,
		c,
		t1,
		t2,
		t3
	)	fold_build2_stat_loc (l, c, t1, t2, t3 MEM_STAT_INFO)

Referenced by build_fold_addr_expr_loc(), build_one_array(), expand_builtin_expect(), fold_builtin_cexp(), fold_builtin_constant_p(), fold_builtin_fabs(), fold_builtin_int_roundingfn(), fold_comparison(), fold_mathfn_compare(), fold_mult_zconjz(), integer_valued_real_p(), lower_send_clauses(), native_interpret_vector(), operand_equal_for_comparison_p(), and vec_cst_ctor_to_array().

#define fold_build3	(	c,
		t1,
		t2,
		t3,
		t4
	)	fold_build3_stat_loc (UNKNOWN_LOCATION, c, t1, t2, t3, t4 MEM_STAT_INFO)

Referenced by gimple_get_virt_method_for_binfo(), tree_simplify_using_condition(), and type_contains_placeholder_1().

#define fold_build3_loc	(	l,
		c,
		t1,
		t2,
		t3,
		t4
	)	fold_build3_stat_loc (l, c, t1, t2, t3, t4 MEM_STAT_INFO)

Referenced by fold_builtin_fabs(), fold_builtin_strcpy(), and operand_equal_for_comparison_p().

#define fold_build_call_array	(	T1,
		T2,
		N,
		T4
	)	fold_build_call_array_loc (UNKNOWN_LOCATION, T1, T2, N, T4)

#define fold_build_call_array_initializer	(	T1,
		T2,
		N,
		T4
	)	fold_build_call_array_initializer_loc (UNKNOWN_LOCATION, T1, T2, N, T4)

#define fold_build_pointer_plus	(	p,
		o
	)	fold_build_pointer_plus_loc (UNKNOWN_LOCATION, p, o)

Referenced by create_mem_ref(), move_variant_to_index(), nothing_to_prefetch_p(), number_of_iterations_lt_to_ne(), and vect_can_advance_ivs_p().

#define fold_build_pointer_plus_hwi	(	p,
		o
	)	fold_build_pointer_plus_hwi_loc (UNKNOWN_LOCATION, p, o)

Referenced by default_member_type_forces_blk().

#define fold_convert	(	T1,
		T2
	)	fold_convert_loc (UNKNOWN_LOCATION, T1, T2)

Referenced by aff_combination_add(), aff_combination_add_product(), aff_combination_remove_elt(), alloc_iv(), assign_parms(), associate_equivalences_with_edges(), backtrace_base_for_ref(), build_function_decl_skip_args(), build_one_cst(), can_unroll_loop_p(), compute_object_offset(), debug_ddrs(), decode_field_reference(), dr_analyze_indices(), expand_omp_atomic_load(), extract_muldiv(), finish_builtin_struct(), get_or_alloc_expr_for(), gimplify_modify_expr_to_memset(), gimplify_return_expr(), instantiate_scev_binary(), instantiate_scev_poly(), move_pointer_to_base(), move_variant_to_index(), nothing_to_prefetch_p(), relayout_decl(), single_incoming_edge_ignoring_loop_edges(), test_for_singularity(), valid_mem_ref_p(), vect_can_advance_ivs_p(), vect_do_peeling_for_loop_bound(), vect_gen_niters_for_prolog_loop(), and vrp_stmt_computes_nonzero().

#define fold_indirect_ref ( T ) fold_indirect_ref_loc (UNKNOWN_LOCATION, T)

#define fold_ternary	(	CODE,
		T1,
		T2,
		T3,
		T4
	)	fold_ternary_loc (UNKNOWN_LOCATION, CODE, T1, T2, T3, T4)

Referenced by expr_has_constants().

#define fold_unary	(	CODE,
		T1,
		T2
	)	fold_unary_loc (UNKNOWN_LOCATION, CODE, T1, T2)

Referenced by get_or_alloc_expr_for(), and vect_init_vector_1().

#define fold_unary_ignore_overflow	(	CODE,
		T1,
		T2
	)	fold_unary_ignore_overflow_loc (UNKNOWN_LOCATION, CODE, T1, T2)

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

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 expand_call().

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

#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 count_type_elements(), expand_expr_real_1(), tree_low_cst(), and write_ts_block_tree_pointers().

#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 mark_constant_pool(), and optimize_compound_literals_in_ctor().

#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 lower_gimple_return().

#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 upper_bound_in_type().

#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.

#define fract_type_node global_trees[TI_FRACT_TYPE]

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

#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.

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

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

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

#define ha_type_node global_trees[TI_HA_TYPE]

#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.

#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 sub_costs().

#define hq_type_node global_trees[TI_HQ_TYPE]

#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(), and stringpool_statistics().

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

Referenced by gen_int_to_fp_nondecimal_conv_libfunc().

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

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

Referenced by asan_clear_shadow(), find_decls_types_in_eh_region(), find_decls_types_in_node(), get_eh_types_for_runtime(), go_type_decl(), register_scoped_attribute(), and write_identifier().

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

#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 output_weakrefs().

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

Getter of the imported declaration associated to the IMPORTED_DECL node.

#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 compute_subscript_distance(), and execute_sm_if_changed_flag_set().

#define int128_integer_type_node integer_types[itk_int128]

#define int128_unsigned_type_node integer_types[itk_unsigned_int128]

#define INT_CST_LT	(	A,
		B
	)

Value:

(TREE_INT_CST_HIGH (A) < TREE_INT_CST_HIGH (B)        \
   || (TREE_INT_CST_HIGH (A) == TREE_INT_CST_HIGH (B)   \
       && TREE_INT_CST_LOW (A) < TREE_INT_CST_LOW (B)))

#define INT_CST_LT_UNSIGNED	(	A,
		B
	)

Value:

(((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (A)              \
    < (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (B))           \
   || (((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (A)          \
        == (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (B))      \
       && TREE_INT_CST_LOW (A) < TREE_INT_CST_LOW (B)))

Referenced by default_cxx_guard_type().

#define intDI_type_node global_trees[TI_INTDI_TYPE]

#define integer_minus_one_node global_trees[TI_INTEGER_MINUS_ONE]

Referenced by instantiate_scev_binary().

#define integer_one_node global_trees[TI_INTEGER_ONE]

Referenced by chrec_is_positive(), create_if_region_on_edge(), find_case_label_index(), fold_builtin_isascii(), lower_gimple_return(), maybe_canonicalize_comparison(), and simple_operand_p().

#define integer_ptr_type_node global_trees[TI_INTEGER_PTR_TYPE]

#define integer_three_node global_trees[TI_INTEGER_THREE]

#define integer_type_node integer_types[itk_int]

Referenced by convert_to_integer(), coverage_counter_alloc(), fold_builtin_fabs(), fold_builtin_sprintf_chk_1(), fold_builtin_strncpy(), get_ssa_def_if_simple_copy(), gimple_init_edge_profiler(), initialize_argument_information(), rewrite_call_expr(), single_element_loc_list_p(), and sjlj_assign_call_site_values().

#define INTEGRAL_TYPE_P ( TYPE )

Value:

(TREE_CODE (TYPE) == ENUMERAL_TYPE  \
   || TREE_CODE (TYPE) == BOOLEAN_TYPE \
   || TREE_CODE (TYPE) == INTEGER_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 check_array_ref(), determine_base_object(), estimated_stmt_executions_int(), expand_builtin_atomic_exchange(), expand_omp_atomic_load(), fold_build1_initializer_loc(), fold_convert_const_fixed_from_int(), forward_propagate_addr_expr(), gimplify_switch_expr(), infer_value_range(), init_scc_vn(), instrument_derefs(), native_interpret_expr(), process_assert_insertions(), range_fits_type_p(), reverse_op(), scev_finalize(), scev_reset(), simplify_bitwise_binary_1(), simplify_cond_using_ranges(), simplify_gimple_switch_label_vec(), simplify_rotate(), tree_predict_by_opcode(), vn_reference_compute_hash(), and vrp_val_is_max().

#define intHI_type_node global_trees[TI_INTHI_TYPE]

#define intQI_type_node global_trees[TI_INTQI_TYPE]

#define intSI_type_node global_trees[TI_INTSI_TYPE]

#define intTI_type_node global_trees[TI_INTTI_TYPE]

#define invert_truthvalue ( T ) invert_truthvalue_loc (UNKNOWN_LOCATION, T)

#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>).

#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 signed_or_unsigned_type_for().

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

Returns nonzero iff NODE represents a type or declaration.

Referenced by verify_gimple_label().

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

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

#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 gimple_call_arg_flags(), replace_ssa_name(), and unpack_ts_decl_common_value_fields().

#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.

#define long_accum_type_node global_trees[TI_LACCUM_TYPE]

#define long_double_ptr_type_node global_trees[TI_LONG_DOUBLE_PTR_TYPE]

#define long_double_type_node global_trees[TI_LONG_DOUBLE_TYPE]

Referenced by maybe_canonicalize_argtypes().

#define long_fract_type_node global_trees[TI_LFRACT_TYPE]

#define long_integer_type_node integer_types[itk_long]

Referenced by convert_to_integer(), expand_omp_for_init_vars(), get_ws_args_for(), is_task_ctx(), and workshare_safe_to_combine_p().

#define long_long_accum_type_node global_trees[TI_LLACCUM_TYPE]

#define long_long_fract_type_node global_trees[TI_LLFRACT_TYPE]

#define long_long_integer_type_node integer_types[itk_long_long]

Referenced by convert_to_integer().

#define long_long_unsigned_type_node integer_types[itk_unsigned_long_long]

Referenced by expand_omp_for_init_vars().

#define long_unsigned_type_node integer_types[itk_unsigned_long]

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

In a LOOP_EXPR node.

Referenced by gimplify_vla_decl().

#define main_identifier_node global_trees[TI_MAIN_IDENTIFIER]

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

#define make_node ( t ) make_node_stat (t MEM_STAT_INFO)

Referenced by avoid_complex_debug_insns(), build_constructor(), build_minus_one_cst(), double_int_to_tree(), ipa_modify_call_arguments(), lookup_tramp_for_decl(), lower_omp_sections(), maybe_add_implicit_barrier_cancel(), remap_ssa_name(), rewrite_use_nonlinear_expr(), and simple_cst_equal().

#define make_or_reuse_sat_signed_accum_type ( P ) make_or_reuse_accum_type (P, 0, 1)

#define make_or_reuse_sat_signed_fract_type ( P ) make_or_reuse_fract_type (P, 0, 1)

#define make_or_reuse_sat_unsigned_accum_type ( P ) make_or_reuse_accum_type (P, 1, 1)

#define make_or_reuse_sat_unsigned_fract_type ( P ) make_or_reuse_fract_type (P, 1, 1)

#define make_or_reuse_signed_accum_type ( P ) make_or_reuse_accum_type (P, 0, 0)

#define make_or_reuse_signed_fract_type ( P ) make_or_reuse_fract_type (P, 0, 0)

#define make_or_reuse_unsigned_accum_type ( P ) make_or_reuse_accum_type (P, 1, 0)

#define make_or_reuse_unsigned_fract_type ( P ) make_or_reuse_fract_type (P, 1, 0)

#define make_sat_signed_accum_type ( P ) make_accum_type (P, 0, 1)

#define make_sat_signed_fract_type ( P ) make_fract_type (P, 0, 1)

#define make_sat_unsigned_accum_type ( P ) make_accum_type (P, 1, 1)

#define make_sat_unsigned_fract_type ( P ) make_fract_type (P, 1, 1)

#define make_signed_accum_type ( P ) make_accum_type (P, 0, 0)

#define make_signed_fract_type ( P ) make_fract_type (P, 0, 0)

#define make_tree_binfo ( t ) make_tree_binfo_stat (t MEM_STAT_INFO)

#define make_tree_vec ( t ) make_tree_vec_stat (t MEM_STAT_INFO)

Referenced by cache_integer_cst().

#define make_unsigned_accum_type ( P ) make_accum_type (P, 1, 0)

#define make_unsigned_fract_type ( P ) make_fract_type (P, 1, 0)

#define make_vector ( n ) make_vector_stat (n MEM_STAT_INFO)

#define MARK_TS_BASE ( C )

Value:

do {                                                  \
    tree_contains_struct[C][TS_BASE] = 1;               \
  } while (0)

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/. Macros for initializing `tree_contains_struct'.

Referenced by initialize_tree_contains_struct().

#define MARK_TS_COMMON ( C )

Value:

do {                                                  \
    MARK_TS_TYPED (C);                                  \
    tree_contains_struct[C][TS_COMMON] = 1;             \
  } while (0)

Referenced by initialize_tree_contains_struct().

#define MARK_TS_DECL_COMMON ( C )

Value:

do {                                                  \
    MARK_TS_DECL_MINIMAL (C);                           \
    tree_contains_struct[C][TS_DECL_COMMON] = 1;        \
  } while (0)

Referenced by initialize_tree_contains_struct().

#define MARK_TS_DECL_MINIMAL ( C )

Value:

do {                                                  \
    MARK_TS_COMMON (C);                                 \
    tree_contains_struct[C][TS_DECL_MINIMAL] = 1;       \
  } while (0)

Referenced by initialize_tree_contains_struct().

#define MARK_TS_DECL_NON_COMMON ( C )

Value:

do {                                                  \
    MARK_TS_DECL_WITH_VIS (C);                          \
    tree_contains_struct[C][TS_DECL_NON_COMMON] = 1;    \
  } while (0)

Referenced by initialize_tree_contains_struct().

#define MARK_TS_DECL_WITH_VIS ( C )

Value:

do {                                                  \
    MARK_TS_DECL_WRTL (C);                              \
    tree_contains_struct[C][TS_DECL_WITH_VIS] = 1;      \
  } while (0)

Referenced by initialize_tree_contains_struct().

#define MARK_TS_DECL_WRTL ( C )

Value:

do {                                                  \
    MARK_TS_DECL_COMMON (C);                            \
    tree_contains_struct[C][TS_DECL_WRTL] = 1;          \
  } while (0)

Referenced by initialize_tree_contains_struct().

#define MARK_TS_TYPE_COMMON ( C )

Value:

do {                                                  \
    MARK_TS_COMMON (C);                                 \
    tree_contains_struct[C][TS_TYPE_COMMON] = 1;        \
  } while (0)

Referenced by initialize_tree_contains_struct().

#define MARK_TS_TYPE_WITH_LANG_SPECIFIC ( C )

Value:

do {                                                  \
    MARK_TS_TYPE_COMMON (C);                            \
    tree_contains_struct[C][TS_TYPE_WITH_LANG_SPECIFIC] = 1;    \
  } while (0)

Referenced by initialize_tree_contains_struct().

#define MARK_TS_TYPED ( C )

Value:

do {                                                  \
    MARK_TS_BASE (C);                                   \
    tree_contains_struct[C][TS_TYPED] = 1;              \
  } while (0)

Referenced by initialize_tree_contains_struct().

#define MAX_INIT_PRIORITY 65535

The maximum allowed initialization priority.

#define MAX_RESERVED_INIT_PRIORITY 100

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

Referenced by tsan_pass().

#define MAY_HAVE_DEBUG_STMTS (flag_var_tracking_assignments)

Nonzero if is_gimple_debug() may possibly hold.

Referenced by expr_with_var_bounded_array_refs_p(), find_released_ssa_name(), first_readonly_imm_use(), gimple_replace_ssa_lhs(), next_readonly_imm_use(), release_ssa_name(), and rewrite_use_nonlinear_expr().

#define non_lvalue ( T ) non_lvalue_loc (UNKNOWN_LOCATION, T)

Return an expr equal to X but certainly not valid as an lvalue.

Referenced by fold_builtin_sprintf_chk_1().

#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.

#define NON_TYPE_CHECK ( T ) (T)

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

#define null_pointer_node global_trees[TI_NULL_POINTER]

Referenced by output_addressed_constants(), and output_constant_pool().

#define NULL_TREE (tree) NULL

Referenced by add_bit_offset_attribute(), add_costs(), add_data_member_location_attribute(), add_linkage_name(), add_repeat_to_ops_vec(), add_rshift(), add_to_predicate_list(), adjust_last_stmt(), adjust_simduid_builtins(), aff_combination_add_elt(), agg_jmp_p_vec_for_t_vec(), alias_sets_must_conflict_p(), analyze_evolution_in_loop(), asan_clear_shadow(), asan_mem_ref_new(), assign_assembler_name_if_neeeded(), avoid_folding_inline_builtin(), bit_value_binop(), build3_stat(), build_fn_decl(), build_minus_one_cst(), build_opaque_vector_type(), calculate_live_on_exit(), can_unroll_loop_p(), change_address_1(), check_all_array_refs(), check_bool_pattern(), comp_type_attributes(), compare_names(), compare_range_with_value(), compute_reloc_for_constant(), constant_pointer_difference(), contains_vce_or_bfcref_p(), convert_nl_goto_reference(), copy_decl_no_change(), copy_if_shared_r(), copy_to_suggested_reg(), coverage_obj_init(), create_component_ref_by_pieces_1(), create_iv(), create_loop_fn(), create_mem_ref(), create_mul_ssa_cand(), create_phi_for_local_result(), debug_currdefs(), debug_lattice_value(), debug_rli(), decimal_from_integer(), decl_for_type_lookup(), default_builtin_support_vector_misalignment(), default_expand_builtin(), default_function_section(), default_invalid_within_doloop(), default_promote_function_mode(), default_stack_protect_guard(), delete_unreachable_blocks_update_callgraph(), delete_worklist(), disqualify_ops_if_throwing_stmt(), do_ssa_ccp(), dump_chrecs_stats(), dump_ddrs(), dump_function_to_file(), dump_gimple_fmt(), dump_live_info(), eliminate_phi(), eliminate_useless_phis(), expr_elt_hasher::equal(), execute_pred_commoning_chain(), expand_builtin_memory_chk(), expand_builtin_object_size(), expand_builtin_va_copy(), expand_omp_atomic_load(), expand_omp_for_init_vars(), expand_omp_sections(), expand_stack_vars(), expr_first(), extract_int(), extract_ops_from_tree_1(), find_bswap_1(), find_equal_ptrs(), find_loop_niter(), find_use_stmt(), fold_builtin_4(), fold_builtin_cbrt(), fold_builtin_classify(), fold_builtin_exponent(), fold_builtin_fputs(), fold_builtin_logarithm(), fold_builtin_n(), fold_builtin_strcspn(), fold_builtin_strncat_chk(), fold_builtin_strncpy(), fold_builtin_strstr(), fold_call_expr(), fold_fma(), fold_mathfn_compare(), fold_trunc_transparent_mathfn(), fold_unary_ignore_overflow_loc(), forward_propagate_addr_expr(), gather_chrec_stats(), gcd_of_steps_may_divide_p(), gen_eh_region_try(), gen_lexical_block_die(), generate_code_for_partition(), generate_subtree_copies(), get_addr_base_and_unit_offset_1(), get_frame_field(), get_identifier_with_length(), get_initial_def_for_reduction(), get_instantiated_value_entry(), get_mem_ref_of_assignment(), get_or_create_ssa_default_def(), get_pointer_alignment(), get_rank(), get_ubsan_type_info_for_type(), get_unwidened(), get_value_from_alignment(), gimple_assign_unary_nop_p(), gimple_build_assign_with_ops(), gimple_expand_builtin_powi(), gimple_gen_one_value_profiler(), gimple_gen_pow2_profiler(), gimple_get_virt_method_for_binfo(), gimple_init_edge_profiler(), gimple_redirect_edge_and_branch(), gimple_replace_ssa_lhs(), gimple_stmt_nonnegative_warnv_p(), gimplify_mem_ref_parts(), gimplify_switch_expr(), gimplify_vla_decl(), handle_lhs_call(), handle_pointer_plus(), handle_rhs_call(), hide_evolution_in_other_loops_than_loop(), if_convertible_loop_p(), ifcombine_ifandif(), independent_of_stmt_p(), infer_value_range(), init_ssa_operands(), initialize_argument_information(), insert_gimplified_predicates(), insert_int(), instantiate_decls(), instrument_builtin_call(), instrument_derefs(), int_const_binop_1(), ipa_free_all_structures_after_iinln(), ipa_modify_call_arguments(), ipa_set_jf_arith_pass_through(), ipa_tm_diagnose_tm_safe(), ipcp_discover_new_direct_edges(), is_reference(), is_task_ctx(), iterative_hash_exprs_commutative(), iterative_hash_hashval_t(), lhd_do_nothing_f(), lhd_pass_through_t(), lhd_return_null_tree(), lhd_return_null_tree_v(), load_from_unmodified_param(), local_scope_p(), lower_omp_target(), lower_send_clauses(), lto_read_body(), lto_read_tree(), lto_write_tree(), make_fancy_name(), mark_stmt_if_obviously_necessary(), may_propagate_copy_into_asm(), maybe_canonicalize_argtypes(), maybe_emit_chk_warning(), maybe_emit_sprintf_chk_warning(), maybe_fold_tmr(), maybe_register_def(), maybe_skip_until(), member_declared_type(), move_pointer_to_base(), needs_overflow_infinity(), niter_for_single_dom_exit(), note_nonlocal_vla_type(), note_simd_array_uses(), op_iter_next_tree(), optimize_range_tests_diff(), output_addressed_constants(), output_constant(), output_constant_pool(), output_constant_pool_contents(), partition_to_var(), phi_translate(), premark_types_used_by_global_vars(), preprocess_case_label_vec_for_gimple(), print_generic_expr(), propagate_with_phi(), record_stmt_cost(), redirect_eh_edge(), ref_maybe_used_by_call_p(), refs_may_alias_p(), refs_output_dependent_p(), register_new_def(), register_scoped_attribute(), release_ssa_name(), remap_vla_decls(), remove_exit_barrier(), remove_name_from_operation(), replace_conditional_candidate(), replace_phi_args_in(), replace_uncond_cands_and_profitable_phis(), resolve_unique_section(), restore_vars_to_original_value(), reverse_op(), rewrite_add_phi_arguments(), rewrite_call_expr(), rewrite_call_expr_valist(), rewrite_to_defined_overflow(), rhs_to_tree(), same_bool_result_p(), same_data_refs(), set_hint_predicate(), set_mem_attributes(), set_strinfo(), set_value_range_to_null(), sign_bit_p(), simple_mem_ref_in_stmt(), simple_operand_p(), simplify_binary_expression(), single_element_loc_list_p(), split_complex_types(), sra_modify_expr(), start_ssa_stmt_operands(), staticp(), stmt_references_abnormal_ssa_name(), streamer_read_tree_bitfields(), streamer_write_builtin(), swap_tree_comparison(), symbolic_range_p(), t2r_eq(), TB_current_chain_node(), TB_get_tree_code(), tree_fold_binomial(), tsan_pass(), type_contains_placeholder_1(), type_hash_list(), type_like_member_ptr_p(), unshare_aff_combination(), unshare_body(), update_dominators_in_loop(), update_range_test(), update_specialized_profile(), upper_bound_in_type(), use_register_for_decl(), uses_local_type_r(), valid_gimple_call_p(), valid_mem_ref_p(), valid_value_p(), var_decl_component_p(), var_to_partition(), vect_analyze_scalar_cycles(), vect_build_slp_tree_1(), vect_compute_data_ref_alignment(), vect_create_cond_for_alias_checks(), vect_create_oprnd_info(), vect_create_vectorized_demotion_stmts(), vect_do_peeling_for_loop_bound(), vect_finish_stmt_generation(), vect_get_loop_based_defs(), vect_grouped_store_supported(), vect_init_vector_1(), vect_load_lanes_supported(), vect_permute_store_chain(), vect_update_ivs_after_vectorizer(), verify_related_strinfos(), visit_nary_op(), vn_nary_op_compute_hash(), vrp_intersect_ranges_1(), vrp_val_is_min(), vrp_val_max(), vrp_val_min(), write_ts_common_tree_pointers(), write_ts_decl_common_tree_pointers(), and write_ts_vec_tree_pointers().

#define NUMERICAL_TYPE_CHECK ( T )

Value:

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

FIXED_POINT_TYPE)

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

OBJ_TYPE_REF accessors.

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

Referenced by possible_polymorphic_call_target_p().

#define omit_one_operand	(	T1,
		T2,
		T3
	)	omit_one_operand_loc (UNKNOWN_LOCATION, T1, T2, T3)

#define omit_two_operands	(	T1,
		T2,
		T3,
		T4
	)	omit_two_operands_loc (UNKNOWN_LOCATION, T1, T2, T3, T4)

#define OMP_ATOMIC_SEQ_CST ( NODE )

Value:

(TREE_RANGE_CHECK (NODE, OMP_ATOMIC, \

OMP_ATOMIC_CAPTURE_NEW)->base.private_flag)

True if OMP_ATOMIC* is supposed to be sequentially consistent as opposed to relaxed.

#define OMP_BODY ( NODE ) TREE_OPERAND (TREE_RANGE_CHECK (NODE, OMP_PARALLEL, OMP_CRITICAL), 0)

OpenMP directive and clause accessors.

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

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

#define OMP_CLAUSE_CHAIN ( NODE ) TREE_CHAIN (OMP_CLAUSE_CHECK (NODE))

Referenced by build_call_array_loc(), build_call_vec(), convert_tramp_reference_stmt(), lower_reduction_clauses(), note_nonlocal_vla_type(), use_pointer_for_field(), and workshare_safe_to_combine_p().

#define OMP_CLAUSE_CODE ( NODE ) (OMP_CLAUSE_CHECK (NODE))->omp_clause.code

Referenced by lower_reduction_clauses(), omp_is_private(), and use_pointer_for_field().

#define OMP_CLAUSE_COLLAPSE_COUNT ( NODE ) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_COLLAPSE), 2)

#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_DECL ( NODE )

Value:

OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (OMP_CLAUSE_CHECK (NODE),  \
                                              OMP_CLAUSE_PRIVATE,       \
                                              OMP_CLAUSE__LOOPTEMP_), 0)

Referenced by convert_tramp_reference_stmt(), lower_reduction_clauses(), note_nonlocal_vla_type(), omp_is_private(), omp_max_vf(), use_pointer_for_field(), and workshare_safe_to_combine_p().

#define OMP_CLAUSE_DEFAULT_KIND ( NODE ) (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEFAULT)->omp_clause.subcode.default_kind)

#define OMP_CLAUSE_DEPEND_KIND ( NODE ) (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEPEND)->omp_clause.subcode.depend_kind)

#define OMP_CLAUSE_DEVICE_ID ( NODE ) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEVICE), 0)

Referenced by expand_omp_atomic_mutex().

#define OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR ( NODE )

Value:

OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, \

OMP_CLAUSE_DIST_SCHEDULE), 0)

#define OMP_CLAUSE_ELT_CHECK	(	T,
		i
	)	((T)->omp_clause.ops[i])

#define OMP_CLAUSE_FINAL_EXPR ( NODE ) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_FINAL), 0)

#define OMP_CLAUSE_HAS_LOCATION ( NODE )

Value:

(LOCATION_LOCUS ((OMP_CLAUSE_CHECK (NODE))->omp_clause.locus) \

!= UNKNOWN_LOCATION)

#define OMP_CLAUSE_IF_EXPR ( NODE ) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_IF), 0)

Referenced by lower_send_clauses().

#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 lower_reduction_clauses(), and omp_is_private().

#define OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ ( NODE ) (OMP_CLAUSE_CHECK (NODE))->omp_clause.gimple_reduction_init

Referenced by convert_local_omp_clauses().

#define OMP_CLAUSE_LASTPRIVATE_STMT ( NODE )

Value:

OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE,                   \
                                                OMP_CLAUSE_LASTPRIVATE),\
                      1)

#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 omp_is_private().

#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 omp_is_private().

#define OMP_CLAUSE_LINEAR_STEP ( NODE ) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR), 1)

#define OMP_CLAUSE_LOCATION ( NODE ) (OMP_CLAUSE_CHECK (NODE))->omp_clause.locus

Referenced by expand_omp_atomic_mutex(), lower_reduction_clauses(), and lower_send_clauses().

#define OMP_CLAUSE_MAP_KIND ( NODE ) (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP)->omp_clause.subcode.map_kind)

#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 correspoidng OMP_CLAUSE_MAP_POINTER clause are marked with this flag.

#define OMP_CLAUSE_NUM_TEAMS_EXPR ( NODE ) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_TEAMS), 0)

#define OMP_CLAUSE_NUM_THREADS_EXPR ( NODE ) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_THREADS),0)

Referenced by lower_send_clauses().

#define OMP_CLAUSE_OPERAND	(	NODE,
		I
	)	OMP_CLAUSE_ELT_CHECK (NODE, I)

Referenced by build_call_array_loc(), and build_call_vec().

#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 omp_is_private(), and omp_max_vf().

#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 lower_reduction_clauses().

#define OMP_CLAUSE_PROC_BIND_KIND ( NODE ) (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_PROC_BIND)->omp_clause.subcode.proc_bind_kind)

Referenced by lower_send_clauses().

#define OMP_CLAUSE_RANGE_CHECK	(	T,
		CODE1,
		CODE2
	)	(T)

#define OMP_CLAUSE_REDUCTION_CODE ( NODE ) (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_REDUCTION)->omp_clause.subcode.reduction_code)

#define OMP_CLAUSE_REDUCTION_GIMPLE_INIT ( NODE ) (OMP_CLAUSE_CHECK (NODE))->omp_clause.gimple_reduction_init

Referenced by convert_local_omp_clauses().

#define OMP_CLAUSE_REDUCTION_GIMPLE_MERGE ( NODE ) (OMP_CLAUSE_CHECK (NODE))->omp_clause.gimple_reduction_merge

Referenced by convert_local_omp_clauses().

#define OMP_CLAUSE_REDUCTION_INIT ( NODE ) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_REDUCTION), 1)

#define OMP_CLAUSE_REDUCTION_MERGE ( NODE ) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_REDUCTION), 2)

#define OMP_CLAUSE_REDUCTION_OMP_ORIG_REF ( NODE ) (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_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 omp_max_vf().

#define OMP_CLAUSE_REDUCTION_PLACEHOLDER ( NODE ) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_REDUCTION), 3)

Referenced by convert_local_omp_clauses(), and lower_lastprivate_clauses().

#define OMP_CLAUSE_SAFELEN_EXPR ( NODE ) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SAFELEN), 0)

#define OMP_CLAUSE_SCHEDULE_CHUNK_EXPR ( NODE ) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SCHEDULE), 0)

#define OMP_CLAUSE_SCHEDULE_KIND ( NODE ) (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SCHEDULE)->omp_clause.subcode.schedule_kind)

#define OMP_CLAUSE_SET_CODE	(	NODE,
		CODE
	)	((OMP_CLAUSE_CHECK (NODE))->omp_clause.code = (CODE))

Referenced by omp_is_private().

#define OMP_CLAUSE_SIMDLEN_EXPR ( NODE ) OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SIMDLEN), 0)

#define OMP_CLAUSE_SIZE ( NODE )

Value:

OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (OMP_CLAUSE_CHECK (NODE),  \
                                              OMP_CLAUSE_FROM,          \
                                              OMP_CLAUSE_MAP), 1)

#define OMP_CLAUSE_SUBCODE_CHECK	(	T,
		CODE
	)	(T)

#define OMP_CLAUSE_THREAD_LIMIT_EXPR ( NODE )

Value:

OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, \

OMP_CLAUSE_THREAD_LIMIT), 0)

#define OMP_CLAUSES ( NODE ) TREE_OPERAND (TREE_RANGE_CHECK (NODE, OMP_PARALLEL, OMP_SINGLE), 1)

#define OMP_CRITICAL_BODY ( NODE ) TREE_OPERAND (OMP_CRITICAL_CHECK (NODE), 0)

#define OMP_CRITICAL_NAME ( NODE ) TREE_OPERAND (OMP_CRITICAL_CHECK (NODE), 1)

#define OMP_FOR_BODY ( NODE ) TREE_OPERAND (OMP_LOOP_CHECK (NODE), 0)

#define OMP_FOR_CLAUSES ( NODE ) TREE_OPERAND (OMP_LOOP_CHECK (NODE), 1)

#define OMP_FOR_COND ( NODE ) TREE_OPERAND (OMP_LOOP_CHECK (NODE), 3)

#define OMP_FOR_INCR ( NODE ) TREE_OPERAND (OMP_LOOP_CHECK (NODE), 4)

#define OMP_FOR_INIT ( NODE ) TREE_OPERAND (OMP_LOOP_CHECK (NODE), 2)

#define OMP_FOR_PRE_BODY ( NODE ) TREE_OPERAND (OMP_LOOP_CHECK (NODE), 5)

#define OMP_LOOP_CHECK ( NODE ) TREE_RANGE_CHECK (NODE, OMP_FOR, OMP_DISTRIBUTE)

#define OMP_MASTER_BODY ( NODE ) TREE_OPERAND (OMP_MASTER_CHECK (NODE), 0)

#define OMP_ORDERED_BODY ( NODE ) TREE_OPERAND (OMP_ORDERED_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_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.

#define OMP_SECTION_BODY ( NODE ) TREE_OPERAND (OMP_SECTION_CHECK (NODE), 0)

#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.

#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_SINGLE_BODY ( NODE ) TREE_OPERAND (OMP_SINGLE_CHECK (NODE), 0)

#define OMP_SINGLE_CLAUSES ( NODE ) TREE_OPERAND (OMP_SINGLE_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_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_UPDATE_CLAUSES ( NODE ) TREE_OPERAND (OMP_TARGET_UPDATE_CHECK (NODE), 0)

#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_TASKGROUP_BODY ( NODE ) TREE_OPERAND (OMP_TASKGROUP_CHECK (NODE), 0)

#define OMP_TASKREG_BODY ( NODE ) TREE_OPERAND (OMP_TASKREG_CHECK (NODE), 0)

#define OMP_TASKREG_CHECK ( NODE ) TREE_RANGE_CHECK (NODE, OMP_PARALLEL, OMP_TASK)

#define OMP_TASKREG_CLAUSES ( NODE ) TREE_OPERAND (OMP_TASKREG_CHECK (NODE), 1)

#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 optimization_current_node global_trees[TI_OPTIMIZATION_CURRENT]

Referenced by blocks_nreverse_all().

#define optimization_default_node global_trees[TI_OPTIMIZATION_DEFAULT]

Optimization options (OPTIMIZATION_NODE) to use for default and current functions.

Referenced by blocks_nreverse_all().

#define pid_type_node global_trees[TI_PID_TYPE]

#define POINTER_BOUNDS_P ( NODE ) (POINTER_BOUNDS_TYPE_P (TREE_TYPE (NODE)))

Nonzero if this node has a pointer bounds type.

#define pointer_bounds_type_node global_trees[TI_POINTER_BOUNDS_TYPE]

#define POINTER_BOUNDS_TYPE_P ( NODE ) (TREE_CODE (NODE) == POINTER_BOUNDS_TYPE)

Nonzero if this type is a pointer bounds type.

#define pointer_sized_int_node global_trees[TI_POINTER_SIZED_TYPE]

#define POINTER_TYPE_OVERFLOW_UNDEFINED (flag_strict_overflow)

True if pointer types have undefined overflow.

#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 addr_expr_of_non_mem_decl_p_1(), adjust_related_strinfos(), aff_combination_constant_multiple_p(), analyze_caller_dereference_legality(), build_method_type_directly(), build_opaque_vector_type(), can_propagate_from(), check_array_ref(), create_function_info_for(), create_iv(), determine_base_object(), duplicate_ssa_name_ptr_info(), elim_forward(), estimated_stmt_executions_int(), expand_builtin_prefetch(), expand_omp_atomic_load(), fold_build1_initializer_loc(), fold_builtin_strspn(), fold_convert_const_fixed_from_int(), fold_convert_const_fixed_from_real(), gate_intra_sra(), get_ancestor_addr_info(), get_object_alignment(), get_value(), gimple_get_virt_method_for_binfo(), initializer_constant_valid_p_1(), instrument_derefs(), ipa_load_from_parm_agg(), last_stmt(), load_from_unmodified_param(), lto_input_ts_function_decl_tree_pointers(), move_variant_to_index(), number_of_iterations_cond(), number_of_iterations_lt_to_ne(), process_assert_insertions(), pt_solutions_intersect_1(), range_fits_type_p(), register_edge_assert_for_1(), scev_finalize(), scev_reset(), set_ptr_info_alignment(), simplify_cond_using_ranges(), simplify_using_outer_evolutions(), skip_simple_arithmetic(), split_constant_offset(), stmt_overflow_infinity(), tree_predict_by_opcode(), type_like_member_ptr_p(), update_alias_info_with_stack_vars(), vect_can_advance_ivs_p(), and vrp_stmt_computes_nonzero().

#define PREDICT_EXPR_OUTCOME ( NODE ) ((enum prediction) (PREDICT_EXPR_CHECK (NODE)->base.addressable_flag))

#define PREDICT_EXPR_PREDICTOR ( NODE ) ((enum br_predictor)tree_low_cst (TREE_OPERAND (PREDICT_EXPR_CHECK (NODE), 0), 0))

#define PTR_OR_REF_CHECK ( T ) TREE_CHECK2 (T, POINTER_TYPE, REFERENCE_TYPE)

#define ptr_type_node global_trees[TI_PTR_TYPE]

The C type `void *'.

Referenced by default_function_arg_round_boundary(), expand_builtin_prefetch(), factor_computed_gotos(), get_emutls_object_name(), instrument_memory_accesses(), and lookup_tramp_for_decl().

#define ptrdiff_type_node global_trees[TI_PTRDIFF_TYPE]

#define qq_type_node global_trees[TI_QQ_TYPE]

#define RECORD_OR_UNION_CHECK ( T ) TREE_CHECK3 (T, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE)

#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 asan_decl_phase_3(), go_output_typedef(), lto_input_ts_function_decl_tree_pointers(), and write_ts_field_decl_tree_pointers().

#define REFERENCE_CLASS_P ( NODE ) (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_reference)

Nonzero if NODE represents a reference.

Referenced by contains_placeholder_p(), fold_stmt_1(), type_contains_placeholder_1(), and vect_build_slp_tree_1().

#define round_down	(	T,
		N
	)	round_down_loc (UNKNOWN_LOCATION, T, N)

#define round_up	(	T,
		N
	)	round_up_loc (UNKNOWN_LOCATION, T, N)

#define sa_type_node global_trees[TI_SA_TYPE]

#define sat_accum_type_node global_trees[TI_SAT_ACCUM_TYPE]

Referenced by get_callee_fndecl().

#define sat_da_type_node global_trees[TI_SAT_DA_TYPE]

#define sat_dq_type_node global_trees[TI_SAT_DQ_TYPE]

#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.

#define sat_fract_type_node global_trees[TI_SAT_FRACT_TYPE]

Referenced by decl_type_context().

#define sat_ha_type_node global_trees[TI_SAT_HA_TYPE]

#define sat_hq_type_node global_trees[TI_SAT_HQ_TYPE]

#define sat_long_accum_type_node global_trees[TI_SAT_LACCUM_TYPE]

Referenced by get_callee_fndecl().

#define sat_long_fract_type_node global_trees[TI_SAT_LFRACT_TYPE]

Referenced by decl_type_context().

#define sat_long_long_accum_type_node global_trees[TI_SAT_LLACCUM_TYPE]

Referenced by get_callee_fndecl().

#define sat_long_long_fract_type_node global_trees[TI_SAT_LLFRACT_TYPE]

Referenced by decl_type_context().

#define sat_qq_type_node global_trees[TI_SAT_QQ_TYPE]

#define sat_sa_type_node global_trees[TI_SAT_SA_TYPE]

#define sat_short_accum_type_node global_trees[TI_SAT_SACCUM_TYPE]

Referenced by get_callee_fndecl().

#define sat_short_fract_type_node global_trees[TI_SAT_SFRACT_TYPE]

The fixed-point types.

Referenced by decl_type_context().

#define sat_sq_type_node global_trees[TI_SAT_SQ_TYPE]

#define sat_ta_type_node global_trees[TI_SAT_TA_TYPE]

#define sat_tq_type_node global_trees[TI_SAT_TQ_TYPE]

#define sat_uda_type_node global_trees[TI_SAT_UDA_TYPE]

#define sat_udq_type_node global_trees[TI_SAT_UDQ_TYPE]

#define sat_uha_type_node global_trees[TI_SAT_UHA_TYPE]

#define sat_uhq_type_node global_trees[TI_SAT_UHQ_TYPE]

#define sat_unsigned_accum_type_node global_trees[TI_SAT_UACCUM_TYPE]

Referenced by get_callee_fndecl().

#define sat_unsigned_fract_type_node global_trees[TI_SAT_UFRACT_TYPE]

Referenced by decl_type_context().

#define sat_unsigned_long_accum_type_node global_trees[TI_SAT_ULACCUM_TYPE]

Referenced by get_callee_fndecl().

#define sat_unsigned_long_fract_type_node global_trees[TI_SAT_ULFRACT_TYPE]

Referenced by decl_type_context().

#define sat_unsigned_long_long_accum_type_node global_trees[TI_SAT_ULLACCUM_TYPE]

Referenced by get_callee_fndecl().

#define sat_unsigned_long_long_fract_type_node global_trees[TI_SAT_ULLFRACT_TYPE]

Referenced by decl_type_context().

#define sat_unsigned_short_accum_type_node global_trees[TI_SAT_USACCUM_TYPE]

Referenced by get_callee_fndecl().

#define sat_unsigned_short_fract_type_node global_trees[TI_SAT_USFRACT_TYPE]

Referenced by decl_type_context().

#define sat_uqq_type_node global_trees[TI_SAT_UQQ_TYPE]

#define sat_usa_type_node global_trees[TI_SAT_USA_TYPE]

#define sat_usq_type_node global_trees[TI_SAT_USQ_TYPE]

#define sat_uta_type_node global_trees[TI_SAT_UTA_TYPE]

#define sat_utq_type_node global_trees[TI_SAT_UTQ_TYPE]

#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_builtin_prefetch().

#define sbitsize_int ( L ) size_int_kind (L, stk_sbitsizetype)

#define sbitsizetype sizetype_tab[(int) stk_sbitsizetype]

#define SCALAR_FLOAT_TYPE_P ( TYPE ) (TREE_CODE (TYPE) == REAL_TYPE)

Nonzero if TYPE represents a scalar floating-point type.

Referenced by chrec_evaluate(), expand_complex_libcall(), and vect_slp_analyze_bb().

#define SCOPE_FILE_SCOPE_P ( EXP ) (! (EXP) || TREE_CODE (EXP) == TRANSLATION_UNIT_DECL)

Nonzero for a scope which is equal to file scope.

#define SET_DECL_ASSEMBLER_NAME	(	NODE,
		NAME
	)	(DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.assembler_name = (NAME))

Set the DECL_ASSEMBLER_NAME for NODE to NAME.

Referenced by lto_input_ts_decl_common_tree_pointers().

#define SET_DECL_DEBUG_EXPR	(	NODE,
		VAL
	)	(decl_debug_expr_insert (VAR_DECL_CHECK (NODE), VAL))

Referenced by complex_visit_phi().

#define SET_DECL_FINI_PRIORITY	(	NODE,
		VAL
	)	(decl_fini_priority_insert (NODE, VAL))

Set the finalization priority for NODE to VAL.

#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_stat().

#define SET_DECL_OFFSET_ALIGN	(	NODE,
		X
	)	(FIELD_DECL_CHECK (NODE)->decl_common.off_align = ffs_hwi (X) - 1)

Specify that DECL_ALIGN(NODE) is a multiple of X.

#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 make_node_stat().

#define SET_DECL_RTL	(	NODE,
		RTL
	)	set_decl_rtl (NODE, RTL)

Set the DECL_RTL for NODE to RTL.

Referenced by allocate_struct_function(), assign_parm_adjust_stack_rtl(), and canonicalize_component_ref().

#define SET_DECL_VALUE_EXPR	(	NODE,
		VAL
	)	(decl_value_expr_insert (DECL_WRTL_CHECK (NODE), VAL))

Referenced by assign_parms(), canonicalize_component_ref(), gimplify_return_expr(), and move_stmt_eh_region_nr().

#define SET_EXPR_LOCATION	(	NODE,
		LOCUS
	)	EXPR_CHECK ((NODE))->exp.locus = (LOCUS)

Referenced by build_minus_one_cst(), ipa_set_jf_known_type(), lookup_tmp_var(), maybe_with_size_expr(), protected_set_expr_location_unshare(), tree_operand_length(), and unshare_body().

#define SET_PREDICT_EXPR_OUTCOME	(	NODE,
		OUTCOME
	)	(PREDICT_EXPR_CHECK (NODE)->base.addressable_flag = (int) OUTCOME)

#define SET_SSA_NAME_VAR_OR_IDENTIFIER	(	NODE,
		VAR
	)	do { SSA_NAME_CHECK (NODE)->ssa_name.var = (VAR); } while (0)

Referenced by rewrite_update_dom_walker::after_dom_children(), copy_ssa_name(), duplicate_ssa_name_fn(), and release_ssa_name().

#define SET_TYPE_MODE	(	NODE,
		MODE
	)	(TYPE_CHECK (NODE)->type_common.mode = (MODE))

Referenced by compute_record_mode(), finish_bitfield_layout(), and simple_cst_equal().

#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 associative_tree_code(), build_array_type(), and simple_cst_equal().

#define SET_TYPE_VECTOR_SUBPARTS	(	VECTOR_TYPE,
		X
	)	(VECTOR_TYPE_CHECK (VECTOR_TYPE)->type_common.precision = exact_log2 (X))

Set precision to n when we have 2^n sub-parts of the vector.

#define short_accum_type_node global_trees[TI_SACCUM_TYPE]

#define short_fract_type_node global_trees[TI_SFRACT_TYPE]

#define short_integer_type_node integer_types[itk_short]

#define short_unsigned_type_node integer_types[itk_unsigned_short]

#define signed_char_type_node integer_types[itk_signed_char]

Referenced by build_nonshared_array_type().

#define size_binop	(	CODE,
		T1,
		T2
	)	size_binop_loc (UNKNOWN_LOCATION, CODE, T1, T2)

Referenced by compute_object_offset(), create_component_ref_by_pieces_1(), dr_analyze_indices(), expand_builtin_memset_args(), finish_builtin_struct(), and relayout_decl().

#define size_diffop	(	T1,
		T2
	)	size_diffop_loc (UNKNOWN_LOCATION, T1, T2)

#define size_int ( L ) size_int_kind (L, stk_sizetype)

Referenced by assign_parms(), compute_object_offset(), coverage_end_function(), coverage_obj_init(), create_component_ref_by_pieces_1(), default_cxx_guard_type(), distribute_real_division(), expand_builtin_va_copy(), finish_bitfield_layout(), fold_mathfn_compare(), gimplify_return_expr(), lookup_tramp_for_decl(), nothing_to_prefetch_p(), and vect_do_peeling_for_loop_bound().

#define size_one_node global_trees[TI_SIZE_ONE]

Referenced by constant_pointer_difference(), and expand_builtin_prefetch().

#define size_type_node global_trees[TI_SIZE_TYPE]

The C type `size_t'.

Referenced by build_call_expr(), fold_builtin_strcspn(), and handle_pointer_plus().

#define size_zero_node global_trees[TI_SIZE_ZERO]

Referenced by build_call_expr(), constant_pointer_difference(), expand_builtin_prefetch(), finish_builtin_struct(), gimple_get_virt_method_for_binfo(), and vect_do_peeling_for_loop_bound().

#define sizetype sizetype_tab[(int) stk_sizetype]

Referenced by backtrace_base_for_ref(), compute_object_offset(), create_mem_ref(), default_cxx_guard_type(), expand_builtin_prefetch(), expand_expr_real_1(), finish_builtin_struct(), gimplify_mem_ref_parts(), maybe_fold_tmr(), move_pointer_to_base(), move_variant_to_index(), nothing_to_prefetch_p(), number_of_iterations_cond(), tree_to_aff_combination(), and vect_gen_niters_for_prolog_loop().

#define sq_type_node global_trees[TI_SQ_TYPE]

#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_repeat_to_ops_vec(), adjust_related_strinfos(), analyze_evolution_in_loop(), analyze_increments(), ao_ref_base_alias_set(), build_and_add_sum(), check_bool_pattern(), constant_pointer_difference(), convert_mult_to_widen(), create_call_for_reduction(), create_expression_by_pieces(), create_parallel_loop(), create_phi_for_local_result(), debug_lattice_value(), decrement_power(), determine_base_object(), determine_max_movement(), dump_live_info(), eliminate_local_variables(), eliminate_phi(), execute_pred_commoning_chain(), extr_type_from_vtbl_ptr_store(), find_bswap_1(), find_equal_ptrs(), find_givs_in_bb(), find_induction_variables(), find_loop_niter(), find_matching_predicate_in_rest_chains(), find_subloop_latch_edge_by_profile(), fold_stmt_inplace(), follow_ssa_edge_binary(), gen_conditions_for_pow_cst_base(), get_ancestor_addr_info(), get_continuation_for_phi(), get_initial_def_for_reduction(), get_instantiated_value_entry(), get_iv(), get_loops_exits(), get_rank(), get_rtx_for_ssa_name(), independent_of_stmt_p(), infer_value_range(), initialize_inline_failed(), insert_aux(), ipa_load_from_parm_agg(), is_and_or_or(), is_true_predicate(), jump_function_from_stmt(), loe_visit_block(), lookup_avail_expr(), make_pass_build_ssa(), maybe_register_def(), move_sese_in_condition(), ncd_for_two_cands(), ncd_of_cand_and_phis(), outermost_invariant_loop(), phi_result_unknown_predicate(), propagate_with_phi(), recognize_single_bit_test(), ref_may_be_aliased(), register_edge_assert_for_1(), remove_ssa_form(), replace_phi_args_in(), rewrite_reciprocal(), rewrite_to_defined_overflow(), rewrite_use_nonlinear_expr(), simplify_bitwise_binary_1(), simplify_gimple_switch_label_vec(), stmt_cost(), stmt_kills_ref_p(), stmt_kills_ref_p_1(), strlen_optimize_stmt(), tm_log_emit_restores(), transform_to_exit_first_loop(), trivially_conflicts_p(), try_improve_iv_set(), type_for_widest_vector_mode(), vect_create_cond_for_alias_checks(), vect_slp_analyze_bb(), vn_reference_lookup_1(), and instantiate_cache_type::~instantiate_cache_type().

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

SSA_NAME accessors. Returns the IDENTIFIER_NODE giving the SSA name a name or NULL_TREE if there is no name associated with it.

#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 delink_imm_use(), end_imm_use_stmt_traverse(), first_readonly_imm_use(), has_zero_uses(), next_readonly_imm_use(), and release_ssa_name().

#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 last_stmt(), and release_ssa_name().

#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 rewrite_update_dom_walker::after_dom_children(), coalesce_partitions(), debug_tree_ssa(), do_partial_partial_insertion(), get_ancestor_addr_info(), get_rank(), initialize_inline_failed(), ipa_compute_jump_functions(), ipa_load_from_parm_agg(), propagate_with_phi(), remap_ssa_name(), stmt_kills_ref_p(), tm_log_emit_saves(), and warn_uninitialized_vars().

#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 alloc_iv(), associate_equivalences_with_edges(), compare_range_with_value(), compute_uninit_opnds_pos(), forward_propagate_addr_expr(), gate_lower_resx(), group_case_labels(), handle_pointer_plus(), lookup_avail_expr(), maybe_register_def(), and simplify_conversion_from_bitmask().

#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 duplicate_ssa_name_ptr_info(), get_address_description(), get_object_alignment(), get_value(), set_ptr_info_alignment(), and update_alias_info_with_stack_vars().

#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 duplicate_ssa_name_ptr_info(), and get_value().

#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 adjust_ptr_info_misalignment(), adjust_simduid_builtins(), rewrite_update_dom_walker::after_dom_children(), coalesce_partitions(), debug_currdefs(), dump_live_info(), dump_tree_ssa_stats(), elim_forward(), find_clusters_1(), find_replaceable_in_bb(), get_ancestor_addr_info(), gimple_replace_ssa_lhs(), has_undefined_value_p(), initialize_root(), insert_phi_nodes(), ipa_load_from_parm_agg(), ipa_note_param_call(), maybe_register_def(), note_simd_array_uses(), release_ssa_name(), remap_ssa_name(), rewrite_dom_walker::rewrite_dom_walker(), rewrite_use_nonlinear_expr(), set_component_ssa_name(), set_is_used(), and warn_uninitialized_vars().

#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_scope_conflicts(), adjust_related_strinfos(), attempt_coalesce(), check_all_array_refs(), check_array_bounds(), check_va_list_escapes(), coalesce_partitions(), compute_builtin_object_size(), cond_expr_object_size(), constant_type(), create_component_ref_by_pieces(), create_outofssa_var_map(), debug_rename_map(), del_scev_info(), delete_var_map(), dump_cand(), dump_update_ssa(), find_matching_predicate_in_rest_chains(), find_va_list_reference(), get_continuation_for_phi(), get_loops_exits(), get_rtx_for_ssa_name(), inhibit_phi_insertion(), initialize_root_vars_lm(), kill_expr(), make_pass_build_ssa(), print_exprs(), propagate_rhs_into_lhs(), propagate_with_phi(), register_edge_assert_for(), register_edge_assert_for_1(), release_defs(), release_ssa_name(), remove_from_partition_kill_list(), reset_debug_uses(), rewrite_use_nonlinear_expr(), separate_decls_in_region_stmt(), set_livein_block(), set_value_range_to_null(), stmt_kills_ref_p_1(), valueize_val(), version_to_var(), vrp_operand_equal_p(), and will_be_nonconstant_expr_predicate().

#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 fold_builtin_logarithm(), gimplify_assign(), and separate_decls_in_region_stmt().

#define ssize_int ( L ) size_int_kind (L, stk_ssizetype)

Referenced by expand_builtin_memset_args().

#define ssizetype sizetype_tab[(int) stk_ssizetype]

Referenced by debug_ddrs(), and finish_builtin_struct().

#define STATEMENT_CLASS_P ( NODE ) (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_statement)

Nonzero if NODE represents a statement expression.

#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 tsi_link_before().

#define STATEMENT_LIST_TAIL ( NODE ) (STATEMENT_LIST_CHECK (NODE)->stmt_list.tail)

Referenced by expr_first(), and tsi_link_before().

#define STMT_CHECK ( T ) TREE_CLASS_CHECK (T, tcc_statement)

#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_data_member_location_attribute(), decode_field_reference(), dw2_output_call_site_table(), extract_int(), fixed_zerop(), fold_builtin_constant_p(), fold_builtin_strcspn(), fold_builtin_strncat_chk(), fold_builtin_strncpy(), get_object_alignment(), get_pointer_alignment(), get_unwidened(), gimple_get_virt_method_for_binfo(), native_encode_real(), optimize_bit_field_compare(), and split_constant_offset().

#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 native_encode_real().

#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.

#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 fold_build_cond_expr(), and vrp_stmt_computes_nonzero().

#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 find_placeholder_in_expr(), and type_contains_placeholder_1().

#define SUBSTITUTE_PLACEHOLDER_IN_EXPR	(	EXP,
		OBJ
	)

Value:

((EXP) == 0 || TREE_CONSTANT (EXP) ? (EXP) \

: substitute_placeholder_in_expr (EXP, OBJ))

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 count_type_elements().

#define SWITCH_BODY ( NODE ) TREE_OPERAND (SWITCH_EXPR_CHECK (NODE), 1)

#define SWITCH_COND ( NODE ) TREE_OPERAND (SWITCH_EXPR_CHECK (NODE), 0)

SWITCH_EXPR accessors. These give access to the condition, body and original condition type (before any compiler conversions) of the switch statement, respectively.

#define SWITCH_LABELS ( NODE ) TREE_OPERAND (SWITCH_EXPR_CHECK (NODE), 2)

#define ta_type_node global_trees[TI_TA_TYPE]

#define TARGET_EXPR_CLEANUP ( NODE ) TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 2)

#define TARGET_EXPR_INITIAL ( NODE ) TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 1)

#define TARGET_EXPR_SLOT ( NODE ) TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 0)

In a TARGET_EXPR node.

#define target_option_current_node global_trees[TI_TARGET_OPTION_CURRENT]

#define target_option_default_node global_trees[TI_TARGET_OPTION_DEFAULT]

Default/current target options (TARGET_OPTION_NODE).

#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 is_used_p(), and mark_address_taken().

#define TMR_INDEX ( NODE ) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 2))

Referenced by get_addr_base_and_unit_offset_1(), is_used_p(), and mark_address_taken().

#define TMR_INDEX2 ( NODE ) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 4))

Referenced by get_addr_base_and_unit_offset_1(), get_address_description(), is_used_p(), and mark_address_taken().

#define TMR_OFFSET ( NODE ) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 1))

Referenced by get_addr_base_and_unit_offset_1().

#define TMR_STEP ( NODE ) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 3))

Referenced by get_address_description().

#define tq_type_node global_trees[TI_TQ_TYPE]

#define TRANSACTION_EXPR_BODY ( NODE ) TREE_OPERAND (TRANSACTION_EXPR_CHECK (NODE), 0)

TM directives and accessors.

#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 TRANSLATION_UNIT_LANGUAGE ( NODE ) (TRANSLATION_UNIT_DECL_CHECK (NODE)->translation_unit_decl.language)

The source language of the translation-unit.

Referenced by build3_stat(), and pack_ts_block_value_fields().

#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 assign_parms(), compute_argument_block_size(), create_tmp_var_raw(), expand_omp_for_init_vars(), expand_task_call(), gate_intra_sra(), initialize_argument_information(), lookup_tramp_for_decl(), non_rewritable_mem_ref_base(), tree_nrv(), use_register_for_decl(), and verify_phi_args().

#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_bit_offset_attribute(), emit_common(), emit_local(), macinfo_entry_hasher::equal(), initialize_sanitizer_builtins(), output_constructor_bitfield(), setjmp_vars_warning(), and vect_load_lanes_supported().

#define TREE_BLOCK ( NODE ) (tree_block (NODE))

#define TREE_CHAIN ( NODE ) ((NODE)->common.chain)

Referenced by add_bit_offset_attribute(), add_ttypes_entry(), assign_assembler_name_if_neeeded(), build_fn_decl(), build_reference_type_for_mode(), build_sender_ref(), build_vector_from_val(), comp_type_attributes(), contains_placeholder_p(), decl_debug_expr_insert(), decl_value_expr_lookup(), expand_eh_return(), find_decls_types_in_eh_region(), find_decls_types_in_node(), free_lang_data_in_binfo(), gimple_asm_clobbers_memory_p(), init_inline_once(), instrument_builtin_call(), ipa_print_all_params(), ipa_register_cgraph_hooks(), iterative_hash_exprs_commutative(), iterative_hash_hashval_t(), list_length(), lower_omp_teams(), lto_input_eh_catch_list(), lto_input_ts_type_common_tree_pointers(), output_weakrefs(), really_constant_p(), record_common_node(), reverse_op(), stmt_overflow_infinity(), store_child_info(), streamer_read_chain(), streamer_write_builtin(), tree_conflicts_with_clobbers_p(), tree_invariant_p(), type_contains_placeholder_1(), and value_member().

#define TREE_CHECK	(	T,
		CODE
	)	(T)

#define TREE_CHECK2	(	T,
		CODE1,
		CODE2
	)	(T)

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

#define TREE_CHECK4	(	T,
		CODE1,
		CODE2,
		CODE3,
		CODE4
	)	(T)

#define TREE_CHECK5	(	T,
		CODE1,
		CODE2,
		CODE3,
		CODE4,
		CODE5
	)	(T)

#define TREE_CLASS_CHECK	(	T,
		CODE
	)	(T)

#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 mark_stmt_if_obviously_necessary().

#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.

Referenced by add_abstract_origin_attribute(), add_bit_offset_attribute(), add_bound_info(), add_data_member_location_attribute(), add_gnat_descriptive_type_attribute(), add_linkage_name(), add_loc_list(), add_location_or_const_value_attribute(), add_scope_conflicts(), adjust_related_strinfos(), adjust_simduid_builtins(), rewrite_update_dom_walker::after_dom_children(), agg_jmp_p_vec_for_t_vec(), alias_sets_must_conflict_p(), all_zeros_p(), alloc_cand_and_find_basis(), allocate_vn_table(), analyze_evolution_in_loop(), analyze_overlapping_iterations(), annotate_all_with_location_after(), append_to_statement_list_1(), array_ref_up_bound(), asan_decl_phase_3(), assemble_integer_with_op(), assign_parms(), associate_equivalences_with_edges(), auto_var_in_fn_p(), backtrace_base_for_ref(), bb_predicate(), bitmap_find_leader(), build_and_add_sum(), build_function_type_list_1(), build_method_type_directly(), build_offset_type(), build_opaque_vector_type(), build_qualified_type(), build_simple_mem_ref_loc(), build_string(), build_word_mode_vector_type(), can_propagate_from(), canonicalize_component_ref(), ceil_sdiv_adjust(), cgraph_call_node_duplication_hooks(), cgraph_create_empty_node(), check_array_ref(), check_for_plus_in_loops_1(), chrec_evaluate(), chrec_fold_automatically_generated_operands(), comp_type_attributes(), compcode_to_comparison(), component_uses_parent_alias_set_from(), compute_argument_block_size(), compute_object_offset(), compute_subscript_distance(), constant_after_peeling(), constant_pointer_difference(), contains_placeholder_p(), convert_descriptor_to_mode(), copy_to_suggested_reg(), copy_tree_body_r(), count_type_elements(), create_expression_by_pieces(), create_function_info_for(), create_iv(), create_mul_ssa_cand(), create_outofssa_var_map(), create_vector_array(), debug_tree(), debug_varpool(), decode_addr_const(), decode_field_reference(), delete_unreachable_blocks_update_callgraph(), delete_var_map(), delink_imm_use(), dependence_level(), destroy_predicate_vecs(), DFS(), DFS_write_tree_body(), diagnose_tm_1_op(), dr_analyze_indices(), dump_dominator_optimization_stats(), dump_gimple_statistics(), dump_possible_polymorphic_call_targets(), dump_symtab(), dw2_output_call_site_table(), elim_forward(), eliminate_local_variables(), eliminate_phi(), eliminate_temp_copies(), eliminate_useless_phis(), emit_local(), eq_evolutions_p(), estimate_move_cost(), evolution_function_is_invariant_p(), evolution_function_is_invariant_rec_p(), execute_sm_if_changed_flag_set(), expand_builtin_memset_args(), expand_builtin_prefetch(), expand_complex_libcall(), expand_debug_parm_decl(), expand_expr_real_1(), expand_omp_for_init_vars(), expr_first(), expr_location_or(), extract_int(), extract_range_from_comparison(), file_name_acquire(), find_bswap_1(), find_case_label_index(), find_decls_types_in_node(), find_givs_in_bb(), find_induction_variables(), find_matching_predicate_in_rest_chains(), find_subloop_latch_edge_by_profile(), find_var_from_fn(), finish_bitfield_layout(), finish_builtin_struct(), fixed_address_object_p(), fixed_zerop(), fold_build_cond_expr(), fold_builtin_4(), fold_builtin_cbrt(), fold_builtin_classify(), fold_builtin_exponent(), fold_builtin_logarithm(), fold_builtin_strcspn(), fold_builtin_strncat_chk(), fold_builtin_strncpy(), fold_builtin_strstr(), fold_convert_const_fixed_from_int(), fold_convert_const_fixed_from_real(), fold_fma(), fold_mathfn_compare(), fold_negate_expr(), fold_or_predicates(), fold_unary_ignore_overflow_loc(), fortran_common(), forward_propagate_addr_expr(), free_conflict_function(), free_lang_data_in_binfo(), gate_cse_sincos(), gate_intra_sra(), gen_eh_region_try(), gen_lexical_block_die(), generate_subtree_copies(), get_addr_base_and_unit_offset_1(), get_address_description(), get_ancestor_addr_info(), get_asm_expr_operands(), get_AT_hi_pc(), get_attrs_for(), get_deref_alias_set_1(), get_expr_type(), get_loops_exits(), get_memmodel(), get_mode_alignment(), get_object_alignment(), get_or_create_ssa_default_def(), get_pointer_alignment(), get_pool_constant(), get_unwidened(), get_value_from_alignment(), gimple_asm_clobbers_memory_p(), gimple_assign_nonzero_warnv_p(), gimple_build_call(), gimple_build_call_vec(), gimple_call_reset_alias_info(), gimple_could_trap_p(), gimple_get_virt_method_for_binfo(), gimple_redirect_edge_and_branch(), gimple_replace_ssa_lhs(), gimple_stmt_nonnegative_warnv_p(), gimplify_assign(), gimplify_expr(), gimplify_modify_expr_to_memset(), gimplify_omp_task(), gimplify_switch_expr(), hash_scc(), hash_type_name(), hide_evolution_in_other_loops_than_loop(), if_convertible_loop_p(), independent_of_stmt_p(), infer_value_range(), inhibit_phi_insertion(), init_block_clear_fn(), initialize_argument_information(), initialize_inline_failed(), initialize_sanitizer_builtins(), initializer_constant_valid_p_1(), inline_forbidden_p_stmt(), insert_debug_temps_for_defs(), insert_gimplified_predicates(), insert_int(), insert_var_expansion_initialization(), instantiate_decls(), instantiate_scev_3(), instantiate_scev_not(), invert_truthvalue_loc(), ipa_analyze_virtual_call_uses(), ipa_compute_jump_functions(), ipa_load_from_parm_agg(), ipa_prop_write_all_agg_replacement(), ipa_reference_get_not_written_global(), ipa_set_jf_known_type(), is_gimple_addressable(), is_gimple_condexpr(), is_gimple_constant(), is_gimple_ip_invariant(), is_gimple_lvalue(), is_gimple_min_invariant(), is_gimple_val(), is_true_predicate(), is_vptr_store(), lhd_complain_wrong_lang_p(), lhd_print_error_function(), live_track_init(), local_scope_p(), lookup_avail_expr(), lookup_cand(), loop_phi_node_p(), lower_emutls_stmt(), lower_omp_target(), lto_input_ts_decl_common_tree_pointers(), lto_input_ts_decl_minimal_tree_pointers(), lto_input_ts_function_decl_tree_pointers(), lto_write_tree(), make_blocks(), make_decl_rtl_for_debug(), make_fancy_name(), make_pass_tree_loop_done(), mark_modified(), mark_stmt_if_obviously_necessary(), maybe_canonicalize_argtypes(), maybe_dump_rtl_for_gimple_stmt(), maybe_optimize_var(), maybe_record_node(), maybe_register_def(), maybe_with_size_expr(), member_declared_type(), mode_for_array(), move_sese_in_condition(), move_stmt_eh_region_nr(), n_occurrences(), new_alias_set(), non_rewritable_mem_ref_base(), normalize_offset(), note_nonlocal_vla_type(), nreverse(), num_imm_uses(), object_address_invariant_in_loop_p(), old_insns_match_p(), op_iter_next_def(), operand_equal_for_phi_arg_p(), optimize_bit_field_compare(), optimize_minmax_comparison(), optimize_omp_library_calls(), optimize_range_tests_diff(), optimize_stmt(), outermost_invariant_loop_for_expr(), output_constant(), output_constant_pool(), output_constructor_bitfield(), output_type_ref(), paradoxical_subreg_p(), phi_result_unknown_predicate(), phi_translate_1(), plus_stmt_object_size(), pop_access_from_work_queue(), print_insn(), process_assert_insertions_for(), promote_mode(), propagate_with_phi(), ptr_deref_may_alias_decl_p(), range_fits_type_p(), range_includes_zero_p(), really_constant_p(), record_equality(), ref_may_alias_global_p(), ref_may_be_aliased(), referred_to_p(), register_edge_assert_for(), register_edge_assert_for_1(), register_new_def(), relayout_decl(), release_mem_refs(), remap_decl(), remap_gimple_op_r(), remap_ssa_name(), remap_type(), remove_exit_barrier(), replace_goto_queue(), replace_phi_args_in(), reverse_op(), rewrite_reciprocal(), rewrite_to_defined_overflow(), rewrite_use_nonlinear_expr(), rhs_to_tree(), same_bool_result_p(), separate_decls_in_region_stmt(), set_all_contains_variable(), set_random_seed(), set_rename(), set_value_varying(), set_var_live_on_entry(), shared_hash_find_slot_1(), shortcut_cond_expr(), sign_bit_p(), signed_or_unsigned_type_for(), simple_cst_equal(), simplify_binary_expression(), simplify_bitwise_binary_1(), simplify_cond_using_ranges(), simplify_conversion_from_bitmask(), simplify_using_outer_evolutions(), single_element_loc_list_p(), skip_simple_arithmetic(), split_address_cost(), split_constant_offset(), ssa_default_def(), ssa_prop_fini(), ssanames_print_statistics(), stmt_is_power_of_op(), stmt_overflow_infinity(), store_child_info(), streamer_write_chain(), TB_get_tree_code(), thunk_adjust(), tm_log_emit_saves(), tree_block(), tree_int_cst_sign_bit(), tree_invariant_p(), tree_nrv(), tree_predict_by_opcode(), tree_to_aff_combination(), trivially_conflicts_p(), try_improve_iv_set(), type_contains_placeholder_1(), type_for_widest_vector_mode(), type_hash_list(), type_like_member_ptr_p(), ubsan_type_descriptor(), unmark_visited_r(), unmodified_parm_or_parm_agg_item(), unshare_expr_without_location(), update_complex_assignment(), update_complex_components_on_edge(), update_profiling_info(), update_range_test(), update_value_range(), use_register_for_decl(), valid_value_p(), value_inside_range(), value_range_constant_singleton(), varpool_finalize_decl(), varpool_output_variables(), vect_analyze_slp(), vect_build_slp_tree_1(), vect_create_vectorized_demotion_stmts(), vect_do_peeling_for_loop_bound(), vect_finish_stmt_generation(), vect_get_new_vect_var(), vect_get_vec_defs_for_stmt_copy(), vect_load_lanes_supported(), vect_mark_relevant(), verify_gimple_label(), verify_loop_closed_ssa(), verify_phi_args(), virt_loc_aware_diagnostic_finalizer(), virtual_operand_p(), vn_nary_op_insert_into(), vn_reference_lookup(), vn_reference_maybe_forwprop_address(), vn_reference_op_compute_hash(), vrp_intersect_ranges_1(), vrp_stmt_computes_nonzero(), walk_polymorphic_call_targets(), walk_stmt_load_store_addr_ops(), warn_uninitialized_vars(), will_be_nonconstant_expr_predicate(), write_ts_common_tree_pointers(), write_ts_decl_minimal_tree_pointers(), and write_ts_field_decl_tree_pointers().

#define TREE_CODE_CLASS_STRING ( CLASS ) tree_code_class_strings[(int) (CLASS)]

Returns the string representing CLASS.

Referenced by auto_var_in_fn_p().

#define TREE_CODE_LENGTH ( CODE ) tree_code_length[(int) (CODE)]

Referenced by attribute_list_equal(), contains_placeholder_p(), type_contains_placeholder_1(), and vect_create_vectorized_demotion_stmts().

#define tree_cons	(	t,
		q,
		w
	)	tree_cons_stat (t,q,w MEM_STAT_INFO)

Referenced by decl_attributes(), gen_eh_region_try(), gimple_init_edge_profiler(), ipa_free_all_structures_after_iinln(), iterative_hash_exprs_commutative(), output_constructor_bitfield(), t2r_eq(), and type_contains_placeholder_1().

#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 expand_builtin_va_copy(), internal_reference_types(), optimize_compound_literals_in_ctor(), output_constant_pool(), pack_ts_base_value_fields(), and tree_predict_by_opcode().

#define tree_decl_map_eq tree_map_base_eq

#define tree_decl_map_marked_p tree_map_base_marked_p

#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)).

#define TREE_FIXED_CST ( NODE ) (*TREE_FIXED_CST_PTR (NODE))

Referenced by decode_addr_const(), fold_convert_const_int_from_fixed(), fold_convert_const_int_from_int(), tree_unary_nonnegative_warnv_p(), and try_move_mult_to_index().

#define TREE_FIXED_CST_PTR ( NODE ) (FIXED_CST_CHECK (NODE)->fixed_cst.fixed_cst_ptr)

Referenced by build_constructor(), and default_assemble_integer().

#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.

#define TREE_IMAGPART ( NODE ) (COMPLEX_CST_CHECK (NODE)->complex.imag)

Referenced by decode_addr_const(), default_assemble_integer(), fixed_zerop(), fold_builtin_snprintf_chk(), fold_negate_expr(), init_block_clear_fn(), and initializer_constant_valid_p_1().

#define TREE_INT_CST ( NODE ) (INTEGER_CST_CHECK (NODE)->int_cst.int_cst)

Define additional fields and accessors for nodes representing constants. In an INTEGER_CST node. These two together make a 2-word integer. If the data type is signed, the value is sign-extended to 2 words even though not all of them may really be in use. In an unsigned constant shorter than 2 words, the extra bits are 0.

Referenced by default_assemble_integer(), and double_int_to_tree().

#define TREE_INT_CST_HIGH ( NODE ) (TREE_INT_CST (NODE).high)

Referenced by add_bit_offset_attribute(), attribute_list_contained(), build_vector_type_for_mode(), copy_tree_body_r(), fold_builtin_cbrt(), initializer_constant_valid_p_1(), output_constant(), preprocess_case_label_vec_for_gimple(), remap_gimple_op_r(), and type_hash_list().

#define TREE_INT_CST_LOW ( NODE ) (TREE_INT_CST (NODE).low)

#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_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 comp_type_attributes().

#define TREE_LANG_FLAG_1 ( NODE ) (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_1)

Referenced by comp_type_attributes().

#define TREE_LANG_FLAG_2 ( NODE ) (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_2)

Referenced by comp_type_attributes().

#define TREE_LANG_FLAG_3 ( NODE ) (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_3)

Referenced by comp_type_attributes().

#define TREE_LANG_FLAG_4 ( NODE ) (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_4)

Referenced by comp_type_attributes().

#define TREE_LANG_FLAG_5 ( NODE ) (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_5)

Referenced by comp_type_attributes().

#define TREE_LANG_FLAG_6 ( NODE ) (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_6)

Referenced by comp_type_attributes().

#define tree_map_eq tree_map_base_eq

Referenced by merge_weak().

#define tree_map_marked_p tree_map_base_marked_p

#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 output_constant_pool().

#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 complex_visit_phi(), find_assert_locations_1(), gimple_purge_dead_eh_edges(), has_undefined_value_p(), and vrp_meet_1().

#define TREE_NOT_CHECK	(	T,
		CODE
	)	(T)

#define TREE_NOT_CHECK2	(	T,
		CODE1,
		CODE2
	)	(T)

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

#define TREE_NOT_CHECK4	(	T,
		CODE1,
		CODE2,
		CODE3,
		CODE4
	)	(T)

#define TREE_NOT_CHECK5	(	T,
		CODE1,
		CODE2,
		CODE3,
		CODE4,
		CODE5
	)	(T)

#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 default_stack_protect_guard(), and gimple_init_edge_profiler().

#define TREE_OPERAND	(	NODE,
		I
	)	TREE_OPERAND_CHECK (NODE, I)

Referenced by add_bound_info(), add_data_member_location_attribute(), adjust_related_strinfos(), analyze_all_param_acesses(), array_ref_element_size(), attribute_list_equal(), backtrace_base_for_ref(), bb_predicate(), build1_stat(), build_fold_addr_expr_loc(), build_function_decl_skip_args(), canonicalize_component_ref(), check_va_list_escapes(), compute_antic(), compute_object_offset(), compute_subscript_distance(), constant_after_peeling(), contains_placeholder_p(), create_iv(), decl_address_ip_invariant_p(), delete_unreachable_blocks_update_callgraph(), dependence_level(), diagnose_tm_1_op(), dr_analyze_indices(), dump_dominator_optimization_stats(), dump_gimple_statistics(), dw2_output_call_site_table(), tree_upper_hasher::equal(), exact_inverse(), execute_sm_if_changed_flag_set(), expand_builtin_prefetch(), expand_debug_parm_decl(), expr_first(), expr_has_constants(), fixed_address_object_p(), fold_build_cond_expr(), fold_builtin_alloca_with_align(), fold_builtin_constant_p(), fold_builtin_logarithm(), fold_mathfn_compare(), fold_mult_zconjz(), fold_truth_not_expr(), fold_unary_ignore_overflow_loc(), fold_widened_comparison(), generate_subtree_copies(), generic_expr_could_trap_p(), get_addr_base_and_unit_offset_1(), get_address_description(), get_ancestor_addr_info(), get_asm_expr_operands(), get_deref_alias_set_1(), get_expr_operands(), get_initial_def_for_reduction(), get_object_alignment(), get_or_create_ssa_default_def(), get_pointer_alignment(), get_rank(), get_ssa_def_if_simple_copy(), get_subtarget(), get_unwidened(), gimple_assign_nonzero_warnv_p(), gimple_get_virt_method_for_binfo(), gimple_stmt_nonnegative_warnv_p(), gimple_val_nonnegative_real_p(), gimplify_expr(), gimplify_init_ctor_eval(), gimplify_modify_expr_complex_part(), gimplify_modify_expr_to_memset(), gimplify_omp_task(), gimplify_switch_expr(), hash_type_name(), if_convertible_loop_p(), init_subtree_with_zero(), initializer_constant_valid_p_1(), insert_gimplified_predicates(), instantiate_array_ref(), instantiate_scev_3(), instantiate_scev_not(), integer_valued_real_p(), ipa_get_parm_lattices(), ipa_prop_write_all_agg_replacement(), ipa_set_jf_known_type(), is_gimple_ip_invariant(), is_gimple_val(), is_gimple_variable(), is_vptr_store(), last_stmt(), loop_has_blocks_with_irreducible_flag(), lower_omp_master(), lower_reduction_clauses(), lto_input_ts_type_non_common_tree_pointers(), make_fancy_name(), make_pass_tree_loop_done(), maybe_record_node(), n_occurrences(), native_interpret_expr(), native_interpret_real(), object_address_invariant_in_loop_p(), objects_must_conflict_p(), omp_copy_decl_2(), operand_equal_for_comparison_p(), optimize_bit_field_compare(), optimize_compound_literals_in_ctor(), optimize_omp_library_calls(), output_addressed_constants(), output_constant(), output_constant_pool(), prune_expr_location(), ptr_deref_may_alias_decl_p(), range_includes_zero_p(), relayout_decl(), release_mem_refs(), reverse_op(), same_type_for_tbaa(), save_expr(), scev_direction(), scev_initialize(), shortcut_cond_expr(), split_address_cost(), split_constant_offset(), ssa_prop_fini(), staticp(), sub_costs(), TB_current_chain_node(), tree_int_cst_sgn(), tree_invariant_p(), tree_ssa_strip_useless_type_conversions(), tree_to_aff_combination(), type_contains_placeholder_1(), unmodified_parm_or_parm_agg_item(), unshare_expr_without_location(), valid_value_p(), value_range_constant_singleton(), verify_phi_args(), vn_reference_maybe_forwprop_address(), vn_reference_op_compute_hash(), and walk_stmt_load_store_addr_ops().

#define TREE_OPERAND_CHECK	(	T,
		I
	)	((T)->exp.operands[I])

#define TREE_OPERAND_CHECK_CODE	(	T,
		CODE,
		I
	)	((T)->exp.operands[I])

#define TREE_OPERAND_LENGTH ( NODE ) tree_operand_length (NODE)

In ordinary expression nodes.

Referenced by contains_placeholder_p(), tree_upper_hasher::equal(), get_initial_def_for_reduction(), get_rank(), lto_input_ts_type_non_common_tree_pointers(), TB_current_chain_node(), and virtual_operand_p().

#define TREE_OPTIMIZATION ( NODE ) (&OPTIMIZATION_NODE_CHECK (NODE)->optimization.opts)

Referenced by blocks_nreverse_all(), and operand_equal_for_phi_arg_p().

#define TREE_OPTIMIZATION_BASE_OPTABS ( NODE ) (OPTIMIZATION_NODE_CHECK (NODE)->optimization.base_optabs)

#define TREE_OPTIMIZATION_OPTABS ( NODE ) (OPTIMIZATION_NODE_CHECK (NODE)->optimization.optabs)

Referenced by blocks_nreverse_all().

#define TREE_OVERFLOW ( NODE ) (CST_CHECK (NODE)->base.public_flag)

In an INTEGER_CST, REAL_CST, COMPLEX_CST, or VECTOR_CST, this means there was an overflow in folding.

Referenced by array_ref_up_bound(), double_int_to_tree(), fold_builtin_cbrt(), fold_builtin_strncat_chk(), fold_builtin_strncpy(), fold_convert_const_int_from_fixed(), hash_scc(), lto_write_tree(), make_overflow_infinity(), native_interpret_vector(), needs_overflow_infinity(), negative_overflow_infinity(), positive_overflow_infinity(), and tree_unary_nonnegative_warnv_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.

#define tree_priority_map_eq tree_map_base_eq

#define tree_priority_map_hash tree_map_base_hash

#define tree_priority_map_marked_p tree_map_base_marked_p

#define TREE_PRIVATE ( NODE ) ((NODE)->base.private_flag)

Used in classes in C++.

#define TREE_PROTECTED ( NODE ) ((NODE)->base.protected_flag)

Used in classes in C++.

#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 align_variable(), attribute_value_equal(), default_elf_select_section(), default_stack_protect_guard(), dw2_output_call_site_table(), gen_array_type_die(), lhd_omp_predetermined_sharing(), make_decl_rtl_for_debug(), maybe_catch_exception(), output_constructor_bitfield(), pack_ts_base_value_fields(), process_common_attributes(), process_function_and_variable_attributes(), and wrapup_global_declarations().

#define TREE_PURPOSE ( NODE ) (TREE_LIST_CHECK (NODE)->list.purpose)

In a TREE_LIST node.

Referenced by add_bit_offset_attribute(), build_fn_decl(), build_vector_from_val(), chain_member(), create_outofssa_var_map(), decl_debug_expr_insert(), fold_stmt_1(), lto_input_ts_type_common_tree_pointers(), tree_conflicts_with_clobbers_p(), and type_contains_placeholder_1().

#define TREE_RANGE_CHECK	(	T,
		CODE1,
		CODE2
	)	(T)

#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 add_abstract_origin_attribute(), create_tmp_var_name(), delete_unreachable_blocks_update_callgraph(), expand_builtin_va_copy(), get_unwidened(), ipa_discover_readonly_nonaddressable_vars(), pack_ts_base_value_fields(), refs_independent_p(), and varpool_remove_initializer().

#define TREE_REAL_CST ( NODE ) (*TREE_REAL_CST_PTR (NODE))

Referenced by associate_equivalences_with_edges(), build_complex_cproj(), decode_addr_const(), estimate_move_cost(), expand_complex_libcall(), fixed_zerop(), fold_builtin_ceil(), fold_builtin_isascii(), fold_builtin_strncat_chk(), initializer_constant_valid_p_1(), pack_ts_int_cst_value_fields(), set_value_varying(), and tree_unary_nonnegative_warnv_p().

#define TREE_REAL_CST_PTR ( NODE ) (REAL_CST_CHECK (NODE)->real_cst.real_cst_ptr)

Referenced by default_assemble_integer(), fold_builtin_snprintf_chk(), fold_builtin_sprintf_chk_1(), and fold_builtin_strncpy().

#define TREE_REALPART ( NODE ) (COMPLEX_CST_CHECK (NODE)->complex.real)

In a COMPLEX_CST node.

Referenced by decode_addr_const(), default_assemble_integer(), fixed_zerop(), fold_builtin_snprintf_chk(), fold_negate_expr(), init_block_clear_fn(), and initializer_constant_valid_p_1().

#define TREE_SET_BLOCK	(	T,
		B
	)	(tree_set_block ((T), (B)))

Referenced by lto_input_ts_type_non_common_tree_pointers().

#define TREE_SET_CODE	(	NODE,
		VALUE
	)	((NODE)->base.code = (VALUE))

Referenced by alloc_stmt_list(), and release_ssa_name().

#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 expand_builtin_memset_args(), expand_expr_real_1(), fold_builtin_sprintf_chk_1(), fold_builtin_strcspn(), fold_call_expr(), get_pointer_alignment(), gimplify_modify_expr_to_memset(), insert_init_debug_bind(), maybe_emit_sprintf_chk_warning(), pack_ts_base_value_fields(), prune_expr_location(), unmark_visited_r(), and unvisit_body().

#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 array_ref_element_size(), canonicalize_component_ref(), contains_placeholder_p(), count_type_elements(), coverage_obj_init(), create_tmp_var_name(), default_stack_protect_guard(), expand_builtin_va_copy(), gimple_redirect_edge_and_branch(), initialize_argument_information(), maybe_lookup_decl(), new_die(), tree_nrv(), and vect_load_lanes_supported().

#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 add_data_member_location_attribute(), constant_pointer_difference(), convert_debug_memory_address(), decode_addr_const(), default_assemble_integer(), expand_expr_real_1(), initializer_constant_valid_p_1(), maybe_emit_chk_warning(), and streamer_write_string_cst().

#define TREE_STRING_POINTER ( NODE ) ((const char *)(STRING_CST_CHECK (NODE)->string.str))

Referenced by add_data_member_location_attribute(), convert_debug_memory_address(), create_block_symbol(), create_outofssa_var_map(), decode_addr_const(), default_assemble_integer(), expand_expr_real_1(), fold_stmt_1(), initializer_constant_valid_p_1(), maybe_emit_chk_warning(), n_occurrences(), streamer_write_string_cst(), and tree_conflicts_with_clobbers_p().

#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 wrapup_global_declarations().

#define TREE_TARGET_OPTION ( NODE ) (&TARGET_OPTION_NODE_CHECK (NODE)->target_option.opts)

Referenced by unpack_ts_block_value_fields().

#define TREE_THIS_NOTRAP ( NODE )

Value:

(TREE_CHECK5 (NODE, INDIRECT_REF, MEM_REF, TARGET_MEM_REF, ARRAY_REF, \

ARRAY_RANGE_REF)->base.nothrow_flag)

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 gimplify_return_expr().

#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_abstract_origin_attribute(), build_stack_save_restore(), component_of(), default_stack_protect_guard(), expand_call(), function_always_visible_to_compiler_p(), gate_intra_sra(), get_expr_operands(), get_unwidened(), mark_address_taken(), non_rewritable_mem_ref_base(), pop_access_from_work_queue(), refs_independent_p(), and tree_nrv().

#define TREE_TYPE ( NODE ) ((NODE)->typed.type)

Referenced by add_abstract_origin_attribute(), add_bit_offset_attribute(), add_bound_info(), add_data_member_location_attribute(), add_equivalence(), add_gnat_descriptive_type_attribute(), add_linkage_name(), addr_expr_of_non_mem_decl_p(), addr_expr_of_non_mem_decl_p_1(), adjust_ptr_info_misalignment(), adjust_related_strinfos(), aff_combination_add_product(), aff_combination_remove_elt(), agg_jmp_p_vec_for_t_vec(), align_variable(), alloc_cand_and_find_basis(), alloc_iv(), analyze_caller_dereference_legality(), asan_decl_phase_3(), asan_mem_ref_new(), assign_parm_adjust_stack_rtl(), assign_parm_remove_parallels(), assign_parms(), assign_parms_unsplit_complex(), associate_equivalences_with_edges(), avoid_complex_debug_insns(), backtrace_base_for_ref(), build2_stat(), build_access_from_expr_1(), build_complex_cproj(), build_constructor(), build_fold_addr_expr_loc(), build_function_decl_skip_args(), build_function_type_array_1(), build_function_type_list_1(), build_minus_one_cst(), build_one_array(), build_one_cst(), build_opaque_vector_type(), build_qualified_type(), build_sender_ref(), build_stack_save_restore(), build_string(), build_tree_list_vec_stat(), build_type_attribute_qual_variant(), build_varargs_function_type_array(), build_vector_type_for_mode(), call_expr_flags(), can_propagate_from(), can_unroll_loop_p(), case_bit_test_cmp(), ceil_sdiv_adjust(), check_array_ref(), check_bool_pattern(), chrec_evaluate(), compare_range_with_value(), compcode_to_comparison(), component_of(), component_uses_parent_alias_set_from(), compute_antic(), compute_argument_block_size(), compute_object_offset(), constant_pointer_difference(), convert_plusminus_to_widen(), convert_to_integer(), convert_to_pointer(), convert_to_real(), copy_debug_stmts(), copy_tree_body_r(), count_type_elements(), coverage_end_function(), coverage_obj_init(), cprop_into_successor_phis(), create_function_info_for(), create_iv(), create_mem_ref(), create_mul_ssa_cand(), create_one_component_var(), create_phi_for_local_result(), create_vector_array(), decl_debug_expr_insert(), decode_addr_const(), decode_field_reference(), default_member_type_forces_blk(), descr_info_loc(), dest_safe_for_nrv_p(), destroy_predicate_vecs(), determine_base_object(), determine_use_iv_cost_address(), double_int_to_tree(), dr_analyze_indices(), dump_possible_polymorphic_call_targets(), dump_type_inheritance_graph(), duplicate_ssa_name_fn(), duplicate_ssa_name_ptr_info(), elim_forward(), elim_unvisited_predecessor(), emit_library_call_value_1(), estimated_loop_iterations(), evaluate_stmt(), expand_builtin_atomic_exchange(), expand_builtin_expect(), expand_builtin_memset_args(), expand_builtin_prefetch(), expand_builtin_sincos(), expand_builtin_va_copy(), expand_builtin_va_start(), expand_complex_conjugate(), expand_debug_parm_decl(), expand_expr_real_1(), expand_omp_atomic_load(), expand_omp_for_init_vars(), expand_omp_sections(), expand_value_return(), expr_has_constants(), extract_int(), finalize_task_copyfn(), find_loop_location(), find_use_stmt(), finish_bitfield_layout(), finish_builtin_struct(), fixed_zerop(), fold_build1_initializer_loc(), fold_build2_stat_loc(), fold_builtin_4(), fold_builtin_cbrt(), fold_builtin_classify(), fold_builtin_exponent(), fold_builtin_fputs(), fold_builtin_n(), fold_builtin_snprintf_chk(), fold_builtin_sprintf_chk_1(), fold_builtin_strncpy(), fold_builtin_strspn(), fold_builtin_tan(), fold_convert_const_fixed_from_real(), fold_fma(), fold_mathfn_compare(), forward_propagate_addr_expr(), forward_propagate_into_comparison_1(), gate_intra_sra(), gather_stats_on_scev_database_1(), gbb_loop_at_index(), gen_conditions_for_pow_cst_base(), gen_lexical_block_die(), generate_subtree_copies(), get_addr_base_and_unit_offset_1(), get_ancestor_addr_info(), get_attrs_for(), get_frame_arg(), get_frame_field(), get_initial_def_for_reduction(), get_integer_term(), get_name_for_bit_test(), get_object_alignment(), get_or_alloc_expr_for(), get_or_create_ssa_default_def(), get_ref_base_and_extent(), get_tm_region_blocks(), get_value(), gimple_asm_clobbers_memory_p(), gimple_call_fnspec(), gimple_call_reset_alias_info(), gimple_get_virt_method_for_binfo(), gimplify_init_ctor_eval(), gimplify_init_ctor_preeval_1(), gimplify_modify_expr_complex_part(), gimplify_modify_expr_to_memset(), gimplify_omp_task(), gimplify_omp_workshare(), gimplify_return_expr(), gimplify_switch_expr(), go_output_typedef(), hash_scc(), ifcombine_ifandif(), infer_value_range(), init_range_entry(), initialize_argument_information(), initializer_constant_valid_p_1(), inline_forbidden_p_stmt(), insert_float(), insert_gimplified_predicates(), insert_rtx_to_part_on_edge(), instantiate_decls(), instantiate_scev_3(), instantiate_scev_not(), instrument_builtin_call(), instrument_derefs(), internal_arg_pointer_based_exp(), ipa_load_from_parm_agg(), ipa_modify_call_arguments(), ipa_prop_write_all_agg_replacement(), ipa_unregister_cgraph_hooks(), is_gimple_reg_rhs(), is_gimple_val(), is_overflow_infinity(), is_positive_overflow_infinity(), last_stmt(), load_from_unmodified_param(), loc_descriptor_from_tree(), lookup_decl(), lookup_field_for_decl(), lookup_tmp_var(), lookup_tramp_for_decl(), lower_gimple_return(), lower_send_clauses(), make_blocks(), make_fancy_name(), make_or_reuse_fract_type(), make_overflow_infinity(), mark_constant_pool(), max_stmt_executions(), max_stmt_executions_tree(), maybe_canonicalize_argtypes(), maybe_dump_rtl_for_gimple_stmt(), maybe_emit_sprintf_chk_warning(), maybe_with_size_expr(), merge_comps(), merge_ranges(), mode_for_array(), move_variant_to_index(), ncd_for_two_cands(), negative_overflow_infinity(), nesting_copy_decl(), new_alias_set(), non_rewritable_mem_ref_base(), normalize_offset(), objects_must_conflict_p(), operand_equal_for_value_replacement(), outermost_invariant_loop_for_expr(), output_constant(), pop_access_from_work_queue(), positive_overflow_infinity(), process_assert_insertions(), promote_function_mode(), promote_mode(), propagate_with_phi(), prune_expr_location(), pt_solutions_intersect_1(), range_fits_type_p(), read_replacements_section(), recognize_single_bit_test(), refs_independent_p(), register_edge_assert_for_1(), remap_decl(), remap_gimple_op_r(), remap_ssa_name(), remap_vla_decls(), replace_ref(), resolve_operand_name_1(), reverse_op(), rewrite_use_nonlinear_expr(), rhs_to_tree(), same_bool_result_p(), same_type_for_tbaa(), scev_finalize(), scev_reset(), separate_decls_in_region_name(), set_ptr_info_alignment(), set_strinfo(), set_value_varying(), shortcut_cond_expr(), simple_cst_equal(), simplify_bitwise_binary_1(), simplify_bitwise_binary_boolean(), simplify_cond_using_ranges(), simplify_gimple_switch_label_vec(), simplify_rotate(), simplify_using_outer_evolutions(), single_element_loc_list_p(), single_incoming_edge_ignoring_loop_edges(), skip_simple_arithmetic(), split_constant_offset(), stmt_overflow_infinity(), streamer_write_chain(), swap_tree_comparison(), thunk_adjust(), tm_log_init(), tm_mangle(), translate_vuse_through_block(), tree_int_cst_sgn(), tree_nrv(), tree_predict_by_opcode(), tree_ssa_strip_useless_type_conversions(), tree_to_aff_combination(), tree_unroll_loop(), try_move_mult_to_index(), type_contains_placeholder_1(), type_for_widest_vector_mode(), type_hash_list(), type_like_member_ptr_p(), unmark_visited_r(), unvisit_body(), update_alias_info_with_stack_vars(), update_complex_components_on_edge(), use_register_for_decl(), value_inside_range(), value_range_constant_singleton(), varpool_finalize_decl(), vec_cst_ctor_to_array(), vect_can_advance_ivs_p(), vect_create_cond_for_alias_checks(), vect_create_vectorized_demotion_stmts(), vect_do_peeling_for_loop_bound(), vect_find_same_alignment_drs(), vect_get_vec_def_for_operand(), vect_init_vector_1(), vect_permute_load_chain(), vect_permute_store_chain(), vect_recog_pow_pattern(), vect_slp_analyze_bb(), vn_nary_op_insert_into(), vrp_meet_1(), vrp_stmt_computes_nonzero(), vrp_val_max(), vrp_val_min(), walk_all_functions(), walk_gimple_asm(), and walk_polymorphic_call_targets().

#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 attribute_value_equal(), canonicalize_component_ref(), compute_argument_addresses(), create_tmp_var_name(), default_stack_protect_guard(), and mark_all_vars_used().

#define TREE_VALUE ( NODE ) (TREE_LIST_CHECK (NODE)->list.value)

#define TREE_VEC_ELT	(	NODE,
		I
	)	TREE_VEC_ELT_CHECK (NODE, I)

#define TREE_VEC_ELT_CHECK	(	T,
		I
	)	((T)->vec.a[I])

#define TREE_VEC_END ( NODE ) ((void) TREE_VEC_CHECK (NODE), &((NODE)->vec.a[(NODE)->vec.base.u.length]))

#define TREE_VEC_LENGTH ( NODE ) (TREE_VEC_CHECK (NODE)->base.u.length)

In a TREE_VEC node.

#define tree_vec_map_eq tree_map_base_eq

Referenced by check_aligned_type().

#define tree_vec_map_hash tree_decl_map_hash

Referenced by check_aligned_type().

#define tree_vec_map_marked_p tree_map_base_marked_p

#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().

#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().

#define TYPE_ADDR_SPACE ( NODE ) (TYPE_CHECK (NODE)->base.u.bits.address_space)

The address space the type is in.

Referenced by addr_expr_of_non_mem_decl_p_1(), convert_to_pointer(), fold_convert_const_fixed_from_real(), initializer_constant_valid_p_1(), lookup_ident_attribute(), promote_function_mode(), and valid_mem_ref_p().

#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.

#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.

#define TYPE_ALIGN ( NODE ) (TYPE_CHECK (NODE)->type_common.align)

The alignment necessary for objects of this type. The value is an int, measured in bits.

Referenced by allocate_struct_function(), build_qualified_type(), compute_record_mode(), debug_rli(), default_store_bounds_for_arg(), elim_forward(), finish_bitfield_layout(), get_mode_alignment(), gimplify_init_ctor_eval(), initialize_argument_information(), lookup_field_for_decl(), lookup_tramp_for_decl(), rli_size_unit_so_far(), and vect_do_peeling_for_loop_bound().

#define TYPE_ALIGN_OK ( NODE ) (TYPE_CHECK (NODE)->base.nothrow_flag)

In a type, nonzero means that all objects of the type are guaranteed by the language or front-end to be properly aligned, so we can indicate that a MEM of this type is aligned at least to the alignment of the type, even if it doesn't appear that it is. We see this, for example, in object-oriented languages where a tag field may show this is an object of a more-aligned variant of the more generic type.

In an SSA_NAME node, nonzero if the SSA_NAME node is on the SSA_NAME freelist.

#define TYPE_ALIGN_UNIT ( NODE ) (TYPE_ALIGN (NODE) / BITS_PER_UNIT)

The alignment for NODE, in bytes.

Referenced by create_component_ref_by_pieces_1(), default_cxx_guard_type(), and vect_permute_store_chain().

#define TYPE_ARG_TYPES ( NODE ) (FUNC_OR_METHOD_CHECK (NODE)->type_non_common.values)

Referenced by add_linkage_name(), decl_value_expr_lookup(), dump_function_name(), dump_type_inheritance_graph(), gimple_asm_clobbers_memory_p(), instrument_builtin_call(), ipa_get_vector_of_formal_parms(), ipa_register_cgraph_hooks(), ipa_unregister_cgraph_hooks(), lto_input_ts_function_decl_tree_pointers(), reverse_op(), and write_ts_field_decl_tree_pointers().

#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 nreverse().

#define TYPE_ARTIFICIAL ( NODE ) (TYPE_CHECK (NODE)->base.nowarning_flag)

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

#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 build_decl_attribute_variant(), build_qualified_type(), build_simple_mem_ref_loc(), get_attrs_for(), simple_cst_equal(), stmt_overflow_infinity(), and write_ts_decl_with_vis_tree_pointers().

#define TYPE_BINFO ( NODE ) (RECORD_OR_UNION_CHECK (NODE)->type_non_common.binfo)

For record and union types, information about this type, as a base type for itself.

Referenced by hash_type_name(), ipa_set_jf_arith_pass_through(), lto_input_ts_function_decl_tree_pointers(), and new_alias_set().

#define TYPE_CACHED_VALUES ( NODE ) (TYPE_CHECK (NODE)->type_non_common.values)

Referenced by cache_integer_cst().

#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().

#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(), iterative_hash_exprs_commutative(), lto_read_body(), and simple_cst_equal().

#define TYPE_CHECK ( T ) TREE_CLASS_CHECK (T, tcc_type)

#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.

#define TYPE_CONTEXT ( NODE ) (TYPE_CHECK (NODE)->type_common.context)

Referenced by write_ts_decl_with_vis_tree_pointers().

#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.

#define TYPE_DOMAIN ( NODE ) (ARRAY_TYPE_CHECK (NODE)->type_non_common.values)

Referenced by add_data_member_location_attribute(), extract_int(), gimple_get_virt_method_for_binfo(), gimplify_modify_expr_to_memset(), lto_input_ts_function_decl_tree_pointers(), validate_call(), and write_ts_field_decl_tree_pointers().

#define TYPE_FBIT ( NODE ) (GET_MODE_FBIT (TYPE_MODE (NODE)))

#define TYPE_FIELDS ( NODE ) (RECORD_OR_UNION_CHECK (NODE)->type_non_common.values)

Referenced by asan_decl_phase_3(), build_sender_ref(), finalize_task_copyfn(), insert_int(), lto_input_ts_function_decl_tree_pointers(), new_alias_set(), new_omp_context(), pop_access_from_work_queue(), really_constant_p(), record_common_node(), and write_ts_field_decl_tree_pointers().

#define TYPE_FILE_SCOPE_P ( EXP ) SCOPE_FILE_SCOPE_P (TYPE_CONTEXT (EXP))

Nonzero for a type which is at file scope.

#define TYPE_FINAL_P ( NODE ) (RECORD_OR_UNION_CHECK (NODE)->base.default_def_flag)

Nonzero if RECORD_TYPE represents a final derivation of class.

#define TYPE_HASH ( TYPE ) (TYPE_UID (TYPE))

Here is how primitive or already-canonicalized types' hash codes are made.

#define TYPE_IBIT ( NODE ) (GET_MODE_IBIT (TYPE_MODE (NODE)))

#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.

#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_SLOT_1 ( NODE ) (NOT_RECORD_OR_UNION_CHECK (NODE)->type_non_common.binfo)

For non record and union types, used in a language-dependent way.

#define TYPE_LANG_SPECIFIC ( NODE ) (TYPE_CHECK (NODE)->type_with_lang_specific.lang_specific)

#define TYPE_MAIN_VARIANT ( NODE ) (TYPE_CHECK (NODE)->type_common.main_variant)

Referenced by build_debug_ref_for_model(), expand_omp_atomic_load(), fold_builtin_sprintf_chk_1(), gen_inlined_subroutine_die(), get_ubsan_type_info_for_type(), gimple_asm_clobbers_memory_p(), gimplify_switch_expr(), lhd_decl_printable_name(), lookup_tmp_var(), lto_read_body(), native_interpret_real(), and write_ts_decl_with_vis_tree_pointers().

#define TYPE_MAX_VALUE ( NODE ) (NUMERICAL_TYPE_CHECK (NODE)->type_non_common.maxval)

Referenced by build_function_type_list_1(), build_method_type_directly(), check_array_ref(), commutative_ternary_tree_code(), extract_int(), finish_builtin_struct(), needs_to_live_in_memory(), number_of_iterations_lt_to_ne(), preprocess_case_label_vec_for_gimple(), validate_call(), and vrp_meet_1().

#define TYPE_MAXVAL ( NODE ) (TYPE_CHECK (NODE)->type_non_common.maxval)

Referenced by lto_input_ts_function_decl_tree_pointers().

#define TYPE_METHOD_BASETYPE ( NODE ) (FUNC_OR_METHOD_CHECK (NODE)->type_non_common.maxval)

Referenced by gimple_asm_clobbers_memory_p().

#define TYPE_METHODS ( NODE ) (RECORD_OR_UNION_CHECK (NODE)->type_non_common.maxval)

#define TYPE_MIN_VALUE ( NODE ) (NUMERICAL_TYPE_CHECK (NODE)->type_non_common.minval)

Referenced by add_data_member_location_attribute(), build_function_type_list_1(), build_method_type_directly(), check_array_ref(), commutative_ternary_tree_code(), finish_builtin_struct(), gimple_get_virt_method_for_binfo(), needs_to_live_in_memory(), validate_call(), and vrp_meet_1().

#define TYPE_MINVAL ( NODE ) (TYPE_CHECK (NODE)->type_non_common.minval)

Referenced by lto_input_ts_function_decl_tree_pointers().

#define TYPE_MODE ( NODE )

Value:

(VECTOR_TYPE_P (TYPE_CHECK (NODE)) \

? vector_type_mode (NODE) : (NODE)->type_common.mode)

Referenced by add_data_member_location_attribute(), add_gnat_descriptive_type_attribute(), add_rshift(), alloc_cand_and_find_basis(), assign_parm_adjust_stack_rtl(), assign_parms(), associate_equivalences_with_edges(), avoid_complex_debug_insns(), build_complex_cproj(), build_function_type_array_1(), build_one_array(), build_one_cst(), build_qualified_type(), build_string(), ceil_sdiv_adjust(), check_bool_pattern(), compute_argument_block_size(), compute_reloc_for_constant(), constant_pointer_difference(), convert_to_real(), decode_addr_const(), expand_builtin_memset_args(), expand_builtin_sincos(), expand_builtin_va_start(), expand_debug_parm_decl(), expand_expr_real_1(), expand_omp_atomic_load(), finish_bitfield_layout(), fixed_zerop(), fold_builtin_cbrt(), fold_builtin_ceil(), fold_builtin_constant_p(), fold_builtin_sincos(), fold_builtin_snprintf_chk(), fold_builtin_sprintf_chk_1(), fold_builtin_strcpy(), fold_builtin_strncat_chk(), fold_builtin_strncpy(), fold_comparison(), fold_convert_const_int_from_fixed(), fold_mathfn_compare(), forward_propagate_addr_expr(), get_initial_def_for_reduction(), get_ref_base_and_extent(), gimple_call_fnspec(), initialize_argument_information(), initializer_constant_valid_p_1(), inline_forbidden_p_stmt(), integer_valued_real_p(), loc_descriptor_from_tree(), make_or_reuse_fract_type(), maybe_canonicalize_argtypes(), native_interpret_complex(), operand_equal_for_value_replacement(), reverse_op(), rewrite_use_nonlinear_expr(), set_value_varying(), simple_cst_equal(), simplify_rotate(), sjlj_assign_call_site_values(), supportable_widening_operation(), swap_tree_comparison(), try_move_mult_to_index(), valid_mem_ref_p(), vect_build_slp_tree_1(), vect_compute_data_ref_alignment(), vect_permute_load_chain(), and vect_recog_rotate_pattern().

#define TYPE_NAME ( NODE ) (TYPE_CHECK (NODE)->type_common.name)

Referenced by build_qualified_type(), finalize_task_copyfn(), get_AT_hi_pc(), ubsan_type_descriptor(), and write_ts_decl_with_vis_tree_pointers().

#define TYPE_NAMELESS ( NODE ) (TYPE_CHECK (NODE)->base.u.bits.nameless_flag)

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

#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.

#define TYPE_NEXT_PTR_TO ( NODE ) (POINTER_TYPE_CHECK (NODE)->type_non_common.minval)

Referenced by simple_cst_equal().

#define TYPE_NEXT_REF_TO ( NODE ) (REFERENCE_TYPE_CHECK (NODE)->type_non_common.minval)

#define TYPE_NEXT_VARIANT ( NODE ) (TYPE_CHECK (NODE)->type_common.next_variant)

Referenced by lto_read_body().

#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.

#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 all_zeros_p(), and objects_must_conflict_p().

#define TYPE_OFFSET_BASETYPE ( NODE ) (OFFSET_TYPE_CHECK (NODE)->type_non_common.maxval)

#define TYPE_OVERFLOW_TRAPS ( TYPE ) (!TYPE_UNSIGNED (TYPE) && flag_trapv)

True if overflow for the given integral type should issue a trap.

Referenced by init_scc_vn().

#define TYPE_OVERFLOW_UNDEFINED ( TYPE ) (!TYPE_UNSIGNED (TYPE) && !flag_wrapv && !flag_trapv && flag_strict_overflow)

True if overflow is undefined for the given integral 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 add_equivalence(), estimated_stmt_executions_int(), and extract_muldiv().

#define TYPE_OVERFLOW_WRAPS ( TYPE ) (TYPE_UNSIGNED (TYPE) || flag_wrapv)

True if overflow wraps around for the given integral type. That is, TYPE_MAX + 1 == TYPE_MIN.

Referenced by vrp_val_is_max().

#define TYPE_P ( NODE ) (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_type)

Nonzero if NODE represents a type.

Referenced by copy_ssa_name(), debug_tree(), dw2_output_call_site_table(), first_non_label_stmt(), gen_array_type_die(), gen_inlined_subroutine_die(), get_attrs_for(), instantiate_decls(), lower_omp_target(), and remove_exit_barrier().

#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.

#define TYPE_POINTER_TO ( NODE ) (TYPE_CHECK (NODE)->type_common.pointer_to)

Referenced by simple_cst_equal().

#define TYPE_PRECISION ( NODE ) (TYPE_CHECK (NODE)->type_common.precision)

Referenced by aff_combination_add(), bit_value_binop_1(), bit_value_unop_1(), build_function_decl_skip_args(), build_method_type_directly(), build_vector_type_for_mode(), case_values_threshold(), check_bool_pattern(), common_affine_function(), convert_plusminus_to_widen(), convert_to_integer(), convert_to_pointer(), convert_to_real(), decode_addr_const(), double_int_to_tree(), finish_bitfield_layout(), finish_builtin_struct(), fold_build2_stat_loc(), fold_builtin_cbrt(), fold_mathfn_compare(), forward_propagate_addr_expr(), gate_cse_sincos(), gen_conditions_for_pow_cst_base(), get_name_for_bit_test(), gimple_ior_addresses_taken_1(), infer_value_range(), int_const_binop_1(), make_unsigned_type(), maybe_dump_rtl_for_gimple_stmt(), native_interpret_complex(), native_interpret_expr(), number_of_iterations_ne_max(), quad_int_pair_sort(), recognize_single_bit_test(), reconstruct_complex_type(), simplify_bitwise_binary_1(), simplify_gimple_switch_label_vec(), simplify_rotate(), tree_unroll_loop(), try_move_mult_to_index(), value_inside_range(), and vn_reference_compute_hash().

#define TYPE_QUALS ( NODE )

Value:

((int) ((TYPE_READONLY (NODE) * TYPE_QUAL_CONST)              \
          | (TYPE_VOLATILE (NODE) * TYPE_QUAL_VOLATILE)         \
          | (TYPE_RESTRICT (NODE) * TYPE_QUAL_RESTRICT)         \
          | (ENCODE_QUAL_ADDR_SPACE (TYPE_ADDR_SPACE (NODE)))))

The set of type qualifiers for this type.

Referenced by expand_value_return(), gimplify_switch_expr(), and native_interpret_real().

#define TYPE_QUALS_NO_ADDR_SPACE ( 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 qualifications.

#define TYPE_READONLY ( NODE ) (TYPE_CHECK (NODE)->base.readonly_flag)

Means this type is const-qualified.

Referenced by lookup_ident_attribute().

#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 component_uses_parent_alias_set_from(), make_or_reuse_fract_type(), and simple_cst_equal().

#define TYPE_REF_IS_RVALUE ( NODE ) (REFERENCE_TYPE_CHECK (NODE)->base.private_flag)

True if reference type NODE is a C++ rvalue reference.

#define TYPE_REFERENCE_TO ( NODE ) (TYPE_CHECK (NODE)->type_common.reference_to)

#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 create_function_info_for(), and lookup_ident_attribute().

#define TYPE_SATURATING ( NODE ) (TYPE_CHECK (NODE)->base.u.bits.saturating_flag)

In fixed-point types, means a saturating type.

Referenced by finish_bitfield_layout(), fold_convert_const_int_from_fixed(), optab_for_tree_code(), and tree_unary_nonnegative_warnv_p().

#define TYPE_SIZE ( NODE ) (TYPE_CHECK (NODE)->type_common.size)

Referenced by all_zeros_p(), analyze_caller_dereference_legality(), build_offset_type(), compute_record_mode(), coverage_end_function(), finish_bitfield_layout(), finish_builtin_struct(), fold_convert_const_fixed_from_int(), get_ref_base_and_extent(), gimple_get_virt_method_for_binfo(), outermost_invariant_loop_for_expr(), output_constant(), read_replacements_section(), skip_simple_arithmetic(), type_like_member_ptr_p(), vn_reference_compute_hash(), and write_ts_decl_with_vis_tree_pointers().

#define TYPE_SIZE_UNIT ( NODE ) (TYPE_CHECK (NODE)->type_common.size_unit)

Referenced by assemble_thunks_and_aliases(), build_offset_type(), compute_object_offset(), compute_record_mode(), coverage_end_function(), finish_bitfield_layout(), get_addr_base_and_unit_offset_1(), gimple_val_nonnegative_real_p(), initialize_argument_information(), skip_simple_arithmetic(), vect_do_peeling_for_loop_bound(), vect_find_same_alignment_drs(), and write_ts_decl_with_vis_tree_pointers().

#define TYPE_SIZES_GIMPLIFIED ( NODE ) (TYPE_CHECK (NODE)->base.constant_flag)

Nonzero if NODE, a type, has had its sizes gimplified.

#define TYPE_STRING_FLAG ( NODE ) (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 add_gnat_descriptive_type_attribute().

#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(), and simple_cst_equal().

#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 add_bit_offset_attribute(), gen_lexical_block_die(), and write_ts_decl_with_vis_tree_pointers().

#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.c to hold the type's number in the generated stabs.

#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.c to point to the DIE generated for the type.

Referenced by get_AT_unsigned().

#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.

#define TYPE_SYMTAB_IS_DIE (2)

#define TYPE_SYMTAB_IS_POINTER (1)

#define TYPE_SYMTAB_POINTER ( NODE ) (TYPE_CHECK (NODE)->type_common.symtab.pointer)

Symtab field as a string. Used by COFF generator in sdbout.c to hold struct/union type tag names.

#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 initialize_argument_information(), and instantiate_decls().

#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.

#define TYPE_UNSIGNED ( NODE ) (TYPE_CHECK (NODE)->base.u.bits.unsigned_flag)

In integral and pointer types, means an unsigned type.

Referenced by add_bit_offset_attribute(), aff_combination_constant_multiple_p(), assign_parm_remove_parallels(), build_function_decl_skip_args(), build_function_type_list_1(), build_int_cst_type(), build_method_type_directly(), ceil_sdiv_adjust(), convert_plusminus_to_widen(), convert_to_integer(), create_iv(), destroy_predicate_vecs(), dump_case_nodes(), elim_unvisited_predecessor(), estimated_loop_iterations(), expand_debug_parm_decl(), expand_omp_for_init_vars(), finish_bitfield_layout(), finish_builtin_struct(), gimple_ior_addresses_taken_1(), infer_value_range(), init_range_entry(), initialize_argument_information(), insert_rtx_to_part_on_edge(), make_unsigned_type(), merge_ranges(), nb_vars_in_chrec(), promote_mode(), quad_int_pair_sort(), reconstruct_complex_type(), resolve_operand_name_1(), sign_bit_p(), simplify_bitwise_binary_1(), simplify_gimple_switch_label_vec(), tree_int_cst_sgn(), tree_unary_nonnegative_warnv_p(), and type_hash_list().

#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 compute_record_mode(), finish_bitfield_layout(), and rli_size_unit_so_far().

#define TYPE_VALUES ( NODE ) (ENUMERAL_TYPE_CHECK (NODE)->type_non_common.values)

Referenced by add_bit_offset_attribute(), lto_input_ts_function_decl_tree_pointers(), and write_ts_field_decl_tree_pointers().

#define TYPE_VALUES_RAW ( NODE ) (TYPE_CHECK (NODE)->type_non_common.values)

#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.

#define TYPE_VECTOR_SUBPARTS ( VECTOR_TYPE )

Value:

(((unsigned HOST_WIDE_INT) 1) \

<< VECTOR_TYPE_CHECK (VECTOR_TYPE)->type_common.precision)

For a VECTOR_TYPE, this is the number of sub-parts of the vector.

Referenced by build_qualified_type(), cst_and_fits_in_hwi(), expand_vector_comparison(), finish_bitfield_layout(), gimple_get_virt_method_for_binfo(), type_for_widest_vector_mode(), vect_build_slp_tree_1(), vect_do_peeling_for_loop_bound(), and vect_get_store_cost().

#define TYPE_VFIELD ( NODE ) (RECORD_OR_UNION_CHECK (NODE)->type_non_common.minval)

#define TYPE_VOLATILE ( NODE ) (TYPE_CHECK (NODE)->base.volatile_flag)

Nonzero in a type considered volatile as a whole.

Referenced by gate_intra_sra(), and lookup_ident_attribute().

#define uda_type_node global_trees[TI_UDA_TYPE]

#define udq_type_node global_trees[TI_UDQ_TYPE]

#define uha_type_node global_trees[TI_UHA_TYPE]

#define uhq_type_node global_trees[TI_UHQ_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 UNARY_CLASS_P ( NODE ) (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_unary)

Nonzero if NODE represents a unary arithmetic expression.

Referenced by decl_address_ip_invariant_p().

#define unsigned_accum_type_node global_trees[TI_UACCUM_TYPE]

#define unsigned_char_type_node integer_types[itk_unsigned_char]

Referenced by build_nonshared_array_type().

#define unsigned_fract_type_node global_trees[TI_UFRACT_TYPE]

#define unsigned_intDI_type_node global_trees[TI_UINTDI_TYPE]

#define unsigned_intHI_type_node global_trees[TI_UINTHI_TYPE]

#define unsigned_intQI_type_node global_trees[TI_UINTQI_TYPE]

#define unsigned_intSI_type_node global_trees[TI_UINTSI_TYPE]

#define unsigned_intTI_type_node global_trees[TI_UINTTI_TYPE]

#define unsigned_long_accum_type_node global_trees[TI_ULACCUM_TYPE]

#define unsigned_long_fract_type_node global_trees[TI_ULFRACT_TYPE]

#define unsigned_long_long_accum_type_node global_trees[TI_ULLACCUM_TYPE]

#define unsigned_long_long_fract_type_node global_trees[TI_ULLFRACT_TYPE]

#define unsigned_short_accum_type_node global_trees[TI_USACCUM_TYPE]

#define unsigned_short_fract_type_node global_trees[TI_USFRACT_TYPE]

#define unsigned_type_node integer_types[itk_unsigned_int]

Referenced by adjust_simduid_builtins(), affine_fn_univar(), gimple_init_edge_profiler(), lower_send_clauses(), and ubsan_source_location_type().

#define uqq_type_node global_trees[TI_UQQ_TYPE]

#define usa_type_node global_trees[TI_USA_TYPE]

#define usq_type_node global_trees[TI_USQ_TYPE]

#define uta_type_node global_trees[TI_UTA_TYPE]

#define utq_type_node global_trees[TI_UTQ_TYPE]

#define va_list_fpr_counter_field global_trees[TI_VA_LIST_FPR_COUNTER_FIELD]

#define va_list_gpr_counter_field global_trees[TI_VA_LIST_GPR_COUNTER_FIELD]

#define va_list_type_node global_trees[TI_VA_LIST_TYPE]

Referenced by build_debug_ref_for_model().

#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 rewrite_update_dom_walker::after_dom_children(), and gimple_replace_ssa_lhs().

#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 streamer_write_builtin().

#define VAR_P ( NODE ) (TREE_CODE (NODE) == VAR_DECL)

True if NODE designates a variable declaration.

#define VECTOR_CST_ELT	(	NODE,
		IDX
	)	(VECTOR_CST_CHECK (NODE)->vector.elts[IDX])

Referenced by assemble_integer(), build_case_label(), decode_addr_const(), initializer_constant_valid_p_1(), and tree_log2().

#define VECTOR_CST_ELTS ( NODE ) (VECTOR_CST_CHECK (NODE)->vector.elts)

#define VECTOR_CST_NELTS ( NODE ) (TYPE_VECTOR_SUBPARTS (TREE_TYPE (NODE)))

In a VECTOR_CST node.

Referenced by assemble_integer(), build_case_label(), decode_addr_const(), initializer_constant_valid_p_1(), and tree_log2().

#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.

#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.

#define VECTOR_TYPE_P ( TYPE ) (TREE_CODE (TYPE) == VECTOR_TYPE)

Nonzero if TYPE represents a vector type.

#define VL_EXP_CHECK ( T ) TREE_CLASS_CHECK (T, tcc_vl_exp)

#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.

#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.

#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 build_reference_type_for_mode(), dump_function_name(), ipa_print_all_params(), iterative_hash_exprs_commutative(), and reverse_op().

#define void_type_node global_trees[TI_VOID_TYPE]

Referenced by build_minus_one_cst(), copy_decl_no_change(), default_stack_protect_guard(), expand_omp_sections(), get_frame_arg(), gimple_init_edge_profiler(), ipa_free_all_structures_after_ipa_cp(), mode_for_array(), prune_expr_location(), unmark_visited_r(), unvisit_body(), and upper_bound_in_type().

#define VOID_TYPE_P ( NODE ) (TREE_CODE (NODE) == VOID_TYPE)

Nonzero if this type is the (possibly qualified) void type.

Referenced by decl_value_expr_lookup(), get_or_create_ssa_default_def(), inline_forbidden_p_stmt(), instantiate_decls(), and unmark_visited_r().

#define walk_tree	(	a,
		b,
		c,
		d
	)	walk_tree_1 (a, b, c, d, NULL)

Referenced by copy_if_shared(), finalize_task_copyfn(), get_shiftadd_cost(), gimplify_init_ctor_eval(), mostly_copy_tree_r(), remap_decl(), store_child_info(), and walk_gimple_asm().

#define walk_tree_without_duplicates	(	a,
		b,
		c
	)	walk_tree_without_duplicates_1 (a, b, c, NULL)

Referenced by assign_parms(), and build_opaque_vector_type().

Function Documentation

bool addr_expr_of_non_mem_decl_p ( tree )

Is it an ADDR_EXPR of a DECL that's not in memory?

int aggregate_value_p	(	const_tree	,
		const_tree
	)

bool alloca_call_p ( const_tree )

int allocate_decl_uid ( void )

Allocate and return a new UID from the DECL_UID namespace.

References DECL_ALIGN, and DECL_MODE.

Referenced by make_node_stat().

void allocate_struct_function	(	tree	,
		bool
	)

void apply_tm_attr	(	tree	,
		tree
	)

bool array_at_struct_end_p ( tree )

tree array_ref_element_size ( tree )

Return a tree of sizetype representing the size, in bytes, of the element of EXP, an ARRAY_REF or an ARRAY_RANGE_REF.

tree array_ref_low_bound ( tree )

Return a tree representing the lower bound of the array mentioned in EXP, an ARRAY_REF or an ARRAY_RANGE_REF.

tree array_ref_up_bound ( tree )

Return a tree representing the upper bound of the array mentioned in EXP, an ARRAY_REF or an ARRAY_RANGE_REF.

tree array_type_nelts ( const_tree )

void assemble_alias	(	tree	,
		tree
	)

Make one symbol an alias for another.

void assign_assembler_name_if_neeeded ( tree )

bool associative_tree_code ( enum tree_code )

int attribute_list_contained	(	const_tree	,
		const_tree
	)

int attribute_list_equal	(	const_tree	,
		const_tree
	)

bool auto_var_in_fn_p	(	const_tree	,
		const_tree
	)

bool avoid_folding_inline_builtin ( tree )

tree bit_from_pos	(	tree	,
		tree
	)

tree bit_position ( const_tree )

bool block_may_fallthru ( const_tree )

location_t* block_nonartificial_location ( tree )

tree block_ultimate_origin ( const_tree )

tree build0_stat	(	enum	tree_code,
		tree	MEM_STAT_DECL
	)

tree build1_stat	(	enum	tree_code,
		tree	,
		tree	MEM_STAT_DECL
	)

static tree build1_stat_loc	(	location_t	loc,
		enum tree_code	code,
		tree	type,
		tree arg1	MEM_STAT_DECL
	)

inlinestatic

_loc versions of build[1-5].

tree build2_stat	(	enum	tree_code,
		tree	,
		tree	,
		tree	MEM_STAT_DECL
	)

static tree build2_stat_loc	(	location_t	loc,
		enum tree_code	code,
		tree	type,
		tree	arg0,
		tree arg1	MEM_STAT_DECL
	)

inlinestatic

tree build3_stat	(	enum	tree_code,
		tree	,
		tree	,
		tree	,
		tree	MEM_STAT_DECL
	)

static tree build3_stat_loc	(	location_t	loc,
		enum tree_code	code,
		tree	type,
		tree	arg0,
		tree	arg1,
		tree arg2	MEM_STAT_DECL
	)

inlinestatic

tree build4_stat	(	enum	tree_code,
		tree	,
		tree	,
		tree	,
		tree	,
		tree	MEM_STAT_DECL
	)

static tree build4_stat_loc	(	location_t	loc,
		enum tree_code	code,
		tree	type,
		tree	arg0,
		tree	arg1,
		tree	arg2,
		tree arg3	MEM_STAT_DECL
	)

inlinestatic

tree build5_stat	(	enum	tree_code,
		tree	,
		tree	,
		tree	,
		tree	,
		tree	,
		tree	MEM_STAT_DECL
	)

static tree build5_stat_loc	(	location_t	loc,
		enum tree_code	code,
		tree	type,
		tree	arg0,
		tree	arg1,
		tree	arg2,
		tree	arg3,
		tree arg4	MEM_STAT_DECL
	)

inlinestatic

tree build_addr	(	tree	,
		tree
	)

In tree-nested.c

tree build_aligned_type	(	tree	,
		unsigned	int
	)

Create a variant of type T with alignment ALIGN.

tree build_all_ones_cst ( tree )

tree build_array_type	(	tree	,
		tree
	)

tree build_array_type_nelts	(	tree	,
		unsigned	HOST_WIDE_INT
	)

tree build_block	(	tree	,
		tree	,
		tree	,
		tree
	)

tree build_call_array_loc	(	location_t	loc,
		tree	return_type,
		tree	fn,
		int	nargs,
		const tree *	args
	)

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 OMP_CLAUSE_CHAIN, OMP_CLAUSE_OPERAND, WALK_SUBTREE, and WALK_SUBTREE_TAIL.

Referenced by maybe_with_size_expr().

tree build_call_expr	(	tree	,
		int	,
			...
	)

tree build_call_expr_loc	(	location_t	,
		tree	,
		int	,
			...
	)

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_nary	(	tree	,
		tree	,
		int	,
			...
	)

tree build_call_valist	(	tree	,
		tree	,
		int	,
		va_list
	)

tree build_call_vec	(	tree	,
		tree	,
		vec< tree, va_gc > *
	)

tree build_case_label	(	tree	,
		tree	,
		tree
	)

Make a CASE_LABEL_EXPR.

void build_common_builtin_nodes ( void )

Call this function after instantiating all builtins that the language front end cares about. This will build the rest of the builtins that are relied upon by the tree optimizers and the middle-end.

 If we're checking the stack, `alloca' can throw.

 If there's a possibility that we might use the ARM EABI, build the
alternate __cxa_end_cleanup node used to resume from C++ and Java.

 The exception object and filter values from the runtime.  The argument
 must be zero before exception lowering, i.e. from the front end.  After
 exception lowering, it will be the region number for the exception
 landing pad.  These functions are PURE instead of CONST to prevent
 them from being hoisted past the exception edge that will initialize
 its value in the landing pad.

 Only use TM_PURE if we we have TM language support.

 Complex multiplication and division.  These are handled as builtins
 rather than optabs because emit_library_call_value doesn't support
 complex.  Further, we can do slightly better with folding these
 beasties if the real and complex parts of the arguments are separate.

void build_common_tree_nodes	(	bool	,
		bool
	)

tree build_complex	(	tree	,
		tree	,
		tree
	)

tree build_complex_type ( tree )

tree build_constructor	(	tree	,
		vec< constructor_elt, va_gc > *
	)

tree build_constructor_from_list	(	tree	,
		tree
	)

tree build_constructor_single	(	tree	,
		tree	,
		tree
	)

tree build_constructor_va	(	tree	,
		int	,
			...
	)

tree build_decl_attribute_variant	(	tree	,
		tree
	)

tree build_decl_stat	(	location_t	,
		enum	tree_code,
		tree	,
		tree	MEM_STAT_DECL
	)

tree build_distinct_type_copy ( tree )

Make a copy of a type node.

tree build_duplicate_type ( tree )

This is in tree-inline.c since the routine uses data structures from the inliner.

tree build_empty_stmt ( location_t )

tree build_fn_decl	(	const char *	,
		tree
	)

tree build_fold_addr_expr_loc	(	location_t	,
		tree
	)

tree build_fold_addr_expr_with_type_loc	(	location_t	,
		tree	,
		tree
	)

tree build_fold_indirect_ref_loc	(	location_t	,
		tree
	)

tree build_function_decl_skip_args	(	tree	orig_decl,
		bitmap	args_to_skip,
		bool	skip_return
	)

Build variant of function decl ORIG_DECL skipping ARGS_TO_SKIP and the return value if SKIP_RETURN is true.

Arguments from DECL_ARGUMENTS list can't be removed now, since they are linked by TREE_CHAIN directly. The caller is responsible for eliminating them when they are being duplicated (i.e. copy_arguments_for_versioning).

For declarations setting DECL_VINDEX (i.e. methods) we expect first argument to be THIS pointer.

 When signature changes, we need to clear builtin info.

References DECL_BIT_FIELD, DECL_SIZE, DECL_UNSIGNED, fold_convert, tree_low_cst(), TREE_OPERAND, TREE_TYPE, lang_hooks_for_types::type_for_size, TYPE_PRECISION, TYPE_UNSIGNED, and lang_hooks::types.

tree build_function_type	(	tree	,
		tree
	)

tree build_function_type_array	(	tree	,
		int	,
		tree *
	)

tree build_function_type_list	(	tree	,
			...
	)

tree build_index_type ( tree )

tree build_int_cst	(	tree	,
		HOST_WIDE_INT
	)

tree build_int_cst_type	(	tree	,
		HOST_WIDE_INT
	)

tree build_int_cst_wide	(	tree	,
		unsigned	HOST_WIDE_INT,
		HOST_WIDE_INT
	)

static tree build_int_cstu ( )

inlinestatic

Create an INT_CST node with a CST value zero extended.

Referenced by fold_builtin_strcspn().

tree build_invariant_address	(	tree	,
		tree	,
		HOST_WIDE_INT
	)

tree build_low_bits_mask	(	tree	,
		unsigned
	)

tree build_method_type	(	tree	,
		tree
	)

tree build_method_type_directly	(	tree	basetype,
		tree	rettype,
		tree	argtypes
	)

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.

 Make a node of the sort we want.

 The actual arglist for this function includes a "hidden" argument
 which is "this".  Put it into the list of argument types.

 If we already have such a type, use the old one.

 Set up the canonical type.

References double_int_one, double_int::mask(), mpz_set_double_int(), POINTER_TYPE_P, TREE_CODE, tree_to_double_int(), TYPE_MAX_VALUE, TYPE_MIN_VALUE, TYPE_PRECISION, and TYPE_UNSIGNED.

tree build_minus_one_cst ( tree )

tree build_nonshared_array_type	(	tree	,
		tree
	)

tree build_nonshared_range_type	(	tree	,
		tree	,
		tree
	)

tree build_nonstandard_integer_type	(	unsigned HOST_WIDE_INT	precision,
		int	unsignedp
	)

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.

tree build_nt	(	enum	tree_code,
			...
	)

Construct various types of nodes.

tree build_nt_call_vec	(	tree	,
		vec< tree, va_gc > *
	)

tree build_offset_type	(	tree	,
		tree
	)

tree build_omp_clause	(	location_t	,
		enum	omp_clause_code
	)

tree build_one_cst ( tree )

tree build_opaque_vector_type	(	tree	innertype,
		int	nunits
	)

tree build_optimization_node ( struct gcc_options * opts )

Return a tree node that encapsulates the optimization options in OPTS.

tree build_personality_function ( const char * )

tree build_pointer_type ( tree )

tree build_pointer_type_for_mode	(	tree	to_type,
		enum machine_mode	mode,
		bool	can_alias_all
	)

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 CAN_ALIAS_ALL is TRUE, indicate this type can reference all of memory. If such a type has already been constructed, reuse it.

 If the pointed-to type has the may_alias attribute set, force
 a TYPE_REF_CAN_ALIAS_ALL pointer to be generated.

 In some cases, languages will have things that aren't a POINTER_TYPE
 (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_POINTER_TO.
 In that case, return that type without regard to the rest of our
 operands.

 ??? This is a kludge, but consistent with the way this function has
 always operated and there doesn't seem to be a good way to avoid this
 at the moment.

 First, if we already have a type for pointers to TO_TYPE and it's
 the proper mode, use it.

 Lay out the type.  This function has many callers that are concerned
 with expression-construction, and this simplifies them all.

Referenced by expand_omp_atomic_load(), make_or_reuse_fract_type(), and simple_cst_equal().

tree build_qualified_type	(	tree	,
		int
	)

Like get_qualified_type, but creates the type if it does not exist. This function never returns NULL_TREE.

tree build_range_check	(	location_t	loc,
		tree	type,
		tree	exp,
		int	in_p,
		tree	low,
		tree	high
	)

Given a range, LOW, HIGH, and IN_P, an expression, EXP, and a result type, TYPE, return an expression to test if EXP is in (or out of, depending on IN_P) the range. Return 0 if the test couldn't be created.

 Optimize (c>=1) && (c<=127) into (signed char)c > 0.

 Optimize (c>=low) && (c<=high) into (c-low>=0) && (c-low<=high-low).
 This requires wrap-around arithmetics for the type of the expression.
 First make sure that arithmetics in this type is valid, then make sure
 that it wraps around.

     Check if (unsigned) INT_MAX + 1 == (unsigned) INT_MIN
     for the type in question, as we rely on this here.

tree build_range_type	(	tree	,
		tree	,
		tree
	)

tree build_real_from_int_cst	(	tree	,
		const_tree
	)

tree build_reference_type ( tree )

tree build_reference_type_for_mode	(	tree	to_type,
		enum machine_mode	mode,
		bool	can_alias_all
	)

Same as build_pointer_type_for_mode, but for REFERENCE_TYPE.

 If the pointed-to type has the may_alias attribute set, force
 a TYPE_REF_CAN_ALIAS_ALL pointer to be generated.

 In some cases, languages will have things that aren't a REFERENCE_TYPE
 (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_REFERENCE_TO.
 In that case, return that type without regard to the rest of our
 operands.

 ??? This is a kludge, but consistent with the way this function has
 always operated and there doesn't seem to be a good way to avoid this
 at the moment.

 First, if we already have a type for pointers to TO_TYPE and it's
 the proper mode, use it.

References TREE_CHAIN, and void_list_node.

tree build_simple_mem_ref_loc	(	location_t	,
		tree
	)

tree build_string	(	int	,
		const char *
	)

tree build_string_literal	(	int	,
		const char *
	)

tree build_target_option_node ( struct gcc_options * opts )

Return a tree node that encapsulates the target options in OPTS.

tree build_tm_abort_call	(	location_t	,
		bool
	)

In trans-mem.c.

tree build_translation_unit_decl ( tree )

tree build_tree_list_stat	(	tree	,
		tree	MEM_STAT_DECL
	)

tree build_tree_list_vec_stat ( const vec< tree, va_gc > * MEM_STAT_DECL )

tree build_type_attribute_qual_variant	(	tree	,
		tree	,
		int
	)

tree build_type_attribute_variant	(	tree	,
		tree
	)

Return a type like TTYPE except that its TYPE_ATTRIBUTES is ATTRIBUTE.

Such modified types already made are recorded so that duplicates are not made.

tree build_type_no_quals ( tree )

tree build_var_debug_value_stat	(	tree	,
		tree	MEM_STAT_DECL
	)

tree build_varargs_function_type_array	(	tree	,
		int	,
		tree *
	)

tree build_varargs_function_type_list	(	tree	,
			...
	)

tree build_variant_type_copy ( tree )

tree build_vector_from_ctor	(	tree	,
		vec< constructor_elt, va_gc > *
	)

tree build_vector_from_val	(	tree	,
		tree
	)

tree build_vector_stat	(	tree	,
		tree *	MEM_STAT_DECL
	)

tree build_vector_type	(	tree	innertype,
		int	nunits
	)

tree build_vector_type_for_mode	(	tree	,
		enum	machine_mode
	)

tree build_vl_exp_stat	(	enum	tree_code,
		int	MEM_STAT_DECL
	)

tree build_zero_cst ( tree )

static tree builtin_decl_explicit ( )

inlinestatic

Return the tree node for an explicit standard builtin function or NULL.

Referenced by assign_parms(), emit_call_1(), expand_omp_atomic_load(), expand_omp_sections(), find_bswap(), fold_builtin_fputs(), get_tm_region_blocks(), gimplify_return_expr(), ipa_tm_diagnose_tm_safe(), lower_emutls_phi_arg(), lower_omp_sections(), maybe_add_implicit_barrier_cancel(), maybe_catch_exception(), maybe_emit_sprintf_chk_warning(), rewrite_call_expr_valist(), and tree_int_cst_sign_bit().

static bool builtin_decl_explicit_p ( )

inlinestatic

Return whether the standard builtin function can be used as an explicit function.

static tree builtin_decl_implicit ( )

inlinestatic

Return the tree node for an implicit builtin function or NULL.

Referenced by avoid_folding_inline_builtin(), fold_builtin_4(), fold_builtin_classify(), fold_builtin_logarithm(), instrument_builtin_call(), instrument_memory_accesses(), lower_gimple_return(), maybe_emit_sprintf_chk_warning(), rewrite_call_expr_valist(), set_strinfo(), split_critical_edges(), and tsan_pass().

static bool builtin_decl_implicit_p ( )

inlinestatic

Return whether the standard builtin function can be used implicitly.

enum built_in_function builtin_mathfn_code ( const_tree )

rtx builtin_memset_read_str	(	void *	data,
		HOST_WIDE_INT	offset,
		enum machine_mode	mode
	)

Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE) bytes from constant string DATA + OFFSET and return it as target constant.

tree byte_from_pos	(	tree	,
		tree
	)

tree byte_position ( const_tree )

tree c_strlen	(	tree	,
		int
	)

void cache_integer_cst ( tree )

int call_expr_flags ( const_tree )

int can_move_by_pieces	(	unsigned HOST_WIDE_INT	len,
		unsigned int	align
	)

In expr.c. Determine whether the LEN bytes can be moved by using several move instructions. Return nonzero if a call to move_by_pieces should succeed.

Determine whether the LEN bytes can be moved by using several move instructions. Return nonzero if a call to move_by_pieces should succeed.

References move_by_pieces_d::autinc_from, move_by_pieces_d::reverse, USE_LOAD_PRE_DECREMENT, and widest_int_mode_for_size().

Referenced by gimplify_init_ctor_eval().

bool categorize_ctor_elements	(	const_tree	ctor,
		HOST_WIDE_INT *	p_nz_elts,
		HOST_WIDE_INT *	p_init_elts,
		bool *	p_complete
	)

Examine CTOR to discover: how many scalar fields are set to nonzero values, and place it in *P_NZ_ELTS; how many scalar fields in total are in CTOR, and place it in *P_ELT_COUNT. whether the constructor is complete – in the sense that every meaningful byte is explicitly given a value – and place it in *P_COMPLETE.

Return whether or not CTOR is a valid static constant initializer, the same as "initializer_constant_valid_p (CTOR, TREE_TYPE (CTOR)) != 0".

tree chain_index	(	int	,
		tree
	)

int chain_member	(	const_tree	,
		const_tree
	)

tree chainon	(	tree	,
		tree
	)

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.

void change_decl_assembler_name	(	tree	,
		tree
	)

In cgraph.c

bool check_qualified_type	(	const_tree	,
		const_tree	,
		int
	)

Check whether CAND is suitable to be returned from get_qualified_type (BASE, TYPE_QUALS).

void clean_symbol_name ( char * )

tree combine_comparisons	(	location_t	loc,
		enum tree_code	code,
		enum tree_code	lcode,
		enum tree_code	rcode,
		tree	truth_type,
		tree	ll_arg,
		tree	lr_arg
	)

Return a tree for the comparison which is the combination of doing the AND or OR (depending on CODE) of the two operations LCODE and RCODE on the identical operands LL_ARG and LR_ARG. Take into account the possibility of trapping if the mode has NaNs, and return NULL_TREE if this makes the transformation invalid.

     Eliminate unordered comparisons, as well as LTGT and ORD
     which are not used unless the mode has NaNs.

       Check that the original operation and the optimized ones will trap
       under the same condition.

       In a short-circuited boolean expression the LHS might be
       such that the RHS, if evaluated, will never trap.  For
       example, in ORD (x, y) && (x < y), we evaluate the RHS only
       if neither x nor y is NaN.  (This is a mixed blessing: for
       example, the expression above will never trap, hence
       optimizing it to x < y would be invalid).

       If the comparison was short-circuited, and only the RHS
       trapped, we may now generate a spurious trap.

       If we changed the conditions that cause a trap, we lose.

Referenced by fold_range_test().

bool commutative_ternary_tree_code ( enum tree_code )

bool commutative_tree_code ( enum tree_code )

int comp_type_attributes	(	const_tree	,
		const_tree
	)

Return 0 if the attributes for two types are incompatible, 1 if they are compatible, and 2 if they are nearly compatible (which causes a warning to be generated).

int compare_tree_int	(	const_tree	,
		unsigned	HOST_WIDE_INT
	)

bool complete_ctor_at_level_p	(	const_tree	type,
		HOST_WIDE_INT	num_elts,
		const_tree	last_type
	)

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.

??? We could look at each element of the union, and find the largest element. Which would avoid comparing the size of the initialized element against any tail padding in the union. Doesn't seem worth the effort...

tree component_ref_field_offset ( tree )

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.

unsigned HOST_WIDE_INT compute_builtin_object_size	(	tree	,
		int
	)

void compute_record_mode ( tree )

tree constant_boolean_node	(	bool	,
		tree
	)

bool constructor_static_from_elts_p ( const_tree )

Whether a constructor CTOR is a valid static constant initializer if all its elements are. This used to be internal to initializer_constant_valid_p and has been exposed to let other functions like categorize_ctor_elements evaluate the property while walking a constructor for other purposes.

bool contains_bitfld_component_ref_p ( const_tree )

bool contains_placeholder_p ( const_tree )

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.

tree convert	(	tree	,
		tree
	)

static tree convert_to_ptrofftype_loc ( )

inlinestatic

Return OFF converted to a pointer offset type suitable as offset for POINTER_PLUS_EXPR. Use location LOC for this conversion.

tree copy_list ( tree )

Make a copy of a chain of TREE_LIST nodes.

tree copy_node_stat ( tree MEM_STAT_DECL )

Make a copy of a node, with all the same contents.

unsigned crc32_byte	(	unsigned	,
		char
	)

unsigned crc32_string	(	unsigned	,
		const char *
	)

In tree.c

unsigned crc32_unsigned	(	unsigned	,
		unsigned
	)

tree create_artificial_label ( location_t )

bool cst_and_fits_in_hwi ( const_tree )

vec<tree, va_gc>* ctor_to_vec ( tree )

Given a CONSTRUCTOR CTOR, return the element values as a vector.

bool cxx11_attribute_p ( const_tree )

void debug ( const tree_node & ref )

void debug ( const tree_node * ptr )

void debug ( vec< tree, va_gc > & ref )

void debug ( vec< tree, va_gc > * ptr )

void debug_body ( const tree_node & ref )

void debug_body ( const tree_node * ptr )

bool debug_find_tree	(	tree	,
		tree
	)

In tree-inline.c:

void debug_fold_checksum ( const_tree )

void debug_head ( const tree_node & ref )

void debug_head ( const tree_node * ptr )

void debug_raw ( const tree_node & ref )

void debug_raw ( const tree_node * ptr )

void debug_raw ( vec< tree, va_gc > & ref )

void debug_raw ( vec< tree, va_gc > * ptr )

void debug_tree ( tree )

In print-rtl.c In print-tree.c

void debug_vec_tree ( vec< tree, va_gc > * )

void debug_verbose ( const tree_node & ref )

void debug_verbose ( const tree_node * ptr )

bool decl_address_invariant_p ( const_tree )

bool decl_address_ip_invariant_p ( const_tree )

tree decl_assembler_name ( tree )

bool decl_assembler_name_equal	(	tree	decl,
		const_tree	asmname
	)

hashval_t decl_assembler_name_hash ( const_tree asmname )

tree decl_attributes	(	tree *	,
		tree	,
		int
	)

Process the attributes listed in ATTRIBUTES and install them in *NODE, which is either a DECL (including a TYPE_DECL) or a TYPE. If a DECL, it should be modified in place; if a TYPE, a copy should be created unless ATTR_FLAG_TYPE_IN_PLACE is set in FLAGS. FLAGS gives further information, in the form of a bitwise OR of flags in enum attribute_flags from tree.h. Depending on these flags, some attributes may be returned to be applied at a later stage (for example, to apply a decl attribute to the declaration rather than to its type).

bool decl_binds_to_current_def_p ( tree )

Referenced by align_variable(), and default_elf_select_section().

vec<tree, va_gc>** decl_debug_args_insert ( tree )

vec<tree, va_gc>** decl_debug_args_lookup ( tree )

void decl_debug_expr_insert	(	tree	,
		tree
	)

tree decl_debug_expr_lookup ( tree )

enum tls_model decl_default_tls_model ( const_tree )

void decl_fini_priority_insert	(	tree	,
		priority_type
	)

priority_type decl_fini_priority_lookup ( tree )

tree decl_function_context ( const_tree )

Return the FUNCTION_DECL which provides this _DECL with its context, or zero if none.

void decl_init_priority_insert	(	tree	,
		priority_type
	)

priority_type decl_init_priority_lookup ( tree )

bool decl_replaceable_p ( tree )

tree decl_type_context ( const_tree )

Return the RECORD_TYPE, UNION_TYPE, or QUAL_UNION_TYPE which provides this _DECL with its context, or zero if none.

void decl_value_expr_insert	(	tree	,
		tree
	)

tree decl_value_expr_lookup ( tree )

void declare_weak ( tree )

Declare DECL to be a weak symbol.

tree div_if_zero_remainder	(	enum	tree_code,
		const_tree	,
		const_tree
	)

bool double_int_fits_to_tree_p	(	const_tree	,
		double_int
	)

tree double_int_to_tree	(	tree	,
		double_int
	)

void dump_tree_statistics ( void )

Print debugging information about tree nodes generated during the compile, and any language-specific information.

References targetm.

unsigned int element_precision ( const_tree )

tree excess_precision_type ( tree )

void expand_asm_stmt ( gimple )

void expand_computed_goto ( tree )

In stmt.c

void expand_dummy_function_end ( void )

Undo the effects of init_dummy_function_start.

End any sequences that failed to be closed due to syntax errors.

 Outside function body, can't compute type's actual size
 until next function's body starts.

References gcc_assert, htab_create_ggc, and NEXT_INSN.

void expand_function_end ( void )

Generate RTL for the end of the current function.

 If arg_pointer_save_area was referenced only from a nested
 function, we will not have initialized it yet.  Do that now.

 If we are doing generic stack checking and this function makes calls,
 do a stack probe at the start of the function to ensure we have enough
 space for another stack frame.

 End any sequences that failed to be closed due to syntax errors.

 Output a linenumber for the end of the function.
 SDB depends on this.

 Before the return label (if any), clobber the return
 registers so that they are not propagated live to the rest of
 the function.  This can only happen with functions that drop
 through; if there had been a return statement, there would
 have either been a return rtx, or a jump to the return label.

 We delay actual code generation after the current_function_value_rtx
 is computed.

 Output the label for the actual return from the function.

     Let except.c know where it should emit the call to unregister
     the function context for sjlj exceptions.

     We want to ensure that instructions that may trap are not
     moved into the epilogue by scheduling, because we don't
     always emit unwind information for the epilogue.

 If this is an implementation of throw, do what's necessary to
 communicate between __builtin_eh_return and the epilogue.

 If scalar return value was computed in a pseudo-reg, or was a named
 return value that got dumped to the stack, copy that to the hard
 return register.

         This should be set in assign_parms.

         If this is a BLKmode structure being returned in registers,
         then use the mode computed in expand_return.  Note that if
         decl_rtl is memory, then its mode may have been changed,
         but that crtl->return_rtx has not.

         If a non-BLKmode return value should be padded at the least
         significant end of the register, shift it left by the appropriate
         amount.  BLKmode results are handled using the group load/store
         machinery.

         If a named return value dumped decl_return to memory, then
         we may need to re-do the PROMOTE_MODE signed/unsigned
         extension.

             If expand_function_start has created a PARALLEL for decl_rtl,
             move the result to the real return registers.  Otherwise, do
             a group load from decl_rtl for a named return.

         In the case of complex integer modes smaller than a word, we'll
         need to generate some non-trivial bitfield insertions.  Do that
         on a pseudo and not the hard register.

 If returning a structure, arrange to return the address of the value
 in a place where debuggers expect to find it.

 If returning a structure PCC style,
 the caller also depends on this value.
 And cfun->returns_pcc_struct is not necessarily set.

     Mark this as a function return value so integrate will delete the
     assignment and USE below when inlining this function.

     The address may be ptr_mode and OUTGOING may be Pmode.

     Show return register used to hold result (in this case the address
     of the result.

 Emit the actual code to clobber return register.

 Output the label for the naked return from the function.

 @@@ This is a kludge.  We want to ensure that instructions that
 may trap are not moved into the epilogue by scheduling, because
 we don't always emit unwind information for the epilogue.

 If stack protection is enabled for this function, check the guard.

 If we had calls to alloca, and this machine needs
 an accurate stack pointer to exit the function,
 insert some code to save and restore the stack pointer.

 ??? This should no longer be necessary since stupid is no longer with
 us, but there are some parts of the compiler (eg reload_combine, and
 sh mach_dep_reorg) that still try and compute their own lifetime info
 instead of using the general framework.

void expand_function_start ( tree )

void expand_goto ( tree )

void expand_label ( tree )

In stmt.c

void expand_main_function ( void )

In function.c

void expand_return ( tree )

void expand_stack_restore ( tree )

rtx expand_stack_save ( void )

Emit code to save the current value of stack.

unsigned int expr_align ( const_tree )

tree expr_first ( tree )

tree expr_last ( tree )

int fields_length ( const_tree )

Returns the number of FIELD_DECLs in a type.

void finalize_size_functions ( void )

Take, queue and compile all the size functions. It is essential that the size functions be gimplified at the very end of the compilation in order to guarantee transparent handling of self-referential sizes. Otherwise the GENERIC inliner would not be able to inline them back at each of their call sites, thus creating artificial non-constant size expressions which would trigger nasty problems later on.

void find_placeholder_in_expr	(	tree	,
		vec< tree > *
	)

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.

void fini_object_sizes ( void )

Destroy data structures after the object size computation.

void finish_builtin_struct	(	tree	type,
		const char *	name,
		tree	fields,
		tree	align_type
	)

Finish up a builtin RECORD_TYPE. Give it a name and provide its fields. Optionally specify an alignment, and then lay it out.

Finish processing a builtin RECORD_TYPE type TYPE. It's name is NAME, its fields are chained in reverse on FIELDS.

If ALIGN_TYPE is non-null, it is given the same alignment as ALIGN_TYPE.

References build_int_cst(), double_int_to_tree(), fold_convert, integer_zerop(), size_binop, size_zero_node, sizetype, ssizetype, TREE_CODE, tree_int_cst_lt(), tree_to_double_int(), TREE_TYPE, TYPE_MAX_VALUE, TYPE_MIN_VALUE, TYPE_PRECISION, TYPE_SIZE, and TYPE_UNSIGNED.

void finish_record_layout	(	record_layout_info	,
		int
	)

static tree first_call_expr_arg ( )

inlinestatic

Initialize the abstract argument list iterator object ITER, then advance past and return the first argument. Useful in for expressions, e.g. for (arg = first_call_expr_arg (exp, &iter); arg; arg = next_call_expr_arg (&iter))

Referenced by delete_unreachable_blocks_update_callgraph().

static const_tree first_const_call_expr_arg ( )

inlinestatic

tree first_field ( const_tree )

Returns the first FIELD_DECL in a type.

int fixed_zerop ( const_tree )

fixed_zerop (tree x) is nonzero if X is a fixed-point constant of value 0.

void fixup_signed_type ( tree )

void fixup_unsigned_type ( tree )

int flags_from_decl_or_type ( const_tree )

In calls.c

tree fold ( tree )

Fold constants as much as possible in an expression. Returns the simplified expression. Acts only on the top level of the expression; if the argument itself cannot be simplified, its subexpressions are not changed.

tree fold_abs_const	(	tree	,
		tree
	)

tree fold_binary_loc	(	location_t	loc,
		enum tree_code	code,
		tree	type,
		tree	op0,
		tree	op1
	)

Fold a binary expression of code CODE and type TYPE with operands OP0 and OP1. LOC is the location of the resulting expression. Return the folded expression if folding is successful. Otherwise, return NULL_TREE.

 Strip any conversions that don't change the mode.  This is
 safe for every expression, except for a comparison expression
 because its signedness is derived from its operands.  So, in
 the latter case, only strip conversions that don't change the
 signedness.  MIN_EXPR/MAX_EXPR also need signedness of arguments
 preserved.

 Note that this is done as an internal manipulation within the
 constant folder, in order to find the simplest representation
 of the arguments so that their form can be studied.  In any
 cases, the appropriate type conversions should be put back in
 the tree that will get out of the constant folder.

 Note that TREE_CONSTANT isn't enough: static var addresses are
 constant but we can't do arithmetic on them.

         Make sure type and arg0 have the same saturating flag.

 If this is a commutative operation, and ARG0 is a constant, move it
 to ARG1 to reduce the number of tests below.

 ARG0 is the first operand of EXPR, and ARG1 is the second operand.

 First check for cases where an arithmetic operation is applied to a
 compound, conditional, or comparison operation.  Push the arithmetic
 operation inside the compound or conditional to see if any folding
 can then be done.  Convert comparison to conditional for this purpose.
 The also optimizes non-constant cases that used to be done in
 expand_expr.

 Before we do that, see if this is a BIT_AND_EXPR or a BIT_IOR_EXPR,
 one of the operands is a comparison and the other is a comparison, a
 BIT_AND_EXPR with the constant 1, or a truth value.  In that case, the
 code below would make the expression more complex.  Change it to a
 TRUTH_{AND,OR}_EXPR.  Likewise, convert a similar NE_EXPR to
 TRUTH_XOR_EXPR and an EQ_EXPR to the inversion of a TRUTH_XOR_EXPR.

     MEM[&MEM[p, CST1], CST2] -> MEM[p, CST1 + CST2].

     MEM[&a.b, CST2] -> MEM[&a, offsetof (a, b) + CST2].

     0 +p index -> (type)index

     PTR +p 0 -> PTR

     INT +p INT -> (PTR)(INT + INT).  Stripping types allows for this.

     (PTR +p B) +p A -> PTR +p (B + A)

     PTR_CST +p CST -> CST1

    Try replacing &a[i1] +p c * i2 with &a[i1 + i2], if c is step
    of the array.  Loop optimizer sometimes produce this type of
    expressions.

     A + (-B) -> A - B

     (-A) + B -> B - A

         Convert ~A + 1 to -A.

         ~X + X is -1.

         X + ~X is -1.

         X + (X / CST) * -CST is X % CST.

     Handle (A1 * C1) + (A2 * C2) with A1, A2 or C1, C2 being the same or
     one.  Make sure the type is not saturating and has the signedness of
     the stripped operands, as fold_plusminus_mult_expr will re-associate.
     ??? The latter condition should use TYPE_OVERFLOW_* flags instead.

         If we are adding two BIT_AND_EXPR's, both of which are and'ing
         with a constant, and the two constants have no bits in common,
         we should treat this as a BIT_IOR_EXPR since this may produce more
         simplifications.

         Reassociate (plus (plus (mult) (foo)) (mult)) as
         (plus (plus (mult) (mult)) (foo)) so that we can
         take advantage of the factoring cases below.

         See if ARG1 is zero and X + ARG1 reduces to X.

         Likewise if the operands are reversed.

         Convert X + -C into X - C.

         Fold __complex__ ( x, 0 ) + __complex__ ( 0, y )
         to __complex__ ( x, y ).  This is not the same for SNaNs or
         if signed zeros are involved.

         Convert x+x into x*2.0.

         Convert a + (b*c + d*e) into (a + b*c) + d*e.
         We associate floats only if the user has specified
         -fassociative-math.

         Convert (b*c + d*e) + a into b*c + (d*e +a).
         We associate floats only if the user has specified
         -fassociative-math.

     (A << C1) + (A >> C2) if A is unsigned and C1+C2 is the size of A
     is a rotate of A by C1 bits.

     (A << B) + (A >> (Z - B)) if A is unsigned and Z is the size of A
     is a rotate of A by B bits.

           Only create rotates in complete modes.  Other cases are not
           expanded properly.

     In most languages, can't associate operations on floats through
     parentheses.  Rather than remember where the parentheses were, we
     don't associate floats at all, unless the user has specified
     -fassociative-math.
     And, we need to make sure type is not saturating.

         Split both trees into variables, constants, and literals.  Then
         associate each group together, the constants with literals,
         then the result with variables.  This increases the chances of
         literals being recombined later and of generating relocatable
         expressions for the sum of a constant and literal.

         Recombine MINUS_EXPR operands by using PLUS_EXPR.

         With undefined overflow prefer doing association in a type
         which wraps on overflow, if that is one of the operand types.

         With undefined overflow we can only associate constants with one
         variable, and constants whose association doesn't overflow.

                 The only case we can still associate with two variables
                 is if they are the same, modulo negation and bit-pattern
                 preserving conversions.

         Only do something if we found more than two objects.  Otherwise,
         nothing has changed and we risk infinite recursion.

             Preserve the MINUS_EXPR if the negative part of the literal is
             greater than the positive part.  Otherwise, the multiplicative
             folding code (i.e extract_muldiv) may be fooled in case
             unsigned constants are subtracted, like in the following
             example: ((X*2 + 4) - 8U)/2.

             Don't introduce overflows through reassociation.

     Pointer simplifications for subtraction, simple reassociations.

         (PTR0 p+ A) - (PTR1 p+ B) -> (PTR0 - PTR1) + (A - B)

         (PTR0 p+ A) - PTR1 -> (PTR0 - PTR1) + A, assuming PTR0 - PTR1 simplifies.

     A - (-B) -> A + B

     (-A) - B -> (-B) - A  where B is easily negated and we can swap.

     Convert -A - 1 to ~A.

     Convert -1 - A to ~A.

     X - (X / Y) * Y is X % Y.

         Fold A - (A & B) into ~B & A.

         Fold (A & ~B) - (A & B) into (A ^ B) - B, where B is
         any power of 2 minus 1.

     See if ARG1 is zero and X - ARG1 reduces to X.

     (ARG0 - ARG1) is the same as (-ARG1 + ARG0).  So check whether
     ARG0 is zero and X + ARG0 reduces to X, since that would mean
     (-ARG1 + ARG0) reduces to -ARG1.

     Fold __complex__ ( x, 0 ) - __complex__ ( 0, y ) to
     __complex__ ( x, -y ).  This is not the same for SNaNs or if
     signed zeros are involved.

     Fold &x - &x.  This can happen from &x.foo - &x.
     This is unsafe for certain floats even in non-IEEE formats.
     In IEEE, it is unsafe because it does wrong for NaNs.
     Also note that operand_equal_p is always false if an operand
     is volatile.

     A - B -> A + (-B) if B is easily negatable.

              Avoid this transformation if B is a positive REAL_CST.

     Try folding difference of addresses.

     Fold &a[i] - &a[j] to i-j.

     Handle (A1 * C1) - (A2 * C2) with A1, A2 or C1, C2 being the same or
     one.  Make sure the type is not saturating and has the signedness of
     the stripped operands, as fold_plusminus_mult_expr will re-associate.
     ??? The latter condition should use TYPE_OVERFLOW_* flags instead.

     (-A) * (-B) -> A * B

         Transform x * -1 into -x.  Make sure to do the negation
         on the original operand with conversions not stripped
         because we can only strip non-sign-changing conversions.

         Transform x * -C into -x * C if x is easily negatable.

         (a * (1 << b)) is (a << b)

         (A + A) * C -> A * 2 * C

         ((T) (X /[ex] C)) * C cancels out if the conversion is
         sign-changing only.

         Optimize z * conj(z) for integer complex numbers.

         Maybe fold x * 0 to 0.  The expressions aren't the same
         when x is NaN, since x * 0 is also NaN.  Nor are they the
         same in modes with signed zeros, since multiplying a
         negative value by 0 gives -0, not +0.

         In IEEE floating point, x*1 is not equivalent to x for snans.
         Likewise for complex arithmetic with signed zeros.

         Transform x * -1.0 into -x.

         Convert (C1/X)*C2 into (C1*C2)/X.  This transformation may change
         the result for floating point types due to rounding so it is applied
         only if -fassociative-math was specify.

         Strip sign operations from X in X*X, i.e. -Y*-Y -> Y*Y.

         Fold z * +-I to __complex__ (-+__imag z, +-__real z).
         This is not the same for NaNs or if signed zeros are
         involved.

         Optimize z * conj(z) for floating point complex numbers.
         Guarded by flag_unsafe_math_optimizations as non-finite
         imaginary components don't produce scalar results.

             Optimizations of root(...)*root(...).

                 Optimize sqrt(x)*sqrt(x) as x.

                 Optimize root(x)*root(y) as root(x*y).

             Optimize expN(x)*expN(y) as expN(x+y).

             Optimizations of pow(...)*pow(...).

                 Optimize pow(x,y)*pow(z,y) as pow(x*z,y).

                 Optimize pow(x,y)*pow(x,z) as pow(x,y+z).

             Optimize tan(x)*cos(x) as sin(x).

             Optimize x*pow(x,c) as pow(x,c+1).

             Optimize pow(x,c)*x as pow(x,c+1).

             Canonicalize x*x as pow(x,2.0), which is expanded as x*x.

     ~X | X is -1.

     X | ~X is -1.

     Canonicalize (X & C1) | C2.

         If (C1&C2) == C1, then (X&C1)|C2 becomes (X,C2).

         If (C1|C2) == ~0 then (X&C1)|C2 becomes X|C2.

         Minimize the number of bits set in C1, i.e. C1 := C1 & ~C2,
         unless (C1 & ~C2) | (C2 & C3) for some C3 is a mask of some
         mode which allows further optimizations.

         If X is a tree of the form (Y * K1) & K2, this might conflict
         with that optimization from the BIT_AND_EXPR optimizations.
         This could end up in an infinite recursion.

     (X & Y) | Y is (X, Y).

     (X & Y) | X is (Y, X).

     X | (X & Y) is (Y, X).

     X | (Y & X) is (Y, X).

     (X & ~Y) | (~X & Y) is X ^ Y

     Convert (or (not arg0) (not arg1)) to (not (and (arg0) (arg1))).

     This results in more efficient code for machines without a NAND
     instruction.  Combine will canonicalize to the first form
     which will allow use of NAND instructions provided by the
     backend if they exist.

     See if this can be simplified into a rotate first.  If that
     is unsuccessful continue in the association code.

     ~X ^ X is -1.

     X ^ ~X is -1.

     If we are XORing two BIT_AND_EXPR's, both of which are and'ing
     with a constant, and the two constants have no bits in common,
     we should treat this as a BIT_IOR_EXPR since this may produce more
     simplifications.

     (X | Y) ^ X -> Y & ~ X

     (Y | X) ^ X -> Y & ~ X

     X ^ (X | Y) -> Y & ~ X

     X ^ (Y | X) -> Y & ~ X

     Convert ~X ^ ~Y to X ^ Y.

     Convert ~X ^ C to X ^ ~C.

     Fold (X & 1) ^ 1 as (X & 1) == 0.

     Fold (X & Y) ^ Y as ~X & Y.

     Fold (X & Y) ^ X as ~Y & X.

     Fold X ^ (X & Y) as X & ~Y.

     Fold X ^ (Y & X) as ~Y & X.

     See if this can be simplified into a rotate first.  If that
     is unsuccessful continue in the association code.

     ~X & X, (X == 0) & X, and !X & X are always zero.

     X & ~X , X & (X == 0), and X & !X are always zero.

     Canonicalize (X | C1) & C2 as (X & C2) | (C1 & C2).

     (X | Y) & Y is (X, Y).

     (X | Y) & X is (Y, X).

     X & (X | Y) is (Y, X).

     X & (Y | X) is (Y, X).

     Fold (X ^ 1) & 1 as (X & 1) == 0.

     Fold ~X & 1 as (X & 1) == 0.

     Fold !X & 1 as X == 0.

     Fold (X ^ Y) & Y as ~X & Y.

     Fold (X ^ Y) & X as ~Y & X.

     Fold X & (X ^ Y) as X & ~Y.

     Fold X & (Y ^ X) as ~Y & X.

     Fold (X * Y) & -(1 << CST) to X * Y if Y is a constant
     multiple of 1 << CST.

     Fold (X * CST1) & CST2 to zero if we can, or drop known zero
     bits from CST2.

     For constants M and N, if M == (1LL << cst) - 1 && (N & M) == M,
     ((A & N) + B) & M -> (A + B) & M
     Similarly if (N & M) == 0,
     ((A | N) + B) & M -> (A + B) & M
     and for - instead of + (or unary - instead of +)
     and/or ^ instead of |.
     If B is constant and (B & M) == 0, fold into A & M.

             Now we know that arg0 is (C + D) or (C - D) or
             -C and arg1 (M) is == (1LL << cst) - 1.
             Store C into PMOP[0] and D into PMOP[1].

                   tree_low_cst not used, because we don't care about
                   the upper bits.

                   If C or D is of the form (A & N) where
                   (N & M) == M, or of the form (A | N) or
                   (A ^ N) where (N & M) == 0, replace it with A.

                   If C or D is a N where (N & M) == 0, it can be
                   omitted (assumed 0).

             Only build anything new if we optimized one or both arguments
             above.

                     Perform the operations in a type that has defined
                     overflow behavior.

                 TEM is now the new binary +, - or unary - replacement.

     Simplify ((int)c & 0377) into (int)c, if c is unsigned char.

     Convert (and (not arg0) (not arg1)) to (not (or (arg0) (arg1))).

     This results in more efficient code for machines without a NOR
     instruction.  Combine will canonicalize to the first form
     which will allow use of NOR instructions provided by the
     backend if they exist.

     If arg0 is derived from the address of an object or function, we may
     be able to fold this expression using the object or function's
     alignment.

         This works because modulus is a power of 2.  If this weren't the
         case, we'd have to replace it by its greatest power-of-2
         divisor: modulus & -modulus.

     Fold (X << C1) & C2 into (X << C1) & (C2 | ((1 << C1) - 1))
          (X >> C1) & C2 into (X >> C1) & (C2 | ~((type) -1 >> C1))
     if the new mask might be further optimized.

             See if more bits can be proven as zero because of
             zero extension.

                     See if we can shorten the right shift.

             For arithmetic shift if sign bit could be set, zerobits
             can contain actually sign bits, so no transformation is
             possible, unless MASK masks them all away.  In that
             case the shift needs to be converted into logical shift.

         ((X << 16) & 0xff00) is (X, 0).

             Only do the transformation if NEWMASK is some integer
             mode's mask.

     Don't touch a floating-point divide by zero unless the mode
     of the constant can represent infinity.

     Optimize A / A to 1.0 if we don't care about
     NaNs or Infinities.  Skip the transformation
     for non-real operands.

     The complex version of the above A / A optimization.

             omit_two_operands will call fold_convert for us.

     (-A) / (-B) -> A / B

     In IEEE floating point, x/1 is not equivalent to x for snans.

     In IEEE floating point, x/-1 is not equivalent to -x for snans.

     If ARG1 is a constant, we can convert this to a multiply by the
     reciprocal.  This does not have the same rounding properties,
     so only do this if -freciprocal-math.  We can actually
     always safely do it if ARG1 is a power of two, but it's hard to
     tell if it is or not in a portable manner.

         Find the reciprocal if optimizing and the result is exact.
         TODO: Complex reciprocal not implemented.

     Convert A/B/C to A/(B*C).

     Convert A/(B/C) to (A/B)*C.

     Convert C1/(X*C2) into (C1/C2)/X.

         Optimize sin(x)/cos(x) as tan(x).

         Optimize cos(x)/sin(x) as 1.0/tan(x).

         Optimize sin(x)/tan(x) as cos(x) if we don't care about
         NaNs or Infinities.

         Optimize tan(x)/sin(x) as 1.0/cos(x) if we don't care about
         NaNs or Infinities.

         Optimize pow(x,c)/x as pow(x,c-1).

         Optimize a/root(b/c) into a*root(c/b).

         Optimize x/expN(y) into x*expN(-y).

         Optimize x/pow(y,z) into x*pow(y,-z).

     Optimize (X & (-A)) / A where A is a power of 2,
     to X >> log2(A)

     Fall through

     Simplify A / (B << N) where A and B are positive and B is
     a power of 2, to A >> (N + log2(B)).

     For unsigned integral types, FLOOR_DIV_EXPR is the same as
     TRUNC_DIV_EXPR.  Rewrite into the latter in this case.

     Fall through

     X / -1 is -X.

     Convert -A / -B to A / B when the type is signed and overflow is
     undefined.

     If arg0 is a multiple of arg1, then rewrite to the fastest div
     operation, EXACT_DIV_EXPR.

     Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
     At one time others generated faster code, it's not clear if they do
     after the last round to changes to the DIV code in expmed.c.

     X % 1 is always zero, but be sure to preserve any side
     effects in X.

     X % 0, return X % 0 unchanged so that we can get the
     proper warnings and errors.

     0 % X is always zero, but be sure to preserve any side
     effects in X.  Place this after checking for X == 0.

     X % -1 is zero.

     X % -C is the same as X % C.

         Avoid this transformation if C is INT_MIN, i.e. C == -C.

     X % -Y is the same as X % Y.

     Optimize TRUNC_MOD_EXPR by a power of two into a BIT_AND_EXPR,
     i.e. "X % C" into "X & (C - 1)", if X and C are positive.

         Also optimize A % (C << N)  where C is a power of 2,
         to A & ((C << N) - 1).

     Optimize -1 >> x for arithmetic right shifts.

     ... fall through ...

     Prefer vector1 << scalar to vector1 << vector2
     if vector2 is uniform.

     Since negative shift count is not well-defined,
     don't try to compute it in the compiler.

     Turn (a OP c1) OP c2 into a OP (c1+c2).

         Deal with a OP (c1 + c2) being undefined but (a OP c1) OP c2
         being well defined.

     Transform (x >> c) << c into x & (-1<<c), or transform (x << c) >> c
     into x & ((unsigned)-1 >> c) for unsigned types.

     Rewrite an LROTATE_EXPR by a constant into an
     RROTATE_EXPR by a new constant.

     If we have a rotate of a bit operation with the rotate count and
     the second operand of the bit operation both constant,
     permute the two operations.

     Two consecutive rotates adding up to the precision of the
     type can be ignored.

     Fold (X & C2) << C1 into (X << C1) & (C2 << C1)
          (X & C2) >> C1 into (X >> C1) & (C2 >> C1)
     if the latter can be further optimized.

     Note that the operands of this must be ints
     and their values must be 0 or 1.
     ("true" is a fixed value perhaps depending on the language.)

     If first arg is constant zero, return it.

     If either arg is constant true, drop it.

         Preserve sequence points.

     If second arg is constant zero, result is zero, but first arg
     must be evaluated.

     Likewise for first arg, but note that only the TRUTH_AND_EXPR
     case will be handled here.

     !X && X is always false.

     X && !X is always false.

     A < X && A + 1 > Y ==> A < X && A >= Y.  Normally A + 1 > Y
     means A >= Y && A != MAX, but in this case we know that
     A < X <= MAX.

     Note that the operands of this must be ints
     and their values must be 0 or true.
     ("true" is a fixed value perhaps depending on the language.)

     If first arg is constant true, return it.

     If either arg is constant zero, drop it.

         Preserve sequence points.

     If second arg is constant true, result is true, but we must
     evaluate first arg.

     Likewise for first arg, but note this only occurs here for
     TRUTH_OR_EXPR.

     !X || X is always true.

     X || !X is always true.

     (X && !Y) || (!X && Y) is X ^ Y

     If the second arg is constant zero, drop it.

     If the second arg is constant true, this is a logical inversion.

     Identical arguments cancel to zero.

     !X ^ X is always true.

     X ^ !X is always true.

     bool_var != 0 becomes bool_var.

     bool_var == 1 becomes bool_var.

     bool_var != 1 becomes !bool_var.

     bool_var == 0 becomes !bool_var.

     !exp != 0 becomes !exp

     If this is an equality comparison of the address of two non-weak,
     unaliased symbols neither of which are extern (since we do not
     have access to attributes for externs), then we know the result.

         We know that we're looking at the address of two
         non-weak, unaliased, static _DECL nodes.

         It is both wasteful and incorrect to call operand_equal_p
         to compare the two ADDR_EXPR nodes.  It is wasteful in that
         all we need to do is test pointer equality for the arguments
         to the two ADDR_EXPR nodes.  It is incorrect to use
         operand_equal_p as that function is NOT equivalent to a
         C equality test.  It can in fact return false for two
         objects which would test as equal using the C equality
         operator.

     If this is an EQ or NE comparison of a constant with a PLUS_EXPR or
     a MINUS_EXPR of a constant, we can convert it into a comparison with
     a revised constant as long as no overflow occurs.

     Similarly for a NEGATE_EXPR.

     Similarly for a BIT_XOR_EXPR;  X ^ C1 == C2 is X == (C1 ^ C2).

     Transform comparisons of the form X +- Y CMP X to Y CMP 0.

     Transform comparisons of the form C - X CMP X if C % 2 == 1.

     If we have X - Y == 0, we can convert that to X == Y and similarly
     for !=.  Don't do this for ordered comparisons due to overflow.

     Convert ABS_EXPR<x> == 0 or ABS_EXPR<x> != 0 to x == 0 or x != 0.

     If this is an EQ or NE comparison with zero and ARG0 is
     (1 << foo) & bar, convert it to (bar >> foo) & 1.  Both require
     two operations, but the latter can be done in one less insn
     on machines that have only two-operand insns or on which a
     constant cannot be the first operand.

     If this is an NE or EQ comparison of zero against the result of a
     signed MOD operation whose second operand is a power of 2, make
     the MOD operation unsigned since it is simpler and equivalent.

     Fold ((X >> C1) & C2) == 0 and ((X >> C1) & C2) != 0 where
     C1 is a valid shift constant, and C2 is a power of two, i.e.
     a single bit.

         Check for a valid shift count.

             If (C2 << C1) doesn't overflow, then ((X >> C1) & C2) != 0
             can be rewritten as (X & (C2 << C1)) != 0.

             Otherwise, for signed (arithmetic) shifts,
             ((X >> C1) & C2) != 0 is rewritten as X < 0, and
             ((X >> C1) & C2) == 0 is rewritten as X >= 0.

             Otherwise, of unsigned (logical) shifts,
             ((X >> C1) & C2) != 0 is rewritten as (X,false), and
             ((X >> C1) & C2) == 0 is rewritten as (X,true).

     If we have (A & C) == C where C is a power of 2, convert this into
     (A & C) != 0.  Similarly for NE_EXPR.

     If we have (A & C) != 0 or (A & C) == 0 and C is the sign
     bit, then fold the expression into A < 0 or A >= 0.

     If we have (A & C) == D where D & ~C != 0, convert this into 0.
     Similarly for NE_EXPR.

     If we have (A | C) == D where C & ~D != 0, convert this into 0.
     Similarly for NE_EXPR.

     If this is a comparison of a field, we may be able to simplify it.

         Handle the constant case even without -O
         to make sure the warnings are given.

     Optimize comparisons of strlen vs zero to a compare of the
     first character of the string vs zero.  To wit,
            strlen(ptr) == 0   =>  *ptr == 0
            strlen(ptr) != 0   =>  *ptr != 0
     Other cases should reduce to one of these two (or a constant)
     due to the return value of strlen being unsigned.

     Fold (X >> C) != 0 into X < 0 if C is one less than the width
     of X.  Similarly fold (X >> C) == 0 into X >= 0.

     (X ^ Y) == 0 becomes X == Y, and (X ^ Y) != 0 becomes X != Y.

     (X ^ Y) == Y becomes X == 0.  We know that Y has no side-effects.

     Likewise (X ^ Y) == X becomes Y == 0.  X has no side-effects.

     (X ^ C1) op C2 can be rewritten as X op (C1 ^ C2).

     Fold (~X & C) == 0 into (X & C) != 0 and (~X & C) != 0 into
     (X & C) == 0 when C is a single bit.

     Fold ((X & C) ^ C) eq/ne 0 into (X & C) ne/eq 0, when the
     constant C is a power of two, i.e. a single bit.

     Likewise, fold ((X ^ C) & C) eq/ne 0 into (X & C) ne/eq 0,
     when is C is a power of two, i.e. a single bit.

     Fold -X op -Y as X op Y, where op is eq/ne.

     Fold (X & C) op (Y & C) as (X ^ Y) & C op 0", and symmetries.

         Optimize (X ^ Z) op (Y ^ Z) as X op Y, and symmetries.
         operand_equal_p guarantees no side-effects so we don't need
         to use omit_one_operand on Z.

         Optimize (X ^ C1) op (Y ^ C2) as (X ^ (C1 ^ C2)) op Y.

     Attempt to simplify equality/inequality comparisons of complex
     values.  Only lower the comparison if the result is known or
     can be simplified to a single scalar comparison.

     Transform comparisons of the form X +- C CMP X.

         (X - c) > X becomes false.

         Likewise (X + c) < X becomes false.

         Convert (X - c) <= X to true.

         Convert (X + c) >= X to true.

             Convert X + c > X and X - c < X to true for integers.

             Convert X + c <= X and X - c >= X to false for integers.

     Comparisons with the highest or lowest possible integer of
     the specified precision will have known values.

               The GE_EXPR and LT_EXPR cases above are not normally
               reached because of previous transformations.

                    We will flip the signedness of the comparison operator
                    associated with the mode of arg1, so the sign bit is
                    specified by this mode.  Check that arg1 is the signed
                    max associated with this sign bit.

                    signed_type does not work on pointer types.

               The following case also applies to X < signed_max+1
               and X >= signed_max+1 because previous transformations.

     If we are comparing an ABS_EXPR with a constant, we can
     convert all the cases into explicit comparisons, but they may
     well not be faster than doing the ABS and one comparison.
     But ABS (X) <= C is a range comparison, which becomes a subtraction
     and a comparison, and is probably faster.

     Convert ABS_EXPR<x> >= 0 to true.

     Convert ABS_EXPR<x> < 0 to false.

     If X is unsigned, convert X < (1 << Y) into X >> Y == 0
     and similarly for >= into !=.

     Similarly for X < (cast) (1 << Y).  But cast can't be narrowing,
     otherwise Y might be >= # of bits in X's type and thus e.g.
     (unsigned char) (1 << Y) for Y 15 might be 0.
     If the cast is widening, then 1 << Y should have unsigned type,
     otherwise if Y is number of bits in the signed shift type minus 1,
     we can't optimize this.  E.g. (unsigned long long) (1 << Y) for Y
     31 might be 0xffffffff80000000.

     If the first operand is NaN, the result is constant.

     If the second operand is NaN, the result is constant.

     Simplify unordered comparison of something with itself.

     Fold (double)float1 CMP (double)float2 into float1 CMP float2.

     When pedantic, a compound expression can be neither an lvalue
     nor an integer constant expression.

     Don't let (0, 0) be null pointer constant.

     An ASSERT_EXPR should never be passed to fold_binary.

Referenced by create_bb(), fold_mult_zconjz(), optimize_stmt(), and rhs_to_tree().

tree fold_binary_to_constant	(	enum	tree_code,
		tree	,
		tree	,
		tree
	)

tree fold_build1_initializer_loc	(	location_t	,
		enum	tree_code,
		tree	,
		tree
	)

References INTEGRAL_TYPE_P, POINTER_TYPE_P, and TREE_TYPE.

tree fold_build1_stat_loc	(	location_t	,
		enum	tree_code,
		tree	,
		tree	MEM_STAT_DECL
	)

tree fold_build2_initializer_loc	(	location_t	,
		enum	tree_code,
		tree	,
		tree	,
		tree
	)

tree fold_build2_stat_loc	(	location_t	,
		enum	tree_code,
		tree	,
		tree	,
		tree	MEM_STAT_DECL
	)

tree fold_build3_initializer_loc	(	location_t	,
		enum	tree_code,
		tree	,
		tree	,
		tree	,
		tree
	)

tree fold_build3_stat_loc	(	location_t	,
		enum	tree_code,
		tree	,
		tree	,
		tree	,
		tree	MEM_STAT_DECL
	)

tree fold_build_call_array_initializer_loc	(	location_t	,
		tree	,
		tree	,
		int	,
		tree *
	)

tree fold_build_call_array_loc	(	location_t	loc,
		tree	type,
		tree	fn,
		int	nargs,
		tree *	argarray
	)

Fold a CALL_EXPR expression of type TYPE with operands FN and NARGS arguments in ARGARRAY, and a null static chain. Return a folded expression if successful. Otherwise, return a CALL_EXPR of type TYPE from the given operands as constructed by build_call_array.

tree fold_build_cleanup_point_expr	(	tree	type,
		tree	expr
	)

static tree fold_build_pointer_plus_hwi_loc ( )

inlinestatic

Build and fold a POINTER_PLUS_EXPR at LOC offsetting PTR by OFF.

Referenced by fold_builtin_4(), fold_builtin_exponent(), fold_builtin_n(), and thunk_adjust().

static tree fold_build_pointer_plus_loc ( )

inlinestatic

Build and fold a POINTER_PLUS_EXPR at LOC offsetting PTR by OFF.

Referenced by fold_builtin_fputs().

tree fold_builtin_call_array	(	location_t	loc,
		tree	type,
		tree	fn,
		int	n,
		tree *	argarray
	)

Construct a CALL_EXPR with type TYPE with FN as the function expression. N arguments are passed in the array ARGARRAY.

       If last argument is __builtin_va_arg_pack (), arguments to this
       function are not finalized yet.  Defer folding until they are.

           First try the transformations that don't require consing up
           an exp.

       If we got this far, we need to build an exp.

tree fold_builtin_fputs	(	location_t	loc,
		tree	arg0,
		tree	arg1,
		bool	ignore,
		bool	unlocked,
		tree	len
	)

Fold a call to the fputs builtin. ARG0 and ARG1 are the arguments to the call. IGNORE is true if the value returned by the builtin will be ignored. UNLOCKED is true is true if this actually a call to fputs_unlocked. If LEN in non-NULL, it represents the known length of the string. Return NULL_TREE if no simplification was possible.

 If we're using an unlocked function, assume the other unlocked
 functions exist explicitly.

 If the return value is used, don't do the transformation.

 Verify the arguments in the original call.

 Get the length of the string passed to fputs.  If the length
 can't be determined, punt.

     FALLTHROUGH

       If optimizing for size keep fputs.

       New argument list transforming fputs(string, stream) to
       fwrite(string, 1, len, stream).

References build_call_expr_loc(), builtin_decl_explicit(), fold_build_pointer_plus_loc(), fold_convert_loc(), host_integerp(), integer_all_onesp(), NULL_TREE, omit_one_operand_loc(), operand_equal_p(), tree_int_cst_lt(), TREE_TYPE, and validate_arg().

Referenced by fold_builtin_classify().

tree fold_builtin_memory_chk	(	location_t	loc,
		tree	fndecl,
		tree	dest,
		tree	src,
		tree	len,
		tree	size,
		tree	maxlen,
		bool	ignore,
		enum built_in_function	fcode
	)

Fold a call to the __mem{cpy,pcpy,move,set}_chk builtin. DEST, SRC, LEN, and SIZE are the arguments to the call. IGNORE is true, if return value can be ignored. FCODE is the BUILT_IN_* code of the builtin. If MAXLEN is not NULL, it is maximum length passed as third argument.

 If SRC and DEST are the same (and not volatile), return DEST
 (resp. DEST+LEN for __mempcpy_chk).

         If LEN is not constant, try MAXLEN too.
         For MAXLEN only allow optimizing into non-_ocs function
         if SIZE is >= MAXLEN, never convert to __ocs_fail ().

                 (void) __mempcpy_chk () can be optimized into
                 (void) __memcpy_chk ().

 If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
 mem{cpy,pcpy,move,set} is available.

bool fold_builtin_next_arg	(	tree	,
		bool
	)

tree fold_builtin_snprintf_chk	(	location_t	loc,
		tree	exp,
		tree	maxlen,
		enum built_in_function	fcode
	)

Fold a call EXP to {,v}snprintf. Return NULL_TREE if a normal call should be emitted rather than expanding the function inline. FCODE is either BUILT_IN_SNPRINTF_CHK or BUILT_IN_VSNPRINTF_CHK. If MAXLEN is not NULL, it is maximum length passed as second argument.

References real_format::p, real_isfinite(), REAL_MODE_FORMAT, REAL_VALUE_TYPE, real_format::round_towards_zero, TREE_IMAGPART, TREE_REAL_CST_PTR, TREE_REALPART, TREE_TYPE, and TYPE_MODE.

tree fold_builtin_strcpy	(	location_t	,
		tree	,
		tree	,
		tree	,
		tree
	)

tree fold_builtin_strncpy	(	location_t	loc,
		tree	fndecl,
		tree	dest,
		tree	src,
		tree	len,
		tree	slen
	)

Fold function call to builtin strncpy with arguments DEST, SRC, and LEN. If SLEN is not NULL, it represents the length of the source string. Return NULL_TREE if no simplification can be made.

 If the LEN parameter is zero, return DEST.

 We can't compare slen with len as constants below if len is not a
 constant.

 Now, we must be passed a constant src ptr parameter.

 We do not support simplification of this case, though we do
 support it when expanding trees into RTL.

 FIXME: generate a call to __builtin_memset.

 OK transform into builtin memcpy.

References build_int_cst(), build_real(), fold_convert_loc(), integer_type_node, NULL_TREE, REAL_EXP, real_inf(), real_isinf(), real_isneg(), REAL_MODE_FORMAT, REAL_VALUE_TYPE, rvc_inf, rvc_nan, rvc_normal, rvc_zero, STRIP_NOPS, TREE_CODE, TREE_OVERFLOW, TREE_REAL_CST_PTR, TREE_TYPE, TYPE_MODE, and validate_arg().

tree fold_builtin_stxcpy_chk	(	location_t	loc,
		tree	fndecl,
		tree	dest,
		tree	src,
		tree	size,
		tree	maxlen,
		bool	ignore,
		enum built_in_function	fcode
	)

Fold a call to the __st[rp]cpy_chk builtin. DEST, SRC, and SIZE are the arguments to the call. IGNORE is true if return value can be ignored. FCODE is the BUILT_IN_* code of the builtin. If MAXLEN is not NULL, it is maximum length of strings passed as second argument.

 If SRC and DEST are the same (and not volatile), return DEST.

         If LEN is not constant, try MAXLEN too.
         For MAXLEN only allow optimizing into non-_ocs function
         if SIZE is >= MAXLEN, never convert to __ocs_fail ().

                 If return value of __stpcpy_chk is ignored,
                 optimize into __strcpy_chk.

             If c_strlen returned something, but not a constant,
             transform __strcpy_chk into __memcpy_chk.

 If __builtin_st{r,p}cpy_chk is used, assume st{r,p}cpy is available.

tree fold_builtin_stxncpy_chk	(	location_t	loc,
		tree	dest,
		tree	src,
		tree	len,
		tree	size,
		tree	maxlen,
		bool	ignore,
		enum built_in_function	fcode
	)

Fold a call to the __st{r,p}ncpy_chk builtin. DEST, SRC, LEN, and SIZE are the arguments to the call. If MAXLEN is not NULL, it is maximum length passed as third argument. IGNORE is true if return value can be ignored. FCODE is the BUILT_IN_* code of the builtin.

      If return value of __stpncpy_chk is ignored,
      optimize into __strncpy_chk.

         If LEN is not constant, try MAXLEN too.
         For MAXLEN only allow optimizing into non-_ocs function
         if SIZE is >= MAXLEN, never convert to __ocs_fail ().

 If __builtin_st{r,p}ncpy_chk is used, assume st{r,p}ncpy is available.

tree fold_call_expr	(	location_t	,
		tree	,
		bool
	)

tree fold_call_stmt	(	gimple	,
		bool
	)

tree fold_convert_loc	(	location_t	,
		tree	,
		tree
	)

bool fold_convertible_p	(	const_tree	,
		const_tree
	)

void fold_defer_overflow_warnings ( void )

Start deferring overflow warnings. We could use a stack here to permit nested calls, but at present it is not necessary.

References fold_deferring_overflow_warnings, gcc_assert, and NULL.

Referenced by bit_value_binop(), create_bb(), and rhs_to_tree().

bool fold_deferring_overflow_warnings_p ( void )

Whether we are deferring overflow warnings.

tree fold_fma	(	location_t	loc,
		tree	type,
		tree	arg0,
		tree	arg1,
		tree	arg2
	)

Fold a fma operation with arguments ARG[012].

References NULL_TREE, TREE_CODE, and TREE_TYPE.

Referenced by fold_builtin_strcpy().

tree fold_ignored_result ( tree )

tree fold_indirect_ref_1	(	location_t	,
		tree	,
		tree
	)

tree fold_indirect_ref_loc	(	location_t	,
		tree
	)

tree fold_read_from_constant_string ( tree )

bool fold_real_zero_addition_p	(	const_tree	,
		const_tree	,
		int
	)

tree fold_single_bit_test	(	location_t	loc,
		enum tree_code	code,
		tree	arg0,
		tree	arg1,
		tree	result_type
	)

If CODE with arguments ARG0 and ARG1 represents a single bit equality/inequality test, then return a simplified form of the test using shifts and logical operations. Otherwise return NULL. TYPE is the desired result type.

 If this is testing a single bit, we can optimize the test.

     First, see if we can fold the single bit test into a sign-bit
     test.

     Otherwise we have (A & C) != 0 where C is a single bit,
     convert that into ((A >> C2) & 1).  Where C2 = log2(C).
     Similarly for (A & C) == 0.

     If INNER is a right shift of a constant and it plus BITNUM does
     not overflow, adjust BITNUM and INNER.

     If we are going to be able to omit the AND below, we must do our
     operations as unsigned.  If we must use the AND, we have a choice.
     Normally unsigned is faster, but for some machines signed is.

     Put the AND last so it can combine with more things.

     Make sure to return the proper type.

tree fold_strip_sign_ops ( tree )

tree fold_ternary_loc	(	location_t	loc,
		enum tree_code	code,
		tree	type,
		tree	op0,
		tree	op1,
		tree	op2
	)

Fold a ternary expression of code CODE and type TYPE with operands OP0, OP1, and OP2. Return the folded expression if folding is successful. Otherwise, return NULL_TREE.

 Strip any conversions that don't change the mode.  This is safe
 for every expression, except for a comparison expression because
 its signedness is derived from its operands.  So, in the latter
 case, only strip conversions that don't change the signedness.

 Note that this is done as an internal manipulation within the
 constant folder, in order to find the simplest representation of
 the arguments so that their form can be studied.  In any cases,
 the appropriate type conversions should be put back in the tree
 that will get out of the constant folder.

     Pedantic ANSI C says that a conditional expression is never an lvalue,
     so all simple results must be passed through pedantic_non_lvalue.

         Only optimize constant conditions when the selected branch
         has the same type as the COND_EXPR.  This avoids optimizing
         away "c ? x : throw", where the throw has a void type.
         Avoid throwing away that operand which contains label.

     If we have A op B ? A : C, we may be able to convert this to a
     simpler expression, depending on the operation and the values
     of B and C.  Signed zeros prevent all of these transformations,
     for reasons given above each one.

     Also try swapping the arguments and inverting the conditional.

     If the second operand is simpler than the third, swap them
     since that produces better jump optimization results.

         See if this can be inverted.  If it can't, possibly because
         it was a floating-point inequality comparison, don't do
         anything.

     Convert A ? 1 : 0 to simply A.

         If we try to convert OP0 to our type, the
         call to fold will try to move the conversion inside
         a COND, which will recurse.  In that case, the COND_EXPR
         is probably the best choice, so leave it alone.

     Convert A ? 0 : 1 to !A.  This prefers the use of NOT_EXPR
     over COND_EXPR in cases such as floating point comparisons.

     A < 0 ? <sign bit of A> : 0 is simply (A & <sign bit of A>).

         sign_bit_p looks through both zero and sign extensions,
         but for this optimization only sign extensions are
         usable.

         sign_bit_p only checks ARG1 bits within A's precision.
         If <sign bit of A> has wider type than A, bits outside
         of A's precision in <sign bit of A> need to be checked.
         If they are all 0, this optimization needs to be done
         in unsigned A's type, if they are all 1 in signed A's type,
         otherwise this can't be done.

     (A >> N) & 1 ? (1 << N) : 0 is simply A & (1 << N).  A & 1 was
     already handled above.

     A & N ? N : 0 is simply A & N if N is a power of two.  This
     is probably obsolete because the first operand should be a
     truth value (that's why we have the two cases above), but let's
     leave it in until we can confirm this for all front-ends.

     Disable the transformations below for vectors, since
     fold_binary_op_with_conditional_arg may undo them immediately,
     yielding an infinite loop.

     Convert A ? B : 0 into A && B if A and B are truth values.

     Convert A ? B : 1 into !A || B if A and B are truth values.

         Only perform transformation if ARG0 is easily inverted.

     Convert A ? 0 : B into !A && B if A and B are truth values.

         Only perform transformation if ARG0 is easily inverted.

     Convert A ? 1 : B into A || B if A and B are truth values.

     CALL_EXPRs used to be ternary exprs.  Catch any mistaken uses
     of fold_ternary on them.

             Constructor elements can be subvectors.

             We keep an exact subset of the constructor elements.

             The bitfield references a single constructor element.

     A bit-field-ref that referenced the full argument can be stripped.

     On constants we can use native encode/interpret to constant
     fold (nearly) all BIT_FIELD_REFs.

         This limitation should not be necessary, we just need to
         round this up to mode size.

         Need bit-shifting of the buffer to relax the following.

         ???  We cannot tell native_encode_expr to start at
         some random byte only.  So limit us to a reasonable amount
         of work.

     For integers we can decompose the FMA if possible.

tree fold_unary_ignore_overflow_loc	(	location_t	loc,
		enum tree_code	code,
		tree	type,
		tree	op0
	)

If the operation was a conversion do not mark a resulting constant with TREE_OVERFLOW if the original constant was not. These conversions have implementation defined behavior and retaining the TREE_OVERFLOW flag here would confuse later passes such as VRP.

References get_inner_reference(), NULL_TREE, TREE_CODE, and TREE_OPERAND.

tree fold_unary_loc	(	location_t	,
		enum	tree_code,
		tree	,
		tree
	)

tree fold_unary_to_constant	(	enum	tree_code,
		tree	,
		tree
	)

void fold_undefer_and_ignore_overflow_warnings ( void )

Stop deferring overflow warnings, ignoring any deferred warnings.

References NULL.

void fold_undefer_overflow_warnings	(	bool	,
		const_gimple	,
		int
	)

tree force_fit_type_double	(	tree	type,
		double_int	cst,
		int	overflowable,
		bool	overflowed
	)

We force the double_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 double_int. The node is shared if no overflow flags are set.

If we need to set overflow flags, return a new unshared node.

 Else build a shared node.

Referenced by native_interpret_vector(), and tree_unary_nonnegative_warnv_p().

void free_temp_slots ( void )

Free all temporaries used so far. This is normally called at the end of generating code for a statement.

References crtl, initial_value_struct::entries, GGC_RESIZEVEC, has_hard_reg_initial_val(), initial_value_struct::max_entries, and initial_value_struct::num_entries.

Referenced by expand_asm_stmt().

static tree function_args_iter_cond ( )

inlinestatic

Return the next argument if there are more arguments to handle, otherwise return NULL.

static tree* function_args_iter_cond_ptr ( )

inlinestatic

Return a pointer that holds the next argument if there are more arguments to handle, otherwise return NULL.

static void function_args_iter_init ( )

inlinestatic

Initialize the iterator I with arguments from function FNDECL

static void function_args_iter_next ( )

inlinestatic

Advance to the next argument.

void generate_setjmp_warnings ( void )

Generate warning messages for variables live across setjmp.

References BLOCK_NUMBER, DECL_INITIAL, get_block_vector(), SDB_DEBUG, and XCOFF_DEBUG.

Referenced by split_live_ranges_for_shrink_wrap().

tree get_attribute_name ( const_tree )

tree get_attribute_namespace ( const_tree )

tree get_base_address ( tree t )

In gimple.c.

tree get_binfo_at_offset	(	tree	,
		HOST_WIDE_INT	,
		tree
	)

tree get_callee_fndecl ( const_tree )

tree get_containing_scope ( const_tree )

Given a DECL or TYPE, return the scope in which it was declared, or NUL_TREE if there is no containing scope.

tree get_file_function_name ( const char * )

tree get_identifier ( const char * )

Return the (unique) IDENTIFIER_NODE node for a given name. The name is supplied as a char *.

tree get_identifier_with_length	(	const char *	,
		size_t
	)

Identical to get_identifier, except that the length is assumed known.

tree get_inner_reference	(	tree	exp,
		HOST_WIDE_INT *	pbitsize,
		HOST_WIDE_INT *	pbitpos,
		tree *	poffset,
		enum machine_mode *	pmode,
		int *	punsignedp,
		int *	pvolatilep,
		bool	keep_aligning
	)

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, and *PUNSIGNEDP to the signedness 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.

If KEEP_ALIGNING is true and the target is STRICT_ALIGNMENT, we don't look through nodes that serve as markers of a greater alignment than the one that can be deduced from the expression. These nodes make it possible for front-ends to prevent temporaries from being created by the middle-end on alignment considerations. For that purpose, the normal operating mode at high-level is to always pass FALSE so that the ultimate containing object is really returned; moreover, the associated predicate handled_component_p will always return TRUE on these nodes, thus indicating that they are essentially handled by get_inner_reference. TRUE should only be passed when the caller is scanning the expression in order to build another representation and specifically knows how to handle these nodes; as such, this is the normal operating mode in the RTL expanders.

 First get the mode, signedness, and size.  We do this from just the
 outermost expression.

       Volatile bitfields should be accessed in the mode of the
         field's type, not the mode computed based on the bit
         size.

     For vector types, with the correct size of access, use the mode of
     inner type.

 Compute cumulative bit-offset for nested component-refs and array-refs,
 and find the ultimate containing object.

           If this field hasn't been filled in yet, don't go past it.
           This should only happen when folding expressions made during
           type construction.

           ??? Right now we don't do anything with DECL_OFFSET_ALIGN.

           We assume all arrays have sizes that are a multiple of a byte.
           First subtract the lower bound, if any, in the type of the
           index, then convert to sizetype and multiply by the size of
           the array element.

         Hand back the decl for MEM[&decl, off].

     If any reference in the chain is volatile, the effect is volatile.

 If OFFSET is constant, see if we can return the whole thing as a
 constant bit position.  Make sure to handle overflow during
 this conversion.

 Otherwise, split it up.

     Avoid returning a negative bitpos as this may wreak havoc later.

         TEM is the bitpos rounded to BITS_PER_UNIT towards -Inf.
         Subtract it to BIT_OFFSET and add it (scaled) to OFFSET.

 We can use BLKmode for a byte-aligned BLKmode bitfield.

References emit_move_insn(), gen_reg_rtx(), and GET_MODE.

Referenced by delegitimize_mem_from_attrs(), fold_unary_ignore_overflow_loc(), invert_truthvalue_loc(), native_interpret_real(), and tree_to_aff_combination().

const char* get_name ( tree )

tree get_narrower	(	tree	,
		int *
	)

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.

unsigned int get_object_alignment ( tree )

bool get_object_alignment_1	(	tree	exp,
		unsigned int *	alignp,
		unsigned HOST_WIDE_INT *	bitposp
	)

For a memory reference expression EXP compute values M and N such that M divides (&EXP - N) and such that N < M. If these numbers can be determined, store M in alignp and N in *BITPOSP and return true. Otherwise return false and store BITS_PER_UNIT to *alignp and any bit-offset to *bitposp.

unsigned int get_pointer_alignment ( tree )

bool get_pointer_alignment_1	(	tree	exp,
		unsigned int *	alignp,
		unsigned HOST_WIDE_INT *	bitposp
	)

For a pointer valued expression EXP compute values M and N such that M divides (EXP - N) and such that N < M. If these numbers can be determined, store M in alignp and N in *BITPOSP and return true. Return false if the results are just a conservative approximation.

If EXP is not a pointer, false is returned too.

We cannot really tell whether this result is an approximation.

tree get_qualified_type	(	tree	,
		int
	)

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.

const char* get_tree_code_name ( enum tree_code )

void get_type_static_bounds	(	const_tree	,
		mpz_t	,
		mpz_t
	)

tree get_unwidened	(	tree	,
		tree
	)

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.

bool gimple_alloca_call_p ( const_gimple )

tree gimple_fold_builtin_snprintf_chk	(	gimple	stmt,
		tree	maxlen,
		enum built_in_function	fcode
	)

Fold a call STMT to {,v}snprintf. Return NULL_TREE if a normal call should be emitted rather than expanding the function inline. FCODE is either BUILT_IN_SNPRINTF_CHK or BUILT_IN_VSNPRINTF_CHK. If MAXLEN is not NULL, it is maximum length passed as second argument.

gimple_seq gimplify_parameters ( void )

Gimplify the parameter list for current_function_decl. This involves evaluating SAVE_EXPRs of variable sized parameters and generating code to implement callee-copies reference parameters. Returns a sequence of statements to add to the beginning of the function.

     Extract the type of PARM; adjust it according to ABI.

     Early out for errors and void parameters.

     Update info on where next arg arrives in registers.

     ??? Once upon a time variable_size stuffed parameter list
     SAVE_EXPRs (amongst others) onto a pending sizes list.  This
     turned out to be less than manageable in the gimple world.
     Now we have to hunt them down ourselves.

             For constant-sized objects, this is trivial; for
             variable-sized objects, we have to play games.

                 If PARM was addressable, move that flag over
                 to the local copy, as its address will be taken,
                 not the PARMs.  Keep the parms address taken
                 as we'll query that flag during gimplification.

                 The call has been built for a variable-sized object.

static bool handled_component_p ( )

inlinestatic

Return true if T is an expression that get_inner_reference handles.

Referenced by alias_sets_must_conflict_p(), compute_subscript_distance(), constant_after_peeling(), dump_gimple_statistics(), generic_expr_could_trap_p(), ipa_prop_write_all_agg_replacement(), is_gimple_variable(), loop_has_blocks_with_irreducible_flag(), same_type_for_tbaa(), ssa_prop_fini(), sub_costs(), and verify_phi_args().

unsigned HOST_WIDE_INT highest_pow2_factor ( const_tree )

int host_integerp	(	const_tree	,
		int
	)

bool in_array_bounds_p ( tree )

void init_attributes ( void )

Initialize attribute tables, and make some sanity checks if –enable-checking.

Translate NULL pointers to pointers to the empty table.

   Put all the GNU attributes into the "gnu" namespace.

static void init_call_expr_arg_iterator ( )

inlinestatic

Initialize the abstract argument list iterator object ITER with the arguments from CALL_EXPR node EXP.

static void init_const_call_expr_arg_iterator ( )

inlinestatic

void init_dummy_function_start ( void )

Initialize the rtl expansion mechanism so that we can do simple things like generate sequences. This is used to provide a context during global initialization of some passes. You must call expand_dummy_function_end to exit this context.

References DECL_RESULT, DECL_RTL, DECL_RTL_SET_P, diddle_return_value(), do_clobber_return_reg(), REG_P, and REGNO.

void init_function_start ( tree )

void init_inline_once ( void )

In tree-inline.c.

Initializes weights used by estimate_num_insns.

Estimating time for call is difficult, since we have no idea what the called function does. In the current uses of eni_time_weights, underestimating the cost does less harm than overestimating it, so we choose a rather small value here.

References copy_body_data::block, BLOCK_VARS, and TREE_CHAIN.

void init_object_sizes ( void )

In tree-object-size.c.

Initialize data structures for the object size computation.

References BUILT_IN_NORMAL, DECL_BUILT_IN_CLASS, DECL_FUNCTION_CODE, FOR_EACH_BB, gimple_call_fndecl(), gsi_end_p(), gsi_next(), gsi_start_bb(), gsi_stmt(), and init_object_sizes().

Referenced by init_object_sizes().

void init_temp_slots ( void )

Initialize temporary slots.

We have not allocated any temporaries yet.

 Set up the table to map addresses to temp slots.

Referenced by blocks_nreverse().

void init_tree_optimization_optabs ( tree )

void init_ttree ( void )

Init tree.c.

Initialize the hash table of types.

 Initialize the tree_contains_struct array.

void initialize_sizetypes ( void )

Initialize sizetypes so layout_type can use them.

 Get sizetypes precision from the SIZE_TYPE target macro.

 Create stubs for sizetype and bitsizetype so we can create constants.

 Now layout both types manually.

 Create the signed variants of *sizetype.

bool initializer_constant_valid_for_bitfield_p ( tree )

Return true if VALUE is a valid constant-valued expression for use in initializing a static bit-field; one that can be an element of a "constant" initializer.

tree initializer_constant_valid_p	(	tree	,
		tree
	)

Return nonzero if VALUE is a valid constant-valued expression for use in initializing a static variable; one that can be an element of a "constant" initializer.

Return null_pointer_node if the value is absolute; if it is relocatable, return the variable that determines the relocation. We assume that VALUE has been folded as much as possible; therefore, we do not need to check for such things as arithmetic-combinations of integers.

Referenced by insert_float(), and optimize_compound_literals_in_ctor().

bool initializer_zerop ( const_tree )

Given an initializer INIT, return TRUE if INIT is zero or some aggregate of zeros. Otherwise return FALSE.

static bool inlined_function_outer_scope_p ( )

inlinestatic

We set BLOCK_SOURCE_LOCATION only to inlined function entry points.

HOST_WIDE_INT int_bit_position ( const_tree )

HOST_WIDE_INT int_byte_position ( const_tree )

tree int_const_binop	(	enum	tree_code,
		const_tree	,
		const_tree
	)

HOST_WIDE_INT int_cst_value ( const_tree )

bool int_fits_type_p	(	const_tree	,
		const_tree
	)

HOST_WIDE_INT int_size_in_bytes ( const_tree )

int integer_all_onesp ( const_tree )

integer_all_onesp (tree x) is nonzero if X is an integer constant all of whose significant bits are 1.

int integer_minus_onep ( const_tree )

integer_minus_onep (tree x) is nonzero if X is an integer constant of value -1.

int integer_nonzerop ( const_tree )

integer_nonzerop (tree x) is nonzero if X is an integer constant with a nonzero value.

int integer_onep ( const_tree )

integer_onep (tree x) is nonzero if X is an integer constant of value 1.

int integer_pow2p ( const_tree )

integer_pow2p (tree x) is nonzero is X is an integer constant with exactly one bit 1.

int integer_zerop ( const_tree )

integer_zerop (tree x) is nonzero if X is an integer constant of value 0.

void internal_reference_types ( void )

Show that REFERENCE_TYPES are internal and should use address_mode. Called only by front end.

References TREE_CONSTANT.

enum tree_code invert_tree_comparison	(	enum	tree_code,
		bool
	)

tree invert_truthvalue_loc	(	location_t	,
		tree
	)

static bool is_attribute_p ( )

inlinestatic

Given an identifier node IDENT and a string ATTR_NAME, return true if the identifier node is a valid attribute name for the string. ATTR_NAME must be in the form 'text' (not 'text'). IDENT could be the identifier for 'text' or for 'text'.

Do the strlen() before calling the out-of-line implementation. In most cases attr_name is a string constant, and the compiler will optimize the strlen() away.

Referenced by build_fn_decl().

bool is_builtin_fn ( tree )

static bool is_global_var ( )

inlinestatic

Return true if T (assumed to be a DECL) is a global variable. A variable is considered global if its storage is not automatic.

Referenced by lower_reduction_clauses(), make_constraint_from(), non_rewritable_mem_ref_base(), omp_copy_decl_2(), omp_is_private(), omp_max_vf(), and warn_uninitialized_vars().

bool is_inexpensive_builtin ( tree )

static bool is_lang_specific ( )

inlinestatic

Return true if tree node T is a language-specific node.

bool is_simple_builtin ( tree )

bool is_tm_ending_fndecl ( tree )

bool is_tm_may_cancel_outer ( tree )

bool is_tm_pure ( const_tree )

bool is_tm_safe ( const_tree )

static bool is_tm_safe_or_pure ( )

inlinestatic

bool is_typedef_decl ( tree x )

hashval_t iterative_hash_expr	(	const_tree	,
		hashval_t
	)

hashval_t iterative_hash_exprs_commutative	(	const_tree	t1,
		const_tree	t2,
		hashval_t	val
	)

Generate a hash value for a pair of expressions. This can be used iteratively by passing a previous result as the VAL argument.

The same hash value is always returned for a given pair of expressions, regardless of the order in which they are presented. This is useful in hashing the operands of commutative functions.

References chainon(), nreverse(), NULL_TREE, TREE_CHAIN, tree_cons, TREE_VALUE, TYPE_CANONICAL, and void_list_node.

hashval_t iterative_hash_hashval_t	(	hashval_t	,
		hashval_t
	)

hashval_t iterative_hash_host_wide_int	(	HOST_WIDE_INT	,
		hashval_t
	)

void layout_decl	(	tree	,
		unsigned
	)

Given a VAR_DECL, PARM_DECL, RESULT_DECL or FIELD_DECL node, calculates the DECL_SIZE, DECL_SIZE_UNIT, DECL_ALIGN and DECL_MODE fields. Call this only once for any given decl node.

Second argument is the boundary that this field can be assumed to be starting at (in bits). Zero means it can be assumed aligned on any boundary that may be needed.

void layout_type ( tree )

Given a ..._TYPE node, calculate the TYPE_SIZE, TYPE_SIZE_UNIT, TYPE_ALIGN and TYPE_MODE fields. If called more than once on one node, does nothing except for the first time.

tree lhd_gcc_personality ( void )

Return the GCC personality function decl.

bool list_equal_p	(	const_tree	,
		const_tree
	)

int list_length ( const_tree )

Returns the length of a chain of nodes (number of chain pointers to follow before reaching a null pointer).

static tree lookup_attribute ( )

inlinestatic

Given an attribute name ATTR_NAME and a list of attributes LIST, return a pointer to the attribute's list element if the attribute is part of the list, or NULL_TREE if not found. If the attribute appears more than once, this only returns the first occurrence; the TREE_CHAIN of the return value should be passed back in if further occurrences are wanted. ATTR_NAME must be in the form 'text' (not 'text').

In most cases, list is NULL_TREE.

   Do the strlen() before calling the out-of-line implementation.
   In most cases attr_name is a string constant, and the compiler
   will optimize the strlen() away.

Referenced by apply_return_prediction(), build_fn_decl(), cgraph_create_empty_node(), decl_attributes(), dump_possible_polymorphic_call_targets(), iterative_hash_hashval_t(), output_constructor_bitfield(), process_common_attributes(), simple_cst_equal(), stmt_overflow_infinity(), and varpool_output_variables().

struct attribute_spec* lookup_attribute_spec ( const_tree )

read

In attribs.c.

struct attribute_spec* lookup_scoped_attribute_spec	(	const_tree	,
		const_tree
	)

read

tree lower_bound_in_type	(	tree	,
		tree
	)

tree make_accum_type	(	int	,
		int	,
		int
	)

void make_decl_one_only	(	tree	,
		tree
	)

void make_decl_rtl ( tree )

rtx make_decl_rtl_for_debug ( tree )

tree make_fract_type	(	int	,
		int	,
		int
	)

Construct various nodes representing fract or accum data types.

tree make_node_stat ( enum tree_code MEM_STAT_DECL )

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.

tree make_range	(	tree	exp,
		int *	pin_p,
		tree *	plow,
		tree *	phigh,
		bool *	strict_overflow_p
	)

Given EXP, a logical expression, set the range it is testing into variables denoted by PIN_P, PLOW, and PHIGH. Return the expression actually being tested. *PLOW and *PHIGH will be made of the same type as the returned expression. If EXP is not a comparison, we will most likely not be returning a useful value and range. Set *STRICT_OVERFLOW_P to true if the return value is only valid because signed overflow is undefined; otherwise, do not change *STRICT_OVERFLOW_P.

Start with simply saying "EXP != 0" and then look at the code of EXP and see if we can refine the range. Some of the cases below may not happen, but it doesn't seem worth worrying about this. We "continue" the outer loop when we've changed something; otherwise we "break" the switch, which will "break" the while.

 If EXP is a constant, we can evaluate whether this is true or false.

tree make_range_step	(	location_t	loc,
		enum tree_code	code,
		tree	arg0,
		tree	arg1,
		tree	exp_type,
		tree *	p_low,
		tree *	p_high,
		int *	p_in_p,
		bool *	strict_overflow_p
	)

Helper routine for make_range. Perform one step for it, return new expression if the loop should continue or NULL_TREE if it should stop.

     We can only do something if the range is testing for zero.

     We can only do something if the range is testing for zero
     and if the second operand is an integer constant.  Note that
     saying something is "in" the range we make is done by
     complementing IN_P since it will set in the initial case of
     being not equal to zero; "out" is leaving it alone.

     If this is an unsigned comparison, we also know that EXP is
     greater than or equal to zero.  We base the range tests we make
     on that fact, so we record it here so we can parse existing
     range tests.  We test arg0_type since often the return type
     of, e.g. EQ_EXPR, is boolean.

         If the high bound is missing, but we have a nonzero low
         bound, reverse the range so it goes from zero to the low bound
         minus 1.

     If flag_wrapv and ARG0_TYPE is signed, make sure
     low and high are non-NULL, then normalize will DTRT.

     (-x) IN [a,b] -> x in [-b, -a]

     ~ X -> -X - 1

     If flag_wrapv and ARG0_TYPE is signed, then we cannot
     move a constant to the other side.

     If EXP is signed, any overflow in the computation is undefined,
     so we don't worry about it so long as our computations on
     the bounds don't overflow.  For unsigned, overflow is defined
     and this is exactly the right thing.

       Check for an unsigned range which has wrapped around the maximum
       value thus making n_high < n_low, and normalize it.

           If the range is of the form +/- [ x+1, x ], we won't
           be able to normalize it.  But then, it represents the
           whole range or the empty set, so make it
           +/- [ -, - ].

     If we're converting arg0 from an unsigned type, to exp,
     a signed type,  we will be doing the comparison as unsigned.
     The tests above have already verified that LOW and HIGH
     are both positive.

     So we have to ensure that we will handle large unsigned
     values the same way that the current signed bounds treat
     negative values.

         For fixed-point modes, we need to pass the saturating flag
         as the 2nd parameter.

         A range without an upper bound is, naturally, unbounded.
         Since convert would have cropped a very large value, use
         the max value for the destination type.

         If the low bound is specified, "and" the range with the
         range for which the original unsigned value will be
         positive.

             Otherwise, "or" the range with the range of the input
             that will be interpreted as negative.

tree make_signed_type ( int )

Construct various nodes representing data types.

tree make_tree	(	tree	,
		rtx
	)

From expmed.c. 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.

tree make_tree_binfo_stat ( unsigned MEM_STAT_DECL )

Make a BINFO.

tree make_tree_vec_stat ( int MEM_STAT_DECL )

Make a TREE_VEC.

tree make_unsigned_type ( int )

tree make_vector_stat ( unsigned MEM_STAT_DECL )

void mark_addressable ( tree )

void mark_decl_referenced ( tree )

void mark_referenced ( tree )

tree mathfn_built_in	(	tree	,
		enum built_in_function	fn
	)

HOST_WIDE_INT max_int_size_in_bytes ( const_tree )

static bool may_be_aliased ( )

inlinestatic

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.

bool may_negate_without_overflow_p ( const_tree )

tree maybe_get_identifier ( const char * )

If an identifier with the name TEXT (a null-terminated string) has previously been referred to, return that node; otherwise return NULL_TREE.

double_int mem_ref_offset ( const_tree )

tree merge_attributes	(	tree	,
		tree
	)

Given two attributes lists, return a list of their union.

tree merge_decl_attributes	(	tree	,
		tree
	)

Default versions of target-overridable functions.

bool merge_ranges	(	int *	pin_p,
		tree *	plow,
		tree *	phigh,
		int	in0_p,
		tree	low0,
		tree	high0,
		int	in1_p,
		tree	low1,
		tree	high1
	)

Given two ranges, see if we can merge them into one. Return 1 if we can, 0 if we can't. Set the output range into the specified parameters.

 Make range 0 be the range that starts first, or ends last if they
 start at the same value.  Swap them if it isn't.

 Now flag two cases, whether the ranges are disjoint or whether the
 second range is totally subsumed in the first.  Note that the tests
 below are simplified by the ones above.

 We now have four cases, depending on whether we are including or
 excluding the two ranges.

     If they don't overlap, the result is false.  If the second range
     is a subset it is the result.  Otherwise, the range is from the start
     of the second to the end of the first.

     If they don't overlap, the result is the first range.  If they are
     equal, the result is false.  If the second range is a subset of the
     first, and the ranges begin at the same place, we go from just after
     the end of the second range to the end of the first.  If the second
     range is not a subset of the first, or if it is a subset and both
     ranges end at the same place, the range starts at the start of the
     first range and ends just before the second range.
     Otherwise, we can't describe this as a single range.

             We are in the weird situation where high0 > high1 but
             high1 has no successor.  Punt.

             low0 < low1 but low1 has no predecessor.  Punt.

     If they don't overlap, the result is the second range.  If the second
     is a subset of the first, the result is false.  Otherwise,
     the range starts just after the first range and ends at the
     end of the second.

             high1 > high0 but high0 has no successor.  Punt.

     The case where we are excluding both ranges.  Here the complex case
     is if they don't overlap.  In that case, the only time we have a
     range is if they are adjacent.  If the second is a subset of the
     first, the result is the first.  Otherwise, the range to exclude
     starts at the beginning of the first range and ends at the end of the
     second.

             Canonicalize - [min, x] into - [-, x].

                   FALLTHROUGH

             Canonicalize - [x, max] into - [x, -].

                   FALLTHROUGH

             The ranges might be also adjacent between the maximum and
             minimum values of the given type.  For
             - [{min,-}, x] and - [y, {max,-}] ranges where x + 1 < y
             return + [x + 1, y - 1].

References fold_build1_loc, fold_convert_loc(), gcc_assert, negate_expr(), pedantic_non_lvalue_loc(), signed_type_for(), tcc_comparison, TREE_CODE_CLASS, TREE_TYPE, and TYPE_UNSIGNED.

Referenced by optimize_range_tests_diff(), and sign_bit_p().

tree merge_type_attributes	(	tree	,
		tree
	)

void merge_weak	(	tree	,
		tree
	)

Merge weak status.

enum machine_mode mode_for_size_tree	(	const_tree	,
		enum	mode_class,
		int
	)

Return the mode for data of a given size SIZE and mode class CLASS. If LIMIT is nonzero, then don't use modes bigger than MAX_FIXED_MODE_SIZE. The value is BLKmode if no other mode is found. This is like mode_for_size, but is passed a tree.

static bool more_call_expr_args_p ( )

inlinestatic

Test whether there are more arguments in abstract argument list iterator ITER, without changing its state.

static bool more_const_call_expr_args_p ( )

inlinestatic

int multiple_of_p	(	tree	,
		const_tree	,
		const_tree
	)

bool must_pass_in_stack_var_size	(	enum machine_mode	mode,
		const_tree	type
	)

Nonzero if we do not know how to pass TYPE solely in registers.

If the type has variable size...

 If the type is marked as addressable (it is required
 to be constructed into the stack)...

bool must_pass_in_stack_var_size_or_pad	(	enum	machine_mode,
		const_tree
	)

int native_encode_expr	(	const_tree	,
		unsigned char *	,
		int
	)

Convert between trees and native memory representation.

tree native_interpret_expr	(	tree	,
		const unsigned char *	,
		int
	)

bool needs_to_live_in_memory ( const_tree )

static tree next_call_expr_arg ( )

inlinestatic

Return the next argument from abstract argument list iterator object ITER, and advance its state. Return NULL_TREE if there are no more arguments.

Referenced by delete_unreachable_blocks_update_callgraph().

static const_tree next_const_call_expr_arg ( )

inlinestatic

tree non_lvalue_loc	(	location_t	,
		tree
	)

void normalize_offset	(	tree *	,
		tree *	,
		unsigned	int
	)

void normalize_rli ( record_layout_info )

void notice_global_symbol ( tree )

Referenced by decide_function_section().

tree nreverse ( tree )

Reverse the order of elements in a chain, and return the new head.

tree num_ending_zeros ( const_tree )

tree obj_type_ref_class ( tree ref )

tree omit_one_operand_loc	(	location_t	,
		tree	,
		tree	,
		tree
	)

tree omit_two_operands_loc	(	location_t	loc,
		tree	type,
		tree	result,
		tree	omitted1,
		tree	omitted2
	)

Return a tree for the case when the result of an expression is RESULT converted to TYPE and OMITTED1 and OMITTED2 were previously operands of the expression but are now not needed.

If OMITTED1 or OMITTED2 has side effects, they must be evaluated. If both OMITTED1 and OMITTED2 have side effects, OMITTED1 is evaluated before OMITTED2. Otherwise, if neither has side effects, just do the conversion of RESULT to TYPE.

Referenced by build_call_expr().

void omp_remove_redundant_declare_simd_attrs ( tree )

Remove redundant "omp declare simd" attributes from fndecl.

int operand_equal_for_phi_arg_p	(	const_tree	,
		const_tree
	)

int operand_equal_p	(	const_tree	,
		const_tree	,
		unsigned	int
	)

bool parse_input_constraint	(	const char **	constraint_p,
		int	input_num,
		int	ninputs,
		int	noutputs,
		int	ninout,
		const char const	constraints,
		bool *	allows_mem,
		bool *	allows_reg
	)

Similar, but for input constraints.

 Assume the constraint doesn't allow the use of either
 a register or memory.

 Make sure constraint has neither `=', `+', nor '&'.

       Whether or not a numeric constraint allows a register is
       decided by the matching constraint, and so there is no need
       to do anything special with them.  We must handle them in
       the default case, so that we don't unnecessarily force
       operands to memory.

         Try and find the real constraint for this dup.  Only do this
         if the matching constraint is the only alternative.

             ??? At the end of the loop, we will skip the first part of
             the matched constraint.  This assumes not only that the
             other constraint is an output constraint, but also that
             the '=' or '+' come first.

         Anticipate increment at end of loop.

       Fall through.

References error().

bool parse_output_constraint	(	const char **	constraint_p,
		int	operand_num,
		int	ninputs,
		int	noutputs,
		bool *	allows_mem,
		bool *	allows_reg,
		bool *	is_inout
	)

Parse the output constraint pointed to by *CONSTRAINT_P. It is the OPERAND_NUMth output operand, indexed from zero. There are NINPUTS inputs and NOUTPUTS outputs to this extended-asm. Upon return, *ALLOWS_MEM will be TRUE iff the constraint allows the use of a memory operand. Similarly, *ALLOWS_REG will be TRUE iff the constraint allows the use of a register operand. And, *IS_INOUT will be true if the operand is read-write, i.e., if it is used as an input as well as an output. If *CONSTRAINT_P is not in canonical form, it will be made canonical. (Note that `+' will be replaced with `=' as part of this process.)

Returns TRUE if all went well; FALSE if an error occurred.

 Assume the constraint doesn't allow the use of either a register
 or memory.

 Allow the `=' or `+' to not be at the beginning of the string,
 since it wasn't explicitly documented that way, and there is a
 large body of code that puts it last.  Swap the character to
 the front, so as not to uglify any place else.

 If the string doesn't contain an `=', issue an error
 message.

 If the constraint begins with `+', then the operand is both read
 from and written to.

 Canonicalize the output constraint so that it begins with `='.

     Make a copy of the constraint.

     Swap the first character and the `=' or `+'.

     Make sure the first character is an `='.  (Until we do this,
     it might be a `+'.)

     Replace the constraint with the canonicalized string.

 Loop through the constraint string.

       ??? Before flow, auto inc/dec insns are not supposed to exist,
       excepting those that expand_call created.  So match memory
       and hope.

void place_field	(	record_layout_info	,
		tree
	)

void pop_function_context ( void )

Restore the last saved context, at the end of a nested function. This function is called from language-specific code.

Reset variables that have known state during rtx generation.

void pop_temp_slots ( void )

Pop a temporary nesting level. All slots in use in the current level are freed.

References crtl.

void pos_from_bit	(	tree *	poffset,
		tree *	pbitpos,
		unsigned int	off_align,
		tree	pos
	)

Split the bit position POS into a byte offset *POFFSET and a bit position *PBITPOS with the byte offset aligned to OFF_ALIGN bits.

References normalize_offset().

void preserve_temp_slots ( rtx )

bool private_is_attribute_p	(	const char *	,
		size_t	,
		const_tree
	)

This function is a private implementation detail of is_attribute_p() and you should never call it directly.

tree private_lookup_attribute	(	const char *	,
		size_t	,
		tree
	)

This function is a private implementation detail of lookup_attribute() and you should never call it directly.

void process_pending_assemble_externals ( void )

void protected_set_expr_location	(	tree	,
		location_t
	)

bool prototype_p ( tree )

bool ptr_difference_const	(	tree	,
		tree	,
		HOST_WIDE_INT *
	)

static bool ptrofftype_p ( )

inlinestatic

Return whether TYPE is a type suitable for an offset for a POINTER_PLUS_EXPR.

tree purpose_member	(	const_tree	,
		tree
	)

void push_function_context ( void )

Save the current context for compilation of a nested function. This is called from language-specific code.

References function::decl, generating_concat_p, set_cfun(), and virtuals_instantiated.

void push_struct_function ( tree fndecl )

void push_temp_slots ( void )

Push deeper into the nesting level for stack temporaries.

bool range_in_array_bounds_p ( tree )

int real_minus_onep ( const_tree )

int real_onep ( const_tree )

int real_twop ( const_tree )

int real_zerop ( const_tree )

Return 1 if EXPR is the real constant zero.

int really_constant_p ( const_tree )

In tree.c

void recompute_tree_invariant_for_addr_expr ( tree )

tree reconstruct_complex_type	(	tree	,
		tree
	)

void record_tm_replacement	(	tree	,
		tree
	)

void relayout_decl ( tree )

Given a VAR_DECL, PARM_DECL or RESULT_DECL, clears the results of a previous call to layout_decl and calls it again.

tree remove_attribute	(	const char *	,
		tree
	)

Remove any instances of attribute ATTR_NAME in LIST and return the modified list. ATTR_NAME must be in the form 'text' (not 'text').

tree resolve_asm_operand_names	(	tree	,
		tree	,
		tree	,
		tree
	)

void resolve_unique_section	(	tree	decl,
		int	reloc,
		int	flag_function_or_data_sections
	)

If required, set DECL_SECTION_NAME to a unique name.

References DECL_SECTION_NAME, get_named_section(), NULL, NULL_TREE, and text_section.

tree rli_size_so_far ( record_layout_info )

tree rli_size_unit_so_far ( record_layout_info )

tree round_down_loc	(	location_t	,
		tree	,
		int
	)

tree round_up_loc	(	location_t	,
		tree	,
		int
	)

tree save_expr ( tree )

save_expr (EXP) returns an expression equivalent to EXP but it can be used multiple times within context CTX and only evaluate EXP once.

void save_vtable_map_decl ( tree )

In vtable-verify.c.

static void set_builtin_decl ( )

inlinestatic

Set explicit builtin function nodes and whether it is an implicit function.

static void set_builtin_decl_implicit_p ( )

inlinestatic

Set the implicit flag for a builtin function.

void set_builtin_user_assembler_name	(	tree	decl,
		const char *	asmspec
	)

void set_call_expr_flags	(	tree	,
		int
	)

void set_decl_incoming_rtl	(	tree	,
		rtx	,
		bool
	)

void set_decl_rtl	(	tree	,
		rtx
	)

In emit-rtl.c Assign the RTX to declaration.

void set_min_and_max_values_for_integral_type	(	tree	type,
		int	precision,
		bool	is_unsigned
	)

In stor-layout.c

TYPE is an integral type, i.e., an INTEGRAL_TYPE, ENUMERAL_TYPE or BOOLEAN_TYPE. Set TYPE_MIN_VALUE and TYPE_MAX_VALUE for TYPE, based on the PRECISION and whether or not the TYPE IS_UNSIGNED. PRECISION need not correspond to a width supported natively by the hardware; for example, on a machine with 8-bit, 16-bit, and 32-bit register modes, PRECISION might be 7, 23, or

For bitfields with zero width we end up creating integer types with zero precision. Don't assign any minimum/maximum values to those types, they don't have any valid value.

References bit_field_mode_iterator::next_mode().

Referenced by make_unsigned_type().

void set_user_assembler_name	(	tree	,
		const char *
	)

Referenced by gen_int_to_fp_nondecimal_conv_libfunc().

int setjmp_call_p ( const_tree )

tree signed_or_unsigned_type_for	(	int	,
		tree
	)

tree signed_type_for ( tree )

int simple_cst_equal	(	const_tree	,
		const_tree
	)

int simple_cst_list_equal	(	const_tree	,
		const_tree
	)

tree size_binop_loc	(	location_t	,
		enum	tree_code,
		tree	,
		tree
	)

tree size_diffop_loc	(	location_t	,
		tree	,
		tree
	)

tree size_in_bytes ( const_tree )

tree size_int_kind	(	HOST_WIDE_INT	,
		enum	size_type_kind
	)

HOST_WIDE_INT size_low_cst ( const_tree )

tree skip_simple_arithmetic ( tree )

Look inside EXPR into any simple arithmetic operations. Return the outermost non-arithmetic or non-invariant node.

tree skip_simple_constant_arithmetic ( tree )

Look inside EXPR into simple arithmetic operations involving constants. Return the outermost non-arithmetic or non-constant node.

bool ssa_name_nonnegative_p ( const_tree )

In tree-vrp.c

tree stabilize_reference ( tree )

stabilize_reference (EXP) returns a reference equivalent to EXP but it can be used multiple times and only evaluate the subexpressions once.

tree stabilize_reference_1 ( tree )

Subroutine of stabilize_reference; this is called for subtrees of references. Any expression with side-effects must be put in a SAVE_EXPR to ensure that it is only evaluated once.

void stack_protect_epilogue ( void )

 Allow the target to compare Y with X without leaking either into
 a register.

     FALLTHRU

 The noreturn predictor has been moved to the tree level.  The rtl-level
 predictors estimate this branch about 20%, which isn't enough to get
 things moved out of line.  Since this is the only extant case of adding
 a noreturn function at the rtl level, it doesn't seem worth doing ought
 except adding the prediction by hand.

void stack_protect_prologue ( void )

Allow the target to copy from Y to X without leaking Y into a register.

 Otherwise do a straight move.

record_layout_info start_record_layout ( tree )

tree staticp ( tree )

staticp (tree x) is nonzero if X is a reference to data allocated at a fixed address in memory. Returns the outermost data.

bool stdarg_p ( const_tree )

tree strip_array_types ( tree )

tree strip_float_extensions ( tree )

In convert.c

const_tree strip_invariant_refs ( const_tree )

static int struct_ptr_eq ( )

inlinestatic

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.

static hashval_t struct_ptr_hash ( )

inlinestatic

bool subrange_type_for_debug_p	(	const_tree	,
		tree *	,
		tree *
	)

tree substitute_in_expr	(	tree	,
		tree	,
		tree
	)

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.

tree substitute_placeholder_in_expr	(	tree	,
		tree
	)

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.

int supports_one_only ( void )

Returns 1 if the target configuration supports defining public symbols so that one of them will be chosen at link time instead of generating a multiply-defined symbol error, whether through the use of weak symbols or a target-specific mechanism for having duplicates discarded.

enum tree_code swap_tree_comparison ( enum tree_code )

void tm_malloc_replacement ( tree )

bool tree_binary_nonnegative_warnv_p	(	enum tree_code	code,
		tree	type,
		tree	op0,
		tree	op1,
		bool *	strict_overflow_p
	)

Return true if (CODE OP0 OP1) is known to be non-negative. If the return value is based on the assumption that signed overflow is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't change *STRICT_OVERFLOW_P.

     zero_extend(x) + zero_extend(y) is non-negative if x and y are
     both unsigned and at least 2 bits shorter than the result.

         x * x is always non-negative for floating point x
         or without overflow.

     zero_extend(x) * zero_extend(y) is non-negative if x and y are
     both unsigned and their total bits is shorter than the result.

 We don't know sign of `t', so be conservative and return false.

bool tree_binary_nonzero_warnv_p	(	enum tree_code	code,
		tree	type,
		tree	op0,
		tree	op1,
		bool *	strict_overflow_p
	)

Return true when (CODE OP0 OP1) is an address and is known to be nonzero. For floating point we further ensure that T is not denormal. Similar logic is present in nonzero_address in rtlanal.h.

If the return value is based on the assumption that signed overflow is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't change *STRICT_OVERFLOW_P.

         With the presence of negative values it is hard
         to say something.

         One of operands must be positive and the other non-negative.

         We don't set *STRICT_OVERFLOW_P here: even if this value
         overflows, on a twos-complement machine the sum of two
         nonnegative numbers can never be zero.

         When both operands are nonzero, then MAX must be too.

         MAX where operand 0 is positive is positive.

     MAX where operand 1 is positive is positive.

tree tree_block ( tree )

bool tree_call_nonnegative_warnv_p	(	tree	type,
		tree	fndecl,
		tree	arg0,
		tree	arg1,
		bool *	strict_overflow_p
	)

Return true if T is known to be non-negative. If the return value is based on the assumption that signed overflow is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't change *STRICT_OVERFLOW_P.

       Always true.

       sqrt(-0.0) is -0.0.

       True if the 1st argument is nonnegative.

       True if the 1st OR 2nd arguments are nonnegative.

       True if the 1st AND 2nd arguments are nonnegative.

       True if the 2nd argument is nonnegative.

       True if the 1st argument is nonnegative or the second
       argument is an even integer.

       True if the 1st argument is nonnegative or the second
       argument is an even integer valued real.

Referenced by symbolic_range_p().

size_t tree_code_size ( enum tree_code )

Compute the number of bytes occupied by a tree with code CODE. This function cannot be used for TREE_VEC codes, which are of variable length.

tree tree_cons_stat	(	tree	,
		tree	,
		tree	MEM_STAT_DECL
	)

Make a new TREE_LIST node from specified PURPOSE, VALUE and CHAIN.

unsigned int tree_decl_map_hash ( const void * )

bool tree_expr_nonnegative_p ( tree )

bool tree_expr_nonnegative_warnv_p	(	tree	,
		bool *
	)

bool tree_expr_nonzero_p ( tree )

bool tree_expr_nonzero_warnv_p	(	tree	,
		bool *
	)

tree tree_expr_size ( const_tree )

int tree_floor_log2 ( const_tree )

int tree_int_cst_compare	(	const_tree	,
		const_tree
	)

int tree_int_cst_equal	(	const_tree	,
		const_tree
	)

int tree_int_cst_lt	(	const_tree	,
		const_tree
	)

unsigned int tree_int_cst_min_precision	(	tree	,
		bool
	)

int tree_int_cst_sgn ( const_tree )

int tree_int_cst_sign_bit ( const_tree )

bool tree_invalid_nonnegative_warnv_p	(	tree	t,
		bool *	strict_overflow_p
	)

tree tree_last ( tree )

Return the last tree node in a chain.

int tree_log2 ( const_tree )

HOST_WIDE_INT tree_low_cst	(	const_tree	,
		int
	)

int tree_map_base_eq	(	const void *	,
		const void *
	)

In tree.c.

unsigned int tree_map_base_hash ( const void * )

int tree_map_base_marked_p ( const void * )

unsigned int tree_map_hash ( const void * )

enum tree_node_structure_enum tree_node_structure ( const_tree )

Return which tree structure is used by T.

location_t tree_nonartificial_location ( tree )

static int tree_operand_length ( )

inlinestatic

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 build4_stat(), CAN_HAVE_LOCATION_P, PASS_MEM_STAT, and SET_EXPR_LOCATION.

tree tree_output_constant_def ( tree )

varasm.c

Referenced by gimplify_init_ctor_eval().

void tree_set_block	(	tree	,
		tree
	)

bool tree_single_nonnegative_warnv_p	(	tree	t,
		bool *	strict_overflow_p
	)

bool tree_single_nonzero_warnv_p	(	tree	,
		bool *
	)

size_t tree_size ( const_tree )

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.

tree tree_strip_nop_conversions ( tree )

tree tree_strip_sign_nop_conversions ( tree )

bool tree_swap_operands_p	(	const_tree	,
		const_tree	,
		bool
	)

static double_int tree_to_double_int ( )

inlinestatic

Constructs double_int from tree CST.

Referenced by add_loc_list(), backtrace_base_for_ref(), build_function_type_list_1(), build_method_type_directly(), cgraph_create_function_alias(), create_mul_ssa_cand(), finish_builtin_struct(), merge_comps(), native_interpret_vector(), quad_int_pair_sort(), tree_to_aff_combination(), tree_unary_nonnegative_warnv_p(), and vrp_int_const_binop().

bool tree_unary_nonnegative_warnv_p	(	enum tree_code	code,
		tree	type,
		tree	op0,
		bool *	strict_overflow_p
	)

Return true if (CODE OP0) is known to be non-negative. If the return value is based on the assumption that signed overflow is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't change *STRICT_OVERFLOW_P.

We can't return 1 if flag_wrapv is set because
ABS_EXPR<INT_MIN> = INT_MIN.

We don't know sign of `t', so be conservative and return false.

References build_fixed(), build_real(), fixed_arithmetic(), FIXED_VALUE_TYPE, force_fit_type_double(), gcc_unreachable, double_int::neg_with_overflow(), NULL, real_value_negate(), TREE_FIXED_CST, TREE_OVERFLOW, TREE_REAL_CST, tree_to_double_int(), TYPE_SATURATING, and TYPE_UNSIGNED.

Referenced by range_is_null().

bool tree_unary_nonzero_warnv_p	(	enum tree_code	code,
		tree	type,
		tree	op0,
		bool *	strict_overflow_p
	)

Return true when (CODE OP0) is an address and is known to be nonzero. For floating point we further ensure that T is not denormal. Similar logic is present in nonzero_address in rtlanal.h.

If the return value is based on the assumption that signed overflow is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't change *STRICT_OVERFLOW_P.

tree truth_type_for ( tree )

static bool truth_value_p ( )

inlinestatic

Return nonzero if CODE is a tree code that represents a truth value.

References builtin_info, BUILTIN_VALID_P, and gcc_checking_assert.

bool type_contains_placeholder_p ( tree )

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.

tree type_hash_canon	(	unsigned	int,
		tree
	)

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.

bool type_in_anonymous_namespace_p ( tree )

int type_list_equal	(	const_tree	,
		const_tree
	)

int type_num_arguments ( const_tree )

bool typedef_variant_p ( tree )

bool types_same_for_odr	(	tree	type1,
		tree	type2
	)

tree uniform_vector_p ( const_tree )

Given a vector VEC, return its first element if all elements are the same. Otherwise return NULL_TREE.

tree unshare_expr ( tree )

In gimplify.c

tree unshare_expr_without_location ( tree )

tree unsigned_type_for ( tree )

unsigned int update_alignment_for_field	(	record_layout_info	rli,
		tree	field,
		unsigned int	known_align
	)

FIELD is about to be added to RLI->T. The alignment (in bits) of the next available location within the record is given by KNOWN_ALIGN. Update the variable alignment fields in RLI, and return the alignment to give the FIELD.

 The alignment required for FIELD.

 The type of this field.

 True if the field was explicitly aligned by the user.

 Do not attempt to align an ERROR_MARK node

 Lay out the field so we know what alignment it needs.

 Record must have at least as much alignment as any field.
 Otherwise, the alignment of the field within the record is
 meaningless.

     Here, the alignment of the underlying type of a bitfield can
     affect the alignment of a record; even a zero-sized field
     can do this.  The alignment should be to the alignment of
     the type, except that for zero-size bitfields this only
     applies if there was an immediately prior, nonzero-size
     bitfield.  (That's the way it is, experimentally.)

tree upper_bound_in_type	(	tree	,
		tree
	)

bool use_register_for_decl ( const_tree )

void using_eh_for_cleanups ( void )

This routine is called from front ends to indicate eh should be used for cleanups.

bool using_eh_for_cleanups_p ( void )

Query whether EH is used for cleanups.

bool valid_constant_size_p ( const_tree )

bool validate_arglist	(	const_tree	,
			...
	)

tree value_member	(	tree	,
		tree
	)

tree variable_size ( tree )

variable_size (EXP) is like save_expr (EXP) except that it is for the special case of something that is part of a variable size for a data type. It makes special arrangements to compute the value at the right time when the data type belongs to a function parameter.

bool variably_modified_type_p	(	tree	,
		tree
	)

bool vec_member	(	const_tree	,
		vec< tree, va_gc > *
	)

enum machine_mode vector_type_mode ( const_tree )

Vector types need to check target flags to determine type.

bool virtual_method_call_p ( tree )

tree walk_tree_1	(	tree *	tp,
		walk_tree_fn	func,
		void *	data,
		struct pointer_set_t *	pset,
		walk_tree_lh	lh
	)

In tree-inline.c

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.

 Skip empty subtrees.

 Don't walk the same tree twice, if the user has requested
 that we avoid doing so.

 Call the function.

 If we found something, return it.

 Even if we didn't, FUNC may have decided that there was nothing
 interesting below this point in the tree.

     But we still need to check our siblings.

     None of these have subtrees other than those already walked
     above.

       Walk all elements but the first.

       Now walk the first one as a tail call.

           Walk the DECL_INITIAL and DECL_SIZE.  We don't want to walk
           into declarations that are just mentioned, rather than
           declared; they don't really belong to this part of the tree.
           And, we can see cycles: the initializer for a declaration
           can refer to the declaration itself.

         FALLTHRU

       TARGET_EXPRs are peculiar: operands 1 and 3 can be the same.
       But, we only want to walk once.

     If this is a TYPE_DECL, walk into the fields of the type that it's
     defining.  We only want to walk into these fields of a type in this
     case and not in the general case of a mere reference to the type.

     The criterion is as follows: if the field can be an expression, it
     must be walked only here.  This should be in keeping with the fields
     that are directly gimplified in gimplify_type_sizes in order for the
     mark/copy-if-shared/unmark machinery of the gimplifier to work with
     variable-sized types.

     Note that DECLs get walked as part of processing the BIND_EXPR.

         Call the function for the type.  See if it returns anything or
         doesn't want us to continue.  If we are to continue, walk both
         the normal fields and those for the declaration case.

         But do not walk a pointed-to type since it may itself need to
         be walked in the declaration case if it isn't anonymous.

         If this is a record type, also walk the fields.

                 We'd like to look at the type of the field, but we can
                 easily get infinite recursion.  So assume it's pointed
                 to elsewhere in the tree.  Also, ignore things that
                 aren't fields.

         Same for scalar types.

     FALLTHRU

         Walk over all the sub-trees of this operand.

         Go through the subtrees.  We need to do this in forward order so
         that the scope of a FOR_EXPR is handled properly.

     If this is a type, walk the needed fields in the type.

 We didn't find what we were looking for.

tree walk_tree_without_duplicates_1	(	tree *	tp,
		walk_tree_fn	func,
		void *	data,
		walk_tree_lh	lh
	)

Like walk_tree, but does not walk duplicate nodes more than once.

References BINFO_TYPE, and types_same_for_odr().

void warn_deprecated_use	(	tree	,
		tree
	)

HOST_WIDEST_INT widest_int_cst_value ( const_tree )

Variable Documentation

int folding_initializer

In fold-const.c Non-zero if we are folding constants inside an initializer; zero otherwise.

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/. The entry points in this file are fold, size_int_wide and size_binop.

fold takes a tree as argument and returns a simplified tree.

size_binop takes a tree code for an arithmetic operation and two operands that are trees, and produces a tree for the result, assuming the type comes from `sizetype'.

size_int takes an integer value, and creates a tree constant with type from `sizetype'.

Note: Since the folders get called on non-gimple code as well as gimple code, we need to handle GIMPLE tuples as well as their corresponding tree equivalents. Nonzero if we are folding constants inside an initializer; zero otherwise.

bool force_folding_builtin_constant_p

In builtins.c Non-zero if __builtin_constant_p should be folded right away.

Non-zero if __builtin_constant_p should be folded right away.

Macros

Functions

Variables

Macro Definition Documentation

Function Documentation

Variable Documentation