Fix overflow check of r_386_pc16

[• espindola]

Summary

This a partial change to show what is needed to correctly check r_386_pc16.

ELF/InputSection.cpp

static uint64_t getRelocTargetVA(uint32_t Type, int64_t A, uint64_t P,
   case R_RELAX_GOT_PC_NOPIC:
     return Body.getVA(A);
   case R_ARM_SBREL:
     return Body.getVA(A) - getARMStaticBase(Body);
   case R_GOT:
   case R_RELAX_TLS_GD_TO_IE_ABS:
     return Body.getGotVA() + A;
   case R_GOTONLY_PC:
-    return InX::Got->getVA() + A - P;
+    return InX::Got->getVA() + A;
   case R_GOTONLY_PC_FROM_END:
-    return InX::Got->getVA() + A - P + InX::Got->getSize();
+    return InX::Got->getVA() + A + InX::Got->getSize();
   case R_GOTREL:
     return Body.getVA(A) - InX::Got->getVA();
   case R_GOTREL_FROM_END:
     return Body.getVA(A) - InX::Got->getVA() - InX::Got->getSize();
   case R_GOT_FROM_END:
   case R_RELAX_TLS_GD_TO_IE_END:
     return Body.getGotOffset() + A - InX::Got->getSize();
   case R_GOT_OFF:
     return Body.getGotOffset() + A;
   case R_GOT_PAGE_PC:
   case R_RELAX_TLS_GD_TO_IE_PAGE_PC:
-    return getAArch64Page(Body.getGotVA() + A) - getAArch64Page(P);
+    return getAArch64Page(Body.getGotVA() + A);
   case R_GOT_PC:
   case R_RELAX_TLS_GD_TO_IE:
-    return Body.getGotVA() + A - P;
+    return Body.getGotVA() + A;
   case R_HINT:
   case R_NONE:
   case R_TLSDESC_CALL:
     llvm_unreachable("cannot relocate hint relocs");
   case R_MIPS_GOTREL:
     return Body.getVA(A) - InX::MipsGot->getGp();
   case R_MIPS_GOT_GP:
     return InX::MipsGot->getGp() + A;
   case R_MIPS_GOT_GP_PC: {
     // R_MIPS_LO16 expression has R_MIPS_GOT_GP_PC type iif the target
     // is _gp_disp symbol. In that case we should use the following
     // formula for calculation "AHL + GP - P + 4". For details see p. 4-19 at
     // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
-    uint64_t V = InX::MipsGot->getGp() + A - P;
+    uint64_t V = InX::MipsGot->getGp() + A;
     if (Type == R_MIPS_LO16)
       V += 4;
     return V;
   }
   case R_MIPS_GOT_LOCAL_PAGE:
     // If relocation against MIPS local symbol requires GOT entry, this entry
     // should be initialized by 'page address'. This address is high 16-bits
     // of sum the symbol's value and the addend.
return InX::MipsGot->getVA() + InX::MipsGot->getTlsOffset() +
            InX::MipsGot->getTlsIndexOff() - InX::MipsGot->getGp();
   case R_PAGE_PC:
   case R_PLT_PAGE_PC: {
     uint64_t Dest;
     if (Body.isUndefined() && !Body.isLocal() && Body.symbol()->isWeak())
       Dest = getAArch64Page(A);
     else
       Dest = getAArch64Page(Body.getVA(A));
-    return Dest - getAArch64Page(P);
+    return Dest;
   }
-  case R_PC: {
-    uint64_t Dest;
+  case R_PC:
     if (Body.isUndefined() && !Body.isLocal() && Body.symbol()->isWeak()) {
       // On ARM and AArch64 a branch to an undefined weak resolves to the
       // next instruction, otherwise the place.
       if (Config->EMachine == EM_ARM)
-        Dest = getARMUndefinedRelativeWeakVA(Type, A, P);
-      else if (Config->EMachine == EM_AARCH64)
-        Dest = getAArch64UndefinedRelativeWeakVA(Type, A, P);
-      else
-        Dest = Body.getVA(A);
-    } else {
-      Dest = Body.getVA(A);
-    }
-    return Dest - P;
+        return getARMUndefinedRelativeWeakVA(Type, A, P);
+      if (Config->EMachine == EM_AARCH64)
+        return getAArch64UndefinedRelativeWeakVA(Type, A, P);
     }
+    if (Config->EMachine == EM_386 && Type == R_386_PC16)
+      return Body.getVA(A) + 2;
+    return Body.getVA(A);
   case R_PLT:
     return Body.getPltVA() + A;
   case R_PLT_PC:
   case R_PPC_PLT_OPD:
-    return Body.getPltVA() + A - P;
+    return Body.getPltVA() + A;
   case R_PPC_OPD: {
     uint64_t SymVA = Body.getVA(A);
     // If we have an undefined weak symbol, we might get here with a symbol
     // address of zero. That could overflow, but the code must be unreachable,
     // so don't bother doing anything at all.
     if (!SymVA)
-      return 0;
+      return P;
     if (Out::Opd) {
       // If this is a local call, and we currently have the address of a
       // function-descriptor, get the underlying code address instead.
       uint64_t OpdStart = Out::Opd->Addr;
       uint64_t OpdEnd = OpdStart + Out::Opd->Size;
       bool InOpd = OpdStart <= SymVA && SymVA < OpdEnd;
       if (InOpd)
         SymVA = read64be(&Out::OpdBuf[SymVA - OpdStart]);
     }
-    return SymVA - P;
+    return SymVA;
   }
   case R_PPC_TOC:
     return getPPC64TocBase() + A;
   case R_RELAX_GOT_PC:
-    return Body.getVA(A) - P;
+    return Body.getVA(A);
   case R_RELAX_TLS_GD_TO_LE:
   case R_RELAX_TLS_IE_TO_LE:
   case R_RELAX_TLS_LD_TO_LE:
   case R_TLS:
     // A weak undefined TLS symbol resolves to the base of the TLS
     // block, i.e. gets a value of zero. If we pass --gc-sections to
     // lld and .tbss is not referenced, it gets reclaimed and we don't
     // create a TLS program header. Therefore, we resolve this
     // statically to zero.
     if (Body.isTls() && (Body.isLazy() || Body.isUndefined()) &&
         Body.symbol()->isWeak())
       return 0;
     if (Target->TcbSize)
       return Body.getVA(A) + alignTo(Target->TcbSize, Out::TlsPhdr->p_align);
     return Body.getVA(A) - Out::TlsPhdr->p_memsz;
   case R_RELAX_TLS_GD_TO_LE_NEG:
   case R_NEG_TLS:
     return Out::TlsPhdr->p_memsz - Body.getVA(A);
   case R_SIZE:
     return A; // Body.getSize was already folded into the addend.
   case R_TLSDESC:
     return InX::Got->getGlobalDynAddr(Body) + A;
   case R_TLSDESC_PAGE:
-    return getAArch64Page(InX::Got->getGlobalDynAddr(Body) + A) -
-           getAArch64Page(P);
+    return getAArch64Page(InX::Got->getGlobalDynAddr(Body) + A);
   case R_TLSGD:
     return InX::Got->getGlobalDynOffset(Body) + A - InX::Got->getSize();
   case R_TLSGD_PC:
-    return InX::Got->getGlobalDynAddr(Body) + A - P;
+    return InX::Got->getGlobalDynAddr(Body) + A;
   case R_TLSLD:
     return InX::Got->getTlsIndexOff() + A - InX::Got->getSize();
   case R_TLSLD_PC:
-    return InX::Got->getTlsIndexVA() + A - P;
+    return InX::Got->getTlsIndexVA() + A;
   }
   llvm_unreachable("Invalid expression");
 }
 
