debugging of malloc and interface nicities

3 files changed, 327 insertions, 322 deletions

diff --git a/gcc/ipa-str-reorg-instance-interleave.c b/gcc/ipa-str-reorg-instance-interleave.c
index d2eaa0fa4c7..d14b51abe66 100644
--- a/gcc/ipa-str-reorg-instance-interleave.c
+++ b/gcc/ipa-str-reorg-instance-interleave.c
@@ -291,240 +291,243 @@ str_reorg_instance_interleave_trans ( Info *info)
 		    // Not needed for single pool.
 		    break;
 		  case ReorgT_Malloc:
-		    #if 0
-		    DEBUG_L("Transform ReorgT_Malloc\n");
-		    INDENT(2);
-		    // Note, unlike other simpler transformations,
-		    // this must build new basic blocks to add new
-		    // gimple to and use a phi for the final result.
-		    // See appendix on malloc transformation for
-		    // each comment starting with "FROM."
-		    ReorgType_t *ri = contains_a_reorgtype( stmt, info);
-		    // FROM len = val/size
-		    tree arg = gimple_call_arg( stmt, 0);
-		    // TBD: len is new SSA
-		    tree val = gimple_call_lhs( stmt);
-		    gcc_assert( TREE_CODE( TREE_TYPE(val)) == INDIRECT_REF);
-		    tree size = TYPE_SIZE_UNIT( TREE_TYPE( TREE_TYPE( val)));
-		    // FROM len = val/size (insert before stmt) <== maybe arg/size
-		    tree len =
-		      make_temp_ssa_name( sizetype, NULL, "fail_val");
-		    gimple_stmt_iterator gsi = gsi_for_stmt( stmt);
-		    //gimple *glen = 
-		    //  gimple_build_assign ( len, TRUNC_DIV_EXPR, val, size); 
-		    gimple *glen = 
-		      gimple_build_assign ( len, TRUNC_DIV_EXPR, arg, size); 
-		    gsi_insert_before( &gsi, glen, GSI_SAME_STMT);
-		    // Note in other places in this doc this would
-		    // be "insert glen before stmt" instead of this but
-		    // here we need to create new basic blocks.
-		    // FROM edge = split this block after stmt
-		    edge new_edge = split_block ( bb, stmt);
-		    // FROM before_bb = edge->src // same as this bb
-		    basic_block before_bb = new_edge->src; // 
-		    // FROM after_bb = edge->dest
-		    basic_block after_bb = new_edge->dest;
-		    // FROM delete edge
-		    remove_edge ( new_edge);
-		    // FROM prev_bb = before_bb
-		    basic_block prev_bb = before_bb;
-		    // FROM prev_ok_field is new label
-		    tree prev_ok_field_L =
-		      create_artificial_label ( UNKNOWN_LOCATION);
-		    // FROM after_label is new label
-		    tree after_label_L =
-		      create_artificial_label ( UNKNOWN_LOCATION);
-		    // FROM add goto for prev_ok_field to end of before_bb
-		    gimple *goto_pof = gimple_build_goto ( prev_ok_field_L);
-		    gsi_insert_before ( &gsi, goto_pof, GSI_SAME_STMT); // TBD insert after???
-		    // FROM failure_bb = create_empty_block(prev_bb)
-		    basic_block failure_bb = create_empty_bb ( prev_bb);
-		    // FROM make_edge( failure_bb, after_bb, EDGE_FALLTHRU);
-		    edge failure_edge = make_edge ( failure_bb,
-						    after_bb, EDGE_FALLTHRU);
-		    // FROM bad_field is new label
-		    tree bad_field_L =
-		      create_artificial_label ( UNKNOWN_LOCATION);
-		    // FROM delete stmt
-		    gsi_remove ( &gsi, true);
-
-		    // code in failure_bb
-		    //
-		    // FROM fail_val is new SSA
-		    tree return_type = TREE_TYPE ( arg);
-		    tree fail_val = 
-		      make_temp_ssa_name ( return_type, NULL, "fail_val");
+		    #if 1
+		    {
+		      DEBUG_L("Transform ReorgT_Malloc\n");
+		      INDENT(2);
+		      // Note, unlike other simpler transformations,
+		      // this must build new basic blocks to add new
+		      // gimple to and use a phi for the final result.
+		      // See appendix on malloc transformation for
+		      // each comment starting with "FROM."
+		      ReorgType_t *ri = contains_a_reorgtype( stmt, info);
+		      // FROM len = val/size
+		      tree arg = gimple_call_arg( stmt, 0);
+		      // TBD: len is new SSA
+		      tree val = gimple_call_lhs( stmt);
+		      gcc_assert( TREE_CODE( TREE_TYPE(val)) == INDIRECT_REF);
+		      tree size = TYPE_SIZE_UNIT( TREE_TYPE( TREE_TYPE( val)));
+		      // FROM len = val/size (insert before stmt) <== maybe arg/size
+		      tree len =
+			make_temp_ssa_name( sizetype, NULL, "fail_val");
+		      gimple_stmt_iterator gsi = gsi_for_stmt( stmt);
+		      //gimple *glen = 
+		      //  gimple_build_assign ( len, TRUNC_DIV_EXPR, val, size); 
+		      gimple *glen = 
+			gimple_build_assign ( len, TRUNC_DIV_EXPR, arg, size); 
+		      gsi_insert_before( &gsi, glen, GSI_SAME_STMT);
+		      // Note in other places in this doc this would
+		      // be "insert glen before stmt" instead of this but
+		      // here we need to create new basic blocks.
+		      // FROM edge = split this block after stmt
+		      edge new_edge = split_block ( bb, stmt);
+		      // FROM before_bb = edge->src // same as this bb
+		      basic_block before_bb = new_edge->src; // 
+		      // FROM after_bb = edge->dest
+		      basic_block after_bb = new_edge->dest;
+		      // FROM delete edge
+		      remove_edge ( new_edge);
+		      // FROM prev_bb = before_bb
+		      basic_block prev_bb = before_bb;
+		      // FROM prev_ok_field is new label
+		      tree prev_ok_field_L =
+			create_artificial_label ( UNKNOWN_LOCATION);
+		      // FROM after_label is new label
+		      tree after_label_L =
+			create_artificial_label ( UNKNOWN_LOCATION);
+		      // FROM add goto for prev_ok_field to end of before_bb
+		      gimple *goto_pof = gimple_build_goto ( prev_ok_field_L);
+		      gsi_insert_before ( &gsi, goto_pof, GSI_SAME_STMT); // TBD insert after???
+		      // FROM failure_bb = create_empty_block(prev_bb)
+		      basic_block failure_bb = create_empty_bb ( prev_bb);
+		      // FROM make_edge( failure_bb, after_bb, EDGE_FALLTHRU);
+		      edge failure_edge = make_edge ( failure_bb,
+						      after_bb, EDGE_FALLTHRU);
+		      // FROM bad_field is new label
+		      tree bad_field_L =
+			create_artificial_label ( UNKNOWN_LOCATION);
+		      // FROM delete stmt
+		      gsi_remove ( &gsi, true);
+		      
+		      // code in failure_bb
+		      //
+		      // FROM fail_val is new SSA
+		      tree return_type = TREE_TYPE ( arg);
+		      tree fail_val = 
+			make_temp_ssa_name ( return_type, NULL, "fail_val");
 		      // FROM gsi = gsi_start_bb ( failure_bb)
-		    gsi = gsi_start_bb ( failure_bb);
-		    // FROM gsi_insert_after ( &gsi, "goto after_label")
-		    gimple *goto_al = gimple_build_goto ( after_label_L);
-		    gsi_insert_after ( &gsi, goto_al, GSI_SAME_STMT);
-		    // (per field) {
-		    tree field;
-		    tree reorg_type = ri->gcc_type; // is this useful here?
-		    tree reorg_pointer_type = ri->pointer_rep;
-		    tree fndecl_free = builtin_decl_explicit( BUILT_IN_FREE);
-		    tree base = ri->clone;
-		    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);
-		      gimple *gzero = gimple_build_assign( lhs_ass, null_pointer_node);
-		      gsi_insert_after( &gsi, gzero, GSI_SAME_STMT);
-		
-		      // FROM gsi_insert_after( &gsi, "free(field)")
-		      // TBD -- I'm 
-		      tree to_free = 
-			make_temp_ssa_name( reorg_pointer_type, NULL, "to_free");
-		      gcall *free_call = gimple_build_call( fndecl_free, 1, to_free);
-		      gsi_insert_after( &gsi, free_call, GSI_SAME_STMT);
-		      tree rhs_ass =
-			build3( COMPONENT_REF, ptr_type_node, base, field, NULL_TREE);
-		      gimple *gaddr2free = gimple_build_assign( to_free, rhs_ass);
-		      gsi_insert_after( &gsi, gaddr2free, GSI_SAME_STMT);
-		    }
-		    // FROM gsi_insert_after( &gsi, "fail_val = minint")
-		    gimple *gretnull =
-		      gimple_build_assign ( fail_val,
-					    build_int_cst ( size_type_node,
-							    TYPE_MIN_VALUE ( TREE_TYPE ( fail_val))));
-		    gsi_insert_after( &gsi, gretnull, GSI_SAME_STMT);
-		    // FROM gsi_insert_after( &gsi, bad_field )
-		    gimple *gbad_field = gimple_build_label( bad_field_L);
-		    gsi_insert_after( &gsi, gbad_field, GSI_SAME_STMT);
-		    
-		    // loop setup trickery for gimple idioms
-		    //
-		    // FROM prev_order = failure_bb
-		    basic_block prev_order = failure_bb;
-		    // FROM prev_bb = before_bb
-		    prev_bb = before_bb;
-		    
-		    // Generate all the real allocation code
-		    tree fndecl_malloc = builtin_decl_explicit( BUILT_IN_MALLOC);
-		    // This, after the following loop, will hold the start of the
-		    // field related code.
-		    tree new_ok_field_L;
-
-		    // FROM (for fields) {
-		    for( field = TYPE_FIELDS( reorg_type); 
-			 field; 
-			 field = DECL_CHAIN( field))
-		      {
-			// FROM res is new SSA
-			// Note, alternative code would substitute ptr_type_node
-			// for null_pointer_node.
-			// This is probably a duplicate of the def of res below.
-			//tree res = 
-			//  make_temp_ssa_name( null_pointer_node, NULL, "res");
-			// FROM new_bb = create_empty_block(prev_order);
-			basic_block new_bb = create_empty_bb ( prev_order);
-			// FROM gsi = gsi_start_bb( new_bb)
-			gimple_stmt_iterator gsi = gsi_start_bb ( new_bb);
-			// FROM set imm dom new_bb as prev_bb
-			set_immediate_dominator ( CDI_DOMINATORS, new_bb, prev_bb);	
-			// FROM make_edge( prev_bb, new_bb, EDGE_TRUE_VALUE);
-			make_edge ( prev_bb, new_bb, EDGE_TRUE_VALUE);
-			// FROM make_edge( new_bb, failure_bb, EDGE_FALSE_VALUE);
-			make_edge ( new_bb, failure_bb, EDGE_FALSE_VALUE);
-			// FROM new_ok_field is new label
-			new_ok_field_L =
-			  create_artificial_label ( UNKNOWN_LOCATION);
-			// FROM gsi_insert_after( &gsi, "if( res NE NULL ) 
-			//    	            goto new_ok_field; 
-			//		    goto bad_field")
-			tree res = 
-			  make_temp_ssa_name ( ptr_type_node, NULL, "res");
-			gimple *gcond =
-			  gimple_build_cond ( NE_EXPR, res, null_pointer_node,
-					      new_ok_field_L, bad_field_L);
-			gsi_insert_after ( &gsi, gcond, GSI_SAME_STMT);		
-			// FROM gsi_insert_after( &gsi, "base.field = res")
+		      gsi = gsi_start_bb ( failure_bb);
+		      // FROM gsi_insert_after ( &gsi, "goto after_label")
+		      gimple *goto_al = gimple_build_goto ( after_label_L);
+		      gsi_insert_after ( &gsi, goto_al, GSI_SAME_STMT);
+		      // (per field) {
+		      tree field;
+		      tree reorg_type = ri->gcc_type; // is this useful here?
+		      tree reorg_pointer_type = ri->pointer_rep;
+		      tree fndecl_free = builtin_decl_explicit( BUILT_IN_FREE);
+		      tree base = ri->clone;
+		      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);
-			gimple *gset_field = gimple_build_assign( lhs_ass, res);
-			gsi_insert_after( &gsi, gset_field, GSI_SAME_STMT);
+			gimple *gzero = gimple_build_assign( lhs_ass, null_pointer_node);
+			gsi_insert_after( &gsi, gzero, 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.
-			tree mem_size = 
-			  make_temp_ssa_name( sizetype, NULL, "mem_size");
-			gcall *malloc_call = gimple_build_call( fndecl_malloc, 1, mem_size);
-			gimple_call_set_lhs( malloc_call, res);
-			gsi_insert_after( &gsi, malloc_call, GSI_SAME_STMT);
-			// 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);
-			gimple *gsize = 
-			  gimple_build_assign ( mem_size,
-						MULT_EXPR,
-						TYPE_SIZE ( field), 
-						len);
-			gsi_insert_after( &gsi, gsize, GSI_SAME_STMT);
-			// FROM gsi_insert_after( &gsi, prev_ok_field)
-			gimple *gprev_ok_field = gimple_build_label ( prev_ok_field_L);
-			gsi_insert_after ( &gsi, gprev_ok_field, GSI_SAME_STMT);
-			// FROM prev_bb = new_bb
-			prev_bb = new_bb;
-			// FROM prev_order = new_bb
-			prev_order = new_bb;
-			// FROM prev_ok_field = new_ok_field
-			prev_ok_field_L = new_ok_field_L;
+			// FROM gsi_insert_after( &gsi, "free(field)")
+			// TBD -- I'm 
+			tree to_free = 
+			  make_temp_ssa_name( reorg_pointer_type, NULL, "to_free");
+			gcall *free_call = gimple_build_call( fndecl_free, 1, to_free);
+			gsi_insert_after( &gsi, free_call, GSI_SAME_STMT);
+			tree rhs_ass =
+			  build3( COMPONENT_REF, ptr_type_node, base, field, NULL_TREE);
+			gimple *gaddr2free = gimple_build_assign( to_free, rhs_ass);
+			gsi_insert_after( &gsi, gaddr2free, GSI_SAME_STMT);
 		      }
