Bug Summary

File:lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp
Warning:line 337, column 11
2nd function call argument is an uninitialized value

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