LLVM 18.0.0git
ELF.cpp
Go to the documentation of this file.
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
14
23#include "llvm/Object/ELF.h"
24#include "llvm/Support/Endian.h"
25#include "llvm/Support/Format.h"
27#include <cstring>
28
29using namespace llvm;
30
31#define DEBUG_TYPE "jitlink"
32
33namespace llvm {
34namespace jitlink {
35
37 const char *Data = Buffer.data();
38
41 if (auto File = llvm::object::ELF64LEFile::create(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(Buffer)) {
48 return File->getHeader().e_machine;
49 } else {
50 return File.takeError();
51 }
52 }
53 }
54
57 if (auto File = llvm::object::ELF64BEFile::create(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(Buffer)) {
64 return File->getHeader().e_machine;
65 } else {
66 return File.takeError();
67 }
68 }
69 }
70
71 return ELF::EM_NONE;
72}
73
76 StringRef Buffer = ObjectBuffer.getBuffer();
77 if (Buffer.size() < ELF::EI_NIDENT)
78 return make_error<JITLinkError>("Truncated ELF buffer");
79
80 if (memcmp(Buffer.data(), ELF::ElfMagic, strlen(ELF::ElfMagic)) != 0)
81 return make_error<JITLinkError>("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);
91 case ELF::EM_ARM:
92 return createLinkGraphFromELFObject_aarch32(ObjectBuffer);
94 return createLinkGraphFromELFObject_loongarch(ObjectBuffer);
95 case ELF::EM_PPC64: {
96 if (DataEncoding == ELF::ELFDATA2LSB)
97 return createLinkGraphFromELFObject_ppc64le(ObjectBuffer);
98 else
99 return createLinkGraphFromELFObject_ppc64(ObjectBuffer);
100 }
101 case ELF::EM_RISCV:
102 return createLinkGraphFromELFObject_riscv(ObjectBuffer);
103 case ELF::EM_X86_64:
104 return createLinkGraphFromELFObject_x86_64(ObjectBuffer);
105 case ELF::EM_386:
106 return createLinkGraphFromELFObject_i386(ObjectBuffer);
107 default:
108 return make_error<JITLinkError>(
109 "Unsupported target machine architecture in ELF object " +
110 ObjectBuffer.getBufferIdentifier());
111 }
112}
113
114void link_ELF(std::unique_ptr<LinkGraph> G,
115 std::unique_ptr<JITLinkContext> Ctx) {
116 switch (G->getTargetTriple().getArch()) {
117 case Triple::aarch64:
118 link_ELF_aarch64(std::move(G), std::move(Ctx));
119 return;
120 case Triple::arm:
121 case Triple::armeb:
122 case Triple::thumb:
123 case Triple::thumbeb:
124 link_ELF_aarch32(std::move(G), std::move(Ctx));
125 return;
128 link_ELF_loongarch(std::move(G), std::move(Ctx));
129 return;
130 case Triple::ppc64:
131 link_ELF_ppc64(std::move(G), std::move(Ctx));
132 return;
133 case Triple::ppc64le:
134 link_ELF_ppc64le(std::move(G), std::move(Ctx));
135 return;
136 case Triple::riscv32:
137 case Triple::riscv64:
138 link_ELF_riscv(std::move(G), std::move(Ctx));
139 return;
140 case Triple::x86_64:
141 link_ELF_x86_64(std::move(G), std::move(Ctx));
142 return;
143 case Triple::x86:
144 link_ELF_i386(std::move(G), std::move(Ctx));
145 return;
146 default:
147 Ctx->notifyFailed(make_error<JITLinkError>(
148 "Unsupported target machine architecture in ELF link graph " +
149 G->getName()));
150 return;
151 }
152}
153
154} // end namespace jitlink
155} // end namespace llvm
#define G(x, y, z)
Definition: MD5.cpp:56
Merge contiguous icmps into a memcmp
Definition: MergeICmps.cpp:911
Tagged union holding either a T or a Error.
Definition: Error.h:468
Error takeError()
Take ownership of the stored error.
Definition: Error.h:595
StringRef getBufferIdentifier() const
StringRef getBuffer() const
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
constexpr size_t size() const
size - Get the string size.
Definition: StringRef.h:137
const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:131
@ loongarch32
Definition: Triple.h:61
@ loongarch64
Definition: Triple.h:62
static Expected< ELFFile > create(StringRef Object)
Definition: ELF.h:792
@ EI_DATA
Definition: ELF.h:53
@ EI_NIDENT
Definition: ELF.h:58
@ EI_CLASS
Definition: ELF.h:52
@ EM_PPC64
Definition: ELF.h:149
@ EM_NONE
Definition: ELF.h:133
@ EM_386
Definition: ELF.h:136
@ EM_LOONGARCH
Definition: ELF.h:322
@ EM_X86_64
Definition: ELF.h:178
@ EM_AARCH64
Definition: ELF.h:280
@ EM_RISCV
Definition: ELF.h:317
@ EM_ARM
Definition: ELF.h:156
@ ELFDATA2MSB
Definition: ELF.h:336
@ ELFDATA2LSB
Definition: ELF.h:335
static const char ElfMagic[]
Definition: ELF.h:44
@ ELFCLASS64
Definition: ELF.h:329
@ ELFCLASS32
Definition: ELF.h:328
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18