src/ld/Options.h

/* -*- mode: C++; c-basic-offset: 4; tab-width: 4 -*-
 *
 * Copyright (c) 2005-2007 Apple  Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 *
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 *
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 *
 * @APPLE_LICENSE_HEADER_END@
 */

#ifndef __OPTIONS__
#define __OPTIONS__


#include <stdint.h>
#include <mach/machine.h>

#include <vector>
#include <ext/hash_set>
#include <ext/hash_map>

#include "ObjectFile.h"

extern void throwf (const char* format, ...) __attribute__ ((noreturn,format(printf, 1, 2)));
extern void warning(const char* format, ...) __attribute__((format(printf, 1, 2)));

class LibraryOptions
{
public:
	LibraryOptions() : fWeakImport(false), fReExport(false), fBundleLoader(false), fLazyLoad(false), fForceLoad(false) {}
	// for dynamic libraries
	bool		fWeakImport;
	bool		fReExport;
	bool		fBundleLoader;
	bool		fLazyLoad;
	// for static libraries
	bool		fForceLoad;
};


//
// The public interface to the Options class is the abstract representation of what work the linker
// should do.
//
// This abstraction layer will make it easier to support a future where the linker is a shared library
// invoked directly from Xcode.  The target settings in Xcode would be used to directly construct an Options
// object (without building a command line which is then parsed).
//
//
class Options
{
public:
	Options(int argc, const char* argv[]);
	~Options();

	enum OutputKind { kDynamicExecutable, kStaticExecutable, kDynamicLibrary, kDynamicBundle, kObjectFile, kDyld, kPreload, kKextBundle };
	enum NameSpace { kTwoLevelNameSpace, kFlatNameSpace, kForceFlatNameSpace };
	// Standard treatment for many options.
	enum Treatment { kError, kWarning, kSuppress, kNULL, kInvalid };
	enum UndefinedTreatment { kUndefinedError, kUndefinedWarning, kUndefinedSuppress, kUndefinedDynamicLookup };
	enum WeakReferenceMismatchTreatment { kWeakReferenceMismatchError, kWeakReferenceMismatchWeak,
										  kWeakReferenceMismatchNonWeak };
	enum CommonsMode { kCommonsIgnoreDylibs, kCommonsOverriddenByDylibs, kCommonsConflictsDylibsError };
	enum DeadStripMode { kDeadStripOff, kDeadStripOn, kDeadStripOnPlusUnusedInits };
	enum UUIDMode { kUUIDNone, kUUIDRandom, kUUIDContent };
	enum LocalSymbolHandling { kLocalSymbolsAll, kLocalSymbolsNone, kLocalSymbolsSelectiveInclude, kLocalSymbolsSelectiveExclude };

	struct FileInfo {
		const char*				path;
		uint64_t				fileLen;
		time_t					modTime;
		LibraryOptions			options;
	};

	struct ExtraSection {
		const char*				segmentName;
		const char*				sectionName;
		const char*				path;
		const uint8_t*			data;
		uint64_t				dataLen;
	};

	struct SectionAlignment {
		const char*				segmentName;
		const char*				sectionName;
		uint8_t					alignment;
	};

	struct OrderedSymbol {
		const char*				symbolName;
		const char*				objectFileName;
	};

	struct SegmentStart {
		const char*				name;
		uint64_t				address;
	};

	struct SegmentSize {
		const char*				name;
		uint64_t				size;
	};

	struct SegmentProtect {
		const char*				name;
		uint32_t				max;
		uint32_t				init;
	};

	struct DylibOverride {
		const char*				installName;
		const char*				useInstead;
	};


	const ObjectFile::ReaderOptions&	readerOptions();
	const char*							getOutputFilePath();
	std::vector<FileInfo>&				getInputFiles();

