2014-04-02 05:49:04 +08:00
|
|
|
//===-- llvm/CodeGen/DebugLocEntry.h - Entry in debug_loc list -*- C++ -*--===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2014-08-14 00:26:38 +08:00
|
|
|
#ifndef LLVM_LIB_CODEGEN_ASMPRINTER_DEBUGLOCENTRY_H
|
|
|
|
#define LLVM_LIB_CODEGEN_ASMPRINTER_DEBUGLOCENTRY_H
|
2015-03-03 06:02:33 +08:00
|
|
|
#include "llvm/ADT/SmallString.h"
|
2014-04-02 05:49:04 +08:00
|
|
|
#include "llvm/IR/Constants.h"
|
2014-08-02 06:11:58 +08:00
|
|
|
#include "llvm/IR/DebugInfo.h"
|
2014-04-02 05:49:04 +08:00
|
|
|
#include "llvm/MC/MCSymbol.h"
|
2015-01-14 19:23:27 +08:00
|
|
|
#include "llvm/MC/MachineLocation.h"
|
2014-04-02 05:49:04 +08:00
|
|
|
|
|
|
|
namespace llvm {
|
2015-03-03 06:02:33 +08:00
|
|
|
class AsmPrinter;
|
AsmPrinter: Create a unified .debug_loc stream
This commit removes `DebugLocList` and replaces it with
`DebugLocStream`.
- `DebugLocEntry` no longer contains its byte/comment streams.
- The `DebugLocEntry` list for a variable/inlined-at pair is allocated
on the stack, and released right after `DebugLocEntry::finalize()`
(possible because of the refactoring in r231023). Now, only one
list is in memory at a time now.
- There's a single unified stream for the `.debug_loc` section that
persists, stored in the new `DebugLocStream` data structure.
The last point is important: this collapses the nested `SmallVector<>`s
from `DebugLocList` into unified streams. We previously had something
like the following:
vec<tuple<Label, CU,
vec<tuple<BeginSym, EndSym,
vec<Value>,
vec<char>,
vec<string>>>>>
A `SmallVector` can avoid allocations, but is statically fairly large
for a vector: three pointers plus the size of the small storage, which
is the number of elements in small mode times the element size).
Nesting these is expensive, since an inner vector's size contributes to
the element size of an outer one. (Nesting any vector is expensive...)
In the old data structure, the outer vector's *element* size was 632B,
excluding allocation costs for when the middle and inner vectors
exceeded their small sizes. 312B of this was for the "three" pointers
in the vector-tree beneath it. If you assume 1M functions with an
average of 10 variable/inlined-at pairs each (in an LTO scenario),
that's almost 6GB (besides inner allocations), with almost 3GB for the
"three" pointers.
This came up in a heap profile a little while ago of a `clang -flto -g`
bootstrap, with `DwarfDebug::collectVariableInfo()` using something like
10-15% of the total memory.
With this commit, we have:
tuple<vec<tuple<Label, CU, Offset>>,
vec<tuple<BeginSym, EndSym, Offset, Offset>>,
vec<char>,
vec<string>>
The offsets are used to create `ArrayRef` slices of adjacent
`SmallVector`s. This reduces the number of vectors to four (unrelated
to the number of variable/inlined-at pairs), and caps the number of
allocations at the same number.
Besides saving memory and limiting allocations, this is NFC.
I don't know my way around this code very well yet, but I wonder if we
could go further: why stream to a side-table, instead of directly to the
output stream?
llvm-svn: 235229
2015-04-18 05:34:47 +08:00
|
|
|
class DebugLocStream;
|
2015-04-18 00:36:10 +08:00
|
|
|
|
2014-04-02 05:49:04 +08:00
|
|
|
/// \brief This struct describes location entries emitted in the .debug_loc
|
|
|
|
/// section.
|
|
|
|
class DebugLocEntry {
|
2015-03-03 06:02:33 +08:00
|
|
|
/// Begin and end symbols for the address range that this location is valid.
|
2014-04-02 05:49:04 +08:00
|
|
|
const MCSymbol *Begin;
|
|
|
|
const MCSymbol *End;
|
|
|
|
|
2014-04-28 02:25:40 +08:00
|
|
|
public:
|
2015-03-03 06:02:33 +08:00
|
|
|
/// \brief A single location or constant.
|
2014-04-28 02:25:40 +08:00
|
|
|
struct Value {
|
2015-04-18 00:36:10 +08:00
|
|
|
Value(const MDExpression *Expr, int64_t i)
|
2015-04-18 00:33:37 +08:00
|
|
|
: Expression(Expr), EntryKind(E_Integer) {
|
2014-04-28 02:25:40 +08:00
|
|
|
Constant.Int = i;
|
|
|
|
}
|
2015-04-18 00:36:10 +08:00
|
|
|
Value(const MDExpression *Expr, const ConstantFP *CFP)
|
2015-04-18 00:33:37 +08:00
|
|
|
: Expression(Expr), EntryKind(E_ConstantFP) {
|
2014-04-28 02:25:40 +08:00
|
|
|
Constant.CFP = CFP;
|
|
|
|
}
|
2015-04-18 00:36:10 +08:00
|
|
|
Value(const MDExpression *Expr, const ConstantInt *CIP)
|
2015-04-18 00:33:37 +08:00
|
|
|
: Expression(Expr), EntryKind(E_ConstantInt) {
|
2014-04-28 02:25:40 +08:00
|
|
|
Constant.CIP = CIP;
|
|
|
|
}
|
2015-04-18 00:36:10 +08:00
|
|
|
Value(const MDExpression *Expr, MachineLocation Loc)
|
2015-04-18 00:33:37 +08:00
|
|
|
: Expression(Expr), EntryKind(E_Location), Loc(Loc) {
|
2015-04-07 07:27:40 +08:00
|
|
|
assert(cast<MDExpression>(Expr)->isValid());
|
2014-04-28 02:25:40 +08:00
|
|
|
}
|
2014-04-02 05:49:04 +08:00
|
|
|
|
2015-03-03 06:02:33 +08:00
|
|
|
/// Any complex address location expression for this Value.
|
2015-04-18 00:36:10 +08:00
|
|
|
const MDExpression *Expression;
|
Move the complex address expression out of DIVariable and into an extra
argument of the llvm.dbg.declare/llvm.dbg.value intrinsics.
Previously, DIVariable was a variable-length field that has an optional
reference to a Metadata array consisting of a variable number of
complex address expressions. In the case of OpPiece expressions this is
wasting a lot of storage in IR, because when an aggregate type is, e.g.,
SROA'd into all of its n individual members, the IR will contain n copies
of the DIVariable, all alike, only differing in the complex address
reference at the end.
By making the complex address into an extra argument of the
dbg.value/dbg.declare intrinsics, all of the pieces can reference the
same variable and the complex address expressions can be uniqued across
the CU, too.
Down the road, this will allow us to move other flags, such as
"indirection" out of the DIVariable, too.
The new intrinsics look like this:
declare void @llvm.dbg.declare(metadata %storage, metadata %var, metadata %expr)
declare void @llvm.dbg.value(metadata %storage, i64 %offset, metadata %var, metadata %expr)
This patch adds a new LLVM-local tag to DIExpressions, so we can detect
and pretty-print DIExpression metadata nodes.
What this patch doesn't do:
This patch does not touch the "Indirect" field in DIVariable; but moving
that into the expression would be a natural next step.
http://reviews.llvm.org/D4919
rdar://problem/17994491
Thanks to dblaikie and dexonsmith for reviewing this patch!
Note: I accidentally committed a bogus older version of this patch previously.
llvm-svn: 218787
2014-10-02 02:55:02 +08:00
|
|
|
|
2015-03-03 06:02:33 +08:00
|
|
|
/// Type of entry that this represents.
|
2014-04-28 02:25:40 +08:00
|
|
|
enum EntryType { E_Location, E_Integer, E_ConstantFP, E_ConstantInt };
|
|
|
|
enum EntryType EntryKind;
|
2014-04-02 05:49:04 +08:00
|
|
|
|
2015-03-03 06:02:33 +08:00
|
|
|
/// Either a constant,
|
2014-04-28 02:25:40 +08:00
|
|
|
union {
|
|
|
|
int64_t Int;
|
|
|
|
const ConstantFP *CFP;
|
|
|
|
const ConstantInt *CIP;
|
|
|
|
} Constant;
|
2014-04-02 05:49:04 +08:00
|
|
|
|
2014-04-28 02:25:40 +08:00
|
|
|
// Or a location in the machine frame.
|
|
|
|
MachineLocation Loc;
|
2014-04-02 05:49:04 +08:00
|
|
|
|
2014-04-28 02:25:40 +08:00
|
|
|
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; }
|
2015-04-14 09:12:42 +08:00
|
|
|
bool isBitPiece() const { return getExpression()->isBitPiece(); }
|
2015-04-22 02:44:06 +08:00
|
|
|
const MDExpression *getExpression() const { return Expression; }
|
2014-08-12 06:52:56 +08:00
|
|
|
friend bool operator==(const Value &, const Value &);
|
|
|
|
friend bool operator<(const Value &, const Value &);
|
2014-04-28 02:25:40 +08:00
|
|
|
};
|
2014-08-12 06:52:56 +08:00
|
|
|
|
2014-04-28 02:25:40 +08:00
|
|
|
private:
|
2014-08-12 05:06:03 +08:00
|
|
|
/// A nonempty list of locations/constants belonging to this entry,
|
|
|
|
/// sorted by offset.
|
2014-04-28 02:25:40 +08:00
|
|
|
SmallVector<Value, 1> Values;
|
|
|
|
|
2014-04-02 05:49:04 +08:00
|
|
|
public:
|
2014-08-06 07:14:16 +08:00
|
|
|
DebugLocEntry(const MCSymbol *B, const MCSymbol *E, Value Val)
|
|
|
|
: Begin(B), End(E) {
|
2014-04-28 02:25:40 +08:00
|
|
|
Values.push_back(std::move(Val));
|
2014-04-02 05:49:04 +08:00
|
|
|
}
|
|
|
|
|
2014-08-12 04:59:28 +08:00
|
|
|
/// \brief If this and Next are describing different pieces of the same
|
2015-03-03 06:02:33 +08:00
|
|
|
/// variable, merge them by appending Next's values to the current
|
|
|
|
/// list of values.
|
|
|
|
/// Return true if the merge was successful.
|
2014-08-12 04:59:28 +08:00
|
|
|
bool MergeValues(const DebugLocEntry &Next) {
|
Move the complex address expression out of DIVariable and into an extra
argument of the llvm.dbg.declare/llvm.dbg.value intrinsics.
Previously, DIVariable was a variable-length field that has an optional
reference to a Metadata array consisting of a variable number of
complex address expressions. In the case of OpPiece expressions this is
wasting a lot of storage in IR, because when an aggregate type is, e.g.,
SROA'd into all of its n individual members, the IR will contain n copies
of the DIVariable, all alike, only differing in the complex address
reference at the end.
By making the complex address into an extra argument of the
dbg.value/dbg.declare intrinsics, all of the pieces can reference the
same variable and the complex address expressions can be uniqued across
the CU, too.
Down the road, this will allow us to move other flags, such as
"indirection" out of the DIVariable, too.
The new intrinsics look like this:
declare void @llvm.dbg.declare(metadata %storage, metadata %var, metadata %expr)
declare void @llvm.dbg.value(metadata %storage, i64 %offset, metadata %var, metadata %expr)
This patch adds a new LLVM-local tag to DIExpressions, so we can detect
and pretty-print DIExpression metadata nodes.
What this patch doesn't do:
This patch does not touch the "Indirect" field in DIVariable; but moving
that into the expression would be a natural next step.
http://reviews.llvm.org/D4919
rdar://problem/17994491
Thanks to dblaikie and dexonsmith for reviewing this patch!
Note: I accidentally committed a bogus older version of this patch previously.
llvm-svn: 218787
2014-10-02 02:55:02 +08:00
|
|
|
if (Begin == Next.Begin) {
|
2015-04-22 02:44:06 +08:00
|
|
|
auto *Expr = cast_or_null<MDExpression>(Values[0].Expression);
|
|
|
|
auto *NextExpr = cast_or_null<MDExpression>(Next.Values[0].Expression);
|
2015-04-18 00:33:37 +08:00
|
|
|
if (Expr->isBitPiece() && NextExpr->isBitPiece()) {
|
2014-08-12 05:06:00 +08:00
|
|
|
addValues(Next.Values);
|
2014-08-02 06:11:58 +08:00
|
|
|
End = Next.End;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
2014-08-12 04:59:28 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// \brief Attempt to merge this DebugLocEntry with Next and return
|
|
|
|
/// true if the merge was successful. Entries can be merged if they
|
|
|
|
/// share the same Loc/Constant and if Next immediately follows this
|
|
|
|
/// Entry.
|
|
|
|
bool MergeRanges(const DebugLocEntry &Next) {
|
2014-08-02 06:11:58 +08:00
|
|
|
// If this and Next are describing the same variable, merge them.
|
2014-04-28 02:25:40 +08:00
|
|
|
if ((End == Next.Begin && Values == Next.Values)) {
|
2014-04-02 07:19:23 +08:00
|
|
|
End = Next.End;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
2014-04-02 05:49:04 +08:00
|
|
|
}
|
2014-08-02 06:11:58 +08:00
|
|
|
|
2014-04-02 05:49:04 +08:00
|
|
|
const MCSymbol *getBeginSym() const { return Begin; }
|
|
|
|
const MCSymbol *getEndSym() const { return End; }
|
2014-08-27 13:25:00 +08:00
|
|
|
ArrayRef<Value> getValues() const { return Values; }
|
2014-08-12 05:06:00 +08:00
|
|
|
void addValues(ArrayRef<DebugLocEntry::Value> Vals) {
|
|
|
|
Values.append(Vals.begin(), Vals.end());
|
2014-08-12 05:05:55 +08:00
|
|
|
sortUniqueValues();
|
2014-08-12 05:06:00 +08:00
|
|
|
assert(std::all_of(Values.begin(), Values.end(), [](DebugLocEntry::Value V){
|
2015-02-10 07:57:15 +08:00
|
|
|
return V.isBitPiece();
|
2014-08-12 05:06:00 +08:00
|
|
|
}) && "value must be a piece");
|
2014-08-12 05:05:55 +08:00
|
|
|
}
|
|
|
|
|
2015-03-03 06:02:33 +08:00
|
|
|
// \brief Sort the pieces by offset.
|
2014-08-12 05:05:55 +08:00
|
|
|
// Remove any duplicate entries by dropping all but the first.
|
|
|
|
void sortUniqueValues() {
|
|
|
|
std::sort(Values.begin(), Values.end());
|
2015-04-18 00:33:37 +08:00
|
|
|
Values.erase(
|
|
|
|
std::unique(
|
|
|
|
Values.begin(), Values.end(), [](const Value &A, const Value &B) {
|
|
|
|
return A.getExpression() == B.getExpression();
|
|
|
|
}),
|
|
|
|
Values.end());
|
2014-08-02 06:11:58 +08:00
|
|
|
}
|
2015-03-03 06:02:33 +08:00
|
|
|
|
|
|
|
/// \brief Lower this entry into a DWARF expression.
|
AsmPrinter: Create a unified .debug_loc stream
This commit removes `DebugLocList` and replaces it with
`DebugLocStream`.
- `DebugLocEntry` no longer contains its byte/comment streams.
- The `DebugLocEntry` list for a variable/inlined-at pair is allocated
on the stack, and released right after `DebugLocEntry::finalize()`
(possible because of the refactoring in r231023). Now, only one
list is in memory at a time now.
- There's a single unified stream for the `.debug_loc` section that
persists, stored in the new `DebugLocStream` data structure.
The last point is important: this collapses the nested `SmallVector<>`s
from `DebugLocList` into unified streams. We previously had something
like the following:
vec<tuple<Label, CU,
vec<tuple<BeginSym, EndSym,
vec<Value>,
vec<char>,
vec<string>>>>>
A `SmallVector` can avoid allocations, but is statically fairly large
for a vector: three pointers plus the size of the small storage, which
is the number of elements in small mode times the element size).
Nesting these is expensive, since an inner vector's size contributes to
the element size of an outer one. (Nesting any vector is expensive...)
In the old data structure, the outer vector's *element* size was 632B,
excluding allocation costs for when the middle and inner vectors
exceeded their small sizes. 312B of this was for the "three" pointers
in the vector-tree beneath it. If you assume 1M functions with an
average of 10 variable/inlined-at pairs each (in an LTO scenario),
that's almost 6GB (besides inner allocations), with almost 3GB for the
"three" pointers.
This came up in a heap profile a little while ago of a `clang -flto -g`
bootstrap, with `DwarfDebug::collectVariableInfo()` using something like
10-15% of the total memory.
With this commit, we have:
tuple<vec<tuple<Label, CU, Offset>>,
vec<tuple<BeginSym, EndSym, Offset, Offset>>,
vec<char>,
vec<string>>
The offsets are used to create `ArrayRef` slices of adjacent
`SmallVector`s. This reduces the number of vectors to four (unrelated
to the number of variable/inlined-at pairs), and caps the number of
allocations at the same number.
Besides saving memory and limiting allocations, this is NFC.
I don't know my way around this code very well yet, but I wonder if we
could go further: why stream to a side-table, instead of directly to the
output stream?
llvm-svn: 235229
2015-04-18 05:34:47 +08:00
|
|
|
void finalize(const AsmPrinter &AP, DebugLocStream &Locs,
|
|
|
|
const MDBasicType *BT);
|
2014-04-02 05:49:04 +08:00
|
|
|
};
|
|
|
|
|
2015-03-03 06:02:33 +08:00
|
|
|
/// \brief Compare two Values for equality.
|
2014-08-12 06:52:56 +08:00
|
|
|
inline bool operator==(const DebugLocEntry::Value &A,
|
|
|
|
const DebugLocEntry::Value &B) {
|
|
|
|
if (A.EntryKind != B.EntryKind)
|
|
|
|
return false;
|
|
|
|
|
Move the complex address expression out of DIVariable and into an extra
argument of the llvm.dbg.declare/llvm.dbg.value intrinsics.
Previously, DIVariable was a variable-length field that has an optional
reference to a Metadata array consisting of a variable number of
complex address expressions. In the case of OpPiece expressions this is
wasting a lot of storage in IR, because when an aggregate type is, e.g.,
SROA'd into all of its n individual members, the IR will contain n copies
of the DIVariable, all alike, only differing in the complex address
reference at the end.
By making the complex address into an extra argument of the
dbg.value/dbg.declare intrinsics, all of the pieces can reference the
same variable and the complex address expressions can be uniqued across
the CU, too.
Down the road, this will allow us to move other flags, such as
"indirection" out of the DIVariable, too.
The new intrinsics look like this:
declare void @llvm.dbg.declare(metadata %storage, metadata %var, metadata %expr)
declare void @llvm.dbg.value(metadata %storage, i64 %offset, metadata %var, metadata %expr)
This patch adds a new LLVM-local tag to DIExpressions, so we can detect
and pretty-print DIExpression metadata nodes.
What this patch doesn't do:
This patch does not touch the "Indirect" field in DIVariable; but moving
that into the expression would be a natural next step.
http://reviews.llvm.org/D4919
rdar://problem/17994491
Thanks to dblaikie and dexonsmith for reviewing this patch!
Note: I accidentally committed a bogus older version of this patch previously.
llvm-svn: 218787
2014-10-02 02:55:02 +08:00
|
|
|
if (A.Expression != B.Expression)
|
|
|
|
return false;
|
|
|
|
|
2014-08-12 06:52:56 +08:00
|
|
|
switch (A.EntryKind) {
|
|
|
|
case DebugLocEntry::Value::E_Location:
|
|
|
|
return A.Loc == B.Loc;
|
|
|
|
case DebugLocEntry::Value::E_Integer:
|
|
|
|
return A.Constant.Int == B.Constant.Int;
|
|
|
|
case DebugLocEntry::Value::E_ConstantFP:
|
|
|
|
return A.Constant.CFP == B.Constant.CFP;
|
|
|
|
case DebugLocEntry::Value::E_ConstantInt:
|
|
|
|
return A.Constant.CIP == B.Constant.CIP;
|
|
|
|
}
|
|
|
|
llvm_unreachable("unhandled EntryKind");
|
|
|
|
}
|
|
|
|
|
2015-03-03 06:02:33 +08:00
|
|
|
/// \brief Compare two pieces based on their offset.
|
2014-08-12 06:52:56 +08:00
|
|
|
inline bool operator<(const DebugLocEntry::Value &A,
|
|
|
|
const DebugLocEntry::Value &B) {
|
2015-04-14 09:12:42 +08:00
|
|
|
return A.getExpression()->getBitPieceOffset() <
|
|
|
|
B.getExpression()->getBitPieceOffset();
|
2014-08-12 06:52:56 +08:00
|
|
|
}
|
|
|
|
|
2014-04-02 05:49:04 +08:00
|
|
|
}
|
2014-08-12 06:52:56 +08:00
|
|
|
|
2014-04-02 05:49:04 +08:00
|
|
|
#endif
|