1063 lines
43 KiB
C++
1063 lines
43 KiB
C++
//===-- Statistics.cpp - Debug Info quality metrics -----------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm-dwarfdump.h"
|
|
#include "llvm/ADT/DenseMap.h"
|
|
#include "llvm/ADT/StringSet.h"
|
|
#include "llvm/DebugInfo/DWARF/DWARFContext.h"
|
|
#include "llvm/DebugInfo/DWARF/DWARFDebugLoc.h"
|
|
#include "llvm/DebugInfo/DWARF/DWARFExpression.h"
|
|
#include "llvm/Object/ObjectFile.h"
|
|
#include "llvm/Support/JSON.h"
|
|
|
|
#define DEBUG_TYPE "dwarfdump"
|
|
using namespace llvm;
|
|
using namespace llvm::dwarfdump;
|
|
using namespace llvm::object;
|
|
|
|
namespace {
|
|
/// 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;
|
|
|
|
/// This is used for zero location coverage bucket.
|
|
constexpr unsigned ZeroCoverageBucket = 0;
|
|
|
|
/// The UINT64_MAX is used as an indication of the overflow.
|
|
constexpr uint64_t OverflowValue = std::numeric_limits<uint64_t>::max();
|
|
|
|
/// This represents variables DIE offsets.
|
|
using AbstractOriginVarsTy = llvm::SmallVector<uint64_t>;
|
|
/// This maps function DIE offset to its variables.
|
|
using AbstractOriginVarsTyMap = llvm::DenseMap<uint64_t, AbstractOriginVarsTy>;
|
|
/// This represents function DIE offsets containing an abstract_origin.
|
|
using FunctionsWithAbstractOriginTy = llvm::SmallVector<uint64_t>;
|
|
|
|
/// This represents a data type for the stats and it helps us to
|
|
/// detect an overflow.
|
|
/// NOTE: This can be implemented as a template if there is an another type
|
|
/// needing this.
|
|
struct SaturatingUINT64 {
|
|
/// Number that represents the stats.
|
|
uint64_t Value;
|
|
|
|
SaturatingUINT64(uint64_t Value_) : Value(Value_) {}
|
|
|
|
void operator++(int) { return *this += 1; }
|
|
void operator+=(uint64_t Value_) {
|
|
if (Value != OverflowValue) {
|
|
if (Value < OverflowValue - Value_)
|
|
Value += Value_;
|
|
else
|
|
Value = OverflowValue;
|
|
}
|
|
}
|
|
};
|
|
|
|
/// Utility struct to store the full location of a DIE - its CU and offset.
|
|
struct DIELocation {
|
|
DWARFUnit *DwUnit;
|
|
uint64_t DIEOffset;
|
|
DIELocation(DWARFUnit *_DwUnit, uint64_t _DIEOffset)
|
|
: DwUnit(_DwUnit), DIEOffset(_DIEOffset) {}
|
|
};
|
|
/// This represents DWARF locations of CrossCU referencing DIEs.
|
|
using CrossCUReferencingDIELocationTy = llvm::SmallVector<DIELocation>;
|
|
|
|
/// This maps function DIE offset to its DWARF CU.
|
|
using FunctionDIECUTyMap = llvm::DenseMap<uint64_t, DWARFUnit *>;
|
|
|
|
/// 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.
|
|
uint64_t NumFnInlined = 0;
|
|
/// Number of out-of-line instances of this function.
|
|
uint64_t NumFnOutOfLine = 0;
|
|
/// Number of inlined instances that have abstract origins.
|
|
uint64_t NumAbstractOrigins = 0;
|
|
/// Number of variables and parameters with location across all inlined
|
|
/// instances.
|
|
uint64_t TotalVarWithLoc = 0;
|
|
/// Number of constants with location across all inlined instances.
|
|
uint64_t ConstantMembers = 0;
|
|
/// Number of arificial variables, parameters or members across all instances.
|
|
uint64_t NumArtificial = 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;
|
|
/// Function has source location information.
|
|
bool HasSourceLocation = false;
|
|
/// Number of function parameters.
|
|
uint64_t NumParams = 0;
|
|
/// Number of function parameters with source location.
|
|
uint64_t NumParamSourceLocations = 0;
|
|
/// Number of function parameters with type.
|
|
uint64_t NumParamTypes = 0;
|
|
/// Number of function parameters with a DW_AT_location.
|
|
uint64_t NumParamLocations = 0;
|
|
/// Number of local variables.
|
|
uint64_t NumLocalVars = 0;
|
|
/// Number of local variables with source location.
|
|
uint64_t NumLocalVarSourceLocations = 0;
|
|
/// Number of local variables with type.
|
|
uint64_t NumLocalVarTypes = 0;
|
|
/// Number of local variables with DW_AT_location.
|
|
uint64_t NumLocalVarLocations = 0;
|
|
};
|
|
|
|
/// Holds accumulated global statistics about DIEs.
|
|
struct GlobalStats {
|
|
/// Total number of PC range bytes covered by DW_AT_locations.
|
|
SaturatingUINT64 TotalBytesCovered = 0;
|
|
/// Total number of parent DIE PC range bytes covered by DW_AT_Locations.
|
|
SaturatingUINT64 ScopeBytesCovered = 0;
|
|
/// Total number of PC range bytes in each variable's enclosing scope.
|
|
SaturatingUINT64 ScopeBytes = 0;
|
|
/// Total number of PC range bytes covered by DW_AT_locations with
|
|
/// the debug entry values (DW_OP_entry_value).
|
|
SaturatingUINT64 ScopeEntryValueBytesCovered = 0;
|
|
/// Total number of PC range bytes covered by DW_AT_locations of
|
|
/// formal parameters.
|
|
SaturatingUINT64 ParamScopeBytesCovered = 0;
|
|
/// Total number of PC range bytes in each parameter's enclosing scope.
|
|
SaturatingUINT64 ParamScopeBytes = 0;
|
|
/// Total number of PC range bytes covered by DW_AT_locations with
|
|
/// the debug entry values (DW_OP_entry_value) (only for parameters).
|
|
SaturatingUINT64 ParamScopeEntryValueBytesCovered = 0;
|
|
/// Total number of PC range bytes covered by DW_AT_locations (only for local
|
|
/// variables).
|
|
SaturatingUINT64 LocalVarScopeBytesCovered = 0;
|
|
/// Total number of PC range bytes in each local variable's enclosing scope.
|
|
SaturatingUINT64 LocalVarScopeBytes = 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).
|
|
SaturatingUINT64 LocalVarScopeEntryValueBytesCovered = 0;
|
|
/// Total number of call site entries (DW_AT_call_file & DW_AT_call_line).
|
|
SaturatingUINT64 CallSiteEntries = 0;
|
|
/// Total number of call site DIEs (DW_TAG_call_site).
|
|
SaturatingUINT64 CallSiteDIEs = 0;
|
|
/// Total number of call site parameter DIEs (DW_TAG_call_site_parameter).
|
|
SaturatingUINT64 CallSiteParamDIEs = 0;
|
|
/// Total byte size of concrete functions. This byte size includes
|
|
/// inline functions contained in the concrete functions.
|
|
SaturatingUINT64 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.
|
|
SaturatingUINT64 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<SaturatingUINT64> VarParamLocStats{
|
|
std::vector<SaturatingUINT64>(NumOfCoverageCategories, 0)};
|
|
/// Map non debug entry values coverage.
|
|
std::vector<SaturatingUINT64> VarParamNonEntryValLocStats{
|
|
std::vector<SaturatingUINT64>(NumOfCoverageCategories, 0)};
|
|
/// The debug location statistics for formal parameters.
|
|
std::vector<SaturatingUINT64> ParamLocStats{
|
|
std::vector<SaturatingUINT64>(NumOfCoverageCategories, 0)};
|
|
/// Map non debug entry values coverage for formal parameters.
|
|
std::vector<SaturatingUINT64> ParamNonEntryValLocStats{
|
|
std::vector<SaturatingUINT64>(NumOfCoverageCategories, 0)};
|
|
/// The debug location statistics for local variables.
|
|
std::vector<SaturatingUINT64> LocalVarLocStats{
|
|
std::vector<SaturatingUINT64>(NumOfCoverageCategories, 0)};
|
|
/// Map non debug entry values coverage for local variables.
|
|
std::vector<SaturatingUINT64> LocalVarNonEntryValLocStats{
|
|
std::vector<SaturatingUINT64>(NumOfCoverageCategories, 0)};
|
|
/// Total number of local variables and function parameters processed.
|
|
SaturatingUINT64 NumVarParam = 0;
|
|
/// Total number of formal parameters processed.
|
|
SaturatingUINT64 NumParam = 0;
|
|
/// Total number of local variables processed.
|
|
SaturatingUINT64 NumVar = 0;
|
|
};
|
|
} // namespace
|
|
|
|
/// Collect debug location statistics for one DIE.
|
|
static void collectLocStats(uint64_t ScopeBytesCovered, uint64_t BytesInScope,
|
|
std::vector<SaturatingUINT64> &VarParamLocStats,
|
|
std::vector<SaturatingUINT64> &ParamLocStats,
|
|
std::vector<SaturatingUINT64> &LocalVarLocStats,
|
|
bool IsParam, bool IsLocalVar) {
|
|
auto getCoverageBucket = [ScopeBytesCovered, BytesInScope]() -> unsigned {
|
|
// No debug location at all for the variable.
|
|
if (ScopeBytesCovered == 0)
|
|
return 0;
|
|
// Fully covered variable within its scope.
|
|
if (ScopeBytesCovered >= BytesInScope)
|
|
return NumOfCoverageCategories - 1;
|
|
// Get covered range (e.g. 20%-29%).
|
|
unsigned LocBucket = 100 * (double)ScopeBytesCovered / BytesInScope;
|
|
LocBucket /= 10;
|
|
return LocBucket + 1;
|
|
};
|
|
|
|
unsigned CoverageBucket = getCoverageBucket();
|
|
|
|
VarParamLocStats[CoverageBucket].Value++;
|
|
if (IsParam)
|
|
ParamLocStats[CoverageBucket].Value++;
|
|
else if (IsLocalVar)
|
|
LocalVarLocStats[CoverageBucket].Value++;
|
|
}
|
|
|
|
/// Construct an identifier for a given DIE from its Prefix, Name, DeclFileName
|
|
/// and DeclLine. The identifier aims to be unique for any unique entities,
|
|
/// but keeping the same among different instances of the same entity.
|
|
static std::string constructDieID(DWARFDie Die,
|
|
StringRef Prefix = StringRef()) {
|
|
std::string IDStr;
|
|
llvm::raw_string_ostream ID(IDStr);
|
|
ID << Prefix
|
|
<< Die.getName(DINameKind::LinkageName);
|
|
|
|
// Prefix + Name is enough for local variables and parameters.
|
|
if (!Prefix.empty() && !Prefix.equals("g"))
|
|
return ID.str();
|
|
|
|
auto DeclFile = Die.findRecursively(dwarf::DW_AT_decl_file);
|
|
std::string File;
|
|
if (DeclFile) {
|
|
DWARFUnit *U = Die.getDwarfUnit();
|
|
if (const auto *LT = U->getContext().getLineTableForUnit(U))
|
|
if (LT->getFileNameByIndex(
|
|
dwarf::toUnsigned(DeclFile, 0), U->getCompilationDir(),
|
|
DILineInfoSpecifier::FileLineInfoKind::AbsoluteFilePath, File))
|
|
File = std::string(sys::path::filename(File));
|
|
}
|
|
ID << ":" << (File.empty() ? "/" : File);
|
|
ID << ":"
|
|
<< dwarf::toUnsigned(Die.findRecursively(dwarf::DW_AT_decl_line), 0);
|
|
return ID.str();
|
|
}
|
|
|
|
/// Return the number of bytes in the overlap of ranges A and B.
|
|
static uint64_t calculateOverlap(DWARFAddressRange A, DWARFAddressRange B) {
|
|
uint64_t Lower = std::max(A.LowPC, B.LowPC);
|
|
uint64_t Upper = std::min(A.HighPC, B.HighPC);
|
|
if (Lower >= Upper)
|
|
return 0;
|
|
return Upper - Lower;
|
|
}
|
|
|
|
/// Collect debug info quality metrics for one DIE.
|
|
static void collectStatsForDie(DWARFDie Die, const std::string &FnPrefix,
|
|
const std::string &VarPrefix,
|
|
uint64_t BytesInScope, uint32_t InlineDepth,
|
|
StringMap<PerFunctionStats> &FnStatMap,
|
|
GlobalStats &GlobalStats,
|
|
LocationStats &LocStats,
|
|
AbstractOriginVarsTy *AbstractOriginVariables) {
|
|
const dwarf::Tag Tag = Die.getTag();
|
|
// Skip CU node.
|
|
if (Tag == dwarf::DW_TAG_compile_unit)
|
|
return;
|
|
|
|
bool HasLoc = false;
|
|
bool HasSrcLoc = false;
|
|
bool HasType = false;
|
|
uint64_t TotalBytesCovered = 0;
|
|
uint64_t ScopeBytesCovered = 0;
|
|
uint64_t BytesEntryValuesCovered = 0;
|
|
auto &FnStats = FnStatMap[FnPrefix];
|
|
bool IsParam = Tag == dwarf::DW_TAG_formal_parameter;
|
|
bool IsLocalVar = Tag == dwarf::DW_TAG_variable;
|
|
bool IsConstantMember = Tag == dwarf::DW_TAG_member &&
|
|
Die.find(dwarf::DW_AT_const_value);
|
|
|
|
// For zero covered inlined variables the locstats will be
|
|
// calculated later.
|
|
bool DeferLocStats = false;
|
|
|
|
if (Tag == dwarf::DW_TAG_call_site || Tag == dwarf::DW_TAG_GNU_call_site) {
|
|
GlobalStats.CallSiteDIEs++;
|
|
return;
|
|
}
|
|
|
|
if (Tag == dwarf::DW_TAG_call_site_parameter ||
|
|
Tag == dwarf::DW_TAG_GNU_call_site_parameter) {
|
|
GlobalStats.CallSiteParamDIEs++;
|
|
return;
|
|
}
|
|
|
|
if (!IsParam && !IsLocalVar && !IsConstantMember) {
|
|
// Not a variable or constant member.
|
|
return;
|
|
}
|
|
|
|
// Ignore declarations of global variables.
|
|
if (IsLocalVar && Die.find(dwarf::DW_AT_declaration))
|
|
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_abstract_origin)) {
|
|
if (Die.find(dwarf::DW_AT_location) || Die.find(dwarf::DW_AT_const_value)) {
|
|
if (AbstractOriginVariables) {
|
|
auto Offset = Die.find(dwarf::DW_AT_abstract_origin);
|
|
// Do not track this variable any more, since it has location
|
|
// coverage.
|
|
llvm::erase_value(*AbstractOriginVariables, (*Offset).getRawUValue());
|
|
}
|
|
} else {
|
|
// The locstats will be handled at the end of
|
|
// the collectStatsRecursive().
|
|
DeferLocStats = 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->getAddressByteSize(),
|
|
U->getFormParams().Format);
|
|
// Consider the expression containing the DW_OP_entry_value as
|
|
// an entry value.
|
|
return llvm::any_of(Expression, [](const 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;
|
|
ScopeBytesCovered = BytesInScope;
|
|
TotalBytesCovered = BytesInScope;
|
|
} else {
|
|
// Handle variables and function arguments.
|
|
Expected<std::vector<DWARFLocationExpression>> Loc =
|
|
Die.getLocations(dwarf::DW_AT_location);
|
|
if (!Loc) {
|
|
consumeError(Loc.takeError());
|
|
} else {
|
|
HasLoc = true;
|
|
// Get PC coverage.
|
|
auto Default = find_if(
|
|
*Loc, [](const DWARFLocationExpression &L) { return !L.Range; });
|
|
if (Default != Loc->end()) {
|
|
// Assume the entire range is covered by a single location.
|
|
ScopeBytesCovered = BytesInScope;
|
|
TotalBytesCovered = BytesInScope;
|
|
} else {
|
|
// Caller checks this Expected result already, it cannot fail.
|
|
auto ScopeRanges = cantFail(Die.getParent().getAddressRanges());
|
|
for (auto Entry : *Loc) {
|
|
TotalBytesCovered += Entry.Range->HighPC - Entry.Range->LowPC;
|
|
uint64_t ScopeBytesCoveredByEntry = 0;
|
|
// Calculate how many bytes of the parent scope this entry covers.
|
|
// FIXME: In section 2.6.2 of the DWARFv5 spec it says that "The
|
|
// address ranges defined by the bounded location descriptions of a
|
|
// location list may overlap". So in theory a variable can have
|
|
// multiple simultaneous locations, which would make this calculation
|
|
// misleading because we will count the overlapped areas
|
|
// twice. However, clang does not currently emit DWARF like this.
|
|
for (DWARFAddressRange R : ScopeRanges) {
|
|
ScopeBytesCoveredByEntry += calculateOverlap(*Entry.Range, R);
|
|
}
|
|
ScopeBytesCovered += ScopeBytesCoveredByEntry;
|
|
if (IsEntryValue(Entry.Expr))
|
|
BytesEntryValuesCovered += ScopeBytesCoveredByEntry;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Calculate the debug location statistics.
|
|
if (BytesInScope && !DeferLocStats) {
|
|
LocStats.NumVarParam.Value++;
|
|
if (IsParam)
|
|
LocStats.NumParam.Value++;
|
|
else if (IsLocalVar)
|
|
LocStats.NumVar.Value++;
|
|
|
|
collectLocStats(ScopeBytesCovered, BytesInScope, LocStats.VarParamLocStats,
|
|
LocStats.ParamLocStats, LocStats.LocalVarLocStats, IsParam,
|
|
IsLocalVar);
|
|
// Non debug entry values coverage statistics.
|
|
collectLocStats(ScopeBytesCovered - BytesEntryValuesCovered, BytesInScope,
|
|
LocStats.VarParamNonEntryValLocStats,
|
|
LocStats.ParamNonEntryValLocStats,
|
|
LocStats.LocalVarNonEntryValLocStats, IsParam, IsLocalVar);
|
|
}
|
|
|
|
// Collect PC range coverage data.
|
|
if (DWARFDie D =
|
|
Die.getAttributeValueAsReferencedDie(dwarf::DW_AT_abstract_origin))
|
|
Die = D;
|
|
|
|
std::string VarID = constructDieID(Die, VarPrefix);
|
|
FnStats.VarsInFunction.insert(VarID);
|
|
|
|
GlobalStats.TotalBytesCovered += TotalBytesCovered;
|
|
if (BytesInScope) {
|
|
GlobalStats.ScopeBytesCovered += ScopeBytesCovered;
|
|
GlobalStats.ScopeBytes += BytesInScope;
|
|
GlobalStats.ScopeEntryValueBytesCovered += BytesEntryValuesCovered;
|
|
if (IsParam) {
|
|
GlobalStats.ParamScopeBytesCovered += ScopeBytesCovered;
|
|
GlobalStats.ParamScopeBytes += BytesInScope;
|
|
GlobalStats.ParamScopeEntryValueBytesCovered += BytesEntryValuesCovered;
|
|
} else if (IsLocalVar) {
|
|
GlobalStats.LocalVarScopeBytesCovered += ScopeBytesCovered;
|
|
GlobalStats.LocalVarScopeBytes += BytesInScope;
|
|
GlobalStats.LocalVarScopeEntryValueBytesCovered +=
|
|
BytesEntryValuesCovered;
|
|
}
|
|
assert(GlobalStats.ScopeBytesCovered.Value <= GlobalStats.ScopeBytes.Value);
|
|
}
|
|
|
|
if (IsConstantMember) {
|
|
FnStats.ConstantMembers++;
|
|
return;
|
|
}
|
|
|
|
FnStats.TotalVarWithLoc += (unsigned)HasLoc;
|
|
|
|
if (Die.find(dwarf::DW_AT_artificial)) {
|
|
FnStats.NumArtificial++;
|
|
return;
|
|
}
|
|
|
|
if (IsParam) {
|
|
FnStats.NumParams++;
|
|
if (HasType)
|
|
FnStats.NumParamTypes++;
|
|
if (HasSrcLoc)
|
|
FnStats.NumParamSourceLocations++;
|
|
if (HasLoc)
|
|
FnStats.NumParamLocations++;
|
|
} else if (IsLocalVar) {
|
|
FnStats.NumLocalVars++;
|
|
if (HasType)
|
|
FnStats.NumLocalVarTypes++;
|
|
if (HasSrcLoc)
|
|
FnStats.NumLocalVarSourceLocations++;
|
|
if (HasLoc)
|
|
FnStats.NumLocalVarLocations++;
|
|
}
|
|
}
|
|
|
|
/// Recursively collect variables from subprogram with DW_AT_inline attribute.
|
|
static void collectAbstractOriginFnInfo(
|
|
DWARFDie Die, uint64_t SPOffset,
|
|
AbstractOriginVarsTyMap &GlobalAbstractOriginFnInfo,
|
|
AbstractOriginVarsTyMap &LocalAbstractOriginFnInfo) {
|
|
DWARFDie Child = Die.getFirstChild();
|
|
while (Child) {
|
|
const dwarf::Tag ChildTag = Child.getTag();
|
|
if (ChildTag == dwarf::DW_TAG_formal_parameter ||
|
|
ChildTag == dwarf::DW_TAG_variable) {
|
|
GlobalAbstractOriginFnInfo[SPOffset].push_back(Child.getOffset());
|
|
LocalAbstractOriginFnInfo[SPOffset].push_back(Child.getOffset());
|
|
} else if (ChildTag == dwarf::DW_TAG_lexical_block)
|
|
collectAbstractOriginFnInfo(Child, SPOffset, GlobalAbstractOriginFnInfo,
|
|
LocalAbstractOriginFnInfo);
|
|
Child = Child.getSibling();
|
|
}
|
|
}
|
|
|
|
/// Recursively collect debug info quality metrics.
|
|
static void collectStatsRecursive(
|
|
DWARFDie Die, std::string FnPrefix, std::string VarPrefix,
|
|
uint64_t BytesInScope, uint32_t InlineDepth,
|
|
StringMap<PerFunctionStats> &FnStatMap, GlobalStats &GlobalStats,
|
|
LocationStats &LocStats, FunctionDIECUTyMap &AbstractOriginFnCUs,
|
|
AbstractOriginVarsTyMap &GlobalAbstractOriginFnInfo,
|
|
AbstractOriginVarsTyMap &LocalAbstractOriginFnInfo,
|
|
FunctionsWithAbstractOriginTy &FnsWithAbstractOriginToBeProcessed,
|
|
AbstractOriginVarsTy *AbstractOriginVarsPtr = nullptr) {
|
|
// Skip NULL nodes.
|
|
if (Die.isNULL())
|
|
return;
|
|
|
|
const dwarf::Tag Tag = Die.getTag();
|
|
// Skip function types.
|
|
if (Tag == dwarf::DW_TAG_subroutine_type)
|
|
return;
|
|
|
|
// Handle any kind of lexical scope.
|
|
const bool HasAbstractOrigin = Die.find(dwarf::DW_AT_abstract_origin) != None;
|
|
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;
|
|
// We want to know how many variables (with abstract_origin) don't have
|
|
// location info.
|
|
const bool IsCandidateForZeroLocCovTracking =
|
|
(IsInlinedFunction || (IsFunction && HasAbstractOrigin));
|
|
|
|
AbstractOriginVarsTy AbstractOriginVars;
|
|
|
|
// Get the vars of the inlined fn, so the locstats
|
|
// reports the missing vars (with coverage 0%).
|
|
if (IsCandidateForZeroLocCovTracking) {
|
|
auto OffsetFn = Die.find(dwarf::DW_AT_abstract_origin);
|
|
if (OffsetFn) {
|
|
uint64_t OffsetOfInlineFnCopy = (*OffsetFn).getRawUValue();
|
|
if (LocalAbstractOriginFnInfo.count(OffsetOfInlineFnCopy)) {
|
|
AbstractOriginVars = LocalAbstractOriginFnInfo[OffsetOfInlineFnCopy];
|
|
AbstractOriginVarsPtr = &AbstractOriginVars;
|
|
} else {
|
|
// This means that the DW_AT_inline fn copy is out of order
|
|
// or that the abstract_origin references another CU,
|
|
// so this abstract origin instance will be processed later.
|
|
FnsWithAbstractOriginToBeProcessed.push_back(Die.getOffset());
|
|
AbstractOriginVarsPtr = nullptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (IsFunction || IsInlinedFunction || IsBlock) {
|
|
// Reset VarPrefix when entering a new function.
|
|
if (IsFunction || IsInlinedFunction)
|
|
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;
|
|
|
|
// Count the function.
|
|
if (!IsBlock) {
|
|
// Skip over abstract origins, but collect variables
|
|
// from it so it can be used for location statistics
|
|
// for inlined instancies.
|
|
if (Die.find(dwarf::DW_AT_inline)) {
|
|
uint64_t SPOffset = Die.getOffset();
|
|
AbstractOriginFnCUs[SPOffset] = Die.getDwarfUnit();
|
|
collectAbstractOriginFnInfo(Die, SPOffset, GlobalAbstractOriginFnInfo,
|
|
LocalAbstractOriginFnInfo);
|
|
return;
|
|
}
|
|
|
|
std::string FnID = constructDieID(Die);
|
|
// We've seen an instance of this function.
|
|
auto &FnStats = FnStatMap[FnID];
|
|
FnStats.IsFunction = true;
|
|
if (IsInlinedFunction) {
|
|
FnStats.NumFnInlined++;
|
|
if (Die.findRecursively(dwarf::DW_AT_abstract_origin))
|
|
FnStats.NumAbstractOrigins++;
|
|
} else {
|
|
FnStats.NumFnOutOfLine++;
|
|
}
|
|
if (Die.findRecursively(dwarf::DW_AT_decl_file) &&
|
|
Die.findRecursively(dwarf::DW_AT_decl_line))
|
|
FnStats.HasSourceLocation = true;
|
|
// Update function prefix.
|
|
FnPrefix = FnID;
|
|
}
|
|
|
|
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, FnPrefix, VarPrefix, BytesInScope, InlineDepth,
|
|
FnStatMap, GlobalStats, LocStats, AbstractOriginVarsPtr);
|
|
}
|
|
|
|
// Set InlineDepth correctly for child recursion
|
|
if (IsFunction)
|
|
InlineDepth = 0;
|
|
else if (IsInlinedFunction)
|
|
++InlineDepth;
|
|
|
|
// Traverse children.
|
|
unsigned LexicalBlockIndex = 0;
|
|
unsigned FormalParameterIndex = 0;
|
|
DWARFDie Child = Die.getFirstChild();
|
|
while (Child) {
|
|
std::string ChildVarPrefix = VarPrefix;
|
|
if (Child.getTag() == dwarf::DW_TAG_lexical_block)
|
|
ChildVarPrefix += toHex(LexicalBlockIndex++) + '.';
|
|
if (Child.getTag() == dwarf::DW_TAG_formal_parameter)
|
|
ChildVarPrefix += 'p' + toHex(FormalParameterIndex++) + '.';
|
|
|
|
collectStatsRecursive(
|
|
Child, FnPrefix, ChildVarPrefix, BytesInScope, InlineDepth, FnStatMap,
|
|
GlobalStats, LocStats, AbstractOriginFnCUs, GlobalAbstractOriginFnInfo,
|
|
LocalAbstractOriginFnInfo, FnsWithAbstractOriginToBeProcessed,
|
|
AbstractOriginVarsPtr);
|
|
Child = Child.getSibling();
|
|
}
|
|
|
|
if (!IsCandidateForZeroLocCovTracking)
|
|
return;
|
|
|
|
// After we have processed all vars of the inlined function (or function with
|
|
// an abstract_origin), we want to know how many variables have no location.
|
|
for (auto Offset : AbstractOriginVars) {
|
|
LocStats.NumVarParam++;
|
|
LocStats.VarParamLocStats[ZeroCoverageBucket]++;
|
|
auto FnDie = Die.getDwarfUnit()->getDIEForOffset(Offset);
|
|
if (!FnDie)
|
|
continue;
|
|
auto Tag = FnDie.getTag();
|
|
if (Tag == dwarf::DW_TAG_formal_parameter) {
|
|
LocStats.NumParam++;
|
|
LocStats.ParamLocStats[ZeroCoverageBucket]++;
|
|
} else if (Tag == dwarf::DW_TAG_variable) {
|
|
LocStats.NumVar++;
|
|
LocStats.LocalVarLocStats[ZeroCoverageBucket]++;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Print human-readable output.
|
|
/// \{
|
|
static void printDatum(json::OStream &J, const char *Key, json::Value Value) {
|
|
if (Value == OverflowValue)
|
|
J.attribute(Key, "overflowed");
|
|
else
|
|
J.attribute(Key, Value);
|
|
|
|
LLVM_DEBUG(llvm::dbgs() << Key << ": " << Value << '\n');
|
|
}
|
|
|
|
static void printLocationStats(json::OStream &J, const char *Key,
|
|
std::vector<SaturatingUINT64> &LocationStats) {
|
|
if (LocationStats[0].Value == OverflowValue)
|
|
J.attribute((Twine(Key) +
|
|
" with (0%,10%) of parent scope covered by DW_AT_location")
|
|
.str(),
|
|
"overflowed");
|
|
else
|
|
J.attribute(
|
|
(Twine(Key) + " with 0% of parent scope covered by DW_AT_location")
|
|
.str(),
|
|
LocationStats[0].Value);
|
|
LLVM_DEBUG(
|
|
llvm::dbgs() << Key
|
|
<< " with 0% of parent scope covered by DW_AT_location: \\"
|
|
<< LocationStats[0].Value << '\n');
|
|
|
|
if (LocationStats[1].Value == OverflowValue)
|
|
J.attribute((Twine(Key) +
|
|
" with (0%,10%) of parent scope covered by DW_AT_location")
|
|
.str(),
|
|
"overflowed");
|
|
else
|
|
J.attribute((Twine(Key) +
|
|
" with (0%,10%) of parent scope covered by DW_AT_location")
|
|
.str(),
|
|
LocationStats[1].Value);
|
|
LLVM_DEBUG(llvm::dbgs()
|
|
<< Key
|
|
<< " with (0%,10%) of parent scope covered by DW_AT_location: "
|
|
<< LocationStats[1].Value << '\n');
|
|
|
|
for (unsigned i = 2; i < NumOfCoverageCategories - 1; ++i) {
|
|
if (LocationStats[i].Value == OverflowValue)
|
|
J.attribute((Twine(Key) + " with [" + Twine((i - 1) * 10) + "%," +
|
|
Twine(i * 10) +
|
|
"%) of parent scope covered by DW_AT_location")
|
|
.str(),
|
|
"overflowed");
|
|
else
|
|
J.attribute((Twine(Key) + " with [" + Twine((i - 1) * 10) + "%," +
|
|
Twine(i * 10) +
|
|
"%) of parent scope covered by DW_AT_location")
|
|
.str(),
|
|
LocationStats[i].Value);
|
|
LLVM_DEBUG(llvm::dbgs()
|
|
<< Key << " with [" << (i - 1) * 10 << "%," << i * 10
|
|
<< "%) of parent scope covered by DW_AT_location: "
|
|
<< LocationStats[i].Value);
|
|
}
|
|
if (LocationStats[NumOfCoverageCategories - 1].Value == OverflowValue)
|
|
J.attribute(
|
|
(Twine(Key) + " with 100% of parent scope covered by DW_AT_location")
|
|
.str(),
|
|
"overflowed");
|
|
else
|
|
J.attribute(
|
|
(Twine(Key) + " with 100% of parent scope covered by DW_AT_location")
|
|
.str(),
|
|
LocationStats[NumOfCoverageCategories - 1].Value);
|
|
LLVM_DEBUG(
|
|
llvm::dbgs() << Key
|
|
<< " with 100% of parent scope covered by DW_AT_location: "
|
|
<< LocationStats[NumOfCoverageCategories - 1].Value);
|
|
}
|
|
|
|
static void printSectionSizes(json::OStream &J, const SectionSizes &Sizes) {
|
|
for (const auto &It : Sizes.DebugSectionSizes)
|
|
J.attribute((Twine("#bytes in ") + It.first).str(), int64_t(It.second));
|
|
}
|
|
|
|
/// Stop tracking variables that contain abstract_origin with a location.
|
|
/// This is used for out-of-order DW_AT_inline subprograms only.
|
|
static void updateVarsWithAbstractOriginLocCovInfo(
|
|
DWARFDie FnDieWithAbstractOrigin,
|
|
AbstractOriginVarsTy &AbstractOriginVars) {
|
|
DWARFDie Child = FnDieWithAbstractOrigin.getFirstChild();
|
|
while (Child) {
|
|
const dwarf::Tag ChildTag = Child.getTag();
|
|
if ((ChildTag == dwarf::DW_TAG_formal_parameter ||
|
|
ChildTag == dwarf::DW_TAG_variable) &&
|
|
(Child.find(dwarf::DW_AT_location) ||
|
|
Child.find(dwarf::DW_AT_const_value))) {
|
|
auto OffsetVar = Child.find(dwarf::DW_AT_abstract_origin);
|
|
if (OffsetVar)
|
|
llvm::erase_value(AbstractOriginVars, (*OffsetVar).getRawUValue());
|
|
} else if (ChildTag == dwarf::DW_TAG_lexical_block)
|
|
updateVarsWithAbstractOriginLocCovInfo(Child, AbstractOriginVars);
|
|
Child = Child.getSibling();
|
|
}
|
|
}
|
|
|
|
/// Collect zero location coverage for inlined variables which refer to
|
|
/// a DW_AT_inline copy of subprogram that is out of order in the DWARF.
|
|
/// Also cover the variables of a concrete function (represented with
|
|
/// the DW_TAG_subprogram) with an abstract_origin attribute.
|
|
static void collectZeroLocCovForVarsWithAbstractOrigin(
|
|
DWARFUnit *DwUnit, GlobalStats &GlobalStats, LocationStats &LocStats,
|
|
AbstractOriginVarsTyMap &LocalAbstractOriginFnInfo,
|
|
FunctionsWithAbstractOriginTy &FnsWithAbstractOriginToBeProcessed) {
|
|
// The next variable is used to filter out functions that have been processed,
|
|
// leaving FnsWithAbstractOriginToBeProcessed with just CrossCU references.
|
|
FunctionsWithAbstractOriginTy ProcessedFns;
|
|
for (auto FnOffset : FnsWithAbstractOriginToBeProcessed) {
|
|
DWARFDie FnDieWithAbstractOrigin = DwUnit->getDIEForOffset(FnOffset);
|
|
auto FnCopy = FnDieWithAbstractOrigin.find(dwarf::DW_AT_abstract_origin);
|
|
AbstractOriginVarsTy AbstractOriginVars;
|
|
if (!FnCopy)
|
|
continue;
|
|
uint64_t FnCopyRawUValue = (*FnCopy).getRawUValue();
|
|
// If there is no entry within LocalAbstractOriginFnInfo for the given
|
|
// FnCopyRawUValue, function isn't out-of-order in DWARF. Rather, we have
|
|
// CrossCU referencing.
|
|
if (!LocalAbstractOriginFnInfo.count(FnCopyRawUValue))
|
|
continue;
|
|
AbstractOriginVars = LocalAbstractOriginFnInfo[FnCopyRawUValue];
|
|
updateVarsWithAbstractOriginLocCovInfo(FnDieWithAbstractOrigin,
|
|
AbstractOriginVars);
|
|
|
|
for (auto Offset : AbstractOriginVars) {
|
|
LocStats.NumVarParam++;
|
|
LocStats.VarParamLocStats[ZeroCoverageBucket]++;
|
|
auto Tag = DwUnit->getDIEForOffset(Offset).getTag();
|
|
if (Tag == dwarf::DW_TAG_formal_parameter) {
|
|
LocStats.NumParam++;
|
|
LocStats.ParamLocStats[ZeroCoverageBucket]++;
|
|
} else if (Tag == dwarf::DW_TAG_variable) {
|
|
LocStats.NumVar++;
|
|
LocStats.LocalVarLocStats[ZeroCoverageBucket]++;
|
|
}
|
|
}
|
|
ProcessedFns.push_back(FnOffset);
|
|
}
|
|
for (auto ProcessedFn : ProcessedFns)
|
|
llvm::erase_value(FnsWithAbstractOriginToBeProcessed, ProcessedFn);
|
|
}
|
|
|
|
/// Collect zero location coverage for inlined variables which refer to
|
|
/// a DW_AT_inline copy of subprogram that is in a different CU.
|
|
static void collectZeroLocCovForVarsWithCrossCUReferencingAbstractOrigin(
|
|
LocationStats &LocStats, FunctionDIECUTyMap AbstractOriginFnCUs,
|
|
AbstractOriginVarsTyMap &GlobalAbstractOriginFnInfo,
|
|
CrossCUReferencingDIELocationTy &CrossCUReferencesToBeResolved) {
|
|
for (const auto &CrossCUReferenceToBeResolved :
|
|
CrossCUReferencesToBeResolved) {
|
|
DWARFUnit *DwUnit = CrossCUReferenceToBeResolved.DwUnit;
|
|
DWARFDie FnDIEWithCrossCUReferencing =
|
|
DwUnit->getDIEForOffset(CrossCUReferenceToBeResolved.DIEOffset);
|
|
auto FnCopy =
|
|
FnDIEWithCrossCUReferencing.find(dwarf::DW_AT_abstract_origin);
|
|
if (!FnCopy)
|
|
continue;
|
|
uint64_t FnCopyRawUValue = (*FnCopy).getRawUValue();
|
|
AbstractOriginVarsTy AbstractOriginVars =
|
|
GlobalAbstractOriginFnInfo[FnCopyRawUValue];
|
|
updateVarsWithAbstractOriginLocCovInfo(FnDIEWithCrossCUReferencing,
|
|
AbstractOriginVars);
|
|
for (auto Offset : AbstractOriginVars) {
|
|
LocStats.NumVarParam++;
|
|
LocStats.VarParamLocStats[ZeroCoverageBucket]++;
|
|
auto Tag = (AbstractOriginFnCUs[FnCopyRawUValue])
|
|
->getDIEForOffset(Offset)
|
|
.getTag();
|
|
if (Tag == dwarf::DW_TAG_formal_parameter) {
|
|
LocStats.NumParam++;
|
|
LocStats.ParamLocStats[ZeroCoverageBucket]++;
|
|
} else if (Tag == dwarf::DW_TAG_variable) {
|
|
LocStats.NumVar++;
|
|
LocStats.LocalVarLocStats[ZeroCoverageBucket]++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// \}
|
|
|
|
/// 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 dwarfdump::collectStatsForObjectFile(ObjectFile &Obj, DWARFContext &DICtx,
|
|
const Twine &Filename,
|
|
raw_ostream &OS) {
|
|
StringRef FormatName = Obj.getFileFormatName();
|
|
GlobalStats GlobalStats;
|
|
LocationStats LocStats;
|
|
StringMap<PerFunctionStats> Statistics;
|
|
// This variable holds variable information for functions with
|
|
// abstract_origin globally, across all CUs.
|
|
AbstractOriginVarsTyMap GlobalAbstractOriginFnInfo;
|
|
// This variable holds information about the CU of a function with
|
|
// abstract_origin.
|
|
FunctionDIECUTyMap AbstractOriginFnCUs;
|
|
CrossCUReferencingDIELocationTy CrossCUReferencesToBeResolved;
|
|
for (const auto &CU : static_cast<DWARFContext *>(&DICtx)->compile_units()) {
|
|
if (DWARFDie CUDie = CU->getNonSkeletonUnitDIE(false)) {
|
|
// This variable holds variable information for functions with
|
|
// abstract_origin, but just for the current CU.
|
|
AbstractOriginVarsTyMap LocalAbstractOriginFnInfo;
|
|
FunctionsWithAbstractOriginTy FnsWithAbstractOriginToBeProcessed;
|
|
|
|
collectStatsRecursive(
|
|
CUDie, "/", "g", 0, 0, Statistics, GlobalStats, LocStats,
|
|
AbstractOriginFnCUs, GlobalAbstractOriginFnInfo,
|
|
LocalAbstractOriginFnInfo, FnsWithAbstractOriginToBeProcessed);
|
|
|
|
// collectZeroLocCovForVarsWithAbstractOrigin will filter out all
|
|
// out-of-order DWARF functions that have been processed within it,
|
|
// leaving FnsWithAbstractOriginToBeProcessed with only CrossCU
|
|
// references.
|
|
collectZeroLocCovForVarsWithAbstractOrigin(
|
|
CUDie.getDwarfUnit(), GlobalStats, LocStats,
|
|
LocalAbstractOriginFnInfo, FnsWithAbstractOriginToBeProcessed);
|
|
|
|
// Collect all CrossCU references into CrossCUReferencesToBeResolved.
|
|
for (auto CrossCUReferencingDIEOffset :
|
|
FnsWithAbstractOriginToBeProcessed)
|
|
CrossCUReferencesToBeResolved.push_back(
|
|
DIELocation(CUDie.getDwarfUnit(), CrossCUReferencingDIEOffset));
|
|
}
|
|
}
|
|
|
|
/// Resolve CrossCU references.
|
|
collectZeroLocCovForVarsWithCrossCUReferencingAbstractOrigin(
|
|
LocStats, AbstractOriginFnCUs, GlobalAbstractOriginFnInfo,
|
|
CrossCUReferencesToBeResolved);
|
|
|
|
/// Collect the sizes of debug sections.
|
|
SectionSizes Sizes;
|
|
calculateSectionSizes(Obj, Sizes, Filename);
|
|
|
|
/// 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 = 9;
|
|
SaturatingUINT64 VarParamTotal = 0;
|
|
SaturatingUINT64 VarParamUnique = 0;
|
|
SaturatingUINT64 VarParamWithLoc = 0;
|
|
SaturatingUINT64 NumFunctions = 0;
|
|
SaturatingUINT64 NumInlinedFunctions = 0;
|
|
SaturatingUINT64 NumFuncsWithSrcLoc = 0;
|
|
SaturatingUINT64 NumAbstractOrigins = 0;
|
|
SaturatingUINT64 ParamTotal = 0;
|
|
SaturatingUINT64 ParamWithType = 0;
|
|
SaturatingUINT64 ParamWithLoc = 0;
|
|
SaturatingUINT64 ParamWithSrcLoc = 0;
|
|
SaturatingUINT64 LocalVarTotal = 0;
|
|
SaturatingUINT64 LocalVarWithType = 0;
|
|
SaturatingUINT64 LocalVarWithSrcLoc = 0;
|
|
SaturatingUINT64 LocalVarWithLoc = 0;
|
|
for (auto &Entry : Statistics) {
|
|
PerFunctionStats &Stats = Entry.getValue();
|
|
uint64_t TotalVars = Stats.VarsInFunction.size() *
|
|
(Stats.NumFnInlined + Stats.NumFnOutOfLine);
|
|
// Count variables in global scope.
|
|
if (!Stats.IsFunction)
|
|
TotalVars =
|
|
Stats.NumLocalVars + Stats.ConstantMembers + Stats.NumArtificial;
|
|
uint64_t 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;
|
|
LocalVarTotal += Stats.NumLocalVars;
|
|
LocalVarWithType += Stats.NumLocalVarTypes;
|
|
LocalVarWithLoc += Stats.NumLocalVarLocations;
|
|
LocalVarWithSrcLoc += Stats.NumLocalVarSourceLocations;
|
|
}
|
|
|
|
// Print summary.
|
|
OS.SetBufferSize(1024);
|
|
json::OStream J(OS, 2);
|
|
J.objectBegin();
|
|
J.attribute("version", Version);
|
|
LLVM_DEBUG(llvm::dbgs() << "Variable location quality metrics\n";
|
|
llvm::dbgs() << "---------------------------------\n");
|
|
|
|
printDatum(J, "file", Filename.str());
|
|
printDatum(J, "format", FormatName);
|
|
|
|
printDatum(J, "#functions", NumFunctions.Value);
|
|
printDatum(J, "#functions with location", NumFuncsWithSrcLoc.Value);
|
|
printDatum(J, "#inlined functions", NumInlinedFunctions.Value);
|
|
printDatum(J, "#inlined functions with abstract origins",
|
|
NumAbstractOrigins.Value);
|
|
|
|
// This includes local variables and formal parameters.
|
|
printDatum(J, "#unique source variables", VarParamUnique.Value);
|
|
printDatum(J, "#source variables", VarParamTotal.Value);
|
|
printDatum(J, "#source variables with location", VarParamWithLoc.Value);
|
|
|
|
printDatum(J, "#call site entries", GlobalStats.CallSiteEntries.Value);
|
|
printDatum(J, "#call site DIEs", GlobalStats.CallSiteDIEs.Value);
|
|
printDatum(J, "#call site parameter DIEs",
|
|
GlobalStats.CallSiteParamDIEs.Value);
|
|
|
|
printDatum(J, "sum_all_variables(#bytes in parent scope)",
|
|
GlobalStats.ScopeBytes.Value);
|
|
printDatum(J,
|
|
"sum_all_variables(#bytes in any scope covered by DW_AT_location)",
|
|
GlobalStats.TotalBytesCovered.Value);
|
|
printDatum(J,
|
|
"sum_all_variables(#bytes in parent scope covered by "
|
|
"DW_AT_location)",
|
|
GlobalStats.ScopeBytesCovered.Value);
|
|
printDatum(J,
|
|
"sum_all_variables(#bytes in parent scope covered by "
|
|
"DW_OP_entry_value)",
|
|
GlobalStats.ScopeEntryValueBytesCovered.Value);
|
|
|
|
printDatum(J, "sum_all_params(#bytes in parent scope)",
|
|
GlobalStats.ParamScopeBytes.Value);
|
|
printDatum(J,
|
|
"sum_all_params(#bytes in parent scope covered by DW_AT_location)",
|
|
GlobalStats.ParamScopeBytesCovered.Value);
|
|
printDatum(J,
|
|
"sum_all_params(#bytes in parent scope covered by "
|
|
"DW_OP_entry_value)",
|
|
GlobalStats.ParamScopeEntryValueBytesCovered.Value);
|
|
|
|
printDatum(J, "sum_all_local_vars(#bytes in parent scope)",
|
|
GlobalStats.LocalVarScopeBytes.Value);
|
|
printDatum(J,
|
|
"sum_all_local_vars(#bytes in parent scope covered by "
|
|
"DW_AT_location)",
|
|
GlobalStats.LocalVarScopeBytesCovered.Value);
|
|
printDatum(J,
|
|
"sum_all_local_vars(#bytes in parent scope covered by "
|
|
"DW_OP_entry_value)",
|
|
GlobalStats.LocalVarScopeEntryValueBytesCovered.Value);
|
|
|
|
printDatum(J, "#bytes within functions", GlobalStats.FunctionSize.Value);
|
|
printDatum(J, "#bytes within inlined functions",
|
|
GlobalStats.InlineFunctionSize.Value);
|
|
|
|
// Print the summary for formal parameters.
|
|
printDatum(J, "#params", ParamTotal.Value);
|
|
printDatum(J, "#params with source location", ParamWithSrcLoc.Value);
|
|
printDatum(J, "#params with type", ParamWithType.Value);
|
|
printDatum(J, "#params with binary location", ParamWithLoc.Value);
|
|
|
|
// Print the summary for local variables.
|
|
printDatum(J, "#local vars", LocalVarTotal.Value);
|
|
printDatum(J, "#local vars with source location", LocalVarWithSrcLoc.Value);
|
|
printDatum(J, "#local vars with type", LocalVarWithType.Value);
|
|
printDatum(J, "#local vars with binary location", LocalVarWithLoc.Value);
|
|
|
|
// Print the debug section sizes.
|
|
printSectionSizes(J, Sizes);
|
|
|
|
// Print the location statistics for variables (includes local variables
|
|
// and formal parameters).
|
|
printDatum(J, "#variables processed by location statistics",
|
|
LocStats.NumVarParam.Value);
|
|
printLocationStats(J, "#variables", LocStats.VarParamLocStats);
|
|
printLocationStats(J, "#variables - entry values",
|
|
LocStats.VarParamNonEntryValLocStats);
|
|
|
|
// Print the location statistics for formal parameters.
|
|
printDatum(J, "#params processed by location statistics",
|
|
LocStats.NumParam.Value);
|
|
printLocationStats(J, "#params", LocStats.ParamLocStats);
|
|
printLocationStats(J, "#params - entry values",
|
|
LocStats.ParamNonEntryValLocStats);
|
|
|
|
// Print the location statistics for local variables.
|
|
printDatum(J, "#local vars processed by location statistics",
|
|
LocStats.NumVar.Value);
|
|
printLocationStats(J, "#local vars", LocStats.LocalVarLocStats);
|
|
printLocationStats(J, "#local vars - entry values",
|
|
LocStats.LocalVarNonEntryValLocStats);
|
|
J.objectEnd();
|
|
OS << '\n';
|
|
LLVM_DEBUG(
|
|
llvm::dbgs() << "Total Availability: "
|
|
<< (VarParamTotal.Value
|
|
? (int)std::round((VarParamWithLoc.Value * 100.0) /
|
|
VarParamTotal.Value)
|
|
: 0)
|
|
<< "%\n";
|
|
llvm::dbgs() << "PC Ranges covered: "
|
|
<< (GlobalStats.ScopeBytes.Value
|
|
? (int)std::round(
|
|
(GlobalStats.ScopeBytesCovered.Value * 100.0) /
|
|
GlobalStats.ScopeBytes.Value)
|
|
: 0)
|
|
<< "%\n");
|
|
return true;
|
|
}
|