This is the mail archive of the
gcc@gcc.gnu.org
mailing list for the GCC project.
[tree-ssa] Disastrous simplification of large switch stmt
- From: Steven Bosscher <s dot bosscher at student dot tudelft dot nl>
- To: dnovillo at redhat dot com
- Cc: gcc at gcc dot gnu dot org
- Date: 23 Sep 2002 11:10:21 +0200
- Subject: [tree-ssa] Disastrous simplification of large switch stmt
Hello,
Here's a "simplified" version of tree.c:make_node(). It's a piece of
tree.c.t11.optimized (CCP enabled).
Look at the incredibly large number of temporaries we need to simpify
this function. If you compare his with the original make_node(), you can
see something needs to be fixed here.
(Perhaps we should put each case in the switch statement in a separate
binding level before simplifying...)
Greetz
Steven
make_node()
{
union tree_node * t;
int type;
unsigned int code.167;
const char * T.166;
const char[10] * T.165;
const char * T.164;
const char[21] * T.163;
char T.162;
int T.161;
union tree_node * retval.160;
void (*<unnamed pfn>) (union tree_node *) T.159;
const char * T.158;
const char[10] * T.157;
const char * T.156;
const char[21] * T.155;
char T.154;
int T.153;
union tree_node * retval.152;
const char * T.151;
const char[10] * T.150;
const char * T.149;
const char[21] * T.148;
char T.147;
int T.146;
union tree_node * retval.145;
const char * T.144;
const char[10] * T.143;
const char * T.142;
const char[21] * T.141;
char T.140;
int T.139;
union tree_node * retval.138;
const char * T.137;
const char[10] * T.136;
const char * T.135;
const char[21] * T.134;
char T.133;
int T.132;
union tree_node * retval.131;
union tree_node * T.130;
unsigned int iftmp.129;
const char * T.128;
const char[10] * T.127;
const char * T.126;
const char[21] * T.125;
char T.124;
int T.123;
union tree_node * retval.122;
const char * T.121;
const char[10] * T.120;
const char * T.119;
const char[21] * T.118;
char T.117;
int T.116;
union tree_node * retval.115;
const char * T.114;
const char[10] * T.113;
const char * T.112;
const char[21] * T.111;
char T.110;
int T.109;
union tree_node * retval.108;
const char * T.107;
const char[10] * T.106;
const char * T.105;
const char[21] * T.104;
char T.103;
int T.102;
union tree_node * retval.101;
const char * T.100;
const char[11] * T.99;
const char * iftmp.98;
const char * T.97;
const char[10] * T.96;
const char * T.95;
const char[21] * T.94;
char T.93;
int T.92;
union tree_node * retval.91;
const char * T.90;
const char[10] * T.89;
const char * T.88;
const char[21] * T.87;
char T.86;
int T.85;
union tree_node * retval.84;
const char * T.83;
const char[10] * T.82;
const char * T.81;
const char[21] * T.80;
char T.79;
int T.78;
union tree_node * retval.77;
const char * T.76;
const char[10] * T.75;
const char * T.74;
const char[21] * T.73;
char T.72;
int T.71;
union tree_node * retval.70;
const char * T.69;
const char[10] * T.68;
const char * T.67;
const char[21] * T.66;
char T.65;
int T.64;
union tree_node * retval.63;
unsigned int code.62;
void * t.61;
void * T.60;
union tree_node * ttmp.59;
struct tree_common * ttmp.58;
union tree_node * ttmp.57;
struct tree_common * ttmp.56;
const char * T.55;
const char[10] * T.54;
const char * T.53;
const char[21] * T.52;
unsigned int code.51;
int code.50;
code.50 = (int)code;
type = (int)tree_code_type[code.50];
size_t length;
struct tree_common ttmp;
code.51 = (unsigned int)code;
if (code.51 == 3)
{
T.52 = "../../gcc/gcc/tree.c";
T.53 = (const char *)T.52;
T.54 = "make_node";
T.55 = (const char *)T.54;
fancy_abort (T.53, 232, T.55);
}
ttmp.56 = &ttmp;
ttmp.57 = (union tree_node *)ttmp.56
ttmp.57->common.code = (unsigned char)code;
(tree_code)ttmp.57->common.code;
ttmp.58 = &ttmp;
ttmp.59 = (union tree_node *)ttmp.58;
length = tree_size (ttmp.59);
T.60 = ggc_alloc (length);
t = (union tree_node *)T.60;
t.61 = (void *)t;
memset (t.61, 0, length);
t->common.code = (unsigned char)code;
(tree_code)t->common.code;
switch (type)
{
case 115:
t->common.side_effects_flag = 1;
t->common.type = global_trees[27];
break;
case 100:
code.62 = (unsigned int)code;
if (code.62 != 30)
{
{
union tree_node * const __t;
__t = t;
T.64 = (int)__t->common.code;
T.65 = tree_code_type[T.64];
if (T.65 != 100)
{
T.66 = "../../gcc/gcc/tree.c";
T.67 = (const char *)T.66;
T.68 = "make_node";
T.69 = (const char *)T.68;
tree_class_check_failed (__t, 100, T.67, 303, T.69);
}
retval.63 = __t;
}
retval.63->decl.u1.a.align = 1;
retval.63->decl.u1.a.align;
}
{
union tree_node * const __t;
__t = t;
T.71 = (int)__t->common.code;
T.72 = tree_code_type[T.71];
if (T.72 != 100)
{
T.73 = "../../gcc/gcc/tree.c";
T.74 = (const char *)T.73;
T.75 = "make_node";
T.76 = (const char *)T.75;
tree_class_check_failed (__t, 100, T.74, 304, T.76);
}
retval.70 = __t;
}
retval.70->decl.user_align = 0;
retval.70->decl.user_align;
{
union tree_node * const __t;
__t = t;
T.78 = (int)__t->common.code;
T.79 = tree_code_type[T.78];
if (T.79 != 100)
{
T.80 = "../../gcc/gcc/tree.c";
T.81 = (const char *)T.80;
T.82 = "make_node";
T.83 = (const char *)T.82;
tree_class_check_failed (__t, 100, T.81, 305, T.83);
}
retval.77 = __t;
}
retval.77->decl.in_system_header_flag = (unsigned int)in_system_header;
retval.77->decl.in_system_header_flag;
{
union tree_node * const __t;
__t = t;
T.85 = (int)__t->common.code;
T.86 = tree_code_type[T.85];
if (T.86 != 100)
{
T.87 = "../../gcc/gcc/tree.c";
T.88 = (const char *)T.87;
T.89 = "make_node";
T.90 = (const char *)T.89;
tree_class_check_failed (__t, 100, T.88, 306, T.90);
}
retval.84 = __t;
}
retval.84->decl.locus.line = lineno;
retval.84->decl.locus.line;
{
union tree_node * const __t;
__t = t;
T.92 = (int)__t->common.code;
T.93 = tree_code_type[T.92];
if (T.93 != 100)
{
T.94 = "../../gcc/gcc/tree.c";
T.95 = (const char *)T.94;
T.96 = "make_node";
T.97 = (const char *)T.96;
tree_class_check_failed (__t, 100, T.95, 307, T.97);
}
retval.91 = __t;
}
if (input_filename != 0B)
{
iftmp.98 = (const char * const)input_filename;
}
else
{
T.99 = "<built-in>";
T.100 = (const char *)T.99;
iftmp.98 = (const char * const)T.100;
}
retval.91->decl.locus.file = iftmp.98;
retval.91->decl.locus.file;
{
union tree_node * const __t;
__t = t;
T.102 = (int)__t->common.code;
T.103 = tree_code_type[T.102];
if (T.103 != 100)
{
T.104 = "../../gcc/gcc/tree.c";
T.105 = (const char *)T.104;
T.106 = "make_node";
T.107 = (const char *)T.106;
tree_class_check_failed (__t, 100, T.105, 309, T.107);
}
retval.101 = __t;
}
retval.101->decl.uid = (unsigned int)next_decl_uid;
retval.101->decl.uid;
next_decl_uid = next_decl_uid + 1;
{
union tree_node * const __t;
__t = t;
T.109 = (int)__t->common.code;
T.110 = tree_code_type[T.109];
if (T.110 != 100)
{
T.111 = "../../gcc/gcc/tree.c";
T.112 = (const char *)T.111;
T.113 = "make_node";
T.114 = (const char *)T.113;
tree_class_check_failed (__t, 100, T.112, 312, T.114);
}
retval.108 = __t;
}
retval.108->decl.pointer_alias_set = -1;
retval.108->decl.pointer_alias_set;
break;
case 116:
{
union tree_node * const __t;
__t = t;
T.116 = (int)__t->common.code;
T.117 = tree_code_type[T.116];
if (T.117 != 116)
{
T.118 = "../../gcc/gcc/tree.c";
T.119 = (const char *)T.118;
T.120 = "make_node";
T.121 = (const char *)T.120;
tree_class_check_failed (__t, 116, T.119, 316, T.121);
}
retval.115 = __t;
}
retval.115->type.uid = (unsigned int)next_type_uid;
retval.115->type.uid;
next_type_uid = next_type_uid + 1;
{
union tree_node * const __t;
__t = t;
T.123 = (int)__t->common.code;
T.124 = tree_code_type[T.123];
if (T.124 != 116)
{
T.125 = "../../gcc/gcc/tree.c";
T.126 = (const char *)T.125;
T.127 = "make_node";
T.128 = (const char *)T.127;
tree_class_check_failed (__t, 116, T.126, 317, T.128);
}
retval.122 = __t;
}
T.130 = integer_types[0];
if (T.130 != 0B)
{
{
union tree_node * const __t;
__t = integer_types[0];
T.132 = (int)__t->common.code;
T.133 = tree_code_type[T.132];
if (T.133 != 116)
{
T.134 = "../../gcc/gcc/tree.c";
T.135 = (const char *)T.134;
T.136 = "make_node";
T.137 = (const char *)T.136;
tree_class_check_failed (__t, 116, T.135, 317, T.137);
}
retval.131 = __t;
}
iftmp.129 = retval.131->type.align;
}
else
{
iftmp.129 = 0;
}
retval.122->type.align = iftmp.129;
retval.122->type.align;
{
union tree_node * const __t;
__t = t;
T.139 = (int)__t->common.code;
T.140 = tree_code_type[T.139];
if (T.140 != 116)
{
T.141 = "../../gcc/gcc/tree.c";
T.142 = (const char *)T.141;
T.143 = "make_node";
T.144 = (const char *)T.143;
tree_class_check_failed (__t, 116, T.142, 318, T.144);
}
retval.138 = __t;
}
retval.138->type.user_align = 0;
retval.138->type.user_align;
{
union tree_node * const __t;
__t = t;
T.146 = (int)__t->common.code;
T.147 = tree_code_type[T.146];
if (T.147 != 116)
{
T.148 = "../../gcc/gcc/tree.c";
T.149 = (const char *)T.148;
T.150 = "make_node";
T.151 = (const char *)T.150;
tree_class_check_failed (__t, 116, T.149, 319, T.151);
}
retval.145 = __t;
}
retval.145->type.main_variant = t;
retval.145->type.main_variant;
{
union tree_node * const __t;
__t = t;
T.153 = (int)__t->common.code;
T.154 = tree_code_type[T.153];
if (T.154 != 116)
{
T.155 = "../../gcc/gcc/tree.c";
T.156 = (const char *)T.155;
T.157 = "make_node";
T.158 = (const char *)T.157;
tree_class_check_failed (__t, 116, T.156, 322, T.158);
}
retval.152 = __t;
}
retval.152->type.attributes = 0B;
retval.152->type.attributes;
T.159 = targetm.set_default_type_attributes;
T.159 (t);
{
union tree_node * const __t;
__t = t;
T.161 = (int)__t->common.code;
T.162 = tree_code_type[T.161];
if (T.162 != 116)
{
T.163 = "../../gcc/gcc/tree.c";
T.164 = (const char *)T.163;
T.165 = "make_node";
T.166 = (const char *)T.165;
tree_class_check_failed (__t, 116, T.164, 326, T.166);
}
retval.160 = __t;
}
retval.160->type.alias_set = -1;
retval.160->type.alias_set;
break;
case 99:
t->common.constant_flag = 1;
break;
case 101:
code.167 = (unsigned int)code;
switch (code.167)
{
case 49:
case 48:
case 133:
case 120:
case 129:
case 130:
case 131:
case 132:
t->common.side_effects_flag = 1;
break;
default :
break;
}
break;
}
return t;
}