diff --git a/llvm/include/llvm/MC/MCSymbolWasm.h b/llvm/include/llvm/MC/MCSymbolWasm.h
--- a/llvm/include/llvm/MC/MCSymbolWasm.h
+++ b/llvm/include/llvm/MC/MCSymbolWasm.h
@@ -18,6 +18,7 @@
   bool IsWeak = false;
   bool IsHidden = false;
   bool IsComdat = false;
+  mutable bool IsUsedInGOT = false;
   Optional<std::string> ImportModule;
   Optional<std::string> ImportName;
   wasm::WasmSignature *Signature = nullptr;
@@ -78,6 +79,9 @@
   }
   void setImportName(StringRef Name) { ImportName = Name; }
 
+  void setUsedInGOT() const { IsUsedInGOT = true; }
+  bool isUsedInGOT() const { return IsUsedInGOT; }
+
   const wasm::WasmSignature *getSignature() const { return Signature; }
   void setSignature(wasm::WasmSignature *Sig) { Signature = Sig; }
 
diff --git a/llvm/lib/MC/WasmObjectWriter.cpp b/llvm/lib/MC/WasmObjectWriter.cpp
--- a/llvm/lib/MC/WasmObjectWriter.cpp
+++ b/llvm/lib/MC/WasmObjectWriter.cpp
@@ -259,7 +259,6 @@
 
   DenseMap<WasmSignature, uint32_t, WasmSignatureDenseMapInfo> SignatureIndices;
   SmallVector<WasmSignature, 4> Signatures;
-  SmallVector<WasmGlobal, 4> Globals;
   SmallVector<WasmDataSegment, 4> DataSegments;
   unsigned NumFunctionImports = 0;
   unsigned NumGlobalImports = 0;
@@ -294,7 +293,6 @@
     CustomSectionsRelocations.clear();
     SignatureIndices.clear();
     Signatures.clear();
-    Globals.clear();
     DataSegments.clear();
     SectionFunctions.clear();
     NumFunctionImports = 0;
@@ -324,7 +322,6 @@
   void writeImportSection(ArrayRef<wasm::WasmImport> Imports, uint32_t DataSize,
                           uint32_t NumElements);
   void writeFunctionSection(ArrayRef<WasmFunction> Functions);
-  void writeGlobalSection();
   void writeExportSection(ArrayRef<wasm::WasmExport> Exports);
   void writeElemSection(ArrayRef<uint32_t> TableElems);
   void writeCodeSection(const MCAssembler &Asm, const MCAsmLayout &Layout,
@@ -543,6 +540,9 @@
     SymA->setUsedInReloc();
   }
 
+  if (Type == wasm::R_WASM_GLOBAL_INDEX_LEB)
+    SymA->setUsedInGOT();
+
   WasmRelocationEntry Rec(FixupOffset, SymA, C, Type, &FixupSection);
   LLVM_DEBUG(dbgs() << "WasmReloc: " << Rec << "\n");
 
@@ -785,26 +785,6 @@
   endSection(Section);
 }
 
-void WasmObjectWriter::writeGlobalSection() {
-  if (Globals.empty())
-    return;
-
-  SectionBookkeeping Section;
-  startSection(Section, wasm::WASM_SEC_GLOBAL);
-
-  encodeULEB128(Globals.size(), W.OS);
-  for (const WasmGlobal &Global : Globals) {
-    writeValueType(static_cast<wasm::ValType>(Global.Type.Type));
-    W.OS << char(Global.Type.Mutable);
-
-    W.OS << char(wasm::WASM_OPCODE_I32_CONST);
-    encodeSLEB128(Global.InitialValue, W.OS);
-    W.OS << char(wasm::WASM_OPCODE_END);
-  }
-
-  endSection(Section);
-}
-
 void WasmObjectWriter::writeEventSection(ArrayRef<wasm::WasmEventType> Events) {
   if (Events.empty())
     return;
@@ -1207,7 +1187,7 @@
         Import.SigIndex = getFunctionType(WS);
         Imports.push_back(Import);
         WasmIndices[&WS] = NumFunctionImports++;
-      } else if (WS.isGlobal()) {
+      } else if (WS.isGlobal() || WS.isUsedInGOT()) {
         if (WS.isWeak())
           report_fatal_error("undefined global symbol cannot be weak");
 
@@ -1215,7 +1195,10 @@
         Import.Module = WS.getImportModule();
         Import.Field = WS.getImportName();
         Import.Kind = wasm::WASM_EXTERNAL_GLOBAL;
-        Import.Global = WS.getGlobalType();
+        if (WS.isGlobal())
+          Import.Global = WS.getGlobalType();
+        else
+          Import.Global = {wasm::WASM_TYPE_I32, true};
         Imports.push_back(Import);
         WasmIndices[&WS] = NumGlobalImports++;
       } else if (WS.isEvent()) {
@@ -1579,7 +1562,6 @@
   writeFunctionSection(Functions);
   // Skip the "table" section; we import the table instead.
   // Skip the "memory" section; we import the memory instead.
-  writeGlobalSection();
   writeEventSection(Events);
   writeExportSection(Exports);
   writeElemSection(TableElems);
diff --git a/llvm/lib/Object/WasmObjectFile.cpp b/llvm/lib/Object/WasmObjectFile.cpp
--- a/llvm/lib/Object/WasmObjectFile.cpp
+++ b/llvm/lib/Object/WasmObjectFile.cpp
@@ -747,7 +747,7 @@
                                               object_error::parse_failed);
       break;
     case wasm::R_WASM_GLOBAL_INDEX_LEB:
-      if (!isValidGlobalSymbol(Reloc.Index))
+      if (!isValidGlobalSymbol(Reloc.Index) && !isValidDataSymbol(Reloc.Index))
         return make_error<GenericBinaryError>("Bad relocation global index",
                                               object_error::parse_failed);
       break;
diff --git a/llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCTargetDesc.h b/llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCTargetDesc.h
--- a/llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCTargetDesc.h
+++ b/llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCTargetDesc.h
@@ -87,14 +87,19 @@
 
 /// Target Operand Flag enum.
 enum TOF {
-  MO_NO_FLAG = 0,
+  MO_NO_FLAG,
 
   // Flags to indicate the type of the symbol being referenced
   MO_SYMBOL_FUNCTION = 0x1,
   MO_SYMBOL_GLOBAL = 0x2,
   MO_SYMBOL_EVENT = 0x4,
   MO_SYMBOL_MASK = 0x7,
+
+  // Address of data symbol via a wasm global.  This adds a level of indirection
+  // similar to the GOT on native platforms.
+  MO_GOT = 0x8,
 };
+
 } // end namespace WebAssemblyII
 
 } // end namespace llvm
diff --git a/llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyWasmObjectWriter.cpp b/llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyWasmObjectWriter.cpp
--- a/llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyWasmObjectWriter.cpp
+++ b/llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyWasmObjectWriter.cpp
@@ -46,6 +46,10 @@
   return Ref->getKind() == MCSymbolRefExpr::VK_WebAssembly_TYPEINDEX;
 }
 
+static bool isGOTRef(const MCSymbolRefExpr *Ref) {
+  return Ref->getKind() == MCSymbolRefExpr::VK_GOT;
+}
+
 static const MCSection *getFixupSection(const MCExpr *Expr) {
   if (auto SyExp = dyn_cast<MCSymbolRefExpr>(Expr)) {
     if (SyExp->getSymbol().isInSection())
@@ -85,7 +89,7 @@
       else
         return wasm::R_WASM_FUNCTION_INDEX_LEB;
     }
-    if (SymA.isGlobal())
+    if (SymA.isGlobal() || isGOTRef(RefA))
       return wasm::R_WASM_GLOBAL_INDEX_LEB;
     if (SymA.isEvent())
       return wasm::R_WASM_EVENT_INDEX_LEB;
diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyFastISel.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyFastISel.cpp
--- a/llvm/lib/Target/WebAssembly/WebAssemblyFastISel.cpp
+++ b/llvm/lib/Target/WebAssembly/WebAssemblyFastISel.cpp
@@ -152,6 +152,8 @@
   }
   bool computeAddress(const Value *Obj, Address &Addr);
   void materializeLoadStoreOperands(Address &Addr);
+  unsigned materializeDataAddrPIC(const GlobalValue *GV);
+  unsigned materializeFunctionAddrPIC(const GlobalValue *GV);
   void addLoadStoreOperands(const Address &Addr, const MachineInstrBuilder &MIB,
                             MachineMemOperand *MMO);
   unsigned maskI1Value(unsigned Reg, const Value *V);
@@ -374,16 +376,79 @@
   return Addr.getReg() != 0;
 }
 
+unsigned
+WebAssemblyFastISel::materializeFunctionAddrPIC(const GlobalValue *GV) {
+  // For PIC code, function addresses need to be offset by to __table_base
+  // wasm global.
+  LLVM_DEBUG(dbgs() << "materializeFunctionAddrPIC\n");
+  unsigned BaseReg = createResultReg(&WebAssembly::I32RegClass);
+  auto *Base = FuncInfo.MF->createExternalSymbolName("__table_base");
+  unsigned Opc = WebAssembly::GLOBAL_GET_I32;
+  BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(Opc), BaseReg)
+      .addExternalSymbol(Base, WebAssemblyII::MO_SYMBOL_GLOBAL);
+
+  unsigned OpcConst = WebAssembly::CONST_I32;
+  unsigned ConstReg = createResultReg(&WebAssembly::I32RegClass);
+  BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(OpcConst), ConstReg)
+      .addGlobalAddress(GV);
+
+  unsigned OpcAdd = WebAssembly::ADD_I32;
+  unsigned ResultReg = createResultReg(&WebAssembly::I32RegClass);
+  BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(OpcAdd), ResultReg)
+      .addReg(BaseReg)
+      .addReg(ConstReg);
+  return ResultReg;
+}
+
+unsigned WebAssemblyFastISel::materializeDataAddrPIC(const GlobalValue *GV) {
+
+  unsigned Reg = createResultReg(&WebAssembly::I32RegClass);
+  assert(TLI.isPositionIndependent());
+  LLVM_DEBUG(dbgs() << "materializeDataAddrPIC: " << GV->getName() << "\n");
+  // For PIC code, data address are either loaded offset from __memory_base or
+  // from an imported global.
+  unsigned Opc = WebAssembly::GLOBAL_GET_I32;
+  if (TM.shouldAssumeDSOLocal(*GV->getParent(), GV)) {
+    unsigned BaseReg = createResultReg(&WebAssembly::I32RegClass);
+    auto *Base = FuncInfo.MF->createExternalSymbolName("__memory_base");
+    BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(Opc), BaseReg)
+        .addExternalSymbol(Base, WebAssemblyII::MO_SYMBOL_GLOBAL);
+
+    unsigned OpcConst = WebAssembly::CONST_I32;
+    unsigned ConstReg = createResultReg(&WebAssembly::I32RegClass);
+    BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(OpcConst),
+            ConstReg)
+        .addGlobalAddress(GV);
+
+    unsigned OpcAdd = WebAssembly::ADD_I32;
+    BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(OpcAdd), Reg)
+        .addReg(BaseReg)
+        .addReg(ConstReg);
+  } else {
+    BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(Opc), Reg)
+        .addGlobalAddress(GV, /*Offset*/ 0, WebAssemblyII::MO_GOT);
+  }
+
+  return Reg;
+}
+
 void WebAssemblyFastISel::materializeLoadStoreOperands(Address &Addr) {
+  LLVM_DEBUG(dbgs() << "materializeLoadStoreOperands\n");
   if (Addr.isRegBase()) {
     unsigned Reg = Addr.getReg();
     if (Reg == 0) {
-      Reg = createResultReg(Subtarget->hasAddr64() ? &WebAssembly::I64RegClass
-                                                   : &WebAssembly::I32RegClass);
-      unsigned Opc = Subtarget->hasAddr64() ? WebAssembly::CONST_I64
-                                            : WebAssembly::CONST_I32;
-      BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(Opc), Reg)
-          .addImm(0);
+      const GlobalValue *GV = Addr.getGlobalValue();
+      if (GV && TLI.isPositionIndependent()) {
+        if (GV->getValueType()->isFunctionTy())
+          Reg = materializeFunctionAddrPIC(GV);
+        else
+          Reg = materializeDataAddrPIC(GV);
+      } else {
+        Reg = createResultReg(&WebAssembly::I32RegClass);
+        unsigned Opc = WebAssembly::CONST_I32;
+        BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(Opc), Reg)
+            .addImm(0);
+      }
       Addr.setReg(Reg);
     }
   }
