This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[tuples] Rename gimple-ir.[ch] to gimple.[ch]


Self-explanatory.  This is for consistency, we do not append -ir to the
definition files of the other two IRs.

Tested on gimple.exp.  Committed.
2007-07-15  Diego Novillo  <dnovillo@google.com>

	* gimple.c: Rename from gimple-ir.c.
	Update all users.
	* gimple.h: Rename from gimple-ir.h.
	Update all users.

Index: gengtype.c
===================================================================
--- gengtype.c	(revision 126643)
+++ gengtype.c	(working copy)
@@ -1537,7 +1537,7 @@ open_base_files (void)
       "hard-reg-set.h", "basic-block.h", "cselib.h", "insn-addr.h",
       "optabs.h", "libfuncs.h", "debug.h", "ggc.h", "cgraph.h",
       "tree-flow.h", "reload.h", "cpp-id-data.h", "tree-chrec.h",
-      "cfglayout.h", "except.h", "output.h", "gimple-ir.h", "cfgloop.h", NULL
+      "cfglayout.h", "except.h", "output.h", "gimple.h", "cfgloop.h", NULL
     };
     const char *const *ifp;
     outf_p gtype_desc_c;
Index: tree-gimple.h
===================================================================
--- tree-gimple.h	(revision 126643)
+++ tree-gimple.h	(working copy)
@@ -24,7 +24,7 @@ Boston, MA 02110-1301, USA.  */
 
 
 #include "tree-iterator.h"
-#include "gimple-ir.h"
+#include "gimple.h"
 
 extern tree create_tmp_var_raw (tree, const char *);
 extern tree create_tmp_var_name (const char *);
Index: tree-eh.c
===================================================================
--- tree-eh.c	(revision 126643)
+++ tree-eh.c	(working copy)
@@ -37,7 +37,7 @@ Boston, MA 02110-1301, USA.  */
 #include "langhooks.h"
 #include "ggc.h"
 #include "toplev.h"
-#include "gimple-ir.h"
+#include "gimple.h"
 
 
 /* Nonzero if we are using EH to handle cleanups.  */
Index: gimple-pretty-print.c
===================================================================
--- gimple-pretty-print.c	(revision 126643)
+++ gimple-pretty-print.c	(working copy)
@@ -32,7 +32,7 @@ Software Foundation, 51 Franklin Street,
 #include "tree-flow.h"
 #include "gimple-iterator.h"
 #include "tree-pass.h"
-#include "gimple-ir.h"
+#include "gimple.h"
 
 #define INDENT(SPACE) do { \
   int i; for (i = 0; i<SPACE; i++) pp_space (buffer); } while (0)
