The unit test test_08_20c now works. There was some major

insanity happening in processing ssa_names because I was using
the wrong method of determining default_defs.

1 files changed, 233 insertions, 103 deletions

diff --git a/gcc/ipa-str-reorg-instance-interleave.c b/gcc/ipa-str-reorg-instance-interleave.c
index fb08824f04f..7ba1da525f9 100644
--- a/gcc/ipa-str-reorg-instance-interleave.c
+++ b/gcc/ipa-str-reorg-instance-interleave.c
@@ -58,6 +58,7 @@ static void create_a_new_type ( Info_t *, tree);
 static unsigned int reorg_perf_qual ( Info *);
 static tree find_coresponding_field ( tree, tree);
 static void remove_default_def ( tree, struct function *);
+static void set_lhs_for ( gimple *, tree);
 
 
 // These are local to this file by design
@@ -68,6 +69,34 @@ static void remove_default_def ( tree, struct function *);
 // TBD Delete all this after sending a note on it
 // to the gcc mailing list.
 #define USE_BUILT_IN_FREE 1
+
+/*
+0000 ssa_verify error loc_3
+0001 tree_class_check err in interleave
+0010 ssa_verify error arr_46
+0011 ssa_verify error loc_3
+0100 ssa_verify error loc_3
+0101 ssa_verify error arr_46
+0110 ssa_verify error arr_46
+0111 ssa_verify error arr_46
+1000 ssa_verify error loc_3
+1001 bad failure: walk return bogus op
+1010 bad failure: walk return bogus op
+1011 bad failure: walk return bogus op
+1100 bad failure: walk return bogus op
+1101 bad failure: walk return bogus op
+1110 bad failure: walk return bogus op
+1111 bad failure: walk return bogus op
+*/
+
+
+#define TOGSSA1 1
+#define TOGSSA2 1
+#define TOGUPD1 1
+#define TOGUPD2 1
+// ignore TOGUPD3
+#define TOGUPD3 1
+#define TOGUPD4 1
   
 int
 str_reorg_instance_interleave_qual ( Info *info)
@@ -90,6 +119,9 @@ str_reorg_instance_interleave_trans ( Info *info)
     fprintf ( info->reorg_dump_file, "Start of str_reorg_instance_interleave_trans:\n");
     print_program ( info->reorg_dump_file, PRINT_FORMAT, 4, info);
   }
+
+  DEBUG ("INTERNALS PRINT\n");
+  DEBUG_F (apply_to_all_gimple, print_internals, true, (void *)info);
   
   struct cgraph_node *node;
   FOR_EACH_FUNCTION_WITH_GIMPLE_BODY ( node)  {
@@ -143,7 +175,7 @@ str_reorg_instance_interleave_trans ( Info *info)
 		  {
 		    print_gimple_stmt( info->reorg_dump_file, stmt, 0);
 		  }
-	    
+
 		switch ( trans)
 		  { 
 		  case ReorgT_StrAssign:
@@ -213,7 +245,7 @@ str_reorg_instance_interleave_trans ( Info *info)
 		      
 		      DEBUG_L("ReorgT_ElemAssign: ");
 		      DEBUG_F( print_gimple_stmt, stderr, stmt, 0);
-		      //INDENT(2);
+		      INDENT(2);
 		      // Needed for helloworld
 		      tree lhs = gimple_assign_lhs( stmt);
 		      tree rhs = gimple_assign_rhs1( stmt);
@@ -395,16 +427,37 @@ str_reorg_instance_interleave_trans ( Info *info)
 			  
 			} // end recognize_op ( rhs, info) switch
 
-		      //INDENT(-2);
+		      INDENT(-2);
 		    } // end ReorgT_ElemAssign case
 		    break;
 		  case ReorgT_If_Null:
 		  case ReorgT_If_NotNull:
