1//===-- WebAssemblyDebugFixup.cpp - Debug Fixup ------------------===//
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/// \file
10/// Several prior passes may "stackify" registers, here we ensure any references
11/// in such registers in debug_value instructions become stack relative also.
12/// This is done in a separate pass such that not all previous passes need to
13/// track stack depth when values get stackified.
14///
15//===----------------------------------------------------------------------===//
16
17#include "MCTargetDesc/WebAssemblyMCTargetDesc.h"
18#include "WebAssembly.h"
19#include "WebAssemblyMachineFunctionInfo.h"
20#include "WebAssemblySubtarget.h"
21#include "WebAssemblyUtilities.h"
22#include "llvm/CodeGen/MachineFrameInfo.h"
23#include "llvm/CodeGen/MachineFunction.h"
24#include "llvm/CodeGen/MachineInstrBuilder.h"
25#include "llvm/CodeGen/Passes.h"
26#include "llvm/Support/Debug.h"
27#include "llvm/Support/raw_ostream.h"
28using namespace llvm;
29
30#define DEBUG_TYPE "wasm-debug-fixup"
31
32namespace {
33class WebAssemblyDebugFixup final : public MachineFunctionPass {
34 StringRef getPassName() const override { return "WebAssembly Debug Fixup"; }
35
36 void getAnalysisUsage(AnalysisUsage &AU) const override {
37 AU.setPreservesCFG();
38 MachineFunctionPass::getAnalysisUsage(AU);
39 }
40
41 bool runOnMachineFunction(MachineFunction &MF) override;
42
43public:
44 static char ID; // Pass identification, replacement for typeid
45 WebAssemblyDebugFixup() : MachineFunctionPass(ID) {}
46};
47} // end anonymous namespace
48
49char WebAssemblyDebugFixup::ID = 0;
50INITIALIZE_PASS(
51 WebAssemblyDebugFixup, DEBUG_TYPE,
52 "Ensures debug_value's that have been stackified become stack relative",
53 false, false)
54
55FunctionPass *llvm::createWebAssemblyDebugFixup() {
56 return new WebAssemblyDebugFixup();
57}
58
59// At this very end of the compilation pipeline, if any DBG_VALUEs with
60// registers remain, it means they are dangling info which we failed to update
61// when their corresponding def instruction was transformed/moved/splitted etc.
62// Because Wasm cannot access values in LLVM virtual registers in the debugger,
63// these dangling DBG_VALUEs in effect kill the effect of any previous DBG_VALUE
64// associated with the variable, which will appear as "optimized out".
65static void setDanglingDebugValuesUndef(MachineBasicBlock &MBB,
66 const TargetInstrInfo *TII) {
67 for (auto &MI : llvm::make_early_inc_range(Range&: MBB)) {
68 if (MI.isDebugValue() && MI.getDebugOperand(Index: 0).isReg() &&
69 !MI.isUndefDebugValue()) {
70 LLVM_DEBUG(dbgs() << "Warning: dangling DBG_VALUE set to undef: " << MI
71 << "\n");
72 MI.setDebugValueUndef();
73 }
74 }
75}
76
77bool WebAssemblyDebugFixup::runOnMachineFunction(MachineFunction &MF) {
78 LLVM_DEBUG(dbgs() << "********** Debug Fixup **********\n"
79 "********** Function: "
80 << MF.getName() << '\n');
81
82 WebAssemblyFunctionInfo &MFI = *MF.getInfo<WebAssemblyFunctionInfo>();
83 const auto *TII = MF.getSubtarget<WebAssemblySubtarget>().getInstrInfo();
84
85 struct StackElem {
86 unsigned Reg;
87 MachineInstr *DebugValue;
88 };
89 std::vector<StackElem> Stack;
90 for (MachineBasicBlock &MBB : MF) {
91 // We may insert into this list.
92 for (auto MII = MBB.begin(); MII != MBB.end(); ++MII) {
93 MachineInstr &MI = *MII;
94 if (MI.isDebugValue()) {
95 auto &MO = MI.getOperand(i: 0);
96 // Also check if not a $noreg: likely a DBG_VALUE we just inserted.
97 if (MO.isReg() && MO.getReg().isValid() &&
98 MFI.isVRegStackified(VReg: MO.getReg())) {
99 // Found a DBG_VALUE with a stackified register we will
100 // change into a stack operand.
101 // Search for register rather than assume it is on top (which it
102 // typically is if it appears right after the def), since
103 // DBG_VALUE's may shift under some circumstances.
104 for (auto &Elem : reverse(C&: Stack)) {
105 if (MO.getReg() == Elem.Reg) {
106 auto Depth = static_cast<unsigned>(&Elem - &Stack[0]);
107 LLVM_DEBUG(dbgs() << "Debug Value VReg " << printReg(MO.getReg())
108 << " -> Stack Relative " << Depth << "\n");
109 MO.ChangeToTargetIndex(Idx: WebAssembly::TI_OPERAND_STACK, Offset: Depth);
110 // Save the DBG_VALUE instruction that defined this stackified
111 // variable since later we need it to construct another one on
112 // pop.
113 Elem.DebugValue = &MI;
114 break;
115 }
116 }
117 // If the Reg was not found, we have a DBG_VALUE outside of its
118 // def-use range, and we leave it unmodified as reg, which means
119 // it will be culled later.
120 }
121 } else {
122 // Track stack depth.
123 for (MachineOperand &MO : reverse(C: MI.explicit_uses())) {
124 if (MO.isReg() && MFI.isVRegStackified(VReg: MO.getReg())) {
125 auto Prev = Stack.back();
126 Stack.pop_back();
127 assert(Prev.Reg == MO.getReg() &&
128 "WebAssemblyDebugFixup: Pop: Register not matched!");
129 // We should not put a DBG_VALUE after a terminator; debug ranges
130 // are terminated at the end of a BB anyway.
131 if (Prev.DebugValue && !MI.isTerminator()) {
132 // This stackified reg is a variable that started life at
133 // Prev.DebugValue, so now that we're popping it we must insert
134 // a $noreg DBG_VALUE for the variable to end it, right after
135 // the current instruction.
136 BuildMI(BB&: *Prev.DebugValue->getParent(), I: std::next(x: MII),
137 DL: Prev.DebugValue->getDebugLoc(),
138 MCID: TII->get(Opcode: WebAssembly::DBG_VALUE), IsIndirect: false, Reg: Register(),
139 Variable: Prev.DebugValue->getOperand(i: 2).getMetadata(),
140 Expr: Prev.DebugValue->getOperand(i: 3).getMetadata());
141 }
142 }
143 }
144 for (MachineOperand &MO : MI.defs()) {
145 if (MO.isReg() && MFI.isVRegStackified(VReg: MO.getReg())) {
146 Stack.push_back(x: {.Reg: MO.getReg(), .DebugValue: nullptr});
147 }
148 }
149 }
150 }
151 assert(Stack.empty() &&
152 "WebAssemblyDebugFixup: Stack not empty at end of basic block!");
153
154 setDanglingDebugValuesUndef(MBB, TII);
155 }
156
157 return true;
158}
159