[WebAssembly] Prevent inline assembly from being mangled by SjLj

[quantum]

Summary

Before, inline assembly gets mangled by the SjLj transformation.

For example, in a function with setjmp/longjmp, this LLVM IR code

call void asm sideeffect "", ""()

would be transformed into

call void @__invoke_void(void ()* asm sideeffect "", "")

This is invalid, and results in the error:

Cannot take the address of an inline asm!

In this diff, we skip the transformation for inline assembly.

[tlively]

LGTM with a quick explanatory comment!

llvm/lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp

971

Please add a comment about why InlineAsm needs to be skipped.

[sbc100]

llvm/lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp

971

Why move this into calLongjmp?

[tlively]

llvm/lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp

971

That seems like a good idea.

[quantum]

Moved into canLongjmp and added comments.

[quantum]

Applied suggestions.

[aheejin]

Doesn't this only prevent longjmp from generated? Shouldn't we also prevent exception-related invokes from generated?

[aheejin]

Thank you for fixing this. This pass does two things: exception handling and setjmp-longjmp handling. This CL only fixes setjmp-longjmp. Could you fix the exception case too if that's not too much of a burden? You can fix the NeedInvoke part as I told you before. This is basically my bug so I can do it too, in case it takes time though.

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

192 ↗

(On Diff #207671)

Nit: please delete hidden and #0

210 ↗

(On Diff #207671)

We can simplify this test case further: We don't need longjmp in the same function to test this. You can refer to setjmp_other function in this file; you can make this as a single BB function, replacing the call to foo with your inline asm call, because with a few exceptions, most function calls in the same function as setjmp are turned into invokes.

[quantum]

I don't think this is actually a problem in the exception case. To call something that throws, you'd use invoke instead of call, but inline assembly is generated with call and not invoke.

[aheejin]

Hmm right, invokes don't seem to be generated from inline assembly except for handwritten test cases.

llvm/lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp

 }
 
 bool WebAssemblyLowerEmscriptenEHSjLj::canLongjmp(Module &M,
                                                   const Value *Callee) const {
   if (auto *CalleeF = dyn_cast<Function>(Callee))
     if (CalleeF->isIntrinsic())
       return false;
 
+  // Attempting to transform inline assembly will result in something like:
+  //     call void @__invoke_void(void ()* asm ...)
+  // which is invalid because inline assembly blocks do not have addresses
+  // and can't be passed by pointer. The result is a crash with illegal IR.
+  if (isa<InlineAsm>(Callee))
+    return false;
+
   // The reason we include malloc/free here is to exclude the malloc/free
   // calls generated in setjmp prep / cleanup routines.
   Function *SetjmpF = M.getFunction("setjmp");
   Function *MallocF = M.getFunction("malloc");
   Function *FreeF = M.getFunction("free");
   if (Callee == SetjmpF || Callee == MallocF || Callee == FreeF)
     return false;
 
for (unsigned I = 0; I < BBs.size(); I++) {
     BasicBlock *BB = BBs[I];
     for (Instruction &I : *BB) {
       assert(!isa<InvokeInst>(&I));
       auto *CI = dyn_cast<CallInst>(&I);
       if (!CI)
         continue;
 
       const Value *Callee = CI->getCalledValue();
       if (!canLongjmp(M, Callee))
         continue;
 
       Value *Threw = nullptr;
       BasicBlock *Tail;
       if (Callee->getName().startswith(InvokePrefix)) {
         // If invoke wrapper has already been generated for this call in
         // previous EH phase, search for the load instruction
         // %__THREW__.val = __THREW__;

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

entry:
   %buf = alloca [1 x %struct.__jmp_buf_tag], align 16
   %arraydecay = getelementptr inbounds [1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* %buf, i32 0, i32 0
   call void @longjmp(%struct.__jmp_buf_tag* %arraydecay, i32 5) #1
   unreachable
 ; CHECK: %[[ARRAYDECAY:.*]] = getelementptr inbounds
 ; CHECK-NEXT: call void @emscripten_longjmp_jmpbuf(%struct.__jmp_buf_tag* %[[ARRAYDECAY]], i32 5) #1
 }
 
+; Test inline asm handling
+define hidden void @inline_asm() #0 {
+; CHECK-LABEL: @inline_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) #4
+  %cmp = icmp eq i32 %call, 0
+  br i1 %cmp, label %if.then, label %if.else
+
+if.then:                                          ; preds = %entry
+; CHECK: call void asm sideeffect "", ""()
+  call void asm sideeffect "", ""()
+  %arraydecay1 = getelementptr inbounds [1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* %env, i32 0, i32 0
+  call void @longjmp(%struct.__jmp_buf_tag* %arraydecay1, i32 1) #5
+  unreachable
+
+if.else:                                          ; preds = %entry
+  ret void
+}
+
 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()