/*
- * Copyright (C) 1995-2007 University of Karlsruhe. All right reserved.
+ * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved.
*
* This file is part of libFirm.
*
#endif
#include "irnode_t.h"
-#include "irgraph_t.h" /* visited flag */
+#include "irgraph_t.h"
#include "irprog.h"
#include "irgwalk.h"
#include "irhooks.h"
#include "ircgcons.h"
+#include "entity_t.h"
+#include "error.h"
#include "pset_new.h"
#include "array.h"
{
assert(is_ir_node(node));
+#ifdef INTERPROCEDURAL_VIEW
if (get_interprocedural_view()) {
pset_new_t irg_set;
pset_new_iterator_t iter;
irg_walk_cg(node, visited, &irg_set, pre, post, env);
pset_new_destroy(&irg_set);
} else {
- set_using_visited(current_ir_graph);
+#endif
+ set_using_irn_visited(current_ir_graph);
inc_irg_visited(current_ir_graph);
nodes_touched = irg_walk_2(node, pre, post, env);
- clear_using_visited(current_ir_graph);
+ clear_using_irn_visited(current_ir_graph);
+#ifdef INTERPROCEDURAL_VIEW
}
+#endif
return;
}
if (get_interprocedural_view()) {
assert(0 && "This is not yet implemented.");
} else {
- set_using_visited(current_ir_graph);
+ set_using_irn_visited(current_ir_graph);
inc_irg_visited(current_ir_graph);
nodes_touched = irg_walk_in_or_dep_2(node, pre, post, env);
- clear_using_visited(current_ir_graph);
+ clear_using_irn_visited(current_ir_graph);
}
return;
}
return;
}
-
+#ifdef INTERPROCEDURAL_VIEW
/* Walks all irgs in interprocedural view. Visits each node only once. */
void cg_walk(irg_walk_func *pre, irg_walk_func *post, void *env) {
int i;
set_interprocedural_view(rem_view);
current_ir_graph = rem;
}
+#endif
/***************************************************************************/
/* Walks back from n until it finds a real cf op. */
static ir_node *get_cf_op(ir_node *n) {
- ir_node *pred;
-
- n = skip_Id(n);
- n = skip_Tuple(n);
- pred = skip_Proj(n);
- if (!(is_cfop(pred) || is_fragile_op(pred) || is_Bad(pred)))
- n = get_cf_op(n);
-
- return skip_Proj(n);
+ while (!is_cfop(n) && !is_fragile_op(n) && !is_Bad(n)) {
+ n = skip_Id(n);
+ n = skip_Tuple(n);
+ n = skip_Proj(n);
+ }
+ return n;
}
static void irg_block_walk_2(ir_node *node, irg_walk_func *pre, irg_walk_func *post, void *env)
* Additionally walk over all anchors. Do NOT increase the visit flag.
*/
void irg_walk_anchors(ir_graph *irg, irg_walk_func *pre, irg_walk_func *post, void *env) {
- int i;
ir_graph * rem = current_ir_graph;
current_ir_graph = irg;
- for (i = 0; i < anchor_max; ++i) {
- ir_node *anchor = irg->anchors[i];
+ inc_irg_visited(irg);
+ irg_walk_2(irg->anchor, pre, post, env);
- irg_walk_2(anchor, pre, post, env);
- }
current_ir_graph = rem;
}
void *env;
} walk_env;
+static void walk_initializer(ir_initializer_t *initializer, walk_env *env)
+{
+ switch(initializer->kind) {
+ case IR_INITIALIZER_CONST:
+ irg_walk(initializer->consti.value, env->pre, env->post, env->env);
+ return;
+ case IR_INITIALIZER_TARVAL:
+ case IR_INITIALIZER_NULL:
+ return;
+
+ case IR_INITIALIZER_COMPOUND: {
+ size_t i;
+ for(i = 0; i < initializer->compound.n_initializers; ++i) {
+ ir_initializer_t *subinitializer
+ = initializer->compound.initializers[i];
+ walk_initializer(subinitializer, env);
+ }
+ return;
+ }
+ }
+ panic("invalid initializer found");
+}
+
/**
* Walk to all constant expressions in this entity.
*/
walk_env *my_env = (walk_env *)env;
if (get_entity_variability(ent) != variability_uninitialized) {
- if (is_atomic_entity(ent)) {
+ if (ent->has_initializer) {
+ walk_initializer(ent->attr.initializer, my_env);
+ } else if (is_atomic_entity(ent)) {
irg_walk(get_atomic_ent_value(ent), my_env->pre, my_env->post, my_env->env);
} else {
int i, n_vals = get_compound_ent_n_values(ent);
/* Walks over all code in const_code_irg. */
void walk_const_code(irg_walk_func *pre, irg_walk_func *post, void *env) {
- int i, j;
+ int i, j, n_types;
walk_env my_env;
ir_graph *rem = current_ir_graph;
/* Walk all types that can contain constant entities. */
walk_types_entities(get_glob_type(), &walk_entity, &my_env);
- for (i = 0; i < get_irp_n_types(); i++)
+ n_types = get_irp_n_types();
+ for (i = 0; i < n_types; i++)
walk_types_entities(get_irp_type(i), &walk_entity, &my_env);
for (i = 0; i < get_irp_n_irgs(); i++)
walk_types_entities(get_irg_frame_type(get_irp_irg(i)), &walk_entity, &my_env);
/* Walk constant array bounds. */
- for (i = 0; i < get_irp_n_types(); i++) {
+ for (i = 0; i < n_types; i++) {
ir_type *tp = get_irp_type(i);
if (is_Array_type(tp)) {
- for (j = 0; j < get_array_n_dimensions(tp); j++) {
+ int n_dim = get_array_n_dimensions(tp);
+ for (j = 0; j < n_dim; j++) {
ir_node *n = get_array_lower_bound(tp, j);
if (n) irg_walk(n, pre, post, env);
n = get_array_upper_bound(tp, j);
projects / libfirm / blobdiff