Hi all, In this ICE on aarch64 combine ends up creating a V4SI vec_duplicate of a comparison: (eq:CC_NZ (reg:CC_NZ 66 cc) (const_int 0 [0]))
This triggers and assertion in simplify_const_unary_operation about the inner mode of the duplicate (SImode in this case) not being the same as the CC_NZ mode of the comparison. I suspect ICE'ing here is too harsh as this particular function supports returing 0 to indicate that no simplification is possible, which is what this patch does. With this patch the testcase compiles successfully and bootstrap and tests look ok on arm, aarch64, x86_64. Is this the right way of going around fixing this? I'm not sure if there's a clean way of teaching combine to not try creating these RTXes in the first place... Thanks, Kyrill 2016-01-07 Kyrylo Tkachov <kyrylo.tkac...@arm.com> PR rtl-optimization/69161 * simplify-rtx.c (simplify_const_unary_operation): Return zero rather than ICEing when vector inner mode and op mode don't match in a vec_duplicate. 2016-01-07 Kyrylo Tkachov <kyrylo.tkac...@arm.com> PR rtl-optimization/69161 * gcc.c-torture/compile/pr69161.c: New test.
diff --git a/gcc/simplify-rtx.c b/gcc/simplify-rtx.c index f918d2da4ff2b72ee30622a3f78212fa1f88982c..966d9472349a02ab72946e9784fbf8de31a45b2b 100644 --- a/gcc/simplify-rtx.c +++ b/gcc/simplify-rtx.c @@ -1628,13 +1628,15 @@ simplify_const_unary_operation (enum rtx_code code, machine_mode mode, { gcc_assert (VECTOR_MODE_P (mode)); if (GET_MODE (op) != VOIDmode) - { - if (!VECTOR_MODE_P (GET_MODE (op))) - gcc_assert (GET_MODE_INNER (mode) == GET_MODE (op)); - else - gcc_assert (GET_MODE_INNER (mode) == GET_MODE_INNER - (GET_MODE (op))); - } + { + /* Make sure we've got an appropriate inner mode. */ + if (!VECTOR_MODE_P (GET_MODE (op)) + && GET_MODE_INNER (mode) != GET_MODE (op)) + return 0; + else if (VECTOR_MODE_P (GET_MODE (op)) + && GET_MODE_INNER (mode) != GET_MODE_INNER (GET_MODE (op))) + return 0; + } if (CONST_SCALAR_INT_P (op) || CONST_DOUBLE_AS_FLOAT_P (op) || GET_CODE (op) == CONST_VECTOR) { diff --git a/gcc/testsuite/gcc.c-torture/compile/pr69161.c b/gcc/testsuite/gcc.c-torture/compile/pr69161.c new file mode 100644 index 0000000000000000000000000000000000000000..b64197550ce8c6c7e6c1c17fcb4b39fd2ce9d61a --- /dev/null +++ b/gcc/testsuite/gcc.c-torture/compile/pr69161.c @@ -0,0 +1,1199 @@ +/* { dg-options "-w" } */ + +typedef signed char int8_t; +typedef short int int16_t; +typedef int int32_t; +typedef long int int64_t; +typedef unsigned char uint8_t; +typedef unsigned short int uint16_t; +typedef unsigned int uint32_t; +typedef unsigned long int uint64_t; +static int8_t (safe_sub_func_int8_t_s_s) (int8_t si1, int8_t si2) {} +static uint8_t (safe_mul_func_uint8_t_u_u) (uint8_t ui1, uint8_t ui2) {} +static uint8_t (safe_rshift_func_uint8_t_u_u) (uint8_t left, + unsigned int right) +{ + return (((unsigned int)right) >= 32) ? ((left)) + : (left >> ((unsigned int)right)); +} +static uint16_t (safe_lshift_func_uint16_t_u_u) (uint16_t left, + unsigned int right) +{ + return ((((unsigned int)right) >= 32) + || (left > ((65535) >> ((unsigned int)right)))) + ? ((left)) + : (left << ((unsigned int)right)); +} +static uint32_t (safe_add_func_uint32_t_u_u) (uint32_t ui1, uint32_t ui2) {} +static int32_t g_10 = 0xCB61D225L; +static uint32_t g_49[5] + = { 0xC4438182L, 0xC4438182L, 0xC4438182L, 0xC4438182L, 0xC4438182L }; +static uint8_t g_53 = 0xEEL; +static int32_t g_61 = 0x8CA40452L; +static uint32_t g_79[1][1] = { { 0x464CD027L } }; +static int64_t g_126 = 0xFCBDC27B9F097201LL; +static int32_t *g_129 = &g_61; +static int32_t **g_128 = &g_129; +static int8_t g_195 = 0x61L; +static uint16_t g_223 = 3UL; +static uint32_t g_234 = 0UL; +static int8_t **g_242[8][7] = {}; +static uint16_t g_251 = 0x2CE0L; +static uint64_t g_254 = 0x02AD15776B272A17LL; +static int32_t g_276[3] = { 1L, 1L, 1L }; +static int16_t g_391[7] + = { (-9L), 0x61C0L, 0x61C0L, (-9L), 0x61C0L, 0x61C0L, (-9L) }; +static int16_t *volatile g_454 = &g_391[0]; +static uint8_t g_493 = 0x2BL; +static uint64_t *g_608[4] = { (void *)0, (void *)0, (void *)0, (void *)0 }; +static uint32_t *g_619 = &g_79[0][0]; +static uint8_t g_674 = 1UL; +static int16_t ***g_781 = (void *)0; +static int8_t g_817 = 9L; +static uint64_t g_1066[1] = { 0x29C9DEA68F9DE84CLL }; +static uint32_t **g_1088 = &g_619; +static uint32_t ***g_1087 = &g_1088; +static int32_t g_1148[3] = { 0x656211FCL, 0x656211FCL, 0x656211FCL }; +static int64_t **g_1224 = (void *)0; +static int8_t ***g_1240 = &g_242[6][5]; +static int8_t ****g_1239[2] = { &g_1240, &g_1240 }; +static int8_t *****g_1238 = &g_1239[1]; +static uint32_t g_1263[10] + = { 7UL, 4294967295UL, 7UL, 4294967295UL, 7UL, + 4294967295UL, 7UL, 4294967295UL, 7UL, 4294967295UL }; +static int64_t g_1320 = 0x2C4AE0D152A60C7BLL; +static int64_t g_1423 = 0L; +static uint32_t g_1433 = 0UL; +static uint32_t *const g_1432 = &g_1433; +static uint32_t *const *g_1431 = &g_1432; +static uint32_t g_1436[2][1] = { { 1UL }, { 1UL } }; +static uint32_t g_1437[4][1][6] + = { { { 0xF73687BCL, 4294967292UL, 0xF73687BCL, 4294967292UL, 0xF73687BCL, + 4294967292UL } }, + { { 0xF73687BCL, 4294967292UL, 0xF73687BCL, 4294967292UL, 0xF73687BCL, + 4294967292UL } } }; +static uint32_t g_1463 = 0xFE4D9542L; +static int16_t g_1495[2][6][9] = {}; +static uint32_t g_1615 = 4294967293UL; +static int16_t g_1649 = 0L; +static int32_t g_1679[9][7][4] + = { { { 1L, 1L, (-1L), (-1L) }, { 0x2E58FA5BL, 0L, 0xB7710DD2L, 0L } }, + { { 0xB7710DD2L, 0xB7710DD2L, 0xB1D78015L, (-1L) }, + { 1L, 0x1ABB78C6L, 9L, 0x2DF9F644L } } }; +static uint32_t g_1719 = 0x6D7D61E2L; +static uint32_t g_1720 = 0x81D54A64L; +static int32_t g_1757 = 9L; +static uint64_t g_1794 = 1UL; +static uint64_t g_1832 = 0xFC48378BB950899ALL; +static int8_t g_1944 = 0xF8L; +static int16_t g_2014[6][7] + = { { 0x51B1L, 1L, 0x51B1L, 1L, 0L, 9L, 7L }, + { 0x2F60L, 0L, 0x56ACL, 0x56ACL, 0L, 0x2F60L, 1L } }; +static uint16_t *g_2122 = (void *)0; +static int16_t *g_2184 = &g_1495[1][4][1]; +static int16_t **const g_2183 = &g_2184; +static int16_t **const *g_2182 = &g_2183; +static int32_t *g_2234 = &g_1679[3][2][2]; +static const uint8_t g_2254 = 247UL; +static uint32_t **const g_2265 = (void *)0; +static uint32_t **const *g_2264 = &g_2265; +static uint32_t **const **g_2263 = &g_2264; +static const volatile int64_t g_2444 = 5L; +static const volatile int64_t *g_2443 = &g_2444; +static const volatile int64_t *volatile *g_2442 = &g_2443; +static volatile uint16_t *volatile **g_2672 = (void *)0; +static int8_t g_2767 = 0x21L; +static uint16_t **g_2838 = &g_2122; +static uint16_t ***g_2837 = &g_2838; +static uint16_t ****g_2836[3] = { &g_2837, &g_2837, &g_2837 }; +static uint16_t ***g_2903 = &g_2838; +static uint16_t ****const g_2902 = &g_2903; +static uint16_t ****const *g_2901 = &g_2902; +static volatile int8_t g_3143 = 0x2BL; +static volatile int8_t *g_3142 = &g_3143; +static volatile int8_t *volatile *g_3141 = &g_3142; +static volatile int8_t *volatile *volatile *g_3140 = &g_3141; +static volatile int8_t *volatile *volatile *volatile *g_3139[3] + = { &g_3140, &g_3140, &g_3140 }; +static volatile int8_t *volatile *volatile *volatile **g_3138 = &g_3139[1]; +static int32_t g_3280 = 0x23FC0E27L; +static uint16_t g_3886 = 7UL; +static uint32_t ****g_3890[3][6] + = { { &g_1087, &g_1087, &g_1087, &g_1087, &g_1087, &g_1087 }, + { &g_1087, &g_1087, &g_1087, &g_1087, &g_1087, &g_1087 } }; +static const int32_t g_3902 = 0L; +static uint64_t g_3915[8][6][5] + = { { { 0x7ACC3F8F6BD91664LL, 9UL, 0x7CFDBF31909E5575LL, 1UL, + 18446744073709551615UL }, + { 0x7ACC3F8F6BD91664LL, 0x78074E9222E82CC6LL, 1UL, + 0x31291D9B7D7EE93FLL, 1UL } }, + { { 0x5624F34AA3D133DALL, 0x85F2FF7FDC702A67LL, 1UL, + 0x7CFDBF31909E5575LL, 0x78074E9222E82CC6LL }, + { 0x31291D9B7D7EE93FLL, 18446744073709551615UL, 0x5624F34AA3D133DALL, + 0x5624F34AA3D133DALL, 18446744073709551615UL } } }; +static const int32_t g_4027 = 0L; +static int64_t *const ***g_4122[10] + = { (void *)0, (void *)0, (void *)0, (void *)0, (void *)0, + (void *)0, (void *)0, (void *)0, (void *)0, (void *)0 }; +static int64_t *const ****g_4121 = &g_4122[3]; +static int32_t *const volatile g_4166[2] = { &g_10, &g_10 }; +static int32_t *volatile g_4168 = &g_1679[4][1][1]; +static int8_t g_4225 = 0xA6L; +static int32_t *g_4237[1] = { &g_1148[2] }; +static int32_t **g_4236 = &g_4237[0]; +static int32_t *func_40 (int16_t p_41); +static int8_t func_44 (uint32_t p_45, int32_t p_46, uint8_t *p_47); +static int64_t +func_1 (void) +{ + int32_t l_3[5] + = { 0xD16DF251L, 0xD16DF251L, 0xD16DF251L, 0xD16DF251L, 0xD16DF251L }; + uint32_t l_3865 = 1UL; + int32_t l_3866 = 8L; + int32_t l_3875 = 0x63202617L; + uint8_t l_3876 = 0x10L; + int32_t l_3877 = (-7L); + int32_t l_3885 = 5L; + uint16_t l_3911 = 65530UL; + int16_t l_3912 = 0x485CL; + int8_t l_3921 = (-2L); + const int32_t *l_4026 = &g_4027; + int8_t *l_4139 = &g_817; + int32_t *const *l_4239 = &g_4237[0]; + { + int32_t l_3867 = (-1L); + (*g_128) = func_40 ((safe_sub_func_int32_t_s_s ( + ((safe_mod_func_uint32_t_u_u ( + ((**g_1431) = (safe_mul_func_int16_t_s_s ( + l_3867))))) + > l_3867)))); + } + if ((safe_mod_func_int64_t_s_s ((safe_mul_func_uint16_t_u_u ( + (((l_3865, (((((((l_3877 = ((safe_mul_func_uint16_t_u_u (l_3875, 9L)) + & (0x2E19L > (l_3876 >= l_3865)))) + == (safe_rshift_func_uint16_t_u_s (14))), + l_3885) + >= 0x90578CE0L) + && g_3886) + >= 8UL) + <= l_3885)), + (*g_1432)), + 9UL), + (-2L)))))) + { + uint32_t ****l_3887 = &g_1087; + int32_t l_3893 = (-4L); + const int32_t *l_3901 = &g_3902; + const int32_t **l_3900 = &l_3901; + int16_t *l_3913 = &g_2014[1][5]; + int8_t l_3914 = 0x94L; + g_3915[3][5][0] + ^= ((&g_1087 != (g_3890[2][4] = l_3887)) + != (((safe_lshift_func_int8_t_s_s ( + (0xE739DC1BA8329DECLL + == ((((**g_2442) + > (((((l_3893 + ^ (safe_rshift_func_uint8_t_u_s ( + (safe_rshift_func_int8_t_s_s ( + (((safe_sub_func_int8_t_s_s ( + ((((*l_3900) = &g_1148[2]) + != ((safe_mul_func_int8_t_s_s ( + 7L)), + (void *)0)) + >= 0x73L), + l_3[0])) + <= 2L), + l_3911), + l_3912)), + 7))), + l_3913) + != (void *)0) + | l_3893), + l_3914)) + >= l_3912) + && (-7L))), + 0)) + >= l_3866) + ^ 18446744073709551615UL)); + } + { + int16_t *l_3920 = &g_1495[0][5][0]; + int32_t **l_3952 = &g_129; + uint64_t l_4097 = 18446744073709551615UL; + int32_t *l_4224 = &g_3280; + { + int32_t l_3935 = (-1L); + uint16_t l_3994 = 0xA45EL; + int64_t *const ****l_4124 = (void *)0; + const int16_t *l_4130 = &g_2014[5][6]; + const int16_t **l_4129 = &l_4130; + int32_t l_4240[5]; + if (((safe_lshift_func_uint16_t_u_u (65530UL, 6)) + <= (l_4097 + >= (((0xA542L + | ((0x62L + >= ((safe_lshift_func_uint16_t_u_u ( + 0x4D37L, ((((((**l_3952) + > ((void *)0 == &g_3890[2][4])) + & ((safe_add_func_uint16_t_u_u ( + (*l_4026))) + & (**l_3952))) + > (*l_4026)) + == 65535UL) + && 1UL))) + ^ 18446744073709551611UL)) + && l_3994)), + 0xB574L) + && (***g_2182))))) + { + const int32_t *const l_4114 = &g_61; + int32_t *l_4127 = &l_3935; + uint8_t l_4131 = 0xA4L; + uint64_t *l_4194 = &l_4097; + int64_t l_4226[5]; + int32_t ***l_4238 = &g_4236; + const uint32_t l_4241 = 1UL; + uint32_t l_4242[4]; + if ((0UL || ((((safe_div_func_uint32_t_u_u ( + (safe_add_func_uint64_t_u_u (( + (l_4124 = ((*l_4026), g_4121)) + != (((((((safe_div_func_int32_t_s_s (l_3994)), + l_4129) + == &l_3920) + & 0x182AF6800DD64893LL) + ^ (**l_3952)) + == 0xD8L), + (void *)0)))), + 5L)) + >= (**g_2183)) + || (*l_4026)) + ^ l_4131))) + { + int32_t *l_4136 = &g_276[2]; + int8_t *l_4187 = &g_817; + { + uint32_t l_4165 = 9UL; + (*g_4168) |= (safe_unary_minus_func_uint32_t_u ( + (safe_add_func_uint64_t_u_u (( + (safe_rshift_func_uint16_t_u_s ( + (safe_lshift_func_uint8_t_u_u ((**l_3952), 6)))) + >= (safe_mul_func_int8_t_s_s ( + (safe_add_func_uint64_t_u_u ( + ((l_3866 + = (((**l_3952) + < (((0UL + & (((**g_1431) || (*l_4114)) + | ((safe_mul_func_int16_t_s_s ( + ((safe_sub_func_int64_t_s_s ( + l_4165)) + < 0xD0L))) + > 0x5E4F62760AD05A68LL))) + > (*l_4136)) + < l_3935)), + 0x67AE938BL)), + 18446744073709551615UL), + 0x5D9C441B26F85A2CLL)), + 0x87L))))))); + } + { + uint16_t **l_4181 = &g_2122; + const uint64_t **l_4186 = (void *)0; + int8_t *l_4188[4]; + int32_t l_4195 = (-7L); + (*l_4127) ^= (safe_lshift_func_int8_t_s_s ( + ((4294967288UL && (((*g_2837) = (**g_2902)) == l_4181)), + (safe_rshift_func_int8_t_s_s ( + ((safe_mul_func_int8_t_s_s ( + (((&g_608[0] != l_4186), + (l_4188[1] = (l_4139 = l_4187))) + == ((((+((safe_mul_func_int16_t_s_s (0xFCE3L, + (*l_4026))) + | (safe_div_func_int64_t_s_s ( + 0x53599B7C60C6F012LL)))), + (*l_4136)) + != (**l_3952)), + &l_3921)), + (*****g_3138))) + == 0x8F39CB92L), + 2))), + l_4195)); + } + } + g_276[0] &= (safe_sub_func_int32_t_s_s ( + ((((~((safe_lshift_func_uint8_t_u_s ( + (((safe_mod_func_int32_t_s_s ( + (((safe_sub_func_int16_t_s_s ( + (((*l_4194) + = ((safe_rshift_func_int16_t_s_s ( + (((*l_4238) + = ((((l_4127 == l_4224) + | ((g_4225, &l_4131) + != (void *)0)) + < (l_4226[2] + <= (safe_mod_func_uint8_t_u_u ( + 250UL)))), + g_4236)) + != l_4239), + (**l_3952))) + < 0xBEA3L)), + (*g_454)), + 0x538EL)) + > 8UL) + < l_4240[4]), + (**l_3952))), + (*l_4127)) + | l_4241), + l_4242[2])) + || (*l_4114))) + != (*l_4114)) + <= 1L) + >= (*l_4026)), + (*l_4026))); + } + } + } +} +static int32_t * +func_40 (int16_t p_41) +{ + uint8_t *l_52 = &g_53; + int32_t l_2078 = 0x1ED30906L; + uint16_t l_2101 = 65530UL; + int64_t l_2106 = (-6L); + int16_t l_2126 = (-1L); + int32_t *l_2153 = &g_276[2]; + int8_t l_2176 = 0x6CL; + int32_t l_2209[6] = { 0L, (-1L), (-1L), 0L, (-1L), (-1L) }; + uint32_t l_2304 = 1UL; + int32_t ***const l_2427 = &g_128; + uint64_t **l_2453[6][10][4] + = { { { &g_608[0], &g_608[0], &g_608[0], &g_608[0] }, + { &g_608[3], (void *)0, &g_608[0], &g_608[0] } }, + { { &g_608[3], &g_608[0], (void *)0, &g_608[1] }, + { &g_608[0], &g_608[0], (void *)0, &g_608[0] } } }; + uint16_t **l_2724 = (void *)0; + uint16_t ***l_2723 = &l_2724; + int16_t ****l_2752[4] = { &g_781, &g_781, &g_781, &g_781 }; + const uint32_t l_2770 = 0x48C61770L; + uint16_t l_2970 = 0x3A8DL; + const uint16_t **l_2999[5][5][10] = {}; + if ((func_44 ((g_49[2]++), g_10, l_52), l_2078)) + if ((safe_div_func_int32_t_s_s ( + ((safe_rshift_func_int16_t_s_u ( + ((safe_mod_func_uint32_t_u_u ( + ((safe_sub_func_uint32_t_u_u ( + ((*g_619) &= (g_1615, p_41)), (0x38L != 0xFDL))) + && (safe_sub_func_int8_t_s_s ( + p_41, ((safe_div_func_int16_t_s_s ( + (safe_sub_func_int16_t_s_s ( + 3L, (((safe_sub_func_int16_t_s_s ( + 65533UL)) + == l_2078) + ^ l_2106))))) + <= 0x5BA845DBL)))), + p_41)) + & l_2106), + 9)), + p_41)))) + { + const uint32_t l_2147 = 18446744073709551615UL; + uint32_t l_2149 = 0xE873F636L; + uint32_t l_2196 = 0x0BF1E669L; + int32_t l_2200 = 0x6BB93CCAL; + int32_t l_2201[3]; + uint16_t *l_2259 = &l_2101; + { + int8_t *l_2255 = &g_817; + uint32_t **const **l_2260[7] + = { (void *)0, (void *)0, (void *)0, (void *)0, + (void *)0, (void *)0, (void *)0 }; + uint32_t ****l_2267 = &g_1087; + if ((l_2149 + ^ (+(((*l_2255) = (safe_add_func_int8_t_s_s ( + (l_2200 + = ((p_41 + < (((((safe_add_func_uint16_t_u_u (( + 0x5BL + >= (safe_rshift_func_int8_t_s_s ( + ((((safe_mul_func_int16_t_s_s (( + ((safe_sub_func_uint16_t_u_u ( + (safe_mul_func_uint8_t_u_u ( + (((((*l_2153) + = (+( + **g_1431))) + & p_41) + || (safe_div_func_int64_t_s_s ( + (*l_2153)))), + g_2254), + p_41)), + 0xFA76L)) + & 0x48F6AE03L) + != p_41))), + (void *)0) + != (void *)0), + p_41), + l_2147))))) + <= p_41) + ^ (*g_2234)) + & l_2176), + p_41)) + > p_41)), + l_2176))) + ^ 0xEBL)))) + { + uint32_t ****l_2266 = &g_1087; + int32_t l_2279 = 5L; + { + (*l_2153) |= (((g_2122 = &g_251) == l_2259) + < (l_2201[1] + ^= (((((((((g_2263 = l_2260[6]) + == (l_2267 = l_2266)), + (safe_mul_func_uint16_t_u_u ( + ((safe_rshift_func_int8_t_s_u ( + l_2279)), + (-7L))))) + && p_41) + < p_41), + 1L) + || 8UL) + < p_41) + ^ 0xB4L))); + } + } + } + { + l_2304 = (safe_sub_func_int16_t_s_s ( + (safe_rshift_func_int8_t_s_u ( + (l_2200 = (safe_mod_func_uint8_t_u_u ( + (safe_sub_func_int64_t_s_s ( + ((255UL + && (((safe_mul_func_uint8_t_u_u ( + (((+((safe_add_func_uint8_t_u_u (l_2196)) + || 0L)), + (*g_1432)), + 249UL), + 1L)), + 0x3130C64E29DA9801LL) + || 0x23BB9FAC3A7E1613LL)) + <= 0x2CA16ACCL))), + 0x12L))), + 6)), + (-10L))); + } + } + { + uint64_t l_2635 = 0x6332B884FED21FE6LL; + uint64_t ***l_2636 = &l_2453[0][5][1]; + int32_t l_2642 = (-6L); + int32_t l_2645 = 0L; + int32_t l_2647[3][10] + = { { (-5L), 1L, 0x9132284EL, 0x5BEECFCDL, 1L, 0x0F838D8AL, 0L, + 0x9132284EL, 0x9132284EL, 0L }, + { (-5L), 0L, 0xB3D9143CL, 0x5BEECFCDL, 0L, 0x08F81831L, 0L, + 0x5BEECFCDL, 0xB3D9143CL, 0L } }; + int64_t *l_2686 = &g_1320; + int64_t **l_2685[7][10][3] = { + }; + int32_t l_2765 = 0x11E3D50EL; + uint32_t l_2766 = 0xDC8DAE09L; + int64_t l_2768 = (-9L); + uint16_t l_2769 = 0xC7C8L; + uint32_t ****l_3104 = &g_1087; + int16_t ****l_3134 = &g_781; + if ((l_2635, + (((((-8L) && ((*g_1432) = (l_2636 == &l_2453[0][5][1]))) + <= ((((*g_2234) &= (safe_mod_func_uint64_t_u_u ( + (p_41 + && (l_2642 = (p_41 || (safe_rshift_func_uint8_t_u_u ( + (*l_2153), 7)))))))) + || ((p_41 ^ l_2642) == p_41)), + l_2635)) + & p_41) + || 0xB968F138L))) + { + uint64_t l_2684[3][2][6] = { + }; + int32_t l_2732 = (-10L); + int32_t l_2733 = (-1L); + int32_t l_2735 = 0L; + int32_t l_2737 = (-9L); + int32_t l_2740 = (-3L); + int32_t l_2741 = 0x99774314L; + int32_t l_2743 = 1L; + int32_t l_2744[3]; + int8_t *l_2771 = &g_1944; + uint16_t ****l_2833 = (void *)0; + uint16_t l_2860[4] = { 0x4CC0L, 0x4CC0L, 0x4CC0L, 0x4CC0L }; + uint32_t **l_2885 = &g_619; + int8_t ***l_2973 = &g_242[7][3]; + { + uint32_t l_2700 = 1UL; + uint16_t l_2702 = 2UL; + uint32_t ***l_2727 = (void *)0; + { + int32_t l_2699[8]; + { + uint16_t *l_2701 = &g_223; + l_2209[3] + = (((((**g_1088) + = ((safe_add_func_uint16_t_u_u ((safe_div_func_int32_t_s_s ( + (l_2684[1][1][4] + & ((l_2685[5][1][0] == (void *)0) + && ((safe_sub_func_uint8_t_u_u (( + g_1679[(g_1615 + 1)] + [(g_1615 + 1)] + [g_126] + = ((safe_rshift_func_uint16_t_u_s ( + (((*l_2153) + = ((((*l_2701) + = ((0x890E0FBEBB0D3A99LL + >= ((safe_rshift_func_int16_t_s_s ( + p_41)) + >= p_41)), + l_2700)) + != l_2700), + 3L)) + ^ p_41), + 12)), + p_41)))) + != p_41))), + l_2647[0][6])))) + == p_41)) + | 0x2561E494L), + l_2702) + == p_41); + } + { + uint16_t *l_2716 = &g_251; + uint16_t ****l_2725 = &l_2723; + (*l_2153) |= (safe_mul_func_int16_t_s_s ( + ((safe_sub_func_uint32_t_u_u ( + (((((--(*l_2716)) + < (((***g_1087) = g_1679[(g_126 + 3)][l_2126][g_126]), + p_41)) + || g_1495[1][4][1]) + <= l_2699[2]) + == ((safe_mod_func_int64_t_s_s ( + (safe_mul_func_uint8_t_u_u ( + (((*l_2725) = ((**g_2183), l_2723)) + != (((safe_unary_minus_func_int32_t_s ( + ((((void *)0 == l_2727) + == (((+0x0EA2F1D5L), p_41) + | (**g_1431))) + & 0x51C35683L))) + != g_1679[(g_126 + 3)][l_2126][g_126]), + g_2672)), + p_41)), + p_41)), + 65528UL)), + (-9L))) + > 1L), + g_391[5])); + } + } + } + if (((((void *)0 == &l_2642) > (g_251 ^= g_1066[0])) + > (((*l_2771) + ^= ((!((((**g_2183) < ((void *)0 != l_2752[3])), 0x8693L), + (safe_sub_func_int64_t_s_s ( + (safe_div_func_int8_t_s_s ( + (((**g_1088) |= 0x1D10C8E0L), + (safe_add_func_uint64_t_u_u ( + ((safe_rshift_func_uint16_t_u_s ( + (((+((g_2767 + ^= (((((((!(((safe_lshift_func_int8_t_s_s ( + 6)) + <= p_41) + && 8UL)) + || l_2766) + || (*l_2153)) + || (*l_2153)) + && p_41) + && p_41) + > p_41)) + > l_2768)) + < l_2642) + != p_41), + p_41)) + != (-7L)), + l_2769))), + p_41)), + l_2770)))) + != l_2766)) + < l_2737))) + { + int32_t *l_2804 = &l_2743; + if (((safe_lshift_func_uint16_t_u_u ( + ((l_2647[0][6], + (((safe_mul_func_uint8_t_u_u ( + ((safe_lshift_func_uint16_t_u_s (0xADAEL, 8)) + && l_2647[1][6]), + ((*l_2771) + = (p_41 + && (((safe_mul_func_uint16_t_u_u ( + ((**g_2183) = p_41))) + & (safe_rshift_func_int8_t_s_u (l_2645))) + & p_41))))), + (void *)0) + != (void *)0)) + & (-9L)), + 14)) + <= 1L)) + { + uint16_t l_2810 = 0UL; + int64_t **const *l_2830 = (void *)0; + int64_t **const **l_2829 = &l_2830; + { + int16_t l_2807 = 1L; + int64_t **const ***l_2831 = &l_2829; + int32_t l_2832 = 1L; + (*g_2234) + = (l_2807, + ((safe_mul_func_uint16_t_u_u (l_2810, (!p_41))) + || ((*l_2686) + = (+(((safe_div_func_uint16_t_u_u (l_2810, l_2807)) + == (((((((*g_2234) ^ (-9L)) + & (p_41 ^ (p_41 >= l_2769))) + & 1UL) + > (-1L)) + & 0L) + > l_2733)) + || p_41))))); + (*g_2234) = (safe_mul_func_int16_t_s_s ( + ((safe_mod_func_uint16_t_u_u ( + (((safe_mod_func_uint16_t_u_u ( + ((safe_div_func_int16_t_s_s ( + (((&g_2672 + == (g_2836[0] + = ((((*l_2804) + ^= (((*l_2831) = l_2829) + == (void *)0)) + < l_2832), + l_2833))) + != (--g_251)) + == ((safe_add_func_int64_t_s_s ( + ((safe_add_func_uint16_t_u_u ( + (--g_223), 65533UL)) + || p_41))) + || (-4L))), + p_41)) + >= 0xEA3C1582L), + p_41)) + <= p_41), + l_2744[0]), + 0x6DF8L)), + p_41), + 0x5BB2L)); + } + } + { + { + const int8_t *l_2945 = &g_817; + const int8_t **l_2944 = &l_2945; + const int8_t ***l_2943 = &l_2944; + uint16_t *l_2948 = (void *)0; + int32_t l_2959 = 1L; + (*l_2153) = (~(+(~(safe_sub_func_int32_t_s_s ( + (safe_sub_func_uint32_t_u_u ((safe_div_func_uint8_t_u_u ( + (l_2943 + != ((((((safe_add_func_uint64_t_u_u ( + (((void *)0 == l_2948), + ((*l_2804) + ^= ((safe_div_func_uint8_t_u_u (p_41)) + >= ((l_2970--) + == (((*l_52) + = (l_2959 + && ((0xFCL <= (*l_2153)) + && (***g_1087)))) + ^ 0UL))))), + p_41)) + | p_41) + >= 1UL), + (void *)0) + != &l_2885), + l_2973)), + p_41)))), + p_41))))); + } + } + } + { + const uint16_t ***l_3001 = &l_2999[1][1][0]; + { + int32_t l_2995[10][5] = { { (-1L), (-1L), (-1L), (-1L), (-1L) }, + { 0x8328F685L, 0x8328F685L, 0x8328F685L, + 0x8328F685L, 0x8328F685L } }; + l_2733 + &= ((g_1148[l_2970], + (((*l_52) = (g_234, 1UL)) + <= ((l_2769 + == (+(safe_rshift_func_int8_t_s_u ( + ((((safe_rshift_func_uint16_t_u_u (( + ((safe_lshift_func_int8_t_s_u (p_41, 4)) + | (0x332FBE74996D7677LL + <= (((safe_rshift_func_uint16_t_u_s ( + p_41, 9)) + != (l_2995[6][3] + = (safe_add_func_int64_t_s_s ( + p_41)))) + > (*l_2153)))) + <= p_41))) + & l_2744[2]) + > 0x68D4L) + ^ 0xF092L), + 2)))) + || p_41))) + <= p_41); + } + l_2647[0][6] + = ((*l_2153) = (safe_sub_func_uint8_t_u_u ( + (((((***g_2901) == ((*l_3001) = l_2999[0][4][5])) + && ((safe_mod_func_int8_t_s_s ( + ((*l_2771) + = ((((safe_mod_func_uint8_t_u_u ( + ((safe_lshift_func_uint8_t_u_s ( + (safe_rshift_func_uint16_t_u_u ( + ((l_2741 + = ((safe_unary_minus_func_uint64_t_u ( + (p_41 + != ((safe_sub_func_int32_t_s_s ( + (l_2743 + = (safe_add_func_uint64_t_u_u ( + p_41))))) + & p_41)))) + && 18446744073709551615UL)), + l_2735), + 9)), + l_2768)) + & (*g_1432)), + p_41)) + >= (***g_1087)), + l_2732) + ^ p_41)), + 255UL)), + 0x121ED21114C8BF3ALL)), + (void *)0) + == (void *)0), + p_41))); + { + uint32_t *l_3034 = &g_1436[0][0]; + { + uint16_t *l_3040 = &l_2101; + uint16_t *l_3041 = &l_2970; + (**l_2427) + = ((safe_add_func_int16_t_s_s ( + (safe_rshift_func_int16_t_s_s ( + (((*l_3041) + = ((*l_3040) + = (((safe_mul_func_uint8_t_u_u ( + (((safe_lshift_func_int16_t_s_u ( + (p_41 = p_41), 2)) + >= l_2744[1]) + == ((*g_1431) != l_3034)), + ((safe_div_func_int16_t_s_s ( + ((***g_2182) + ^= ((safe_mul_func_int8_t_s_s ( + (-1L), 0L)) + > l_2768)))) + && l_2735))) + <= l_2635) + <= l_2209[g_1649]))) + | 0L))), + (-6L))), + &g_276[2]); + } + } + } + { + int32_t *l_3065 = &l_2765; + { + const int32_t *l_3064 = &l_2647[0][4]; + { + (*g_2234) + ^= (0x21L + > ((((l_3104 != (void *)0) + >= (((**g_2183) + >= (255UL + ^ ((*l_2771) + = (((safe_sub_func_int8_t_s_s ( + ((safe_sub_func_int64_t_s_s (( + (((*l_2153) + &= (((safe_rshift_func_uint8_t_u_u ( + p_41, 2)) + < ((((safe_sub_func_int64_t_s_s ( + (-6L))) + > p_41) + ^ l_2740) + | 0x9D7CA23DL)) + >= p_41)) + ^ l_2645) + || (-10L)))), + l_2860[0]), + 0L)) + | (***l_2427)) + < (-2L))))) + | 0x29DA3E89L)) + <= 1L) + < 255UL)); + } + if (((l_2740, l_2752[3]) + != ((0xD846BCC1L + && (((*l_3064) & (*l_3065)), + (safe_rshift_func_int16_t_s_u ( + ((safe_div_func_int32_t_s_s ( + (((p_41 <= ((**g_2183) = 0x92BFL)) + && ((safe_mul_func_uint8_t_u_u ( + (((safe_add_func_int32_t_s_s ( + (*g_129))) + != p_41) + | (*l_3065)), + (-1L))) + != (*l_3064))), + p_41))) + & p_41), + p_41)))), + l_3134))) + { + } + } + } + } + } +} +static int8_t +func_44 (uint32_t p_45, int32_t p_46, uint8_t *p_47) +{ + uint16_t l_54 = 0x75E3L; + int32_t l_65 = 0x487B2547L; + uint8_t *l_134 = &g_53; + int32_t l_1641[6] + = { 5L, 0x7D39BD4DL, 0x7D39BD4DL, 5L, 0x7D39BD4DL, 0x7D39BD4DL }; + int32_t l_1717 = (-2L); + int32_t l_1831 = 0xB48C0CFBL; + int8_t l_1867[1]; + uint32_t l_1926[6][10][4] = {}; + int8_t *******l_1938 = (void *)0; + { + int32_t *l_137 = (void *)0; + int32_t **l_136 = &l_137; + int64_t l_1640 = (-1L); + int32_t l_1834 = 0xD80D892DL; + { + int32_t *l_103 = &l_65; + int32_t **l_102 = &l_103; + uint32_t l_1750 = 2UL; + for (p_45 = 1; (p_45 <= 4); p_45 += 1) + { + uint32_t l_1694 = 0xC4857EC0L; + int64_t l_1722 = 0L; + for (g_1463 = 0; (g_1463 < 20); g_1463++) + { + uint64_t **l_1661 = &g_608[3]; + (**g_128) &= (((void *)0 != l_1661) > p_46); + } + { + int32_t l_1687 = 0x38E5F7D2L; + { + uint8_t *l_1695 = &g_493; + uint32_t l_1721[5] = { 1UL, 1UL, 1UL, 1UL, 1UL }; + p_46 &= (safe_rshift_func_uint8_t_u_u ( + ((*l_1695) = (safe_lshift_func_uint16_t_u_u ( + ((((*l_134) + = (g_1263[g_1423] + ^ ((**l_102) + | (l_1687 + = ((safe_sub_func_int8_t_s_s ( + ((-1L) ^ (l_1687 <= (&g_1238 + == (void *)0))), + 0x62L)), + (((***g_1087) + = (safe_mul_func_uint8_t_u_u ( + ((safe_add_func_uint32_t_u_u ( + ((safe_mul_func_uint8_t_u_u ( + l_1694, 1UL)) + >= 1L), + p_45)), + 0x54L), + p_45))) + | g_1263[g_1423])))))) + && p_45) + | p_45), + p_45))), + 1)); + (**l_102) = (+( + (p_46 > p_45) + && ((((safe_div_func_uint64_t_u_u ( + ((safe_div_func_int16_t_s_s ( + ((((p_46, + (safe_lshift_func_uint16_t_u_u ( + ((p_46 + <= ((((p_45, + ((safe_add_func_int16_t_s_s ( + l_1687)) + > l_1687)) + || p_46) + >= l_1717) + <= p_46)), + l_1641[0]), + 4))) + ^ g_1719) + & l_1687) + && g_1720), + 0xA650L)) + & 0x92L), + l_1721[1])) + > 0x41L) + < p_45) + == l_1722))); + } + } + } + { + int32_t l_1749[5][10]; + { + int32_t l_1748[4][3] + = { { (-1L), (-1L), (-1L) }, { (-1L), (-1L), (-1L) } }; + { + int8_t l_1734 = 4L; + uint16_t *l_1744[2][3][10] + = { { { &l_54, &l_54, &l_54, &l_54, &l_54, &l_54, &l_54, &l_54, + &l_54, &l_54 }, + { &g_251, &l_54, &g_251, &g_251, &l_54, &g_251, &g_251, + &l_54, &g_251, &g_251 } }, + { { &l_54, &l_54, &l_54, &l_54, &l_54, &l_54, &l_54, &l_54, + &l_54, &l_54 }, + { &g_251, &l_54, &g_251, &g_251, &l_54, &g_251, &g_251, + &l_54, &g_251, &g_251 } } }; + l_1750 + &= ((safe_div_func_int16_t_s_s ( + ((((safe_lshift_func_int16_t_s_u ( + (safe_mul_func_int16_t_s_s (( + (((safe_sub_func_int16_t_s_s ( + (safe_rshift_func_uint16_t_u_u ( + (l_1734 + && ((((safe_rshift_func_uint16_t_u_s ( + 9)) + | ((((safe_div_func_int16_t_s_s ( + g_195)), + g_1436[1][0]) + == l_1734), + 0x69B7L)) + >= g_1437[1][0][4]) + != 0xF00CEFD7L)), + 8)))) + <= l_1748[3][0]) + != (*g_1432)) + <= p_45))), + g_254)) + && p_45), + l_1749[2][9]) + && 2UL), + 0xBC6CL)) + == (*p_47)); + } + { + (*g_129) + = (p_46 + >= (((safe_mod_func_uint32_t_u_u ( + ((safe_div_func_uint8_t_u_u ( + ((((0x9874L && p_45) + < (((void *)0 != &g_1088) + || (safe_unary_minus_func_uint16_t_u ( + 1UL)))) + & ((g_1757 = p_45), + (safe_sub_func_int8_t_s_s ( + 0xB2L, + ((((*l_103) + = (((p_45 || 0x22BDL) & p_46) + && 0xA842C273L)) + < p_46) + >= 1L))))), + (*p_47)), + 255UL)) + > 0x6B9D1555L), + p_46)) + < p_46) + >= p_45)); + } + } + } + } + { + int32_t **l_1800 = &l_137; + const int8_t ****l_1807 = (void *)0; + const int8_t *****l_1806[8][8][4] + = { { { &l_1807, &l_1807, &l_1807, &l_1807 }, + { &l_1807, &l_1807, &l_1807, &l_1807 } }, + { { &l_1807, &l_1807, &l_1807, &l_1807 }, + { &l_1807, &l_1807, &l_1807, &l_1807 } } }; + const int8_t ******l_1805 = &l_1806[6][7][1]; + const int64_t **l_1879 = (void *)0; + { + uint16_t l_1802[6][8][5] + = { { { 7UL, 0x2302L, 0x4453L, 0UL, 0UL }, + { 0x2A70L, 0x87C5L, 0x956FL, 1UL, 65534UL } }, + { { 65535UL, 0x69AAL, 0UL, 65534UL, 7UL }, + { 0x956FL, 1UL, 0x87C5L, 0UL, 0x69AAL } } }; + int32_t l_1829 = 0x632C3B7AL; + int32_t l_1830 = 1L; + uint32_t l_1836 = 1UL; + { + int32_t ***l_1801 = &l_136; + int8_t ******l_1803[5]; + int8_t *******l_1804 = &l_1803[1]; + int64_t *l_1814 = &l_1640; + int16_t *l_1833 = &g_391[4]; + uint8_t *l_1835 = &g_674; + p_46 = ((p_46, (p_45 & g_1794)), + (p_46 + >= (safe_rshift_func_uint16_t_u_u ( + (((p_45 + & (safe_sub_func_int64_t_s_s ( + ((p_45, ((*l_1801) = l_1800)) + != (((((l_1802[1][4][3] | p_45), (void *)0) + == (void *)0), + (***g_1087)), + (void *)0))))) + != 3L) + >= p_46), + p_46)))); + l_1836 + = (((((((((*l_1804) = l_1803[0]) == l_1805) + <= ((*l_1835) &= (safe_lshift_func_int8_t_s_s ( + ((((safe_add_func_uint16_t_u_u (( + (*l_1833) = (safe_div_func_uint8_t_u_u ( + ((*l_134) + = (safe_mul_func_int16_t_s_s ( + (((l_1830 + ^= (l_1829 + ^= (l_1814 + == ((((safe_add_func_int8_t_s_s ( + (*p_47))) + <= p_46) + == (***g_1087)), + l_1814)))) + == 0x97A0850DE6CA7808LL) + >= l_1802[1][4][3]), + l_1831))), + g_1832))))) + > p_45), + 18446744073709551606UL), + l_1834), + p_46)))) + || 0x250DL) + | p_46) + ^ l_1802[1][4][3]), + 0xE44CA8DCL), + (*g_129)); + } + } + { + uint16_t l_1876[4][9][7] = {}; + int8_t *l_1878 = &g_817; + int32_t l_1883 = 0xFED42E73L; + int8_t ******l_1886 = &g_1238; + int8_t *******l_1887 = &l_1886; + int32_t l_1889 = 0x883D0273L; + int8_t *l_1890 = &l_1867[0]; + if (((*p_47) + < ((*l_1890) + = ((safe_lshift_func_int8_t_s_u ( + ((*l_1878) |= l_1876[2][4][3]), 7)) + == (l_1889 + = (((g_1224 == l_1879) + <= ((p_45 + == ((((g_126 + = ((safe_rshift_func_uint8_t_u_u ( + (l_1883 &= (0xC9L || (!0L))), + (safe_sub_func_int8_t_s_s ( + ((((*l_1887) = l_1886) + != (void *)0) + > l_1876[2][4][3]), + 0xC2L)))) + > p_46)), + (**g_128)) + & (**g_128)) + & 0UL)) + != l_1876[2][4][3])) + ^ p_45)))))) + { + } + } + } + } + { + uint32_t l_1906 = 7UL; + uint16_t *l_1943 = &l_54; + { + uint16_t l_1925 = 0x3BBCL; + int16_t l_1927 = 0x7D9EL; + uint64_t *l_1928 = &g_254; + (*g_129) &= (l_1906, + ((((safe_div_func_int8_t_s_s (( + (((((*g_129) + = ((safe_mod_func_uint16_t_u_u (g_1719)) + | ((*l_1928) = (safe_rshift_func_uint8_t_u_u ( + ((((safe_mod_func_uint16_t_u_u ( + (p_45 <= l_1925), (-1L))), + 0L) + >= l_1925) + < l_1926[2][3][1]), + l_1927))))) + < p_45) + | 0L) + == (*p_47)) + || 0UL))), + 0x611E34B16CBCCED0LL), + p_46) + != p_46)); + (**g_128) = (safe_sub_func_uint64_t_u_u ( + ((safe_sub_func_uint16_t_u_u ( + (((void *)0 != l_1938) + >= ((safe_sub_func_int8_t_s_s ( + (((safe_lshift_func_int8_t_s_s ( + p_45, ((l_1943 == (void *)0) > (-1L)))) + && p_45) + == l_1927), + g_1944)) + != l_1927)))) + & (*g_129)))); + } + } +} +int +main (int argc, char *argv[]) +{ + if (argc == 2 + && __extension__({ + (__builtin_constant_p (argv[1]) && __builtin_constant_p ("1") + ? __builtin_strcmp (argv[1], "1") + : (__builtin_constant_p (argv[1]) + ? (__builtin_constant_p ("1") + ? __builtin_strcmp (argv[1], "1") + : (__extension__({ + const unsigned char *__s2 + = (const unsigned char *)(const char + *)("1"); + int __result + = (((const unsigned char + *)(const char *)(argv[1]))[0] + - __s2[0]); + __result; + }))) + : (__builtin_constant_p ("1") + ? (__builtin_constant_p (argv[1]) + ? __builtin_strcmp (argv[1], "1") + : (-(__extension__({ + const unsigned char *__s2 + = (const unsigned char + *)(const char *)(argv[1]); + int __result + = (((const unsigned char + *)(const char *)("1"))[0] + - __s2[0]); + __result; + })))) + : __builtin_strcmp (argv[1], "1")))); + }) == 0) + func_1 (); +}