X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;ds=sidebyside;f=ir%2Fir%2Firopt_t.h;h=ebf8cad114f64f5ac0a71f826009374fca39a0c3;hb=b59e22a229aa1227ef992c184c79fdafe34908cf;hp=29d3b3b38d96a5e74838ba578ea45a4b1eef04b1;hpb=5c8fea174ada95511143ff2838ae1c2ce04bae6f;p=libfirm diff --git a/ir/ir/iropt_t.h b/ir/ir/iropt_t.h index 29d3b3b38..ebf8cad11 100644 --- a/ir/ir/iropt_t.h +++ b/ir/ir/iropt_t.h @@ -1,46 +1,70 @@ /* - * 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 -*/ - -# ifndef _IROPT_T_H_ -# define _IROPT_T_H_ - -# include "pset.h" -# include "iropt.h" -# include "tv.h" + * @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 -ir_node *equivalent_node (ir_node *n); +#include +#include "irop_t.h" +#include "iropt.h" +#include "irnode_t.h" +#include "pset.h" +#include "tv.h" -/*@{*/ +/** + * Calculate a hash value of a node. + * + * @param node The IR-node + */ +unsigned ir_node_hash(const ir_node *node); -/** For cse */ -pset *new_identities (void); -void del_identities (pset *value_table); -void add_identities (pset *value_table, ir_node *node); -/*@}*/ +/** + * 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); -ir_node *optimize_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); -ir_node *optimize_in_place_2 (ir_node *n); +/** + * Deletes a identities value table. + * + * @param value_table the identity set + */ +void del_identities(ir_graph *irg); -/** Calculate a hash value of a node. */ -unsigned ir_node_hash (ir_node *node); +/** + * Add a node to the identities value table. + */ +void add_identities(ir_node *node); /** * Compare function for two nodes in the hash table. Gets two @@ -53,28 +77,72 @@ int identities_cmp(const void *elt, const void *key); * Looks up the node in a hash table, enters it in the table * if it isn't there yet. */ -ir_node *identify_remember(pset *value_table, ir_node *n); +ir_node *identify_remember(ir_node *n); -/** - * Returns the tarval of a Const node or tarval_bad for all other nodes. - */ -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; -} +/** Visit each node in the value table of a graph. */ +void visit_all_identities(ir_graph *irg, irg_walk_func visit, void *env); /** - * Sets the default operation for an ir_op_ops. + * Normalize a node by putting constants (and operands with larger + * node index) on the right (operator side). * - * @param code the opcode for the default operation - * @param ops the operations initialized + * @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); + +extern value_of_func value_of_ptr; + +/** + * Set a new value_of function. * - * @return - * The operations. + * @param func the function, NULL restores the default behavior + */ +void set_value_of_func(value_of_func func); + +/** + * Returns the associated tarval of a node. */ -ir_op_ops *firm_set_default_operations(opcode code, ir_op_ops *ops); +static inline ir_tarval *value_of(const ir_node *n) +{ + return value_of_ptr(n); +} + +/** + * 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); + +/** + * Returns true if Conv_m0(Conv_m1( x_m2)) is equivalent to Conv_m0(x_m2) + */ +bool may_leave_out_middle_conv(ir_mode *m0, ir_mode *m1, ir_mode *m2); + +void ir_register_opt_node_ops(void); -# endif /* _IROPT_T_H_ */ +#endif