replica
/
hanchenye-llvm-project
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Introduce DebugScope which gets embedded into the machine instructions' DebugLoc. 

DebugScope refers to a debug region, function or block.

llvm-svn: 72191
This commit is contained in:
Argyrios Kyrtzidis 2009-05-20 22:57:17 +00:00
parent 920e3af495
commit 2b59a5fc6c
9 changed files with 201 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

73
llvm/include/llvm/CodeGen/DebugLoc.h
View File

@ -20,18 +20,77 @@
namespace llvm {
class GlobalVariable;
class MachineFunction;
/// DebugLocTuple - Debug location tuple of filename id, line and column.
/// DebugScope - Debug scope id. This is carried into DebugLocTuple to index
/// into a vector of DebugScopeInfos. Provides the ability to associate a
/// SDNode/MachineInstr with the debug scope that it belongs to.
///
class DebugScope {
unsigned Idx;
public:
DebugScope() : Idx(~0U) {} // Defaults to null.
static DebugScope getInvalid() { DebugScope S; S.Idx = ~0U; return S; }
static DebugScope get(unsigned idx) { DebugScope S; S.Idx = idx; return S; }
unsigned getIndex() const { return Idx; }
/// isInvalid - Return true if it doesn't refer to any scope.
bool isInvalid() const { return Idx == ~0U; }
bool operator==(const DebugScope &DS) const { return Idx == DS.Idx; }
bool operator!=(const DebugScope &DS) const { return !(*this == DS); }
};
/// DebugScopeInfo - Contains info about the scope global variable and the
/// parent debug scope. DebugScope is only a "cookie" that can point to a
/// specific DebugScopeInfo.
///
struct DebugScopeInfo {
GlobalVariable *GV;
DebugScope Parent;
DebugScopeInfo(GlobalVariable *gv, DebugScope parent)
: GV(gv), Parent(parent) {}
DebugScopeInfo()
: GV(0), Parent(DebugScope::getInvalid()) {}
};
/// DebugScopeTracker - Create and keep track of the debug scope while
/// entering/exiting subprograms and blocks. Used by the instruction
/// selectors.
///
class DebugScopeTracker {
DebugScope CurScope;
public:
/// getCurScope - The current debug scope that we "entered" through
/// EnterDebugScope.
DebugScope getCurScope() const { return CurScope; }
/// EnterDebugScope - Start a new debug scope. ScopeGV can be a DISubprogram
/// or a DIBlock.
void EnterDebugScope(GlobalVariable *ScopeGV, MachineFunction &MF);
/// ExitDebugScope - "Pop" a DISubprogram or a DIBlock.
void ExitDebugScope(GlobalVariable *ScopeGV, MachineFunction &MF);
};
/// DebugLocTuple - Debug location tuple of a DICompileUnit global variable,
/// debug scope, line and column.
///
struct DebugLocTuple {
GlobalVariable *CompileUnit;
DebugScope Scope;
unsigned Line, Col;
DebugLocTuple(GlobalVariable *v, unsigned l, unsigned c)
: CompileUnit(v), Line(l), Col(c) {};
DebugLocTuple(GlobalVariable *v, DebugScope s, unsigned l, unsigned c)
: CompileUnit(v), Scope(s), Line(l), Col(c) {};
bool operator==(const DebugLocTuple &DLT) const {
return CompileUnit == DLT.CompileUnit &&
return CompileUnit == DLT.CompileUnit && Scope == DLT.Scope &&
Line == DLT.Line && Col == DLT.Col;
}
bool operator!=(const DebugLocTuple &DLT) const {
@ -63,18 +122,20 @@ namespace llvm {
// Partially specialize DenseMapInfo for DebugLocTyple.
template<> struct DenseMapInfo<DebugLocTuple> {
static inline DebugLocTuple getEmptyKey() {
return DebugLocTuple(0, ~0U, ~0U);
return DebugLocTuple(0, DebugScope::getInvalid(), ~0U, ~0U);
}
static inline DebugLocTuple getTombstoneKey() {
return DebugLocTuple((GlobalVariable*)~1U, ~1U, ~1U);
return DebugLocTuple((GlobalVariable*)~1U,DebugScope::get(~1U), ~1U, ~1U);
}
static unsigned getHashValue(const DebugLocTuple &Val) {
return DenseMapInfo<GlobalVariable*>::getHashValue(Val.CompileUnit) ^
DenseMapInfo<unsigned>::getHashValue(Val.Scope.getIndex()) ^
DenseMapInfo<unsigned>::getHashValue(Val.Line) ^
DenseMapInfo<unsigned>::getHashValue(Val.Col);
}
static bool isEqual(const DebugLocTuple &LHS, const DebugLocTuple &RHS) {
return LHS.CompileUnit == RHS.CompileUnit &&
LHS.Scope == RHS.Scope &&
LHS.Line == RHS.Line &&
LHS.Col == RHS.Col;
}

1
llvm/include/llvm/CodeGen/FastISel.h
View File

@ -57,6 +57,7 @@ protected:
MachineFrameInfo &MFI;
MachineConstantPool &MCP;
DebugLoc DL;
DebugScopeTracker DbgScopeTrack;
const TargetMachine &TM;
const TargetData &TD;
const TargetInstrInfo &TII;

10
llvm/include/llvm/CodeGen/MachineFunction.h
View File

@ -111,6 +111,8 @@ class MachineFunction : private Annotation {
// Tracks debug locations.
DebugLocTracker DebugLocInfo;
std::vector<DebugScopeInfo> DbgScopeInfos;
public:
MachineFunction(const Function *Fn, const TargetMachine &TM);
~MachineFunction();
@ -332,7 +334,7 @@ public:
/// getOrCreateDebugLocID - Look up the DebugLocTuple index with the given
/// source file, line, and column. If none currently exists, create a new
/// DebugLocTuple, and insert it into the DebugIdMap.
unsigned getOrCreateDebugLocID(GlobalVariable *CompileUnit,
unsigned getOrCreateDebugLocID(GlobalVariable *CompileUnit, DebugScope Scope,
unsigned Line, unsigned Col);
/// getDebugLocTuple - Get the DebugLocTuple for a given DebugLoc object.
@ -345,6 +347,12 @@ public:
/// setDefaultDebugLoc - Get the default debug location for the machine
/// function.
void setDefaultDebugLoc(DebugLoc DL) { DefaultDebugLoc = DL; }
/// CreateDebugScope - Create a new debug scope.
DebugScope CreateDebugScope(GlobalVariable *ScopeGV, DebugScope Parent);
/// getDebugScopeInfo - Get the DebugScopeInfo for a given DebugScope object.
const DebugScopeInfo &getDebugScopeInfo(DebugScope DS) const;
};
//===--------------------------------------------------------------------===//

2
llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp
View File

@ -1311,7 +1311,7 @@ void AsmPrinter::PrintSpecial(const MachineInstr *MI, const char *Code) const {
void AsmPrinter::processDebugLoc(DebugLoc DL) {
if (TAI->doesSupportDebugInformation() && DW->ShouldEmitDwarfDebug()) {
if (!DL.isUnknown()) {
static DebugLocTuple PrevDLT(0, ~0U, ~0U);
static DebugLocTuple PrevDLT(0, DebugScope::getInvalid(), ~0U, ~0U);
DebugLocTuple CurDLT = MF->getDebugLocTuple(DL);
if (CurDLT.CompileUnit != 0 && PrevDLT != CurDLT)

38
llvm/lib/CodeGen/DebugLoc.cpp Normal file
View File

@ -0,0 +1,38 @@
//===-- DebugLoc.cpp ------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// Implementation for DebugScopeTracker.
//
//===----------------------------------------------------------------------===//
#include "llvm/CodeGen/DebugLoc.h"
#include "llvm/CodeGen/MachineFunction.h"
using namespace llvm;
/// EnterDebugScope - Start a new debug scope. ScopeGV can be a DISubprogram
/// or a DIBlock.
void DebugScopeTracker::EnterDebugScope(GlobalVariable *ScopeGV,
MachineFunction &MF) {
assert(ScopeGV && "GlobalVariable for scope is null!");
CurScope = MF.CreateDebugScope(ScopeGV, CurScope);
}
/// ExitDebugScope - "Pop" a DISubprogram or a DIBlock.
void DebugScopeTracker::ExitDebugScope(GlobalVariable *ScopeGV,
MachineFunction &MF) {
assert(ScopeGV && "GlobalVariable for scope is null!");
assert(!CurScope.isInvalid() && "Mismatched region.end ?");
// We may have skipped a region.end because it was in an unreachable block.
// Go up the scope chain until we reach the scope that ScopeGV points to.
DebugScopeInfo DSI;
do {
DSI = MF.getDebugScopeInfo(CurScope);
CurScope = DSI.Parent;
} while (!DSI.Parent.isInvalid() && DSI.GV != ScopeGV);
}

18
llvm/lib/CodeGen/MachineFunction.cpp
View File

@ -403,8 +403,9 @@ unsigned MachineFunction::addLiveIn(unsigned PReg,
/// source file, line, and column. If none currently exists, create a new
/// DebugLocTuple, and insert it into the DebugIdMap.
unsigned MachineFunction::getOrCreateDebugLocID(GlobalVariable *CompileUnit,
DebugScope Scope,
unsigned Line, unsigned Col) {
DebugLocTuple Tuple(CompileUnit, Line, Col);
DebugLocTuple Tuple(CompileUnit, Scope, Line, Col);
DenseMap<DebugLocTuple, unsigned>::iterator II
= DebugLocInfo.DebugIdMap.find(Tuple);
if (II != DebugLocInfo.DebugIdMap.end())
@ -424,6 +425,21 @@ DebugLocTuple MachineFunction::getDebugLocTuple(DebugLoc DL) const {
return DebugLocInfo.DebugLocations[Idx];
}
/// CreateDebugScope - Create a new debug scope.
DebugScope MachineFunction::CreateDebugScope(GlobalVariable *ScopeGV,
DebugScope Parent) {
DbgScopeInfos.push_back(DebugScopeInfo(ScopeGV, Parent));
return DebugScope::get(DbgScopeInfos.size() - 1);
}
/// getDebugScopeInfo - Get the DebugScopeInfo for a given DebugScope object.
const DebugScopeInfo &MachineFunction::getDebugScopeInfo(DebugScope DS) const {
unsigned Idx = DS.getIndex();
assert(Idx < DbgScopeInfos.size() && "Invalid index into debug scopes!");
return DbgScopeInfos[Idx];
}
//===----------------------------------------------------------------------===//
// MachineFrameInfo implementation
//===----------------------------------------------------------------------===//

38
llvm/lib/CodeGen/SelectionDAG/FastISel.cpp
View File

@ -331,17 +331,22 @@ bool FastISel::SelectCall(User *I) {
DICompileUnit CU(cast<GlobalVariable>(SPI->getContext()));
unsigned Line = SPI->getLine();
unsigned Col = SPI->getColumn();
unsigned Idx = MF.getOrCreateDebugLocID(CU.getGV(), Line, Col);
unsigned Idx = MF.getOrCreateDebugLocID(CU.getGV(),
DbgScopeTrack.getCurScope(),
Line, Col);
setCurDebugLoc(DebugLoc::get(Idx));
}
return true;
}
case Intrinsic::dbg_region_start: {
DbgRegionStartInst *RSI = cast<DbgRegionStartInst>(I);
if (DIDescriptor::ValidDebugInfo(RSI->getContext(), CodeGenOpt::None) &&
DW && DW->ShouldEmitDwarfDebug()) {
unsigned ID =
DW->RecordRegionStart(cast<GlobalVariable>(RSI->getContext()));
if (!DIDescriptor::ValidDebugInfo(RSI->getContext(), CodeGenOpt::None))
return true;
GlobalVariable *Rgn = cast<GlobalVariable>(RSI->getContext());
DbgScopeTrack.EnterDebugScope(Rgn, MF);
if (DW && DW->ShouldEmitDwarfDebug()) {
unsigned ID = DW->RecordRegionStart(Rgn);
const TargetInstrDesc &II = TII.get(TargetInstrInfo::DBG_LABEL);
BuildMI(MBB, DL, II).addImm(ID);
}
@ -349,10 +354,14 @@ bool FastISel::SelectCall(User *I) {
}
case Intrinsic::dbg_region_end: {
DbgRegionEndInst *REI = cast<DbgRegionEndInst>(I);
if (DIDescriptor::ValidDebugInfo(REI->getContext(), CodeGenOpt::None) &&
DW && DW->ShouldEmitDwarfDebug()) {
if (!DIDescriptor::ValidDebugInfo(REI->getContext(), CodeGenOpt::None))
return true;
GlobalVariable *Rgn = cast<GlobalVariable>(REI->getContext());
DbgScopeTrack.ExitDebugScope(Rgn, MF);
if (DW && DW->ShouldEmitDwarfDebug()) {
unsigned ID = 0;
DISubprogram Subprogram(cast<GlobalVariable>(REI->getContext()));
DISubprogram Subprogram(Rgn);
if (!Subprogram.isNull() && !Subprogram.describes(MF.getFunction())) {
// This is end of an inlined function.
const TargetInstrDesc &II = TII.get(TargetInstrInfo::DBG_LABEL);
@ -382,6 +391,7 @@ bool FastISel::SelectCall(User *I) {
DebugLoc PrevLoc = DL;
DISubprogram Subprogram(cast<GlobalVariable>(SP));
DICompileUnit CompileUnit = Subprogram.getCompileUnit();
DbgScopeTrack.EnterDebugScope(Subprogram.getGV(), MF);
if (!Subprogram.describes(MF.getFunction())) {
// This is a beginning of an inlined function.
@ -393,8 +403,10 @@ bool FastISel::SelectCall(User *I) {
return true;
// Record the source line.
unsigned Line = Subprogram.getLineNumber();
setCurDebugLoc(DebugLoc::get(MF.getOrCreateDebugLocID(
CompileUnit.getGV(), Line, 0)));
setCurDebugLoc(
DebugLoc::get(MF.getOrCreateDebugLocID(CompileUnit.getGV(),
DbgScopeTrack.getCurScope(),
Line, 0)));
if (DW && DW->ShouldEmitDwarfDebug()) {
DebugLocTuple PrevLocTpl = MF.getDebugLocTuple(PrevLoc);
@ -408,8 +420,10 @@ bool FastISel::SelectCall(User *I) {
} else {
// Record the source line.
unsigned Line = Subprogram.getLineNumber();
MF.setDefaultDebugLoc(DebugLoc::get(MF.getOrCreateDebugLocID(
CompileUnit.getGV(), Line, 0)));
MF.setDefaultDebugLoc(
DebugLoc::get(MF.getOrCreateDebugLocID(CompileUnit.getGV(),
DbgScopeTrack.getCurScope(),
Line, 0)));
if (DW && DW->ShouldEmitDwarfDebug()) {
// llvm.dbg.func_start also defines beginning of function scope.
DW->RecordRegionStart(cast<GlobalVariable>(FSI->getSubprogram()));

53
llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuild.cpp
View File

@ -312,6 +312,17 @@ void FunctionLoweringInfo::set(Function &fn, MachineFunction &mf,
!StaticAllocaMap.count(cast<AllocaInst>(I)))
InitializeRegForValue(I);
// FIXME: PHI instructions currently get an invalid scope. This is because
// tracking of debug scopes is done through a simple mechanism where
// "entering" a scope implies that the scope is entered for the first time.
// If we keep track of debug scopes for the following loop, the PHI
// instructions would get scopes that will not be used again later by the
// instruction selectors.
// Either provide a mechanism to re-enter a previously created scope or wait
// for when the DebugLoc is retrieved from Instruction, in which case the
// current debug scope tracking mechanism will be obsolete.
DebugScope DbgScope;
// Create an initial MachineBasicBlock for each LLVM BasicBlock in F. This
// also creates the initial PHI MachineInstrs, though none of the input
// operands are populated.
@ -337,6 +348,7 @@ void FunctionLoweringInfo::set(Function &fn, MachineFunction &mf,
CodeGenOpt::Default)) {
DICompileUnit CU(cast<GlobalVariable>(SPI->getContext()));
unsigned idx = MF->getOrCreateDebugLocID(CU.getGV(),
DbgScope,
SPI->getLine(),
SPI->getColumn());
DL = DebugLoc::get(idx);
@ -352,7 +364,7 @@ void FunctionLoweringInfo::set(Function &fn, MachineFunction &mf,
DISubprogram Subprogram(cast<GlobalVariable>(SP));
DICompileUnit CU(Subprogram.getCompileUnit());
unsigned Line = Subprogram.getLineNumber();
DL = DebugLoc::get(MF->getOrCreateDebugLocID(CU.getGV(),
DL = DebugLoc::get(MF->getOrCreateDebugLocID(CU.getGV(), DbgScope,
Line, 0));
}
@ -3909,7 +3921,9 @@ SelectionDAGLowering::visitIntrinsicCall(CallInst &I, unsigned Intrinsic) {
MachineFunction &MF = DAG.getMachineFunction();
DICompileUnit CU(cast<GlobalVariable>(SPI.getContext()));
DebugLoc Loc = DebugLoc::get(MF.getOrCreateDebugLocID(CU.getGV(),
SPI.getLine(), SPI.getColumn()));
DbgScopeTrack.getCurScope(),
SPI.getLine(),
SPI.getColumn()));
setCurDebugLoc(Loc);
if (OptLevel == CodeGenOpt::None)
@ -3923,11 +3937,14 @@ SelectionDAGLowering::visitIntrinsicCall(CallInst &I, unsigned Intrinsic) {
case Intrinsic::dbg_region_start: {
DwarfWriter *DW = DAG.getDwarfWriter();
DbgRegionStartInst &RSI = cast<DbgRegionStartInst>(I);
if (!DIDescriptor::ValidDebugInfo(RSI.getContext(), OptLevel))
return 0;
if (DIDescriptor::ValidDebugInfo(RSI.getContext(), OptLevel) &&
DW && DW->ShouldEmitDwarfDebug()) {
unsigned LabelID =
DW->RecordRegionStart(cast<GlobalVariable>(RSI.getContext()));
MachineFunction &MF = DAG.getMachineFunction();
GlobalVariable *Rgn = cast<GlobalVariable>(RSI.getContext());
DbgScopeTrack.EnterDebugScope(Rgn, MF);
if (DW && DW->ShouldEmitDwarfDebug()) {
unsigned LabelID = DW->RecordRegionStart(Rgn);
DAG.setRoot(DAG.getLabel(ISD::DBG_LABEL, getCurDebugLoc(),
getRoot(), LabelID));
}
@ -3937,11 +3954,14 @@ SelectionDAGLowering::visitIntrinsicCall(CallInst &I, unsigned Intrinsic) {
case Intrinsic::dbg_region_end: {
DwarfWriter *DW = DAG.getDwarfWriter();
DbgRegionEndInst &REI = cast<DbgRegionEndInst>(I);
if (!DIDescriptor::ValidDebugInfo(REI.getContext(), OptLevel))
return 0;
if (DIDescriptor::ValidDebugInfo(REI.getContext(), OptLevel) &&
DW && DW->ShouldEmitDwarfDebug()) {
MachineFunction &MF = DAG.getMachineFunction();
DISubprogram Subprogram(cast<GlobalVariable>(REI.getContext()));
MachineFunction &MF = DAG.getMachineFunction();
GlobalVariable *Rgn = cast<GlobalVariable>(REI.getContext());
DbgScopeTrack.ExitDebugScope(Rgn, MF);
if (DW && DW->ShouldEmitDwarfDebug()) {
DISubprogram Subprogram(Rgn);
if (Subprogram.isNull() || Subprogram.describes(MF.getFunction())) {
unsigned LabelID =
@ -3974,6 +3994,7 @@ SelectionDAGLowering::visitIntrinsicCall(CallInst &I, unsigned Intrinsic) {
return 0;
MachineFunction &MF = DAG.getMachineFunction();
DbgScopeTrack.EnterDebugScope(cast<GlobalVariable>(SP), MF);
if (OptLevel == CodeGenOpt::None) {
// llvm.dbg.func.start implicitly defines a dbg_stoppoint which is what
// (most?) gdb expects.
@ -3993,7 +4014,9 @@ SelectionDAGLowering::visitIntrinsicCall(CallInst &I, unsigned Intrinsic) {
// Record the source line.
unsigned Line = Subprogram.getLineNumber();
setCurDebugLoc(DebugLoc::get(
MF.getOrCreateDebugLocID(CompileUnit.getGV(), Line, 0)));
MF.getOrCreateDebugLocID(CompileUnit.getGV(),
DbgScopeTrack.getCurScope(),
Line, 0)));
if (DW && DW->ShouldEmitDwarfDebug()) {
DebugLocTuple PrevLocTpl = MF.getDebugLocTuple(PrevLoc);
@ -4008,7 +4031,9 @@ SelectionDAGLowering::visitIntrinsicCall(CallInst &I, unsigned Intrinsic) {
// Record the source line.
unsigned Line = Subprogram.getLineNumber();
MF.setDefaultDebugLoc(DebugLoc::get(
MF.getOrCreateDebugLocID(CompileUnit.getGV(), Line, 0)));
MF.getOrCreateDebugLocID(CompileUnit.getGV(),
DbgScopeTrack.getCurScope(),
Line, 0)));
if (DW && DW->ShouldEmitDwarfDebug()) {
// llvm.dbg.func_start also defines beginning of function scope.
DW->RecordRegionStart(cast<GlobalVariable>(FSI.getSubprogram()));
@ -4035,7 +4060,9 @@ SelectionDAGLowering::visitIntrinsicCall(CallInst &I, unsigned Intrinsic) {
// create a label if this is a beginning of inlined function.
unsigned Line = Subprogram.getLineNumber();
setCurDebugLoc(DebugLoc::get(
MF.getOrCreateDebugLocID(CompileUnit.getGV(), Line, 0)));
MF.getOrCreateDebugLocID(CompileUnit.getGV(),
DbgScopeTrack.getCurScope(),
Line, 0)));
// FIXME - Start new region because llvm.dbg.func_start also defines
// beginning of function scope.
}

2
llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuild.h
View File

@ -169,6 +169,8 @@ class SelectionDAGLowering {
/// CurDebugLoc - current file + line number. Changes as we build the DAG.
DebugLoc CurDebugLoc;
DebugScopeTracker DbgScopeTrack;
DenseMap<const Value*, SDValue> NodeMap;
/// PendingLoads - Loads are not emitted to the program immediately. We bunch