X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fopt%2Fopt_osr.c;h=5bbff09354aa27840f4c0173ae80854c38b261a6;hb=e9924cc1137b5920e75f4b9f2e99195dce708433;hp=a79ca2027d88d27dd90eba0abb9958f25f8ed0fe;hpb=4894813d230d1d8cbfcf1efef29119cee5e8fa80;p=libfirm

diff --git a/ir/opt/opt_osr.c b/ir/opt/opt_osr.c
index a79ca2027..5bbff0935 100644
--- a/ir/opt/opt_osr.c
+++ b/ir/opt/opt_osr.c
@@ -1,27 +1,37 @@
+/*
+ * 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.
+ */
+
 /**
- * Project:     libFIRM
- * File name:   ir/opt/opt_osr.c
- * Purpose:     Operator Strength Reduction, based on
- *              Keith D. Cooper, L. Taylor Simpson, Christopher A. Vick
- * Author:      Michael Beck
- * Modified by:
- * Created:     12.5.2006
- * CVS-ID:      $Id$
- * Copyright:   (c) 2006 Universität Karlsruhe
- * Licence:     This file protected by GPL -  GNU GENERAL PUBLIC LICENSE.
+ * @file
+ * @brief   Operator Strength Reduction.
+ * @date    12.5.2006
+ * @author  Michael Beck
+ * @version $Id$
+ * @summary
+ *  Implementation of the Operator Strength Reduction algorithm
+ *  by Keith D. Cooper, L. Taylor Simpson, Christopher A. Vick.
  */
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
-#ifdef HAVE_MALLOC_H
-#include <malloc.h>
-#endif
-#ifdef HAVE_ALLOCA_H
-#include <alloca.h>
-#endif
-
-#include "opt_osr.h"
+#include "iroptimize.h"
 #include "irgraph.h"
 #include "ircons.h"
 #include "irop_t.h"
@@ -40,6 +50,7 @@
 #include "irloop_t.h"
 #include "array.h"
 #include "firmstat.h"
+#include "xmalloc.h"
 
 /** The debug handle. */
 DEBUG_ONLY(static firm_dbg_module_t *dbg;)
