[WebAssembly] Handle cleanuppad with no parent in Wasm SjLj

[aheejin]

Summary

Wasm SjLj converts longjmpable calls into invokes that unwind to
%catch.longjmp.dispatch BB, from where we check if the thrown
exception is a longjmp. But in case a call already has a funclet
attribute, i.e., it is within a catch scope, we have to unwind to its
unwind destination first to preserve the scoping structure. That will
eventually unwind to %catch.longjmp.dispatch, because all
catchswitch and cleanupret that unwind to caller are redirected to
%catch.dispatch.longjmp during Wasm SjLj transformation.

But the prevous code assumed cleanuppad's parent pad was always an
instruction, and didn't handle when a cleanuppad's parent is none.
This CL handles this case, and makes the while loop more intuitive by
removing FromPad condition and explicitly inserting breaks.

[aheejin]

Test comment

[aheejin]

clang-tidy

[dschuff]

llvm/test/CodeGen/WebAssembly/lower-wasm-ehsjlj.ll

270

is it catch.longjmp.dispatch or catch.dispatch.longjmp?

[aheejin]

llvm/test/CodeGen/WebAssembly/lower-wasm-ehsjlj.ll

270

Oh it's catch.dispatch.longjmp: https://github.com/llvm/llvm-project/blob/e900f0584e904e884207e40c80a8126824ef4c41/llvm/lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp#L1702-L1703

Fixed the comments.

[aheejin]

llvm/test/CodeGen/WebAssembly/lower-wasm-ehsjlj.ll

270

Oh, I fixed this in D118408 by mistake... Will move the fix here.

[aheejin]

catch.longjmp.dispatch -> catch.dispatch.longjmp

llvm/lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp

for (auto *CI : LongjmpableCalls) {
     // Change it to an invoke and make it unwind to the catch.dispatch.longjmp
     // BB. If the call is enclosed in another catchpad/cleanuppad scope, unwind
     // to its parent pad's unwind destination instead to preserve the scope
     // structure. It will eventually unwind to the catch.dispatch.longjmp.
     SmallVector<OperandBundleDef, 1> Bundles;
     BasicBlock *UnwindDest = nullptr;
     if (auto Bundle = CI->getOperandBundle(LLVMContext::OB_funclet)) {
       Instruction *FromPad = cast<Instruction>(Bundle->Inputs[0]);
-      while (!UnwindDest && FromPad) {
+      while (!UnwindDest) {
         if (auto *CPI = dyn_cast<CatchPadInst>(FromPad)) {
           UnwindDest = CPI->getCatchSwitch()->getUnwindDest();
-          FromPad = nullptr; // stop searching
+          break;
         } else if (auto *CPI = dyn_cast<CleanupPadInst>(FromPad)) {
           // getCleanupRetUnwindDest() can return nullptr when
           // 1. This cleanuppad's matching cleanupret uwninds to caller
           // 2. There is no matching cleanupret because it ends with
           //    unreachable.
           // In case of 2, we need to traverse the parent pad chain.
           UnwindDest = getCleanupRetUnwindDest(CPI);
-          FromPad = cast<Instruction>(CPI->getParentPad());
+          Value *ParentPad = CPI->getParentPad();
+          if (isa<ConstantTokenNone>(ParentPad))
+            break;
+          FromPad = cast<Instruction>(ParentPad);
         }
       }
     }
     if (!UnwindDest)
       UnwindDest = CatchDispatchLongjmpBB;
     changeToInvokeAndSplitBasicBlock(CI, UnwindDest);
   }
 

llvm/test/CodeGen/WebAssembly/lower-wasm-ehsjlj.ll

 ; RUN: opt < %s -wasm-lower-em-ehsjlj -wasm-enable-eh -wasm-enable-sjlj -S | FileCheck %s
 ; RUN: llc < %s -wasm-enable-eh -wasm-enable-sjlj -exception-model=wasm -mattr=+exception-handling -verify-machineinstrs
 
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
 %struct.__jmp_buf_tag = type { [6 x i32], i32, [32 x i32] }
+%struct.Temp = type { i8 }
 @_ZL3buf = internal global [1 x %struct.__jmp_buf_tag] zeroinitializer, align 16
 
 ; void test() {
 ;   int jmpval = setjmp(buf);
 ;   if (jmpval != 0)
 ;     return;
 ;   try {
 ;     foo();
 ;   } catch (...) {
 ;   }
 ; }
 define void @setjmp_and_try() personality i8* bitcast (i32 (...)* @__gxx_wasm_personality_v0 to i8*) {
-; CHECK-LABEL: @setjmp_and_try(
-
+; CHECK-LABEL: @setjmp_and_try
 entry:
   %call = call i32 @setjmp(%struct.__jmp_buf_tag* getelementptr inbounds ([1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* @_ZL3buf, i32 0, i32 0)) #0
   %cmp = icmp ne i32 %call, 0
   br i1 %cmp, label %return, label %if.end
 
 if.end:                                           ; preds = %entry
   invoke void @foo()
   to label %return unwind label %catch.dispatch

 ;     int jmpval = setjmp(buf);
 ;     if (jmpval != 0)
 ;       return;
 ;     foo();
 ;   } catch (...) {
 ;   }
 ; }
 define void @setjmp_within_try() personality i8* bitcast (i32 (...)* @__gxx_wasm_personality_v0 to i8*) {
-; CHECK-LABEL: @setjmp_within_try(
+; CHECK-LABEL: @setjmp_within_try
 entry:
   %jmpval = alloca i32, align 4
   %exn.slot = alloca i8*, align 4
   invoke void @foo()
   to label %invoke.cont unwind label %catch.dispatch
 
 invoke.cont:                                      ; preds = %entry
   %call = invoke i32 @setjmp(%struct.__jmp_buf_tag* getelementptr inbounds ([1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* @_ZL3buf, i32 0, i32 0)) #0

 ;       foo();
 ;     } catch (...) {
 ;       foo();
 ;     }
 ;   } catch (...) {
 ;   }
 ; }
 define void @setjmp_and_nested_try() personality i8* bitcast (i32 (...)* @__gxx_wasm_personality_v0 to i8*) {
-; CHECK-LABEL: @setjmp_and_nested_try(
+; CHECK-LABEL: @setjmp_and_nested_try
 entry:
   %call = call i32 @setjmp(%struct.__jmp_buf_tag* getelementptr inbounds ([1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* @_ZL3buf, i32 0, i32 0)) #0
   %cmp = icmp ne i32 %call, 0
   br i1 %cmp, label %try.cont10, label %if.end
 
 if.end:                                           ; preds = %entry
   invoke void @foo()
   to label %invoke.cont unwind label %catch.dispatch5

 
 ; CHECK:       .noexc4:
 ; CHECK-NEXT:    unreachable
 
 ; CHECK:       catch.dispatch.longjmp:
 ; CHECK-NEXT:    catchswitch within none [label %catch.longjmp] unwind to caller
 }
 
+; void @cleanuppad_no_parent {
+;   jmp_buf buf;
+;   Temp t;
+;   setjmp(buf);
+; }
+define void @cleanuppad_no_parent() personality i8* bitcast (i32 (...)* @__gxx_wasm_personality_v0 to i8*) {
+; CHECK-LABEL: @cleanuppad_no_parent
+entry:
+  %buf = alloca [1 x %struct.__jmp_buf_tag], align 16
+  %t = alloca %struct.Temp, align 1
+  %arraydecay = getelementptr inbounds [1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* %buf, i32 0, i32 0
+  %call = invoke i32 @setjmp(%struct.__jmp_buf_tag* noundef %arraydecay) #0
+          to label %invoke.cont unwind label %ehcleanup
+
+invoke.cont:                                      ; preds = %entry
+  %call1 = call noundef %struct.Temp* @_ZN4TempD2Ev(%struct.Temp* noundef %t) #2
+  ret void
+
+ehcleanup:                                        ; preds = %entry
+  %0 = cleanuppad within none []
+  ; After SjLj transformation, this will be converted to an invoke that
+  ; eventually unwinds to %catch.dispatch.longjmp. But in case a call has a
+  ; "funclet" attribute, we should unwind to the funclet's unwind destination
+  ; first to preserve the scoping structure. But this call's parent is %0
+  ; (cleanuppad), whose parent is 'none', so we should unwind directly to
+  ; %catch.dispatch.longjmp.
+  %call2 = call noundef %struct.Temp* @_ZN4TempD2Ev(%struct.Temp* noundef %t) #2 [ "funclet"(token %0) ]
+; CHECK: %call13 = invoke {{.*}} %struct.Temp* @_ZN4TempD2Ev(%struct.Temp*
+; CHECK-NEXT:    to label {{.*}} unwind label %catch.dispatch.longjmp
+  cleanupret from %0 unwind to caller
+}
+
 declare void @foo()
+; Function Attrs: nounwind
+declare %struct.Temp* @_ZN4TempD2Ev(%struct.Temp* %this) #2
 ; 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_wasm_personality_v0(...)
 ; Function Attrs: nounwind
 declare i8* @llvm.wasm.get.exception(token) #2
 ; Function Attrs: nounwind