From patchwork Wed Nov 20 16:47:42 2013 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andrew MacLeod X-Patchwork-Id: 292819 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (Client did not present a certificate) by ozlabs.org (Postfix) with ESMTPS id B64B82C0099 for ; Thu, 21 Nov 2013 03:51:14 +1100 (EST) DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender :message-id:date:from:mime-version:to:cc:subject:references :in-reply-to:content-type; q=dns; s=default; b=w5Z/GsUCbKa/jEgfl qepeVovnG9YZCoUc8ZIgsyT/coin5H3bceeMdpmeMtA8czAIQoiK/Yp73cgcLMf5 x9chT967eWWcLydFqTPrMYo/l8WdbToOl0NDJzs7L0rfyrULa8k3VsSR26TGbGuY JMi2/S45QEflrnmad5PFgMILLo= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender :message-id:date:from:mime-version:to:cc:subject:references :in-reply-to:content-type; s=default; bh=LzbcsYBhmDbsY9AbHbUV3u9 Snvk=; b=AEN/hN1IvDoepwlHYGqHdqsQaoIYLpkaIJHEVjmqziqduDA+RAGRBHh ke/d61A2hrY/VhPteiPQ6UIcMwiDHwyOgBo1WLYhL+FnOhatFzES/ge8FrHCESn5 tEltVO83AvpoDHLjuAfRr9LPo8dIlFjByDjokH98qrHUpARvn5AQ= Received: (qmail 27583 invoked by alias); 20 Nov 2013 16:49:58 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org Received: (qmail 27553 invoked by uid 89); 20 Nov 2013 16:49:57 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-1.4 required=5.0 tests=AWL, BAYES_50, RDNS_NONE, SPF_HELO_PASS, SPF_PASS autolearn=no version=3.3.2 X-HELO: mx1.redhat.com Received: from Unknown (HELO mx1.redhat.com) (209.132.183.28) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Wed, 20 Nov 2013 16:47:52 +0000 Received: from int-mx02.intmail.prod.int.phx2.redhat.com (int-mx02.intmail.prod.int.phx2.redhat.com [10.5.11.12]) by mx1.redhat.com (8.14.4/8.14.4) with ESMTP id rAKGli5q011166 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=OK); Wed, 20 Nov 2013 11:47:44 -0500 Received: from [10.10.56.26] (vpn-56-26.rdu2.redhat.com [10.10.56.26]) by int-mx02.intmail.prod.int.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id rAKGlg0T002832; Wed, 20 Nov 2013 11:47:43 -0500 Message-ID: <528CE7AE.4020502@redhat.com> Date: Wed, 20 Nov 2013 11:47:42 -0500 From: Andrew MacLeod User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:24.0) Gecko/20100101 Thunderbird/24.1.0 MIME-Version: 1.0 To: Richard Biener , Trevor Saunders CC: GCC Patches Subject: Re: [patch] Privatize gimplify_ctx structure. References: <528CBAA0.5060801@redhat.com> <20131120141658.GJ892@tucnak.redhat.com> <20131120150622.GA19586@tsaunders-iceball.corp.tor1.mozilla.com> <528CE3BA.7010105@redhat.com> In-Reply-To: <528CE3BA.7010105@redhat.com> X-IsSubscribed: yes On 11/20/2013 11:30 AM, Andrew MacLeod wrote: > On 11/20/2013 10:51 AM, Richard Biener wrote: >> On Wed, Nov 20, 2013 at 4:06 PM, Trevor Saunders >> wrote: >>> On Wed, Nov 20, 2013 at 03:18:07PM +0100, Richard Biener wrote: >>>> On Wed, Nov 20, 2013 at 3:16 PM, Jakub Jelinek >>>> wrote: >>>>> On Wed, Nov 20, 2013 at 03:12:34PM +0100, Richard Biener wrote: >>>>>> The limit looks reasonable, but you could have used a simple linked >>>>>> list (and never free). Also being able to pop a random context >>>>>> looks fragile ... that is, pop_gimplify_context shouldn't have >>>>>> an argument. >>>>> Can't we use stack_vec for that? Though >>>>> that would >>>>> mean a global var constructor and destructor, so alternatively >>>>> just use >>>>> a normal vec and .create(30) it somewhere during initialization? >>>> only with gimplify_context *, otherwise things will break during >>>> re-allocation. >>> hm? it seems like the only member of gimplify_ctx that can't just be >>> memcpyd is the prev pointer which presumably could go away if you >>> have a >>> vec of all the contexts. >> Callers have a pointer to gimplify_context AFAIK. >> >> > > No one except gimplify.c can have a pointer to the gimplify_context, > so its contained to within gimplify.c. Pretty much everything is > based off the current context pointer (gimplify_ctxp). There are > places where the address of a field within that context structure is > passed to another routine. If that routine then eventually triggered > another push/pop_context call, the address underneath could be > changed... and chaos ensues. > > I don't know if that does happen, but it is a possibility and I dont > see the need to find out. So a simple allocation scheme has the > minimal impact on the code, and my preference is leave it as it is, > or otherwise do the simple linked list malloc-ing only as necessary.... > > Want me to change it, or leave it as is? In fact, I like the code better for the linked list... its even simpler I've attached that patch. Its currently bootstrapping and I'll run the tests. And it wouldn't need a special testcase since there are no edge cases. Which is your preference? Andrew * gimplify.h (gimplify_hasher : typed_free_remove, struct gimplify_ctx): Move to gimplify.c. * gimplify.c (gimplify_hasher:typed_free_remove): Relocate here. (struct gimplify_ctx): Relocate here and add 'malloced' field. (gimplify_ctxp): Make static. (ctx_pool, ctx_alloc, ctx_free): 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'. * 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. Index: gimplify.h =================================================================== *** gimplify.h (revision 205035) --- gimplify.h (working copy) *************** enum gimplify_status { *** 48,86 **** 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 pop_gimplify_context (gimple); extern gimple gimple_current_bind_expr (void); extern vec gimple_bind_expr_stack (void); --- 48,56 ---- GS_OK = 0, /* We did something, maybe more to do. */ GS_ALL_DONE = 1 /* The expression is fully gimplified. */ }; ! 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); Index: gimplify.c =================================================================== *** gimplify.c (revision 205035) --- gimplify.c (working copy) *************** enum omp_region_type *** 89,94 **** --- 89,125 ---- 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; *************** struct gimplify_omp_ctx *** 100,109 **** 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); --- 131,139 ---- 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, *** 134,147 **** 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 --- 164,211 ---- gsi_insert_seq_after_without_update (&si, src, GSI_NEW_STMT); } + + /* pointer to a list of gimplify_ctx structs to be used as a stack of allocated + memory for push and pop of 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 = (struct gimplify_ctx *) xmalloc (sizeof (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; + } + /* 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) *** 168,173 **** --- 232,238 ---- 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, *** 5726,5732 **** 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); --- 5791,5796 ---- *************** gimplify_scan_omp_clauses (tree *list_p, *** 5863,5869 **** 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; --- 5927,5933 ---- 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, *** 5872,5878 **** &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 --- 5936,5942 ---- &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, *** 5886,5892 **** && 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, --- 5950,5956 ---- && 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 *** 6309,6322 **** 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) --- 6373,6385 ---- 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_ *** 6346,6359 **** 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) --- 6409,6421 ---- 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 *** 6751,6758 **** 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); --- 6813,6819 ---- 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 *** 6987,6993 **** 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 --- 7048,7053 ---- *************** gimplify_transaction (tree *expr_p, gimp *** 7000,7006 **** 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); --- 7060,7066 ---- 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 *** 8358,8364 **** 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); --- 8418,8423 ---- *************** gimplify_body (tree fndecl, bool do_parm *** 8368,8374 **** default_rtl_profile (); gcc_assert (gimplify_ctxp == NULL); ! push_gimplify_context (&gctx); if (flag_openmp) { --- 8427,8433 ---- default_rtl_profile (); gcc_assert (gimplify_ctxp == NULL); ! push_gimplify_context (); if (flag_openmp) { Index: gimplify-me.c =================================================================== *** gimplify-me.c (revision 205035) --- gimplify-me.c (working copy) *************** force_gimple_operand_1 (tree expr, gimpl *** 45,51 **** gimple_predicate gimple_test_f, tree var) { enum gimplify_status ret; - struct gimplify_ctx gctx; location_t saved_location; *stmts = NULL; --- 45,50 ---- *************** force_gimple_operand_1 (tree expr, gimpl *** 57,72 **** && (*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); } --- 56,68 ---- && (*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, *** 160,169 **** 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)) { --- 156,163 ---- tree lhs; gimple_seq pre = NULL; gimple post_stmt = NULL; ! push_gimplify_context (gimple_in_ssa_p (cfun)); switch (gimple_code (stmt)) { Index: omp-low.c =================================================================== *** omp-low.c (revision 205035) --- omp-low.c (working copy) *************** lower_omp_sections (gimple_stmt_iterator *** 8351,8361 **** 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; --- 8351,8360 ---- 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 * *** 8561,8569 **** 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); --- 8560,8567 ---- 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 * *** 8621,8629 **** 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); --- 8619,8626 ---- 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 *** 8688,8696 **** { 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); --- 8685,8692 ---- { 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 *** 8734,8740 **** 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) --- 8730,8735 ---- *************** lower_omp_critical (gimple_stmt_iterator *** 8787,8793 **** unlock = build_call_expr_loc (loc, unlock, 0); } ! push_gimplify_context (&gctx); block = make_node (BLOCK); bind = gimple_build_bind (NULL, NULL, block); --- 8782,8788 ---- 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 *** 8877,8885 **** 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); --- 8872,8879 ---- 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 *** 9094,9100 **** 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); --- 9088,9093 ---- *************** create_task_copyfn (gimple task_stmt, om *** 9107,9113 **** 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); --- 9100,9106 ---- 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 *** 9387,9393 **** 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); --- 9380,9385 ---- *************** lower_omp_taskreg (gimple_stmt_iterator *** 9412,9418 **** 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); } --- 9404,9410 ---- 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 *** 9420,9426 **** if (ctx->srecord_type) create_task_copyfn (stmt, ctx); ! push_gimplify_context (&gctx); par_olist = NULL; par_ilist = NULL; --- 9412,9418 ---- if (ctx->srecord_type) create_task_copyfn (stmt, ctx); ! push_gimplify_context (); par_olist = NULL; par_ilist = NULL; *************** lower_omp_target (gimple_stmt_iterator * *** 9510,9516 **** 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; --- 9502,9507 ---- *************** lower_omp_target (gimple_stmt_iterator * *** 9525,9531 **** 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)) --- 9516,9522 ---- 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 *** 9811,9818 **** 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); --- 9802,9808 ---- 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) *** 10105,10114 **** 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); --- 10095,10102 ---- if (all_contexts->root) { if (task_shared_vars) ! push_gimplify_context (); lower_omp (&body, NULL); if (task_shared_vars) pop_gimplify_context (NULL); Index: gimple-fold.c =================================================================== *** gimple-fold.c (revision 205035) --- gimple-fold.c (working copy) *************** gimplify_and_update_call_from_tree (gimp *** 608,614 **** gimple stmt, new_stmt; gimple_stmt_iterator i; gimple_seq stmts = NULL; - struct gimplify_ctx gctx; gimple laststore; tree reaching_vuse; --- 608,613 ---- *************** gimplify_and_update_call_from_tree (gimp *** 616,623 **** 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) --- 615,621 ---- gcc_assert (is_gimple_call (stmt)); ! push_gimplify_context (gimple_in_ssa_p (cfun)); lhs = gimple_call_lhs (stmt); if (lhs == NULL_TREE) Index: tree-inline.c =================================================================== *** tree-inline.c (revision 205035) --- tree-inline.c (working copy) *************** optimize_inline_calls (tree fn) *** 4518,4524 **** 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. */ --- 4518,4523 ---- *************** optimize_inline_calls (tree fn) *** 4539,4545 **** 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); --- 4538,4544 ---- 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);