[WebAssembly] Support Emscripten EH/SjLj in Wasm64

[aheejin]

Summary

In wasm64, the signatures of some library functions and global variables
defined in Emscripten change:

• emscripten_longjmp: (i32, i32) -> () -> (i64, i32) -> () This changes because the first argument is the address of a memory buffer. This in turn causes more changes below.
• setThrew: (i32, i32) -> () -> (i64, i32) -> () emscripten_longjmp calls setThrew with the i64 buffer argument as the first parameter.
• __THREW__ (global var): i32 to i64 setThrew's first argument is set to this __THREW__ variable, so it should change to i64 as well.
• testSetjmp: (i32, i32*, i32) -> (i32) -> (i64, i32*, i32) -> (i32) In the code transformation done in this pass, the value of __THREW__ is passed as the first parameter of testSetjmp.

This patch creates some helper functions to easily get types that become
different depending on the wasm32/wasm64, and uses them to change
various function signatures and code transformations. Also updates the
tests with WASM32/WASM64 check lines.

(Untested) Emscripten side patch: https://github.com/emscripten-core/emscripten/pull/14108

[aardappel]

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

50

tip: you can declutter these kind of tests by passing -Dptr=i32 to Filecheck and then using a single CHECK line with [[ptr]] in them.

[aheejin]

Fix incorrect comment pointed out here: https://github.com/emscripten-core/emscripten/pull/14108/files#r627479849

[aheejin]

Use DPTR in tests

[aheejin]

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

50

Thanks! This really simplifies things.

llvm/lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp

 ///    mean a longjmp occurred. In the case of longjmp, __threwValue variable
 ///    indicates the corresponding setjmp buffer the longjmp corresponds to.
 ///
 /// * Exception handling
 ///
 /// 2) We assume the existence of setThrew and setTempRet0/getTempRet0 functions
 ///    at link time. setThrew exists in Emscripten's compiler-rt:
 ///
-///    void setThrew(int threw, int value) {
+///    void setThrew(uintptr_t threw, int value) {
 ///      if (__THREW__ == 0) {
 ///        __THREW__ = threw;
 ///        __threwValue = value;
 ///      }
 ///    }
 //
 ///    setTempRet0 is called from __cxa_find_matching_catch() in JS glue code.
 ///    In exception handling, getTempRet0 indicates the type of an exception
if (const auto *F = dyn_cast<const Function>(V)) {
     if (Name == "setjmp" || Name == "longjmp")
       return false;
     return !F->doesNotThrow();
   }
   // not a function, so an indirect call - can throw, we can't tell
   return true;
 }
 
