[BOLT] Handle ifuncs trampolines for aarch64

[yota9]

Summary

The aarch64 uses the trampolines located in .iplt section, which
contains plt-like trampolines on the value stored in .got. In this case
we don't have JUMP_SLOT relocation, but we have a symbol that belongs to
ifunc trampoline, so use it and set plt symbol for such functions.

Vladislav Khmelevsky,
Advanced Software Technology Lab, Huawei

[yota9]

@rafaelauler gentle ping :)

[rafauler]

bolt/lib/Rewrite/RewriteInstance.cpp

1261

I don't understand why the BinaryFunction is already created for ifuncs? For X86, both ifuncs and regular PLTs are pretty similar, except for the relocation type.

[yota9]

bolt/lib/Rewrite/RewriteInstance.cpp

1261

Because the symtab contains the trampoline IFUNC symbol and it is already disassembled. Currently it does not work because such trampolines are moved to the new text section and since the adrp+add does not have relocations (like in plt) - the "got" address becomes wrong

[rafauler]

LGTM

bolt/lib/Rewrite/RewriteInstance.cpp

1261

Oh, I see. Thanks!

bolt/include/bolt/Rewrite/RewriteInstance.h

private:
   const PLTSectionInfo X86_64_PLTSections[4] = {
       { ".plt", 16 },
       { ".plt.got", 8 },
       { ".plt.sec", 8 },
       { nullptr, 0 }
   };
 
   /// AArch64 PLT sections.
-  const PLTSectionInfo AArch64_PLTSections[2] = {{".plt"}, {nullptr}};
+  const PLTSectionInfo AArch64_PLTSections[3] = {
+      {".plt"}, {".iplt"}, {nullptr}};
 
   /// Return PLT information for a section with \p SectionName or nullptr
   /// if the section is not PLT.
   const PLTSectionInfo *getPLTSectionInfo(StringRef SectionName) {
     const PLTSectionInfo *PLTSI = nullptr;
     switch (BC->TheTriple->getArch()) {
     default:
       break;

bolt/lib/Rewrite/RewriteInstance.cpp

 }
 
 void RewriteInstance::createPLTBinaryFunction(uint64_t TargetAddress,
                                               uint64_t EntryAddress,
                                               uint64_t EntrySize) {
   if (!TargetAddress)
     return;
 
+  auto setPLTSymbol = [&](BinaryFunction *BF, StringRef Name) {
+    const unsigned PtrSize = BC->AsmInfo->getCodePointerSize();
+    MCSymbol *TargetSymbol = BC->registerNameAtAddress(
+        Name.str() + "@GOT", TargetAddress, PtrSize, PtrSize);
+    BF->setPLTSymbol(TargetSymbol);
+  };
+
+  BinaryFunction *BF = BC->getBinaryFunctionAtAddress(EntryAddress);
+  if (BF && BC->isAArch64()) {
+    // Handle IFUNC trampoline
+    setPLTSymbol(BF, BF->getOneName());
+    return;
+  }
+
   const Relocation *Rel = BC->getDynamicRelocationAt(TargetAddress);
   if (!Rel || !Rel->Symbol)
     return;
 
-  const unsigned PtrSize = BC->AsmInfo->getCodePointerSize();
   ErrorOr<BinarySection &> Section = BC->getSectionForAddress(EntryAddress);
   assert(Section && "cannot get section for address");
-  BinaryFunction *BF = BC->createBinaryFunction(
-      Rel->Symbol->getName().str() + "@PLT", *Section, EntryAddress, 0,
-      EntrySize, Section->getAlignment());
-  MCSymbol *TargetSymbol = BC->registerNameAtAddress(
-      Rel->Symbol->getName().str() + "@GOT", TargetAddress, PtrSize, PtrSize);
-  BF->setPLTSymbol(TargetSymbol);
+  BF = BC->createBinaryFunction(Rel->Symbol->getName().str() + "@PLT", *Section,
+                                EntryAddress, 0, EntrySize,
+                                Section->getAlignment());
+  setPLTSymbol(BF, Rel->Symbol->getName());
 }
 
 void RewriteInstance::disassemblePLTSectionAArch64(BinarySection &Section) {
   const uint64_t SectionAddress = Section.getAddress();
   const uint64_t SectionSize = Section.getSize();
   StringRef PLTContents = Section.getContents();
   ArrayRef<uint8_t> PLTData(
       reinterpret_cast<const uint8_t *>(PLTContents.data()), SectionSize);

bolt/test/runtime/AArch64/iplt.c

+// This test checks that the ifuncs works after bolt.
+
+// RUN: %clang %cflags %s -fuse-ld=lld \
+// RUN:    -o %t.exe -Wl,-q
+// RUN: llvm-bolt %t.exe -o %t.bolt.exe -use-old-text=0 -lite=0
+// RUN: %t.bolt.exe  | FileCheck %s
+
+// CHECK: foo
+
+#include <stdio.h>
+#include <string.h>
+
+static void foo() { printf("foo\n"); }
+
+static void *resolver_foo(void) { return foo; }
+
+__attribute__((ifunc("resolver_foo"))) void ifoo();
+
+static void *resolver_memcpy(void) { return memcpy; }
+
+__attribute__((ifunc("resolver_memcpy"))) void *
+imemcpy(void *dest, const void *src, size_t n);
+
+int main() {
+  int a = 0xdeadbeef, b = 0;
+  ifoo();
+  imemcpy(&b, &a, sizeof(b));
+  return a != b;
+}