-		    DEBUG_L("ReorgT_If_(Not)Null\n");
-		    /*
-	      gimple_cond_set_rhs( stmt, 
-	        TYPE_MIN_VALUE( pointer_sized_int_node));
-		    */
+		    {
+		      DEBUG_L("ReorgT_If_(Not)Null: ");
+		      DEBUG_F( print_gimple_stmt, stderr, stmt, 0);
+		      /*
+			gimple_cond_set_rhs( stmt, 
+			TYPE_MAX_VALUE( pointer_sized_int_node));
+		      */
+		      // TYPE_MAX_VALUE ( TREE_TYPE ( fail_val)
+		      gimple_stmt_iterator gsi = gsi_for_stmt( stmt);
+		      ReorgType_t *ri = contains_a_reorgtype( stmt, info);
+		      //tree null_val = 
+		      //  make_temp_ssa_name ( ri->pointer_rep, NULL, "if_cond_null");
+		      gcond *cond_stmt = as_a <gcond *> (stmt);
+		      
+		      //tree max = TYPE_MAX_VALUE ( TREE_TYPE ( ri->pointer_rep));
+		      tree max = TYPE_MAX_VALUE ( ri->pointer_rep);
+		      
+		      DEBUG_L("max: ");
+		      DEBUG_F(print_generic_expr, stderr, max, (dump_flags_t)0);
+		      DEBUG("\n");
+		      
+		      gimple_cond_set_rhs( cond_stmt, max);
+		      
+		      DEBUG_L("after: ");
+		      DEBUG_F( print_gimple_stmt, stderr, stmt, 0);
+		    }
 		    break;
 		  case ReorgT_IfPtrEQ:
 		  case ReorgT_IfPtrNE:
@@ -413,7 +466,7 @@ str_reorg_instance_interleave_trans ( Info *info)
 		  case ReorgT_IfPtrLE:
 		  case ReorgT_IfPtrGE:
 		    DEBUG_L("ReorgT_IfPtr*\n");
