WIP: [WebAssembly] Always use call_indirect when calling interposable functions

[sbc100]

Summary

Without this calls to DSO-local but weakly defined symbols will be
direct calls even though at runtime another DLL could define that
symbol.

Fixes: https://github.com/emscripten-core/emscripten/issues/13773

[sbc100]

Still needs a test.. but this fixes the emscripten issue.

[dschuff]

when is Func->isInterposable() true? Is it just for weakly-defined functions (unlike e.g. in ELF where it's true anytime it's not DSO-local?)

[sbc100]

In D108060#2944722, @dschuff wrote:

when is Func->isInterposable() true? Is it just for weakly-defined functions (unlike e.g. in ELF where it's true anytime it's not DSO-local?)

Ah good point.. my goal here is to got call_indirect (via GOT) for weakly defined functions, but we might not want to do this for all externally visible symbols (or when calling imported functions).

llvm/lib/Target/WebAssembly/WebAssemblyFastISel.cpp

bool WebAssemblyFastISel::selectCall(const Instruction *I) {
   Function *Func = Call->getCalledFunction();
   if (Func && Func->isIntrinsic())
     return false;
 
   if (Call->getCallingConv() == CallingConv::Swift)
     return false;
 
   bool IsDirect = Func != nullptr;
+  if (TLI.isPositionIndependent() && Func && Func->isInterposable())
+    IsDirect = false;
   if (!IsDirect && isa<ConstantExpr>(Call->getCalledOperand()))
     return false;
 
   FunctionType *FuncTy = Call->getFunctionType();
   unsigned Opc = IsDirect ? WebAssembly::CALL : WebAssembly::CALL_INDIRECT;
   bool IsVoid = FuncTy->getReturnType()->isVoidTy();
   unsigned ResultReg;
   if (!IsVoid) {

llvm/lib/Target/WebAssembly/WebAssemblyISelLowering.cpp

if (IsVarArg && NumBytes) {
     }
     if (!Chains.empty())
       Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Chains);
   } else if (IsVarArg) {
     FINode = DAG.getIntPtrConstant(0, DL);
   }
 
   if (Callee->getOpcode() == ISD::GlobalAddress) {
+    GlobalAddressSDNode* GA = cast<GlobalAddressSDNode>(Callee);
+    // llvm::dbgs() << "LowerCall: " << GA->getGlobal()->getName() << "\n";
+    if (!isPositionIndependent() || !GA->getGlobal()->isInterposable()) {
+      // llvm::dbgs() << "is decl\n";
       // If the callee is a GlobalAddress node (quite common, every direct call
       // is) turn it into a TargetGlobalAddress node so that LowerGlobalAddress
-    // doesn't at MO_GOT which is not needed for direct calls.
-    GlobalAddressSDNode* GA = cast<GlobalAddressSDNode>(Callee);
+      // doesn't add MO_GOT which is not needed for direct calls (to
+      // non-interposable functions);
       Callee = DAG.getTargetGlobalAddress(GA->getGlobal(), DL,
                                           getPointerTy(DAG.getDataLayout()),
                                           GA->getOffset());
+    }
     Callee = DAG.getNode(WebAssemblyISD::Wrapper, DL,
                          getPointerTy(DAG.getDataLayout()), Callee);
   }
 
   // Compute the operands for the CALLn node.
   SmallVector<SDValue, 16> Ops;
   Ops.push_back(Chain);
   Ops.push_back(Callee);
SDValue WebAssemblyTargetLowering::LowerGlobalAddress(SDValue Op,
   assert(GA->getTargetFlags() == 0 &&
          "Unexpected target flags on generic GlobalAddressSDNode");
   if (!WebAssembly::isValidAddressSpace(GA->getAddressSpace()))
     fail(DL, DAG, "Invalid address space for WebAssembly target");
 
   unsigned OperandFlags = 0;
   if (isPositionIndependent()) {
     const GlobalValue *GV = GA->getGlobal();
-    if (getTargetMachine().shouldAssumeDSOLocal(*GV->getParent(), GV)) {
+    // llvm::dbgs() << "LowerGlobalAddress: " << GV->getName() << "\n";
+    if (getTargetMachine().shouldAssumeDSOLocal(*GV->getParent(), GV) &&
+        !GV->isInterposable()) {
+      // llvm::dbgs() << "DSO local\n";
       MachineFunction &MF = DAG.getMachineFunction();
       MVT PtrVT = getPointerTy(MF.getDataLayout());
       const char *BaseName;
       if (GV->getValueType()->isFunctionTy()) {
         BaseName = MF.createExternalSymbolName("__table_base");
         OperandFlags = WebAssemblyII::MO_TABLE_BASE_REL;
       }
       else {
         BaseName = MF.createExternalSymbolName("__memory_base");
         OperandFlags = WebAssemblyII::MO_MEMORY_BASE_REL;
       }
       SDValue BaseAddr =
           DAG.getNode(WebAssemblyISD::Wrapper, DL, PtrVT,
                       DAG.getTargetExternalSymbol(BaseName, PtrVT));
 
       SDValue SymAddr = DAG.getNode(
           WebAssemblyISD::WrapperPIC, DL, VT,
           DAG.getTargetGlobalAddress(GA->getGlobal(), DL, VT, GA->getOffset(),
                                      OperandFlags));
 
       return DAG.getNode(ISD::ADD, DL, VT, BaseAddr, SymAddr);
     } else {
+      // llvm::dbgs() << "not DSO local\n";
       OperandFlags = WebAssemblyII::MO_GOT;
     }
   }
 
   return DAG.getNode(WebAssemblyISD::Wrapper, DL, VT,
                      DAG.getTargetGlobalAddress(GA->getGlobal(), DL, VT,
                                                 GA->getOffset(), OperandFlags));
 }

llvm/test/CodeGen/WebAssembly/call-pic.ll

 ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -wasm-keep-registers -relocation-model=pic -fast-isel=1 | FileCheck %s
 ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -wasm-keep-registers -relocation-model=pic -fast-isel=0 | FileCheck %s
 target triple = "wasm32-unknown-emscripten"
 
 declare i32 @foo()
 declare i32 @bar()
 declare hidden i32 @hidden_function()
 
 @indirect_func = hidden global i32 ()* @foo
 @alias_func = hidden alias i32 (), i32 ()* @local_function
 
-define i32 @local_function() {
+define hidden i32 @local_function() {
   ret i32 1
 }
 
 define void @call_indirect_func() {
 ; CHECK-LABEL: call_indirect_func:
 ; CHECK:      global.get $push[[L0:[0-9]+]]=, __memory_base{{$}}
 ; CHECK-NEXT: i32.const $push[[L1:[0-9]+]]=, indirect_func@MBREL{{$}}
 ; CHECK-NEXT: i32.add $push[[L2:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}