*/
int is_region(const void *thing)
{
- const firm_kind *kind = thing;
+ const firm_kind *kind = (const firm_kind*) thing;
return *kind == k_ir_region;
}
ir_region *reg;
current_ir_graph = irg;
- reg = get_irn_link(get_irg_start_block(irg));
+ reg = (ir_region*) get_irn_link(get_irg_start_block(irg));
env->premax = 0;
env->postmax = 0;
*/
static void wrap_BasicBlocks(ir_node *block, void *ctx)
{
- walk_env *env = ctx;
+ walk_env *env = (walk_env*) ctx;
ir_region *reg;
/* Allocate a Block wrapper */
*/
static void update_BasicBlock_regions(ir_node *blk, void *ctx)
{
- walk_env *env = ctx;
- ir_region *reg = get_irn_link(blk);
+ walk_env *env = (walk_env*) ctx;
+ ir_region *reg = (ir_region*) get_irn_link(blk);
int i, j, len;
if (blk == env->start_block) {
reg->pred = NEW_ARR_D(ir_region *, env->obst, len);
for (i = j = 0; i < len; ++i) {
ir_node *pred = get_Block_cfgpred_block(blk, i);
- reg->pred[j++] = get_irn_link(pred);
+ reg->pred[j++] = (ir_region*) get_irn_link(pred);
}
ARR_SHRINKLEN(reg->pred, j);
}
reg->succ = NEW_ARR_D(ir_region *, env->obst, len);
for (i = j = 0; i < len; ++i) {
ir_node *succ = get_Block_cfg_out(blk, i);
- reg->succ[j++] = get_irn_link(succ);
+ reg->succ[j++] = (ir_region*) get_irn_link(succ);
}
ARR_SHRINKLEN(reg->succ, j);
} /* update_BasicBlock_regions */
nset = next;
reg->parts[i].region = nset;
nset->parent = reg;
- next = nset->link;
+ next = (ir_region*) nset->link;
nset->link = NULL;
}
int add = 1;
/* check, if the exit block is in the list */
- for (c = cases; c != NULL; c = c->link) {
+ for (c = cases; c != NULL; c = (ir_region*) c->link) {
if (c == exit) {
add = 0;
break;
reg->parts[0].region = head; head->parent = reg;
i = 1;
for (c = cases; c != NULL; c = n) {
- n = c->link;
+ n = (ir_region*) c->link;
if (c != exit) {
reg->parts[i++].region = c;
c->parent = reg;
static ir_region *new_WhileLoop(struct obstack *obst, ir_region *head)
{
ir_region *reg, *succ;
- ir_region *body = head->link;
+ ir_region *body = (ir_region*) head->link;
int i, j, len;
head->link = NULL;
int i, j, k, len, n_pred, n_succ;
/* count number of parts */
- for (len = 0, c = head; c != NULL; c = c->link)
+ for (len = 0, c = head; c != NULL; c = (ir_region*) c->link)
++len;
ALLOC_REG(obst, reg, ir_rk_WhileLoop);
for (i = 0, c = head; c != NULL; c = n) {
reg->parts[i++].region = c;
c->parent = reg;
- n = c->link;
+ n = (ir_region*) c->link;
c->link = NULL;
}
ir_region *prev = NULL, *next;
for (; n; n = next) {
- next = n->link;
+ next = (ir_region*) n->link;
n->link = prev;
prev = n;
}
}
}
/* reverse the list. */
- last = rem->link;
- rem->link = reverse_list(rem->link);
+ last = (ir_region*) rem->link;
+ rem->link = reverse_list((ir_region*) rem->link);
}
}
list = find_cyclic_region(node);
if (list->link) {
- if (!LINK(list)->link && get_region_n_succs(list->link) == 1) {
+ if (!LINK(list)->link && get_region_n_succs((ir_region*) list->link) == 1) {
/* only one body block with only one successor (the head) */
return new_WhileLoop(obst, list);
}
ir_region *next;
for (next = list; next; list = next) {
- next = list->link;
+ next = (ir_region*) list->link;
list->link = NULL;
}
}
ir_region *pos_exit_2 = NULL;
/* find the exit */
- for (m = nset; m != NULL; m = m->link) {
+ for (m = (ir_region*) nset; m != NULL; m = (ir_region*) m->link) {
if (get_region_n_succs(m) != 1) {
/* must be the exit block */
if (rexit == NULL) {
}
if (rexit != NULL) {
/* do the checks */
- for (n = nset; n != NULL; n = n->link) {
+ for (n = (ir_region*) nset; n != NULL; n = (ir_region*) n->link) {
ir_region *succ;
if (n == rexit) {
/* good, default fall through */