-		    // Not needed for single pool.
+		    // Not needed for single pool. TBD test this
 		    break;
 		  case ReorgT_PtrPlusInt:   // "a = b + i"
 		    {
@@ -473,19 +526,20 @@ str_reorg_instance_interleave_trans ( Info *info)
 
 		      gsi_remove ( &gsi, true);
 
-		      //DEBUG_L("");
-		      //DEBUG_F( print_gimple_stmt, stderr, gPPI_rhs2_cast, 0);
-		      //DEBUG_L("");
-		      //DEBUG_F( print_gimple_stmt, stderr, gPPI_adj, 0);
-		      //DEBUG_L("");
-		      //DEBUG_F( print_gimple_stmt, stderr, gPPI, 0);
-		      //DEBUG_L("");
-		      //DEBUG_F( print_gimple_stmt, stderr, gPPI_cast, 0);
+		      DEBUG_L("");
+		      DEBUG_F( print_gimple_stmt, stderr, gPPI_rhs2_cast, 0);
+		      DEBUG_L("");
+		      DEBUG_F( print_gimple_stmt, stderr, gPPI_adj, 0);
+		      DEBUG_L("");
+		      DEBUG_F( print_gimple_stmt, stderr, gPPI, 0);
+		      DEBUG_L("");
+		      DEBUG_F( print_gimple_stmt, stderr, gPPI_cast, 0);
 		    }
 		    break;
 		  case ReorgT_Ptr2Zero:   //  "a = 0"
 		    DEBUG_L("ReorgT_Ptr2Zero\n");
 		    /*
+		    // TBD
 		    // Note, this is way too simple... just saying.
 		    gimple_set_op( stmt, 1, 
 		    TYPE_MIN_VALUE( pointer_sized_int_node));
@@ -493,10 +547,11 @@ str_reorg_instance_interleave_trans ( Info *info)
 		    break;
 		  case ReorgT_PtrDiff:    //  "i = a - b"
 		    DEBUG_L("ReorgT_PtrDiff\n");
-		    // Do nothing in the single pool case.
+		    // Do nothing in the single pool case. TBD test this
 		    break;
 		  case ReorgT_Adr2Ptr:    //  "a = &x[i]"
 		    DEBUG_L("ReorgT_Adr2Ptr\n");
+		    // TBD
 		    /*
 	      tree *add_stmt = 
 	        gimple_build_assign( 
@@ -513,7 +568,8 @@ str_reorg_instance_interleave_trans ( Info *info)
 		    break;
 		  case ReorgT_PtrNull:     //  "x = a == 0"
 		  case ReorgT_PtrNotNull:  //  "x = a != 0"
-		    DEBUG_L("ReorgT_Ptr(Not)Null\n");
+		    DEBUG_L("ReorgT_Ptr(Not)Null\n");\
+		    // TBD
 		    /*
 	      gimple_set_op( stmt, 2, 
 	      		     TYPE_MIN_VALUE( pointer_sized_int_node));
@@ -526,12 +582,12 @@ str_reorg_instance_interleave_trans ( Info *info)
 		  case ReorgT_PtrGT:       //  "i = a > b"
 		  case ReorgT_PtrGE:       //  "i = a >= b"
 		    DEBUG_L("ReorgT_Ptr*\n");
-		    // Not needed for single pool.
+		    // Not needed for single pool. TBD test this
 		    break;
 		  case ReorgT_Malloc:
 		    {
 		      DEBUG_L("Transform ReorgT_Malloc\n");
-		      //INDENT(2);
+		      INDENT(2);
 
 		      // We need to use the user malloc function
 		      // declaration rather than the builtin!!!
@@ -896,7 +952,9 @@ str_reorg_instance_interleave_trans ( Info *info)
 			gimple_build_assign ( val, CONVERT_EXPR, m_phi_val);
 		      SSA_NAME_DEF_STMT ( val) = gm_cast_phi_val;
 
-		      gsi_insert_after( &gsi, gm_cast_phi_val, GSI_NEW_STMT);
+		      //gsi_insert_after( &gsi, gm_cast_phi_val, GSI_NEW_STMT);
+		      // TBD What does GSI_NEW_STMT do if  the block isn't emply?
+		      gsi_insert_before( &gsi, gm_cast_phi_val, GSI_NEW_STMT);
 
 		      //// FROM gsi_insert_after( &gsi, after_label)
 		      //gimple *gafter_label = gimple_build_label( after_label_L);
@@ -916,7 +974,7 @@ str_reorg_instance_interleave_trans ( Info *info)
 		      // FROM gsi_insert_after( &gsi, "fail_val = minint")
 		      gimple *gretnull =
 			gimple_build_assign ( fail_val, CONVERT_EXPR,
-					      TYPE_MIN_VALUE ( TREE_TYPE ( fail_val)));
+					      TYPE_MAX_VALUE ( TREE_TYPE ( fail_val)));
 		      SSA_NAME_DEF_STMT ( fail_val) = gretnull;
 		      
 		      gsi_insert_after( &gsi, gretnull, GSI_NEW_STMT);
@@ -976,9 +1034,10 @@ str_reorg_instance_interleave_trans ( Info *info)
 		      //DEBUG_L("End of malloc:\n");
 		      //DEBUG_F( print_program, PRINT_FORMAT, stderr, 4);
 		    }
-		    //INDENT(-2);
+		    INDENT(-2);
 		    break;
 		  case ReorgT_Calloc:
+		    // TBD
 		    DEBUG_L("ReorgT_Calloc\n");
 		    /*
 		    // This used to be almost a clone of the old version of
@@ -1067,6 +1126,7 @@ str_reorg_instance_interleave_trans ( Info *info)
 		      */
 		    break;
 		  case ReorgT_Realloc:
+		    // TBD
 		    DEBUG_L("ReorgT_Realloc\n");
 		    /*
 		// This used to be closely related to the old version of
@@ -1144,6 +1204,7 @@ str_reorg_instance_interleave_trans ( Info *info)
 		    */
 		    break;
 		  case ReorgT_Free:
