[JITLink][AArch32] Multi-stub support and selection armv7/thumbv7

Author: weliveindetail

llvm/include/llvm/ExecutionEngine/JITLink/aarch32.h

@@ -318,74 +318,32 @@ inline Error applyFixup(LinkGraph &G, Block &B, const Edge &E,
   llvm_unreachable("Relocation must be of class Data, Arm or Thumb");
 }
 
-/// Stubs builder for a specific StubsFlavor
-///
-/// Right now we only have one default stub kind, but we want to extend this
-/// and allow creation of specific kinds in the future (e.g. branch range
-/// extension or interworking).
-///
+/// Stubs builder for v7 emits non-position-independent Arm and Thumb stubs.
 /// Let's keep it simple for the moment and not wire this through a GOT.
 ///
-template <StubsFlavor Flavor>
-class StubsManager : public TableManager<StubsManager<Flavor>> {
+class StubsManager_v7 {
 public:
-  StubsManager() = default;
 
-  /// Name of the object file section that will contain all our stubs.
-  static StringRef getSectionName();
+  StubsManager_v7() = default;
 
-  /// Implements link-graph traversal via visitExistingEdges().
-  bool visitEdge(LinkGraph &G, Block *B, Edge &E) {
-    if (E.getTarget().isDefined())
-      return false;
-
-    switch (E.getKind()) {
-    case Thumb_Call:
-    case Thumb_Jump24: {
-      DEBUG_WITH_TYPE("jitlink", {
-        dbgs() << "  Fixing " << G.getEdgeKindName(E.getKind()) << " edge at "
-               << B->getFixupAddress(E) << " (" << B->getAddress() << " + "
-               << formatv("{0:x}", E.getOffset()) << ")\n";
-      });
-      E.setTarget(this->getEntryForTarget(G, E.getTarget()));
-      return true;
-    }
-    }
-    return false;
+  /// Name of the object file section that will contain all our stubs.
+  static StringRef getSectionName() {
+    return "__llvm_jitlink_aarch32_STUBS_v7";
   }
 
-  /// Create a branch range extension stub for the class's flavor.
-  Symbol &createEntry(LinkGraph &G, Symbol &Target);
+  /// Implements link-graph traversal via visitExistingEdges().
+  bool visitEdge(LinkGraph &G, Block *B, Edge &E);
 
 private:
-  /// Create a new node in the link-graph for the given stub template.
-  template <size_t Size>
-  Block &addStub(LinkGraph &G, const uint8_t (&Code)[Size],
-                 uint64_t Alignment) {
-    ArrayRef<char> Template(reinterpret_cast<const char *>(Code), Size);
-    return G.createContentBlock(getStubsSection(G), Template,
-                                orc::ExecutorAddr(), Alignment, 0);
-  }
+  using StubMapEntry = SmallVector<std::tuple<bool, Symbol *>>;
+  enum ThumbStatePreference { Undefined = -1, Avoid = 0, PreferNot, Prefer, Force };
 
-  /// Get or create the object file section that will contain all our stubs.
-  Section &getStubsSection(LinkGraph &G) {
-    if (!StubsSection)
-      StubsSection = &G.createSection(getSectionName(),
-                                      orc::MemProt::Read | orc::MemProt::Exec);
-    return *StubsSection;
-  }
+  Symbol *selectStub(const StubMapEntry &Candidates, ThumbStatePreference ThumbState);
 
+  DenseMap<StringRef, StubMapEntry> StubMap;
   Section *StubsSection = nullptr;
 };
 
-/// Create a branch range extension stub with Thumb encoding for v7 CPUs.
-template <>
-Symbol &StubsManager<StubsFlavor::v7>::createEntry(LinkGraph &G, Symbol &Target);
-
-template <> inline StringRef StubsManager<StubsFlavor::v7>::getSectionName() {
-  return "__llvm_jitlink_aarch32_STUBS_Thumbv7";
-}
-
 } // namespace aarch32
 } // namespace jitlink
 } // namespace llvm

llvm/lib/ExecutionEngine/JITLink/ELF_aarch32.cpp

@@ -216,12 +216,12 @@ class ELFLinkGraphBuilder_aarch32
         ArmCfg(std::move(ArmCfg)) {}
 };
 
