--Added support for the extension SPV_KHR_relaxed_extended_instruction

aadeshps-mcw · aadeshps-mcw · commit 6af50cf343db · 2025-10-30T17:39:22.000+05:30
--Modified the SPIRVEmitNonSemanticDI.cpp file for forward referencing
--Modified the test files to reflect the changes made in SPIRVEmitNonSemanticDI.cpp.
diff --git a/llvm/lib/Target/SPIRV/SPIRVEmitNonSemanticDI.cpp b/llvm/lib/Target/SPIRV/SPIRVEmitNonSemanticDI.cpp
@@ -196,6 +196,10 @@ struct SPIRVEmitNonSemanticDI : public MachineFunctionPass {
                            SPIRVCodeGenContext &Ctx,
                            const DenseMap<StringRef, Register> &MacroDefRegs);
 
+  void emitDebugTypeEnum(
+      const SmallPtrSetImpl<const DICompositeType *> &EnumTypes,
+      SPIRVCodeGenContext &Ctx);
+
   void emitDebugQualifiedTypes(
       const SmallPtrSetImpl<DIDerivedType *> &QualifiedDerivedTypes,
       SPIRVCodeGenContext &Ctx);
@@ -465,30 +469,20 @@ bool SPIRVEmitNonSemanticDI::emitGlobalDI(MachineFunction &MF) {
     emitDebugMacroDefs(MF, Ctx);
     emitDebugBuildIdentifier(BuildIdentifier, Ctx);
     emitDebugStoragePath(BuildStoragePath, Ctx);
-
-    // *** MODIFIED ORDER *** Emit basic types first
     emitDebugBasicTypes(Collector.BasicTypes, Ctx);
 
-    // Now emit types that might depend on basic types or each other
     emitSubroutineTypes(Collector.SubRoutineTypes, Ctx);
-    emitSubprograms(Collector.SubPrograms,
-                    Ctx); // Subprograms use SubroutineTypes
+    emitSubprograms(Collector.SubPrograms, Ctx);
     emitLexicalScopes(Collector.LexicalScopes, Ctx);
-    emitDebugPointerTypes(Collector.PointerDerivedTypes,
-                          Ctx); // Pointers use BaseTypes (Basic/Composite)
-    emitDebugArrayTypes(Collector.ArrayTypes, Ctx); // Arrays use BaseTypes
-    emitAllDebugTypeComposites(
-        Collector.CompositeTypes,
-        Ctx); // Composites define types used by Pointers/Members
+    emitDebugPointerTypes(Collector.PointerDerivedTypes, Ctx);
+    emitDebugArrayTypes(Collector.ArrayTypes, Ctx);
+    emitAllDebugTypeComposites(Collector.CompositeTypes, Ctx);
+    emitDebugTypeEnum(Collector.EnumTypes, Ctx);
     emitAllTemplateDebugInstructions(Collector.CompositeTypesWithTemplates,
-                                     Ctx); // Templates use Composites & Params
-    emitDebugQualifiedTypes(Collector.QualifiedDerivedTypes,
-                            Ctx);                   // Qualifiers use BaseTypes
-    emitDebugTypedefs(Collector.TypedefTypes, Ctx); // Typedefs use BaseTypes
-    emitDebugTypePtrToMember(Collector.PtrToMemberTypes,
-                             Ctx); // PtrToMember uses BaseTypes
-
-    // Emit entities that use types
+                                     Ctx);
+    emitDebugQualifiedTypes(Collector.QualifiedDerivedTypes, Ctx);
+    emitDebugTypedefs(Collector.TypedefTypes, Ctx);
+    emitDebugTypePtrToMember(Collector.PtrToMemberTypes, Ctx);
     emitAllDebugGlobalVariables(MF, Ctx);
     emitDebugImportedEntities(Collector.ImportedEntities, Ctx);
   }
@@ -535,7 +529,6 @@ Register SPIRVEmitNonSemanticDI::EmitDIInstruction(
               SPIRV::InstructionSet::NonSemantic_Shader_DebugInfo_100))
           .addImm(Inst);
   for (auto Reg : Operands) {
-    llvm::errs() << "Adding operand register: " << Reg << "\n";
     MIB.addUse(Reg);
   }
   MIB.constrainAllUses(*Ctx.TII, *Ctx.TRI, *Ctx.RBI);
