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/InitializePasses.h"
18#include "llvm/Pass.h"
19#include "llvm/PassRegistry.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 "livedebugvalues"
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 if (!LiveDebugValues().run(MF, ShouldEmitDebugEntryValues))
116 return PreservedAnalyses::all();
117 auto PA = getMachineFunctionPassPreservedAnalyses();
118 PA.preserveSet<CFGAnalyses>();
119 return PA;
120}
121
122void LiveDebugValuesPass::printPipeline(
123 raw_ostream &OS, function_ref<StringRef(StringRef)> MapClassName2PassName) {
124 OS << MapClassName2PassName(name());
125 if (ShouldEmitDebugEntryValues)
126 OS << "<emit-debug-entry-values>";
127}
128
129bool LiveDebugValuesLegacy::runOnMachineFunction(MachineFunction &MF) {
130 auto *TPC = &getAnalysis<TargetPassConfig>();
131 return LiveDebugValues().run(
132 MF, ShouldEmitDebugEntryValues: TPC->getTM<TargetMachine>().Options.ShouldEmitDebugEntryValues());
133}
134
135bool LiveDebugValues::run(MachineFunction &MF,
136 bool ShouldEmitDebugEntryValues) {
137 bool InstrRefBased = MF.useDebugInstrRef();
138 // Allow the user to force selection of InstrRef LDV.
139 InstrRefBased |= ForceInstrRefLDV;
140
141 LDVImpl *TheImpl = &*VarLocImpl;
142
143 MachineDominatorTree *DomTree = nullptr;
144 if (InstrRefBased) {
145 DomTree = &MDT;
146 MDT.recalculate(Func&: MF);
147 TheImpl = &*InstrRefImpl;
148 }
149
150 return TheImpl->ExtendRanges(MF, DomTree, ShouldEmitDebugEntryValues,
151 InputBBLimit, InputDbgValLimit: InputDbgValueLimit);
152}
153
154bool llvm::debuginfoShouldUseDebugInstrRef(const Triple &T) {
155 // Enable by default on x86_64, disable if explicitly turned off on cmdline.
156 if (T.getArch() == llvm::Triple::x86_64 &&
157 ValueTrackingVariableLocations != cl::boolOrDefault::BOU_FALSE)
158 return true;
159
160 // Enable if explicitly requested on command line.
161 return ValueTrackingVariableLocations == cl::boolOrDefault::BOU_TRUE;
162}
163