	cpu_type_t					architecture() { return fArchitecture; }
	bool						preferSubArchitecture() { return fHasPreferredSubType; }
	cpu_subtype_t				subArchitecture() { return fSubArchitecture; }
	bool						allowSubArchitectureMismatches() { return fAllowCpuSubtypeMismatches; }
	OutputKind					outputKind();
	bool						prebind();
	bool						bindAtLoad();
	bool						fullyLoadArchives();
	NameSpace					nameSpace();
	const char*					installPath();			// only for kDynamicLibrary
	uint32_t					currentVersion();		// only for kDynamicLibrary
	uint32_t					compatibilityVersion();	// only for kDynamicLibrary
	const char*					entryName();			// only for kDynamicExecutable or kStaticExecutable
	const char*					executablePath();
	uint64_t					baseAddress();
	bool						keepPrivateExterns();			// only for kObjectFile
	bool						needsModuleTable();				// only for kDynamicLibrary
	bool						interposable(const char* name);
	bool						hasExportRestrictList();		// -exported_symbol or -unexported_symbol
	bool						hasExportMaskList();			// just -exported_symbol
	bool						hasWildCardExportRestrictList();
	bool						allGlobalsAreDeadStripRoots();
	bool						shouldExport(const char*);
	bool						ignoreOtherArchInputFiles();
	bool						forceCpuSubtypeAll();
	bool						traceDylibs();
	bool						traceArchives();
	DeadStripMode				deadStrip();
	UndefinedTreatment			undefinedTreatment();
	ObjectFile::ReaderOptions::MacVersionMin	macosxVersionMin() { return fReaderOptions.fMacVersionMin; }
	ObjectFile::ReaderOptions::IPhoneVersionMin	iphoneOSVersionMin() { return fReaderOptions.fIPhoneVersionMin; }
	bool						minOS(ObjectFile::ReaderOptions::MacVersionMin mac, ObjectFile::ReaderOptions::IPhoneVersionMin iPhoneOS);
	bool						messagesPrefixedWithArchitecture();
	Treatment					picTreatment();
	WeakReferenceMismatchTreatment	weakReferenceMismatchTreatment();
	const char*					umbrellaName();
	std::vector<const char*>&	allowableClients();
	const char*					clientName();
	const char*					initFunctionName();			// only for kDynamicLibrary
	const char*					dotOutputFile();
	uint64_t					zeroPageSize();
	bool						hasCustomStack();
	uint64_t					customStackSize();
	uint64_t					customStackAddr();
	bool						hasExecutableStack();
	std::vector<const char*>&	initialUndefines();
	bool						printWhyLive(const char* name);
	uint32_t					minimumHeaderPad();
	uint64_t					segmentAlignment() { return fSegmentAlignment; }
	bool						maxMminimumHeaderPad() { return fMaxMinimumHeaderPad; }
	std::vector<ExtraSection>&	extraSections();
	std::vector<SectionAlignment>&	sectionAlignments();
	CommonsMode					commonsMode();
	bool						warnCommons();
	bool						keepRelocations();
	FileInfo					findFile(const char* path);
	UUIDMode					getUUIDMode() { return fUUIDMode; }
	bool						warnStabs();
	bool						pauseAtEnd() { return fPause; }
	bool						printStatistics() { return fStatistics; }
	bool						printArchPrefix() { return fMessagesPrefixedWithArchitecture; }
	void						gotoClassicLinker(int argc, const char* argv[]);
	bool						sharedRegionEligible() { return fSharedRegionEligible; }
	bool						printOrderFileStatistics() { return fPrintOrderFileStatistics; }
	const char*					dTraceScriptName() { return fDtraceScriptName; }
	bool						dTrace() { return (fDtraceScriptName != NULL); }
	std::vector<OrderedSymbol>&	orderedSymbols() { return fOrderedSymbols; }
	bool						splitSeg() { return fSplitSegs; }
	uint64_t					baseWritableAddress() { return fBaseWritableAddress; }
	std::vector<SegmentStart>&	customSegmentAddresses() { return fCustomSegmentAddresses; }
	std::vector<SegmentSize>&	customSegmentSizes() { return fCustomSegmentSizes; }
	std::vector<SegmentProtect>& customSegmentProtections() { return fCustomSegmentProtections; }
	bool						saveTempFiles() { return fSaveTempFiles; }
	const std::vector<const char*>&   rpaths() { return fRPaths; }
	bool						readOnlyx86Stubs() { return fReadOnlyx86Stubs; }
	std::vector<DylibOverride>&	dylibOverrides() { return fDylibOverrides; }
	const char*					generatedMapPath() { return fMapPath; }
	bool						positionIndependentExecutable() { return fPositionIndependentExecutable; }
	Options::FileInfo			findFileUsingPaths(const char* path);
	bool						deadStripDylibs() { return fDeadStripDylibs; }
	bool						allowedUndefined(const char* name) { return ( fAllowedUndefined.find(name) != fAllowedUndefined.end() ); }
	bool						someAllowedUndefines() { return (fAllowedUndefined.size() != 0); }
	LocalSymbolHandling			localSymbolHandling() { return fLocalSymbolHandling; }
	bool						keepLocalSymbol(const char* symbolName);
	bool						allowTextRelocs() { return fAllowTextRelocs; }
	bool						warnAboutTextRelocs() { return fWarnTextRelocs; }
	bool						usingLazyDylibLinking() { return fUsingLazyDylibLinking; }
	bool						verbose() { return fVerbose; }
	bool						makeEncryptable() { return fEncryptable; }
	bool						needsUnwindInfoSection() { return fReaderOptions.fAddCompactUnwindEncoding; }
	std::vector<const char*>&	llvmOptions() { return fLLVMOptions; }
	bool						makeClassicDyldInfo() { return fMakeClassicDyldInfo; }
	bool						makeCompressedDyldInfo() { return fMakeCompressedDyldInfo; }
	bool						hasExportedSymbolOrder();
	bool						exportedSymbolOrder(const char* sym, unsigned int* order);
	bool						orderData() { return fOrderData; }
	bool						errorOnOtherArchFiles() { return fErrorOnOtherArchFiles; }
	bool						markAutoDeadStripDylib() { return fMarkDeadStrippableDylib; }
	bool						removeEHLabels() { return fReaderOptions.fNoEHLabels; }
	bool						useSimplifiedDylibReExports() { return fUseSimplifiedDylibReExports; }

private:
	class CStringEquals
	{
	public:
		bool operator()(const char* left, const char* right) const { return (strcmp(left, right) == 0); }
	};
	typedef __gnu_cxx::hash_map<const char*, unsigned int, __gnu_cxx::hash<const char*>, CStringEquals> NameToOrder;
	typedef __gnu_cxx::hash_set<const char*, __gnu_cxx::hash<const char*>, CStringEquals>  NameSet;
	enum ExportMode { kExportDefault, kExportSome, kDontExportSome };
	enum LibrarySearchMode { kSearchDylibAndArchiveInEachDir, kSearchAllDirsForDylibsThenAllDirsForArchives };
	enum InterposeMode { kInterposeNone, kInterposeAllExternal, kInterposeSome };