+		      // FROM gsi_insert_after( &gsi, "fail_val = minint")
+		      gimple *gretnull =
+			gimple_build_assign ( fail_val,
+					      //build_int_cst ( size_type_node,
+					      TYPE_MIN_VALUE ( TREE_TYPE ( fail_val))); // );
+		      gsi_insert_after( &gsi, gretnull, GSI_SAME_STMT);
+		      // FROM gsi_insert_after( &gsi, bad_field )
+		      gimple *gbad_field = gimple_build_label( bad_field_L);
+		      gsi_insert_after( &gsi, gbad_field, GSI_SAME_STMT);
+		      
+		      // loop setup trickery for gimple idioms
+		      //
+		      // FROM prev_order = failure_bb
+		      basic_block prev_order = failure_bb;
+		      // FROM prev_bb = before_bb
+		      prev_bb = before_bb;
+		      
+		      // Generate all the real allocation code
+		      tree fndecl_malloc = builtin_decl_explicit( BUILT_IN_MALLOC);
+		      // This, after the following loop, will hold the start of the
+		      // field related code.
+		      tree new_ok_field_L;
+		      
+		      // FROM (for fields) {
+		      for( field = TYPE_FIELDS( reorg_type); 
+			   field; 
+			   field = DECL_CHAIN( field))
+			{
+			  // FROM res is new SSA
+			  // Note, alternative code would substitute ptr_type_node
+			  // for null_pointer_node.
+			  // This is probably a duplicate of the def of res below.
+			  //tree res = 
+			  //  make_temp_ssa_name( null_pointer_node, NULL, "res");
+			  // FROM new_bb = create_empty_block(prev_order);
+			  basic_block new_bb = create_empty_bb ( prev_order);
+			  // FROM gsi = gsi_start_bb( new_bb)
+			  gimple_stmt_iterator gsi = gsi_start_bb ( new_bb);
+			  // FROM set imm dom new_bb as prev_bb
+			  set_immediate_dominator ( CDI_DOMINATORS, new_bb, prev_bb);	
+			  // FROM make_edge( prev_bb, new_bb, EDGE_TRUE_VALUE);
+			  make_edge ( prev_bb, new_bb, EDGE_TRUE_VALUE);
+			  // FROM make_edge( new_bb, failure_bb, EDGE_FALSE_VALUE);
+			  make_edge ( new_bb, failure_bb, EDGE_FALSE_VALUE);
+			  // FROM new_ok_field is new label
+			  new_ok_field_L =
+			    create_artificial_label ( UNKNOWN_LOCATION);
+			  // FROM gsi_insert_after( &gsi, "if( res NE NULL ) 
+			  //    	            goto new_ok_field; 
+			  //		    goto bad_field")
+			  tree res = 
+			    make_temp_ssa_name ( ptr_type_node, NULL, "res");
+			  gimple *gcond =
+			    gimple_build_cond ( NE_EXPR, res, null_pointer_node,
+						new_ok_field_L, bad_field_L);
+			  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);
+			  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.
+			  tree mem_size = 
+			    make_temp_ssa_name( sizetype, NULL, "mem_size");
+			  gcall *malloc_call = gimple_build_call( fndecl_malloc, 1, mem_size);
+			  gimple_call_set_lhs( malloc_call, res);
+			  gsi_insert_after( &gsi, malloc_call, GSI_SAME_STMT);
+			  // 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);
+			  gimple *gsize = 
+			    gimple_build_assign ( mem_size,
+						  MULT_EXPR,
+						  TYPE_SIZE ( field), 
+						  len);
+			  gsi_insert_after( &gsi, gsize, GSI_SAME_STMT);
+			  // FROM gsi_insert_after( &gsi, prev_ok_field)
+			  gimple *gprev_ok_field = gimple_build_label ( prev_ok_field_L);
+			  gsi_insert_after ( &gsi, gprev_ok_field, GSI_SAME_STMT);
+			  // FROM prev_bb = new_bb
+			  prev_bb = new_bb;
+			  // FROM prev_order = new_bb
+			  prev_order = new_bb;
+			  // FROM prev_ok_field = new_ok_field
+			  prev_ok_field_L = new_ok_field_L;
+			}
+		      
+		      // create basic block for success
+		      //
+		      // FROM success_bb = create_empty_block(prev_bb_order);
+		      basic_block success_bb = create_empty_bb ( prev_bb);
+		      // FROM set imm dom success_bb as prev_bb
+		      set_immediate_dominator ( CDI_DOMINATORS, success_bb, prev_bb);
+		      // FROM make_edge( prev_bb, success_bb, EDGE_TRUE_VALUE);
+		      make_edge ( prev_bb, success_bb, EDGE_TRUE_VALUE);
+		      // FROM make_edge( success_bb, after_bb, EDGE_TRUE_VALUE);
+		      edge success_edge = make_edge ( success_bb, after_bb, EDGE_TRUE_VALUE);
+		      
+		      // code in success_bb
+		      //
+		      // FROM success_val is new SSA
+		      tree success_val = 
+			make_temp_ssa_name( reorg_pointer_type, NULL, "success_val");
+		      // FROM gsi = gsi_start_bb( failure_bb)
+		      // Reuse the same gsi??? Or create a new one???
+		      //gimple_stmt_iterator gsi = gsi_start_bb ( failure_bb);
+		      gsi = gsi_start_bb ( success_bb);  // used to be failure_bb
+		      // FROM gsi_insert_after( &gsi, "goto after_label")
+		      // Reuse goto_al
+		      //gimple *goto_al = gimple_build_goto( after_label_L);
+		      goto_al = gimple_build_goto( after_label_L);
+		      gsi_insert_after( &gsi, goto_al, GSI_SAME_STMT);
+		      // FROM gsi_insert_after( &gsi, "success_val = 0")
+		      gimple *set_succ =
+			gimple_build_assign ( success_val,
+					      build_int_cst ( reorg_pointer_type, 0));
+		      gsi_insert_after( &gsi, set_succ, GSI_SAME_STMT);
+		      // FROM gsi_insert_after( &gsi, new_ok_field )
+		      gimple *gnew_ok_field = gimple_build_label ( new_ok_field_L);
+		      gsi_insert_after ( &gsi, gnew_ok_field, GSI_SAME_STMT);
+		      
+		      // add code to after_bb
+		      //
+		      // FROM gsi = gsi_start_bb( after_bb)
+		      // Reuse gsi
+		      //gimple_stmt_iterator gsi = gsi_start_bb( after_bb);
+		      gsi = gsi_start_bb( after_bb);
+		      // FROM gsi_insert_after( &gsi, "lhs = "phi(success_val, fail_val)
+		      gphi *der_phi = create_phi_node( val, after_bb); // was lhs?? instead of val
+		      add_phi_arg( der_phi, success_val, success_edge, UNKNOWN_LOCATION);
+		      add_phi_arg( der_phi, fail_val, failure_edge, UNKNOWN_LOCATION);
+		      gsi_insert_after( &gsi, der_phi, GSI_SAME_STMT);
 
