[committed][lto merge]: Declare EH structures in except.h

[Diego Novillo <dnovillo at google dot com>]

LTO needs to read and write EH structures, so the EH region structures
need to be visible externally.  This will be used shortly when LTO
streaming hits mainline.

Bootstrapped and tested on x86_64.


Diego.

	* 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

Index: except.c
===================================================================
--- except.c	(revision 146295)
+++ except.c	(working copy)
@@ -114,119 +114,15 @@ static int sjlj_fc_personality_ofs;
 static int sjlj_fc_lsda_ofs;
 static int sjlj_fc_jbuf_ofs;
 
-/* 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;

 struct call_site_record GTY(())
 {
   rtx landing_pad;
   int action;
 };
-
-DEF_VEC_P(eh_region);
-DEF_VEC_ALLOC_P(eh_region, gc);
-DEF_VEC_ALLOC_P(eh_region, heap);
-
-/* 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;
-};
 
 static int t2r_eq (const void *, const void *);
 static hashval_t t2r_hash (const void *);
-static void add_type_for_runtime (tree);
-static tree lookup_type_for_runtime (tree);

 static int ttypes_filter_eq (const void *, const void *);
 static hashval_t ttypes_filter_hash (const void *);
@@ -1282,7 +1178,7 @@ t2r_hash (const void *pentry)
   return TREE_HASH (TREE_PURPOSE (entry));
 }

-static void
+void
 add_type_for_runtime (tree type)
 {
   tree *slot;
@@ -1296,7 +1192,7 @@ add_type_for_runtime (tree type)
     }
 }

-static tree
+tree
 lookup_type_for_runtime (tree type)
 {
   tree *slot;
@@ -4066,6 +3962,15 @@ dump_eh_tree (FILE * out, struct functio
     }
 }

+/* Dump the EH tree for FN on stderr.  */
+
+void
+debug_eh_tree (struct function *fn)
+{
+  dump_eh_tree (stderr, fn);
+}
+
+
 /* Verify EH region invariants.  */

 static bool
Index: except.h
===================================================================
--- except.h	(revision 146295)
+++ except.h	(working copy)
@@ -24,12 +24,109 @@ along with GCC; see the file COPYING3.

 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 (voi
 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
Index: Makefile.in
===================================================================
--- Makefile.in	(revision 146295)
+++ Makefile.in	(working copy)
@@ -3307,9 +3307,9 @@ GTFILES = $(CPP_ID_DATA_H) $(srcdir)/inp
   $(srcdir)/dbxout.c $(srcdir)/ipa-struct-reorg.c
$(srcdir)/dwarf2out.c $(srcdir)/dwarf2asm.c \
   $(srcdir)/tree-vect-generic.c \
   $(srcdir)/dojump.c \
-  $(srcdir)/emit-rtl.c $(srcdir)/except.c $(srcdir)/explow.c $(srcdir)/expr.c \
+  $(srcdir)/emit-rtl.c $(srcdir)/except.h $(srcdir)/explow.c $(srcdir)/expr.c \
   $(srcdir)/expr.h \
-  $(srcdir)/function.c $(srcdir)/except.h \
+  $(srcdir)/function.c $(srcdir)/except.c \
   $(srcdir)/gcse.c $(srcdir)/integrate.c $(srcdir)/lists.c $(srcdir)/optabs.c \
   $(srcdir)/profile.c $(srcdir)/reginfo.c $(srcdir)/mcf.c \
   $(srcdir)/reg-stack.c $(srcdir)/cfglayout.c $(srcdir)/cfglayout.h \