X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fopt%2Fldstopt.c;h=6cd64da0dcc95142a52151d044440d1f9ffdcf21;hb=bb5c6d5ce2e35c4074900017f8c8e1a4935054d0;hp=13b0e623ec0401e9e7639f1a15d4879807473e61;hpb=81d4cf5aeab4d0c0bc2a5e7c461d58ee7a7522d6;p=libfirm

diff --git a/ir/opt/ldstopt.c b/ir/opt/ldstopt.c
index 13b0e623e..6cd64da0d 100644
--- a/ir/opt/ldstopt.c
+++ b/ir/opt/ldstopt.c
@@ -48,7 +48,6 @@
 #include "irtools.h"
 #include "opt_polymorphy.h"
 #include "irmemory.h"
-#include "xmalloc.h"
 #include "irphase_t.h"
 #include "irgopt.h"
 #include "debug.h"
@@ -1244,6 +1243,21 @@ static int is_completely_overwritten(ir_mode *old_mode, ir_mode *new_mode)
 	return get_mode_size_bits(new_mode) >= get_mode_size_bits(old_mode);
 }  /* is_completely_overwritten */
 
+/**
+ * Check whether small is a part of large (starting at same address).
+ */
+static int is_partially_same(ir_node *small, ir_node *large)
+{
+	ir_mode *sm = get_irn_mode(small);
+	ir_mode *lm = get_irn_mode(large);
+
+	/* FIXME: Check endianness */
+	return is_Conv(small) && get_Conv_op(small) == large
+	    && get_mode_size_bytes(sm) < get_mode_size_bytes(lm)
+	    && get_mode_arithmetic(sm) == irma_twos_complement
+	    && get_mode_arithmetic(lm) == irma_twos_complement;
+}  /* is_partially_same */
+
 /**
  * follow the memory chain as long as there are only Loads and alias free Stores.
  *
@@ -1268,24 +1282,55 @@ static unsigned follow_Mem_chain_for_Store(ir_node *store, ir_node *curr) {
 		 * if the pointers are identical, they refer to the same object.
 		 * This is only true in strong typed languages, not is C were the following
 		 * is possible *(ir_type1 *)p = a; *(ir_type2 *)p = b ...
-		 * However, if the mode that is written have a bigger  or equal size the the old
-		 * one, the old value is completely overwritten and can be killed ...
+		 * However, if the size of the mode that is written is bigger or equal the
+		 * size of the old one, the old value is completely overwritten and can be
+		 * killed ...
 		 */
 		if (is_Store(pred) && get_Store_ptr(pred) == ptr &&
-		    get_nodes_MacroBlock(pred) == mblk &&
-		    is_completely_overwritten(get_irn_mode(get_Store_value(pred)), mode)) {
+            get_nodes_MacroBlock(pred) == mblk) {
 			/*
 			 * a Store after a Store in the same MacroBlock -- a write after write.
-			 * We may remove the first Store, if it does not have an exception handler.
+			 */
+
+			/*
+			 * We may remove the first Store, if the old value is completely
+			 * overwritten or the old value is a part of the new value,
+			 * and if it does not have an exception handler.
 			 *
 			 * TODO: What, if both have the same exception handler ???
 			 */
-			if (get_Store_volatility(pred) != volatility_is_volatile && !pred_info->projs[pn_Store_X_except]) {
-				DBG_OPT_WAW(pred, store);
-				exchange(pred_info->projs[pn_Store_M], get_Store_mem(pred));
-				kill_node(pred);
-				reduce_adr_usage(ptr);
-				return DF_CHANGED;
+			if (get_Store_volatility(pred) != volatility_is_volatile
+			        && !pred_info->projs[pn_Store_X_except]) {
+				ir_node *predvalue = get_Store_value(pred);
+				ir_mode *predmode  = get_irn_mode(predvalue);
+
+				if(is_completely_overwritten(predmode, mode)
+				        || is_partially_same(predvalue, value)) {
+					DBG_OPT_WAW(pred, store);
+					exchange(pred_info->projs[pn_Store_M], get_Store_mem(pred));
+					kill_node(pred);
+					reduce_adr_usage(ptr);
+					return DF_CHANGED;
+				}
+			}
+
+			/*
+			 * We may remove the Store, if the old value already contains
+			 * the new value, and if it does not have an exception handler.
+			 *
+			 * TODO: What, if both have the same exception handler ???
+			 */
+			if (get_Store_volatility(store) != volatility_is_volatile
+			        && !info->projs[pn_Store_X_except]) {
+				ir_node *predvalue = get_Store_value(pred);
+
+				if(is_partially_same(value, predvalue)) {
+					DBG_OPT_WAW(pred, store);
+					exchange(info->projs[pn_Store_M], mem);
+					kill_node(store);
+					reduce_adr_usage(ptr);
+					return DF_CHANGED;
+				}
 			}
 		} else if (is_Load(pred) && get_Load_ptr(pred) == ptr &&
 		           value == pred_info->projs[pn_Load_res]) {
@@ -2035,7 +2080,7 @@ static void dfs(ir_node *irn, loop_env *env)
 			ir_node *pred = get_irn_n(irn, i);
 			node_entry *o = get_irn_ne(pred, env);
 
-			if (irn_not_visited(pred)) {
+			if (!irn_visited(pred)) {
 				dfs(pred, env);
 				node->low = MIN(node->low, o->low);
 			}
@@ -2046,7 +2091,7 @@ static void dfs(ir_node *irn, loop_env *env)
 		ir_node *pred = get_fragile_op_mem(irn);
 		node_entry *o = get_irn_ne(pred, env);
 
-		if (irn_not_visited(pred)) {
+		if (!irn_visited(pred)) {
 			dfs(pred, env);
 			node->low = MIN(node->low, o->low);
 		}
@@ -2056,7 +2101,7 @@ static void dfs(ir_node *irn, loop_env *env)
 		ir_node *pred = get_Proj_pred(irn);
 		node_entry *o = get_irn_ne(pred, env);
 
-		if (irn_not_visited(pred)) {
+		if (!irn_visited(pred)) {
 			dfs(pred, env);
 			node->low = MIN(node->low, o->low);
 		}
@@ -2122,7 +2167,7 @@ static void do_dfs(ir_graph *irg, loop_env *env) {
 	for (i = get_End_n_keepalives(end) - 1; i >= 0; --i) {
 		ir_node *ka = get_End_keepalive(end, i);
 
-		if (is_Phi(ka) && irn_not_visited(ka))
+		if (is_Phi(ka) && !irn_visited(ka))
 			dfs(ka, env);
 	}
 	current_ir_graph = rem;
@@ -2165,7 +2210,7 @@ static int optimize_loops(ir_graph *irg) {
 /*
  * do the load store optimization
  */
-void optimize_load_store(ir_graph *irg) {
+int optimize_load_store(ir_graph *irg) {
 	walk_env_t env;
 
 	FIRM_DBG_REGISTER(dbg, "firm.opt.ldstopt");
@@ -2212,4 +2257,5 @@ void optimize_load_store(ir_graph *irg) {
 		have Bad() predecessors. */
 		set_irg_doms_inconsistent(irg);
 	}
+	return (int) env.changes;
 }  /* optimize_load_store */