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