@@ -396,7 +461,10 @@
   // TODO: Disable SetP2AlignOperands for FastISel and just do it here.
   MIB.addImm(0);
 
-  if (const GlobalValue *GV = Addr.getGlobalValue())
+  const GlobalValue *GV = Addr.getGlobalValue();
+
+  // For PIC code the global address in the stack already
+  if (GV && !TLI.isPositionIndependent())
     MIB.addGlobalAddress(GV, Addr.getOffset());
   else
     MIB.addImm(Addr.getOffset());
@@ -604,15 +672,20 @@
 }
 
 unsigned WebAssemblyFastISel::fastMaterializeConstant(const Constant *C) {
-  if (const auto *GV = dyn_cast<GlobalValue>(C)) {
-    unsigned ResultReg =
-        createResultReg(Subtarget->hasAddr64() ? &WebAssembly::I64RegClass
-                                               : &WebAssembly::I32RegClass);
-    unsigned Opc = Subtarget->hasAddr64() ? WebAssembly::CONST_I64
-                                          : WebAssembly::CONST_I32;
-    BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(Opc), ResultReg)
-        .addGlobalAddress(GV);
-    return ResultReg;
+  if (const GlobalValue *GV = dyn_cast<GlobalValue>(C)) {
+    LLVM_DEBUG(dbgs() << "fastMaterializeConstant " << *GV << "\n");
+    if (TLI.isPositionIndependent()) {
+      if (GV->getValueType()->isFunctionTy())
+        return materializeFunctionAddrPIC(GV);
+      else
+        return materializeDataAddrPIC(GV);
+    } else {
+      unsigned ResultReg = createResultReg(&WebAssembly::I32RegClass);
+      unsigned Opc = WebAssembly::CONST_I32;
+      BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(Opc), ResultReg)
+          .addGlobalAddress(GV);
+      return ResultReg;
+    }
   }
 
   // Let target-independent code handle it.
@@ -741,9 +814,15 @@
     return false;
 
   bool IsDirect = Func != nullptr;
+
   if (!IsDirect && isa<ConstantExpr>(Call->getCalledValue()))
     return false;
 
+  if (IsDirect && TLI.isPositionIndependent() && !Func->hasHiddenVisibility()) {
+    LLVM_DEBUG(dbgs() << "call to external function: " << *Func << "\n");
+    IsDirect = false;
+  }
+
   FunctionType *FuncTy = Call->getFunctionType();
   unsigned Opc;
   bool IsVoid = FuncTy->getReturnType()->isVoidTy();
diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyISD.def b/llvm/lib/Target/WebAssembly/WebAssemblyISD.def
--- a/llvm/lib/Target/WebAssembly/WebAssemblyISD.def
+++ b/llvm/lib/Target/WebAssembly/WebAssemblyISD.def
@@ -17,7 +17,11 @@
 HANDLE_NODETYPE(CALL0)
 HANDLE_NODETYPE(RETURN)
 HANDLE_NODETYPE(ARGUMENT)
+// A wrapper node for TargetExternalSymbol, TargetGlobalAddress, and MCSymbol
 HANDLE_NODETYPE(Wrapper)
+// A special wapper used in PIC code for __memory_base/__table_base relcative
+// access.
+HANDLE_NODETYPE(WrapperPIC)
 HANDLE_NODETYPE(BR_IF)
 HANDLE_NODETYPE(BR_TABLE)
 HANDLE_NODETYPE(SHUFFLE)
diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyISelLowering.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyISelLowering.cpp
--- a/llvm/lib/Target/WebAssembly/WebAssemblyISelLowering.cpp
+++ b/llvm/lib/Target/WebAssembly/WebAssemblyISelLowering.cpp
@@ -759,9 +759,8 @@
   }
   InTys.push_back(MVT::Other);
   SDVTList InTyList = DAG.getVTList(InTys);
-  SDValue Res =
-      DAG.getNode(Ins.empty() ? WebAssemblyISD::CALL0 : WebAssemblyISD::CALL1,
-                  DL, InTyList, Ops);
+  unsigned Opcode = Ins.empty() ? WebAssemblyISD::CALL0 : WebAssemblyISD::CALL1;
+  SDValue Res = DAG.getNode(Opcode, DL, InTyList, Ops);
   if (Ins.empty()) {
     Chain = Res;
   } else {
@@ -983,9 +982,34 @@
          "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()));
+
+  const GlobalValue *GV = GA->getGlobal();
+  LLVM_DEBUG(dbgs() << "LowerGlobalAddress: " << *GV << "\n");
+
+  unsigned Flags = 0;
+  if (isPositionIndependent()) {
+    if (getTargetMachine().shouldAssumeDSOLocal(*GV->getParent(), GV)) {
+      MachineFunction &MF = DAG.getMachineFunction();
+      MVT PtrVT = getPointerTy(MF.getDataLayout());
+      const char *SymName = MF.createExternalSymbolName("__memory_base");
+
+      SDValue BaseAddr =
+          DAG.getNode(WebAssemblyISD::Wrapper, DL, PtrVT,
+                      DAG.getTargetExternalSymbol(SymName, PtrVT));
+
+      SDValue SymAddr = DAG.getNode(
+          WebAssemblyISD::WrapperPIC, DL, VT,
+          DAG.getTargetGlobalAddress(GA->getGlobal(), DL, VT, GA->getOffset()));
+
+      return DAG.getNode(ISD::ADD, DL, VT, BaseAddr, SymAddr);
+    } else {
+      Flags |= WebAssemblyII::MO_GOT;
+    }
+  }
+
+  return DAG.getNode(WebAssemblyISD::Wrapper, DL, VT,
+                     DAG.getTargetGlobalAddress(GA->getGlobal(), DL, VT,
+                                                GA->getOffset(), Flags));
 }
 
 SDValue
diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyInstrInfo.td b/llvm/lib/Target/WebAssembly/WebAssemblyInstrInfo.td
--- a/llvm/lib/Target/WebAssembly/WebAssemblyInstrInfo.td
+++ b/llvm/lib/Target/WebAssembly/WebAssemblyInstrInfo.td
@@ -15,6 +15,9 @@
 // WebAssembly Instruction Predicate Definitions.
 //===----------------------------------------------------------------------===//
 
+def IsPIC     : Predicate<"TM.isPositionIndependent()">;
+def IsNotPIC  : Predicate<"!TM.isPositionIndependent()">;
+
 def HasAddr32 : Predicate<"!Subtarget->hasAddr64()">;
 
 def HasAddr64 : Predicate<"Subtarget->hasAddr64()">;
@@ -67,14 +70,16 @@
                                                   SDTCisVT<1, iPTR>]>;
 def SDT_WebAssemblyCallSeqEnd :
     SDCallSeqEnd<[SDTCisVT<0, iPTR>, SDTCisVT<1, iPTR>]>;
-def SDT_WebAssemblyCall0    : SDTypeProfile<0, -1, [SDTCisPtrTy<0>]>;
-def SDT_WebAssemblyCall1    : SDTypeProfile<1, -1, [SDTCisPtrTy<1>]>;
-def SDT_WebAssemblyBrTable  : SDTypeProfile<0, -1, [SDTCisPtrTy<0>]>;
-def SDT_WebAssemblyArgument : SDTypeProfile<1, 1, [SDTCisVT<1, i32>]>;
-def SDT_WebAssemblyReturn   : SDTypeProfile<0, -1, []>;
-def SDT_WebAssemblyWrapper  : SDTypeProfile<1, 1, [SDTCisSameAs<0, 1>,
-                                                   SDTCisPtrTy<0>]>;
-def SDT_WebAssemblyThrow    : SDTypeProfile<0, -1, [SDTCisPtrTy<0>]>;
+def SDT_WebAssemblyCall0      : SDTypeProfile<0, -1, [SDTCisPtrTy<0>]>;
+def SDT_WebAssemblyCall1      : SDTypeProfile<1, -1, [SDTCisPtrTy<1>]>;
+def SDT_WebAssemblyBrTable    : SDTypeProfile<0, -1, [SDTCisPtrTy<0>]>;
+def SDT_WebAssemblyArgument   : SDTypeProfile<1, 1, [SDTCisVT<1, i32>]>;
+def SDT_WebAssemblyReturn     : SDTypeProfile<0, -1, []>;
+def SDT_WebAssemblyWrapper    : SDTypeProfile<1, 1, [SDTCisSameAs<0, 1>,
+                                                     SDTCisPtrTy<0>]>;
+def SDT_WebAssemblyWrapperPIC : SDTypeProfile<1, 1, [SDTCisSameAs<0, 1>,
+                                                     SDTCisPtrTy<0>]>;
+def SDT_WebAssemblyThrow      : SDTypeProfile<0, -1, [SDTCisPtrTy<0>]>;
 
 //===----------------------------------------------------------------------===//
 // WebAssembly-specific DAG Nodes.
@@ -101,6 +106,8 @@
                                  SDT_WebAssemblyReturn, [SDNPHasChain]>;
 def WebAssemblywrapper  : SDNode<"WebAssemblyISD::Wrapper",
                                  SDT_WebAssemblyWrapper>;
+def WebAssemblywrapperPIC  : SDNode<"WebAssemblyISD::WrapperPIC",
+                                     SDT_WebAssemblyWrapperPIC>;
 def WebAssemblythrow : SDNode<"WebAssemblyISD::THROW", SDT_WebAssemblyThrow,
                               [SDNPHasChain, SDNPVariadic]>;
 
@@ -295,11 +302,22 @@
 } // isMoveImm = 1, isAsCheapAsAMove = 1, isReMaterializable = 1
 
 def : Pat<(i32 (WebAssemblywrapper tglobaladdr:$addr)),
-          (CONST_I32 tglobaladdr:$addr)>;
+          (CONST_I32 tglobaladdr:$addr)>, Requires<[IsNotPIC]>;
+
+def : Pat<(i32 (WebAssemblywrapper tglobaladdr:$addr)),
+          (GLOBAL_GET_I32 tglobaladdr:$addr)>, Requires<[IsPIC]>;
+
+def : Pat<(i32 (WebAssemblywrapperPIC tglobaladdr:$addr)),
+          (CONST_I32 tglobaladdr:$addr)>, Requires<[IsPIC]>;
+
+def : Pat<(i32 (WebAssemblywrapper texternalsym:$addr)),
+          (GLOBAL_GET_I32 texternalsym:$addr)>, Requires<[IsPIC]>;
+
 def : Pat<(i32 (WebAssemblywrapper texternalsym:$addr)),
