1 files changed, 29 insertions, 63 deletions

diff --git a/gcc/ada/ada-tree.h b/gcc/ada/ada-tree.h
index 6ab348e9d20..a43cd48ecf2 100644
--- a/gcc/ada/ada-tree.h
+++ b/gcc/ada/ada-tree.h
@@ -33,35 +33,10 @@ enum gnat_tree_code {
 };
 #undef DEFTREECODE
 
-/* A tree to hold a loop ID.  */
-struct tree_loop_id GTY(())
-{
-  struct tree_common common;
-  struct nesting *loop_id;
-};
-
-/* The language-specific tree.  */
-union lang_tree_node
-  GTY((desc ("TREE_CODE (&%h.generic) == GNAT_LOOP_ID"),
-       chain_next ("(union lang_tree_node *)TREE_CHAIN (&%h.generic)")))
-{
-  union tree_node GTY ((tag ("0"),
-			desc ("tree_node_structure (&%h)")))
-    generic;
-  struct tree_loop_id GTY ((tag ("1"))) loop_id;
-};
-
 /* Ada uses the lang_decl and lang_type fields to hold more trees.  */
-struct lang_decl GTY(())
-{
-  union lang_tree_node
-    GTY((desc ("TREE_CODE (&%h.generic) == GNAT_LOOP_ID"))) t;
-};
-struct lang_type GTY(())
-{
-  union lang_tree_node
-    GTY((desc ("TREE_CODE (&%h.generic) == GNAT_LOOP_ID"))) t;
-};
+union lang_tree_node GTY((desc ("0"))) {union tree_node GTY((tag ("0"))) t; };
+struct lang_decl GTY(()) {union lang_tree_node t; };
+struct lang_type GTY(()) {union lang_tree_node t; };
 
 /* Flags added to GCC type nodes.  */
 
@@ -164,28 +139,28 @@ struct lang_type GTY(())
    by copy in copy out.  It is a CONSTRUCTOR.  For a full description of the
    cico parameter passing mechanism refer to the routine gnat_to_gnu_entity. */
 #define TYPE_CI_CO_LIST(NODE)   \
-  (&TYPE_LANG_SPECIFIC (FUNCTION_TYPE_CHECK (NODE))->t.generic)
+  (&TYPE_LANG_SPECIFIC (FUNCTION_TYPE_CHECK (NODE))->t.t)
 #define SET_TYPE_CI_CO_LIST(NODE, X)   \
   (TYPE_LANG_SPECIFIC (FUNCTION_TYPE_CHECK (NODE)) = (struct lang_type *)(X))
 
 /* For an INTEGER_TYPE with TYPE_MODULAR_P, this is the value of the
    modulus. */
 #define TYPE_MODULUS(NODE)  \
-  (&TYPE_LANG_SPECIFIC (INTEGER_TYPE_CHECK (NODE))->t.generic)
+  (&TYPE_LANG_SPECIFIC (INTEGER_TYPE_CHECK (NODE))->t.t)
 #define SET_TYPE_MODULUS(NODE, X)  \
   (TYPE_LANG_SPECIFIC (INTEGER_TYPE_CHECK (NODE)) = (struct lang_type *)(X))
 
 /* For an INTEGER_TYPE that is the TYPE_DOMAIN of some ARRAY_TYPE, points to
    the type corresponding to the Ada index type.  */
 #define TYPE_INDEX_TYPE(NODE)	\
-  (&TYPE_LANG_SPECIFIC (INTEGER_TYPE_CHECK (NODE))->t.generic)
+  (&TYPE_LANG_SPECIFIC (INTEGER_TYPE_CHECK (NODE))->t.t)
 #define SET_TYPE_INDEX_TYPE(NODE, X)	\
   (TYPE_LANG_SPECIFIC (INTEGER_TYPE_CHECK (NODE)) = (struct lang_type *) (X))
 
 /* For an INTEGER_TYPE with TYPE_VAX_FLOATING_POINT_P, stores the
    Digits_Value.  */
 #define TYPE_DIGITS_VALUE(NODE) \
-  (&TYPE_LANG_SPECIFIC (INTEGER_TYPE_CHECK (NODE))->t.generic)
+  (&TYPE_LANG_SPECIFIC (INTEGER_TYPE_CHECK (NODE))->t.t)
 #define SET_TYPE_DIGITS_VALUE(NODE, X)  \
   (TYPE_LANG_SPECIFIC (INTEGER_TYPE_CHECK (NODE)) = (struct lang_type *) (X))
 
@@ -194,7 +169,7 @@ struct lang_type GTY(())
 
 /* Likewise for ENUMERAL_TYPE.  */
 #define TYPE_RM_SIZE_ENUM(NODE)	\
