This is a set of fixes that allow instance interleavingcommon/ipa-str-reorg

performance qualification to work for mcf.

3 files changed, 612 insertions, 323 deletions

diff --git a/gcc/ipa-str-reorg-instance-interleave.c b/gcc/ipa-str-reorg-instance-interleave.c
index f171359b661..7073c9fc1d2 100644
--- a/gcc/ipa-str-reorg-instance-interleave.c
+++ b/gcc/ipa-str-reorg-instance-interleave.c
@@ -109,9 +109,9 @@ static basic_block make_bb ( char *, basic_block);
 */
 
 // These are dummy values tha alway result the reorganization
-#define SINGLE_POOL_RAW_SKIP_IT      0.10
+#define SINGLE_POOL_RAW_SKIP_IT      0.05
 #define SINGLE_POOL_RAW_DO_IT_ALWAYS 0.90
-#define SINGLE_POOL_ABS_SKIP_IT      0.05
+#define SINGLE_POOL_ABS_SKIP_IT      0.02
 #define SINGLE_POOL_ABS_DO_IT_ALWAYS 0.10
   
 int
@@ -121,6 +121,7 @@ str_reorg_instance_interleave_qual ( Info *info)
   //
   str_reorg_instance_interleave_qual_part ( info);
 
+  //if ( BYPASS_TRANSFORM ) return 0;
   // this modifiies the qualified types.
   //
   str_reorg_instance_interleave_type_part ( info);
@@ -130,17 +131,21 @@ str_reorg_instance_interleave_qual ( Info *info)
 int
 str_reorg_instance_interleave_trans ( Info *info)
 {
+  if ( BYPASS_TRANSFORM )
+    {
+
+      fprintf ( stderr, "Bypassing str_reorg_instance_interleave_trans for experiment\n");
+      return 0;
+    }
+  
   if ( info->show_all_reorg_cands )
   {
     fprintf ( info->reorg_dump_file, "Start of str_reorg_instance_interleave_trans:\n");
     print_program ( info->reorg_dump_file, PRINT_FORMAT, 4, info);
   }
 
-  fprintf ( stderr, "Bypassing str_reorg_instance_interleave_trans for experiment\n");
-  return 0;
-
-  DEBUG ("INTERNALS PRINT\n");
-  DEBUG_F (apply_to_all_gimple, print_internals, true, (void *)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)  {
@@ -264,7 +269,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);
@@ -446,14 +451,14 @@ 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: ");
-		      DEBUG_F( print_gimple_stmt, stderr, stmt, 0);
+		      //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));
@@ -468,14 +473,14 @@ str_reorg_instance_interleave_trans ( Info *info)
 		      //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");
+		      //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);
+		      //DEBUG_L("after: ");
+		      //DEBUG_F( print_gimple_stmt, stderr, stmt, 0);
 		    }
 		    break;
 		  case ReorgT_IfPtrEQ:
@@ -484,13 +489,13 @@ str_reorg_instance_interleave_trans ( Info *info)
 		  case ReorgT_IfPtrGT:
 		  case ReorgT_IfPtrLE:
 		  case ReorgT_IfPtrGE:
-		    DEBUG_L("ReorgT_IfPtr*\n");
+		    //DEBUG_L("ReorgT_IfPtr*\n");
 		    // Not needed for single pool. TBD test this
 		    break;
 		  case ReorgT_PtrPlusInt:   // "a = b + i"
 		    {
-		      DEBUG_L("ReorgT_PtrPlusInt: ");
-		      DEBUG_F( print_gimple_stmt, stderr, stmt, 0);
+		      //DEBUG_L("ReorgT_PtrPlusInt: ");
+		      //DEBUG_F( print_gimple_stmt, stderr, stmt, 0);
 		      // Needed for hellowotrld
 		      
 		      // Does the type of stmt need to be adjusted? I assume so.
@@ -545,14 +550,14 @@ 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"
@@ -606,14 +611,14 @@ str_reorg_instance_interleave_trans ( Info *info)
 
 		      gsi_remove ( &gsi, true);
 
-		      DEBUG_L("");
-		      DEBUG_F( print_gimple_stmt, stderr, gPD_rhs1_cast, 0);
-		      DEBUG_L("");
-		      DEBUG_F( print_gimple_stmt, stderr, gPD_rhs2_cast, 0);
-		      DEBUG_L("");
-		      DEBUG_F( print_gimple_stmt, stderr, gPD, 0);
-		      DEBUG_L("");
-		      DEBUG_F( print_gimple_stmt, stderr, gPD_cast, 0);
+		      //DEBUG_L("");
+		      //DEBUG_F( print_gimple_stmt, stderr, gPD_rhs1_cast, 0);
+		      //DEBUG_L("");
+		      //DEBUG_F( print_gimple_stmt, stderr, gPD_rhs2_cast, 0);
+		      //DEBUG_L("");
+		      //DEBUG_F( print_gimple_stmt, stderr, gPD, 0);
+		      //DEBUG_L("");
+		      //DEBUG_F( print_gimple_stmt, stderr, gPD_cast, 0);
 		  }
 		    break;
 		  case ReorgT_Adr2Ptr:    //  "a = &x[i]"
@@ -635,7 +640,7 @@ 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, 
@@ -654,7 +659,7 @@ str_reorg_instance_interleave_trans ( Info *info)
 		  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!!!
@@ -1101,7 +1106,7 @@ 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
@@ -1320,8 +1325,8 @@ str_reorg_instance_interleave_trans ( Info *info)
 	// transform any constant zero into it's new repersentation.
 	// OR MAYBE... use FOR_EACH_PHI_ARG for the iterator...
 	
-	DEBUG_L("Phis with constant operands:\n");
-	INDENT(4);
+	//DEBUG_L("Phis with constant operands:\n");
+	//INDENT(4);
 	gphi_iterator pi;
 	for ( pi = gsi_start_phis (bb); !gsi_end_p (pi); gsi_next (&pi))
 	  {
@@ -1338,30 +1343,30 @@ str_reorg_instance_interleave_trans ( Info *info)
 		for (int i = 0; i < gimple_phi_num_args (phi); i++)
 		  {
 		    tree *arg = gimple_phi_arg_def_ptr (phi, i);
-		    DEBUG_A("arg[%d] = ",i);
-		    DEBUG_F(flexible_print, stderr, *arg, 1, (dump_flags_t)0);
+		    //DEBUG_A("arg[%d] = ",i);
+		    //DEBUG_F(flexible_print, stderr, *arg, 1, (dump_flags_t)0);
 		    bool int_cst = TREE_CODE ( *arg) == INTEGER_CST;
-		    DEBUG_A("is %sinteger constant\n", int_cst ? "" : "not ");
+		    //DEBUG_A("is %sinteger constant\n", int_cst ? "" : "not ");
 		    if ( int_cst && integer_zerop ( *arg) )
 		      {
 			*arg = TYPE_MAX_VALUE ( ri->pointer_rep);
-			DEBUG_L("arg after = ");
-			DEBUG_F(flexible_print, stderr, *arg, 1, (dump_flags_t)0);
+			//DEBUG_L("arg after = ");
+			//DEBUG_F(flexible_print, stderr, *arg, 1, (dump_flags_t)0);
 		      }
 		  }
 	      }
 	  }
-	INDENT(-4);
+	//INDENT(-4);
       }
     pop_cfun ();
   }
 
-  DEBUG_L("after bulk of transformations\n");
+  //DEBUG_L("after bulk of transformations\n");
 
-  DEBUG_F( print_program, info->reorg_dump_file, PRINT_FORMAT, 4, info);
+  //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);
+  //DEBUG ("INTERNALS PRINT\n");
+  //DEBUG_F (apply_to_all_gimple, print_internals, true, (void *)info);
 
   // A mini-pass to fixup dangling SSA temps.
   
@@ -1372,7 +1377,7 @@ str_reorg_instance_interleave_trans ( Info *info)
 
       std::vector <tree> ssa_to_delete;
 
-      DEBUG_L("Mini-Pass on Function %s:\n", lang_hooks.decl_printable_name ( func->decl, 2));
+      //DEBUG_L("Mini-Pass on Function %s:\n", lang_hooks.decl_printable_name ( func->decl, 2));
       
       //DEBUG_L("\n");
       //DEBUG_F( wolf_fence, info);
@@ -1404,21 +1409,21 @@ str_reorg_instance_interleave_trans ( Info *info)
       // of many functions mapping onto one declaration (which I
       // even doubt is possible in thi case) can't be a problem.
       
-      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");
-	  INDENT(2);
+	  //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
@@ -1428,9 +1433,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
 
@@ -1457,11 +1462,11 @@ 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
@@ -1475,8 +1480,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
@@ -1485,14 +1490,14 @@ 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
 		  //
@@ -1501,12 +1506,12 @@ str_reorg_instance_interleave_trans ( Info *info)
 		  release_ssa_name_fn ( func, old_default_def);
 		}
 	    }
-	  INDENT(-2);
+	  //INDENT(-2);
 	}
-      INDENT(-4);
+      //INDENT(-4);
       
-      DEBUG_L("Dangling Types for Function Local (default defs).\n");
-      INDENT(4);
+      //DEBUG_L("Dangling Types for Function Local (default defs).\n");
+      //INDENT(4);
       //DEBUG_L("\n");
       //DEBUG_F( wolf_fence, info);
       
@@ -1521,9 +1526,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;
 	  
@@ -1563,28 +1568,28 @@ str_reorg_instance_interleave_trans ( Info *info)
 		}
 	    }
 	}
-      INDENT(-4);      
+      //INDENT(-4);      
       
       // Normal ssa name case
-      DEBUG_L("Dangling Types for Normal SSA Names:\n");
+      //DEBUG_L("Dangling Types for Normal SSA Names:\n");
       //DEBUG_L("\n");
       //DEBUG_F( wolf_fence, info);
       
-      INDENT(4);
+      //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");
+	      //DEBUG_L("Skip, ssa_name == NULL\n");
 	      continue;
 	    }
 
@@ -1595,42 +1600,42 @@ str_reorg_instance_interleave_trans ( Info *info)
 	  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(" %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);
+	  //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");
+	      //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);
+	  //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++)
 	    {
@@ -1646,8 +1651,8 @@ 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 before: ");
-	      DEBUG_F ( print_gimple_stmt, stderr, use_stmt, 0);
+	      //DEBUG_L("use_stmt before: ");
+	      //DEBUG_F ( print_gimple_stmt, stderr, use_stmt, 0);
 	      
 	      // Deal with the uses
 	      use_operand_p use_p;
@@ -1656,14 +1661,14 @@ 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)
 		    SET_USE ( use_p, new_ssa_name);
 		}
-	      DEBUG_L("use_stmt after: ");
-	      DEBUG_F ( print_gimple_stmt, stderr, use_stmt, 0);
+	      //DEBUG_L("use_stmt after: ");
+	      //DEBUG_F ( print_gimple_stmt, stderr, use_stmt, 0);
 	      
 	      // Should update_stmt be called here?
 	      // It does not seem either harm or help so I'll
@@ -1672,12 +1677,12 @@ str_reorg_instance_interleave_trans ( Info *info)
 	    }
 	  // 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, 1, (dump_flags_t)0);
+	  //DEBUG_L("What is ssa_name? ");
+	  //DEBUG_F(flexible_print, stderr, ssa_name, 1, (dump_flags_t)0);
 	  gimple *def = SSA_NAME_DEF_STMT ( ssa_name);
 	  
-	  DEBUG_L("def: ");
-	  DEBUG_F ( print_gimple_stmt, stderr, def, 0);
+	  //DEBUG_L("def: ");
+	  //DEBUG_F ( print_gimple_stmt, stderr, def, 0);
 	  
 	  set_lhs_for ( def, new_ssa_name);
 
@@ -1687,7 +1692,7 @@ str_reorg_instance_interleave_trans ( Info *info)
 	  release_ssa_name_fn ( func, ssa_name);
 	  
 	}
-      INDENT(-4);
+      //INDENT(-4);
 
       // Might be a bad idea.
       #if 0
@@ -1700,29 +1705,19 @@ str_reorg_instance_interleave_trans ( Info *info)
       pop_cfun ();
     }
 
-  DEBUG_L("after mini-passes\n");
-
-  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);
-    }
+  // This used to be off of.. "if ( info->show_all_reorg_cands ) { ..."
+  // I'm leaning towards deleting this as redundnt.
+  //DEBUG ( info->reorg_dump_file,
+  //  "\nEnd of str_reorg_instance_interleave_trans (after mini-psasses):\n\n");
+  //DEBUG_F ( 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);
+  //DEBUG ("INTERNALS PRINT\n");
+  //DEBUG_F (apply_to_all_gimple, print_internals, true, (void *)info);
   
-  // Spin through all the functions and recompute the dominace info.
-  FOR_EACH_FUNCTION_WITH_GIMPLE_BODY ( node)  {
-    struct function *func = DECL_STRUCT_FUNCTION ( node->decl);
-    push_cfun ( func);
-    if ( dom_info_available_p ( CDI_DOMINATORS) )
-      {
-	free_dominance_info ( CDI_DOMINATORS);
-      }
-    calculate_dominance_info (CDI_DOMINATORS);
-    pop_cfun ();
-  }
+  // NOTE, spinning through all the functions and recomputing all the
+  // dominace info here is a really bad idea.
+
   return 0;
 }
 
@@ -1977,7 +1972,7 @@ reorg_perf_qual ( Info *info)
     {
       fprintf ( info->reorg_dump_file, "Doing Performance Qualification\n");
     }
-  DEBUG_L("reorg_perf_qual:\n");
+  //DEBUG_L("reorg_perf_qual:\n");
   #if 1
   // TBD use design in doc but mark ReorgTypes
   // (do_instance_interleave) that qualify instead of deleting them
@@ -2030,11 +2025,13 @@ reorg_perf_qual ( Info *info)
     // However, the dominace calculations other things need it.
     push_cfun ( func);
 
+    #if 1
     if ( dom_info_available_p ( CDI_DOMINATORS) )
       {
 	free_dominance_info ( CDI_DOMINATORS);
       }
     calculate_dominance_info (CDI_DOMINATORS);
+    #endif
 
     if ( info->show_perf_qualify )
       {
@@ -2065,13 +2062,17 @@ reorg_perf_qual ( Info *info)
 	  {
 	    basic_block bb = bbs [i];
 	    //DEBUG_A("BB %i:\n", bb->index);
-	    INDENT(4);
+	    //INDENT(4);
 	    for ( auto gsi = gsi_start_bb ( bb); !gsi_end_p ( gsi); gsi_next ( &gsi) )
 	      {
 		gimple *stmt = gsi_stmt ( gsi);
 		//DEBUG_A("examine: ");
 		//DEBUG_F ( print_gimple_stmt, stderr, stmt, TDF_DETAILS);
-		INDENT(4);
+		//INDENT(4);
+
+		if ( gimple_code ( stmt) == GIMPLE_LABEL  ||
+		     gimple_code ( stmt) == GIMPLE_SWITCH    ) continue;
+		  		
 		unsigned n_ops = gimple_num_ops( stmt);
 		tree op;
 		unsigned ith_op;
@@ -2080,8 +2081,8 @@ reorg_perf_qual ( Info *info)
 		    op = gimple_op ( stmt, ith_op);
 		    // It's lieing about the number of operands... so...
 		    if ( op == NULL ) continue;
-		    //DEBUG_A("op[%d]: %p", ith_op, op);
-		    //DEBUG_F(flexible_print, stderr, op, 0, (dump_flags_t)0);
+		    //DEBUG_A("op[%d]: %p, ", ith_op, op);
+		    //DEBUG_F(flexible_print, stderr, op, 1, (dump_flags_t)0);
 		    ReorgType_t *tri = tree_contains_a_reorgtype ( op, info);
 		    enum ReorgOpTrans optran = recognize_op ( op, false, info);
 		    // TBD This is where we need to remember
@@ -2138,9 +2139,9 @@ reorg_perf_qual ( Info *info)
 			missing_cases = true;
 		      }
 		  }
-		INDENT(-4);
+		//INDENT(-4);
 	      }
-	    INDENT(-4);
+	    //INDENT(-4);
 	  }
 
 	//DEBUG_L("Dumping acc_info:\n");
@@ -2166,8 +2167,8 @@ reorg_perf_qual ( Info *info)
 	
 	compress_acc_infos ( acc_info );
 
-	DEBUG_A("after compress: \n");
-	DEBUG_F(print_acc_infos, stderr, acc_info );
+	//DEBUG_A("after compress: \n");
+	//DEBUG_F(print_acc_infos, stderr, acc_info );
 	
 	// Obtain loop count by looking at all the block counts.
 	unsigned loop_count = 0;
@@ -2176,13 +2177,17 @@ reorg_perf_qual ( Info *info)
 	    basic_block bb = bbs [i];
 	    loop_count = MAX( loop_count, bb->count.value ());
 	  }
-	DEBUG_L("loop_count = %d, nb_iterations_estimate = %ld\n",
-		loop_count, loop->nb_iterations_estimate);
+	//DEBUG_L("loop_count = %d, nb_iterations_estimate = %ld\n",
+	//	loop_count, loop->nb_iterations_estimate);
 
 	// Create the variable infos
 	varInfo_t var_entry;
 	var_entry.rep_access = &acc_info[0];
 	unsigned len = acc_info.size ();
+
+	// If no accesses detected, never for this loop.
+	if ( len == 0 ) continue;
+	
  	if ( len == 1 )
 	  {
 	    var_entry.fields.push_front ( acc_info[0].field);
@@ -2206,12 +2211,16 @@ reorg_perf_qual ( Info *info)
 	  }
 	var_info.push_back( var_entry);
 
-	print_var_infos ( stderr, var_info);
+	if ( info->show_perf_qualify )
+	  {
+	    fprintf ( stderr, "%d VarInfos\n", var_info.size ());
+	  }
+	//DEBUG_F(print_var_infos, stderr, var_info);
 
 	//
 	// Model the performance
 	//
-	DEBUG_A("Model The Performance\n");
+	//DEBUG_A("Model The Performance\n");
 
 	// Originally this was done per bb but now it has to be per
 	// loop. TBD But perf_bb is per loop so we need something similar
@@ -2223,17 +2232,16 @@ reorg_perf_qual ( Info *info)
 	    ReorgType_t *ri = pvi->rep_access->reorg;
 	    
 	    // Reorg accounting
-	    DEBUG_L("\n");
-	    DEBUG_A("Reorg Accounting\n");
+	    //DEBUG_L("\n");
+	    //DEBUG_A("Reorg Accounting\n");
 	    
 	    if( ri != NULL )
 	      {
 		double reorg_nca = 0.0;
 
-		DEBUG_A("  for: ");
-		DEBUG_F( flexible_print, stderr, ri->gcc_type, 1, (dump_flags_t)0);
-
-		INDENT(4);
+		//DEBUG_A("  for: ");
+		//DEBUG_F( flexible_print, stderr, ri->gcc_type, 1, (dump_flags_t)0);
+		//INDENT(4);
 		for ( auto fldi = pvi->fields.begin (); fldi != pvi->fields.end (); fldi++ )
 		  {
 		    unsigned HOST_WIDE_INT fld_width =
@@ -2241,18 +2249,18 @@ reorg_perf_qual ( Info *info)
 		    double effect = alignment_effect ( fld_width);
 		    double product = loop_count * effect;
 		    reorg_nca += product;
-		    DEBUG_A("Add loop_count * effect (%d * %f = %f) to reorg_nca (now %f)\n",
-			    loop_count, effect, product, reorg_nca);
+		    //DEBUG_A("Add loop_count * effect (%d * %f = %f) to reorg_nca (now %f)\n",
+		    //	    loop_count, effect, product, reorg_nca);
 		  }
-		INDENT(-4);
+		//INDENT(-4);
 		ri->instance_interleave.reorg_perf += reorg_nca;
-		DEBUG_A("Add reorg_nca (%f) to reorg_perf (now %e)\n",
-			reorg_nca, ri->instance_interleave.reorg_perf);
+		//DEBUG_A("Add reorg_nca (%f) to reorg_perf (now %e)\n",
+		//	reorg_nca, ri->instance_interleave.reorg_perf);
               } // 699
 
 	    // regular accounting
