150#define MARK_TS_BASE(C)                                 \ 
  151  (tree_contains_struct[C][TS_BASE] = true) 
 
  153#define MARK_TS_TYPED(C)                                \ 
  155   tree_contains_struct[C][TS_TYPED] = true) 
 
  157#define MARK_TS_COMMON(C)                               \ 
  158  (MARK_TS_TYPED (C),                                   \ 
  159   tree_contains_struct[C][TS_COMMON] = true) 
 
  161#define MARK_TS_TYPE_COMMON(C)                          \ 
  162  (MARK_TS_COMMON (C),                                  \ 
  163   tree_contains_struct[C][TS_TYPE_COMMON] = true) 
 
  165#define MARK_TS_TYPE_WITH_LANG_SPECIFIC(C)              \ 
  166  (MARK_TS_TYPE_COMMON (C),                             \ 
  167   tree_contains_struct[C][TS_TYPE_WITH_LANG_SPECIFIC] = true) 
 
  169#define MARK_TS_TYPE_NON_COMMON(C)                      \ 
  170  (MARK_TS_TYPE_WITH_LANG_SPECIFIC (C),                 \ 
  171   tree_contains_struct[C][TS_TYPE_NON_COMMON] = true)  \ 
 
  173#define MARK_TS_DECL_MINIMAL(C)                         \ 
  174  (MARK_TS_COMMON (C),                                  \ 
  175   tree_contains_struct[C][TS_DECL_MINIMAL] = true) 
 
  177#define MARK_TS_DECL_COMMON(C)                          \ 
  178  (MARK_TS_DECL_MINIMAL (C),                            \ 
  179   tree_contains_struct[C][TS_DECL_COMMON] = true) 
 
  181#define MARK_TS_DECL_WRTL(C)                            \ 
  182  (MARK_TS_DECL_COMMON (C),                             \ 
  183   tree_contains_struct[C][TS_DECL_WRTL] = true) 
 
  185#define MARK_TS_DECL_WITH_VIS(C)                        \ 
  186  (MARK_TS_DECL_WRTL (C),                               \ 
  187   tree_contains_struct[C][TS_DECL_WITH_VIS] = true) 
 
  189#define MARK_TS_DECL_NON_COMMON(C)                      \ 
  190  (MARK_TS_DECL_WITH_VIS (C),                           \ 
  191   tree_contains_struct[C][TS_DECL_NON_COMMON] = true) 
 
  193#define MARK_TS_EXP(C)                                  \ 
  194  (MARK_TS_TYPED (C),                                   \ 
  195   tree_contains_struct[C][TS_EXP] = true) 
 
  199#define TREE_CODE_CLASS_STRING(CLASS)\ 
  200        tree_code_class_strings[(int) (CLASS)] 
 
  202#if __cpp_inline_variables < 201606L 
  203#define TREE_CODE_CLASS(CODE)   \ 
  204  tree_code_type_tmpl <0>::tree_code_type[(int) (CODE)] 
 
  206#define TREE_CODE_CLASS(CODE)   tree_code_type[(int) (CODE)] 
  211#define EXCEPTIONAL_CLASS_P(NODE)\ 
  212        (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_exceptional) 
 
  216#define CONSTANT_CLASS_P(NODE)\ 
  217        (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_constant) 
 
  222#define CONSTANT_CLASS_OR_WRAPPER_P(NODE)\ 
  223        (CONSTANT_CLASS_P (tree_strip_any_location_wrapper (NODE))) 
 
  228        (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_type) 
 
  233        (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_declaration) 
 
  237  (TREE_CODE (NODE) == VAR_DECL) 
 
  241#define VAR_OR_FUNCTION_DECL_P(DECL)\ 
  242  (TREE_CODE (DECL) == VAR_DECL || TREE_CODE (DECL) == FUNCTION_DECL) 
 
  247#define INDIRECT_REF_P(NODE)\ 
  248  (TREE_CODE (NODE) == INDIRECT_REF) 
 
  252#define REFERENCE_CLASS_P(NODE)\ 
  253        (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_reference) 
 
  257#define COMPARISON_CLASS_P(NODE)\ 
  258        (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_comparison) 
 
  262#define UNARY_CLASS_P(NODE)\ 
  263        (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_unary) 
 
  267#define BINARY_CLASS_P(NODE)\ 
  268        (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_binary) 
 
  272#define STATEMENT_CLASS_P(NODE)\ 
  273        (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_statement) 
 
  278#define VL_EXP_CLASS_P(NODE)\ 
  279        (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_vl_exp) 
 
  283#define EXPRESSION_CLASS_P(NODE)\ 
  284        (TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_expression) 
 
  288#define IS_TYPE_OR_DECL_P(NODE)\ 
  289        (TYPE_P (NODE) || DECL_P (NODE)) 
 
  294#define IS_EXPR_CODE_CLASS(CLASS)\ 
  295        ((CLASS) >= tcc_reference && (CLASS) <= tcc_expression) 
 
  299#define EXPR_P(NODE) IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (NODE))) 
  301#if __cpp_inline_variables < 201606L 
  302#define TREE_CODE_LENGTH(CODE)  \ 
  303  tree_code_length_tmpl <0>::tree_code_length[(int) (CODE)] 
 
  305#define TREE_CODE_LENGTH(CODE)  tree_code_length[(int) (CODE)] 
  311#define CASE_FLT_FN(FN) case FN: case FN##F: case FN##L 
  312#define CASE_FLT_FN_FLOATN_NX(FN)                          \ 
  313  case FN##F16: case FN##F32: case FN##F64: case FN##F128: \ 
  314  case FN##F32X: case FN##F64X: case FN##F128X 
 
  315#define CASE_FLT_FN_REENT(FN) case FN##_R: case FN##F_R: case FN##L_R 
  316#define CASE_INT_FN(FN) case FN: case FN##L: case FN##LL: case FN##IMAX 
  318#define NULL_TREE (tree) NULL 
  325#define TREE_CODE(NODE) ((enum tree_code) (NODE)->base.code) 
  326#define TREE_SET_CODE(NODE, VALUE) ((NODE)->base.code = (VALUE)) 
  330#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007) 
  332#define TREE_CHECK(T, CODE) \ 
  333(tree_check ((T), __FILE__, __LINE__, __FUNCTION__, (CODE))) 
  335#define TREE_NOT_CHECK(T, CODE) \ 
  336(tree_not_check ((T), __FILE__, __LINE__, __FUNCTION__, (CODE))) 
  338#define TREE_CHECK2(T, CODE1, CODE2) \ 
  339(tree_check2 ((T), __FILE__, __LINE__, __FUNCTION__, (CODE1), (CODE2))) 
  341#define TREE_NOT_CHECK2(T, CODE1, CODE2) \ 
  342(tree_not_check2 ((T), __FILE__, __LINE__, __FUNCTION__, (CODE1), (CODE2))) 
  344#define TREE_CHECK3(T, CODE1, CODE2, CODE3) \ 
  345(tree_check3 ((T), __FILE__, __LINE__, __FUNCTION__, (CODE1), (CODE2), (CODE3))) 
  347#define TREE_NOT_CHECK3(T, CODE1, CODE2, CODE3) \ 
  348(tree_not_check3 ((T), __FILE__, __LINE__, __FUNCTION__, \ 
  349                               (CODE1), (CODE2), (CODE3))) 
  351#define TREE_CHECK4(T, CODE1, CODE2, CODE3, CODE4) \ 
  352(tree_check4 ((T), __FILE__, __LINE__, __FUNCTION__, \ 
  353                           (CODE1), (CODE2), (CODE3), (CODE4))) 
  355#define TREE_NOT_CHECK4(T, CODE1, CODE2, CODE3, CODE4) \ 
  356(tree_not_check4 ((T), __FILE__, __LINE__, __FUNCTION__, \ 
  357                               (CODE1), (CODE2), (CODE3), (CODE4))) 
  359#define TREE_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) \ 
  360(tree_check5 ((T), __FILE__, __LINE__, __FUNCTION__, \ 
  361                           (CODE1), (CODE2), (CODE3), (CODE4), (CODE5))) 
  363#define TREE_NOT_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) \ 
  364(tree_not_check5 ((T), __FILE__, __LINE__, __FUNCTION__, \ 
  365                               (CODE1), (CODE2), (CODE3), (CODE4), (CODE5))) 
  367#define TREE_CHECK6(T, CODE1, CODE2, CODE3, CODE4, CODE5, CODE6) \ 
  368(tree_check6 ((T), __FILE__, __LINE__, __FUNCTION__, \ 
  369                        (CODE1), (CODE2), (CODE3), (CODE4), (CODE5), (CODE6))) 
  371#define TREE_NOT_CHECK6(T, CODE1, CODE2, CODE3, CODE4, CODE5, CODE6) \ 
  372(tree_not_check6 ((T), __FILE__, __LINE__, __FUNCTION__, \ 
  373                        (CODE1), (CODE2), (CODE3), (CODE4), (CODE5), (CODE6))) 
  375#define CONTAINS_STRUCT_CHECK(T, STRUCT) \ 
  376(contains_struct_check ((T), (STRUCT), __FILE__, __LINE__, __FUNCTION__)) 
  378#define TREE_CLASS_CHECK(T, CLASS) \ 
  379(tree_class_check ((T), (CLASS), __FILE__, __LINE__, __FUNCTION__)) 
  381#define TREE_RANGE_CHECK(T, CODE1, CODE2) \ 
  382(tree_range_check ((T), (CODE1), (CODE2), __FILE__, __LINE__, __FUNCTION__)) 
  384#define OMP_CLAUSE_SUBCODE_CHECK(T, CODE) \ 
  385(omp_clause_subcode_check ((T), (CODE), __FILE__, __LINE__, __FUNCTION__)) 
  387#define OMP_CLAUSE_RANGE_CHECK(T, CODE1, CODE2) \ 
  388(omp_clause_range_check ((T), (CODE1), (CODE2), \ 
  389                                      __FILE__, __LINE__, __FUNCTION__)) 
  392#define EXPR_CHECK(T) \ 
  393(expr_check ((T), __FILE__, __LINE__, __FUNCTION__)) 
  396#define NON_TYPE_CHECK(T) \ 
  397(non_type_check ((T), __FILE__, __LINE__, __FUNCTION__)) 
  400#define ANY_INTEGRAL_TYPE_CHECK(T) \ 
  401(any_integral_type_check ((T), __FILE__, __LINE__, __FUNCTION__)) 
  403#define TREE_INT_CST_ELT_CHECK(T, I) \ 
  404(*tree_int_cst_elt_check ((T), (I), __FILE__, __LINE__, __FUNCTION__)) 
  406#define TREE_VEC_ELT_CHECK(T, I) \ 
  407(*(CONST_CAST2 (tree *, typeof (T)*, \ 
  408     tree_vec_elt_check ((T), (I), __FILE__, __LINE__, __FUNCTION__)))) 
  410#define OMP_CLAUSE_ELT_CHECK(T, I) \ 
  411(*(omp_clause_elt_check ((T), (I), __FILE__, __LINE__, __FUNCTION__))) 
  414#define TREE_OPERAND_CHECK(T, I) \ 
  415(*(CONST_CAST2 (tree*, typeof (T)*, \ 
  416     tree_operand_check ((T), (I), __FILE__, __LINE__, __FUNCTION__)))) 
  418#define TREE_OPERAND_CHECK_CODE(T, CODE, I) \ 
  419(*(tree_operand_check_code ((T), (CODE), (I), \ 
  420                                         __FILE__, __LINE__, __FUNCTION__))) 
  431#define TREE_CHAIN(NODE) \ 
  432(CONTAINS_STRUCT_CHECK (NODE, TS_COMMON)->common.chain) 
  438#define TREE_TYPE(NODE) \ 
  439(CONTAINS_STRUCT_CHECK (NODE, TS_TYPED)->typed.type) 
  441extern void tree_contains_struct_check_failed (
const_tree,
 
  443                                               const char *, 
int, 
const char *)
 
  446extern void tree_check_failed (
const_tree, 
const char *, 
int, 
const char *,
 
  448extern 
void tree_not_check_failed (
const_tree, const 
char *, 
int, const 
char *,
 
  451                                     const 
char *, 
int, const 
char *)
 
  453extern 
void tree_range_check_failed (
const_tree, const 
char *, 
int,
 
  457extern 
void tree_not_class_check_failed (
const_tree,
 
  459                                         const 
char *, 
int, const 
char *)
 
  461extern 
void tree_int_cst_elt_check_failed (
int, 
int, const 
char *,
 
  464extern 
void tree_vec_elt_check_failed (
int, 
int, const 
char *,
 
  467extern 
void phi_node_elt_check_failed (
int, 
int, const 
char *,
 
  470extern 
void tree_operand_check_failed (
int, 
const_tree,
 
  471                                       const 
char *, 
int, const 
char *)
 
  473extern 
void omp_clause_check_failed (
const_tree, const 
char *, 
int,
 
  476extern 
void omp_clause_operand_check_failed (
int, 
const_tree, const 
char *,
 
  479extern 
void omp_clause_range_check_failed (
const_tree, const 
char *, 
int,
 
  486#define CONTAINS_STRUCT_CHECK(T, ENUM)          (T) 
  487#define TREE_CHECK(T, CODE)                     (T) 
  488#define TREE_NOT_CHECK(T, CODE)                 (T) 
  489#define TREE_CHECK2(T, CODE1, CODE2)            (T) 
  490#define TREE_NOT_CHECK2(T, CODE1, CODE2)        (T) 
  491#define TREE_CHECK3(T, CODE1, CODE2, CODE3)     (T) 
  492#define TREE_NOT_CHECK3(T, CODE1, CODE2, CODE3) (T) 
  493#define TREE_CHECK4(T, CODE1, CODE2, CODE3, CODE4) (T) 
  494#define TREE_NOT_CHECK4(T, CODE1, CODE2, CODE3, CODE4) (T) 
  495#define TREE_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) (T) 
  496#define TREE_NOT_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) (T) 
  497#define TREE_CHECK6(T, CODE1, CODE2, CODE3, CODE4, CODE5, CODE6) (T) 
  498#define TREE_NOT_CHECK6(T, CODE1, CODE2, CODE3, CODE4, CODE5, CODE6) (T) 
  499#define TREE_CLASS_CHECK(T, CODE)               (T) 
  500#define TREE_RANGE_CHECK(T, CODE1, CODE2)       (T) 
  501#define EXPR_CHECK(T)                           (T) 
  502#define NON_TYPE_CHECK(T)                       (T) 
  503#define TREE_INT_CST_ELT_CHECK(T, I)            ((T)->int_cst.val[I]) 
  504#define TREE_VEC_ELT_CHECK(T, I)                ((T)->vec.a[I]) 
  505#define TREE_OPERAND_CHECK(T, I)                ((T)->exp.operands[I]) 
  506#define TREE_OPERAND_CHECK_CODE(T, CODE, I)     ((T)->exp.operands[I]) 
  507#define OMP_CLAUSE_ELT_CHECK(T, i)              ((T)->omp_clause.ops[i]) 
  508#define OMP_CLAUSE_RANGE_CHECK(T, CODE1, CODE2) (T) 
  509#define OMP_CLAUSE_SUBCODE_CHECK(T, CODE)       (T) 
  510#define ANY_INTEGRAL_TYPE_CHECK(T)              (T) 
  512#define TREE_CHAIN(NODE) ((NODE)->common.chain) 
  513#define TREE_TYPE(NODE) ((NODE)->typed.type) 
  517#define TREE_BLOCK(NODE)                (tree_block (NODE)) 
  518#define TREE_SET_BLOCK(T, B)            (tree_set_block ((T), (B))) 
  520#include "tree-check.h" 
  522#define TYPE_CHECK(T)           TREE_CLASS_CHECK (T, tcc_type) 
  523#define DECL_MINIMAL_CHECK(T)   CONTAINS_STRUCT_CHECK (T, TS_DECL_MINIMAL) 
  524#define DECL_COMMON_CHECK(T)    CONTAINS_STRUCT_CHECK (T, TS_DECL_COMMON) 
  525#define DECL_WRTL_CHECK(T)      CONTAINS_STRUCT_CHECK (T, TS_DECL_WRTL) 
  526#define DECL_WITH_VIS_CHECK(T)  CONTAINS_STRUCT_CHECK (T, TS_DECL_WITH_VIS) 
  527#define DECL_NON_COMMON_CHECK(T) CONTAINS_STRUCT_CHECK (T, TS_DECL_NON_COMMON) 
  528#define CST_CHECK(T)            TREE_CLASS_CHECK (T, tcc_constant) 
  529#define STMT_CHECK(T)           TREE_CLASS_CHECK (T, tcc_statement) 
  530#define VL_EXP_CHECK(T)         TREE_CLASS_CHECK (T, tcc_vl_exp) 
  531#define FUNC_OR_METHOD_CHECK(T) TREE_CHECK2 (T, FUNCTION_TYPE, METHOD_TYPE) 
  532#define PTR_OR_REF_CHECK(T)     TREE_CHECK2 (T, POINTER_TYPE, REFERENCE_TYPE) 
  534#define RECORD_OR_UNION_CHECK(T)        \ 
  535  TREE_CHECK3 (T, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE) 
 
  536#define NOT_RECORD_OR_UNION_CHECK(T) \ 
  537  TREE_NOT_CHECK3 (T, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE) 
 
  538#define ARRAY_OR_INTEGER_TYPE_CHECK(T)  \ 
  539  TREE_CHECK2 (T, ARRAY_TYPE, INTEGER_TYPE) 
 
  541#define NUMERICAL_TYPE_CHECK(T)                                 \ 
  542  TREE_CHECK6 (T, INTEGER_TYPE, ENUMERAL_TYPE, BOOLEAN_TYPE, REAL_TYPE, \ 
  543               FIXED_POINT_TYPE, BITINT_TYPE) 
 
  547#define TYPE_HASH(TYPE) (TYPE_UID (TYPE)) 
  551#define TREE_HASH(NODE) ((size_t) (NODE) & 0777777) 
  554#define CONVERT_EXPR_CODE_P(CODE)                               \ 
  555  ((CODE) == NOP_EXPR || (CODE) == CONVERT_EXPR) 
 
  558#define CONVERT_EXPR_P(EXP)     CONVERT_EXPR_CODE_P (TREE_CODE (EXP)) 
  562#define CASE_CONVERT                                            \ 
 
  570#define STRIP_NOPS(EXP) \ 
  571  (EXP) = tree_strip_nop_conversions (CONST_CAST_TREE (EXP)) 
 
  575#define STRIP_SIGN_NOPS(EXP) \ 
  576  (EXP) = tree_strip_sign_nop_conversions (CONST_CAST_TREE (EXP)) 
 
  580#define STRIP_TYPE_NOPS(EXP) \ 
  581  while ((CONVERT_EXPR_P (EXP)                                  \ 
  582          || TREE_CODE (EXP) == NON_LVALUE_EXPR)                \ 
  583         && TREE_OPERAND (EXP, 0) != error_mark_node            \ 
  584         && (TREE_TYPE (EXP)                                    \ 
  585             == TREE_TYPE (TREE_OPERAND (EXP, 0))))             \ 
  586    (EXP) = TREE_OPERAND (EXP, 0) 
 
  591#define STRIP_USELESS_TYPE_CONVERSION(EXP) \ 
  592  (EXP) = tree_ssa_strip_useless_type_conversions (EXP) 
 
  597#define STRIP_ANY_LOCATION_WRAPPER(EXP) \ 
  598  (EXP) = tree_strip_any_location_wrapper (CONST_CAST_TREE (EXP)) 
 
  602#define VECTOR_TYPE_P(TYPE) (TREE_CODE (TYPE) == VECTOR_TYPE) 
  606#define VECTOR_BOOLEAN_TYPE_P(TYPE)                             \ 
  607  (TREE_CODE (TYPE) == VECTOR_TYPE                      \ 
  608   && TREE_CODE (TREE_TYPE (TYPE)) == BOOLEAN_TYPE) 
 
  614#define INTEGRAL_TYPE_P(TYPE)  \ 
  615  (TREE_CODE (TYPE) == ENUMERAL_TYPE  \ 
  616   || TREE_CODE (TYPE) == BOOLEAN_TYPE \ 
  617   || TREE_CODE (TYPE) == INTEGER_TYPE \ 
  618   || TREE_CODE (TYPE) == BITINT_TYPE) 
 
  623#define ANY_INTEGRAL_TYPE_P(TYPE)               \ 
  624  (INTEGRAL_TYPE_P (TYPE)                       \ 
  625   || ((TREE_CODE (TYPE) == COMPLEX_TYPE        \ 
  626        || VECTOR_TYPE_P (TYPE))                \ 
  627       && INTEGRAL_TYPE_P (TREE_TYPE (TYPE)))) 
 
  631#define BITINT_TYPE_P(TYPE) (TREE_CODE (TYPE) == BITINT_TYPE) 
  635#define NON_SAT_FIXED_POINT_TYPE_P(TYPE) \ 
  636  (TREE_CODE (TYPE) == FIXED_POINT_TYPE && !TYPE_SATURATING (TYPE)) 
 
  640#define SAT_FIXED_POINT_TYPE_P(TYPE) \ 
  641  (TREE_CODE (TYPE) == FIXED_POINT_TYPE && TYPE_SATURATING (TYPE)) 
 
  645#define FIXED_POINT_TYPE_P(TYPE)        (TREE_CODE (TYPE) == FIXED_POINT_TYPE) 
  649#define SCALAR_FLOAT_TYPE_P(TYPE) (TREE_CODE (TYPE) == REAL_TYPE) 
  653#define COMPLEX_FLOAT_TYPE_P(TYPE)      \ 
  654  (TREE_CODE (TYPE) == COMPLEX_TYPE     \ 
  655   && TREE_CODE (TREE_TYPE (TYPE)) == REAL_TYPE) 
 
  659#define VECTOR_INTEGER_TYPE_P(TYPE)                     \ 
  660  (VECTOR_TYPE_P (TYPE)                                 \ 
  661   && TREE_CODE (TREE_TYPE (TYPE)) == INTEGER_TYPE) 
 
  666#define VECTOR_FLOAT_TYPE_P(TYPE)       \ 
  667  (VECTOR_TYPE_P (TYPE)                 \ 
  668   && TREE_CODE (TREE_TYPE (TYPE)) == REAL_TYPE) 
 
  674#define FLOAT_TYPE_P(TYPE)                      \ 
  675  (SCALAR_FLOAT_TYPE_P (TYPE)                   \ 
  676   || ((TREE_CODE (TYPE) == COMPLEX_TYPE        \ 
  677        || VECTOR_TYPE_P (TYPE))                \ 
  678       && SCALAR_FLOAT_TYPE_P (TREE_TYPE (TYPE)))) 
 
  681#define DECIMAL_FLOAT_TYPE_P(TYPE)              \ 
  682  (SCALAR_FLOAT_TYPE_P (TYPE)                   \ 
  683   && DECIMAL_FLOAT_MODE_P (TYPE_MODE (TYPE))) 
 
  686#define RECORD_OR_UNION_TYPE_P(TYPE)            \ 
  687  (TREE_CODE (TYPE) == RECORD_TYPE              \ 
  688   || TREE_CODE (TYPE) == UNION_TYPE            \ 
  689   || TREE_CODE (TYPE) == QUAL_UNION_TYPE) 
 
  694#define AGGREGATE_TYPE_P(TYPE) \ 
  695  (TREE_CODE (TYPE) == ARRAY_TYPE || RECORD_OR_UNION_TYPE_P (TYPE)) 
 
  701#define POINTER_TYPE_P(TYPE) \ 
  702  (TREE_CODE (TYPE) == POINTER_TYPE || TREE_CODE (TYPE) == REFERENCE_TYPE) 
 
  705#define FUNCTION_POINTER_TYPE_P(TYPE) \ 
  706  (POINTER_TYPE_P (TYPE) && TREE_CODE (TREE_TYPE (TYPE)) == FUNCTION_TYPE) 
 
  709#define COMPLETE_TYPE_P(NODE) (TYPE_SIZE (NODE) != NULL_TREE) 
  712#define VOID_TYPE_P(NODE) (TREE_CODE (NODE) == VOID_TYPE) 
  715#define COMPLETE_OR_VOID_TYPE_P(NODE) \ 
  716  (COMPLETE_TYPE_P (NODE) || VOID_TYPE_P (NODE)) 
 
  719#define COMPLETE_OR_UNBOUND_ARRAY_TYPE_P(NODE) \ 
  720  (COMPLETE_TYPE_P (TREE_CODE (NODE) == ARRAY_TYPE ? TREE_TYPE (NODE) : (NODE))) 
 
  722#define FUNC_OR_METHOD_TYPE_P(NODE) \ 
  723  (TREE_CODE (NODE) == FUNCTION_TYPE || TREE_CODE (NODE) == METHOD_TYPE) 
 
  725#define OPAQUE_TYPE_P(NODE) \ 
  726    (TREE_CODE (NODE) == OPAQUE_TYPE) 
 
  745#define TREE_ADDRESSABLE(NODE) ((NODE)->base.addressable_flag) 
  750#define CALL_EXPR_TAILCALL(NODE) \ 
  751  (CALL_EXPR_CHECK (NODE)->base.addressable_flag) 
 
  755#define CALL_EXPR_MUST_TAIL_CALL(NODE) \ 
  756  (CALL_EXPR_CHECK (NODE)->base.static_flag) 
 
  760#define CASE_LOW_SEEN(NODE) \ 
  761  (CASE_LABEL_EXPR_CHECK (NODE)->base.addressable_flag) 
 
  763#define PREDICT_EXPR_OUTCOME(NODE) \ 
  764  ((enum prediction) (PREDICT_EXPR_CHECK (NODE)->base.addressable_flag)) 
 
  765#define SET_PREDICT_EXPR_OUTCOME(NODE, OUTCOME) \ 
  766  (PREDICT_EXPR_CHECK (NODE)->base.addressable_flag = (int) OUTCOME) 
 
  767#define PREDICT_EXPR_PREDICTOR(NODE) \ 
  768  ((enum br_predictor)tree_to_shwi (TREE_OPERAND (PREDICT_EXPR_CHECK (NODE), 0))) 
 
  773#define TREE_STATIC(NODE) ((NODE)->base.static_flag) 
  776#define TREE_NO_TRAMPOLINE(NODE) (ADDR_EXPR_CHECK (NODE)->base.static_flag) 
  781#define CLEANUP_EH_ONLY(NODE) ((NODE)->base.static_flag) 
  785#define TRY_CATCH_IS_CLEANUP(NODE) \ 
  786  (TRY_CATCH_EXPR_CHECK (NODE)->base.static_flag) 
 
  790#define CASE_HIGH_SEEN(NODE) \ 
  791  (CASE_LABEL_EXPR_CHECK (NODE)->base.static_flag) 
 
  794#define ENUM_IS_SCOPED(NODE) (ENUMERAL_TYPE_CHECK (NODE)->base.static_flag) 
  797#define ENUM_IS_OPAQUE(NODE) (ENUMERAL_TYPE_CHECK (NODE)->base.private_flag) 
  804#define TREE_NO_WARNING(NODE) ((NODE)->base.nowarning_flag) 
  808#define TRANSLATION_UNIT_WARN_EMPTY_P(NODE) \ 
  809  (TRANSLATION_UNIT_DECL_CHECK (NODE)->decl_common.decl_flag_0) 
 
  812#define TYPE_EMPTY_P(NODE) (TYPE_CHECK (NODE)->type_common.empty_flag) 
  815#define TYPE_ARTIFICIAL(NODE) (TYPE_CHECK (NODE)->base.nowarning_flag) 
  820#define TYPE_INDIVISIBLE_P(NODE) (TYPE_CHECK (NODE)->type_common.indivisible_p) 
  825#define TYPE_NO_NAMED_ARGS_STDARG_P(NODE) \ 
  826  (FUNC_OR_METHOD_CHECK (NODE)->type_common.no_named_args_stdarg_p) 
 
  830#define TYPE_INCLUDES_FLEXARRAY(NODE) \ 
  831  (RECORD_OR_UNION_CHECK (NODE)->type_common.no_named_args_stdarg_p) 
 
  835#define TREE_SYMBOL_REFERENCED(NODE) \ 
  836  (IDENTIFIER_NODE_CHECK (NODE)->base.static_flag) 
 
  840#define TYPE_REF_CAN_ALIAS_ALL(NODE) \ 
  841  (PTR_OR_REF_CHECK (NODE)->base.static_flag) 
 
  846#define TREE_OVERFLOW(NODE) (CST_CHECK (NODE)->base.public_flag) 
  850#define TREE_OVERFLOW_P(EXPR) \ 
  851 (CONSTANT_CLASS_P (EXPR) && TREE_OVERFLOW (EXPR)) 
 
  858#define TREE_PUBLIC(NODE) ((NODE)->base.public_flag) 
  862#define TYPE_CACHED_VALUES_P(NODE) (TYPE_CHECK (NODE)->base.public_flag) 
  866#define SAVE_EXPR_RESOLVED_P(NODE) \ 
  867  (SAVE_EXPR_CHECK (NODE)->base.public_flag) 
 
  871#define CALL_EXPR_VA_ARG_PACK(NODE) \ 
  872  (CALL_EXPR_CHECK (NODE)->base.public_flag) 
 
  879#define TREE_SIDE_EFFECTS(NODE) \ 
  880  (NON_TYPE_CHECK (NODE)->base.side_effects_flag) 
 
  885#define FORCED_LABEL(NODE) (LABEL_DECL_CHECK (NODE)->base.side_effects_flag) 
  889#define FALLTHROUGH_LABEL_P(NODE) \ 
  890  (LABEL_DECL_CHECK (NODE)->base.private_flag) 
 
  894#define SWITCH_BREAK_LABEL_P(NODE) \ 
  895  (LABEL_DECL_CHECK (NODE)->base.protected_flag) 
 
  900#define UNUSED_LABEL_P(NODE) \ 
  901  (LABEL_DECL_CHECK (NODE)->base.default_def_flag) 
 
  913#define VACUOUS_INIT_LABEL_P(NODE) \ 
  914  (LABEL_DECL_CHECK (NODE)->base.nothrow_flag) 
 
  929#define TREE_THIS_VOLATILE(NODE) ((NODE)->base.volatile_flag) 
  940#define TREE_THIS_NOTRAP(NODE) \ 
  941  (TREE_CHECK5 (NODE, INDIRECT_REF, MEM_REF, TARGET_MEM_REF, ARRAY_REF, \ 
  942                ARRAY_RANGE_REF)->base.nothrow_flag) 
 
  948#define TREE_READONLY(NODE) (NON_TYPE_CHECK (NODE)->base.readonly_flag) 
  952#define TREE_CONSTANT(NODE) (NON_TYPE_CHECK (NODE)->base.constant_flag) 
  955#define TYPE_SIZES_GIMPLIFIED(NODE) \ 
  956  (TYPE_CHECK (NODE)->base.constant_flag) 
 
  959#define DECL_UNSIGNED(NODE) \ 
  960  (DECL_COMMON_CHECK (NODE)->base.u.bits.unsigned_flag) 
 
  963#define TYPE_UNSIGNED(NODE) (TYPE_CHECK (NODE)->base.u.bits.unsigned_flag) 
  966#define TYPE_SIGN(NODE) ((signop) TYPE_UNSIGNED (NODE)) 
  970#define TYPE_OVERFLOW_WRAPS(TYPE) \ 
  971  (POINTER_TYPE_P (TYPE)                                        \ 
  972   ? flag_wrapv_pointer                                         \ 
  973   : (ANY_INTEGRAL_TYPE_CHECK(TYPE)->base.u.bits.unsigned_flag  \ 
 
  984#define TYPE_OVERFLOW_UNDEFINED(TYPE)                           \ 
  985  (POINTER_TYPE_P (TYPE)                                        \ 
  986   ? !flag_wrapv_pointer                                        \ 
  987   : (!ANY_INTEGRAL_TYPE_CHECK(TYPE)->base.u.bits.unsigned_flag \ 
  988      && !flag_wrapv && !flag_trapv)) 
 
  992#define TYPE_OVERFLOW_TRAPS(TYPE) \ 
  993  (!ANY_INTEGRAL_TYPE_CHECK(TYPE)->base.u.bits.unsigned_flag && flag_trapv) 
 
  996#define TYPE_OVERFLOW_SANITIZED(TYPE)                   \ 
  997  (INTEGRAL_TYPE_P (TYPE)                               \ 
  998   && !TYPE_OVERFLOW_WRAPS (TYPE)                       \ 
  999   && (flag_sanitize & SANITIZE_SI_OVERFLOW)) 
 
 1010#define TREE_ASM_WRITTEN(NODE) ((NODE)->base.asm_written_flag) 
 1017#define TREE_USED(NODE) ((NODE)->base.used_flag) 
 1023#define TREE_NOTHROW(NODE) ((NODE)->base.nothrow_flag) 
 1027#define CALL_EXPR_RETURN_SLOT_OPT(NODE) \ 
 1028  (CALL_EXPR_CHECK (NODE)->base.private_flag) 
 
 1033#define DECL_BY_REFERENCE(NODE) \ 
 1034  (TREE_CHECK3 (NODE, VAR_DECL, PARM_DECL, \ 
 1035                RESULT_DECL)->decl_common.decl_by_reference_flag) 
 
 1039#define DECL_READ_P(NODE) \ 
 1040  (TREE_CHECK2 (NODE, VAR_DECL, PARM_DECL)->decl_common.decl_read_flag) 
 
 1044#define DECL_NONSHAREABLE(NODE) \ 
 1045  (TREE_CHECK2 (NODE, VAR_DECL, \ 
 1046                RESULT_DECL)->decl_common.decl_nonshareable_flag) 
 
 1050#define DECL_HIDDEN_STRING_LENGTH(NODE) \ 
 1051  (TREE_CHECK (NODE, PARM_DECL)->decl_common.decl_nonshareable_flag) 
 
 1056#define CALL_FROM_THUNK_P(NODE) (CALL_EXPR_CHECK (NODE)->base.protected_flag) 
 1062#define CALL_ALLOCA_FOR_VAR_P(NODE) \ 
 1063  (CALL_EXPR_CHECK (NODE)->base.protected_flag) 
 
 1068#define CALL_FROM_NEW_OR_DELETE_P(NODE) \ 
 1069  (CALL_EXPR_CHECK (NODE)->base.protected_flag) 
 
 1072#define TREE_PRIVATE(NODE) ((NODE)->base.private_flag) 
 1074#define TREE_PROTECTED(NODE) ((NODE)->base.protected_flag) 
 1077#define TYPE_REF_IS_RVALUE(NODE) \ 
 1078  (REFERENCE_TYPE_CHECK (NODE)->base.private_flag) 
 
 1082#define TREE_DEPRECATED(NODE) \ 
 1083  ((NODE)->base.deprecated_flag) 
 
 1087#define TREE_UNAVAILABLE(NODE) \ 
 1088  ((NODE)->base.u.bits.unavailable_flag) 
 
 1092#define IDENTIFIER_ANON_P(NODE) \ 
 1093  (IDENTIFIER_NODE_CHECK (NODE)->base.private_flag) 
 
 1097#define IDENTIFIER_INTERNAL_P(NODE) \ 
 1098  (IDENTIFIER_NODE_CHECK (NODE)->base.volatile_flag) 
 
 1102#define IDENTIFIER_TRANSPARENT_ALIAS(NODE) \ 
 1103  (IDENTIFIER_NODE_CHECK (NODE)->base.deprecated_flag) 
 
 1108#define TYPE_REVERSE_STORAGE_ORDER(NODE) \ 
 1109  (TREE_CHECK4 (NODE, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, ARRAY_TYPE)->base.u.bits.saturating_flag) 
 
 1112#define TYPE_SATURATING(NODE) \ 
 1113  (TREE_NOT_CHECK4 (NODE, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, ARRAY_TYPE)->base.u.bits.saturating_flag) 
 
 1126#define REF_REVERSE_STORAGE_ORDER(NODE) \ 
 1127  (TREE_CHECK2 (NODE, BIT_FIELD_REF, MEM_REF)->base.default_def_flag) 
 
 1131#define FUNC_ADDR_BY_DESCRIPTOR(NODE) \ 
 1132  (TREE_CHECK (NODE, ADDR_EXPR)->base.default_def_flag) 
 
 1136#define CALL_EXPR_BY_DESCRIPTOR(NODE) \ 
 1137  (TREE_CHECK (NODE, CALL_EXPR)->base.default_def_flag) 
 
 1140#define TREE_LANG_FLAG_0(NODE) \ 
 1141  (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_0) 
 
 1142#define TREE_LANG_FLAG_1(NODE) \ 
 1143  (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_1) 
 
 1144#define TREE_LANG_FLAG_2(NODE) \ 
 1145  (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_2) 
 
 1146#define TREE_LANG_FLAG_3(NODE) \ 
 1147  (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_3) 
 
 1148#define TREE_LANG_FLAG_4(NODE) \ 
 1149  (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_4) 
 
 1150#define TREE_LANG_FLAG_5(NODE) \ 
 1151  (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_5) 
 
 1152#define TREE_LANG_FLAG_6(NODE) \ 
 1153  (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_6) 
 
 1157#define TREE_INT_CST_NUNITS(NODE) \ 
 1158  (INTEGER_CST_CHECK (NODE)->base.u.int_length.unextended) 
 
 1159#define TREE_INT_CST_EXT_NUNITS(NODE) \ 
 1160  (INTEGER_CST_CHECK (NODE)->base.u.int_length.extended) 
 
 1161#define TREE_INT_CST_ELT(NODE, I) TREE_INT_CST_ELT_CHECK (NODE, I) 
 1162#define TREE_INT_CST_LOW(NODE) \ 
 1163  ((unsigned HOST_WIDE_INT) TREE_INT_CST_ELT (NODE, 0)) 
 
 1167#define POLY_INT_CST_P(NODE) \ 
 1168  (NUM_POLY_INT_COEFFS > 1 && TREE_CODE (NODE) == POLY_INT_CST) 
 
 1171#define POLY_INT_CST_COEFF(NODE, I) \ 
 1172  (POLY_INT_CST_CHECK (NODE)->poly_int_cst.coeffs[I]) 
 
 1174#define TREE_REAL_CST_PTR(NODE) (&REAL_CST_CHECK (NODE)->real_cst.value) 
 1175#define TREE_REAL_CST(NODE) (*TREE_REAL_CST_PTR (NODE)) 
 1177#define TREE_FIXED_CST_PTR(NODE) \ 
 1178  (FIXED_CST_CHECK (NODE)->fixed_cst.fixed_cst_ptr) 
 
 1179#define TREE_FIXED_CST(NODE) (*TREE_FIXED_CST_PTR (NODE)) 
 1183#define TREE_STRING_LENGTH(NODE) (STRING_CST_CHECK (NODE)->string.length) 
 1184#define TREE_STRING_POINTER(NODE) \ 
 1185  ((const char *)(STRING_CST_CHECK (NODE)->string.str)) 
 
 1188#define RAW_DATA_LENGTH(NODE) \ 
 1189  (RAW_DATA_CST_CHECK (NODE)->raw_data_cst.length) 
 
 1190#define RAW_DATA_POINTER(NODE) \ 
 1191  (RAW_DATA_CST_CHECK (NODE)->raw_data_cst.str) 
 
 1192#define RAW_DATA_OWNER(NODE) \ 
 1193  (RAW_DATA_CST_CHECK (NODE)->raw_data_cst.owner) 
 
 1194#define RAW_DATA_UCHAR_ELT(NODE, I) \ 
 1195  (((const unsigned char *) RAW_DATA_POINTER (NODE))[I]) 
 
 1196#define RAW_DATA_SCHAR_ELT(NODE, I) \ 
 1197  (((const signed char *) RAW_DATA_POINTER (NODE))[I]) 
 
 1200#define TREE_REALPART(NODE) (COMPLEX_CST_CHECK (NODE)->complex.real) 
 1201#define TREE_IMAGPART(NODE) (COMPLEX_CST_CHECK (NODE)->complex.imag) 
 1204#define VECTOR_CST_NELTS(NODE) (TYPE_VECTOR_SUBPARTS (TREE_TYPE (NODE))) 
 1205#define VECTOR_CST_ELT(NODE,IDX) vector_cst_elt (NODE, IDX) 
 1207#define VECTOR_CST_LOG2_NPATTERNS(NODE) \ 
 1208  (VECTOR_CST_CHECK (NODE)->base.u.vector_cst.log2_npatterns) 
 
 1209#define VECTOR_CST_NPATTERNS(NODE) \ 
 1210  (1U << VECTOR_CST_LOG2_NPATTERNS (NODE)) 
 
 1211#define VECTOR_CST_NELTS_PER_PATTERN(NODE) \ 
 1212  (VECTOR_CST_CHECK (NODE)->base.u.vector_cst.nelts_per_pattern) 
 
 1213#define VECTOR_CST_DUPLICATE_P(NODE) \ 
 1214  (VECTOR_CST_NELTS_PER_PATTERN (NODE) == 1) 
 
 1215#define VECTOR_CST_STEPPED_P(NODE) \ 
 1216  (VECTOR_CST_NELTS_PER_PATTERN (NODE) == 3) 
 
 1217#define VECTOR_CST_ENCODED_ELTS(NODE) \ 
 1218  (VECTOR_CST_CHECK (NODE)->vector.elts) 
 
 1219#define VECTOR_CST_ENCODED_ELT(NODE, ELT) \ 
 1220  (VECTOR_CST_CHECK (NODE)->vector.elts[ELT]) 
 
 1225#define IDENTIFIER_LENGTH(NODE) \ 
 1226  (IDENTIFIER_NODE_CHECK (NODE)->identifier.id.len) 
 
 1227#define IDENTIFIER_POINTER(NODE) \ 
 1228  ((const char *) IDENTIFIER_NODE_CHECK (NODE)->identifier.id.str) 
 
 1229#define IDENTIFIER_HASH_VALUE(NODE) \ 
 1230  (IDENTIFIER_NODE_CHECK (NODE)->identifier.id.hash_value) 
 
 1235#define HT_IDENT_TO_GCC_IDENT(NODE) \ 
 1236  ((tree) ((char *) (NODE) - sizeof (struct tree_common))) 
 
 1237#define GCC_IDENT_TO_HT_IDENT(NODE) (&((struct tree_identifier *) (NODE))->id) 
 1240#define TREE_PURPOSE(NODE) (TREE_LIST_CHECK (NODE)->list.purpose) 
 1241#define TREE_VALUE(NODE) (TREE_LIST_CHECK (NODE)->list.value) 
 1244#define TREE_VEC_LENGTH(NODE) (TREE_VEC_CHECK (NODE)->base.u.length) 
 1245#define TREE_VEC_BEGIN(NODE) (&TREE_VEC_CHECK (NODE)->vec.a[0]) 
 1246#define TREE_VEC_END(NODE) \ 
 1247  ((void) TREE_VEC_CHECK (NODE), &((NODE)->vec.a[(NODE)->base.u.length])) 
 
 1249#define TREE_VEC_ELT(NODE,I) TREE_VEC_ELT_CHECK (NODE, I) 
 1252#define CONSTRUCTOR_ELTS(NODE) (CONSTRUCTOR_CHECK (NODE)->constructor.elts) 
 1253#define CONSTRUCTOR_ELT(NODE,IDX) \ 
 1254  (&(*CONSTRUCTOR_ELTS (NODE))[IDX]) 
 
 1255#define CONSTRUCTOR_NELTS(NODE) \ 
 1256  (vec_safe_length (CONSTRUCTOR_ELTS (NODE))) 
 
 1257#define CONSTRUCTOR_NO_CLEARING(NODE) \ 
 1258  (CONSTRUCTOR_CHECK (NODE)->base.public_flag) 
 
 1260#define CONSTRUCTOR_ZERO_PADDING_BITS(NODE) \ 
 1261  (CONSTRUCTOR_CHECK (NODE)->base.default_def_flag) 
 
 1266#define FOR_EACH_CONSTRUCTOR_VALUE(V, IX, VAL) \ 
 1267  for (IX = 0; (IX >= vec_safe_length (V)) \ 
 1269               : ((VAL = (*(V))[IX].value), \ 
 
 1276#define FOR_EACH_CONSTRUCTOR_ELT(V, IX, INDEX, VAL) \ 
 1277  for (IX = 0; (IX >= vec_safe_length (V)) \ 
 1279               : (((void) (VAL = (*V)[IX].value)), \ 
 1280                  (INDEX = (*V)[IX].index), \ 
 
 1285#define CONSTRUCTOR_APPEND_ELT(V, INDEX, VALUE) \ 
 1287    constructor_elt _ce___ = {INDEX, VALUE}; \ 
 1288    vec_safe_push ((V), _ce___); \ 
 
 1293#define CONSTRUCTOR_BITFIELD_P(NODE) \ 
 1294  (DECL_BIT_FIELD (FIELD_DECL_CHECK (NODE)) \ 
 1295   && (DECL_MODE (NODE) != BLKmode \ 
 1296       || TREE_CODE (TREE_TYPE (NODE)) == BITINT_TYPE)) 
 
 1303#define TREE_CLOBBER_P(NODE) \ 
 1304  (TREE_CODE (NODE) == CONSTRUCTOR && TREE_THIS_VOLATILE (NODE)) 
 
 1307#define CLOBBER_KIND(NODE) \ 
 1308  (CONSTRUCTOR_CHECK (NODE)->base.u.bits.address_space) 
 
 1313#define IS_EMPTY_STMT(NODE)     (TREE_CODE (NODE) == NOP_EXPR \ 
 1314                                 && VOID_TYPE_P (TREE_TYPE (NODE)) \ 
 1315                                 && integer_zerop (TREE_OPERAND (NODE, 0))) 
 
 1318#define TREE_OPERAND_LENGTH(NODE) tree_operand_length (NODE) 
 1319#define TREE_OPERAND(NODE, I) TREE_OPERAND_CHECK (NODE, I) 
 1326#define VL_EXP_OPERAND_LENGTH(NODE) \ 
 1327  ((int)TREE_INT_CST_LOW (VL_EXP_CHECK (NODE)->exp.operands[0])) 
 
 1330#define MAY_HAVE_DEBUG_MARKER_STMTS debug_nonbind_markers_p 
 1333#define MAY_HAVE_DEBUG_BIND_STMTS flag_var_tracking_assignments 
 1335#define MAY_HAVE_DEBUG_STMTS                                    \ 
 1336  (MAY_HAVE_DEBUG_MARKER_STMTS || MAY_HAVE_DEBUG_BIND_STMTS) 
 
 1339#define LOOP_EXPR_BODY(NODE) TREE_OPERAND_CHECK_CODE (NODE, LOOP_EXPR, 0) 
 1344#define EXPR_LOCATION(NODE) \ 
 1345  (CAN_HAVE_LOCATION_P ((NODE)) ? (NODE)->exp.locus : UNKNOWN_LOCATION) 
 
 1346#define SET_EXPR_LOCATION(NODE, LOCUS) EXPR_CHECK ((NODE))->exp.locus = (LOCUS) 
 1347#define EXPR_HAS_LOCATION(NODE) (LOCATION_LOCUS (EXPR_LOCATION (NODE))  \ 
 1348  != UNKNOWN_LOCATION) 
 
 1351#define EXPR_LOC_OR_LOC(NODE, LOCUS) (EXPR_HAS_LOCATION (NODE) \ 
 1352                                      ? (NODE)->exp.locus : (LOCUS)) 
 
 1353#define EXPR_FILENAME(NODE) LOCATION_FILE (EXPR_CHECK ((NODE))->exp.locus) 
 1354#define EXPR_LINENO(NODE) LOCATION_LINE (EXPR_CHECK (NODE)->exp.locus) 
 1356#define CAN_HAVE_RANGE_P(NODE) (CAN_HAVE_LOCATION_P (NODE)) 
 1357#define EXPR_LOCATION_RANGE(NODE) (get_expr_source_range (EXPR_CHECK ((NODE)))) 
 1359#define EXPR_HAS_RANGE(NODE) \ 
 1360    (CAN_HAVE_RANGE_P (NODE) \ 
 1361     ? EXPR_LOCATION_RANGE (NODE).m_start != UNKNOWN_LOCATION \ 
 
 1366#define CAN_HAVE_LOCATION_P(NODE) ((NODE) && EXPR_P (NODE)) 
 1377ATTRIBUTE_WARN_UNUSED_RESULT
 
 1396#define TARGET_EXPR_SLOT(NODE) TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 0) 
 1397#define TARGET_EXPR_INITIAL(NODE) TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 1) 
 1398#define TARGET_EXPR_CLEANUP(NODE) TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 2) 
 1401#define TARGET_EXPR_NO_ELIDE(NODE) (TARGET_EXPR_CHECK (NODE)->base.private_flag) 
 1405#define DECL_EXPR_DECL(NODE)    TREE_OPERAND (DECL_EXPR_CHECK (NODE), 0) 
 1407#define EXIT_EXPR_COND(NODE)         TREE_OPERAND (EXIT_EXPR_CHECK (NODE), 0) 
 1410#define COMPOUND_LITERAL_EXPR_DECL_EXPR(NODE)           \ 
 1411  TREE_OPERAND (COMPOUND_LITERAL_EXPR_CHECK (NODE), 0) 
 
 1412#define COMPOUND_LITERAL_EXPR_DECL(NODE)                        \ 
 1413  DECL_EXPR_DECL (COMPOUND_LITERAL_EXPR_DECL_EXPR (NODE)) 
 
 1416#define SWITCH_COND(NODE)       TREE_OPERAND (SWITCH_EXPR_CHECK (NODE), 0) 
 1417#define SWITCH_BODY(NODE)       TREE_OPERAND (SWITCH_EXPR_CHECK (NODE), 1) 
 1421#define SWITCH_ALL_CASES_P(NODE) (SWITCH_EXPR_CHECK (NODE)->base.private_flag) 
 1425#define CASE_LOW(NODE)                  TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 0) 
 1426#define CASE_HIGH(NODE)                 TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 1) 
 1427#define CASE_LABEL(NODE)                TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 2) 
 1428#define CASE_CHAIN(NODE)                TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 3) 
 1432#define TMR_BASE(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 0)) 
 1433#define TMR_OFFSET(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 1)) 
 1434#define TMR_INDEX(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 2)) 
 1435#define TMR_STEP(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 3)) 
 1436#define TMR_INDEX2(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 4)) 
 1438#define MR_DEPENDENCE_CLIQUE(NODE) \ 
 1439  (TREE_CHECK2 (NODE, MEM_REF, TARGET_MEM_REF)->base.u.dependence_info.clique) 
 
 1440#define MR_DEPENDENCE_BASE(NODE) \ 
 1441  (TREE_CHECK2 (NODE, MEM_REF, TARGET_MEM_REF)->base.u.dependence_info.base) 
 
 1444#define BIND_EXPR_VARS(NODE) (TREE_OPERAND (BIND_EXPR_CHECK (NODE), 0)) 
 1445#define BIND_EXPR_BODY(NODE) (TREE_OPERAND (BIND_EXPR_CHECK (NODE), 1)) 
 1446#define BIND_EXPR_BLOCK(NODE) (TREE_OPERAND (BIND_EXPR_CHECK (NODE), 2)) 
 1450#define GOTO_DESTINATION(NODE)  TREE_OPERAND (GOTO_EXPR_CHECK (NODE), 0) 
 1456#define ASM_STRING(NODE)        TREE_OPERAND (ASM_EXPR_CHECK (NODE), 0) 
 1457#define ASM_OUTPUTS(NODE)       TREE_OPERAND (ASM_EXPR_CHECK (NODE), 1) 
 1458#define ASM_INPUTS(NODE)        TREE_OPERAND (ASM_EXPR_CHECK (NODE), 2) 
 1459#define ASM_CLOBBERS(NODE)      TREE_OPERAND (ASM_EXPR_CHECK (NODE), 3) 
 1460#define ASM_LABELS(NODE)        TREE_OPERAND (ASM_EXPR_CHECK (NODE), 4) 
 1464#define ASM_BASIC_P(NODE)       (ASM_EXPR_CHECK (NODE)->base.static_flag) 
 1465#define ASM_VOLATILE_P(NODE)    (ASM_EXPR_CHECK (NODE)->base.public_flag) 
 1468#define ASM_INLINE_P(NODE)      (ASM_EXPR_CHECK (NODE)->base.protected_flag) 
 1471#define COND_EXPR_COND(NODE)    (TREE_OPERAND (COND_EXPR_CHECK (NODE), 0)) 
 1472#define COND_EXPR_THEN(NODE)    (TREE_OPERAND (COND_EXPR_CHECK (NODE), 1)) 
 1473#define COND_EXPR_ELSE(NODE)    (TREE_OPERAND (COND_EXPR_CHECK (NODE), 2)) 
 1476#define CHREC_LEFT(NODE)        TREE_OPERAND (POLYNOMIAL_CHREC_CHECK (NODE), 0) 
 1477#define CHREC_RIGHT(NODE)       TREE_OPERAND (POLYNOMIAL_CHREC_CHECK (NODE), 1) 
 1478#define CHREC_VARIABLE(NODE)    POLYNOMIAL_CHREC_CHECK (NODE)->base.u.chrec_var 
 1480#define CHREC_NOWRAP(NODE)      POLYNOMIAL_CHREC_CHECK (NODE)->base.nothrow_flag 
 1484#define LABEL_EXPR_LABEL(NODE)  TREE_OPERAND (LABEL_EXPR_CHECK (NODE), 0) 
 1487#define CATCH_TYPES(NODE)       TREE_OPERAND (CATCH_EXPR_CHECK (NODE), 0) 
 1488#define CATCH_BODY(NODE)        TREE_OPERAND (CATCH_EXPR_CHECK (NODE), 1) 
 1491#define EH_FILTER_TYPES(NODE)   TREE_OPERAND (EH_FILTER_EXPR_CHECK (NODE), 0) 
 1492#define EH_FILTER_FAILURE(NODE) TREE_OPERAND (EH_FILTER_EXPR_CHECK (NODE), 1) 
 1495#define OBJ_TYPE_REF_EXPR(NODE)   TREE_OPERAND (OBJ_TYPE_REF_CHECK (NODE), 0) 
 1496#define OBJ_TYPE_REF_OBJECT(NODE) TREE_OPERAND (OBJ_TYPE_REF_CHECK (NODE), 1) 
 1497#define OBJ_TYPE_REF_TOKEN(NODE)  TREE_OPERAND (OBJ_TYPE_REF_CHECK (NODE), 2) 
 1500#define CALL_EXPR_FN(NODE) TREE_OPERAND (CALL_EXPR_CHECK (NODE), 1) 
 1501#define CALL_EXPR_STATIC_CHAIN(NODE) TREE_OPERAND (CALL_EXPR_CHECK (NODE), 2) 
 1502#define CALL_EXPR_ARG(NODE, I) TREE_OPERAND (CALL_EXPR_CHECK (NODE), (I) + 3) 
 1503#define call_expr_nargs(NODE) (VL_EXP_OPERAND_LENGTH (NODE) - 3) 
 1504#define CALL_EXPR_IFN(NODE) (CALL_EXPR_CHECK (NODE)->base.u.ifn) 
 1512#define CALL_EXPR_ARGP(NODE) \ 
 1513  (&(TREE_OPERAND (CALL_EXPR_CHECK (NODE), 0)) + 3) 
 
 1516#define TRANSACTION_EXPR_BODY(NODE) \ 
 1517  TREE_OPERAND (TRANSACTION_EXPR_CHECK (NODE), 0) 
 
 1518#define TRANSACTION_EXPR_OUTER(NODE) \ 
 1519  (TRANSACTION_EXPR_CHECK (NODE)->base.static_flag) 
 
 1520#define TRANSACTION_EXPR_RELAXED(NODE) \ 
 1521  (TRANSACTION_EXPR_CHECK (NODE)->base.public_flag) 
 
 1527#define OMP_BODY(NODE) \ 
 1528  TREE_OPERAND (TREE_RANGE_CHECK (NODE, OACC_PARALLEL, OMP_MASTER), 0) 
 
 1529#define OMP_CLAUSES(NODE) \ 
 1530  TREE_OPERAND (TREE_RANGE_CHECK (NODE, OACC_PARALLEL, OMP_SCAN), 1) 
 
 1533#define OMP_STANDALONE_CLAUSES(NODE) \ 
 1534  TREE_OPERAND (TREE_RANGE_CHECK (NODE, OACC_CACHE, OMP_TARGET_EXIT_DATA), 0) 
 
 1536#define OACC_DATA_BODY(NODE) \ 
 1537  TREE_OPERAND (OACC_DATA_CHECK (NODE), 0) 
 
 1538#define OACC_DATA_CLAUSES(NODE) \ 
 1539  TREE_OPERAND (OACC_DATA_CHECK (NODE), 1) 
 
 1541#define OACC_HOST_DATA_BODY(NODE) \ 
 1542  TREE_OPERAND (OACC_HOST_DATA_CHECK (NODE), 0) 
 
 1543#define OACC_HOST_DATA_CLAUSES(NODE) \ 
 1544  TREE_OPERAND (OACC_HOST_DATA_CHECK (NODE), 1) 
 
 1546#define OACC_CACHE_CLAUSES(NODE) \ 
 1547  TREE_OPERAND (OACC_CACHE_CHECK (NODE), 0) 
 
 1549#define OACC_DECLARE_CLAUSES(NODE) \ 
 1550  TREE_OPERAND (OACC_DECLARE_CHECK (NODE), 0) 
 
 1552#define OACC_ENTER_DATA_CLAUSES(NODE) \ 
 1553  TREE_OPERAND (OACC_ENTER_DATA_CHECK (NODE), 0) 
 
 1555#define OACC_EXIT_DATA_CLAUSES(NODE) \ 
 1556  TREE_OPERAND (OACC_EXIT_DATA_CHECK (NODE), 0) 
 
 1558#define OACC_UPDATE_CLAUSES(NODE) \ 
 1559  TREE_OPERAND (OACC_UPDATE_CHECK (NODE), 0) 
 
 1561#define OMP_PARALLEL_BODY(NODE)    TREE_OPERAND (OMP_PARALLEL_CHECK (NODE), 0) 
 1562#define OMP_PARALLEL_CLAUSES(NODE) TREE_OPERAND (OMP_PARALLEL_CHECK (NODE), 1) 
 1564#define OMP_TASK_BODY(NODE)        TREE_OPERAND (OMP_TASK_CHECK (NODE), 0) 
 1565#define OMP_TASK_CLAUSES(NODE)     TREE_OPERAND (OMP_TASK_CHECK (NODE), 1) 
 1567#define OMP_TASKREG_CHECK(NODE)   TREE_RANGE_CHECK (NODE, OMP_PARALLEL, OMP_TASK) 
 1568#define OMP_TASKREG_BODY(NODE)    TREE_OPERAND (OMP_TASKREG_CHECK (NODE), 0) 
 1569#define OMP_TASKREG_CLAUSES(NODE) TREE_OPERAND (OMP_TASKREG_CHECK (NODE), 1) 
 1571#define OMP_LOOPING_CHECK(NODE) TREE_RANGE_CHECK (NODE, OMP_FOR, OACC_LOOP) 
 1572#define OMP_FOR_BODY(NODE)         TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 0) 
 1573#define OMP_FOR_CLAUSES(NODE)      TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 1) 
 1574#define OMP_FOR_INIT(NODE)         TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 2) 
 1575#define OMP_FOR_COND(NODE)         TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 3) 
 1576#define OMP_FOR_INCR(NODE)         TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 4) 
 1577#define OMP_FOR_PRE_BODY(NODE)     TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 5) 
 1578#define OMP_FOR_ORIG_DECLS(NODE)   TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 6) 
 1580#define OMP_INTEROP_CLAUSES(NODE)\ 
 1581  TREE_OPERAND (OMP_INTEROP_CHECK (NODE), 0) 
 
 1583#define OMP_LOOPXFORM_CHECK(NODE) TREE_RANGE_CHECK (NODE, OMP_TILE, OMP_UNROLL) 
 1584#define OMP_LOOPXFORM_LOWERED(NODE) \ 
 1585  (OMP_LOOPXFORM_CHECK (NODE)->base.public_flag) 
 
 1587#define OMP_SECTIONS_BODY(NODE)    TREE_OPERAND (OMP_SECTIONS_CHECK (NODE), 0) 
 1588#define OMP_SECTIONS_CLAUSES(NODE) TREE_OPERAND (OMP_SECTIONS_CHECK (NODE), 1) 
 1590#define OMP_SECTION_BODY(NODE)     TREE_OPERAND (OMP_SECTION_CHECK (NODE), 0) 
 1592#define OMP_STRUCTURED_BLOCK_BODY(NODE) \ 
 1593  TREE_OPERAND (OMP_STRUCTURED_BLOCK_CHECK (NODE), 0) 
 
 1595#define OMP_SINGLE_BODY(NODE)      TREE_OPERAND (OMP_SINGLE_CHECK (NODE), 0) 
 1596#define OMP_SINGLE_CLAUSES(NODE)   TREE_OPERAND (OMP_SINGLE_CHECK (NODE), 1) 
 1598#define OMP_SCOPE_BODY(NODE)       TREE_OPERAND (OMP_SCOPE_CHECK (NODE), 0) 
 1599#define OMP_SCOPE_CLAUSES(NODE)    TREE_OPERAND (OMP_SCOPE_CHECK (NODE), 1) 
 1601#define OMP_MASTER_BODY(NODE)      TREE_OPERAND (OMP_MASTER_CHECK (NODE), 0) 
 1603#define OMP_MASKED_BODY(NODE)      TREE_OPERAND (OMP_MASKED_CHECK (NODE), 0) 
 1604#define OMP_MASKED_CLAUSES(NODE)   TREE_OPERAND (OMP_MASKED_CHECK (NODE), 1) 
 1606#define OMP_TASKGROUP_BODY(NODE)   TREE_OPERAND (OMP_TASKGROUP_CHECK (NODE), 0) 
 1607#define OMP_TASKGROUP_CLAUSES(NODE) \ 
 1608  TREE_OPERAND (OMP_TASKGROUP_CHECK (NODE), 1) 
 
 1610#define OMP_ORDERED_BODY(NODE)     TREE_OPERAND (OMP_ORDERED_CHECK (NODE), 0) 
 1611#define OMP_ORDERED_CLAUSES(NODE)  TREE_OPERAND (OMP_ORDERED_CHECK (NODE), 1) 
 1613#define OMP_CRITICAL_BODY(NODE)    TREE_OPERAND (OMP_CRITICAL_CHECK (NODE), 0) 
 1614#define OMP_CRITICAL_CLAUSES(NODE) TREE_OPERAND (OMP_CRITICAL_CHECK (NODE), 1) 
 1615#define OMP_CRITICAL_NAME(NODE)    TREE_OPERAND (OMP_CRITICAL_CHECK (NODE), 2) 
 1617#define OMP_TEAMS_BODY(NODE)       TREE_OPERAND (OMP_TEAMS_CHECK (NODE), 0) 
 1618#define OMP_TEAMS_CLAUSES(NODE)    TREE_OPERAND (OMP_TEAMS_CHECK (NODE), 1) 
 1620#define OMP_TARGET_DATA_BODY(NODE) \ 
 1621  TREE_OPERAND (OMP_TARGET_DATA_CHECK (NODE), 0) 
 
 1622#define OMP_TARGET_DATA_CLAUSES(NODE)\ 
 1623  TREE_OPERAND (OMP_TARGET_DATA_CHECK (NODE), 1) 
 
 1625#define OMP_TARGET_BODY(NODE)      TREE_OPERAND (OMP_TARGET_CHECK (NODE), 0) 
 1626#define OMP_TARGET_CLAUSES(NODE)   TREE_OPERAND (OMP_TARGET_CHECK (NODE), 1) 
 1628#define OMP_TARGET_UPDATE_CLAUSES(NODE)\ 
 1629  TREE_OPERAND (OMP_TARGET_UPDATE_CHECK (NODE), 0) 
 
 1631#define OMP_TARGET_ENTER_DATA_CLAUSES(NODE)\ 
 1632  TREE_OPERAND (OMP_TARGET_ENTER_DATA_CHECK (NODE), 0) 
 
 1634#define OMP_TARGET_EXIT_DATA_CLAUSES(NODE)\ 
 1635  TREE_OPERAND (OMP_TARGET_EXIT_DATA_CHECK (NODE), 0) 
 
 1637#define OMP_METADIRECTIVE_VARIANTS(NODE) \ 
 1638  TREE_OPERAND (OMP_METADIRECTIVE_CHECK (NODE), 0) 
 
 1640#define OMP_METADIRECTIVE_VARIANT_SELECTOR(v) \ 
 
 1642#define OMP_METADIRECTIVE_VARIANT_DIRECTIVE(v) \ 
 1643  TREE_PURPOSE (TREE_VALUE (v)) 
 
 1644#define OMP_METADIRECTIVE_VARIANT_BODY(v) \ 
 1645  TREE_VALUE (TREE_VALUE (v)) 
 
 1647#define OMP_DECLARE_MAPPER_ID(NODE) \ 
 1648  TREE_OPERAND (OMP_DECLARE_MAPPER_CHECK (NODE), 0) 
 
 1649#define OMP_DECLARE_MAPPER_DECL(NODE) \ 
 1650  TREE_OPERAND (OMP_DECLARE_MAPPER_CHECK (NODE), 1) 
 
 1651#define OMP_DECLARE_MAPPER_CLAUSES(NODE) \ 
 1652  TREE_OPERAND (OMP_DECLARE_MAPPER_CHECK (NODE), 2) 
 
 1654#define OMP_SCAN_BODY(NODE)     TREE_OPERAND (OMP_SCAN_CHECK (NODE), 0) 
 1655#define OMP_SCAN_CLAUSES(NODE)  TREE_OPERAND (OMP_SCAN_CHECK (NODE), 1) 
 1657#define OMP_DISPATCH_BODY(NODE) TREE_OPERAND (OMP_DISPATCH_CHECK (NODE), 0) 
 1658#define OMP_DISPATCH_CLAUSES(NODE) TREE_OPERAND (OMP_DISPATCH_CHECK (NODE), 1) 
 1660#define OMP_CLAUSE_SIZE(NODE)                                           \ 
 1661  OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (OMP_CLAUSE_CHECK (NODE),  \ 
 1663                                              OMP_CLAUSE__CACHE_), 1) 
 
 1665#define OMP_CLAUSE_CHAIN(NODE)     TREE_CHAIN (OMP_CLAUSE_CHECK (NODE)) 
 1666#define OMP_CLAUSE_DECL(NODE)                                           \ 
 1667  OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (OMP_CLAUSE_CHECK (NODE),  \ 
 1668                                              OMP_CLAUSE_PRIVATE,       \ 
 1669                                              OMP_CLAUSE__SCANTEMP_), 0) 
 
 1670#define OMP_CLAUSE_HAS_LOCATION(NODE) \ 
 1671  (LOCATION_LOCUS ((OMP_CLAUSE_CHECK (NODE))->omp_clause.locus)         \ 
 1672  != UNKNOWN_LOCATION) 
 
 1673#define OMP_CLAUSE_LOCATION(NODE)  (OMP_CLAUSE_CHECK (NODE))->omp_clause.locus 
 1675#define OMP_CLAUSE_HAS_ITERATORS(NODE) \ 
 1676  ((OMP_CLAUSE_CODE (NODE) == OMP_CLAUSE_FROM                           \ 
 1677    || OMP_CLAUSE_CODE (NODE) == OMP_CLAUSE_TO                          \ 
 1678    || OMP_CLAUSE_CODE (NODE) == OMP_CLAUSE_MAP)                        \ 
 1679   && OMP_CLAUSE_ITERATORS (NODE)) 
 
 1680#define OMP_CLAUSE_ITERATORS(NODE) \ 
 1681  OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (OMP_CLAUSE_CHECK (NODE),  \ 
 
 1687#define OMP_FOR_NON_RECTANGULAR(NODE) \ 
 1688  (OMP_LOOPING_CHECK (NODE)->base.private_flag) 
 
 1692#define OMP_SECTION_LAST(NODE) \ 
 1693  (OMP_SECTION_CHECK (NODE)->base.private_flag) 
 
 1697#define OMP_PARALLEL_COMBINED(NODE) \ 
 1698  (OMP_PARALLEL_CHECK (NODE)->base.private_flag) 
 
 1702#define OMP_TEAMS_COMBINED(NODE) \ 
 1703  (OMP_TEAMS_CHECK (NODE)->base.private_flag) 
 
 1707#define OMP_TARGET_COMBINED(NODE) \ 
 1708  (OMP_TARGET_CHECK (NODE)->base.private_flag) 
 
 1712#define OMP_MASTER_COMBINED(NODE) \ 
 1713  (OMP_MASTER_CHECK (NODE)->base.private_flag) 
 
 1717#define OMP_MASKED_COMBINED(NODE) \ 
 1718  (OMP_MASKED_CHECK (NODE)->base.private_flag) 
 
 1721#define OMP_ATOMIC_MEMORY_ORDER(NODE) \ 
 1722  (TREE_RANGE_CHECK (NODE, OMP_ATOMIC, \ 
 1723                     OMP_ATOMIC_CAPTURE_NEW)->base.u.omp_atomic_memory_order) 
 
 1726#define OMP_ATOMIC_WEAK(NODE) \ 
 1727  (TREE_RANGE_CHECK (NODE, OMP_ATOMIC, \ 
 1728                     OMP_ATOMIC_CAPTURE_NEW)->base.public_flag) 
 
 1733#define OMP_CLAUSE_PRIVATE_DEBUG(NODE) \ 
 1734  (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_PRIVATE)->base.public_flag) 
 
 1738#define OMP_CLAUSE_PRIVATE_OUTER_REF(NODE) \ 
 1739  TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_PRIVATE)) 
 
 1744#define OMP_CLAUSE_PRIVATE_TASKLOOP_IV(NODE) \ 
 1745  TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_PRIVATE)) 
 
 1748#define OMP_CLAUSE_FIRSTPRIVATE_IMPLICIT(NODE) \ 
 1749  (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_FIRSTPRIVATE)->base.public_flag) 
 
 1753#define OMP_CLAUSE_FIRSTPRIVATE_NO_REFERENCE(NODE) \ 
 1754  TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_FIRSTPRIVATE)) 
 
 1758#define OMP_CLAUSE_FIRSTPRIVATE_IMPLICIT_TARGET(NODE) \ 
 1759  TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_FIRSTPRIVATE)) 
 
 1763#define OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE(NODE) \ 
 1764  (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LASTPRIVATE)->base.public_flag) 
 
 1765#define OMP_CLAUSE_LASTPRIVATE_STMT(NODE) \ 
 1766  OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE,                   \ 
 1767                                                OMP_CLAUSE_LASTPRIVATE),\ 
 
 1769#define OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ(NODE) \ 
 1770  (OMP_CLAUSE_CHECK (NODE))->omp_clause.gimple_reduction_init 
 
 1776#define OMP_CLAUSE_LASTPRIVATE_LOOP_IV(NODE) \ 
 1777  TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LASTPRIVATE)) 
 
 1780#define OMP_CLAUSE_LASTPRIVATE_CONDITIONAL(NODE) \ 
 1781  TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LASTPRIVATE)) 
 
 1786#define OMP_CLAUSE_SHARED_FIRSTPRIVATE(NODE) \ 
 1787  (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SHARED)->base.public_flag) 
 
 1791#define OMP_CLAUSE_SHARED_READONLY(NODE) \ 
 1792  TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SHARED)) 
 
 1794#define OMP_CLAUSE_IF_MODIFIER(NODE)    \ 
 1795  (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_IF)->omp_clause.subcode.if_modifier) 
 
 1797#define OMP_CLAUSE_FINAL_EXPR(NODE) \ 
 1798  OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_FINAL), 0) 
 
 1799#define OMP_CLAUSE_IF_EXPR(NODE) \ 
 1800  OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_IF), 0) 
 
 1801#define OMP_CLAUSE_SELF_EXPR(NODE) \ 
 1802  OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SELF), 0) 
 
 1803#define OMP_CLAUSE_NUM_THREADS_EXPR(NODE) \ 
 1804  OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_THREADS),0) 
 
 1805#define OMP_CLAUSE_SCHEDULE_CHUNK_EXPR(NODE) \ 
 1806  OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SCHEDULE), 0) 
 
 1807#define OMP_CLAUSE_NUM_TASKS_EXPR(NODE) \ 
 1808  OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_TASKS), 0) 
 
 1809#define OMP_CLAUSE_HINT_EXPR(NODE) \ 
 1810  OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_HINT), 0) 
 
 1811#define OMP_CLAUSE_FILTER_EXPR(NODE) \ 
 1812  OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_FILTER), 0) 
 
 1813#define OMP_CLAUSE_PARTIAL_EXPR(NODE) \ 
 1814  OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_PARTIAL), 0) 
 
 1815#define OMP_CLAUSE_SIZES_LIST(NODE) \ 
 1816  OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SIZES), 0) 
 
 1817#define OMP_CLAUSE_NOVARIANTS_EXPR(NODE)                                       \ 
 1818  OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NOVARIANTS), 0) 
 
 1819#define OMP_CLAUSE_NOCONTEXT_EXPR(NODE)                                        \ 
 1820  OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NOCONTEXT), 0) 
 
 1822#define OMP_CLAUSE_GRAINSIZE_EXPR(NODE) \ 
 1823  OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_GRAINSIZE),0) 
 
 1825#define OMP_CLAUSE_PRIORITY_EXPR(NODE) \ 
 1826  OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_PRIORITY),0) 
 
 1828#define OMP_CLAUSE_GRAINSIZE_STRICT(NODE) \ 
 1829  TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_GRAINSIZE)) 
 
 1830#define OMP_CLAUSE_NUM_TASKS_STRICT(NODE) \ 
 1831  TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_TASKS)) 
 
 1834#define OMP_CLAUSE_EXPR(NODE, CLAUSE) \ 
 1835  OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, CLAUSE), 0) 
 
 1836#define OMP_CLAUSE_GANG_EXPR(NODE) \ 
 1837  OMP_CLAUSE_OPERAND ( \ 
 1838    OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_GANG), 0) 
 
 1839#define OMP_CLAUSE_GANG_STATIC_EXPR(NODE) \ 
 1840  OMP_CLAUSE_OPERAND ( \ 
 1841    OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_GANG), 1) 
 
 1842#define OMP_CLAUSE_ASYNC_EXPR(NODE) \ 
 1843  OMP_CLAUSE_OPERAND ( \ 
 1844    OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ASYNC), 0) 
 
 1845#define OMP_CLAUSE_WAIT_EXPR(NODE) \ 
 1846  OMP_CLAUSE_OPERAND ( \ 
 1847    OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_WAIT), 0) 
 
 1848#define OMP_CLAUSE_VECTOR_EXPR(NODE) \ 
 1849  OMP_CLAUSE_OPERAND ( \ 
 1850    OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_VECTOR), 0) 
 
 1851#define OMP_CLAUSE_WORKER_EXPR(NODE) \ 
 1852  OMP_CLAUSE_OPERAND ( \ 
 1853    OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_WORKER), 0) 
 
 1854#define OMP_CLAUSE_NUM_GANGS_EXPR(NODE) \ 
 1855  OMP_CLAUSE_OPERAND ( \ 
 1856    OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_GANGS), 0) 
 
 1857#define OMP_CLAUSE_NUM_WORKERS_EXPR(NODE) \ 
 1858  OMP_CLAUSE_OPERAND ( \ 
 1859    OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_WORKERS), 0) 
 
 1860#define OMP_CLAUSE_VECTOR_LENGTH_EXPR(NODE) \ 
 1861  OMP_CLAUSE_OPERAND ( \ 
 1862    OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_VECTOR_LENGTH), 0) 
 
 1864#define OMP_CLAUSE_DEPEND_KIND(NODE) \ 
 1865  (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEPEND)->omp_clause.subcode.depend_kind) 
 
 1867#define OMP_CLAUSE_DOACROSS_KIND(NODE) \ 
 1868  (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DOACROSS)->omp_clause.subcode.doacross_kind) 
 
 1870#define OMP_CLAUSE_DOACROSS_SINK_NEGATIVE(NODE) \ 
 1871  TREE_PUBLIC (TREE_LIST_CHECK (NODE)) 
 
 1874#define OMP_CLAUSE_DOACROSS_DEPEND(NODE) \ 
 1875  TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DOACROSS)) 
 
 1877#define OMP_CLAUSE_MAP_KIND(NODE) \ 
 1878  ((enum gomp_map_kind) OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP)->omp_clause.subcode.map_kind) 
 
 1879#define OMP_CLAUSE_SET_MAP_KIND(NODE, MAP_KIND) \ 
 1880  (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP)->omp_clause.subcode.map_kind \ 
 1881   = (unsigned int) (MAP_KIND)) 
 
 1883#define OMP_CLAUSE_MOTION_PRESENT(NODE) \ 
 1884  (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_FROM, OMP_CLAUSE_TO)->base.deprecated_flag) 
 
 1886#define OMP_CLAUSE_INIT_TARGET(NODE) \ 
 1887  (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_INIT)->base.public_flag) 
 
 1888#define OMP_CLAUSE_INIT_TARGETSYNC(NODE) \ 
 1889  (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_INIT)->base.deprecated_flag) 
 
 1890#define OMP_CLAUSE_INIT_PREFER_TYPE(NODE)                               \ 
 1891  OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (OMP_CLAUSE_CHECK (NODE),  \ 
 1893                                              OMP_CLAUSE_INIT), 1) 
 
 1898#define OMP_CLAUSE_MAP_ZERO_BIAS_ARRAY_SECTION(NODE) \ 
 1899  (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP)->base.public_flag) 
 
 1902#define OMP_CLAUSE_MAP_MAYBE_ZERO_LENGTH_ARRAY_SECTION(NODE) \ 
 1903  TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP)) 
 
 1907#define OMP_CLAUSE_MAP_IN_REDUCTION(NODE) \ 
 1908  TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP)) 
 
 1912#define OMP_CLAUSE_MAP_IMPLICIT(NODE) \ 
 1913  (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP)->base.default_def_flag) 
 
 1917#define OMP_CLAUSE_MAP_RUNTIME_IMPLICIT_P(NODE) \ 
 1918  (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP)->base.deprecated_flag) 
 
 1921#define OMP_CLAUSE_ATTACHMENT_MAPPING_ERASED(NODE) \ 
 1922  TREE_STATIC (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP)) 
 
 1925#define OMP_CLAUSE_RELEASE_DESCRIPTOR(NODE) \ 
 1926  TREE_NOTHROW (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP)) 
 
 1930#define OMP_CLAUSE_MAP_DECL_MAKE_ADDRESSABLE(NODE) \ 
 1931  (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP)->base.addressable_flag) 
 
 1934#define OMP_CLAUSE_MAP_READONLY(NODE) \ 
 1935  TREE_READONLY (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP)) 
 
 1938#define OMP_CLAUSE__CACHE__READONLY(NODE) \ 
 1939  TREE_READONLY (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE__CACHE_)) 
 
 1943#define OMP_CLAUSE_USE_DEVICE_PTR_IF_PRESENT(NODE) \ 
 1944  (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_USE_DEVICE_PTR)->base.public_flag) 
 
 1946#define OMP_CLAUSE_PROC_BIND_KIND(NODE) \ 
 1947  (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_PROC_BIND)->omp_clause.subcode.proc_bind_kind) 
 
 1949#define OMP_CLAUSE_DEVICE_TYPE_KIND(NODE) \ 
 1950  (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEVICE_TYPE)->omp_clause.subcode.device_type_kind) 
 
 1952#define OMP_CLAUSE_INDIRECT_EXPR(NODE) \ 
 1953  OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_INDIRECT), 0) 
 
 1957#define OMP_CLAUSE_DEVICE_ANCESTOR(NODE) \ 
 1958  (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEVICE)->base.public_flag) 
 
 1960#define OMP_CLAUSE_COLLAPSE_EXPR(NODE) \ 
 1961  OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_COLLAPSE), 0) 
 
 1962#define OMP_CLAUSE_COLLAPSE_ITERVAR(NODE) \ 
 1963  OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_COLLAPSE), 1) 
 
 1964#define OMP_CLAUSE_COLLAPSE_COUNT(NODE) \ 
 1965  OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_COLLAPSE), 2) 
 
 1967#define OMP_CLAUSE_ORDERED_EXPR(NODE) \ 
 1968  OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ORDERED), 0) 
 
 1972#define OMP_CLAUSE_ORDERED_DOACROSS(NODE) \ 
 1973  (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ORDERED)->base.public_flag) 
 
 1976#define OMP_CLAUSE_ORDER_UNCONSTRAINED(NODE) \ 
 1977  (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ORDER)->base.public_flag) 
 
 1979#define OMP_CLAUSE_ORDER_REPRODUCIBLE(NODE) \ 
 1980  TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ORDER)) 
 
 1982#define OMP_CLAUSE_REDUCTION_CODE(NODE) \ 
 1983  (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_REDUCTION, \ 
 1984     OMP_CLAUSE_IN_REDUCTION)->omp_clause.subcode.reduction_code) 
 
 1985#define OMP_CLAUSE_REDUCTION_INIT(NODE) \ 
 1986  OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_REDUCTION, \ 
 1987                                              OMP_CLAUSE_IN_REDUCTION), 1) 
 
 1988#define OMP_CLAUSE_REDUCTION_MERGE(NODE) \ 
 1989  OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_REDUCTION, \ 
 1990                                              OMP_CLAUSE_IN_REDUCTION), 2) 
 
 1991#define OMP_CLAUSE_REDUCTION_GIMPLE_INIT(NODE) \ 
 1992  (OMP_CLAUSE_CHECK (NODE))->omp_clause.gimple_reduction_init 
 
 1993#define OMP_CLAUSE_REDUCTION_GIMPLE_MERGE(NODE) \ 
 1994  (OMP_CLAUSE_CHECK (NODE))->omp_clause.gimple_reduction_merge 
 
 1995#define OMP_CLAUSE_REDUCTION_PLACEHOLDER(NODE) \ 
 1996  OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_REDUCTION, \ 
 1997                                              OMP_CLAUSE_IN_REDUCTION), 3) 
 
 1998#define OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER(NODE) \ 
 1999  OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_REDUCTION, \ 
 2000                                              OMP_CLAUSE_IN_REDUCTION), 4) 
 
 2004#define OMP_CLAUSE_REDUCTION_OMP_ORIG_REF(NODE) \ 
 2005  (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_REDUCTION, \ 
 2006                           OMP_CLAUSE_IN_REDUCTION)->base.public_flag) 
 
 2009#define OMP_CLAUSE_REDUCTION_TASK(NODE) \ 
 2010  TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_REDUCTION)) 
 
 2013#define OMP_CLAUSE_REDUCTION_INSCAN(NODE) \ 
 2014  TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_REDUCTION)) 
 
 2018#define OMP_CLAUSE_LINEAR_NO_COPYIN(NODE) \ 
 2019  (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR)->base.public_flag) 
 
 2023#define OMP_CLAUSE_LINEAR_NO_COPYOUT(NODE) \ 
 2024  TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR)) 
 
 2027#define OMP_CLAUSE_LINEAR_VARIABLE_STRIDE(NODE) \ 
 2028  TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR)) 
 
 2032#define OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER(NODE) \ 
 2033  (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR)->base.addressable_flag) 
 
 2037#define OMP_CLAUSE_LINEAR_ARRAY(NODE) \ 
 2038  (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR)->base.deprecated_flag) 
 
 2040#define OMP_CLAUSE_LINEAR_STEP(NODE) \ 
 2041  OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR), 1) 
 
 2043#define OMP_CLAUSE_LINEAR_STMT(NODE) \ 
 2044  OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR), 2) 
 
 2046#define OMP_CLAUSE_LINEAR_GIMPLE_SEQ(NODE) \ 
 2047  (OMP_CLAUSE_CHECK (NODE))->omp_clause.gimple_reduction_init 
 
 2049#define OMP_CLAUSE_LINEAR_KIND(NODE) \ 
 2050  (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR)->omp_clause.subcode.linear_kind) 
 
 2052#define OMP_CLAUSE_ALIGNED_ALIGNMENT(NODE) \ 
 2053  OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ALIGNED), 1) 
 
 2055#define OMP_CLAUSE_ALLOCATE_ALLOCATOR(NODE) \ 
 2056  OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ALLOCATE), 1) 
 
 2058#define OMP_CLAUSE_ALLOCATE_ALIGN(NODE) \ 
 2059  OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ALLOCATE), 2) 
 
 2065#define OMP_CLAUSE_ALLOCATE_COMBINED(NODE) \ 
 2066  (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ALLOCATE)->base.public_flag) 
 
 2068#define OMP_CLAUSE_NUM_TEAMS_UPPER_EXPR(NODE) \ 
 2069  OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_TEAMS), 0) 
 
 2071#define OMP_CLAUSE_NUM_TEAMS_LOWER_EXPR(NODE) \ 
 2072  OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_TEAMS), 1) 
 
 2074#define OMP_CLAUSE_THREAD_LIMIT_EXPR(NODE) \ 
 2075  OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, \ 
 2076                                                OMP_CLAUSE_THREAD_LIMIT), 0) 
 
 2078#define OMP_CLAUSE_DEVICE_ID(NODE) \ 
 2079  OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEVICE), 0) 
 
 2081#define OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR(NODE) \ 
 2082  OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, \ 
 2083                                                OMP_CLAUSE_DIST_SCHEDULE), 0) 
 
 2085#define OMP_CLAUSE_SAFELEN_EXPR(NODE) \ 
 2086  OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SAFELEN), 0) 
 
 2088#define OMP_CLAUSE_SIMDLEN_EXPR(NODE) \ 
 2089  OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SIMDLEN), 0) 
 
 2091#define OMP_CLAUSE__SIMDUID__DECL(NODE) \ 
 2092  OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE__SIMDUID_), 0) 
 
 2094#define OMP_CLAUSE_SCHEDULE_KIND(NODE) \ 
 2095  (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SCHEDULE)->omp_clause.subcode.schedule_kind) 
 
 2098#define OMP_CLAUSE_SCHEDULE_SIMD(NODE) \ 
 2099  (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SCHEDULE)->base.public_flag) 
 
 2101#define OMP_CLAUSE_DEFAULT_KIND(NODE) \ 
 2102  (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEFAULT)->omp_clause.subcode.default_kind) 
 
 2104#define OMP_CLAUSE_DEFAULTMAP_KIND(NODE) \ 
 2105  (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEFAULTMAP)->omp_clause.subcode.defaultmap_kind) 
 
 2106#define OMP_CLAUSE_DEFAULTMAP_CATEGORY(NODE) \ 
 2107  ((enum omp_clause_defaultmap_kind) \ 
 2108   (OMP_CLAUSE_DEFAULTMAP_KIND (NODE) & OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK)) 
 
 2109#define OMP_CLAUSE_DEFAULTMAP_BEHAVIOR(NODE) \ 
 2110  ((enum omp_clause_defaultmap_kind) \ 
 2111   (OMP_CLAUSE_DEFAULTMAP_KIND (NODE) & OMP_CLAUSE_DEFAULTMAP_MASK)) 
 
 2112#define OMP_CLAUSE_DEFAULTMAP_SET_KIND(NODE, BEHAVIOR, CATEGORY) \ 
 2113  (OMP_CLAUSE_DEFAULTMAP_KIND (NODE) \ 
 2114   = (enum omp_clause_defaultmap_kind) (CATEGORY | BEHAVIOR)) 
 
 2116#define OMP_CLAUSE_BIND_KIND(NODE) \ 
 2117  (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_BIND)->omp_clause.subcode.bind_kind) 
 
 2120#define OMP_CLAUSE_ENTER_TO(NODE) \ 
 2121  (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ENTER)->base.public_flag) 
 
 2123#define OMP_CLAUSE_TILE_LIST(NODE) \ 
 2124  OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_TILE), 0) 
 
 2125#define OMP_CLAUSE_TILE_ITERVAR(NODE) \ 
 2126  OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_TILE), 1) 
 
 2127#define OMP_CLAUSE_TILE_COUNT(NODE) \ 
 2128  OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_TILE), 2) 
 
 2131#define OMP_CLAUSE__CONDTEMP__ITER(NODE) \ 
 2132  (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE__CONDTEMP_)->base.public_flag) 
 
 2136#define OMP_CLAUSE__SCANTEMP__ALLOC(NODE) \ 
 2137  (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE__SCANTEMP_)->base.public_flag) 
 
 2142#define OMP_CLAUSE__SCANTEMP__CONTROL(NODE) \ 
 2143  TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE__SCANTEMP_)) 
 
 2146#define OMP_NEXT_VARIANT_INDEX(NODE)                    \ 
 2147  TREE_OPERAND (OMP_NEXT_VARIANT_CHECK (NODE), 0) 
 
 2148#define OMP_NEXT_VARIANT_STATE(NODE)                    \ 
 2149  TREE_OPERAND (OMP_NEXT_VARIANT_CHECK (NODE), 1) 
 
 2152#define OMP_TARGET_DEVICE_MATCHES_SELECTOR(NODE)        \ 
 2153  TREE_OPERAND (OMP_TARGET_DEVICE_MATCHES_CHECK (NODE), 0) 
 
 2154#define OMP_TARGET_DEVICE_MATCHES_PROPERTIES(NODE)      \ 
 2155  TREE_OPERAND (OMP_TARGET_DEVICE_MATCHES_CHECK (NODE), 1) 
 
 2157#define OMP_CLAUSE__MAPPER_BINDING__ID(NODE) \ 
 2158  OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, \ 
 2159                        OMP_CLAUSE__MAPPER_BINDING_), 0) 
 
 2161#define OMP_CLAUSE__MAPPER_BINDING__DECL(NODE) \ 
 2162  OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, \ 
 2163                        OMP_CLAUSE__MAPPER_BINDING_), 1) 
 
 2165#define OMP_CLAUSE__MAPPER_BINDING__MAPPER(NODE) \ 
 2166  OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, \ 
 2167                        OMP_CLAUSE__MAPPER_BINDING_), 2) 
 
 2173#define SSA_NAME_IS_VIRTUAL_OPERAND(NODE) \ 
 2174  SSA_NAME_CHECK (NODE)->base.public_flag 
 
 2178#define SSA_NAME_IDENTIFIER(NODE)                               \ 
 2179  (SSA_NAME_CHECK (NODE)->ssa_name.var != NULL_TREE             \ 
 2180   ? (TREE_CODE ((NODE)->ssa_name.var) == IDENTIFIER_NODE       \ 
 2181      ? (NODE)->ssa_name.var                                    \ 
 2182      : DECL_NAME ((NODE)->ssa_name.var))                       \ 
 
 2188#define SSA_NAME_VAR(NODE)                                      \ 
 2189  (SSA_NAME_CHECK (NODE)->ssa_name.var == NULL_TREE             \ 
 2190   || TREE_CODE ((NODE)->ssa_name.var) == IDENTIFIER_NODE       \ 
 2191   ? NULL_TREE : (NODE)->ssa_name.var) 
 
 2193#define SET_SSA_NAME_VAR_OR_IDENTIFIER(NODE,VAR) \ 
 2196      tree var_ = (VAR); \ 
 2197      SSA_NAME_CHECK (NODE)->ssa_name.var = var_; \ 
 2198      SSA_NAME_IS_VIRTUAL_OPERAND (NODE) \ 
 2200           && TREE_CODE (var_) == VAR_DECL \ 
 2201           && VAR_DECL_IS_VIRTUAL_OPERAND (var_)); \ 
 
 2206#define SSA_NAME_DEF_STMT(NODE) SSA_NAME_CHECK (NODE)->ssa_name.def_stmt 
 2210#define SSA_NAME_VERSION(NODE)  SSA_NAME_CHECK (NODE)->base.u.version 
 2215#define SSA_NAME_OCCURS_IN_ABNORMAL_PHI(NODE) \ 
 2216    SSA_NAME_CHECK (NODE)->base.asm_written_flag 
 
 2221#define SSA_NAME_IN_FREE_LIST(NODE) \ 
 2222    SSA_NAME_CHECK (NODE)->base.nothrow_flag 
 
 2229#define SSA_NAME_IS_DEFAULT_DEF(NODE) \ 
 2230    SSA_NAME_CHECK (NODE)->base.default_def_flag 
 
 2236#define SSA_NAME_POINTS_TO_READONLY_MEMORY(NODE) \ 
 2237    SSA_NAME_CHECK (NODE)->base.deprecated_flag 
 
 2240#define SSA_NAME_PTR_INFO(N) \ 
 2241   SSA_NAME_CHECK (N)->ssa_name.info.ptr_info 
 
 2244#define SSA_NAME_RANGE_INFO(N) \ 
 2245    SSA_NAME_CHECK (N)->ssa_name.info.range_info 
 
 2248#define SSA_NAME_IMM_USE_NODE(NODE) SSA_NAME_CHECK (NODE)->ssa_name.imm_uses 
 2250#define OMP_CLAUSE_CODE(NODE)                                   \ 
 2251        (OMP_CLAUSE_CHECK (NODE))->omp_clause.code 
 
 2253#define OMP_CLAUSE_SET_CODE(NODE, CODE)                         \ 
 2254        ((OMP_CLAUSE_CHECK (NODE))->omp_clause.code = (CODE)) 
 
 2256#define OMP_CLAUSE_OPERAND(NODE, I)                             \ 
 2257        OMP_CLAUSE_ELT_CHECK (NODE, I) 
 
 2260#define OMP_ITERATOR_DECL_P(NODE) \ 
 2261        (TREE_CODE (NODE) == TREE_LIST                          \ 
 2262         && TREE_PURPOSE (NODE)                                 \ 
 2263         && TREE_CODE (TREE_PURPOSE (NODE)) == TREE_VEC) 
 
 2267#define BLOCK_VARS(NODE) (BLOCK_CHECK (NODE)->block.vars) 
 2268#define BLOCK_NONLOCALIZED_VARS(NODE) \ 
 2269  (BLOCK_CHECK (NODE)->block.nonlocalized_vars) 
 
 2270#define BLOCK_NUM_NONLOCALIZED_VARS(NODE) \ 
 2271  vec_safe_length (BLOCK_NONLOCALIZED_VARS (NODE)) 
 
 2272#define BLOCK_NONLOCALIZED_VAR(NODE,N) (*BLOCK_NONLOCALIZED_VARS (NODE))[N] 
 2274#define BLOCK_SUBBLOCKS(NODE) (BLOCK_CHECK (NODE)->block.subblocks) 
 2279#define BLOCK_SUPERCONTEXT(NODE) (BLOCK_CHECK (NODE)->block.supercontext) 
 2281#define BLOCK_CHAIN(NODE) (BLOCK_CHECK (NODE)->block.chain) 
 2286#define BLOCK_ABSTRACT_ORIGIN(NODE) (BLOCK_CHECK (NODE)->block.abstract_origin) 
 2287#define BLOCK_ORIGIN(NODE) \ 
 2288  (BLOCK_ABSTRACT_ORIGIN(NODE) ? BLOCK_ABSTRACT_ORIGIN(NODE) : (NODE)) 
 
 2289#define BLOCK_DIE(NODE) (BLOCK_CHECK (NODE)->block.die) 
 2292#define BLOCK_SAME_RANGE(NODE) (BLOCK_CHECK (NODE)->base.u.bits.nameless_flag) 
 2295#define BLOCK_IN_COLD_SECTION_P(NODE) \ 
 2296  (BLOCK_CHECK (NODE)->base.u.bits.atomic_flag) 
 
 2301#define BLOCK_NUMBER(NODE) (BLOCK_CHECK (NODE)->block.block_num) 
 2325#define BLOCK_FRAGMENT_ORIGIN(NODE) (BLOCK_CHECK (NODE)->block.fragment_origin) 
 2326#define BLOCK_FRAGMENT_CHAIN(NODE) (BLOCK_CHECK (NODE)->block.fragment_chain) 
 2332#define BLOCK_SOURCE_LOCATION(NODE) (BLOCK_CHECK (NODE)->block.locus) 
 2337#define BLOCK_SOURCE_END_LOCATION(NODE) (BLOCK_CHECK (NODE)->block.end_locus) 
 2350#define TYPE_UID(NODE) (TYPE_CHECK (NODE)->type_common.uid) 
 2355#define TYPE_SIZE(NODE) (TYPE_CHECK (NODE)->type_common.size) 
 2357#define TYPE_SIZE_UNIT(NODE) (TYPE_CHECK (NODE)->type_common.size_unit) 
 2358#define TYPE_POINTER_TO(NODE) (TYPE_CHECK (NODE)->type_common.pointer_to) 
 2359#define TYPE_REFERENCE_TO(NODE) (TYPE_CHECK (NODE)->type_common.reference_to) 
 2360#define TYPE_PRECISION(NODE) \ 
 2361  (TREE_NOT_CHECK (TYPE_CHECK (NODE), VECTOR_TYPE)->type_common.precision) 
 
 2362#define TYPE_PRECISION_RAW(NODE) (TYPE_CHECK (NODE)->type_common.precision) 
 2363#define TYPE_NAME(NODE) (TYPE_CHECK (NODE)->type_common.name) 
 2364#define TYPE_NEXT_VARIANT(NODE) (TYPE_CHECK (NODE)->type_common.next_variant) 
 2365#define TYPE_MAIN_VARIANT(NODE) (TYPE_CHECK (NODE)->type_common.main_variant) 
 2366#define TYPE_CONTEXT(NODE) (TYPE_CHECK (NODE)->type_common.context) 
 2368#define TYPE_MODE_RAW(NODE) (TYPE_CHECK (NODE)->type_common.mode) 
 2369#define TYPE_MODE(NODE) \ 
 2370  (VECTOR_TYPE_P (TYPE_CHECK (NODE)) \ 
 2371   ? vector_type_mode (NODE) : (NODE)->type_common.mode) 
 
 2372#define SCALAR_TYPE_MODE(NODE) \ 
 2373  (as_a <scalar_mode> (TYPE_CHECK (NODE)->type_common.mode)) 
 
 2374#define SCALAR_INT_TYPE_MODE(NODE) \ 
 2375  (as_a <scalar_int_mode> (TYPE_CHECK (NODE)->type_common.mode)) 
 
 2376#define SCALAR_FLOAT_TYPE_MODE(NODE) \ 
 2377  (as_a <scalar_float_mode> (TYPE_CHECK (NODE)->type_common.mode)) 
 
 2378#define SET_TYPE_MODE(NODE, MODE) \ 
 2379  (TYPE_CHECK (NODE)->type_common.mode = (MODE)) 
 
 2403#define TYPE_CANONICAL(NODE) (TYPE_CHECK (NODE)->type_common.canonical) 
 2410#define TYPE_STRUCTURAL_EQUALITY_P(NODE) (TYPE_CANONICAL (NODE) == NULL_TREE) 
 2413#define SET_TYPE_STRUCTURAL_EQUALITY(NODE) (TYPE_CANONICAL (NODE) = NULL_TREE) 
 2415#define TYPE_IBIT(NODE) (GET_MODE_IBIT (TYPE_MODE (NODE))) 
 2416#define TYPE_FBIT(NODE) (GET_MODE_FBIT (TYPE_MODE (NODE))) 
 2423#define TYPE_ALIAS_SET(NODE) (TYPE_CHECK (NODE)->type_common.alias_set) 
 2427#define TYPE_ALIAS_SET_KNOWN_P(NODE) \ 
 2428  (TYPE_CHECK (NODE)->type_common.alias_set != -1) 
 
 2432#define TYPE_ATTRIBUTES(NODE) (TYPE_CHECK (NODE)->type_common.attributes) 
 2435#define TYPE_ALIGN_RAW(NODE)                    \ 
 2436  (TYPE_CHECK (NODE)->type_common.align) 
 
 2441#define TYPE_ALIGN(NODE)                                        \ 
 2442  (TYPE_ALIGN_RAW (NODE)                                        \ 
 2443   ? ((unsigned)1) << (TYPE_ALIGN_RAW(NODE) - 1) : 0) 
 
 2446#define SET_TYPE_ALIGN(NODE, X) \ 
 2447    (TYPE_CHECK (NODE)->type_common.align = ffs_hwi (X)) 
 
 2451#define TYPE_USER_ALIGN(NODE) (TYPE_CHECK (NODE)->base.u.bits.user_align) 
 2454#define TYPE_ALIGN_UNIT(NODE) (TYPE_ALIGN (NODE) / BITS_PER_UNIT) 
 2458#define TYPE_WARN_IF_NOT_ALIGN_RAW(NODE) \ 
 2459    (TYPE_CHECK (NODE)->type_common.warn_if_not_align) 
 
 2460#define TYPE_WARN_IF_NOT_ALIGN(NODE) \ 
 2461    (TYPE_WARN_IF_NOT_ALIGN_RAW (NODE) \ 
 2462     ? ((unsigned)1) << (TYPE_WARN_IF_NOT_ALIGN_RAW (NODE) - 1) : 0) 
 
 2465#define SET_TYPE_WARN_IF_NOT_ALIGN(NODE, X) \ 
 2466    (TYPE_WARN_IF_NOT_ALIGN_RAW (NODE) = ffs_hwi (X)) 
 
 2475#define TYPE_STUB_DECL(NODE) (TREE_CHAIN (TYPE_CHECK (NODE))) 
 2480#define TYPE_NO_FORCE_BLK(NODE) \ 
 2481  (TYPE_CHECK (NODE)->type_common.no_force_blk_flag) 
 
 2484#define TYPE_VOLATILE(NODE) (TYPE_CHECK (NODE)->base.volatile_flag) 
 2487#define TYPE_ATOMIC(NODE) (TYPE_CHECK (NODE)->base.u.bits.atomic_flag) 
 2490#define TYPE_READONLY(NODE) (TYPE_CHECK (NODE)->base.readonly_flag) 
 2494#define TYPE_RESTRICT(NODE) (TYPE_CHECK (NODE)->type_common.restrict_flag) 
 2497#define TYPE_NAMELESS(NODE) (TYPE_CHECK (NODE)->base.u.bits.nameless_flag) 
 2500#define TYPE_ADDR_SPACE(NODE) (TYPE_CHECK (NODE)->base.u.bits.address_space) 
 2504#define ENCODE_QUAL_ADDR_SPACE(NUM) ((NUM & 0xFF) << 8) 
 2505#define DECODE_QUAL_ADDR_SPACE(X) (((X) >> 8) & 0xFF) 
 2508#define CLEAR_QUAL_ADDR_SPACE(X) ((X) & ~0xFF00) 
 2512#define KEEP_QUAL_ADDR_SPACE(X) ((X) & 0xFF00) 
 2515#define TYPE_QUALS(NODE)                                        \ 
 2516  ((int) ((TYPE_READONLY (NODE) * TYPE_QUAL_CONST)              \ 
 2517          | (TYPE_VOLATILE (NODE) * TYPE_QUAL_VOLATILE)         \ 
 2518          | (TYPE_ATOMIC (NODE) * TYPE_QUAL_ATOMIC)             \ 
 2519          | (TYPE_RESTRICT (NODE) * TYPE_QUAL_RESTRICT)         \ 
 2520          | (ENCODE_QUAL_ADDR_SPACE (TYPE_ADDR_SPACE (NODE))))) 
 
 2523#define TYPE_QUALS_NO_ADDR_SPACE(NODE)                          \ 
 2524  ((int) ((TYPE_READONLY (NODE) * TYPE_QUAL_CONST)              \ 
 2525          | (TYPE_VOLATILE (NODE) * TYPE_QUAL_VOLATILE)         \ 
 2526          | (TYPE_ATOMIC (NODE) * TYPE_QUAL_ATOMIC)             \ 
 2527          | (TYPE_RESTRICT (NODE) * TYPE_QUAL_RESTRICT))) 
 
 2531#define TYPE_QUALS_NO_ADDR_SPACE_NO_ATOMIC(NODE)                \ 
 2532  ((int) ((TYPE_READONLY (NODE) * TYPE_QUAL_CONST)              \ 
 2533          | (TYPE_VOLATILE (NODE) * TYPE_QUAL_VOLATILE)         \ 
 2534          | (TYPE_RESTRICT (NODE) * TYPE_QUAL_RESTRICT))) 
 
 2537#define TYPE_LANG_FLAG_0(NODE) (TYPE_CHECK (NODE)->type_common.lang_flag_0) 
 2538#define TYPE_LANG_FLAG_1(NODE) (TYPE_CHECK (NODE)->type_common.lang_flag_1) 
 2539#define TYPE_LANG_FLAG_2(NODE) (TYPE_CHECK (NODE)->type_common.lang_flag_2) 
 2540#define TYPE_LANG_FLAG_3(NODE) (TYPE_CHECK (NODE)->type_common.lang_flag_3) 
 2541#define TYPE_LANG_FLAG_4(NODE) (TYPE_CHECK (NODE)->type_common.lang_flag_4) 
 2542#define TYPE_LANG_FLAG_5(NODE) (TYPE_CHECK (NODE)->type_common.lang_flag_5) 
 2543#define TYPE_LANG_FLAG_6(NODE) (TYPE_CHECK (NODE)->type_common.lang_flag_6) 
 2544#define TYPE_LANG_FLAG_7(NODE) (TYPE_CHECK (NODE)->type_common.lang_flag_7) 
 2548#define TREE_VISITED(NODE) ((NODE)->base.visited) 
 2553#define TYPE_STRING_FLAG(NODE) \ 
 2554        (ARRAY_OR_INTEGER_TYPE_CHECK (NODE)->type_common.string_flag) 
 
 2559#define TYPE_CXX_ODR_P(NODE) \ 
 2560        (RECORD_OR_UNION_CHECK (NODE)->type_common.string_flag) 
 
 2564#define TYPE_VECTOR_OPAQUE(NODE) \ 
 2565  (VECTOR_TYPE_CHECK (NODE)->base.default_def_flag) 
 
 2569#define TYPE_NEEDS_CONSTRUCTING(NODE) \ 
 2570  (TYPE_CHECK (NODE)->type_common.needs_constructing_flag) 
 
 2576#define TYPE_TRANSPARENT_AGGR(NODE) \ 
 2577  (RECORD_OR_UNION_CHECK (NODE)->type_common.transparent_aggr_flag) 
 
 2582#define TYPE_NONALIASED_COMPONENT(NODE) \ 
 2583  (ARRAY_TYPE_CHECK (NODE)->type_common.transparent_aggr_flag) 
 
 2594#define TYPE_TYPELESS_STORAGE(NODE) \ 
 2595  (TREE_CHECK4 (NODE, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, \ 
 2596                ARRAY_TYPE)->type_common.typeless_storage) 
 
 2600#define TYPE_PACKED(NODE) (TYPE_CHECK (NODE)->base.u.bits.packed_flag) 
 2605#define TYPE_CONTAINS_PLACEHOLDER_INTERNAL(NODE) \ 
 2606  (TYPE_CHECK (NODE)->type_common.contains_placeholder_bits) 
 
 2609#define TYPE_FINAL_P(NODE) \ 
 2610  (RECORD_OR_UNION_CHECK (NODE)->base.default_def_flag) 
 
 2621#define TYPE_SYMTAB_ADDRESS(NODE) \ 
 2622  (TYPE_CHECK (NODE)->type_common.symtab.address) 
 
 2626#define TYPE_SYMTAB_DIE(NODE) \ 
 2627  (TYPE_CHECK (NODE)->type_common.symtab.die) 
 
 2633#define TYPE_SYMTAB_IS_ADDRESS (0) 
 2634#define TYPE_SYMTAB_IS_DIE (1) 
 2636#define TYPE_LANG_SPECIFIC(NODE) \ 
 2637  (TYPE_CHECK (NODE)->type_with_lang_specific.lang_specific) 
 
 2639#define TYPE_VALUES(NODE) (ENUMERAL_TYPE_CHECK (NODE)->type_non_common.values) 
 2640#define TYPE_DOMAIN(NODE) (ARRAY_TYPE_CHECK (NODE)->type_non_common.values) 
 2641#define TYPE_FIELDS(NODE)                               \ 
 2642  (RECORD_OR_UNION_CHECK (NODE)->type_non_common.values) 
 
 2643#define TYPE_CACHED_VALUES(NODE) (TYPE_CHECK (NODE)->type_non_common.values) 
 2644#define TYPE_ARG_TYPES(NODE)                            \ 
 2645  (FUNC_OR_METHOD_CHECK (NODE)->type_non_common.values) 
 
 2646#define TYPE_VALUES_RAW(NODE) (TYPE_CHECK (NODE)->type_non_common.values) 
 2648#define TYPE_MIN_VALUE(NODE)                            \ 
 2649  (NUMERICAL_TYPE_CHECK (NODE)->type_non_common.minval) 
 
 2650#define TYPE_NEXT_PTR_TO(NODE)                          \ 
 2651  (POINTER_TYPE_CHECK (NODE)->type_non_common.minval) 
 
 2652#define TYPE_NEXT_REF_TO(NODE)                          \ 
 2653  (REFERENCE_TYPE_CHECK (NODE)->type_non_common.minval) 
 
 2654#define TYPE_VFIELD(NODE)                               \ 
 2655  (RECORD_OR_UNION_CHECK (NODE)->type_non_common.minval) 
 
 2656#define TYPE_MIN_VALUE_RAW(NODE) (TYPE_CHECK (NODE)->type_non_common.minval) 
 2658#define TYPE_MAX_VALUE(NODE) \ 
 2659  (NUMERICAL_TYPE_CHECK (NODE)->type_non_common.maxval) 
 
 2660#define TYPE_METHOD_BASETYPE(NODE)                      \ 
 2661  (FUNC_OR_METHOD_CHECK (NODE)->type_non_common.maxval) 
 
 2662#define TYPE_OFFSET_BASETYPE(NODE)                      \ 
 2663  (OFFSET_TYPE_CHECK (NODE)->type_non_common.maxval) 
 
 2667#define TYPE_ARRAY_MAX_SIZE(ARRAY_TYPE) \ 
 2668  (ARRAY_TYPE_CHECK (ARRAY_TYPE)->type_non_common.maxval) 
 
 2669#define TYPE_MAX_VALUE_RAW(NODE) (TYPE_CHECK (NODE)->type_non_common.maxval) 
 2672#define TYPE_BINFO(NODE) (RECORD_OR_UNION_CHECK (NODE)->type_non_common.maxval) 
 2675#define TYPE_LANG_SLOT_1(NODE) \ 
 2676  (TYPE_CHECK (NODE)->type_non_common.lang_1) 
 
 2696#define BINFO_VIRTUAL_P(NODE) (TREE_BINFO_CHECK (NODE)->base.static_flag) 
 2699#define BINFO_FLAG_0(NODE) TREE_LANG_FLAG_0 (TREE_BINFO_CHECK (NODE)) 
 2700#define BINFO_FLAG_1(NODE) TREE_LANG_FLAG_1 (TREE_BINFO_CHECK (NODE)) 
 2701#define BINFO_FLAG_2(NODE) TREE_LANG_FLAG_2 (TREE_BINFO_CHECK (NODE)) 
 2702#define BINFO_FLAG_3(NODE) TREE_LANG_FLAG_3 (TREE_BINFO_CHECK (NODE)) 
 2703#define BINFO_FLAG_4(NODE) TREE_LANG_FLAG_4 (TREE_BINFO_CHECK (NODE)) 
 2704#define BINFO_FLAG_5(NODE) TREE_LANG_FLAG_5 (TREE_BINFO_CHECK (NODE)) 
 2705#define BINFO_FLAG_6(NODE) TREE_LANG_FLAG_6 (TREE_BINFO_CHECK (NODE)) 
 2708#define BINFO_TYPE(NODE) TREE_TYPE (TREE_BINFO_CHECK (NODE)) 
 2716#define BINFO_OFFSET(NODE) (TREE_BINFO_CHECK (NODE)->binfo.offset) 
 2717#define BINFO_OFFSET_ZEROP(NODE) (integer_zerop (BINFO_OFFSET (NODE))) 
 2723#define BINFO_VTABLE(NODE) (TREE_BINFO_CHECK (NODE)->binfo.vtable) 
 2728#define BINFO_VIRTUALS(NODE) (TREE_BINFO_CHECK (NODE)->binfo.virtuals) 
 2736#define BINFO_BASE_BINFOS(NODE) (&TREE_BINFO_CHECK (NODE)->binfo.base_binfos) 
 2739#define BINFO_N_BASE_BINFOS(NODE) (BINFO_BASE_BINFOS (NODE)->length ()) 
 2742#define BINFO_BASE_BINFO(NODE,N) \ 
 2743 ((*BINFO_BASE_BINFOS (NODE))[(N)]) 
 
 2744#define BINFO_BASE_ITERATE(NODE,N,B) \ 
 2745 (BINFO_BASE_BINFOS (NODE)->iterate ((N), &(B))) 
 
 2746#define BINFO_BASE_APPEND(NODE,T) \ 
 2747 (BINFO_BASE_BINFOS (NODE)->quick_push ((T))) 
 
 2754#define BINFO_VPTR_FIELD(NODE) (TREE_BINFO_CHECK (NODE)->binfo.vptr_field) 
 2759#define BINFO_BASE_ACCESSES(NODE) \ 
 2760  (TREE_BINFO_CHECK (NODE)->binfo.base_accesses) 
 
 2762#define BINFO_BASE_ACCESS(NODE,N) \ 
 2763  (*BINFO_BASE_ACCESSES (NODE))[(N)] 
 
 2764#define BINFO_BASE_ACCESS_APPEND(NODE,T) \ 
 2765  BINFO_BASE_ACCESSES (NODE)->quick_push ((T)) 
 
 2769#define BINFO_SUBVTT_INDEX(NODE) (TREE_BINFO_CHECK (NODE)->binfo.vtt_subvtt) 
 2773#define BINFO_VPTR_INDEX(NODE) (TREE_BINFO_CHECK (NODE)->binfo.vtt_vptr) 
 2779#define BINFO_INHERITANCE_CHAIN(NODE) \ 
 2780        (TREE_BINFO_CHECK (NODE)->binfo.inheritance) 
 
 2787#define SSA_VAR_P(DECL)                                                 \ 
 2788        (TREE_CODE (DECL) == VAR_DECL                                   \ 
 2789         || TREE_CODE (DECL) == PARM_DECL                               \ 
 2790         || TREE_CODE (DECL) == RESULT_DECL                             \ 
 2791         || TREE_CODE (DECL) == SSA_NAME) 
 
 2794#define DECL_CHAIN(NODE) (TREE_CHAIN (DECL_MINIMAL_CHECK (NODE))) 
 2798#define DECL_NAME(NODE) (DECL_MINIMAL_CHECK (NODE)->decl_minimal.name) 
 2801#define TYPE_IDENTIFIER(NODE) \ 
 2802  (TYPE_NAME (NODE) && DECL_P (TYPE_NAME (NODE)) \ 
 2803   ? DECL_NAME (TYPE_NAME (NODE)) : TYPE_NAME (NODE)) 
 
 2806#define DECL_UID(NODE) (DECL_MINIMAL_CHECK (NODE)->decl_minimal.uid) 
 2810#define DEBUG_TEMP_UID(NODE) (-DECL_UID (TREE_CHECK ((NODE), DEBUG_EXPR_DECL))) 
 2814#define DECL_PT_UID(NODE) \ 
 2815  (DECL_COMMON_CHECK (NODE)->decl_common.pt_uid == -1u \ 
 2816   ? (NODE)->decl_minimal.uid : (NODE)->decl_common.pt_uid) 
 
 2818#define SET_DECL_PT_UID(NODE, UID) \ 
 2819  (DECL_COMMON_CHECK (NODE)->decl_common.pt_uid = (UID)) 
 
 2822#define DECL_PT_UID_SET_P(NODE) \ 
 2823  (DECL_COMMON_CHECK (NODE)->decl_common.pt_uid != -1u) 
 
 2829#define DECL_SOURCE_LOCATION(NODE) \ 
 2830  (DECL_MINIMAL_CHECK (NODE)->decl_minimal.locus) 
 
 2831#define DECL_SOURCE_FILE(NODE) LOCATION_FILE (DECL_SOURCE_LOCATION (NODE)) 
 2832#define DECL_SOURCE_LINE(NODE) LOCATION_LINE (DECL_SOURCE_LOCATION (NODE)) 
 2833#define DECL_SOURCE_COLUMN(NODE) LOCATION_COLUMN (DECL_SOURCE_LOCATION (NODE)) 
 2838#define DECL_IS_UNDECLARED_BUILTIN(DECL) \ 
 2839  (DECL_SOURCE_LOCATION (DECL) <= BUILTINS_LOCATION) 
 
 2850#define DECL_CONTEXT(NODE) (DECL_MINIMAL_CHECK (NODE)->decl_minimal.context) 
 2851#define DECL_FIELD_CONTEXT(NODE) \ 
 2852  (FIELD_DECL_CHECK (NODE)->decl_minimal.context) 
 
 2855#define DECL_NAMELESS(NODE) (DECL_MINIMAL_CHECK (NODE)->base.u.bits.nameless_flag) 
 2863#define DECL_ABSTRACT_ORIGIN(NODE) \ 
 2864  (DECL_COMMON_CHECK (NODE)->decl_common.abstract_origin) 
 
 2868#define DECL_ORIGIN(NODE) \ 
 2869  (DECL_ABSTRACT_ORIGIN (NODE) ? DECL_ABSTRACT_ORIGIN (NODE) : (NODE)) 
 
 2875#define DECL_FROM_INLINE(NODE) \ 
 2876  (DECL_ABSTRACT_ORIGIN (NODE) != NULL_TREE \ 
 2877   && DECL_ABSTRACT_ORIGIN (NODE) != (NODE)) 
 
 2880#define DECL_ATTRIBUTES(NODE) \ 
 2881  (DECL_COMMON_CHECK (NODE)->decl_common.attributes) 
 
 2893#define DECL_INITIAL(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.initial) 
 2899#define DECL_SIZE(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.size) 
 2901#define DECL_SIZE_UNIT(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.size_unit) 
 2902#define DECL_ALIGN_RAW(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.align) 
 2906#define DECL_ALIGN(NODE)                                        \ 
 2907  (DECL_ALIGN_RAW (NODE)                                        \ 
 2908   ? ((unsigned)1) << (DECL_ALIGN_RAW (NODE) - 1) : 0) 
 
 2910#define SET_DECL_ALIGN(NODE, X) \ 
 2911  (DECL_ALIGN_RAW (NODE) = ffs_hwi (X)) 
 
 2915#define DECL_WARN_IF_NOT_ALIGN_RAW(NODE)                        \ 
 2916  (DECL_COMMON_CHECK (NODE)->decl_common.warn_if_not_align) 
 
 2917#define DECL_WARN_IF_NOT_ALIGN(NODE)                                    \ 
 2918  (DECL_WARN_IF_NOT_ALIGN_RAW (NODE)                                    \ 
 2919   ? ((unsigned)1) << (DECL_WARN_IF_NOT_ALIGN_RAW (NODE) - 1) : 0) 
 
 2922#define SET_DECL_WARN_IF_NOT_ALIGN(NODE, X)             \ 
 2923  (DECL_WARN_IF_NOT_ALIGN_RAW (NODE) = ffs_hwi (X)) 
 
 2926#define DECL_ALIGN_UNIT(NODE) (DECL_ALIGN (NODE) / BITS_PER_UNIT) 
 2929#define DECL_USER_ALIGN(NODE) \ 
 2930  (DECL_COMMON_CHECK (NODE)->base.u.bits.user_align) 
 
 2934#define DECL_MODE(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.mode) 
 2935#define SET_DECL_MODE(NODE, MODE) \ 
 2936  (DECL_COMMON_CHECK (NODE)->decl_common.mode = (MODE)) 
 
 2942#define DECL_UNCHECKED_FUNCTION_CODE(NODE) \ 
 2943  (FUNCTION_DECL_CHECK (NODE)->function_decl.function_code) 
 
 2946#define ALLOCA_FUNCTION_CODE_P(FCODE)                           \ 
 2947  ((FCODE) == BUILT_IN_ALLOCA                                   \ 
 2948   || (FCODE) == BUILT_IN_ALLOCA_WITH_ALIGN                     \ 
 2949   || (FCODE) == BUILT_IN_ALLOCA_WITH_ALIGN_AND_MAX) 
 
 2952#define CASE_BUILT_IN_ALLOCA                    \ 
 2953  case BUILT_IN_ALLOCA:                         \ 
 2954  case BUILT_IN_ALLOCA_WITH_ALIGN:              \ 
 2955  case BUILT_IN_ALLOCA_WITH_ALIGN_AND_MAX 
 
 2957#define DECL_FUNCTION_PERSONALITY(NODE) \ 
 2958  (FUNCTION_DECL_CHECK (NODE)->function_decl.personality) 
 
 2964#define DECL_IGNORED_P(NODE) \ 
 2965  (DECL_COMMON_CHECK (NODE)->decl_common.ignored_flag) 
 
 2973#define DECL_ABSTRACT_P(NODE) \ 
 2974  (DECL_COMMON_CHECK (NODE)->decl_common.abstract_flag) 
 
 2977#define DECL_LANG_SPECIFIC(NODE) \ 
 2978  (DECL_COMMON_CHECK (NODE)->decl_common.lang_specific) 
 
 2987#define DECL_EXTERNAL(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.decl_flag_1) 
 2996#define DECL_NONLOCAL(NODE) \ 
 2997  (DECL_COMMON_CHECK (NODE)->decl_common.nonlocal_flag) 
 
 3002#define DECL_VIRTUAL_P(NODE) \ 
 3003  (DECL_COMMON_CHECK (NODE)->decl_common.virtual_flag) 
 
 3006#define DECL_ARTIFICIAL(NODE) \ 
 3007  (DECL_COMMON_CHECK (NODE)->decl_common.artificial_flag) 
 
 3010#define DECL_LANG_FLAG_0(NODE) \ 
 3011  (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_0) 
 
 3012#define DECL_LANG_FLAG_1(NODE) \ 
 3013  (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_1) 
 
 3014#define DECL_LANG_FLAG_2(NODE) \ 
 3015  (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_2) 
 
 3016#define DECL_LANG_FLAG_3(NODE) \ 
 3017  (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_3) 
 
 3018#define DECL_LANG_FLAG_4(NODE) \ 
 3019  (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_4) 
 
 3020#define DECL_LANG_FLAG_5(NODE) \ 
 3021  (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_5) 
 
 3022#define DECL_LANG_FLAG_6(NODE) \ 
 3023  (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_6) 
 
 3024#define DECL_LANG_FLAG_7(NODE) \ 
 3025  (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_7) 
 
 3026#define DECL_LANG_FLAG_8(NODE) \ 
 3027  (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_8) 
 
 3030#define SCOPE_FILE_SCOPE_P(EXP) \ 
 3031  (! (EXP) || TREE_CODE (EXP) == TRANSLATION_UNIT_DECL) 
 
 3033#define DECL_FILE_SCOPE_P(EXP) SCOPE_FILE_SCOPE_P (DECL_CONTEXT (EXP)) 
 3035#define TYPE_FILE_SCOPE_P(EXP) SCOPE_FILE_SCOPE_P (TYPE_CONTEXT (EXP)) 
 3039#define DECL_PRESERVE_P(DECL) \ 
 3040  DECL_COMMON_CHECK (DECL)->decl_common.preserve_flag 
 
 3045#define DECL_NOINIT_P(DECL)     \ 
 3047   && (lookup_attribute ("noinit", DECL_ATTRIBUTES (DECL)) != NULL_TREE)) 
 
 3052#define DECL_PERSISTENT_P(DECL) \ 
 3054   && (lookup_attribute ("persistent", DECL_ATTRIBUTES (DECL)) != NULL_TREE)) 
 
 3061#define DECL_NOT_GIMPLE_REG_P(DECL) \ 
 3062  DECL_COMMON_CHECK (DECL)->decl_common.not_gimple_reg_flag 
 
 3070#define DECL_HAS_VALUE_EXPR_P(NODE) \ 
 3071  (TREE_CHECK3 (NODE, VAR_DECL, PARM_DECL, RESULT_DECL) \ 
 3072   ->decl_common.decl_flag_2) 
 
 3073#define DECL_VALUE_EXPR(NODE) \ 
 3074  (decl_value_expr_lookup (DECL_WRTL_CHECK (NODE))) 
 
 3075#define SET_DECL_VALUE_EXPR(NODE, VAL) \ 
 3076  (decl_value_expr_insert (DECL_WRTL_CHECK (NODE), VAL)) 
 
 3081#define DECL_RTL(NODE)                                  \ 
 3082  (DECL_WRTL_CHECK (NODE)->decl_with_rtl.rtl            \ 
 3083   ? (NODE)->decl_with_rtl.rtl                                  \ 
 3084   : (make_decl_rtl (NODE), (NODE)->decl_with_rtl.rtl)) 
 
 3087#define SET_DECL_RTL(NODE, RTL) set_decl_rtl (NODE, RTL) 
 3090#define HAS_RTL_P(NODE) (CODE_CONTAINS_STRUCT (TREE_CODE (NODE), TS_DECL_WRTL)) 
 3093#define DECL_RTL_SET_P(NODE) \ 
 3094  (HAS_RTL_P (NODE) && DECL_WRTL_CHECK (NODE)->decl_with_rtl.rtl != NULL) 
 
 3098#define COPY_DECL_RTL(SRC_DECL, DST_DECL) \ 
 3099  (DECL_WRTL_CHECK (DST_DECL)->decl_with_rtl.rtl \ 
 3100   = DECL_WRTL_CHECK (SRC_DECL)->decl_with_rtl.rtl) 
 
 3103#define DECL_RTL_IF_SET(NODE) (DECL_RTL_SET_P (NODE) ? DECL_RTL (NODE) : NULL) 
 3105#if (GCC_VERSION >= 2007) 
 3106#define DECL_RTL_KNOWN_SET(decl) __extension__                          \ 
 3107({  tree const __d = (decl);                                            \ 
 3108    gcc_checking_assert (DECL_RTL_SET_P (__d));                         \ 
 3111    &*DECL_RTL_IF_SET (__d); }) 
 3113#define DECL_RTL_KNOWN_SET(decl) (&*DECL_RTL_IF_SET (decl)) 
 3117#define DECL_REGISTER(NODE) (DECL_WRTL_CHECK (NODE)->decl_common.decl_flag_0) 
 3122#define DECL_FIELD_OFFSET(NODE) (FIELD_DECL_CHECK (NODE)->field_decl.offset) 
 3128#define DECL_FIELD_BIT_OFFSET(NODE) \ 
 3129  (FIELD_DECL_CHECK (NODE)->field_decl.bit_offset) 
 
 3134#define DECL_BIT_FIELD_TYPE(NODE) \ 
 3135  (FIELD_DECL_CHECK (NODE)->field_decl.bit_field_type) 
 
 3139#define DECL_BIT_FIELD_REPRESENTATIVE(NODE) \ 
 3140  (FIELD_DECL_CHECK (NODE)->field_decl.qualifier) 
 
 3144#define DECL_QUALIFIER(NODE) (FIELD_DECL_CHECK (NODE)->field_decl.qualifier) 
 3150#define DECL_OFFSET_ALIGN(NODE) \ 
 3151  (HOST_WIDE_INT_1U << FIELD_DECL_CHECK (NODE)->decl_common.off_align) 
 
 3154#define SET_DECL_OFFSET_ALIGN(NODE, X) \ 
 3155  (FIELD_DECL_CHECK (NODE)->decl_common.off_align = ffs_hwi (X) - 1) 
 
 3160#define DECL_FCONTEXT(NODE) (FIELD_DECL_CHECK (NODE)->field_decl.fcontext) 
 3163#define DECL_PACKED(NODE) (FIELD_DECL_CHECK (NODE)->base.u.bits.packed_flag) 
 3167#define DECL_BIT_FIELD(NODE) (FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_1) 
 3173#define DECL_FIELD_ABI_IGNORED(NODE) \ 
 3174  (!DECL_BIT_FIELD (NODE) && (NODE)->decl_common.decl_flag_0) 
 
 3175#define SET_DECL_FIELD_ABI_IGNORED(NODE, VAL) \ 
 3177    gcc_checking_assert (!DECL_BIT_FIELD (NODE));                       \ 
 3178    FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_0 = (VAL);           \ 
 
 3186#define DECL_FIELD_CXX_ZERO_WIDTH_BIT_FIELD(NODE) \ 
 3187  (DECL_BIT_FIELD (NODE) && (NODE)->decl_common.decl_flag_0) 
 
 3188#define SET_DECL_FIELD_CXX_ZERO_WIDTH_BIT_FIELD(NODE, VAL) \ 
 3190    gcc_checking_assert (DECL_BIT_FIELD (NODE));                        \ 
 3191    FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_0 = (VAL);           \ 
 
 3209#define DECL_NONADDRESSABLE_P(NODE) \ 
 3210  (FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_2) 
 
 3213#define DECL_PADDING_P(NODE) \ 
 3214  (FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_3) 
 
 3219#define DECL_NOT_FLEXARRAY(NODE) \ 
 3220  (FIELD_DECL_CHECK (NODE)->decl_common.decl_not_flexarray) 
 
 3225#define LABEL_DECL_UID(NODE) \ 
 3226  (LABEL_DECL_CHECK (NODE)->label_decl.label_decl_uid) 
 
 3230#define EH_LANDING_PAD_NR(NODE) \ 
 3231  (LABEL_DECL_CHECK (NODE)->label_decl.eh_landing_pad_nr) 
 
 3235#define DECL_ARG_TYPE(NODE) (PARM_DECL_CHECK (NODE)->decl_common.initial) 
 3239#define DECL_INCOMING_RTL(NODE) \ 
 3240  (PARM_DECL_CHECK (NODE)->parm_decl.incoming_rtl) 
 
 3244#define DECL_IN_SYSTEM_HEADER(NODE) \ 
 3245  (in_system_header_at (DECL_SOURCE_LOCATION (NODE))) 
 
 3249#define DECL_DEFER_OUTPUT(NODE) \ 
 3250  (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.defer_output) 
 
 3254#define DECL_IN_TEXT_SECTION(NODE) \ 
 3255  (VAR_DECL_CHECK (NODE)->decl_with_vis.in_text_section) 
 
 3259#define DECL_IN_CONSTANT_POOL(NODE) \ 
 3260  (VAR_DECL_CHECK (NODE)->decl_with_vis.in_constant_pool) 
 
 3265#define DECL_COMMON(NODE) \ 
 3266  (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.common_flag) 
 
 3270#define DECL_HARD_REGISTER(NODE)  \ 
 3271  (VAR_DECL_CHECK (NODE)->decl_with_vis.hard_register) 
 
 3274#define DECL_WEAK(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.weak_flag) 
 3277#define DECL_DLLIMPORT_P(NODE) \ 
 3278  (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.dllimport_flag) 
 
 3289#define DECL_COMDAT(NODE) \ 
 3290  (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.comdat_flag) 
 
 3292#define DECL_COMDAT_GROUP(NODE) \ 
 3293  decl_comdat_group (NODE) 
 
 3297#define DECL_ONE_ONLY(NODE) (DECL_COMDAT_GROUP (NODE) != NULL_TREE \ 
 3298                             && (TREE_PUBLIC (NODE) || DECL_EXTERNAL (NODE))) 
 
 3307#define DECL_ASSEMBLER_NAME(NODE) decl_assembler_name (NODE) 
 3310#define DECL_ASSEMBLER_NAME_RAW(NODE) \ 
 3311  (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.assembler_name) 
 
 3315#define HAS_DECL_ASSEMBLER_NAME_P(NODE) \ 
 3316  (CODE_CONTAINS_STRUCT (TREE_CODE (NODE), TS_DECL_WITH_VIS)) 
 
 3321#define DECL_ASSEMBLER_NAME_SET_P(NODE) \ 
 3322  (DECL_ASSEMBLER_NAME_RAW (NODE) != NULL_TREE) 
 
 3325#define SET_DECL_ASSEMBLER_NAME(NODE, NAME) \ 
 3326  overwrite_decl_assembler_name (NODE, NAME) 
 
 3339#define COPY_DECL_ASSEMBLER_NAME(SRC_DECL, DST_DECL)                    \ 
 3340  SET_DECL_ASSEMBLER_NAME (DST_DECL, DECL_ASSEMBLER_NAME_RAW (SRC_DECL)) 
 
 3344#define DECL_SECTION_NAME(NODE) decl_section_name (NODE) 
 3348#define DECL_SEEN_IN_BIND_EXPR_P(NODE) \ 
 3349  (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.seen_in_bind_expr) 
 
 3352#define DECL_VISIBILITY(NODE) \ 
 3353  (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.visibility) 
 
 3357#define DECL_VISIBILITY_SPECIFIED(NODE) \ 
 3358  (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.visibility_specified) 
 
 3362#define DECL_TLS_MODEL(NODE) decl_tls_model (NODE) 
 3366#define DECL_THREAD_LOCAL_P(NODE) \ 
 3367  ((TREE_STATIC (NODE) || DECL_EXTERNAL (NODE)) && decl_tls_model (NODE) >= TLS_MODEL_REAL) 
 
 3372#define DECL_HAS_INIT_PRIORITY_P(NODE) \ 
 3373  (VAR_DECL_CHECK (NODE)->decl_with_vis.init_priority_p) 
 
 3379#define DECL_HAS_DEBUG_EXPR_P(NODE) \ 
 3380  (VAR_DECL_CHECK (NODE)->decl_common.debug_expr_is_from) 
 
 3381#define DECL_DEBUG_EXPR(NODE) \ 
 3382  (decl_debug_expr_lookup (VAR_DECL_CHECK (NODE))) 
 
 3384#define SET_DECL_DEBUG_EXPR(NODE, VAL) \ 
 3385  (decl_debug_expr_insert (VAR_DECL_CHECK (NODE), VAL)) 
 
 3394#define DECL_INIT_PRIORITY(NODE) \ 
 3395  (decl_init_priority_lookup (NODE)) 
 
 3397#define SET_DECL_INIT_PRIORITY(NODE, VAL) \ 
 3398  (decl_init_priority_insert (NODE, VAL)) 
 
 3401#define DECL_FINI_PRIORITY(NODE) \ 
 3402  (decl_fini_priority_lookup (NODE)) 
 
 3404#define SET_DECL_FINI_PRIORITY(NODE, VAL) \ 
 3405  (decl_fini_priority_insert (NODE, VAL)) 
 
 3409#define DEFAULT_INIT_PRIORITY 65535 
 3412#define MAX_INIT_PRIORITY 65535 
 3416#define MAX_RESERVED_INIT_PRIORITY 100 
 3419#define VAR_DECL_IS_VIRTUAL_OPERAND(NODE) \ 
 3420  (VAR_DECL_CHECK (NODE)->base.u.bits.saturating_flag) 
 
 3423#define DECL_NONLOCAL_FRAME(NODE)  \ 
 3424  (VAR_DECL_CHECK (NODE)->base.default_def_flag) 
 
 3427#define DECL_NONALIASED(NODE) \ 
 3428  (VAR_DECL_CHECK (NODE)->base.nothrow_flag) 
 
 3433#define DECL_MERGEABLE(NODE) \ 
 3434  (VAR_DECL_CHECK (NODE)->decl_common.decl_flag_3) 
 
 3438#define DECL_RESULT_FLD(NODE) \ 
 3439  (DECL_NON_COMMON_CHECK (NODE)->decl_non_common.result) 
 
 3448#define DECL_VINDEX(NODE) \ 
 3449  (FUNCTION_DECL_CHECK (NODE)->function_decl.vindex) 
 
 3452#define DECL_RESULT(NODE) (FUNCTION_DECL_CHECK (NODE)->decl_non_common.result) 
 3455#define DECL_UNINLINABLE(NODE) \ 
 3456  (FUNCTION_DECL_CHECK (NODE)->function_decl.uninlinable) 
 
 3460#define DECL_SAVED_TREE(NODE) \ 
 3461  (FUNCTION_DECL_CHECK (NODE)->function_decl.saved_tree) 
 
 3466#define DECL_IS_MALLOC(NODE) \ 
 3467  (FUNCTION_DECL_CHECK (NODE)->function_decl.malloc_flag) 
 
 3470#define FUNCTION_DECL_DECL_TYPE(NODE) \ 
 3471  (NODE->function_decl.decl_type) 
 
 3491#define DECL_IS_REPLACEABLE_OPERATOR(NODE)\ 
 3492   (FUNCTION_DECL_CHECK (NODE)->function_decl.replaceable_operator) 
 
 3497#define DECL_IS_OPERATOR_NEW_P(NODE) \ 
 3498  (FUNCTION_DECL_DECL_TYPE (FUNCTION_DECL_CHECK (NODE)) \ 
 3499   == function_decl_type::OPERATOR_NEW) 
 
 3501#define DECL_IS_REPLACEABLE_OPERATOR_NEW_P(NODE) \ 
 3502  (DECL_IS_OPERATOR_NEW_P (NODE) && DECL_IS_REPLACEABLE_OPERATOR (NODE)) 
 
 3504#define DECL_SET_IS_OPERATOR_NEW(NODE, VAL) \ 
 3505  set_function_decl_type (FUNCTION_DECL_CHECK (NODE), \ 
 3506                          function_decl_type::OPERATOR_NEW, VAL) 
 
 3510#define DECL_IS_OPERATOR_DELETE_P(NODE) \ 
 3511  (FUNCTION_DECL_DECL_TYPE (FUNCTION_DECL_CHECK (NODE)) \ 
 3512   == function_decl_type::OPERATOR_DELETE) 
 
 3514#define DECL_SET_IS_OPERATOR_DELETE(NODE, VAL) \ 
 3515  set_function_decl_type (FUNCTION_DECL_CHECK (NODE), \ 
 3516                          function_decl_type::OPERATOR_DELETE, VAL) 
 
 3520#define DECL_IS_RETURNS_TWICE(NODE) \ 
 3521  (FUNCTION_DECL_CHECK (NODE)->function_decl.returns_twice_flag) 
 
 3528#define DECL_PURE_P(NODE) (FUNCTION_DECL_CHECK (NODE)->function_decl.pure_flag) 
 3536#define DECL_LOOPING_CONST_OR_PURE_P(NODE) \ 
 3537  (FUNCTION_DECL_CHECK (NODE)->function_decl.looping_const_or_pure_flag) 
 
 3542#define DECL_IS_NOVOPS(NODE) \ 
 3543  (FUNCTION_DECL_CHECK (NODE)->function_decl.novops_flag) 
 
 3547#define DECL_STATIC_CONSTRUCTOR(NODE) \ 
 3548  (FUNCTION_DECL_CHECK (NODE)->function_decl.static_ctor_flag) 
 
 3550#define DECL_STATIC_DESTRUCTOR(NODE) \ 
 3551(FUNCTION_DECL_CHECK (NODE)->function_decl.static_dtor_flag) 
 
 3555#define DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT(NODE) \ 
 3556  (FUNCTION_DECL_CHECK (NODE)->function_decl.no_instrument_function_entry_exit) 
 
 3560#define DECL_NO_LIMIT_STACK(NODE) \ 
 3561  (FUNCTION_DECL_CHECK (NODE)->function_decl.no_limit_stack) 
 
 3564#define DECL_STATIC_CHAIN(NODE) \ 
 3565  (FUNCTION_DECL_CHECK (NODE)->decl_with_vis.regdecl_flag) 
 
 3570#define DECL_POSSIBLY_INLINED(DECL) \ 
 3571  FUNCTION_DECL_CHECK (DECL)->function_decl.possibly_inlined 
 
 3576#define DECL_DECLARED_INLINE_P(NODE) \ 
 3577  (FUNCTION_DECL_CHECK (NODE)->function_decl.declared_inline_flag) 
 
 3581#define DECL_NO_INLINE_WARNING_P(NODE) \ 
 3582  (FUNCTION_DECL_CHECK (NODE)->function_decl.no_inline_warning_flag) 
 
 3585#define BUILTIN_TM_LOAD_STORE_P(FN) \ 
 3586  ((FN) >= BUILT_IN_TM_STORE_1 && (FN) <= BUILT_IN_TM_LOAD_RFW_LDOUBLE) 
 
 3589#define BUILTIN_TM_LOAD_P(FN) \ 
 3590  ((FN) >= BUILT_IN_TM_LOAD_1 && (FN) <= BUILT_IN_TM_LOAD_RFW_LDOUBLE) 
 
 3593#define BUILTIN_TM_STORE_P(FN) \ 
 3594  ((FN) >= BUILT_IN_TM_STORE_1 && (FN) <= BUILT_IN_TM_STORE_WAW_LDOUBLE) 
 
 3596#define CASE_BUILT_IN_TM_LOAD(FN)       \ 
 3597  case BUILT_IN_TM_LOAD_##FN:           \ 
 3598  case BUILT_IN_TM_LOAD_RAR_##FN:       \ 
 3599  case BUILT_IN_TM_LOAD_RAW_##FN:       \ 
 3600  case BUILT_IN_TM_LOAD_RFW_##FN 
 
 3602#define CASE_BUILT_IN_TM_STORE(FN)      \ 
 3603  case BUILT_IN_TM_STORE_##FN:          \ 
 3604  case BUILT_IN_TM_STORE_WAR_##FN:      \ 
 3605  case BUILT_IN_TM_STORE_WAW_##FN 
 
 3611#define DECL_DISREGARD_INLINE_LIMITS(NODE) \ 
 3612  (FUNCTION_DECL_CHECK (NODE)->function_decl.disregard_inline_limits) 
 
 3618#define DECL_HAS_DEBUG_ARGS_P(NODE) \ 
 3619  (FUNCTION_DECL_CHECK (NODE)->function_decl.has_debug_args_flag) 
 
 3623#define DECL_STRUCT_FUNCTION(NODE) \ 
 3624  (FUNCTION_DECL_CHECK (NODE)->function_decl.f) 
 
 3627#define DECL_BUILT_IN_CLASS(NODE) \ 
 3628   ((built_in_class) FUNCTION_DECL_CHECK (NODE)->function_decl.built_in_class) 
 
 3631#define DECL_ARGUMENTS(NODE) \ 
 3632   (FUNCTION_DECL_CHECK (NODE)->function_decl.arguments) 
 
 3636#define DECL_FUNCTION_SPECIFIC_TARGET(NODE) \ 
 3637   (FUNCTION_DECL_CHECK (NODE)->function_decl.function_specific_target) 
 
 3641#define DECL_FUNCTION_SPECIFIC_OPTIMIZATION(NODE) \ 
 3642   (FUNCTION_DECL_CHECK (NODE)->function_decl.function_specific_optimization) 
 
 3647#define DECL_FUNCTION_VERSIONED(NODE)\ 
 3648   (FUNCTION_DECL_CHECK (NODE)->function_decl.versioned_function) 
 
 3654#define DECL_CXX_CONSTRUCTOR_P(NODE)\ 
 3655   (FUNCTION_DECL_CHECK (NODE)->decl_with_vis.cxx_constructor) 
 
 3659#define DECL_CXX_DESTRUCTOR_P(NODE)\ 
 3660   (FUNCTION_DECL_CHECK (NODE)->decl_with_vis.cxx_destructor) 
 
 3663#define DECL_LAMBDA_FUNCTION_P(NODE) \ 
 3664  (FUNCTION_DECL_DECL_TYPE (FUNCTION_DECL_CHECK (NODE)) \ 
 3665   == function_decl_type::LAMBDA_FUNCTION) 
 
 3667#define DECL_SET_LAMBDA_FUNCTION(NODE, VAL) \ 
 3668  set_function_decl_type (FUNCTION_DECL_CHECK (NODE), \ 
 3669                          function_decl_type::LAMBDA_FUNCTION, VAL) 
 
 3673#define DECL_FINAL_P(NODE)\ 
 3674   (FUNCTION_DECL_CHECK (NODE)->decl_with_vis.final) 
 
 3677#define TRANSLATION_UNIT_LANGUAGE(NODE) \ 
 3678  (TRANSLATION_UNIT_DECL_CHECK (NODE)->translation_unit_decl.language) 
 
 3683#define DECL_ORIGINAL_TYPE(NODE) \ 
 3684  (TYPE_DECL_CHECK (NODE)->decl_non_common.result) 
 
 3689#define TYPE_DECL_SUPPRESS_DEBUG(NODE) \ 
 3690  (TYPE_DECL_CHECK (NODE)->decl_common.decl_flag_1) 
 
 3694#define IMPORTED_DECL_ASSOCIATED_DECL(NODE) \ 
 3695(DECL_INITIAL (IMPORTED_DECL_CHECK (NODE))) 
 
 3699#define NAMELIST_DECL_ASSOCIATED_DECL(NODE) \ 
 3700  (DECL_INITIAL (NODE)) 
 
 3708#define STATEMENT_LIST_HEAD(NODE) \ 
 3709  (STATEMENT_LIST_CHECK (NODE)->stmt_list.head) 
 
 3710#define STATEMENT_LIST_TAIL(NODE) \ 
 3711  (STATEMENT_LIST_CHECK (NODE)->stmt_list.tail) 
 
 3713#define TREE_OPTIMIZATION(NODE) \ 
 3714  (OPTIMIZATION_NODE_CHECK (NODE)->optimization.opts) 
 
 3716#define TREE_OPTIMIZATION_OPTABS(NODE) \ 
 3717  (OPTIMIZATION_NODE_CHECK (NODE)->optimization.optabs) 
 
 3719#define TREE_OPTIMIZATION_BASE_OPTABS(NODE) \ 
 3720  (OPTIMIZATION_NODE_CHECK (NODE)->optimization.base_optabs) 
 
 3725                                     struct gcc_options *opts_set);
 
 3727#define TREE_TARGET_OPTION(NODE) \ 
 3728  (TARGET_OPTION_NODE_CHECK (NODE)->target_option.opts) 
 
 3730#define TREE_TARGET_GLOBALS(NODE) \ 
 3731  (TARGET_OPTION_NODE_CHECK (NODE)->target_option.globals) 
 
 3736                                      struct gcc_options *opts_set);
 
 3740#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007) 
 3743tree_check (
tree __t, 
const char *__f, 
int __l, 
const char *__g, 
tree_code __c)
 
 3746    tree_check_failed (__t, __f, __l, __g, __c, 0);
 
 3751tree_not_check (
tree __t, 
const char *__f, 
int __l, 
const char *__g,
 
 3755    tree_not_check_failed (__t, __f, __l, __g, __c, 0);
 
 3760tree_check2 (
tree __t, 
const char *__f, 
int __l, 
const char *__g,
 
 3765    tree_check_failed (__t, __f, __l, __g, __c1, __c2, 0);
 
 3770tree_not_check2 (
tree __t, 
const char *__f, 
int __l, 
const char *__g,
 
 3775    tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, 0);
 
 3780tree_check3 (
tree __t, 
const char *__f, 
int __l, 
const char *__g,
 
 3786    tree_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, 0);
 
 3791tree_not_check3 (
tree __t, 
const char *__f, 
int __l, 
const char *__g,
 
 3797    tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, 0);
 
 3802tree_check4 (
tree __t, 
const char *__f, 
int __l, 
const char *__g,
 
 3810    tree_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, 0);
 
 3815tree_not_check4 (
tree __t, 
const char *__f, 
int __l, 
const char *__g,
 
 3823    tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, 0);
 
 3828tree_check5 (
tree __t, 
const char *__f, 
int __l, 
const char *__g,
 
 3837    tree_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, __c5, 0);
 
 3842tree_not_check5 (
tree __t, 
const char *__f, 
int __l, 
const char *__g,
 
 3851    tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, __c5, 0);
 
 3856tree_check6 (
tree __t, 
const char *__f, 
int __l, 
const char *__g,
 
 3866    tree_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, __c5, __c6,
 
 3872tree_not_check6 (
tree __t, 
const char *__f, 
int __l, 
const char *__g,
 
 3882    tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, __c5,
 
 3889                       const char *__f, 
int __l, 
const char *__g)
 
 3892      tree_contains_struct_check_failed (__t, __s, __f, __l, __g);
 
 3898                  const char *__f, 
int __l, 
const char *__g)
 
 3901    tree_class_check_failed (__t, __class, __f, __l, __g);
 
 3906tree_range_check (
tree __t,
 
 3908                  const char *__f, 
int __l, 
const char *__g)
 
 3911    tree_range_check_failed (__t, __f, __l, __g, __code1, __code2);
 
 3917                          const char *__f, 
int __l, 
const char *__g)
 
 3920    tree_check_failed (__t, __f, __l, __g, OMP_CLAUSE, 0);
 
 3921  if (__t->omp_clause.code != __code)
 
 3922    omp_clause_check_failed (__t, __f, __l, __g, __code);
 
 3927omp_clause_range_check (
tree __t,
 
 3930                        const char *__f, 
int __l, 
const char *__g)
 
 3933    tree_check_failed (__t, __f, __l, __g, OMP_CLAUSE, 0);
 
 3934  if ((
int) __t->omp_clause.code < (
int) __code1
 
 3935      || (
int) __t->omp_clause.code > (
int) __code2)
 
 3936    omp_clause_range_check_failed (__t, __f, __l, __g, __code1, __code2);
 
 3943expr_check (
tree __t, 
const char *__f, 
int __l, 
const char *__g)
 
 3954non_type_check (
tree __t, 
const char *__f, 
int __l, 
const char *__g)
 
 3957    tree_not_class_check_failed (__t, 
tcc_type, __f, __l, __g);
 
 3961inline const HOST_WIDE_INT *
 
 3962tree_int_cst_elt_check (
const_tree __t, 
int __i,
 
 3963                        const char *__f, 
int __l, 
const char *__g)
 
 3966    tree_check_failed (__t, __f, __l, __g, INTEGER_CST, 0);
 
 3967  if (__i < 0 || __i >= __t->base.u.int_length.extended)
 
 3968    tree_int_cst_elt_check_failed (__i, __t->base.u.int_length.extended,
 
 3973inline HOST_WIDE_INT *
 
 3974tree_int_cst_elt_check (
tree __t, 
int __i,
 
 3975                        const char *__f, 
int __l, 
const char *__g)
 
 3978    tree_check_failed (__t, __f, __l, __g, INTEGER_CST, 0);
 
 3979  if (__i < 0 || __i >= __t->base.u.int_length.extended)
 
 3980    tree_int_cst_elt_check_failed (__i, __t->base.u.int_length.extended,
 
 3987# if GCC_VERSION >= 4006 
 3988#pragma GCC diagnostic push 
 3989#pragma GCC diagnostic ignored "-Wstrict-overflow" 
 3993tree_vec_elt_check (
tree __t, 
int __i,
 
 3994                    const char *__f, 
int __l, 
const char *__g)
 
 3997    tree_check_failed (__t, __f, __l, __g, TREE_VEC, 0);
 
 3998  if (__i < 0 || __i >= __t->base.u.length)
 
 3999    tree_vec_elt_check_failed (__i, __t->base.u.length, __f, __l, __g);
 
 4003# if GCC_VERSION >= 4006 
 4004#pragma GCC diagnostic pop 
 4008omp_clause_elt_check (
tree __t, 
int __i,
 
 4009                      const char *__f, 
int __l, 
const char *__g)
 
 4012    tree_check_failed (__t, __f, __l, __g, OMP_CLAUSE, 0);
 
 4014    omp_clause_operand_check_failed (__i, __t, __f, __l, __g);
 
 4015  return &__t->omp_clause.ops[__i];
 
 4021any_integral_type_check (
tree __t, 
const char *__f, 
int __l, 
const char *__g)
 
 4024    tree_check_failed (__t, __f, __l, __g, BOOLEAN_TYPE, ENUMERAL_TYPE,
 
 4025                       INTEGER_TYPE, BITINT_TYPE, 0);
 
 4030tree_check (
const_tree __t, 
const char *__f, 
int __l, 
const char *__g,
 
 4034    tree_check_failed (__t, __f, __l, __g, __c, 0);
 
 4039tree_not_check (
const_tree __t, 
const char *__f, 
int __l, 
const char *__g,
 
 4043    tree_not_check_failed (__t, __f, __l, __g, __c, 0);
 
 4048tree_check2 (
const_tree __t, 
const char *__f, 
int __l, 
const char *__g,
 
 4053    tree_check_failed (__t, __f, __l, __g, __c1, __c2, 0);
 
 4058tree_not_check2 (
const_tree __t, 
const char *__f, 
int __l, 
const char *__g,
 
 4063    tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, 0);
 
 4068tree_check3 (
const_tree __t, 
const char *__f, 
int __l, 
const char *__g,
 
 4074    tree_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, 0);
 
 4079tree_not_check3 (
const_tree __t, 
const char *__f, 
int __l, 
const char *__g,
 
 4085    tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, 0);
 
 4090tree_check4 (
const_tree __t, 
const char *__f, 
int __l, 
const char *__g,
 
 4098    tree_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, 0);
 
 4103tree_not_check4 (
const_tree __t, 
const char *__f, 
int __l, 
const char *__g,
 
 4111    tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, 0);
 
 4116tree_check5 (
const_tree __t, 
const char *__f, 
int __l, 
const char *__g,
 
 4125    tree_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, __c5, 0);
 
 4130tree_not_check5 (
const_tree __t, 
const char *__f, 
int __l, 
const char *__g,
 
 4139    tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, __c5, 0);
 
 4144tree_check6 (
const_tree __t, 
const char *__f, 
int __l, 
const char *__g,
 
 4154    tree_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, __c5, __c6,
 
 4160tree_not_check6 (
const_tree __t, 
const char *__f, 
int __l, 
const char *__g,
 
 4170    tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, __c5,
 
 4177                       const char *__f, 
int __l, 
const char *__g)
 
 4180      tree_contains_struct_check_failed (__t, __s, __f, __l, __g);
 
 4186                  const char *__f, 
int __l, 
const char *__g)
 
 4189    tree_class_check_failed (__t, __class, __f, __l, __g);
 
 4196                  const char *__f, 
int __l, 
const char *__g)
 
 4199    tree_range_check_failed (__t, __f, __l, __g, __code1, __code2);
 
 4205                          const char *__f, 
int __l, 
const char *__g)
 
 4208    tree_check_failed (__t, __f, __l, __g, OMP_CLAUSE, 0);
 
 4209  if (__t->omp_clause.code != __code)
 
 4210    omp_clause_check_failed (__t, __f, __l, __g, __code);
 
 4218                        const char *__f, 
int __l, 
const char *__g)
 
 4221    tree_check_failed (__t, __f, __l, __g, OMP_CLAUSE, 0);
 
 4222  if ((
int) __t->omp_clause.code < (
int) __code1
 
 4223      || (
int) __t->omp_clause.code > (
int) __code2)
 
 4224    omp_clause_range_check_failed (__t, __f, __l, __g, __code1, __code2);
 
 4229expr_check (
const_tree __t, 
const char *__f, 
int __l, 
const char *__g)
 
 4238non_type_check (
const_tree __t, 
const char *__f, 
int __l, 
const char *__g)
 
 4241    tree_not_class_check_failed (__t, 
tcc_type, __f, __l, __g);
 
 4245# if GCC_VERSION >= 4006 
 4246#pragma GCC diagnostic push 
 4247#pragma GCC diagnostic ignored "-Wstrict-overflow" 
 4252                    const char *__f, 
int __l, 
const char *__g)
 
 4255    tree_check_failed (__t, __f, __l, __g, TREE_VEC, 0);
 
 4256  if (__i < 0 || __i >= __t->base.u.length)
 
 4257    tree_vec_elt_check_failed (__i, __t->base.u.length, __f, __l, __g);
 
 4262# if GCC_VERSION >= 4006 
 4263#pragma GCC diagnostic pop 
 4267omp_clause_elt_check (
const_tree __t, 
int __i,
 
 4268                      const char *__f, 
int __l, 
const char *__g)
 
 4271    tree_check_failed (__t, __f, __l, __g, OMP_CLAUSE, 0);
 
 4273    omp_clause_operand_check_failed (__i, __t, __f, __l, __g);
 
 4278any_integral_type_check (
const_tree __t, 
const char *__f, 
int __l,
 
 4282    tree_check_failed (__t, __f, __l, __g, BOOLEAN_TYPE, ENUMERAL_TYPE,
 
 4283                       INTEGER_TYPE, BITINT_TYPE, 0);
 
 4301#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007) 
 4305tree_operand_check (
tree __t, 
int __i,
 
 4306                    const char *__f, 
int __l, 
const char *__g)
 
 4310    tree_operand_check_failed (__i, __u, __f, __l, __g);
 
 4315tree_operand_check_code (
tree __t, 
enum tree_code __code, 
int __i,
 
 4316                         const char *__f, 
int __l, 
const char *__g)
 
 4319    tree_check_failed (__t, __f, __l, __g, __code, 0);
 
 4321    tree_operand_check_failed (__i, __t, __f, __l, __g);
 
 4322  return &__t->exp.operands[__i];
 
 4327                    const char *__f, 
int __l, 
const char *__g)
 
 4331    tree_operand_check_failed (__i, __u, __f, __l, __g);
 
 4337                         const char *__f, 
int __l, 
const char *__g)
 
 4340    tree_check_failed (__t, __f, __l, __g, __code, 0);
 
 4342    tree_operand_check_failed (__i, __t, __f, __l, __g);
 
 4368  unsigned int precision = VECTOR_TYPE_CHECK (
node)->type_common.precision;
 
 4375      if (precision & 0x100)
 
 
 4390  unsigned HOST_WIDE_INT coeff0 = subparts.
coeffs[0];
 
 4410      unsigned HOST_WIDE_INT coeff1 = subparts.
coeffs[1];
 
 4411      gcc_assert (coeff1 == 0 || coeff1 == coeff0);
 
 4412      VECTOR_TYPE_CHECK (
node)->type_common.precision
 
 4413        = index + (coeff1 != 0 ? 0x100 : 0);
 
 4416    VECTOR_TYPE_CHECK (
node)->type_common.precision = index;
 
 
 4425  unsigned HOST_WIDE_INT coeff0 = subparts.
coeffs[0];
 
 4430      unsigned HOST_WIDE_INT coeff1 = subparts.
coeffs[1];
 
 4431      if (coeff1 != 0 && coeff1 != coeff0)
 
 
 4442  const tree_function_decl &fndecl = FUNCTION_DECL_CHECK (
decl)->function_decl;
 
 
 4453  const tree_function_decl &fndecl = FUNCTION_DECL_CHECK (
decl)->function_decl;
 
 4455  return fndecl.function_code;
 
 
 4464  const tree_function_decl &fndecl = FUNCTION_DECL_CHECK (
decl)->function_decl;
 
 4466  return fndecl.function_code;
 
 
 4475  tree_function_decl &fndecl = FUNCTION_DECL_CHECK (
decl)->function_decl;
 
 4476  fndecl.built_in_class = fclass;
 
 4477  fndecl.function_code = fcode;
 
 
 4485  tree_function_decl &newfndecl = FUNCTION_DECL_CHECK (newdecl)->function_decl;
 
 4486  const tree_function_decl &oldfndecl
 
 4487    = FUNCTION_DECL_CHECK (olddecl)->function_decl;
 
 4488  newfndecl.built_in_class = oldfndecl.built_in_class;
 
 4489  newfndecl.function_code = oldfndecl.function_code;
 
 
 4496#define EXPR_LOCATION_WRAPPER_P(NODE) \ 
 4497  (TREE_CHECK2(NODE, NON_LVALUE_EXPR, VIEW_CONVERT_EXPR)->base.public_flag) 
 
 4531#define error_mark_node                 global_trees[TI_ERROR_MARK] 
 4533#define intQI_type_node                 global_trees[TI_INTQI_TYPE] 
 4534#define intHI_type_node                 global_trees[TI_INTHI_TYPE] 
 4535#define intSI_type_node                 global_trees[TI_INTSI_TYPE] 
 4536#define intDI_type_node                 global_trees[TI_INTDI_TYPE] 
 4537#define intTI_type_node                 global_trees[TI_INTTI_TYPE] 
 4539#define unsigned_intQI_type_node        global_trees[TI_UINTQI_TYPE] 
 4540#define unsigned_intHI_type_node        global_trees[TI_UINTHI_TYPE] 
 4541#define unsigned_intSI_type_node        global_trees[TI_UINTSI_TYPE] 
 4542#define unsigned_intDI_type_node        global_trees[TI_UINTDI_TYPE] 
 4543#define unsigned_intTI_type_node        global_trees[TI_UINTTI_TYPE] 
 4545#define atomicQI_type_node      global_trees[TI_ATOMICQI_TYPE] 
 4546#define atomicHI_type_node      global_trees[TI_ATOMICHI_TYPE] 
 4547#define atomicSI_type_node      global_trees[TI_ATOMICSI_TYPE] 
 4548#define atomicDI_type_node      global_trees[TI_ATOMICDI_TYPE] 
 4549#define atomicTI_type_node      global_trees[TI_ATOMICTI_TYPE] 
 4551#define uint16_type_node                global_trees[TI_UINT16_TYPE] 
 4552#define uint32_type_node                global_trees[TI_UINT32_TYPE] 
 4553#define uint64_type_node                global_trees[TI_UINT64_TYPE] 
 4554#define uint128_type_node               global_trees[TI_UINT128_TYPE] 
 4556#define void_node                       global_trees[TI_VOID] 
 4558#define integer_zero_node               global_trees[TI_INTEGER_ZERO] 
 4559#define integer_one_node                global_trees[TI_INTEGER_ONE] 
 4560#define integer_minus_one_node          global_trees[TI_INTEGER_MINUS_ONE] 
 4561#define size_zero_node                  global_trees[TI_SIZE_ZERO] 
 4562#define size_one_node                   global_trees[TI_SIZE_ONE] 
 4563#define bitsize_zero_node               global_trees[TI_BITSIZE_ZERO] 
 4564#define bitsize_one_node                global_trees[TI_BITSIZE_ONE] 
 4565#define bitsize_unit_node               global_trees[TI_BITSIZE_UNIT] 
 4568#define access_public_node              global_trees[TI_PUBLIC] 
 4569#define access_protected_node           global_trees[TI_PROTECTED] 
 4570#define access_private_node             global_trees[TI_PRIVATE] 
 4572#define null_pointer_node               global_trees[TI_NULL_POINTER] 
 4574#define float_type_node                 global_trees[TI_FLOAT_TYPE] 
 4575#define double_type_node                global_trees[TI_DOUBLE_TYPE] 
 4576#define long_double_type_node           global_trees[TI_LONG_DOUBLE_TYPE] 
 4577#define bfloat16_type_node              global_trees[TI_BFLOAT16_TYPE] 
 4580#define FLOATN_TYPE_NODE(IDX)           global_trees[TI_FLOATN_TYPE_FIRST + (IDX)] 
 4581#define FLOATN_NX_TYPE_NODE(IDX)        global_trees[TI_FLOATN_NX_TYPE_FIRST + (IDX)] 
 4582#define FLOATNX_TYPE_NODE(IDX)          global_trees[TI_FLOATNX_TYPE_FIRST + (IDX)] 
 4587#define float16_type_node               global_trees[TI_FLOAT16_TYPE] 
 4588#define float32_type_node               global_trees[TI_FLOAT32_TYPE] 
 4589#define float64_type_node               global_trees[TI_FLOAT64_TYPE] 
 4590#define float128_type_node              global_trees[TI_FLOAT128_TYPE] 
 4591#define float32x_type_node              global_trees[TI_FLOAT32X_TYPE] 
 4592#define float64x_type_node              global_trees[TI_FLOAT64X_TYPE] 
 4593#define float128x_type_node             global_trees[TI_FLOAT128X_TYPE] 
 4597#define float128t_type_node             global_trees[TI_FLOAT128T_TYPE] 
 4599#define float_ptr_type_node             global_trees[TI_FLOAT_PTR_TYPE] 
 4600#define double_ptr_type_node            global_trees[TI_DOUBLE_PTR_TYPE] 
 4601#define long_double_ptr_type_node       global_trees[TI_LONG_DOUBLE_PTR_TYPE] 
 4602#define integer_ptr_type_node           global_trees[TI_INTEGER_PTR_TYPE] 
 4604#define complex_integer_type_node       global_trees[TI_COMPLEX_INTEGER_TYPE] 
 4605#define complex_float_type_node         global_trees[TI_COMPLEX_FLOAT_TYPE] 
 4606#define complex_double_type_node        global_trees[TI_COMPLEX_DOUBLE_TYPE] 
 4607#define complex_long_double_type_node   global_trees[TI_COMPLEX_LONG_DOUBLE_TYPE] 
 4609#define COMPLEX_FLOATN_NX_TYPE_NODE(IDX)        global_trees[TI_COMPLEX_FLOATN_NX_TYPE_FIRST + (IDX)] 
 4611#define void_type_node                  global_trees[TI_VOID_TYPE] 
 4613#define ptr_type_node                   global_trees[TI_PTR_TYPE] 
 4615#define const_ptr_type_node             global_trees[TI_CONST_PTR_TYPE] 
 4617#define size_type_node                  global_trees[TI_SIZE_TYPE] 
 4618#define pid_type_node                   global_trees[TI_PID_TYPE] 
 4619#define ptrdiff_type_node               global_trees[TI_PTRDIFF_TYPE] 
 4620#define va_list_type_node               global_trees[TI_VA_LIST_TYPE] 
 4621#define va_list_gpr_counter_field       global_trees[TI_VA_LIST_GPR_COUNTER_FIELD] 
 4622#define va_list_fpr_counter_field       global_trees[TI_VA_LIST_FPR_COUNTER_FIELD] 
 4624#define fileptr_type_node               global_trees[TI_FILEPTR_TYPE] 
 4626#define const_tm_ptr_type_node          global_trees[TI_CONST_TM_PTR_TYPE] 
 4628#define fenv_t_ptr_type_node            global_trees[TI_FENV_T_PTR_TYPE] 
 4629#define const_fenv_t_ptr_type_node      global_trees[TI_CONST_FENV_T_PTR_TYPE] 
 4631#define fexcept_t_ptr_type_node         global_trees[TI_FEXCEPT_T_PTR_TYPE] 
 4632#define const_fexcept_t_ptr_type_node   global_trees[TI_CONST_FEXCEPT_T_PTR_TYPE] 
 4633#define pointer_sized_int_node          global_trees[TI_POINTER_SIZED_TYPE] 
 4635#define boolean_type_node               global_trees[TI_BOOLEAN_TYPE] 
 4636#define boolean_false_node              global_trees[TI_BOOLEAN_FALSE] 
 4637#define boolean_true_node               global_trees[TI_BOOLEAN_TRUE] 
 4640#define dfloat32_type_node              global_trees[TI_DFLOAT32_TYPE] 
 4641#define dfloat64_type_node              global_trees[TI_DFLOAT64_TYPE] 
 4642#define dfloat128_type_node             global_trees[TI_DFLOAT128_TYPE] 
 4643#define dfloat64x_type_node             global_trees[TI_DFLOAT64X_TYPE] 
 4646#define sat_short_fract_type_node       global_trees[TI_SAT_SFRACT_TYPE] 
 4647#define sat_fract_type_node             global_trees[TI_SAT_FRACT_TYPE] 
 4648#define sat_long_fract_type_node        global_trees[TI_SAT_LFRACT_TYPE] 
 4649#define sat_long_long_fract_type_node   global_trees[TI_SAT_LLFRACT_TYPE] 
 4650#define sat_unsigned_short_fract_type_node \ 
 4651                                        global_trees[TI_SAT_USFRACT_TYPE] 
 
 4652#define sat_unsigned_fract_type_node    global_trees[TI_SAT_UFRACT_TYPE] 
 4653#define sat_unsigned_long_fract_type_node \ 
 4654                                        global_trees[TI_SAT_ULFRACT_TYPE] 
 
 4655#define sat_unsigned_long_long_fract_type_node \ 
 4656                                        global_trees[TI_SAT_ULLFRACT_TYPE] 
 
 4657#define short_fract_type_node           global_trees[TI_SFRACT_TYPE] 
 4658#define fract_type_node                 global_trees[TI_FRACT_TYPE] 
 4659#define long_fract_type_node            global_trees[TI_LFRACT_TYPE] 
 4660#define long_long_fract_type_node       global_trees[TI_LLFRACT_TYPE] 
 4661#define unsigned_short_fract_type_node  global_trees[TI_USFRACT_TYPE] 
 4662#define unsigned_fract_type_node        global_trees[TI_UFRACT_TYPE] 
 4663#define unsigned_long_fract_type_node   global_trees[TI_ULFRACT_TYPE] 
 4664#define unsigned_long_long_fract_type_node \ 
 4665                                        global_trees[TI_ULLFRACT_TYPE] 
 
 4666#define sat_short_accum_type_node       global_trees[TI_SAT_SACCUM_TYPE] 
 4667#define sat_accum_type_node             global_trees[TI_SAT_ACCUM_TYPE] 
 4668#define sat_long_accum_type_node        global_trees[TI_SAT_LACCUM_TYPE] 
 4669#define sat_long_long_accum_type_node   global_trees[TI_SAT_LLACCUM_TYPE] 
 4670#define sat_unsigned_short_accum_type_node \ 
 4671                                        global_trees[TI_SAT_USACCUM_TYPE] 
 
 4672#define sat_unsigned_accum_type_node    global_trees[TI_SAT_UACCUM_TYPE] 
 4673#define sat_unsigned_long_accum_type_node \ 
 4674                                        global_trees[TI_SAT_ULACCUM_TYPE] 
 
 4675#define sat_unsigned_long_long_accum_type_node \ 
 4676                                        global_trees[TI_SAT_ULLACCUM_TYPE] 
 
 4677#define short_accum_type_node           global_trees[TI_SACCUM_TYPE] 
 4678#define accum_type_node                 global_trees[TI_ACCUM_TYPE] 
 4679#define long_accum_type_node            global_trees[TI_LACCUM_TYPE] 
 4680#define long_long_accum_type_node       global_trees[TI_LLACCUM_TYPE] 
 4681#define unsigned_short_accum_type_node  global_trees[TI_USACCUM_TYPE] 
 4682#define unsigned_accum_type_node        global_trees[TI_UACCUM_TYPE] 
 4683#define unsigned_long_accum_type_node   global_trees[TI_ULACCUM_TYPE] 
 4684#define unsigned_long_long_accum_type_node \ 
 4685                                        global_trees[TI_ULLACCUM_TYPE] 
 
 4686#define qq_type_node                    global_trees[TI_QQ_TYPE] 
 4687#define hq_type_node                    global_trees[TI_HQ_TYPE] 
 4688#define sq_type_node                    global_trees[TI_SQ_TYPE] 
 4689#define dq_type_node                    global_trees[TI_DQ_TYPE] 
 4690#define tq_type_node                    global_trees[TI_TQ_TYPE] 
 4691#define uqq_type_node                   global_trees[TI_UQQ_TYPE] 
 4692#define uhq_type_node                   global_trees[TI_UHQ_TYPE] 
 4693#define usq_type_node                   global_trees[TI_USQ_TYPE] 
 4694#define udq_type_node                   global_trees[TI_UDQ_TYPE] 
 4695#define utq_type_node                   global_trees[TI_UTQ_TYPE] 
 4696#define sat_qq_type_node                global_trees[TI_SAT_QQ_TYPE] 
 4697#define sat_hq_type_node                global_trees[TI_SAT_HQ_TYPE] 
 4698#define sat_sq_type_node                global_trees[TI_SAT_SQ_TYPE] 
 4699#define sat_dq_type_node                global_trees[TI_SAT_DQ_TYPE] 
 4700#define sat_tq_type_node                global_trees[TI_SAT_TQ_TYPE] 
 4701#define sat_uqq_type_node               global_trees[TI_SAT_UQQ_TYPE] 
 4702#define sat_uhq_type_node               global_trees[TI_SAT_UHQ_TYPE] 
 4703#define sat_usq_type_node               global_trees[TI_SAT_USQ_TYPE] 
 4704#define sat_udq_type_node               global_trees[TI_SAT_UDQ_TYPE] 
 4705#define sat_utq_type_node               global_trees[TI_SAT_UTQ_TYPE] 
 4706#define ha_type_node                    global_trees[TI_HA_TYPE] 
 4707#define sa_type_node                    global_trees[TI_SA_TYPE] 
 4708#define da_type_node                    global_trees[TI_DA_TYPE] 
 4709#define ta_type_node                    global_trees[TI_TA_TYPE] 
 4710#define uha_type_node                   global_trees[TI_UHA_TYPE] 
 4711#define usa_type_node                   global_trees[TI_USA_TYPE] 
 4712#define uda_type_node                   global_trees[TI_UDA_TYPE] 
 4713#define uta_type_node                   global_trees[TI_UTA_TYPE] 
 4714#define sat_ha_type_node                global_trees[TI_SAT_HA_TYPE] 
 4715#define sat_sa_type_node                global_trees[TI_SAT_SA_TYPE] 
 4716#define sat_da_type_node                global_trees[TI_SAT_DA_TYPE] 
 4717#define sat_ta_type_node                global_trees[TI_SAT_TA_TYPE] 
 4718#define sat_uha_type_node               global_trees[TI_SAT_UHA_TYPE] 
 4719#define sat_usa_type_node               global_trees[TI_SAT_USA_TYPE] 
 4720#define sat_uda_type_node               global_trees[TI_SAT_UDA_TYPE] 
 4721#define sat_uta_type_node               global_trees[TI_SAT_UTA_TYPE] 
 4728#define void_list_node                  global_trees[TI_VOID_LIST_NODE] 
 4730#define main_identifier_node            global_trees[TI_MAIN_IDENTIFIER] 
 4731#define MAIN_NAME_P(NODE) \ 
 4732  (IDENTIFIER_NODE_CHECK (NODE) == main_identifier_node) 
 
 4736#define optimization_default_node       global_trees[TI_OPTIMIZATION_DEFAULT] 
 4737#define optimization_current_node       global_trees[TI_OPTIMIZATION_CURRENT] 
 4740#define target_option_default_node      global_trees[TI_TARGET_OPTION_DEFAULT] 
 4741#define target_option_current_node      global_trees[TI_TARGET_OPTION_CURRENT] 
 4745#define current_target_pragma           global_trees[TI_CURRENT_TARGET_PRAGMA] 
 4746#define current_optimize_pragma         global_trees[TI_CURRENT_OPTIMIZE_PRAGMA] 
 4749#define chrec_not_analyzed_yet          NULL_TREE 
 4750#define chrec_dont_know                 global_trees[TI_CHREC_DONT_KNOW] 
 4751#define chrec_known                     global_trees[TI_CHREC_KNOWN] 
 4753#define char_type_node                  integer_types[itk_char] 
 4754#define signed_char_type_node           integer_types[itk_signed_char] 
 4755#define unsigned_char_type_node         integer_types[itk_unsigned_char] 
 4756#define short_integer_type_node         integer_types[itk_short] 
 4757#define short_unsigned_type_node        integer_types[itk_unsigned_short] 
 4758#define integer_type_node               integer_types[itk_int] 
 4759#define unsigned_type_node              integer_types[itk_unsigned_int] 
 4760#define long_integer_type_node          integer_types[itk_long] 
 4761#define long_unsigned_type_node         integer_types[itk_unsigned_long] 
 4762#define long_long_integer_type_node     integer_types[itk_long_long] 
 4763#define long_long_unsigned_type_node    integer_types[itk_unsigned_long_long] 
 4979#define build_call_array(T1,T2,N,T3)\ 
 4980   build_call_array_loc (UNKNOWN_LOCATION, T1, T2, N, T3) 
 
 5031#define build_function_type_vec(RET, V) \ 
 5032  build_function_type_array (RET, vec_safe_length (V), vec_safe_address (V)) 
 
 5033#define build_varargs_function_type_vec(RET, V) \ 
 5034  build_varargs_function_type_array (RET, vec_safe_length (V), \ 
 5035                                     vec_safe_address (V)) 
 
 5060  ATTRIBUTE_NONNULL (1) ATTRIBUTE_PURE;
 
 5062  ATTRIBUTE_NONNULL (1) ATTRIBUTE_PURE;
 
 5064  ATTRIBUTE_NONNULL (1) ATTRIBUTE_PURE;
 
 5066  ATTRIBUTE_NONNULL (1) ATTRIBUTE_PURE;
 
 5068  ATTRIBUTE_NONNULL (1) ATTRIBUTE_PURE;
 
 5069#if !defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 4003) 
 5070extern inline __attribute__ ((__gnu_inline__)) HOST_WIDE_INT
 
 5077extern inline __attribute__ ((__gnu_inline__)) 
unsigned HOST_WIDE_INT
 
 5083#if NUM_POLY_INT_COEFFS == 1 
 5084extern inline __attribute__ ((__gnu_inline__)) 
poly_int64 
 5091extern inline __attribute__ ((__gnu_inline__)) 
poly_uint64 
 5208#define build_type_variant(TYPE, CONST_P, VOLATILE_P)                   \ 
 5209  build_qualified_type ((TYPE),                                         \ 
 5210                        ((CONST_P) ? TYPE_QUAL_CONST : 0)               \ 
 5211                        | ((VOLATILE_P) ? TYPE_QUAL_VOLATILE : 0)) 
 
 5242#define sizetype sizetype_tab[(int) stk_sizetype] 
 5243#define bitsizetype sizetype_tab[(int) stk_bitsizetype] 
 5244#define ssizetype sizetype_tab[(int) stk_ssizetype] 
 5245#define sbitsizetype sizetype_tab[(int) stk_sbitsizetype] 
 5246#define size_int(L) size_int_kind (L, stk_sizetype) 
 5247#define ssize_int(L) size_int_kind (L, stk_ssizetype) 
 5248#define bitsize_int(L) size_int_kind (L, stk_bitsizetype) 
 5249#define sbitsize_int(L) size_int_kind (L, stk_sbitsizetype) 
 5253#if BITS_PER_UNIT == 8 
 5254#define LOG2_BITS_PER_UNIT 3 
 5255#elif BITS_PER_UNIT == 16 
 5256#define LOG2_BITS_PER_UNIT 4 
 5258#error Unknown BITS_PER_UNIT 
 5414#define CONTAINS_PLACEHOLDER_P(EXP) \ 
 5415  ((EXP) != 0 && ! TREE_CONSTANT (EXP) && contains_placeholder_p (EXP)) 
 
 5435#define FIND_PLACEHOLDER_IN_EXPR(EXP, V) \ 
 5437  if((EXP) && !TREE_CONSTANT (EXP))      \ 
 5438    find_placeholder_in_expr (EXP, V);   \ 
 
 5453#define SUBSTITUTE_IN_EXPR(EXP, F, R) \ 
 5454  ((EXP) == 0 || TREE_CONSTANT (EXP) ? (EXP) : substitute_in_expr (EXP, F, R)) 
 
 5464#define SUBSTITUTE_PLACEHOLDER_IN_EXPR(EXP, OBJ) \ 
 5465  ((EXP) == 0 || TREE_CONSTANT (EXP) ? (EXP)    \ 
 5466   : substitute_placeholder_in_expr (EXP, OBJ)) 
 
 5499    case ARRAY_RANGE_REF:
 
 5502    case VIEW_CONVERT_EXPR:
 
 
 5537    case ARRAY_RANGE_REF:
 
 5538    case VIEW_CONVERT_EXPR:
 
 
 5637#define FOREACH_FUNCTION_ARGS_PTR(FNTYPE, PTR, ITER)                    \ 
 5638  for (function_args_iter_init (&(ITER), (FNTYPE));                     \ 
 5639       (PTR = function_args_iter_cond_ptr (&(ITER))) != NULL;           \ 
 5640       function_args_iter_next (&(ITER))) 
 
 5645#define FOREACH_FUNCTION_ARGS(FNTYPE, TREE, ITER)                       \ 
 5646  for (function_args_iter_init (&(ITER), (FNTYPE));                     \ 
 5647       (TREE = function_args_iter_cond (&(ITER))) != NULL_TREE;         \ 
 5648       function_args_iter_next (&(ITER))) 
 
 5720  const void * 
const * x = (
const void * 
const *) 
a;
 
 5721  const void * 
const * 
y = (
const void * 
const *) 
b;
 
 
 5728  const void * 
const * x = (
const void * 
const *) 
a;
 
 5729  return (intptr_t)*x >> 4;
 
 
 5742  return code == TRUNC_DIV_EXPR || code == EXACT_DIV_EXPR;
 
 
 5750          || code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR
 
 5751          || code == TRUTH_OR_EXPR || code == TRUTH_ORIF_EXPR
 
 5752          || code == TRUTH_XOR_EXPR || code == TRUTH_NOT_EXPR);
 
 
 5808  ATTRIBUTE_NONNULL (1) ATTRIBUTE_NONNULL (2) ATTRIBUTE_PURE;
 
 5809#ifndef GENERATOR_FILE 
 5831  return hstate.
