+2013-11-20 Andrew MacLeod <amacleod@redhat.com>
+
+ * gimplify.h (gimplify_hasher : typed_free_remove, struct gimplify_ctx):
+ Move to gimplify.c.
+ (free_gimplify_stack): Add prototype.
+ * gimplify.c (gimplify_hasher:typed_free_remove): Relocate here.
+ (struct gimplify_ctx): Relocate here.
+ (gimplify_ctxp): Make static.
+ (ctx_pool, ctx_alloc, ctx_free, free_gimplify_stack): New. Manage a
+ list of struct gimplify_ctx.
+ (push_gimplify_context): Add default parameters and allocate a struct
+ from the pool.
+ (pop_gimplify_context): Free a struct back to the pool.
+ (gimplify_scan_omp_clauses, gimplify_omp_parallel, gimplify_omp_task,
+ gimplify_omp_workshare, gimplify_transaction, gimplify_body): Don't
+ use a local 'struct gimplify_ctx'.
+ * cgraphunit.c (expand_all_functions): call free_gimplify_stack.
+ * gimplify-me.c (force_gimple_operand_1, gimple_regimplify_operands):
+ Likewise.
+ * omp-low.c (lower_omp_sections, lower_omp_single, lower_omp_master,
+ lower_omp_ordered, lower_omp_critical, lower_omp_for,
+ create_task_copyfn, lower_omp_taskreg, lower_omp_target,
+ lower_omp_teams, execute_lower_omp): Likewise.
+ * gimple-fold.c (gimplify_and_update_call_from_tree): Likewise.
+ * tree-inline.c (optimize_inline_calls): Likewise.
+
2013-11-20 Bill Schmidt <wschmidt@linux.vnet.ibm.com>
* config/rs6000/vsx.md (vsx_set_<mode>): Adjust for little endian.
#include "context.h"
#include "pass_manager.h"
#include "tree-nested.h"
+#include "gimplify.h"
/* Queue of cgraph nodes scheduled to be added into cgraph. This is a
secondary queue used during optimization to accommodate passes that
}
}
cgraph_process_new_functions ();
+ free_gimplify_stack ();
free (order);
gimple stmt, new_stmt;
gimple_stmt_iterator i;
gimple_seq stmts = NULL;
- struct gimplify_ctx gctx;
gimple laststore;
tree reaching_vuse;
gcc_assert (is_gimple_call (stmt));
- push_gimplify_context (&gctx);
- gctx.into_ssa = gimple_in_ssa_p (cfun);
+ push_gimplify_context (gimple_in_ssa_p (cfun));
lhs = gimple_call_lhs (stmt);
if (lhs == NULL_TREE)
gimple_predicate gimple_test_f, tree var)
{
enum gimplify_status ret;
- struct gimplify_ctx gctx;
location_t saved_location;
*stmts = NULL;
&& (*gimple_test_f) (expr))
return expr;
- push_gimplify_context (&gctx);
- gimplify_ctxp->into_ssa = gimple_in_ssa_p (cfun);
- gimplify_ctxp->allow_rhs_cond_expr = true;
+ push_gimplify_context (gimple_in_ssa_p (cfun), true);
saved_location = input_location;
input_location = UNKNOWN_LOCATION;
if (var)
{
- if (gimplify_ctxp->into_ssa
- && is_gimple_reg (var))
+ if (gimple_in_ssa_p (cfun) && is_gimple_reg (var))
var = make_ssa_name (var, NULL);
expr = build2 (MODIFY_EXPR, TREE_TYPE (var), var, expr);
}
tree lhs;
gimple_seq pre = NULL;
gimple post_stmt = NULL;
- struct gimplify_ctx gctx;
- push_gimplify_context (&gctx);
- gimplify_ctxp->into_ssa = gimple_in_ssa_p (cfun);
+ push_gimplify_context (gimple_in_ssa_p (cfun));
switch (gimple_code (stmt))
{
ORT_TARGET = 32
};
+/* Gimplify hashtable helper. */
+
+struct gimplify_hasher : typed_free_remove <elt_t>
+{
+ typedef elt_t value_type;
+ typedef elt_t compare_type;
+ static inline hashval_t hash (const value_type *);
+ static inline bool equal (const value_type *, const compare_type *);
+};
+
+struct gimplify_ctx
+{
+ struct gimplify_ctx *prev_context;
+
+ vec<gimple> bind_expr_stack;
+ tree temps;
+ gimple_seq conditional_cleanups;
+ tree exit_label;
+ tree return_temp;
+
+ vec<tree> case_labels;
+ /* The formal temporary table. Should this be persistent? */
+ hash_table <gimplify_hasher> temp_htab;
+
+ int conditions;
+ bool save_stack;
+ bool into_ssa;
+ bool allow_rhs_cond_expr;
+ bool in_cleanup_point_expr;
+};
+
struct gimplify_omp_ctx
{
struct gimplify_omp_ctx *outer_context;
bool combined_loop;
};
-struct gimplify_ctx *gimplify_ctxp;
+static struct gimplify_ctx *gimplify_ctxp;
static struct gimplify_omp_ctx *gimplify_omp_ctxp;
-
/* Forward declaration. */
static enum gimplify_status gimplify_compound_expr (tree *, gimple_seq *, bool);
gsi_insert_seq_after_without_update (&si, src, GSI_NEW_STMT);
}
+
+/* Pointer to a list of allocated gimplify_ctx structs to be used for pushing
+ and popping gimplify contexts. */
+
+static struct gimplify_ctx *ctx_pool = NULL;
+
+/* Return a gimplify context struct from the pool. */
+
+static inline struct gimplify_ctx *
+ctx_alloc (void)
+{
+ struct gimplify_ctx * c = ctx_pool;
+
+ if (c)
+ ctx_pool = c->prev_context;
+ else
+ c = XNEW (struct gimplify_ctx);
+
+ memset (c, '\0', sizeof (*c));
+ return c;
+}
+
+/* Put gimplify context C back into the pool. */
+
+static inline void
+ctx_free (struct gimplify_ctx *c)
+{
+ c->prev_context = ctx_pool;
+ ctx_pool = c;
+}
+
+/* Free allocated ctx stack memory. */
+
+void
+free_gimplify_stack (void)
+{
+ struct gimplify_ctx *c;
+
+ while ((c = ctx_pool))
+ {
+ ctx_pool = c->prev_context;
+ free (c);
+ }
+}
+
+
/* Set up a context for the gimplifier. */
void
-push_gimplify_context (struct gimplify_ctx *c)
+push_gimplify_context (bool in_ssa, bool rhs_cond_ok)
{
- memset (c, '\0', sizeof (*c));
+ struct gimplify_ctx *c = ctx_alloc ();
+
c->prev_context = gimplify_ctxp;
gimplify_ctxp = c;
+ gimplify_ctxp->into_ssa = in_ssa;
+ gimplify_ctxp->allow_rhs_cond_expr = rhs_cond_ok;
}
/* Tear down a context for the gimplifier. If BODY is non-null, then
if (c->temp_htab.is_created ())
c->temp_htab.dispose ();
+ ctx_free (c);
}
/* Push a GIMPLE_BIND tuple onto the stack of bindings. */
enum omp_region_type region_type)
{
struct gimplify_omp_ctx *ctx, *outer_ctx;
- struct gimplify_ctx gctx;
tree c;
ctx = new_omp_context (region_type);
omp_add_variable (ctx, OMP_CLAUSE_REDUCTION_PLACEHOLDER (c),
GOVD_LOCAL | GOVD_SEEN);
gimplify_omp_ctxp = ctx;
- push_gimplify_context (&gctx);
+ push_gimplify_context ();
OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c) = NULL;
OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c) = NULL;
&OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c));
pop_gimplify_context
(gimple_seq_first_stmt (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c)));
- push_gimplify_context (&gctx);
+ push_gimplify_context ();
gimplify_and_add (OMP_CLAUSE_REDUCTION_MERGE (c),
&OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c));
pop_gimplify_context
&& OMP_CLAUSE_LASTPRIVATE_STMT (c))
{
gimplify_omp_ctxp = ctx;
- push_gimplify_context (&gctx);
+ push_gimplify_context ();
if (TREE_CODE (OMP_CLAUSE_LASTPRIVATE_STMT (c)) != BIND_EXPR)
{
tree bind = build3 (BIND_EXPR, void_type_node, NULL,
tree expr = *expr_p;
gimple g;
gimple_seq body = NULL;
- struct gimplify_ctx gctx;
gimplify_scan_omp_clauses (&OMP_PARALLEL_CLAUSES (expr), pre_p,
OMP_PARALLEL_COMBINED (expr)
? ORT_COMBINED_PARALLEL
: ORT_PARALLEL);
- push_gimplify_context (&gctx);
+ push_gimplify_context ();
g = gimplify_and_return_first (OMP_PARALLEL_BODY (expr), &body);
if (gimple_code (g) == GIMPLE_BIND)
tree expr = *expr_p;
gimple g;
gimple_seq body = NULL;
- struct gimplify_ctx gctx;
gimplify_scan_omp_clauses (&OMP_TASK_CLAUSES (expr), pre_p,
find_omp_clause (OMP_TASK_CLAUSES (expr),
OMP_CLAUSE_UNTIED)
? ORT_UNTIED_TASK : ORT_TASK);
- push_gimplify_context (&gctx);
+ push_gimplify_context ();
g = gimplify_and_return_first (OMP_TASK_BODY (expr), &body);
if (gimple_code (g) == GIMPLE_BIND)
gimplify_scan_omp_clauses (&OMP_CLAUSES (expr), pre_p, ort);
if (ort == ORT_TARGET || ort == ORT_TARGET_DATA)
{
- struct gimplify_ctx gctx;
- push_gimplify_context (&gctx);
+ push_gimplify_context ();
gimple g = gimplify_and_return_first (OMP_BODY (expr), &body);
if (gimple_code (g) == GIMPLE_BIND)
pop_gimplify_context (g);
tree expr = *expr_p, temp, tbody = TRANSACTION_EXPR_BODY (expr);
gimple g;
gimple_seq body = NULL;
- struct gimplify_ctx gctx;
int subcode = 0;
/* Wrap the transaction body in a BIND_EXPR so we have a context
TRANSACTION_EXPR_BODY (expr) = bind;
}
- push_gimplify_context (&gctx);
+ push_gimplify_context ();
temp = voidify_wrapper_expr (*expr_p, NULL);
g = gimplify_and_return_first (TRANSACTION_EXPR_BODY (expr), &body);
location_t saved_location = input_location;
gimple_seq parm_stmts, seq;
gimple outer_bind;
- struct gimplify_ctx gctx;
struct cgraph_node *cgn;
timevar_push (TV_TREE_GIMPLIFY);
default_rtl_profile ();
gcc_assert (gimplify_ctxp == NULL);
- push_gimplify_context (&gctx);
+ push_gimplify_context ();
if (flag_openmp)
{
GS_OK = 0, /* We did something, maybe more to do. */
GS_ALL_DONE = 1 /* The expression is fully gimplified. */
};
-/* Gimplify hashtable helper. */
-struct gimplify_hasher : typed_free_remove <elt_t>
-{
- typedef elt_t value_type;
- typedef elt_t compare_type;
- static inline hashval_t hash (const value_type *);
- static inline bool equal (const value_type *, const compare_type *);
-};
-
-struct gimplify_ctx
-{
- struct gimplify_ctx *prev_context;
-
- vec<gimple> bind_expr_stack;
- tree temps;
- gimple_seq conditional_cleanups;
- tree exit_label;
- tree return_temp;
-
- vec<tree> case_labels;
- /* The formal temporary table. Should this be persistent? */
- hash_table <gimplify_hasher> temp_htab;
-
- int conditions;
- bool save_stack;
- bool into_ssa;
- bool allow_rhs_cond_expr;
- bool in_cleanup_point_expr;
-};
-
-extern struct gimplify_ctx *gimplify_ctxp;
-extern void push_gimplify_context (struct gimplify_ctx *);
+extern void free_gimplify_stack (void);
+extern void push_gimplify_context (bool in_ssa = false,
+ bool rhs_cond_ok = false);
extern void pop_gimplify_context (gimple);
extern gimple gimple_current_bind_expr (void);
extern vec<gimple> gimple_bind_expr_stack (void);
gimple_stmt_iterator tgsi;
gimple stmt, new_stmt, bind, t;
gimple_seq ilist, dlist, olist, new_body;
- struct gimplify_ctx gctx;
stmt = gsi_stmt (*gsi_p);
- push_gimplify_context (&gctx);
+ push_gimplify_context ();
dlist = NULL;
ilist = NULL;
tree block;
gimple t, bind, single_stmt = gsi_stmt (*gsi_p);
gimple_seq bind_body, bind_body_tail = NULL, dlist;
- struct gimplify_ctx gctx;
- push_gimplify_context (&gctx);
+ push_gimplify_context ();
block = make_node (BLOCK);
bind = gimple_build_bind (NULL, NULL, block);
gimple stmt = gsi_stmt (*gsi_p), bind;
location_t loc = gimple_location (stmt);
gimple_seq tseq;
- struct gimplify_ctx gctx;
- push_gimplify_context (&gctx);
+ push_gimplify_context ();
block = make_node (BLOCK);
bind = gimple_build_bind (NULL, NULL, block);
{
tree block;
gimple stmt = gsi_stmt (*gsi_p), bind, x;
- struct gimplify_ctx gctx;
- push_gimplify_context (&gctx);
+ push_gimplify_context ();
block = make_node (BLOCK);
bind = gimple_build_bind (NULL, NULL, block);
gimple stmt = gsi_stmt (*gsi_p), bind;
location_t loc = gimple_location (stmt);
gimple_seq tbody;
- struct gimplify_ctx gctx;
name = gimple_omp_critical_name (stmt);
if (name)
unlock = build_call_expr_loc (loc, unlock, 0);
}
- push_gimplify_context (&gctx);
+ push_gimplify_context ();
block = make_node (BLOCK);
bind = gimple_build_bind (NULL, NULL, block);
gimple stmt = gsi_stmt (*gsi_p), new_stmt;
gimple_seq omp_for_body, body, dlist;
size_t i;
- struct gimplify_ctx gctx;
- push_gimplify_context (&gctx);
+ push_gimplify_context ();
lower_omp (gimple_omp_for_pre_body_ptr (stmt), ctx);
bool record_needs_remap = false, srecord_needs_remap = false;
splay_tree_node n;
struct omp_taskcopy_context tcctx;
- struct gimplify_ctx gctx;
location_t loc = gimple_location (task_stmt);
child_fn = gimple_omp_task_copy_fn (task_stmt);
DECL_CONTEXT (t) = child_fn;
/* Populate the function. */
- push_gimplify_context (&gctx);
+ push_gimplify_context ();
push_cfun (child_cfun);
bind = build3 (BIND_EXPR, void_type_node, NULL, NULL, NULL);
gimple stmt = gsi_stmt (*gsi_p);
gimple par_bind, bind, dep_bind = NULL;
gimple_seq par_body, olist, ilist, par_olist, par_rlist, par_ilist, new_body;
- struct gimplify_ctx gctx, dep_gctx;
location_t loc = gimple_location (stmt);
clauses = gimple_omp_taskreg_clauses (stmt);
if (gimple_code (stmt) == GIMPLE_OMP_TASK
&& find_omp_clause (clauses, OMP_CLAUSE_DEPEND))
{
- push_gimplify_context (&dep_gctx);
+ push_gimplify_context ();
dep_bind = gimple_build_bind (NULL, NULL, make_node (BLOCK));
lower_depend_clauses (stmt, &dep_ilist, &dep_olist);
}
if (ctx->srecord_type)
create_task_copyfn (stmt, ctx);
- push_gimplify_context (&gctx);
+ push_gimplify_context ();
par_olist = NULL;
par_ilist = NULL;
gimple stmt = gsi_stmt (*gsi_p);
gimple tgt_bind = NULL, bind;
gimple_seq tgt_body = NULL, olist, ilist, new_body;
- struct gimplify_ctx gctx;
location_t loc = gimple_location (stmt);
int kind = gimple_omp_target_kind (stmt);
unsigned int map_cnt = 0;
tgt_body = gimple_omp_body (stmt);
child_fn = ctx->cb.dst_fn;
- push_gimplify_context (&gctx);
+ push_gimplify_context ();
for (c = clauses; c ; c = OMP_CLAUSE_CHAIN (c))
switch (OMP_CLAUSE_CODE (c))
lower_omp_teams (gimple_stmt_iterator *gsi_p, omp_context *ctx)
{
gimple teams_stmt = gsi_stmt (*gsi_p);
- struct gimplify_ctx gctx;
- push_gimplify_context (&gctx);
+ push_gimplify_context ();
tree block = make_node (BLOCK);
gimple bind = gimple_build_bind (NULL, NULL, block);
if (all_contexts->root)
{
- struct gimplify_ctx gctx;
-
if (task_shared_vars)
- push_gimplify_context (&gctx);
+ push_gimplify_context ();
lower_omp (&body, NULL);
if (task_shared_vars)
pop_gimplify_context (NULL);
copy_body_data id;
basic_block bb;
int last = n_basic_blocks_for_fn (cfun);
- struct gimplify_ctx gctx;
bool inlined_p = false;
/* Clear out ID. */
id.transform_lang_insert_block = NULL;
id.statements_to_fold = pointer_set_create ();
- push_gimplify_context (&gctx);
+ push_gimplify_context ();
/* We make no attempts to keep dominance info up-to-date. */
free_dominance_info (CDI_DOMINATORS);
projects / platform / upstream / gcc.git / commitdiff