Index: gimple-ir.c
===================================================================
--- gimple-ir.c	(revision 126643)
+++ gimple-ir.c	(working copy)
@@ -1,999 +0,0 @@
-/* Gimple IR support functions.
-
-   Copyright 2007 Free Software Foundation, Inc.
-   Contributed by Aldy Hernandez <aldyh@redhat.com>
-
-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 2, 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 COPYING.  If not, write to the Free
-Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
-02110-1301, USA.  */
-
-#include "config.h"
-#include "system.h"
-#include "coretypes.h"
-#include "tree.h"
-#include "ggc.h"
-#include "errors.h"
-#include "tree-gimple.h"
-#include "gimple-ir.h"
-#include "diagnostic.h"
-
-#define DEFGSCODE(SYM, NAME)	NAME,
-const char *const gs_code_name[] = {
-#include "gimple.def"
-};
-#undef DEFGSCODE
-
-/* Pointer map to store the sequence of GIMPLE statements
-   corresponding to each function.  For every FUNCTION_DECL FN, the
-   sequence of GIMPLE statements corresponding to FN are stored in
-   gimple_body (FN).  */
-static struct pointer_map_t *gimple_bodies = NULL;
-
-/* Gimple tuple constructors.  */
-
-/* Construct a GS_RETURN statement.
-
-   RESULT_DECL_P is non-zero if using RESULT_DECL.
-   RETVAL is the return value.  */
-
-gimple
-gs_build_return (bool result_decl_p, tree retval)
-{
-  gimple p = ggc_alloc_cleared (sizeof (struct gimple_statement_return));
-
-  GS_CODE (p) = GS_RETURN;
-  GS_SUBCODE_FLAGS (p) = (int) result_decl_p;
-  gs_return_set_retval (p, retval);
-  return p;
-}
-
-/* Helper for gs_build_call and gs_build_call_vec.  Build the basic
-   components of a GS_CALL statement to function FN with NARGS
-   arguments.  */
-
-static inline gimple
-gs_build_call_1 (tree fn, size_t nargs)
-{
-  gimple gs = ggc_alloc_cleared (sizeof (struct gimple_statement_call)
-                                 + sizeof (tree) * (nargs - 1));
-
-  GS_CODE (gs) = GS_CALL;
-  GS_SUBCODE_FLAGS (gs) = 0;
-  gs->gs_call.nargs = nargs;
-  gs->gs_call.fn = fn;
-
-  return gs;
-}
-
-
-/* Build a GS_CALL statement to function FN with the arguments
-   specified in vector ARGS.  */
-
-gimple
-gs_build_call_vec (tree fn, VEC(tree, gc) *args)
-{
-  size_t i;
-  size_t nargs = VEC_length (tree, args);
-  gimple call = gs_build_call_1 (fn, nargs);
-
-  for (i = 0; i < nargs; i++)
-    gs_call_set_arg (call, i, VEC_index (tree, args, i));
-
-  return call;
-}
-
-
-/* Build a GS_CALL statement to function FN.  NARGS is the number of
-   arguments.  The ... are the arguments.  */
-
-gimple
-gs_build_call (tree fn, size_t nargs, ...)
-{
-  va_list ap;
-  gimple call;
-  size_t i;
-
-  call = gs_build_call_1 (fn, nargs);
-
-  va_start (ap, nargs);
-  for (i = 0; i < nargs; i++)
-    gs_call_set_arg (call, i, va_arg (ap, tree));
-  va_end (ap);
-
-  return call;
-}
-
-/* Construct a GS_ASSIGN statement.
-
-   LHS of the assignment.
-   RHS of the assignment which can be unary or binary.  */
-
-gimple
-gs_build_assign (tree lhs, tree rhs)
-{
-  gimple p;
-  enum gimple_statement_structure_enum gss;
-
-  gss = gss_for_assign (TREE_CODE (rhs));
-  switch (gss)
-    {
-    case GSS_ASSIGN_BINARY:
-      p = ggc_alloc_cleared (sizeof (struct gimple_statement_assign_binary));
-      GS_CODE (p) = GS_ASSIGN;
-      GS_SUBCODE_FLAGS (p) = TREE_CODE (rhs);
-      gs_assign_set_lhs (p, lhs);
-      gs_assign_binary_set_rhs1 (p, TREE_OPERAND (rhs, 0));
-      gs_assign_binary_set_rhs2 (p, TREE_OPERAND (rhs, 1));
-      break;
-
-    case GSS_ASSIGN_UNARY_REG:
-      p = ggc_alloc_cleared (sizeof (struct gimple_statement_assign_unary_reg));
-      GS_CODE (p) = GS_ASSIGN;
-      GS_SUBCODE_FLAGS (p) = TREE_CODE (rhs);
-      gs_assign_set_lhs (p, lhs);
-      if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (rhs))))
-	gs_assign_unary_set_rhs (p, TREE_OPERAND (rhs, 0));
-      else
-	gs_assign_unary_set_rhs (p, rhs);
-      break;
-
-    case GSS_ASSIGN_UNARY_MEM:
-      p = ggc_alloc_cleared (sizeof (struct gimple_statement_assign_unary_mem));
-      GS_CODE (p) = GS_ASSIGN;
-      GS_SUBCODE_FLAGS (p) = TREE_CODE (rhs);
-      gs_assign_set_lhs (p, lhs);
-      if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (rhs))))
-        gs_assign_unary_set_rhs (p, TREE_OPERAND (rhs, 0));
-      else
-        gs_assign_unary_set_rhs (p, rhs);
-
-      break;
-
-    default:
-      gcc_unreachable ();
-    }
-
-  return p;
-}
-
-
-/* Given a CODE for the RHS of a GS_ASSIGN, return the GSS enum for it.  */
-
-enum gimple_statement_structure_enum
-gss_for_assign (enum tree_code code)
-{
-  enum tree_code_class class = TREE_CODE_CLASS (code);
-
-  if (class == tcc_binary || class == tcc_comparison)
-    return GSS_ASSIGN_BINARY;
-
-  /* There can be 3 types of unary operations:
-
-     SYM = <constant>		<== GSS_ASSIGN_UNARY_REG
-     SYM = SSA_NAME		<== GSS_ASSIGN_UNARY_REG
-     SYM = SYM2			<== GSS_ASSIGN_UNARY_MEM
-     SYM = UNARY_OP SYM2	<== GSS_ASSIGN_UNARY_MEM
-  */
-
-  if (class == tcc_constant || code == SSA_NAME)
-    return GSS_ASSIGN_UNARY_REG;
-
-  /* Must be class == tcc_unary.  */
-  return GSS_ASSIGN_UNARY_MEM;
-}
-
-/* Construct a GS_COND statement.
-
-   PRED is the condition used to compare LHS and the RHS.
-   T_LABEL is the label to jump to if the condition is true.
-   F_LABEL is teh label to jump to otherwise.  */
-
-gimple
-gs_build_cond (enum gs_cond pred, tree lhs, tree rhs,
-    	       tree t_label, tree f_label)
-{
-  gimple p;
-
-  p = ggc_alloc_cleared (sizeof (struct gimple_statement_cond));
-  GS_CODE (p) = GS_COND;
-  GS_SUBCODE_FLAGS (p) = pred;
-  gs_cond_set_lhs (p, lhs);
-  gs_cond_set_rhs (p, rhs);
-  gs_cond_set_true_label (p, t_label);
-  gs_cond_set_false_label (p, f_label);
-
-  return p;
-}
-
-/* Invert the condition of a GS_COND by swapping its labels.  */
-
-void
-gs_cond_invert (gimple g)
-{
-  tree tmp;
-
-  tmp = gs_cond_true_label (g);
-  gs_cond_set_true_label (g, gs_cond_false_label (g));
-  gs_cond_set_false_label (g, tmp);
-}
-
-/* Construct a GS_LABEL statement for LABEL.  */
-
-gimple
-gs_build_label (tree label)
-{
-  gimple p;
-
-  p = ggc_alloc_cleared (sizeof (struct gimple_statement_label));
-  GS_CODE (p) = GS_LABEL;
-  gs_label_set_label (p, label);
-
-  return p;
-}
-
-/* Construct a GS_GOTO statement to DEST.  */
-
-gimple
-gs_build_goto (tree dest)
-{
-  gimple p;
-
-  p = ggc_alloc_cleared (sizeof (struct gimple_statement_goto));
-  GS_CODE (p) = GS_GOTO;
-  gs_goto_set_dest (p, dest);
-
-  return p;
-}
-
-/* Construct a GS_NOP statement.  */
-
-gimple 
-gs_build_nop (void)
-{
-  gimple p;
-
-  p = ggc_alloc_cleared (sizeof (struct gimple_statement_base));
-  GS_CODE (p) = GS_NOP;
-
-  return p;
-}
-
-/* Construct a GS_BIND statement.
-
-   VARS are the variables in BODY.  */
-
-gimple
-gs_build_bind (tree vars, gs_seq body)
-{
-  gimple p;
-
-  p = ggc_alloc_cleared (sizeof (struct gimple_statement_bind));
-  GS_CODE (p) = GS_BIND;
-  gs_bind_set_vars (p, vars);
-  gs_bind_set_body (p, body);
-
-  return p;
-}
-
-/* Construct a GS_ASM statement.
-
-   STRING is the assembly code.
-   NINPUT is the number of register inputs.
-   NOUTPUT is the number of register outputs.
-   NCLOBBERED is the number of clobbered registers.
-   ... are trees for each input, output and clobbered register.  */
-
-gimple
-gs_build_asm (const char *string, unsigned ninputs, unsigned noutputs, 
-              unsigned nclobbered, ...)
-{
-  gimple p;
-  unsigned i;
-  va_list ap;
-
-  p = ggc_alloc_cleared (sizeof (struct gimple_statement_asm)
-                         + sizeof (tree) * (ninputs + noutputs + nclobbered - 1));
-  GS_CODE (p) = GS_ASM;
-  gs_asm_set_ninputs (p, ninputs);
-  gs_asm_set_noutputs (p, noutputs);
-  gs_asm_set_nclobbered (p, nclobbered);
-  gs_asm_set_string (p, string);
-  
-  va_start (ap, nclobbered);
-  for (i = 0; i < ninputs; i++)
-    gs_asm_set_input_op (p, i, va_arg (ap, tree));
-  for (i = 0; i < noutputs; i++)
-    gs_asm_set_output_op (p, i, va_arg (ap, tree));
-  for (i = 0; i < nclobbered; i++)
-    gs_asm_set_clobber_op (p, i, va_arg (ap, tree));
-  va_end (ap);
-  
-  return p;
-}
-
-/* Construct a GS_CATCH statement.
-
-  TYPES are the catch types.
-  HANDLER is the exception handler.  */
-
-gimple
-gs_build_catch (tree types, gimple handler)
-{
-  gimple p;
-
-  p = ggc_alloc_cleared (sizeof (struct gimple_statement_catch));
-  GS_CODE (p) = GS_CATCH;
-  gs_catch_set_types (p, types);
-  gs_catch_set_handler (p, handler);
-
-  return p;
-}
-
-/* Construct a GS_EH_FILTER statement.
-
-   TYPES are the filter's types.
-   FAILURE is the filter's failure action.  */
-
-gimple
-gs_build_eh_filter (tree types, gimple failure)
-{
-  gimple p;
-
-  p = ggc_alloc_cleared (sizeof (struct gimple_statement_eh_filter));
-  GS_CODE (p) = GS_EH_FILTER;
-  gs_eh_filter_set_types (p, types);
-  gs_eh_filter_set_failure (p, failure);
-
-  return p;
-}
-
-/* Construct a GS_TRY statement.
-
-   EVAL is the expression to evaluate.
-   CLEANUP is the cleanup expression.
-   CATCH_FINALLY is either GS_TRY_CATCH or GS_TRY_FINALLY depending on whether
-   this is a try/catch or a try/finally respectively.  */
-
-gimple
-gs_build_try (gs_seq eval, gs_seq cleanup, unsigned int catch_finally)
-{
-  gimple p;
-
-  gcc_assert (catch_finally == GS_TRY_CATCH
-	      || catch_finally == GS_TRY_FINALLY);
-  p = ggc_alloc_cleared (sizeof (struct gimple_statement_try));
-  GS_CODE (p) = GS_TRY;
-  gs_try_set_eval (p, eval);
-  gs_try_set_cleanup (p, cleanup);
-  GS_SUBCODE_FLAGS (p) = catch_finally;
-
-  return p;
-}
-
-/* Construct a GS_PHI statement.
-
-   CAPACITY is the max number of args this node can have (for later reuse).
-   RESULT the 
-   NARGS is the number of phi_arg_d's in ..., representing the number of
-   incomming edges in this phi node.
-   ... phi_arg_d* for the incomming edges to this node.  */
-
-gimple
-gs_build_phi (unsigned capacity, unsigned nargs, tree result, ...)
-{
-  gimple p;
-  unsigned int i;
-  va_list va;
-  p = ggc_alloc_cleared (sizeof (struct gimple_statement_phi)
-      + (sizeof (struct phi_arg_d) * (nargs - 1)) );
-  
-  GS_CODE (p) = GS_PHI;
-  gs_phi_set_capacity (p, capacity);
-  gs_phi_set_nargs (p, nargs);
-  gs_phi_set_result (p, result);
-  
-  va_start (va, result);
-  for (i = 0; i < nargs; i++)
-    {
-      struct phi_arg_d* phid = va_arg (va, struct phi_arg_d*);
-      gs_phi_set_arg (p, i, phid);
-    }
-  va_end (va);
-  
-  return p;
-}
-
-/* Construct a GS_RESX statement.
-
-   REGION is the region number from which this resx causes control flow to 
-   leave.  */
-
-gimple
-gs_build_resx (int region)
-{
-  gimple p;
-
-  p = ggc_alloc_cleared (sizeof (struct gimple_statement_resx));
-  GS_CODE (p) = GS_RESX;
-  gs_resx_set_region (p, region);
-  return p;
-}
-
-
-/* The helper for constructing a gimple switch statement.
-   INDEX is the switch's index.
-   NLABELS is the number of labels in the switch excluding the default.
-   DEFAULT_LABEL is the default label for the switch statement.  */
-
-static inline gimple 
-gs_build_switch_1 (unsigned int nlabels, tree index, tree default_label)
-{
-  gimple p;
-  
-  /* nlabels + 1 default label - 1 extra from struct.  */
-  p = ggc_alloc_cleared (sizeof (struct gimple_statement_switch)
-                         + sizeof (tree) * nlabels);
-  GS_CODE (p) = GS_SWITCH;
-
-  gs_switch_set_nlabels (p, nlabels);
-  gs_switch_set_index (p, index);
-  gs_switch_set_default_label (p, default_label);
-  
-  return p;
-}
-
-
-/* Construct a GS_SWITCH statement.
-
-   INDEX is the switch's index.
-   NLABELS is the number of labels in the switch excluding the DEFAULT_LABEL. 
-   ... are the labels excluding the default.  */
-
-gimple 
-gs_build_switch (unsigned int nlabels, tree index, tree default_label, ...)
-{
-  va_list al;
-  unsigned int i;
-
-  gimple p = gs_build_switch_1 (nlabels, index, default_label);
-  va_start (al, default_label);
-  for (i = 1; i <= nlabels; i++)
-    gs_switch_set_label (p, i, va_arg (al, tree));
-  va_end (al);
-
-  return p;
-}
-
-
-/* Construct a GS_SWITCH statement.
-
-   INDEX is the switch's index.
-   NLABELS is the number of labels in the switch excluding the default. 
-   ARGS is a vector of labels excluding the default.  */
-
-gimple
-gs_build_switch_vec (tree index, tree default_label, VEC(tree, heap) * args)
-{
-  size_t i;
-  size_t nlabels = VEC_length (tree, args);
-  gimple p = gs_build_switch_1 (nlabels, index, default_label);
-
-  for (i = 0; i < nlabels; i++)
-    gs_switch_set_label (p, i + 1, VEC_index (tree, args, i));
-
-  return p;
-}
-
-
-/* Construct a GS_OMP_CRITICAL statement.
-
-   BODY is the sequence of statements for which only one thread can execute.
-   NAME is optional identifier for this critical block.  */
-
-gimple 
-gs_omp_build_critical (gs_seq body, tree name)
-{
-  gimple p;
-
-  p = ggc_alloc_cleared (sizeof (struct gimple_statement_omp_critical));
-  GS_CODE (p) = GS_OMP_CRITICAL;
-  gs_omp_critical_set_name (p, name);
-  gs_omp_set_body (p, body);
-
-  return p;
-}
-
-/* Construct a GS_OMP_FOR statement.
-
-   BODY is sequence of statements inside the for loop.
-   CLAUSES, are any of the OMP loop construct's clauses: private, firstprivate, 
-   lastprivate, reductions, ordered, schedule, and nowait.
-   PRE_BODY is the sequence of statements that are loop invariant.
-   INDEX is the index variable.
-   INITIAL is the initial value of INDEX.
-   FINAL is final value of INDEX.
-   OMP_FOR_COND  the predicate used to compare INDEX and FINAL.
-   INCR is the increment expression.  */
-
-gimple
-gs_omp_build_for (gs_seq body, tree clauses, tree index, 
-                  tree initial, tree final, tree incr, 
-                  gs_seq pre_body, enum gs_cond omp_for_cond)
-{
-  gimple p;
-
-  p = ggc_alloc_cleared (sizeof (struct gimple_statement_omp_for));
-  GS_CODE (p) = GS_OMP_FOR;
-  gs_omp_set_body (p, body);
-  gs_omp_for_set_clauses (p, clauses);
-  gs_omp_for_set_index (p, index);
-  gs_omp_for_set_initial (p, initial);
-  gs_omp_for_set_final (p, final);
-  gs_omp_for_set_incr (p, incr);
-  gs_omp_for_set_pre_body (p, pre_body);
-  gs_assign_omp_for_cond (p, omp_for_cond);
-
-  return p;
-}
-
-/* Construct a GS_OMP_PARALLEL statement.
-
-   BODY is sequence of statements which are executed in parallel.
-   CLAUSES, are the OMP parallel construct's clauses.
-   CHILD_FN is the function created for the parallel threads to execute.
-   DATA_ARG are the shared data argument(s).  */
-
-gimple 
-gs_omp_build_parallel (gs_seq body, tree clauses, tree child_fn, 
-                       tree data_arg)
-{
-  gimple p;
-
-  p = ggc_alloc_cleared (sizeof (struct gimple_statement_omp_parallel));
-  GS_CODE (p) = GS_OMP_PARALLEL;
-  gs_omp_set_body (p, body);
-  gs_omp_parallel_set_clauses (p, clauses);
-  gs_omp_parallel_set_child_fn (p, child_fn);
-  gs_omp_parallel_set_data_arg (p, data_arg);
-
-  return p;
-}
-
-/* Construct a GS_OMP_SECTION statement for a sections statement.
-
-   BODY is the sequence of statements in the section.  */
-
-gimple
-gs_omp_build_section (gs_seq body)
-{
-  gimple p;
-
-  p = ggc_alloc_cleared (sizeof (struct gimple_statement_omp));
-  GS_CODE (p) = GS_OMP_SECTION;
-  gs_omp_set_body (p, body);
-
-  return p;
-}
-/* Construct a GS_OMP_MASTER statement.
-
-   BODY is the sequence of statements to be executed by just the master.  */
-
-gimple 
-gs_omp_build_master (gs_seq body)
-{
-  gimple p;
-
-  p = ggc_alloc_cleared (sizeof (struct gimple_statement_omp));
-  GS_CODE (p) = GS_OMP_MASTER;
-  gs_omp_set_body (p, body);
-
-  return p;
-}
-/* Construct a GS_OMP_CONTINUE statement.
-   FIXME tuples: BODY.  */
-
-gimple 
-gs_omp_build_continue (gs_seq body)
-{
-  gimple p;
-
-  p = ggc_alloc_cleared (sizeof (struct gimple_statement_omp));
-  GS_CODE (p) = GS_OMP_CONTINUE;
-  gs_omp_set_body (p, body);
-
-  return p;
-}
-
-/* Construct a GS_OMP_ORDERED statement.
-
-   BODY is the sequence of statements inside a loop that will executed in
-   sequence.  */
-
-gimple 
-gs_omp_build_ordered (gs_seq body)
-{
-  gimple p;
-
-  p = ggc_alloc_cleared (sizeof (struct gimple_statement_omp));
-  GS_CODE (p) = GS_OMP_ORDERED;
-  gs_omp_set_body (p, body);
-
-  return p;
-}
-
-/* Construct a GS_OMP_RETURN statement.
-   WAIT_P is true if this is a non-waiting return.  */
-
-gimple 
-gs_omp_build_return (bool wait_p)
-{
-  gimple p;
-
-  p = ggc_alloc_cleared (sizeof (struct gimple_statement_omp));
-  GS_CODE (p) = GS_OMP_RETURN;
-  if (wait_p)
-    GS_SUBCODE_FLAGS(p) = OMP_RETURN_NOWAIT_FLAG;
-
-  return p;
-}
-
-/* Construct a GS_OMP_SECTIONS statement.
-
-   BODY is a sequence of section statements.
-   CLAUSES are any of the OMP sections contsruct's clauses: private,
-   firstprivate, lastprivate, reduction, and nowait.  */
-
-gimple 
-gs_omp_build_sections (gs_seq body, tree clauses)
-{
-  gimple p;
-
-  p = ggc_alloc_cleared (sizeof (struct gimple_statement_omp_sections));
-  GS_CODE (p) = GS_OMP_SECTIONS;
-  gs_omp_set_body (p, body);
-  gs_omp_sections_set_clauses (p, clauses);
-
-  return p;
-}
-
-/* Construct a GS_OMP_SINGLE statement.
-
-   BODY is the sequence of statements that will be executed once.
-   CLAUSES are any of the OMP single construct's clauses: private, firstprivate,
-   copyprivate, nowait.  */
-
-gimple 
-gs_omp_build_single (gs_seq body, tree clauses)
-{
-  gimple p;
-
-  p = ggc_alloc_cleared (sizeof (struct gimple_statement_omp_single));
-  GS_CODE (p) = GS_OMP_SINGLE;
-  gs_omp_set_body (p, body);
-  gs_omp_single_set_clauses (p, clauses);
-
-  return p;
-}
-
-/* Return which gimple structure is used by T.  The enums here are defined
-   in gsstruct.def.  */
-
-enum gimple_statement_structure_enum
-gimple_statement_structure (gimple gs)
-{
-  unsigned int code = GS_CODE (gs);
-  unsigned int subcode = GS_SUBCODE_FLAGS (gs);
-
-  switch (code)
-    {
-    case GS_ASSIGN:		return gss_for_assign (subcode);
-    case GS_ASM:		return GSS_ASM;
-    case GS_BIND:		return GSS_BIND;
-    case GS_CALL:		return GSS_CALL;
-    case GS_CATCH:		return GSS_CATCH;
-    case GS_COND:		return GSS_COND;
-    case GS_EH_FILTER:		return GSS_EH_FILTER;
-    case GS_GOTO:		return GSS_GOTO;
-    case GS_LABEL:		return GSS_LABEL;
-    case GS_NOP:		return GSS_BASE;
-    case GS_PHI:		return GSS_PHI;
-    case GS_RESX:		return GSS_RESX;
-    case GS_RETURN:		return GSS_RETURN;
-    case GS_SWITCH:		return GSS_SWITCH;
-    case GS_TRY:		return GSS_TRY;
-    case GS_OMP_CRITICAL:	return GSS_OMP_CRITICAL;
-    case GS_OMP_FOR:		return GSS_OMP_FOR;
-    case GS_OMP_CONTINUE:
-    case GS_OMP_MASTER:		
-    case GS_OMP_ORDERED:
-    case GS_OMP_RETURN:
-    case GS_OMP_SECTION:
-				return GSS_OMP;
-    case GS_OMP_PARALLEL:	return GSS_OMP_PARALLEL;
-    case GS_OMP_SECTIONS:	return GSS_OMP_SECTIONS;
-    case GS_OMP_SINGLE:		return GSS_OMP_SINGLE;
-    default:
-      gcc_unreachable ();
-    }
-}
-
-#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
-/* Complain of a gimple type mismatch and die.  */
-
-void
-gs_check_failed (const gimple gs, const char *file, int line,
-	         const char *function, unsigned int code,
-		 unsigned int subcode)
-{
-  internal_error ("gimple check: expected %s(%s), have %s(%s) in %s, at %s:%d",
-      		  gs_code_name[code],
-		  tree_code_name[subcode],
-		  gs_code_name[GS_CODE (gs)],
-		  tree_code_name[GS_SUBCODE_FLAGS (gs)],
-		  function, trim_filename (file), line);
-}
-#endif /* ENABLE_TREE_CHECKING */
-
-
-/* Push gimple statement GS into the front of sequence SEQ.  */
-
-void
-gs_push (gimple gs, gs_seq seq)
-{
-  gimple oldfirst = gs_seq_first (seq);
-
-  GS_NEXT (gs) = oldfirst;
-  if (oldfirst)
-    GS_PREV (oldfirst) = gs;
-  gs_seq_set_first (seq, gs);
-}
-
-
-/* Remove the first gimple statement from sequence SEQ and return it.  */
-
-gimple
-gs_pop (gs_seq seq)
-{
-  gimple first = gs_seq_first (seq);
-  gimple new_first;
-
-  gs_seq_set_first (seq, GS_NEXT (first));
-  new_first = gs_seq_first (seq);
-  if (new_first)
-    GS_PREV (new_first) = NULL;
-  if (first)
-    GS_NEXT (first) = NULL;
-  return first;
-}
-
-
-/* Link a gimple statement(s) to the end of the sequence SEQ.  */
-
-void
-gs_add (gs_seq seq, gimple gs)
-{
-  gimple last;
-
-  /* Make sure this stmt is not part of another chain.  */
-  gcc_assert (GS_PREV (gs) == NULL);
-
-  for (last = gs; GS_NEXT (last) != NULL; last = GS_NEXT (last))
-    ;
-
-  if (gs_seq_first (seq) == NULL)
-    {
-      gs_seq_set_first (seq, gs);
-      gs_seq_set_last (seq, last);
-    }
-  else
-    {
-      GS_PREV (gs) = gs_seq_last (seq);
-      GS_NEXT (gs_seq_last (seq)) = gs;
-      gs_seq_set_last (seq, last);
-    }
-}
-
-
-/* Visit all the tuples in sequence SEQ, and apply FUNC to all the tree leaves
-   in the tuples.  The trees in the tuples encountered will be walked with
-   walk_tree().  FUNC, DATA, and PSET are as in walk_tree.
-
-   You cannot use this function to rewrite trees, as the address of
-   thre trees passed to walk_tree are local to this function.
-   Besides, you shouldn't be rewriting trees this late in the
-   game.  */
-
-void
-walk_seq_ops (gs_seq seq, walk_tree_fn func, void *data,
-	      struct pointer_set_t *pset)
-{
-  gimple_stmt_iterator gsi;
-
-  for (gsi = gsi_start (seq); !gsi_end_p (gsi); gsi_next (&gsi))
-    walk_tuple_ops (gsi_stmt (gsi), func, data, pset);
-}
-
-
-/* Helper function of walk_seq_ops.  Walks one tuple's trees.  The
-   arguments are as in walk_seq_ops, except GS is the tuple to
-   walk.  */
-#define WALKIT(__this) leaf = (__this), walk_tree (&leaf, func, data, pset)
-void
-walk_tuple_ops (gimple gs, walk_tree_fn func, void *data,
-		struct pointer_set_t *pset)
-{
-  unsigned int i;
-  tree leaf;
-
-  switch (GS_CODE (gs))
-    {
-    case GS_ASM:
-      for (i = 0; i < gs_asm_ninputs (gs); ++i)
-	WALKIT (gs_asm_input_op (gs, i));
-
-      for (i = 0; i < gs_asm_noutputs (gs); ++i)
-	WALKIT (gs_asm_output_op (gs, i));
-
-      for (i = 0; i < gs_asm_nclobbered (gs); ++i)
-	WALKIT (gs_asm_clobber_op (gs, i));
-      break;
-
-    case GS_ASSIGN:
-      WALKIT (gs_assign_operand (gs, 0));
-      WALKIT (gs_assign_operand (gs, 1));
-
-      if (gss_for_assign (GS_SUBCODE_FLAGS (gs)) == GSS_ASSIGN_BINARY)
-	WALKIT (gs_assign_operand (gs, 2));
-      break;
-
-    case GS_BIND:
-      WALKIT (gs_bind_vars (gs));
-      walk_seq_ops (gs_bind_body (gs), func, data, pset);
-      break;
-
-    case GS_CALL:
-      WALKIT (gs_call_lhs (gs));
-      WALKIT (gs_call_fn (gs));
-      WALKIT (gs_call_chain (gs));
-      for (i = 0; i < gs_call_nargs (gs); ++i)
-        WALKIT (gs_call_arg (gs, i));
-      break;
-
-    case GS_CATCH:
-      WALKIT (gs_catch_types (gs));
-      walk_tuple_ops (gs_catch_handler (gs), func, data, pset);
-      break;
-
-    case GS_COND:
-      WALKIT (gs_cond_lhs (gs));
-      WALKIT (gs_cond_rhs (gs));
-      WALKIT (gs_cond_true_label (gs));
-      WALKIT (gs_cond_false_label (gs));
-      break;
-
-    case GS_EH_FILTER:
-      WALKIT (gs_eh_filter_types (gs));
-      walk_tuple_ops (gs_eh_filter_failure (gs), func, data, pset);
-      break;
-
-    case GS_GOTO:
-      WALKIT (gs_goto_dest (gs));
-      break;
-
-    case GS_LABEL:
-      WALKIT (gs_label_label (gs));
-      break;
-
-    case GS_PHI:
-      WALKIT (gs_phi_result (gs));
-      break;
-
-    case GS_RETURN:
-      WALKIT (gs_return_retval (gs));
-      break;
-
-    case GS_SWITCH:
-      WALKIT (gs_switch_index (gs));
-      for (i = 0; i <= gs_switch_nlabels (gs); ++i)
-	WALKIT (gs_switch_label (gs, i));
-      break;
-
-    case GS_TRY:
-      walk_seq_ops (gs_try_eval (gs), func, data, pset);
-      walk_seq_ops (gs_try_cleanup (gs), func, data, pset);
-      break;
-
-    case GS_OMP_CRITICAL:
-      walk_seq_ops (gs_omp_body (gs), func, data, pset);
-      WALKIT (gs_omp_critical_name (gs));
-      break;
-
-      /* Just a body.  */
-    case GS_OMP_CONTINUE:
-    case GS_OMP_MASTER:
-    case GS_OMP_ORDERED:
-    case GS_OMP_SECTION:
-      walk_seq_ops (gs_omp_body (gs), func, data, pset);
-      break;
-
-    case GS_OMP_FOR:
-      walk_seq_ops (gs_omp_body (gs), func, data, pset);
-      WALKIT (gs_omp_for_clauses (gs));
-      WALKIT (gs_omp_for_index (gs));
-      WALKIT (gs_omp_for_initial (gs));
-      WALKIT (gs_omp_for_final (gs));
-      WALKIT (gs_omp_for_incr (gs));
-      walk_seq_ops (gs_omp_for_pre_body (gs), func, data, pset);
-      break;
-
-    case GS_OMP_PARALLEL:
-      walk_seq_ops (gs_omp_body (gs), func, data, pset);
-      WALKIT (gs_omp_parallel_clauses (gs));
-      WALKIT (gs_omp_parallel_child_fn (gs));
-      WALKIT (gs_omp_parallel_data_arg (gs));
-      break;
-
-    case GS_OMP_SECTIONS:
-      walk_seq_ops (gs_omp_body (gs), func, data, pset);
-      WALKIT (gs_omp_sections_clauses (gs));
-      break;
-
-    case GS_OMP_SINGLE:
-      walk_seq_ops (gs_omp_body (gs), func, data, pset);
-      WALKIT (gs_omp_single_clauses (gs));
-      break;
-
-      /* Tuples that do not have trees.  */
-    case GS_NOP:
-    case GS_RESX:
-    case GS_OMP_RETURN:
-      break;
-
-    default:
-      debug_gimple_stmt (gs);
-      gcc_unreachable ();
-      break;
-    }
-}
-
-
-/* Set sequence SEQ to be the GIMPLE body for function FN.  */
-
-void
-set_gimple_body (tree fn, gs_seq seq)
-{
-  void **slot;
-
-  if (gimple_bodies == NULL)
-    gimple_bodies = pointer_map_create ();
-
-  slot = pointer_map_insert (gimple_bodies, fn);
-  *slot = (void *) seq;
-}
-  
-
-/* Return the body of GIMPLE statements for function FN.  */
-
-gs_seq
-gimple_body (tree fn)
-{
-  void **slot;
-  
-  if (gimple_bodies && (slot = pointer_map_contains (gimple_bodies, fn)))
-    return (gs_seq) *slot;
-  
-  return NULL;
-}
Index: gimple-ir.h
===================================================================
--- gimple-ir.h	(revision 126643)
+++ gimple-ir.h	(working copy)
@@ -1,1346 +0,0 @@
-/* Gimple IR definitions.
-
-   Copyright 2007 Free Software Foundation, Inc.
-   Contributed by Aldy Hernandez <aldyh@redhat.com>
-
-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 2, 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 COPYING.  If not, write to the Free
-Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
-02110-1301, USA.  */
-
-#ifndef GCC_GIMPLE_IR_H
-#define GCC_GIMPLE_IR_H
-
-#include "pointer-set.h"
-
-enum gs_code {
-#define DEFGSCODE(SYM, STRING)	SYM,
-#include "gimple.def"
-#undef DEFGSCODE
-    LAST_AND_UNUSED_GS_CODE
-};
-
-#define GS_CODE(G) ((G)->base.code)
-#define GS_SUBCODE_FLAGS(G) ((G)->base.subcode_flags)
-#define GS_NEXT(G) ((G)->base.next)
-#define GS_PREV(G) ((G)->base.prev)
-#define GS_LOCUS(G) ((G)->base.locus)
-#define GS_LOCUS_EMPTY_P(G)	(GS_LOCUS ((G)).file == NULL \
-				 && GS_LOCUS ((G)).line == 0)
-
-/* A sequence of gimple statements.  */
-struct gs_sequence
-{
-  gimple first;
-  gimple last;
-};
-
-static inline gimple
-gs_seq_first (gs_seq s)
-{
-  return s->first;
-}
-
-static inline gimple
-gs_seq_last (gs_seq s)
-{
-  return s->last;
-}
-
-static inline void
-gs_seq_set_last (gs_seq s, gimple last)
-{
-  s->last = last;
-}
-
-static inline void
-gs_seq_set_first (gs_seq s, gimple first)
-{
-  s->first = first;
-}
-
-static inline void
-gs_seq_init (gs_seq s)
-{
-  s->first = NULL;
-  s->last = NULL;
-}
-
-/* Copy the sequence SRC into the sequence DEST.  */
-
-static inline void
-gs_seq_copy (gs_seq dest, gs_seq src)
-{
-  gs_seq_set_first (dest, gs_seq_first (src));
-  gs_seq_set_last (dest, gs_seq_last (src));
-}
-
-static inline bool
-gs_seq_empty_p (gs_seq s)
-{
-  return s->first == NULL;
-}
-
-/* Data structure definitions for GIMPLE tuples.  */
-
-struct gimple_statement_base GTY(())
-{
-  ENUM_BITFIELD(gs_code) code : 16;
-  unsigned int subcode_flags : 16;
-  gimple next;
-  gimple prev;
-  struct basic_block_def *bb;
-  location_t locus;
-  tree block;
-};
-
-struct gimple_statement_with_ops GTY(())
-{
-  struct gimple_statement_base base;
-  unsigned modified : 1;
-  struct def_optype_d GTY((skip)) *def_ops;
-  struct use_optype_d GTY((skip)) *use_ops;
-};
-
-struct gimple_statement_with_memory_ops GTY(())
-{
-  struct gimple_statement_with_ops with_ops;
-  unsigned has_volatile_ops : 1;
-  struct voptype_d GTY((skip)) *vdef_ops;
-  struct voptype_d GTY((skip)) *vuse_ops;
-  bitmap stores;
-  bitmap loads;
-};
-
-struct gimple_statement_omp GTY(())
-{
-     struct gimple_statement_base base;
-     struct gs_sequence body;
-};
-
-/* GS_BIND */
-struct gimple_statement_bind GTY(())
-{
-  struct gimple_statement_base base;
-  tree vars;
-  struct gs_sequence body;
-};
-
-/* GS_CATCH */
-struct gimple_statement_catch GTY(())
-{
-  struct gimple_statement_base base;
-  tree types;
-  gimple handler;
-};
-
-/* GS_EH_FILTER */
-struct gimple_statement_eh_filter GTY(())
-{
-  struct gimple_statement_base base;
-  /* Filter types.  */
-  tree types;
-  /* Failure actions.  */
-  gimple failure;
-};
-
-/* GS_LABEL */
-struct gimple_statement_label GTY(())
-{
-  struct gimple_statement_base base;
-  tree label;
-};
-
-/* GS_PHI */
-struct gimple_statement_phi GTY(())
-{
-  struct gimple_statement_base base;
-  unsigned capacity;
-  unsigned nargs;
-  tree result;
-  struct phi_arg_d GTY ((length ("%h.nargs"))) args[1];
-};
-
-/* GS_RESX */
-struct gimple_statement_resx GTY(())
-{
-  struct gimple_statement_base base;
-  /* Exception region number.  */
-  int region;
-};
-
-/* GS_TRY */
-struct gimple_statement_try GTY(())
-{
-  struct gimple_statement_base base;
-  /* Expression to evaluate.  */
-  struct gs_sequence eval;
-  /* Cleanup expression.  */
-  struct gs_sequence cleanup;
-};
-
-/* Flags stored in GS_TRY's subcode flags.  */
-#define GS_TRY_CATCH 1 << 0
-#define GS_TRY_FINALLY 1 << 1
-
-/* GS_ASSIGN */
-struct gimple_statement_assign_binary GTY(())
-{
-  struct gimple_statement_with_ops with_ops;
-  tree op[3];
-};
-
-struct gimple_statement_assign_unary_reg GTY(())
-{
-  struct gimple_statement_with_ops with_ops;
-  tree op[2];
-};
-
-struct gimple_statement_assign_unary_mem GTY(())
-{
-  struct gimple_statement_with_memory_ops with_mem_ops;
-  tree op[2];
-};
-
-/* GS_COND */
-struct gimple_statement_cond GTY(())
-{
-  struct gimple_statement_with_ops with_ops;
-  tree op[2];
-  tree label_true;
-  tree label_false;
-};
-
-/* GS_GOTO */
-struct gimple_statement_goto GTY(())
-{
-  struct gimple_statement_with_ops with_ops;
-  tree dest;
-};
-
-/* GS_SWITCH */
-struct gimple_statement_switch GTY(())
-{
-  struct gimple_statement_with_ops with_ops;
-  unsigned int nlabels;
-  tree index;
-  tree GTY ((length ("%h.nlabels + 1"))) labels[1];
-};
-
-/* GS_ASM */
-struct gimple_statement_asm GTY(())
-{
-  struct gimple_statement_with_memory_ops with_mem_ops;
-  const char *string;
-  /* Number of inputs.  */
-  unsigned ni;
-  /* Number of outputs.  */
-  unsigned no;
-  /* Number of clobbers.  */
-  unsigned nc;
-  tree GTY ((length ("%h.ni+%h.no+%h.nc"))) op[1];
-};
-
-/* GS_CALL */
-struct gimple_statement_call GTY(())
-{
-  struct gimple_statement_with_memory_ops with_mem_ops;
-  tree lhs;
-  tree fn;
-  tree chain;
-  size_t nargs;
-  tree GTY ((length ("%h.nargs"))) args[1];
-};
-
-/* GS_RETURN */
-struct gimple_statement_return GTY(())
-{
-  struct gimple_statement_with_memory_ops with_mem_ops;
-  tree retval;
-};
-
-/* GS_OMP_CRITICAL */
-struct gimple_statement_omp_critical GTY(())
-{
-  struct gimple_statement_omp omp;
-  /* Critical section name.  */
-  tree name;
-};
-
-/* GS_OMP_FOR */
-struct gimple_statement_omp_for GTY(())
-{
-  struct gimple_statement_omp omp;
-  tree clauses;
-  /* Index variable.  */
-  tree index;
-  /* Initial value.  */
-  tree initial;
-  /* Final value.  */
-  tree final;
-  /* Increment.  */
-  tree incr;
-  /* Pre-body evaluated before the loop body begins.  */
-  struct gs_sequence pre_body;
-};
-
-/* Predicate for conds. */
-enum gs_cond {
-  /* These must be in sync with op_gs_cond().  */
-  GS_COND_LT, GS_COND_GT, GS_COND_LE, GS_COND_GE, GS_COND_EQ, GS_COND_NE
-};
-
-/* GS_OMP_PARALLEL */
-struct gimple_statement_omp_parallel GTY(())
-{
-  struct gimple_statement_omp omp;
-  tree clauses;
-  tree child_fn;
-  /* Shared data argument.  */
-  tree data_arg;
-};
-
-/* GS_OMP_SECTION */
-/* Uses struct gimple_statement_omp.  */
-
-/* GS_OMP_SECTIONS */
-struct gimple_statement_omp_sections GTY(())
-{
-  struct gimple_statement_omp omp;
-  tree clauses;
-};
-
-/* GS_OMP_SINGLE */
-struct gimple_statement_omp_single GTY(())
-{
-  struct gimple_statement_omp omp;
-  tree clauses;
-};
-
-/* GS_OMP_RETURN */
-/* Flags stored in GS_OMP_RETURN's subcode flags.*/
-#define OMP_RETURN_NOWAIT_FLAG 1 << 0
-
-enum gimple_statement_structure_enum {
-#define DEFGSSTRUCT(SYM, STRING)	SYM,
-#include "gsstruct.def"
-#undef DEFGSSTRUCT
-    LAST_GSS_ENUM
-};
-
-/* Define the overall contents of a gimple tuple.  It may be any of the
-   structures declared above for various types of tuples.  */
-
-union gimple_statement_d GTY ((desc ("gimple_statement_structure (&%h)")))
-{
-  struct gimple_statement_base GTY ((tag ("GSS_BASE"))) base;
-  /* We never really return GSS_WITH_OPS or GSS_WITH_MEM_OPS in
-     gimple_statement_structure() since they're subsumed by the other
-     tuples.  We only include the tags for completeness.  */
-  struct gimple_statement_with_ops GTY ((tag ("GSS_WITH_OPS"))) with_ops;
-  struct gimple_statement_with_memory_ops GTY ((tag ("GSS_WITH_MEM_OPS"))) with_mem_ops;
-  struct gimple_statement_omp GTY ((tag ("GSS_OMP"))) omp;
-
-  struct gimple_statement_bind GTY ((tag ("GSS_BIND"))) gs_bind;
-  struct gimple_statement_catch GTY ((tag ("GSS_CATCH"))) gs_catch;
-  struct gimple_statement_eh_filter GTY ((tag ("GSS_EH_FILTER"))) gs_eh_filter;
-  struct gimple_statement_label GTY ((tag ("GSS_LABEL"))) gs_label;
-  struct gimple_statement_phi GTY ((tag ("GSS_PHI"))) gs_phi;
-  struct gimple_statement_resx GTY ((tag ("GSS_RESX"))) gs_resx;
-  struct gimple_statement_try GTY ((tag ("GSS_TRY"))) gs_try;
-  struct gimple_statement_assign_binary GTY ((tag ("GSS_ASSIGN_BINARY"))) gs_assign_binary;
-  struct gimple_statement_assign_unary_reg GTY ((tag ("GSS_ASSIGN_UNARY_REG"))) gs_assign_unary_reg;
-  struct gimple_statement_assign_unary_mem GTY ((tag ("GSS_ASSIGN_UNARY_MEM"))) gs_assign_unary_mem;
-  struct gimple_statement_cond GTY ((tag ("GSS_COND"))) gs_cond;
-  struct gimple_statement_goto GTY ((tag ("GSS_GOTO"))) gs_goto;
-  struct gimple_statement_switch GTY ((tag ("GSS_SWITCH"))) gs_switch;
-  struct gimple_statement_asm GTY ((tag ("GSS_ASM"))) gs_asm;
-  struct gimple_statement_call GTY ((tag ("GSS_CALL"))) gs_call;
-  struct gimple_statement_return GTY ((tag ("GSS_RETURN"))) gs_return;
-  struct gimple_statement_omp_critical GTY ((tag ("GSS_OMP_CRITICAL"))) gs_omp_critical;
-  struct gimple_statement_omp_for GTY ((tag ("GSS_OMP_FOR"))) gs_omp_for;
-  struct gimple_statement_omp_parallel GTY ((tag ("GSS_OMP_PARALLEL"))) gs_omp_parallel;
-  struct gimple_statement_omp_sections GTY ((tag ("GSS_OMP_SECTIONS"))) gs_omp_sections;
-  struct gimple_statement_omp_single GTY ((tag ("GSS_OMP_SINGLE"))) gs_omp_single;
-};
-
-/* Prototypes.  */
-
-extern gimple gs_build_return (bool, tree);
-extern gimple gs_build_assign (tree, tree);
-extern gimple gs_build_call_vec (tree, VEC(tree, gc) *);
-extern gimple gs_build_call (tree, size_t, ...);
-extern gimple gs_build_cond (enum gs_cond, tree, tree, tree, tree);
-extern void gs_cond_invert (gimple);
-extern gimple gs_build_label (tree label);
-extern gimple gs_build_goto (tree dest);
-extern gimple gs_build_nop (void);
-extern gimple gs_build_bind (tree, gs_seq);
-extern gimple gs_build_asm (const char *, unsigned, unsigned, unsigned, ...);
-extern gimple gs_build_catch (tree, gimple);
-extern gimple gs_build_eh_filter (tree, gimple);
-extern gimple gs_build_try (gs_seq, gs_seq, unsigned int);
-extern gimple gs_build_phi (unsigned, unsigned, tree, ...);
-extern gimple gs_build_resx (int);
-extern gimple gs_build_switch (unsigned int, tree, tree, ...);
-extern gimple gs_build_switch_vec (tree, tree, VEC(tree,heap) *);
-extern gimple gs_omp_build_parallel (gs_seq, tree, tree, tree);
-extern gimple gs_omp_build_for (gs_seq, tree, tree, tree, tree, tree, gs_seq,
-				enum gs_cond);
-extern gimple gs_omp_build_critical (gs_seq, tree);
-extern gimple gs_omp_build_section (gs_seq);
-extern gimple gs_omp_build_continue (gs_seq);
-extern gimple gs_omp_build_master (gs_seq);
-extern gimple gs_omp_build_return (bool);
-extern gimple gs_omp_build_ordered (gs_seq);
-extern gimple gs_omp_build_sections (gs_seq, tree);
-extern gimple gs_omp_build_single (gs_seq, tree);
-extern enum gimple_statement_structure_enum gimple_statement_structure (gimple);
-extern void gs_add (gs_seq, gimple);
-extern void gs_push (gimple, gs_seq);
-extern gimple gs_pop (gs_seq);
-extern enum gimple_statement_structure_enum gss_for_assign (enum tree_code);
-extern void sort_case_labels (VEC(tree,heap) *);
-extern void walk_tuple_ops (gimple, walk_tree_fn, void *,
-    			    struct pointer_set_t *);
-extern void walk_seq_ops (gs_seq, walk_tree_fn, void *, struct pointer_set_t *);
-extern void set_gimple_body (tree, gs_seq);
-extern gs_seq gimple_body (tree);
-
-extern const char *const gs_code_name[];
-
-/* Error out if a gimple tuple is addressed incorrectly.  */
-#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
-
-extern void gs_check_failed (const gimple, const char *, int, const char *, \
-    			     unsigned int, unsigned int) ATTRIBUTE_NORETURN;
-
-#define GS_CHECK(GS, CODE) __extension__				\
-  ({  const gimple __gs = (GS);						\
-      if (GS_CODE (__gs) != (CODE))					\
-        gs_check_failed (__gs, __FILE__, __LINE__, __FUNCTION__,	\
-	  		 (CODE), 0);					\
-      __gs; })
-
-#define GS_CHECK2(GS, CODE1, CODE2) __extension__			\
-  ({  const gimple __gs = (GS);						\
-      if (GS_CODE (__gs) != (CODE1)					\
-	  || GS_SUBCODE_FLAGS (__gs) != (CODE2))			\
-        gs_check_failed (__gs, __FILE__, __LINE__, __FUNCTION__,	\
-	  		 (CODE1), (CODE2));				\
-      __gs; })
-#else  /* not ENABLE_TREE_CHECKING, or not gcc */
-#define GS_CHECK(GS, CODE)	(GS)
-#define GS_CHECK2(GS, C1, C2)	(GS)
-#endif
-
-/* GIMPLE IR accessor functions.  */
-
-/* GS_ASSIGN accessors.  */
-
-/* Get an operand in a GS_ASSIGN.
-
-   OPNO is the number of the operand to get.
-   GS is a GS_ASSIGN statement.  */
-
-static inline tree
-gs_assign_operand (gimple gs, size_t opno)
-{
-  enum gimple_statement_structure_enum gss;
-
-  GS_CHECK (gs, GS_ASSIGN);
-
-  gss = gimple_statement_structure (gs);
-  if (gss == GSS_ASSIGN_BINARY)
-    return gs->gs_assign_binary.op[opno];
-  else if (gss == GSS_ASSIGN_UNARY_REG)
-    return gs->gs_assign_unary_reg.op[opno];
-  else if (gss == GSS_ASSIGN_UNARY_MEM)
-    return gs->gs_assign_unary_mem.op[opno];
-
-  gcc_unreachable ();
-}
-
-/* Set an operand in a GS_ASSIGN.
-
-   OPNO is the number of the operand to set.
-   GS is a GS_ASSIGN statement.
-   OP is the tree to set the operand to.  */
-
-static inline void
-gs_assign_set_operand (gimple gs, size_t opno, tree op)
-{
-  enum gimple_statement_structure_enum gss;
-
-  GS_CHECK (gs, GS_ASSIGN);
-
-  gss = gimple_statement_structure (gs);
-  if (gss == GSS_ASSIGN_BINARY) 
-    {
-      gcc_assert (opno <= 2);
-      gs->gs_assign_binary.op[opno] = op;
-      return;
-    }
-  else if (gss == GSS_ASSIGN_UNARY_REG)
-    {
-      gcc_assert (opno <= 1);
-      gs->gs_assign_unary_reg.op[opno] = op;
-      return;
-    }
-  else if (gss == GSS_ASSIGN_UNARY_MEM)
-    {
-      gcc_assert (opno <= 1);
-      gs->gs_assign_unary_mem.op[opno] = op;
-      return;
-    }
-
-  gcc_unreachable ();
-}
-
-static inline tree
-gs_assign_lhs (gimple gs)
-{
-  return gs_assign_operand (gs, 0);
-}
-
-static inline void
-gs_assign_set_lhs (gimple gs, tree lhs)
-{
-  gs_assign_set_operand (gs, 0, lhs);
-}
-
-static inline tree
-gs_assign_binary_rhs1 (gimple gs)
-{
-#if defined ENABLE_CHECKING
-  enum gimple_statement_structure_enum gss;
-  gss = gss_for_assign (GS_SUBCODE_FLAGS (gs));
-  gcc_assert (gss == GSS_ASSIGN_BINARY);
-#endif
-  return gs_assign_operand (gs, 1);
-}
-
-static inline void
-gs_assign_binary_set_rhs1 (gimple gs, tree rhs)
-{
-#if defined ENABLE_CHECKING
-  enum gimple_statement_structure_enum gss;
-  gss = gss_for_assign (GS_SUBCODE_FLAGS (gs));
-  gcc_assert (gss == GSS_ASSIGN_BINARY);
-#endif
-  gs_assign_set_operand (gs, 1, rhs);
-}
-
-static inline tree
-gs_assign_binary_rhs2 (gimple gs)
-{
-#if defined ENABLE_CHECKING
-  enum gimple_statement_structure_enum gss;
-  gss = gss_for_assign (GS_SUBCODE_FLAGS (gs));
-  gcc_assert (gss == GSS_ASSIGN_BINARY);
-#endif
-  return gs_assign_operand (gs, 2);
-}
-
-static inline void
-gs_assign_binary_set_rhs2 (gimple gs, tree rhs)
-{
-#if defined ENABLE_CHECKING
-  enum gimple_statement_structure_enum gss;
-  gss = gss_for_assign (GS_SUBCODE_FLAGS (gs));
-  gcc_assert (gss == GSS_ASSIGN_BINARY);
-#endif
-  gs_assign_set_operand (gs, 2, rhs);
-}
-
-static inline tree
-gs_assign_unary_rhs (gimple gs)
-{
-#if defined ENABLE_CHECKING
-  enum gimple_statement_structure_enum gss;
-  gss = gss_for_assign (GS_SUBCODE_FLAGS (gs));
-  gcc_assert (gss == GSS_ASSIGN_UNARY_REG || gss == GSS_ASSIGN_UNARY_MEM);
-#endif
-  return gs_assign_operand (gs, 1);
-}
-
-static inline void
-gs_assign_unary_set_rhs (gimple gs, tree rhs)
-{
-#if defined ENABLE_CHECKING
-  enum gimple_statement_structure_enum gss;
-  gss = gss_for_assign (GS_SUBCODE_FLAGS (gs));
-  gcc_assert (gss == GSS_ASSIGN_UNARY_REG || gss == GSS_ASSIGN_UNARY_MEM);
-#endif
-  gs_assign_set_operand (gs, 1, rhs);
-}
-
-
-/* GS_CALL accessors. */
-
-static inline tree
-gs_call_fn (gimple gs)
-{
-  GS_CHECK (gs, GS_CALL);
-  return gs->gs_call.fn;
-}
-
-static inline tree
-gs_call_lhs (gimple gs)
-{
-  GS_CHECK (gs, GS_CALL);
-  return gs->gs_call.lhs;
-}
-
-static inline void
-gs_call_set_lhs (gimple gs, tree lhs)
-{
-  GS_CHECK (gs, GS_CALL);
-  gs->gs_call.lhs = lhs;
-}
-
-static inline tree
-gs_call_chain (gimple gs)
-{
-  GS_CHECK (gs, GS_CALL);
-  return gs->gs_call.chain;
-}
-
-static inline void
-gs_call_set_chain (gimple gs, tree chain)
-{
-  GS_CHECK (gs, GS_CALL);
-  gs->gs_call.chain = chain;
-}
-
-static inline unsigned long
-gs_call_nargs (gimple gs)
-{
-  GS_CHECK (gs, GS_CALL);
-  return gs->gs_call.nargs;
-}
-
-static inline tree
-gs_call_arg (gimple gs, int index)
-{
-  GS_CHECK (gs, GS_CALL);
-  return gs->gs_call.args[index];
-}
-
-static inline void
-gs_call_set_arg (gimple gs, int index, tree arg)
-{
-  GS_CHECK (gs, GS_CALL);
-  gs->gs_call.args[index] = arg;
-}
-
-
-/* GS_COND accessors. */
-
-static inline tree
-gs_cond_lhs (gimple gs)
-{
-  GS_CHECK (gs, GS_COND);
-  return gs->gs_cond.op[0];
-}
-
-static inline void
-gs_cond_set_lhs (gimple gs, tree lhs)
-{
-  GS_CHECK (gs, GS_COND);
-  gs->gs_cond.op[0] = lhs;
-}
-
-static inline tree
-gs_cond_rhs (gimple gs)
-{
-  GS_CHECK (gs, GS_COND);
-  return gs->gs_cond.op[1];
-}
-
-static inline void
-gs_cond_set_rhs (gimple gs, tree rhs)
-{
-  GS_CHECK (gs, GS_COND);
-  gs->gs_cond.op[1] = rhs;
-}
-
-static inline tree
-gs_cond_true_label (gimple gs)
-{
-  GS_CHECK (gs, GS_COND);
-  return gs->gs_cond.label_true;
-}
-
-static inline void
-gs_cond_set_true_label (gimple gs, tree label)
-{
-  GS_CHECK (gs, GS_COND);
-  gs->gs_cond.label_true = label;
-}
-
-static inline void
-gs_cond_set_false_label (gimple gs, tree label)
-{
-  GS_CHECK (gs, GS_COND);
-  gs->gs_cond.label_false = label;
-}
-
-static inline tree
-gs_cond_false_label (gimple gs)
-{
-  GS_CHECK (gs, GS_COND);
-  return gs->gs_cond.label_false;
-}
-
-/* GS_LABEL accessors. */
-
-static inline tree
-gs_label_label (gimple gs)
-{
-  GS_CHECK (gs, GS_LABEL);
-  return gs->gs_label.label;
-}
-static inline void
-gs_label_set_label (gimple gs, tree label)
-{
-  GS_CHECK (gs, GS_LABEL);
-  gs->gs_label.label = label;
-}
-
-/* GS_GOTO accessors. */
-
-static inline tree
-gs_goto_dest (gimple gs)
-{
-  GS_CHECK (gs, GS_GOTO);
-  return gs->gs_goto.dest;
-}
-static inline void 
-gs_goto_set_dest (gimple gs, tree dest)
-{
-  GS_CHECK (gs, GS_GOTO);
-  gs->gs_goto.dest =  dest;
-}
-
-/* GS_BIND accessors. */
-
-static inline tree
-gs_bind_vars (gimple gs)
-{
-  GS_CHECK (gs, GS_BIND);
-  return gs->gs_bind.vars;
-}
-
-static inline void
-gs_bind_set_vars (gimple gs, tree vars)
-{
-  GS_CHECK (gs, GS_BIND);
-  gs->gs_bind.vars = vars;
-}
-
-static inline gs_seq
-gs_bind_body (gimple gs) {
-  GS_CHECK (gs, GS_BIND);
-  return &(gs->gs_bind.body);
-}
-
-static inline void
-gs_bind_set_body (gimple gs, gs_seq seq)
-{
-  GS_CHECK (gs, GS_BIND);
-  gs_seq_copy (&(gs->gs_bind.body), seq);
-}
-
-/* GS_ASM accessors. */
-static inline unsigned int
-gs_asm_ninputs (gimple gs)
-{
-  GS_CHECK (gs, GS_ASM);
-  return gs->gs_asm.ni;
-}
-
-static inline void
-gs_asm_set_ninputs (gimple gs, unsigned ni)
-{
-  GS_CHECK (gs, GS_ASM);
-  gs->gs_asm.ni = ni;
-}
-
-static inline unsigned int
-gs_asm_noutputs (gimple gs)
-{
-  GS_CHECK (gs, GS_ASM);
-  return gs->gs_asm.no;
-}
-
-static inline void
-gs_asm_set_noutputs (gimple gs, unsigned no)
-{
-  GS_CHECK (gs, GS_ASM);
-  gs->gs_asm.no = no;
-}
-
-static inline unsigned int
-gs_asm_nclobbered (gimple gs)
-{
-  GS_CHECK (gs, GS_ASM);
-  return gs->gs_asm.nc;
-}
-
-static inline void
-gs_asm_set_nclobbered (gimple gs, unsigned nc)
-{
-  GS_CHECK (gs, GS_ASM);
-  gs->gs_asm.nc = nc;
-}
-
-static inline tree
-gs_asm_input_op (gimple gs, unsigned int index)
-{
-  GS_CHECK (gs, GS_ASM);
-  gcc_assert (index <= gs->gs_asm.ni);
-  return gs->gs_asm.op[index];
-}
-
-static inline void
-gs_asm_set_input_op (gimple gs, unsigned int index, tree in_op)
-{
-  GS_CHECK (gs, GS_ASM);
-  gcc_assert (index <= gs->gs_asm.ni);
-  gs->gs_asm.op[index] = in_op;
-}
-
-static inline tree
-gs_asm_output_op (gimple gs, unsigned int index)
-{
-  GS_CHECK (gs, GS_ASM);
-  gcc_assert (index <= gs->gs_asm.no);
-  return gs->gs_asm.op[index + gs->gs_asm.ni];
-}
-
-static inline void
-gs_asm_set_output_op (gimple gs, unsigned int index, tree out_op)
-{
-  GS_CHECK (gs, GS_ASM);
-  gcc_assert (index <= gs->gs_asm.no);
-  gs->gs_asm.op[index + gs->gs_asm.ni] = out_op;
-}
-
-static inline tree
-gs_asm_clobber_op (gimple gs, unsigned int index)
-{
-  GS_CHECK (gs, GS_ASM);
-  gcc_assert (index <= gs->gs_asm.nc);
-  return gs->gs_asm.op[index + gs->gs_asm.ni + gs->gs_asm.no];
-}
-
-static inline void
-gs_asm_set_clobber_op (gimple gs, unsigned int index, tree clobber_op)
-{
-  GS_CHECK (gs, GS_ASM);
-  gcc_assert (index <= gs->gs_asm.nc);
-  gs->gs_asm.op[index + gs->gs_asm.ni + gs->gs_asm.no] = clobber_op;
-}
-
-static inline const char *
-gs_asm_string (gimple gs)
-{
-  GS_CHECK (gs, GS_ASM);
-  return gs->gs_asm.string;
-}
-
-static inline void
-gs_asm_set_string (gimple gs, const char* string) 
-{
-  GS_CHECK (gs, GS_ASM);
-  gs->gs_asm.string = string;
-}
-
-/* GS_CATCH accessors. */
-
-static inline tree
-gs_catch_types (gimple gs)
-{
- GS_CHECK (gs, GS_CATCH);
- return gs->gs_catch.types;
-}
-
-static inline gimple
-gs_catch_handler (gimple gs)
-{
-  GS_CHECK (gs, GS_CATCH);
-  return gs->gs_catch.handler;
-}
-
-static inline void
-gs_catch_set_types (gimple gs, tree t)
-{
-  GS_CHECK (gs, GS_CATCH);
-  gs->gs_catch.types = t;
-}
-
-static inline void
-gs_catch_set_handler (gimple gs, gimple handler)
-{
-  GS_CHECK (gs, GS_CATCH);
-  gs->gs_catch.handler = handler;
-}
-
-/* GS_EH_FILTER accessors. */
-
-static inline tree
-gs_eh_filter_types (gimple gs)
-{
-  GS_CHECK (gs, GS_EH_FILTER);
-  return gs->gs_eh_filter.types;
-}
-
-static inline gimple
-gs_eh_filter_failure (gimple gs)
-{
-  GS_CHECK (gs, GS_EH_FILTER);
-  return gs->gs_eh_filter.failure;
-}
-
-static inline void
-gs_eh_filter_set_types (gimple gs, tree types)
-{
-  GS_CHECK (gs, GS_EH_FILTER);
-  gs->gs_eh_filter.types = types;
-}
-
-static inline void
-gs_eh_filter_set_failure (gimple gs, gimple failure)
-{
-  GS_CHECK (gs, GS_EH_FILTER);
-  gs->gs_eh_filter.failure = failure;
-}
-
-
-/* GS_TRY accessors. */
-
-static inline gs_seq
-gs_try_eval (gimple gs)
-{
-  GS_CHECK (gs, GS_TRY);
-  return &gs->gs_try.eval;
-}
-
-static inline gs_seq
-gs_try_cleanup (gimple gs)
-{
-  GS_CHECK (gs, GS_TRY);
-  return &gs->gs_try.cleanup;
-}
-
-static inline void
-gs_try_set_eval (gimple gs, gs_seq eval)
-{
-  GS_CHECK (gs, GS_TRY);
-  gs_seq_copy (gs_try_eval (gs), eval);
-}
-
-static inline void
-gs_try_set_cleanup (gimple gs, gs_seq cleanup)
-{
-  GS_CHECK (gs, GS_TRY);
-  gs_seq_copy (gs_try_cleanup (gs), cleanup);
-}
-
-/* GS_PHI accessors. */
-
-static inline unsigned int
-gs_phi_capacity (gimple gs)
-{
-    GS_CHECK (gs, GS_PHI);
-    return gs->gs_phi.capacity;
-}
-
-static inline void
-gs_phi_set_capacity (gimple gs, unsigned int capacity)
-{
-  GS_CHECK (gs, GS_PHI);
-  gs->gs_phi.capacity = capacity;
-}
-
-static inline unsigned int
-gs_phi_nargs (gimple gs)
-{
-  GS_CHECK (gs, GS_PHI);
-  return gs->gs_phi.nargs;
-}
-
-static inline void
-gs_phi_set_nargs (gimple gs, unsigned int nargs)
-{
-  GS_CHECK (gs, GS_PHI);
-  gs->gs_phi.nargs = nargs;
-}
-
-static inline tree
-gs_phi_result (gimple gs)
-{
-  GS_CHECK (gs, GS_PHI);
-  return gs->gs_phi.result;
-}
-
-static inline void
-gs_phi_set_result (gimple gs, tree result)
-{
-  GS_CHECK (gs, GS_PHI);
-  gs->gs_phi.result = result;
-}
-
-static inline struct phi_arg_d *
-gs_phi_arg (gimple gs, unsigned int index)
-{
-  GS_CHECK (gs, GS_PHI);
-  gcc_assert (index <= gs->gs_phi.nargs);
-  return &(gs->gs_phi.args[index]);
-}
-
-static inline void
-gs_phi_set_arg (gimple gs, unsigned int index, struct phi_arg_d * phiarg)
-{
-  GS_CHECK (gs, GS_PHI);
-  gcc_assert (index <= gs->gs_phi.nargs);
-  memcpy (gs->gs_phi.args + index, phiarg, sizeof (struct phi_arg_d));
-}
-
-/* GS_RESX accessors. */
-
-static inline int
-gs_resx_region (gimple gs)
-{
-  GS_CHECK (gs, GS_RESX);
-  return gs->gs_resx.region;
-}
-
-static inline void
-gs_resx_set_region (gimple gs, int region)
-{
-  GS_CHECK (gs, GS_RESX);
-  gs->gs_resx.region = region;
-}
-
-/* GS_SWITCH accessors. */
-
-static inline unsigned int
-gs_switch_nlabels (gimple gs)
-{
-  GS_CHECK (gs, GS_SWITCH);
-  return gs->gs_switch.nlabels;
-}
-
-static inline void
-gs_switch_set_nlabels (gimple gs, unsigned int nlabels)
-{
-  GS_CHECK (gs, GS_SWITCH);
-  gs->gs_switch.nlabels = nlabels;
-}
-
-static inline tree
-gs_switch_index (gimple gs)
-{
-  GS_CHECK (gs, GS_SWITCH);
-  return gs->gs_switch.index;
-}
-
-static inline void
-gs_switch_set_index (gimple gs, tree index)
-{
-  GS_CHECK (gs, GS_SWITCH);
-  gs->gs_switch.index = index;
-}
-
-static inline tree
-gs_switch_default_label (gimple gs)
-{
-  GS_CHECK (gs, GS_SWITCH);
-  return gs->gs_switch.labels[0];
-}
-
-static inline void
-gs_switch_set_default_label (gimple gs, tree label)
-{
-  GS_CHECK (gs, GS_SWITCH);
-  gs->gs_switch.labels[0] = label;
-}
-
-/* Return the label numbered INDEX.  The default label is 0, followed by any
-   labels in a switch statement.  */
-
-static inline tree
-gs_switch_label (gimple gs, int index)
-{
-  GS_CHECK (gs, GS_SWITCH);
-  gcc_assert ((unsigned)index <= gs->gs_switch.nlabels);
-  return gs->gs_switch.labels[index];
-}
-
-/* Set the label number INDEX to LABEL.  0 is always the default label.  */
-
-static inline void
-gs_switch_set_label (gimple gs, int index, tree label)
-{
-  GS_CHECK (gs, GS_SWITCH);
-  gcc_assert ((unsigned)index <= gs->gs_switch.nlabels);
-  gs->gs_switch.labels[index] = label;
-}
-
-/* GS_OMP_* accessors. */
-
-static inline gs_seq 
-gs_omp_body (gimple gs)
-{
-  return &(gs->omp.body);
-}
-
-static inline void
-gs_omp_set_body (gimple gs, gs_seq body)
-{
-  gs_seq_copy (&(gs->omp.body), body);
-}
-
-/* GS_OMP_CRITICAL accessors. */
-
-static inline tree
-gs_omp_critical_name (gimple gs)
-{
-  GS_CHECK (gs, GS_OMP_CRITICAL);
-  return gs->gs_omp_critical.name;
-}
-
-static inline void
-gs_omp_critical_set_name (gimple gs, tree name)
-{
-  GS_CHECK (gs, GS_OMP_CRITICAL);
-  gs->gs_omp_critical.name = name;
-}
-
-/* GS_OMP_FOR accessors. */
-
-static inline tree
-gs_omp_for_clauses (gimple gs)
-{
-  GS_CHECK (gs, GS_OMP_FOR);
-  return gs->gs_omp_for.clauses;
-}
-
-static inline void
-gs_omp_for_set_clauses (gimple gs, tree clauses)
-{
-  GS_CHECK (gs, GS_OMP_FOR);
-  gs->gs_omp_for.clauses = clauses;
-}
-
-static inline tree
-gs_omp_for_index (gimple gs)
-{
-  GS_CHECK (gs, GS_OMP_FOR);
-  return gs->gs_omp_for.index;
-}
-
-static inline void
-gs_omp_for_set_index (gimple gs, tree index)
-{
-  GS_CHECK (gs, GS_OMP_FOR);
-  gs->gs_omp_for.index = index;
-}
-
-static inline tree
-gs_omp_for_initial (gimple gs)
-{
-  GS_CHECK (gs, GS_OMP_FOR);
-  return gs->gs_omp_for.initial;
-}
-
-static inline void
-gs_omp_for_set_initial (gimple gs, tree initial)
-{
-  GS_CHECK (gs, GS_OMP_FOR);
-  gs->gs_omp_for.initial = initial;
-}
-
-static inline tree
-gs_omp_for_final (gimple gs)
-{
-  GS_CHECK (gs, GS_OMP_FOR);
-  return gs->gs_omp_for.final;
-}
-
-static inline void
-gs_omp_for_set_final (gimple gs, tree final)
-{
-  GS_CHECK (gs, GS_OMP_FOR);
-  gs->gs_omp_for.final = final;
-}
-
-static inline tree
-gs_omp_for_incr (gimple gs)
-{
-  GS_CHECK (gs, GS_OMP_FOR);
-  return gs->gs_omp_for.incr;
-}
-
-static inline void
-gs_omp_for_set_incr (gimple gs, tree incr)
-{
-  GS_CHECK (gs, GS_OMP_FOR);
-  gs->gs_omp_for.incr = incr;
-}
-
-static inline gs_seq
-gs_omp_for_pre_body (gimple gs)
-{
-  GS_CHECK (gs, GS_OMP_FOR);
-  return &(gs->gs_omp_for.pre_body);
-}
-
-static inline void
-gs_omp_for_set_pre_body (gimple gs, gs_seq pre_body)
-{
-  GS_CHECK (gs, GS_OMP_FOR);
-  gs_seq_copy (&(gs->gs_omp_for.pre_body),  pre_body);
-}
-
-/* GS_OMP_PARALLEL accessors. */
-
-static inline tree
-gs_omp_parallel_clauses (gimple gs)
-{
-  GS_CHECK (gs, GS_OMP_PARALLEL);
-  return gs->gs_omp_parallel.clauses;
-}
-
-static inline void
-gs_omp_parallel_set_clauses (gimple gs, tree clauses)
-{
-  GS_CHECK (gs, GS_OMP_PARALLEL);
-  gs->gs_omp_parallel.clauses = clauses;
-}
-
-static inline tree
-gs_omp_parallel_child_fn (gimple gs)
-{
-  GS_CHECK (gs, GS_OMP_PARALLEL);
-  return gs->gs_omp_parallel.child_fn;
-}
-
-static inline void
-gs_omp_parallel_set_child_fn (gimple gs, tree child_fn)
-{
-  GS_CHECK (gs, GS_OMP_PARALLEL);
-  gs->gs_omp_parallel.child_fn = child_fn;
-}
-
-static inline tree
-gs_omp_parallel_data_arg (gimple gs)
-{
-  GS_CHECK (gs, GS_OMP_PARALLEL);
-  return gs->gs_omp_parallel.data_arg;
-}
-
-static inline void
-gs_omp_parallel_set_data_arg (gimple gs, tree data_arg)
-{
-  GS_CHECK (gs, GS_OMP_PARALLEL);
-  gs->gs_omp_parallel.data_arg = data_arg;
-}
-
-/* GS_OMP_SECTION accessors. */
-
-/* GS_OMP_SINGLE accessors. */
-
-static inline tree
-gs_omp_single_clauses (gimple gs)
-{
-  GS_CHECK (gs, GS_OMP_SINGLE);
-  return gs->gs_omp_single.clauses;
-}
-
-static inline void
-gs_omp_single_set_clauses (gimple gs, tree clauses)
-{
-  GS_CHECK (gs, GS_OMP_SINGLE);
-  gs->gs_omp_single.clauses = clauses;
-}
-
-static inline tree
-gs_omp_sections_clauses (gimple gs)
-{
-  GS_CHECK (gs, GS_OMP_SECTIONS);
-  return gs->gs_omp_sections.clauses;
-}
-
-static inline void
-gs_omp_sections_set_clauses (gimple gs, tree clauses)
-{
-  GS_CHECK (gs, GS_OMP_SECTIONS);
-  gs->gs_omp_sections.clauses = clauses;
-}
-
-
-
-/* get or set the OMP_FOR_COND stored in the subcode flags */
-static inline void
-gs_assign_omp_for_cond (gimple gs, enum gs_cond cond)
-{
-  GS_CHECK (gs, GS_OMP_FOR);
-  GS_SUBCODE_FLAGS (gs) =  cond;
-}
-
-static inline enum gs_cond
-gs_omp_for_cond (gimple gs)
-{
-  GS_CHECK (gs, GS_OMP_FOR);
-  return (enum gs_cond) GS_SUBCODE_FLAGS (gs);
-}
-
-/* GS_RETURN accessors.  */
-
-static inline tree
-gs_return_retval (gimple gs)
-{
-  GS_CHECK (gs, GS_RETURN);
-  return gs->gs_return.retval;
-}
-
-static inline void
-gs_return_set_retval (gimple gs, tree retval)
-{
-  GS_CHECK (gs, GS_RETURN);
-  gs->gs_return.retval = retval;
-}
-
-/* Append sequence SRC to the end of sequence DST.  */
-
-static inline void
-gs_seq_append (gs_seq dst, gs_seq src)
-{
-  if (!gs_seq_empty_p (src))
-    gs_add (dst, gs_seq_first (src));
-}
-
-static inline void
-gs_add_subcode_flag (gimple g, unsigned int flag)
-{
-  GS_SUBCODE_FLAGS (g) |= flag;
-}
-
-#include "gimple-iterator.h"
-
-#endif  /* GCC_GIMPLE_IR_H */
Index: gimplify.c
===================================================================
--- gimplify.c	(revision 126668)
+++ gimplify.c	(working copy)
@@ -51,7 +51,7 @@ Software Foundation, 51 Franklin Street,
 #include "pointer-set.h"
 #include "splay-tree.h"
 #include "vec.h"
