X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firopt_t.h;h=468b3822744b9654bc4793e435b63b30a13046d6;hb=daba4aa82ec48b142c6d48d9a4b2d0bfffc92683;hp=eb3bdff80e70e42f0d849cb29fc2ccd1bdb42884;hpb=265829494264529c53e5180a56cc9f1196346385;p=libfirm diff --git a/ir/ir/iropt_t.h b/ir/ir/iropt_t.h index eb3bdff80..468b38227 100644 --- a/ir/ir/iropt_t.h +++ b/ir/ir/iropt_t.h @@ -1,60 +1,182 @@ /* - * Project: libFIRM - * File name: ir/ir/iropt_t.h - * Purpose: iropt --- optimizations intertwined with IR construction -- private header. - * Author: Martin Trapp, Christian Schaefer - * Modified by: Goetz Lindenmaier - * Created: - * CVS-ID: $Id$ - * Copyright: (c) 1998-2003 Universität Karlsruhe - * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE. + * Copyright (C) 1995-2008 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. */ /** -* @file iropt_t.h -* -* Declarations for optimizations intertwined with IR construction. -* -* @author Martin Trapp, Christian Schaefer -*/ + * @file + * @brief iropt --- optimizations intertwined with IR construction -- private header. + * @author Martin Trapp, Christian Schaefer, Goetz Lindenmaier, Michael Beck + */ +#ifndef FIRM_IR_IROPT_T_H +#define FIRM_IR_IROPT_T_H -# ifndef _IROPT_T_H_ -# define _IROPT_T_H_ +#include +#include "irop_t.h" +#include "iropt.h" +#include "irnode_t.h" +#include "pset.h" +#include "tv.h" -# include "pset.h" -# include "iropt.h" +/** + * Calculate a hash value of a node. + * + * @param node The IR-node + */ +unsigned ir_node_hash(const ir_node *node); -ir_node *equivalent_node (ir_node *n); +/** + * equivalent_node() returns a node equivalent to input n. It skips all nodes that + * perform no actual computation, as, e.g., the Id nodes. It does not create + * new nodes. It is therefore safe to free n if the node returned is not n. + * If a node returns a Tuple we can not just skip it. If the size of the + * in array fits, we transform n into a tuple (e.g., Div). + */ +ir_node *equivalent_node(ir_node *n); -/*@{*/ +/** + * Creates a new value table used for storing CSE identities. + * The value table is used to identify common expressions. + */ +void new_identities(ir_graph *irg); -/** For cse */ -pset *new_identities (void); -void del_identities (pset *value_table); -void add_identities (pset *value_table, ir_node *node); -/*@}*/ +/** + * Deletes a identities value table. + * + * @param value_table the identity set + */ +void del_identities(ir_graph *irg); -ir_node *optimize_node (ir_node *n); +/** + * Add a node to the identities value table. + */ +void add_identities(ir_node *node); -ir_node *optimize_in_place_2 (ir_node *n); +/** + * Compare function for two nodes in the hash table. Gets two + * nodes as parameters. Returns 0 if the nodes are a cse. + */ +int identities_cmp(const void *elt, const void *key); + +/** + * Return the canonical node computing the same value as n. + * Looks up the node in a hash table, enters it in the table + * if it isn't there yet. + */ +ir_node *identify_remember(ir_node *n); + +/** Visit each node in the value table of a graph. */ +void visit_all_identities(ir_graph *irg, irg_walk_func visit, void *env); + +/** + * Normalize a node by putting constants (and operands with larger + * node index) on the right (operator side). + * + * @param n The node to normalize + */ +void ir_normalize_node(ir_node *n); + +ir_node *optimize_node(ir_node *n); + +ir_node *optimize_in_place_2(ir_node *n); + +/** + * The value_of operation. + * This operation returns for every IR node an associated tarval if existing, + * returning tarval_bad otherwise. + * No calculations are done here, just a lookup. + */ +typedef ir_tarval *(*value_of_func)(const ir_node *self); -/* Calculate a hash value of a node. */ -unsigned ir_node_hash (ir_node *node); +extern value_of_func value_of_ptr; /** - * Returns the tarval of a Const node or tarval_bad for all other nodes. + * Set a new value_of function. + * + * @param func the function, NULL restores the default behavior */ -static INLINE tarval * -value_of(ir_node *n) { - if ((n != NULL) && (get_irn_op(n) == op_Const)) - return get_Const_tarval(n); /* might return tarval_bad */ - else - return tarval_bad; +void set_value_of_func(value_of_func func); + +/** + * Returns the associated tarval of a node. + */ +static inline ir_tarval *value_of(const ir_node *n) +{ + return value_of_ptr(n); } /** - * set the default ir op operations + * returns true if a value becomes zero when converted to mode @p mode + */ +bool ir_zero_when_converted(const ir_node *node, ir_mode *dest_mode); + +int ir_mux_is_abs(const ir_node *sel, const ir_node *mux_false, + const ir_node *mux_true); + +ir_node *ir_get_abs_op(const ir_node *sel, ir_node *mux_false, + ir_node *mux_true); + +/** + * return true if the Mux node will be optimized away. This can be used for + * the if-conversion callback. Allowing these Muxes should be always safe, even + * if the backend cannot handle them. + */ +bool ir_is_optimizable_mux(const ir_node *sel, const ir_node *mux_false, + const ir_node *mux_true); + +/** + * Set the default hash operation in an ir_op_ops. + * + * @param code the opcode for the default operation + * @param ops the operations initialized + */ +void firm_set_default_hash(unsigned code, ir_op_ops *ops); + +/** + * Set the default computed_value evaluator in an ir_op_ops. + * + * @param code the opcode for the default operation + * @param ops the operations initialized + */ +void firm_set_default_computed_value(ir_opcode code, ir_op_ops *ops); + +/** + * Sets the default equivalent node operation for an ir_op_ops. + * + * @param code the opcode for the default operation + * @param ops the operations initialized + */ +void firm_set_default_equivalent_node(ir_opcode code, ir_op_ops *ops); + +/** + * Sets the default transform node operation for an ir_op_ops. + * + * @param code the opcode for the default operation + * @param ops the operations initialized + */ +void firm_set_default_transform_node(ir_opcode code, ir_op_ops *ops); + +/** + * Set the default node attribute compare operation for an ir_op_ops. + * + * @param code the opcode for the default operation + * @param ops the operations initialized */ -ir_op *firm_set_default_operations(ir_op *op); +void firm_set_default_node_cmp_attr(ir_opcode code, ir_op_ops *ops); + -# endif /* _IROPT_T_H_ */ +#endif