+		    // TBD
 		    DEBUG_L("ReorgT_Free\n");
 		    // We won't free the base because it a global.
 		    /*
@@ -1176,6 +1237,7 @@ str_reorg_instance_interleave_trans ( Info *info)
 		  case ReorgT_Convert:
 		    // Ignore type casting because another
 		    // mini-pass sweeps up any ugly dangling types.
+		    // TBD test this
 		    DEBUG_L("ReorgT_Convert\n");
 		    break;
 		  case ReorgT_Return:
@@ -1193,13 +1255,25 @@ str_reorg_instance_interleave_trans ( Info *info)
 
   DEBUG_L("after bulk of transformations\n");
 
+  DEBUG_F( print_program, info->reorg_dump_file, PRINT_FORMAT, 4, info);
+  
+  DEBUG ("INTERNALS PRINT\n");
+  DEBUG_F (apply_to_all_gimple, print_internals, true, (void *)info);
+
   // A mini-pass to fixup dangling SSA temps.
   
   FOR_EACH_FUNCTION_WITH_GIMPLE_BODY ( node)
     {
       struct function *func = DECL_STRUCT_FUNCTION ( node->decl);
       push_cfun ( func);
+
+      std::vector <tree> ssa_to_delete;
+
+      DEBUG_L("Mini-Pass on Function %s:\n", lang_hooks.decl_printable_name ( func->decl, 2));
       
+      DEBUG_L("\n");
+      DEBUG_F( wolf_fence, info);
+
       // We need a map of old ssa_name to new ssa_name. Not currently used.
       std::map <tree,tree> ssa_map;
 
@@ -1222,20 +1296,21 @@ str_reorg_instance_interleave_trans ( Info *info)
       
       // For parameters
       
-      //DEBUG_L("Dangling Types for Function Params (default defs).\n");
-      //INDENT(4);
+      DEBUG_L("Dangling Types for Function Params (default defs).\n");
+      INDENT(4);
       tree parm;
       for ( parm = DECL_ARGUMENTS ( func->decl);
 	    parm;
 	    parm = DECL_CHAIN ( parm) )
 	{
-	  //DEBUG_A("param: ");
-	  //DEBUG_F( print_generic_decl, stderr, parm, (dump_flags_t)0);
-	  //DEBUG("\n");
+	  DEBUG_A("param: ");
+	  DEBUG_F( print_generic_decl, stderr, parm, (dump_flags_t)0);
+	  DEBUG("\n");
+	  INDENT(2);
 	  tree old_default_def = ssa_default_def ( func, parm);
-	  //DEBUG_A("old_default_def: ");
-	  //DEBUG_F( print_generic_expr, stderr, old_default_def, (dump_flags_t)0);
-	  //DEBUG("\n");
+	  DEBUG_A("old_default_def: ");
+	  DEBUG_F( print_generic_expr, stderr, old_default_def, (dump_flags_t)0);
+	  DEBUG("\n");
 	  tree new_default_def;
 
 	  // Modify prameter and do the default def stuff
@@ -1245,9 +1320,9 @@ str_reorg_instance_interleave_trans ( Info *info)
 	  
 	  if ( modify_decl_core ( &parm, info) )
 	    {
-	      //DEBUG_A("double check new param: ");
-	      //DEBUG_F( print_generic_decl, stderr, parm, (dump_flags_t)0);
-	      //DEBUG("\n");
+	      DEBUG_A("double check new param: ");
+	      DEBUG_F( print_generic_decl, stderr, parm, (dump_flags_t)0);
+	      DEBUG("\n");
 	      
 	      // New default def here
 
@@ -1274,12 +1349,13 @@ str_reorg_instance_interleave_trans ( Info *info)
 		  new_default_def = make_ssa_name_fn ( func, parm, gimple_build_nop ());
 		  set_ssa_default_def ( func, parm, new_default_def);
 
-		  //DEBUG_A("new_default_def: ");
-		  //DEBUG_F(print_generic_expr, stderr, new_default_def, (dump_flags_t)0);
-		  //DEBUG(", TYPE: ");
-		  //DEBUG_F(print_generic_expr, stderr, TREE_TYPE(new_default_def), (dump_flags_t)0);
-		  //DEBUG("\n");
+		  DEBUG_A("new_default_def: ");
+		  DEBUG_F(print_generic_expr, stderr, new_default_def, (dump_flags_t)0);
+		  DEBUG(", TYPE: ");
+		  DEBUG_F(print_generic_expr, stderr, TREE_TYPE(new_default_def), (dump_flags_t)0);
+		  DEBUG("\n");
 
+		  // TBD REMOVE DUPLICATE!
 		  // Replace old one (not really totally hence the
 		  // remove_default_def below.)
 		  set_ssa_default_def ( func, parm, new_default_def);
@@ -1291,8 +1367,8 @@ str_reorg_instance_interleave_trans ( Info *info)
 		  // new default def
 		  FOR_EACH_IMM_USE_STMT ( stmt, iter, old_default_def)  // <== use other form??? Not
 		    {
-		      //DEBUG_A("before: ");
-		      //DEBUG_F ( print_gimple_stmt, stderr, stmt, 0);
+		      DEBUG_A("before: ");
+		      DEBUG_F ( print_gimple_stmt, stderr, stmt, 0);
 		      use_operand_p use_p;
 		      ssa_op_iter ssa_iter;
 		      // The F_E_S_U_O macro was blowing up on a phi
@@ -1301,25 +1377,30 @@ str_reorg_instance_interleave_trans ( Info *info)
 			{
 			  if ( use_p == NULL ) continue;
 			  tree use = USE_FROM_PTR (use_p);
-			  //DEBUG_A("use to replace: ");
-			  //DEBUG_F( print_generic_expr, stderr, use, (dump_flags_t)0);
-			  //DEBUG("\n");
+			  DEBUG_A("use to replace: ");
+			  DEBUG_F( print_generic_expr, stderr, use, (dump_flags_t)0);
+			  DEBUG("\n");
 			  if (use == old_default_def)
 			    SET_USE ( use_p, new_default_def);
 			}
-		      //DEBUG_A("after: ");
-		      //DEBUG_F ( print_gimple_stmt, stderr, stmt, 0);
+		      DEBUG_A("after: ");
+		      DEBUG_F ( print_gimple_stmt, stderr, stmt, 0);
 		    }
 		  // Get rid of the old default def because it confuses
 		  //
-		  remove_default_def ( old_default_def, func);
+		  //remove_default_def ( old_default_def, func);
+		  ssa_to_delete.push_back ( old_default_def);
+		  release_ssa_name_fn ( func, old_default_def);
 		}
 	    }
+	  INDENT(-2);
 	}
-      //INDENT(-4);
+      INDENT(-4);
 
       DEBUG_L("Dangling Types for Function Local (default defs).\n");
-      //INDENT(4);
+      INDENT(4);
+      DEBUG_L("\n");
+      DEBUG_F( wolf_fence, info);
       
       // For locals
       //
@@ -1332,9 +1413,9 @@ str_reorg_instance_interleave_trans ( Info *info)
       tree decl;
       FOR_EACH_LOCAL_DECL ( func, i, decl)
 	{
-	  //DEBUG_A("local: ");
-	  //DEBUG_F( print_generic_decl, stderr, decl, (dump_flags_t)0);
-	  //DEBUG("\n");
+	  DEBUG_A("local: ");
+	  DEBUG_F( print_generic_decl, stderr, decl, (dump_flags_t)0);
+	  DEBUG("\n");
 	  tree old_default_def = ssa_default_def ( func, decl);
 	  tree new_default_def;
 	  
@@ -1374,59 +1455,74 @@ str_reorg_instance_interleave_trans ( Info *info)
 		}
 	    }
 	}
-      //INDENT(-4);      
-
+      INDENT(-4);      
+      
       // Normal ssa name case
       DEBUG_L("Dangling Types for Normal SSA Names:\n");
-      //INDENT(4);
+      DEBUG_L("\n");
+      DEBUG_F( wolf_fence, info);
+      
+      INDENT(4);
       // We use len instead of using func->length() in the for loop test
       // because new ssa names are created in the loop body and we
       // shouldn't process them.
       unsigned int len = SSANAMES ( func)->length ();
-      //DEBUG_L("len = %d\n",len);
+      DEBUG_L("len = %d\n",len);
       for ( unsigned int i = 0; i < len; i++)
 	{
-	  //DEBUG_L("SSANAMES(func)[%d]\n",i);
+	  DEBUG_L("SSANAMES(func)[%d]\n",i);
 
 	  tree ssa_name = (*SSANAMES ( func))[i];
 
 	  if( ssa_name == NULL )
 	    {
-	      //DEBUG_L("Skip, ssa_name == NULL\n");
-	      continue;
-	    }
-
-	  if ( ssa_defined_default_def_p ( ssa_name))
-	    {
-	      //DEBUG_L("Skip, ssa_name ");
-	      //DEBUG_F(print_generic_expr, stderr, ssa_name, (dump_flags_t)0);
-	      //DEBUG(" is default_def\n");
+	      DEBUG_L("Skip, ssa_name == NULL\n");
 	      continue;
 	    }
 
+	  bool a_default_def = SSA_NAME_IS_DEFAULT_DEF ( ssa_name);
+	  gimple *defining_stmt = SSA_NAME_DEF_STMT ( ssa_name);;
+	  bool no_defining_stmt = defining_stmt == NULL;
+	  bool defined_by_nop = defining_stmt && gimple_code ( defining_stmt) == GIMPLE_NOP;
 	  tree type = TREE_TYPE ( ssa_name);
 	  tree bottom_type = base_type_of ( type);
 	  ReorgType_t *ri = get_reorgtype_info ( bottom_type, info);
-	  //DEBUG_L("ssa_name = ");
-	  //DEBUG_F(print_generic_expr, stderr, ssa_name, (dump_flags_t)0);
-	  //DEBUG(", type = ");
-	  //DEBUG_F(print_generic_expr, stderr, type, (dump_flags_t)0);
-	  //DEBUG(", bottom_type = ");
-	  //DEBUG_F(print_generic_expr, stderr, bottom_type, (dump_flags_t)0);
-	  //DEBUG(", ri = %p\n",ri);
+	  DEBUG_L("ssa_name = ");
+	  DEBUG_F(print_generic_expr, stderr, ssa_name, (dump_flags_t)0);
+	  DEBUG(" %s", a_default_def ? "is default_def" : "");
+	  DEBUG(" %s", no_defining_stmt ? "has no defining stmt" : "");
+	  DEBUG(" %s", defined_by_nop ? "defined by a nop" : "");
+	  DEBUG(", type = ");
+	  DEBUG_F(print_generic_expr, stderr, type, (dump_flags_t)0);
+	  DEBUG(", bottom_type = ");
+	  DEBUG_F(print_generic_expr, stderr, bottom_type, (dump_flags_t)0);
+	  DEBUG(", ri = %p\n",ri);
 
 	  // If it's not a dangling type we don't care
 	  if ( ri == NULL )
 	    {
-	      //DEBUG_L("Skip, ri == NULL\n");
+	      DEBUG_L("Skip, ri == NULL\n");
+	      continue;
+	    }
+
+	  // A default def is processed seperately
+	  if ( a_default_def )
+	    {
+	      DEBUG_L("Skip default_def\n");
 	      continue;
 	    }
 
+	  gcc_assert ( !no_defining_stmt);
+	  gcc_assert ( !defined_by_nop);
+
+	  DEBUG_L("Defining stmt: ");
+	  DEBUG_F ( print_gimple_stmt, stderr, defining_stmt, 0);
+
 	  tree new_type = ri->pointer_rep;
 	  tree new_ssa_name = make_temp_ssa_name( new_type, NULL, "dedangled");
-	  //DEBUG_L("new_ssa_name = ");
-	  //DEBUG_F(print_generic_expr, stderr, new_ssa_name, (dump_flags_t)0);
-	  //DEBUG("\n");
+	  DEBUG_L("new_ssa_name = ");
+	  DEBUG_F(print_generic_expr, stderr, new_ssa_name, (dump_flags_t)0);
+	  DEBUG("\n");
 	  #if DEBUGGING
 	  for ( unsigned int j = 0; j < SSANAMES ( func)->length (); j++)
 	    {
@@ -1442,9 +1538,9 @@ str_reorg_instance_interleave_trans ( Info *info)
 	  imm_use_iterator iter;
 	  FOR_EACH_IMM_USE_STMT ( use_stmt, iter, ssa_name)
 	    {
-	      //DEBUG_L("use_stmt: ");
-	      //DEBUG_F ( print_gimple_stmt, stderr, use_stmt, 0);
-
+	      DEBUG_L("use_stmt: ");
+	      DEBUG_F ( print_gimple_stmt, stderr, use_stmt, 0);
+	      
 	      // Deal with the uses
 	      use_operand_p use_p;
 	      ssa_op_iter ssa_iter;
@@ -1452,7 +1548,7 @@ str_reorg_instance_interleave_trans ( Info *info)
 	      //FOR_EACH_SSA_USE_OPERAND( use_p, use_stmt, ssa_iter, SSA_OP_USE )
 	      FOR_EACH_PHI_OR_STMT_USE ( use_p, use_stmt, ssa_iter, SSA_OP_USE )
 		{
-		  //DEBUG_L("use_p = %p\n",use_p);
+		  DEBUG_L("use_p = %p\n",use_p);
 		  if ( use_p == NULL ) continue;
 		  tree use = USE_FROM_PTR (use_p);
 		  if (use == ssa_name)
@@ -1461,49 +1557,80 @@ str_reorg_instance_interleave_trans ( Info *info)
 	      // Should update_stmt be called here?
 	      // It does not seem either harm or help so I'll
 	      // leave it in.
+#if TOGUPD3
 	      update_stmt ( use_stmt);
+#endif
 	    }
 	  // Modify the LHS too
 	  // TBD This code needs to be more general.
+	  DEBUG_L("What is ssa_name? ");
+	  DEBUG_F(flexible_print, stderr, ssa_name, (dump_flags_t)0);
+	  DEBUG("\n");
 	  gimple *def = SSA_NAME_DEF_STMT ( ssa_name);
 	  
-	  //DEBUG_L("def: ");
-	  //DEBUG_F ( print_gimple_stmt, stderr, def, 0);
-
-	  // Note, the following code might be a bit overly
-	  // simplistic.
+	  DEBUG_L("def: ");
+	  DEBUG_F ( print_gimple_stmt, stderr, def, 0);
 	  
-	  if ( gimple_code ( def) == GIMPLE_ASSIGN ) 
-	    {
-	      gimple_assign_set_lhs ( def, new_ssa_name);
-	    }
-	  else
-	  if ( gimple_code ( def) == GIMPLE_CALL ) 
-	    {
-	      gimple_call_set_lhs ( def, new_ssa_name);
-	    }
-	  else
-	    continue;
+	  set_lhs_for ( def, new_ssa_name);
 
+	  #if TOGUPD4
+	  update_stmt ( def);
+	  #endif
 	  // This is where we know that ssa_name needs to be replaced
+	  #if TOGSSA2
 	  release_ssa_name_fn ( func, ssa_name);
+	  #endif
+	  
 	}
-      //INDENT(-4);
+      INDENT(-4);
+
+      // Might be a bad idea.
+      #if 0
+      for ( auto iter = ssa_to_delete.begin ();iter != ssa_to_delete.end (); iter++ )
+	{
+	  remove_default_def ( *iter, func);
+	}
+      #endif
 
       pop_cfun ();
     }
 
   DEBUG_L("after mini-passes\n");
 
-  // TBD Should this be a diagnostic or not?
-  //DEBUG ("INTERNALS PRINT\n");
-  //DEBUG_F (apply_to_all_gimple, print_internals, true, (void *)info);
-
   if ( info->show_all_reorg_cands )
     {
       fprintf ( info->reorg_dump_file, "End of str_reorg_instance_interleave_trans:\n");
       print_program ( info->reorg_dump_file, PRINT_FORMAT, 4, info);
     }
+  
+  // TBD Should this be a diagnostic or not?
+  DEBUG ("INTERNALS PRINT\n");
+  DEBUG_F (apply_to_all_gimple, print_internals, true, (void *)info);
+}
+
+// Note, the following code might be a bit overly simplistic.
+static void
+set_lhs_for ( gimple *stmt, tree ssa_name)
+{
+  switch ( gimple_code ( stmt))
+    {
+    case GIMPLE_ASSIGN:
+      gimple_assign_set_lhs ( stmt, ssa_name);
+      break;
+    case GIMPLE_CALL:
+      gimple_call_set_lhs ( stmt, ssa_name);
+      break;
+    case GIMPLE_PHI:
+		  {
+		    gphi *phi_stmt = as_a <gphi *> ( stmt);
+		    gimple_phi_set_result ( phi_stmt, ssa_name);
+		  }
+		  break;
+    default:
+      fprintf ( stderr, "error: unprecidented gimple for set_lhs_for\n    ");
+      print_gimple_stmt( stderr, stmt, 0);
+      gcc_assert ( 0);
+    }
 }
 
 // TBD no longer used... preserve it for a bit, then remove it.
@@ -1585,6 +1712,9 @@ print_internals (gimple *stmt, void *data)
       gcc_assert ( rhs1);
       
       bool lhs_reorg = tree_contains_a_reorgtype_p ( lhs, info);
+      //DEBUG_L("rhs1 = ");
+      //DEBUG_F(flexible_print, stderr, rhs1, (dump_flags_t)0);
+      //DEBUG("\n");
       bool rhs1_reorg = tree_contains_a_reorgtype_p ( rhs1, info);
       bool rhs2_reorg = tree_contains_a_reorgtype_p ( rhs2, info);
       bool rhs3_reorg = tree_contains_a_reorgtype_p ( rhs3, info);