-	    DEBUG_L("\n");
-	    DEBUG_A("Regular Accounting\n");
+	    //DEBUG_L("\n");
+	    //DEBUG_A("Regular Accounting\n");
 	    
 	    double regular_nca = 0.0;
 	    sbitmap cache_model = sbitmap_alloc(1);
@@ -2261,11 +2269,14 @@ reorg_perf_qual ( Info *info)
 	      { // 704
 		tree access = pv2i->rep_access->base_info.acc_base;
 		tree base_type; // = base_type_of ( access);
-		if ( pv2i->rep_access->reorg != NULL )		  {
+		if ( pv2i->rep_access->reorg != NULL )
+		  {
+		    //DEBUG_A("Base type from reorg: ");
 		    base_type = pv2i->rep_access->reorg->gcc_type;
 		  }
 		else
 		  {
+		    //DEBUG_A("Base type from access: ");
 		    if ( TREE_TYPE ( access ) != NULL )
 		      {
 			base_type = base_type_of ( access);
@@ -2275,15 +2286,56 @@ reorg_perf_qual ( Info *info)
 			gcc_assert (0);
 		      }
 		  }
+		//DEBUG_F( flexible_print, stderr, base_type, 1, (dump_flags_t)0);
 
 		bool base_type_isa_decl = DECL_P ( base_type );
 
 		// create a tiny model of the cache big
 		// enough for this record.
+		#if 0
 		tree base_type_size = base_type_isa_decl ?
 		  DECL_SIZE ( base_type )
 		  :
 		  TYPE_SIZE ( base_type);
+		#else
+		tree base_type_size;
+		if ( base_type_isa_decl )
+		  {
+		    //DEBUG_A("decl\n");
+		    switch ( TREE_CODE (base_type) )
+		      {
+		      case VAR_DECL:
+			{
+			  //DEBUG_A("VAR_DECL\n");
+			  base_type_size = TYPE_SIZE ( base_type);
+			  break;
+			}
+		      case FIELD_DECL:
+			{
+			  //DEBUG_A("VAR_DECL\n");
+			  base_type_size = TYPE_SIZE ( TREE_TYPE ( base_type));
+			  break;
+			}
+		      default:
+			{
+			  //DEBUG_A("other decl %s\n", code_str(TREE_CODE (base_type)));
+			  gcc_assert(0);
+			}
+		      }
+		  }
+		else
+		  {
+		    //DEBUG_A("nondecl %s\n", code_str(TREE_CODE (base_type)));
+		    if ( TREE_CODE ( base_type) == SSA_NAME )
+		      {
+			base_type_size = TYPE_SIZE ( TREE_TYPE( base_type));
+		      }
+		    else
+		      {
+			base_type_size = TYPE_SIZE ( base_type);
+		      }
+		  }
+		#endif
 		    
 		unsigned HOST_WIDE_INT len =
 		  (( tree_to_uhwi ( base_type_size)
@@ -2293,15 +2345,21 @@ reorg_perf_qual ( Info *info)
 		   param_l1_cache_line_size)
 		  +
 		  1;
-		DEBUG_L("\n");
-		DEBUG_A("cache len = %d\n", len);
+		//DEBUG_L("\n");
+		//DEBUG_A("cache len = %d (lines), for: ", len);
+		//DEBUG_F( flexible_print, stderr, base_type, 0, (dump_flags_t)0);
+		//DEBUG("%sstruct\n")
 	      
 		// TBD Does this clear the bits??? It needs to.
 		// Each bit represents a cache line.
 		cache_model = sbitmap_resize( cache_model, (unsigned) len, 0);
 		double accum = 0.0;
 		int nrbo = 0;
-		if ( base_type_isa_decl )
+		tree type = TREE_TYPE ( base_type);
+		
+		//bool a_record = type == NULL && TREE_CODE ( type) == RECORD_TYPE;
+		bool a_record = type != NULL && TREE_CODE ( type) == RECORD_TYPE;
+		if ( base_type_isa_decl && a_record )
 		  {
 		    for ( auto field_ex = TYPE_FIELDS ( base_type);
 			  field_ex; 
@@ -2312,14 +2370,14 @@ reorg_perf_qual ( Info *info)
 			// why this is here and what it does. Sigh...
 			unsigned HOST_WIDE_INT base_offset =
 			  tree_to_uhwi ( DECL_FIELD_OFFSET( field_ex));
-			DEBUG_L("\n");
-			DEBUG_A("For field_ex: ");
-			DEBUG_F( flexible_print, stderr, field_ex, 0, (dump_flags_t)0);
-			DEBUG(", nrbo %d, base_offset %d\n", nrbo, base_offset);
+			//DEBUG_L("\n");
+			//DEBUG_A("For field_ex: ");
+			//DEBUG_F( flexible_print, stderr, field_ex, 0, (dump_flags_t)0);
+			//DEBUG(", nrbo %d, base_offset %d\n", nrbo, base_offset);
 			
 			// Access accounting
 
-			INDENT(4);
+			//INDENT(4);
 			for ( auto fldi = pv2i->fields.begin ();
 			      fldi != pv2i->fields.end (); fldi++ )
 			  {
@@ -2327,27 +2385,27 @@ reorg_perf_qual ( Info *info)
 			    unsigned HOST_WIDE_INT fld_width, fld_offset;
 			    fld_width = tree_to_uhwi ( DECL_SIZE ( field));
 			    fld_offset = tree_to_uhwi ( DECL_FIELD_OFFSET ( field));
-			    DEBUG_A("Field: ");
-			    DEBUG_F( flexible_print, stderr, field, 0, (dump_flags_t)0);
-			    DEBUG(", width = %d, offset = %d\n", fld_width, fld_offset);
+			    //DEBUG_A("Field: ");
+			    //DEBUG_F( flexible_print, stderr, field, 0, (dump_flags_t)0);
+			    //DEBUG(", width = %d, offset = %d\n", fld_width, fld_offset);
 			    int chari;
-			    INDENT(4);
+			    //INDENT(4);
 			    for ( chari = 0; chari < fld_width; chari++ )
 			      {
 				int loc = (chari + fld_offset + base_offset)
 				  /
 				  param_l1_cache_line_size;
-				DEBUG_A("loc: %d\n", loc);
+				//DEBUG_A("loc: %d\n", loc);
 				bitmap_set_bit ( cache_model, loc);
 			      }
-			    INDENT(-4);
+			    //INDENT(-4);
 			  }
-			INDENT(-4);
+			//INDENT(-4);
 			unsigned bcount = bitmap_count_bits ( cache_model);
 			accum += bcount;
-			DEBUG_L("\n");
-			DEBUG_A("Add popcount of cache (%d) to accum (now %f)\n",
-				bcount, accum);
+			//DEBUG_L("\n");
+			//DEBUG_A("Add popcount of cache (%d) to accum (now %f)\n",
+			//	bcount, accum);
 			bitmap_clear ( cache_model);
 		      }
 		  }
@@ -2355,22 +2413,22 @@ reorg_perf_qual ( Info *info)
 		  {
 		    nrbo = 1;
 		    accum++;
-		    DEBUG_L("\n");
-		    DEBUG_A("nrbo = 1, increment accum to %f\n", accum);
+		    //DEBUG_L("\n");
+		    //DEBUG_A("nrbo = 1, increment accum to %f\n", accum);
 		  }
 		#if 1	
 		double amount = accum / nrbo;
 		double product = amount * loop_count;
 		regular_nca += product;
-		DEBUG_L("\n");
-		DEBUG_A("Add loop_count*accum/nrbo (%f*%f/%d = %f) to regular_nca (now %e)\n",
-			loop_count, accum, nrbo, product, regular_nca);
+		//DEBUG_L("\n");
+		//DEBUG_A("Add loop_count*accum/nrbo (%f*%f/%d = %f) to regular_nca (now %e)\n",
+		//	loop_count, accum, nrbo, product, regular_nca);
 		#else
 		double amount = accum / nrbo;
 		regular_nca += amount;
-		DEBUG_L("\n");
-		DEBUG_A("Add accum/nrbo (%f/%d = %f) to regular_nca (now %e)\n",
-			accum, nrbo, amount, regular_nca);
+		//DEBUG_L("\n");
+		//DEBUG_A("Add accum/nrbo (%f/%d = %f) to regular_nca (now %e)\n",
+		//	accum, nrbo, amount, regular_nca);
 		#endif
 	      } // 739
 	    sbitmap_free ( cache_model);
@@ -2378,11 +2436,11 @@ reorg_perf_qual ( Info *info)
 	    if( ri != NULL ) {
 	      ri->instance_interleave.regular_perf += regular_nca;
               cache_accesses_noreorg += regular_nca;
-	      DEBUG_L("\n");
-	      DEBUG_A("Add regular_nca (%f) to regular_perf (now %e)",
-		      regular_nca, ri->instance_interleave.regular_perf);
-	      DEBUG_A("  and to cache_accesses_noreorg (now %e)\n",
-		      cache_accesses_noreorg);
+	      //DEBUG_L("\n");
+	      //DEBUG_A("Add regular_nca (%f) to regular_perf (now %e)",
+	      //	      regular_nca, ri->instance_interleave.regular_perf);
+	      //DEBUG_A("  and to cache_accesses_noreorg (now %e)\n",
+	      //	      cache_accesses_noreorg);
             } else {
 	        cache_accesses += regular_nca;
             }
@@ -2435,12 +2493,12 @@ reorg_perf_qual ( Info *info)
       double raw_effect = with_opt/without_opt;
       double absolute_effect =
         (without_opt - with_opt) / total_cache_accesses;
-      DEBUG_A("For ");
-      DEBUG_F(flexible_print, stderr, reorgi->gcc_type, 0, (dump_flags_t)0);
-      DEBUG(" with_opt: %e, without_opt %e, total_cache_accesses %e\n",
-	    with_opt, without_opt, total_cache_accesses);
-      DEBUG_A("  Raw Effect: %5.4f, Absolute Effect %5.4f\n",
-	      raw_effect, absolute_effect);
+      //DEBUG_A("For ");
+      //DEBUG_F(flexible_print, stderr, reorgi->gcc_type, 0, (dump_flags_t)0);
+      //DEBUG(" with_opt: %e, without_opt %e, total_cache_accesses %e\n",
+      //	    with_opt, without_opt, total_cache_accesses);
+      //DEBUG_A("  Raw Effect: %5.4f, Absolute Effect %5.4f\n",
+      //	      raw_effect, absolute_effect);
 
       // Note, there would need to be a multi-pool case here if
       // that is every done.
@@ -2455,7 +2513,7 @@ reorg_perf_qual ( Info *info)
 			       (dump_flags_t)0);
 	      fprintf ( info->reorg_dump_file, ": Very small effect:\n");
 	      fprintf ( info->reorg_dump_file,
-			"    raw_effect %5.4 < SINGLE_POOL_RAW_SKIP_IT %5.4\n",
+			"    raw_effect %5.4f < SINGLE_POOL_RAW_SKIP_IT %5.4f\n",
 			raw_effect, SINGLE_POOL_RAW_SKIP_IT);
 	    }
 	  reorgi->do_instance_interleave = false;
