[WebAssembly] FastISel : Bail to SelectionDAG for constexpr calls

[jgravelle-google]

Summary

Currently FastISel lowers constexpr calls as indirect calls. We'd like those to direct calls, and falling back to SelectionDAGISel handles that.

[dschuff]

Are there any other constants/constexprs besides bitcast that we might encounter, that we should test? Looking at the constexprs, I don't see too much that looks likely. Maybe GEP? I guess you can indirectly call a GlobalVariable, which ought to look the same as a local function pointer, maybe we should have a test for that too (presumably dag isel handles that too).
Also that this patch really does is just bail from fast-isel when the callee is a constant (which is fine), and that has the effect of causing calls of bitcasts to be lowered as direct calls.

[dschuff]

OK nevermind, GlobalVariable doesn't make sense because you have to load it, and similarly for GEP. We could probably do inttoptr though, and maybe select, to get a function pointer and call that.

[jgravelle-google]

• Test more constexpr instructions, make test name more explicit

[dschuff]

Also looking back and my previous comment,

Also that this patch really does is just bail from fast-isel when the callee is a constant (which is fine), and that has the effect of causing calls of bitcasts to be lowered as direct calls.

it really wasn't clear what what I meant was that when you land this you should update the commit description to be more clear about what this change does (bail) and that that's why its effect is to cause calls of bitcasts to be direct.

test/CodeGen/WebAssembly/call.ll

163

If the behavior of bailing from fast-isel is to go back and select the whole rest of the BB with the DAG isel, then these calls probably need to be in different BBs, so we can check that each independently causes a bail.

[jgravelle-google]

• Add basic blocks to call_constexpr test

[sunfish]

This is subtle enough that it would be good to have a comment in the code itself explaining it.

lib/Target/WebAssembly/WebAssemblyFastISel.cpp

bool WebAssemblyFastISel::selectCall(const Instruction *I) {
   if (Call->isMustTailCall() || Call->isInlineAsm() ||
       Call->getFunctionType()->isVarArg())
     return false;
 
   Function *Func = Call->getCalledFunction();
   if (Func && Func->isIntrinsic())
     return false;
 
+  bool IsDirect = Func != nullptr;
+  if (!IsDirect && isa<ConstantExpr>(Call->getCalledValue()))
+    return false;
+
   FunctionType *FuncTy = Call->getFunctionType();
   unsigned Opc;
-  bool IsDirect = Func != nullptr;
   bool IsVoid = FuncTy->getReturnType()->isVoidTy();
   unsigned ResultReg;
   if (IsVoid) {
     Opc = IsDirect ? WebAssembly::CALL_VOID : WebAssembly::PCALL_INDIRECT_VOID;
   } else {
     if (!Subtarget->hasSIMD128() && Call->getType()->isVectorTy())
       return false;
 

test/CodeGen/WebAssembly/call.ll

 ; CHECK-LABEL: coldcc_tail_call_void_nullary:
 ; CHECK-NEXT: {{^}} call void_nullary@FUNCTION{{$}}
 ; CHECK-NEXT: return{{$}}
 define void @coldcc_tail_call_void_nullary() {
   tail call coldcc void @void_nullary()
   ret void
 }
 
+; CHECK-LABEL: call_constexpr:
+; CHECK-NEXT: i32.const $push[[L0:[0-9]+]]=, 2{{$}}
+; CHECK-NEXT: i32.const $push[[L1:[0-9]+]]=, 3{{$}}
+; CHECK-NEXT: call vararg_func@FUNCTION, $pop[[L0]], $pop[[L1]]{{$}}
+; CHECK-NEXT: call other_void_nullary@FUNCTION{{$}}
+; CHECK-NEXT: call void_nullary@FUNCTION{{$}}
+; CHECK-NEXT: return{{$}}
+declare void @vararg_func(...)
+declare void @other_void_nullary()
+define void @call_constexpr() {
+  call void bitcast (void (...)* @vararg_func to void (i32, i32)*)(i32 2, i32 3)
+  call void select (i1 0, void ()* @void_nullary, void ()* @other_void_nullary)()
+  call void inttoptr (i32 ptrtoint (void ()* @void_nullary to i32) to void ()*)()
+  ret void
+}
+
 ; TODO: test the following:
 ;  - More argument combinations.
 ;  - Tail call.
 ;  - Interesting returns (struct, multiple).
 ;  - Vararg.