Changeset 4303 for parabix-LLVM


Ignore:
Timestamp:
Nov 12, 2014, 6:39:42 PM (5 years ago)
Author:
linmengl
Message:

Full support of 256-bit long stream shift: simd<256>::dslli<n>

Location:
parabix-LLVM/llvm_git
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • parabix-LLVM/llvm_git/lib/Target/X86/X86ParabixISelLowering.cpp

    r4295 r4303  
    12371237         "PXPerformLogic only works for AND / OR / XOR");
    12381238
     1239  /* Support for simd<128>::dslli<n>(A, B): long shift left for A, with shift-in bits in B
     1240   * Pattern: OR(SHL(i128 A, n), SHR(i128 B, 128 - n))
     1241   */
    12391242  if (N->getOpcode() == ISD::OR && VT == MVT::i128 &&
    12401243     ((V1.getOpcode() == ISD::SHL && V2.getOpcode() == ISD::SRL) ||
    12411244      (V1.getOpcode() == ISD::SRL && V2.getOpcode() == ISD::SHL))) {
    1242     //possibly its advance with carry
     1245    //possibly it's advance with carry
    12431246    //now check if the shl amount + shr amount is 128
    12441247    if (V1.getOpcode() != ISD::SHL) {
     
    12741277  }
    12751278
     1279  /* Support for simd<256>::dslli<n>(A, B): long shift left for A, with shift-in bits in B
     1280   * Pattern: OR(SHL(i256 A, n), SHR(i256 B, 256 - n))
     1281   */
     1282  if (N->getOpcode() == ISD::OR && VT == MVT::i256 &&
     1283     ((V1.getOpcode() == ISD::SHL && V2.getOpcode() == ISD::SRL) ||
     1284      (V1.getOpcode() == ISD::SRL && V2.getOpcode() == ISD::SHL))) {
     1285    //possibly it's advance with carry
     1286    //now check if the shl amount + shr amount is 256
     1287    if (V1.getOpcode() != ISD::SHL) {
     1288      std::swap(V1, V2);
     1289    }
     1290
     1291    int immLeft, immRight;
     1292    if (isImmediateShiftingMask(V1.getOperand(1), immLeft) &&
     1293        isImmediateShiftingMask(V2.getOperand(1), immRight))
     1294    {
     1295      if (immLeft + immRight == 256) {
     1296        //finally, it is advance with carry
     1297        SDValue A = b.BITCAST(V1.getOperand(0), MVT::v4i64);
     1298        SDValue B = b.BITCAST(V2.getOperand(0), MVT::v4i64);
     1299
     1300        if (immLeft < 64) {
     1301          int pool[] = {3, 4, 5, 6};
     1302          SDValue C = b.VECTOR_SHUFFLE(B, A, pool);
     1303
     1304          SDValue D = b.SHL(immLeft, A);
     1305          SDValue E = b.SRL(64 - immLeft, C);
     1306          SDValue R = b.OR(D, E);
     1307          return b.BITCAST(R, VT);
     1308        }
     1309        else if (immLeft >= 64 && immLeft < 128)
     1310        {
     1311          int apool[] = {3, 4, 5, 6};
     1312          SDValue NA = b.VECTOR_SHUFFLE(B, A, apool);
     1313
     1314          int pool[] = {2, 3, 4, 5};
     1315          SDValue C = b.VECTOR_SHUFFLE(B, A, pool);
     1316
     1317          SDValue D = b.SHL(immLeft - 64, NA);
     1318          SDValue E = b.SRL(128 - immLeft, C);
     1319          SDValue R = b.OR(D, E);
     1320          return b.BITCAST(R, VT);
     1321        }
     1322        else if (immLeft >= 128 && immLeft < 192)
     1323        {
     1324          int apool[] = {2, 3, 4, 5};
     1325          SDValue NA = b.VECTOR_SHUFFLE(B, A, apool);
     1326
     1327          int pool[] = {1, 2, 3, 4};
     1328          SDValue C = b.VECTOR_SHUFFLE(B, A, pool);
     1329
     1330          SDValue D = b.SHL(immLeft - 128, NA);
     1331          SDValue E = b.SRL(192 - immLeft, C);
     1332          SDValue R = b.OR(D, E);
     1333
     1334          return b.BITCAST(R, VT);
     1335        }
     1336        else
     1337        {
     1338          //immLeft >= 192 && immLeft <= 256
     1339          int apool[] = {1, 2, 3, 4};
     1340          A = b.VECTOR_SHUFFLE(B, A, apool);
     1341
     1342          SDValue D = b.SHL(immLeft - 192, A);
     1343          SDValue E = b.SRL(256 - immLeft, B);
     1344          SDValue R = b.OR(D, E);
     1345
     1346          return b.BITCAST(R, VT);
     1347        }
     1348      }
     1349    }
     1350  }
     1351
    12761352  if (VT == MVT::i128 && Subtarget->hasSSE2()) {
    12771353    return b.BITCAST(DAG.getNode(N->getOpcode(), dl, MVT::v2i64,
  • parabix-LLVM/llvm_git/test/Parabix/i256.ll

    r4295 r4303  
    4848  ret <4 x i64> %sum3
    4949}
     50
     51define <4 x i64> @dslli(<4 x i64> %a, <4 x i64> %b) {
     52entry:
     53  ;CHECK-LABEL: dslli
     54  %aa = bitcast <4 x i64> %a to i256
     55  %bb = bitcast <4 x i64> %b to i256
     56
     57  %a1 = shl i256 %aa, 1
     58  %b1 = lshr i256 %bb, 255
     59  %cc = or i256 %a1, %b1
     60
     61  %c = bitcast i256 %cc to <4 x i64>
     62  ret <4 x i64> %c
     63}
Note: See TracChangeset for help on using the changeset viewer.