#include "rta.h"
#include <stdlib.h>
+#include <stdbool.h>
#include "irnode_t.h"
#include "irprog_t.h"
#include "irgraph_t.h"
-#include "eset.h"
+#include "pset_new.h"
#include "irgwalk.h"
#include "irgmod.h"
-#include "irvrfy.h"
+#include "irverify.h"
#include "irprintf.h"
#include "debug.h"
#include "error.h"
-# ifndef TRUE
-# define TRUE 1
-# define FALSE 0
-# endif /* not defined TRUE */
-
/** The debug handle. */
DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;)
/* base data */
-static eset *_live_classes = NULL;
+static pset_new_t *_live_classes = NULL;
/* cache computed results */
-static eset *_live_graphs = NULL;
-
-/**
- * Given a method, find the firm graph that implements that method.
- */
-static ir_graph *get_implementing_graph(ir_entity *method)
-{
- ir_graph *graph = NULL;
-
- if (get_entity_peculiarity(method) != peculiarity_description)
- graph = get_entity_irg(get_SymConst_entity(get_atomic_ent_value(method)));
-
- return graph;
-}
+static pset_new_t *_live_graphs = NULL;
/**
* Add a graph to the set of live graphs.
* @return non-zero if the graph was added, zero
* if it was already in the live set
*/
-static int add_graph(ir_graph *graph)
+static bool add_graph(ir_graph *graph)
{
- if (!eset_contains(_live_graphs, graph)) {
+ if (!pset_new_contains(_live_graphs, graph)) {
DB((dbg, LEVEL_2, "RTA: new graph of %+F\n", graph));
- eset_insert(_live_graphs, graph);
- return TRUE;
+ pset_new_insert(_live_graphs, graph);
+ return true;
}
- return FALSE;
+ return false;
}
/**
* @return non-zero if the graph was added, zero
* if it was already in the live set
*/
-static int add_class(ir_type *clazz)
+static bool add_class(ir_type *clazz)
{
- if (!eset_contains(_live_classes, clazz)) {
+ if (!pset_new_contains(_live_classes, clazz)) {
DB((dbg, LEVEL_2, "RTA: new class: %+F\n", clazz));
- eset_insert(_live_classes, clazz);
- return TRUE;
+ pset_new_insert(_live_classes, clazz);
+ return true;
}
- return FALSE;
+ return false;
}
/** Given an entity, add all implementing graphs that belong to live classes
* to _live_graphs.
*
- * Iff additions occurred, return TRUE, else FALSE.
+ * Iff additions occurred, return true, else false.
*/
-static int add_implementing_graphs(ir_entity *method)
+static bool add_implementing_graphs(ir_entity *method)
{
int i;
int n_over = get_entity_n_overwrittenby(method);
ir_graph *graph = get_entity_irg(method);
- int change = FALSE;
+ bool change = false;
if (NULL == graph)
- graph = get_implementing_graph(method);
+ graph = get_entity_irg(method);
DB((dbg, LEVEL_2, "RTA: new call to %+F\n", method));
*/
static void rta_act(ir_node *node, void *env)
{
- int *change = (int *)env;
- ir_opcode op = get_irn_opcode(node);
+ bool *change = (bool*)env;
+ unsigned op = get_irn_opcode(node);
if (iro_Call == op) { /* CALL */
ir_entity *ent = NULL;
} 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. */
panic("This SymConst can not be an address for a method call.");
Traverse the given graph to collect method accesses and
object allocations.
*/
-static int rta_fill_graph(ir_graph* graph)
+static bool rta_fill_graph(ir_graph* graph)
{
- int change = FALSE;
+ bool change = false;
irg_walk_graph(graph, rta_act, NULL, &change);
return change;
}
*/
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
+ int i;
+ int n_runs = 0;
+ bool rerun = true;
/* init_tables has added main_irg to _live_graphs */
for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
ir_graph *graph = get_irp_irg(i);
ir_entity *ent = get_irg_entity(graph);
+ ir_linkage linkage = get_entity_linkage(ent);
- if ((visibility_external_visible == get_entity_visibility(ent)) ||
- (stickyness_sticky == get_entity_stickyness(ent))) {
- eset_insert(_live_graphs, graph);
+ if (entity_is_externally_visible(ent)
+ || (linkage & IR_LINKAGE_HIDDEN_USER)) {
+ pset_new_insert(_live_graphs, graph);
}
}
while (rerun) {
ir_graph *graph;
+ pset_new_iterator_t iter;
/* start off new */
- eset *live_graphs = _live_graphs;
- _live_graphs = eset_create();
+ pset_new_t *live_graphs = _live_graphs;
+ _live_graphs = XMALLOC(pset_new_t);
+ pset_new_init(_live_graphs);
DB((dbg, LEVEL_2, "RTA: RUN %i\n", n_runs));
/* collect what we have found previously */
- eset_insert_all(_live_graphs, live_graphs);
+ foreach_pset_new(live_graphs, ir_graph*, graph, iter) {
+ pset_new_insert(_live_graphs, graph);
+ }
- rerun = FALSE;
- for (graph = eset_first(live_graphs);
- graph != NULL;
- graph = eset_next(live_graphs)) {
+ rerun = false;
+ foreach_pset_new(live_graphs, ir_graph*, graph, iter) {
DB((dbg, LEVEL_2, "RTA: RUN %i: considering graph of %+F\n", n_runs, graph));
rerun |= rta_fill_graph(graph);
}
- eset_destroy(live_graphs);
+ pset_new_destroy(live_graphs);
+ free(live_graphs);
++n_runs;
}
-#ifdef INTERPROCEDURAL_VIEW
- set_interprocedural_view(old_ip_view); /* cover up our traces */
-#endif
-
return n_runs;
}
+#ifdef DEBUG_libfirm
/**
* Count the number of graphs that we have found to be live.
*/
return n_live_graphs;
}
+#endif
/* remove a graph, part I */
/*
int i, n;
ir_graph *irg;
- _live_classes = eset_create();
- _live_graphs = eset_create();
+ _live_classes = XMALLOC(pset_new_t);
+ pset_new_init(_live_classes);
+ _live_graphs = XMALLOC(pset_new_t);
+ pset_new_init(_live_graphs);
irg = get_irp_main_irg();
if (irg != NULL) {
/* add the main irg to the live set if one is specified */
- eset_insert(_live_graphs, irg);
+ pset_new_insert(_live_graphs, irg);
}
/* Find static allocated classes */
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);
+ pset_new_insert(_live_classes, member_type);
}
tp = get_tls_type();
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);
+ pset_new_insert(_live_classes, member_type);
}
/** @FIXME: add constructors/destructors */
void rta_init(void)
{
int n_runs = 0;
- int rem_vpi = get_visit_pseudo_irgs();
- set_visit_pseudo_irgs(1);
FIRM_DBG_REGISTER(dbg, "firm.ana.rta");
{
int i;
for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
- irg_vrfy(get_irp_irg(i));
+ irg_verify(get_irp_irg(i), 0);
}
- tr_vrfy();
+ tr_verify();
}
# endif /* defined DEBUG_libfirm */
int i;
for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
- irg_vrfy(get_irp_irg(i));
+ irg_verify(get_irp_irg(i), 0);
}
- tr_vrfy();
+ tr_verify();
}
# endif /* defined DEBUG_libfirm */
-
- set_visit_pseudo_irgs(rem_vpi);
}
/**
* Changes the peculiarity of entities that represents
* dead graphs to peculiarity_description.
*/
-static void make_entity_to_description(type_or_ent tore, void *env) {
+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)) {
+ if ((is_Method_type(get_entity_type(ent))) &&
+ !entity_is_externally_visible(ent)) {
+ ir_graph *irg = get_entity_irg(ent);
+ if (irg != NULL && ! pset_new_contains(_live_graphs, irg)) {
set_entity_peculiarity(ent, peculiarity_description);
set_entity_irg(ent, NULL);
}
int i, n_dead_irgs, n_graphs = get_irp_n_irgs();
ir_graph *irg, *next_irg, *dead_irgs;
- int rem_vpi = get_visit_pseudo_irgs();
- set_visit_pseudo_irgs(1);
-
irp_reserve_resources(irp, IR_RESOURCE_IRG_LINK);
n_dead_irgs = 0;
irg = get_irp_irg(i);
if (! rta_is_alive_graph(irg)) {
-#ifndef NDEBUG
- ir_entity *ent = get_irg_entity(irg);
- assert(visibility_external_visible != get_entity_visibility(ent));
-#endif
set_irg_link(irg, dead_irgs);
dead_irgs = irg;
++n_dead_irgs;
/* Hmm, probably we need to run this only if dead_irgs is non-NULL */
type_walk(make_entity_to_description, NULL, NULL);
for (irg = dead_irgs; irg != NULL; irg = next_irg) {
- next_irg = get_irg_link(irg);
+ next_irg = (ir_graph*) get_irg_link(irg);
remove_irp_irg(irg);
}
DB((dbg, LEVEL_1, "RTA: dead methods = %i\n", n_dead_irgs));
irp_free_resources(irp, IR_RESOURCE_IRG_LINK);
- set_visit_pseudo_irgs(rem_vpi);
}
/* Clean up the RTA data structures. Call this after calling rta_init */
# ifdef DEBUG_libfirm
int i;
for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
- irg_vrfy(get_irp_irg(i));
+ irg_verify(get_irp_irg(i), 0);
}
- tr_vrfy();
+ tr_verify();
# endif /* defined DEBUG_libfirm */
if (_live_classes != NULL) {
- eset_destroy(_live_classes);
+ pset_new_destroy(_live_classes);
+ free(_live_classes);
_live_classes = NULL;
}
if (_live_graphs != NULL) {
- eset_destroy(_live_graphs);
+ pset_new_destroy(_live_graphs);
+ free(_live_graphs);
_live_graphs = NULL;
}
}
/* 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);
+ return pset_new_contains(_live_classes, clazz);
}
/* Say whether this graph might be run at any time in the program: */
int rta_is_alive_graph(ir_graph *graph)
{
- return eset_contains(_live_graphs, graph);
+ return pset_new_contains(_live_graphs, graph);
}
/* dump our opinion */
projects / libfirm / blobdiff