* 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):
Don't use a local 'struct gimplify_ctx'.
* 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.
===================================================================
*************** enum gimplify_status {
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 pop_gimplify_context (gimple);
extern gimple gimple_current_bind_expr (void);
extern vec<gimple> gimple_bind_expr_stack (void);
GS_OK = 0, /* We did something, maybe more to do. */
GS_ALL_DONE = 1 /* The expression is fully gimplified. */
};
! 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);
===================================================================
*************** enum omp_region_type
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;
*************** struct gimplify_omp_ctx
bool combined_loop;
};
! 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);
bool combined_loop;
};
! 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);
*************** gimplify_seq_add_seq (gimple_seq *dst_p,
gsi_insert_seq_after_without_update (&si, src, GSI_NEW_STMT);
}
/* Set up a context for the gimplifier. */
void
! push_gimplify_context (struct gimplify_ctx *c)
{
! memset (c, '\0', sizeof (*c));
c->prev_context = gimplify_ctxp;
gimplify_ctxp = c;
}
/* Tear down a context for the gimplifier. If BODY is non-null, then
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 (bool in_ssa, bool rhs_cond_ok)
{
! 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
*************** pop_gimplify_context (gimple body)
if (c->temp_htab.is_created ())
c->temp_htab.dispose ();
+ ctx_free (c);
}
/* Push a GIMPLE_BIND tuple onto the stack of bindings. */
*************** gimplify_scan_omp_clauses (tree *list_p,
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);
*************** gimplify_scan_omp_clauses (tree *list_p,
omp_add_variable (ctx, OMP_CLAUSE_REDUCTION_PLACEHOLDER (c),
GOVD_LOCAL | GOVD_SEEN);
gimplify_omp_ctxp = ctx;
! push_gimplify_context (&gctx);
OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c) = NULL;
OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c) = NULL;
omp_add_variable (ctx, OMP_CLAUSE_REDUCTION_PLACEHOLDER (c),
GOVD_LOCAL | GOVD_SEEN);
gimplify_omp_ctxp = ctx;
! push_gimplify_context ();
OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c) = NULL;
OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c) = NULL;
*************** gimplify_scan_omp_clauses (tree *list_p,
&OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c));
pop_gimplify_context
(gimple_seq_first_stmt (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c)));
! push_gimplify_context (&gctx);
gimplify_and_add (OMP_CLAUSE_REDUCTION_MERGE (c),
&OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c));
pop_gimplify_context
&OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c));
pop_gimplify_context
(gimple_seq_first_stmt (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c)));
! push_gimplify_context ();
gimplify_and_add (OMP_CLAUSE_REDUCTION_MERGE (c),
&OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c));
pop_gimplify_context
*************** gimplify_scan_omp_clauses (tree *list_p,
&& OMP_CLAUSE_LASTPRIVATE_STMT (c))
{
gimplify_omp_ctxp = ctx;
! push_gimplify_context (&gctx);
if (TREE_CODE (OMP_CLAUSE_LASTPRIVATE_STMT (c)) != BIND_EXPR)
{
tree bind = build3 (BIND_EXPR, void_type_node, NULL,
&& OMP_CLAUSE_LASTPRIVATE_STMT (c))
{
gimplify_omp_ctxp = ctx;
! push_gimplify_context ();
if (TREE_CODE (OMP_CLAUSE_LASTPRIVATE_STMT (c)) != BIND_EXPR)
{
tree bind = build3 (BIND_EXPR, void_type_node, NULL,
*************** gimplify_omp_parallel (tree *expr_p, gim
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);
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;
gimplify_scan_omp_clauses (&OMP_PARALLEL_CLAUSES (expr), pre_p,
OMP_PARALLEL_COMBINED (expr)
? ORT_COMBINED_PARALLEL
: ORT_PARALLEL);
! push_gimplify_context ();
g = gimplify_and_return_first (OMP_PARALLEL_BODY (expr), &body);
if (gimple_code (g) == GIMPLE_BIND)
*************** gimplify_omp_task (tree *expr_p, gimple_
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);
g = gimplify_and_return_first (OMP_TASK_BODY (expr), &body);
if (gimple_code (g) == GIMPLE_BIND)
tree expr = *expr_p;
gimple g;
gimple_seq body = NULL;
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 ();
g = gimplify_and_return_first (OMP_TASK_BODY (expr), &body);
if (gimple_code (g) == GIMPLE_BIND)
*************** gimplify_omp_workshare (tree *expr_p, gi
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);
gimple g = gimplify_and_return_first (OMP_BODY (expr), &body);
if (gimple_code (g) == GIMPLE_BIND)
pop_gimplify_context (g);
gimplify_scan_omp_clauses (&OMP_CLAUSES (expr), pre_p, ort);
if (ort == ORT_TARGET || ort == ORT_TARGET_DATA)
{
! push_gimplify_context ();
gimple g = gimplify_and_return_first (OMP_BODY (expr), &body);
if (gimple_code (g) == GIMPLE_BIND)
pop_gimplify_context (g);
*************** gimplify_transaction (tree *expr_p, gimp
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
*************** gimplify_transaction (tree *expr_p, gimp
TRANSACTION_EXPR_BODY (expr) = bind;
}
! push_gimplify_context (&gctx);
temp = voidify_wrapper_expr (*expr_p, NULL);
g = gimplify_and_return_first (TRANSACTION_EXPR_BODY (expr), &body);
TRANSACTION_EXPR_BODY (expr) = bind;
}
! push_gimplify_context ();
temp = voidify_wrapper_expr (*expr_p, NULL);
g = gimplify_and_return_first (TRANSACTION_EXPR_BODY (expr), &body);
*************** gimplify_body (tree fndecl, bool do_parm
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);
*************** gimplify_body (tree fndecl, bool do_parm
default_rtl_profile ();
gcc_assert (gimplify_ctxp == NULL);
! push_gimplify_context (&gctx);
if (flag_openmp)
{
default_rtl_profile ();
gcc_assert (gimplify_ctxp == NULL);
! push_gimplify_context ();
if (flag_openmp)
{
===================================================================
*************** along with GCC; see the file COPYING3.
#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
*************** expand_all_functions (void)
}
}
cgraph_process_new_functions ();
+ free_gimplify_stack ();
free (order);
===================================================================
*************** force_gimple_operand_1 (tree expr, gimpl
gimple_predicate gimple_test_f, tree var)
{
enum gimplify_status ret;
- struct gimplify_ctx gctx;
location_t saved_location;
*stmts = NULL;
*************** force_gimple_operand_1 (tree expr, gimpl
&& (*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;
saved_location = input_location;
input_location = UNKNOWN_LOCATION;
if (var)
{
! if (gimplify_ctxp->into_ssa
! && is_gimple_reg (var))
var = make_ssa_name (var, NULL);
expr = build2 (MODIFY_EXPR, TREE_TYPE (var), var, expr);
}
&& (*gimple_test_f) (expr))
return expr;
! push_gimplify_context (gimple_in_ssa_p (cfun), true);
saved_location = input_location;
input_location = UNKNOWN_LOCATION;
if (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);
}
*************** gimple_regimplify_operands (gimple stmt,
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);
switch (gimple_code (stmt))
{
tree lhs;
gimple_seq pre = NULL;
gimple post_stmt = NULL;
! push_gimplify_context (gimple_in_ssa_p (cfun));
switch (gimple_code (stmt))
{
===================================================================
*************** gimplify_and_update_call_from_tree (gimp
gimple stmt, new_stmt;
gimple_stmt_iterator i;
gimple_seq stmts = NULL;
- struct gimplify_ctx gctx;
gimple laststore;
tree reaching_vuse;
*************** gimplify_and_update_call_from_tree (gimp
gcc_assert (is_gimple_call (stmt));
! push_gimplify_context (&gctx);
! gctx.into_ssa = gimple_in_ssa_p (cfun);
lhs = gimple_call_lhs (stmt);
if (lhs == NULL_TREE)
gcc_assert (is_gimple_call (stmt));
! push_gimplify_context (gimple_in_ssa_p (cfun));
lhs = gimple_call_lhs (stmt);
if (lhs == NULL_TREE)
===================================================================
*************** lower_omp_sections (gimple_stmt_iterator
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);
dlist = NULL;
ilist = NULL;
gimple_stmt_iterator tgsi;
gimple stmt, new_stmt, bind, t;
gimple_seq ilist, dlist, olist, new_body;
stmt = gsi_stmt (*gsi_p);
! push_gimplify_context ();
dlist = NULL;
ilist = NULL;
*************** lower_omp_single (gimple_stmt_iterator *
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);
block = make_node (BLOCK);
bind = gimple_build_bind (NULL, NULL, block);
tree block;
gimple t, bind, single_stmt = gsi_stmt (*gsi_p);
gimple_seq bind_body, bind_body_tail = NULL, dlist;
! push_gimplify_context ();
block = make_node (BLOCK);
bind = gimple_build_bind (NULL, NULL, block);
*************** lower_omp_master (gimple_stmt_iterator *
gimple stmt = gsi_stmt (*gsi_p), bind;
location_t loc = gimple_location (stmt);
gimple_seq tseq;
- struct gimplify_ctx gctx;
! push_gimplify_context (&gctx);
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;
! push_gimplify_context ();
block = make_node (BLOCK);
bind = gimple_build_bind (NULL, NULL, block);
*************** lower_omp_ordered (gimple_stmt_iterator
{
tree block;
gimple stmt = gsi_stmt (*gsi_p), bind, x;
- struct gimplify_ctx gctx;
! push_gimplify_context (&gctx);
block = make_node (BLOCK);
bind = gimple_build_bind (NULL, NULL, block);
{
tree block;
gimple stmt = gsi_stmt (*gsi_p), bind, x;
! push_gimplify_context ();
block = make_node (BLOCK);
bind = gimple_build_bind (NULL, NULL, block);
*************** lower_omp_critical (gimple_stmt_iterator
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)
*************** lower_omp_critical (gimple_stmt_iterator
unlock = build_call_expr_loc (loc, unlock, 0);
}
! push_gimplify_context (&gctx);
block = make_node (BLOCK);
bind = gimple_build_bind (NULL, NULL, block);
unlock = build_call_expr_loc (loc, unlock, 0);
}
! push_gimplify_context ();
block = make_node (BLOCK);
bind = gimple_build_bind (NULL, NULL, block);
*************** lower_omp_for (gimple_stmt_iterator *gsi
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);
lower_omp (gimple_omp_for_pre_body_ptr (stmt), ctx);
gimple stmt = gsi_stmt (*gsi_p), new_stmt;
gimple_seq omp_for_body, body, dlist;
size_t i;
! push_gimplify_context ();
lower_omp (gimple_omp_for_pre_body_ptr (stmt), ctx);
*************** create_task_copyfn (gimple task_stmt, om
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);
*************** create_task_copyfn (gimple task_stmt, om
DECL_CONTEXT (t) = child_fn;
/* Populate the function. */
! push_gimplify_context (&gctx);
push_cfun (child_cfun);
bind = build3 (BIND_EXPR, void_type_node, NULL, NULL, NULL);
DECL_CONTEXT (t) = child_fn;
/* Populate the function. */
! push_gimplify_context ();
push_cfun (child_cfun);
bind = build3 (BIND_EXPR, void_type_node, NULL, NULL, NULL);
*************** lower_omp_taskreg (gimple_stmt_iterator
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);
*************** lower_omp_taskreg (gimple_stmt_iterator
if (gimple_code (stmt) == GIMPLE_OMP_TASK
&& find_omp_clause (clauses, OMP_CLAUSE_DEPEND))
{
! push_gimplify_context (&dep_gctx);
dep_bind = gimple_build_bind (NULL, NULL, make_node (BLOCK));
lower_depend_clauses (stmt, &dep_ilist, &dep_olist);
}
if (gimple_code (stmt) == GIMPLE_OMP_TASK
&& find_omp_clause (clauses, OMP_CLAUSE_DEPEND))
{
! push_gimplify_context ();
dep_bind = gimple_build_bind (NULL, NULL, make_node (BLOCK));
lower_depend_clauses (stmt, &dep_ilist, &dep_olist);
}
*************** lower_omp_taskreg (gimple_stmt_iterator
if (ctx->srecord_type)
create_task_copyfn (stmt, ctx);
! push_gimplify_context (&gctx);
par_olist = NULL;
par_ilist = NULL;
if (ctx->srecord_type)
create_task_copyfn (stmt, ctx);
! push_gimplify_context ();
par_olist = NULL;
par_ilist = NULL;
*************** lower_omp_target (gimple_stmt_iterator *
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;
*************** lower_omp_target (gimple_stmt_iterator *
tgt_body = gimple_omp_body (stmt);
child_fn = ctx->cb.dst_fn;
! push_gimplify_context (&gctx);
for (c = clauses; c ; c = OMP_CLAUSE_CHAIN (c))
switch (OMP_CLAUSE_CODE (c))
tgt_body = gimple_omp_body (stmt);
child_fn = ctx->cb.dst_fn;
! push_gimplify_context ();
for (c = clauses; c ; c = OMP_CLAUSE_CHAIN (c))
switch (OMP_CLAUSE_CODE (c))
*************** static void
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);
tree block = make_node (BLOCK);
gimple bind = gimple_build_bind (NULL, NULL, block);
lower_omp_teams (gimple_stmt_iterator *gsi_p, omp_context *ctx)
{
gimple teams_stmt = gsi_stmt (*gsi_p);
! push_gimplify_context ();
tree block = make_node (BLOCK);
gimple bind = gimple_build_bind (NULL, NULL, block);
*************** execute_lower_omp (void)
if (all_contexts->root)
{
- struct gimplify_ctx gctx;
-
if (task_shared_vars)
! push_gimplify_context (&gctx);
lower_omp (&body, NULL);
if (task_shared_vars)
pop_gimplify_context (NULL);
if (all_contexts->root)
{
if (task_shared_vars)
! push_gimplify_context ();
lower_omp (&body, NULL);
if (task_shared_vars)
pop_gimplify_context (NULL);
===================================================================
*************** optimize_inline_calls (tree fn)
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. */
*************** optimize_inline_calls (tree fn)
id.transform_lang_insert_block = NULL;
id.statements_to_fold = pointer_set_create ();
! push_gimplify_context (&gctx);
/* We make no attempts to keep dominance info up-to-date. */
free_dominance_info (CDI_DOMINATORS);
id.transform_lang_insert_block = NULL;
id.statements_to_fold = pointer_set_create ();
! push_gimplify_context ();
/* We make no attempts to keep dominance info up-to-date. */
free_dominance_info (CDI_DOMINATORS);