-  (&TYPE_LANG_SPECIFIC (ENUMERAL_TYPE_CHECK (NODE))->t.generic)
+  (&TYPE_LANG_SPECIFIC (ENUMERAL_TYPE_CHECK (NODE))->t.t)
 #define SET_TYPE_RM_SIZE_ENUM(NODE, X)	\
   (TYPE_LANG_SPECIFIC (ENUMERAL_TYPE_CHECK (NODE)) = (struct lang_type *)(X))
 
@@ -207,21 +182,21 @@ struct lang_type GTY(())
    unconstrained object.  Likewise for a RECORD_TYPE that is pointed
    to by a thin pointer.  */
 #define TYPE_UNCONSTRAINED_ARRAY(NODE)  \
-  (&TYPE_LANG_SPECIFIC (RECORD_TYPE_CHECK (NODE))->t.generic)
+  (&TYPE_LANG_SPECIFIC (RECORD_TYPE_CHECK (NODE))->t.t)
 #define SET_TYPE_UNCONSTRAINED_ARRAY(NODE, X)  \
   (TYPE_LANG_SPECIFIC (RECORD_TYPE_CHECK (NODE)) = (struct lang_type *)(X))
 
 /* For other RECORD_TYPEs and all UNION_TYPEs and QUAL_UNION_TYPEs, the Ada
    size of the object.  This differs from the GCC size in that it does not
    include any rounding up to the alignment of the type.  */
-#define TYPE_ADA_SIZE(NODE)	(&TYPE_LANG_SPECIFIC (NODE)->t.generic)
+#define TYPE_ADA_SIZE(NODE)	(&TYPE_LANG_SPECIFIC (NODE)->t.t)
 #define SET_TYPE_ADA_SIZE(NODE, X) \
   (TYPE_LANG_SPECIFIC (NODE) = (struct lang_type *)(X))
 
 /* For an INTEGER_TYPE with TYPE_HAS_ACTUAL_BOUNDS_P or an ARRAY_TYPE, this is
    the index type that should be used when the actual bounds are required for
    a template.  This is used in the case of packed arrays.  */
-#define TYPE_ACTUAL_BOUNDS(NODE)   (&TYPE_LANG_SPECIFIC (NODE)->t.generic)
+#define TYPE_ACTUAL_BOUNDS(NODE)   (&TYPE_LANG_SPECIFIC (NODE)->t.t)
 #define SET_TYPE_ACTUAL_BOUNDS(NODE, X) \
   (TYPE_LANG_SPECIFIC (NODE) = (struct lang_type *)(X))
 
@@ -238,9 +213,6 @@ struct lang_type GTY(())
    discriminant.  */
 #define DECL_STUBBED_P(NODE) DECL_LANG_FLAG_0 (FUNCTION_DECL_CHECK (NODE))
 
-/* Nonzero in a VAR_DECL if it needs to be initialized by an assignment.  */
-#define DECL_INIT_BY_ASSIGN_P(NODE) DECL_LANG_FLAG_0 (VAR_DECL_CHECK (NODE))
-
 /* Nonzero if this decl is always used by reference; i.e., an INDIRECT_REF
    is needed to access the object.  */
 #define DECL_BY_REF_P(NODE) DECL_LANG_FLAG_1 (NODE)
@@ -270,14 +242,14 @@ struct lang_type GTY(())
    memory.  Used when a scalar constant is aliased or has its
    address taken.  */
 #define DECL_CONST_CORRESPONDING_VAR(NODE) \
-  (&DECL_LANG_SPECIFIC (CONST_DECL_CHECK (NODE))->t.generic)
+  (&DECL_LANG_SPECIFIC (CONST_DECL_CHECK (NODE))->t.t)
 #define SET_DECL_CONST_CORRESPONDING_VAR(NODE, X) \
   (DECL_LANG_SPECIFIC (CONST_DECL_CHECK (NODE)) = (struct lang_decl *)(X))
 
 /* In a FIELD_DECL, points to the FIELD_DECL that was the ultimate
    source of the decl.  */
 #define DECL_ORIGINAL_FIELD(NODE) \
-  (&DECL_LANG_SPECIFIC (FIELD_DECL_CHECK (NODE))->t.generic)
+  (&DECL_LANG_SPECIFIC (FIELD_DECL_CHECK (NODE))->t.t)
 #define SET_DECL_ORIGINAL_FIELD(NODE, X) \
   (DECL_LANG_SPECIFIC (FIELD_DECL_CHECK (NODE)) = (struct lang_decl *)(X))
 
@@ -285,31 +257,25 @@ struct lang_type GTY(())
    discriminant number.  */
 #define DECL_DISCRIMINANT_NUMBER(NODE) DECL_INITIAL (FIELD_DECL_CHECK (NODE))
 
-/* This is the loop id for a GNAT_LOOP_ID node.  */
-#define TREE_LOOP_ID(NODE) \
-  ((union lang_tree_node *) GNAT_LOOP_ID_CHECK (NODE))->loop_id.loop_id
-
 /* Define fields and macros for statements.
 
    Start by defining which tree codes are used for statements.  */
 #define IS_STMT(NODE)		(TREE_CODE_CLASS (TREE_CODE (NODE)) == 's')