-#include "gimple-ir.h"
+#include "gimple.h"
 
 
 enum gimplify_omp_var_data
Index: Makefile.in
===================================================================
--- Makefile.in	(revision 126643)
+++ Makefile.in	(working copy)
@@ -735,7 +735,7 @@ BUILTINS_DEF = builtins.def sync-builtin
 TREE_H = tree.h tree.def $(MACHMODE_H) tree-check.h $(BUILTINS_DEF) \
           input.h statistics.h vec.h treestruct.def $(HASHTAB_H) \
           double-int.h
-GIMPLE_IR_H = gimple-ir.h gimple.def gsstruct.def gimple-iterator.h \
+GIMPLE_H = gimple.h gimple.def gsstruct.def gimple-iterator.h \
 	      pointer-set.h
 BASIC_BLOCK_H = basic-block.h bitmap.h sbitmap.h varray.h $(PARTITION_H) \
           hard-reg-set.h cfghooks.h $(OBSTACK_H)
@@ -778,7 +778,7 @@ MKDEPS_H = $(srcdir)/../libcpp/include/m
 SYMTAB_H = $(srcdir)/../libcpp/include/symtab.h
 CPP_ID_DATA_H = $(CPPLIB_H) $(srcdir)/../libcpp/include/cpp-id-data.h
 TREE_DUMP_H = tree-dump.h $(SPLAY_TREE_H)
