X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbespill.h;h=843a0df8dec82a5a4291ca4f6a3efe431e66571c;hb=df2faee01a5832057bb3ca0ba5f67e979c916e19;hp=0273f315d7595e1afae128cee5215639914bdf21;hpb=d016265fdff42dfaf0c2e3875203a9a94177a254;p=libfirm diff --git a/ir/be/bespill.h b/ir/be/bespill.h index 0273f315d..843a0df8d 100644 --- a/ir/be/bespill.h +++ b/ir/be/bespill.h @@ -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. * @@ -19,133 +19,53 @@ /** * @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); +extern int be_coalesce_spill_slots; +extern int be_do_remats; /** - * Deletes a spill environment. + * An entry in the list of spill-algorithms. */ -void be_delete_spill_env(spill_env_t *senv); - -ir_node *be_get_end_of_block_insertion_point(const ir_node *block); +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); - -/** - * 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 *after); - -/** - * 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