X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Fgimple.h;h=7f0755155311bd49c839d9ef2db3ebd181bcfa70;hb=07d9744116e63d0500d9d0b2868850123e4dd78b;hp=87309b694d40899b826d9727e4aa3f49530f4f0b;hpb=66bd377c8bbc3148d3b640a27be40d60b7754fa1;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/gimple.h b/gcc/gimple.h index 87309b694d4..7f075515531 100644 --- a/gcc/gimple.h +++ b/gcc/gimple.h @@ -1,6 +1,6 @@ /* Gimple IR definitions. - Copyright 2007, 2008, 2009 Free Software Foundation, Inc. + Copyright 2007, 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc. Contributed by Aldy Hernandez This file is part of GCC. @@ -24,23 +24,17 @@ along with GCC; see the file COPYING3. If not see #include "pointer-set.h" #include "vec.h" +#include "vecprim.h" +#include "vecir.h" #include "ggc.h" -#include "tm.h" -#include "hard-reg-set.h" #include "basic-block.h" #include "tree-ssa-operands.h" +#include "tree-ssa-alias.h" +#include "internal-fn.h" -DEF_VEC_P(gimple); -DEF_VEC_ALLOC_P(gimple,heap); -DEF_VEC_ALLOC_P(gimple,gc); - -typedef gimple *gimple_p; -DEF_VEC_P(gimple_p); -DEF_VEC_ALLOC_P(gimple_p,heap); - -DEF_VEC_P(gimple_seq); -DEF_VEC_ALLOC_P(gimple_seq,gc); -DEF_VEC_ALLOC_P(gimple_seq,heap); +struct gimple_seq_node_d; +typedef struct gimple_seq_node_d *gimple_seq_node; +typedef const struct gimple_seq_node_d *const_gimple_seq_node; /* For each block, the PHI nodes that need to be rewritten are stored into these vectors. */ @@ -60,6 +54,7 @@ extern const unsigned char gimple_rhs_class_table[]; /* Error out if a gimple tuple is addressed incorrectly. */ #if defined ENABLE_GIMPLE_CHECKING +#define gcc_gimple_checking_assert(EXPR) gcc_assert (EXPR) extern void gimple_check_failed (const_gimple, const char *, int, \ const char *, enum gimple_code, \ enum tree_code) ATTRIBUTE_NORETURN; @@ -72,6 +67,7 @@ extern void gimple_check_failed (const_gimple, const char *, int, \ (CODE), ERROR_MARK); \ } while (0) #else /* not ENABLE_GIMPLE_CHECKING */ +#define gcc_gimple_checking_assert(EXPR) ((void)(0 && (EXPR))) #define GIMPLE_CHECK(GS, CODE) (void)0 #endif @@ -80,6 +76,7 @@ extern void gimple_check_failed (const_gimple, const char *, int, \ enum gimple_rhs_class { GIMPLE_INVALID_RHS, /* The expression cannot be used on the RHS. */ + GIMPLE_TERNARY_RHS, /* The expression is a ternary operation. */ GIMPLE_BINARY_RHS, /* The expression is a binary operation. */ GIMPLE_UNARY_RHS, /* The expression is a unary operation. */ GIMPLE_SINGLE_RHS /* The expression is a single object (an SSA @@ -100,11 +97,13 @@ enum gimple_rhs_class enum gf_mask { GF_ASM_INPUT = 1 << 0, GF_ASM_VOLATILE = 1 << 1, - GF_CALL_CANNOT_INLINE = 1 << 0, - GF_CALL_FROM_THUNK = 1 << 1, - GF_CALL_RETURN_SLOT_OPT = 1 << 2, - GF_CALL_TAILCALL = 1 << 3, - GF_CALL_VA_ARG_PACK = 1 << 4, + GF_CALL_FROM_THUNK = 1 << 0, + GF_CALL_RETURN_SLOT_OPT = 1 << 1, + GF_CALL_TAILCALL = 1 << 2, + GF_CALL_VA_ARG_PACK = 1 << 3, + GF_CALL_NOTHROW = 1 << 4, + GF_CALL_ALLOCA_FOR_VAR = 1 << 5, + GF_CALL_INTERNAL = 1 << 6, GF_OMP_PARALLEL_COMBINED = 1 << 0, /* True on an GIMPLE_OMP_RETURN statement if the return does not require @@ -114,15 +113,17 @@ enum gf_mask { GF_OMP_RETURN_NOWAIT = 1 << 0, GF_OMP_SECTION_LAST = 1 << 0, + GF_OMP_ATOMIC_NEED_VALUE = 1 << 0, GF_PREDICT_TAKEN = 1 << 15 }; -/* Currently, there's only one type of gimple debug stmt. Others are +/* Currently, there are only two types of gimple debug stmt. Others are envisioned, for example, to enable the generation of is_stmt notes in line number information, to mark sequence points, etc. This subcode is to be used to tell them apart. */ enum gimple_debug_subcode { - GIMPLE_DEBUG_BIND = 0 + GIMPLE_DEBUG_BIND = 0, + GIMPLE_DEBUG_SOURCE_BIND = 1 }; /* Masks for selecting a pass local flag (PLF) to work on. These @@ -220,6 +221,13 @@ gimple_seq_empty_p (const_gimple_seq s) void gimple_seq_add_stmt (gimple_seq *, gimple); +/* Link gimple statement GS to the end of the sequence *SEQ_P. If + *SEQ_P is NULL, a new sequence is allocated. This function is + similar to gimple_seq_add_stmt, but does not scan the operands. + During gimplification, we need to manipulate statement sequences + before the def/use vectors have been constructed. */ +void gimple_seq_add_stmt_without_update (gimple_seq *, gimple); + /* Allocate a new sequence and initialize its first element with STMT. */ static inline gimple_seq @@ -245,7 +253,7 @@ bb_seq (const_basic_block bb) static inline void set_bb_seq (basic_block bb, gimple_seq seq) { - gcc_assert (!(bb->flags & BB_RTL)); + gcc_checking_assert (!(bb->flags & BB_RTL)); bb->il.gimple->seq = seq; } @@ -297,9 +305,6 @@ struct GTY(()) gimple_statement_base { /* Nonzero if this statement contains volatile operands. */ unsigned has_volatile_ops : 1; - /* Padding to get subcode to 16 bit alignment. */ - unsigned pad : 1; - /* The SUBCODE field can be used for tuple-specific flags for tuples that do not require subcodes. Note that SUBCODE should be at least as wide as tree codes, as several tuples store tree codes @@ -390,6 +395,31 @@ struct GTY(()) gimple_statement_with_memory_ops }; +/* Call statements that take both memory and register operands. */ + +struct GTY(()) gimple_statement_call +{ + /* [ WORD 1-8 ] */ + struct gimple_statement_with_memory_ops_base membase; + + /* [ WORD 9-12 ] */ + struct pt_solution call_used; + struct pt_solution call_clobbered; + + /* [ WORD 13 ] */ + union GTY ((desc ("%1.membase.opbase.gsbase.subcode & GF_CALL_INTERNAL"))) { + tree GTY ((tag ("0"))) fntype; + enum internal_fn GTY ((tag ("GF_CALL_INTERNAL"))) internal_fn; + } u; + + /* [ WORD 14 ] + Operand vector. NOTE! This must always be the last field + of this structure. In particular, this means that this + structure cannot be embedded inside another one. */ + tree GTY((length ("%h.membase.opbase.gsbase.num_ops"))) op[1]; +}; + + /* OpenMP statements (#pragma omp). */ struct GTY(()) gimple_statement_omp { @@ -453,6 +483,15 @@ struct GTY(()) gimple_statement_eh_filter { gimple_seq failure; }; +/* GIMPLE_EH_ELSE */ + +struct GTY(()) gimple_statement_eh_else { + /* [ WORD 1-4 ] */ + struct gimple_statement_base gsbase; + + /* [ WORD 5,6 ] */ + gimple_seq n_body, e_body; +}; /* GIMPLE_EH_MUST_NOT_THROW */ @@ -584,13 +623,13 @@ struct GTY(()) gimple_omp_for_iter { /* Index variable. */ tree index; - + /* Initial value. */ tree initial; /* Final value. */ tree final; - + /* Increment. */ tree incr; }; @@ -700,7 +739,7 @@ struct GTY(()) gimple_statement_omp_single { }; -/* GIMPLE_OMP_ATOMIC_LOAD. +/* GIMPLE_OMP_ATOMIC_LOAD. Note: This is based on gimple_statement_base, not g_s_omp, because g_s_omp contains a sequence, which we don't need here. */ @@ -723,6 +762,43 @@ struct GTY(()) gimple_statement_omp_atomic_store { tree val; }; +/* GIMPLE_TRANSACTION. */ + +/* Bits to be stored in the GIMPLE_TRANSACTION subcode. */ + +/* The __transaction_atomic was declared [[outer]] or it is + __transaction_relaxed. */ +#define GTMA_IS_OUTER (1u << 0) +#define GTMA_IS_RELAXED (1u << 1) +#define GTMA_DECLARATION_MASK (GTMA_IS_OUTER | GTMA_IS_RELAXED) + +/* The transaction is seen to not have an abort. */ +#define GTMA_HAVE_ABORT (1u << 2) +/* The transaction is seen to have loads or stores. */ +#define GTMA_HAVE_LOAD (1u << 3) +#define GTMA_HAVE_STORE (1u << 4) +/* The transaction MAY enter serial irrevocable mode in its dynamic scope. */ +#define GTMA_MAY_ENTER_IRREVOCABLE (1u << 5) +/* The transaction WILL enter serial irrevocable mode. + An irrevocable block post-dominates the entire transaction, such + that all invocations of the transaction will go serial-irrevocable. + In such case, we don't bother instrumenting the transaction, and + tell the runtime that it should begin the transaction in + serial-irrevocable mode. */ +#define GTMA_DOES_GO_IRREVOCABLE (1u << 6) + +struct GTY(()) gimple_statement_transaction +{ + /* [ WORD 1-10 ] */ + struct gimple_statement_with_memory_ops_base gsbase; + + /* [ WORD 11 ] */ + gimple_seq body; + + /* [ WORD 12 ] */ + tree label; +}; + #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) SYM, enum gimple_statement_structure_enum { #include "gsstruct.def" @@ -734,15 +810,18 @@ enum gimple_statement_structure_enum { /* Define the overall contents of a gimple tuple. It may be any of the structures declared above for various types of tuples. */ -union GTY ((desc ("gimple_statement_structure (&%h)"))) gimple_statement_d { +union GTY ((desc ("gimple_statement_structure (&%h)"), variable_size)) gimple_statement_d { struct gimple_statement_base GTY ((tag ("GSS_BASE"))) gsbase; struct gimple_statement_with_ops GTY ((tag ("GSS_WITH_OPS"))) gsops; + struct gimple_statement_with_memory_ops_base GTY ((tag ("GSS_WITH_MEM_OPS_BASE"))) gsmembase; struct gimple_statement_with_memory_ops GTY ((tag ("GSS_WITH_MEM_OPS"))) gsmem; + struct gimple_statement_call GTY ((tag ("GSS_CALL"))) gimple_call; struct gimple_statement_omp GTY ((tag ("GSS_OMP"))) omp; struct gimple_statement_bind GTY ((tag ("GSS_BIND"))) gimple_bind; struct gimple_statement_catch GTY ((tag ("GSS_CATCH"))) gimple_catch; struct gimple_statement_eh_filter GTY ((tag ("GSS_EH_FILTER"))) gimple_eh_filter; struct gimple_statement_eh_mnt GTY ((tag ("GSS_EH_MNT"))) gimple_eh_mnt; + struct gimple_statement_eh_else GTY ((tag ("GSS_EH_ELSE"))) gimple_eh_else; struct gimple_statement_phi GTY ((tag ("GSS_PHI"))) gimple_phi; struct gimple_statement_eh_ctrl GTY ((tag ("GSS_EH_CTRL"))) gimple_eh_ctrl; struct gimple_statement_try GTY ((tag ("GSS_TRY"))) gimple_try; @@ -757,6 +836,7 @@ union GTY ((desc ("gimple_statement_structure (&%h)"))) gimple_statement_d { struct gimple_statement_omp_continue GTY ((tag ("GSS_OMP_CONTINUE"))) gimple_omp_continue; struct gimple_statement_omp_atomic_load GTY ((tag ("GSS_OMP_ATOMIC_LOAD"))) gimple_omp_atomic_load; struct gimple_statement_omp_atomic_store GTY ((tag ("GSS_OMP_ATOMIC_STORE"))) gimple_omp_atomic_store; + struct gimple_statement_transaction GTY((tag ("GSS_TRANSACTION"))) gimple_transaction; }; /* In gimple.c. */ @@ -768,24 +848,36 @@ extern size_t const gimple_ops_offset_[]; /* Map GIMPLE codes to GSS codes. */ extern enum gimple_statement_structure_enum const gss_for_code_[]; +/* This variable holds the currently expanded gimple statement for purposes + of comminucating the profile info to the builtin expanders. */ +extern gimple currently_expanding_gimple_stmt; + gimple gimple_build_return (tree); gimple gimple_build_assign_stat (tree, tree MEM_STAT_DECL); #define gimple_build_assign(l,r) gimple_build_assign_stat (l, r MEM_STAT_INFO) -void extract_ops_from_tree (tree, enum tree_code *, tree *, tree *); +void extract_ops_from_tree_1 (tree, enum tree_code *, tree *, tree *, tree *); gimple gimple_build_assign_with_ops_stat (enum tree_code, tree, tree, - tree MEM_STAT_DECL); -#define gimple_build_assign_with_ops(c,o1,o2,o3) \ - gimple_build_assign_with_ops_stat (c, o1, o2, o3 MEM_STAT_INFO) + tree, tree MEM_STAT_DECL); +#define gimple_build_assign_with_ops(c,o1,o2,o3) \ + gimple_build_assign_with_ops_stat (c, o1, o2, o3, NULL_TREE MEM_STAT_INFO) +#define gimple_build_assign_with_ops3(c,o1,o2,o3,o4) \ + gimple_build_assign_with_ops_stat (c, o1, o2, o3, o4 MEM_STAT_INFO) gimple gimple_build_debug_bind_stat (tree, tree, gimple MEM_STAT_DECL); #define gimple_build_debug_bind(var,val,stmt) \ gimple_build_debug_bind_stat ((var), (val), (stmt) MEM_STAT_INFO) +gimple gimple_build_debug_source_bind_stat (tree, tree, gimple MEM_STAT_DECL); +#define gimple_build_debug_source_bind(var,val,stmt) \ + gimple_build_debug_source_bind_stat ((var), (val), (stmt) MEM_STAT_INFO) gimple gimple_build_call_vec (tree, VEC(tree, heap) *); gimple gimple_build_call (tree, unsigned, ...); +gimple gimple_build_call_valist (tree, unsigned, va_list); +gimple gimple_build_call_internal (enum internal_fn, unsigned, ...); +gimple gimple_build_call_internal_vec (enum internal_fn, VEC(tree, heap) *); gimple gimple_build_call_from_tree (tree); gimple gimplify_assign (tree, tree, gimple_seq *); gimple gimple_build_cond (enum tree_code, tree, tree, tree, tree); @@ -798,6 +890,7 @@ gimple gimple_build_asm_vec (const char *, VEC(tree,gc) *, VEC(tree,gc) *, gimple gimple_build_catch (tree, gimple_seq); gimple gimple_build_eh_filter (tree, gimple_seq); gimple gimple_build_eh_must_not_throw (tree); +gimple gimple_build_eh_else (gimple_seq, gimple_seq); gimple gimple_build_try (gimple_seq, gimple_seq, enum gimple_try_flags); gimple gimple_build_wce (gimple_seq); gimple gimple_build_resx (int); @@ -820,6 +913,7 @@ gimple gimple_build_omp_single (gimple_seq, tree); gimple gimple_build_cdt (tree, tree); gimple gimple_build_omp_atomic_load (tree, tree); gimple gimple_build_omp_atomic_store (tree); +gimple gimple_build_transaction (gimple_seq, tree); gimple gimple_build_predict (enum br_predictor, enum prediction); enum gimple_statement_structure_enum gss_for_assign (enum tree_code); void sort_case_labels (VEC(tree,heap) *); @@ -830,27 +924,29 @@ gimple_seq gimple_seq_alloc (void); void gimple_seq_free (gimple_seq); void gimple_seq_add_seq (gimple_seq *, gimple_seq); gimple_seq gimple_seq_copy (gimple_seq); +bool gimple_call_same_target_p (const_gimple, const_gimple); int gimple_call_flags (const_gimple); +int gimple_call_return_flags (const_gimple); +int gimple_call_arg_flags (const_gimple, unsigned); +void gimple_call_reset_alias_info (gimple); bool gimple_assign_copy_p (gimple); bool gimple_assign_ssa_name_copy_p (gimple); -bool gimple_assign_single_p (gimple); bool gimple_assign_unary_nop_p (gimple); void gimple_set_bb (gimple, struct basic_block_def *); -tree gimple_fold (const_gimple); void gimple_assign_set_rhs_from_tree (gimple_stmt_iterator *, tree); -void gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *, enum tree_code, - tree, tree); +void gimple_assign_set_rhs_with_ops_1 (gimple_stmt_iterator *, enum tree_code, + tree, tree, tree); tree gimple_get_lhs (const_gimple); void gimple_set_lhs (gimple, tree); +void gimple_replace_lhs (gimple, tree); gimple gimple_copy (gimple); -bool is_gimple_operand (const_tree); void gimple_set_modified (gimple, bool); void gimple_cond_get_ops_from_tree (tree, enum tree_code *, tree *, tree *); gimple gimple_build_cond_from_tree (tree, tree, tree); void gimple_cond_set_condition_from_tree (gimple, tree); bool gimple_has_side_effects (const_gimple); -bool gimple_rhs_has_side_effects (const_gimple); bool gimple_could_trap_p (gimple); +bool gimple_could_trap_p_1 (gimple, bool, bool); bool gimple_assign_rhs_could_trap_p (gimple); void gimple_regimplify_operands (gimple, gimple_stmt_iterator *); bool empty_body_p (gimple_seq); @@ -858,13 +954,12 @@ unsigned get_gimple_rhs_num_ops (enum tree_code); #define gimple_alloc(c, n) gimple_alloc_stat (c, n MEM_STAT_INFO) gimple gimple_alloc_stat (enum gimple_code, unsigned MEM_STAT_DECL); const char *gimple_decl_printable_name (tree, int); -tree gimple_fold_obj_type_ref (tree, tree); - +tree gimple_get_virt_method_for_binfo (HOST_WIDE_INT, tree); +void gimple_adjust_this_by_delta (gimple_stmt_iterator *, tree); +tree gimple_extract_devirt_binfo_from_cst (tree); /* Returns true iff T is a valid GIMPLE statement. */ extern bool is_gimple_stmt (tree); -/* Returns true iff TYPE is a valid type for a scalar register variable. */ -extern bool is_gimple_reg_type (tree); /* Returns true iff T is a scalar register variable. */ extern bool is_gimple_reg (tree); /* Returns true iff T is any sort of variable. */ @@ -895,6 +990,8 @@ extern bool is_gimple_ip_invariant (const_tree); extern bool is_gimple_val (tree); /* Returns true iff T is a GIMPLE asm statement input. */ extern bool is_gimple_asm_val (tree); +/* Returns true iff T is a valid address operand of a MEM_REF. */ +bool is_gimple_mem_ref_addr (tree); /* Returns true iff T is a valid rhs for a MODIFY_EXPR where the LHS is a GIMPLE temporary, a renamed user variable, or something else, respectively. */ @@ -904,18 +1001,13 @@ extern bool is_gimple_mem_rhs (tree); /* Returns true iff T is a valid if-statement condition. */ extern bool is_gimple_condexpr (tree); -/* Returns true iff T is a type conversion. */ -extern bool is_gimple_cast (tree); -/* Returns true iff T is a variable that does not need to live in memory. */ -extern bool is_gimple_non_addressable (tree t); - /* Returns true iff T is a valid call address expression. */ extern bool is_gimple_call_addr (tree); -/* If T makes a function call, returns the CALL_EXPR operand. */ -extern tree get_call_expr_in (tree t); extern void recalculate_side_effects (tree); +extern bool gimple_compare_field_offset (tree, tree); extern tree gimple_register_type (tree); +extern tree gimple_register_canonical_type (tree); extern void print_gimple_types_stats (void); extern void free_gimple_type_tables (void); extern tree gimple_unsigned_type (tree); @@ -931,15 +1023,17 @@ extern bool walk_stmt_load_store_ops (gimple, void *, bool (*)(gimple, tree, void *), bool (*)(gimple, tree, void *)); extern bool gimple_ior_addresses_taken (bitmap, gimple); +extern bool gimple_call_builtin_p (gimple, enum built_in_function); +extern bool gimple_asm_clobbers_memory_p (const_gimple); /* In gimplify.c */ extern tree create_tmp_var_raw (tree, const char *); extern tree create_tmp_var_name (const char *); extern tree create_tmp_var (tree, const char *); +extern tree create_tmp_reg (tree, const char *); extern tree get_initialized_tmp_var (tree, gimple_seq *, gimple_seq *); extern tree get_formal_tmp_var (tree, gimple_seq *); extern void declare_vars (tree, gimple, bool); -extern void tree_annotate_all_with_location (tree *, location_t); extern void annotate_all_with_location (gimple_seq, location_t); /* Validation of GIMPLE expressions. Note that these predicates only check @@ -981,7 +1075,7 @@ struct gimplify_ctx gimple_seq conditional_cleanups; tree exit_label; tree return_temp; - + VEC(tree,heap) *case_labels; /* The formal temporary table. Should this be persistent? */ htab_t temp_htab; @@ -990,6 +1084,7 @@ struct gimplify_ctx bool save_stack; bool into_ssa; bool allow_rhs_cond_expr; + bool in_cleanup_point_expr; }; extern enum gimplify_status gimplify_expr (tree *, gimple_seq *, gimple_seq *, @@ -997,7 +1092,7 @@ extern enum gimplify_status gimplify_expr (tree *, gimple_seq *, gimple_seq *, extern void gimplify_type_sizes (tree, gimple_seq *); extern void gimplify_one_sizepos (tree *, gimple_seq *); extern bool gimplify_stmt (tree *, gimple_seq *); -extern gimple gimplify_body (tree *, tree, bool); +extern gimple gimplify_body (tree, bool); extern void push_gimplify_context (struct gimplify_ctx *); extern void pop_gimplify_context (gimple); extern void gimplify_and_add (tree, gimple_seq *); @@ -1008,8 +1103,6 @@ extern gimple gimple_current_bind_expr (void); extern VEC(gimple, heap) *gimple_bind_expr_stack (void); extern tree voidify_wrapper_expr (tree, tree); extern tree build_and_jump (tree *); -extern tree alloc_stmt_list (void); -extern void free_stmt_list (tree); extern tree force_labels_r (tree *, int *, void *); extern enum gimplify_status gimplify_va_arg_expr (tree *, gimple_seq *, gimple_seq *); @@ -1022,6 +1115,10 @@ extern tree canonicalize_cond_expr_cond (tree); /* In omp-low.c. */ extern tree omp_reduction_init (tree, tree); +/* In trans-mem.c. */ +extern void diagnose_tm_safe_errors (tree); +extern void compute_transaction_bits (void); + /* In tree-nested.c. */ extern void lower_nested_functions (tree); extern void insert_field_into_struct (tree, tree); @@ -1055,7 +1152,7 @@ gimple_code (const_gimple g) static inline enum gimple_statement_structure_enum gss_for_code (enum gimple_code code) { - gcc_assert ((unsigned int)code < LAST_AND_UNUSED_GIMPLE_CODE); + gcc_gimple_checking_assert ((unsigned int)code < LAST_AND_UNUSED_GIMPLE_CODE); return gss_for_code_[code]; } @@ -1080,6 +1177,7 @@ gimple_has_substatements (gimple g) case GIMPLE_BIND: case GIMPLE_CATCH: case GIMPLE_EH_FILTER: + case GIMPLE_EH_ELSE: case GIMPLE_TRY: case GIMPLE_OMP_FOR: case GIMPLE_OMP_MASTER: @@ -1091,13 +1189,14 @@ gimple_has_substatements (gimple g) case GIMPLE_OMP_SINGLE: case GIMPLE_OMP_CRITICAL: case GIMPLE_WITH_CLEANUP_EXPR: + case GIMPLE_TRANSACTION: return true; default: return false; } } - + /* Return the basic block holding statement G. */ @@ -1295,7 +1394,7 @@ gimple_def_ops (const_gimple g) static inline void gimple_set_def_ops (gimple g, struct def_optype_d *def) { - gcc_assert (gimple_has_ops (g)); + gcc_gimple_checking_assert (gimple_has_ops (g)); g->gsops.opbase.def_ops = def; } @@ -1316,7 +1415,7 @@ gimple_use_ops (const_gimple g) static inline void gimple_set_use_ops (gimple g, struct use_optype_d *use) { - gcc_assert (gimple_has_ops (g)); + gcc_gimple_checking_assert (gimple_has_ops (g)); g->gsops.opbase.use_ops = use; } @@ -1331,7 +1430,7 @@ gimple_vuse_op (const_gimple g) return NULL_USE_OPERAND_P; ops = g->gsops.opbase.use_ops; if (ops - && USE_OP_PTR (ops)->use == &g->gsmem.membase.vuse) + && USE_OP_PTR (ops)->use == &g->gsmembase.vuse) return USE_OP_PTR (ops); return NULL_USE_OPERAND_P; } @@ -1346,7 +1445,7 @@ gimple_vdef_op (const_gimple g) return NULL_DEF_OPERAND_P; ops = g->gsops.opbase.def_ops; if (ops - && DEF_OP_PTR (ops) == &g->gsmem.membase.vdef) + && DEF_OP_PTR (ops) == &g->gsmembase.vdef) return DEF_OP_PTR (ops); return NULL_DEF_OPERAND_P; } @@ -1359,7 +1458,7 @@ gimple_vuse (const_gimple g) { if (!gimple_has_mem_ops (g)) return NULL_TREE; - return g->gsmem.membase.vuse; + return g->gsmembase.vuse; } /* Return the single VDEF operand of the statement G. */ @@ -1369,7 +1468,7 @@ gimple_vdef (const_gimple g) { if (!gimple_has_mem_ops (g)) return NULL_TREE; - return g->gsmem.membase.vdef; + return g->gsmembase.vdef; } /* Return the single VUSE operand of the statement G. */ @@ -1379,7 +1478,7 @@ gimple_vuse_ptr (gimple g) { if (!gimple_has_mem_ops (g)) return NULL; - return &g->gsmem.membase.vuse; + return &g->gsmembase.vuse; } /* Return the single VDEF operand of the statement G. */ @@ -1389,7 +1488,7 @@ gimple_vdef_ptr (gimple g) { if (!gimple_has_mem_ops (g)) return NULL; - return &g->gsmem.membase.vdef; + return &g->gsmembase.vdef; } /* Set the single VUSE operand of the statement G. */ @@ -1397,8 +1496,8 @@ gimple_vdef_ptr (gimple g) static inline void gimple_set_vuse (gimple g, tree vuse) { - gcc_assert (gimple_has_mem_ops (g)); - g->gsmem.membase.vuse = vuse; + gcc_gimple_checking_assert (gimple_has_mem_ops (g)); + g->gsmembase.vuse = vuse; } /* Set the single VDEF operand of the statement G. */ @@ -1406,8 +1505,8 @@ gimple_set_vuse (gimple g, tree vuse) static inline void gimple_set_vdef (gimple g, tree vdef) { - gcc_assert (gimple_has_mem_ops (g)); - g->gsmem.membase.vdef = vdef; + gcc_gimple_checking_assert (gimple_has_mem_ops (g)); + g->gsmembase.vdef = vdef; } @@ -1433,10 +1532,11 @@ gimple_expr_code (const_gimple stmt) enum gimple_code code = gimple_code (stmt); if (code == GIMPLE_ASSIGN || code == GIMPLE_COND) return (enum tree_code) stmt->gsbase.subcode; - else if (code == GIMPLE_CALL) - return CALL_EXPR; else - gcc_unreachable (); + { + gcc_gimple_checking_assert (code == GIMPLE_CALL); + return CALL_EXPR; + } } @@ -1482,6 +1582,21 @@ gimple_set_has_volatile_ops (gimple stmt, bool volatilep) stmt->gsbase.has_volatile_ops = (unsigned) volatilep; } +/* Return true if BB is in a transaction. */ + +static inline bool +block_in_transaction (basic_block bb) +{ + return flag_tm && bb->flags & BB_IN_TRANSACTION; +} + +/* Return true if STMT is in a transaction. */ + +static inline bool +gimple_in_transaction (gimple stmt) +{ + return block_in_transaction (gimple_bb (stmt)); +} /* Return true if statement STMT may access memory. */ @@ -1497,7 +1612,7 @@ gimple_references_memory_p (gimple stmt) static inline unsigned gimple_omp_subcode (const_gimple s) { - gcc_assert (gimple_code (s) >= GIMPLE_OMP_ATOMIC_LOAD + gcc_gimple_checking_assert (gimple_code (s) >= GIMPLE_OMP_ATOMIC_LOAD && gimple_code (s) <= GIMPLE_OMP_SINGLE); return s->gsbase.subcode; } @@ -1509,7 +1624,7 @@ gimple_omp_set_subcode (gimple s, unsigned int subcode) { /* We only have 16 bits for the subcode. Assert that we are not overflowing it. */ - gcc_assert (subcode < (1 << 16)); + gcc_gimple_checking_assert (subcode < (1 << 16)); s->gsbase.subcode = subcode; } @@ -1580,6 +1695,29 @@ gimple_omp_parallel_set_combined_p (gimple g, bool combined_p) } +/* Return true if OMP atomic load/store statement G has the + GF_OMP_ATOMIC_NEED_VALUE flag set. */ + +static inline bool +gimple_omp_atomic_need_value_p (const_gimple g) +{ + if (gimple_code (g) != GIMPLE_OMP_ATOMIC_LOAD) + GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE); + return (gimple_omp_subcode (g) & GF_OMP_ATOMIC_NEED_VALUE) != 0; +} + + +/* Set the GF_OMP_ATOMIC_NEED_VALUE flag on G. */ + +static inline void +gimple_omp_atomic_set_need_value (gimple g) +{ + if (gimple_code (g) != GIMPLE_OMP_ATOMIC_LOAD) + GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE); + g->gsbase.subcode |= GF_OMP_ATOMIC_NEED_VALUE; +} + + /* Return the number of operands for statement GS. */ static inline unsigned @@ -1609,7 +1747,7 @@ gimple_ops (gimple gs) of the structure. Note that those structures that do not have an operand vector have a zero offset. */ off = gimple_ops_offset_[gimple_statement_structure (gs)]; - gcc_assert (off != 0); + gcc_gimple_checking_assert (off != 0); return (tree *) ((char *) gs + off); } @@ -1622,7 +1760,7 @@ gimple_op (const_gimple gs, unsigned i) { if (gimple_has_ops (gs)) { - gcc_assert (i < gimple_num_ops (gs)); + gcc_gimple_checking_assert (i < gimple_num_ops (gs)); return gimple_ops (CONST_CAST_GIMPLE (gs))[i]; } else @@ -1636,7 +1774,7 @@ gimple_op_ptr (const_gimple gs, unsigned i) { if (gimple_has_ops (gs)) { - gcc_assert (i < gimple_num_ops (gs)); + gcc_gimple_checking_assert (i < gimple_num_ops (gs)); return gimple_ops (CONST_CAST_GIMPLE (gs)) + i; } else @@ -1648,7 +1786,7 @@ gimple_op_ptr (const_gimple gs, unsigned i) static inline void gimple_set_op (gimple gs, unsigned i, tree op) { - gcc_assert (gimple_has_ops (gs) && i < gimple_num_ops (gs)); + gcc_gimple_checking_assert (gimple_has_ops (gs) && i < gimple_num_ops (gs)); /* Note. It may be tempting to assert that OP matches is_gimple_operand, but that would be wrong. Different tuples @@ -1700,7 +1838,6 @@ static inline void gimple_assign_set_lhs (gimple gs, tree lhs) { GIMPLE_CHECK (gs, GIMPLE_ASSIGN); - gcc_assert (is_gimple_operand (lhs)); gimple_set_op (gs, 0, lhs); if (lhs && TREE_CODE (lhs) == SSA_NAME) @@ -1735,13 +1872,6 @@ gimple_assign_set_rhs1 (gimple gs, tree rhs) { GIMPLE_CHECK (gs, GIMPLE_ASSIGN); - /* If there are 3 or more operands, the 2 operands on the RHS must be - GIMPLE values. */ - if (gimple_num_ops (gs) >= 3) - gcc_assert (is_gimple_val (rhs)); - else - gcc_assert (is_gimple_operand (rhs)); - gimple_set_op (gs, 1, rhs); } @@ -1779,12 +1909,66 @@ gimple_assign_set_rhs2 (gimple gs, tree rhs) { GIMPLE_CHECK (gs, GIMPLE_ASSIGN); - /* The 2 operands on the RHS must be GIMPLE values. */ - gcc_assert (is_gimple_val (rhs)); - gimple_set_op (gs, 2, rhs); } +/* Return the third operand on the RHS of assignment statement GS. + If GS does not have two operands, NULL is returned instead. */ + +static inline tree +gimple_assign_rhs3 (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_ASSIGN); + + if (gimple_num_ops (gs) >= 4) + return gimple_op (gs, 3); + else + return NULL_TREE; +} + +/* Return a pointer to the third operand on the RHS of assignment + statement GS. */ + +static inline tree * +gimple_assign_rhs3_ptr (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_ASSIGN); + return gimple_op_ptr (gs, 3); +} + + +/* Set RHS to be the third operand on the RHS of assignment statement GS. */ + +static inline void +gimple_assign_set_rhs3 (gimple gs, tree rhs) +{ + GIMPLE_CHECK (gs, GIMPLE_ASSIGN); + + gimple_set_op (gs, 3, rhs); +} + +/* A wrapper around gimple_assign_set_rhs_with_ops_1, for callers which expect + to see only a maximum of two operands. */ + +static inline void +gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *gsi, enum tree_code code, + tree op1, tree op2) +{ + gimple_assign_set_rhs_with_ops_1 (gsi, code, op1, op2, NULL); +} + +/* A wrapper around extract_ops_from_tree_1, for callers which expect + to see only a maximum of two operands. */ + +static inline void +extract_ops_from_tree (tree expr, enum tree_code *code, tree *op0, + tree *op1) +{ + tree op2; + extract_ops_from_tree_1 (expr, code, op0, op1, &op2); + gcc_assert (op2 == NULL_TREE); +} + /* Returns true if GS is a nontemporal move. */ static inline bool @@ -1814,7 +1998,10 @@ gimple_assign_rhs_code (const_gimple gs) enum tree_code code; GIMPLE_CHECK (gs, GIMPLE_ASSIGN); - code = gimple_expr_code (gs); + code = (enum tree_code) gs->gsbase.subcode; + /* While we initially set subcode to the TREE_CODE of the rhs for + GIMPLE_SINGLE_RHS assigns we do not update that subcode to stay + in sync when we rewrite stmts into SSA form or do SSA propagations. */ if (get_gimple_rhs_class (code) == GIMPLE_SINGLE_RHS) code = TREE_CODE (gimple_assign_rhs1 (gs)); @@ -1843,6 +2030,19 @@ gimple_assign_rhs_class (const_gimple gs) return get_gimple_rhs_class (gimple_assign_rhs_code (gs)); } +/* Return true if GS is an assignment with a singleton RHS, i.e., + there is no operator associated with the assignment itself. + Unlike gimple_assign_copy_p, this predicate returns true for + any RHS operand, including those that perform an operation + and do not have the semantics of a copy, such as COND_EXPR. */ + +static inline bool +gimple_assign_single_p (gimple gs) +{ + return (is_gimple_assign (gs) + && gimple_assign_rhs_class (gs) == GIMPLE_SINGLE_RHS); +} + /* Return true if S is a type-cast assignment. */ @@ -1860,6 +2060,14 @@ gimple_assign_cast_p (gimple s) return false; } +/* Return true if S is a clobber statement. */ + +static inline bool +gimple_clobber_p (gimple s) +{ + return gimple_assign_single_p (s) + && TREE_CLOBBER_P (gimple_assign_rhs1 (s)); +} /* Return true if GS is a GIMPLE_CALL. */ @@ -1895,13 +2103,55 @@ static inline void gimple_call_set_lhs (gimple gs, tree lhs) { GIMPLE_CHECK (gs, GIMPLE_CALL); - gcc_assert (!lhs || is_gimple_operand (lhs)); gimple_set_op (gs, 0, lhs); if (lhs && TREE_CODE (lhs) == SSA_NAME) SSA_NAME_DEF_STMT (lhs) = gs; } +/* Return true if call GS calls an internal-only function, as enumerated + by internal_fn. */ + +static inline bool +gimple_call_internal_p (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_CALL); + return (gs->gsbase.subcode & GF_CALL_INTERNAL) != 0; +} + + +/* Return the target of internal call GS. */ + +static inline enum internal_fn +gimple_call_internal_fn (const_gimple gs) +{ + gcc_gimple_checking_assert (gimple_call_internal_p (gs)); + return gs->gimple_call.u.internal_fn; +} + + +/* Return the function type of the function called by GS. */ + +static inline tree +gimple_call_fntype (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_CALL); + if (gimple_call_internal_p (gs)) + return NULL_TREE; + return gs->gimple_call.u.fntype; +} + +/* Set the type of the function called by GS to FNTYPE. */ + +static inline void +gimple_call_set_fntype (gimple gs, tree fntype) +{ + GIMPLE_CHECK (gs, GIMPLE_CALL); + gcc_gimple_checking_assert (!gimple_call_internal_p (gs)); + gs->gimple_call.u.fntype = fntype; +} + + /* Return the tree node representing the function called by call statement GS. */ @@ -1912,7 +2162,6 @@ gimple_call_fn (const_gimple gs) return gimple_op (gs, 1); } - /* Return a pointer to the tree node representing the function called by call statement GS. */ @@ -1930,7 +2179,7 @@ static inline void gimple_call_set_fn (gimple gs, tree fn) { GIMPLE_CHECK (gs, GIMPLE_CALL); - gcc_assert (is_gimple_operand (fn)); + gcc_gimple_checking_assert (!gimple_call_internal_p (gs)); gimple_set_op (gs, 1, fn); } @@ -1941,11 +2190,41 @@ static inline void gimple_call_set_fndecl (gimple gs, tree decl) { GIMPLE_CHECK (gs, GIMPLE_CALL); - gcc_assert (TREE_CODE (decl) == FUNCTION_DECL); + gcc_gimple_checking_assert (!gimple_call_internal_p (gs)); gimple_set_op (gs, 1, build_fold_addr_expr_loc (gimple_location (gs), decl)); } +/* Set internal function FN to be the function called by call statement GS. */ + +static inline void +gimple_call_set_internal_fn (gimple gs, enum internal_fn fn) +{ + GIMPLE_CHECK (gs, GIMPLE_CALL); + gcc_gimple_checking_assert (gimple_call_internal_p (gs)); + gs->gimple_call.u.internal_fn = fn; +} + + +/* Given a valid GIMPLE_CALL function address return the FUNCTION_DECL + associated with the callee if known. Otherwise return NULL_TREE. */ + +static inline tree +gimple_call_addr_fndecl (const_tree fn) +{ + if (fn && TREE_CODE (fn) == ADDR_EXPR) + { + tree fndecl = TREE_OPERAND (fn, 0); + if (TREE_CODE (fndecl) == MEM_REF + && TREE_CODE (TREE_OPERAND (fndecl, 0)) == ADDR_EXPR + && integer_zerop (TREE_OPERAND (fndecl, 1))) + fndecl = TREE_OPERAND (TREE_OPERAND (fndecl, 0), 0); + if (TREE_CODE (fndecl) == FUNCTION_DECL) + return fndecl; + } + return NULL_TREE; +} + /* If a given GIMPLE_CALL's callee is a FUNCTION_DECL, return it. Otherwise return NULL. This function is analogous to get_callee_fndecl in tree land. */ @@ -1953,13 +2232,7 @@ gimple_call_set_fndecl (gimple gs, tree decl) static inline tree gimple_call_fndecl (const_gimple gs) { - tree addr = gimple_call_fn (gs); - if (TREE_CODE (addr) == ADDR_EXPR) - { - gcc_assert (TREE_CODE (TREE_OPERAND (addr, 0)) == FUNCTION_DECL); - return TREE_OPERAND (addr, 0); - } - return NULL_TREE; + return gimple_call_addr_fndecl (gimple_call_fn (gs)); } @@ -1968,17 +2241,12 @@ gimple_call_fndecl (const_gimple gs) static inline tree gimple_call_return_type (const_gimple gs) { - tree fn = gimple_call_fn (gs); - tree type = TREE_TYPE (fn); - - /* See through the pointer. */ - gcc_assert (POINTER_TYPE_P (type)); - type = TREE_TYPE (type); + tree type = gimple_call_fntype (gs); - gcc_assert (TREE_CODE (type) == FUNCTION_TYPE - || TREE_CODE (type) == METHOD_TYPE); + if (type == NULL_TREE) + return TREE_TYPE (gimple_call_lhs (gs)); - /* The type returned by a FUNCTION_DECL is the type of its + /* The type returned by a function is the type of its function type. */ return TREE_TYPE (type); } @@ -2009,9 +2277,7 @@ static inline void gimple_call_set_chain (gimple gs, tree chain) { GIMPLE_CHECK (gs, GIMPLE_CALL); - gcc_assert (chain == NULL - || TREE_CODE (chain) == ADDR_EXPR - || SSA_VAR_P (chain)); + gimple_set_op (gs, 2, chain); } @@ -2024,7 +2290,6 @@ gimple_call_num_args (const_gimple gs) unsigned num_ops; GIMPLE_CHECK (gs, GIMPLE_CALL); num_ops = gimple_num_ops (gs); - gcc_assert (num_ops >= 3); return num_ops - 3; } @@ -2056,7 +2321,6 @@ static inline void gimple_call_set_arg (gimple gs, unsigned index, tree arg) { GIMPLE_CHECK (gs, GIMPLE_CALL); - gcc_assert (is_gimple_operand (arg)); gimple_set_op (gs, index + 3, arg); } @@ -2086,29 +2350,6 @@ gimple_call_tail_p (gimple s) } -/* Set the inlinable status of GIMPLE_CALL S to INLINABLE_P. */ - -static inline void -gimple_call_set_cannot_inline (gimple s, bool inlinable_p) -{ - GIMPLE_CHECK (s, GIMPLE_CALL); - if (inlinable_p) - s->gsbase.subcode |= GF_CALL_CANNOT_INLINE; - else - s->gsbase.subcode &= ~GF_CALL_CANNOT_INLINE; -} - - -/* Return true if GIMPLE_CALL S cannot be inlined. */ - -static inline bool -gimple_call_cannot_inline_p (gimple s) -{ - GIMPLE_CHECK (s, GIMPLE_CALL); - return (s->gsbase.subcode & GF_CALL_CANNOT_INLINE) != 0; -} - - /* If RETURN_SLOT_OPT_P is true mark GIMPLE_CALL S as valid for return slot optimization. This transformation uses the target of the call expansion as the return slot for calls that return in memory. */ @@ -2193,6 +2434,19 @@ gimple_call_noreturn_p (gimple s) } +/* If NOTHROW_P is true, GIMPLE_CALL S is a call that is known to not throw + even if the called function can throw in other cases. */ + +static inline void +gimple_call_set_nothrow (gimple s, bool nothrow_p) +{ + GIMPLE_CHECK (s, GIMPLE_CALL); + if (nothrow_p) + s->gsbase.subcode |= GF_CALL_NOTHROW; + else + s->gsbase.subcode &= ~GF_CALL_NOTHROW; +} + /* Return true if S is a nothrow call. */ static inline bool @@ -2202,6 +2456,29 @@ gimple_call_nothrow_p (gimple s) return (gimple_call_flags (s) & ECF_NOTHROW) != 0; } +/* If FOR_VAR is true, GIMPLE_CALL S is a call to builtin_alloca that + is known to be emitted for VLA objects. Those are wrapped by + stack_save/stack_restore calls and hence can't lead to unbounded + stack growth even when they occur in loops. */ + +static inline void +gimple_call_set_alloca_for_var (gimple s, bool for_var) +{ + GIMPLE_CHECK (s, GIMPLE_CALL); + if (for_var) + s->gsbase.subcode |= GF_CALL_ALLOCA_FOR_VAR; + else + s->gsbase.subcode &= ~GF_CALL_ALLOCA_FOR_VAR; +} + +/* Return true of S is a call to builtin_alloca emitted for VLA objects. */ + +static inline bool +gimple_call_alloca_for_var_p (gimple s) +{ + GIMPLE_CHECK (s, GIMPLE_CALL); + return (s->gsbase.subcode & GF_CALL_ALLOCA_FOR_VAR) != 0; +} /* Copy all the GF_CALL_* flags from ORIG_CALL to DEST_CALL. */ @@ -2214,6 +2491,28 @@ gimple_call_copy_flags (gimple dest_call, gimple orig_call) } +/* Return a pointer to the points-to solution for the set of call-used + variables of the call CALL. */ + +static inline struct pt_solution * +gimple_call_use_set (gimple call) +{ + GIMPLE_CHECK (call, GIMPLE_CALL); + return &call->gimple_call.call_used; +} + + +/* Return a pointer to the points-to solution for the set of call-used + variables of the call CALL. */ + +static inline struct pt_solution * +gimple_call_clobber_set (gimple call) +{ + GIMPLE_CHECK (call, GIMPLE_CALL); + return &call->gimple_call.call_clobbered; +} + + /* Returns true if this is a GIMPLE_ASSIGN or a GIMPLE_CALL with a non-NULL lhs. */ @@ -2242,7 +2541,6 @@ static inline void gimple_cond_set_code (gimple gs, enum tree_code code) { GIMPLE_CHECK (gs, GIMPLE_COND); - gcc_assert (TREE_CODE_CLASS (code) == tcc_comparison); gs->gsbase.subcode = code; } @@ -2273,7 +2571,6 @@ static inline void gimple_cond_set_lhs (gimple gs, tree lhs) { GIMPLE_CHECK (gs, GIMPLE_COND); - gcc_assert (is_gimple_operand (lhs)); gimple_set_op (gs, 0, lhs); } @@ -2305,7 +2602,6 @@ static inline void gimple_cond_set_rhs (gimple gs, tree rhs) { GIMPLE_CHECK (gs, GIMPLE_COND); - gcc_assert (is_gimple_operand (rhs)); gimple_set_op (gs, 1, rhs); } @@ -2328,7 +2624,6 @@ static inline void gimple_cond_set_true_label (gimple gs, tree label) { GIMPLE_CHECK (gs, GIMPLE_COND); - gcc_assert (!label || TREE_CODE (label) == LABEL_DECL); gimple_set_op (gs, 2, label); } @@ -2340,7 +2635,6 @@ static inline void gimple_cond_set_false_label (gimple gs, tree label) { GIMPLE_CHECK (gs, GIMPLE_COND); - gcc_assert (!label || TREE_CODE (label) == LABEL_DECL); gimple_set_op (gs, 3, label); } @@ -2471,7 +2765,6 @@ static inline void gimple_label_set_label (gimple gs, tree label) { GIMPLE_CHECK (gs, GIMPLE_LABEL); - gcc_assert (TREE_CODE (label) == LABEL_DECL); gimple_set_op (gs, 0, label); } @@ -2488,11 +2781,10 @@ gimple_goto_dest (const_gimple gs) /* Set DEST to be the destination of the unconditonal jump GS. */ -static inline void +static inline void gimple_goto_set_dest (gimple gs, tree dest) { GIMPLE_CHECK (gs, GIMPLE_GOTO); - gcc_assert (is_gimple_operand (dest)); gimple_set_op (gs, 0, dest); } @@ -2588,7 +2880,8 @@ static inline void gimple_bind_set_block (gimple gs, tree block) { GIMPLE_CHECK (gs, GIMPLE_BIND); - gcc_assert (block == NULL_TREE || TREE_CODE (block) == BLOCK); + gcc_gimple_checking_assert (block == NULL_TREE + || TREE_CODE (block) == BLOCK); gs->gimple_bind.block = block; } @@ -2637,7 +2930,7 @@ static inline tree gimple_asm_input_op (const_gimple gs, unsigned index) { GIMPLE_CHECK (gs, GIMPLE_ASM); - gcc_assert (index <= gs->gimple_asm.ni); + gcc_gimple_checking_assert (index <= gs->gimple_asm.ni); return gimple_op (gs, index); } @@ -2647,7 +2940,7 @@ static inline tree * gimple_asm_input_op_ptr (const_gimple gs, unsigned index) { GIMPLE_CHECK (gs, GIMPLE_ASM); - gcc_assert (index <= gs->gimple_asm.ni); + gcc_gimple_checking_assert (index <= gs->gimple_asm.ni); return gimple_op_ptr (gs, index); } @@ -2658,8 +2951,8 @@ static inline void gimple_asm_set_input_op (gimple gs, unsigned index, tree in_op) { GIMPLE_CHECK (gs, GIMPLE_ASM); - gcc_assert (index <= gs->gimple_asm.ni); - gcc_assert (TREE_CODE (in_op) == TREE_LIST); + gcc_gimple_checking_assert (index <= gs->gimple_asm.ni + && TREE_CODE (in_op) == TREE_LIST); gimple_set_op (gs, index, in_op); } @@ -2670,7 +2963,7 @@ static inline tree gimple_asm_output_op (const_gimple gs, unsigned index) { GIMPLE_CHECK (gs, GIMPLE_ASM); - gcc_assert (index <= gs->gimple_asm.no); + gcc_gimple_checking_assert (index <= gs->gimple_asm.no); return gimple_op (gs, index + gs->gimple_asm.ni); } @@ -2680,7 +2973,7 @@ static inline tree * gimple_asm_output_op_ptr (const_gimple gs, unsigned index) { GIMPLE_CHECK (gs, GIMPLE_ASM); - gcc_assert (index <= gs->gimple_asm.no); + gcc_gimple_checking_assert (index <= gs->gimple_asm.no); return gimple_op_ptr (gs, index + gs->gimple_asm.ni); } @@ -2691,8 +2984,8 @@ static inline void gimple_asm_set_output_op (gimple gs, unsigned index, tree out_op) { GIMPLE_CHECK (gs, GIMPLE_ASM); - gcc_assert (index <= gs->gimple_asm.no); - gcc_assert (TREE_CODE (out_op) == TREE_LIST); + gcc_gimple_checking_assert (index <= gs->gimple_asm.no + && TREE_CODE (out_op) == TREE_LIST); gimple_set_op (gs, index + gs->gimple_asm.ni, out_op); } @@ -2703,7 +2996,7 @@ static inline tree gimple_asm_clobber_op (const_gimple gs, unsigned index) { GIMPLE_CHECK (gs, GIMPLE_ASM); - gcc_assert (index <= gs->gimple_asm.nc); + gcc_gimple_checking_assert (index <= gs->gimple_asm.nc); return gimple_op (gs, index + gs->gimple_asm.ni + gs->gimple_asm.no); } @@ -2714,8 +3007,8 @@ static inline void gimple_asm_set_clobber_op (gimple gs, unsigned index, tree clobber_op) { GIMPLE_CHECK (gs, GIMPLE_ASM); - gcc_assert (index <= gs->gimple_asm.nc); - gcc_assert (TREE_CODE (clobber_op) == TREE_LIST); + gcc_gimple_checking_assert (index <= gs->gimple_asm.nc + && TREE_CODE (clobber_op) == TREE_LIST); gimple_set_op (gs, index + gs->gimple_asm.ni + gs->gimple_asm.no, clobber_op); } @@ -2725,7 +3018,7 @@ static inline tree gimple_asm_label_op (const_gimple gs, unsigned index) { GIMPLE_CHECK (gs, GIMPLE_ASM); - gcc_assert (index <= gs->gimple_asm.nl); + gcc_gimple_checking_assert (index <= gs->gimple_asm.nl); return gimple_op (gs, index + gs->gimple_asm.ni + gs->gimple_asm.nc); } @@ -2735,8 +3028,8 @@ static inline void gimple_asm_set_label_op (gimple gs, unsigned index, tree label_op) { GIMPLE_CHECK (gs, GIMPLE_ASM); - gcc_assert (index <= gs->gimple_asm.nl); - gcc_assert (TREE_CODE (label_op) == TREE_LIST); + gcc_gimple_checking_assert (index <= gs->gimple_asm.nl + && TREE_CODE (label_op) == TREE_LIST); gimple_set_op (gs, index + gs->gimple_asm.ni + gs->gimple_asm.nc, label_op); } @@ -2929,6 +3222,35 @@ gimple_eh_must_not_throw_set_fndecl (gimple gs, tree decl) gs->gimple_eh_mnt.fndecl = decl; } +/* GIMPLE_EH_ELSE accessors. */ + +static inline gimple_seq +gimple_eh_else_n_body (gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_EH_ELSE); + return gs->gimple_eh_else.n_body; +} + +static inline gimple_seq +gimple_eh_else_e_body (gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_EH_ELSE); + return gs->gimple_eh_else.e_body; +} + +static inline void +gimple_eh_else_set_n_body (gimple gs, gimple_seq seq) +{ + GIMPLE_CHECK (gs, GIMPLE_EH_ELSE); + gs->gimple_eh_else.n_body = seq; +} + +static inline void +gimple_eh_else_set_e_body (gimple gs, gimple_seq seq) +{ + GIMPLE_CHECK (gs, GIMPLE_EH_ELSE); + gs->gimple_eh_else.e_body = seq; +} /* GIMPLE_TRY accessors. */ @@ -2949,7 +3271,8 @@ static inline void gimple_try_set_kind (gimple gs, enum gimple_try_flags kind) { GIMPLE_CHECK (gs, GIMPLE_TRY); - gcc_assert (kind == GIMPLE_TRY_CATCH || kind == GIMPLE_TRY_FINALLY); + gcc_gimple_checking_assert (kind == GIMPLE_TRY_CATCH + || kind == GIMPLE_TRY_FINALLY); if (gimple_try_kind (gs) != kind) gs->gsbase.subcode = (unsigned int) kind; } @@ -2960,7 +3283,7 @@ gimple_try_set_kind (gimple gs, enum gimple_try_flags kind) static inline bool gimple_try_catch_is_cleanup (const_gimple gs) { - gcc_assert (gimple_try_kind (gs) == GIMPLE_TRY_CATCH); + gcc_gimple_checking_assert (gimple_try_kind (gs) == GIMPLE_TRY_CATCH); return (gs->gsbase.subcode & GIMPLE_TRY_CATCH_IS_CLEANUP) != 0; } @@ -2991,7 +3314,7 @@ gimple_try_cleanup (gimple gs) static inline void gimple_try_set_catch_is_cleanup (gimple g, bool catch_is_cleanup) { - gcc_assert (gimple_try_kind (g) == GIMPLE_TRY_CATCH); + gcc_gimple_checking_assert (gimple_try_kind (g) == GIMPLE_TRY_CATCH); if (catch_is_cleanup) g->gsbase.subcode |= GIMPLE_TRY_CATCH_IS_CLEANUP; else @@ -3118,7 +3441,7 @@ static inline struct phi_arg_d * gimple_phi_arg (gimple gs, unsigned index) { GIMPLE_CHECK (gs, GIMPLE_PHI); - gcc_assert (index <= gs->gimple_phi.capacity); + gcc_gimple_checking_assert (index <= gs->gimple_phi.capacity); return &(gs->gimple_phi.args[index]); } @@ -3129,8 +3452,8 @@ static inline void gimple_phi_set_arg (gimple gs, unsigned index, struct phi_arg_d * phiarg) { GIMPLE_CHECK (gs, GIMPLE_PHI); - gcc_assert (index <= gs->gimple_phi.nargs); - memcpy (gs->gimple_phi.args + index, phiarg, sizeof (struct phi_arg_d)); + gcc_gimple_checking_assert (index <= gs->gimple_phi.nargs); + gs->gimple_phi.args[index] = *phiarg; } /* Return the region number for GIMPLE_RESX GS. */ @@ -3177,7 +3500,7 @@ gimple_switch_num_labels (const_gimple gs) unsigned num_ops; GIMPLE_CHECK (gs, GIMPLE_SWITCH); num_ops = gimple_num_ops (gs); - gcc_assert (num_ops > 1); + gcc_gimple_checking_assert (num_ops > 1); return num_ops - 1; } @@ -3218,7 +3541,7 @@ static inline void gimple_switch_set_index (gimple gs, tree index) { GIMPLE_CHECK (gs, GIMPLE_SWITCH); - gcc_assert (SSA_VAR_P (index) || CONSTANT_CLASS_P (index)); + gcc_gimple_checking_assert (SSA_VAR_P (index) || CONSTANT_CLASS_P (index)); gimple_set_op (gs, 0, index); } @@ -3230,7 +3553,7 @@ static inline tree gimple_switch_label (const_gimple gs, unsigned index) { GIMPLE_CHECK (gs, GIMPLE_SWITCH); - gcc_assert (gimple_num_ops (gs) > index + 1); + gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 1); return gimple_op (gs, index + 1); } @@ -3240,8 +3563,9 @@ static inline void gimple_switch_set_label (gimple gs, unsigned index, tree label) { GIMPLE_CHECK (gs, GIMPLE_SWITCH); - gcc_assert (gimple_num_ops (gs) > index + 1); - gcc_assert (label == NULL_TREE || TREE_CODE (label) == CASE_LABEL_EXPR); + gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 1 + && (label == NULL_TREE + || TREE_CODE (label) == CASE_LABEL_EXPR)); gimple_set_op (gs, index + 1, label); } @@ -3286,7 +3610,7 @@ static inline tree gimple_debug_bind_get_var (gimple dbg) { GIMPLE_CHECK (dbg, GIMPLE_DEBUG); - gcc_assert (gimple_debug_bind_p (dbg)); + gcc_gimple_checking_assert (gimple_debug_bind_p (dbg)); return gimple_op (dbg, 0); } @@ -3297,7 +3621,7 @@ static inline tree gimple_debug_bind_get_value (gimple dbg) { GIMPLE_CHECK (dbg, GIMPLE_DEBUG); - gcc_assert (gimple_debug_bind_p (dbg)); + gcc_gimple_checking_assert (gimple_debug_bind_p (dbg)); return gimple_op (dbg, 1); } @@ -3308,7 +3632,7 @@ static inline tree * gimple_debug_bind_get_value_ptr (gimple dbg) { GIMPLE_CHECK (dbg, GIMPLE_DEBUG); - gcc_assert (gimple_debug_bind_p (dbg)); + gcc_gimple_checking_assert (gimple_debug_bind_p (dbg)); return gimple_op_ptr (dbg, 1); } @@ -3318,7 +3642,7 @@ static inline void gimple_debug_bind_set_var (gimple dbg, tree var) { GIMPLE_CHECK (dbg, GIMPLE_DEBUG); - gcc_assert (gimple_debug_bind_p (dbg)); + gcc_gimple_checking_assert (gimple_debug_bind_p (dbg)); gimple_set_op (dbg, 0, var); } @@ -3329,7 +3653,7 @@ static inline void gimple_debug_bind_set_value (gimple dbg, tree value) { GIMPLE_CHECK (dbg, GIMPLE_DEBUG); - gcc_assert (gimple_debug_bind_p (dbg)); + gcc_gimple_checking_assert (gimple_debug_bind_p (dbg)); gimple_set_op (dbg, 1, value); } @@ -3344,7 +3668,7 @@ static inline void gimple_debug_bind_reset_value (gimple dbg) { GIMPLE_CHECK (dbg, GIMPLE_DEBUG); - gcc_assert (gimple_debug_bind_p (dbg)); + gcc_gimple_checking_assert (gimple_debug_bind_p (dbg)); gimple_set_op (dbg, 1, GIMPLE_DEBUG_BIND_NOVALUE); } @@ -3355,15 +3679,79 @@ static inline bool gimple_debug_bind_has_value_p (gimple dbg) { GIMPLE_CHECK (dbg, GIMPLE_DEBUG); - gcc_assert (gimple_debug_bind_p (dbg)); + gcc_gimple_checking_assert (gimple_debug_bind_p (dbg)); return gimple_op (dbg, 1) != GIMPLE_DEBUG_BIND_NOVALUE; } #undef GIMPLE_DEBUG_BIND_NOVALUE +/* Return true if S is a GIMPLE_DEBUG SOURCE BIND statement. */ + +static inline bool +gimple_debug_source_bind_p (const_gimple s) +{ + if (is_gimple_debug (s)) + return s->gsbase.subcode == GIMPLE_DEBUG_SOURCE_BIND; + + return false; +} + +/* Return the variable bound in a GIMPLE_DEBUG source bind statement. */ + +static inline tree +gimple_debug_source_bind_get_var (gimple dbg) +{ + GIMPLE_CHECK (dbg, GIMPLE_DEBUG); + gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg)); + return gimple_op (dbg, 0); +} + +/* Return the value bound to the variable in a GIMPLE_DEBUG source bind + statement. */ + +static inline tree +gimple_debug_source_bind_get_value (gimple dbg) +{ + GIMPLE_CHECK (dbg, GIMPLE_DEBUG); + gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg)); + return gimple_op (dbg, 1); +} + +/* Return a pointer to the value bound to the variable in a + GIMPLE_DEBUG source bind statement. */ + +static inline tree * +gimple_debug_source_bind_get_value_ptr (gimple dbg) +{ + GIMPLE_CHECK (dbg, GIMPLE_DEBUG); + gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg)); + return gimple_op_ptr (dbg, 1); +} + +/* Set the variable bound in a GIMPLE_DEBUG source bind statement. */ + +static inline void +gimple_debug_source_bind_set_var (gimple dbg, tree var) +{ + GIMPLE_CHECK (dbg, GIMPLE_DEBUG); + gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg)); + gimple_set_op (dbg, 0, var); +} + +/* Set the value bound to the variable in a GIMPLE_DEBUG source bind + statement. */ + +static inline void +gimple_debug_source_bind_set_value (gimple dbg, tree value) +{ + GIMPLE_CHECK (dbg, GIMPLE_DEBUG); + gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg)); + gimple_set_op (dbg, 1, value); +} + /* Return the body for the OMP statement GS. */ -static inline gimple_seq +static inline gimple_seq gimple_omp_body (gimple gs) { return gs->omp.body; @@ -3454,7 +3842,7 @@ static inline tree gimple_omp_for_index (const_gimple gs, size_t i) { GIMPLE_CHECK (gs, GIMPLE_OMP_FOR); - gcc_assert (i < gs->gimple_omp_for.collapse); + gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse); return gs->gimple_omp_for.iter[i].index; } @@ -3465,7 +3853,7 @@ static inline tree * gimple_omp_for_index_ptr (gimple gs, size_t i) { GIMPLE_CHECK (gs, GIMPLE_OMP_FOR); - gcc_assert (i < gs->gimple_omp_for.collapse); + gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse); return &gs->gimple_omp_for.iter[i].index; } @@ -3476,7 +3864,7 @@ static inline void gimple_omp_for_set_index (gimple gs, size_t i, tree index) { GIMPLE_CHECK (gs, GIMPLE_OMP_FOR); - gcc_assert (i < gs->gimple_omp_for.collapse); + gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse); gs->gimple_omp_for.iter[i].index = index; } @@ -3487,7 +3875,7 @@ static inline tree gimple_omp_for_initial (const_gimple gs, size_t i) { GIMPLE_CHECK (gs, GIMPLE_OMP_FOR); - gcc_assert (i < gs->gimple_omp_for.collapse); + gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse); return gs->gimple_omp_for.iter[i].initial; } @@ -3498,7 +3886,7 @@ static inline tree * gimple_omp_for_initial_ptr (gimple gs, size_t i) { GIMPLE_CHECK (gs, GIMPLE_OMP_FOR); - gcc_assert (i < gs->gimple_omp_for.collapse); + gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse); return &gs->gimple_omp_for.iter[i].initial; } @@ -3509,7 +3897,7 @@ static inline void gimple_omp_for_set_initial (gimple gs, size_t i, tree initial) { GIMPLE_CHECK (gs, GIMPLE_OMP_FOR); - gcc_assert (i < gs->gimple_omp_for.collapse); + gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse); gs->gimple_omp_for.iter[i].initial = initial; } @@ -3520,7 +3908,7 @@ static inline tree gimple_omp_for_final (const_gimple gs, size_t i) { GIMPLE_CHECK (gs, GIMPLE_OMP_FOR); - gcc_assert (i < gs->gimple_omp_for.collapse); + gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse); return gs->gimple_omp_for.iter[i].final; } @@ -3531,7 +3919,7 @@ static inline tree * gimple_omp_for_final_ptr (gimple gs, size_t i) { GIMPLE_CHECK (gs, GIMPLE_OMP_FOR); - gcc_assert (i < gs->gimple_omp_for.collapse); + gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse); return &gs->gimple_omp_for.iter[i].final; } @@ -3542,7 +3930,7 @@ static inline void gimple_omp_for_set_final (gimple gs, size_t i, tree final) { GIMPLE_CHECK (gs, GIMPLE_OMP_FOR); - gcc_assert (i < gs->gimple_omp_for.collapse); + gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse); gs->gimple_omp_for.iter[i].final = final; } @@ -3553,7 +3941,7 @@ static inline tree gimple_omp_for_incr (const_gimple gs, size_t i) { GIMPLE_CHECK (gs, GIMPLE_OMP_FOR); - gcc_assert (i < gs->gimple_omp_for.collapse); + gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse); return gs->gimple_omp_for.iter[i].incr; } @@ -3564,7 +3952,7 @@ static inline tree * gimple_omp_for_incr_ptr (gimple gs, size_t i) { GIMPLE_CHECK (gs, GIMPLE_OMP_FOR); - gcc_assert (i < gs->gimple_omp_for.collapse); + gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse); return &gs->gimple_omp_for.iter[i].incr; } @@ -3575,7 +3963,7 @@ static inline void gimple_omp_for_set_incr (gimple gs, size_t i, tree incr) { GIMPLE_CHECK (gs, GIMPLE_OMP_FOR); - gcc_assert (i < gs->gimple_omp_for.collapse); + gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse); gs->gimple_omp_for.iter[i].incr = incr; } @@ -4077,8 +4465,8 @@ static inline void gimple_omp_for_set_cond (gimple gs, size_t i, enum tree_code cond) { GIMPLE_CHECK (gs, GIMPLE_OMP_FOR); - gcc_assert (TREE_CODE_CLASS (cond) == tcc_comparison); - gcc_assert (i < gs->gimple_omp_for.collapse); + gcc_gimple_checking_assert (TREE_CODE_CLASS (cond) == tcc_comparison + && i < gs->gimple_omp_for.collapse); gs->gimple_omp_for.iter[i].cond = cond; } @@ -4089,7 +4477,7 @@ static inline enum tree_code gimple_omp_for_cond (const_gimple gs, size_t i) { GIMPLE_CHECK (gs, GIMPLE_OMP_FOR); - gcc_assert (i < gs->gimple_omp_for.collapse); + gcc_gimple_checking_assert (i < gs->gimple_omp_for.collapse); return gs->gimple_omp_for.iter[i].cond; } @@ -4241,6 +4629,67 @@ gimple_omp_continue_set_control_use (gimple g, tree use) g->gimple_omp_continue.control_use = use; } +/* Return the body for the GIMPLE_TRANSACTION statement GS. */ + +static inline gimple_seq +gimple_transaction_body (gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_TRANSACTION); + return gs->gimple_transaction.body; +} + +/* Return the label associated with a GIMPLE_TRANSACTION. */ + +static inline tree +gimple_transaction_label (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_TRANSACTION); + return gs->gimple_transaction.label; +} + +static inline tree * +gimple_transaction_label_ptr (gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_TRANSACTION); + return &gs->gimple_transaction.label; +} + +/* Return the subcode associated with a GIMPLE_TRANSACTION. */ + +static inline unsigned int +gimple_transaction_subcode (const_gimple gs) +{ + GIMPLE_CHECK (gs, GIMPLE_TRANSACTION); + return gs->gsbase.subcode; +} + +/* Set BODY to be the body for the GIMPLE_TRANSACTION statement GS. */ + +static inline void +gimple_transaction_set_body (gimple gs, gimple_seq body) +{ + GIMPLE_CHECK (gs, GIMPLE_TRANSACTION); + gs->gimple_transaction.body = body; +} + +/* Set the label associated with a GIMPLE_TRANSACTION. */ + +static inline void +gimple_transaction_set_label (gimple gs, tree label) +{ + GIMPLE_CHECK (gs, GIMPLE_TRANSACTION); + gs->gimple_transaction.label = label; +} + +/* Set the subcode associated with a GIMPLE_TRANSACTION. */ + +static inline void +gimple_transaction_set_subcode (gimple gs, unsigned int subcode) +{ + GIMPLE_CHECK (gs, GIMPLE_TRANSACTION); + gs->gsbase.subcode = subcode; +} + /* Return a pointer to the return value for GIMPLE_RETURN GS. */ @@ -4248,7 +4697,6 @@ static inline tree * gimple_return_retval_ptr (const_gimple gs) { GIMPLE_CHECK (gs, GIMPLE_RETURN); - gcc_assert (gimple_num_ops (gs) == 1); return gimple_op_ptr (gs, 0); } @@ -4258,7 +4706,6 @@ static inline tree gimple_return_retval (const_gimple gs) { GIMPLE_CHECK (gs, GIMPLE_RETURN); - gcc_assert (gimple_num_ops (gs) == 1); return gimple_op (gs, 0); } @@ -4269,10 +4716,6 @@ static inline void gimple_return_set_retval (gimple gs, tree retval) { GIMPLE_CHECK (gs, GIMPLE_RETURN); - gcc_assert (gimple_num_ops (gs) == 1); - gcc_assert (retval == NULL_TREE - || TREE_CODE (retval) == RESULT_DECL - || is_gimple_val (retval)); gimple_set_op (gs, 0, retval); } @@ -4406,6 +4849,13 @@ gimple_expr_type (const_gimple stmt) return void_type_node; } +/* Return true if TYPE is a suitable type for a scalar register variable. */ + +static inline bool +is_gimple_reg_type (tree type) +{ + return !AGGREGATE_TYPE_P (type); +} /* Return a new iterator pointing to GIMPLE_SEQ's first statement. */ @@ -4429,7 +4879,7 @@ gsi_start_bb (basic_block bb) { gimple_stmt_iterator i; gimple_seq seq; - + seq = bb_seq (bb); i.ptr = gimple_seq_first (seq); i.seq = seq; @@ -4580,7 +5030,7 @@ gsi_last_nondebug_bb (basic_block bb) } /* Return a pointer to the current stmt. - + NOTE: You may want to use gsi_replace on the iterator itself, as this performs additional bookkeeping that will not be done if you simply assign through a pointer returned by gsi_stmt_ptr. */ @@ -4673,6 +5123,12 @@ struct walk_stmt_info will be visited more than once. */ struct pointer_set_t *pset; + /* Operand returned by the callbacks. This is set when calling + walk_gimple_seq. If the walk_stmt_fn or walk_tree_fn callback + returns non-NULL, this field will contain the tree returned by + the last callback. */ + tree callback_result; + /* Indicates whether the operand being examined may be replaced with something that matches is_gimple_val (if true) or something slightly more complicated (if false). "Something" technically @@ -4685,23 +5141,20 @@ struct walk_stmt_info statement 'foo (&var)', the flag VAL_ONLY will initially be set to true, however, when walking &var, the operand of that ADDR_EXPR does not need to be a GIMPLE value. */ - bool val_only; + BOOL_BITFIELD val_only : 1; /* True if we are currently walking the LHS of an assignment. */ - bool is_lhs; + BOOL_BITFIELD is_lhs : 1; /* Optional. Set to true by the callback functions if they made any changes. */ - bool changed; + BOOL_BITFIELD changed : 1; /* True if we're interested in location information. */ - bool want_locations; + BOOL_BITFIELD want_locations : 1; - /* Operand returned by the callbacks. This is set when calling - walk_gimple_seq. If the walk_stmt_fn or walk_tree_fn callback - returns non-NULL, this field will contain the tree returned by - the last callback. */ - tree callback_result; + /* True if we've removed the statement that was processed. */ + BOOL_BITFIELD removed_stmt : 1; }; /* Callback for walk_gimple_stmt. Called for every statement found @@ -4756,4 +5209,17 @@ gimple_alloc_kind (enum gimple_code code) extern void dump_gimple_statistics (void); +/* In gimple-fold.c. */ +void gimplify_and_update_call_from_tree (gimple_stmt_iterator *, tree); +tree gimple_fold_builtin (gimple); +bool fold_stmt (gimple_stmt_iterator *); +bool fold_stmt_inplace (gimple_stmt_iterator *); +tree get_symbol_constant_value (tree); +tree canonicalize_constructor_val (tree); +extern tree maybe_fold_and_comparisons (enum tree_code, tree, tree, + enum tree_code, tree, tree); +extern tree maybe_fold_or_comparisons (enum tree_code, tree, tree, + enum tree_code, tree, tree); + +bool gimple_val_nonnegative_real_p (tree); #endif /* GCC_GIMPLE_H */