[WebAssembly] Track frame/stack pointer local for debug information

[yurydelendik]

Summary

Uses global.set as a reference point to track which local is used
for storing a WebAssembly frame pointer in the function.

[dschuff]

I think the general idea here makes sense, although as-is I'm afraid it might be brittle. I think for this to work, we'd need to ensure that the frame base stays in the designated local for the whole function, correct? i.e. we'd have to ensure it never gets stackified, which it currently could, right?

Come to think of it, do we know that the CFA is always correct in that case ? IIUC if SP gets stackified, we'd need to emit CFA definition instructions to ensure that the debugger could follow it from the local to the stack, possibly to another local, etc. I think that could work (e.g. we could use DW_CFA_def_cfa_expression) but I don't know that it would work out of the box. How are you handling this with wasmtime right now?

[yurydelendik]

In D69807#1734845, @dschuff wrote:

we'd need to ensure that the frame base stays in the designated local for the whole function, correct? i.e. we'd have to ensure it never gets stackified, which it currently could, right?

Ideally, that's correct. Though we need to take in account Philosophy behind LLVM debugging information . If producing a "stable" frame base location is a trade-off for producing an optimized code, the latter has to be favored.

Come to think of it, do we know that the CFA is always correct in that case ? IIUC if SP gets stackified, we'd need to emit CFA definition instructions to ensure that the debugger could follow it from the local to the stack, possibly to another local, etc.

Right, the moving/spilling (between registers) is not handled as this moment. :/ TODO

How are you handling this with wasmtime right now?

wasmtime, when transforms wasm DWARF into "native" DWARF, is able to process DW_AT_frame_base as a list that can define noncontinuous/different frame base locations for a single function. It is worth to note that during transform/compilation WebAssembly FP/SP abstraction will disappear as result of JIT/AOT compiler's work -- the wasm DWARF DW_AT_frame_base will be inlined into "native" DWARF expressions as transformed operators to match native instructions.

[yurydelendik]

llvm/lib/Target/WebAssembly/WebAssemblyFrameLowering.cpp

221

needsSPWriteback(MF) is false when there is no calls -- we need different "anchor" than set_global

[yurydelendik]

Closing in favor of D71681

llvm/include/llvm/CodeGen/TargetRegisterInfo.h

 
 /// Each TargetRegisterClass has a per register weight, and weight
 /// limit which must be less than the limits of its pressure sets.
 struct RegClassWeight {
   unsigned RegWeight;
   unsigned WeightLimit;
 };
 
