From patchwork Thu Aug 29 16:20:16 2013 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: David Malcolm X-Patchwork-Id: 270881 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 with cipher DHE-RSA-AES256-SHA (256/256 bits)) (Client CN "www.sourceware.org", Issuer "StartCom Class 1 Primary Intermediate Server CA" (not verified)) by ozlabs.org (Postfix) with ESMTPS id CB5F62C0089 for ; Fri, 30 Aug 2013 02:22:07 +1000 (EST) DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:from :to:cc:subject:date:message-id:in-reply-to:references; q=dns; s= default; b=DhmzFUhpus6tDXb3K1GoZWyz5NTKnSERSfObFrPAxYhdfdUoCN2zy 247FdA7CzU+0fx7uNk+JRCqDviFSXBuMbkVXX34gWG39HoLu2MZZcOzt/0OFTj0+ 2xOtEcFw/fi24Wz0TphIlLb2Ay+oGPnRFoBm0ChMd30F1ORqXjoqfc= 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:from :to:cc:subject:date:message-id:in-reply-to:references; s= default; bh=sm6scIGiWnCW5KptsSPnZQVjBxk=; b=ZBZyVmR6hZIG0NvlL/8/ 8maMWg18Oce9Ys1t+WNyz1B43wwGYrMrE+CMg9Bdkh7gYksn+wJghyAS6Ghlil5p 9gRhqLcUBioaJ+YY3GFgFgwczeXccKmeg1gQZD55cy3Bi+r7NHBiH0Qg4wPWlAa1 Zed18OFh5MEpYMMHey/K+cI= Received: (qmail 25546 invoked by alias); 29 Aug 2013 16:20:43 -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 25516 invoked by uid 89); 29 Aug 2013 16:20:43 -0000 Received: from eggs.gnu.org (HELO eggs.gnu.org) (208.118.235.92) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES256-SHA encrypted) ESMTPS; Thu, 29 Aug 2013 16:20:43 +0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-7.1 required=5.0 tests=AWL, BAYES_00, KHOP_THREADED, RCVD_IN_HOSTKARMA_W, RCVD_IN_HOSTKARMA_WL, RP_MATCHES_RCVD, SPF_HELO_PASS, SPF_PASS autolearn=ham version=3.3.2 X-HELO: eggs.gnu.org Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1VF4xS-00061N-6M for gcc-patches@gcc.gnu.org; Thu, 29 Aug 2013 12:20:36 -0400 Received: from mx1.redhat.com ([209.132.183.28]:63947) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1VF4xR-00060l-Sq for gcc-patches@gcc.gnu.org; Thu, 29 Aug 2013 12:20:30 -0400 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 r7TGKSpc028948 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=OK) for ; Thu, 29 Aug 2013 12:20:28 -0400 Received: from surprise.bos.redhat.com ([10.18.25.132]) by int-mx11.intmail.prod.int.phx2.redhat.com (8.14.4/8.14.4) with ESMTP id r7TGKOIV013271; Thu, 29 Aug 2013 12:20:27 -0400 From: David Malcolm To: gcc-patches@gcc.gnu.org Cc: David Malcolm Subject: [PATCH 6/6] Add manual GTY hooks Date: Thu, 29 Aug 2013 12:20:16 -0400 Message-Id: <1377793216-22549-7-git-send-email-dmalcolm@redhat.com> In-Reply-To: <1377793216-22549-1-git-send-email-dmalcolm@redhat.com> References: <1377793216-22549-1-git-send-email-dmalcolm@redhat.com> X-detected-operating-system: by eggs.gnu.org: GNU/Linux 3.x X-Received-From: 209.132.183.28 * gimple.c (gt_ggc_mx (gimple)): New, as required by GTY((user)). (gt_pch_nx (gimple)): Likewise. (gt_pch_nx (gimple, gt_pointer_operator, void *)): Likewise. * gimple.h (gt_ggc_mx (gimple)): Declare. (gt_pch_nx (gimple)): Declare. (gt_pch_nx (gimple, gt_pointer_operator, void *)): Declare. * tree-cfg.c (ggc_mx (gimple&)): Remove declaration, as this collides with the function that GTY((user)) expects. (gt_ggc_mx (edge_def *)): Replace call to gt_ggc_mx on the gimple with gt_ggc_mx_gimple_statement_base: in the pre-GTY((user)) world, "gt_ggc_mx" was the function to be called on a possibly NULL pointed to check if needed marking and if so to traverse its fields. In the GTY((user)) world, "gt_ggc_mx" is the function to be called on non-NULL objects immediately *after* they have been marked: it does not mark the object itself. (gt_pch_nx (gimple&)): Remove declaration. (gt_pch_nx (edge_def *)): Update as per the mx hook. --- gcc/gimple.c | 743 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ gcc/gimple.h | 6 + gcc/tree-cfg.c | 6 +- 3 files changed, 751 insertions(+), 4 deletions(-) diff --git a/gcc/gimple.c b/gcc/gimple.c index 1ad36d1..dd99cda 100644 --- a/gcc/gimple.c +++ b/gcc/gimple.c @@ -4338,4 +4338,747 @@ build_type_cast (tree to_type, gimple op, enum ssa_mode mode) return build_type_cast (to_type, gimple_assign_lhs (op), mode); } +void +gt_ggc_mx (gimple gs) +{ + gimple x = gs; + /* Emulation of the "chain_next" GTY attribute. + + gs has already been marked. + Iterate the chain of next statements, marking until we reach one that + has already been marked, or NULL. */ + gimple xlimit = gs->next; + while (ggc_test_and_set_mark (xlimit)) + xlimit = xlimit->next; + + /* All of the statements within the half-open interval [x..xlimit) have + just been marked. Iterate through the list, visiting their fields. */ + while (x != xlimit) + { + gt_ggc_m_15basic_block_def (x->bb); + switch (gimple_statement_structure (&((*x)))) + { + case GSS_BASE: + break; + case GSS_WITH_OPS: + { + gimple_statement_with_ops *stmt + = static_cast (x); + size_t num = (size_t)(stmt->num_ops); + for (size_t i = 0; i != num; i++) + gt_ggc_m_9tree_node (stmt->op[i]); + } + break; + case GSS_WITH_MEM_OPS_BASE: + break; + case GSS_WITH_MEM_OPS: + { + gimple_statement_with_memory_ops *stmt + = static_cast (x); + size_t num = (size_t)(stmt->num_ops); + for (size_t i = 0; i != num; i++) + gt_ggc_m_9tree_node (stmt->op[i]); + } + break; + case GSS_CALL: + { + gimple_statement_call *stmt + = static_cast (x); + gt_ggc_m_15bitmap_head_def (stmt->call_used.vars); + gt_ggc_m_15bitmap_head_def (stmt->call_clobbered.vars); + switch (stmt->subcode & GF_CALL_INTERNAL) + { + case 0: + gt_ggc_m_9tree_node (stmt->u.fntype); + break; + case GF_CALL_INTERNAL: + break; + default: + break; + } + size_t num = (size_t)(stmt->num_ops); + for (size_t i = 0; i != num; i++) + gt_ggc_m_9tree_node (stmt->op[i]); + } + break; + case GSS_OMP: + { + gimple_statement_omp *stmt + = static_cast (x); + gt_ggc_mx_gimple_statement_base (stmt->body); + } + break; + case GSS_BIND: + { + gimple_statement_bind *stmt + = static_cast (x); + gt_ggc_m_9tree_node (stmt->vars); + gt_ggc_m_9tree_node (stmt->block); + gt_ggc_mx_gimple_statement_base (stmt->body); + } + break; + case GSS_CATCH: + { + gimple_statement_catch *stmt + = static_cast (x); + gt_ggc_m_9tree_node (stmt->types); + gt_ggc_mx_gimple_statement_base (stmt->handler); + } + break; + case GSS_EH_FILTER: + { + gimple_statement_eh_filter *stmt + = static_cast (x); + gt_ggc_m_9tree_node (stmt->types); + gt_ggc_mx_gimple_statement_base (stmt->failure); + } + break; + case GSS_EH_MNT: + { + gimple_statement_eh_mnt *stmt + = static_cast (x); + gt_ggc_m_9tree_node (stmt->fndecl); + } + break; + case GSS_EH_ELSE: + { + gimple_statement_eh_else*stmt + = static_cast (x); + gt_ggc_mx_gimple_statement_base (stmt->n_body); + gt_ggc_mx_gimple_statement_base (stmt->e_body); + } + break; + case GSS_PHI: + { + gimple_statement_phi *stmt + = static_cast (x); + size_t num = (size_t)(stmt->nargs); + gt_ggc_m_9tree_node (stmt->result); + for (size_t i = 0; i != num; i++) + gt_ggc_m_9tree_node (stmt->args[i].def); + } + break; + case GSS_EH_CTRL: + break; + case GSS_TRY: + { + gimple_statement_try *stmt + = static_cast (x); + gt_ggc_mx_gimple_statement_base (stmt->eval); + gt_ggc_mx_gimple_statement_base (stmt->cleanup); + } + break; + case GSS_WCE: + { + gimple_statement_wce *stmt + = static_cast (x); + gt_ggc_mx_gimple_statement_base (stmt->cleanup); + } + break; + case GSS_ASM: + { + gimple_statement_asm *stmt + = static_cast (x); + size_t num = (size_t)(stmt->num_ops); + gt_ggc_m_S (stmt->string); + for (size_t i = 0; i != num; i++) + gt_ggc_m_9tree_node (stmt->op[i]); + } + break; + case GSS_OMP_CRITICAL: + { + gimple_statement_omp_critical *stmt + = static_cast (x); + gt_ggc_mx_gimple_statement_base (stmt->body); + gt_ggc_m_9tree_node (stmt->name); + } + break; + case GSS_OMP_FOR: + { + gimple_statement_omp_for *stmt + = static_cast (x); + size_t num = (size_t)(stmt->collapse); + gt_ggc_mx_gimple_statement_base (stmt->body); + gt_ggc_m_9tree_node (stmt->clauses); + if (stmt->iter != NULL) { + for (size_t i = 0; i != num; i++) { + gt_ggc_m_9tree_node (stmt->iter[i].index); + gt_ggc_m_9tree_node (stmt->iter[i].initial); + gt_ggc_m_9tree_node (stmt->iter[i].final); + gt_ggc_m_9tree_node (stmt->iter[i].incr); + } + ggc_mark (stmt->iter); + } + gt_ggc_mx_gimple_statement_base (stmt->pre_body); + } + break; + case GSS_OMP_PARALLEL: + { + gimple_statement_omp_parallel *stmt + = static_cast (x); + gt_ggc_mx_gimple_statement_base (stmt->body); + gt_ggc_m_9tree_node (stmt->clauses); + gt_ggc_m_9tree_node (stmt->child_fn); + gt_ggc_m_9tree_node (stmt->data_arg); + } + break; + case GSS_OMP_TASK: + { + gimple_statement_omp_task *stmt + = static_cast (x); + gt_ggc_mx_gimple_statement_base (stmt->body); + gt_ggc_m_9tree_node (stmt->clauses); + gt_ggc_m_9tree_node (stmt->child_fn); + gt_ggc_m_9tree_node (stmt->data_arg); + gt_ggc_m_9tree_node (stmt->copy_fn); + gt_ggc_m_9tree_node (stmt->arg_size); + gt_ggc_m_9tree_node (stmt->arg_align); + } + break; + case GSS_OMP_SECTIONS: + { + gimple_statement_omp_sections *stmt + = static_cast (x); + gt_ggc_mx_gimple_statement_base (stmt->body); + gt_ggc_m_9tree_node (stmt->clauses); + gt_ggc_m_9tree_node (stmt->control); + } + break; + case GSS_OMP_SINGLE: + { + gimple_statement_omp_single *stmt + = static_cast (x); + gt_ggc_mx_gimple_statement_base (stmt->body); + gt_ggc_m_9tree_node (stmt->clauses); + } + break; + case GSS_OMP_CONTINUE: + { + gimple_statement_omp_continue *stmt + = static_cast (x); + gt_ggc_m_9tree_node (stmt->control_def); + gt_ggc_m_9tree_node (stmt->control_use); + } + break; + case GSS_OMP_ATOMIC_LOAD: + { + gimple_statement_omp_atomic_load *stmt + = static_cast (x); + gt_ggc_m_9tree_node (stmt->rhs); + gt_ggc_m_9tree_node (stmt->lhs); + } + break; + case GSS_OMP_ATOMIC_STORE: + { + gimple_statement_omp_atomic_store *stmt + = static_cast (x); + gt_ggc_m_9tree_node (stmt->val); + } + break; + case GSS_TRANSACTION: + { + gimple_statement_transaction *stmt + = static_cast (x); + gt_ggc_mx_gimple_statement_base (stmt->body); + gt_ggc_m_9tree_node (stmt->label); + } + break; + default: + break; + } + x = x->next; + } +} + +void +gt_pch_nx (gimple gs) +{ + gimple x = gs; + /* Emulation of the "chain_next" GTY attribute. + + gs has already been marked. + Iterate the chain of next statements, marking until we reach one that + has already been marked, or NULL. */ + gimple xlimit = gs->next; + while (gt_pch_note_object (xlimit, xlimit, gt_pch_p_21gimple_statement_base)) + xlimit = xlimit->next; + + /* All of the statements within the half-open interval [x..xlimit) have + just been marked. Iterate through the list, visiting their fields. */ + while (x != xlimit) + { + gt_pch_n_15basic_block_def (x->bb); + switch (gimple_statement_structure (&((*x)))) + { + case GSS_BASE: + break; + case GSS_WITH_OPS: + { + gimple_statement_with_ops *stmt + = static_cast (x); + size_t num = (size_t)(stmt->num_ops); + for (size_t i = 0; i != num; i++) + gt_pch_n_9tree_node (stmt->op[i]); + } + break; + case GSS_WITH_MEM_OPS_BASE: + break; + case GSS_WITH_MEM_OPS: + { + gimple_statement_with_memory_ops *stmt + = static_cast (x); + size_t num = (size_t)(stmt->num_ops); + for (size_t i = 0; i != num; i++) + gt_pch_n_9tree_node (stmt->op[i]); + } + break; + case GSS_CALL: + { + gimple_statement_call *stmt + = static_cast (x); + gt_pch_n_15bitmap_head_def (stmt->call_used.vars); + gt_pch_n_15bitmap_head_def (stmt->call_clobbered.vars); + switch (stmt->subcode & GF_CALL_INTERNAL) + { + case 0: + gt_pch_n_9tree_node (stmt->u.fntype); + break; + case GF_CALL_INTERNAL: + break; + default: + break; + } + size_t num = (size_t)(stmt->num_ops); + for (size_t i = 0; i != num; i++) + gt_pch_n_9tree_node (stmt->op[i]); + } + break; + case GSS_OMP: + { + gimple_statement_omp *stmt + = static_cast (x); + gt_pch_nx_gimple_statement_base (stmt->body); + } + break; + case GSS_BIND: + { + gimple_statement_bind *stmt + = static_cast (x); + gt_pch_n_9tree_node (stmt->vars); + gt_pch_n_9tree_node (stmt->block); + gt_pch_nx_gimple_statement_base (stmt->body); + } + break; + case GSS_CATCH: + { + gimple_statement_catch *stmt + = static_cast (x); + gt_pch_n_9tree_node (stmt->types); + gt_pch_nx_gimple_statement_base (stmt->handler); + } + break; + case GSS_EH_FILTER: + { + gimple_statement_eh_filter *stmt + = static_cast (x); + gt_pch_n_9tree_node (stmt->types); + gt_pch_nx_gimple_statement_base (stmt->failure); + } + break; + case GSS_EH_MNT: + { + gimple_statement_eh_mnt *stmt + = static_cast (x); + gt_pch_n_9tree_node (stmt->fndecl); + } + break; + case GSS_EH_ELSE: + { + gimple_statement_eh_else*stmt + = static_cast (x); + gt_pch_nx_gimple_statement_base (stmt->n_body); + gt_pch_nx_gimple_statement_base (stmt->e_body); + } + break; + case GSS_PHI: + { + gimple_statement_phi *stmt + = static_cast (x); + size_t num = (size_t)(stmt->nargs); + gt_pch_n_9tree_node (stmt->result); + for (size_t i = 0; i != num; i++) + gt_pch_n_9tree_node (stmt->args[i].def); + } + break; + case GSS_EH_CTRL: + break; + case GSS_TRY: + { + gimple_statement_try *stmt + = static_cast (x); + gt_pch_nx_gimple_statement_base (stmt->eval); + gt_pch_nx_gimple_statement_base (stmt->cleanup); + } + break; + case GSS_WCE: + { + gimple_statement_wce *stmt + = static_cast (x); + gt_pch_nx_gimple_statement_base (stmt->cleanup); + } + break; + case GSS_ASM: + { + gimple_statement_asm *stmt + = static_cast (x); + size_t num = (size_t)(stmt->num_ops); + gt_pch_n_S (stmt->string); + for (size_t i = 0; i != num; i++) + gt_pch_n_9tree_node (stmt->op[i]); + } + break; + case GSS_OMP_CRITICAL: + { + gimple_statement_omp_critical *stmt + = static_cast (x); + gt_pch_nx_gimple_statement_base (stmt->body); + gt_pch_n_9tree_node (stmt->name); + } + break; + case GSS_OMP_FOR: + { + gimple_statement_omp_for *stmt + = static_cast (x); + size_t num = (size_t)(stmt->collapse); + gt_pch_nx_gimple_statement_base (stmt->body); + gt_pch_n_9tree_node (stmt->clauses); + if (stmt->iter != NULL) { + for (size_t i = 0; i != num; i++) { + gt_pch_n_9tree_node (stmt->iter[i].index); + gt_pch_n_9tree_node (stmt->iter[i].initial); + gt_pch_n_9tree_node (stmt->iter[i].final); + gt_pch_n_9tree_node (stmt->iter[i].incr); + } + gt_pch_note_object (stmt->iter, x, + gt_pch_p_21gimple_statement_base); + } + gt_pch_nx_gimple_statement_base (stmt->pre_body); + } + break; + case GSS_OMP_PARALLEL: + { + gimple_statement_omp_parallel *stmt + = static_cast (x); + gt_pch_nx_gimple_statement_base (stmt->body); + gt_pch_n_9tree_node (stmt->clauses); + gt_pch_n_9tree_node (stmt->child_fn); + gt_pch_n_9tree_node (stmt->data_arg); + } + break; + case GSS_OMP_TASK: + { + gimple_statement_omp_task *stmt + = static_cast (x); + gt_pch_nx_gimple_statement_base (stmt->body); + gt_pch_n_9tree_node (stmt->clauses); + gt_pch_n_9tree_node (stmt->child_fn); + gt_pch_n_9tree_node (stmt->data_arg); + gt_pch_n_9tree_node (stmt->copy_fn); + gt_pch_n_9tree_node (stmt->arg_size); + gt_pch_n_9tree_node (stmt->arg_align); + } + break; + case GSS_OMP_SECTIONS: + { + gimple_statement_omp_sections *stmt + = static_cast (x); + gt_pch_nx_gimple_statement_base (stmt->body); + gt_pch_n_9tree_node (stmt->clauses); + gt_pch_n_9tree_node (stmt->control); + } + break; + case GSS_OMP_SINGLE: + { + gimple_statement_omp_single *stmt + = static_cast (x); + gt_pch_nx_gimple_statement_base (stmt->body); + gt_pch_n_9tree_node (stmt->clauses); + } + break; + case GSS_OMP_CONTINUE: + { + gimple_statement_omp_continue *stmt + = static_cast (x); + gt_pch_n_9tree_node (stmt->control_def); + gt_pch_n_9tree_node (stmt->control_use); + } + break; + case GSS_OMP_ATOMIC_LOAD: + { + gimple_statement_omp_atomic_load *stmt + = static_cast (x); + gt_pch_n_9tree_node (stmt->rhs); + gt_pch_n_9tree_node (stmt->lhs); + } + break; + case GSS_OMP_ATOMIC_STORE: + { + gimple_statement_omp_atomic_store *stmt + = static_cast (x); + gt_pch_n_9tree_node (stmt->val); + } + break; + case GSS_TRANSACTION: + { + gimple_statement_transaction *stmt + = static_cast (x); + gt_pch_nx_gimple_statement_base (stmt->body); + gt_pch_n_9tree_node (stmt->label); + } + break; + default: + break; + } + x = x->next; + } +} + +void +gt_pch_nx (gimple gs, gt_pointer_operator op, void *cookie) +{ + op (&(gs->bb), cookie); + op (&(gs->next), cookie); + switch (gimple_statement_structure (gs)) + { + case GSS_BASE: + break; + case GSS_WITH_OPS: + { + gimple_statement_with_ops *stmt + = static_cast (gs); + size_t num = (size_t)(stmt->num_ops); + for (size_t i = 0; i != num; i++) + op (&(stmt->op[i]), cookie); + } + break; + case GSS_WITH_MEM_OPS_BASE: + break; + case GSS_WITH_MEM_OPS: + { + gimple_statement_with_memory_ops *stmt + = static_cast (gs); + size_t num = (size_t)(stmt->num_ops); + for (size_t i = 0; i != num; i++) + op (&(stmt->op[i]), cookie); + } + break; + case GSS_CALL: + { + gimple_statement_call *stmt + = static_cast (gs); + size_t num = (size_t)(stmt->num_ops); + op (&(stmt->call_used.vars), cookie); + op (&(stmt->call_clobbered.vars), cookie); + switch (stmt->subcode & GF_CALL_INTERNAL) + { + case 0: + op (&(stmt->u.fntype), cookie); + break; + case GF_CALL_INTERNAL: + break; + default: + break; + } + for (size_t i = 0; i != num; i++) + op (&(stmt->op[i]), cookie); + } + break; + case GSS_OMP: + { + gimple_statement_omp *stmt + = static_cast (gs); + op (&(stmt->body), cookie); + } + break; + case GSS_BIND: + { + gimple_statement_bind *stmt + = static_cast (gs); + op (&(stmt->vars), cookie); + op (&(stmt->block), cookie); + op (&(stmt->body), cookie); + } + break; + case GSS_CATCH: + { + gimple_statement_catch *stmt + = static_cast (gs); + op (&(stmt->types), cookie); + op (&(stmt->handler), cookie); + } + break; + case GSS_EH_FILTER: + { + gimple_statement_eh_filter *stmt + = static_cast (gs); + op (&(stmt->types), cookie); + op (&(stmt->failure), cookie); + } + break; + case GSS_EH_MNT: + { + gimple_statement_eh_mnt *stmt + = static_cast (gs); + op (&(stmt->fndecl), cookie); + } + break; + case GSS_EH_ELSE: + { + gimple_statement_eh_else*stmt + = static_cast (gs); + op (&(stmt->n_body), cookie); + op (&(stmt->e_body), cookie); + } + break; + case GSS_PHI: + { + gimple_statement_phi *stmt + = static_cast (gs); + size_t num = (size_t)(stmt->nargs); + op (&(stmt->result), cookie); + for (size_t i = 0; i != num; i++) + op (&(stmt->args[i].def), cookie); + } + break; + case GSS_EH_CTRL: + break; + case GSS_TRY: + { + gimple_statement_try *stmt + = static_cast (gs); + op (&(stmt->eval), cookie); + op (&(stmt->cleanup), cookie); + } + break; + case GSS_WCE: + { + gimple_statement_wce *stmt + = static_cast (gs); + op (&(stmt->cleanup), cookie); + } + break; + case GSS_ASM: + { + gimple_statement_asm *stmt + = static_cast (gs); + size_t num = (size_t)(stmt->num_ops); + op (&(stmt->string), cookie); + for (size_t i = 0; i != num; i++) + op (&(stmt->op[i]), cookie); + } + break; + case GSS_OMP_CRITICAL: + { + gimple_statement_omp_critical *stmt + = static_cast (gs); + op (&(stmt->body), cookie); + op (&(stmt->name), cookie); + } + break; + case GSS_OMP_FOR: + { + gimple_statement_omp_for *stmt + = static_cast (gs); + size_t num = (size_t)(stmt->collapse); + op (&(stmt->body), cookie); + op (&(stmt->clauses), cookie); + if (stmt->iter != NULL) { + for (size_t i = 0; i != num; i++) { + op (&(stmt->iter[i].index), cookie); + op (&(stmt->iter[i].initial), cookie); + op (&(stmt->iter[i].final), cookie); + op (&(stmt->iter[i].incr), cookie); + } + op (&(stmt->iter), cookie); + } + op (&(stmt->pre_body), cookie); + } + break; + case GSS_OMP_PARALLEL: + { + gimple_statement_omp_parallel *stmt + = static_cast (gs); + op (&(stmt->body), cookie); + op (&(stmt->clauses), cookie); + op (&(stmt->child_fn), cookie); + op (&(stmt->data_arg), cookie); + } + break; + case GSS_OMP_TASK: + { + gimple_statement_omp_task *stmt + = static_cast (gs); + op (&(stmt->body), cookie); + op (&(stmt->clauses), cookie); + op (&(stmt->child_fn), cookie); + op (&(stmt->data_arg), cookie); + op (&(stmt->copy_fn), cookie); + op (&(stmt->arg_size), cookie); + op (&(stmt->arg_align), cookie); + } + break; + case GSS_OMP_SECTIONS: + { + gimple_statement_omp_sections *stmt + = static_cast (gs); + op (&(stmt->body), cookie); + op (&(stmt->clauses), cookie); + op (&(stmt->control), cookie); + } + break; + case GSS_OMP_SINGLE: + { + gimple_statement_omp_single *stmt + = static_cast (gs); + op (&(stmt->body), cookie); + op (&(stmt->clauses), cookie); + } + break; + case GSS_OMP_CONTINUE: + { + gimple_statement_omp_continue *stmt + = static_cast (gs); + op (&(stmt->control_def), cookie); + op (&(stmt->control_use), cookie); + } + break; + case GSS_OMP_ATOMIC_LOAD: + { + gimple_statement_omp_atomic_load *stmt + = static_cast (gs); + op (&(stmt->rhs), cookie); + op (&(stmt->lhs), cookie); + } + break; + case GSS_OMP_ATOMIC_STORE: + { + gimple_statement_omp_atomic_store *stmt + = static_cast (gs); + op (&(stmt->val), cookie); + } + break; + case GSS_TRANSACTION: + { + gimple_statement_transaction *stmt + = static_cast (gs); + op (&(stmt->body), cookie); + op (&(stmt->label), cookie); + } + break; + default: + break; + } +} + + #include "gt-gimple.h" diff --git a/gcc/gimple.h b/gcc/gimple.h index daab54e..9b428eb 100644 --- a/gcc/gimple.h +++ b/gcc/gimple.h @@ -222,6 +222,12 @@ struct GTY((user)) gimple_statement_base { gimple GTY((skip)) prev; }; +/* GTY((user)) hooks for gimple, called once per-traversal. */ +void gt_ggc_mx (gimple gs); +void gt_pch_nx (gimple gs); +void gt_pch_nx (gimple gs, gt_pointer_operator op, void *cookie); + + /* Base structure for tuples with operands. */ diff --git a/gcc/tree-cfg.c b/gcc/tree-cfg.c index af8685c..185c072 100644 --- a/gcc/tree-cfg.c +++ b/gcc/tree-cfg.c @@ -8291,7 +8291,6 @@ make_pass_warn_unused_result (gcc::context *ctxt) /* Garbage collection support for edge_def. */ extern void gt_ggc_mx (tree&); -extern void gt_ggc_mx (gimple&); extern void gt_ggc_mx (rtx&); extern void gt_ggc_mx (basic_block&); @@ -8302,7 +8301,7 @@ gt_ggc_mx (edge_def *e) gt_ggc_mx (e->src); gt_ggc_mx (e->dest); if (current_ir_type () == IR_GIMPLE) - gt_ggc_mx (e->insns.g); + gt_ggc_mx_gimple_statement_base (e->insns.g); else gt_ggc_mx (e->insns.r); gt_ggc_mx (block); @@ -8311,7 +8310,6 @@ gt_ggc_mx (edge_def *e) /* PCH support for edge_def. */ extern void gt_pch_nx (tree&); -extern void gt_pch_nx (gimple&); extern void gt_pch_nx (rtx&); extern void gt_pch_nx (basic_block&); @@ -8322,7 +8320,7 @@ gt_pch_nx (edge_def *e) gt_pch_nx (e->src); gt_pch_nx (e->dest); if (current_ir_type () == IR_GIMPLE) - gt_pch_nx (e->insns.g); + gt_pch_nx_gimple_statement_base (e->insns.g); else gt_pch_nx (e->insns.r); gt_pch_nx (block);