Fix translation of APInt constants

MrSidims · vmaksimo · commit ff49e3448969 · 2020-10-06T14:44:56.000+03:00
Previously APInt constants were being stored into uint64_t value
with following encoding/decoding. Now they are being packed into
SPIRVWords array directly.

Signed-off-by: Dmitry Sidorov &lt;dmitry.sidorov@intel.com&gt;
diff --git a/llvm-spirv/lib/SPIRV/SPIRVReader.cpp b/llvm-spirv/lib/SPIRV/SPIRVReader.cpp
@@ -1497,10 +1497,27 @@ Value *SPIRVToLLVM::transValueWithoutDecoration(SPIRVValue *BV, Function *F,
     }
     switch (BT->getOpCode()) {
     case OpTypeBool:
-    case OpTypeInt:
+    case OpTypeInt: {
+      const unsigned NumBits = BT->getBitWidth();
+      if (NumBits > 64) {
+        // Translate arbitrary precision integer constants
+        const unsigned RawDataNumWords = BConst->getNumWords();
+        const unsigned BigValNumWords = (RawDataNumWords + 1) / 2;
+        std::vector<uint64_t> BigValVec(BigValNumWords);
+        const SPIRVWord *RawData = BConst->getSPIRVWords();
+        // SPIRV words are integers of 32-bit width, meanwhile llvm::APInt
+        // is storing data using an array of 64-bit words. Here we pack SPIRV
+        // words into 64-bit integer array.
+        for (size_t I = 0; I != RawDataNumWords; ++I)
+          BigValVec[I / 2] =
+              (I % 2) ? BigValVec[I / 2] | ((uint64_t)RawData[I] << 32)
+                      : BigValVec[I / 2] | ((uint64_t)RawData[I]);
+        return mapValue(BV, ConstantInt::get(LT, APInt(NumBits, BigValVec)));
+      }
       return mapValue(
           BV, ConstantInt::get(LT, ConstValue,
                                static_cast<SPIRVTypeInt *>(BT)->isSigned()));
+    }
     case OpTypeFloat: {
       const llvm::fltSemantics *FS = nullptr;
       switch (BT->getFloatBitWidth()) {
diff --git a/llvm-spirv/lib/SPIRV/SPIRVWriter.cpp b/llvm-spirv/lib/SPIRV/SPIRVWriter.cpp
@@ -684,8 +684,17 @@ SPIRVValue *LLVMToSPIRV::transConstant(Value *V) {
     return BM->addNullConstant(transType(AggType));
   }
 
-  if (auto ConstI = dyn_cast<ConstantInt>(V))
+  if (auto ConstI = dyn_cast<ConstantInt>(V)) {
+    unsigned BitWidth = ConstI->getType()->getBitWidth();
+    if (BitWidth > 64) {
+      BM->getErrorLog().checkError(
+          BM->isAllowedToUseExtension(
+              ExtensionID::SPV_INTEL_arbitrary_precision_integers),
+          SPIRVEC_InvalidBitWidth, std::to_string(BitWidth));
+      return BM->addConstant(transType(V->getType()), ConstI->getValue());
+    }
     return BM->addConstant(transType(V->getType()), ConstI->getZExtValue());
+  }
 
   if (auto ConstFP = dyn_cast<ConstantFP>(V)) {
     auto BT = static_cast<SPIRVType *>(transType(V->getType()));
diff --git a/llvm-spirv/lib/SPIRV/libSPIRV/SPIRVModule.cpp b/llvm-spirv/lib/SPIRV/libSPIRV/SPIRVModule.cpp
@@ -48,6 +48,8 @@
 #include "SPIRVType.h"
 #include "SPIRVValue.h"
 
+#include "llvm/ADT/APInt.h"
+
 #include <set>
 #include <unordered_map>
 #include <unordered_set>
@@ -261,6 +263,7 @@ class SPIRVModuleImpl : public SPIRVModule {
                                            SPIRVFunction *F) override;
   SPIRVValue *addConstant(SPIRVValue *) override;
   SPIRVValue *addConstant(SPIRVType *, uint64_t) override;
+  SPIRVValue *addConstant(SPIRVType *, llvm::APInt) override;
   SPIRVValue *addSpecConstant(SPIRVType *, uint64_t) override;
   SPIRVValue *addDoubleConstant(SPIRVTypeFloat *, double) override;
   SPIRVValue *addFloatConstant(SPIRVTypeFloat *, float) override;
@@ -1021,6 +1024,25 @@ SPIRVValue *SPIRVModuleImpl::addConstant(SPIRVType *Ty, uint64_t V) {
   return addConstant(new SPIRVConstant(this, Ty, getId(), V));
 }
 
+// Complete constructor for AP integer constant
+template <spv::Op OC>
+SPIRVConstantBase<OC>::SPIRVConstantBase(SPIRVModule *M, SPIRVType *TheType,
+                                         SPIRVId TheId, llvm::APInt &TheValue)
+    : SPIRVValue(M, 0, OC, TheType, TheId) {
+  const uint64_t *BigValArr = TheValue.getRawData();
+  for (size_t I = 0; I != TheValue.getNumWords(); ++I) {
+    Union.Words[I * 2 + 1] =
+        (uint32_t)((BigValArr[I] & 0xFFFFFFFF00000000LL) >> 32);
+    Union.Words[I * 2] = (uint32_t)(BigValArr[I] & 0xFFFFFFFFLL);
+  }
+  recalculateWordCount();
+  validate();
+}
+
+SPIRVValue *SPIRVModuleImpl::addConstant(SPIRVType *Ty, llvm::APInt V) {
+  return addConstant(new SPIRVConstant(this, Ty, getId(), V));
+}
+
 SPIRVValue *SPIRVModuleImpl::addIntegerConstant(SPIRVTypeInt *Ty, uint64_t V) {
   if (Ty->getBitWidth() == 32) {
     unsigned I32 = static_cast<unsigned>(V);
diff --git a/llvm-spirv/lib/SPIRV/libSPIRV/SPIRVModule.h b/llvm-spirv/lib/SPIRV/libSPIRV/SPIRVModule.h
@@ -48,6 +48,10 @@
 #include <string>
 #include <vector>
 
+namespace llvm {
+class APInt;
+} // namespace llvm
+
 namespace SPIRV {
 
 template <Op> class SPIRVConstantBase;
@@ -252,6 +256,7 @@ class SPIRVModule {
                                                    SPIRVFunction *F) = 0;
   virtual SPIRVValue *addConstant(SPIRVValue *) = 0;
   virtual SPIRVValue *addConstant(SPIRVType *, uint64_t) = 0;
+  virtual SPIRVValue *addConstant(SPIRVType *, llvm::APInt) = 0;
   virtual SPIRVValue *addSpecConstant(SPIRVType *, uint64_t) = 0;
   virtual SPIRVValue *addDoubleConstant(SPIRVTypeFloat *, double) = 0;
   virtual SPIRVValue *addFloatConstant(SPIRVTypeFloat *, float) = 0;
diff --git a/llvm-spirv/lib/SPIRV/libSPIRV/SPIRVType.h b/llvm-spirv/lib/SPIRV/libSPIRV/SPIRVType.h
@@ -185,7 +185,7 @@ class SPIRVTypeInt : public SPIRVType {
            (BitWidth <= 64 ||
             (Module->isAllowedToUseExtension(
                  ExtensionID::SPV_INTEL_arbitrary_precision_integers) &&
-             BitWidth <= 1024)) &&
+             BitWidth <= 2048)) &&
            "Invalid bit width");
   }
 
diff --git a/llvm-spirv/lib/SPIRV/libSPIRV/SPIRVValue.h b/llvm-spirv/lib/SPIRV/libSPIRV/SPIRVValue.h
@@ -47,6 +47,10 @@
 #include "SPIRVEntry.h"
 #include "SPIRVType.h"
 
+namespace llvm {
+class APInt;
+} // namespace llvm
+
 #include <iostream>
 
 namespace SPIRV {
@@ -146,6 +150,9 @@ template <spv::Op OC> class SPIRVConstantBase : public SPIRVValue {
     recalculateWordCount();
     validate();
   }
+  // Incomplete constructor for AP integer constant
+  SPIRVConstantBase(SPIRVModule *M, SPIRVType *TheType, SPIRVId TheId,
+                    llvm::APInt &TheValue);
   // Complete constructor for float constant
   SPIRVConstantBase(SPIRVModule *M, SPIRVType *TheType, SPIRVId TheId,
                     float TheValue)
@@ -167,6 +174,8 @@ template <spv::Op OC> class SPIRVConstantBase : public SPIRVValue {
   uint64_t getZExtIntValue() const { return Union.UInt64Val; }
   float getFloatValue() const { return Union.FloatVal; }
   double getDoubleValue() const { return Union.DoubleVal; }
+  unsigned getNumWords() const { return NumWords; }
+  SPIRVWord *getSPIRVWords() { return Union.Words; }
 
 protected:
   void recalculateWordCount() {
@@ -175,7 +184,7 @@ template <spv::Op OC> class SPIRVConstantBase : public SPIRVValue {
   }
   void validate() const override {
     SPIRVValue::validate();
-    assert(NumWords >= 1 && NumWords <= 32 && "Invalid constant size");
+    assert(NumWords >= 1 && NumWords <= 64 && "Invalid constant size");
   }
   void encode(spv_ostream &O) const override {
     getEncoder(O) << Type << Id;
@@ -197,7 +206,7 @@ template <spv::Op OC> class SPIRVConstantBase : public SPIRVValue {
     uint64_t UInt64Val;
     float FloatVal;
     double DoubleVal;
-    SPIRVWord Words[32];
+    SPIRVWord Words[64];
     UnionType() { UInt64Val = 0; }
   } Union;
 };
diff --git a/llvm-spirv/test/capability-arbitrary-precision-integers.ll b/llvm-spirv/test/capability-arbitrary-precision-integers.ll
@@ -18,11 +18,11 @@
 ; CHECK-SPIRV-DAG: TypeInt [[#I96:]] 96 0
 ; CHECK-SPIRV-DAG: TypeInt [[#I128:]] 128 0
 ; CHECK-SPIRV-DAG: TypeInt [[#I256:]] 256 0
-; CHECK-SPIRV-DAG: TypeInt [[#I1024:]] 1024 0
-; CHECK-SPIRV-DAG: Constant [[#I96]] [[#]] 1 0 0
+; CHECK-SPIRV-DAG: TypeInt [[#I2048:]] 2048 0
+; CHECK-SPIRV-DAG: Constant [[#I96]] [[#]] 4 0 1
 ; CHECK-SPIRV-DAG: Constant [[#I128]] [[#]] 1 0 0 0
 ; CHECK-SPIRV-DAG: Constant [[#I256]] [[#]] 1 0 0 0 0 0 0 0
-; CHECK-SPIRV-DAG: Constant [[#I1024]] [[#]] 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+; CHECK-SPIRV-DAG: Constant [[#I2048]] [[#]] 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
 
 target datalayout = "e-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024"
 target triple = "spir64-unknown-unknown"
@@ -36,7 +36,7 @@ target triple = "spir64-unknown-unknown"
 @d = addrspace(1) global i96 0, align 8
 @e = addrspace(1) global i128 0, align 8
 @f = addrspace(1) global i256 0, align 8
-@g = addrspace(1) global i1024 0, align 8
+@g = addrspace(1) global i2048 0, align 8
 
 ; Function Attrs: noinline nounwind optnone
 ; CHECK-LLVM: void @_Z4funci(i30 %a)
@@ -50,13 +50,13 @@ entry:
   store i30 1, i30* %a.addr, align 4
 ; CHECK-LLVM: store i48 -4294901761, i48 addrspace(1)* @c
   store i48 -4294901761, i48 addrspace(1)* @c, align 8
-  store i96 1, i96 addrspace(1)* @d, align 8
-; CHECK-LLVM: store i96 1, i96 addrspace(1)* @d
+  store i96 18446744073709551620, i96 addrspace(1)* @d, align 8
+; CHECK-LLVM: store i96 18446744073709551620, i96 addrspace(1)* @d
   store i128 1, i128 addrspace(1)* @e, align 8
 ; CHECK-LLVM: store i128 1, i128 addrspace(1)* @e
   store i256 1, i256 addrspace(1)* @f, align 8
 ; CHECK-LLVM: store i256 1, i256 addrspace(1)* @f
-  store i1024 1, i1024 addrspace(1)* @g, align 8
-; CHECK-LLVM: store i1024 1, i1024 addrspace(1)* @g
+  store i2048 1, i2048 addrspace(1)* @g, align 8
+; CHECK-LLVM: store i2048 1, i2048 addrspace(1)* @g
   ret void
 }

Original file line number	Diff line number	Diff line change
`@@ -185,7 +185,7 @@ class SPIRVTypeInt : public SPIRVType {`
`185`	`185`	`(BitWidth <= 64 \|\|`
`186`	`186`	`(Module->isAllowedToUseExtension(`
`187`	`187`	`ExtensionID::SPV_INTEL_arbitrary_precision_integers) &&`
`188`		`- BitWidth <= 1024)) &&`
	`188`	`+ BitWidth <= 2048)) &&`
`189`	`189`	`"Invalid bit width");`
`190`	`190`	`}`
`191`	`191`