@@ -2577,7 +2635,8 @@ static void
 compress_acc_infos ( std::vector <acc_info_t> ainfo )
 {
   unsigned len = ainfo.size ();
-  if ( len == 1 ) return;
+  //DEBUG_L("compress_acc_infos: len in %d, ",len);
+  if ( len <= 1 ) return;
   unsigned i, j;
   for ( i = j = 1; j < len; j++ )
     {
@@ -2586,11 +2645,13 @@ compress_acc_infos ( std::vector <acc_info_t> ainfo )
     }
   if ( i == j ) return;
   ainfo.resize ( len - (j -i));
+  //DEBUG_L("len out %d, ", ainfo.size ());
 }
 
 static void
 print_acc_info ( FILE *file, acc_info_t *ainfo )
 {
+  //DEBUG_L("print_acc_info: ainfo %p\n", ainfo);
   fprintf ( file, "%s%s%s%s%s%s\n",
 	    ainfo->base_info.a_def_def ? ", deflt_def" : "",
 	    ainfo->base_info.a_decl ? ", decl" : "",
@@ -2804,10 +2865,10 @@ is_array_access( tree acc)
 static void
 account_for_access ( tree access, tree field, std::vector <acc_info_t> *acc_info, Info_t *info)
 {
-  DEBUG_A("account_for_use var: ");
-  DEBUG_F(flexible_print, stderr, access, 0, (dump_flags_t)0);
-  DEBUG(", field: ");
-  DEBUG_F(flexible_print, stderr, field, 1, (dump_flags_t)0);
+  //DEBUG_A("account_for_use var: ");
+  //DEBUG_F(flexible_print, stderr, access, 0, (dump_flags_t)0);
+  //DEBUG(", field: ");
+  //DEBUG_F(flexible_print, stderr, field, 1, (dump_flags_t)0);
   
   // assert might eventually make sense but not yet
   //gcc_assert ( TREE_CODE ( ssa_var) == SSA_NAME);
@@ -2826,7 +2887,7 @@ account_for_access ( tree access, tree field, std::vector <acc_info_t> *acc_info
 static void
 tmasn_helper ( tree t, int indent, std::set<tree> *already )
 {
-  DEBUG_A("");
+  //DEBUG_A("");
   fprintf( stderr, "%*s", indent, " ");
   indent += 4;
   flexible_print ( stderr, t, 0, (dump_flags_t)0);
@@ -2839,7 +2900,7 @@ tmasn_helper ( tree t, int indent, std::set<tree> *already )
     {
       fprintf( stderr, "\n");
     }
-  DEBUG_L("code: %s\n", code_str(TREE_CODE (t)));
+  //DEBUG_L("code: %s\n", code_str(TREE_CODE (t)));
   if ( TREE_CODE (t) == SSA_NAME )
     {
       already->insert (t);
@@ -2905,16 +2966,20 @@ tell_me_about_ssa_name ( tree ssa_name, int indent)
   tmasn_helper ( ssa_name, indent, &already);
 }
 
+static unsigned insane_helper;
+
 static void
 an_ac_helper ( tree t, int indent, std::set<tree> *already, acc_info_t *ainfo )
 {
+  gcc_assert ( insane_helper < 100 );
+  insane_helper++;
   acc_base_info_t *binfo = &ainfo->base_info;
-  DEBUG_A("%*s", indent, " ");
+  //DEBUG_A("%*s", indent, " ");
   indent += 4;
-  DEBUG_F( flexible_print, stderr, t, 0, (dump_flags_t)0);
+  //DEBUG_F( flexible_print, stderr, t, 0, (dump_flags_t)0);
   if ( already->find (t) != already->end () )
     {
-      DEBUG(" <Induction>\n");
+      //DEBUG(" <Induction>\n");
       binfo->multi_induct =
 	binfo->multi_induct || binfo->has_induct_var_acc;
       binfo->induct_base = t;
@@ -2923,15 +2988,16 @@ an_ac_helper ( tree t, int indent, std::set<tree> *already, acc_info_t *ainfo )
     }
   else
     {
-      DEBUG("\n");
+      //DEBUG("\n");
+      
     }
-  DEBUG_A("%*scode: %s\n", indent, " ", code_str(TREE_CODE (t)));
+  //DEBUG_A("%*scode: %s\n", indent, " ", code_str(TREE_CODE (t)));
   if ( TREE_CODE (t) == SSA_NAME )
     {
       already->insert (t);
       gimple *stmt = SSA_NAME_DEF_STMT (t);
-      DEBUG_A("%*sSSA_NAME defined in: ", indent, " ");
-      DEBUG_F(print_gimple_stmt, stderr, stmt, TDF_DETAILS);
+      //DEBUG_A("%*sSSA_NAME defined in: ", indent, " ");
+      //DEBUG_F(print_gimple_stmt, stderr, stmt, TDF_DETAILS);
       if ( SSA_NAME_IS_DEFAULT_DEF ( t ) )
         {
 	  binfo->acc_base = t;
@@ -2990,21 +3056,33 @@ an_ac_helper ( tree t, int indent, std::set<tree> *already, acc_info_t *ainfo )
 		binfo->complicated || binfo->a_def_def || binfo->a_decl || binfo->a_func;
       binfo->a_decl = true;
       
-      DEBUG_A("field (index) for a_decl: ");
-      DEBUG_F(flexible_print, stderr, ainfo->field, 1, (dump_flags_t)0);
+      //DEBUG_A("field (index) for a_decl: ");
+      //DEBUG_F(flexible_print, stderr, ainfo->field, 1, (dump_flags_t)0);
 
-      an_ac_helper ( ainfo->field, indent, already, ainfo);
+      if ( TREE_CODE ( t) != FIELD_DECL )
+	{
+	  an_ac_helper ( ainfo->field, indent, already, ainfo);
+	}
       return;
     }
   if ( TREE_CODE ( t) == MEM_REF )
     {
       tree t_0 = TREE_OPERAND ( t, 0);
-      DEBUG_A("%*sMEM_REF t_0: ", indent, " ");
-      DEBUG_F(flexible_print, stderr, t_0, 1, (dump_flags_t)0);
+      //DEBUG_A("%*sMEM_REF t_0: ", indent, " ");
+      //DEBUG_F(flexible_print, stderr, t_0, 1, (dump_flags_t)0);
+      an_ac_helper ( t_0 , indent, already, ainfo);
+      return;
+    }
+  if ( TREE_CODE ( t) == COMPONENT_REF )
+    {
+      tree t_0 = TREE_OPERAND ( t, 0);
+      //DEBUG_A("%*sCOMPONENT_REF t_0: ", indent, " ");
+      //DEBUG_F(flexible_print, stderr, t_0, 1, (dump_flags_t)0);
       an_ac_helper ( t_0 , indent, already, ainfo);
       return;
     }
   if ( TREE_CODE ( t) == INTEGER_CST ) return;
+  if ( TREE_CODE ( t) == ADDR_EXPR ) return;
   fprintf ( stderr, "Unanticipated TREE_CODE\n");
   gcc_assert ( 0);
 }
@@ -3012,8 +3090,9 @@ an_ac_helper ( tree t, int indent, std::set<tree> *already, acc_info_t *ainfo )
 static void
 analyze_access ( tree access, acc_info_t *acc_info)
 {
+  insane_helper = 0;
   acc_base_info_t *base_info = &acc_info->base_info;
-  DEBUG_A("analyze_access:\n");
+  //DEBUG_A("analyze_access:\n");
   base_info->a_def_def = false;
   base_info->a_decl = false;
   base_info->a_func = false;
@@ -3295,10 +3374,10 @@ static basic_block
 make_bb ( char *msg, basic_block prev_bb )
 {
   basic_block ret = create_empty_bb ( prev_bb);
-  DEBUG_A( "make_bb ( %s, <bb %d>/%p  ): <bb %d>/%p, prev: <bb %d>/%p, next: <bb %d>/%p\n",
-	   msg, prev_bb->index, prev_bb,
-	   ret->index, ret,
-	   ret->prev_bb->index, ret->prev_bb,
-	   ret->next_bb->index, ret->next_bb);
+  //DEBUG_A( "make_bb ( %s, <bb %d>/%p  ): <bb %d>/%p, prev: <bb %d>/%p, next: <bb %d>/%p\n",
+  //	   msg, prev_bb->index, prev_bb,
+  //	   ret->index, ret,
+  //	   ret->prev_bb->index, ret->prev_bb,
+  //	   ret->next_bb->index, ret->next_bb);
   return ret;
 }
diff --git a/gcc/ipa-structure-reorg.c b/gcc/ipa-structure-reorg.c
index 4d9bf695b59..96f07c11aeb 100644
--- a/gcc/ipa-structure-reorg.c
+++ b/gcc/ipa-structure-reorg.c
@@ -140,7 +140,7 @@ ipa_structure_reorg ( void)
   cgraph_node* node;
   FOR_EACH_FUNCTION_WITH_GIMPLE_BODY ( node) node->get_untransformed_body ();
   
-  DEBUG_F( ssa_check, stderr, Show_everything, Do_not_fail, false, true);
+  //DEBUG_F( ssa_check, stderr, Show_everything, Do_not_fail, false, true);
 
   setup_debug_flags ( &info);
   initial_debug_info ( &info);
@@ -153,10 +153,10 @@ ipa_structure_reorg ( void)
     return true;
   }
 
-  DEBUG_L("after reorg_analysis\n");
+  //DEBUG_L("after reorg_analysis\n");
 
   bool qualified = reorg_qualification(&info);
-  DEBUG_L("after reorg_qualification\n");
+  //DEBUG_L("after reorg_qualification\n");
   //DEBUG_L("");
   //DEBUG_F(wolf_fence, &info);
 
@@ -186,6 +186,8 @@ ipa_structure_reorg ( void)
 
       }
 
+    fprintf (stderr, "info.show_all_reorg_cands_in_detail %s\n",
+	     info.show_all_reorg_cands_in_detail ? "true" : "false");
     if ( info.show_all_reorg_cands_in_detail )
       {
 	fprintf ( info.reorg_dump_file, "Qualified the following types:\n"); 
@@ -193,7 +195,7 @@ ipa_structure_reorg ( void)
       }
 
     reorg_common_middle_code( &info); // ??? might not amount to anything
-    DEBUG_L("after reorg_common_middle_code\n");
+    //DEBUG_L("after reorg_common_middle_code\n");
     //DEBUG_L("");
     //DEBUG_F(wolf_fence, &info);
       
@@ -324,7 +326,7 @@ reorg_analysis ( Info *info)
 	gimple *stmt = gsi_stmt ( gsi);
 	//DEBUG_L ( "");
 	//DEBUG_F ( print_gimple_stmt, stderr, stmt, 0);
-	INDENT(2);
+	//INDENT(2);
 	if ( is_gimple_call ( stmt) )
 	{
 	  // next line has issues but the mechanism is sound
@@ -345,34 +347,78 @@ reorg_analysis ( Info *info)
 	      //DEBUG_A( "TREE_CODE( bt) == %s\n", code_str( TREE_CODE ( bt)));
 	      //DEBUG_A("");
 	      //DEBUG_F(flexible_print, stderr, bt, 1, (dump_flags_t)0);
-	      INDENT(-2);
+	      //INDENT(-2);
 	      continue;
 	    }
 	    if ( TREE_CODE( bt) == VOID_TYPE )
 	      {
-		// find the use of lhs.  If is an assign
+		// Find the use of lhs.  If is an assign
 		// get use the base type of it's lhs.
-		// Otherwise never mind.
+		// Otherwise never mind. Note, there
+		// can be multiple uses but find the "one"
+		// that's a simple assignment to a typed
+		// variable.
+
+		#if 0
 		gimple *use_stmt;
 		use_operand_p immuse;
 		bool yup_a_use = single_imm_use ( t, &immuse, &use_stmt);
-		//DEBUG_A("VOID case: %sa single imm use, ", yup_a_use ? "" : "not ");
-		//DEBUG("%san assign\n",
-		//	yup_a_use && is_gimple_assign ( use_stmt) ? "" : "not ");
+		DEBUG_A("VOID case: %sa single imm use, ", yup_a_use ? "" : "not ");
+		DEBUG("%san assign\n",
+			yup_a_use && is_gimple_assign ( use_stmt) ? "" : "not ");
 		if ( TREE_CODE ( t) == SSA_NAME
 		     && yup_a_use
 		     && is_gimple_assign ( use_stmt) )
 		  {
 		    tree use_lhs = gimple_assign_lhs ( use_stmt);
 		    bt = base_type_of ( TREE_TYPE ( use_lhs));
+		    //DEBUG_A("found bt: ");
+		    //DEBUG_F(flexible_print, stderr, bt, 1, (dump_flags_t)0);
 		  }
 		else
-		  continue;
+		  {
+		    //DEBUG_A("bailed on base type of complicated case\n");
+		    //INDENT(-2);
+		    continue;
+		  }
+		#endif
+		
+		tree ssa_name = gimple_call_lhs( stmt);
+		gimple *use_stmt;
+		imm_use_iterator iter;
+		int num_bt = 0;
+		FOR_EACH_IMM_USE_STMT ( use_stmt, iter, ssa_name)
+		  {
+		    //DEBUG_A("use_stmt: ");
+		    //DEBUG_F ( print_gimple_stmt, stderr, use_stmt, 0);
+		    if ( is_assign_from_ssa ( use_stmt ) )
+		      {
+			//DEBUG_A("is assign from ssa\n");
+			tree lhs_assign = gimple_assign_lhs( use_stmt);
+			tree lhs_type = TREE_TYPE ( lhs_assign);
+			tree lhs_base_type = base_type_of ( lhs_type);
+			if ( TREE_CODE( lhs_base_type) != VOID_TYPE )
+			  {
+			    //DEBUG_A("not void\n");
+			    num_bt++;
+			    bt = lhs_base_type;
+			  }
+		      }
+		  }
+		if ( num_bt != 1 )
+		  {
+		    //DEBUG_L("bailed on base type of complicated case\n");
+		    //INDENT(-2);
+		    continue;
+		  }
 	      }
+		
+	    
+	    bool alloc_trigger = is_reorg_alloc_trigger ( stmt);
 	      
 	    // find if in reorgtypes and get the info (in one call)
 	    ReorgType_t *ri = get_reorgtype_info ( bt, info);
-	    if ( ri != NULL && is_reorg_alloc_trigger ( stmt) )
+	    if ( ri != NULL && alloc_trigger )
 	    {
 	      //DEBUG_L( "Found allocaion: \n");
 	      //DEBUG_A( "  Reorg: ");
@@ -385,13 +431,13 @@ reorg_analysis ( Info *info)
 	    }
 	  }
 	}
-	INDENT(-2);
+	//INDENT(-2);
       }
     }
   }
 
