[llvm] [SPIRV] Emit NonSemantic DebugGlobalVariable (PR #207230)
via llvm-commits
llvm-commits at lists.llvm.org
Thu Jul 2 10:03:07 PDT 2026
llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-backend-spir-v
Author: Manuel Carrasco (mgcarrasco)
<details>
<summary>Changes</summary>
Add emitDebugGlobalVariable to the NSDI handler, translating each DIGlobalVariable to a [DebugGlobalVariable](https://github.khronos.org/SPIRV-Registry/nonsemantic/NonSemantic.Shader.DebugInfo.html#DebugGlobalVariable) ext inst.
---
Patch is 26.93 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/207230.diff
8 Files Affected:
- (modified) llvm/lib/Target/SPIRV/SPIRVNonSemanticDebugHandler.cpp (+122)
- (modified) llvm/lib/Target/SPIRV/SPIRVNonSemanticDebugHandler.h (+53)
- (added) llvm/test/CodeGen/SPIRV/debug-info/debug-global-variable-default-address-space.ll (+43)
- (added) llvm/test/CodeGen/SPIRV/debug-info/debug-global-variable-init-expr.ll (+42)
- (added) llvm/test/CodeGen/SPIRV/debug-info/debug-global-variable-no-backing-var.ll (+42)
- (added) llvm/test/CodeGen/SPIRV/debug-info/debug-global-variable-no-type.ll (+47)
- (added) llvm/test/CodeGen/SPIRV/debug-info/debug-global-variable-skip-static-member.ll (+39)
- (added) llvm/test/CodeGen/SPIRV/debug-info/debug-global-variable-skip-type-not-in-regs.ll (+34)
``````````diff
diff --git a/llvm/lib/Target/SPIRV/SPIRVNonSemanticDebugHandler.cpp b/llvm/lib/Target/SPIRV/SPIRVNonSemanticDebugHandler.cpp
index 7303288aaea16..42c784d0a461d 100644
--- a/llvm/lib/Target/SPIRV/SPIRVNonSemanticDebugHandler.cpp
+++ b/llvm/lib/Target/SPIRV/SPIRVNonSemanticDebugHandler.cpp
@@ -16,6 +16,7 @@
#include "llvm/CodeGen/AsmPrinter.h"
#include "llvm/IR/DebugInfo.h"
#include "llvm/IR/DebugInfoMetadata.h"
+#include "llvm/IR/GlobalVariable.h"
#include "llvm/IR/Module.h"
#include "llvm/MC/MCInst.h"
#include "llvm/MC/MCStreamer.h"
@@ -194,6 +195,9 @@ void SPIRVNonSemanticDebugHandler::beginModule(Module *M) {
SubroutineTypes.clear();
VectorTypes.clear();
SubprogramDeclarations.clear();
+ GlobalVariables.clear();
+ DIGVToLLVMGV.clear();
+ DIGVToInitExpr.clear();
DebugFunctionDeclarationRegs.clear();
ScopeToPathOpStringReg.clear();
CUToCompilationUnitDbgReg.clear();
@@ -251,6 +255,27 @@ void SPIRVNonSemanticDebugHandler::beginModule(Module *M) {
if (!SP->isDefinition())
SubprogramDeclarations.push_back(SP);
}
+
+ // Map DIGlobalVariable -> llvm::GlobalVariable for globals that attach !dbg.
+ // The link lives on the IR global (via DIGlobalVariableExpression); DIGV
+ // metadata has no back-reference to its @g.
+ for (const GlobalVariable &G : M->globals()) {
+ SmallVector<DIGlobalVariableExpression *, 4> GVEs;
+ G.getDebugInfo(GVEs);
+ for (DIGlobalVariableExpression *GVE : GVEs)
+ DIGVToLLVMGV.try_emplace(GVE->getVariable(), &G);
+ }
+
+ // DebugInfoFinder deduplicates expressions but not by their pointed
+ // variables. We use a SmallSetVector to deduplicate them.
+ for (const DIGlobalVariableExpression *GVE : Finder.global_variables()) {
+ GlobalVariables.insert(GVE->getVariable());
+ const DIGlobalVariable *GV = GVE->getVariable();
+ const DIExpression *Expr = GVE->getExpression();
+ // For Variable operand of DebugExpression type in DebugGlobalVariable.
+ if (GV && Expr && Expr->getNumElements())
+ DIGVToInitExpr.try_emplace(GV, Expr);
+ }
}
void SPIRVNonSemanticDebugHandler::prepareModuleOutput(
@@ -561,6 +586,90 @@ std::optional<MCRegister> SPIRVNonSemanticDebugHandler::mapDISignatureTypeToReg(
return lookupOptReg(DebugTypeRegs, Ty);
}
+std::optional<MCRegister>
+SPIRVNonSemanticDebugHandler::resolveGlobalVariableParent(
+ const DIGlobalVariable *GV) const {
+ // TODO: When this backend emits debug instructions for namespace, subprogram,
+ // and module scopes, return GV->getScope()'s debug id.
+
+ // Fallback: first module compile unit (SPIRV-LLVM-Translator default).
+ if (CompileUnits.empty())
+ return std::nullopt;
+ return lookupOptReg(CUToCompilationUnitDbgReg, CompileUnits[0].TheCU);
+}
+
+// Unimplemented no-op; see emitDebugExpression declaration.
+std::optional<MCRegister> SPIRVNonSemanticDebugHandler::emitDebugExpression(
+ const DIExpression *, MCRegister, MCRegister, SPIRV::ModuleAnalysisInfo &) {
+ return std::nullopt;
+}
+
+std::optional<MCRegister> SPIRVNonSemanticDebugHandler::emitDebugGlobalVariable(
+ const DIGlobalVariable *GV, MCRegister VoidTypeReg, MCRegister I32TypeReg,
+ MCRegister ExtInstSetReg, SPIRV::ModuleAnalysisInfo &MAI) {
+ assert(GV && "GV must not be null in emitDebugGlobalVariable");
+
+ auto ParentRegOpt = resolveGlobalVariableParent(GV);
+ if (!ParentRegOpt)
+ return std::nullopt;
+
+ // TyReg: DebugInfoNone when GV has no DI type (as done in
+ // SPIRV-LLVM-Translator). Declarations (isDefinition: false) can have null
+ // getType() while definitions must have a non-null one (enforced by the IR
+ // verifier).
+ MCRegister TyReg = CachedDebugInfoNoneReg;
+ if (const DIType *Ty = GV->getType()) {
+ auto TyRegOpt = lookupOptReg(DebugTypeRegs, Ty);
+ if (!TyRegOpt)
+ return std::nullopt;
+ TyReg = *TyRegOpt;
+ }
+
+ std::optional<MCRegister> StaticMemberRegOpt;
+ if (const DIDerivedType *SM = GV->getStaticDataMemberDeclaration()) {
+ StaticMemberRegOpt = lookupOptReg(DebugTypeRegs, SM);
+ if (!StaticMemberRegOpt)
+ return std::nullopt;
+ }
+
+ MCRegister NameReg = getCachedOpStringReg(GV->getName());
+ MCRegister LinkageReg = getCachedOpStringReg(GV->getLinkageName());
+ MCRegister FileStrReg = getCachedOpStringReg(getDebugFullPath(GV->getFile()));
+ MCRegister SrcReg = getOrEmitDebugSourceForFileStrReg(FileStrReg, VoidTypeReg,
+ ExtInstSetReg, MAI);
+
+ MCRegister LineReg =
+ emitOpConstantI32(static_cast<uint32_t>(GV->getLine()), I32TypeReg, MAI);
+ // DIGlobalVariable metadata carries no column field.
+ // Column is hardcoded to 0, matching SPIRV-LLVM-Translator.
+ MCRegister ColReg = emitOpConstantI32(0, I32TypeReg, MAI);
+
+ // Variable: @g OpVariable id when !dbg matches; else a DebugExpression for
+ // the GVE init value when no @g exists; else DebugInfoNone.
+ MCRegister VariableReg = CachedDebugInfoNoneReg;
+ if (const GlobalVariable *LLVMGV = DIGVToLLVMGV.lookup(GV)) {
+ MCRegister GVReg = MAI.getGlobalObjReg(LLVMGV);
+ if (GVReg.isValid())
+ VariableReg = GVReg;
+ } else if (const DIExpression *InitExpr = DIGVToInitExpr.lookup(GV)) {
+ if (auto ExprReg =
+ emitDebugExpression(InitExpr, VoidTypeReg, ExtInstSetReg, MAI))
+ VariableReg = *ExprReg;
+ }
+
+ MCRegister FlagsReg = emitOpConstantI32(transDebugFlags(GV), I32TypeReg, MAI);
+
+ SmallVector<MCRegister, 10> Ops = {NameReg, TyReg, SrcReg,
+ LineReg, ColReg, *ParentRegOpt,
+ LinkageReg, VariableReg, FlagsReg};
+
+ if (StaticMemberRegOpt)
+ Ops.push_back(*StaticMemberRegOpt);
+
+ return emitExtInst(SPIRV::NonSemanticExtInst::DebugGlobalVariable,
+ VoidTypeReg, ExtInstSetReg, Ops, MAI);
+}
+
std::optional<MCRegister> SPIRVNonSemanticDebugHandler::emitDebugTypeVector(
const DICompositeType *VT, MCRegister ExtInstSetReg,
SPIRV::ModuleAnalysisInfo &MAI) {
@@ -619,6 +728,15 @@ void SPIRVNonSemanticDebugHandler::emitNonSemanticDebugStrings(
ScopeToPathOpStringReg[SP] = emitOpStringIfNew(getDebugFullPath(SP), MAI);
}
+ for (const DIGlobalVariable *GV : GlobalVariables) {
+ emitOpStringIfNew(GV->getName(), MAI);
+ emitOpStringIfNew(GV->getLinkageName(), MAI);
+ SmallString<128> Path = getDebugFullPath(GV->getFile());
+ MCRegister PathReg = emitOpStringIfNew(Path, MAI);
+ if (const DIFile *F = GV->getFile())
+ ScopeToPathOpStringReg[F] = PathReg;
+ }
+
#ifndef NDEBUG
NonSemanticOpStringsSectionEmitted = true;
#endif
@@ -756,6 +874,10 @@ void SPIRVNonSemanticDebugHandler::emitNonSemanticGlobalDebugInfo(
ExtInstSetReg, MAI))
DebugFunctionDeclarationRegs[SP] = *DeclReg;
}
+
+ // Emit DebugGlobalVariable for each collected DIGlobalVariable.
+ for (const DIGlobalVariable *GV : GlobalVariables)
+ emitDebugGlobalVariable(GV, VoidTypeReg, I32TypeReg, ExtInstSetReg, MAI);
}
SmallString<128>
diff --git a/llvm/lib/Target/SPIRV/SPIRVNonSemanticDebugHandler.h b/llvm/lib/Target/SPIRV/SPIRVNonSemanticDebugHandler.h
index ceb5573b55873..d0bbea07e73f8 100644
--- a/llvm/lib/Target/SPIRV/SPIRVNonSemanticDebugHandler.h
+++ b/llvm/lib/Target/SPIRV/SPIRVNonSemanticDebugHandler.h
@@ -21,6 +21,7 @@
#include "MCTargetDesc/SPIRVBaseInfo.h"
#include "SPIRVModuleAnalysis.h"
#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/SetVector.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringMap.h"
@@ -32,6 +33,7 @@
namespace llvm {
+class GlobalVariable;
class SPIRVSubtarget;
/// AsmPrinter handler that emits NonSemantic.Shader.DebugInfo.100 (NSDI)
@@ -75,6 +77,21 @@ class SPIRVNonSemanticDebugHandler : public DebugHandlerBase {
// in beginModule() for DebugFunctionDeclaration emission.
SmallVector<const DISubprogram *> SubprogramDeclarations;
+ // DIGlobalVariable nodes for DebugGlobalVariable emission; SmallSetVector
+ // dedupes (see beginModule()).
+ SmallSetVector<const DIGlobalVariable *, 8> GlobalVariables;
+
+ // Maps a DIGlobalVariable to the llvm::GlobalVariable it describes, when the
+ // module has one with matching debug info. Used to fill the Variable operand
+ // of DebugGlobalVariable with the global's SPIR-V result id. Absent
+ // entries fall back to DebugInfoNone.
+ DenseMap<const DIGlobalVariable *, const GlobalVariable *> DIGVToLLVMGV;
+
+ // First non-empty DIExpression per DIGV from the CU global list (finder
+ // order). For Variable operand of DebugExpression type in
+ // DebugGlobalVariable, when supported.
+ DenseMap<const DIGlobalVariable *, const DIExpression *> DIGVToInitExpr;
+
// DebugFunctionDeclaration result id per emitted declaration DISubprogram
// (only entries where emission succeeded).
DenseMap<const DISubprogram *, MCRegister> DebugFunctionDeclarationRegs;
@@ -256,6 +273,42 @@ class SPIRVNonSemanticDebugHandler : public DebugHandlerBase {
MCRegister I32TypeReg, MCRegister ExtInstSetReg,
SPIRV::ModuleAnalysisInfo &MAI);
+ /// Emit \c DebugGlobalVariable for the source global variable \p GV.
+ ///
+ /// (\c SPIRVDebug::Operand::GlobalVariable): Name, Type, Source, Line,
+ /// Column, Parent, Linkage Name, Variable, Flags, and an optional Static
+ /// Member Declaration. Line, Column, and Flags are emitted as \c OpConstant
+ /// ids as required for non-semantic debug info.
+ ///
+ /// \c DebugInfoNone is used for two operands when LLVM has no value to
+ /// supply:
+ /// \c Type when \p GV is a declaration with no DI type (e.g. \c extern void;
+ /// valid IR, \c isDefinition: false); \c Variable when no \c
+ /// llvm::GlobalVariable in this module carries \p GV in its \c !dbg metadata.
+ ///
+ /// \returns The result id register on success. Returns \c std::nullopt and
+ /// emits nothing if a non-null \p GV type was not emitted in \c
+ /// DebugTypeRegs,
+ /// \p GV has a static data member declaration that was not emitted in
+ /// \c DebugTypeRegs, or \c resolveGlobalVariableParent returns no id for the
+ /// \c Parent operand.
+ std::optional<MCRegister>
+ emitDebugGlobalVariable(const DIGlobalVariable *GV, MCRegister VoidTypeReg,
+ MCRegister I32TypeReg, MCRegister ExtInstSetReg,
+ SPIRV::ModuleAnalysisInfo &MAI);
+
+ /// Resolve the \c Parent operand for \c DebugGlobalVariable.
+ std::optional<MCRegister>
+ resolveGlobalVariableParent(const DIGlobalVariable *GV) const;
+
+ /// Emit \c DebugExpression for \p Expr. Unimplemented: defined as a no-op
+ /// (\returns \c std::nullopt, emits nothing) so \c emitDebugGlobalVariable
+ /// can complete Variable-operand resolution for the opcodes we support today.
+ std::optional<MCRegister> emitDebugExpression(const DIExpression *Expr,
+ MCRegister VoidTypeReg,
+ MCRegister ExtInstSetReg,
+ SPIRV::ModuleAnalysisInfo &MAI);
+
/// Emit \c DebugTypeVector for the vector composite type \p VT.
///
/// \returns The result id register on success. Returns \c std::nullopt and
diff --git a/llvm/test/CodeGen/SPIRV/debug-info/debug-global-variable-default-address-space.ll b/llvm/test/CodeGen/SPIRV/debug-info/debug-global-variable-default-address-space.ll
new file mode 100644
index 0000000000000..590462a4859c3
--- /dev/null
+++ b/llvm/test/CodeGen/SPIRV/debug-info/debug-global-variable-default-address-space.ll
@@ -0,0 +1,43 @@
+; RUN: llc --verify-machineinstrs --spirv-ext=+SPV_KHR_non_semantic_info -O0 -mtriple=spirv64-unknown-unknown %s -o - | FileCheck %s
+; RUN: %if spirv-tools %{ llc --verify-machineinstrs --spirv-ext=+SPV_KHR_non_semantic_info -O0 -mtriple=spirv64-unknown-unknown %s -o - -filetype=obj | spirv-val %}
+
+; A default-address-space global with !dbg. Such globals do not become a
+; module-scope OpVariable (they are turned into function-local copies), so no
+; result id is registered for them. The DIGlobalVariable is still emitted, but
+; its Variable operand falls back to DebugInfoNone.
+
+; CHECK-DAG: [[EXT:%[0-9]+]] = OpExtInstImport "NonSemantic.Shader.DebugInfo.100"
+; CHECK-DAG: [[VOID:%[0-9]+]] = OpTypeVoid
+; CHECK-DAG: [[I32T:%[0-9]+]] = OpTypeInt 32 0
+; CHECK-DAG: [[NAME:%[0-9]+]] = OpString "localas"
+; CHECK-DAG: [[STR_INT:%[0-9]+]] = OpString "int"
+; CHECK-DAG: [[C42:%[0-9]+]] = OpConstant [[I32T]] 42
+; CHECK-DAG: [[NONE:%[0-9]+]] = OpExtInst [[VOID]] [[EXT]] DebugInfoNone
+; CHECK-DAG: [[DS:%[0-9]+]] = OpExtInst [[VOID]] [[EXT]] DebugSource
+; CHECK-DAG: [[DTI:%[0-9]+]] = OpExtInst [[VOID]] [[EXT]] DebugTypeBasic [[STR_INT]]
+; CHECK-DAG: OpExtInst [[VOID]] [[EXT]] DebugGlobalVariable [[NAME]] [[DTI]] [[DS]] [[C42]] {{%[0-9]+}} {{%[0-9]+}} [[NAME]] [[NONE]]
+
+target triple = "spirv64-unknown-unknown"
+
+ at g = dso_local global i32 0, align 4, !dbg !0
+
+define spir_func void @f() !dbg !9 {
+entry:
+ ret void, !dbg !10
+}
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!12, !13}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "localas", linkageName: "localas", scope: !2, file: !3, line: 42, type: !8, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, globals: !4, splitDebugInlining: false, nameTableKind: None)
+!3 = !DIFile(filename: "t.c", directory: "/tmp")
+!4 = !{!0}
+!8 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!9 = distinct !DISubprogram(name: "f", scope: !3, file: !3, line: 1, type: !16, scopeLine: 1, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !2)
+!10 = !DILocation(line: 2, column: 1, scope: !9)
+!12 = !{i32 7, !"Dwarf Version", i32 5}
+!13 = !{i32 2, !"Debug Info Version", i32 3}
+!16 = !DISubroutineType(cc: DW_CC_LLVM_SpirFunction, types: !17)
+!17 = !{null}
diff --git a/llvm/test/CodeGen/SPIRV/debug-info/debug-global-variable-init-expr.ll b/llvm/test/CodeGen/SPIRV/debug-info/debug-global-variable-init-expr.ll
new file mode 100644
index 0000000000000..fb83a6350ce03
--- /dev/null
+++ b/llvm/test/CodeGen/SPIRV/debug-info/debug-global-variable-init-expr.ll
@@ -0,0 +1,42 @@
+; RUN: llc --verify-machineinstrs --spirv-ext=+SPV_KHR_non_semantic_info -O0 -mtriple=spirv64-unknown-unknown %s -o - | FileCheck %s
+; RUN: %if spirv-tools %{ llc --verify-machineinstrs --spirv-ext=+SPV_KHR_non_semantic_info -O0 -mtriple=spirv64-unknown-unknown %s -o - -filetype=obj | spirv-val %}
+
+; A DIGlobalVariable with no backing llvm::GlobalVariable but whose
+; DIGlobalVariableExpression carries a non-empty DIExpression (a constant
+; initializer). Since DebugExpression emission is not implemented, the Variable
+; operand falls back to DebugInfoNone. Flags encode IsLocal|IsDefinition (12).
+
+; CHECK-DAG: [[EXT:%[0-9]+]] = OpExtInstImport "NonSemantic.Shader.DebugInfo.100"
+; CHECK-DAG: [[VOID:%[0-9]+]] = OpTypeVoid
+; CHECK-DAG: [[I32T:%[0-9]+]] = OpTypeInt 32 0
+; CHECK-DAG: [[NAME:%[0-9]+]] = OpString "constg"
+; CHECK-DAG: [[STR_INT:%[0-9]+]] = OpString "int"
+; CHECK-DAG: [[C42:%[0-9]+]] = OpConstant [[I32T]] 42
+; CHECK-DAG: [[C12:%[0-9]+]] = OpConstant [[I32T]] 12
+; CHECK-DAG: [[NONE:%[0-9]+]] = OpExtInst [[VOID]] [[EXT]] DebugInfoNone
+; CHECK-DAG: [[DS:%[0-9]+]] = OpExtInst [[VOID]] [[EXT]] DebugSource
+; CHECK-DAG: [[DTI:%[0-9]+]] = OpExtInst [[VOID]] [[EXT]] DebugTypeBasic [[STR_INT]]
+; CHECK-DAG: OpExtInst [[VOID]] [[EXT]] DebugGlobalVariable [[NAME]] [[DTI]] [[DS]] [[C42]] {{%[0-9]+}} {{%[0-9]+}} [[NAME]] [[NONE]] [[C12]]
+
+target triple = "spirv64-unknown-unknown"
+
+define spir_func void @f() !dbg !9 {
+entry:
+ ret void, !dbg !10
+}
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!12, !13}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression(DW_OP_constu, 42, DW_OP_stack_value))
+!1 = distinct !DIGlobalVariable(name: "constg", linkageName: "constg", scope: !2, file: !3, line: 42, type: !8, isLocal: true, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, globals: !4, splitDebugInlining: false, nameTableKind: None)
+!3 = !DIFile(filename: "t.c", directory: "/tmp")
+!4 = !{!0}
+!8 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!9 = distinct !DISubprogram(name: "f", scope: !3, file: !3, line: 1, type: !16, scopeLine: 1, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !2)
+!10 = !DILocation(line: 2, column: 1, scope: !9)
+!12 = !{i32 7, !"Dwarf Version", i32 5}
+!13 = !{i32 2, !"Debug Info Version", i32 3}
+!16 = !DISubroutineType(cc: DW_CC_LLVM_SpirFunction, types: !17)
+!17 = !{null}
diff --git a/llvm/test/CodeGen/SPIRV/debug-info/debug-global-variable-no-backing-var.ll b/llvm/test/CodeGen/SPIRV/debug-info/debug-global-variable-no-backing-var.ll
new file mode 100644
index 0000000000000..d77c0887e8cc4
--- /dev/null
+++ b/llvm/test/CodeGen/SPIRV/debug-info/debug-global-variable-no-backing-var.ll
@@ -0,0 +1,42 @@
+; RUN: llc --verify-machineinstrs --spirv-ext=+SPV_KHR_non_semantic_info -O0 -mtriple=spirv64-unknown-unknown %s -o - | FileCheck %s
+; RUN: %if spirv-tools %{ llc --verify-machineinstrs --spirv-ext=+SPV_KHR_non_semantic_info -O0 -mtriple=spirv64-unknown-unknown %s -o - -filetype=obj | spirv-val %}
+
+; A DIGlobalVariable listed in the compile unit's globals but with no backing
+; llvm::GlobalVariable in the module and an empty DIExpression. The Type operand
+; still resolves (int), but the Variable operand falls back to DebugInfoNone.
+
+; CHECK-DAG: [[EXT:%[0-9]+]] = OpExtInstImport "NonSemantic.Shader.DebugInfo.100"
+; CHECK-DAG: [[VOID:%[0-9]+]] = OpTypeVoid
+; CHECK-DAG: [[I32T:%[0-9]+]] = OpTypeInt 32 0
+; CHECK-DAG: [[NAME:%[0-9]+]] = OpString "novar"
+; CHECK-DAG: [[STR_INT:%[0-9]+]] = OpString "int"
+; CHECK-DAG: [[C0:%[0-9]+]] = OpConstant [[I32T]] 0
+; CHECK-DAG: [[C42:%[0-9]+]] = OpConstant [[I32T]] 42
+; CHECK-DAG: [[NONE:%[0-9]+]] = OpExtInst [[VOID]] [[EXT]] DebugInfoNone
+; CHECK-DAG: [[DS:%[0-9]+]] = OpExtInst [[VOID]] [[EXT]] DebugSource
+; CHECK-DAG: [[CU:%[0-9]+]] = OpExtInst [[VOID]] [[EXT]] DebugCompilationUnit {{.*}} [[DS]] [[C0]]
+; CHECK-DAG: [[DTI:%[0-9]+]] = OpExtInst [[VOID]] [[EXT]] DebugTypeBasic [[STR_INT]]
+; CHECK-DAG: OpExtInst [[VOID]] [[EXT]] DebugGlobalVariable [[NAME]] [[DTI]] [[DS]] [[C42]] [[C0]] [[CU]] [[NAME]] [[NONE]]
+
+target triple = "spirv64-unknown-unknown"
+
+define spir_func void @f() !dbg !9 {
+entry:
+ ret void, !dbg !10
+}
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!12, !13}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "novar", linkageName: "novar", scope: !2, file: !3, line: 42, type: !8, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, globals: !4, splitDebugInlining: false, nameTableKind: None)
+!3 = !DIFile(filename: "t.c", directory: "/tmp")
+!4 = !{!0}
+!8 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!9 = distinct !DISubprogram(name: "f", scope: !3, file: !3, line: 1, type: !16, scopeLine: 1, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !2)
+!10 = !DILocation(line: 2, column: 1, scope: !9)
+!12 = !{i32 7, !"Dwarf Version", i32 5}
+!13 = !{i32 2, !"Debug Info Version", i32 3}
+!16 = !DISubroutineType(cc: DW_CC_LLVM_SpirFunction, types: !17)
+!17 = !{null}
diff --git a/llvm/test/CodeGen/SPIRV/debug-info/debug-global-variable-no-type.ll b/llvm/test/CodeGen/SPIRV/debug-info/debug-global-variable-no-type.ll
new file mode 100644
index 0000000000000..a0b3df4632aba
--- /dev/null
+++ b/llvm/test/CodeGen/SPIRV/debug-info/debug-global-variable-no-type.ll
@@ -0,0 +1,47 @@
+; RUN: llc --verify-machineinstrs --spirv-ext=+SPV_KHR_non_semantic_info -O0 -mtriple=spirv64-unknown-unknown %s -o - | FileCheck %s
+
+; This is an edge case: IR that is valid but cannot be correctly encoded in SPIRV.
+
+; A DIGlobalVariable declaration with a null type (isDefinition: false, which the
+; IR verifier permits) ...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/207230
More information about the llvm-commits
mailing list