[WebAssembly] Make EH work with dynamic linking

[aheejin]

Summary

This makes Wasm EH work with dynamic linking. So far we were only able
to handle destructors, which do not use any tags or LSDA info.

1. This uses TargetExternalSymbol for GCC_except_tableN symbols, which points to the address of per-function LSDA info. It is more convenient to use than MCSymbol because it can take additional target flags.

2. When lowering wasm_lsda intrinsic, if PIC is enabled, make the symbol relative to __memory_base and generate the add node. If PIC is disabled, continue to use the absolute address.

3. Make tag symbols (__cpp_exception and __c_longjmp) undefined in the backend, because it is hard to make it work with dynamic linking's loading order. Instead, we make all tag symbols undefined in the LLVM backend and import it from JS.

4. Add support for undefined tags to the linker.

Companion patches:

• https://github.com/WebAssembly/binaryen/pull/4223
• https://github.com/emscripten-core/emscripten/pull/15266

[aheejin]

llvm/lib/Object/WasmObjectFile.cpp

1127–1129

This was deleted by mistake in D111086. It was fine with that patch because until now we don't have any case of tag imports.

llvm/lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp

281–284

Now we are using LSDA symbol with target flags, for this I removed this comment and assert.

287–293

I tried to remove this MO_MCSymbol case altogether, but it turned out this case is used by __funcref_call_table and __indirect_call_table. So I only deleted the (already incorrect) comment.

[aheejin]

lld/test/wasm/tag-section.ll

14

I'm not very sure what each of --experimental-pic and -pie does... Without --experimental-pic this doesn't work and without -pie it emits a warning, so I ended up putting both.

[sbc100]

lld/test/wasm/tag-section.ll

14

Yes, you need them both today. -pie is experimental so you need to opt into this feature. -pie outputs a position independent executable, which is what emscripten used for MAIN_MODULE today.

52

Maybe add ; PIC-NOT: - Type: TAG ?

lld/wasm/InputFiles.cpp

670

Maybe remove of rephrase this comment.. It conceivable that other folks could build other object (either via .s or some other mechanism that could contain undefined tags). Or remove the limitation?

I'm curious why the compiler wasn't complaining before if this enum value was missing from this swtich?

lld/wasm/Symbols.h

70

Maybe follow the pattern of one comparison per line here?

llvm/test/CodeGen/WebAssembly/eh-lsda.ll

4

It seems like a shame to use coverage of eh-lsda for the non-emscripten targets? cna you remove the target tripple completely here and instead set it from the command line. Then you can use emscripten for the PIC test and unknown for the non-PIC test?

[aheejin]

Address comments + improve test

lld/wasm/InputFiles.cpp

670

Maybe remove of rephrase this comment.. It conceivable that other folks could build other object (either via .s or some other mechanism that could contain undefined tags). Or remove the limitation?

Removed the limitation.

I'm curious why the compiler wasn't complaining before if this enum value was missing from this swtich?

I think it's because WasmSymbolInfo.Kind's type is not enum WasmSymbolType but uint32_t: https://github.com/llvm/llvm-project/blob/63aab4065b452ae5693481dfd12fed3c184261c7/llvm/include/llvm/BinaryFormat/Wasm.h#L192

lld/wasm/Symbols.h

70

This is what clang-format insists. Currently our wasm lld code conforms to clang-format nearly 99%, so I'm not sure if this is worth making an exception..?

llvm/test/CodeGen/WebAssembly/eh-lsda.ll

4

For EH/LSDA we don't do anything differently for emscripten and non-emscripten targets, but yeah, will change to a command line argument, and also will add wasm64 tests. So this will test 6 combinations:

1. wasm32-unknown-unknown
2. wasm64-unknown-unknown
3. wasm32-unknown-emscripten
4. wasm64-unknown-emscripten
5. wasm32-unknown-emscripten + PIC
6. wasm64-unknown-emscripten + PIC

[sbc100]

lld/wasm/Symbols.h

70

Clang-format is the boss I guess.

lld/test/wasm/Inputs/tag-section1.ll

 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32-unknown-unknown"
+target triple = "wasm32-unknown-emscripten"
 
 declare void @llvm.wasm.throw(i32, i8*)
 
 define void @foo(i8* %p) {
   call void @llvm.wasm.throw(i32 0, i8* %p)
   ret void
 }

lld/test/wasm/Inputs/tag-section2.ll

 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32-unknown-unknown"
