800593a014
This commit resolves an issue in the LLVMIR export that caused the duplication of the "Debug Info Version" module flag, when it was already in MLIR.
611 lines
24 KiB
C++
611 lines
24 KiB
C++
//===- DebugTranslation.cpp - MLIR to LLVM Debug conversion ---------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "DebugTranslation.h"
|
|
#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
|
|
#include "llvm/ADT/TypeSwitch.h"
|
|
#include "llvm/IR/Metadata.h"
|
|
#include "llvm/IR/Module.h"
|
|
#include "llvm/Support/FileSystem.h"
|
|
#include "llvm/Support/Path.h"
|
|
|
|
using namespace mlir;
|
|
using namespace mlir::LLVM;
|
|
using namespace mlir::LLVM::detail;
|
|
|
|
/// A utility walker that interrupts if the operation has valid debug
|
|
/// information.
|
|
static WalkResult interruptIfValidLocation(Operation *op) {
|
|
return isa<UnknownLoc>(op->getLoc()) ? WalkResult::advance()
|
|
: WalkResult::interrupt();
|
|
}
|
|
|
|
DebugTranslation::DebugTranslation(Operation *module, llvm::Module &llvmModule)
|
|
: debugEmissionIsEnabled(false), llvmModule(llvmModule),
|
|
llvmCtx(llvmModule.getContext()) {
|
|
// If the module has no location information, there is nothing to do.
|
|
if (!module->walk(interruptIfValidLocation).wasInterrupted())
|
|
return;
|
|
debugEmissionIsEnabled = true;
|
|
}
|
|
|
|
static constexpr StringRef kDebugVersionKey = "Debug Info Version";
|
|
static constexpr StringRef kCodeViewKey = "CodeView";
|
|
|
|
void DebugTranslation::addModuleFlagsIfNotPresent() {
|
|
// TODO: The version information should be encoded on the LLVM module itself,
|
|
// not implicitly set here.
|
|
|
|
// Mark this module as having debug information.
|
|
if (!llvmModule.getModuleFlag(kDebugVersionKey))
|
|
llvmModule.addModuleFlag(llvm::Module::Warning, kDebugVersionKey,
|
|
llvm::DEBUG_METADATA_VERSION);
|
|
|
|
const llvm::Triple &targetTriple = llvmModule.getTargetTriple();
|
|
if (targetTriple.isKnownWindowsMSVCEnvironment()) {
|
|
// Dwarf debugging files will be generated by default, unless "CodeView"
|
|
// is set explicitly. Windows/MSVC should use CodeView instead.
|
|
if (!llvmModule.getModuleFlag(kCodeViewKey))
|
|
llvmModule.addModuleFlag(llvm::Module::Warning, kCodeViewKey, 1);
|
|
}
|
|
}
|
|
|
|
/// Translate the debug information for the given function.
|
|
void DebugTranslation::translate(LLVMFuncOp func, llvm::Function &llvmFunc) {
|
|
if (!debugEmissionIsEnabled)
|
|
return;
|
|
|
|
// Look for a sub program attached to the function.
|
|
auto spLoc =
|
|
func.getLoc()->findInstanceOf<FusedLocWith<LLVM::DISubprogramAttr>>();
|
|
if (!spLoc)
|
|
return;
|
|
llvmFunc.setSubprogram(translate(spLoc.getMetadata()));
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Attributes
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
llvm::DIType *DebugTranslation::translateImpl(DINullTypeAttr attr) {
|
|
// A DINullTypeAttr at the beginning of the subroutine types list models
|
|
// a void result type. If it is at the end, it models a variadic function.
|
|
// Translate the explicit DINullTypeAttr to a nullptr since LLVM IR metadata
|
|
// does not have an explicit void result type nor a variadic type
|
|
// representation.
|
|
return nullptr;
|
|
}
|
|
|
|
llvm::DIExpression *
|
|
DebugTranslation::getExpressionAttrOrNull(DIExpressionAttr attr) {
|
|
if (!attr)
|
|
return nullptr;
|
|
return translateExpression(attr);
|
|
}
|
|
|
|
llvm::MDString *DebugTranslation::getMDStringOrNull(StringAttr stringAttr) {
|
|
if (!stringAttr || stringAttr.empty())
|
|
return nullptr;
|
|
return llvm::MDString::get(llvmCtx, stringAttr);
|
|
}
|
|
|
|
llvm::MDTuple *
|
|
DebugTranslation::getMDTupleOrNull(ArrayRef<DINodeAttr> elements) {
|
|
if (elements.empty())
|
|
return nullptr;
|
|
SmallVector<llvm::Metadata *> llvmElements = llvm::to_vector(
|
|
llvm::map_range(elements, [&](DINodeAttr attr) -> llvm::Metadata * {
|
|
if (DIAnnotationAttr annAttr = dyn_cast<DIAnnotationAttr>(attr)) {
|
|
llvm::Metadata *ops[2] = {
|
|
llvm::MDString::get(llvmCtx, annAttr.getName()),
|
|
llvm::MDString::get(llvmCtx, annAttr.getValue())};
|
|
return llvm::MDNode::get(llvmCtx, ops);
|
|
}
|
|
return translate(attr);
|
|
}));
|
|
return llvm::MDNode::get(llvmCtx, llvmElements);
|
|
}
|
|
|
|
llvm::DIBasicType *DebugTranslation::translateImpl(DIBasicTypeAttr attr) {
|
|
return llvm::DIBasicType::get(
|
|
llvmCtx, attr.getTag(), getMDStringOrNull(attr.getName()),
|
|
attr.getSizeInBits(),
|
|
/*AlignInBits=*/0, attr.getEncoding(), llvm::DINode::FlagZero);
|
|
}
|
|
|
|
llvm::DICompileUnit *DebugTranslation::translateImpl(DICompileUnitAttr attr) {
|
|
llvm::DIBuilder builder(llvmModule);
|
|
return builder.createCompileUnit(
|
|
attr.getSourceLanguage(), translate(attr.getFile()),
|
|
attr.getProducer() ? attr.getProducer().getValue() : "",
|
|
attr.getIsOptimized(),
|
|
/*Flags=*/"", /*RV=*/0, /*SplitName=*/{},
|
|
static_cast<llvm::DICompileUnit::DebugEmissionKind>(
|
|
attr.getEmissionKind()),
|
|
0, true, false,
|
|
static_cast<llvm::DICompileUnit::DebugNameTableKind>(
|
|
attr.getNameTableKind()));
|
|
}
|
|
|
|
/// Returns a new `DINodeT` that is either distinct or not, depending on
|
|
/// `isDistinct`.
|
|
template <class DINodeT, class... Ts>
|
|
static DINodeT *getDistinctOrUnique(bool isDistinct, Ts &&...args) {
|
|
if (isDistinct)
|
|
return DINodeT::getDistinct(std::forward<Ts>(args)...);
|
|
return DINodeT::get(std::forward<Ts>(args)...);
|
|
}
|
|
|
|
llvm::TempDICompositeType
|
|
DebugTranslation::translateTemporaryImpl(DICompositeTypeAttr attr) {
|
|
return llvm::DICompositeType::getTemporary(
|
|
llvmCtx, attr.getTag(), getMDStringOrNull(attr.getName()), nullptr,
|
|
attr.getLine(), nullptr, nullptr, attr.getSizeInBits(),
|
|
attr.getAlignInBits(),
|
|
/*OffsetInBits=*/0,
|
|
/*Flags=*/static_cast<llvm::DINode::DIFlags>(attr.getFlags()),
|
|
/*Elements=*/nullptr, /*RuntimeLang=*/0, /*EnumKind=*/std::nullopt,
|
|
/*VTableHolder=*/nullptr);
|
|
}
|
|
|
|
llvm::TempDISubprogram
|
|
DebugTranslation::translateTemporaryImpl(DISubprogramAttr attr) {
|
|
return llvm::DISubprogram::getTemporary(
|
|
llvmCtx, /*Scope=*/nullptr, /*Name=*/{}, /*LinkageName=*/{},
|
|
/*File=*/nullptr, attr.getLine(), /*Type=*/nullptr,
|
|
/*ScopeLine=*/0, /*ContainingType=*/nullptr, /*VirtualIndex=*/0,
|
|
/*ThisAdjustment=*/0, llvm::DINode::FlagZero,
|
|
static_cast<llvm::DISubprogram::DISPFlags>(attr.getSubprogramFlags()),
|
|
/*Unit=*/nullptr);
|
|
}
|
|
|
|
llvm::DICompositeType *
|
|
DebugTranslation::translateImpl(DICompositeTypeAttr attr) {
|
|
// TODO: Use distinct attributes to model this, once they have landed.
|
|
// Depending on the tag, composite types must be distinct.
|
|
bool isDistinct = false;
|
|
switch (attr.getTag()) {
|
|
case llvm::dwarf::DW_TAG_class_type:
|
|
case llvm::dwarf::DW_TAG_enumeration_type:
|
|
case llvm::dwarf::DW_TAG_structure_type:
|
|
case llvm::dwarf::DW_TAG_union_type:
|
|
isDistinct = true;
|
|
}
|
|
|
|
return getDistinctOrUnique<llvm::DICompositeType>(
|
|
isDistinct, llvmCtx, attr.getTag(), getMDStringOrNull(attr.getName()),
|
|
translate(attr.getFile()), attr.getLine(), translate(attr.getScope()),
|
|
translate(attr.getBaseType()), attr.getSizeInBits(),
|
|
attr.getAlignInBits(),
|
|
/*OffsetInBits=*/0,
|
|
/*Flags=*/static_cast<llvm::DINode::DIFlags>(attr.getFlags()),
|
|
getMDTupleOrNull(attr.getElements()),
|
|
/*RuntimeLang=*/0, /*EnumKind*/ std::nullopt, /*VTableHolder=*/nullptr,
|
|
/*TemplateParams=*/nullptr, /*Identifier=*/nullptr,
|
|
/*Discriminator=*/nullptr,
|
|
getExpressionAttrOrNull(attr.getDataLocation()),
|
|
getExpressionAttrOrNull(attr.getAssociated()),
|
|
getExpressionAttrOrNull(attr.getAllocated()),
|
|
getExpressionAttrOrNull(attr.getRank()));
|
|
}
|
|
|
|
llvm::DIDerivedType *DebugTranslation::translateImpl(DIDerivedTypeAttr attr) {
|
|
return llvm::DIDerivedType::get(
|
|
llvmCtx, attr.getTag(), getMDStringOrNull(attr.getName()),
|
|
/*File=*/nullptr, /*Line=*/0,
|
|
/*Scope=*/nullptr, translate(attr.getBaseType()), attr.getSizeInBits(),
|
|
attr.getAlignInBits(), attr.getOffsetInBits(),
|
|
attr.getDwarfAddressSpace(), /*PtrAuthData=*/std::nullopt,
|
|
/*Flags=*/llvm::DINode::FlagZero, translate(attr.getExtraData()));
|
|
}
|
|
|
|
llvm::DIStringType *DebugTranslation::translateImpl(DIStringTypeAttr attr) {
|
|
return llvm::DIStringType::get(
|
|
llvmCtx, attr.getTag(), getMDStringOrNull(attr.getName()),
|
|
translate(attr.getStringLength()),
|
|
getExpressionAttrOrNull(attr.getStringLengthExp()),
|
|
getExpressionAttrOrNull(attr.getStringLocationExp()),
|
|
attr.getSizeInBits(), attr.getAlignInBits(), attr.getEncoding());
|
|
}
|
|
|
|
llvm::DIFile *DebugTranslation::translateImpl(DIFileAttr attr) {
|
|
return llvm::DIFile::get(llvmCtx, getMDStringOrNull(attr.getName()),
|
|
getMDStringOrNull(attr.getDirectory()));
|
|
}
|
|
|
|
llvm::DILabel *DebugTranslation::translateImpl(DILabelAttr attr) {
|
|
return llvm::DILabel::get(llvmCtx, translate(attr.getScope()),
|
|
getMDStringOrNull(attr.getName()),
|
|
translate(attr.getFile()), attr.getLine());
|
|
}
|
|
|
|
llvm::DILexicalBlock *DebugTranslation::translateImpl(DILexicalBlockAttr attr) {
|
|
return llvm::DILexicalBlock::getDistinct(llvmCtx, translate(attr.getScope()),
|
|
translate(attr.getFile()),
|
|
attr.getLine(), attr.getColumn());
|
|
}
|
|
|
|
llvm::DILexicalBlockFile *
|
|
DebugTranslation::translateImpl(DILexicalBlockFileAttr attr) {
|
|
return llvm::DILexicalBlockFile::getDistinct(
|
|
llvmCtx, translate(attr.getScope()), translate(attr.getFile()),
|
|
attr.getDiscriminator());
|
|
}
|
|
|
|
llvm::DILocalScope *DebugTranslation::translateImpl(DILocalScopeAttr attr) {
|
|
return cast<llvm::DILocalScope>(translate(DINodeAttr(attr)));
|
|
}
|
|
|
|
llvm::DIVariable *DebugTranslation::translateImpl(DIVariableAttr attr) {
|
|
return cast<llvm::DIVariable>(translate(DINodeAttr(attr)));
|
|
}
|
|
|
|
llvm::DILocalVariable *
|
|
DebugTranslation::translateImpl(DILocalVariableAttr attr) {
|
|
return llvm::DILocalVariable::get(
|
|
llvmCtx, translate(attr.getScope()), getMDStringOrNull(attr.getName()),
|
|
translate(attr.getFile()), attr.getLine(), translate(attr.getType()),
|
|
attr.getArg(), static_cast<llvm::DINode::DIFlags>(attr.getFlags()),
|
|
attr.getAlignInBits(),
|
|
/*Annotations=*/nullptr);
|
|
}
|
|
|
|
llvm::DIGlobalVariable *
|
|
DebugTranslation::translateImpl(DIGlobalVariableAttr attr) {
|
|
return llvm::DIGlobalVariable::getDistinct(
|
|
llvmCtx, translate(attr.getScope()), getMDStringOrNull(attr.getName()),
|
|
getMDStringOrNull(attr.getLinkageName()), translate(attr.getFile()),
|
|
attr.getLine(), translate(attr.getType()), attr.getIsLocalToUnit(),
|
|
attr.getIsDefined(), nullptr, nullptr, attr.getAlignInBits(), nullptr);
|
|
}
|
|
|
|
llvm::DINode *
|
|
DebugTranslation::translateRecursive(DIRecursiveTypeAttrInterface attr) {
|
|
DistinctAttr recursiveId = attr.getRecId();
|
|
if (auto *iter = recursiveNodeMap.find(recursiveId);
|
|
iter != recursiveNodeMap.end()) {
|
|
return iter->second;
|
|
}
|
|
assert(!attr.getIsRecSelf() && "unbound DI recursive self reference");
|
|
|
|
auto setRecursivePlaceholder = [&](llvm::DINode *placeholder) {
|
|
recursiveNodeMap.try_emplace(recursiveId, placeholder);
|
|
};
|
|
|
|
llvm::DINode *result =
|
|
TypeSwitch<DIRecursiveTypeAttrInterface, llvm::DINode *>(attr)
|
|
.Case<DICompositeTypeAttr>([&](auto attr) {
|
|
auto temporary = translateTemporaryImpl(attr);
|
|
setRecursivePlaceholder(temporary.get());
|
|
// Must call `translateImpl` directly instead of `translate` to
|
|
// avoid handling the recursive interface again.
|
|
auto *concrete = translateImpl(attr);
|
|
temporary->replaceAllUsesWith(concrete);
|
|
return concrete;
|
|
})
|
|
.Case<DISubprogramAttr>([&](auto attr) {
|
|
auto temporary = translateTemporaryImpl(attr);
|
|
setRecursivePlaceholder(temporary.get());
|
|
// Must call `translateImpl` directly instead of `translate` to
|
|
// avoid handling the recursive interface again.
|
|
auto *concrete = translateImpl(attr);
|
|
temporary->replaceAllUsesWith(concrete);
|
|
return concrete;
|
|
});
|
|
|
|
assert(recursiveNodeMap.back().first == recursiveId &&
|
|
"internal inconsistency: unexpected recursive translation stack");
|
|
recursiveNodeMap.pop_back();
|
|
|
|
return result;
|
|
}
|
|
|
|
llvm::DIScope *DebugTranslation::translateImpl(DIScopeAttr attr) {
|
|
return cast<llvm::DIScope>(translate(DINodeAttr(attr)));
|
|
}
|
|
|
|
llvm::DISubprogram *DebugTranslation::translateImpl(DISubprogramAttr attr) {
|
|
if (auto iter = distinctAttrToNode.find(attr.getId());
|
|
iter != distinctAttrToNode.end())
|
|
return cast<llvm::DISubprogram>(iter->second);
|
|
|
|
llvm::DIScope *scope = translate(attr.getScope());
|
|
llvm::DIFile *file = translate(attr.getFile());
|
|
llvm::DIType *type = translate(attr.getType());
|
|
llvm::DICompileUnit *compileUnit = translate(attr.getCompileUnit());
|
|
|
|
// Check again after recursive calls in case this distinct node recurses back
|
|
// to itself.
|
|
if (auto iter = distinctAttrToNode.find(attr.getId());
|
|
iter != distinctAttrToNode.end())
|
|
return cast<llvm::DISubprogram>(iter->second);
|
|
|
|
bool isDefinition = static_cast<bool>(attr.getSubprogramFlags() &
|
|
LLVM::DISubprogramFlags::Definition);
|
|
|
|
llvm::DISubprogram *node = getDistinctOrUnique<llvm::DISubprogram>(
|
|
isDefinition, llvmCtx, scope, getMDStringOrNull(attr.getName()),
|
|
getMDStringOrNull(attr.getLinkageName()), file, attr.getLine(), type,
|
|
attr.getScopeLine(),
|
|
/*ContainingType=*/nullptr, /*VirtualIndex=*/0,
|
|
/*ThisAdjustment=*/0, llvm::DINode::FlagZero,
|
|
static_cast<llvm::DISubprogram::DISPFlags>(attr.getSubprogramFlags()),
|
|
compileUnit, /*TemplateParams=*/nullptr, /*Declaration=*/nullptr,
|
|
getMDTupleOrNull(attr.getRetainedNodes()), nullptr,
|
|
getMDTupleOrNull(attr.getAnnotations()));
|
|
if (attr.getId())
|
|
distinctAttrToNode.try_emplace(attr.getId(), node);
|
|
return node;
|
|
}
|
|
|
|
llvm::DIModule *DebugTranslation::translateImpl(DIModuleAttr attr) {
|
|
return llvm::DIModule::get(
|
|
llvmCtx, translate(attr.getFile()), translate(attr.getScope()),
|
|
getMDStringOrNull(attr.getName()),
|
|
getMDStringOrNull(attr.getConfigMacros()),
|
|
getMDStringOrNull(attr.getIncludePath()),
|
|
getMDStringOrNull(attr.getApinotes()), attr.getLine(), attr.getIsDecl());
|
|
}
|
|
|
|
llvm::DINamespace *DebugTranslation::translateImpl(DINamespaceAttr attr) {
|
|
return llvm::DINamespace::get(llvmCtx, translate(attr.getScope()),
|
|
getMDStringOrNull(attr.getName()),
|
|
attr.getExportSymbols());
|
|
}
|
|
|
|
llvm::DIImportedEntity *
|
|
DebugTranslation::translateImpl(DIImportedEntityAttr attr) {
|
|
return llvm::DIImportedEntity::get(
|
|
llvmCtx, attr.getTag(), translate(attr.getScope()),
|
|
translate(attr.getEntity()), translate(attr.getFile()), attr.getLine(),
|
|
getMDStringOrNull(attr.getName()), getMDTupleOrNull(attr.getElements()));
|
|
}
|
|
|
|
llvm::DISubrange *DebugTranslation::translateImpl(DISubrangeAttr attr) {
|
|
auto getMetadataOrNull = [&](Attribute attr) -> llvm::Metadata * {
|
|
if (!attr)
|
|
return nullptr;
|
|
|
|
llvm::Metadata *metadata =
|
|
llvm::TypeSwitch<Attribute, llvm::Metadata *>(attr)
|
|
.Case([&](IntegerAttr intAttr) {
|
|
return llvm::ConstantAsMetadata::get(llvm::ConstantInt::getSigned(
|
|
llvm::Type::getInt64Ty(llvmCtx), intAttr.getInt()));
|
|
})
|
|
.Case([&](LLVM::DIExpressionAttr expr) {
|
|
return translateExpression(expr);
|
|
})
|
|
.Case([&](LLVM::DILocalVariableAttr local) {
|
|
return translate(local);
|
|
})
|
|
.Case<>([&](LLVM::DIGlobalVariableAttr global) {
|
|
return translate(global);
|
|
})
|
|
.Default([&](Attribute attr) { return nullptr; });
|
|
return metadata;
|
|
};
|
|
return llvm::DISubrange::get(llvmCtx, getMetadataOrNull(attr.getCount()),
|
|
getMetadataOrNull(attr.getLowerBound()),
|
|
getMetadataOrNull(attr.getUpperBound()),
|
|
getMetadataOrNull(attr.getStride()));
|
|
}
|
|
|
|
llvm::DICommonBlock *DebugTranslation::translateImpl(DICommonBlockAttr attr) {
|
|
return llvm::DICommonBlock::get(llvmCtx, translate(attr.getScope()),
|
|
translate(attr.getDecl()),
|
|
getMDStringOrNull(attr.getName()),
|
|
translate(attr.getFile()), attr.getLine());
|
|
}
|
|
|
|
llvm::DIGenericSubrange *
|
|
DebugTranslation::translateImpl(DIGenericSubrangeAttr attr) {
|
|
auto getMetadataOrNull = [&](Attribute attr) -> llvm::Metadata * {
|
|
if (!attr)
|
|
return nullptr;
|
|
|
|
llvm::Metadata *metadata =
|
|
llvm::TypeSwitch<Attribute, llvm::Metadata *>(attr)
|
|
.Case([&](LLVM::DIExpressionAttr expr) {
|
|
return translateExpression(expr);
|
|
})
|
|
.Case([&](LLVM::DILocalVariableAttr local) {
|
|
return translate(local);
|
|
})
|
|
.Case<>([&](LLVM::DIGlobalVariableAttr global) {
|
|
return translate(global);
|
|
})
|
|
.Default([&](Attribute attr) { return nullptr; });
|
|
return metadata;
|
|
};
|
|
return llvm::DIGenericSubrange::get(llvmCtx,
|
|
getMetadataOrNull(attr.getCount()),
|
|
getMetadataOrNull(attr.getLowerBound()),
|
|
getMetadataOrNull(attr.getUpperBound()),
|
|
getMetadataOrNull(attr.getStride()));
|
|
}
|
|
|
|
llvm::DISubroutineType *
|
|
DebugTranslation::translateImpl(DISubroutineTypeAttr attr) {
|
|
// Concatenate the result and argument types into a single array.
|
|
SmallVector<llvm::Metadata *> types;
|
|
for (DITypeAttr type : attr.getTypes())
|
|
types.push_back(translate(type));
|
|
return llvm::DISubroutineType::get(
|
|
llvmCtx, llvm::DINode::FlagZero, attr.getCallingConvention(),
|
|
llvm::DITypeRefArray(llvm::MDNode::get(llvmCtx, types)));
|
|
}
|
|
|
|
llvm::DIType *DebugTranslation::translateImpl(DITypeAttr attr) {
|
|
return cast<llvm::DIType>(translate(DINodeAttr(attr)));
|
|
}
|
|
|
|
llvm::DINode *DebugTranslation::translate(DINodeAttr attr) {
|
|
if (!attr)
|
|
return nullptr;
|
|
// Check for a cached instance.
|
|
if (llvm::DINode *node = attrToNode.lookup(attr))
|
|
return node;
|
|
|
|
llvm::DINode *node = nullptr;
|
|
// Recursive types go through a dedicated handler. All other types are
|
|
// dispatched directly to their specific handlers.
|
|
if (auto recTypeAttr = dyn_cast<DIRecursiveTypeAttrInterface>(attr))
|
|
if (recTypeAttr.getRecId())
|
|
node = translateRecursive(recTypeAttr);
|
|
|
|
if (!node)
|
|
node = TypeSwitch<DINodeAttr, llvm::DINode *>(attr)
|
|
.Case<DIBasicTypeAttr, DICommonBlockAttr, DICompileUnitAttr,
|
|
DICompositeTypeAttr, DIDerivedTypeAttr, DIFileAttr,
|
|
DIGenericSubrangeAttr, DIGlobalVariableAttr,
|
|
DIImportedEntityAttr, DILabelAttr, DILexicalBlockAttr,
|
|
DILexicalBlockFileAttr, DILocalVariableAttr, DIModuleAttr,
|
|
DINamespaceAttr, DINullTypeAttr, DIStringTypeAttr,
|
|
DISubprogramAttr, DISubrangeAttr, DISubroutineTypeAttr>(
|
|
[&](auto attr) { return translateImpl(attr); });
|
|
|
|
if (node && !node->isTemporary())
|
|
attrToNode.insert({attr, node});
|
|
return node;
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Locations
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// Translate the given location to an llvm debug location.
|
|
llvm::DILocation *DebugTranslation::translateLoc(Location loc,
|
|
llvm::DILocalScope *scope) {
|
|
if (!debugEmissionIsEnabled)
|
|
return nullptr;
|
|
return translateLoc(loc, scope, /*inlinedAt=*/nullptr);
|
|
}
|
|
|
|
llvm::DIExpression *
|
|
DebugTranslation::translateExpression(LLVM::DIExpressionAttr attr) {
|
|
SmallVector<uint64_t, 1> ops;
|
|
if (attr) {
|
|
// Append operations their operands to the list.
|
|
for (const DIExpressionElemAttr &op : attr.getOperations()) {
|
|
ops.push_back(op.getOpcode());
|
|
append_range(ops, op.getArguments());
|
|
}
|
|
}
|
|
return llvm::DIExpression::get(llvmCtx, ops);
|
|
}
|
|
|
|
llvm::DIGlobalVariableExpression *
|
|
DebugTranslation::translateGlobalVariableExpression(
|
|
LLVM::DIGlobalVariableExpressionAttr attr) {
|
|
return llvm::DIGlobalVariableExpression::get(
|
|
llvmCtx, translate(attr.getVar()), translateExpression(attr.getExpr()));
|
|
}
|
|
|
|
/// Translate the given location to an llvm DebugLoc.
|
|
llvm::DILocation *DebugTranslation::translateLoc(Location loc,
|
|
llvm::DILocalScope *scope,
|
|
llvm::DILocation *inlinedAt) {
|
|
// LLVM doesn't have a representation for unknown.
|
|
if (isa<UnknownLoc>(loc))
|
|
return nullptr;
|
|
|
|
// Check for a cached instance.
|
|
auto existingIt = locationToLoc.find(std::make_tuple(loc, scope, inlinedAt));
|
|
if (existingIt != locationToLoc.end())
|
|
return existingIt->second;
|
|
|
|
llvm::DILocation *llvmLoc = nullptr;
|
|
if (auto callLoc = dyn_cast<CallSiteLoc>(loc)) {
|
|
// For callsites, the caller is fed as the inlinedAt for the callee.
|
|
auto *callerLoc = translateLoc(callLoc.getCaller(), scope, inlinedAt);
|
|
// If the caller scope is not translatable, the overall callsite cannot be
|
|
// represented in LLVM (the callee scope may not match the parent function).
|
|
if (!callerLoc) {
|
|
// If there is an inlinedAt scope (an outer caller), skip to that
|
|
// directly. Otherwise, cannot translate.
|
|
if (!inlinedAt)
|
|
return nullptr;
|
|
callerLoc = inlinedAt;
|
|
}
|
|
llvmLoc = translateLoc(callLoc.getCallee(), nullptr, callerLoc);
|
|
// Fallback: Ignore callee if it has no debug scope.
|
|
if (!llvmLoc)
|
|
llvmLoc = callerLoc;
|
|
|
|
} else if (auto fileLoc = dyn_cast<FileLineColLoc>(loc)) {
|
|
// A scope of a DILocation cannot be null.
|
|
if (!scope)
|
|
return nullptr;
|
|
llvmLoc =
|
|
llvm::DILocation::get(llvmCtx, fileLoc.getLine(), fileLoc.getColumn(),
|
|
scope, const_cast<llvm::DILocation *>(inlinedAt));
|
|
|
|
} else if (auto fusedLoc = dyn_cast<FusedLoc>(loc)) {
|
|
ArrayRef<Location> locations = fusedLoc.getLocations();
|
|
|
|
// Check for a scope encoded with the location.
|
|
if (auto scopedAttr =
|
|
dyn_cast_or_null<LLVM::DILocalScopeAttr>(fusedLoc.getMetadata()))
|
|
scope = translate(scopedAttr);
|
|
|
|
// For fused locations, merge each of the nodes.
|
|
llvmLoc = translateLoc(locations.front(), scope, inlinedAt);
|
|
for (Location locIt : locations.drop_front()) {
|
|
llvmLoc = llvm::DILocation::getMergedLocation(
|
|
llvmLoc, translateLoc(locIt, scope, inlinedAt));
|
|
}
|
|
|
|
} else if (auto nameLoc = dyn_cast<NameLoc>(loc)) {
|
|
llvmLoc = translateLoc(nameLoc.getChildLoc(), scope, inlinedAt);
|
|
|
|
} else if (auto opaqueLoc = dyn_cast<OpaqueLoc>(loc)) {
|
|
llvmLoc = translateLoc(opaqueLoc.getFallbackLocation(), scope, inlinedAt);
|
|
} else {
|
|
llvm_unreachable("unknown location kind");
|
|
}
|
|
|
|
locationToLoc.try_emplace(std::make_tuple(loc, scope, inlinedAt), llvmLoc);
|
|
return llvmLoc;
|
|
}
|
|
|
|
/// Create an llvm debug file for the given file path.
|
|
llvm::DIFile *DebugTranslation::translateFile(StringRef fileName) {
|
|
auto *&file = fileMap[fileName];
|
|
if (file)
|
|
return file;
|
|
|
|
// Make sure the current working directory is up-to-date.
|
|
if (currentWorkingDir.empty())
|
|
llvm::sys::fs::current_path(currentWorkingDir);
|
|
|
|
StringRef directory = currentWorkingDir;
|
|
SmallString<128> dirBuf;
|
|
SmallString<128> fileBuf;
|
|
if (llvm::sys::path::is_absolute(fileName)) {
|
|
// Strip the common prefix (if it is more than just "/") from current
|
|
// directory and FileName for a more space-efficient encoding.
|
|
auto fileIt = llvm::sys::path::begin(fileName);
|
|
auto fileE = llvm::sys::path::end(fileName);
|
|
auto curDirIt = llvm::sys::path::begin(directory);
|
|
auto curDirE = llvm::sys::path::end(directory);
|
|
for (; curDirIt != curDirE && *curDirIt == *fileIt; ++curDirIt, ++fileIt)
|
|
llvm::sys::path::append(dirBuf, *curDirIt);
|
|
if (std::distance(llvm::sys::path::begin(directory), curDirIt) == 1) {
|
|
// Don't strip the common prefix if it is only the root "/" since that
|
|
// would make LLVM diagnostic locations confusing.
|
|
directory = StringRef();
|
|
} else {
|
|
for (; fileIt != fileE; ++fileIt)
|
|
llvm::sys::path::append(fileBuf, *fileIt);
|
|
directory = dirBuf;
|
|
fileName = fileBuf;
|
|
}
|
|
}
|
|
return (file = llvm::DIFile::get(llvmCtx, fileName, directory));
|
|
}
|