-		    // create basic block for success
-		    //
-		    // FROM success_bb = create_empty_block(prev_bb_order);
-		    basic_block success_bb = create_empty_bb ( prev_bb);
-		    // FROM set imm dom success_bb as prev_bb
-		    set_immediate_dominator ( CDI_DOMINATORS, success_bb, prev_bb);
-		    // FROM make_edge( prev_bb, success_bb, EDGE_TRUE_VALUE);
-		    make_edge ( prev_bb, success_bb, EDGE_TRUE_VALUE);
-		    // FROM make_edge( success_bb, after_bb, EDGE_TRUE_VALUE);
-		    edge success_edge = make_edge ( success_bb, after_bb, EDGE_TRUE_VALUE);
-		    
-		    // code in success_bb
-		    //
-		    // FROM success_val is new SSA
-		    tree success_val = 
-		      make_temp_ssa_name( reorg_pointer_type, NULL, "success_val");
-		    // FROM gsi = gsi_start_bb( failure_bb)
-		    // Reuse the same gsi??? Or create a new one???
-		    //gimple_stmt_iterator gsi = gsi_start_bb ( failure_bb);
-		    gsi = gsi_start_bb ( failure_bb);
-		    // FROM gsi_insert_after( &gsi, "goto after_label")
-		    // Reuse goto_al
-		    //gimple *goto_al = gimple_build_goto( after_label_L);
-		    goto_al = gimple_build_goto( after_label_L);
-		    gsi_insert_after( &gsi, goto_al, GSI_SAME_STMT);
-		    // FROM gsi_insert_after( &gsi, "success_val = 0")
-		    gimple *set_succ =
-		      gimple_build_assign ( success_val,
-					    build_int_cst ( reorg_pointer_type, 0));
-		    gsi_insert_after( &gsi, set_succ, GSI_SAME_STMT);
-		    // FROM gsi_insert_after( &gsi, new_ok_field )
-		    gimple *gnew_ok_field = gimple_build_label ( new_ok_field_L);
-		    gsi_insert_after ( &gsi, gnew_ok_field, GSI_SAME_STMT);
-		    
-		    // add code to after_bb
-		    //
-		    // FROM gsi = gsi_start_bb( after_bb)
-		    // Reuse gsi
-		    //gimple_stmt_iterator gsi = gsi_start_bb( after_bb);
-		    gsi = gsi_start_bb( after_bb);
-		    // FROM gsi_insert_after( &gsi, "lhs = "phi(success_val, fail_val)
-		    gphi *der_phi = create_phi_node( lhs, after_bb);
-		    add_phi_arg( der_phi, success_val, success_edge, UNKNOWN_LOCATION);
-		    add_phi_arg( der_phi, fail_val, failure_edge, UNKNOWN_LOCATION);
-		    
-		    // FROM gsi_insert_after( &gsi, after_label)
-		    gimple gafter_label = gimple_build_label( after_L);
-		    gsi_insert_after( &gsi, gafter_label, GSI_SAME_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);
+		    }
+                    #endif
 		    INDENT(-2);
 		    break;
 		  case ReorgT_Calloc:
