* except.c (debug_eh_tree): New.

	(struct eh_region, struct eh_status): Move ...
	* except.h: ... here.
	(add_type_for_runtime): Declare extern.
	(lookup_type_for_runtime): Likewise.
	(debug_eh_tree): Declare.
	* Makefile.in (GTFILES): List except.h before except.c




git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@146296 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 105 insertions, 5 deletions

diff --git a/gcc/except.h b/gcc/except.h
index 21145fd4f75..18c36b01987 100644
--- a/gcc/except.h
+++ b/gcc/except.h
@@ -24,12 +24,109 @@ along with GCC; see the file COPYING3.  If not see
 
 struct function;
 
-/* Per-function EH data.  Used only in except.c, but GC and others
-   manipulate pointers to the opaque type.  */
-struct eh_status;
+/* Describes one exception region.  */
+struct eh_region GTY(())
+{
+  /* The immediately surrounding region.  */
+  struct eh_region *outer;
+
+  /* The list of immediately contained regions.  */
+  struct eh_region *inner;
+  struct eh_region *next_peer;
+
+  /* An identifier for this region.  */
+  int region_number;
+
+  /* When a region is deleted, its parents inherit the REG_EH_REGION
+     numbers already assigned.  */
+  bitmap aka;
+
+  /* Each region does exactly one thing.  */
+  enum eh_region_type
+  {
+    ERT_UNKNOWN = 0,
+    ERT_CLEANUP,
+    ERT_TRY,
+    ERT_CATCH,
+    ERT_ALLOWED_EXCEPTIONS,
+    ERT_MUST_NOT_THROW,
+    ERT_THROW
+  } type;
+
+  /* Holds the action to perform based on the preceding type.  */
+  union eh_region_u {
+    /* A list of catch blocks, a surrounding try block,
+       and the label for continuing after a catch.  */
+    struct eh_region_u_try {
+      struct eh_region *eh_catch;
+      struct eh_region *last_catch;
+    } GTY ((tag ("ERT_TRY"))) eh_try;
+
+    /* The list through the catch handlers, the list of type objects
+       matched, and the list of associated filters.  */
+    struct eh_region_u_catch {
+      struct eh_region *next_catch;
+      struct eh_region *prev_catch;
+      tree type_list;
+      tree filter_list;
+    } GTY ((tag ("ERT_CATCH"))) eh_catch;
+
+    /* A tree_list of allowed types.  */
+    struct eh_region_u_allowed {
+      tree type_list;
+      int filter;
+    } GTY ((tag ("ERT_ALLOWED_EXCEPTIONS"))) allowed;
+
+    /* The type given by a call to "throw foo();", or discovered
+       for a throw.  */
+    struct eh_region_u_throw {
+      tree type;
+    } GTY ((tag ("ERT_THROW"))) eh_throw;
+
+    /* Retain the cleanup expression even after expansion so that
+       we can match up fixup regions.  */
+    struct eh_region_u_cleanup {
+      struct eh_region *prev_try;
+    } GTY ((tag ("ERT_CLEANUP"))) cleanup;
+  } GTY ((desc ("%0.type"))) u;
+
+  /* Entry point for this region's handler before landing pads are built.  */
+  rtx label;
+  tree tree_label;
+
+  /* Entry point for this region's handler from the runtime eh library.  */
+  rtx landing_pad;
+
+  /* Entry point for this region's handler from an inner region.  */
+  rtx post_landing_pad;
+
+  /* The RESX insn for handing off control to the next outermost handler,
+     if appropriate.  */
+  rtx resume;
+
+  /* True if something in this region may throw.  */
+  unsigned may_contain_throw : 1;
+};
+
+typedef struct eh_region *eh_region;
+DEF_VEC_P(eh_region);
+DEF_VEC_ALLOC_P(eh_region, gc);
+DEF_VEC_ALLOC_P(eh_region, heap);
+
+/* Per-function EH data.  Used to save exception status for each
+   function.  */
+struct eh_status GTY(())
+{
+  /* The tree of all regions for this function.  */
+  struct eh_region *region_tree;
+
+  /* The same information as an indexable array.  */
+  VEC(eh_region,gc) *region_array;
+  int last_region_number;
+
+  htab_t GTY((param_is (struct throw_stmt_node))) throw_stmt_table;
+};
 
-/* Internal structure describing a region.  */
-struct eh_region;
 
 /* Test: is exception handling turned on?  */
 extern int doing_eh (int);
@@ -108,7 +205,10 @@ extern void collect_eh_region_array (void);
 extern void expand_resx_expr (tree);
 extern void verify_eh_tree (struct function *);
 extern void dump_eh_tree (FILE *, struct function *);
+void debug_eh_tree (struct function *);
 extern int eh_region_outermost (struct function *, int, int);
+extern void add_type_for_runtime (tree);
+extern tree lookup_type_for_runtime (tree);
 
 /* If non-NULL, this is a function that returns an expression to be
    executed if an unhandled exception is propagated out of a cleanup