-// Get a global variable with the given name.  If it doesn't exist declare it,
-// which will generate an import and asssumes that it will exist at link time.
-static GlobalVariable *getGlobalVariableI32(Module &M, IRBuilder<> &IRB,
-                                            WebAssemblyTargetMachine &TM,
-                                            const char *Name) {
-  auto Int32Ty = IRB.getInt32Ty();
-  auto *GV = dyn_cast<GlobalVariable>(M.getOrInsertGlobal(Name, Int32Ty));
+// Get a global variable with the given name. If it doesn't exist declare it,
+// which will generate an import and assume that it will exist at link time.
+static GlobalVariable *getGlobalVariable(Module &M, Type *Ty,
+  auto *GV = dyn_cast<GlobalVariable>(M.getOrInsertGlobal(Name, Ty));
   if (!GV)
     report_fatal_error(Twine("unable to create global: ") + Name);
 
   // If the target supports TLS, make this variable thread-local. We can't just
   // unconditionally make it thread-local and depend on
   // CoalesceFeaturesAndStripAtomics to downgrade it, because stripping TLS has
   // the side effect of disallowing the object from being linked into a
   // shared-memory module, which we don't want to be responsible for.
static Function *getEmscriptenFunction(FunctionType *Ty, const Twine &Name,
   if (!F->hasFnAttribute("wasm-import-name")) {
     llvm::AttrBuilder B;
     B.addAttribute("wasm-import-name", F->getName());
     F->addAttributes(llvm::AttributeList::FunctionIndex, B);
   }
   return F;
 }
 
+// Returns an integer type for the target architecture's address space.
+// i32 for wasm32 and i64 for wasm64.
+static Type *getAddrIntType(Module *M) {
+  IRBuilder<> IRB(M->getContext());
+  return IRB.getIntNTy(M->getDataLayout().getPointerSizeInBits());
+}
+
+// Returns an integer pointer type for the target architecture's address space.
+// i32* for wasm32 and i64* for wasm64.
+static Type *getAddrPtrType(Module *M) {
+  return Type::getIntNPtrTy(M->getContext(),
+                            M->getDataLayout().getPointerSizeInBits());
+}
+
+// Returns an integer whose type is the integer type for the target's address
+// space. Returns (i32 C) for wasm32 and (i64 C) for wasm64, when C is the
+// integer.
+static Value *getAddrSizeInt(Module *M, uint64_t C) {
+  IRBuilder<> IRB(M->getContext());
+  return IRB.getIntN(M->getDataLayout().getPointerSizeInBits(), C);
+}
+
 // Returns __cxa_find_matching_catch_N function, where N = NumClauses + 2.
 // This is because a landingpad instruction contains two more arguments, a
 // personality function and a cleanup bit, and __cxa_find_matching_catch_N
 // functions are named after the number of arguments in the original landingpad
 // instruction.
 Function *
 WebAssemblyLowerEmscriptenEHSjLj::getFindMatchingCatch(Module &M,
                                                        unsigned NumClauses) {

 // Generate invoke wrapper seqence with preamble and postamble
 // Preamble:
 // __THREW__ = 0;
 // Postamble:
 // %__THREW__.val = __THREW__; __THREW__ = 0;
 // Returns %__THREW__.val, which indicates whether an exception is thrown (or
 // whether longjmp occurred), for future use.
 Value *WebAssemblyLowerEmscriptenEHSjLj::wrapInvoke(CallBase *CI) {
-  LLVMContext &C = CI->getModule()->getContext();
+  Module *M = CI->getModule();
+  LLVMContext &C = M->getContext();
 
   // If we are calling a function that is noreturn, we must remove that
   // attribute. The code we insert here does expect it to return, after we
   // catch the exception.
   if (CI->doesNotReturn()) {
     if (auto *F = CI->getCalledFunction())
       F->removeFnAttr(Attribute::NoReturn);
     CI->removeAttribute(AttributeList::FunctionIndex, Attribute::NoReturn);
   }
 
   IRBuilder<> IRB(C);
   IRB.SetInsertPoint(CI);
 
   // Pre-invoke
   // __THREW__ = 0;
-  IRB.CreateStore(IRB.getInt32(0), ThrewGV);
+  IRB.CreateStore(getAddrSizeInt(M, 0), ThrewGV);
 
   // Invoke function wrapper in JavaScript
   SmallVector<Value *, 16> Args;
   // Put the pointer to the callee as first argument, so it can be called
   // within the invoke wrapper later
   Args.push_back(CI->getCalledOperand());
   Args.append(CI->arg_begin(), CI->arg_end());
   CallInst *NewCall = IRB.CreateCall(getInvokeWrapper(CI), Args);
AttributeList NewCallAL =
                          InvokeAL.getRetAttributes(), ArgAttributes);
   NewCall->setAttributes(NewCallAL);
 
   CI->replaceAllUsesWith(NewCall);
 
   // Post-invoke
   // %__THREW__.val = __THREW__; __THREW__ = 0;
   Value *Threw =
-      IRB.CreateLoad(IRB.getInt32Ty(), ThrewGV, ThrewGV->getName() + ".val");
-  IRB.CreateStore(IRB.getInt32(0), ThrewGV);
+      IRB.CreateLoad(getAddrIntType(M), ThrewGV, ThrewGV->getName() + ".val");
+  IRB.CreateStore(getAddrSizeInt(M, 0), ThrewGV);
   return Threw;
 }
 
 // Get matching invoke wrapper based on callee signature
 Function *WebAssemblyLowerEmscriptenEHSjLj::getInvokeWrapper(CallBase *CI) {
   Module *M = CI->getModule();
   SmallVector<Type *, 16> ArgTys;
   FunctionType *CalleeFTy = CI->getFunctionType();

 //
 // As output parameters. returns %label, %longjmp_result, and the BB the last
 // instruction (%longjmp_result = ...) is in.
 void WebAssemblyLowerEmscriptenEHSjLj::wrapTestSetjmp(
     BasicBlock *BB, DebugLoc DL, Value *Threw, Value *SetjmpTable,
     Value *SetjmpTableSize, Value *&Label, Value *&LongjmpResult,
     BasicBlock *&EndBB) {
   Function *F = BB->getParent();
-  LLVMContext &C = BB->getModule()->getContext();
+  Module *M = F->getParent();
+  LLVMContext &C = M->getContext();
   IRBuilder<> IRB(C);
   IRB.SetCurrentDebugLocation(DL);
 
   // if (%__THREW__.val != 0 & threwValue != 0)
   IRB.SetInsertPoint(BB);
   BasicBlock *ThenBB1 = BasicBlock::Create(C, "if.then1", F);
   BasicBlock *ElseBB1 = BasicBlock::Create(C, "if.else1", F);
   BasicBlock *EndBB1 = BasicBlock::Create(C, "if.end", F);
-  Value *ThrewCmp = IRB.CreateICmpNE(Threw, IRB.getInt32(0));
+  Value *ThrewCmp = IRB.CreateICmpNE(Threw, getAddrSizeInt(M, 0));
   Value *ThrewValue = IRB.CreateLoad(IRB.getInt32Ty(), ThrewValueGV,
                                      ThrewValueGV->getName() + ".val");
   Value *ThrewValueCmp = IRB.CreateICmpNE(ThrewValue, IRB.getInt32(0));
   Value *Cmp1 = IRB.CreateAnd(ThrewCmp, ThrewValueCmp, "cmp1");
   IRB.CreateCondBr(Cmp1, ThenBB1, ElseBB1);
 
   // %label = _testSetjmp(mem[%__THREW__.val], _setjmpTable, _setjmpTableSize);
   // if (%label == 0)
   IRB.SetInsertPoint(ThenBB1);
   BasicBlock *ThenBB2 = BasicBlock::Create(C, "if.then2", F);
   BasicBlock *EndBB2 = BasicBlock::Create(C, "if.end2", F);
-  Value *ThrewInt = IRB.CreateIntToPtr(Threw, Type::getInt32PtrTy(C),
-                                       Threw->getName() + ".i32p");
-  Value *LoadedThrew = IRB.CreateLoad(IRB.getInt32Ty(), ThrewInt,
-                                      ThrewInt->getName() + ".loaded");
+  Value *ThrewPtr =
+      IRB.CreateIntToPtr(Threw, getAddrPtrType(M), Threw->getName() + ".p");
+  Value *LoadedThrew = IRB.CreateLoad(getAddrIntType(M), ThrewPtr,
+                                      ThrewPtr->getName() + ".loaded");
   Value *ThenLabel = IRB.CreateCall(
       TestSetjmpF, {LoadedThrew, SetjmpTable, SetjmpTableSize}, "label");
   Value *Cmp2 = IRB.CreateICmpEQ(ThenLabel, IRB.getInt32(0));
   IRB.CreateCondBr(Cmp2, ThenBB2, EndBB2);
 
   // emscripten_longjmp(%__THREW__.val, threwValue);
   IRB.SetInsertPoint(ThenBB2);
   IRB.CreateCall(EmLongjmpF, {Threw, ThrewValue});
for (Instruction &I : BB) {
           continue;
         SSA.RewriteUseAfterInsertions(U);
       }
     }
   }
 }
 
 // Replace uses of longjmp with emscripten_longjmp. emscripten_longjmp takes
-// arguments of type {i32, i32} and longjmp takes {jmp_buf*, i32}, so we need a
-// ptrtoint instruction here to make the type match. jmp_buf* will eventually be
-// lowered to i32 in the wasm backend.
+// arguments of type {i32, i32} (wasm32) / {i64, i32} (wasm64) and longjmp takes
+// {jmp_buf*, i32}, so we need a ptrtoint instruction here to make the type
+// match. jmp_buf* will eventually be lowered to i32 in the wasm backend.
 static void replaceLongjmpWithEmscriptenLongjmp(Function *LongjmpF,
                                                 Function *EmLongjmpF) {
+  Module *M = LongjmpF->getParent();
   SmallVector<CallInst *, 8> ToErase;
   LLVMContext &C = LongjmpF->getParent()->getContext();
   IRBuilder<> IRB(C);
 
   // For calls to longjmp, replace it with emscripten_longjmp and cast its first
   // argument (jmp_buf*) to int
   for (User *U : LongjmpF->users()) {
     auto *CI = dyn_cast<CallInst>(U);
     if (CI && CI->getCalledFunction() == LongjmpF) {
       IRB.SetInsertPoint(CI);
       Value *Jmpbuf =
-          IRB.CreatePtrToInt(CI->getArgOperand(0), IRB.getInt32Ty(), "jmpbuf");
+          IRB.CreatePtrToInt(CI->getArgOperand(0), getAddrIntType(M), "jmpbuf");
       IRB.CreateCall(EmLongjmpF, {Jmpbuf, CI->getArgOperand(1)});
       ToErase.push_back(CI);
     }
   }
   for (auto *I : ToErase)
     I->eraseFromParent();
 
   // If we have any remaining uses of longjmp's function pointer, replace it
bool WebAssemblyLowerEmscriptenEHSjLj::runOnModule(Module &M) {
   bool SetjmpUsed = SetjmpF && !SetjmpF->use_empty();
   bool LongjmpUsed = LongjmpF && !LongjmpF->use_empty();
   bool DoSjLj = EnableSjLj && (SetjmpUsed || LongjmpUsed);
 
   auto *TPC = getAnalysisIfAvailable<TargetPassConfig>();
   assert(TPC && "Expected a TargetPassConfig");
   auto &TM = TPC->getTM<WebAssemblyTargetMachine>();
 
-  if ((EnableEH || DoSjLj) &&
-      Triple(M.getTargetTriple()).getArch() == Triple::wasm64)
-    report_fatal_error("Emscripten EH/SjLj is not supported with wasm64 yet");
   if (EnableEH && TM.Options.ExceptionModel == ExceptionHandling::Wasm)
     report_fatal_error("-exception-model=wasm not allowed with "
                        "-enable-emscripten-cxx-exceptions");
   if (DoSjLj && TM.Options.ExceptionModel == ExceptionHandling::Wasm)
     report_fatal_error("Emscripten SjLj is not supported with Wasm EH yet");
 
   // Declare (or get) global variables __THREW__, __threwValue, and
   // getTempRet0/setTempRet0 function which are used in common for both
   // exception handling and setjmp/longjmp handling
-  ThrewGV = getGlobalVariableI32(M, IRB, TM, "__THREW__");
-  ThrewValueGV = getGlobalVariableI32(M, IRB, TM, "__threwValue");
+  ThrewGV = getGlobalVariable(M, getAddrIntType(&M), TM, "__THREW__");
+  ThrewValueGV = getGlobalVariable(M, IRB.getInt32Ty(), TM, "__threwValue");
   GetTempRet0Func = getEmscriptenFunction(
       FunctionType::get(IRB.getInt32Ty(), false), "getTempRet0", &M);
   SetTempRet0Func = getEmscriptenFunction(
       FunctionType::get(IRB.getVoidTy(), IRB.getInt32Ty(), false),
       "setTempRet0", &M);
   GetTempRet0Func->setDoesNotThrow();
   SetTempRet0Func->setDoesNotThrow();
 
bool WebAssemblyLowerEmscriptenEHSjLj::runOnModule(Module &M) {
   }
 
   // Setjmp/longjmp handling
   if (DoSjLj) {
     Changed = true; // We have setjmp or longjmp somewhere
 
     // Register emscripten_longjmp function
     FunctionType *FTy = FunctionType::get(
-        IRB.getVoidTy(), {IRB.getInt32Ty(), IRB.getInt32Ty()}, false);
+        IRB.getVoidTy(), {getAddrIntType(&M), IRB.getInt32Ty()}, false);
     EmLongjmpF = getEmscriptenFunction(FTy, "emscripten_longjmp", &M);
 
     if (LongjmpF)
       replaceLongjmpWithEmscriptenLongjmp(LongjmpF, EmLongjmpF);
 
     if (SetjmpF) {
       // Register saveSetjmp function
       FunctionType *SetjmpFTy = SetjmpF->getFunctionType();
       FTy = FunctionType::get(Type::getInt32PtrTy(C),
                               {SetjmpFTy->getParamType(0), IRB.getInt32Ty(),
                                Type::getInt32PtrTy(C), IRB.getInt32Ty()},
                               false);
       SaveSetjmpF = getEmscriptenFunction(FTy, "saveSetjmp", &M);
 
       // Register testSetjmp function
       FTy = FunctionType::get(
           IRB.getInt32Ty(),
-          {IRB.getInt32Ty(), Type::getInt32PtrTy(C), IRB.getInt32Ty()}, false);
+          {getAddrIntType(&M), Type::getInt32PtrTy(C), IRB.getInt32Ty()},
+          false);
       TestSetjmpF = getEmscriptenFunction(FTy, "testSetjmp", &M);
 
       // Only traverse functions that uses setjmp in order not to insert
       // unnecessary prep / cleanup code in every function
       SmallPtrSet<Function *, 8> SetjmpUsers;
       for (User *U : SetjmpF->users()) {
         auto *UI = cast<Instruction>(U);
         SetjmpUsers.insert(UI->getFunction());
for (BasicBlock &BB : F) {
 
     bool NeedInvoke = AllowExceptions && canThrow(II->getCalledOperand());
     if (NeedInvoke) {
       // Wrap invoke with invoke wrapper and generate preamble/postamble
       Value *Threw = wrapInvoke(II);
       ToErase.push_back(II);
 
       // Insert a branch based on __THREW__ variable
-      Value *Cmp = IRB.CreateICmpEQ(Threw, IRB.getInt32(1), "cmp");
+      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);
for (Instruction &I : *BB) {
                 Threw = ThrewLI = LI;
                 break;
               }
         }
         // Search for the store instruction after the load above
         // __THREW__ = 0;
         for (auto I = std::next(BasicBlock::iterator(ThrewLI)), IE = BB->end();
              I != IE; ++I) {
-          if (auto *SI = dyn_cast<StoreInst>(I))
-            if (auto *GV = dyn_cast<GlobalVariable>(SI->getPointerOperand()))
-              if (GV == ThrewGV && SI->getValueOperand() == IRB.getInt32(0)) {
+          if (auto *SI = dyn_cast<StoreInst>(I)) {
+            if (auto *GV = dyn_cast<GlobalVariable>(SI->getPointerOperand())) {
+              if (GV == ThrewGV &&
+                  SI->getValueOperand() == getAddrSizeInt(&M, 0)) {
                 ThrewResetSI = SI;
                 break;
               }
             }
+          }
+        }
         assert(Threw && ThrewLI && "Cannot find __THREW__ load after invoke");
         assert(ThrewResetSI && "Cannot find __THREW__ store after invoke");
         Tail = SplitBlock(BB, ThrewResetSI->getNextNode());
 
       } else {
         // Wrap call with invoke wrapper and generate preamble/postamble
         Threw = wrapInvoke(CI);
         ToErase.push_back(CI);

llvm/test/CodeGen/WebAssembly/lower-em-ehsjlj-options.ll

 ; RUN: llc < %s -enable-emscripten-cxx-exceptions | FileCheck %s --check-prefix=EH
 ; RUN: llc < %s -enable-emscripten-sjlj | FileCheck %s --check-prefix=SJLJ
 ; RUN: llc < %s | FileCheck %s --check-prefix=NONE
-; RUN: not --crash llc < %s -enable-emscripten-cxx-exceptions -mtriple=wasm64-unknown-unknown 2>&1 | FileCheck %s --check-prefix=WASM64-EH
-; RUN: not --crash llc < %s -enable-emscripten-sjlj -mtriple=wasm64-unknown-unknown 2>&1 | FileCheck %s --check-prefix=WASM64-SJLJ
 ; RUN: not --crash llc < %s -enable-emscripten-cxx-exceptions -exception-model=wasm 2>&1 | FileCheck %s --check-prefix=WASM-EH-EM-EH
 ; RUN: not --crash llc < %s -enable-emscripten-sjlj -exception-model=wasm 2>&1 | FileCheck %s --check-prefix=WASM-EH-EM-SJLJ
 
 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] }
 

 
 ; SJLJ: .functype  emscripten_longjmp (i32, i32) -> ()
 ; SJLJ: .import_module  emscripten_longjmp, env
 ; SJLJ: .import_name  emscripten_longjmp, emscripten_longjmp
 ; SJLJ-NOT: .functype  emscripten_longjmp_jmpbuf
 ; SJLJ-NOT: .import_module  emscripten_longjmp_jmpbuf
 ; SJLJ-NOT: .import_name  emscripten_longjmp_jmpbuf
 
-; WASM64-EH: LLVM ERROR: Emscripten EH/SjLj is not supported with wasm64 yet
-; WASM64-SJLJ: LLVM ERROR: Emscripten EH/SjLj is not supported with wasm64 yet
 ; WASM-EH-EM-EH: LLVM ERROR: -exception-model=wasm not allowed with -enable-emscripten-cxx-exceptions
 ; WASM-EH-EM-SJLJ: LLVM ERROR: Emscripten SjLj is not supported with Wasm EH yet

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

-; RUN: opt < %s -wasm-lower-em-ehsjlj -S | FileCheck %s --check-prefixes=CHECK,NO-TLS
+; RUN: opt < %s -wasm-lower-em-ehsjlj -S | FileCheck %s --check-prefixes=CHECK,WASM32,NO-TLS
 ; RUN: opt < %s -wasm-lower-em-ehsjlj -S --mattr=+atomics,+bulk-memory | FileCheck %s --check-prefixes=CHECK,TLS
+; RUN: opt < %s -wasm-lower-em-ehsjlj --mtriple=wasm64-unknown-unknown -data-layout="e-m:e-p:64:64-i64:64-n32:64-S128" -S | FileCheck %s --check-prefixes=CHECK,WASM64
 
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
 @_ZTIi = external constant i8*
 @_ZTIc = external constant i8*
 ; NO-TLS-DAG: __THREW__ = external global i32
 ; NO-TLS-DAG: __threwValue = external global i32
 ; TLS-DAG: __THREW__ = external thread_local(localexec) global i32
 ; TLS-DAG: __threwValue = external thread_local(localexec) global i32
+; WASM64-DAG: __THREW__ = external global i64
 
 ; Test invoke instruction with clauses (try-catch block)
 define void @clause() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 ; CHECK-LABEL: @clause(
 entry:
   invoke void @foo(i32 3)
           to label %invoke.cont unwind label %lpad
 ; CHECK: entry:
-; CHECK-NEXT: store i32 0, i32* @__THREW__
-; CHECK-NEXT: call cc{{.*}} void @__invoke_void_i32(void (i32)* @foo, i32 3)
-; CHECK-NEXT: %[[__THREW__VAL:.*]] = load i32, i32* @__THREW__
-; CHECK-NEXT: store i32 0, i32* @__THREW__
-; CHECK-NEXT: %cmp = icmp eq i32 %[[__THREW__VAL]], 1
-; CHECK-NEXT: br i1 %cmp, label %lpad, label %invoke.cont
+; WASM32:      store i32 0, i32* @__THREW__
+; WASM64:      store i64 0, i64* @__THREW__
+; CHECK:       call cc{{.*}} void @__invoke_void_i32(void (i32)* @foo, i32 3)
+; WASM32:      %[[__THREW__VAL:.*]] = load i32, i32* @__THREW__
+; WASM64:      %[[__THREW__VAL:.*]] = load i64, i64* @__THREW__
+; WASM32-NEXT: store i32 0, i32* @__THREW__
+; WASM64-NEXT: store i64 0, i64* @__THREW__
+; WASM32-NEXT: %cmp = icmp eq i32 %[[__THREW__VAL]], 1
+; WASM64-NEXT: %cmp = icmp eq i64 %[[__THREW__VAL]], 1
+; CHECK:       br i1 %cmp, label %lpad, label %invoke.cont
 
 invoke.cont:                                      ; preds = %entry
   br label %try.cont
 
 lpad:                                             ; preds = %entry
   %0 = landingpad { i8*, i32 }
           catch i8* bitcast (i8** @_ZTIi to i8*)
           catch i8* null

 
 ; Test invoke instruction with filters (functions with throw(...) declaration)
 define void @filter() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 ; CHECK-LABEL: @filter(
 entry:
   invoke void @foo(i32 3)
           to label %invoke.cont unwind label %lpad
 ; CHECK: entry:
-; CHECK-NEXT: store i32 0, i32* @__THREW__
-; CHECK-NEXT: call cc{{.*}} void @__invoke_void_i32(void (i32)* @foo, i32 3)
-; CHECK-NEXT: %[[__THREW__VAL:.*]] = load i32, i32* @__THREW__
-; CHECK-NEXT: store i32 0, i32* @__THREW__
-; CHECK-NEXT: %cmp = icmp eq i32 %[[__THREW__VAL]], 1
-; CHECK-NEXT: br i1 %cmp, label %lpad, label %invoke.cont
+; WASM32-NEXT: store i32 0, i32* @__THREW__
+; WASM64-NEXT: store i64 0, i64* @__THREW__
+; CHECK:       call cc{{.*}} void @__invoke_void_i32(void (i32)* @foo, i32 3)
+; WASM32:      %[[__THREW__VAL:.*]] = load i32, i32* @__THREW__
+; WASM64:      %[[__THREW__VAL:.*]] = load i64, i64* @__THREW__
+; WASM32-NEXT: store i32 0, i32* @__THREW__
+; WASM64-NEXT: store i64 0, i64* @__THREW__
+; WASM32-NEXT: %cmp = icmp eq i32 %[[__THREW__VAL]], 1
+; WASM64-NEXT: %cmp = icmp eq i64 %[[__THREW__VAL]], 1
+; CHECK:       br i1 %cmp, label %lpad, label %invoke.cont
 
 invoke.cont:                                      ; preds = %entry
   ret void
 
 lpad:                                             ; preds = %entry
   %0 = landingpad { i8*, i32 }
           filter [2 x i8*] [i8* bitcast (i8** @_ZTIi to i8*), i8* bitcast (i8** @_ZTIc to i8*)]
   %1 = extractvalue { i8*, i32 } %0, 0

 
 ; Test if argument attributes indices in newly created call instructions are correct
 define void @arg_attributes() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 ; CHECK-LABEL: @arg_attributes(
 entry:
   %0 = invoke noalias i8* @bar(i8 signext 1, i8 zeroext 2)
           to label %invoke.cont unwind label %lpad
 ; CHECK: entry:
-; CHECK-NEXT: store i32 0, i32* @__THREW__
-; CHECK-NEXT: %0 = call cc{{.*}} noalias i8* @"__invoke_i8*_i8_i8"(i8* (i8, i8)* @bar, i8 signext 1, i8 zeroext 2)
+; WASM32:  store i32 0, i32* @__THREW__
+; WASM64:  store i64 0, i64* @__THREW__
+; CHECK:   %0 = call cc{{.*}} noalias i8* @"__invoke_i8*_i8_i8"(i8* (i8, i8)* @bar, i8 signext 1, i8 zeroext 2)
 
 invoke.cont:                                      ; preds = %entry
   br label %try.cont
 
 lpad:                                             ; preds = %entry
   %1 = landingpad { i8*, i32 }
           catch i8* bitcast (i8** @_ZTIi to i8*)
           catch i8* null

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

-; RUN: opt < %s -wasm-lower-em-ehsjlj -S | FileCheck %s --check-prefixes=CHECK,NO-TLS
+; RUN: opt < %s -wasm-lower-em-ehsjlj -S | FileCheck %s --check-prefixes=CHECK,WASM32,NO-TLS
 ; RUN: opt < %s -wasm-lower-em-ehsjlj -S --mattr=+atomics,+bulk-memory | FileCheck %s --check-prefixes=CHECK,TLS
+; RUN: opt < %s -wasm-lower-em-ehsjlj --mtriple=wasm64-unknown-unknown -data-layout="e-m:e-p:64:64-i64:64-n32:64-S128" -S | FileCheck %s --check-prefixes=CHECK,WASM64
 
 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] }
 
 @global_var = global i32 0, align 4
 ; NO-TLS-DAG: __THREW__ = external global i32
 ; NO-TLS-DAG: __threwValue = external global i32
 ; TLS-DAG: __THREW__ = external thread_local(localexec) global i32
 ; TLS-DAG: __threwValue = external thread_local(localexec) global i32
+; WASM64-DAG: __THREW__ = external global i64
 @global_longjmp_ptr = global void (%struct.__jmp_buf_tag*, i32)* @longjmp, align 4
-; CHECK-DAG: @global_longjmp_ptr = global void (%struct.__jmp_buf_tag*, i32)* bitcast (void (i32, i32)* @emscripten_longjmp to void (%struct.__jmp_buf_tag*, i32)*)
+; WASM32-DAG: @global_longjmp_ptr = global void (%struct.__jmp_buf_tag*, i32)* bitcast (void (i32, i32)* @emscripten_longjmp to void (%struct.__jmp_buf_tag*, i32)*)
+; WASM64-DAG: @global_longjmp_ptr = global void (%struct.__jmp_buf_tag*, i32)* bitcast (void (i64, i32)* @emscripten_longjmp to void (%struct.__jmp_buf_tag*, i32)*)
 
 ; Test a simple setjmp - longjmp sequence
 define void @setjmp_longjmp() {
 ; CHECK-LABEL: @setjmp_longjmp
 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 = call i32 @setjmp(%struct.__jmp_buf_tag* %arraydecay) #0
   %arraydecay1 = 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* %arraydecay1, i32 1) #1
   unreachable
 ; CHECK: entry:
 ; CHECK-NEXT: %[[MALLOCCALL:.*]] = tail call i8* @malloc(i32 40)
 ; CHECK-NEXT: %[[SETJMP_TABLE:.*]] = bitcast i8* %[[MALLOCCALL]] to i32*
 ; CHECK-NEXT: store i32 0, i32* %[[SETJMP_TABLE]]
 ; CHECK-NEXT: %[[SETJMP_TABLE_SIZE:.*]] = add i32 4, 0
 ; CHECK-NEXT: %[[BUF:.*]] = alloca [1 x %struct.__jmp_buf_tag]
 ; CHECK-NEXT: %[[ARRAYDECAY:.*]] = getelementptr inbounds [1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* %[[BUF]], i32 0, i32 0
 ; CHECK-NEXT: %[[SETJMP_TABLE1:.*]] = call i32* @saveSetjmp(%struct.__jmp_buf_tag* %[[ARRAYDECAY]], i32 1, i32* %[[SETJMP_TABLE]], i32 %[[SETJMP_TABLE_SIZE]])
 ; CHECK-NEXT: %[[SETJMP_TABLE_SIZE1:.*]] = call i32 @getTempRet0()
 ; CHECK-NEXT: br label %entry.split
 
 ; CHECK: entry.split:
-; CHECK-NEXT: phi i32 [ 0, %entry ], [ %[[LONGJMP_RESULT:.*]], %if.end ]
-; CHECK-NEXT: %[[ARRAYDECAY1:.*]] = getelementptr inbounds [1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* %[[BUF]], i32 0, i32 0
-; CHECK-NEXT: %[[JMPBUF:.*]] = ptrtoint %struct.__jmp_buf_tag* %[[ARRAYDECAY1]] to i32
-; CHECK-NEXT: store i32 0, i32* @__THREW__
-; CHECK-NEXT: call cc{{.*}} void @__invoke_void_i32_i32(void (i32, i32)* @emscripten_longjmp, i32 %[[JMPBUF]], i32 1)
-; CHECK-NEXT: %[[__THREW__VAL:.*]] = load i32, i32* @__THREW__
-; CHECK-NEXT: store i32 0, i32* @__THREW__
-; CHECK-NEXT: %[[CMP0:.*]] = icmp ne i32 %__THREW__.val, 0
-; CHECK-NEXT: %[[THREWVALUE_VAL:.*]] = load i32, i32* @__threwValue
-; CHECK-NEXT: %[[CMP1:.*]] = icmp ne i32 %[[THREWVALUE_VAL]], 0
-; CHECK-NEXT: %[[CMP:.*]] = and i1 %[[CMP0]], %[[CMP1]]
-; CHECK-NEXT: br i1 %[[CMP]], label %if.then1, label %if.else1
+; CHECK-NEXT:  phi i32 [ 0, %entry ], [ %[[LONGJMP_RESULT:.*]], %if.end ]
+; CHECK-NEXT:  %[[ARRAYDECAY1:.*]] = getelementptr inbounds [1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* %[[BUF]], i32 0, i32 0
+; WASM32:      %[[JMPBUF:.*]] = ptrtoint %struct.__jmp_buf_tag* %[[ARRAYDECAY1]] to i32
+; WASM64:      %[[JMPBUF:.*]] = ptrtoint %struct.__jmp_buf_tag* %[[ARRAYDECAY1]] to i64
+; WASM32-NEXT: store i32 0, i32* @__THREW__
+; WASM64-NEXT: store i64 0, i64* @__THREW__
+; WASM32-NEXT: call cc{{.*}} void @__invoke_void_i32_i32(void (i32, i32)* @emscripten_longjmp, i32 %[[JMPBUF]], i32 1)
+; WASM64-NEXT: call cc{{.*}} void @__invoke_void_i64_i32(void (i64, i32)* @emscripten_longjmp, i64 %[[JMPBUF]], i32 1)
+; WASM32-NEXT: %[[__THREW__VAL:.*]] = load i32, i32* @__THREW__
+; WASM64-NEXT: %[[__THREW__VAL:.*]] = load i64, i64* @__THREW__
+; WASM32-NEXT: store i32 0, i32* @__THREW__
+; WASM64-NEXT: store i64 0, i64* @__THREW__
+; CHECK:       %[[CMP0:.*]] = icmp ne i{{32|64}} %__THREW__.val, 0
+; CHECK-NEXT:  %[[THREWVALUE_VAL:.*]] = load i32, i32* @__threwValue
+; CHECK-NEXT:  %[[CMP1:.*]] = icmp ne i32 %[[THREWVALUE_VAL]], 0
+; CHECK-NEXT:  %[[CMP:.*]] = and i1 %[[CMP0]], %[[CMP1]]
+; CHECK-NEXT:  br i1 %[[CMP]], label %if.then1, label %if.else1
 
 ; CHECK: entry.split.split:
 ; CHECK-NEXT: unreachable
 
 ; CHECK: if.then1:
-; CHECK-NEXT: %[[__THREW__VAL_I32P:.*]] = inttoptr i32 %[[__THREW__VAL]] to i32*
-; CHECK-NEXT: %[[__THREW__VAL_I32P_LOADED:.*]] = load i32, i32* %[[__THREW__VAL_I32P]]
-; CHECK-NEXT: %[[LABEL:.*]] = call i32 @testSetjmp(i32 %[[__THREW__VAL_I32P_LOADED]], i32* %[[SETJMP_TABLE1]], i32 %[[SETJMP_TABLE_SIZE1]])
-; CHECK-NEXT: %[[CMP:.*]] = icmp eq i32 %[[LABEL]], 0
-; CHECK-NEXT: br i1 %[[CMP]], label %if.then2, label %if.end2
+; WASM32:      %[[__THREW__VAL_P:.*]] = inttoptr i32 %[[__THREW__VAL]] to i32*
+; WASM64:      %[[__THREW__VAL_P:.*]] = inttoptr i64 %[[__THREW__VAL]] to i64*
+; WASM32-NEXT: %[[__THREW__VAL_P_LOADED:.*]] = load i32, i32* %[[__THREW__VAL_P]]
+; WASM64-NEXT: %[[__THREW__VAL_P_LOADED:.*]] = load i64, i64* %[[__THREW__VAL_P]]
+; WASM32-NEXT: %[[LABEL:.*]] = call i32 @testSetjmp(i32 %[[__THREW__VAL_P_LOADED]], i32* %[[SETJMP_TABLE1]], i32 %[[SETJMP_TABLE_SIZE1]])
+; WASM64-NEXT: %[[LABEL:.*]] = call i32 @testSetjmp(i64 %[[__THREW__VAL_P_LOADED]], i32* %[[SETJMP_TABLE1]], i32 %[[SETJMP_TABLE_SIZE1]])
+; CHECK:       %[[CMP:.*]] = icmp eq i32 %{{.*}}, 0
+; CHECK-NEXT:  br i1 %[[CMP]], label %if.then2, label %if.end2
 
 ; CHECK: if.else1:
 ; CHECK-NEXT: br label %if.end
 
 ; CHECK: if.end:
-; CHECK-NEXT: %[[LABEL_PHI:.*]] = phi i32 [ %[[LABEL:.*]], %if.end2 ], [ -1, %if.else1 ]
-; CHECK-NEXT: %[[LONGJMP_RESULT]] = call i32 @getTempRet0()
-; CHECK-NEXT: switch i32 %[[LABEL_PHI]], label %entry.split.split [
-; CHECK-NEXT:   i32 1, label %entry.split
+; WASM32:     %[[LABEL_PHI:.*]] = phi i32 [ %[[LABEL:.*]], %if.end2 ], [ -1, %if.else1 ]
+; WASM64:     %[[LABEL_PHI:.*]] = phi i32 [ %[[LABEL:.*]], %if.end2 ], [ -1, %if.else1 ]
+; CHECK:      %[[LONGJMP_RESULT]] = call i32 @getTempRet0()
+; WASM32:     switch i32 %[[LABEL_PHI]], label %entry.split.split [
+; WASM64:     switch i32 %[[LABEL_PHI]], label %entry.split.split [
+; CHECK:        i32 1, label %entry.split
 ; CHECK-NEXT: ]
 
 ; CHECK: if.then2:
-; CHECK-NEXT: call void @emscripten_longjmp(i32 %[[__THREW__VAL]], i32 %[[THREWVALUE_VAL]])
-; CHECK-NEXT: unreachable
+; WASM32-NEXT: call void @emscripten_longjmp(i32 %[[__THREW__VAL]], i32 %[[THREWVALUE_VAL]])
+; WASM64-NEXT: call void @emscripten_longjmp(i64 %[[__THREW__VAL]], i32 %[[THREWVALUE_VAL]])
+; CHECK:       unreachable
 
 ; CHECK: if.end2:
 ; CHECK-NEXT: call void  @setTempRet0(i32 %[[THREWVALUE_VAL]])
 ; CHECK-NEXT: br label %if.end
 }
 
 ; Test a case of a function call (which is not longjmp) after a setjmp
 define void @setjmp_other() {

 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 = call i32 @setjmp(%struct.__jmp_buf_tag* %arraydecay) #0
   invoke void @foo()
           to label %try.cont unwind label %lpad
 
 ; CHECK: entry.split:
-; CHECK: store i32 0, i32* @__THREW__
-; CHECK-NEXT: call cc{{.*}} void @__invoke_void(void ()* @foo)
-; CHECK-NEXT: %[[__THREW__VAL:.*]] = load i32, i32* @__THREW__
-; CHECK-NEXT: store i32 0, i32* @__THREW__
-; CHECK-NEXT: %[[CMP0:.*]] = icmp ne i32 %[[__THREW__VAL]], 0
-; CHECK-NEXT: %[[THREWVALUE_VAL:.*]] = load i32, i32* @__threwValue
-; CHECK-NEXT: %[[CMP1:.*]] = icmp ne i32 %[[THREWVALUE_VAL]], 0
-; CHECK-NEXT: %[[CMP:.*]] = and i1 %[[CMP0]], %[[CMP1]]
-; CHECK-NEXT: br i1 %[[CMP]], label %if.then1, label %if.else1
+; WASM32:      store i32 0, i32* @__THREW__
+; WASM64:      store i64 0, i64* @__THREW__
+; CHECK:       call cc{{.*}} void @__invoke_void(void ()* @foo)
+; WASM32:      %[[__THREW__VAL:.*]] = load i32, i32* @__THREW__
+; WASM64:      %[[__THREW__VAL:.*]] = load i64, i64* @__THREW__
+; WASM32-NEXT: store i32 0, i32* @__THREW__
+; WASM64-NEXT: store i64 0, i64* @__THREW__
+; WASM32-NEXT: %{{.*}} = icmp ne i32 %[[__THREW__VAL]], 0
+; WASM64-NEXT: %{{.*}} = icmp ne i64 %[[__THREW__VAL]], 0
+; CHECK:       %[[THREWVALUE_VAL:.*]] = load i32, i32* @__threwValue
+; CHECK-NEXT:  %[[CMP1:.*]] = icmp ne i32 %[[THREWVALUE_VAL]], 0
+; CHECK-NEXT:  %[[CMP:.*]] = and i1 %{{.*}}, %[[CMP1]]
+; CHECK-NEXT:  br i1 %[[CMP]], label %if.then1, label %if.else1
 
 ; CHECK: entry.split.split:
-; CHECK-NEXT: %[[CMP:.*]] = icmp eq i32 %[[__THREW__VAL]], 1
-; CHECK-NEXT: br i1 %[[CMP]], label %lpad, label %try.cont
+; WASM32:      %[[CMP:.*]] = icmp eq i32 %[[__THREW__VAL]], 1
+; WASM64:      %[[CMP:.*]] = icmp eq i64 %[[__THREW__VAL]], 1
+; WASM32-NEXT: br i1 %[[CMP]], label %lpad, label %try.cont
+; WASM64-NEXT: br i1 %[[CMP]], label %lpad, label %try.cont
 
 lpad:                                             ; preds = %entry
   %0 = landingpad { i8*, i32 }
           catch i8* null
   %1 = extractvalue { i8*, i32 } %0, 0
   %2 = extractvalue { i8*, i32 } %0, 1
   %3 = call i8* @__cxa_begin_catch(i8* %1) #2
   call void @__cxa_end_catch()
   br label %try.cont
 
 try.cont:                                         ; preds = %entry, %lpad
   ret void
 }
 
 ; Test SSA validity
 define void @ssa(i32 %n) {
 ; CHECK-LABEL: @ssa
 entry:
   %buf = alloca [1 x %struct.__jmp_buf_tag], align 16
   %cmp = icmp sgt i32 %n, 5
   br i1 %cmp, label %if.then, label %if.end
 ; CHECK: entry:
-; CHECK: %[[SETJMP_TABLE0:.*]] = bitcast i8*
-; CHECK: %[[SETJMP_TABLE_SIZE0:.*]] = add i32 4, 0
+; CHECK:   %[[SETJMP_TABLE0:.*]] = bitcast i8*
+; CHECK:   %[[SETJMP_TABLE_SIZE0:.*]] = add i32 4, 0
 
 if.then:                                          ; preds = %entry
   %0 = load i32, i32* @global_var, align 4
   %arraydecay = getelementptr inbounds [1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* %buf, i32 0, i32 0
   %call = call i32 @setjmp(%struct.__jmp_buf_tag* %arraydecay) #0
   store i32 %0, i32* @global_var, align 4
   br label %if.end
 ; CHECK: if.then:
-; CHECK: %[[VAR0:.*]] = load i32, i32* @global_var, align 4
-; CHECK: %[[SETJMP_TABLE1:.*]] = call i32* @saveSetjmp(
+; CHECK:      %[[VAR0:.*]] = load i32, i32* @global_var, align 4
+; CHECK:      %[[SETJMP_TABLE1:.*]] = call i32* @saveSetjmp(
 ; CHECK-NEXT: %[[SETJMP_TABLE_SIZE1:.*]] = call i32 @getTempRet0()
 
 ; CHECK: if.then.split:
-; CHECK: %[[VAR1:.*]] = phi i32 [ %[[VAR0]], %if.then ], [ %[[VAR2:.*]], %if.end3 ]
-; CHECK: %[[SETJMP_TABLE_SIZE2:.*]] = phi i32 [ %[[SETJMP_TABLE_SIZE1]], %if.then ], [ %[[SETJMP_TABLE_SIZE3:.*]], %if.end3 ]
-; CHECK: %[[SETJMP_TABLE2:.*]] = phi i32* [ %[[SETJMP_TABLE1]], %if.then ], [ %[[SETJMP_TABLE3:.*]], %if.end3 ]
-; CHECK: store i32 %[[VAR1]], i32* @global_var, align 4
+; CHECK:   %[[VAR1:.*]] = phi i32 [ %[[VAR0]], %if.then ], [ %[[VAR2:.*]], %if.end3 ]
+; CHECK:   %[[SETJMP_TABLE_SIZE2:.*]] = phi i32 [ %[[SETJMP_TABLE_SIZE1]], %if.then ], [ %[[SETJMP_TABLE_SIZE3:.*]], %if.end3 ]
+; CHECK:   %[[SETJMP_TABLE2:.*]] = phi i32* [ %[[SETJMP_TABLE1]], %if.then ], [ %[[SETJMP_TABLE3:.*]], %if.end3 ]
+; CHECK:   store i32 %[[VAR1]], i32* @global_var, align 4
 
 if.end:                                           ; preds = %if.then, %entry
   %arraydecay1 = 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* %arraydecay1, i32 5) #1
   unreachable
 ; CHECK: if.end:
-; CHECK: %[[VAR2]] = phi i32 [ %[[VAR1]], %if.then.split ], [ undef, %entry ]
-; CHECK: %[[SETJMP_TABLE_SIZE3]] = phi i32 [ %[[SETJMP_TABLE_SIZE2]], %if.then.split ], [ %[[SETJMP_TABLE_SIZE0]], %entry ]
-; CHECK: %[[SETJMP_TABLE3]] = phi i32* [ %[[SETJMP_TABLE2]], %if.then.split ], [ %[[SETJMP_TABLE0]], %entry ]
+; CHECK:   %[[VAR2]] = phi i32 [ %[[VAR1]], %if.then.split ], [ undef, %entry ]
+; CHECK:   %[[SETJMP_TABLE_SIZE3]] = phi i32 [ %[[SETJMP_TABLE_SIZE2]], %if.then.split ], [ %[[SETJMP_TABLE_SIZE0]], %entry ]
+; CHECK:   %[[SETJMP_TABLE3]] = phi i32* [ %[[SETJMP_TABLE2]], %if.then.split ], [ %[[SETJMP_TABLE0]], %entry ]
 }
 
 ; Test a case when a function only calls other functions that are neither setjmp nor longjmp
 define void @only_other_func() {
 entry:
   call void @foo()
   ret void
 ; CHECK: call void @foo()
 }
 
 ; Test a case when a function only calls longjmp and not setjmp
 define void @only_longjmp() {
 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: %[[JMPBUF:.*]] = ptrtoint
-; CHECK-NEXT: call void @emscripten_longjmp(i32 %[[JMPBUF]], i32 5)
+; WASM32: call void @emscripten_longjmp(i32 %[[JMPBUF]], i32 5)
+; WASM64: call void @emscripten_longjmp(i64 %[[JMPBUF]], i32 5)
 }
 
 ; Test inline asm handling
 define void @inline_asm() {
 ; 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

 ; CHECK-LABEL: @indirect_longjmp
 entry:
   %local_longjmp_ptr = alloca void (%struct.__jmp_buf_tag*, i32)*, align 4
   %buf0 = alloca [1 x %struct.__jmp_buf_tag], align 16
   %buf1 = alloca [1 x %struct.__jmp_buf_tag], align 16
 
   ; Store longjmp in a local variable, load it, and call it
   store void (%struct.__jmp_buf_tag*, i32)* @longjmp, void (%struct.__jmp_buf_tag*, i32)** %local_longjmp_ptr, align 4
-  ; CHECK: store void (%struct.__jmp_buf_tag*, i32)* bitcast (void (i32, i32)* @emscripten_longjmp to void (%struct.__jmp_buf_tag*, i32)*), void (%struct.__jmp_buf_tag*, i32)** %local_longjmp_ptr, align 4
+  ; WASM32: store void (%struct.__jmp_buf_tag*, i32)* bitcast (void (i32, i32)* @emscripten_longjmp to void (%struct.__jmp_buf_tag*, i32)*), void (%struct.__jmp_buf_tag*, i32)** %local_longjmp_ptr, align 4
+  ; WASM64: store void (%struct.__jmp_buf_tag*, i32)* bitcast (void (i64, i32)* @emscripten_longjmp to void (%struct.__jmp_buf_tag*, i32)*), void (%struct.__jmp_buf_tag*, i32)** %local_longjmp_ptr, align 4
   %longjmp_from_local_ptr = load void (%struct.__jmp_buf_tag*, i32)*, void (%struct.__jmp_buf_tag*, i32)** %local_longjmp_ptr, align 4
   %arraydecay = getelementptr inbounds [1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* %buf0, i32 0, i32 0
   call void %longjmp_from_local_ptr(%struct.__jmp_buf_tag* %arraydecay, i32 0)
 
   ; Load longjmp from a global variable and call it
   %longjmp_from_global_ptr = load void (%struct.__jmp_buf_tag*, i32)*, void (%struct.__jmp_buf_tag*, i32)** @global_longjmp_ptr, align 4
   %arraydecay1 = getelementptr inbounds [1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* %buf1, i32 0, i32 0
   call void %longjmp_from_global_ptr(%struct.__jmp_buf_tag* %arraydecay1, i32 0)
 
   ; Pass longjmp as a function argument. This is a call but longjmp is not a
   ; callee but an argument.
   call void @take_longjmp(void (%struct.__jmp_buf_tag*, i32)* @longjmp)
-  ; CHECK: call void @take_longjmp(void (%struct.__jmp_buf_tag*, i32)* bitcast (void (i32, i32)* @emscripten_longjmp to void (%struct.__jmp_buf_tag*, i32)*))
+  ; WASM32: call void @take_longjmp(void (%struct.__jmp_buf_tag*, i32)* bitcast (void (i32, i32)* @emscripten_longjmp to void (%struct.__jmp_buf_tag*, i32)*))
+  ; WASM64: call void @take_longjmp(void (%struct.__jmp_buf_tag*, i32)* bitcast (void (i64, i32)* @emscripten_longjmp to void (%struct.__jmp_buf_tag*, i32)*))
   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()
 declare i8* @malloc(i32)
 declare void @free(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(i32, i32)
+; WASM32-DAG: declare i32 @testSetjmp(i32, i32*, i32)
+; WASM64-DAG: declare i32 @testSetjmp(i64, i32*, i32)
+; WASM32-DAG: declare void @emscripten_longjmp(i32, i32)
+; WASM64-DAG: declare void @emscripten_longjmp(i64, i32)
 ; CHECK-DAG: declare void @__invoke_void(void ()*)
 
 attributes #0 = { returns_twice }
 attributes #1 = { noreturn }
 attributes #2 = { nounwind }
 attributes #3 = { allocsize(0) }
 ; CHECK-DAG: attributes #{{[0-9]+}} = { nounwind "wasm-import-module"="env" "wasm-import-name"="getTempRet0" }
 ; CHECK-DAG: attributes #{{[0-9]+}} = { nounwind "wasm-import-module"="env" "wasm-import-name"="setTempRet0" }