Support for record debug format (#2565)

Recently, LLVM migrated to new debug format replacing debug intrinsics with so-called records. The DIBuilder api supports both formats now with grace deprecation period for intrinsics. Currently Translator during reverse translation have new format disabled by flag and still supports only old one.
Documentation for the migration: https://llvm.org/docs/RemoveDIsDebugInfo.html

Original commit:
KhronosGroup/SPIRV-LLVM-Translator@50c6c3e6b99462a

Author: bwlodarcz

llvm-spirv/lib/SPIRV/SPIRVReader.cpp

@@ -61,6 +61,7 @@
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/IR/AttributeMask.h"
 #include "llvm/IR/Constants.h"
+#include "llvm/IR/DebugProgramInstruction.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/IRBuilder.h"
@@ -2439,7 +2440,18 @@ Value *SPIRVToLLVM::transValueWithoutDecoration(SPIRVValue *BV, Function *F,
     case SPIRVEIS_OpenCL_DebugInfo_100:
     case SPIRVEIS_NonSemantic_Shader_DebugInfo_100:
     case SPIRVEIS_NonSemantic_Shader_DebugInfo_200:
-      return mapValue(BV, DbgTran->transDebugIntrinsic(ExtInst, BB));
+      if (!M->IsNewDbgInfoFormat) {
+        return mapValue(
+            BV, DbgTran->transDebugIntrinsic(ExtInst, BB).get<Instruction *>());
+      } else {
+        auto MaybeRecord = DbgTran->transDebugIntrinsic(ExtInst, BB);
+        if (!MaybeRecord.isNull()) {
+          auto *Record = MaybeRecord.get<DbgRecord *>();
+          Record->setDebugLoc(
+              DbgTran->transDebugScope(static_cast<SPIRVInstruction *>(BV)));
+        }
+        return mapValue(BV, nullptr);
+      }
     default:
       llvm_unreachable("Unknown extended instruction set!");
     }
@@ -5054,9 +5066,6 @@ llvm::convertSpirvToLLVM(LLVMContext &C, SPIRVModule &BM,
                          const SPIRV::TranslatorOpts &Opts,
                          std::string &ErrMsg) {
   std::unique_ptr<Module> M(new Module("", C));
-  // TODO: Migrate to the new debug record format.  Until then, keep using the
-  // old format.
-  M->setNewDbgInfoFormatFlag(false);
 
   SPIRVToLLVM BTL(M.get(), &BM);
 

llvm-spirv/lib/SPIRV/SPIRVToLLVMDbgTran.cpp

@@ -47,6 +47,7 @@
 
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/IR/DIBuilder.h"
+#include "llvm/IR/DebugProgramInstruction.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Module.h"
 
@@ -1547,7 +1548,7 @@ MDNode *SPIRVToLLVMDbgTran::transDebugInstImpl(const SPIRVExtInst *DebugInst) {
   }
 }
 
-Instruction *
+DbgInstPtr
 SPIRVToLLVMDbgTran::transDebugIntrinsic(const SPIRVExtInst *DebugInst,
                                         BasicBlock *BB) {
   auto GetLocalVar = [&](SPIRVId Id) -> std::pair<DILocalVariable *, DebugLoc> {
@@ -1572,6 +1573,7 @@ SPIRVToLLVMDbgTran::transDebugIntrinsic(const SPIRVExtInst *DebugInst,
   case SPIRVDebug::Declare: {
     using namespace SPIRVDebug::Operand::DebugDeclare;
     auto LocalVar = GetLocalVar(Ops[DebugLocalVarIdx]);
+    DIBuilder &DIB = getDIBuilder(DebugInst);
     if (getDbgInst<SPIRVDebug::DebugInfoNone>(Ops[VariableIdx])) {
       // If we don't have the variable(e.g. alloca might be promoted by mem2reg)
       // we should generate the following IR:
@@ -1581,16 +1583,15 @@ SPIRVToLLVMDbgTran::transDebugIntrinsic(const SPIRVExtInst *DebugInst,
       // parameter. To work around this limitation we create a dummy temp
       // alloca, use it to create llvm.dbg.declare, and then remove the alloca.
       auto *AI = new AllocaInst(Type::getInt8Ty(M->getContext()), 0, "tmp", BB);
-      DbgInstPtr DbgDeclare = getDIBuilder(DebugInst).insertDeclare(
+      DbgInstPtr DbgDeclare = DIB.insertDeclare(
           AI, LocalVar.first, GetExpression(Ops[ExpressionIdx]),
           LocalVar.second, BB);
       AI->eraseFromParent();
-      return DbgDeclare.get<Instruction *>();
+      return DbgDeclare;
     }
-    return getDIBuilder(DebugInst)
-        .insertDeclare(GetValue(Ops[VariableIdx]), LocalVar.first,
-                       GetExpression(Ops[ExpressionIdx]), LocalVar.second, BB)
-        .get<Instruction *>();
+    return DIB.insertDeclare(GetValue(Ops[VariableIdx]), LocalVar.first,
+                             GetExpression(Ops[ExpressionIdx]), LocalVar.second,
+                             BB);
   }
   case SPIRVDebug::Value: {
     using namespace SPIRVDebug::Operand::DebugValue;
@@ -1606,10 +1607,15 @@ SPIRVToLLVMDbgTran::transDebugIntrinsic(const SPIRVExtInst *DebugInst,
     }
     if (!MDs.empty()) {
       DIArgList *AL = DIArgList::get(M->getContext(), MDs);
-      cast<DbgVariableIntrinsic>(DbgValIntr.get<Instruction *>())
-          ->setRawLocation(AL);
+      if (M->IsNewDbgInfoFormat) {
+        cast<DbgVariableRecord>(DbgValIntr.get<DbgRecord *>())
+            ->setRawLocation(AL);
+      } else {
+        cast<DbgVariableIntrinsic>(DbgValIntr.get<Instruction *>())
+            ->setRawLocation(AL);
+      }
     }
-    return DbgValIntr.get<Instruction *>();
+    return DbgValIntr;
   }
   default:
     llvm_unreachable("Unknown debug intrinsic!");

llvm-spirv/lib/SPIRV/SPIRVToLLVMDbgTran.h

@@ -84,9 +84,9 @@ class SPIRVToLLVMDbgTran {
     return static_cast<T *>(Res);
   }
 
-  Instruction *transDebugIntrinsic(const SPIRVExtInst *DebugInst,
-                                   BasicBlock *BB);
+  DbgInstPtr transDebugIntrinsic(const SPIRVExtInst *DebugInst, BasicBlock *BB);
   void finalize();
+  llvm::DebugLoc transDebugScope(const SPIRVInstruction *Inst);
 
 private:
   DIFile *getFile(const SPIRVId SourceId);
@@ -104,8 +104,6 @@ class SPIRVToLLVMDbgTran {
 
   llvm::DebugLoc transDebugLocation(const SPIRVExtInst *DebugInst);
 
-  llvm::DebugLoc transDebugScope(const SPIRVInstruction *Inst);
-
   MDNode *transDebugInlined(const SPIRVExtInst *Inst);
   MDNode *transDebugInlinedNonSemanticShader200(const SPIRVExtInst *Inst);