]> git.saurik.com Git - apple/ld64.git/blob - src/ld/ld.hpp
projects / apple / ld64.git / blob
? search:


89c091b84c9449821e0f464d4ed0e10fb1280652
[apple/ld64.git] / src / ld / ld.hpp
1 /* -*- mode: C++; c-basic-offset: 4; tab-width: 4 -*-
2 *
3 * Copyright (c) 2005-2010 Apple Inc. All rights reserved.
4 *
5 * @APPLE_LICENSE_HEADER_START@
6 *
7 * This file contains Original Code and/or Modifications of Original Code
8 * as defined in and that are subject to the Apple Public Source License
9 * Version 2.0 (the 'License'). You may not use this file except in
10 * compliance with the License. Please obtain a copy of the License at
11 * http://www.opensource.apple.com/apsl/ and read it before using this
12 * file.
13 *
14 * The Original Code and all software distributed under the License are
15 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
19 * Please see the License for the specific language governing rights and
20 * limitations under the License.
21 *
22 * @APPLE_LICENSE_HEADER_END@
23 */
24
25
26 #ifndef __LD_HPP__
27 #define __LD_HPP__
28
29 #include <stdint.h>
30 #include <math.h>
31 #include <unistd.h>
32 #include <assert.h>
33
34 #include <set>
35 #include <map>
36 #include <vector>
37 #include <string>
38 #include <unordered_set>
39
40 #include "configure.h"
41
42 namespace ld {
43
44 // Forward declaration for bitcode support
45 class Bitcode;
46
47 //
48 // ld::File
49 //
50 // Abstract base class for all object or library files the linker processes.
51 //
52 // forEachAtom() iterates over the Atoms in the order they occur in the file.
53 //
54 // justInTimeforEachAtom(name) iterates over lazily created Atoms. For instance if
55 // File is a static library, justInTimeforEachAtom() will iterate over the base set
56 // of Atoms from the archive member implementing 'name'.
57 //
58 class File
59 {
60 public:
61 enum ObjcConstraint { objcConstraintNone, objcConstraintRetainRelease,
62 objcConstraintRetainReleaseOrGC, objcConstraintGC,
63 objcConstraintRetainReleaseForSimulator };
64
65 class AtomHandler {
66 public:
67 virtual ~AtomHandler() {}
68 virtual void doAtom(const class Atom&) = 0;
69 virtual void doFile(const class File&) = 0;
70 };
71
72 //
73 // ld::File::Ordinal
74 //
75 // Codifies the rules of ordering input files for symbol precedence. These are:
76 // - Input files listed on the command line are ordered according to their index in the argument list.
77 // - Input files listed in a file list are ordered first at the index of the file list argument, then
78 // by index in the file list
79 // - Input files extracted from archives are ordered using the ordinal of the archive itself plus the
80 // index of the object file within the archive
81 // - Indirect dylibs are ordered after all input files derived from the command line, in the order that
82 // they are discovered.
83 // - The LTO object file is last.
84 //
85 class Ordinal
86 {
87 private:
88 // The actual numeric ordinal. Lower values have higher precedence and a zero value is invalid.
89 // The 64 bit ordinal is broken into 4 16 bit chunks. The high 16 bits are a "partition" that
90 // is used to distinguish major ordinal groups: command line, indirect dylib, LTO.
91 // The remaining chunks are used according to the partition (see below).
92 uint64_t _ordinal;
93
94 Ordinal (uint64_t ordinal) : _ordinal(ordinal) {}
95
96 enum { kArgListPartition=0, kIndirectDylibPartition=1, kLTOPartition = 2, kLinkerOptionPartition = 2, InvalidParition=0xffff };
97 Ordinal(uint16_t partition, uint16_t majorIndex, uint16_t minorIndex, uint16_t counter) {
98 _ordinal = ((uint64_t)partition<<48) | ((uint64_t)majorIndex<<32) | ((uint64_t)minorIndex<<16) | ((uint64_t)counter<<0);
99 }
100
101 const uint16_t partition() const { return (_ordinal>>48)&0xffff; }
102 const uint16_t majorIndex() const { return (_ordinal>>32)&0xffff; }
103 const uint16_t minorIndex() const { return (_ordinal>>16)&0xffff; }
104 const uint16_t counter() const { return (_ordinal>>00)&0xffff; }
105
106 const Ordinal nextMajorIndex() const { assert(majorIndex() < 0xffff); return Ordinal(_ordinal+((uint64_t)1<<32)); }
107 const Ordinal nextMinorIndex() const { assert(minorIndex() < 0xffff); return Ordinal(_ordinal+((uint64_t)1<<16)); }
108 const Ordinal nextCounter() const { assert(counter() < 0xffff); return Ordinal(_ordinal+((uint64_t)1<<0)); }
109
110 public:
111 Ordinal() : _ordinal(0) {};
112
113 static const Ordinal NullOrdinal() { return Ordinal((uint64_t)0); }
114
115 const bool validOrdinal() const { return _ordinal != 0; }
116
117 bool operator ==(const Ordinal& rhs) const { return _ordinal == rhs._ordinal; }
118 bool operator !=(const Ordinal& rhs) const { return _ordinal != rhs._ordinal; }
119 bool operator < (const Ordinal& rhs) const { return _ordinal < rhs._ordinal; }
120 bool operator > (const Ordinal& rhs) const { return _ordinal > rhs._ordinal; }
121
122 // For ordinals derived from the command line args the partition is ArgListPartition
123 // The majorIndex is the arg index that pulls in the file, file list, or archive.
124 // The minorIndex is used for files pulled in by a file list and the value is the index of the file in the file list.
125 // The counter is used for .a files and the value is the index of the object in the archive.
126 // Thus, an object pulled in from a .a that was listed in a file list could use all three fields.
127 static const Ordinal makeArgOrdinal(uint16_t argIndex) { return Ordinal(kArgListPartition, argIndex, 0, 0); };
128 const Ordinal nextFileListOrdinal() const { return nextMinorIndex(); }
129 const Ordinal archiveOrdinalWithMemberIndex(uint16_t index) const { return Ordinal(kArgListPartition, majorIndex(), minorIndex(), index); }
130
131 // For indirect libraries the partition is IndirectDylibPartition and the counter is used or order the libraries.
132 static const ld::File::Ordinal indirectDylibBase() { return Ordinal(kIndirectDylibPartition, 0, 0, 0); }
133 const Ordinal nextIndirectDylibOrdinal() const { return nextCounter(); }
134
135 // For the LTO mach-o the partition is LTOPartition. As there is only one LTO file no other fields are needed.
136 static const ld::File::Ordinal LTOOrdinal() { return Ordinal(kLTOPartition, 0, 0, 0); }
137
138 // For linker options embedded in object files
139 static const ld::File::Ordinal linkeOptionBase() { return Ordinal(kIndirectDylibPartition, 1, 0, 0); }
140 const Ordinal nextLinkerOptionOrdinal() { nextCounter(); return *this; };
141
142 };
143
144 typedef enum { Reloc, Dylib, Archive, Other } Type;
145
146 File(const char* pth, time_t modTime, Ordinal ord, Type type)
147 : _path(pth), _modTime(modTime), _ordinal(ord), _type(type) { }
148 virtual ~File() {}
149 const char* path() const { return _path; }
150 time_t modificationTime() const{ return _modTime; }
151 Ordinal ordinal() const { return _ordinal; }
152 virtual bool forEachAtom(AtomHandler&) const = 0;
153 virtual bool justInTimeforEachAtom(const char* name, AtomHandler&) const = 0;
154 virtual ObjcConstraint objCConstraint() const { return objcConstraintNone; }
155 virtual uint8_t swiftVersion() const { return 0; }
156 virtual uint32_t cpuSubType() const { return 0; }
157 virtual uint32_t subFileCount() const { return 1; }
158 virtual uint32_t minOSVersion() const { return 0; }
159 virtual uint32_t platformLoadCommand() const { return 0; }
160 bool fileExists() const { return _modTime != 0; }
161 Type type() const { return _type; }
162 virtual Bitcode* getBitcode() const { return NULL; }
163 private:
164 const char* _path;
165 time_t _modTime;
166 const Ordinal _ordinal;
167 const Type _type;
168 };
169
170
171 //
172 // minumum OS versions
173 //
174 enum MacVersionMin { macVersionUnset=0, mac10_4=0x000A0400, mac10_5=0x000A0500,
175 mac10_6=0x000A0600, mac10_7=0x000A0700, mac10_8=0x000A0800,
176 mac10_9=0x000A0900, mac10_Future=0x10000000 };
177 enum IOSVersionMin { iOSVersionUnset=0, iOS_2_0=0x00020000, iOS_3_1=0x00030100,
178 iOS_4_2=0x00040200, iOS_4_3=0x00040300, iOS_5_0=0x00050000,
179 iOS_6_0=0x00060000, iOS_7_0=0x00070000, iOS_8_0=0x00080000,
180 iOS_9_0=0x00090000, iOS_Future=0x10000000};
181 enum WatchOSVersionMin { wOSVersionUnset=0, wOS_1_0=0x00010000, wOS_2_0=0x00020000 };
182
183
184 namespace relocatable {
185 //
186 // ld::relocatable::File
187 //
188 // Abstract base class for object files the linker processes.
189 //
190 // debugInfo() returns if the object file contains debugger information (stabs or dwarf).
191 //
192 // stabs() lazily creates a vector of Stab objects for each atom
193 //
194 // canScatterAtoms() true for all compiler generated code. Hand written assembly can opt-in
195 // via .subsections_via_symbols directive. When true it means the linker can break up section
196 // content at symbol boundaries and do optimizations like coalescing, dead code stripping, or
197 // apply order files.
198 //
199 // optimize() used by libLTO to lazily generate code from llvm bit-code files
200 //
201 class File : public ld::File
202 {
203 public:
204 enum DebugInfoKind { kDebugInfoNone=0, kDebugInfoStabs=1, kDebugInfoDwarf=2, kDebugInfoStabsUUID=3 };
205 enum SourceKind { kSourceUnknown=0, kSourceObj, kSourceLTO, kSourceArchive, kSourceCompilerArchive };
206 struct Stab {
207 const class Atom* atom;
208 uint8_t type;
209 uint8_t other;
210 uint16_t desc;
211 uint32_t value;
212 const char* string;
213 };
214 typedef const std::vector< std::vector<const char*> > LinkerOptionsList;
215
216 File(const char* pth, time_t modTime, Ordinal ord)
217 : ld::File(pth, modTime, ord, Reloc) { }
218 virtual ~File() {}
219 virtual DebugInfoKind debugInfo() const = 0;
220 virtual const char* debugInfoPath() const { return path(); }
221 virtual time_t debugInfoModificationTime() const { return modificationTime(); }
222 virtual const std::vector<Stab>* stabs() const = 0;
223 virtual bool canScatterAtoms() const = 0;
224 virtual bool hasLongBranchStubs() { return false; }
225 virtual LinkerOptionsList* linkerOptions() const = 0;
226 virtual SourceKind sourceKind() const { return kSourceUnknown; }
227 };
228 } // namespace relocatable
229
230
231 namespace dylib {
232
233 //
234 // ld::dylib::File
235 //
236 // Abstract base class for dynamic shared libraries read by the linker processes.
237 //
238 class File : public ld::File
239 {
240 public:
241 class DylibHandler
242 {
243 public:
244 virtual ~DylibHandler() {}
245 virtual File* findDylib(const char* installPath, const char* fromPath) = 0;
246 };
247
248 File(const char* pth, time_t modTime, Ordinal ord)
249 : ld::File(pth, modTime, ord, Dylib), _dylibInstallPath(NULL), _frameworkName(NULL),
250 _dylibTimeStamp(0), _dylibCurrentVersion(0), _dylibCompatibilityVersion(0),
251 _explicitlyLinked(false), _implicitlyLinked(false),
252 _lazyLoadedDylib(false), _forcedWeakLinked(false), _reExported(false),
253 _upward(false), _dead(false) { }
254 const char* installPath() const { return _dylibInstallPath; }
255 const char* frameworkName() const { return _frameworkName; }
256 uint32_t timestamp() const { return _dylibTimeStamp; }
257 uint32_t currentVersion() const { return _dylibCurrentVersion; }
258 uint32_t compatibilityVersion() const{ return _dylibCompatibilityVersion; }
259 void setExplicitlyLinked() { _explicitlyLinked = true; }
260 bool explicitlyLinked() const { return _explicitlyLinked; }
261 void setImplicitlyLinked() { _implicitlyLinked = true; }
262 bool implicitlyLinked() const { return _implicitlyLinked; }
263
264 // attributes of how dylib will be used when linked
265 void setWillBeLazyLoadedDylb() { _lazyLoadedDylib = true; }
266 bool willBeLazyLoadedDylib() const { return _lazyLoadedDylib; }
267 void setForcedWeakLinked() { _forcedWeakLinked = true; }
268 bool forcedWeakLinked() const { return _forcedWeakLinked; }
269
270 void setWillBeReExported() { _reExported = true; }
271 bool willBeReExported() const { return _reExported; }
272 void setWillBeUpwardDylib() { _upward = true; }
273 bool willBeUpwardDylib() const { return _upward; }
274 void setWillBeRemoved(bool value) { _dead = value; }
275 bool willRemoved() const { return _dead; }
276
277 virtual void processIndirectLibraries(DylibHandler* handler, bool addImplicitDylibs) = 0;
278 virtual bool providedExportAtom() const = 0;
279 virtual const char* parentUmbrella() const = 0;
280 virtual const std::vector<const char*>* allowableClients() const = 0;
281 virtual bool hasWeakExternals() const = 0;
282 virtual bool deadStrippable() const = 0;
283 virtual bool hasWeakDefinition(const char* name) const = 0;
284 virtual bool hasPublicInstallName() const = 0;
285 virtual bool allSymbolsAreWeakImported() const = 0;
286 virtual bool installPathVersionSpecific() const { return false; }
287 virtual bool appExtensionSafe() const = 0;
288
289 public:
290 const char* _dylibInstallPath;
291 const char* _frameworkName;
292 uint32_t _dylibTimeStamp;
293 uint32_t _dylibCurrentVersion;
294 uint32_t _dylibCompatibilityVersion;
295 bool _explicitlyLinked;
296 bool _implicitlyLinked;
297 bool _lazyLoadedDylib;
298 bool _forcedWeakLinked;
299 bool _reExported;
300 bool _upward;
301 bool _dead;
302 };
303 } // namespace dylib
304
305
306 namespace archive {
307 //
308 // ld::archive::File
309 //
310 // Abstract base class for static libraries read by the linker processes.
311 //
312 class File : public ld::File
313 {
314 public:
315 File(const char* pth, time_t modTime, Ordinal ord)
316 : ld::File(pth, modTime, ord, Archive) { }
317 virtual ~File() {}
318 virtual bool justInTimeDataOnlyforEachAtom(const char* name, AtomHandler&) const = 0;
319 };
320 } // namespace archive
321
322
323 //
324 // ld::Section
325 //
326 class Section
327 {
328 public:
329 enum Type { typeUnclassified, typeCode, typePageZero, typeImportProxies, typeLinkEdit, typeMachHeader, typeStack,
330 typeLiteral4, typeLiteral8, typeLiteral16, typeConstants, typeTempLTO, typeTempAlias,
331 typeCString, typeNonStdCString, typeCStringPointer, typeUTF16Strings, typeCFString, typeObjC1Classes,
332 typeCFI, typeLSDA, typeDtraceDOF, typeUnwindInfo, typeObjCClassRefs, typeObjC2CategoryList,
333 typeZeroFill, typeTentativeDefs, typeLazyPointer, typeStub, typeNonLazyPointer, typeDyldInfo,
334 typeLazyDylibPointer, typeStubHelper, typeInitializerPointers, typeTerminatorPointers,
335 typeStubClose, typeLazyPointerClose, typeAbsoluteSymbols,
336 typeTLVDefs, typeTLVZeroFill, typeTLVInitialValues, typeTLVInitializerPointers, typeTLVPointers,
337 typeFirstSection, typeLastSection, typeDebug, typeSectCreate };
338
339
340 Section(const char* sgName, const char* sctName,
341 Type t, bool hidden=false)
342 : _segmentName(sgName), _sectionName(sctName),
343 _type(t), _hidden(hidden) {}
344 Section(const Section& sect)
345 : _segmentName(sect.segmentName()), _sectionName(sect.sectionName()),
346 _type(sect.type()), _hidden(sect.isSectionHidden()) {}
347
348 bool operator==(const Section& rhs) const { return ( (_hidden==rhs._hidden) &&
349 (strcmp(_segmentName, rhs._segmentName)==0) &&
350 (strcmp(_sectionName, rhs._sectionName)==0) ); }
351 bool operator!=(const Section& rhs) const { return ! (*this == rhs); }
352 const char* segmentName() const { return _segmentName; }
353 const char* sectionName() const { return _sectionName; }
354 Type type() const { return _type; }
355 bool isSectionHidden() const { return _hidden; }
356
357 private:
358 const char* _segmentName;
359 const char* _sectionName;
360 Type _type;
361 bool _hidden;
362 };
363
364
365
366 //
367 // ld::Fixup
368 //
369 // A Fixup describes how part of an Atom's content must be fixed up. For instance,
370 // an instruction may contain a displacement to another Atom that must be
371 // fixed up by the linker.
372 //
373 // A Fixup my reference another Atom. There are two kinds of references: direct and by-name.
374 // With a direct reference, the target is bound by the File that created it.
375 // For instance a reference to a static would produce a direct reference.
376 // A by-name reference requires the linker to find the target Atom with the
377 // required name in order to be bound.
378 //
379 // For a link to succeed all Fixup must be bound.
380 //
381 // A Reference also has a fix-up-offset. This is the offset into the content of the
382 // Atom holding the reference where the fix-up (relocation) will be applied.
383 //
384 //
385 struct Fixup
386 {
387 enum TargetBinding { bindingNone, bindingByNameUnbound, bindingDirectlyBound, bindingByContentBound, bindingsIndirectlyBound };
388 enum Cluster { k1of1, k1of2, k2of2, k1of3, k2of3, k3of3, k1of4, k2of4, k3of4, k4of4, k1of5, k2of5, k3of5, k4of5, k5of5 };
389 enum Kind { kindNone, kindNoneFollowOn,
390 // grouping
391 kindNoneGroupSubordinate,
392 kindNoneGroupSubordinateFDE, kindNoneGroupSubordinateLSDA, kindNoneGroupSubordinatePersonality,
393 // value calculations
394 kindSetTargetAddress,
395 kindSubtractTargetAddress,
396 kindAddAddend,
397 kindSubtractAddend,
398 kindSetTargetImageOffset,
399 kindSetTargetSectionOffset,
400 kindSetTargetTLVTemplateOffset,
401 // pointer store kinds (of current calculated value)
402 kindStore8,
403 kindStoreLittleEndian16,
404 kindStoreLittleEndianLow24of32,
405 kindStoreLittleEndian32,
406 kindStoreLittleEndian64,
407 kindStoreBigEndian16,
408 kindStoreBigEndianLow24of32,
409 kindStoreBigEndian32,
410 kindStoreBigEndian64,
411 // Intel specific store kinds
412 kindStoreX86BranchPCRel8, kindStoreX86BranchPCRel32,
413 kindStoreX86PCRel8, kindStoreX86PCRel16,
414 kindStoreX86PCRel32, kindStoreX86PCRel32_1, kindStoreX86PCRel32_2, kindStoreX86PCRel32_4,
415 kindStoreX86PCRel32GOTLoad, kindStoreX86PCRel32GOTLoadNowLEA, kindStoreX86PCRel32GOT,
416 kindStoreX86PCRel32TLVLoad, kindStoreX86PCRel32TLVLoadNowLEA,
417 kindStoreX86Abs32TLVLoad, kindStoreX86Abs32TLVLoadNowLEA,
418 // ARM specific store kinds
419 kindStoreARMBranch24, kindStoreThumbBranch22,
420 kindStoreARMLoad12,
421 kindStoreARMLow16, kindStoreARMHigh16,
422 kindStoreThumbLow16, kindStoreThumbHigh16,
423 #if SUPPORT_ARCH_arm64
424 // ARM64 specific store kinds
425 kindStoreARM64Branch26,
426 kindStoreARM64Page21, kindStoreARM64PageOff12,
427 kindStoreARM64GOTLoadPage21, kindStoreARM64GOTLoadPageOff12,
428 kindStoreARM64GOTLeaPage21, kindStoreARM64GOTLeaPageOff12,
429 kindStoreARM64TLVPLoadPage21, kindStoreARM64TLVPLoadPageOff12,
430 kindStoreARM64TLVPLoadNowLeaPage21, kindStoreARM64TLVPLoadNowLeaPageOff12,
431 kindStoreARM64PointerToGOT, kindStoreARM64PCRelToGOT,
432 #endif
433 // dtrace probes
434 kindDtraceExtra,
435 kindStoreX86DtraceCallSiteNop, kindStoreX86DtraceIsEnableSiteClear,
436 kindStoreARMDtraceCallSiteNop, kindStoreARMDtraceIsEnableSiteClear,
437 kindStoreARM64DtraceCallSiteNop, kindStoreARM64DtraceIsEnableSiteClear,
438 kindStoreThumbDtraceCallSiteNop, kindStoreThumbDtraceIsEnableSiteClear,
439 // lazy binding
440 kindLazyTarget, kindSetLazyOffset,
441 // islands
442 kindIslandTarget,
443 // data-in-code markers
444 kindDataInCodeStartData, kindDataInCodeStartJT8, kindDataInCodeStartJT16,
445 kindDataInCodeStartJT32, kindDataInCodeStartJTA32, kindDataInCodeEnd,
446 // linker optimization hints
447 kindLinkerOptimizationHint,
448 // pointer store combinations
449 kindStoreTargetAddressLittleEndian32, // kindSetTargetAddress + kindStoreLittleEndian32
450 kindStoreTargetAddressLittleEndian64, // kindSetTargetAddress + kindStoreLittleEndian64
451 kindStoreTargetAddressBigEndian32, // kindSetTargetAddress + kindStoreBigEndian32
452 kindStoreTargetAddressBigEndian64, // kindSetTargetAddress + kindStoreBigEndian364
453 kindSetTargetTLVTemplateOffsetLittleEndian32, // kindSetTargetTLVTemplateOffset + kindStoreLittleEndian32
454 kindSetTargetTLVTemplateOffsetLittleEndian64, // kindSetTargetTLVTemplateOffset + kindStoreLittleEndian64
455 // Intel value calculation and store combinations
456 kindStoreTargetAddressX86PCRel32, // kindSetTargetAddress + kindStoreX86PCRel32
457 kindStoreTargetAddressX86BranchPCRel32, // kindSetTargetAddress + kindStoreX86BranchPCRel32
458 kindStoreTargetAddressX86PCRel32GOTLoad,// kindSetTargetAddress + kindStoreX86PCRel32GOTLoad
459 kindStoreTargetAddressX86PCRel32GOTLoadNowLEA,// kindSetTargetAddress + kindStoreX86PCRel32GOTLoadNowLEA
460 kindStoreTargetAddressX86PCRel32TLVLoad, // kindSetTargetAddress + kindStoreX86PCRel32TLVLoad
461 kindStoreTargetAddressX86PCRel32TLVLoadNowLEA, // kindSetTargetAddress + kindStoreX86PCRel32TLVLoadNowLEA
462 kindStoreTargetAddressX86Abs32TLVLoad, // kindSetTargetAddress + kindStoreX86Abs32TLVLoad
463 kindStoreTargetAddressX86Abs32TLVLoadNowLEA, // kindSetTargetAddress + kindStoreX86Abs32TLVLoadNowLEA
464 // ARM value calculation and store combinations
465 kindStoreTargetAddressARMBranch24, // kindSetTargetAddress + kindStoreARMBranch24
466 kindStoreTargetAddressThumbBranch22, // kindSetTargetAddress + kindStoreThumbBranch22
467 kindStoreTargetAddressARMLoad12, // kindSetTargetAddress + kindStoreARMLoad12
468 #if SUPPORT_ARCH_arm64
469 // ARM64 value calculation and store combinations
470 kindStoreTargetAddressARM64Branch26, // kindSetTargetAddress + kindStoreARM64Branch26
471 kindStoreTargetAddressARM64Page21, // kindSetTargetAddress + kindStoreARM64Page21
472 kindStoreTargetAddressARM64PageOff12, // kindSetTargetAddress + kindStoreARM64PageOff12
473 kindStoreTargetAddressARM64GOTLoadPage21, // kindSetTargetAddress + kindStoreARM64GOTLoadPage21
474 kindStoreTargetAddressARM64GOTLoadPageOff12,// kindSetTargetAddress + kindStoreARM64GOTLoadPageOff12
475 kindStoreTargetAddressARM64GOTLeaPage21, // kindSetTargetAddress + kindStoreARM64GOTLeaPage21
476 kindStoreTargetAddressARM64GOTLeaPageOff12, // kindSetTargetAddress + kindStoreARM64GOTLeaPageOff12
477 kindStoreTargetAddressARM64TLVPLoadPage21, // kindSetTargetAddress + kindStoreARM64TLVPLoadPage21
478 kindStoreTargetAddressARM64TLVPLoadPageOff12,// kindSetTargetAddress + kindStoreARM64TLVPLoadPageOff12
479 kindStoreTargetAddressARM64TLVPLoadNowLeaPage21, // kindSetTargetAddress + kindStoreARM64TLVPLoadNowLeaPage21
480 kindStoreTargetAddressARM64TLVPLoadNowLeaPageOff12, // kindSetTargetAddress + kindStoreARM64TLVPLoadNowLeaPageOff12
481 #endif
482 };
483
484 union {
485 const Atom* target;
486 const char* name;
487 uint64_t addend;
488 uint32_t bindingIndex;
489 } u;
490 uint32_t offsetInAtom;
491 Kind kind : 8;
492 Cluster clusterSize : 4;
493 bool weakImport : 1;
494 TargetBinding binding : 3;
495 bool contentAddendOnly : 1;
496 bool contentDetlaToAddendOnly : 1;
497 bool contentIgnoresAddend : 1;
498
499 typedef Fixup* iterator;
500
501 Fixup() :
502 offsetInAtom(0), kind(kindNone), clusterSize(k1of1), weakImport(false),
503 binding(bindingNone),
504 contentAddendOnly(false), contentDetlaToAddendOnly(false), contentIgnoresAddend(false) { u.target = NULL; }
505
506 Fixup(Kind k, Atom* targetAtom) :
507 offsetInAtom(0), kind(k), clusterSize(k1of1), weakImport(false),
508 binding(Fixup::bindingDirectlyBound),
509 contentAddendOnly(false), contentDetlaToAddendOnly(false), contentIgnoresAddend(false)
510 { assert(targetAtom != NULL); u.target = targetAtom; }
511
512 Fixup(uint32_t off, Cluster c, Kind k) :
513 offsetInAtom(off), kind(k), clusterSize(c), weakImport(false),
514 binding(Fixup::bindingNone),
515 contentAddendOnly(false), contentDetlaToAddendOnly(false), contentIgnoresAddend(false)
516 { u.addend = 0; }
517
518 Fixup(uint32_t off, Cluster c, Kind k, bool weakIm, const char* name) :
519 offsetInAtom(off), kind(k), clusterSize(c), weakImport(weakIm),
520 binding(Fixup::bindingByNameUnbound),
521 contentAddendOnly(false), contentDetlaToAddendOnly(false), contentIgnoresAddend(false)
522 { assert(name != NULL); u.name = name; }
523
524 Fixup(uint32_t off, Cluster c, Kind k, TargetBinding b, const char* name) :
525 offsetInAtom(off), kind(k), clusterSize(c), weakImport(false), binding(b),
526 contentAddendOnly(false), contentDetlaToAddendOnly(false), contentIgnoresAddend(false)
527 { assert(name != NULL); u.name = name; }
528
529 Fixup(uint32_t off, Cluster c, Kind k, const Atom* targetAtom) :
530 offsetInAtom(off), kind(k), clusterSize(c), weakImport(false),
531 binding(Fixup::bindingDirectlyBound),
532 contentAddendOnly(false), contentDetlaToAddendOnly(false), contentIgnoresAddend(false)
533 { assert(targetAtom != NULL); u.target = targetAtom; }
534
535 Fixup(uint32_t off, Cluster c, Kind k, TargetBinding b, const Atom* targetAtom) :
536 offsetInAtom(off), kind(k), clusterSize(c), weakImport(false), binding(b),
537 contentAddendOnly(false), contentDetlaToAddendOnly(false), contentIgnoresAddend(false)
538 { assert(targetAtom != NULL); u.target = targetAtom; }
539
540 Fixup(uint32_t off, Cluster c, Kind k, uint64_t addend) :
541 offsetInAtom(off), kind(k), clusterSize(c), weakImport(false),
542 binding(Fixup::bindingNone),
543 contentAddendOnly(false), contentDetlaToAddendOnly(false), contentIgnoresAddend(false)
544 { u.addend = addend; }
545
546 Fixup(Kind k, uint32_t lohKind, uint32_t off1, uint32_t off2) :
547 offsetInAtom(off1), kind(k), clusterSize(k1of1),
548 weakImport(false), binding(Fixup::bindingNone), contentAddendOnly(false),
549 contentDetlaToAddendOnly(false), contentIgnoresAddend(false) {
550 assert(k == kindLinkerOptimizationHint);
551 LOH_arm64 extra;
552 extra.addend = 0;
553 extra.info.kind = lohKind;
554 extra.info.count = 1;
555 extra.info.delta1 = 0;
556 extra.info.delta2 = (off2 - off1) >> 2;
557 u.addend = extra.addend;
558 }
559
560
561 bool firstInCluster() const {
562 switch (clusterSize) {
563 case k1of1:
564 case k1of2:
565 case k1of3:
566 case k1of4:
567 case k1of5:
568 return true;
569 default:
570 break;
571 }
572 return false;
573 }
574
575 bool lastInCluster() const {
576 switch (clusterSize) {
577 case k1of1:
578 case k2of2:
579 case k3of3:
580 case k4of4:
581 case k5of5:
582 return true;
583 default:
584 break;
585 }
586 return false;
587 }
588
589 union LOH_arm64 {
590 uint64_t addend;
591 struct {
592 unsigned kind : 6,
593 count : 2, // 00 => 1 addr, 11 => 4 addrs
594 delta1 : 14, // 16-bit delta, low 2 bits assumed zero
595 delta2 : 14,
596 delta3 : 14,
597 delta4 : 14;
598 } info;
599 };
600
601 };
602
603 //
604 // ld::Atom
605 //
606 // An atom is the fundamental unit of linking. A C function or global variable is an atom.
607 // An atom has content and attributes. The content of a function atom is the instructions
608 // that implement the function. The content of a global variable atom is its initial bits.
609 //
610 // Name:
611 // The name of an atom is the label name generated by the compiler. A C compiler names foo()
612 // as _foo. A C++ compiler names foo() as __Z3foov.
613 // The name refers to the first byte of the content. An atom cannot have multiple entry points.
614 // Such code is modeled as multiple atoms, each having a "follow on" reference to the next.
615 // A "follow on" reference is a contraint to the linker to the atoms must be laid out contiguously.
616 //
617 // Scope:
618 // An atom is in one of three scopes: translation-unit, linkage-unit, or global. These correspond
619 // to the C visibility of static, hidden, default.
620 //
621 // DefinitionKind:
622 // An atom is one of five defintion kinds:
623 // regular Most atoms.
624 // weak C++ compiler makes some functions weak if there might be multiple copies
625 // that the linker needs to coalesce.
626 // tentative A straggler from ancient C when the extern did not exist. "int foo;" is ambiguous.
627 // It could be a prototype or it could be a definition.
628 // external This is a "proxy" atom produced by a dylib reader. It has no content. It exists
629 // so that the graph of Atoms can be complete.
630 // external-weak Same as external, but the definition in the dylib is weak.
631 //
632 // SymbolTableInclusion:
633 // An atom may or may not be in the symbol table in an object file.
634 // in Most atoms for functions or global data
635 // not-in Anonymous atoms such literal c-strings, or other compiler generated data
636 // not-in-final Atom whose name should not be in the symbol table of final linkd image (e.g. 'l' labels .eh labels)
637 // in-never-strip Atom whose name the strip tool should never remove (e.g. REFERENCED_DYNAMICALLY in mach-o)
638 //
639 // ContentType:
640 // Some atoms require specially processing by the linker based on their content. For instance, zero-fill data
641 // atom are group together at the end of the DATA segment to reduce disk size.
642 //
643 // ObjectAddress:
644 // For reproducability, the linker lays out atoms in the order they occurred in the source (object) files.
645 // The objectAddress() method returns the address of an atom in the object file so that the linker
646 // can arrange the atoms.
647 //
648 //
649 class Atom
650 {
651 public:
652 enum Scope { scopeTranslationUnit, scopeLinkageUnit, scopeGlobal };
653 enum Definition { definitionRegular, definitionTentative, definitionAbsolute, definitionProxy };
654 enum Combine { combineNever, combineByName, combineByNameAndContent, combineByNameAndReferences };
655 enum ContentType { typeUnclassified, typeZeroFill, typeCString, typeCFI, typeLSDA, typeSectionStart,
656 typeSectionEnd, typeBranchIsland, typeLazyPointer, typeStub, typeNonLazyPointer,
657 typeLazyDylibPointer, typeStubHelper, typeInitializerPointers, typeTerminatorPointers,
658 typeLTOtemporary, typeResolver,
659 typeTLV, typeTLVZeroFill, typeTLVInitialValue, typeTLVInitializerPointers, typeTLVPointer };
660
661 enum SymbolTableInclusion { symbolTableNotIn, symbolTableNotInFinalLinkedImages, symbolTableIn,
662 symbolTableInAndNeverStrip, symbolTableInAsAbsolute,
663 symbolTableInWithRandomAutoStripLabel };
664 enum WeakImportState { weakImportUnset, weakImportTrue, weakImportFalse };
665
666 struct Alignment {
667 Alignment(int p2, int m=0) : powerOf2(p2), modulus(m) {}
668 uint8_t trailingZeros() const { return (modulus==0) ? powerOf2 : __builtin_ctz(modulus); }
669 uint16_t powerOf2;
670 uint16_t modulus;
671 };
672 struct LineInfo {
673 const char* fileName;
674 uint32_t atomOffset;
675 uint32_t lineNumber;
676
677 typedef LineInfo* iterator;
678 };
679 struct UnwindInfo {
680 uint32_t startOffset;
681 uint32_t unwindInfo;
682
683 typedef UnwindInfo* iterator;
684 };
685
686 Atom(const Section& sect, Definition d, Combine c, Scope s, ContentType ct,
687 SymbolTableInclusion i, bool dds, bool thumb, bool al, Alignment a) :
688 _section(&sect), _address(0), _alignmentModulus(a.modulus),
689 _alignmentPowerOf2(a.powerOf2), _definition(d), _combine(c),
690 _dontDeadStrip(dds), _thumb(thumb), _alias(al), _autoHide(false),
691 _contentType(ct), _symbolTableInclusion(i),
692 _scope(s), _mode(modeSectionOffset),
693 _overridesADylibsWeakDef(false), _coalescedAway(false),
694 _live(false), _dontDeadStripIfRefLive(false),
695 _machoSection(0), _weakImportState(weakImportUnset)
696 {
697 #ifndef NDEBUG
698 switch ( _combine ) {
699 case combineByNameAndContent:
700 case combineByNameAndReferences:
701 assert(_symbolTableInclusion != symbolTableIn);
702 assert(_scope != scopeGlobal);
703 break;
704 case combineByName:
705 case combineNever:
706 break;
707 };
708 #endif
709 }
710 virtual ~Atom() {}
711
712 const Section& section() const { return *_section; }
713 Definition definition() const { return _definition; }
714 Combine combine() const { return _combine; }
715 Scope scope() const { return _scope; }
716 ContentType contentType() const { return _contentType; }
717 SymbolTableInclusion symbolTableInclusion() const{ return _symbolTableInclusion; }
718 bool dontDeadStrip() const { return _dontDeadStrip; }
719 bool dontDeadStripIfReferencesLive() const { return _dontDeadStripIfRefLive; }
720 bool isThumb() const { return _thumb; }
721 bool isAlias() const { return _alias; }
722 Alignment alignment() const { return Alignment(_alignmentPowerOf2, _alignmentModulus); }
723 bool overridesDylibsWeakDef() const { return _overridesADylibsWeakDef; }
724 bool coalescedAway() const { return _coalescedAway; }
725 bool weakImported() const { return _weakImportState == weakImportTrue; }
726 WeakImportState weakImportState() const { return _weakImportState; }
727 bool autoHide() const { return _autoHide; }
728 bool live() const { return _live; }
729 uint8_t machoSection() const { assert(_machoSection != 0); return _machoSection; }
730
731 void setScope(Scope s) { _scope = s; }
732 void setSymbolTableInclusion(SymbolTableInclusion i)
733 { _symbolTableInclusion = i; }
734 void setCombine(Combine c) { _combine = c; }
735 void setOverridesDylibsWeakDef() { _overridesADylibsWeakDef = true; }
736 void setCoalescedAway() { _coalescedAway = true; }
737 void setWeakImportState(bool w) { assert(_definition == definitionProxy); _weakImportState = ( w ? weakImportTrue : weakImportFalse); }
738 void setAutoHide() { _autoHide = true; }
739 void setDontDeadStripIfReferencesLive() { _dontDeadStripIfRefLive = true; }
740 void setLive() { _live = true; }
741 void setLive(bool value) { _live = value; }
742 void setMachoSection(unsigned x) { assert(x != 0); assert(x < 256); _machoSection = x; }
743 void setSectionOffset(uint64_t o){ assert(_mode == modeSectionOffset); _address = o; _mode = modeSectionOffset; }
744 void setSectionStartAddress(uint64_t a) { assert(_mode == modeSectionOffset); _address += a; _mode = modeFinalAddress; }
745 uint64_t sectionOffset() const { assert(_mode == modeSectionOffset); return _address; }
746 uint64_t finalAddress() const { assert(_mode == modeFinalAddress); return _address; }
747 #ifndef NDEBUG
748 bool finalAddressMode() const { return (_mode == modeFinalAddress); }
749 #endif
750 virtual const File* file() const = 0;
751 virtual const char* translationUnitSource() const { return NULL; }
752 virtual const char* name() const = 0;
753 virtual uint64_t objectAddress() const = 0;
754 virtual uint64_t size() const = 0;
755 virtual void copyRawContent(uint8_t buffer[]) const = 0;
756 virtual const uint8_t* rawContentPointer() const { return NULL; }
757 virtual unsigned long contentHash(const class IndirectBindingTable&) const { return 0; }
758 virtual bool canCoalesceWith(const Atom& rhs, const class IndirectBindingTable&) const { return false; }
759 virtual Fixup::iterator fixupsBegin() const { return NULL; }
760 virtual Fixup::iterator fixupsEnd() const { return NULL; }
761 bool hasFixupsOfKind(Fixup::Kind kind) const {
762 for (ld::Fixup::iterator fit = fixupsBegin(), end=fixupsEnd(); fit != end; ++fit) {
763 if ( fit->kind == kind ) return true;
764 }
765 return false;
766 }
767 virtual void setFile(const File* f) { }
768
769 virtual UnwindInfo::iterator beginUnwind() const { return NULL; }
770 virtual UnwindInfo::iterator endUnwind() const { return NULL; }
771 virtual LineInfo::iterator beginLineInfo() const { return NULL; }
772 virtual LineInfo::iterator endLineInfo() const { return NULL; }
773
774 void setAttributesFromAtom(const Atom& a) {
775 _section = a._section;
776 _alignmentModulus = a._alignmentModulus;
777 _alignmentPowerOf2 = a._alignmentPowerOf2;
778 _definition = a._definition;
779 _combine = a._combine;
780 _dontDeadStrip = a._dontDeadStrip;
781 _thumb = a._thumb;
782 _autoHide = a._autoHide;
783 _contentType = a._contentType;
784 _symbolTableInclusion = a._symbolTableInclusion;
785 _scope = a._scope;
786 _mode = a._mode;
787 _overridesADylibsWeakDef = a._overridesADylibsWeakDef;
788 _coalescedAway = a._coalescedAway;
789 _weakImportState = a._weakImportState;
790 }
791
792 protected:
793 enum AddressMode { modeSectionOffset, modeFinalAddress };
794
795 const Section * _section;
796 uint64_t _address;
797 uint16_t _alignmentModulus;
798 uint8_t _alignmentPowerOf2;
799 Definition _definition : 2;
800 Combine _combine : 2;
801 bool _dontDeadStrip : 1;
802 bool _thumb : 1;
803 bool _alias : 1;
804 int _autoHide : 1;
805 ContentType _contentType : 5;
806 SymbolTableInclusion _symbolTableInclusion : 3;
807 Scope _scope : 2;
808 AddressMode _mode: 2;
809 bool _overridesADylibsWeakDef : 1;
810 bool _coalescedAway : 1;
811 bool _live : 1;
812 bool _dontDeadStripIfRefLive : 1;
813 unsigned _machoSection : 8;
814 WeakImportState _weakImportState : 2;
815 };
816
817
818 class IndirectBindingTable
819 {
820 public:
821 virtual const char* indirectName(uint32_t bindingIndex) const = 0;
822 virtual const ld::Atom* indirectAtom(uint32_t bindingIndex) const = 0;
823 };
824
825
826
827 // utility classes for using std::unordered_map with c-strings
828 struct CStringHash {
829 size_t operator()(const char* __s) const {
830 size_t __h = 0;
831 for ( ; *__s; ++__s)
832 __h = 5 * __h + *__s;
833 return __h;
834 };
835 };
836 struct CStringEquals
837 {
838 bool operator()(const char* left, const char* right) const { return (strcmp(left, right) == 0); }
839 };
840
841 typedef std::unordered_set<const char*, ld::CStringHash, ld::CStringEquals> CStringSet;
842
843
844 class Internal
845 {
846 public:
847 class FinalSection : public ld::Section {
848 public:
849 FinalSection(const Section& sect) : Section(sect), address(0),
850 fileOffset(0), size(0), alignment(0),
851 indirectSymTabStartIndex(0), indirectSymTabElementSize(0),
852 relocStart(0), relocCount(0),
853 hasLocalRelocs(false), hasExternalRelocs(false) {}
854 std::vector<const Atom*> atoms;
855 uint64_t address;
856 uint64_t fileOffset;
857 uint64_t size;
858 uint32_t alignmentPaddingBytes;
859 uint8_t alignment;
860 uint32_t indirectSymTabStartIndex;
861 uint32_t indirectSymTabElementSize;
862 uint32_t relocStart;
863 uint32_t relocCount;
864 bool hasLocalRelocs;
865 bool hasExternalRelocs;
866 };
867
868 typedef std::map<const ld::Atom*, FinalSection*> AtomToSection;
869
870 virtual uint64_t assignFileOffsets() = 0;
871 virtual void setSectionSizesAndAlignments() = 0;
872 virtual ld::Internal::FinalSection* addAtom(const Atom&) = 0;
873 virtual ld::Internal::FinalSection* getFinalSection(const ld::Section& inputSection) = 0;
874 virtual ~Internal() {}
875 Internal() : bundleLoader(NULL),
876 entryPoint(NULL), classicBindingHelper(NULL),
877 lazyBindingHelper(NULL), compressedFastBinderProxy(NULL),
878 objcObjectConstraint(ld::File::objcConstraintNone),
879 objcDylibConstraint(ld::File::objcConstraintNone),
880 swiftVersion(0), cpuSubType(0), minOSVersion(0),
881 objectFileFoundWithNoVersion(false),
882 allObjectFilesScatterable(true),
883 someObjectFileHasDwarf(false), usingHugeSections(false),
884 hasThreadLocalVariableDefinitions(false),
885 hasWeakExternalSymbols(false),
886 someObjectHasOptimizationHints(false),
887 dropAllBitcode(false), embedMarkerOnly(false) { }
888
889 std::vector<FinalSection*> sections;
890 std::vector<ld::dylib::File*> dylibs;
891 std::vector<ld::relocatable::File::Stab> stabs;
892 AtomToSection atomToSection;
893 CStringSet linkerOptionLibraries;
894 CStringSet linkerOptionFrameworks;
895 CStringSet linkerOptionLibrariesProcessed;
896 CStringSet linkerOptionFrameworksProcessed;
897 std::vector<const ld::Atom*> indirectBindingTable;
898 std::vector<const ld::relocatable::File*> filesWithBitcode;
899 std::unordered_set<const char*> allUndefProxies;
900 const ld::dylib::File* bundleLoader;
901 const Atom* entryPoint;
902 const Atom* classicBindingHelper;
903 const Atom* lazyBindingHelper;
904 const Atom* compressedFastBinderProxy;
905 ld::File::ObjcConstraint objcObjectConstraint;
906 ld::File::ObjcConstraint objcDylibConstraint;
907 uint8_t swiftVersion;
908 uint32_t cpuSubType;
909 uint32_t minOSVersion;
910 uint32_t derivedPlatformLoadCommand;
911 bool objectFileFoundWithNoVersion;
912 bool allObjectFilesScatterable;
913 bool someObjectFileHasDwarf;
914 bool usingHugeSections;
915 bool hasThreadLocalVariableDefinitions;
916 bool hasWeakExternalSymbols;
917 bool someObjectHasOptimizationHints;
918 bool dropAllBitcode;
919 bool embedMarkerOnly;
920 std::string ltoBitcodePath;
921 };
922
923
924
925
926
927
928
929 } // namespace ld
930
931 #endif // __LD_HPP__
mirror of ld64