// 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"
#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;
/// 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.
///
/// 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.
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;
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) {
// 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);
// 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);
}
// 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);
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);
}
}
// 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);
}
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);
}
}
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()) {
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);
}
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;
}
///
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;
}
/// 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);
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) {
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));
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;
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;
/// correspondence to the source line list.
unsigned DwarfDebug::RecordSourceLine(unsigned Line, unsigned Col,
DICompileUnit CU) {
+ if (!MMI)
+ return 0;
+
if (TimePassesIsEnabled)
DebugTimer->startTimer();
}
/// 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);
}
/// 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.
}
/// 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)
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);
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());
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);
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?
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;
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))
projects / oota-llvm.git / blobdiff