[WebAssembly] Rename relocations from R_WEBASSEMBLY_ to R_WASM_. NFC

[sbc100]

Summary

See https://github.com/WebAssembly/tool-conventions/pull/95.

This is less typing and IMHO more readable, and it also fits with
our naming around the binary format which tends to use the short name.
e.g.

include/llvm/BinaryFormat/Wasm.h
tools/llvm-objdump/WasmDump.cpp
etc..

include/llvm/BinaryFormat/WasmRelocs.def

 #ifndef WASM_RELOC
 #error "WASM_RELOC must be defined"
 #endif
 
-WASM_RELOC(R_WEBASSEMBLY_FUNCTION_INDEX_LEB,   0)
-WASM_RELOC(R_WEBASSEMBLY_TABLE_INDEX_SLEB,     1)
-WASM_RELOC(R_WEBASSEMBLY_TABLE_INDEX_I32,      2)
-WASM_RELOC(R_WEBASSEMBLY_MEMORY_ADDR_LEB,      3)
-WASM_RELOC(R_WEBASSEMBLY_MEMORY_ADDR_SLEB,     4)
-WASM_RELOC(R_WEBASSEMBLY_MEMORY_ADDR_I32,      5)
-WASM_RELOC(R_WEBASSEMBLY_TYPE_INDEX_LEB,       6)
-WASM_RELOC(R_WEBASSEMBLY_GLOBAL_INDEX_LEB,     7)
-WASM_RELOC(R_WEBASSEMBLY_FUNCTION_OFFSET_I32,  8)
-WASM_RELOC(R_WEBASSEMBLY_SECTION_OFFSET_I32,   9)
-WASM_RELOC(R_WEBASSEMBLY_EVENT_INDEX_LEB,     10)
+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)

include/llvm/Object/RelocVisitor.h

if (ObjToVisit.getArch() == Triple::x86_64 &&
       return Value;
     HasError = true;
     return 0;
   }
 
   uint64_t visitWasm(uint32_t Rel, RelocationRef R, uint64_t Value) {
     if (ObjToVisit.getArch() == Triple::wasm32) {
       switch (Rel) {
-      case wasm::R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
-      case wasm::R_WEBASSEMBLY_TABLE_INDEX_SLEB:
-      case wasm::R_WEBASSEMBLY_TABLE_INDEX_I32:
-      case wasm::R_WEBASSEMBLY_MEMORY_ADDR_LEB:
-      case wasm::R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
-      case wasm::R_WEBASSEMBLY_MEMORY_ADDR_I32:
-      case wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB:
-      case wasm::R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
-      case wasm::R_WEBASSEMBLY_FUNCTION_OFFSET_I32:
-      case wasm::R_WEBASSEMBLY_SECTION_OFFSET_I32:
-      case wasm::R_WEBASSEMBLY_EVENT_INDEX_LEB:
+      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_SLEB:
+      case wasm::R_WASM_MEMORY_ADDR_I32:
+      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:
         // For wasm section, its offset at 0 -- ignoring Value
         return 0;
       }
     }
     HasError = true;
     return 0;
   }
 };
 
 } // end namespace object
 } // end namespace llvm
 
 #endif // LLVM_OBJECT_RELOCVISITOR_H

lib/MC/WasmObjectWriter.cpp

struct WasmRelocationEntry {
   WasmRelocationEntry(uint64_t Offset, const MCSymbolWasm *Symbol,
                       int64_t Addend, unsigned Type,
                       const MCSectionWasm *FixupSection)
       : Offset(Offset), Symbol(Symbol), Addend(Addend), Type(Type),
         FixupSection(FixupSection) {}
 
   bool hasAddend() const {
     switch (Type) {
-    case wasm::R_WEBASSEMBLY_MEMORY_ADDR_LEB:
-    case wasm::R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
-    case wasm::R_WEBASSEMBLY_MEMORY_ADDR_I32:
-    case wasm::R_WEBASSEMBLY_FUNCTION_OFFSET_I32:
-    case wasm::R_WEBASSEMBLY_SECTION_OFFSET_I32:
+    case wasm::R_WASM_MEMORY_ADDR_LEB:
+    case wasm::R_WASM_MEMORY_ADDR_SLEB:
+    case wasm::R_WASM_MEMORY_ADDR_I32:
+    case wasm::R_WASM_FUNCTION_OFFSET_I32:
+    case wasm::R_WASM_SECTION_OFFSET_I32:
       return true;
     default:
       return false;
     }
   }
 
   void print(raw_ostream &Out) const {
     Out << wasm::relocTypetoString(Type) << " Off=" << Offset
void WasmObjectWriter::recordRelocation(MCAssembler &Asm,
 
   unsigned Type = getRelocType(Target, Fixup);
   assert(!IsPCRel);
   assert(SymA);
 
   // Absolute offset within a section or a function.
   // Currently only supported for for metadata sections.
   // See: test/MC/WebAssembly/blockaddress.ll
-  if (Type == wasm::R_WEBASSEMBLY_FUNCTION_OFFSET_I32 ||
-      Type == wasm::R_WEBASSEMBLY_SECTION_OFFSET_I32) {
+  if (Type == wasm::R_WASM_FUNCTION_OFFSET_I32 ||
+      Type == wasm::R_WASM_SECTION_OFFSET_I32) {
     if (!FixupSection.getKind().isMetadata())
       report_fatal_error("relocations for function or section offsets are "
                          "only supported in metadata sections");
 
     const MCSymbol *SectionSymbol = nullptr;
     const MCSection &SecA = SymA->getSection();
     if (SecA.getKind().isText())
       SectionSymbol = SectionFunctions.find(&SecA)->second;
     else
       SectionSymbol = SecA.getBeginSymbol();
     if (!SectionSymbol)
       report_fatal_error("section symbol is required for relocation");
 
     C += Layout.getSymbolOffset(*SymA);
     SymA = cast<MCSymbolWasm>(SectionSymbol);
   }
 
-  // Relocation other than R_WEBASSEMBLY_TYPE_INDEX_LEB are required to be
+  // Relocation other than R_WASM_TYPE_INDEX_LEB are required to be
   // against a named symbol.
-  if (Type != wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB) {
+  if (Type != wasm::R_WASM_TYPE_INDEX_LEB) {
     if (SymA->getName().empty())
       report_fatal_error("relocations against un-named temporaries are not yet "
                          "supported by wasm");
 
     SymA->setUsedInReloc();
   }
 
   WasmRelocationEntry Rec(FixupOffset, SymA, C, Type, &FixupSection);

 
 // 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
 WasmObjectWriter::getProvisionalValue(const WasmRelocationEntry &RelEntry) {
   switch (RelEntry.Type) {
-  case wasm::R_WEBASSEMBLY_TABLE_INDEX_SLEB:
-  case wasm::R_WEBASSEMBLY_TABLE_INDEX_I32: {
+  case wasm::R_WASM_TABLE_INDEX_SLEB:
+  case wasm::R_WASM_TABLE_INDEX_I32: {
     // Provisional value is table address of the resolved symbol itself
     const MCSymbolWasm *Sym = ResolveSymbol(*RelEntry.Symbol);
     assert(Sym->isFunction());
     return TableIndices[Sym];
   }
-  case wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB:
+  case wasm::R_WASM_TYPE_INDEX_LEB:
     // Provisional value is same as the index
     return getRelocationIndexValue(RelEntry);
-  case wasm::R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
-  case wasm::R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
-  case wasm::R_WEBASSEMBLY_EVENT_INDEX_LEB:
+  case wasm::R_WASM_FUNCTION_INDEX_LEB:
+  case wasm::R_WASM_GLOBAL_INDEX_LEB:
+  case wasm::R_WASM_EVENT_INDEX_LEB:
     // Provisional value is function/global/event Wasm index
     if (!WasmIndices.count(RelEntry.Symbol))
       report_fatal_error("symbol not found in wasm index space: " +
                          RelEntry.Symbol->getName());
     return WasmIndices[RelEntry.Symbol];
-  case wasm::R_WEBASSEMBLY_FUNCTION_OFFSET_I32:
-  case wasm::R_WEBASSEMBLY_SECTION_OFFSET_I32: {
+  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_WEBASSEMBLY_MEMORY_ADDR_LEB:
-  case wasm::R_WEBASSEMBLY_MEMORY_ADDR_I32:
-  case wasm::R_WEBASSEMBLY_MEMORY_ADDR_SLEB: {
+  case wasm::R_WASM_MEMORY_ADDR_LEB:
+  case wasm::R_WASM_MEMORY_ADDR_I32:
+  case wasm::R_WASM_MEMORY_ADDR_SLEB: {
     // 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.
for (const MCFragment &Frag : DataSection) {
     }
   }
 
   LLVM_DEBUG(dbgs() << "addData -> " << DataBytes.size() << "\n");
 }
 
 uint32_t
 WasmObjectWriter::getRelocationIndexValue(const WasmRelocationEntry &RelEntry) {
-  if (RelEntry.Type == wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB) {
+  if (RelEntry.Type == wasm::R_WASM_TYPE_INDEX_LEB) {
     if (!TypeIndices.count(RelEntry.Symbol))
       report_fatal_error("symbol not found in type index space: " +
                          RelEntry.Symbol->getName());
     return TypeIndices[RelEntry.Symbol];
   }
 
   return RelEntry.Symbol->getIndex();
 }
 
 // Apply the portions of the relocation records that we can handle ourselves
 // directly.
 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);
 
     switch (RelEntry.Type) {
-    case wasm::R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
-    case wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB:
-    case wasm::R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
-    case wasm::R_WEBASSEMBLY_MEMORY_ADDR_LEB:
-    case wasm::R_WEBASSEMBLY_EVENT_INDEX_LEB:
+    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);
       break;
-    case wasm::R_WEBASSEMBLY_TABLE_INDEX_I32:
-    case wasm::R_WEBASSEMBLY_MEMORY_ADDR_I32:
-    case wasm::R_WEBASSEMBLY_FUNCTION_OFFSET_I32:
-    case wasm::R_WEBASSEMBLY_SECTION_OFFSET_I32:
+    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:
       WriteI32(Stream, Value, Offset);
       break;
-    case wasm::R_WEBASSEMBLY_TABLE_INDEX_SLEB:
-    case wasm::R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
+    case wasm::R_WASM_TABLE_INDEX_SLEB:
+    case wasm::R_WASM_MEMORY_ADDR_SLEB:
       WritePatchableSLEB(Stream, Value, Offset);
       break;
     default:
       llvm_unreachable("invalid relocation type");
     }
   }
 }
 
for (const MCSymbol &S : Asm.symbols()) {
     SymbolInfos.emplace_back(Info);
   }
 
   {
     auto HandleReloc = [&](const WasmRelocationEntry &Rel) {
       // Functions referenced by a relocation need to put in the table.  This is
       // purely to make the object file's provisional values readable, and is
       // ignored by the linker, which re-calculates the relocations itself.
-      if (Rel.Type != wasm::R_WEBASSEMBLY_TABLE_INDEX_I32 &&
-          Rel.Type != wasm::R_WEBASSEMBLY_TABLE_INDEX_SLEB)
+      if (Rel.Type != wasm::R_WASM_TABLE_INDEX_I32 &&
+          Rel.Type != wasm::R_WASM_TABLE_INDEX_SLEB)
         return;
       assert(Rel.Symbol->isFunction());
       const MCSymbolWasm &WS = *ResolveSymbol(*Rel.Symbol);
       uint32_t FunctionIndex = WasmIndices.find(&WS)->second;
       uint32_t TableIndex = TableElems.size() + kInitialTableOffset;
       if (TableIndices.try_emplace(&WS, TableIndex).second) {
         LLVM_DEBUG(dbgs() << "  -> adding " << WS.getName()
                           << " to table: " << TableIndex << "\n");

lib/Object/WasmObjectFile.cpp

while (RelocCount--) {
     Reloc.Type = readVaruint32(Ctx);
     Reloc.Offset = readVaruint32(Ctx);
     if (Reloc.Offset < PreviousOffset)
       return make_error<GenericBinaryError>("Relocations not in offset order",
                                             object_error::parse_failed);
     PreviousOffset = Reloc.Offset;
     Reloc.Index = readVaruint32(Ctx);
     switch (Reloc.Type) {
-    case wasm::R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
-    case wasm::R_WEBASSEMBLY_TABLE_INDEX_SLEB:
-    case wasm::R_WEBASSEMBLY_TABLE_INDEX_I32:
+    case wasm::R_WASM_FUNCTION_INDEX_LEB:
+    case wasm::R_WASM_TABLE_INDEX_SLEB:
+    case wasm::R_WASM_TABLE_INDEX_I32:
       if (!isValidFunctionSymbol(Reloc.Index))
         return make_error<GenericBinaryError>("Bad relocation function index",
                                               object_error::parse_failed);
       break;
-    case wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB:
+    case wasm::R_WASM_TYPE_INDEX_LEB:
       if (Reloc.Index >= Signatures.size())
         return make_error<GenericBinaryError>("Bad relocation type index",
                                               object_error::parse_failed);
       break;
-    case wasm::R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
+    case wasm::R_WASM_GLOBAL_INDEX_LEB:
       if (!isValidGlobalSymbol(Reloc.Index))
         return make_error<GenericBinaryError>("Bad relocation global index",
                                               object_error::parse_failed);
       break;
-    case wasm::R_WEBASSEMBLY_EVENT_INDEX_LEB:
+    case wasm::R_WASM_EVENT_INDEX_LEB:
       if (!isValidEventSymbol(Reloc.Index))
         return make_error<GenericBinaryError>("Bad relocation event index",
                                               object_error::parse_failed);
       break;
-    case wasm::R_WEBASSEMBLY_MEMORY_ADDR_LEB:
-    case wasm::R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
-    case wasm::R_WEBASSEMBLY_MEMORY_ADDR_I32:
+    case wasm::R_WASM_MEMORY_ADDR_LEB:
+    case wasm::R_WASM_MEMORY_ADDR_SLEB:
+    case wasm::R_WASM_MEMORY_ADDR_I32:
       if (!isValidDataSymbol(Reloc.Index))
         return make_error<GenericBinaryError>("Bad relocation data index",
                                               object_error::parse_failed);
       Reloc.Addend = readVarint32(Ctx);
       break;
-    case wasm::R_WEBASSEMBLY_FUNCTION_OFFSET_I32:
+    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_WEBASSEMBLY_SECTION_OFFSET_I32:
+    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_WEBASSEMBLY_TABLE_INDEX_I32 ||
-        Reloc.Type == wasm::R_WEBASSEMBLY_MEMORY_ADDR_I32 ||
-        Reloc.Type == wasm::R_WEBASSEMBLY_SECTION_OFFSET_I32 ||
-        Reloc.Type == wasm::R_WEBASSEMBLY_FUNCTION_OFFSET_I32)
+    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)
       Size = 4;
     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)

 
 uint64_t WasmObjectFile::getRelocationOffset(DataRefImpl Ref) const {
   const wasm::WasmRelocation &Rel = getWasmRelocation(Ref);
   return Rel.Offset;
 }
 
 symbol_iterator WasmObjectFile::getRelocationSymbol(DataRefImpl Ref) const {
   const wasm::WasmRelocation &Rel = getWasmRelocation(Ref);
-  if (Rel.Type == wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB)
+  if (Rel.Type == wasm::R_WASM_TYPE_INDEX_LEB)
     return symbol_end();
   DataRefImpl Sym;
   Sym.d.a = 1;
   Sym.d.b = Rel.Index;
   return symbol_iterator(SymbolRef(Sym, this));
 }
 
 uint64_t WasmObjectFile::getRelocationType(DataRefImpl Ref) const {

lib/Target/WebAssembly/MCTargetDesc/WebAssemblyWasmObjectWriter.cpp

unsigned WebAssemblyWasmObjectWriter::getRelocType(const MCValue &Target,
                                                    const MCFixup &Fixup) const {
   // WebAssembly functions are not allocated in the data address space. To
   // resolve a pointer to a function, we must use a special relocation type.
   bool IsFunction = IsFunctionExpr(Fixup.getValue());
 
   switch (unsigned(Fixup.getKind())) {
   case WebAssembly::fixup_code_sleb128_i32:
     if (IsFunction)
-      return wasm::R_WEBASSEMBLY_TABLE_INDEX_SLEB;
-    return wasm::R_WEBASSEMBLY_MEMORY_ADDR_SLEB;
+      return wasm::R_WASM_TABLE_INDEX_SLEB;
+    return wasm::R_WASM_MEMORY_ADDR_SLEB;
   case WebAssembly::fixup_code_sleb128_i64:
     llvm_unreachable("fixup_sleb128_i64 not implemented yet");
   case WebAssembly::fixup_code_uleb128_i32:
     if (IsGlobalType(Target))
-      return wasm::R_WEBASSEMBLY_GLOBAL_INDEX_LEB;
+      return wasm::R_WASM_GLOBAL_INDEX_LEB;
     if (IsFunctionType(Target))
-      return wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB;
+      return wasm::R_WASM_TYPE_INDEX_LEB;
     if (IsFunction)
-      return wasm::R_WEBASSEMBLY_FUNCTION_INDEX_LEB;
+      return wasm::R_WASM_FUNCTION_INDEX_LEB;
     if (IsEventType(Target))
-      return wasm::R_WEBASSEMBLY_EVENT_INDEX_LEB;
-    return wasm::R_WEBASSEMBLY_MEMORY_ADDR_LEB;
+      return wasm::R_WASM_EVENT_INDEX_LEB;
+    return wasm::R_WASM_MEMORY_ADDR_LEB;
   case FK_Data_4:
     if (IsFunction)
-      return wasm::R_WEBASSEMBLY_TABLE_INDEX_I32;
+      return wasm::R_WASM_TABLE_INDEX_I32;
     if (auto Section = static_cast<const MCSectionWasm *>(
             GetFixupSection(Fixup.getValue()))) {
       if (Section->getKind().isText())
-        return wasm::R_WEBASSEMBLY_FUNCTION_OFFSET_I32;
+        return wasm::R_WASM_FUNCTION_OFFSET_I32;
       else if (!Section->isWasmData())
-        return wasm::R_WEBASSEMBLY_SECTION_OFFSET_I32;
+        return wasm::R_WASM_SECTION_OFFSET_I32;
     }
-    return wasm::R_WEBASSEMBLY_MEMORY_ADDR_I32;
+    return wasm::R_WASM_MEMORY_ADDR_I32;
   case FK_Data_8:
     llvm_unreachable("FK_Data_8 not implemented yet");
   default:
     llvm_unreachable("unimplemented fixup kind");
   }
 }
 
 std::unique_ptr<MCObjectTargetWriter>
 llvm::createWebAssemblyWasmObjectWriter(bool Is64Bit) {
   return llvm::make_unique<WebAssemblyWasmObjectWriter>(Is64Bit);
 }

test/MC/WebAssembly/assembler-binary.ll

 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           bar
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         SigIndex:        1
 ; CHECK-NEXT:   - Type:            FUNCTION
 ; CHECK-NEXT:     FunctionTypes:   [ 0 ]
 ; CHECK-NEXT:   - Type:            CODE
 ; CHECK-NEXT:     Relocations:
-; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
+; CHECK-NEXT:       - Type:            R_WASM_FUNCTION_INDEX_LEB
 ; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000004
 ; CHECK-NEXT:     Functions:
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Locals:          []
 ; CHECK-NEXT:         Body:            1080808080000B
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking

test/MC/WebAssembly/comdat.ll

 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           funcImport
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         SigIndex:        0
 ; CHECK-NEXT:   - Type:            FUNCTION
 ; CHECK-NEXT:     FunctionTypes:   [ 0, 0, 0 ]
 ; CHECK-NEXT:  - Type:            CODE
 ; CHECK-NEXT:    Relocations:
-; CHECK-NEXT:      - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
+; CHECK-NEXT:      - Type:            R_WASM_FUNCTION_INDEX_LEB
 ; CHECK-NEXT:        Index:           1
 ; CHECK-NEXT:        Offset:          0x00000004
 ; CHECK-NEXT:    Functions:
 ; CHECK-NEXT:      - Index:           1
 ; CHECK-NEXT:        Locals:
 ; CHECK-NEXT:        Body:            1080808080000B
 ; CHECK-NEXT:      - Index:           2
 ; CHECK-NEXT:        Locals:

test/MC/WebAssembly/debug-info.ll

 ; CHECK-NEXT:    Type: CUSTOM (0x0)
 ; CHECK-NEXT:    Size: 77
 ; CHECK-NEXT:    Offset: 1021
 ; CHECK-NEXT:    Name: producers
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:]
 ; CHECK-NEXT:Relocations [
 ; CHECK-NEXT:  Section (6) DATA {
-; CHECK-NEXT:    0x6 R_WEBASSEMBLY_MEMORY_ADDR_I32 myextern 0
-; CHECK-NEXT:    0xF R_WEBASSEMBLY_TABLE_INDEX_I32 f2
+; CHECK-NEXT:    0x6 R_WASM_MEMORY_ADDR_I32 myextern 0
+; CHECK-NEXT:    0xF R_WASM_TABLE_INDEX_I32 f2
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section (9) .debug_info {
-; CHECK-NEXT:    0x6 R_WEBASSEMBLY_SECTION_OFFSET_I32 .debug_abbrev 0
-; CHECK-NEXT:    0xC R_WEBASSEMBLY_SECTION_OFFSET_I32 .debug_str 0
-; CHECK-NEXT:    0x12 R_WEBASSEMBLY_SECTION_OFFSET_I32 .debug_str 55
-; CHECK-NEXT:    0x16 R_WEBASSEMBLY_SECTION_OFFSET_I32 .debug_line 0
-; CHECK-NEXT:    0x1A R_WEBASSEMBLY_SECTION_OFFSET_I32 .debug_str 62
-; CHECK-NEXT:    0x1E R_WEBASSEMBLY_FUNCTION_OFFSET_I32 f2 0
-; CHECK-NEXT:    0x27 R_WEBASSEMBLY_SECTION_OFFSET_I32 .debug_str 105
-; CHECK-NEXT:    0x33 R_WEBASSEMBLY_MEMORY_ADDR_I32 foo 0
-; CHECK-NEXT:    0x3D R_WEBASSEMBLY_SECTION_OFFSET_I32 .debug_str 109
-; CHECK-NEXT:    0x44 R_WEBASSEMBLY_SECTION_OFFSET_I32 .debug_str 113
-; CHECK-NEXT:    0x50 R_WEBASSEMBLY_MEMORY_ADDR_I32 ptr2 0
-; CHECK-NEXT:    0x5B R_WEBASSEMBLY_FUNCTION_OFFSET_I32 f2 0
-; CHECK-NEXT:    0x63 R_WEBASSEMBLY_SECTION_OFFSET_I32 .debug_str 118
+; CHECK-NEXT:    0x6 R_WASM_SECTION_OFFSET_I32 .debug_abbrev 0
+; CHECK-NEXT:    0xC R_WASM_SECTION_OFFSET_I32 .debug_str 0
+; CHECK-NEXT:    0x12 R_WASM_SECTION_OFFSET_I32 .debug_str 55
+; CHECK-NEXT:    0x16 R_WASM_SECTION_OFFSET_I32 .debug_line 0
+; CHECK-NEXT:    0x1A R_WASM_SECTION_OFFSET_I32 .debug_str 62
+; CHECK-NEXT:    0x1E R_WASM_FUNCTION_OFFSET_I32 f2 0
+; CHECK-NEXT:    0x27 R_WASM_SECTION_OFFSET_I32 .debug_str 105
+; CHECK-NEXT:    0x33 R_WASM_MEMORY_ADDR_I32 foo 0
+; CHECK-NEXT:    0x3D R_WASM_SECTION_OFFSET_I32 .debug_str 109
+; CHECK-NEXT:    0x44 R_WASM_SECTION_OFFSET_I32 .debug_str 113
+; CHECK-NEXT:    0x50 R_WASM_MEMORY_ADDR_I32 ptr2 0
+; CHECK-NEXT:    0x5B R_WASM_FUNCTION_OFFSET_I32 f2 0
+; CHECK-NEXT:    0x63 R_WASM_SECTION_OFFSET_I32 .debug_str 118
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section (11) .debug_pubnames {
-; CHECK-NEXT:    0x6 R_WEBASSEMBLY_SECTION_OFFSET_I32 .debug_info 0
+; CHECK-NEXT:    0x6 R_WASM_SECTION_OFFSET_I32 .debug_info 0
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section (12) .debug_pubtypes {
-; CHECK-NEXT:    0x6 R_WEBASSEMBLY_SECTION_OFFSET_I32 .debug_info 0
+; CHECK-NEXT:    0x6 R_WASM_SECTION_OFFSET_I32 .debug_info 0
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section (13) .debug_line {
-; CHECK-NEXT:    0x2B R_WEBASSEMBLY_FUNCTION_OFFSET_I32 f2 0
+; CHECK-NEXT:    0x2B R_WASM_FUNCTION_OFFSET_I32 f2 0
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:]
 ; CHECK-NEXT:Symbols [
 ; CHECK-NEXT:  Symbol {
 ; CHECK-NEXT:    Name: f2
 ; CHECK-NEXT:    Type: FUNCTION (0x0)
 ; CHECK-NEXT:    Flags: 0x4
 ; CHECK-NEXT:  }

test/MC/WebAssembly/event-section.ll

 ; CHECK:        - Type:            EVENT
 ; CHECK-NEXT:     Events:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Attribute:       0
 ; CHECK-NEXT:         SigIndex:        1
 
 ; CHECK-NEXT:   - Type:            CODE
 ; CHECK-NEXT:     Relocations:
-; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_EVENT_INDEX_LEB
+; CHECK-NEXT:       - Type:            R_WASM_EVENT_INDEX_LEB
 ; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000006
-; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_EVENT_INDEX_LEB
+; CHECK-NEXT:       - Type:            R_WASM_EVENT_INDEX_LEB
 ; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000011
 
 ; CHECK:        - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     Version:         2
 ; CHECK-NEXT:     SymbolTable:
 

test/MC/WebAssembly/external-data.ll

 ; RUN: llc -filetype=obj %s -o - | obj2yaml | FileCheck %s
 
 target triple = "wasm32-unknown-unknown"
 
 ; Verify relocations are correctly generated for addresses of externals
 ; in the data section.
 
 @myimport = external global i32, align 4
 
 @foo = global i64 7, align 4
 @bar = hidden global i32* @myimport, align 4
 
 ; CHECK:        - Type:            DATA
 ; CHECK-NEXT:     Relocations:
-; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_I32
+; CHECK-NEXT:       - Type:            R_WASM_MEMORY_ADDR_I32
 ; CHECK-NEXT:         Index:           2
 ; CHECK-NEXT:         Offset:          0x00000013
 ; CHECK-NEXT:     Segments:
 ; CHECK-NEXT:       - SectionOffset:   6
 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           0
 ; CHECK-NEXT:         Content:         '0700000000000000'
 ; CHECK-NEXT:       - SectionOffset:   19
 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:          
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           8
 ; CHECK-NEXT:         Content:         '00000000'

test/MC/WebAssembly/external-func-address.ll

 ; CHECK:        - Type:            ELEM
 ; CHECK-NEXT:     Segments:
 ; CHECK-NEXT:       - Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1
 ; CHECK-NEXT:         Functions:       [ 1, 2 ]
 ; CHECK:        - Type:            DATA
 ; CHECK-NEXT:     Relocations:
-; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_I32
+; CHECK-NEXT:       - Type:            R_WASM_TABLE_INDEX_I32
 ; CHECK-NEXT:         Index:           3
 ; CHECK-NEXT:         Offset:          0x00000006

test/MC/WebAssembly/func-address.ll

 }
 
 ; CHECK:          Type: ELEM (0x9)
 ; CHECK-NEXT:     Size: 7
 
 ; CHECK:      Relocations [
 ; CHECK-NEXT:   Section (5) CODE {
 ; CHECK-NEXT:     Relocation {
-; CHECK-NEXT:       Type: R_WEBASSEMBLY_FUNCTION_INDEX_LEB (0)
+; CHECK-NEXT:       Type: R_WASM_FUNCTION_INDEX_LEB (0)
 ; CHECK-NEXT:       Offset: 0x4
 ; CHECK-NEXT:       Symbol: import1
 ; CHECK-NEXT:     }
 ; CHECK-NEXT:     Relocation {
-; CHECK-NEXT:       Type: R_WEBASSEMBLY_FUNCTION_INDEX_LEB (0)
+; CHECK-NEXT:       Type: R_WASM_FUNCTION_INDEX_LEB (0)
 ; CHECK-NEXT:       Offset: 0xB
 ; CHECK-NEXT:       Symbol: import2
 ; CHECK-NEXT:     }
 ; CHECK-NEXT:     Relocation {
-; CHECK-NEXT:       Type: R_WEBASSEMBLY_GLOBAL_INDEX_LEB (7)
+; CHECK-NEXT:       Type: R_WASM_GLOBAL_INDEX_LEB (7)
 ; CHECK-NEXT:       Offset: 0x15
 ; CHECK-NEXT:       Symbol: __stack_pointer
 ; CHECK-NEXT:     }
 ; CHECK-NEXT:     Relocation {
-; CHECK-NEXT:       Type: R_WEBASSEMBLY_TABLE_INDEX_SLEB (1)
+; CHECK-NEXT:       Type: R_WASM_TABLE_INDEX_SLEB (1)
 ; CHECK-NEXT:       Offset: 0x1E
 ; CHECK-NEXT:       Symbol: import3
 ; CHECK-NEXT:     }
 ; CHECK-NEXT:   }
 ; CHECK-NEXT: ]

test/MC/WebAssembly/global-ctor-dtor.ll

 ; CHECK-NEXT:   - Type:            ELEM
 ; CHECK-NEXT:     Segments:        
 ; CHECK-NEXT:       - Offset:          
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1
 ; CHECK-NEXT:         Functions:       [ 5, 7 ]
 ; CHECK-NEXT:   - Type:            CODE
 ; CHECK-NEXT:     Relocations:     
-; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
+; CHECK-NEXT:       - Type:            R_WASM_FUNCTION_INDEX_LEB
 ; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000004
-; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_SLEB
+; CHECK-NEXT:       - Type:            R_WASM_TABLE_INDEX_SLEB
 ; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:         Offset:          0x0000000F
-; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_SLEB
+; CHECK-NEXT:       - Type:            R_WASM_MEMORY_ADDR_SLEB
 ; CHECK-NEXT:         Index:           3
 ; CHECK-NEXT:         Offset:          0x00000017
-; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
+; CHECK-NEXT:       - Type:            R_WASM_FUNCTION_INDEX_LEB
 ; CHECK-NEXT:         Index:           4
 ; CHECK-NEXT:         Offset:          0x0000001D
-; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
+; CHECK-NEXT:       - Type:            R_WASM_FUNCTION_INDEX_LEB
 ; CHECK-NEXT:         Index:           6
 ; CHECK-NEXT:         Offset:          0x0000002C
-; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_SLEB
+; CHECK-NEXT:       - Type:            R_WASM_TABLE_INDEX_SLEB
 ; CHECK-NEXT:         Index:           5
 ; CHECK-NEXT:         Offset:          0x00000037
-; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_SLEB
+; CHECK-NEXT:       - Type:            R_WASM_MEMORY_ADDR_SLEB
 ; CHECK-NEXT:         Index:           3
 ; CHECK-NEXT:         Offset:          0x0000003F
-; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
+; CHECK-NEXT:       - Type:            R_WASM_FUNCTION_INDEX_LEB
 ; CHECK-NEXT:         Index:           4
 ; CHECK-NEXT:         Offset:          0x00000045
 ; CHECK-NEXT:     Functions:       
 ; CHECK-NEXT:       - Index:           5
 ; CHECK-NEXT:         Locals:          
 ; CHECK-NEXT:         Body:            1080808080000B
 ; CHECK-NEXT:       - Index:           6
 ; CHECK-NEXT:         Locals:          

test/MC/WebAssembly/reloc-code.ll

entry:
     ret i32 %tmp2
 }
 
 
 ; CHECK: Format: WASM
 ; CHECK: Relocations [
 ; CHECK-NEXT:   Section (4) CODE {
 ; CHECK-NEXT:     Relocation {
-; CHECK-NEXT:       Type: R_WEBASSEMBLY_MEMORY_ADDR_LEB (3)
+; CHECK-NEXT:       Type: R_WASM_MEMORY_ADDR_LEB (3)
 ; CHECK-NEXT:       Offset: 0x9
 ; CHECK-NEXT:       Symbol: b
 ; CHECK-NEXT:       Addend: 0
 ; CHECK-NEXT:     }
 ; CHECK-NEXT:     Relocation {
-; CHECK-NEXT:       Type: R_WEBASSEMBLY_MEMORY_ADDR_LEB (3)
+; CHECK-NEXT:       Type: R_WASM_MEMORY_ADDR_LEB (3)
 ; CHECK-NEXT:       Offset: 0x14
 ; CHECK-NEXT:       Symbol: a
 ; CHECK-NEXT:       Addend: 0
 ; CHECK-NEXT:     }
 ; CHECK-NEXT:     Relocation {
-; CHECK-NEXT:       Type: R_WEBASSEMBLY_TYPE_INDEX_LEB (6)
+; CHECK-NEXT:       Type: R_WASM_TYPE_INDEX_LEB (6)
 ; CHECK-NEXT:       Offset: 0x1A
 ; CHECK-NEXT:       Index: 0x1
 ; CHECK-NEXT:     }
 ; CHECK-NEXT:     Relocation {
-; CHECK-NEXT:       Type: R_WEBASSEMBLY_TYPE_INDEX_LEB (6)
+; CHECK-NEXT:       Type: R_WASM_TYPE_INDEX_LEB (6)
 ; CHECK-NEXT:       Offset: 0x24
 ; CHECK-NEXT:       Index: 0x0
 ; CHECK-NEXT:     }
 ; CHECK-NEXT:     Relocation {
-; CHECK-NEXT:       Type: R_WEBASSEMBLY_FUNCTION_INDEX_LEB (0)
+; CHECK-NEXT:       Type: R_WASM_FUNCTION_INDEX_LEB (0)
 ; CHECK-NEXT:       Offset: 0x2D
 ; CHECK-NEXT:       Symbol: c
 ; CHECK-NEXT:     }
 ; CHECK-NEXT:     Relocation {
-; CHECK-NEXT:       Type: R_WEBASSEMBLY_FUNCTION_INDEX_LEB (0)
+; CHECK-NEXT:       Type: R_WASM_FUNCTION_INDEX_LEB (0)
 ; CHECK-NEXT:       Offset: 0x34
 ; CHECK-NEXT:       Symbol: d
 ; CHECK-NEXT:     }
 ; CHECK-NEXT:   }
 ; CHECK-NEXT: ]

test/MC/WebAssembly/reloc-data.ll

 @a = global i32* getelementptr (i32, i32* @foo, i32 2), align 8
 @b = global i64* getelementptr (i64, i64* @bar, i64 -2), align 8
 @c = global [3 x i32*] [i32* @foo, i32* @foo, i32* @foo], align 16
 
 ; CHECK:      Format: WASM
 ; CHECK:      Relocations [
 ; CHECK-NEXT:   Section (2) DATA {
 ; CHECK-NEXT:     Relocation {
-; CHECK-NEXT:       Type: R_WEBASSEMBLY_MEMORY_ADDR_I32 (5)
+; CHECK-NEXT:       Type: R_WASM_MEMORY_ADDR_I32 (5)
 ; CHECK-NEXT:       Offset: 0x13
 ; CHECK-NEXT:       Symbol: foo
 ; CHECK-NEXT:       Addend: 8
 ; CHECK-NEXT:     }
 ; CHECK-NEXT:     Relocation {
-; CHECK-NEXT:       Type: R_WEBASSEMBLY_MEMORY_ADDR_I32 (5)
+; CHECK-NEXT:       Type: R_WASM_MEMORY_ADDR_I32 (5)
 ; CHECK-NEXT:       Offset: 0x1C
 ; CHECK-NEXT:       Symbol: bar
 ; CHECK-NEXT:       Addend: -16
 ; CHECK-NEXT:     }
 ; CHECK-NEXT:     Relocation {
-; CHECK-NEXT:       Type: R_WEBASSEMBLY_MEMORY_ADDR_I32 (5)
+; CHECK-NEXT:       Type: R_WASM_MEMORY_ADDR_I32 (5)
 ; CHECK-NEXT:       Offset: 0x25
 ; CHECK-NEXT:       Symbol: foo
 ; CHECK-NEXT:       Addend: 0
 ; CHECK-NEXT:     }
 ; CHECK-NEXT:     Relocation {
-; CHECK-NEXT:       Type: R_WEBASSEMBLY_MEMORY_ADDR_I32 (5)
+; CHECK-NEXT:       Type: R_WASM_MEMORY_ADDR_I32 (5)
 ; CHECK-NEXT:       Offset: 0x29
 ; CHECK-NEXT:       Symbol: foo
 ; CHECK-NEXT:       Addend: 0
 ; CHECK-NEXT:     }
 ; CHECK-NEXT:     Relocation {
-; CHECK-NEXT:       Type: R_WEBASSEMBLY_MEMORY_ADDR_I32 (5)
+; CHECK-NEXT:       Type: R_WASM_MEMORY_ADDR_I32 (5)
 ; CHECK-NEXT:       Offset: 0x2D
 ; CHECK-NEXT:       Symbol: foo
 ; CHECK-NEXT:       Addend: 0
 ; CHECK-NEXT:     }
 ; CHECK-NEXT:   }
 ; CHECK-NEXT: ]

test/MC/WebAssembly/stack-ptr.ll

 ; CHECK:     Imports:
 ; CHECK:       - Module:          env
 ; CHECK:         Field:           __stack_pointer
 ; CHECK:         Kind:            GLOBAL
 ; CHECK:         GlobalType:      I32
 ; CHECK:         GlobalMutable:   true
 ; CHECK:   - Type:            CODE
 ; CHECK:     Relocations:
-; CHECK:       - Type:            R_WEBASSEMBLY_GLOBAL_INDEX_LEB
+; CHECK:       - Type:            R_WASM_GLOBAL_INDEX_LEB
 ; CHECK:         Index:           0

test/MC/WebAssembly/unnamed-data.ll

 ; RUN: llc -filetype=obj %s -o - | obj2yaml | FileCheck %s
 
 target triple = "wasm32-unknown-unknown"
 
 @.str1 = private unnamed_addr constant [6 x i8] c"hello\00", align 1
 @.str2 = private unnamed_addr constant [6 x i8] c"world\00", align 1
 
 @a = global i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str1, i32 0, i32 0), align 8
 @b = global i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str2, i32 0, i32 0), align 8
 
 
 ; CHECK:        - Type:            DATA
 ; CHECK-NEXT:     Relocations:     
-; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_I32
+; CHECK-NEXT:       - Type:            R_WASM_MEMORY_ADDR_I32
 ; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:         Offset:          0x0000001C
-; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_I32
+; CHECK-NEXT:       - Type:            R_WASM_MEMORY_ADDR_I32
 ; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000025
 ; CHECK-NEXT:     Segments:        
 ; CHECK-NEXT:       - SectionOffset:   6
 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:          
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           0

test/MC/WebAssembly/weak-alias.ll

 ; CHECK-NEXT:   - Type:            ELEM
 ; CHECK-NEXT:     Segments:
 ; CHECK-NEXT:       - Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1
 ; CHECK-NEXT:         Functions:       [ 0 ]
 ; CHECK-NEXT:   - Type:            CODE
 ; CHECK-NEXT:     Relocations:
-; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
+; CHECK-NEXT:       - Type:            R_WASM_FUNCTION_INDEX_LEB
 ; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:         Offset:          0x00000009
-; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
+; CHECK-NEXT:       - Type:            R_WASM_FUNCTION_INDEX_LEB
 ; CHECK-NEXT:         Index:           3
 ; CHECK-NEXT:         Offset:          0x00000012
-; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
+; CHECK-NEXT:       - Type:            R_WASM_MEMORY_ADDR_LEB
 ; CHECK-NEXT:         Index:           5
 ; CHECK-NEXT:         Offset:          0x0000001E
-; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_TYPE_INDEX_LEB
+; CHECK-NEXT:       - Type:            R_WASM_TYPE_INDEX_LEB
 ; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:         Offset:          0x00000024
-; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
+; CHECK-NEXT:       - Type:            R_WASM_MEMORY_ADDR_LEB
 ; CHECK-NEXT:         Index:           7
 ; CHECK-NEXT:         Offset:          0x00000031
-; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_TYPE_INDEX_LEB
+; CHECK-NEXT:       - Type:            R_WASM_TYPE_INDEX_LEB
 ; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:         Offset:          0x00000037
 ; CHECK-NEXT:     Functions:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            41000B
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            1080808080000B
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            1080808080000B
 ; CHECK-NEXT:       - Index:           3
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            410028028880808000118080808000000B
 ; CHECK-NEXT:       - Index:           4
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            410028029080808000118080808000000B
 ; CHECK-NEXT:   - Type:            DATA
 ; CHECK-NEXT:     Relocations:
-; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_I32
+; CHECK-NEXT:       - Type:            R_WASM_TABLE_INDEX_I32
 ; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:         Offset:          0x0000000F
-; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_I32
+; CHECK-NEXT:       - Type:            R_WASM_TABLE_INDEX_I32
 ; CHECK-NEXT:         Index:           3
 ; CHECK-NEXT:         Offset:          0x00000018
 ; CHECK-NEXT:     Segments:
 ; CHECK-NEXT:       - SectionOffset:   6
 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           0

test/Object/objdump-relocations.test

 ELF-MIPSEL: R_MIPS_HI16 _gp_disp
 ELF-MIPSEL: R_MIPS_LO16 _gp_disp
 ELF-MIPSEL: R_MIPS_GOT16 $.str
 ELF-MIPSEL: R_MIPS_LO16 $.str
 ELF-MIPSEL: R_MIPS_CALL16 puts
 ELF-MIPSEL: R_MIPS_CALL16 SomeOtherFunction
 
 WASM:      CODE
-WASM-NEXT: R_WEBASSEMBLY_MEMORY_ADDR_SLEB .L.str
-WASM-NEXT: R_WEBASSEMBLY_FUNCTION_INDEX_LEB puts
-WASM-NEXT: R_WEBASSEMBLY_FUNCTION_INDEX_LEB .LSomeOtherFunction_bitcast
-WASM-NEXT: R_WEBASSEMBLY_FUNCTION_INDEX_LEB SomeOtherFunction
+WASM-NEXT: R_WASM_MEMORY_ADDR_SLEB .L.str
+WASM-NEXT: R_WASM_FUNCTION_INDEX_LEB puts
+WASM-NEXT: R_WASM_FUNCTION_INDEX_LEB .LSomeOtherFunction_bitcast
+WASM-NEXT: R_WASM_FUNCTION_INDEX_LEB SomeOtherFunction
 
 ELF-complex-x86-64: .text
 ELF-complex-x86-64-NEXT: R_X86_64_8 .data-4
 ELF-complex-x86-64-NEXT: R_X86_64_16 .data-4
 ELF-complex-x86-64-NEXT: R_X86_64_32 .data-4
 ELF-complex-x86-64-NEXT: R_X86_64_32S .data-4
 ELF-complex-x86-64-NEXT: R_X86_64_64 .data-4
 ELF-complex-x86-64-NEXT: R_X86_64_PC32 .data-4
 ELF-complex-x86-64-NEXT: R_X86_64_32 .data
 ELF-complex-x86-64-NEXT: R_X86_64_32 .data+4

test/ObjectYAML/wasm/code_section.yaml

Signatures:
           - I32
           - I64
   - Type:            FUNCTION
     FunctionTypes:
       - 0
       - 1
   - Type:            CODE
     Relocations:
-      - Type:            R_WEBASSEMBLY_TABLE_INDEX_SLEB
+      - Type:            R_WASM_TABLE_INDEX_SLEB
         Index:           0
         Offset:          0x00000006
-      - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
+      - Type:            R_WASM_FUNCTION_INDEX_LEB
         Index:           1
         Offset:          0x00000025
     Functions:
       - Index:              0
         Locals:
          - Type:            I32
            Count:           3
         Body:            418080808000210020002101200111808080800000210220020F0B

 # CHECK:          - I32
 # CHECK:      - Index:           1
 # CHECK:        ReturnType:      NORESULT
 # CHECK:        ParamTypes:
 # CHECK:          - I32
 # CHECK:          - I64
 # CHECK:  - Type:            CODE
 # CHECK:    Relocations:
-# CHECK:      - Type:            R_WEBASSEMBLY_TABLE_INDEX_SLEB
+# CHECK:      - Type:            R_WASM_TABLE_INDEX_SLEB
 # CHECK:        Index:           0
 # CHECK:        Offset:          0x00000006
-# CHECK:      - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
+# CHECK:      - Type:            R_WASM_FUNCTION_INDEX_LEB
 # CHECK:        Index:           1
 # CHECK:        Offset:          0x00000025
 # CHECK:    Functions:
 # CHECK:      - Index:              0
 # CHECK:        Locals:
 # CHECK:         - Type:            I32
 # CHECK:           Count:           3
 # CHECK:        Body:            418080808000210020002101200111808080800000210220020F0B
 # CHECK:      - Index:              1
 # CHECK:        Locals:
 # CHECK:         - Type:            I32
 # CHECK:           Count:           1
 # CHECK:        Body:            108180808000210020000F0B

test/ObjectYAML/wasm/data_section.yaml

 # RUN: yaml2obj %s | obj2yaml | FileCheck %s
 --- !WASM
 FileHeader:
   Version:         0x00000001
 Sections:
   - Type:            MEMORY
     Memories:
       - Initial:         0x00000003
   - Type:            DATA
     Segments:
       - MemoryIndex:      0
         Offset:
           Opcode:          I32_CONST
           Value:           4
         Content:         '10001000'
     Relocations:
-      - Type:            R_WEBASSEMBLY_MEMORY_ADDR_I32
+      - Type:            R_WASM_MEMORY_ADDR_I32
         Index:           0
         Offset:          0x00000006
         Addend:          8
-      - Type:            R_WEBASSEMBLY_MEMORY_ADDR_I32
+      - Type:            R_WASM_MEMORY_ADDR_I32
         Index:           0
         Offset:          0x00000006
         Addend:          -6
   - Type:            CUSTOM
     Name:            linking
     Version:         2
     SymbolTable:
       - Index:           0
         Kind:            DATA
         Name:            dataSymbol
         Flags:           [  ]
         Segment:         0
         Offset:          0
         Size:            4
 ...
 # CHECK: --- !WASM
 # CHECK: FileHeader:
 # CHECK:   Version:           0x00000001
 # CHECK: Sections:
 # CHECK:   - Type:            DATA
 # CHECK-NEXT:     Relocations:
-# CHECK-NEXT:      - Type:            R_WEBASSEMBLY_MEMORY_ADDR_I32
+# CHECK-NEXT:      - Type:            R_WASM_MEMORY_ADDR_I32
 # CHECK-NEXT:        Index:           0
 # CHECK-NEXT:        Offset:          0x00000006
 # CHECK-NEXT:        Addend:          8
-# CHECK-NEXT:      - Type:            R_WEBASSEMBLY_MEMORY_ADDR_I32
+# CHECK-NEXT:      - Type:            R_WASM_MEMORY_ADDR_I32
 # CHECK-NEXT:        Index:           0
 # CHECK-NEXT:        Offset:          0x00000006
 # CHECK-NEXT:        Addend:          -6
 # CHECK-NEXT:     Segments:
 # CHECK-NEXT:       - SectionOffset:   6
 # CHECK-NEXT:         MemoryIndex:     0
 # CHECK-NEXT:         Offset:
 # CHECK-NEXT:           Opcode:          I32_CONST
 # CHECK-NEXT:           Value:           4
 # CHECK-NEXT:         Content:         '10001000'
 # CHECK-NEXT:   - Type:            CUSTOM

test/ObjectYAML/wasm/event_section.yaml

- Type:            FUNCTION
     FunctionTypes:   [ 0 ]
   - Type:            EVENT
     Events:
       - Index:           0
         Attribute:       0
         SigIndex:        1
   - Type:            CODE
     Relocations:
-      - Type:            R_WEBASSEMBLY_EVENT_INDEX_LEB
+      - Type:            R_WASM_EVENT_INDEX_LEB
         Index:           1
         Offset:          0x00000006
     Functions:
       - Index:           0
         Locals:
         Body:            200008808080800041000B
   - Type:            CUSTOM
     Name:            linking

 # CHECK-NEXT:     FunctionTypes:   [ 0 ]
 # CHECK-NEXT:   - Type:            EVENT
 # CHECK-NEXT:     Events:
 # CHECK-NEXT:       - Index:           0
 # CHECK-NEXT:         Attribute:       0
 # CHECK-NEXT:         SigIndex:        1
 # CHECK-NEXT:   - Type:            CODE
 # CHECK-NEXT:     Relocations:
-# CHECK-NEXT:       - Type:            R_WEBASSEMBLY_EVENT_INDEX_LEB
+# CHECK-NEXT:       - Type:            R_WASM_EVENT_INDEX_LEB
 # CHECK-NEXT:         Index:           1
 # CHECK-NEXT:         Offset:          0x00000006
 # CHECK-NEXT:     Functions:
 # CHECK-NEXT:       - Index:           0
 # CHECK-NEXT:         Locals:
 # CHECK-NEXT:         Body:            200008808080800041000B
 # CHECK-NEXT:   - Type:            CUSTOM
 # CHECK-NEXT:     Name:            linking

test/tools/llvm-objdump/WebAssembly/relocations.test

 ; RUN: llc -mtriple=wasm32-unknown-unknown -filetype=obj %s -o - | llvm-objdump -r - | FileCheck %s
 
 @foo = external global i32, align 4
 @bar = global i32* @foo, align 4
 
 define void @make_call(void ()* nocapture %func) {
 entry:
   call void %func()
   ret void
 }
 
 ; CHECK:      RELOCATION RECORDS FOR [CODE]:
-; CHECK-NEXT: 00000006 R_WEBASSEMBLY_TYPE_INDEX_LEB 1+0
+; CHECK-NEXT: 00000006 R_WASM_TYPE_INDEX_LEB 1+0
 
 ; CHECK:      RELOCATION RECORDS FOR [DATA]:
-; CHECK-NEXT: 00000006 R_WEBASSEMBLY_MEMORY_ADDR_I32 foo+0
+; CHECK-NEXT: 00000006 R_WASM_MEMORY_ADDR_I32 foo+0

test/tools/llvm-readobj/relocations.test

 MACHO-ARM-NEXT:        Value: 0x4
 MACHO-ARM-NEXT:      }
 MACHO-ARM-NEXT:    }
 MACHO-ARM-NEXT:  ]
 
 WASM:      Relocations [
 WASM-NEXT:   Section (4) CODE {
 WASM-NEXT:     Relocation {
-WASM-NEXT:       Type: R_WEBASSEMBLY_MEMORY_ADDR_SLEB (4)
+WASM-NEXT:       Type: R_WASM_MEMORY_ADDR_SLEB (4)
 WASM-NEXT:       Offset: 0x4
 WASM-NEXT:       Symbol: .L.str
 WASM-NEXT:       Addend: 0
 WASM-NEXT:     }
 WASM-NEXT:     Relocation {
-WASM-NEXT:       Type: R_WEBASSEMBLY_FUNCTION_INDEX_LEB (0)
+WASM-NEXT:       Type: R_WASM_FUNCTION_INDEX_LEB (0)
 WASM-NEXT:       Offset: 0xA
 WASM-NEXT:       Symbol: puts
 WASM-NEXT:     }
 WASM-NEXT:     Relocation {
-WASM-NEXT:       Type: R_WEBASSEMBLY_FUNCTION_INDEX_LEB (0)
+WASM-NEXT:       Type: R_WASM_FUNCTION_INDEX_LEB (0)
 WASM-NEXT:       Offset: 0x11
 WASM-NEXT:       Symbol: .LSomeOtherFunction_bitcast
 WASM-NEXT:     }
 WASM-NEXT:     Relocation {
-WASM-NEXT:       Type: R_WEBASSEMBLY_FUNCTION_INDEX_LEB (0)
+WASM-NEXT:       Type: R_WASM_FUNCTION_INDEX_LEB (0)
 WASM-NEXT:       Offset: 0x1E
 WASM-NEXT:       Symbol: SomeOtherFunction
 WASM-NEXT:     }
 WASM-NEXT:   }
 WASM-NEXT: ]

tools/llvm-objdump/WasmDump.cpp

llvm::getWasmRelocationValueString(const WasmObjectFile *Obj,
                                    const RelocationRef &RelRef,
                                    SmallVectorImpl<char> &Result) {
   const wasm::WasmRelocation &Rel = Obj->getWasmRelocation(RelRef);
   symbol_iterator SI = RelRef.getSymbol();
   std::string FmtBuf;
   raw_string_ostream Fmt(FmtBuf);
   if (SI == Obj->symbol_end()) {
     // Not all wasm relocations have symbols associated with them.
-    // In particular R_WEBASSEMBLY_TYPE_INDEX_LEB.
+    // In particular R_WASM_TYPE_INDEX_LEB.
     Fmt << Rel.Index;
   } else {
     Expected<StringRef> SymNameOrErr = SI->getName();
     if (!SymNameOrErr)
       return errorToErrorCode(SymNameOrErr.takeError());
     StringRef SymName = *SymNameOrErr;
     Result.append(SymName.begin(), SymName.end());
   }
   Fmt << (Rel.Addend < 0 ? "" : "+") << Rel.Addend;
   Fmt.flush();
   Result.append(FmtBuf.begin(), FmtBuf.end());
   return std::error_code();
 }

tools/llvm-readobj/WasmDumper.cpp

void WasmDumper::printRelocation(const SectionRef &Section,
 
   StringRef SymName;
   symbol_iterator SI = Reloc.getSymbol();
   if (SI != Obj->symbol_end())
     SymName = error(SI->getName());
 
   bool HasAddend = false;
   switch (RelocType) {
-  case wasm::R_WEBASSEMBLY_MEMORY_ADDR_LEB:
-  case wasm::R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
-  case wasm::R_WEBASSEMBLY_MEMORY_ADDR_I32:
-  case wasm::R_WEBASSEMBLY_FUNCTION_OFFSET_I32:
-  case wasm::R_WEBASSEMBLY_SECTION_OFFSET_I32:
+  case wasm::R_WASM_MEMORY_ADDR_LEB:
+  case wasm::R_WASM_MEMORY_ADDR_SLEB:
+  case wasm::R_WASM_MEMORY_ADDR_I32:
+  case wasm::R_WASM_FUNCTION_OFFSET_I32:
+  case wasm::R_WASM_SECTION_OFFSET_I32:
     HasAddend = true;
     break;
   default:
     break;
   }
   if (opts::ExpandRelocs) {
     DictScope Group(W, "Relocation");
     W.printNumber("Type", RelocTypeName, RelocType);

tools/yaml2obj/yaml2wasm.cpp

int WasmWriter::writeRelocSection(raw_ostream &OS, WasmYAML::Section &Sec,
   encodeULEB128(SectionIndex, OS);
   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_WEBASSEMBLY_MEMORY_ADDR_LEB:
-    case wasm::R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
-    case wasm::R_WEBASSEMBLY_MEMORY_ADDR_I32:
-    case wasm::R_WEBASSEMBLY_FUNCTION_OFFSET_I32:
-    case wasm::R_WEBASSEMBLY_SECTION_OFFSET_I32:
+    case wasm::R_WASM_MEMORY_ADDR_LEB:
+    case wasm::R_WASM_MEMORY_ADDR_SLEB:
+    case wasm::R_WASM_MEMORY_ADDR_I32:
+    case wasm::R_WASM_FUNCTION_OFFSET_I32:
+    case wasm::R_WASM_SECTION_OFFSET_I32:
       encodeULEB128(Reloc.Addend, OS);
     }
   }
   return 0;
 }
 
 int WasmWriter::writeWasm(raw_ostream &OS) {
   // Write headers