}
-void
-init_irnode(void) {
+void init_irnode(void) {
/* Forbid the addition of new data to an ir node. */
forbid_new_data = 1;
}
if (arity < 0) {
res->in = NEW_ARR_F(ir_node *, 1); /* 1: space for block */
} else {
- res->in = NEW_ARR_D(ir_node *, irg->obst, (arity+1));
+ /* not nice but necessary: End must always have a flexible array */
+ if (op == op_End)
+ res->in = NEW_ARR_F(ir_node *, (arity+1));
+ else
+ res->in = NEW_ARR_D(ir_node *, irg->obst, (arity+1));
memcpy(&res->in[1], in, sizeof(ir_node *) * arity);
}
/*-- getting some parameters from ir_nodes --*/
-int
-(is_ir_node)(const void *thing) {
+int (is_ir_node)(const void *thing) {
return _is_ir_node(thing);
}
-int
-(get_irn_intra_arity)(const ir_node *node) {
+int (get_irn_intra_arity)(const ir_node *node) {
return _get_irn_intra_arity(node);
}
-int
-(get_irn_inter_arity)(const ir_node *node) {
+int (get_irn_inter_arity)(const ir_node *node) {
return _get_irn_inter_arity(node);
}
int (*_get_irn_arity)(const ir_node *node) = _get_irn_intra_arity;
-int
-(get_irn_arity)(const ir_node *node) {
+int (get_irn_arity)(const ir_node *node) {
return _get_irn_arity(node);
}
The order of the predecessors in this array is not guaranteed, except that
lists of operands as predecessors of Block or arguments of a Call are
consecutive. */
-ir_node **
-get_irn_in(const ir_node *node) {
+ir_node **get_irn_in(const ir_node *node) {
assert(node);
if (get_interprocedural_view()) { /* handle Filter and Block specially */
if (get_irn_opcode(node) == iro_Filter) {
return node->in;
}
-void
-set_irn_in(ir_node *node, int arity, ir_node **in) {
+void set_irn_in(ir_node *node, int arity, ir_node **in) {
int i;
- ir_node *** arr;
+ ir_node *** pOld_in;
ir_graph *irg = current_ir_graph;
assert(node);
if (get_interprocedural_view()) { /* handle Filter and Block specially */
- if (get_irn_opcode(node) == iro_Filter) {
+ ir_opcode code = get_irn_opcode(node);
+ if (code == iro_Filter) {
assert(node->attr.filter.in_cg);
- arr = &node->attr.filter.in_cg;
- } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) {
- arr = &node->attr.block.in_cg;
+ pOld_in = &node->attr.filter.in_cg;
+ } else if (code == iro_Block && node->attr.block.in_cg) {
+ pOld_in = &node->attr.block.in_cg;
} else {
- arr = &node->in;
+ pOld_in = &node->in;
}
} else {
- arr = &node->in;
+ pOld_in = &node->in;
}
for (i = 0; i < arity; i++) {
- if (i < ARR_LEN(*arr)-1)
- edges_notify_edge(node, i, in[i], (*arr)[i+1], irg);
+ if (i < ARR_LEN(*pOld_in)-1)
+ edges_notify_edge(node, i, in[i], (*pOld_in)[i+1], irg);
else
- edges_notify_edge(node, i, in[i], NULL, irg);
+ edges_notify_edge(node, i, in[i], NULL, irg);
}
- for(;i < ARR_LEN(*arr)-1; i++) {
- edges_notify_edge(node, i, NULL, (*arr)[i+1], irg);
+ for (;i < ARR_LEN(*pOld_in)-1; i++) {
+ edges_notify_edge(node, i, NULL, (*pOld_in)[i+1], irg);
}
- if (arity != ARR_LEN(*arr) - 1) {
- ir_node * block = (*arr)[0];
- *arr = NEW_ARR_D(ir_node *, irg->obst, arity + 1);
- (*arr)[0] = block;
+ if (arity != ARR_LEN(*pOld_in) - 1) {
+ ir_node * block = (*pOld_in)[0];
+ *pOld_in = NEW_ARR_D(ir_node *, irg->obst, arity + 1);
+ (*pOld_in)[0] = block;
}
fix_backedges(irg->obst, node);
- memcpy((*arr) + 1, in, sizeof(ir_node *) * arity);
+ memcpy((*pOld_in) + 1, in, sizeof(ir_node *) * arity);
}
-ir_node *
-(get_irn_intra_n)(const ir_node *node, int n) {
+ir_node *(get_irn_intra_n)(const ir_node *node, int n) {
return _get_irn_intra_n (node, n);
}
-ir_node *
-(get_irn_inter_n)(const ir_node *node, int n) {
+ir_node *(get_irn_inter_n)(const ir_node *node, int n) {
return _get_irn_inter_n (node, n);
}
ir_node *(*_get_irn_n)(const ir_node *node, int n) = _get_irn_intra_n;
-ir_node *
-(get_irn_n)(const ir_node *node, int n) {
+ir_node *(get_irn_n)(const ir_node *node, int n) {
return _get_irn_n(node, n);
}
-void
-set_irn_n (ir_node *node, int n, ir_node *in) {
+void set_irn_n(ir_node *node, int n, ir_node *in) {
assert(node && node->kind == k_ir_node);
assert(-1 <= n);
assert(n < get_irn_arity(node));
node->in[n + 1] = in;
}
-int add_irn_n(ir_node *node, ir_node *in)
-{
+int add_irn_n(ir_node *node, ir_node *in) {
int pos;
ir_graph *irg = get_irn_irg(node);
return pos;
}
-int
-(get_irn_deps)(const ir_node *node)
-{
+int (get_irn_deps)(const ir_node *node) {
return _get_irn_deps(node);
}
-ir_node *
-(get_irn_dep)(const ir_node *node, int pos)
-{
+ir_node *(get_irn_dep)(const ir_node *node, int pos) {
return _get_irn_dep(node, pos);
}
-void
-(set_irn_dep)(ir_node *node, int pos, ir_node *dep)
-{
+void (set_irn_dep)(ir_node *node, int pos, ir_node *dep) {
_set_irn_dep(node, pos, dep);
}
-int add_irn_dep(ir_node *node, ir_node *dep)
-{
+int add_irn_dep(ir_node *node, ir_node *dep) {
int res = 0;
if (node->deps == NULL) {
}
-ir_mode *
-(get_irn_mode)(const ir_node *node) {
+ir_mode *(get_irn_mode)(const ir_node *node) {
return _get_irn_mode(node);
}
-void
-(set_irn_mode)(ir_node *node, ir_mode *mode) {
+void (set_irn_mode)(ir_node *node, ir_mode *mode) {
_set_irn_mode(node, mode);
}
-modecode
-get_irn_modecode(const ir_node *node) {
+modecode get_irn_modecode(const ir_node *node) {
assert(node);
return node->mode->code;
}
/** Gets the string representation of the mode .*/
-const char *
-get_irn_modename(const ir_node *node) {
+const char *get_irn_modename(const ir_node *node) {
assert(node);
return get_mode_name(node->mode);
}
-ident *
-get_irn_modeident(const ir_node *node) {
+ident *get_irn_modeident(const ir_node *node) {
assert(node);
return get_mode_ident(node->mode);
}
-ir_op *
-(get_irn_op)(const ir_node *node) {
+ir_op *(get_irn_op)(const ir_node *node) {
return _get_irn_op(node);
}
/* should be private to the library: */
-void
-(set_irn_op)(ir_node *node, ir_op *op) {
+void (set_irn_op)(ir_node *node, ir_op *op) {
_set_irn_op(node, op);
}
-unsigned
-(get_irn_opcode)(const ir_node *node) {
+unsigned (get_irn_opcode)(const ir_node *node) {
return _get_irn_opcode(node);
}
-const char *
-get_irn_opname(const ir_node *node) {
+const char *get_irn_opname(const ir_node *node) {
assert(node);
if (is_Phi0(node)) return "Phi0";
return get_id_str(node->op->name);
}
-ident *
-get_irn_opident(const ir_node *node) {
+ident *get_irn_opident(const ir_node *node) {
assert(node);
return node->op->name;
}
-unsigned long
-(get_irn_visited)(const ir_node *node) {
+unsigned long (get_irn_visited)(const ir_node *node) {
return _get_irn_visited(node);
}
-void
-(set_irn_visited)(ir_node *node, unsigned long visited) {
+void (set_irn_visited)(ir_node *node, unsigned long visited) {
_set_irn_visited(node, visited);
}
-void
-(mark_irn_visited)(ir_node *node) {
+void (mark_irn_visited)(ir_node *node) {
_mark_irn_visited(node);
}
-int
-(irn_not_visited)(const ir_node *node) {
+int (irn_not_visited)(const ir_node *node) {
return _irn_not_visited(node);
}
-int
-(irn_visited)(const ir_node *node) {
+int (irn_visited)(const ir_node *node) {
return _irn_visited(node);
}
-void
-(set_irn_link)(ir_node *node, void *link) {
+void (set_irn_link)(ir_node *node, void *link) {
_set_irn_link(node, link);
}
-void *
-(get_irn_link)(const ir_node *node) {
+void *(get_irn_link)(const ir_node *node) {
return _get_irn_link(node);
}
-op_pin_state
-(get_irn_pinned)(const ir_node *node) {
+op_pin_state (get_irn_pinned)(const ir_node *node) {
return _get_irn_pinned(node);
}
-op_pin_state
-(is_irn_pinned_in_irg) (const ir_node *node) {
+op_pin_state (is_irn_pinned_in_irg) (const ir_node *node) {
return _is_irn_pinned_in_irg(node);
}
#endif
}
-const_attr *
-get_irn_const_attr(ir_node *node) {
+const_attr *get_irn_const_attr(ir_node *node) {
assert(node->op == op_Const);
return &node->attr.con;
}
-long
-get_irn_proj_attr(ir_node *node) {
+long get_irn_proj_attr(ir_node *node) {
assert(node->op == op_Proj);
return node->attr.proj;
}
-alloc_attr *
-get_irn_alloc_attr(ir_node *node) {
+alloc_attr *get_irn_alloc_attr(ir_node *node) {
assert(node->op == op_Alloc);
return &node->attr.alloc;
}
-free_attr *
-get_irn_free_attr(ir_node *node) {
+free_attr *get_irn_free_attr(ir_node *node) {
assert(node->op == op_Free);
return &node->attr.free;
}
-symconst_attr *
-get_irn_symconst_attr(ir_node *node) {
+symconst_attr *get_irn_symconst_attr(ir_node *node) {
assert(node->op == op_SymConst);
return &node->attr.symc;
}
-ir_type *
-get_irn_call_attr(ir_node *node) {
+ir_type *get_irn_call_attr(ir_node *node) {
assert(node->op == op_Call);
return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
}
-sel_attr *
-get_irn_sel_attr(ir_node *node) {
+sel_attr *get_irn_sel_attr(ir_node *node) {
assert(node->op == op_Sel);
return &node->attr.sel;
}
-int
-get_irn_phi0_attr(ir_node *node) {
- assert(is_Phi0(node));
- return node->attr.phi0.pos;
+phi_attr *get_irn_phi_attr(ir_node *node) {
+ return &node->attr.phi;
}
-block_attr *
-get_irn_block_attr(ir_node *node) {
+block_attr *get_irn_block_attr(ir_node *node) {
assert(node->op == op_Block);
return &node->attr.block;
}
-load_attr *
-get_irn_load_attr(ir_node *node) {
+load_attr *get_irn_load_attr(ir_node *node) {
assert(node->op == op_Load);
return &node->attr.load;
}
-store_attr *
-get_irn_store_attr(ir_node *node) {
+store_attr *get_irn_store_attr(ir_node *node) {
assert(node->op == op_Store);
return &node->attr.store;
}
-except_attr *
-get_irn_except_attr(ir_node *node) {
+except_attr *get_irn_except_attr(ir_node *node) {
assert(node->op == op_Div || node->op == op_Quot ||
- node->op == op_DivMod || node->op == op_Mod || node->op == op_Call || node->op == op_Alloc);
+ node->op == op_DivMod || node->op == op_Mod || node->op == op_Call || node->op == op_Alloc || node->op == op_Bound);
return &node->attr.except;
}
+divmod_attr *get_irn_divmod_attr(ir_node *node) {
+ assert(node->op == op_Div || node->op == op_Quot ||
+ node->op == op_DivMod || node->op == op_Mod);
+ return &node->attr.divmod;
+}
+
void *(get_irn_generic_attr)(ir_node *node) {
assert(is_ir_node(node));
return _get_irn_generic_attr(node);
/** manipulate fields of individual nodes **/
/* this works for all except Block */
-ir_node *
-get_nodes_block(const ir_node *node) {
+ir_node *get_nodes_block(const ir_node *node) {
assert(node->op != op_Block);
return get_irn_n(node, -1);
}
-void
-set_nodes_block(ir_node *node, ir_node *block) {
+void set_nodes_block(ir_node *node, ir_node *block) {
assert(node->op != op_Block);
set_irn_n(node, -1, block);
}
/* this works for all except Block */
-ir_node *
-get_nodes_MacroBlock(const ir_node *node) {
+ir_node *get_nodes_MacroBlock(const ir_node *node) {
assert(node->op != op_Block);
return get_Block_MacroBlock(get_irn_n(node, -1));
}
the implementation of the graph data structure this can be a copy of
the internal representation of predecessors as well as the internal
array itself. Therefore writing to this array might obstruct the ir. */
-ir_node **
-get_Block_cfgpred_arr(ir_node *node) {
+ir_node **get_Block_cfgpred_arr(ir_node *node) {
assert((node->op == op_Block));
return (ir_node **)&(get_irn_in(node)[1]);
}
-int
-(get_Block_n_cfgpreds)(const ir_node *node) {
+int (get_Block_n_cfgpreds)(const ir_node *node) {
return _get_Block_n_cfgpreds(node);
}
-ir_node *
-(get_Block_cfgpred)(const ir_node *node, int pos) {
+ir_node *(get_Block_cfgpred)(const ir_node *node, int pos) {
return _get_Block_cfgpred(node, pos);
}
-void
-set_Block_cfgpred(ir_node *node, int pos, ir_node *pred) {
+void set_Block_cfgpred(ir_node *node, int pos, ir_node *pred) {
assert(node->op == op_Block);
set_irn_n(node, pos, pred);
}
-ir_node *
-(get_Block_cfgpred_block)(const ir_node *node, int pos) {
+ir_node *(get_Block_cfgpred_block)(const ir_node *node, int pos) {
return _get_Block_cfgpred_block(node, pos);
}
-int
-get_Block_matured(const ir_node *node) {
+int get_Block_matured(const ir_node *node) {
assert(node->op == op_Block);
return (int)node->attr.block.is_matured;
}
-void
-set_Block_matured(ir_node *node, int matured) {
+void set_Block_matured(ir_node *node, int matured) {
assert(node->op == op_Block);
node->attr.block.is_matured = matured;
}
-unsigned long
-(get_Block_block_visited)(const ir_node *node) {
+unsigned long (get_Block_block_visited)(const ir_node *node) {
return _get_Block_block_visited(node);
}
-void
-(set_Block_block_visited)(ir_node *node, unsigned long visit) {
+void (set_Block_block_visited)(ir_node *node, unsigned long visit) {
_set_Block_block_visited(node, visit);
}
/* For this current_ir_graph must be set. */
-void
-(mark_Block_block_visited)(ir_node *node) {
+void (mark_Block_block_visited)(ir_node *node) {
_mark_Block_block_visited(node);
}
-int
-(Block_not_block_visited)(const ir_node *node) {
+int (Block_not_block_visited)(const ir_node *node) {
return _Block_not_block_visited(node);
}
-int
-(Block_block_visited)(const ir_node *node) {
+int (Block_block_visited)(const ir_node *node) {
return _Block_block_visited(node);
}
-ir_node *
-get_Block_graph_arr(ir_node *node, int pos) {
+ir_node *get_Block_graph_arr(ir_node *node, int pos) {
assert(node->op == op_Block);
return node->attr.block.graph_arr[pos+1];
}
-void
-set_Block_graph_arr(ir_node *node, int pos, ir_node *value) {
+void set_Block_graph_arr(ir_node *node, int pos, ir_node *value) {
assert(node->op == op_Block);
node->attr.block.graph_arr[pos+1] = value;
}
block->attr.block.extblk = extblk;
}
-/* returns the macro block header of a block. */
+/* Returns the macro block header of a block.*/
ir_node *get_Block_MacroBlock(const ir_node *block) {
ir_node *mbh;
assert(is_Block(block));
return mbh;
}
+/* Sets the macro block header of a block. */
+void set_Block_MacroBlock(ir_node *block, ir_node *mbh) {
+ assert(is_Block(block));
+ assert(is_Block(mbh));
+ set_irn_n(block, -1, mbh);
+}
+
/* returns the macro block header of a node. */
ir_node *get_irn_MacroBlock(const ir_node *n) {
if (! is_Block(n)) {
block->attr.block.label = label;
}
-int
-get_End_n_keepalives(const ir_node *end) {
+ir_node *(get_Block_phis)(const ir_node *block) {
+ return _get_Block_phis(block);
+}
+
+void (set_Block_phis)(ir_node *block, ir_node *phi) {
+ _set_Block_phis(block, phi);
+}
+
+int get_End_n_keepalives(const ir_node *end) {
assert(end->op == op_End);
return (get_irn_arity(end) - END_KEEPALIVE_OFFSET);
}
-ir_node *
-get_End_keepalive(const ir_node *end, int pos) {
+ir_node *get_End_keepalive(const ir_node *end, int pos) {
assert(end->op == op_End);
return get_irn_n(end, pos + END_KEEPALIVE_OFFSET);
}
-void
-add_End_keepalive(ir_node *end, ir_node *ka) {
+void add_End_keepalive(ir_node *end, ir_node *ka) {
assert(end->op == op_End);
assert((is_Phi(ka) || is_Proj(ka) || is_Block(ka) || is_irn_keep(ka)) && "Only Phi, Block or Keep nodes can be kept alive!");
add_irn_n(end, ka);
}
-void
-set_End_keepalive(ir_node *end, int pos, ir_node *ka) {
+void set_End_keepalive(ir_node *end, int pos, ir_node *ka) {
assert(end->op == op_End);
set_irn_n(end, pos + END_KEEPALIVE_OFFSET, ka);
}
UNOP(Conv)
UNOP(Cast)
+int is_Div_remainderless(const ir_node *node) {
+ assert(node->op == op_Div);
+ return node->attr.divmod.no_remainder;
+}
+
int get_Conv_strict(const ir_node *node) {
assert(node->op == op_Conv);
return node->attr.conv.strict;
set_irn_n(node, pos, pred);
}
+ir_node *(get_Phi_next)(const ir_node *phi) {
+ return _get_Phi_next(phi);
+}
+
+void (set_Phi_next)(ir_node *phi, ir_node *next) {
+ _set_Phi_next(phi, next);
+}
int is_memop(const ir_node *node) {
ir_opcode code = get_irn_opcode(node);
return _is_Tuple(node);
}
+int
+(is_Bound)(const ir_node *node) {
+ return _is_Bound(node);
+}
+
int
(is_Start)(const ir_node *node) {
return _is_Start(node);
projects / libfirm / blobdiff