RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-10-19 19:12:56 +02:00
Code Issues Projects Releases Wiki Activity
b90e1fddd8
llvm-mirror/lib/CodeGen/AsmPrinter/DbgEntityHistoryCalculator.cpp
OCHyams 463930d1cb [DwarfDebug] Improve single location detection in validThroughout (2/4) 
With this patch we're now accounting for two more cases which should be
considered 'valid throughout': First, where RangeEnd is ScopeEnd. Second, where
RangeEnd comes before ScopeEnd when including meta instructions, but are both
preceded by the same non-meta instruction.

CTMark shows a geomean binary size reduction of 1.5% for RelWithDebInfo builds.
`llvm-locstats` (using D85636) shows a very small variable location coverage
change in 2 of 10 binaries, but it is in the order of 10s of bytes which lines
up with my expectations.

I've added a test which checks both of these new cases. The first check in the
test isn't strictly necessary for this patch. But I'm not sure that it is
explicitly tested anywhere else, and is useful for the final patch in the
series.

Reviewed By: aprantl

Differential Revision: https://reviews.llvm.org/D86151
2020-08-27 11:52:29 +01:00

562 lines
23 KiB
C++
Raw Blame History

//===- llvm/CodeGen/AsmPrinter/DbgEntityHistoryCalculator.cpp -------------===//
//
// 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/CodeGen/DbgEntityHistoryCalculator.h"
#include "llvm/ADT/BitVector.h"
#include "llvm/ADT/Optional.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallSet.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/CodeGen/LexicalScopes.h"
#include "llvm/CodeGen/MachineBasicBlock.h"
#include "llvm/CodeGen/MachineFunction.h"
#include "llvm/CodeGen/MachineInstr.h"
#include "llvm/CodeGen/MachineOperand.h"
#include "llvm/CodeGen/TargetLowering.h"
#include "llvm/CodeGen/TargetRegisterInfo.h"
#include "llvm/CodeGen/TargetSubtargetInfo.h"
#include "llvm/IR/DebugInfoMetadata.h"
#include "llvm/IR/DebugLoc.h"
#include "llvm/MC/MCRegisterInfo.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h"
#include <cassert>
#include <map>
#include <utility>
using namespace llvm;
#define DEBUG_TYPE "dwarfdebug"
namespace {
using EntryIndex = DbgValueHistoryMap::EntryIndex;
}
// If @MI is a DBG_VALUE with debug value described by a
// defined register, returns the number of this register.
// In the other case, returns 0.
static Register isDescribedByReg(const MachineInstr &MI) {
assert(MI.isDebugValue());
assert(MI.getNumOperands() == 4);
// If the location of variable is an entry value (DW_OP_LLVM_entry_value)
// do not consider it as a register location.
if (MI.getDebugExpression()->isEntryValue())
return 0;
// If location of variable is described using a register (directly or
// indirectly), this register is always a first operand.
return MI.getDebugOperand(0).isReg() ? MI.getDebugOperand(0).getReg()
: Register();
}
void InstructionOrdering::initialize(const MachineFunction &MF) {
// We give meta instructions the same ordinal as the preceding instruction
// because this class is written for the task of comparing positions of
// variable location ranges against scope ranges. To reflect what we'll see
// in the binary, when we look at location ranges we must consider all
// DBG_VALUEs between two real instructions at the same position. And a
// scope range which ends on a meta instruction should be considered to end
// at the last seen real instruction. E.g.
//
// 1 instruction p Both the variable location for x and for y start
// 1 DBG_VALUE for "x" after instruction p so we give them all the same
// 1 DBG_VALUE for "y" number. If a scope range ends at DBG_VALUE for "y",
// 2 instruction q we should treat it as ending after instruction p
// because it will be the last real instruction in the
// range. DBG_VALUEs at or after this position for
// variables declared in the scope will have no effect.
clear();
unsigned Position = 0;
for (const MachineBasicBlock &MBB : MF)
for (const MachineInstr &MI : MBB)
InstNumberMap[&MI] = MI.isMetaInstruction() ? Position : ++Position;
}
bool InstructionOrdering::isBefore(const MachineInstr *A,
const MachineInstr *B) const {
assert(A->getParent() && B->getParent() && "Operands must have a parent");
assert(A->getMF() == B->getMF() &&
"Operands must be in the same MachineFunction");
return InstNumberMap.lookup(A) < InstNumberMap.lookup(B);
}
bool DbgValueHistoryMap::startDbgValue(InlinedEntity Var,
const MachineInstr &MI,
EntryIndex &NewIndex) {
// Instruction range should start with a DBG_VALUE instruction for the
// variable.
assert(MI.isDebugValue() && "not a DBG_VALUE");
auto &Entries = VarEntries[Var];
if (!Entries.empty() && Entries.back().isDbgValue() &&
!Entries.back().isClosed() &&
Entries.back().getInstr()->isIdenticalTo(MI)) {
LLVM_DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
<< "\t" << Entries.back().getInstr() << "\t" << MI
<< "\n");
return false;
}
Entries.emplace_back(&MI, Entry::DbgValue);
NewIndex = Entries.size() - 1;
return true;
}
EntryIndex DbgValueHistoryMap::startClobber(InlinedEntity Var,
const MachineInstr &MI) {
auto &Entries = VarEntries[Var];
// If an instruction clobbers multiple registers that the variable is
// described by, then we may have already created a clobbering instruction.
if (Entries.back().isClobber() && Entries.back().getInstr() == &MI)
return Entries.size() - 1;
Entries.emplace_back(&MI, Entry::Clobber);
return Entries.size() - 1;
}
void DbgValueHistoryMap::Entry::endEntry(EntryIndex Index) {
// For now, instruction ranges are not allowed to cross basic block
// boundaries.
assert(isDbgValue() && "Setting end index for non-debug value");
assert(!isClosed() && "End index has already been set");
EndIndex = Index;
}
/// Check if the instruction range [StartMI, EndMI] intersects any instruction
/// range in Ranges. EndMI can be nullptr to indicate that the range is
/// unbounded. Assumes Ranges is ordered and disjoint. Returns true and points
/// to the first intersecting scope range if one exists.
static Optional<ArrayRef<InsnRange>::iterator>
intersects(const MachineInstr *StartMI, const MachineInstr *EndMI,
const ArrayRef<InsnRange> &Ranges,
const InstructionOrdering &Ordering) {
for (auto RangesI = Ranges.begin(), RangesE = Ranges.end();
RangesI != RangesE; ++RangesI) {
if (EndMI && Ordering.isBefore(EndMI, RangesI->first))
return None;
if (EndMI && !Ordering.isBefore(RangesI->second, EndMI))
return RangesI;
if (Ordering.isBefore(StartMI, RangesI->second))
return RangesI;
}
return None;
}
void DbgValueHistoryMap::trimLocationRanges(
const MachineFunction &MF, LexicalScopes &LScopes,
const InstructionOrdering &Ordering) {
// The indices of the entries we're going to remove for each variable.
SmallVector<EntryIndex, 4> ToRemove;
// Entry reference count for each variable. Clobbers left with no references
// will be removed.
SmallVector<int, 4> ReferenceCount;
// Entries reference other entries by index. Offsets is used to remap these
// references if any entries are removed.
SmallVector<size_t, 4> Offsets;
for (auto &Record : VarEntries) {
auto &HistoryMapEntries = Record.second;
if (HistoryMapEntries.empty())
continue;
InlinedEntity Entity = Record.first;
const DILocalVariable *LocalVar = cast<DILocalVariable>(Entity.first);
LexicalScope *Scope = nullptr;
if (const DILocation *InlinedAt = Entity.second) {
Scope = LScopes.findInlinedScope(LocalVar->getScope(), InlinedAt);
} else {
Scope = LScopes.findLexicalScope(LocalVar->getScope());
// Ignore variables for non-inlined function level scopes. The scope
// ranges (from scope->getRanges()) will not include any instructions
// before the first one with a debug-location, which could cause us to
// incorrectly drop a location. We could introduce special casing for
// these variables, but it doesn't seem worth it because no out-of-scope
// locations have been observed for variables declared in function level
// scopes.
if (Scope &&
(Scope->getScopeNode() == Scope->getScopeNode()->getSubprogram()) &&
(Scope->getScopeNode() == LocalVar->getScope()))
continue;
}
// If there is no scope for the variable then something has probably gone
// wrong.
if (!Scope)
continue;
ToRemove.clear();
// Zero the reference counts.
ReferenceCount.assign(HistoryMapEntries.size(), 0);
// Index of the DBG_VALUE which marks the start of the current location
// range.
EntryIndex StartIndex = 0;
ArrayRef<InsnRange> ScopeRanges(Scope->getRanges());
for (auto EI = HistoryMapEntries.begin(), EE = HistoryMapEntries.end();
EI != EE; ++EI, ++StartIndex) {
// Only DBG_VALUEs can open location ranges so skip anything else.
if (!EI->isDbgValue())
continue;
// Index of the entry which closes this range.
EntryIndex EndIndex = EI->getEndIndex();
// If this range is closed bump the reference count of the closing entry.
if (EndIndex != NoEntry)
ReferenceCount[EndIndex] += 1;
// Skip this location range if the opening entry is still referenced. It
// may close a location range which intersects a scope range.
// TODO: We could be 'smarter' and trim these kinds of ranges such that
// they do not leak out of the scope ranges if they partially overlap.
if (ReferenceCount[StartIndex] > 0)
continue;
const MachineInstr *StartMI = EI->getInstr();
const MachineInstr *EndMI = EndIndex != NoEntry
? HistoryMapEntries[EndIndex].getInstr()
: nullptr;
// Check if the location range [StartMI, EndMI] intersects with any scope
// range for the variable.
if (auto R = intersects(StartMI, EndMI, ScopeRanges, Ordering)) {
// Adjust ScopeRanges to exclude ranges which subsequent location ranges
// cannot possibly intersect.
ScopeRanges = ArrayRef<InsnRange>(R.getValue(), ScopeRanges.end());
} else {
// If the location range does not intersect any scope range then the
// DBG_VALUE which opened this location range is usless, mark it for
// removal.
ToRemove.push_back(StartIndex);
// Because we'll be removing this entry we need to update the reference
// count of the closing entry, if one exists.
if (EndIndex != NoEntry)
ReferenceCount[EndIndex] -= 1;
}
}
// If there is nothing to remove then jump to next variable.
if (ToRemove.empty())
continue;
// Mark clobbers that will no longer close any location ranges for removal.
for (size_t i = 0; i < HistoryMapEntries.size(); ++i)
if (ReferenceCount[i] <= 0 && HistoryMapEntries[i].isClobber())
ToRemove.push_back(i);
std::sort(ToRemove.begin(), ToRemove.end());
// Build an offset map so we can update the EndIndex of the remaining
// entries.
// Zero the offsets.
Offsets.assign(HistoryMapEntries.size(), 0);
size_t CurOffset = 0;
auto ToRemoveItr = ToRemove.begin();
for (size_t EntryIdx = *ToRemoveItr; EntryIdx < HistoryMapEntries.size();
++EntryIdx) {
// Check if this is an entry which will be removed.
if (ToRemoveItr != ToRemove.end() && *ToRemoveItr == EntryIdx) {
++ToRemoveItr;
++CurOffset;
}
Offsets[EntryIdx] = CurOffset;
}
// Update the EndIndex of the entries to account for those which will be
// removed.
for (auto &Entry : HistoryMapEntries)
if (Entry.isClosed())
Entry.EndIndex -= Offsets[Entry.EndIndex];
// Now actually remove the entries. Iterate backwards so that our remaining
// ToRemove indices are valid after each erase.
for (auto Itr = ToRemove.rbegin(), End = ToRemove.rend(); Itr != End; ++Itr)
HistoryMapEntries.erase(HistoryMapEntries.begin() + *Itr);
}
}
void DbgLabelInstrMap::addInstr(InlinedEntity Label, const MachineInstr &MI) {
assert(MI.isDebugLabel() && "not a DBG_LABEL");
LabelInstr[Label] = &MI;
}
namespace {
// Maps physreg numbers to the variables they describe.
using InlinedEntity = DbgValueHistoryMap::InlinedEntity;
using RegDescribedVarsMap = std::map<unsigned, SmallVector<InlinedEntity, 1>>;
// Keeps track of the debug value entries that are currently live for each
// inlined entity. As the history map entries are stored in a SmallVector, they
// may be moved at insertion of new entries, so store indices rather than
// pointers.
using DbgValueEntriesMap = std::map<InlinedEntity, SmallSet<EntryIndex, 1>>;
} // end anonymous namespace
// Claim that @Var is not described by @RegNo anymore.
static void dropRegDescribedVar(RegDescribedVarsMap &RegVars, unsigned RegNo,
InlinedEntity Var) {
const auto &I = RegVars.find(RegNo);
assert(RegNo != 0U && I != RegVars.end());
auto &VarSet = I->second;
const auto &VarPos = llvm::find(VarSet, Var);
assert(VarPos != VarSet.end());
VarSet.erase(VarPos);
// Don't keep empty sets in a map to keep it as small as possible.
if (VarSet.empty())
RegVars.erase(I);
}
// Claim that @Var is now described by @RegNo.
static void addRegDescribedVar(RegDescribedVarsMap &RegVars, unsigned RegNo,
InlinedEntity Var) {
assert(RegNo != 0U);
auto &VarSet = RegVars[RegNo];
assert(!is_contained(VarSet, Var));
VarSet.push_back(Var);
}
/// Create a clobbering entry and end all open debug value entries
/// for \p Var that are described by \p RegNo using that entry.
static void clobberRegEntries(InlinedEntity Var, unsigned RegNo,
const MachineInstr &ClobberingInstr,
DbgValueEntriesMap &LiveEntries,
DbgValueHistoryMap &HistMap) {
EntryIndex ClobberIndex = HistMap.startClobber(Var, ClobberingInstr);
// Close all entries whose values are described by the register.
SmallVector<EntryIndex, 4> IndicesToErase;
for (auto Index : LiveEntries[Var]) {
auto &Entry = HistMap.getEntry(Var, Index);
assert(Entry.isDbgValue() && "Not a DBG_VALUE in LiveEntries");
if (isDescribedByReg(*Entry.getInstr()) == RegNo) {
IndicesToErase.push_back(Index);
Entry.endEntry(ClobberIndex);
}
}
// Drop all entries that have ended.
for (auto Index : IndicesToErase)
LiveEntries[Var].erase(Index);
}
/// Add a new debug value for \p Var. Closes all overlapping debug values.
static void handleNewDebugValue(InlinedEntity Var, const MachineInstr &DV,
RegDescribedVarsMap &RegVars,
DbgValueEntriesMap &LiveEntries,
DbgValueHistoryMap &HistMap) {
EntryIndex NewIndex;
if (HistMap.startDbgValue(Var, DV, NewIndex)) {
SmallDenseMap<unsigned, bool, 4> TrackedRegs;
// If we have created a new debug value entry, close all preceding
// live entries that overlap.
SmallVector<EntryIndex, 4> IndicesToErase;
const DIExpression *DIExpr = DV.getDebugExpression();
for (auto Index : LiveEntries[Var]) {
auto &Entry = HistMap.getEntry(Var, Index);
assert(Entry.isDbgValue() && "Not a DBG_VALUE in LiveEntries");
const MachineInstr &DV = *Entry.getInstr();
bool Overlaps = DIExpr->fragmentsOverlap(DV.getDebugExpression());
if (Overlaps) {
IndicesToErase.push_back(Index);
Entry.endEntry(NewIndex);
}
if (Register Reg = isDescribedByReg(DV))
TrackedRegs[Reg] |= !Overlaps;
}
// If the new debug value is described by a register, add tracking of
// that register if it is not already tracked.
if (Register NewReg = isDescribedByReg(DV)) {
if (!TrackedRegs.count(NewReg))
addRegDescribedVar(RegVars, NewReg, Var);
LiveEntries[Var].insert(NewIndex);
TrackedRegs[NewReg] = true;
}
// Drop tracking of registers that are no longer used.
for (auto I : TrackedRegs)
if (!I.second)
dropRegDescribedVar(RegVars, I.first, Var);
// Drop all entries that have ended, and mark the new entry as live.
for (auto Index : IndicesToErase)
LiveEntries[Var].erase(Index);
LiveEntries[Var].insert(NewIndex);
}
}
// Terminate the location range for variables described by register at
// @I by inserting @ClobberingInstr to their history.
static void clobberRegisterUses(RegDescribedVarsMap &RegVars,
RegDescribedVarsMap::iterator I,
DbgValueHistoryMap &HistMap,
DbgValueEntriesMap &LiveEntries,
const MachineInstr &ClobberingInstr) {
// Iterate over all variables described by this register and add this
// instruction to their history, clobbering it.
for (const auto &Var : I->second)
clobberRegEntries(Var, I->first, ClobberingInstr, LiveEntries, HistMap);
RegVars.erase(I);
}
// Terminate the location range for variables described by register
// @RegNo by inserting @ClobberingInstr to their history.
static void clobberRegisterUses(RegDescribedVarsMap &RegVars, unsigned RegNo,
DbgValueHistoryMap &HistMap,
DbgValueEntriesMap &LiveEntries,
const MachineInstr &ClobberingInstr) {
const auto &I = RegVars.find(RegNo);
if (I == RegVars.end())
return;
clobberRegisterUses(RegVars, I, HistMap, LiveEntries, ClobberingInstr);
}
void llvm::calculateDbgEntityHistory(const MachineFunction *MF,
const TargetRegisterInfo *TRI,
DbgValueHistoryMap &DbgValues,
DbgLabelInstrMap &DbgLabels) {
const TargetLowering *TLI = MF->getSubtarget().getTargetLowering();
unsigned SP = TLI->getStackPointerRegisterToSaveRestore();
Register FrameReg = TRI->getFrameRegister(*MF);
RegDescribedVarsMap RegVars;
DbgValueEntriesMap LiveEntries;
for (const auto &MBB : *MF) {
for (const auto &MI : MBB) {
if (MI.isDebugValue()) {
assert(MI.getNumOperands() > 1 && "Invalid DBG_VALUE instruction!");
// Use the base variable (without any DW_OP_piece expressions)
// as index into History. The full variables including the
// piece expressions are attached to the MI.
const DILocalVariable *RawVar = MI.getDebugVariable();
assert(RawVar->isValidLocationForIntrinsic(MI.getDebugLoc()) &&
"Expected inlined-at fields to agree");
InlinedEntity Var(RawVar, MI.getDebugLoc()->getInlinedAt());
handleNewDebugValue(Var, MI, RegVars, LiveEntries, DbgValues);
} else if (MI.isDebugLabel()) {
assert(MI.getNumOperands() == 1 && "Invalid DBG_LABEL instruction!");
const DILabel *RawLabel = MI.getDebugLabel();
assert(RawLabel->isValidLocationForIntrinsic(MI.getDebugLoc()) &&
"Expected inlined-at fields to agree");
// When collecting debug information for labels, there is no MCSymbol
// generated for it. So, we keep MachineInstr in DbgLabels in order
// to query MCSymbol afterward.
InlinedEntity L(RawLabel, MI.getDebugLoc()->getInlinedAt());
DbgLabels.addInstr(L, MI);
}
// Meta Instructions have no output and do not change any values and so
// can be safely ignored.
if (MI.isMetaInstruction())
continue;
// Not a DBG_VALUE instruction. It may clobber registers which describe
// some variables.
for (const MachineOperand &MO : MI.operands()) {
if (MO.isReg() && MO.isDef() && MO.getReg()) {
// Ignore call instructions that claim to clobber SP. The AArch64
// backend does this for aggregate function arguments.
if (MI.isCall() && MO.getReg() == SP)
continue;
// If this is a virtual register, only clobber it since it doesn't
// have aliases.
if (Register::isVirtualRegister(MO.getReg()))
clobberRegisterUses(RegVars, MO.getReg(), DbgValues, LiveEntries,
MI);
// If this is a register def operand, it may end a debug value
// range. Ignore frame-register defs in the epilogue and prologue,
// we expect debuggers to understand that stack-locations are
// invalid outside of the function body.
else if (MO.getReg() != FrameReg ||
(!MI.getFlag(MachineInstr::FrameDestroy) &&
!MI.getFlag(MachineInstr::FrameSetup))) {
for (MCRegAliasIterator AI(MO.getReg(), TRI, true); AI.isValid();
++AI)
clobberRegisterUses(RegVars, *AI, DbgValues, LiveEntries, MI);
}
} else if (MO.isRegMask()) {
// If this is a register mask operand, clobber all debug values in
// non-CSRs.
SmallVector<unsigned, 32> RegsToClobber;
// Don't consider SP to be clobbered by register masks.
for (auto It : RegVars) {
unsigned int Reg = It.first;
if (Reg != SP && Register::isPhysicalRegister(Reg) &&
MO.clobbersPhysReg(Reg))
RegsToClobber.push_back(Reg);
}
for (unsigned Reg : RegsToClobber) {
clobberRegisterUses(RegVars, Reg, DbgValues, LiveEntries, MI);
}
}
} // End MO loop.
} // End instr loop.
// Make sure locations for all variables are valid only until the end of
// the basic block (unless it's the last basic block, in which case let
// their liveness run off to the end of the function).
if (!MBB.empty() && &MBB != &MF->back()) {
// Iterate over all variables that have open debug values.
for (auto &Pair : LiveEntries) {
if (Pair.second.empty())
continue;
// Create a clobbering entry.
EntryIndex ClobIdx = DbgValues.startClobber(Pair.first, MBB.back());
// End all entries.
for (EntryIndex Idx : Pair.second) {
DbgValueHistoryMap::Entry &Ent = DbgValues.getEntry(Pair.first, Idx);
assert(Ent.isDbgValue() && !Ent.isClosed());
Ent.endEntry(ClobIdx);
}
}
LiveEntries.clear();
RegVars.clear();
}
}
}
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
LLVM_DUMP_METHOD void DbgValueHistoryMap::dump() const {
dbgs() << "DbgValueHistoryMap:\n";
for (const auto &VarRangePair : *this) {
const InlinedEntity &Var = VarRangePair.first;
const Entries &Entries = VarRangePair.second;
const DILocalVariable *LocalVar = cast<DILocalVariable>(Var.first);
const DILocation *Location = Var.second;
dbgs() << " - " << LocalVar->getName() << " at ";
if (Location)
dbgs() << Location->getFilename() << ":" << Location->getLine() << ":"
<< Location->getColumn();
else
dbgs() << "<unknown location>";
dbgs() << " --\n";
for (const auto &E : enumerate(Entries)) {
const auto &Entry = E.value();
dbgs() << " Entry[" << E.index() << "]: ";
if (Entry.isDbgValue())
dbgs() << "Debug value\n";
else
dbgs() << "Clobber\n";
dbgs() << " Instr: " << *Entry.getInstr();
if (Entry.isDbgValue()) {
if (Entry.getEndIndex() == NoEntry)
dbgs() << " - Valid until end of function\n";
else
dbgs() << " - Closed by Entry[" << Entry.getEndIndex() << "]\n";
}
dbgs() << "\n";
}
}
}
#endif
Reference in New Issue View Git Blame Copy Permalink