-TREE_GIMPLE_H = tree-gimple.h tree-iterator.h gimple-ir.h gimple-iterator.h
+TREE_GIMPLE_H = tree-gimple.h tree-iterator.h gimple.h gimple-iterator.h
 TREE_FLOW_H = tree-flow.h tree-flow-inline.h tree-ssa-operands.h \
 		bitmap.h $(BASIC_BLOCK_H) hard-reg-set.h $(TREE_GIMPLE_H) \
 		$(HASHTAB_H) $(CGRAPH_H) $(IPA_REFERENCE_H)
@@ -1007,7 +1007,7 @@ OBJS-common = \
 	gcse.o \
 	genrtl.o \
 	ggc-common.o \
-	gimple-ir.o \
+	gimple.o \
 	gimple-low.o \
 	gimple-pretty-print.o \
 	gimplify.o \
@@ -2142,7 +2142,7 @@ c-gimplify.o : c-gimplify.c $(CONFIG_H) 
    $(FLAGS_H) langhooks.h toplev.h $(RTL_H) $(TREE_FLOW_H) $(LANGHOOKS_DEF_H) \
    $(TM_H) coretypes.h $(C_PRETTY_PRINT_H) $(CGRAPH_H) $(BASIC_BLOCK_H) \
    hard-reg-set.h $(TREE_DUMP_H) $(TREE_INLINE_H)
