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_i386.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_x86_64.h"
23 #include "llvm/Object/ELF.h"
24 #include "llvm/Support/Format.h"
25 #include "llvm/Support/MemoryBuffer.h"
26 #include <cstring>
27 
28 using namespace llvm;
29 
30 #define DEBUG_TYPE "jitlink"
31 
32 namespace llvm {
33 namespace jitlink {
34 
35 Expected<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(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(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(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(Buffer)) {
63         return File->getHeader().e_machine;
64       } else {
65         return File.takeError();
66       }
67     }
68   }
69 
70   return ELF::EM_NONE;
71 }
72 
73 Expected<std::unique_ptr<LinkGraph>>
74 createLinkGraphFromELFObject(MemoryBufferRef ObjectBuffer) {
75   StringRef Buffer = ObjectBuffer.getBuffer();
76   if (Buffer.size() < ELF::EI_NIDENT)
77     return make_error<JITLinkError>("Truncated ELF buffer");
78 
79   if (memcmp(Buffer.data(), ELF::ElfMagic, strlen(ELF::ElfMagic)) != 0)
80     return make_error<JITLinkError>("ELF magic not valid");
81 
82   uint8_t DataEncoding = Buffer.data()[ELF::EI_DATA];
83   Expected<uint16_t> TargetMachineArch = readTargetMachineArch(Buffer);
84   if (!TargetMachineArch)
85     return TargetMachineArch.takeError();
86 
87   switch (*TargetMachineArch) {
88   case ELF::EM_AARCH64:
89     return createLinkGraphFromELFObject_aarch64(ObjectBuffer);
90   case ELF::EM_ARM:
91     return createLinkGraphFromELFObject_aarch32(ObjectBuffer);
92   case ELF::EM_LOONGARCH:
93     return createLinkGraphFromELFObject_loongarch(ObjectBuffer);
94   case ELF::EM_PPC64: {
95     if (DataEncoding == ELF::ELFDATA2LSB)
96       return createLinkGraphFromELFObject_ppc64le(ObjectBuffer);
97     else
98       return createLinkGraphFromELFObject_ppc64(ObjectBuffer);
99   }
100   case ELF::EM_RISCV:
101     return createLinkGraphFromELFObject_riscv(ObjectBuffer);
102   case ELF::EM_X86_64:
103     return createLinkGraphFromELFObject_x86_64(ObjectBuffer);
104   case ELF::EM_386:
105     return createLinkGraphFromELFObject_i386(ObjectBuffer);
106   default:
107     return make_error<JITLinkError>(
108         "Unsupported target machine architecture in ELF object " +
109         ObjectBuffer.getBufferIdentifier());
110   }
111 }
112 
113 void link_ELF(std::unique_ptr<LinkGraph> G,
114               std::unique_ptr<JITLinkContext> Ctx) {
115   switch (G->getTargetTriple().getArch()) {
116   case Triple::aarch64:
117     link_ELF_aarch64(std::move(G), std::move(Ctx));
118     return;
119   case Triple::arm:
120   case Triple::armeb:
121   case Triple::thumb:
122   case Triple::thumbeb:
123     link_ELF_aarch32(std::move(G), std::move(Ctx));
124     return;
125   case Triple::loongarch32:
126   case Triple::loongarch64:
127     link_ELF_loongarch(std::move(G), std::move(Ctx));
128     return;
129   case Triple::ppc64:
130     link_ELF_ppc64(std::move(G), std::move(Ctx));
131     return;
132   case Triple::ppc64le:
133     link_ELF_ppc64le(std::move(G), std::move(Ctx));
134     return;
135   case Triple::riscv32:
136   case Triple::riscv64:
137     link_ELF_riscv(std::move(G), std::move(Ctx));
138     return;
139   case Triple::x86_64:
140     link_ELF_x86_64(std::move(G), std::move(Ctx));
141     return;
142   case Triple::x86:
143     link_ELF_i386(std::move(G), std::move(Ctx));
144     return;
145   default:
146     Ctx->notifyFailed(make_error<JITLinkError>(
147         "Unsupported target machine architecture in ELF link graph " +
148         G->getName()));
149     return;
150   }
151 }
152 
153 } // end namespace jitlink
154 } // end namespace llvm
155