X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fana%2Frta.c;h=bbc9da2ccf409a3807cb73abadfea5750970be25;hb=00894f1e0b6e74ca6c12d253dd30f7d873808977;hp=bfc143c68c401aacf0fe0cb2e437fbbff1cce5c1;hpb=ea561ae324dc1f7ec0a6bc8572c4c0bc5873043a;p=libfirm

diff --git a/ir/ana/rta.c b/ir/ana/rta.c
index bfc143c68..bbc9da2cc 100644
--- a/ir/ana/rta.c
+++ b/ir/ana/rta.c
@@ -1,365 +1,568 @@
-/* -*- c -*- */
-
 /*
- * Project:     libFIRM
- * File name:   ir/ana/rta.c
- * Purpose:     Intraprozedural analyses to improve the call graph estimate.
- * Author:      Florian
- * Modified by:
- * Created:     09.06.2002
- * CVS-ID:      $$
- * Copyright:   (c) 1999-2004 Universität Karlsruhe
- * Licence:     This file protected by GPL -  GNU GENERAL PUBLIC LICENSE.
+ * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
+ *
+ * This file is part of libFirm.
+ *
+ * This file may be distributed and/or modified under the terms of the
+ * GNU General Public License version 2 as published by the Free Software
+ * Foundation and appearing in the file LICENSE.GPL included in the
+ * packaging of this file.
+ *
+ * Licensees holding valid libFirm Professional Edition licenses may use
+ * this file in accordance with the libFirm Commercial License.
+ * Agreement provided with the Software.
+ *
+ * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+ * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE.
  */
 
 /**
- * Intraprozedurale Analyse zur Abschätzung der Aufrufrelation. Es
- * die Menge der instantiierten Klassen bestimmt, und daraus existierende Methoden
- * bestimmt.
+ * @file
+ * @brief    Interprocedural analysis to improve the call graph estimate.
+ * @author   Florian
+ * @version  09.06.2002
+ * @version  $Id$
  */
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
 
 #include "rta.h"
 
-# define TRUE 1
-# define FALSE 0
+#include <stdlib.h>
 
-/* # define RTA_SET */
-# ifdef RTA_SET
-typedef struct rta_set_elt
-{
-  struct rta_set_elt *_next;
-  void *_obj;
-} rta_set_elt_t;
+#include "irnode_t.h"
+#include "irprog_t.h"
+#include "irgraph_t.h"
 
-typedef struct rta_set
-{
-  rta_set_elt_t *_list;
-} rta_set_t;
+#include "eset.h"
+#include "irgwalk.h"
+#include "irgmod.h"
+#include "irvrfy.h"
+#include "irprintf.h"
+
+# ifndef TRUE
+#  define TRUE 1
+#  define FALSE 0
+# endif /* not defined TRUE */
 
-#  define SET_T rta_set_t
+/* flags */
+static int verbose     = 0;
 
-# else /* if defined RTA_SET */
-#  define SET_T eset
-#  define new_set eset_create
-#  define delete_set(SET)       eset_destroy(SET)
-#  define set_insert(SET,ELT)   eset_insert(SET,ELT)
-#  define set_contains(SET,ELT) eset_contains(SET,ELT)
-# endif /* defined RTA_SET */
 
-static SET_T *_live_classes   = NULL;
-static SET_T *_live_fields    = NULL;
-static SET_T *_called_methods = NULL;
+/* base data */
+static eset *_live_classes   = NULL;
 
 /* cache computed results */
-static SET_T *_live_graphs    = NULL;
-static SET_T *_dead_graphs    = NULL;
+static eset *_live_graphs    = NULL;
 
-# ifdef RTA_SET
-/* Reinvent the wheel, err, set. */
-/* eset uses obstacks, which fucks up the graph somehow */
-static rta_set_t *new_set ()
+/**
+   Given a method, find the firm graph that implements that method.
+*/
+static ir_graph *get_implementing_graph (ir_entity *method)
 {
-  rta_set_t *set = (rta_set_t*) xmalloc (sizeof (rta_set_t));
+#if 0
+  ir_graph *graph = get_entity_irg ((ir_entity*) method);
+
+  /* Search upwards in the overwrites graph. */
+  /* GL: this will not work for multiple inheritance */
+  if (NULL == graph) {
+    int i;
+    int n_over = get_entity_n_overwrites ((ir_entity*) method);
+
+    for (i = 0; (NULL == graph) && (i < n_over); i ++) {
+      ir_entity *over = get_entity_overwrites ((ir_entity*) method, i);
+      graph = get_implementing_graph (over);
+    }
+  }
+
+  /* GL   this is not valid in our remove irg algorithm ... which we removed by now ...  */
+  assert(get_entity_peculiarity(method) == peculiarity_description
+     || graph == get_entity_irg(get_SymConst_entity(get_atomic_ent_value(method))));
 
-  set->_list = NULL;
+  /* we *must* always return a graph != NULL, *except* when we're used
+     inside remove_irg or force_description */
+  /* assert (graph && "no graph"); */
+
+  return (graph);
+#else
+  ir_graph *graph = NULL;
 
-  return (set);
+  if (get_entity_peculiarity(method) != peculiarity_description)
+    graph = get_entity_irg(get_SymConst_entity(get_atomic_ent_value(method)));
+
+  return graph;
+#endif
 }
 
