Added fix for changing the type of ssa temps.

In the middle of program_print change to dump declarations (there are
bugs with modifying decls.)

3 files changed, 401 insertions, 130 deletions

diff --git a/gcc/ipa-str-reorg-instance-interleave.c b/gcc/ipa-str-reorg-instance-interleave.c
index cc2969ab598..d3087f9e1f2 100644
--- a/gcc/ipa-str-reorg-instance-interleave.c
+++ b/gcc/ipa-str-reorg-instance-interleave.c
@@ -50,6 +50,7 @@ static void wrangle_ssa_type( tree, Info_t*);
 static bool print_internals (gimple *, void *);
 static void str_reorg_instance_interleave_qual_part ( Info *);
 static void str_reorg_instance_interleave_type_part ( Info *);
+static void header ( bool);
 static void create_new_types ( Info_t *);
 static void create_a_new_type ( Info_t *, tree);
 static unsigned int reorg_perf_qual ( Info *);
@@ -249,14 +250,14 @@ str_reorg_instance_interleave_trans ( Info *info)
 
 			    tree rhs_faa = build3 ( COMPONENT_REF,
 						    // ???
-						    //base_field_type, 
-						    ptr_type_node, // This seems bogus
+						    base_field_type, 
+						    //ptr_type_node, // This seems bogus
 						    base,
-						    //base_field,
+						    base_field,
 						    // This almost certainly is bogus
 						    // If this "works" the the types
 						    // of fields are messed up.
-						    orig_field,
+						    //orig_field,
 						    NULL_TREE);
 
 		            // Use this to access the array of element.
@@ -446,42 +447,60 @@ str_reorg_instance_interleave_trans ( Info *info)
 		      // the type of pointer_sized_int_node is probably not correct
 		      // even though that's the representation.
 
+		      tree PPI_orig_lhs = gimple_assign_lhs ( stmt);
+
 		      tree offset_type = TREE_TYPE ( TYPE_SIZE_UNIT (ri->gcc_type));
 		      tree type = ri->pointer_rep;
-		      tree ptrplusint_adj =  make_temp_ssa_name( type, NULL, "PtrPlusInt_Adj");
+
 		      tree str_siz =
 			build_int_cst ( type, int_cst_value ( TYPE_SIZE_UNIT (ri->gcc_type)));
+		      
 		      tree rhs1 = gimple_assign_rhs1( stmt);
 		      tree rhs2 = gimple_assign_rhs2( stmt);
+		      
+		      tree PPI_rhs1_cast = make_temp_ssa_name( type, NULL, "PPI_rhs1_cast");
+		      gimple *gPPI_rhs1_cast = gimple_build_assign ( PPI_rhs1_cast, CONVERT_EXPR, rhs1);
+		      SSA_NAME_DEF_STMT ( PPI_rhs1_cast) = gPPI_rhs1_cast;
+		      
 		      tree PPI_rhs2_cast = make_temp_ssa_name( type, NULL, "PPI_rhs2_cast");
 		      gimple *gPPI_rhs2_cast = gimple_build_assign ( PPI_rhs2_cast, CONVERT_EXPR, rhs2);
 		      SSA_NAME_DEF_STMT ( PPI_rhs2_cast) = gPPI_rhs2_cast;
-		      
-		      gimple *gptrplusint_adj =
-			gimple_build_assign ( ptrplusint_adj, TRUNC_DIV_EXPR, PPI_rhs2_cast, str_siz);
-		      SSA_NAME_DEF_STMT ( ptrplusint_adj) = gptrplusint_adj;
+
+		      tree PPI_adj =  make_temp_ssa_name( type, NULL, "PtrPlusInt_Adj");
+		      gimple *gPPI_adj =
+			gimple_build_assign ( PPI_adj, TRUNC_DIV_EXPR, PPI_rhs2_cast, str_siz);
+		      SSA_NAME_DEF_STMT ( PPI_adj) = gPPI_adj;
 		      // Note, gimple_set_op is used in limited places so using it
 		      // to modify existed code might be problematic. NOOOOOOOOOOOOOOOOOO!!!!!!!
 		      // TBD <==================================================================
 		      // Build a regular add expression here using the desination of stmt and its
 		      // first operand along with the new second operand.
 		      tree ptrplusint =  make_temp_ssa_name( type, NULL, "PtrPlusInt");
-		      gimple *gptrplusint =
-			gimple_build_assign ( ptrplusint, PLUS_EXPR, rhs1, ptrplusint_adj);
-		      SSA_NAME_DEF_STMT ( ptrplusint) = gptrplusint;
+		      gimple *gPPI =
+		      	gimple_build_assign ( ptrplusint, PLUS_EXPR, PPI_rhs1_cast, PPI_adj);
+		      SSA_NAME_DEF_STMT ( ptrplusint) = gPPI;
+		      gimple *gPPI_cast = 
+			gimple_build_assign ( PPI_orig_lhs, CONVERT_EXPR, ptrplusint);
+		      SSA_NAME_DEF_STMT ( PPI_orig_lhs) = gPPI_cast;
 		      
 		      //gimple_set_op( stmt, 2, tmp);
 		      gimple_stmt_iterator gsi = gsi_for_stmt( stmt);
+		      gsi_insert_before( &gsi, gPPI_rhs1_cast, GSI_SAME_STMT);
 		      gsi_insert_before( &gsi, gPPI_rhs2_cast, GSI_SAME_STMT);
