forked from OSchip/llvm-project
615 lines
26 KiB
C++
615 lines
26 KiB
C++
#include "llvm/ADT/DenseMap.h"
|
|
#include "llvm/ADT/StringExtras.h"
|
|
#include "llvm/ADT/StringSet.h"
|
|
#include "llvm/DebugInfo/DIContext.h"
|
|
#include "llvm/DebugInfo/DWARF/DWARFContext.h"
|
|
#include "llvm/DebugInfo/DWARF/DWARFDebugLoc.h"
|
|
#include "llvm/Object/ObjectFile.h"
|
|
#include "llvm/Support/JSON.h"
|
|
|
|
#define DEBUG_TYPE "dwarfdump"
|
|
using namespace llvm;
|
|
using namespace object;
|
|
|
|
/// This represents the number of categories of debug location coverage being
|
|
/// calculated. The first category is the number of variables with 0% location
|
|
/// coverage, but the last category is the number of variables with 100%
|
|
/// location coverage.
|
|
constexpr int NumOfCoverageCategories = 12;
|
|
|
|
/// Holds statistics for one function (or other entity that has a PC range and
|
|
/// contains variables, such as a compile unit).
|
|
struct PerFunctionStats {
|
|
/// Number of inlined instances of this function.
|
|
unsigned NumFnInlined = 0;
|
|
/// Number of inlined instances that have abstract origins.
|
|
unsigned NumAbstractOrigins = 0;
|
|
/// Number of variables and parameters with location across all inlined
|
|
/// instances.
|
|
unsigned TotalVarWithLoc = 0;
|
|
/// Number of constants with location across all inlined instances.
|
|
unsigned ConstantMembers = 0;
|
|
/// List of all Variables and parameters in this function.
|
|
StringSet<> VarsInFunction;
|
|
/// Compile units also cover a PC range, but have this flag set to false.
|
|
bool IsFunction = false;
|
|
/// Verify function definition has PC addresses (for detecting when
|
|
/// a function has been inlined everywhere).
|
|
bool HasPCAddresses = false;
|
|
/// Function has source location information.
|
|
bool HasSourceLocation = false;
|
|
/// Number of function parameters.
|
|
unsigned NumParams = 0;
|
|
/// Number of function parameters with source location.
|
|
unsigned NumParamSourceLocations = 0;
|
|
/// Number of function parameters with type.
|
|
unsigned NumParamTypes = 0;
|
|
/// Number of function parameters with a DW_AT_location.
|
|
unsigned NumParamLocations = 0;
|
|
/// Number of variables.
|
|
unsigned NumVars = 0;
|
|
/// Number of variables with source location.
|
|
unsigned NumVarSourceLocations = 0;
|
|
/// Number of variables with type.
|
|
unsigned NumVarTypes = 0;
|
|
/// Number of variables with DW_AT_location.
|
|
unsigned NumVarLocations = 0;
|
|
};
|
|
|
|
/// Holds accumulated global statistics about DIEs.
|
|
struct GlobalStats {
|
|
/// Total number of PC range bytes covered by DW_AT_locations.
|
|
unsigned ScopeBytesCovered = 0;
|
|
/// Total number of PC range bytes in each variable's enclosing scope,
|
|
/// starting from the first definition of the variable.
|
|
unsigned ScopeBytesFromFirstDefinition = 0;
|
|
/// Total number of PC range bytes covered by DW_AT_locations with
|
|
/// the debug entry values (DW_OP_entry_value).
|
|
unsigned ScopeEntryValueBytesCovered = 0;
|
|
/// Total number of PC range bytes covered by DW_AT_locations of
|
|
/// formal parameters.
|
|
unsigned ParamScopeBytesCovered = 0;
|
|
/// Total number of PC range bytes in each variable's enclosing scope,
|
|
/// starting from the first definition of the variable (only for parameters).
|
|
unsigned ParamScopeBytesFromFirstDefinition = 0;
|
|
/// Total number of PC range bytes covered by DW_AT_locations with
|
|
/// the debug entry values (DW_OP_entry_value) (only for parameters).
|
|
unsigned ParamScopeEntryValueBytesCovered = 0;
|
|
/// Total number of PC range bytes covered by DW_AT_locations (only for local
|
|
/// variables).
|
|
unsigned VarScopeBytesCovered = 0;
|
|
/// Total number of PC range bytes in each variable's enclosing scope,
|
|
/// starting from the first definition of the variable (only for local
|
|
/// variables).
|
|
unsigned VarScopeBytesFromFirstDefinition = 0;
|
|
/// Total number of PC range bytes covered by DW_AT_locations with
|
|
/// the debug entry values (DW_OP_entry_value) (only for local variables).
|
|
unsigned VarScopeEntryValueBytesCovered = 0;
|
|
/// Total number of call site entries (DW_AT_call_file & DW_AT_call_line).
|
|
unsigned CallSiteEntries = 0;
|
|
/// Total number of call site DIEs (DW_TAG_call_site).
|
|
unsigned CallSiteDIEs = 0;
|
|
/// Total number of call site parameter DIEs (DW_TAG_call_site_parameter).
|
|
unsigned CallSiteParamDIEs = 0;
|
|
/// Total byte size of concrete functions. This byte size includes
|
|
/// inline functions contained in the concrete functions.
|
|
unsigned FunctionSize = 0;
|
|
/// Total byte size of inlined functions. This is the total number of bytes
|
|
/// for the top inline functions within concrete functions. This can help
|
|
/// tune the inline settings when compiling to match user expectations.
|
|
unsigned InlineFunctionSize = 0;
|
|
};
|
|
|
|
/// Holds accumulated debug location statistics about local variables and
|
|
/// formal parameters.
|
|
struct LocationStats {
|
|
/// Map the scope coverage decile to the number of variables in the decile.
|
|
/// The first element of the array (at the index zero) represents the number
|
|
/// of variables with the no debug location at all, but the last element
|
|
/// in the vector represents the number of fully covered variables within
|
|
/// its scope.
|
|
std::vector<unsigned> VarParamLocStats{
|
|
std::vector<unsigned>(NumOfCoverageCategories, 0)};
|
|
/// Map non debug entry values coverage.
|
|
std::vector<unsigned> VarParamNonEntryValLocStats{
|
|
std::vector<unsigned>(NumOfCoverageCategories, 0)};
|
|
/// The debug location statistics for formal parameters.
|
|
std::vector<unsigned> ParamLocStats{
|
|
std::vector<unsigned>(NumOfCoverageCategories, 0)};
|
|
/// Map non debug entry values coverage for formal parameters.
|
|
std::vector<unsigned> ParamNonEntryValLocStats{
|
|
std::vector<unsigned>(NumOfCoverageCategories, 0)};
|
|
/// The debug location statistics for local variables.
|
|
std::vector<unsigned> VarLocStats{
|
|
std::vector<unsigned>(NumOfCoverageCategories, 0)};
|
|
/// Map non debug entry values coverage for local variables.
|
|
std::vector<unsigned> VarNonEntryValLocStats{
|
|
std::vector<unsigned>(NumOfCoverageCategories, 0)};
|
|
/// Total number of local variables and function parameters processed.
|
|
unsigned NumVarParam = 0;
|
|
/// Total number of formal parameters processed.
|
|
unsigned NumParam = 0;
|
|
/// Total number of local variables processed.
|
|
unsigned NumVar = 0;
|
|
};
|
|
|
|
/// Extract the low pc from a Die.
|
|
static uint64_t getLowPC(DWARFDie Die) {
|
|
auto RangesOrError = Die.getAddressRanges();
|
|
DWARFAddressRangesVector Ranges;
|
|
if (RangesOrError)
|
|
Ranges = RangesOrError.get();
|
|
else
|
|
llvm::consumeError(RangesOrError.takeError());
|
|
if (Ranges.size())
|
|
return Ranges[0].LowPC;
|
|
return dwarf::toAddress(Die.find(dwarf::DW_AT_low_pc), 0);
|
|
}
|
|
|
|
/// Collect debug location statistics for one DIE.
|
|
static void collectLocStats(uint64_t BytesCovered, uint64_t BytesInScope,
|
|
std::vector<unsigned> &VarParamLocStats,
|
|
std::vector<unsigned> &ParamLocStats,
|
|
std::vector<unsigned> &VarLocStats, bool IsParam,
|
|
bool IsLocalVar) {
|
|
auto getCoverageBucket = [BytesCovered, BytesInScope]() -> unsigned {
|
|
unsigned LocBucket = 100 * (double)BytesCovered / BytesInScope;
|
|
if (LocBucket == 0) {
|
|
// No debug location at all for the variable.
|
|
return 0;
|
|
} else if (LocBucket == 100 || BytesCovered > BytesInScope) {
|
|
// Fully covered variable within its scope.
|
|
return NumOfCoverageCategories - 1;
|
|
} else {
|
|
// Get covered range (e.g. 20%-29%).
|
|
LocBucket /= 10;
|
|
return LocBucket + 1;
|
|
}
|
|
};
|
|
|
|
unsigned CoverageBucket = getCoverageBucket();
|
|
VarParamLocStats[CoverageBucket]++;
|
|
if (IsParam)
|
|
ParamLocStats[CoverageBucket]++;
|
|
else if (IsLocalVar)
|
|
VarLocStats[CoverageBucket]++;
|
|
}
|
|
|
|
/// Collect debug info quality metrics for one DIE.
|
|
static void collectStatsForDie(DWARFDie Die, uint64_t UnitLowPC, std::string FnPrefix,
|
|
std::string VarPrefix, uint64_t ScopeLowPC,
|
|
uint64_t BytesInScope, uint32_t InlineDepth,
|
|
StringMap<PerFunctionStats> &FnStatMap,
|
|
GlobalStats &GlobalStats,
|
|
LocationStats &LocStats) {
|
|
bool HasLoc = false;
|
|
bool HasSrcLoc = false;
|
|
bool HasType = false;
|
|
bool IsArtificial = false;
|
|
uint64_t BytesCovered = 0;
|
|
uint64_t BytesEntryValuesCovered = 0;
|
|
uint64_t OffsetToFirstDefinition = 0;
|
|
auto &FnStats = FnStatMap[FnPrefix];
|
|
bool IsParam = Die.getTag() == dwarf::DW_TAG_formal_parameter;
|
|
bool IsLocalVar = Die.getTag() == dwarf::DW_TAG_variable;
|
|
|
|
if (Die.getTag() == dwarf::DW_TAG_call_site ||
|
|
Die.getTag() == dwarf::DW_TAG_GNU_call_site) {
|
|
GlobalStats.CallSiteDIEs++;
|
|
return;
|
|
}
|
|
|
|
if (Die.getTag() == dwarf::DW_TAG_call_site_parameter ||
|
|
Die.getTag() == dwarf::DW_TAG_GNU_call_site_parameter) {
|
|
GlobalStats.CallSiteParamDIEs++;
|
|
return;
|
|
}
|
|
|
|
if (!IsParam && !IsLocalVar && Die.getTag() != dwarf::DW_TAG_member) {
|
|
// Not a variable or constant member.
|
|
return;
|
|
}
|
|
|
|
if (Die.findRecursively(dwarf::DW_AT_decl_file) &&
|
|
Die.findRecursively(dwarf::DW_AT_decl_line))
|
|
HasSrcLoc = true;
|
|
|
|
if (Die.findRecursively(dwarf::DW_AT_type))
|
|
HasType = true;
|
|
|
|
if (Die.find(dwarf::DW_AT_artificial))
|
|
IsArtificial = true;
|
|
|
|
auto IsEntryValue = [&](ArrayRef<uint8_t> D) -> bool {
|
|
DWARFUnit *U = Die.getDwarfUnit();
|
|
DataExtractor Data(toStringRef(D),
|
|
Die.getDwarfUnit()->getContext().isLittleEndian(), 0);
|
|
DWARFExpression Expression(Data, U->getVersion(), U->getAddressByteSize());
|
|
// Consider the expression containing the DW_OP_entry_value as
|
|
// an entry value.
|
|
return llvm::any_of(Expression, [](DWARFExpression::Operation &Op) {
|
|
return Op.getCode() == dwarf::DW_OP_entry_value ||
|
|
Op.getCode() == dwarf::DW_OP_GNU_entry_value;
|
|
});
|
|
};
|
|
|
|
if (Die.find(dwarf::DW_AT_const_value)) {
|
|
// This catches constant members *and* variables.
|
|
HasLoc = true;
|
|
BytesCovered = BytesInScope;
|
|
} else {
|
|
if (Die.getTag() == dwarf::DW_TAG_member) {
|
|
// Non-const member.
|
|
return;
|
|
}
|
|
// Handle variables and function arguments.
|
|
auto FormValue = Die.find(dwarf::DW_AT_location);
|
|
HasLoc = FormValue.hasValue();
|
|
if (HasLoc) {
|
|
// Get PC coverage.
|
|
if (auto DebugLocOffset = FormValue->getAsSectionOffset()) {
|
|
auto *DebugLoc = Die.getDwarfUnit()->getContext().getDebugLoc();
|
|
if (auto List = DebugLoc->getLocationListAtOffset(*DebugLocOffset)) {
|
|
for (auto Entry : List->Entries) {
|
|
uint64_t BytesEntryCovered = Entry.End - Entry.Begin;
|
|
BytesCovered += BytesEntryCovered;
|
|
if (IsEntryValue(Entry.Loc))
|
|
BytesEntryValuesCovered += BytesEntryCovered;
|
|
}
|
|
if (List->Entries.size()) {
|
|
uint64_t FirstDef = List->Entries[0].Begin;
|
|
uint64_t UnitOfs = UnitLowPC;
|
|
// Ranges sometimes start before the lexical scope.
|
|
if (UnitOfs + FirstDef >= ScopeLowPC)
|
|
OffsetToFirstDefinition = UnitOfs + FirstDef - ScopeLowPC;
|
|
// Or even after it. Count that as a failure.
|
|
if (OffsetToFirstDefinition > BytesInScope)
|
|
OffsetToFirstDefinition = 0;
|
|
}
|
|
}
|
|
assert(BytesInScope);
|
|
} else {
|
|
// Assume the entire range is covered by a single location.
|
|
BytesCovered = BytesInScope;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Calculate the debug location statistics.
|
|
if (BytesInScope) {
|
|
LocStats.NumVarParam++;
|
|
if (IsParam)
|
|
LocStats.NumParam++;
|
|
else if (IsLocalVar)
|
|
LocStats.NumVar++;
|
|
|
|
collectLocStats(BytesCovered, BytesInScope, LocStats.VarParamLocStats,
|
|
LocStats.ParamLocStats, LocStats.VarLocStats, IsParam,
|
|
IsLocalVar);
|
|
// Non debug entry values coverage statistics.
|
|
collectLocStats(BytesCovered - BytesEntryValuesCovered, BytesInScope,
|
|
LocStats.VarParamNonEntryValLocStats,
|
|
LocStats.ParamNonEntryValLocStats,
|
|
LocStats.VarNonEntryValLocStats, IsParam, IsLocalVar);
|
|
}
|
|
|
|
// Collect PC range coverage data.
|
|
if (DWARFDie D =
|
|
Die.getAttributeValueAsReferencedDie(dwarf::DW_AT_abstract_origin))
|
|
Die = D;
|
|
// By using the variable name + the path through the lexical block tree, the
|
|
// keys are consistent across duplicate abstract origins in different CUs.
|
|
std::string VarName = StringRef(Die.getName(DINameKind::ShortName));
|
|
FnStats.VarsInFunction.insert(VarPrefix + VarName);
|
|
if (BytesInScope) {
|
|
FnStats.TotalVarWithLoc += (unsigned)HasLoc;
|
|
// Adjust for the fact the variables often start their lifetime in the
|
|
// middle of the scope.
|
|
BytesInScope -= OffsetToFirstDefinition;
|
|
// Turns out we have a lot of ranges that extend past the lexical scope.
|
|
GlobalStats.ScopeBytesCovered += std::min(BytesInScope, BytesCovered);
|
|
GlobalStats.ScopeBytesFromFirstDefinition += BytesInScope;
|
|
GlobalStats.ScopeEntryValueBytesCovered += BytesEntryValuesCovered;
|
|
if (IsParam) {
|
|
GlobalStats.ParamScopeBytesCovered +=
|
|
std::min(BytesInScope, BytesCovered);
|
|
GlobalStats.ParamScopeBytesFromFirstDefinition += BytesInScope;
|
|
GlobalStats.ParamScopeEntryValueBytesCovered += BytesEntryValuesCovered;
|
|
} else if (IsLocalVar) {
|
|
GlobalStats.VarScopeBytesCovered += std::min(BytesInScope, BytesCovered);
|
|
GlobalStats.VarScopeBytesFromFirstDefinition += BytesInScope;
|
|
GlobalStats.VarScopeEntryValueBytesCovered += BytesEntryValuesCovered;
|
|
}
|
|
assert(GlobalStats.ScopeBytesCovered <=
|
|
GlobalStats.ScopeBytesFromFirstDefinition);
|
|
} else if (Die.getTag() == dwarf::DW_TAG_member) {
|
|
FnStats.ConstantMembers++;
|
|
} else {
|
|
FnStats.TotalVarWithLoc += (unsigned)HasLoc;
|
|
}
|
|
if (!IsArtificial) {
|
|
if (IsParam) {
|
|
FnStats.NumParams++;
|
|
if (HasType)
|
|
FnStats.NumParamTypes++;
|
|
if (HasSrcLoc)
|
|
FnStats.NumParamSourceLocations++;
|
|
if (HasLoc)
|
|
FnStats.NumParamLocations++;
|
|
} else if (IsLocalVar) {
|
|
FnStats.NumVars++;
|
|
if (HasType)
|
|
FnStats.NumVarTypes++;
|
|
if (HasSrcLoc)
|
|
FnStats.NumVarSourceLocations++;
|
|
if (HasLoc)
|
|
FnStats.NumVarLocations++;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Recursively collect debug info quality metrics.
|
|
static void collectStatsRecursive(DWARFDie Die, uint64_t UnitLowPC, std::string FnPrefix,
|
|
std::string VarPrefix, uint64_t ScopeLowPC,
|
|
uint64_t BytesInScope, uint32_t InlineDepth,
|
|
StringMap<PerFunctionStats> &FnStatMap,
|
|
GlobalStats &GlobalStats,
|
|
LocationStats &LocStats) {
|
|
// Handle any kind of lexical scope.
|
|
const dwarf::Tag Tag = Die.getTag();
|
|
const bool IsFunction = Tag == dwarf::DW_TAG_subprogram;
|
|
const bool IsBlock = Tag == dwarf::DW_TAG_lexical_block;
|
|
const bool IsInlinedFunction = Tag == dwarf::DW_TAG_inlined_subroutine;
|
|
if (IsFunction || IsInlinedFunction || IsBlock) {
|
|
|
|
// Reset VarPrefix when entering a new function.
|
|
if (Die.getTag() == dwarf::DW_TAG_subprogram ||
|
|
Die.getTag() == dwarf::DW_TAG_inlined_subroutine)
|
|
VarPrefix = "v";
|
|
|
|
// Ignore forward declarations.
|
|
if (Die.find(dwarf::DW_AT_declaration))
|
|
return;
|
|
|
|
// Check for call sites.
|
|
if (Die.find(dwarf::DW_AT_call_file) && Die.find(dwarf::DW_AT_call_line))
|
|
GlobalStats.CallSiteEntries++;
|
|
|
|
// PC Ranges.
|
|
auto RangesOrError = Die.getAddressRanges();
|
|
if (!RangesOrError) {
|
|
llvm::consumeError(RangesOrError.takeError());
|
|
return;
|
|
}
|
|
|
|
auto Ranges = RangesOrError.get();
|
|
uint64_t BytesInThisScope = 0;
|
|
for (auto Range : Ranges)
|
|
BytesInThisScope += Range.HighPC - Range.LowPC;
|
|
ScopeLowPC = getLowPC(Die);
|
|
|
|
// Count the function.
|
|
if (!IsBlock) {
|
|
StringRef Name = Die.getName(DINameKind::LinkageName);
|
|
if (Name.empty())
|
|
Name = Die.getName(DINameKind::ShortName);
|
|
FnPrefix = Name;
|
|
// Skip over abstract origins.
|
|
if (Die.find(dwarf::DW_AT_inline))
|
|
return;
|
|
// We've seen an (inlined) instance of this function.
|
|
auto &FnStats = FnStatMap[Name];
|
|
if (IsInlinedFunction) {
|
|
FnStats.NumFnInlined++;
|
|
if (Die.findRecursively(dwarf::DW_AT_abstract_origin))
|
|
FnStats.NumAbstractOrigins++;
|
|
}
|
|
FnStats.IsFunction = true;
|
|
if (BytesInThisScope && !IsInlinedFunction)
|
|
FnStats.HasPCAddresses = true;
|
|
std::string FnName = StringRef(Die.getName(DINameKind::ShortName));
|
|
if (Die.findRecursively(dwarf::DW_AT_decl_file) &&
|
|
Die.findRecursively(dwarf::DW_AT_decl_line))
|
|
FnStats.HasSourceLocation = true;
|
|
}
|
|
|
|
if (BytesInThisScope) {
|
|
BytesInScope = BytesInThisScope;
|
|
if (IsFunction)
|
|
GlobalStats.FunctionSize += BytesInThisScope;
|
|
else if (IsInlinedFunction && InlineDepth == 0)
|
|
GlobalStats.InlineFunctionSize += BytesInThisScope;
|
|
}
|
|
} else {
|
|
// Not a scope, visit the Die itself. It could be a variable.
|
|
collectStatsForDie(Die, UnitLowPC, FnPrefix, VarPrefix, ScopeLowPC, BytesInScope,
|
|
InlineDepth, FnStatMap, GlobalStats, LocStats);
|
|
}
|
|
|
|
// Set InlineDepth correctly for child recursion
|
|
if (IsFunction)
|
|
InlineDepth = 0;
|
|
else if (IsInlinedFunction)
|
|
++InlineDepth;
|
|
|
|
// Traverse children.
|
|
unsigned LexicalBlockIndex = 0;
|
|
DWARFDie Child = Die.getFirstChild();
|
|
while (Child) {
|
|
std::string ChildVarPrefix = VarPrefix;
|
|
if (Child.getTag() == dwarf::DW_TAG_lexical_block)
|
|
ChildVarPrefix += toHex(LexicalBlockIndex++) + '.';
|
|
|
|
collectStatsRecursive(Child, UnitLowPC, FnPrefix, ChildVarPrefix, ScopeLowPC,
|
|
BytesInScope, InlineDepth, FnStatMap, GlobalStats,
|
|
LocStats);
|
|
Child = Child.getSibling();
|
|
}
|
|
}
|
|
|
|
/// Print machine-readable output.
|
|
/// The machine-readable format is single-line JSON output.
|
|
/// \{
|
|
static void printDatum(raw_ostream &OS, const char *Key, json::Value Value) {
|
|
OS << ",\"" << Key << "\":" << Value;
|
|
LLVM_DEBUG(llvm::dbgs() << Key << ": " << Value << '\n');
|
|
}
|
|
static void printLocationStats(raw_ostream &OS,
|
|
const char *Key,
|
|
std::vector<unsigned> &LocationStats) {
|
|
OS << ",\"" << Key << " with 0% of its scope covered\":"
|
|
<< LocationStats[0];
|
|
LLVM_DEBUG(llvm::dbgs() << Key << " with 0% of its scope covered: "
|
|
<< LocationStats[0] << '\n');
|
|
OS << ",\"" << Key << " with 1-9% of its scope covered\":"
|
|
<< LocationStats[1];
|
|
LLVM_DEBUG(llvm::dbgs() << Key << " with 1-9% of its scope covered: "
|
|
<< LocationStats[1] << '\n');
|
|
for (unsigned i = 2; i < NumOfCoverageCategories - 1; ++i) {
|
|
OS << ",\"" << Key << " with " << (i - 1) * 10 << "-" << i * 10 - 1
|
|
<< "% of its scope covered\":" << LocationStats[i];
|
|
LLVM_DEBUG(llvm::dbgs()
|
|
<< Key << " with " << (i - 1) * 10 << "-" << i * 10 - 1
|
|
<< "% of its scope covered: " << LocationStats[i]);
|
|
}
|
|
OS << ",\"" << Key << " with 100% of its scope covered\":"
|
|
<< LocationStats[NumOfCoverageCategories - 1];
|
|
LLVM_DEBUG(llvm::dbgs() << Key << " with 100% of its scope covered: "
|
|
<< LocationStats[NumOfCoverageCategories - 1]);
|
|
}
|
|
/// \}
|
|
|
|
/// Collect debug info quality metrics for an entire DIContext.
|
|
///
|
|
/// Do the impossible and reduce the quality of the debug info down to a few
|
|
/// numbers. The idea is to condense the data into numbers that can be tracked
|
|
/// over time to identify trends in newer compiler versions and gauge the effect
|
|
/// of particular optimizations. The raw numbers themselves are not particularly
|
|
/// useful, only the delta between compiling the same program with different
|
|
/// compilers is.
|
|
bool collectStatsForObjectFile(ObjectFile &Obj, DWARFContext &DICtx,
|
|
Twine Filename, raw_ostream &OS) {
|
|
StringRef FormatName = Obj.getFileFormatName();
|
|
GlobalStats GlobalStats;
|
|
LocationStats LocStats;
|
|
StringMap<PerFunctionStats> Statistics;
|
|
for (const auto &CU : static_cast<DWARFContext *>(&DICtx)->compile_units())
|
|
if (DWARFDie CUDie = CU->getNonSkeletonUnitDIE(false))
|
|
collectStatsRecursive(CUDie, getLowPC(CUDie), "/", "g", 0, 0, 0,
|
|
Statistics, GlobalStats, LocStats);
|
|
|
|
/// The version number should be increased every time the algorithm is changed
|
|
/// (including bug fixes). New metrics may be added without increasing the
|
|
/// version.
|
|
unsigned Version = 3;
|
|
unsigned VarParamTotal = 0;
|
|
unsigned VarParamUnique = 0;
|
|
unsigned VarParamWithLoc = 0;
|
|
unsigned NumFunctions = 0;
|
|
unsigned NumInlinedFunctions = 0;
|
|
unsigned NumFuncsWithSrcLoc = 0;
|
|
unsigned NumAbstractOrigins = 0;
|
|
unsigned ParamTotal = 0;
|
|
unsigned ParamWithType = 0;
|
|
unsigned ParamWithLoc = 0;
|
|
unsigned ParamWithSrcLoc = 0;
|
|
unsigned VarTotal = 0;
|
|
unsigned VarWithType = 0;
|
|
unsigned VarWithSrcLoc = 0;
|
|
unsigned VarWithLoc = 0;
|
|
for (auto &Entry : Statistics) {
|
|
PerFunctionStats &Stats = Entry.getValue();
|
|
unsigned TotalVars = Stats.VarsInFunction.size() * Stats.NumFnInlined;
|
|
// Count variables in concrete out-of-line functions and in global scope.
|
|
if (Stats.HasPCAddresses || !Stats.IsFunction)
|
|
TotalVars += Stats.VarsInFunction.size();
|
|
unsigned Constants = Stats.ConstantMembers;
|
|
VarParamWithLoc += Stats.TotalVarWithLoc + Constants;
|
|
VarParamTotal += TotalVars;
|
|
VarParamUnique += Stats.VarsInFunction.size();
|
|
LLVM_DEBUG(for (auto &V
|
|
: Stats.VarsInFunction) llvm::dbgs()
|
|
<< Entry.getKey() << ": " << V.getKey() << "\n");
|
|
NumFunctions += Stats.IsFunction;
|
|
NumFuncsWithSrcLoc += Stats.HasSourceLocation;
|
|
NumInlinedFunctions += Stats.IsFunction * Stats.NumFnInlined;
|
|
NumAbstractOrigins += Stats.IsFunction * Stats.NumAbstractOrigins;
|
|
ParamTotal += Stats.NumParams;
|
|
ParamWithType += Stats.NumParamTypes;
|
|
ParamWithLoc += Stats.NumParamLocations;
|
|
ParamWithSrcLoc += Stats.NumParamSourceLocations;
|
|
VarTotal += Stats.NumVars;
|
|
VarWithType += Stats.NumVarTypes;
|
|
VarWithLoc += Stats.NumVarLocations;
|
|
VarWithSrcLoc += Stats.NumVarSourceLocations;
|
|
}
|
|
|
|
// Print summary.
|
|
OS.SetBufferSize(1024);
|
|
OS << "{\"version\":" << Version;
|
|
LLVM_DEBUG(llvm::dbgs() << "Variable location quality metrics\n";
|
|
llvm::dbgs() << "---------------------------------\n");
|
|
printDatum(OS, "file", Filename.str());
|
|
printDatum(OS, "format", FormatName);
|
|
printDatum(OS, "source functions", NumFunctions);
|
|
printDatum(OS, "source functions with location", NumFuncsWithSrcLoc);
|
|
printDatum(OS, "inlined functions", NumInlinedFunctions);
|
|
printDatum(OS, "inlined funcs with abstract origins", NumAbstractOrigins);
|
|
printDatum(OS, "unique source variables", VarParamUnique);
|
|
printDatum(OS, "source variables", VarParamTotal);
|
|
printDatum(OS, "variables with location", VarParamWithLoc);
|
|
printDatum(OS, "call site entries", GlobalStats.CallSiteEntries);
|
|
printDatum(OS, "call site DIEs", GlobalStats.CallSiteDIEs);
|
|
printDatum(OS, "call site parameter DIEs", GlobalStats.CallSiteParamDIEs);
|
|
printDatum(OS, "scope bytes total",
|
|
GlobalStats.ScopeBytesFromFirstDefinition);
|
|
printDatum(OS, "scope bytes covered", GlobalStats.ScopeBytesCovered);
|
|
printDatum(OS, "entry value scope bytes covered",
|
|
GlobalStats.ScopeEntryValueBytesCovered);
|
|
printDatum(OS, "formal params scope bytes total",
|
|
GlobalStats.ParamScopeBytesFromFirstDefinition);
|
|
printDatum(OS, "formal params scope bytes covered",
|
|
GlobalStats.ParamScopeBytesCovered);
|
|
printDatum(OS, "formal params entry value scope bytes covered",
|
|
GlobalStats.ParamScopeEntryValueBytesCovered);
|
|
printDatum(OS, "vars scope bytes total",
|
|
GlobalStats.VarScopeBytesFromFirstDefinition);
|
|
printDatum(OS, "vars scope bytes covered", GlobalStats.VarScopeBytesCovered);
|
|
printDatum(OS, "vars entry value scope bytes covered",
|
|
GlobalStats.VarScopeEntryValueBytesCovered);
|
|
printDatum(OS, "total function size", GlobalStats.FunctionSize);
|
|
printDatum(OS, "total inlined function size", GlobalStats.InlineFunctionSize);
|
|
printDatum(OS, "total formal params", ParamTotal);
|
|
printDatum(OS, "formal params with source location", ParamWithSrcLoc);
|
|
printDatum(OS, "formal params with type", ParamWithType);
|
|
printDatum(OS, "formal params with binary location", ParamWithLoc);
|
|
printDatum(OS, "total vars", VarTotal);
|
|
printDatum(OS, "vars with source location", VarWithSrcLoc);
|
|
printDatum(OS, "vars with type", VarWithType);
|
|
printDatum(OS, "vars with binary location", VarWithLoc);
|
|
printDatum(OS, "total variables procesed by location statistics",
|
|
LocStats.NumVarParam);
|
|
printLocationStats(OS, "variables", LocStats.VarParamLocStats);
|
|
printLocationStats(OS, "variables (excluding the debug entry values)",
|
|
LocStats.VarParamNonEntryValLocStats);
|
|
printDatum(OS, "total params procesed by location statistics",
|
|
LocStats.NumParam);
|
|
printLocationStats(OS, "params", LocStats.ParamLocStats);
|
|
printLocationStats(OS, "params (excluding the debug entry values)",
|
|
LocStats.ParamNonEntryValLocStats);
|
|
printDatum(OS, "total vars procesed by location statistics", LocStats.NumVar);
|
|
printLocationStats(OS, "vars", LocStats.VarLocStats);
|
|
printLocationStats(OS, "vars (excluding the debug entry values)",
|
|
LocStats.ParamNonEntryValLocStats);
|
|
OS << "}\n";
|
|
LLVM_DEBUG(
|
|
llvm::dbgs() << "Total Availability: "
|
|
<< (int)std::round((VarParamWithLoc * 100.0) / VarParamTotal)
|
|
<< "%\n";
|
|
llvm::dbgs() << "PC Ranges covered: "
|
|
<< (int)std::round((GlobalStats.ScopeBytesCovered * 100.0) /
|
|
GlobalStats.ScopeBytesFromFirstDefinition)
|
|
<< "%\n");
|
|
return true;
|
|
}
|