[SPIR-V] Emit DebugTypeBasic for NonSemantic DI

The commit introduces support for fundamental DI instruction.
Metadata handlers required for this instruction is stored inside
debug records (https://llvm.org/docs/SourceLevelDebugging.html) parts
of the module which rises the necessity of it's traversal.

Author: bwlodarcz

llvm/lib/Target/SPIRV/SPIRVEmitNonSemanticDI.cpp

@@ -4,7 +4,9 @@
 #include "SPIRVGlobalRegistry.h"
 #include "SPIRVRegisterInfo.h"
 #include "SPIRVTargetMachine.h"
+#include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/SmallString.h"
+#include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/CodeGen/GlobalISel/MachineIRBuilder.h"
 #include "llvm/CodeGen/MachineBasicBlock.h"
 #include "llvm/CodeGen/MachineFunction.h"
@@ -13,7 +15,10 @@
 #include "llvm/CodeGen/MachineInstrBuilder.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/CodeGen/MachineOperand.h"
+#include "llvm/CodeGen/MachineRegisterInfo.h"
+#include "llvm/CodeGen/Register.h"
 #include "llvm/IR/DebugInfoMetadata.h"
+#include "llvm/IR/DebugProgramInstruction.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/PassRegistry.h"
 #include "llvm/Support/Casting.h"
@@ -71,7 +76,7 @@ bool SPIRVEmitNonSemanticDI::emitGlobalDI(MachineFunction &MF) {
   unsigned SourceLanguage = 0;
   int64_t DwarfVersion = 0;
   int64_t DebugInfoVersion = 0;
-
+  SmallSet<DIBasicType *, 12> BasicTypes;
   // Searching through the Module metadata to find nescessary
   // information like DwarfVersion or SourceLanguage
   {
@@ -104,6 +109,24 @@ bool SPIRVEmitNonSemanticDI::emitGlobalDI(MachineFunction &MF) {
                 cast<ConstantAsMetadata>(Op->getOperand(2))->getValue())
                 ->getSExtValue();
     }
+
+    // This traversal is the only supported way to access
+    // instruction related DI metadata like DIBasicType
+    for (auto &F : *M) {
+      for (auto &BB : F) {
+        for (auto &I : BB) {
+          for (DbgRecord &DR : I.getDbgRecordRange()) {
+            if (auto *DVR = dyn_cast<DbgVariableRecord>(&DR)) {
+              DILocalVariable *LocalVariable = DVR->getVariable();
+              if (auto *BasicType =
+                      dyn_cast<DIBasicType>(LocalVariable->getType())) {
+                BasicTypes.insert(BasicType);
+              }
+            }
+          }
+        }
+      }
+    }
   }
   // NonSemantic.Shader.DebugInfo.100 global DI instruction emitting
   {
@@ -120,29 +143,45 @@ bool SPIRVEmitNonSemanticDI::emitGlobalDI(MachineFunction &MF) {
     // and before first terminator
     MachineIRBuilder MIRBuilder(MBB, MBB.getFirstTerminator());
 
+    const auto EmitOpString = [&](StringRef SR) {
+      const Register StrReg = MRI.createVirtualRegister(&SPIRV::IDRegClass);
+      MRI.setType(StrReg, LLT::scalar(32));
+      MachineInstrBuilder MIB = MIRBuilder.buildInstr(SPIRV::OpString);
+      MIB.addDef(StrReg);
+      addStringImm(SR, MIB);
+      return StrReg;
+    };
+
     // Emit OpString with FilePath which is required by DebugSource
-    const Register StrReg = MRI.createVirtualRegister(&SPIRV::IDRegClass);
-    MRI.setType(StrReg, LLT::scalar(32));
-    MachineInstrBuilder MIB = MIRBuilder.buildInstr(SPIRV::OpString);
-    MIB.addDef(StrReg);
-    addStringImm(FilePath, MIB);
+    const Register FilePathStrReg = EmitOpString(FilePath);
 
     const SPIRVType *VoidTy =
         GR->getOrCreateSPIRVType(Type::getVoidTy(*Context), MIRBuilder);
 
+    const auto EmitDIInstruction =
+        [&](SPIRV::NonSemanticExtInst::NonSemanticExtInst Inst,
+            std::initializer_list<Register> Registers) {
+          const Register InstReg =
+              MRI.createVirtualRegister(&SPIRV::IDRegClass);
+          MRI.setType(InstReg, LLT::scalar(32));
+          MachineInstrBuilder MIB =
+              MIRBuilder.buildInstr(SPIRV::OpExtInst)
+                  .addDef(InstReg)
+                  .addUse(GR->getSPIRVTypeID(VoidTy))
+                  .addImm(static_cast<int64_t>(
+                      SPIRV::InstructionSet::NonSemantic_Shader_DebugInfo_100))
+                  .addImm(Inst);
+          for (auto Reg : Registers) {
+            MIB.addUse(Reg);
+          }
+          MIB.constrainAllUses(*TII, *TRI, *RBI);
+          GR->assignSPIRVTypeToVReg(VoidTy, InstReg, MF);
+          return InstReg;
+        };
+
     // Emit DebugSource which is required by DebugCompilationUnit
-    const Register DebugSourceResIdReg =
-        MRI.createVirtualRegister(&SPIRV::IDRegClass);
-    MRI.setType(DebugSourceResIdReg, LLT::scalar(32));
-    MIB = MIRBuilder.buildInstr(SPIRV::OpExtInst)
-              .addDef(DebugSourceResIdReg)
-              .addUse(GR->getSPIRVTypeID(VoidTy))
-              .addImm(static_cast<int64_t>(
-                  SPIRV::InstructionSet::NonSemantic_Shader_DebugInfo_100))
-              .addImm(SPIRV::NonSemanticExtInst::DebugSource)
-              .addUse(StrReg);
-    MIB.constrainAllUses(*TII, *TRI, *RBI);
-    GR->assignSPIRVTypeToVReg(VoidTy, DebugSourceResIdReg, MF);
+    const Register DebugSourceResIdReg = EmitDIInstruction(
+        SPIRV::NonSemanticExtInst::DebugSource, {FilePathStrReg});
 
     const SPIRVType *I32Ty =
         GR->getOrCreateSPIRVType(Type::getInt32Ty(*Context), MIRBuilder);
@@ -156,22 +195,56 @@ bool SPIRVEmitNonSemanticDI::emitGlobalDI(MachineFunction &MF) {
     const Register SourceLanguageReg =
         GR->buildConstantInt(SourceLanguage, MIRBuilder, I32Ty, false);
 
-    // Emit DebugCompilationUnit
+    [[maybe_unused]]
     const Register DebugCompUnitResIdReg =
-        MRI.createVirtualRegister(&SPIRV::IDRegClass);
-    MRI.setType(DebugCompUnitResIdReg, LLT::scalar(32));
-    MIB = MIRBuilder.buildInstr(SPIRV::OpExtInst)
-              .addDef(DebugCompUnitResIdReg)
-              .addUse(GR->getSPIRVTypeID(VoidTy))
-              .addImm(static_cast<int64_t>(
-                  SPIRV::InstructionSet::NonSemantic_Shader_DebugInfo_100))
-              .addImm(SPIRV::NonSemanticExtInst::DebugCompilationUnit)
-              .addUse(DebugInfoVersionReg)
-              .addUse(DwarfVersionReg)
-              .addUse(DebugSourceResIdReg)
-              .addUse(SourceLanguageReg);
-    MIB.constrainAllUses(*TII, *TRI, *RBI);
-    GR->assignSPIRVTypeToVReg(VoidTy, DebugCompUnitResIdReg, MF);
+        EmitDIInstruction(SPIRV::NonSemanticExtInst::DebugCompilationUnit,
+                          {DebugInfoVersionReg, DwarfVersionReg,
+                           DebugSourceResIdReg, SourceLanguageReg});
+
+    // Emit DebugInfoNone. This instruction is a wildcard accepted
+    // by standard to put into instruction arguments as Not Available/Null
+    const Register DebugInfoNoneReg =
+        EmitDIInstruction(SPIRV::NonSemanticExtInst::DebugInfoNone, {});
+
+    for (auto *BasicType : BasicTypes) {
+      const Register BasicTypeStrReg = EmitOpString(BasicType->getName());
+
+      const Register ConstIntBitwidthReg = GR->buildConstantInt(
+          BasicType->getSizeInBits(), MIRBuilder, I32Ty, false);
+
+      uint64_t AttributeEncoding = 0;
+      switch (BasicType->getEncoding()) {
+      case dwarf::DW_ATE_signed:
+        AttributeEncoding = 4;
+        break;
+      case dwarf::DW_ATE_unsigned:
+        AttributeEncoding = 6;
+        break;
+      case dwarf::DW_ATE_unsigned_char:
+        AttributeEncoding = 7;
+        break;
+      case dwarf::DW_ATE_signed_char:
+        AttributeEncoding = 5;
+        break;
+      case dwarf::DW_ATE_float:
+        AttributeEncoding = 3;
+        break;
+      case dwarf::DW_ATE_boolean:
+        AttributeEncoding = 2;
+        break;
+      case dwarf::DW_ATE_address:
+        AttributeEncoding = 1;
+      }
+
+      const Register AttributeEncodingReg =
+          GR->buildConstantInt(AttributeEncoding, MIRBuilder, I32Ty, false);
+
+      [[maybe_unused]]
+      const Register BasicTypeReg =
+          EmitDIInstruction(SPIRV::NonSemanticExtInst::DebugTypeBasic,
+                            {BasicTypeStrReg, ConstIntBitwidthReg,
+                             AttributeEncodingReg, DebugInfoNoneReg});
+    }
   }
   return true;
 }

llvm/lib/Target/SPIRV/SPIRVModuleAnalysis.cpp

@@ -432,7 +432,8 @@ void SPIRVModuleAnalysis::processOtherInstrs(const Module &M) {
           MachineOperand Ins = MI.getOperand(3);
           namespace NS = SPIRV::NonSemanticExtInst;
           static constexpr int64_t GlobalNonSemanticDITy[] = {
-              NS::DebugSource, NS::DebugCompilationUnit};
+              NS::DebugSource, NS::DebugCompilationUnit, NS::DebugInfoNone,
+              NS::DebugTypeBasic};
           bool IsGlobalDI = false;
           for (unsigned Idx = 0; Idx < std::size(GlobalNonSemanticDITy); ++Idx)
             IsGlobalDI |= Ins.getImm() == GlobalNonSemanticDITy[Idx];