[patch] tree-eh.c prototypes

[Andrew MacLeod <amacleod at redhat dot com>]

This patch moves the prototypes for tree-eh.c into a new file 
tree-eh.h.   This file is in fact really gimple-eh.. we'll rename that 
later with the other tree->gimple renaming that is needed.

however, using_eh_for_cleanups() is in fact a front end routine which is 
called when eh regions are used for cleanups. It sets a static flag in 
tree-eh.c and is only examined from one place in tree-eh.c.  I think 4 
or 5 of the front ends call this routine.

Since this is really a front end interface routine, I kept the name and 
moved it and the static variable to tree.[ch] for now and added a query 
routine. This prevents the front ends from having to include any of this 
gimple stuff.

Bootstraps onx86_64-unknown-linux-gnu and has no new regressions. OK?

Andrew

PS.  do we want to put debug routines in the .h file?  I ask because I 
see a few are, but in many other cases there are a number of them in the 
.c file which are not explicitly exported.  Often their names aren't 
very useful either and sometimes sometimes utilize structs or types that 
are specific to that .c file.   Mostly I think they are not static 
simply because the debugger needs them so the compiler wont throw them away.

for instance, tree-ssa-pre.c has 3 of them, including a very common 
form: debug_bitmap_sets_for_bb(basic_block bb)...  This prints a bitmaps 
based on internal meanings of the bits. I see numerous other files which 
have similar, if slightly different names to do a simiiar function
And in fact, tree-ssa-pre.c will have no header file, unless we need a 
place to put these 3 debug files.

My personal preference is to simply leave them in the .c file, mostly 
because they can have internal types.  Ideally, all the prototypes would 
be listed early in the .c file in one place so anyone truing to debug 
something can find them easily.


	* tree-flow.h: Remove some prototypes.
	* tree.h: Remove some protypes, add a couple.
	* tree.c (using_eh_for_cleanups_flag, using_eh_for_cleanups,
	using_eh_for_cleanups_p): Add interface routines for front ends.
	* tree-eh.h: New file.  Add protoptyes.
	* tree-eh.c (using_eh_for_cleanups_p, using_eh_for_cleanups): Delete.
	(add_stmt_to_eh_lp_fn): Make static.
	(lower_try_finally): Use new using_eh_for_cleanups_p.
	* emit-rtl.c: Include tree-eh.h.
	* gimple.h: Include tree-eh.h.

Index: tree-flow.h
===================================================================
*** tree-flow.h	(revision 203118)
--- tree-flow.h	(working copy)
*************** enum move_pos
*** 390,427 ****
  extern enum move_pos movement_possibility (gimple);
  char *get_lsm_tmp_name (tree, unsigned);
  
- /* In tree-flow-inline.h  */
- static inline bool unmodifiable_var_p (const_tree);
- static inline bool ref_contains_array_ref (const_tree);
- 
- /* In tree-eh.c  */
- extern void make_eh_edges (gimple);
- extern bool make_eh_dispatch_edges (gimple);
- extern edge redirect_eh_edge (edge, basic_block);
- extern void redirect_eh_dispatch_edge (gimple, edge, basic_block);
- extern bool stmt_could_throw_p (gimple);
- extern bool stmt_can_throw_internal (gimple);
- extern bool stmt_can_throw_external (gimple);
- extern void add_stmt_to_eh_lp_fn (struct function *, gimple, int);
- extern void add_stmt_to_eh_lp (gimple, int);
- extern bool remove_stmt_from_eh_lp (gimple);
- extern bool remove_stmt_from_eh_lp_fn (struct function *, gimple);
- extern int lookup_stmt_eh_lp_fn (struct function *, gimple);
- extern int lookup_stmt_eh_lp (gimple);
- extern bool maybe_clean_eh_stmt_fn (struct function *, gimple);
- extern bool maybe_clean_eh_stmt (gimple);
- extern bool maybe_clean_or_replace_eh_stmt (gimple, gimple);
- extern bool maybe_duplicate_eh_stmt_fn (struct function *, gimple,
- 					struct function *, gimple,
- 					struct pointer_map_t *, int);
- extern bool maybe_duplicate_eh_stmt (gimple, gimple);
- extern bool verify_eh_edges (gimple);
- extern bool verify_eh_dispatch_edge (gimple);
- extern void maybe_remove_unreachable_handlers (void);
- 
- /* In tree-ssa-pre.c  */
- void debug_value_expressions (unsigned int);
- 
  /* In tree-loop-linear.c  */
  extern void linear_transform_loops (void);
  extern unsigned perfect_loop_nest_depth (struct loop *);
