X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbespilldaemel.c;h=4f058bf4f53ac09d6abc177d28df2c5b0da4004f;hb=5474a1c188c9d59eea2c915515980cd9cbab58d8;hp=6454b1fdb6f1f54c318eff3e70f81e8da8356ae6;hpb=8a40be4492274e2799181e4ce950b33b367a59ef;p=libfirm diff --git a/ir/be/bespilldaemel.c b/ir/be/bespilldaemel.c index 6454b1fdb..4f058bf4f 100644 --- a/ir/be/bespilldaemel.c +++ b/ir/be/bespilldaemel.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved. + * Copyright (C) 1995-2011 University of Karlsruhe. All right reserved. * * This file is part of libFirm. * @@ -22,7 +22,6 @@ * @brief Naive spilling algorithm * @author Matthias Braun * @date 20.09.2005 - * @version $Id: bespillbelady.c 13913 2007-05-18 12:48:56Z matze $ * @brief * This implements a naive spilling algorithm. It is designed to produce * similar effects to the spill decisions produced by traditional graph @@ -57,7 +56,7 @@ DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;) static spill_env_t *spill_env; -static int n_regs; +static unsigned n_regs; static const arch_register_class_t *cls; static const be_lv_t *lv; static bitset_t *spilled_nodes; @@ -70,8 +69,8 @@ struct spill_candidate_t { static int compare_spill_candidates_desc(const void *d1, const void *d2) { - const spill_candidate_t *c1 = d1; - const spill_candidate_t *c2 = d2; + const spill_candidate_t *c1 = (const spill_candidate_t*)d1; + const spill_candidate_t *c2 = (const spill_candidate_t*)d2; return (int) (c1->costs - c2->costs); } @@ -133,6 +132,12 @@ static void spill_node(ir_node *node) bitset_set(spilled_nodes, get_irn_idx(node)); } +static unsigned get_value_width(const ir_node *node) +{ + const arch_register_req_t *req = arch_get_irn_register_req(node); + return req->width; +} + /** * spill @p n nodes from a nodeset. Removes the nodes from the nodeset and * sets the spilled bits in spilled_nodes. @@ -144,15 +149,16 @@ static void do_spilling(ir_nodeset_t *live_nodes, ir_node *node) size_t free_regs_needed = 0; spill_candidate_t *candidates; ir_nodeset_iterator_t iter; - size_t i, arity; + int i, arity; + size_t c; int spills_needed; size_t cand_idx; ir_node *n; ir_node *value; be_foreach_definition(node, cls, value, - assert(req_->width == 1); /* no support for wide-values yet */ - ++values_defined; + assert(req_->width >= 1); + values_defined += req_->width; ); /* we need registers for the non-live argument values */ @@ -161,7 +167,7 @@ static void do_spilling(ir_nodeset_t *live_nodes, ir_node *node) ir_node *pred = get_irn_n(node, i); if (arch_irn_consider_in_reg_alloc(cls, pred) && !ir_nodeset_contains(live_nodes, pred)) { - ++free_regs_needed; + free_regs_needed += get_value_width(pred); } } @@ -178,17 +184,17 @@ static void do_spilling(ir_nodeset_t *live_nodes, ir_node *node) candidates = ALLOCAN(spill_candidate_t, n_live_nodes); /* construct array with spill candidates and calculate their costs */ - i = 0; + c = 0; foreach_ir_nodeset(live_nodes, n, iter) { - spill_candidate_t *candidate = & candidates[i]; + spill_candidate_t *candidate = & candidates[c]; assert(!bitset_is_set(spilled_nodes, get_irn_idx(n))); candidate->node = n; candidate->costs = get_spill_costs(n); - ++i; + ++c; } - assert(i == n_live_nodes); + assert(c == n_live_nodes); /* sort spill candidates */ qsort(candidates, n_live_nodes, sizeof(candidates[0]), @@ -197,9 +203,9 @@ static void do_spilling(ir_nodeset_t *live_nodes, ir_node *node) /* spill cheapest ones */ cand_idx = 0; while (spills_needed > 0) { - bool is_use = false; - spill_candidate_t *candidate; - ir_node *cand_node; + bool is_use = false; + spill_candidate_t *candidate; + ir_node *cand_node; if (cand_idx >= n_live_nodes) { panic("can't spill enough values for node %+F", node); @@ -220,13 +226,12 @@ static void do_spilling(ir_nodeset_t *live_nodes, ir_node *node) break; } } - if (is_use) { + if (is_use) continue; - } spill_node(cand_node); ir_nodeset_remove(live_nodes, cand_node); - --spills_needed; + spills_needed -= get_value_width(cand_node); } } @@ -282,6 +287,7 @@ static void spill_block(ir_node *block, void *data) ir_node *node; int n_phi_values_spilled; int regpressure; + int live_nodes_pressure; int phi_spills_needed; (void) data; @@ -322,12 +328,17 @@ static void spill_block(ir_node *block, void *data) break; if (bitset_is_set(spilled_nodes, get_irn_idx(node))) { - ++n_phi_values_spilled; + n_phi_values_spilled += get_value_width(node); } } + live_nodes_pressure = 0; + foreach_ir_nodeset(&live_nodes, node, iter) { + live_nodes_pressure += get_value_width(node); + } + /* calculate how many of the phis need to be spilled */ - regpressure = ir_nodeset_size(&live_nodes) + n_phi_values_spilled; + regpressure = live_nodes_pressure + n_phi_values_spilled; phi_spills_needed = regpressure - n_regs; DBG((dbg, LEVEL_3, "Regpressure before phis: %d phispills: %d\n", regpressure, phi_spills_needed)); @@ -341,10 +352,11 @@ static void spill_block(ir_node *block, void *data) if (phi_spills_needed <= 0) break; - if (bitset_is_set(spilled_nodes, get_irn_idx(node))) { - be_spill_phi(spill_env, node); - --phi_spills_needed; - } + if (!bitset_is_set(spilled_nodes, get_irn_idx(node))) + continue; + + be_spill_phi(spill_env, node); + phi_spills_needed -= get_value_width(node); } assert(phi_spills_needed <= 0); @@ -353,11 +365,11 @@ static void spill_block(ir_node *block, void *data) static void be_spill_daemel(ir_graph *irg, const arch_register_class_t *new_cls) { - n_regs = new_cls->n_regs - be_put_ignore_regs(irg, new_cls, NULL); + n_regs = be_get_n_allocatable_regs(irg, new_cls); if (n_regs == 0) return; - be_liveness_assure_sets(be_assure_liveness(irg)); + be_assure_live_sets(irg); spill_env = be_new_spill_env(irg); cls = new_cls; @@ -374,7 +386,7 @@ static void be_spill_daemel(ir_graph *irg, const arch_register_class_t *new_cls) be_delete_spill_env(spill_env); } -BE_REGISTER_MODULE_CONSTRUCTOR(be_init_daemelspill); +BE_REGISTER_MODULE_CONSTRUCTOR(be_init_daemelspill) void be_init_daemelspill(void) { static be_spiller_t daemel_spiller = {