I have a tiny program composed of a few functions
and one of those functions (setupB) has gone missing.
Since I need to walk its GIMPLE, this is a problem.
The program:
-- aux.h -----------------------------------------
#include "stdlib.h"
typedef struct A A_t;
typedef struct A B_t;
struct A {
int i;
double x;
};
#define MAX(x,y) ((x)>(y) ? (x) : (y))
extern int max1( A_t *, size_t);
extern double max2( B_t *, size_t);
extern A_t *setupA( size_t);
extern B_t *setupB( size_t);
-- aux.c ----------------------------------------
#include "aux.h"
#include "stdlib.h"
A_t *
setupA( size_t size)
{
A_t *data = (A_t *)malloc( size * sizeof(A_t));
size_t i;
for( i = 0; i < size; i++ ) {
data[i].i = rand();
data[i].x = drand48();
}
return data;
}
B_t *
setupB( size_t size)
{
B_t *data = (B_t *)malloc( size * sizeof(B_t));
size_t i;
for( i = 0; i < size; i++ ) {
data[i].i = rand();
data[i].x = drand48();
}
return data;
}
int
max1( A_t *array, size_t len)
{
size_t i;
int result = array[0].i;
for( i = 1; i < len; i++ ) {
result = MAX( array[i].i, result);
}
return result;
}
double
max2( B_t *array, size_t len)
{
size_t i;
double result = array[0].x;
for( i = 1; i < len; i++ ) {
result = MAX( array[i].x, result);
}
return result;
}
-- main.c -------------------------------------
#include "stdio.h"
A_t *data1;
int
main(void)
{
B_t *data2 = setupB(200);
data1 = setupA(100);
printf("First %d\n" , max1(data1,100));
printf("Second %e\n", max2(data2,200));
}
------------------------------------------------
Here is its GIMPLE dump:
(for the sole purpose of letting you see
with your own eyes that setupB is indeed missing)
------------------------------------------------
Program:
static struct A_t * data1;
struct A_t * <T623> (size_t)
;; Function setupA (setupA, funcdef_no=4, decl_uid=4398, cgraph_uid=6,
symbol_order=48) (executed once)
setupA (size_t size)
{
size_t i;
struct A_t * data;
<bb 2> [local count: 118111600]:
_1 = size_8(D) * 16;
data_11 = malloc (_1);
goto <bb 4>; [100.00%]
<bb 3> [local count: 955630225]:
_2 = i_6 * 16;
_3 = data_11 + _2;
_4 = rand ();
_3->i = _4;
_5 = drand48 ();
_3->x = _5;
i_16 = i_6 + 1;
<bb 4> [local count: 1073741824]:
# i_6 = PHI <0(2), i_16(3)>
if (i_6 < size_8(D))
goto <bb 3>; [89.00%]
else
goto <bb 5>; [11.00%]
<bb 5> [local count: 118111600]:
return data_11;
}
int <T622> (struct A_t *)
;; Function max1.constprop (max1.constprop.0, funcdef_no=1, decl_uid=4397,
cgraph_uid=5, symbol_order=58) (executed once)
max1.constprop (struct A_t * array)
{
size_t i;
int result;
size_t len;
<bb 6> [local count: 118111600]:
<bb 2> [local count: 118111600]:
result_2 = array_1(D)->i;
goto <bb 4>; [100.00%]
<bb 3> [local count: 955630225]:
_4 = i_3 * 16;
_5 = array_1(D) + _4;
_6 = _5->i;
result_8 = MAX_EXPR <_6, result_7>;
i_9 = i_3 + 1;
<bb 4> [local count: 1073741824]:
# i_3 = PHI <1(2), i_9(3)>
# result_7 = PHI <result_2(2), result_8(3)>
if (i_3 <= 99)
goto <bb 3>; [89.00%]
else
goto <bb 5>; [11.00%]
<bb 5> [local count: 118111600]:
# result_10 = PHI <result_7(4)>
return result_10;
}
double <T61e> (struct B_t *)
;; Function max2.constprop (max2.constprop.0, funcdef_no=3, decl_uid=4395,
cgraph_uid=3, symbol_order=59) (executed once)
max2.constprop (struct B_t * array)
{
size_t i;
double result;
size_t len;
<bb 8> [local count: 118111600]:
<bb 2> [local count: 118111600]:
result_2 = array_1(D)->x;
goto <bb 6>; [100.00%]
<bb 3> [local count: 955630225]:
_4 = i_3 * 16;
_5 = array_1(D) + _4;
_6 = _5->x;
if (_6 > result_7)
goto <bb 4>; [50.00%]
else
goto <bb 5>; [50.00%]
<bb 4> [local count: 477815112]:
<bb 5> [local count: 955630225]:
# _10 = PHI <result_7(3), _6(4)>
i_8 = i_3 + 1;
<bb 6> [local count: 1073741824]:
# i_3 = PHI <1(2), i_8(5)>
# result_7 = PHI <result_2(2), _10(5)>
if (i_3 <= 199)
goto <bb 3>; [89.00%]
else
goto <bb 7>; [11.00%]
<bb 7> [local count: 118111600]:
# result_9 = PHI <result_7(6)>
return result_9;
}
int <T619> (void)
;; Function main (main, funcdef_no=5, decl_uid=4392, cgraph_uid=1,
symbol_order=25) (executed once)
main ()
{
struct B_t * data2;
<bb 2> [local count: 1073741824]:
data2_6 = setupB (200);
_1 = setupA (100);
data1 = _1;
_2 = max1 (_1, 100);
printf ("First %d\n", _2);
_3 = max2 (data2_6, 200);
printf ("Second %e\n", _3);
return 0;
}
------------------------------------------------
The pass is invoked at this location in passes.def
/* Simple IPA passes executed after the regular passes. In WHOPR mode the
passes are executed after partitioning and thus see just parts of the
compiled unit. */
INSERT_PASSES_AFTER (all_late_ipa_passes)
NEXT_PASS (pass_materialize_all_clones);
NEXT_PASS (pass_ipa_type_escape_analysis);
NEXT_PASS (pass_ipa_structure_reorg); <========== my pass!
NEXT_PASS (pass_ipa_prototype);
NEXT_PASS (pass_ipa_pta);
NEXT_PASS (pass_omp_simd_clone);
TERMINATE_PASS_LIST (all_late_ipa_passes)
--------------------------------------------------------------------------
The program was compiled with these options:
export OPTIONS='-O2 -fdump-passes -flto -flto-partition=one
-fipa-instance-interleave -fdump-ipa-all-details -save-temps -v'
By the way, changing -flto-partition=one to -flto-partition=none
makes no difference.
---------------------------------------------------------------------------
Here is how the dump was done:
void
print_program ( FILE *file, bool my_format, int leading_space, Info_t *info)
{
struct cgraph_node *node;
fprintf ( file, "%*sProgram:\n", leading_space, "");
// Print Global Decls
//
varpool_node *var;
FOR_EACH_VARIABLE ( var)
{
tree decl = var->decl;
fprintf ( file, "%*s", leading_space, "");
flexible_print ( file, decl, 1, (dump_flags_t)0);
}
FOR_EACH_FUNCTION_WITH_GIMPLE_BODY ( node)
{
struct function *func = DECL_STRUCT_FUNCTION ( node->decl);
flexible_print ( file, TREE_TYPE( func->decl), 1, (dump_flags_t)0);
dump_function_header ( file, func->decl, (dump_flags_t)0);
dump_function_to_file ( func->decl, file, (dump_flags_t)0);
}
}
Note, flexible_print is a wrapper that calls either print_generic_decl
or print_generic_expr depending on whether or not it's a decl. The "1"
just causes a "\n" to be emmited...
I also should mention I spin through the following loop at the
start of my pass to make sure the functions are sane:
cgraph_node* node;
FOR_EACH_FUNCTION_WITH_GIMPLE_BODY ( node)
node->get_untransformed_body ();
I don't think I left out any pertinent details.
Any suggestions (other than don't use lto this way)
are welcome.
Thanks,
Gary
CONFIDENTIALITY NOTICE: This e-mail message, including any attachments, is for
the sole use of the intended recipient(s) and contains information that is
confidential and proprietary to Ampere Computing or its subsidiaries. It is to
be used solely for the purpose of furthering the parties' business
relationship. Any unauthorized review, copying, or distribution of this email
(or any attachments thereto) is strictly prohibited. If you are not the
intended recipient, please contact the sender immediately and permanently
delete the original and any copies of this email and any attachments thereto.
