[llvm-branch-commits] [llvm] [SPIRV] Emit each debug scope from getOrCreateDebugScope. (PR #229488)
via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Wed Oct 7 03:53:42 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 PR updates the DIScope handlers. Now, they don't directly emit the associated instruction but instead return a previous state that is the final SPV opcode plus its operands.
This simplifies the implementation for back edges when processing DIScope. This is to make sure that the actual emission of these DIScopes happens in `getOrCreateDebugScope` and avoid bugs in future handlers.
`getOrCreateDebugScope` will make sure that forward references and their definitions use the right register ID, even when the later defined scope might not be supported.
---
Patch is 48.07 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/229488.diff
2 Files Affected:
- (modified) llvm/lib/Target/SPIRV/SPIRVNonSemanticDebugHandler.cpp (+171-177)
- (modified) llvm/lib/Target/SPIRV/SPIRVNonSemanticDebugHandler.h (+127-97)
``````````diff
diff --git a/llvm/lib/Target/SPIRV/SPIRVNonSemanticDebugHandler.cpp b/llvm/lib/Target/SPIRV/SPIRVNonSemanticDebugHandler.cpp
index 902b16d805abb..b741113c6540c 100644
--- a/llvm/lib/Target/SPIRV/SPIRVNonSemanticDebugHandler.cpp
+++ b/llvm/lib/Target/SPIRV/SPIRVNonSemanticDebugHandler.cpp
@@ -542,6 +542,7 @@ MCRegister SPIRVNonSemanticDebugHandler::emitExtInst(
MCRegister VoidTypeReg, MCRegister ExtInstSetReg,
ArrayRef<MCRegister> Operands, SPIRV::ModuleAnalysisInfo &MAI) {
MCRegister Reg = MAI.getNextIDRegister();
+
MCInst Inst;
Inst.setOpcode(SPIRV::OpExtInst);
Inst.addOperand(MCOperand::createReg(Reg));
@@ -761,34 +762,44 @@ MCRegister SPIRVNonSemanticDebugHandler::findOrEmitOpTypeInt32(
// Each node emits its dependencies first. E.g. for `void f() { struct L; }`,
// node L emits f, then L. For `struct S { S *p; }`, S* is a back edge, so S
// is emitted without member p.
-SPIRVNonSemanticDebugHandler::EmitResult
-SPIRVNonSemanticDebugHandler::getOrCreateDebugScope(const DIScope *S) {
+auto SPIRVNonSemanticDebugHandler::getOrCreateDebugScope(const DIScope *S)
+ -> EmitResult<MCRegister> {
if (!S || FailedScopes.contains(S))
- return EmitResult::unsupported();
+ return EmitResult<MCRegister>::unsupported();
if (auto Reg = lookupOptReg(DebugScopeRegs, S))
- return EmitResult::emitted(*Reg);
+ return EmitResult<MCRegister>::emitted(*Reg);
// Mark the node as in progress while its dependencies are resolved/emitted.
// This also prevents cycles from happening.
if (!ScopesInProgress.insert(S).second)
- return EmitResult::inProgress();
- EmitResult R = emitDebugScope(S);
+ return EmitResult<MCRegister>::inProgress();
+
+ EmitResult<PreparedScope> P = emitDebugScope(S);
ScopesInProgress.erase(S);
- assert((!R || !GlobalNSDIEnabled) &&
+ assert((!P || !GlobalNSDIEnabled) &&
"debug type or scope created after module-scope NSDI emission");
- if (R)
- DebugScopeRegs[S] = R.Reg;
- else if (R.Status == EmitStatus::Unsupported)
- FailedScopes.insert(S);
- return R;
+ if (!P) {
+ if (P.Status == EmitStatus::Unsupported)
+ FailedScopes.insert(S);
+ return P.Status == EmitStatus::InProgress
+ ? EmitResult<MCRegister>::inProgress()
+ : EmitResult<MCRegister>::unsupported();
+ }
+
+ // The scope was successfully emitted.
+ SPIRV::ModuleAnalysisInfo &MAI = *CurrentMAI;
+ MCRegister Reg =
+ emitExtInst(P.Value->Opcode, getOrEmitOpTypeVoidReg(MAI),
+ MAI.getExtInstSetReg(NSSet), P.Value->Operands, MAI);
+ DebugScopeRegs[S] = Reg;
+ return EmitResult<MCRegister>::emitted(Reg);
}
-SPIRVNonSemanticDebugHandler::EmitResult
-SPIRVNonSemanticDebugHandler::emitDebugTypeBasic(
- const DIBasicType *BT, MCRegister VoidTypeReg, MCRegister I32TypeReg,
- MCRegister ExtInstSetReg, SPIRV::ModuleAnalysisInfo &MAI) {
+auto SPIRVNonSemanticDebugHandler::emitDebugTypeBasic(
+ const DIBasicType *BT, MCRegister I32TypeReg,
+ SPIRV::ModuleAnalysisInfo &MAI) -> EmitResult<PreparedScope> {
if (!isUInt<32>(BT->getSizeInBits()))
- return EmitResult::unsupported();
+ return EmitResult<PreparedScope>::unsupported();
MCRegister NameReg = getCachedOpStringReg(BT->getName());
MCRegister SizeReg = emitOpConstantI32(
@@ -822,13 +833,13 @@ SPIRVNonSemanticDebugHandler::emitDebugTypeBasic(
}
MCRegister EncodingReg = emitOpConstantI32(Encoding, I32TypeReg, MAI);
MCRegister FlagsReg = emitOpConstantI32(0, I32TypeReg, MAI);
- return EmitResult::emitted(emitExtInst(
- SPIRV::NonSemanticExtInst::DebugTypeBasic, VoidTypeReg, ExtInstSetReg,
- {NameReg, SizeReg, EncodingReg, FlagsReg}, MAI));
+ return EmitResult<PreparedScope>::emitted(
+ PreparedScope{SPIRV::NonSemanticExtInst::DebugTypeBasic,
+ {NameReg, SizeReg, EncodingReg, FlagsReg}});
}
-SPIRVNonSemanticDebugHandler::EmitResult
-SPIRVNonSemanticDebugHandler::emitDebugScope(const DIScope *S) {
+auto SPIRVNonSemanticDebugHandler::emitDebugScope(const DIScope *S)
+ -> EmitResult<PreparedScope> {
assert(CurrentMAI && "emitDebugScope requires CurrentMAI");
SPIRV::ModuleAnalysisInfo &MAI = *CurrentMAI;
MCRegister ExtInstSetReg = MAI.getExtInstSetReg(NSSet);
@@ -836,9 +847,9 @@ SPIRVNonSemanticDebugHandler::emitDebugScope(const DIScope *S) {
MCRegister I32TypeReg = getOrEmitOpTypeInt32Reg(MAI);
if (const auto *BT = dyn_cast<DIBasicType>(S))
- return emitDebugTypeBasic(BT, VoidTypeReg, I32TypeReg, ExtInstSetReg, MAI);
+ return emitDebugTypeBasic(BT, I32TypeReg, MAI);
if (const auto *ST = dyn_cast<DISubroutineType>(S))
- return emitDebugTypeFunctionForSubroutineType(ST, ExtInstSetReg, MAI);
+ return emitDebugTypeFunctionForSubroutineType(ST, MAI);
if (const auto *CT = dyn_cast<DICompositeType>(S))
return emitDebugTypeForCompositeType(CT, VoidTypeReg, I32TypeReg,
ExtInstSetReg, MAI);
@@ -854,13 +865,13 @@ SPIRVNonSemanticDebugHandler::emitDebugScope(const DIScope *S) {
return emitDebugFunctionDeclaration(SP, VoidTypeReg, I32TypeReg,
ExtInstSetReg, MAI);
}
- return EmitResult::unsupported();
+ return EmitResult<PreparedScope>::unsupported();
}
-SPIRVNonSemanticDebugHandler::EmitResult
-SPIRVNonSemanticDebugHandler::emitDebugTypeForCompositeType(
+auto SPIRVNonSemanticDebugHandler::emitDebugTypeForCompositeType(
const DICompositeType *CT, MCRegister VoidTypeReg, MCRegister I32TypeReg,
- MCRegister ExtInstSetReg, SPIRV::ModuleAnalysisInfo &MAI) {
+ MCRegister ExtInstSetReg, SPIRV::ModuleAnalysisInfo &MAI)
+ -> EmitResult<PreparedScope> {
switch (CT->getTag()) {
case dwarf::DW_TAG_array_type:
// A vector is an array with DINode::FlagVector. A plain array is the
@@ -875,49 +886,48 @@ SPIRVNonSemanticDebugHandler::emitDebugTypeForCompositeType(
// not disambiguate a matrix from a genuine array of vectors. Once the
// frontend marks matrices, route them to a DebugTypeMatrix path here.
if (CT->isVector())
- return emitDebugTypeVector(CT, ExtInstSetReg, MAI);
- return emitDebugTypeArray(CT, ExtInstSetReg, MAI);
+ return emitDebugTypeVector(CT, MAI);
+ return emitDebugTypeArray(CT, MAI);
case dwarf::DW_TAG_structure_type:
case dwarf::DW_TAG_class_type:
case dwarf::DW_TAG_union_type:
return emitDebugTypeComposite(CT, VoidTypeReg, I32TypeReg, ExtInstSetReg,
MAI);
default:
- return EmitResult::unsupported();
+ return EmitResult<PreparedScope>::unsupported();
}
}
-SPIRVNonSemanticDebugHandler::EmitResult
-SPIRVNonSemanticDebugHandler::emitDebugTypeForDerivedType(
+auto SPIRVNonSemanticDebugHandler::emitDebugTypeForDerivedType(
const DIDerivedType *DT, MCRegister VoidTypeReg, MCRegister I32TypeReg,
- MCRegister ExtInstSetReg, SPIRV::ModuleAnalysisInfo &MAI) {
+ MCRegister ExtInstSetReg, SPIRV::ModuleAnalysisInfo &MAI)
+ -> EmitResult<PreparedScope> {
switch (DT->getTag()) {
case dwarf::DW_TAG_pointer_type:
- return emitDebugTypePointer(DT, ExtInstSetReg, MAI);
+ return emitDebugTypePointer(DT, MAI);
case dwarf::DW_TAG_typedef:
return emitDebugTypedef(DT, VoidTypeReg, I32TypeReg, ExtInstSetReg, MAI);
case dwarf::DW_TAG_member:
return emitDebugTypeMember(DT, VoidTypeReg, I32TypeReg, ExtInstSetReg, MAI);
default:
- return EmitResult::unsupported();
+ return EmitResult<PreparedScope>::unsupported();
}
}
-SPIRVNonSemanticDebugHandler::EmitResult
-SPIRVNonSemanticDebugHandler::emitDebugTypePointer(
- const DIDerivedType *PT, MCRegister ExtInstSetReg,
- SPIRV::ModuleAnalysisInfo &MAI) {
+auto SPIRVNonSemanticDebugHandler::emitDebugTypePointer(
+ const DIDerivedType *PT, SPIRV::ModuleAnalysisInfo &MAI)
+ -> EmitResult<PreparedScope> {
// A DWARF address space is required to determine the SPIR-V storage class.
// Skip pointer types that do not carry one.
if (!PT->getDWARFAddressSpace().has_value())
- return EmitResult::unsupported();
+ return EmitResult<PreparedScope>::unsupported();
MCRegister BaseReg;
if (const DIType *BaseTy = PT->getBaseType()) {
- EmitResult Base = getOrCreateDebugScope(BaseTy);
+ EmitResult<MCRegister> Base = getOrCreateDebugScope(BaseTy);
if (!Base)
- return Base;
- BaseReg = Base.Reg;
+ return EmitResult<PreparedScope>::failure(Base);
+ BaseReg = *Base.Value;
} else {
// No getBaseType() (typical for void*): use DebugInfoNone as Base Type,
// same as SPIRV-LLVM-Translator (see issue #109287 and the DISABLED
@@ -926,7 +936,6 @@ SPIRVNonSemanticDebugHandler::emitDebugTypePointer(
BaseReg = CachedDebugInfoNoneReg;
}
- MCRegister VoidTypeReg = getOrEmitOpTypeVoidReg(MAI);
MCRegister I32TypeReg = getOrEmitOpTypeInt32Reg(MAI);
MCRegister DebugTypePointerFlagsReg =
emitOpConstantI32(transDebugFlags(PT), I32TypeReg, MAI);
@@ -938,15 +947,14 @@ SPIRVNonSemanticDebugHandler::emitDebugTypePointer(
addressSpaceToStorageClass(PT->getDWARFAddressSpace().value(), ST),
I32TypeReg, MAI);
- return EmitResult::emitted(emitExtInst(
- SPIRV::NonSemanticExtInst::DebugTypePointer, VoidTypeReg, ExtInstSetReg,
- {BaseReg, StorageClassReg, DebugTypePointerFlagsReg}, MAI));
+ return EmitResult<PreparedScope>::emitted(
+ PreparedScope{SPIRV::NonSemanticExtInst::DebugTypePointer,
+ {BaseReg, StorageClassReg, DebugTypePointerFlagsReg}});
}
-SPIRVNonSemanticDebugHandler::EmitResult
-SPIRVNonSemanticDebugHandler::emitDebugTypeFunctionForSubroutineType(
- const DISubroutineType *ST, MCRegister ExtInstSetReg,
- SPIRV::ModuleAnalysisInfo &MAI) {
+auto SPIRVNonSemanticDebugHandler::emitDebugTypeFunctionForSubroutineType(
+ const DISubroutineType *ST, SPIRV::ModuleAnalysisInfo &MAI)
+ -> EmitResult<PreparedScope> {
MCRegister VoidTypeReg = getOrEmitOpTypeVoidReg(MAI);
MCRegister I32TypeReg = getOrEmitOpTypeInt32Reg(MAI);
MCRegister DebugTypeFunctionFlagsReg =
@@ -962,49 +970,49 @@ SPIRVNonSemanticDebugHandler::emitDebugTypeFunctionForSubroutineType(
} else {
for (unsigned I = 0, E = TA.size(); I != E; ++I) {
bool IsReturnType = (I == 0);
- EmitResult Slot =
+ EmitResult<MCRegister> Slot =
mapDISignatureTypeToReg(TA[I], VoidTypeReg, IsReturnType);
// No emitted DebugType* id for this slot (e.g., pointer that
// was skipped due missing address space, etc.).
if (!Slot)
- return Slot;
- Ops.push_back(Slot.Reg);
+ return EmitResult<PreparedScope>::failure(Slot);
+ Ops.push_back(*Slot.Value);
}
}
- return EmitResult::emitted(
- emitExtInst(SPIRV::NonSemanticExtInst::DebugTypeFunction, VoidTypeReg,
- ExtInstSetReg, Ops, MAI));
+ return EmitResult<PreparedScope>::emitted(
+ PreparedScope{SPIRV::NonSemanticExtInst::DebugTypeFunction, Ops});
}
// Match SPIRV-LLVM-Translator's selection logic for the Parent operand.
-SPIRVNonSemanticDebugHandler::EmitResult
-SPIRVNonSemanticDebugHandler::resolveScope(const DIScope *Scope,
- const DICompileUnit *FallbackCU) {
+auto SPIRVNonSemanticDebugHandler::resolveScope(const DIScope *Scope,
+ const DICompileUnit *FallbackCU)
+ -> EmitResult<MCRegister> {
if (isa_and_nonnull<DIType, DILexicalBlock, DINamespace, DISubprogram>(Scope))
return getOrCreateDebugScope(Scope);
// For a file, compile-unit, or absent scope, fall back to a compile unit.
auto CUResult = [](std::optional<MCRegister> Reg) {
- return Reg ? EmitResult::emitted(*Reg) : EmitResult::unsupported();
+ return Reg ? EmitResult<MCRegister>::emitted(*Reg)
+ : EmitResult<MCRegister>::unsupported();
};
if (FallbackCU)
return CUResult(lookupOptReg(DebugScopeRegs, FallbackCU));
if (CompileUnits.empty())
- return EmitResult::unsupported();
+ return EmitResult<MCRegister>::unsupported();
return CUResult(lookupOptReg(DebugScopeRegs, CompileUnits[0].TheCU));
}
-SPIRVNonSemanticDebugHandler::EmitResult
-SPIRVNonSemanticDebugHandler::emitDebugLexicalBlock(
+auto SPIRVNonSemanticDebugHandler::emitDebugLexicalBlock(
const DIScope *S, MCRegister VoidTypeReg, MCRegister I32TypeReg,
- MCRegister ExtInstSetReg, SPIRV::ModuleAnalysisInfo &MAI) {
+ MCRegister ExtInstSetReg, SPIRV::ModuleAnalysisInfo &MAI)
+ -> EmitResult<PreparedScope> {
assert((isa<DILexicalBlock, DINamespace>(S)) &&
"S must be a DILexicalBlock or DINamespace in emitDebugLexicalBlock");
- EmitResult Parent = resolveScope(S->getScope());
+ EmitResult<MCRegister> Parent = resolveScope(S->getScope());
if (!Parent)
- return Parent;
+ return EmitResult<PreparedScope>::failure(Parent);
MCRegister FileStrReg = getCachedScopePathOpStringReg(
S->getFile(), /*UseEmptyPathIfNullScope=*/true);
@@ -1017,19 +1025,18 @@ SPIRVNonSemanticDebugHandler::emitDebugLexicalBlock(
I32TypeReg, MAI);
MCRegister ColReg = emitOpConstantI32(
static_cast<uint32_t>(LB->getColumn()), I32TypeReg, MAI);
- Ops = {SrcReg, LineReg, ColReg, Parent.Reg};
+ Ops = {SrcReg, LineReg, ColReg, *Parent.Value};
} else {
const auto *NS = cast<DINamespace>(S);
// DINamespace carries no line/column info.
MCRegister LineReg = emitOpConstantI32(0, I32TypeReg, MAI);
MCRegister ColReg = emitOpConstantI32(0, I32TypeReg, MAI);
MCRegister NameReg = getCachedOpStringReg(NS->getName());
- Ops = {SrcReg, LineReg, ColReg, Parent.Reg, NameReg};
+ Ops = {SrcReg, LineReg, ColReg, *Parent.Value, NameReg};
}
- return EmitResult::emitted(
- emitExtInst(SPIRV::NonSemanticExtInst::DebugLexicalBlock, VoidTypeReg,
- ExtInstSetReg, Ops, MAI));
+ return EmitResult<PreparedScope>::emitted(
+ PreparedScope{SPIRV::NonSemanticExtInst::DebugLexicalBlock, Ops});
}
MCRegister SPIRVNonSemanticDebugHandler::getOrEmitDebugInlinedAt(
@@ -1040,14 +1047,14 @@ MCRegister SPIRVNonSemanticDebugHandler::getOrEmitDebugInlinedAt(
if (MCRegister Cached = DebugInlinedAtRegs.lookup(IA))
return Cached;
- EmitResult Scope = resolveScope(IA->getScope());
+ EmitResult<MCRegister> Scope = resolveScope(IA->getScope());
if (!Scope)
return MCRegister();
MCRegister LineReg =
emitOpConstantI32(static_cast<uint32_t>(IA->getLine()), I32TypeReg, MAI);
- SmallVector<MCRegister, 3> Ops{LineReg, Scope.Reg};
+ SmallVector<MCRegister, 3> Ops{LineReg, *Scope.Value};
// Recurse before building this instruction's operands so an outer
// inlined-at link is always available.
if (const DILocation *Outer = IA->getInlinedAt()) {
@@ -1064,22 +1071,22 @@ MCRegister SPIRVNonSemanticDebugHandler::getOrEmitDebugInlinedAt(
return Reg;
}
-SPIRVNonSemanticDebugHandler::EmitResult
-SPIRVNonSemanticDebugHandler::emitDebugFunctionDeclaration(
+auto SPIRVNonSemanticDebugHandler::emitDebugFunctionDeclaration(
const DISubprogram *SP, MCRegister VoidTypeReg, MCRegister I32TypeReg,
- MCRegister ExtInstSetReg, SPIRV::ModuleAnalysisInfo &MAI) {
+ MCRegister ExtInstSetReg, SPIRV::ModuleAnalysisInfo &MAI)
+ -> EmitResult<PreparedScope> {
assert(SP && "SP must not be null in emitDebugFunctionDeclaration");
assert(!SP->isDefinition() &&
"SP must not be a definition in emitDebugFunctionDeclaration");
// The IR verifier already enforces that this cannot be null.
- EmitResult FnTy = getOrCreateDebugScope(SP->getType());
+ EmitResult<MCRegister> FnTy = getOrCreateDebugScope(SP->getType());
if (!FnTy)
- return FnTy;
+ return EmitResult<PreparedScope>::failure(FnTy);
- EmitResult Parent = resolveScope(SP->getScope(), SP->getUnit());
+ EmitResult<MCRegister> Parent = resolveScope(SP->getScope(), SP->getUnit());
if (!Parent)
- return Parent;
+ return EmitResult<PreparedScope>::failure(Parent);
MCRegister FileStrReg = getCachedScopePathOpStringReg(SP);
@@ -1098,28 +1105,26 @@ SPIRVNonSemanticDebugHandler::emitDebugFunctionDeclaration(
FlagsVal &= ~NSDIFlagIsDefinition;
MCRegister FlagsReg = emitOpConstantI32(FlagsVal, I32TypeReg, MAI);
- return EmitResult::emitted(
- emitExtInst(SPIRV::NonSemanticExtInst::DebugFunctionDeclaration,
- VoidTypeReg, ExtInstSetReg,
- {NameReg, FnTy.Reg, SrcReg, LineReg, ColReg, Parent.Reg,
- LinkageReg, FlagsReg},
- MAI));
+ return EmitResult<PreparedScope>::emitted(
+ PreparedScope{SPIRV::NonSemanticExtInst::DebugFunctionDeclaration,
+ {NameReg, *FnTy.Value, SrcReg, LineReg, ColReg,
+ *Parent.Value, LinkageReg, FlagsReg}});
}
-SPIRVNonSemanticDebugHandler::EmitResult
-SPIRVNonSemanticDebugHandler::emitDebugFunction(
+auto SPIRVNonSemanticDebugHandler::emitDebugFunction(
const DISubprogram *SP, MCRegister VoidTypeReg, MCRegister I32TypeReg,
- MCRegister ExtInstSetReg, SPIRV::ModuleAnalysisInfo &MAI) {
+ MCRegister ExtInstSetReg, SPIRV::ModuleAnalysisInfo &MAI)
+ -> EmitResult<PreparedScope> {
assert(SP && "SP must not be null in emitDebugFunction");
assert(SP->isDefinition() && "SP must be a definition in emitDebugFunction");
- EmitResult FnTy = getOrCreateDebugScope(SP->getType());
+ EmitResult<MCRegister> FnTy = getOrCreateDebugScope(SP->getType());
if (!FnTy)
- return FnTy;
+ return EmitResult<PreparedScope>::failure(FnTy);
- EmitResult Parent = resolveScope(SP->getScope(), SP->getUnit());
+ EmitResult<MCRegister> Parent = resolveScope(SP->getScope(), SP->getUnit());
if (!Parent)
- return Parent;
+ return EmitResult<PreparedScope>::failure(Parent);
MCRegister NameReg = getCachedOpStringReg(SP->getName());
MCRegister LinkageReg = getCachedOpStringReg(SP->getLinkageName());
@@ -1136,9 +1141,9 @@ SPIRVNonSemanticDebugHandler::emitDebugFunction(
MCRegister ScopeLineReg = emitOpConstantI32(
static_cast<uint32_t>(SP->getScopeLine()), I32TypeReg, MAI);
- SmallVector<MCRegister, 10> Ops = {NameReg, FnTy.Reg, SrcReg,
- LineReg, ColReg, Parent.Reg,
- LinkageReg, FlagsReg, ScopeLineReg};
+ SmallVector<MCRegister, 10> Ops = {NameReg, *FnTy.Value, SrcReg,
+ LineReg, ColReg, *Parent.Value,
+ LinkageReg, FlagsReg, ScopeLineReg};
// TODO: Create on demand once beginModule collects missing getDeclaration()
// cases.
@@ -1147,21 +1152,19 @@ SPIRVNonSemanticDebugHandler::emitDebugFunction(
Ops.push_back(*DeclRegOpt);
}
- return EmitResult::emitted(
- emitExtInst(SPIRV::NonSemanticExtInst::DebugFunction, VoidTypeReg,
- ExtInstSetReg, Ops, MAI));
+ return EmitResult<PreparedScope>::emitted(
+ PreparedScope{SPIRV::NonSemanticExtInst::DebugFunction, Ops});
}
-SPIRVNonSemanticDebugHandler::EmitResult
-SPIRVNonSemanticDebugHandler::mapDISignatureTypeToReg(const DIType *Ty,
- MCRegister VoidTypeReg,
- bool ReturnType) {
+auto SPIRVNonSemanticDebugHandler::mapDISignatureTypeToReg(
+ const DIType *Ty, MCRegister VoidTypeReg, bool ReturnType)
+ -> EmitResult<MCRegister> {
if (!Ty) {
if (ReturnType)
- return EmitResult::emitted(VoidTypeReg);
+ return EmitResult<MCRegister>::emitted(VoidTypeReg);
assert(CachedDebugInfoNoneReg.isValid() &&
"DebugInfoNone must be emitted before DISubroutineType operands");
- return EmitResult::emitted(CachedDebugInfoNoneReg);
+ return EmitResult<MCRegister>::emitted(CachedDebugInfoNoneReg);
}
return getOrCreateDebugScope(Ty);
}
@@ -1280,11 +1283,11 @@ std::optional<MCRegister> SPIRVNonSemanticDebugHandler::emitDebugGlobalVariable(
SPIRV::ModuleAnalysisInfo &MAI) {
assert(GV && "GV must not be null in emitDebugGlobalVariable");
- EmitResult Parent = resolveScope(GV->getScope());
+ EmitResult<MCRegister> Parent = resolveScope(GV->getScope());
if (!Parent)
return std::nullopt;
- MCRegister ParentReg = Parent.Reg;
+ MCRegister ParentReg = *Parent.V...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/229488
More information about the llvm-branch-commits
mailing list