--- 390,395 ----
Index: tree.h
===================================================================
*** tree.h	(revision 203117)
--- tree.h	(working copy)
*************** extern rtx expand_stack_save (void);
*** 4216,4230 ****
  extern void expand_stack_restore (tree);
  extern void expand_return (tree);
  
- /* In tree-eh.c */
- extern void using_eh_for_cleanups (void);
- 
- extern bool tree_could_trap_p (tree);
- extern bool operation_could_trap_helper_p (enum tree_code, bool, bool, bool,
- 					   bool, tree, bool *);
- extern bool operation_could_trap_p (enum tree_code, bool, bool, tree);
- extern bool tree_could_throw_p (tree);
- 
  /* Compare and hash for any structure which begins with a canonical
     pointer.  Assumes all pointers are interchangeable, which is sort
     of already assumed by gcc elsewhere IIRC.  */
--- 4216,4221 ----
*************** extern bool types_same_for_odr (tree typ
*** 4531,4536 ****
--- 4522,4529 ----
  extern bool contains_bitfld_component_ref_p (const_tree);
  extern bool type_in_anonymous_namespace_p (tree);
  extern bool block_may_fallthru (const_tree);
+ extern void using_eh_for_cleanups (void);
+ extern bool using_eh_for_cleanups_p (void);
  
  /* In tree-nested.c */
  extern tree build_addr (tree, tree);
Index: tree.c
===================================================================
*** tree.c	(revision 203117)
--- tree.c	(working copy)
*************** block_may_fallthru (const_tree block)
*** 12247,12250 ****
--- 12247,12268 ----
      }
  }
  
+ /* True if we are using EH to handle cleanups.  */
+ static bool using_eh_for_cleanups_flag = false;
+ 
+ /* This routine is called from front ends to indicate eh should be used for
+    cleanups.  */
+ void
+ using_eh_for_cleanups (void)
+ {
+   using_eh_for_cleanups_flag = true;
+ }
+ 
+ /* Query whether EH is used for cleanups.  */
+ bool
+ using_eh_for_cleanups_p (void)
+ {
+   return using_eh_for_cleanups_flag;
+ }
+ 
  #include "gt-tree.h"