	class SetWithWildcards {
	public:
		void					insert(const char*);
		bool					contains(const char*);
		bool					hasWildCards()	{ return !fWildCard.empty(); }
		NameSet::iterator		regularBegin()	{ return fRegular.begin(); }
		NameSet::iterator		regularEnd()	{ return fRegular.end(); }
	private:
		static bool				hasWildCards(const char*);
		bool					wildCardMatch(const char* pattern, const char* candidate);
		bool					inCharRange(const char*& range, unsigned char c);

		NameSet							fRegular;
		std::vector<const char*>		fWildCard;
	};


	void						parse(int argc, const char* argv[]);
	void						checkIllegalOptionCombinations();
	void						buildSearchPaths(int argc, const char* argv[]);
	void						parseArch(const char* architecture);
	FileInfo					findLibrary(const char* rootName, bool dylibsOnly=false);
	FileInfo					findFramework(const char* frameworkName);
	FileInfo					findFramework(const char* rootName, const char* suffix);
	bool						checkForFile(const char* format, const char* dir, const char* rootName,
											 FileInfo& result);
	uint32_t					parseVersionNumber(const char*);
	void						parseSectionOrderFile(const char* segment, const char* section, const char* path);
	void						parseOrderFile(const char* path, bool cstring);
	void						addSection(const char* segment, const char* section, const char* path);
	void						addSubLibrary(const char* name);
	void						loadFileList(const char* fileOfPaths);
	uint64_t					parseAddress(const char* addr);
	void						loadExportFile(const char* fileOfExports, const char* option, SetWithWildcards& set);
	void						parseAliasFile(const char* fileOfAliases);
	void						parsePreCommandLineEnvironmentSettings();
	void						parsePostCommandLineEnvironmentSettings();
	void						setUndefinedTreatment(const char* treatment);
	void						setMacOSXVersionMin(const char* version);
	void						setIPhoneVersionMin(const char* version);
	void						setWeakReferenceMismatchTreatment(const char* treatment);
	void						addDylibOverride(const char* paths);
	void						addSectionAlignment(const char* segment, const char* section, const char* alignment);
	CommonsMode					parseCommonsTreatment(const char* mode);
	Treatment					parseTreatment(const char* treatment);
	void						reconfigureDefaults();
	void						checkForClassic(int argc, const char* argv[]);
	void						parseSegAddrTable(const char* segAddrPath, const char* installPath);
	void						addLibrary(const FileInfo& info);
	void						warnObsolete(const char* arg);
	uint32_t					parseProtection(const char* prot);
	void						loadSymbolOrderFile(const char* fileOfExports, NameToOrder& orderMapping);


