X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbespill.h;h=dc6b475823365bac1e1dd78c08a0e4f6b6d76f9f;hb=b38e2c8fb2d6b9f713f0948a536a28b623b0732b;hp=75a539b5b6868de6954127b9d484827f9510c49f;hpb=4f7329d7d8d3c676f076459a45a6d5ccf9c6fbba;p=libfirm diff --git a/ir/be/bespill.h b/ir/be/bespill.h index 75a539b5b..dc6b47582 100644 --- a/ir/be/bespill.h +++ b/ir/be/bespill.h @@ -1,159 +1,57 @@ /* - * 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. - * - * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE - * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR - * PURPOSE. + * Copyright (C) 2012 University of Karlsruhe. */ /** * @file - * @brief higher level abstraction for the creation of spill and reload - * instructions and rematerialisation of values. - * @author Daniel Grund, Sebastian Hack, Matthias Braun - * @date 29.09.2005 - * @version $Id$ + * @brief Option handling for spiller. + * @author Matthias Braun + * @date 12.10.2006 */ #ifndef FIRM_BE_BESPILL_H #define FIRM_BE_BESPILL_H -#include "firm_types.h" -#include "debug.h" - #include "bearch.h" -#include "beirg.h" - -typedef struct spill_env_t spill_env_t; - -/** - * Creates a new spill environment. - */ -spill_env_t *be_new_spill_env(be_irg_t *birg); - -/** - * Deletes a spill environment. - */ -void be_delete_spill_env(spill_env_t *senv); -ir_node *be_get_end_of_block_insertion_point(const ir_node *block); +extern int be_coalesce_spill_slots; +extern int be_do_remats; /** - * marks a point until which a node must be spilled + * An entry in the list of spill-algorithms. */ -void be_add_spill(spill_env_t *senv, ir_node *to_spill, ir_node *before); +typedef struct be_spiller_t { + /** + * The spill function. + * + * @param irg the graph to spill on + * @param cls the register class to spill + */ + void (*spill)(ir_graph *irg, const arch_register_class_t *cls); +} be_spiller_t; /** - * Inserts a new entry into the list of reloads to place (the real nodes will - * be created when be_insert_spills_reloads is run). You don't have to - * explicitly create spill nodes, they will be created automatically after - * the definition of a value as soon as a reload is created. (we should add a - * possibility for explicit spill placement in the future) + * Register a new spill algorithm. * - * @param senv The spill environment - * @param to_spill The node which is about to be spilled - * @param before The node before the reload should be added - * @param reload_cls The register class the reloaded value will be put into - * @param allow_remat Set to 1 if the node may be rematerialized instead of - * reloaded - */ -void be_add_reload(spill_env_t *senv, ir_node *to_spill, ir_node *before, - const arch_register_class_t *reload_cls, int allow_remat); - -void be_add_reload2(spill_env_t *senv, ir_node *to_spill, ir_node *before, ir_node *can_spill_after, - const arch_register_class_t *reload_cls, int allow_remat); - -/** - * Add a reload at the end of a block. - * Similar to be_add_reload_on_edge(). - */ -void be_add_reload_at_end(spill_env_t *env, ir_node *to_spill, const ir_node *block, - const arch_register_class_t *reload_cls, - int allow_remat); - -/** - * Analog to be_add_reload, but places the reload "on an edge" between 2 blocks - * @see be_add_reload - */ -void be_add_reload_on_edge(spill_env_t *senv, ir_node *to_spill, ir_node *bl, - int pos, const arch_register_class_t *reload_cls, - int allow_remat); - -/** - * Analog to be_add_reload but adds an already created rematerialized node. - */ -void be_add_remat(spill_env_t *env, ir_node *to_spill, ir_node *before, - ir_node *rematted_node); - -/** - * The main function that places real spills/reloads (or rematerializes values) - * for all values where be_add_reload was called. It then rebuilds the - * SSA-form and updates liveness information - */ -void be_insert_spills_reloads(spill_env_t *senv); - -/** - * There are 2 possibilities to spill a phi node: Only it's value, or replacing - * the whole phi-node with a memory phi. Normally only the value of a phi will - * be spilled unless you mark the phi with be_spill_phi. - * (Remember that each phi needs a register, so you have to spill phis when - * there are more phis than registers in a block) - */ -void be_spill_phi(spill_env_t *env, ir_node *node); - -/** - * Returns the estimated costs if a node would ge spilled. This does only return - * the costs for the spill instructions, not the costs for needed reload - * instructions. The value is weighted by the estimated execution frequency of - * the spill. - */ -double be_get_spill_costs(spill_env_t *env, ir_node *to_spill, ir_node *before); - -/** - * Returns the estimated costs if a node would get reloaded at a specific place - * This returns the costs for a reload instructions, or when possible the costs - * for a rematerialisation. The value is weighted by the estimated execution - * frequency of the reload/rematerialisation. - */ -double be_get_reload_costs(spill_env_t *env, ir_node *to_spill, - ir_node *before); - -/** - * Analog to be_get_reload_costs but returns the cost if the reload would be - * placed "on an edge" between 2 blocks + * @param name the name of the spill algorithm, + * used to select it + * @param spiller a spill entry */ -double be_get_reload_costs_on_edge(spill_env_t *env, ir_node *to_spill, - ir_node *block, int pos); - -typedef struct { - unsigned n_spills; - unsigned n_reloads; - double spill_costs; - double reload_costs; -} be_total_spill_costs_t; +void be_register_spiller(const char *name, be_spiller_t *spiller); /** - * Collect spill/reload cost statistics for a graph. - * @param birg The backend graph. - * @param costs A struct which will be filled with the costs. + * Execute the selected spill algorithm + * + * @param irg the graph to spill on + * @param cls the register class to spill */ -void be_get_total_spill_costs(be_irg_t *birg, be_total_spill_costs_t *costs); +void be_do_spill(ir_graph *irg, const arch_register_class_t *cls); /** - * Check, if a node is rematerializable. - * @param env The spill env. - + * Adds additional copies, so constraints needing additional registers to be + * solved correctly induce the additional register pressure. */ -int be_is_rematerializable(spill_env_t *env, const ir_node *to_remat, const ir_node *before); +void be_pre_spill_prepare_constr(ir_graph *irg, + const arch_register_class_t *cls); #endif