--- a/gcc/tree-ssa-loop-im.c	Tue May 25 18:58:51 2010 +0900
+++ b/gcc/tree-ssa-loop-im.c	Tue Mar 22 17:18:12 2011 +0900
@@ -26,9 +26,8 @@
 #include "tm_p.h"
 #include "basic-block.h"
 #include "output.h"
-#include "diagnostic.h"
+#include "tree-pretty-print.h"
 #include "gimple-pretty-print.h"
-#include "tree-pretty-print.h"
 #include "tree-flow.h"
 #include "tree-dump.h"
 #include "timevar.h"
@@ -273,9 +272,7 @@
 	case SSA_NAME:
 	  return cbck (*addr_p, addr_p, data);
 
-	case MISALIGNED_INDIRECT_REF:
-	case ALIGN_INDIRECT_REF:
-	case INDIRECT_REF:
+	case MEM_REF:
 	  nxt = &TREE_OPERAND (*addr_p, 0);
 	  return cbck (*addr_p, nxt, data);
 
@@ -329,6 +326,10 @@
 	  if (*idx
 	      && !cbck (*addr_p, idx, data))
 	    return false;
+	  idx = &TMR_INDEX2 (*addr_p);
+	  if (*idx
+	      && !cbck (*addr_p, idx, data))
+	    return false;
 	  return true;
 
 	default:
@@ -675,31 +676,38 @@
      by the true edge of the predicate block and the other edge
      dominated by the false edge.  This ensures that the PHI argument
      we are going to take is completely determined by the path we
-     take from the predicate block.  */
+     take from the predicate block.
+     We can only use BB dominance checks below if the destination of
+     the true/false edges are dominated by their edge, thus only
+     have a single predecessor.  */
   extract_true_false_edges_from_block (dom, &true_edge, &false_edge);
   tem = EDGE_PRED (bb, 0);
   if (tem == true_edge
-      || tem->src == true_edge->dest
-      || dominated_by_p (CDI_DOMINATORS,
-			 tem->src, true_edge->dest))
+      || (single_pred_p (true_edge->dest)
+	  && (tem->src == true_edge->dest
+	      || dominated_by_p (CDI_DOMINATORS,
+				 tem->src, true_edge->dest))))
     arg0 = PHI_ARG_DEF (phi, tem->dest_idx);
   else if (tem == false_edge
-	   || tem->src == false_edge->dest
-	   || dominated_by_p (CDI_DOMINATORS,
-			      tem->src, false_edge->dest))
+	   || (single_pred_p (false_edge->dest)
+	       && (tem->src == false_edge->dest
+		   || dominated_by_p (CDI_DOMINATORS,
+				      tem->src, false_edge->dest))))
     arg1 = PHI_ARG_DEF (phi, tem->dest_idx);
   else
     return false;
   tem = EDGE_PRED (bb, 1);
   if (tem == true_edge
-      || tem->src == true_edge->dest
-      || dominated_by_p (CDI_DOMINATORS,
-			 tem->src, true_edge->dest))
+      || (single_pred_p (true_edge->dest)
+	  && (tem->src == true_edge->dest
+	      || dominated_by_p (CDI_DOMINATORS,
+				 tem->src, true_edge->dest))))
     arg0 = PHI_ARG_DEF (phi, tem->dest_idx);
   else if (tem == false_edge
-	   || tem->src == false_edge->dest
-	   || dominated_by_p (CDI_DOMINATORS,
-			      tem->src, false_edge->dest))
+	   || (single_pred_p (false_edge->dest)
+	       && (tem->src == false_edge->dest
+		   || dominated_by_p (CDI_DOMINATORS,
+				      tem->src, false_edge->dest))))
     arg1 = PHI_ARG_DEF (phi, tem->dest_idx);
   else
     return false;
@@ -909,19 +917,7 @@
   add_referenced_var (var);
   DECL_GIMPLE_REG_P (var) = 1;
 
-  /* For vectors, create a VECTOR_CST full of 1's.  */
-  if (TREE_CODE (type) == VECTOR_TYPE)
-    {
-      int i, len;
-      tree list = NULL_TREE;
-      real_one = build_real (TREE_TYPE (type), dconst1);
-      len = TYPE_VECTOR_SUBPARTS (type);
-      for (i = 0; i < len; i++)
-	list = tree_cons (NULL, real_one, list);
-      real_one = build_vector (type, list);
-    }
-  else
-    real_one = build_real (type, dconst1);
+  real_one = build_one_cst (type);
 
   stmt1 = gimple_build_assign_with_ops (RDIV_EXPR,
 		var, real_one, gimple_assign_rhs2 (stmt));
@@ -1444,7 +1440,7 @@
   if (!accs)
     return;
 
-  for (i = 0; VEC_iterate (mem_ref_loc_p, accs->locs, i, loc); i++)
+  FOR_EACH_VEC_ELT (mem_ref_loc_p, accs->locs, i, loc)
     free (loc);
   VEC_free (mem_ref_loc_p, heap, accs->locs);
   free (accs);
@@ -1465,7 +1461,7 @@
   BITMAP_FREE (mem->indep_ref);
   BITMAP_FREE (mem->dep_ref);
 
-  for (i = 0; VEC_iterate (mem_ref_locs_p, mem->accesses_in_loop, i, accs); i++)
+  FOR_EACH_VEC_ELT (mem_ref_locs_p, mem->accesses_in_loop, i, accs)
     free_mem_ref_locs (accs);
   VEC_free (mem_ref_locs_p, heap, mem->accesses_in_loop);
 
