maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/llvm/lib/CodeGen/AsmPrinter/DbgEntityHistoryCalculator.cpp

567 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();
}
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;
}
using OrderMap = DenseMap<const MachineInstr *, unsigned>;
/// Number instructions so that we can compare instruction positions within MF.
/// Meta instructions are given the same nubmer as the preceding instruction.
/// Because the block ordering will not change it is possible (and safe) to
/// compare instruction positions between blocks.
static void numberInstructions(const MachineFunction &MF, OrderMap &Ordering) {
// We give meta instructions the same number as the peceding instruction
// because this function 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.
unsigned position = 0;
for (const MachineBasicBlock &MBB : MF)
for (const MachineInstr &MI : MBB)
Ordering[&MI] = MI.isMetaInstruction() ? position : ++position;
}
/// Check if instruction A comes before B. Meta instructions have the same
/// position as the preceding non-meta instruction. See numberInstructions for
/// more info.
static bool isBefore(const MachineInstr *A, const MachineInstr *B,
const OrderMap &Ordering) {
return Ordering.lookup(A) < Ordering.lookup(B);
}
/// 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 OrderMap &Ordering) {
for (auto RangesI = Ranges.begin(), RangesE = Ranges.end();
RangesI != RangesE; ++RangesI) {
if (EndMI && isBefore(EndMI, RangesI->first, Ordering))
return None;
if (EndMI && !isBefore(RangesI->second, EndMI, Ordering))
return RangesI;
if (isBefore(StartMI, RangesI->second, Ordering))
return RangesI;
}
return None;
}
void DbgValueHistoryMap::trimLocationRanges(const MachineFunction &MF,
LexicalScopes &LScopes) {
OrderMap Ordering;
numberInstructions(MF, 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