[WebAssembly] Support __builtin_frame_address

[sunfish]

Summary

This adds support for __builtin_frame_address. Nothing fancy; just the basics.

[jfb]

Awesome! Just one comment update, then lgtm.

lib/Target/WebAssembly/WebAssemblyISelLowering.cpp

586

This just returns zero, right? That seems like valid behavior so I'd say so in the comment above:

On some machines it may be impossible to determine the frame address of any function other than the current one; in such cases, or when the top of the stack has been reached, this function returns 0 if the first frame pointer is properly initialized by the startup code.

Calling this function with a nonzero argument can have unpredictable effects, including crashing the calling program. As a result, calls that are considered unsafe are diagnosed when the -Wframe-address option is in effect. Such calls should only be made in debugging situations.

[dschuff]

lib/Target/WebAssembly/WebAssemblyISelLowering.cpp

586

Just returning SDValue() here will cause an isel failure, which is fatal with an obscure error. We should probably fail() gracefully with a diagnostic here instead.

[dschuff]

Otherwise LGTM too

lib/Target/WebAssembly/WebAssemblyISelLowering.cpp

586

Or returning 0 would be fine too. Maybe even better if that's what GCC. does.

[dschuff]

lib/Target/WebAssembly/WebAssemblyISelLowering.cpp

586

Sorry, this returns an empty SDValue and not the original one. Ignore my previous comment.

lib/Target/WebAssembly/WebAssemblyFrameLowering.cpp

 // TODO: Prolog/epilog should be stackified too. This pass runs after register
 //       stackification, so we'll have to do it manually.
 // TODO: Emit TargetOpcode::CFI_INSTRUCTION instructions
 
 /// Return true if the specified function should have a dedicated frame pointer
 /// register.
 bool WebAssemblyFrameLowering::hasFP(const MachineFunction &MF) const {
   const MachineFrameInfo *MFI = MF.getFrameInfo();
-  assert(!MFI->isFrameAddressTaken());
   const auto *RegInfo =
       MF.getSubtarget<WebAssemblySubtarget>().getRegisterInfo();
-  return MFI->hasVarSizedObjects() || MFI->hasStackMap() ||
-         MFI->hasPatchPoint() || RegInfo->needsStackRealignment(MF);
+  return MFI->isFrameAddressTaken() || MFI->hasVarSizedObjects() ||
+         MFI->hasStackMap() || MFI->hasPatchPoint() ||
+         RegInfo->needsStackRealignment(MF);
 }
 
 /// Under normal circumstances, when a frame pointer is not required, we reserve
 /// argument space for call sites in the function immediately on entry to the
 /// current function. This eliminates the need for add/sub sp brackets around
 /// call sites. Returns true if the call frame is included as part of the stack
 /// frame.
 bool WebAssemblyFrameLowering::hasReservedCallFrame(

lib/Target/WebAssembly/WebAssemblyISelLowering.h

SDValue LowerFormalArguments(SDValue Chain, CallingConv::ID CallConv,
                                bool IsVarArg,
                                const SmallVectorImpl<ISD::InputArg> &Ins,
                                SDLoc DL, SelectionDAG &DAG,
                                SmallVectorImpl<SDValue> &InVals) const override;
 
   // Custom lowering hooks.
   SDValue LowerOperation(SDValue Op, SelectionDAG &DAG) const override;
   SDValue LowerFrameIndex(SDValue Op, SelectionDAG &DAG) const;
+  SDValue LowerFRAMEADDR(SDValue Op, SelectionDAG &DAG) const;
   SDValue LowerGlobalAddress(SDValue Op, SelectionDAG &DAG) const;
   SDValue LowerExternalSymbol(SDValue Op, SelectionDAG &DAG) const;
   SDValue LowerBR_JT(SDValue Op, SelectionDAG &DAG) const;
   SDValue LowerJumpTable(SDValue Op, SelectionDAG &DAG) const;
   SDValue LowerVASTART(SDValue Op, SelectionDAG &DAG) const;
   SDValue LowerCopyToReg(SDValue Op, SelectionDAG &DAG) const;
 };
 
 namespace WebAssembly {
 FastISel *createFastISel(FunctionLoweringInfo &funcInfo,
                          const TargetLibraryInfo *libInfo);
 }  // end namespace WebAssembly
 
 }  // end namespace llvm
 
 #endif

lib/Target/WebAssembly/WebAssemblyISelLowering.cpp

case ISD::VASTART:
       return LowerVASTART(Op, DAG);
     case ISD::BlockAddress:
     case ISD::BRIND:
       fail(DL, DAG, "WebAssembly hasn't implemented computed gotos");
       return SDValue();
     case ISD::RETURNADDR: // Probably nothing meaningful can be returned here.
       fail(DL, DAG, "WebAssembly hasn't implemented __builtin_return_address");
       return SDValue();