-template <aarch32::StubsFlavor Flavor>
+template <typename StubsManagerType>
 Error buildTables_ELF_aarch32(LinkGraph &G) {
   LLVM_DEBUG(dbgs() << "Visiting edges in graph:\n");
 
-  aarch32::StubsManager<Flavor> PLT;
-  visitExistingEdges(G, PLT);
+  StubsManagerType Stubs;
+  visitExistingEdges(G, Stubs);
   return Error::success();
 }
 
@@ -311,7 +311,7 @@ void link_ELF_aarch32(std::unique_ptr<LinkGraph> G,
     switch (ArmCfg.Stubs) {
     case aarch32::StubsFlavor::v7:
       PassCfg.PostPrunePasses.push_back(
-          buildTables_ELF_aarch32<aarch32::StubsFlavor::v7>);
+          buildTables_ELF_aarch32<aarch32::StubsManager_v7>);
       break;
     case aarch32::StubsFlavor::Unsupported:
       llvm_unreachable("Check before building graph");

llvm/lib/ExecutionEngine/JITLink/aarch32.cpp

@@ -15,6 +15,7 @@
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/ExecutionEngine/JITLink/JITLink.h"
+#include "llvm/ExecutionEngine/Orc/Shared/MemoryFlags.h"
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/ManagedStatic.h"
@@ -678,28 +679,145 @@ Error applyFixupThumb(LinkGraph &G, Block &B, const Edge &E,
   }
 }
 
+const uint8_t Armv7ABS[] = {
+    0x00, 0xc0, 0x00, 0xe3, // movw r12, #0x0000     ; lower 16-bit
+    0x00, 0xc0, 0x40, 0xe3, // movt r12, #0x0000     ; upper 16-bit
+    0x1c, 0xff, 0x2f, 0xe1  // bx   r12
+};
+
 const uint8_t Thumbv7ABS[] = {
     0x40, 0xf2, 0x00, 0x0c, // movw r12, #0x0000    ; lower 16-bit
     0xc0, 0xf2, 0x00, 0x0c, // movt r12, #0x0000    ; upper 16-bit
     0x60, 0x47              // bx   r12
 };
 
