From patchwork Thu Nov 21 00:07:00 2013 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andrew MacLeod X-Patchwork-Id: 292899 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 932322C016A for ; Thu, 21 Nov 2013 11:07:22 +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=YjtYQn8tQkP6gxULc RFOl9tLBHeO5KSXkvVXnApAHR2vRaL6+i3Ic3RP9um/2ExFH1jyDxcMNybJYQ93k yxcxc7ZhygwMmy6oFr8aDLQUQ+TbxPsJFvS21Xtl40uFI3hXrFMvpg6xR/BhWFqV 869O8xknq7knDEvJ+whERe+3Zc= 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=uH/Gv3DGKgTtvxVe30sJN6g Lj/I=; b=VGhLs3L5JCyqZjqg92duuHyjnlM4NTiLT8IIoEZSYqd6aDGtClElspp FtgtfxIfBP/UnfvUzUlXbZsyJ5JZm+K/O/G9soQNuzGlloLPMGChSd94C20TOPFM SHgPeeSlVnUwXSLrGifGu5r/c4u+vuBPdJzKAm+yPXa8HfN4NkeU= Received: (qmail 6609 invoked by alias); 21 Nov 2013 00:07:13 -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 6599 invoked by uid 89); 21 Nov 2013 00:07:12 -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; Thu, 21 Nov 2013 00:07:10 +0000 Received: from int-mx11.intmail.prod.int.phx2.redhat.com (int-mx11.intmail.prod.int.phx2.redhat.com [10.5.11.24]) by mx1.redhat.com (8.14.4/8.14.4) with ESMTP id rAL072Up002662 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=OK); Wed, 20 Nov 2013 19:07:02 -0500 Received: from [10.10.56.26] (vpn-56-26.rdu2.redhat.com [10.10.56.26]) by int-mx11.intmail.prod.int.phx2.redhat.com (8.14.4/8.14.4) with ESMTP id rAL070Vj005298; Wed, 20 Nov 2013 19:07:01 -0500 Message-ID: <528D4EA4.7040900@redhat.com> Date: Wed, 20 Nov 2013 19:07:00 -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: Jeff Law , 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> <528CE7AE.4020502@redhat.com> <528D020F.7010502@redhat.com> <528D0B13.90803@redhat.com> <528D147C.1090102@redhat.com> In-Reply-To: <528D147C.1090102@redhat.com> X-IsSubscribed: yes On 11/20/2013 02:58 PM, Jeff Law wrote: > On 11/20/13 12:18, Andrew MacLeod wrote: >> >> And per Jakubs suggestion, I'll use XNEW... along with the changelog >> oversite. >> >> Assuming that all works, and no regressions, OK? > Yup. > jeff Bootstrapped on x86_64-unknown-linux-gnu with no new regressions. The attached final version was checked in as revision 205168 Andrew * 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. 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,57 ---- 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_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,226 ---- 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) *** 168,173 **** --- 247,253 ---- 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); --- 5806,5811 ---- *************** 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; --- 5942,5948 ---- 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 --- 5951,5957 ---- &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, --- 5965,5971 ---- && 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) --- 6388,6400 ---- 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) --- 6424,6436 ---- 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); --- 6828,6834 ---- 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 --- 7063,7068 ---- *************** 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); --- 7075,7081 ---- 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); --- 8433,8438 ---- *************** gimplify_body (tree fndecl, bool do_parm *** 8368,8374 **** default_rtl_profile (); gcc_assert (gimplify_ctxp == NULL); ! push_gimplify_context (&gctx); if (flag_openmp) { --- 8442,8448 ---- default_rtl_profile (); gcc_assert (gimplify_ctxp == NULL); ! push_gimplify_context (); if (flag_openmp) { Index: cgraphunit.c =================================================================== *** cgraphunit.c (revision 205035) --- cgraphunit.c (working copy) *************** along with GCC; see the file COPYING3. *** 205,210 **** --- 205,211 ---- #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) *** 1866,1871 **** --- 1867,1873 ---- } } cgraph_process_new_functions (); + free_gimplify_stack (); free (order); 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: 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: 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: 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);