@@ -79,22 +90,22 @@ typedef struct iv_env {
 /**
  * An entry in the (op, node, node) -> node map.
  */
-typedef struct quad_t {
-	opcode  code;  /**< the opcode of the reduced operation */
-	ir_node *op1;  /**< the first operand the reduced operation */
-	ir_node *op2;  /**< the second operand of the reduced operation */
+typedef struct quadruple_t {
+	ir_opcode code;  /**< the opcode of the reduced operation */
+	ir_node   *op1;  /**< the first operand the reduced operation */
+	ir_node   *op2;  /**< the second operand of the reduced operation */
 
-	ir_node *res; /**< the reduced operation */
-} quad_t;
+	ir_node   *res; /**< the reduced operation */
+} quadruple_t;
 
 /**
  * A LFTR edge.
  */
 typedef struct LFTR_edge {
-	ir_node *src;   /**< the source node */
-	ir_node *dst;   /**< the destination node */
-	opcode  code;   /**< the opcode that must be applied */
-	ir_node *rc;    /**< the region const that must be applied */
+	ir_node   *src;   /**< the source node */
+	ir_node   *dst;   /**< the destination node */
+	ir_opcode code;   /**< the opcode that must be applied */
+	ir_node   *rc;    /**< the region const that must be applied */
 } LFTR_edge;
 
 /* forward */
@@ -106,10 +117,12 @@ static ir_node *reduce(ir_node *orig, ir_node *iv, ir_node *rc, iv_env *env);
 static int LFTR_cmp(const void *e1, const void *e2, size_t size) {
 	const LFTR_edge *l1 = e1;
 	const LFTR_edge *l2 = e2;
+	(void) size;
 
 	return l1->src != l2->src;
 }
 
+#if 0
 /**
  * Find a LFTR edge.
  */
@@ -120,11 +133,12 @@ static LFTR_edge *LFTR_find(ir_node *src, iv_env *env) {
 
 	return set_find(env->lftr_edges, &key, sizeof(key), HASH_PTR(src));
 }
+#endif
 
 /**
  * Add a LFTR edge.
  */
-static void LFTR_add(ir_node *src, ir_node *dst, opcode code, ir_node *rc, iv_env *env) {
+static void LFTR_add(ir_node *src, ir_node *dst, ir_opcode code, ir_node *rc, iv_env *env) {
 	LFTR_edge key;
 
 	key.src  = src;
@@ -183,8 +197,9 @@ static int is_rc(ir_node *irn, ir_node *header_block) {
  * Set compare function for the quad set.
  */
 static int quad_cmp(const void *e1, const void *e2, size_t size) {
-	const quad_t *c1 = e1;
-	const quad_t *c2 = e2;
+	const quadruple_t *c1 = e1;
+	const quadruple_t *c2 = e2;
+	(void) size;
 
 	return c1->code != c2->code || c1->op1 != c2->op1 || c1->op2 != c2->op2;
 }
@@ -199,8 +214,8 @@ static int quad_cmp(const void *e1, const void *e2, size_t size) {
  *
  * @return the already reduced node or NULL if this operation is not yet reduced
  */
-static ir_node *search(opcode code, ir_node *op1, ir_node *op2, iv_env *env) {
-	quad_t key, *entry;
+static ir_node *search(ir_opcode code, ir_node *op1, ir_node *op2, iv_env *env) {
+	quadruple_t key, *entry;
 
 	key.code = code;
 	key.op1 = op1;
@@ -222,8 +237,8 @@ static ir_node *search(opcode code, ir_node *op1, ir_node *op2, iv_env *env) {
  * @param result  the result of the reduced operation
  * @param env     the environment
  */
-static void add(opcode code, ir_node *op1, ir_node *op2, ir_node *result, iv_env *env) {
-	quad_t key;
+static void add(ir_opcode code, ir_node *op1, ir_node *op2, ir_node *result, iv_env *env) {
+	quadruple_t key;
 
 	key.code = code;
 	key.op1  = op1;
@@ -263,7 +278,7 @@ static ir_node *find_location(ir_node *block1, ir_node *block2) {
  *
  * @return the newly created node
  */
-static ir_node *do_apply(opcode code, dbg_info *db, ir_node *op1, ir_node *op2, ir_mode *mode) {
+static ir_node *do_apply(ir_opcode code, dbg_info *db, ir_node *op1, ir_node *op2, ir_mode *mode) {
 	ir_graph *irg = current_ir_graph;
 	ir_node *result;
 	ir_node *block = find_location(get_nodes_block(op1), get_nodes_block(op2));
@@ -297,7 +312,7 @@ static ir_node *do_apply(opcode code, dbg_info *db, ir_node *op1, ir_node *op2,
  * @return the newly created node
  */
 static ir_node *apply(ir_node *orig, ir_node *op1, ir_node *op2, iv_env *env) {
-	opcode code = get_irn_opcode(orig);
+	ir_opcode code = get_irn_opcode(orig);
 	ir_node *result = search(code, op1, op2, env);
 
 	if (! result) {
@@ -330,7 +345,7 @@ static ir_node *apply(ir_node *orig, ir_node *op1, ir_node *op2, iv_env *env) {
  * @return the reduced node
  */
 static ir_node *reduce(ir_node *orig, ir_node *iv, ir_node *rc, iv_env *env) {
-	opcode code = get_irn_opcode(orig);
+	ir_opcode code = get_irn_opcode(orig);
 	ir_node *result = search(code, iv, rc, env);
 
 	if (! result) {
@@ -420,10 +435,10 @@ static int replace(ir_node *irn, ir_node *iv, ir_node *rc, iv_env *env) {
  * @return non-zero if irn should be Replace'd
  */
 static int check_replace(ir_node *irn, iv_env *env) {
-	ir_node *left, *right, *iv, *rc;
-	ir_op   *op  = get_irn_op(irn);
-	opcode  code = get_op_code(op);
-	ir_node *liv, *riv;
+	ir_node   *left, *right, *iv, *rc;
+	ir_op     *op  = get_irn_op(irn);
+	ir_opcode code = get_op_code(op);
+	ir_node   *liv, *riv;
 
 	switch (code) {
 	case iro_Mul:
@@ -822,6 +837,7 @@ static void assign_po(ir_node *block, void *ctx) {
 	e->POnum = env->POnum++;
 }
 
+#if 0
 /**
  * Follows the LFTR edges and return the last node in the chain.
  *
@@ -993,6 +1009,7 @@ static void do_lftr(ir_node *cmp, void *ctx) {
 static void lftr(ir_graph *irg, iv_env *env) {
 	irg_walk_graph(irg, NULL, do_lftr, env);
 }
+#endif
 
 /**
  * Pre-walker: set all node links to NULL and fix the
@@ -1000,6 +1017,7 @@ static void lftr(ir_graph *irg, iv_env *env) {
  */
 static void clear_and_fix(ir_node *irn, void *env)
 {
+	(void) env;
 	set_irn_link(irn, NULL);
 
 	if (is_Proj(irn)) {