-          (CONST_I32 texternalsym:$addr)>;
-def : Pat<(i32 (WebAssemblywrapper mcsym:$sym)), (CONST_I32 mcsym:$sym)>;
-def : Pat<(i64 (WebAssemblywrapper mcsym:$sym)), (CONST_I64 mcsym:$sym)>;
+          (CONST_I32 texternalsym:$addr)>, Requires<[IsNotPIC]>;
+
+def : Pat<(i32 (WebAssemblywrapper mcsym:$sym)), (CONST_I32 mcsym:$sym)>, Requires<[IsNotPIC]>;
+def : Pat<(i64 (WebAssemblywrapper mcsym:$sym)), (CONST_I64 mcsym:$sym)>, Requires<[IsNotPIC]>;
 
 //===----------------------------------------------------------------------===//
 // Additional sets of instructions.
diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemory.td b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemory.td
--- a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemory.td
+++ b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemory.td
@@ -95,7 +95,7 @@
 
 class LoadPatGlobalAddr<ValueType ty, PatFrag kind, NI inst> :
   Pat<(ty (kind (regPlusGA I32:$addr, (WebAssemblywrapper tglobaladdr:$off)))),
-      (inst 0, tglobaladdr:$off, I32:$addr)>;
+      (inst 0, tglobaladdr:$off, I32:$addr)>, Requires<[IsNotPIC]>;
 
 def : LoadPatGlobalAddr<i32, load, LOAD_I32>;
 def : LoadPatGlobalAddr<i64, load, LOAD_I64>;
@@ -113,7 +113,7 @@
 
 class LoadPatGlobalAddrOffOnly<ValueType ty, PatFrag kind, NI inst> :
   Pat<(ty (kind (WebAssemblywrapper tglobaladdr:$off))),
-      (inst 0, tglobaladdr:$off, (CONST_I32 0))>;
+      (inst 0, tglobaladdr:$off, (CONST_I32 0))>, Requires<[IsNotPIC]>;
 
 def : LoadPatGlobalAddrOffOnly<i32, load, LOAD_I32>;
 def : LoadPatGlobalAddrOffOnly<i64, load, LOAD_I64>;
@@ -285,7 +285,7 @@
 class StorePatGlobalAddr<ValueType ty, PatFrag kind, NI inst> :
   Pat<(kind ty:$val,
             (regPlusGA I32:$addr, (WebAssemblywrapper tglobaladdr:$off))),
-      (inst 0, tglobaladdr:$off, I32:$addr, ty:$val)>;
+      (inst 0, tglobaladdr:$off, I32:$addr, ty:$val)>, Requires<[IsNotPIC]>;
 def : StorePatGlobalAddr<i32, store, STORE_I32>;
 def : StorePatGlobalAddr<i64, store, STORE_I64>;
 def : StorePatGlobalAddr<f32, store, STORE_F32>;
@@ -301,7 +301,7 @@
 
 class StorePatGlobalAddrOffOnly<ValueType ty, PatFrag kind, NI inst> :
   Pat<(kind ty:$val, (WebAssemblywrapper tglobaladdr:$off)),
-      (inst 0, tglobaladdr:$off, (CONST_I32 0), ty:$val)>;
+      (inst 0, tglobaladdr:$off, (CONST_I32 0), ty:$val)>, Requires<[IsNotPIC]>;
 def : StorePatGlobalAddrOffOnly<i32, store, STORE_I32>;
 def : StorePatGlobalAddrOffOnly<i64, store, STORE_I64>;
 def : StorePatGlobalAddrOffOnly<f32, store, STORE_F32>;
diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyMCInstLower.h b/llvm/lib/Target/WebAssembly/WebAssemblyMCInstLower.h
--- a/llvm/lib/Target/WebAssembly/WebAssemblyMCInstLower.h
+++ b/llvm/lib/Target/WebAssembly/WebAssemblyMCInstLower.h
@@ -33,7 +33,7 @@
   MCSymbol *GetGlobalAddressSymbol(const MachineOperand &MO) const;
   MCSymbol *GetExternalSymbolSymbol(const MachineOperand &MO) const;
   MCOperand lowerSymbolOperand(MCSymbol *Sym, int64_t Offset, bool IsFunc,
-                               bool IsGlob, bool IsEvent) const;
+                               bool IsGlob, bool IsEvent, unsigned flags) const;
 
 public:
   WebAssemblyMCInstLower(MCContext &ctx, WebAssemblyAsmPrinter &printer)
diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp
--- a/llvm/lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp
+++ b/llvm/lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp
@@ -73,11 +73,12 @@
   auto *WasmSym = cast<MCSymbolWasm>(Printer.GetExternalSymbolSymbol(Name));
   const WebAssemblySubtarget &Subtarget = Printer.getSubtarget();
 
-  // Except for the two exceptions (__stack_pointer and __cpp_exception), 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) {
+  // Except for certain known symbols, all 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, "__memory_base") == 0 || strcmp(Name, "__table_base") == 0) {
     WasmSym->setType(wasm::WASM_SYMBOL_TYPE_GLOBAL);
     WasmSym->setGlobalType(wasm::WasmGlobalType{
         uint8_t(Subtarget.hasAddr64() ? wasm::WASM_TYPE_I64
@@ -118,12 +119,16 @@
   return WasmSym;
 }
 
-MCOperand WebAssemblyMCInstLower::lowerSymbolOperand(MCSymbol *Sym,
-                                                     int64_t Offset,
-                                                     bool IsFunc, bool IsGlob,
-                                                     bool IsEvent) const {
-  const MCExpr *Expr =
-      MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_None, Ctx);
+MCOperand WebAssemblyMCInstLower::lowerSymbolOperand(
+    MCSymbol *Sym, int64_t Offset, bool IsFunc, bool IsGlob, bool IsEvent,
+    unsigned TargetFlags) const {
+  MCSymbolRefExpr::VariantKind Kind = MCSymbolRefExpr::VK_None;
+  if (TargetFlags == WebAssemblyII::MO_GOT) {
+    if (Offset != 0)
+      report_fatal_error("GOT symbol references do not support offsets");
+    Kind = MCSymbolRefExpr::VK_GOT;
+  }
+  const MCExpr *Expr = MCSymbolRefExpr::create(Sym, Kind, Ctx);
 
   if (Offset != 0) {
     if (IsFunc)
@@ -230,11 +235,9 @@
       break;
     }
     case MachineOperand::MO_GlobalAddress:
-      assert(MO.getTargetFlags() == WebAssemblyII::MO_NO_FLAG &&
-             "WebAssembly does not use target flags on GlobalAddresses");
       MCOp = lowerSymbolOperand(GetGlobalAddressSymbol(MO), MO.getOffset(),
                                 MO.getGlobal()->getValueType()->isFunctionTy(),
-                                false, false);
+                                false, false, MO.getTargetFlags());
       break;
     case MachineOperand::MO_ExternalSymbol:
       // The target flag indicates whether this is a symbol for a
@@ -245,7 +248,8 @@
           GetExternalSymbolSymbol(MO), /*Offset=*/0,
           (MO.getTargetFlags() & WebAssemblyII::MO_SYMBOL_FUNCTION) != 0,
           (MO.getTargetFlags() & WebAssemblyII::MO_SYMBOL_GLOBAL) != 0,
-          (MO.getTargetFlags() & WebAssemblyII::MO_SYMBOL_EVENT) != 0);
+          (MO.getTargetFlags() & WebAssemblyII::MO_SYMBOL_EVENT) != 0,
+          MO.getTargetFlags());
       break;
     case MachineOperand::MO_MCSymbol:
       // This is currently used only for LSDA symbols (GCC_except_table),
@@ -253,7 +257,7 @@
       assert(MO.getTargetFlags() == 0 &&
              "WebAssembly does not use target flags on MCSymbol");
       MCOp = lowerSymbolOperand(MO.getMCSymbol(), /*Offset=*/0, false, false,
-                                false);
+                                false, MO.getTargetFlags());
       break;
     }
 
diff --git a/llvm/test/CodeGen/WebAssembly/address-offsets.ll b/llvm/test/CodeGen/WebAssembly/address-offsets.ll
--- a/llvm/test/CodeGen/WebAssembly/address-offsets.ll
+++ b/llvm/test/CodeGen/WebAssembly/address-offsets.ll
@@ -1,4 +1,6 @@
-; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -wasm-disable-explicit-locals -wasm-keep-registers | FileCheck %s
+; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -wasm-disable-explicit-locals -wasm-keep-registers | FileCheck %s -check-prefixes=CHECK,NON-PIC
+; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -wasm-disable-explicit-locals -wasm-keep-registers -relocation-model=pic -fast-isel | FileCheck %s -check-prefixes=CHECK,PIC
+
 
 ; Test folding constant offsets and symbols into load and store addresses under
 ; a variety of circumstances.
@@ -10,8 +12,10 @@
 
 ; CHECK-LABEL: load_test0:
 ; CHECK-NEXT: .functype load_test0 () -> (i32){{$}}
