2ea60f4197
There's an issue in the translator today where, for a CallsiteLoc, if the callee does not have a DI scope (perhaps due to compile options or optimizations), it may get propagated the DI scope of its callsite's parent function, which will create a non-existent DILocation combining line & col number from one file, and the filename from another. The root problem is we cannot propagate the parent scope when translating the callee location, as it no longer applies to inlined locations (see code diff and hopefully this will make sense). To facilitate this, the importer is also changed so that callee scopes are fused with the callee FileLineCol loc, instead of on the Callsite loc itself. This comes with the benefit that we now have a symmetric Callsite loc representation. If we required the callee scope be always annotated on the Callsite loc, it would be hard for generic inlining passes to maintain that, since it would have to somehow understand the semantics of the fused metadata and pull it out while inlining.
409 lines
16 KiB
C++
409 lines
16 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;
|
|
|
|
// TODO: The version information should be encoded on the LLVM module itself,
|
|
// not implicitly set here.
|
|
|
|
// Mark this module as having debug information.
|
|
StringRef debugVersionKey = "Debug Info Version";
|
|
if (!llvmModule.getModuleFlag(debugVersionKey))
|
|
llvmModule.addModuleFlag(llvm::Module::Warning, debugVersionKey,
|
|
llvm::DEBUG_METADATA_VERSION);
|
|
|
|
if (auto targetTripleAttr = module->getDiscardableAttr(
|
|
LLVM::LLVMDialect::getTargetTripleAttrName())) {
|
|
auto targetTriple =
|
|
llvm::Triple(cast<StringAttr>(targetTripleAttr).getValue());
|
|
if (targetTriple.isKnownWindowsMSVCEnvironment()) {
|
|
// Dwarf debugging files will be generated by default, unless "CodeView"
|
|
// is set explicitly. Windows/MSVC should use CodeView instead.
|
|
llvmModule.addModuleFlag(llvm::Module::Warning, "CodeView", 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Finalize the translation of debug information.
|
|
void DebugTranslation::finalize() {}
|
|
|
|
/// 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::MDString *DebugTranslation::getMDStringOrNull(StringAttr stringAttr) {
|
|
if (!stringAttr || stringAttr.empty())
|
|
return nullptr;
|
|
return llvm::MDString::get(llvmCtx, stringAttr);
|
|
}
|
|
|
|
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()));
|
|
}
|
|
|
|
/// 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::DICompositeType *
|
|
DebugTranslation::translateImpl(DICompositeTypeAttr attr) {
|
|
SmallVector<llvm::Metadata *> elements;
|
|
for (auto member : attr.getElements())
|
|
elements.push_back(translate(member));
|
|
|
|
// 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()),
|
|
llvm::MDNode::get(llvmCtx, elements),
|
|
/*RuntimeLang=*/0, /*VTableHolder=*/nullptr);
|
|
}
|
|
|
|
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(),
|
|
/*DWARFAddressSpace=*/std::nullopt, /*Flags=*/llvm::DINode::FlagZero);
|
|
}
|
|
|
|
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::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(),
|
|
/*Flags=*/llvm::DINode::FlagZero, 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::DIScope *DebugTranslation::translateImpl(DIScopeAttr attr) {
|
|
return cast<llvm::DIScope>(translate(DINodeAttr(attr)));
|
|
}
|
|
|
|
llvm::DISubprogram *DebugTranslation::translateImpl(DISubprogramAttr attr) {
|
|
bool isDefinition = static_cast<bool>(attr.getSubprogramFlags() &
|
|
LLVM::DISubprogramFlags::Definition);
|
|
return getDistinctOrUnique<llvm::DISubprogram>(
|
|
isDefinition, llvmCtx, translate(attr.getScope()),
|
|
getMDStringOrNull(attr.getName()),
|
|
getMDStringOrNull(attr.getLinkageName()), translate(attr.getFile()),
|
|
attr.getLine(), translate(attr.getType()), attr.getScopeLine(),
|
|
/*ContainingType=*/nullptr, /*VirtualIndex=*/0,
|
|
/*ThisAdjustment=*/0, llvm::DINode::FlagZero,
|
|
static_cast<llvm::DISubprogram::DISPFlags>(attr.getSubprogramFlags()),
|
|
translate(attr.getCompileUnit()));
|
|
}
|
|
|
|
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::DISubrange *DebugTranslation::translateImpl(DISubrangeAttr attr) {
|
|
auto getMetadataOrNull = [&](IntegerAttr attr) -> llvm::Metadata * {
|
|
if (!attr)
|
|
return nullptr;
|
|
return llvm::ConstantAsMetadata::get(llvm::ConstantInt::getSigned(
|
|
llvm::Type::getInt64Ty(llvmCtx), attr.getInt()));
|
|
};
|
|
return llvm::DISubrange::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 =
|
|
TypeSwitch<DINodeAttr, llvm::DINode *>(attr)
|
|
.Case<DIBasicTypeAttr, DICompileUnitAttr, DICompositeTypeAttr,
|
|
DIDerivedTypeAttr, DIFileAttr, DIGlobalVariableAttr,
|
|
DILabelAttr, DILexicalBlockAttr, DILexicalBlockFileAttr,
|
|
DILocalVariableAttr, DIModuleAttr, DINamespaceAttr,
|
|
DINullTypeAttr, DISubprogramAttr, DISubrangeAttr,
|
|
DISubroutineTypeAttr>(
|
|
[&](auto attr) { return translateImpl(attr); });
|
|
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);
|
|
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));
|
|
}
|