[WebAssembly] Use llvm utility functions in EH/SjLj

[aheejin]

Summary

This uses changeToCall and changeToInvokeAndSplitBasicBlock from
lib/Transforms/Utils, replacing the custom logic. One difference of
those functions from our previous logic is they delete the original
CallInst/InvokeInst, which makes them tricky to use while iterating
through instructions/BBs. So this CL gathers the candidate calls first
and run them through changeToInvokeAndSplitBasicBlock later.

Also this renames some variables.

llvm/lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp

 #include "llvm/CodeGen/TargetPassConfig.h"
 #include "llvm/CodeGen/WasmEHFuncInfo.h"
 #include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/IntrinsicsWebAssembly.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
+#include "llvm/Transforms/Utils/Local.h"
 #include "llvm/Transforms/Utils/SSAUpdater.h"
 #include "llvm/Transforms/Utils/SSAUpdaterBulk.h"
 
 using namespace llvm;
 
 #define DEBUG_TYPE "wasm-lower-em-ehsjlj"
 
 static cl::list<std::string>
if (NeedInvoke) {
 
       // Insert a branch based on __THREW__ variable
       Value *Cmp = IRB.CreateICmpEQ(Threw, getAddrSizeInt(&M, 1), "cmp");
       IRB.CreateCondBr(Cmp, II->getUnwindDest(), II->getNormalDest());
 
     } else {
       // This can't throw, and we don't need this invoke, just replace it with a
       // call+branch
-      SmallVector<Value *, 16> Args(II->args());
-      CallInst *NewCall =
-          IRB.CreateCall(II->getFunctionType(), II->getCalledOperand(), Args);
-      NewCall->takeName(II);
-      NewCall->setCallingConv(II->getCallingConv());
-      NewCall->setDebugLoc(II->getDebugLoc());
-      NewCall->setAttributes(II->getAttributes());
-      II->replaceAllUsesWith(NewCall);
-      ToErase.push_back(II);
-
-      IRB.CreateBr(II->getNormalDest());
-
-      // Remove any PHI node entries from the exception destination
-      II->getUnwindDest()->removePredecessor(&BB);
+      changeToCall(II);
     }
   }
 
   // Process resume instructions
   for (BasicBlock &BB : F) {
     // Scan the body of the basic block for resumes
     for (Instruction &I : BB) {
       auto *RI = dyn_cast<ResumeInst>(&I);
void WebAssemblyLowerEmscriptenEHSjLj::handleLongjmpableCallsForWasmSjLj(
   //   switch will be inserted here later
   // entry.split: (OrigEntry)
   //   the original function starts here
   BasicBlock *OrigEntry = Entry->getNextNode();
   BasicBlock *SetjmpDispatchBB =
       BasicBlock::Create(C, "setjmp.dispatch", &F, OrigEntry);
   cast<BranchInst>(Entry->getTerminator())->setSuccessor(0, SetjmpDispatchBB);
 
-  // Create catch.dispatch.longjmp BB a catchswitch instruction
-  BasicBlock *CatchSwitchBB =
+  // Create catch.dispatch.longjmp BB and a catchswitch instruction
+  BasicBlock *CatchDispatchLongjmpBB =
       BasicBlock::Create(C, "catch.dispatch.longjmp", &F);
-  IRB.SetInsertPoint(CatchSwitchBB);
-  CatchSwitchInst *CatchSwitch =
+  IRB.SetInsertPoint(CatchDispatchLongjmpBB);
+  CatchSwitchInst *CatchSwitchLongjmp =
       IRB.CreateCatchSwitch(ConstantTokenNone::get(C), nullptr, 1);
 
   // Create catch.longjmp BB and a catchpad instruction
   BasicBlock *CatchLongjmpBB = BasicBlock::Create(C, "catch.longjmp", &F);
-  CatchSwitch->addHandler(CatchLongjmpBB);
+  CatchSwitchLongjmp->addHandler(CatchLongjmpBB);
   IRB.SetInsertPoint(CatchLongjmpBB);
-  CatchPadInst *CatchPad = IRB.CreateCatchPad(CatchSwitch, {});
+  CatchPadInst *CatchPad = IRB.CreateCatchPad(CatchSwitchLongjmp, {});
 
   // Wasm throw and catch instructions can throw and catch multiple values, but
   // that requires multivalue support in the toolchain, which is currently not
   // very reliable. We instead throw and catch a pointer to a struct value of
   // type 'struct __WasmLongjmpArgs', which is defined in Emscripten.
   Instruction *CatchCI =
       IRB.CreateCall(CatchF, {IRB.getInt32(WebAssembly::C_LONGJMP)}, "thrown");
   Value *LongjmpArgs =
void WebAssemblyLowerEmscriptenEHSjLj::handleLongjmpableCallsForWasmSjLj(
   // 0).
   for (unsigned I = 0; I < SetjmpRetPHIs.size(); I++) {
     SI->addCase(IRB.getInt32(I + 1), SetjmpRetPHIs[I]->getParent());
     SetjmpRetPHIs[I]->addIncoming(Val, SetjmpDispatchBB);
   }
 
   // Convert all longjmpable call instructions to invokes that unwind to the
   // newly created catch.dispatch.longjmp BB.
-  SmallVector<Instruction *, 64> ToErase;
+  SmallVector<CallInst *, 64> LongjmpableCalls;
   for (auto *BB = &*F.begin(); BB; BB = BB->getNextNode()) {
-    for (Instruction &I : *BB) {
+    for (auto &I : *BB) {
       auto *CI = dyn_cast<CallInst>(&I);
       if (!CI)
         continue;
       const Value *Callee = CI->getCalledOperand();
       if (!canLongjmp(Callee))
         continue;
       if (isEmAsmCall(Callee))
         report_fatal_error("Cannot use EM_ASM* alongside setjmp/longjmp in " +
                                F.getName() +
                                ". Please consider using EM_JS, or move the "
                                "EM_ASM into another function.",
                            false);
       // This is __wasm_longjmp() call we inserted in this function, which
       // rethrows the longjmp when the longjmp does not correspond to one of
       // setjmps in this function. We should not convert this call to an invoke.
       if (CI == WasmLongjmpCI)
         continue;
-      ToErase.push_back(CI);
-
-      // Even if the callee function has attribute 'nounwind', which is true for
-      // all C functions, it can longjmp, which means it can throw a Wasm
-      // exception now.
-      CI->removeFnAttr(Attribute::NoUnwind);
-      if (Function *CalleeF = CI->getCalledFunction()) {
-        CalleeF->removeFnAttr(Attribute::NoUnwind);
-      }
-
-      IRB.SetInsertPoint(CI);
-      BasicBlock *Tail = SplitBlock(BB, CI->getNextNode());
-      // We will add a new invoke. So remove the branch created when we split
-      // the BB
-      ToErase.push_back(BB->getTerminator());
-      SmallVector<Value *, 8> Args(CI->args());
-      InvokeInst *II =
-          IRB.CreateInvoke(CI->getFunctionType(), CI->getCalledOperand(), Tail,
-                           CatchSwitchBB, Args);
-      II->takeName(CI);
-      II->setDebugLoc(CI->getDebugLoc());
-      II->setAttributes(CI->getAttributes());
-      CI->replaceAllUsesWith(II);
-    }
-  }
-
-  for (Instruction *I : ToErase)
-    I->eraseFromParent();
+      LongjmpableCalls.push_back(CI);
+    }
+  }
+  for (auto *CI : LongjmpableCalls) {
+    if (Function *CalleeF = CI->getCalledFunction())
+    // Change it to an invoke and make it unwind to the catch.dispatch.longjmp
+    // BB.
+    changeToInvokeAndSplitBasicBlock(CI, CatchDispatchLongjmpBB);
 }

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

 ; CHECK:    entry.split.split:
 ; CHECK-NEXT: %buf8 = phi [1 x %struct.__jmp_buf_tag]* [ %buf9, %setjmp.dispatch ], [ %buf, %entry.split ]
 ; CHECK-NEXT: %setjmpTableSize7 = phi i32 [ %setjmpTableSize2, %entry.split ], [ %setjmpTableSize6, %setjmp.dispatch ]
 ; CHECK-NEXT: %setjmpTable5 = phi i32* [ %setjmpTable1, %entry.split ], [ %setjmpTable4, %setjmp.dispatch ]
 ; CHECK-NEXT: %setjmp.ret = phi i32 [ 0, %entry.split ], [ %val10, %setjmp.dispatch ]
 ; CHECK-NEXT: %arraydecay1 = getelementptr inbounds [1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* %buf8, i32 0, i32 0
 ; CHECK-NEXT: %env = bitcast %struct.__jmp_buf_tag* %arraydecay1 to i8*
 ; CHECK-NEXT: invoke void @__wasm_longjmp(i8* %env, i32 1)
-; CHECK-NEXT:         to label %entry.split.split.split unwind label %catch.dispatch.longjmp
+; CHECK-NEXT:         to label %.noexc unwind label %catch.dispatch.longjmp
 
-; CHECK:    entry.split.split.split:
+; CHECK:    .noexc:
 ; CHECK-NEXT: unreachable
 
 ; CHECK:    catch.dispatch.longjmp:
 ; CHECK-NEXT: %0 = catchswitch within none [label %catch.longjmp] unwind to caller
 
 ; CHECK:    catch.longjmp:
 ; CHECK-NEXT: %1 = catchpad within %0 []
 ; CHECK-NEXT: %thrown = call i8* @llvm.wasm.catch(i32 1)
entry:
   call void @foo()
   call void @foo()
   ret void
 
 ; CHECK: entry.split.split:
 ; CHECK:   invoke void @foo()
 ; CHECK:           to label %{{.*}} unwind label %catch.dispatch.longjmp
 
-; CHECK: entry.split.split.split:
+; CHECK: .noexc:
 ; CHECK:   invoke void @foo()
 ; CHECK:           to label %{{.*}} unwind label %catch.dispatch.longjmp
 }
 
 ; Tests cases where longjmp function pointer is used in other ways than direct
 ; calls. longjmps should be replaced with (void(*)(jmp_buf*, int))__wasm_longjmp.
 declare void @take_longjmp(void (%struct.__jmp_buf_tag*, i32)* %arg_ptr)
 define void @indirect_longjmp() {