+target triple = "wasm32-unknown-emscripten"
 
 declare void @llvm.wasm.throw(i32, i8*)
 
 define void @bar(i8* %p) {
   call void @llvm.wasm.throw(i32 0, i8* %p)
   ret void
 }

lld/test/wasm/tag-section.ll

+; Static code
 ; RUN: llc -filetype=obj -wasm-enable-eh -exception-model=wasm -mattr=+exception-handling %p/Inputs/tag-section1.ll -o %t1.o
 ; RUN: llc -filetype=obj -wasm-enable-eh -exception-model=wasm -mattr=+exception-handling %p/Inputs/tag-section2.ll -o %t2.o
 ; RUN: llc -filetype=obj -wasm-enable-eh -exception-model=wasm -mattr=+exception-handling %s -o %t.o
 ; RUN: wasm-ld -o %t.wasm %t.o %t1.o %t2.o
 ; RUN: wasm-ld --export-all -o %t-export-all.wasm %t.o %t1.o %t2.o
-; RUN: obj2yaml %t.wasm | FileCheck %s
-; RUN: obj2yaml %t-export-all.wasm | FileCheck %s --check-prefix=EXPORT-ALL
+; RUN: obj2yaml %t.wasm | FileCheck %s --check-prefix=NOPIC
+; RUN: obj2yaml %t-export-all.wasm | FileCheck %s --check-prefix=NOPIC-EXPORT-ALL
+
+; PIC code
+; RUN: llc -filetype=obj -wasm-enable-eh -exception-model=wasm -mattr=+exception-handling -relocation-model=pic %p/Inputs/tag-section1.ll -o %t1.o
+; RUN: llc -filetype=obj -wasm-enable-eh -exception-model=wasm -mattr=+exception-handling -relocation-model=pic %p/Inputs/tag-section2.ll -o %t2.o
+; RUN: llc -filetype=obj -wasm-enable-eh -exception-model=wasm -mattr=+exception-handling -relocation-model=pic %s -o %t.o
+; RUN: wasm-ld --import-undefined --experimental-pic -pie -o %t.wasm %t.o %t1.o %t2.o
+; RUN: obj2yaml %t.wasm | FileCheck %s --check-prefix=PIC
 
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32-unknown-unknown"
+target triple = "wasm32-unknown-emscripten"
 
 declare void @foo(i8*)
 declare void @bar(i8*)
 
 define void @_start() {
   call void @foo(i8* null)
   call void @bar(i8* null)
   ret void
 }
 
-; CHECK:      Sections:
-; CHECK-NEXT:   - Type:            TYPE
-; CHECK-NEXT:     Signatures:
-; CHECK-NEXT:       - Index:           0
-; CHECK-NEXT:         ParamTypes:      []
-; CHECK-NEXT:         ReturnTypes:     []
-; CHECK-NEXT:       - Index:           1
-; CHECK-NEXT:         ParamTypes:
-; CHECK-NEXT:           - I32
-; CHECK-NEXT:         ReturnTypes:     []
+; NOPIC:      Sections:
+; NOPIC-NEXT:   - Type:            TYPE
+; NOPIC-NEXT:     Signatures:
+; NOPIC-NEXT:       - Index:           0
+; NOPIC-NEXT:         ParamTypes:      []
+; NOPIC-NEXT:         ReturnTypes:     []
+; NOPIC-NEXT:       - Index:           1
+; NOPIC-NEXT:         ParamTypes:
+; NOPIC-NEXT:           - I32
+; NOPIC-NEXT:         ReturnTypes:     []
 
-; CHECK:        - Type:            TAG
-; CHECK-NEXT:     TagTypes:        [ 1 ]
+; NOPIC:        - Type:            TAG
+; NOPIC-NEXT:     TagTypes:        [ 1 ]
 
 ; Global section has to come after tag section
-; CHECK:        - Type:            GLOBAL
+; NOPIC:        - Type:            GLOBAL
 
