From patchwork Fri Sep 6 22:26:13 2013 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Diego Novillo X-Patchwork-Id: 273348 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 EA6FE2C011F for ; Sat, 7 Sep 2013 08:26:30 +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:date :from:to:subject:message-id:mime-version:content-type; q=dns; s= default; b=A8NtpFQF8cunddlc+Dw7XkRTj1DQfv2NcVcXuP/lpRZA4HbvfNJi3 QnFiqHO0S3jQcrVErSlm3pw55cj9X2iVM01B/ZbG/gztIn07/cSNN9xE/c4ls8f0 Fii1WopxqWMnSLL2JgzhHq+xyTuMZBCAgwWRsCs/NACngf0UCqe76Q= 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:date :from:to:subject:message-id:mime-version:content-type; s= default; bh=KxfvhriWIcfUX49PBrnOyzki9w0=; b=S10gahdcZ4eDtKd+w6hx Sxgpqktx9coStl4Id9aPmEhx7iiF5dC9AfwQNSchNYzva8izgjyv+FmccDVL/u7u 3yFbPel3+oUxKZD9JjMu0ALqa/QOi1dTOC0ImURoJWvzgeJlVwLx0NQlWS6Ra8xf IFnda+LqWgjXSXa7JxfqWiU= Received: (qmail 26545 invoked by alias); 6 Sep 2013 22:26:23 -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 26535 invoked by uid 89); 6 Sep 2013 22:26:22 -0000 Received: from mail-ye0-f202.google.com (HELO mail-ye0-f202.google.com) (209.85.213.202) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES128-SHA encrypted) ESMTPS; Fri, 06 Sep 2013 22:26:22 +0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-2.3 required=5.0 tests=AWL, BAYES_50, RP_MATCHES_RCVD, SPF_SOFTFAIL autolearn=ham version=3.3.2 X-HELO: mail-ye0-f202.google.com Received: by mail-ye0-f202.google.com with SMTP id r14so188217yen.3 for ; Fri, 06 Sep 2013 15:26:14 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:date:from:to:subject:message-id:mime-version :content-type:content-disposition:organization:user-agent; bh=Zuh4Of+dqPXaHxF5Jp+TbosJmTEjpo2vC3V0f8KdqdU=; b=NAPCcjKBkAFrEbU98yYm8DSR/HGpBOJWc9FqB1o3Oq8GgJXUW9cKgwvMXfqfVL6BBp iJSFwsA0WOFYVQmmiTXXfjGNBtFH91kUWOwSSdGGIB8y8IDIfT/rxQJwkL+k99JfwYJr o0s+kzJ+v3OazAd16g4H4BvN6WicVPyptbN7HS8NvmSC67hHW0COvpiqCUtnXGzhNAlD TEigQqFZO7cxh9KORclvL/jnaojxpJAmwPBYEzX1vo6mpfBL8b4RxMAIVg+Kh3Hesye5 j1dT6CfrFeLx5FYCihcmvIQuwN9cpXcjv+XRyGznJrH6y6UaO5evMalEcq4OyF13rQcu 9fRw== X-Gm-Message-State: ALoCoQk2eZq8WZcmSszbz9bnTJCnBstCGG9M4/28QV4LYo0IndSmJYKLsx+u54+Dc557ZdN+1e1uhD7AqqvrDtLy8iYYTivrNU1pnZShpXP61jLL4eDh7REzA8xFv0+TPQTyfjcg9+86lOBcK/kIthk20KoPOHqBOB8okPVKZKRROydKnNCcT6OnH9GkeYB4fprpJaxGIdmPSpHXmWhmkwStaoYsE0ePZ/fbqoCnCgVvHzdV0HBJVpI= X-Received: by 10.236.66.244 with SMTP id h80mr1607460yhd.30.1378506374526; Fri, 06 Sep 2013 15:26:14 -0700 (PDT) Received: from corp2gmr1-1.hot.corp.google.com (corp2gmr1-1.hot.corp.google.com [172.24.189.92]) by gmr-mx.google.com with ESMTPS id a42si30yhj.6.1969.12.31.16.00.00 (version=TLSv1.1 cipher=AES128-SHA bits=128/128); Fri, 06 Sep 2013 15:26:14 -0700 (PDT) Received: from torture.tor.corp.google.com (torture.tor.corp.google.com [172.30.217.1]) by corp2gmr1-1.hot.corp.google.com (Postfix) with ESMTP id 5895431C1A6; Fri, 6 Sep 2013 15:26:14 -0700 (PDT) Received: by torture.tor.corp.google.com (Postfix, from userid 54752) id AA731C0A86; Fri, 6 Sep 2013 18:26:13 -0400 (EDT) Date: Fri, 6 Sep 2013 18:26:13 -0400 From: Diego Novillo To: amacleod@redhat.com, gcc-patches@gcc.gnu.org Subject: Factor gimple structures out of gimple.h Message-ID: <20130906222613.GA22838@google.com> MIME-Version: 1.0 Content-Disposition: inline User-Agent: Mutt/1.5.21 (2010-09-15) X-IsSubscribed: yes This patch introduces gimple-core.h, which contains just the data structures needed to define gimple. I left everything else in gimple.h The addition of alias.h to tree-ssa-alias.h is so that we can include tree-ssa-alias.h in isolation. It now includes everything it needs. More discussion on rationale at the thread: http://gcc.gnu.org/ml/gcc-patches/2013-09/msg00300.html Tested on x86_64. 2013-09-06 Diego Novillo * Makefile.in (GIMPLE_CORE_H): New. (GIMPLE_H): Depend on GIMPLE_CORE_H. (TREE_SSA_ALIAS_H): New. Replace references to tree-ssa-alias.h with TREE_SSA_ALIAS_H. * gimple-core.h: New. Factor all gimple data structures out of ... * gimple.h: ... here. * tree-ssa-alias.h: Include alias.h. diff --git a/gcc/Makefile.in b/gcc/Makefile.in index a72b753..2be8846 100644 --- a/gcc/Makefile.in +++ b/gcc/Makefile.in @@ -882,15 +882,19 @@ TREE_H = tree.h $(TREE_CORE_H) tree-check.h REGSET_H = regset.h $(BITMAP_H) hard-reg-set.h BASIC_BLOCK_H = basic-block.h $(PREDICT_H) $(VEC_H) $(FUNCTION_H) \ cfg-flags.def cfghooks.h -GIMPLE_H = gimple.h gimple.def gsstruct.def pointer-set.h $(VEC_H) \ +GIMPLE_CORE_H = gimple-core.h $(CONFIG_H) $(SYSTEM_H) $(CORETYPES_H) \ + $(INPUT_H) gimple.def gsstruct.def $(TREE_SSA_ALIAS_H) \ + $(INTERNAL_FN_H) $(TREE_CORE_H) +GIMPLE_H = gimple.h $(GIMPLE_CORE_H) pointer-set.h $(VEC_H) \ $(GGC_H) $(BASIC_BLOCK_H) $(TREE_H) tree-ssa-operands.h \ - tree-ssa-alias.h $(INTERNAL_FN_H) $(HASH_TABLE_H) + $(HASH_TABLE_H) TRANS_MEM_H = trans-mem.h GCOV_IO_H = gcov-io.h gcov-iov.h auto-host.h COVERAGE_H = coverage.h $(GCOV_IO_H) DEMANGLE_H = $(srcdir)/../include/demangle.h RECOG_H = recog.h ALIAS_H = alias.h +TREE_SSA_ALIAS_H = tree-ssa-alias.h $(ALIAS_H) EMIT_RTL_H = emit-rtl.h FLAGS_H = flags.h flag-types.h $(OPTIONS_H) OPTIONS_H = options.h flag-types.h $(OPTIONS_H_EXTRA) @@ -946,7 +950,7 @@ TREE_PASS_H = tree-pass.h $(TIMEVAR_H) $(DUMPFILE_H) TREE_FLOW_H = tree-flow.h tree-flow-inline.h tree-ssa-operands.h \ $(BITMAP_H) sbitmap.h $(BASIC_BLOCK_H) $(GIMPLE_H) \ $(HASHTAB_H) $(CGRAPH_H) $(IPA_REFERENCE_H) \ - tree-ssa-alias.h + $(TREE_SSA_ALIAS_H) TREE_HASHER_H = tree-hasher.h $(HASH_TABLE_H) $(TREE_FLOW_H) TREE_SSA_LIVE_H = tree-ssa-live.h $(PARTITION_H) SSAEXPAND_H = ssaexpand.h $(TREE_SSA_LIVE_H) @@ -2234,7 +2238,7 @@ test-dump.o : test-dump.c $(CONFIG_H) $(SYSTEM_H) $(CORETYPES_H) \ $(BITMAP_H) sbitmap.h sreal.h $(TREE_H) $(CXX_PARSER_H) $(DWARF2OUT_H) \ $(GIMPLE_PRETTY_PRINT_H) $(BASIC_BLOCK_H) insn-config.h $(LRA_INT.H) \ $(SEL_SCHED_DUMP_H) $(IRA_INT_H) $(TREE_DATA_REF_H) $(TREE_FLOW_H) \ - $(TREE_SSA_LIVE_H) tree-ssa-alias.h $(OMEGA_H) $(RTL_H) + $(TREE_SSA_LIVE_H) $(TREE_SSA_ALIAS_H) $(OMEGA_H) $(RTL_H) tree.o: tree.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(TREE_H) \ all-tree.def $(FLAGS_H) $(FUNCTION_H) $(PARAMS_H) \ toplev.h $(DIAGNOSTIC_CORE_H) $(GGC_H) $(HASHTAB_H) $(TARGET_H) output.h $(TM_P_H) \ @@ -2722,7 +2726,7 @@ targhooks.o : targhooks.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TREE_H) \ $(EXPR_H) $(TM_H) $(RTL_H) $(TM_P_H) $(FUNCTION_H) output.h $(DIAGNOSTIC_CORE_H) \ $(MACHMODE_H) $(TARGET_DEF_H) $(TARGET_H) $(GGC_H) gt-targhooks.h \ $(OPTABS_H) $(RECOG_H) $(REGS_H) reload.h hard-reg-set.h intl.h $(OPTS_H) \ - tree-ssa-alias.h $(TREE_FLOW_H) + $(TREE_SSA_ALIAS_H) $(TREE_FLOW_H) common/common-targhooks.o : common/common-targhooks.c $(CONFIG_H) $(SYSTEM_H) \ coretypes.h $(INPUT_H) $(TM_H) $(COMMON_TARGET_H) common/common-targhooks.h @@ -2746,7 +2750,7 @@ toplev.o : toplev.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(TREE_H) \ langhooks.h insn-flags.h $(CFGLOOP_H) hosthooks.h \ $(CGRAPH_H) $(COVERAGE_H) alloc-pool.h $(GGC_H) \ $(OPTS_H) params.def tree-mudflap.h $(TREE_PASS_H) $(GIMPLE_H) \ - tree-ssa-alias.h $(PLUGIN_H) realmpfr.h tree-diagnostic.h \ + $(TREE_SSA_ALIAS_H) $(PLUGIN_H) realmpfr.h tree-diagnostic.h \ $(TREE_PRETTY_PRINT_H) opts-diagnostic.h $(COMMON_TARGET_H) \ tsan.h diagnostic-color.h $(CONTEXT_H) $(PASS_MANAGER_H) @@ -3303,7 +3307,7 @@ alias.o : alias.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(DUMPFILE_H) \ $(ALIAS_H) $(EMIT_RTL_H) $(GGC_H) $(FUNCTION_H) cselib.h $(TREE_H) $(TM_P_H) \ langhooks.h $(TARGET_H) gt-alias.h $(TIMEVAR_H) $(CGRAPH_H) \ $(SPLAY_TREE_H) $(DF_H) \ - tree-ssa-alias.h pointer-set.h $(TREE_FLOW_H) + $(TREE_SSA_ALIAS_H) pointer-set.h $(TREE_FLOW_H) stack-ptr-mod.o : stack-ptr-mod.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \ $(TM_H) $(TREE_H) $(RTL_H) $(REGS_H) $(EXPR_H) $(TREE_PASS_H) \ $(BASIC_BLOCK_H) $(FLAGS_H) output.h $(DF_H) @@ -3819,7 +3823,7 @@ GTFILES = $(CPP_ID_DATA_H) $(srcdir)/input.h $(srcdir)/coretypes.h \ $(srcdir)/reg-stack.c $(srcdir)/cfgrtl.c \ $(srcdir)/sdbout.c $(srcdir)/stor-layout.c \ $(srcdir)/stringpool.c $(srcdir)/tree.c $(srcdir)/varasm.c \ - $(srcdir)/gimple.h $(srcdir)/gimple.c \ + $(srcdir)/gimple-core.h $(srcdir)/gimple.h $(srcdir)/gimple.c \ $(srcdir)/tree-mudflap.c $(srcdir)/tree-flow.h \ $(srcdir)/tree-ssanames.c $(srcdir)/tree-eh.c $(srcdir)/tree-ssa-address.c \ $(srcdir)/tree-cfg.c \ diff --git a/gcc/gimple-core.h b/gcc/gimple-core.h new file mode 100644 index 0000000..c489750 --- /dev/null +++ b/gcc/gimple-core.h @@ -0,0 +1,574 @@ +/* Data structure definitions for the gimple type. + + Copyright (C) 2007-2013 Free Software Foundation, Inc. + Contributed by Diego Novillo + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free +Software Foundation; either version 3, or (at your option) any later +version. + +GCC is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. + +You should have received a copy of the GNU General Public License +along with GCC; see the file COPYING3. If not see +. */ + +#ifndef GCC_GIMPLE_CORE_H +#define GCC_GIMPLE_CORE_H + +#include "input.h" +#include "tree-ssa-alias.h" +#include "internal-fn.h" +#include "tree-core.h" + +/* This file contains all the data structures that define the 'gimple' type. + There are no accessor macros nor functions in this file. Only the + basic data structures, extern declarations and type definitions. */ + +enum gimple_code { +#define DEFGSCODE(SYM, STRING, STRUCT) SYM, +#include "gimple.def" +#undef DEFGSCODE + LAST_AND_UNUSED_GIMPLE_CODE +}; + +/* Data structure definitions for GIMPLE tuples. NOTE: word markers + are for 64 bit hosts. */ + +struct GTY((chain_next ("%h.next"))) gimple_statement_base { + /* [ WORD 1 ] + Main identifying code for a tuple. */ + ENUM_BITFIELD(gimple_code) code : 8; + + /* Nonzero if a warning should not be emitted on this tuple. */ + unsigned int no_warning : 1; + + /* Nonzero if this tuple has been visited. Passes are responsible + for clearing this bit before using it. */ + unsigned int visited : 1; + + /* Nonzero if this tuple represents a non-temporal move. */ + unsigned int nontemporal_move : 1; + + /* Pass local flags. These flags are free for any pass to use as + they see fit. Passes should not assume that these flags contain + any useful value when the pass starts. Any initial state that + the pass requires should be set on entry to the pass. See + gimple_set_plf and gimple_plf for usage. */ + unsigned int plf : 2; + + /* Nonzero if this statement has been modified and needs to have its + operands rescanned. */ + unsigned modified : 1; + + /* Nonzero if this statement contains volatile operands. */ + unsigned has_volatile_ops : 1; + + /* The SUBCODE field can be used for tuple-specific flags for tuples + that do not require subcodes. Note that SUBCODE should be at + least as wide as tree codes, as several tuples store tree codes + in there. */ + unsigned int subcode : 16; + + /* UID of this statement. This is used by passes that want to + assign IDs to statements. It must be assigned and used by each + pass. By default it should be assumed to contain garbage. */ + unsigned uid; + + /* [ WORD 2 ] + Locus information for debug info. */ + location_t location; + + /* Number of operands in this tuple. */ + unsigned num_ops; + + /* [ WORD 3 ] + Basic block holding this statement. */ + basic_block bb; + + /* [ WORD 4-5 ] + Linked lists of gimple statements. The next pointers form + a NULL terminated list, the prev pointers are a cyclic list. + A gimple statement is hence also a double-ended list of + statements, with the pointer itself being the first element, + and the prev pointer being the last. */ + gimple next; + gimple GTY((skip)) prev; +}; + + +/* Base structure for tuples with operands. */ + +struct GTY(()) gimple_statement_with_ops_base { + /* [ WORD 1-6 ] */ + struct gimple_statement_base gsbase; + + /* [ WORD 7 ] + SSA operand vectors. NOTE: It should be possible to + amalgamate these vectors with the operand vector OP. However, + the SSA operand vectors are organized differently and contain + more information (like immediate use chaining). */ + struct use_optype_d GTY((skip (""))) *use_ops; +}; + + +/* Statements that take register operands. */ + +struct GTY(()) gimple_statement_with_ops { + /* [ WORD 1-7 ] */ + struct gimple_statement_with_ops_base opbase; + + /* [ WORD 8 ] + Operand vector. NOTE! This must always be the last field + of this structure. In particular, this means that this + structure cannot be embedded inside another one. */ + tree GTY((length ("%h.opbase.gsbase.num_ops"))) op[1]; +}; + + +/* Base for statements that take both memory and register operands. */ + +struct GTY(()) gimple_statement_with_memory_ops_base { + /* [ WORD 1-7 ] */ + struct gimple_statement_with_ops_base opbase; + + /* [ WORD 8-9 ] + Virtual operands for this statement. The GC will pick them + up via the ssa_names array. */ + tree GTY((skip (""))) vdef; + tree GTY((skip (""))) vuse; +}; + + +/* Statements that take both memory and register operands. */ + +struct GTY(()) gimple_statement_with_memory_ops { + /* [ WORD 1-9 ] */ + struct gimple_statement_with_memory_ops_base membase; + + /* [ WORD 10 ] + Operand vector. NOTE! This must always be the last field + of this structure. In particular, this means that this + structure cannot be embedded inside another one. */ + tree GTY((length ("%h.membase.opbase.gsbase.num_ops"))) op[1]; +}; + + +/* Call statements that take both memory and register operands. */ + +struct GTY(()) gimple_statement_call { + /* [ WORD 1-9 ] */ + struct gimple_statement_with_memory_ops_base membase; + + /* [ WORD 10-13 ] */ + struct pt_solution call_used; + struct pt_solution call_clobbered; + + /* [ WORD 14 ] */ + union GTY ((desc ("%1.membase.opbase.gsbase.subcode & GF_CALL_INTERNAL"))) { + tree GTY ((tag ("0"))) fntype; + enum internal_fn GTY ((tag ("GF_CALL_INTERNAL"))) internal_fn; + } u; + + /* [ WORD 15 ] + Operand vector. NOTE! This must always be the last field + of this structure. In particular, this means that this + structure cannot be embedded inside another one. */ + tree GTY((length ("%h.membase.opbase.gsbase.num_ops"))) op[1]; +}; + + +/* OpenMP statements (#pragma omp). */ + +struct GTY(()) gimple_statement_omp { + /* [ WORD 1-6 ] */ + struct gimple_statement_base gsbase; + + /* [ WORD 7 ] */ + gimple_seq body; +}; + + +/* GIMPLE_BIND */ + +struct GTY(()) gimple_statement_bind { + /* [ WORD 1-6 ] */ + struct gimple_statement_base gsbase; + + /* [ WORD 7 ] + Variables declared in this scope. */ + tree vars; + + /* [ WORD 8 ] + This is different than the BLOCK field in gimple_statement_base, + which is analogous to TREE_BLOCK (i.e., the lexical block holding + this statement). This field is the equivalent of BIND_EXPR_BLOCK + in tree land (i.e., the lexical scope defined by this bind). See + gimple-low.c. */ + tree block; + + /* [ WORD 9 ] */ + gimple_seq body; +}; + + +/* GIMPLE_CATCH */ + +struct GTY(()) gimple_statement_catch { + /* [ WORD 1-6 ] */ + struct gimple_statement_base gsbase; + + /* [ WORD 7 ] */ + tree types; + + /* [ WORD 8 ] */ + gimple_seq handler; +}; + + +/* GIMPLE_EH_FILTER */ + +struct GTY(()) gimple_statement_eh_filter { + /* [ WORD 1-6 ] */ + struct gimple_statement_base gsbase; + + /* [ WORD 7 ] + Filter types. */ + tree types; + + /* [ WORD 8 ] + Failure actions. */ + gimple_seq failure; +}; + +/* GIMPLE_EH_ELSE */ + +struct GTY(()) gimple_statement_eh_else { + /* [ WORD 1-6 ] */ + struct gimple_statement_base gsbase; + + /* [ WORD 7,8 ] */ + gimple_seq n_body, e_body; +}; + +/* GIMPLE_EH_MUST_NOT_THROW */ + +struct GTY(()) gimple_statement_eh_mnt { + /* [ WORD 1-6 ] */ + struct gimple_statement_base gsbase; + + /* [ WORD 7 ] Abort function decl. */ + tree fndecl; +}; + +/* GIMPLE_PHI */ + +struct GTY(()) gimple_statement_phi { + /* [ WORD 1-6 ] */ + struct gimple_statement_base gsbase; + + /* [ WORD 7 ] */ + unsigned capacity; + unsigned nargs; + + /* [ WORD 8 ] */ + tree result; + + /* [ WORD 9 ] */ + struct phi_arg_d GTY ((length ("%h.nargs"))) args[1]; +}; + + +/* GIMPLE_RESX, GIMPLE_EH_DISPATCH */ + +struct GTY(()) gimple_statement_eh_ctrl +{ + /* [ WORD 1-6 ] */ + struct gimple_statement_base gsbase; + + /* [ WORD 7 ] + Exception region number. */ + int region; +}; + + +/* GIMPLE_TRY */ + +struct GTY(()) gimple_statement_try { + /* [ WORD 1-6 ] */ + struct gimple_statement_base gsbase; + + /* [ WORD 7 ] + Expression to evaluate. */ + gimple_seq eval; + + /* [ WORD 8 ] + Cleanup expression. */ + gimple_seq cleanup; +}; + + +/* GIMPLE_WITH_CLEANUP_EXPR */ + +struct GTY(()) gimple_statement_wce { + /* [ WORD 1-6 ] */ + struct gimple_statement_base gsbase; + + /* Subcode: CLEANUP_EH_ONLY. True if the cleanup should only be + executed if an exception is thrown, not on normal exit of its + scope. This flag is analogous to the CLEANUP_EH_ONLY flag + in TARGET_EXPRs. */ + + /* [ WORD 7 ] + Cleanup expression. */ + gimple_seq cleanup; +}; + + +/* GIMPLE_ASM */ + +struct GTY(()) gimple_statement_asm { + /* [ WORD 1-9 ] */ + struct gimple_statement_with_memory_ops_base membase; + + /* [ WORD 10 ] + __asm__ statement. */ + const char *string; + + /* [ WORD 11 ] + Number of inputs, outputs, clobbers, labels. */ + unsigned char ni; + unsigned char no; + unsigned char nc; + unsigned char nl; + + /* [ WORD 12 ] + Operand vector. NOTE! This must always be the last field + of this structure. In particular, this means that this + structure cannot be embedded inside another one. */ + tree GTY((length ("%h.membase.opbase.gsbase.num_ops"))) op[1]; +}; + + +/* GIMPLE_OMP_CRITICAL */ + +struct GTY(()) gimple_statement_omp_critical { + /* [ WORD 1-7 ] */ + struct gimple_statement_omp omp; + + /* [ WORD 8 ] + Critical section name. */ + tree name; +}; + + +struct GTY(()) gimple_omp_for_iter { + /* Condition code. */ + enum tree_code cond; + + /* Index variable. */ + tree index; + + /* Initial value. */ + tree initial; + + /* Final value. */ + tree final; + + /* Increment. */ + tree incr; +}; + + +/* GIMPLE_OMP_FOR */ + +struct GTY(()) gimple_statement_omp_for { + /* [ WORD 1-7 ] */ + struct gimple_statement_omp omp; + + /* [ WORD 8 ] */ + tree clauses; + + /* [ WORD 9 ] + Number of elements in iter array. */ + size_t collapse; + + /* [ WORD 10 ] */ + struct gimple_omp_for_iter * GTY((length ("%h.collapse"))) iter; + + /* [ WORD 11 ] + Pre-body evaluated before the loop body begins. */ + gimple_seq pre_body; +}; + + +/* GIMPLE_OMP_PARALLEL */ + +struct GTY(()) gimple_statement_omp_parallel { + /* [ WORD 1-7 ] */ + struct gimple_statement_omp omp; + + /* [ WORD 8 ] + Clauses. */ + tree clauses; + + /* [ WORD 9 ] + Child function holding the body of the parallel region. */ + tree child_fn; + + /* [ WORD 10 ] + Shared data argument. */ + tree data_arg; +}; + + +/* GIMPLE_OMP_TASK */ + +struct GTY(()) gimple_statement_omp_task { + /* [ WORD 1-10 ] */ + struct gimple_statement_omp_parallel par; + + /* [ WORD 11 ] + Child function holding firstprivate initialization if needed. */ + tree copy_fn; + + /* [ WORD 12-13 ] + Size and alignment in bytes of the argument data block. */ + tree arg_size; + tree arg_align; +}; + + +/* GIMPLE_OMP_SECTION */ +/* Uses struct gimple_statement_omp. */ + + +/* GIMPLE_OMP_SECTIONS */ + +struct GTY(()) gimple_statement_omp_sections { + /* [ WORD 1-7 ] */ + struct gimple_statement_omp omp; + + /* [ WORD 8 ] */ + tree clauses; + + /* [ WORD 9 ] + The control variable used for deciding which of the sections to + execute. */ + tree control; +}; + + +/* GIMPLE_OMP_CONTINUE. + + Note: This does not inherit from gimple_statement_omp, because we + do not need the body field. */ + +struct GTY(()) gimple_statement_omp_continue { + /* [ WORD 1-6 ] */ + struct gimple_statement_base gsbase; + + /* [ WORD 7 ] */ + tree control_def; + + /* [ WORD 8 ] */ + tree control_use; +}; + + +/* GIMPLE_OMP_SINGLE */ + +struct GTY(()) gimple_statement_omp_single { + /* [ WORD 1-7 ] */ + struct gimple_statement_omp omp; + + /* [ WORD 7 ] */ + tree clauses; +}; + + +/* GIMPLE_OMP_ATOMIC_LOAD. + Note: This is based on gimple_statement_base, not g_s_omp, because g_s_omp + contains a sequence, which we don't need here. */ + +struct GTY(()) gimple_statement_omp_atomic_load { + /* [ WORD 1-6 ] */ + struct gimple_statement_base gsbase; + + /* [ WORD 7-8 ] */ + tree rhs, lhs; +}; + + +/* GIMPLE_OMP_ATOMIC_STORE. + See note on GIMPLE_OMP_ATOMIC_LOAD. */ + +struct GTY(()) gimple_statement_omp_atomic_store { + /* [ WORD 1-6 ] */ + struct gimple_statement_base gsbase; + + /* [ WORD 7 ] */ + tree val; +}; + +/* GIMPLE_TRANSACTION. */ + +struct GTY(()) gimple_statement_transaction { + /* [ WORD 1-9 ] */ + struct gimple_statement_with_memory_ops_base gsbase; + + /* [ WORD 10 ] */ + gimple_seq body; + + /* [ WORD 11 ] */ + tree label; +}; + +#define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) SYM, +enum gimple_statement_structure_enum { +#include "gsstruct.def" + LAST_GSS_ENUM +}; +#undef DEFGSSTRUCT + + +/* Define the overall contents of a gimple tuple. It may be any of the + structures declared above for various types of tuples. */ + +union GTY ((desc ("gimple_statement_structure (&%h)"), + chain_next ("%h.gsbase.next"), variable_size)) gimple_statement_d { + struct gimple_statement_base GTY ((tag ("GSS_BASE"))) gsbase; + struct gimple_statement_with_ops GTY ((tag ("GSS_WITH_OPS"))) gsops; + struct gimple_statement_with_memory_ops_base GTY ((tag ("GSS_WITH_MEM_OPS_BASE"))) gsmembase; + struct gimple_statement_with_memory_ops GTY ((tag ("GSS_WITH_MEM_OPS"))) gsmem; + struct gimple_statement_call GTY ((tag ("GSS_CALL"))) gimple_call; + struct gimple_statement_omp GTY ((tag ("GSS_OMP"))) omp; + struct gimple_statement_bind GTY ((tag ("GSS_BIND"))) gimple_bind; + struct gimple_statement_catch GTY ((tag ("GSS_CATCH"))) gimple_catch; + struct gimple_statement_eh_filter GTY ((tag ("GSS_EH_FILTER"))) gimple_eh_filter; + struct gimple_statement_eh_mnt GTY ((tag ("GSS_EH_MNT"))) gimple_eh_mnt; + struct gimple_statement_eh_else GTY ((tag ("GSS_EH_ELSE"))) gimple_eh_else; + struct gimple_statement_phi GTY ((tag ("GSS_PHI"))) gimple_phi; + struct gimple_statement_eh_ctrl GTY ((tag ("GSS_EH_CTRL"))) gimple_eh_ctrl; + struct gimple_statement_try GTY ((tag ("GSS_TRY"))) gimple_try; + struct gimple_statement_wce GTY ((tag ("GSS_WCE"))) gimple_wce; + struct gimple_statement_asm GTY ((tag ("GSS_ASM"))) gimple_asm; + struct gimple_statement_omp_critical GTY ((tag ("GSS_OMP_CRITICAL"))) gimple_omp_critical; + struct gimple_statement_omp_for GTY ((tag ("GSS_OMP_FOR"))) gimple_omp_for; + struct gimple_statement_omp_parallel GTY ((tag ("GSS_OMP_PARALLEL"))) gimple_omp_parallel; + struct gimple_statement_omp_task GTY ((tag ("GSS_OMP_TASK"))) gimple_omp_task; + struct gimple_statement_omp_sections GTY ((tag ("GSS_OMP_SECTIONS"))) gimple_omp_sections; + struct gimple_statement_omp_single GTY ((tag ("GSS_OMP_SINGLE"))) gimple_omp_single; + struct gimple_statement_omp_continue GTY ((tag ("GSS_OMP_CONTINUE"))) gimple_omp_continue; + struct gimple_statement_omp_atomic_load GTY ((tag ("GSS_OMP_ATOMIC_LOAD"))) gimple_omp_atomic_load; + struct gimple_statement_omp_atomic_store GTY ((tag ("GSS_OMP_ATOMIC_STORE"))) gimple_omp_atomic_store; + struct gimple_statement_transaction GTY((tag ("GSS_TRANSACTION"))) gimple_transaction; +}; + +#endif /* GCC_GIMPLE_CORE_H */ diff --git a/gcc/gimple.h b/gcc/gimple.h index 9f29561..3d2120f 100644 --- a/gcc/gimple.h +++ b/gcc/gimple.h @@ -22,6 +22,8 @@ along with GCC; see the file COPYING3. If not see #ifndef GCC_GIMPLE_H #define GCC_GIMPLE_H +#include "gimple-core.h" + #include "pointer-set.h" #include "hash-table.h" #include "vec.h" @@ -47,13 +49,6 @@ enum ssa_mode { these vectors. */ typedef vec gimple_vec; -enum gimple_code { -#define DEFGSCODE(SYM, STRING, STRUCT) SYM, -#include "gimple.def" -#undef DEFGSCODE - LAST_AND_UNUSED_GIMPLE_CODE -}; - extern const char *const gimple_code_name[]; extern const unsigned char gimple_rhs_class_table[]; @@ -156,286 +151,6 @@ struct gimple_stmt_iterator_d basic_block bb; }; -/* Data structure definitions for GIMPLE tuples. NOTE: word markers - are for 64 bit hosts. */ - -struct GTY((chain_next ("%h.next"))) gimple_statement_base { - /* [ WORD 1 ] - Main identifying code for a tuple. */ - ENUM_BITFIELD(gimple_code) code : 8; - - /* Nonzero if a warning should not be emitted on this tuple. */ - unsigned int no_warning : 1; - - /* Nonzero if this tuple has been visited. Passes are responsible - for clearing this bit before using it. */ - unsigned int visited : 1; - - /* Nonzero if this tuple represents a non-temporal move. */ - unsigned int nontemporal_move : 1; - - /* Pass local flags. These flags are free for any pass to use as - they see fit. Passes should not assume that these flags contain - any useful value when the pass starts. Any initial state that - the pass requires should be set on entry to the pass. See - gimple_set_plf and gimple_plf for usage. */ - unsigned int plf : 2; - - /* Nonzero if this statement has been modified and needs to have its - operands rescanned. */ - unsigned modified : 1; - - /* Nonzero if this statement contains volatile operands. */ - unsigned has_volatile_ops : 1; - - /* The SUBCODE field can be used for tuple-specific flags for tuples - that do not require subcodes. Note that SUBCODE should be at - least as wide as tree codes, as several tuples store tree codes - in there. */ - unsigned int subcode : 16; - - /* UID of this statement. This is used by passes that want to - assign IDs to statements. It must be assigned and used by each - pass. By default it should be assumed to contain garbage. */ - unsigned uid; - - /* [ WORD 2 ] - Locus information for debug info. */ - location_t location; - - /* Number of operands in this tuple. */ - unsigned num_ops; - - /* [ WORD 3 ] - Basic block holding this statement. */ - basic_block bb; - - /* [ WORD 4-5 ] - Linked lists of gimple statements. The next pointers form - a NULL terminated list, the prev pointers are a cyclic list. - A gimple statement is hence also a double-ended list of - statements, with the pointer itself being the first element, - and the prev pointer being the last. */ - gimple next; - gimple GTY((skip)) prev; -}; - - -/* Base structure for tuples with operands. */ - -struct GTY(()) gimple_statement_with_ops_base -{ - /* [ WORD 1-6 ] */ - struct gimple_statement_base gsbase; - - /* [ WORD 7 ] - SSA operand vectors. NOTE: It should be possible to - amalgamate these vectors with the operand vector OP. However, - the SSA operand vectors are organized differently and contain - more information (like immediate use chaining). */ - struct use_optype_d GTY((skip (""))) *use_ops; -}; - - -/* Statements that take register operands. */ - -struct GTY(()) gimple_statement_with_ops -{ - /* [ WORD 1-7 ] */ - struct gimple_statement_with_ops_base opbase; - - /* [ WORD 8 ] - Operand vector. NOTE! This must always be the last field - of this structure. In particular, this means that this - structure cannot be embedded inside another one. */ - tree GTY((length ("%h.opbase.gsbase.num_ops"))) op[1]; -}; - - -/* Base for statements that take both memory and register operands. */ - -struct GTY(()) gimple_statement_with_memory_ops_base -{ - /* [ WORD 1-7 ] */ - struct gimple_statement_with_ops_base opbase; - - /* [ WORD 8-9 ] - Virtual operands for this statement. The GC will pick them - up via the ssa_names array. */ - tree GTY((skip (""))) vdef; - tree GTY((skip (""))) vuse; -}; - - -/* Statements that take both memory and register operands. */ - -struct GTY(()) gimple_statement_with_memory_ops -{ - /* [ WORD 1-9 ] */ - struct gimple_statement_with_memory_ops_base membase; - - /* [ WORD 10 ] - Operand vector. NOTE! This must always be the last field - of this structure. In particular, this means that this - structure cannot be embedded inside another one. */ - tree GTY((length ("%h.membase.opbase.gsbase.num_ops"))) op[1]; -}; - - -/* Call statements that take both memory and register operands. */ - -struct GTY(()) gimple_statement_call -{ - /* [ WORD 1-9 ] */ - struct gimple_statement_with_memory_ops_base membase; - - /* [ WORD 10-13 ] */ - struct pt_solution call_used; - struct pt_solution call_clobbered; - - /* [ WORD 14 ] */ - union GTY ((desc ("%1.membase.opbase.gsbase.subcode & GF_CALL_INTERNAL"))) { - tree GTY ((tag ("0"))) fntype; - enum internal_fn GTY ((tag ("GF_CALL_INTERNAL"))) internal_fn; - } u; - - /* [ WORD 15 ] - Operand vector. NOTE! This must always be the last field - of this structure. In particular, this means that this - structure cannot be embedded inside another one. */ - tree GTY((length ("%h.membase.opbase.gsbase.num_ops"))) op[1]; -}; - - -/* OpenMP statements (#pragma omp). */ - -struct GTY(()) gimple_statement_omp { - /* [ WORD 1-6 ] */ - struct gimple_statement_base gsbase; - - /* [ WORD 7 ] */ - gimple_seq body; -}; - - -/* GIMPLE_BIND */ - -struct GTY(()) gimple_statement_bind { - /* [ WORD 1-6 ] */ - struct gimple_statement_base gsbase; - - /* [ WORD 7 ] - Variables declared in this scope. */ - tree vars; - - /* [ WORD 8 ] - This is different than the BLOCK field in gimple_statement_base, - which is analogous to TREE_BLOCK (i.e., the lexical block holding - this statement). This field is the equivalent of BIND_EXPR_BLOCK - in tree land (i.e., the lexical scope defined by this bind). See - gimple-low.c. */ - tree block; - - /* [ WORD 9 ] */ - gimple_seq body; -}; - - -/* GIMPLE_CATCH */ - -struct GTY(()) gimple_statement_catch { - /* [ WORD 1-6 ] */ - struct gimple_statement_base gsbase; - - /* [ WORD 7 ] */ - tree types; - - /* [ WORD 8 ] */ - gimple_seq handler; -}; - - -/* GIMPLE_EH_FILTER */ - -struct GTY(()) gimple_statement_eh_filter { - /* [ WORD 1-6 ] */ - struct gimple_statement_base gsbase; - - /* [ WORD 7 ] - Filter types. */ - tree types; - - /* [ WORD 8 ] - Failure actions. */ - gimple_seq failure; -}; - -/* GIMPLE_EH_ELSE */ - -struct GTY(()) gimple_statement_eh_else { - /* [ WORD 1-6 ] */ - struct gimple_statement_base gsbase; - - /* [ WORD 7,8 ] */ - gimple_seq n_body, e_body; -}; - -/* GIMPLE_EH_MUST_NOT_THROW */ - -struct GTY(()) gimple_statement_eh_mnt { - /* [ WORD 1-6 ] */ - struct gimple_statement_base gsbase; - - /* [ WORD 7 ] Abort function decl. */ - tree fndecl; -}; - -/* GIMPLE_PHI */ - -struct GTY(()) gimple_statement_phi { - /* [ WORD 1-6 ] */ - struct gimple_statement_base gsbase; - - /* [ WORD 7 ] */ - unsigned capacity; - unsigned nargs; - - /* [ WORD 8 ] */ - tree result; - - /* [ WORD 9 ] */ - struct phi_arg_d GTY ((length ("%h.nargs"))) args[1]; -}; - - -/* GIMPLE_RESX, GIMPLE_EH_DISPATCH */ - -struct GTY(()) gimple_statement_eh_ctrl -{ - /* [ WORD 1-6 ] */ - struct gimple_statement_base gsbase; - - /* [ WORD 7 ] - Exception region number. */ - int region; -}; - - -/* GIMPLE_TRY */ - -struct GTY(()) gimple_statement_try { - /* [ WORD 1-6 ] */ - struct gimple_statement_base gsbase; - - /* [ WORD 7 ] - Expression to evaluate. */ - gimple_seq eval; - - /* [ WORD 8 ] - Cleanup expression. */ - gimple_seq cleanup; -}; - /* Kind of GIMPLE_TRY statements. */ enum gimple_try_flags { @@ -450,206 +165,6 @@ enum gimple_try_flags GIMPLE_TRY_CATCH_IS_CLEANUP = 1 << 2 }; -/* GIMPLE_WITH_CLEANUP_EXPR */ - -struct GTY(()) gimple_statement_wce { - /* [ WORD 1-6 ] */ - struct gimple_statement_base gsbase; - - /* Subcode: CLEANUP_EH_ONLY. True if the cleanup should only be - executed if an exception is thrown, not on normal exit of its - scope. This flag is analogous to the CLEANUP_EH_ONLY flag - in TARGET_EXPRs. */ - - /* [ WORD 7 ] - Cleanup expression. */ - gimple_seq cleanup; -}; - - -/* GIMPLE_ASM */ - -struct GTY(()) gimple_statement_asm -{ - /* [ WORD 1-9 ] */ - struct gimple_statement_with_memory_ops_base membase; - - /* [ WORD 10 ] - __asm__ statement. */ - const char *string; - - /* [ WORD 11 ] - Number of inputs, outputs, clobbers, labels. */ - unsigned char ni; - unsigned char no; - unsigned char nc; - unsigned char nl; - - /* [ WORD 12 ] - Operand vector. NOTE! This must always be the last field - of this structure. In particular, this means that this - structure cannot be embedded inside another one. */ - tree GTY((length ("%h.membase.opbase.gsbase.num_ops"))) op[1]; -}; - -/* GIMPLE_OMP_CRITICAL */ - -struct GTY(()) gimple_statement_omp_critical { - /* [ WORD 1-7 ] */ - struct gimple_statement_omp omp; - - /* [ WORD 8 ] - Critical section name. */ - tree name; -}; - - -struct GTY(()) gimple_omp_for_iter { - /* Condition code. */ - enum tree_code cond; - - /* Index variable. */ - tree index; - - /* Initial value. */ - tree initial; - - /* Final value. */ - tree final; - - /* Increment. */ - tree incr; -}; - -/* GIMPLE_OMP_FOR */ - -struct GTY(()) gimple_statement_omp_for { - /* [ WORD 1-7 ] */ - struct gimple_statement_omp omp; - - /* [ WORD 8 ] */ - tree clauses; - - /* [ WORD 9 ] - Number of elements in iter array. */ - size_t collapse; - - /* [ WORD 10 ] */ - struct gimple_omp_for_iter * GTY((length ("%h.collapse"))) iter; - - /* [ WORD 11 ] - Pre-body evaluated before the loop body begins. */ - gimple_seq pre_body; -}; - - -/* GIMPLE_OMP_PARALLEL */ - -struct GTY(()) gimple_statement_omp_parallel { - /* [ WORD 1-7 ] */ - struct gimple_statement_omp omp; - - /* [ WORD 8 ] - Clauses. */ - tree clauses; - - /* [ WORD 9 ] - Child function holding the body of the parallel region. */ - tree child_fn; - - /* [ WORD 10 ] - Shared data argument. */ - tree data_arg; -}; - - -/* GIMPLE_OMP_TASK */ - -struct GTY(()) gimple_statement_omp_task { - /* [ WORD 1-10 ] */ - struct gimple_statement_omp_parallel par; - - /* [ WORD 11 ] - Child function holding firstprivate initialization if needed. */ - tree copy_fn; - - /* [ WORD 12-13 ] - Size and alignment in bytes of the argument data block. */ - tree arg_size; - tree arg_align; -}; - - -/* GIMPLE_OMP_SECTION */ -/* Uses struct gimple_statement_omp. */ - - -/* GIMPLE_OMP_SECTIONS */ - -struct GTY(()) gimple_statement_omp_sections { - /* [ WORD 1-7 ] */ - struct gimple_statement_omp omp; - - /* [ WORD 8 ] */ - tree clauses; - - /* [ WORD 9 ] - The control variable used for deciding which of the sections to - execute. */ - tree control; -}; - -/* GIMPLE_OMP_CONTINUE. - - Note: This does not inherit from gimple_statement_omp, because we - do not need the body field. */ - -struct GTY(()) gimple_statement_omp_continue { - /* [ WORD 1-6 ] */ - struct gimple_statement_base gsbase; - - /* [ WORD 7 ] */ - tree control_def; - - /* [ WORD 8 ] */ - tree control_use; -}; - -/* GIMPLE_OMP_SINGLE */ - -struct GTY(()) gimple_statement_omp_single { - /* [ WORD 1-7 ] */ - struct gimple_statement_omp omp; - - /* [ WORD 7 ] */ - tree clauses; -}; - - -/* GIMPLE_OMP_ATOMIC_LOAD. - Note: This is based on gimple_statement_base, not g_s_omp, because g_s_omp - contains a sequence, which we don't need here. */ - -struct GTY(()) gimple_statement_omp_atomic_load { - /* [ WORD 1-6 ] */ - struct gimple_statement_base gsbase; - - /* [ WORD 7-8 ] */ - tree rhs, lhs; -}; - -/* GIMPLE_OMP_ATOMIC_STORE. - See note on GIMPLE_OMP_ATOMIC_LOAD. */ - -struct GTY(()) gimple_statement_omp_atomic_store { - /* [ WORD 1-6 ] */ - struct gimple_statement_base gsbase; - - /* [ WORD 7 ] */ - tree val; -}; - -/* GIMPLE_TRANSACTION. */ /* Bits to be stored in the GIMPLE_TRANSACTION subcode. */ @@ -677,58 +192,6 @@ struct GTY(()) gimple_statement_omp_atomic_store { likely because it is guaranteed to go irrevocable upon entry. */ #define GTMA_HAS_NO_INSTRUMENTATION (1u << 7) -struct GTY(()) gimple_statement_transaction -{ - /* [ WORD 1-9 ] */ - struct gimple_statement_with_memory_ops_base gsbase; - - /* [ WORD 10 ] */ - gimple_seq body; - - /* [ WORD 11 ] */ - tree label; -}; - -#define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) SYM, -enum gimple_statement_structure_enum { -#include "gsstruct.def" - LAST_GSS_ENUM -}; -#undef DEFGSSTRUCT - - -/* Define the overall contents of a gimple tuple. It may be any of the - structures declared above for various types of tuples. */ - -union GTY ((desc ("gimple_statement_structure (&%h)"), - chain_next ("%h.gsbase.next"), variable_size)) gimple_statement_d { - struct gimple_statement_base GTY ((tag ("GSS_BASE"))) gsbase; - struct gimple_statement_with_ops GTY ((tag ("GSS_WITH_OPS"))) gsops; - struct gimple_statement_with_memory_ops_base GTY ((tag ("GSS_WITH_MEM_OPS_BASE"))) gsmembase; - struct gimple_statement_with_memory_ops GTY ((tag ("GSS_WITH_MEM_OPS"))) gsmem; - struct gimple_statement_call GTY ((tag ("GSS_CALL"))) gimple_call; - struct gimple_statement_omp GTY ((tag ("GSS_OMP"))) omp; - struct gimple_statement_bind GTY ((tag ("GSS_BIND"))) gimple_bind; - struct gimple_statement_catch GTY ((tag ("GSS_CATCH"))) gimple_catch; - struct gimple_statement_eh_filter GTY ((tag ("GSS_EH_FILTER"))) gimple_eh_filter; - struct gimple_statement_eh_mnt GTY ((tag ("GSS_EH_MNT"))) gimple_eh_mnt; - struct gimple_statement_eh_else GTY ((tag ("GSS_EH_ELSE"))) gimple_eh_else; - struct gimple_statement_phi GTY ((tag ("GSS_PHI"))) gimple_phi; - struct gimple_statement_eh_ctrl GTY ((tag ("GSS_EH_CTRL"))) gimple_eh_ctrl; - struct gimple_statement_try GTY ((tag ("GSS_TRY"))) gimple_try; - struct gimple_statement_wce GTY ((tag ("GSS_WCE"))) gimple_wce; - struct gimple_statement_asm GTY ((tag ("GSS_ASM"))) gimple_asm; - struct gimple_statement_omp_critical GTY ((tag ("GSS_OMP_CRITICAL"))) gimple_omp_critical; - struct gimple_statement_omp_for GTY ((tag ("GSS_OMP_FOR"))) gimple_omp_for; - struct gimple_statement_omp_parallel GTY ((tag ("GSS_OMP_PARALLEL"))) gimple_omp_parallel; - struct gimple_statement_omp_task GTY ((tag ("GSS_OMP_TASK"))) gimple_omp_task; - struct gimple_statement_omp_sections GTY ((tag ("GSS_OMP_SECTIONS"))) gimple_omp_sections; - struct gimple_statement_omp_single GTY ((tag ("GSS_OMP_SINGLE"))) gimple_omp_single; - struct gimple_statement_omp_continue GTY ((tag ("GSS_OMP_CONTINUE"))) gimple_omp_continue; - struct gimple_statement_omp_atomic_load GTY ((tag ("GSS_OMP_ATOMIC_LOAD"))) gimple_omp_atomic_load; - struct gimple_statement_omp_atomic_store GTY ((tag ("GSS_OMP_ATOMIC_STORE"))) gimple_omp_atomic_store; - struct gimple_statement_transaction GTY((tag ("GSS_TRANSACTION"))) gimple_transaction; -}; /* In gimple.c. */ diff --git a/gcc/tree-ssa-alias.h b/gcc/tree-ssa-alias.h index 96d0192..39bd835 100644 --- a/gcc/tree-ssa-alias.h +++ b/gcc/tree-ssa-alias.h @@ -21,6 +21,8 @@ #ifndef TREE_SSA_ALIAS_H #define TREE_SSA_ALIAS_H +#include "alias.h" + /* The points-to solution. The points-to solution is a union of pt_vars and the abstract