David Blaikie | 1275e4f | 2014-04-01 21:49:04 +0000 | [diff] [blame] | 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 | |
Benjamin Kramer | a7c40ef | 2014-08-13 16:26:38 +0000 | [diff] [blame] | 10 | #ifndef LLVM_LIB_CODEGEN_ASMPRINTER_DEBUGLOCENTRY_H |
| 11 | #define LLVM_LIB_CODEGEN_ASMPRINTER_DEBUGLOCENTRY_H |
Adrian Prantl | 92da14b | 2015-03-02 22:02:33 +0000 | [diff] [blame] | 12 | #include "llvm/ADT/SmallString.h" |
David Blaikie | 1275e4f | 2014-04-01 21:49:04 +0000 | [diff] [blame] | 13 | #include "llvm/IR/Constants.h" |
Adrian Prantl | b141683 | 2014-08-01 22:11:58 +0000 | [diff] [blame] | 14 | #include "llvm/IR/DebugInfo.h" |
David Blaikie | 1275e4f | 2014-04-01 21:49:04 +0000 | [diff] [blame] | 15 | #include "llvm/MC/MCSymbol.h" |
Chandler Carruth | d990388 | 2015-01-14 11:23:27 +0000 | [diff] [blame] | 16 | #include "llvm/MC/MachineLocation.h" |
David Blaikie | 1275e4f | 2014-04-01 21:49:04 +0000 | [diff] [blame] | 17 | |
| 18 | namespace llvm { |
Adrian Prantl | 92da14b | 2015-03-02 22:02:33 +0000 | [diff] [blame] | 19 | class AsmPrinter; |
Duncan P. N. Exon Smith | 364a300 | 2015-04-17 21:34:47 +0000 | [diff] [blame] | 20 | class DebugLocStream; |
Duncan P. N. Exon Smith | c0f7dd7 | 2015-04-17 16:36:10 +0000 | [diff] [blame] | 21 | |
David Blaikie | 1275e4f | 2014-04-01 21:49:04 +0000 | [diff] [blame] | 22 | /// \brief This struct describes location entries emitted in the .debug_loc |
| 23 | /// section. |
| 24 | class DebugLocEntry { |
Adrian Prantl | 92da14b | 2015-03-02 22:02:33 +0000 | [diff] [blame] | 25 | /// Begin and end symbols for the address range that this location is valid. |
David Blaikie | 1275e4f | 2014-04-01 21:49:04 +0000 | [diff] [blame] | 26 | const MCSymbol *Begin; |
| 27 | const MCSymbol *End; |
| 28 | |
Adrian Prantl | e19e5ef | 2014-04-27 18:25:40 +0000 | [diff] [blame] | 29 | public: |
Adrian Prantl | 92da14b | 2015-03-02 22:02:33 +0000 | [diff] [blame] | 30 | /// \brief A single location or constant. |
Adrian Prantl | e19e5ef | 2014-04-27 18:25:40 +0000 | [diff] [blame] | 31 | struct Value { |
Duncan P. N. Exon Smith | a9308c4 | 2015-04-29 16:38:44 +0000 | [diff] [blame] | 32 | Value(const DIExpression *Expr, int64_t i) |
Duncan P. N. Exon Smith | 546c8be | 2015-04-17 16:33:37 +0000 | [diff] [blame] | 33 | : Expression(Expr), EntryKind(E_Integer) { |
Adrian Prantl | e19e5ef | 2014-04-27 18:25:40 +0000 | [diff] [blame] | 34 | Constant.Int = i; |
| 35 | } |
Duncan P. N. Exon Smith | a9308c4 | 2015-04-29 16:38:44 +0000 | [diff] [blame] | 36 | Value(const DIExpression *Expr, const ConstantFP *CFP) |
Duncan P. N. Exon Smith | 546c8be | 2015-04-17 16:33:37 +0000 | [diff] [blame] | 37 | : Expression(Expr), EntryKind(E_ConstantFP) { |
Adrian Prantl | e19e5ef | 2014-04-27 18:25:40 +0000 | [diff] [blame] | 38 | Constant.CFP = CFP; |
| 39 | } |
Duncan P. N. Exon Smith | a9308c4 | 2015-04-29 16:38:44 +0000 | [diff] [blame] | 40 | Value(const DIExpression *Expr, const ConstantInt *CIP) |
Duncan P. N. Exon Smith | 546c8be | 2015-04-17 16:33:37 +0000 | [diff] [blame] | 41 | : Expression(Expr), EntryKind(E_ConstantInt) { |
Adrian Prantl | e19e5ef | 2014-04-27 18:25:40 +0000 | [diff] [blame] | 42 | Constant.CIP = CIP; |
| 43 | } |
Duncan P. N. Exon Smith | a9308c4 | 2015-04-29 16:38:44 +0000 | [diff] [blame] | 44 | Value(const DIExpression *Expr, MachineLocation Loc) |
Duncan P. N. Exon Smith | 546c8be | 2015-04-17 16:33:37 +0000 | [diff] [blame] | 45 | : Expression(Expr), EntryKind(E_Location), Loc(Loc) { |
Duncan P. N. Exon Smith | a9308c4 | 2015-04-29 16:38:44 +0000 | [diff] [blame] | 46 | assert(cast<DIExpression>(Expr)->isValid()); |
David Blaikie | d306baf | 2014-04-01 22:04:07 +0000 | [diff] [blame] | 47 | } |
| 48 | |
Adrian Prantl | 92da14b | 2015-03-02 22:02:33 +0000 | [diff] [blame] | 49 | /// Any complex address location expression for this Value. |
Duncan P. N. Exon Smith | a9308c4 | 2015-04-29 16:38:44 +0000 | [diff] [blame] | 50 | const DIExpression *Expression; |
Adrian Prantl | 87b7eb9 | 2014-10-01 18:55:02 +0000 | [diff] [blame] | 51 | |
Adrian Prantl | 92da14b | 2015-03-02 22:02:33 +0000 | [diff] [blame] | 52 | /// Type of entry that this represents. |
Adrian Prantl | e19e5ef | 2014-04-27 18:25:40 +0000 | [diff] [blame] | 53 | enum EntryType { E_Location, E_Integer, E_ConstantFP, E_ConstantInt }; |
| 54 | enum EntryType EntryKind; |
| 55 | |
Adrian Prantl | 92da14b | 2015-03-02 22:02:33 +0000 | [diff] [blame] | 56 | /// Either a constant, |
Adrian Prantl | e19e5ef | 2014-04-27 18:25:40 +0000 | [diff] [blame] | 57 | union { |
| 58 | int64_t Int; |
| 59 | const ConstantFP *CFP; |
| 60 | const ConstantInt *CIP; |
| 61 | } Constant; |
| 62 | |
| 63 | // Or a location in the machine frame. |
| 64 | MachineLocation Loc; |
| 65 | |
Adrian Prantl | e19e5ef | 2014-04-27 18:25:40 +0000 | [diff] [blame] | 66 | bool isLocation() const { return EntryKind == E_Location; } |
| 67 | bool isInt() const { return EntryKind == E_Integer; } |
| 68 | bool isConstantFP() const { return EntryKind == E_ConstantFP; } |
| 69 | bool isConstantInt() const { return EntryKind == E_ConstantInt; } |
| 70 | int64_t getInt() const { return Constant.Int; } |
| 71 | const ConstantFP *getConstantFP() const { return Constant.CFP; } |
| 72 | const ConstantInt *getConstantInt() const { return Constant.CIP; } |
| 73 | MachineLocation getLoc() const { return Loc; } |
Duncan P. N. Exon Smith | 6a0320a | 2015-04-14 01:12:42 +0000 | [diff] [blame] | 74 | bool isBitPiece() const { return getExpression()->isBitPiece(); } |
Duncan P. N. Exon Smith | a9308c4 | 2015-04-29 16:38:44 +0000 | [diff] [blame] | 75 | const DIExpression *getExpression() const { return Expression; } |
Adrian Prantl | e8bde9f | 2014-08-11 22:52:56 +0000 | [diff] [blame] | 76 | friend bool operator==(const Value &, const Value &); |
| 77 | friend bool operator<(const Value &, const Value &); |
Adrian Prantl | e19e5ef | 2014-04-27 18:25:40 +0000 | [diff] [blame] | 78 | }; |
Adrian Prantl | e8bde9f | 2014-08-11 22:52:56 +0000 | [diff] [blame] | 79 | |
Adrian Prantl | e19e5ef | 2014-04-27 18:25:40 +0000 | [diff] [blame] | 80 | private: |
Adrian Prantl | be4b517 | 2014-08-11 21:06:03 +0000 | [diff] [blame] | 81 | /// A nonempty list of locations/constants belonging to this entry, |
| 82 | /// sorted by offset. |
Adrian Prantl | e19e5ef | 2014-04-27 18:25:40 +0000 | [diff] [blame] | 83 | SmallVector<Value, 1> Values; |
| 84 | |
David Blaikie | 1275e4f | 2014-04-01 21:49:04 +0000 | [diff] [blame] | 85 | public: |
David Blaikie | e1a26a6 | 2014-08-05 23:14:16 +0000 | [diff] [blame] | 86 | DebugLocEntry(const MCSymbol *B, const MCSymbol *E, Value Val) |
| 87 | : Begin(B), End(E) { |
Adrian Prantl | e19e5ef | 2014-04-27 18:25:40 +0000 | [diff] [blame] | 88 | Values.push_back(std::move(Val)); |
David Blaikie | 1275e4f | 2014-04-01 21:49:04 +0000 | [diff] [blame] | 89 | } |
| 90 | |
Adrian Prantl | e09ee3f | 2014-08-11 20:59:28 +0000 | [diff] [blame] | 91 | /// \brief If this and Next are describing different pieces of the same |
Adrian Prantl | 92da14b | 2015-03-02 22:02:33 +0000 | [diff] [blame] | 92 | /// variable, merge them by appending Next's values to the current |
| 93 | /// list of values. |
| 94 | /// Return true if the merge was successful. |
Adrian Prantl | e09ee3f | 2014-08-11 20:59:28 +0000 | [diff] [blame] | 95 | bool MergeValues(const DebugLocEntry &Next) { |
Adrian Prantl | 87b7eb9 | 2014-10-01 18:55:02 +0000 | [diff] [blame] | 96 | if (Begin == Next.Begin) { |
Duncan P. N. Exon Smith | a9308c4 | 2015-04-29 16:38:44 +0000 | [diff] [blame] | 97 | auto *Expr = cast_or_null<DIExpression>(Values[0].Expression); |
| 98 | auto *NextExpr = cast_or_null<DIExpression>(Next.Values[0].Expression); |
Duncan P. N. Exon Smith | 546c8be | 2015-04-17 16:33:37 +0000 | [diff] [blame] | 99 | if (Expr->isBitPiece() && NextExpr->isBitPiece()) { |
Adrian Prantl | 1c6f2ec | 2014-08-11 21:06:00 +0000 | [diff] [blame] | 100 | addValues(Next.Values); |
Adrian Prantl | b141683 | 2014-08-01 22:11:58 +0000 | [diff] [blame] | 101 | End = Next.End; |
| 102 | return true; |
| 103 | } |
| 104 | } |
Adrian Prantl | e09ee3f | 2014-08-11 20:59:28 +0000 | [diff] [blame] | 105 | return false; |
| 106 | } |
| 107 | |
| 108 | /// \brief Attempt to merge this DebugLocEntry with Next and return |
| 109 | /// true if the merge was successful. Entries can be merged if they |
| 110 | /// share the same Loc/Constant and if Next immediately follows this |
| 111 | /// Entry. |
| 112 | bool MergeRanges(const DebugLocEntry &Next) { |
Adrian Prantl | b141683 | 2014-08-01 22:11:58 +0000 | [diff] [blame] | 113 | // If this and Next are describing the same variable, merge them. |
Adrian Prantl | e19e5ef | 2014-04-27 18:25:40 +0000 | [diff] [blame] | 114 | if ((End == Next.Begin && Values == Next.Values)) { |
David Blaikie | 6fa9966 | 2014-04-01 23:19:23 +0000 | [diff] [blame] | 115 | End = Next.End; |
| 116 | return true; |
| 117 | } |
| 118 | return false; |
David Blaikie | 1275e4f | 2014-04-01 21:49:04 +0000 | [diff] [blame] | 119 | } |
Adrian Prantl | b141683 | 2014-08-01 22:11:58 +0000 | [diff] [blame] | 120 | |
David Blaikie | 1275e4f | 2014-04-01 21:49:04 +0000 | [diff] [blame] | 121 | const MCSymbol *getBeginSym() const { return Begin; } |
| 122 | const MCSymbol *getEndSym() const { return End; } |
Craig Topper | 3af9722 | 2014-08-27 05:25:00 +0000 | [diff] [blame] | 123 | ArrayRef<Value> getValues() const { return Values; } |
Adrian Prantl | 1c6f2ec | 2014-08-11 21:06:00 +0000 | [diff] [blame] | 124 | void addValues(ArrayRef<DebugLocEntry::Value> Vals) { |
| 125 | Values.append(Vals.begin(), Vals.end()); |
Adrian Prantl | 293dd93 | 2014-08-11 21:05:55 +0000 | [diff] [blame] | 126 | sortUniqueValues(); |
Adrian Prantl | 1c6f2ec | 2014-08-11 21:06:00 +0000 | [diff] [blame] | 127 | assert(std::all_of(Values.begin(), Values.end(), [](DebugLocEntry::Value V){ |
Adrian Prantl | 27bd01f | 2015-02-09 23:57:15 +0000 | [diff] [blame] | 128 | return V.isBitPiece(); |
Adrian Prantl | 1c6f2ec | 2014-08-11 21:06:00 +0000 | [diff] [blame] | 129 | }) && "value must be a piece"); |
Adrian Prantl | 293dd93 | 2014-08-11 21:05:55 +0000 | [diff] [blame] | 130 | } |
| 131 | |
Adrian Prantl | 92da14b | 2015-03-02 22:02:33 +0000 | [diff] [blame] | 132 | // \brief Sort the pieces by offset. |
Adrian Prantl | 293dd93 | 2014-08-11 21:05:55 +0000 | [diff] [blame] | 133 | // Remove any duplicate entries by dropping all but the first. |
| 134 | void sortUniqueValues() { |
| 135 | std::sort(Values.begin(), Values.end()); |
Duncan P. N. Exon Smith | 546c8be | 2015-04-17 16:33:37 +0000 | [diff] [blame] | 136 | Values.erase( |
| 137 | std::unique( |
| 138 | Values.begin(), Values.end(), [](const Value &A, const Value &B) { |
| 139 | return A.getExpression() == B.getExpression(); |
| 140 | }), |
| 141 | Values.end()); |
Adrian Prantl | b141683 | 2014-08-01 22:11:58 +0000 | [diff] [blame] | 142 | } |
Adrian Prantl | 92da14b | 2015-03-02 22:02:33 +0000 | [diff] [blame] | 143 | |
| 144 | /// \brief Lower this entry into a DWARF expression. |
Duncan P. N. Exon Smith | 364a300 | 2015-04-17 21:34:47 +0000 | [diff] [blame] | 145 | void finalize(const AsmPrinter &AP, DebugLocStream &Locs, |
Duncan P. N. Exon Smith | a9308c4 | 2015-04-29 16:38:44 +0000 | [diff] [blame] | 146 | const DIBasicType *BT); |
David Blaikie | 1275e4f | 2014-04-01 21:49:04 +0000 | [diff] [blame] | 147 | }; |
| 148 | |
Adrian Prantl | 92da14b | 2015-03-02 22:02:33 +0000 | [diff] [blame] | 149 | /// \brief Compare two Values for equality. |
Adrian Prantl | e8bde9f | 2014-08-11 22:52:56 +0000 | [diff] [blame] | 150 | inline bool operator==(const DebugLocEntry::Value &A, |
| 151 | const DebugLocEntry::Value &B) { |
| 152 | if (A.EntryKind != B.EntryKind) |
| 153 | return false; |
| 154 | |
Adrian Prantl | 87b7eb9 | 2014-10-01 18:55:02 +0000 | [diff] [blame] | 155 | if (A.Expression != B.Expression) |
| 156 | return false; |
| 157 | |
Adrian Prantl | e8bde9f | 2014-08-11 22:52:56 +0000 | [diff] [blame] | 158 | switch (A.EntryKind) { |
| 159 | case DebugLocEntry::Value::E_Location: |
| 160 | return A.Loc == B.Loc; |
| 161 | case DebugLocEntry::Value::E_Integer: |
| 162 | return A.Constant.Int == B.Constant.Int; |
| 163 | case DebugLocEntry::Value::E_ConstantFP: |
| 164 | return A.Constant.CFP == B.Constant.CFP; |
| 165 | case DebugLocEntry::Value::E_ConstantInt: |
| 166 | return A.Constant.CIP == B.Constant.CIP; |
| 167 | } |
| 168 | llvm_unreachable("unhandled EntryKind"); |
David Blaikie | 1275e4f | 2014-04-01 21:49:04 +0000 | [diff] [blame] | 169 | } |
Adrian Prantl | e8bde9f | 2014-08-11 22:52:56 +0000 | [diff] [blame] | 170 | |
Adrian Prantl | 92da14b | 2015-03-02 22:02:33 +0000 | [diff] [blame] | 171 | /// \brief Compare two pieces based on their offset. |
Adrian Prantl | e8bde9f | 2014-08-11 22:52:56 +0000 | [diff] [blame] | 172 | inline bool operator<(const DebugLocEntry::Value &A, |
| 173 | const DebugLocEntry::Value &B) { |
Duncan P. N. Exon Smith | 6a0320a | 2015-04-14 01:12:42 +0000 | [diff] [blame] | 174 | return A.getExpression()->getBitPieceOffset() < |
| 175 | B.getExpression()->getBitPieceOffset(); |
Adrian Prantl | e8bde9f | 2014-08-11 22:52:56 +0000 | [diff] [blame] | 176 | } |
| 177 | |
| 178 | } |
| 179 | |
David Blaikie | 1275e4f | 2014-04-01 21:49:04 +0000 | [diff] [blame] | 180 | #endif |