-template <>
-Symbol &StubsManager<StubsFlavor::v7>::createEntry(LinkGraph &G, Symbol &Target) {
+/// Create a new node in the link-graph for the given stub template.
+template <size_t Size>
+static Block &allocStub(LinkGraph &G, Section &S, const uint8_t (&Code)[Size]) {
   constexpr uint64_t Alignment = 4;
-  Block &B = addStub(G, Thumbv7ABS, Alignment);
-  LLVM_DEBUG({
-    const char *StubPtr = B.getContent().data();
-    HalfWords Reg12 = encodeRegMovtT1MovwT3(12);
-    assert(checkRegister<Thumb_MovwAbsNC>(StubPtr, Reg12) &&
-           checkRegister<Thumb_MovtAbs>(StubPtr + 4, Reg12) &&
-           "Linker generated stubs may only corrupt register r12 (IP)");
-  });
+  ArrayRef<char> Template(reinterpret_cast<const char *>(Code), Size);
+  return G.createContentBlock(S, Template, orc::ExecutorAddr(), Alignment, 0);
+}
+
+static Block &createStubThumbv7(LinkGraph &G, Section &S, Symbol &Target) {
+  Block &B = allocStub(G, S, Thumbv7ABS);
   B.addEdge(Thumb_MovwAbsNC, 0, Target, 0);
   B.addEdge(Thumb_MovtAbs, 4, Target, 0);
-  Symbol &Stub = G.addAnonymousSymbol(B, 0, B.getSize(), true, false);
-  Stub.setTargetFlags(ThumbSymbol);
-  return Stub;
+
+  [[maybe_unused]] const char *StubPtr = B.getContent().data();
+  [[maybe_unused]] HalfWords Reg12 = encodeRegMovtT1MovwT3(12);
+  assert(checkRegister<Thumb_MovwAbsNC>(StubPtr, Reg12) &&
+         checkRegister<Thumb_MovtAbs>(StubPtr + 4, Reg12) &&
+         "Linker generated stubs may only corrupt register r12 (IP)");
+  return B;
+}
+
+static Block &createStubArmv7(LinkGraph &G, Section &S, Symbol &Target) {
+  Block &B = allocStub(G, S, Armv7ABS);
+  B.addEdge(Arm_MovwAbsNC, 0, Target, 0);
+  B.addEdge(Arm_MovtAbs, 4, Target, 0);
+
+  [[maybe_unused]] const char *StubPtr = B.getContent().data();
+  [[maybe_unused]] uint32_t Reg12 = encodeRegMovtA1MovwA2(12);
+  assert(checkRegister<Arm_MovwAbsNC>(StubPtr, Reg12) &&
+         checkRegister<Arm_MovtAbs>(StubPtr + 4, Reg12) &&
+         "Linker generated stubs may only corrupt register r12 (IP)");
+  return B;
+}
+
+Symbol *StubsManager_v7::selectStub(const StubMapEntry &Candidates,
+                                    ThumbStatePreference ThumbState) {
+  Symbol *StubSymbol = nullptr;
+  for (auto [StubIsThumb, Sym] : Candidates) {
+    if (StubIsThumb) {
+      if (ThumbState == Avoid)
+        continue; // No match
+      StubSymbol = Sym;
+      break; // Best match
+    }
+    if (ThumbState == Avoid) {
+      StubSymbol = Sym;
+      break; // Best match
+    }
+    if (ThumbState == Prefer) {
+      StubSymbol = Sym;
+      continue; // Acceptable match
+    }
+  }
+  return StubSymbol;
+}
+
+bool StubsManager_v7::visitEdge(LinkGraph &G, Block *B, Edge &E) {
+  ThumbStatePreference ThumbState = Undefined;
+  switch (E.getKind()) {
+  case Arm_Call:
+  case Arm_Jump24:
+    ThumbState = Avoid;
+    break;
+  case Thumb_Call:
+    ThumbState = Prefer;
+    break;
+  case Thumb_Jump24:
+    ThumbState = Force;
+    break;
+  default:
+    return false;
+  }
+
+  assert(ThumbState != Undefined && "Define Thumb state preference");
+
+  // Stubs are usually created only for external targets.
+  Symbol &Target = E.getTarget();
+  if (Target.isDefined()) {
+    bool TargetIsThumb = Target.getTargetFlags() & ThumbSymbol;
+    bool InterworkingStub = ThumbState == Force && !TargetIsThumb;
+    if (!InterworkingStub)
+      return false;
+  }
+
+  LLVM_DEBUG(dbgs() << "  Preparing stub with thumb-state '"
+                    << (ThumbState == Avoid ? "Avoid" : "")
+                    << (ThumbState == Prefer ? "Prefer" : "")
+                    << (ThumbState == Force ? "Force" : "") << "' for "
+                    << G.getEdgeKindName(E.getKind()) << " edge at "
+                    << B->getFixupAddress(E) << " (" << B->getAddress() << " + "
+                    << formatv("{0:x}", E.getOffset()) << ")\n");
+
+  assert(Target.hasName() && "Edge cannot point to anonymous target");
+  auto TargetEntry = StubMap.try_emplace(Target.getName()).first;
+
+  Symbol *StubSymbol = selectStub(TargetEntry->second, ThumbState);
+  if (!StubSymbol) {
+    if (!StubsSection)
+      StubsSection = &G.createSection(getSectionName(),
+                                      orc::MemProt::Read | orc::MemProt::Exec);
+
+    bool MakeThumb = ThumbState >= Prefer;
+    Block &B = MakeThumb ? createStubThumbv7(G, *StubsSection, Target)
+                         : createStubArmv7(G, *StubsSection, Target);
+
+    StubSymbol = &G.addAnonymousSymbol(B, 0, B.getSize(), true, false);
+    if (MakeThumb)
+      StubSymbol->setTargetFlags(ThumbSymbol);
+
+    LLVM_DEBUG({
+      dbgs() << "    Created " << (MakeThumb ? "Thumb" : "Arm") << " entry for "
+             << Target.getName() << " in " << StubsSection->getName() << ": "
+             << *StubSymbol << "\n";
+    });
+
+    TargetEntry->second.emplace_back(MakeThumb, StubSymbol);
+  }
+
+  LLVM_DEBUG({
+    bool StubIsThumb = StubSymbol->getTargetFlags() & ThumbSymbol;
+    dbgs() << "    Using " << (StubIsThumb ? "Thumb" : "Arm") << " entry "
+           << *StubSymbol << " in "
+           << StubSymbol->getBlock().getSection().getName() << "\n";
+  });
+
+  E.setTarget(*StubSymbol);
+  return true;
 }
 
 const char *getEdgeKindName(Edge::Kind K) {

llvm/test/ExecutionEngine/JITLink/AArch32/ELF_stubs_arm.s

@@ -0,0 +1,39 @@
+# RUN: rm -rf %t && mkdir -p %t
+# RUN: llvm-mc -triple=armv7-linux-gnueabi -arm-add-build-attributes \
+# RUN:         -filetype=obj -filetype=obj -o %t/elf_stubs.o %s
+# RUN: llvm-jitlink -noexec -slab-address 0x76ff0000 \
+# RUN:              -slab-allocate 10Kb -slab-page-size 4096 \
+# RUN:              -abs ext_arm=0x76bbe880 \
+# RUN:              -check %s %t/elf_stubs.o
+
+	.text
+	.syntax unified
+
+# Check that calls/jumps to external functions trigger the generation of
+# branch-range extension stubs. These stubs don't follow the default PLT model
+# where the branch-target address is loaded from a GOT entry. Instead, they
+# hard-code it in the immediate field.
+#
+# jitlink-check: decode_operand(test_external_call, 0) = stub_addr(elf_stubs.o, ext_arm) - (test_external_call + 8)
+# jitlink-check: decode_operand(test_external_jump, 0) = stub_addr(elf_stubs.o, ext_arm) - (test_external_jump + 8)
+	.globl  test_external_call
+	.type	test_external_call,%function
+	.p2align	2
+test_external_call:
+	bl	ext_arm
+	.size test_external_call, .-test_external_call
+
+	.globl  test_external_jump
+	.type	test_external_jump,%function
+	.p2align	2
+test_external_jump:
+	b	ext_arm
+	.size test_external_jump, .-test_external_jump
+
+# Empty main function for jitlink to be happy
+	.globl	main
+	.type	main,%function
+	.p2align	2
+main:
+	bx	lr
+	.size	main,	.-main

llvm/test/ExecutionEngine/JITLink/AArch32/ELF_stubs_multi.s

@@ -0,0 +1,56 @@
+# RUN: rm -rf %t && mkdir -p %t
+# RUN: llvm-mc -triple=thumbv7-linux-gnueabi -arm-add-build-attributes \
+# RUN:         -filetype=obj -filetype=obj -o %t/elf_stubs.o %s
+# RUN: llvm-jitlink -noexec -slab-address 0x76ff0000 \
+# RUN:              -slab-allocate 10Kb -slab-page-size 4096 \
+# RUN:              -abs external_func=0x76bbe880 \
+# RUN:              -check %s %t/elf_stubs.o
+
+	.text
+	.syntax unified
+
+# Check support for multiple stubs for a single symbol
+
+# jitlink-check: decode_operand(test_avoid_thumb, 0)  = stub_addr(elf_stubs.o, external_func, 0) - (test_avoid_thumb + 8)
+# jitlink-check: decode_operand(test_prefer_thumb, 2) = stub_addr(elf_stubs.o, external_func, 0) - next_pc(test_prefer_thumb)
+# jitlink-check: decode_operand(test_force_thumb, 0)  = stub_addr(elf_stubs.o, external_func, 1) - next_pc(test_force_thumb)
+
+# Arm call will create an Arm stub first
+	.globl  test_avoid_thumb
+	.type	test_avoid_thumb,%function
+	.p2align	2
+	.code	32
+test_avoid_thumb:
+	bl	external_func
+	.size test_avoid_thumb, .-test_avoid_thumb
+
+# Thumb call would create a Thumb stub if there was non at all, but it can be
+# rewritten to BLX and reuse the existing Arm stub.
+# TODO: Should we reconsider during relaxation?
+	.globl  test_prefer_thumb
+	.type	test_prefer_thumb,%function
+	.p2align	1
+	.code	16
+	.thumb_func
+test_prefer_thumb:
+	bl	external_func
+	.size test_prefer_thumb, .-test_prefer_thumb
+
+# Thumb jump requires a Thumb stub, so it creates one in addition to the
+# existing Arm stub.
+	.globl  test_force_thumb
+	.type	test_force_thumb,%function
+	.p2align	1
+	.code	16
+	.thumb_func
+test_force_thumb:
+	b	external_func
+	.size test_force_thumb, .-test_force_thumb
+
+# Empty main function for jitlink to be happy
+	.globl	main
+	.type	main,%function
+	.p2align	2
+main:
+	bx	lr
+	.size	main,	.-main