-		      gsi_insert_before( &gsi, gptrplusint_adj, GSI_SAME_STMT);
-		      gsi_insert_before( &gsi, gptrplusint, GSI_SAME_STMT);
+		      gsi_insert_before( &gsi, gPPI_adj, GSI_SAME_STMT);
+		      gsi_insert_before( &gsi, gPPI, GSI_SAME_STMT);
+		      gsi_insert_before( &gsi, gPPI_cast, GSI_SAME_STMT);
 
 		      gsi_remove ( &gsi, true);
-		      
+
+		      DEBUG_L("");
+		      DEBUG_F( print_gimple_stmt, stderr, gPPI_rhs2_cast, 0);
 		      DEBUG_L("");
-		      DEBUG_F( print_gimple_stmt, stderr, gptrplusint_adj, 0);
+		      DEBUG_F( print_gimple_stmt, stderr, gPPI_adj, 0);
 		      DEBUG_L("");
-		      DEBUG_F( print_gimple_stmt, stderr, gptrplusint, 0);
+		      DEBUG_F( print_gimple_stmt, stderr, gPPI, 0);
+		      DEBUG_L("");
+		      DEBUG_F( print_gimple_stmt, stderr, gPPI_cast, 0);
 		      
 		    }
 		    break;
@@ -679,6 +698,20 @@ str_reorg_instance_interleave_trans ( Info *info)
 			{
 			  basic_block new_bb = create_empty_bb ( prev_order);
 			  new_bb->count = prev_order->count;
+			    
+			  tree base_field =
+			      find_coresponding_field ( base, field);
+
+			  DEBUG_L("base_field: %p\n", base_field);
+			  DEBUG_A("  : ");
+			  DEBUG_F(print_generic_expr, stderr, base_field, (dump_flags_t)0);
+			  DEBUG("\n");
+
+			  tree base_field_type = TREE_TYPE( base_field);
+			  DEBUG_L("base_field_type: %p\n", base_field_type);
+			  DEBUG_A("  : ");
+			  DEBUG_F(print_generic_expr, stderr, base_field_type, (dump_flags_t)0);
+			  DEBUG("\n");
 			  
 			  gimple_stmt_iterator gsi = gsi_start_bb ( new_bb);
 			  // Note, switching the order of edge creation and
@@ -696,7 +729,7 @@ str_reorg_instance_interleave_trans ( Info *info)
 			  // TBD what happens if I punt on this????
 			  //set_immediate_dominator ( CDI_DOMINATORS, new_bb, prev_bb);
 
-			  // TBD set edge probability and flags
+			  // create edge and set edge probability and flags
 			  edge fail_edge = make_edge ( new_bb, failure_bb, EDGE_FALSE_VALUE);
 			  fail_edge->probability = profile_probability::very_unlikely ();
 			  fail_edge->count () = new_bb->count - new_bb->count;
@@ -706,30 +739,12 @@ str_reorg_instance_interleave_trans ( Info *info)
 			    create_artificial_label ( UNKNOWN_LOCATION);
 			  #endif
 
-			  tree res = 
-			    make_temp_ssa_name ( ptr_type_node, NULL, "res");
-			  gimple *gcond =
-			    gimple_build_cond ( NE_EXPR, res, null_pointer_node,
-						#if USE_LABELS
-						new_ok_field_L, bad_field_L
-						#else
-						NULL, NULL
-						#endif
-						);
-			  #if USE_LABELS
-			  // Moved label here from end
-			  gimple *gprev_ok_field = gimple_build_label ( prev_ok_field_L);
-			  gsi_insert_after ( &gsi, gprev_ok_field, GSI_NEW_STMT);
-			  #else
-			  // This just makes adding code after this easier
-			  gimple *dummy = gimple_build_nop ();
-			  gsi_insert_after ( &gsi, dummy, GSI_NEW_STMT);
-			  #endif
-			  //gsi_insert_after ( &gsi, gcond, GSI_SAME_STMT);		
-			  gsi_insert_after ( &gsi, gcond, GSI_SAME_STMT);		
-			  // FROM gsi_insert_after( &gsi, "base.field = res")
-			  tree lhs_ass =
-			    build3( COMPONENT_REF, ptr_type_node, base, field, NULL_TREE);
+			  //tree lhs_ass =
+			  //  build3( COMPONENT_REF, ptr_type_node, base, field, NULL_TREE);
+			  tree lhs_ass = build3( COMPONENT_REF,
+						 base_field_type,
+						 base,
+						 base_field, NULL_TREE);
 
 			  DEBUG_L("base: %p\n", base);
 			  DEBUG_A("  base: ");
@@ -751,57 +766,96 @@ str_reorg_instance_interleave_trans ( Info *info)
 			  DEBUG_A("  lhs_ass: ");
 			  DEBUG_F(print_generic_expr, stderr, lhs_ass, (dump_flags_t)0);
 			  DEBUG("\n");
-			  
-			  gimple *gset_field = gimple_build_assign( lhs_ass, res);
-			  
-			  gsi_insert_after( &gsi, gset_field, GSI_SAME_STMT);
-			  
-			  // FROM gsi_insert_after( &gsi, "res = malloc( mem_size)")
-			  // The alternative to sizetype are long_integer_type_node
-			  // and integer_type_node.
-			  // TBD NOTE! We insert the instructions into block
-			  // in reverse order but we don't need to create the GIMPLE
-			  // for them that way. This screams out for a reordering.
+
+			  tree lhs_ass_type = TREE_TYPE ( lhs_ass);
+			  DEBUG_L("lhs_ass_type: %p\n", lhs_ass_type);
+			  DEBUG_A("  lhs_ass_type: ");
+			  DEBUG_F(print_generic_expr, stderr, lhs_ass_type, (dump_flags_t)0);
+			  DEBUG("\n");
+
 			  tree mem_size = 
 			    make_temp_ssa_name( sizetype, NULL, "malloc_mem_size");
-			  gcall *malloc_call = gimple_build_call( fndecl_malloc, 1, mem_size);
-			  gimple_call_set_lhs( malloc_call, res);
-			  SSA_NAME_DEF_STMT ( res) = malloc_call;
-			  gsi_insert_after( &gsi, malloc_call, GSI_SAME_STMT);
-
-			  cgraph_node::get ( cfun->decl)->
-			    create_edge ( cgraph_node::get_create ( fndecl_malloc),
-					  malloc_call,
-					  // Nah... lets do this a bit differently
-					  //gimple_bb ( free_call)->count
-					  new_bb->count
-					  );
 			  
-			  // FROM gsi_insert_after( &gsi, "mem_size = len * field_size")
-			  //gimple *gsize = 
-			  //  gimple_build_assign ( mem_size, MULT_EXPR, TYPE_SIZE(field), 
-			  //			len, NULL_TREE, NULL_TREE);
-
 			  // We need field_size to be of the correct type so
 			  // we type cast.
 			  tree field_size =
 			    make_temp_ssa_name( TREE_TYPE ( mem_size), NULL, "field_size");
+
+			  // Move gprev_ok_field here
+			  #if USE_LABELS
+			  gimple *gprev_ok_field = gimple_build_label ( prev_ok_field_L);
+			  #endif
+			  
+			  // Move gfield_size here
 			  gimple *gfield_size =
 			    gimple_build_assign ( field_size,
 						  CONVERT_EXPR,
 						  TYPE_SIZE ( TREE_TYPE ( field)));
 			  SSA_NAME_DEF_STMT ( field_size) = gfield_size;
 
+			  // Move gsize here
 			  gimple *gsize = 
 			    gimple_build_assign ( mem_size,
 						  MULT_EXPR,
 						  field_size,
 						  len);
 			  SSA_NAME_DEF_STMT ( mem_size) = gsize;
+
+			  tree res = 
+			    make_temp_ssa_name ( ptr_type_node, NULL, "res");
+
+			  tree cast_res =
+			    make_temp_ssa_name ( TREE_TYPE ( base_field), NULL, "cast_res");
+
+			  tree res_type = TREE_TYPE( res);
+			  DEBUG_L("res_type: %p\n", res_type);
+			  DEBUG_A("  : ");
+			  DEBUG_F(print_generic_expr, stderr, res_type, (dump_flags_t)0);
+			  DEBUG("\n");
+
+			  // Move malloc_call here
+			  gcall *malloc_call = gimple_build_call( fndecl_malloc, 1, mem_size);
+			  gimple_call_set_lhs( malloc_call, res);
+			  SSA_NAME_DEF_STMT ( res) = malloc_call;
+			  //gsi_insert_after( &gsi, malloc_call, GSI_SAME_STMT);
+
+			  cgraph_node::get ( cfun->decl)->
+			    create_edge ( cgraph_node::get_create ( fndecl_malloc),
+					  malloc_call,
+					  // Nah... lets do this a bit differently
+					  //gimple_bb ( free_call)->count
+					  new_bb->count
+					  );
+			  
+			  gimple *gcast_res =
+			    gimple_build_assign ( cast_res, CONVERT_EXPR, res);
+			  SSA_NAME_DEF_STMT ( cast_res) = gcast_res;
 			  
-			  gsi_insert_after ( &gsi, gsize, GSI_SAME_STMT);
+			  // Move gset_field here
+			  gimple *gset_field = gimple_build_assign ( lhs_ass, cast_res);
 
-			  gsi_insert_after ( &gsi, gfield_size, GSI_SAME_STMT);
+			  // Move gcond here
+			  gimple *gcond =
+			    gimple_build_cond ( NE_EXPR, res, null_pointer_node,
+						#if USE_LABELS
+						new_ok_field_L, bad_field_L
+						#else
+						NULL, NULL
+						#endif
+						);
+
+			  // Last is first
+			  gsi_insert_before ( &gsi, gcond, GSI_NEW_STMT);
+			  
+			  // The rest in order before the last
+			  #if USE_LABELS
+			  gsi_insert_before ( &gsi, gprev_ok_field, GSI_SAME_STMT);
+			  #endif
+			  gsi_insert_before ( &gsi, gfield_size, GSI_SAME_STMT);
+			  gsi_insert_before ( &gsi, gsize, GSI_SAME_STMT);
+			  gsi_insert_before ( &gsi, malloc_call, GSI_SAME_STMT);
+			  gsi_insert_before ( &gsi, gcast_res, GSI_SAME_STMT);
+			  gsi_insert_before ( &gsi, gset_field, GSI_SAME_STMT);
 			  
 			  prev_bb = new_bb;
 			  prev_order = new_bb;
@@ -881,12 +935,22 @@ str_reorg_instance_interleave_trans ( Info *info)
 		      
 		      // Note, BBs have a sequence of phis which create_phi_node takes care of
 		      // adding this phi too.
-		      gphi *der_phi = create_phi_node( val, after_bb);
-		      // OPS!
-		      //add_phi_arg( der_phi, success_val, success_edge, UNKNOWN_LOCATION);
+		      tree m_phi_val =
+			make_temp_ssa_name ( TREE_TYPE ( success_val), NULL, "m_phi_val");
+		      gphi *der_phi = create_phi_node( m_phi_val, after_bb);
 		      add_phi_arg( der_phi, success_val, succ_to_after_e, UNKNOWN_LOCATION);
 		      add_phi_arg( der_phi, fail_val, fail_to_after_e, UNKNOWN_LOCATION);
 
+		      gimple *gm_cast_phi_val =
+			gimple_build_assign ( val, CONVERT_EXPR, m_phi_val);
+		      SSA_NAME_DEF_STMT ( val) = gm_cast_phi_val;
+
+		      #if USE_LABELS
+		      gsi_insert_after( &gsi, gm_cast_phi_val, GSI_SAME_STMT);
+		      #else
+		      gsi_insert_after( &gsi, gm_cast_phi_val, GSI_NEW_STMT);
+		      #endif
+
 		      //// FROM gsi_insert_after( &gsi, after_label)
 		      //gimple *gafter_label = gimple_build_label( after_label_L);
 		      //gsi_insert_after( &gsi, gafter_label, GSI_SAME_STMT);
@@ -926,22 +990,29 @@ str_reorg_instance_interleave_trans ( Info *info)
 		      // Don't use the builtin!
 		      //tree fndecl_free = builtin_decl_explicit( BUILT_IN_FREE);
 
-		      //tree base = ri->reorg_ver_type;
 		      for( field = TYPE_FIELDS( reorg_type); 
 			   field; 
 			   field = DECL_CHAIN( field)) {
-			// FROM gsi_insert_after( &gsi, "base.field = 0")
-			tree lhs_ass =
-			  build3( COMPONENT_REF, ptr_type_node, base, field, NULL_TREE);
+
+			tree base_field =
+			      find_coresponding_field ( base, field);
+			tree base_field_type = TREE_TYPE( base_field);
+			
+			tree lhs_ass = build3( COMPONENT_REF,
+					       base_field_type,
+					       base,
+					       base_field, NULL_TREE);
+			
 			gimple *gzero = gimple_build_assign( lhs_ass, null_pointer_node);
 			gsi_insert_after( &gsi, gzero, GSI_SAME_STMT);
+
+			tree m_cast2free =
+			  make_temp_ssa_name( ptr_type_node, NULL, "m_cast2free");
 			
 			// Tried reorg_pointer_type
-			//tree to_free = 
-			//  make_temp_ssa_name( reorg_pointer_type, NULL, "malloc_to_free");
-			tree to_free = 
-			  make_temp_ssa_name( ptr_type_node, NULL, "malloc_to_free");
-			gcall *free_call = gimple_build_call( fndecl_free, 1, to_free);
+			tree m_to_free = 
+			  make_temp_ssa_name( base_field_type, NULL, "malloc_to_free");
+			gcall *free_call = gimple_build_call( fndecl_free, 1, m_cast2free);
 			gsi_insert_after( &gsi, free_call, GSI_SAME_STMT);
 			
 			cgraph_node::get ( cfun->decl)->
@@ -955,10 +1026,19 @@ str_reorg_instance_interleave_trans ( Info *info)
 			// TBD Note, this brings up the question of bb counts which is being
 			// punted on
 			
-			tree rhs_ass =
-			  build3( COMPONENT_REF, ptr_type_node, base, field, NULL_TREE);
-			gimple *gaddr2free = gimple_build_assign( to_free, rhs_ass);
-			SSA_NAME_DEF_STMT ( to_free) = gaddr2free;
+			tree rhs_ass = build3( COMPONENT_REF,
+			    base_field_type,
+			    base,
+			    base_field, NULL_TREE);
+
+			gimple *gm_cast2free =
+			  gimple_build_assign( m_cast2free, CONVERT_EXPR, m_to_free);
+			SSA_NAME_DEF_STMT ( m_cast2free) = gm_cast2free;
+
+			gsi_insert_after( &gsi, gm_cast2free, GSI_SAME_STMT);
+			
+			gimple *gaddr2free = gimple_build_assign( m_to_free, rhs_ass);
+			SSA_NAME_DEF_STMT ( m_to_free) = gaddr2free;
 			
 			gsi_insert_after( &gsi, gaddr2free, GSI_SAME_STMT);
 		      }
@@ -1172,6 +1252,11 @@ str_reorg_instance_interleave_trans ( Info *info)
 		    
 		    DEBUG_L("ReorgT_UserFunc\n");
 		    break;
+		  case ReorgT_Convert:
+		    // Ignore type casting because another
+		    // mini-pass sweeps up any ugly dangling types.
+		    DEBUG_L("ReorgT_Convert\n");
+		    break;
 		  case ReorgT_Return:
 		    // TBD The type must be adjusted (maybe.)
 		    DEBUG_L("ReorgT_Return\n");
@@ -1191,7 +1276,7 @@ str_reorg_instance_interleave_trans ( Info *info)
   int mini_pass; // Passes 0 and two are just for testing
   for ( mini_pass = 0; mini_pass < 3; mini_pass++ )
     {
-      bool emit_header = true;
+      header ( true);
       FOR_EACH_FUNCTION_WITH_GIMPLE_BODY ( node)  {
 	struct function *func = DECL_STRUCT_FUNCTION ( node->decl);
 	// Ulgy GCC idiom with global pointer to current function.
@@ -1199,6 +1284,57 @@ str_reorg_instance_interleave_trans ( Info *info)
 	basic_block bb;
 	FOR_EACH_BB_FN ( bb, func)
 	  {
+	    gimple_seq seq = bb->il.gimple.phi_nodes;
+	    if ( seq )
+	      {
+		gimple_stmt_iterator phii;
+		for ( phii = gsi_start (seq); !gsi_end_p (phii); gsi_next (&phii))
+		  {
+		    gimple *phi_stmt = gsi_stmt ( phii);
+		    if ( contains_a_reorgtype( phi_stmt, info) )
+		      {
+			tree lhs = gimple_assign_lhs( phi_stmt);
+			if ( tree_contains_a_reorgtype_p ( lhs, info) )
+			  {
+			    if ( mini_pass == 0 || mini_pass == 2 )
+			      {
+				header ( false);
+				fprintf( stderr, "  LHS: ");
+				print_generic_expr ( stderr, TREE_TYPE ( lhs), (dump_flags_t)0);
+				fprintf( stderr, "  ");
+			      }
+			    else
+			      {
+				wrangle_ssa_type ( lhs, info);
+			      }
+			  }
+
+			// Wrangle the right hand side
+			unsigned num;
+			num = gimple_num_ops ( phi_stmt);
+			unsigned i;
+			for ( i = 1; i < num; i++ )
+			  {
+			    tree *op = gimple_op_ptr ( phi_stmt, i);
+			    if ( tree_contains_a_reorgtype_p ( *op, info) )
+			      {
+				if ( mini_pass == 0 || mini_pass == 2 )
+				  {
+				    header ( false);
+				    fprintf( stderr, "  RHS%d: ", i);
+				    print_generic_expr ( stderr, TREE_TYPE ( *op), (dump_flags_t)0);
+				    fprintf( stderr, "  ");
+				  }
+				else
+				  {
+				    wrangle_ssa_type ( *op, info);
+				  }
+			      }
+			  }
+		      }
+		  }
+	      }
+	    
 	    gimple_stmt_iterator gsi;
 	    for ( gsi = gsi_start_bb ( bb); !gsi_end_p ( gsi); gsi_next ( &gsi) )
 	      {
@@ -1225,29 +1361,23 @@ str_reorg_instance_interleave_trans ( Info *info)
 
 			if ( mini_pass == 0 || mini_pass == 2 )
 			  {
-			    if ( lhs_reorg || rhs1_reorg || rhs2_reorg|| rhs3_reorg)
-			      {
-				if ( emit_header )
-				  {
-				    emit_header = false;
-				    fprintf( stderr, "SANITY CHECKING FAILURE:\n");
-				  }
-				print_gimple_stmt ( stderr, stmt, 0);
-			      }
 			    if ( lhs_reorg )
 			      {
+				header ( false);
 				fprintf( stderr, "  LHS%s: ", lhs_ssa ? "*" : "");
 				print_generic_expr ( stderr, TREE_TYPE ( lhs), (dump_flags_t)0);
 				fprintf( stderr, "  ");
 			      }
 			    if ( rhs1_reorg )
 			      {
+				header ( false);
 				fprintf( stderr, "%s  RHS1%s: ", lhs_reorg ? ",  " : "",
 					 rhs1_ssa ? "*" : "");
 				print_generic_expr ( stderr, TREE_TYPE ( rhs1), (dump_flags_t)0);
 			      }
 			    if ( rhs2_reorg )
 			      {
+				header ( false);
 				fprintf( stderr, "%s  RHS2%s: ",
 					 lhs_reorg || rhs1_reorg ? ",  " : "",
 					 rhs2_ssa ? "*" : "");
@@ -1255,6 +1385,7 @@ str_reorg_instance_interleave_trans ( Info *info)
 			      }
 			    if ( rhs3_reorg )
 			      {
+				header ( false);
 				fprintf( stderr, "%s  RHS3%s: ",
 					 lhs_reorg || rhs1_reorg || rhs2_reorg ? ",  " : "",
 					 rhs3_ssa ? "*" : "");
@@ -1270,6 +1401,9 @@ str_reorg_instance_interleave_trans ( Info *info)
 			  {
 			    if ( lhs_ssa )
 			      {
+				#if 1
+				wrangle_ssa_type ( lhs, info);
+				#else
 				tree lhs_type = TREE_TYPE ( lhs);
 				tree bottom_type = base_type_of ( lhs_type);
 				DEBUG_L("lhs: ");
@@ -1291,13 +1425,14 @@ str_reorg_instance_interleave_trans ( Info *info)
 				    DEBUG_L( "prev_type: %p, type: %p\n", prev_type, type);
 				  }
 
-				#if 0
-				// Modify type of ssa temp (dicey!)
-				// This changes every instance of * reorg_type to the
-				// new pointre rep in one fell swoop.
-				// I sweat just thinking how crazy this is....
-				TREE_TYPE ( prev_type) = ri->pointer_rep;
-				#endif
+				// I thought about doing this:
+				//   Modify type of ssa temp (dicey!)
+				//   This changes every instance of * reorg_type to the
+				//   new pointre rep in one fell swoop.
+				//   I sweat just thinking how crazy this is....
+				//
+				//   TREE_TYPE ( prev_type) = ri->pointer_rep;
+
 				// TBD might use build_pointer_type to build new type for *(N)reorg_type
 				// to *(N-1)ri->pointer_rep
 				// Fakes this for levels == 1
@@ -1316,6 +1451,7 @@ str_reorg_instance_interleave_trans ( Info *info)
 					gcc_assert(0);
 				      }
 				  }
+				#endif
 			      }
 			    if ( rhs1_ssa )
 			      {
@@ -1339,7 +1475,7 @@ str_reorg_instance_interleave_trans ( Info *info)
     }
 
   fprintf ( stderr, "INTERNALS PRINT\n");
-  apply_to_all_gimple ( print_internals, (void *)info);
+  apply_to_all_gimple ( print_internals, true, (void *)info);
 
   if ( info->show_all_reorg_cands )
     {
@@ -1353,7 +1489,7 @@ wrangle_ssa_type( tree side, Info_t *info )
 {
   tree side_type = TREE_TYPE ( side);
   tree bottom_type = base_type_of ( side_type);
-  DEBUG_L("side: ");
+  DEBUG_L("op: ");
   DEBUG_F(print_generic_expr, stderr, side, (dump_flags_t)0);
   DEBUG("\n");
   DEBUG_L("bottom_type: ");
@@ -1373,20 +1509,21 @@ wrangle_ssa_type( tree side, Info_t *info )
       DEBUG_L( "prev_type: %p, type: %p\n", prev_type, type);
     }
 
-#if 0
-  // Modify type of ssa temp (dicey!)
-  // This changes every instance of * reorg_type to the
-  // new pointre rep in one fell swoop.
-  // I sweat just thinking how crazy this is....
-  TREE_TYPE ( prev_type) = ri->pointer_rep;
-#endif
+  // I thought about doing this:
+  //   Modify type of ssa temp (dicey!)
+  //   This changes every instance of * reorg_type to the
+  //   new pointre rep in one fell swoop.
+  //   I sweat just thinking how crazy this is....
+  //
+  //   TREE_TYPE ( prev_type) = ri->pointer_rep;
+
   // TBD might use build_pointer_type to build new type for *(N)reorg_type
   // to *(N-1)ri->pointer_rep
   // Fakes this for levels == 1
   if ( levels == 0)
     {
       DEBUG_L( "LEVELS  ZERO\n");
-      TREE_TYPE ( side) = ri->pointer_rep;
+      modify_ssa_name_type ( side, ri->pointer_rep);
     }
   else
     {
@@ -1395,7 +1532,6 @@ wrangle_ssa_type( tree side, Info_t *info )
     }
 }
 
-
 static bool
 print_internals (gimple *stmt, void *data)
 {
@@ -1440,11 +1576,39 @@ print_internals (gimple *stmt, void *data)
 	  print_generic_expr ( stderr, TREE_TYPE ( rhs3), (dump_flags_t)0);
 	}
       fprintf ( stderr, "\n");
-    }
+    } else
+    if ( gimple_code ( stmt) == GIMPLE_PHI )
+      {
+	use_operand_p phi_op;
+	ssa_op_iter iter;
+	gphi *phi_stmt = dyn_cast <gphi *> ( stmt);
+
+	tree def = PHI_RESULT ( phi_stmt);
+	fprintf( stderr, "  OP: ");
+	print_generic_expr ( stderr, def, (dump_flags_t)0);
+	fprintf( stderr, "  TYPE:  ");
+	print_generic_expr ( stderr, TREE_TYPE ( def), (dump_flags_t)0);
+	fprintf( stderr, "\n");
+	
+	FOR_EACH_PHI_ARG ( phi_op, phi_stmt, iter, SSA_OP_ALL_OPERANDS)
+	  {
+	    tree op = USE_FROM_PTR ( phi_op);
+	    fprintf( stderr, "  OP: ");
+	    print_generic_expr ( stderr, op, (dump_flags_t)0);
+	    fprintf( stderr, "  TYPE:  ");
+	    print_generic_expr ( stderr, TREE_TYPE ( op), (dump_flags_t)0);
+	    fprintf( stderr, "\n");
+	  }
+      }
+    else
+      {
+	// This is OK I believe unless checking CONDs is necessary
+	;
+      }
+    
   return false;
 }
 
-
 static void
 str_reorg_instance_interleave_qual_part ( Info *info)
 {
@@ -1475,6 +1639,24 @@ reorg_perf_qual ( Info *info)
     }
 }
 
+static void
+header ( bool initialize )
+{
+  static bool emit_header;
+  if ( initialize )
+    {
+      emit_header = true;
+    }
+  else
+    {
+      if ( emit_header )
+	{
+	  emit_header = false;
+	  fprintf( stderr, "SANITY CHECKING FAILURE:\n");
+	}
+    }
+}
+
 // create_new_types has to crawl "all" the
 // types, create new types and transform
 // other types that must be changed.
@@ -1599,7 +1781,7 @@ create_a_new_type ( Info_t *info, tree type)
 	tree new_fld_type = build_pointer_type ( tree_type);
 	tree new_decl =
 	  build_decl ( DECL_SOURCE_LOCATION (field),
-		       VAR_DECL, DECL_NAME (field), new_fld_type);
+		       FIELD_DECL, DECL_NAME (field), new_fld_type);
 	// Missing a bunch of attributes (see tree-nested.c:899)
 	// Let us seee what happens without them!
 	DECL_CHAIN ( new_decl) = new_fields; // <- bug: need decl, not type
