+ return res;
+}
+
+int be_has_frame_entity(const ir_node *irn)
+{
+ switch (get_irn_opcode(irn)) {
+ case beo_Spill:
+ case beo_Reload:
+ case beo_FrameAddr:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+ir_entity *be_get_frame_entity(const ir_node *irn)
+{
+ if (be_has_frame_entity(irn)) {
+ const be_frame_attr_t *a = get_irn_attr_const(irn);
+ return a->ent;
+ }
+ return NULL;
+}
+
+int be_get_frame_offset(const ir_node *irn)
+{
+ assert(is_be_node(irn));
+ if (be_has_frame_entity(irn)) {
+ const be_frame_attr_t *a = get_irn_attr_const(irn);
+ return a->offset;
+ }
+ return 0;
+}
+
+void be_set_MemPerm_in_entity(const ir_node *irn, int n, ir_entity *ent)
+{
+ const be_memperm_attr_t *attr = get_irn_attr_const(irn);
+
+ assert(be_is_MemPerm(irn));
+ assert(n < be_get_MemPerm_entity_arity(irn));
+
+ attr->in_entities[n] = ent;
+}
+
+ir_entity* be_get_MemPerm_in_entity(const ir_node* irn, int n)
+{
+ const be_memperm_attr_t *attr = get_irn_attr_const(irn);
+
+ assert(be_is_MemPerm(irn));
+ assert(n < be_get_MemPerm_entity_arity(irn));
+
+ return attr->in_entities[n];
+}
+
+void be_set_MemPerm_out_entity(const ir_node *irn, int n, ir_entity *ent)
+{
+ const be_memperm_attr_t *attr = get_irn_attr_const(irn);
+
+ assert(be_is_MemPerm(irn));
+ assert(n < be_get_MemPerm_entity_arity(irn));
+
+ attr->out_entities[n] = ent;
+}
+
+ir_entity* be_get_MemPerm_out_entity(const ir_node* irn, int n)
+{
+ const be_memperm_attr_t *attr = get_irn_attr_const(irn);
+
+ assert(be_is_MemPerm(irn));
+ assert(n < be_get_MemPerm_entity_arity(irn));
+
+ return attr->out_entities[n];
+}
+
+int be_get_MemPerm_entity_arity(const ir_node *irn)
+{
+ return get_irn_arity(irn) - 1;
+}
+
+void be_set_constr_single_reg(ir_node *node, int pos, const arch_register_t *reg)
+{
+ arch_register_req_t *req = get_req(node, pos);
+ const arch_register_class_t *cls = arch_register_get_class(reg);
+ ir_graph *irg = get_irn_irg(node);
+ struct obstack *obst = get_irg_obstack(irg);
+ unsigned *limited_bitset;
+
+ assert(req->cls == NULL || req->cls == cls);
+ assert(! (req->type & arch_register_req_type_limited));
+ assert(req->limited == NULL);
+
+ limited_bitset = rbitset_obstack_alloc(obst, arch_register_class_n_regs(cls));
+ rbitset_set(limited_bitset, arch_register_get_index(reg));
+
+ req->cls = cls;
+ req->type |= arch_register_req_type_limited;
+ req->limited = limited_bitset;
+}
+
+void be_set_constr_limited(ir_node *node, int pos, const arch_register_req_t *req)
+{
+ ir_graph *irg = get_irn_irg(node);
+ struct obstack *obst = get_irg_obstack(irg);
+ arch_register_req_t *r = get_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)));
+ memcpy(r, req, sizeof(r[0]));
+ r->limited = rbitset_duplicate_obstack_alloc(obst, req->limited, req->cls->n_regs);
+}
+
+void be_node_set_flags(ir_node *irn, int pos, arch_irn_flags_t flags)
+{
+ be_req_t *bereq = get_be_req(irn, pos);
+ bereq->flags = flags;
+}
+
+void be_node_add_flags(ir_node *irn, int pos, arch_irn_flags_t flags)
+{
+ be_req_t *bereq = get_be_req(irn, pos);
+ bereq->flags |= flags;
+}
+
+void be_node_set_reg_class(ir_node *irn, int pos, const arch_register_class_t *cls)
+{
+ arch_register_req_t *req = get_req(irn, pos);
+
+ req->cls = cls;
+
+ if (cls == NULL) {
+ req->type = arch_register_req_type_none;
+ } else if (req->type == arch_register_req_type_none) {
+ req->type = arch_register_req_type_normal;
+ }
+}
+
+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);
+ req->type = type;
+}
+
+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) {
+ assert(be_is_IncSP(incsp));
+ set_irn_n(incsp, 0, pred);
+}
+
+void be_set_IncSP_offset(ir_node *irn, int offset)
+{
+ be_incsp_attr_t *a = get_irn_attr(irn);
+ assert(be_is_IncSP(irn));
+ a->offset = offset;
+}
+
+int be_get_IncSP_offset(const ir_node *irn)
+{
+ const be_incsp_attr_t *a = get_irn_attr_const(irn);
+ assert(be_is_IncSP(irn));
+ return a->offset;
+}
+
+int be_get_IncSP_align(const ir_node *irn)
+{
+ const be_incsp_attr_t *a = get_irn_attr_const(irn);
+ assert(be_is_IncSP(irn));
+ return a->align;
+}
+
+ir_node *be_spill(ir_node *block, ir_node *irn)
+{
+ ir_graph *irg = get_irn_irg(block);
+ ir_node *frame = get_irg_frame(irg);
+ const arch_register_class_t *cls = arch_get_irn_reg_class(irn, -1);
+ const arch_register_class_t *cls_frame = arch_get_irn_reg_class(frame, -1);
+ ir_node *spill;
+
+ spill = be_new_Spill(cls, cls_frame, irg, block, frame, irn);