diff --git a/gcc/ipa-structure-reorg.c b/gcc/ipa-structure-reorg.c
index 68865afbb19..50a52f75c49 100644
--- a/gcc/ipa-structure-reorg.c
+++ b/gcc/ipa-structure-reorg.c
@@ -132,13 +132,14 @@ ipa_structure_reorg ( void)
   bool qualified = reorg_qualification(&info);
   if ( qualified )
   {
-#if USE_NEW_INTERFACE
     if ( flag_ipa_structure_reorg || flag_ipa_dead_field_eliminate )
       {
         log("before str_reorg_dead_field_eliminate_qual \n");
         str_reorg_dead_field_eliminate_qual ( &info);
 	// Because I just want to do this now...
+	#if KLUDGE
 	return true;
+	#endif
       }
     if ( flag_ipa_structure_reorg || flag_ipa_field_reorder )
       {
@@ -146,6 +147,7 @@ ipa_structure_reorg ( void)
       }
     if ( flag_ipa_structure_reorg || flag_ipa_instance_interleave )
       {
+	//DEBUG_L("before str_reorg_instance_interleave_qual\n");
 	str_reorg_instance_interleave_qual ( &info);
       }
 
@@ -169,24 +171,6 @@ ipa_structure_reorg ( void)
       {
         str_reorg_instance_interleave_trans ( &info);
       }
-    #else
-    // Each of these do their own performance qualification and
-    // if they delete any types they must invoke restore_deleted_types
-    // so the next subpass has all the types to consider.
-    // Also, if they change the shape of a type the must create my
-    // type and update the ReorgTypes to reflect this.
-    
-    log("We are using the old interface...\n");
-    if ( flag_ipa_structure_reorg || flag_ipa_dead_field_eliminate ) {
-      str_reorg_dead_field_eliminate ( &info);
-    }
-    if ( flag_ipa_structure_reorg || flag_ipa_field_reorder ) {
-      str_reorg_field_reorder ( &info);
-    }
-    if ( flag_ipa_structure_reorg || flag_ipa_instance_interleave ) {
-      str_reorg_instance_interleave ( &info);
-    }
-    #endif
   }
 
   final_debug_info ( &info);
