[WebAssembly] allow EM_ASM to be used with setjmp

[quantum]

Summary

Avoid wrapping emscripten_asm_* calls in __invoke_* wrappers, which breaks
EM_ASM. See https://github.com/emscripten-core/emscripten/issues/8894.

[kripken]

Interesting!

To make sure I understand, is the issue that in the presence of a setjmp we turn those calls into invokes, which means in wasm we end up with an indirect call - and then in binaryen we don't see the emscripten_asm_const_int etc., and instead just the indirect call? (Or does the backend do more processing here?)

if so, then I'm not sure this is the correct fix, since EM_ASM calls *may* throw (not just JS exceptions, but also they may call back into compiled code and do a longjmp from there, and that should work). Perhaps what we need to do is, in Binaryen, look at indirect calls and see if they are done with a constant index, and the function at that index is emscripten_asm_const_int? (Maybe this is what you were thinking earlier, and I didn't understand it? Sorry if so!)

[quantum]

Now that you mention it, it doesn't feel correct to me either. I think the fix would have to be in binaryen.

llvm/lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp

bool WebAssemblyLowerEmscriptenEHSjLj::canLongjmp(Module &M,
   Function *AllocExceptionF = M.getFunction("__cxa_allocate_exception");
   Function *ThrowF = M.getFunction("__cxa_throw");
   Function *TerminateF = M.getFunction("__clang_call_terminate");
   if (Callee == BeginCatchF || Callee == EndCatchF ||
       Callee == AllocExceptionF || Callee == ThrowF || Callee == TerminateF ||
       Callee == GetTempRet0Func || Callee == SetTempRet0Func)
     return false;
 
+  // EM_ASM related functions
+  Function *EmAsmConstIntF = M.getFunction("emscripten_asm_const_int");
+  Function *EmAsmConstDoubleF = M.getFunction("emscripten_asm_const_double");
+  Function *EmAsmConstIntSyncMainF =
+      M.getFunction("emscripten_asm_const_int_sync_on_main_thread");
+  Function *EmAsmConstDoubleSyncMainF =
+      M.getFunction("emscripten_asm_const_double_sync_on_main_thread");
+  Function *EmAsmConstAsyncMainF =
+      M.getFunction("emscripten_asm_const_async_on_main_thread");
+  if (Callee == EmAsmConstIntF || Callee == EmAsmConstDoubleF ||
+      Callee == EmAsmConstIntSyncMainF || Callee == EmAsmConstDoubleSyncMainF ||
+      Callee == EmAsmConstAsyncMainF)
+    return false;
+
   // Otherwise we don't know
   return true;
 }
 
 // Generate testSetjmp function call seqence with preamble and postamble.
 // The code this generates is equivalent to the following JavaScript code:
 // if (%__THREW__.val != 0 & threwValue != 0) {
 //   %label = _testSetjmp(mem[%__THREW__.val], setjmpTable, setjmpTableSize);

llvm/test/CodeGen/WebAssembly/lower-em-sjlj.ll

 ; Inline assembly should not generate __invoke wrappers.
 ; Doing so would fail as inline assembly cannot be passed as a function pointer.
 ; CHECK: call void asm sideeffect "", ""()
 ; CHECK-NOT: __invoke_void
   call void asm sideeffect "", ""()
   ret void
 }
 
+; Test EM_ASM handling
+@em_asm_str = constant [32 x i8] c"{ console.log(\22hello world\22); }\00", align 1
+
+define hidden i32 @em_asm() {
+; CHECK-LABEL: @em_asm
+entry:
+  %env = alloca [1 x %struct.__jmp_buf_tag], align 16
+  %arraydecay = getelementptr inbounds [1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* %env, i32 0, i32 0
+  %call = call i32 @setjmp(%struct.__jmp_buf_tag* %arraydecay)
+
+  %.compoundliteral = alloca [1 x i8], align 1
+  %arraydecay1 = getelementptr inbounds [1 x i8], [1 x i8]* %.compoundliteral, i32 0, i32 0
+; CHECK: call i32 (i8*, i8*, ...) @emscripten_asm_const_int
+; CHECK-NOT: @"__invoke_i32_i8*_i8*_..."
+  %call2 = call i32 (i8*, i8*, ...) @emscripten_asm_const_int(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @em_asm_str, i32 0, i32 0), i8* %arraydecay1)
+  ret i32 %call2
+}
+
 declare void @foo()
 ; Function Attrs: returns_twice
 declare i32 @setjmp(%struct.__jmp_buf_tag*) #0
 ; Function Attrs: noreturn
 declare void @longjmp(%struct.__jmp_buf_tag*, i32) #1
 declare i32 @__gxx_personality_v0(...)
 declare i8* @__cxa_begin_catch(i8*)
 declare void @__cxa_end_catch()
 declare i8* @malloc(i32)
 declare void @free(i8*)
+declare i32 @emscripten_asm_const_int(i8*, i8*, ...)
 
 ; JS glue functions and invoke wrappers declaration
 ; CHECK-DAG: declare i32 @getTempRet0()
 ; CHECK-DAG: declare void @setTempRet0(i32)
 ; CHECK-DAG: declare i32* @saveSetjmp(%struct.__jmp_buf_tag*, i32, i32*, i32)
 ; CHECK-DAG: declare i32 @testSetjmp(i32, i32*, i32)
 ; CHECK-DAG: declare void @emscripten_longjmp_jmpbuf(%struct.__jmp_buf_tag*, i32)
 ; CHECK-DAG: declare void @emscripten_longjmp(i32, i32)
 ; CHECK-DAG: declare void @__invoke_void(void ()*)
 ; CHECK-DAG: declare void @"__invoke_void_%struct.__jmp_buf_tag*_i32"(void (%struct.__jmp_buf_tag*, i32)*, %struct.__jmp_buf_tag*, i32)
 
 attributes #0 = { returns_twice }
 attributes #1 = { noreturn }
 attributes #2 = { nounwind }