@@ -613,6 +606,72 @@ uint32_t SPIRVEmitNonSemanticDI::mapDebugFlags(DINode::DIFlags DFlags) {
   return Flags;
 }
 
+void SPIRVEmitNonSemanticDI::emitDebugTypeEnum(
+    const SmallPtrSetImpl<const DICompositeType *> &EnumTypes,
+    SPIRVCodeGenContext &Ctx) {
+  for (auto *EnumTy : EnumTypes) {
+    if (!EnumTy || EnumTy->getTag() != dwarf::DW_TAG_enumeration_type)
+      continue;
+    if (Register Existing = Ctx.GR->getDebugValue(EnumTy); Existing.isValid())
+      continue;
+    Register NameStr = EmitOpString(EnumTy->getName(), Ctx);
+    bool UnderlyingTypeIsFwd = false;
+    Register UnderlyingTypeReg = findBaseTypeRegisterRecursive(
+        EnumTy->getBaseType(), Ctx, UnderlyingTypeIsFwd);
+    if (!UnderlyingTypeReg.isValid()) {
+      UnderlyingTypeReg = EmitDIInstruction(
+          SPIRV::NonSemanticExtInst::DebugInfoNone, {}, Ctx, false);
+      UnderlyingTypeIsFwd = false;
+    }
+    Register SourceReg =
+        findRegisterFromMap(EnumTy->getFile(), Ctx.SourceRegPairs);
+    if (!SourceReg.isValid()) {
+      SourceReg = EmitDIInstruction(SPIRV::NonSemanticExtInst::DebugInfoNone,
+                                    {}, Ctx, false);
+    }
+    Register Line = Ctx.GR->buildConstantInt(EnumTy->getLine(), Ctx.MIRBuilder,
+                                             Ctx.I32Ty, false);
+    Register Column =
+        Ctx.GR->buildConstantInt(1, Ctx.MIRBuilder, Ctx.I32Ty, false);
+
+    Register ParentReg = Ctx.GR->getDebugValue(EnumTy->getScope());
+    if (!ParentReg.isValid()) {
+      llvm::errs() << "Warning: Could not find Parent scope register for Enum: "
+                   << EnumTy->getName() << "\n";
+      ParentReg = Ctx.GR->getDebugValue(EnumTy->getFile());
+      if (!ParentReg.isValid()) {
+        ParentReg = EmitDIInstruction(SPIRV::NonSemanticExtInst::DebugInfoNone,
+                                      {}, Ctx, false);
+      }
+    }
+    Register Size = Ctx.GR->buildConstantInt(EnumTy->getSizeInBits(),
+                                             Ctx.MIRBuilder, Ctx.I32Ty, false);
+    uint32_t Flags = transDebugFlags(EnumTy);
+    Register FlagsReg =
+        Ctx.GR->buildConstantInt(Flags, Ctx.MIRBuilder, Ctx.I32Ty, false);
+    SmallVector<Register, 16> EnumOperands;
+    for (Metadata *MD : EnumTy->getElements()) {
+      if (auto *E = dyn_cast<DIEnumerator>(MD)) {
+        Register Val = Ctx.GR->buildConstantInt(
+            E->getValue().getZExtValue(), Ctx.MIRBuilder, Ctx.I32Ty, false);
+        Register Name = EmitOpString(E->getName(), Ctx);
+        EnumOperands.push_back(Val);
+        EnumOperands.push_back(Name);
+      }
+    }
+    SmallVector<Register, 12> Ops = {
+        NameStr, UnderlyingTypeReg, SourceReg, Line,
+        Column,  ParentReg,         Size,      FlagsReg};
+    Ops.append(EnumOperands);
+    bool HasForwardRef = UnderlyingTypeIsFwd;
+    Register DefReg = Ctx.GR->getDebugValue(EnumTy);
+    Register Res = EmitDIInstruction(SPIRV::NonSemanticExtInst::DebugTypeEnum,
+                                     Ops, Ctx, HasForwardRef, DefReg);
+    Ctx.GR->addDebugValue(EnumTy, Res);
+    Ctx.CompositeTypeRegPairs.emplace_back(EnumTy, Res);
+  }
+}
+
 void SPIRVEmitNonSemanticDI::emitSingleCompilationUnit(
     StringRef FilePath, int64_t Language, SPIRVCodeGenContext &Ctx,
     Register DebugInfoVersionReg, Register DwarfVersionReg,
@@ -845,10 +904,7 @@ void SPIRVEmitNonSemanticDI::emitDebugPointerTypes(
                                                        Ctx.I32Ty, false, false);
 
     const DIType *BaseTy = PointerDerivedType->getBaseType();
-    llvm::errs() << "Pointer Derived Type BaseTy: "
-                 << (BaseTy ? BaseTy->getName() : "null") << "\n";
-
-    bool HasForwardRef = false;
+      bool HasForwardRef = false;
     Register BaseTypeReg =
         findBaseTypeRegisterRecursive(BaseTy, Ctx, HasForwardRef);
 
@@ -1230,7 +1286,7 @@ void SPIRVEmitNonSemanticDI::emitDebugArrayTypes(
     Register BaseTypeReg =
         findBaseTypeRegisterRecursive(ElementType, Ctx, HasForwardRef);
 
-    if (!BaseTypeReg.isValid()) { // If still not valid after recursive lookup
+    if (!BaseTypeReg.isValid()) {
       llvm::errs()
           << "Warning: Could not find element type for Array/Vector.\n";
       BaseTypeReg = EmitDIInstruction(SPIRV::NonSemanticExtInst::DebugInfoNone,
@@ -1433,9 +1489,6 @@ void SPIRVEmitNonSemanticDI::emitDebugTypeComposite(
       Ctx.GR->buildConstantInt(Flags, Ctx.MIRBuilder, Ctx.I32Ty, false, false);
 
   Register DefReg = Ctx.GR->getDebugValue(CompTy);
-  llvm::errs() << "Emitting DebugTypeComposite for: " << CompTy->getName()
-               << ", Found Res: " << DefReg << "\n";
-
   SmallVector<Register, 4> MemberRegs;
   bool HasForwardRef = false;
 
@@ -1744,8 +1797,6 @@ Register SPIRVEmitNonSemanticDI::findBaseTypeRegisterRecursive(
       IsForwardRef = Ctx.GR->isForwardPlaceholder(Found);
       return Found;
     }
-    llvm::errs() << "Creating placeholder for CompositeType: " << Ty->getName()
-                 << "\n";
     Register PlaceholderReg = Ctx.MRI.createVirtualRegister(&SPIRV::IDRegClass);
     Ctx.MRI.setType(PlaceholderReg, LLT::scalar(32));
     Ctx.GR->markAsForwardPlaceholder(PlaceholderReg);
diff --git a/llvm/lib/Target/SPIRV/SPIRVModuleAnalysis.cpp b/llvm/lib/Target/SPIRV/SPIRVModuleAnalysis.cpp
@@ -681,7 +681,7 @@ void SPIRVModuleAnalysis::processOtherInstrs(const Module &M) {
               NS::DebugMacroDef,
               NS::DebugMacroUndef,
               NS::DebugTypePtrToMember,
-              NS::DebugTypeInheritance};
+              NS::DebugTypeEnum};
           bool IsGlobalDI = false;
           for (unsigned Idx = 0; Idx < std::size(GlobalNonSemanticDITy); ++Idx)
             IsGlobalDI |= Ins.getImm() == GlobalNonSemanticDITy[Idx];
diff --git a/llvm/test/CodeGen/SPIRV/debug-info/debug-type-enum.ll b/llvm/test/CodeGen/SPIRV/debug-info/debug-type-enum.ll
@@ -0,0 +1,72 @@
+; RUN: llc --verify-machineinstrs --spv-emit-nonsemantic-debug-info --spirv-ext=+SPV_KHR_non_semantic_info --print-after=spirv-nonsemantic-debug-info -O0 -mtriple=spirv64-unknown-unknown %s -o - 2>&1 | FileCheck %s --check-prefix=CHECK-MIR
+; RUN: llc --verify-machineinstrs --spv-emit-nonsemantic-debug-info --spirv-ext=+SPV_KHR_non_semantic_info -O0 -mtriple=spirv64-unknown-unknown %s -o - | FileCheck %s --check-prefix=CHECK-SPIRV
+; RUN: llc --verify-machineinstrs -O0 -mtriple=spirv64-unknown-unknown --spirv-ext=+SPV_KHR_non_semantic_info %s -o - | FileCheck %s --check-prefix=CHECK-OPTION
+; RUN: %if spirv-tools %{ llc --verify-machineinstrs --spv-emit-nonsemantic-debug-info --spirv-ext=+SPV_KHR_non_semantic_info -O0 -mtriple=spirv64-unknown-unknown %s -o - -filetype=obj | spirv-val %}
+
+@c = dso_local global i32 1, align 4, !dbg !0
+
+define dso_local noundef i32 @main() !dbg !21 {
+entry:
+  %retval = alloca i32, align 4
+  store i32 0, ptr %retval, align 4
+  %0 = load i32, ptr @c, align 4, !dbg !23
+  ret i32 %0, !dbg !24
+}
+
+; CHECK-MIR-DAG: [[TYPE_I32:%[0-9]+:type]] = OpTypeInt 32, 0
+; CHECK-MIR-DAG: [[TYPE_VOID:%[0-9]+:type\(s64\)]] = OpTypeVoid
+; CHECK-MIR-DAG: [[C_NULL:%[0-9]+:iid]] = OpConstantNull [[TYPE_I32]]
+; CHECK-MIR-DAG: [[C_TW:%[0-9]+:iid\(s32\)]] = OpConstantI [[TYPE_I32]], 256
+; CHECK-MIR-DAG: [[C_THIRTYTWO:%[0-9]+:iid\(s32\)]] = OpConstantI [[TYPE_I32]], 32
+; CHECK-MIR-DAG: [[C_THIRTEEN:%[0-9]+:iid\(s32\)]] = OpConstantI [[TYPE_I32]], 13
+; CHECK-MIR-DAG: [[C_ONE:%[0-9]+:iid]] = OpConstantI [[TYPE_I32]], 1
+; CHECK-MIR-DAG: [[C_TWO:%[0-9]+:iid\(s32\)]] = OpConstantI [[TYPE_I32]], 2
+; CHECK-MIR-DAG: [[C_THREE:%[0-9]+:iid\(s32\)]] = OpConstantI [[TYPE_I32]], 3
+; CHECK-MIR-DAG: [[C_FOUR:%[0-9]+:iid\(s32\)]] = OpConstantI [[TYPE_I32]], 4
+; CHECK-MIR-DAG: [[C_FIVE:%[0-9]+:iid\(s32\)]] = OpConstantI [[TYPE_I32]], 5
+; CHECK-MIR-DAG: [[STR_RED:%[0-9]+:id\(s32\)]] = OpString 6579538
+; CHECK-MIR-DAG: [[STR_GREEN:%[0-9]+:id\(s32\)]] = OpString 1701147207, 110
+; CHECK-MIR-DAG: [[STR_BLUE:%[0-9]+:id\(s32\)]] = OpString 1702194242, 0
+; CHECK-MIR-DAG: [[DBG_SOURCE:%[0-9]+:id\(s32\)]] = OpExtInst [[TYPE_VOID]], 3, 35
+; CHECK-MIR-DAG: [[DBG_CU:%[0-9]+:id\(s32\)]] = OpExtInst [[TYPE_VOID]], 3, 1, [[C_THREE]], [[C_FIVE]], [[DBG_SOURCE]], [[C_THIRTEEN]]
+; CHECK-MIR-DAG: [[DBG_ENUM:%[0-9]+:id\(s32\)]] = OpExtInst [[TYPE_VOID]], 3, 9, {{%[0-9]+\:[a-z0-9\(\)]+}}, {{%[0-9]+\:[a-z0-9\(\)]+}}, [[DBG_SOURCE]], [[C_ONE]], [[C_ONE]], [[DBG_CU]], [[C_THIRTYTWO]], [[C_THREE]], [[C_ONE]], [[STR_RED]], [[C_TWO]], [[STR_GREEN]], [[C_FOUR]], [[STR_BLUE]]
+
+; CHECK-SPIRV-DAG: %[[DBG_SRC:[0-9]+]] = OpExtInst %[[VOID:[0-9]+]] {{%[0-9]+}} DebugSource
+; CHECK-SPIRV-DAG: %[[DBG_CU:[0-9]+]] = OpExtInst %[[VOID]] {{%[0-9]+}} DebugCompilationUnit {{%[0-9]+}} {{%[0-9]+}} %[[DBG_SRC]] {{%[0-9]+}}
+; CHECK-SPIRV-DAG: %[[STR_INT:[0-9]+]] = OpString "int"
+; CHECK-SPIRV-DAG: %[[DBG_TY_INT:[0-9]+]] = OpExtInst %[[VOID]] {{%[0-9]+}} DebugTypeBasic %[[STR_INT]] {{%[0-9]+}} {{%[0-9]+}} {{%[0-9]+}}
+; CHECK-SPIRV-DAG: %[[STR_COLOR:[0-9]+]] = OpString "Color"
+; CHECK-SPIRV-DAG: %[[STR_RED:[0-9]+]]   = OpString "Red"
+; CHECK-SPIRV-DAG: %[[STR_GREEN:[0-9]+]] = OpString "Green"
+; CHECK-SPIRV-DAG: %[[STR_BLUE:[0-9]+]]  = OpString "Blue"
+; CHECK-SPIRV-DAG: %[[DBG_ENUM_COLOR:[0-9]+]] = OpExtInst %[[VOID]] {{%[0-9]+}} DebugTypeEnum %[[STR_COLOR]] %[[DBG_TY_INT]] %[[DBG_SRC]] {{%[0-9]+}} {{%[0-9]+}} %[[DBG_CU]] {{%[0-9]+}} {{%[0-9]+}} {{%[0-9]+}} %[[STR_RED]] {{%[0-9]+}} %[[STR_GREEN]] {{%[0-9]+}} %[[STR_BLUE]]
+
+; CHECK-OPTION-NOT: DebugTypeEnum
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!13, !14, !15, !16, !17, !18, !19}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "c", scope: !2, file: !3, line: 7, type: !5, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !3, producer: "clang version XX.X.XXXX (FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, retainedTypes: !11, globals: !12, splitDebugInlining: false, nameTableKind: None)
+!3 = !DIFile(filename: "example.cpp", directory: "/AAAAAAAAAA/BBBBBBBB/CCCCCCCCC", checksumkind: CSK_MD5, checksum: "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF")
+!4 = !{!5}
+!5 = !DICompositeType(tag: DW_TAG_enumeration_type, name: "Color", file: !3, line: 1, baseType: !6, size: 32, elements: !7, identifier: "_ZTS5Color", flags: DIFlagPublic)
+!6 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed, flags: DIFlagPublic)
+!7 = !{!8, !9, !10}
+!8 = !DIEnumerator(name: "Red", value: 1)
+!9 = !DIEnumerator(name: "Green", value: 2)
+!10 = !DIEnumerator(name: "Blue", value: -4)
+!11 = !{!6}
+!12 = !{!0}
+!13 = !{i32 7, !"Dwarf Version", i32 5}
+!14 = !{i32 2, !"Debug Info Version", i32 3}
+!15 = !{i32 1, !"wchar_size", i32 4}
+!16 = !{i32 8, !"PIC Level", i32 2}
+!17 = !{i32 7, !"PIE Level", i32 2}
+!18 = !{i32 7, !"uwtable", i32 2}
+!19 = !{i32 7, !"frame-pointer", i32 2}
+!21 = distinct !DISubprogram(name: "main", scope: !3, file: !3, line: 9, type: !22, scopeLine: 9, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !2)
+!22 = !DISubroutineType(types: !11, flags: DIFlagPublic)
+!23 = !DILocation(line: 10, column: 29, scope: !21)
+!24 = !DILocation(line: 10, column: 5, scope: !21)
