gcc/testsuite/gcc.c-torture/compile/920625-1.c

   1 /* { dg-skip-if "too many arguments in function call" { bpf-*-* } } */
   2 /* { dg-additional-options "-std=gnu89" } */
   3
   4 typedef unsigned long int unsigned_word;
   5 typedef signed long int signed_word;
   6 typedef unsigned_word word;
   7
   8 typedef enum { ADD, ADD_CI, ADD_CO, ADD_CIO, SUB, SUB_CI, SUB_CO,
   9 SUB_CIO, ADC_CI, ADC_CO, ADC_CIO, AND, IOR, XOR, ANDC, IORC, EQV,
  10 NAND, NOR, AND_RC, IOR_RC, XOR_RC, ANDC_RC, IORC_RC, EQV_RC, NAND_RC,
  11 NOR_RC, AND_CC, IOR_CC, XOR_CC, ANDC_CC, IORC_CC, EQV_CC, NAND_CC,
  12 NOR_CC, LSHIFTR, ASHIFTR, SHIFTL, LSHIFTR_CO, ASHIFTR_CO, SHIFTL_CO,
  13 ROTATEL, ROTATEL_CO, ROTATEXL_CIO, ASHIFTR_CON, EXTS1, EXTS2, EXTU1,
  14 EXTU2, CLZ, CTZ, FF1, FF0, ABSVAL, NABSVAL, CMP, CPEQ, CPGE, CPGEU,
  15 CPGT, CPGTU, CPLE, CPLEU, CPLT, CPLTU, CPNEQ, CMPPAR, DOZ, COPY,
  16 EXCHANGE, COMCY, } opcode_t;
  17
  18 typedef struct
  19 {
  20   opcode_t opcode:8;
  21   unsigned int s1:8;
  22   unsigned int s2:8;
  23   unsigned int d:8;
  24 } insn_t;
  25
  26 enum prune_flags
  27 {
  28   NO_PRUNE = 0,
  29   CY_0 = 1,
  30   CY_1 = 2,
  31   CY_JUST_SET = 4,
  32 };
  33
  34 int flag_use_carry = 1;
  35
  36 inline
  37 recurse(opcode_t opcode,
  38  int d,
  39  int s1,
  40  int s2,
  41  word v,
  42  int cost,
  43  insn_t *sequence,
  44  int n_insns,
  45  word *values,
  46  int n_values,
  47  const word goal_value,
  48  int allowed_cost,
  49  int cy,
  50  int prune_flags)
  51 {
  52   insn_t insn;
  53
  54   allowed_cost -= cost;
  55
  56   if (allowed_cost > 0)
  57     {
  58       word old_d;
  59
  60       old_d = values[d];
  61       values[d] = v;
  62
  63       insn.opcode = opcode;
  64       insn.s1 = s1;
  65       insn.s2 = s2;
  66       insn.d = d;
  67       sequence[n_insns] = insn;
  68
  69       synth(sequence, n_insns + 1, values, n_values,
  70      goal_value, allowed_cost, cy, prune_flags);
  71
  72       values[d] = old_d;
  73     }
  74   else if (goal_value == v)
  75     {
  76       insn.opcode = opcode;
  77       insn.s1 = s1;
  78       insn.s2 = s2;
  79       insn.d = d;
  80       sequence[n_insns] = insn;
  81       test_sequence(sequence, n_insns + 1);
  82     }
  83 }
  84
  85 synth(insn_t *sequence,
  86       int n_insns,
  87       word *values,
  88       int n_values,
  89       word goal_value,
  90       int allowed_cost,
  91       int ci,
  92       int prune_hint)
  93 {
  94   int s1, s2;
  95   word v, r1, r2;
  96   int co;
  97   int last_dest;
  98
  99   if (n_insns > 0)
 100     last_dest = sequence[n_insns - 1].d;
 101   else
 102     last_dest = -1;
 103   if (ci >= 0 && flag_use_carry)
 104     {
 105       for (s1 = n_values - 1; s1 >= 0; s1--)
 106  {
 107    r1 = values[s1];
 108    for (s2 = s1 - 1; s2 >= 0; s2--)
 109      {
 110        r2 = values[s2];
 111
 112        if (allowed_cost <= 1 && (prune_hint & CY_JUST_SET) == 0)
 113   {
 114     if (last_dest >= 0 && s1 != last_dest && s2 != last_dest)
 115       continue;
 116   }
 117        do { word __d = ( r1) + ( r2) + (( ci)); ( co) = ( ci) ? __d <= ( r1) : __d < ( r1); (v) = __d; } while (0);
 118        recurse(ADD_CIO, n_values,  s1,  s2, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  CY_JUST_SET);
 119        do { word __d = ( r1) + ( r2) + (( ci)); ( co) = ( ci); (v) = __d; } while (0);
 120        recurse(ADD_CI, n_values,  s1,  s2, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  prune_hint & ~CY_JUST_SET);
 121
 122        do { word __d = ( r1) - ( r2) - (( ci)); ( co) = ( ci) ? __d >= ( r1) : __d > ( r1); (v) = __d; } while (0);
 123        recurse(SUB_CIO, n_values,  s1,  s2, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  CY_JUST_SET);
 124        do { word __d = ( r2) - ( r1) - (( ci)); ( co) = ( ci) ? __d >= ( r2) : __d > ( r2); (v) = __d; } while (0);
 125        recurse(SUB_CIO, n_values,  s2,  s1, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  CY_JUST_SET);
 126
 127        do { word __d = ( r1) - ( r2) - (( ci)); ( co) = ( ci); (v) = __d; } while (0);
 128        recurse(SUB_CI, n_values,  s1,  s2, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  prune_hint & ~CY_JUST_SET);
 129        do { word __d = ( r2) - ( r1) - (( ci)); ( co) = ( ci); (v) = __d; } while (0);
 130        recurse(SUB_CI, n_values,  s2,  s1, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  prune_hint & ~CY_JUST_SET);
 131
 132      }
 133  }
 134     }
 135   for (s1 = n_values - 1; s1 >= 0; s1--)
 136     {
 137       r1 = values[s1];
 138       for (s2 = s1 - 1; s2 >= 0; s2--)
 139  {
 140    r2 = values[s2];
 141
 142    if (allowed_cost <= 1)
 143      {
 144        if (last_dest >= 0 && s1 != last_dest && s2 != last_dest)
 145   continue;
 146      }
 147
 148    do { word __d = ( r1) + ( r2); ( co) = __d < ( r1); (v) = __d; } while (0);
 149    recurse(ADD_CO, n_values,  s1,  s2, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  CY_JUST_SET);
 150
 151    ((v) = ( r1) + ( r2), ( co) = ( ci));
 152    recurse(ADD, n_values,  s1,  s2, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  prune_hint & ~CY_JUST_SET);
 153
 154    do { word __d = ( r1) - ( r2); ( co) = __d > ( r1); (v) = __d; } while (0);
 155    recurse(SUB_CO, n_values,  s1,  s2, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  CY_JUST_SET);
 156    do { word __d = ( r2) - ( r1); ( co) = __d > ( r2); (v) = __d; } while (0);
 157    recurse(SUB_CO, n_values,  s2,  s1, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  CY_JUST_SET);
 158    ((v) = ( r1) - ( r2), ( co) = ( ci));
 159    recurse(SUB, n_values,  s1,  s2, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  prune_hint & ~CY_JUST_SET);
 160    ((v) = ( r2) - ( r1), ( co) = ( ci));
 161    recurse(SUB, n_values,  s2,  s1, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  prune_hint & ~CY_JUST_SET);
 162
 163    ((v) = ( r1) & ( r2), ( co) = ( ci));
 164    recurse(AND, n_values,  s1,  s2, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  prune_hint & ~CY_JUST_SET);
 165
 166    ((v) = ( r1) | ( r2), ( co) = ( ci));
 167    recurse(IOR, n_values,  s1,  s2, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  prune_hint & ~CY_JUST_SET);
 168
 169    ((v) = ( r1) ^ ( r2), ( co) = ( ci));
 170    recurse(XOR, n_values,  s1,  s2, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  prune_hint & ~CY_JUST_SET);
 171
 172    ((v) = ( r1) & ~( r2), ( co) = ( ci));
 173    recurse(ANDC, n_values,  s1,  s2, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  prune_hint & ~CY_JUST_SET);
 174    ((v) = ( r2) & ~( r1), ( co) = ( ci));
 175    recurse(ANDC, n_values,  s2,  s1, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  prune_hint & ~CY_JUST_SET);
 176    ((v) = ( r1) | ~( r2), ( co) = ( ci));
 177    recurse(IORC, n_values,  s1,  s2, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  prune_hint & ~CY_JUST_SET);
 178    ((v) = ( r2) | ~( r1), ( co) = ( ci));
 179    recurse(IORC, n_values,  s2,  s1, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  prune_hint & ~CY_JUST_SET);
 180    ((v) = ( r1) ^ ~( r2), ( co) = ( ci));
 181    recurse(EQV, n_values,  s1,  s2, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  prune_hint & ~CY_JUST_SET);
 182
 183  }
 184     }
 185   if (ci >= 0 && flag_use_carry)
 186     {
 187       for (s1 = n_values - 1; s1 >= 0; s1--)
 188  {
 189    r1 = values[s1];
 190
 191    if (allowed_cost <= 1 && (prune_hint & CY_JUST_SET) == 0)
 192      {
 193
 194        if (last_dest >= 0 && s1 != last_dest)
 195   continue;
 196      }
 197
 198    do { word __d = ( r1) + ( r1) + (( ci)); ( co) = ( ci) ? __d <= ( r1) : __d < ( r1); (v) = __d; } while (0);
 199    recurse(ADD_CIO, n_values,  s1,  s1, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  CY_JUST_SET);
 200
 201    do { word __d = ( r1) + ( r1) + (( ci)); ( co) = ( ci); (v) = __d; } while (0);
 202    recurse(ADD_CI, n_values,  s1,  s1, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  prune_hint & ~CY_JUST_SET);
 203
 204    do { word __d = ( r1) + ( -1 ) + (( ci)); ( co) = ( ci) ? __d <= ( r1) : __d < ( r1); (v) = __d; } while (0);
 205    recurse(ADD_CIO, n_values,  s1,  (0x20 + -1) , v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  CY_JUST_SET);
 206
 207    do { word __d = ( r1) + ( 0 ) + (( ci)); ( co) = ( ci) ? __d <= ( r1) : __d < ( r1); (v) = __d; } while (0);
 208    recurse(ADD_CIO, n_values,  s1,  (0x20 + 0) , v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  CY_JUST_SET);
 209    do { word __d = ( 0 ) - ( r1) - (( ci)); ( co) = ( ci) ? __d >= ( 0 ) : __d > ( 0 ); (v) = __d; } while (0);
 210    recurse(SUB_CIO, n_values,  (0x20 + 0) ,  s1, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  CY_JUST_SET);
 211
 212  }
 213     }
 214   for (s1 = n_values - 1; s1 >= 0; s1--)
 215     {
 216       r1 = values[s1];
 217
 218       if (allowed_cost <= 1)
 219  {
 220    if (last_dest >= 0 && s1 != last_dest)
 221      continue;
 222  }
 223       do { word __d = ( r1) + ( r1); ( co) = __d < ( r1); (v) = __d; } while (0);
 224       recurse(ADD_CO, n_values,  s1,  s1, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  CY_JUST_SET);
 225
 226       ((v) = ( r1) & ( 1 ), ( co) = ( ci));
 227       recurse(AND, n_values,  s1,  (0x20 + 1) , v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  prune_hint & ~CY_JUST_SET);
 228
 229       ((v) = ( r1) ^ ( 1 ), ( co) = ( ci));
 230       recurse(XOR, n_values,  s1,  (0x20 + 1) , v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  prune_hint & ~CY_JUST_SET);
 231
 232       ((v) = ( -1 ) - ( r1), ( co) = ( ci));
 233       recurse(SUB, n_values,  (0x20 + -1) ,  s1, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  prune_hint & ~CY_JUST_SET);
 234       do { word __d = ( r1) + ( 1 ); ( co) = __d < ( r1); (v) = __d; } while (0);
 235       recurse(ADD_CO, n_values,  s1,  (0x20 + 1) , v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  CY_JUST_SET);
 236       ((v) = ( r1) + ( 1 ), ( co) = ( ci));
 237       recurse(ADD, n_values,  s1,  (0x20 + 1) , v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  prune_hint & ~CY_JUST_SET);
 238       do { word __d = ( r1) + ( -1 ); ( co) = __d < ( r1); (v) = __d; } while (0);
 239       recurse(ADD_CO, n_values,  s1,  (0x20 + -1) , v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  CY_JUST_SET);
 240       do { word __d = ( r1) - ( 1 ); ( co) = __d > ( r1); (v) = __d; } while (0);
 241       recurse(SUB_CO, n_values,  s1,  (0x20 + 1) , v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  CY_JUST_SET);
 242       do { word __d = ( 0 ) - ( r1); ( co) = __d > ( 0 ); (v) = __d; } while (0);
 243       recurse(SUB_CO, n_values,  (0x20 + 0) ,  s1, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  CY_JUST_SET);
 244       ((v) = ( 0 ) - ( r1), ( co) = ( ci));
 245       recurse(SUB, n_values,  (0x20 + 0) ,  s1, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  prune_hint & ~CY_JUST_SET);
 246       ((v) = ((unsigned_word) ( r1) >> (( 1 ) & (32  - 1)) ), ( co) = ( ci));
 247       recurse(LSHIFTR, n_values,  s1,  (0x20 + 1) , v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  prune_hint & ~CY_JUST_SET);
 248       ((v) = ((signed_word) ( r1) >> (( 1 ) & (32  - 1)) ), ( co) = ( ci));
 249       recurse(ASHIFTR, n_values,  s1,  (0x20 + 1) , v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  prune_hint & ~CY_JUST_SET);
 250       ((v) = ((signed_word) ( r1) << (( 1 ) & (32  - 1)) ), ( co) = ( ci));
 251       recurse(SHIFTL, n_values,  s1,  (0x20 + 1) , v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  prune_hint & ~CY_JUST_SET);
 252       ((v) = ((unsigned_word) ( r1) >> (( 32 -1 ) & (32  - 1)) ), ( co) = ( ci));
 253       recurse(LSHIFTR, n_values,  s1,  (0x20 + 32 -1) , v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  prune_hint & ~CY_JUST_SET);
 254       ((v) = ((signed_word) ( r1) >> (( 32 -1 ) & (32  - 1)) ), ( co) = ( ci));
 255       recurse(ASHIFTR, n_values,  s1,  (0x20 + 32 -1) , v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  prune_hint & ~CY_JUST_SET);
 256     }
 257   if (ci >= 0 && flag_use_carry
 258       && (allowed_cost <= 1 ? ((prune_hint & CY_JUST_SET) != 0) : 1))
 259     {
 260       do { word __d = ( 0 ) + ( 0 ) + (( ci)); ( co) = ( ci) ? __d <= ( 0 ) : __d < ( 0 ); (v) = __d; } while (0);
 261       recurse(ADD_CIO, n_values,  (0x20 + 0) ,  (0x20 + 0) , v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  CY_JUST_SET | CY_0);
 262       do { word __d = ( 0 ) - ( 0 ) - (( ci)); ( co) = ( ci) ? __d >= ( 0 ) : __d > ( 0 ); (v) = __d; } while (0);
 263       recurse(SUB_CIO, n_values,  (0x20 + 0) ,  (0x20 + 0) , v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  prune_hint & ~CY_JUST_SET);
 264       do { word __d = ( 0 ) - ( -1 ) - (( ci)); ( co) = ( ci) ? __d >= ( 0 ) : __d > ( 0 ); (v) = __d; } while (0);
 265       recurse(SUB_CIO, n_values,  (0x20 + 0) ,  (0x20 + -1) , v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  CY_JUST_SET | CY_1);
 266       do { word __d = ( 0 ) + ( -1 ) + (( ci)); ( co) = ( ci) ? __d <= ( 0 ) : __d < ( 0 ); (v) = __d; } while (0);
 267       recurse(ADD_CIO, n_values,  (0x20 + 0) ,  (0x20 + -1) , v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  prune_hint & ~CY_JUST_SET);
 268
 269     }
 270
 271   if (allowed_cost > 1)
 272     {
 273       ((v) = ( 0x80000000 ), ( co) = ( ci));
 274       recurse(COPY, n_values,  (0x20 - 2) ,  0, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  prune_hint & ~CY_JUST_SET);
 275
 276       ((v) = ( -1 ), ( co) = ( ci));
 277       recurse(COPY, n_values,  (0x20 + -1) ,  0, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  prune_hint & ~CY_JUST_SET);
 278
 279       ((v) = ( 1 ), ( co) = ( ci));
 280       recurse(COPY, n_values,  (0x20 + 1) ,  0, v, 1, sequence, n_insns, values, n_values + 1, goal_value, allowed_cost, co,  prune_hint & ~CY_JUST_SET);
 281     }
 282 }