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" 28 using namespace llvm; 29 30 #define DEBUG_TYPE "wasm-debug-fixup" 31 32 namespace { 33 class 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 43 public: 44 static char ID; // Pass identification, replacement for typeid 45 WebAssemblyDebugFixup() : MachineFunctionPass(ID) {} 46 }; 47 } // end anonymous namespace 48 49 char WebAssemblyDebugFixup::ID = 0; 50 INITIALIZE_PASS( 51 WebAssemblyDebugFixup, DEBUG_TYPE, 52 "Ensures debug_value's that have been stackified become stack relative", 53 false, false) 54 55 FunctionPass *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". 65 static void setDanglingDebugValuesUndef(MachineBasicBlock &MBB, 66 const TargetInstrInfo *TII) { 67 for (auto &MI : llvm::make_early_inc_range(MBB)) { 68 if (MI.isDebugValue() && MI.getDebugOperand(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 77 bool 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(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(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(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(WebAssembly::TI_OPERAND_STACK, 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(MI.explicit_uses())) { 124 if (MO.isReg() && MFI.isVRegStackified(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(*Prev.DebugValue->getParent(), std::next(MII), 137 Prev.DebugValue->getDebugLoc(), 138 TII->get(WebAssembly::DBG_VALUE), false, Register(), 139 Prev.DebugValue->getOperand(2).getMetadata(), 140 Prev.DebugValue->getOperand(3).getMetadata()); 141 } 142 } 143 } 144 for (MachineOperand &MO : MI.defs()) { 145 if (MO.isReg() && MFI.isVRegStackified(MO.getReg())) { 146 Stack.push_back({MO.getReg(), 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