-//DEBUG_L( "possible deletes:\n");
-  INDENT(2);
+  //DEBUG_L( "possible deletes:\n");
+  //INDENT(2);
   // It's LOT more clear to use an iterator here TBD
   for ( int i = 0; i < info->reorg_type->size (); i++ )
   {
@@ -407,10 +453,18 @@ reorg_analysis ( Info *info)
     //DEBUG_A("%d pools\n",n)
     if ( n != 1 )
     {
+      if ( info->show_all_reorg_cands_in_detail )
+	{
+	  fprintf ( info->reorg_dump_file, "Delete ReorgType: ");
+	  flexible_print ( info->reorg_dump_file,
+			   (*(info->reorg_type))[i].gcc_type,
+			   0, (dump_flags_t)0);
+	  fprintf ( info->reorg_dump_file, ", it has %d pools\n", n);
+	}
       delete_reorgtype ( &(*(info->reorg_type))[i], info);
     }
   }
-  INDENT(-2);
+  //INDENT(-2);
 
   //DEBUG_L("after reorg_analysis\n");
   remove_deleted_types ( info, &reorg_analysis_debug);
@@ -469,7 +523,9 @@ find_decls_and_types ( Info *info)
     if ( TREE_CODE ( base) == RECORD_TYPE )
     {
       // skip if found before
-      if ( typeset.find ( base) != typeset.end () )
+      tree tmv_type = TYPE_MAIN_VARIANT ( base);
+      tree tmv_base = tmv_type ? tmv_type : base;
+      if ( typeset.find ( tmv_base) != typeset.end () )
       {
 	//DEBUG_L( "  not found\n");
 	continue;
@@ -479,9 +535,9 @@ find_decls_and_types ( Info *info)
       }
 
       #if USE_REORG_TYPES
-      add_reorg_type ( base, info);
+      add_reorg_type ( tmv_base, info);
       #endif
-      typeset.insert ( base); // ???
+      typeset.insert ( tmv_base); // ???
     }
   }
   
@@ -516,16 +572,18 @@ find_decls_and_types ( Info *info)
 
       if ( TREE_CODE ( base) == RECORD_TYPE)
       {
-	if ( typeset.find ( base) != typeset.end () )
+	tree tmv_type = TYPE_MAIN_VARIANT ( base);
+	tree tmv_base = tmv_type ? tmv_type : base;
+	if ( typeset.find ( tmv_base) != typeset.end () )
         {
 	  //INDENT(-2)
 	  continue;
 	}
 
 	#if USE_REORG_TYPES
-	add_reorg_type ( base, info);
+	add_reorg_type ( tmv_base, info);
 	#endif
-	typeset.insert ( base); // ???
+	typeset.insert ( tmv_base); // ???
       }
     }
     //INDENT(-2);
