Commit f6b78c1b authored by Matthias Braun's avatar Matthias Braun
Browse files

rename ir_phase to ir_nodemap and simplify interface

The new interface uses no complicated callbacks anymore, but is a simple
ir_node* -> void* nodemap. Adapted all users of ir_phase for this.
parent 7dd67de2
......@@ -55,13 +55,6 @@ FIRM_API unsigned get_irn_height(const ir_heights_t *h, const ir_node *irn);
FIRM_API int heights_reachable_in_block(ir_heights_t *h, const ir_node *n,
const ir_node *m);
/**
* Recompute the height information.
* This can be used to recompute the height information if the graph has changed since the last computation.
* @param h The heights object.
*/
FIRM_API void heights_recompute(ir_heights_t *h);
/**
* Recompute the height information for a certain block.
* This can be used to recompute the height information of a block.
......
......@@ -40,11 +40,12 @@ enum range_types {
/** VRP information */
typedef struct {
int valid; /**< This node has valid vrp information */
ir_tarval *bits_set; /**< The bits which, by analysis, are definitely set.
0: may be not set, 1: definitely set*/
ir_tarval *bits_set; /**< The bits which, by analysis, are
definitely set:
0: may be not set, 1: definitely set */
ir_tarval *bits_not_set; /**< The bits which by analysis are definitely
not set, 1 for may be set, 0: definitely not set */
not set:
1 for may be set, 0: definitely not set */
enum range_types range_type; /**< The range represented by range_top, range_bottom */
ir_tarval *range_bottom;
ir_tarval *range_top;
......@@ -56,6 +57,11 @@ typedef struct {
*/
FIRM_API void set_vrp_data(ir_graph *irg);
/**
* free vrp infos in an irg
*/
FIRM_API void free_vrp_data(ir_graph *irg);
/**
* Test, if the two nodes can be compared with their vrp information
*
......@@ -67,9 +73,9 @@ FIRM_API ir_relation vrp_cmp(const ir_node *left, const ir_node *right);
/*
* Return the vrp data for this node
* Note: only allowed for nodes with an integer mode!
*
* @param n: the node for which to return the vrp information
*
* @return a pointer to the vrp data or NULL if there is none
*/
FIRM_API vrp_attr *vrp_get_info(const ir_node *n);
......
......@@ -36,13 +36,14 @@
#include "irdump.h"
#include "irgwalk.h"
#include "irtools.h"
#include "irphase_t.h"
#include "irnodemap.h"
#include "iredges_t.h"
struct ir_heights_t {
ir_phase phase;
unsigned visited;
void *dump_handle;
ir_nodemap data;
unsigned visited;
void *dump_handle;
struct obstack obst;
};
typedef struct {
......@@ -50,30 +51,29 @@ typedef struct {
unsigned visited;
} irn_height_t;
static void *irn_height_init(ir_phase *phase, const ir_node *node)
static irn_height_t *maybe_get_height_data(const ir_heights_t *heights,
const ir_node *node)
{
irn_height_t *h = (irn_height_t*) phase_alloc(phase, sizeof(*h));
(void) node;
memset(h, 0, sizeof(*h));
return h;
irn_height_t *height = (irn_height_t*)ir_nodemap_get(&heights->data, node);
return height;
}
static void *irn_height_reinit(ir_phase *phase, const ir_node *node,
void *old_data)
static irn_height_t *get_height_data(ir_heights_t *heights, const ir_node *node)
{
irn_height_t *h = (irn_height_t*) old_data;
(void) node;
(void) phase;
memset(h, 0, sizeof(*h));
return h;
irn_height_t *height = (irn_height_t*)ir_nodemap_get(&heights->data, node);
if (height == NULL) {
height = obstack_alloc(&heights->obst, sizeof(*height));
memset(height, 0, sizeof(*height));
ir_nodemap_insert(&heights->data, node, height);
}
return height;
}
static void height_dump_cb(void *data, FILE *f, const ir_node *irn)
{
ir_heights_t *heights = (ir_heights_t*) data;
irn_height_t *h = (irn_height_t*) phase_get_irn_data(&heights->phase, irn);
if (h)
const ir_heights_t *heights = (const ir_heights_t*) data;
const irn_height_t *h = maybe_get_height_data(heights, irn);
if (h != NULL)
fprintf(f, "height: %u\n", h->height);
}
......@@ -84,8 +84,7 @@ static void height_dump_cb(void *data, FILE *f, const ir_node *irn)
* @param tgt The node we try to reach.
* @return 1, one of tgt can be reached from curr, 0 else.
*/
static bool search(const ir_heights_t *h, const ir_node *curr,
const ir_node *tgt)
static bool search(ir_heights_t *h, const ir_node *curr, const ir_node *tgt)
{
irn_height_t *h_curr;
irn_height_t *h_tgt;
......@@ -102,12 +101,12 @@ static bool search(const ir_heights_t *h, const ir_node *curr,
return false;
/* Check, if we have already been here. Coming more often won't help :-) */
h_curr = (irn_height_t*) phase_get_irn_data(&h->phase, curr);
h_curr = get_height_data(h, curr);
if (h_curr->visited >= h->visited)
return false;
/* If we are too deep into the DAG we won't find the target either. */
h_tgt = (irn_height_t*) phase_get_irn_data(&h->phase, tgt);
h_tgt = get_height_data(h, tgt);
if (h_curr->height > h_tgt->height)
return false;
......@@ -132,8 +131,8 @@ int heights_reachable_in_block(ir_heights_t *h, const ir_node *n,
const ir_node *m)
{
int res = 0;
irn_height_t *hn = (irn_height_t*) phase_get_irn_data(&h->phase, n);
irn_height_t *hm = (irn_height_t*) phase_get_irn_data(&h->phase, m);
irn_height_t *hn = get_height_data(h, n);
irn_height_t *hm = get_height_data(h, m);
assert(get_nodes_block(n) == get_nodes_block(m));
assert(hn != NULL && hm != NULL);
......@@ -154,7 +153,7 @@ int heights_reachable_in_block(ir_heights_t *h, const ir_node *n,
*/
static unsigned compute_height(ir_heights_t *h, ir_node *irn, const ir_node *bl)
{
irn_height_t *ih = (irn_height_t*) phase_get_or_set_irn_data(&h->phase, irn);
irn_height_t *ih = get_height_data(h, irn);
const ir_edge_t *edge;
......@@ -223,21 +222,22 @@ static void compute_heights_in_block_walker(ir_node *block, void *data)
unsigned get_irn_height(const ir_heights_t *heights, const ir_node *irn)
{
const irn_height_t *h = (irn_height_t*) phase_get_irn_data(&heights->phase, irn);
assert(h && "No height information for node");
return h->height;
const irn_height_t *height = maybe_get_height_data(heights, irn);
assert(height != NULL && "No height information for node");
return height->height;
}
unsigned heights_recompute_block(ir_heights_t *h, ir_node *block)
{
ir_graph *irg = get_irn_irg(block);
const ir_edge_t *edge;
edges_assure(phase_get_irg(&h->phase));
edges_assure(irg);
/* reset phase data for all nodes in the block */
foreach_out_edge(block, edge) {
ir_node *irn = get_edge_src_irn(edge);
irn_height_t *ih = (irn_height_t*) phase_get_irn_data(&h->phase, irn);
irn_height_t *ih = get_height_data(h, irn);
memset(ih, 0, sizeof(*ih));
}
......@@ -245,29 +245,23 @@ unsigned heights_recompute_block(ir_heights_t *h, ir_node *block)
return compute_heights_in_block(block, h);
}
void heights_recompute(ir_heights_t *h)
{
ir_graph *irg = phase_get_irg(&h->phase);
edges_assure(irg);
phase_reinit_irn_data(&h->phase, irn_height_reinit);
h->visited = 0;
irg_block_walk_graph(irg, compute_heights_in_block_walker, NULL, h);
}
ir_heights_t *heights_new(ir_graph *irg)
{
ir_heights_t *res = XMALLOC(ir_heights_t);
phase_init(&res->phase, irg, irn_height_init);
ir_nodemap_init(&res->data, irg);
obstack_init(&res->obst);
res->dump_handle = dump_add_node_info_callback(height_dump_cb, res);
heights_recompute(res);
edges_assure(irg);
irg_block_walk_graph(irg, compute_heights_in_block_walker, NULL, res);
return res;
}
void heights_free(ir_heights_t *h)
{
phase_deinit(&h->phase);
dump_remove_node_info_callback(h->dump_handle);
obstack_free(&h->obst, NULL);
ir_nodemap_destroy(&h->data);
xfree(h);
}
......@@ -43,7 +43,7 @@
#include "irgraph_t.h"
#include "irnode_t.h"
#include "irphase_t.h"
#include "irnodemap.h"
#include "iredges_t.h"
#include "irprintf.h"
......@@ -73,29 +73,30 @@ typedef struct bl_info_t {
in the reduced graph. */
} bl_info_t;
#define get_block_info(lv, bl) ((bl_info_t *) phase_get_irn_data(&(lv)->ph, bl))
struct lv_chk_t {
ir_phase ph;
const dfs_t *dfs;
int n_blocks;
bitset_t *back_edge_src;
bitset_t *back_edge_tgt;
bl_info_t **map;
ir_nodemap block_infos;
struct obstack obst;
const dfs_t *dfs;
int n_blocks;
bitset_t *back_edge_src;
bitset_t *back_edge_tgt;
bl_info_t **map;
DEBUG_ONLY(firm_dbg_module_t *dbg;)
};
static void *init_block_data(ir_phase *ph, const ir_node *irn)
static bl_info_t *get_block_info(lv_chk_t *lv, const ir_node *block)
{
lv_chk_t *lv = firm_container_of(ph, lv_chk_t, ph);
bl_info_t *bi = (bl_info_t*) phase_alloc(ph, sizeof(bi[0]));
bi->id = get_Block_dom_tree_pre_num(irn);
bi->block = irn;
bi->red_reachable = bitset_obstack_alloc(phase_obst(ph), lv->n_blocks);
bi->be_tgt_reach = bitset_obstack_alloc(phase_obst(ph), lv->n_blocks);
bi->be_tgt_calc = 0;
return bi;
bl_info_t *info = ir_nodemap_get(&lv->block_infos, block);
if (info == NULL) {
info = obstack_alloc(&lv->obst, sizeof(*info));
info->id = get_Block_dom_tree_pre_num(block);
info->block = block;
info->red_reachable = bitset_obstack_alloc(&lv->obst, lv->n_blocks);
info->be_tgt_reach = bitset_obstack_alloc(&lv->obst, lv->n_blocks);
info->be_tgt_calc = 0;
ir_nodemap_insert(&lv->block_infos, block, info);
}
return info;
}
/**
......@@ -243,27 +244,26 @@ static inline void compute_back_edge_chains(lv_chk_t *lv)
lv_chk_t *lv_chk_new(ir_graph *irg, const dfs_t *dfs)
{
lv_chk_t *res = XMALLOC(lv_chk_t);
struct obstack *obst;
int i;
assure_doms(irg);
stat_ev_tim_push();
phase_init(&res->ph, irg, init_block_data);
obst = phase_obst(&res->ph);
ir_nodemap_init(&res->block_infos, irg);
obstack_init(&res->obst);
FIRM_DBG_REGISTER(res->dbg, "ir.ana.lvchk");
res->dfs = dfs;
res->n_blocks = dfs_get_n_nodes(res->dfs);
res->back_edge_src = bitset_obstack_alloc(obst, res->n_blocks);
res->back_edge_tgt = bitset_obstack_alloc(obst, res->n_blocks);
res->map = OALLOCNZ(obst, bl_info_t*, res->n_blocks);
res->back_edge_src = bitset_obstack_alloc(&res->obst, res->n_blocks);
res->back_edge_tgt = bitset_obstack_alloc(&res->obst, res->n_blocks);
res->map = OALLOCNZ(&res->obst, bl_info_t*, res->n_blocks);
/* fill the map which maps pre_num to block infos */
for (i = res->n_blocks - 1; i >= 0; --i) {
ir_node *irn = (ir_node *) dfs_get_pre_num_node(res->dfs, i);
bl_info_t *bi = (bl_info_t*) phase_get_or_set_irn_data(&res->ph, irn);
bl_info_t *bi = get_block_info(res, irn);
assert(bi->id < res->n_blocks);
assert(res->map[bi->id] == NULL);
res->map[bi->id] = bi;
......@@ -295,7 +295,8 @@ lv_chk_t *lv_chk_new(ir_graph *irg, const dfs_t *dfs)
void lv_chk_free(lv_chk_t *lv)
{
phase_deinit(&lv->ph);
obstack_free(&lv->obst, NULL);
ir_nodemap_destroy(&lv->block_infos);
xfree(lv);
}
......@@ -308,7 +309,7 @@ void lv_chk_free(lv_chk_t *lv)
* @param var The node to check for.
* @return A bitmask of lv_chk_state_XXX fields.
*/
unsigned lv_chk_bl_xxx(const lv_chk_t *lv, const ir_node *bl, const ir_node *var)
unsigned lv_chk_bl_xxx(lv_chk_t *lv, const ir_node *bl, const ir_node *var)
{
int res = 0;
ir_node *def_bl;
......
......@@ -67,7 +67,7 @@ extern void lv_chk_free(lv_chk_t *lv);
* @param irn The node to check for.
* @return A bitmask of <code>lv_chk_state_t</code>.
*/
extern unsigned lv_chk_bl_xxx(const lv_chk_t *lv, const ir_node *bl, const ir_node *irn);
extern unsigned lv_chk_bl_xxx(lv_chk_t *lv, const ir_node *bl, const ir_node *irn);
#define lv_chk_bl_in(lv, bl, irn) ((lv_chk_bl_xxx((lv), (bl), (irn)) & lv_chk_state_in) != 0)
#define lv_chk_bl_end(lv, bl, irn) ((lv_chk_bl_xxx((lv), (bl), (irn)) & lv_chk_state_end) != 0)
......
......@@ -37,23 +37,47 @@
#include "tv.h"
#include "irop.h"
#include "pdeq.h"
#include "irphase_t.h"
#include "irnodemap.h"
#include "bitset.h"
#include "debug.h"
DEBUG_ONLY(static firm_dbg_module_t *dbg;)
typedef struct vrp_env_t {
waitq *workqueue;
bitset_t *visited;
waitq *workqueue;
bitset_t *visited;
ir_vrp_info *info;
} vrp_env_t;
static vrp_attr *get_vrp_attr(const ir_node *node)
static vrp_attr *vrp_get_or_set_info(ir_vrp_info *info, const ir_node *node)
{
return (vrp_attr*) get_or_set_irn_phase_info(node, PHASE_VRP);
vrp_attr *attr = ir_nodemap_get(&info->infos, node);
if (attr == NULL) {
ir_mode *mode = get_irn_mode(node);
assert(mode_is_int(mode));
attr = obstack_alloc(&info->obst, sizeof(*attr));
memset(attr, 0, sizeof(*attr));
attr->range_type = VRP_UNDEFINED;
attr->bits_set = get_mode_null(mode);
attr->bits_not_set = get_mode_all_one(mode);
attr->range_bottom = get_tarval_top();
attr->range_top = get_tarval_top();
ir_nodemap_insert(&info->infos, node, attr);
}
return attr;
}
vrp_attr *vrp_get_info(const ir_node *node)
{
ir_graph *irg = get_irn_irg(node);
if (irg->vrp.infos.data == NULL)
return NULL;
return (vrp_attr*) ir_nodemap_get(&irg->vrp.infos, node);
}
static int vrp_update_node(ir_node *node)
static int vrp_update_node(ir_vrp_info *info, ir_node *node)
{
ir_tarval *new_bits_set = get_tarval_bad();
ir_tarval *new_bits_not_set = get_tarval_bad();
......@@ -67,7 +91,7 @@ static int vrp_update_node(ir_node *node)
return 0; /* we don't optimize for non-int-nodes*/
}
vrp = get_vrp_attr(node);
vrp = vrp_get_or_set_info(info, node);
/* TODO: Check if all predecessors have valid VRP information*/
......@@ -87,8 +111,8 @@ static int vrp_update_node(ir_node *node)
left = get_And_left(node);
right = get_And_right(node);
vrp_left = get_vrp_attr(left);
vrp_right = get_vrp_attr(right);
vrp_left = vrp_get_or_set_info(info, left);
vrp_right = vrp_get_or_set_info(info, right);
new_bits_set = tarval_and(vrp_left->bits_set, vrp_right->bits_set);
new_bits_not_set = tarval_and(vrp_left->bits_not_set, vrp_right->bits_not_set);
......@@ -99,8 +123,8 @@ static int vrp_update_node(ir_node *node)
int overflow_top, overflow_bottom;
ir_tarval *new_top, *new_bottom;
const vrp_attr *vrp_left, *vrp_right;
vrp_left = get_vrp_attr(get_Add_left(node));
vrp_right = get_vrp_attr(get_Add_right(node));
vrp_left = vrp_get_or_set_info(info, get_Add_left(node));
vrp_right = vrp_get_or_set_info(info, get_Add_right(node));
if (vrp_left->range_type == VRP_UNDEFINED || vrp_right->range_type ==
VRP_UNDEFINED || vrp_left->range_type == VRP_VARYING ||
......@@ -128,11 +152,17 @@ static int vrp_update_node(ir_node *node)
}
case iro_Sub: {
ir_node *left = get_Sub_left(node);
ir_node *right = get_Sub_right(node);
int overflow_top, overflow_bottom;
ir_tarval *new_top, *new_bottom;
const vrp_attr *vrp_left, *vrp_right;
vrp_left = get_vrp_attr(get_Sub_left(node));
vrp_right = get_vrp_attr(get_Sub_right(node));
if (!mode_is_int(get_irn_mode(left)))
return 0;
vrp_left = vrp_get_or_set_info(info, left);
vrp_right = vrp_get_or_set_info(info, right);
if (vrp_left->range_type == VRP_UNDEFINED || vrp_right->range_type ==
VRP_UNDEFINED || vrp_left->range_type == VRP_VARYING ||
......@@ -161,8 +191,8 @@ static int vrp_update_node(ir_node *node)
case iro_Or: {
const vrp_attr *vrp_left, *vrp_right;
vrp_left = get_vrp_attr(get_Or_left(node));
vrp_right = get_vrp_attr(get_Or_right(node));
vrp_left = vrp_get_or_set_info(info, get_Or_left(node));
vrp_right = vrp_get_or_set_info(info, get_Or_right(node));
new_bits_set = tarval_or(vrp_left->bits_set, vrp_right->bits_set);
new_bits_not_set = tarval_or(vrp_left->bits_not_set, vrp_right->bits_not_set);
......@@ -174,7 +204,7 @@ static int vrp_update_node(ir_node *node)
const vrp_attr *vrp_left;
const ir_node *right = get_Rotl_right(node);
vrp_left = get_vrp_attr(get_Rotl_left(node));
vrp_left = vrp_get_or_set_info(info, get_Rotl_left(node));
/* We can only compute this if the right value is a constant*/
if (is_Const(right)) {
......@@ -187,7 +217,7 @@ static int vrp_update_node(ir_node *node)
case iro_Shl: {
const vrp_attr *vrp_left;
const ir_node *right = get_Shl_right(node);
vrp_left = get_vrp_attr(get_Shl_left(node));
vrp_left = vrp_get_or_set_info(info, get_Shl_left(node));
/* We can only compute this if the right value is a constant*/
if (is_Const(right)) {
......@@ -201,7 +231,7 @@ static int vrp_update_node(ir_node *node)
const vrp_attr *vrp_left;
const ir_node *right = get_Shr_right(node);
vrp_left = get_vrp_attr(get_Shr_left(node));
vrp_left = vrp_get_or_set_info(info, get_Shr_left(node));
/* We can only compute this if the right value is a constant*/
if (is_Const(right)) {
......@@ -215,7 +245,7 @@ static int vrp_update_node(ir_node *node)
const vrp_attr *vrp_left;
const ir_node *right = get_Shrs_right(node);
vrp_left = get_vrp_attr(get_Shrs_left(node));
vrp_left = vrp_get_or_set_info(info, get_Shrs_left(node));
/* We can only compute this if the right value is a constant*/
if (is_Const(right)) {
......@@ -228,8 +258,8 @@ static int vrp_update_node(ir_node *node)
case iro_Eor: {
const vrp_attr *vrp_left, *vrp_right;
vrp_left = get_vrp_attr(get_Eor_left(node));
vrp_right = get_vrp_attr(get_Eor_right(node));
vrp_left = vrp_get_or_set_info(info, get_Eor_left(node));
vrp_right = vrp_get_or_set_info(info, get_Eor_right(node));
new_bits_set = tarval_or(
tarval_and(vrp_left->bits_set, tarval_not(vrp_right->bits_not_set)),
......@@ -244,7 +274,7 @@ static int vrp_update_node(ir_node *node)
}
case iro_Id: {
const vrp_attr *vrp_pred = get_vrp_attr(get_Id_pred(node));
const vrp_attr *vrp_pred = vrp_get_or_set_info(info, get_Id_pred(node));
new_bits_set = vrp_pred->bits_set;
new_bits_not_set = vrp_pred->bits_not_set;
new_range_top = vrp_pred->range_top;
......@@ -254,7 +284,7 @@ static int vrp_update_node(ir_node *node)
}
case iro_Not: {
const vrp_attr *vrp_pred = get_vrp_attr(get_Not_op(node));
const vrp_attr *vrp_pred = vrp_get_or_set_info(info, get_Not_op(node));
new_bits_set = tarval_not(vrp_pred->bits_not_set);
new_bits_not_set = tarval_not(vrp_pred->bits_set);
break;
......@@ -263,13 +293,14 @@ static int vrp_update_node(ir_node *node)
case iro_Conv: {
const ir_node *pred = get_Conv_op(node);
ir_mode *old_mode = get_irn_mode(pred);
const vrp_attr *vrp_pred = get_vrp_attr(pred);
const vrp_attr *vrp_pred;
ir_mode *new_mode;
if (!mode_is_int(old_mode))
return 0;
vrp_pred = vrp_get_or_set_info(info, pred);
new_mode = get_irn_mode(node);
/* The second and is needed if target type is smaller*/
......@@ -320,7 +351,7 @@ static int vrp_update_node(ir_node *node)
int i;
const ir_node *pred = get_Phi_pred(node,0);
const vrp_attr *vrp_pred = get_vrp_attr(pred);
const vrp_attr *vrp_pred = vrp_get_or_set_info(info, pred);
new_range_top = vrp_pred->range_top;
new_range_bottom = vrp_pred->range_bottom;
new_range_type = vrp_pred->range_type;
......@@ -331,7 +362,7 @@ static int vrp_update_node(ir_node *node)
for (i = 1; i < num; i++) {
pred = get_Phi_pred(node, i);
vrp_pred = get_vrp_attr(pred);
vrp_pred = vrp_get_or_set_info(info, pred);
if (new_range_type == VRP_RANGE && vrp_pred->range_type ==
VRP_RANGE) {
relation = tarval_cmp(new_range_top, vrp_pred->range_top);
......@@ -482,7 +513,7 @@ static void vrp_first_pass(ir_node *n, void *e)
bitset_set(env->visited, get_irn_idx(n));
vrp_update_node(n);
vrp_update_node(env->info, n);
assure_irg_outs(get_current_ir_graph());
for (i = get_irn_n_outs(n) - 1; i >=0; --i) {
......@@ -494,70 +525,26 @@ static void vrp_first_pass(ir_node *n, void *e)
}
}
static void *vrp_init_node(ir_phase *phase, const ir_node *n)
{
ir_mode *mode;
vrp_attr *vrp;
DBG((dbg, LEVEL_2, "initialized node nr: %d\n", get_irn_node_nr(n)));
vrp = (vrp_attr*) phase_alloc(phase, sizeof(vrp_attr));
memset(vrp, 0, sizeof(vrp_attr));
/* Initialize the vrp information to default */
mode = get_irn_mode(n);
vrp->range_type = VRP_UNDEFINED;
/* TODO: We might be able to optimize space usage if we do not allocate
* vrp space for non-int nodes. (currently caught by vrp_update_node)
*/
if (mode_is_int(mode)) {
/* We are assuming that 0 is always represented as this modes null */
vrp->valid = 1;
vrp->bits_set = get_mode_null(mode);
vrp->bits_not_set = get_mode_all_one(mode);
vrp->range_bottom = get_tarval_top();
vrp->range_top = get_tarval_top();
} else {
vrp->valid = 0;
vrp->bits_set = get_tarval_bad();
vrp->bits_not_set = get_tarval_bad();
vrp->range_bottom = get_tarval_bad();
vrp->range_top = get_tarval_bad();
}
/* TODO: We might be able to set better vrp info at this time, if this is
* a node which is newly created in an already initialized irg
*
* maybe just call vrp_update_node and if it returns one, iterate over
* successors
*/
return vrp;
}
void set_vrp_data(ir_graph *irg)
{
ir_node *succ, *node;
int i;
vrp_env_t *env;
ir_phase *phase;
ir_vrp_info *info;
if (irg->vrp.infos.data != NULL)
free_vrp_data(irg);