@@ -6586,7 +6586,7 @@ (define_insn "xxeval"
(match_operand:QI 4 "u8bit_cint_operand" "n")]
UNSPEC_XXEVAL))]
"TARGET_POWER10"
- "xxeval %0,%1,%2,%3,%4"
+ "xxeval %x0,%x1,%x2,%x3,%4"
[(set_attr "type" "vecperm")
(set_attr "prefixed" "yes")])
new file mode 100644
@@ -0,0 +1,552 @@
+/* { dg-do run { target { power10_hw } } } */
+/* { dg-options "-O2 -mdejagnu-cpu=power10" } */
+
+#include <altivec.h>
+
+typedef unsigned char uint8_t;
+
+template <uint8_t kTernLogOp>
+static inline vector unsigned long long
+VSXTernaryLogic (vector unsigned long long a, vector unsigned long long b,
+ vector unsigned long long c)
+{
+ return vec_ternarylogic (a, b, c, kTernLogOp);
+}
+
+static vector unsigned long long
+VSXTernaryLogic (vector unsigned long long a, vector unsigned long long b,
+ vector unsigned long long c, int ternary_logic_op)
+{
+ switch (ternary_logic_op & 0xFF)
+ {
+ case 0:
+ return VSXTernaryLogic<0> (a, b, c);
+ case 1:
+ return VSXTernaryLogic<1> (a, b, c);
+ case 2:
+ return VSXTernaryLogic<2> (a, b, c);
+ case 3:
+ return VSXTernaryLogic<3> (a, b, c);
+ case 4:
+ return VSXTernaryLogic<4> (a, b, c);
+ case 5:
+ return VSXTernaryLogic<5> (a, b, c);
+ case 6:
+ return VSXTernaryLogic<6> (a, b, c);
+ case 7:
+ return VSXTernaryLogic<7> (a, b, c);
+ case 8:
+ return VSXTernaryLogic<8> (a, b, c);
+ case 9:
+ return VSXTernaryLogic<9> (a, b, c);
+ case 10:
+ return VSXTernaryLogic<10> (a, b, c);
+ case 11:
+ return VSXTernaryLogic<11> (a, b, c);
+ case 12:
+ return VSXTernaryLogic<12> (a, b, c);
+ case 13:
+ return VSXTernaryLogic<13> (a, b, c);
+ case 14:
+ return VSXTernaryLogic<14> (a, b, c);
+ case 15:
+ return VSXTernaryLogic<15> (a, b, c);
+ case 16:
+ return VSXTernaryLogic<16> (a, b, c);
+ case 17:
+ return VSXTernaryLogic<17> (a, b, c);
+ case 18:
+ return VSXTernaryLogic<18> (a, b, c);
+ case 19:
+ return VSXTernaryLogic<19> (a, b, c);
+ case 20:
+ return VSXTernaryLogic<20> (a, b, c);
+ case 21:
+ return VSXTernaryLogic<21> (a, b, c);
+ case 22:
+ return VSXTernaryLogic<22> (a, b, c);
+ case 23:
+ return VSXTernaryLogic<23> (a, b, c);
+ case 24:
+ return VSXTernaryLogic<24> (a, b, c);
+ case 25:
+ return VSXTernaryLogic<25> (a, b, c);
+ case 26:
+ return VSXTernaryLogic<26> (a, b, c);
+ case 27:
+ return VSXTernaryLogic<27> (a, b, c);
+ case 28:
+ return VSXTernaryLogic<28> (a, b, c);
+ case 29:
+ return VSXTernaryLogic<29> (a, b, c);
+ case 30:
+ return VSXTernaryLogic<30> (a, b, c);
+ case 31:
+ return VSXTernaryLogic<31> (a, b, c);
+ case 32:
+ return VSXTernaryLogic<32> (a, b, c);
+ case 33:
+ return VSXTernaryLogic<33> (a, b, c);
+ case 34:
+ return VSXTernaryLogic<34> (a, b, c);
+ case 35:
+ return VSXTernaryLogic<35> (a, b, c);
+ case 36:
+ return VSXTernaryLogic<36> (a, b, c);
+ case 37:
+ return VSXTernaryLogic<37> (a, b, c);
+ case 38:
+ return VSXTernaryLogic<38> (a, b, c);
+ case 39:
+ return VSXTernaryLogic<39> (a, b, c);
+ case 40:
+ return VSXTernaryLogic<40> (a, b, c);
+ case 41:
+ return VSXTernaryLogic<41> (a, b, c);
+ case 42:
+ return VSXTernaryLogic<42> (a, b, c);
+ case 43:
+ return VSXTernaryLogic<43> (a, b, c);
+ case 44:
+ return VSXTernaryLogic<44> (a, b, c);
+ case 45:
+ return VSXTernaryLogic<45> (a, b, c);
+ case 46:
+ return VSXTernaryLogic<46> (a, b, c);
+ case 47:
+ return VSXTernaryLogic<47> (a, b, c);
+ case 48:
+ return VSXTernaryLogic<48> (a, b, c);
+ case 49:
+ return VSXTernaryLogic<49> (a, b, c);
+ case 50:
+ return VSXTernaryLogic<50> (a, b, c);
+ case 51:
+ return VSXTernaryLogic<51> (a, b, c);
+ case 52:
+ return VSXTernaryLogic<52> (a, b, c);
+ case 53:
+ return VSXTernaryLogic<53> (a, b, c);
+ case 54:
+ return VSXTernaryLogic<54> (a, b, c);
+ case 55:
+ return VSXTernaryLogic<55> (a, b, c);
+ case 56:
+ return VSXTernaryLogic<56> (a, b, c);
+ case 57:
+ return VSXTernaryLogic<57> (a, b, c);
+ case 58:
+ return VSXTernaryLogic<58> (a, b, c);
+ case 59:
+ return VSXTernaryLogic<59> (a, b, c);
+ case 60:
+ return VSXTernaryLogic<60> (a, b, c);
+ case 61:
+ return VSXTernaryLogic<61> (a, b, c);
+ case 62:
+ return VSXTernaryLogic<62> (a, b, c);
+ case 63:
+ return VSXTernaryLogic<63> (a, b, c);
+ case 64:
+ return VSXTernaryLogic<64> (a, b, c);
+ case 65:
+ return VSXTernaryLogic<65> (a, b, c);
+ case 66:
+ return VSXTernaryLogic<66> (a, b, c);
+ case 67:
+ return VSXTernaryLogic<67> (a, b, c);
+ case 68:
+ return VSXTernaryLogic<68> (a, b, c);
+ case 69:
+ return VSXTernaryLogic<69> (a, b, c);
+ case 70:
+ return VSXTernaryLogic<70> (a, b, c);
+ case 71:
+ return VSXTernaryLogic<71> (a, b, c);
+ case 72:
+ return VSXTernaryLogic<72> (a, b, c);
+ case 73:
+ return VSXTernaryLogic<73> (a, b, c);
+ case 74:
+ return VSXTernaryLogic<74> (a, b, c);
+ case 75:
+ return VSXTernaryLogic<75> (a, b, c);
+ case 76:
+ return VSXTernaryLogic<76> (a, b, c);
+ case 77:
+ return VSXTernaryLogic<77> (a, b, c);
+ case 78:
+ return VSXTernaryLogic<78> (a, b, c);
+ case 79:
+ return VSXTernaryLogic<79> (a, b, c);
+ case 80:
+ return VSXTernaryLogic<80> (a, b, c);
+ case 81:
+ return VSXTernaryLogic<81> (a, b, c);
+ case 82:
+ return VSXTernaryLogic<82> (a, b, c);
+ case 83:
+ return VSXTernaryLogic<83> (a, b, c);
+ case 84:
+ return VSXTernaryLogic<84> (a, b, c);
+ case 85:
+ return VSXTernaryLogic<85> (a, b, c);
+ case 86:
+ return VSXTernaryLogic<86> (a, b, c);
+ case 87:
+ return VSXTernaryLogic<87> (a, b, c);
+ case 88:
+ return VSXTernaryLogic<88> (a, b, c);
+ case 89:
+ return VSXTernaryLogic<89> (a, b, c);
+ case 90:
+ return VSXTernaryLogic<90> (a, b, c);
+ case 91:
+ return VSXTernaryLogic<91> (a, b, c);
+ case 92:
+ return VSXTernaryLogic<92> (a, b, c);
+ case 93:
+ return VSXTernaryLogic<93> (a, b, c);
+ case 94:
+ return VSXTernaryLogic<94> (a, b, c);
+ case 95:
+ return VSXTernaryLogic<95> (a, b, c);
+ case 96:
+ return VSXTernaryLogic<96> (a, b, c);
+ case 97:
+ return VSXTernaryLogic<97> (a, b, c);
+ case 98:
+ return VSXTernaryLogic<98> (a, b, c);
+ case 99:
+ return VSXTernaryLogic<99> (a, b, c);
+ case 100:
+ return VSXTernaryLogic<100> (a, b, c);
+ case 101:
+ return VSXTernaryLogic<101> (a, b, c);
+ case 102:
+ return VSXTernaryLogic<102> (a, b, c);
+ case 103:
+ return VSXTernaryLogic<103> (a, b, c);
+ case 104:
+ return VSXTernaryLogic<104> (a, b, c);
+ case 105:
+ return VSXTernaryLogic<105> (a, b, c);
+ case 106:
+ return VSXTernaryLogic<106> (a, b, c);
+ case 107:
+ return VSXTernaryLogic<107> (a, b, c);
+ case 108:
+ return VSXTernaryLogic<108> (a, b, c);
+ case 109:
+ return VSXTernaryLogic<109> (a, b, c);
+ case 110:
+ return VSXTernaryLogic<110> (a, b, c);
+ case 111:
+ return VSXTernaryLogic<111> (a, b, c);
+ case 112:
+ return VSXTernaryLogic<112> (a, b, c);
+ case 113:
+ return VSXTernaryLogic<113> (a, b, c);
+ case 114:
+ return VSXTernaryLogic<114> (a, b, c);
+ case 115:
+ return VSXTernaryLogic<115> (a, b, c);
+ case 116:
+ return VSXTernaryLogic<116> (a, b, c);
+ case 117:
+ return VSXTernaryLogic<117> (a, b, c);
+ case 118:
+ return VSXTernaryLogic<118> (a, b, c);
+ case 119:
+ return VSXTernaryLogic<119> (a, b, c);
+ case 120:
+ return VSXTernaryLogic<120> (a, b, c);
+ case 121:
+ return VSXTernaryLogic<121> (a, b, c);
+ case 122:
+ return VSXTernaryLogic<122> (a, b, c);
+ case 123:
+ return VSXTernaryLogic<123> (a, b, c);
+ case 124:
+ return VSXTernaryLogic<124> (a, b, c);
+ case 125:
+ return VSXTernaryLogic<125> (a, b, c);
+ case 126:
+ return VSXTernaryLogic<126> (a, b, c);
+ case 127:
+ return VSXTernaryLogic<127> (a, b, c);
+ case 128:
+ return VSXTernaryLogic<128> (a, b, c);
+ case 129:
+ return VSXTernaryLogic<129> (a, b, c);
+ case 130:
+ return VSXTernaryLogic<130> (a, b, c);
+ case 131:
+ return VSXTernaryLogic<131> (a, b, c);
+ case 132:
+ return VSXTernaryLogic<132> (a, b, c);
+ case 133:
+ return VSXTernaryLogic<133> (a, b, c);
+ case 134:
+ return VSXTernaryLogic<134> (a, b, c);
+ case 135:
+ return VSXTernaryLogic<135> (a, b, c);
+ case 136:
+ return VSXTernaryLogic<136> (a, b, c);
+ case 137:
+ return VSXTernaryLogic<137> (a, b, c);
+ case 138:
+ return VSXTernaryLogic<138> (a, b, c);
+ case 139:
+ return VSXTernaryLogic<139> (a, b, c);
+ case 140:
+ return VSXTernaryLogic<140> (a, b, c);
+ case 141:
+ return VSXTernaryLogic<141> (a, b, c);
+ case 142:
+ return VSXTernaryLogic<142> (a, b, c);
+ case 143:
+ return VSXTernaryLogic<143> (a, b, c);
+ case 144:
+ return VSXTernaryLogic<144> (a, b, c);
+ case 145:
+ return VSXTernaryLogic<145> (a, b, c);
+ case 146:
+ return VSXTernaryLogic<146> (a, b, c);
+ case 147:
+ return VSXTernaryLogic<147> (a, b, c);
+ case 148:
+ return VSXTernaryLogic<148> (a, b, c);
+ case 149:
+ return VSXTernaryLogic<149> (a, b, c);
+ case 150:
+ return VSXTernaryLogic<150> (a, b, c);
+ case 151:
+ return VSXTernaryLogic<151> (a, b, c);
+ case 152:
+ return VSXTernaryLogic<152> (a, b, c);
+ case 153:
+ return VSXTernaryLogic<153> (a, b, c);
+ case 154:
+ return VSXTernaryLogic<154> (a, b, c);
+ case 155:
+ return VSXTernaryLogic<155> (a, b, c);
+ case 156:
+ return VSXTernaryLogic<156> (a, b, c);
+ case 157:
+ return VSXTernaryLogic<157> (a, b, c);
+ case 158:
+ return VSXTernaryLogic<158> (a, b, c);
+ case 159:
+ return VSXTernaryLogic<159> (a, b, c);
+ case 160:
+ return VSXTernaryLogic<160> (a, b, c);
+ case 161:
+ return VSXTernaryLogic<161> (a, b, c);
+ case 162:
+ return VSXTernaryLogic<162> (a, b, c);
+ case 163:
+ return VSXTernaryLogic<163> (a, b, c);
+ case 164:
+ return VSXTernaryLogic<164> (a, b, c);
+ case 165:
+ return VSXTernaryLogic<165> (a, b, c);
+ case 166:
+ return VSXTernaryLogic<166> (a, b, c);
+ case 167:
+ return VSXTernaryLogic<167> (a, b, c);
+ case 168:
+ return VSXTernaryLogic<168> (a, b, c);
+ case 169:
+ return VSXTernaryLogic<169> (a, b, c);
+ case 170:
+ return VSXTernaryLogic<170> (a, b, c);
+ case 171:
+ return VSXTernaryLogic<171> (a, b, c);
+ case 172:
+ return VSXTernaryLogic<172> (a, b, c);
+ case 173:
+ return VSXTernaryLogic<173> (a, b, c);
+ case 174:
+ return VSXTernaryLogic<174> (a, b, c);
+ case 175:
+ return VSXTernaryLogic<175> (a, b, c);
+ case 176:
+ return VSXTernaryLogic<176> (a, b, c);
+ case 177:
+ return VSXTernaryLogic<177> (a, b, c);
+ case 178:
+ return VSXTernaryLogic<178> (a, b, c);
+ case 179:
+ return VSXTernaryLogic<179> (a, b, c);
+ case 180:
+ return VSXTernaryLogic<180> (a, b, c);
+ case 181:
+ return VSXTernaryLogic<181> (a, b, c);
+ case 182:
+ return VSXTernaryLogic<182> (a, b, c);
+ case 183:
+ return VSXTernaryLogic<183> (a, b, c);
+ case 184:
+ return VSXTernaryLogic<184> (a, b, c);
+ case 185:
+ return VSXTernaryLogic<185> (a, b, c);
+ case 186:
+ return VSXTernaryLogic<186> (a, b, c);
+ case 187:
+ return VSXTernaryLogic<187> (a, b, c);
+ case 188:
+ return VSXTernaryLogic<188> (a, b, c);
+ case 189:
+ return VSXTernaryLogic<189> (a, b, c);
+ case 190:
+ return VSXTernaryLogic<190> (a, b, c);
+ case 191:
+ return VSXTernaryLogic<191> (a, b, c);
+ case 192:
+ return VSXTernaryLogic<192> (a, b, c);
+ case 193:
+ return VSXTernaryLogic<193> (a, b, c);
+ case 194:
+ return VSXTernaryLogic<194> (a, b, c);
+ case 195:
+ return VSXTernaryLogic<195> (a, b, c);
+ case 196:
+ return VSXTernaryLogic<196> (a, b, c);
+ case 197:
+ return VSXTernaryLogic<197> (a, b, c);
+ case 198:
+ return VSXTernaryLogic<198> (a, b, c);
+ case 199:
+ return VSXTernaryLogic<199> (a, b, c);
+ case 200:
+ return VSXTernaryLogic<200> (a, b, c);
+ case 201:
+ return VSXTernaryLogic<201> (a, b, c);
+ case 202:
+ return VSXTernaryLogic<202> (a, b, c);
+ case 203:
+ return VSXTernaryLogic<203> (a, b, c);
+ case 204:
+ return VSXTernaryLogic<204> (a, b, c);
+ case 205:
+ return VSXTernaryLogic<205> (a, b, c);
+ case 206:
+ return VSXTernaryLogic<206> (a, b, c);
+ case 207:
+ return VSXTernaryLogic<207> (a, b, c);
+ case 208:
+ return VSXTernaryLogic<208> (a, b, c);
+ case 209:
+ return VSXTernaryLogic<209> (a, b, c);
+ case 210:
+ return VSXTernaryLogic<210> (a, b, c);
+ case 211:
+ return VSXTernaryLogic<211> (a, b, c);
+ case 212:
+ return VSXTernaryLogic<212> (a, b, c);
+ case 213:
+ return VSXTernaryLogic<213> (a, b, c);
+ case 214:
+ return VSXTernaryLogic<214> (a, b, c);
+ case 215:
+ return VSXTernaryLogic<215> (a, b, c);
+ case 216:
+ return VSXTernaryLogic<216> (a, b, c);
+ case 217:
+ return VSXTernaryLogic<217> (a, b, c);
+ case 218:
+ return VSXTernaryLogic<218> (a, b, c);
+ case 219:
+ return VSXTernaryLogic<219> (a, b, c);
+ case 220:
+ return VSXTernaryLogic<220> (a, b, c);
+ case 221:
+ return VSXTernaryLogic<221> (a, b, c);
+ case 222:
+ return VSXTernaryLogic<222> (a, b, c);
+ case 223:
+ return VSXTernaryLogic<223> (a, b, c);
+ case 224:
+ return VSXTernaryLogic<224> (a, b, c);
+ case 225:
+ return VSXTernaryLogic<225> (a, b, c);
+ case 226:
+ return VSXTernaryLogic<226> (a, b, c);
+ case 227:
+ return VSXTernaryLogic<227> (a, b, c);
+ case 228:
+ return VSXTernaryLogic<228> (a, b, c);
+ case 229:
+ return VSXTernaryLogic<229> (a, b, c);
+ case 230:
+ return VSXTernaryLogic<230> (a, b, c);
+ case 231:
+ return VSXTernaryLogic<231> (a, b, c);
+ case 232:
+ return VSXTernaryLogic<232> (a, b, c);
+ case 233:
+ return VSXTernaryLogic<233> (a, b, c);
+ case 234:
+ return VSXTernaryLogic<234> (a, b, c);
+ case 235:
+ return VSXTernaryLogic<235> (a, b, c);
+ case 236:
+ return VSXTernaryLogic<236> (a, b, c);
+ case 237:
+ return VSXTernaryLogic<237> (a, b, c);
+ case 238:
+ return VSXTernaryLogic<238> (a, b, c);
+ case 239:
+ return VSXTernaryLogic<239> (a, b, c);
+ case 240:
+ return VSXTernaryLogic<240> (a, b, c);
+ case 241:
+ return VSXTernaryLogic<241> (a, b, c);
+ case 242:
+ return VSXTernaryLogic<242> (a, b, c);
+ case 243:
+ return VSXTernaryLogic<243> (a, b, c);
+ case 244:
+ return VSXTernaryLogic<244> (a, b, c);
+ case 245:
+ return VSXTernaryLogic<245> (a, b, c);
+ case 246:
+ return VSXTernaryLogic<246> (a, b, c);
+ case 247:
+ return VSXTernaryLogic<247> (a, b, c);
+ case 248:
+ return VSXTernaryLogic<248> (a, b, c);
+ case 249:
+ return VSXTernaryLogic<249> (a, b, c);
+ case 250:
+ return VSXTernaryLogic<250> (a, b, c);
+ case 251:
+ return VSXTernaryLogic<251> (a, b, c);
+ case 252:
+ return VSXTernaryLogic<252> (a, b, c);
+ case 253:
+ return VSXTernaryLogic<253> (a, b, c);
+ case 254:
+ return VSXTernaryLogic<254> (a, b, c);
+ case 255:
+ return VSXTernaryLogic<255> (a, b, c);
+ default:
+ return a;
+ }
+}
+
+int
+main (int argc, char **argv)
+{
+ vector unsigned long long a = {0xD8, 0xDB};
+ vector unsigned long long b = {0x6C, 0x6C};
+ vector unsigned long long c = {0x56, 0x56};
+ vector unsigned long long ternlog_result = VSXTernaryLogic (a, b, c, 0xB6);
+
+ if (ternlog_result[0] != 0xffffffffffffff3dull
+ || ternlog_result[1] != 0xffffffffffffff3eull)
+ __builtin_abort ();
+
+ return 0;
+}