/* Gimple IR definitions.
- Copyright 2007, 2008, 2009 Free Software Foundation, Inc.
+ Copyright 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
Contributed by Aldy Hernandez <aldyh@redhat.com>
This file is part of GCC.
#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"
-
-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);
+#include "tree-ssa-alias.h"
/* For each block, the PHI nodes that need to be rewritten are stored into
these vectors. */
GF_CALL_RETURN_SLOT_OPT = 1 << 2,
GF_CALL_TAILCALL = 1 << 3,
GF_CALL_VA_ARG_PACK = 1 << 4,
+ GF_CALL_NOTHROW = 1 << 5,
GF_OMP_PARALLEL_COMBINED = 1 << 0,
/* True on an GIMPLE_OMP_RETURN statement if the return does not require
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 gimplify_seq_add_stmt (gimple_seq *, gimple);
+
/* Allocate a new sequence and initialize its first element with STMT. */
static inline gimple_seq
};
+/* 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 ]
+ 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 {
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;
void gimple_seq_add_seq (gimple_seq *, gimple_seq);
gimple_seq gimple_seq_copy (gimple_seq);
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);
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_relevant_ref_binfo (tree ref, tree known_binfo);
+tree gimple_fold_obj_type_ref_known_binfo (HOST_WIDE_INT, tree);
/* Returns true iff T is a valid GIMPLE statement. */
extern bool is_gimple_stmt (tree);
extern tree get_call_expr_in (tree t);
extern void recalculate_side_effects (tree);
-extern bool compare_field_offset (tree, tree);
+extern bool gimple_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 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 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 *);
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];
}
{
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);
}
}
+/* 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
}
+/* 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. */
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);
}
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;
}
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);
}
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);
+tree maybe_fold_offset_to_reference (location_t, tree, tree, tree);
+tree maybe_fold_offset_to_address (location_t, tree, tree, tree);
+tree maybe_fold_stmt_addition (location_t, tree, tree, tree);
+tree get_symbol_constant_value (tree);
+bool may_propagate_address_into_dereference (tree, tree);
+
+
#endif /* GCC_GIMPLE_H */