[llvm] [JITLink] Add Hexagon ELF backend (PR #189710)

Brian Cain via llvm-commits llvm-commits at lists.llvm.org
Tue Apr 7 07:07:38 PDT 2026


https://github.com/androm3da updated https://github.com/llvm/llvm-project/pull/189710

>From 06d30a585be573688730ff6d68b26ec454916edb Mon Sep 17 00:00:00 2001
From: Brian Cain <brian.cain at oss.qualcomm.com>
Date: Tue, 31 Mar 2026 09:51:32 -0700
Subject: [PATCH 1/4] [JITLink] Add Hexagon ELF backend

Add JITLink support for Hexagon (ELF32-LE) object files.

This patch implements:
  - ELF_hexagon.cpp: graph-building from ELF32 objects, relocation
    parsing for all 28 Hexagon relocation types
  - hexagon.cpp: fixup application via applyMask() bit-spreading,
    handling constant extenders, duplexes, and PC-relative branches
  - 5 initial lit tests with jitlink-check verification covering:
    R_HEX_B22_PCREL, R_HEX_32, R_HEX_HI16, R_HEX_LO16,
    R_HEX_32_6_X + R_HEX_16_X, R_HEX_B32_PCREL_X + R_HEX_B22_PCREL_X
---
 .../ExecutionEngine/JITLink/ELF_hexagon.h     |  37 ++
 .../llvm/ExecutionEngine/JITLink/hexagon.h    | 156 +++++++++
 .../ExecutionEngine/JITLink/CMakeLists.txt    |   2 +
 llvm/lib/ExecutionEngine/JITLink/ELF.cpp      |   6 +
 .../ExecutionEngine/JITLink/ELF_hexagon.cpp   | 231 +++++++++++++
 llvm/lib/ExecutionEngine/JITLink/hexagon.cpp  | 317 ++++++++++++++++++
 .../JITLink/Hexagon/ELF_hexagon_b22_pcrel.s   |  34 ++
 .../Hexagon/ELF_hexagon_const_extender.s      |  50 +++
 .../Hexagon/ELF_hexagon_data_relocations.s    |  35 ++
 .../JITLink/Hexagon/ELF_hexagon_hilo16.s      |  42 +++
 .../JITLink/Hexagon/ELF_hexagon_minimal.s     |  17 +
 .../JITLink/Hexagon/lit.local.cfg             |   2 +
 12 files changed, 929 insertions(+)
 create mode 100644 llvm/include/llvm/ExecutionEngine/JITLink/ELF_hexagon.h
 create mode 100644 llvm/include/llvm/ExecutionEngine/JITLink/hexagon.h
 create mode 100644 llvm/lib/ExecutionEngine/JITLink/ELF_hexagon.cpp
 create mode 100644 llvm/lib/ExecutionEngine/JITLink/hexagon.cpp
 create mode 100644 llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_b22_pcrel.s
 create mode 100644 llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_const_extender.s
 create mode 100644 llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_data_relocations.s
 create mode 100644 llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_hilo16.s
 create mode 100644 llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_minimal.s
 create mode 100644 llvm/test/ExecutionEngine/JITLink/Hexagon/lit.local.cfg

diff --git a/llvm/include/llvm/ExecutionEngine/JITLink/ELF_hexagon.h b/llvm/include/llvm/ExecutionEngine/JITLink/ELF_hexagon.h
new file mode 100644
index 0000000000000..4a9e948382efc
--- /dev/null
+++ b/llvm/include/llvm/ExecutionEngine/JITLink/ELF_hexagon.h
@@ -0,0 +1,37 @@
+//===--- ELF_hexagon.h - JIT link functions for ELF/hexagon ---*- C++ -*---===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// jit-link functions for ELF/hexagon.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_JITLINK_ELF_HEXAGON_H
+#define LLVM_EXECUTIONENGINE_JITLINK_ELF_HEXAGON_H
+
+#include "llvm/ExecutionEngine/JITLink/JITLink.h"
+
+namespace llvm {
+namespace jitlink {
+
+/// Create a LinkGraph from an ELF/Hexagon relocatable object.
+///
+/// Note: The graph does not take ownership of the underlying buffer, nor copy
+/// its contents. The caller is responsible for ensuring that the object buffer
+/// outlives the graph.
+Expected<std::unique_ptr<LinkGraph>> createLinkGraphFromELFObject_hexagon(
+    MemoryBufferRef ObjectBuffer, std::shared_ptr<orc::SymbolStringPool> SSP);
+
+/// jit-link the given object buffer, which must be a ELF Hexagon relocatable
+/// object file.
+void link_ELF_hexagon(std::unique_ptr<LinkGraph> G,
+                      std::unique_ptr<JITLinkContext> Ctx);
+
+} // end namespace jitlink
+} // end namespace llvm
+
+#endif // LLVM_EXECUTIONENGINE_JITLINK_ELF_HEXAGON_H
diff --git a/llvm/include/llvm/ExecutionEngine/JITLink/hexagon.h b/llvm/include/llvm/ExecutionEngine/JITLink/hexagon.h
new file mode 100644
index 0000000000000..a9960832836a0
--- /dev/null
+++ b/llvm/include/llvm/ExecutionEngine/JITLink/hexagon.h
@@ -0,0 +1,156 @@
+//===---- hexagon.h - JITLink hexagon edge kinds, utilities -----*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Generic utilities for graphs representing Hexagon objects.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_JITLINK_HEXAGON_H
+#define LLVM_EXECUTIONENGINE_JITLINK_HEXAGON_H
+
+#include "llvm/ExecutionEngine/JITLink/JITLink.h"
+#include "llvm/Support/Compiler.h"
+
+namespace llvm::jitlink::hexagon {
+
+/// Represents Hexagon fixup kinds.
+enum EdgeKind_hexagon : Edge::Kind {
+  /// Full 32-bit absolute pointer.
+  ///   Fixup <- Target + Addend : uint32
+  Pointer32 = Edge::FirstRelocation,
+
+  /// 32-bit PC-relative.
+  ///   Fixup <- Target - Fixup + Addend : int32
+  PCRel32,
+
+  /// 22-bit PC-relative branch (shifted right by 2).
+  ///   Fixup <- (Target - Fixup + Addend) >> 2 : int22
+  ///   Mask: 0x01ff3ffe
+  B22_PCREL,
+
+  /// 15-bit PC-relative branch (shifted right by 2).
+  ///   Fixup <- (Target - Fixup + Addend) >> 2 : int15
+  ///   Mask: 0x00df20fe
+  B15_PCREL,
+
+  /// 13-bit PC-relative branch (shifted right by 2).
+  ///   Fixup <- (Target - Fixup + Addend) >> 2 : int13
+  ///   Mask: 0x00202ffe
+  B13_PCREL,
+
+  /// 9-bit PC-relative branch (shifted right by 2).
+  ///   Fixup <- (Target - Fixup + Addend) >> 2 : int9
+  ///   Mask: 0x003000fe
+  B9_PCREL,
+
+  /// 7-bit PC-relative branch (shifted right by 2).
+  ///   Fixup <- (Target - Fixup + Addend) >> 2 : int7
+  ///   Mask: 0x00001f18
+  B7_PCREL,
+
+  /// High 16 bits of absolute address.
+  ///   Fixup <- (Target + Addend) >> 16
+  ///   Mask: 0x00c03fff
+  HI16,
+
+  /// Low 16 bits of absolute address.
+  ///   Fixup <- (Target + Addend) & 0xffff
+  ///   Mask: 0x00c03fff
+  LO16,
+
+  /// 32-bit absolute, upper 26 bits via constant extender (shifted right by 6).
+  ///   Fixup <- (Target + Addend) >> 6
+  ///   Mask: 0x0fff3fff
+  Word32_6_X,
+
+  /// 32-bit PC-relative, upper 26 bits via constant extender (shifted by 6).
+  ///   Fixup <- (Target - Fixup + Addend) >> 6
+  ///   Mask: 0x0fff3fff
+  B32_PCREL_X,
+
+  /// 22-bit PC-relative branch, lower 6 bits via extender.
+  ///   Fixup <- (Target - Fixup + Addend) & 0x3f
+  ///   Mask: 0x01ff3ffe
+  B22_PCREL_X,
+
+  /// 15-bit PC-relative branch, lower 6 bits via extender.
+  ///   Fixup <- (Target - Fixup + Addend) & 0x3f
+  ///   Mask: 0x00df20fe
+  B15_PCREL_X,
+
+  /// 13-bit PC-relative branch, lower 6 bits via extender.
+  ///   Fixup <- (Target - Fixup + Addend) & 0x3f
+  ///   Mask: 0x00202ffe
+  B13_PCREL_X,
+
+  /// 9-bit PC-relative branch, lower 6 bits via extender.
+  ///   Fixup <- (Target - Fixup + Addend) & 0x3f
+  ///   Mask: 0x003000fe
+  B9_PCREL_X,
+
+  /// 7-bit PC-relative branch, lower 6 bits via extender.
+  ///   Fixup <- (Target - Fixup + Addend) & 0x3f
+  ///   Mask: 0x00001f18
+  B7_PCREL_X,
+
+  /// 6-bit absolute extended.
+  ///   Fixup <- (Target + Addend) & mask (instruction-dependent)
+  Word6_X,
+
+  /// 6-bit PC-relative extended.
+  ///   Fixup <- (Target - Fixup + Addend) & mask (instruction-dependent)
+  Word6_PCREL_X,
+
+  /// 8-bit absolute extended.
+  Word8_X,
+
+  /// 9-bit absolute extended (6 effective bits).
+  Word9_X,
+
+  /// 10-bit absolute extended (6 effective bits).
+  Word10_X,
+
+  /// 11-bit absolute extended (6 effective bits).
+  Word11_X,
+
+  /// 12-bit absolute extended.
+  Word12_X,
+
+  /// 16-bit absolute extended (6 effective bits).
+  Word16_X,
+};
+
+/// Returns a string name for the given Hexagon edge kind.
+LLVM_ABI const char *getEdgeKindName(Edge::Kind K);
+
+/// Hexagon pointer size.
+constexpr uint32_t PointerSize = 4;
+
+/// Spread data bits into instruction word according to mask.
+/// For each set bit in mask (scanning low to high), the corresponding
+/// bit position in the result gets the next data bit.
+constexpr uint32_t applyMask(uint32_t Mask, uint32_t Data) {
+  uint32_t Result = 0;
+  size_t Off = 0;
+  for (size_t Bit = 0; Bit != 32; ++Bit) {
+    uint32_t ValBit = (Data >> Off) & 1;
+    uint32_t MaskBit = (Mask >> Bit) & 1;
+    if (MaskBit) {
+      Result |= (ValBit << Bit);
+      ++Off;
+    }
+  }
+  return Result;
+}
+
+/// Apply fixup expression for edge to block content.
+LLVM_ABI Error applyFixup(LinkGraph &G, Block &B, const Edge &E);
+
+} // namespace llvm::jitlink::hexagon
+
+#endif // LLVM_EXECUTIONENGINE_JITLINK_HEXAGON_H
diff --git a/llvm/lib/ExecutionEngine/JITLink/CMakeLists.txt b/llvm/lib/ExecutionEngine/JITLink/CMakeLists.txt
index 0b530fb1bc478..0109002e9bc18 100644
--- a/llvm/lib/ExecutionEngine/JITLink/CMakeLists.txt
+++ b/llvm/lib/ExecutionEngine/JITLink/CMakeLists.txt
@@ -23,6 +23,7 @@ add_llvm_component_library(LLVMJITLink
   ELFLinkGraphBuilder.cpp
   ELF_aarch32.cpp
   ELF_aarch64.cpp
+  ELF_hexagon.cpp
   ELF_loongarch.cpp
   ELF_ppc64.cpp
   ELF_riscv.cpp
@@ -44,6 +45,7 @@ add_llvm_component_library(LLVMJITLink
   # Architectures:
   aarch32.cpp
   aarch64.cpp
+  hexagon.cpp
   loongarch.cpp
   ppc64.cpp
   riscv.cpp
diff --git a/llvm/lib/ExecutionEngine/JITLink/ELF.cpp b/llvm/lib/ExecutionEngine/JITLink/ELF.cpp
index 42f42eef00e5b..494466297aefe 100644
--- a/llvm/lib/ExecutionEngine/JITLink/ELF.cpp
+++ b/llvm/lib/ExecutionEngine/JITLink/ELF.cpp
@@ -15,6 +15,7 @@
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/ExecutionEngine/JITLink/ELF_aarch32.h"
 #include "llvm/ExecutionEngine/JITLink/ELF_aarch64.h"
+#include "llvm/ExecutionEngine/JITLink/ELF_hexagon.h"
 #include "llvm/ExecutionEngine/JITLink/ELF_loongarch.h"
 #include "llvm/ExecutionEngine/JITLink/ELF_ppc64.h"
 #include "llvm/ExecutionEngine/JITLink/ELF_riscv.h"
@@ -89,6 +90,8 @@ createLinkGraphFromELFObject(MemoryBufferRef ObjectBuffer,
     return createLinkGraphFromELFObject_aarch64(ObjectBuffer, std::move(SSP));
   case ELF::EM_ARM:
     return createLinkGraphFromELFObject_aarch32(ObjectBuffer, std::move(SSP));
+  case ELF::EM_HEXAGON:
+    return createLinkGraphFromELFObject_hexagon(ObjectBuffer, std::move(SSP));
   case ELF::EM_PPC64: {
     if (DataEncoding == ELF::ELFDATA2LSB)
       return createLinkGraphFromELFObject_ppc64le(ObjectBuffer, std::move(SSP));
@@ -124,6 +127,9 @@ void link_ELF(std::unique_ptr<LinkGraph> G,
   case Triple::thumbeb:
     link_ELF_aarch32(std::move(G), std::move(Ctx));
     return;
+  case Triple::hexagon:
+    link_ELF_hexagon(std::move(G), std::move(Ctx));
+    return;
   case Triple::loongarch32:
   case Triple::loongarch64:
     link_ELF_loongarch(std::move(G), std::move(Ctx));
diff --git a/llvm/lib/ExecutionEngine/JITLink/ELF_hexagon.cpp b/llvm/lib/ExecutionEngine/JITLink/ELF_hexagon.cpp
new file mode 100644
index 0000000000000..a19acf324f9e8
--- /dev/null
+++ b/llvm/lib/ExecutionEngine/JITLink/ELF_hexagon.cpp
@@ -0,0 +1,231 @@
+//===------ ELF_hexagon.cpp - JIT linker for ELF/hexagon ------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// ELF/hexagon jit-link implementation.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ExecutionEngine/JITLink/ELF_hexagon.h"
+#include "ELFLinkGraphBuilder.h"
+#include "JITLinkGeneric.h"
+#include "llvm/BinaryFormat/ELF.h"
+#include "llvm/ExecutionEngine/JITLink/hexagon.h"
+#include "llvm/Object/ELFObjectFile.h"
+
+#define DEBUG_TYPE "jitlink"
+
+using namespace llvm;
+using namespace llvm::jitlink;
+
+namespace {
+
+class ELFJITLinker_hexagon : public JITLinker<ELFJITLinker_hexagon> {
+  friend class JITLinker<ELFJITLinker_hexagon>;
+
+public:
+  ELFJITLinker_hexagon(std::unique_ptr<JITLinkContext> Ctx,
+                       std::unique_ptr<LinkGraph> G,
+                       PassConfiguration PassConfig)
+      : JITLinker(std::move(Ctx), std::move(G), std::move(PassConfig)) {}
+
+private:
+  Error applyFixup(LinkGraph &G, Block &B, const Edge &E) const {
+    return hexagon::applyFixup(G, B, E);
+  }
+};
+
+class ELFLinkGraphBuilder_hexagon
+    : public ELFLinkGraphBuilder<object::ELF32LE> {
+private:
+  using ELFT = object::ELF32LE;
+
+  Expected<hexagon::EdgeKind_hexagon> getRelocationKind(const uint32_t Type) {
+    switch (Type) {
+    case ELF::R_HEX_32:
+      return hexagon::Pointer32;
+    case ELF::R_HEX_32_PCREL:
+      return hexagon::PCRel32;
+    case ELF::R_HEX_B22_PCREL:
+    case ELF::R_HEX_PLT_B22_PCREL:
+    // GD_PLT variants are mapped to plain branch edges since JITLink resolves
+    // all symbols directly. This does not handle TLS __tls_get_addr calls.
+    case ELF::R_HEX_GD_PLT_B22_PCREL:
+      return hexagon::B22_PCREL;
+    case ELF::R_HEX_B15_PCREL:
+      return hexagon::B15_PCREL;
+    case ELF::R_HEX_B13_PCREL:
+      return hexagon::B13_PCREL;
+    case ELF::R_HEX_B9_PCREL:
+      return hexagon::B9_PCREL;
+    case ELF::R_HEX_B7_PCREL:
+      return hexagon::B7_PCREL;
+    case ELF::R_HEX_HI16:
+      return hexagon::HI16;
+    case ELF::R_HEX_LO16:
+      return hexagon::LO16;
+    case ELF::R_HEX_32_6_X:
+      return hexagon::Word32_6_X;
+    case ELF::R_HEX_B32_PCREL_X:
+    case ELF::R_HEX_GD_PLT_B32_PCREL_X: // See GD_PLT note above.
+      return hexagon::B32_PCREL_X;
+    case ELF::R_HEX_B22_PCREL_X:
+    case ELF::R_HEX_GD_PLT_B22_PCREL_X: // See GD_PLT note above.
+      return hexagon::B22_PCREL_X;
+    case ELF::R_HEX_B15_PCREL_X:
+      return hexagon::B15_PCREL_X;
+    case ELF::R_HEX_B13_PCREL_X:
+      return hexagon::B13_PCREL_X;
+    case ELF::R_HEX_B9_PCREL_X:
+      return hexagon::B9_PCREL_X;
+    case ELF::R_HEX_B7_PCREL_X:
+      return hexagon::B7_PCREL_X;
+    case ELF::R_HEX_6_X:
+      return hexagon::Word6_X;
+    case ELF::R_HEX_6_PCREL_X:
+      return hexagon::Word6_PCREL_X;
+    case ELF::R_HEX_8_X:
+      return hexagon::Word8_X;
+    case ELF::R_HEX_9_X:
+      return hexagon::Word9_X;
+    case ELF::R_HEX_10_X:
+      return hexagon::Word10_X;
+    case ELF::R_HEX_11_X:
+      return hexagon::Word11_X;
+    case ELF::R_HEX_12_X:
+      return hexagon::Word12_X;
+    case ELF::R_HEX_16_X:
+      return hexagon::Word16_X;
+    }
+
+    return make_error<JITLinkError>(
+        "In " + G->getName() + ": Unsupported Hexagon relocation type " +
+        object::getELFRelocationTypeName(ELF::EM_HEXAGON, Type));
+  }
+
+  Error addRelocations() override {
+    LLVM_DEBUG(dbgs() << "Adding relocations\n");
+    using Base = ELFLinkGraphBuilder<ELFT>;
+    using Self = ELFLinkGraphBuilder_hexagon;
+
+    for (const auto &RelSect : Base::Sections) {
+      // Hexagon uses SHT_RELA.
+      if (RelSect.sh_type == ELF::SHT_REL)
+        return make_error<StringError>(
+            "Unexpected SHT_REL section in Hexagon ELF object",
+            inconvertibleErrorCode());
+
+      if (Error Err = Base::forEachRelaRelocation(RelSect, this,
+                                                  &Self::addSingleRelocation))
+        return Err;
+    }
+
+    return Error::success();
+  }
+
+  Error addSingleRelocation(const typename ELFT::Rela &Rel,
+                            const typename ELFT::Shdr &FixupSection,
+                            Block &BlockToFix) {
+    using Base = ELFLinkGraphBuilder<ELFT>;
+
+    auto ELFReloc = Rel.getType(false);
+
+    if (LLVM_UNLIKELY(ELFReloc == ELF::R_HEX_NONE))
+      return Error::success();
+
+    uint32_t SymbolIndex = Rel.getSymbol(false);
+    auto ObjSymbol = Base::Obj.getRelocationSymbol(Rel, Base::SymTabSec);
+    if (!ObjSymbol)
+      return ObjSymbol.takeError();
+
+    Symbol *GraphSymbol = Base::getGraphSymbol(SymbolIndex);
+    if (!GraphSymbol)
+      return make_error<StringError>(
+          formatv("Could not find symbol at given index, did you add it to "
+                  "JITSymbolTable? index: {0}, shndx: {1} Size of table: {2}",
+                  SymbolIndex, (*ObjSymbol)->st_shndx,
+                  Base::GraphSymbols.size()),
+          inconvertibleErrorCode());
+
+    Expected<hexagon::EdgeKind_hexagon> Kind = getRelocationKind(ELFReloc);
+    if (!Kind)
+      return Kind.takeError();
+
+    auto FixupAddress = orc::ExecutorAddr(FixupSection.sh_addr) + Rel.r_offset;
+    int64_t Addend = Rel.r_addend;
+
+    Edge::OffsetT Offset = FixupAddress - BlockToFix.getAddress();
+    Edge GE(*Kind, Offset, *GraphSymbol, Addend);
+    LLVM_DEBUG({
+      dbgs() << "    ";
+      printEdge(dbgs(), BlockToFix, GE, hexagon::getEdgeKindName(*Kind));
+      dbgs() << "\n";
+    });
+
+    BlockToFix.addEdge(std::move(GE));
+    return Error::success();
+  }
+
+public:
+  ELFLinkGraphBuilder_hexagon(StringRef FileName,
+                              const object::ELFFile<ELFT> &Obj,
+                              std::shared_ptr<orc::SymbolStringPool> SSP,
+                              Triple TT, SubtargetFeatures Features)
+      : ELFLinkGraphBuilder<ELFT>(Obj, std::move(SSP), std::move(TT),
+                                  std::move(Features), FileName,
+                                  hexagon::getEdgeKindName) {}
+};
+
+} // anonymous namespace
+
+namespace llvm::jitlink {
+
+Expected<std::unique_ptr<LinkGraph>> createLinkGraphFromELFObject_hexagon(
+    MemoryBufferRef ObjectBuffer, std::shared_ptr<orc::SymbolStringPool> SSP) {
+  LLVM_DEBUG({
+    dbgs() << "Building jitlink graph for new input "
+           << ObjectBuffer.getBufferIdentifier() << "...\n";
+  });
+
+  auto ELFObj = object::ObjectFile::createELFObjectFile(ObjectBuffer);
+  if (!ELFObj)
+    return ELFObj.takeError();
+
+  auto Features = (*ELFObj)->getFeatures();
+  if (!Features)
+    return Features.takeError();
+
+  assert((*ELFObj)->getArch() == Triple::hexagon &&
+         "Only Hexagon is supported");
+
+  auto &ELFObjFile = cast<object::ELFObjectFile<object::ELF32LE>>(**ELFObj);
+
+  return ELFLinkGraphBuilder_hexagon(
+             (*ELFObj)->getFileName(), ELFObjFile.getELFFile(), std::move(SSP),
+             (*ELFObj)->makeTriple(), std::move(*Features))
+      .buildGraph();
+}
+
+void link_ELF_hexagon(std::unique_ptr<LinkGraph> G,
+                      std::unique_ptr<JITLinkContext> Ctx) {
+  PassConfiguration Config;
+  const Triple &TT = G->getTargetTriple();
+  if (Ctx->shouldAddDefaultTargetPasses(TT)) {
+    // TODO: Add GOT/PLT stubs builder when external symbol support is needed.
+    // TODO: Add eh-frame passes when exception handling support is needed.
+    if (auto MarkLive = Ctx->getMarkLivePass(TT))
+      Config.PrePrunePasses.push_back(std::move(MarkLive));
+    else
+      Config.PrePrunePasses.push_back(markAllSymbolsLive);
+  }
+  if (auto Err = Ctx->modifyPassConfig(*G, Config))
+    return Ctx->notifyFailed(std::move(Err));
+
+  ELFJITLinker_hexagon::link(std::move(Ctx), std::move(G), std::move(Config));
+}
+
+} // namespace llvm::jitlink
diff --git a/llvm/lib/ExecutionEngine/JITLink/hexagon.cpp b/llvm/lib/ExecutionEngine/JITLink/hexagon.cpp
new file mode 100644
index 0000000000000..8cc37e38297f6
--- /dev/null
+++ b/llvm/lib/ExecutionEngine/JITLink/hexagon.cpp
@@ -0,0 +1,317 @@
+//===-------- hexagon.cpp - JITLink hexagon support --------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Hexagon edge kind names and fixup application.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ExecutionEngine/JITLink/hexagon.h"
+#include "llvm/Support/Endian.h"
+
+#define DEBUG_TYPE "jitlink"
+
+using namespace llvm;
+using namespace llvm::jitlink;
+
+namespace {
+
+// Instruction mask tables for R_HEX_6_X.
+struct InstructionMask {
+  uint32_t CmpMask;
+  uint32_t RelocMask;
+};
+
+static const InstructionMask R6Masks[] = {
+    {0x38000000, 0x0000201f}, {0x39000000, 0x0000201f},
+    {0x3e000000, 0x00001f80}, {0x3f000000, 0x00001f80},
+    {0x40000000, 0x000020f8}, {0x41000000, 0x000007e0},
+    {0x42000000, 0x000020f8}, {0x43000000, 0x000007e0},
+    {0x44000000, 0x000020f8}, {0x45000000, 0x000007e0},
+    {0x46000000, 0x000020f8}, {0x47000000, 0x000007e0},
+    {0x6a000000, 0x00001f80}, {0x7c000000, 0x001f2000},
+    {0x9a000000, 0x00000f60}, {0x9b000000, 0x00000f60},
+    {0x9c000000, 0x00000f60}, {0x9d000000, 0x00000f60},
+    {0x9f000000, 0x001f0100}, {0xab000000, 0x0000003f},
+    {0xad000000, 0x0000003f}, {0xaf000000, 0x00030078},
+    {0xd7000000, 0x006020e0}, {0xd8000000, 0x006020e0},
+    {0xdb000000, 0x006020e0}, {0xdf000000, 0x006020e0}};
+
+constexpr uint32_t InstParsePacketEnd = 0x0000c000;
+
+bool isDuplex(uint32_t Insn) { return (InstParsePacketEnd & Insn) == 0; }
+
+Expected<uint32_t> findMaskR6(uint32_t Insn) {
+  if (isDuplex(Insn))
+    return 0x03f00000;
+  for (auto &I : R6Masks)
+    if ((0xff000000 & Insn) == I.CmpMask)
+      return I.RelocMask;
+  return make_error<JITLinkError>("unrecognized instruction for R_HEX_6_X "
+                                  "relocation: 0x" +
+                                  utohexstr(Insn));
+}
+
+Expected<uint32_t> findMaskR8(uint32_t Insn) {
+  if (isDuplex(Insn))
+    return 0x03f00000;
+  if ((0xff000000 & Insn) == 0xde000000)
+    return 0x00e020e8;
+  if ((0xff000000 & Insn) == 0x3c000000)
+    return 0x0000207f;
+  return 0x00001fe0;
+}
+
+Expected<uint32_t> findMaskR11(uint32_t Insn) {
+  if (isDuplex(Insn))
+    return 0x03f00000;
+  if ((0xff000000 & Insn) == 0xa1000000)
+    return 0x060020ff;
+  return 0x06003fe0;
+}
+
+Expected<uint32_t> findMaskR16(uint32_t Insn) {
+  if (isDuplex(Insn))
+    return 0x03f00000;
+  Insn = Insn & ~InstParsePacketEnd;
+  if ((0xff000000 & Insn) == 0x48000000)
+    return 0x061f20ff;
+  if ((0xff000000 & Insn) == 0x49000000)
+    return 0x061f3fe0;
+  if ((0xff000000 & Insn) == 0x78000000)
+    return 0x00df3fe0;
+  if ((0xff000000 & Insn) == 0xb0000000)
+    return 0x0fe03fe0;
+  if ((0xff802000 & Insn) == 0x74000000)
+    return 0x00001fe0;
+  if ((0xff802000 & Insn) == 0x74002000)
+    return 0x00001fe0;
+  if ((0xff802000 & Insn) == 0x74800000)
+    return 0x00001fe0;
+  if ((0xff802000 & Insn) == 0x74802000)
+    return 0x00001fe0;
+  for (auto &I : R6Masks)
+    if ((0xff000000 & Insn) == I.CmpMask)
+      return I.RelocMask;
+  return make_error<JITLinkError>("unrecognized instruction for R_HEX_16_X "
+                                  "relocation: 0x" +
+                                  utohexstr(Insn));
+}
+
+} // anonymous namespace
+
+namespace llvm::jitlink::hexagon {
+
+const char *getEdgeKindName(Edge::Kind K) {
+  switch (K) {
+  case Pointer32:
+    return "Pointer32";
+  case PCRel32:
+    return "PCRel32";
+  case B22_PCREL:
+    return "B22_PCREL";
+  case B15_PCREL:
+    return "B15_PCREL";
+  case B13_PCREL:
+    return "B13_PCREL";
+  case B9_PCREL:
+    return "B9_PCREL";
+  case B7_PCREL:
+    return "B7_PCREL";
+  case HI16:
+    return "HI16";
+  case LO16:
+    return "LO16";
+  case Word32_6_X:
+    return "Word32_6_X";
+  case B32_PCREL_X:
+    return "B32_PCREL_X";
+  case B22_PCREL_X:
+    return "B22_PCREL_X";
+  case B15_PCREL_X:
+    return "B15_PCREL_X";
+  case B13_PCREL_X:
+    return "B13_PCREL_X";
+  case B9_PCREL_X:
+    return "B9_PCREL_X";
+  case B7_PCREL_X:
+    return "B7_PCREL_X";
+  case Word6_X:
+    return "Word6_X";
+  case Word6_PCREL_X:
+    return "Word6_PCREL_X";
+  case Word8_X:
+    return "Word8_X";
+  case Word9_X:
+    return "Word9_X";
+  case Word10_X:
+    return "Word10_X";
+  case Word11_X:
+    return "Word11_X";
+  case Word12_X:
+    return "Word12_X";
+  case Word16_X:
+    return "Word16_X";
+  default:
+    return getGenericEdgeKindName(K);
+  }
+}
+
+Error applyFixup(LinkGraph &G, Block &B, const Edge &E) {
+  using namespace llvm::support;
+
+  char *BlockWorkingMem = B.getAlreadyMutableContent().data();
+  char *FixupPtr = BlockWorkingMem + E.getOffset();
+  auto FixupAddress = B.getAddress() + E.getOffset();
+
+  int64_t TargetAddr = E.getTarget().getAddress().getValue() + E.getAddend();
+  int64_t PCRelVal = E.getTarget().getAddress().getValue() -
+                     FixupAddress.getValue() + E.getAddend();
+
+  auto or32le = [](char *P, uint32_t V) {
+    endian::write32le(P, endian::read32le(P) | V);
+  };
+
+  uint32_t Insn = endian::read32le(FixupPtr);
+
+  switch (E.getKind()) {
+  case Pointer32:
+    endian::write32le(FixupPtr, static_cast<uint32_t>(TargetAddr));
+    break;
+
+  case PCRel32:
+    endian::write32le(FixupPtr, static_cast<uint32_t>(PCRelVal));
+    break;
+
+  case B22_PCREL:
+    if (!isInt<24>(PCRelVal))
+      return makeTargetOutOfRangeError(G, B, E);
+    or32le(FixupPtr, applyMask(0x01ff3ffe, PCRelVal >> 2));
+    break;
+
+  case B15_PCREL:
+    if (!isInt<17>(PCRelVal))
+      return makeTargetOutOfRangeError(G, B, E);
+    or32le(FixupPtr, applyMask(0x00df20fe, PCRelVal >> 2));
+    break;
+
+  case B13_PCREL:
+    if (!isInt<15>(PCRelVal))
+      return makeTargetOutOfRangeError(G, B, E);
+    or32le(FixupPtr, applyMask(0x00202ffe, PCRelVal >> 2));
+    break;
+
+  case B9_PCREL:
+    if (!isInt<11>(PCRelVal))
+      return makeTargetOutOfRangeError(G, B, E);
+    or32le(FixupPtr, applyMask(0x003000fe, PCRelVal >> 2));
+    break;
+
+  case B7_PCREL:
+    if (!isInt<9>(PCRelVal))
+      return makeTargetOutOfRangeError(G, B, E);
+    or32le(FixupPtr, applyMask(0x00001f18, PCRelVal >> 2));
+    break;
+
+  case HI16:
+    or32le(FixupPtr, applyMask(0x00c03fff, TargetAddr >> 16));
+    break;
+
+  case LO16:
+    or32le(FixupPtr, applyMask(0x00c03fff, TargetAddr));
+    break;
+
+  case Word32_6_X:
+    or32le(FixupPtr, applyMask(0x0fff3fff, TargetAddr >> 6));
+    break;
+
+  case B32_PCREL_X:
+    or32le(FixupPtr, applyMask(0x0fff3fff, PCRelVal >> 6));
+    break;
+
+  case B22_PCREL_X:
+    or32le(FixupPtr, applyMask(0x01ff3ffe, PCRelVal & 0x3f));
+    break;
+
+  case B15_PCREL_X:
+    or32le(FixupPtr, applyMask(0x00df20fe, PCRelVal & 0x3f));
+    break;
+
+  case B13_PCREL_X:
+    or32le(FixupPtr, applyMask(0x00202ffe, PCRelVal & 0x3f));
+    break;
+
+  case B9_PCREL_X:
+    or32le(FixupPtr, applyMask(0x003000fe, PCRelVal & 0x3f));
+    break;
+
+  case B7_PCREL_X:
+    or32le(FixupPtr, applyMask(0x00001f18, PCRelVal & 0x3f));
+    break;
+
+  case Word6_X: {
+    auto Mask = findMaskR6(Insn);
+    if (!Mask)
+      return Mask.takeError();
+    or32le(FixupPtr, applyMask(*Mask, TargetAddr));
+    break;
+  }
+
+  case Word6_PCREL_X: {
+    auto Mask = findMaskR6(Insn);
+    if (!Mask)
+      return Mask.takeError();
+    or32le(FixupPtr, applyMask(*Mask, PCRelVal));
+    break;
+  }
+
+  case Word8_X: {
+    auto Mask = findMaskR8(Insn);
+    if (!Mask)
+      return Mask.takeError();
+    or32le(FixupPtr, applyMask(*Mask, TargetAddr));
+    break;
+  }
+
+  case Word9_X:
+    or32le(FixupPtr, applyMask(0x00003fe0, TargetAddr & 0x3f));
+    break;
+
+  case Word10_X:
+    or32le(FixupPtr, applyMask(0x00203fe0, TargetAddr & 0x3f));
+    break;
+
+  case Word11_X: {
+    auto Mask = findMaskR11(Insn);
+    if (!Mask)
+      return Mask.takeError();
+    or32le(FixupPtr, applyMask(*Mask, TargetAddr & 0x3f));
+    break;
+  }
+
+  case Word12_X:
+    or32le(FixupPtr, applyMask(0x000007e0, TargetAddr));
+    break;
+
+  case Word16_X: {
+    auto Mask = findMaskR16(Insn);
+    if (!Mask)
+      return Mask.takeError();
+    or32le(FixupPtr, applyMask(*Mask, TargetAddr & 0x3f));
+    break;
+  }
+
+  default:
+    return make_error<JITLinkError>(
+        "In graph " + G.getName() + ", section " + B.getSection().getName() +
+        " unsupported Hexagon edge kind " + getEdgeKindName(E.getKind()));
+  }
+
+  return Error::success();
+}
+
+} // namespace llvm::jitlink::hexagon
diff --git a/llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_b22_pcrel.s b/llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_b22_pcrel.s
new file mode 100644
index 0000000000000..f0d46389d9835
--- /dev/null
+++ b/llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_b22_pcrel.s
@@ -0,0 +1,34 @@
+# RUN: llvm-mc -triple=hexagon-unknown-linux-musl -filetype=obj -o %t.o %s
+# RUN: llvm-jitlink -noexec -slab-address 0x10000 -slab-allocate 64Kb \
+# RUN:   -slab-page-size 4096 -check %s %t.o
+
+## Verify R_HEX_B22_PCREL relocation encoding for function calls.
+## The B22_PCREL fixup spreads (target - PC) >> 2 into the instruction word
+## via mask 0x01ff3ffe: bits [13:1] hold the lower 13 data bits and
+## bits [24:16] hold the upper 9 data bits.
+
+	.text
+	.globl	main, foo
+	.type	main, at function
+	.p2align	4
+main:
+# jitlink-check: (*{4}main)[13:1] = (foo - main)[14:2]
+# jitlink-check: (*{4}main)[24:16] = (foo - main)[23:15]
+	{
+		call foo
+	}
+	{
+		jumpr r31
+	}
+	.size	main, .-main
+
+	.type	foo, at function
+	.p2align	4
+foo:
+	{
+		r0 = #0
+	}
+	{
+		jumpr r31
+	}
+	.size	foo, .-foo
diff --git a/llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_const_extender.s b/llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_const_extender.s
new file mode 100644
index 0000000000000..9aba358e7c857
--- /dev/null
+++ b/llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_const_extender.s
@@ -0,0 +1,50 @@
+# RUN: llvm-mc -triple=hexagon-unknown-linux-musl -filetype=obj -o %t.o %s
+# RUN: llvm-jitlink -noexec -slab-address 0x10000 -slab-allocate 64Kb \
+# RUN:   -slab-page-size 4096 -check %s %t.o
+
+## Verify constant extender relocation pairs.
+## Each extended instruction is two words: an immext (constant extender) at
+## the label address, followed by the main instruction at label + 4.
+##
+## B32_PCREL_X (mask 0x0fff3fff) encodes (target - PC) >> 6.
+## B22_PCREL_X (mask 0x01ff3ffe) encodes low 6 bits (assembler adds +4 addend).
+## Word32_6_X  (mask 0x0fff3fff) encodes target >> 6.
+
+	.text
+	.globl	main, far_func, data_ext
+	.type	main, at function
+	.p2align	4
+main:
+	## Extended call: immext (B32_PCREL_X) at main, call (B22_PCREL_X) at main+4.
+# jitlink-check: (*{4}main)[13:0] = (far_func - main)[19:6]
+# jitlink-check: (*{4}main)[27:16] = (far_func - main)[31:20]
+# jitlink-check: (*{4}(main + 4))[6:1] = (far_func - main)[5:0]
+	{
+		call ##far_func
+	}
+	## Extended load: immext (Word32_6_X) at data_ext, main (Word16_X) at data_ext+4.
+# jitlink-check: (*{4}data_ext)[13:0] = far_data[19:6]
+# jitlink-check: (*{4}data_ext)[27:16] = far_data[31:20]
+data_ext:
+	{
+		r0 = ##far_data
+	}
+	{
+		jumpr r31
+	}
+	.size	main, .-main
+
+	.type	far_func, at function
+	.p2align	4
+far_func:
+	{
+		jumpr r31
+	}
+	.size	far_func, .-far_func
+
+	.data
+	.globl	far_data
+	.p2align	2
+far_data:
+	.word	0x12345678
+	.size	far_data, 4
diff --git a/llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_data_relocations.s b/llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_data_relocations.s
new file mode 100644
index 0000000000000..0eadf779f7e5d
--- /dev/null
+++ b/llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_data_relocations.s
@@ -0,0 +1,35 @@
+# RUN: llvm-mc -triple=hexagon-unknown-linux-musl -filetype=obj -o %t.o %s
+# RUN: llvm-jitlink -noexec -slab-address 0x10000 -slab-allocate 64Kb \
+# RUN:   -slab-page-size 4096 -check %s %t.o
+
+## Verify R_HEX_32 (Pointer32) data relocation.
+
+	.text
+	.globl	main
+	.type	main, at function
+	.p2align	4
+main:
+	{
+		jumpr r31
+	}
+	.size	main, .-main
+
+	.globl	target_fn
+	.type	target_fn, at function
+	.p2align	4
+target_fn:
+	{
+		r0 = #42
+	}
+	{
+		jumpr r31
+	}
+	.size	target_fn, .-target_fn
+
+	.data
+	.globl	ptr_to_fn
+	.p2align	2
+ptr_to_fn:
+# jitlink-check: *{4}ptr_to_fn = target_fn
+	.word	target_fn
+	.size	ptr_to_fn, 4
diff --git a/llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_hilo16.s b/llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_hilo16.s
new file mode 100644
index 0000000000000..7da869209d35f
--- /dev/null
+++ b/llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_hilo16.s
@@ -0,0 +1,42 @@
+# RUN: llvm-mc -triple=hexagon-unknown-linux-musl -filetype=obj -o %t.o %s
+# RUN: llvm-jitlink -noexec -slab-address 0x10000 -slab-allocate 64Kb \
+# RUN:   -slab-page-size 4096 -check %s %t.o
+
+## Verify R_HEX_HI16 and R_HEX_LO16 relocation encoding.
+## Both use mask 0x00c03fff: bits [13:0] hold the lower 14 data bits and
+## bits [23:22] hold the upper 2 data bits.
+## HI16 encodes target[31:16]; LO16 encodes target[15:0].
+
+	.text
+	.globl	main, target, lo_insn
+	.type	main, at function
+	.p2align	4
+main:
+## HI16: insn[13:0] = target[29:16], insn[23:22] = target[31:30].
+# jitlink-check: (*{4}main)[13:0] = target[29:16]
+# jitlink-check: (*{4}main)[23:22] = target[31:30]
+	{
+		r0.h = #hi(target)
+	}
+## LO16: insn[13:0] = target[13:0], insn[23:22] = target[15:14].
+# jitlink-check: (*{4}lo_insn)[13:0] = target[13:0]
+# jitlink-check: (*{4}lo_insn)[23:22] = target[15:14]
+lo_insn:
+	{
+		r0.l = #lo(target)
+	}
+	{
+		jumpr r31
+	}
+	.size	main, .-main
+
+	.type	target, at function
+	.p2align	4
+target:
+	{
+		r0 = #42
+	}
+	{
+		jumpr r31
+	}
+	.size	target, .-target
diff --git a/llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_minimal.s b/llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_minimal.s
new file mode 100644
index 0000000000000..340643404c407
--- /dev/null
+++ b/llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_minimal.s
@@ -0,0 +1,17 @@
+# RUN: llvm-mc -triple=hexagon-unknown-linux-musl -filetype=obj -o %t.o %s
+# RUN: llvm-jitlink -noexec -slab-address 0x10000 -slab-allocate 64Kb \
+# RUN:   -slab-page-size 4096 -check %s %t.o
+
+## Verify that a minimal Hexagon ELF object links without error and that the
+## instruction data is preserved (no relocations -- just a raw encoding check).
+
+	.text
+	.globl	main
+	.type	main, at function
+	.p2align	4
+main:
+# jitlink-check: *{4}main = 0x529fc000
+	{
+		jumpr r31
+	}
+	.size	main, .-main
diff --git a/llvm/test/ExecutionEngine/JITLink/Hexagon/lit.local.cfg b/llvm/test/ExecutionEngine/JITLink/Hexagon/lit.local.cfg
new file mode 100644
index 0000000000000..3bed54b1a88d2
--- /dev/null
+++ b/llvm/test/ExecutionEngine/JITLink/Hexagon/lit.local.cfg
@@ -0,0 +1,2 @@
+if not "Hexagon" in config.root.targets:
+    config.unsupported = True

>From 467e090ea1688edca095db6b4bd383ed0b2dd83d Mon Sep 17 00:00:00 2001
From: Brian Cain <brian.cain at oss.qualcomm.com>
Date: Tue, 31 Mar 2026 09:51:54 -0700
Subject: [PATCH 2/4] [JITLink][Hexagon] Expand test scope

Add new tests covering remaining relocation types:

  - PLT_B22_PCREL, GD_PLT_B22_PCREL (PLT call variants)
  - GD_PLT_B32_PCREL_X + GD_PLT_B22_PCREL_X (extended GD_PLT)
  - B32_PCREL_X + B15_PCREL_X (extended conditional branch)
  - B32_PCREL_X + B9_PCREL_X  (extended compound/duplex branch)
  - B32_PCREL_X + B7_PCREL_X  (extended hardware loop)
  - B15_PCREL, B13_PCREL, B9_PCREL, B7_PCREL (non-extended branches)
  - Word32_6_X + 6_X/11_X/12_X/9_X/10_X/8_X (extended data ops)
  - B32_PCREL_X + 6_PCREL_X (PC-relative add)
  - 32_PCREL (data PC-relative reference)
---
 .../JITLink/Hexagon/ELF_hexagon_combined.s    | 103 ++++++++++++++++++
 .../JITLink/Hexagon/ELF_hexagon_compound.s    |  39 +++++++
 .../JITLink/Hexagon/ELF_hexagon_cond_branch.s |  40 +++++++
 .../JITLink/Hexagon/ELF_hexagon_duplex.s      |  51 +++++++++
 .../JITLink/Hexagon/ELF_hexagon_loop.s        |  33 ++++++
 .../JITLink/Hexagon/ELF_hexagon_mem_relocs.s  |  88 +++++++++++++++
 .../Hexagon/ELF_hexagon_noext_branch.s        |  55 ++++++++++
 .../JITLink/Hexagon/ELF_hexagon_packet.s      |  59 ++++++++++
 .../JITLink/Hexagon/ELF_hexagon_plt.s         |  43 ++++++++
 9 files changed, 511 insertions(+)
 create mode 100644 llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_combined.s
 create mode 100644 llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_compound.s
 create mode 100644 llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_cond_branch.s
 create mode 100644 llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_duplex.s
 create mode 100644 llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_loop.s
 create mode 100644 llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_mem_relocs.s
 create mode 100644 llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_noext_branch.s
 create mode 100644 llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_packet.s
 create mode 100644 llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_plt.s

diff --git a/llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_combined.s b/llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_combined.s
new file mode 100644
index 0000000000000..d87b766f3e183
--- /dev/null
+++ b/llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_combined.s
@@ -0,0 +1,103 @@
+# RUN: llvm-mc -triple=hexagon-unknown-linux-musl -filetype=obj -o %t.o %s
+# RUN: llvm-jitlink -noexec -slab-address 0x10000 -slab-allocate 64Kb \
+# RUN:   -slab-page-size 4096 -check %s %t.o
+
+## Combined test exercising constant extenders, duplexes, packets, and
+## conditional/compound branches together.  This verifies that the JITLink
+## Hexagon backend handles a realistic mix of relocation types in one object.
+##
+## Relocation types exercised:
+##   - R_HEX_B22_PCREL       (plain call)
+##   - R_HEX_PLT_B22_PCREL   (PLT call)
+##   - R_HEX_B32_PCREL_X     (constant extender for branches)
+##   - R_HEX_B15_PCREL_X     (conditional branch, extended)
+##   - R_HEX_B9_PCREL_X      (compound compare-jump / duplex jump)
+##   - R_HEX_B22_PCREL_X     (extended call)
+##   - R_HEX_32_6_X          (constant extender for data)
+##   - R_HEX_16_X            (extended immediate load)
+##   - R_HEX_8_X             (duplex with extended immediate)
+##   - R_HEX_HI16            (high 16 bits)
+##   - R_HEX_LO16            (low 16 bits)
+
+	.text
+	.globl	main, leaf, helper, plt_call, ext_call, hi_insn, lo_insn
+	.type	main, at function
+	.p2align	4
+main:
+	## Extended immediate load: Word32_6_X extender at main.
+# jitlink-check: (*{4}main)[13:0] = data_val[19:6]
+# jitlink-check: (*{4}main)[27:16] = data_val[31:20]
+	{
+		r0 = ##data_val
+	}
+	## Conditional branch with extender.
+	{
+		if (p0) jump leaf
+	}
+	## Compound compare-and-jump.
+	{
+		p0 = cmp.eq(r0, #0)
+		if (p0.new) jump:t leaf
+	}
+	## PLT-style call: resolved as B22_PCREL.
+# jitlink-check: (*{4}plt_call)[13:1] = (helper - plt_call)[14:2]
+plt_call:
+	{
+		call helper at PLT
+	}
+	## Extended call: B32_PCREL_X + B22_PCREL_X.
+# jitlink-check: (*{4}ext_call)[13:0] = (helper - ext_call)[19:6]
+ext_call:
+	{
+		call ##helper
+	}
+	## HI16/LO16 pair for address construction.
+# jitlink-check: (*{4}hi_insn)[13:0] = data_val[29:16]
+hi_insn:
+	{
+		r2.h = #hi(data_val)
+	}
+# jitlink-check: (*{4}lo_insn)[13:0] = data_val[13:0]
+lo_insn:
+	{
+		r2.l = #lo(data_val)
+	}
+	## Duplex jump (r0 = #0 + jump packs into one duplex word).
+	{
+		r0 = #0
+		jump leaf
+	}
+	.size	main, .-main
+
+	.type	leaf, at function
+	.p2align	4
+leaf:
+	## Duplex with constant extender: Word32_6_X extender.
+# jitlink-check: (*{4}leaf)[13:0] = data_val[19:6]
+	{
+		r0 = add(r0, ##data_val)
+		r1 = #0
+	}
+	{
+		jumpr r31
+	}
+	.size	leaf, .-leaf
+
+	.type	helper, at function
+	.p2align	4
+helper:
+	## Conditional negated branch.
+	{
+		if (!p0) jump leaf
+	}
+	{
+		jumpr r31
+	}
+	.size	helper, .-helper
+
+	.data
+	.globl	data_val
+	.p2align	2
+data_val:
+	.word	0xcafebabe
+	.size	data_val, 4
diff --git a/llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_compound.s b/llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_compound.s
new file mode 100644
index 0000000000000..25d90e2052ad0
--- /dev/null
+++ b/llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_compound.s
@@ -0,0 +1,39 @@
+# RUN: llvm-mc -triple=hexagon-unknown-linux-musl -filetype=obj -o %t.o %s
+# RUN: llvm-jitlink -noexec -slab-address 0x10000 -slab-allocate 64Kb \
+# RUN:   -slab-page-size 4096 -check %s %t.o
+
+## Verify compound compare-and-jump relocation pairs (R_HEX_B32_PCREL_X +
+## R_HEX_B9_PCREL_X).  The compound instruction includes an extender that
+## encodes (target - PC) >> 6.
+
+	.text
+	.globl	main, helper
+	.type	main, at function
+	.p2align	4
+main:
+	## Extender at main: B32_PCREL_X encodes (target - PC) >> 6.
+# jitlink-check: (*{4}main)[13:0] = (helper - main)[19:6]
+# jitlink-check: (*{4}main)[27:16] = (helper - main)[31:20]
+	{
+		p0 = cmp.eq(r0, #0)
+		if (p0.new) jump:t helper
+	}
+	{
+		p0 = cmp.gt(r0, #0)
+		if (!p0.new) jump:t helper
+	}
+	{
+		jumpr r31
+	}
+	.size	main, .-main
+
+	.type	helper, at function
+	.p2align	4
+helper:
+	{
+		r0 = #0
+	}
+	{
+		jumpr r31
+	}
+	.size	helper, .-helper
diff --git a/llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_cond_branch.s b/llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_cond_branch.s
new file mode 100644
index 0000000000000..4bfd9611d67e3
--- /dev/null
+++ b/llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_cond_branch.s
@@ -0,0 +1,40 @@
+# RUN: llvm-mc -triple=hexagon-unknown-linux-musl -filetype=obj -o %t.o %s
+# RUN: llvm-jitlink -noexec -slab-address 0x10000 -slab-allocate 64Kb \
+# RUN:   -slab-page-size 4096 -check %s %t.o
+
+## Verify conditional branch relocation pairs (R_HEX_B32_PCREL_X +
+## R_HEX_B15_PCREL_X).  The assembler always generates extended forms for
+## conditional jumps: immext (B32_PCREL_X) at the label, branch (B15_PCREL_X)
+## at label + 4.
+
+	.text
+	.globl	main, helper
+	.type	main, at function
+	.p2align	4
+main:
+	## Extender: B32_PCREL_X encodes (target - PC) >> 6.
+# jitlink-check: (*{4}main)[13:0] = (helper - main)[19:6]
+# jitlink-check: (*{4}main)[27:16] = (helper - main)[31:20]
+	## Branch: B15_PCREL_X encodes low 6 bits in bits [6:1] (addend +4).
+# jitlink-check: (*{4}(main + 4))[6:1] = (helper - main)[5:0]
+	{
+		if (p0) jump helper
+	}
+	{
+		if (!p0) jump helper
+	}
+	{
+		jumpr r31
+	}
+	.size	main, .-main
+
+	.type	helper, at function
+	.p2align	4
+helper:
+	{
+		r0 = #42
+	}
+	{
+		jumpr r31
+	}
+	.size	helper, .-helper
diff --git a/llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_duplex.s b/llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_duplex.s
new file mode 100644
index 0000000000000..9b0b6b9f3244d
--- /dev/null
+++ b/llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_duplex.s
@@ -0,0 +1,51 @@
+# RUN: llvm-mc -triple=hexagon-unknown-linux-musl -filetype=obj -o %t.o %s
+# RUN: llvm-jitlink -noexec -slab-address 0x10000 -slab-allocate 64Kb \
+# RUN:   -slab-page-size 4096 -check %s %t.o
+
+## Verify relocations targeting duplex-encoded instructions.  Duplex
+## instructions pack two sub-instructions into a single 32-bit word with
+## parse bits [15:14] = 0b00.  The fixup mask lookup functions (findMaskR6,
+## findMaskR8, etc.) have a special isDuplex() path returning mask 0x03f00000.
+##
+## Test 1: { r0 = #0; jump helper } -- duplex jump generates
+##         R_HEX_B32_PCREL_X (extender) + R_HEX_B9_PCREL_X (duplex word).
+##
+## Test 2: { r0 = add(r0, ##data_sym); r1 = #0 } -- duplex with constant
+##         extender generates R_HEX_32_6_X (extender) + R_HEX_8_X (duplex
+##         word), exercising the isDuplex() path in findMaskR8().
+
+	.text
+	.globl	main, helper
+	.type	main, at function
+	.p2align	4
+main:
+	## The extender at main uses B32_PCREL_X (mask 0x0fff3fff).
+# jitlink-check: (*{4}main)[13:0] = (helper - main)[19:6]
+# jitlink-check: (*{4}main)[27:16] = (helper - main)[31:20]
+	{
+		r0 = #0
+		jump helper
+	}
+	.size	main, .-main
+
+	.type	helper, at function
+	.p2align	4
+helper:
+	## The extender at helper uses Word32_6_X (mask 0x0fff3fff).
+# jitlink-check: (*{4}helper)[13:0] = data_sym[19:6]
+# jitlink-check: (*{4}helper)[27:16] = data_sym[31:20]
+	{
+		r0 = add(r0, ##data_sym)
+		r1 = #0
+	}
+	{
+		jumpr r31
+	}
+	.size	helper, .-helper
+
+	.data
+	.globl	data_sym
+	.p2align	2
+data_sym:
+	.word	0xdeadbeef
+	.size	data_sym, 4
diff --git a/llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_loop.s b/llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_loop.s
new file mode 100644
index 0000000000000..c4c8b7634df03
--- /dev/null
+++ b/llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_loop.s
@@ -0,0 +1,33 @@
+# RUN: llvm-mc -triple=hexagon-unknown-linux-musl -filetype=obj -o %t.o %s
+# RUN: llvm-jitlink -noexec -slab-address 0x10000 -slab-allocate 64Kb \
+# RUN:   -slab-page-size 4096 -check %s %t.o
+
+## Verify hardware loop relocation pairs (R_HEX_B32_PCREL_X + R_HEX_B7_PCREL_X).
+## The loop0 instruction uses an extender that encodes (target - PC) >> 6.
+
+	.text
+	.globl	main, loop_body
+	.type	main, at function
+	.p2align	4
+main:
+	## Extender at main: B32_PCREL_X encodes (target - PC) >> 6.
+# jitlink-check: (*{4}main)[13:0] = (loop_body - main)[19:6]
+# jitlink-check: (*{4}main)[27:16] = (loop_body - main)[31:20]
+	{
+		loop0(loop_body, #10)
+	}
+	{
+		jumpr r31
+	}
+	.size	main, .-main
+
+	.type	loop_body, at function
+	.p2align	4
+loop_body:
+	{
+		nop
+	}:endloop0
+	{
+		jumpr r31
+	}
+	.size	loop_body, .-loop_body
diff --git a/llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_mem_relocs.s b/llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_mem_relocs.s
new file mode 100644
index 0000000000000..2f1dd2d937d57
--- /dev/null
+++ b/llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_mem_relocs.s
@@ -0,0 +1,88 @@
+# RUN: llvm-mc -triple=hexagon-unknown-linux-musl -filetype=obj -o %t.o %s
+# RUN: llvm-jitlink -noexec -slab-address 0x10000 -slab-allocate 64Kb \
+# RUN:   -slab-page-size 4096 -check %s %t.o
+
+## Verify memory-operation and data relocations that exercise different
+## fixup mask widths:
+##   - R_HEX_32_6_X + R_HEX_6_X    (memop with extended offset, 6-bit field)
+##   - R_HEX_32_6_X + R_HEX_11_X   (memb load with extended offset, 11-bit field)
+##   - R_HEX_32_6_X + R_HEX_12_X   (conditional transfer, 12-bit field)
+##   - R_HEX_32_6_X + R_HEX_9_X    (unsigned compare, 9-bit field)
+##   - R_HEX_32_6_X + R_HEX_10_X   (signed compare, 10-bit field)
+##   - R_HEX_B32_PCREL_X + R_HEX_6_PCREL_X  (PC-relative add, 6-bit field)
+##   - R_HEX_32_PCREL               (PC-relative data reference)
+##   - R_HEX_GD_PLT_B22_PCREL      (GD_PLT call, mapped to plain branch)
+
+	.text
+	.globl	main, helper, memb_ext, cond_ext, pcrel_ext, gdplt_call
+	.type	main, at function
+	.p2align	4
+main:
+	## Memop with extended offset: generates R_HEX_32_6_X + R_HEX_6_X.
+	## Verify Word32_6_X extender encoding (mask 0x0fff3fff).
+# jitlink-check: (*{4}main)[13:0] = data_val[19:6]
+# jitlink-check: (*{4}main)[27:16] = data_val[31:20]
+	{
+		memw(r0+##data_val) += r1
+	}
+	## Byte load with extended offset: generates R_HEX_32_6_X + R_HEX_11_X.
+# jitlink-check: (*{4}memb_ext)[13:0] = data_val[19:6]
+memb_ext:
+	{
+		r0 = memb(r1+##data_val)
+	}
+	## Conditional transfer: generates R_HEX_32_6_X + R_HEX_12_X.
+# jitlink-check: (*{4}cond_ext)[13:0] = data_val[19:6]
+cond_ext:
+	{
+		if (p0) r0 = ##data_val
+	}
+	## Unsigned compare: generates R_HEX_32_6_X + R_HEX_9_X.
+	{
+		p0 = !cmp.gtu(r0, ##data_val)
+	}
+	## Signed compare: generates R_HEX_32_6_X + R_HEX_10_X.
+	{
+		p0 = !cmp.gt(r0, ##data_val)
+	}
+	## PC-relative add: generates R_HEX_B32_PCREL_X + R_HEX_6_PCREL_X.
+	## Verify B32_PCREL_X extender encoding.
+# jitlink-check: (*{4}pcrel_ext)[13:0] = (data_val - pcrel_ext)[19:6]
+# jitlink-check: (*{4}pcrel_ext)[27:16] = (data_val - pcrel_ext)[31:20]
+pcrel_ext:
+	{
+		r0 = add(pc, ##data_val at PCREL)
+	}
+	## GD_PLT call: resolved as B22_PCREL.
+# jitlink-check: (*{4}gdplt_call)[13:1] = (helper - gdplt_call)[14:2]
+gdplt_call:
+	{
+		call helper at GDPLT
+	}
+	{
+		jumpr r31
+	}
+	.size	main, .-main
+
+	.type	helper, at function
+	.p2align	4
+helper:
+	{
+		jumpr r31
+	}
+	.size	helper, .-helper
+
+	.data
+	.globl	data_val
+	.p2align	2
+data_val:
+	.word	0x42
+	.size	data_val, 4
+
+## PC-relative data reference: generates R_HEX_32_PCREL.
+	.globl	pcrel_ref
+	.p2align	2
+pcrel_ref:
+# jitlink-check: *{4}pcrel_ref = helper - pcrel_ref
+	.word	helper - pcrel_ref
+	.size	pcrel_ref, 4
diff --git a/llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_noext_branch.s b/llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_noext_branch.s
new file mode 100644
index 0000000000000..53218388a741b
--- /dev/null
+++ b/llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_noext_branch.s
@@ -0,0 +1,55 @@
+# RUN: llvm-mc -triple=hexagon-unknown-linux-musl -filetype=obj -o %t.o %s
+# RUN: llvm-jitlink -noexec -slab-address 0x10000 -slab-allocate 64Kb \
+# RUN:   -slab-page-size 4096 -check %s %t.o
+
+## Verify non-extended branch relocations.  Using an explicit '#' prefix on
+## the branch target sets mustNotExtend, preventing assembler relaxation.
+## Each branch type spreads (target - PC) >> 2 into non-contiguous bit fields
+## via applyMask.  We verify the largest contiguous field run for each type.
+
+	.text
+	.globl	main, helper, b13_insn, b9_insn, b7_insn
+	.type	main, at function
+	.p2align	4
+main:
+	## B15_PCREL (mask 0x00df20fe): bits [7:1] hold data[6:0].
+# jitlink-check: (*{4}main)[7:1] = (helper - main)[8:2]
+	{
+		if (p0) jump #helper
+	}
+	## B13_PCREL (mask 0x00202ffe): bits [11:1] hold data[10:0].
+# jitlink-check: (*{4}b13_insn)[11:1] = (helper - b13_insn)[12:2]
+b13_insn:
+	{
+		if (r0 == #0) jump:t #helper
+	}
+	## B9_PCREL (mask 0x003000fe): bits [7:1] hold data[6:0].
+# jitlink-check: (*{4}b9_insn)[7:1] = (helper - b9_insn)[8:2]
+b9_insn:
+	{
+		p0 = cmp.eq(r0, #0)
+		if (p0.new) jump:t #helper
+	}
+	## B7_PCREL (mask 0x00001f18): bits [4:3] hold data[1:0],
+	## bits [12:8] hold data[6:2].
+# jitlink-check: (*{4}b7_insn)[4:3] = (helper - b7_insn)[3:2]
+# jitlink-check: (*{4}b7_insn)[12:8] = (helper - b7_insn)[8:4]
+b7_insn:
+	{
+		loop0(#helper, #10)
+	}
+	{
+		jumpr r31
+	}
+	.size	main, .-main
+
+	.type	helper, at function
+	.p2align	4
+helper:
+	{
+		nop
+	}:endloop0
+	{
+		jumpr r31
+	}
+	.size	helper, .-helper
diff --git a/llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_packet.s b/llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_packet.s
new file mode 100644
index 0000000000000..37bd103c5b5a8
--- /dev/null
+++ b/llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_packet.s
@@ -0,0 +1,59 @@
+# RUN: llvm-mc -triple=hexagon-unknown-linux-musl -filetype=obj -o %t.o %s
+# RUN: llvm-jitlink -noexec -slab-address 0x10000 -slab-allocate 64Kb \
+# RUN:   -slab-page-size 4096 -check %s %t.o
+
+## Verify multi-instruction packets with different relocation types.
+## Exercises R_HEX_32_6_X + R_HEX_16_X, R_HEX_HI16, R_HEX_LO16,
+## and R_HEX_B22_PCREL.
+
+	.text
+	.globl	main, helper, hi_insn, lo_insn, call_insn
+	.type	main, at function
+	.p2align	4
+main:
+	## Extended immediate load: Word32_6_X extender at main.
+# jitlink-check: (*{4}main)[13:0] = data1[19:6]
+# jitlink-check: (*{4}main)[27:16] = data1[31:20]
+	{
+		r0 = ##data1
+	}
+	## HI16: insn[13:0] = data2[29:16].
+# jitlink-check: (*{4}hi_insn)[13:0] = data2[29:16]
+hi_insn:
+	{
+		r1.h = #hi(data2)
+	}
+	## LO16: insn[13:0] = data2[13:0].
+# jitlink-check: (*{4}lo_insn)[13:0] = data2[13:0]
+lo_insn:
+	{
+		r1.l = #lo(data2)
+	}
+	## B22_PCREL call.
+# jitlink-check: (*{4}call_insn)[13:1] = (helper - call_insn)[14:2]
+call_insn:
+	{
+		call helper
+	}
+	{
+		jumpr r31
+	}
+	.size	main, .-main
+
+	.type	helper, at function
+	.p2align	4
+helper:
+	{
+		jumpr r31
+	}
+	.size	helper, .-helper
+
+	.data
+	.globl	data1, data2
+	.p2align	2
+data1:
+	.word	0x11111111
+	.size	data1, 4
+data2:
+	.word	0x22222222
+	.size	data2, 4
diff --git a/llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_plt.s b/llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_plt.s
new file mode 100644
index 0000000000000..901ab56a32297
--- /dev/null
+++ b/llvm/test/ExecutionEngine/JITLink/Hexagon/ELF_hexagon_plt.s
@@ -0,0 +1,43 @@
+# RUN: llvm-mc -triple=hexagon-unknown-linux-musl -filetype=obj -o %t.o %s
+# RUN: llvm-jitlink -noexec -slab-address 0x10000 -slab-allocate 64Kb \
+# RUN:   -slab-page-size 4096 -check %s %t.o
+
+## Verify that PLT-style relocations link correctly.  JITLink resolves all
+## symbols directly, so PLT and GD_PLT variants are mapped to plain branch
+## edges.  This test covers:
+##   - R_HEX_PLT_B22_PCREL (call @PLT)
+##   - R_HEX_GD_PLT_B32_PCREL_X + R_HEX_GD_PLT_B22_PCREL_X (call ##@GDPLT)
+
+	.text
+	.globl	main, helper, gdplt_call
+	.type	main, at function
+	.p2align	4
+main:
+	## PLT call: resolved as B22_PCREL (mask 0x01ff3ffe).
+# jitlink-check: (*{4}main)[13:1] = (helper - main)[14:2]
+# jitlink-check: (*{4}main)[24:16] = (helper - main)[23:15]
+	{
+		call helper at PLT
+	}
+	## Extended GD_PLT call: resolved as B32_PCREL_X + B22_PCREL_X.
+# jitlink-check: (*{4}gdplt_call)[13:0] = (helper - gdplt_call)[19:6]
+# jitlink-check: (*{4}gdplt_call)[27:16] = (helper - gdplt_call)[31:20]
+gdplt_call:
+	{
+		call ##helper at GDPLT
+	}
+	{
+		jumpr r31
+	}
+	.size	main, .-main
+
+	.type	helper, at function
+	.p2align	4
+helper:
+	{
+		r0 = #0
+	}
+	{
+		jumpr r31
+	}
+	.size	helper, .-helper

>From df179778c5288d6c976964ebfbac315910f1f220 Mon Sep 17 00:00:00 2001
From: Brian Cain <brian.cain at oss.qualcomm.com>
Date: Tue, 31 Mar 2026 11:19:44 -0700
Subject: [PATCH 3/4] fixup! [JITLink] Add Hexagon ELF backend

fixup! [JITLink] Add Hexagon ELF backend

Add missing #include for utohexstr.
---
 llvm/lib/ExecutionEngine/JITLink/hexagon.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/llvm/lib/ExecutionEngine/JITLink/hexagon.cpp b/llvm/lib/ExecutionEngine/JITLink/hexagon.cpp
index 8cc37e38297f6..409e286c312d8 100644
--- a/llvm/lib/ExecutionEngine/JITLink/hexagon.cpp
+++ b/llvm/lib/ExecutionEngine/JITLink/hexagon.cpp
@@ -11,6 +11,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ExecutionEngine/JITLink/hexagon.h"
+#include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/Endian.h"
 
 #define DEBUG_TYPE "jitlink"

>From 4f8612a73796eb73e2f8217b598b4ceb884acef6 Mon Sep 17 00:00:00 2001
From: Brian Cain <brian.cain at oss.qualcomm.com>
Date: Tue, 7 Apr 2026 06:32:43 -0700
Subject: [PATCH 4/4] fixup! [JITLink] Add Hexagon ELF backend

- Move applyFixup() and mask-lookup helpers inline into hexagon.h
  (this function is typically very hot during linking).
- Update PLT relocation comments to reference the GOT/PLT stubs TODO.
---
 .../llvm/ExecutionEngine/JITLink/hexagon.h    | 237 ++++++++++++++++-
 .../ExecutionEngine/JITLink/ELF_hexagon.cpp   |  11 +-
 llvm/lib/ExecutionEngine/JITLink/hexagon.cpp  | 246 +-----------------
 3 files changed, 244 insertions(+), 250 deletions(-)

diff --git a/llvm/include/llvm/ExecutionEngine/JITLink/hexagon.h b/llvm/include/llvm/ExecutionEngine/JITLink/hexagon.h
index a9960832836a0..713d76653c2ed 100644
--- a/llvm/include/llvm/ExecutionEngine/JITLink/hexagon.h
+++ b/llvm/include/llvm/ExecutionEngine/JITLink/hexagon.h
@@ -13,6 +13,7 @@
 #ifndef LLVM_EXECUTIONENGINE_JITLINK_HEXAGON_H
 #define LLVM_EXECUTIONENGINE_JITLINK_HEXAGON_H
 
+#include "llvm/ADT/StringExtras.h"
 #include "llvm/ExecutionEngine/JITLink/JITLink.h"
 #include "llvm/Support/Compiler.h"
 
@@ -148,8 +149,242 @@ constexpr uint32_t applyMask(uint32_t Mask, uint32_t Data) {
   return Result;
 }
 
+/// Instruction mask entry for R_HEX_6_X / R_HEX_16_X lookup.
+struct InstructionMask {
+  uint32_t CmpMask;
+  uint32_t RelocMask;
+};
+
+/// Mask table for R_HEX_6_X relocations, indexed by instruction class.
+inline constexpr InstructionMask R6Masks[] = {
+    {0x38000000, 0x0000201f}, {0x39000000, 0x0000201f},
+    {0x3e000000, 0x00001f80}, {0x3f000000, 0x00001f80},
+    {0x40000000, 0x000020f8}, {0x41000000, 0x000007e0},
+    {0x42000000, 0x000020f8}, {0x43000000, 0x000007e0},
+    {0x44000000, 0x000020f8}, {0x45000000, 0x000007e0},
+    {0x46000000, 0x000020f8}, {0x47000000, 0x000007e0},
+    {0x6a000000, 0x00001f80}, {0x7c000000, 0x001f2000},
+    {0x9a000000, 0x00000f60}, {0x9b000000, 0x00000f60},
+    {0x9c000000, 0x00000f60}, {0x9d000000, 0x00000f60},
+    {0x9f000000, 0x001f0100}, {0xab000000, 0x0000003f},
+    {0xad000000, 0x0000003f}, {0xaf000000, 0x00030078},
+    {0xd7000000, 0x006020e0}, {0xd8000000, 0x006020e0},
+    {0xdb000000, 0x006020e0}, {0xdf000000, 0x006020e0}};
+
+inline constexpr uint32_t InstParsePacketEnd = 0x0000c000;
+
+inline bool isDuplex(uint32_t Insn) { return (InstParsePacketEnd & Insn) == 0; }
+
+inline Expected<uint32_t> findMaskR6(uint32_t Insn) {
+  if (isDuplex(Insn))
+    return 0x03f00000;
+  for (auto &I : R6Masks)
+    if ((0xff000000 & Insn) == I.CmpMask)
+      return I.RelocMask;
+  return make_error<JITLinkError>("unrecognized instruction for R_HEX_6_X "
+                                  "relocation: 0x" +
+                                  utohexstr(Insn));
+}
+
+inline Expected<uint32_t> findMaskR8(uint32_t Insn) {
+  if (isDuplex(Insn))
+    return 0x03f00000;
+  if ((0xff000000 & Insn) == 0xde000000)
+    return 0x00e020e8;
+  if ((0xff000000 & Insn) == 0x3c000000)
+    return 0x0000207f;
+  return 0x00001fe0;
+}
+
+inline Expected<uint32_t> findMaskR11(uint32_t Insn) {
+  if (isDuplex(Insn))
+    return 0x03f00000;
+  if ((0xff000000 & Insn) == 0xa1000000)
+    return 0x060020ff;
+  return 0x06003fe0;
+}
+
+inline Expected<uint32_t> findMaskR16(uint32_t Insn) {
+  if (isDuplex(Insn))
+    return 0x03f00000;
+  Insn = Insn & ~InstParsePacketEnd;
+  if ((0xff000000 & Insn) == 0x48000000)
+    return 0x061f20ff;
+  if ((0xff000000 & Insn) == 0x49000000)
+    return 0x061f3fe0;
+  if ((0xff000000 & Insn) == 0x78000000)
+    return 0x00df3fe0;
+  if ((0xff000000 & Insn) == 0xb0000000)
+    return 0x0fe03fe0;
+  if ((0xff802000 & Insn) == 0x74000000)
+    return 0x00001fe0;
+  if ((0xff802000 & Insn) == 0x74002000)
+    return 0x00001fe0;
+  if ((0xff802000 & Insn) == 0x74800000)
+    return 0x00001fe0;
+  if ((0xff802000 & Insn) == 0x74802000)
+    return 0x00001fe0;
+  for (auto &I : R6Masks)
+    if ((0xff000000 & Insn) == I.CmpMask)
+      return I.RelocMask;
+  return make_error<JITLinkError>("unrecognized instruction for R_HEX_16_X "
+                                  "relocation: 0x" +
+                                  utohexstr(Insn));
+}
+
 /// Apply fixup expression for edge to block content.
-LLVM_ABI Error applyFixup(LinkGraph &G, Block &B, const Edge &E);
+inline Error applyFixup(LinkGraph &G, Block &B, const Edge &E) {
+  using namespace llvm::support;
+
+  char *BlockWorkingMem = B.getAlreadyMutableContent().data();
+  char *FixupPtr = BlockWorkingMem + E.getOffset();
+  auto FixupAddress = B.getAddress() + E.getOffset();
+
+  int64_t TargetAddr = E.getTarget().getAddress().getValue() + E.getAddend();
+  int64_t PCRelVal = E.getTarget().getAddress().getValue() -
+                     FixupAddress.getValue() + E.getAddend();
+
+  auto or32le = [](char *P, uint32_t V) {
+    endian::write32le(P, endian::read32le(P) | V);
+  };
+
+  uint32_t Insn = endian::read32le(FixupPtr);
+
+  switch (E.getKind()) {
+  case Pointer32:
+    endian::write32le(FixupPtr, static_cast<uint32_t>(TargetAddr));
+    break;
+
+  case PCRel32:
+    endian::write32le(FixupPtr, static_cast<uint32_t>(PCRelVal));
+    break;
+
+  case B22_PCREL:
+    if (!isInt<24>(PCRelVal))
+      return makeTargetOutOfRangeError(G, B, E);
+    or32le(FixupPtr, applyMask(0x01ff3ffe, PCRelVal >> 2));
+    break;
+
+  case B15_PCREL:
+    if (!isInt<17>(PCRelVal))
+      return makeTargetOutOfRangeError(G, B, E);
+    or32le(FixupPtr, applyMask(0x00df20fe, PCRelVal >> 2));
+    break;
+
+  case B13_PCREL:
+    if (!isInt<15>(PCRelVal))
+      return makeTargetOutOfRangeError(G, B, E);
+    or32le(FixupPtr, applyMask(0x00202ffe, PCRelVal >> 2));
+    break;
+
+  case B9_PCREL:
+    if (!isInt<11>(PCRelVal))
+      return makeTargetOutOfRangeError(G, B, E);
+    or32le(FixupPtr, applyMask(0x003000fe, PCRelVal >> 2));
+    break;
+
+  case B7_PCREL:
+    if (!isInt<9>(PCRelVal))
+      return makeTargetOutOfRangeError(G, B, E);
+    or32le(FixupPtr, applyMask(0x00001f18, PCRelVal >> 2));
+    break;
+
+  case HI16:
+    or32le(FixupPtr, applyMask(0x00c03fff, TargetAddr >> 16));
+    break;
+
+  case LO16:
+    or32le(FixupPtr, applyMask(0x00c03fff, TargetAddr));
+    break;
+
+  case Word32_6_X:
+    or32le(FixupPtr, applyMask(0x0fff3fff, TargetAddr >> 6));
+    break;
+
+  case B32_PCREL_X:
+    or32le(FixupPtr, applyMask(0x0fff3fff, PCRelVal >> 6));
+    break;
+
+  case B22_PCREL_X:
+    or32le(FixupPtr, applyMask(0x01ff3ffe, PCRelVal & 0x3f));
+    break;
+
+  case B15_PCREL_X:
+    or32le(FixupPtr, applyMask(0x00df20fe, PCRelVal & 0x3f));
+    break;
+
+  case B13_PCREL_X:
+    or32le(FixupPtr, applyMask(0x00202ffe, PCRelVal & 0x3f));
+    break;
+
+  case B9_PCREL_X:
+    or32le(FixupPtr, applyMask(0x003000fe, PCRelVal & 0x3f));
+    break;
+
+  case B7_PCREL_X:
+    or32le(FixupPtr, applyMask(0x00001f18, PCRelVal & 0x3f));
+    break;
+
+  case Word6_X: {
+    auto Mask = findMaskR6(Insn);
+    if (!Mask)
+      return Mask.takeError();
+    or32le(FixupPtr, applyMask(*Mask, TargetAddr));
+    break;
+  }
+
+  case Word6_PCREL_X: {
+    auto Mask = findMaskR6(Insn);
+    if (!Mask)
+      return Mask.takeError();
+    or32le(FixupPtr, applyMask(*Mask, PCRelVal));
+    break;
+  }
+
+  case Word8_X: {
+    auto Mask = findMaskR8(Insn);
+    if (!Mask)
+      return Mask.takeError();
+    or32le(FixupPtr, applyMask(*Mask, TargetAddr));
+    break;
+  }
+
+  case Word9_X:
+    or32le(FixupPtr, applyMask(0x00003fe0, TargetAddr & 0x3f));
+    break;
+
+  case Word10_X:
+    or32le(FixupPtr, applyMask(0x00203fe0, TargetAddr & 0x3f));
+    break;
+
+  case Word11_X: {
+    auto Mask = findMaskR11(Insn);
+    if (!Mask)
+      return Mask.takeError();
+    or32le(FixupPtr, applyMask(*Mask, TargetAddr & 0x3f));
+    break;
+  }
+
+  case Word12_X:
+    or32le(FixupPtr, applyMask(0x000007e0, TargetAddr));
+    break;
+
+  case Word16_X: {
+    auto Mask = findMaskR16(Insn);
+    if (!Mask)
+      return Mask.takeError();
+    or32le(FixupPtr, applyMask(*Mask, TargetAddr & 0x3f));
+    break;
+  }
+
+  default:
+    return make_error<JITLinkError>(
+        "In graph " + G.getName() + ", section " + B.getSection().getName() +
+        " unsupported Hexagon edge kind " + getEdgeKindName(E.getKind()));
+  }
+
+  return Error::success();
+}
 
 } // namespace llvm::jitlink::hexagon
 
diff --git a/llvm/lib/ExecutionEngine/JITLink/ELF_hexagon.cpp b/llvm/lib/ExecutionEngine/JITLink/ELF_hexagon.cpp
index a19acf324f9e8..18949b492bfbd 100644
--- a/llvm/lib/ExecutionEngine/JITLink/ELF_hexagon.cpp
+++ b/llvm/lib/ExecutionEngine/JITLink/ELF_hexagon.cpp
@@ -52,8 +52,11 @@ class ELFLinkGraphBuilder_hexagon
       return hexagon::PCRel32;
     case ELF::R_HEX_B22_PCREL:
     case ELF::R_HEX_PLT_B22_PCREL:
-    // GD_PLT variants are mapped to plain branch edges since JITLink resolves
-    // all symbols directly. This does not handle TLS __tls_get_addr calls.
+    // PLT and GD_PLT variants are mapped to plain branch edges since JITLink
+    // resolves all symbols directly within contiguous JIT memory. When the
+    // GOT/PLT stubs builder is added (see TODO in link_ELF_hexagon), these
+    // should map to a distinct edge kind that triggers stub generation.
+    // GD_PLT does not handle TLS __tls_get_addr calls.
     case ELF::R_HEX_GD_PLT_B22_PCREL:
       return hexagon::B22_PCREL;
     case ELF::R_HEX_B15_PCREL:
@@ -71,10 +74,10 @@ class ELFLinkGraphBuilder_hexagon
     case ELF::R_HEX_32_6_X:
       return hexagon::Word32_6_X;
     case ELF::R_HEX_B32_PCREL_X:
-    case ELF::R_HEX_GD_PLT_B32_PCREL_X: // See GD_PLT note above.
+    case ELF::R_HEX_GD_PLT_B32_PCREL_X: // See PLT/GD_PLT note above.
       return hexagon::B32_PCREL_X;
     case ELF::R_HEX_B22_PCREL_X:
-    case ELF::R_HEX_GD_PLT_B22_PCREL_X: // See GD_PLT note above.
+    case ELF::R_HEX_GD_PLT_B22_PCREL_X: // See PLT/GD_PLT note above.
       return hexagon::B22_PCREL_X;
     case ELF::R_HEX_B15_PCREL_X:
       return hexagon::B15_PCREL_X;
diff --git a/llvm/lib/ExecutionEngine/JITLink/hexagon.cpp b/llvm/lib/ExecutionEngine/JITLink/hexagon.cpp
index 409e286c312d8..29edb94cbac32 100644
--- a/llvm/lib/ExecutionEngine/JITLink/hexagon.cpp
+++ b/llvm/lib/ExecutionEngine/JITLink/hexagon.cpp
@@ -6,105 +6,14 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// Hexagon edge kind names and fixup application.
+// Hexagon edge kind names.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ExecutionEngine/JITLink/hexagon.h"
-#include "llvm/ADT/StringExtras.h"
-#include "llvm/Support/Endian.h"
 
 #define DEBUG_TYPE "jitlink"
 
-using namespace llvm;
-using namespace llvm::jitlink;
-
-namespace {
-
-// Instruction mask tables for R_HEX_6_X.
-struct InstructionMask {
-  uint32_t CmpMask;
-  uint32_t RelocMask;
-};
-
-static const InstructionMask R6Masks[] = {
-    {0x38000000, 0x0000201f}, {0x39000000, 0x0000201f},
-    {0x3e000000, 0x00001f80}, {0x3f000000, 0x00001f80},
-    {0x40000000, 0x000020f8}, {0x41000000, 0x000007e0},
-    {0x42000000, 0x000020f8}, {0x43000000, 0x000007e0},
-    {0x44000000, 0x000020f8}, {0x45000000, 0x000007e0},
-    {0x46000000, 0x000020f8}, {0x47000000, 0x000007e0},
-    {0x6a000000, 0x00001f80}, {0x7c000000, 0x001f2000},
-    {0x9a000000, 0x00000f60}, {0x9b000000, 0x00000f60},
-    {0x9c000000, 0x00000f60}, {0x9d000000, 0x00000f60},
-    {0x9f000000, 0x001f0100}, {0xab000000, 0x0000003f},
-    {0xad000000, 0x0000003f}, {0xaf000000, 0x00030078},
-    {0xd7000000, 0x006020e0}, {0xd8000000, 0x006020e0},
-    {0xdb000000, 0x006020e0}, {0xdf000000, 0x006020e0}};
-
-constexpr uint32_t InstParsePacketEnd = 0x0000c000;
-
-bool isDuplex(uint32_t Insn) { return (InstParsePacketEnd & Insn) == 0; }
-
-Expected<uint32_t> findMaskR6(uint32_t Insn) {
-  if (isDuplex(Insn))
-    return 0x03f00000;
-  for (auto &I : R6Masks)
-    if ((0xff000000 & Insn) == I.CmpMask)
-      return I.RelocMask;
-  return make_error<JITLinkError>("unrecognized instruction for R_HEX_6_X "
-                                  "relocation: 0x" +
-                                  utohexstr(Insn));
-}
-
-Expected<uint32_t> findMaskR8(uint32_t Insn) {
-  if (isDuplex(Insn))
-    return 0x03f00000;
-  if ((0xff000000 & Insn) == 0xde000000)
-    return 0x00e020e8;
-  if ((0xff000000 & Insn) == 0x3c000000)
-    return 0x0000207f;
-  return 0x00001fe0;
-}
-
-Expected<uint32_t> findMaskR11(uint32_t Insn) {
-  if (isDuplex(Insn))
-    return 0x03f00000;
-  if ((0xff000000 & Insn) == 0xa1000000)
-    return 0x060020ff;
-  return 0x06003fe0;
-}
-
-Expected<uint32_t> findMaskR16(uint32_t Insn) {
-  if (isDuplex(Insn))
-    return 0x03f00000;
-  Insn = Insn & ~InstParsePacketEnd;
-  if ((0xff000000 & Insn) == 0x48000000)
-    return 0x061f20ff;
-  if ((0xff000000 & Insn) == 0x49000000)
-    return 0x061f3fe0;
-  if ((0xff000000 & Insn) == 0x78000000)
-    return 0x00df3fe0;
-  if ((0xff000000 & Insn) == 0xb0000000)
-    return 0x0fe03fe0;
-  if ((0xff802000 & Insn) == 0x74000000)
-    return 0x00001fe0;
-  if ((0xff802000 & Insn) == 0x74002000)
-    return 0x00001fe0;
-  if ((0xff802000 & Insn) == 0x74800000)
-    return 0x00001fe0;
-  if ((0xff802000 & Insn) == 0x74802000)
-    return 0x00001fe0;
-  for (auto &I : R6Masks)
-    if ((0xff000000 & Insn) == I.CmpMask)
-      return I.RelocMask;
-  return make_error<JITLinkError>("unrecognized instruction for R_HEX_16_X "
-                                  "relocation: 0x" +
-                                  utohexstr(Insn));
-}
-
-} // anonymous namespace
-
 namespace llvm::jitlink::hexagon {
 
 const char *getEdgeKindName(Edge::Kind K) {
@@ -162,157 +71,4 @@ const char *getEdgeKindName(Edge::Kind K) {
   }
 }
 
-Error applyFixup(LinkGraph &G, Block &B, const Edge &E) {
-  using namespace llvm::support;
-
-  char *BlockWorkingMem = B.getAlreadyMutableContent().data();
-  char *FixupPtr = BlockWorkingMem + E.getOffset();
-  auto FixupAddress = B.getAddress() + E.getOffset();
-
-  int64_t TargetAddr = E.getTarget().getAddress().getValue() + E.getAddend();
-  int64_t PCRelVal = E.getTarget().getAddress().getValue() -
-                     FixupAddress.getValue() + E.getAddend();
-
-  auto or32le = [](char *P, uint32_t V) {
-    endian::write32le(P, endian::read32le(P) | V);
-  };
-
-  uint32_t Insn = endian::read32le(FixupPtr);
-
-  switch (E.getKind()) {
-  case Pointer32:
-    endian::write32le(FixupPtr, static_cast<uint32_t>(TargetAddr));
-    break;
-
-  case PCRel32:
-    endian::write32le(FixupPtr, static_cast<uint32_t>(PCRelVal));
-    break;
-
-  case B22_PCREL:
-    if (!isInt<24>(PCRelVal))
-      return makeTargetOutOfRangeError(G, B, E);
-    or32le(FixupPtr, applyMask(0x01ff3ffe, PCRelVal >> 2));
-    break;
-
-  case B15_PCREL:
-    if (!isInt<17>(PCRelVal))
-      return makeTargetOutOfRangeError(G, B, E);
-    or32le(FixupPtr, applyMask(0x00df20fe, PCRelVal >> 2));
-    break;
-
-  case B13_PCREL:
-    if (!isInt<15>(PCRelVal))
-      return makeTargetOutOfRangeError(G, B, E);
-    or32le(FixupPtr, applyMask(0x00202ffe, PCRelVal >> 2));
-    break;
-
-  case B9_PCREL:
-    if (!isInt<11>(PCRelVal))
-      return makeTargetOutOfRangeError(G, B, E);
-    or32le(FixupPtr, applyMask(0x003000fe, PCRelVal >> 2));
-    break;
-
-  case B7_PCREL:
-    if (!isInt<9>(PCRelVal))
-      return makeTargetOutOfRangeError(G, B, E);
-    or32le(FixupPtr, applyMask(0x00001f18, PCRelVal >> 2));
-    break;
-
-  case HI16:
-    or32le(FixupPtr, applyMask(0x00c03fff, TargetAddr >> 16));
-    break;
-
-  case LO16:
-    or32le(FixupPtr, applyMask(0x00c03fff, TargetAddr));
-    break;
-
-  case Word32_6_X:
-    or32le(FixupPtr, applyMask(0x0fff3fff, TargetAddr >> 6));
-    break;
-
-  case B32_PCREL_X:
-    or32le(FixupPtr, applyMask(0x0fff3fff, PCRelVal >> 6));
-    break;
-
-  case B22_PCREL_X:
-    or32le(FixupPtr, applyMask(0x01ff3ffe, PCRelVal & 0x3f));
-    break;
-
-  case B15_PCREL_X:
-    or32le(FixupPtr, applyMask(0x00df20fe, PCRelVal & 0x3f));
-    break;
-
-  case B13_PCREL_X:
-    or32le(FixupPtr, applyMask(0x00202ffe, PCRelVal & 0x3f));
-    break;
-
-  case B9_PCREL_X:
-    or32le(FixupPtr, applyMask(0x003000fe, PCRelVal & 0x3f));
-    break;
-
-  case B7_PCREL_X:
-    or32le(FixupPtr, applyMask(0x00001f18, PCRelVal & 0x3f));
-    break;
-
-  case Word6_X: {
-    auto Mask = findMaskR6(Insn);
-    if (!Mask)
-      return Mask.takeError();
-    or32le(FixupPtr, applyMask(*Mask, TargetAddr));
-    break;
-  }
-
-  case Word6_PCREL_X: {
-    auto Mask = findMaskR6(Insn);
-    if (!Mask)
-      return Mask.takeError();
-    or32le(FixupPtr, applyMask(*Mask, PCRelVal));
-    break;
-  }
-
-  case Word8_X: {
-    auto Mask = findMaskR8(Insn);
-    if (!Mask)
-      return Mask.takeError();
-    or32le(FixupPtr, applyMask(*Mask, TargetAddr));
-    break;
-  }
-
-  case Word9_X:
-    or32le(FixupPtr, applyMask(0x00003fe0, TargetAddr & 0x3f));
-    break;
-
-  case Word10_X:
-    or32le(FixupPtr, applyMask(0x00203fe0, TargetAddr & 0x3f));
-    break;
-
-  case Word11_X: {
-    auto Mask = findMaskR11(Insn);
-    if (!Mask)
-      return Mask.takeError();
-    or32le(FixupPtr, applyMask(*Mask, TargetAddr & 0x3f));
-    break;
-  }
-
-  case Word12_X:
-    or32le(FixupPtr, applyMask(0x000007e0, TargetAddr));
-    break;
-
-  case Word16_X: {
-    auto Mask = findMaskR16(Insn);
-    if (!Mask)
-      return Mask.takeError();
-    or32le(FixupPtr, applyMask(*Mask, TargetAddr & 0x3f));
-    break;
-  }
-
-  default:
-    return make_error<JITLinkError>(
-        "In graph " + G.getName() + ", section " + B.getSection().getName() +
-        " unsupported Hexagon edge kind " + getEdgeKindName(E.getKind()));
-  }
-
-  return Error::success();
-}
-
 } // namespace llvm::jitlink::hexagon



More information about the llvm-commits mailing list