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
 236 private:
 237         class CStringEquals
 238         {
 239         public:
 240                 bool operator()(const char* left, const char* right) const { return (strcmp(left, right) == 0); }
 241         };
 242         typedef __gnu_cxx::hash_map<const char*, unsigned int, __gnu_cxx::hash<const char*>, CStringEquals> NameToOrder;
 243         typedef __gnu_cxx::hash_set<const char*, __gnu_cxx::hash<const char*>, CStringEquals>  NameSet;
 244         enum ExportMode { kExportDefault, kExportSome, kDontExportSome };
 245         enum LibrarySearchMode { kSearchDylibAndArchiveInEachDir, kSearchAllDirsForDylibsThenAllDirsForArchives };
 246         enum InterposeMode { kInterposeNone, kInterposeAllExternal, kInterposeSome };
 247
 248         class SetWithWildcards {
 249         public:
 250                 void                                    insert(const char*);
 251                 bool                                    contains(const char*);
 252                 bool                                    hasWildCards()  { return !fWildCard.empty(); }
 253                 NameSet::iterator               regularBegin()  { return fRegular.begin(); }
 254                 NameSet::iterator               regularEnd()    { return fRegular.end(); }
 255         private:
 256                 static bool                             hasWildCards(const char*);
 257                 bool                                    wildCardMatch(const char* pattern, const char* candidate);
 258                 bool                                    inCharRange(const char*& range, unsigned char c);
 259
 260                 NameSet                                                 fRegular;
 261                 std::vector<const char*>                fWildCard;
 262         };
 263
 264
 265         void                                            parse(int argc, const char* argv[]);
 266         void                                            checkIllegalOptionCombinations();
 267         void                                            buildSearchPaths(int argc, const char* argv[]);
 268         void                                            parseArch(const char* architecture);
 269         FileInfo                                        findLibrary(const char* rootName, bool dylibsOnly=false);
 270         FileInfo                                        findFramework(const char* frameworkName);
 271         FileInfo                                        findFramework(const char* rootName, const char* suffix);
 272         bool                                            checkForFile(const char* format, const char* dir, const char* rootName,
 273                                                                                          FileInfo& result);
 274         uint32_t                                        parseVersionNumber(const char*);
 275         void                                            parseSectionOrderFile(const char* segment, const char* section, const char* path);
 276         void                                            parseOrderFile(const char* path, bool cstring);
 277         void                                            addSection(const char* segment, const char* section, const char* path);
 278         void                                            addSubLibrary(const char* name);
 279         void                                            loadFileList(const char* fileOfPaths);
 280         uint64_t                                        parseAddress(const char* addr);
 281         void                                            loadExportFile(const char* fileOfExports, const char* option, SetWithWildcards& set);
 282         void                                            parseAliasFile(const char* fileOfAliases);
 283         void                                            parsePreCommandLineEnvironmentSettings();
 284         void                                            parsePostCommandLineEnvironmentSettings();
 285         void                                            setUndefinedTreatment(const char* treatment);
 286         void                                            setMacOSXVersionMin(const char* version);
 287         void                                            setIPhoneVersionMin(const char* version);
 288         void                                            setWeakReferenceMismatchTreatment(const char* treatment);
 289         void                                            addDylibOverride(const char* paths);
 290         void                                            addSectionAlignment(const char* segment, const char* section, const char* alignment);
 291         CommonsMode                                     parseCommonsTreatment(const char* mode);
 292         Treatment                                       parseTreatment(const char* treatment);
 293         void                                            reconfigureDefaults();
 294         void                                            checkForClassic(int argc, const char* argv[]);
 295         void                                            parseSegAddrTable(const char* segAddrPath, const char* installPath);
 296         void                                            addLibrary(const FileInfo& info);
 297         void                                            warnObsolete(const char* arg);
 298         uint32_t                                        parseProtection(const char* prot);
 299         void                                            loadSymbolOrderFile(const char* fileOfExports, NameToOrder& orderMapping);
 300
 301
 302         ObjectFile::ReaderOptions                       fReaderOptions;
 303         const char*                                                     fOutputFile;
 304         std::vector<Options::FileInfo>          fInputFiles;
 305         cpu_type_t                                                      fArchitecture;
 306         cpu_subtype_t                                           fSubArchitecture;
 307         OutputKind                                                      fOutputKind;
 308         bool                                                            fHasPreferredSubType;
 309         bool                                                            fPrebind;
 310         bool                                                            fBindAtLoad;
 311         bool                                                            fKeepPrivateExterns;
 312         bool                                                            fNeedsModuleTable;
 313         bool                                                            fIgnoreOtherArchFiles;
 314         bool                                                            fErrorOnOtherArchFiles;
 315         bool                                                            fForceSubtypeAll;
 316         InterposeMode                                           fInterposeMode;
 317         DeadStripMode                                           fDeadStrip;
 318         NameSpace                                                       fNameSpace;
 319         uint32_t                                                        fDylibCompatVersion;
 320         uint32_t                                                        fDylibCurrentVersion;
 321         const char*                                                     fDylibInstallName;
 322         const char*                                                     fFinalName;
 323         const char*                                                     fEntryName;
 324         uint64_t                                                        fBaseAddress;
 325         uint64_t                                                        fBaseWritableAddress;
 326         bool                                                            fSplitSegs;
 327         SetWithWildcards                                        fExportSymbols;
 328         SetWithWildcards                                        fDontExportSymbols;
 329         SetWithWildcards                                        fInterposeList;
 330         NameToOrder                                                     fExportSymbolsOrder;
 331         ExportMode                                                      fExportMode;
 332         LibrarySearchMode                                       fLibrarySearchMode;
 333         UndefinedTreatment                                      fUndefinedTreatment;
 334         bool                                                            fMessagesPrefixedWithArchitecture;
 335         WeakReferenceMismatchTreatment          fWeakReferenceMismatchTreatment;
 336         std::vector<const char*>                        fSubUmbellas;
 337         std::vector<const char*>                        fSubLibraries;
 338         std::vector<const char*>                        fAllowableClients;
 339         std::vector<const char*>                        fRPaths;
 340         const char*                                                     fClientName;
 341         const char*                                                     fUmbrellaName;
 342         const char*                                                     fInitFunctionName;
 343         const char*                                                     fDotOutputFile;
 344         const char*                                                     fExecutablePath;
 345         const char*                                                     fBundleLoader;
 346         const char*                                                     fDtraceScriptName;
 347         const char*                                                     fSegAddrTablePath;
 348         const char*                                                     fMapPath;
 349         uint64_t                                                        fZeroPageSize;
 350         uint64_t                                                        fStackSize;
 351         uint64_t                                                        fStackAddr;
 352         bool                                                            fExecutableStack;
 353         uint32_t                                                        fMinimumHeaderPad;
 354         uint64_t                                                        fSegmentAlignment;
 355         CommonsMode                                                     fCommonsMode;
 356         UUIDMode                                                        fUUIDMode;
 357         SetWithWildcards                                        fLocalSymbolsIncluded;
 358         SetWithWildcards                                        fLocalSymbolsExcluded;
 359         LocalSymbolHandling                                     fLocalSymbolHandling;
 360         bool                                                            fWarnCommons;
 361         bool                                                            fVerbose;
 362         bool                                                            fKeepRelocations;
 363         bool                                                            fWarnStabs;
 364         bool                                                            fTraceDylibSearching;
 365         bool                                                            fPause;
 366         bool                                                            fStatistics;
 367         bool                                                            fPrintOptions;
 368         bool                                                            fSharedRegionEligible;
 369         bool                                                            fPrintOrderFileStatistics;
 370         bool                                                            fReadOnlyx86Stubs;
 371         bool                                                            fPositionIndependentExecutable;
 372         bool                                                            fMaxMinimumHeaderPad;
 373         bool                                                            fDeadStripDylibs;
 374         bool                                                            fAllowTextRelocs;
 375         bool                                                            fWarnTextRelocs;
 376         bool                                                            fUsingLazyDylibLinking;
 377         bool                                                            fEncryptable;
 378         bool                                                            fOrderData;
 379         bool                                                            fMarkDeadStrippableDylib;
 380         bool                                                            fMakeClassicDyldInfo;
 381         bool                                                            fMakeCompressedDyldInfo;
 382         bool                                                            fNoEHLabels;
 383         bool                                                            fAllowCpuSubtypeMismatches;
 384         bool                                                            fUseSimplifiedDylibReExports;
 385         std::vector<const char*>                        fInitialUndefines;
 386         NameSet                                                         fAllowedUndefined;
 387         NameSet                                                         fWhyLive;
 388         std::vector<ExtraSection>                       fExtraSections;
 389         std::vector<SectionAlignment>           fSectionAlignments;
 390         std::vector<OrderedSymbol>                      fOrderedSymbols;
 391         std::vector<SegmentStart>                       fCustomSegmentAddresses;
 392         std::vector<SegmentSize>                        fCustomSegmentSizes;
 393         std::vector<SegmentProtect>                     fCustomSegmentProtections;
 394         std::vector<DylibOverride>                      fDylibOverrides;
 395         std::vector<const char*>                        fLLVMOptions;
 396         std::vector<const char*>                        fLibrarySearchPaths;
 397         std::vector<const char*>                        fFrameworkSearchPaths;
 398         std::vector<const char*>                        fSDKPaths;
 399         bool                                                            fSaveTempFiles;
 400 };
 401
 402
 403
 404 #endif // __OPTIONS__