New code to analyze file level static variables and to determine if

they escape and also code to use this information to prune clobber
lists.


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

1 files changed, 93 insertions, 0 deletions

diff --git a/gcc/cgraph.h b/gcc/cgraph.h
index a6e9cd75880..0af4447df35 100644
--- a/gcc/cgraph.h
+++ b/gcc/cgraph.h
@@ -22,6 +22,8 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 #ifndef GCC_CGRAPH_H
 #define GCC_CGRAPH_H
 #include "hashtab.h"
+#include "bitmap.h"
+#include "tree.h"
 
 /* Information about the function collected locally.
    Available after function is analyzed.  */
@@ -30,19 +32,37 @@ struct cgraph_local_info GTY(())
 {
   /* Size of the function before inlining.  */
   int self_insns;
+
   /* Set when function function is visible in current compilation unit only
      and it's address is never taken.  */
   bool local;
+
+  /* Set when function is defined in another compilation unit.  */
+  bool external;
+
+  /* Set when this function calls a function external of the
+     compilation unit.  In general, such calls are modeled as reading
+     and writing all variables (both bits on) but sometime there are
+     attributes on the called function so we can do better.  */
+  bool calls_read_all;
+  bool calls_write_all;
+
   /* Set once it has been finalized so we consider it to be output.  */
   bool finalized;
 
   /* False when there something makes inlining impossible (such as va_arg).  */
   bool inlinable;
+
   /* True when function should be inlined independently on it's size.  */
   bool disregard_inline_limits;
+
   /* True when the function has been originally extern inline, but it is
      redefined now.  */
   bool redefined_extern_inline;
+
+  /* True if statics_read_for_function and
+     statics_written_for_function contain valid data.  */
+  bool for_functions_valid;
 };
 
 /* Information about the function that needs to be computed globally
@@ -70,6 +90,69 @@ struct cgraph_rtl_info GTY(())
    bool pure_function;
 };
 
+/* FIXME -- PROFILE-RESTRUCTURE: When the next round of the profiling
+   code gets merged in, it will contain a restructing where ssa form
+   is built for every function within the compilation unit before the
+   rest of the compilation continues.  When this reorgination is done,
+   it will no longer be necessary to have the _decl_uid versions of
+   local_static_vars_info and global_static_vars_info structures.
+   Having both structures is now requirred because the _ann_uid values
+   for static variables are reset as each function is compiled.
+   Currently, the analysis is done using the _decl_uid versions and
+   converted to the _var_ann versions on demand.
+
+   Also, the var_anns_valid fields within these structures can also go
+   away.
+*/
+
+/* The static variables defined within the compilation unit that are
+   loaded or stored directly by function that owns this structure.  */ 
+
+struct local_static_vars_info_d GTY(())
+{
+  bitmap statics_read_by_decl_uid;
+  bitmap statics_written_by_decl_uid;
+};
+
+struct global_static_vars_info_d GTY(())
+{
+  bitmap statics_read_by_decl_uid;
+  bitmap statics_written_by_decl_uid;
+  bitmap statics_read_by_ann_uid;
+  bitmap statics_written_by_ann_uid;
+  bitmap statics_not_read_by_decl_uid;
+  bitmap statics_not_written_by_decl_uid;
+  bitmap statics_not_read_by_ann_uid;
+  bitmap statics_not_written_by_ann_uid;
+
+  /* var_anns_valid is reset at the start of compilation for each
+     function because the indexing that the "_var_anns" is based
+     on is invalidated between function compilations.  This allows for
+     lazy creation of the "_var_ann" variables.  */
+  bool var_anns_valid;
+};
+
+/* Statics that are read and written by some set of functions. The
+   local ones are based on the loads and stores local to the function.
+   The global ones are based on the local info as well as the
+   transitive closure of the functions that are called.  The
+   structures are separated to allow the global structures to be
+   shared between several functions since every function within a
+   strongly connected component will have the same information.  This
+   sharing saves both time and space in the computation of the vectors
+   as well as their translation from decl_uid form to ann_uid
+   form.  */ 
+
+typedef struct local_static_vars_info_d *local_static_vars_info_t;
+typedef struct global_static_vars_info_d *global_static_vars_info_t;
+
+struct static_vars_info_d GTY(()) 
+{
+  local_static_vars_info_t local;
+  global_static_vars_info_t global;
+};
+
+typedef struct static_vars_info_d *static_vars_info_t;
 
 /* The cgraph data structure.
    Each function decl has assigned cgraph_node listing callees and callers.  */
@@ -91,11 +174,18 @@ struct cgraph_node GTY((chain_next ("%h.next"), chain_prev ("%h.previous")))
   struct cgraph_node *next_needed;
   /* Pointer to the next clone.  */
   struct cgraph_node *next_clone;
+  /* Pointer to next node in a recursive call graph cycle; */
+  struct cgraph_node *next_cycle;
   PTR GTY ((skip)) aux;
 
   struct cgraph_local_info local;
   struct cgraph_global_info global;
   struct cgraph_rtl_info rtl;
+  
+  /* Pointer to the structure that contains the sets of global
+     variables modified by function calls.  */
+  static_vars_info_t static_vars_info;
+
   /* Unique id of the node.  */
   int uid;
   /* Set when function must be output - it is externally visible
@@ -192,6 +282,9 @@ void verify_cgraph_node (struct cgraph_node *);
 void cgraph_mark_inline_edge (struct cgraph_edge *e);
 void cgraph_clone_inlined_nodes (struct cgraph_edge *e, bool duplicate);
 void cgraph_build_static_cdtor (char which, tree body, int priority);
+void cgraph_reset_static_var_maps (void);
+bitmap get_global_statics_not_read (tree fn);
+bitmap get_global_statics_not_written(tree fn);
 void init_cgraph (void);
 
 #endif  /* GCC_CGRAPH_H  */