-gimplify.o : gimplify.c $(CONFIG_H) $(SYSTEM_H) $(TREE_H) $(GIMPLE_IR_H) \
+gimplify.o : gimplify.c $(CONFIG_H) $(SYSTEM_H) $(TREE_H) $(GIMPLE_H) \
    $(DIAGNOSTIC_H) $(TREE_GIMPLE_H) $(TREE_INLINE_H) $(VARRAY_H) langhooks.h \
    $(LANGHOOKS_DEF_H) $(TREE_FLOW_H) $(CGRAPH_H) $(TIMEVAR_H) $(TM_H) \
    coretypes.h except.h $(FLAGS_H) $(RTL_H) $(FUNCTION_H) $(EXPR_H) output.h \
@@ -2207,11 +2207,11 @@ tree-object-size.o: tree-object-size.c $
 tree-gimple.o : tree-gimple.c $(CONFIG_H) $(SYSTEM_H) $(TREE_H) $(EXPR_H) \
    $(RTL_H) $(TREE_GIMPLE_H) $(TM_H) coretypes.h bitmap.h $(GGC_H) \
    output.h $(TREE_FLOW_H)
-gimple-ir.o : gimple-ir.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TREE_H) \
-   $(GGC_H) $(TREE_GIMPLE_H) $(GIMPLE_IR_H) $(DIAGNOSTIC_H)
+gimple.o : gimple.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TREE_H) \
+   $(GGC_H) $(TREE_GIMPLE_H) $(GIMPLE_H) $(DIAGNOSTIC_H)
 gimple-pretty-print.o : gimple-pretty-print.c $(CONFIG_H) $(SYSTEM_H) \
    $(TREE_H) $(DIAGNOSTIC_H) $(REAL_H) $(HASHTAB_H) $(TREE_FLOW_H) \