@@ -244,6 +228,8 @@ reorg_analysis ( Info *info)
   // It is only triggered when flag_ipa_structure_reorg is 
   // specified since I am not sure what this function should
   // concretely do.
+  // Eric this is not really helping me... ;-)
+  #if INTEGRATION_FUNCTIONAL
   const bool run_escape_analysis = flag_ipa_dead_field_eliminate && !flag_ipa_instance_interleave && !flag_ipa_field_reorder;
   if (run_escape_analysis)
   {
@@ -256,6 +242,7 @@ reorg_analysis ( Info *info)
     info->sets.print_in_points_to_record();
     return true;
   }
+  #endif
   struct cgraph_node *node;
 
   find_decls_and_types ( info);
@@ -273,6 +260,7 @@ reorg_analysis ( Info *info)
     // This is a work around
     if ( func == NULL )
     {
+      //DEBUG_L("tripped work around\n");
       continue;
     }	
 
@@ -323,7 +311,7 @@ reorg_analysis ( Info *info)
 	    }
 	  }
 	}
-	INDENT(-2);
+	//INDENT(-2);
       }
     }
   }
@@ -393,7 +381,7 @@ static bool find_decls_and_types ( Info *info)
     //DEBUG_F( print_generic_decl, stderr, decl, (dump_flags_t)-1);
     tree base = base_type_of ( decl);
     //DEBUG( "\n");
