mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2025-06-19 03:24:09 +00:00
Update DebugInfo interface to use metadata, instead of special named llvm.dbg.... global variables, to encode debugging information in llvm IR. This is mostly a mechanical change that tests metadata support very well.
This change speeds up llvm-gcc by more then 6% at "-O0 -g" (measured by compiling InstructionCombining.cpp!) git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@79977 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Devang Patel
@ -10,7 +10,7 @@
|
||||
// This file contains support for writing dwarf debug info into asm files.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#define DEBUG_TYPE "dwarfdebug"
|
||||
#include "DwarfDebug.h"
|
||||
#include "llvm/Module.h"
|
||||
#include "llvm/CodeGen/MachineFunction.h"
|
||||
@ -24,6 +24,7 @@
|
||||
#include "llvm/Target/TargetRegisterInfo.h"
|
||||
#include "llvm/ADT/StringExtras.h"
|
||||
#include "llvm/Support/Timer.h"
|
||||
#include "llvm/Support/Debug.h"
|
||||
#include "llvm/System/Path.h"
|
||||
using namespace llvm;
|
||||
|
||||
@ -56,11 +57,13 @@ class VISIBILITY_HIDDEN CompileUnit {
|
||||
|
||||
/// GVToDieMap - Tracks the mapping of unit level debug informaton
|
||||
/// variables to debug information entries.
|
||||
std::map<GlobalVariable *, DIE *> GVToDieMap;
|
||||
/// FIXME : Rename GVToDieMap -> NodeToDieMap
|
||||
std::map<MDNode *, DIE *> GVToDieMap;
|
||||
|
||||
/// GVToDIEEntryMap - Tracks the mapping of unit level debug informaton
|
||||
/// descriptors to debug information entries using a DIEEntry proxy.
|
||||
std::map<GlobalVariable *, DIEEntry *> GVToDIEEntryMap;
|
||||
/// FIXME : Rename
|
||||
std::map<MDNode *, DIEEntry *> GVToDIEEntryMap;
|
||||
|
||||
/// Globals - A map of globally visible named entities for this unit.
|
||||
///
|
||||
@ -89,12 +92,12 @@ public:
|
||||
|
||||
/// getDieMapSlotFor - Returns the debug information entry map slot for the
|
||||
/// specified debug variable.
|
||||
DIE *&getDieMapSlotFor(GlobalVariable *GV) { return GVToDieMap[GV]; }
|
||||
DIE *&getDieMapSlotFor(MDNode *N) { return GVToDieMap[N]; }
|
||||
|
||||
/// getDIEEntrySlotFor - Returns the debug information entry proxy slot for
|
||||
/// the specified debug variable.
|
||||
DIEEntry *&getDIEEntrySlotFor(GlobalVariable *GV) {
|
||||
return GVToDIEEntryMap[GV];
|
||||
DIEEntry *&getDIEEntrySlotFor(MDNode *N) {
|
||||
return GVToDIEEntryMap[N];
|
||||
}
|
||||
|
||||
/// AddDie - Adds or interns the DIE to the compile unit.
|
||||
@ -239,7 +242,7 @@ DwarfDebug::~DwarfDebug() {
|
||||
for (unsigned j = 0, M = Values.size(); j < M; ++j)
|
||||
delete Values[j];
|
||||
|
||||
for (DenseMap<const GlobalVariable *, DbgScope *>::iterator
|
||||
for (DenseMap<const MDNode *, DbgScope *>::iterator
|
||||
I = AbstractInstanceRootMap.begin(),
|
||||
E = AbstractInstanceRootMap.end(); I != E;++I)
|
||||
delete I->second;
|
||||
@ -531,7 +534,7 @@ void DwarfDebug::AddType(CompileUnit *DW_Unit, DIE *Entity, DIType Ty) {
|
||||
return;
|
||||
|
||||
// Check for pre-existence.
|
||||
DIEEntry *&Slot = DW_Unit->getDIEEntrySlotFor(Ty.getGV());
|
||||
DIEEntry *&Slot = DW_Unit->getDIEEntrySlotFor(Ty.getNode());
|
||||
|
||||
// If it exists then use the existing value.
|
||||
if (Slot) {
|
||||
@ -545,19 +548,20 @@ void DwarfDebug::AddType(CompileUnit *DW_Unit, DIE *Entity, DIType Ty) {
|
||||
// Construct type.
|
||||
DIE Buffer(dwarf::DW_TAG_base_type);
|
||||
if (Ty.isBasicType(Ty.getTag()))
|
||||
ConstructTypeDIE(DW_Unit, Buffer, DIBasicType(Ty.getGV()));
|
||||
else if (Ty.isDerivedType(Ty.getTag()))
|
||||
ConstructTypeDIE(DW_Unit, Buffer, DIDerivedType(Ty.getGV()));
|
||||
ConstructTypeDIE(DW_Unit, Buffer, DIBasicType(Ty.getNode()));
|
||||
else if (Ty.isCompositeType(Ty.getTag()))
|
||||
ConstructTypeDIE(DW_Unit, Buffer, DICompositeType(Ty.getNode()));
|
||||
else {
|
||||
assert(Ty.isCompositeType(Ty.getTag()) && "Unknown kind of DIType");
|
||||
ConstructTypeDIE(DW_Unit, Buffer, DICompositeType(Ty.getGV()));
|
||||
assert(Ty.isDerivedType(Ty.getTag()) && "Unknown kind of DIType");
|
||||
ConstructTypeDIE(DW_Unit, Buffer, DIDerivedType(Ty.getNode()));
|
||||
|
||||
}
|
||||
|
||||
// Add debug information entry to entity and appropriate context.
|
||||
DIE *Die = NULL;
|
||||
DIDescriptor Context = Ty.getContext();
|
||||
if (!Context.isNull())
|
||||
Die = DW_Unit->getDieMapSlotFor(Context.getGV());
|
||||
Die = DW_Unit->getDieMapSlotFor(Context.getNode());
|
||||
|
||||
if (Die) {
|
||||
DIE *Child = new DIE(Buffer);
|
||||
@ -642,7 +646,7 @@ void DwarfDebug::ConstructTypeDIE(CompileUnit *DW_Unit, DIE &Buffer,
|
||||
// Add enumerators to enumeration type.
|
||||
for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
|
||||
DIE *ElemDie = NULL;
|
||||
DIEnumerator Enum(Elements.getElement(i).getGV());
|
||||
DIEnumerator Enum(Elements.getElement(i).getNode());
|
||||
ElemDie = ConstructEnumTypeDIE(DW_Unit, &Enum);
|
||||
Buffer.AddChild(ElemDie);
|
||||
}
|
||||
@ -652,7 +656,7 @@ void DwarfDebug::ConstructTypeDIE(CompileUnit *DW_Unit, DIE &Buffer,
|
||||
// Add return type.
|
||||
DIArray Elements = CTy.getTypeArray();
|
||||
DIDescriptor RTy = Elements.getElement(0);
|
||||
AddType(DW_Unit, &Buffer, DIType(RTy.getGV()));
|
||||
AddType(DW_Unit, &Buffer, DIType(RTy.getNode()));
|
||||
|
||||
// Add prototype flag.
|
||||
AddUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
|
||||
@ -661,7 +665,7 @@ void DwarfDebug::ConstructTypeDIE(CompileUnit *DW_Unit, DIE &Buffer,
|
||||
for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
|
||||
DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
|
||||
DIDescriptor Ty = Elements.getElement(i);
|
||||
AddType(DW_Unit, Arg, DIType(Ty.getGV()));
|
||||
AddType(DW_Unit, Arg, DIType(Ty.getNode()));
|
||||
Buffer.AddChild(Arg);
|
||||
}
|
||||
}
|
||||
@ -679,13 +683,15 @@ void DwarfDebug::ConstructTypeDIE(CompileUnit *DW_Unit, DIE &Buffer,
|
||||
// Add elements to structure type.
|
||||
for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
|
||||
DIDescriptor Element = Elements.getElement(i);
|
||||
if (Element.isNull())
|
||||
continue;
|
||||
DIE *ElemDie = NULL;
|
||||
if (Element.getTag() == dwarf::DW_TAG_subprogram)
|
||||
ElemDie = CreateSubprogramDIE(DW_Unit,
|
||||
DISubprogram(Element.getGV()));
|
||||
DISubprogram(Element.getNode()));
|
||||
else
|
||||
ElemDie = CreateMemberDIE(DW_Unit,
|
||||
DIDerivedType(Element.getGV()));
|
||||
DIDerivedType(Element.getNode()));
|
||||
Buffer.AddChild(ElemDie);
|
||||
}
|
||||
|
||||
@ -765,7 +771,7 @@ void DwarfDebug::ConstructArrayTypeDIE(CompileUnit *DW_Unit, DIE &Buffer,
|
||||
for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
|
||||
DIDescriptor Element = Elements.getElement(i);
|
||||
if (Element.getTag() == dwarf::DW_TAG_subrange_type)
|
||||
ConstructSubrangeDIE(Buffer, DISubrange(Element.getGV()), IndexTy);
|
||||
ConstructSubrangeDIE(Buffer, DISubrange(Element.getNode()), IndexTy);
|
||||
}
|
||||
}
|
||||
|
||||
@ -892,7 +898,7 @@ DIE *DwarfDebug::CreateSubprogramDIE(CompileUnit *DW_Unit,
|
||||
if (Args.isNull() || SPTag != dwarf::DW_TAG_subroutine_type)
|
||||
AddType(DW_Unit, SPDie, SPTy);
|
||||
else
|
||||
AddType(DW_Unit, SPDie, DIType(Args.getElement(0).getGV()));
|
||||
AddType(DW_Unit, SPDie, DIType(Args.getElement(0).getNode()));
|
||||
}
|
||||
|
||||
if (!SP.isDefinition()) {
|
||||
@ -903,7 +909,7 @@ DIE *DwarfDebug::CreateSubprogramDIE(CompileUnit *DW_Unit,
|
||||
if (SPTag == dwarf::DW_TAG_subroutine_type)
|
||||
for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
|
||||
DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
|
||||
AddType(DW_Unit, Arg, DIType(Args.getElement(i).getGV()));
|
||||
AddType(DW_Unit, Arg, DIType(Args.getElement(i).getNode()));
|
||||
AddUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1); // ??
|
||||
SPDie->AddChild(Arg);
|
||||
}
|
||||
@ -913,7 +919,7 @@ DIE *DwarfDebug::CreateSubprogramDIE(CompileUnit *DW_Unit,
|
||||
AddUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
|
||||
|
||||
// DW_TAG_inlined_subroutine may refer to this DIE.
|
||||
DIE *&Slot = DW_Unit->getDieMapSlotFor(SP.getGV());
|
||||
DIE *&Slot = DW_Unit->getDieMapSlotFor(SP.getNode());
|
||||
Slot = SPDie;
|
||||
return SPDie;
|
||||
}
|
||||
@ -922,7 +928,7 @@ DIE *DwarfDebug::CreateSubprogramDIE(CompileUnit *DW_Unit,
|
||||
///
|
||||
CompileUnit &DwarfDebug::FindCompileUnit(DICompileUnit Unit) const {
|
||||
DenseMap<Value *, CompileUnit *>::const_iterator I =
|
||||
CompileUnitMap.find(Unit.getGV());
|
||||
CompileUnitMap.find(Unit.getNode());
|
||||
assert(I != CompileUnitMap.end() && "Missing compile unit.");
|
||||
return *I->second;
|
||||
}
|
||||
@ -975,26 +981,26 @@ DIE *DwarfDebug::CreateDbgScopeVariable(DbgVariable *DV, CompileUnit *Unit) {
|
||||
|
||||
/// getOrCreateScope - Returns the scope associated with the given descriptor.
|
||||
///
|
||||
DbgScope *DwarfDebug::getOrCreateScope(GlobalVariable *V) {
|
||||
DbgScope *&Slot = DbgScopeMap[V];
|
||||
DbgScope *DwarfDebug::getOrCreateScope(MDNode *N) {
|
||||
DbgScope *&Slot = DbgScopeMap[N];
|
||||
if (Slot) return Slot;
|
||||
|
||||
DbgScope *Parent = NULL;
|
||||
DIBlock Block(V);
|
||||
DIBlock Block(N);
|
||||
|
||||
// Don't create a new scope if we already created one for an inlined function.
|
||||
DenseMap<const GlobalVariable *, DbgScope *>::iterator
|
||||
II = AbstractInstanceRootMap.find(V);
|
||||
DenseMap<const MDNode *, DbgScope *>::iterator
|
||||
II = AbstractInstanceRootMap.find(N);
|
||||
if (II != AbstractInstanceRootMap.end())
|
||||
return LexicalScopeStack.back();
|
||||
|
||||
if (!Block.isNull()) {
|
||||
DIDescriptor ParentDesc = Block.getContext();
|
||||
Parent =
|
||||
ParentDesc.isNull() ? NULL : getOrCreateScope(ParentDesc.getGV());
|
||||
ParentDesc.isNull() ? NULL : getOrCreateScope(ParentDesc.getNode());
|
||||
}
|
||||
|
||||
Slot = new DbgScope(Parent, DIDescriptor(V));
|
||||
Slot = new DbgScope(Parent, DIDescriptor(N));
|
||||
|
||||
if (Parent)
|
||||
Parent->AddScope(Slot);
|
||||
@ -1103,10 +1109,10 @@ void DwarfDebug::ConstructFunctionDbgScope(DbgScope *RootScope,
|
||||
return;
|
||||
|
||||
// Get the subprogram debug information entry.
|
||||
DISubprogram SPD(Desc.getGV());
|
||||
DISubprogram SPD(Desc.getNode());
|
||||
|
||||
// Get the subprogram die.
|
||||
DIE *SPDie = ModuleCU->getDieMapSlotFor(SPD.getGV());
|
||||
DIE *SPDie = ModuleCU->getDieMapSlotFor(SPD.getNode());
|
||||
assert(SPDie && "Missing subprogram descriptor");
|
||||
|
||||
if (!AbstractScope) {
|
||||
@ -1179,8 +1185,8 @@ unsigned DwarfDebug::GetOrCreateSourceID(const std::string &DirName,
|
||||
return SrcId;
|
||||
}
|
||||
|
||||
void DwarfDebug::ConstructCompileUnit(GlobalVariable *GV) {
|
||||
DICompileUnit DIUnit(GV);
|
||||
void DwarfDebug::ConstructCompileUnit(MDNode *N) {
|
||||
DICompileUnit DIUnit(N);
|
||||
std::string Dir, FN, Prod;
|
||||
unsigned ID = GetOrCreateSourceID(DIUnit.getDirectory(Dir),
|
||||
DIUnit.getFilename(FN));
|
||||
@ -1217,15 +1223,15 @@ void DwarfDebug::ConstructCompileUnit(GlobalVariable *GV) {
|
||||
ModuleCU = Unit;
|
||||
}
|
||||
|
||||
CompileUnitMap[DIUnit.getGV()] = Unit;
|
||||
CompileUnitMap[DIUnit.getNode()] = Unit;
|
||||
CompileUnits.push_back(Unit);
|
||||
}
|
||||
|
||||
void DwarfDebug::ConstructGlobalVariableDIE(GlobalVariable *GV) {
|
||||
DIGlobalVariable DI_GV(GV);
|
||||
void DwarfDebug::ConstructGlobalVariableDIE(MDNode *N) {
|
||||
DIGlobalVariable DI_GV(N);
|
||||
|
||||
// Check for pre-existence.
|
||||
DIE *&Slot = ModuleCU->getDieMapSlotFor(DI_GV.getGV());
|
||||
DIE *&Slot = ModuleCU->getDieMapSlotFor(DI_GV.getNode());
|
||||
if (Slot)
|
||||
return;
|
||||
|
||||
@ -1251,11 +1257,11 @@ void DwarfDebug::ConstructGlobalVariableDIE(GlobalVariable *GV) {
|
||||
return;
|
||||
}
|
||||
|
||||
void DwarfDebug::ConstructSubprogram(GlobalVariable *GV) {
|
||||
DISubprogram SP(GV);
|
||||
void DwarfDebug::ConstructSubprogram(MDNode *N) {
|
||||
DISubprogram SP(N);
|
||||
|
||||
// Check for pre-existence.
|
||||
DIE *&Slot = ModuleCU->getDieMapSlotFor(GV);
|
||||
DIE *&Slot = ModuleCU->getDieMapSlotFor(N);
|
||||
if (Slot)
|
||||
return;
|
||||
|
||||
@ -1538,6 +1544,9 @@ unsigned DwarfDebug::RecordSourceLine(Value *V, unsigned Line, unsigned Col) {
|
||||
/// correspondence to the source line list.
|
||||
unsigned DwarfDebug::RecordSourceLine(unsigned Line, unsigned Col,
|
||||
DICompileUnit CU) {
|
||||
if (!MMI)
|
||||
return 0;
|
||||
|
||||
if (TimePassesIsEnabled)
|
||||
DebugTimer->startTimer();
|
||||
|
||||
@ -1572,11 +1581,11 @@ unsigned DwarfDebug::getOrCreateSourceID(const std::string &DirName,
|
||||
}
|
||||
|
||||
/// RecordRegionStart - Indicate the start of a region.
|
||||
unsigned DwarfDebug::RecordRegionStart(GlobalVariable *V) {
|
||||
unsigned DwarfDebug::RecordRegionStart(MDNode *N) {
|
||||
if (TimePassesIsEnabled)
|
||||
DebugTimer->startTimer();
|
||||
|
||||
DbgScope *Scope = getOrCreateScope(V);
|
||||
DbgScope *Scope = getOrCreateScope(N);
|
||||
unsigned ID = MMI->NextLabelID();
|
||||
if (!Scope->getStartLabelID()) Scope->setStartLabelID(ID);
|
||||
LexicalScopeStack.push_back(Scope);
|
||||
@ -1588,11 +1597,11 @@ unsigned DwarfDebug::RecordRegionStart(GlobalVariable *V) {
|
||||
}
|
||||
|
||||
/// RecordRegionEnd - Indicate the end of a region.
|
||||
unsigned DwarfDebug::RecordRegionEnd(GlobalVariable *V) {
|
||||
unsigned DwarfDebug::RecordRegionEnd(MDNode *N) {
|
||||
if (TimePassesIsEnabled)
|
||||
DebugTimer->startTimer();
|
||||
|
||||
DbgScope *Scope = getOrCreateScope(V);
|
||||
DbgScope *Scope = getOrCreateScope(N);
|
||||
unsigned ID = MMI->NextLabelID();
|
||||
Scope->setEndLabelID(ID);
|
||||
// FIXME : region.end() may not be in the last basic block.
|
||||
@ -1609,41 +1618,36 @@ unsigned DwarfDebug::RecordRegionEnd(GlobalVariable *V) {
|
||||
}
|
||||
|
||||
/// RecordVariable - Indicate the declaration of a local variable.
|
||||
void DwarfDebug::RecordVariable(GlobalVariable *GV, unsigned FrameIndex) {
|
||||
void DwarfDebug::RecordVariable(MDNode *N, unsigned FrameIndex) {
|
||||
if (TimePassesIsEnabled)
|
||||
DebugTimer->startTimer();
|
||||
|
||||
DIDescriptor Desc(GV);
|
||||
DIDescriptor Desc(N);
|
||||
DbgScope *Scope = NULL;
|
||||
bool InlinedFnVar = false;
|
||||
|
||||
if (Desc.getTag() == dwarf::DW_TAG_variable) {
|
||||
// GV is a global variable.
|
||||
DIGlobalVariable DG(GV);
|
||||
Scope = getOrCreateScope(DG.getContext().getGV());
|
||||
} else {
|
||||
if (Desc.getTag() == dwarf::DW_TAG_variable)
|
||||
Scope = getOrCreateScope(DIGlobalVariable(N).getContext().getNode());
|
||||
else {
|
||||
bool InlinedVar = false;
|
||||
DIVariable DV(GV);
|
||||
GlobalVariable *V = DV.getContext().getGV();
|
||||
DISubprogram SP(V);
|
||||
MDNode *Context = DIVariable(N).getContext().getNode();
|
||||
DISubprogram SP(Context);
|
||||
if (!SP.isNull()) {
|
||||
// SP is inserted into DbgAbstractScopeMap when inlined function
|
||||
// start was recorded by RecordInlineFnStart.
|
||||
DenseMap<GlobalVariable *, DbgScope *>::iterator
|
||||
I = DbgAbstractScopeMap.find(SP.getGV());
|
||||
DenseMap<MDNode *, DbgScope *>::iterator
|
||||
I = DbgAbstractScopeMap.find(SP.getNode());
|
||||
if (I != DbgAbstractScopeMap.end()) {
|
||||
InlinedVar = true;
|
||||
Scope = I->second;
|
||||
}
|
||||
}
|
||||
if (!InlinedVar) {
|
||||
// GV is a local variable.
|
||||
Scope = getOrCreateScope(V);
|
||||
}
|
||||
if (!InlinedVar)
|
||||
Scope = getOrCreateScope(Context);
|
||||
}
|
||||
|
||||
assert(Scope && "Unable to find the variable's scope");
|
||||
DbgVariable *DV = new DbgVariable(DIVariable(GV), FrameIndex, InlinedFnVar);
|
||||
DbgVariable *DV = new DbgVariable(DIVariable(N), FrameIndex, InlinedFnVar);
|
||||
Scope->AddVariable(DV);
|
||||
|
||||
if (TimePassesIsEnabled)
|
||||
@ -1661,17 +1665,17 @@ unsigned DwarfDebug::RecordInlinedFnStart(DISubprogram &SP, DICompileUnit CU,
|
||||
if (TimePassesIsEnabled)
|
||||
DebugTimer->startTimer();
|
||||
|
||||
GlobalVariable *GV = SP.getGV();
|
||||
DenseMap<const GlobalVariable *, DbgScope *>::iterator
|
||||
II = AbstractInstanceRootMap.find(GV);
|
||||
MDNode *Node = SP.getNode();
|
||||
DenseMap<const MDNode *, DbgScope *>::iterator
|
||||
II = AbstractInstanceRootMap.find(Node);
|
||||
|
||||
if (II == AbstractInstanceRootMap.end()) {
|
||||
// Create an abstract instance entry for this inlined function if it doesn't
|
||||
// already exist.
|
||||
DbgScope *Scope = new DbgScope(NULL, DIDescriptor(GV));
|
||||
DbgScope *Scope = new DbgScope(NULL, DIDescriptor(Node));
|
||||
|
||||
// Get the compile unit context.
|
||||
DIE *SPDie = ModuleCU->getDieMapSlotFor(GV);
|
||||
DIE *SPDie = ModuleCU->getDieMapSlotFor(Node);
|
||||
if (!SPDie)
|
||||
SPDie = CreateSubprogramDIE(ModuleCU, SP, false, true);
|
||||
|
||||
@ -1683,18 +1687,18 @@ unsigned DwarfDebug::RecordInlinedFnStart(DISubprogram &SP, DICompileUnit CU,
|
||||
AddUInt(SPDie, dwarf::DW_AT_inline, 0, dwarf::DW_INL_declared_not_inlined);
|
||||
|
||||
// Keep track of the abstract scope for this function.
|
||||
DbgAbstractScopeMap[GV] = Scope;
|
||||
DbgAbstractScopeMap[Node] = Scope;
|
||||
|
||||
AbstractInstanceRootMap[GV] = Scope;
|
||||
AbstractInstanceRootMap[Node] = Scope;
|
||||
AbstractInstanceRootList.push_back(Scope);
|
||||
}
|
||||
|
||||
// Create a concrete inlined instance for this inlined function.
|
||||
DbgConcreteScope *ConcreteScope = new DbgConcreteScope(DIDescriptor(GV));
|
||||
DbgConcreteScope *ConcreteScope = new DbgConcreteScope(DIDescriptor(Node));
|
||||
DIE *ScopeDie = new DIE(dwarf::DW_TAG_inlined_subroutine);
|
||||
ScopeDie->setAbstractCompileUnit(ModuleCU);
|
||||
|
||||
DIE *Origin = ModuleCU->getDieMapSlotFor(GV);
|
||||
DIE *Origin = ModuleCU->getDieMapSlotFor(Node);
|
||||
AddDIEEntry(ScopeDie, dwarf::DW_AT_abstract_origin,
|
||||
dwarf::DW_FORM_ref4, Origin);
|
||||
AddUInt(ScopeDie, dwarf::DW_AT_call_file, 0, ModuleCU->getID());
|
||||
@ -1708,20 +1712,20 @@ unsigned DwarfDebug::RecordInlinedFnStart(DISubprogram &SP, DICompileUnit CU,
|
||||
LexicalScopeStack.back()->AddConcreteInst(ConcreteScope);
|
||||
|
||||
// Keep track of the concrete scope that's inlined into this function.
|
||||
DenseMap<GlobalVariable *, SmallVector<DbgScope *, 8> >::iterator
|
||||
SI = DbgConcreteScopeMap.find(GV);
|
||||
DenseMap<MDNode *, SmallVector<DbgScope *, 8> >::iterator
|
||||
SI = DbgConcreteScopeMap.find(Node);
|
||||
|
||||
if (SI == DbgConcreteScopeMap.end())
|
||||
DbgConcreteScopeMap[GV].push_back(ConcreteScope);
|
||||
DbgConcreteScopeMap[Node].push_back(ConcreteScope);
|
||||
else
|
||||
SI->second.push_back(ConcreteScope);
|
||||
|
||||
// Track the start label for this inlined function.
|
||||
DenseMap<GlobalVariable *, SmallVector<unsigned, 4> >::iterator
|
||||
I = InlineInfo.find(GV);
|
||||
DenseMap<MDNode *, SmallVector<unsigned, 4> >::iterator
|
||||
I = InlineInfo.find(Node);
|
||||
|
||||
if (I == InlineInfo.end())
|
||||
InlineInfo[GV].push_back(LabelID);
|
||||
InlineInfo[Node].push_back(LabelID);
|
||||
else
|
||||
I->second.push_back(LabelID);
|
||||
|
||||
@ -1739,9 +1743,9 @@ unsigned DwarfDebug::RecordInlinedFnEnd(DISubprogram &SP) {
|
||||
if (TimePassesIsEnabled)
|
||||
DebugTimer->startTimer();
|
||||
|
||||
GlobalVariable *GV = SP.getGV();
|
||||
DenseMap<GlobalVariable *, SmallVector<DbgScope *, 8> >::iterator
|
||||
I = DbgConcreteScopeMap.find(GV);
|
||||
MDNode *Node = SP.getNode();
|
||||
DenseMap<MDNode *, SmallVector<DbgScope *, 8> >::iterator
|
||||
I = DbgConcreteScopeMap.find(Node);
|
||||
|
||||
if (I == DbgConcreteScopeMap.end()) {
|
||||
// FIXME: Can this situation actually happen? And if so, should it?
|
||||
@ -2446,11 +2450,11 @@ void DwarfDebug::EmitDebugInlineInfo() {
|
||||
Asm->EmitInt16(dwarf::DWARF_VERSION); Asm->EOL("Dwarf Version");
|
||||
Asm->EmitInt8(TD->getPointerSize()); Asm->EOL("Address Size (in bytes)");
|
||||
|
||||
for (DenseMap<GlobalVariable *, SmallVector<unsigned, 4> >::iterator
|
||||
for (DenseMap<MDNode *, SmallVector<unsigned, 4> >::iterator
|
||||
I = InlineInfo.begin(), E = InlineInfo.end(); I != E; ++I) {
|
||||
GlobalVariable *GV = I->first;
|
||||
MDNode *Node = I->first;
|
||||
SmallVector<unsigned, 4> &Labels = I->second;
|
||||
DISubprogram SP(GV);
|
||||
DISubprogram SP(Node);
|
||||
std::string Name;
|
||||
std::string LName;
|
||||
|
||||
@ -2476,7 +2480,7 @@ void DwarfDebug::EmitDebugInlineInfo() {
|
||||
|
||||
for (SmallVector<unsigned, 4>::iterator LI = Labels.begin(),
|
||||
LE = Labels.end(); LI != LE; ++LI) {
|
||||
DIE *SP = ModuleCU->getDieMapSlotFor(GV);
|
||||
DIE *SP = ModuleCU->getDieMapSlotFor(Node);
|
||||
Asm->EmitInt32(SP->getOffset()); Asm->EOL("DIE offset");
|
||||
|
||||
if (TD->getPointerSize() == sizeof(int32_t))
|
||||
|
||||
Reference in New Issue
Block a user