[WebAssembly] Add support for thread-local data

[ncw]

Summary

MOSTLY FINISHED - SOME BITS STILL TO TIDY UP

• Enables users to use static __thread int threadLocalValue variable declarations
• Enables Musl to use the existing __builtin_thread_pointer() intrinsic to read from the "thread-local register" (on x86 that intrinsic would be reading the %fs register, on ARM it might be the CP15 register?)

OK, OK, I know Wasm doesn't have threads quite yet - but it will do soon, surely sometime in 2018. At that point having the infrastructure in place would be quite nice.

I'm implementing the Itanium TLS ABI, as on ARM (x86 has a weird legacy model).

TODO:

• Add some tests
• Add an intrinsic __builtin_wasm_set_thread_pointer() to allow Musl to initialise its TLS block
• Open the corresponding review for LLD (halfway done, I put it to one side about a month ago)

include/llvm/BinaryFormat/Wasm.h

 // Kind codes used in the custom "linking" section
 enum : unsigned {
   WASM_SEGMENT_INFO   = 0x5,
   WASM_INIT_FUNCS     = 0x6,
   WASM_COMDAT_INFO    = 0x7,
   WASM_SYMBOL_TABLE   = 0x8,
 };
 
+// Flags used in the custom "linking" section in the WASM_SEGMENT_INFO
+enum : unsigned {
+  WASM_SEGMENT_TLS = 0x2,
+};
+
 // Kind codes used in the custom "linking" section in the WASM_COMDAT_INFO
 enum : unsigned {
   WASM_COMDAT_DATA        = 0x0,
   WASM_COMDAT_FUNCTION    = 0x1,
 };
 
 // Kind codes used in the custom "linking" section in the WASM_SYMBOL_TABLE
 enum WasmSymbolType : unsigned {

include/llvm/BinaryFormat/WasmRelocs.def

 
 #ifndef WASM_RELOC
 #error "WASM_RELOC must be defined"
 #endif
 
 WASM_RELOC(R_WEBASSEMBLY_FUNCTION_INDEX_LEB,   0)
 WASM_RELOC(R_WEBASSEMBLY_TABLE_INDEX_SLEB,     1)
 WASM_RELOC(R_WEBASSEMBLY_TABLE_INDEX_I32,      2)
 WASM_RELOC(R_WEBASSEMBLY_MEMORY_ADDR_LEB,      3)
 WASM_RELOC(R_WEBASSEMBLY_MEMORY_ADDR_SLEB,     4)
 WASM_RELOC(R_WEBASSEMBLY_MEMORY_ADDR_I32,      5)
 WASM_RELOC(R_WEBASSEMBLY_TYPE_INDEX_LEB,       6)
 WASM_RELOC(R_WEBASSEMBLY_GLOBAL_INDEX_LEB,     7)
+WASM_RELOC(R_WEBASSEMBLY_MEMORY_TLSOFF_LEB,    8)

include/llvm/MC/MCSectionWasm.h

public:
 
   void PrintSwitchToSection(const MCAsmInfo &MAI, const Triple &T,
                             raw_ostream &OS,
                             const MCExpr *Subsection) const override;
   bool UseCodeAlign() const override;
   bool isVirtualSection() const override;
 
   bool isWasmData() const {
-    return Kind.isGlobalWriteableData() || Kind.isReadOnly();
+    return Kind.isWriteable() || Kind.isReadOnly();
+  }
+  bool isWasmTlsData() const {
+    return Kind.isThreadLocal();
   }
 
   bool isUnique() const { return UniqueID != ~0U; }
   unsigned getUniqueID() const { return UniqueID; }
 
   uint64_t getSectionOffset() const { return SectionOffset; }
   void setSectionOffset(uint64_t Offset) { SectionOffset = Offset; }
 

lib/MC/WasmObjectWriter.cpp

WasmRelocationEntry(uint64_t Offset, const MCSymbolWasm *Symbol,
       : Offset(Offset), Symbol(Symbol), Addend(Addend), Type(Type),
         FixupSection(FixupSection) {}
 
   bool hasAddend() const {
     switch (Type) {
     case wasm::R_WEBASSEMBLY_MEMORY_ADDR_LEB:
     case wasm::R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
     case wasm::R_WEBASSEMBLY_MEMORY_ADDR_I32:
+    case wasm::R_WEBASSEMBLY_MEMORY_TLSOFF_LEB:
       return true;
     default:
       return false;
     }
   }
 
   void print(raw_ostream &Out) const {
     Out << "Off=" << Offset << ", Sym=" << *Symbol << ", Addend=" << Addend
case wasm::R_WEBASSEMBLY_MEMORY_ADDR_SLEB: {
     // For undefined symbols, use zero
     if (!Sym->isDefined())
       return 0;
     const wasm::WasmDataReference &Ref = DataLocations[Sym];
     const WasmDataSegment &Segment = DataSegments[Ref.Segment];
     // Ignore overflow. LLVM allows address arithmetic to silently wrap.
     return Segment.Offset + Ref.Offset + RelEntry.Addend;
   }
+  case wasm::R_WEBASSEMBLY_MEMORY_TLSOFF_LEB:
+    return 42; // XXX put a sensible dummy value in - not that it matters!
   default:
     llvm_unreachable("invalid relocation type");
   }
 }
 
 static void addData(SmallVectorImpl<char> &DataBytes,
                     MCSectionWasm &DataSection) {
   DEBUG(errs() << "addData: " << DataSection.getSectionName() << "\n");
for (const WasmRelocationEntry &RelEntry : Relocations) {
     DEBUG(dbgs() << "applyRelocation: " << RelEntry << "\n");
     uint32_t Value = getProvisionalValue(RelEntry);
 
     switch (RelEntry.Type) {
     case wasm::R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
     case wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB:
     case wasm::R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
     case wasm::R_WEBASSEMBLY_MEMORY_ADDR_LEB:
+    case wasm::R_WEBASSEMBLY_MEMORY_TLSOFF_LEB:
       WritePatchableLEB(Stream, Value, Offset);
       break;
     case wasm::R_WEBASSEMBLY_TABLE_INDEX_I32:
     case wasm::R_WEBASSEMBLY_MEMORY_ADDR_I32:
       WriteI32(Stream, Value, Offset);
       break;
     case wasm::R_WEBASSEMBLY_TABLE_INDEX_SLEB:
     case wasm::R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
for (MCSection &Sec : Asm) {
     DataSize = alignTo(DataSize, Section.getAlignment());
     DataSegments.emplace_back();
     WasmDataSegment &Segment = DataSegments.back();
     Segment.Name = Section.getSectionName();
     Segment.Offset = DataSize;
     Segment.Section = &Section;
     addData(Segment.Data, Section);
     Segment.Alignment = Section.getAlignment();
-    Segment.Flags = 0;
+    Segment.Flags = (Section.isWasmTlsData() ? wasm::WASM_SEGMENT_TLS : 0x0);
     DataSize += Segment.Data.size();
     Section.setSegmentIndex(SegmentIndex);
 
     if (const MCSymbolWasm *C = Section.getGroup()) {
       Comdats[C->getName()].emplace_back(
           WasmComdatEntry{wasm::WASM_COMDAT_DATA, SegmentIndex});
     }
   }
if (WS.isFunction()) {
       // corresponding Wasm data segment.
       wasm::WasmDataReference Ref = wasm::WasmDataReference{
           DataSection.getSegmentIndex(),
           static_cast<uint32_t>(Layout.getSymbolOffset(WS)),
           static_cast<uint32_t>(Size)};
       DataLocations[&WS] = Ref;
       DEBUG(dbgs() << "  -> segment index: " << Ref.Segment);
     } else {
-      // A "true" Wasm global (currently just __stack_pointer)
+      // A "true" Wasm global (currently just __stack_pointer, __thread_pointer)
       if (WS.isDefined())
         report_fatal_error("don't yet support defined globals");
 
       // An import; the index was assigned above
       DEBUG(dbgs() << "  -> global index: " << WasmIndices.find(&WS)->second
                    << "\n");
     }
   }

lib/Object/WasmObjectFile.cpp

while (RelocCount--) {
     case wasm::R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
       if (!isValidGlobalSymbol(Reloc.Index))
         return make_error<GenericBinaryError>("Bad relocation global index",
                                               object_error::parse_failed);
       break;
     case wasm::R_WEBASSEMBLY_MEMORY_ADDR_LEB:
     case wasm::R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
     case wasm::R_WEBASSEMBLY_MEMORY_ADDR_I32:
+    case wasm::R_WEBASSEMBLY_MEMORY_TLSOFF_LEB:
       if (!isValidDataSymbol(Reloc.Index))
         return make_error<GenericBinaryError>("Bad relocation data index",
                                               object_error::parse_failed);
       Reloc.Addend = readVarint32(Ptr);
       break;
     default:
       return make_error<GenericBinaryError>("Bad relocation type: " +
                                                 Twine(Reloc.Type),

lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCTargetDesc.h

 // WebAssembly-specific MachineOperand target flags.
 enum WebAssemblyMOTargetFlagVal {
   MO_NO_FLAG = 0,
 
   // Flags to indicate the type of the symbol being referenced
   MO_SYMBOL_FUNCTION = 0x1,
   MO_SYMBOL_GLOBAL   = 0x2,
   MO_SYMBOL_MASK     = 0x3,
+
+  // Flags to indicate the type of the global reference
+  MO_GLOBAL_TPOFF    = 0x10,
+  MO_GLOBAL_MASK     = 0x10,
 };
 } // end namespace WebAssemblyII
 
 } // end namespace llvm
 
 // Defines symbolic names for WebAssembly registers. This defines a mapping from
 // register name to register number.
 //

lib/Target/WebAssembly/MCTargetDesc/WebAssemblyWasmObjectWriter.cpp

static bool IsFunctionType(const MCValue &Target) {
   return RefA && RefA->getKind() == MCSymbolRefExpr::VK_WebAssembly_TYPEINDEX;
 }
 
 static bool IsGlobalType(const MCValue &Target) {
   const MCSymbolRefExpr *RefA = Target.getSymA();
   return RefA && RefA->getKind() == MCSymbolRefExpr::VK_WebAssembly_GLOBAL;
 }
 
+static bool IsTlsOffset(const MCValue &Target) {
+  const MCSymbolRefExpr *RefA = Target.getSymA();
+  return RefA && RefA->getKind() == MCSymbolRefExpr::VK_TPOFF;
+}
+
 unsigned
 WebAssemblyWasmObjectWriter::getRelocType(const MCValue &Target,
                                           const MCFixup &Fixup) const {
   // WebAssembly functions are not allocated in the data address space. To
   // resolve a pointer to a function, we must use a special relocation type.
   bool IsFunction = IsFunctionExpr(Fixup.getValue());
 
   switch (unsigned(Fixup.getKind())) {
   case WebAssembly::fixup_code_sleb128_i32:
     if (IsFunction)
       return wasm::R_WEBASSEMBLY_TABLE_INDEX_SLEB;
+    if (IsTlsOffset(Target))
+      return wasm::R_WEBASSEMBLY_MEMORY_TLSOFF_LEB;
     return wasm::R_WEBASSEMBLY_MEMORY_ADDR_SLEB;
   case WebAssembly::fixup_code_sleb128_i64:
     llvm_unreachable("fixup_sleb128_i64 not implemented yet");
   case WebAssembly::fixup_code_uleb128_i32:
     if (IsGlobalType(Target))
       return wasm::R_WEBASSEMBLY_GLOBAL_INDEX_LEB;
     if (IsFunctionType(Target))
       return wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB;

lib/Target/WebAssembly/WebAssemblyISelLowering.h

SDValue LowerFormalArguments(SDValue Chain, CallingConv::ID CallConv,
                                const SDLoc &DL, SelectionDAG &DAG,
                                SmallVectorImpl<SDValue> &InVals) const override;
 
   // Custom lowering hooks.
   SDValue LowerOperation(SDValue Op, SelectionDAG &DAG) const override;
   SDValue LowerFrameIndex(SDValue Op, SelectionDAG &DAG) const;
   SDValue LowerFRAMEADDR(SDValue Op, SelectionDAG &DAG) const;
   SDValue LowerGlobalAddress(SDValue Op, SelectionDAG &DAG) const;
+  SDValue LowerGlobalTlsAddress(SDValue Op, SelectionDAG &DAG) const;
   SDValue LowerExternalSymbol(SDValue Op, SelectionDAG &DAG) const;
   SDValue LowerBR_JT(SDValue Op, SelectionDAG &DAG) const;
   SDValue LowerJumpTable(SDValue Op, SelectionDAG &DAG) const;
   SDValue LowerVASTART(SDValue Op, SelectionDAG &DAG) const;
   SDValue LowerCopyToReg(SDValue Op, SelectionDAG &DAG) const;
+  SDValue LowerINTRINSIC_WO_CHAIN(SDValue Op, SelectionDAG &DAG) const;
+  SDValue getThreadPointerNode(SDValue Op, SelectionDAG &DAG) const;
 };
 
 namespace WebAssembly {
 FastISel *createFastISel(FunctionLoweringInfo &funcInfo,
                          const TargetLibraryInfo *libInfo);
 }  // end namespace WebAssembly
 
 }  // end namespace llvm
 
 #endif

lib/Target/WebAssembly/WebAssemblyISelLowering.cpp

if (Subtarget->hasSIMD128()) {
     addRegisterClass(MVT::v8i16, &WebAssembly::V128RegClass);
     addRegisterClass(MVT::v4i32, &WebAssembly::V128RegClass);
     addRegisterClass(MVT::v4f32, &WebAssembly::V128RegClass);
   }
   // Compute derived properties from the register classes.
   computeRegisterProperties(Subtarget->getRegisterInfo());
 
   setOperationAction(ISD::GlobalAddress, MVTPtr, Custom);
+  setOperationAction(ISD::GlobalTLSAddress, MVTPtr, Custom);
   setOperationAction(ISD::ExternalSymbol, MVTPtr, Custom);
   setOperationAction(ISD::JumpTable, MVTPtr, Custom);
   setOperationAction(ISD::BlockAddress, MVTPtr, Custom);
   setOperationAction(ISD::BRIND, MVT::Other, Custom);
 
   // Take the default expansion for va_arg, va_copy, and va_end. There is no
   // default action for va_start, so we do that custom.
   setOperationAction(ISD::VASTART, MVT::Other, Custom);
WebAssemblyTargetLowering::WebAssemblyTargetLowering(
 
   // Dynamic stack allocation: use the default expansion.
   setOperationAction(ISD::STACKSAVE, MVT::Other, Expand);
   setOperationAction(ISD::STACKRESTORE, MVT::Other, Expand);
   setOperationAction(ISD::DYNAMIC_STACKALLOC, MVTPtr, Expand);
 
   setOperationAction(ISD::FrameIndex, MVT::i32, Custom);
   setOperationAction(ISD::CopyToReg, MVT::Other, Custom);
+  setOperationAction(ISD::INTRINSIC_WO_CHAIN, MVT::Other, Custom);
 
   // Expand these forms; we pattern-match the forms that we can handle in isel.
   for (auto T : {MVT::i32, MVT::i64, MVT::f32, MVT::f64})
     for (auto Op : {ISD::BR_CC, ISD::SELECT_CC})
       setOperationAction(Op, T, Expand);
 
   // We have custom switch handling.
   setOperationAction(ISD::BR_JT, MVT::Other, Custom);
SDValue WebAssemblyTargetLowering::LowerOperation(SDValue Op,
   switch (Op.getOpcode()) {
     default:
       llvm_unreachable("unimplemented operation lowering");
       return SDValue();
     case ISD::FrameIndex:
       return LowerFrameIndex(Op, DAG);
     case ISD::GlobalAddress:
       return LowerGlobalAddress(Op, DAG);
+    case ISD::GlobalTLSAddress:
+      return LowerGlobalTlsAddress(Op, DAG);
     case ISD::ExternalSymbol:
       return LowerExternalSymbol(Op, DAG);
     case ISD::JumpTable:
       return LowerJumpTable(Op, DAG);
     case ISD::BR_JT:
       return LowerBR_JT(Op, DAG);
     case ISD::VASTART:
       return LowerVASTART(Op, DAG);
     case ISD::BlockAddress:
     case ISD::BRIND:
       fail(DL, DAG, "WebAssembly hasn't implemented computed gotos");
       return SDValue();
     case ISD::RETURNADDR: // Probably nothing meaningful can be returned here.
       fail(DL, DAG, "WebAssembly hasn't implemented __builtin_return_address");
       return SDValue();
     case ISD::FRAMEADDR:
       return LowerFRAMEADDR(Op, DAG);
     case ISD::CopyToReg:
       return LowerCopyToReg(Op, DAG);
+    case ISD::INTRINSIC_WO_CHAIN:
+      return LowerINTRINSIC_WO_CHAIN(Op, DAG);
   }
 }
 
 SDValue WebAssemblyTargetLowering::LowerCopyToReg(SDValue Op,
                                                   SelectionDAG &DAG) const {
   SDValue Src = Op.getOperand(2);
   if (isa<FrameIndexSDNode>(Src.getNode())) {
     // CopyToReg nodes don't support FrameIndex operands. Other targets select
assert(GA->getTargetFlags() == 0 &&
          "Unexpected target flags on generic GlobalAddressSDNode");
   if (GA->getAddressSpace() != 0)
     fail(DL, DAG, "WebAssembly only expects the 0 address space");
   return DAG.getNode(
       WebAssemblyISD::Wrapper, DL, VT,
       DAG.getTargetGlobalAddress(GA->getGlobal(), DL, VT, GA->getOffset()));
 }
 
+SDValue WebAssemblyTargetLowering::LowerGlobalTlsAddress(SDValue Op,
+                                                      SelectionDAG &DAG) const {
+  SDLoc DL(Op);
+  GlobalAddressSDNode *GA = cast<GlobalAddressSDNode>(Op);
+  EVT VT = Op.getValueType();
+  assert(VT == MVT::i32);
+
+  SDValue ThreadPointer = getThreadPointerNode(Op, DAG);
+  SDValue TlsOffset = DAG.getNode(
+      WebAssemblyISD::Wrapper, DL, VT,
+      DAG.getTargetGlobalAddress(GA->getGlobal(), DL, VT, GA->getOffset(),
+                                 WebAssemblyII::MO_GLOBAL_TPOFF));
+
+  return DAG.getNode(ISD::ADD, DL, MVT::i32, ThreadPointer, TlsOffset);
+}
+
 SDValue WebAssemblyTargetLowering::LowerExternalSymbol(
     SDValue Op, SelectionDAG &DAG) const {
   SDLoc DL(Op);
   const auto *ES = cast<ExternalSymbolSDNode>(Op);
   EVT VT = Op.getValueType();
   assert(ES->getTargetFlags() == 0 &&
          "Unexpected target flags on generic ExternalSymbolSDNode");
   // Set the TargetFlags to 0x1 which indicates that this is a "function"
SDValue WebAssemblyTargetLowering::LowerVASTART(SDValue Op,
   const Value *SV = cast<SrcValueSDNode>(Op.getOperand(2))->getValue();
 
   SDValue ArgN = DAG.getCopyFromReg(DAG.getEntryNode(), DL,
                                     MFI->getVarargBufferVreg(), PtrVT);
   return DAG.getStore(Op.getOperand(0), DL, ArgN, Op.getOperand(1),
                       MachinePointerInfo(SV), 0);
 }
 
+SDValue WebAssemblyTargetLowering::LowerINTRINSIC_WO_CHAIN(SDValue Op,
+                                                      SelectionDAG &DAG) const {
+  unsigned IntNo = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
+  switch (IntNo) {
+  default: return SDValue();    // Don't custom lower most intrinsics.
+  case Intrinsic::thread_pointer: return getThreadPointerNode(Op, DAG);
+  }
+}
+
+SDValue WebAssemblyTargetLowering::getThreadPointerNode(SDValue Op,
+                                                        SelectionDAG &DAG) const {
+  SDValue TPNode = DAG.getTargetExternalSymbol("__thread_pointer", MVT::i32,
+                                               WebAssemblyII::MO_SYMBOL_GLOBAL);
+  return SDValue(DAG.getMachineNode(WebAssembly::GET_GLOBAL_I32, SDLoc(Op),
+                                    MVT::i32, TPNode),
+                 0);
+}
+
 //===----------------------------------------------------------------------===//
 //                          WebAssembly Optimization Hooks
 //===----------------------------------------------------------------------===//

lib/Target/WebAssembly/WebAssemblyInstrInfo.td

 } // isMoveImm = 1, isAsCheapAsAMove = 1, isReMaterializable = 1
 
 } // Defs = [ARGUMENTS]
 
 def : Pat<(i32 (WebAssemblywrapper tglobaladdr:$addr)),
           (CONST_I32 tglobaladdr:$addr)>;
 def : Pat<(i32 (WebAssemblywrapper texternalsym:$addr)),
           (CONST_I32 texternalsym:$addr)>;
+def : Pat<(i32 (WebAssemblywrapper tglobaltlsaddr:$addr)),
+          (CONST_I32 tglobaltlsaddr:$addr)>;
 
 //===----------------------------------------------------------------------===//
 // 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 "WebAssemblyInstrExceptRef.td"

lib/Target/WebAssembly/WebAssemblyMCInstLower.h

 
 /// This class is used to lower an MachineInstr into an MCInst.
 class LLVM_LIBRARY_VISIBILITY WebAssemblyMCInstLower {
   MCContext &Ctx;
   WebAssemblyAsmPrinter &Printer;
 
   MCSymbol *GetGlobalAddressSymbol(const MachineOperand &MO) const;
   MCSymbol *GetExternalSymbolSymbol(const MachineOperand &MO) const;
-  MCOperand LowerSymbolOperand(MCSymbol *Sym, int64_t Offset,
-                               bool IsFunc, bool IsGlob) const;
+  MCOperand LowerSymbolOperand(MCSymbol *Sym, int64_t Offset, bool IsFunc,
+                               bool IsGlob, bool IsTls) const;
 
 public:
   WebAssemblyMCInstLower(MCContext &ctx, WebAssemblyAsmPrinter &printer)
       : Ctx(ctx), Printer(printer) {}
   void Lower(const MachineInstr *MI, MCInst &OutMI) const;
 };
 } // end namespace llvm
 
 #endif

lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp

MCSymbol *WebAssemblyMCInstLower::GetExternalSymbolSymbol(
   const char *Name = MO.getSymbolName();
   MCSymbol *Sym = Printer.GetExternalSymbolSymbol(Name);
   if (isa<MCSymbolELF>(Sym))
     return Sym;
 
   MCSymbolWasm *WasmSym = cast<MCSymbolWasm>(Sym);
   const WebAssemblySubtarget &Subtarget = Printer.getSubtarget();
 
-  // __stack_pointer is a global variable; all other external symbols used by
-  // CodeGen are functions.  It's OK to hardcode knowledge of specific symbols
-  // here; this method is precisely there for fetching the signatures of known
-  // Clang-provided symbols.
-  if (strcmp(Name, "__stack_pointer") == 0) {
+  // __stack_pointer and __thread_pointer are global variables; all other
+  // external symbols used by CodeGen are functions.  It's OK to hardcode
+  // knowledge of specific symbols here; this method is precisely there for
+  // fetching the signatures of known Clang-provided symbols.
+  if (strcmp(Name, "__stack_pointer") == 0 ||
+      strcmp(Name, "__thread_pointer") == 0) {
     WasmSym->setType(wasm::WASM_SYMBOL_TYPE_GLOBAL);
     WasmSym->setGlobalType(wasm::WasmGlobalType{
         uint8_t(Subtarget.hasAddr64() ? wasm::WASM_TYPE_I64
                                       : wasm::WASM_TYPE_I32),
         true});
     return WasmSym;
   }
 
   SmallVector<wasm::ValType, 4> Returns;
   SmallVector<wasm::ValType, 4> Params;
   GetSignature(Subtarget, Name, Returns, Params);
 
   WasmSym->setReturns(std::move(Returns));
   WasmSym->setParams(std::move(Params));
   WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
 
   return WasmSym;
 }
 
 MCOperand WebAssemblyMCInstLower::LowerSymbolOperand(MCSymbol *Sym,
                                                      int64_t Offset,
                                                      bool IsFunc,
-                                                     bool IsGlob) const {
+                                                     bool IsGlob,
+                                                     bool IsTls) const {
   MCSymbolRefExpr::VariantKind VK =
       IsFunc ? MCSymbolRefExpr::VK_WebAssembly_FUNCTION :
-      IsGlob ? MCSymbolRefExpr::VK_WebAssembly_GLOBAL
+      IsGlob ? MCSymbolRefExpr::VK_WebAssembly_GLOBAL :
+      IsTls  ? MCSymbolRefExpr::VK_TPOFF
              : MCSymbolRefExpr::VK_None;
 
   const MCExpr *Expr = MCSymbolRefExpr::create(Sym, VK, Ctx);
 
   if (Offset != 0) {
     if (IsFunc)
       report_fatal_error("Function addresses with offsets not supported");
     if (IsGlob)
case MachineOperand::MO_FPImmediate: {
         MCOp = MCOperand::createFPImm(Imm->getValueAPF().convertToFloat());
       else if (Imm->getType()->isDoubleTy())
         MCOp = MCOperand::createFPImm(Imm->getValueAPF().convertToDouble());
       else
         llvm_unreachable("unknown floating point immediate type");
       break;
     }
     case MachineOperand::MO_GlobalAddress:
-      assert(MO.getTargetFlags() == WebAssemblyII::MO_NO_FLAG &&
-             "WebAssembly does not use target flags on GlobalAddresses");
+      assert((MO.getTargetFlags() & ~WebAssemblyII::MO_GLOBAL_MASK) == 0 &&
+             "WebAssembly uses only global flags on GlobalAddresses");
       MCOp = LowerSymbolOperand(GetGlobalAddressSymbol(MO), MO.getOffset(),
                                 MO.getGlobal()->getValueType()->isFunctionTy(),
-                                false);
+                                false,
+                                (MO.getTargetFlags() & WebAssemblyII::MO_GLOBAL_TPOFF) != 0);
       break;
     case MachineOperand::MO_ExternalSymbol:
       // The target flag indicates whether this is a symbol for a
       // variable or a function.
       assert((MO.getTargetFlags() & ~WebAssemblyII::MO_SYMBOL_MASK) == 0 &&
              "WebAssembly uses only symbol flags on ExternalSymbols");
       MCOp = LowerSymbolOperand(GetExternalSymbolSymbol(MO), /*Offset=*/0,
           (MO.getTargetFlags() & WebAssemblyII::MO_SYMBOL_FUNCTION) != 0,
-          (MO.getTargetFlags() & WebAssemblyII::MO_SYMBOL_GLOBAL) != 0);
+          (MO.getTargetFlags() & WebAssemblyII::MO_SYMBOL_GLOBAL) != 0,
+          false);
       break;
     }
 
     OutMI.addOperand(MCOp);
   }
 }

tools/llvm-readobj/WasmDumper.cpp

void WasmDumper::printRelocation(const SectionRef &Section,
   Reloc.getTypeName(RelocTypeName);
   const wasm::WasmRelocation &WasmReloc = Obj->getWasmRelocation(Reloc);
 
   bool HasAddend = false;
   switch (RelocType) {
   case wasm::R_WEBASSEMBLY_MEMORY_ADDR_LEB:
   case wasm::R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
   case wasm::R_WEBASSEMBLY_MEMORY_ADDR_I32:
+  case wasm::R_WEBASSEMBLY_MEMORY_TLSOFF_LEB:
     HasAddend = true;
     break;
   default:
     break;
   }
   if (opts::ExpandRelocs) {
     DictScope Group(W, "Relocation");
     W.printNumber("Type", RelocTypeName, RelocType);

tools/yaml2obj/yaml2wasm.cpp

int WasmWriter::writeRelocSection(raw_ostream &OS,
   for (auto Reloc: Sec.Relocations) {
     writeUint8(OS, Reloc.Type);
     encodeULEB128(Reloc.Offset, OS);
     encodeULEB128(Reloc.Index, OS);
     switch (Reloc.Type) {
       case wasm::R_WEBASSEMBLY_MEMORY_ADDR_LEB:
       case wasm::R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
       case wasm::R_WEBASSEMBLY_MEMORY_ADDR_I32:
+      case wasm::R_WEBASSEMBLY_MEMORY_TLSOFF_LEB:
         encodeULEB128(Reloc.Addend, OS);
     }
   }
   return 0;
 }
 
 
 int WasmWriter::writeWasm(raw_ostream &OS) {