6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-01-01 00:33:09 +00:00
Code Issues Projects Releases Wiki Activity

Debug Info: Prepare DebugLocEntry to handle more than a single value per

Browse Source 
entry. This is in preparation for generic DW_OP_piece support.
No functional change so far.

http://reviews.llvm.org/D3373
rdar://problem/15928306

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@207368 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Adrian Prantl 2014-04-27 18:25:40 +00:00
parent 14a1490eb8
commit eccd574af8
2 changed files with 92 additions and 96 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

150
lib/CodeGen/AsmPrinter/DebugLocEntry.h
View File

@ -23,75 +23,82 @@ class DebugLocEntry {
const MCSymbol *Begin;
const MCSymbol *End;
// Type of entry that this represents.
enum EntryType { E_Location, E_Integer, E_ConstantFP, E_ConstantInt };
enum EntryType EntryKind;
union {
int64_t Int;
const ConstantFP *CFP;
const ConstantInt *CIP;
} Constants;
// The location in the machine frame.
MachineLocation Loc;
// The variable to which this location entry corresponds.
const MDNode *Variable;
// The compile unit to which this location entry is referenced by.
const DwarfCompileUnit *Unit;
bool hasSameValueOrLocation(const DebugLocEntry &Next) {
if (EntryKind != Next.EntryKind)
return false;
bool EqualValues;
switch (EntryKind) {
case E_Location:
EqualValues = Loc == Next.Loc;
break;
case E_Integer:
EqualValues = Constants.Int == Next.Constants.Int;
break;
case E_ConstantFP:
EqualValues = Constants.CFP == Next.Constants.CFP;
break;
case E_ConstantInt:
EqualValues = Constants.CIP == Next.Constants.CIP;
break;
public:
/// A single location or constant.
struct Value {
Value(const MDNode *Var, int64_t i)
: Variable(Var), EntryKind(E_Integer) {
Constant.Int = i;
}
Value(const MDNode *Var, const ConstantFP *CFP)
: Variable(Var), EntryKind(E_ConstantFP) {
Constant.CFP = CFP;
}
Value(const MDNode *Var, const ConstantInt *CIP)
: Variable(Var), EntryKind(E_ConstantInt) {
Constant.CIP = CIP;
}
Value(const MDNode *Var, MachineLocation Loc)
: Variable(Var), EntryKind(E_Location), Loc(Loc) {
}
return EqualValues;
}
// The variable to which this location entry corresponds.
const MDNode *Variable;
// Type of entry that this represents.
enum EntryType { E_Location, E_Integer, E_ConstantFP, E_ConstantInt };
enum EntryType EntryKind;
// Either a constant,
union {
int64_t Int;
const ConstantFP *CFP;
const ConstantInt *CIP;
} Constant;
// Or a location in the machine frame.
MachineLocation Loc;
bool operator==(const Value &other) const {
if (EntryKind != other.EntryKind)
return false;
switch (EntryKind) {
case E_Location:
return Loc == other.Loc;
case E_Integer:
return Constant.Int == other.Constant.Int;
case E_ConstantFP:
return Constant.CFP == other.Constant.CFP;
case E_ConstantInt:
return Constant.CIP == other.Constant.CIP;
}
llvm_unreachable("unhandled EntryKind");
}
bool isLocation() const { return EntryKind == E_Location; }
bool isInt() const { return EntryKind == E_Integer; }
bool isConstantFP() const { return EntryKind == E_ConstantFP; }
bool isConstantInt() const { return EntryKind == E_ConstantInt; }
int64_t getInt() const { return Constant.Int; }
const ConstantFP *getConstantFP() const { return Constant.CFP; }
const ConstantInt *getConstantInt() const { return Constant.CIP; }
MachineLocation getLoc() const { return Loc; }
const MDNode *getVariable() const { return Variable; }
};
private:
/// A list of locations/constants belonging to this entry.
SmallVector<Value, 1> Values;
/// The compile unit that this location entry is referenced by.
const DwarfCompileUnit *Unit;
public:
DebugLocEntry() : Begin(0), End(0), Variable(0), Unit(0) {
Constants.Int = 0;
}
DebugLocEntry(const MCSymbol *B, const MCSymbol *E, MachineLocation &L,
const MDNode *V, const DwarfCompileUnit *U)
: Begin(B), End(E), Loc(L), Variable(V), Unit(U) {
Constants.Int = 0;
EntryKind = E_Location;
}
DebugLocEntry(const MCSymbol *B, const MCSymbol *E, int64_t i,
const MDNode *V, const DwarfCompileUnit *U)
: Begin(B), End(E), Variable(V), Unit(U) {
Constants.Int = i;
EntryKind = E_Integer;
}
DebugLocEntry(const MCSymbol *B, const MCSymbol *E, const ConstantFP *FPtr,
const MDNode *V, const DwarfCompileUnit *U)
: Begin(B), End(E), Variable(V), Unit(U) {
Constants.CFP = FPtr;
EntryKind = E_ConstantFP;
}
DebugLocEntry(const MCSymbol *B, const MCSymbol *E, const ConstantInt *IPtr,
const MDNode *V, const DwarfCompileUnit *U)
: Begin(B), End(E), Variable(V), Unit(U) {
Constants.CIP = IPtr;
EntryKind = E_ConstantInt;
DebugLocEntry() : Begin(0), End(0), Unit(0) {}
DebugLocEntry(const MCSymbol *B, const MCSymbol *E,
Value Val, const DwarfCompileUnit *U)
: Begin(B), End(E), Unit(U) {
Values.push_back(std::move(Val));
}
/// \brief Attempt to merge this DebugLocEntry with Next and return
@ -99,24 +106,17 @@ public:
/// share the same Loc/Constant and if Next immediately follows this
/// Entry.
bool Merge(const DebugLocEntry &Next) {
if (End == Next.Begin && hasSameValueOrLocation(Next)) {
if ((End == Next.Begin && Values == Next.Values)) {
End = Next.End;
return true;
}
return false;
}
bool isLocation() const { return EntryKind == E_Location; }
bool isInt() const { return EntryKind == E_Integer; }
bool isConstantFP() const { return EntryKind == E_ConstantFP; }
bool isConstantInt() const { return EntryKind == E_ConstantInt; }
int64_t getInt() const { return Constants.Int; }
const ConstantFP *getConstantFP() const { return Constants.CFP; }
const ConstantInt *getConstantInt() const { return Constants.CIP; }
const MDNode *getVariable() const { return Variable; }
const MCSymbol *getBeginSym() const { return Begin; }
const MCSymbol *getEndSym() const { return End; }
const DwarfCompileUnit *getCU() const { return Unit; }
MachineLocation getLoc() const { return Loc; }
const ArrayRef<Value> getValues() const { return Values; }
void addValue(Value Val) { Values.push_back(Val); }
};
}

38
lib/CodeGen/AsmPrinter/DwarfDebug.cpp
View File

@ -1132,11 +1132,7 @@ static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
}
// Get .debug_loc entry for the instruction range starting at MI.
static DebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
const MCSymbol *FLabel,
const MCSymbol *SLabel,
const MachineInstr *MI,
DwarfCompileUnit *Unit) {
static DebugLocEntry::Value getDebugLocValue(const MachineInstr *MI) {
const MDNode *Var = MI->getDebugVariable();
assert(MI->getNumOperands() == 3);
@ -1148,16 +1144,14 @@ static DebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
MLoc.set(MI->getOperand(0).getReg());
else
MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
return DebugLocEntry(FLabel, SLabel, MLoc, Var, Unit);
return DebugLocEntry::Value(Var, MLoc);
}
if (MI->getOperand(0).isImm())
return DebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm(), Var, Unit);
return DebugLocEntry::Value(Var, MI->getOperand(0).getImm());
if (MI->getOperand(0).isFPImm())
return DebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm(),
Var, Unit);
return DebugLocEntry::Value(Var, MI->getOperand(0).getFPImm());
if (MI->getOperand(0).isCImm())
return DebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm(),
Var, Unit);
return DebugLocEntry::Value(Var, MI->getOperand(0).getCImm());
llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
}
@ -1165,6 +1159,8 @@ static DebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
// Find variables for each lexical scope.
void
DwarfDebug::collectVariableInfo(SmallPtrSet<const MDNode *, 16> &Processed) {
LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
// Grab the variable info that was squirreled away in the MMI side-table.
collectVariableInfoFromMMITable(Processed);
@ -1252,16 +1248,13 @@ DwarfDebug::collectVariableInfo(SmallPtrSet<const MDNode *, 16> &Processed) {
}
// The value is valid until the next DBG_VALUE or clobber.
LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
DebugLocEntry Loc = getDebugLocEntry(Asm, FLabel, SLabel, Begin, TheCU);
DebugLocEntry Loc(FLabel, SLabel, getDebugLocValue(Begin), TheCU);
if (DebugLoc.empty() || !DebugLoc.back().Merge(Loc))
DebugLoc.push_back(std::move(Loc));
}
}
// Collect info for variables that were optimized out.
LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
DIVariable DV(Variables.getElement(i));
@ -2057,19 +2050,22 @@ void DwarfDebug::emitDebugStr() {
void DwarfDebug::emitDebugLocEntry(ByteStreamer &Streamer,
const DebugLocEntry &Entry) {
DIVariable DV(Entry.getVariable());
if (Entry.isInt()) {
assert(Entry.getValues().size() == 1 &&
"multi-value entries are not supported yet.");
const DebugLocEntry::Value Value = Entry.getValues()[0];
DIVariable DV(Value.getVariable());
if (Value.isInt()) {
DIBasicType BTy(resolve(DV.getType()));
if (BTy.Verify() && (BTy.getEncoding() == dwarf::DW_ATE_signed ||
BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
Streamer.EmitInt8(dwarf::DW_OP_consts, "DW_OP_consts");
Streamer.EmitSLEB128(Entry.getInt());
Streamer.EmitSLEB128(Value.getInt());
} else {
Streamer.EmitInt8(dwarf::DW_OP_constu, "DW_OP_constu");
Streamer.EmitULEB128(Entry.getInt());
Streamer.EmitULEB128(Value.getInt());
}
} else if (Entry.isLocation()) {
MachineLocation Loc = Entry.getLoc();
} else if (Value.isLocation()) {
MachineLocation Loc = Value.getLoc();
if (!DV.hasComplexAddress())
// Regular entry.
Asm->EmitDwarfRegOp(Streamer, Loc, DV.isIndirect());