159 lines · cpp
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-exception6//7//===----------------------------------------------------------------------===//8///9/// \file10/// Several prior passes may "stackify" registers, here we ensure any references11/// 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 to13/// 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 typeid45 WebAssemblyDebugFixup() : MachineFunctionPass(ID) {}46};47} // end anonymous namespace48 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 with60// registers remain, it means they are dangling info which we failed to update61// 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_VALUE64// 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(MBB)) {68 if (MI.isDebugValue() && MI.getDebugOperand(0).isReg() &&69 !MI.isUndefDebugValue()) {70 LLVM_DEBUG(dbgs() << "Warning: dangling DBG_VALUE set to undef: " << MI71 << "\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(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 will100 // change into a stack operand.101 // Search for register rather than assume it is on top (which it102 // typically is if it appears right after the def), since103 // 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 stackified111 // variable since later we need it to construct another one on112 // pop.113 Elem.DebugValue = &MI;114 break;115 }116 }117 // If the Reg was not found, we have a DBG_VALUE outside of its118 // def-use range, and we leave it unmodified as reg, which means119 // 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 ranges130 // 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 at133 // Prev.DebugValue, so now that we're popping it we must insert134 // a $noreg DBG_VALUE for the variable to end it, right after135 // 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