	ObjectFile::ReaderOptions			fReaderOptions;
	const char*							fOutputFile;
	std::vector<Options::FileInfo>		fInputFiles;
	cpu_type_t							fArchitecture;
	cpu_subtype_t						fSubArchitecture;
	OutputKind							fOutputKind;
	bool								fHasPreferredSubType;
	bool								fPrebind;
	bool								fBindAtLoad;
	bool								fKeepPrivateExterns;
	bool								fNeedsModuleTable;
	bool								fIgnoreOtherArchFiles;
	bool								fErrorOnOtherArchFiles;
	bool								fForceSubtypeAll;
	InterposeMode						fInterposeMode;
	DeadStripMode						fDeadStrip;
	NameSpace							fNameSpace;
	uint32_t							fDylibCompatVersion;
	uint32_t							fDylibCurrentVersion;
	const char*							fDylibInstallName;
	const char*							fFinalName;
	const char*							fEntryName;
	uint64_t							fBaseAddress;
	uint64_t							fBaseWritableAddress;
	bool								fSplitSegs;
	SetWithWildcards					fExportSymbols;
	SetWithWildcards					fDontExportSymbols;
	SetWithWildcards					fInterposeList;
	NameToOrder							fExportSymbolsOrder;
	ExportMode							fExportMode;
	LibrarySearchMode					fLibrarySearchMode;
	UndefinedTreatment					fUndefinedTreatment;
	bool								fMessagesPrefixedWithArchitecture;
	WeakReferenceMismatchTreatment		fWeakReferenceMismatchTreatment;
	std::vector<const char*>			fSubUmbellas;
	std::vector<const char*>			fSubLibraries;
	std::vector<const char*>			fAllowableClients;
	std::vector<const char*>			fRPaths;
	const char*							fClientName;
	const char*							fUmbrellaName;
	const char*							fInitFunctionName;
	const char*							fDotOutputFile;
	const char*							fExecutablePath;
	const char*							fBundleLoader;
	const char*							fDtraceScriptName;
	const char*							fSegAddrTablePath;
	const char*							fMapPath;
	uint64_t							fZeroPageSize;
	uint64_t							fStackSize;
	uint64_t							fStackAddr;
	bool								fExecutableStack;
	uint32_t							fMinimumHeaderPad;
	uint64_t							fSegmentAlignment;
	CommonsMode							fCommonsMode;
	UUIDMode							fUUIDMode;
	SetWithWildcards					fLocalSymbolsIncluded;
	SetWithWildcards					fLocalSymbolsExcluded;
	LocalSymbolHandling					fLocalSymbolHandling;
	bool								fWarnCommons;
	bool								fVerbose;
	bool								fKeepRelocations;
	bool								fWarnStabs;
	bool								fTraceDylibSearching;
	bool								fPause;
	bool								fStatistics;
	bool								fPrintOptions;
	bool								fSharedRegionEligible;
	bool								fPrintOrderFileStatistics;
	bool								fReadOnlyx86Stubs;
	bool								fPositionIndependentExecutable;
	bool								fMaxMinimumHeaderPad;
	bool								fDeadStripDylibs;
	bool								fAllowTextRelocs;
	bool								fWarnTextRelocs;
	bool								fUsingLazyDylibLinking;
	bool								fEncryptable;
	bool								fOrderData;
	bool								fMarkDeadStrippableDylib;
	bool								fMakeClassicDyldInfo;
	bool								fMakeCompressedDyldInfo;
	bool								fNoEHLabels;
	bool								fAllowCpuSubtypeMismatches;
	bool								fUseSimplifiedDylibReExports;
	std::vector<const char*>			fInitialUndefines;
	NameSet								fAllowedUndefined;
	NameSet								fWhyLive;
	std::vector<ExtraSection>			fExtraSections;
	std::vector<SectionAlignment>		fSectionAlignments;
	std::vector<OrderedSymbol>			fOrderedSymbols;
	std::vector<SegmentStart>			fCustomSegmentAddresses;
	std::vector<SegmentSize>			fCustomSegmentSizes;
	std::vector<SegmentProtect>			fCustomSegmentProtections;
	std::vector<DylibOverride>			fDylibOverrides;
	std::vector<const char*>			fLLVMOptions;
	std::vector<const char*>			fLibrarySearchPaths;
	std::vector<const char*>			fFrameworkSearchPaths;
	std::vector<const char*>			fSDKPaths;
	bool								fSaveTempFiles;
};


#endif // __OPTIONS__
Commit	Line	Data
	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__