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_ppc64.h"
21#include "llvm/ExecutionEngine/JITLink/ELF_riscv.h"
22#include "llvm/ExecutionEngine/JITLink/ELF_systemz.h"
23#include "llvm/ExecutionEngine/JITLink/ELF_x86.h"
24#include "llvm/ExecutionEngine/JITLink/ELF_x86_64.h"
25#include "llvm/Object/ELF.h"
26#include <cstring>
27
28using namespace llvm;
29
30#define DEBUG_TYPE "jitlink"
31
32namespace llvm {
33namespace jitlink {
34
35Expected<uint16_t> readTargetMachineArch(StringRef Buffer) {
36 const char *Data = Buffer.data();
37
38 if (Data[ELF::EI_DATA] == ELF::ELFDATA2LSB) {
39 if (Data[ELF::EI_CLASS] == ELF::ELFCLASS64) {
40 if (auto File = llvm::object::ELF64LEFile::create(Object: Buffer)) {
41 return File->getHeader().e_machine;
42 } else {
43 return File.takeError();
44 }
45 } else if (Data[ELF::EI_CLASS] == ELF::ELFCLASS32) {
46 if (auto File = llvm::object::ELF32LEFile::create(Object: Buffer)) {
47 return File->getHeader().e_machine;
48 } else {
49 return File.takeError();
50 }
51 }
52 }
53
54 if (Data[ELF::EI_DATA] == ELF::ELFDATA2MSB) {
55 if (Data[ELF::EI_CLASS] == ELF::ELFCLASS64) {
56 if (auto File = llvm::object::ELF64BEFile::create(Object: Buffer)) {
57 return File->getHeader().e_machine;
58 } else {
59 return File.takeError();
60 }
61 } else if (Data[ELF::EI_CLASS] == ELF::ELFCLASS32) {
62 if (auto File = llvm::object::ELF32BEFile::create(Object: Buffer)) {
63 return File->getHeader().e_machine;
64 } else {
65 return File.takeError();
66 }
67 }
68 }
69
70 return ELF::EM_NONE;
71}
72
73Expected<std::unique_ptr<LinkGraph>>
74createLinkGraphFromELFObject(MemoryBufferRef ObjectBuffer,
75 std::shared_ptr<orc::SymbolStringPool> SSP) {
76 StringRef Buffer = ObjectBuffer.getBuffer();
77 if (Buffer.size() < ELF::EI_NIDENT)
78 return make_error<JITLinkError>(Args: "Truncated ELF buffer");
79
80 if (memcmp(s1: Buffer.data(), s2: ELF::ElfMagic, n: strlen(s: ELF::ElfMagic)) != 0)
81 return make_error<JITLinkError>(Args: "ELF magic not valid");
82
83 uint8_t DataEncoding = Buffer.data()[ELF::EI_DATA];
84 Expected<uint16_t> TargetMachineArch = readTargetMachineArch(Buffer);
85 if (!TargetMachineArch)
86 return TargetMachineArch.takeError();
87
88 switch (*TargetMachineArch) {
89 case ELF::EM_AARCH64:
90 return createLinkGraphFromELFObject_aarch64(ObjectBuffer, SSP: std::move(SSP));
91 case ELF::EM_ARM:
92 return createLinkGraphFromELFObject_aarch32(ObjectBuffer, SSP: std::move(SSP));
93 case ELF::EM_HEXAGON:
94 return createLinkGraphFromELFObject_hexagon(ObjectBuffer, SSP: std::move(SSP));
95 case ELF::EM_PPC64: {
96 if (DataEncoding == ELF::ELFDATA2LSB)
97 return createLinkGraphFromELFObject_ppc64le(ObjectBuffer, SSP: std::move(SSP));
98 else
99 return createLinkGraphFromELFObject_ppc64(ObjectBuffer, SSP: std::move(SSP));
100 }
101 case ELF::EM_LOONGARCH:
102 return createLinkGraphFromELFObject_loongarch(ObjectBuffer, SSP: std::move(SSP));
103 case ELF::EM_RISCV:
104 return createLinkGraphFromELFObject_riscv(ObjectBuffer, SSP: std::move(SSP));
105 case ELF::EM_S390:
106 return createLinkGraphFromELFObject_systemz(ObjectBuffer, SSP: std::move(SSP));
107 case ELF::EM_X86_64:
108 return createLinkGraphFromELFObject_x86_64(ObjectBuffer, SSP: std::move(SSP));
109 case ELF::EM_386:
110 return createLinkGraphFromELFObject_x86(ObjectBuffer, SSP: std::move(SSP));
111 default:
112 return make_error<JITLinkError>(
113 Args: "Unsupported target machine architecture in ELF object " +
114 ObjectBuffer.getBufferIdentifier());
115 }
116}
117
118void link_ELF(std::unique_ptr<LinkGraph> G,
119 std::unique_ptr<JITLinkContext> Ctx) {
120 switch (G->getTargetTriple().getArch()) {
121 case Triple::aarch64:
122 link_ELF_aarch64(G: std::move(G), Ctx: std::move(Ctx));
123 return;
124 case Triple::arm:
125 case Triple::armeb:
126 case Triple::thumb:
127 case Triple::thumbeb:
128 link_ELF_aarch32(G: std::move(G), Ctx: std::move(Ctx));
129 return;
130 case Triple::hexagon:
131 link_ELF_hexagon(G: std::move(G), Ctx: std::move(Ctx));
132 return;
133 case Triple::loongarch32:
134 case Triple::loongarch64:
135 link_ELF_loongarch(G: std::move(G), Ctx: std::move(Ctx));
136 return;
137 case Triple::ppc64:
138 link_ELF_ppc64(G: std::move(G), Ctx: std::move(Ctx));
139 return;
140 case Triple::ppc64le:
141 link_ELF_ppc64le(G: std::move(G), Ctx: std::move(Ctx));
142 return;
143 case Triple::riscv32:
144 case Triple::riscv64:
145 link_ELF_riscv(G: std::move(G), Ctx: std::move(Ctx));
146 return;
147 case Triple::systemz:
148 link_ELF_systemz(G: std::move(G), Ctx: std::move(Ctx));
149 return;
150 case Triple::x86_64:
151 link_ELF_x86_64(G: std::move(G), Ctx: std::move(Ctx));
152 return;
153 case Triple::x86:
154 link_ELF_x86(G: std::move(G), Ctx: std::move(Ctx));
155 return;
156 default:
157 Ctx->notifyFailed(Err: make_error<JITLinkError>(
158 Args: "Unsupported target machine architecture in ELF link graph " +
159 G->getName()));
160 return;
161 }
162}
163
164} // end namespace jitlink
165} // end namespace llvm
166