Bug Summary

File:include/llvm/ADT/FunctionExtras.h
Warning:line 142, column 5
Undefined or garbage value returned to caller

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name RuntimeDyld.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mthread-model posix -mframe-pointer=none -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-10/lib/clang/10.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-10~svn374877/build-llvm/lib/ExecutionEngine/RuntimeDyld -I /build/llvm-toolchain-snapshot-10~svn374877/lib/ExecutionEngine/RuntimeDyld -I /build/llvm-toolchain-snapshot-10~svn374877/build-llvm/include -I /build/llvm-toolchain-snapshot-10~svn374877/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-10/lib/clang/10.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-10~svn374877/build-llvm/lib/ExecutionEngine/RuntimeDyld -fdebug-prefix-map=/build/llvm-toolchain-snapshot-10~svn374877=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -o /tmp/scan-build-2019-10-15-233810-7101-1 -x c++ /build/llvm-toolchain-snapshot-10~svn374877/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp

/build/llvm-toolchain-snapshot-10~svn374877/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp

1//===-- RuntimeDyld.cpp - Run-time dynamic linker for MC-JIT ----*- C++ -*-===//
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// Implementation of the MC-JIT runtime dynamic linker.
10//
11//===----------------------------------------------------------------------===//
12
13#include "llvm/ExecutionEngine/RuntimeDyld.h"
14#include "RuntimeDyldCOFF.h"
15#include "RuntimeDyldELF.h"
16#include "RuntimeDyldImpl.h"
17#include "RuntimeDyldMachO.h"
18#include "llvm/Object/COFF.h"
19#include "llvm/Object/ELFObjectFile.h"
20#include "llvm/Support/Alignment.h"
21#include "llvm/Support/MSVCErrorWorkarounds.h"
22#include "llvm/Support/ManagedStatic.h"
23#include "llvm/Support/MathExtras.h"
24#include <mutex>
25
26#include <future>
27
28using namespace llvm;
29using namespace llvm::object;
30
31#define DEBUG_TYPE"dyld" "dyld"
32
33namespace {
34
35enum RuntimeDyldErrorCode {
36 GenericRTDyldError = 1
37};
38
39// FIXME: This class is only here to support the transition to llvm::Error. It
40// will be removed once this transition is complete. Clients should prefer to
41// deal with the Error value directly, rather than converting to error_code.
42class RuntimeDyldErrorCategory : public std::error_category {
43public:
44 const char *name() const noexcept override { return "runtimedyld"; }
45
46 std::string message(int Condition) const override {
47 switch (static_cast<RuntimeDyldErrorCode>(Condition)) {
48 case GenericRTDyldError: return "Generic RuntimeDyld error";
49 }
50 llvm_unreachable("Unrecognized RuntimeDyldErrorCode")::llvm::llvm_unreachable_internal("Unrecognized RuntimeDyldErrorCode"
, "/build/llvm-toolchain-snapshot-10~svn374877/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp"
, 50)
;
51 }
52};
53
54static ManagedStatic<RuntimeDyldErrorCategory> RTDyldErrorCategory;
55
56}
57
58char RuntimeDyldError::ID = 0;
59
60void RuntimeDyldError::log(raw_ostream &OS) const {
61 OS << ErrMsg << "\n";
62}
63
64std::error_code RuntimeDyldError::convertToErrorCode() const {
65 return std::error_code(GenericRTDyldError, *RTDyldErrorCategory);
66}
67
68// Empty out-of-line virtual destructor as the key function.
69RuntimeDyldImpl::~RuntimeDyldImpl() {}
70
71// Pin LoadedObjectInfo's vtables to this file.
72void RuntimeDyld::LoadedObjectInfo::anchor() {}
73
74namespace llvm {
75
76void RuntimeDyldImpl::registerEHFrames() {}
77
78void RuntimeDyldImpl::deregisterEHFrames() {
79 MemMgr.deregisterEHFrames();
80}
81
82#ifndef NDEBUG
83static void dumpSectionMemory(const SectionEntry &S, StringRef State) {
84 dbgs() << "----- Contents of section " << S.getName() << " " << State
85 << " -----";
86
87 if (S.getAddress() == nullptr) {
88 dbgs() << "\n <section not emitted>\n";
89 return;
90 }
91
92 const unsigned ColsPerRow = 16;
93
94 uint8_t *DataAddr = S.getAddress();
95 uint64_t LoadAddr = S.getLoadAddress();
96
97 unsigned StartPadding = LoadAddr & (ColsPerRow - 1);
98 unsigned BytesRemaining = S.getSize();
99
100 if (StartPadding) {
101 dbgs() << "\n" << format("0x%016" PRIx64"l" "x",
102 LoadAddr & ~(uint64_t)(ColsPerRow - 1)) << ":";
103 while (StartPadding--)
104 dbgs() << " ";
105 }
106
107 while (BytesRemaining > 0) {
108 if ((LoadAddr & (ColsPerRow - 1)) == 0)
109 dbgs() << "\n" << format("0x%016" PRIx64"l" "x", LoadAddr) << ":";
110
111 dbgs() << " " << format("%02x", *DataAddr);
112
113 ++DataAddr;
114 ++LoadAddr;
115 --BytesRemaining;
116 }
117
118 dbgs() << "\n";
119}
120#endif
121
122// Resolve the relocations for all symbols we currently know about.
123void RuntimeDyldImpl::resolveRelocations() {
124 std::lock_guard<sys::Mutex> locked(lock);
125
126 // Print out the sections prior to relocation.
127 LLVM_DEBUG(for (int i = 0, e = Sections.size(); i != e; ++i)do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dyld")) { for (int i = 0, e = Sections.size(); i != e; ++i)
dumpSectionMemory(Sections[i], "before relocations");; } } while
(false)
128 dumpSectionMemory(Sections[i], "before relocations");)do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dyld")) { for (int i = 0, e = Sections.size(); i != e; ++i)
dumpSectionMemory(Sections[i], "before relocations");; } } while
(false)
;
129
130 // First, resolve relocations associated with external symbols.
131 if (auto Err = resolveExternalSymbols()) {
132 HasError = true;
133 ErrorStr = toString(std::move(Err));
134 }
135
136 resolveLocalRelocations();
137
138 // Print out sections after relocation.
139 LLVM_DEBUG(for (int i = 0, e = Sections.size(); i != e; ++i)do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dyld")) { for (int i = 0, e = Sections.size(); i != e; ++i)
dumpSectionMemory(Sections[i], "after relocations");; } } while
(false)
140 dumpSectionMemory(Sections[i], "after relocations");)do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dyld")) { for (int i = 0, e = Sections.size(); i != e; ++i)
dumpSectionMemory(Sections[i], "after relocations");; } } while
(false)
;
141}
142
143void RuntimeDyldImpl::resolveLocalRelocations() {
144 // Iterate over all outstanding relocations
145 for (auto it = Relocations.begin(), e = Relocations.end(); it != e; ++it) {
146 // The Section here (Sections[i]) refers to the section in which the
147 // symbol for the relocation is located. The SectionID in the relocation
148 // entry provides the section to which the relocation will be applied.
149 int Idx = it->first;
150 uint64_t Addr = Sections[Idx].getLoadAddress();
151 LLVM_DEBUG(dbgs() << "Resolving relocations Section #" << Idx << "\t"do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dyld")) { dbgs() << "Resolving relocations Section #"
<< Idx << "\t" << format("%p", (uintptr_t)
Addr) << "\n"; } } while (false)
152 << format("%p", (uintptr_t)Addr) << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dyld")) { dbgs() << "Resolving relocations Section #"
<< Idx << "\t" << format("%p", (uintptr_t)
Addr) << "\n"; } } while (false)
;
153 resolveRelocationList(it->second, Addr);
154 }
155 Relocations.clear();
156}
157
158void RuntimeDyldImpl::mapSectionAddress(const void *LocalAddress,
159 uint64_t TargetAddress) {
160 std::lock_guard<sys::Mutex> locked(lock);
161 for (unsigned i = 0, e = Sections.size(); i != e; ++i) {
162 if (Sections[i].getAddress() == LocalAddress) {
163 reassignSectionAddress(i, TargetAddress);
164 return;
165 }
166 }
167 llvm_unreachable("Attempting to remap address of unknown section!")::llvm::llvm_unreachable_internal("Attempting to remap address of unknown section!"
, "/build/llvm-toolchain-snapshot-10~svn374877/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp"
, 167)
;
168}
169
170static Error getOffset(const SymbolRef &Sym, SectionRef Sec,
171 uint64_t &Result) {
172 Expected<uint64_t> AddressOrErr = Sym.getAddress();
173 if (!AddressOrErr)
174 return AddressOrErr.takeError();
175 Result = *AddressOrErr - Sec.getAddress();
176 return Error::success();
177}
178
179Expected<RuntimeDyldImpl::ObjSectionToIDMap>
180RuntimeDyldImpl::loadObjectImpl(const object::ObjectFile &Obj) {
181 std::lock_guard<sys::Mutex> locked(lock);
182
183 // Save information about our target
184 Arch = (Triple::ArchType)Obj.getArch();
185 IsTargetLittleEndian = Obj.isLittleEndian();
186 setMipsABI(Obj);
187
188 // Compute the memory size required to load all sections to be loaded
189 // and pass this information to the memory manager
190 if (MemMgr.needsToReserveAllocationSpace()) {
191 uint64_t CodeSize = 0, RODataSize = 0, RWDataSize = 0;
192 uint32_t CodeAlign = 1, RODataAlign = 1, RWDataAlign = 1;
193 if (auto Err = computeTotalAllocSize(Obj,
194 CodeSize, CodeAlign,
195 RODataSize, RODataAlign,
196 RWDataSize, RWDataAlign))
197 return std::move(Err);
198 MemMgr.reserveAllocationSpace(CodeSize, CodeAlign, RODataSize, RODataAlign,
199 RWDataSize, RWDataAlign);
200 }
201
202 // Used sections from the object file
203 ObjSectionToIDMap LocalSections;
204
205 // Common symbols requiring allocation, with their sizes and alignments
206 CommonSymbolList CommonSymbolsToAllocate;
207
208 uint64_t CommonSize = 0;
209 uint32_t CommonAlign = 0;
210
211 // First, collect all weak and common symbols. We need to know if stronger
212 // definitions occur elsewhere.
213 JITSymbolResolver::LookupSet ResponsibilitySet;
214 {
215 JITSymbolResolver::LookupSet Symbols;
216 for (auto &Sym : Obj.symbols()) {
217 uint32_t Flags = Sym.getFlags();
218 if ((Flags & SymbolRef::SF_Common) || (Flags & SymbolRef::SF_Weak)) {
219 // Get symbol name.
220 if (auto NameOrErr = Sym.getName())
221 Symbols.insert(*NameOrErr);
222 else
223 return NameOrErr.takeError();
224 }
225 }
226
227 if (auto ResultOrErr = Resolver.getResponsibilitySet(Symbols))
228 ResponsibilitySet = std::move(*ResultOrErr);
229 else
230 return ResultOrErr.takeError();
231 }
232
233 // Parse symbols
234 LLVM_DEBUG(dbgs() << "Parse symbols:\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dyld")) { dbgs() << "Parse symbols:\n"; } } while (false
)
;
235 for (symbol_iterator I = Obj.symbol_begin(), E = Obj.symbol_end(); I != E;
236 ++I) {
237 uint32_t Flags = I->getFlags();
238
239 // Skip undefined symbols.
240 if (Flags & SymbolRef::SF_Undefined)
241 continue;
242
243 // Get the symbol type.
244 object::SymbolRef::Type SymType;
245 if (auto SymTypeOrErr = I->getType())
246 SymType = *SymTypeOrErr;
247 else
248 return SymTypeOrErr.takeError();
249
250 // Get symbol name.
251 StringRef Name;
252 if (auto NameOrErr = I->getName())
253 Name = *NameOrErr;
254 else
255 return NameOrErr.takeError();
256
257 // Compute JIT symbol flags.
258 auto JITSymFlags = getJITSymbolFlags(*I);
259 if (!JITSymFlags)
260 return JITSymFlags.takeError();
261
262 // If this is a weak definition, check to see if there's a strong one.
263 // If there is, skip this symbol (we won't be providing it: the strong
264 // definition will). If there's no strong definition, make this definition
265 // strong.
266 if (JITSymFlags->isWeak() || JITSymFlags->isCommon()) {
267 // First check whether there's already a definition in this instance.
268 if (GlobalSymbolTable.count(Name))
269 continue;
270
271 // If we're not responsible for this symbol, skip it.
272 if (!ResponsibilitySet.count(Name))
273 continue;
274
275 // Otherwise update the flags on the symbol to make this definition
276 // strong.
277 if (JITSymFlags->isWeak())
278 *JITSymFlags &= ~JITSymbolFlags::Weak;
279 if (JITSymFlags->isCommon()) {
280 *JITSymFlags &= ~JITSymbolFlags::Common;
281 uint32_t Align = I->getAlignment();
282 uint64_t Size = I->getCommonSize();
283 if (!CommonAlign)
284 CommonAlign = Align;
285 CommonSize = alignTo(CommonSize, Align) + Size;
286 CommonSymbolsToAllocate.push_back(*I);
287 }
288 }
289
290 if (Flags & SymbolRef::SF_Absolute &&
291 SymType != object::SymbolRef::ST_File) {
292 uint64_t Addr = 0;
293 if (auto AddrOrErr = I->getAddress())
294 Addr = *AddrOrErr;
295 else
296 return AddrOrErr.takeError();
297
298 unsigned SectionID = AbsoluteSymbolSection;
299
300 LLVM_DEBUG(dbgs() << "\tType: " << SymType << " (absolute) Name: " << Namedo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dyld")) { dbgs() << "\tType: " << SymType <<
" (absolute) Name: " << Name << " SID: " <<
SectionID << " Offset: " << format("%p", (uintptr_t
)Addr) << " flags: " << Flags << "\n"; } } while
(false)
301 << " SID: " << SectionIDdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dyld")) { dbgs() << "\tType: " << SymType <<
" (absolute) Name: " << Name << " SID: " <<
SectionID << " Offset: " << format("%p", (uintptr_t
)Addr) << " flags: " << Flags << "\n"; } } while
(false)
302 << " Offset: " << format("%p", (uintptr_t)Addr)do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dyld")) { dbgs() << "\tType: " << SymType <<
" (absolute) Name: " << Name << " SID: " <<
SectionID << " Offset: " << format("%p", (uintptr_t
)Addr) << " flags: " << Flags << "\n"; } } while
(false)
303 << " flags: " << Flags << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dyld")) { dbgs() << "\tType: " << SymType <<
" (absolute) Name: " << Name << " SID: " <<
SectionID << " Offset: " << format("%p", (uintptr_t
)Addr) << " flags: " << Flags << "\n"; } } while
(false)
;
304 GlobalSymbolTable[Name] = SymbolTableEntry(SectionID, Addr, *JITSymFlags);
305 } else if (SymType == object::SymbolRef::ST_Function ||
306 SymType == object::SymbolRef::ST_Data ||
307 SymType == object::SymbolRef::ST_Unknown ||
308 SymType == object::SymbolRef::ST_Other) {
309
310 section_iterator SI = Obj.section_end();
311 if (auto SIOrErr = I->getSection())
312 SI = *SIOrErr;
313 else
314 return SIOrErr.takeError();
315
316 if (SI == Obj.section_end())
317 continue;
318
319 // Get symbol offset.
320 uint64_t SectOffset;
321 if (auto Err = getOffset(*I, *SI, SectOffset))
322 return std::move(Err);
323
324 bool IsCode = SI->isText();
325 unsigned SectionID;
326 if (auto SectionIDOrErr =
327 findOrEmitSection(Obj, *SI, IsCode, LocalSections))
328 SectionID = *SectionIDOrErr;
329 else
330 return SectionIDOrErr.takeError();
331
332 LLVM_DEBUG(dbgs() << "\tType: " << SymType << " Name: " << Namedo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dyld")) { dbgs() << "\tType: " << SymType <<
" Name: " << Name << " SID: " << SectionID
<< " Offset: " << format("%p", (uintptr_t)SectOffset
) << " flags: " << Flags << "\n"; } } while
(false)
333 << " SID: " << SectionIDdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dyld")) { dbgs() << "\tType: " << SymType <<
" Name: " << Name << " SID: " << SectionID
<< " Offset: " << format("%p", (uintptr_t)SectOffset
) << " flags: " << Flags << "\n"; } } while
(false)
334 << " Offset: " << format("%p", (uintptr_t)SectOffset)do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dyld")) { dbgs() << "\tType: " << SymType <<
" Name: " << Name << " SID: " << SectionID
<< " Offset: " << format("%p", (uintptr_t)SectOffset
) << " flags: " << Flags << "\n"; } } while
(false)
335 << " flags: " << Flags << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dyld")) { dbgs() << "\tType: " << SymType <<
" Name: " << Name << " SID: " << SectionID
<< " Offset: " << format("%p", (uintptr_t)SectOffset
) << " flags: " << Flags << "\n"; } } while
(false)
;
336 GlobalSymbolTable[Name] =
337 SymbolTableEntry(SectionID, SectOffset, *JITSymFlags);
338 }
339 }
340
341 // Allocate common symbols
342 if (auto Err = emitCommonSymbols(Obj, CommonSymbolsToAllocate, CommonSize,
343 CommonAlign))
344 return std::move(Err);
345
346 // Parse and process relocations
347 LLVM_DEBUG(dbgs() << "Parse relocations:\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dyld")) { dbgs() << "Parse relocations:\n"; } } while
(false)
;
348 for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end();
349 SI != SE; ++SI) {
350 StubMap Stubs;
351 section_iterator RelocatedSection = SI->getRelocatedSection();
352
353 if (RelocatedSection == SE)
354 continue;
355
356 relocation_iterator I = SI->relocation_begin();
357 relocation_iterator E = SI->relocation_end();
358
359 if (I == E && !ProcessAllSections)
360 continue;
361
362 bool IsCode = RelocatedSection->isText();
363 unsigned SectionID = 0;
364 if (auto SectionIDOrErr = findOrEmitSection(Obj, *RelocatedSection, IsCode,
365 LocalSections))
366 SectionID = *SectionIDOrErr;
367 else
368 return SectionIDOrErr.takeError();
369
370 LLVM_DEBUG(dbgs() << "\tSectionID: " << SectionID << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dyld")) { dbgs() << "\tSectionID: " << SectionID
<< "\n"; } } while (false)
;
371
372 for (; I != E;)
373 if (auto IOrErr = processRelocationRef(SectionID, I, Obj, LocalSections, Stubs))
374 I = *IOrErr;
375 else
376 return IOrErr.takeError();
377
378 // If there is a NotifyStubEmitted callback set, call it to register any
379 // stubs created for this section.
380 if (NotifyStubEmitted) {
381 StringRef FileName = Obj.getFileName();
382 StringRef SectionName = Sections[SectionID].getName();
383 for (auto &KV : Stubs) {
384
385 auto &VR = KV.first;
386 uint64_t StubAddr = KV.second;
387
388 // If this is a named stub, just call NotifyStubEmitted.
389 if (VR.SymbolName) {
390 NotifyStubEmitted(FileName, SectionName, VR.SymbolName, SectionID,
391 StubAddr);
392 continue;
393 }
394
395 // Otherwise we will have to try a reverse lookup on the globla symbol table.
396 for (auto &GSTMapEntry : GlobalSymbolTable) {
397 StringRef SymbolName = GSTMapEntry.first();
398 auto &GSTEntry = GSTMapEntry.second;
399 if (GSTEntry.getSectionID() == VR.SectionID &&
400 GSTEntry.getOffset() == VR.Offset) {
401 NotifyStubEmitted(FileName, SectionName, SymbolName, SectionID,
402 StubAddr);
403 break;
404 }
405 }
406 }
407 }
408 }
409
410 // Process remaining sections
411 if (ProcessAllSections) {
412 LLVM_DEBUG(dbgs() << "Process remaining sections:\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dyld")) { dbgs() << "Process remaining sections:\n"; }
} while (false)
;
413 for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end();
414 SI != SE; ++SI) {
415
416 /* Ignore already loaded sections */
417 if (LocalSections.find(*SI) != LocalSections.end())
418 continue;
419
420 bool IsCode = SI->isText();
421 if (auto SectionIDOrErr =
422 findOrEmitSection(Obj, *SI, IsCode, LocalSections))
423 LLVM_DEBUG(dbgs() << "\tSectionID: " << (*SectionIDOrErr) << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dyld")) { dbgs() << "\tSectionID: " << (*SectionIDOrErr
) << "\n"; } } while (false)
;
424 else
425 return SectionIDOrErr.takeError();
426 }
427 }
428
429 // Give the subclasses a chance to tie-up any loose ends.
430 if (auto Err = finalizeLoad(Obj, LocalSections))
431 return std::move(Err);
432
433// for (auto E : LocalSections)
434// llvm::dbgs() << "Added: " << E.first.getRawDataRefImpl() << " -> " << E.second << "\n";
435
436 return LocalSections;
437}
438
439// A helper method for computeTotalAllocSize.
440// Computes the memory size required to allocate sections with the given sizes,
441// assuming that all sections are allocated with the given alignment
442static uint64_t
443computeAllocationSizeForSections(std::vector<uint64_t> &SectionSizes,
444 uint64_t Alignment) {
445 uint64_t TotalSize = 0;
446 for (size_t Idx = 0, Cnt = SectionSizes.size(); Idx < Cnt; Idx++) {
447 uint64_t AlignedSize =
448 (SectionSizes[Idx] + Alignment - 1) / Alignment * Alignment;
449 TotalSize += AlignedSize;
450 }
451 return TotalSize;
452}
453
454static bool isRequiredForExecution(const SectionRef Section) {
455 const ObjectFile *Obj = Section.getObject();
456 if (isa<object::ELFObjectFileBase>(Obj))
457 return ELFSectionRef(Section).getFlags() & ELF::SHF_ALLOC;
458 if (auto *COFFObj = dyn_cast<object::COFFObjectFile>(Obj)) {
459 const coff_section *CoffSection = COFFObj->getCOFFSection(Section);
460 // Avoid loading zero-sized COFF sections.
461 // In PE files, VirtualSize gives the section size, and SizeOfRawData
462 // may be zero for sections with content. In Obj files, SizeOfRawData
463 // gives the section size, and VirtualSize is always zero. Hence
464 // the need to check for both cases below.
465 bool HasContent =
466 (CoffSection->VirtualSize > 0) || (CoffSection->SizeOfRawData > 0);
467 bool IsDiscardable =
468 CoffSection->Characteristics &
469 (COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_LNK_INFO);
470 return HasContent && !IsDiscardable;
471 }
472
473 assert(isa<MachOObjectFile>(Obj))((isa<MachOObjectFile>(Obj)) ? static_cast<void> (
0) : __assert_fail ("isa<MachOObjectFile>(Obj)", "/build/llvm-toolchain-snapshot-10~svn374877/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp"
, 473, __PRETTY_FUNCTION__))
;
474 return true;
475}
476
477static bool isReadOnlyData(const SectionRef Section) {
478 const ObjectFile *Obj = Section.getObject();
479 if (isa<object::ELFObjectFileBase>(Obj))
480 return !(ELFSectionRef(Section).getFlags() &
481 (ELF::SHF_WRITE | ELF::SHF_EXECINSTR));
482 if (auto *COFFObj = dyn_cast<object::COFFObjectFile>(Obj))
483 return ((COFFObj->getCOFFSection(Section)->Characteristics &
484 (COFF::IMAGE_SCN_CNT_INITIALIZED_DATA
485 | COFF::IMAGE_SCN_MEM_READ
486 | COFF::IMAGE_SCN_MEM_WRITE))
487 ==
488 (COFF::IMAGE_SCN_CNT_INITIALIZED_DATA
489 | COFF::IMAGE_SCN_MEM_READ));
490
491 assert(isa<MachOObjectFile>(Obj))((isa<MachOObjectFile>(Obj)) ? static_cast<void> (
0) : __assert_fail ("isa<MachOObjectFile>(Obj)", "/build/llvm-toolchain-snapshot-10~svn374877/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp"
, 491, __PRETTY_FUNCTION__))
;
492 return false;
493}
494
495static bool isZeroInit(const SectionRef Section) {
496 const ObjectFile *Obj = Section.getObject();
497 if (isa<object::ELFObjectFileBase>(Obj))
498 return ELFSectionRef(Section).getType() == ELF::SHT_NOBITS;
499 if (auto *COFFObj = dyn_cast<object::COFFObjectFile>(Obj))
500 return COFFObj->getCOFFSection(Section)->Characteristics &
501 COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA;
502
503 auto *MachO = cast<MachOObjectFile>(Obj);
504 unsigned SectionType = MachO->getSectionType(Section);
505 return SectionType == MachO::S_ZEROFILL ||
506 SectionType == MachO::S_GB_ZEROFILL;
507}
508
509// Compute an upper bound of the memory size that is required to load all
510// sections
511Error RuntimeDyldImpl::computeTotalAllocSize(const ObjectFile &Obj,
512 uint64_t &CodeSize,
513 uint32_t &CodeAlign,
514 uint64_t &RODataSize,
515 uint32_t &RODataAlign,
516 uint64_t &RWDataSize,
517 uint32_t &RWDataAlign) {
518 // Compute the size of all sections required for execution
519 std::vector<uint64_t> CodeSectionSizes;
520 std::vector<uint64_t> ROSectionSizes;
521 std::vector<uint64_t> RWSectionSizes;
522
523 // Collect sizes of all sections to be loaded;
524 // also determine the max alignment of all sections
525 for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end();
526 SI != SE; ++SI) {
527 const SectionRef &Section = *SI;
528
529 bool IsRequired = isRequiredForExecution(Section) || ProcessAllSections;
530
531 // Consider only the sections that are required to be loaded for execution
532 if (IsRequired) {
533 uint64_t DataSize = Section.getSize();
534 uint64_t Alignment64 = Section.getAlignment();
535 unsigned Alignment = (unsigned)Alignment64 & 0xffffffffL;
536 bool IsCode = Section.isText();
537 bool IsReadOnly = isReadOnlyData(Section);
538
539 Expected<StringRef> NameOrErr = Section.getName();
540 if (!NameOrErr)
541 return NameOrErr.takeError();
542 StringRef Name = *NameOrErr;
543
544 uint64_t StubBufSize = computeSectionStubBufSize(Obj, Section);
545
546 uint64_t PaddingSize = 0;
547 if (Name == ".eh_frame")
548 PaddingSize += 4;
549 if (StubBufSize != 0)
550 PaddingSize += getStubAlignment() - 1;
551
552 uint64_t SectionSize = DataSize + PaddingSize + StubBufSize;
553
554 // The .eh_frame section (at least on Linux) needs an extra four bytes
555 // padded
556 // with zeroes added at the end. For MachO objects, this section has a
557 // slightly different name, so this won't have any effect for MachO
558 // objects.
559 if (Name == ".eh_frame")
560 SectionSize += 4;
561
562 if (!SectionSize)
563 SectionSize = 1;
564
565 if (IsCode) {
566 CodeAlign = std::max(CodeAlign, Alignment);
567 CodeSectionSizes.push_back(SectionSize);
568 } else if (IsReadOnly) {
569 RODataAlign = std::max(RODataAlign, Alignment);
570 ROSectionSizes.push_back(SectionSize);
571 } else {
572 RWDataAlign = std::max(RWDataAlign, Alignment);
573 RWSectionSizes.push_back(SectionSize);
574 }
575 }
576 }
577
578 // Compute Global Offset Table size. If it is not zero we
579 // also update alignment, which is equal to a size of a
580 // single GOT entry.
581 if (unsigned GotSize = computeGOTSize(Obj)) {
582 RWSectionSizes.push_back(GotSize);
583 RWDataAlign = std::max<uint32_t>(RWDataAlign, getGOTEntrySize());
584 }
585
586 // Compute the size of all common symbols
587 uint64_t CommonSize = 0;
588 uint32_t CommonAlign = 1;
589 for (symbol_iterator I = Obj.symbol_begin(), E = Obj.symbol_end(); I != E;
590 ++I) {
591 uint32_t Flags = I->getFlags();
592 if (Flags & SymbolRef::SF_Common) {
593 // Add the common symbols to a list. We'll allocate them all below.
594 uint64_t Size = I->getCommonSize();
595 uint32_t Align = I->getAlignment();
596 // If this is the first common symbol, use its alignment as the alignment
597 // for the common symbols section.
598 if (CommonSize == 0)
599 CommonAlign = Align;
600 CommonSize = alignTo(CommonSize, Align) + Size;
601 }
602 }
603 if (CommonSize != 0) {
604 RWSectionSizes.push_back(CommonSize);
605 RWDataAlign = std::max(RWDataAlign, CommonAlign);
606 }
607
608 // Compute the required allocation space for each different type of sections
609 // (code, read-only data, read-write data) assuming that all sections are
610 // allocated with the max alignment. Note that we cannot compute with the
611 // individual alignments of the sections, because then the required size
612 // depends on the order, in which the sections are allocated.
613 CodeSize = computeAllocationSizeForSections(CodeSectionSizes, CodeAlign);
614 RODataSize = computeAllocationSizeForSections(ROSectionSizes, RODataAlign);
615 RWDataSize = computeAllocationSizeForSections(RWSectionSizes, RWDataAlign);
616
617 return Error::success();
618}
619
620// compute GOT size
621unsigned RuntimeDyldImpl::computeGOTSize(const ObjectFile &Obj) {
622 size_t GotEntrySize = getGOTEntrySize();
623 if (!GotEntrySize)
624 return 0;
625
626 size_t GotSize = 0;
627 for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end();
628 SI != SE; ++SI) {
629
630 for (const RelocationRef &Reloc : SI->relocations())
631 if (relocationNeedsGot(Reloc))
632 GotSize += GotEntrySize;
633 }
634
635 return GotSize;
636}
637
638// compute stub buffer size for the given section
639unsigned RuntimeDyldImpl::computeSectionStubBufSize(const ObjectFile &Obj,
640 const SectionRef &Section) {
641 unsigned StubSize = getMaxStubSize();
642 if (StubSize == 0) {
643 return 0;
644 }
645 // FIXME: this is an inefficient way to handle this. We should computed the
646 // necessary section allocation size in loadObject by walking all the sections
647 // once.
648 unsigned StubBufSize = 0;
649 for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end();
650 SI != SE; ++SI) {
651 section_iterator RelSecI = SI->getRelocatedSection();
652 if (!(RelSecI == Section))
653 continue;
654
655 for (const RelocationRef &Reloc : SI->relocations())
656 if (relocationNeedsStub(Reloc))
657 StubBufSize += StubSize;
658 }
659
660 // Get section data size and alignment
661 uint64_t DataSize = Section.getSize();
662 uint64_t Alignment64 = Section.getAlignment();
663
664 // Add stubbuf size alignment
665 unsigned Alignment = (unsigned)Alignment64 & 0xffffffffL;
666 unsigned StubAlignment = getStubAlignment();
667 unsigned EndAlignment = (DataSize | Alignment) & -(DataSize | Alignment);
668 if (StubAlignment > EndAlignment)
669 StubBufSize += StubAlignment - EndAlignment;
670 return StubBufSize;
671}
672
673uint64_t RuntimeDyldImpl::readBytesUnaligned(uint8_t *Src,
674 unsigned Size) const {
675 uint64_t Result = 0;
676 if (IsTargetLittleEndian) {
677 Src += Size - 1;
678 while (Size--)
679 Result = (Result << 8) | *Src--;
680 } else
681 while (Size--)
682 Result = (Result << 8) | *Src++;
683
684 return Result;
685}
686
687void RuntimeDyldImpl::writeBytesUnaligned(uint64_t Value, uint8_t *Dst,
688 unsigned Size) const {
689 if (IsTargetLittleEndian) {
690 while (Size--) {
691 *Dst++ = Value & 0xFF;
692 Value >>= 8;
693 }
694 } else {
695 Dst += Size - 1;
696 while (Size--) {
697 *Dst-- = Value & 0xFF;
698 Value >>= 8;
699 }
700 }
701}
702
703Expected<JITSymbolFlags>
704RuntimeDyldImpl::getJITSymbolFlags(const SymbolRef &SR) {
705 return JITSymbolFlags::fromObjectSymbol(SR);
706}
707
708Error RuntimeDyldImpl::emitCommonSymbols(const ObjectFile &Obj,
709 CommonSymbolList &SymbolsToAllocate,
710 uint64_t CommonSize,
711 uint32_t CommonAlign) {
712 if (SymbolsToAllocate.empty())
713 return Error::success();
714
715 // Allocate memory for the section
716 unsigned SectionID = Sections.size();
717 uint8_t *Addr = MemMgr.allocateDataSection(CommonSize, CommonAlign, SectionID,
718 "<common symbols>", false);
719 if (!Addr)
720 report_fatal_error("Unable to allocate memory for common symbols!");
721 uint64_t Offset = 0;
722 Sections.push_back(
723 SectionEntry("<common symbols>", Addr, CommonSize, CommonSize, 0));
724 memset(Addr, 0, CommonSize);
725
726 LLVM_DEBUG(dbgs() << "emitCommonSection SectionID: " << SectionIDdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dyld")) { dbgs() << "emitCommonSection SectionID: " <<
SectionID << " new addr: " << format("%p", Addr)
<< " DataSize: " << CommonSize << "\n"; } }
while (false)
727 << " new addr: " << format("%p", Addr)do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dyld")) { dbgs() << "emitCommonSection SectionID: " <<
SectionID << " new addr: " << format("%p", Addr)
<< " DataSize: " << CommonSize << "\n"; } }
while (false)
728 << " DataSize: " << CommonSize << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dyld")) { dbgs() << "emitCommonSection SectionID: " <<
SectionID << " new addr: " << format("%p", Addr)
<< " DataSize: " << CommonSize << "\n"; } }
while (false)
;
729
730 // Assign the address of each symbol
731 for (auto &Sym : SymbolsToAllocate) {
732 uint32_t Alignment = Sym.getAlignment();
733 uint64_t Size = Sym.getCommonSize();
734 StringRef Name;
735 if (auto NameOrErr = Sym.getName())
736 Name = *NameOrErr;
737 else
738 return NameOrErr.takeError();
739 if (Alignment) {
740 // This symbol has an alignment requirement.
741 uint64_t AlignOffset =
742 offsetToAlignment((uint64_t)Addr, Align(Alignment));
743 Addr += AlignOffset;
744 Offset += AlignOffset;
745 }
746 auto JITSymFlags = getJITSymbolFlags(Sym);
747
748 if (!JITSymFlags)
749 return JITSymFlags.takeError();
750
751 LLVM_DEBUG(dbgs() << "Allocating common symbol " << Name << " address "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dyld")) { dbgs() << "Allocating common symbol " <<
Name << " address " << format("%p", Addr) <<
"\n"; } } while (false)
752 << format("%p", Addr) << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dyld")) { dbgs() << "Allocating common symbol " <<
Name << " address " << format("%p", Addr) <<
"\n"; } } while (false)
;
753 GlobalSymbolTable[Name] =
754 SymbolTableEntry(SectionID, Offset, std::move(*JITSymFlags));
755 Offset += Size;
756 Addr += Size;
757 }
758
759 return Error::success();
760}
761
762Expected<unsigned>
763RuntimeDyldImpl::emitSection(const ObjectFile &Obj,
764 const SectionRef &Section,
765 bool IsCode) {
766 StringRef data;
767 uint64_t Alignment64 = Section.getAlignment();
768
769 unsigned Alignment = (unsigned)Alignment64 & 0xffffffffL;
770 unsigned PaddingSize = 0;
771 unsigned StubBufSize = 0;
772 bool IsRequired = isRequiredForExecution(Section);
773 bool IsVirtual = Section.isVirtual();
774 bool IsZeroInit = isZeroInit(Section);
775 bool IsReadOnly = isReadOnlyData(Section);
776 uint64_t DataSize = Section.getSize();
777
778 // An alignment of 0 (at least with ELF) is identical to an alignment of 1,
779 // while being more "polite". Other formats do not support 0-aligned sections
780 // anyway, so we should guarantee that the alignment is always at least 1.
781 Alignment = std::max(1u, Alignment);
782
783 Expected<StringRef> NameOrErr = Section.getName();
784 if (!NameOrErr)
785 return NameOrErr.takeError();
786 StringRef Name = *NameOrErr;
787
788 StubBufSize = computeSectionStubBufSize(Obj, Section);
789
790 // The .eh_frame section (at least on Linux) needs an extra four bytes padded
791 // with zeroes added at the end. For MachO objects, this section has a
792 // slightly different name, so this won't have any effect for MachO objects.
793 if (Name == ".eh_frame")
794 PaddingSize = 4;
795
796 uintptr_t Allocate;
797 unsigned SectionID = Sections.size();
798 uint8_t *Addr;
799 const char *pData = nullptr;
800
801 // If this section contains any bits (i.e. isn't a virtual or bss section),
802 // grab a reference to them.
803 if (!IsVirtual && !IsZeroInit) {
804 // In either case, set the location of the unrelocated section in memory,
805 // since we still process relocations for it even if we're not applying them.
806 if (Expected<StringRef> E = Section.getContents())
807 data = *E;
808 else
809 return E.takeError();
810 pData = data.data();
811 }
812
813 // If there are any stubs then the section alignment needs to be at least as
814 // high as stub alignment or padding calculations may by incorrect when the
815 // section is remapped.
816 if (StubBufSize != 0) {
817 Alignment = std::max(Alignment, getStubAlignment());
818 PaddingSize += getStubAlignment() - 1;
819 }
820
821 // Some sections, such as debug info, don't need to be loaded for execution.
822 // Process those only if explicitly requested.
823 if (IsRequired || ProcessAllSections) {
824 Allocate = DataSize + PaddingSize + StubBufSize;
825 if (!Allocate)
826 Allocate = 1;
827 Addr = IsCode ? MemMgr.allocateCodeSection(Allocate, Alignment, SectionID,
828 Name)
829 : MemMgr.allocateDataSection(Allocate, Alignment, SectionID,
830 Name, IsReadOnly);
831 if (!Addr)
832 report_fatal_error("Unable to allocate section memory!");
833
834 // Zero-initialize or copy the data from the image
835 if (IsZeroInit || IsVirtual)
836 memset(Addr, 0, DataSize);
837 else
838 memcpy(Addr, pData, DataSize);
839
840 // Fill in any extra bytes we allocated for padding
841 if (PaddingSize != 0) {
842 memset(Addr + DataSize, 0, PaddingSize);
843 // Update the DataSize variable to include padding.
844 DataSize += PaddingSize;
845
846 // Align DataSize to stub alignment if we have any stubs (PaddingSize will
847 // have been increased above to account for this).
848 if (StubBufSize > 0)
849 DataSize &= -(uint64_t)getStubAlignment();
850 }
851
852 LLVM_DEBUG(dbgs() << "emitSection SectionID: " << SectionID << " Name: "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dyld")) { dbgs() << "emitSection SectionID: " <<
SectionID << " Name: " << Name << " obj addr: "
<< format("%p", pData) << " new addr: " <<
format("%p", Addr) << " DataSize: " << DataSize <<
" StubBufSize: " << StubBufSize << " Allocate: "
<< Allocate << "\n"; } } while (false)
853 << Name << " obj addr: " << format("%p", pData)do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dyld")) { dbgs() << "emitSection SectionID: " <<
SectionID << " Name: " << Name << " obj addr: "
<< format("%p", pData) << " new addr: " <<
format("%p", Addr) << " DataSize: " << DataSize <<
" StubBufSize: " << StubBufSize << " Allocate: "
<< Allocate << "\n"; } } while (false)
854 << " new addr: " << format("%p", Addr) << " DataSize: "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dyld")) { dbgs() << "emitSection SectionID: " <<
SectionID << " Name: " << Name << " obj addr: "
<< format("%p", pData) << " new addr: " <<
format("%p", Addr) << " DataSize: " << DataSize <<
" StubBufSize: " << StubBufSize << " Allocate: "
<< Allocate << "\n"; } } while (false)
855 << DataSize << " StubBufSize: " << StubBufSizedo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dyld")) { dbgs() << "emitSection SectionID: " <<
SectionID << " Name: " << Name << " obj addr: "
<< format("%p", pData) << " new addr: " <<
format("%p", Addr) << " DataSize: " << DataSize <<
" StubBufSize: " << StubBufSize << " Allocate: "
<< Allocate << "\n"; } } while (false)
856 << " Allocate: " << Allocate << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dyld")) { dbgs() << "emitSection SectionID: " <<
SectionID << " Name: " << Name << " obj addr: "
<< format("%p", pData) << " new addr: " <<
format("%p", Addr) << " DataSize: " << DataSize <<
" StubBufSize: " << StubBufSize << " Allocate: "
<< Allocate << "\n"; } } while (false)
;
857 } else {
858 // Even if we didn't load the section, we need to record an entry for it
859 // to handle later processing (and by 'handle' I mean don't do anything
860 // with these sections).
861 Allocate = 0;
862 Addr = nullptr;
863 LLVM_DEBUG(do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dyld")) { dbgs() << "emitSection SectionID: " <<
SectionID << " Name: " << Name << " obj addr: "
<< format("%p", data.data()) << " new addr: 0" <<
" DataSize: " << DataSize << " StubBufSize: " <<
StubBufSize << " Allocate: " << Allocate <<
"\n"; } } while (false)
864 dbgs() << "emitSection SectionID: " << SectionID << " Name: " << Namedo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dyld")) { dbgs() << "emitSection SectionID: " <<
SectionID << " Name: " << Name << " obj addr: "
<< format("%p", data.data()) << " new addr: 0" <<
" DataSize: " << DataSize << " StubBufSize: " <<
StubBufSize << " Allocate: " << Allocate <<
"\n"; } } while (false)
865 << " obj addr: " << format("%p", data.data()) << " new addr: 0"do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dyld")) { dbgs() << "emitSection SectionID: " <<
SectionID << " Name: " << Name << " obj addr: "
<< format("%p", data.data()) << " new addr: 0" <<
" DataSize: " << DataSize << " StubBufSize: " <<
StubBufSize << " Allocate: " << Allocate <<
"\n"; } } while (false)
866 << " DataSize: " << DataSize << " StubBufSize: " << StubBufSizedo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dyld")) { dbgs() << "emitSection SectionID: " <<
SectionID << " Name: " << Name << " obj addr: "
<< format("%p", data.data()) << " new addr: 0" <<
" DataSize: " << DataSize << " StubBufSize: " <<
StubBufSize << " Allocate: " << Allocate <<
"\n"; } } while (false)
867 << " Allocate: " << Allocate << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dyld")) { dbgs() << "emitSection SectionID: " <<
SectionID << " Name: " << Name << " obj addr: "
<< format("%p", data.data()) << " new addr: 0" <<
" DataSize: " << DataSize << " StubBufSize: " <<
StubBufSize << " Allocate: " << Allocate <<
"\n"; } } while (false)
;
868 }
869
870 Sections.push_back(
871 SectionEntry(Name, Addr, DataSize, Allocate, (uintptr_t)pData));
872
873 // Debug info sections are linked as if their load address was zero
874 if (!IsRequired)
875 Sections.back().setLoadAddress(0);
876
877 return SectionID;
878}
879
880Expected<unsigned>
881RuntimeDyldImpl::findOrEmitSection(const ObjectFile &Obj,
882 const SectionRef &Section,
883 bool IsCode,
884 ObjSectionToIDMap &LocalSections) {
885
886 unsigned SectionID = 0;
887 ObjSectionToIDMap::iterator i = LocalSections.find(Section);
888 if (i != LocalSections.end())
889 SectionID = i->second;
890 else {
891 if (auto SectionIDOrErr = emitSection(Obj, Section, IsCode))
892 SectionID = *SectionIDOrErr;
893 else
894 return SectionIDOrErr.takeError();
895 LocalSections[Section] = SectionID;
896 }
897 return SectionID;
898}
899
900void RuntimeDyldImpl::addRelocationForSection(const RelocationEntry &RE,
901 unsigned SectionID) {
902 Relocations[SectionID].push_back(RE);
903}
904
905void RuntimeDyldImpl::addRelocationForSymbol(const RelocationEntry &RE,
906 StringRef SymbolName) {
907 // Relocation by symbol. If the symbol is found in the global symbol table,
908 // create an appropriate section relocation. Otherwise, add it to
909 // ExternalSymbolRelocations.
910 RTDyldSymbolTable::const_iterator Loc = GlobalSymbolTable.find(SymbolName);
911 if (Loc == GlobalSymbolTable.end()) {
912 ExternalSymbolRelocations[SymbolName].push_back(RE);
913 } else {
914 // Copy the RE since we want to modify its addend.
915 RelocationEntry RECopy = RE;
916 const auto &SymInfo = Loc->second;
917 RECopy.Addend += SymInfo.getOffset();
918 Relocations[SymInfo.getSectionID()].push_back(RECopy);
919 }
920}
921
922uint8_t *RuntimeDyldImpl::createStubFunction(uint8_t *Addr,
923 unsigned AbiVariant) {
924 if (Arch == Triple::aarch64 || Arch == Triple::aarch64_be ||
925 Arch == Triple::aarch64_32) {
926 // This stub has to be able to access the full address space,
927 // since symbol lookup won't necessarily find a handy, in-range,
928 // PLT stub for functions which could be anywhere.
929 // Stub can use ip0 (== x16) to calculate address
930 writeBytesUnaligned(0xd2e00010, Addr, 4); // movz ip0, #:abs_g3:<addr>
931 writeBytesUnaligned(0xf2c00010, Addr+4, 4); // movk ip0, #:abs_g2_nc:<addr>
932 writeBytesUnaligned(0xf2a00010, Addr+8, 4); // movk ip0, #:abs_g1_nc:<addr>
933 writeBytesUnaligned(0xf2800010, Addr+12, 4); // movk ip0, #:abs_g0_nc:<addr>
934 writeBytesUnaligned(0xd61f0200, Addr+16, 4); // br ip0
935
936 return Addr;
937 } else if (Arch == Triple::arm || Arch == Triple::armeb) {
938 // TODO: There is only ARM far stub now. We should add the Thumb stub,
939 // and stubs for branches Thumb - ARM and ARM - Thumb.
940 writeBytesUnaligned(0xe51ff004, Addr, 4); // ldr pc, [pc, #-4]
941 return Addr + 4;
942 } else if (IsMipsO32ABI || IsMipsN32ABI) {
943 // 0: 3c190000 lui t9,%hi(addr).
944 // 4: 27390000 addiu t9,t9,%lo(addr).
945 // 8: 03200008 jr t9.
946 // c: 00000000 nop.
947 const unsigned LuiT9Instr = 0x3c190000, AdduiT9Instr = 0x27390000;
948 const unsigned NopInstr = 0x0;
949 unsigned JrT9Instr = 0x03200008;
950 if ((AbiVariant & ELF::EF_MIPS_ARCH) == ELF::EF_MIPS_ARCH_32R6 ||
951 (AbiVariant & ELF::EF_MIPS_ARCH) == ELF::EF_MIPS_ARCH_64R6)
952 JrT9Instr = 0x03200009;
953
954 writeBytesUnaligned(LuiT9Instr, Addr, 4);
955 writeBytesUnaligned(AdduiT9Instr, Addr + 4, 4);
956 writeBytesUnaligned(JrT9Instr, Addr + 8, 4);
957 writeBytesUnaligned(NopInstr, Addr + 12, 4);
958 return Addr;
959 } else if (IsMipsN64ABI) {
960 // 0: 3c190000 lui t9,%highest(addr).
961 // 4: 67390000 daddiu t9,t9,%higher(addr).
962 // 8: 0019CC38 dsll t9,t9,16.
963 // c: 67390000 daddiu t9,t9,%hi(addr).
964 // 10: 0019CC38 dsll t9,t9,16.
965 // 14: 67390000 daddiu t9,t9,%lo(addr).
966 // 18: 03200008 jr t9.
967 // 1c: 00000000 nop.
968 const unsigned LuiT9Instr = 0x3c190000, DaddiuT9Instr = 0x67390000,
969 DsllT9Instr = 0x19CC38;
970 const unsigned NopInstr = 0x0;
971 unsigned JrT9Instr = 0x03200008;
972 if ((AbiVariant & ELF::EF_MIPS_ARCH) == ELF::EF_MIPS_ARCH_64R6)
973 JrT9Instr = 0x03200009;
974
975 writeBytesUnaligned(LuiT9Instr, Addr, 4);
976 writeBytesUnaligned(DaddiuT9Instr, Addr + 4, 4);
977 writeBytesUnaligned(DsllT9Instr, Addr + 8, 4);
978 writeBytesUnaligned(DaddiuT9Instr, Addr + 12, 4);
979 writeBytesUnaligned(DsllT9Instr, Addr + 16, 4);
980 writeBytesUnaligned(DaddiuT9Instr, Addr + 20, 4);
981 writeBytesUnaligned(JrT9Instr, Addr + 24, 4);
982 writeBytesUnaligned(NopInstr, Addr + 28, 4);
983 return Addr;
984 } else if (Arch == Triple::ppc64 || Arch == Triple::ppc64le) {
985 // Depending on which version of the ELF ABI is in use, we need to
986 // generate one of two variants of the stub. They both start with
987 // the same sequence to load the target address into r12.
988 writeInt32BE(Addr, 0x3D800000); // lis r12, highest(addr)
989 writeInt32BE(Addr+4, 0x618C0000); // ori r12, higher(addr)
990 writeInt32BE(Addr+8, 0x798C07C6); // sldi r12, r12, 32
991 writeInt32BE(Addr+12, 0x658C0000); // oris r12, r12, h(addr)
992 writeInt32BE(Addr+16, 0x618C0000); // ori r12, r12, l(addr)
993 if (AbiVariant == 2) {
994 // PowerPC64 stub ELFv2 ABI: The address points to the function itself.
995 // The address is already in r12 as required by the ABI. Branch to it.
996 writeInt32BE(Addr+20, 0xF8410018); // std r2, 24(r1)
997 writeInt32BE(Addr+24, 0x7D8903A6); // mtctr r12
998 writeInt32BE(Addr+28, 0x4E800420); // bctr
999 } else {
1000 // PowerPC64 stub ELFv1 ABI: The address points to a function descriptor.
1001 // Load the function address on r11 and sets it to control register. Also
1002 // loads the function TOC in r2 and environment pointer to r11.
1003 writeInt32BE(Addr+20, 0xF8410028); // std r2, 40(r1)
1004 writeInt32BE(Addr+24, 0xE96C0000); // ld r11, 0(r12)
1005 writeInt32BE(Addr+28, 0xE84C0008); // ld r2, 0(r12)
1006 writeInt32BE(Addr+32, 0x7D6903A6); // mtctr r11
1007 writeInt32BE(Addr+36, 0xE96C0010); // ld r11, 16(r2)
1008 writeInt32BE(Addr+40, 0x4E800420); // bctr
1009 }
1010 return Addr;
1011 } else if (Arch == Triple::systemz) {
1012 writeInt16BE(Addr, 0xC418); // lgrl %r1,.+8
1013 writeInt16BE(Addr+2, 0x0000);
1014 writeInt16BE(Addr+4, 0x0004);
1015 writeInt16BE(Addr+6, 0x07F1); // brc 15,%r1
1016 // 8-byte address stored at Addr + 8
1017 return Addr;
1018 } else if (Arch == Triple::x86_64) {
1019 *Addr = 0xFF; // jmp
1020 *(Addr+1) = 0x25; // rip
1021 // 32-bit PC-relative address of the GOT entry will be stored at Addr+2
1022 } else if (Arch == Triple::x86) {
1023 *Addr = 0xE9; // 32-bit pc-relative jump.
1024 }
1025 return Addr;
1026}
1027
1028// Assign an address to a symbol name and resolve all the relocations
1029// associated with it.
1030void RuntimeDyldImpl::reassignSectionAddress(unsigned SectionID,
1031 uint64_t Addr) {
1032 // The address to use for relocation resolution is not
1033 // the address of the local section buffer. We must be doing
1034 // a remote execution environment of some sort. Relocations can't
1035 // be applied until all the sections have been moved. The client must
1036 // trigger this with a call to MCJIT::finalize() or
1037 // RuntimeDyld::resolveRelocations().
1038 //
1039 // Addr is a uint64_t because we can't assume the pointer width
1040 // of the target is the same as that of the host. Just use a generic
1041 // "big enough" type.
1042 LLVM_DEBUG(do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dyld")) { dbgs() << "Reassigning address for section "
<< SectionID << " (" << Sections[SectionID
].getName() << "): " << format("0x%016" "l" "x", Sections
[SectionID].getLoadAddress()) << " -> " << format
("0x%016" "l" "x", Addr) << "\n"; } } while (false)
1043 dbgs() << "Reassigning address for section " << SectionID << " ("do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dyld")) { dbgs() << "Reassigning address for section "
<< SectionID << " (" << Sections[SectionID
].getName() << "): " << format("0x%016" "l" "x", Sections
[SectionID].getLoadAddress()) << " -> " << format
("0x%016" "l" "x", Addr) << "\n"; } } while (false)
1044 << Sections[SectionID].getName() << "): "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dyld")) { dbgs() << "Reassigning address for section "
<< SectionID << " (" << Sections[SectionID
].getName() << "): " << format("0x%016" "l" "x", Sections
[SectionID].getLoadAddress()) << " -> " << format
("0x%016" "l" "x", Addr) << "\n"; } } while (false)
1045 << format("0x%016" PRIx64, Sections[SectionID].getLoadAddress())do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dyld")) { dbgs() << "Reassigning address for section "
<< SectionID << " (" << Sections[SectionID
].getName() << "): " << format("0x%016" "l" "x", Sections
[SectionID].getLoadAddress()) << " -> " << format
("0x%016" "l" "x", Addr) << "\n"; } } while (false)
1046 << " -> " << format("0x%016" PRIx64, Addr) << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dyld")) { dbgs() << "Reassigning address for section "
<< SectionID << " (" << Sections[SectionID
].getName() << "): " << format("0x%016" "l" "x", Sections
[SectionID].getLoadAddress()) << " -> " << format
("0x%016" "l" "x", Addr) << "\n"; } } while (false)
;
1047 Sections[SectionID].setLoadAddress(Addr);
1048}
1049
1050void RuntimeDyldImpl::resolveRelocationList(const RelocationList &Relocs,
1051 uint64_t Value) {
1052 for (unsigned i = 0, e = Relocs.size(); i != e; ++i) {
1053 const RelocationEntry &RE = Relocs[i];
1054 // Ignore relocations for sections that were not loaded
1055 if (Sections[RE.SectionID].getAddress() == nullptr)
1056 continue;
1057 resolveRelocation(RE, Value);
1058 }
1059}
1060
1061void RuntimeDyldImpl::applyExternalSymbolRelocations(
1062 const StringMap<JITEvaluatedSymbol> ExternalSymbolMap) {
1063 while (!ExternalSymbolRelocations.empty()) {
1064
1065 StringMap<RelocationList>::iterator i = ExternalSymbolRelocations.begin();
1066
1067 StringRef Name = i->first();
1068 if (Name.size() == 0) {
1069 // This is an absolute symbol, use an address of zero.
1070 LLVM_DEBUG(dbgs() << "Resolving absolute relocations."do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dyld")) { dbgs() << "Resolving absolute relocations."
<< "\n"; } } while (false)
1071 << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dyld")) { dbgs() << "Resolving absolute relocations."
<< "\n"; } } while (false)
;
1072 RelocationList &Relocs = i->second;
1073 resolveRelocationList(Relocs, 0);
1074 } else {
1075 uint64_t Addr = 0;
1076 JITSymbolFlags Flags;
1077 RTDyldSymbolTable::const_iterator Loc = GlobalSymbolTable.find(Name);
1078 if (Loc == GlobalSymbolTable.end()) {
1079 auto RRI = ExternalSymbolMap.find(Name);
1080 assert(RRI != ExternalSymbolMap.end() && "No result for symbol")((RRI != ExternalSymbolMap.end() && "No result for symbol"
) ? static_cast<void> (0) : __assert_fail ("RRI != ExternalSymbolMap.end() && \"No result for symbol\""
, "/build/llvm-toolchain-snapshot-10~svn374877/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp"
, 1080, __PRETTY_FUNCTION__))
;
1081 Addr = RRI->second.getAddress();
1082 Flags = RRI->second.getFlags();
1083 // The call to getSymbolAddress may have caused additional modules to
1084 // be loaded, which may have added new entries to the
1085 // ExternalSymbolRelocations map. Consquently, we need to update our
1086 // iterator. This is also why retrieval of the relocation list
1087 // associated with this symbol is deferred until below this point.
1088 // New entries may have been added to the relocation list.
1089 i = ExternalSymbolRelocations.find(Name);
1090 } else {
1091 // We found the symbol in our global table. It was probably in a
1092 // Module that we loaded previously.
1093 const auto &SymInfo = Loc->second;
1094 Addr = getSectionLoadAddress(SymInfo.getSectionID()) +
1095 SymInfo.getOffset();
1096 Flags = SymInfo.getFlags();
1097 }
1098
1099 // FIXME: Implement error handling that doesn't kill the host program!
1100 if (!Addr)
1101 report_fatal_error("Program used external function '" + Name +
1102 "' which could not be resolved!");
1103
1104 // If Resolver returned UINT64_MAX, the client wants to handle this symbol
1105 // manually and we shouldn't resolve its relocations.
1106 if (Addr != UINT64_MAX(18446744073709551615UL)) {
1107
1108 // Tweak the address based on the symbol flags if necessary.
1109 // For example, this is used by RuntimeDyldMachOARM to toggle the low bit
1110 // if the target symbol is Thumb.
1111 Addr = modifyAddressBasedOnFlags(Addr, Flags);
1112
1113 LLVM_DEBUG(dbgs() << "Resolving relocations Name: " << Name << "\t"do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dyld")) { dbgs() << "Resolving relocations Name: " <<
Name << "\t" << format("0x%lx", Addr) << "\n"
; } } while (false)
1114 << format("0x%lx", Addr) << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("dyld")) { dbgs() << "Resolving relocations Name: " <<
Name << "\t" << format("0x%lx", Addr) << "\n"
; } } while (false)
;
1115 // This list may have been updated when we called getSymbolAddress, so
1116 // don't change this code to get the list earlier.
1117 RelocationList &Relocs = i->second;
1118 resolveRelocationList(Relocs, Addr);
1119 }
1120 }
1121
1122 ExternalSymbolRelocations.erase(i);
1123 }
1124}
1125
1126Error RuntimeDyldImpl::resolveExternalSymbols() {
1127 StringMap<JITEvaluatedSymbol> ExternalSymbolMap;
1128
1129 // Resolution can trigger emission of more symbols, so iterate until
1130 // we've resolved *everything*.
1131 {
1132 JITSymbolResolver::LookupSet ResolvedSymbols;
1133
1134 while (true) {
1135 JITSymbolResolver::LookupSet NewSymbols;
1136
1137 for (auto &RelocKV : ExternalSymbolRelocations) {
1138 StringRef Name = RelocKV.first();
1139 if (!Name.empty() && !GlobalSymbolTable.count(Name) &&
1140 !ResolvedSymbols.count(Name))
1141 NewSymbols.insert(Name);
1142 }
1143
1144 if (NewSymbols.empty())
1145 break;
1146
1147#ifdef _MSC_VER
1148 using ExpectedLookupResult =
1149 MSVCPExpected<JITSymbolResolver::LookupResult>;
1150#else
1151 using ExpectedLookupResult = Expected<JITSymbolResolver::LookupResult>;
1152#endif
1153
1154 auto NewSymbolsP = std::make_shared<std::promise<ExpectedLookupResult>>();
1155 auto NewSymbolsF = NewSymbolsP->get_future();
1156 Resolver.lookup(NewSymbols,
1157 [=](Expected<JITSymbolResolver::LookupResult> Result) {
1158 NewSymbolsP->set_value(std::move(Result));
1159 });
1160
1161 auto NewResolverResults = NewSymbolsF.get();
1162
1163 if (!NewResolverResults)
1164 return NewResolverResults.takeError();
1165
1166 assert(NewResolverResults->size() == NewSymbols.size() &&((NewResolverResults->size() == NewSymbols.size() &&
"Should have errored on unresolved symbols") ? static_cast<
void> (0) : __assert_fail ("NewResolverResults->size() == NewSymbols.size() && \"Should have errored on unresolved symbols\""
, "/build/llvm-toolchain-snapshot-10~svn374877/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp"
, 1167, __PRETTY_FUNCTION__))
1167 "Should have errored on unresolved symbols")((NewResolverResults->size() == NewSymbols.size() &&
"Should have errored on unresolved symbols") ? static_cast<
void> (0) : __assert_fail ("NewResolverResults->size() == NewSymbols.size() && \"Should have errored on unresolved symbols\""
, "/build/llvm-toolchain-snapshot-10~svn374877/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp"
, 1167, __PRETTY_FUNCTION__))
;
1168
1169 for (auto &RRKV : *NewResolverResults) {
1170 assert(!ResolvedSymbols.count(RRKV.first) && "Redundant resolution?")((!ResolvedSymbols.count(RRKV.first) && "Redundant resolution?"
) ? static_cast<void> (0) : __assert_fail ("!ResolvedSymbols.count(RRKV.first) && \"Redundant resolution?\""
, "/build/llvm-toolchain-snapshot-10~svn374877/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp"
, 1170, __PRETTY_FUNCTION__))
;
1171 ExternalSymbolMap.insert(RRKV);
1172 ResolvedSymbols.insert(RRKV.first);
1173 }
1174 }
1175 }
1176
1177 applyExternalSymbolRelocations(ExternalSymbolMap);
1178
1179 return Error::success();
1180}
1181
1182void RuntimeDyldImpl::finalizeAsync(
1183 std::unique_ptr<RuntimeDyldImpl> This,
1184 unique_function<void(Error)> OnEmitted,
1185 std::unique_ptr<MemoryBuffer> UnderlyingBuffer) {
1186
1187 auto SharedThis = std::shared_ptr<RuntimeDyldImpl>(std::move(This));
1188 auto PostResolveContinuation =
1189 [SharedThis, OnEmitted = std::move(OnEmitted),
6
Calling implicit move constructor
7
Calling move constructor for 'unique_function<void (llvm::Error)>'
10
Returning from move constructor for 'unique_function<void (llvm::Error)>'
11
Returning from move constructor
1190 UnderlyingBuffer = std::move(UnderlyingBuffer)](
1191 Expected<JITSymbolResolver::LookupResult> Result) mutable {
1192 if (!Result) {
15
Taking true branch
1193 OnEmitted(Result.takeError());
16
Calling 'unique_function::operator()'
1194 return;
1195 }
1196
1197 /// Copy the result into a StringMap, where the keys are held by value.
1198 StringMap<JITEvaluatedSymbol> Resolved;
1199 for (auto &KV : *Result)
1200 Resolved[KV.first] = KV.second;
1201
1202 SharedThis->applyExternalSymbolRelocations(Resolved);
1203 SharedThis->resolveLocalRelocations();
1204 SharedThis->registerEHFrames();
1205 std::string ErrMsg;
1206 if (SharedThis->MemMgr.finalizeMemory(&ErrMsg))
1207 OnEmitted(make_error<StringError>(std::move(ErrMsg),
1208 inconvertibleErrorCode()));
1209 else
1210 OnEmitted(Error::success());
1211 };
1212
1213 JITSymbolResolver::LookupSet Symbols;
1214
1215 for (auto &RelocKV : SharedThis->ExternalSymbolRelocations) {
1216 StringRef Name = RelocKV.first();
1217 assert(!Name.empty() && "Symbol has no name?")((!Name.empty() && "Symbol has no name?") ? static_cast
<void> (0) : __assert_fail ("!Name.empty() && \"Symbol has no name?\""
, "/build/llvm-toolchain-snapshot-10~svn374877/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp"
, 1217, __PRETTY_FUNCTION__))
;
1218 assert(!SharedThis->GlobalSymbolTable.count(Name) &&((!SharedThis->GlobalSymbolTable.count(Name) && "Name already processed. RuntimeDyld instances can not be re-used "
"when finalizing with finalizeAsync.") ? static_cast<void
> (0) : __assert_fail ("!SharedThis->GlobalSymbolTable.count(Name) && \"Name already processed. RuntimeDyld instances can not be re-used \" \"when finalizing with finalizeAsync.\""
, "/build/llvm-toolchain-snapshot-10~svn374877/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp"
, 1220, __PRETTY_FUNCTION__))
1219 "Name already processed. RuntimeDyld instances can not be re-used "((!SharedThis->GlobalSymbolTable.count(Name) && "Name already processed. RuntimeDyld instances can not be re-used "
"when finalizing with finalizeAsync.") ? static_cast<void
> (0) : __assert_fail ("!SharedThis->GlobalSymbolTable.count(Name) && \"Name already processed. RuntimeDyld instances can not be re-used \" \"when finalizing with finalizeAsync.\""
, "/build/llvm-toolchain-snapshot-10~svn374877/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp"
, 1220, __PRETTY_FUNCTION__))
1220 "when finalizing with finalizeAsync.")((!SharedThis->GlobalSymbolTable.count(Name) && "Name already processed. RuntimeDyld instances can not be re-used "
"when finalizing with finalizeAsync.") ? static_cast<void
> (0) : __assert_fail ("!SharedThis->GlobalSymbolTable.count(Name) && \"Name already processed. RuntimeDyld instances can not be re-used \" \"when finalizing with finalizeAsync.\""
, "/build/llvm-toolchain-snapshot-10~svn374877/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp"
, 1220, __PRETTY_FUNCTION__))
;
1221 Symbols.insert(Name);
1222 }
1223
1224 if (!Symbols.empty()) {
12
Assuming the condition is false
13
Taking false branch
1225 SharedThis->Resolver.lookup(Symbols, std::move(PostResolveContinuation));
1226 } else
1227 PostResolveContinuation(std::map<StringRef, JITEvaluatedSymbol>());
14
Calling 'operator()'
1228}
1229
1230//===----------------------------------------------------------------------===//
1231// RuntimeDyld class implementation
1232
1233uint64_t RuntimeDyld::LoadedObjectInfo::getSectionLoadAddress(
1234 const object::SectionRef &Sec) const {
1235
1236 auto I = ObjSecToIDMap.find(Sec);
1237 if (I != ObjSecToIDMap.end())
1238 return RTDyld.Sections[I->second].getLoadAddress();
1239
1240 return 0;
1241}
1242
1243void RuntimeDyld::MemoryManager::anchor() {}
1244void JITSymbolResolver::anchor() {}
1245void LegacyJITSymbolResolver::anchor() {}
1246
1247RuntimeDyld::RuntimeDyld(RuntimeDyld::MemoryManager &MemMgr,
1248 JITSymbolResolver &Resolver)
1249 : MemMgr(MemMgr), Resolver(Resolver) {
1250 // FIXME: There's a potential issue lurking here if a single instance of
1251 // RuntimeDyld is used to load multiple objects. The current implementation
1252 // associates a single memory manager with a RuntimeDyld instance. Even
1253 // though the public class spawns a new 'impl' instance for each load,
1254 // they share a single memory manager. This can become a problem when page
1255 // permissions are applied.
1256 Dyld = nullptr;
1257 ProcessAllSections = false;
1258}
1259
1260RuntimeDyld::~RuntimeDyld() {}
1261
1262static std::unique_ptr<RuntimeDyldCOFF>
1263createRuntimeDyldCOFF(
1264 Triple::ArchType Arch, RuntimeDyld::MemoryManager &MM,
1265 JITSymbolResolver &Resolver, bool ProcessAllSections,
1266 RuntimeDyld::NotifyStubEmittedFunction NotifyStubEmitted) {
1267 std::unique_ptr<RuntimeDyldCOFF> Dyld =
1268 RuntimeDyldCOFF::create(Arch, MM, Resolver);
1269 Dyld->setProcessAllSections(ProcessAllSections);
1270 Dyld->setNotifyStubEmitted(std::move(NotifyStubEmitted));
1271 return Dyld;
1272}
1273
1274static std::unique_ptr<RuntimeDyldELF>
1275createRuntimeDyldELF(Triple::ArchType Arch, RuntimeDyld::MemoryManager &MM,
1276 JITSymbolResolver &Resolver, bool ProcessAllSections,
1277 RuntimeDyld::NotifyStubEmittedFunction NotifyStubEmitted) {
1278 std::unique_ptr<RuntimeDyldELF> Dyld =
1279 RuntimeDyldELF::create(Arch, MM, Resolver);
1280 Dyld->setProcessAllSections(ProcessAllSections);
1281 Dyld->setNotifyStubEmitted(std::move(NotifyStubEmitted));
1282 return Dyld;
1283}
1284
1285static std::unique_ptr<RuntimeDyldMachO>
1286createRuntimeDyldMachO(
1287 Triple::ArchType Arch, RuntimeDyld::MemoryManager &MM,
1288 JITSymbolResolver &Resolver,
1289 bool ProcessAllSections,
1290 RuntimeDyld::NotifyStubEmittedFunction NotifyStubEmitted) {
1291 std::unique_ptr<RuntimeDyldMachO> Dyld =
1292 RuntimeDyldMachO::create(Arch, MM, Resolver);
1293 Dyld->setProcessAllSections(ProcessAllSections);
1294 Dyld->setNotifyStubEmitted(std::move(NotifyStubEmitted));
1295 return Dyld;
1296}
1297
1298std::unique_ptr<RuntimeDyld::LoadedObjectInfo>
1299RuntimeDyld::loadObject(const ObjectFile &Obj) {
1300 if (!Dyld) {
1301 if (Obj.isELF())
1302 Dyld =
1303 createRuntimeDyldELF(static_cast<Triple::ArchType>(Obj.getArch()),
1304 MemMgr, Resolver, ProcessAllSections,
1305 std::move(NotifyStubEmitted));
1306 else if (Obj.isMachO())
1307 Dyld = createRuntimeDyldMachO(
1308 static_cast<Triple::ArchType>(Obj.getArch()), MemMgr, Resolver,
1309 ProcessAllSections, std::move(NotifyStubEmitted));
1310 else if (Obj.isCOFF())
1311 Dyld = createRuntimeDyldCOFF(
1312 static_cast<Triple::ArchType>(Obj.getArch()), MemMgr, Resolver,
1313 ProcessAllSections, std::move(NotifyStubEmitted));
1314 else
1315 report_fatal_error("Incompatible object format!");
1316 }
1317
1318 if (!Dyld->isCompatibleFile(Obj))
1319 report_fatal_error("Incompatible object format!");
1320
1321 auto LoadedObjInfo = Dyld->loadObject(Obj);
1322 MemMgr.notifyObjectLoaded(*this, Obj);
1323 return LoadedObjInfo;
1324}
1325
1326void *RuntimeDyld::getSymbolLocalAddress(StringRef Name) const {
1327 if (!Dyld)
1328 return nullptr;
1329 return Dyld->getSymbolLocalAddress(Name);
1330}
1331
1332unsigned RuntimeDyld::getSymbolSectionID(StringRef Name) const {
1333 assert(Dyld && "No RuntimeDyld instance attached")((Dyld && "No RuntimeDyld instance attached") ? static_cast
<void> (0) : __assert_fail ("Dyld && \"No RuntimeDyld instance attached\""
, "/build/llvm-toolchain-snapshot-10~svn374877/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp"
, 1333, __PRETTY_FUNCTION__))
;
1334 return Dyld->getSymbolSectionID(Name);
1335}
1336
1337JITEvaluatedSymbol RuntimeDyld::getSymbol(StringRef Name) const {
1338 if (!Dyld)
1339 return nullptr;
1340 return Dyld->getSymbol(Name);
1341}
1342
1343std::map<StringRef, JITEvaluatedSymbol> RuntimeDyld::getSymbolTable() const {
1344 if (!Dyld)
1345 return std::map<StringRef, JITEvaluatedSymbol>();
1346 return Dyld->getSymbolTable();
1347}
1348
1349void RuntimeDyld::resolveRelocations() { Dyld->resolveRelocations(); }
1350
1351void RuntimeDyld::reassignSectionAddress(unsigned SectionID, uint64_t Addr) {
1352 Dyld->reassignSectionAddress(SectionID, Addr);
1353}
1354
1355void RuntimeDyld::mapSectionAddress(const void *LocalAddress,
1356 uint64_t TargetAddress) {
1357 Dyld->mapSectionAddress(LocalAddress, TargetAddress);
1358}
1359
1360bool RuntimeDyld::hasError() { return Dyld->hasError(); }
1361
1362StringRef RuntimeDyld::getErrorString() { return Dyld->getErrorString(); }
1363
1364void RuntimeDyld::finalizeWithMemoryManagerLocking() {
1365 bool MemoryFinalizationLocked = MemMgr.FinalizationLocked;
1366 MemMgr.FinalizationLocked = true;
1367 resolveRelocations();
1368 registerEHFrames();
1369 if (!MemoryFinalizationLocked) {
1370 MemMgr.finalizeMemory();
1371 MemMgr.FinalizationLocked = false;
1372 }
1373}
1374
1375StringRef RuntimeDyld::getSectionContent(unsigned SectionID) const {
1376 assert(Dyld && "No Dyld instance attached")((Dyld && "No Dyld instance attached") ? static_cast<
void> (0) : __assert_fail ("Dyld && \"No Dyld instance attached\""
, "/build/llvm-toolchain-snapshot-10~svn374877/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp"
, 1376, __PRETTY_FUNCTION__))
;
1377 return Dyld->getSectionContent(SectionID);
1378}
1379
1380uint64_t RuntimeDyld::getSectionLoadAddress(unsigned SectionID) const {
1381 assert(Dyld && "No Dyld instance attached")((Dyld && "No Dyld instance attached") ? static_cast<
void> (0) : __assert_fail ("Dyld && \"No Dyld instance attached\""
, "/build/llvm-toolchain-snapshot-10~svn374877/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp"
, 1381, __PRETTY_FUNCTION__))
;
1382 return Dyld->getSectionLoadAddress(SectionID);
1383}
1384
1385void RuntimeDyld::registerEHFrames() {
1386 if (Dyld)
1387 Dyld->registerEHFrames();
1388}
1389
1390void RuntimeDyld::deregisterEHFrames() {
1391 if (Dyld)
1392 Dyld->deregisterEHFrames();
1393}
1394// FIXME: Kill this with fire once we have a new JIT linker: this is only here
1395// so that we can re-use RuntimeDyld's implementation without twisting the
1396// interface any further for ORC's purposes.
1397void jitLinkForORC(object::ObjectFile &Obj,
1398 std::unique_ptr<MemoryBuffer> UnderlyingBuffer,
1399 RuntimeDyld::MemoryManager &MemMgr,
1400 JITSymbolResolver &Resolver, bool ProcessAllSections,
1401 unique_function<Error(
1402 std::unique_ptr<RuntimeDyld::LoadedObjectInfo> LoadedObj,
1403 std::map<StringRef, JITEvaluatedSymbol>)>
1404 OnLoaded,
1405 unique_function<void(Error)> OnEmitted) {
1406
1407 RuntimeDyld RTDyld(MemMgr, Resolver);
1408 RTDyld.setProcessAllSections(ProcessAllSections);
1409
1410 auto Info = RTDyld.loadObject(Obj);
1411
1412 if (RTDyld.hasError()) {
1
Assuming the condition is false
2
Taking false branch
1413 OnEmitted(make_error<StringError>(RTDyld.getErrorString(),
1414 inconvertibleErrorCode()));
1415 return;
1416 }
1417
1418 if (auto Err = OnLoaded(std::move(Info), RTDyld.getSymbolTable()))
3
Assuming the condition is false
4
Taking false branch
1419 OnEmitted(std::move(Err));
1420
1421 RuntimeDyldImpl::finalizeAsync(std::move(RTDyld.Dyld), std::move(OnEmitted),
5
Calling 'RuntimeDyldImpl::finalizeAsync'
1422 std::move(UnderlyingBuffer));
1423}
1424
1425} // end namespace llvm