+struct FrameBaseLocation {
+  enum LocationKind { Register, CFA, TargetIndex } Kind;
+  struct TargetIndexInfo {
+    unsigned Index;
+    signed Offset;
+  };
+  union {
+    unsigned Reg;
+    TargetIndexInfo TI;
+  };
+};
+
 /// TargetRegisterInfo base class - We assume that the target defines a static
 /// array of TargetRegisterDesc objects that represent all of the machine
 /// registers that the target has.  As such, we simply have to track a pointer
 /// to this array so that we can turn register number into a register
 /// descriptor.
 ///
 class TargetRegisterInfo : public MCRegisterInfo {
 public:
public:
 
   //===--------------------------------------------------------------------===//
   /// Debug information queries.
 
   /// getFrameRegister - This method should return the register used as a base
   /// for values allocated in the current stack frame.
   virtual Register getFrameRegister(const MachineFunction &MF) const = 0;
 
+  virtual FrameBaseLocation
+  getFrameBaseLocation(const MachineFunction &MF) const {
+    FrameBaseLocation Loc;
+    Loc.Kind = FrameBaseLocation::Register;
+    Loc.Reg = getFrameRegister(MF);
+    return Loc;
+  }
+
   /// Mark a register and all its aliases as reserved in the given set.
   void markSuperRegs(BitVector &RegisterSet, unsigned Reg) const;
 
   /// Returns true if for every register in the set all super registers are part
   /// of the set as well.
   bool checkAllSuperRegsMarked(const BitVector &RegisterSet,
       ArrayRef<MCPhysReg> Exceptions = ArrayRef<MCPhysReg>()) const;
 

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

DIE &DwarfCompileUnit::updateSubprogramScopeDIE(const DISubprogram *SP) {
   attachLowHighPC(*SPDie, Asm->getFunctionBegin(), Asm->getFunctionEnd());
   if (DD->useAppleExtensionAttributes() &&
       !DD->getCurrentFunction()->getTarget().Options.DisableFramePointerElim(
           *DD->getCurrentFunction()))
     addFlag(*SPDie, dwarf::DW_AT_APPLE_omit_frame_ptr);
 
   // Only include DW_AT_frame_base in full debug info
   if (!includeMinimalInlineScopes()) {
-    if (Asm->MF->getTarget().getTargetTriple().isNVPTX()) {
+    const TargetRegisterInfo *RI = Asm->MF->getSubtarget().getRegisterInfo();
+    auto FBL = RI->getFrameBaseLocation(*Asm->MF);
+    if (FBL.Kind == FrameBaseLocation::CFA) {
       DIELoc *Loc = new (DIEValueAllocator) DIELoc;
       addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_call_frame_cfa);
       addBlock(*SPDie, dwarf::DW_AT_frame_base, Loc);
+    } else if (FBL.Kind == FrameBaseLocation::TargetIndex) {
+      if (FBL.TI.Offset >= 0) {
+        DIELoc *Loc = new (DIEValueAllocator) DIELoc;
+        DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
+        DIExpressionCursor Cursor({});
+        DwarfExpr.addTargetIndexLocation(FBL.TI.Index, FBL.TI.Offset);
+        DwarfExpr.addExpression(std::move(Cursor));
+        addBlock(*SPDie, dwarf::DW_AT_frame_base, DwarfExpr.finalize());
+      }
     } else {
-      const TargetRegisterInfo *RI = Asm->MF->getSubtarget().getRegisterInfo();
-      MachineLocation Location(RI->getFrameRegister(*Asm->MF));
+      assert(FBL.Kind == FrameBaseLocation::Register);
+      MachineLocation Location(FBL.Reg);
       if (Register::isPhysicalRegister(Location.getReg()))
         addAddress(*SPDie, dwarf::DW_AT_frame_base, Location);
     }
   }
 
   // Add name to the name table, we do this here because we're guaranteed
   // to have concrete versions of our DW_TAG_subprogram nodes.
   DD->addSubprogramNames(*CUNode, SP, *SPDie);

llvm/lib/Target/NVPTX/NVPTXRegisterInfo.h

public:
   BitVector getReservedRegs(const MachineFunction &MF) const override;
 
   void eliminateFrameIndex(MachineBasicBlock::iterator MI, int SPAdj,
                            unsigned FIOperandNum,
                            RegScavenger *RS = nullptr) const override;
 
   Register getFrameRegister(const MachineFunction &MF) const override;
 
+  FrameBaseLocation
+  getFrameBaseLocation(const MachineFunction &MF) const override {
+    FrameBaseLocation Loc;
+    Loc.Kind = FrameBaseLocation::CFA;
+    return Loc;
+  }
+
   ManagedStringPool *getStrPool() const {
     return const_cast<ManagedStringPool *>(&ManagedStrPool);
   }
 
   const char *getName(unsigned RegNo) const {
     std::stringstream O;
     O << "reg" << RegNo;
     return getStrPool()->getManagedString(O.str().c_str())->c_str();

llvm/lib/Target/WebAssembly/WebAssemblyExplicitLocals.cpp

for (unsigned I = 0, E = MRI.getNumVirtRegs(); I < E; ++I) {
     if (RL == Reg2Local.end() || RL->second < MFI.getParams().size())
       continue;
 
     MFI.setLocal(RL->second - MFI.getParams().size(),
                  typeForRegClass(MRI.getRegClass(Reg)));
     Changed = true;
   }
 
+  // Recording in which local we store SP. Usually global.set precede with TEE or GET.
+  if (MachineInstr *GI = MFI.SPInstr) {
+    auto TI = std::prev(GI->getIterator());
+    if (TI->getOpcode() == WebAssembly::LOCAL_TEE_I32 ||
+        TI->getOpcode() == WebAssembly::LOCAL_TEE_I64 ||
+        TI->getOpcode() == WebAssembly::LOCAL_GET_I32 ||
+        TI->getOpcode() == WebAssembly::LOCAL_GET_I64)
+        MFI.SPLocal = TI->getOperand(1).getImm();
+  }
+
 #ifndef NDEBUG
   // Assert that all registers have been stackified at this point.
   for (const MachineBasicBlock &MBB : MF) {
     for (const MachineInstr &MI : MBB) {
       if (MI.isDebugInstr() || MI.isLabel())
         continue;
       for (const MachineOperand &MO : MI.explicit_operands()) {
         assert(

llvm/lib/Target/WebAssembly/WebAssemblyFrameLowering.h

 
 #ifndef LLVM_LIB_TARGET_WEBASSEMBLY_WEBASSEMBLYFRAMELOWERING_H
 #define LLVM_LIB_TARGET_WEBASSEMBLY_WEBASSEMBLYFRAMELOWERING_H
 
 #include "llvm/CodeGen/TargetFrameLowering.h"
 
 namespace llvm {
 class MachineFrameInfo;
+class MachineInstr;
 
 class WebAssemblyFrameLowering final : public TargetFrameLowering {
 public:
   /// Size of the red zone for the user stack (leaf functions can use this much
   /// space below the stack pointer without writing it back to __stack_pointer
   /// global).
   // TODO: (ABI) Revisit and decide how large it should be.
   static const size_t RedZoneSize = 128;
public:
   void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
 
   bool hasFP(const MachineFunction &MF) const override;
   bool hasReservedCallFrame(const MachineFunction &MF) const override;
 
   bool needsPrologForEH(const MachineFunction &MF) const;
 
   /// Write SP back to __stack_pointer global.
-  void writeSPToGlobal(unsigned SrcReg, MachineFunction &MF,
+  MachineInstr *writeSPToGlobal(unsigned SrcReg, MachineFunction &MF,
                        MachineBasicBlock &MBB,
                        MachineBasicBlock::iterator &InsertStore,
                        const DebugLoc &DL) const;
 
 private:
   bool hasBP(const MachineFunction &MF) const;
   bool needsSPForLocalFrame(const MachineFunction &MF) const;
   bool needsSP(const MachineFunction &MF) const;
   bool needsSPWriteback(const MachineFunction &MF) const;
 };
 
 } // end namespace llvm
 
 #endif

llvm/lib/Target/WebAssembly/WebAssemblyFrameLowering.cpp

 #include "MCTargetDesc/WebAssemblyMCTargetDesc.h"
 #include "WebAssemblyInstrInfo.h"
 #include "WebAssemblyMachineFunctionInfo.h"
 #include "WebAssemblySubtarget.h"
 #include "WebAssemblyTargetMachine.h"
 #include "WebAssemblyUtilities.h"
 #include "llvm/CodeGen/MachineFrameInfo.h"
 #include "llvm/CodeGen/MachineFunction.h"
+#include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/CodeGen/MachineInstrBuilder.h"
 #include "llvm/CodeGen/MachineModuleInfoImpls.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/Support/Debug.h"
 using namespace llvm;
 
 #define DEBUG_TYPE "wasm-frame-info"
bool WebAssemblyFrameLowering::needsSPWriteback(
   // 1. We need SP not only for EH support but also because we actually use
   // stack or we have a frame address taken.
   // 2. We cannot use the red zone.
   bool CanUseRedZone = MFI.getStackSize() <= RedZoneSize && !MFI.hasCalls() &&
                        !MF.getFunction().hasFnAttribute(Attribute::NoRedZone);
   return needsSPForLocalFrame(MF) && !CanUseRedZone;
 }
 
-void WebAssemblyFrameLowering::writeSPToGlobal(
+MachineInstr *WebAssemblyFrameLowering::writeSPToGlobal(
     unsigned SrcReg, MachineFunction &MF, MachineBasicBlock &MBB,
     MachineBasicBlock::iterator &InsertStore, const DebugLoc &DL) const {
   const auto *TII = MF.getSubtarget<WebAssemblySubtarget>().getInstrInfo();
 
   const char *ES = "__stack_pointer";
   auto *SPSymbol = MF.createExternalSymbolName(ES);
-  BuildMI(MBB, InsertStore, DL, TII->get(WebAssembly::GLOBAL_SET_I32))
+  return BuildMI(MBB, InsertStore, DL, TII->get(WebAssembly::GLOBAL_SET_I32))
       .addExternalSymbol(SPSymbol)
       .addReg(SrcReg);
 }
 
 MachineBasicBlock::iterator
 WebAssemblyFrameLowering::eliminateCallFramePseudoInstr(
     MachineFunction &MF, MachineBasicBlock &MBB,
     MachineBasicBlock::iterator I) const {
void WebAssemblyFrameLowering::emitPrologue(MachineFunction &MF,
   }
   if (hasFP(MF)) {
     // Unlike most conventional targets (where FP points to the saved FP),
     // FP points to the bottom of the fixed-size locals, so we can use positive
     // offsets in load/store instructions.
     BuildMI(MBB, InsertPt, DL, TII->get(WebAssembly::COPY), WebAssembly::FP32)
         .addReg(WebAssembly::SP32);
   }
   if (StackSize && needsSPWriteback(MF)) {
-    writeSPToGlobal(WebAssembly::SP32, MF, MBB, InsertPt, DL);
+    auto FI = MF.getInfo<WebAssemblyFunctionInfo>();
+    FI->SPInstr = writeSPToGlobal(WebAssembly::SP32, MF, MBB, InsertPt, DL);
   }
 }
 
 void WebAssemblyFrameLowering::emitEpilogue(MachineFunction &MF,
                                             MachineBasicBlock &MBB) const {
   uint64_t StackSize = MF.getFrameInfo().getStackSize();
   if (!needsSP(MF) || !needsSPWriteback(MF))
     return;

llvm/lib/Target/WebAssembly/WebAssemblyMachineFunctionInfo.h

 #include "llvm/MC/MCSymbolWasm.h"
 
 namespace llvm {
 
 namespace yaml {
 struct WebAssemblyFunctionInfo;
 }
 
+class MachineInstr;
+
 /// This class is derived from MachineFunctionInfo and contains private
 /// WebAssembly-specific information for each MachineFunction.
 class WebAssemblyFunctionInfo final : public MachineFunctionInfo {
   MachineFunction &MF;
 
   std::vector<MVT> Params;
   std::vector<MVT> Results;
   std::vector<MVT> Locals;
class WebAssemblyFunctionInfo final : public MachineFunctionInfo {
   // A virtual register holding the base pointer for functions that have
   // overaligned values on the user stack.
   unsigned BasePtrVreg = -1U;
 
   // Function properties.
   bool CFGStackified = false;
 
 public:
-  explicit WebAssemblyFunctionInfo(MachineFunction &MF) : MF(MF) {}
+  explicit WebAssemblyFunctionInfo(MachineFunction &MF)
+      : MF(MF), SPInstr(nullptr), SPLocal(-1)  {}
   ~WebAssemblyFunctionInfo() override;
   void initializeBaseYamlFields(const yaml::WebAssemblyFunctionInfo &YamlMFI);
 
   void addParam(MVT VT) { Params.push_back(VT); }
   const std::vector<MVT> &getParams() const { return Params; }
 
   void addResult(MVT VT) { Results.push_back(VT); }
   const std::vector<MVT> &getResults() const { return Results; }
public:
   // For a given stackified WAReg, return the id number to print with push/pop.
   static unsigned getWARegStackId(unsigned Reg) {
     assert(Reg & INT32_MIN);
     return Reg & INT32_MAX;
   }
 
   bool isCFGStackified() const { return CFGStackified; }
   void setCFGStackified(bool Value = true) { CFGStackified = Value; }
+
+  MachineInstr* SPInstr;
+  unsigned SPLocal;
 };
 
 void computeLegalValueVTs(const Function &F, const TargetMachine &TM, Type *Ty,
                           SmallVectorImpl<MVT> &ValueVTs);
 
 // Compute the signature for a given FunctionType (Ty). Note that it's not the
 // signature for F (F is just used to get varous context)
 void computeSignatureVTs(const FunctionType *Ty, const Function &F,

llvm/lib/Target/WebAssembly/WebAssemblyRegisterInfo.h

public:
   BitVector getReservedRegs(const MachineFunction &MF) const override;
   void eliminateFrameIndex(MachineBasicBlock::iterator MI, int SPAdj,
                            unsigned FIOperandNum,
                            RegScavenger *RS = nullptr) const override;
 
   // Debug information queries.
   Register getFrameRegister(const MachineFunction &MF) const override;
 
+  FrameBaseLocation
+  getFrameBaseLocation(const MachineFunction &MF) const override;
+
   const TargetRegisterClass *
   getPointerRegClass(const MachineFunction &MF,
                      unsigned Kind = 0) const override;
   // This does not apply to wasm.
   const uint32_t *getNoPreservedMask() const override { return nullptr; }
 };
 
 } // end namespace llvm
 
 #endif

llvm/lib/Target/WebAssembly/WebAssemblyRegisterInfo.cpp

WebAssemblyRegisterInfo::getFrameRegister(const MachineFunction &MF) const {
   static const unsigned Regs[2][2] = {
       /*            !isArch64Bit       isArch64Bit      */
       /* !hasFP */ {WebAssembly::SP32, WebAssembly::SP64},
       /*  hasFP */ {WebAssembly::FP32, WebAssembly::FP64}};
   const WebAssemblyFrameLowering *TFI = getFrameLowering(MF);
   return Regs[TFI->hasFP(MF)][TT.isArch64Bit()];
 }
 
+FrameBaseLocation
+WebAssemblyRegisterInfo::getFrameBaseLocation(const MachineFunction &MF) const {
+  const WebAssemblyFunctionInfo &MFI = *MF.getInfo<WebAssemblyFunctionInfo>();
+  FrameBaseLocation Loc;
+  Loc.Kind = FrameBaseLocation::TargetIndex;
+  signed Local = MFI.SPInstr != nullptr ? MFI.SPLocal : -1;
+  Loc.TI = {0, Local};
+  return Loc;
+}
+
 const TargetRegisterClass *
 WebAssemblyRegisterInfo::getPointerRegClass(const MachineFunction &MF,
                                             unsigned Kind) const {
   assert(Kind == 0 && "Only one kind of pointer on WebAssembly");
   if (MF.getSubtarget<WebAssemblySubtarget>().hasAddr64())
     return &WebAssembly::I64RegClass;
   return &WebAssembly::I32RegClass;
 }