+static uint64_t adjustIfPC(uint32_t Type, int64_t T, uint64_t P,
+                           const SymbolBody &Body, RelExpr Expr) {
+  switch (Expr) {
+  case R_GOTONLY_PC:
+  case R_GOTONLY_PC_FROM_END:
+  case R_GOT_PC:
+  case R_RELAX_TLS_GD_TO_IE:
+  case R_MIPS_GOT_GP_PC:
+  case R_PLT_PC:
+  case R_PPC_PLT_OPD:
+  case R_RELAX_GOT_PC:
+  case R_TLSGD_PC:
+  case R_TLSLD_PC:
+  case R_PPC_OPD:
+    return T - P;
+  case R_PC:
+    if (Config->EMachine == EM_386 && Type == R_386_PC16)
+      return T - P - 2;
+    return T - P;
+  case R_RELAX_TLS_GD_TO_IE_PAGE_PC:
+  case R_GOT_PAGE_PC:
+  case R_PAGE_PC:
+  case R_PLT_PAGE_PC:
+  case R_TLSDESC_PAGE:
+    return T - getAArch64Page(P);
+  case R_ABS:
+  case R_RELAX_GOT_PC_NOPIC:
+  case R_ARM_SBREL:
+  case R_GOT:
+  case R_RELAX_TLS_GD_TO_IE_ABS:
+  case R_GOTREL:
+  case R_GOTREL_FROM_END:
+  case R_GOT_FROM_END:
+  case R_RELAX_TLS_GD_TO_IE_END:
+  case R_GOT_OFF:
+  case R_HINT:
+  case R_NONE:
+  case R_TLSDESC_CALL:
+  case R_MIPS_GOTREL:
+  case R_MIPS_GOT_GP:
+  case R_MIPS_GOT_LOCAL_PAGE:
+  case R_MIPS_GOT_OFF:
+  case R_MIPS_GOT_OFF32:
+  case R_MIPS_TLSGD:
+  case R_MIPS_TLSLD:
+  case R_PLT:
+  case R_PPC_TOC:
+  case R_RELAX_TLS_GD_TO_LE:
+  case R_RELAX_TLS_IE_TO_LE:
+  case R_RELAX_TLS_LD_TO_LE:
+  case R_TLS:
+  case R_RELAX_TLS_GD_TO_LE_NEG:
+  case R_NEG_TLS:
+  case R_SIZE:
+  case R_TLSDESC:
+  case R_TLSGD:
+  case R_TLSLD:
+    return T;
+  }
+  llvm_unreachable("Invalid expression");
+}
+
+template <class ELFT> static std::string getErrorLoc(const uint8_t *Loc) {
+  for (InputSectionBase *D : InputSections) {
+    auto *IS = dyn_cast_or_null<InputSection>(D);
+    if (!IS || !IS->getParent())
+      continue;
+
+    uint8_t *ISLoc = IS->getParent()->Loc + IS->OutSecOff;
+    if (ISLoc <= Loc && Loc < ISLoc + IS->getSize())
+      return IS->template getLocation<ELFT>(Loc - ISLoc) + ": ";
+  }
+  return "";
+}
+
+static std::string getErrorLocation(const uint8_t *Loc) {
+  switch (Config->EKind) {
+  case ELF32LEKind:
+    return getErrorLoc<ELF32LE>(Loc);
+  case ELF32BEKind:
+    return getErrorLoc<ELF32BE>(Loc);
+  case ELF64LEKind:
+    return getErrorLoc<ELF64LE>(Loc);
+  case ELF64BEKind:
+    return getErrorLoc<ELF64BE>(Loc);
+  default:
+    llvm_unreachable("unknown ELF type");
+  }
+}
+
+static void checkInt(uint8_t *Loc, unsigned N, uint64_t V, uint32_t Type) {
+  if (!isIntN(N, V))
+    error(getErrorLocation(Loc) + "relocation " + toString(Type) +
+          " out of range");
+}
+
+static void checkUInt(uint8_t *Loc, unsigned N, uint64_t V, uint32_t Type) {
+  if (!isUIntN(N, V))
+    error(getErrorLocation(Loc) + "relocation " + toString(Type) +
+          " out of range");
+}
+
+static uint64_t getRelocValue(uint8_t *Loc, uint32_t Type, int64_t A,
+                              uint64_t P, const SymbolBody &Body,
+                              RelExpr Expr) {
+  uint64_t Dest = getRelocTargetVA(Type, A, P, Body, Expr);
+  uint64_t Value = adjustIfPC(Type, Dest, P, Body, Expr);
+  RelOverflow RO = Target->getRelOverflow(Type);
+  switch (RO.Kind) {
+  case RelOverflow::FinalValue:
+    checkInt(Loc, RO.NumBits, Value, Type);
+    break;
+  case RelOverflow::TargetValue:
+    checkUInt(Loc, RO.NumBits, Dest, Type);
+    break;
+  }
+  return Value;
+}
+
 // This function applies relocations to sections without SHF_ALLOC bit.
 // Such sections are never mapped to memory at runtime. Debug sections are
 // an example. Relocations in non-alloc sections are much easier to
 // handle than in allocated sections because it will never need complex
 // treatement such as GOT or PLT (because at runtime no one refers them).
 // So, we handle relocations for non-alloc sections directly in this
 // function as a performance optimization.
 template <class ELFT, class RelTy>
