src/ld/Options.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 #ifndef __OPTIONS__
  26 #define __OPTIONS__
  27
  28
  29 #include <stdint.h>
  30 #include <mach/machine.h>
  31
  32 #include <vector>
  33 #include <ext/hash_set>
  34 #include <ext/hash_map>
  35
  36 #include "ObjectFile.h"
  37
  38 extern void throwf (const char* format, ...) __attribute__ ((noreturn,format(printf, 1, 2)));
  39 extern void warning(const char* format, ...) __attribute__((format(printf, 1, 2)));
  40
  41 class LibraryOptions
  42 {
  43 public:
  44         LibraryOptions() : fWeakImport(false), fReExport(false), fBundleLoader(false), fLazyLoad(false), fForceLoad(false) {}
  45         // for dynamic libraries
  46         bool            fWeakImport;
  47         bool            fReExport;
  48         bool            fBundleLoader;
  49         bool            fLazyLoad;
  50         // for static libraries
  51         bool            fForceLoad;
  52 };
  53
  54
  55
  56 //
  57 // The public interface to the Options class is the abstract representation of what work the linker
  58 // should do.
  59 //
  60 // This abstraction layer will make it easier to support a future where the linker is a shared library
  61 // invoked directly from Xcode.  The target settings in Xcode would be used to directly construct an Options
  62 // object (without building a command line which is then parsed).
  63 //
  64 //
  65 class Options
  66 {
  67 public:
  68         Options(int argc, const char* argv[]);
  69         ~Options();
  70
  71         enum OutputKind { kDynamicExecutable, kStaticExecutable, kDynamicLibrary, kDynamicBundle, kObjectFile, kDyld, kPreload, kKextBundle };
  72         enum NameSpace { kTwoLevelNameSpace, kFlatNameSpace, kForceFlatNameSpace };
  73         // Standard treatment for many options.
  74         enum Treatment { kError, kWarning, kSuppress, kNULL, kInvalid };
  75         enum UndefinedTreatment { kUndefinedError, kUndefinedWarning, kUndefinedSuppress, kUndefinedDynamicLookup };
  76         enum WeakReferenceMismatchTreatment { kWeakReferenceMismatchError, kWeakReferenceMismatchWeak,
  77                                                                                   kWeakReferenceMismatchNonWeak };
  78         enum CommonsMode { kCommonsIgnoreDylibs, kCommonsOverriddenByDylibs, kCommonsConflictsDylibsError };
  79         enum DeadStripMode { kDeadStripOff, kDeadStripOn, kDeadStripOnPlusUnusedInits };
  80         enum UUIDMode { kUUIDNone, kUUIDRandom, kUUIDContent };
  81         enum LocalSymbolHandling { kLocalSymbolsAll, kLocalSymbolsNone, kLocalSymbolsSelectiveInclude, kLocalSymbolsSelectiveExclude };
  82
  83         struct FileInfo {
  84                 const char*                             path;
  85                 uint64_t                                fileLen;
  86                 time_t                                  modTime;
  87                 LibraryOptions                  options;
  88         };
  89
  90         struct ExtraSection {
  91                 const char*                             segmentName;
  92                 const char*                             sectionName;
  93                 const char*                             path;
  94                 const uint8_t*                  data;
  95                 uint64_t                                dataLen;
  96         };
  97
  98         struct SectionAlignment {
  99                 const char*                             segmentName;
 100                 const char*                             sectionName;
 101                 uint8_t                                 alignment;
 102         };
 103
 104         struct OrderedSymbol {
 105                 const char*                             symbolName;
 106                 const char*                             objectFileName;
 107         };
 108
 109         struct SegmentStart {
 110                 const char*                             name;
 111                 uint64_t                                address;
 112         };
 113
 114         struct SegmentSize {
 115                 const char*                             name;
 116                 uint64_t                                size;
 117         };
 118
 119         struct SegmentProtect {
 120                 const char*                             name;
 121                 uint32_t                                max;
 122                 uint32_t                                init;
 123         };
 124
 125         struct DylibOverride {
 126                 const char*                             installName;
 127                 const char*                             useInstead;
 128         };
 129
 130
 131         const ObjectFile::ReaderOptions&        readerOptions();
 132         const char*                                                     getOutputFilePath();
 133         std::vector<FileInfo>&                          getInputFiles();
 134
 135         cpu_type_t                                      architecture() { return fArchitecture; }
 136         bool                                            preferSubArchitecture() { return fHasPreferredSubType; }
 137         cpu_subtype_t                           subArchitecture() { return fSubArchitecture; }
 138         bool                                            allowSubArchitectureMismatches() { return fAllowCpuSubtypeMismatches; }
 139         OutputKind                                      outputKind();
 140         bool                                            prebind();
 141         bool                                            bindAtLoad();
 142         bool                                            fullyLoadArchives();
 143         NameSpace                                       nameSpace();
 144         const char*                                     installPath();                  // only for kDynamicLibrary
 145         uint32_t                                        currentVersion();               // only for kDynamicLibrary
 146         uint32_t                                        compatibilityVersion(); // only for kDynamicLibrary
 147         const char*                                     entryName();                    // only for kDynamicExecutable or kStaticExecutable
 148         const char*                                     executablePath();
 149         uint64_t                                        baseAddress();
 150         bool                                            keepPrivateExterns();                   // only for kObjectFile
 151         bool                                            needsModuleTable();                             // only for kDynamicLibrary
 152         bool                                            interposable(const char* name);
 153         bool                                            hasExportRestrictList();                // -exported_symbol or -unexported_symbol
 154         bool                                            hasExportMaskList();                    // just -exported_symbol
 155         bool                                            hasWildCardExportRestrictList();
 156         bool                                            allGlobalsAreDeadStripRoots();
 157         bool                                            shouldExport(const char*);
 158         bool                                            ignoreOtherArchInputFiles();
 159         bool                                            forceCpuSubtypeAll();
 160         bool                                            traceDylibs();
 161         bool                                            traceArchives();
 162         DeadStripMode                           deadStrip();
 163         UndefinedTreatment                      undefinedTreatment();
 164         ObjectFile::ReaderOptions::MacVersionMin        macosxVersionMin() { return fReaderOptions.fMacVersionMin; }
 165         ObjectFile::ReaderOptions::IPhoneVersionMin     iphoneOSVersionMin() { return fReaderOptions.fIPhoneVersionMin; }
 166         bool                                            minOS(ObjectFile::ReaderOptions::MacVersionMin mac, ObjectFile::ReaderOptions::IPhoneVersionMin iPhoneOS);
 167         bool                                            messagesPrefixedWithArchitecture();
 168         Treatment                                       picTreatment();
 169         WeakReferenceMismatchTreatment  weakReferenceMismatchTreatment();
 170         const char*                                     umbrellaName();
 171         std::vector<const char*>&       allowableClients();
 172         const char*                                     clientName();
 173         const char*                                     initFunctionName();                     // only for kDynamicLibrary
 174         const char*                                     dotOutputFile();
 175         uint64_t                                        zeroPageSize();
 176         bool                                            hasCustomStack();
 177         uint64_t                                        customStackSize();
 178         uint64_t                                        customStackAddr();
 179         bool                                            hasExecutableStack();
 180         std::vector<const char*>&       initialUndefines();
 181         bool                                            printWhyLive(const char* name);
 182         uint32_t                                        minimumHeaderPad();
 183         uint64_t                                        segmentAlignment() { return fSegmentAlignment; }
 184         bool                                            maxMminimumHeaderPad() { return fMaxMinimumHeaderPad; }
 185         std::vector<ExtraSection>&      extraSections();
 186         std::vector<SectionAlignment>&  sectionAlignments();
 187         CommonsMode                                     commonsMode();
 188         bool                                            warnCommons();
 189         bool                                            keepRelocations();
 190         FileInfo                                        findFile(const char* path);
 191         UUIDMode                                        getUUIDMode() { return fUUIDMode; }
 192         bool                                            warnStabs();
 193         bool                                            pauseAtEnd() { return fPause; }
 194         bool                                            printStatistics() { return fStatistics; }
 195         bool                                            printArchPrefix() { return fMessagesPrefixedWithArchitecture; }
 196         void                                            gotoClassicLinker(int argc, const char* argv[]);
 197         bool                                            sharedRegionEligible() { return fSharedRegionEligible; }
 198         bool                                            printOrderFileStatistics() { return fPrintOrderFileStatistics; }
 199         const char*                                     dTraceScriptName() { return fDtraceScriptName; }
 200         bool                                            dTrace() { return (fDtraceScriptName != NULL); }
 201         std::vector<OrderedSymbol>&     orderedSymbols() { return fOrderedSymbols; }
 202         bool                                            splitSeg() { return fSplitSegs; }
 203         uint64_t                                        baseWritableAddress() { return fBaseWritableAddress; }
 204         std::vector<SegmentStart>&      customSegmentAddresses() { return fCustomSegmentAddresses; }
 205         std::vector<SegmentSize>&       customSegmentSizes() { return fCustomSegmentSizes; }
 206         std::vector<SegmentProtect>& customSegmentProtections() { return fCustomSegmentProtections; }
 207         bool                                            saveTempFiles() { return fSaveTempFiles; }
 208         const std::vector<const char*>&   rpaths() { return fRPaths; }
 209         bool                                            readOnlyx86Stubs() { return fReadOnlyx86Stubs; }
 210         std::vector<DylibOverride>&     dylibOverrides() { return fDylibOverrides; }
 211         const char*                                     generatedMapPath() { return fMapPath; }
 212         bool                                            positionIndependentExecutable() { return fPositionIndependentExecutable; }
 213         Options::FileInfo                       findFileUsingPaths(const char* path);
 214         bool                                            deadStripDylibs() { return fDeadStripDylibs; }
 215         bool                                            allowedUndefined(const char* name) { return ( fAllowedUndefined.find(name) != fAllowedUndefined.end() ); }
 216         bool                                            someAllowedUndefines() { return (fAllowedUndefined.size() != 0); }
 217         LocalSymbolHandling                     localSymbolHandling() { return fLocalSymbolHandling; }
 218         bool                                            keepLocalSymbol(const char* symbolName);
 219         bool                                            allowTextRelocs() { return fAllowTextRelocs; }
 220         bool                                            warnAboutTextRelocs() { return fWarnTextRelocs; }
 221         bool                                            usingLazyDylibLinking() { return fUsingLazyDylibLinking; }
 222         bool                                            verbose() { return fVerbose; }
 223         bool                                            makeEncryptable() { return fEncryptable; }
 224         bool                                            needsUnwindInfoSection() { return fReaderOptions.fAddCompactUnwindEncoding; }
 225         std::vector<const char*>&       llvmOptions() { return fLLVMOptions; }
 226         bool                                            makeClassicDyldInfo() { return fMakeClassicDyldInfo; }
 227         bool                                            makeCompressedDyldInfo() { return fMakeCompressedDyldInfo; }
 228         bool                                            hasExportedSymbolOrder();
 229         bool                                            exportedSymbolOrder(const char* sym, unsigned int* order);
 230         bool                                            orderData() { return fOrderData; }
 231         bool                                            errorOnOtherArchFiles() { return fErrorOnOtherArchFiles; }
 232         bool                                            markAutoDeadStripDylib() { return fMarkDeadStrippableDylib; }
 233         bool                                            removeEHLabels() { return fReaderOptions.fNoEHLabels; }
 234         bool                                            useSimplifiedDylibReExports() { return fUseSimplifiedDylibReExports; }
 235         bool                                            objCABIVersion2POverride() { return fObjCABIVersion2POverride; }
 236
 237 private:
 238         class CStringEquals
 239         {
 240         public:
 241                 bool operator()(const char* left, const char* right) const { return (strcmp(left, right) == 0); }
 242         };
 243         typedef __gnu_cxx::hash_map<const char*, unsigned int, __gnu_cxx::hash<const char*>, CStringEquals> NameToOrder;
 244         typedef __gnu_cxx::hash_set<const char*, __gnu_cxx::hash<const char*>, CStringEquals>  NameSet;
 245         enum ExportMode { kExportDefault, kExportSome, kDontExportSome };
 246         enum LibrarySearchMode { kSearchDylibAndArchiveInEachDir, kSearchAllDirsForDylibsThenAllDirsForArchives };
 247         enum InterposeMode { kInterposeNone, kInterposeAllExternal, kInterposeSome };
 248
 249         class SetWithWildcards {
 250         public:
 251                 void                                    insert(const char*);
 252                 bool                                    contains(const char*);
 253                 bool                                    hasWildCards()  { return !fWildCard.empty(); }
 254                 NameSet::iterator               regularBegin()  { return fRegular.begin(); }
 255                 NameSet::iterator               regularEnd()    { return fRegular.end(); }
 256         private:
 257                 static bool                             hasWildCards(const char*);
 258                 bool                                    wildCardMatch(const char* pattern, const char* candidate);
 259                 bool                                    inCharRange(const char*& range, unsigned char c);
 260
 261                 NameSet                                                 fRegular;
 262                 std::vector<const char*>                fWildCard;
 263         };
 264
 265
 266         void                                            parse(int argc, const char* argv[]);
 267         void                                            checkIllegalOptionCombinations();
 268         void                                            buildSearchPaths(int argc, const char* argv[]);
 269         void                                            parseArch(const char* architecture);
 270         FileInfo                                        findLibrary(const char* rootName, bool dylibsOnly=false);
 271         FileInfo                                        findFramework(const char* frameworkName);
 272         FileInfo                                        findFramework(const char* rootName, const char* suffix);
 273         bool                                            checkForFile(const char* format, const char* dir, const char* rootName,
 274                                                                                          FileInfo& result);
 275         uint32_t                                        parseVersionNumber(const char*);
 276         void                                            parseSectionOrderFile(const char* segment, const char* section, const char* path);
 277         void                                            parseOrderFile(const char* path, bool cstring);
 278         void                                            addSection(const char* segment, const char* section, const char* path);
 279         void                                            addSubLibrary(const char* name);
 280         void                                            loadFileList(const char* fileOfPaths);
 281         uint64_t                                        parseAddress(const char* addr);
 282         void                                            loadExportFile(const char* fileOfExports, const char* option, SetWithWildcards& set);
 283         void                                            parseAliasFile(const char* fileOfAliases);
 284         void                                            parsePreCommandLineEnvironmentSettings();
 285         void                                            parsePostCommandLineEnvironmentSettings();
 286         void                                            setUndefinedTreatment(const char* treatment);
 287         void                                            setMacOSXVersionMin(const char* version);
 288         void                                            setIPhoneVersionMin(const char* version);
 289         void                                            setWeakReferenceMismatchTreatment(const char* treatment);
 290         void                                            addDylibOverride(const char* paths);
 291         void                                            addSectionAlignment(const char* segment, const char* section, const char* alignment);
 292         CommonsMode                                     parseCommonsTreatment(const char* mode);
 293         Treatment                                       parseTreatment(const char* treatment);
 294         void                                            reconfigureDefaults();
 295         void                                            checkForClassic(int argc, const char* argv[]);
 296         void                                            parseSegAddrTable(const char* segAddrPath, const char* installPath);
 297         void                                            addLibrary(const FileInfo& info);
 298         void                                            warnObsolete(const char* arg);
 299         uint32_t                                        parseProtection(const char* prot);
 300         void                                            loadSymbolOrderFile(const char* fileOfExports, NameToOrder& orderMapping);
 301
 302
 303         ObjectFile::ReaderOptions                       fReaderOptions;
 304         const char*                                                     fOutputFile;
 305         std::vector<Options::FileInfo>          fInputFiles;
 306         cpu_type_t                                                      fArchitecture;
 307         cpu_subtype_t                                           fSubArchitecture;
 308         OutputKind                                                      fOutputKind;
 309         bool                                                            fHasPreferredSubType;
 310         bool                                                            fPrebind;
 311         bool                                                            fBindAtLoad;
 312         bool                                                            fKeepPrivateExterns;
 313         bool                                                            fNeedsModuleTable;
 314         bool                                                            fIgnoreOtherArchFiles;
 315         bool                                                            fErrorOnOtherArchFiles;
 316         bool                                                            fForceSubtypeAll;
 317         InterposeMode                                           fInterposeMode;
 318         DeadStripMode                                           fDeadStrip;
 319         NameSpace                                                       fNameSpace;
 320         uint32_t                                                        fDylibCompatVersion;
 321         uint32_t                                                        fDylibCurrentVersion;
 322         const char*                                                     fDylibInstallName;
 323         const char*                                                     fFinalName;
 324         const char*                                                     fEntryName;
 325         uint64_t                                                        fBaseAddress;
 326         uint64_t                                                        fBaseWritableAddress;
 327         bool                                                            fSplitSegs;
 328         SetWithWildcards                                        fExportSymbols;
 329         SetWithWildcards                                        fDontExportSymbols;
 330         SetWithWildcards                                        fInterposeList;
 331         NameToOrder                                                     fExportSymbolsOrder;
 332         ExportMode                                                      fExportMode;
 333         LibrarySearchMode                                       fLibrarySearchMode;
 334         UndefinedTreatment                                      fUndefinedTreatment;
 335         bool                                                            fMessagesPrefixedWithArchitecture;
 336         WeakReferenceMismatchTreatment          fWeakReferenceMismatchTreatment;
 337         std::vector<const char*>                        fSubUmbellas;
 338         std::vector<const char*>                        fSubLibraries;
 339         std::vector<const char*>                        fAllowableClients;
 340         std::vector<const char*>                        fRPaths;
 341         const char*                                                     fClientName;
 342         const char*                                                     fUmbrellaName;
 343         const char*                                                     fInitFunctionName;
 344         const char*                                                     fDotOutputFile;
 345         const char*                                                     fExecutablePath;
 346         const char*                                                     fBundleLoader;
 347         const char*                                                     fDtraceScriptName;
 348         const char*                                                     fSegAddrTablePath;
 349         const char*                                                     fMapPath;
 350         uint64_t                                                        fZeroPageSize;
 351         uint64_t                                                        fStackSize;
 352         uint64_t                                                        fStackAddr;
 353         bool                                                            fExecutableStack;
 354         uint32_t                                                        fMinimumHeaderPad;
 355         uint64_t                                                        fSegmentAlignment;
 356         CommonsMode                                                     fCommonsMode;
 357         UUIDMode                                                        fUUIDMode;
 358         SetWithWildcards                                        fLocalSymbolsIncluded;
 359         SetWithWildcards                                        fLocalSymbolsExcluded;
 360         LocalSymbolHandling                                     fLocalSymbolHandling;
 361         bool                                                            fWarnCommons;
 362         bool                                                            fVerbose;
 363         bool                                                            fKeepRelocations;
 364         bool                                                            fWarnStabs;
 365         bool                                                            fTraceDylibSearching;
 366         bool                                                            fPause;
 367         bool                                                            fStatistics;
 368         bool                                                            fPrintOptions;
 369         bool                                                            fSharedRegionEligible;
 370         bool                                                            fPrintOrderFileStatistics;
 371         bool                                                            fReadOnlyx86Stubs;
 372         bool                                                            fPositionIndependentExecutable;
 373         bool                                                            fDisablePositionIndependentExecutable;
 374         bool                                                            fMaxMinimumHeaderPad;
 375         bool                                                            fDeadStripDylibs;
 376         bool                                                            fAllowTextRelocs;
 377         bool                                                            fWarnTextRelocs;
 378         bool                                                            fUsingLazyDylibLinking;
 379         bool                                                            fEncryptable;
 380         bool                                                            fOrderData;
 381         bool                                                            fMarkDeadStrippableDylib;
 382         bool                                                            fMakeClassicDyldInfo;
 383         bool                                                            fMakeCompressedDyldInfo;
 384         bool                                                            fNoEHLabels;
 385         bool                                                            fAllowCpuSubtypeMismatches;
 386         bool                                                            fUseSimplifiedDylibReExports;
 387         bool                                                            fObjCABIVersion2POverride;
 388         std::vector<const char*>                        fInitialUndefines;
 389         NameSet                                                         fAllowedUndefined;
 390         NameSet                                                         fWhyLive;
 391         std::vector<ExtraSection>                       fExtraSections;
 392         std::vector<SectionAlignment>           fSectionAlignments;
 393         std::vector<OrderedSymbol>                      fOrderedSymbols;
 394         std::vector<SegmentStart>                       fCustomSegmentAddresses;
 395         std::vector<SegmentSize>                        fCustomSegmentSizes;
 396         std::vector<SegmentProtect>                     fCustomSegmentProtections;
 397         std::vector<DylibOverride>                      fDylibOverrides;
 398         std::vector<const char*>                        fLLVMOptions;
 399         std::vector<const char*>                        fLibrarySearchPaths;
 400         std::vector<const char*>                        fFrameworkSearchPaths;
 401         std::vector<const char*>                        fSDKPaths;
 402         bool                                                            fSaveTempFiles;
 403 };
 404
 405
 406
 407 #endif // __OPTIONS__