Index: tree-eh.h
===================================================================
*** tree-eh.h	(revision 0)
--- tree-eh.h	(revision 0)
***************
*** 0 ****
--- 1,52 ----
+ /* Header file for exception handling.
+    Copyright (C) 2013 Free Software Foundation, Inc.
+ 
+ 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 3, 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 COPYING3.  If not see
+ <http://www.gnu.org/licenses/>.  */
+ 
+ #ifndef GCC_TREE_EH_H
+ #define GCC_TREE_EH_H
+ 
+ extern void using_eh_for_cleanups (void);
+ extern void add_stmt_to_eh_lp (gimple, int);
+ extern bool remove_stmt_from_eh_lp_fn (struct function *, gimple);
+ extern bool remove_stmt_from_eh_lp (gimple);
+ extern int lookup_stmt_eh_lp_fn (struct function *, gimple);
+ extern int lookup_stmt_eh_lp (gimple);
+ extern bool make_eh_dispatch_edges (gimple);
+ extern void make_eh_edges (gimple);
+ extern edge redirect_eh_edge (edge, basic_block);
+ extern void redirect_eh_dispatch_edge (gimple, edge, basic_block);
+ extern bool operation_could_trap_helper_p (enum tree_code, bool, bool, bool,
+ 					   bool, tree, bool *);
+ extern bool operation_could_trap_p (enum tree_code, bool, bool, tree);
+ extern bool tree_could_trap_p (tree);
+ extern bool stmt_could_throw_p (gimple);
+ extern bool tree_could_throw_p (tree);
+ extern bool stmt_can_throw_external (gimple);
+ extern bool stmt_can_throw_internal (gimple);
+ extern bool maybe_clean_eh_stmt_fn (struct function *, gimple);
+ extern bool maybe_clean_eh_stmt (gimple);
+ extern bool maybe_clean_or_replace_eh_stmt (gimple, gimple);
+ extern bool maybe_duplicate_eh_stmt_fn (struct function *, gimple,
+ 					struct function *, gimple,
+ 					struct pointer_map_t *, int);
+ extern bool maybe_duplicate_eh_stmt (gimple, gimple);
+ extern void maybe_remove_unreachable_handlers (void);
+ extern bool verify_eh_edges (gimple);
+ extern bool verify_eh_dispatch_edge (gimple);
+ 
+ #endif /* GCC_TREE_EH_H */
Index: tree-eh.c
===================================================================
*** tree-eh.c	(revision 203117)
--- tree-eh.c	(working copy)
*************** along with GCC; see the file COPYING3.  
*** 41,55 ****
     i.e. in hash tables. This is a structure to do this. */
  typedef union {tree *tp; tree t; gimple g;} treemple;
  
- /* Nonzero if we are using EH to handle cleanups.  */
- static int using_eh_for_cleanups_p = 0;
- 
- void
- using_eh_for_cleanups (void)
- {
-   using_eh_for_cleanups_p = 1;
- }
- 
  /* Misc functions used in this file.  */
  
  /* Remember and lookup EH landing pad data for arbitrary statements.
--- 41,46 ----
*************** using_eh_for_cleanups (void)
*** 66,72 ****
  
  /* Add statement T in function IFUN to landing pad NUM.  */
  
! void
  add_stmt_to_eh_lp_fn (struct function *ifun, gimple t, int num)
  {
    struct throw_stmt_node *n;
--- 57,63 ----
  
  /* Add statement T in function IFUN to landing pad NUM.  */
  
! static void
  add_stmt_to_eh_lp_fn (struct function *ifun, gimple t, int num)
  {
    struct throw_stmt_node *n;
*************** lower_try_finally (struct leh_state *sta
*** 1655,1661 ****
    this_tf.try_finally_expr = tp;
    this_tf.top_p = tp;
    this_tf.outer = state;
!   if (using_eh_for_cleanups_p && !cleanup_is_dead_in (state->cur_region))
      {
        this_tf.region = gen_eh_region_cleanup (state->cur_region);
        this_state.cur_region = this_tf.region;
--- 1646,1652 ----
    this_tf.try_finally_expr = tp;
    this_tf.top_p = tp;
    this_tf.outer = state;
!   if (using_eh_for_cleanups_p () && !cleanup_is_dead_in (state->cur_region))
      {
        this_tf.region = gen_eh_region_cleanup (state->cur_region);
        this_state.cur_region = this_tf.region;
Index: emit-rtl.c
===================================================================
*** emit-rtl.c	(revision 203117)
--- emit-rtl.c	(working copy)
*************** along with GCC; see the file COPYING3.  
*** 55,60 ****
--- 55,61 ----
  #include "df.h"
  #include "params.h"
  #include "target.h"
+ #include "tree-eh.h"
  
  struct target_rtl default_target_rtl;
  #if SWITCHABLE_TARGET
Index: gimple.h
===================================================================
*** gimple.h	(revision 203118)
--- gimple.h	(working copy)
*************** along with GCC; see the file COPYING3.  
*** 31,36 ****
--- 31,37 ----
  #include "tree-ssa-alias.h"
  #include "internal-fn.h"
  #include "gimple-fold.h"
+ #include "tree-eh.h"
  
  typedef gimple gimple_seq_node;