-; EXPORT-ALL:   - Type:            EXPORT
-; EXPORT-ALL-NEXT Exports:
-; EXPORT-ALL:       - Name:            __cpp_exception
-; EXPORT-ALL:         Kind:            TAG
-; EXPORT-ALL:         Index:           0
+; NOPIC-EXPORT-ALL:   - Type:            EXPORT
+; NOPIC-EXPORT-ALL-NEXT Exports:
+; NOPIC-EXPORT-ALL:       - Name:            __cpp_exception
+; NOPIC-EXPORT-ALL:         Kind:            TAG
+; NOPIC-EXPORT-ALL:         Index:           0
+
+; In PIC mode, tags are undefined and imported from JS.
+; PIC:        Sections:
+; PIC:         - Type:            TYPE
+; PIC-NEXT:      Signatures:
+; PIC-NEXT:        - Index:           0
+; PIC-NEXT:          ParamTypes:
+; PIC-NEXT:            - I32
+; PIC-NEXT:          ReturnTypes:     []
+; PIC-NEXT:        - Index:           1
+; PIC-NEXT:          ParamTypes:      []
+; PIC-NEXT:          ReturnTypes:     []
+
+; PIC:         - Type:            IMPORT
+; PIC-NEXT:      Imports:
+; PIC:             - Module:          env
+; PIC:               Field:           __cpp_exception
+; PIC-NEXT:          Kind:            TAG
+; PIC-NEXT:          SigIndex:        0

lld/wasm/InputFiles.cpp

Symbol *ObjFile::createUndefined(const WasmSymbol &sym, bool isCalledDirectly) {
   case WASM_SYMBOL_TYPE_TABLE:
     if (sym.isBindingLocal())
       return make<UndefinedTable>(name, sym.Info.ImportName,
                                   sym.Info.ImportModule, flags, this,
                                   sym.TableType);
     return symtab->addUndefinedTable(name, sym.Info.ImportName,
                                      sym.Info.ImportModule, flags, this,
                                      sym.TableType);
+  case WASM_SYMBOL_TYPE_TAG:
+    // We only enter here when there are tag symbols for C++ exceptions
+    // (__cpp_exception) or C longjmp (__c_longjmp) and we use dynamic linking
+    // in which we don't define those symbols. These symbols are always binding
+    // global.
+    assert(sym.isBindingGlobal());
+    return symtab->addUndefinedTag(name, sym.Info.ImportName,
+                                   sym.Info.ImportModule, flags, this,
+                                   sym.Signature);
   case WASM_SYMBOL_TYPE_SECTION:
     llvm_unreachable("section symbols cannot be undefined");
   }
   llvm_unreachable("unknown symbol kind");
 }
 
 void ArchiveFile::parse() {
   // Parse a MemoryBufferRef as an archive file.

lld/wasm/SymbolTable.h

Symbol *addUndefinedGlobal(StringRef name,
                              llvm::Optional<StringRef> importModule,
                              uint32_t flags, InputFile *file,
                              const WasmGlobalType *type);
   Symbol *addUndefinedTable(StringRef name,
                             llvm::Optional<StringRef> importName,
                             llvm::Optional<StringRef> importModule,
                             uint32_t flags, InputFile *file,
                             const WasmTableType *type);
+  Symbol *addUndefinedTag(StringRef name, llvm::Optional<StringRef> importName,
+                          llvm::Optional<StringRef> importModule,
+                          uint32_t flags, InputFile *file,
+                          const WasmSignature *sig);
 
   TableSymbol *resolveIndirectFunctionTable(bool required);
 
   void addLazy(ArchiveFile *f, const llvm::object::Archive::Symbol *sym);
 
   bool addComdat(StringRef name);
 
   DefinedData *addSyntheticDataSymbol(StringRef name, uint32_t flags);

lld/wasm/SymbolTable.cpp

replaceSymbol<UndefinedTable>(s, name, importName, importModule, flags,
                                   file, type);
   else if (auto *lazy = dyn_cast<LazySymbol>(s))
     lazy->fetch();
   else if (s->isDefined())
     checkTableType(s, file, type);
   return s;
 }
 