/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/ADT/FunctionExtras.h

1//===- FunctionExtras.h - Function type erasure utilities -------*- C++ -*-===//
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/// \file
9/// This file provides a collection of function (or more generally, callable)
10/// type erasure utilities supplementing those provided by the standard library
11/// in `<function>`.
12///
13/// It provides `unique_function`, which works like `std::function` but supports
14/// move-only callable objects.
15///
16/// Future plans:
17/// - Add a `function` that provides const, volatile, and ref-qualified support,
18/// which doesn't work with `std::function`.
19/// - Provide support for specifying multiple signatures to type erase callable
20/// objects with an overload set, such as those produced by generic lambdas.
21/// - Expand to include a copyable utility that directly replaces std::function
22/// but brings the above improvements.
23///
24/// Note that LLVM's utilities are greatly simplified by not supporting
25/// allocators.
26///
27/// If the standard library ever begins to provide comparable facilities we can
28/// consider switching to those.
29///
30//===----------------------------------------------------------------------===//
31
32#ifndef LLVM_ADT_FUNCTION_EXTRAS_H
33#define LLVM_ADT_FUNCTION_EXTRAS_H
34
35#include "llvm/ADT/PointerIntPair.h"
36#include "llvm/ADT/PointerUnion.h"
37#include "llvm/Support/type_traits.h"
38#include <memory>
39
40namespace llvm {
41
42template <typename FunctionT> class unique_function;
43
44template <typename ReturnT, typename... ParamTs>
45class unique_function<ReturnT(ParamTs...)> {
46 static constexpr size_t InlineStorageSize = sizeof(void *) * 3;
47
48 // MSVC has a bug and ICEs if we give it a particular dependent value
49 // expression as part of the `std::conditional` below. To work around this,
50 // we build that into a template struct's constexpr bool.
51 template <typename T> struct IsSizeLessThanThresholdT {
52 static constexpr bool value = sizeof(T) <= (2 * sizeof(void *));
53 };
54
55 // Provide a type function to map parameters that won't observe extra copies
56 // or moves and which are small enough to likely pass in register to values
57 // and all other types to l-value reference types. We use this to compute the
58 // types used in our erased call utility to minimize copies and moves unless
59 // doing so would force things unnecessarily into memory.
60 //
61 // The heuristic used is related to common ABI register passing conventions.
62 // It doesn't have to be exact though, and in one way it is more strict
63 // because we want to still be able to observe either moves *or* copies.
64 template <typename T>
65 using AdjustedParamT = typename std::conditional<
66 !std::is_reference<T>::value &&
67 llvm::is_trivially_copy_constructible<T>::value &&
68 llvm::is_trivially_move_constructible<T>::value &&
69 IsSizeLessThanThresholdT<T>::value,
70 T, T &>::type;
71
72 // The type of the erased function pointer we use as a callback to dispatch to
73 // the stored callable when it is trivial to move and destroy.
74 using CallPtrT = ReturnT (*)(void *CallableAddr,
75 AdjustedParamT<ParamTs>... Params);
76 using MovePtrT = void (*)(void *LHSCallableAddr, void *RHSCallableAddr);
77 using DestroyPtrT = void (*)(void *CallableAddr);
78
79 /// A struct to hold a single trivial callback with sufficient alignment for
80 /// our bitpacking.
81 struct alignas(8) TrivialCallback {
82 CallPtrT CallPtr;
83 };
84
85 /// A struct we use to aggregate three callbacks when we need full set of
86 /// operations.
87 struct alignas(8) NonTrivialCallbacks {
88 CallPtrT CallPtr;
89 MovePtrT MovePtr;
90 DestroyPtrT DestroyPtr;
91 };
92
93 // Create a pointer union between either a pointer to a static trivial call
94 // pointer in a struct or a pointer to a static struct of the call, move, and
95 // destroy pointers.
96 using CallbackPointerUnionT =
97 PointerUnion<TrivialCallback *, NonTrivialCallbacks *>;
98
99 // The main storage buffer. This will either have a pointer to out-of-line
100 // storage or an inline buffer storing the callable.
101 union StorageUnionT {
102 // For out-of-line storage we keep a pointer to the underlying storage and
103 // the size. This is enough to deallocate the memory.
104 struct OutOfLineStorageT {
105 void *StoragePtr;
106 size_t Size;
107 size_t Alignment;
108 } OutOfLineStorage;
109 static_assert(
110 sizeof(OutOfLineStorageT) <= InlineStorageSize,
111 "Should always use all of the out-of-line storage for inline storage!");
112
113 // For in-line storage, we just provide an aligned character buffer. We
114 // provide three pointers worth of storage here.
115 typename std::aligned_storage<InlineStorageSize, alignof(void *)>::type
116 InlineStorage;
117 } StorageUnion;
118
119 // A compressed pointer to either our dispatching callback or our table of
120 // dispatching callbacks and the flag for whether the callable itself is
121 // stored inline or not.
122 PointerIntPair<CallbackPointerUnionT, 1, bool> CallbackAndInlineFlag;
123
124 bool isInlineStorage() const { return CallbackAndInlineFlag.getInt(); }
125
126 bool isTrivialCallback() const {
127 return CallbackAndInlineFlag.getPointer().template is<TrivialCallback *>();
128 }
129
130 CallPtrT getTrivialCallback() const {
131 return CallbackAndInlineFlag.getPointer().template get<TrivialCallback *>()->CallPtr;
132 }
133
134 NonTrivialCallbacks *getNonTrivialCallbacks() const {
135 return CallbackAndInlineFlag.getPointer()
136 .template get<NonTrivialCallbacks *>();
137 }
138
139 void *getInlineStorage() { return &StorageUnion.InlineStorage; }
140
141 void *getOutOfLineStorage() {
142 return StorageUnion.OutOfLineStorage.StoragePtr;
20
Undefined or garbage value returned to caller
143 }
144 size_t getOutOfLineStorageSize() const {
145 return StorageUnion.OutOfLineStorage.Size;
146 }
147 size_t getOutOfLineStorageAlignment() const {
148 return StorageUnion.OutOfLineStorage.Alignment;
149 }
150
151 void setOutOfLineStorage(void *Ptr, size_t Size, size_t Alignment) {
152 StorageUnion.OutOfLineStorage = {Ptr, Size, Alignment};
153 }
154
155 template <typename CallableT>
156 static ReturnT CallImpl(void *CallableAddr, AdjustedParamT<ParamTs>... Params) {
157 return (*reinterpret_cast<CallableT *>(CallableAddr))(
158 std::forward<ParamTs>(Params)...);
159 }
160
161 template <typename CallableT>
162 static void MoveImpl(void *LHSCallableAddr, void *RHSCallableAddr) noexcept {
163 new (LHSCallableAddr)
164 CallableT(std::move(*reinterpret_cast<CallableT *>(RHSCallableAddr)));
165 }
166
167 template <typename CallableT>
168 static void DestroyImpl(void *CallableAddr) noexcept {
169 reinterpret_cast<CallableT *>(CallableAddr)->~CallableT();
170 }
171
172public:
173 unique_function() = default;
174 unique_function(std::nullptr_t /*null_callable*/) {}
175
176 ~unique_function() {
177 if (!CallbackAndInlineFlag.getPointer())
178 return;
179
180 // Cache this value so we don't re-check it after type-erased operations.
181 bool IsInlineStorage = isInlineStorage();
182
183 if (!isTrivialCallback())
184 getNonTrivialCallbacks()->DestroyPtr(
185 IsInlineStorage ? getInlineStorage() : getOutOfLineStorage());
186
187 if (!IsInlineStorage)
188 deallocate_buffer(getOutOfLineStorage(), getOutOfLineStorageSize(),
189 getOutOfLineStorageAlignment());
190 }
191
192 unique_function(unique_function &&RHS) noexcept {
193 // Copy the callback and inline flag.
194 CallbackAndInlineFlag = RHS.CallbackAndInlineFlag;
195
196 // If the RHS is empty, just copying the above is sufficient.
197 if (!RHS)
8
Taking true branch
198 return;
9
Returning without writing to 'this->StorageUnion.OutOfLineStorage.StoragePtr'
199
200 if (!isInlineStorage()) {
201 // The out-of-line case is easiest to move.
202 StorageUnion.OutOfLineStorage = RHS.StorageUnion.OutOfLineStorage;
203 } else if (isTrivialCallback()) {
204 // Move is trivial, just memcpy the bytes across.
205 memcpy(getInlineStorage(), RHS.getInlineStorage(), InlineStorageSize);
206 } else {
207 // Non-trivial move, so dispatch to a type-erased implementation.
208 getNonTrivialCallbacks()->MovePtr(getInlineStorage(),
209 RHS.getInlineStorage());
210 }
211
212 // Clear the old callback and inline flag to get back to as-if-null.
213 RHS.CallbackAndInlineFlag = {};
214
215#ifndef NDEBUG
216 // In debug builds, we also scribble across the rest of the storage.
217 memset(RHS.getInlineStorage(), 0xAD, InlineStorageSize);
218#endif
219 }
220
221 unique_function &operator=(unique_function &&RHS) noexcept {
222 if (this == &RHS)
223 return *this;
224
225 // Because we don't try to provide any exception safety guarantees we can
226 // implement move assignment very simply by first destroying the current
227 // object and then move-constructing over top of it.
228 this->~unique_function();
229 new (this) unique_function(std::move(RHS));
230 return *this;
231 }
232
233 template <typename CallableT> unique_function(CallableT Callable) {
234 bool IsInlineStorage = true;
235 void *CallableAddr = getInlineStorage();
236 if (sizeof(CallableT) > InlineStorageSize ||
237 alignof(CallableT) > alignof(decltype(StorageUnion.InlineStorage))) {
238 IsInlineStorage = false;
239 // Allocate out-of-line storage. FIXME: Use an explicit alignment
240 // parameter in C++17 mode.
241 auto Size = sizeof(CallableT);
242 auto Alignment = alignof(CallableT);
243 CallableAddr = allocate_buffer(Size, Alignment);
244 setOutOfLineStorage(CallableAddr, Size, Alignment);
245 }
246
247 // Now move into the storage.
248 new (CallableAddr) CallableT(std::move(Callable));
249
250 // See if we can create a trivial callback. We need the callable to be
251 // trivially moved and trivially destroyed so that we don't have to store
252 // type erased callbacks for those operations.
253 //
254 // FIXME: We should use constexpr if here and below to avoid instantiating
255 // the non-trivial static objects when unnecessary. While the linker should
256 // remove them, it is still wasteful.
257 if (llvm::is_trivially_move_constructible<CallableT>::value &&
258 std::is_trivially_destructible<CallableT>::value) {
259 // We need to create a nicely aligned object. We use a static variable
260 // for this because it is a trivial struct.
261 static TrivialCallback Callback = { &CallImpl<CallableT> };
262
263 CallbackAndInlineFlag = {&Callback, IsInlineStorage};
264 return;
265 }
266
267 // Otherwise, we need to point at an object that contains all the different
268 // type erased behaviors needed. Create a static instance of the struct type
269 // here and then use a pointer to that.
270 static NonTrivialCallbacks Callbacks = {
271 &CallImpl<CallableT>, &MoveImpl<CallableT>, &DestroyImpl<CallableT>};
272
273 CallbackAndInlineFlag = {&Callbacks, IsInlineStorage};
274 }
275
276 ReturnT operator()(ParamTs... Params) {
277 void *CallableAddr =
278 isInlineStorage() ? getInlineStorage() : getOutOfLineStorage();
17
Assuming the condition is false
18
'?' condition is false
19
Calling 'unique_function::getOutOfLineStorage'
279
280 return (isTrivialCallback()
281 ? getTrivialCallback()
282 : getNonTrivialCallbacks()->CallPtr)(CallableAddr, Params...);
283 }
284
285 explicit operator bool() const {
286 return (bool)CallbackAndInlineFlag.getPointer();
287 }
288};
289
290} // end namespace llvm
291
292#endif // LLVM_ADT_FUNCTION_H