Revert llvm-spirv change

Signed-off-by: gejin <[email protected]>

Author: jinge90

llvm-spirv/lib/SPIRV/SPIRVUtil.cpp

@@ -1531,34 +1531,10 @@ bool hasLoopMetadata(const Module *M) {
 // Returns true if type(s) and number of elements (if vector) is valid
 bool checkTypeForSPIRVExtendedInstLowering(IntrinsicInst *II, SPIRVModule *BM) {
   switch (II->getIntrinsicID()) {
-  case Intrinsic::ceil:
-  case Intrinsic::copysign:
-  case Intrinsic::cos:
-  case Intrinsic::exp:
-  case Intrinsic::exp2:
   case Intrinsic::fabs:
-  case Intrinsic::floor:
-  case Intrinsic::fma:
-  case Intrinsic::log:
-  case Intrinsic::log10:
-  case Intrinsic::log2:
-  case Intrinsic::maximum:
+  case Intrinsic::ceil:
   case Intrinsic::maxnum:
-  case Intrinsic::minimum:
-  case Intrinsic::minnum:
-  case Intrinsic::nearbyint:
-  case Intrinsic::pow:
-  case Intrinsic::powi:
-  case Intrinsic::rint:
-  case Intrinsic::round:
-  case Intrinsic::roundeven:
-  case Intrinsic::sin:
-  case Intrinsic::sqrt:
-  case Intrinsic::trunc: {
-    // Although some of the intrinsics above take multiple arguments, it is
-    // sufficient to check arg 0 because the LLVM Verifier will have checked
-    // that all floating point operands have the same type and the second
-    // argument of powi is i32.
+  case Intrinsic::nearbyint: {
     Type *Ty = II->getType();
     if (II->getArgOperand(0)->getType() != Ty)
       return false;

llvm-spirv/lib/SPIRV/SPIRVWriter.cpp

@@ -2067,33 +2067,12 @@ void addIntelFPGADecorationsForStructMember(SPIRVEntry *E,
 bool LLVMToSPIRV::isKnownIntrinsic(Intrinsic::ID Id) {
   // Known intrinsics usually do not need translation of their declaration
   switch (Id) {
-  case Intrinsic::abs:
   case Intrinsic::assume:
   case Intrinsic::bitreverse:
-  case Intrinsic::ceil:
-  case Intrinsic::copysign:
-  case Intrinsic::cos:
-  case Intrinsic::exp:
-  case Intrinsic::exp2:
-  case Intrinsic::fabs:
-  case Intrinsic::floor:
-  case Intrinsic::fma:
-  case Intrinsic::log:
-  case Intrinsic::log10:
-  case Intrinsic::log2:
-  case Intrinsic::maximum:
-  case Intrinsic::maxnum:
-  case Intrinsic::minimum:
-  case Intrinsic::minnum:
-  case Intrinsic::nearbyint:
-  case Intrinsic::pow:
-  case Intrinsic::powi:
-  case Intrinsic::rint:
-  case Intrinsic::round:
-  case Intrinsic::roundeven:
-  case Intrinsic::sin:
   case Intrinsic::sqrt:
-  case Intrinsic::trunc:
+  case Intrinsic::fabs:
+  case Intrinsic::abs:
+  case Intrinsic::ceil:
   case Intrinsic::ctpop:
   case Intrinsic::ctlz:
   case Intrinsic::cttz:
@@ -2116,6 +2095,7 @@ bool LLVMToSPIRV::isKnownIntrinsic(Intrinsic::ID Id) {
   case Intrinsic::fmuladd:
   case Intrinsic::memset:
   case Intrinsic::memcpy:
+  case Intrinsic::nearbyint:
   case Intrinsic::lifetime_start:
   case Intrinsic::lifetime_end:
   case Intrinsic::dbg_declare:
@@ -2152,69 +2132,6 @@ LLVMToSPIRV::applyRoundingModeConstraint(Value *V, SPIRVInstruction *I) {
   return I;
 }
 
-static SPIRVWord getBuiltinIdForIntrinsic(Intrinsic::ID IID) {
-  switch (IID) {
-  // Note: In some cases the semantics of the OpenCL builtin are not identical
-  //       to the semantics of the corresponding LLVM IR intrinsic. The LLVM
-  //       intrinsics handled here assume the default floating point environment
-  //       (no unmasked exceptions, round-to-nearest-ties-even rounding mode)
-  //       and assume that the operations have no side effects (FP status flags
-  //       aren't maintained), so the OpenCL builtin behavior should be
-  //       acceptable.
-  case Intrinsic::ceil:
-    return OpenCLLIB::Ceil;
-  case Intrinsic::copysign:
-    return OpenCLLIB::Copysign;
-  case Intrinsic::cos:
-    return OpenCLLIB::Cos;
-  case Intrinsic::exp:
-    return OpenCLLIB::Exp;
-  case Intrinsic::exp2:
-    return OpenCLLIB::Exp2;
-  case Intrinsic::fabs:
-    return OpenCLLIB::Fabs;
-  case Intrinsic::floor:
-    return OpenCLLIB::Floor;
-  case Intrinsic::fma:
-    return OpenCLLIB::Fma;
-  case Intrinsic::log:
-    return OpenCLLIB::Log;
-  case Intrinsic::log10:
-    return OpenCLLIB::Log10;
-  case Intrinsic::log2:
-    return OpenCLLIB::Log2;
-  case Intrinsic::maximum:
-    return OpenCLLIB::Fmax;
-  case Intrinsic::maxnum:
-    return OpenCLLIB::Fmax;
-  case Intrinsic::minimum:
-    return OpenCLLIB::Fmin;
-  case Intrinsic::minnum:
-    return OpenCLLIB::Fmin;
-  case Intrinsic::nearbyint:
-    return OpenCLLIB::Rint;
-  case Intrinsic::pow:
-    return OpenCLLIB::Pow;
-  case Intrinsic::powi:
-    return OpenCLLIB::Pown;
-  case Intrinsic::rint:
-    return OpenCLLIB::Rint;
-  case Intrinsic::round:
-    return OpenCLLIB::Round;
-  case Intrinsic::roundeven:
-    return OpenCLLIB::Rint;
-  case Intrinsic::sin:
-    return OpenCLLIB::Sin;
-  case Intrinsic::sqrt:
-    return OpenCLLIB::Sqrt;
-  case Intrinsic::trunc:
-    return OpenCLLIB::Trunc;
-  default:
-    assert(false && "Builtin ID requested for Unhandled intrinsic!");
-    return 0;
-  }
-}
-
 SPIRVValue *LLVMToSPIRV::transIntrinsicInst(IntrinsicInst *II,
                                             SPIRVBasicBlock *BB) {
   auto GetMemoryAccess = [](MemIntrinsic *MI) -> std::vector<SPIRVWord> {
@@ -2257,65 +2174,35 @@ SPIRVValue *LLVMToSPIRV::transIntrinsicInst(IntrinsicInst *II,
     SPIRVValue *Op = transValue(II->getArgOperand(0), BB);
     return BM->addUnaryInst(OpBitReverse, Ty, Op, BB);
   }
-  // Unary FP intrinsic
-  case Intrinsic::ceil:
-  case Intrinsic::cos:
-  case Intrinsic::exp:
-  case Intrinsic::exp2:
-  case Intrinsic::fabs:
-  case Intrinsic::floor:
-  case Intrinsic::log:
-  case Intrinsic::log10:
-  case Intrinsic::log2:
-  case Intrinsic::nearbyint:
-  case Intrinsic::rint:
-  case Intrinsic::round:
-  case Intrinsic::roundeven:
-  case Intrinsic::sin:
-  case Intrinsic::sqrt:
-  case Intrinsic::trunc: {
-    if (!checkTypeForSPIRVExtendedInstLowering(II, BM))
-      break;
-    SPIRVWord ExtOp = getBuiltinIdForIntrinsic(II->getIntrinsicID());
-    SPIRVType *STy = transType(II->getType());
-    std::vector<SPIRVValue *> Ops(1, transValue(II->getArgOperand(0), BB));
-    return BM->addExtInst(STy, BM->getExtInstSetId(SPIRVEIS_OpenCL), ExtOp, Ops,
-                          BB);
+  case Intrinsic::sqrt: {
+    return BM->addExtInst(transType(II->getType()),
+                          BM->getExtInstSetId(SPIRVEIS_OpenCL), OpenCLLIB::Sqrt,
+                          {transValue(II->getOperand(0), BB)}, BB);
   }
-  // Binary FP intrinsics
-  case Intrinsic::copysign:
-  case Intrinsic::pow:
-  case Intrinsic::powi:
-  case Intrinsic::maximum:
-  case Intrinsic::maxnum:
-  case Intrinsic::minimum:
-  case Intrinsic::minnum: {
+  case Intrinsic::fabs: {
     if (!checkTypeForSPIRVExtendedInstLowering(II, BM))
       break;
-    SPIRVWord ExtOp = getBuiltinIdForIntrinsic(II->getIntrinsicID());
+    SPIRVWord ExtOp = OpenCLLIB::Fabs;
     SPIRVType *STy = transType(II->getType());
-    std::vector<SPIRVValue *> Ops{transValue(II->getArgOperand(0), BB),
-                                  transValue(II->getArgOperand(1), BB)};
+    std::vector<SPIRVValue *> Ops(1, transValue(II->getArgOperand(0), BB));
     return BM->addExtInst(STy, BM->getExtInstSetId(SPIRVEIS_OpenCL), ExtOp, Ops,
                           BB);
   }
-  case Intrinsic::fma: {
+  case Intrinsic::abs: {
     if (!checkTypeForSPIRVExtendedInstLowering(II, BM))
       break;
-    SPIRVWord ExtOp = OpenCLLIB::Fma;
+    // LLVM has only one version of abs and it is only for signed integers. We
+    // unconditionally choose SAbs here
+    SPIRVWord ExtOp = OpenCLLIB::SAbs;
     SPIRVType *STy = transType(II->getType());
-    std::vector<SPIRVValue *> Ops{transValue(II->getArgOperand(0), BB),
-                                  transValue(II->getArgOperand(1), BB),
-                                  transValue(II->getArgOperand(2), BB)};
+    std::vector<SPIRVValue *> Ops(1, transValue(II->getArgOperand(0), BB));
     return BM->addExtInst(STy, BM->getExtInstSetId(SPIRVEIS_OpenCL), ExtOp, Ops,
                           BB);
   }
-  case Intrinsic::abs: {
+  case Intrinsic::ceil: {
     if (!checkTypeForSPIRVExtendedInstLowering(II, BM))
       break;
-    // LLVM has only one version of abs and it is only for signed integers. We
-    // unconditionally choose SAbs here
-    SPIRVWord ExtOp = OpenCLLIB::SAbs;
+    SPIRVWord ExtOp = OpenCLLIB::Ceil;
     SPIRVType *STy = transType(II->getType());
     std::vector<SPIRVValue *> Ops(1, transValue(II->getArgOperand(0), BB));
     return BM->addExtInst(STy, BM->getExtInstSetId(SPIRVEIS_OpenCL), ExtOp, Ops,
@@ -2457,6 +2344,16 @@ SPIRVValue *LLVMToSPIRV::transIntrinsicInst(IntrinsicInst *II,
     return BM->addBinaryInst(OpFAdd, Ty, Mul,
                              transValue(II->getArgOperand(2), BB), BB);
   }
+  case Intrinsic::maxnum: {
+    if (!checkTypeForSPIRVExtendedInstLowering(II, BM))
+      break;
+    SPIRVWord ExtOp = OpenCLLIB::Fmax;
+    SPIRVType *STy = transType(II->getType());
+    std::vector<SPIRVValue *> Ops{transValue(II->getArgOperand(0), BB),
+                                  transValue(II->getArgOperand(1), BB)};
+    return BM->addExtInst(STy, BM->getExtInstSetId(SPIRVEIS_OpenCL), ExtOp, Ops,
+                          BB);
+  }
   case Intrinsic::usub_sat: {
     // usub.sat(a, b) -> (a > b) ? a - b : 0
     SPIRVType *Ty = transType(II->getType());
@@ -2529,6 +2426,13 @@ SPIRVValue *LLVMToSPIRV::transIntrinsicInst(IntrinsicInst *II,
       Size = 0;
     return BM->addLifetimeInst(OC, transValue(II->getOperand(1), BB), Size, BB);
   }
+  case Intrinsic::nearbyint: {
+    if (!checkTypeForSPIRVExtendedInstLowering(II, BM))
+      break;
+    return BM->addExtInst(transType(II->getType()),
+                          BM->getExtInstSetId(SPIRVEIS_OpenCL), OpenCLLIB::Rint,
+                          {transValue(II->getOperand(0), BB)}, BB);
+  }
   // We don't want to mix translation of regular code and debug info, because
   // it creates a mess, therefore translation of debug intrinsics is
   // postponed until LLVMToSPIRVDbgTran::finalizeDebug...() methods.