+#define IS_ADA_STMT(NODE)	(IS_STMT (NODE)				\
+				 && TREE_CODE (NODE) >= DECL_STMT)
 
-/* We store the Sloc in statement nodes.  */
-#define TREE_SLOC(NODE)		TREE_COMPLEXITY (STMT_CHECK (NODE))
-
-#define EXPR_STMT_EXPR(NODE)	TREE_OPERAND_CHECK_CODE (NODE, EXPR_STMT, 0)
 #define DECL_STMT_VAR(NODE)	TREE_OPERAND_CHECK_CODE (NODE, DECL_STMT, 0)
-#define BLOCK_STMT_LIST(NODE)	TREE_OPERAND_CHECK_CODE (NODE, BLOCK_STMT, 0)
-#define BLOCK_STMT_BLOCK(NODE)	TREE_OPERAND_CHECK_CODE (NODE, BLOCK_STMT, 1)
-#define IF_STMT_COND(NODE)	TREE_OPERAND_CHECK_CODE (NODE, IF_STMT, 0)
-#define IF_STMT_TRUE(NODE)	TREE_OPERAND_CHECK_CODE (NODE, IF_STMT, 1)
-#define IF_STMT_ELSEIF(NODE)	TREE_OPERAND_CHECK_CODE (NODE, IF_STMT, 2)
-#define IF_STMT_ELSE(NODE)	TREE_OPERAND_CHECK_CODE (NODE, IF_STMT, 3)
-#define GOTO_STMT_LABEL(NODE)	TREE_OPERAND_CHECK_CODE (NODE, GOTO_STMT, 0)
-#define LABEL_STMT_LABEL(NODE)	TREE_OPERAND_CHECK_CODE (NODE, LABEL_STMT, 0)
-#define RETURN_STMT_EXPR(NODE)	TREE_OPERAND_CHECK_CODE (NODE, RETURN_STMT, 0)
-#define ASM_STMT_TEMPLATE(NODE)	TREE_OPERAND_CHECK_CODE (NODE, ASM_STMT, 0)
-#define ASM_STMT_OUTPUT(NODE)	TREE_OPERAND_CHECK_CODE (NODE, ASM_STMT, 1)
-#define ASM_STMT_ORIG_OUT(NODE)	TREE_OPERAND_CHECK_CODE (NODE, ASM_STMT, 2)
-#define ASM_STMT_INPUT(NODE)	TREE_OPERAND_CHECK_CODE (NODE, ASM_STMT, 3)
-#define ASM_STMT_CLOBBER(NODE)	TREE_OPERAND_CHECK_CODE (NODE, ASM_STMT, 4)
+#define STMT_STMT_STMT(NODE)	TREE_OPERAND_CHECK_CODE (NODE, STMT_STMT, 0)
+#define LOOP_STMT_TOP_COND(NODE) TREE_OPERAND_CHECK_CODE (NODE, LOOP_STMT, 0)
+#define LOOP_STMT_BOT_COND(NODE) TREE_OPERAND_CHECK_CODE (NODE, LOOP_STMT, 1)
+#define LOOP_STMT_UPDATE(NODE)	TREE_OPERAND_CHECK_CODE (NODE, LOOP_STMT, 2)
+#define LOOP_STMT_BODY(NODE)	TREE_OPERAND_CHECK_CODE (NODE, LOOP_STMT, 3)
+#define LOOP_STMT_LABEL(NODE)	TREE_OPERAND_CHECK_CODE (NODE, LOOP_STMT, 4)
+#define EXIT_STMT_COND(NODE)	TREE_OPERAND_CHECK_CODE (NODE, EXIT_STMT, 0)
+#define EXIT_STMT_LOOP(NODE)	TREE_OPERAND_CHECK_CODE (NODE, EXIT_STMT, 1)
+#define REGION_STMT_BODY(NODE)	TREE_OPERAND_CHECK_CODE (NODE, REGION_STMT, 0)
+#define REGION_STMT_HANDLE(NODE) TREE_OPERAND_CHECK_CODE (NODE, REGION_STMT, 1)
+#define REGION_STMT_BLOCK(NODE)	TREE_OPERAND_CHECK_CODE (NODE, REGION_STMT, 2)
+#define HANDLER_STMT_ARG(NODE) TREE_OPERAND_CHECK_CODE (NODE, HANDLER_STMT, 0)
+#define HANDLER_STMT_LIST(NODE)	TREE_OPERAND_CHECK_CODE (NODE, HANDLER_STMT, 1)
+#define HANDLER_STMT_BLOCK(NODE) TREE_OPERAND_CHECK_CODE (NODE, HANDLER_STMT, 2)