X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbeinsn.c;h=4eee0429573ad920c547e3c90da9c2ff23d9ad6e;hb=07ea816fa30005a2e1e94171090327233e05a112;hp=34c239d74f7c15bce1e9f154922e75ebd5bbf227;hpb=44f25648d311cfdf958fa5d1ed20659b250e0eac;p=libfirm diff --git a/ir/be/beinsn.c b/ir/be/beinsn.c index 34c239d74..4eee04295 100644 --- a/ir/be/beinsn.c +++ b/ir/be/beinsn.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 1995-2007 University of Karlsruhe. All right reserved. + * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved. * * This file is part of libFirm. * @@ -23,18 +23,16 @@ * @author Sebastian Hack * @version $Id$ */ -#ifdef HAVE_CONFIG_H #include "config.h" -#endif #include "irgraph_t.h" #include "irmode_t.h" #include "irnode_t.h" #include "iredges.h" -#include "besched_t.h" +#include "besched.h" #include "beinsn_t.h" -#include "beirg_t.h" +#include "beirg.h" #include "beabi.h" #include "raw_bitset.h" @@ -45,9 +43,9 @@ * @param insn the be_insn that is build * @param mach_op the machine operand for which uses are added */ -static void add_machine_operands(const be_insn_env_t *env, be_insn_t *insn, ir_node *mach_op) { - const arch_env_t *arch_env = env->aenv; - struct obstack *obst = env->obst; +static void add_machine_operands(const be_insn_env_t *env, be_insn_t *insn, ir_node *mach_op) +{ + struct obstack *obst = env->obst; int i, n; for (i = 0, n = get_irn_arity(mach_op); i < n; ++i) { @@ -55,11 +53,11 @@ static void add_machine_operands(const be_insn_env_t *env, be_insn_t *insn, ir_n if (is_irn_machine_operand(op)) { add_machine_operands(env, insn, op); - } else if (arch_irn_consider_in_reg_alloc(arch_env, env->cls, op)) { + } else if (arch_irn_consider_in_reg_alloc(env->cls, op)) { be_operand_t o; /* found a register use, create an operand */ - o.req = arch_get_register_req(arch_env, mach_op, i); + o.req = arch_get_register_req(mach_op, i); o.carrier = op; o.irn = insn->irn; o.pos = i; @@ -82,15 +80,13 @@ static void add_machine_operands(const be_insn_env_t *env, be_insn_t *insn, ir_n */ be_insn_t *be_scan_insn(const be_insn_env_t *env, ir_node *irn) { - const arch_env_t *arch_env = env->aenv; - struct obstack *obst = env->obst; + struct obstack *obst = env->obst; be_operand_t o; be_insn_t *insn; int i, n; int pre_colored = 0; - insn = obstack_alloc(obst, sizeof(insn[0])); - memset(insn, 0, sizeof(insn[0])); + insn = OALLOCZ(obst, be_insn_t); insn->irn = irn; insn->next_insn = sched_next(irn); @@ -107,9 +103,9 @@ be_insn_t *be_scan_insn(const be_insn_env_t *env, ir_node *irn) in the backend, but check it for now. */ assert(get_irn_mode(p) != mode_T); - if (arch_irn_consider_in_reg_alloc(arch_env, env->cls, p)) { + if (arch_irn_consider_in_reg_alloc(env->cls, p)) { /* found a def: create a new operand */ - o.req = arch_get_register_req(arch_env, p, -1); + o.req = arch_get_register_req_out(p); o.carrier = p; o.irn = irn; o.pos = -(get_Proj_proj(p) + 1); @@ -118,20 +114,12 @@ be_insn_t *be_scan_insn(const be_insn_env_t *env, ir_node *irn) obstack_grow(obst, &o, sizeof(o)); insn->n_ops++; insn->out_constraints |= o.has_constraints; - pre_colored += arch_get_irn_register(arch_env, p) != NULL; + pre_colored += arch_get_irn_register(p) != NULL; } } - -#ifdef SCHEDULE_PROJS - /* When Proj's are scheduled, so we need to find the first - non-Proj instruction in the schedule */ - for (p = sched_next(irn); is_Proj(p); p = sched_next(p)); - insn->next_insn = p; -#endif - - } else if (arch_irn_consider_in_reg_alloc(arch_env, env->cls, irn)) { + } else if (arch_irn_consider_in_reg_alloc(env->cls, irn)) { /* only one def, create one operand */ - o.req = arch_get_register_req(arch_env, irn, -1); + o.req = arch_get_register_req_out(irn); o.carrier = irn; o.irn = irn; o.pos = -1; @@ -140,7 +128,7 @@ be_insn_t *be_scan_insn(const be_insn_env_t *env, ir_node *irn) obstack_grow(obst, &o, sizeof(o)); insn->n_ops++; insn->out_constraints |= o.has_constraints; - pre_colored += arch_get_irn_register(arch_env, irn) != NULL; + pre_colored += arch_get_irn_register(irn) != NULL; } if (pre_colored > 0) { @@ -155,9 +143,9 @@ be_insn_t *be_scan_insn(const be_insn_env_t *env, ir_node *irn) if (is_irn_machine_operand(op)) { add_machine_operands(env, insn, op); - } else if (arch_irn_consider_in_reg_alloc(arch_env, env->cls, op)) { + } else if (arch_irn_consider_in_reg_alloc(env->cls, op)) { /* found a register use, create an operand */ - o.req = arch_get_register_req(arch_env, irn, i); + o.req = arch_get_register_req(irn, i); o.carrier = op; o.irn = irn; o.pos = i; @@ -170,7 +158,7 @@ be_insn_t *be_scan_insn(const be_insn_env_t *env, ir_node *irn) } insn->has_constraints = insn->in_constraints | insn->out_constraints; - insn->ops = obstack_finish(obst); + insn->ops = (be_operand_t*)obstack_finish(obst); /* Compute the admissible registers bitsets. */ for (i = 0; i < insn->n_ops; ++i) { @@ -187,29 +175,14 @@ be_insn_t *be_scan_insn(const be_insn_env_t *env, ir_node *irn) assert(cls == env->cls); - op->regs = bitset_obstack_alloc(obst, env->cls->n_regs); - if (type & arch_register_req_type_limited) { - rbitset_copy_to_bitset(req->limited, op->regs); + bitset_t *regs = bitset_obstack_alloc(obst, env->cls->n_regs); + rbitset_copy_to_bitset(req->limited, regs); + op->regs = regs; } else { - arch_put_non_ignore_regs(arch_env, env->cls, op->regs); - if (env->ignore_colors) - bitset_andnot(op->regs, env->ignore_colors); + op->regs = env->allocatable_regs; } } return insn; } - -be_insn_env_t *be_insn_env_init(be_insn_env_t *ie, const be_irg_t *birg, - const arch_register_class_t *cls, - struct obstack *obst) -{ - ie->aenv = be_get_birg_arch_env(birg); - ie->cls = cls; - ie->obst = obst; - ie->ignore_colors = bitset_obstack_alloc(obst, cls->n_regs); - be_abi_put_ignore_regs(birg->abi, cls, ie->ignore_colors); - - return ie; -}