end ();
 
 
 5875#define walk_tree(a,b,c,d) \ 
 5876        walk_tree_1 (a, b, c, d, NULL) 
 
 5877#define walk_tree_without_duplicates(a,b,c) \ 
 5878        walk_tree_without_duplicates_1 (a, b, c, NULL) 
 
 5945                                                 bool trust_type_canonical = 
true);
 
 5964  if (code == ENUMERAL_TYPE)
 
 5965    return INTEGER_TYPE;
 
 5971  if (code == REFERENCE_TYPE)
 
 5972    return POINTER_TYPE;
 
 
 6003#define tree_map_eq tree_map_base_eq 
 6005#define tree_map_marked_p tree_map_base_marked_p 
 6007#define tree_decl_map_eq tree_map_base_eq 
 6009#define tree_decl_map_marked_p tree_map_base_marked_p 
 6027#define tree_int_map_eq tree_map_base_eq 
 6028#define tree_int_map_hash tree_map_base_hash 
 6029#define tree_int_map_marked_p tree_map_base_marked_p 
 6031#define tree_vec_map_eq tree_map_base_eq 
 6032#define tree_vec_map_hash tree_decl_map_hash 
 6033#define tree_vec_map_marked_p tree_map_base_marked_p 
 6037  static hashval_t 