-   $(TM_H) coretypes.h gimple-iterator.h tree-pass.h gimple-ir.h
+   $(TM_H) coretypes.h gimple-iterator.h tree-pass.h $(GIMPLE_H)
 tree-mudflap.o : $(CONFIG_H) $(SYSTEM_H) $(TREE_H) $(TREE_INLINE_H) \
    $(TREE_GIMPLE_H) $(DIAGNOSTIC_H) $(HASHTAB_H) langhooks.h tree-mudflap.h \
    $(TM_H) coretypes.h $(TREE_DUMP_H) tree-pass.h $(CGRAPH_H) $(GGC_H) \
@@ -2994,7 +2994,7 @@ GTFILES = $(srcdir)/input.h $(srcdir)/co
   $(srcdir)/tree-ssa-structalias.c \
   $(srcdir)/omp-low.c $(srcdir)/varpool.c \
   $(srcdir)/targhooks.c $(out_file) $(srcdir)/passes.c $(srcdir)/cgraphunit.c \
-  $(srcdir)/gimple-ir.h \
+  $(srcdir)/gimple.h \
   @all_gtfiles@
 
 GTFILES_H = $(subst /,-, $(subst $(srcdir)/,gt-, $(subst .c,.h, \
Index: gimple.c
===================================================================
--- gimple.c	(revision 126643)
+++ gimple.c	(working copy)
@@ -27,7 +27,7 @@ Software Foundation, 51 Franklin Street,
 #include "ggc.h"
 #include "errors.h"
 #include "tree-gimple.h"
-#include "gimple-ir.h"
+#include "gimple.h"
 #include "diagnostic.h"
 
 #define DEFGSCODE(SYM, NAME)	NAME,

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]