[ELF] Ignore R_*_NONE relocs when relocating non-alloc sections

[phosek]

Summary

We shouldn't report an error for R_*_NONE relocs since we're emitting them when writing relocations to discarded sections.

[ruiu]

ELF/InputSection.cpp

471

nit: no else after continue/return/break/etc.

ELF/Relocations.cpp

323

Is this needed? If a relocation is R_NONE, the control shouldn't reach here in the first place, I think.

[ruiu]

ELF/Relocations.cpp

323

How about this?

[phosek]

ELF/Relocations.cpp

323

I tried that but it's being invoked from adjustExpr in scanRelocs before we ignore the R_NONE reloc (the change below). I could move that check before the adjustExpr call if you prefer?

[ruiu]

ELF/Relocations.cpp

323

How about do continue after RelExpr Expr = Target->getRelExpr(Type, Body); in scanRelocs?

[ruiu]

ELF/Relocations.cpp

323

So now you can revert the change to this function?

[ruiu]

LGTM

ELF/InputSection.cpp

 }
 
 template <class ELFT>
 static typename ELFT::uint
 getRelocTargetVA(uint32_t Type, int64_t A, typename ELFT::uint P,
                  const SymbolBody &Body, RelExpr Expr) {
   switch (Expr) {
   case R_HINT:
+  case R_NONE:
   case R_TLSDESC_CALL:
     llvm_unreachable("cannot relocate hint relocs");
   case R_TLSLD:
     return In<ELFT>::Got->getTlsIndexOff() + A - In<ELFT>::Got->getSize();
   case R_TLSLD_PC:
     return In<ELFT>::Got->getTlsIndexVA() + A - P;
   case R_PPC_TOC:
     return getPPC64TocBase() + A;
for (const RelTy &Rel : Rels) {
     uint32_t Type = Rel.getType(Config->Mips64EL);
     uintX_t Offset = this->getOffset(Rel.r_offset);
     uint8_t *BufLoc = Buf + Offset;
     int64_t Addend = getAddend<ELFT>(Rel);
     if (!RelTy::IsRela)
       Addend += Target->getImplicitAddend(BufLoc, Type);
 
     SymbolBody &Sym = this->File->getRelocTargetSym(Rel);
-    if (Target->getRelExpr(Type, Sym) != R_ABS) {
+    RelExpr Expr = Target->getRelExpr(Type, Sym);
+    if (Expr == R_NONE)
+      continue;
+    if (Expr != R_ABS) {
       error(this->getLocation(Offset) + ": has non-ABS reloc");
       return;
     }
 
     uintX_t AddrLoc = this->OutSec->Addr + Offset;
     uint64_t SymVA = 0;
     if (!Sym.isTls() || Out<ELFT>::TlsPhdr)
       SymVA = SignExtend64<sizeof(uintX_t) * 8>(

ELF/Relocations.h

enum RelExpr {
   R_HINT,
   R_MIPS_GOT_LOCAL_PAGE,
   R_MIPS_GOT_OFF,
   R_MIPS_GOT_OFF32,
   R_MIPS_GOTREL,
   R_MIPS_TLSGD,
   R_MIPS_TLSLD,
   R_NEG_TLS,
+  R_NONE,
   R_PAGE_PC,
   R_PC,
   R_PLT,
   R_PLT_PC,
   R_PLT_PAGE_PC,
   R_PPC_OPD,
   R_PPC_PLT_OPD,
   R_PPC_TOC,

ELF/Relocations.cpp

 
 template <class ELFT>
 static bool isStaticLinkTimeConstant(RelExpr E, uint32_t Type,
                                      const SymbolBody &Body,
                                      InputSectionBase<ELFT> &S,
                                      typename ELFT::uint RelOff) {
   // These expressions always compute a constant
   if (isRelExprOneOf<R_SIZE, R_GOT_FROM_END, R_GOT_OFF, R_MIPS_GOT_LOCAL_PAGE,
-                     R_MIPS_GOT_OFF, R_MIPS_GOT_OFF32, R_MIPS_TLSGD,
+                     R_MIPS_GOT_OFF, R_MIPS_GOT_OFF32, R_MIPS_TLSGD, R_NONE,
                      R_GOT_PAGE_PC, R_GOT_PC, R_PLT_PC, R_TLSGD_PC, R_TLSGD,
                      R_PPC_PLT_OPD, R_TLSDESC_CALL, R_TLSDESC_PAGE, R_HINT>(E))
     return true;
 
   // These never do, except if the entire file is position dependent or if
   // only the low bits are used.
   if (E == R_GOT || E == R_PLT || E == R_TLSDESC)
     return Target->usesOnlyLowPageBits(Type) || !Config->pic();
for (auto I = Rels.begin(), E = Rels.end(); I != E; ++I) {
     }
 
     // We only report undefined symbols if they are referenced somewhere in the
     // code.
     if (!Body.isLocal() && Body.isUndefined() && !Body.symbol()->isWeak())
       reportUndefined(Body, C, RI.r_offset);
 
     RelExpr Expr = Target->getRelExpr(Type, Body);
+
+    // Ignore "hint" relocations because they are only markers for relaxation.
+    if (isRelExprOneOf<R_HINT, R_NONE>(Expr))
+      continue;
+
     bool Preemptible = isPreemptible(Body, Type);
     Expr = adjustExpr(*File, Body, IsWrite, Expr, Type, Buf + RI.r_offset, C,
                       RI.r_offset);
     if (ErrorCount)
       continue;
 
     // Skip a relocation that points to a dead piece
     // in a eh_frame section.
for (auto I = Rels.begin(), E = Rels.end(); I != E; ++I) {
     int64_t Addend = computeAddend(*File, Buf, E, RI, Expr, Body);
 
     if (unsigned Processed =
             handleTlsRelocation<ELFT>(Type, Body, C, Offset, Addend, Expr)) {
       I += (Processed - 1);
       continue;
     }
 
-    // Ignore "hint" and TLS Descriptor call relocation because they are
-    // only markers for relaxation.
-    if (isRelExprOneOf<R_HINT, R_TLSDESC_CALL>(Expr))
+    if (Expr == R_TLSDESC_CALL)
       continue;
 
     if (needsPlt(Expr) ||
         refersToGotEntry(Expr) || !isPreemptible(Body, Type)) {
       // If the relocation points to something in the file, we can process it.
       bool Constant =
           isStaticLinkTimeConstant<ELFT>(Expr, Type, Body, C, RI.r_offset);
 

ELF/Target.cpp

case R_386_TLS_GOTIE:
     return R_GOT_FROM_END;
   case R_386_GOTOFF:
     return R_GOTREL_FROM_END;
   case R_386_TLS_LE:
     return R_TLS;
   case R_386_TLS_LE_32:
     return R_NEG_TLS;
   case R_386_NONE:
-    return R_HINT;
+    return R_NONE;
   default:
     error(toString(S.File) + ": unknown relocation type: " + toString(Type));
     return R_HINT;
   }
 }
 
 RelExpr X86TargetInfo::adjustRelaxExpr(uint32_t Type, const uint8_t *Data,
                                        RelExpr Expr) const {
RelExpr X86_64TargetInfo<ELFT>::getRelExpr(uint32_t Type,
   case R_X86_64_GOT64:
     return R_GOT_FROM_END;
   case R_X86_64_GOTPCREL:
   case R_X86_64_GOTPCRELX:
   case R_X86_64_REX_GOTPCRELX:
   case R_X86_64_GOTTPOFF:
     return R_GOT_PC;
   case R_X86_64_NONE:
-    return R_HINT;
+    return R_NONE;
   default:
     error(toString(S.File) + ": unknown relocation type: " + toString(Type));
     return R_HINT;
   }
 }
 
 template <class ELFT>
 void X86_64TargetInfo<ELFT>::writeGotPltHeader(uint8_t *Buf) const {
case R_ARM_BASE_PREL:
     return R_GOTONLY_PC;
   case R_ARM_MOVW_PREL_NC:
   case R_ARM_MOVT_PREL:
   case R_ARM_REL32:
   case R_ARM_THM_MOVW_PREL_NC:
   case R_ARM_THM_MOVT_PREL:
     return R_PC;
   case R_ARM_NONE:
-    return R_HINT;
+    return R_NONE;
   case R_ARM_TLS_LE32:
     return R_TLS;
   }
 }
 
 bool ARMTargetInfo::isPicRel(uint32_t Type) const {
   return (Type == R_ARM_TARGET1 && !Config->Target1Rel) ||
          (Type == R_ARM_ABS32);

test/ELF/Inputs/relocatable-non-alloc.s

+.section .text.foo,"axG",@progbits,foo,comdat,unique,0
+foo:
+  nop
+
+.section .debug_info
+.long .text.foo

test/ELF/relocatable-non-alloc.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t1.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %S/Inputs/relocatable-non-alloc.s -o %t2.o
+# RUN: ld.lld %t2.o %t2.o -r -o %t3.o
+# RUN: ld.lld %t1.o %t3.o -o %t.o | FileCheck -allow-empty %s
+
+# CHECK-NOT:  has non-ABS reloc
+
+.globl _start
+_start: