#include "be_t.h"
#include "belive_t.h"
-#include "besched_t.h"
+#include "besched.h"
#include "benode_t.h"
-#include "bearch_t.h"
+#include "bearch.h"
#include "beirgmod.h"
typedef struct {
arch_register_req_t req;
-} be_req_t;
-
-typedef struct {
- be_req_t req;
- be_req_t in_req;
+ arch_register_req_t in_req;
} be_reg_data_t;
/** The generic be nodes attribute type. */
#define K irop_flag_keep
#define M irop_flag_uses_memory
-static int be_reqs_equal(const be_req_t *req1, const be_req_t *req2)
-{
- if(!reg_reqs_equal(&req1->req, &req2->req))
- return 0;
-
- return 1;
-}
-
/**
* Compare two be node attributes.
*
* @return zero if both attributes are identically
*/
static int _node_cmp_attr(const be_node_attr_t *a, const be_node_attr_t *b) {
- int i, len;
+ int i, len = ARR_LEN(a->reg_data);
- if (ARR_LEN(a->reg_data) != ARR_LEN(b->reg_data))
+ if (len != ARR_LEN(b->reg_data))
return 1;
- len = ARR_LEN(a->reg_data);
- for (i = 0; i < len; ++i) {
- if (!be_reqs_equal(&a->reg_data[i].in_req, &b->reg_data[i].in_req) ||
- !be_reqs_equal(&a->reg_data[i].req, &b->reg_data[i].req))
+ for (i = len - 1; i >= 0; --i) {
+ if (!reg_reqs_equal(&a->reg_data[i].in_req, &b->reg_data[i].in_req) ||
+ !reg_reqs_equal(&a->reg_data[i].req, &b->reg_data[i].req))
return 1;
}
const be_node_attr_t *a_attr = get_irn_attr_const(a);
const be_node_attr_t *b_attr = get_irn_attr_const(b);
- if(_node_cmp_attr(a_attr, b_attr) != 0)
+ if (_node_cmp_attr(a_attr, b_attr) != 0)
return 1;
return !be_info_equal(a, b);
const be_call_attr_t *b_attr = get_irn_attr_const(b);
if (a_attr->ent != b_attr->ent ||
- a_attr->call_tp != b_attr->call_tp)
+ a_attr->call_tp != b_attr->call_tp)
return 1;
return _node_cmp_attr(&a_attr->node_attr, &b_attr->node_attr);
}
-static inline be_req_t *get_be_req(const ir_node *node, int pos)
+static inline arch_register_req_t *get_be_req(const ir_node *node, int pos)
{
int idx;
const be_node_attr_t *attr;
assert(is_be_node(node));
attr = get_irn_attr_const(node);
- if(pos < 0) {
+ if (pos < 0) {
idx = -(pos + 1);
} else {
idx = pos;
return pos < 0 ? &rd->req : &rd->in_req;
}
-static inline arch_register_req_t *get_req(const ir_node *node, int pos)
-{
- be_req_t *bereq = get_be_req(node, pos);
- return &bereq->req;
-}
-
/**
- * Initializes the generic attribute of all be nodes and return ir.
+ * Initializes the generic attribute of all be nodes and return it.
*/
static void *init_node_attr(ir_node *node, int max_reg_data)
{
ARR_APP1(reg_out_info_t, info->out_infos, out_info);
}
-/**
- * Skip Proj nodes and return their Proj numbers.
- *
- * If *node is a Proj or Proj(Proj) node, skip it.
- *
- * @param node points to the node to be skipped
- *
- * @return 0 if *node was no Proj node, its Proj number else.
- */
-static int redir_proj(const ir_node **node)
-{
- const ir_node *n = *node;
-
- if(is_Proj(n)) {
- ir_node *irn;
-
- *node = irn = get_Proj_pred(n);
- if(is_Proj(irn)) {
- assert(get_irn_mode(irn) == mode_T);
- *node = get_Proj_pred(irn);
- }
- return get_Proj_proj(n);
- }
-
- return 0;
-}
-
ir_node *be_new_Spill(const arch_register_class_t *cls, const arch_register_class_t *cls_frame,
- ir_graph *irg, ir_node *bl, ir_node *frame, ir_node *to_spill)
+ ir_node *bl, ir_node *frame, ir_node *to_spill)
{
be_frame_attr_t *a;
ir_node *in[2];
ir_node *res;
+ ir_graph *irg = get_Block_irg(bl);
in[0] = frame;
in[1] = to_spill;
be_node_set_reg_class_in(res, be_pos_Spill_frame, cls_frame);
be_node_set_reg_class_in(res, be_pos_Spill_val, cls);
+
+ /*
+ * For spills and reloads, we return "none" as requirement for frame
+ * pointer, so every input is ok. Some backends need this (e.g. STA).
+ * Matze: we should investigate if this is really needed, this solution
+ * looks very hacky to me
+ */
+ be_node_set_reg_class_in(res, be_pos_Spill_frame, NULL);
+
return res;
}
ir_node *be_new_Reload(const arch_register_class_t *cls,
- const arch_register_class_t *cls_frame, ir_graph *irg, ir_node *block,
+ const arch_register_class_t *cls_frame, ir_node *block,
ir_node *frame, ir_node *mem, ir_mode *mode)
{
- ir_node *in[2];
- ir_node *res;
+ ir_node *in[2];
+ ir_node *res;
+ ir_graph *irg = get_Block_irg(block);
in[0] = frame;
in[1] = mem;
be_node_set_reg_class_out(res, 0, cls);
be_node_set_reg_class_in(res, be_pos_Reload_frame, cls_frame);
arch_irn_set_flags(res, arch_irn_flags_rematerializable);
+
+ /*
+ * For spills and reloads, we return "none" as requirement for frame
+ * pointer, so every input is ok. Some backends need this (e.g. STA).
+ * Matze: we should investigate if this is really needed, this solution
+ * looks very hacky to me
+ */
+ be_node_set_reg_class_in(res, be_pos_Reload_frame, NULL);
+
return res;
}
return get_irn_n(irn, be_pos_Spill_frame);
}
-ir_node *be_new_Perm(const arch_register_class_t *cls, ir_graph *irg,
- ir_node *block, int n, ir_node *in[])
+ir_node *be_new_Perm(const arch_register_class_t *cls, ir_node *block, int n, ir_node *in[])
{
- int i;
+ int i;
+ ir_graph *irg = get_Block_irg(block);
+
ir_node *irn = new_ir_node(NULL, irg, block, op_be_Perm, mode_T, n, in);
init_node_attr(irn, n);
- for(i = 0; i < n; ++i) {
+ for (i = 0; i < n; ++i) {
be_node_set_reg_class_in(irn, i, cls);
be_node_set_reg_class_out(irn, i, cls);
}
set_irn_in(perm, new_size, new_in);
}
-ir_node *be_new_MemPerm(const arch_env_t *arch_env, ir_graph *irg, ir_node *bl, int n, ir_node *in[])
+ir_node *be_new_MemPerm(const arch_env_t *arch_env, ir_node *bl, int n, ir_node *in[])
{
+ 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 *be_new_Copy(const arch_register_class_t *cls, ir_graph *irg, ir_node *bl, ir_node *op)
+ir_node *be_new_Copy(const arch_register_class_t *cls, ir_node *bl, ir_node *op)
{
ir_node *in[1];
ir_node *res;
arch_register_req_t *req;
+ ir_graph *irg = get_Block_irg(bl);
in[0] = op;
res = new_ir_node(NULL, irg, bl, op_be_Copy, get_irn_mode(op), 1, in);
be_node_set_reg_class_in(res, 0, cls);
be_node_set_reg_class_out(res, 0, cls);
- req = get_req(res, BE_OUT_POS(0));
+ req = get_be_req(res, BE_OUT_POS(0));
req->cls = cls;
req->type = arch_register_req_type_should_be_same;
req->other_same = 1U << 0;
set_irn_n(cpy, be_pos_Copy_op, op);
}
-ir_node *be_new_Keep(const arch_register_class_t *cls, ir_graph *irg, ir_node *bl, int n, ir_node *in[])
+ir_node *be_new_Keep(const arch_register_class_t *cls, ir_node *bl, int n, ir_node *in[])
{
int i;
ir_node *res;
+ ir_graph *irg = get_Block_irg(bl);
res = new_ir_node(NULL, irg, bl, op_be_Keep, mode_ANY, -1, NULL);
init_node_attr(res, -1);
return pos;
}
-ir_node *be_new_IncSP(const arch_register_t *sp, ir_graph *irg, ir_node *bl,
+ir_node *be_new_IncSP(const arch_register_t *sp, ir_node *bl,
ir_node *old_sp, int offset, int align)
{
be_incsp_attr_t *a;
ir_node *irn;
ir_node *in[1];
+ ir_graph *irg = get_Block_irg(bl);
in[0] = old_sp;
irn = new_ir_node(NULL, irg, bl, op_be_IncSP, sp->reg_class->mode,
return irn;
}
-ir_node *be_new_AddSP(const arch_register_t *sp, ir_graph *irg, ir_node *bl, ir_node *old_sp, ir_node *sz)
+ir_node *be_new_AddSP(const arch_register_t *sp, ir_node *bl, ir_node *old_sp, ir_node *sz)
{
be_node_attr_t *a;
ir_node *irn;
ir_node *in[be_pos_AddSP_last];
const arch_register_class_t *cls;
+ ir_graph *irg;
in[be_pos_AddSP_old_sp] = old_sp;
in[be_pos_AddSP_size] = sz;
+ irg = get_Block_irg(bl);
irn = new_ir_node(NULL, irg, bl, op_be_AddSP, mode_T, be_pos_AddSP_last, in);
a = init_node_attr(irn, be_pos_AddSP_last);
return irn;
}
-ir_node *be_new_SubSP(const arch_register_t *sp, ir_graph *irg, ir_node *bl, ir_node *old_sp, ir_node *sz)
+ir_node *be_new_SubSP(const arch_register_t *sp, ir_node *bl, ir_node *old_sp, ir_node *sz)
{
be_node_attr_t *a;
ir_node *irn;
ir_node *in[be_pos_SubSP_last];
+ ir_graph *irg;
in[be_pos_SubSP_old_sp] = old_sp;
in[be_pos_SubSP_size] = sz;
+ irg = get_Block_irg(bl);
irn = new_ir_node(NULL, irg, bl, op_be_SubSP, mode_T, be_pos_SubSP_last, in);
a = init_node_attr(irn, be_pos_SubSP_last);
return irn;
}
-ir_node *be_new_RegParams(ir_graph *irg, ir_node *bl, int n_outs)
+ir_node *be_new_RegParams(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_RegParams, mode_T, 0, NULL);
init_node_attr(res, -1);
return res;
}
-ir_node *be_new_FrameAddr(const arch_register_class_t *cls_frame, ir_graph *irg, ir_node *bl, ir_node *frame, ir_entity *ent)
+ir_node *be_new_FrameAddr(const arch_register_class_t *cls_frame, ir_node *bl, ir_node *frame, ir_entity *ent)
{
be_frame_attr_t *a;
ir_node *irn;
ir_node *in[1];
+ ir_graph *irg = get_Block_irg(bl);
in[0] = frame;
irn = new_ir_node(NULL, irg, bl, op_be_FrameAddr, get_irn_mode(frame), 1, in);
return attr->ent;
}
-ir_node *be_new_CopyKeep(const arch_register_class_t *cls, ir_graph *irg, ir_node *bl, ir_node *src, int n, ir_node *in_keep[], ir_mode *mode)
+ir_node *be_new_CopyKeep(const arch_register_class_t *cls, ir_node *bl, ir_node *src, int n, ir_node *in_keep[], ir_mode *mode)
{
ir_node *irn;
ir_node **in = ALLOCAN(ir_node*, n + 1);
+ ir_graph *irg = get_Block_irg(bl);
in[0] = src;
memcpy(&in[1], in_keep, n * sizeof(in[0]));
return irn;
}
-ir_node *be_new_CopyKeep_single(const arch_register_class_t *cls, ir_graph *irg, ir_node *bl, ir_node *src, ir_node *keep, ir_mode *mode)
+ir_node *be_new_CopyKeep_single(const arch_register_class_t *cls, ir_node *bl, ir_node *src, ir_node *keep, ir_mode *mode)
{
- return be_new_CopyKeep(cls, irg, bl, src, 1, &keep, mode);
+ return be_new_CopyKeep(cls, bl, src, 1, &keep, mode);
}
ir_node *be_get_CopyKeep_op(const ir_node *cpy) {
set_irn_n(cpy, be_pos_CopyKeep_op, op);
}
-ir_node *be_new_Barrier(ir_graph *irg, ir_node *bl, int n, ir_node *in[])
+ir_node *be_new_Barrier(ir_node *bl, int n, ir_node *in[])
{
ir_node *res;
int i;
+ ir_graph *irg = get_Block_irg(bl);
res = new_ir_node(NULL, irg, bl, op_be_Barrier, mode_T, -1, NULL);
init_node_attr(res, -1);
ir_node *be_Barrier_append_node(ir_node *barrier, ir_node *node)
{
- ir_graph *irg = get_irn_irg(barrier);
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(irg, block, barrier, mode, n);
+ ir_node *proj = new_r_Proj(block, barrier, mode, n);
add_register_req(barrier);
return proj;
}
/* Construct a new be_Unwind. */
-ir_node *be_new_Unwind(dbg_info *dbg, ir_graph *irg, ir_node *block,
+ir_node *be_new_Unwind(dbg_info *dbg, ir_node *block,
ir_node *mem, ir_node *sp)
{
ir_node *res;
ir_node *in[2];
+ ir_graph *irg = get_Block_irg(block);
in[be_pos_Unwind_mem] = mem;
in[be_pos_Unwind_sp] = sp;
void be_set_constr_single_reg_in(ir_node *node, int pos,
const arch_register_t *reg, arch_register_req_type_t additional_types)
{
- arch_register_req_t *req = get_req(node, pos);
+ arch_register_req_t *req = get_be_req(node, pos);
ir_graph *irg = get_irn_irg(node);
struct obstack *obst = get_irg_obstack(irg);
void be_set_constr_single_reg_out(ir_node *node, int pos,
const arch_register_t *reg, arch_register_req_type_t additional_types)
{
- arch_register_req_t *req = get_req(node, BE_OUT_POS(pos));
+ arch_register_req_t *req = get_be_req(node, BE_OUT_POS(pos));
ir_graph *irg = get_irn_irg(node);
struct obstack *obst = get_irg_obstack(irg);
{
ir_graph *irg = get_irn_irg(node);
struct obstack *obst = get_irg_obstack(irg);
- arch_register_req_t *r = get_req(node, pos);
+ arch_register_req_t *r = get_be_req(node, pos);
assert(arch_register_req_is(req, limited));
assert(!(req->type & (arch_register_req_type_should_be_same | arch_register_req_type_must_be_different)));
void be_node_set_reg_class_in(ir_node *irn, int pos, const arch_register_class_t *cls)
{
- arch_register_req_t *req = get_req(irn, pos);
+ arch_register_req_t *req = get_be_req(irn, pos);
req->cls = cls;
void be_node_set_reg_class_out(ir_node *irn, int pos, const arch_register_class_t *cls)
{
- arch_register_req_t *req = get_req(irn, BE_OUT_POS(pos));
+ arch_register_req_t *req = get_be_req(irn, BE_OUT_POS(pos));
req->cls = cls;
void be_node_set_req_type(ir_node *irn, int pos, arch_register_req_type_t type)
{
- arch_register_req_t *req = get_req(irn, pos);
+ arch_register_req_t *req = get_be_req(irn, pos);
req->type = type;
}
ir_node *be_spill(ir_node *block, ir_node *irn)
{
- ir_graph *irg = get_irn_irg(block);
+ ir_graph *irg = get_Block_irg(block);
ir_node *frame = get_irg_frame(irg);
const arch_register_class_t *cls = arch_get_irn_reg_class_out(irn);
const arch_register_class_t *cls_frame = arch_get_irn_reg_class_out(frame);
ir_node *spill;
- spill = be_new_Spill(cls, cls_frame, irg, block, frame, irn);
+ spill = be_new_Spill(cls, cls_frame, block, frame, irn);
return spill;
}
{
ir_node *reload;
ir_node *bl = is_Block(insert) ? insert : get_nodes_block(insert);
- ir_graph *irg = get_irn_irg(bl);
+ 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);
assert(be_is_Spill(spill) || (is_Phi(spill) && get_irn_mode(spill) == mode_M));
- reload = be_new_Reload(cls, cls_frame, irg, bl, frame, spill, mode);
+ reload = be_new_Reload(cls, cls_frame, bl, frame, spill, mode);
if (is_Block(insert)) {
insert = sched_skip(insert, 0, sched_skip_cf_predicator, NULL);
*/
-static const
-arch_register_req_t *get_out_reg_req(const ir_node *irn, int out_pos)
+static const arch_register_req_t *be_node_get_out_reg_req(
+ const ir_node *irn, int pos)
{
const be_node_attr_t *a = get_irn_attr_const(irn);
- if(out_pos >= ARR_LEN(a->reg_data)) {
+ assert(pos >= 0);
+ if (pos >= ARR_LEN(a->reg_data)) {
return arch_no_register_req;
}
- return &a->reg_data[out_pos].req.req;
+ return &a->reg_data[pos].req;
}
-static const
-arch_register_req_t *get_in_reg_req(const ir_node *irn, int pos)
+static const arch_register_req_t *be_node_get_in_reg_req(
+ const ir_node *irn, int pos)
{
const be_node_attr_t *a = get_irn_attr_const(irn);
- if(pos >= get_irn_arity(irn) || pos >= ARR_LEN(a->reg_data))
+ assert(pos >= 0);
+ if (pos >= get_irn_arity(irn) || pos >= ARR_LEN(a->reg_data))
return arch_no_register_req;
- return &a->reg_data[pos].in_req.req;
-}
-
-static const arch_register_req_t *
-be_node_get_irn_reg_req(const ir_node *irn, int pos)
-{
- int out_pos = pos;
-
- if (pos < 0) {
- if (get_irn_mode(irn) == mode_T)
- return arch_no_register_req;
-
- assert(pos == -1);
- out_pos = redir_proj((const ir_node **)&irn);
- assert(is_be_node(irn));
- return get_out_reg_req(irn, out_pos);
- } else if (is_be_node(irn)) {
- /*
- * For spills and reloads, we return "none" as requirement for frame
- * pointer, so every input is ok. Some backends need this (e.g. STA).
- */
- if ((be_is_Spill(irn) && pos == be_pos_Spill_frame) ||
- (be_is_Reload(irn) && pos == be_pos_Reload_frame))
- return arch_no_register_req;
-
- return get_in_reg_req(irn, pos);
- }
-
- return arch_no_register_req;
+ return &a->reg_data[pos].in_req;
}
static arch_irn_class_t be_node_classify(const ir_node *irn)
{
-restart:
switch (get_irn_opcode(irn)) {
-#define XXX(a,b) case a: return b
- XXX(beo_Spill, arch_irn_class_spill);
- XXX(beo_Reload, arch_irn_class_reload);
- XXX(beo_Perm, arch_irn_class_perm);
- XXX(beo_Copy, arch_irn_class_copy);
- XXX(beo_Return, arch_irn_class_branch);
-#undef XXX
- case iro_Proj:
- irn = get_Proj_pred(irn);
- if (is_Proj(irn)) {
- assert(get_irn_mode(irn) == mode_T);
- irn = get_Proj_pred(irn);
- }
- goto restart;
-
- default:
- return 0;
+ case beo_Spill: return arch_irn_class_spill;
+ case beo_Reload: return arch_irn_class_reload;
+ case beo_Perm: return arch_irn_class_perm;
+ case beo_Copy: return arch_irn_class_copy;
+ default: return 0;
}
}
static void be_node_set_frame_offset(ir_node *irn, int offset)
{
- if(be_has_frame_entity(irn)) {
- be_frame_attr_t *a = get_irn_attr(irn);
- a->offset = offset;
- }
+ be_frame_attr_t *a;
+
+ if(!be_has_frame_entity(irn))
+ return;
+
+ a = get_irn_attr(irn);
+ a->offset = offset;
}
static int be_node_get_sp_bias(const ir_node *irn)
*/
+/* for be nodes */
static const arch_irn_ops_t be_node_irn_ops = {
- be_node_get_irn_reg_req,
+ be_node_get_in_reg_req,
+ be_node_get_out_reg_req,
be_node_classify,
be_node_get_frame_entity,
be_node_set_frame_entity,
NULL, /* perform_memory_operand */
};
+static const arch_register_req_t *dummy_reg_req(
+ const ir_node *node, int pos)
+{
+ (void) node;
+ (void) pos;
+ return arch_no_register_req;
+}
+
+static arch_irn_class_t dummy_classify(const ir_node *node)
+{
+ (void) node;
+ return 0;
+}
+
+static ir_entity* dummy_get_frame_entity(const ir_node *node)
+{
+ (void) node;
+ return NULL;
+}
+
+static void dummy_set_frame_entity(ir_node *node, ir_entity *entity)
+{
+ (void) node;
+ (void) entity;
+ panic("dummy_set_frame_entity() should not be called");
+}
+
+static void dummy_set_frame_offset(ir_node *node, int bias)
+{
+ (void) node;
+ (void) bias;
+ panic("dummy_set_frame_offset() should not be called");
+}
+
+static int dummy_get_sp_bias(const ir_node *node)
+{
+ (void) node;
+ return 0;
+}
+
+/* for "middleend" nodes */
+static const arch_irn_ops_t dummy_be_irn_ops = {
+ dummy_reg_req,
+ dummy_reg_req,
+ dummy_classify,
+ dummy_get_frame_entity,
+ dummy_set_frame_entity,
+ dummy_set_frame_offset,
+ dummy_get_sp_bias,
+ NULL, /* get_inverse */
+ NULL, /* get_op_estimated_cost */
+ NULL, /* possible_memory_operand */
+ NULL, /* perform_memory_operand */
+};
+
/*
____ _ _ ___ ____ _ _ _ _ _ _
| _ \| |__ (_) |_ _| _ \| \ | | | | | | __ _ _ __ __| | | ___ _ __
*/
-typedef struct {
- const arch_register_t *reg;
- arch_register_req_t req;
- arch_irn_flags_t flags;
-} phi_attr_t;
-
-static struct {
- pmap *phi_attrs;
-} phi_handler;
-
-#define get_phi_handler_from_ops(h) container_of(h, phi_handler_t, irn_ops)
-
-static inline
-phi_attr_t *get_Phi_attr(const ir_node *phi)
-{
- phi_attr_t *attr = pmap_get(phi_handler.phi_attrs, (void*) phi);
- if(attr == NULL) {
- ir_graph *irg = get_irn_irg(phi);
- struct obstack *obst = get_irg_obstack(irg);
- attr = obstack_alloc(obst, sizeof(attr[0]));
- memset(attr, 0, sizeof(attr[0]));
- pmap_insert(phi_handler.phi_attrs, phi, attr);
- }
-
- return attr;
-}
-
/**
- * Get register class of a Phi.
+ * Guess correct register class of a phi node by looking at its arguments
*/
-static
-const arch_register_req_t *get_Phi_reg_req_recursive(const ir_node *phi,
- pset **visited)
+static const arch_register_req_t *get_Phi_reg_req_recursive(const ir_node *phi,
+ pset **visited)
{
int n = get_irn_arity(phi);
ir_node *op;
return NULL;
}
-static
-const arch_register_req_t *phi_get_irn_reg_req(const ir_node *irn, int pos)
+static const arch_register_req_t *phi_get_irn_reg_req(const ir_node *node,
+ int pos)
{
- phi_attr_t *attr;
+ backend_info_t *info = be_get_info(node);
+ const arch_register_req_t *req = info->out_infos[0].req;
(void) pos;
- if(!mode_is_datab(get_irn_mode(irn)))
- return arch_no_register_req;
-
- attr = get_Phi_attr(irn);
-
- if(attr->req.type == arch_register_req_type_none) {
- pset *visited = NULL;
- const arch_register_req_t *req;
- req = get_Phi_reg_req_recursive(irn, &visited);
-
- attr->req = *req;
- assert(attr->req.cls != NULL);
- attr->req.type = arch_register_req_type_normal;
+ if (req == NULL) {
+ if (!mode_is_datab(get_irn_mode(node))) {
+ req = arch_no_register_req;
+ } else {
+ pset *visited = NULL;
+ ir_graph *irg = get_irn_irg(node);
+ struct obstack *obst = get_irg_obstack(irg);
+
+ req = get_Phi_reg_req_recursive(node, &visited);
+ assert(req->cls != NULL);
+
+ if (req->type != arch_register_req_type_normal) {
+ arch_register_req_t *nreq = obstack_alloc(obst, sizeof(*nreq));
+ *nreq = *req;
+ nreq->type = arch_register_req_type_normal;
+ req = nreq;
+ }
- if(visited != NULL)
- del_pset(visited);
+ if (visited != NULL)
+ del_pset(visited);
+ }
+ info->out_infos[0].req = req;
}
- return &attr->req;
+ return req;
}
-void be_set_phi_reg_req(ir_node *node, const arch_register_req_t *req,
- arch_register_req_type_t additional_types)
+void be_set_phi_reg_req(ir_node *node, const arch_register_req_t *req)
{
- phi_attr_t *attr;
+ backend_info_t *info = be_get_info(node);
+ info->out_infos[0].req = req;
assert(mode_is_datab(get_irn_mode(node)));
-
- attr = get_Phi_attr(node);
- attr->req = *req;
- attr->req.type |= additional_types;
}
-void be_set_phi_flags(ir_node *node, arch_irn_flags_t flags)
+int be_dump_phi_reg_reqs(ir_node *node, FILE *F, dump_reason_t reason)
{
- phi_attr_t *attr;
+ backend_info_t *info;
+ int i;
+ int arity;
- assert(mode_is_datab(get_irn_mode(node)));
+ switch(reason) {
+ case dump_node_opcode_txt:
+ fputs(get_op_name(get_irn_op(node)), F);
+ break;
+ case dump_node_mode_txt:
+ fprintf(F, "%s", get_mode_name(get_irn_mode(node)));
+ break;
+ case dump_node_nodeattr_txt:
+ break;
+ case dump_node_info_txt:
+ info = be_get_info(node);
+
+ /* we still have a little problem with the initialisation order. This
+ dump function is attached to the Phi ops before we can be sure
+ that all backend infos have been constructed... */
+ if (info != NULL) {
+ const arch_register_req_t *req = info->out_infos[0].req;
+ const arch_register_t *reg = arch_irn_get_register(node, 0);
+
+ arity = get_irn_arity(node);
+ for (i = 0; i < arity; ++i) {
+ fprintf(F, "inreq #%d = ", i);
+ arch_dump_register_req(F, req, node);
+ fputs("\n", F);
+ }
+ fprintf(F, "outreq #0 = ");
+ arch_dump_register_req(F, req, node);
+ fputs("\n", F);
- attr = get_Phi_attr(node);
- attr->flags = flags;
-}
+ fputs("\n", F);
-static arch_irn_class_t phi_classify(const ir_node *irn)
-{
- (void) irn;
- return 0;
-}
+ fprintf(F, "reg #0 = %s\n", reg != NULL ? reg->name : "n/a");
+ }
-static ir_entity *phi_get_frame_entity(const ir_node *irn)
-{
- (void) irn;
- return NULL;
-}
+ break;
-static void phi_set_frame_entity(ir_node *irn, ir_entity *ent)
-{
- (void) irn;
- (void) ent;
- panic("phi_set_frame_entity() should not be called");
-}
-
-static void phi_set_frame_offset(ir_node *irn, int bias)
-{
- (void) irn;
- (void) bias;
- panic("phi_set_frame_offset() should not be called");
-}
+ default:
+ break;
+ }
-static int phi_get_sp_bias(const ir_node *irn)
-{
- (void) irn;
return 0;
}
static const arch_irn_ops_t phi_irn_ops = {
phi_get_irn_reg_req,
- phi_classify,
- phi_get_frame_entity,
- phi_set_frame_entity,
- phi_set_frame_offset,
- phi_get_sp_bias,
+ phi_get_irn_reg_req,
+ dummy_classify,
+ dummy_get_frame_entity,
+ dummy_set_frame_entity,
+ dummy_set_frame_offset,
+ dummy_get_sp_bias,
NULL, /* get_inverse */
NULL, /* get_op_estimated_cost */
NULL, /* possible_memory_operand */
NULL, /* perform_memory_operand */
};
-void be_phi_handler_new(void)
-{
- phi_handler.phi_attrs = pmap_create();
- op_Phi->ops.be_ops = &phi_irn_ops;
-}
-
-void be_phi_handler_free(void)
-{
- pmap_destroy(phi_handler.phi_attrs);
- phi_handler.phi_attrs = NULL;
- op_Phi->ops.be_ops = NULL;
-}
-
-void be_phi_handler_reset(void)
-{
- if(phi_handler.phi_attrs)
- pmap_destroy(phi_handler.phi_attrs);
- phi_handler.phi_attrs = pmap_create();
-}
-
/*
_ _ _ ____ _
| \ | | ___ __| | ___ | _ \ _ _ _ __ ___ _ __ (_)_ __ __ _
|_| |___/
*/
-/**
- * Dumps a register requirement to a file.
- */
-static void dump_node_req(FILE *f, int idx, const arch_register_req_t *req,
- const ir_node *node)
-{
- int did_something = 0;
- char buf[16];
- const char *prefix = buf;
-
- snprintf(buf, sizeof(buf), "#%d ", idx);
- buf[sizeof(buf) - 1] = '\0';
-
- if(req->cls != 0) {
- char tmp[256];
- fprintf(f, prefix);
- arch_register_req_format(tmp, sizeof(tmp), req, node);
- fprintf(f, "%s", tmp);
- did_something = 1;
- }
-
- if(did_something)
- fprintf(f, "\n");
-}
-
/**
* Dumps node register requirements to a file.
*/
-static void dump_node_reqs(FILE *f, ir_node *node)
+static void dump_node_reqs(FILE *F, ir_node *node)
{
int i;
be_node_attr_t *a = get_irn_attr(node);
int len = ARR_LEN(a->reg_data);
- fprintf(f, "registers: \n");
- for(i = 0; i < len; ++i) {
- const arch_register_t *reg = arch_irn_get_register(node, i);
- fprintf(f, "#%d: %s\n", i, reg != NULL ? reg->name : "n/a");
+ for (i = 0; i < len; ++i) {
+ const arch_register_req_t *req = &a->reg_data[i].in_req;
+ if (req->cls == NULL)
+ continue;
+ fprintf(F, "inreq #%d = ", i);
+ arch_dump_register_req(F, req, node);
+ fputs("\n", F);
}
- fprintf(f, "in requirements:\n");
- for(i = 0; i < len; ++i) {
- dump_node_req(f, i, &a->reg_data[i].in_req.req, node);
+ for (i = 0; i < len; ++i) {
+ const arch_register_req_t *req = &a->reg_data[i].req;
+ if (req->cls == NULL)
+ continue;
+ fprintf(F, "outreq #%d = ", i);
+ arch_dump_register_req(F, req, node);
+ fputs("\n", F);
}
- fprintf(f, "\nout requirements:\n");
- for(i = 0; i < len; ++i) {
- dump_node_req(f, i, &a->reg_data[i].req.req, node);
+ fputs("\n", F);
+
+ for (i = 0; i < len; ++i) {
+ const arch_register_t *reg = arch_irn_get_register(node, i);
+ fprintf(F, "reg #%d = %s\n", i, reg != NULL ? reg->name : "n/a");
}
}
switch(reason) {
case dump_node_opcode_txt:
- fprintf(f, get_op_name(get_irn_op(irn)));
+ fputs(get_op_name(get_irn_op(irn)), f);
break;
case dump_node_mode_txt:
if(be_is_Perm(irn) || be_is_Copy(irn) || be_is_CopyKeep(irn)) {
for(i = 0; i < len; ++i) {
const be_reg_data_t *rd = &old_attr->reg_data[i];
be_reg_data_t *newrd = &new_attr->reg_data[i];
- if(arch_register_req_is(&rd->req.req, limited)) {
- const arch_register_req_t *req = &rd->req.req;
- arch_register_req_t *new_req = &newrd->req.req;
+ if (arch_register_req_is(&rd->req, limited)) {
+ const arch_register_req_t *req = &rd->req;
+ arch_register_req_t *new_req = &newrd->req;
new_req->limited
= rbitset_duplicate_obstack_alloc(obst, req->limited, req->cls->n_regs);
}
- if(arch_register_req_is(&rd->in_req.req, limited)) {
- const arch_register_req_t *req = &rd->in_req.req;
- arch_register_req_t *new_req = &newrd->in_req.req;
+ if(arch_register_req_is(&rd->in_req, limited)) {
+ const arch_register_req_t *req = &rd->in_req;
+ arch_register_req_t *new_req = &newrd->in_req;
new_req->limited
= rbitset_duplicate_obstack_alloc(obst, req->limited, req->cls->n_regs);
}
return get_op_ops(get_irn_op(irn))->be_ops == &be_node_irn_ops;
}
-void be_node_init(void) {
- static int inited = 0;
-
- if(inited)
- return;
-
- inited = 1;
+void be_init_op(void)
+{
+ ir_opcode opc;
/* Acquire all needed opcodes. */
op_be_Spill = new_ir_op(beo_Spill, "be_Spill", op_pin_state_pinned, N, oparity_unary, 0, sizeof(be_frame_attr_t), &be_node_op_ops);
op_be_Perm = new_ir_op(beo_Perm, "be_Perm", op_pin_state_pinned, N, oparity_variable, 0, sizeof(be_node_attr_t), &be_node_op_ops);
op_be_MemPerm = new_ir_op(beo_MemPerm, "be_MemPerm", op_pin_state_pinned, N, oparity_variable, 0, sizeof(be_memperm_attr_t), &be_node_op_ops);
op_be_Copy = new_ir_op(beo_Copy, "be_Copy", op_pin_state_floats, N, oparity_unary, 0, sizeof(be_node_attr_t), &be_node_op_ops);
- op_be_Keep = new_ir_op(beo_Keep, "be_Keep", op_pin_state_pinned, K, oparity_dynamic, 0, sizeof(be_node_attr_t), &be_node_op_ops);
- op_be_CopyKeep = new_ir_op(beo_CopyKeep, "be_CopyKeep", op_pin_state_pinned, K, oparity_variable, 0, sizeof(be_node_attr_t), &be_node_op_ops);
+ op_be_Keep = new_ir_op(beo_Keep, "be_Keep", op_pin_state_floats, K, oparity_dynamic, 0, sizeof(be_node_attr_t), &be_node_op_ops);
+ op_be_CopyKeep = new_ir_op(beo_CopyKeep, "be_CopyKeep", op_pin_state_floats, K, oparity_variable, 0, sizeof(be_node_attr_t), &be_node_op_ops);
op_be_Call = new_ir_op(beo_Call, "be_Call", op_pin_state_pinned, F|M, oparity_variable, 0, sizeof(be_call_attr_t), &be_node_op_ops);
op_be_Return = new_ir_op(beo_Return, "be_Return", op_pin_state_pinned, X, oparity_dynamic, 0, sizeof(be_return_attr_t), &be_node_op_ops);
op_be_AddSP = new_ir_op(beo_AddSP, "be_AddSP", op_pin_state_pinned, N, oparity_unary, 0, sizeof(be_node_attr_t), &be_node_op_ops);
op_be_FrameAddr->ops.node_cmp_attr = FrameAddr_cmp_attr;
op_be_Barrier->ops.node_cmp_attr = node_cmp_attr;
op_be_Unwind->ops.node_cmp_attr = node_cmp_attr;
+
+ /* attach out dummy_ops to middle end nodes */
+ for (opc = iro_First; opc <= iro_Last; ++opc) {
+ ir_op *op = get_irp_opcode(opc);
+ assert(op->ops.be_ops == NULL);
+ op->ops.be_ops = &dummy_be_irn_ops;
+ }
+
+ op_Phi->ops.be_ops = &phi_irn_ops;
}
projects / libfirm / blobdiff