@@ -721,6 +779,8 @@ find_decls_and_types ( Info *info)
 static void
 add_reorg_type ( tree base, Info *info)
 {
+  tree tmv_type = TYPE_MAIN_VARIANT ( base);
+  tree type2add = tmv_type ? tmv_type : base;
   ReorgType_t rt =
     { 0, true, base, NULL, NULL, false, false, false,
       { 0}, { 0}, { 0, 0, 0, NULL, 0.0, 0.0, false}};
@@ -851,6 +911,14 @@ disq_str_in_str_or_union_helper ( tree type,
       ReorgType_t *rinfo = get_reorgtype_info ( field_type, info);  // base to field type
       if ( rinfo != NULL )
       {
+	if ( info->show_all_reorg_cands_in_detail )
+	  {
+	    fprintf ( info->reorg_dump_file, "Delete ReorgType: ");
+	    flexible_print ( info->reorg_dump_file,
+			     rinfo->gcc_type,
+			     0, (dump_flags_t)0);
+	    fprintf ( info->reorg_dump_file, ", Structure in structure.\n");
+	  }
 	delete_reorgtype ( rinfo, info);
       } else {
 	disq_str_in_str_or_union_helper ( field_type, typeset, info ); // base to field type
@@ -923,7 +991,11 @@ transformation_legality ( Info *info)
   // GIMPLE_IL sizeof tree expr
   // memmove(&astruct_1, &astruct_2, sizeof(struct astruct_s));
   // memmove(&astruct_1.b, &astruct_2.b, 2*sizeof(_Bool));
-  const bool run_escape_analysis = flag_ipa_dead_field_eliminate && !flag_ipa_instance_interleave && !flag_ipa_field_reorder;
+  const bool run_escape_analysis =
+    flag_ipa_dead_field_eliminate &&
+    !flag_ipa_instance_interleave &&
+    !flag_ipa_field_reorder;
+  
   if (run_escape_analysis)
   {
     bool retval = !info->is_non_escaping_set_empty();
@@ -954,7 +1026,8 @@ transformation_legality ( Info *info)
 	    case Not_Supported:
 	      //DEBUG_L("deleting %d reorgs for unsuported stmt: ", num);
 	      //DEBUG_F ( print_gimple_stmt, stderr, stmt, 0);
-	    disqualify_all_reorgtypes_of ( stmt, num, info);
+	      // TBD This is not working
+	      //disqualify_all_reorgtypes_of ( stmt, num, info);
 	    case ReorgT_UserFunc:
 	      // TBD ReorgT_Ptr2Zero does not catch all cases of
 	      // setting a reorg pointer to zero. One that I
@@ -1006,6 +1079,7 @@ transformation_legality_debug ( Info *info, ReorgType *reorg )
 static void
 reorg_common_middle_code ( Info *info)
 {
+  if ( BYPASS_TRANSFORM ) return;
   modify_declarations( info);
 }
 
@@ -1101,11 +1175,24 @@ disqualify_all_reorgtypes_of ( gimple *stmt, int num, Info *info)
 {
   //DEBUG_L("disqualify %d reorgtypes of: ", num);
   //DEBUG_F ( print_gimple_stmt, stderr, stmt, 0);
+  if ( info->show_all_reorg_cands_in_detail )
+    {
+      print_gimple_stmt( info->reorg_dump_file, stmt, 0);
+    }
   int i;
   for ( i = 0; i < num; i++ )
     {
       ReorgType_t *reorg_type =
 	get_reorgtype ( stmt, info, i);
+      //DEBUG_A( "reorg_type = %p\n", reorg_type);
+      if ( info->show_all_reorg_cands_in_detail )
+	{
+	  fprintf ( info->reorg_dump_file, "  Delete ReorgType: ");
+	  flexible_print ( info->reorg_dump_file,
+			   (*(info->reorg_type))[i].gcc_type,
+			   0, (dump_flags_t)0);
+	  fprintf ( info->reorg_dump_file, ", because of gimple above.\n");
+	}
       delete_reorgtype ( reorg_type, info);
     }
 }
@@ -1131,7 +1218,7 @@ modify_func_type ( struct function *func, Info *info )
   tree func_type = TREE_TYPE ( func->decl);
   //DEBUG_L("old func_type = ");
   //DEBUG_F( flexible_print, stderr, func_type, 1, (dump_flags_t)0);
-  INDENT(4);
+  //INDENT(4);
   tree new_type;
   tree func_ret_type = TREE_TYPE ( func_type);
   tree base = base_type_of ( func_ret_type);
@@ -1171,13 +1258,14 @@ modify_func_type ( struct function *func, Info *info )
       ri = get_reorgtype_info ( base, info);
       if ( ri != NULL )
 	{
+	  int levels = number_of_levels ( type_of_arg );
 	  if ( number_of_levels ( type_of_arg ) == 1 )
 	    {
 	      new_arg_type = TYPE_MAIN_VARIANT ( ri->pointer_rep);
 	    }
 	  else
 	    {
-	      gcc_assert(0);
+	      new_arg_type = make_multilevel ( ri->pointer_rep, levels);
 	    }
 	}
       else
@@ -1196,7 +1284,7 @@ modify_func_type ( struct function *func, Info *info )
   
   //DEBUG_A("new args = ");
   //DEBUG_F( flexible_print, stderr, new_args, 1, (dump_flags_t)0);
-  INDENT(-4);
+  //INDENT(-4);
 
   new_type = build_function_type ( func_ret_type, new_args);
   //DEBUG_L("new_type (func) = ");
@@ -1238,6 +1326,18 @@ tree prev_type;
   return levels;
 }
 
+tree
+make_multilevel( tree base_type, int levels_indirection)
+{
+  if ( levels_indirection == 0 )
+    return base_type;
+  else
+    {
+      tree lower = make_multilevel ( base_type, levels_indirection - 1);
+      return build_pointer_type ( lower);
+    }
+}
+
 static bool
 modify_func_decl_core ( struct function *func, Info *info)
 {
@@ -1460,7 +1560,7 @@ reorg_recognize ( gimple *stmt, cgraph_node* node, Info_t *info )
 {
   //DEBUG_L ( "ReorgTransformation reorg_recognize for: ");
   //DEBUG_F ( print_gimple_stmt, stderr, stmt, 0);
-  INDENT(2);
+  //INDENT(2);
   switch (  gimple_code( stmt) )
   {
   case  GIMPLE_ASSIGN:
@@ -1472,24 +1572,26 @@ reorg_recognize ( gimple *stmt, cgraph_node* node, Info_t *info )
       if ( gimple_assign_single_p ( stmt) )
       {
 	//DEBUG_L("gimple_assign_single_p() = true\n");
-	INDENT(2);
+	//INDENT(2);
 	tree rhs = gimple_assign_rhs1 ( stmt);
 	enum ReorgOpTrans lhs_op = recognize_op ( lhs, true, info);
 	switch ( lhs_op )
 	{
 	case ReorgOpT_Pointer:     // "a"
 	  //DEBUG_L("case ReorgOpT_Pointer\n");
-	  INDENT(-4);
+	  //INDENT(-4);
 	  switch ( recognize_op ( rhs, true, info) )
 	  {
 	  case ReorgOpT_Scalar:
-	    if ( integer_zerop ( rhs) )
 	    {
-	      return ReorgT_Ptr2Zero;
+	      if ( integer_zerop ( rhs) )
+		{
+		  return ReorgT_Ptr2Zero;
+		}
+	      // If we get here this is clearly really odd code
+	      // so we need to bail out.
+	      return Not_Supported;
 	    }
-	    // If we get here this is clearly really odd code
-	    // so we need to bail out.
-	    return Not_Supported;
 	  case ReorgOpT_Temp:      // t
 	    return ReorgT_ElemAssign;
 	  case ReorgOpT_Address:   // "&x[i]"
@@ -1499,7 +1601,7 @@ reorg_recognize ( gimple *stmt, cgraph_node* node, Info_t *info )
 	  }
 	case ReorgOpT_Struct:      // "s"
 	  //DEBUG_L("case ReorgOpT_Struct\n");
-	  INDENT(-4);
+	  //INDENT(-4);
 	  switch ( recognize_op ( rhs, true, info) )
 	  {
 	  case ReorgOpT_Deref:     // "*a"
@@ -1516,7 +1618,7 @@ reorg_recognize ( gimple *stmt, cgraph_node* node, Info_t *info )
 	  }
 	case ReorgOpT_Deref:       // "*a"
 	  //DEBUG_L("case ReorgOpT_Deref\n");
-	  INDENT(-4);
+	  //INDENT(-4);
 	  switch ( recognize_op ( rhs, true, info) )
 	  {
 	  case ReorgOpT_Deref:     // "*a"
@@ -1528,7 +1630,7 @@ reorg_recognize ( gimple *stmt, cgraph_node* node, Info_t *info )
 	  }
 	case ReorgOpT_Array:       // "x[i]"
 	  //DEBUG_L("case ReorgOpT_Array\n");
-	  INDENT(-4);
+	  //INDENT(-4);
 	  switch ( recognize_op ( rhs, true, info) )
 	  {
 	  case ReorgOpT_Struct:    // "s"
@@ -1541,7 +1643,7 @@ reorg_recognize ( gimple *stmt, cgraph_node* node, Info_t *info )
 	case ReorgOpT_Temp:        // t
 	case ReorgOpT_Scalar:      // "z"
 	  //DEBUG_L("case ReorgOpT_%s\n", lhs_op == ReorgOpT_Temp ? "Temp" : "Scalar");
-	  INDENT(-4);
+	  //INDENT(-4);
 	  switch ( recognize_op( rhs, true, info) )
 	  {
 	  case ReorgOpT_Scalar:      // "z"
@@ -1555,42 +1657,43 @@ 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);
+	  //INDENT(-4);
 	  switch ( recognize_op ( rhs, true, info) )
 	  {
+	  case ReorgOpT_Cst:       // k
 	  case ReorgOpT_Temp:      // t
 	  case ReorgOpT_Scalar:    // "z"
 	  case ReorgOpT_Indirect:  // "a->f"
 	  case ReorgOpT_AryDir:    // "x[i].f"
 	    return ReorgT_ElemAssign;
+	  case ReorgOpT_Cst0:
+	    return ReorgT_Ptr2Zero;
 	  default:
 	    return Not_Supported;
 	  }
 	default:
-	  INDENT(-4);
+	  //INDENT(-4);
 	  return Not_Supported;
 	} // switch ( recognize_op ( lhs, true, info) )
       } else {
 	//DEBUG_L("gimple_assign_single_p() = false\n");
-	INDENT(2);
+	//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");
-
+	//DEBUG_F( flexible_print, stderr, op1, 1, TDF_DETAILS);
 	if ( CONVERT_EXPR_CODE_P ( gimple_assign_rhs_code ( stmt)))
 	  {
 	    //DEBUG_L("CONVERT_EXPR_CODE_P (...)\n");
-	    INDENT(-4);
+	    //INDENT(-4);
 	    return ReorgT_Convert;
 	  }
 
 	if ( gimple_assign_rhs3 ( stmt) != NULL )
 	  {
 	    //DEBUG_L("gimple_assign_rhs3 ( stmt) != NULL\n");
-	    INDENT(-4);
+	    //INDENT(-4);
 	    return Not_Supported;
 	  }
 	
@@ -1601,7 +1704,7 @@ reorg_recognize ( gimple *stmt, cgraph_node* node, Info_t *info )
 	    || (POINTER_TYPE_P ( TREE_TYPE( op2)) && integer_zerop ( op1)))
        && ( integer_zerop ( op1) || integer_zerop ( op2) );
 	//DEBUG_L("zero_case = %s\n", zero_case ? "true" : "false" );
-	INDENT(-4);
+	//INDENT(-4);
 	switch ( rhs_code )
 	{
 	case POINTER_PLUS_EXPR:
@@ -1664,7 +1767,7 @@ reorg_recognize ( gimple *stmt, cgraph_node* node, Info_t *info )
       gcc_assert( edge);
       //DEBUG_L("called function %s gimple_body\n",
       //	      edge->callee->has_gimple_body_p() ? "has a" : "has no");
-      INDENT(-2);
+      //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;
       if ( gimple_call_builtin_p( stmt, BUILT_IN_REALLOC) ) return ReorgT_Realloc;
@@ -1685,14 +1788,14 @@ reorg_recognize ( gimple *stmt, cgraph_node* node, Info_t *info )
     break;
   case GIMPLE_RETURN:
     //DEBUG_L("GIMPLE_RETURN:\n");
-    INDENT(-2);
+    //INDENT(-2);
     return ReorgT_Return;
     break;
   default:
     //DEBUG_L ( "didn't support: ");
     //DEBUG_F ( print_gimple_stmt, stderr, stmt, 0);
     //DEBUG( "\n");
-    INDENT(-2);
+    //INDENT(-2);
     return Not_Supported;
   }
 }
@@ -1812,17 +1915,28 @@ recognize_op ( tree op,  bool lie, Info *info)
       // case with a bogus RHS.
       //DEBUG_L("  returns: ReorgOpT_Temp\n");
       return ReorgOpT_Temp;
+    case INTEGER_CST:
+      if ( integer_zerop ( op) )
+	{
+	  //DEBUG_A("  returns: ReorgOpT_Cst0\n");
+	  return ReorgOpT_Cst0;
+	}
     case REAL_CST:
     case FIXED_CST:
     case STRING_CST:
     case COMPLEX_CST:
     case CONSTRUCTOR:
-    case INTEGER_CST:
     case VECTOR_CST:
-      return ReorgOpT_Cst;
+      {
+	//DEBUG_A("  returns: ReorgOpT_Cst\n");
+	return ReorgOpT_Cst;
+      }
     }
   
   tree type = TREE_TYPE ( op);
+  // This type bases approach seems like crap.
+  // I'm turning it off to see what breaks.
+  #if 0
   if ( type != NULL && POINTER_TYPE_P (type) )
   {
     //DEBUG_L("POINTER_TYPE_P (type) = true\n");
@@ -1840,41 +1954,74 @@ recognize_op ( tree op,  bool lie, Info *info)
       return ReorgOpT_Scalar;
     }
   }
+  #endif
   // This might not occur in practice
   if ( op_code == RECORD_TYPE )
   {
     // The assumption here is that this
     // is a reorg type.
-    //DEBUG_L("  returns: ReorgOpT_Struct\n");
+    //DEBUG_A("  returns: ReorgOpT_Struct\n");
     return ReorgOpT_Struct;
   }
   if ( op_code == VAR_DECL )
   {
     tree type = TREE_TYPE ( op);
-    //DEBUG_L("  recursing on type :");
-    //DEBUG_F( flexible_print, stderr, type, 1, TDF_DETAILS);
-    return recognize_op ( type, true, info);
+    gcc_assert ( type != NULL );
+    if ( POINTER_TYPE_P (type) )
+      {
+	bool a_reorg = is_reorg_type ( type, info);
+	if ( a_reorg || !lie )
+	  {
+	    //DEBUG_A("  returns: ReorgOpT_Pointer\n");
+	    return ReorgOpT_Pointer;
+	  }
+	else
+	  {
+	    // This would be for when the field of a struct
+	    // element is a pointer that's not a reorg
+	    // pointer. I.e. ReorgT_ElemAssign. That is
+	    // this is while lie for a good purpose.	    
+	    //DEBUG_L("  returns: ReorgOpT_Scalar\n");
+	    return ReorgOpT_Scalar;
+	  }
+      }
+    //DEBUG_L("  returns: ReorgOpT_Scalar\n");
+    return ReorgOpT_Scalar;
   }
   tree inner_op = TREE_OPERAND( op, 0);
   tree inner_type = TREE_TYPE ( inner_op);
   enum tree_code inner_op_code = TREE_CODE ( inner_op);
   //DEBUG_L("inner_op = ");
-  //DEBUG_F( print_generic_expr, stderr, inner_op, TDF_DETAILS);
-  //DEBUG(", TREE_CODE = %s\n", code_str( TREE_CODE(inner_op)));
+  //DEBUG_F(flexible_print, stderr, inner_op, 0, (dump_flags_t)0);
+  //DEBUG(", TREE_CODE = %s\n", code_str( inner_op_code));
   if ( op_code == ADDR_EXPR )
     {
       //DEBUG_L("op_code == ADDR_EXPR\n");
-      bool a_reorg = is_reorg_type ( inner_op, info);
-      if (    inner_op_code == ARRAY_REF
-	      && (a_reorg || !lie)   )
+      if ( inner_op_code == ARRAY_REF )
+	{
+	  bool a_reorg = is_reorg_type ( inner_op, info);
+	  if ( a_reorg || !lie )
+	    {
+	      //DEBUG_L("  returns: ReorgOpT_Address\n");
+	      return ReorgOpT_Address;
+	    }
+	}
+      // TBD shouldn't we be testing for a reorg???
+      if ( inner_op_code == VAR_DECL )
 	{
-	  //DEBUG_L("  returns: ReorgOpT_Address\n");
-	  return ReorgOpT_Address;
+	  tree var_type = TREE_TYPE ( inner_op );
+	  bool a_reorg = is_reorg_type ( var_type, info);
+	  if ( a_reorg || !lie )
+	    {
+	      //DEBUG_L("  returns: ReorgOpT_Address\n");
+	      return ReorgOpT_Address;
+	    }
 	}
     }
   if ( op_code == COMPONENT_REF )
   {
     //DEBUG_L("op_code == COMPONENT_REF\n");
+    
     if ( inner_op_code == INDIRECT_REF )
     {
       //DEBUG_L("TREE_CODE( inner_op) == INDIRECT_REF\n");
@@ -1907,7 +2054,7 @@ recognize_op ( tree op,  bool lie, Info *info)
     bool a_reorg = is_reorg_type ( base_type_of ( inner_type), info);
     if ( a_reorg || !lie )
       {
-	//DEBUG_L("  returns: ReorgOpT_AryDir\n");
+	//DEBUG_A("  returns: ReorgOpT_AryDir\n");
 	return ReorgOpT_AryDir;
       }
     // Just normal field reference otherwise...
@@ -1920,7 +2067,7 @@ recognize_op ( tree op,  bool lie, Info *info)
     bool a_reorg = is_reorg_type( base_type_of ( type), info);
     if ( a_reorg || !lie )
     {
-      //DEBUG_L("  returns: ReorgOpT_Array\n");
+      //DEBUG_A("  returns: ReorgOpT_Array\n");
       return ReorgOpT_Array;
     }
     //DEBUG_L("  returns: ReorgOpT_Scalar\n");
@@ -1935,7 +2082,7 @@ recognize_op ( tree op,  bool lie, Info *info)
     bool a_reorg = is_reorg_type ( type, info);
     if( a_reorg || !lie )
     {
-      //DEBUG_L("  returns: ReorgOpT_Deref\n");
+      //DEBUG_A("  returns: ReorgOpT_Deref\n");
       return ReorgOpT_Deref;
     }
     //DEBUG_L("  returns: ReorgOpT_Scalar\n");
@@ -1948,6 +2095,8 @@ recognize_op ( tree op,  bool lie, Info *info)
 bool
 is_reorg_type( tree rt, Info *info )
 {
+  tree tmv_type = TYPE_MAIN_VARIANT ( rt);
+  tree type2check = tmv_type ? tmv_type : rt;
   return get_reorgtype_info ( rt, info) != NULL;  
 }
 
@@ -2100,12 +2249,16 @@ bool same_type_p( tree a, tree b )
 ReorgType_t *
 get_reorgtype_info ( tree type, Info* info)
 {
-  //DEBUG_L( "get_reorgtype_info\n");
+  //DEBUG_L( "get_reorgtype_info: type = ");
+  //DEBUG_F(  flexible_print, stderr, type, 1, (dump_flags_t)0);
   
   // Note, I'm going to use the most stupid and slowest possible way
   // to do this. The advanage is it will be super easy and almost
   // certainly correct. It will also almost certainly need to be
   // improved but I get something out there now.
+
+  tree tmv_type = TYPE_MAIN_VARIANT ( type);
+  tree type2check = tmv_type ? tmv_type : type;
   for ( std::vector<ReorgType_t>::iterator ri = info->reorg_type->begin ();
 	ri != info->reorg_type->end ();
 	ri++                                                              )
@@ -2118,7 +2271,7 @@ get_reorgtype_info ( tree type, Info* info)
     //DEBUG_L("");
     //DEBUG_F( print_generic_expr, stderr, type, TDF_DETAILS);
     //DEBUG("\n");
-    if ( same_type_p ( ri->gcc_type, type) )
+    if ( same_type_p ( ri->gcc_type, type2check) )
     {
       //DEBUG_A( "  returns %p\n", &(*ri));
       
@@ -2160,11 +2313,11 @@ contains_a_reorgtype ( gimple *stmt, Info *info)
 {
   //DEBUG_L ( "contains_a_reorgtype: ");
   //DEBUG_F ( print_gimple_stmt, stderr, stmt, 0);
-  INDENT(2);
+  //INDENT(2);
 
   if ( gimple_code ( stmt) == GIMPLE_PHI )
     {
-      INDENT(-2);
+      //INDENT(-2);
       tree base = base_type_of ( TREE_TYPE ( PHI_RESULT ( stmt)));
       return get_reorgtype_info ( base, info);
     }
@@ -2179,7 +2332,7 @@ contains_a_reorgtype ( gimple *stmt, Info *info)
       walk_gimple_op ( stmt,
 		       detect_reorg,
 		       &walk_info);
-      INDENT(-2);
+      //INDENT(-2);
       return hi.found_reorg;
     }
 }
@@ -2263,26 +2416,34 @@ print_base_reorg ( FILE *file, int leading_space, ReorgType_t *reorg, bool detai
     = identifier_to_locale ( IDENTIFIER_POINTER ( TYPE_NAME ( reorg->gcc_type)));
   fprintf ( file, "%*s{ type:%s, #%d, ", leading_space, "",text, reorg->id);
 
-  if( reorg->do_dead_field_elim ) {
-    fprintf ( file, "elim:{ ");
-    // TBD
-    fprintf ( file, "}, ");
-  }
+  if ( reorg->do_dead_field_elim )
+    {
+      fprintf ( file, "elim:{ ");
+      // TBD
+      fprintf ( file, "}, ");
+    }
   
-  if( reorg->do_field_reorder ) {
-    fprintf ( file, "reorder:{ ");
-    // TBD
-    fprintf ( file, "}, ");
-  }
+  if ( reorg->do_field_reorder )
+    {
+      fprintf ( file, "reorder:{ ");
+      // TBD
+      fprintf ( file, "}, ");
+    }
+  
+  if ( reorg->do_instance_interleave )
+    {
+      fprintf ( file, "inter:{ ");
+      // TBD
+      fprintf ( file, "%s, ",
+		reorg->instance_interleave.multi_pool ? "multi" : "single" );
+      // TBD When multi-pool implemented (and found) emit pointer_rep.
+      fprintf ( file, "}, ");
+    }
+  else
+    {
+      fprintf ( file, "no interleave, ");
+    }
   
-  if( reorg->do_instance_interleave ) {
-    fprintf ( file, "inter:{ ");
-    // TBD
-    fprintf ( file, "%s, ",
-	      reorg->instance_interleave.multi_pool ? "multi" : "single" );
-    // TBD When multi-pool implemented (and found) emit pointer_rep.
-    fprintf ( file, "}, ");
-  }
   if ( reorg->reorg_ver_type != NULL )
     {
       // TBD does this belong here? How will the clone be done with elim and
@@ -2487,6 +2648,8 @@ print_function ( FILE *file, int leading_space, struct function *func)
 ReorgType_t *
 get_reorgtype( gimple *stmt, Info *info, int i)
 {
+  //DEBUG_A("get_reorgtype: i = %d, stmt = ", i);
+  //DEBUG_F(print_gimple_stmt, stderr, stmt, 0);
   // Looking at operands of statement, when we get to
   // the ith one, return it.
   int num_reorgs = 0;
@@ -2496,11 +2659,37 @@ get_reorgtype( gimple *stmt, Info *info, int i)
     {
       tree op = gimple_op ( stmt, j);
       if ( tree_contains_a_reorgtype_p ( op, info) ) {
-	num_reorgs++;
 	if ( num_reorgs == i )
 	  {
-	    return get_reorgtype_info ( op, info);
+	    //DEBUG_A("op = ");
+	    //DEBUG_F(  flexible_print, stderr, op, 1, (dump_flags_t)0);
+
+	    if ( TREE_CODE ( op) == COMPONENT_REF )
+	      {
+		tree field_op = TREE_OPERAND ( op, 1);
+		tree field_type = TREE_TYPE ( field_op);
+		tree base_field_type = base_type_of ( field_type);
+		//DEBUG_A("field_op = ");
+		//DEBUG_F(  flexible_print, stderr, field_op, 1, (dump_flags_t)0);
+		//DEBUG_A("field_type = ");
+		//DEBUG_F(  flexible_print, stderr, field_type, 1, (dump_flags_t)0);
+		//DEBUG_A("base_field_type = ");
+		//DEBUG_F(  flexible_print, stderr, base_field_type, 1, (dump_flags_t)0);
+		return get_reorgtype_info ( base_field_type, info);
+	      }
+	    else
+	      {
+		tree op_type = TREE_TYPE ( op);
+		tree op_base_type = base_type_of ( op_type);
+		//DEBUG_A("op_type = ");
+		//DEBUG_F(  flexible_print, stderr, op_type, 1, (dump_flags_t)0);
+		//DEBUG_A("op_base_type = ");
+		//DEBUG_F(  flexible_print, stderr, op_base_type, 1, (dump_flags_t)0);
+
+		return get_reorgtype_info ( op_base_type, info);
+	      }
 	  }
+	num_reorgs++;
       }
     }
   gcc_assert ( 0);
@@ -2600,6 +2789,22 @@ modify_ssa_name_type ( tree ssa_name, tree type)
     }
 }
 
+bool
+is_assign_from_ssa ( gimple *stmt )
+{
+  if ( is_gimple_assign ( stmt) )
+    {
+      //DEBUG_A("is gimple assign\n");
+      if ( gimple_assign_rhs_class ( stmt) == GIMPLE_SINGLE_RHS )
+	{
+	  //DEBUG_A("has single rhs\n");
+	  if ( TREE_CODE ( gimple_assign_rhs1 ( stmt)) == SSA_NAME )
+	    return true;
+	}
+    }
+  return false;
+}
+
 //-- debugging only --
 //static const char *
 #if DEBUGGING
diff --git a/gcc/ipa-structure-reorg.h b/gcc/ipa-structure-reorg.h
index 3f2e137af6c..0a3a87e3088 100644
--- a/gcc/ipa-structure-reorg.h
+++ b/gcc/ipa-structure-reorg.h
@@ -28,6 +28,8 @@ along with GCC; see the file COPYING3.  If not see
 #define USE_REORG_TYPES 1
 // If PRINT_FORMAT is true use pass specific print format.
 #define PRINT_FORMAT false
+// Trun off actual transformations for testing
+#define BYPASS_TRANSFORM false
 
 typedef struct RT_Elim       RT_Elim;
 typedef struct RT_Reorder    RT_Reorder;
@@ -100,7 +102,8 @@ enum ReorgOpTrans {
   ReorgOpT_Scalar,      // "z"
   ReorgOpT_Indirect,    // "a->f"
   ReorgOpT_AryDir,      // "x[i].f"
-  ReorgOpT_Cst
+  ReorgOpT_Cst,
+  ReorgOpT_Cst0
 };
 
 enum CompressionControl {
@@ -226,6 +229,7 @@ extern int str_reorg_instance_interleave ( Info *);
 #endif
 
 extern int number_of_levels ( tree);
+extern tree make_multilevel( tree, int);
 extern bool modify_decl_core ( tree *, Info *);
 extern void delete_reorgtype ( ReorgType_t *, Info_t *);
 extern void undelete_reorgtype ( ReorgType_t *, Info_t *);
@@ -251,14 +255,15 @@ extern void print_type ( FILE *, tree);
 extern void modify_ssa_name_type ( tree, tree);
 extern bool print_internals (gimple *, void *);
 extern const char *optrans_to_str ( enum ReorgOpTrans);
+extern bool is_assign_from_ssa ( gimple *);
 
 
 
-// I have no intention of leaving this or uses of the
-// defined marcos in the code. However, some of uses
-// should obviously be converted to dump file information.
+// I have no intention of leaving these debugging marcos or uses of
+// them in the code. However, some of the uses should obviously be
+// converted to dump file information.
 
-#define DEBUGGING 0
+#define DEBUGGING 1
 #if DEBUGGING
 enum Display {
   Show_nothing,