hash (tree_vec_map *m) { 
return DECL_UID (m->base.from); }
 
 6042    return a->base.from == 
b->base.from;
 
 
 
 6057  static inline hashval_t 
hash (
tree);
 
 
 6069  static inline hashval_t 
hash (
tree);
 
 
 6083  static inline hashval_t 
hash (
tree);
 
 
 6107struct tree_cache_traits
 
 
 6113struct decl_tree_cache_traits
 
 
 6119struct type_tree_cache_traits
 
 6124struct decl_tree_traits
 
 
 6131init_call_expr_arg_iterator (
tree exp, call_expr_arg_iterator *iter)
 
 
 6139init_const_call_expr_arg_iterator (
const_tree exp, const_call_expr_arg_iterator *iter)
 
 
 6149next_call_expr_arg (call_expr_arg_iterator *iter)
 
 6152  if (iter->i >= iter->n)
 
 
 6160next_const_call_expr_arg (const_call_expr_arg_iterator *iter)
 
 
 6163  if (iter->i >= iter->n)
 
 6177  init_call_expr_arg_iterator (
exp, iter);
 
 6178  return next_call_expr_arg (iter);
 
 6184  init_const_call_expr_arg_iterator (
exp, iter);
 
 6185  return next_const_call_expr_arg (iter);
 
 6193  return (iter->i < iter->n);
 
 
 6198#define FOR_EACH_CALL_EXPR_ARG(arg, iter, call)                 \ 
 6199  for ((arg) = first_call_expr_arg ((call), &(iter)); (arg);    \ 
 6200       (arg) = next_call_expr_arg (&(iter))) 
 6202#define FOR_EACH_CONST_CALL_EXPR_ARG(arg, iter, call)                   \ 
 6203  for ((arg) = first_const_call_expr_arg ((call), &(iter)); (arg);      \ 
 6204       (arg) = next_const_call_expr_arg (&(iter))) 
 
 6214#define BUILTIN_VALID_P(FNCODE) \ 
 6215  (IN_RANGE ((int)FNCODE, ((int)BUILT_IN_NONE) + 1, ((int) END_BUILTINS) - 1)) 
 6221#define BUILTIN_ASM_NAME_PTR(BUILTIN) \ 
 6222  (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (builtin_decl_explicit (BUILTIN)))) 
 
 6237  size_t uns_fncode = (size_t)fncode;
 
 
 6257  size_t ufncode = (size_t)fncode;
 
 6272  size_t uns_fncode = (size_t)fncode;
 
 
 6285  size_t uns_fncode = (size_t)fncode;
 
 6308  size_t uns_fncode = (size_t)fncode;
 
 6320  size_t uns_fncode = (size_t)fncode;
 
 6379inline struct cl_optimization *
 
 
 6389inline cl_target_option *
 
 
 6400#define opt_for_fn(fndecl, opt) (opts_for_fn (fndecl)->x_##opt) 
 6422    unsigned int get_len () 
