diff options
-rw-r--r-- | gcc/ipa-str-reorg-instance-interleave.c | 459 | ||||
-rw-r--r-- | gcc/ipa-structure-reorg.c | 185 | ||||
-rw-r--r-- | gcc/ipa-structure-reorg.h | 5 |
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; |