/* Index variable. */
tree index;
-
+
/* Initial value. */
tree initial;
/* Final value. */
tree final;
-
+
/* Increment. */
tree incr;
};
};
-/* 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. */
union GTY ((desc ("gimple_statement_structure (&%h)"))) 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_omp GTY ((tag ("GSS_OMP"))) omp;
struct gimple_statement_bind GTY ((tag ("GSS_BIND"))) gimple_bind;
/* 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);
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);
extern tree get_call_expr_in (tree t);
extern void recalculate_side_effects (tree);
-extern void gimple_force_type_merge (tree, tree);
-extern int gimple_types_compatible_p (tree, tree);
+extern bool compare_field_offset (tree, tree);
extern tree gimple_register_type (tree);
extern void print_gimple_types_stats (void);
+extern void free_gimple_type_tables (void);
extern tree gimple_unsigned_type (tree);
extern tree gimple_signed_type (tree);
extern alias_set_type gimple_get_alias_set (tree);
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
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;
static inline enum gimple_statement_structure_enum
gss_for_code (enum gimple_code code)
{
+#ifdef ENABLE_CHECKING
gcc_assert ((unsigned int)code < LAST_AND_UNUSED_GIMPLE_CODE);
+#endif
return gss_for_code_[code];
}
return false;
}
}
-
+
/* Return the basic block holding statement 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;
}
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;
}
{
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. */
{
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. */
{
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. */
{
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. */
gimple_set_vuse (gimple g, tree vuse)
{
gcc_assert (gimple_has_mem_ops (g));
- g->gsmem.membase.vuse = vuse;
+ g->gsmembase.vuse = vuse;
}
/* Set the single VDEF operand of the statement G. */
gimple_set_vdef (gimple g, tree vdef)
{
gcc_assert (gimple_has_mem_ops (g));
- g->gsmem.membase.vdef = vdef;
+ g->gsmembase.vdef = vdef;
}
{
if (gimple_has_ops (gs))
{
+#ifdef ENABLE_CHECKING
gcc_assert (i < gimple_num_ops (gs));
+#endif
return gimple_ops (CONST_CAST_GIMPLE (gs))[i];
}
else
{
if (gimple_has_ops (gs))
{
+#ifdef ENABLE_CHECKING
gcc_assert (i < gimple_num_ops (gs));
+#endif
return gimple_ops (CONST_CAST_GIMPLE (gs)) + i;
}
else
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)
{
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);
}
{
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);
}
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;
gimple_call_set_fn (gimple gs, tree fn)
{
GIMPLE_CHECK (gs, GIMPLE_CALL);
- gcc_assert (is_gimple_operand (fn));
gimple_set_op (gs, 1, fn);
}
gimple_call_set_fndecl (gimple gs, tree decl)
{
GIMPLE_CHECK (gs, GIMPLE_CALL);
- gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
gimple_set_op (gs, 1, build_fold_addr_expr_loc (gimple_location (gs), decl));
}
{
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 TREE_OPERAND (addr, 0);
return NULL_TREE;
}
tree type = TREE_TYPE (fn);
/* See through the pointer. */
- gcc_assert (POINTER_TYPE_P (type));
type = TREE_TYPE (type);
- gcc_assert (TREE_CODE (type) == FUNCTION_TYPE
- || TREE_CODE (type) == METHOD_TYPE);
-
/* The type returned by a FUNCTION_DECL is the type of its
function type. */
return TREE_TYPE (type);
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);
}
unsigned num_ops;
GIMPLE_CHECK (gs, GIMPLE_CALL);
num_ops = gimple_num_ops (gs);
- gcc_assert (num_ops >= 3);
return num_ops - 3;
}
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);
}
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;
}
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);
}
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);
}
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);
}
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);
}
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);
}
/* 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);
}
gimple_debug_bind_get_var (gimple dbg)
{
GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
+#ifdef ENABLE_CHECKING
gcc_assert (gimple_debug_bind_p (dbg));
+#endif
return gimple_op (dbg, 0);
}
gimple_debug_bind_get_value (gimple dbg)
{
GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
+#ifdef ENABLE_CHECKING
gcc_assert (gimple_debug_bind_p (dbg));
+#endif
return gimple_op (dbg, 1);
}
gimple_debug_bind_get_value_ptr (gimple dbg)
{
GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
+#ifdef ENABLE_CHECKING
gcc_assert (gimple_debug_bind_p (dbg));
+#endif
return gimple_op_ptr (dbg, 1);
}
gimple_debug_bind_set_var (gimple dbg, tree var)
{
GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
+#ifdef ENABLE_CHECKING
gcc_assert (gimple_debug_bind_p (dbg));
+#endif
gimple_set_op (dbg, 0, var);
}
gimple_debug_bind_set_value (gimple dbg, tree value)
{
GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
+#ifdef ENABLE_CHECKING
gcc_assert (gimple_debug_bind_p (dbg));
+#endif
gimple_set_op (dbg, 1, value);
}
gimple_debug_bind_reset_value (gimple dbg)
{
GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
+#ifdef ENABLE_CHECKING
gcc_assert (gimple_debug_bind_p (dbg));
+#endif
gimple_set_op (dbg, 1, GIMPLE_DEBUG_BIND_NOVALUE);
}
gimple_debug_bind_has_value_p (gimple dbg)
{
GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
+#ifdef ENABLE_CHECKING
gcc_assert (gimple_debug_bind_p (dbg));
+#endif
return gimple_op (dbg, 1) != GIMPLE_DEBUG_BIND_NOVALUE;
}
/* 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;
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);
}
gimple_return_retval (const_gimple gs)
{
GIMPLE_CHECK (gs, GIMPLE_RETURN);
- gcc_assert (gimple_num_ops (gs) == 1);
return gimple_op (gs, 0);
}
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);
}
{
gimple_stmt_iterator i;
gimple_seq seq;
-
+
seq = bb_seq (bb);
i.ptr = gimple_seq_first (seq);
i.seq = seq;
}
/* 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. */
OSDN Git Service