@@ -1931,7 +1927,7 @@
       accs = VEC_index (mem_ref_locs_p, ref->accesses_in_loop, loop->num);
       if (accs)
 	{
-	  for (i = 0; VEC_iterate (mem_ref_loc_p, accs->locs, i, loc); i++)
+	  FOR_EACH_VEC_ELT (mem_ref_loc_p, accs->locs, i, loc)
 	    VEC_safe_push (mem_ref_loc_p, heap, *locs, loc);
 	}
     }
@@ -1950,7 +1946,7 @@
   VEC (mem_ref_loc_p, heap) *locs = NULL;
 
   get_all_locs_in_loop (loop, ref, &locs);
-  for (i = 0; VEC_iterate (mem_ref_loc_p, locs, i, loc); i++)
+  FOR_EACH_VEC_ELT (mem_ref_loc_p, locs, i, loc)
     rewrite_mem_ref_loc (loc, tmp_var);
   VEC_free (mem_ref_loc_p, heap, locs);
 }
@@ -1984,13 +1980,15 @@
 
   switch (TREE_CODE (ref))
     {
-    case MISALIGNED_INDIRECT_REF:
-    case ALIGN_INDIRECT_REF:
-    case INDIRECT_REF:
+    case MEM_REF:
       gen_lsm_tmp_name (TREE_OPERAND (ref, 0));
       lsm_tmp_name_add ("_");
       break;
 
+    case ADDR_EXPR:
+      gen_lsm_tmp_name (TREE_OPERAND (ref, 0));
+      break;
+
     case BIT_FIELD_REF:
     case VIEW_CONVERT_EXPR:
     case ARRAY_RANGE_REF:
@@ -2112,7 +2110,7 @@
      all dependencies.  */
   gsi_insert_on_edge (loop_latch_edge (loop), load);
 
-  for (i = 0; VEC_iterate (edge, exits, i, ex); i++)
+  FOR_EACH_VEC_ELT (edge, exits, i, ex)
     {
       store = gimple_build_assign (unshare_expr (ref->mem), tmp_var);
       gsi_insert_on_edge (ex, store);
@@ -2151,11 +2149,12 @@
   tree base;
 
   base = get_base_address (ref->mem);
-  if (INDIRECT_REF_P (base))
+  if (INDIRECT_REF_P (base)
+      || TREE_CODE (base) == MEM_REF)
     base = TREE_OPERAND (base, 0);
 
   get_all_locs_in_loop (loop, ref, &locs);
-  for (i = 0; VEC_iterate (mem_ref_loc_p, locs, i, loc); i++)
+  FOR_EACH_VEC_ELT (mem_ref_loc_p, locs, i, loc)
     {
       if (!get_lim_data (loc->stmt))
 	continue;
@@ -2170,7 +2169,8 @@
 	  lhs = get_base_address (gimple_get_lhs (loc->stmt));
 	  if (!lhs)
 	    continue;
-	  if (INDIRECT_REF_P (lhs))
+	  if (INDIRECT_REF_P (lhs)
+	      || TREE_CODE (lhs) == MEM_REF)
 	    lhs = TREE_OPERAND (lhs, 0);
 	  if (lhs != base)
 	    continue;
@@ -2325,6 +2325,10 @@
       || !for_each_index (&ref->mem, may_move_till, loop))
     return false;
 
+  /* If it can throw fail, we do not properly update EH info.  */
+  if (tree_could_throw_p (ref->mem))
+    return false;
+
   /* If it can trap, it must be always executed in LOOP.
      Readonly memory locations may trap when storing to them, but
      tree_could_trap_p is a predicate for rvalues, so check that
@@ -2375,8 +2379,8 @@
   unsigned i;
   edge ex;
 
-  for (i = 0; VEC_iterate (edge, exits, i, ex); i++)
-    if (ex->flags & EDGE_ABNORMAL)
+  FOR_EACH_VEC_ELT (edge, exits, i, ex)
+    if (ex->flags & (EDGE_ABNORMAL | EDGE_EH))
       return false;
 
   return true;
@@ -2542,19 +2546,19 @@
   VEC_free (mem_ref_p, heap, memory_accesses.refs_list);
   htab_delete (memory_accesses.refs);
 
-  for (i = 0; VEC_iterate (bitmap, memory_accesses.refs_in_loop, i, b); i++)
+  FOR_EACH_VEC_ELT (bitmap, memory_accesses.refs_in_loop, i, b)
     BITMAP_FREE (b);
   VEC_free (bitmap, heap, memory_accesses.refs_in_loop);
 
-  for (i = 0; VEC_iterate (bitmap, memory_accesses.all_refs_in_loop, i, b); i++)
+  FOR_EACH_VEC_ELT (bitmap, memory_accesses.all_refs_in_loop, i, b)
     BITMAP_FREE (b);
   VEC_free (bitmap, heap, memory_accesses.all_refs_in_loop);
 
-  for (i = 0; VEC_iterate (bitmap, memory_accesses.clobbered_vops, i, b); i++)
+  FOR_EACH_VEC_ELT (bitmap, memory_accesses.clobbered_vops, i, b)
     BITMAP_FREE (b);
   VEC_free (bitmap, heap, memory_accesses.clobbered_vops);
 
-  for (i = 0; VEC_iterate (htab_t, memory_accesses.vop_ref_map, i, h); i++)
+  FOR_EACH_VEC_ELT (htab_t, memory_accesses.vop_ref_map, i, h)
     htab_delete (h);
   VEC_free (htab_t, heap, memory_accesses.vop_ref_map);