class Type;
class Value;
class DbgDeclareInst;
- class DebugLoc;
- struct DebugLocTracker;
class Instruction;
class MDNode;
class LLVMContext;
std::string &Type, unsigned &LineNo, std::string &File,
std::string &Dir);
- /// ExtractDebugLocation - Extract debug location information
- /// from DILocation.
- DebugLoc ExtractDebugLocation(DILocation &Loc,
- DebugLocTracker &DebugLocInfo);
-
/// getDISubprogram - Find subprogram that is enclosing this scope.
DISubprogram getDISubprogram(MDNode *Scope);
namespace llvm {
-class DILocation;
class Value;
class Function;
class MachineRegisterInfo;
// of a function.
DebugLoc DefaultDebugLoc;
- // Tracks debug locations.
- DebugLocTracker DebugLocInfo;
-
/// FunctionNumber - This provides a unique ID for each function emitted in
/// this translation unit.
///
// Debug location.
//
- /// getDILocation - Get the DILocation for a given DebugLoc object.
- DILocation getDILocation(DebugLoc DL) const;
-
/// getDefaultDebugLoc - Get the default debug location for the machine
/// function.
DebugLoc getDefaultDebugLoc() const { return DefaultDebugLoc; }
/// setDefaultDebugLoc - Get the default debug location for the machine
/// function.
void setDefaultDebugLoc(DebugLoc DL) { DefaultDebugLoc = DL; }
-
- /// getDebugLocInfo - Get the debug info location tracker.
- DebugLocTracker &getDebugLocInfo() { return DebugLocInfo; }
};
//===--------------------------------------------------------------------===//
#include "llvm/CodeGen/MachineLocation.h"
#include "llvm/MC/MCContext.h"
#include "llvm/Support/Dwarf.h"
+#include "llvm/Support/DebugLoc.h"
#include "llvm/Support/ValueHandle.h"
#include "llvm/System/DataTypes.h"
#include "llvm/ADT/DenseMap.h"
public:
static char ID; // Pass identification, replacement for typeid
- typedef std::pair<unsigned, TrackingVH<MDNode> > UnsignedAndMDNodePair;
- typedef SmallVector< std::pair<TrackingVH<MDNode>, UnsignedAndMDNodePair>, 4>
+ typedef std::pair<unsigned, DebugLoc> UnsignedDebugLocPair;
+ typedef SmallVector<std::pair<TrackingVH<MDNode>, UnsignedDebugLocPair>, 4>
VariableDbgInfoMapTy;
VariableDbgInfoMapTy VariableDbgInfo;
/// of one is required to emit exception handling info.
Function *getPersonality() const;
- /// setVariableDbgInfo - Collect information used to emit debugging information
- /// of a variable.
- void setVariableDbgInfo(MDNode *N, unsigned Slot, MDNode *Scope) {
- VariableDbgInfo.push_back(std::make_pair(N, std::make_pair(Slot, Scope)));
+ /// setVariableDbgInfo - Collect information used to emit debugging
+ /// information of a variable.
+ void setVariableDbgInfo(MDNode *N, unsigned Slot, DebugLoc Loc) {
+ VariableDbgInfo.push_back(std::make_pair(N, std::make_pair(Slot, Loc)));
}
VariableDbgInfoMapTy &getVariableDbgInfo() { return VariableDbgInfo; }
return LineCol == DL.LineCol && ScopeIdx == DL.ScopeIdx;
}
bool operator!=(const NewDebugLoc &DL) const { return !(*this == DL); }
+
+
+
+
+ static NewDebugLoc getUnknownLoc() { NewDebugLoc L; return L; }
};
+ typedef NewDebugLoc DebugLoc;
- /// DebugLoc - Debug location id. This is carried by SDNode and MachineInstr
- /// to index into a vector of unique debug location tuples.
- class DebugLoc {
- unsigned Idx;
- public:
- DebugLoc() : Idx(~0U) {} // Defaults to invalid.
-
- static DebugLoc getUnknownLoc() { DebugLoc L; L.Idx = ~0U; return L; }
- static DebugLoc get(unsigned idx) { DebugLoc L; L.Idx = idx; return L; }
-
- unsigned getIndex() const { return Idx; }
-
- /// isUnknown - Return true if there is no debug info for the SDNode /
- /// MachineInstr.
- bool isUnknown() const { return Idx == ~0U; }
-
- bool operator==(const DebugLoc &DL) const { return Idx == DL.Idx; }
- bool operator!=(const DebugLoc &DL) const { return !(*this == DL); }
- };
-
- /// DebugLocTracker - This class tracks debug location information.
- ///
- struct DebugLocTracker {
- /// DebugLocations - A vector of unique DebugLocTuple's.
- ///
- std::vector<MDNode *> DebugLocations;
-
- /// DebugIdMap - This maps DebugLocTuple's to indices into the
- /// DebugLocations vector.
- DenseMap<MDNode *, unsigned> DebugIdMap;
-
- DebugLocTracker() {}
- };
-
} // end namespace llvm
#endif /* LLVM_DEBUGLOC_H */
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/Dwarf.h"
-#include "llvm/Support/DebugLoc.h"
#include "llvm/Support/raw_ostream.h"
using namespace llvm;
using namespace llvm::dwarf;
return true;
}
-/// ExtractDebugLocation - Extract debug location information
-/// from DILocation.
-DebugLoc llvm::ExtractDebugLocation(DILocation &Loc,
- DebugLocTracker &DebugLocInfo) {
- DenseMap<MDNode *, unsigned>::iterator II
- = DebugLocInfo.DebugIdMap.find(Loc.getNode());
- if (II != DebugLocInfo.DebugIdMap.end())
- return DebugLoc::get(II->second);
-
- // Add a new location entry.
- unsigned Id = DebugLocInfo.DebugLocations.size();
- DebugLocInfo.DebugLocations.push_back(Loc.getNode());
- DebugLocInfo.DebugIdMap[Loc.getNode()] = Id;
-
- return DebugLoc::get(Id);
-}
-
/// getDISubprogram - Find subprogram that is enclosing this scope.
DISubprogram llvm::getDISubprogram(MDNode *Scope) {
DIDescriptor D(Scope);
const MachineFunction *MF = MI.getParent()->getParent();
const TargetMachine &TM = MF->getTarget();
- if (!MI.getDebugLoc().isUnknown()) {
- DILocation DLT = MF->getDILocation(MI.getDebugLoc());
-
- // Print source line info.
- DIScope Scope = DLT.getScope();
+ DebugLoc DL = MI.getDebugLoc();
+ if (!DL.isUnknown()) { // Print source line info.
+ DIScope Scope(DL.getScope(MF->getFunction()->getContext()));
// Omit the directory, because it's likely to be long and uninteresting.
if (Scope.Verify())
CommentOS << Scope.getFilename();
else
CommentOS << "<unknown>";
- CommentOS << ':' << DLT.getLineNumber();
- if (DLT.getColumnNumber() != 0)
- CommentOS << ':' << DLT.getColumnNumber();
+ CommentOS << ':' << DL.getLine();
+ if (DL.getCol() != 0)
+ CommentOS << ':' << DL.getCol();
CommentOS << '\n';
}
: DwarfPrinter(OS, A, T), ModuleCU(0),
AbbreviationsSet(InitAbbreviationsSetSize), Abbreviations(),
DIEBlocks(), SectionSourceLines(), didInitial(false), shouldEmit(false),
- CurrentFnDbgScope(0), PrevDILoc(0), DebugTimer(0) {
+ CurrentFnDbgScope(0), DebugTimer(0) {
NextStringPoolNumber = 0;
if (TimePassesIsEnabled)
DebugTimer = new Timer("Dwarf Debug Writer");
/// findAbstractVariable - Find abstract variable, if any, associated with Var.
DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
unsigned FrameIdx,
- DILocation &ScopeLoc) {
+ DebugLoc ScopeLoc) {
DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
if (AbsDbgVariable)
return AbsDbgVariable;
- DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope().getNode());
+ LLVMContext &Ctx = Var.getNode()->getContext();
+ DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
if (!Scope)
return NULL;
/// FIXME : Refactor findAbstractVariable.
DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &Var,
const MachineInstr *MI,
- DILocation &ScopeLoc) {
+ DebugLoc ScopeLoc) {
DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var.getNode());
if (AbsDbgVariable)
return AbsDbgVariable;
- DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope().getNode());
+ LLVMContext &Ctx = Var.getNode()->getContext();
+ DbgScope *Scope = AbstractScopes.lookup(ScopeLoc.getScope(Ctx));
if (!Scope)
return NULL;
void DwarfDebug::collectVariableInfo() {
if (!MMI) return;
+ const LLVMContext &Ctx = MF->getFunction()->getContext();
+
MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
VE = VMap.end(); VI != VE; ++VI) {
MDNode *Var = VI->first;
if (!Var) continue;
- DIVariable DV (Var);
- std::pair< unsigned, MDNode *> VP = VI->second;
- DILocation ScopeLoc(VP.second);
-
- DbgScope *Scope =
- ConcreteScopes.lookup(ScopeLoc.getOrigLocation().getNode());
- if (!Scope)
- Scope = DbgScopeMap.lookup(ScopeLoc.getScope().getNode());
+ DIVariable DV(Var);
+ const std::pair<unsigned, DebugLoc> &VP = VI->second;
+
+ DbgScope *Scope = 0;
+ if (MDNode *IA = VP.second.getInlinedAt(Ctx))
+ Scope = ConcreteScopes.lookup(IA);
+ if (Scope == 0)
+ Scope = DbgScopeMap.lookup(VP.second.getScope(Ctx));
+
// If variable scope is not found then skip this variable.
- if (!Scope)
+ if (Scope == 0)
continue;
- DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.first, ScopeLoc);
+ DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.first, VP.second);
DbgVariable *RegVar = new DbgVariable(DV, VP.first, AbsDbgVariable);
Scope->addVariable(RegVar);
}
DebugLoc DL = MInsn->getDebugLoc();
if (DL.isUnknown()) continue;
- DILocation ScopeLoc = MF->getDILocation(DL);
- DbgScope *Scope =
- ConcreteScopes.lookup(ScopeLoc.getOrigLocation().getNode());
- if (!Scope)
- Scope = DbgScopeMap.lookup(ScopeLoc.getScope().getNode());
+ DbgScope *Scope = 0;
+ if (MDNode *IA = DL.getInlinedAt(Ctx))
+ Scope = ConcreteScopes.lookup(IA);
+ if (Scope == 0)
+ Scope = DbgScopeMap.lookup(DL.getScope(Ctx));
+
// If variable scope is not found then skip this variable.
- if (!Scope)
+ if (Scope == 0)
continue;
- DbgVariable *AbsDbgVariable = findAbstractVariable(DV, MInsn, ScopeLoc);
+ DbgVariable *AbsDbgVariable = findAbstractVariable(DV, MInsn, DL);
DbgVariable *RegVar = new DbgVariable(DV, MInsn, AbsDbgVariable);
DbgValueStartMap[MInsn] = RegVar;
Scope->addVariable(RegVar);
DebugLoc DL = MI->getDebugLoc();
if (DL.isUnknown())
return;
- DILocation DILoc = MF->getDILocation(DL);
- if (!DILoc.getScope().Verify())
- return;
// Check and update last known location info.
- if(DILoc.getNode() == PrevDILoc)
+ if (DL == PrevInstLoc)
+ return;
+
+ MDNode *Scope = DL.getScope(MF->getFunction()->getContext());
+
+ // FIXME: Should only verify each scope once!
+ if (!DIScope(Scope).Verify())
return;
// DBG_VALUE instruction establishes new value.
DenseMap<const MachineInstr *, DbgVariable *>::iterator DI
= DbgValueStartMap.find(MI);
if (DI != DbgValueStartMap.end()) {
- MCSymbol *Label = recordSourceLine(DILoc.getLineNumber(),
- DILoc.getColumnNumber(),
- DILoc.getScope().getNode());
- PrevDILoc = DILoc.getNode();
+ MCSymbol *Label = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
+ PrevInstLoc = DL;
DI->second->setDbgValueLabel(Label);
}
return;
// Emit a label to indicate location change. This is used for line
// table even if this instruction does start a new scope.
- MCSymbol *Label = recordSourceLine(DILoc.getLineNumber(),
- DILoc.getColumnNumber(),
- DILoc.getScope().getNode());
- PrevDILoc = DILoc.getNode();
+ MCSymbol *Label = recordSourceLine(DL.getLine(), DL.getCol(), Scope);
+ PrevInstLoc = DL;
// update DbgScope if this instruction starts a new scope.
InsnToDbgScopeMapTy::iterator I = DbgScopeBeginMap.find(MI);
DebugLoc DL = MI->getDebugLoc();
if (DL.isUnknown())
return;
- DILocation DILoc = MF->getDILocation(DL);
- if (!DILoc.getScope().Verify())
- return;
-
+
// Emit a label and update DbgScope if this instruction ends a scope.
InsnToDbgScopeMapTy::iterator I = DbgScopeEndMap.find(MI);
if (I == DbgScopeEndMap.end())
return;
-
+
MCSymbol *Label = MMI->getContext().CreateTempSymbol();
Asm->OutStreamer.EmitLabel(Label);
/// createDbgScope - Create DbgScope for the scope.
void DwarfDebug::createDbgScope(MDNode *Scope, MDNode *InlinedAt) {
-
if (!InlinedAt) {
DbgScope *WScope = DbgScopeMap.lookup(Scope);
if (WScope)
DenseMap<const MachineInstr *, unsigned> MIIndexMap;
unsigned MIIndex = 0;
+ LLVMContext &Ctx = MF->getFunction()->getContext();
+
// Scan each instruction and create scopes. First build working set of scopes.
for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
I != E; ++I) {
// FIXME : Remove DBG_VALUE check.
if (MInsn->isDebugValue()) continue;
MIIndexMap[MInsn] = MIIndex++;
+
DebugLoc DL = MInsn->getDebugLoc();
if (DL.isUnknown()) continue;
- DILocation DLT = MF->getDILocation(DL);
- DIScope DLTScope = DLT.getScope();
- if (!DLTScope.getNode()) continue;
+
+ MDNode *Scope = DL.getScope(Ctx);
+
// There is no need to create another DIE for compile unit. For all
// other scopes, create one DbgScope now. This will be translated
// into a scope DIE at the end.
- if (DLTScope.isCompileUnit()) continue;
- createDbgScope(DLTScope.getNode(), DLT.getOrigLocation().getNode());
+ if (DIScope(Scope).isCompileUnit()) continue;
+ createDbgScope(Scope, DL.getInlinedAt(Ctx));
}
}
// FIXME : Remove DBG_VALUE check.
if (MInsn->isDebugValue()) continue;
DebugLoc DL = MInsn->getDebugLoc();
- if (DL.isUnknown()) continue;
- DILocation DLT = MF->getDILocation(DL);
- DIScope DLTScope = DLT.getScope();
- if (!DLTScope.getNode()) continue;
+ if (DL.isUnknown()) continue;
+
+ MDNode *Scope = DL.getScope(Ctx);
+ if (Scope == 0) continue;
+
// There is no need to create another DIE for compile unit. For all
// other scopes, create one DbgScope now. This will be translated
// into a scope DIE at the end.
- if (DLTScope.isCompileUnit()) continue;
- DbgScope *Scope = getUpdatedDbgScope(DLTScope.getNode(), MInsn,
- DLT.getOrigLocation().getNode());
- Scope->setLastInsn(MInsn);
+ if (DIScope(Scope).isCompileUnit()) continue;
+ DbgScope *DScope = getUpdatedDbgScope(Scope, MInsn, DL.getInlinedAt(Ctx));
+ DScope->setLastInsn(MInsn);
}
}
// Emit label for the implicitly defined dbg.stoppoint at the start of the
// function.
DebugLoc FDL = MF->getDefaultDebugLoc();
- if (!FDL.isUnknown()) {
- DILocation DLT = MF->getDILocation(FDL);
- DISubprogram SP = getDISubprogram(DLT.getScope().getNode());
- unsigned Line, Col;
- if (SP.Verify()) {
- Line = SP.getLineNumber();
- Col = 0;
- } else {
- Line = DLT.getLineNumber();
- Col = DLT.getColumnNumber();
- }
-
- recordSourceLine(Line, Col, DLT.getScope().getNode());
+ if (FDL.isUnknown()) return;
+
+ MDNode *Scope = FDL.getScope(MF->getFunction()->getContext());
+
+ DISubprogram SP = getDISubprogram(Scope);
+ unsigned Line, Col;
+ if (SP.Verify()) {
+ Line = SP.getLineNumber();
+ Col = 0;
+ } else {
+ Line = FDL.getLine();
+ Col = FDL.getCol();
}
+
+ recordSourceLine(Line, Col, Scope);
}
/// endFunction - Gather and emit post-function debug information.
/// Previous instruction's location information. This is used to determine
/// label location to indicate scope boundries in dwarf debug info.
- mutable const MDNode *PrevDILoc;
+ DebugLoc PrevInstLoc;
/// DebugTimer - Timer for the Dwarf debug writer.
Timer *DebugTimer;
/// getUpdatedDbgScope - Find or create DbgScope assicated with
/// the instruction. Initialize scope and update scope hierarchy.
- DbgScope *getUpdatedDbgScope(MDNode *N, const MachineInstr *MI, MDNode *InlinedAt);
+ DbgScope *getUpdatedDbgScope(MDNode *N, const MachineInstr *MI,
+ MDNode *InlinedAt);
/// createDbgScope - Create DbgScope for the scope.
void createDbgScope(MDNode *Scope, MDNode *InlinedAt);
/// findAbstractVariable - Find abstract variable associated with Var.
DbgVariable *findAbstractVariable(DIVariable &Var, unsigned FrameIdx,
- DILocation &Loc);
+ DebugLoc Loc);
DbgVariable *findAbstractVariable(DIVariable &Var, const MachineInstr *MI,
- DILocation &Loc);
+ DebugLoc Loc);
/// updateSubprogramScopeDIE - Find DIE for the given subprogram and
/// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
return VReg;
}
-/// getDILocation - Get the DILocation for a given DebugLoc object.
-DILocation MachineFunction::getDILocation(DebugLoc DL) const {
- unsigned Idx = DL.getIndex();
- assert(Idx < DebugLocInfo.DebugLocations.size() &&
- "Invalid index into debug locations!");
- return DILocation(DebugLocInfo.DebugLocations[Idx]);
-}
-
-
/// getJTISymbol - Return the MCSymbol for the specified non-empty jump table.
/// If isLinkerPrivate is specified, an 'l' label is returned, otherwise a
/// normal 'L' label is returned.
// TODO: print InlinedAtLoc information
- DILocation DLT = MF->getDILocation(debugLoc);
- DIScope Scope = DLT.getScope();
+ DIScope Scope(debugLoc.getScope(MF->getFunction()->getContext()));
OS << " dbg:";
// Omit the directory, since it's usually long and uninteresting.
if (Scope.Verify())
OS << Scope.getFilename();
else
OS << "<unknown>";
- OS << ':' << DLT.getLineNumber();
- if (DLT.getColumnNumber() != 0)
- OS << ':' << DLT.getColumnNumber();
+ OS << ':' << debugLoc.getLine();
+ if (debugLoc.getCol() != 0)
+ OS << ':' << debugLoc.getCol();
}
OS << "\n";
StaticAllocaMap.find(AI);
if (SI == StaticAllocaMap.end()) break; // VLAs.
int FI = SI->second;
- if (MDNode *Dbg = DI->getDbgMetadata())
- MMI->setVariableDbgInfo(DI->getVariable(), FI, Dbg);
+ if (!DI->getDebugLoc().isUnknown())
+ MMI->setVariableDbgInfo(DI->getVariable(), FI, DI->getDebugLoc());
// Building the map above is target independent. Generating DBG_VALUE
// inline is target dependent; do this now.
int FI = SI->second;
if (MachineModuleInfo *MMI = DAG.getMachineModuleInfo())
- if (MDNode *Dbg = DI.getDbgMetadata())
- MMI->setVariableDbgInfo(Variable, FI, Dbg);
+ if (!DI.getDebugLoc().isUnknown())
+ MMI->setVariableDbgInfo(Variable, FI, DI.getDebugLoc());
return 0;
}
case Intrinsic::dbg_value: {
if (SI == FuncInfo.StaticAllocaMap.end())
return 0; // VLAs.
int FI = SI->second;
+
if (MachineModuleInfo *MMI = DAG.getMachineModuleInfo())
- if (MDNode *Dbg = DI.getDbgMetadata())
- MMI->setVariableDbgInfo(Variable, FI, Dbg);
+ if (!DI.getDebugLoc().isUnknown())
+ MMI->setVariableDbgInfo(Variable, FI, DI.getDebugLoc());
return 0;
}
case Intrinsic::eh_exception: {
/// attached with this instruction.
static void SetDebugLoc(Instruction *I, SelectionDAGBuilder *SDB,
FastISel *FastIS, MachineFunction *MF) {
- MDNode *Dbg = I->getDbgMetadata();
- if (Dbg == 0) return;
+ DebugLoc DL = I->getDebugLoc();
+ if (DL.isUnknown()) return;
- DILocation DILoc(Dbg);
- DebugLoc Loc = ExtractDebugLocation(DILoc, MF->getDebugLocInfo());
-
- SDB->setCurDebugLoc(Loc);
+ SDB->setCurDebugLoc(DL);
if (FastIS)
- FastIS->setCurDebugLoc(Loc);
+ FastIS->setCurDebugLoc(DL);
// If the function doesn't have a default debug location yet, set
// it. This is kind of a hack.
if (MF->getDefaultDebugLoc().isUnknown())
- MF->setDefaultDebugLoc(Loc);
+ MF->setDefaultDebugLoc(DL);
}
/// ResetDebugLoc - Set MF's and SDB's DebugLocs to Unknown.
}
void JITEmitter::processDebugLoc(DebugLoc DL, bool BeforePrintingInsn) {
- if (!DL.isUnknown()) {
- DILocation CurDLT = EmissionDetails.MF->getDILocation(DL);
-
- if (BeforePrintingInsn) {
- if (CurDLT.getScope().getNode() != 0
- && PrevDLT.getNode() != CurDLT.getNode()) {
- JITEvent_EmittedFunctionDetails::LineStart NextLine;
- NextLine.Address = getCurrentPCValue();
- NextLine.Loc = DL;
- EmissionDetails.LineStarts.push_back(NextLine);
- }
+ if (DL.isUnknown()) return;
+ if (!BeforePrintingInsn) return;
- PrevDLT = CurDLT;
- }
+ // FIXME: This is horribly inefficient.
+ DILocation CurDLT(DL.getAsMDNode(CurFn->getContext()));
+
+ if (CurDLT.getScope().getNode() != 0 && PrevDLT.getNode() !=CurDLT.getNode()){
+ JITEvent_EmittedFunctionDetails::LineStart NextLine;
+ NextLine.Address = getCurrentPCValue();
+ NextLine.Loc = DL;
+ EmissionDetails.LineStarts.push_back(NextLine);
}
+
+ PrevDLT = CurDLT;
}
static unsigned GetConstantPoolSizeInBytes(MachineConstantPool *MCP,
///
void PIC16DbgInfo::ChangeDebugLoc(const MachineFunction &MF,
const DebugLoc &DL, bool IsInBeginFunction) {
- if (! EmitDebugDirectives) return;
- assert (! DL.isUnknown() && "can't change to invalid debug loc");
-
- DILocation Loc = MF.getDILocation(DL);
- MDNode *CU = Loc.getScope().getNode();
- unsigned line = Loc.getLineNumber();
+ if (!EmitDebugDirectives) return;
+ assert(!DL.isUnknown() && "can't change to invalid debug loc");
- SwitchToCU(CU);
- SwitchToLine(line, IsInBeginFunction);
+ SwitchToCU(DL.getScope(MF.getFunction()->getContext()));
+ SwitchToLine(DL.getLine(), IsInBeginFunction);
}
/// SwitchToLine - Emit line directive for a new line.
namespace llvm {
class MachineFunction;
- class DebugLoc;
+ class NewDebugLoc; typedef NewDebugLoc DebugLoc;
namespace PIC16Dbg {
enum VarType {
T_NULL,
projects / oota-llvm.git / commitdiff