- replaced all backedge info by raw bitsets
[r16785]
this irg. */
int get_irg_recursion_depth(ir_graph *irg);
this irg. */
int get_irg_recursion_depth(ir_graph *irg);
-#ifdef INTERPROCEDURAL_VIEW
/** Returns the method execution frequency of a graph. */
double get_irg_method_execution_frequency(ir_graph *irg);
/** Returns the method execution frequency of a graph. */
double get_irg_method_execution_frequency(ir_graph *irg);
/** Marks the nesting depth state of the program representation as inconsistent. */
void set_irp_loop_nesting_depth_state_inconsistent(void);
/** Marks the nesting depth state of the program representation as inconsistent. */
void set_irp_loop_nesting_depth_state_inconsistent(void);
#endif /* _CALLGRAPH_H_ */
#endif /* _CALLGRAPH_H_ */
# include "config.h"
#endif
# include "config.h"
#endif
-#ifdef INTERPROCEDURAL_VIEW
-
#ifdef HAVE_STRING_H
# include <string.h>
#endif
#ifdef HAVE_STRING_H
# include <string.h>
#endif
#include "array.h"
#include "pmap.h"
#include "hashptr.h"
#include "array.h"
#include "pmap.h"
#include "hashptr.h"
/* Returns the caller at position pos. */
ir_graph *get_irg_caller(ir_graph *irg, int pos) {
/* Returns the caller at position pos. */
ir_graph *get_irg_caller(ir_graph *irg, int pos) {
- assert (pos >= 0 && pos < get_irg_n_callers(irg));
+ assert(pos >= 0 && pos < get_irg_n_callers(irg));
if (irg->callers) return irg->callers[pos];
return NULL;
}
if (irg->callers) return irg->callers[pos];
return NULL;
}
-#ifdef INTERPROCEDURAL_VIEW
/* Returns non-zero if the caller at position pos is "a backedge", i.e. a recursion. */
int is_irg_caller_backedge(ir_graph *irg, int pos) {
/* Returns non-zero if the caller at position pos is "a backedge", i.e. a recursion. */
int is_irg_caller_backedge(ir_graph *irg, int pos) {
- assert (pos >= 0 && pos < get_irg_n_callers(irg));
+ assert(pos >= 0 && pos < get_irg_n_callers(irg));
return irg->caller_isbe != NULL ? rbitset_is_set(irg->caller_isbe, pos) : 0;
}
return irg->caller_isbe != NULL ? rbitset_is_set(irg->caller_isbe, pos) : 0;
}
/**
* Find the reversion position of a caller.
/**
* Find the reversion position of a caller.
/* Returns the callee at position pos. */
ir_graph *get_irg_callee(ir_graph *irg, int pos) {
/* Returns the callee at position pos. */
ir_graph *get_irg_callee(ir_graph *irg, int pos) {
- assert (pos >= 0 && pos < get_irg_n_callees(irg));
+ assert(pos >= 0 && pos < get_irg_n_callees(irg));
if (irg->callees) return irg->callees[pos]->irg;
return NULL;
}
/* Returns non-zero if the callee at position pos is "a backedge", i.e. a recursion. */
int is_irg_callee_backedge(ir_graph *irg, int pos) {
if (irg->callees) return irg->callees[pos]->irg;
return NULL;
}
/* Returns non-zero if the callee at position pos is "a backedge", i.e. a recursion. */
int is_irg_callee_backedge(ir_graph *irg, int pos) {
- assert (pos >= 0 && pos < get_irg_n_callees(irg));
- return irg->callee_isbe != NULL ? irg->callee_isbe[pos] : 0;
+ assert(pos >= 0 && pos < get_irg_n_callees(irg));
+ return irg->callee_isbe != NULL ? rbitset_is_set(irg->callee_isbe, pos) : 0;
}
/* Returns non-zero if the irg has a backedge callee. */
}
/* Returns non-zero if the irg has a backedge callee. */
if (irg->callee_isbe != NULL) {
for (i = 0; i < n_callees; ++i)
if (irg->callee_isbe != NULL) {
for (i = 0; i < n_callees; ++i)
- if (irg->callee_isbe[i]) return 1;
+ if (rbitset_is_set(irg->callee_isbe, i))
+ return 1;
-#ifdef INTERPROCEDURAL_VIEW
/**
* Mark the callee at position pos as a backedge.
*/
static void set_irg_callee_backedge(ir_graph *irg, int pos) {
int n = get_irg_n_callees(irg);
/**
* Mark the callee at position pos as a backedge.
*/
static void set_irg_callee_backedge(ir_graph *irg, int pos) {
int n = get_irg_n_callees(irg);
- assert (pos >= 0 && pos < n);
-
/* allocate a new array on demand */
if (irg->callee_isbe == NULL)
/* allocate a new array on demand */
if (irg->callee_isbe == NULL)
- irg->callee_isbe = xcalloc(n, sizeof(irg->callee_isbe[0]));
- irg->callee_isbe[pos] = 1;
+ irg->callee_isbe = rbitset_malloc(n);
+ assert(pos >= 0 && pos < n);
+ rbitset_set(irg->callee_isbe, pos);
/* Returns the maximal loop depth of call nodes that call along this edge. */
int get_irg_callee_loop_depth(ir_graph *irg, int pos) {
/* Returns the maximal loop depth of call nodes that call along this edge. */
int get_irg_callee_loop_depth(ir_graph *irg, int pos) {
- assert (pos >= 0 && pos < get_irg_n_callees(irg));
+ assert(pos >= 0 && pos < get_irg_n_callees(irg));
if (irg->callees) return irg->callees[pos]->max_depth;
return -1;
}
if (irg->callees) return irg->callees[pos]->max_depth;
return -1;
}
void compute_callgraph(void) {
int i, n_irgs;
void compute_callgraph(void) {
int i, n_irgs;
+#ifdef INTERPROCEDURAL_VIEW
assert(! get_interprocedural_view()); /* Else walking will not reach the Call nodes. */
assert(! get_interprocedural_view()); /* Else walking will not reach the Call nodes. */
/* initialize */
free_callgraph();
/* initialize */
free_callgraph();
static int loop_node_cnt = 0; /**< Counts the number of allocated cfloop nodes.
Each cfloop node gets a unique number.
What for? ev. remove. @@@ */
static int loop_node_cnt = 0; /**< Counts the number of allocated cfloop nodes.
Each cfloop node gets a unique number.
What for? ev. remove. @@@ */
-#ifdef INTERPROCEDURAL_VIEW
static int current_dfn = 1; /**< Counter to generate depth first numbering
of visited nodes. */
static int current_dfn = 1; /**< Counter to generate depth first numbering
of visited nodes. */
/*-----------------*/
/* Node attributes */
/*-----------------*/
/* Node attributes */
* allocates a new scc_info of the obstack
*/
static INLINE scc_info *new_scc_info(void) {
* allocates a new scc_info of the obstack
*/
static INLINE scc_info *new_scc_info(void) {
- scc_info *info = obstack_alloc (outermost_ir_graph->obst, sizeof(*info));
+ scc_info *info = obstack_alloc(outermost_ir_graph->obst, sizeof(*info));
memset(info, 0, sizeof(*info));
return info;
}
memset(info, 0, sizeof(*info));
return info;
}
cg_irg_visited(ir_graph *irg) {
scc_info *info = get_irg_link(irg);
assert(info && "missing call to init_scc");
cg_irg_visited(ir_graph *irg) {
scc_info *info = get_irg_link(irg);
assert(info && "missing call to init_scc");
- return (info->visited >= master_cg_visited);
+ return info->visited >= master_cg_visited;
*/
static INLINE void init_stack(void) {
if (stack) {
*/
static INLINE void init_stack(void) {
if (stack) {
- ARR_RESIZE (ir_graph *, stack, 1000);
+ ARR_RESIZE(ir_graph *, stack, 1000);
- stack = NEW_ARR_F (ir_graph *, 1000);
+ stack = NEW_ARR_F(ir_graph *, 1000);
* @param n the graph to be pushed
*/
static INLINE void push(ir_graph *irg) {
* @param n the graph to be pushed
*/
static INLINE void push(ir_graph *irg) {
- if (tos == ARR_LEN (stack)) {
- int nlen = ARR_LEN (stack) * 2;
- ARR_RESIZE (ir_node *, stack, nlen);
+ if (tos == ARR_LEN(stack)) {
+ int nlen = ARR_LEN(stack) * 2;
+ ARR_RESIZE(ir_node *, stack, nlen);
}
stack [tos++] = irg;
mark_irg_in_stack(irg);
}
stack [tos++] = irg;
mark_irg_in_stack(irg);
-#ifdef INTERPROCEDURAL_VIEW
/* GL ??? my last son is my grandson??? Removes cfloops with no
ir_nodes in them. Such loops have only another loop as son. (Why
can't they have two loops as sons? Does it never get that far? ) */
/* GL ??? my last son is my grandson??? Removes cfloops with no
ir_nodes in them. Such loops have only another loop as son. (Why
can't they have two loops as sons? Does it never get that far? ) */
/**
* Removes and unmarks all nodes up to n from the stack.
/**
* Removes and unmarks all nodes up to n from the stack.
/* The loop data structure. **/
/**********************************************************************/
/* The loop data structure. **/
/**********************************************************************/
-#ifdef INTERPROCEDURAL_VIEW
/**
* Allocates a new loop as son of current_loop. Sets current_loop
* to the new loop and returns the father.
/**
* Allocates a new loop as son of current_loop. Sets current_loop
* to the new loop and returns the father.
son = obstack_alloc(outermost_ir_graph->obst, sizeof(*son));
memset(son, 0, sizeof(*son));
son->kind = k_ir_loop;
son = obstack_alloc(outermost_ir_graph->obst, sizeof(*son));
memset(son, 0, sizeof(*son));
son->kind = k_ir_loop;
- son->children = NEW_ARR_F (loop_element, 0);
+ son->children = NEW_ARR_F(loop_element, 0);
son->n_nodes = 0;
son->n_sons = 0;
son->link = NULL;
son->n_nodes = 0;
son->n_sons = 0;
son->link = NULL;
for (i = 0; i < arity; i++) {
ir_graph *pred = get_irg_callee(n, i);
assert(pred);
for (i = 0; i < arity; i++) {
ir_graph *pred = get_irg_callee(n, i);
assert(pred);
- if (is_irg_callee_backedge(n, i)) { continue; }
+ if (is_irg_callee_backedge(n, i))
+ continue;
if (!irg_is_in_stack(pred)) {
some_outof_loop = 1;
} else {
if (!irg_is_in_stack(pred)) {
some_outof_loop = 1;
} else {
- if(get_irg_uplink(pred) < get_irg_uplink(root)) {
+ if (get_irg_uplink(pred) < get_irg_uplink(root)) {
assert(get_irg_uplink(pred) >= get_irg_uplink(root));
}
some_in_loop = 1;
assert(get_irg_uplink(pred) >= get_irg_uplink(root));
}
some_in_loop = 1;
return !some_outof_loop & some_in_loop;
}
return !some_outof_loop & some_in_loop;
}
+#ifdef INTERPROCEDURAL_VIEW
/**
* Check whether there is a parallel edge in the ip control flow.
* Only
/**
* Check whether there is a parallel edge in the ip control flow.
* Only
is_ip_head(ir_graph *n, ir_graph *pred)
{
int is_be = 0;
is_ip_head(ir_graph *n, ir_graph *pred)
{
int is_be = 0;
int iv_rem = get_interprocedural_view();
set_interprocedural_view(1);
{
int iv_rem = get_interprocedural_view();
set_interprocedural_view(1);
{
set_interprocedural_view(iv_rem);
return is_be;
}
set_interprocedural_view(iv_rem);
return is_be;
}
+#endif /* INTERPROCEDURAL_VIEW */
/**
* Returns index of the predecessor with the smallest dfn number
/**
* Returns index of the predecessor with the smallest dfn number
int arity = get_irg_n_callees(n);
for (i = 0; i < arity; i++) {
ir_graph *pred = get_irg_callee(n, i);
int arity = get_irg_n_callees(n);
for (i = 0; i < arity; i++) {
ir_graph *pred = get_irg_callee(n, i);
- if (is_irg_callee_backedge(n, i) || !irg_is_in_stack(pred)) continue;
+ if (is_irg_callee_backedge(n, i) || !irg_is_in_stack(pred))
+ continue;
if (get_irg_dfn(pred) >= limit && (min == -1 || get_irg_dfn(pred) < min)) {
index = i;
min = get_irg_dfn(pred);
if (get_irg_dfn(pred) >= limit && (min == -1 || get_irg_dfn(pred) < min)) {
index = i;
min = get_irg_dfn(pred);
int i, index = -2, max = -1;
int arity = get_irg_n_callees(n);
int i, index = -2, max = -1;
int arity = get_irg_n_callees(n);
- for (i = 0; i < arity; i++) {
+ for (i = 0; i < arity; ++i) {
ir_graph *pred = get_irg_callee(n, i);
if (is_irg_callee_backedge (n, i) || !irg_is_in_stack(pred)) continue;
if (get_irg_dfn(pred) > max) {
ir_graph *pred = get_irg_callee(n, i);
if (is_irg_callee_backedge (n, i) || !irg_is_in_stack(pred)) continue;
if (get_irg_dfn(pred) > max) {
+#ifndef INTERPROCEDURAL_VIEW
static ir_graph *
find_tail(ir_graph *n) {
ir_graph *m;
static ir_graph *
find_tail(ir_graph *n) {
ir_graph *m;
for (i = tos-2; i >= 0; --i) {
m = stack[i];
for (i = tos-2; i >= 0; --i) {
m = stack[i];
- if (is_head (m, n)) {
- res_index = smallest_dfn_pred (m, get_irg_dfn(m) + 1);
+ if (is_head(m, n)) {
+ res_index = smallest_dfn_pred(m, get_irg_dfn(m) + 1);
if (res_index == -2) /* no smallest dfn pred found. */
if (res_index == -2) /* no smallest dfn pred found. */
- res_index = largest_dfn_pred (m);
+ res_index = largest_dfn_pred(m);
if ((m == n) && (res_index == -2)) {
i = -1;
if ((m == n) && (res_index == -2)) {
i = -1;
/* A dead loop not reachable from Start. */
for (i = tos-2; i >= 0; --i) {
m = stack[i];
/* A dead loop not reachable from Start. */
for (i = tos-2; i >= 0; --i) {
m = stack[i];
- if (is_endless_head (m, n)) {
- res_index = smallest_dfn_pred (m, get_irg_dfn(m) + 1);
+ if (is_endless_head(m, n)) {
+ res_index = smallest_dfn_pred(m, get_irg_dfn(m) + 1);
if (res_index == -2) /* no smallest dfn pred found. */
if (res_index == -2) /* no smallest dfn pred found. */
- res_index = largest_dfn_pred (m);
+ res_index = largest_dfn_pred(m);
break;
}
if (m == n) { break; } /* It's not an unreachable loop, either. */
break;
}
if (m == n) { break; } /* It's not an unreachable loop, either. */
}
assert (res_index > -2);
}
assert (res_index > -2);
- set_irg_callee_backedge (m, res_index);
+ set_irg_callee_backedge(m, res_index);
return get_irg_callee(m, res_index);
}
#else
return get_irg_callee(m, res_index);
}
#else
ir_graph *pred = (i < tos -1) ? stack[i+1] : n;
m = stack[i];
ir_graph *pred = (i < tos -1) ? stack[i+1] : n;
m = stack[i];
//printf(" found 1a! "); DDM;
in_and_out = m;
if (is_ip_head(pred, m)) {
//printf(" found 1a! "); DDM;
in_and_out = m;
if (is_ip_head(pred, m)) {
//printf("*** head is "); DDMG(m);
//printf("*** head is "); DDMG(m);
- res_index = smallest_dfn_pred (m, get_irg_dfn(m) + 1);
+ res_index = smallest_dfn_pred(m, get_irg_dfn(m) + 1);
if (res_index == -2) /* no smallest dfn pred found. */
if (res_index == -2) /* no smallest dfn pred found. */
- res_index = largest_dfn_pred (m);
+ res_index = largest_dfn_pred(m);
- set_irg_callee_backedge (m, res_index);
+ set_irg_callee_backedge(m, res_index);
res = get_irg_callee(m, res_index);
//printf("*** tail is "); DDMG(res);
return res;
}
res = get_irg_callee(m, res_index);
//printf("*** tail is "); DDMG(res);
return res;
}
+#endif /* INTERPROCEDURAL_VIEW */
/*-----------------------------------------------------------*
* The core algorithm. *
/*-----------------------------------------------------------*
* The core algorithm. *
ir_loop *l = new_loop();
/* Remove the cfloop from the stack ... */
ir_loop *l = new_loop();
/* Remove the cfloop from the stack ... */
- pop_scc_unmark_visit (n);
+ pop_scc_unmark_visit(n);
/* The current backedge has been marked, that is temporarily eliminated,
by find tail. Start the scc algorithm
anew on the subgraph thats left (the current cfloop without the backedge)
in order to find more inner cfloops. */
/* The current backedge has been marked, that is temporarily eliminated,
by find tail. Start the scc algorithm
anew on the subgraph thats left (the current cfloop without the backedge)
in order to find more inner cfloops. */
- assert (cg_irg_visited(n));
+ assert(cg_irg_visited(n));
close_loop(l);
} else {
pop_scc_to_loop(n);
close_loop(l);
} else {
pop_scc_to_loop(n);
irg->callee_isbe = NULL;
}
}
irg->callee_isbe = NULL;
}
}
/* ----------------------------------------------------------------------------------- */
/* Another algorithm to compute recursion nesting depth */
/* ----------------------------------------------------------------------------------- */
/* Another algorithm to compute recursion nesting depth */
/* weight. Assign graphs the maximal depth. */
/* ----------------------------------------------------------------------------------- */
/* weight. Assign graphs the maximal depth. */
/* ----------------------------------------------------------------------------------- */
-static void compute_loop_depth (ir_graph *irg, void *env) {
+static void compute_loop_depth(ir_graph *irg, void *env) {
int current_nesting = *(int *) env;
int old_nesting = irg->callgraph_loop_depth;
int old_visited = get_cg_irg_visited(irg);
int current_nesting = *(int *) env;
int old_nesting = irg->callgraph_loop_depth;
int old_visited = get_cg_irg_visited(irg);
-static void compute_rec_depth (ir_graph *irg, void *env) {
+static void compute_rec_depth(ir_graph *irg, void *env) {
ana_entry2 *e = (ana_entry2 *)env;
ir_loop *l = irg->l;
int depth, old_depth = irg->callgraph_recursion_depth;
ana_entry2 *e = (ana_entry2 *)env;
ir_loop *l = irg->l;
int depth, old_depth = irg->callgraph_recursion_depth;
/* Don't walk the graph, but a tree that is an unfolded graph.
Therefore we unset the visited flag at the end. */
n_callees = get_irg_n_callees(irg);
/* Don't walk the graph, but a tree that is an unfolded graph.
Therefore we unset the visited flag at the end. */
n_callees = get_irg_n_callees(irg);
- for (i = 0; i < n_callees; i++) {
+ for (i = 0; i < n_callees; ++i) {
ir_graph *m = get_irg_callee(irg, i);
compute_rec_depth(m, env);
}
ir_graph *m = get_irg_callee(irg, i);
compute_rec_depth(m, env);
}
/* nodes to evaluate a callgraph edge. */
/* ----------------------------------------------------------------------------------- */
/* nodes to evaluate a callgraph edge. */
/* ----------------------------------------------------------------------------------- */
-#ifdef INTERPROCEDURAL_VIEW
/* Returns the method execution frequency of a graph. */
/* Returns the method execution frequency of a graph. */
-double get_irg_method_execution_frequency (ir_graph *irg) {
+double get_irg_method_execution_frequency(ir_graph *irg) {
return irg->method_execution_frequency;
}
return irg->method_execution_frequency;
}
So they must be marked. Else we will reach the node through
one of the unmarked ones. */
n_callers = get_irg_n_callers(irg);
So they must be marked. Else we will reach the node through
one of the unmarked ones. */
n_callers = get_irg_n_callers(irg);
- for (i = 0; i < n_callers; i++) {
+ for (i = 0; i < n_callers; ++i) {
ir_graph *m = get_irg_caller(irg, i);
if (is_irg_caller_backedge(irg, i)) continue;
if (!cg_irg_visited(m)) {
ir_graph *m = get_irg_caller(irg, i);
if (is_irg_caller_backedge(irg, i)) continue;
if (!cg_irg_visited(m)) {
/* recur */
n_callees = get_irg_n_callees(irg);
/* recur */
n_callees = get_irg_n_callees(irg);
- for (i = 0; i < n_callees; i++) {
+ for (i = 0; i < n_callees; ++i) {
compute_method_execution_frequency(get_irg_callee(irg, i), NULL);
}
}
compute_method_execution_frequency(get_irg_callee(irg, i), NULL);
}
}
master_cg_visited++;
cgscc(outermost_ir_graph);
master_cg_visited++;
cgscc(outermost_ir_graph);
- for (i = 0; i < n_irgs; i++) {
+ for (i = 0; i < n_irgs; ++i) {
ir_graph *irg = get_irp_irg(i);
if (!cg_irg_visited(irg) && get_irg_n_callers(irg) == 0)
cgscc(irg);
}
ir_graph *irg = get_irp_irg(i);
if (!cg_irg_visited(irg) && get_irg_n_callers(irg) == 0)
cgscc(irg);
}
- for (i = 0; i < n_irgs; i++) {
+ for (i = 0; i < n_irgs; ++i) {
ir_graph *irg = get_irp_irg(i);
if (!cg_irg_visited(irg))
cgscc(irg);
ir_graph *irg = get_irp_irg(i);
if (!cg_irg_visited(irg))
cgscc(irg);
irp->outermost_cg_loop = current_loop;
/* -- Reverse the backedge information. -- */
irp->outermost_cg_loop = current_loop;
/* -- Reverse the backedge information. -- */
- for (i = 0; i < n_irgs; i++) {
+ for (i = 0; i < n_irgs; ++i) {
ir_graph *irg = get_irp_irg(i);
int j, n_callees = get_irg_n_callees(irg);
for (j = 0; j < n_callees; ++j) {
ir_graph *irg = get_irp_irg(i);
int j, n_callees = get_irg_n_callees(irg);
for (j = 0; j < n_callees; ++j) {
current_nesting = 0;
irp->max_callgraph_loop_depth = 0;
master_cg_visited += 2;
current_nesting = 0;
irp->max_callgraph_loop_depth = 0;
master_cg_visited += 2;
- //printf (" ** starting at "); DDMG(get_irp_main_irg());
+ //printf(" ** starting at "); DDMG(get_irp_main_irg());
compute_loop_depth(get_irp_main_irg(), ¤t_nesting);
for (i = 0; i < n_irgs; i++) {
ir_graph *irg = get_irp_irg(i);
if ((get_cg_irg_visited(irg) < master_cg_visited-1) &&
get_irg_n_callers(irg) == 0) {
compute_loop_depth(irg, ¤t_nesting);
compute_loop_depth(get_irp_main_irg(), ¤t_nesting);
for (i = 0; i < n_irgs; i++) {
ir_graph *irg = get_irp_irg(i);
if ((get_cg_irg_visited(irg) < master_cg_visited-1) &&
get_irg_n_callers(irg) == 0) {
compute_loop_depth(irg, ¤t_nesting);
- //printf (" ** starting at "); DDMG(irg);
+ //printf(" ** starting at "); DDMG(irg);
}
}
for (i = 0; i < n_irgs; i++) {
ir_graph *irg = get_irp_irg(i);
if (get_cg_irg_visited(irg) < master_cg_visited-1) {
compute_loop_depth(irg, ¤t_nesting);
}
}
for (i = 0; i < n_irgs; i++) {
ir_graph *irg = get_irp_irg(i);
if (get_cg_irg_visited(irg) < master_cg_visited-1) {
compute_loop_depth(irg, ¤t_nesting);
- //printf (" ** starting at "); DDMG(irg);
+ //printf(" ** starting at "); DDMG(irg);
master_cg_visited += 2;
compute_rec_depth(get_irp_main_irg(), &e);
master_cg_visited += 2;
compute_rec_depth(get_irp_main_irg(), &e);
- //printf (" ++ starting at "); DDMG(get_irp_main_irg());
+ //printf(" ++ starting at "); DDMG(get_irp_main_irg());
for (i = 0; i < n_irgs; i++) {
ir_graph *irg = get_irp_irg(i);
if ((get_cg_irg_visited(irg) < master_cg_visited-1) &&
get_irg_n_callers(irg) == 0) {
compute_rec_depth(irg, &e);
for (i = 0; i < n_irgs; i++) {
ir_graph *irg = get_irp_irg(i);
if ((get_cg_irg_visited(irg) < master_cg_visited-1) &&
get_irg_n_callers(irg) == 0) {
compute_rec_depth(irg, &e);
- //printf (" ++ starting at "); DDMG(irg);
+ //printf(" ++ starting at "); DDMG(irg);
}
}
for (i = 0; i < n_irgs; i++) {
ir_graph *irg = get_irp_irg(i);
if (get_cg_irg_visited(irg) < master_cg_visited-1) {
compute_rec_depth(irg, &e);
}
}
for (i = 0; i < n_irgs; i++) {
ir_graph *irg = get_irp_irg(i);
if (get_cg_irg_visited(irg) < master_cg_visited-1) {
compute_rec_depth(irg, &e);
- //printf (" ++ starting at "); DDMG(irg);
+ //printf(" ++ starting at "); DDMG(irg);
/* Returns the maximal loop depth of all paths from an external visible method to
this irg. */
/* Returns the maximal loop depth of all paths from an external visible method to
this irg. */
set_irp_loop_nesting_depth_state(loop_nesting_depth_consistent);
}
set_irp_loop_nesting_depth_state(loop_nesting_depth_consistent);
}
loop_nesting_depth_state get_irp_loop_nesting_depth_state(void) {
return irp->lnd_state;
}
loop_nesting_depth_state get_irp_loop_nesting_depth_state(void) {
return irp->lnd_state;
}
if (irp->lnd_state == loop_nesting_depth_consistent)
irp->lnd_state = loop_nesting_depth_inconsistent;
}
if (irp->lnd_state == loop_nesting_depth_consistent)
irp->lnd_state = loop_nesting_depth_inconsistent;
}
the node. */
ir_graph **callers; /**< For callgraph analysis: list of caller graphs. */
the node. */
ir_graph **callers; /**< For callgraph analysis: list of caller graphs. */
- unsigned *caller_isbe; /**< For callgraph analysis: raw bitset if backedge. */
+ unsigned *caller_isbe; /**< For callgraph analysis: raw bitset if backedge info calculated. */
cg_callee_entry **callees; /**< For callgraph analysis: list of callee calls */
cg_callee_entry **callees; /**< For callgraph analysis: list of callee calls */
- unsigned char *callee_isbe; /**< For callgraph analysis: set if backedge. */
+ unsigned *callee_isbe; /**< For callgraph analysis: raw bitset if backedge info calculated. */
int callgraph_loop_depth; /**< For callgraph analysis */
int callgraph_recursion_depth; /**< For callgraph analysis */
double method_execution_frequency; /**< For callgraph analysis */
int callgraph_loop_depth; /**< For callgraph analysis */
int callgraph_recursion_depth; /**< For callgraph analysis */
double method_execution_frequency; /**< For callgraph analysis */
double max_method_execution_frequency; /**< needed in callgraph. */
irp_temperature_state temperature_state; /**< accumulated temperatures computed? */
exec_freq_state execfreq_state; /**< The state of execution frequency information */
double max_method_execution_frequency; /**< needed in callgraph. */
irp_temperature_state temperature_state; /**< accumulated temperatures computed? */
exec_freq_state execfreq_state; /**< The state of execution frequency information */
-#ifdef INTERPROCEDURAL_VIEW
loop_nesting_depth_state lnd_state; /**< The state of loop nesting depth information. */
loop_nesting_depth_state lnd_state; /**< The state of loop nesting depth information. */
ir_class_cast_state class_cast_state; /**< The state of cast operations in code. */
ir_address_taken_computed_state globals_adr_taken_state; /**< Address taken state of the globals. */
ir_class_cast_state class_cast_state; /**< The state of cast operations in code. */
ir_address_taken_computed_state globals_adr_taken_state; /**< Address taken state of the globals. */