[WebAssembly] Add new relocation for location relative data

[kateinoigakukun]

Summary

This R_WASM_MEMORY_ADDR_SELFREL_I32 relocation represents an offset
between its relocating address and the symbol address. It's very similar
to R_X86_64_PC32 but restricted to be used for only data segments.

S + A - P

A: Represents the addend used to compute the value of the relocatable
field.
P: Represents the place of the storage unit being relocated.
S: Represents the value of the symbol whose index resides in the
relocation entry.

Proposal: https://github.com/WebAssembly/tool-conventions/issues/162

[kateinoigakukun]

Addressed clang-tidy warnings

[kateinoigakukun]

Addressed clang-tidy warnings in lld

[sbc100]

Is the "pc-rel" in the title a little misleading? How about just "relative" or "location relative"?

Thinking a little more about this, would it not make sense to have these relative relocations in the code section instead (or in addition)? I assume the idea is to do stuff like this:

i32.load <some_base_pointer>
i32.load <selfrel_location>
i32.add
.. use absolute pointer ..

In that case wouldn't it be better to just do:

i32.load <some_base_pointer>
i32.const <relative_relocation>
i32.add
.. use absolute pointer ..

This would save using memory at all and just embed the relative offset into the i32.const instruction.

llvm/test/MC/WebAssembly/selfrel.ll

48 ↗

(On Diff #323600)

What happens today with this code? (without this change would this fail in some way?).

[kateinoigakukun]

@sbc100 Thanks for taking a look!

Is the "pc-rel" in the title a little misleading? How about just "relative" or "location relative"?

You are right. it seems "location relative" is suitable. I'll change naming in my patch also.

Thinking a little more about this, would it not make sense to have these relative relocations in the code section instead (or in addition)? I assume the idea is to do stuff like this:

i32.load <some_base_pointer>
i32.load <selfrel_location>
i32.add
.. use absolute pointer ..

In that case wouldn't it be better to just do:

i32.load <some_base_pointer>
i32.const <relative_relocation>
i32.add
.. use absolute pointer ..

This would save using memory at all and just embed the relative offset into the i32.const instruction.

In the latter case, the relocation needs to have two symbols to calculate the difference. On the other hand, the former case requires a single symbol to calculate the diff because it's relative to selfrel_location itself.

Do you think we can have two symbols in a reloc?

llvm/test/MC/WebAssembly/selfrel.ll

48 ↗

(On Diff #323600)

What happens today with this code? (without this change would this fail in some way?).

[kateinoigakukun]

llvm/test/MC/WebAssembly/selfrel.ll

48 ↗

(On Diff #323600)

Yes, this kind of subtractions between cross-sections are failing now because the diff can not be fixed at compile-time layout.

[kateinoigakukun]

Update naming from pc relative to location relative

[aardappel]

This generally looks nice to me.. but my reservations on how useful this is beyond a singular use case still stand: https://github.com/WebAssembly/tool-conventions/issues/162

[kateinoigakukun]

In D96659#2572750, @aardappel wrote:

This generally looks nice to me.. but my reservations on how useful this is beyond a singular use case still stand: https://github.com/WebAssembly/tool-conventions/issues/162

I couldn't come up with another use case. But without this reloc type, every frontend compiler using relative-ptr needs to work around this issue, so I think adding a new reloc type is meaningful. (I know only a few compilers are using relative-ptr, but ...)
And also, in my investigation, using relative-ptr makes Swift's binary size about 5% smaller than absolute-ptr one. Binary size is one of the most sensitive aspects in wasm binary, so we want to use relative ptr on wasm64.

[aardappel]

Ok, well, I am fine with this patch if @sbc100 is.

[sbc100]

Mostly lgtm. Just a few nits at this point.

I don't love the name SELFREL but naming is hard and I'm not sure I can think of a better one. (LOCREL for location-relative?) Also, since can renaming the enum later without breaking compat we are not locked into the name. I wonder if we should rename of the existing REL relocation types to MBREL and TBREL to be explicit there too? (Not suggesting you do that as part of this change).

lld/test/wasm/selfrel-reloc.ll

27 ↗

(On Diff #323630)

Can we write this test in assembly? I've been trying to convert all the lld test to asm so would rather not add more .ll tests here. Also I think it might be a lore more concise/readable perhaps in .s form?

lld/wasm/InputFiles.cpp

184

Is this correct? It looks like we are expecting the value written to the location to be the start of the segment containing the symbol? (Maybe this works because we default to -fdata-sections?)

llvm/test/MC/WebAssembly/selfrel.ll

1 ↗

(On Diff #323630)

Can we give this test file a more descriptive name? How about reloc-relative.ll or reloc-selfrel.ll ? (to match the other tests in this directory that start with reloc-

[kateinoigakukun]

Re-write lld test in assembly, fix expected provisioning value, and rename test file to match naming convention in the directory

[kateinoigakukun]

lld/wasm/InputFiles.cpp

184

That was incorrect 😅 I fixed it and added tests to catch this bug. Thanks.

[kateinoigakukun]

re-trigger ci

[kateinoigakukun]

Gentle ping :)

[sbc100]

I don't have any more objections myself. @sunfish , WDYT of this addition? My feeling is that if it helps swift then its probably worth adding.

lld/test/wasm/reloc-relative.s

4

Do you need --allow-undefined here?

30

How does this not trigger the can not be placed in a different section error in the object writer?

[kateinoigakukun]

lld/test/wasm/reloc-relative.s

4

Yes, hello.s requires puts symbol but this test doesn't use printing function, so I put --allow-undefined to ignore such unrelated symbols.

## hello.s

  .globl  hello
hello:
  .functype hello () -> ()
  i32.const hello_str
  call  puts
  end_function

  .section  .rodata.hello_str,"",@
  .globl  hello_str
hello_str:
  .asciz  "hello\n"
  .size hello_str, 7

  .functype puts (i32) -> ()

30

S + A - P

R_WASM_MEMORY_ADDR_LOCREL_I32 allows S to be a symbol in a different section, but doesn't allow P to be in a different section. This limitation is because a relocation entry can have only one symbol, so the base address (P) needs to be relative to the writing location.

In this case, hello_str is an external section symbol, but S can be a symbol in a different section and bar is placed in the same section with writing location, so does not trigger can not be placed in a different section.
This expression emits the below relocation entry.

Relocation {
  Type: R_WASM_MEMORY_ADDR_LOCREL_I32 (23)
  Offset: 0x0
  Symbol: hello_str
  Addend: 0
}

[kateinoigakukun]

Resolved conflicts between main branch

[kateinoigakukun]

@sbc100 Thanks for your approval! I don't have commit access, so could you land this patch? 🙏

[kateinoigakukun]

Sorry for repeating 🙇 Could anyone land this patch to the main branch?

[aardappel]

I can land it.. let me pull it in locally and run tests to be sure.

[kateinoigakukun]

Thank you very much!

lld/test/wasm/reloc-relative.s

+# RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown %p/Inputs/hello.s -o %t.hello32.o
+# RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown %s -o %t.o
+# RUN: wasm-ld --no-entry --no-gc-sections --allow-undefined -fatal-warnings -o %t.wasm %t.o %t.hello32.o
+# RUN: obj2yaml %t.wasm | FileCheck %s
+
+.section .x_sec,"",@
+internal_x_seg_pad:
+  # padding for provisioning value assertion
+  .int32 0
+  .size internal_x_seg_pad, 4
+internal_x_seg:
+  .int32 42
+  .size internal_x_seg, 4
+
+# internal cross segment subtraction
+.section .foo,"",@
+.globl  foo
+foo:
+  .int32 internal_x_seg - foo
+  .size foo, 4
+foo_addend:
+  .int32 internal_x_seg - foo
+  .size foo_addend, 4
+
+# external cross segment subtraction
+.section .bar,"",@
+.globl  bar
+bar:
+  .int32 hello_str - bar
+  .size bar, 4
+bar_addend:
+  .int32 hello_str - bar
+  .size bar_addend, 4
+
+# positive calc result
+.section .fizz,"",@
+.globl  fizz
+fizz:
+  .int32 far - fizz
+  .size fizz, 4
+fizz_addend:
+  .int32 far - fizz
+  .size fizz_addend, 4
+
+.section .far,"",@
+.globl  far
+far:
+  .int32 21
+  .size far, 4
+
+# CHECK:      - Type:            DATA
+# CHECK-NEXT:    Segments:
+# CHECK-NEXT:      - SectionOffset:   7
+# CHECK-NEXT:        InitFlags:       0
+# CHECK-NEXT:        Offset:
+# CHECK-NEXT:          Opcode:          I32_CONST
+# CHECK-NEXT:          Value:           1024
+# CHECK-NEXT:        Content:         68656C6C6F0A00
+# CHECK-NEXT:      - SectionOffset:   20
+# CHECK-NEXT:        InitFlags:       0
+# CHECK-NEXT:        Offset:
+# CHECK-NEXT:          Opcode:          I32_CONST
+# CHECK-NEXT:          Value:           1031
+# CHECK-NEXT:        Content:         000000002A000000
+# CHECK-NEXT:      - SectionOffset:   34
+# CHECK-NEXT:        InitFlags:       0
+# CHECK-NEXT:        Offset:
+# CHECK-NEXT:          Opcode:          I32_CONST
+# CHECK-NEXT:          Value:           1039
+# CHECK-NEXT:        Content:         FCFFFFFFFCFFFFFF
+# CHECK-NEXT:      - SectionOffset:   48
+# CHECK-NEXT:        InitFlags:       0
+# CHECK-NEXT:        Offset:
+# CHECK-NEXT:          Opcode:          I32_CONST
+# CHECK-NEXT:          Value:           1047
+# CHECK-NEXT:        Content:         E9FFFFFFE9FFFFFF
+# CHECK-NEXT:      - SectionOffset:   62
+# CHECK-NEXT:        InitFlags:       0
+# CHECK-NEXT:        Offset:
+# CHECK-NEXT:          Opcode:          I32_CONST
+# CHECK-NEXT:          Value:           1055
+# CHECK-NEXT:        Content:         '0800000008000000'
+# CHECK-NEXT:      - SectionOffset:   76
+# CHECK-NEXT:        InitFlags:       0
+# CHECK-NEXT:        Offset:
+# CHECK-NEXT:          Opcode:          I32_CONST
+# CHECK-NEXT:          Value:           1063
+# CHECK-NEXT:        Content:         '15000000'
+

lld/wasm/InputChunks.cpp

case R_WASM_MEMORY_ADDR_REL_SLEB64:
       existingValue = static_cast<uint64_t>(decodeSLEB128(loc, &bytesRead));
       paddedLEBWidth = 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:
+    case R_WASM_MEMORY_ADDR_LOCREL_I32:
       existingValue = read32le(loc);
       break;
     case R_WASM_TABLE_INDEX_I64:
     case R_WASM_MEMORY_ADDR_I64:
     case R_WASM_FUNCTION_OFFSET_I64:
       existingValue = read64le(loc);
       break;
     default:
#endif
 
   LLVM_DEBUG(dbgs() << "applying relocations: " << toString(this)
                     << " count=" << relocations.size() << "\n");
   int32_t off = outSecOff - getInputSectionOffset();
   auto tombstone = getTombstone();
 
   for (const WasmRelocation &rel : relocations) {
     uint8_t *loc = buf + rel.Offset + off;
-    auto value = file->calcNewValue(rel, tombstone);
+    auto value = file->calcNewValue(rel, tombstone, this);
     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) {
for (const WasmRelocation &rel : relocations) {
     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:
+    case R_WASM_MEMORY_ADDR_LOCREL_I32:
       write32le(loc, value);
       break;
     case R_WASM_TABLE_INDEX_I64:
     case R_WASM_MEMORY_ADDR_I64:
     case R_WASM_FUNCTION_OFFSET_I64:
       write64le(loc, value);
       break;
     default:
void InputFunction::calculateSize() {
   uint32_t end = start + function->Size;
 
   auto tombstone = getTombstone();
 
   uint32_t lastRelocEnd = start + functionSizeLength;
   for (const WasmRelocation &rel : relocations) {
     LLVM_DEBUG(dbgs() << "  region: " << (rel.Offset - lastRelocEnd) << "\n");
     compressedFuncSize += rel.Offset - lastRelocEnd;
-    compressedFuncSize += getRelocWidth(rel, file->calcNewValue(rel, tombstone));
+    compressedFuncSize +=
+        getRelocWidth(rel, file->calcNewValue(rel, tombstone, this));
     lastRelocEnd = rel.Offset + getRelocWidthPadded(rel);
   }
   LLVM_DEBUG(dbgs() << "  final region: " << (end - lastRelocEnd) << "\n");
   compressedFuncSize += end - lastRelocEnd;
 
   // Now we know how long the resulting function is we can add the encoding
   // of its length
   uint8_t buf[5];
void InputFunction::writeTo(uint8_t *buf) const {
   LLVM_DEBUG(dbgs() << "write func: " << getName() << "\n");
   buf += encodeULEB128(compressedFuncSize, buf);
   const uint8_t *lastRelocEnd = funcStart;
   for (const WasmRelocation &rel : relocations) {
     unsigned chunkSize = (secStart + rel.Offset) - lastRelocEnd;
     LLVM_DEBUG(dbgs() << "  write chunk: " << chunkSize << "\n");
     memcpy(buf, lastRelocEnd, chunkSize);
     buf += chunkSize;
-    buf += writeCompressedReloc(buf, rel, file->calcNewValue(rel, tombstone));
+    buf += writeCompressedReloc(buf, rel,
+                                file->calcNewValue(rel, tombstone, this));
     lastRelocEnd = secStart + rel.Offset + getRelocWidthPadded(rel);
   }
 
   unsigned chunkSize = end - lastRelocEnd;
   LLVM_DEBUG(dbgs() << "  write final chunk: " << chunkSize << "\n");
   memcpy(buf, lastRelocEnd, chunkSize);
   LLVM_DEBUG(dbgs() << "  total: " << (buf + chunkSize - orig) << "\n");
 }
for (const WasmRelocation &rel : relocations) {
     } else {
       const GlobalSymbol* baseSymbol = WasmSym::memoryBase;
       if (rel.Type == R_WASM_TABLE_INDEX_I32 ||
           rel.Type == R_WASM_TABLE_INDEX_I64)
         baseSymbol = WasmSym::tableBase;
       writeU8(os, WASM_OPCODE_GLOBAL_GET, "GLOBAL_GET");
       writeUleb128(os, baseSymbol->getGlobalIndex(), "base");
       writeU8(os, opcode_reloc_const, "CONST");
-      writeSleb128(os, file->calcNewValue(rel, tombstone), "offset");
+      writeSleb128(os, file->calcNewValue(rel, tombstone, this), "offset");
       writeU8(os, opcode_reloc_add, "ADD");
     }
 
     // Store that value at the virtual address
     writeU8(os, opcode_reloc_store, "I32_STORE");
     writeUleb128(os, 2, "align");
     writeUleb128(os, 0, "offset");
   }

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;
-  uint64_t calcNewValue(const WasmRelocation &reloc, uint64_t tombstone) const;
+  uint64_t calcNewValue(const WasmRelocation &reloc, uint64_t tombstone,
+                        const InputChunk *chunk) 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;

lld/wasm/InputFiles.cpp

uint64_t ObjFile::calcNewAddend(const WasmRelocation &reloc) const {
   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_MEMORY_ADDR_TLS_SLEB:
   case R_WASM_FUNCTION_OFFSET_I32:
   case R_WASM_FUNCTION_OFFSET_I64:
+  case R_WASM_MEMORY_ADDR_LOCREL_I32:
     return reloc.Addend;
   case R_WASM_SECTION_OFFSET_I32:
     return getSectionSymbol(reloc.Index)->section->getOffset(reloc.Addend);
   default:
     llvm_unreachable("unexpected relocation type");
   }
 }
 
uint64_t ObjFile::calcExpectedValue(const WasmRelocation &reloc) const {
   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_MEMORY_ADDR_TLS_SLEB: {
+  case R_WASM_MEMORY_ADDR_TLS_SLEB:
+  case R_WASM_MEMORY_ADDR_LOCREL_I32: {
     const WasmSymbol &sym = wasmObj->syms()[reloc.Index];
     if (sym.isUndefined())
       return 0;
     const WasmSegment &segment =
         wasmObj->dataSegments()[sym.Info.DataRef.Segment];
     if (segment.Data.Offset.Opcode == WASM_OPCODE_I32_CONST)
       return segment.Data.Offset.Value.Int32 + sym.Info.DataRef.Offset +
              reloc.Addend;
     else if (segment.Data.Offset.Opcode == WASM_OPCODE_I64_CONST)
       return segment.Data.Offset.Value.Int64 + sym.Info.DataRef.Offset +
              reloc.Addend;
     else
       llvm_unreachable("unknown init expr opcode");
   }
   case R_WASM_FUNCTION_OFFSET_I32:
   case R_WASM_FUNCTION_OFFSET_I64: {
     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_SECTION_OFFSET_I32:
     return reloc.Addend;
   case R_WASM_TYPE_INDEX_LEB:
     return reloc.Index;
   case R_WASM_FUNCTION_INDEX_LEB:
   case R_WASM_GLOBAL_INDEX_LEB:
   case R_WASM_GLOBAL_INDEX_I32:
   case R_WASM_EVENT_INDEX_LEB:
   case R_WASM_TABLE_NUMBER_LEB: {
     const WasmSymbol &sym = wasmObj->syms()[reloc.Index];
     return sym.Info.ElementIndex;
   }
   default:
     llvm_unreachable("unknown relocation type");
   }
 }
 
 // Translate from the relocation's index into the final linked output value.
-uint64_t ObjFile::calcNewValue(const WasmRelocation &reloc, uint64_t tombstone) const {
+uint64_t ObjFile::calcNewValue(const WasmRelocation &reloc, uint64_t tombstone,
+                               const InputChunk *chunk) 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 a tombstone value in debug symbol sections
     // so this will not produce a valid range conflicting with ranges of actual
     // code. In other sections we return reloc.Addend.
uint64_t ObjFile::calcNewValue(const WasmRelocation &reloc, uint64_t tombstone,
   }
   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_MEMORY_ADDR_I64:
+  case R_WASM_MEMORY_ADDR_LOCREL_I32: {
     if (isa<UndefinedData>(sym) || sym->isUndefWeak())
       return 0;
     auto D = cast<DefinedData>(sym);
     // Treat non-TLS relocation against symbols that live in the TLS segment
     // like TLS relocations.  This beaviour exists to support older object
     // files created before we introduced TLS relocations.
     // TODO(sbc): Remove this legacy behaviour one day.  This will break
     // backward compat with old object files built with `-fPIC`.
     if (D->segment && D->segment->outputSeg->name == ".tdata")
       return D->getOutputSegmentOffset() + reloc.Addend;
-    return D->getVA(reloc.Addend);
+
+    uint64_t value = D->getVA(reloc.Addend);
+    if (reloc.Type == R_WASM_MEMORY_ADDR_LOCREL_I32) {
+      const auto *segment = cast<InputSegment>(chunk);
+      uint64_t p = segment->outputSeg->startVA + segment->outputSegmentOffset +
+                   reloc.Offset - segment->getInputSectionOffset();
+      value -= p;
+    }
+    return value;
   }
   case R_WASM_MEMORY_ADDR_TLS_SLEB:
     if (isa<UndefinedData>(sym) || sym->isUndefWeak())
       return 0;
     // TLS relocations are relative to the start of the TLS output segment
     return cast<DefinedData>(sym)->getOutputSegmentOffset() + reloc.Addend;
   case R_WASM_TYPE_INDEX_LEB:
     return typeMap[reloc.Index];

llvm/include/llvm/BinaryFormat/WasmRelocs.def

 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)
 WASM_RELOC(R_WASM_TABLE_INDEX_SLEB64,     18)
 WASM_RELOC(R_WASM_TABLE_INDEX_I64,        19)
 WASM_RELOC(R_WASM_TABLE_NUMBER_LEB,       20)
 WASM_RELOC(R_WASM_MEMORY_ADDR_TLS_SLEB,   21)
 WASM_RELOC(R_WASM_FUNCTION_OFFSET_I64,    22)
+WASM_RELOC(R_WASM_MEMORY_ADDR_LOCREL_I32, 23)

llvm/include/llvm/MC/MCWasmObjectWriter.h

 public:
   virtual ~MCWasmObjectTargetWriter();
 
   Triple::ObjectFormatType getFormat() const override { return Triple::Wasm; }
   static bool classof(const MCObjectTargetWriter *W) {
     return W->getFormat() == Triple::Wasm;
   }
 
-  virtual unsigned getRelocType(const MCValue &Target,
-                                const MCFixup &Fixup) const = 0;
+  virtual unsigned getRelocType(const MCValue &Target, const MCFixup &Fixup,
+                                bool IsLocRel) const = 0;
 
   /// \name Accessors
   /// @{
   bool is64Bit() const { return Is64Bit; }
   bool isEmscripten() const { return IsEmscripten; }
   /// @}
 };
 

llvm/lib/BinaryFormat/Wasm.cpp

bool llvm::wasm::relocTypeHasAddend(uint32_t Type) {
   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_MEMORY_ADDR_TLS_SLEB:
   case R_WASM_FUNCTION_OFFSET_I32:
   case R_WASM_FUNCTION_OFFSET_I64:
   case R_WASM_SECTION_OFFSET_I32:
+  case R_WASM_MEMORY_ADDR_LOCREL_I32:
     return true;
   default:
     return false;
   }
 }

llvm/lib/MC/WasmObjectWriter.cpp

void WasmObjectWriter::recordRelocation(MCAssembler &Asm,
   // The WebAssembly backend should never generate FKF_IsPCRel fixups
   assert(!(Asm.getBackend().getFixupKindInfo(Fixup.getKind()).Flags &
            MCFixupKindInfo::FKF_IsPCRel));
 
   const auto &FixupSection = cast<MCSectionWasm>(*Fragment->getParent());
   uint64_t C = Target.getConstant();
   uint64_t FixupOffset = Layout.getFragmentOffset(Fragment) + Fixup.getOffset();
   MCContext &Ctx = Asm.getContext();
+  bool IsLocRel = false;
 
   if (const MCSymbolRefExpr *RefB = Target.getSymB()) {
-    // To get here the A - B expression must have failed evaluateAsRelocatable.
-    // This means either A or B must be undefined and in WebAssembly we can't
-    // support either of those cases.
+
     const auto &SymB = cast<MCSymbolWasm>(RefB->getSymbol());
-    Ctx.reportError(
-        Fixup.getLoc(),
+
+    if (FixupSection.getKind().isText()) {
+      Ctx.reportError(Fixup.getLoc(),
                       Twine("symbol '") + SymB.getName() +
-            "': unsupported subtraction expression used in relocation.");
+                          "' unsupported subtraction expression used in "
+                          "relocation in code section.");
       return;
     }
 
+    if (SymB.isUndefined()) {
+      Ctx.reportError(Fixup.getLoc(),
+                      Twine("symbol '") + SymB.getName() +
+                          "' can not be undefined in a subtraction expression");
+      return;
+    }
+    const MCSection &SecB = SymB.getSection();
+    if (&SecB != &FixupSection) {
+      Ctx.reportError(Fixup.getLoc(),
+                      Twine("symbol '") + SymB.getName() +
+                          "' can not be placed in a different section");
+      return;
+    }
+    IsLocRel = true;
+    C += FixupOffset - Layout.getSymbolOffset(SymB);
+  }
+
   // We either rejected the fixup or folded B into C at this point.
   const MCSymbolRefExpr *RefA = Target.getSymA();
   const auto *SymA = cast<MCSymbolWasm>(&RefA->getSymbol());
 
   // The .init_array isn't translated as data, so don't do relocations in it.
   if (FixupSection.getName().startswith(".init_array")) {
     SymA->setUsedInInitArray();
     return;
   }
 
   if (SymA->isVariable()) {
     const MCExpr *Expr = SymA->getVariableValue();
     if (const auto *Inner = dyn_cast<MCSymbolRefExpr>(Expr))
       if (Inner->getKind() == MCSymbolRefExpr::VK_WEAKREF)
         llvm_unreachable("weakref used in reloc not yet implemented");
   }
 
   // Put any constant offset in an addend. Offsets can be negative, and
   // LLVM expects wrapping, in contrast to wasm's immediates which can't
   // be negative and don't wrap.
   FixedValue = 0;
 
-  unsigned Type = TargetObjectWriter->getRelocType(Target, Fixup);
+  unsigned Type = TargetObjectWriter->getRelocType(Target, Fixup, IsLocRel);
 
   // 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_WASM_FUNCTION_OFFSET_I32 ||
       Type == wasm::R_WASM_FUNCTION_OFFSET_I64 ||
       Type == wasm::R_WASM_SECTION_OFFSET_I32) {
     if (!FixupSection.getKind().isMetadata())
WasmObjectWriter::getProvisionalValue(const WasmRelocationEntry &RelEntry,
   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_REL_SLEB:
   case wasm::R_WASM_MEMORY_ADDR_REL_SLEB64:
   case wasm::R_WASM_MEMORY_ADDR_I32:
   case wasm::R_WASM_MEMORY_ADDR_I64:
-  case wasm::R_WASM_MEMORY_ADDR_TLS_SLEB: {
+  case wasm::R_WASM_MEMORY_ADDR_TLS_SLEB:
+  case wasm::R_WASM_MEMORY_ADDR_LOCREL_I32: {
     // Provisional value is address of the global plus the offset
     // For undefined symbols, use zero
     if (!RelEntry.Symbol->isDefined())
       return 0;
     const wasm::WasmDataReference &SymRef = DataLocations[RelEntry.Symbol];
     const WasmDataSegment &Segment = DataSegments[SymRef.Segment];
     // Ignore overflow. LLVM allows address arithmetic to silently wrap.
     return Segment.Offset + SymRef.Offset + RelEntry.Addend;
for (const WasmRelocationEntry &RelEntry : Relocations) {
     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:
+    case wasm::R_WASM_MEMORY_ADDR_LOCREL_I32:
       patchI32(Stream, Value, Offset);
       break;
     case wasm::R_WASM_TABLE_INDEX_I64:
     case wasm::R_WASM_MEMORY_ADDR_I64:
     case wasm::R_WASM_FUNCTION_OFFSET_I64:
       patchI64(Stream, Value, Offset);
       break;
     case wasm::R_WASM_TABLE_INDEX_SLEB:

llvm/lib/Object/RelocationResolver.cpp

static bool supportsWasm32(uint64_t Type) {
   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:
   case wasm::R_WASM_GLOBAL_INDEX_I32:
   case wasm::R_WASM_TABLE_NUMBER_LEB:
+  case wasm::R_WASM_MEMORY_ADDR_LOCREL_I32:
     return true;
   default:
     return false;
   }
 }
 
 static bool supportsWasm64(uint64_t Type) {
   switch (Type) {
static uint64_t resolveWasm32(uint64_t Type, uint64_t Offset, uint64_t S,
   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:
   case wasm::R_WASM_GLOBAL_INDEX_I32:
   case wasm::R_WASM_TABLE_NUMBER_LEB:
+  case wasm::R_WASM_MEMORY_ADDR_LOCREL_I32:
     // For wasm section, its offset at 0 -- ignoring Value
     return LocData;
   default:
     llvm_unreachable("Invalid relocation type");
   }
 }
 
 static uint64_t resolveWasm64(uint64_t Type, uint64_t Offset, uint64_t S,

llvm/lib/Object/WasmObjectFile.cpp

case wasm::R_WASM_EVENT_INDEX_LEB:
         return make_error<GenericBinaryError>("invalid relocation event index",
                                               object_error::parse_failed);
       break;
     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_MEMORY_ADDR_REL_SLEB:
     case wasm::R_WASM_MEMORY_ADDR_TLS_SLEB:
+    case wasm::R_WASM_MEMORY_ADDR_LOCREL_I32:
       if (!isValidDataSymbol(Reloc.Index))
         return make_error<GenericBinaryError>("invalid 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:
while (RelocCount--) {
     // 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_MEMORY_ADDR_LOCREL_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_TABLE_INDEX_I64 ||
         Reloc.Type == wasm::R_WASM_MEMORY_ADDR_I64 ||
         Reloc.Type == wasm::R_WASM_FUNCTION_OFFSET_I64)
       Size = 8;

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

 using namespace llvm;
 
 namespace {
 class WebAssemblyWasmObjectWriter final : public MCWasmObjectTargetWriter {
 public:
   explicit WebAssemblyWasmObjectWriter(bool Is64Bit, bool IsEmscripten);
 
 private:
-  unsigned getRelocType(const MCValue &Target,
-                        const MCFixup &Fixup) const override;
+  unsigned getRelocType(const MCValue &Target, const MCFixup &Fixup,
+                        bool IsLocRel) const override;
 };
 } // end anonymous namespace
 
 WebAssemblyWasmObjectWriter::WebAssemblyWasmObjectWriter(bool Is64Bit,
                                                          bool IsEmscripten)
     : MCWasmObjectTargetWriter(Is64Bit, IsEmscripten) {}
 
 static const MCSection *getFixupSection(const MCExpr *Expr) {
static const MCSection *getFixupSection(const MCExpr *Expr) {
 
   if (auto UnOp = dyn_cast<MCUnaryExpr>(Expr))
     return getFixupSection(UnOp->getSubExpr());
 
   return nullptr;
 }
 
 unsigned WebAssemblyWasmObjectWriter::getRelocType(const MCValue &Target,
-                                                   const MCFixup &Fixup) const {
+                                                   const MCFixup &Fixup,
+                                                   bool IsLocRel) const {
   const MCSymbolRefExpr *RefA = Target.getSymA();
   assert(RefA);
   auto& SymA = cast<MCSymbolWasm>(RefA->getSymbol());
 
   MCSymbolRefExpr::VariantKind Modifier = Target.getAccessVariant();
 
   switch (Modifier) {
     case MCSymbolRefExpr::VK_GOT:
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;
+    return IsLocRel ? wasm::R_WASM_MEMORY_ADDR_LOCREL_I32
+                    : wasm::R_WASM_MEMORY_ADDR_I32;
   case FK_Data_8:
     if (SymA.isFunction())
       return wasm::R_WASM_TABLE_INDEX_I64;
     if (SymA.isGlobal())
       llvm_unreachable("unimplemented R_WASM_GLOBAL_INDEX_I64");
     if (auto Section = static_cast<const MCSectionWasm *>(
             getFixupSection(Fixup.getValue()))) {
       if (Section->getKind().isText())

llvm/test/MC/WebAssembly/bad-fixup-expr.s

 // RUN: not llvm-mc -filetype=obj -triple wasm32 %s -o /dev/null 2>&1 | FileCheck %s
 
   .section    .data.foo,"",@
 foo:
   .int8       1
   .size       foo, 1
 foo_other:
   .int8       1
   .size       foo_other, 1
 
   .section    .data.bar,"",@
 bar:
   .int8       1
   .size       bar, 1
 
+  .section    .data.fizz,"",@
+fizz:
+  .int8       1
+  .size       fizz, 1
+
+  .section    .data.segment1,"",@
+segment1:
+// CHECK: 'bar' can not be placed in a different section
+  .int32 fizz-bar
+// CHECK: 'undef_baz' can not be undefined in a subtraction expression
+  .int32 fizz-undef_baz
+// CHECK: 'fizz' can not be placed in a different section
+  .int32 undef_baz-fizz
+  .size       segment1, 12
+
+
   .text
   .section    .text.main,"",@
 main:
   .functype   main () -> (i32)
 // Expressions involving symbols within the same sections can be evaluated
 // prior to writing the object file.
 // CHECK-NOT: foo
   i32.const foo-foo_other+2
   i32.const foo_other-foo-10
 
-// CHECK: 'bar': unsupported subtraction expression used in relocation
+// CHECK: 'bar' unsupported subtraction expression used in relocation in code section.
   i32.const foo-bar
-// CHECK: 'undef_baz': unsupported subtraction expression used in relocation
+// CHECK: 'undef_baz' unsupported subtraction expression used in relocation in code section.
   i32.const foo-undef_baz
-// CHECK: 'foo': unsupported subtraction expression used in relocation
+// CHECK: 'foo' unsupported subtraction expression used in relocation in code section.
   i32.const undef_baz-foo
   end_function

llvm/test/MC/WebAssembly/reloc-relative.ll

+; RUN: llc -O0 -filetype=obj %s -o - | llvm-readobj -r --expand-relocs - | FileCheck %s
+
+; CHECK:      Format: WASM
+; CHECK:      Relocations [
+; CHECK-NEXT:   Section (3) DATA {
+; CHECK-NEXT:     Relocation {
+; CHECK-NEXT:       Type: R_WASM_MEMORY_ADDR_LOCREL_I32 (23)
+; CHECK-NEXT:       Offset: 0x6
+; CHECK-NEXT:       Symbol: foo
+; CHECK-NEXT:       Addend: 0
+; CHECK-NEXT:     }
+; CHECK-NEXT:     Relocation {
+; CHECK-NEXT:       Type: R_WASM_MEMORY_ADDR_LOCREL_I32 (23)
+; CHECK-NEXT:       Offset: 0xA
+; CHECK-NEXT:       Symbol: fizz
+; CHECK-NEXT:       Addend: 0
+; CHECK-NEXT:     }
+; CHECK-NEXT:     Relocation {
+; CHECK-NEXT:       Type: R_WASM_MEMORY_ADDR_LOCREL_I32 (23)
+; CHECK-NEXT:       Offset: 0x17
+; CHECK-NEXT:       Symbol: foo
+; CHECK-NEXT:       Addend: 4
+; CHECK-NEXT:     }
+; CHECK-NEXT:   }
+; CHECK-NEXT: ]
+
+target triple = "wasm32-unknown-unknown"
+
+
+; @foo - @bar
+@foo = external global i32, align 4
+@bar = constant i32 sub (
+    i32 ptrtoint (i32* @foo to i32),
+    i32 ptrtoint (i32* @bar to i32)
+), section ".sec1"
+
+
+; @foo - @addend + 4
+@fizz = constant i32 42, align 4, section ".sec2"
+@addend = constant i32 sub (
+    i32 ptrtoint (i32* @foo to i32),
+    i32 ptrtoint (i32* @fizz to i32)
+), section ".sec2"
+
+@x_sec = constant i32 sub (
+    i32 ptrtoint (i32* @fizz to i32),
+    i32 ptrtoint (i32* @x_sec to i32)
+), section ".sec1"