LLVM 19.0.0git
Go to the documentation of this file.
1//===- LiveDebugValues.cpp - Tracking Debug Value MIs ---------------------===//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
9#include "LiveDebugValues.h"
14#include "llvm/CodeGen/Passes.h"
17#include "llvm/Pass.h"
18#include "llvm/PassRegistry.h"
23/// \file LiveDebugValues.cpp
25/// The LiveDebugValues pass extends the range of variable locations
26/// (specified by DBG_VALUE instructions) from single blocks to successors
27/// and any other code locations where the variable location is valid.
28/// There are currently two implementations: the "VarLoc" implementation
29/// explicitly tracks the location of a variable, while the "InstrRef"
30/// implementation tracks the values defined by instructions through locations.
32/// This file implements neither; it merely registers the pass, allows the
33/// user to pick which implementation will be used to propagate variable
34/// locations.
36#define DEBUG_TYPE "livedebugvalues"
38using namespace llvm;
40static cl::opt<bool>
41 ForceInstrRefLDV("force-instr-ref-livedebugvalues", cl::Hidden,
42 cl::desc("Use instruction-ref based LiveDebugValues with "
43 "normal DBG_VALUE inputs"),
44 cl::init(false));
47 "experimental-debug-variable-locations",
48 cl::desc("Use experimental new value-tracking variable locations"));
50// Options to prevent pathological compile-time behavior. If InputBBLimit and
51// InputDbgValueLimit are both exceeded, range extension is disabled.
53 "livedebugvalues-input-bb-limit",
54 cl::desc("Maximum input basic blocks before DBG_VALUE limit applies"),
55 cl::init(10000), cl::Hidden);
57 "livedebugvalues-input-dbg-value-limit",
59 "Maximum input DBG_VALUE insts supported by debug range extension"),
60 cl::init(50000), cl::Hidden);
62namespace {
63/// Generic LiveDebugValues pass. Calls through to VarLocBasedLDV or
64/// InstrRefBasedLDV to perform location propagation, via the LDVImpl
65/// base class.
68 static char ID;
71 ~LiveDebugValues() = default;
73 /// Calculate the liveness information for the given machine function.
74 bool runOnMachineFunction(MachineFunction &MF) override;
76 void getAnalysisUsage(AnalysisUsage &AU) const override {
77 AU.setPreservesCFG();
79 }
82 std::unique_ptr<LDVImpl> InstrRefImpl;
83 std::unique_ptr<LDVImpl> VarLocImpl;
84 TargetPassConfig *TPC = nullptr;
87} // namespace
89char LiveDebugValues::ID = 0;
93INITIALIZE_PASS(LiveDebugValues, DEBUG_TYPE, "Live DEBUG_VALUE analysis", false,
94 false)
96/// Default construct and initialize the pass.
99 InstrRefImpl =
100 std::unique_ptr<LDVImpl>(llvm::makeInstrRefBasedLiveDebugValues());
101 VarLocImpl = std::unique_ptr<LDVImpl>(llvm::makeVarLocBasedLiveDebugValues());
104bool LiveDebugValues::runOnMachineFunction(MachineFunction &MF) {
105 // Except for Wasm, all targets should be only using physical register at this
106 // point. Wasm only use virtual registers throught its pipeline, but its
107 // virtual registers don't participate in this LiveDebugValues analysis; only
108 // its target indices do.
111 MachineFunctionProperties::Property::NoVRegs));
113 bool InstrRefBased = MF.useDebugInstrRef();
114 // Allow the user to force selection of InstrRef LDV.
115 InstrRefBased |= ForceInstrRefLDV;
117 TPC = getAnalysisIfAvailable<TargetPassConfig>();
118 LDVImpl *TheImpl = &*VarLocImpl;
120 MachineDominatorTree *DomTree = nullptr;
121 if (InstrRefBased) {
122 DomTree = &MDT;
123 MDT.calculate(MF);
124 TheImpl = &*InstrRefImpl;
125 }
127 return TheImpl->ExtendRanges(MF, DomTree, TPC, InputBBLimit,
132 // Enable by default on x86_64, disable if explicitly turned off on cmdline.
133 if (T.getArch() == llvm::Triple::x86_64 &&
134 ValueTrackingVariableLocations != cl::boolOrDefault::BOU_FALSE)
135 return true;
137 // Enable if explicitly requested on command line.
138 return ValueTrackingVariableLocations == cl::boolOrDefault::BOU_TRUE;
static cl::opt< unsigned > InputBBLimit("livedebugvalues-input-bb-limit", cl::desc("Maximum input basic blocks before DBG_VALUE limit applies"), cl::init(10000), cl::Hidden)
static cl::opt< bool > ForceInstrRefLDV("force-instr-ref-livedebugvalues", cl::Hidden, cl::desc("Use instruction-ref based LiveDebugValues with " "normal DBG_VALUE inputs"), cl::init(false))
static cl::opt< unsigned > InputDbgValueLimit("livedebugvalues-input-dbg-value-limit", cl::desc("Maximum input DBG_VALUE insts supported by debug range extension"), cl::init(50000), cl::Hidden)
static cl::opt< cl::boolOrDefault > ValueTrackingVariableLocations("experimental-debug-variable-locations", cl::desc("Use experimental new value-tracking variable locations"))
#define DEBUG_TYPE
#define INITIALIZE_PASS(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:38
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Target-Independent Code Generator Pass Configuration Options pass.
Represent the analysis usage information of a pass.
void setPreservesCFG()
This function should be called by the pass, iff they do not:
Definition: Pass.cpp:269
DominatorTree Class - Concrete subclass of DominatorTreeBase that is used to compute a normal dominat...
void calculate(MachineFunction &F)
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - Subclasses that override getAnalysisUsage must call this.
virtual bool runOnMachineFunction(MachineFunction &MF)=0
runOnMachineFunction - This method must be overloaded to perform the desired machine code transformat...
bool hasProperty(Property P) const
bool useDebugInstrRef() const
Returns true if the function's variable locations are tracked with instruction referencing.
const LLVMTargetMachine & getTarget() const
getTarget - Return the target machine this machine code is compiled with
const MachineFunctionProperties & getProperties() const
Get the function properties.
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
virtual bool ExtendRanges(MachineFunction &MF, MachineDominatorTree *DomTree, TargetPassConfig *TPC, unsigned InputBBLimit, unsigned InputDbgValLimit)=0
const Triple & getTargetTriple() const
Target-Independent Code Generator Pass Configuration Options.
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
bool isWasm() const
Tests whether the target is wasm (32- and 64-bit).
Definition: Triple.h:1021
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:450
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
void initializeLiveDebugValuesPass(PassRegistry &)
LDVImpl * makeInstrRefBasedLiveDebugValues()
char & LiveDebugValuesID
LiveDebugValues pass.
LDVImpl * makeVarLocBasedLiveDebugValues()
bool debuginfoShouldUseDebugInstrRef(const Triple &T)