1//===- LiveDebugValues.cpp - Tracking Debug Value MIs ---------------------===//
2//
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
6//
7//===----------------------------------------------------------------------===//
8
9#include "LiveDebugValues.h"
10
11#include "llvm/CodeGen/LiveDebugValuesPass.h"
12#include "llvm/CodeGen/MachineDominators.h"
13#include "llvm/CodeGen/MachineFunction.h"
14#include "llvm/CodeGen/MachineFunctionPass.h"
15#include "llvm/CodeGen/Passes.h"
16#include "llvm/CodeGen/TargetPassConfig.h"
17#include "llvm/IR/Module.h"
18#include "llvm/InitializePasses.h"
19#include "llvm/Pass.h"
20#include "llvm/Support/CommandLine.h"
21#include "llvm/Target/TargetMachine.h"
22#include "llvm/TargetParser/Triple.h"
23
24/// \file LiveDebugValues.cpp
25///
26/// The LiveDebugValues pass extends the range of variable locations
27/// (specified by DBG_VALUE instructions) from single blocks to successors
28/// and any other code locations where the variable location is valid.
29/// There are currently two implementations: the "VarLoc" implementation
30/// explicitly tracks the location of a variable, while the "InstrRef"
31/// implementation tracks the values defined by instructions through locations.
32///
33/// This file implements neither; it merely registers the pass, allows the
34/// user to pick which implementation will be used to propagate variable
35/// locations.
36
37#define DEBUG_TYPE "live-debug-values"
38
39using namespace llvm;
40
41static cl::opt<bool>
42 ForceInstrRefLDV("force-instr-ref-livedebugvalues", cl::Hidden,
43 cl::desc("Use instruction-ref based LiveDebugValues with "
44 "normal DBG_VALUE inputs"),
45 cl::init(Val: false));
46
47static cl::opt<cl::boolOrDefault> ValueTrackingVariableLocations(
48 "experimental-debug-variable-locations",
49 cl::desc("Use experimental new value-tracking variable locations"));
50
51// Options to prevent pathological compile-time behavior. If InputBBLimit and
52// InputDbgValueLimit are both exceeded, range extension is disabled.
53static cl::opt<unsigned> InputBBLimit(
54 "livedebugvalues-input-bb-limit",
55 cl::desc("Maximum input basic blocks before DBG_VALUE limit applies"),
56 cl::init(Val: 10000), cl::Hidden);
57static cl::opt<unsigned> InputDbgValueLimit(
58 "livedebugvalues-input-dbg-value-limit",
59 cl::desc(
60 "Maximum input DBG_VALUE insts supported by debug range extension"),
61 cl::init(Val: 50000), cl::Hidden);
62
63namespace {
64/// Generic LiveDebugValues pass. Calls through to VarLocBasedLDV or
65/// InstrRefBasedLDV to perform location propagation, via the LDVImpl
66/// base class.
67class LiveDebugValuesLegacy : public MachineFunctionPass {
68public:
69 static char ID;
70
71 LiveDebugValuesLegacy();
72 ~LiveDebugValuesLegacy() override = default;
73
74 /// Calculate the liveness information for the given machine function.
75 bool runOnMachineFunction(MachineFunction &MF) override;
76
77 void getAnalysisUsage(AnalysisUsage &AU) const override {
78 AU.setPreservesCFG();
79 AU.addRequired<TargetPassConfig>();
80 MachineFunctionPass::getAnalysisUsage(AU);
81 }
82};
83
84struct LiveDebugValues {
85 LiveDebugValues();
86 ~LiveDebugValues() = default;
87 bool run(MachineFunction &MF, bool ShouldEmitDebugEntryValues);
88
89private:
90 std::unique_ptr<LDVImpl> InstrRefImpl;
91 std::unique_ptr<LDVImpl> VarLocImpl;
92 MachineDominatorTree MDT;
93};
94} // namespace
95
96char LiveDebugValuesLegacy::ID = 0;
97
98char &llvm::LiveDebugValuesID = LiveDebugValuesLegacy::ID;
99
100INITIALIZE_PASS(LiveDebugValuesLegacy, DEBUG_TYPE, "Live DEBUG_VALUE analysis",
101 false, false)
102
103/// Default construct and initialize the pass.
104LiveDebugValuesLegacy::LiveDebugValuesLegacy() : MachineFunctionPass(ID) {}
105
106LiveDebugValues::LiveDebugValues() {
107 InstrRefImpl =
108 std::unique_ptr<LDVImpl>(llvm::makeInstrRefBasedLiveDebugValues());
109 VarLocImpl = std::unique_ptr<LDVImpl>(llvm::makeVarLocBasedLiveDebugValues());
110}
111
112PreservedAnalyses
113LiveDebugValuesPass::run(MachineFunction &MF,
114 MachineFunctionAnalysisManager &MFAM) {
115
116 const Module *M = MF.getFunction().getParent();
117 bool ShouldEmitDebugEntryValues =
118 MF.getTarget().shouldEmitDebugEntryValues(Tuning: M->getDebuggerTuning());
119 if (!LiveDebugValues().run(MF, ShouldEmitDebugEntryValues))
120 return PreservedAnalyses::all();
121 auto PA = getMachineFunctionPassPreservedAnalyses();
122 PA.preserveSet<CFGAnalyses>();
123 return PA;
124}
125
126bool LiveDebugValuesLegacy::runOnMachineFunction(MachineFunction &MF) {
127 auto *TPC = &getAnalysis<TargetPassConfig>();
128 const Module *M = MF.getFunction().getParent();
129 return LiveDebugValues().run(
130 MF, ShouldEmitDebugEntryValues: TPC->getTM<TargetMachine>().shouldEmitDebugEntryValues(
131 Tuning: M->getDebuggerTuning()));
132}
133
134bool LiveDebugValues::run(MachineFunction &MF,
135 bool ShouldEmitDebugEntryValues) {
136 bool InstrRefBased = MF.useDebugInstrRef();
137 // Allow the user to force selection of InstrRef LDV.
138 InstrRefBased |= ForceInstrRefLDV;
139
140 LDVImpl *TheImpl = &*VarLocImpl;
141
142 MachineDominatorTree *DomTree = nullptr;
143 if (InstrRefBased) {
144 DomTree = &MDT;
145 MDT.recalculate(Func&: MF);
146 TheImpl = &*InstrRefImpl;
147 }
148
149 return TheImpl->ExtendRanges(MF, DomTree, ShouldEmitDebugEntryValues,
150 InputBBLimit, InputDbgValLimit: InputDbgValueLimit);
151}
152
153bool llvm::debuginfoShouldUseDebugInstrRef(const Triple &T) {
154 // Enable by default on x86_64, disable if explicitly turned off on cmdline.
155 if (T.getArch() == llvm::Triple::x86_64 &&
156 ValueTrackingVariableLocations != cl::boolOrDefault::BOU_FALSE)
157 return true;
158
159 // Enable if explicitly requested on command line.
160 return ValueTrackingVariableLocations == cl::boolOrDefault::BOU_TRUE;
161}
162