[llvm-branch-commits] [llvm] Implement support for NSDI DebugFunctionDefinition. (PR #211853)
via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Tue Jul 28 09:47:50 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>
This is a draft and depends on the DebugFunction PR: https://github.com/llvm/llvm-project/pull/211760. This PR implements support for [DebugFunctionDefinition](https://github.khronos.org/SPIRV-Registry/nonsemantic/NonSemantic.Shader.DebugInfo.html#DebugFunctionDefinition).
I wanted to gather some early feedback on the core logic for supporting DebugFunctionDefinition.
This opcode must be emitted within the instruction sequence of its corresponding OpFunction. The current implementation inserts DebugFunctionDefinition immediately after the last OpVariable, if one exists, or otherwise immediately after the first OpLabel. The goal is to satisfy the following [requirement](https://github.khronos.org/SPIRV-Registry/nonsemantic/NonSemantic.Shader.DebugInfo.html#_binary_form):
> DebugScope, DebugNoScope, DebugDeclare, DebugValue, DebugLine, DebugNoLine, and DebugFunctionDefinition instructions may interleave with instructions inside a function, but they must appear at valid locations within a block as required by SPV_KHR_non_semantic_info. In particular, they cannot appear before any OpPhi or function-level variable declarations in a block, and they cannot appear after a merge instruction.
To support this, I updated SPIRVAsmPrinter to notify the debug handler whenever an instruction is emitted. The debug handler maintains a small amount of state so it can detect when the last OpVariable or the first OpLabel has been emitted and insert DebugFunctionDefinition at the appropriate location.
Does this seem like the right approach, or is there a cleaner way to handle this placement logic? Hopefully this is aligned with the previous TODO comments.
---
Patch is 22.06 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/211853.diff
5 Files Affected:
- (modified) llvm/lib/Target/SPIRV/SPIRVAsmPrinter.cpp (+11-3)
- (modified) llvm/lib/Target/SPIRV/SPIRVNonSemanticDebugHandler.cpp (+165-11)
- (modified) llvm/lib/Target/SPIRV/SPIRVNonSemanticDebugHandler.h (+55-26)
- (added) llvm/test/CodeGen/SPIRV/debug-info/debug-function-definition-after-opvariable.ll (+36)
- (added) llvm/test/CodeGen/SPIRV/debug-info/debug-function-definition.ll (+55)
``````````diff
diff --git a/llvm/lib/Target/SPIRV/SPIRVAsmPrinter.cpp b/llvm/lib/Target/SPIRV/SPIRVAsmPrinter.cpp
index 31953bf811982..7376e97b80901 100644
--- a/llvm/lib/Target/SPIRV/SPIRVAsmPrinter.cpp
+++ b/llvm/lib/Target/SPIRV/SPIRVAsmPrinter.cpp
@@ -322,16 +322,24 @@ void SPIRVAsmPrinter::emitInstruction(const MachineInstr *MI) {
SPIRV_MC::verifyInstructionPredicates(MI->getOpcode(),
getSubtargetInfo().getFeatureBits());
- if (!MAI->getSkipEmission(MI))
+ bool InstructionEmitted = !MAI->getSkipEmission(MI);
+ if (InstructionEmitted)
outputInstruction(MI);
// Output OpLabel after OpFunction and OpFunctionParameter in the first MBB.
const MachineInstr *NextMI = MI->getNextNode();
- if (!LabeledMBB.contains(MI->getParent()) && isFuncOrHeaderInstr(MI, TII) &&
- (!NextMI || !isFuncOrHeaderInstr(NextMI, TII))) {
+ bool BlockHasLabel = LabeledMBB.contains(MI->getParent());
+ bool IsFunctionPreambleInstruction = isFuncOrHeaderInstr(MI, TII);
+ bool IsNextInstructionFunctionPreamble =
+ NextMI && isFuncOrHeaderInstr(NextMI, TII);
+ bool ShouldEmitEntryLabel = !BlockHasLabel && IsFunctionPreambleInstruction &&
+ !IsNextInstructionFunctionPreamble;
+ if (ShouldEmitEntryLabel) {
assert(MI->getParent()->getNumber() == MF->front().getNumber() &&
"OpFunction is not in the front MBB of MF");
emitOpLabel(*MI->getParent());
+ if (NSDebugHandler && !isHidden())
+ NSDebugHandler->notifyEntryLabelEmitted(*MF, *MAI);
}
}
diff --git a/llvm/lib/Target/SPIRV/SPIRVNonSemanticDebugHandler.cpp b/llvm/lib/Target/SPIRV/SPIRVNonSemanticDebugHandler.cpp
index 953a66162ba26..01fa481435470 100644
--- a/llvm/lib/Target/SPIRV/SPIRVNonSemanticDebugHandler.cpp
+++ b/llvm/lib/Target/SPIRV/SPIRVNonSemanticDebugHandler.cpp
@@ -14,6 +14,8 @@
#include "llvm/ADT/SmallVectorExtras.h"
#include "llvm/BinaryFormat/Dwarf.h"
#include "llvm/CodeGen/AsmPrinter.h"
+#include "llvm/CodeGen/MachineFunction.h"
+#include "llvm/CodeGen/MachineInstr.h"
#include "llvm/IR/DebugInfo.h"
#include "llvm/IR/DebugInfoMetadata.h"
#include "llvm/IR/GlobalVariable.h"
@@ -168,6 +170,35 @@ static uint32_t transDebugFlags(const DINode *DN) {
return Flags;
}
+static const MachineInstr *
+findLastEmittedFunctionOpVariable(const MachineFunction &MF,
+ SPIRV::ModuleAnalysisInfo &MAI) {
+
+ // We iterate over the instructions to find the last OpVariable instruction if
+ // any. The following SPIRV rule is used to terminate the traversal earlier:
+ // SPIR-V 2.16.1, Function Structure: "All OpVariable instructions in a
+ // function must be in the first block in the function. These instructions,
+ // together with any intermixed OpLine and OpNoLine instructions, must be the
+ // first instructions in that block."
+ const MachineInstr *LastOpVariable = nullptr;
+ bool SeenOpVariable = false;
+ for (const MachineInstr &MI : MF.front()) {
+ if (MI.getOpcode() == SPIRV::OpVariable) {
+ SeenOpVariable = true;
+ if (!MAI.getSkipEmission(&MI))
+ LastOpVariable = &MI;
+ continue;
+ }
+
+ bool CanInterleaveWithOpVariable =
+ MI.getOpcode() == SPIRV::OpLine || MI.getOpcode() == SPIRV::OpNoLine;
+ if (SeenOpVariable && !CanInterleaveWithOpVariable &&
+ !MAI.getSkipEmission(&MI))
+ break;
+ }
+ return LastOpVariable;
+}
+
} // namespace
SPIRVNonSemanticDebugHandler::SPIRVNonSemanticDebugHandler(AsmPrinter &AP)
@@ -215,6 +246,7 @@ void SPIRVNonSemanticDebugHandler::beginModule(Module *M) {
SubprogramDefinitions.clear();
GlobalVariableDebugInfoMap.clear();
DebugFunctionDeclarationRegs.clear();
+ DebugFunctionRegs.clear();
ScopeToPathOpStringReg.clear();
CUToCompilationUnitDbgReg.clear();
DebugSourceRegByFileStr.clear();
@@ -223,6 +255,8 @@ void SPIRVNonSemanticDebugHandler::beginModule(Module *M) {
I32ConstantCache.clear();
DebugTypeFunctionCache.clear();
GlobalDIEmitted = false;
+ GlobalNSDIEnabled = false;
+ CurrentMAI = nullptr;
#ifndef NDEBUG
NonSemanticOpStringsSectionEmitted = false;
#endif
@@ -309,8 +343,6 @@ void SPIRVNonSemanticDebugHandler::prepareModuleOutput(
// Add the NonSemantic.Shader.DebugInfo.100 entry to ExtInstSetMap so that
// outputOpExtInstImports() emits the OpExtInstImport instruction. Allocate a
// fresh result ID for it now; the same ID is used in emitExtInst() operands.
- constexpr unsigned NSSet = static_cast<unsigned>(
- SPIRV::InstructionSet::NonSemantic_Shader_DebugInfo_100);
if (!MAI.ExtInstSetMap.count(NSSet))
MAI.ExtInstSetMap[NSSet] = MAI.getNextIDRegister();
}
@@ -823,8 +855,6 @@ void SPIRVNonSemanticDebugHandler::emitNonSemanticDebugStrings(
// Check that prepareModuleOutput() registered the extended instruction set.
// If the subtarget does not support the extension, neither strings nor ext
// insts are emitted.
- constexpr unsigned NSSet = static_cast<unsigned>(
- SPIRV::InstructionSet::NonSemantic_Shader_DebugInfo_100);
if (!MAI.getExtInstSetReg(NSSet).isValid())
return;
@@ -863,18 +893,135 @@ void SPIRVNonSemanticDebugHandler::emitNonSemanticDebugStrings(
#endif
}
+void SPIRVNonSemanticDebugHandler::emitDebugFunctionDefinition(
+ MCRegister DebugFunctionReg, MCRegister OpFunctionReg,
+ SPIRV::ModuleAnalysisInfo &MAI) {
+ assert(DebugFunctionReg.isValid() && OpFunctionReg.isValid() &&
+ "DebugFunctionDefinition operands must be valid");
+ MCRegister VoidTypeReg = getOrEmitOpTypeVoidReg(MAI);
+ MCRegister ExtInstSetReg = MAI.getExtInstSetReg(NSSet);
+ emitExtInst(SPIRV::NonSemanticExtInst::DebugFunctionDefinition, VoidTypeReg,
+ ExtInstSetReg, {DebugFunctionReg, OpFunctionReg}, MAI);
+}
+
+void SPIRVNonSemanticDebugHandler::resetPerFunctionDebugState() {
+ CurrentMF = nullptr;
+ LastFunctionOpVariable = nullptr;
+ DebugFunctionDefinitionEmitted = false;
+}
+
+void SPIRVNonSemanticDebugHandler::preparePerFunctionDebug(
+ const MachineFunction *MF) {
+ resetPerFunctionDebugState();
+ if (!GlobalNSDIEnabled || !CurrentMAI)
+ return;
+
+ CurrentMF = MF;
+
+ if (MF->getFunction()
+ .getFnAttribute(SPIRV_BACKEND_SERVICE_FUN_NAME)
+ .isValid())
+ return;
+
+ const DISubprogram *SP = MF->getFunction().getSubprogram();
+ if (!SP || !SP->isDefinition())
+ return;
+
+ // DebugFunctionDefinition is emitted after the last function-level
+ // OpVariable. If there are none, it is emitted after the entry OpLabel.
+ LastFunctionOpVariable = findLastEmittedFunctionOpVariable(*MF, *CurrentMAI);
+}
+
+void SPIRVNonSemanticDebugHandler::tryEmitDebugFunctionDefinition(
+ SPIRV::ModuleAnalysisInfo &MAI) {
+ if (DebugFunctionDefinitionEmitted || !GlobalNSDIEnabled)
+ return;
+
+ assert(CurrentMF && "no current MachineFunction");
+ const Function &F = CurrentMF->getFunction();
+ const DISubprogram *SP = F.getSubprogram();
+ if (!SP || !SP->isDefinition())
+ return;
+
+ auto DFIt = DebugFunctionRegs.find(SP);
+ if (DFIt == DebugFunctionRegs.end())
+ return;
+
+ MCRegister OpFunctionReg = MAI.getGlobalObjReg(&F);
+ if (!OpFunctionReg.isValid())
+ return;
+
+ emitDebugFunctionDefinition(DFIt->second, OpFunctionReg, MAI);
+ DebugFunctionDefinitionEmitted = true;
+}
+
+void SPIRVNonSemanticDebugHandler::beginFunctionImpl(
+ const MachineFunction *MF) {
+ preparePerFunctionDebug(MF);
+}
+
+void SPIRVNonSemanticDebugHandler::endFunctionImpl(const MachineFunction *MF) {
+ (void)MF;
+ resetPerFunctionDebugState();
+}
+
+void SPIRVNonSemanticDebugHandler::beginInstruction(const MachineInstr *MI) {
+ assert(CurMI == nullptr && "CurMI must be null");
+ CurMI = MI;
+}
+
+void SPIRVNonSemanticDebugHandler::endInstruction() {
+ const MachineInstr *MI = CurMI;
+ CurMI = nullptr;
+
+ if (!MI || !GlobalNSDIEnabled || DebugFunctionDefinitionEmitted || !CurrentMF)
+ return;
+
+ if (MI != LastFunctionOpVariable)
+ return;
+
+ // If this is the last function-level OpVariable, emit the
+ // DebugFunctionDefinition. Otherwise, we had already done it before right
+ // after the OpLabel (see notifyEntryLabelEmitted).
+ assert(CurrentMAI && "CurrentMAI must be set");
+ tryEmitDebugFunctionDefinition(*CurrentMAI);
+}
+
+void SPIRVNonSemanticDebugHandler::notifyEntryLabelEmitted(
+ const MachineFunction &MF, SPIRV::ModuleAnalysisInfo &MAI) {
+ if (!GlobalNSDIEnabled || DebugFunctionDefinitionEmitted || !CurrentMF)
+ return;
+
+ assert(CurrentMF == &MF &&
+ "notification does not match the current MachineFunction");
+
+ if (LastFunctionOpVariable)
+ return;
+
+ // If there are no function-level OpVariables, emit the
+ // DebugFunctionDefinition. Otherwise, DebugFunctionDefinition is emitted
+ // after the last OpVariable (see endInstruction).
+ tryEmitDebugFunctionDefinition(*CurrentMAI);
+}
+
void SPIRVNonSemanticDebugHandler::emitNonSemanticGlobalDebugInfo(
SPIRV::ModuleAnalysisInfo &MAI) {
- if (GlobalDIEmitted || CompileUnits.empty())
+ if (GlobalDIEmitted)
return;
+
GlobalDIEmitted = true;
+ if (CompileUnits.empty()) {
+ GlobalNSDIEnabled = false;
+ return;
+ }
+
// Retrieve the ext inst set register allocated by prepareModuleOutput().
- constexpr unsigned NSSet = static_cast<unsigned>(
- SPIRV::InstructionSet::NonSemantic_Shader_DebugInfo_100);
MCRegister ExtInstSetReg = MAI.getExtInstSetReg(NSSet);
- if (!ExtInstSetReg.isValid())
- return; // Extension not available.
+ if (!ExtInstSetReg.isValid()) {
+ GlobalNSDIEnabled = false;
+ return;
+ }
#ifndef NDEBUG
assert(NonSemanticOpStringsSectionEmitted &&
@@ -882,6 +1029,8 @@ void SPIRVNonSemanticDebugHandler::emitNonSemanticGlobalDebugInfo(
"emitNonSemanticGlobalDebugInfo()");
#endif
+ CurrentMAI = &MAI;
+
MCRegister VoidTypeReg = getOrEmitOpTypeVoidReg(MAI);
MCRegister I32TypeReg = getOrEmitOpTypeInt32Reg(MAI);
@@ -1005,13 +1154,18 @@ void SPIRVNonSemanticDebugHandler::emitNonSemanticGlobalDebugInfo(
}
// Emit DebugFunction for DISubprogram definitions.
- for (const DISubprogram *SP : SubprogramDefinitions)
- emitDebugFunction(SP, VoidTypeReg, I32TypeReg, ExtInstSetReg, MAI);
+ for (const DISubprogram *SP : SubprogramDefinitions) {
+ if (auto FnReg =
+ emitDebugFunction(SP, VoidTypeReg, I32TypeReg, ExtInstSetReg, MAI))
+ DebugFunctionRegs[SP] = *FnReg;
+ }
// Emit DebugGlobalVariable for each collected DIGlobalVariable.
for (const auto &[GV, Info] : GlobalVariableDebugInfoMap)
emitDebugGlobalVariable(GV, Info, VoidTypeReg, I32TypeReg, ExtInstSetReg,
MAI);
+
+ GlobalNSDIEnabled = true;
}
SmallString<128>
diff --git a/llvm/lib/Target/SPIRV/SPIRVNonSemanticDebugHandler.h b/llvm/lib/Target/SPIRV/SPIRVNonSemanticDebugHandler.h
index c9e1947536443..5e6c6548a0cfa 100644
--- a/llvm/lib/Target/SPIRV/SPIRVNonSemanticDebugHandler.h
+++ b/llvm/lib/Target/SPIRV/SPIRVNonSemanticDebugHandler.h
@@ -40,17 +40,20 @@ class SPIRVSubtarget;
/// the module contains debug info (llvm.dbg.cu).
///
/// Call sequence:
-/// beginModule() -- collect compile-unit metadata.
-/// prepareModuleOutput() -- add extension + ext inst set to MAI.
-/// emitNonSemanticDebugStrings() -- OpString for NSDI strings (sec. 7).
-/// emitNonSemanticGlobalDebugInfo() -- emit DebugSource,
-/// DebugCompilationUnit, DebugTypeBasic,
-/// DebugTypePointer, DebugTypeFunction,
-/// DebugFunctionDeclaration,
-/// DebugFunction.
-/// beginFunctionImpl() -- no-op (no per-function DI yet).
-/// endFunctionImpl() -- no-op.
+/// - beginModule() collects compile-unit metadata.
+/// - prepareModuleOutput() adds the extension and ext-inst set to MAI.
+/// - emitNonSemanticDebugStrings() emits NSDI OpStrings in section 7.
+/// - emitNonSemanticGlobalDebugInfo() emits module-scope NSDI and sets
+/// GlobalNSDIEnabled.
+/// - beginFunctionImpl() prepares per-function DebugFunctionDefinition state.
+/// - endInstruction() emits DebugFunctionDefinition after the last function-
+/// level OpVariable; SPIRVAsmPrinter calls notifyEntryLabelEmitted() after
+/// the synthesized entry OpLabel when there are no OpVariables.
+/// - endFunctionImpl() resets per-function state.
class SPIRVNonSemanticDebugHandler : public DebugHandlerBase {
+ static constexpr unsigned NSSet = static_cast<unsigned>(
+ SPIRV::InstructionSet::NonSemantic_Shader_DebugInfo_100);
+
struct CompileUnitInfo {
const DICompileUnit *TheCU = nullptr;
SmallString<128> FilePath;
@@ -95,6 +98,10 @@ class SPIRVNonSemanticDebugHandler : public DebugHandlerBase {
// (only entries where emission succeeded).
DenseMap<const DISubprogram *, MCRegister> DebugFunctionDeclarationRegs;
+ // DebugFunction result id per emitted definition DISubprogram (only entries
+ // where emission succeeded).
+ DenseMap<const DISubprogram *, MCRegister> DebugFunctionRegs;
+
// Path \c OpString result id per \c DIScope (CU, \c DIFile, declaration
// \c DISubprogram, …). Filled during \c emitNonSemanticDebugStrings() using
// \c getDebugFullPath + \c emitOpStringIfNew; section 10 uses it for
@@ -142,6 +149,18 @@ class SPIRVNonSemanticDebugHandler : public DebugHandlerBase {
// change.
bool GlobalDIEmitted = false;
+ // True when emitNonSemanticGlobalDebugInfo() completed module-scope NSDI
+ // emission for this module.
+ bool GlobalNSDIEnabled = false;
+
+ SPIRV::ModuleAnalysisInfo *CurrentMAI = nullptr;
+
+ const MachineFunction *CurrentMF = nullptr;
+
+ const MachineInstr *LastFunctionOpVariable = nullptr;
+
+ bool DebugFunctionDefinitionEmitted = false;
+
public:
explicit SPIRVNonSemanticDebugHandler(AsmPrinter &AP);
@@ -171,8 +190,13 @@ class SPIRVNonSemanticDebugHandler : public DebugHandlerBase {
/// SPIRVAsmPrinter::outputModuleSections() at section 10 in place of
/// outputModuleSection(MB_NonSemanticGlobalDI). Requires
/// emitNonSemanticDebugStrings() to have run first when NSDI strings apply.
+ /// Sets \c GlobalNSDIEnabled when module-scope NSDI emission completes.
void emitNonSemanticGlobalDebugInfo(SPIRV::ModuleAnalysisInfo &MAI);
+ /// Called after the synthesized entry \c OpLabel has been emitted.
+ void notifyEntryLabelEmitted(const MachineFunction &MF,
+ SPIRV::ModuleAnalysisInfo &MAI);
+
protected:
// All module-level output is driven by emitNonSemanticGlobalDebugInfo(),
// called explicitly from SPIRVAsmPrinter::outputModuleSections(). Nothing
@@ -182,24 +206,29 @@ class SPIRVNonSemanticDebugHandler : public DebugHandlerBase {
// DebugHandlerBase stores MMI as a pointer copy from Asm->MMI at construction
// time (DebugHandlerBase.cpp: `MMI(Asm->MMI)`). The handler is constructed
// before AsmPrinter::doInitialization() runs, so Asm->MMI is null at that
- // point and MMI remains null for this handler's entire lifetime. The
- // base-class beginInstruction/endInstruction dereference MMI to create temp
- // symbols for label tracking and would crash. Override them as no-ops.
- // When per-function NSDI is implemented, use Asm->OutStreamer->getContext()
- // for MCContext access rather than MMI->getContext().
- void beginInstruction(const MachineInstr *MI) override {}
- void endInstruction() override {}
-
- // TODO: Emit DebugFunctionDefinition here once per-function NSDI emission is
- // implemented. DebugHandlerBase::beginFunction() populates LScopes and
- // DbgValues, which are needed for DebugLine emission. Do not override
- // beginFunction() until that work is in place.
- void beginFunctionImpl(const MachineFunction *MF) override {}
- // TODO: Add per-function cleanup when DebugFunctionDefinition emission is in
- // place.
- void endFunctionImpl(const MachineFunction *MF) override {}
+ // point and MMI remains null for this handler's entire lifetime. Do not call
+ // the base-class beginInstruction/endInstruction — they dereference MMI to
+ // create temp symbols for label tracking and would crash.
+ // Future local NSDI that needs MCContext must use
+ // Asm->OutStreamer->getContext() rather than MMI->getContext().
+ void beginInstruction(const MachineInstr *MI) override;
+ void endInstruction() override;
+
+ // Override beginFunctionImpl(), not beginFunction():
+ // DebugHandlerBase::beginFunction() populates LScopes and DbgValues needed
+ // for future DebugLine emission.
+ void beginFunctionImpl(const MachineFunction *MF) override;
+ void endFunctionImpl(const MachineFunction *MF) override;
private:
+ void emitDebugFunctionDefinition(MCRegister DebugFunctionReg,
+ MCRegister OpFunctionReg,
+ SPIRV::ModuleAnalysisInfo &MAI);
+
+ void resetPerFunctionDebugState();
+ void preparePerFunctionDebug(const MachineFunction *MF);
+ void tryEmitDebugFunctionDefinition(SPIRV::ModuleAnalysisInfo &MAI);
+
void emitMCInst(MCInst &Inst);
MCRegister emitOpString(StringRef S, SPIRV::ModuleAnalysisInfo &MAI);
diff --git a/llvm/test/CodeGen/SPIRV/debug-info/debug-function-definition-after-opvariable.ll b/llvm/test/CodeGen/SPIRV/debug-info/debug-function-definition-after-opvariable.ll
new file mode 100644
index 0000000000000..ec3c93c5115b6
--- /dev/null
+++ b/llvm/test/CodeGen/SPIRV/debug-info/debug-function-definition-after-opvariable.ll
@@ -0,0 +1,36 @@
+; RUN: llc --verify-machineinstrs -O0 -mtriple=spirv64-unknown-unknown --spirv-ext=+SPV_KHR_non_semantic_info %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 %}
+
+; DebugFunctionDefinition must follow function-local OpVariable instructions.
+
+; CHECK-DAG: [[EXT:%[0-9]+]] = OpExtInstImport "NonSemantic.Shader.DebugInfo.100"
+; CHECK-DAG: [[VOID:%[0-9]+]] = OpTypeVoid
+; CHECK-DAG: [[DF:%[0-9]+]] = OpExtInst [[VOID]] [[EXT]] DebugFunction {{.*}}
+; CHECK: [[FOO:%[0-9]+]] = OpFunction
+; CHECK: OpVariable {{.*}} Function
+; CHECK-NEXT: OpVariable {{.*}} Function
+; CHECK-NEXT: OpExtInst [[VOID]] [[EXT]] DebugFunctionDefinition [[DF]] [[FOO]]
+
+target triple = "spirv64-unknown-unknown"
+
+define spir_func void @foo() !dbg !4 {
+entry:
+ %x = alloca i32, align 4
+ %y = alloca i32, align 4
+ store i32 0, ptr %x
+ store i32 1, ptr %y
+ ret void, !dbg !7
+}
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!2, !3}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "debug-function-definition-after-opvariable.c", directory: "/src")
+!2 = !{i32 7, !"Dwarf Version", i32 5}
+!3 = !{i32 2, !"Debug Info Version", i32 3}
+
+!4 = distinct !DISubprogram(name: "foo", scope: !1, file: !1, line: 1, type: !5, scopeLine: 1, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0)
+!5 = !DISubroutineType(types: !6)
+!6 = !{null}
+!7 = !DILocation(line: 2, column: 1, scope: !4)
diff --git a/llvm/test/CodeGen/SPIRV/debug-info/debug-function-definition.ll b/llvm/test/CodeGen/SPIRV/debug-info/debug-function-definition.ll
new file mode 100644
index 0000000000000..57c246edff8f3
--- /dev/null
+++ b/llvm/test/CodeGen/SPIRV/debug-info/debug-function-definition.ll
@@ -0,0 +1,55 @@
+; RUN: llc --verify-machineinstrs -O0 -mtriple=spirv64-unknown-unknown --spirv-ext=+SPV_KHR_non_semantic_info %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 %}
+
+; Exercise NonSemantic DebugFunctionDefinition for defined functions, including
+; per-function emitter state across multiple definitions in one module.
+
+; CHECK-DAG: [[EXT:%[0-9]+]] = OpExtInstImport "NonSemantic.Shader.DebugInfo.100"
+; CHECK-DAG: [[VOID:%[0-9]+]] = OpTypeVoid
+; CHECK-DAG: [[I32:%[0-9]+]] = OpTypeInt 32 0
+; CHECK-DAG: [[PATH:%[0-9]+]] = OpString "{{[/\\]}}src{{[/\\]}}debug-function-definition.c"
+; CHECK-DAG: [[NAME1:%[0-9]+]] = OpString "add_one"
+; ...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/211853
More information about the llvm-branch-commits
mailing list