-    case ISD::FRAMEADDR: // TODO: Make this return the userspace frame address
-      fail(DL, DAG, "WebAssembly hasn't implemented __builtin_frame_address");
-      return SDValue();
+    case ISD::FRAMEADDR:
+      return LowerFRAMEADDR(Op, DAG);
     case ISD::CopyToReg:
       return LowerCopyToReg(Op, DAG);
   }
 }
 
 SDValue WebAssemblyTargetLowering::LowerCopyToReg(SDValue Op,
                                                   SelectionDAG &DAG) const {
   SDValue Src = Op.getOperand(2);

 }
 
 SDValue WebAssemblyTargetLowering::LowerFrameIndex(SDValue Op,
                                                    SelectionDAG &DAG) const {
   int FI = cast<FrameIndexSDNode>(Op)->getIndex();
   return DAG.getTargetFrameIndex(FI, Op.getValueType());
 }
 
+SDValue WebAssemblyTargetLowering::LowerFRAMEADDR(SDValue Op,
+                                                  SelectionDAG &DAG) const {
+  // Non-zero depths are not supported yet. We currently don't store saved
+  // frame pointers in the address space.
+  if (cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue() > 0)
+    return SDValue();
+
+  DAG.getMachineFunction().getFrameInfo()->setFrameAddressIsTaken(true);
+  EVT VT = Op.getValueType();
+  unsigned FP =
+      Subtarget->getRegisterInfo()->getFrameRegister(DAG.getMachineFunction());
+  return DAG.getCopyFromReg(DAG.getEntryNode(), SDLoc(Op), FP, VT);
+}
+
 SDValue WebAssemblyTargetLowering::LowerGlobalAddress(SDValue Op,
                                                       SelectionDAG &DAG) const {
   SDLoc DL(Op);
   const auto *GA = cast<GlobalAddressSDNode>(Op);
   EVT VT = Op.getValueType();
   assert(GA->getTargetFlags() == 0 &&
          "Unexpected target flags on generic GlobalAddressSDNode");
   if (GA->getAddressSpace() != 0)

lib/Target/WebAssembly/WebAssemblyRegNumbering.cpp

if (MFI.isVRegStackified(VReg)) {
       continue;
     }
     if (MFI.getWAReg(VReg) == WebAssemblyFunctionInfo::UnusedReg) {
       DEBUG(dbgs() << "VReg " << VReg << " -> WAReg " << CurReg << "\n");
       MFI.setWAReg(VReg, CurReg++);
     }
   }
   // Allocate locals for used physical registers
-  if (FrameInfo.getStackSize() > 0 || FrameInfo.adjustsStack()) {
+  bool HasFP = MF.getSubtarget().getFrameLowering()->hasFP(MF);
+  if (FrameInfo.getStackSize() > 0 || FrameInfo.adjustsStack() || HasFP) {
     DEBUG(dbgs() << "PReg SP " << CurReg << "\n");
     MFI.addPReg(WebAssembly::SP32, CurReg++);
   }
-  bool HasFP = MF.getSubtarget().getFrameLowering()->hasFP(MF);
   if (HasFP) {
     DEBUG(dbgs() << "PReg FP " << CurReg << "\n");
     MFI.addPReg(WebAssembly::FP32, CurReg++);
   }
 
   return true;
 }

test/CodeGen/WebAssembly/userstack.ll

  %a = phi i32* [%addr, %entry], [%b, %body]
  store i32 1, i32* %a
  ; CHECK: i32.store {{.*}}, 0([[COPY]]),
  br i1 %cond, label %body, label %exit
 exit:
  ret void
 }
 
+declare void @use_i8_star(i8*)
+declare i8* @llvm.frameaddress(i32)
+
+; Test __builtin_frame_address(0).
+; TODO: When the prolog/epilog sequences are optimized, refine these checks to
+; be more specific.
+
+; CHECK-LABEL: frameaddress_0:
+; CHECK: __stack_pointer
+; CHECK: load
+; CHECK: call use_i8_star
+; CHECK: __stack_pointer
+; CHECK: store
+define void @frameaddress_0() {
+  %t = call i8* @llvm.frameaddress(i32 0)
+  call void @use_i8_star(i8* %t)
+  ret void
+}
+
+; Test __builtin_frame_address(1).
+
+; CHECK-LABEL: frameaddress_1:
+; CHECK-NEXT: i32.const $push0=, 0{{$}}
+; CHECK-NEXT: call use_i8_star@FUNCTION, $pop0{{$}}
+; CHECK-NEXT: return{{$}}
+define void @frameaddress_1() {
+  %t = call i8* @llvm.frameaddress(i32 1)
+  call void @use_i8_star(i8* %t)
+  ret void
+}
+
 ; TODO: test over-aligned alloca