Skip to content

GitLab

Commit 1535324d authored by Michael Beck's avatar Michael Beck
Browse files

make backedge arrays raw bitsets 

[r16775]
parent 425aaf1d
Hide whitespace changes
Inline Side-by-side
ir/ana/irbackedge.c
View file @ 1535324d
......@@ -32,6 +32,7 @@
#include "irgraph_t.h"
#include "array.h"
#include "irbackedge_t.h"
#include "raw_bitset.h"
/*--------------------------------------------------------------------*/
/* Backedge information. */
......@@ -45,194 +46,187 @@
* Does not assert whether the backarray is correct -- use
* very careful!
*/
static INLINE int *mere_get_backarray(ir_node *n) {
switch (get_irn_opcode(n)) {
case iro_Block:
if (!get_Block_matured(n)) return NULL;
if (get_interprocedural_view() && n->attr.block.in_cg) {
assert(n->attr.block.cg_backedge && "backedge array not allocated!");
return n->attr.block.cg_backedge;
} else {
assert(n->attr.block.backedge && "backedge array not allocated!");
return n->attr.block.backedge;
}
break;
case iro_Phi:
assert(n->attr.phi_backedge && "backedge array not allocated!");
return n->attr.phi_backedge;
break;
case iro_Filter:
if (get_interprocedural_view()) {
assert(n->attr.filter.backedge && "backedge array not allocated!");
return n->attr.filter.backedge;
}
break;
default: ;
}
return NULL;
static unsigned *mere_get_backarray(ir_node *n) {
switch (get_irn_opcode(n)) {
case iro_Block:
if (!get_Block_matured(n)) return NULL;
if (get_interprocedural_view() && n->attr.block.in_cg) {
assert(n->attr.block.cg_backedge && "backedge array not allocated!");
return n->attr.block.cg_backedge;
} else {
assert(n->attr.block.backedge && "backedge array not allocated!");
return n->attr.block.backedge;
}
break;
case iro_Phi:
assert(n->attr.phi_backedge && "backedge array not allocated!");
return n->attr.phi_backedge;
break;
case iro_Filter:
if (get_interprocedural_view()) {
assert(n->attr.filter.backedge && "backedge array not allocated!");
return n->attr.filter.backedge;
}
break;
default: ;
}
return NULL;
}
/**
* Returns backarray if the node can have backedges, else returns
* NULL.
*/
static INLINE int *get_backarray(ir_node *n) {
int *ba = mere_get_backarray(n);
static unsigned *get_backarray(ir_node *n) {
unsigned *ba = mere_get_backarray(n);
#ifndef NDEBUG
if (ba) {
int bal = ARR_LEN(ba); /* avoid makro expansion in assertion. */
int inl = ARR_LEN(get_irn_in(n)) -1; /* Use get_irn_in -- sensitive to view! */
assert(bal == inl && "backedge array with faulty length");
}
if (ba) {
int bal = rbitset_size(ba); /* avoid macro expansion in assertion. */
int inl = get_irn_arity(n);
assert(bal == inl && "backedge array with faulty length");
}
#endif
return ba;
return ba;
}
/**
* Returns nin-zero if node has no backarray, or
* Returns non-zero if node has no backarray, or
* if size of backarray == size of in array.
*/
static INLINE int legal_backarray (ir_node *n) {
int *ba = mere_get_backarray(n);
if (ba && (ARR_LEN(ba) != ARR_LEN(get_irn_in(n))-1)) /* Use get_irn_in -- sensitive to view! */
return 0;
return 1;
static int legal_backarray(ir_node *n) {
unsigned *ba = mere_get_backarray(n);
if (ba && (rbitset_size(ba) != get_irn_arity(n)))
return 0;
return 1;
}
void fix_backedges(struct obstack *obst, ir_node *n) {
int *arr = mere_get_backarray(n);
ir_opcode opc;
if (! arr)
return;
if (ARR_LEN(arr) != ARR_LEN(get_irn_in(n))-1) {
arr = new_backedge_arr(obst, ARR_LEN(get_irn_in(n))-1);
opc = get_irn_opcode(n);
if (opc == iro_Phi)
n->attr.phi_backedge = arr;
else if (opc == iro_Block) {
if (!get_interprocedural_view())
n->attr.block.backedge = arr;
else
n->attr.block.cg_backedge = arr;
}
else if (opc == iro_Filter)
n->attr.filter.backedge = arr;
}
assert(legal_backarray(n));
/* @@@ more efficient in memory consumption, not possible with
array implementation.
if (ARR_LEN(arr) < ARR_LEN(get_irn_in(n))-1) {
ARR_SETLEN(int, arr, ARR_LEN(get_irn_in(n))-1);
}*/
unsigned *arr = mere_get_backarray(n);
ir_opcode opc;
int arity;
if (! arr)
return;
arity = get_irn_arity(n);
if (rbitset_size(arr) != arity) {
arr = new_backedge_arr(obst, arity);
opc = get_irn_opcode(n);
if (opc == iro_Phi)
n->attr.phi_backedge = arr;
else if (opc == iro_Block) {
if (!get_interprocedural_view())
n->attr.block.backedge = arr;
else
n->attr.block.cg_backedge = arr;
}
else if (opc == iro_Filter)
n->attr.filter.backedge = arr;
}
assert(legal_backarray(n));
}
#ifdef INTERPROCEDURAL_VIEW
int is_inter_backedge(ir_node *n, int pos) {
int res;
int rem = get_interprocedural_view();
set_interprocedural_view(0);
res = is_backedge(n, pos);
set_interprocedural_view(rem);
return res;
int res;
int rem = get_interprocedural_view();
set_interprocedural_view(0);
res = is_backedge(n, pos);
set_interprocedural_view(rem);
return res;
}
int is_intra_backedge(ir_node *n, int pos) {
int res;
int rem = get_interprocedural_view();
set_interprocedural_view(1);
res = is_backedge(n, pos);
set_interprocedural_view(rem);
return res;
int res;
int rem = get_interprocedural_view();
set_interprocedural_view(1);
res = is_backedge(n, pos);
set_interprocedural_view(rem);
return res;
}
#endif
/* Returns non-zero if the predecessor pos is a backedge. */
int is_backedge (ir_node *n, int pos) {
int *ba = get_backarray (n);
if (ba) return ba[pos];
return 0;
int is_backedge(ir_node *n, int pos) {
unsigned *ba = get_backarray(n);
if (ba)
return rbitset_is_set(ba, pos);
return 0;
}
/* Remarks that edge pos is a backedge. */
void set_backedge (ir_node *n, int pos) {
int *ba = get_backarray (n);
assert(ba && "can only set backedges at Phi, Filter, Block nodes.");
ba[pos] = 1;
void set_backedge(ir_node *n, int pos) {
unsigned *ba = get_backarray(n);
assert(ba && "can only set backedges at Phi, Filter, Block nodes.");
rbitset_set(ba, pos);
}
/* Remarks that edge pos is a backedge. */
void set_not_backedge (ir_node *n, int pos) {
int *ba = get_backarray (n);
assert(ba && "can only set backedges at Phi, Filter, Block nodes.");
ba[pos] = 0;
void set_not_backedge(ir_node *n, int pos) {
unsigned *ba = get_backarray(n);
assert(ba && "can only set backedges at Phi, Filter, Block nodes.");
rbitset_clear(ba, pos);
}
/* Returns non-zero if n has backedges. */
int has_backedges (ir_node *n) {
int i;
int *ba = get_backarray (n);
if (ba) {
int arity = get_irn_arity(n);
for (i = 0; i < arity; i++)
if (ba[i]) return 1;
}
return 0;
int has_backedges(ir_node *n) {
unsigned *ba = get_backarray(n);
if (ba) {
int arity = get_irn_arity(n);
return !rbitset_is_empty(ba, arity);
}
return 0;
}
/** Sets all backedge information to zero. */
void clear_backedges (ir_node *n) {
int i, arity;
int *ba;
void clear_backedges(ir_node *n) {
int i, arity;
unsigned *ba;
#ifdef INTERPROCEDURAL_VIEW
int rem = get_interprocedural_view();
set_interprocedural_view(0);
int rem = get_interprocedural_view();
set_interprocedural_view(0);
#endif
ba = get_backarray (n);
if (ba) {
arity = get_irn_arity(n);
for (i = 0; i < arity; i++)
ba[i] = 0;
}
ba = get_backarray(n);
if (ba) {
arity = get_irn_arity(n);
for (i = 0; i < arity; i++)
rbitset_clear(ba, i);
}
#ifdef INTERPROCEDURAL_VIEW
set_interprocedural_view(1);
ba = get_backarray (n);
if (ba) {
arity = get_irn_arity(n);
for (i = 0; i < arity; i++)
ba[i] = 0;
}
set_interprocedural_view(rem);
set_interprocedural_view(1);
ba = get_backarray (n);
if (ba) {
arity = get_irn_arity(n);
for (i = 0; i < arity; i++)
rbitset_clear(ba, i);
}
set_interprocedural_view(rem);
#endif
}
int *new_backedge_arr(struct obstack *obst, int size) {
int *res = NEW_ARR_D (int, obst, size);
memset(res, 0, sizeof(int) * size);
return res;
/* Allocate a new backedge array on the obstack for given size. */
unsigned *new_backedge_arr(struct obstack *obst, unsigned size) {
return rbitset_w_size_obstack_alloc(obst, size);
}
/* TODO: add an ir_op operation */
void new_backedge_info(ir_node *n) {
switch(get_irn_opcode(n)) {
case iro_Block:
n->attr.block.cg_backedge = NULL;
n->attr.block.backedge = new_backedge_arr(current_ir_graph->obst, get_irn_arity(n));
break;
case iro_Phi:
n->attr.phi_backedge = new_backedge_arr(current_ir_graph->obst, get_irn_arity(n));
break;
case iro_Filter:
n->attr.filter.backedge = new_backedge_arr(current_ir_graph->obst, get_irn_arity(n));
break;
default: ;
}
switch (get_irn_opcode(n)) {
case iro_Block:
n->attr.block.cg_backedge = NULL;
n->attr.block.backedge = new_backedge_arr(current_ir_graph->obst, get_irn_arity(n));
break;
case iro_Phi:
n->attr.phi_backedge = new_backedge_arr(current_ir_graph->obst, get_irn_arity(n));
break;
case iro_Filter:
n->attr.filter.backedge = new_backedge_arr(current_ir_graph->obst, get_irn_arity(n));
break;
default: ;
}
}
ir/ana/irbackedge_t.h
View file @ 1535324d
......@@ -29,11 +29,14 @@
/**
* Allocate a new backedge array on the obstack for given size.
*
* @param obst the obstack to allocate the array on
* @param size the size of the backedge array
*/
int *new_backedge_arr(struct obstack *obst, int size);
unsigned *new_backedge_arr(struct obstack *obst, unsigned size);
/**
* allocate new backedge info for nodes.
* Allocate new backedge info for nodes.
*/
void new_backedge_info(ir_node *n);
......
ir/ir/irtypes.h
View file @ 1535324d
......@@ -133,10 +133,8 @@ typedef struct {
ir_node ** in_cg; /**< array with predecessors in
* interprocedural_view, if they differ
* from intraprocedural predecessors */
int *backedge; /**< Field n set to true if pred n is backedge.
@@@ @todo Ev. replace by bit field! */
int *cg_backedge; /**< Field n set to true if pred n is interprocedural backedge.
@@@ @todo Ev. replace by bit field! */
unsigned *backedge; /**< Raw Bitfield n set to true if pred n is backedge.*/
unsigned *cg_backedge; /**< Raw Bitfield n set to true if pred n is interprocedural backedge. */
ir_extblk *extblk; /**< The extended basic block this block belongs to. */
ir_region *region; /**< The immediate structural region this block belongs to. */
unsigned mb_depth; /**< The macroblock depth: A distance from the macroblock header */
......@@ -209,9 +207,8 @@ typedef struct {
/** Filter attributes. */
typedef struct {
long proj; /**< contains the result position to project (Proj) */
ir_node ** in_cg; /**< array with interprocedural predecessors (Phi) */
int *backedge; /**< Field n set to true if pred n is backedge.
@todo Ev. replace by bitfield! */
ir_node **in_cg; /**< array with interprocedural predecessors (Phi) */
unsigned *backedge; /**< Raw Bitfield n set to true if pred n is backedge. */
} filter_attr;
/** CallBegin attributes. */
......@@ -301,9 +298,8 @@ typedef union {
load_attr load; /**< For Load. */
store_attr store; /**< For Store. */
phi0_attr phi0; /**< for Phi0 nodes. */
int *phi_backedge; /**< For Phi after construction.
Field n set to true if pred n is backedge.
@todo Ev. replace by bitfield! */
unsigned *phi_backedge; /**< For Phi after construction.
Raw Bitfield n set to true if pred n is backedge. */
long proj; /**< For Proj: contains the result position to project */
confirm_attr confirm; /**< For Confirm: compare operation and region. */
filter_attr filter; /**< For Filter */
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment

Imprint