1//===-------------- ELF.cpp - JIT linker function for ELF -------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// ELF jit-link function.
10//
11//===----------------------------------------------------------------------===//
12
13#include "llvm/ExecutionEngine/JITLink/ELF.h"
14
15#include "llvm/BinaryFormat/ELF.h"
16#include "llvm/ExecutionEngine/JITLink/ELF_aarch32.h"
17#include "llvm/ExecutionEngine/JITLink/ELF_aarch64.h"
18#include "llvm/ExecutionEngine/JITLink/ELF_hexagon.h"
19#include "llvm/ExecutionEngine/JITLink/ELF_loongarch.h"
20#include "llvm/ExecutionEngine/JITLink/ELF_mips.h"
21#include "llvm/ExecutionEngine/JITLink/ELF_ppc64.h"
22#include "llvm/ExecutionEngine/JITLink/ELF_riscv.h"
23#include "llvm/ExecutionEngine/JITLink/ELF_systemz.h"
24#include "llvm/ExecutionEngine/JITLink/ELF_x86.h"
25#include "llvm/ExecutionEngine/JITLink/ELF_x86_64.h"
26#include "llvm/Object/ELF.h"
27#include <cstring>
28
29using namespace llvm;
30
31#define DEBUG_TYPE "jitlink"
32
33namespace llvm {
34namespace jitlink {
35
36Expected<uint16_t> readTargetMachineArch(StringRef Buffer) {
37 const char *Data = Buffer.data();
38
39 if (Data[ELF::EI_DATA] == ELF::ELFDATA2LSB) {
40 if (Data[ELF::EI_CLASS] == ELF::ELFCLASS64) {
41 if (auto File = llvm::object::ELF64LEFile::create(Object: Buffer)) {
42 return File->getHeader().e_machine;
43 } else {
44 return File.takeError();
45 }
46 } else if (Data[ELF::EI_CLASS] == ELF::ELFCLASS32) {
47 if (auto File = llvm::object::ELF32LEFile::create(Object: Buffer)) {
48 return File->getHeader().e_machine;
49 } else {
50 return File.takeError();
51 }
52 }
53 }
54
55 if (Data[ELF::EI_DATA] == ELF::ELFDATA2MSB) {
56 if (Data[ELF::EI_CLASS] == ELF::ELFCLASS64) {
57 if (auto File = llvm::object::ELF64BEFile::create(Object: Buffer)) {
58 return File->getHeader().e_machine;
59 } else {
60 return File.takeError();
61 }
62 } else if (Data[ELF::EI_CLASS] == ELF::ELFCLASS32) {
63 if (auto File = llvm::object::ELF32BEFile::create(Object: Buffer)) {
64 return File->getHeader().e_machine;
65 } else {
66 return File.takeError();
67 }
68 }
69 }
70
71 return ELF::EM_NONE;
72}
73
74Expected<std::unique_ptr<LinkGraph>>
75createLinkGraphFromELFObject(MemoryBufferRef ObjectBuffer,
76 std::shared_ptr<orc::SymbolStringPool> SSP) {
77 StringRef Buffer = ObjectBuffer.getBuffer();
78 if (Buffer.size() < ELF::EI_NIDENT)
79 return make_error<JITLinkError>(Args: "Truncated ELF buffer");
80
81 if (memcmp(s1: Buffer.data(), s2: ELF::ElfMagic, n: strlen(s: ELF::ElfMagic)) != 0)
82 return make_error<JITLinkError>(Args: "ELF magic not valid");
83
84 uint8_t DataEncoding = Buffer.data()[ELF::EI_DATA];
85 Expected<uint16_t> TargetMachineArch = readTargetMachineArch(Buffer);
86 if (!TargetMachineArch)
87 return TargetMachineArch.takeError();
88
89 switch (*TargetMachineArch) {
90 case ELF::EM_AARCH64: {
91 if (DataEncoding == ELF::ELFDATA2LSB)
92 return createLinkGraphFromELFObject_aarch64(ObjectBuffer, SSP: std::move(SSP));
93 else
94 return createLinkGraphFromELFObject_aarch64_be(ObjectBuffer,
95 SSP: std::move(SSP));
96 }
97 case ELF::EM_ARM:
98 return createLinkGraphFromELFObject_aarch32(ObjectBuffer, SSP: std::move(SSP));
99 case ELF::EM_HEXAGON:
100 return createLinkGraphFromELFObject_hexagon(ObjectBuffer, SSP: std::move(SSP));
101 case ELF::EM_PPC64: {
102 if (DataEncoding == ELF::ELFDATA2LSB)
103 return createLinkGraphFromELFObject_ppc64le(ObjectBuffer, SSP: std::move(SSP));
104 else
105 return createLinkGraphFromELFObject_ppc64(ObjectBuffer, SSP: std::move(SSP));
106 }
107 case ELF::EM_LOONGARCH:
108 return createLinkGraphFromELFObject_loongarch(ObjectBuffer, SSP: std::move(SSP));
109 case ELF::EM_MIPS:
110 return createLinkGraphFromELFObject_mips(ObjectBuffer, SSP: std::move(SSP));
111 case ELF::EM_RISCV:
112 return createLinkGraphFromELFObject_riscv(ObjectBuffer, SSP: std::move(SSP));
113 case ELF::EM_S390:
114 return createLinkGraphFromELFObject_systemz(ObjectBuffer, SSP: std::move(SSP));
115 case ELF::EM_X86_64:
116 return createLinkGraphFromELFObject_x86_64(ObjectBuffer, SSP: std::move(SSP));
117 case ELF::EM_386:
118 return createLinkGraphFromELFObject_x86(ObjectBuffer, SSP: std::move(SSP));
119 default:
120 return make_error<JITLinkError>(
121 Args: "Unsupported target machine architecture in ELF object " +
122 ObjectBuffer.getBufferIdentifier());
123 }
124}
125
126void link_ELF(std::unique_ptr<LinkGraph> G,
127 std::unique_ptr<JITLinkContext> Ctx) {
128 switch (G->getTargetTriple().getArch()) {
129 case Triple::aarch64:
130 link_ELF_aarch64(G: std::move(G), Ctx: std::move(Ctx));
131 return;
132 case Triple::aarch64_be:
133 link_ELF_aarch64_be(G: std::move(G), Ctx: std::move(Ctx));
134 return;
135 case Triple::arm:
136 case Triple::armeb:
137 case Triple::thumb:
138 case Triple::thumbeb:
139 link_ELF_aarch32(G: std::move(G), Ctx: std::move(Ctx));
140 return;
141 case Triple::hexagon:
142 link_ELF_hexagon(G: std::move(G), Ctx: std::move(Ctx));
143 return;
144 case Triple::loongarch32:
145 case Triple::loongarch64:
146 link_ELF_loongarch(G: std::move(G), Ctx: std::move(Ctx));
147 return;
148 case Triple::mips:
149 case Triple::mipsel:
150 case Triple::mips64:
151 case Triple::mips64el:
152 link_ELF_mips(G: std::move(G), Ctx: std::move(Ctx));
153 return;
154 case Triple::ppc64:
155 link_ELF_ppc64(G: std::move(G), Ctx: std::move(Ctx));
156 return;
157 case Triple::ppc64le:
158 link_ELF_ppc64le(G: std::move(G), Ctx: std::move(Ctx));
159 return;
160 case Triple::riscv32:
161 case Triple::riscv64:
162 link_ELF_riscv(G: std::move(G), Ctx: std::move(Ctx));
163 return;
164 case Triple::systemz:
165 link_ELF_systemz(G: std::move(G), Ctx: std::move(Ctx));
166 return;
167 case Triple::x86_64:
168 link_ELF_x86_64(G: std::move(G), Ctx: std::move(Ctx));
169 return;
170 case Triple::x86:
171 link_ELF_x86(G: std::move(G), Ctx: std::move(Ctx));
172 return;
173 default:
174 Ctx->notifyFailed(Err: make_error<JITLinkError>(
175 Args: "Unsupported target machine architecture in ELF link graph " +
176 G->getName()));
177 return;
178 }
179}
180
181} // end namespace jitlink
182} // end namespace llvm
183