Sync with SPIRV-LLVM-Translator 55f2041f2c

llvm-spirv/include/LLVMSPIRVLib.h

@@ -79,7 +79,7 @@ bool isSpirvBinary(std::string &Img);
 bool convertSpirv(std::istream &IS, std::ostream &OS, std::string &ErrMsg,
                   bool FromText, bool ToText);
 
-/// \brief Convert SPIR-V between binary and internel text formats.
+/// \brief Convert SPIR-V between binary and internal text formats.
 /// This function is not thread safe and should not be used in multi-thread
 /// applications unless guarded by a critical section.
 bool convertSpirv(std::string &Input, std::string &Out, std::string &ErrMsg,
@@ -93,11 +93,11 @@ bool isSpirvText(std::string &Img);
 
 namespace llvm {
 
-/// \brief Translate LLVM module to SPIRV and write to ostream.
+/// \brief Translate LLVM module to SPIR-V and write to ostream.
 /// \returns true if succeeds.
 bool writeSpirv(Module *M, std::ostream &OS, std::string &ErrMsg);
 
-/// \brief Load SPIRV from istream and translate to LLVM module.
+/// \brief Load SPIR-V from istream and translate to LLVM module.
 /// \returns true if succeeds.
 bool readSpirv(LLVMContext &C, std::istream &IS, Module *&M,
                std::string &ErrMsg);

llvm-spirv/lib/SPIRV/OCL20ToSPIRV.cpp

@@ -1111,7 +1111,7 @@ void OCL20ToSPIRV::visitCallReadImageWithSampler(
           assert(0 && "read_image* with unhandled number of args!");
         }
 
-        // SPIR-V intruction always returns 4-element vector
+        // SPIR-V instruction always returns 4-element vector
         if (IsRetScalar)
           Ret = VectorType::get(Ret, 4);
         return getSPIRVFuncName(OpImageSampleExplicitLod,
@@ -1687,13 +1687,14 @@ void OCL20ToSPIRV::visitSubgroupImageMediaBlockINTEL(
   spv::Op OpCode = DemangledName.rfind("read") != std::string::npos
                        ? spv::OpSubgroupImageMediaBlockReadINTEL
                        : spv::OpSubgroupImageMediaBlockWriteINTEL;
-  mutateCallInstSPIRV(M, CI,
-                      [=](CallInst *, std::vector<Value *> &Args) {
-                        // Moving the last argument to the begining.
-                        std::rotate(Args.begin(), Args.end() - 1, Args.end());
-                        return getSPIRVFuncName(OpCode, CI->getType());
-                      },
-                      &Attrs);
+  mutateCallInstSPIRV(
+      M, CI,
+      [=](CallInst *, std::vector<Value *> &Args) {
+        // Moving the last argument to the beginning.
+        std::rotate(Args.begin(), Args.end() - 1, Args.end());
+        return getSPIRVFuncName(OpCode, CI->getType());
+      },
+      &Attrs);
 }
 
 static const char *getSubgroupAVCIntelOpKind(const std::string &Name) {

llvm-spirv/lib/SPIRV/SPIRVInternal.h

@@ -184,6 +184,7 @@ enum SPIRAddressSpace {
   SPIRAS_Local,
   SPIRAS_Generic,
   SPIRAS_Input,
+  SPIRAS_Output,
   SPIRAS_Count,
 };
 

llvm-spirv/lib/SPIRV/SPIRVReader.cpp

@@ -2202,6 +2202,10 @@ void generateIntelFPGAAnnotation(const SPIRVEntry *E,
     Out << "{numbanks:" << Result << '}';
   if (E->hasDecorate(DecorationMaxconcurrencyINTEL, 0, &Result))
     Out << "{max_concurrency:" << Result << '}';
+  if (E->hasDecorate(DecorationSinglepumpINTEL))
+    Out << "{pump:1}";
+  if (E->hasDecorate(DecorationDoublepumpINTEL))
+    Out << "{pump:2}";
 }
 
 void generateIntelFPGAAnnotationForStructMember(
@@ -2224,6 +2228,10 @@ void generateIntelFPGAAnnotationForStructMember(
   if (E->hasMemberDecorate(DecorationMaxconcurrencyINTEL, 0, MemberNumber,
                            &Result))
     Out << "{max_concurrency:" << Result << '}';
+  if (E->hasMemberDecorate(DecorationSinglepumpINTEL, 0, MemberNumber))
+    Out << "{pump:1}";
+  if (E->hasMemberDecorate(DecorationDoublepumpINTEL, 0, MemberNumber))
+    Out << "{pump:2}";
 }
 
 void SPIRVToLLVM::transIntelFPGADecorations(SPIRVValue *BV, Value *V) {
@@ -2904,6 +2912,7 @@ bool llvm::readSpirv(LLVMContext &C, std::istream &IS, Module *&M,
 
   IS >> *BM;
   if (!BM->isModuleValid()) {
+    BM->getError(ErrMsg);
     M = nullptr;
     return false;
   }

llvm-spirv/lib/SPIRV/SPIRVToOCL20.cpp

@@ -77,7 +77,7 @@ class SPIRVToOCL20 : public ModulePass, public InstVisitor<SPIRVToOCL20> {
   // appropriate calls to conversion built-ins defined by the standards.
   void visitCastInst(CastInst &CI);
 
-  /// Transform __spirv_ImageQuerySize[Lod] into vector of the same lenght
+  /// Transform __spirv_ImageQuerySize[Lod] into vector of the same length
   /// containing {[get_image_width | get_image_dim], get_image_array_size}
   /// for all images except image1d_t which is always converted into
   /// get_image_width returning scalar result.

llvm-spirv/lib/SPIRV/SPIRVUtil.cpp

@@ -1210,7 +1210,7 @@ Type *getSPIRVTypeByChangeBaseTypeName(Module *M, Type *T, StringRef OldName,
   if (isSPIRVType(T, OldName, &Postfixes))
     return getOrCreateOpaquePtrType(M, getSPIRVTypeName(NewName, Postfixes));
   LLVM_DEBUG(dbgs() << " Invalid SPIR-V type " << *T << '\n');
-  llvm_unreachable("Invalid SPIRV-V type");
+  llvm_unreachable("Invalid SPIR-V type");
   return nullptr;
 }
 

llvm-spirv/lib/SPIRV/SPIRVWriter.cpp

@@ -128,6 +128,7 @@ LLVMToSPIRV::LLVMToSPIRV(SPIRVModule *SMod)
 
 bool LLVMToSPIRV::runOnModule(Module &Mod) {
   M = &Mod;
+  CG = make_unique<CallGraph>(Mod);
   Ctx = &M->getContext();
   DbgTran->setModule(M);
   assert(BM && "SPIR-V module not initialized");
@@ -1127,16 +1128,25 @@ parseAnnotations(StringRef AnnotatedCode) {
     StringRef AnnotatedDecoration = AnnotatedCode.substr(From + 1, To - 1);
     std::pair<StringRef, StringRef> D = AnnotatedDecoration.split(':');
 
-    StringRef F = D.first;
-    Decoration Dec =
-        llvm::StringSwitch<Decoration>(F)
-            .Case("memory", DecorationMemoryINTEL)
-            .Case("register", DecorationRegisterINTEL)
-            .Case("numbanks", DecorationNumbanksINTEL)
-            .Case("bankwidth", DecorationBankwidthINTEL)
-            .Case("max_concurrency", DecorationMaxconcurrencyINTEL);
+    StringRef F = D.first, S = D.second;
+    StringRef Value;
+    Decoration Dec;
+    if (F == "pump") {
+      Dec = llvm::StringSwitch<Decoration>(S)
+                .Case("1", DecorationSinglepumpINTEL)
+                .Case("2", DecorationDoublepumpINTEL);
+    } else if (F == "register") {
+      Dec = DecorationRegisterINTEL;
+    } else {
+      Dec = llvm::StringSwitch<Decoration>(F)
+                .Case("memory", DecorationMemoryINTEL)
+                .Case("numbanks", DecorationNumbanksINTEL)
+                .Case("bankwidth", DecorationBankwidthINTEL)
+                .Case("max_concurrency", DecorationMaxconcurrencyINTEL);
+      Value = S;
+    }
 
-    Decorates.push_back({Dec, D.second});
+    Decorates.push_back({Dec, Value});
     AnnotatedCode = AnnotatedCode.drop_front(To + 1);
   }
   return Decorates;
@@ -1146,12 +1156,25 @@ void addIntelFPGADecorations(
     SPIRVEntry *E,
     std::vector<std::pair<Decoration, std::string>> &Decorations) {
   for (const auto &I : Decorations) {
-    if (I.first == DecorationMemoryINTEL)
+    switch (I.first) {
+    case DecorationMemoryINTEL:
       E->addDecorate(new SPIRVDecorateMemoryINTELAttr(E, I.second));
-    else {
+      break;
+    case DecorationRegisterINTEL:
+    case DecorationSinglepumpINTEL:
+    case DecorationDoublepumpINTEL:
+      assert(I.second.empty());
+      E->addDecorate(I.first);
+      break;
+    // The rest of IntelFPGA decorations:
+    // DecorationNumbanksINTEL
+    // DecorationBankwidthINTEL
+    // DecorationMaxconcurrencyINTEL
+    default:
       SPIRVWord Result = 0;
       StringRef(I.second).getAsInteger(10, Result);
       E->addDecorate(I.first, Result);
+      break;
     }
   }
 }
@@ -1160,13 +1183,26 @@ void addIntelFPGADecorationsForStructMember(
     SPIRVEntry *E, SPIRVWord MemberNumber,
     std::vector<std::pair<Decoration, std::string>> &Decorations) {
   for (const auto &I : Decorations) {
-    if (I.first == DecorationMemoryINTEL)
+    switch (I.first) {
+    case DecorationMemoryINTEL:
       E->addMemberDecorate(
           new SPIRVMemberDecorateMemoryINTELAttr(E, MemberNumber, I.second));
-    else {
+      break;
+    case DecorationRegisterINTEL:
+    case DecorationSinglepumpINTEL:
+    case DecorationDoublepumpINTEL:
+      assert(I.second.empty());
+      E->addMemberDecorate(MemberNumber, I.first);
+      break;
+    // The rest of IntelFPGA decorations:
+    // DecorationNumbanksINTEL
+    // DecorationBankwidthINTEL
+    // DecorationMaxconcurrencyINTEL
+    default:
       SPIRVWord Result = 0;
       StringRef(I.second).getAsInteger(10, Result);
       E->addMemberDecorate(MemberNumber, I.first, Result);
+      break;
     }
   }
 }
@@ -1177,6 +1213,14 @@ SPIRVValue *LLVMToSPIRV::transIntrinsicInst(IntrinsicInst *II,
     std::vector<SPIRVWord> MemoryAccess(1, MemoryAccessMaskNone);
     if (SPIRVWord AlignVal = MI->getDestAlignment()) {
       MemoryAccess[0] |= MemoryAccessAlignedMask;
+      if (auto MTI = dyn_cast<MemTransferInst>(MI)) {
+        SPIRVWord SourceAlignVal = MTI->getSourceAlignment();
+        assert(SourceAlignVal && "Missed Source alignment!");
+
+        // In a case when alignment of source differs from dest one
+        // least value is guaranteed anyway.
+        AlignVal = std::min(AlignVal, SourceAlignVal);
+      }
       MemoryAccess.push_back(AlignVal);
     }
     if (MI->isVolatile())
@@ -1233,9 +1277,6 @@ SPIRVValue *LLVMToSPIRV::transIntrinsicInst(IntrinsicInst *II,
                                       GetMemoryAccess(MSI), BB);
   } break;
   case Intrinsic::memcpy:
-    assert(cast<MemCpyInst>(II)->getSourceAlignment() ==
-               cast<MemCpyInst>(II)->getDestAlignment() &&
-           "Alignment mismatch!");
     return BM->addCopyMemorySizedInst(
         transValue(II->getOperand(0), BB), transValue(II->getOperand(1), BB),
         transValue(II->getOperand(2), BB),
@@ -1417,6 +1458,59 @@ bool LLVMToSPIRV::transGlobalVariables() {
   return true;
 }
 
+bool LLVMToSPIRV::isAnyFunctionReachableFromFunction(
+    const Function *FS,
+    const std::unordered_set<const Function *> Funcs) const {
+  std::unordered_set<const Function *> Done;
+  std::unordered_set<const Function *> ToDo;
+  ToDo.insert(FS);
+
+  while (!ToDo.empty()) {
+    auto It = ToDo.begin();
+    const Function *F = *It;
+
+    if (Funcs.find(F) != Funcs.end())
+      return true;
+
+    ToDo.erase(It);
+    Done.insert(F);
+
+    const CallGraphNode *FN = (*CG)[F];
+    for (unsigned I = 0; I < FN->size(); ++I) {
+      const CallGraphNode *NN = (*FN)[I];
+      const Function *NNF = NN->getFunction();
+      if (!NNF)
+        continue;
+      if (Done.find(NNF) == Done.end()) {
+        ToDo.insert(NNF);
+      }
+    }
+  }
+
+  return false;
+}
+
+void LLVMToSPIRV::collectInputOutputVariables(SPIRVFunction *SF, Function *F) {
+  for (auto &GV : M->globals()) {
+    const auto AS = GV.getAddressSpace();
+    if (AS != SPIRAS_Input && AS != SPIRAS_Output)
+      continue;
+
+    std::unordered_set<const Function *> Funcs;
+
+    for (const auto &U : GV.uses()) {
+      const Instruction *Inst = dyn_cast<Instruction>(U.getUser());
+      if (!Inst)
+        continue;
+      Funcs.insert(Inst->getFunction());
+    }
+
+    if (isAnyFunctionReachableFromFunction(F, Funcs)) {
+      SF->addVariable(ValueMap[&GV]);
+    }
+  }
+}
+
 void LLVMToSPIRV::mutateFuncArgType(
     const std::map<unsigned, Type *> &ChangedType, Function *F) {
   for (auto &I : ChangedType) {
@@ -1458,6 +1552,9 @@ void LLVMToSPIRV::transFunction(Function *I) {
     BF->addExecutionMode(BF->getModule()->add(
         new SPIRVExecutionMode(BF, spv::ExecutionModeContractionOff)));
   }
+  if (BF->getModule()->isEntryPoint(spv::ExecutionModelKernel, BF->getId())) {
+    collectInputOutputVariables(BF, I);
+  }
 }
 
 bool LLVMToSPIRV::translate() {

llvm-spirv/lib/SPIRV/SPIRVWriter.h

@@ -57,6 +57,7 @@
 #include "SPIRVUtil.h"
 #include "SPIRVValue.h"
 
+#include "llvm/Analysis/CallGraph.h"
 #include "llvm/IR/IntrinsicInst.h"
 
 #include <memory>
@@ -128,6 +129,7 @@ class LLVMToSPIRV : public ModulePass {
   SPIRVWord SrcLang;
   SPIRVWord SrcLangVer;
   std::unique_ptr<LLVMToSPIRVDbgTran> DbgTran;
+  std::unique_ptr<CallGraph> CG;
 
   SPIRVType *mapType(Type *T, SPIRVType *BT);
   SPIRVValue *mapValue(Value *V, SPIRVValue *BV);
@@ -178,6 +180,11 @@ class LLVMToSPIRV : public ModulePass {
   SPIRVId addInt32(int);
   void transFunction(Function *I);
   SPIRV::SPIRVLinkageTypeKind transLinkageType(const GlobalValue *GV);
+
+  bool isAnyFunctionReachableFromFunction(
+      const Function *FS,
+      const std::unordered_set<const Function *> Funcs) const;
+  void collectInputOutputVariables(SPIRVFunction *SF, Function *F);
 };
 
 } // namespace SPIRV

llvm-spirv/lib/SPIRV/libSPIRV/SPIRVDecorate.h

@@ -136,6 +136,16 @@ class SPIRVDecorate : public SPIRVDecorateGeneric {
   // Incomplete constructor
   SPIRVDecorate() : SPIRVDecorateGeneric(OC) {}
 
+  SPIRVExtSet getRequiredExtensions() const override {
+    switch (Dec) {
+    case DecorationNoSignedWrap:
+    case DecorationNoUnsignedWrap:
+      return getSet(SPV_KHR_no_integer_wrap_decoration);
+    default:
+      return SPIRVExtSet();
+    }
+  }
+
   _SPIRV_DCL_ENCDEC
   void setWordCount(SPIRVWord) override;
   void validate() const override {

llvm-spirv/lib/SPIRV/libSPIRV/SPIRVEntry.cpp

@@ -438,17 +438,18 @@ std::istream &operator>>(std::istream &I, SPIRVEntry &E) {
 
 SPIRVEntryPoint::SPIRVEntryPoint(SPIRVModule *TheModule,
                                  SPIRVExecutionModelKind TheExecModel,
-                                 SPIRVId TheId, const std::string &TheName)
+                                 SPIRVId TheId, const std::string &TheName,
+                                 std::vector<SPIRVId> Variables)
     : SPIRVAnnotation(TheModule->get<SPIRVFunction>(TheId),
-                      getSizeInWords(TheName) + 3),
-      ExecModel(TheExecModel), Name(TheName) {}
+                      getSizeInWords(TheName) + Variables.size() + 3),
+      ExecModel(TheExecModel), Name(TheName), Variables(Variables) {}
 
 void SPIRVEntryPoint::encode(spv_ostream &O) const {
-  getEncoder(O) << ExecModel << Target << Name;
+  getEncoder(O) << ExecModel << Target << Name << Variables;
 }
 
 void SPIRVEntryPoint::decode(std::istream &I) {
-  getDecoder(I) >> ExecModel >> Target >> Name;
+  getDecoder(I) >> ExecModel >> Target >> Name >> Variables;
   Module->setName(getOrCreateTarget(), Name);
   Module->addEntryPoint(ExecModel, Target);
 }

llvm-spirv/lib/SPIRV/libSPIRV/SPIRVEntry.h

@@ -288,6 +288,7 @@ class SPIRVEntry {
   Op getOpCode() const { return OpCode; }
   SPIRVModule *getModule() const { return Module; }
   virtual SPIRVCapVec getRequiredCapability() const { return SPIRVCapVec(); }
+  virtual SPIRVExtSet getRequiredExtensions() const { return SPIRVExtSet(); }
   const std::string &getName() const { return Name; }
   bool hasDecorate(Decoration Kind, size_t Index = 0,
                    SPIRVWord *Result = 0) const;
@@ -478,12 +479,16 @@ template <Op OC> class SPIRVAnnotation : public SPIRVAnnotationGeneric {
 class SPIRVEntryPoint : public SPIRVAnnotation<OpEntryPoint> {
 public:
   SPIRVEntryPoint(SPIRVModule *TheModule, SPIRVExecutionModelKind,
-                  SPIRVId TheId, const std::string &TheName);
+                  SPIRVId TheId, const std::string &TheName,
+                  std::vector<SPIRVId> Variables);
   SPIRVEntryPoint() : ExecModel(ExecutionModelKernel) {}
   _SPIRV_DCL_ENCDEC
 protected:
   SPIRVExecutionModelKind ExecModel;
   std::string Name;
+
+private:
+  std::vector<SPIRVId> Variables;
 };
 
 class SPIRVName : public SPIRVAnnotation<OpName> {