-static void delete_set (rta_set_t *set)
+/**
+ * Add a graph to the set of live graphs.
+ *
+ * @param graph  the graph to add
+ * @return non-zero if the graph was added, zero
+ *         if it was already in the live set
+ */
+static int add_graph (ir_graph *graph)
 {
-  rta_set_elt_t *elt = set->_list;
-
-  while (NULL != elt) {
-    rta_set_elt_t *old = elt;
-    elt = elt->_next;
+  if (!eset_contains (_live_graphs, graph)) {
+    if (verbose > 1) {
+      ir_fprintf(stdout, "RTA:        new graph of %+F\n", graph);
+    }
 
-    old->_next = NULL;
-    old->_obj  = NULL;
-    free (old);
+    eset_insert (_live_graphs, graph);
+    return (TRUE);
   }
 
-  free (set);
+  return (FALSE);
 }
 
-static void set_insert (rta_set_t *set, void *obj)
+/**
+ * Add a class to the set of live classes.
+ *
+ * @param clazz   the class to add
+ * @return non-zero if the graph was added, zero
+ *         if it was already in the live set
+ */
+static int add_class (ir_type *clazz)
 {
-  rta_set_elt_t *elt = (rta_set_elt_t*) xmalloc (sizeof (rta_set_elt_t));
+  if (!eset_contains (_live_classes, clazz)) {
+    if (verbose > 1) {
+      ir_fprintf(stdout, "RTA:        new class: %+F\n", clazz);
+    }
+
+    eset_insert (_live_classes, clazz);
+    return (TRUE);
+  }
 
-  elt->_obj = obj;
-  elt->_next = set->_list;
-  set->_list = elt;
+  return (FALSE);
 }
 
-static int set_contains (rta_set_t *set, void *obj)
+/** Given an entity, add all implementing graphs that belong to live classes
+ *  to _live_graphs.
+ *
+ *  Iff additions occurred, return TRUE, else FALSE.
+*/
+static int add_implementing_graphs (ir_entity *method)
 {
-  rta_set_elt_t *elt = set->_list;
+  int i;
+  int n_over = get_entity_n_overwrittenby (method);
+  ir_graph *graph = get_entity_irg (method);
+  int change = FALSE;
 
-  while (NULL != elt) {
-    if (elt->_obj == obj) {
-      return (TRUE);
+  if (NULL == graph) {
+    graph = get_implementing_graph (method);
+  }
+
+  if (verbose > 1) {
+    ir_fprintf(stdout, "RTA:        new call to %+F\n", method);
+  }
+
+  if (rta_is_alive_class (get_entity_owner (method))) {
+    if (NULL != graph) {
+      change = add_graph (graph);
     }
+  }
 
-    elt = elt->_next;
+  for (i = 0; i < n_over; i ++) {
+    ir_entity *over = get_entity_overwrittenby (method, i);
+    change |= add_implementing_graphs (over);
   }
 
-  return (FALSE);
+  return (change);
 }
-# endif /* defined RTA_SET */
-
-/* now the meat */
 
+/** Enter all method accesses and all class allocations into
+ *  our tables.
+ *
+ *  Set *(int*)env to true iff (possibly) new graphs have been found.
+ */
 static void rta_act (ir_node *node, void *env)
 {
-  opcode op = get_irn_opcode (node);
+  int *change = (int*) env;
+  ir_opcode op = get_irn_opcode (node);
 
-  if (iro_Call == op) {
-    entity *ent = NULL;
+  if (iro_Call == op) {         /* CALL */
+    ir_entity *ent = NULL;
 
     ir_node *ptr = get_Call_ptr (node);
-    // TODO: test:  ptr.op == Const
 
+    /* CALL SEL */
     if (iro_Sel == get_irn_opcode (ptr)) {
       ent = get_Sel_entity (ptr);
+      *change |= add_implementing_graphs (ent);
+
+      /* CALL SYMCONST */
+    } else if (iro_SymConst == get_irn_opcode (ptr)) {
+      if (get_SymConst_kind(ptr) == symconst_addr_ent) {
+        ir_graph *graph;
+
+        ent = get_SymConst_entity (ptr);
+        graph = get_entity_irg (ent);
+        if (graph) {
+          *change |= add_graph (graph);
+        } else {
+          /* it's an external allocated thing. */
+        }
+      } else if (get_SymConst_kind(ptr) == symconst_addr_name) {
+	    /* Entities of kind addr_name may not be allocated in this compilation unit.
+	       If so, the frontend built faulty Firm.  So just ignore. */
+	    /* if (get_SymConst_name(ptr) != new_id_from_str("iro_Catch"))
+        assert (ent && "couldn't determine entity of call to SymConst of kind addr_name."); */
+      } else {
+        /* other symconst. */
+        assert(0 && "This SymConst can not be an address for a method call.");
+      }
+
+      /* STRANGE */
+    } else {
+      assert(0 && "Unexpected address expression: can not analyse, therefore can not do correct rta!");
     }
 
-    if (ent) {
-      set_insert (_called_methods, ent);
-    }
-  } else if (iro_Load  == op) {
-    ir_node *ptr = get_Load_ptr (node);
-    entity  *ent = NULL;
-
-    if (iro_Sel == get_irn_opcode (ptr)) {
-      ent = get_Sel_entity (ptr);
-    }
-    if (ent) {
-      set_insert (_live_fields, ent);
-    }
-  } else  if (iro_Store == op) {
-    ir_node *ptr = get_Store_ptr (node);
-    entity  *ent = NULL;
+  } else if (iro_Alloc == op) { /* ALLOC */
+    ir_type *type = get_Alloc_type (node);
 
-    if (iro_Sel == get_irn_opcode (ptr)) {
-      ent = get_Sel_entity (ptr);
-    }
-    if (ent) {
-      set_insert (_live_fields, ent);
-    }
-  } else if (iro_Alloc == op) {
-    type *type = get_Alloc_type (node);
-    set_insert (_live_classes, type);
+    *change |= add_class (type);
   }
 }
 
-static void rta_fill_graph (ir_graph* graph)
+/**
+   Traverse the given graph to collect method accesses and
+   object allocations.
+*/
+static int rta_fill_graph (ir_graph* graph)
 {
-  irg_walk (get_irg_end_block (graph), rta_act, NULL, NULL);
+  int change = FALSE;
+  irg_walk_graph (graph, rta_act, NULL, &change);
+  return change;
 }
 
-static void rta_fill_all ()
+/** Traverse all graphs to collect method accesses and object allocations.
+ */
+static int rta_fill_incremental (void)
 {
   int i;
+  int n_runs = 0;
+  int rerun  = TRUE;
+#ifdef INTERPROCEDURAL_VIEW
+  int old_ip_view = get_interprocedural_view();
+
+  set_interprocedural_view(0);     /* save this for later */
+#endif
+
+  /* init_tables has added main_irg to _live_graphs */
+
+  /* Need to take care of graphs that are externally
+     visible or sticky. Pretend that they are called: */
 
   for (i = 0; i < get_irp_n_irgs(); i++) {
-    rta_fill_graph (get_irp_irg (i));
+    ir_graph *graph = get_irp_irg (i);
+    ir_entity *ent = get_irg_entity (graph);
+
+    if ((visibility_external_visible == get_entity_visibility (ent)) ||
+        (stickyness_sticky == get_entity_stickyness (ent))) {
+      eset_insert (_live_graphs, graph);
+      // printf("external visible: "); DDMG(graph);
+    }
   }
-}
 
-static int is_call_target (entity *method)
-{
-  return (TRUE);
-}
+  while (rerun) {
+    ir_graph *graph;
 
+    /* start off new */
+    eset *live_graphs = _live_graphs;
+    _live_graphs = eset_create ();
 
-static ir_graph *get_implementing_graph (entity *method)
-{
-  ir_graph *graph = get_entity_irg (method);
+    if (verbose > 1) {
+      fprintf(stdout, "RTA: RUN %i\n", n_runs);
+    }
 
-  if (NULL == graph) {
-    int i;
-    int n_over = get_entity_n_overwrites (method);
+    /* collect what we have found previously */
+    eset_insert_all (_live_graphs, live_graphs);
 
-    for (i = 0; (NULL == graph) && (i < n_over); i ++) {
-      entity *over = get_entity_overwrites (method, i);
-      graph = get_implementing_graph (over);
+    rerun = FALSE;
+    for (graph = eset_first (live_graphs);
+         graph;
+         graph = eset_next (live_graphs)) {
+
+      if (verbose > 1) {
+        ir_fprintf(stdout, "RTA: RUN %i: considering graph of %+F\n", n_runs,
+		        graph);
+      }
+
+      rerun |= rta_fill_graph (graph);
     }
+
+    eset_destroy (live_graphs);
+
+    n_runs ++;
   }
 
-  assert (graph && "no graph");
+#ifdef INTERPROCEDURAL_VIEW
+  set_interprocedural_view(old_ip_view); /* cover up our traces */
+#endif
 
-  return (graph);
+  return (n_runs);
 }
 
-static int has_live_call (entity *method, ir_graph *graph)
+/**
+ * Count the number of graphs that we have found to be live.
+ */
+static int stats (void)
 {
-  int has_call = FALSE;
-  int i, n_over;
-
-  if (get_irg_ent (graph) != method) {
-    return (FALSE);
-  }
+  int i;
+  int n_live_graphs = 0;
+  int n_graphs = get_irp_n_irgs();
 
-  if (is_call_target (method)) {
-    return (TRUE);
-  }
+  for (i = 0; i < n_graphs; i++) {
+    ir_graph *graph = get_irp_irg(i);
 
-  n_over = get_entity_n_overwrittenby (method);
-  for (i = 0; !has_call && (i < n_over); i ++) {
-    entity *over = get_entity_overwrittenby(method, i);
-    has_call |= has_live_call (over, graph);
+    if (rta_is_alive_graph (graph)) {
+      n_live_graphs ++;
+    }
   }
 
-  return (has_call);
+  return (n_live_graphs);
 }
 
-static int has_graph (type *clazz, ir_graph *graph)
+/* remove a graph, part I */
+/*
+   We removed the first graph to implement the entity, so we're
+   abstract now.  Pretend that it wasn't there at all, and every
+   entity that used to inherit this entity's graph is now abstract.
+*/
+/* Since we *know* that this entity will not be called, this is OK. */
+static void force_description (ir_entity *ent, ir_entity *addr)
 {
-  int has_the_graph = FALSE;
-  int i;
-  int n_sub;
+  int i, n_over = get_entity_n_overwrittenby (ent);
+
+  set_entity_peculiarity (ent, peculiarity_description);
+
+  for (i = 0; i < n_over; i ++) {
+    ir_entity *over = get_entity_overwrittenby (ent, i);
+
+    if (peculiarity_inherited == get_entity_peculiarity (over)) {
+      /* We rely on the fact that cse is performed on the const_code_irg. */
+      ir_entity *my_addr = get_SymConst_entity(get_atomic_ent_value(over));
+
+      if (addr == my_addr) {
+        force_description (over, addr);
+      }
+    } else if (peculiarity_existent == get_entity_peculiarity (over)) {
+      /* check whether 'over' forces 'inheritance' of *our* graph: */
+      ir_node *f_addr = get_atomic_ent_value (over);
+      ir_entity *impl_ent = get_SymConst_entity (f_addr);
+
+      assert(is_SymConst(f_addr) && "can't do complex addrs");
+      if (impl_ent == addr) {
+        assert (0 && "gibt's denn sowas");
+        force_description (over, addr);
+      }
+    }
+  }
+}
 
-  if (set_contains (_live_classes, clazz)) {
-    int n_meth = get_class_n_members (clazz);
+/**
+   Initialize the static data structures.
+*/
+static void init_tables (void)
+{
+  ir_type *tp;
+  int i, n;
 
-    for (i = 0; i < n_meth; i ++) {
-      entity *member = get_class_member (clazz, i);
-      if (is_method_type (get_entity_type (member))) {
-        ir_graph *impl = get_entity_irg (member);
+  _live_classes = eset_create ();
+  _live_graphs  = eset_create ();
 
-        if (impl == graph) {
-          return (TRUE);
-        }
-      } /* is_method */
-    } /* all methods */
-  } /* _live_classes.contains (clazz) */
-
-  n_sub = get_class_n_subtypes (clazz);
-  for (i = 0; !has_the_graph && (i < n_sub); i ++) {
-    type *sub = get_class_subtype (clazz, i);
+  if (get_irp_main_irg ()) {
+    eset_insert (_live_graphs, get_irp_main_irg ());
+  }
 
-    has_the_graph |= has_graph (sub, graph);
+  /* Find static allocated classes */
+  tp = get_glob_type();
+  n = get_class_n_members(tp);
+  for (i = 0; i < n; ++i) {
+    ir_type *member_type = get_entity_type(get_class_member(tp, i));
+    if (is_Class_type(member_type))
+      eset_insert(_live_classes, member_type);
   }
 
-  return (has_the_graph);
+  tp = get_tls_type();
+  n = get_struct_n_members(tp);
+  for (i = 0; i < n; ++i) {
+    ir_type *member_type = get_entity_type(get_struct_member(tp, i));
+    if (is_Class_type(member_type))
+      eset_insert(_live_classes, member_type);
+  }
 }
 
-static int has_live_class (entity *method, ir_graph *graph)
+/*
+ * Initialize the RTA data structures, and perform RTA.
+ * do_verbose If == 1, print statistics, if > 1, chatter about every detail
+ */
+void rta_init (int do_verbose)
 {
-  int has_class = FALSE;
-  int i;
-  int n_over;
-  type *clazz;
-
-  if (get_implementing_graph (method) != graph) {
-    return (FALSE);
+  int n_runs = 0;
+
+  int rem_vpi = get_visit_pseudo_irgs();
+  set_visit_pseudo_irgs(1);
+
+# ifdef DEBUG_libfirm
+  {
+    int i, n;
+    n = get_irp_n_irgs();
+    for (i = 0; i < n; i++) {
+      irg_vrfy (get_irp_irg(i));
+	}
+    tr_vrfy ();
   }
+# endif /* defined DEBUG_libfirm */
 
-  clazz = get_entity_owner (method);
-  if (has_graph (clazz, graph)) {
-    return (TRUE);
+  verbose = do_verbose;
+
+  init_tables ();
+
+  n_runs = rta_fill_incremental ();
+
+  if (verbose) {
+    int n_live_graphs = stats ();
+
+    printf ("RTA: n_graphs      = %i\n", get_irp_n_irgs ());
+    printf ("RTA: n_live_graphs = %i\n", n_live_graphs);
+    printf ("RTA: n_runs        = %i\n", n_runs);
   }
 
-  n_over = get_entity_n_overwrittenby (method);
-  for (i = 0; !has_class && (i < n_over); i ++) {
-    entity *over = get_entity_overwrittenby (method, i);
-    has_class |= has_live_class (over, graph);
+# ifdef DEBUG_libfirm
+  {
+    int i, n;
+    n = get_irp_n_irgs();
+    for (i = 0; i < n; i++) {
+      irg_vrfy (get_irp_irg(i));
+	}
+    tr_vrfy ();
   }
+# endif /* defined DEBUG_libfirm */
 
-  return (has_class);
+  set_visit_pseudo_irgs(rem_vpi);
 }
 
+/**
+ * walker for all types and entities
+ *
+ * Changes the peculiarity of entities that represents
+ * dead graphs to peculiarity_description.
+ */
+static void make_entity_to_description(type_or_ent tore, void *env) {
+  (void) env;
+  if (is_entity(tore.ent)) {
+    ir_entity *ent = tore.ent;
+
+    if ((is_Method_type(get_entity_type(ent)))                        &&
+        (get_entity_peculiarity(ent) != peculiarity_description)      &&
+        (get_entity_visibility(ent)  != visibility_external_allocated)   ) {
+      ir_graph *irg = get_entity_irg(get_SymConst_entity(get_atomic_ent_value(ent)));
+      if (!eset_contains (_live_graphs, irg)) {
+        set_entity_peculiarity(ent, peculiarity_description);
+        set_entity_irg(ent, NULL);
+      }
+    }
+  }
+}
 
-void rta_init ()
+/* Delete all graphs that we have found to be dead from the program
+   If verbose == 1, print statistics, if > 1, chatter about every detail
+*/
+void rta_delete_dead_graphs (void)
 {
-  fprintf (stdout, "BEGIN %s(%i): %s\n", __FILE__, __LINE__, __FUNCTION__);
+  int i;
+  int n_graphs = get_irp_n_irgs ();
+  ir_graph *graph = NULL;
+  int n_dead_graphs = 0;
+  ir_graph **dead_graphs;
 
-  _live_classes   = new_set ();
-  _live_fields    = new_set ();
-  _called_methods = new_set ();
+  int rem_vpi = get_visit_pseudo_irgs();
+  set_visit_pseudo_irgs(1);
 
-  _live_graphs = new_set ();
-  _dead_graphs = new_set ();
+  dead_graphs = XMALLOCN(ir_graph*, get_irp_n_irgs());
 
-  fprintf (stdout, "FILL  %s(%i): %s\n", __FILE__, __LINE__, __FUNCTION__);
-  rta_fill_all ();
-  fprintf (stdout, "DONE  %s(%i): %s\n", __FILE__, __LINE__, __FUNCTION__);
+  for (i = 0; i < n_graphs; i++) {
+    graph = get_irp_irg(i);
 
-  /*
-   * shold be:
-   * rta_fill_queue ()
-   */
-}
+    if (rta_is_alive_graph (graph)) {
+      /* do nothing (except some debugging fprintf`s :-) */
+    } else {
+#ifndef NDEBUG
+      ir_entity *ent = get_irg_entity (graph);
+      assert (visibility_external_visible != get_entity_visibility (ent));
+#endif
 
-void rta_cleanup ()
-{
-  if (_live_classes) {
-    delete_set (_live_classes);
-    _live_classes = NULL;
+      dead_graphs[n_dead_graphs] = graph;
+      n_dead_graphs ++;
+    }
   }
 
-  if (_live_fields) {
-    delete_set (_live_fields);
-    _live_fields = NULL;
+  type_walk(make_entity_to_description, NULL, NULL);
+  for (i = 0; i < n_dead_graphs; ++i) {
+    remove_irp_irg (dead_graphs[i]);
   }
 
-  if (_called_methods) {
-    delete_set (_called_methods);
-    _called_methods = NULL;
+  if (verbose) {
+    printf ("RTA: n_dead_graphs = %i\n", n_dead_graphs);
   }
 
-  if (_live_graphs) {
-    delete_set (_live_graphs);
-    _live_graphs = NULL;
-  }
+  set_visit_pseudo_irgs(rem_vpi);
 
-  if (_dead_graphs) {
-    delete_set (_dead_graphs);
-    _dead_graphs = NULL;
-  }
+  free(dead_graphs);
 }
 
-int  rta_is_alive_class  (type   *clazz)
+/* Clean up the RTA data structures.  Call this after calling rta_init */
+void rta_cleanup (void)
 {
-  return (set_contains (_live_classes, clazz));
-}
+# ifdef DEBUG_libfirm
+  int i;
+    for (i = 0; i < get_irp_n_irgs(); i++) {
+      irg_vrfy (get_irp_irg(i));
+    }
+    tr_vrfy ();
+# endif /* defined DEBUG_libfirm */
 
-int  rta_is_alive_graph (ir_graph *graph)
-{
-  if (set_contains (_live_graphs, graph)) {
-    return (TRUE);
+  if (_live_classes) {
+    eset_destroy (_live_classes);
+    _live_classes = NULL;
   }
 
-  if (set_contains (_dead_graphs, graph)) {
-    return (FALSE);
+  if (_live_graphs) {
+    eset_destroy (_live_graphs);
+    _live_graphs = NULL;
   }
+}
 
-  entity *meth = get_irg_ent (graph);
-
-  if (has_live_call (meth, graph) && has_live_class (meth, graph)) {
-    set_insert (_live_graphs, graph);
-
-    return (TRUE);
-  } else {
-    set_insert (_dead_graphs, graph);
-
-    return (FALSE);
-  }
+/* Say whether this class might be instantiated at any point in the program: */
+int  rta_is_alive_class  (ir_type   *clazz)
+{
+  return (eset_contains (_live_classes, clazz));
 }
 
-int  rta_is_alive_field  (entity *field)
+/* Say whether this graph might be run at any time in the program: */
+int  rta_is_alive_graph (ir_graph *graph)
 {
-  return (set_contains (_live_fields, field));
+  return eset_contains (_live_graphs, graph);
 }
 
+/* dump our opinion */
+void rta_report (void)
+{
+  int i;
 
+  for (i = 0; i < get_irp_n_types(); ++i) {
+    ir_type *tp = get_irp_type(i);
+    if (is_Class_type(tp) && rta_is_alive_class(tp)) {
+      ir_fprintf(stdout, "RTA: considered allocated: %+F\n", tp);
+    }
+  }
 
-/*
- * $Log$
- * Revision 1.2  2004/06/11 18:25:39  liekweg
- * Added todo
- *
- * Revision 1.1  2004/06/11 18:24:18  liekweg
- * Added RTA --flo
- *
- */
+  for (i = 0; i < get_irp_n_irgs(); i++) {
+    if (rta_is_alive_graph (get_irp_irg(i))) {
+      ir_fprintf(stdout, "RTA: considered called: graph of %+F\n", get_irp_irg(i));
+    }
+  }
+}