if (Expr != R_ABS) {
       error(this->getLocation<ELFT>(Offset) + ": has non-ABS reloc");
       return;
     }
 
     uint64_t AddrLoc = getParent()->Addr + Offset;
     uint64_t SymVA = 0;
     if (!Sym.isTls() || Out::TlsPhdr)
       SymVA = SignExtend64<sizeof(typename ELFT::uint) * 8>(
-          getRelocTargetVA(Type, Addend, AddrLoc, Sym, R_ABS));
+          getRelocValue(BufLoc, Type, Addend, AddrLoc, Sym, R_ABS));
     Target->relocateOne(BufLoc, Type, SymVA);
   }
 }
 
 template <class ELFT> elf::ObjectFile<ELFT> *InputSectionBase::getFile() const {
   return cast_or_null<elf::ObjectFile<ELFT>>(File);
 }
 
void InputSectionBase::relocateAlloc(uint8_t *Buf, uint8_t *BufEnd) {
   for (const Relocation &Rel : Relocations) {
     uint64_t Offset = getOffset(Rel.Offset);
     uint8_t *BufLoc = Buf + Offset;
     uint32_t Type = Rel.Type;
 
     uint64_t AddrLoc = getOutputSection()->Addr + Offset;
     RelExpr Expr = Rel.Expr;
     uint64_t TargetVA = SignExtend64(
-        getRelocTargetVA(Type, Rel.Addend, AddrLoc, *Rel.Sym, Expr), Bits);
+        getRelocValue(BufLoc, Type, Rel.Addend, AddrLoc, *Rel.Sym, Expr), Bits);
 
     switch (Expr) {
     case R_RELAX_GOT_PC:
     case R_RELAX_GOT_PC_NOPIC:
       Target->relaxGot(BufLoc, TargetVA);
       break;
     case R_RELAX_TLS_IE_TO_LE:
       Target->relaxTlsIeToLe(BufLoc, Type, TargetVA);

ELF/Target.h

 
 #include <memory>
 
 namespace lld {
 namespace elf {
 class InputFile;
 class SymbolBody;
 
+struct RelOverflow {
+  unsigned NumBits;
+  enum { FinalValue, TargetValue } Kind;
+};
+
 class TargetInfo {
 public:
   virtual bool isPicRel(uint32_t Type) const { return true; }
   virtual uint32_t getDynRel(uint32_t Type) const { return Type; }
   virtual void writeGotPltHeader(uint8_t *Buf) const {}
   virtual void writeGotPlt(uint8_t *Buf, const SymbolBody &S) const {};
   virtual void writeIgotPlt(uint8_t *Buf, const SymbolBody &S) const;
   virtual int64_t getImplicitAddend(const uint8_t *Buf, uint32_t Type) const;
public:
   virtual bool usesOnlyLowPageBits(uint32_t Type) const;
 
   // Decide whether a Thunk is needed for the relocation from File
   // targeting S.
   virtual bool needsThunk(RelExpr Expr, uint32_t RelocType,
                           const InputFile *File, const SymbolBody &S) const;
   virtual RelExpr getRelExpr(uint32_t Type, const SymbolBody &S,
                              const uint8_t *Loc) const = 0;
+  virtual RelOverflow getRelOverflow(uint32_t Type) const = 0;
   virtual void relocateOne(uint8_t *Loc, uint32_t Type, uint64_t Val) const = 0;
   virtual ~TargetInfo();
 
   unsigned TlsGdRelaxSkip = 1;
   unsigned PageSize = 4096;
   unsigned DefaultMaxPageSize = 4096;
 
   // On FreeBSD x86_64 the first page cannot be mmaped.

ELF/Target.cpp

 }
 
 namespace {
 class X86TargetInfo final : public TargetInfo {
 public:
   X86TargetInfo();
   RelExpr getRelExpr(uint32_t Type, const SymbolBody &S,
                      const uint8_t *Loc) const override;
+  RelOverflow getRelOverflow(uint32_t Type) const override;
   int64_t getImplicitAddend(const uint8_t *Buf, uint32_t Type) const override;
   void writeGotPltHeader(uint8_t *Buf) const override;
   uint32_t getDynRel(uint32_t Type) const override;
   void writeGotPlt(uint8_t *Buf, const SymbolBody &S) const override;
   void writeIgotPlt(uint8_t *Buf, const SymbolBody &S) const override;
   void writePltHeader(uint8_t *Buf) const override;
   void writePlt(uint8_t *Buf, uint64_t GotPltEntryAddr, uint64_t PltEntryAddr,
                 int32_t Index, unsigned RelOff) const override;
   void relocateOne(uint8_t *Loc, uint32_t Type, uint64_t Val) const override;
 
   RelExpr adjustRelaxExpr(uint32_t Type, const uint8_t *Data,
                           RelExpr Expr) const override;
   void relaxTlsGdToIe(uint8_t *Loc, uint32_t Type, uint64_t Val) const override;
   void relaxTlsGdToLe(uint8_t *Loc, uint32_t Type, uint64_t Val) const override;
   void relaxTlsIeToLe(uint8_t *Loc, uint32_t Type, uint64_t Val) const override;
   void relaxTlsLdToLe(uint8_t *Loc, uint32_t Type, uint64_t Val) const override;
 };
 
 template <class ELFT> class X86_64TargetInfo final : public TargetInfo {
 public:
   X86_64TargetInfo();
   RelExpr getRelExpr(uint32_t Type, const SymbolBody &S,
                      const uint8_t *Loc) const override;
+  RelOverflow getRelOverflow(uint32_t Type) const override;
   bool isPicRel(uint32_t Type) const override;
   void writeGotPltHeader(uint8_t *Buf) const override;
   void writeGotPlt(uint8_t *Buf, const SymbolBody &S) const override;
   void writePltHeader(uint8_t *Buf) const override;
   void writePlt(uint8_t *Buf, uint64_t GotPltEntryAddr, uint64_t PltEntryAddr,
                 int32_t Index, unsigned RelOff) const override;
   void relocateOne(uint8_t *Loc, uint32_t Type, uint64_t Val) const override;
 

 };
 
 class PPCTargetInfo final : public TargetInfo {
 public:
   PPCTargetInfo();
   void relocateOne(uint8_t *Loc, uint32_t Type, uint64_t Val) const override;
   RelExpr getRelExpr(uint32_t Type, const SymbolBody &S,
                      const uint8_t *Loc) const override;
+  RelOverflow getRelOverflow(uint32_t Type) const override;
 };
 
 class PPC64TargetInfo final : public TargetInfo {
 public:
   PPC64TargetInfo();
   RelExpr getRelExpr(uint32_t Type, const SymbolBody &S,
                      const uint8_t *Loc) const override;
+  RelOverflow getRelOverflow(uint32_t Type) const override;
   void writePlt(uint8_t *Buf, uint64_t GotPltEntryAddr, uint64_t PltEntryAddr,
                 int32_t Index, unsigned RelOff) const override;
   void relocateOne(uint8_t *Loc, uint32_t Type, uint64_t Val) const override;
 };
 
 class AArch64TargetInfo final : public TargetInfo {
 public:
   AArch64TargetInfo();
   RelExpr getRelExpr(uint32_t Type, const SymbolBody &S,
                      const uint8_t *Loc) const override;
+  RelOverflow getRelOverflow(uint32_t Type) const override;
   bool isPicRel(uint32_t Type) const override;
   void writeGotPlt(uint8_t *Buf, const SymbolBody &S) const override;
   void writePltHeader(uint8_t *Buf) const override;
   void writePlt(uint8_t *Buf, uint64_t GotPltEntryAddr, uint64_t PltEntryAddr,
                 int32_t Index, unsigned RelOff) const override;
   bool usesOnlyLowPageBits(uint32_t Type) const override;
   void relocateOne(uint8_t *Loc, uint32_t Type, uint64_t Val) const override;
   RelExpr adjustRelaxExpr(uint32_t Type, const uint8_t *Data,
                           RelExpr Expr) const override;
   void relaxTlsGdToLe(uint8_t *Loc, uint32_t Type, uint64_t Val) const override;
   void relaxTlsGdToIe(uint8_t *Loc, uint32_t Type, uint64_t Val) const override;
   void relaxTlsIeToLe(uint8_t *Loc, uint32_t Type, uint64_t Val) const override;
 };
 
 class AMDGPUTargetInfo final : public TargetInfo {
 public:
   AMDGPUTargetInfo();
   void relocateOne(uint8_t *Loc, uint32_t Type, uint64_t Val) const override;
   RelExpr getRelExpr(uint32_t Type, const SymbolBody &S,
                      const uint8_t *Loc) const override;
+  RelOverflow getRelOverflow(uint32_t Type) const override;
 };
 
 class ARMTargetInfo final : public TargetInfo {
 public:
   ARMTargetInfo();
   RelExpr getRelExpr(uint32_t Type, const SymbolBody &S,
                      const uint8_t *Loc) const override;
+  RelOverflow getRelOverflow(uint32_t Type) const override;
   bool isPicRel(uint32_t Type) const override;
   uint32_t getDynRel(uint32_t Type) const override;
   int64_t getImplicitAddend(const uint8_t *Buf, uint32_t Type) const override;
   void writeGotPlt(uint8_t *Buf, const SymbolBody &S) const override;
   void writeIgotPlt(uint8_t *Buf, const SymbolBody &S) const override;
   void writePltHeader(uint8_t *Buf) const override;
   void writePlt(uint8_t *Buf, uint64_t GotPltEntryAddr, uint64_t PltEntryAddr,
                 int32_t Index, unsigned RelOff) const override;
   void addPltSymbols(InputSectionBase *IS, uint64_t Off) const override;
   void addPltHeaderSymbols(InputSectionBase *ISD) const override;
   bool needsThunk(RelExpr Expr, uint32_t RelocType, const InputFile *File,
                   const SymbolBody &S) const override;
   void relocateOne(uint8_t *Loc, uint32_t Type, uint64_t Val) const override;
 };
 
 template <class ELFT> class MipsTargetInfo final : public TargetInfo {
 public:
   MipsTargetInfo();
   RelExpr getRelExpr(uint32_t Type, const SymbolBody &S,
                      const uint8_t *Loc) const override;
+  RelOverflow getRelOverflow(uint32_t Type) const override;
   int64_t getImplicitAddend(const uint8_t *Buf, uint32_t Type) const override;
   bool isPicRel(uint32_t Type) const override;
   uint32_t getDynRel(uint32_t Type) const override;
   void writeGotPlt(uint8_t *Buf, const SymbolBody &S) const override;
   void writePltHeader(uint8_t *Buf) const override;
   void writePlt(uint8_t *Buf, uint64_t GotPltEntryAddr, uint64_t PltEntryAddr,
                 int32_t Index, unsigned RelOff) const override;
   bool needsThunk(RelExpr Expr, uint32_t RelocType, const InputFile *File,
RelExpr X86TargetInfo::getRelExpr(uint32_t Type, const SymbolBody &S,
   case R_386_NONE:
     return R_NONE;
   default:
     error(toString(S.File) + ": unknown relocation type: " + toString(Type));
     return R_HINT;
   }
 }
 
+RelOverflow X86TargetInfo::getRelOverflow(uint32_t Type) const {
+  switch (Type) {
+  case R_386_PC16:
+    return {16, RelOverflow::TargetValue};
+  }
+  error("unknown relocation type: " + toString(Type));
+  llvm_unreachable("unknown reloc");
+}
+
 RelExpr X86TargetInfo::adjustRelaxExpr(uint32_t Type, const uint8_t *Data,
                                        RelExpr Expr) const {
   switch (Expr) {
   default:
     return Expr;
   case R_RELAX_TLS_GD_TO_IE:
     return R_RELAX_TLS_GD_TO_IE_END;
   case R_RELAX_TLS_GD_TO_LE:
case R_386_PC8:
     checkInt<8>(Loc, Val, Type);
     *Loc = Val;
     break;
   case R_386_16:
     checkUInt<16>(Loc, Val, Type);
     write16le(Loc, Val);
     break;
   case R_386_PC16:
-    checkInt<16>(Loc, Val, Type);
     write16le(Loc, Val);
     break;
   default:
     checkInt<32>(Loc, Val, Type);
     write32le(Loc, Val);
   }
 }
 
case R_X86_64_NONE:
     return R_NONE;
   default:
     error(toString(S.File) + ": unknown relocation type: " + toString(Type));
     return R_HINT;
   }
 }
 
 template <class ELFT>
+RelOverflow X86_64TargetInfo<ELFT>::getRelOverflow(uint32_t Type) const {
+  llvm_unreachable("foo");
+}
+
+template <class ELFT>
 void X86_64TargetInfo<ELFT>::writeGotPltHeader(uint8_t *Buf) const {
   // The first entry holds the value of _DYNAMIC. It is not clear why that is
   // required, but it is documented in the psabi and the glibc dynamic linker
   // seems to use it (note that this is relevant for linking ld.so, not any
   // other program).
   write64le(Buf, InX::Dynamic->getVA());
 }
 
void PPCTargetInfo::relocateOne(uint8_t *Loc, uint32_t Type,
   case R_PPC_REL24:
     or32be(Loc, Val & 0x3FFFFFC);
     break;
   default:
     error(getErrorLocation(Loc) + "unrecognized reloc " + Twine(Type));
   }
 }
 
+RelOverflow PPCTargetInfo::getRelOverflow(uint32_t Type) const {
+  llvm_unreachable("foo");
+}
+
 RelExpr PPCTargetInfo::getRelExpr(uint32_t Type, const SymbolBody &S,
                                   const uint8_t *Loc) const {
   switch (Type) {
   case R_PPC_REL24:
   case R_PPC_REL32:
     return R_PC;
   default:
     return R_ABS;
uint64_t getPPC64TocBase() {
 
   // Per the ppc64-elf-linux ABI, The TOC base is TOC value plus 0x8000
   // thus permitting a full 64 Kbytes segment. Note that the glibc startup
   // code (crt1.o) assumes that you can get from the TOC base to the
   // start of the .toc section with only a single (signed) 16-bit relocation.
   return TocVA + PPC64TocOffset;
 }
 
+RelOverflow PPC64TargetInfo::getRelOverflow(uint32_t Type) const {
+  llvm_unreachable("foo");
+}
+
 RelExpr PPC64TargetInfo::getRelExpr(uint32_t Type, const SymbolBody &S,
                                     const uint8_t *Loc) const {
   switch (Type) {
   default:
     return R_ABS;
   case R_PPC64_TOC16:
   case R_PPC64_TOC16_DS:
   case R_PPC64_TOC16_HA:
AArch64TargetInfo::AArch64TargetInfo() {
   PltHeaderSize = 32;
   DefaultMaxPageSize = 65536;
 
   // It doesn't seem to be documented anywhere, but tls on aarch64 uses variant
   // 1 of the tls structures and the tcb size is 16.
   TcbSize = 16;
 }
 
+RelOverflow AArch64TargetInfo::getRelOverflow(uint32_t Type) const {
+  llvm_unreachable("foo");
+}
+
 RelExpr AArch64TargetInfo::getRelExpr(uint32_t Type, const SymbolBody &S,
                                       const uint8_t *Loc) const {
   switch (Type) {
   default:
     return R_ABS;
   case R_AARCH64_TLSDESC_ADR_PAGE21:
     return R_TLSDESC_PAGE;
   case R_AARCH64_TLSDESC_LD64_LO12:
void AMDGPUTargetInfo::relocateOne(uint8_t *Loc, uint32_t Type,
   case R_AMDGPU_REL32_HI:
     write32le(Loc, Val >> 32);
     break;
   default:
     error(getErrorLocation(Loc) + "unrecognized reloc " + Twine(Type));
   }
 }
 
+RelOverflow AMDGPUTargetInfo::getRelOverflow(uint32_t Type) const {
+  llvm_unreachable("foo");
+}
+
 RelExpr AMDGPUTargetInfo::getRelExpr(uint32_t Type, const SymbolBody &S,
                                      const uint8_t *Loc) const {
   switch (Type) {
   case R_AMDGPU_ABS32:
   case R_AMDGPU_ABS64:
     return R_ABS;
   case R_AMDGPU_REL32:
   case R_AMDGPU_REL32_LO:
ARMTargetInfo::ARMTargetInfo() {
   GotPltEntrySize = 4;
   PltEntrySize = 16;
   PltHeaderSize = 20;
   // ARM uses Variant 1 TLS
   TcbSize = 8;
   NeedsThunks = true;
 }
 
+RelOverflow ARMTargetInfo::getRelOverflow(uint32_t Type) const {
+  llvm_unreachable("foo");
+}
+
 RelExpr ARMTargetInfo::getRelExpr(uint32_t Type, const SymbolBody &S,
                                   const uint8_t *Loc) const {
   switch (Type) {
   default:
     return R_ABS;
   case R_ARM_THM_JUMP11:
     return R_PC;
   case R_ARM_CALL:
if (ELFT::Is64Bits) {
     RelativeRel = R_MIPS_REL32;
     TlsGotRel = R_MIPS_TLS_TPREL32;
     TlsModuleIndexRel = R_MIPS_TLS_DTPMOD32;
     TlsOffsetRel = R_MIPS_TLS_DTPREL32;
   }
 }
 
 template <class ELFT>
+RelOverflow MipsTargetInfo<ELFT>::getRelOverflow(uint32_t Type) const {
+  llvm_unreachable("foo");
+}
+
+template <class ELFT>
 RelExpr MipsTargetInfo<ELFT>::getRelExpr(uint32_t Type, const SymbolBody &S,
                                          const uint8_t *Loc) const {
   // See comment in the calculateMipsRelChain.
   if (ELFT::Is64Bits || Config->MipsN32Abi)
     Type &= 0xff;
   switch (Type) {
   default:
     return R_ABS;

test/ELF/i386-reloc-large-addend.s

+// RUN: llvm-mc %s -o %t.o -triple i386-pc-linux-code16 -filetype=obj
+
+// RUN: echo ".global foo; foo = 0x1" > %t1.s
+// RUN: llvm-mc %t1.s -o %t1.o -triple i386-pc-linux -filetype=obj
+
+// RUN: ld.lld -Ttext 0x7000 %t.o %t1.o -o %t
+// RUN: llvm-objdump -d -triple=i386-pc-linux-code16 %t | FileCheck %s
+
+// CHECK:        Disassembly of section .text:
+// CHECK-NEXT: _start:
+// CHECK-NEXT:     7000:       e9 fe 1f        jmp     8190
+//                            0x1 + 0x9000 - 0x7003 == 8190
+        .global _start
+_start:
+jmp foo + 0x9000

test/ELF/i386-reloc-range.s

 // RUN: llvm-mc %s -o %t.o -triple i386-pc-linux-code16 -filetype=obj
 
-// RUN: echo ".global foo; foo = 0x8202" > %t1.s
+// RUN: echo ".global foo; foo = 0xffff" > %t1.s
 // RUN: llvm-mc %t1.s -o %t1.o -triple i386-pc-linux -filetype=obj
-// RUN: echo ".global foo; foo = 0x8203" > %t2.s
+// RUN: echo ".global foo; foo = 0x10000" > %t2.s
 // RUN: llvm-mc %t2.s -o %t2.o -triple i386-pc-linux -filetype=obj
 
 // RUN: ld.lld -Ttext 0x200 %t.o %t1.o -o %t1
 // RUN: llvm-objdump -d -triple=i386-pc-linux-code16 %t1 | FileCheck %s
 
 // CHECK:        Disassembly of section .text:
 // CHECK-NEXT: _start:
-// CHECK-NEXT:      200:       e9 ff 7f        jmp     32767
-//                                   0x8202 - 0x203 == 32767
+// CHECK-NEXT:      200: {{.*}} jmp -516
+//      0xffff - 0x203 == 0xfdfc == -516
 
 // RUN: not ld.lld -Ttext 0x200 %t.o %t2.o -o %t2 2>&1 | FileCheck --check-prefix=ERR %s
 
 // ERR: {{.*}}:(.text+0x1): relocation R_386_PC16 out of range
 
         .global _start
 _start:
         jmp foo