[WebAssembly] Adding 64-bit version of R_WASM_MEMORY_ADDR_* relocs

[aardappel]

Summary

This adds 4 new reloc types.

A lot of code that previously assumed any memory or offset values could be contained in a uint32_t (and often truncated results from functions returning 64-bit values) have been upgraded to uint64_t. This is not comprehensive: it is only the values that come in contact with the new relocation values and their dependents.

A new tablegen mapping was added to automatically upgrade loads/stores in the assembler, which otherwise has no way to select for these instructions (since they are indentical other than for the offset immediate).

[sbc100]

I don't really grok the tablegen stuff but everything else looks pretty good to me!

lld/wasm/Driver.cpp

502

This seems odd.

I wonder if this function should at least take an in32_t?

lld/wasm/InputChunks.cpp

89

I don't think I'm ready for these kind of autos just yet. I'd rather see what type it is.

117

ditto

lld/wasm/InputFiles.cpp

141

oops?

429

ditto

llvm/include/llvm/BinaryFormat/Wasm.h

79

How about calling this something else? Maybe ConstVal? Or just Int?

The fact that you have left all the other ones makes me less attracted to this part of the change. What would it looks like to instead leave this member of the union and instead check all accesses to ensure they match the Opcode?

llvm/lib/Object/RelocationResolver.cpp

498

But we don't support 64 bit relocs o wasm32 and vice versa, right? I mean I don't think we should.

llvm/lib/Object/WasmObjectFile.cpp

170

Removing this seems wrong.. we don't to support wider const values with this opcode.

568

ditto re: auto

1254

Again it doesn't sit right to assign to the Int64 member for I32_CONST opcode.

1352

ditto.

llvm/lib/ObjectYAML/WasmYAML.cpp

423

Maybe would make more sense if the union member had a different name.. but I'm leaning towards restoring the different members.

llvm/lib/Target/WebAssembly/AsmParser/WebAssemblyAsmParser.cpp

854

Does the triple have something like is64() that might make this shorter? Or isWasm64?

[aardappel]

lld/wasm/Driver.cpp

502

As I mentioned below, I have tried instead your approach of explicitly checking the opcode. I hope I have caught them all. Please review :)

lld/wasm/InputChunks.cpp

89

The reason I replaced these with auto is we had a bunch of spots where we had unnecessary truncation because of a uint32_t var = exp that results in a 64-bit value. Using auto avoids these problems, now, and with future changes.

lld/wasm/InputFiles.cpp

141

how did I miss that..

llvm/include/llvm/BinaryFormat/Wasm.h

79

Ok, as you wish. This added a bunch of new if-thens to the code, please have a look if they are correct. Also see the TODO(wvo).

llvm/lib/Object/RelocationResolver.cpp

498

ok, I'll make 2 of these functions instead.

llvm/lib/Target/WebAssembly/AsmParser/WebAssemblyAsmParser.cpp

854

Using isArch64Bit now.

[aardappel]

Changed init expr to use all union types, and added code to check for opcode.
Other misc code review.
Fixed linker error due to tablegen adding both generated functions to same #ifdef :(
clang-format

[sbc100]

Nice! lgtm % the extra used of auto.

I'm not sure how strictly to apply the rules here: https://llvm.org/docs/CodingStandards.html#use-auto-type-deduction-to-make-code-more-readable. But I feel like they confirm my hunch these are overuses. I'm not sure though. and I don't personally care too much either way. @dschuff what do you think about these uses of auto in this PR?

lld/wasm/SyntheticSections.cpp

290

I think the answer is "for functions symbols never and for data symbols alwasys".

GOT symbols represent offsets into either the table or the memory.

Happy to leave this as followup (PIC output is limited to emscripten today anyway and is likely to change in the official ABI).

[aardappel]

as for auto, indeed its says "Use auto if and only if it makes the code more readable or easier to maintain". That was exactly my point when I mentioned "The reason I replaced these with auto is we had a bunch of spots where we had unnecessary truncation because of a uint32_t var = exp that results in a 64-bit value. Using auto avoids these problems, now, and with future changes."

[sbc100]

I'm worried that if one interprets the "easier to maintain" argument too broadly then we end up with the "“almost always auto” situation that the guidelines specifically want to avoid.

Some argue that its good to use auto everywhere that you store the return value of another function since then you can then change the return type of an function without having the change all the callsites. I think that argument is one that llvm doesn't currently accept.

Am I misinterpreting the llvm guidelines? Do you think that auto var = SomeFunction() should generally be preferred based on your reading of the guide? Or maybe you only thinking about function that return types that have builtin lossy coercions?

[aardappel]

@sbc100 Like I said, I think these silent truncations by using explicit types are a maintenance problem which the guidelines mention.

But it sounds like we're not going to agree on the use of auto here.. since you're working with this code more often than me, I'd be happy to change them to int64_t etc if you prefer that.

[dschuff]

llvm/lib/Target/WebAssembly/WebAssemblyInstrMemory.td

233–234

I guess this bit is just a holdover from the previous CL?

[aardappel]

llvm/lib/Target/WebAssembly/WebAssemblyInstrMemory.td

233–234

Yes, I need to rebase this on the other CL once merged.

[aheejin]

(Phabricator tip: You can set parent / child revisions, which can be useful in case multiple CLs are in flight and have not been landed yet :) Probably you already know that, but anyway just in case)

[jhenderson]

In D81704#2091425, @aheejin wrote:

(Phabricator tip: You can set parent / child revisions, which can be useful in case multiple CLs are in flight and have not been landed yet :) Probably you already know that, but anyway just in case)

Better yet, Phabricator will do it for you, if you say something like "Depends on DXXXXX"!

[aardappel]

Thanks for the tips. Though frankly in this case I should have tried to make this commit independent, since significant changes in the other one made rebasing a mess.

[aardappel]

Rebased against previous commit

[aardappel]

Made dedicated supportsWasm64/resolveWasm64 rather than sharing the Wasm32 versions.

[thakis]

llvm/lib/Target/WebAssembly/TargetInfo/WebAssemblyTargetInfo.cpp

40 ↗

(On Diff #270790)

This is a bit awkward. It makes WebAssembly the only target that has its TargetInfo dir depend on a llvm-tblgen generated file. It doesn't cause actual issues, but it's irregular.

Make of this what you will :)

[aardappel]

llvm/lib/Target/WebAssembly/TargetInfo/WebAssemblyTargetInfo.cpp

40 ↗

(On Diff #270790)

I'd be happy to move this something else.. we just don't have any other .cpp that is shared between CodeGen and MC. I could add a new lib that both depend on? @dschuff

[aardappel]

llvm/lib/Target/WebAssembly/TargetInfo/WebAssemblyTargetInfo.cpp

40 ↗

(On Diff #270790)

Actually, the cleaner solution would be to have tablegen (or whatever creates the instruction mappings) not stick both generated functions in the same #ifdef, which is the root cause of this having to sit in a shared location in the first place. Or make the functions static. But that potentially affects other targets, etc.

[thakis]

llvm/lib/Target/WebAssembly/TargetInfo/WebAssemblyTargetInfo.cpp

40 ↗

(On Diff #270790)

This came back to bite me today (or, well, actually, a few weeks ago, but I didn't notice until today): In the GN build (which isn't supported and which you don't have to care about; it's just FYI, nothing to act on), the .inc files get generated in the Target sub directory they best fit into. Due to this change, I had moved WebAssemblyGenInstrInfo.inc from WebAssembly/MCTargetDesc to WebAssembly/TargetInfo. I didn't realize that this had the effect that I now had a correct WebAssemblyGenInstrInfo.inc and a stale WebAssemblyGenInstrInfo.inc in different directories in build dirs on the bots, and they happened to pick up the stale one. Since the .inc include is unqualified, a wasm .td change today broke my bots. The hack fix was to delete the stale .inc file.

The cmake build puts all target llvm-tblgen output in lib/Target/$targetname so it's not a problem there (the GN build should do that too), but I thought it's a nice example of how "this looks a bit funny" turned into an actual problem down the road.

Again, nothing for you to do here :)

[aardappel]

llvm/lib/Target/WebAssembly/TargetInfo/WebAssemblyTargetInfo.cpp

40 ↗

(On Diff #270790)

Sorry about that.. I wouldn't mind fixing this, question is what is the best fix? Do you know of a way to have tablegen generate one file per instruction mapping?

lld/wasm/Driver.cpp

createUndefinedGlobal(StringRef name, llvm::wasm::WasmGlobalType *type) {
   sym->isUsedInRegularObj = true;
   return sym;
 }
 
 static GlobalSymbol *createGlobalVariable(StringRef name, bool isMutable,
                                           int value) {
   llvm::wasm::WasmGlobal wasmGlobal;
   wasmGlobal.Type = {WASM_TYPE_I32, isMutable};
-  wasmGlobal.InitExpr.Value.Int32 = value;
+  wasmGlobal.InitExpr.Value.Int64 = value;
   wasmGlobal.InitExpr.Opcode = WASM_OPCODE_I32_CONST;
   wasmGlobal.SymbolName = name;
   return symtab->addSyntheticGlobal(name, WASM_SYMBOL_VISIBILITY_HIDDEN,
                                     make<InputGlobal>(wasmGlobal, nullptr));
 }
 
 // Create ABI-defined synthetic symbols
 static void createSyntheticSymbols() {

lld/wasm/InputChunks.cpp

StringRef InputChunk::getComdatName() const {
   uint32_t index = getComdat();
   if (index == UINT32_MAX)
     return StringRef();
   return file->getWasmObj()->linkingData().Comdats[index];
 }
 
 void InputChunk::verifyRelocTargets() const {
   for (const WasmRelocation &rel : relocations) {
-    uint32_t existingValue;
+    uint64_t existingValue;
     unsigned bytesRead = 0;
-    uint32_t offset = rel.Offset - getInputSectionOffset();
+    auto offset = rel.Offset - getInputSectionOffset();
     const uint8_t *loc = data().data() + offset;
     switch (rel.Type) {
     case R_WASM_TYPE_INDEX_LEB:
     case R_WASM_FUNCTION_INDEX_LEB:
     case R_WASM_GLOBAL_INDEX_LEB:
     case R_WASM_EVENT_INDEX_LEB:
     case R_WASM_MEMORY_ADDR_LEB:
+    case R_WASM_MEMORY_ADDR_LEB64:
       existingValue = decodeULEB128(loc, &bytesRead);
       break;
     case R_WASM_TABLE_INDEX_SLEB:
     case R_WASM_TABLE_INDEX_REL_SLEB:
     case R_WASM_MEMORY_ADDR_SLEB:
+    case R_WASM_MEMORY_ADDR_SLEB64:
     case R_WASM_MEMORY_ADDR_REL_SLEB:
-      existingValue = static_cast<uint32_t>(decodeSLEB128(loc, &bytesRead));
+    case R_WASM_MEMORY_ADDR_REL_SLEB64:
+      existingValue = static_cast<uint64_t>(decodeSLEB128(loc, &bytesRead));
       break;
     case R_WASM_TABLE_INDEX_I32:
     case R_WASM_MEMORY_ADDR_I32:
     case R_WASM_FUNCTION_OFFSET_I32:
     case R_WASM_SECTION_OFFSET_I32:
     case R_WASM_GLOBAL_INDEX_I32:
-      existingValue = static_cast<uint32_t>(read32le(loc));
+      existingValue = read32le(loc);
+      break;
+    case R_WASM_MEMORY_ADDR_I64:
+      existingValue = read64le(loc);
       break;
     default:
       llvm_unreachable("unknown relocation type");
     }
 
     if (bytesRead && bytesRead != 5)
       warn("expected LEB at relocation site be 5-byte padded");
 
     if (rel.Type != R_WASM_GLOBAL_INDEX_LEB &&
         rel.Type != R_WASM_GLOBAL_INDEX_I32) {
-      uint32_t expectedValue = file->calcExpectedValue(rel);
+      auto expectedValue = file->calcExpectedValue(rel);
       if (expectedValue != existingValue)
         warn("unexpected existing value for " + relocTypeToString(rel.Type) +
              ": existing=" + Twine(existingValue) +
              " expected=" + Twine(expectedValue));
     }
   }
 }
 

 #endif
 
   LLVM_DEBUG(dbgs() << "applying relocations: " << toString(this)
                     << " count=" << relocations.size() << "\n");
   int32_t off = outputOffset - getInputSectionOffset();
 
   for (const WasmRelocation &rel : relocations) {
     uint8_t *loc = buf + rel.Offset + off;
-    uint32_t value = file->calcNewValue(rel);
+    auto value = file->calcNewValue(rel);
     LLVM_DEBUG(dbgs() << "apply reloc: type=" << relocTypeToString(rel.Type));
     if (rel.Type != R_WASM_TYPE_INDEX_LEB)
       LLVM_DEBUG(dbgs() << " sym=" << file->getSymbols()[rel.Index]->getName());
     LLVM_DEBUG(dbgs() << " addend=" << rel.Addend << " index=" << rel.Index
                       << " value=" << value << " offset=" << rel.Offset
                       << "\n");
 
     switch (rel.Type) {
     case R_WASM_TYPE_INDEX_LEB:
     case R_WASM_FUNCTION_INDEX_LEB:
     case R_WASM_GLOBAL_INDEX_LEB:
     case R_WASM_EVENT_INDEX_LEB:
     case R_WASM_MEMORY_ADDR_LEB:
       encodeULEB128(value, loc, 5);
       break;
+    case R_WASM_MEMORY_ADDR_LEB64:
+      encodeULEB128(value, loc, 10);
+      break;
     case R_WASM_TABLE_INDEX_SLEB:
     case R_WASM_TABLE_INDEX_REL_SLEB:
     case R_WASM_MEMORY_ADDR_SLEB:
     case R_WASM_MEMORY_ADDR_REL_SLEB:
       encodeSLEB128(static_cast<int32_t>(value), loc, 5);
       break;
+    case R_WASM_MEMORY_ADDR_SLEB64:
+    case R_WASM_MEMORY_ADDR_REL_SLEB64:
+      encodeSLEB128(static_cast<int64_t>(value), loc, 10);
+      break;
     case R_WASM_TABLE_INDEX_I32:
     case R_WASM_MEMORY_ADDR_I32:
     case R_WASM_FUNCTION_OFFSET_I32:
     case R_WASM_SECTION_OFFSET_I32:
     case R_WASM_GLOBAL_INDEX_I32:
       write32le(loc, value);
       break;
+    case R_WASM_MEMORY_ADDR_I64:
+      write64le(loc, value);
+      break;
     default:
       llvm_unreachable("unknown relocation type");
     }
   }
 }
 
 // Copy relocation entries to a given output stream.
 // This function is used only when a user passes "-r". For a regular link,
LLVM_DEBUG(dbgs() << "InputFunction::setTableIndex: " << getName() << " -> "
                     << index << "\n");
   assert(!hasTableIndex());
   tableIndex = index;
 }
 
 // Write a relocation value without padding and return the number of bytes
 // witten.
 static unsigned writeCompressedReloc(uint8_t *buf, const WasmRelocation &rel,
-                                     uint32_t value) {
+                                     uint64_t value) {
   switch (rel.Type) {
   case R_WASM_TYPE_INDEX_LEB:
   case R_WASM_FUNCTION_INDEX_LEB:
   case R_WASM_GLOBAL_INDEX_LEB:
   case R_WASM_EVENT_INDEX_LEB:
   case R_WASM_MEMORY_ADDR_LEB:
+  case R_WASM_MEMORY_ADDR_LEB64:
     return encodeULEB128(value, buf);
   case R_WASM_TABLE_INDEX_SLEB:
   case R_WASM_MEMORY_ADDR_SLEB:
-    return encodeSLEB128(static_cast<int32_t>(value), buf);
+  case R_WASM_MEMORY_ADDR_SLEB64:
+    return encodeSLEB128(static_cast<int64_t>(value), buf);
   default:
     llvm_unreachable("unexpected relocation type");
   }
 }
 
 static unsigned getRelocWidthPadded(const WasmRelocation &rel) {
   switch (rel.Type) {
   case R_WASM_TYPE_INDEX_LEB:
   case R_WASM_FUNCTION_INDEX_LEB:
   case R_WASM_GLOBAL_INDEX_LEB:
   case R_WASM_EVENT_INDEX_LEB:
   case R_WASM_MEMORY_ADDR_LEB:
   case R_WASM_TABLE_INDEX_SLEB:
   case R_WASM_MEMORY_ADDR_SLEB:
     return 5;
+  case R_WASM_MEMORY_ADDR_LEB64:
+  case R_WASM_MEMORY_ADDR_SLEB64:
+    return 10;
   default:
     llvm_unreachable("unexpected relocation type");
   }
 }
 
-static unsigned getRelocWidth(const WasmRelocation &rel, uint32_t value) {
-  uint8_t buf[5];
+static unsigned getRelocWidth(const WasmRelocation &rel, uint64_t value) {
+  uint8_t buf[10];
   return writeCompressedReloc(buf, rel, value);
 }
 
 // Relocations of type LEB and SLEB in the code section are padded to 5 bytes
 // so that a fast linker can blindly overwrite them without needing to worry
 // about the number of bytes needed to encode the values.
 // However, for optimal output the code section can be compressed to remove
 // the padding then outputting non-relocatable files.

lld/wasm/InputFiles.h

public:
   void parse(bool ignoreComdats = false);
 
   // Returns the underlying wasm file.
   const WasmObjectFile *getWasmObj() const { return wasmObj.get(); }
 
   void dumpInfo() const;
 
   uint32_t calcNewIndex(const WasmRelocation &reloc) const;
-  uint32_t calcNewValue(const WasmRelocation &reloc) const;
-  uint32_t calcNewAddend(const WasmRelocation &reloc) const;
-  uint32_t calcExpectedValue(const WasmRelocation &reloc) const;
+  uint64_t calcNewValue(const WasmRelocation &reloc) const;
+  uint64_t calcNewAddend(const WasmRelocation &reloc) const;
+  uint64_t calcExpectedValue(const WasmRelocation &reloc) const;
   Symbol *getSymbol(const WasmRelocation &reloc) const {
     return symbols[reloc.Index];
   };
 
   const WasmSection *codeSection = nullptr;
   const WasmSection *dataSection = nullptr;
 
   // Maps input type indices to output type indices

lld/wasm/InputFiles.cpp

uint32_t ObjFile::calcNewIndex(const WasmRelocation &reloc) const {
   const Symbol *sym = symbols[reloc.Index];
   if (auto *ss = dyn_cast<SectionSymbol>(sym))
     sym = ss->getOutputSectionSymbol();
   return sym->getOutputSymbolIndex();
 }
 
 // Relocations can contain addend for combined sections. This function takes a
 // relocation and returns updated addend by offset in the output section.
-uint32_t ObjFile::calcNewAddend(const WasmRelocation &reloc) const {
+uint64_t ObjFile::calcNewAddend(const WasmRelocation &reloc) const {
   switch (reloc.Type) {
   case R_WASM_MEMORY_ADDR_LEB:
+  case R_WASM_MEMORY_ADDR_LEB64:
+  case R_WASM_MEMORY_ADDR_SLEB64:
   case R_WASM_MEMORY_ADDR_SLEB:
   case R_WASM_MEMORY_ADDR_REL_SLEB:
+  case R_WASM_MEMORY_ADDR_REL_SLEB64:
   case R_WASM_MEMORY_ADDR_I32:
+  case R_WASM_MEMORY_ADDR_I64:
   case R_WASM_FUNCTION_OFFSET_I32:
     return reloc.Addend;
   case R_WASM_SECTION_OFFSET_I32:
     return getSectionSymbol(reloc.Index)->section->outputOffset + reloc.Addend;
   default:
     llvm_unreachable("unexpected relocation type");
   }
 }
 
 // Calculate the value we expect to find at the relocation location.
 // This is used as a sanity check before applying a relocation to a given
 // location.  It is useful for catching bugs in the compiler and linker.
-uint32_t ObjFile::calcExpectedValue(const WasmRelocation &reloc) const {
+uint64_t ObjFile::calcExpectedValue(const WasmRelocation &reloc) const {
   switch (reloc.Type) {
   case R_WASM_TABLE_INDEX_I32:
   case R_WASM_TABLE_INDEX_SLEB: {
     const WasmSymbol &sym = wasmObj->syms()[reloc.Index];
     return tableEntries[sym.Info.ElementIndex];
   }
+<<<<<<< HEAD
   case R_WASM_TABLE_INDEX_REL_SLEB: {
     const WasmSymbol &sym = wasmObj->syms()[reloc.Index];
     return tableEntriesRel[sym.Info.ElementIndex];
   }
+=======
+  case R_WASM_MEMORY_ADDR_LEB:
+  case R_WASM_MEMORY_ADDR_LEB64:
+>>>>>>> [WebAssembly] Adding 64-bit version of R_WASM_MEMORY_ADDR_* relocs
   case R_WASM_MEMORY_ADDR_SLEB:
+  case R_WASM_MEMORY_ADDR_SLEB64:
+  case R_WASM_MEMORY_ADDR_REL_SLEB:
+  case R_WASM_MEMORY_ADDR_REL_SLEB64:
   case R_WASM_MEMORY_ADDR_I32:
-  case R_WASM_MEMORY_ADDR_LEB:
-  case R_WASM_MEMORY_ADDR_REL_SLEB: {
+  case R_WASM_MEMORY_ADDR_I64: {
     const WasmSymbol &sym = wasmObj->syms()[reloc.Index];
     if (sym.isUndefined())
       return 0;
     const WasmSegment &segment =
         wasmObj->dataSegments()[sym.Info.DataRef.Segment];
-    return segment.Data.Offset.Value.Int32 + sym.Info.DataRef.Offset +
+    return segment.Data.Offset.Value.Int64 + sym.Info.DataRef.Offset +
            reloc.Addend;
   }
   case R_WASM_FUNCTION_OFFSET_I32: {
     const WasmSymbol &sym = wasmObj->syms()[reloc.Index];
     InputFunction *f =
         functions[sym.Info.ElementIndex - wasmObj->getNumImportedFunctions()];
     return f->getFunctionInputOffset() + f->getFunctionCodeOffset() +
            reloc.Addend;
case R_WASM_EVENT_INDEX_LEB: {
     return sym.Info.ElementIndex;
   }
   default:
     llvm_unreachable("unknown relocation type");
   }
 }
 
 // Translate from the relocation's index into the final linked output value.
-uint32_t ObjFile::calcNewValue(const WasmRelocation &reloc) const {
+uint64_t ObjFile::calcNewValue(const WasmRelocation &reloc) const {
   const Symbol* sym = nullptr;
   if (reloc.Type != R_WASM_TYPE_INDEX_LEB) {
     sym = symbols[reloc.Index];
 
     // We can end up with relocations against non-live symbols.  For example
     // in debug sections. We return reloc.Addend because always returning zero
     // causes the generation of spurious range-list terminators in the
     // .debug_ranges section.
     if ((isa<FunctionSymbol>(sym) || isa<DataSymbol>(sym)) && !sym->isLive())
       return reloc.Addend;
   }
 
   switch (reloc.Type) {
   case R_WASM_TABLE_INDEX_I32:
   case R_WASM_TABLE_INDEX_SLEB:
   case R_WASM_TABLE_INDEX_REL_SLEB: {
     if (!getFunctionSymbol(reloc.Index)->hasTableIndex())
       return 0;
     uint32_t index = getFunctionSymbol(reloc.Index)->getTableIndex();
     if (reloc.Type == R_WASM_TABLE_INDEX_REL_SLEB)
       index -= config->tableBase;
     return index;
 
   }
-  case R_WASM_MEMORY_ADDR_SLEB:
-  case R_WASM_MEMORY_ADDR_I32:
   case R_WASM_MEMORY_ADDR_LEB:
+  case R_WASM_MEMORY_ADDR_LEB64:
+  case R_WASM_MEMORY_ADDR_SLEB:
+  case R_WASM_MEMORY_ADDR_SLEB64:
   case R_WASM_MEMORY_ADDR_REL_SLEB:
+  case R_WASM_MEMORY_ADDR_REL_SLEB64:
+  case R_WASM_MEMORY_ADDR_I32:
+  case R_WASM_MEMORY_ADDR_I64:
     if (isa<UndefinedData>(sym) || sym->isUndefWeak())
       return 0;
     return cast<DefinedData>(sym)->getVirtualAddress() + reloc.Addend;
   case R_WASM_TYPE_INDEX_LEB:
     return typeMap[reloc.Index];
   case R_WASM_FUNCTION_INDEX_LEB:
     return getFunctionSymbol(reloc.Index)->getFunctionIndex();
   case R_WASM_GLOBAL_INDEX_LEB:
   case R_WASM_GLOBAL_INDEX_I32:
     if (auto gs = dyn_cast<GlobalSymbol>(sym))
       return gs->getGlobalIndex();
     return sym->getGOTIndex();
   case R_WASM_EVENT_INDEX_LEB:
     return getEventSymbol(reloc.Index)->getEventIndex();
   case R_WASM_FUNCTION_OFFSET_I32: {
     auto *f = cast<DefinedFunction>(sym);
-    return f->function->outputOffset + f->function->getFunctionCodeOffset() +
-           reloc.Addend;
+    return f->function->outputOffset +
+           (f->function->getFunctionCodeOffset() + reloc.Addend);
   }
   case R_WASM_SECTION_OFFSET_I32:
     return getSectionSymbol(reloc.Index)->section->outputOffset + reloc.Addend;
   default:
     llvm_unreachable("unknown relocation type");
   }
 }
 
void ObjFile::parse(bool ignoreComdats) {
   // verifying the existing table index relocations
   uint32_t totalFunctions =
       wasmObj->getNumImportedFunctions() + wasmObj->functions().size();
   tableEntriesRel.resize(totalFunctions);
   tableEntries.resize(totalFunctions);
   for (const WasmElemSegment &seg : wasmObj->elements()) {
     if (seg.Offset.Opcode != WASM_OPCODE_I32_CONST)
       fatal(toString(this) + ": invalid table elements");
-    uint32_t offset = seg.Offset.Value.Int32;
-    for (uint32_t index = 0; index < seg.Functions.size(); index++) {
-
-      uint32_t functionIndex = seg.Functions[index];
+    auto offset = seg.Offset.Value.Int64;
+    for (size_t index = 0; index < seg.Functions.size(); index++) {
+      auto functionIndex = seg.Functions[index];
       tableEntriesRel[functionIndex] = index;
       tableEntries[functionIndex] = offset + index;
     }
   }
 
   uint32_t sectionIndex = 0;
 
   // Bool for each symbol, true if called directly.  This allows us to implement
case WASM_SYMBOL_TYPE_FUNCTION: {
     if (sym.isBindingLocal())
       return make<DefinedFunction>(name, flags, this, func);
     if (func->discarded)
       return nullptr;
     return symtab->addDefinedFunction(name, flags, this, func);
   }
   case WASM_SYMBOL_TYPE_DATA: {
     InputSegment *seg = segments[sym.Info.DataRef.Segment];
-    uint32_t offset = sym.Info.DataRef.Offset;
-    uint32_t size = sym.Info.DataRef.Size;
+    auto offset = sym.Info.DataRef.Offset;
+    auto size = sym.Info.DataRef.Size;
     if (sym.isBindingLocal())
       return make<DefinedData>(name, flags, this, seg, offset, size);
     if (seg->discarded)
       return nullptr;
     return symtab->addDefinedData(name, flags, this, seg, offset, size);
   }
   case WASM_SYMBOL_TYPE_GLOBAL: {
     InputGlobal *global =

lld/wasm/OutputSections.cpp

if (segment->initFlags & WASM_SEGMENT_HAS_MEMINDEX)
       writeUleb128(os, 0, "memory index");
     if ((segment->initFlags & WASM_SEGMENT_IS_PASSIVE) == 0) {
       WasmInitExpr initExpr;
       if (config->isPic) {
         initExpr.Opcode = WASM_OPCODE_GLOBAL_GET;
         initExpr.Value.Global = WasmSym::memoryBase->getGlobalIndex();
       } else {
         initExpr.Opcode = WASM_OPCODE_I32_CONST;
-        initExpr.Value.Int32 = segment->startVA;
+        initExpr.Value.Int64 = segment->startVA;
       }
       writeInitExpr(os, initExpr);
     }
     writeUleb128(os, segment->size, "segment size");
     os.flush();
 
     segment->sectionOffset = bodySize;
     bodySize += segment->header.size() + segment->size;

lld/wasm/Relocations.cpp

case R_WASM_GLOBAL_INDEX_I32:
       break;
     }
 
     if (config->isPic) {
       switch (reloc.Type) {
       case R_WASM_TABLE_INDEX_SLEB:
       case R_WASM_MEMORY_ADDR_SLEB:
       case R_WASM_MEMORY_ADDR_LEB:
+      case R_WASM_MEMORY_ADDR_SLEB64:
+      case R_WASM_MEMORY_ADDR_LEB64:
         // Certain relocation types can't be used when building PIC output,
         // since they would require absolute symbol addresses at link time.
         error(toString(file) + ": relocation " + relocTypeToString(reloc.Type) +
               " cannot be used against symbol " + toString(*sym) +
               "; recompile with -fPIC");
         break;
       case R_WASM_TABLE_INDEX_I32:
       case R_WASM_MEMORY_ADDR_I32:
+      case R_WASM_MEMORY_ADDR_I64:
         // These relocation types are only present in the data section and
         // will be converted into code by `generateRelocationCode`.  This code
         // requires the symbols to have GOT entires.
         if (requiresGOTAccess(sym))
           addGOTEntry(sym);
         break;
       }
     } else {

lld/wasm/SymbolTable.h

public:
 
   void replace(StringRef name, Symbol* sym);
 
   void trace(StringRef name);
 
   Symbol *addDefinedFunction(StringRef name, uint32_t flags, InputFile *file,
                              InputFunction *function);
   Symbol *addDefinedData(StringRef name, uint32_t flags, InputFile *file,
-                         InputSegment *segment, uint32_t address,
-                         uint32_t size);
+                         InputSegment *segment, uint64_t address,
+                         uint64_t size);
   Symbol *addDefinedGlobal(StringRef name, uint32_t flags, InputFile *file,
                            InputGlobal *g);
   Symbol *addDefinedEvent(StringRef name, uint32_t flags, InputFile *file,
                           InputEvent *e);
 
   Symbol *addUndefinedFunction(StringRef name,
                                llvm::Optional<StringRef> importName,
                                llvm::Optional<StringRef> importModule,

lld/wasm/SymbolTable.cpp

Symbol *SymbolTable::addDefinedFunction(StringRef name, uint32_t flags,
   if (shouldReplace(s, file, flags))
     replaceSym(s);
 
   return s;
 }
 
 Symbol *SymbolTable::addDefinedData(StringRef name, uint32_t flags,
                                     InputFile *file, InputSegment *segment,
-                                    uint32_t address, uint32_t size) {
+                                    uint64_t address, uint64_t size) {
   LLVM_DEBUG(dbgs() << "addDefinedData:" << name << " addr:" << address
                     << "\n");
   Symbol *s;
   bool wasInserted;
   std::tie(s, wasInserted) = insert(name, file);
 
   auto replaceSym = [&]() {
     replaceSymbol<DefinedData>(s, name, flags, file, segment, address, size);

lld/wasm/Symbols.h

protected:
   DataSymbol(StringRef name, Kind k, uint32_t flags, InputFile *f)
       : Symbol(name, k, flags, f) {}
 };
 
 class DefinedData : public DataSymbol {
 public:
   // Constructor for regular data symbols originating from input files.
   DefinedData(StringRef name, uint32_t flags, InputFile *f,
-              InputSegment *segment, uint32_t offset, uint32_t size)
+              InputSegment *segment, uint64_t offset, uint64_t size)
       : DataSymbol(name, DefinedDataKind, flags, f), segment(segment),
         offset(offset), size(size) {}
 
   // Constructor for linker synthetic data symbols.
   DefinedData(StringRef name, uint32_t flags)
       : DataSymbol(name, DefinedDataKind, flags, nullptr) {}
 
   static bool classof(const Symbol *s) { return s->kind() == DefinedDataKind; }
 
   // Returns the output virtual address of a defined data symbol.
-  uint32_t getVirtualAddress() const;
-  void setVirtualAddress(uint32_t va);
+  uint64_t getVirtualAddress() const;
+  void setVirtualAddress(uint64_t va);
 
   // Returns the offset of a defined data symbol within its OutputSegment.
-  uint32_t getOutputSegmentOffset() const;
-  uint32_t getOutputSegmentIndex() const;
-  uint32_t getSize() const { return size; }
+  uint64_t getOutputSegmentOffset() const;
+  uint64_t getOutputSegmentIndex() const;
+  uint64_t getSize() const { return size; }
 
   InputSegment *segment = nullptr;
 
 protected:
-  uint32_t offset = 0;
-  uint32_t size = 0;
+  uint64_t offset = 0;
+  uint64_t size = 0;
 };
 
 class UndefinedData : public DataSymbol {
 public:
   UndefinedData(StringRef name, uint32_t flags, InputFile *file = nullptr)
       : DataSymbol(name, UndefinedDataKind, flags, file) {}
   static bool classof(const Symbol *s) {
     return s->kind() == UndefinedDataKind;

lld/wasm/Symbols.cpp

 }
 
 DefinedFunction::DefinedFunction(StringRef name, uint32_t flags, InputFile *f,
                                  InputFunction *function)
     : FunctionSymbol(name, DefinedFunctionKind, flags, f,
                      function ? &function->signature : nullptr),
       function(function) {}
 
-uint32_t DefinedData::getVirtualAddress() const {
+uint64_t DefinedData::getVirtualAddress() const {
   LLVM_DEBUG(dbgs() << "getVirtualAddress: " << getName() << "\n");
   if (segment) {
     // For thread local data, the symbol location is relative to the start of
     // the .tdata section, since they are used as offsets from __tls_base.
     // Hence, we do not add in segment->outputSeg->startVA.
     if (segment->outputSeg->name == ".tdata")
       return segment->outputSegmentOffset + offset;
     return segment->outputSeg->startVA + segment->outputSegmentOffset + offset;
   }
   return offset;
 }
 
-void DefinedData::setVirtualAddress(uint32_t value) {
+void DefinedData::setVirtualAddress(uint64_t value) {
   LLVM_DEBUG(dbgs() << "setVirtualAddress " << name << " -> " << value << "\n");
   assert(!segment);
   offset = value;
 }
 
-uint32_t DefinedData::getOutputSegmentOffset() const {
+uint64_t DefinedData::getOutputSegmentOffset() const {
   LLVM_DEBUG(dbgs() << "getOutputSegmentOffset: " << getName() << "\n");
   return segment->outputSegmentOffset + offset;
 }
 
-uint32_t DefinedData::getOutputSegmentIndex() const {
+uint64_t DefinedData::getOutputSegmentIndex() const {
   LLVM_DEBUG(dbgs() << "getOutputSegmentIndex: " << getName() << "\n");
   return segment->outputSeg->index;
 }
 
 uint32_t GlobalSymbol::getGlobalIndex() const {
   if (auto *f = dyn_cast<DefinedGlobal>(this))
     return f->global->getGlobalIndex();
   assert(globalIndex != INVALID_INDEX);

lld/wasm/SyntheticSections.cpp

 }
 
 void GlobalSection::writeBody() {
   raw_ostream &os = bodyOutputStream;
 
   writeUleb128(os, numGlobals(), "global count");
   for (InputGlobal *g : inputGlobals)
     writeGlobal(os, g->global);
   for (const Symbol *sym : staticGotSymbols) {
     WasmGlobal global;
     global.Type = {WASM_TYPE_I32, false};
     global.InitExpr.Opcode = WASM_OPCODE_I32_CONST;
     if (auto *d = dyn_cast<DefinedData>(sym))
-      global.InitExpr.Value.Int32 = d->getVirtualAddress();
+      global.InitExpr.Value.Int64 = d->getVirtualAddress();
     else if (auto *f = dyn_cast<FunctionSymbol>(sym))
-      global.InitExpr.Value.Int32 = f->getTableIndex();
+      global.InitExpr.Value.Int64 = f->getTableIndex();
     else {
       assert(isa<UndefinedData>(sym));
-      global.InitExpr.Value.Int32 = 0;
+      global.InitExpr.Value.Int64 = 0;
     }
     writeGlobal(os, global);
   }
   for (const DefinedData *sym : dataAddressGlobals) {
     WasmGlobal global;
     global.Type = {WASM_TYPE_I32, false};
     global.InitExpr.Opcode = WASM_OPCODE_I32_CONST;
-    global.InitExpr.Value.Int32 = sym->getVirtualAddress();
+    global.InitExpr.Value.Int64 = sym->getVirtualAddress();
     writeGlobal(os, global);
   }
 }
 
 void GlobalSection::addGlobal(InputGlobal *global) {
   assert(!isSealed);
   if (!global->live)
     return;
void ElemSection::writeBody() {
   writeUleb128(os, 1, "segment count");
   writeUleb128(os, 0, "table index");
   WasmInitExpr initExpr;
   if (config->isPic) {
     initExpr.Opcode = WASM_OPCODE_GLOBAL_GET;
     initExpr.Value.Global = WasmSym::tableBase->getGlobalIndex();
   } else {
     initExpr.Opcode = WASM_OPCODE_I32_CONST;
-    initExpr.Value.Int32 = config->tableBase;
+    initExpr.Value.Int64 = config->tableBase;
   }
   writeInitExpr(os, initExpr);
   writeUleb128(os, indirectFunctions.size(), "elem count");
 
   uint32_t tableIndex = config->tableBase;
   for (const FunctionSymbol *sym : indirectFunctions) {
     assert(sym->getTableIndex() == tableIndex);
     writeUleb128(os, sym->getFunctionIndex(), "function index");

lld/wasm/Writer.cpp

if (config->relocatable || config->isPic)
       return;
     memoryPtr = alignTo(memoryPtr, stackAlignment);
     if (config->zStackSize != alignTo(config->zStackSize, stackAlignment))
       error("stack size must be " + Twine(stackAlignment) + "-byte aligned");
     log("mem: stack size  = " + Twine(config->zStackSize));
     log("mem: stack base  = " + Twine(memoryPtr));
     memoryPtr += config->zStackSize;
     auto *sp = cast<DefinedGlobal>(WasmSym::stackPointer);
-    sp->global->global.InitExpr.Value.Int32 = memoryPtr;
+    sp->global->global.InitExpr.Value.Int64 = memoryPtr;
     log("mem: stack top   = " + Twine(memoryPtr));
   };
 
   if (config->stackFirst) {
     placeStack();
   } else {
     memoryPtr = config->globalBase;
     log("mem: global base = " + Twine(config->globalBase));
for (OutputSegment *seg : segments) {
     memoryPtr = alignTo(memoryPtr, 1ULL << seg->alignment);
     seg->startVA = memoryPtr;
     log(formatv("mem: {0,-15} offset={1,-8} size={2,-8} align={3}", seg->name,
                 memoryPtr, seg->size, seg->alignment));
     memoryPtr += seg->size;
 
     if (WasmSym::tlsSize && seg->name == ".tdata") {
       auto *tlsSize = cast<DefinedGlobal>(WasmSym::tlsSize);
-      tlsSize->global->global.InitExpr.Value.Int32 = seg->size;
+      tlsSize->global->global.InitExpr.Value.Int64 = seg->size;
 
       auto *tlsAlign = cast<DefinedGlobal>(WasmSym::tlsAlign);
-      tlsAlign->global->global.InitExpr.Value.Int32 = 1U << seg->alignment;
+      tlsAlign->global->global.InitExpr.Value.Int64 = int64_t{1} << seg->alignment;
     }
   }
 
   // Make space for the memory initialization flag
   if (WasmSym::initMemoryFlag) {
     memoryPtr = alignTo(memoryPtr, 4);
     WasmSym::initMemoryFlag->setVirtualAddress(memoryPtr);
     log(formatv("mem: {0,-15} offset={1,-8} size={2,-8} align={3}",

lld/wasm/WriterUtils.h

 #include "llvm/ADT/Twine.h"
 #include "llvm/Object/Wasm.h"
 
 namespace lld {
 namespace wasm {
 
 void debugWrite(uint64_t offset, const Twine &msg);
 
-void writeUleb128(raw_ostream &os, uint32_t number, const Twine &msg);
+void writeUleb128(raw_ostream &os, uint64_t number, const Twine &msg);
 
-void writeSleb128(raw_ostream &os, int32_t number, const Twine &msg);
+void writeSleb128(raw_ostream &os, int64_t number, const Twine &msg);
 
 void writeBytes(raw_ostream &os, const char *bytes, size_t count,
                 const Twine &msg);
 
 void writeStr(raw_ostream &os, StringRef string, const Twine &msg);
 
 void writeU8(raw_ostream &os, uint8_t byte, const Twine &msg);
 
 void writeU32(raw_ostream &os, uint32_t number, const Twine &msg);
 
 void writeValueType(raw_ostream &os, llvm::wasm::ValType type,
                     const Twine &msg);
 
 void writeSig(raw_ostream &os, const llvm::wasm::WasmSignature &sig);
 
 void writeI32Const(raw_ostream &os, int32_t number, const Twine &msg);
 
-void writeI64Const(raw_ostream &os, int32_t number, const Twine &msg);
+void writeI64Const(raw_ostream &os, int64_t number, const Twine &msg);
 
-void writeMemArg(raw_ostream &os, uint32_t alignment, uint32_t offset);
+void writeMemArg(raw_ostream &os, uint32_t alignment, uint64_t offset);
 
 void writeInitExpr(raw_ostream &os, const llvm::wasm::WasmInitExpr &initExpr);
 
 void writeLimits(raw_ostream &os, const llvm::wasm::WasmLimits &limits);
 
 void writeGlobalType(raw_ostream &os, const llvm::wasm::WasmGlobalType &type);
 
 void writeGlobal(raw_ostream &os, const llvm::wasm::WasmGlobal &global);

lld/wasm/WriterUtils.cpp

std::string toString(const WasmEventType &type) {
   return "unknown";
 }
 
 namespace wasm {
 void debugWrite(uint64_t offset, const Twine &msg) {
   LLVM_DEBUG(dbgs() << format("  | %08lld: ", offset) << msg << "\n");
 }
 
-void writeUleb128(raw_ostream &os, uint32_t number, const Twine &msg) {
+void writeUleb128(raw_ostream &os, uint64_t number, const Twine &msg) {
   debugWrite(os.tell(), msg + "[" + utohexstr(number) + "]");
   encodeULEB128(number, os);
 }
 
-void writeSleb128(raw_ostream &os, int32_t number, const Twine &msg) {
+void writeSleb128(raw_ostream &os, int64_t number, const Twine &msg) {
   debugWrite(os.tell(), msg + "[" + utohexstr(number) + "]");
   encodeSLEB128(number, os);
 }
 
 void writeBytes(raw_ostream &os, const char *bytes, size_t count,
                       const Twine &msg) {
   debugWrite(os.tell(), msg + " [data[" + Twine(count) + "]]");
   os.write(bytes, count);
void writeSig(raw_ostream &os, const WasmSignature &sig) {
   }
 }
 
 void writeI32Const(raw_ostream &os, int32_t number, const Twine &msg) {
   writeU8(os, WASM_OPCODE_I32_CONST, "i32.const");
   writeSleb128(os, number, msg);
 }
 
-void writeI64Const(raw_ostream &os, int32_t number, const Twine &msg) {
+void writeI64Const(raw_ostream &os, int64_t number, const Twine &msg) {
   writeU8(os, WASM_OPCODE_I64_CONST, "i64.const");
   writeSleb128(os, number, msg);
 }
 
-void writeMemArg(raw_ostream &os, uint32_t alignment, uint32_t offset) {
+void writeMemArg(raw_ostream &os, uint32_t alignment, uint64_t offset) {
   writeUleb128(os, alignment, "alignment");
   writeUleb128(os, offset, "offset");
 }
 
 void writeInitExpr(raw_ostream &os, const WasmInitExpr &initExpr) {
   writeU8(os, initExpr.Opcode, "opcode");
   switch (initExpr.Opcode) {
   case WASM_OPCODE_I32_CONST:
-    writeSleb128(os, initExpr.Value.Int32, "literal (i32)");
+    writeSleb128(os, initExpr.Value.Int64, "literal (i32)");
     break;
   case WASM_OPCODE_I64_CONST:
     writeSleb128(os, initExpr.Value.Int64, "literal (i64)");
     break;
   case WASM_OPCODE_F32_CONST:
     writeU32(os, initExpr.Value.Float32, "literal (f32)");
     break;
   case WASM_OPCODE_F64_CONST:

llvm/include/llvm/BinaryFormat/Wasm.h

 struct WasmTable {
   uint8_t ElemType;
   WasmLimits Limits;
 };
 
 struct WasmInitExpr {
   uint8_t Opcode;
   union {
-    int32_t Int32;
     int64_t Int64;
     uint32_t Float32;
     uint64_t Float64;
     uint32_t Global;
   } Value;
 };
 
 struct WasmGlobalType {
   uint8_t Type;
struct WasmElemSegment {
   WasmInitExpr Offset;
   std::vector<uint32_t> Functions;
 };
 
 // Represents the location of a Wasm data symbol within a WasmDataSegment, as
 // the index of the segment, and the offset and size within the segment.
 struct WasmDataReference {
   uint32_t Segment;
-  uint32_t Offset;
-  uint32_t Size;
+  uint64_t Offset;
+  uint64_t Size;
 };
 
 struct WasmRelocation {
   uint8_t Type;    // The type of the relocation.
   uint32_t Index;  // Index into either symbol or type index space.
   uint64_t Offset; // Offset from the start of the section.
   int64_t Addend;  // A value to add to the symbol.
 };

llvm/include/llvm/BinaryFormat/WasmRelocs.def

 #ifndef WASM_RELOC
 #error "WASM_RELOC must be defined"
 #endif
 
-WASM_RELOC(R_WASM_FUNCTION_INDEX_LEB,    0)
-WASM_RELOC(R_WASM_TABLE_INDEX_SLEB,      1)
-WASM_RELOC(R_WASM_TABLE_INDEX_I32,       2)
-WASM_RELOC(R_WASM_MEMORY_ADDR_LEB,       3)
-WASM_RELOC(R_WASM_MEMORY_ADDR_SLEB,      4)
-WASM_RELOC(R_WASM_MEMORY_ADDR_I32,       5)
-WASM_RELOC(R_WASM_TYPE_INDEX_LEB,        6)
-WASM_RELOC(R_WASM_GLOBAL_INDEX_LEB,      7)
-WASM_RELOC(R_WASM_FUNCTION_OFFSET_I32,   8)
-WASM_RELOC(R_WASM_SECTION_OFFSET_I32,    9)
-WASM_RELOC(R_WASM_EVENT_INDEX_LEB,      10)
-WASM_RELOC(R_WASM_MEMORY_ADDR_REL_SLEB, 11)
-WASM_RELOC(R_WASM_TABLE_INDEX_REL_SLEB, 12)
-WASM_RELOC(R_WASM_GLOBAL_INDEX_I32,     13)
+WASM_RELOC(R_WASM_FUNCTION_INDEX_LEB,      0)
+WASM_RELOC(R_WASM_TABLE_INDEX_SLEB,        1)
+WASM_RELOC(R_WASM_TABLE_INDEX_I32,         2)
+WASM_RELOC(R_WASM_MEMORY_ADDR_LEB,         3)
+WASM_RELOC(R_WASM_MEMORY_ADDR_SLEB,        4)
+WASM_RELOC(R_WASM_MEMORY_ADDR_I32,         5)
+WASM_RELOC(R_WASM_TYPE_INDEX_LEB,          6)
+WASM_RELOC(R_WASM_GLOBAL_INDEX_LEB,        7)
+WASM_RELOC(R_WASM_FUNCTION_OFFSET_I32,     8)
+WASM_RELOC(R_WASM_SECTION_OFFSET_I32,      9)
+WASM_RELOC(R_WASM_EVENT_INDEX_LEB,        10)
+WASM_RELOC(R_WASM_MEMORY_ADDR_REL_SLEB,   11)
+WASM_RELOC(R_WASM_TABLE_INDEX_REL_SLEB,   12)
+WASM_RELOC(R_WASM_GLOBAL_INDEX_I32,       13)
+WASM_RELOC(R_WASM_MEMORY_ADDR_LEB64,      14)
+WASM_RELOC(R_WASM_MEMORY_ADDR_SLEB64,     15)
+WASM_RELOC(R_WASM_MEMORY_ADDR_I64,        16)
+WASM_RELOC(R_WASM_MEMORY_ADDR_REL_SLEB64, 17)

llvm/include/llvm/ObjectYAML/WasmYAML.h

struct Function {
   uint32_t Index;
   std::vector<LocalDecl> Locals;
   yaml::BinaryRef Body;
 };
 
 struct Relocation {
   RelocType Type;
   uint32_t Index;
+  // TODO(wvo): this would strictly be better as Hex64, but that will change
+  // all existing obj2yaml output.
   yaml::Hex32 Offset;
-  int32_t Addend;
+  int64_t Addend;
 };
 
 struct DataSegment {
   uint32_t SectionOffset;
   uint32_t InitFlags;
   uint32_t MemoryIndex;
   wasm::WasmInitExpr Offset;
   yaml::BinaryRef Content;

llvm/lib/BinaryFormat/Wasm.cpp

#undef WASM_RELOC
   default:
     llvm_unreachable("unknown reloc type");
   }
 }
 
 bool llvm::wasm::relocTypeHasAddend(uint32_t Type) {
   switch (Type) {
   case R_WASM_MEMORY_ADDR_LEB:
+  case R_WASM_MEMORY_ADDR_LEB64:
   case R_WASM_MEMORY_ADDR_SLEB:
+  case R_WASM_MEMORY_ADDR_SLEB64:
   case R_WASM_MEMORY_ADDR_REL_SLEB:
+  case R_WASM_MEMORY_ADDR_REL_SLEB64:
   case R_WASM_MEMORY_ADDR_I32:
+  case R_WASM_MEMORY_ADDR_I64:
   case R_WASM_FUNCTION_OFFSET_I32:
   case R_WASM_SECTION_OFFSET_I32:
     return true;
   default:
     return false;
   }
 }

llvm/lib/MC/WasmObjectWriter.cpp

 raw_ostream &operator<<(raw_ostream &OS, const WasmRelocationEntry &Rel) {
   Rel.print(OS);
   return OS;
 }
 #endif
 
 // Write X as an (unsigned) LEB value at offset Offset in Stream, padded
 // to allow patching.
-static void writePatchableLEB(raw_pwrite_stream &Stream, uint32_t X,
+template<int W> void writePatchableLEB(raw_pwrite_stream &Stream, uint64_t X,
                                        uint64_t Offset) {
-  uint8_t Buffer[5];
-  unsigned SizeLen = encodeULEB128(X, Buffer, 5);
-  assert(SizeLen == 5);
+  uint8_t Buffer[W];
+  unsigned SizeLen = encodeULEB128(X, Buffer, W);
+  assert(SizeLen == W);
   Stream.pwrite((char *)Buffer, SizeLen, Offset);
 }
 
 // Write X as an signed LEB value at offset Offset in Stream, padded
 // to allow patching.
-static void writePatchableSLEB(raw_pwrite_stream &Stream, int32_t X,
+template<int W> void writePatchableSLEB(raw_pwrite_stream &Stream, int64_t X,
                                         uint64_t Offset) {
-  uint8_t Buffer[5];
-  unsigned SizeLen = encodeSLEB128(X, Buffer, 5);
-  assert(SizeLen == 5);
+  uint8_t Buffer[W];
+  unsigned SizeLen = encodeSLEB128(X, Buffer, W);
+  assert(SizeLen == W);
   Stream.pwrite((char *)Buffer, SizeLen, Offset);
 }
 
 // Write X as a plain integer value at offset Offset in Stream.
 static void patchI32(raw_pwrite_stream &Stream, uint32_t X, uint64_t Offset) {
   uint8_t Buffer[4];
   support::endian::write32le(Buffer, X);
   Stream.pwrite((char *)Buffer, sizeof(Buffer), Offset);
 }
 
+static void patchI64(raw_pwrite_stream &Stream, uint64_t X, uint64_t Offset) {
+  uint8_t Buffer[8];
+  support::endian::write64le(Buffer, X);
+  Stream.pwrite((char *)Buffer, sizeof(Buffer), Offset);
+}
+
 class WasmObjectWriter : public MCObjectWriter {
   support::endian::Writer W;
 
   /// The target specific Wasm writer instance.
   std::unique_ptr<MCWasmObjectTargetWriter> TargetObjectWriter;
 
   // Relocations for fixing up references in the code section.
   std::vector<WasmRelocationEntry> CodeRelocations;
void writeLinkingMetaDataSection(
       const std::map<StringRef, std::vector<WasmComdatEntry>> &Comdats);
   void writeCustomSection(WasmCustomSection &CustomSection,
                           const MCAssembler &Asm, const MCAsmLayout &Layout);
   void writeCustomRelocSections();
   void
   updateCustomSectionRelocations(const SmallVector<WasmFunction, 4> &Functions,
                                  const MCAsmLayout &Layout);
 
-  uint32_t getProvisionalValue(const WasmRelocationEntry &RelEntry);
+  uint64_t getProvisionalValue(const WasmRelocationEntry &RelEntry);
   void applyRelocations(ArrayRef<WasmRelocationEntry> Relocations,
                         uint64_t ContentsOffset);
 
   uint32_t getRelocationIndexValue(const WasmRelocationEntry &RelEntry);
   uint32_t getFunctionType(const MCSymbolWasm &Symbol);
   uint32_t getEventType(const MCSymbolWasm &Symbol);
   void registerFunctionType(const MCSymbolWasm &Symbol);
   void registerEventType(const MCSymbolWasm &Symbol);
void WasmObjectWriter::endSection(SectionBookkeeping &Section) {
   Size -= Section.PayloadOffset;
   if (uint32_t(Size) != Size)
     report_fatal_error("section size does not fit in a uint32_t");
 
   LLVM_DEBUG(dbgs() << "endSection size=" << Size << "\n");
 
   // Write the final section size to the payload_len field, which follows
   // the section id byte.
-  writePatchableLEB(static_cast<raw_pwrite_stream &>(W.OS), Size,
+  writePatchableLEB<5>(static_cast<raw_pwrite_stream &>(W.OS), Size,
                        Section.SizeOffset);
 }
 
 // Emit the Wasm header.
 void WasmObjectWriter::writeHeader(const MCAssembler &Asm) {
   W.OS.write(wasm::WasmMagic, sizeof(wasm::WasmMagic));
   W.write<uint32_t>(wasm::WasmVersion);
 }
 
static const MCSymbolWasm *resolveSymbol(const MCSymbolWasm &Symbol) {
   }
   return Ret;
 }
 
 // Compute a value to write into the code at the location covered
 // by RelEntry. This value isn't used by the static linker; it just serves
 // to make the object format more readable and more likely to be directly
 // useable.
-uint32_t
+uint64_t
 WasmObjectWriter::getProvisionalValue(const WasmRelocationEntry &RelEntry) {
   if ((RelEntry.Type == wasm::R_WASM_GLOBAL_INDEX_LEB ||
        RelEntry.Type == wasm::R_WASM_GLOBAL_INDEX_I32) &&
       !RelEntry.Symbol->isGlobal()) {
     assert(GOTIndices.count(RelEntry.Symbol) > 0 && "symbol not found in GOT index space");
     return GOTIndices[RelEntry.Symbol];
   }
 
case wasm::R_WASM_EVENT_INDEX_LEB:
     return WasmIndices[RelEntry.Symbol];
   case wasm::R_WASM_FUNCTION_OFFSET_I32:
   case wasm::R_WASM_SECTION_OFFSET_I32: {
     const auto &Section =
         static_cast<const MCSectionWasm &>(RelEntry.Symbol->getSection());
     return Section.getSectionOffset() + RelEntry.Addend;
   }
   case wasm::R_WASM_MEMORY_ADDR_LEB:
-  case wasm::R_WASM_MEMORY_ADDR_I32:
+  case wasm::R_WASM_MEMORY_ADDR_LEB64:
+  case wasm::R_WASM_MEMORY_ADDR_SLEB:
+  case wasm::R_WASM_MEMORY_ADDR_SLEB64: 
   case wasm::R_WASM_MEMORY_ADDR_REL_SLEB:
-  case wasm::R_WASM_MEMORY_ADDR_SLEB: {
+  case wasm::R_WASM_MEMORY_ADDR_REL_SLEB64:
+  case wasm::R_WASM_MEMORY_ADDR_I32:
+  case wasm::R_WASM_MEMORY_ADDR_I64: {
     // Provisional value is address of the global
     const MCSymbolWasm *Sym = resolveSymbol(*RelEntry.Symbol);
     // 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.
void WasmObjectWriter::applyRelocations(
     ArrayRef<WasmRelocationEntry> Relocations, uint64_t ContentsOffset) {
   auto &Stream = static_cast<raw_pwrite_stream &>(W.OS);
   for (const WasmRelocationEntry &RelEntry : Relocations) {
     uint64_t Offset = ContentsOffset +
                       RelEntry.FixupSection->getSectionOffset() +
                       RelEntry.Offset;
 
     LLVM_DEBUG(dbgs() << "applyRelocation: " << RelEntry << "\n");
-    uint32_t Value = getProvisionalValue(RelEntry);
+    auto Value = getProvisionalValue(RelEntry);
 
     switch (RelEntry.Type) {
     case wasm::R_WASM_FUNCTION_INDEX_LEB:
     case wasm::R_WASM_TYPE_INDEX_LEB:
     case wasm::R_WASM_GLOBAL_INDEX_LEB:
     case wasm::R_WASM_MEMORY_ADDR_LEB:
     case wasm::R_WASM_EVENT_INDEX_LEB:
-      writePatchableLEB(Stream, Value, Offset);
+      writePatchableLEB<5>(Stream, Value, Offset);
+      break;
+    case wasm::R_WASM_MEMORY_ADDR_LEB64:
+      writePatchableLEB<10>(Stream, Value, Offset);
       break;
     case wasm::R_WASM_TABLE_INDEX_I32:
     case wasm::R_WASM_MEMORY_ADDR_I32:
     case wasm::R_WASM_FUNCTION_OFFSET_I32:
     case wasm::R_WASM_SECTION_OFFSET_I32:
     case wasm::R_WASM_GLOBAL_INDEX_I32:
       patchI32(Stream, Value, Offset);
       break;
+    case wasm::R_WASM_MEMORY_ADDR_I64:
+      patchI64(Stream, Value, Offset);
+      break;
     case wasm::R_WASM_TABLE_INDEX_SLEB:
     case wasm::R_WASM_TABLE_INDEX_REL_SLEB:
     case wasm::R_WASM_MEMORY_ADDR_SLEB:
     case wasm::R_WASM_MEMORY_ADDR_REL_SLEB:
-      writePatchableSLEB(Stream, Value, Offset);
+      writePatchableSLEB<5>(Stream, Value, Offset);
+      break;
+    case wasm::R_WASM_MEMORY_ADDR_SLEB64:
+    case wasm::R_WASM_MEMORY_ADDR_REL_SLEB64:
+      writePatchableSLEB<10>(Stream, Value, Offset);
       break;
     default:
       llvm_unreachable("invalid relocation type");
     }
   }
 }
 
 void WasmObjectWriter::writeTypeSection(ArrayRef<WasmSignature> Signatures) {
if (WS.isFunction()) {
       auto &DataSection = static_cast<MCSectionWasm &>(WS.getSection());
       if (!DataSection.isWasmData())
         report_fatal_error("data symbols must live in a data section: " +
                            WS.getName());
 
       // For each data symbol, export it in the symtab as a reference to the
       // corresponding Wasm data segment.
       wasm::WasmDataReference Ref = wasm::WasmDataReference{
-          DataSection.getSegmentIndex(),
-          static_cast<uint32_t>(Layout.getSymbolOffset(WS)),
-          static_cast<uint32_t>(Size)};
+          DataSection.getSegmentIndex(), Layout.getSymbolOffset(WS),
+          static_cast<uint64_t>(Size)};
       DataLocations[&WS] = Ref;
       LLVM_DEBUG(dbgs() << "  -> segment index: " << Ref.Segment << "\n");
 
     } else if (WS.isGlobal()) {
       // A "true" Wasm global (currently just __stack_pointer)
       if (WS.isDefined()) {
         assert(WasmIndices.count(&WS) == 0);
         wasm::WasmGlobal Global;

llvm/lib/Object/RelocationResolver.cpp

 }
 
 static uint64_t resolveMachOX86_64(RelocationRef R, uint64_t S, uint64_t A) {
   if (R.getType() == MachO::X86_64_RELOC_UNSIGNED)
     return S;
   llvm_unreachable("Invalid relocation type");
 }
 
-static bool supportsWasm32(uint64_t Type) {
+static bool supportsWasm(uint64_t Type) {
   switch (Type) {
   case wasm::R_WASM_FUNCTION_INDEX_LEB:
   case wasm::R_WASM_TABLE_INDEX_SLEB:
   case wasm::R_WASM_TABLE_INDEX_I32:
   case wasm::R_WASM_MEMORY_ADDR_LEB:
+  case wasm::R_WASM_MEMORY_ADDR_LEB64:
   case wasm::R_WASM_MEMORY_ADDR_SLEB:
+  case wasm::R_WASM_MEMORY_ADDR_SLEB64:
   case wasm::R_WASM_MEMORY_ADDR_I32:
+  case wasm::R_WASM_MEMORY_ADDR_I64:
   case wasm::R_WASM_TYPE_INDEX_LEB:
   case wasm::R_WASM_GLOBAL_INDEX_LEB:
   case wasm::R_WASM_FUNCTION_OFFSET_I32:
   case wasm::R_WASM_SECTION_OFFSET_I32:
   case wasm::R_WASM_EVENT_INDEX_LEB:
   case wasm::R_WASM_GLOBAL_INDEX_I32:
     return true;
   default:
     return false;
   }
 }
 
-static uint64_t resolveWasm32(RelocationRef R, uint64_t S, uint64_t A) {
+static uint64_t resolveWasm(RelocationRef R, uint64_t S, uint64_t A) {
   switch (R.getType()) {
   case wasm::R_WASM_FUNCTION_INDEX_LEB:
   case wasm::R_WASM_TABLE_INDEX_SLEB:
   case wasm::R_WASM_TABLE_INDEX_I32:
   case wasm::R_WASM_MEMORY_ADDR_LEB:
+  case wasm::R_WASM_MEMORY_ADDR_LEB64:
   case wasm::R_WASM_MEMORY_ADDR_SLEB:
+  case wasm::R_WASM_MEMORY_ADDR_SLEB64:
   case wasm::R_WASM_MEMORY_ADDR_I32:
+  case wasm::R_WASM_MEMORY_ADDR_I64:
   case wasm::R_WASM_TYPE_INDEX_LEB:
   case wasm::R_WASM_GLOBAL_INDEX_LEB:
   case wasm::R_WASM_FUNCTION_OFFSET_I32:
   case wasm::R_WASM_SECTION_OFFSET_I32:
   case wasm::R_WASM_EVENT_INDEX_LEB:
   case wasm::R_WASM_GLOBAL_INDEX_I32:
     // For wasm section, its offset at 0 -- ignoring Value
     return A;
if (Obj.isCOFF()) {
     default:
       return {nullptr, nullptr};
     }
   } else if (Obj.isMachO()) {
     if (Obj.getArch() == Triple::x86_64)
       return {supportsMachOX86_64, resolveMachOX86_64};
     return {nullptr, nullptr};
   } else if (Obj.isWasm()) {
-    if (Obj.getArch() == Triple::wasm32)
-      return {supportsWasm32, resolveWasm32};
+    if (Obj.getArch() == Triple::wasm32 || Obj.getArch() == Triple::wasm64)
+      return {supportsWasm, resolveWasm};
     return {nullptr, nullptr};
   }
 
   llvm_unreachable("Invalid object file");
 }
 
 } // namespace object
 } // namespace llvm

llvm/lib/Object/WasmObjectFile.cpp

if (Result > UINT32_MAX)
     report_fatal_error("LEB is outside Varuint32 range");
   return Result;
 }
 
 static int64_t readVarint64(WasmObjectFile::ReadContext &Ctx) {
   return readLEB128(Ctx);
 }
 
+static uint64_t readVaruint64(WasmObjectFile::ReadContext &Ctx) {
+  return readULEB128(Ctx);
+}
+
 static uint8_t readOpcode(WasmObjectFile::ReadContext &Ctx) {
   return readUint8(Ctx);
 }
 
 static Error readInitExpr(wasm::WasmInitExpr &Expr,
                           WasmObjectFile::ReadContext &Ctx) {
   Expr.Opcode = readOpcode(Ctx);
 
   switch (Expr.Opcode) {
   case wasm::WASM_OPCODE_I32_CONST:
-    Expr.Value.Int32 = readVarint32(Ctx);
-    break;
   case wasm::WASM_OPCODE_I64_CONST:
     Expr.Value.Int64 = readVarint64(Ctx);
     break;
   case wasm::WASM_OPCODE_F32_CONST:
     Expr.Value.Float32 = readFloat32(Ctx);
     break;
   case wasm::WASM_OPCODE_F64_CONST:
     Expr.Value.Float64 = readFloat64(Ctx);
case wasm::WASM_SYMBOL_TYPE_GLOBAL:
           Info.ImportModule = Import.Module;
         }
       }
       break;
 
     case wasm::WASM_SYMBOL_TYPE_DATA:
       Info.Name = readString(Ctx);
       if (IsDefined) {
-        uint32_t Index = readVaruint32(Ctx);
+        auto Index = readVaruint32(Ctx);
         if (Index >= DataSegments.size())
           return make_error<GenericBinaryError>("invalid data symbol index",
                                                 object_error::parse_failed);
-        uint32_t Offset = readVaruint32(Ctx);
-        uint32_t Size = readVaruint32(Ctx);
+        auto Offset = readVaruint64(Ctx);
+        auto Size = readVaruint64(Ctx);
         if (Offset + Size > DataSegments[Index].Data.Content.size())
           return make_error<GenericBinaryError>("invalid data symbol offset",
                                                 object_error::parse_failed);
         Info.DataRef = wasm::WasmDataReference{Index, Offset, Size};
       }
       break;
 
     case wasm::WASM_SYMBOL_TYPE_SECTION: {
while (RelocCount--) {
     case wasm::R_WASM_MEMORY_ADDR_SLEB:
     case wasm::R_WASM_MEMORY_ADDR_I32:
     case wasm::R_WASM_MEMORY_ADDR_REL_SLEB:
       if (!isValidDataSymbol(Reloc.Index))
         return make_error<GenericBinaryError>("Bad relocation data index",
                                               object_error::parse_failed);
       Reloc.Addend = readVarint32(Ctx);
       break;
+    case wasm::R_WASM_MEMORY_ADDR_LEB64:
+    case wasm::R_WASM_MEMORY_ADDR_SLEB64:
+    case wasm::R_WASM_MEMORY_ADDR_I64:
+    case wasm::R_WASM_MEMORY_ADDR_REL_SLEB64:
+      if (!isValidDataSymbol(Reloc.Index))
+        return make_error<GenericBinaryError>("Bad relocation data index",
+          object_error::parse_failed);
+      Reloc.Addend = readVarint64(Ctx);
+      break;
     case wasm::R_WASM_FUNCTION_OFFSET_I32:
       if (!isValidFunctionSymbol(Reloc.Index))
         return make_error<GenericBinaryError>("Bad relocation function index",
                                               object_error::parse_failed);
       Reloc.Addend = readVarint32(Ctx);
       break;
     case wasm::R_WASM_SECTION_OFFSET_I32:
       if (!isValidSectionSymbol(Reloc.Index))
         return make_error<GenericBinaryError>("Bad relocation section index",
                                               object_error::parse_failed);
       Reloc.Addend = readVarint32(Ctx);
       break;
     default:
       return make_error<GenericBinaryError>("Bad relocation type: " +
                                                 Twine(Reloc.Type),
                                             object_error::parse_failed);
     }
 
     // Relocations must fit inside the section, and must appear in order.  They
     // also shouldn't overlap a function/element boundary, but we don't bother
     // to check that.
     uint64_t Size = 5;
+    if (Reloc.Type == wasm::R_WASM_MEMORY_ADDR_LEB64 ||
+        Reloc.Type == wasm::R_WASM_MEMORY_ADDR_SLEB64 ||
+        Reloc.Type == wasm::R_WASM_MEMORY_ADDR_REL_SLEB64)
+      Size = 10;
     if (Reloc.Type == wasm::R_WASM_TABLE_INDEX_I32 ||
         Reloc.Type == wasm::R_WASM_MEMORY_ADDR_I32 ||
         Reloc.Type == wasm::R_WASM_SECTION_OFFSET_I32 ||
         Reloc.Type == wasm::R_WASM_FUNCTION_OFFSET_I32 ||
         Reloc.Type == wasm::R_WASM_GLOBAL_INDEX_I32)
       Size = 4;
+    if (Reloc.Type == wasm::R_WASM_MEMORY_ADDR_I64)
+      Size = 8;
     if (Reloc.Offset + Size > EndOffset)
       return make_error<GenericBinaryError>("Bad relocation offset",
                                             object_error::parse_failed);
 
     Section.Relocations.push_back(Reloc);
   }
   if (Ctx.Ptr != Ctx.End)
     return make_error<GenericBinaryError>("Reloc section ended prematurely",
while (Count--) {
     Segment.Data.InitFlags = readVaruint32(Ctx);
     Segment.Data.MemoryIndex = (Segment.Data.InitFlags & wasm::WASM_SEGMENT_HAS_MEMINDEX)
                                ? readVaruint32(Ctx) : 0;
     if ((Segment.Data.InitFlags & wasm::WASM_SEGMENT_IS_PASSIVE) == 0) {
       if (Error Err = readInitExpr(Segment.Data.Offset, Ctx))
         return Err;
     } else {
       Segment.Data.Offset.Opcode = wasm::WASM_OPCODE_I32_CONST;
-      Segment.Data.Offset.Value.Int32 = 0;
+      Segment.Data.Offset.Value.Int64 = 0;
     }
     uint32_t Size = readVaruint32(Ctx);
     if (Size > (size_t)(Ctx.End - Ctx.Ptr))
       return make_error<GenericBinaryError>("Invalid segment size",
                                             object_error::parse_failed);
     Segment.Data.Content = ArrayRef<uint8_t>(Ctx.Ptr, Size);
     // The rest of these Data fields are set later, when reading in the linking
     // metadata section.
uint64_t WasmObjectFile::getWasmSymbolValue(const WasmSymbol &Sym) const {
   case wasm::WASM_SYMBOL_TYPE_EVENT:
     return Sym.Info.ElementIndex;
   case wasm::WASM_SYMBOL_TYPE_DATA: {
     // The value of a data symbol is the segment offset, plus the symbol
     // offset within the segment.
     uint32_t SegmentIndex = Sym.Info.DataRef.Segment;
     const wasm::WasmDataSegment &Segment = DataSegments[SegmentIndex].Data;
     assert(Segment.Offset.Opcode == wasm::WASM_OPCODE_I32_CONST);
-    return Segment.Offset.Value.Int32 + Sym.Info.DataRef.Offset;
+    return Segment.Offset.Value.Int64 + Sym.Info.DataRef.Offset;
   }
   case wasm::WASM_SYMBOL_TYPE_SECTION:
     return 0;
   }
   llvm_unreachable("invalid symbol type");
 }
 
 uint64_t WasmObjectFile::getSymbolValueImpl(DataRefImpl Symb) const {

llvm/lib/ObjectYAML/WasmEmitter.cpp

void WasmWriter::reportError(const Twine &Msg) {
   HasError = true;
 }
 
 void WasmWriter::writeInitExpr(raw_ostream &OS,
                                const wasm::WasmInitExpr &InitExpr) {
   writeUint8(OS, InitExpr.Opcode);
   switch (InitExpr.Opcode) {
   case wasm::WASM_OPCODE_I32_CONST:
-    encodeSLEB128(InitExpr.Value.Int32, OS);
-    break;
   case wasm::WASM_OPCODE_I64_CONST:
     encodeSLEB128(InitExpr.Value.Int64, OS);
     break;
   case wasm::WASM_OPCODE_F32_CONST:
     writeUint32(OS, InitExpr.Value.Float32);
     break;
   case wasm::WASM_OPCODE_F64_CONST:
     writeUint64(OS, InitExpr.Value.Float64);
void WasmWriter::writeRelocSection(raw_ostream &OS, WasmYAML::Section &Sec,
   encodeULEB128(Sec.Relocations.size(), OS);
 
   for (auto Reloc : Sec.Relocations) {
     writeUint8(OS, Reloc.Type);
     encodeULEB128(Reloc.Offset, OS);
     encodeULEB128(Reloc.Index, OS);
     switch (Reloc.Type) {
     case wasm::R_WASM_MEMORY_ADDR_LEB:
+    case wasm::R_WASM_MEMORY_ADDR_LEB64:
     case wasm::R_WASM_MEMORY_ADDR_SLEB:
+    case wasm::R_WASM_MEMORY_ADDR_SLEB64:
     case wasm::R_WASM_MEMORY_ADDR_I32:
+    case wasm::R_WASM_MEMORY_ADDR_I64:
     case wasm::R_WASM_FUNCTION_OFFSET_I32:
     case wasm::R_WASM_SECTION_OFFSET_I32:
       encodeULEB128(Reloc.Addend, OS);
     }
   }
 }
 
 bool WasmWriter::writeWasm(raw_ostream &OS) {

llvm/lib/ObjectYAML/WasmYAML.cpp

 
 void MappingTraits<wasm::WasmInitExpr>::mapping(IO &IO,
                                                 wasm::WasmInitExpr &Expr) {
   WasmYAML::Opcode Op = Expr.Opcode;
   IO.mapRequired("Opcode", Op);
   Expr.Opcode = Op;
   switch (Expr.Opcode) {
   case wasm::WASM_OPCODE_I32_CONST:
-    IO.mapRequired("Value", Expr.Value.Int32);
-    break;
   case wasm::WASM_OPCODE_I64_CONST:
     IO.mapRequired("Value", Expr.Value.Int64);
     break;
   case wasm::WASM_OPCODE_F32_CONST:
     IO.mapRequired("Value", Expr.Value.Float32);
     break;
   case wasm::WASM_OPCODE_F64_CONST:
     IO.mapRequired("Value", Expr.Value.Float64);
     break;
   case wasm::WASM_OPCODE_GLOBAL_GET:
if (Segment.InitFlags & wasm::WASM_SEGMENT_HAS_MEMINDEX) {
     IO.mapRequired("MemoryIndex", Segment.MemoryIndex);
   } else {
     Segment.MemoryIndex = 0;
   }
   if ((Segment.InitFlags & wasm::WASM_SEGMENT_IS_PASSIVE) == 0) {
     IO.mapRequired("Offset", Segment.Offset);
   } else {
     Segment.Offset.Opcode = wasm::WASM_OPCODE_I32_CONST;
-    Segment.Offset.Value.Int32 = 0;
+    Segment.Offset.Value.Int64 = 0;
   }
   IO.mapRequired("Content", Segment.Content);
 }
 
 void MappingTraits<WasmYAML::InitFunction>::mapping(
     IO &IO, WasmYAML::InitFunction &Init) {
   IO.mapRequired("Priority", Init.Priority);
   IO.mapRequired("Symbol", Init.Symbol);

llvm/lib/Target/WebAssembly/AsmParser/WebAssemblyAsmParser.cpp

 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MCSymbolWasm.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/TargetRegistry.h"
 
 using namespace llvm;
 
+// Defines llvm::WebAssembly::getWasm64Opcode to convert 32-bit instructions to
+// 64-bit.
+#define GET_INSTRMAP_INFO 1
+#include "WebAssemblyGenInstrInfo.inc"
+
 #define DEBUG_TYPE "wasm-asm-parser"
 
 namespace {
 
 /// WebAssemblyOperand - Instances of this class represent the operands in a
 /// parsed WASM machine instruction.
 struct WebAssemblyOperand : public MCParsedAsmOperand {
   enum KindTy { Token, Integer, Float, Symbol, BrList } Kind;
case Match_Success: {
       ensureLocals(Out);
       // Fix unknown p2align operands.
       auto Align = WebAssembly::GetDefaultP2AlignAny(Inst.getOpcode());
       if (Align != -1U) {
         auto &Op0 = Inst.getOperand(0);
         if (Op0.getImm() == -1)
           Op0.setImm(Align);
       }
+      if (getSTI().getTargetTriple().getArch() == Triple::ArchType::wasm64) {
+        // Upgrade 32-bit loads/stores to 64-bit. These mostly differ by having
+        // an offset64 arg instead of offset32, but to the assembler matcher
+        // they're both immediates so don't get selected for.
+        auto Opc64 = WebAssembly::getWasm64Opcode(
+          static_cast<uint16_t>(Inst.getOpcode()));
+        if (Opc64 >= 0) {
+          Inst.setOpcode(Opc64);
+          /*
+          for (unsigned i = 0; i < Inst.getNumOperands(); i++) {
+            auto &Op = Inst.getOperand(i);
+            if (Op.)
+          }*/
+        }
+      }
       Out.emitInstruction(Inst, getSTI());
       if (CurrentState == EndFunction) {
         onEndOfFunction();
       } else {
         CurrentState = Instructions;
       }
       return false;
     }

llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCCodeEmitter.cpp

if (MO.isReg()) {
       case WebAssembly::OPERAND_SIGNATURE:
       case WebAssembly::OPERAND_TYPEINDEX:
       case WebAssembly::OPERAND_GLOBAL:
       case WebAssembly::OPERAND_EVENT:
         FixupKind = MCFixupKind(WebAssembly::fixup_uleb128_i32);
         break;
       case WebAssembly::OPERAND_OFFSET64:
         FixupKind = MCFixupKind(WebAssembly::fixup_uleb128_i64);
+        PaddedSize = 10;
         break;
       default:
         llvm_unreachable("unexpected symbolic operand kind");
       }
       Fixups.push_back(MCFixup::create(OS.tell() - Start, MO.getExpr(),
                                        FixupKind, MI.getLoc()));
       ++MCNumFixups;
       encodeULEB128(0, OS, PaddedSize);

llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyWasmObjectWriter.cpp

unsigned WebAssemblyWasmObjectWriter::getRelocType(const MCValue &Target,
   switch (Modifier) {
     case MCSymbolRefExpr::VK_GOT:
       return wasm::R_WASM_GLOBAL_INDEX_LEB;
     case MCSymbolRefExpr::VK_WASM_TBREL:
       assert(SymA.isFunction());
       return wasm::R_WASM_TABLE_INDEX_REL_SLEB;
     case MCSymbolRefExpr::VK_WASM_MBREL:
       assert(SymA.isData());
-      return wasm::R_WASM_MEMORY_ADDR_REL_SLEB;
+      return is64Bit() ? wasm::R_WASM_MEMORY_ADDR_REL_SLEB64
+                       : wasm::R_WASM_MEMORY_ADDR_REL_SLEB;
     case MCSymbolRefExpr::VK_WASM_TYPEINDEX:
       return wasm::R_WASM_TYPE_INDEX_LEB;
     default:
       break;
   }
 
   switch (unsigned(Fixup.getKind())) {
   case WebAssembly::fixup_sleb128_i32:
-  case WebAssembly::fixup_sleb128_i64:
     if (SymA.isFunction())
       return wasm::R_WASM_TABLE_INDEX_SLEB;
     return wasm::R_WASM_MEMORY_ADDR_SLEB;
+  case WebAssembly::fixup_sleb128_i64:
+    assert(SymA.isData());
+    return wasm::R_WASM_MEMORY_ADDR_SLEB64;
   case WebAssembly::fixup_uleb128_i32:
-  case WebAssembly::fixup_uleb128_i64:
     if (SymA.isGlobal())
       return wasm::R_WASM_GLOBAL_INDEX_LEB;
     if (SymA.isFunction())
       return wasm::R_WASM_FUNCTION_INDEX_LEB;
     if (SymA.isEvent())
       return wasm::R_WASM_EVENT_INDEX_LEB;
     return wasm::R_WASM_MEMORY_ADDR_LEB;
+  case WebAssembly::fixup_uleb128_i64:
+    assert(SymA.isData());
+    return wasm::R_WASM_MEMORY_ADDR_LEB64;
   case FK_Data_4:
     if (SymA.isFunction())
       return wasm::R_WASM_TABLE_INDEX_I32;
     if (SymA.isGlobal())
       return wasm::R_WASM_GLOBAL_INDEX_I32;
     if (auto Section = static_cast<const MCSectionWasm *>(
             getFixupSection(Fixup.getValue()))) {
       if (Section->getKind().isText())
         return wasm::R_WASM_FUNCTION_OFFSET_I32;
       else if (!Section->isWasmData())
         return wasm::R_WASM_SECTION_OFFSET_I32;
     }
     return wasm::R_WASM_MEMORY_ADDR_I32;
+  case FK_Data_8:
+    assert(SymA.isData());
+    return wasm::R_WASM_MEMORY_ADDR_I64;
   default:
     llvm_unreachable("unimplemented fixup kind");
   }
 }
 
 std::unique_ptr<MCObjectTargetWriter>
 llvm::createWebAssemblyWasmObjectWriter(bool Is64Bit, bool IsEmscripten) {
   return std::make_unique<WebAssemblyWasmObjectWriter>(Is64Bit, IsEmscripten);
 }

llvm/lib/Target/WebAssembly/WebAssemblyInstrAtomics.td

 // WebAssemblyInstrAtomics.td-WebAssembly Atomic codegen support-*- tablegen -*-
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// WebAssembly Atomic operand code-gen constructs.
 ///
 //===----------------------------------------------------------------------===//
 
 let UseNamedOperandTable = 1 in
 multiclass ATOMIC_I<dag oops_r, dag iops_r, dag oops_s, dag iops_s,
                     list<dag> pattern_r, string asmstr_r = "",
-                    string asmstr_s = "", bits<32> atomic_op = -1> {
+                    string asmstr_s = "", bits<32> atomic_op = -1, string is64 = "false"> {
   defm "" : I<oops_r, iops_r, oops_s, iops_s, pattern_r, asmstr_r, asmstr_s,
-              !or(0xfe00, !and(0xff, atomic_op))>,
+              !or(0xfe00, !and(0xff, atomic_op)), is64>,
             Requires<[HasAtomics]>;
 }
 
 multiclass ATOMIC_NRI<dag oops, dag iops, list<dag> pattern, string asmstr = "",
                       bits<32> atomic_op = -1> {
   defm "" : NRI<oops, iops, pattern, asmstr,
                 !or(0xfe00, !and(0xff, atomic_op))>,
             Requires<[HasAtomics]>;
 }
 
 //===----------------------------------------------------------------------===//
 // Atomic wait / notify
 //===----------------------------------------------------------------------===//
 
 let hasSideEffects = 1 in {
 defm ATOMIC_NOTIFY_A32 :
   ATOMIC_I<(outs I32:$dst),
            (ins P2Align:$p2align, offset32_op:$off, I32:$addr, I32:$count),
            (outs), (ins P2Align:$p2align, offset32_op:$off), [],
            "atomic.notify \t$dst, ${off}(${addr})${p2align}, $count",
-           "atomic.notify \t${off}${p2align}", 0x00>;
+           "atomic.notify \t${off}${p2align}", 0x00, "false">;
 defm ATOMIC_NOTIFY_A64 :
   ATOMIC_I<(outs I32:$dst),
            (ins P2Align:$p2align, offset64_op:$off, I64:$addr, I32:$count),
            (outs), (ins P2Align:$p2align, offset64_op:$off), [],
            "atomic.notify \t$dst, ${off}(${addr})${p2align}, $count",
-           "atomic.notify \t${off}${p2align}", 0x00>;
+           "atomic.notify \t${off}${p2align}", 0x00, "true">;
 let mayLoad = 1 in {
 defm ATOMIC_WAIT_I32_A32 :
   ATOMIC_I<(outs I32:$dst),
            (ins P2Align:$p2align, offset32_op:$off, I32:$addr, I32:$exp,
                 I64:$timeout),
            (outs), (ins P2Align:$p2align, offset32_op:$off), [],
            "i32.atomic.wait \t$dst, ${off}(${addr})${p2align}, $exp, $timeout",
-           "i32.atomic.wait \t${off}${p2align}", 0x01>;
+           "i32.atomic.wait \t${off}${p2align}", 0x01, "false">;
 defm ATOMIC_WAIT_I32_A64 :
   ATOMIC_I<(outs I32:$dst),
            (ins P2Align:$p2align, offset64_op:$off, I64:$addr, I32:$exp,
                 I64:$timeout),
            (outs), (ins P2Align:$p2align, offset64_op:$off), [],
            "i32.atomic.wait \t$dst, ${off}(${addr})${p2align}, $exp, $timeout",
-           "i32.atomic.wait \t${off}${p2align}", 0x01>;
+           "i32.atomic.wait \t${off}${p2align}", 0x01, "true">;
 defm ATOMIC_WAIT_I64_A32 :
   ATOMIC_I<(outs I32:$dst),
            (ins P2Align:$p2align, offset32_op:$off, I32:$addr, I64:$exp,
                 I64:$timeout),
            (outs), (ins P2Align:$p2align, offset32_op:$off), [],
            "i64.atomic.wait \t$dst, ${off}(${addr})${p2align}, $exp, $timeout",
-           "i64.atomic.wait \t${off}${p2align}", 0x02>;
+           "i64.atomic.wait \t${off}${p2align}", 0x02, "false">;
 defm ATOMIC_WAIT_I64_A64 :
   ATOMIC_I<(outs I32:$dst),
            (ins P2Align:$p2align, offset64_op:$off, I64:$addr, I64:$exp,
                 I64:$timeout),
            (outs), (ins P2Align:$p2align, offset64_op:$off), [],
            "i64.atomic.wait \t$dst, ${off}(${addr})${p2align}, $exp, $timeout",
-           "i64.atomic.wait \t${off}${p2align}", 0x02>;
+           "i64.atomic.wait \t${off}${p2align}", 0x02, "true">;
 } // mayLoad = 1
 } // hasSideEffects = 1
 
 let Predicates = [HasAtomics] in {
 // Select notifys with no constant offset.
 def NotifyPatNoOffset_A32 :
   Pat<(i32 (int_wasm_atomic_notify I32:$addr, I32:$count)),
       (ATOMIC_NOTIFY_A32 0, 0, I32:$addr, I32:$count)>;

 
 } // Predicates = [HasAtomics]
 
 //===----------------------------------------------------------------------===//
 // Atomic stores
 //===----------------------------------------------------------------------===//
 
 multiclass AtomicStore<WebAssemblyRegClass rc, string name, int atomic_op> {
-  defm "" : WebAssemblyStore<rc, name, !or(0xfe00, !and(0xff, atomic_op))>,
-            Requires<[HasAtomics]>;
+  defm "" : WebAssemblyStore<rc, name, !or(0xfe00, !and(0xff, atomic_op)),
+                             [HasAtomics]>;
 }
 
 defm ATOMIC_STORE_I32 : AtomicStore<I32, "i32.atomic.store", 0x17>;
 defm ATOMIC_STORE_I64 : AtomicStore<I64, "i64.atomic.store", 0x18>;
 
 // We need an 'atomic' version of store patterns because store and atomic_store
 // nodes have different operand orders:
 // store: (store $val, $ptr)

 
 multiclass WebAssemblyBinRMW<WebAssemblyRegClass rc, string name,
                              int atomic_op> {
   defm "_A32" :
     ATOMIC_I<(outs rc:$dst),
              (ins P2Align:$p2align, offset32_op:$off, I32:$addr, rc:$val),
              (outs), (ins P2Align:$p2align, offset32_op:$off), [],
              !strconcat(name, "\t$dst, ${off}(${addr})${p2align}, $val"),
-             !strconcat(name, "\t${off}${p2align}"), atomic_op>;
+             !strconcat(name, "\t${off}${p2align}"), atomic_op, "false">;
   defm "_A64" :
     ATOMIC_I<(outs rc:$dst),
              (ins P2Align:$p2align, offset64_op:$off, I64:$addr, rc:$val),
              (outs), (ins P2Align:$p2align, offset64_op:$off), [],
              !strconcat(name, "\t$dst, ${off}(${addr})${p2align}, $val"),
-             !strconcat(name, "\t${off}${p2align}"), atomic_op>;
+             !strconcat(name, "\t${off}${p2align}"), atomic_op, "true">;
 }
 
 defm ATOMIC_RMW_ADD_I32 : WebAssemblyBinRMW<I32, "i32.atomic.rmw.add", 0x1e>;
 defm ATOMIC_RMW_ADD_I64 : WebAssemblyBinRMW<I64, "i64.atomic.rmw.add", 0x1f>;
 defm ATOMIC_RMW8_U_ADD_I32 :
   WebAssemblyBinRMW<I32, "i32.atomic.rmw8.add_u", 0x20>;
 defm ATOMIC_RMW16_U_ADD_I32 :
   WebAssemblyBinRMW<I32, "i32.atomic.rmw16.add_u", 0x21>;

 multiclass WebAssemblyTerRMW<WebAssemblyRegClass rc, string name,
                              int atomic_op> {
   defm "_A32" :
     ATOMIC_I<(outs rc:$dst),
              (ins P2Align:$p2align, offset32_op:$off, I32:$addr, rc:$exp,
                   rc:$new_),
              (outs), (ins P2Align:$p2align, offset32_op:$off), [],
              !strconcat(name, "\t$dst, ${off}(${addr})${p2align}, $exp, $new_"),
-             !strconcat(name, "\t${off}${p2align}"), atomic_op>;
+             !strconcat(name, "\t${off}${p2align}"), atomic_op, "false">;
   defm "_A64" :
     ATOMIC_I<(outs rc:$dst),
              (ins P2Align:$p2align, offset64_op:$off, I64:$addr, rc:$exp,
                   rc:$new_),
              (outs), (ins P2Align:$p2align, offset64_op:$off), [],
              !strconcat(name, "\t$dst, ${off}(${addr})${p2align}, $exp, $new_"),
-             !strconcat(name, "\t${off}${p2align}"), atomic_op>;
+             !strconcat(name, "\t${off}${p2align}"), atomic_op, "true">;
 }
 
 defm ATOMIC_RMW_CMPXCHG_I32 :
   WebAssemblyTerRMW<I32, "i32.atomic.rmw.cmpxchg", 0x48>;
 defm ATOMIC_RMW_CMPXCHG_I64 :
   WebAssemblyTerRMW<I64, "i64.atomic.rmw.cmpxchg", 0x49>;
 defm ATOMIC_RMW8_U_CMPXCHG_I32 :
   WebAssemblyTerRMW<I32, "i32.atomic.rmw8.cmpxchg_u", 0x4a>;

llvm/lib/Target/WebAssembly/WebAssemblyInstrFormats.td

 //=- WebAssemblyInstrFormats.td - WebAssembly Instr. Formats -*- tablegen -*-=//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// WebAssembly instruction format definitions.
 ///
 //===----------------------------------------------------------------------===//
 
 // WebAssembly Instruction Format.
 // We instantiate 2 of these for every actual instruction (register based
 // and stack based), see below.
-class WebAssemblyInst<bits<32> inst, string asmstr, string stack> : StackRel,
-  Instruction {
+class WebAssemblyInst<bits<32> inst, string asmstr, string stack, string is64>
+  : StackRel, Wasm64Rel, Instruction {
   bits<32> Inst = inst; // Instruction encoding.
   string StackBased = stack;
   string BaseName = NAME;
+  string IsWasm64 = is64;
+  string Wasm32Name = !subst("_A64", "_A32", NAME);
   let Namespace   = "WebAssembly";
   let Pattern     = [];
   let AsmString   = asmstr;
   // When there are multiple instructions that map to the same encoding (in
   // e.g. the disassembler use case) prefer the one where IsCanonical == 1.
   bit IsCanonical = 0;
 }
 
 // Normal instructions. Default instantiation of a WebAssemblyInst.
 class NI<dag oops, dag iops, list<dag> pattern, string stack,
-         string asmstr = "", bits<32> inst = -1>
-    : WebAssemblyInst<inst, asmstr, stack> {
+         string asmstr = "", bits<32> inst = -1, string is64 = "false">
+    : WebAssemblyInst<inst, asmstr, stack, is64> {
   dag OutOperandList = oops;
   dag InOperandList  = iops;
   let Pattern        = pattern;
   let Defs           = [ARGUMENTS];
 }
 
 // Generates both register and stack based versions of one actual instruction.
 // We have 2 sets of operands (oops & iops) for the register and stack
 // based version of this instruction, as well as the corresponding asmstr.
 // The register versions have virtual-register operands which correspond to wasm
 // locals or stack locations. Each use and def of the register corresponds to an
 // implicit local.get / local.set or access of stack operands in wasm. These
 // instructions are used for ISel and all MI passes. The stack versions of the
 // instructions do not have register operands (they implicitly operate on the
 // stack), and local.gets and local.sets are explicit. The register instructions
 // are converted to their corresponding stack instructions before lowering to
 // MC.
 // Every instruction should want to be based on this multi-class to guarantee
 // there is always an equivalent pair of instructions.
 multiclass I<dag oops_r, dag iops_r, dag oops_s, dag iops_s,
              list<dag> pattern_r, string asmstr_r = "", string asmstr_s = "",
-             bits<32> inst = -1> {
+             bits<32> inst = -1, string is64 = "false"> {
   let isCodeGenOnly = 1 in
-  def "" : NI<oops_r, iops_r, pattern_r, "false", asmstr_r, inst>;
+  def "" : NI<oops_r, iops_r, pattern_r, "false", asmstr_r, inst, is64>;
   let BaseName = NAME in
-  def _S : NI<oops_s, iops_s, [], "true", asmstr_s, inst>;
+  def _S : NI<oops_s, iops_s, [], "true", asmstr_s, inst, is64>;
 }
 
 // For instructions that have no register ops, so both sets are the same.
 multiclass NRI<dag oops, dag iops, list<dag> pattern, string asmstr = "",
                bits<32> inst = -1> {
   defm "": I<oops, iops, oops, iops, pattern, asmstr, asmstr, inst>;
 }

llvm/lib/Target/WebAssembly/WebAssemblyInstrInfo.td

def getStackOpcode : InstrMapping {
   let FilterClass = "StackRel";
   let RowFields = ["BaseName"];
   let ColFields = ["StackBased"];
   let KeyCol = ["false"];
   let ValueCols = [["true"]];
 }
 
 //===----------------------------------------------------------------------===//
+// WebAssembly 32 to 64-bit instruction mapping
+//===----------------------------------------------------------------------===//
+
+class Wasm64Rel;
+def getWasm64Opcode : InstrMapping {
+  let FilterClass = "Wasm64Rel";
+  let RowFields = ["Wasm32Name"];
+  let ColFields = ["IsWasm64"];
+  let KeyCol = ["false"];
+  let ValueCols = [["true"]];
+}
+
+//===----------------------------------------------------------------------===//
 // WebAssembly Instruction Format Definitions.
 //===----------------------------------------------------------------------===//
 
 include "WebAssemblyInstrFormats.td"
 
 //===----------------------------------------------------------------------===//
 // Additional instructions.
 //===----------------------------------------------------------------------===//

llvm/lib/Target/WebAssembly/WebAssemblyInstrMemory.td

def or_is_add : PatFrag<(ops node:$lhs, node:$rhs), (or node:$lhs, node:$rhs),[{
   return (~Known0.Zero & ~Known1.Zero) == 0;
 }]>;
 
 // We don't need a regPlusES because external symbols never have constant
 // offsets folded into them, so we can just use add.
 
 // Defines atomic and non-atomic loads, regular and extending.
 multiclass WebAssemblyLoad<WebAssemblyRegClass rc, string Name, int Opcode,
-                           list<Predicate> reqs> {
+                           list<Predicate> reqs = []> {
   let mayLoad = 1, UseNamedOperandTable = 1 in {
   defm "_A32": I<(outs rc:$dst),
                  (ins P2Align:$p2align, offset32_op:$off, I32:$addr),
                  (outs), (ins P2Align:$p2align, offset32_op:$off),
                  [], !strconcat(Name, "\t$dst, ${off}(${addr})${p2align}"),
-                 !strconcat(Name, "\t${off}${p2align}"), Opcode>,
-               Requires<reqs>;
+                 !strconcat(Name, "\t${off}${p2align}"), Opcode, "false">,
+               Requires<!listconcat(reqs, [HasAddr32])>;
   defm "_A64": I<(outs rc:$dst),
                  (ins P2Align:$p2align, offset64_op:$off, I64:$addr),
                  (outs), (ins P2Align:$p2align, offset64_op:$off),
                  [], !strconcat(Name, "\t$dst, ${off}(${addr})${p2align}"),
-                 !strconcat(Name, "\t${off}${p2align}"), Opcode>,
+                 !strconcat(Name, "\t${off}${p2align}"), Opcode, "true">,
                Requires<!listconcat(reqs, [HasAddr64])>;
   }
 }
 
 // Basic load.
 // FIXME: When we can break syntax compatibility, reorder the fields in the
 // asmstrings to match the binary encoding.
 defm LOAD_I32 : WebAssemblyLoad<I32, "i32.load", 0x28, []>;

 defm : LoadPatOffsetOnly<i64, extloadi32, "LOAD32_U_I64">;
 defm : LoadPatGlobalAddrOffOnly<i32, extloadi8, "LOAD8_U_I32">;
 defm : LoadPatGlobalAddrOffOnly<i32, extloadi16, "LOAD16_U_I32">;
 defm : LoadPatGlobalAddrOffOnly<i64, extloadi8, "LOAD8_U_I64">;
 defm : LoadPatGlobalAddrOffOnly<i64, extloadi16, "LOAD16_U_I64">;
 defm : LoadPatGlobalAddrOffOnly<i64, extloadi32, "LOAD32_U_I64">;
 
 // Defines atomic and non-atomic stores, regular and truncating
-multiclass WebAssemblyStore<WebAssemblyRegClass rc, string Name, int Opcode> {
+multiclass WebAssemblyStore<WebAssemblyRegClass rc, string Name, int Opcode,
+                            list<Predicate> reqs = []> {
   let mayStore = 1, UseNamedOperandTable = 1 in
   defm "_A32" : I<(outs),
                   (ins P2Align:$p2align, offset32_op:$off, I32:$addr, rc:$val),
                   (outs),
                   (ins P2Align:$p2align, offset32_op:$off), [],
                   !strconcat(Name, "\t${off}(${addr})${p2align}, $val"),
-                  !strconcat(Name, "\t${off}${p2align}"), Opcode>;
+                  !strconcat(Name, "\t${off}${p2align}"), Opcode, "false">,
+                Requires<!listconcat(reqs, [HasAddr32])>;
   let mayStore = 1, UseNamedOperandTable = 1 in
   defm "_A64" : I<(outs),
                   (ins P2Align:$p2align, offset64_op:$off, I64:$addr, rc:$val),
                   (outs),
                   (ins P2Align:$p2align, offset64_op:$off), [],
                   !strconcat(Name, "\t${off}(${addr})${p2align}, $val"),
-                  !strconcat(Name, "\t${off}${p2align}"), Opcode>;
+                  !strconcat(Name, "\t${off}${p2align}"), Opcode, "true">,
+                Requires<!listconcat(reqs, [HasAddr64])>;
 }
 
 // Basic store.
 // Note: WebAssembly inverts SelectionDAG's usual operand order.
 defm STORE_I32  : WebAssemblyStore<I32, "i32.store", 0x36>;
 defm STORE_I64  : WebAssemblyStore<I64, "i64.store", 0x37>;
 defm STORE_F32  : WebAssemblyStore<F32, "f32.store", 0x38>;
 defm STORE_F64  : WebAssemblyStore<F64, "f64.store", 0x39>;

llvm/test/MC/WebAssembly/wasm64.s

 # RUN: llvm-mc -triple=wasm64-unknown-unknown -mattr=+atomics,+unimplemented-simd128,+nontrapping-fptoint,+exception-handling < %s | FileCheck %s
-# Check that it converts to .o without errors, but don't check any output:
-# RUN: llvm-mc -triple=wasm64-unknown-unknown -filetype=obj -mattr=+atomics,+unimplemented-simd128,+nontrapping-fptoint,+exception-handling -o %t.o < %s
+# RUN: llvm-mc -triple=wasm64-unknown-unknown -filetype=obj -mattr=+atomics,+unimplemented-simd128,+nontrapping-fptoint,+exception-handling -o - < %s | obj2yaml | FileCheck %s -check-prefix=BIN
 
 # Most of our other tests are for wasm32, this one adds some wasm64 specific tests.
 
 test:
     .functype   test (i64) -> ()
     .local      i64
 
     ### basic loads
 
     i64.const   0         # get i64 from constant.
     f32.load    0
     drop
 
     local.get   0         # get i64 from local.
     f32.load    0
     drop
 
-#    i64.const   .L.str    # get i64 relocatable.
-#    f32.load    0
-#    drop
+    i64.const   .L.str    # get i64 relocatable.
+    f32.load    0
+    drop
 
     global.get  myglob64  # get i64 from global
     f32.load    0
     drop
 
+    i64.const   0
+    f32.load    .L.str    # relocatable offset!
+    drop
+
     ### basic stores
 
     f32.const   0.0
     i64.const   0         # get i64 from constant.
     f32.store   0
 
     f32.const   0.0
     local.get   0         # get i64 from local.
     f32.store   0
 
-#    f32.const   0.0
-#    i64.const   .L.str    # get i64 relocatable.
-#    f32.store   0
+    f32.const   0.0
+    i64.const   .L.str    # get i64 relocatable.
+    f32.store   0
 
     f32.const   0.0
     global.get  myglob64  # get i64 from global
     f32.store   0
 
+    f32.const   0.0
+    i64.const   0
+    f32.store   .L.str    # relocatable offset!
+
     end_function
 
     .section    .rodata..L.str,"",@
     .hidden     .L.str
     .type       .L.str,@object
 .L.str:
-    .asciz      "Hello, World!"
+    .asciz      "Hello, World!!!"
+    .int64      .L.str    # relocatable inside data.
+    .size       .L.str, 24
 
     .globaltype myglob64, i64
 
 
 
 # CHECK:              .functype       test (i64) -> ()
 # CHECK-NEXT:         .local          i64
 
 
 # CHECK:              i64.const       0
 # CHECK-NEXT:         f32.load        0
 # CHECK-NEXT:         drop
 
 # CHECK:              local.get       0
 # CHECK-NEXT:         f32.load        0
 # CHECK-NEXT:         drop
 
-# NCHECK:              i64.const       .L.str
-# NCHECK-NEXT:         f32.load        0
-# NCHECK-NEXT:         drop
+# CHECK:              i64.const       .L.str
+# CHECK-NEXT:         f32.load        0
+# CHECK-NEXT:         drop
 
 # CHECK:              global.get      myglob64
 # CHECK-NEXT:         f32.load        0
 # CHECK-NEXT:         drop
 
+# CHECK:              i64.const       0
+# CHECK-NEXT:         f32.load        .L.str
+# CHECK-NEXT:         drop
+
 
 # CHECK:              f32.const       0x0p0
 # CHECK-NEXT:         i64.const       0
 # CHECK-NEXT:         f32.store       0
 
 # CHECK:              f32.const       0x0p0
 # CHECK-NEXT:         local.get       0
 # CHECK-NEXT:         f32.store       0
 
-# NCHECK:              f32.const       0x0p0
-# NCHECK-NEXT:         i64.const       .L.str
-# NCHECK-NEXT:         f32.store       0
+# CHECK:              f32.const       0x0p0
+# CHECK-NEXT:         i64.const       .L.str
+# CHECK-NEXT:         f32.store       0
 
 # CHECK:              f32.const       0x0p0
 # CHECK-NEXT:         global.get      myglob64
 # CHECK-NEXT:         f32.store       0
 
+# CHECK:              f32.const       0x0p0
+# CHECK-NEXT:         i64.const       0
+# CHECK-NEXT:         f32.store       .L.str
+
 
 # CHECK:              end_function
 # CHECK-NEXT: .Ltmp0:
 # CHECK-NEXT:         .size   test, .Ltmp0-test
 
 # CHECK:              .section        .rodata..L.str,"",@
 # CHECK-NEXT:         .hidden .L.str
 # CHECK-NEXT: .L.str:
-# CHECK-NEXT:         .asciz  "Hello, World!"
+# CHECK-NEXT:         .asciz  "Hello, World!!!"
+# CHECK-NEXT:         .int64      .L.str
+# CHECK-NEXT:         .size       .L.str, 24
 
 # CHECK:              .globaltype     myglob64, i64
+
+
+
+# BIN:      --- !WASM
+# BIN-NEXT: FileHeader:
+# BIN-NEXT:   Version:         0x00000001
+# BIN-NEXT: Sections:
+# BIN-NEXT:   - Type:            TYPE
+# BIN-NEXT:     Signatures:
+# BIN-NEXT:       - Index:           0
+# BIN-NEXT:         ParamTypes:
+# BIN-NEXT:           - I64
+# BIN-NEXT:         ReturnTypes:     []
+# BIN-NEXT:   - Type:            IMPORT
+# BIN-NEXT:     Imports:
+# BIN-NEXT:       - Module:          env
+# BIN-NEXT:         Field:           __linear_memory
+# BIN-NEXT:         Kind:            MEMORY
+# BIN-NEXT:         Memory:
+# BIN-NEXT:           Initial:         0x00000001
+# BIN-NEXT:       - Module:          env
+# BIN-NEXT:         Field:           __indirect_function_table
+# BIN-NEXT:         Kind:            TABLE
+# BIN-NEXT:         Table:
+# BIN-NEXT:           ElemType:        FUNCREF
+# BIN-NEXT:           Limits:
+# BIN-NEXT:             Initial:         0x00000000
+# BIN-NEXT:       - Module:          env
+# BIN-NEXT:         Field:           myglob64
+# BIN-NEXT:         Kind:            GLOBAL
+# BIN-NEXT:         GlobalType:      I64
+# BIN-NEXT:         GlobalMutable:   true
+# BIN-NEXT:   - Type:            FUNCTION
+# BIN-NEXT:     FunctionTypes:   [ 0 ]
+# BIN-NEXT:   - Type:            DATACOUNT
+# BIN-NEXT:     Count:           1
+# BIN-NEXT:   - Type:            CODE
+# BIN-NEXT:     Relocations:
+# BIN-NEXT:       - Type:            R_WASM_MEMORY_ADDR_SLEB64
+# BIN-NEXT:         Index:           1
+# BIN-NEXT:         Offset:          0x00000013
+# BIN-NEXT:       - Type:            R_WASM_GLOBAL_INDEX_LEB
+# BIN-NEXT:         Index:           2
+# BIN-NEXT:         Offset:          0x00000022
+# BIN-NEXT:       - Type:            R_WASM_MEMORY_ADDR_LEB64
+# BIN-NEXT:         Index:           1
+# BIN-NEXT:         Offset:          0x0000002F
+# BIN-NEXT:       - Type:            R_WASM_MEMORY_ADDR_SLEB64
+# BIN-NEXT:         Index:           1
+# BIN-NEXT:         Offset:          0x00000054
+# BIN-NEXT:       - Type:            R_WASM_GLOBAL_INDEX_LEB
+# BIN-NEXT:         Index:           2
+# BIN-NEXT:         Offset:          0x00000067
+# BIN-NEXT:       - Type:            R_WASM_MEMORY_ADDR_LEB64
+# BIN-NEXT:         Index:           1
+# BIN-NEXT:         Offset:          0x00000078
+# BIN-NEXT:     Functions:
+# BIN-NEXT:       - Index:           0
+# BIN-NEXT:         Locals:
+# BIN-NEXT:           - Type:            I64
+# BIN-NEXT:             Count:           1
+# BIN-NEXT:         Body:            42002A02001A20002A02001A42808080808080808080002A02001A2380808080002A02001A42002A02808080808080808080001A4300000000420038020043000000002000380200430000000042808080808080808080003802004300000000238080808000380200430000000042003802808080808080808080000B
+# BIN-NEXT:   - Type:            DATA
+# BIN-NEXT:     Relocations:
+# BIN-NEXT:       - Type:            R_WASM_MEMORY_ADDR_I64
+# BIN-NEXT:         Index:           1
+# BIN-NEXT:         Offset:          0x00000016
+# BIN-NEXT:     Segments:
+# BIN-NEXT:       - SectionOffset:   6
+# BIN-NEXT:         InitFlags:       0
+# BIN-NEXT:         Offset:
+# BIN-NEXT:           Opcode:          I32_CONST
+# BIN-NEXT:           Value:           0
+# BIN-NEXT:         Content:         48656C6C6F2C20576F726C64212121000000000000000000
+# BIN-NEXT:   - Type:            CUSTOM
+# BIN-NEXT:     Name:            linking
+# BIN-NEXT:     Version:         2
+# BIN-NEXT:     SymbolTable:
+# BIN-NEXT:       - Index:           0
+# BIN-NEXT:         Kind:            FUNCTION
+# BIN-NEXT:         Name:            test
+# BIN-NEXT:         Flags:           [ BINDING_LOCAL ]
+# BIN-NEXT:         Function:        0
+# BIN-NEXT:       - Index:           1
+# BIN-NEXT:         Kind:            DATA
+# BIN-NEXT:         Name:            .L.str
+# BIN-NEXT:         Flags:           [ BINDING_LOCAL, VISIBILITY_HIDDEN ]
+# BIN-NEXT:         Segment:         0
+# BIN-NEXT:         Size:            24
+# BIN-NEXT:       - Index:           2
+# BIN-NEXT:         Kind:            GLOBAL
+# BIN-NEXT:         Name:            myglob64
+# BIN-NEXT:         Flags:           [ UNDEFINED ]
+# BIN-NEXT:         Global:          0
+# BIN-NEXT:     SegmentInfo:
+# BIN-NEXT:       - Index:           0
+# BIN-NEXT:         Name:            .rodata..L.str
+# BIN-NEXT:         Alignment:       0
+# BIN-NEXT:         Flags:           [  ]
+# BIN-NEXT: ...

llvm/tools/llvm-readobj/WasmDumper.cpp

case wasm::WASM_SEC_DATA: {
       ListScope Group(W, "Segments");
       for (const WasmSegment &Segment : Obj->dataSegments()) {
         const wasm::WasmDataSegment &Seg = Segment.Data;
         DictScope Group(W, "Segment");
         if (!Seg.Name.empty())
           W.printString("Name", Seg.Name);
         W.printNumber("Size", static_cast<uint64_t>(Seg.Content.size()));
         if (Seg.Offset.Opcode == wasm::WASM_OPCODE_I32_CONST)
-          W.printNumber("Offset", Seg.Offset.Value.Int32);
+          W.printNumber("Offset", Seg.Offset.Value.Int64);
       }
       break;
     }
     case wasm::WASM_SEC_MEMORY:
       ListScope Group(W, "Memories");
       for (const wasm::WasmLimits &Memory : Obj->memories()) {
         DictScope Group(W, "Memory");
         W.printNumber("InitialPages", Memory.Initial);