[WebAssembly] Fix resume-only case in Emscripten EH

[aheejin]

Summary

D72308 incorrectly assumed resume cannot exist without a landingpad,
which is not true. This sets Changed to true whenever we make changes
to a function, including creating a call to __resumeException within a
function without a landing pad.

[merge_guards_bot]

Unit tests: fail. 62146 tests passed, 5 failed and 811 were skipped.

failed: libc++.std/language_support/cmp/cmp_partialord/partialord.pass.cpp
failed: libc++.std/language_support/cmp/cmp_strongeq/cmp.strongeq.pass.cpp
failed: libc++.std/language_support/cmp/cmp_strongord/strongord.pass.cpp
failed: libc++.std/language_support/cmp/cmp_weakeq/cmp.weakeq.pass.cpp
failed: libc++.std/language_support/cmp/cmp_weakord/weakord.pass.cpp

clang-tidy: fail. clang-tidy found 8 errors and 0 warnings. 0 of them are added as review comments below (why?).

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

[tlively]

LGTM! Tested locally and this fixes the problem.

llvm/lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp

bool WebAssemblyLowerEmscriptenEHSjLj::runEHOnFunction(Function &F) {
   SmallPtrSet<LandingPadInst *, 32> LandingPads;
   bool AllowExceptions =
       areAllExceptionsAllowed() || EHWhitelistSet.count(F.getName());
 
   for (BasicBlock &BB : F) {
     auto *II = dyn_cast<InvokeInst>(BB.getTerminator());
     if (!II)
       continue;
+    Changed = true;
     LandingPads.insert(II->getLandingPadInst());
     IRB.SetInsertPoint(II);
 
     bool NeedInvoke = AllowExceptions && canThrow(II->getCalledValue());
     if (NeedInvoke) {
       // Wrap invoke with invoke wrapper and generate preamble/postamble
       Value *Threw = wrapInvoke(II);
       ToErase.push_back(II);
bool WebAssemblyLowerEmscriptenEHSjLj::runEHOnFunction(Function &F) {
 
   // 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);
       if (!RI)
         continue;
+      Changed = true;
 
       // Split the input into legal values
       Value *Input = RI->getValue();
       IRB.SetInsertPoint(RI);
       Value *Low = IRB.CreateExtractValue(Input, 0, "low");
       // Create a call to __resumeException function
       IRB.CreateCall(ResumeF, {Low});
       // Add a terminator to the block
       IRB.CreateUnreachable();
       ToErase.push_back(RI);
     }
   }
 
   // Process llvm.eh.typeid.for intrinsics
   for (BasicBlock &BB : F) {
     for (Instruction &I : BB) {
       auto *CI = dyn_cast<CallInst>(&I);
       if (!CI)
         continue;
       const Function *Callee = CI->getCalledFunction();
       if (!Callee)
         continue;
       if (Callee->getIntrinsicID() != Intrinsic::eh_typeid_for)
         continue;
+      Changed = true;
 
       IRB.SetInsertPoint(CI);
       CallInst *NewCI =
           IRB.CreateCall(EHTypeIDF, CI->getArgOperand(0), "typeid");
       CI->replaceAllUsesWith(NewCI);
       ToErase.push_back(CI);
     }
   }
 
   // Look for orphan landingpads, can occur in blocks with no predecessors
   for (BasicBlock &BB : F) {
     Instruction *I = BB.getFirstNonPHI();
     if (auto *LPI = dyn_cast<LandingPadInst>(I))
       LandingPads.insert(LPI);
   }
-  Changed = !LandingPads.empty();
+  Changed |= !LandingPads.empty();
 
   // Handle all the landingpad for this function together, as multiple invokes
   // may share a single lp
   for (LandingPadInst *LPI : LandingPads) {
     IRB.SetInsertPoint(LPI);
     SmallVector<Value *, 16> FMCArgs;
     for (unsigned I = 0, E = LPI->getNumClauses(); I < E; ++I) {
       Constant *Clause = LPI->getClause(I);

llvm/test/CodeGen/WebAssembly/lower-em-exceptions-lpad-only.ll

-; RUN: opt < %s -wasm-lower-em-ehsjlj -S | FileCheck %s
-
-target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32-unknown-unknown"
-
-@_ZTIi = external constant i8*
-
-; Checks if a module that only contains a landingpad (and resume) but not an
-; invoke works correctly and does not crash.
-; CHECK-LABEL: @landingpad_only
-define void @landingpad_only() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
-entry:
-  br label %cont
-
-lpad:                                             ; preds = %entry
-  %0 = landingpad { i8*, i32 }
-          catch i8* bitcast (i8** @_ZTIi to i8*)
-          catch i8* null
-  resume { i8*, i32 } %0
-
-cont:
-  ret void
-}
-
-declare i32 @__gxx_personality_v0(...)

llvm/test/CodeGen/WebAssembly/lower-em-exceptions-resume-only.ll

+; RUN: opt < %s -wasm-lower-em-ehsjlj -S | FileCheck %s
+
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-unknown"
+
+; Checks if a module that only contains a resume but not an invoke works
+; correctly and does not crash.
+; CHECK-LABEL: @resume_only
+; CHECK: call void @__resumeException
+define void @resume_only() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
+entry:
+  %val0 = insertvalue { i8*, i32 } undef, i8* null, 0
+  %val1 = insertvalue { i8*, i32} %val0, i32 0, 1
+  resume { i8*, i32 } %val1
+}
+
+declare i32 @__gxx_personality_v0(...)