ELF/ARM: Ignore R_ARM_V4BX but allow linking

[zatrazz]

Summary

This patch allow the ARM relocation R_ARM_V4BX to be processed by lld,
although it is not really handled in the static relocation code. The
relocation is in the form:

Relocation section '.rel.text' at offset 0x428 contains 4 entries:
Offset Info Type Sym.Value Sym. Name
00000014 00000028 R_ARM_V4BX

Meaning it does have a direct target, but rather references to an absolute
section *ABS* (in this exemple to the .text segment itself). It makes the
target Atom after file parse to not have a associated pointer and thus
generating a derrefence NULL point in ELFFile<ELFT>::findAtom. Current
approach is just ignore and return nullptr in such cases.

With this patch I can dynamically link an application against a GLIBC
arm-linux-gnueabi system.

I am not certainly that it is the right approach to handle this cases in arch-neutral
code, so I am more than willing to hear better suggestions.

[shankarke]

Can you add a test ? How do you do that in assembly to create a relocation to nothing ?

[zatrazz]

I am creating a test right now. The problem relies that default GCC configuration
for arm-linux-gnueabi{hf} emits the relocation for the asm:

.syntax unified
.arm

.p2align 2
.type fn, %function
fn:

ldr r3, .LGOT
ldr r2, .LGOT+4

.LPIC:

add r3, pc, r3
ldr r2, [r3, r2]
cmp r2, #0
bxeq lr
b __start__

.LGOT:
.word _GLOBAL_OFFSET_TABLE_-(.LPIC+8)

.word start(GOT)

But only if you use -march=armv4 (which is the default GCC configuration). For
arm5 and forward the relocation is not created. This a special relocation
(defined miscellaneous for ARM) that instruct the linker to replace the bx
instruction into a mov. GNU linker has some options related to which substitution
it can create for such cases.

I am not sure of the status of ARM4 support for lld, but I think it should
not bail linking for this case in special.

[shankarke]

Thanks for providing an example. LGTM.

[zatrazz]

I will repost it with a testcase. Thanks for the review.

lib/ReaderWriter/ELF/ARM/ARMRelocationHandler.cpp

std::error_code ARMTargetRelocationHandler::applyRelocation(
   assert(ref.kindArch() == Reference::KindArch::ARM);
 
   // Calculate proper initial addend for the relocation
   const Reference::Addend addend =
       readAddend(loc, ref.kindValue()) + ref.addend();
 
   // Flags that the relocation addresses Thumb instruction
   bool thumb = false;
-  if (const auto *definedAtom = dyn_cast<DefinedAtom>(ref.target())) {
+  if (const auto *definedAtom = dyn_cast_or_null<DefinedAtom>(ref.target())) {
     thumb = isThumbCode(definedAtom);
   }
 
   switch (ref.kindValue()) {
   case R_ARM_NONE:
     break;
   case R_ARM_ABS32:
     relocR_ARM_ABS32(loc, reloc, target, addend, thumb);
case R_ARM_ALU_PC_G1_NC:
     break;
   case R_ARM_LDR_PC_G2:
     relocR_ARM_LDR_PC_G2(loc, reloc, target, addend);
     break;
   case R_ARM_JUMP_SLOT:
   case R_ARM_IRELATIVE:
     // Runtime only relocations. Ignore here.
     break;
+  case R_ARM_V4BX:
+    // TODO implement
+    break;
   default:
     return make_unhandled_reloc_error();
   }
 
   return std::error_code();
 }

lib/ReaderWriter/ELF/ELFFile.cpp

std::error_code ELFFile<ELFT>::isCompatible(const MemoryBuffer &mb,
   return lld::elf::isCompatible<ELFT>(mb, ctx);
 }
 
 template <typename ELFT>
 Atom *ELFFile<ELFT>::findAtom(const Elf_Sym *sourceSym,
                               const Elf_Sym *targetSym) {
   // Return the atom for targetSym if we can do so.
   Atom *target = _symbolToAtomMapping.lookup(targetSym);
-  if (target->definition() != Atom::definitionRegular)
+  if (!target || target->definition() != Atom::definitionRegular)
     return target;
   Atom::Scope scope = llvm::cast<DefinedAtom>(target)->scope();
   if (scope == DefinedAtom::scopeTranslationUnit)
     return target;
   if (!redirectReferenceUsingUndefAtom(sourceSym, targetSym))
     return target;
 
   // Otherwise, create a new undefined symbol and returns it.

lib/ReaderWriter/ELF/SectionChunks.h

protected:
   void printError(const std::string &errorStr, const AtomLayout &atom,
                   const Reference &ref) const {
     StringRef kindValStr;
     if (!this->_ctx.registry().referenceKindToString(
             ref.kindNamespace(), ref.kindArch(), ref.kindValue(), kindValStr)) {
       kindValStr = "unknown";
     }
 
+    StringRef targetName = "undefined";
+    if (ref.target())
+      targetName = ref.target()->name();
     std::string errStr = (Twine(errorStr) + " in file " +
                           atom._atom->file().path() +
                           ": reference from " + atom._atom->name() +
                           "+" + Twine(ref.offsetInAtom()) +
-                          " to " + ref.target()->name() +
+                          " to " + targetName +
                           "+" + Twine(ref.addend()) +
                           " of type " + Twine(ref.kindValue()) +
                           " (" + kindValStr + ")\n").str();
 
     // Take the lock to prevent output getting interleaved between threads
     std::lock_guard<std::mutex> lock(_outputMutex);
     llvm::errs() << errStr;
   }