1 //===-- llvm/CodeGen/DebugLocEntry.h - Entry in debug_loc list -*- C++ -*--===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #ifndef CODEGEN_ASMPRINTER_DEBUGLOCENTRY_H__ 11 #define CODEGEN_ASMPRINTER_DEBUGLOCENTRY_H__ 12 #include "llvm/IR/Constants.h" 13 #include "llvm/MC/MachineLocation.h" 14 #include "llvm/MC/MCSymbol.h" 15 16 namespace llvm { 17 class DwarfCompileUnit; 18 class MDNode; 19 /// \brief This struct describes location entries emitted in the .debug_loc 20 /// section. 21 class DebugLocEntry { 22 // Begin and end symbols for the address range that this location is valid. 23 const MCSymbol *Begin; 24 const MCSymbol *End; 25 26 public: 27 /// A single location or constant. 28 struct Value { ValueValue29 Value(const MDNode *Var, int64_t i) 30 : Variable(Var), EntryKind(E_Integer) { 31 Constant.Int = i; 32 } ValueValue33 Value(const MDNode *Var, const ConstantFP *CFP) 34 : Variable(Var), EntryKind(E_ConstantFP) { 35 Constant.CFP = CFP; 36 } ValueValue37 Value(const MDNode *Var, const ConstantInt *CIP) 38 : Variable(Var), EntryKind(E_ConstantInt) { 39 Constant.CIP = CIP; 40 } ValueValue41 Value(const MDNode *Var, MachineLocation Loc) 42 : Variable(Var), EntryKind(E_Location), Loc(Loc) { 43 } 44 45 // The variable to which this location entry corresponds. 46 const MDNode *Variable; 47 48 // Type of entry that this represents. 49 enum EntryType { E_Location, E_Integer, E_ConstantFP, E_ConstantInt }; 50 enum EntryType EntryKind; 51 52 // Either a constant, 53 union { 54 int64_t Int; 55 const ConstantFP *CFP; 56 const ConstantInt *CIP; 57 } Constant; 58 59 // Or a location in the machine frame. 60 MachineLocation Loc; 61 62 bool operator==(const Value &other) const { 63 if (EntryKind != other.EntryKind) 64 return false; 65 66 switch (EntryKind) { 67 case E_Location: 68 return Loc == other.Loc; 69 case E_Integer: 70 return Constant.Int == other.Constant.Int; 71 case E_ConstantFP: 72 return Constant.CFP == other.Constant.CFP; 73 case E_ConstantInt: 74 return Constant.CIP == other.Constant.CIP; 75 } 76 llvm_unreachable("unhandled EntryKind"); 77 } 78 isLocationValue79 bool isLocation() const { return EntryKind == E_Location; } isIntValue80 bool isInt() const { return EntryKind == E_Integer; } isConstantFPValue81 bool isConstantFP() const { return EntryKind == E_ConstantFP; } isConstantIntValue82 bool isConstantInt() const { return EntryKind == E_ConstantInt; } getIntValue83 int64_t getInt() const { return Constant.Int; } getConstantFPValue84 const ConstantFP *getConstantFP() const { return Constant.CFP; } getConstantIntValue85 const ConstantInt *getConstantInt() const { return Constant.CIP; } getLocValue86 MachineLocation getLoc() const { return Loc; } getVariableValue87 const MDNode *getVariable() const { return Variable; } 88 }; 89 private: 90 /// A list of locations/constants belonging to this entry. 91 SmallVector<Value, 1> Values; 92 93 /// The compile unit that this location entry is referenced by. 94 const DwarfCompileUnit *Unit; 95 96 public: DebugLocEntry()97 DebugLocEntry() : Begin(nullptr), End(nullptr), Unit(nullptr) {} DebugLocEntry(const MCSymbol * B,const MCSymbol * E,Value Val,const DwarfCompileUnit * U)98 DebugLocEntry(const MCSymbol *B, const MCSymbol *E, 99 Value Val, const DwarfCompileUnit *U) 100 : Begin(B), End(E), Unit(U) { 101 Values.push_back(std::move(Val)); 102 } 103 104 /// \brief Attempt to merge this DebugLocEntry with Next and return 105 /// true if the merge was successful. Entries can be merged if they 106 /// share the same Loc/Constant and if Next immediately follows this 107 /// Entry. Merge(const DebugLocEntry & Next)108 bool Merge(const DebugLocEntry &Next) { 109 if ((End == Next.Begin && Values == Next.Values)) { 110 End = Next.End; 111 return true; 112 } 113 return false; 114 } getBeginSym()115 const MCSymbol *getBeginSym() const { return Begin; } getEndSym()116 const MCSymbol *getEndSym() const { return End; } getCU()117 const DwarfCompileUnit *getCU() const { return Unit; } getValues()118 const ArrayRef<Value> getValues() const { return Values; } addValue(Value Val)119 void addValue(Value Val) { Values.push_back(Val); } 120 }; 121 122 } 123 #endif 124