-    //DEBUG_A(Base\n");
+    //DEBUG_A("Base\n");
     //DEBUG_A( "TREE_CODE = %s, ", code_str( TREE_CODE ( base)));
     //DEBUG_F( print_generic_expr, stderr, base, (dump_flags_t)-1);
     //DEBUG( "\n");
@@ -875,9 +863,7 @@ reorg_legality( Info *info)  {
 bool
 Info::is_non_escaping_set_empty()
 {
-  log("before non escaping empty...\n");
   bool retval = this->sets.non_escaping.empty();
-  log("after non escaping empty...%s \n", retval ? "t" : "f");
   return retval;
 }
 
@@ -890,12 +876,22 @@ transformation_legality ( Info *info)
 {
   //TODO: Gary, for my purposes, I need to start running the
   // code related to dead field eliminate. So, I'll add this bit
+  //
+  // TODO:
+  // * Legality must include type-casting
+  // * Legality must include address ??
+  // * What about memmove?
+  //
+  // struct astruct_s { _Bool a; _Bool b; _Bool c; };
+  // struct astruct_s astruct_1;
+  // struct astruct_s astruct_2;
+  // 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;
   if (run_escape_analysis)
   {
-    log("before empty...\n");
     bool retval = !info->is_non_escaping_set_empty();
-    log("after empty...\n");
     return retval;
   }
 
@@ -1036,28 +1032,28 @@ undelete_reorgtype ( ReorgType_t *rt, Info *info )
 ReorgTransformation
 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);
+  //DEBUG_L ( "ReorgTransformation reorg_recognize for: ");
+  //DEBUG_F ( print_gimple_stmt, stderr, stmt, 0);
+  //INDENT(2);
   switch (  gimple_code( stmt) )
   {
   case  GIMPLE_ASSIGN:
     {
-      DEBUG_L("GIMPLE_ASSIGN:\n");
+      //DEBUG_L("GIMPLE_ASSIGN:\n");
       tree lhs = gimple_assign_lhs ( stmt);
       enum tree_code rhs_code = gimple_assign_rhs_code ( stmt);
       
       if ( gimple_assign_single_p ( stmt) )
       {
-	DEBUG_L("gimple_assign_single_p() = true\n");
-	INDENT(2);
+	//DEBUG_L("gimple_assign_single_p() = true\n");
+	//INDENT(2);
 	tree rhs = gimple_assign_rhs1 ( stmt);
 	enum ReorgOpTrans lhs_op = recognize_op ( lhs, info);
 	switch ( lhs_op )
 	{
 	case ReorgOpT_Pointer:     // "a"
-	  DEBUG_L("case ReorgOpT_Pointer\n");
-	  INDENT(-4);
+	  //DEBUG_L("case ReorgOpT_Pointer\n");
+	  //INDENT(-4);
 	  switch ( recognize_op ( rhs, info) )
 	  {
 	  case ReorgOpT_Scalar:
@@ -1075,8 +1071,8 @@ reorg_recognize ( gimple *stmt, cgraph_node* node, Info_t *info )
 	    return Not_Supported;
 	  }
 	case ReorgOpT_Struct:      // "s"
-	  DEBUG_L("case ReorgOpT_Struct\n");
-	  INDENT(-4);
+	  //DEBUG_L("case ReorgOpT_Struct\n");
+	  //INDENT(-4);
 	  switch ( recognize_op ( rhs, info) )
 	  {
 	  case ReorgOpT_Deref:     // "*a"
@@ -1086,8 +1082,8 @@ reorg_recognize ( gimple *stmt, cgraph_node* node, Info_t *info )
 	    return Not_Supported;
 	  }
 	case ReorgOpT_Deref:       // "*a"
-	  DEBUG_L("case ReorgOpT_Deref\n");
-	  INDENT(-4);
+	  //DEBUG_L("case ReorgOpT_Deref\n");
+	  //INDENT(-4);
 	  switch ( recognize_op ( rhs, info) )
 	  {
 	  case ReorgOpT_Deref:     // "*a"
@@ -1098,8 +1094,8 @@ reorg_recognize ( gimple *stmt, cgraph_node* node, Info_t *info )
 	    return Not_Supported;
 	  }
 	case ReorgOpT_Array:       // "x[i]"
-	  DEBUG_L("case ReorgOpT_Array\n");
-	  INDENT(-4);
+	  //DEBUG_L("case ReorgOpT_Array\n");
+	  //INDENT(-4);
 	  switch ( recognize_op ( rhs, info) )
 	  {
 	  case ReorgOpT_Struct:    // "s"
@@ -1111,8 +1107,8 @@ 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);
+	  //DEBUG_L("case ReorgOpT_%s\n", lhs_op == ReorgOpT_Temp ? "Temp" : "Scalar");
+	  //INDENT(-4);
 	  switch ( recognize_op( rhs, info) )
 	  {
 	  case ReorgOpT_Scalar:      // "z"
@@ -1140,19 +1136,19 @@ reorg_recognize ( gimple *stmt, cgraph_node* node, Info_t *info )
 	  // TBD Might a case for ReorgOpT_Temp
 	  // other places too
 	default:
-	  INDENT(-4);
+	  //INDENT(-4);
 	  return Not_Supported;
 	} // switch ( recognize_op ( lhs, info) )
       } else {
-	DEBUG_L("gimple_assign_single_p() = false\n");
-	INDENT(2);
+	//DEBUG_L("gimple_assign_single_p() = false\n");
+	//INDENT(2);
 	tree op1 = gimple_assign_rhs1 ( stmt);
 	tree op2 = gimple_assign_rhs2 ( stmt);
 
 	if ( gimple_assign_rhs3 ( stmt) != NULL )
 	{
-	  DEBUG_L("gimple_assign_rhs3 ( stmt) != NULL\n");
-	  INDENT(-4);
+	  //DEBUG_L("gimple_assign_rhs3 ( stmt) != NULL\n");
+	  //INDENT(-4);
 	  return Not_Supported;
 	}
 	
@@ -1162,8 +1158,8 @@ reorg_recognize ( gimple *stmt, cgraph_node* node, Info_t *info )
 	  (    (POINTER_TYPE_P ( TREE_TYPE( op1)) && integer_zerop ( op2))
 	    || (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);
+	//DEBUG_L("zero_case = %s\n", zero_case ? "true" : "false" );
+	//INDENT(-4);
 	switch ( rhs_code )
 	{
 	case POINTER_PLUS_EXPR:
@@ -1189,8 +1185,8 @@ reorg_recognize ( gimple *stmt, cgraph_node* node, Info_t *info )
     }
   case GIMPLE_COND:  // Similar to assign cases
     {
-      DEBUG_L("GIMPLE_COND:\n");
-      INDENT(-2);
+      //DEBUG_L("GIMPLE_COND:\n");
+      //INDENT(-2);
       //tree op1 = gimple_assign_rhs1 ( stmt);
       //tree op2 = gimple_assign_rhs2( stmt);
       tree op1 = gimple_cond_lhs ( stmt);
@@ -1221,12 +1217,12 @@ reorg_recognize ( gimple *stmt, cgraph_node* node, Info_t *info )
     }
   case  GIMPLE_CALL:
     {
-      DEBUG_L("GIMPLE_CALL:\n");
+      //DEBUG_L("GIMPLE_CALL:\n");
       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");
-      INDENT(-2);
+      //DEBUG_L("called function %s gimple_body\n",
+      //	    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;
       if ( gimple_call_builtin_p( stmt, BUILT_IN_REALLOC) ) return ReorgT_Realloc;
@@ -1246,15 +1242,15 @@ reorg_recognize ( gimple *stmt, cgraph_node* node, Info_t *info )
     }
     break;
   case GIMPLE_RETURN:
-    DEBUG_L("GIMPLE_RETURN:\n");
-    INDENT(-2);
+    //DEBUG_L("GIMPLE_RETURN:\n");
+    //INDENT(-2);
     return ReorgT_Return;
     break;
   default:
-    DEBUG_L ( "didn't support: ");
-    DEBUG_F ( print_gimple_stmt, stderr, stmt, 0);
-    DEBUG( "\n");
-    INDENT(-2);
+    //DEBUG_L ( "didn't support: ");
+    //DEBUG_F ( print_gimple_stmt, stderr, stmt, 0);
+    //DEBUG( "\n");
+    //INDENT(-2);
     return Not_Supported;
   }
 }
@@ -1361,9 +1357,9 @@ remove_deleted_types ( Info *info, ReorgFn reorg_fn)
 enum ReorgOpTrans
 recognize_op ( tree op,  Info *info)
 {
-  DEBUG_L("recognize_op: ");
-  DEBUG_F( print_generic_expr, stderr, op, TDF_DETAILS);
-  DEBUG("\n");
+  // DEBUG_L("recognize_op: ");
+  //DEBUG_F( print_generic_expr, stderr, op, TDF_DETAILS);
+  //DEBUG("\n");
   enum tree_code op_code = TREE_CODE ( op);
   if ( op_code == SSA_NAME )
     {
@@ -1371,23 +1367,23 @@ recognize_op ( tree op,  Info *info)
       // It caused an assertion failue because
       // it was incorrectly triggering the ReorgT_Ptr2Zero
       // case with a bogus RHS.
-      DEBUG_L("  returns: ReorgOpT_Temp\n");
+      //DEBUG_L("  returns: ReorgOpT_Temp\n");
       return ReorgOpT_Temp;
     }
   tree type = TREE_TYPE ( op);
   if ( POINTER_TYPE_P (type) )
   {
-    DEBUG_L("POINTER_TYPE_P (type) = true\n");
+    //DEBUG_L("POINTER_TYPE_P (type) = true\n");
     if ( is_reorg_type ( type, info) )
     {
-      DEBUG_L("  returns: ReorgOpT_Pointer\n");
+      //DEBUG_L("  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
       // point. I.e. ReorgT_ElemAssign.
-      DEBUG_L("  returns: ReorgOpT_Scalar\n");
+      //DEBUG_L("  returns: ReorgOpT_Scalar\n");
       return ReorgOpT_Scalar;
     }
   }
@@ -1395,90 +1391,90 @@ recognize_op ( tree op,  Info *info)
   {
     // The assumption here is that this
     // is a reorg type.
-    DEBUG_L("  returns: ReorgOpT_Struct\n");
+    //DEBUG_L("  returns: ReorgOpT_Struct\n");
     return ReorgOpT_Struct;
   }
   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_L("inner_op = ");
+  //DEBUG_F( print_generic_expr, stderr, inner_op, TDF_DETAILS);
+  //DEBUG(", TREE_CODE = %s\n", code_str( TREE_CODE(inner_op)));
   if ( op_code == ADDR_EXPR )
     {
-      DEBUG_L("op_code == ADDR_EXPR\n");
+      //DEBUG_L("op_code == ADDR_EXPR\n");
       if (    inner_op_code == ARRAY_REF
 	   && is_reorg_type ( inner_op, info)    )
 	{
-	  DEBUG_L("  returns: ReorgOpT_Address\n");
+	  //DEBUG_L("  returns: ReorgOpT_Address\n");
 	  return ReorgOpT_Address;
 	}
     }
   if ( op_code == COMPONENT_REF )
   {
-    DEBUG_L("op_code == COMPONENT_REF\n");
+    //DEBUG_L("op_code == COMPONENT_REF\n");
     if ( inner_op_code == INDIRECT_REF )
     {
-      DEBUG_L("TREE_CODE( inner_op) == INDIRECT_REF\n");
+      //DEBUG_L("TREE_CODE( inner_op) == INDIRECT_REF\n");
       if ( is_reorg_type ( base_type_of ( type), info) ) // inner_type???
       {
-	DEBUG_L("  returns: ReorgOpT_Indirect\n");
+	//DEBUG_L("  returns: ReorgOpT_Indirect\n");
 	return ReorgOpT_Indirect;
       }
       // Just normal field reference otherwise...
-      DEBUG_L("  returns: ReorgOpT_Scalar\n");
+      //DEBUG_L("  returns: ReorgOpT_Scalar\n");
       return ReorgOpT_Scalar;
     }
     if ( inner_op_code == MEM_REF ) {
-      DEBUG_L("TREE_CODE( inner_op) == MEM_REF\n");
+      //DEBUG_L("TREE_CODE( inner_op) == MEM_REF\n");
       if ( is_reorg_type ( base_type_of ( inner_type), info) )
       {
-	DEBUG_L("  returns: ReorgOpT_Indirect\n");
+	//DEBUG_L("  returns: ReorgOpT_Indirect\n");
 	return ReorgOpT_Indirect; // TBD 
       }
       // Just normal field reference otherwise...
-      DEBUG_L("  returns: ReorgOpT_Scalar\n");
+      //DEBUG_L("  returns: ReorgOpT_Scalar\n");
       return ReorgOpT_Scalar;
     }
-    DEBUG_L("TREE_CODE( inner_op) not INDIRECT_REF or MEM_REF\n");
+    //DEBUG_L("TREE_CODE( inner_op) not INDIRECT_REF or MEM_REF\n");
     // Note, doesn't this ignore ARRAY_REF of this?
     // I think it's OK at least until we start supporting
     // multi-pools.
     if ( is_reorg_type ( base_type_of ( inner_type), info) )
       {
-	DEBUG_L("  returns: ReorgOpT_AryDir\n");
+	//DEBUG_L("  returns: ReorgOpT_AryDir\n");
 	return ReorgOpT_AryDir;
       }
     // Just normal field reference otherwise...
-    DEBUG_L("  returns: ReorgOpT_Scalar\n");
+    //DEBUG_L("  returns: ReorgOpT_Scalar\n");
     return ReorgOpT_Scalar;
   }
   if ( op_code == ARRAY_REF )
   {
-    DEBUG_L("op_code == ARRAY_REF\n");
+    //DEBUG_L("op_code == ARRAY_REF\n");
     if ( is_reorg_type( base_type_of ( type), info) )
     {
-      DEBUG_L("  returns: ReorgOpT_Array\n");
+      //DEBUG_L("  returns: ReorgOpT_Array\n");
       return ReorgOpT_Array;
     }
-    DEBUG_L("  returns: ReorgOpT_Scalar\n");
+    //DEBUG_L("  returns: ReorgOpT_Scalar\n");
     return ReorgOpT_Scalar;
   }
   if( op_code == INDIRECT_REF )
   {
-    DEBUG_L("op_code == INDIRECT_REF\n");
+    //DEBUG_L("op_code == INDIRECT_REF\n");
     //  Do we want to chase the base type?
     // No, we care about (and transform) just
     // *r and not **...r (where r is a ReorgType.)
     if( is_reorg_type ( type, info) )
     {
-      DEBUG_L("  returns: ReorgOpT_Deref\n");
+      //DEBUG_L("  returns: ReorgOpT_Deref\n");
       return ReorgOpT_Deref;
     }
-    DEBUG_L("  returns: ReorgOpT_Scalar\n");
+    //DEBUG_L("  returns: ReorgOpT_Scalar\n");
     return ReorgOpT_Scalar;
   }
-  DEBUG_L("  returns: ReorgOpT_Scalar\n");
+  //DEBUG_L("  returns: ReorgOpT_Scalar\n");
   return ReorgOpT_Scalar;
 }
 
@@ -1575,7 +1571,7 @@ 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\n");
   
   // 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
@@ -1590,9 +1586,9 @@ get_reorgtype_info ( tree type, Info* info)
     // so this is just a place holder until I can get an answer
     // from the gcc community. Note, this is a big issue.
     // Remember, the same_type_p here is my own temporary hack.
-    DEBUG_L("");
-    DEBUG_F( print_generic_expr, stderr, type, TDF_DETAILS);
-    DEBUG("\n");
+    //DEBUG_L("");
+    //DEBUG_F( print_generic_expr, stderr, type, TDF_DETAILS);
+    //DEBUG("\n");
     if ( same_type_p ( ri->gcc_type, type) )
     {
       //DEBUG_A( "  returns %p\n", &(*ri));
@@ -1600,6 +1596,7 @@ get_reorgtype_info ( tree type, Info* info)
       return &(*ri);
     }
   }
+  //DEBUG_A( "  returns NULL\n");
   return NULL;
 }
 
diff --git a/gcc/ipa-structure-reorg.h b/gcc/ipa-structure-reorg.h
index 509597ca85f..04d96426cb5 100644
--- a/gcc/ipa-structure-reorg.h
+++ b/gcc/ipa-structure-reorg.h
@@ -19,7 +19,12 @@ You should have received a copy of the GNU General Public License
 along with GCC; see the file COPYING3.  If not see
 <http://www.gnu.org/licenses/>.  */
 
+// This is depercated
 #define USE_NEW_INTERFACE 1
+// This is when our stuff is integrated
+#define INTEGRATION_FUNCTIONAL 0
+// Erick this is when you do something that really steps on some toes
+#define KLUDGE 1
 
 typedef struct RT_Elim       RT_Elim;
 typedef struct RT_Reorder    RT_Reorder;