+Symbol *SymbolTable::addUndefinedTag(StringRef name,
+                                     Optional<StringRef> importName,
+                                     Optional<StringRef> importModule,
+                                     uint32_t flags, InputFile *file,
+                                     const WasmSignature *sig) {
+  LLVM_DEBUG(dbgs() << "addUndefinedTag: " << name << "\n");
+  assert(flags & WASM_SYMBOL_UNDEFINED);
+
+  Symbol *s;
+  bool wasInserted;
+  std::tie(s, wasInserted) = insert(name, file);
+  if (s->traced)
+    printTraceSymbolUndefined(name, file);
+
+  if (wasInserted)
+    replaceSymbol<UndefinedTag>(s, name, importName, importModule, flags, file,
+                                sig);
+  else if (auto *lazy = dyn_cast<LazySymbol>(s))
+    lazy->fetch();
+  else if (s->isDefined())
+    checkTagType(s, file, sig);
+  return s;
+}
+
 TableSymbol *SymbolTable::createUndefinedIndirectFunctionTable(StringRef name) {
   WasmLimits limits{0, 0, 0}; // Set by the writer.
   WasmTableType *type = make<WasmTableType>();
   type->ElemType = uint8_t(ValType::FUNCREF);
   type->Limits = limits;
   StringRef module(defaultModule);
   uint32_t flags = config->exportTable ? 0 : WASM_SYMBOL_VISIBILITY_HIDDEN;
   flags |= WASM_SYMBOL_UNDEFINED;

lld/wasm/Symbols.h

enum Kind : uint8_t {
     DefinedTagKind,
     DefinedTableKind,
     SectionKind,
     OutputSectionKind,
     UndefinedFunctionKind,
     UndefinedDataKind,
     UndefinedGlobalKind,
     UndefinedTableKind,
+    UndefinedTagKind,
     LazyKind,
   };
 
   Kind kind() const { return symbolKind; }
 
   bool isDefined() const { return !isLazy() && !isUndefined(); }
 
   bool isUndefined() const {
     return symbolKind == UndefinedFunctionKind ||
            symbolKind == UndefinedDataKind ||
            symbolKind == UndefinedGlobalKind ||
-           symbolKind == UndefinedTableKind;
+           symbolKind == UndefinedTableKind || symbolKind == UndefinedTagKind;
   }
 
   bool isLazy() const { return symbolKind == LazyKind; }
 
   bool isLocal() const;
   bool isWeak() const;
   bool isHidden() const;
   bool isTLS() const;

 // would have a distinct tag. Wasm can filter the exceptions it catches based on
 // their tag.
 //
 // A single TagSymbol object represents a single tag. The C++ exception symbol
 // is a weak symbol generated in every object file in which exceptions are used,
 // and is named '__cpp_exception' for linking.
 class TagSymbol : public Symbol {
 public:
-  static bool classof(const Symbol *s) { return s->kind() == DefinedTagKind; }
+  static bool classof(const Symbol *s) {
+    return s->kind() == DefinedTagKind || s->kind() == UndefinedTagKind;
+  }
 
   // Get/set the tag index
   uint32_t getTagIndex() const;
   void setTagIndex(uint32_t index);
   bool hasTagIndex() const;
 
   const WasmSignature *signature;
 

 public:
   DefinedTag(StringRef name, uint32_t flags, InputFile *file, InputTag *tag);
 
   static bool classof(const Symbol *s) { return s->kind() == DefinedTagKind; }
 
   InputTag *tag;
 };
 
+class UndefinedTag : public TagSymbol {
+public:
+  UndefinedTag(StringRef name, llvm::Optional<StringRef> importName,
+               llvm::Optional<StringRef> importModule, uint32_t flags,
+               InputFile *file = nullptr, const WasmSignature *sig = nullptr)
+      : TagSymbol(name, UndefinedTagKind, flags, file, sig) {
+    this->importName = importName;
+    this->importModule = importModule;
+  }
+
+  static bool classof(const Symbol *s) { return s->kind() == UndefinedTagKind; }
+};
+
 // LazySymbol represents a symbol that is not yet in the link, but we know where
 // to find it if needed. If the resolver finds both Undefined and Lazy for the
 // same name, it will ask the Lazy to load a file.
 //
 // A special complication is the handling of weak undefined symbols. They should
 // not load a file, but we have to remember we have seen both the weak undefined
 // and the lazy. We represent that with a lazy symbol with a weak binding. This
 // means that code looking for undefined symbols normally also has to take lazy

lld/wasm/Symbols.cpp

std::string toString(wasm::Symbol::Kind kind) {
   case wasm::Symbol::UndefinedFunctionKind:
     return "UndefinedFunction";
   case wasm::Symbol::UndefinedDataKind:
     return "UndefinedData";
   case wasm::Symbol::UndefinedGlobalKind:
     return "UndefinedGlobal";
   case wasm::Symbol::UndefinedTableKind:
     return "UndefinedTable";
+  case wasm::Symbol::UndefinedTagKind:
+    return "UndefinedTag";
   case wasm::Symbol::LazyKind:
     return "LazyKind";
   case wasm::Symbol::SectionKind:
     return "SectionKind";
   case wasm::Symbol::OutputSectionKind:
     return "OutputSectionKind";
   }
   llvm_unreachable("invalid symbol kind");
WasmSymbolType Symbol::getWasmType() const {
   if (isa<SectionSymbol>(this) || isa<OutputSectionSymbol>(this))
     return WASM_SYMBOL_TYPE_SECTION;
   llvm_unreachable("invalid symbol kind");
 }
 
 const WasmSignature *Symbol::getSignature() const {
   if (auto* f = dyn_cast<FunctionSymbol>(this))
     return f->signature;
+  if (auto *t = dyn_cast<TagSymbol>(this))
+    return t->signature;
   if (auto *l = dyn_cast<LazySymbol>(this))
     return l->signature;
   return nullptr;
 }
 
 InputChunk *Symbol::getChunk() const {
   if (auto *f = dyn_cast<DefinedFunction>(this))
     return f->function;

lld/wasm/SyntheticSections.h

protected:
   bool isSealed = false;
   unsigned numImportedGlobals = 0;
   unsigned numImportedFunctions = 0;
   unsigned numImportedTags = 0;
   unsigned numImportedTables = 0;
   llvm::DenseMap<ImportKey<WasmGlobalType>, uint32_t> importedGlobals;
   llvm::DenseMap<ImportKey<WasmSignature>, uint32_t> importedFunctions;
   llvm::DenseMap<ImportKey<WasmTableType>, uint32_t> importedTables;
+  llvm::DenseMap<ImportKey<WasmSignature>, uint32_t> importedTags;
 };
 
 class FunctionSection : public SyntheticSection {
 public:
   FunctionSection() : SyntheticSection(llvm::wasm::WASM_SEC_FUNCTION) {}
 
   bool isNeeded() const override { return inputFunctions.size() > 0; };
   void writeBody() override;

lld/wasm/SyntheticSections.cpp

if (auto *f = dyn_cast<FunctionSymbol>(sym)) {
     auto entry = importedGlobals.try_emplace(key, numImportedGlobals);
     if (entry.second) {
       importedSymbols.emplace_back(sym);
       g->setGlobalIndex(numImportedGlobals++);
     } else {
       g->setGlobalIndex(entry.first->second);
     }
   } else if (auto *t = dyn_cast<TagSymbol>(sym)) {
-    // NB: There's currently only one possible kind of tag, and no
-    // `UndefinedTag`, so we don't bother de-duplicating tag imports.
+    ImportKey<WasmSignature> key(*(t->getSignature()), module, name);
+    auto entry = importedTags.try_emplace(key, numImportedTags);
+    if (entry.second) {
       importedSymbols.emplace_back(sym);
       t->setTagIndex(numImportedTags++);
     } else {
+      t->setTagIndex(entry.first->second);
+    }
+  } else {
     assert(TableSymbol::classof(sym));
     auto *table = cast<TableSymbol>(sym);
     ImportKey<WasmTableType> key(*(table->getTableType()), module, name);
     auto entry = importedTables.try_emplace(key, numImportedTables);
     if (entry.second) {
       importedSymbols.emplace_back(sym);
       table->setTableNumber(numImportedTables++);
     } else {

llvm/lib/CodeGen/AsmPrinter/WasmException.cpp

 using namespace llvm;
 
 void WasmException::endModule() {
   // These are symbols used to throw/catch C++ exceptions and C longjmps. These
   // symbols have to be emitted somewhere once in the module. Check if each of
   // the symbols has already been created, i.e., we have at least one 'throw' or
   // 'catch' instruction with the symbol in the module, and emit the symbol only
   // if so.
+  //
+  // But in dynamic linking, it is in general not possible to come up with a
+  // module instantiating order in which tag-defining modules are loaded before
+  // the importing modules. So we make them undefined symbols here, define tags
+  // in the JS side, and feed them to each importing module.
+  if (!Asm->isPositionIndependent()) {
     for (const char *SymName : {"__cpp_exception", "__c_longjmp"}) {
       SmallString<60> NameStr;
       Mangler::getNameWithPrefix(NameStr, SymName, Asm->getDataLayout());
       if (Asm->OutContext.lookupSymbol(NameStr)) {
         MCSymbol *ExceptionSym = Asm->GetExternalSymbolSymbol(SymName);
         Asm->OutStreamer->emitLabel(ExceptionSym);
       }
     }
   }
+}
 
 void WasmException::markFunctionEnd() {
   // Get rid of any dead landing pads.
   if (!Asm->MF->getLandingPads().empty()) {
     auto *NonConstMF = const_cast<MachineFunction *>(Asm->MF);
     // Wasm does not set BeginLabel and EndLabel information for landing pads,
     // so we should set the second argument false.
     NonConstMF->tidyLandingPads(nullptr, /* TidyIfNoBeginLabels */ false);

llvm/lib/Object/WasmObjectFile.cpp

case wasm::WASM_EXTERNAL_TABLE: {
       if (ElemType != wasm::WASM_TYPE_FUNCREF &&
           ElemType != wasm::WASM_TYPE_EXTERNREF)
         return make_error<GenericBinaryError>("invalid table element type",
                                               object_error::parse_failed);
       break;
     }
     case wasm::WASM_EXTERNAL_TAG:
       NumImportedTags++;
+      if (readUint8(Ctx) != 0) // Reserved 'attribute' field
+        return make_error<GenericBinaryError>("invalid attribute",
+                                              object_error::parse_failed);
       Im.SigIndex = readVaruint32(Ctx);
       if (Im.SigIndex >= NumTypes)
         return make_error<GenericBinaryError>("invalid tag type",
                                               object_error::parse_failed);
       break;
     default:
       return make_error<GenericBinaryError>("unexpected import kind",
                                             object_error::parse_failed);

 }
 
 Error WasmObjectFile::parseTagSection(ReadContext &Ctx) {
   TagSection = Sections.size();
   uint32_t Count = readVaruint32(Ctx);
   Tags.reserve(Count);
   uint32_t NumTypes = Signatures.size();
   while (Count--) {
-    char Attr = readUint8(Ctx); // Reserved 'attribute' field
-    if (Attr != 0)
+    if (readUint8(Ctx) != 0) // Reserved 'attribute' field
       return make_error<GenericBinaryError>("invalid attribute",
                                             object_error::parse_failed);
     uint32_t Type = readVaruint32(Ctx);
     if (Type >= NumTypes)
       return make_error<GenericBinaryError>("invalid tag type",
                                             object_error::parse_failed);
     wasm::WasmTag Tag;
     Tag.Index = NumImportedTags + Tags.size();

llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp

if (Name == "__stack_pointer" || Name == "__tls_base" ||
     WasmSym->setType(wasm::WASM_SYMBOL_TYPE_GLOBAL);
     WasmSym->setGlobalType(wasm::WasmGlobalType{
         uint8_t(Subtarget.hasAddr64() ? wasm::WASM_TYPE_I64
                                       : wasm::WASM_TYPE_I32),
         Mutable});
     return WasmSym;
   }
 
+  if (Name.startswith("GCC_except_table")) {
+    WasmSym->setType(wasm::WASM_SYMBOL_TYPE_DATA);
+    return WasmSym;
+  }
+
   SmallVector<wasm::ValType, 4> Returns;
   SmallVector<wasm::ValType, 4> Params;
   if (Name == "__cpp_exception" || Name == "__c_longjmp") {
     WasmSym->setType(wasm::WASM_SYMBOL_TYPE_TAG);
-    // We may have multiple C++ compilation units to be linked together, each of
-    // which defines the exception symbol. To resolve them, we declare them as
-    // weak.
+    // In static linking we define tag symbols in WasmException::endModule().
+    // But we may have multiple objects to be linked together, each of which
+    // defines the tag symbols. To resolve them, we declare them as weak. In
+    // dynamic linking we make tag symbols undefined in the backend, define it
+    // in JS, and feed them to each importing module.
+    if (!isPositionIndependent())
       WasmSym->setWeak(true);
     WasmSym->setExternal(true);
 
     // Currently both C++ exceptions and C longjmps have a single pointer type
     // param. For C++ exceptions it is a pointer to an exception object, and for
     // C longjmps it is pointer to a struct that contains a setjmp buffer and a
     // longjmp return value. We may consider using multiple value parameters for
     // longjmps later when multivalue support is ready.
     wasm::ValType AddrType =

llvm/lib/Target/WebAssembly/WebAssemblyISelLowering.cpp

SDValue WebAssemblyTargetLowering::LowerIntrinsic(SDValue Op,
   }
   SDLoc DL(Op);
 
   switch (IntNo) {
   default:
     return SDValue(); // Don't custom lower most intrinsics.
 
   case Intrinsic::wasm_lsda: {
-    EVT VT = Op.getValueType();
-    const TargetLowering &TLI = DAG.getTargetLoweringInfo();
-    MVT PtrVT = TLI.getPointerTy(DAG.getDataLayout());
-    auto &Context = MF.getMMI().getContext();
-    MCSymbol *S = Context.getOrCreateSymbol(Twine("GCC_except_table") +
-                                            Twine(MF.getFunctionNumber()));
-    return DAG.getNode(WebAssemblyISD::Wrapper, DL, VT,
-                       DAG.getMCSymbol(S, PtrVT));
+    auto PtrVT = getPointerTy(MF.getDataLayout());
+    const char *SymName = MF.createExternalSymbolName(
+        "GCC_except_table" + std::to_string(MF.getFunctionNumber()));
+    if (isPositionIndependent()) {
+      SDValue Node = DAG.getTargetExternalSymbol(
+          SymName, PtrVT, WebAssemblyII::MO_MEMORY_BASE_REL);
+      const char *BaseName = MF.createExternalSymbolName("__memory_base");
+      SDValue BaseAddr =
+          DAG.getNode(WebAssemblyISD::Wrapper, DL, PtrVT,
+                      DAG.getTargetExternalSymbol(BaseName, PtrVT));
+      SDValue SymAddr =
+          DAG.getNode(WebAssemblyISD::WrapperREL, DL, PtrVT, Node);
+      return DAG.getNode(ISD::ADD, DL, PtrVT, BaseAddr, SymAddr);
+    }
+    SDValue Node = DAG.getTargetExternalSymbol(SymName, PtrVT);
+    return DAG.getNode(WebAssemblyISD::Wrapper, DL, PtrVT, Node);
   }
 
   case Intrinsic::wasm_shuffle: {
     // Drop in-chain and replace undefs, but otherwise pass through unchanged
     SDValue Ops[18];
     size_t OpIdx = 0;
     Ops[OpIdx++] = Op.getOperand(1);
     Ops[OpIdx++] = Op.getOperand(2);

llvm/lib/Target/WebAssembly/WebAssemblyInstrInfo.td

 def : Pat<(i64 (WebAssemblyWrapper texternalsym:$addr)),
           (GLOBAL_GET_I64 texternalsym:$addr)>, Requires<[IsPIC, HasAddr64]>;
 
 def : Pat<(i32 (WebAssemblyWrapper texternalsym:$addr)),
           (CONST_I32 texternalsym:$addr)>, Requires<[IsNotPIC, HasAddr32]>;
 def : Pat<(i64 (WebAssemblyWrapper texternalsym:$addr)),
           (CONST_I64 texternalsym:$addr)>, Requires<[IsNotPIC, HasAddr64]>;
 
-def : Pat<(i32 (WebAssemblyWrapper mcsym:$sym)), (CONST_I32 mcsym:$sym)>;
-def : Pat<(i64 (WebAssemblyWrapper mcsym:$sym)), (CONST_I64 mcsym:$sym)>;
+def : Pat<(i32 (WebAssemblyWrapperREL texternalsym:$addr)),
+          (CONST_I32 texternalsym:$addr)>, Requires<[IsPIC, HasAddr32]>;
+def : Pat<(i64 (WebAssemblyWrapperREL texternalsym:$addr)),
+          (CONST_I64 texternalsym:$addr)>, Requires<[IsPIC, HasAddr64]>;
 
 //===----------------------------------------------------------------------===//
 // Additional sets of instructions.
 //===----------------------------------------------------------------------===//
 
 include "WebAssemblyInstrMemory.td"
 include "WebAssemblyInstrCall.td"
 include "WebAssemblyInstrControl.td"
 include "WebAssemblyInstrInteger.td"
 include "WebAssemblyInstrConv.td"
 include "WebAssemblyInstrFloat.td"
 include "WebAssemblyInstrAtomics.td"
 include "WebAssemblyInstrSIMD.td"
 include "WebAssemblyInstrRef.td"
 include "WebAssemblyInstrBulkMemory.td"
 include "WebAssemblyInstrTable.td"

llvm/lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp

case MachineOperand::MO_FPImmediate: {
       else
         llvm_unreachable("unknown floating point immediate type");
       break;
     }
     case MachineOperand::MO_GlobalAddress:
       MCOp = lowerSymbolOperand(MO, GetGlobalAddressSymbol(MO));
       break;
     case MachineOperand::MO_ExternalSymbol:
-      // The target flag indicates whether this is a symbol for a
-      // variable or a function.
-      assert(MO.getTargetFlags() == 0 &&
-             "WebAssembly uses only symbol flags on ExternalSymbols");
       MCOp = lowerSymbolOperand(MO, GetExternalSymbolSymbol(MO));
       break;
     case MachineOperand::MO_MCSymbol:
-      // This is currently used only for LSDA symbols (GCC_except_table),
-      // because global addresses or other external symbols are handled above.
       assert(MO.getTargetFlags() == 0 &&
              "WebAssembly does not use target flags on MCSymbol");
       MCOp = lowerSymbolOperand(MO, MO.getMCSymbol());
       break;
     }
 
     OutMI.addOperand(MCOp);
   }
 
   if (!WasmKeepRegisters)
     removeRegisterOperands(MI, OutMI);
   else if (Desc.variadicOpsAreDefs())

llvm/test/CodeGen/WebAssembly/eh-lsda.ll

-; RUN: llc < %s -disable-wasm-fallthrough-return-opt -wasm-keep-registers -wasm-enable-eh -exception-model=wasm -mattr=+exception-handling | FileCheck -allow-deprecated-dag-overlap %s
+; RUN: llc < %s -wasm-disable-explicit-locals -wasm-keep-registers -wasm-enable-eh -exception-model=wasm -mattr=+exception-handling | FileCheck %s -check-prefixes=CHECK,NOPIC
+; RUN: llc < %s -wasm-disable-explicit-locals -wasm-keep-registers -wasm-enable-eh -exception-model=wasm -mattr=+exception-handling -relocation-model=pic | FileCheck %s -check-prefixes=CHECK,PIC
 
-target triple = "wasm32-unknown-unknown"
+target triple = "wasm32-unknown-emscripten"
 
 @_ZTIi = external constant i8*
 @_ZTIf = external constant i8*
 @_ZTId = external constant i8*
 
 ; Single catch (...) does not need an exception table.
 ;
 ; try {

 ; } catch (int) {
 ; } catch (float) {
 ; }
 ;
 ; There are three landing pads. The second landing pad should share action table
 ; entries with the first landing pad because they end with the same sequence
 ; (double -> ...). But the third landing table cannot share action table entries
 ; with others, so it should create its own entries.
+
 ; CHECK-LABEL: test1:
+; In static linking, we load GCC_except_table as a constant directly.
+; NOPIC:      i32.const  $push[[CONTEXT:.*]]=, __wasm_lpad_context
+; NOPIC-NEXT: i32.const  $push[[EXCEPT_TABLE:.*]]=, GCC_except_table1
+; NOPIC-NEXT: i32.store  4($pop[[CONTEXT]]), $pop[[EXCEPT_TABLE]]
+
+; In case of PIC, we make GCC_except_table symbols a relative on based on
+; __memory_base.
+; PIC:        global.get  $push[[CONTEXT:.*]]=, __wasm_lpad_context@GOT
+; PIC-NEXT:   local.tee  $push{{.*}}=, $[[CONTEXT_LOCAL:.*]]=, $pop[[CONTEXT]]
+; PIC:        global.get  $push[[MEMORY_BASE:.*]]=, __memory_base
+; PIC-NEXT:   i32.const  $push[[EXCEPT_TABLE_REL:.*]]=, GCC_except_table1@MBREL
+; PIC-NEXT:   i32.add   $push[[EXCEPT_TABLE:.*]]=, $pop[[MEMORY_BASE]], $pop[[EXCEPT_TABLE_REL]]
+; PIC-NEXT:   i32.store  4($[[CONTEXT_LOCAL]]), $pop[[EXCEPT_TABLE]]
+
 ; CHECK: .section  .rodata.gcc_except_table,"",@
 ; CHECK-NEXT:   .p2align  2
 ; CHECK-NEXT: GCC_except_table[[START:[0-9]+]]:
 ; CHECK-NEXT: .Lexception0:
 ; CHECK-NEXT:   .int8  255                     # @LPStart Encoding = omit
 ; CHECK-NEXT:   .int8  0                       # @TType Encoding = absptr
 ; CHECK-NEXT:   .uleb128 .Lttbase0-.Lttbaseref0
 ; CHECK-NEXT: .Lttbaseref0: