[DebugInfo] Change object::RelocationResolver to return Expected<uint64_t>

[MaskRay]

Summary

This will allow targets to add relocation overflow or misalignment checks.

[ruiu]

Could you also add an actual overflow check to some target to show that this is really required? It will also make it possible to write a test for the new code.

[mstorsjo]

lld/ELF/DWARF.cpp

60

Unrelated to this (but you seem to be fixing variable lowercasing in a comment below); S here (and A in the comment below below) are also left behind upper cased here.

[MaskRay]

Relocation overflow check is probably not necessary. RelocationResolver is mainly used by DebugInfo (the use in llvm-readobj is very light) for local symbols. It is difficult to create any relocation overflow problems with meaningful tests. A somewhat clean approach to detect overflows:

+static Expected<uint64_t> reportError(const char *type, const Twine &v,
+                                      int64_t min, uint64_t max) {
+  return createStringError(inconvertibleErrorCode(),
+                           "relocation " + Twine(type) +
+                               " out of range: " + Twine(v) + " is not in [" +
+                               Twine(min) + ", " + Twine(max) + "]");
+}
+
+static Expected<uint64_t> checkInt(const char *type, int64_t v, int n) {
+  if (v == llvm::SignExtend64(v, n))
+    return v;
+  return reportError(type, Twine(v), minIntN(n), maxIntN(n));
+}

-  case ELF::R_X86_64_PC32:
-    return S + getELFAddend(R) - R.getOffset();
+  case ELF::R_X86_64_PC32: {
+    uint64_t V =  S + getELFAddend(R) - R.getOffset();
+    return checkInt("R_X86_64_PC32", V, 32);  // Passing the string literal is clumsy.
+  }

Passing the string literal to checkInt is clumsy, but the lld way may be too heavyweight?

StringRef llvm::object::getELFRelocationTypeName(uint32_t Machine,
                                                 uint32_t Type) {
  switch (Machine) {
  case ELF::EM_X86_64:
    switch (Type) {
#include "llvm/BinaryFormat/ELFRelocs/x86_64.def"
    default:
      break;
    }
    break;

I'll probably abandon this if people don't think error reporting is useful here.

[labath]

I believe error handling is important. And even more important is testing of that error handling -- as I'm trying to use llvm dwarf parser in lldb I keep finding new ways to crash it with invalid input.

In D63713, we (mainly I, I guess) tried to make checking for errors less verbose by making it possible to check for DataExtractor errors in bulk via the "Cursor" class. This is the first real test of that API, and I am afraid I have to say it's not looking too good. It (I hope) made the usage of that class easier, but it requires one to be careful when writing the code "on the inside". I explain more in the inline comment.

Since you're the first person after me who has to edit this code, I'd be very interested in any feedback you have about this.

llvm/lib/DebugInfo/DWARF/DWARFDataExtractor.cpp

24

The tricky part here is that you cannot assume that the Error argument is always set, and you need to make sure to avoid tripping any Error assertions while making sure that the user still needs to check the error object. I was able to get away without doing any of this in this function, because the only way it could fail is through the getUnsigned function, which already does this tiptoe-ing. However, as you're introducing additional failure points here, you'll need to do that here as well.
The right incantation for that would be to insert:

ErrorAsOutParameter ErrAsOut(Err);
if (Err && *Err)
  return A;

here and then set the error object via if (Err) *Err = R.takeError() else consumeError(R.takeError()) below.

This means that the error will be ignored in some cases, but that's the best we can to if the user has chosen not to receive errors (which has been the only way to use the data extractor until very recently).

[MaskRay]

Address review comments

[MaskRay]

Address review comments

(Last update sent too fast. I still prefer multi repo but have to use a monorepo as the change touches lld - I know that the world is moving toward a monorepo - I just don't like pulling in lots of unrelevant changes with a monorepo)

[MaskRay]

llvm/lib/DebugInfo/DWARF/DWARFDataExtractor.cpp

24

Thanks for the suggestion. (I was ready to abandon this but it looks like there is value with this change)

Do you have suggestions how I should test this change? No call site passes in the Error parameter when calling getRelocatedAddress. I am not sure what is the simplest way to let the various .debug* parser stop parsing immediately.

The test should probably use yaml2obj.

lld/ELF/DWARF.cpp

else if (sec->name == ".debug_str")
       strSection = toStringRef(sec->data());
     else if (sec->name == ".debug_line_str")
       lineStrSection = toStringRef(sec->data());
   }
 }
 
 namespace {
 template <class RelTy> struct LLDRelocationResolver {
-  // In the ELF ABIs, S sepresents the value of the symbol in the relocation
+  // In the ELF ABIs, s sepresents the value of the symbol in the relocation
   // entry. For Rela, the addend is stored as part of the relocation entry.
-  static uint64_t resolve(object::RelocationRef ref, uint64_t s,
-                          uint64_t /* A */) {
+  static Expected<uint64_t> resolve(object::RelocationRef ref, uint64_t s,
+                                    uint64_t /*a*/) {
     return s + ref.getRawDataRefImpl().p;
   }
 };
 
 template <class ELFT> struct LLDRelocationResolver<Elf_Rel_Impl<ELFT, false>> {
-  // For Rel, the addend A is supplied by the caller.
-  static uint64_t resolve(object::RelocationRef /*Ref*/, uint64_t s,
+  // For Rel, the addend a is supplied by the caller.
+  static Expected<uint64_t> resolve(object::RelocationRef /*ref*/, uint64_t s,
                                     uint64_t a) {
     return s + a;
   }
 };
 } // namespace
 
 // Find if there is a relocation at Pos in Sec.  The code is a bit
 // more complicated than usual because we need to pass a section index
 // to llvm since it has no idea about InputSection.

llvm/include/llvm/Object/RelocationResolver.h

 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 #include <cstdint>
 #include <system_error>
 
 namespace llvm {
 namespace object {
 
-using RelocationResolver = uint64_t (*)(RelocationRef R, uint64_t S, uint64_t A);
+using RelocationResolver = Expected<uint64_t> (*)(RelocationRef R, uint64_t S,
+                                                  uint64_t A);
 
 std::pair<bool (*)(uint64_t), RelocationResolver>
 getRelocationResolver(const ObjectFile &Obj);
 
 } // end namespace object
 } // end namespace llvm
 
 #endif // LLVM_OBJECT_RELOCVISITOR_H

llvm/lib/DebugInfo/DWARF/DWARFDataExtractor.cpp

uint64_t DWARFDataExtractor::getRelocatedValue(uint32_t Size, uint64_t *Off,
                                                uint64_t *SecNdx,
                                                Error *Err) const {
   if (SecNdx)
     *SecNdx = object::SectionedAddress::UndefSection;
   if (!Section)
     return getUnsigned(Off, Size, Err);
   Optional<RelocAddrEntry> E = Obj->find(*Section, *Off);
   uint64_t A = getUnsigned(Off, Size, Err);
   if (!E)
     return A;
   if (SecNdx)
     *SecNdx = E->SectionIndex;
-  uint64_t R = E->Resolver(E->Reloc, E->SymbolValue, A);
-  if (E->Reloc2)
-    R = E->Resolver(*E->Reloc2, E->SymbolValue2, R);
-  return R;
+  ErrorAsOutParameter ErrAsOut(Err);
+  if (Err && *Err)
+    return A;
+
+  Expected<uint64_t> R = E->Resolver(E->Reloc, E->SymbolValue, A);
+  if (E->Reloc2 && R)
+    R = E->Resolver(*E->Reloc2, E->SymbolValue2, *R);
+  if (R)
+    return *R;
+  if (Err)
+    *Err = R.takeError();
+  else
+    consumeError(R.takeError());
+  return A;
 }
 
 Optional<uint64_t>
 DWARFDataExtractor::getEncodedPointer(uint64_t *Offset, uint8_t Encoding,
                                       uint64_t PCRelOffset) const {
   if (Encoding == dwarf::DW_EH_PE_omit)
     return None;
 

llvm/lib/Object/RelocationResolver.cpp

 static int64_t getELFAddend(RelocationRef R) {
   Expected<int64_t> AddendOrErr = ELFRelocationRef(R).getAddend();
   handleAllErrors(AddendOrErr.takeError(), [](const ErrorInfoBase &EI) {
     report_fatal_error(EI.message());
   });
   return *AddendOrErr;
 }
 
+static Expected<uint64_t> reportError(StringRef type, const Twine &v,
+                                      int64_t min, uint64_t max) {
+  return createStringError(inconvertibleErrorCode(),
+                           "relocation " + type + " out of range: " + Twine(v) +
+                               " is not in [" + Twine(min) + ", " + Twine(max) +
+                               "]");
+}
+
+static Expected<uint64_t> checkInt(uint32_t machine, uint32_t type, int64_t v, int n) {
+  if (v == llvm::SignExtend64(v, n))
+    return v;
+  return reportError(getELFRelocationTypeName(machine, type), Twine(v),
+                     minIntN(n), maxIntN(n));
+}
+
 static bool supportsX86_64(uint64_t Type) {
   switch (Type) {
   case ELF::R_X86_64_NONE:
   case ELF::R_X86_64_64:
   case ELF::R_X86_64_DTPOFF32:
   case ELF::R_X86_64_DTPOFF64:
   case ELF::R_X86_64_PC32:
   case ELF::R_X86_64_32:
   case ELF::R_X86_64_32S:
     return true;
   default:
     return false;
   }
 }
 
-static uint64_t resolveX86_64(RelocationRef R, uint64_t S, uint64_t A) {
-  switch (R.getType()) {
+static Expected<uint64_t> resolveX86_64(RelocationRef r, uint64_t s,
+                                        uint64_t /*a*/) {
+  uint32_t type = r.getType();
+  uint64_t a = getELFAddend(r);
+  switch (type) {
   case ELF::R_X86_64_NONE:
-    return A;
+    return a;
   case ELF::R_X86_64_64:
   case ELF::R_X86_64_DTPOFF32:
   case ELF::R_X86_64_DTPOFF64:
-    return S + getELFAddend(R);
-  case ELF::R_X86_64_PC32:
-    return S + getELFAddend(R) - R.getOffset();
+    return s + a;
+  case ELF::R_X86_64_PC32: {
+    uint64_t v =  s + a - r.getOffset();
+    return checkInt(ELF::EM_X86_64, type, v, 32);
+  }
   case ELF::R_X86_64_32:
   case ELF::R_X86_64_32S:
-    return (S + getELFAddend(R)) & 0xFFFFFFFF;
+    return (s + a) & 0xFFFFFFFF;
   default:
     llvm_unreachable("Invalid relocation type");
   }
 }
 
 static bool supportsAArch64(uint64_t Type) {
   switch (Type) {
   case ELF::R_AARCH64_ABS32:
   case ELF::R_AARCH64_ABS64:
     return true;
   default:
     return false;
   }
 }
 
-static uint64_t resolveAArch64(RelocationRef R, uint64_t S, uint64_t A) {
+static Expected<uint64_t> resolveAArch64(RelocationRef R, uint64_t S,
+                                         uint64_t A) {
   switch (R.getType()) {
   case ELF::R_AARCH64_ABS32:
     return (S + getELFAddend(R)) & 0xFFFFFFFF;
   case ELF::R_AARCH64_ABS64:
     return S + getELFAddend(R);
   default:
     llvm_unreachable("Invalid relocation type");
   }
 }
 
 static bool supportsBPF(uint64_t Type) {
   switch (Type) {
   case ELF::R_BPF_64_32:
   case ELF::R_BPF_64_64:
     return true;
   default:
     return false;
   }
 }
 
-static uint64_t resolveBPF(RelocationRef R, uint64_t S, uint64_t A) {
+static Expected<uint64_t> resolveBPF(RelocationRef R, uint64_t S, uint64_t A) {
   switch (R.getType()) {
   case ELF::R_BPF_64_32:
     return (S + A) & 0xFFFFFFFF;
   case ELF::R_BPF_64_64:
     return S + A;
   default:
     llvm_unreachable("Invalid relocation type");
   }
 }
 
 static bool supportsMips64(uint64_t Type) {
   switch (Type) {
   case ELF::R_MIPS_32:
   case ELF::R_MIPS_64:
   case ELF::R_MIPS_TLS_DTPREL64:
     return true;
   default:
     return false;
   }
 }
 
-static uint64_t resolveMips64(RelocationRef R, uint64_t S, uint64_t A) {
+static Expected<uint64_t> resolveMips64(RelocationRef R, uint64_t S,
+                                        uint64_t A) {
   switch (R.getType()) {
   case ELF::R_MIPS_32:
     return (S + getELFAddend(R)) & 0xFFFFFFFF;
   case ELF::R_MIPS_64:
     return S + getELFAddend(R);
   case ELF::R_MIPS_TLS_DTPREL64:
     return S + getELFAddend(R) - 0x8000;
   default:
     llvm_unreachable("Invalid relocation type");
   }
 }
 
 static bool supportsPPC64(uint64_t Type) {
   switch (Type) {
   case ELF::R_PPC64_ADDR32:
   case ELF::R_PPC64_ADDR64:
     return true;
   default:
     return false;
   }
 }
 
-static uint64_t resolvePPC64(RelocationRef R, uint64_t S, uint64_t A) {
+static Expected<uint64_t> resolvePPC64(RelocationRef R, uint64_t S,
+                                       uint64_t A) {
   switch (R.getType()) {
   case ELF::R_PPC64_ADDR32:
     return (S + getELFAddend(R)) & 0xFFFFFFFF;
   case ELF::R_PPC64_ADDR64:
     return S + getELFAddend(R);
   default:
     llvm_unreachable("Invalid relocation type");
   }
 }
 
 static bool supportsSystemZ(uint64_t Type) {
   switch (Type) {
   case ELF::R_390_32:
   case ELF::R_390_64:
     return true;
   default:
     return false;
   }
 }
 
-static uint64_t resolveSystemZ(RelocationRef R, uint64_t S, uint64_t A) {
+static Expected<uint64_t> resolveSystemZ(RelocationRef R, uint64_t S,
+                                         uint64_t A) {
   switch (R.getType()) {
   case ELF::R_390_32:
     return (S + getELFAddend(R)) & 0xFFFFFFFF;
   case ELF::R_390_64:
     return S + getELFAddend(R);
   default:
     llvm_unreachable("Invalid relocation type");
   }
 }
 
 static bool supportsSparc64(uint64_t Type) {
   switch (Type) {
   case ELF::R_SPARC_32:
   case ELF::R_SPARC_64:
   case ELF::R_SPARC_UA32:
   case ELF::R_SPARC_UA64:
     return true;
   default:
     return false;
   }
 }
 
-static uint64_t resolveSparc64(RelocationRef R, uint64_t S, uint64_t A) {
+static Expected<uint64_t> resolveSparc64(RelocationRef R, uint64_t S,
+                                         uint64_t A) {
   switch (R.getType()) {
   case ELF::R_SPARC_32:
   case ELF::R_SPARC_64:
   case ELF::R_SPARC_UA32:
   case ELF::R_SPARC_UA64:
     return S + getELFAddend(R);
   default:
     llvm_unreachable("Invalid relocation type");
   }
 }
 
 static bool supportsAmdgpu(uint64_t Type) {
   switch (Type) {
   case ELF::R_AMDGPU_ABS32:
   case ELF::R_AMDGPU_ABS64:
     return true;
   default:
     return false;
   }
 }
 
-static uint64_t resolveAmdgpu(RelocationRef R, uint64_t S, uint64_t A) {
+static Expected<uint64_t> resolveAmdgpu(RelocationRef R, uint64_t S,
+                                        uint64_t A) {
   switch (R.getType()) {
   case ELF::R_AMDGPU_ABS32:
   case ELF::R_AMDGPU_ABS64:
     return S + getELFAddend(R);
   default:
     llvm_unreachable("Invalid relocation type");
   }
 }
 
 static bool supportsX86(uint64_t Type) {
   switch (Type) {
   case ELF::R_386_NONE:
   case ELF::R_386_32:
   case ELF::R_386_PC32:
     return true;
   default:
     return false;
   }
 }
 
-static uint64_t resolveX86(RelocationRef R, uint64_t S, uint64_t A) {
+static Expected<uint64_t> resolveX86(RelocationRef R, uint64_t S, uint64_t A) {
   switch (R.getType()) {
   case ELF::R_386_NONE:
     return A;
   case ELF::R_386_32:
     return S + A;
   case ELF::R_386_PC32:
     return S - R.getOffset() + A;
   default:
     llvm_unreachable("Invalid relocation type");
   }
 }
 
 static bool supportsPPC32(uint64_t Type) {
   return Type == ELF::R_PPC_ADDR32;
 }
 
-static uint64_t resolvePPC32(RelocationRef R, uint64_t S, uint64_t A) {
+static Expected<uint64_t> resolvePPC32(RelocationRef R, uint64_t S,
+                                       uint64_t A) {
   if (R.getType() == ELF::R_PPC_ADDR32)
     return (S + getELFAddend(R)) & 0xFFFFFFFF;
   llvm_unreachable("Invalid relocation type");
 }
 
 static bool supportsARM(uint64_t Type) {
   return Type == ELF::R_ARM_ABS32;
 }
 
-static uint64_t resolveARM(RelocationRef R, uint64_t S, uint64_t A) {
+static Expected<uint64_t> resolveARM(RelocationRef R, uint64_t S, uint64_t A) {
   if (R.getType() == ELF::R_ARM_ABS32)
     return (S + A) & 0xFFFFFFFF;
   llvm_unreachable("Invalid relocation type");
 }
 
 static bool supportsAVR(uint64_t Type) {
   switch (Type) {
   case ELF::R_AVR_16:
   case ELF::R_AVR_32:
     return true;
   default:
     return false;
   }
 }
 
-static uint64_t resolveAVR(RelocationRef R, uint64_t S, uint64_t A) {
+static Expected<uint64_t> resolveAVR(RelocationRef R, uint64_t S, uint64_t A) {
   switch (R.getType()) {
   case ELF::R_AVR_16:
     return (S + getELFAddend(R)) & 0xFFFF;
   case ELF::R_AVR_32:
     return (S + getELFAddend(R)) & 0xFFFFFFFF;
   default:
     llvm_unreachable("Invalid relocation type");
   }
 }
 
 static bool supportsLanai(uint64_t Type) {
   return Type == ELF::R_LANAI_32;
 }
 
-static uint64_t resolveLanai(RelocationRef R, uint64_t S, uint64_t A) {
+static Expected<uint64_t> resolveLanai(RelocationRef R, uint64_t S,
+                                       uint64_t A) {
   if (R.getType() == ELF::R_LANAI_32)
     return (S + getELFAddend(R)) & 0xFFFFFFFF;
   llvm_unreachable("Invalid relocation type");
 }
 
 static bool supportsMips32(uint64_t Type) {
   switch (Type) {
   case ELF::R_MIPS_32:
   case ELF::R_MIPS_TLS_DTPREL32:
     return true;
   default:
     return false;
   }
 }
 
-static uint64_t resolveMips32(RelocationRef R, uint64_t S, uint64_t A) {
+static Expected<uint64_t> resolveMips32(RelocationRef R, uint64_t S,
+                                        uint64_t A) {
   // FIXME: Take in account implicit addends to get correct results.
   uint32_t Rel = R.getType();
   if (Rel == ELF::R_MIPS_32)
     return (S + A) & 0xFFFFFFFF;
   if (Rel == ELF::R_MIPS_TLS_DTPREL32)
     return (S + A) & 0xFFFFFFFF;
   llvm_unreachable("Invalid relocation type");
 }
 
 static bool supportsSparc32(uint64_t Type) {
   switch (Type) {
   case ELF::R_SPARC_32:
   case ELF::R_SPARC_UA32:
     return true;
   default:
     return false;
   }
 }
 
-static uint64_t resolveSparc32(RelocationRef R, uint64_t S, uint64_t A) {
+static Expected<uint64_t> resolveSparc32(RelocationRef R, uint64_t S,
+                                         uint64_t A) {
   uint32_t Rel = R.getType();
   if (Rel == ELF::R_SPARC_32 || Rel == ELF::R_SPARC_UA32)
     return S + getELFAddend(R);
   return A;
 }
 
 static bool supportsHexagon(uint64_t Type) {
   return Type == ELF::R_HEX_32;
 }
 
-static uint64_t resolveHexagon(RelocationRef R, uint64_t S, uint64_t A) {
+static Expected<uint64_t> resolveHexagon(RelocationRef R, uint64_t S,
+                                         uint64_t A) {
   if (R.getType() == ELF::R_HEX_32)
     return S + getELFAddend(R);
   llvm_unreachable("Invalid relocation type");
 }
 
 static bool supportsRISCV(uint64_t Type) {
   switch (Type) {
   case ELF::R_RISCV_NONE:
static bool supportsRISCV(uint64_t Type) {
   case ELF::R_RISCV_ADD64:
   case ELF::R_RISCV_SUB64:
     return true;
   default:
     return false;
   }
 }
 
-static uint64_t resolveRISCV(RelocationRef R, uint64_t S, uint64_t A) {
+static Expected<uint64_t> resolveRISCV(RelocationRef R, uint64_t S,
+                                       uint64_t A) {
   int64_t RA = getELFAddend(R);
   switch (R.getType()) {
   case ELF::R_RISCV_NONE:
     return A;
   case ELF::R_RISCV_32:
     return (S + RA) & 0xFFFFFFFF;
   case ELF::R_RISCV_64:
     return S + RA;
static bool supportsCOFFX86(uint64_t Type) {
   case COFF::IMAGE_REL_I386_SECREL:
   case COFF::IMAGE_REL_I386_DIR32:
     return true;
   default:
     return false;
   }
 }
 
-static uint64_t resolveCOFFX86(RelocationRef R, uint64_t S, uint64_t A) {
+static Expected<uint64_t> resolveCOFFX86(RelocationRef R, uint64_t S,
+                                         uint64_t A) {
   switch (R.getType()) {
   case COFF::IMAGE_REL_I386_SECREL:
   case COFF::IMAGE_REL_I386_DIR32:
     return (S + A) & 0xFFFFFFFF;
   default:
     llvm_unreachable("Invalid relocation type");
   }
 }
 
 static bool supportsCOFFX86_64(uint64_t Type) {
   switch (Type) {
   case COFF::IMAGE_REL_AMD64_SECREL:
   case COFF::IMAGE_REL_AMD64_ADDR64:
     return true;
   default:
     return false;
   }
 }
 
-static uint64_t resolveCOFFX86_64(RelocationRef R, uint64_t S, uint64_t A) {
+static Expected<uint64_t> resolveCOFFX86_64(RelocationRef R, uint64_t S,
+                                            uint64_t A) {
   switch (R.getType()) {
   case COFF::IMAGE_REL_AMD64_SECREL:
     return (S + A) & 0xFFFFFFFF;
   case COFF::IMAGE_REL_AMD64_ADDR64:
     return S + A;
   default:
     llvm_unreachable("Invalid relocation type");
   }
 }
 
+static bool supportsCOFFARM(uint64_t Type) {
+  switch (Type) {
+  case COFF::IMAGE_REL_ARM_SECREL:
+  case COFF::IMAGE_REL_ARM_ADDR32:
+    return true;
+  default:
+    return false;
+  }
+}
+
+static Expected<uint64_t> resolveCOFFARM(RelocationRef R, uint64_t S, uint64_t A) {
+  switch (R.getType()) {
+  case COFF::IMAGE_REL_ARM_SECREL:
+  case COFF::IMAGE_REL_ARM_ADDR32:
+    return (S + A) & 0xFFFFFFFF;
+  default:
+    llvm_unreachable("Invalid relocation type");
+  }
+}
+
+static bool supportsCOFFARM64(uint64_t Type) {
+  switch (Type) {
+  case COFF::IMAGE_REL_ARM64_SECREL:
+  case COFF::IMAGE_REL_ARM64_ADDR64:
+    return true;
+  default:
+    return false;
+  }
+}
+
+static Expected<uint64_t> resolveCOFFARM64(RelocationRef R, uint64_t S,
+                                           uint64_t A) {
+  switch (R.getType()) {
+  case COFF::IMAGE_REL_ARM64_SECREL:
+    return (S + A) & 0xFFFFFFFF;
+  case COFF::IMAGE_REL_ARM64_ADDR64:
+    return S + A;
+  default:
+    llvm_unreachable("Invalid relocation type");
+  }
+}
+
 static bool supportsMachOX86_64(uint64_t Type) {
   return Type == MachO::X86_64_RELOC_UNSIGNED;
 }
 
-static uint64_t resolveMachOX86_64(RelocationRef R, uint64_t S, uint64_t A) {
+static Expected<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) {
   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_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:
     return true;
   default:
     return false;
   }
 }
 
-static uint64_t resolveWasm32(RelocationRef R, uint64_t S, uint64_t A) {
+static Expected<uint64_t> resolveWasm32(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_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 A;
   default:
     llvm_unreachable("Invalid relocation type");
   }
 }
 
 std::pair<bool (*)(uint64_t), RelocationResolver>
 getRelocationResolver(const ObjectFile &Obj) {
   if (Obj.isCOFF()) {
-    if (Obj.getBytesInAddress() == 8)
+    switch (Obj.getArch()) {
+    case Triple::x86_64:
       return {supportsCOFFX86_64, resolveCOFFX86_64};
+    case Triple::x86:
       return {supportsCOFFX86, resolveCOFFX86};
+    case Triple::arm:
+    case Triple::thumb:
+      return {supportsCOFFARM, resolveCOFFARM};
+    case Triple::aarch64:
+      return {supportsCOFFARM64, resolveCOFFARM64};
+    default:
+      return {nullptr, nullptr};
+    }
   } else if (Obj.isELF()) {
     if (Obj.getBytesInAddress() == 8) {
       switch (Obj.getArch()) {
       case Triple::x86_64:
         return {supportsX86_64, resolveX86_64};
       case Triple::aarch64:
       case Triple::aarch64_be:
         return {supportsAArch64, resolveAArch64};

llvm/tools/llvm-readobj/ELFDumper.cpp

if (!Data.isValidOffsetForDataOfSize(Offset, sizeof(Elf_Addr) + 1))
     reportError(
         createStringError(object_error::parse_failed,
                           "found invalid relocation offset into section %s "
                           "while trying to extract a stack size entry",
                           StackSizeSectionName.data()),
         FileStr);
 
   uint64_t Addend = Data.getAddress(&Offset);
-  uint64_t SymValue = Resolver(Reloc, RelocSymValue, Addend);
-  this->printFunctionStackSize(Obj, SymValue, FunctionSec, StackSizeSectionName,
-                               Data, &Offset);
+  if (Expected<uint64_t> SymValue = Resolver(Reloc, RelocSymValue, Addend))
+    this->printFunctionStackSize(Obj, *SymValue, FunctionSec,
+                                 StackSizeSectionName, Data, &Offset);
+  else
+    reportWarning(SymValue.takeError(), FileStr);
 }
 
 template <class ELFT>
 SectionRef toSectionRef(const ObjectFile *Obj, const typename ELFT::Shdr *Sec) {
   DataRefImpl DRI;
   DRI.p = reinterpret_cast<uintptr_t>(Sec);
   return SectionRef(DRI, Obj);
 }