[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