const;
 
 
 6430    static const bool host_dependent_precision = 
false;
 
 6431    static const bool is_sign_extended = 
false;
 
 6432    static const bool needs_write_val_arg = 
false;
 
 
 6446    const HOST_WIDE_INT *
get_val () 
const;
 
 6447    unsigned int get_len () 
const;
 
 6456    static const bool host_dependent_precision = 
false;
 
 6457    static const bool is_sign_extended = 
true;
 
 6458    static const bool needs_write_val_arg = 
false;
 
 6467  typedef const generic_wide_int<wide_int_ref_storage<false, false> >
 
 6476                          generic_wide_int <widest_extended_tree> >
 
 6479                          generic_wide_int <offset_extended_tree> >
 
 6482                          generic_wide_int <unextended_tree> >
 
 
 6492    typedef generic_wide_int <extended_tree <N> > extended;
 
 6493    static extended 
zero (
const extended &);
 
 6499    typedef generic_wide_int <extended_tree <N> > extended;
 
 6500    static extended 
zero (
const extended &);
 
 6506    typedef generic_wide_int <unextended_tree> unextended;
 
 6507    static unextended 
zero (
const unextended &);
 
 
 6513typedef generic_wide_int <wi::extended_tree <WIDEST_INT_MAX_PRECISION * 2> >
 
 6637inline const HOST_WIDE_INT *
 
 
 6672inline const HOST_WIDE_INT *
 
 6689  poly_int <NUM_POLY_INT_COEFFS, generic_wide_int <wi::unextended_tree> > res;
 
 6704                generic_wide_int <widest_extended_tree> > res;
 
 6721                generic_wide_int <offset_extended_tree> > res;
 
 
 6741inline generic_wide_int <wi::extended_tree <N> >
 
 6742wi::ints_for <generic_wide_int <wi::extended_tree <N> >,
 
 6749inline generic_wide_int <wi::extended_tree <N> >
 
 6750wi::ints_for <generic_wide_int <wi::extended_tree <N> >,
 
 6756inline generic_wide_int <wi::unextended_tree>
 
 
 6757wi::ints_for <generic_wide_int <wi::unextended_tree>,
 
 6765  template <
typename T>
 
 
 6768  template <
typename T>
 
 6773#ifndef GENERATOR_FILE 
 
 6778template <
typename T>
 
 6787template <
typename T>
 
 6859                                 tree *, machine_mode *, 
int *, 
int *, 
int *);
 
 6943class builtin_structptr_type
 
 6965  return name0 == name1;
 
 6970template <
typename... F>
 
 7012template <
typename... F>
 
 7062  location_t m_operator_loc;
 
 7063  location_t m_combined_loc;
 
 7066  op_location_t (location_t combined_loc)
 
 7072  op_location_t (location_t operator_loc, location_t combined_loc)
 
 7073  : m_operator_loc (operator_loc), m_combined_loc (combined_loc)
 
 7077  operator location_t ()
 const { 
return m_combined_loc; }
 
 7104  ATTRIBUTE_NONNULL (1);
 
void gt_pch_nx(bbitmap< N > *)
Definition bbitmap.h:226
void gt_ggc_mx(bbitmap< N > *)
Definition bbitmap.h:220
auto_suppress_location_wrappers()
Definition tree.h:1391
~auto_suppress_location_wrappers()
Definition tree.h:1392
tree & base
Definition tree.h:6878
const char * str
Definition tree.h:6879
code_helper(tree_code code)
Definition tree.h:85
tree_code safe_as_tree_code() const
Definition tree.h:113
bool is_internal_fn() const
Definition tree.h:138
code_helper()
Definition tree.h:84
bool operator!=(const code_helper &other)
Definition tree.h:100
code_helper(internal_fn fn)
Definition tree.h:87
bool is_fn_code() const
Definition tree.h:93
bool operator==(const code_helper &other)
Definition tree.h:99
int rep
Definition tree.h:105
code_helper(combined_fn fn)
Definition tree.h:86
int get_rep() const
Definition tree.h:96
bool is_tree_code() const
Definition tree.h:92
bool is_builtin_fn() const
Definition tree.h:144
combined_fn safe_as_fn_code() const
Definition tree.h:123
Definition genmatch.cc:1506
Definition wide-int.h:776
hashval_t end() const
Definition inchash.h:49
op_location_t(location_t operator_loc, location_t combined_loc)
Definition tree.h:7003
op_location_t(location_t combined_loc)
Definition tree.h:6997
location_t m_operator_loc
Definition tree.h:6993
location_t m_combined_loc
Definition tree.h:6994
Definition poly-int.h:378
C coeffs[N]
Definition poly-int.h:433
tree * end()
Definition tree.h:4853
tree v
Definition tree.h:4849
tree_vec_range(tree v)
Definition tree.h:4851
tree * begin()
Definition tree.h:4852
unsigned int get_precision() const
Definition tree.h:6562
const_tree m_t
Definition tree.h:6370
extended_tree(const_tree)
Definition tree.h:6554
const_tree get_tree() const
Definition tree.h:6379
extended_tree()
Definition tree.h:6373
const HOST_WIDE_INT * get_val() const
Definition tree.h:6569
unsigned int get_len() const
Definition tree.h:6576
Definition wide-int.h:707
const_tree get_tree() const
Definition tree.h:6354
unextended_tree()
Definition tree.h:6348
unsigned int get_len() const
Definition tree.h:6610
unextended_tree(const_tree t)
Definition tree.h:6349
unsigned int get_precision() const
Definition tree.h:6598
const HOST_WIDE_INT * get_val() const
Definition tree.h:6604
const_tree m_t
Definition tree.h:6345
static wide_int from(const wide_int_ref &, unsigned int, signop)
Definition wide-int.h:1289
struct rtx_def * rtx
Definition coretypes.h:57
tls_model
Definition coretypes.h:210
excess_precision_type
Definition coretypes.h:465
const union tree_node * const_tree
Definition coretypes.h:98
#define GTY(x)
Definition coretypes.h:41
void(* gt_pointer_operator)(void *, void *, void *)
Definition coretypes.h:488
class bitmap_head * bitmap
Definition coretypes.h:51
union tree_node * tree
Definition coretypes.h:97
void ATTRIBUTE_NORETURN
Definition diagnostic-core.h:76
scalar_int_mode word_mode
Definition emit-rtl.cc:79
void set_decl_rtl(tree t, rtx x)
Definition emit-rtl.cc:1463
tree get_inner_reference(tree exp, poly_int64 *pbitsize, poly_int64 *pbitpos, tree *poffset, machine_mode *pmode, int *punsignedp, int *preversep, int *pvolatilep)
Definition expr.cc:8468
bool complete_ctor_at_level_p(const_tree type, HOST_WIDE_INT num_elts, const_tree last_type)
Definition expr.cc:7347
tree build_personality_function(const char *lang)
Definition expr.cc:14247
uint64_t sanitize_code_type
Definition flag-types.h:355
void copy_warning(location_t to, location_t from)
Definition gcc-diagnostic-spec.cc:206
bool warning_suppressed_at(location_t loc, opt_code opt)
Definition gcc-diagnostic-spec.cc:126
bool suppress_warning_at(location_t loc, opt_code opt, bool supp)
Definition gcc-diagnostic-spec.cc:149
void put_warning_spec_at(location_t loc, unsigned bits)
Definition gcc-diagnostic-spec.cc:185
static vector< name_map > names
Definition gcov.cc:594
static type_p type(options_p *optsp, bool nested)
Definition gengtype-parse.cc:883
static struct token T
Definition gengtype-parse.cc:45
static class line_maps * line_table
Definition genmatch.cc:65
built_in_function
Definition genmatch.cc:1009
combined_fn
Definition genmatch.cc:1020
internal_fn
Definition genmatch.cc:1015
tree_code
Definition genmatch.cc:1002
#define NUM_POLY_INT_COEFFS
Definition genmodes.cc:859
#define N
Definition gensupport.cc:202
bool ggc_marked_p(const void *p)
Definition ggc-page.cc:1681
void suppress_warning(gimple *, opt_code=all_warnings, bool=true) ATTRIBUTE_NONNULL(1)
Definition warning-control.cc:173
bool warning_suppressed_p(const gimple *, opt_code=all_warnings) ATTRIBUTE_NONNULL(1)
Definition warning-control.cc:138
int exact_log2(unsigned HOST_WIDE_INT x)
Definition hwint.cc:75
bool pow2p_hwi(unsigned HOST_WIDE_INT x)
Definition hwint.h:179
#define HOST_WIDE_INT_M1U
Definition hwint.h:72
#define HOST_WIDE_INT_1U
Definition hwint.h:70
bool int_n_enabled_p[NUM_INT_N_ENTS]
Definition tree.cc:291
ALWAYS_INLINE poly_uint16 GET_MODE_PRECISION(machine_mode mode)
Definition machmode.h:710
Definition custom-sarif-properties/state-graphs.h:33
Definition fold-const.cc:4361
void add_expr(const_tree t, inchash::hash &hstate, unsigned int flags)
Definition fold-const.cc:4369
Definition double-int.h:439
precision_type
Definition wide-int.h:387
@ INL_CONST_PRECISION
Definition wide-int.h:398
@ VAR_PRECISION
Definition wide-int.h:394
@ CONST_PRECISION
Definition wide-int.h:402
wide_int min_value(machine_mode, signop)
Definition rtl.h:2364
const poly_int< NUM_POLY_INT_COEFFS, generic_wide_int< unextended_tree > > tree_to_poly_wide_ref
Definition tree.h:6414
tree_to_offset_ref to_offset(const_tree)
Definition tree.h:6507
tree_to_poly_offset_ref to_poly_offset(const_tree)
Definition tree.h:6647
int cmps(const T1 &, const T2 &)
Definition wide-int.h:2444
const generic_wide_int< widest_extended_tree > tree_to_widest_ref
Definition tree.h:6396
UNARY_FUNCTION zext(const T &, unsigned int)
extended_tree< ADDR_MAX_PRECISION > offset_extended_tree
Definition tree.h:6394
tree_to_poly_widest_ref to_poly_widest(const_tree)
Definition tree.h:6630
bool fits_to_tree_p(const T &x, const_tree)
Definition tree.h:6720
const generic_wide_int< wide_int_ref_storage< false, false > > tree_to_wide_ref
Definition tree.h:6399
const generic_wide_int< offset_extended_tree > tree_to_offset_ref
Definition tree.h:6397
hwi_with_prec zero(unsigned int)
Definition wide-int.h:2018
const poly_int< NUM_POLY_INT_COEFFS, generic_wide_int< offset_extended_tree > > tree_to_poly_offset_ref
Definition tree.h:6411
tree_to_widest_ref to_widest(const_tree)
Definition tree.h:6482
rtx_to_poly_wide_ref to_poly_wide(const_rtx, machine_mode)
Definition rtl.h:2409
Ca unsigned int precision
Definition poly-int.h:746
wide_int from_mpz(const_tree, mpz_t, bool)
Definition wide-int.cc:253
bool fits_to_boolean_p(const T &x, const_tree)
Definition tree.h:6711
wide_int max_value(machine_mode, signop)
Definition rtl.h:2372
extended_tree< WIDEST_INT_MAX_PRECISION > widest_extended_tree
Definition tree.h:6393
tree_to_wide_ref to_wide(const_tree)
Definition tree.h:6537
UNARY_FUNCTION sext(const T &, unsigned int)
const poly_int< NUM_POLY_INT_COEFFS, generic_wide_int< widest_extended_tree > > tree_to_poly_widest_ref
Definition tree.h:6408
i
Definition poly-int.h:750
poly_int< NUM_POLY_INT_COEFFS, unsigned HOST_WIDE_INT > poly_uint64
Definition poly-int-types.h:25
poly_int< NUM_POLY_INT_COEFFS, wide_int_ref > poly_wide_int_ref
Definition poly-int-types.h:28
poly_int< NUM_POLY_INT_COEFFS, HOST_WIDE_INT > poly_int64
Definition poly-int-types.h:24
i
Definition poly-int.h:776
Ca const poly_int< N, Cb > & b
Definition poly-int.h:771
Ca & a
Definition poly-int.h:770
signop
Definition signop.h:28
#define PASS_MEM_STAT
Definition statistics.h:54
#define CXX_MEM_STAT_INFO
Definition statistics.h:58
Definition tree-loop-distribution.cc:240
Definition lra-remat.cc:89
Definition genautomata.cc:499
Definition double-int.h:50
Definition hash-traits.h:328
Definition hash-traits.h:321
tree signed_type
Definition tree.h:6796
tree unsigned_type
Definition tree.h:6797
poly_coeff_traits< T >::int_type int_type
Definition poly-int.h:198
Definition hash-map-traits.h:104
Definition hash-map-traits.h:33
static hashval_t hash(tree)
Definition tree.h:6061
static bool equal(tree_decl_map *a, tree_decl_map *b)
Definition tree.h:6015
static hashval_t hash(tree_decl_map *m)
Definition tree.h:6013
static int keep_cache_entry(tree_decl_map *&m)
Definition tree.h:6021
static hashval_t hash(tree)
Definition tree.h:6099
Definition tree-core.h:1582
static hashval_t hash(tree)
Definition tree.h:6087
static hashval_t hash(tree)
Definition tree.h:6073
static hashval_t hash(tree_vec_map *m)
Definition tree.h:6037
static bool equal(tree_vec_map *a, tree_vec_map *b)
Definition tree.h:6040
static int keep_cache_entry(tree_vec_map *&m)
Definition tree.h:6046
Definition gengtype.h:252
static const bool is_sign_extended
Definition tree.h:6388
static const unsigned int precision
Definition tree.h:6390
static const bool needs_write_val_arg
Definition tree.h:6389
static const bool host_dependent_precision
Definition tree.h:6387
static enum precision_type precision_type
Definition tree.h:6386
static enum precision_type precision_type
Definition tree.h:6360
static const bool is_sign_extended
Definition tree.h:6362
static const bool needs_write_val_arg
Definition tree.h:6363
static const bool host_dependent_precision
Definition tree.h:6361
Definition wide-int.h:427
generic_wide_int< extended_tree< N > > extended
Definition tree.h:6430
static extended zero(const extended &)
static extended zero(const extended &)
generic_wide_int< extended_tree< N > > extended
Definition tree.h:6423
generic_wide_int< unextended_tree > unextended
Definition tree.h:6437
static unextended zero(const unextended &)
Definition wide-int.h:2043
static int zero(const T &)
Definition wide-int.h:2044
#define NULL
Definition system.h:50
#define gcc_assert(EXPR)
Definition system.h:814
#define gcc_unreachable()
Definition system.h:841
#define true
Definition system.h:887
#define WARN_UNUSED_RESULT
Definition system.h:833
#define CONST_CAST_TREE(X)
Definition system.h:1194
#define CONST_CAST(TYPE, X)
Definition system.h:1193
#define STATIC_ASSERT(X)
Definition system.h:864
#define DEBUG_FUNCTION
Definition system.h:1236
#define gcc_checking_assert(EXPR)
Definition system.h:821
tree(* walk_tree_fn)(tree *, int *, void *)
Definition tree-core.h:1096
@ END_BUILTINS
Definition tree-core.h:3549
omp_clause_code
Definition tree-core.h:257
built_in_class
Definition tree-core.h:172
@ NOT_BUILT_IN
Definition tree-core.h:173
@ BUILT_IN_FRONTEND
Definition tree-core.h:174
@ BUILT_IN_NORMAL
Definition tree-core.h:176
@ BUILT_IN_MD
Definition tree-core.h:175
tree_code_class
Definition tree-core.h:233
@ tcc_comparison
Definition tree-core.h:240
@ tcc_expression
Definition tree-core.h:247
@ tcc_type
Definition tree-core.h:237
tree_node_structure_enum
Definition tree-core.h:605
unsigned short priority_type
Definition tree-core.h:1093
clobber_kind
Definition tree-core.h:1065
@ CLOBBER_UNDEF
Definition tree-core.h:1067
#define NUM_TREE_CODES
Definition tree-core.h:163
@ MAX_TREE_CODES
Definition tree-core.h:156
tree(* walk_tree_lh)(tree *, int *, tree(*)(tree *, int *, void *), void *, hash_set< tree > *)
Definition tree-core.h:1099
int suppress_location_wrappers
Definition tree.cc:14949
bool disjoint_version_decls(tree fn1, tree fn2)
Definition tree.cc:15515
string_slice get_target_version(const tree decl)
Definition tree.cc:15493
tree arg_size_in_bytes(const_tree type)
Definition tree.cc:15108
poly_int64 tree_to_poly_int64(const_tree t)
Definition tree.cc:3449
bool tree_fits_poly_int64_p(const_tree t)
Definition tree.cc:6599
bool flexible_array_type_p(const_tree type)
Definition tree.cc:15066
tree get_attr_nonstring_decl(tree expr, tree *ref)
Definition tree.cc:15390
bool tree_fits_uhwi_p(const_tree t)
Definition tree.cc:6618
unsigned const char omp_clause_num_ops[]
Definition tree.cc:297
tree build_zero_cst(tree type)
Definition tree.cc:2778
bool default_is_empty_record(const_tree type)
Definition tree.cc:15048
bool tree_fits_shwi_p(const_tree t)
Definition tree.cc:6588
bool nonnull_arg_p(const_tree arg)
Definition tree.cc:14804
auto_vec< string_slice > get_clone_attr_versions(const tree arglist, int *default_count, bool filter)
Definition tree.cc:15445
location_t set_block(location_t loc, tree block)
Definition tree.cc:14867
bool expr_type_first_operand_type_p(tree_code code)
Definition tree.cc:15117
const builtin_structptr_type builtin_structptr_types[6]
Definition tree.cc:15198
auto_vec< string_slice > get_clone_versions(const tree decl, int *default_count, bool filter)
Definition tree.cc:15479
HOST_WIDE_INT arg_int_size_in_bytes(const_tree type)
Definition tree.cc:15100
bool diagnose_versioned_decls(tree old_decl, tree new_decl)
Definition tree.cc:15637
bool is_empty_type(const_tree type)
Definition tree.cc:15026
bool tree_fits_poly_uint64_p(const_tree t)
Definition tree.cc:6629
location_t set_source_range(tree expr, location_t start, location_t finish)
Definition tree.cc:14877
unsigned HOST_WIDE_INT tree_to_uhwi(const_tree t)
Definition tree.cc:6672
struct int_n_trees_t int_n_trees[NUM_INT_N_ENTS]
Definition tree.cc:292
bool tree_contains_struct[MAX_TREE_CODES][64]
Definition tree.cc:294
poly_uint64 tree_to_poly_uint64(const_tree t)
Definition tree.cc:3458
sanitize_code_type tree_to_sanitize_code_type(const_tree t)
Definition tree.cc:6683
unsigned fndecl_dealloc_argno(tree fndecl)
Definition tree.cc:15328
HOST_WIDE_INT int_size_in_bytes(const_tree)
Definition tree.cc:3750
void decl_value_expr_insert(tree, tree)
Definition tree.cc:6123
int suppress_location_wrappers
Definition tree.cc:14949
void overwrite_decl_assembler_name(tree decl, tree name)
Definition tree.cc:858
void get_type_static_bounds(const_tree, mpz_t, mpz_t)
Definition tree.cc:8487
bool check_lang_type(const_tree cand, const_tree base)
Definition tree.cc:5676
special_array_member component_ref_sam_type(tree)
Definition tree.cc:13391
bool type_list_equal(const_tree, const_tree)
Definition tree.cc:6492
void build_common_tree_nodes(bool)
Definition tree.cc:9606
#define TYPE_NAME(NODE)
Definition tree.h:2363
bool is_lang_specific(const_tree t)
Definition tree.h:6139
tree strip_array_types(tree type)
Definition tree.h:5108
tree build_pointer_type(tree)
Definition tree.cc:7229
tree function_args_iter_cond(function_args_iterator *i)
Definition tree.h:5610
tree wide_int_to_tree(tree type, const poly_wide_int_ref &cst)
Definition tree.cc:2001
#define TREE_VALUE(NODE)
Definition tree.h:1241
poly_uint64 bit_field_offset(const_tree t)
Definition tree.h:5797
tree build4(enum tree_code, tree, tree, tree, tree, tree CXX_MEM_STAT_INFO)
tree build_vl_exp(enum tree_code, int CXX_MEM_STAT_INFO)
tree make_anon_name()
Definition tree.cc:9046
tree build3(enum tree_code, tree, tree, tree, tree CXX_MEM_STAT_INFO)
tree build_bitint_type(unsigned HOST_WIDE_INT, int)
Definition tree.cc:7387
tree build_constructor_from_vec(tree, const vec< tree, va_gc > *)
Definition tree.cc:2441
#define COMPLETE_TYPE_P(NODE)
Definition tree.h:709
unsigned int element_precision(const_tree)
Definition tree.cc:6997
const char * get_name(tree)
Definition tree.cc:12002
#define DECL_CONTEXT(NODE)
Definition tree.h:2850
bool operation_can_overflow(enum tree_code)
Definition tree.cc:7088
int allocate_decl_uid(void)
Definition tree.cc:1305
enum tree_code tree_code_for_canonical_type_merging(enum tree_code code)
Definition tree.h:5956
tree build_pointer_type_for_mode(tree, machine_mode, bool)
Definition tree.cc:7165
#define target_option_default_node
Definition tree.h:4740
tree unsigned_type_for(tree)
Definition tree.cc:11401
#define DECL_ORIGINAL_TYPE(NODE)
Definition tree.h:3683
tree num_ending_zeros(const_tree)
Definition tree.cc:11564
tree signed_type_for(tree)
Definition tree.cc:11412
int tree_floor_log2(const_tree)
Definition tree.cc:3172
const char * prefix_for_internal_label(tree label)
Definition tree.cc:833
tree build_int_cst_type(tree, poly_int64)
Definition tree.cc:1658
bool operation_no_trapping_overflow(tree, enum tree_code)
Definition tree.cc:7118
tree make_tree(tree, rtx)
Definition expmed.cc:5385
tree build_block(tree, tree, tree, tree)
Definition tree.cc:5619
unsigned int tree_decl_map_hash(const void *)
Definition tree.cc:5986
tree max_object_size()
Definition tree.cc:15211
poly_uint64 TYPE_VECTOR_SUBPARTS(const_tree node)
Definition tree.h:4365
tree build_vector_type(tree, poly_int64)
Definition tree.cc:10466
#define optimization_default_node
Definition tree.h:4736
#define TREE_READONLY(NODE)
Definition tree.h:948
tree build_function_type_list(tree,...)
Definition tree.cc:7797
tree build_omp_clause(location_t, enum omp_clause_code)
Definition tree.cc:10948
#define DECL_FUNCTION_SPECIFIC_TARGET(NODE)
Definition tree.h:3636
tree build_minus_one_cst(tree)
Definition tree.cc:2737
tree size_in_bytes_loc(location_t, const_tree)
Definition tree.cc:3727
cst_size_error
Definition tree.h:5129
@ cst_size_too_big
Definition tree.h:5133
@ cst_size_not_constant
Definition tree.h:5131
@ cst_size_ok
Definition tree.h:5130
@ cst_size_overflow
Definition tree.h:5134
@ cst_size_negative
Definition tree.h:5132
tree get_containing_scope(const_tree)
Definition tree.cc:8684
tree build_vec_series(tree, tree, tree)
Definition tree.cc:2280
#define call_expr_nargs(NODE)
Definition tree.h:1503
tree build_nonstandard_integer_type(unsigned HOST_WIDE_INT, int)
Definition tree.cc:7323
tree get_narrower(tree, int *)
Definition tree.cc:8277
#define DECL_FIELD_BIT_OFFSET(NODE)
Definition tree.h:3128
tree obj_type_ref_class(const_tree ref, bool=false)
Definition ipa-devirt.cc:1918
bool tree_int_cst_lt(const_tree t1, const_tree t2)
Definition tree.h:6753
tree build1(enum tree_code, tree, tree CXX_MEM_STAT_INFO)
bool real_zerop(const_tree)
Definition tree.cc:3296
built_in_function as_builtin_fn(combined_fn code)
Definition tree.h:55
bool really_constant_p(const_tree)
Definition tree.cc:3408
bool needs_to_live_in_memory(const_tree)
Definition tree.cc:11309
#define TYPE_PRECISION(NODE)
Definition tree.h:2360
tree build_method_type_directly(tree, tree, tree)
Definition tree.cc:7870
bool zerop(const_tree)
Definition tree.cc:2982
#define TREE_INT_CST_NUNITS(NODE)
Definition tree.h:1157
unsigned int vector_cst_encoded_nelts(const_tree t)
Definition tree.h:4777
built_in_function DECL_FUNCTION_CODE(const_tree decl)
Definition tree.h:4440
tree drop_tree_overflow(tree)
Definition tree.cc:13021
#define EXPR_CHECK(T)
Definition tree.h:501
tree build_offset_type(tree, tree)
Definition tree.cc:7946
tree build_alloca_call_expr(tree, unsigned int, HOST_WIDE_INT)
Definition tree.cc:11219
bool integer_all_onesp(const_tree)
Definition tree.cc:3058
#define TREE_OPERAND(NODE, I)
Definition tree.h:1319
tree maybe_build_call_expr_loc(location_t, combined_fn, tree, int,...)
Definition tree.cc:11180
unsigned crc32_unsigned_n(unsigned, unsigned, unsigned)
Definition tree.cc:8984
tree build_varargs_function_type_list(tree,...)
Definition tree.cc:7814
tree build_call_expr_loc_vec(location_t, tree, vec< tree, va_gc > *)
Definition tree.cc:11095
int tree_int_cst_sgn(const_tree)
Definition tree.cc:6704
poly_uint64 bit_field_size(const_tree t)
Definition tree.h:5788
bool poly_int_tree_p(const_tree t, poly_int64 *value)
Definition tree.h:5144
void free_node(tree)
Definition tree.cc:1429
#define DECL_NAME(NODE)
Definition tree.h:2798
bool canonical_type_used_p(const_tree t)
Definition tree.h:5986
tree build_optimization_node(struct gcc_options *opts, struct gcc_options *opts_set)
Definition tree.cc:12194
tree save_expr(tree)
Definition tree.cc:4113
tree build_constructor_from_list(tree, tree)
Definition tree.cc:2421
void protected_set_expr_location(tree, location_t)
Definition tree.cc:5636
const char * get_tree_code_name(enum tree_code)
Definition tree.cc:13002
tree decl_function_context(const_tree)
Definition tree.cc:8708
priority_type decl_init_priority_lookup(tree)
Definition tree.cc:5994
void decl_init_priority_insert(tree, priority_type)
Definition tree.cc:6020
#define IS_EXPR_CODE_CLASS(CLASS)
Definition tree.h:294
void put_warning_spec(tree, unsigned)
Definition warning-control.cc:280
HOST_WIDE_INT max_int_size_in_bytes(const_tree)
Definition tree.cc:3770
tree build_reference_type(tree)
Definition tree.cc:7301
bool tree_invariant_p(tree)
Definition tree.cc:4084
tree tree_last(tree)
Definition tree.cc:3625
void recompute_constructor_flags(tree)
Definition tree.cc:2343
tree byte_position(const_tree)
Definition tree.cc:3813
tree build_vector_from_ctor(tree, const vec< constructor_elt, va_gc > *)
Definition tree.cc:2192
tree signed_or_unsigned_type_for(int, tree)
Definition tree.cc:11349
tree build4_loc(location_t loc, enum tree_code code, tree type, tree arg0, tree arg1, tree arg2, tree arg3 CXX_MEM_STAT_INFO)
Definition tree.h:4903
void decl_fini_priority_insert(tree, priority_type)
Definition tree.cc:6040
bool type_with_interoperable_signedness(const_tree)
Definition tree.cc:13988
tree build_call_valist(tree, tree, int, va_list)
Definition tree.cc:11031
tree build_replicated_int_cst(tree, unsigned, HOST_WIDE_INT)
tree build_truth_vector_type_for_mode(poly_uint64, machine_mode)
Definition tree.cc:10474
void DEBUG_FUNCTION verify_type(const_tree t)
Definition tree.cc:14361
tree build_debug_expr_decl(tree type)
Definition tree.cc:5573
bool block_may_fallthru(const_tree)
Definition tree.cc:12909
int struct_ptr_eq(const void *a, const void *b)
Definition tree.h:5718
bool contains_placeholder_p(const_tree)
Definition tree.cc:4269
#define DECL_FUNCTION_SPECIFIC_OPTIMIZATION(NODE)
Definition tree.h:3641
#define AGGREGATE_TYPE_P(TYPE)
Definition tree.h:694
int tree_map_base_eq(const void *, const void *)
Definition tree.cc:5950
#define sizetype
Definition tree.h:5242
bool maybe_special_function_p(const_tree fndecl)
Definition tree.h:6269
tree * function_args_iter_cond_ptr(function_args_iterator *i)
Definition tree.h:5601
#define TREE_VEC_BEGIN(NODE)
Definition tree.h:1245
tree build_array_type_nelts(tree, poly_uint64)
Definition tree.cc:7617
bool ptrofftype_p(tree type)
Definition tree.h:5758
tree first_call_expr_arg(tree exp, call_expr_arg_iterator *iter)
Definition tree.h:6106
bool address_invariant_p(tree)
Definition tree.cc:4025
void tree_set_block(tree, tree)
Definition tree.cc:11969
combined_fn get_call_combined_fn(const_tree)
Definition tree.cc:8871
enum tree_node_structure_enum tree_node_structure(const_tree)
Definition tree.cc:4229
tree build_case_label(tree, tree, tree)
Definition tree.cc:2899
tree build2_loc(location_t loc, enum tree_code code, tree type, tree arg0, tree arg1 CXX_MEM_STAT_INFO)
Definition tree.h:4883
#define TREE_INT_CST_LOW(NODE)
Definition tree.h:1162
tree build_vector_type_for_mode(tree, machine_mode)
Definition tree.cc:10431
tree builtin_decl_unreachable()
Definition tree.cc:11247
int simple_cst_equal(const_tree, const_tree)
Definition tree.cc:6748
bitmap get_nonnull_args(const_tree)
Definition tree.cc:14971
enum tls_model decl_tls_model(const_tree)
Definition tree.cc:1053
tree array_type_nelts_top(tree)
Definition tree.cc:3870
bool tree_map_base_marked_p(const void *)
Definition tree.cc:5970
bool tree_zero_one_valued_p(tree)
unsigned int tree_int_cst_min_precision(tree, signop)
Definition tree.cc:6720
tree block_ultimate_origin(const_tree)
Definition tree.cc:12262
tree build3_loc(location_t loc, enum tree_code code, tree type, tree arg0, tree arg1, tree arg2 CXX_MEM_STAT_INFO)
Definition tree.h:4893
tree build_variant_type_copy(tree CXX_MEM_STAT_INFO)
#define TREE_OPTIMIZATION(NODE)
Definition tree.h:3713
tree build_nonshared_array_type(tree, tree)
Definition tree.cc:7608
bool warn_deprecated_use(tree, tree)
Definition tree.cc:12663
tree build_empty_stmt(location_t)
Definition tree.cc:10936
bool inlined_function_outer_scope_p(const_tree block)
Definition tree.h:5629
tree build_array_type_1(tree, tree, bool, bool, bool)
Definition tree.cc:7543
poly_int64 tree_to_poly_int64(const_tree) ATTRIBUTE_NONNULL(1) ATTRIBUTE_PURE
Definition tree.cc:3449
void function_args_iter_init(function_args_iterator *i, const_tree fntype)
Definition tree.h:5592
#define tree_decl_map_eq
Definition tree.h:6007
bool tree_fits_uhwi_p(const_tree) ATTRIBUTE_PURE
Definition tree.cc:6618
bool builtin_fn_p(combined_fn code)
Definition tree.h:46
bool commutative_ternary_tree_code(enum tree_code)
Definition genmatch.cc:1074
tree build_function_type_array(tree, int, tree *)
Definition tree.cc:7849
location_t * block_nonartificial_location(tree)
Definition tree.cc:12071
bool type_has_mode_precision_p(const_tree t)
Definition tree.h:6886
bool typedef_variant_p(const_tree type)
Definition tree.h:5708
ATTRIBUTE_WARN_UNUSED_RESULT tree protected_set_expr_location_unshare(tree, location_t)
Definition fold-const.cc:253
bool commutative_tree_code(enum tree_code)
Definition genmatch.cc:1037
bool integer_truep(const_tree)
Definition tree.cc:3135
tree create_artificial_label(location_t)
Definition tree.cc:11986
void assign_assembler_name_if_needed(tree)
Definition tree.cc:947
tree decl_value_expr_lookup(tree)
Definition tree.cc:6109
void function_args_iter_next(function_args_iterator *i)
Definition tree.h:5617
#define TREE_CODE_CLASS(CODE)
Definition tree.h:203
HOST_WIDE_INT int_bit_position(const_tree field)
Definition tree.h:6809
hashval_t struct_ptr_hash(const void *a)
Definition tree.h:5726
bool desired_pro_or_demotion_p(const_tree to_type, const_tree from_type)
Definition tree.h:6860
tree bit_position(const_tree)
Definition tree.cc:3803
bool decl_address_invariant_p(const_tree)
Definition tree.cc:3954
tree build_poly_int_cst(tree, const poly_wide_int_ref &)
Definition tree.cc:1975
unsigned crc32_string(unsigned, const char *)
Definition tree.cc:9014
tree build_tree_list(tree, tree CXX_MEM_STAT_INFO)
#define BLOCK_SOURCE_LOCATION(NODE)
Definition tree.h:2332
constexpr opt_code all_warnings
Definition tree.h:7015
bool real_minus_onep(const_tree)
Definition tree.cc:3355
unsigned HOST_WIDE_INT tree_to_uhwi(const_tree) ATTRIBUTE_NONNULL(1) ATTRIBUTE_PURE
Definition tree.cc:6672
vec< tree, va_gc > ** decl_debug_args_lookup(tree)
Definition tree.cc:6140
tree skip_simple_constant_arithmetic(tree)
Definition tree.cc:4201
void set_decl_tls_model(tree, enum tls_model)
Definition tree.cc:1063
bool valid_constant_size_p(const_tree, cst_size_error *=NULL)
Definition tree.cc:6949
#define DECL_UNCHECKED_FUNCTION_CODE(NODE)
Definition tree.h:2942
tree first_field(const_tree) ATTRIBUTE_NONNULL(1)
Definition tree.cc:3566
bool tree_fits_shwi_p(const_tree) ATTRIBUTE_PURE
Definition tree.cc:6588
void clean_symbol_name(char *)
Definition tree.cc:9026
void SET_TYPE_VECTOR_SUBPARTS(tree node, poly_uint64 subparts)
Definition tree.h:4387
const_tree get_ultimate_context(const_tree)
Definition tree.cc:8692
bool auto_var_p(const_tree)
Definition tree.cc:8516
tree stabilize_reference(tree)
Definition tree.cc:5000
void using_eh_for_cleanups(void)
Definition tree.cc:12988
tree tree_strip_any_location_wrapper(tree exp)
Definition tree.h:4523
tree build_fn_decl(const char *, tree)
Definition tree.cc:5585
bool error_operand_p(const_tree t)
Definition tree.h:4768
tree sign_mask_for(tree)
Definition tree.cc:2849
tree build5_loc(location_t loc, enum tree_code code, tree type, tree arg0, tree arg1, tree arg2, tree arg3, tree arg4 CXX_MEM_STAT_INFO)
Definition tree.h:4913
unsigned int tree_map_hash(const void *)
Definition tree.cc:5978
size_t tree_size(const_tree)
Definition tree.cc:1195
tree lhd_gcc_personality(void)
Definition tree.cc:12472
void set_decl_built_in_function(tree decl, built_in_class fclass, unsigned int fcode)
Definition tree.h:4472
tree vector_cst_elt(const_tree, unsigned int)
Definition tree.cc:10573
bool more_call_expr_args_p(const call_expr_arg_iterator *iter)
Definition tree.h:6122
bool integer_minus_onep(const_tree)
Definition tree.cc:3083
#define IDENTIFIER_LENGTH(NODE)
Definition tree.h:1225
bool tree_fits_sanitize_code_type_p(const_tree) ATTRIBUTE_PURE
Definition tree.cc:6648
bool built_in_function_equal_p(built_in_function name0, built_in_function name1)
Definition tree.h:6894
bool is_truth_type_for(tree, tree)
Definition tree.cc:11425
tree type_argument_type(const_tree, unsigned) ATTRIBUTE_NONNULL(1)
Definition tree.cc:6533
#define TYPE_UNSIGNED(NODE)
Definition tree.h:963
size_t tree_code_size(enum tree_code)
Definition tree.cc:1082
tree build_complex_type(tree, bool named=false)
Definition tree.cc:7992
#define TREE_CODE(NODE)
Definition tree.h:325
tree build_aligned_type(tree, unsigned int)
Definition tree.cc:5870
bool integer_each_onep(const_tree)
Definition tree.cc:3042
tree build_vector_from_val(tree, tree)
Definition tree.cc:2229
bool handled_component_p(const_tree t)
Definition tree.h:5492
#define TYPE_MODE(NODE)
Definition tree.h:2369
tree cache_integer_cst(tree, bool might_duplicate=false)
Definition tree.cc:2016
tree build_function_type(tree, tree, bool=false)
Definition tree.cc:7704
tree build_real_from_int_cst(tree, const_tree)
Definition tree.cc:2576
tree skip_simple_arithmetic(tree)
Definition tree.cc:4154
tree build_each_one_cst(tree)
Definition tree.cc:2669
tree uniform_vector_p(const_tree)
Definition tree.cc:10777
tree array_ref_up_bound(tree)
Definition tree.cc:13144
unsigned crc32_byte(unsigned chksum, char byte)
Definition tree.h:5659
bool integer_zerop(const_tree)
Definition tree.cc:2993
tree build_complex_inf(tree, bool)
Definition tree.cc:2656
tree tree_strip_sign_nop_conversions(tree)
Definition tree.cc:12371
tree decl_comdat_group_id(const_tree)
Definition tree.cc:985
tree build_clobber(tree, enum clobber_kind=CLOBBER_UNDEF)
Definition tree.cc:2475
tree build_string(unsigned, const char *=NULL)
Definition tree.cc:2609
#define TYPE_SIGN(NODE)
Definition tree.h:966
tree build_call_nary(tree, tree, int,...)
Definition tree.cc:11016
bool builtin_decl_declared_p(enum built_in_function fncode)
Definition tree.h:6249
generic_wide_int< wi::extended_tree< WIDEST_INT_MAX_PRECISION *2 > > widest2_int_cst
Definition tree.h:6445
tree component_ref_size(tree, special_array_member *=NULL)
Definition tree.cc:13464
tree make_node(enum tree_code CXX_MEM_STAT_INFO)
void build_common_builtin_nodes(void)
Definition tree.cc:10037
tree build_builtin_unreachable(location_t)
Definition tree.cc:11265
bool array_ref_flexible_size_p(tree, bool *=NULL)
Definition tree.cc:13178
const char * combined_fn_name(combined_fn)
Definition tree.cc:14954
bool truth_value_p(enum tree_code code)
Definition tree.h:5747
int DECL_FE_FUNCTION_CODE(const_tree decl)
Definition tree.h:4462
#define FUNCTION_DECL_DECL_TYPE(NODE)
Definition tree.h:3470
unsigned int tree_ctz(const_tree)
Definition tree.cc:3184
#define EXPR_LOCATION(NODE)
Definition tree.h:1344
int tree_int_cst_sign_bit(const_tree)
Definition tree.cc:6692
source_range get_expr_source_range(tree expr)
Definition tree.h:1369
#define POINTER_TYPE_P(TYPE)
Definition tree.h:701
tree build_vector_a_then_b(tree, unsigned int, tree, tree)
Definition tree.cc:2326
unsigned int tree_map_base_hash(const void *)
Definition tree.cc:5960
bool decl_address_ip_invariant_p(const_tree)
Definition tree.cc:3991
tree get_typenode_from_name(const char *)
Definition tree.cc:15159
#define CAN_HAVE_LOCATION_P(NODE)
Definition tree.h:1366
#define TREE_TARGET_OPTION(NODE)
Definition tree.h:3727
void find_placeholder_in_expr(tree, vec< tree > *)
Definition tree.cc:4471
#define SSA_NAME_VERSION(NODE)
Definition tree.h:2210
tree decl_type_context(const_tree)
Definition tree.cc:8744
#define TYPE_P(NODE)
Definition tree.h:227
location_t tree_inlined_location(tree, bool=true)
Definition tree.cc:12120
bool operand_equal_for_phi_arg_p(const_tree, const_tree)
Definition tree.cc:11552
tree component_ref_field_offset(tree)
Definition tree.cc:13336
hashval_t iterative_hash_expr(const_tree tree, hashval_t seed)
Definition tree.h:5827
tree upper_bound_in_type(tree, tree)
Definition tree.cc:11466
tree generate_internal_label(const char *)
Definition tree.cc:811
tree uniform_integer_cst_p(tree)
Definition tree.cc:10829
void set_decl_section_name(tree, const char *)
Definition tree.cc:1007
const_tree first_const_call_expr_arg(const_tree exp, const_call_expr_arg_iterator *iter)
Definition tree.h:6113
void set_builtin_decl_implicit_p(enum built_in_function fncode, bool implicit_p)
Definition tree.h:6201
tree decl_comdat_group(const_tree)
Definition tree.cc:975
void recompute_tree_invariant_for_addr_expr(tree)
Definition tree.cc:5081
tree strip_float_extensions(tree)
Definition tree.cc:12380
unsigned get_warning_spec(const_tree)
Definition warning-control.cc:271
tree reconstruct_complex_type(tree, tree)
Definition tree.cc:10378
tree staticp(tree)
Definition tree.cc:3883
tree build_range_type(tree, tree, tree)
Definition tree.cc:7468
void tree_cc_finalize(void)
Definition tree.cc:15750
vec< tree, va_gc > ** decl_debug_args_insert(tree)
Definition tree.cc:6158
#define TREE_CHAIN(NODE)
Definition tree.h:512
bool variably_modified_type_p(tree, tree)
Definition tree.cc:8569
bool builtin_decl_implicit_p(enum built_in_function fncode)
Definition tree.h:6237
tree build_all_ones_cst(tree)
Definition tree.cc:2722
bool fndecl_built_in_p(const_tree node)
Definition tree.h:6915
tree build_call_expr_internal_loc_array(location_t, enum internal_fn, tree, int, const tree *)
bool initializer_zerop(const_tree, bool *=NULL)
Definition tree.cc:10604
tree builtin_decl_explicit(enum built_in_function fncode)
Definition tree.h:6157
bool vec_member(const_tree, vec< tree, va_gc > *)
Definition tree.cc:3499
tree strip_zero_offset_components(tree)
Definition tree.cc:12458
#define VL_EXP_CLASS_P(NODE)
Definition tree.h:278
bool stdarg_p(const_tree)
Definition tree.cc:12032
tree build_complex(tree, tree, tree)
Definition tree.cc:2637
location_t tree_nonartificial_location(tree)
Definition tree.cc:12104
tree build_constructor_va(tree, int,...)
Definition tree.cc:2455
bool tree_nop_conversion_p(const_tree, const_tree)
Definition tree.cc:12281
#define IDENTIFIER_POINTER(NODE)
Definition tree.h:1227
tree walk_tree_without_duplicates_1(tree *, walk_tree_fn, void *, walk_tree_lh)
Definition tree.cc:11946
tree value_member(tree, tree)
Definition tree.cc:3470
#define BUILTIN_VALID_P(FNCODE)
Definition tree.h:6145
tree grow_tree_vec(tree v, int CXX_MEM_STAT_INFO)
int type_num_arguments(const_tree)
Definition tree.cc:6512
bool valid_new_delete_pair_p(tree, tree, bool *=NULL)
Definition tree.cc:15238
constexpr opt_code no_warning
Definition tree.h:7013
#define POLY_INT_CST_P(NODE)
Definition tree.h:1167
void dump_tree_statistics(void)
Definition tree.cc:8916
#define TYPE_REVERSE_STORAGE_ORDER(NODE)
Definition tree.h:1108
tree vector_element_bits_tree(const_tree)
Definition tree.cc:13723
tree build_reference_type_for_mode(tree, machine_mode, bool)
Definition tree.cc:7237
#define TREE_STATIC(NODE)
Definition tree.h:773
int tree_int_cst_compare(const_tree t1, const_tree t2)
Definition tree.h:6772
tree builtin_decl_implicit(enum built_in_function fncode)
Definition tree.h:6166
bool integer_nonzerop(const_tree)
Definition tree.cc:3118
void set_call_expr_flags(tree, int)
Definition tree.cc:9966
#define CALL_EXPR_ARG(NODE, I)
Definition tree.h:1502
int DECL_MD_FUNCTION_CODE(const_tree decl)
Definition tree.h:4451
#define ANY_INTEGRAL_TYPE_P(TYPE)
Definition tree.h:623
tree build_opaque_vector_type(tree, poly_int64)
Definition tree.cc:10518
void set_builtin_decl(enum built_in_function fncode, tree decl, bool implicit_p)
Definition tree.h:6186
tree get_binfo_at_offset(tree, poly_int64, tree)
Definition tree.cc:12528
bool ptrdiff_tree_p(const_tree, poly_int64 *)
Definition tree.cc:3425
tree decl_assembler_name(tree)
Definition tree.cc:846
tree build_constructor_single(tree, tree, tree)
Definition tree.cc:2406
tree force_fit_type(tree, const poly_wide_int_ref &, int, bool)
Definition tree.cc:1689
#define TREE_INT_CST_ELT(NODE, I)
Definition tree.h:1161
tree tree_cons(tree, tree, tree CXX_MEM_STAT_INFO)
bool real_onep(const_tree)
Definition tree.cc:3329
bool initializer_each_zero_or_onep(const_tree)
Definition tree.cc:10738
#define DECL_EXTERNAL(NODE)
Definition tree.h:2987
bool builtin_decl_explicit_p(enum built_in_function fncode)
Definition tree.h:6228
tree size_in_bytes(const_tree t)
Definition tree.h:5229
tree build_nonstandard_boolean_type(unsigned HOST_WIDE_INT)
Definition tree.cc:7362
cl_target_option * target_opts_for_fn(const_tree fndecl)
Definition tree.h:6321
bool location_wrapper_p(const_tree exp)
Definition tree.h:4503
machine_mode element_mode(const_tree)
Definition tree.cc:13659
bool real_maybe_zerop(const_tree)
Definition tree.cc:3379
tree last_field(const_tree) ATTRIBUTE_NONNULL(1)
Definition tree.cc:3578
#define TREE_TYPE(NODE)
Definition tree.h:513
tree bitmask_inv_cst_vector_p(tree)
Definition tree.cc:10850
#define VL_EXP_OPERAND_LENGTH(NODE)
Definition tree.h:1326
#define INTEGRAL_TYPE_P(TYPE)
Definition tree.h:614
machine_mode vector_type_mode(const_tree)
Definition tree.cc:13678
bool fndecl_builtin_alloc_p(const_tree node)
Definition tree.h:6954
tree type_hash_canon(unsigned int, tree)
Definition tree.cc:6414
tree build0(enum tree_code, tree CXX_MEM_STAT_INFO)
void copy_decl_built_in_function(tree newdecl, const_tree olddecl)
Definition tree.h:4483
tree build_uniform_cst(tree, tree)
Definition tree.cc:2267
#define DECL_BUILT_IN_CLASS(NODE)
Definition tree.h:3627
tree nreverse(tree)
Definition tree.cc:3638
tree build_call_array_loc(location_t, tree, tree, int, const tree *)
Definition tree.cc:11048
tree array_type_nelts_minus_one(const_tree)
Definition tree.cc:3833
bool reverse_storage_order_for_component_p(tree t)
Definition tree.h:5513
#define TREE_CODE_LENGTH(CODE)
Definition tree.h:302
tree build_zero_cst(tree)
Definition tree.cc:2778
tree purpose_member(const_tree, tree)
Definition tree.cc:3485
bool cst_and_fits_in_hwi(const_tree)
Definition tree.cc:2156
bool int_fits_type_p(const_tree, const_tree) ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_PURE
Definition tree.cc:8388
bool tree_fits_poly_uint64_p(const_tree) ATTRIBUTE_PURE
Definition tree.cc:6629
tree build_int_cst(tree, poly_int64)
Definition tree.cc:1638
unsigned int vector_element_bits(const_tree)
Definition tree.cc:13711
tree build_int_cstu(tree type, poly_uint64)
Definition tree.cc:1650
#define TREE_PUBLIC(NODE)
Definition tree.h:858
bool check_base_type(const_tree cand, const_tree base)
Definition tree.cc:5731
bool storage_order_barrier_p(const_tree t)
Definition tree.h:5551
tree chain_index(int, tree)
Definition tree.cc:3513
bool auto_var_in_fn_p(const_tree, const_tree)
Definition tree.cc:8527
int get_range_pos_neg(tree, gimple *=NULL)
Definition tree.cc:14722
tree build_index_type(tree)
Definition tree.cc:7491
bool associative_tree_code(enum tree_code)
Definition tree.cc:7011
tree build_call_expr_internal_loc(location_t, enum internal_fn, tree, int,...)
Definition tree.cc:11159
tree build_low_bits_mask(tree, unsigned)
Definition tree.cc:2144
tree build_call_expr_loc_array(location_t, tree, int, tree *)
Definition tree.cc:11082
#define TYPE_ARG_TYPES(NODE)
Definition tree.h:2644
bool integer_onep(const_tree)
Definition tree.cc:3017
HOST_WIDE_INT int_cst_value(const_tree)
Definition tree.cc:11321
bool complete_or_array_type_p(const_tree type)
Definition tree.h:5769
tree build_string_literal(unsigned, const char *=NULL, tree=char_type_node, unsigned HOST_WIDE_INT=HOST_WIDE_INT_M1U)
Definition tree.cc:11279
access_mode
Definition tree.h:5995
@ access_deferred
Definition tree.h:6000
@ access_none
Definition tree.h:5996
@ access_read_write
Definition tree.h:5999
@ access_write_only
Definition tree.h:5998
@ access_read_only
Definition tree.h:5997
tree get_qualified_type(tree, int)
Definition tree.cc:5789
wi::tree_to_poly_wide_ref poly_int_cst_value(const_tree x)
Definition tree.h:6618
bool is_access_with_size_p(const_tree)
Definition tree.cc:13635
#define EXPR_LOCATION_WRAPPER_P(NODE)
Definition tree.h:4496
bool internal_fn_p(combined_fn code)
Definition tree.h:64
#define DECL_UID(NODE)
Definition tree.h:2806
HOST_WIDE_INT tree_to_shwi(const_tree) ATTRIBUTE_NONNULL(1) ATTRIBUTE_PURE
Definition tree.cc:6661
unsigned crc32_unsigned(unsigned chksum, unsigned value)
Definition tree.h:5654
tree build_call_vec(tree, tree, const vec< tree, va_gc > *)
Definition tree.cc:11065
void init_ttree(void)
Definition tree.cc:762
tree tree_block(tree)
Definition tree.cc:11958
tree array_ref_low_bound(tree)
Definition tree.cc:13121
void decl_debug_expr_insert(tree, tree)
Definition tree.cc:6096
bool valid_vector_subparts_p(poly_uint64 subparts)
Definition tree.h:4423
tree tree_strip_nop_conversions(tree)
Definition tree.cc:12360
tree build1_loc(location_t loc, enum tree_code code, tree type, tree arg1 CXX_MEM_STAT_INFO)
Definition tree.h:4873
int tree_operand_length(const_tree node)
Definition tree.h:4293
hashval_t type_hash_canon_hash(tree)
Definition tree.cc:6183
bool type_with_alias_set_p(const_tree t)
Definition tree.h:6818
bool check_qualified_type(const_tree, const_tree, int)
Definition tree.cc:5758
tree make_int_cst(int, int CXX_MEM_STAT_INFO)
tree build_call_expr(tree, int,...)
Definition tree.cc:11124
#define REF_REVERSE_STORAGE_ORDER(NODE)
Definition tree.h:1126
bool tree_int_cst_le(const_tree t1, const_tree t2)
Definition tree.h:6762
tree build_distinct_type_copy(tree CXX_MEM_STAT_INFO)
bool types_same_for_odr(const_tree type1, const_tree type2)
Definition ipa-devirt.cc:361
tree build_varargs_function_type_array(tree, int, tree *)
Definition tree.cc:7859
tree build2(enum tree_code, tree, tree, tree CXX_MEM_STAT_INFO)
poly_uint64 tree_to_poly_uint64(const_tree) ATTRIBUTE_NONNULL(1) ATTRIBUTE_PURE
Definition tree.cc:3458
bool prototype_p(const_tree)
Definition tree.cc:12054
#define TREE_HASH(NODE)
Definition tree.h:551
tree copy_list(tree)
Definition tree.cc:1550
tree substitute_placeholder_in_expr(tree, tree)
Definition tree.cc:4737
#define ALLOCA_FUNCTION_CODE_P(FCODE)
Definition tree.h:2946
tree build_call_expr_loc(location_t, tree, int,...)
Definition tree.cc:11107
#define DECL_NONALIASED(NODE)
Definition tree.h:3427
bool trunc_or_exact_div_p(tree_code code)
Definition tree.h:5740
tree build5(enum tree_code, tree, tree, tree, tree, tree, tree CXX_MEM_STAT_INFO)
void prepare_target_option_nodes_for_pch(void)
Definition tree.cc:12251
struct cl_optimization * opts_for_fn(const_tree fndecl)
Definition tree.h:6311
bool type_contains_placeholder_p(tree)
Definition tree.cc:4425
#define VECTOR_CST_NPATTERNS(NODE)
Definition tree.h:1209
bool id_equal(const_tree id, const char *str)
Definition tree.h:4351
special_array_member
Definition tree.h:5913
@ none
Definition tree.h:5914
@ int_0
Definition tree.h:5915
@ trail_0
Definition tree.h:5916
@ trail_n
Definition tree.h:5918
@ trail_1
Definition tree.h:5917
@ int_n
Definition tree.h:5919
#define error_mark_node
Definition tree.h:4531
tree build_nt_call_vec(tree, vec< tree, va_gc > *)
Definition tree.cc:5525
bool fixed_zerop(const_tree)
Definition tree.cc:3148
tree decl_debug_expr_lookup(tree)
Definition tree.cc:6082
const_tree strip_pointer_types(const_tree type)
Definition tree.h:5119
tree build_array_type(tree, tree, bool=false)
Definition tree.cc:7599
#define TREE_VEC_END(NODE)
Definition tree.h:1246
void protected_set_expr_location_if_unset(tree, location_t)
Definition tree.cc:5652
tree build_real_from_wide(tree, const wide_int_ref &, signop)
Definition tree.cc:2591
tree build_decl(location_t, enum tree_code, tree, tree CXX_MEM_STAT_INFO)
tree truth_type_for(tree)
Definition tree.cc:11450
tree substitute_in_expr(tree, tree, tree)
Definition tree.cc:4545
tree get_unwidened(tree, tree)
Definition tree.cc:8193
bool tree_fits_poly_int64_p(const_tree) ATTRIBUTE_PURE
Definition tree.cc:6599
tree build_nt(enum tree_code,...)
Definition tree.cc:5500
tree make_tree_vec(int CXX_MEM_STAT_INFO)
#define TREE_ADDRESSABLE(NODE)
Definition tree.h:745
bool is_typedef_decl(const_tree x)
Definition tree.h:5699
bool subrange_type_for_debug_p(const_tree, tree *, tree *)
Definition tree.cc:7502
#define SET_EXPR_LOCATION(NODE, LOCUS)
Definition tree.h:1346
tree build_method_type(tree, tree)
Definition tree.cc:7932
tree make_vector(unsigned, unsigned CXX_MEM_STAT_INFO)
internal_fn as_internal_fn(combined_fn code)
Definition tree.h:73
WARN_UNUSED_RESULT tree maybe_wrap_with_location(tree, location_t)
Definition tree.cc:14911
int single_nonzero_element(const_tree)
Definition tree.cc:10905
HOST_WIDE_INT int_byte_position(const_tree)
Definition tree.cc:3824
void verify_constructor_flags(tree)
Definition tree.cc:2371
tree copy_node(tree CXX_MEM_STAT_INFO)
void error_unavailable_use(tree, tree)
Definition tree.cc:12750
bool chain_member(const_tree, const_tree)
Definition tree.cc:3523
bool using_eh_for_cleanups_p(void)
Definition tree.cc:12995
#define DECL_FIELD_OFFSET(NODE)
Definition tree.h:3122
#define VECTOR_CST_NELTS_PER_PATTERN(NODE)
Definition tree.h:1211
bool integer_pow2p(const_tree)
Definition tree.cc:3098
combined_fn as_combined_fn(built_in_function fn)
Definition tree.h:30
void set_function_decl_type(tree decl, function_decl_type t, bool set)
Definition tree.h:3477
vec< tree, va_gc > * ctor_to_vec(tree)
Definition tree.cc:3707
#define NULL_TREE
Definition tree.h:318
bool gimple_canonical_types_compatible_p(const_tree, const_tree, bool trust_type_canonical=true)
Definition tree.cc:14009
tree make_tree_binfo(unsigned CXX_MEM_STAT_INFO)
tree lower_bound_in_type(tree, tree)
Definition tree.cc:11519
tree get_base_address(tree t)
Definition tree.cc:13074
tree get_file_function_name(const char *)
Definition tree.cc:9081
priority_type decl_fini_priority_lookup(tree)
Definition tree.cc:6007
tree get_callee_fndecl(const_tree)
Definition tree.cc:8781
const_tree strip_invariant_refs(const_tree)
Definition tree.cc:12428
int list_length(const_tree)
Definition tree.cc:3540
tree build_translation_unit_decl(tree)
Definition tree.cc:5604
tree build_nonshared_range_type(tree, tree, tree)
Definition tree.cc:7476
tree double_int_to_tree(tree, double_int)
Definition tree.cc:1668
tree build_tree_list_vec(const vec< tree, va_gc > *CXX_MEM_STAT_INFO)
#define POLY_INT_CST_COEFF(NODE, I)
Definition tree.h:1171
#define VECTOR_TYPE_P(TYPE)
Definition tree.h:602
int tree_log2(const_tree)
Definition tree.cc:3160
int compare_tree_int(const_tree, unsigned HOST_WIDE_INT)
Definition tree.cc:6928
tree build_index_vector(tree, poly_uint64, poly_uint64)
Definition tree.cc:2304
tree get_ref_from_access_with_size(tree)
Definition tree.cc:13647
void set_builtin_decl_declared_p(enum built_in_function fncode, bool declared_p)
Definition tree.h:6214
tree build_target_option_node(struct gcc_options *opts, struct gcc_options *opts_set)
Definition tree.cc:12222
tree build_qualified_type(tree, int CXX_MEM_STAT_INFO)
bool is_global_var(const_tree t)
Definition tree.h:6287
#define TREE_INT_CST_EXT_NUNITS(NODE)
Definition tree.h:1159
tree build_constructor(tree, vec< constructor_elt, va_gc > *CXX_MEM_STAT_INFO)
tree array_ref_element_size(tree)
Definition tree.cc:13093
#define TYPE_UID(NODE)
Definition tree.h:2350
#define char_type_node
Definition tree.h:4753
#define TREE_OPERAND_LENGTH(NODE)
Definition tree.h:1318
tree chainon(tree, tree)
Definition tree.cc:3598
const char * decl_section_name(const_tree)
Definition tree.cc:996
tree build_one_cst(tree)
Definition tree.cc:2684
tree walk_tree_1(tree *, walk_tree_fn, void *, hash_set< tree > *, walk_tree_lh)
Definition tree.cc:11666
bool virtual_method_call_p(const_tree, bool=false)
Definition tree.cc:12488
bool has_warning_spec(const_tree)
Definition warning-control.cc:262
bool tree_int_cst_equal(const_tree, const_tree)
Definition tree.cc:6565
bool contains_bitfld_component_ref_p(const_tree)
Definition tree.cc:12824
bool may_be_aliased(const_tree var)
Definition tree.h:6297
#define WIDEST_INT_MAX_PRECISION
Definition wide-int.h:257
generic_wide_int< wide_int_ref_storage< false > > wide_int_ref
Definition wide-int.h:353
#define OFFSET_INT_ELTS
Definition wide-int.h:281
#define ADDR_MAX_PRECISION
Definition wide-int.h:276
generic_wide_int< wide_int_storage > wide_int
Definition wide-int.h:343
const T2 & y
Definition wide-int.h:3870