Support translation of DebugSourceContinued (intel#1993)

Max length of SPIRV instruction is 65535 words by specification.
DebugSourceContinued helps to overcome the limitation and specify full source code text by continuing the string from the previous DebugSource(Continued)instruction.

Spec:
https://github.com/KhronosGroup/SPIRV-Registry/blob/main/nonsemantic/NonSemantic.Shader.DebugInfo.100.asciidoc#DebugSourceContinued

Original commit:
KhronosGroup/SPIRV-LLVM-Translator@aabcaf8

Author: vmaksimo

llvm-spirv/lib/SPIRV/LLVMToSPIRVDbgTran.cpp

@@ -1343,17 +1343,44 @@ SPIRVExtInst *LLVMToSPIRVDbgTran::getSource(const T *DIEntry) {
     return It->second;
 
   using namespace SPIRVDebug::Operand::Source;
-  SPIRVWordVec Ops(OperandCount);
+  SPIRVWordVec Ops(MinOperandCount);
   Ops[FileIdx] = BM->getString(FileName)->getId();
   DIFile *F = DIEntry ? DIEntry->getFile() : nullptr;
-  if (F && F->getRawChecksum()) {
+
+  if (F && F->getRawChecksum() && !isNonSemanticDebugInfo()) {
     auto CheckSum = F->getChecksum().value();
-    Ops[TextIdx] = BM->getString("//__" + CheckSum.getKindAsString().str() +
-                                 ":" + CheckSum.Value.str())
-                       ->getId();
-  } else {
-    Ops[TextIdx] = getDebugInfoNone()->getId();
+    Ops.push_back(BM->getString("//__" + CheckSum.getKindAsString().str() +
+                                ":" + CheckSum.Value.str())
+                      ->getId());
   }
+
+  if (F && F->getRawSource() && isNonSemanticDebugInfo()) {
+    std::string Str = F->getSource().value().str();
+    constexpr size_t MaxNumWords =
+        MaxWordCount - 2 /*Fixed WC for SPIRVString*/;
+    constexpr size_t MaxStrSize = MaxNumWords * 4 - 1;
+    const size_t NumWords = getSizeInWords(Str);
+
+    Ops.push_back(BM->getString(Str.substr(0, MaxStrSize))->getId());
+    SPIRVExtInst *Source = static_cast<SPIRVExtInst *>(
+        BM->addDebugInfo(SPIRVDebug::Source, getVoidTy(), Ops));
+    FileMap[FileName] = Source;
+    Str.erase(0, MaxStrSize);
+
+    // No need to generate source continued instructions
+    if (NumWords < MaxNumWords)
+      return Source;
+
+    uint64_t NumOfContinuedInstructions =
+        NumWords / MaxNumWords - 1 + (NumWords % MaxNumWords ? 1 : 0);
+    for (uint64_t J = 0; J < NumOfContinuedInstructions; J++) {
+      SPIRVWord Op = BM->getString(Str.substr(0, MaxStrSize))->getId();
+      BM->addDebugInfo(SPIRVDebug::SourceContinued, getVoidTy(), {Op});
+      Str.erase(0, MaxStrSize);
+    }
+    return Source;
+  }
+
   SPIRVExtInst *Source = static_cast<SPIRVExtInst *>(
       BM->addDebugInfo(SPIRVDebug::Source, getVoidTy(), Ops));
   FileMap[FileName] = Source;

llvm-spirv/lib/SPIRV/SPIRVToLLVMDbgTran.cpp

@@ -75,16 +75,17 @@ void SPIRVToLLVMDbgTran::addDbgInfoVersion() {
                    DEBUG_METADATA_VERSION);
 }
 
-DIFile *SPIRVToLLVMDbgTran::getDIFile(
-    const std::string &FileName,
-    std::optional<DIFile::ChecksumInfo<StringRef>> CS) {
+DIFile *
+SPIRVToLLVMDbgTran::getDIFile(const std::string &FileName,
+                              std::optional<DIFile::ChecksumInfo<StringRef>> CS,
+                              std::optional<StringRef> Source) {
   return getOrInsert(FileMap, FileName, [=]() {
     SplitFileName Split(FileName);
     // Use the first builder from the map to crete DIFile since it's
     // relations with other debug metadata is not going through DICompileUnit
     if (!Split.BaseName.empty())
       return BuilderMap.begin()->second->createFile(Split.BaseName, Split.Path,
-                                                    CS);
+                                                    CS, Source);
     return static_cast<DIFile *>(nullptr);
   });
 }
@@ -134,6 +135,19 @@ const std::string &SPIRVToLLVMDbgTran::getString(const SPIRVId Id) {
   return String->getStr();
 }
 
+const std::string
+SPIRVToLLVMDbgTran::getStringContinued(const SPIRVId Id,
+                                       SPIRVExtInst *DebugInst) {
+  std::string Str = BM->get<SPIRVString>(Id)->getStr();
+  using namespace SPIRVDebug::Operand::SourceContinued;
+  for (auto *I : DebugInst->getContinuedInstructions()) {
+    std::string TmpStr =
+        BM->get<SPIRVString>(I->getArguments()[TextIdx])->getStr();
+    Str.append(TmpStr);
+  }
+  return Str;
+}
+
 void SPIRVToLLVMDbgTran::transDbgInfo(const SPIRVValue *SV, Value *V) {
   // A constant sampler does not have a corresponding SPIRVInstruction.
   if (SV->getOpCode() == OpConstantSampler)
@@ -1327,6 +1341,7 @@ MDNode *SPIRVToLLVMDbgTran::transDebugInstImpl(const SPIRVExtInst *DebugInst) {
 
   case SPIRVDebug::Operation: // To be translated with transExpression
   case SPIRVDebug::Source:    // To be used by other instructions
+  case SPIRVDebug::SourceContinued:
     return nullptr;
 
   case SPIRVDebug::Expression:
@@ -1458,12 +1473,21 @@ DIFile *SPIRVToLLVMDbgTran::getFile(const SPIRVId SourceId) {
   assert(Source->getExtOp() == SPIRVDebug::Source &&
          "DebugSource instruction is expected");
   SPIRVWordVec SourceArgs = Source->getArguments();
-  assert(SourceArgs.size() == OperandCount && "Invalid number of operands");
-  std::string ChecksumStr =
-      getDbgInst<SPIRVDebug::DebugInfoNone>(SourceArgs[TextIdx])
-          ? ""
-          : getString(SourceArgs[TextIdx]);
-  return getDIFile(getString(SourceArgs[FileIdx]), ParseChecksum(ChecksumStr));
+  assert(SourceArgs.size() >= MinOperandCount && "Invalid number of operands");
+  if (SourceArgs.size() == MinOperandCount)
+    return getDIFile(getString(SourceArgs[FileIdx]));
+
+  if (!isNonSemanticDebugInfo(Source->getExtSetKind())) {
+    std::string ChecksumStr =
+        getDbgInst<SPIRVDebug::DebugInfoNone>(SourceArgs[TextIdx])
+            ? ""
+            : getString(SourceArgs[TextIdx]);
+    return getDIFile(getString(SourceArgs[FileIdx]),
+                     ParseChecksum(ChecksumStr));
+  }
+
+  return getDIFile(getString(SourceArgs[FileIdx]), std::nullopt,
+                   getStringContinued(SourceArgs[TextIdx], Source));
 }
 
 DIBuilder &SPIRVToLLVMDbgTran::getDIBuilder(const SPIRVExtInst *DebugInst) {

llvm-spirv/lib/SPIRV/SPIRVToLLVMDbgTran.h

@@ -91,7 +91,8 @@ class SPIRVToLLVMDbgTran {
   DIFile *getFile(const SPIRVId SourceId);
   DIFile *
   getDIFile(const std::string &FileName,
-            std::optional<DIFile::ChecksumInfo<StringRef>> CS = std::nullopt);
+            std::optional<DIFile::ChecksumInfo<StringRef>> CS = std::nullopt,
+            std::optional<StringRef> Source = std::nullopt);
   DIFile *getDIFile(const SPIRVEntry *E);
   unsigned getLineNo(const SPIRVEntry *E);
 
@@ -195,6 +196,8 @@ class SPIRVToLLVMDbgTran {
     return nullptr;
   }
   const std::string &getString(const SPIRVId Id);
+  const std::string getStringContinued(const SPIRVId Id,
+                                       SPIRVExtInst *DebugInst);
   SPIRVWord getConstantValueOrLiteral(const std::vector<SPIRVWord> &,
                                       const SPIRVWord,
                                       const SPIRVExtInstSetKind);

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

@@ -55,6 +55,7 @@ enum Instruction {
   ModuleINTEL                   = 36,
   InstCount                     = 37,
   FunctionDefinition            = 101,
+  SourceContinued               = 102,
   EntryPoint                    = 107,
   Module                        = 200,
   TypeSubrange                  = 201,
@@ -302,9 +303,9 @@ enum {
 
 namespace Source {
 enum {
-  FileIdx      = 0,
-  TextIdx      = 1,
-  OperandCount = 2
+  FileIdx         = 0,
+  TextIdx         = 1,
+  MinOperandCount = 1
 };
 }
 
@@ -573,6 +574,13 @@ enum {
 };
 }
 
+namespace SourceContinued {
+enum {
+  TextIdx      = 0,
+  OperandCount = 1
+};
+}
+
 namespace EntryPoint {
 enum {
   EntryPointIdx        = 0,

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

@@ -262,6 +262,7 @@ template <> inline void SPIRVMap<SPIRVDebugExtOpKind, std::string>::init() {
   add(SPIRVDebug::Expression, "DebugExpression");
   add(SPIRVDebug::Operation, "DebugOperation");
   add(SPIRVDebug::FunctionDefinition, "DebugFunctionDefinition");
+  add(SPIRVDebug::SourceContinued, "DebugSourceContinued");
   add(SPIRVDebug::EntryPoint, "DebugEntryPoint");
 }
 SPIRV_DEF_NAMEMAP(SPIRVDebugExtOpKind, SPIRVDebugExtOpMap)

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

@@ -1758,6 +1758,14 @@ class SPIRVExtInst : public SPIRVFunctionCallGeneric<OpExtInst, 5> {
 
   SPIRVExtInstSetKind getExtSetKind() const { return ExtSetKind; }
 
+  void addContinuedInstruction(SPIRVExtInst *Inst) {
+    ContinuedInstructions.push_back(Inst);
+  }
+
+  std::vector<SPIRVExtInst *> getContinuedInstructions() {
+    return ContinuedInstructions;
+  }
+
   void setExtSetKindById() {
     assert(Module && "Invalid module");
     ExtSetKind = Module->getBuiltinSet(ExtSetId);
@@ -1809,7 +1817,17 @@ class SPIRVExtInst : public SPIRVFunctionCallGeneric<OpExtInst, 5> {
       assert(0 && "not supported");
       getDecoder(I) >> ExtOp;
     }
-    getDecoder(I) >> Args;
+    SPIRVDecoder Decoder = getDecoder(I);
+    Decoder >> Args;
+
+    if (ExtSetKind == SPIRVEIS_NonSemantic_Shader_DebugInfo_100 ||
+        ExtSetKind == SPIRVEIS_NonSemantic_Shader_DebugInfo_200) {
+      if (getExtOp() == SPIRVDebug::Instruction::Source) {
+        for (SPIRVEntry *E : Decoder.getSourceContinuedInstructions()) {
+          addContinuedInstruction(static_cast<SPIRVExtInst *>(E));
+        }
+      }
+    }
   }
   void validate() const override {
     SPIRVFunctionCallGeneric::validate();
@@ -1865,6 +1883,7 @@ class SPIRVExtInst : public SPIRVFunctionCallGeneric<OpExtInst, 5> {
     SPIRVDebugExtOpKind ExtOpDebug;
     NonSemanticAuxDataOpKind ExtOpNonSemanticAuxData;
   };
+  std::vector<SPIRVExtInst *> ContinuedInstructions;
 };
 
 class SPIRVCompositeConstruct : public SPIRVInstruction {

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

@@ -39,6 +39,7 @@
 #include "SPIRVStream.h"
 #include "SPIRVDebug.h"
 #include "SPIRVFunction.h"
+#include "SPIRVInstruction.h"
 #include "SPIRVNameMapEnum.h"
 #include "SPIRVOpCode.h"
 
@@ -331,4 +332,25 @@ SPIRVDecoder::getContinuedInstructions(const spv::Op ContinuedOpCode) {
   return ContinuedInst;
 }
 
+std::vector<SPIRVEntry *> SPIRVDecoder::getSourceContinuedInstructions() {
+  std::vector<SPIRVEntry *> ContinuedInst;
+  std::streampos Pos = IS.tellg(); // remember position
+  getWordCountAndOpCode();
+  while (OpCode == OpExtInst) {
+    SPIRVEntry *Entry = getEntry();
+    assert(Entry && "Failed to decode entry! Invalid instruction!");
+    SPIRVExtInst *Inst = static_cast<SPIRVExtInst *>(Entry);
+    if (Inst->getExtOp() != SPIRVDebug::Instruction::SourceContinued) {
+      IS.seekg(Pos); // restore position
+      return ContinuedInst;
+    }
+    M.add(Entry);
+    ContinuedInst.push_back(Entry);
+    Pos = IS.tellg();
+    getWordCountAndOpCode();
+  }
+  IS.seekg(Pos); // restore position
+  return ContinuedInst;
+}
+
 } // namespace SPIRV

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

@@ -78,6 +78,7 @@ class SPIRVDecoder {
   void ignoreInstruction();
   std::vector<SPIRVEntry *>
   getContinuedInstructions(const spv::Op ContinuedOpCode);
+  std::vector<SPIRVEntry *> getSourceContinuedInstructions();
 
   std::istream &IS;
   SPIRVModule &M;

llvm-spirv/test/DebugInfo/NonSemantic/DebugSourceContinued.ll

@@ -7,8 +7,8 @@
 ; RUN: llvm-dis %t.rev.bc -o - | FileCheck %s --check-prefix=CHECK-LLVM
 
 
-; CHECK-SPIRV: [[#None:]] [[#]] DebugInfoNone
 ; CHECK-SPIRV: [[#CompUnit:]] [[#]] DebugCompilationUnit
+; CHECK-SPIRV: [[#None:]] [[#]] DebugInfoNone
 ; CHECK-SPIRV: [[#EntryFunc:]] [[#]] DebugFunction
 ; CHECK-SPIRV: [[#BaseTy:]] [[#]] DebugTypeBasic
 ; CHECK-SPIRV: [[#Subrange:]] [[#]] DebugTypeSubrange