ada-tree.def (TRANSFORM_EXPR, [...]): Deleted.

	* ada-tree.def (TRANSFORM_EXPR, ALLOCATE_EXPR, USE_EXPR): Deleted.
	(GNAT_NOP_EXPR, GNAT_LOOP_ID, EXPR_STMT, NULL_STMT): Likewise.
	(BLOCK_STMT, IF_STMT, GOTO_STMT, LABEL_STMT, RETURN_STMT): Likewise.
	(ASM_STMT, BREAK_STMT, REGION_STMT,HANDLER_STMT): Likewise.
	(STMT_STMT, USE_STMT): New statement codes.
	(LOOP_STMT, EXIT_STMT): Make slight semantic changes.
	* ada-tree.h: Reflect above changes.
 	(struct tree_loop_id): Deleted.
	(union lang_tree_node, struct lang_decl, struct lang_type):
	Now just contains a tree node; update macros using TYPE_LANG_SPECIFIC
	and DECL_LANGUAGE_SPECIFIC to reflect these changes.
	(DECL_INIT_BY_ASSIGN_P, TRE_LOOP_NODE_ID, TREE_SLOC): Deleted.
	(IS_ADA_STMT): New macro.
	* decl.c (annotate_decl_with_node): New function.
	(gnat_to_gnu_entity): Use it and Sloc_to_locus instead of set_lineno.
	(gnat_to_gnu_entity, case object): Remove call to expand CONVERT_EXPR.
	Call add_stmt_with_node to do needed assignments.
	Add call to update setjmp buffer directly, not via EXPR_STMT.
	(maybe_variable): Argment GNAT_NODE deleted.
	* gigi.h (maybe_variable): Likewise.
	(make_transform, add_stmt_with_node, set_block_for_group): New.
	(gnat_gimplify_expr, gnat_expand_body, Sloc_to_locus): Likewise.
	(set_block_jmpbuf_decl, get_block_jmpbuf_decl): Likewise.
	(discard_file_names, gnu_block_stack, gnat_to_code): Deleted.
	(set_lineno, set_lineno_from_sloc): Likewise.
	(record_code_position, insert_code_for): Likewise.
	(gnat_poplevel): Now returns void.
	(end_subprog_body): Now takes argument.
	* misc.c (cgraph.h, tree-inline.h): New includes.
	(gnat_tree_size, LANG_HOOKS_TREE_SIZE): Deleted.
	(gnat_post_options, LANG_HOOKS_POST_OPTIONS): New.
	(LANG_HOOKS_CALLGRAPH_EXPAND_FUNCTION): Likewise.
	(LANG_HOOKS_RTL_EXPAND_STMT, LANG_HOOKS_GIMPLIFY_EXPR): Likewise.
	(gnat_parse_file): Don't set immediate_size_expand.
	Call cgraph functions.
	(gnat_expand_expr): Remove most cases.
	(record_code_position, insert_code_for): Remove from here.
	* trans.c (toplev.h, tree-gimple.h): Now included.
	(discard_file_names): Deleted.
	(gnu_block_stack, gnu_block_stmt_node, gnu_block_stmt_free_list): Del.
	(first_nondeleted_insn, make_expr_stmt_from_rtl): Likewise.
	(struct stmt_group, current_stmt_group, stmt_group_free_list): New.
	(gnu_stack_free_list, record_cost_position, insert_code_for): Likewise.
	(add_cleanup, push_stack, gnat_gimplify_stmt, add_cleanup): Likewise.
	(gnat_gimplify_type_sizes, gnat_gimplify_one_sizepos): Likewise.
	(gnat_expand_body_1, gnat_gimplify_expr, annotate_with_node): Likewise.
	(set_block_for_group, add_stmt_list): Likewise.
	(start_stmt_group): Renamed from start_block_stmt.
	(end_stmt_group): Likewise, from end_block_stmt.
	(build_stmt_group): Likewise, from build_block_stmt, also add arg.
	(gigi): Don't set discard_file_names or call set_lineno.
	Disallow front end ZCX; call gnat_to_gnu, not gnat_to_code.
	(tree_transform): Deleted, now renamed to be gnat_to_gnu.
	Numerous changes throughout to reflect new names and complete
	function-at-a-time implementation.
	(gnat_expand_stmt): Delete or comment out all cases.
	(process_inlined_subprograms): Use add_stmt.
	(process_decls): Use gnat_to_gnu, not gnat_to_code, and don't
	call set_lineno; also remove unneeded block handling.
	(process_type): Remove unneeded block handling.
	(build_unit_elab): Remove calls to deleted functions.
	* utils.c (cgraph.h, tree-inline.h, tree-gimple.h): Now include.
	(tree-dump.h): Likewise.
	(struct ada_binding_level): Add field jmpbuf_decl.
	(gnat_define_builtin, gnat_install_builtins): New.
	(gnat_gimplify_function, gnat_finalize): Likewise.
	(gnat_poplevel): No longer return BLOCK, set it instead.
	Remove code dealing with nested functions.
	(gnat_init_decl_processing): Also set size_type_node.
	Call gnat_install_builtins.
	(create_var_decl): Don't set DECL_INIT_BY_ASSIGN.
	(create_subprog_decl): Change handling of inline_flag; set TREE_STATIC.
	Remove special-case for "main".
	(end_subprog_body): Add arg and rework for tree-ssa.
	(convert): Don't use GNAT_NOP_EXPR or look for TRANSFORM_EXPR.
	Add case for BOOLEAN_TYPE.
	* utils2.c (rtl.h): Now include.
	(build_call_raise): Test Debug_Flag_NN directly.
	(build_call_alloc_dealloc): Don't use local stack allocation for now.
	(gnat_mark_addressable, case GNAT_NOP_EXPR): Deleted.
	(gnat_mark_addressable, case VAR_DECL): Handle both early & late cases.

From-SVN: r82714

1 files changed, 29 insertions, 63 deletions

diff --git a/gcc/ada/ada-tree.h b/gcc/ada/ada-tree.h
index 6ab348e..a43cd48 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)