From: Andrew MacLeod Date: Thu, 21 Nov 2013 00:06:23 +0000 (+0000) Subject: gimplify.h (gimplify_hasher : typed_free_remove, [...]): Move to gimplify.c. X-Git-Tag: upstream/12.2.0~66390 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=45852dcc91142eb73dc2b12ca939cce842d37daf;p=platform%2Fupstream%2Fgcc.git gimplify.h (gimplify_hasher : typed_free_remove, [...]): Move to gimplify.c. * 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. From-SVN: r205168 --- diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 892f5ef..0afb3c8 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,29 @@ +2013-11-20 Andrew MacLeod + + * 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 * config/rs6000/vsx.md (vsx_set_): Adjust for little endian. diff --git a/gcc/cgraphunit.c b/gcc/cgraphunit.c index fb23abe..f56f7c7 100644 --- a/gcc/cgraphunit.c +++ b/gcc/cgraphunit.c @@ -205,6 +205,7 @@ along with GCC; see the file COPYING3. If not see #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 @@ -1866,6 +1867,7 @@ expand_all_functions (void) } } cgraph_process_new_functions (); + free_gimplify_stack (); free (order); diff --git a/gcc/gimple-fold.c b/gcc/gimple-fold.c index 891d47c..91214bc 100644 --- a/gcc/gimple-fold.c +++ b/gcc/gimple-fold.c @@ -608,7 +608,6 @@ gimplify_and_update_call_from_tree (gimple_stmt_iterator *si_p, tree expr) gimple stmt, new_stmt; gimple_stmt_iterator i; gimple_seq stmts = NULL; - struct gimplify_ctx gctx; gimple laststore; tree reaching_vuse; @@ -616,8 +615,7 @@ gimplify_and_update_call_from_tree (gimple_stmt_iterator *si_p, tree expr) 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) diff --git a/gcc/gimplify-me.c b/gcc/gimplify-me.c index a7e9387..92542a9 100644 --- a/gcc/gimplify-me.c +++ b/gcc/gimplify-me.c @@ -45,7 +45,6 @@ force_gimple_operand_1 (tree expr, gimple_seq *stmts, gimple_predicate gimple_test_f, tree var) { enum gimplify_status ret; - struct gimplify_ctx gctx; location_t saved_location; *stmts = NULL; @@ -57,16 +56,13 @@ force_gimple_operand_1 (tree expr, gimple_seq *stmts, && (*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); } @@ -160,10 +156,8 @@ gimple_regimplify_operands (gimple stmt, gimple_stmt_iterator *gsi_p) 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)) { diff --git a/gcc/gimplify.c b/gcc/gimplify.c index 5c71d2c..2b6de3e 100644 --- a/gcc/gimplify.c +++ b/gcc/gimplify.c @@ -89,6 +89,37 @@ enum omp_region_type ORT_TARGET = 32 }; +/* Gimplify hashtable helper. */ + +struct gimplify_hasher : typed_free_remove +{ + 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 bind_expr_stack; + tree temps; + gimple_seq conditional_cleanups; + tree exit_label; + tree return_temp; + + vec case_labels; + /* The formal temporary table. Should this be persistent? */ + hash_table 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; @@ -100,10 +131,9 @@ struct gimplify_omp_ctx 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); @@ -134,14 +164,63 @@ gimplify_seq_add_seq (gimple_seq *dst_p, gimple_seq src) 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 @@ -168,6 +247,7 @@ 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. */ @@ -5726,7 +5806,6 @@ gimplify_scan_omp_clauses (tree *list_p, gimple_seq *pre_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); @@ -5863,7 +5942,7 @@ gimplify_scan_omp_clauses (tree *list_p, gimple_seq *pre_p, 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; @@ -5872,7 +5951,7 @@ gimplify_scan_omp_clauses (tree *list_p, gimple_seq *pre_p, &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 @@ -5886,7 +5965,7 @@ gimplify_scan_omp_clauses (tree *list_p, gimple_seq *pre_p, && 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, @@ -6309,14 +6388,13 @@ gimplify_omp_parallel (tree *expr_p, gimple_seq *pre_p) 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) @@ -6346,14 +6424,13 @@ gimplify_omp_task (tree *expr_p, gimple_seq *pre_p) 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) @@ -6751,8 +6828,7 @@ gimplify_omp_workshare (tree *expr_p, gimple_seq *pre_p) 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); @@ -6987,7 +7063,6 @@ gimplify_transaction (tree *expr_p, gimple_seq *pre_p) 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 @@ -7000,7 +7075,7 @@ gimplify_transaction (tree *expr_p, gimple_seq *pre_p) 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); @@ -8358,7 +8433,6 @@ gimplify_body (tree fndecl, bool do_parms) 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); @@ -8368,7 +8442,7 @@ gimplify_body (tree fndecl, bool do_parms) default_rtl_profile (); gcc_assert (gimplify_ctxp == NULL); - push_gimplify_context (&gctx); + push_gimplify_context (); if (flag_openmp) { diff --git a/gcc/gimplify.h b/gcc/gimplify.h index 3f7e1b3..91000d1 100644 --- a/gcc/gimplify.h +++ b/gcc/gimplify.h @@ -48,39 +48,10 @@ 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 -{ - 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 bind_expr_stack; - tree temps; - gimple_seq conditional_cleanups; - tree exit_label; - tree return_temp; - - vec case_labels; - /* The formal temporary table. Should this be persistent? */ - hash_table 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_bind_expr_stack (void); diff --git a/gcc/omp-low.c b/gcc/omp-low.c index 5d7e504..6722155 100644 --- a/gcc/omp-low.c +++ b/gcc/omp-low.c @@ -8351,11 +8351,10 @@ lower_omp_sections (gimple_stmt_iterator *gsi_p, omp_context *ctx) 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; @@ -8561,9 +8560,8 @@ lower_omp_single (gimple_stmt_iterator *gsi_p, omp_context *ctx) 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); @@ -8621,9 +8619,8 @@ lower_omp_master (gimple_stmt_iterator *gsi_p, omp_context *ctx) 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); @@ -8688,9 +8685,8 @@ lower_omp_ordered (gimple_stmt_iterator *gsi_p, omp_context *ctx) { 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); @@ -8734,7 +8730,6 @@ lower_omp_critical (gimple_stmt_iterator *gsi_p, omp_context *ctx) 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) @@ -8787,7 +8782,7 @@ lower_omp_critical (gimple_stmt_iterator *gsi_p, omp_context *ctx) 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); @@ -8877,9 +8872,8 @@ lower_omp_for (gimple_stmt_iterator *gsi_p, omp_context *ctx) 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); @@ -9094,7 +9088,6 @@ create_task_copyfn (gimple task_stmt, omp_context *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); @@ -9107,7 +9100,7 @@ create_task_copyfn (gimple task_stmt, omp_context *ctx) 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); @@ -9387,7 +9380,6 @@ lower_omp_taskreg (gimple_stmt_iterator *gsi_p, omp_context *ctx) 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); @@ -9412,7 +9404,7 @@ lower_omp_taskreg (gimple_stmt_iterator *gsi_p, omp_context *ctx) 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); } @@ -9420,7 +9412,7 @@ lower_omp_taskreg (gimple_stmt_iterator *gsi_p, omp_context *ctx) if (ctx->srecord_type) create_task_copyfn (stmt, ctx); - push_gimplify_context (&gctx); + push_gimplify_context (); par_olist = NULL; par_ilist = NULL; @@ -9510,7 +9502,6 @@ lower_omp_target (gimple_stmt_iterator *gsi_p, omp_context *ctx) 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; @@ -9525,7 +9516,7 @@ lower_omp_target (gimple_stmt_iterator *gsi_p, omp_context *ctx) 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)) @@ -9811,8 +9802,7 @@ 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); + push_gimplify_context (); tree block = make_node (BLOCK); gimple bind = gimple_build_bind (NULL, NULL, block); @@ -10105,10 +10095,8 @@ execute_lower_omp (void) 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); diff --git a/gcc/tree-inline.c b/gcc/tree-inline.c index 25705a9..678579a 100644 --- a/gcc/tree-inline.c +++ b/gcc/tree-inline.c @@ -4519,7 +4519,6 @@ 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. */ @@ -4540,7 +4539,7 @@ optimize_inline_calls (tree fn) 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);