| 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 |
} |