mirror of
https://github.com/RPCSX/llvm.git
synced 2025-01-11 06:56:40 +00:00
460dd60c1a
so we can stop using DW_OP_bit_piece with the wrong semantics. The entire back story can be found here: http://lists.llvm.org/pipermail/llvm-commits/Week-of-Mon-20161114/405934.html The gist is that in LLVM we've been misinterpreting DW_OP_bit_piece's offset field to mean the offset into the source variable rather than the offset into the location at the top the DWARF expression stack. In order to be able to fix this in a subsequent patch, this patch introduces a dedicated DW_OP_LLVM_fragment operation with the semantics that we used to apply to DW_OP_bit_piece, which is what we actually need while inside of LLVM. This patch is complete with a bitcode upgrade for expressions using the old format. It does not yet fix the DWARF backend to use DW_OP_bit_piece correctly. Implementation note: We discussed several options for implementing this, including reserving a dedicated field in DIExpression for the fragment size and offset, but using an custom operator at the end of the expression works just fine and is more efficient because we then only pay for it when we need it. Differential Revision: https://reviews.llvm.org/D27361 rdar://problem/29335809 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@288683 91177308-0d34-0410-b5e6-96231b3b80d8
659 lines
28 KiB
C++
659 lines
28 KiB
C++
//===- DebugInfoMetadata.cpp - Implement debug info metadata --------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements the debug info Metadata classes.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/IR/DebugInfoMetadata.h"
|
|
#include "LLVMContextImpl.h"
|
|
#include "MetadataImpl.h"
|
|
#include "llvm/ADT/StringSwitch.h"
|
|
#include "llvm/IR/Function.h"
|
|
|
|
using namespace llvm;
|
|
|
|
DILocation::DILocation(LLVMContext &C, StorageType Storage, unsigned Line,
|
|
unsigned Column, ArrayRef<Metadata *> MDs)
|
|
: MDNode(C, DILocationKind, Storage, MDs) {
|
|
assert((MDs.size() == 1 || MDs.size() == 2) &&
|
|
"Expected a scope and optional inlined-at");
|
|
|
|
// Set line and column.
|
|
assert(Column < (1u << 16) && "Expected 16-bit column");
|
|
|
|
SubclassData32 = Line;
|
|
SubclassData16 = Column;
|
|
}
|
|
|
|
static void adjustColumn(unsigned &Column) {
|
|
// Set to unknown on overflow. We only have 16 bits to play with here.
|
|
if (Column >= (1u << 16))
|
|
Column = 0;
|
|
}
|
|
|
|
DILocation *DILocation::getImpl(LLVMContext &Context, unsigned Line,
|
|
unsigned Column, Metadata *Scope,
|
|
Metadata *InlinedAt, StorageType Storage,
|
|
bool ShouldCreate) {
|
|
// Fixup column.
|
|
adjustColumn(Column);
|
|
|
|
if (Storage == Uniqued) {
|
|
if (auto *N =
|
|
getUniqued(Context.pImpl->DILocations,
|
|
DILocationInfo::KeyTy(Line, Column, Scope, InlinedAt)))
|
|
return N;
|
|
if (!ShouldCreate)
|
|
return nullptr;
|
|
} else {
|
|
assert(ShouldCreate && "Expected non-uniqued nodes to always be created");
|
|
}
|
|
|
|
SmallVector<Metadata *, 2> Ops;
|
|
Ops.push_back(Scope);
|
|
if (InlinedAt)
|
|
Ops.push_back(InlinedAt);
|
|
return storeImpl(new (Ops.size())
|
|
DILocation(Context, Storage, Line, Column, Ops),
|
|
Storage, Context.pImpl->DILocations);
|
|
}
|
|
|
|
DINode::DIFlags DINode::getFlag(StringRef Flag) {
|
|
return StringSwitch<DIFlags>(Flag)
|
|
#define HANDLE_DI_FLAG(ID, NAME) .Case("DIFlag" #NAME, Flag##NAME)
|
|
#include "llvm/IR/DebugInfoFlags.def"
|
|
.Default(DINode::FlagZero);
|
|
}
|
|
|
|
StringRef DINode::getFlagString(DIFlags Flag) {
|
|
switch (Flag) {
|
|
#define HANDLE_DI_FLAG(ID, NAME) \
|
|
case Flag##NAME: \
|
|
return "DIFlag" #NAME;
|
|
#include "llvm/IR/DebugInfoFlags.def"
|
|
}
|
|
return "";
|
|
}
|
|
|
|
DINode::DIFlags DINode::splitFlags(DIFlags Flags,
|
|
SmallVectorImpl<DIFlags> &SplitFlags) {
|
|
// Flags that are packed together need to be specially handled, so
|
|
// that, for example, we emit "DIFlagPublic" and not
|
|
// "DIFlagPrivate | DIFlagProtected".
|
|
if (DIFlags A = Flags & FlagAccessibility) {
|
|
if (A == FlagPrivate)
|
|
SplitFlags.push_back(FlagPrivate);
|
|
else if (A == FlagProtected)
|
|
SplitFlags.push_back(FlagProtected);
|
|
else
|
|
SplitFlags.push_back(FlagPublic);
|
|
Flags &= ~A;
|
|
}
|
|
if (DIFlags R = Flags & FlagPtrToMemberRep) {
|
|
if (R == FlagSingleInheritance)
|
|
SplitFlags.push_back(FlagSingleInheritance);
|
|
else if (R == FlagMultipleInheritance)
|
|
SplitFlags.push_back(FlagMultipleInheritance);
|
|
else
|
|
SplitFlags.push_back(FlagVirtualInheritance);
|
|
Flags &= ~R;
|
|
}
|
|
if ((Flags & FlagIndirectVirtualBase) == FlagIndirectVirtualBase) {
|
|
Flags &= ~FlagIndirectVirtualBase;
|
|
SplitFlags.push_back(FlagIndirectVirtualBase);
|
|
}
|
|
|
|
#define HANDLE_DI_FLAG(ID, NAME) \
|
|
if (DIFlags Bit = Flags & Flag##NAME) { \
|
|
SplitFlags.push_back(Bit); \
|
|
Flags &= ~Bit; \
|
|
}
|
|
#include "llvm/IR/DebugInfoFlags.def"
|
|
return Flags;
|
|
}
|
|
|
|
DIScopeRef DIScope::getScope() const {
|
|
if (auto *T = dyn_cast<DIType>(this))
|
|
return T->getScope();
|
|
|
|
if (auto *SP = dyn_cast<DISubprogram>(this))
|
|
return SP->getScope();
|
|
|
|
if (auto *LB = dyn_cast<DILexicalBlockBase>(this))
|
|
return LB->getScope();
|
|
|
|
if (auto *NS = dyn_cast<DINamespace>(this))
|
|
return NS->getScope();
|
|
|
|
if (auto *M = dyn_cast<DIModule>(this))
|
|
return M->getScope();
|
|
|
|
assert((isa<DIFile>(this) || isa<DICompileUnit>(this)) &&
|
|
"Unhandled type of scope.");
|
|
return nullptr;
|
|
}
|
|
|
|
StringRef DIScope::getName() const {
|
|
if (auto *T = dyn_cast<DIType>(this))
|
|
return T->getName();
|
|
if (auto *SP = dyn_cast<DISubprogram>(this))
|
|
return SP->getName();
|
|
if (auto *NS = dyn_cast<DINamespace>(this))
|
|
return NS->getName();
|
|
if (auto *M = dyn_cast<DIModule>(this))
|
|
return M->getName();
|
|
assert((isa<DILexicalBlockBase>(this) || isa<DIFile>(this) ||
|
|
isa<DICompileUnit>(this)) &&
|
|
"Unhandled type of scope.");
|
|
return "";
|
|
}
|
|
|
|
#ifndef NDEBUG
|
|
static bool isCanonical(const MDString *S) {
|
|
return !S || !S->getString().empty();
|
|
}
|
|
#endif
|
|
|
|
GenericDINode *GenericDINode::getImpl(LLVMContext &Context, unsigned Tag,
|
|
MDString *Header,
|
|
ArrayRef<Metadata *> DwarfOps,
|
|
StorageType Storage, bool ShouldCreate) {
|
|
unsigned Hash = 0;
|
|
if (Storage == Uniqued) {
|
|
GenericDINodeInfo::KeyTy Key(Tag, Header, DwarfOps);
|
|
if (auto *N = getUniqued(Context.pImpl->GenericDINodes, Key))
|
|
return N;
|
|
if (!ShouldCreate)
|
|
return nullptr;
|
|
Hash = Key.getHash();
|
|
} else {
|
|
assert(ShouldCreate && "Expected non-uniqued nodes to always be created");
|
|
}
|
|
|
|
// Use a nullptr for empty headers.
|
|
assert(isCanonical(Header) && "Expected canonical MDString");
|
|
Metadata *PreOps[] = {Header};
|
|
return storeImpl(new (DwarfOps.size() + 1) GenericDINode(
|
|
Context, Storage, Hash, Tag, PreOps, DwarfOps),
|
|
Storage, Context.pImpl->GenericDINodes);
|
|
}
|
|
|
|
void GenericDINode::recalculateHash() {
|
|
setHash(GenericDINodeInfo::KeyTy::calculateHash(this));
|
|
}
|
|
|
|
#define UNWRAP_ARGS_IMPL(...) __VA_ARGS__
|
|
#define UNWRAP_ARGS(ARGS) UNWRAP_ARGS_IMPL ARGS
|
|
#define DEFINE_GETIMPL_LOOKUP(CLASS, ARGS) \
|
|
do { \
|
|
if (Storage == Uniqued) { \
|
|
if (auto *N = getUniqued(Context.pImpl->CLASS##s, \
|
|
CLASS##Info::KeyTy(UNWRAP_ARGS(ARGS)))) \
|
|
return N; \
|
|
if (!ShouldCreate) \
|
|
return nullptr; \
|
|
} else { \
|
|
assert(ShouldCreate && \
|
|
"Expected non-uniqued nodes to always be created"); \
|
|
} \
|
|
} while (false)
|
|
#define DEFINE_GETIMPL_STORE(CLASS, ARGS, OPS) \
|
|
return storeImpl(new (array_lengthof(OPS)) \
|
|
CLASS(Context, Storage, UNWRAP_ARGS(ARGS), OPS), \
|
|
Storage, Context.pImpl->CLASS##s)
|
|
#define DEFINE_GETIMPL_STORE_NO_OPS(CLASS, ARGS) \
|
|
return storeImpl(new (0u) CLASS(Context, Storage, UNWRAP_ARGS(ARGS)), \
|
|
Storage, Context.pImpl->CLASS##s)
|
|
#define DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(CLASS, OPS) \
|
|
return storeImpl(new (array_lengthof(OPS)) CLASS(Context, Storage, OPS), \
|
|
Storage, Context.pImpl->CLASS##s)
|
|
|
|
DISubrange *DISubrange::getImpl(LLVMContext &Context, int64_t Count, int64_t Lo,
|
|
StorageType Storage, bool ShouldCreate) {
|
|
DEFINE_GETIMPL_LOOKUP(DISubrange, (Count, Lo));
|
|
DEFINE_GETIMPL_STORE_NO_OPS(DISubrange, (Count, Lo));
|
|
}
|
|
|
|
DIEnumerator *DIEnumerator::getImpl(LLVMContext &Context, int64_t Value,
|
|
MDString *Name, StorageType Storage,
|
|
bool ShouldCreate) {
|
|
assert(isCanonical(Name) && "Expected canonical MDString");
|
|
DEFINE_GETIMPL_LOOKUP(DIEnumerator, (Value, Name));
|
|
Metadata *Ops[] = {Name};
|
|
DEFINE_GETIMPL_STORE(DIEnumerator, (Value), Ops);
|
|
}
|
|
|
|
DIBasicType *DIBasicType::getImpl(LLVMContext &Context, unsigned Tag,
|
|
MDString *Name, uint64_t SizeInBits,
|
|
uint32_t AlignInBits, unsigned Encoding,
|
|
StorageType Storage, bool ShouldCreate) {
|
|
assert(isCanonical(Name) && "Expected canonical MDString");
|
|
DEFINE_GETIMPL_LOOKUP(DIBasicType,
|
|
(Tag, Name, SizeInBits, AlignInBits, Encoding));
|
|
Metadata *Ops[] = {nullptr, nullptr, Name};
|
|
DEFINE_GETIMPL_STORE(DIBasicType, (Tag, SizeInBits, AlignInBits, Encoding),
|
|
Ops);
|
|
}
|
|
|
|
DIDerivedType *DIDerivedType::getImpl(
|
|
LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *File,
|
|
unsigned Line, Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits,
|
|
uint32_t AlignInBits, uint64_t OffsetInBits, DIFlags Flags,
|
|
Metadata *ExtraData, StorageType Storage, bool ShouldCreate) {
|
|
assert(isCanonical(Name) && "Expected canonical MDString");
|
|
DEFINE_GETIMPL_LOOKUP(DIDerivedType,
|
|
(Tag, Name, File, Line, Scope, BaseType, SizeInBits,
|
|
AlignInBits, OffsetInBits, Flags, ExtraData));
|
|
Metadata *Ops[] = {File, Scope, Name, BaseType, ExtraData};
|
|
DEFINE_GETIMPL_STORE(
|
|
DIDerivedType, (Tag, Line, SizeInBits, AlignInBits, OffsetInBits, Flags),
|
|
Ops);
|
|
}
|
|
|
|
DICompositeType *DICompositeType::getImpl(
|
|
LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *File,
|
|
unsigned Line, Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits,
|
|
uint32_t AlignInBits, uint64_t OffsetInBits, DIFlags Flags,
|
|
Metadata *Elements, unsigned RuntimeLang, Metadata *VTableHolder,
|
|
Metadata *TemplateParams, MDString *Identifier, StorageType Storage,
|
|
bool ShouldCreate) {
|
|
assert(isCanonical(Name) && "Expected canonical MDString");
|
|
|
|
// Keep this in sync with buildODRType.
|
|
DEFINE_GETIMPL_LOOKUP(
|
|
DICompositeType, (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
|
|
AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
|
|
VTableHolder, TemplateParams, Identifier));
|
|
Metadata *Ops[] = {File, Scope, Name, BaseType,
|
|
Elements, VTableHolder, TemplateParams, Identifier};
|
|
DEFINE_GETIMPL_STORE(DICompositeType, (Tag, Line, RuntimeLang, SizeInBits,
|
|
AlignInBits, OffsetInBits, Flags),
|
|
Ops);
|
|
}
|
|
|
|
DICompositeType *DICompositeType::buildODRType(
|
|
LLVMContext &Context, MDString &Identifier, unsigned Tag, MDString *Name,
|
|
Metadata *File, unsigned Line, Metadata *Scope, Metadata *BaseType,
|
|
uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits,
|
|
DIFlags Flags, Metadata *Elements, unsigned RuntimeLang,
|
|
Metadata *VTableHolder, Metadata *TemplateParams) {
|
|
assert(!Identifier.getString().empty() && "Expected valid identifier");
|
|
if (!Context.isODRUniquingDebugTypes())
|
|
return nullptr;
|
|
auto *&CT = (*Context.pImpl->DITypeMap)[&Identifier];
|
|
if (!CT)
|
|
return CT = DICompositeType::getDistinct(
|
|
Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits,
|
|
AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,
|
|
VTableHolder, TemplateParams, &Identifier);
|
|
|
|
// Only mutate CT if it's a forward declaration and the new operands aren't.
|
|
assert(CT->getRawIdentifier() == &Identifier && "Wrong ODR identifier?");
|
|
if (!CT->isForwardDecl() || (Flags & DINode::FlagFwdDecl))
|
|
return CT;
|
|
|
|
// Mutate CT in place. Keep this in sync with getImpl.
|
|
CT->mutate(Tag, Line, RuntimeLang, SizeInBits, AlignInBits, OffsetInBits,
|
|
Flags);
|
|
Metadata *Ops[] = {File, Scope, Name, BaseType,
|
|
Elements, VTableHolder, TemplateParams, &Identifier};
|
|
assert((std::end(Ops) - std::begin(Ops)) == (int)CT->getNumOperands() &&
|
|
"Mismatched number of operands");
|
|
for (unsigned I = 0, E = CT->getNumOperands(); I != E; ++I)
|
|
if (Ops[I] != CT->getOperand(I))
|
|
CT->setOperand(I, Ops[I]);
|
|
return CT;
|
|
}
|
|
|
|
DICompositeType *DICompositeType::getODRType(
|
|
LLVMContext &Context, MDString &Identifier, unsigned Tag, MDString *Name,
|
|
Metadata *File, unsigned Line, Metadata *Scope, Metadata *BaseType,
|
|
uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits,
|
|
DIFlags Flags, Metadata *Elements, unsigned RuntimeLang,
|
|
Metadata *VTableHolder, Metadata *TemplateParams) {
|
|
assert(!Identifier.getString().empty() && "Expected valid identifier");
|
|
if (!Context.isODRUniquingDebugTypes())
|
|
return nullptr;
|
|
auto *&CT = (*Context.pImpl->DITypeMap)[&Identifier];
|
|
if (!CT)
|
|
CT = DICompositeType::getDistinct(
|
|
Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits,
|
|
AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang, VTableHolder,
|
|
TemplateParams, &Identifier);
|
|
return CT;
|
|
}
|
|
|
|
DICompositeType *DICompositeType::getODRTypeIfExists(LLVMContext &Context,
|
|
MDString &Identifier) {
|
|
assert(!Identifier.getString().empty() && "Expected valid identifier");
|
|
if (!Context.isODRUniquingDebugTypes())
|
|
return nullptr;
|
|
return Context.pImpl->DITypeMap->lookup(&Identifier);
|
|
}
|
|
|
|
DISubroutineType *DISubroutineType::getImpl(LLVMContext &Context, DIFlags Flags,
|
|
uint8_t CC, Metadata *TypeArray,
|
|
StorageType Storage,
|
|
bool ShouldCreate) {
|
|
DEFINE_GETIMPL_LOOKUP(DISubroutineType, (Flags, CC, TypeArray));
|
|
Metadata *Ops[] = {nullptr, nullptr, nullptr, TypeArray};
|
|
DEFINE_GETIMPL_STORE(DISubroutineType, (Flags, CC), Ops);
|
|
}
|
|
|
|
DIFile *DIFile::getImpl(LLVMContext &Context, MDString *Filename,
|
|
MDString *Directory, StorageType Storage,
|
|
bool ShouldCreate) {
|
|
assert(isCanonical(Filename) && "Expected canonical MDString");
|
|
assert(isCanonical(Directory) && "Expected canonical MDString");
|
|
DEFINE_GETIMPL_LOOKUP(DIFile, (Filename, Directory));
|
|
Metadata *Ops[] = {Filename, Directory};
|
|
DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(DIFile, Ops);
|
|
}
|
|
|
|
DICompileUnit *DICompileUnit::getImpl(
|
|
LLVMContext &Context, unsigned SourceLanguage, Metadata *File,
|
|
MDString *Producer, bool IsOptimized, MDString *Flags,
|
|
unsigned RuntimeVersion, MDString *SplitDebugFilename,
|
|
unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes,
|
|
Metadata *GlobalVariables, Metadata *ImportedEntities, Metadata *Macros,
|
|
uint64_t DWOId, bool SplitDebugInlining, StorageType Storage,
|
|
bool ShouldCreate) {
|
|
assert(Storage != Uniqued && "Cannot unique DICompileUnit");
|
|
assert(isCanonical(Producer) && "Expected canonical MDString");
|
|
assert(isCanonical(Flags) && "Expected canonical MDString");
|
|
assert(isCanonical(SplitDebugFilename) && "Expected canonical MDString");
|
|
|
|
Metadata *Ops[] = {
|
|
File, Producer, Flags, SplitDebugFilename,
|
|
EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities,
|
|
Macros};
|
|
return storeImpl(new (array_lengthof(Ops))
|
|
DICompileUnit(Context, Storage, SourceLanguage,
|
|
IsOptimized, RuntimeVersion, EmissionKind,
|
|
DWOId, SplitDebugInlining, Ops),
|
|
Storage);
|
|
}
|
|
|
|
Optional<DICompileUnit::DebugEmissionKind>
|
|
DICompileUnit::getEmissionKind(StringRef Str) {
|
|
return StringSwitch<Optional<DebugEmissionKind>>(Str)
|
|
.Case("NoDebug", NoDebug)
|
|
.Case("FullDebug", FullDebug)
|
|
.Case("LineTablesOnly", LineTablesOnly)
|
|
.Default(None);
|
|
}
|
|
|
|
const char *DICompileUnit::EmissionKindString(DebugEmissionKind EK) {
|
|
switch (EK) {
|
|
case NoDebug: return "NoDebug";
|
|
case FullDebug: return "FullDebug";
|
|
case LineTablesOnly: return "LineTablesOnly";
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
DISubprogram *DILocalScope::getSubprogram() const {
|
|
if (auto *Block = dyn_cast<DILexicalBlockBase>(this))
|
|
return Block->getScope()->getSubprogram();
|
|
return const_cast<DISubprogram *>(cast<DISubprogram>(this));
|
|
}
|
|
|
|
DILocalScope *DILocalScope::getNonLexicalBlockFileScope() const {
|
|
if (auto *File = dyn_cast<DILexicalBlockFile>(this))
|
|
return File->getScope()->getNonLexicalBlockFileScope();
|
|
return const_cast<DILocalScope *>(this);
|
|
}
|
|
|
|
DISubprogram *DISubprogram::getImpl(
|
|
LLVMContext &Context, Metadata *Scope, MDString *Name,
|
|
MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type,
|
|
bool IsLocalToUnit, bool IsDefinition, unsigned ScopeLine,
|
|
Metadata *ContainingType, unsigned Virtuality, unsigned VirtualIndex,
|
|
int ThisAdjustment, DIFlags Flags, bool IsOptimized, Metadata *Unit,
|
|
Metadata *TemplateParams, Metadata *Declaration, Metadata *Variables,
|
|
StorageType Storage, bool ShouldCreate) {
|
|
assert(isCanonical(Name) && "Expected canonical MDString");
|
|
assert(isCanonical(LinkageName) && "Expected canonical MDString");
|
|
DEFINE_GETIMPL_LOOKUP(
|
|
DISubprogram,
|
|
(Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition,
|
|
ScopeLine, ContainingType, Virtuality, VirtualIndex, ThisAdjustment,
|
|
Flags, IsOptimized, Unit, TemplateParams, Declaration, Variables));
|
|
Metadata *Ops[] = {File, Scope, Name, Name,
|
|
LinkageName, Type, ContainingType, Unit,
|
|
TemplateParams, Declaration, Variables};
|
|
DEFINE_GETIMPL_STORE(DISubprogram, (Line, ScopeLine, Virtuality, VirtualIndex,
|
|
ThisAdjustment, Flags, IsLocalToUnit,
|
|
IsDefinition, IsOptimized),
|
|
Ops);
|
|
}
|
|
|
|
bool DISubprogram::describes(const Function *F) const {
|
|
assert(F && "Invalid function");
|
|
if (F->getSubprogram() == this)
|
|
return true;
|
|
StringRef Name = getLinkageName();
|
|
if (Name.empty())
|
|
Name = getName();
|
|
return F->getName() == Name;
|
|
}
|
|
|
|
DILexicalBlock *DILexicalBlock::getImpl(LLVMContext &Context, Metadata *Scope,
|
|
Metadata *File, unsigned Line,
|
|
unsigned Column, StorageType Storage,
|
|
bool ShouldCreate) {
|
|
// Fixup column.
|
|
adjustColumn(Column);
|
|
|
|
assert(Scope && "Expected scope");
|
|
DEFINE_GETIMPL_LOOKUP(DILexicalBlock, (Scope, File, Line, Column));
|
|
Metadata *Ops[] = {File, Scope};
|
|
DEFINE_GETIMPL_STORE(DILexicalBlock, (Line, Column), Ops);
|
|
}
|
|
|
|
DILexicalBlockFile *DILexicalBlockFile::getImpl(LLVMContext &Context,
|
|
Metadata *Scope, Metadata *File,
|
|
unsigned Discriminator,
|
|
StorageType Storage,
|
|
bool ShouldCreate) {
|
|
assert(Scope && "Expected scope");
|
|
DEFINE_GETIMPL_LOOKUP(DILexicalBlockFile, (Scope, File, Discriminator));
|
|
Metadata *Ops[] = {File, Scope};
|
|
DEFINE_GETIMPL_STORE(DILexicalBlockFile, (Discriminator), Ops);
|
|
}
|
|
|
|
DINamespace *DINamespace::getImpl(LLVMContext &Context, Metadata *Scope,
|
|
Metadata *File, MDString *Name, unsigned Line,
|
|
bool ExportSymbols, StorageType Storage,
|
|
bool ShouldCreate) {
|
|
assert(isCanonical(Name) && "Expected canonical MDString");
|
|
DEFINE_GETIMPL_LOOKUP(DINamespace, (Scope, File, Name, Line, ExportSymbols));
|
|
Metadata *Ops[] = {File, Scope, Name};
|
|
DEFINE_GETIMPL_STORE(DINamespace, (Line, ExportSymbols), Ops);
|
|
}
|
|
|
|
DIModule *DIModule::getImpl(LLVMContext &Context, Metadata *Scope,
|
|
MDString *Name, MDString *ConfigurationMacros,
|
|
MDString *IncludePath, MDString *ISysRoot,
|
|
StorageType Storage, bool ShouldCreate) {
|
|
assert(isCanonical(Name) && "Expected canonical MDString");
|
|
DEFINE_GETIMPL_LOOKUP(
|
|
DIModule, (Scope, Name, ConfigurationMacros, IncludePath, ISysRoot));
|
|
Metadata *Ops[] = {Scope, Name, ConfigurationMacros, IncludePath, ISysRoot};
|
|
DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(DIModule, Ops);
|
|
}
|
|
|
|
DITemplateTypeParameter *DITemplateTypeParameter::getImpl(LLVMContext &Context,
|
|
MDString *Name,
|
|
Metadata *Type,
|
|
StorageType Storage,
|
|
bool ShouldCreate) {
|
|
assert(isCanonical(Name) && "Expected canonical MDString");
|
|
DEFINE_GETIMPL_LOOKUP(DITemplateTypeParameter, (Name, Type));
|
|
Metadata *Ops[] = {Name, Type};
|
|
DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(DITemplateTypeParameter, Ops);
|
|
}
|
|
|
|
DITemplateValueParameter *DITemplateValueParameter::getImpl(
|
|
LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *Type,
|
|
Metadata *Value, StorageType Storage, bool ShouldCreate) {
|
|
assert(isCanonical(Name) && "Expected canonical MDString");
|
|
DEFINE_GETIMPL_LOOKUP(DITemplateValueParameter, (Tag, Name, Type, Value));
|
|
Metadata *Ops[] = {Name, Type, Value};
|
|
DEFINE_GETIMPL_STORE(DITemplateValueParameter, (Tag), Ops);
|
|
}
|
|
|
|
DIGlobalVariable *
|
|
DIGlobalVariable::getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name,
|
|
MDString *LinkageName, Metadata *File, unsigned Line,
|
|
Metadata *Type, bool IsLocalToUnit, bool IsDefinition,
|
|
Metadata *Variable,
|
|
Metadata *StaticDataMemberDeclaration,
|
|
uint32_t AlignInBits,
|
|
StorageType Storage, bool ShouldCreate) {
|
|
assert(isCanonical(Name) && "Expected canonical MDString");
|
|
assert(isCanonical(LinkageName) && "Expected canonical MDString");
|
|
DEFINE_GETIMPL_LOOKUP(DIGlobalVariable,
|
|
(Scope, Name, LinkageName, File, Line, Type,
|
|
IsLocalToUnit, IsDefinition, Variable,
|
|
StaticDataMemberDeclaration, AlignInBits));
|
|
Metadata *Ops[] = {Scope, Name, File, Type,
|
|
Name, LinkageName, Variable, StaticDataMemberDeclaration};
|
|
DEFINE_GETIMPL_STORE(DIGlobalVariable,
|
|
(Line, IsLocalToUnit, IsDefinition, AlignInBits),
|
|
Ops);
|
|
}
|
|
|
|
DILocalVariable *DILocalVariable::getImpl(LLVMContext &Context, Metadata *Scope,
|
|
MDString *Name, Metadata *File,
|
|
unsigned Line, Metadata *Type,
|
|
unsigned Arg, DIFlags Flags,
|
|
uint32_t AlignInBits,
|
|
StorageType Storage,
|
|
bool ShouldCreate) {
|
|
// 64K ought to be enough for any frontend.
|
|
assert(Arg <= UINT16_MAX && "Expected argument number to fit in 16-bits");
|
|
|
|
assert(Scope && "Expected scope");
|
|
assert(isCanonical(Name) && "Expected canonical MDString");
|
|
DEFINE_GETIMPL_LOOKUP(DILocalVariable,
|
|
(Scope, Name, File, Line, Type, Arg, Flags,
|
|
AlignInBits));
|
|
Metadata *Ops[] = {Scope, Name, File, Type};
|
|
DEFINE_GETIMPL_STORE(DILocalVariable, (Line, Arg, Flags, AlignInBits), Ops);
|
|
}
|
|
|
|
DIExpression *DIExpression::getImpl(LLVMContext &Context,
|
|
ArrayRef<uint64_t> Elements,
|
|
StorageType Storage, bool ShouldCreate) {
|
|
DEFINE_GETIMPL_LOOKUP(DIExpression, (Elements));
|
|
DEFINE_GETIMPL_STORE_NO_OPS(DIExpression, (Elements));
|
|
}
|
|
|
|
unsigned DIExpression::ExprOperand::getSize() const {
|
|
switch (getOp()) {
|
|
case dwarf::DW_OP_LLVM_fragment:
|
|
return 3;
|
|
case dwarf::DW_OP_constu:
|
|
case dwarf::DW_OP_plus:
|
|
case dwarf::DW_OP_minus:
|
|
return 2;
|
|
default:
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
bool DIExpression::isValid() const {
|
|
for (auto I = expr_op_begin(), E = expr_op_end(); I != E; ++I) {
|
|
// Check that there's space for the operand.
|
|
if (I->get() + I->getSize() > E->get())
|
|
return false;
|
|
|
|
// Check that the operand is valid.
|
|
switch (I->getOp()) {
|
|
default:
|
|
return false;
|
|
case dwarf::DW_OP_LLVM_fragment:
|
|
case dwarf::DW_OP_stack_value:
|
|
// We only support fragment and stack value expressions which appear at
|
|
// the end.
|
|
return I->get() + I->getSize() == E->get();
|
|
case dwarf::DW_OP_constu:
|
|
case dwarf::DW_OP_plus:
|
|
case dwarf::DW_OP_minus:
|
|
case dwarf::DW_OP_deref:
|
|
break;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool DIExpression::isFragment() const {
|
|
assert(isValid() && "Expected valid expression");
|
|
if (unsigned N = getNumElements())
|
|
if (N >= 3)
|
|
return getElement(N - 3) == dwarf::DW_OP_LLVM_fragment;
|
|
return false;
|
|
}
|
|
|
|
uint64_t DIExpression::getFragmentOffsetInBits() const {
|
|
assert(isFragment() && "Expected fragment");
|
|
return getElement(getNumElements() - 2);
|
|
}
|
|
|
|
uint64_t DIExpression::getFragmentSizeInBits() const {
|
|
assert(isFragment() && "Expected fragment");
|
|
return getElement(getNumElements() - 1);
|
|
}
|
|
|
|
DIObjCProperty *DIObjCProperty::getImpl(
|
|
LLVMContext &Context, MDString *Name, Metadata *File, unsigned Line,
|
|
MDString *GetterName, MDString *SetterName, unsigned Attributes,
|
|
Metadata *Type, StorageType Storage, bool ShouldCreate) {
|
|
assert(isCanonical(Name) && "Expected canonical MDString");
|
|
assert(isCanonical(GetterName) && "Expected canonical MDString");
|
|
assert(isCanonical(SetterName) && "Expected canonical MDString");
|
|
DEFINE_GETIMPL_LOOKUP(DIObjCProperty, (Name, File, Line, GetterName,
|
|
SetterName, Attributes, Type));
|
|
Metadata *Ops[] = {Name, File, GetterName, SetterName, Type};
|
|
DEFINE_GETIMPL_STORE(DIObjCProperty, (Line, Attributes), Ops);
|
|
}
|
|
|
|
DIImportedEntity *DIImportedEntity::getImpl(LLVMContext &Context, unsigned Tag,
|
|
Metadata *Scope, Metadata *Entity,
|
|
unsigned Line, MDString *Name,
|
|
StorageType Storage,
|
|
bool ShouldCreate) {
|
|
assert(isCanonical(Name) && "Expected canonical MDString");
|
|
DEFINE_GETIMPL_LOOKUP(DIImportedEntity, (Tag, Scope, Entity, Line, Name));
|
|
Metadata *Ops[] = {Scope, Entity, Name};
|
|
DEFINE_GETIMPL_STORE(DIImportedEntity, (Tag, Line), Ops);
|
|
}
|
|
|
|
DIMacro *DIMacro::getImpl(LLVMContext &Context, unsigned MIType,
|
|
unsigned Line, MDString *Name, MDString *Value,
|
|
StorageType Storage, bool ShouldCreate) {
|
|
assert(isCanonical(Name) && "Expected canonical MDString");
|
|
DEFINE_GETIMPL_LOOKUP(DIMacro, (MIType, Line, Name, Value));
|
|
Metadata *Ops[] = { Name, Value };
|
|
DEFINE_GETIMPL_STORE(DIMacro, (MIType, Line), Ops);
|
|
}
|
|
|
|
DIMacroFile *DIMacroFile::getImpl(LLVMContext &Context, unsigned MIType,
|
|
unsigned Line, Metadata *File,
|
|
Metadata *Elements, StorageType Storage,
|
|
bool ShouldCreate) {
|
|
DEFINE_GETIMPL_LOOKUP(DIMacroFile,
|
|
(MIType, Line, File, Elements));
|
|
Metadata *Ops[] = { File, Elements };
|
|
DEFINE_GETIMPL_STORE(DIMacroFile, (MIType, Line), Ops);
|
|
}
|
|
|