-; CHECK-NEXT: i32.const $push0=, 0{{$}}
-; CHECK-NEXT: i32.load  $push1=, g+40($pop0){{$}}
+; NON-PIC-NEXT:  i32.const $push0=, 0{{$}}
+; NON-PIC-NEXT:  i32.load  $push1=, g+40($pop0){{$}}
+; PIC-NEXT:   global.get $push0=, g@GOT{{$}}
+; PIC-NEXT:   i32.load  $push1=, 40($pop0){{$}}
 ; CHECK-NEXT: return    $pop1{{$}}
 define i32 @load_test0() {
   %t = load i32, i32* getelementptr inbounds ([0 x i32], [0 x i32]* @g, i32 0, i32 10), align 4
@@ -20,8 +24,10 @@
 
 ; CHECK-LABEL: load_test0_noinbounds:
 ; CHECK-NEXT: .functype load_test0_noinbounds () -> (i32){{$}}
-; CHECK-NEXT: i32.const $push0=, 0{{$}}
-; CHECK-NEXT: i32.load  $push1=, g+40($pop0){{$}}
+; NON-PIC-NEXT:  i32.const $push0=, 0{{$}}
+; NON-PIC-NEXT:  i32.load  $push1=, g+40($pop0){{$}}
+; PIC-NEXT:   global.get $push0=, g@GOT{{$}}
+; PIC-NEXT:   i32.load  $push1=, 40($pop0){{$}}
 ; CHECK-NEXT: return    $pop1{{$}}
 define i32 @load_test0_noinbounds() {
   %t = load i32, i32* getelementptr ([0 x i32], [0 x i32]* @g, i32 0, i32 10), align 4
@@ -34,7 +40,7 @@
 
 ; CHECK-LABEL: load_test1:
 ; CHECK-NEXT: .functype load_test1 (i32) -> (i32){{$}}
-; CHECK-NEXT: i32.const $push0=, 2{{$}}
+; CHECK-NEX T: i32.const $push0=, 2{{$}}
 ; CHECK-NEX T: i32.shl   $push1=, $0, $pop0{{$}}
 ; CHECK-NEX T: i32.load  $push2=, g+40($pop1){{$}}
 ; CHECK-NEX T: return    $pop2{{$}}
@@ -47,7 +53,7 @@
 
 ; CHECK-LABEL: load_test2:
 ; CHECK-NEXT: .functype load_test2 (i32) -> (i32){{$}}
-; CHECK-NEXT: i32.const $push0=, 2{{$}}
+; CHECK-NEX T:  i32.const $push0=, 2{{$}}
 ; CHECK-NEX T: i32.shl   $push1=, $0, $pop0{{$}}
 ; CHECK-NEX T: i32.load  $push2=, g+40($pop1){{$}}
 ; CHECK-NEX T: return    $pop2{{$}}
@@ -60,7 +66,7 @@
 
 ; CHECK-LABEL: load_test3:
 ; CHECK-NEXT: .functype load_test3 (i32) -> (i32){{$}}
-; CHECK-NEXT: i32.const $push0=, 2{{$}}
+; CHECK-NEX T: i32.const $push0=, 2{{$}}
 ; CHECK-NEX T: i32.shl   $push1=, $0, $pop0{{$}}
 ; CHECK-NEX T: i32.load  $push2=, g+40($pop1){{$}}
 ; CHECK-NEX T: return    $pop2{{$}}
@@ -73,7 +79,7 @@
 
 ; CHECK-LABEL: load_test4:
 ; CHECK-NEXT: .functype load_test4 (i32) -> (i32){{$}}
-; CHECK-NEXT: i32.const $push0=, 2{{$}}
+; CHECK-NEX T: i32.const $push0=, 2{{$}}
 ; CHECK-NEX T: i32.shl   $push1=, $0, $pop0{{$}}
 ; CHECK-NEX T: i32.load  $push2=, g+40($pop1){{$}}
 ; CHECK-NEX T: return    $pop2{{$}}
@@ -85,7 +91,7 @@
 
 ; CHECK-LABEL: load_test5:
 ; CHECK-NEXT: .functype load_test5 (i32) -> (i32){{$}}
-; CHECK-NEXT: i32.const $push0=, 2{{$}}
+; CHECK-NEX T: i32.const $push0=, 2{{$}}
 ; CHECK-NEX T: i32.shl   $push1=, $0, $pop0{{$}}
 ; CHECK-NEX T: i32.load  $push2=, g+40($pop1){{$}}
 ; CHECK-NEX T: return    $pop2{{$}}
@@ -97,7 +103,7 @@
 
 ; CHECK-LABEL: load_test6:
 ; CHECK-NEXT: .functype load_test6 (i32) -> (i32){{$}}
-; CHECK-NEXT: i32.const $push0=, 2{{$}}
+; CHECK-NEX T:  i32.const $push0=, 2{{$}}
 ; CHECK-NEX T: i32.shl   $push1=, $0, $pop0{{$}}
 ; CHECK-NEX T: i32.load  $push2=, g+40($pop1){{$}}
 ; CHECK-NEX T: return    $pop2{{$}}
@@ -110,7 +116,7 @@
 
 ; CHECK-LABEL: load_test7:
 ; CHECK-NEXT: .functype load_test7 (i32) -> (i32){{$}}
-; CHECK-NEXT: i32.const $push0=, 2{{$}}
+; CHECK-NEX T: i32.const $push0=, 2{{$}}
 ; CHECK-NEX T: i32.shl   $push1=, $0, $pop0{{$}}
 ; CHECK-NEX T: i32.load  $push2=, g+40($pop1){{$}}
 ; CHECK-NEX T: return    $pop2{{$}}
@@ -123,7 +129,7 @@
 
 ; CHECK-LABEL: load_test8:
 ; CHECK-NEXT: .functype load_test8 (i32) -> (i32){{$}}
-; CHECK-NEXT: i32.const $push0=, 2{{$}}
+; CHECK-NEX T:  i32.const $push0=, 2{{$}}
 ; CHECK-NEX T: i32.shl   $push1=, $0, $pop0{{$}}
 ; CHECK-NEX T: i32.load  $push2=, g+40($pop1){{$}}
 ; CHECK-NEX T: return    $pop2{{$}}
@@ -136,8 +142,10 @@
 
 ; CHECK-LABEL: load_test9:
 ; CHECK-NEXT: .functype load_test9 () -> (i32){{$}}
-; CHECK-NEXT: i32.const $push0=, 0{{$}}
-; CHECK-NEXT: i32.load  $push1=, g-40($pop0){{$}}
+; PIC-NEXT:   global.get $push0=, g@GOT{{$}}
+; PIC-NEXT:   i32.load  $push1=, 4294967256($pop0){{$}}
+; NON-PIC-NEXT:  i32.const $push0=, 0{{$}}
+; NON-PIC-NEXT:  i32.load  $push1=, g-40($pop0){{$}}
 ; CHECK-NEXT: return    $pop1{{$}}
 define i32 @load_test9() {
   %t = load i32, i32* getelementptr inbounds ([0 x i32], [0 x i32]* @g, i32 0, i32 1073741814), align 4
@@ -146,12 +154,20 @@
 
 ; CHECK-LABEL: load_test10:
 ; CHECK-NEXT: .functype load_test10 (i32) -> (i32){{$}}
-; CHECK-NEXT: i32.const $push0=, 2{{$}}
-; CHECK-NEXT: i32.shl   $push1=, $0, $pop0{{$}}
-; CHECK-NEXT: i32.const $push2=, g-40{{$}}
-; CHECK-NEXT: i32.add   $push3=, $pop1, $pop2{{$}}
-; CHECK-NEXT: i32.load  $push4=, 0($pop3){{$}}
-; CHECK-NEXT: return    $pop4{{$}}
+; NON-PIC-NEXT:  i32.const $push0=, 2{{$}}
+; NON-PIC-NEXT:  i32.shl   $push1=, $0, $pop0{{$}}
+; NON-PIC-NEXT:  i32.const $push2=, g-40{{$}}
+; NON-PIC-NEXT:  i32.add   $push3=, $pop1, $pop2{{$}}
+; NON-PIC-NEXT:  i32.load  $push4=, 0($pop3){{$}}
+; NON-PIC-NEXT:  return    $pop4{{$}}
+; PIC-NEXT:   global.get $push1=, g@GOT{{$}}
+; PIC-NEXT:   i32.const $push5=, -10{{$}}
+; PIC-NEXT:   i32.add   $push6=, $0, $pop5{{$}}
+; PIC-NEXT:   i32.const $push2=, 2{{$}}
+; PIC-NEXT:   i32.shl   $push3=, $pop6, $pop2{{$}}
+; PIC-NEXT:   i32.add   $push4=, $pop1, $pop3{{$}}
+; PIC-NEXT:   i32.load  $push0=, 0($pop4){{$}}
+; PIC-NEXT:   return    $pop0{{$}}
 define i32 @load_test10(i32 %n) {
   %add = add nsw i32 %n, -10
   %arrayidx = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %add
@@ -171,10 +187,10 @@
 
 ; CHECK-LABEL: load_test11_noinbounds:
 ; CHECK-NEXT: .functype load_test11_noinbounds (i32) -> (i32){{$}}
-; CHECK-NEXT: i32.const $push0=, 40{{$}}
-; CHECK-NEXT: i32.add   $push1=, $0, $pop0{{$}}
-; CHECK-NEXT: i32.load  $push2=, 0($pop1){{$}}
-; CHECK-NEXT: return    $pop2{{$}}
+; NON-PIC-NEXT: i32.const $push0=, 40{{$}}
+; NON-PIC-NEXT: i32.add   $push1=, $0, $pop0{{$}}
+; NON-PIC-NEXT: i32.load  $push2=, 0($pop1){{$}}
+; NON-PIC-NEXT: return    $pop2{{$}}
 define i32 @load_test11_noinbounds(i32* %p) {
   %arrayidx = getelementptr i32, i32* %p, i32 10
   %t = load i32, i32* %arrayidx, align 4
@@ -183,13 +199,13 @@
 
 ; CHECK-LABEL: load_test12:
 ; CHECK-NEXT: .functype load_test12 (i32, i32) -> (i32){{$}}
-; CHECK-NEXT: i32.const $push0=, 2{{$}}
-; CHECK-NEXT: i32.shl   $push1=, $1, $pop0{{$}}
-; CHECK-NEXT: i32.add   $push2=, $0, $pop1{{$}}
-; CHECK-NEXT: i32.const $push3=, 40{{$}}
-; CHECK-NEXT: i32.add   $push4=, $pop2, $pop3{{$}}
-; CHECK-NEXT: i32.load  $push5=, 0($pop4){{$}}
-; CHECK-NEXT: return    $pop5{{$}}
+; NON-PIC-NEXT:  i32.const $push0=, 2{{$}}
+; NON-PIC-NEXT:  i32.shl   $push1=, $1, $pop0{{$}}
+; NON-PIC-NEXT:  i32.add   $push2=, $0, $pop1{{$}}
+; NON-PIC-NEXT:  i32.const $push3=, 40{{$}}
+; NON-PIC-NEXT:  i32.add   $push4=, $pop2, $pop3{{$}}
+; NON-PIC-NEXT:  i32.load  $push5=, 0($pop4){{$}}
+; NON-PIC-NEXT:  return    $pop5{{$}}
 define i32 @load_test12(i32* %p, i32 %n) {
   %add = add nsw i32 %n, 10
   %arrayidx = getelementptr inbounds i32, i32* %p, i32 %add
@@ -199,13 +215,13 @@
 
 ; CHECK-LABEL: load_test13:
 ; CHECK-NEXT: .functype load_test13 (i32, i32) -> (i32){{$}}
-; CHECK-NEXT: i32.const $push0=, 2{{$}}
-; CHECK-NEXT: i32.shl   $push1=, $1, $pop0{{$}}
-; CHECK-NEXT: i32.add   $push2=, $0, $pop1{{$}}
-; CHECK-NEXT: i32.const $push3=, 40{{$}}
-; CHECK-NEXT: i32.add   $push4=, $pop2, $pop3{{$}}
-; CHECK-NEXT: i32.load  $push5=, 0($pop4){{$}}
-; CHECK-NEXT: return    $pop5{{$}}
+; NON-PIC-NEXT:  i32.const $push0=, 2{{$}}
+; NON-PIC-NEXT:  i32.shl   $push1=, $1, $pop0{{$}}
+; NON-PIC-NEXT:  i32.add   $push2=, $0, $pop1{{$}}
+; NON-PIC-NEXT:  i32.const $push3=, 40{{$}}
+; NON-PIC-NEXT:  i32.add   $push4=, $pop2, $pop3{{$}}
+; NON-PIC-NEXT:  i32.load  $push5=, 0($pop4){{$}}
+; NON-PIC-NEXT:  return    $pop5{{$}}
 define i32 @load_test13(i32* %p, i32 %n) {
   %add = add nsw i32 10, %n
   %arrayidx = getelementptr inbounds i32, i32* %p, i32 %add
@@ -215,11 +231,11 @@
 
 ; CHECK-LABEL: load_test14:
 ; CHECK-NEXT: .functype load_test14 (i32, i32) -> (i32){{$}}
-; CHECK-NEXT: i32.const $push0=, 2{{$}}
-; CHECK-NEXT: i32.shl   $push1=, $1, $pop0{{$}}
-; CHECK-NEXT: i32.add   $push2=, $0, $pop1{{$}}
-; CHECK-NEXT: i32.load  $push3=, 40($pop2){{$}}
-; CHECK-NEXT: return    $pop3{{$}}
+; NON-PIC-NEXT:  i32.const $push0=, 2{{$}}
+; NON-PIC-NEXT:  i32.shl   $push1=, $1, $pop0{{$}}
+; NON-PIC-NEXT:  i32.add   $push2=, $0, $pop1{{$}}
+; NON-PIC-NEXT:  i32.load  $push3=, 40($pop2){{$}}
+; NON-PIC-NEXT:  return    $pop3{{$}}
 define i32 @load_test14(i32* %p, i32 %n) {
   %add.ptr = getelementptr inbounds i32, i32* %p, i32 %n
   %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 10
@@ -229,13 +245,13 @@
 
 ; CHECK-LABEL: load_test15:
 ; CHECK-NEXT: .functype load_test15 (i32, i32) -> (i32){{$}}
-; CHECK-NEXT: i32.const $push0=, 2{{$}}
-; CHECK-NEXT: i32.shl   $push1=, $1, $pop0{{$}}
-; CHECK-NEXT: i32.add   $push2=, $0, $pop1{{$}}
-; CHECK-NEXT: i32.const $push3=, 40{{$}}
-; CHECK-NEXT: i32.add   $push4=, $pop2, $pop3{{$}}
-; CHECK-NEXT: i32.load  $push5=, 0($pop4){{$}}
-; CHECK-NEXT: return    $pop5{{$}}
+; NON-PIC-NEXT:  i32.const $push0=, 2{{$}}
+; NON-PIC-NEXT:  i32.shl   $push1=, $1, $pop0{{$}}
+; NON-PIC-NEXT:  i32.add   $push2=, $0, $pop1{{$}}
+; NON-PIC-NEXT:  i32.const $push3=, 40{{$}}
+; NON-PIC-NEXT:  i32.add   $push4=, $pop2, $pop3{{$}}
+; NON-PIC-NEXT:  i32.load  $push5=, 0($pop4){{$}}
+; NON-PIC-NEXT:  return    $pop5{{$}}
 define i32 @load_test15(i32* %p, i32 %n) {
   %add.ptr = getelementptr inbounds i32, i32* %p, i32 10
   %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 %n
@@ -245,13 +261,13 @@
 
 ; CHECK-LABEL: load_test16:
 ; CHECK-NEXT: .functype load_test16 (i32, i32) -> (i32){{$}}
-; CHECK-NEXT: i32.const $push0=, 2{{$}}
-; CHECK-NEXT: i32.shl   $push1=, $1, $pop0{{$}}
-; CHECK-NEXT: i32.add   $push2=, $0, $pop1{{$}}
-; CHECK-NEXT: i32.const $push3=, 40{{$}}
-; CHECK-NEXT: i32.add   $push4=, $pop2, $pop3{{$}}
-; CHECK-NEXT: i32.load  $push5=, 0($pop4){{$}}
-; CHECK-NEXT: return    $pop5{{$}}
+; NON-PIC-NEXT:  i32.const $push0=, 2{{$}}
+; NON-PIC-NEXT:  i32.shl   $push1=, $1, $pop0{{$}}
+; NON-PIC-NEXT:  i32.add   $push2=, $0, $pop1{{$}}
+; NON-PIC-NEXT:  i32.const $push3=, 40{{$}}
+; NON-PIC-NEXT:  i32.add   $push4=, $pop2, $pop3{{$}}
+; NON-PIC-NEXT:  i32.load  $push5=, 0($pop4){{$}}
+; NON-PIC-NEXT:  return    $pop5{{$}}
 define i32 @load_test16(i32* %p, i32 %n) {
   %add.ptr = getelementptr inbounds i32, i32* %p, i32 10
   %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 %n
@@ -261,13 +277,13 @@
 
 ; CHECK-LABEL: load_test17:
 ; CHECK-NEXT: .functype load_test17 (i32, i32) -> (i32){{$}}
-; CHECK-NEXT: i32.const $push0=, 2{{$}}
-; CHECK-NEXT: i32.shl   $push1=, $1, $pop0{{$}}
-; CHECK-NEXT: i32.add   $push2=, $0, $pop1{{$}}
-; CHECK-NEXT: i32.const $push3=, 40{{$}}
-; CHECK-NEXT: i32.add   $push4=, $pop2, $pop3{{$}}
-; CHECK-NEXT: i32.load  $push5=, 0($pop4){{$}}
-; CHECK-NEXT: return    $pop5{{$}}
+; NON-PIC-NEXT:  i32.const $push0=, 2{{$}}
+; NON-PIC-NEXT:  i32.shl   $push1=, $1, $pop0{{$}}
+; NON-PIC-NEXT:  i32.add   $push2=, $0, $pop1{{$}}
+; NON-PIC-NEXT:  i32.const $push3=, 40{{$}}
+; NON-PIC-NEXT:  i32.add   $push4=, $pop2, $pop3{{$}}
+; NON-PIC-NEXT:  i32.load  $push5=, 0($pop4){{$}}
+; NON-PIC-NEXT:  return    $pop5{{$}}
 define i32 @load_test17(i32* %p, i32 %n) {
   %add = add nsw i32 %n, 10
   %add.ptr = getelementptr inbounds i32, i32* %p, i32 %add
@@ -277,11 +293,11 @@
 
 ; CHECK-LABEL: load_test18:
 ; CHECK-NEXT: .functype load_test18 (i32, i32) -> (i32){{$}}
-; CHECK-NEXT: i32.const $push0=, 2{{$}}
-; CHECK-NEXT: i32.shl   $push1=, $1, $pop0{{$}}
-; CHECK-NEXT: i32.add   $push2=, $0, $pop1{{$}}
-; CHECK-NEXT: i32.load  $push3=, 40($pop2){{$}}
-; CHECK-NEXT: return    $pop3{{$}}
+; NON-PIC-NEXT:  i32.const $push0=, 2{{$}}
+; NON-PIC-NEXT:  i32.shl   $push1=, $1, $pop0{{$}}
+; NON-PIC-NEXT:  i32.add   $push2=, $0, $pop1{{$}}
+; NON-PIC-NEXT:  i32.load  $push3=, 40($pop2){{$}}
+; NON-PIC-NEXT:  return    $pop3{{$}}
 define i32 @load_test18(i32* %p, i32 %n) {
   %add.ptr = getelementptr inbounds i32, i32* %p, i32 %n
   %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 10
@@ -291,13 +307,13 @@
 
 ; CHECK-LABEL: load_test19:
 ; CHECK-NEXT: .functype load_test19 (i32, i32) -> (i32){{$}}
-; CHECK-NEXT: i32.const $push0=, 2{{$}}
-; CHECK-NEXT: i32.shl   $push1=, $1, $pop0{{$}}
-; CHECK-NEXT: i32.add   $push2=, $0, $pop1{{$}}
-; CHECK-NEXT: i32.const $push3=, 40{{$}}
-; CHECK-NEXT: i32.add   $push4=, $pop2, $pop3{{$}}
-; CHECK-NEXT: i32.load  $push5=, 0($pop4){{$}}
-; CHECK-NEXT: return    $pop5{{$}}
+; NON-PIC-NEXT:  i32.const $push0=, 2{{$}}
+; NON-PIC-NEXT:  i32.shl   $push1=, $1, $pop0{{$}}
+; NON-PIC-NEXT:  i32.add   $push2=, $0, $pop1{{$}}
+; NON-PIC-NEXT:  i32.const $push3=, 40{{$}}
+; NON-PIC-NEXT:  i32.add   $push4=, $pop2, $pop3{{$}}
+; NON-PIC-NEXT:  i32.load  $push5=, 0($pop4){{$}}
+; NON-PIC-NEXT:  return    $pop5{{$}}
 define i32 @load_test19(i32* %p, i32 %n) {
   %add = add nsw i32 10, %n
   %add.ptr = getelementptr inbounds i32, i32* %p, i32 %add
@@ -307,10 +323,10 @@
 
 ; CHECK-LABEL: load_test20:
 ; CHECK-NEXT: .functype load_test20 (i32) -> (i32){{$}}
-; CHECK-NEXT: i32.const $push0=, -40{{$}}
-; CHECK-NEXT: i32.add   $push1=, $0, $pop0{{$}}
-; CHECK-NEXT: i32.load  $push2=, 0($pop1){{$}}
-; CHECK-NEXT: return    $pop2{{$}}
+; NON-PIC-NEXT:  i32.const $push0=, -40{{$}}
+; NON-PIC-NEXT:  i32.add   $push1=, $0, $pop0{{$}}
+; NON-PIC-NEXT:  i32.load  $push2=, 0($pop1){{$}}
+; NON-PIC-NEXT:  return    $pop2{{$}}
 define i32 @load_test20(i32* %p) {
   %arrayidx = getelementptr inbounds i32, i32* %p, i32 -10
   %t = load i32, i32* %arrayidx, align 4
@@ -319,13 +335,13 @@
 
 ; CHECK-LABEL: load_test21:
 ; CHECK-NEXT: .functype load_test21 (i32, i32) -> (i32){{$}}
-; CHECK-NEXT: i32.const $push0=, 2{{$}}
-; CHECK-NEXT: i32.shl   $push1=, $1, $pop0{{$}}
-; CHECK-NEXT: i32.add   $push2=, $0, $pop1{{$}}
-; CHECK-NEXT: i32.const $push3=, -40{{$}}
-; CHECK-NEXT: i32.add   $push4=, $pop2, $pop3{{$}}
-; CHECK-NEXT: i32.load  $push5=, 0($pop4){{$}}
-; CHECK-NEXT: return    $pop5{{$}}
+; NON-PIC-NEXT:  i32.const $push0=, 2{{$}}
+; NON-PIC-NEXT:  i32.shl   $push1=, $1, $pop0{{$}}
+; NON-PIC-NEXT:  i32.add   $push2=, $0, $pop1{{$}}
+; NON-PIC-NEXT:  i32.const $push3=, -40{{$}}
+; NON-PIC-NEXT:  i32.add   $push4=, $pop2, $pop3{{$}}
+; NON-PIC-NEXT:  i32.load  $push5=, 0($pop4){{$}}
+; NON-PIC-NEXT:  return    $pop5{{$}}
 define i32 @load_test21(i32* %p, i32 %n) {
   %add = add nsw i32 %n, -10
   %arrayidx = getelementptr inbounds i32, i32* %p, i32 %add
@@ -335,9 +351,9 @@
 
 ; CHECK-LABEL: store_test0:
 ; CHECK-NEXT: .functype store_test0 (i32) -> (){{$}}
-; CHECK-NEXT: i32.const $push0=, 0{{$}}
-; CHECK-NEXT: i32.store g+40($pop0), $0{{$}}
-; CHECK-NEXT: return{{$}}
+; NON-PIC-NEXT:  i32.const $push0=, 0{{$}}
+; NON-PIC-NEXT:  i32.store g+40($pop0), $0{{$}}
+; NON-PIC-NEXT:  return{{$}}
 define void @store_test0(i32 %i) {
   store i32 %i, i32* getelementptr inbounds ([0 x i32], [0 x i32]* @g, i32 0, i32 10), align 4
   ret void
@@ -345,9 +361,9 @@
 
 ; CHECK-LABEL: store_test0_noinbounds:
 ; CHECK-NEXT: .functype store_test0_noinbounds (i32) -> (){{$}}
-; CHECK-NEXT: i32.const $push0=, 0{{$}}
-; CHECK-NEXT: i32.store g+40($pop0), $0{{$}}
-; CHECK-NEXT: return{{$}}
+; NON-PIC-NEXT:  i32.const $push0=, 0{{$}}
+; NON-PIC-NEXT:  i32.store g+40($pop0), $0{{$}}
+; NON-PIC-NEXT:  return{{$}}
 define void @store_test0_noinbounds(i32 %i) {
   store i32 %i, i32* getelementptr ([0 x i32], [0 x i32]* @g, i32 0, i32 10), align 4
   ret void
@@ -355,8 +371,8 @@
 
 ; CHECK-LABEL: store_test1:
 ; CHECK-NEXT: .functype store_test1 (i32, i32) -> (){{$}}
-; CHECK-NEXT: i32.const $push0=, 2{{$}}
-; CHECK-NEXT: i32.shl   $push1=, $0, $pop0{{$}}
+; NON-PIC-NEXT:  i32.const $push0=, 2{{$}}
+; NON-PIC-NEXT:  i32.shl   $push1=, $0, $pop0{{$}}
 ; CHECK-NEX T: i32.store g+40($pop1), $1{{$}}
 ; CHECK-NEX T: return{{$}}
 define void @store_test1(i32 %n, i32 %i) {
@@ -368,8 +384,8 @@
 
 ; CHECK-LABEL: store_test2:
 ; CHECK-NEXT: .functype store_test2 (i32, i32) -> (){{$}}
-; CHECK-NEXT: i32.const $push0=, 2{{$}}
-; CHECK-NEXT: i32.shl   $push1=, $0, $pop0{{$}}
+; NON-PIC-NEXT:  i32.const $push0=, 2{{$}}
+; NON-PIC-NEXT:  i32.shl   $push1=, $0, $pop0{{$}}
 ; CHECK-NEX T: i32.store g+40($pop1), $1{{$}}
 ; CHECK-NEX T: return{{$}}
 define void @store_test2(i32 %n, i32 %i) {
@@ -381,8 +397,8 @@
 
 ; CHECK-LABEL: store_test3:
 ; CHECK-NEXT: .functype store_test3 (i32, i32) -> (){{$}}
-; CHECK-NEXT: i32.const $push0=, 2{{$}}
-; CHECK-NEXT: i32.shl   $push1=, $0, $pop0{{$}}
+; NON-PIC-NEXT:  i32.const $push0=, 2{{$}}
+; NON-PIC-NEXT:  i32.shl   $push1=, $0, $pop0{{$}}
 ; CHECK-NEX T: i32.store g+40($pop1), $1{{$}}
 ; CHECK-NEX T: return{{$}}
 define void @store_test3(i32 %n, i32 %i) {
@@ -394,8 +410,8 @@
 
 ; CHECK-LABEL: store_test4:
 ; CHECK-NEXT: .functype store_test4 (i32, i32) -> (){{$}}
-; CHECK-NEXT: i32.const $push0=, 2{{$}}
-; CHECK-NEXT: i32.shl   $push1=, $0, $pop0{{$}}
+; NON-PIC-NEXT:  i32.const $push0=, 2{{$}}
+; NON-PIC-NEXT:  i32.shl   $push1=, $0, $pop0{{$}}
 ; CHECK-NEX T: i32.store g+40($pop1), $1{{$}}
 ; CHECK-NEX T: return{{$}}
 define void @store_test4(i32 %n, i32 %i) {
@@ -406,8 +422,8 @@
 
 ; CHECK-LABEL: store_test5:
 ; CHECK-NEXT: .functype store_test5 (i32, i32) -> (){{$}}
-; CHECK-NEXT: i32.const $push0=, 2{{$}}
-; CHECK-NEXT: i32.shl   $push1=, $0, $pop0{{$}}
+; NON-PIC-NEXT:  i32.const $push0=, 2{{$}}
+; NON-PIC-NEXT:  i32.shl   $push1=, $0, $pop0{{$}}
 ; CHECK-NEX T: i32.store g+40($pop1), $1{{$}}
 ; CHECK-NEX T: return{{$}}
 define void @store_test5(i32 %n, i32 %i) {
@@ -418,8 +434,8 @@
 
 ; CHECK-LABEL: store_test6:
 ; CHECK-NEXT: .functype store_test6 (i32, i32) -> (){{$}}
-; CHECK-NEXT: i32.const $push0=, 2{{$}}
-; CHECK-NEXT: i32.shl   $push1=, $0, $pop0{{$}}
+; NON-PIC-NEXT:  i32.const $push0=, 2{{$}}
+; NON-PIC-NEXT:  i32.shl   $push1=, $0, $pop0{{$}}
 ; CHECK-NEX T: i32.store g+40($pop1), $1{{$}}
 ; CHECK-NEX T: return{{$}}
 define void @store_test6(i32 %n, i32 %i) {
@@ -431,8 +447,8 @@
 
 ; CHECK-LABEL: store_test7:
 ; CHECK-NEXT: .functype store_test7 (i32, i32) -> (){{$}}
-; CHECK-NEXT: i32.const $push0=, 2{{$}}
-; CHECK-NEXT: i32.shl   $push1=, $0, $pop0{{$}}
+; NON-PIC-NEXT:  i32.const $push0=, 2{{$}}
+; NON-PIC-NEXT:  i32.shl   $push1=, $0, $pop0{{$}}
 ; CHECK-NEX T: i32.store g+40($pop1), $1{{$}}
 ; CHECK-NEX T: return{{$}}
 define void @store_test7(i32 %n, i32 %i) {
@@ -444,8 +460,8 @@
 
 ; CHECK-LABEL: store_test8:
 ; CHECK-NEXT: .functype store_test8 (i32, i32) -> (){{$}}
-; CHECK-NEXT: i32.const $push0=, 2{{$}}
-; CHECK-NEXT: i32.shl   $push1=, $0, $pop0{{$}}
+; NON-PIC-NEXT:  i32.const $push0=, 2{{$}}
+; NON-PIC-NEXT:  i32.shl   $push1=, $0, $pop0{{$}}
 ; CHECK-NEX T: i32.store g+40($pop1), $1{{$}}
 ; CHECK-NEX T: return{{$}}
 define void @store_test8(i32 %n, i32 %i) {
@@ -457,9 +473,9 @@
 
 ; CHECK-LABEL: store_test9:
 ; CHECK-NEXT: .functype store_test9 (i32) -> (){{$}}
-; CHECK-NEXT: i32.const $push0=, 0{{$}}
-; CHECK-NEXT: i32.store g-40($pop0), $0{{$}}
-; CHECK-NEXT: return{{$}}
+; NON-PIC-NEXT:  i32.const $push0=, 0{{$}}
+; NON-PIC-NEXT:  i32.store g-40($pop0), $0{{$}}
+; NON-PIC-NEXT:  return{{$}}
 define void @store_test9(i32 %i) {
   store i32 %i, i32* getelementptr inbounds ([0 x i32], [0 x i32]* @g, i32 0, i32 1073741814), align 4
   ret void
@@ -467,12 +483,12 @@
 
 ; CHECK-LABEL: store_test10:
 ; CHECK-NEXT: .functype store_test10 (i32, i32) -> (){{$}}
-; CHECK-NEXT: i32.const $push0=, 2{{$}}
-; CHECK-NEXT: i32.shl   $push1=, $0, $pop0{{$}}
-; CHECK-NEXT: i32.const $push2=, g-40{{$}}
-; CHECK-NEXT: i32.add   $push3=, $pop1, $pop2{{$}}
-; CHECK-NEXT: i32.store 0($pop3), $1{{$}}
-; CHECK-NEXT: return{{$}}
+; NON-PIC-NEXT:  i32.const $push0=, 2{{$}}
+; NON-PIC-NEXT:  i32.shl   $push1=, $0, $pop0{{$}}
+; NON-PIC-NEXT:  i32.const $push2=, g-40{{$}}
+; NON-PIC-NEXT:  i32.add   $push3=, $pop1, $pop2{{$}}
+; NON-PIC-NEXT:  i32.store 0($pop3), $1{{$}}
+; NON-PIC-NEXT:  return{{$}}
 define void @store_test10(i32 %n, i32 %i) {
   %add = add nsw i32 %n, -10
   %arrayidx = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %add
@@ -482,8 +498,8 @@
 
 ; CHECK-LABEL: store_test11:
 ; CHECK-NEXT: .functype store_test11 (i32, i32) -> (){{$}}
-; CHECK-NEXT: i32.store 40($0), $1{{$}}
-; CHECK-NEXT: return{{$}}
+; NON-PIC-NEXT:  i32.store 40($0), $1{{$}}
+; NON-PIC-NEXT:  return{{$}}
 define void @store_test11(i32* %p, i32 %i) {
   %arrayidx = getelementptr inbounds i32, i32* %p, i32 10
   store i32 %i, i32* %arrayidx, align 4
@@ -492,10 +508,10 @@
 
 ; CHECK-LABEL: store_test11_noinbounds:
 ; CHECK-NEXT: .functype store_test11_noinbounds (i32, i32) -> (){{$}}
-; CHECK-NEXT: i32.const $push0=, 40{{$}}
-; CHECK-NEXT: i32.add   $push1=, $0, $pop0{{$}}
-; CHECK-NEXT: i32.store 0($pop1), $1{{$}}
-; CHECK-NEXT: return{{$}}
+; NON-PIC-NEXT:  i32.const $push0=, 40{{$}}
+; NON-PIC-NEXT:  i32.add   $push1=, $0, $pop0{{$}}
+; NON-PIC-NEXT:  i32.store 0($pop1), $1{{$}}
+; NON-PIC-NEXT:  return{{$}}
 define void @store_test11_noinbounds(i32* %p, i32 %i) {
   %arrayidx = getelementptr i32, i32* %p, i32 10
   store i32 %i, i32* %arrayidx, align 4
@@ -504,13 +520,13 @@
 
 ; CHECK-LABEL: store_test12:
 ; CHECK-NEXT: .functype store_test12 (i32, i32, i32) -> (){{$}}
-; CHECK-NEXT: i32.const $push0=, 2{{$}}
-; CHECK-NEXT: i32.shl   $push1=, $1, $pop0{{$}}
-; CHECK-NEXT: i32.add   $push2=, $0, $pop1{{$}}
-; CHECK-NEXT: i32.const $push3=, 40{{$}}
-; CHECK-NEXT: i32.add   $push4=, $pop2, $pop3{{$}}
-; CHECK-NEXT: i32.store 0($pop4), $2{{$}}
-; CHECK-NEXT: return{{$}}
+; NON-PIC-NEXT:  i32.const $push0=, 2{{$}}
+; NON-PIC-NEXT:  i32.shl   $push1=, $1, $pop0{{$}}
+; NON-PIC-NEXT:  i32.add   $push2=, $0, $pop1{{$}}
+; NON-PIC-NEXT:  i32.const $push3=, 40{{$}}
+; NON-PIC-NEXT:  i32.add   $push4=, $pop2, $pop3{{$}}
+; NON-PIC-NEXT:  i32.store 0($pop4), $2{{$}}
+; NON-PIC-NEXT:  return{{$}}
 define void @store_test12(i32* %p, i32 %n, i32 %i) {
   %add = add nsw i32 %n, 10
   %arrayidx = getelementptr inbounds i32, i32* %p, i32 %add
@@ -520,13 +536,13 @@
 
 ; CHECK-LABEL: store_test13:
 ; CHECK-NEXT: .functype store_test13 (i32, i32, i32) -> (){{$}}
-; CHECK-NEXT: i32.const $push0=, 2{{$}}
-; CHECK-NEXT: i32.shl   $push1=, $1, $pop0{{$}}
-; CHECK-NEXT: i32.add   $push2=, $0, $pop1{{$}}
-; CHECK-NEXT: i32.const $push3=, 40{{$}}
-; CHECK-NEXT: i32.add   $push4=, $pop2, $pop3{{$}}
-; CHECK-NEXT: i32.store 0($pop4), $2{{$}}
-; CHECK-NEXT: return{{$}}
+; NON-PIC-NEXT:  i32.const $push0=, 2{{$}}
+; NON-PIC-NEXT:  i32.shl   $push1=, $1, $pop0{{$}}
+; NON-PIC-NEXT:  i32.add   $push2=, $0, $pop1{{$}}
+; NON-PIC-NEXT:  i32.const $push3=, 40{{$}}
+; NON-PIC-NEXT:  i32.add   $push4=, $pop2, $pop3{{$}}
+; NON-PIC-NEXT:  i32.store 0($pop4), $2{{$}}
+; NON-PIC-NEXT:  return{{$}}
 define void @store_test13(i32* %p, i32 %n, i32 %i) {
   %add = add nsw i32 10, %n
   %arrayidx = getelementptr inbounds i32, i32* %p, i32 %add
@@ -536,11 +552,11 @@
 
 ; CHECK-LABEL: store_test14:
 ; CHECK-NEXT: .functype store_test14 (i32, i32, i32) -> (){{$}}
-; CHECK-NEXT: i32.const $push0=, 2{{$}}
-; CHECK-NEXT: i32.shl   $push1=, $1, $pop0{{$}}
-; CHECK-NEXT: i32.add   $push2=, $0, $pop1{{$}}
-; CHECK-NEXT: i32.store 40($pop2), $2{{$}}
-; CHECK-NEXT: return{{$}}
+; NON-PIC-NEXT:  i32.const $push0=, 2{{$}}
+; NON-PIC-NEXT:  i32.shl   $push1=, $1, $pop0{{$}}
+; NON-PIC-NEXT:  i32.add   $push2=, $0, $pop1{{$}}
+; NON-PIC-NEXT:  i32.store 40($pop2), $2{{$}}
+; NON-PIC-NEXT:  return{{$}}
 define void @store_test14(i32* %p, i32 %n, i32 %i) {
   %add.ptr = getelementptr inbounds i32, i32* %p, i32 %n
   %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 10
@@ -550,13 +566,13 @@
 
 ; CHECK-LABEL: store_test15:
 ; CHECK-NEXT: .functype store_test15 (i32, i32, i32) -> (){{$}}
-; CHECK-NEXT: i32.const $push0=, 2{{$}}
-; CHECK-NEXT: i32.shl   $push1=, $1, $pop0{{$}}
-; CHECK-NEXT: i32.add   $push2=, $0, $pop1{{$}}
-; CHECK-NEXT: i32.const $push3=, 40{{$}}
-; CHECK-NEXT: i32.add   $push4=, $pop2, $pop3{{$}}
-; CHECK-NEXT: i32.store 0($pop4), $2{{$}}
-; CHECK-NEXT: return{{$}}
+; NON-PIC-NEXT:  i32.const $push0=, 2{{$}}
+; NON-PIC-NEXT:  i32.shl   $push1=, $1, $pop0{{$}}
+; NON-PIC-NEXT:  i32.add   $push2=, $0, $pop1{{$}}
+; NON-PIC-NEXT:  i32.const $push3=, 40{{$}}
+; NON-PIC-NEXT:  i32.add   $push4=, $pop2, $pop3{{$}}
+; NON-PIC-NEXT:  i32.store 0($pop4), $2{{$}}
+; NON-PIC-NEXT:  return{{$}}
 define void @store_test15(i32* %p, i32 %n, i32 %i) {
   %add.ptr = getelementptr inbounds i32, i32* %p, i32 10
   %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 %n
@@ -566,13 +582,13 @@
 
 ; CHECK-LABEL: store_test16:
 ; CHECK-NEXT: .functype store_test16 (i32, i32, i32) -> (){{$}}
-; CHECK-NEXT: i32.const $push0=, 2{{$}}
-; CHECK-NEXT: i32.shl   $push1=, $1, $pop0{{$}}
-; CHECK-NEXT: i32.add   $push2=, $0, $pop1{{$}}
-; CHECK-NEXT: i32.const $push3=, 40{{$}}
-; CHECK-NEXT: i32.add   $push4=, $pop2, $pop3{{$}}
-; CHECK-NEXT: i32.store 0($pop4), $2{{$}}
-; CHECK-NEXT: return{{$}}
+; NON-PIC-NEXT:  i32.const $push0=, 2{{$}}
+; NON-PIC-NEXT:  i32.shl   $push1=, $1, $pop0{{$}}
+; NON-PIC-NEXT:  i32.add   $push2=, $0, $pop1{{$}}
+; NON-PIC-NEXT:  i32.const $push3=, 40{{$}}
+; NON-PIC-NEXT:  i32.add   $push4=, $pop2, $pop3{{$}}
+; NON-PIC-NEXT:  i32.store 0($pop4), $2{{$}}
+; NON-PIC-NEXT:  return{{$}}
 define void @store_test16(i32* %p, i32 %n, i32 %i) {
   %add.ptr = getelementptr inbounds i32, i32* %p, i32 10
   %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 %n
@@ -582,13 +598,13 @@
 
 ; CHECK-LABEL: store_test17:
 ; CHECK-NEXT: .functype store_test17 (i32, i32, i32) -> (){{$}}
-; CHECK-NEXT: i32.const $push0=, 2{{$}}
-; CHECK-NEXT: i32.shl   $push1=, $1, $pop0{{$}}
-; CHECK-NEXT: i32.add   $push2=, $0, $pop1{{$}}
-; CHECK-NEXT: i32.const $push3=, 40{{$}}
-; CHECK-NEXT: i32.add   $push4=, $pop2, $pop3{{$}}
-; CHECK-NEXT: i32.store 0($pop4), $2{{$}}
-; CHECK-NEXT: return{{$}}
+; NON-PIC-NEXT:  i32.const $push0=, 2{{$}}
+; NON-PIC-NEXT:  i32.shl   $push1=, $1, $pop0{{$}}
+; NON-PIC-NEXT:  i32.add   $push2=, $0, $pop1{{$}}
+; NON-PIC-NEXT:  i32.const $push3=, 40{{$}}
+; NON-PIC-NEXT:  i32.add   $push4=, $pop2, $pop3{{$}}
+; NON-PIC-NEXT:  i32.store 0($pop4), $2{{$}}
+; NON-PIC-NEXT:  return{{$}}
 define void @store_test17(i32* %p, i32 %n, i32 %i) {
   %add = add nsw i32 %n, 10
   %add.ptr = getelementptr inbounds i32, i32* %p, i32 %add
@@ -598,11 +614,11 @@
 
 ; CHECK-LABEL: store_test18:
 ; CHECK-NEXT: .functype store_test18 (i32, i32, i32) -> (){{$}}
-; CHECK-NEXT: i32.const $push0=, 2{{$}}
-; CHECK-NEXT: i32.shl   $push1=, $1, $pop0{{$}}
-; CHECK-NEXT: i32.add   $push2=, $0, $pop1{{$}}
-; CHECK-NEXT: i32.store 40($pop2), $2{{$}}
-; CHECK-NEXT: return{{$}}
+; NON-PIC-NEXT:  i32.const $push0=, 2{{$}}
+; NON-PIC-NEXT:  i32.shl   $push1=, $1, $pop0{{$}}
+; NON-PIC-NEXT:  i32.add   $push2=, $0, $pop1{{$}}
+; NON-PIC-NEXT:  i32.store 40($pop2), $2{{$}}
+; NON-PIC-NEXT:  return{{$}}
 define void @store_test18(i32* %p, i32 %n, i32 %i) {
   %add.ptr = getelementptr inbounds i32, i32* %p, i32 %n
   %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 10
@@ -612,13 +628,13 @@
 
 ; CHECK-LABEL: store_test19:
 ; CHECK-NEXT: .functype store_test19 (i32, i32, i32) -> (){{$}}
-; CHECK-NEXT: i32.const $push0=, 2{{$}}
-; CHECK-NEXT: i32.shl   $push1=, $1, $pop0{{$}}
-; CHECK-NEXT: i32.add   $push2=, $0, $pop1{{$}}
-; CHECK-NEXT: i32.const $push3=, 40{{$}}
-; CHECK-NEXT: i32.add   $push4=, $pop2, $pop3{{$}}
-; CHECK-NEXT: i32.store 0($pop4), $2{{$}}
-; CHECK-NEXT: return{{$}}
+; NON-PIC-NEXT:  i32.const $push0=, 2{{$}}
+; NON-PIC-NEXT:  i32.shl   $push1=, $1, $pop0{{$}}
+; NON-PIC-NEXT:  i32.add   $push2=, $0, $pop1{{$}}
+; NON-PIC-NEXT:  i32.const $push3=, 40{{$}}
+; NON-PIC-NEXT:  i32.add   $push4=, $pop2, $pop3{{$}}
+; NON-PIC-NEXT:  i32.store 0($pop4), $2{{$}}
+; NON-PIC-NEXT:  return{{$}}
 define void @store_test19(i32* %p, i32 %n, i32 %i) {
   %add = add nsw i32 10, %n
   %add.ptr = getelementptr inbounds i32, i32* %p, i32 %add
@@ -628,10 +644,10 @@
 
 ; CHECK-LABEL: store_test20:
 ; CHECK-NEXT: .functype store_test20 (i32, i32) -> (){{$}}
-; CHECK-NEXT: i32.const $push0=, -40{{$}}
-; CHECK-NEXT: i32.add   $push1=, $0, $pop0{{$}}
-; CHECK-NEXT: i32.store 0($pop1), $1{{$}}
-; CHECK-NEXT: return{{$}}
+; NON-PIC-NEXT:  i32.const $push0=, -40{{$}}
+; NON-PIC-NEXT:  i32.add   $push1=, $0, $pop0{{$}}
+; NON-PIC-NEXT:  i32.store 0($pop1), $1{{$}}
+; NON-PIC-NEXT:  return{{$}}
 define void @store_test20(i32* %p, i32 %i) {
   %arrayidx = getelementptr inbounds i32, i32* %p, i32 -10
   store i32 %i, i32* %arrayidx, align 4
@@ -640,13 +656,13 @@
 
 ; CHECK-LABEL: store_test21:
 ; CHECK-NEXT: .functype store_test21 (i32, i32, i32) -> (){{$}}
-; CHECK-NEXT: i32.const $push0=, 2{{$}}
-; CHECK-NEXT: i32.shl   $push1=, $1, $pop0{{$}}
-; CHECK-NEXT: i32.add   $push2=, $0, $pop1{{$}}
-; CHECK-NEXT: i32.const $push3=, -40{{$}}
-; CHECK-NEXT: i32.add   $push4=, $pop2, $pop3{{$}}
-; CHECK-NEXT: i32.store 0($pop4), $2{{$}}
-; CHECK-NEXT: return{{$}}
+; NON-PIC-NEXT:  i32.const $push0=, 2{{$}}
+; NON-PIC-NEXT:  i32.shl   $push1=, $1, $pop0{{$}}
+; NON-PIC-NEXT:  i32.add   $push2=, $0, $pop1{{$}}
+; NON-PIC-NEXT:  i32.const $push3=, -40{{$}}
+; NON-PIC-NEXT:  i32.add   $push4=, $pop2, $pop3{{$}}
+; NON-PIC-NEXT:  i32.store 0($pop4), $2{{$}}
+; NON-PIC-NEXT:  return{{$}}
 define void @store_test21(i32* %p, i32 %n, i32 %i) {
   %add = add nsw i32 %n, -10
   %arrayidx = getelementptr inbounds i32, i32* %p, i32 %add
diff --git a/llvm/test/CodeGen/WebAssembly/load-store-pic.ll b/llvm/test/CodeGen/WebAssembly/load-store-pic.ll
new file mode 100644
--- /dev/null
+++ b/llvm/test/CodeGen/WebAssembly/load-store-pic.ll
@@ -0,0 +1,153 @@
+; RUN: llc < %s -asm-verbose=false -wasm-disable-explicit-locals -wasm-keep-registers | FileCheck %s -check-prefixes=NON-PIC,CHECK
+; RUN: llc < %s -asm-verbose=false -relocation-model=pic -fast-isel -wasm-disable-explicit-locals -wasm-keep-registers | FileCheck %s -check-prefixes=PIC,CHECK
+; RUN: llc < %s -asm-verbose=false -relocation-model=pic -fast-isel=false -wasm-disable-explicit-locals -wasm-keep-registers | FileCheck %s -check-prefixes=PIC,CHECK
+
+; Test that globals assemble as expected with -fPIC.
+; We test here both with and without fast-isel.
+
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-unknown"
+
+@hidden_global         = external hidden global i32
+@hidden_global_array   = external hidden global [10 x i32]
+@external_global       = external        global i32
+@external_global_array = external        global [10 x i32]
+
+declare i32 @foo();
+
+; For hidden symbols PIC code needs to offset all loads and stores
+; by the value of the __memory_base global
+
+define i32 @load_hidden_global() {
+; CHECK-LABEL: load_hidden_global:
+; PIC:         global.get $push[[L0:[0-9]+]]=, __memory_base{{$}}
+; PIC-NEXT:    i32.const $push[[L1:[0-9]+]]=, hidden_global{{$}}
+; PIC-NEXT:    i32.add $push[[L2:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
+; PIC-NEXT:    i32.load $push[[L3:[0-9]+]]=, 0($pop[[L2]]){{$}}
+
+; NON-PIC:         i32.const $push0=, 0{{$}}
+; NON-PIC-NEXT:    i32.load $push1=, hidden_global($pop0){{$}}
+; CHECK-NEXT:    end_function
+
+  %1 = load i32, i32* @hidden_global
+  ret i32 %1
+}
+
+define i32 @load_hidden_global_offset() {
+; CHECK-LABEL: load_hidden_global_offset:
+; PIC:         global.get $push[[L0:[0-9]+]]=, __memory_base{{$}}
+; PIC-NEXT:    i32.const $push[[L1:[0-9]+]]=, hidden_global_array{{$}}
+; PIC-NEXT:    i32.add $push[[L2:[0-9]+]]=, $pop[[L0]], $pop[[L1:[0-9]+]]{{$}}
+; PIC-NEXT:    i32.const $push[[L3:[0-9]+]]=, 20{{$}}
+; PIC-NEXT:    i32.add $push[[L4:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}}
+; PIC-NEXT:    i32.load $push{{[0-9]+}}=, 0($pop[[L4]]){{$}}
+
+; NON-PIC:     i32.const $push0=, 0{{$}}
+; NON-PIC-NEXT:i32.load  $push1=, hidden_global_array+20($pop0){{$}}
+; CHECK-NEXT:  end_function
+
+  %1 = getelementptr [10 x i32], [10 x i32]* @hidden_global_array, i32 0, i32 5
+  %2 = load i32, i32* %1
+  ret i32 %2
+}
+
+; Store to a hidden global
+
+define void @store_hidden_global(i32 %n) {
+; CHECK-LABEL: store_hidden_global:
+; PIC:         global.get $push[[L0:[0-9]+]]=, __memory_base{{$}}
+; PIC-NEXT:    i32.const $push[[L1:[0-9]+]]=, hidden_global{{$}}
+; PIC-NEXT:    i32.add $push[[L2:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
+; PIC-NEXT:    i32.store 0($pop[[L2]]), $0{{$}}
+
+; NON-PIC:       i32.const $push0=, 0{{$}}
+; NON-PIC-NEXT:  i32.store hidden_global($pop0), $0{{$}}
+; CHECK-NEXT:    end_function
+
+  store i32 %n, i32* @hidden_global
+  ret void
+}
+
+define void @store_hidden_global_offset(i32 %n) {
+; CHECK-LABEL: store_hidden_global_offset:
+; PIC:         global.get $push[[L0:[0-9]+]]=, __memory_base{{$}}
+; PIC-NEXT:    i32.const $push[[L1:[0-9]+]]=, hidden_global_array{{$}}
+; PIC-NEXT:    i32.add $push[[L2:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
+; PIC-NEXT:    i32.const $push[[L3:[0-9]+]]=, 20{{$}}
+; PIC-NEXT:    i32.add $push[[L4:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}}
+; PIC-NEXT:    i32.store 0($pop[[L4]]), $0{{$}}
+
+; NON-PIC:      i32.const $push0=, 0{{$}}
+; NON-PIC-NEXT: i32.store hidden_global_array+20($pop0), $0{{$}}
+; CHECK-NEXT:   end_function
+
+  %1 = getelementptr [10 x i32], [10 x i32]* @hidden_global_array, i32 0, i32 5
+  store i32 %n, i32* %1
+  ret void
+}
+
+; For non-hidden globals PIC code has to load the address from a wasm global
+; using the @GOT relocation type.
+
+
+define i32 @load_external_global() {
+; CHECK-LABEL:  load_external_global:
+; PIC:          global.get $push0=, external_global@GOT{{$}}
+; PIC-NEXT:     i32.load $push1=, 0($pop0){{$}}
+
+; NON-PIC:      i32.const $push0=, 0{{$}}
+; NON-PIC-NEXT: i32.load $push1=, external_global($pop0){{$}}
+; CHECK-NEXT:   end_function
+
+  %1 = load i32, i32* @external_global
+  ret i32 %1
+}
+
+define i32 @load_external_global_offset() {
+; CHECK-LABEL:  load_external_global_offset:
+; PIC:          global.get $push[[L0:[0-9]+]]=, external_global_array@GOT{{$}}
+; PIC-NEXT:     i32.const $push[[L1:[0-9]+]]=, 20{{$}}
+; PIC-NEXT:     i32.add $push[[L2:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
+; PIC-NEXT:     i32.load $push{{[0-9]+}}=, 0($pop[[L2]]){{$}}
+
+; NON-PIC:      i32.const $push0=, 0{{$}}
+; NON-PIC-NEXT: i32.load $push1=, external_global_array+20($pop0){{$}}
+; CHECK-NEXT:   end_function
+
+  %1 = getelementptr [10 x i32], [10 x i32]* @external_global_array, i32 0, i32 5
+  %2 = load i32, i32* %1
+  ret i32 %2
+}
+
+; Store to a non-hidden global via the wasm global.
+
+define void @store_external_global(i32 %n) {
+; CHECK-LABEL:  store_external_global:
+; PIC:          global.get $push[[L0:[0-9]+]]=, external_global@GOT{{$}}
+; PIC-NEXT:     i32.store 0($pop[[L0]]), $0{{$}}
+
+; NON-PIC:      i32.const $push0=, 0{{$}}
+; NON-PIC-NEXT: i32.store external_global($pop0), $0{{$}}
+; CHECK-NEXT:   end_function
+
+  store i32 %n, i32* @external_global
+  ret void
+}
+
+define void @store_external_global_offset(i32 %n) {
+; CHECK-LABEL:  store_external_global_offset:
+; PIC:          global.get $push[[L0:[0-9]+]]=, external_global_array@GOT{{$}}
+; PIC-NEXT:     i32.const $push[[L1:[0-9]+]]=, 20{{$}}
+; PIC-NEXT:     i32.add $push[[L2:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
+; PIC-NEXT:     i32.store 0($pop[[L2]]), $0{{$}}
+
+; NON-PIC:      i32.const $push0=, 0{{$}}
+; NON-PIC-NEXT: i32.store external_global_array+20($pop0), $0{{$}}
+; CHECK-NEXT:   end_function
+
+  %1 = getelementptr [10 x i32], [10 x i32]* @external_global_array, i32 0, i32 5
+  store i32 %n, i32* %1
+  ret void
+}
+
+; PIC: .globaltype __memory_base, i32
diff --git a/llvm/test/MC/WebAssembly/reloc-pic.s b/llvm/test/MC/WebAssembly/reloc-pic.s
new file mode 100644
--- /dev/null
+++ b/llvm/test/MC/WebAssembly/reloc-pic.s
@@ -0,0 +1,67 @@
+# RUN: llvm-mc -triple=wasm32-unknown-unknown -filetype=obj < %s | obj2yaml | FileCheck %s
+
+# Verify that @GOT relocation entryes result in R_WASM_GLOBAL_INDEX_LEB against
+# a data symbol and that the corresponding data symbol is imported as a wasm
+# global.
+
+load_default_global:
+    .functype   load_default_global () -> (i32)
+    global.get  default_global@GOT
+    i32.load    0
+    end_function
+
+.size default_global, 4
+
+# CHECK:      --- !WASM
+# CHECK-NEXT: FileHeader:
+# CHECK-NEXT:   Version:         0x00000001
+# CHECK-NEXT: Sections:
+# CHECK-NEXT:   - Type:            TYPE
+# CHECK-NEXT:     Signatures:
+# CHECK-NEXT:       - Index:           0
+# CHECK-NEXT:         ReturnType:      I32
+# CHECK-NEXT:         ParamTypes:      []
+# CHECK-NEXT:   - Type:            IMPORT
+# CHECK-NEXT:     Imports:
+# CHECK-NEXT:       - Module:          env
+# CHECK-NEXT:         Field:           __linear_memory
+# CHECK-NEXT:         Kind:            MEMORY
+# CHECK-NEXT:         Memory:
+# CHECK-NEXT:           Initial:         0x00000000
+# CHECK-NEXT:       - Module:          env
+# CHECK-NEXT:         Field:           __indirect_function_table
+# CHECK-NEXT:         Kind:            TABLE
+# CHECK-NEXT:         Table:
+# CHECK-NEXT:           ElemType:        FUNCREF
+# CHECK-NEXT:           Limits:
+# CHECK-NEXT:             Initial:         0x00000000
+# CHECK-NEXT:       - Module:          env
+# CHECK-NEXT:         Field:           default_global
+# CHECK-NEXT:         Kind:            GLOBAL
+# CHECK-NEXT:         GlobalType:      I32
+# CHECK-NEXT:         GlobalMutable:   true
+# CHECK-NEXT:   - Type:            FUNCTION
+# CHECK-NEXT:     FunctionTypes:   [ 0 ]
+# CHECK-NEXT:   - Type:            CODE
+# CHECK-NEXT:     Relocations:
+# CHECK-NEXT:       - Type:            R_WASM_GLOBAL_INDEX_LEB
+# CHECK-NEXT:         Index:           1
+# CHECK-NEXT:         Offset:          0x00000004
+# CHECK-NEXT:     Functions:
+# CHECK-NEXT:       - Index:           0
+# CHECK-NEXT:         Locals:          []
+# CHECK-NEXT:         Body:            2380808080002800000B
+# CHECK-NEXT:   - Type:            CUSTOM
+# CHECK-NEXT:     Name:            linking
+# CHECK-NEXT:     Version:         2
+# CHECK-NEXT:     SymbolTable:
+# CHECK-NEXT:       - Index:           0
+# CHECK-NEXT:         Kind:            FUNCTION
+# CHECK-NEXT:         Name:            load_default_global
+# CHECK-NEXT:         Flags:           [ BINDING_LOCAL ]
+# CHECK-NEXT:         Function:        0
+# CHECK-NEXT:       - Index:           1
+# CHECK-NEXT:         Kind:            DATA
+# CHECK-NEXT:         Name:            default_global
+# CHECK-NEXT:         Flags:           [ UNDEFINED ]
+# CHECK-NEXT: ...