*
* @return zero if both nodes have identically attributes
*/
-static int IncSP_cmp_attr(ir_node *a, ir_node *b) {
+static int IncSP_cmp_attr(ir_node *a, ir_node *b)
+{
const be_incsp_attr_t *a_attr = get_irn_attr_const(a);
const be_incsp_attr_t *b_attr = get_irn_attr_const(b);
{
ir_graph *irg = get_Block_irg(bl);
ir_node *frame = get_irg_frame(irg);
- const arch_register_class_t *cls_frame = arch_get_irn_reg_class_out(frame);
const arch_register_t *sp = arch_env->sp;
ir_node *irn;
be_memperm_attr_t *attr;
ir_node **real_in;
- int i;
real_in = ALLOCAN(ir_node*, n + 1);
real_in[0] = frame;
memcpy(&real_in[1], in, n * sizeof(real_in[0]));
- irn = new_ir_node(NULL, irg, bl, op_be_MemPerm, mode_T, n+1, real_in);
+ irn = new_ir_node(NULL, irg, bl, op_be_MemPerm, mode_T, n+1, real_in);
- init_node_attr(irn, n + 1, n + 1);
+ init_node_attr(irn, n + 1, n);
be_node_set_reg_class_in(irn, 0, sp->reg_class);
- for (i = 0; i < n; ++i) {
- be_node_set_reg_class_in(irn, i + 1, cls_frame);
- be_node_set_reg_class_out(irn, i, cls_frame);
- }
- attr = get_irn_attr(irn);
+ attr = get_irn_attr(irn);
attr->in_entities = OALLOCNZ(irg->obst, ir_entity*, n);
attr->out_entities = OALLOCNZ(irg->obst, ir_entity*, n);
return res;
}
-ir_node *be_get_Copy_op(const ir_node *cpy) {
+ir_node *be_get_Copy_op(const ir_node *cpy)
+{
return get_irn_n(cpy, be_pos_Copy_op);
}
-void be_set_Copy_op(ir_node *cpy, ir_node *op) {
+void be_set_Copy_op(ir_node *cpy, ir_node *op)
+{
set_irn_n(cpy, be_pos_Copy_op, op);
}
}
/* Gets the call entity or NULL if this is no static call. */
-ir_entity *be_Call_get_entity(const ir_node *call) {
+ir_entity *be_Call_get_entity(const ir_node *call)
+{
const be_call_attr_t *a = get_irn_attr_const(call);
assert(be_is_Call(call));
return a->ent;
}
/* Sets the call entity. */
-void be_Call_set_entity(ir_node *call, ir_entity *ent) {
+void be_Call_set_entity(ir_node *call, ir_entity *ent)
+{
be_call_attr_t *a = get_irn_attr(call);
assert(be_is_Call(call));
a->ent = ent;
}
/* Gets the call type. */
-ir_type *be_Call_get_type(ir_node *call) {
+ir_type *be_Call_get_type(ir_node *call)
+{
const be_call_attr_t *a = get_irn_attr_const(call);
assert(be_is_Call(call));
return a->call_tp;
}
/* Sets the call type. */
-void be_Call_set_type(ir_node *call, ir_type *call_tp) {
+void be_Call_set_type(ir_node *call, ir_type *call_tp)
+{
be_call_attr_t *a = get_irn_attr(call);
assert(be_is_Call(call));
a->call_tp = call_tp;
}
-void be_Call_set_pop(ir_node *call, unsigned pop) {
+void be_Call_set_pop(ir_node *call, unsigned pop)
+{
be_call_attr_t *a = get_irn_attr(call);
a->pop = pop;
}
-unsigned be_Call_get_pop(const ir_node *call) {
+unsigned be_Call_get_pop(const ir_node *call)
+{
const be_call_attr_t *a = get_irn_attr_const(call);
return a->pop;
}
}
/* Returns the number of real returns values */
-int be_Return_get_n_rets(const ir_node *ret) {
+int be_Return_get_n_rets(const ir_node *ret)
+{
const be_return_attr_t *a = get_irn_generic_attr_const(ret);
return a->num_ret_vals;
}
/* return the number of bytes that should be popped from stack when executing the Return. */
-unsigned be_Return_get_pop(const ir_node *ret) {
+unsigned be_Return_get_pop(const ir_node *ret)
+{
const be_return_attr_t *a = get_irn_generic_attr_const(ret);
return a->pop;
}
/* return non-zero, if number of popped bytes must be always emitted */
-int be_Return_get_emit_pop(const ir_node *ret) {
+int be_Return_get_emit_pop(const ir_node *ret)
+{
const be_return_attr_t *a = get_irn_generic_attr_const(ret);
return a->emit_pop;
}
/* return non-zero, if number of popped bytes must be always emitted */
-void be_Return_set_emit_pop(ir_node *ret, int emit_pop) {
+void be_Return_set_emit_pop(ir_node *ret, int emit_pop)
+{
be_return_attr_t *a = get_irn_generic_attr(ret);
a->emit_pop = emit_pop;
}
-int be_Return_append_node(ir_node *ret, ir_node *node) {
+int be_Return_append_node(ir_node *ret, ir_node *node)
+{
int pos;
pos = add_irn_n(ret, node);
return irn;
}
-ir_node *be_new_Start(ir_node *bl, int n_outs)
+ir_node *be_new_Start(dbg_info *dbgi, ir_node *bl, int n_outs)
{
ir_node *res;
int i;
ir_graph *irg = get_Block_irg(bl);
- res = new_ir_node(NULL, irg, bl, op_be_Start, mode_T, 0, NULL);
+ res = new_ir_node(dbgi, irg, bl, op_be_Start, mode_T, 0, NULL);
init_node_attr(res, 0, -1);
for (i = 0; i < n_outs; ++i) {
add_register_req_out(res);
return optimize_node(irn);
}
-ir_node *be_get_FrameAddr_frame(const ir_node *node) {
+ir_node *be_get_FrameAddr_frame(const ir_node *node)
+{
assert(be_is_FrameAddr(node));
return get_irn_n(node, be_pos_FrameAddr_ptr);
}
return be_new_CopyKeep(cls, bl, src, 1, &keep, mode);
}
-ir_node *be_get_CopyKeep_op(const ir_node *cpy) {
+ir_node *be_get_CopyKeep_op(const ir_node *cpy)
+{
return get_irn_n(cpy, be_pos_CopyKeep_op);
}
-void be_set_CopyKeep_op(ir_node *cpy, ir_node *op) {
+void be_set_CopyKeep_op(ir_node *cpy, ir_node *op)
+{
set_irn_n(cpy, be_pos_CopyKeep_op, op);
}
ir_node *be_Barrier_append_node(ir_node *barrier, ir_node *node)
{
- ir_node *block = get_nodes_block(barrier);
ir_mode *mode = get_irn_mode(node);
int n = add_irn_n(barrier, node);
- ir_node *proj = new_r_Proj(block, barrier, mode, n);
+ ir_node *proj = new_r_Proj(barrier, mode, n);
add_register_req_in(barrier);
add_register_req_out(barrier);
return proj;
}
-int be_has_frame_entity(const ir_node *irn)
+static bool be_has_frame_entity(const ir_node *irn)
{
switch (get_irn_opcode(irn)) {
case beo_Spill:
case beo_Reload:
case beo_FrameAddr:
- return 1;
+ return true;
default:
- return 0;
+ return false;
}
}
be_set_constr_out(irn, pos, cls->class_req);
}
-ir_node *be_get_IncSP_pred(ir_node *irn) {
+ir_node *be_get_IncSP_pred(ir_node *irn)
+{
assert(be_is_IncSP(irn));
return get_irn_n(irn, 0);
}
-void be_set_IncSP_pred(ir_node *incsp, ir_node *pred) {
+void be_set_IncSP_pred(ir_node *incsp, ir_node *pred)
+{
assert(be_is_IncSP(incsp));
set_irn_n(incsp, 0, pred);
}
int be_dump_phi_reg_reqs(ir_node *node, FILE *F, dump_reason_t reason)
{
- switch(reason) {
+ switch (reason) {
case dump_node_opcode_txt:
fputs(get_op_name(get_irn_op(node)), F);
break;
assert(is_be_node(irn));
- switch(reason) {
+ switch (reason) {
case dump_node_opcode_txt:
fputs(get_op_name(get_irn_op(irn)), f);
break;
* ir_op-Operation:
* Copies the backend specific attributes from old node to new node.
*/
-static void copy_attr(const ir_node *old_node, ir_node *new_node)
+static void copy_attr(ir_graph *irg, const ir_node *old_node, ir_node *new_node)
{
const be_node_attr_t *old_attr = get_irn_attr_const(old_node);
be_node_attr_t *new_attr = get_irn_attr(new_node);
- ir_graph *irg = get_irn_irg(new_node);
struct obstack *obst = be_get_birg_obst(irg);
backend_info_t *old_info = be_get_info(old_node);
backend_info_t *new_info = be_get_info(new_node);