src/ld/ObjectFile.h

   1 /* -*- mode: C++; c-basic-offset: 4; tab-width: 4 -*-
   2  *
   3  * Copyright (c) 2005-2007 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 __OBJECTFILE__
  27 #define __OBJECTFILE__
  28
  29 #include <stdint.h>
  30 #include <vector>
  31 #include <map>
  32 #include <set>
  33
  34
  35
  36 //
  37 // These classes represent the abstract Atoms and References that are the basis of the linker.
  38 // An Atom and a Reference correspond to a Node and Edge in graph theory.
  39 //
  40 // A Reader is a class which parses an object file and presents it as Atoms and References.
  41 // All linking operations are done on Atoms and References.  This makes the linker file
  42 // format independent.
  43 //
  44 // A Writer takes a vector of Atoms with all References resolved and produces an executable file.
  45 //
  46 //
  47
  48
  49
  50 namespace ObjectFile {
  51
  52
  53 struct LineInfo
  54 {
  55         uint32_t        atomOffset;
  56         const char* fileName;
  57         uint32_t        lineNumber;
  58 };
  59
  60
  61 class ReaderOptions
  62 {
  63 public:
  64                                                 ReaderOptions() : fFullyLoadArchives(false), fLoadAllObjcObjectsFromArchives(false), fFlatNamespace(false),
  65                                                                                 fLinkingMainExecutable(false),
  66                                                                                 fForFinalLinkedImage(false), fNoEHLabels(false), fForStatic(false), fForDyld(false), fMakeTentativeDefinitionsReal(false),
  67                                                                                 fWhyLoad(false), fRootSafe(false), fSetuidSafe(false),fDebugInfoStripping(kDebugInfoFull),
  68                                                                                 fImplicitlyLinkPublicDylibs(true),
  69                                                                                 fAddCompactUnwindEncoding(true),
  70                                                                                 fWarnCompactUnwind(false),
  71                                                                                 fRemoveDwarfUnwindIfCompactExists(false),
  72                                                                                 fMakeCompressedDyldInfo(false),
  73                                                                                 fAutoOrderInitializers(true),
  74                                                                                 fOptimizeZeroFill(true),
  75                                                                                 fLogObjectFiles(false), fLogAllFiles(false),
  76                                                                                 fTraceDylibs(false), fTraceIndirectDylibs(false), fTraceArchives(false),
  77                                                                                 fTraceOutputFile(NULL), fMacVersionMin(kMinMacVersionUnset), fIPhoneVersionMin(kMinIPhoneVersionUnset) {}
  78         enum DebugInfoStripping { kDebugInfoNone, kDebugInfoMinimal, kDebugInfoFull };
  79         enum MacVersionMin { kMinMacVersionUnset, k10_1, k10_2, k10_3, k10_4, k10_5, k10_6, k10_7 };
  80         enum IPhoneVersionMin { kMinIPhoneVersionUnset, k2_0, k2_1, k2_2, k3_0, k3_1, k3_2, k4_0 };
  81
  82         struct AliasPair {
  83                 const char*                     realName;
  84                 const char*                     alias;
  85         };
  86
  87         bool                                    fFullyLoadArchives;
  88         bool                                    fLoadAllObjcObjectsFromArchives;
  89         bool                                    fFlatNamespace;
  90         bool                                    fLinkingMainExecutable;
  91         bool                                    fForFinalLinkedImage;
  92         bool                                    fNoEHLabels;
  93         bool                                    fForStatic;
  94         bool                                    fForDyld;
  95         bool                                    fMakeTentativeDefinitionsReal;
  96         bool                                    fWhyLoad;
  97         bool                                    fRootSafe;
  98         bool                                    fSetuidSafe;
  99         DebugInfoStripping              fDebugInfoStripping;
 100         bool                                    fImplicitlyLinkPublicDylibs;
 101         bool                                    fAddCompactUnwindEncoding;
 102         bool                                    fWarnCompactUnwind;
 103         bool                                    fRemoveDwarfUnwindIfCompactExists;
 104         bool                                    fMakeCompressedDyldInfo;
 105         bool                                    fAutoOrderInitializers;
 106         bool                                    fOptimizeZeroFill;
 107         bool                                    fLogObjectFiles;
 108         bool                                    fLogAllFiles;
 109         bool                                    fTraceDylibs;
 110         bool                                    fTraceIndirectDylibs;
 111         bool                                    fTraceArchives;
 112         const char*                             fTraceOutputFile;
 113         MacVersionMin                   fMacVersionMin;
 114         IPhoneVersionMin                fIPhoneVersionMin;
 115         std::vector<AliasPair>  fAliases;
 116 };
 117
 118
 119 class Reader
 120 {
 121 public:
 122         enum DebugInfoKind { kDebugInfoNone=0, kDebugInfoStabs=1, kDebugInfoDwarf=2, kDebugInfoStabsUUID=3 };
 123         struct Stab
 124         {
 125                 class Atom*     atom;
 126                 uint8_t         type;
 127                 uint8_t         other;
 128                 uint16_t        desc;
 129                 uint32_t        value;
 130                 const char* string;
 131         };
 132         enum ObjcConstraint { kObjcNone,  kObjcRetainRelease,  kObjcRetainReleaseOrGC,  kObjcGC };
 133         enum CpuConstraint  { kCpuAny = 0 };
 134
 135         class DylibHander
 136         {
 137         public:
 138                 virtual                         ~DylibHander()  {}
 139                 virtual Reader*         findDylib(const char* installPath, const char* fromPath) = 0;
 140         };
 141
 142
 143         static Reader* createReader(const char* path, const ReaderOptions& options);
 144
 145         virtual const char*                                     getPath() = 0;
 146         virtual time_t                                          getModificationTime() = 0;
 147         virtual DebugInfoKind                           getDebugInfoKind() = 0;
 148         virtual std::vector<class Atom*>&       getAtoms() = 0;
 149         virtual std::vector<class Atom*>*       getJustInTimeAtomsFor(const char* name) = 0;
 150         virtual std::vector<Stab>*                      getStabs() = 0;
 151         virtual ObjcConstraint                          getObjCConstraint()                     { return kObjcNone; }
 152         virtual uint32_t                                        updateCpuConstraint(uint32_t current) { return current; }
 153         virtual bool                                            objcReplacementClasses()        { return false; }
 154
 155         // For relocatable object files only
 156         virtual bool                                            canScatterAtoms()                       { return true; }
 157         virtual bool                                            optimize(const std::vector<ObjectFile::Atom*>&, std::vector<ObjectFile::Atom*>&,
 158                                                                                                         std::vector<const char*>&, const std::set<ObjectFile::Atom*>&,
 159                                                                                                         std::vector<ObjectFile::Atom*>&,
 160                                                                                                         uint32_t, ObjectFile::Reader* writer,
 161                                                                                                         ObjectFile::Atom* entryPointAtom,
 162                                                                                                         const std::vector<const char*>& llvmOptions,
 163                                                                                                         bool allGlobalsAReDeadStripRoots, int okind,
 164                                                                                                         bool verbose, bool saveTemps, const char* outputFilePath,
 165                                                                                                         bool pie, bool allowTextRelocs) { return false; }
 166         virtual bool                                            hasLongBranchStubs()            { return false; }
 167
 168         // For Dynamic Libraries only
 169         virtual const char*                                     getInstallPath()                        { return NULL; }
 170         virtual uint32_t                                        getTimestamp()                          { return 0; }
 171         virtual uint32_t                                        getCurrentVersion()                     { return 0; }
 172         virtual uint32_t                                        getCompatibilityVersion()       { return 0; }
 173         virtual void                                            processIndirectLibraries(DylibHander* handler)  { }
 174         virtual void                                            setExplicitlyLinked()           { }
 175         virtual bool                                            explicitlyLinked()                      { return false; }
 176         virtual bool                                            implicitlyLinked()                      { return false; }
 177         virtual bool                                            providedExportAtom()            { return false; }
 178         virtual const char*                                     parentUmbrella()                        { return NULL; }
 179         virtual std::vector<const char*>*       getAllowableClients()           { return NULL; }
 180         virtual bool                                            hasWeakExternals()                      { return false; }
 181         virtual bool                                            deadStrippable()                        { return false; }
 182         virtual bool                                            isLazyLoadedDylib()                     { return false; }
 183
 184 protected:
 185                                                                                 Reader() {}
 186         virtual                                                         ~Reader() {}
 187 };
 188
 189 class Segment
 190 {
 191 public:
 192         virtual const char*                     getName() const  = 0;
 193         virtual bool                            isContentReadable() const = 0;
 194         virtual bool                            isContentWritable() const = 0;
 195         virtual bool                            isContentExecutable() const = 0;
 196
 197         uint64_t                                        getBaseAddress() const { return fBaseAddress; }
 198         void                                            setBaseAddress(uint64_t addr) { fBaseAddress = addr; }
 199         virtual bool                            hasFixedAddress() const { return false; }
 200
 201 protected:
 202                                                                 Segment() : fBaseAddress(0) {}
 203         virtual                                         ~Segment() {}
 204         uint64_t                                        fBaseAddress;
 205 };
 206
 207 class Reference;
 208
 209 class Section
 210 {
 211 public:
 212         unsigned int    getIndex() { return fIndex; }
 213         uint64_t                getBaseAddress() { return fBaseAddress; }
 214         void                    setBaseAddress(uint64_t addr) { fBaseAddress = addr; }
 215         void*                   fOther;
 216
 217 protected:
 218                                         Section() : fOther(NULL), fBaseAddress(0), fIndex(0)  {}
 219         uint64_t                fBaseAddress;
 220         unsigned int    fIndex;
 221 };
 222
 223
 224 struct Alignment
 225 {
 226                                 Alignment(int p2, int m=0) : powerOf2(p2), modulus(m) {}
 227         uint8_t         trailingZeros() const { return (modulus==0) ? powerOf2 : __builtin_ctz(modulus); }
 228         uint16_t        powerOf2;
 229         uint16_t        modulus;
 230 };
 231
 232 struct UnwindInfo
 233 {
 234         uint32_t        startOffset;
 235         uint32_t        unwindInfo;
 236
 237         typedef UnwindInfo* iterator;
 238
 239 };
 240
 241
 242 //
 243 // An atom is the fundamental unit of linking.  A C function or global variable is an atom.
 244 // An atom has content and some attributes. The content of a function atom is the instructions
 245 // that implement the function.  The content of a global variable atom is its initial bits.
 246 //
 247 // Name:
 248 // The name of an atom is the label name generated by the compiler.  A C compiler names foo()
 249 // as _foo.  A C++ compiler names foo() as __Z3foov.
 250 // The name refers to the first byte of the content.  An atom cannot have multiple entry points.
 251 // Such code is modeled as multiple atoms, each having a "follow on" reference to the next.
 252 // A "follow on" reference is a contraint to the linker to the atoms must be laid out contiguously.
 253 //
 254 // Scope:
 255 // An atom is in one of three scopes: translation-unit, linkage-unit, or global.  These correspond
 256 // to the C visibility of static, hidden, default.
 257 //
 258 // DefinitionKind:
 259 // An atom is one of five defintion kinds:
 260 //      regular                 Most atoms.
 261 //      weak                    C++ compiler makes some functions weak if there might be multiple copies
 262 //                                      that the linker needs to coalesce.
 263 //      tentative               A straggler from ancient C when the extern did not exist. "int foo;" is ambiguous.
 264 //                                      It could be a prototype or it could be a definition.
 265 //      external                This is a "proxy" atom produced by a dylib reader.  It has no content.  It exists
 266 //                                      so that all References can be resolved.
 267 //      external-weak   Same as external, but the definition in the dylib is weak.
 268 //
 269 // SymbolTableInclusion:
 270 // An atom may or may not be in the symbol table in an object file.
 271 //  in                          Most atoms for functions or global data
 272 //      not-in                  Anonymous atoms such literal c-strings, or other compiler generated data
 273 //      in-never-strip  Atom whose name the strip tool should never remove (e.g. REFERENCED_DYNAMICALLY in mach-o)
 274 //
 275 // Ordinal:
 276 // When a reader is created it is given a base ordinal number.  All atoms created by the reader
 277 // should return a contiguous range of ordinal values that start at the base ordinal.  The ordinal
 278 // values are used by the linker to sort the atom graph when producing the output file.
 279 //
 280 class Atom
 281 {
 282 public:
 283         enum Scope { scopeTranslationUnit, scopeLinkageUnit, scopeGlobal };
 284         enum DefinitionKind { kRegularDefinition, kWeakDefinition, kTentativeDefinition, kExternalDefinition, kExternalWeakDefinition, kAbsoluteSymbol };
 285         enum ContentType { kUnclassifiedType, kCStringType, kCFIType, kLSDAType, kSectionStart, kSectionEnd, kBranchIsland,
 286                                         kLazyPointer, kStub, kNonLazyPointer, kLazyDylibPointer, kStubHelper };
 287         enum SymbolTableInclusion { kSymbolTableNotIn, kSymbolTableIn, kSymbolTableInAndNeverStrip, kSymbolTableInAsAbsolute };
 288
 289         virtual Reader*                                                 getFile() const = 0;
 290         virtual bool                                                    getTranslationUnitSource(const char** dir, const char** name) const = 0;
 291         virtual const char*                                             getName() const = 0;
 292         virtual const char*                                             getDisplayName() const = 0;
 293         virtual Scope                                                   getScope() const = 0;
 294         virtual DefinitionKind                                  getDefinitionKind() const = 0;
 295         virtual ContentType                                             getContentType() const { return kUnclassifiedType; }
 296         virtual SymbolTableInclusion                    getSymbolTableInclusion() const = 0;
 297         virtual bool                                                    dontDeadStrip() const = 0;
 298         virtual bool                                                    isZeroFill() const = 0;
 299         virtual bool                                                    isThumb() const = 0;
 300         virtual uint64_t                                                getSize() const = 0;
 301         virtual std::vector<ObjectFile::Reference*>&  getReferences() const = 0;
 302         virtual bool                                                    mustRemainInSection() const = 0;
 303         virtual const char*                                             getSectionName() const = 0;
 304         virtual Segment&                                                getSegment() const = 0;
 305         virtual Atom&                                                   getFollowOnAtom() const = 0;
 306         virtual uint32_t                                                getOrdinal() const = 0;
 307         virtual std::vector<LineInfo>*                  getLineInfo() const = 0;
 308         virtual Alignment                                               getAlignment() const = 0;
 309         virtual void                                                    copyRawContent(uint8_t buffer[]) const = 0;
 310         virtual void                                                    setScope(Scope) = 0;
 311         virtual UnwindInfo::iterator                    beginUnwind() { return NULL; }
 312         virtual UnwindInfo::iterator                    endUnwind() { return NULL; }
 313         virtual Reference*                                              getLSDA() { return NULL; }
 314         virtual Reference*                                              getFDE() { return NULL; }
 315         virtual Atom*                                                   getPersonalityPointer() { return NULL; }
 316
 317                         uint64_t                                                getSectionOffset() const        { return fSectionOffset; }
 318                         uint64_t                                                getAddress() const      { return fSection->getBaseAddress() + fSectionOffset; }
 319                         class Section*                                  getSection() const { return fSection; }
 320
 321         virtual void                                                    setSectionOffset(uint64_t offset) { fSectionOffset = offset; }
 322         virtual void                                                    setSection(class Section* sect) { fSection = sect; }
 323
 324 protected:
 325                                                                                         Atom() :  fSectionOffset(0), fSection(NULL) {}
 326                 virtual                                                         ~Atom() {}
 327
 328                 uint64_t                                                        fSectionOffset;
 329                 class Section*                                          fSection;
 330 };
 331
 332
 333 //
 334 // A Reference is a directed edge to another Atom.  When an instruction in
 335 // the content of an Atom refers to another Atom, that is represented by a
 336 // Reference.
 337 //
 338 // There are two kinds of references: direct and by-name.  With a direct Reference,
 339 // the target is bound by the Reader that created it.  For instance a reference to a
 340 // static would produce a direct reference.  A by-name reference requires the linker
 341 // to find the target Atom with the required name in order to be bound.
 342 //
 343 // For a link to succeed all References must be bound.
 344 //
 345 // A Reference has an optional "from" target.  This is used when the content to fix-up
 346 // is the difference of two Atom address.  For instance, if a pointer sized data Atom
 347 // is to contain A - B, then the Atom would have on Reference with a target of "A" and
 348 // a from-target of "B".
 349 //
 350 // A Reference also has a fix-up-offset.  This is the offset into the content of the
 351 // Atom holding the reference where the fix-up (relocation) will be applied.
 352 //
 353 //
 354 //
 355 class Reference
 356 {
 357 public:
 358         enum TargetBinding { kUnboundByName, kBoundDirectly, kBoundByName, kDontBind };
 359
 360         virtual TargetBinding   getTargetBinding() const = 0;
 361         virtual TargetBinding   getFromTargetBinding() const = 0;
 362         virtual uint8_t                 getKind() const = 0;
 363         virtual uint64_t                getFixUpOffset() const = 0;
 364         virtual const char*             getTargetName() const = 0;
 365         virtual Atom&                   getTarget() const = 0;
 366         virtual uint64_t                getTargetOffset() const = 0;
 367         virtual Atom&                   getFromTarget() const = 0;
 368         virtual const char*             getFromTargetName() const = 0;
 369         virtual uint64_t                getFromTargetOffset() const = 0;
 370
 371         virtual void                    setTarget(Atom&, uint64_t offset) = 0;
 372         virtual void                    setFromTarget(Atom&) = 0;
 373         virtual const char*             getDescription() const = 0;
 374         virtual bool                    isBranch() const  { return false; }
 375
 376 protected:
 377                                                         Reference() {}
 378         virtual                                 ~Reference() {}
 379 };
 380
 381
 382 };      // namespace ObjectFile
 383
 384
 385 #endif // __OBJECTFILE__