diff --git a/gcc/ipa-structure-reorg.c b/gcc/ipa-structure-reorg.c
index f20336d4e2e..3376f00590a 100644
--- a/gcc/ipa-structure-reorg.c
+++ b/gcc/ipa-structure-reorg.c
@@ -1133,8 +1133,8 @@ reorg_recognize ( gimple *stmt, cgraph_node* node, Info_t *info )
 	  }
 	case ReorgOpT_Indirect:    // "a->f"
 	case ReorgOpT_AryDir:      // "x[i].f"
-	  DEBUG_L("case ReorgOpT_%s\n", lhs_op == ReorgOpT_Indirect ? "Indirect" : "AryDir");
-	  INDENT(-4);
+	  //DEBUG_L("case ReorgOpT_%s\n", lhs_op == ReorgOpT_Indirect ? "Indirect" : "AryDir");
+	  //INDENT(-4);
 	  switch ( recognize_op ( rhs, info) )
 	  {
 	  case ReorgOpT_Temp:      // t
@@ -1156,13 +1156,24 @@ reorg_recognize ( gimple *stmt, cgraph_node* node, Info_t *info )
 	//INDENT(2);
 	tree op1 = gimple_assign_rhs1 ( stmt);
 	tree op2 = gimple_assign_rhs2 ( stmt);
+	//DEBUG_L("op1 = %p, op2 = %p\n", op1, op2);
+	//DEBUG_A("");
+	//DEBUG_F( print_generic_expr, stderr, op1, (dump_flags_t)-1);
+	//DEBUG("\n");
+
+	if ( CONVERT_EXPR_CODE_P ( gimple_assign_rhs_code ( stmt)))
+	  {
+	    //DEBUG_L("CONVERT_EXPR_CODE_P (...)\n");
+	    //INDENT(-4);
+	    return ReorgT_Convert;
+	  }
 
 	if ( gimple_assign_rhs3 ( stmt) != NULL )
-	{
-	  //DEBUG_L("gimple_assign_rhs3 ( stmt) != NULL\n");
-	  //INDENT(-4);
-	  return Not_Supported;
-	}
+	  {
+	    //DEBUG_L("gimple_assign_rhs3 ( stmt) != NULL\n");
+	    //INDENT(-4);
+	    return Not_Supported;
+	  }
 	
 	// TBD The parenthesis where a disaster here in the HL Design so
 	// double check this!
@@ -1233,7 +1244,7 @@ reorg_recognize ( gimple *stmt, cgraph_node* node, Info_t *info )
       struct cgraph_edge *edge = node->get_edge ( stmt);
       gcc_assert( edge);
       //DEBUG_L("called function %s gimple_body\n",
-      //	    edge->callee->has_gimple_body_p() ? "has a" : "has no");
+      //	      edge->callee->has_gimple_body_p() ? "has a" : "has no");
       //INDENT(-2);
       if ( gimple_call_builtin_p( stmt, BUILT_IN_CALLOC ) ) return ReorgT_Calloc;
       if ( gimple_call_builtin_p( stmt, BUILT_IN_MALLOC ) ) return ReorgT_Malloc;
@@ -1369,7 +1380,7 @@ remove_deleted_types ( Info *info, ReorgFn reorg_fn)
 enum ReorgOpTrans
 recognize_op ( tree op,  Info *info)
 {
-  // DEBUG_L("recognize_op: ");
+  //DEBUG_L("recognize_op: ");
   //DEBUG_F( print_generic_expr, stderr, op, TDF_DETAILS);
   //DEBUG("\n");
   enum tree_code op_code = TREE_CODE ( op);
@@ -1546,7 +1557,7 @@ find_struct_type_ptr_to_struct ( tree type, Info *info)
 // The applied function func can be used to search because it forces
 // a return if it returns true;
 void
-apply_to_all_gimple ( bool (*function)(gimple *, void *), void *data )
+apply_to_all_gimple ( bool (*function)(gimple *, void *), bool phis_too, void *data )
 {
   struct cgraph_node *node;
   FOR_EACH_FUNCTION_WITH_GIMPLE_BODY ( node)
@@ -1556,6 +1567,19 @@ apply_to_all_gimple ( bool (*function)(gimple *, void *), void *data )
       basic_block bb;
       FOR_EACH_BB_FN ( bb, func)
 	{
+	  if ( phis_too )
+	    {
+	      gimple_seq seq = bb->il.gimple.phi_nodes;
+	      if ( seq )
+		{
+		  gimple_stmt_iterator phii;
+		  for ( phii = gsi_start (seq); !gsi_end_p (phii); gsi_next (&phii))
+		    {
+		      gimple *phi_stmt = gsi_stmt ( phii);
+		      if ( (*function) ( phi_stmt, data )) return;
+		    }
+		}
+	    }
 	  gimple_stmt_iterator gsi;
 	  for ( gsi = gsi_start_bb ( bb); !gsi_end_p ( gsi); gsi_next ( &gsi) )
 	    {
@@ -1854,11 +1878,25 @@ print_program ( FILE *file, int leading_space )
 {
   struct cgraph_node *node;
   fprintf ( file, "%*sProgram:\n", leading_space, "");
+  
+  // Print Global Decls
+  //
+  varpool_node *var;
+  FOR_EACH_VARIABLE ( var)
+  {
+    tree decl = var->decl;
+    fprintf ( file, "%*s", leading_space, "");
+    print_generic_decl ( file, decl, (dump_flags_t)0);
+    fprintf ( file, "\n");
+  }
+  
   FOR_EACH_FUNCTION_WITH_GIMPLE_BODY ( node)
   {
     struct function *func = DECL_STRUCT_FUNCTION ( node->decl);
+    #if 0
     // print func name
     fprintf ( file, "%*sFunc: %s\n", leading_space + 2, "", lang_hooks.decl_printable_name ( node->decl, 2));
+    #endif
     print_function ( file, leading_space + 4, func);
   }
 }
@@ -1867,6 +1905,26 @@ static void
 print_function ( FILE *file, int leading_space, struct function *func)
 {
   basic_block bb;
+  
+  fprintf ( file, "%*sFunc: ", leading_space + 2, "");
+  print_generic_expr ( file, TREE_TYPE(TREE_TYPE( func->decl)), (dump_flags_t)0);
+
+  // Print Func Name
+  fprintf ( file, " %s ( ", lang_hooks.decl_printable_name ( func->decl, 2));
+
+  // Print Parameter Decls
+  tree parm;
+  for ( parm = DECL_ARGUMENTS ( func->decl);
+	parm;
+	parm = DECL_CHAIN ( parm) )
+    {
+      print_generic_expr ( file, TREE_TYPE( parm), (dump_flags_t)0);
+      print_generic_expr ( file, parm, (dump_flags_t)0);
+    }
+  fprintf ( file, ")\n");
+      
+      
+  // TBD Print Local Decls
 
   FOR_EACH_BB_FN ( bb, func)
   {
@@ -1889,6 +1947,16 @@ print_function ( FILE *file, int leading_space, struct function *func)
       }
     fprintf ( file, "\n");
 
+    gimple_seq seq = bb->il.gimple.phi_nodes;
+    if ( seq )
+      {
+	gimple_stmt_iterator phii;
+	for ( phii = gsi_start (seq); !gsi_end_p (phii); gsi_next (&phii))
+	  {
+	    fprintf ( file, "%*s", leading_space + 2, "" );
+	    print_gimple_stmt ( file, gsi_stmt ( phii), 0, TDF_DETAILS);
+	  }
+      }
 
     gimple_stmt_iterator gsi;
       for ( gsi = gsi_start_bb ( bb);
@@ -1932,6 +2000,24 @@ uses_field_of_reorgtypes( gimple *stmt, Info * info)
   return false;
 }
 
+void
+modify_ssa_name_type ( tree ssa_name, tree type)
+{
+  // This rips off the code in make_ssa_name_fn.
+  // Note, this probabily be made into special function
+  // that is part of tree-ssanames.
+  if ( TYPE_P ( type))
+    {
+      TREE_TYPE ( ssa_name) = TYPE_MAIN_VARIANT ( type);
+      SET_SSA_NAME_VAR_OR_IDENTIFIER ( ssa_name, NULL_TREE);
+    }
+  else
+    {
+      TREE_TYPE ( ssa_name) = TREE_TYPE ( type);
+      SET_SSA_NAME_VAR_OR_IDENTIFIER ( ssa_name, type);
+    }
+}
+
 //-- debugging only --
 //static const char *
 #if DEBUGGING
diff --git a/gcc/ipa-structure-reorg.h b/gcc/ipa-structure-reorg.h
index f9a687c1e44..af4219c15b2 100644
--- a/gcc/ipa-structure-reorg.h
+++ b/gcc/ipa-structure-reorg.h
@@ -136,6 +136,7 @@ enum ReorgTransformation {
   ReorgT_Realloc,      //
   ReorgT_Free,         //
   ReorgT_UserFunc,     //
+  ReorgT_Convert,      // type casts
   ReorgT_Return,       // return t
   Not_Supported
 };
@@ -222,7 +223,7 @@ extern enum ReorgOpTrans recognize_op ( tree,  Info_t *);
 extern ReorgTransformation reorg_recognize ( gimple *,
 					     cgraph_node *,
 					     Info_t *);
-extern void apply_to_all_gimple ( bool (*)(gimple *, void *), void *);
+extern void apply_to_all_gimple ( bool (*)(gimple *, void *), bool, void *);
 extern ReorgType_t *get_reorgtype_info ( tree, Info_t *);
 extern void print_reorg_with_msg ( FILE *, ReorgType_t *, int, const char *);
 extern ReorgType_t *contains_a_reorgtype ( gimple *, Info *);
@@ -232,6 +233,8 @@ extern tree base_type_of ( tree);
 extern void print_reorg ( FILE *, int, ReorgType_t *);
 extern void print_program ( FILE *, int);
 extern void print_type ( FILE *, tree);
+extern void modify_ssa_name_type ( tree, tree);
+
   
 //#define MAX(a,b) ((a) > (b) ? (a) : (b))