-/**
- * Author: Daniel Grund
- * Date: 17.01.2006
- * Copyright: (c) Universitaet Karlsruhe
- * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE.
+/*
+ * Copyright (C) 1995-2007 University of Karlsruhe. All right reserved.
+ *
+ * This file is part of libFirm.
+ *
+ * This file may be distributed and/or modified under the terms of the
+ * GNU General Public License version 2 as published by the Free Software
+ * Foundation and appearing in the file LICENSE.GPL included in the
+ * packaging of this file.
+ *
+ * Licensees holding valid libFirm Professional Edition licenses may use
+ * this file in accordance with the libFirm Commercial License.
+ * Agreement provided with the Software.
*
- * Implementation of the RA-Interface for an external, (non-SSA) register allocator.
+ * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+ * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE.
+ */
+
+/**
+ * @file
+ * @brief Implementation of the RA-Interface for an external, (non-SSA) register allocator.
+ * @author Daniel Grund
+ * @date 17.01.2006
+ * @version $Id$
*
* The external register allocator is a program:
* PROG -i INPUTFILE -o OUTPUTFILE
alloc ::= node-nr reg-nr .
-
-******** End of file format docu ********/
-
+*/
+#ifdef NOT_PORTED
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
-#ifdef HAVE_MALLOC_H
- #include <malloc.h>
-#endif
-#ifdef HAVE_ALLOCA_H
- #include <alloca.h>
-#endif
-
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
-#ifdef WITH_LIBCORE
#include <libcore/lc_opts.h>
#include <libcore/lc_opts_enum.h>
-#endif
#include "set.h"
#include "pset.h"
#include "pmap.h"
#include "bitset.h"
+#include "raw_bitset.h"
+#include "xmalloc.h"
#include "irprintf_t.h"
#include "irnode_t.h"
#include "irdom_t.h"
#include "phiclass.h"
-#include "beraextern.h"
+#include "bemodule.h"
#include "beabi.h"
-#include "bearch.h"
+#include "bearch_t.h"
#include "benode_t.h"
#include "beirgmod.h"
#include "besched_t.h"
typedef struct _be_raext_env_t {
arch_env_t *aenv;
const arch_register_class_t *cls;
+ be_irg_t *birg;
ir_graph *irg;
- dom_front_info_t *dom_info;
FILE *f; /**< file handle used for out- and input file */
set *vars; /**< contains all be_var_info_t */
be_operand_t *op = &insn->ops[i];
if(op->has_constraints) {
- ir_node *cpy = be_new_Copy(op->req.cls, env->irg, bl, op->carrier);
+ ir_node *cpy = be_new_Copy(op->req->cls, env->irg, bl, op->carrier);
sched_add_before(insn->next_insn, cpy);
edges_reroute(op->carrier, cpy, env->irg);
}
be_operand_t *op = &insn->ops[i];
if(op->has_constraints) {
- ir_node *cpy = be_new_Copy(op->req.cls, env->irg, bl, op->carrier);
+ ir_node *cpy = be_new_Copy(op->req->cls, env->irg, bl, op->carrier);
sched_add_before(insn->irn, cpy);
set_irn_n(insn->irn, op->pos, cpy);
- be_set_constr_limited(cpy, BE_OUT_POS(0), &op->req);
+ be_set_constr_limited(cpy, BE_OUT_POS(0), op->req);
}
}
}
* If yes, dump it to FILE raenv->f
*/
static INLINE void dump_constraint(be_raext_env_t *raenv, ir_node *irn, int pos) {
- bitset_t *bs = bitset_alloca(raenv->cls->n_regs);
- arch_register_req_t req;
-
- arch_get_register_req(raenv->aenv, &req, irn, pos);
- if (arch_register_req_is(&req, limited)) {
- int reg_nr;
- req.limited(req.limited_env, bs);
- reg_nr = bitset_next_set(bs, 0);
+ const arch_register_req_t *req;
+
+ req = arch_get_register_req(raenv->aenv, irn, pos);
+ if (arch_register_req_is(req, limited)) {
+ unsigned reg_nr;
+
+ reg_nr = rbitset_next(req->limited, 0, 1);
fprintf(raenv->f, "<%d>", reg_nr);
- assert(-1 == bitset_next_set(bs, reg_nr+1) && "Constraints with more than 1 possible register are not supported");
+ assert(rbitset_popcnt(req->limited, raenv->cls->n_regs) <= 1
+ && "Constraints with more than 1 possible register are not supported");
}
}
be_var_info_t *vi1, *vi2;
ir_node *irn1, *irn2;
FILE *f = raenv->f;
+ be_lv_t *lv = raenv->birg->lv;
fprintf(f, "\ninterferences {\n");
pset_foreach(vi1->values, irn1)
pset_foreach(vi2->values, irn2)
- if (values_interfere(irn1, irn2)) {
+ if (values_interfere(lv, irn1, irn2)) {
pset_break(vi1->values);
pset_break(vi2->values);
fprintf(f, "(%d, %d)\n", vi1->var_nr, vi2->var_nr);
static void dump_affinities_walker(ir_node *irn, void *env) {
be_raext_env_t *raenv = env;
- arch_register_req_t req;
+ const arch_register_req_t *req;
int pos, max;
be_var_info_t *vi1, *vi2;
vi1 = be_get_var_info(irn);
/* copies have affinities */
- if (arch_irn_classify(raenv->aenv, irn) == arch_irn_class_copy) {
+ if (arch_irn_class_is(raenv->aenv, irn, copy)) {
ir_node *other = be_get_Copy_op(irn);
if (! arch_irn_is(raenv->aenv, other, ignore)) {
/* should_be_equal constraints are affinites */
for (pos = 0, max = get_irn_arity(irn); pos<max; ++pos) {
- arch_get_register_req(raenv->aenv, &req, irn, pos);
+ req = arch_get_register_req(raenv->aenv, irn, pos);
- if (arch_register_req_is(&req, should_be_same) && arch_irn_is(raenv->aenv, req.other_same, ignore)) {
- vi2 = be_get_var_info(req.other_same);
+ if (arch_register_req_is(req, should_be_same)) {
+ ir_node *other = get_irn_n(skip_Proj(irn), req->other_same);
+ if(arch_irn_is(raenv->aenv, other, ignore)) {
+ vi2 = be_get_var_info(other);
- fprintf(raenv->f, "(%d, %d, %d)\n", vi1->var_nr, vi2->var_nr, get_affinity_weight(irn));
+ fprintf(raenv->f, "(%d, %d, %d)\n", vi1->var_nr, vi2->var_nr, get_affinity_weight(irn));
+ }
}
}
}
int ret_status;
snprintf(cmd_line, sizeof(cmd_line), "%s -i %s -o %s", prog_to_call, out_file, result_file);
+ cmd_line[sizeof(cmd_line) - 1] = '\0';
ret_status = system(cmd_line);
assert(ret_status != -1 && "Invokation of external register allocator failed");
const ir_edge_t *edge, *ne;
pset *spills = pset_new_ptr(4); /* the spills of this variable */
pset *reloads = pset_new_ptr(4); /* the reloads of this variable */
+ be_lv_t *lv = raenv->birg->lv;
+ be_dom_front_info_t *dom_front = raenv->birg->dom_front;
int new_size, n_spills, n_reloads;
assert(vi && "Variable nr does not exist!");
/* all ordinary nodes must be spilled */
DBG((raenv->dbg, LEVEL_2, " spilling %+F\n", irn));
- spill = be_spill(raenv->aenv, irn, ctx);
+ spill = be_spill(raenv->aenv, irn);
/* remember the spill */
pset_insert_ptr(spills, spill);
mode = get_irn_mode(get_irn_n(spill, be_pos_Spill_val));
/* insert reloads and wire them arbitrary*/
- pset_foreach(vi->values, irn)
+ pset_foreach(vi->values, irn) {
foreach_out_edge_safe(irn, edge, ne) {
ir_node *reload, *src = edge->src;
if (is_Phi(src) || be_is_Spill(src))
/* remember the reload */
pset_insert_ptr(reloads, reload);
}
+ }
/* correct the reload->spill pointers... */
- be_ssa_constr_set(raenv->dom_info, spills);
+ be_ssa_constr_set_ignore(dom_front, lv, spills, NULL);
/****** correct the variable <--> values mapping: ******
static void check_allocation(be_raext_env_t *raenv) {
int i, o;
+ be_lv_t *lv = raenv->birg->lv;
for (i=0; i<raenv->n_cls_vars; ++i) {
be_var_info_t *vi1 = raenv->cls_vars[i];
pset_foreach(vi1->values, irn1)
pset_foreach(vi2->values, irn2)
- if (values_interfere(irn1, irn2) && arch_get_irn_register(raenv->aenv, irn1) == arch_get_irn_register(raenv->aenv, irn2)) {
+ if (values_interfere(lv, irn1, irn2) && arch_get_irn_register(raenv->aenv, irn1) == arch_get_irn_register(raenv->aenv, irn2)) {
dump_ir_block_graph_sched(raenv->irg, "ERROR");
- ir_fprintf(stdout, "SSA values %+F and %+F interfere. They belong to varible %d and %d respectively.\n", irn1, irn2, vi1->var_nr, vi2->var_nr);
+ ir_fprintf(stdout, "SSA values %+F and %+F interfere. They belong to variable %d and %d respectively.\n", irn1, irn2, vi1->var_nr, vi2->var_nr);
assert(0 && "ERROR graph dumped");
}
}
/**
* Default values for options
*/
-static set* (*ssa_destr)(ir_graph*,const arch_env_t*) = be_ssa_destr_simple;
static char callee[128] = "\"E:/user/kimohoff/public/register allocator\"";
//static char callee[128] = "/ben/kimohoff/ipd-registerallocator/register_allocator";
* Read in results and apply them
*
*/
-static void be_ra_extern_main(const be_irg_t *bi) {
- be_main_env_t *env = bi->main_env;
- ir_graph *irg = bi->irg;
+static void be_ra_extern_main(be_irg_t *birg) {
+ be_main_env_t *env = birg->main_env;
+ ir_graph *irg = birg->irg;
be_raext_env_t raenv;
int clsnr, clss;
- compute_doms(irg);
+ be_assure_dom_front(birg);
+ be_assure_liveness(birg);
edges_assure(irg);
raenv.irg = irg;
+ raenv.birg = birg;
raenv.aenv = env->arch_env;
- raenv.dom_info = be_compute_dominance_frontiers(irg);
FIRM_DBG_REGISTER(raenv.dbg, "firm.be.raextern");
/* Insert copies for constraints */
dump_to_file(&raenv, out);
execute(callee, out, in);
done = read_and_apply_results(&raenv, in);
- be_abi_fix_stack_nodes(bi->abi);
+ be_abi_fix_stack_nodes(birg->abi);
ir_snprintf(in, sizeof(in), "-extern-%s-round-%d", raenv.cls->name, round);
be_dump(irg, in, dump_ir_block_graph_sched);
/* Clean up */
free_ssa_destr_simple(raenv.vars);
- be_free_dominance_frontiers(raenv.dom_info);
+
+ be_liveness_invalidate(be_get_birg_liveness(birg));
}
/******************************************************************************
|_|
*****************************************************************************/
-#ifdef WITH_LIBCORE
-
-
static const lc_opt_enum_func_ptr_items_t ssa_destr_items[] = {
- { "simple", (int (*)()) be_ssa_destr_simple }, /* TODO make (void*) casts nicer */
+ { "simple", (int (*)(void)) be_ssa_destr_simple }, /* TODO make (void*) casts nicer */
{ NULL, NULL }
};
+static set* (*ssa_destr)(ir_graph*,const arch_env_t*) = be_ssa_destr_simple;
+
static lc_opt_enum_func_ptr_var_t ssa_destr_var = {
- (int (**)()) &ssa_destr, ssa_destr_items
+ (int (**)(void)) &ssa_destr, ssa_destr_items
};
static const lc_opt_table_entry_t be_ra_extern_options[] = {
{ NULL }
};
-static void be_ra_extern_register_options(lc_opt_entry_t *root) {
- lc_opt_entry_t *grp = lc_opt_get_grp(root, "ext");
+static be_ra_t be_ra_external_allocator = {
+ be_ra_extern_main
+};
- lc_opt_add_table(grp, be_ra_extern_options);
-}
+void be_init_raextern(void) {
+ lc_opt_entry_t *be_grp = lc_opt_get_grp(firm_opt_get_root(), "be");
+ lc_opt_entry_t *blocksched_grp = lc_opt_get_grp(be_grp, "ra");
+ lc_opt_entry_t *ext_grp = lc_opt_get_grp(blocksched_grp, "ext");
-#endif /* WITH_LIBCORE */
+ lc_opt_add_table(ext_grp, be_ra_extern_options);
-const be_ra_t be_ra_external_allocator = {
-#ifdef WITH_LIBCORE
- be_ra_extern_register_options,
-#endif
- be_ra_extern_main
-};
+ be_register_allocator("ext", &be_ra_external_allocator);
+}
+BE_REGISTER_MODULE_CONSTRUCTOR(be_init_raextern);
+
+#endif /* NOT_PORTED */