Debian Codegraph @

gcc/testsuite/g++.target/powerpc/pr110741.C

raw
1 /* { dg-do run { target { power10_hw } } } */
2 /* { dg-options "-O2 -mdejagnu-cpu=power10" } */
3
4 #include <altivec.h>
5
6 typedef unsigned char uint8_t;
7
8 template <uint8_t kTernLogOp>
9 static inline vector unsigned long long
10 VSXTernaryLogic (vector unsigned long long a, vector unsigned long long b,
11 vector unsigned long long c)
12 {
13 return vec_ternarylogic (a, b, c, kTernLogOp);
14 }
15
16 static vector unsigned long long
17 VSXTernaryLogic (vector unsigned long long a, vector unsigned long long b,
18 vector unsigned long long c, int ternary_logic_op)
19 {
20 switch (ternary_logic_op & 0xFF)
21 {
22 case 0:
23 return VSXTernaryLogic<0> (a, b, c);
24 case 1:
25 return VSXTernaryLogic<1> (a, b, c);
26 case 2:
27 return VSXTernaryLogic<2> (a, b, c);
28 case 3:
29 return VSXTernaryLogic<3> (a, b, c);
30 case 4:
31 return VSXTernaryLogic<4> (a, b, c);
32 case 5:
33 return VSXTernaryLogic<5> (a, b, c);
34 case 6:
35 return VSXTernaryLogic<6> (a, b, c);
36 case 7:
37 return VSXTernaryLogic<7> (a, b, c);
38 case 8:
39 return VSXTernaryLogic<8> (a, b, c);
40 case 9:
41 return VSXTernaryLogic<9> (a, b, c);
42 case 10:
43 return VSXTernaryLogic<10> (a, b, c);
44 case 11:
45 return VSXTernaryLogic<11> (a, b, c);
46 case 12:
47 return VSXTernaryLogic<12> (a, b, c);
48 case 13:
49 return VSXTernaryLogic<13> (a, b, c);
50 case 14:
51 return VSXTernaryLogic<14> (a, b, c);
52 case 15:
53 return VSXTernaryLogic<15> (a, b, c);
54 case 16:
55 return VSXTernaryLogic<16> (a, b, c);
56 case 17:
57 return VSXTernaryLogic<17> (a, b, c);
58 case 18:
59 return VSXTernaryLogic<18> (a, b, c);
60 case 19:
61 return VSXTernaryLogic<19> (a, b, c);
62 case 20:
63 return VSXTernaryLogic<20> (a, b, c);
64 case 21:
65 return VSXTernaryLogic<21> (a, b, c);
66 case 22:
67 return VSXTernaryLogic<22> (a, b, c);
68 case 23:
69 return VSXTernaryLogic<23> (a, b, c);
70 case 24:
71 return VSXTernaryLogic<24> (a, b, c);
72 case 25:
73 return VSXTernaryLogic<25> (a, b, c);
74 case 26:
75 return VSXTernaryLogic<26> (a, b, c);
76 case 27:
77 return VSXTernaryLogic<27> (a, b, c);
78 case 28:
79 return VSXTernaryLogic<28> (a, b, c);
80 case 29:
81 return VSXTernaryLogic<29> (a, b, c);
82 case 30:
83 return VSXTernaryLogic<30> (a, b, c);
84 case 31:
85 return VSXTernaryLogic<31> (a, b, c);
86 case 32:
87 return VSXTernaryLogic<32> (a, b, c);
88 case 33:
89 return VSXTernaryLogic<33> (a, b, c);
90 case 34:
91 return VSXTernaryLogic<34> (a, b, c);
92 case 35:
93 return VSXTernaryLogic<35> (a, b, c);
94 case 36:
95 return VSXTernaryLogic<36> (a, b, c);
96 case 37:
97 return VSXTernaryLogic<37> (a, b, c);
98 case 38:
99 return VSXTernaryLogic<38> (a, b, c);
100 case 39:
101 return VSXTernaryLogic<39> (a, b, c);
102 case 40:
103 return VSXTernaryLogic<40> (a, b, c);
104 case 41:
105 return VSXTernaryLogic<41> (a, b, c);
106 case 42:
107 return VSXTernaryLogic<42> (a, b, c);
108 case 43:
109 return VSXTernaryLogic<43> (a, b, c);
110 case 44:
111 return VSXTernaryLogic<44> (a, b, c);
112 case 45:
113 return VSXTernaryLogic<45> (a, b, c);
114 case 46:
115 return VSXTernaryLogic<46> (a, b, c);
116 case 47:
117 return VSXTernaryLogic<47> (a, b, c);
118 case 48:
119 return VSXTernaryLogic<48> (a, b, c);
120 case 49:
121 return VSXTernaryLogic<49> (a, b, c);
122 case 50:
123 return VSXTernaryLogic<50> (a, b, c);
124 case 51:
125 return VSXTernaryLogic<51> (a, b, c);
126 case 52:
127 return VSXTernaryLogic<52> (a, b, c);
128 case 53:
129 return VSXTernaryLogic<53> (a, b, c);
130 case 54:
131 return VSXTernaryLogic<54> (a, b, c);
132 case 55:
133 return VSXTernaryLogic<55> (a, b, c);
134 case 56:
135 return VSXTernaryLogic<56> (a, b, c);
136 case 57:
137 return VSXTernaryLogic<57> (a, b, c);
138 case 58:
139 return VSXTernaryLogic<58> (a, b, c);
140 case 59:
141 return VSXTernaryLogic<59> (a, b, c);
142 case 60:
143 return VSXTernaryLogic<60> (a, b, c);
144 case 61:
145 return VSXTernaryLogic<61> (a, b, c);
146 case 62:
147 return VSXTernaryLogic<62> (a, b, c);
148 case 63:
149 return VSXTernaryLogic<63> (a, b, c);
150 case 64:
151 return VSXTernaryLogic<64> (a, b, c);
152 case 65:
153 return VSXTernaryLogic<65> (a, b, c);
154 case 66:
155 return VSXTernaryLogic<66> (a, b, c);
156 case 67:
157 return VSXTernaryLogic<67> (a, b, c);
158 case 68:
159 return VSXTernaryLogic<68> (a, b, c);
160 case 69:
161 return VSXTernaryLogic<69> (a, b, c);
162 case 70:
163 return VSXTernaryLogic<70> (a, b, c);
164 case 71:
165 return VSXTernaryLogic<71> (a, b, c);
166 case 72:
167 return VSXTernaryLogic<72> (a, b, c);
168 case 73:
169 return VSXTernaryLogic<73> (a, b, c);
170 case 74:
171 return VSXTernaryLogic<74> (a, b, c);
172 case 75:
173 return VSXTernaryLogic<75> (a, b, c);
174 case 76:
175 return VSXTernaryLogic<76> (a, b, c);
176 case 77:
177 return VSXTernaryLogic<77> (a, b, c);
178 case 78:
179 return VSXTernaryLogic<78> (a, b, c);
180 case 79:
181 return VSXTernaryLogic<79> (a, b, c);
182 case 80:
183 return VSXTernaryLogic<80> (a, b, c);
184 case 81:
185 return VSXTernaryLogic<81> (a, b, c);
186 case 82:
187 return VSXTernaryLogic<82> (a, b, c);
188 case 83:
189 return VSXTernaryLogic<83> (a, b, c);
190 case 84:
191 return VSXTernaryLogic<84> (a, b, c);
192 case 85:
193 return VSXTernaryLogic<85> (a, b, c);
194 case 86:
195 return VSXTernaryLogic<86> (a, b, c);
196 case 87:
197 return VSXTernaryLogic<87> (a, b, c);
198 case 88:
199 return VSXTernaryLogic<88> (a, b, c);
200 case 89:
201 return VSXTernaryLogic<89> (a, b, c);
202 case 90:
203 return VSXTernaryLogic<90> (a, b, c);
204 case 91:
205 return VSXTernaryLogic<91> (a, b, c);
206 case 92:
207 return VSXTernaryLogic<92> (a, b, c);
208 case 93:
209 return VSXTernaryLogic<93> (a, b, c);
210 case 94:
211 return VSXTernaryLogic<94> (a, b, c);
212 case 95:
213 return VSXTernaryLogic<95> (a, b, c);
214 case 96:
215 return VSXTernaryLogic<96> (a, b, c);
216 case 97:
217 return VSXTernaryLogic<97> (a, b, c);
218 case 98:
219 return VSXTernaryLogic<98> (a, b, c);
220 case 99:
221 return VSXTernaryLogic<99> (a, b, c);
222 case 100:
223 return VSXTernaryLogic<100> (a, b, c);
224 case 101:
225 return VSXTernaryLogic<101> (a, b, c);
226 case 102:
227 return VSXTernaryLogic<102> (a, b, c);
228 case 103:
229 return VSXTernaryLogic<103> (a, b, c);
230 case 104:
231 return VSXTernaryLogic<104> (a, b, c);
232 case 105:
233 return VSXTernaryLogic<105> (a, b, c);
234 case 106:
235 return VSXTernaryLogic<106> (a, b, c);
236 case 107:
237 return VSXTernaryLogic<107> (a, b, c);
238 case 108:
239 return VSXTernaryLogic<108> (a, b, c);
240 case 109:
241 return VSXTernaryLogic<109> (a, b, c);
242 case 110:
243 return VSXTernaryLogic<110> (a, b, c);
244 case 111:
245 return VSXTernaryLogic<111> (a, b, c);
246 case 112:
247 return VSXTernaryLogic<112> (a, b, c);
248 case 113:
249 return VSXTernaryLogic<113> (a, b, c);
250 case 114:
251 return VSXTernaryLogic<114> (a, b, c);
252 case 115:
253 return VSXTernaryLogic<115> (a, b, c);
254 case 116:
255 return VSXTernaryLogic<116> (a, b, c);
256 case 117:
257 return VSXTernaryLogic<117> (a, b, c);
258 case 118:
259 return VSXTernaryLogic<118> (a, b, c);
260 case 119:
261 return VSXTernaryLogic<119> (a, b, c);
262 case 120:
263 return VSXTernaryLogic<120> (a, b, c);
264 case 121:
265 return VSXTernaryLogic<121> (a, b, c);
266 case 122:
267 return VSXTernaryLogic<122> (a, b, c);
268 case 123:
269 return VSXTernaryLogic<123> (a, b, c);
270 case 124:
271 return VSXTernaryLogic<124> (a, b, c);
272 case 125:
273 return VSXTernaryLogic<125> (a, b, c);
274 case 126:
275 return VSXTernaryLogic<126> (a, b, c);
276 case 127:
277 return VSXTernaryLogic<127> (a, b, c);
278 case 128:
279 return VSXTernaryLogic<128> (a, b, c);
280 case 129:
281 return VSXTernaryLogic<129> (a, b, c);
282 case 130:
283 return VSXTernaryLogic<130> (a, b, c);
284 case 131:
285 return VSXTernaryLogic<131> (a, b, c);
286 case 132:
287 return VSXTernaryLogic<132> (a, b, c);
288 case 133:
289 return VSXTernaryLogic<133> (a, b, c);
290 case 134:
291 return VSXTernaryLogic<134> (a, b, c);
292 case 135:
293 return VSXTernaryLogic<135> (a, b, c);
294 case 136:
295 return VSXTernaryLogic<136> (a, b, c);
296 case 137:
297 return VSXTernaryLogic<137> (a, b, c);
298 case 138:
299 return VSXTernaryLogic<138> (a, b, c);
300 case 139:
301 return VSXTernaryLogic<139> (a, b, c);
302 case 140:
303 return VSXTernaryLogic<140> (a, b, c);
304 case 141:
305 return VSXTernaryLogic<141> (a, b, c);
306 case 142:
307 return VSXTernaryLogic<142> (a, b, c);
308 case 143:
309 return VSXTernaryLogic<143> (a, b, c);
310 case 144:
311 return VSXTernaryLogic<144> (a, b, c);
312 case 145:
313 return VSXTernaryLogic<145> (a, b, c);
314 case 146:
315 return VSXTernaryLogic<146> (a, b, c);
316 case 147:
317 return VSXTernaryLogic<147> (a, b, c);
318 case 148:
319 return VSXTernaryLogic<148> (a, b, c);
320 case 149:
321 return VSXTernaryLogic<149> (a, b, c);
322 case 150:
323 return VSXTernaryLogic<150> (a, b, c);
324 case 151:
325 return VSXTernaryLogic<151> (a, b, c);
326 case 152:
327 return VSXTernaryLogic<152> (a, b, c);
328 case 153:
329 return VSXTernaryLogic<153> (a, b, c);
330 case 154:
331 return VSXTernaryLogic<154> (a, b, c);
332 case 155:
333 return VSXTernaryLogic<155> (a, b, c);
334 case 156:
335 return VSXTernaryLogic<156> (a, b, c);
336 case 157:
337 return VSXTernaryLogic<157> (a, b, c);
338 case 158:
339 return VSXTernaryLogic<158> (a, b, c);
340 case 159:
341 return VSXTernaryLogic<159> (a, b, c);
342 case 160:
343 return VSXTernaryLogic<160> (a, b, c);
344 case 161:
345 return VSXTernaryLogic<161> (a, b, c);
346 case 162:
347 return VSXTernaryLogic<162> (a, b, c);
348 case 163:
349 return VSXTernaryLogic<163> (a, b, c);
350 case 164:
351 return VSXTernaryLogic<164> (a, b, c);
352 case 165:
353 return VSXTernaryLogic<165> (a, b, c);
354 case 166:
355 return VSXTernaryLogic<166> (a, b, c);
356 case 167:
357 return VSXTernaryLogic<167> (a, b, c);
358 case 168:
359 return VSXTernaryLogic<168> (a, b, c);
360 case 169:
361 return VSXTernaryLogic<169> (a, b, c);
362 case 170:
363 return VSXTernaryLogic<170> (a, b, c);
364 case 171:
365 return VSXTernaryLogic<171> (a, b, c);
366 case 172:
367 return VSXTernaryLogic<172> (a, b, c);
368 case 173:
369 return VSXTernaryLogic<173> (a, b, c);
370 case 174:
371 return VSXTernaryLogic<174> (a, b, c);
372 case 175:
373 return VSXTernaryLogic<175> (a, b, c);
374 case 176:
375 return VSXTernaryLogic<176> (a, b, c);
376 case 177:
377 return VSXTernaryLogic<177> (a, b, c);
378 case 178:
379 return VSXTernaryLogic<178> (a, b, c);
380 case 179:
381 return VSXTernaryLogic<179> (a, b, c);
382 case 180:
383 return VSXTernaryLogic<180> (a, b, c);
384 case 181:
385 return VSXTernaryLogic<181> (a, b, c);
386 case 182:
387 return VSXTernaryLogic<182> (a, b, c);
388 case 183:
389 return VSXTernaryLogic<183> (a, b, c);
390 case 184:
391 return VSXTernaryLogic<184> (a, b, c);
392 case 185:
393 return VSXTernaryLogic<185> (a, b, c);
394 case 186:
395 return VSXTernaryLogic<186> (a, b, c);
396 case 187:
397 return VSXTernaryLogic<187> (a, b, c);
398 case 188:
399 return VSXTernaryLogic<188> (a, b, c);
400 case 189:
401 return VSXTernaryLogic<189> (a, b, c);
402 case 190:
403 return VSXTernaryLogic<190> (a, b, c);
404 case 191:
405 return VSXTernaryLogic<191> (a, b, c);
406 case 192:
407 return VSXTernaryLogic<192> (a, b, c);
408 case 193:
409 return VSXTernaryLogic<193> (a, b, c);
410 case 194:
411 return VSXTernaryLogic<194> (a, b, c);
412 case 195:
413 return VSXTernaryLogic<195> (a, b, c);
414 case 196:
415 return VSXTernaryLogic<196> (a, b, c);
416 case 197:
417 return VSXTernaryLogic<197> (a, b, c);
418 case 198:
419 return VSXTernaryLogic<198> (a, b, c);
420 case 199:
421 return VSXTernaryLogic<199> (a, b, c);
422 case 200:
423 return VSXTernaryLogic<200> (a, b, c);
424 case 201:
425 return VSXTernaryLogic<201> (a, b, c);
426 case 202:
427 return VSXTernaryLogic<202> (a, b, c);
428 case 203:
429 return VSXTernaryLogic<203> (a, b, c);
430 case 204:
431 return VSXTernaryLogic<204> (a, b, c);
432 case 205:
433 return VSXTernaryLogic<205> (a, b, c);
434 case 206:
435 return VSXTernaryLogic<206> (a, b, c);
436 case 207:
437 return VSXTernaryLogic<207> (a, b, c);
438 case 208:
439 return VSXTernaryLogic<208> (a, b, c);
440 case 209:
441 return VSXTernaryLogic<209> (a, b, c);
442 case 210:
443 return VSXTernaryLogic<210> (a, b, c);
444 case 211:
445 return VSXTernaryLogic<211> (a, b, c);
446 case 212:
447 return VSXTernaryLogic<212> (a, b, c);
448 case 213:
449 return VSXTernaryLogic<213> (a, b, c);
450 case 214:
451 return VSXTernaryLogic<214> (a, b, c);
452 case 215:
453 return VSXTernaryLogic<215> (a, b, c);
454 case 216:
455 return VSXTernaryLogic<216> (a, b, c);
456 case 217:
457 return VSXTernaryLogic<217> (a, b, c);
458 case 218:
459 return VSXTernaryLogic<218> (a, b, c);
460 case 219:
461 return VSXTernaryLogic<219> (a, b, c);
462 case 220:
463 return VSXTernaryLogic<220> (a, b, c);
464 case 221:
465 return VSXTernaryLogic<221> (a, b, c);
466 case 222:
467 return VSXTernaryLogic<222> (a, b, c);
468 case 223:
469 return VSXTernaryLogic<223> (a, b, c);
470 case 224:
471 return VSXTernaryLogic<224> (a, b, c);
472 case 225:
473 return VSXTernaryLogic<225> (a, b, c);
474 case 226:
475 return VSXTernaryLogic<226> (a, b, c);
476 case 227:
477 return VSXTernaryLogic<227> (a, b, c);
478 case 228:
479 return VSXTernaryLogic<228> (a, b, c);
480 case 229:
481 return VSXTernaryLogic<229> (a, b, c);
482 case 230:
483 return VSXTernaryLogic<230> (a, b, c);
484 case 231:
485 return VSXTernaryLogic<231> (a, b, c);
486 case 232:
487 return VSXTernaryLogic<232> (a, b, c);
488 case 233:
489 return VSXTernaryLogic<233> (a, b, c);
490 case 234:
491 return VSXTernaryLogic<234> (a, b, c);
492 case 235:
493 return VSXTernaryLogic<235> (a, b, c);
494 case 236:
495 return VSXTernaryLogic<236> (a, b, c);
496 case 237:
497 return VSXTernaryLogic<237> (a, b, c);
498 case 238:
499 return VSXTernaryLogic<238> (a, b, c);
500 case 239:
501 return VSXTernaryLogic<239> (a, b, c);
502 case 240:
503 return VSXTernaryLogic<240> (a, b, c);
504 case 241:
505 return VSXTernaryLogic<241> (a, b, c);
506 case 242:
507 return VSXTernaryLogic<242> (a, b, c);
508 case 243:
509 return VSXTernaryLogic<243> (a, b, c);
510 case 244:
511 return VSXTernaryLogic<244> (a, b, c);
512 case 245:
513 return VSXTernaryLogic<245> (a, b, c);
514 case 246:
515 return VSXTernaryLogic<246> (a, b, c);
516 case 247:
517 return VSXTernaryLogic<247> (a, b, c);
518 case 248:
519 return VSXTernaryLogic<248> (a, b, c);
520 case 249:
521 return VSXTernaryLogic<249> (a, b, c);
522 case 250:
523 return VSXTernaryLogic<250> (a, b, c);
524 case 251:
525 return VSXTernaryLogic<251> (a, b, c);
526 case 252:
527 return VSXTernaryLogic<252> (a, b, c);
528 case 253:
529 return VSXTernaryLogic<253> (a, b, c);
530 case 254:
531 return VSXTernaryLogic<254> (a, b, c);
532 case 255:
533 return VSXTernaryLogic<255> (a, b, c);
534 default:
535 return a;
536 }
537 }
538
539 int
540 main (int argc, char **argv)
541 {
542 vector unsigned long long a = {0xD8, 0xDB};
543 vector unsigned long long b = {0x6C, 0x6C};
544 vector unsigned long long c = {0x56, 0x56};
545 vector unsigned long long ternlog_result = VSXTernaryLogic (a, b, c, 0xB6);
546
547 if (ternlog_result[0] != 0xffffffffffffff3dull
548 || ternlog_result[1] != 0xffffffffffffff3eull)
549 __builtin_abort ();
550
551 return 0;
552 }