[apple/ld64.git] / src / MachOReaderDylib.hpp

/* -*- mode: C++; c-basic-offset: 4; tab-width: 4 -*-
 *
 * Copyright (c) 2005-2006 Apple Computer, 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 __OBJECT_FILE_DYLIB_MACH_O__
#define __OBJECT_FILE_DYLIB_MACH_O__

#include <stdint.h>
#include <math.h>
#include <unistd.h>
#include <sys/param.h>


#include <vector>
#include <set>
#include <algorithm>
#include <ext/hash_map>

#include "MachOFileAbstraction.hpp"
#include "ObjectFile.h"

//
//
//	To implement architecture xxx, you must write template specializations for the following method:
//			Reader<xxx>::validFile()
//
//


namespace mach_o {
namespace dylib {


// forward reference
template <typename A> class Reader;


class Segment : public ObjectFile::Segment
{
public:
								Segment(const char* name)		{ fName = name; }
	virtual const char*			getName() const					{ return fName; }
	virtual bool				isContentReadable() const		{ return true; }
	virtual bool				isContentWritable() const		{ return false; }
	virtual bool				isContentExecutable() const		{ return false; }
private:
	const char*					fName;
};


//
// An ExportAtom has no content.  It exists so that the linker can track which imported
// symbols can from which dynamic libraries.
//
template <typename A>
class ExportAtom : public ObjectFile::Atom
{
public:
	virtual ObjectFile::Reader*					getFile() const				{ return &fOwner; }
	virtual bool								getTranslationUnitSource(const char** dir, const char** name) const { return false; }
	virtual const char*							getName() const				{ return fName; }
	virtual const char*							getDisplayName() const		{ return fName; }
	virtual Scope								getScope() const			{ return ObjectFile::Atom::scopeGlobal; }
	virtual DefinitionKind						getDefinitionKind() const	{ return fWeakDefinition ? kExternalWeakDefinition : kExternalDefinition; }
	virtual SymbolTableInclusion				getSymbolTableInclusion() const	{ return ObjectFile::Atom::kSymbolTableIn; }
	virtual	bool								dontDeadStrip() const		{ return false; }
	virtual bool								isZeroFill() const			{ return false; }
	virtual uint64_t							getSize() const				{ return 0; }
	virtual std::vector<ObjectFile::Reference*>&  getReferences() const		{ return fgEmptyReferenceList; }
	virtual bool								mustRemainInSection() const { return false; }
	virtual const char*							getSectionName() const		{ return "._imports"; }
	virtual Segment&							getSegment() const			{ return fgImportSegment; }
	virtual bool								requiresFollowOnAtom() const{ return false; }
	virtual ObjectFile::Atom&					getFollowOnAtom() const		{ return *((ObjectFile::Atom*)NULL); }
	virtual std::vector<ObjectFile::LineInfo>*	getLineInfo() const			{ return NULL; }
	virtual ObjectFile::Alignment				getAlignment() const		{ return ObjectFile::Alignment(0); }
	virtual void								copyRawContent(uint8_t buffer[]) const  {}

	virtual void								setScope(Scope)				{ }

protected:
	friend class Reader<A>;
	typedef typename A::P					P;

											ExportAtom(ObjectFile::Reader& owner, const char* name, bool weak)
												: fOwner(owner), fName(name), fWeakDefinition(weak) {}
	virtual									~ExportAtom() {}

	ObjectFile::Reader&						fOwner;
	const char*								fName;
	bool									fWeakDefinition;

	static std::vector<ObjectFile::Reference*>	fgEmptyReferenceList;
	static Segment								fgImportSegment;
};

template <typename A>
Segment								ExportAtom<A>::fgImportSegment("__LINKEDIT");

template <typename A>
std::vector<ObjectFile::Reference*>	ExportAtom<A>::fgEmptyReferenceList;


//
// The reader for a dylib extracts all exported symbols names from the memory-mapped
// dylib, builds a hash table, then unmaps the file.  This is an important memory
// savings for large dylibs.
//
template <typename A>
class Reader : public ObjectFile::Reader
{
public:
	static bool										validFile(const uint8_t* fileContent, bool executableOrDylib);
	static Reader<A>*								make(const uint8_t* fileContent, uint64_t fileLength, const char* path, 
														bool executableOrDylib, const ObjectFile::ReaderOptions& options)
														{ return new Reader<A>(fileContent, fileLength, path, executableOrDylib, options); }
	virtual											~Reader() {}

	virtual const char*								getPath()					{ return fPath; }
	virtual time_t									getModificationTime()		{ return 0; }
	virtual DebugInfoKind							getDebugInfoKind()			{ return ObjectFile::Reader::kDebugInfoNone; }
	virtual std::vector<class ObjectFile::Atom*>&	getAtoms();
	virtual std::vector<class ObjectFile::Atom*>*	getJustInTimeAtomsFor(const char* name);
	virtual std::vector<Stab>*						getStabs()					{ return NULL; }
	virtual const char*								getInstallPath()			{ return fDylibInstallPath; }
	virtual uint32_t								getTimestamp()				{ return fDylibTimeStamp; }
	virtual uint32_t								getCurrentVersion()			{ return fDylibtCurrentVersion; }
	virtual uint32_t								getCompatibilityVersion()	{ return fDylibCompatibilityVersion; }
	virtual std::vector<const char*>*				getDependentLibraryPaths();
	virtual bool									reExports(ObjectFile::Reader*);
	virtual std::vector<const char*>*				getAllowableClients();

protected:
		const char*									parentUmbrella()			{ return fParentUmbrella; }

private:
	typedef typename A::P						P;
	typedef typename A::P::E					E;

	class CStringEquals
	{
	public:
		bool operator()(const char* left, const char* right) const { return (strcmp(left, right) == 0); }
	};
	struct AtomAndWeak { ObjectFile::Atom* atom; bool weak; };
	typedef __gnu_cxx::hash_map<const char*, AtomAndWeak, __gnu_cxx::hash<const char*>, CStringEquals> NameToAtomMap;
	typedef typename NameToAtomMap::iterator		NameToAtomMapIterator;

	struct PathAndFlag { const char* path; bool reExport; };

												Reader(const uint8_t* fileContent, uint64_t fileLength, const char* path,
														bool executableOrDylib, const ObjectFile::ReaderOptions& options);

	const char*									fPath;
	const char*									fParentUmbrella;
	std::vector<const char*>   					fAllowableClients;
	const char*									fDylibInstallPath;
	uint32_t									fDylibTimeStamp;
	uint32_t									fDylibtCurrentVersion;
	uint32_t									fDylibCompatibilityVersion;
	std::vector<PathAndFlag>					fDependentLibraryPaths;
	NameToAtomMap								fAtoms;

	static bool									fgLogHashtable;
	static std::vector<class ObjectFile::Atom*>	fgEmptyAtomList;
};

template <typename A>
std::vector<class ObjectFile::Atom*>	Reader<A>::fgEmptyAtomList;
template <typename A>
bool									Reader<A>::fgLogHashtable = false;


template <typename A>
Reader<A>::Reader(const uint8_t* fileContent, uint64_t fileLength, const char* path, bool executableOrDylib, const ObjectFile::ReaderOptions& options)
	: fParentUmbrella(NULL), fDylibInstallPath(NULL), fDylibTimeStamp(0), fDylibtCurrentVersion(0), fDylibCompatibilityVersion(0)
{
	// sanity check
	if ( ! validFile(fileContent, executableOrDylib) )
		throw "not a valid mach-o object file";

	fPath = strdup(path);
	
	const macho_header<P>* header = (const macho_header<P>*)fileContent;
	const uint32_t cmd_count = header->ncmds();
	const macho_load_command<P>* const cmds = (macho_load_command<P>*)((char*)header + sizeof(macho_header<P>));

	// a "blank" stub has zero load commands
	if ( (header->filetype() == MH_DYLIB_STUB) && (cmd_count == 0) ) {	
		// no further processing needed
		munmap((caddr_t)fileContent, fileLength);
		return;
	}

	// pass 1 builds list of all dependent libraries
	const macho_load_command<P>* cmd = cmds;
	for (uint32_t i = 0; i < cmd_count; ++i) {
		switch (cmd->cmd()) {
			case LC_LOAD_DYLIB:
			case LC_LOAD_WEAK_DYLIB:
				PathAndFlag entry;
				entry.path = strdup(((struct macho_dylib_command<P>*)cmd)->name());
				entry.reExport = false;
				fDependentLibraryPaths.push_back(entry);
				break;
		}
		cmd = (const macho_load_command<P>*)(((char*)cmd)+cmd->cmdsize());
	}

	// pass 2 determines re-export info
	const macho_dysymtab_command<P>* dynamicInfo = NULL;
	const macho_nlist<P>* symbolTable = NULL;
	const char*	strings = NULL;
	cmd = cmds;
	for (uint32_t i = 0; i < cmd_count; ++i) {
		switch (cmd->cmd()) {
			case LC_SYMTAB:
				{
					const macho_symtab_command<P>* symtab = (macho_symtab_command<P>*)cmd;
					symbolTable = (const macho_nlist<P>*)((char*)header + symtab->symoff());
					strings = (char*)header + symtab->stroff();
				}
				break;
			case LC_DYSYMTAB:
				dynamicInfo = (macho_dysymtab_command<P>*)cmd;
				break;
			case LC_ID_DYLIB:
				macho_dylib_command<P>* dylibID = (macho_dylib_command<P>*)cmd;
				fDylibInstallPath			= strdup(dylibID->name());
				fDylibTimeStamp				= dylibID->timestamp();
				fDylibtCurrentVersion		= dylibID->current_version();
				fDylibCompatibilityVersion	= dylibID->compatibility_version();
				break;
			case LC_SUB_UMBRELLA:
				if ( !options.fFlatNamespace ) {
					const char* frameworkLeafName = ((macho_sub_umbrella_command<P>*)cmd)->sub_umbrella();
					for (typename std::vector<PathAndFlag>::iterator it = fDependentLibraryPaths.begin(); it != fDependentLibraryPaths.end(); it++) {
						const char* dylibName = it->path;
						const char* lastSlash = strrchr(dylibName, '/');
						if ( (lastSlash != NULL) && (strcmp(&lastSlash[1], frameworkLeafName) == 0) )
							it->reExport = true;
					}
				}
				break;
			case LC_SUB_LIBRARY:
				if ( !options.fFlatNamespace ) {
					const char* dylibBaseName = ((macho_sub_library_command<P>*)cmd)->sub_library();
					for (typename std::vector<PathAndFlag>::iterator it = fDependentLibraryPaths.begin(); it != fDependentLibraryPaths.end(); it++) {
						const char* dylibName = it->path;
						const char* lastSlash = strrchr(dylibName, '/');
						const char* leafStart = &lastSlash[1];
						if ( lastSlash == NULL )
							leafStart = dylibName;
						const char* firstDot = strchr(leafStart, '.');
						int len = strlen(leafStart);
						if ( firstDot != NULL )
							len = firstDot - leafStart;
						if ( strncmp(leafStart, dylibBaseName, len) == 0 )
							it->reExport = true;
					}
				}
				break;
			case LC_SUB_FRAMEWORK:
				fParentUmbrella = strdup(((macho_sub_framework_command<P>*)cmd)->umbrella());
				break;
		}

		cmd = (const macho_load_command<P>*)(((char*)cmd)+cmd->cmdsize());
	}
	// Process the rest of the commands here.
	cmd = cmds;
	for (uint32_t i = 0; i < cmd_count; ++i) {
		switch (cmd->cmd()) {
		case LC_SUB_CLIENT:
			const char *temp = strdup(((macho_sub_client_command<P>*)cmd)->client());

			fAllowableClients.push_back(temp);
			break;
		}

		cmd = (const macho_load_command<P>*)(((char*)cmd)+cmd->cmdsize());
	}

	// validate minimal load commands
	if ( (fDylibInstallPath == NULL) && (header->filetype() != MH_EXECUTE) ) 
		throw "dylib missing LC_ID_DYLIB load command";
	if ( symbolTable == NULL )
		throw "dylib missing LC_SYMTAB load command";
	if ( dynamicInfo == NULL )
		throw "dylib missing LC_DYSYMTAB load command";
	
	// build hash table
	if ( dynamicInfo->tocoff() == 0 ) {
		if ( fgLogHashtable ) fprintf(stderr, "ld64: building hashtable of %u toc entries for %s\n", dynamicInfo->nextdefsym(), path);
		const macho_nlist<P>* start = &symbolTable[dynamicInfo->iextdefsym()];
		const macho_nlist<P>* end = &start[dynamicInfo->nextdefsym()];
		fAtoms.resize(dynamicInfo->nextdefsym()); // set initial bucket count
		for (const macho_nlist<P>* sym=start; sym < end; ++sym) {
			AtomAndWeak bucket;
			bucket.atom = NULL;
			bucket.weak = ((sym->n_desc() & N_WEAK_DEF) != 0);
			const char* name = strdup(&strings[sym->n_strx()]);
			if ( fgLogHashtable ) fprintf(stderr, "  adding %s to hash table for %s\n", name, this->getPath());
			fAtoms[name] = bucket;
		}
	}
	else {
		int32_t count = dynamicInfo->ntoc();
		fAtoms.resize(count); // set initial bucket count
		if ( fgLogHashtable ) fprintf(stderr, "ld64: building hashtable of %u entries for %s\n", count, path);
		const struct dylib_table_of_contents* toc = (dylib_table_of_contents*)((char*)header + dynamicInfo->tocoff());
		for (int32_t i = 0; i < count; ++i) {
			const uint32_t index = E::get32(toc[i].symbol_index);
			const macho_nlist<P>* sym = &symbolTable[index];
			AtomAndWeak bucket;
			bucket.atom = NULL;
			bucket.weak = ((sym->n_desc() & N_WEAK_DEF) != 0);
			const char* name = strdup(&strings[sym->n_strx()]);
			if ( fgLogHashtable ) fprintf(stderr, "  adding %s to hash table for %s\n", name, this->getPath());
			fAtoms[name] = bucket;
		}
	}

	// unmap file
	munmap((caddr_t)fileContent, fileLength);
}

template <typename A>
std::vector<class ObjectFile::Atom*>& Reader<A>::getAtoms()
{
	// TO DO:	for flat-namespace libraries, when linking flat_namespace
	//			we need to create an atom which references all undefines
	return fgEmptyAtomList;
}


template <typename A>
std::vector<class ObjectFile::Atom*>* Reader<A>::getJustInTimeAtomsFor(const char* name)
{
	std::vector<class ObjectFile::Atom*>* atoms = NULL;

	NameToAtomMapIterator pos = fAtoms.find(name);
	if ( pos != fAtoms.end() ) {
		if ( pos->second.atom == NULL ) {
			// instantiate atom and update hash table
			pos->second.atom = new ExportAtom<A>(*this, name, pos->second.weak);
			if ( fgLogHashtable ) fprintf(stderr, "getJustInTimeAtomsFor: %s found in %s\n", name, this->getPath());
		}
		// return a vector of one atom
		atoms = new std::vector<class ObjectFile::Atom*>;
		atoms->push_back(pos->second.atom);
	}
	else {
		if ( fgLogHashtable ) fprintf(stderr, "getJustInTimeAtomsFor: %s NOT found in %s\n", name, this->getPath());
	}
	return atoms;
}


template <typename A>
std::vector<const char*>* Reader<A>::getDependentLibraryPaths()
{
	std::vector<const char*>* result = new std::vector<const char*>;
	for (typename std::vector<PathAndFlag>::iterator it = fDependentLibraryPaths.begin(); it != fDependentLibraryPaths.end(); it++) {
		result->push_back(it->path);
	}
	return result;
}

template <typename A>
std::vector<const char*>* Reader<A>::getAllowableClients()
{
	std::vector<const char*>* result = new std::vector<const char*>;
	for (typename std::vector<const char*>::iterator it = fAllowableClients.begin();
		 it != fAllowableClients.end();
		 it++) {
		result->push_back(*it);
	}
	return (fAllowableClients.size() != 0 ? result : NULL);
}

template <typename A>
bool Reader<A>::reExports(ObjectFile::Reader* child)
{
	// A dependent dylib is re-exported under two conditions:
	//  1) parent contains LC_SUB_UMBRELLA or LC_SUB_LIBRARY with child name
	const char* childInstallPath = child->getInstallPath();
	for (typename std::vector<PathAndFlag>::iterator it = fDependentLibraryPaths.begin(); it != fDependentLibraryPaths.end(); it++) {
		if ( it->reExport && ((strcmp(it->path, child->getPath()) == 0) || ((childInstallPath!=NULL) && (strcmp(it->path, childInstallPath)==0))) )
			return true;
	}

	//  2) child contains LC_SUB_FRAMEWORK with parent name
	const char* parentUmbrellaName = ((Reader<A>*)child)->parentUmbrella();
	if ( parentUmbrellaName != NULL ) {
		const char* parentName = this->getPath();
		const char* lastSlash = strrchr(parentName, '/');
		if ( (lastSlash != NULL) && (strcmp(&lastSlash[1], parentUmbrellaName) == 0) )
			return true;
	}

	return false;
}

template <>
bool Reader<ppc>::validFile(const uint8_t* fileContent, bool executableOrDylib)
{
	const macho_header<P>* header = (const macho_header<P>*)fileContent;
	if ( header->magic() != MH_MAGIC )
		return false;
	if ( header->cputype() != CPU_TYPE_POWERPC )
		return false;
	switch ( header->filetype() ) {
		case MH_DYLIB:
		case MH_DYLIB_STUB:
			return true;
		case MH_EXECUTE:
			return executableOrDylib;
		default:
			return false;
	}
}

template <>
bool Reader<ppc64>::validFile(const uint8_t* fileContent, bool executableOrDylib)
{
	const macho_header<P>* header = (const macho_header<P>*)fileContent;
	if ( header->magic() != MH_MAGIC_64 )
		return false;
	if ( header->cputype() != CPU_TYPE_POWERPC64 )
		return false;
	switch ( header->filetype() ) {
		case MH_DYLIB:
		case MH_DYLIB_STUB:
			return true;
		case MH_EXECUTE:
			return executableOrDylib;
		default:
			return false;
	}
}

template <>
bool Reader<x86>::validFile(const uint8_t* fileContent, bool executableOrDylib)
{
	const macho_header<P>* header = (const macho_header<P>*)fileContent;
	if ( header->magic() != MH_MAGIC )
		return false;
	if ( header->cputype() != CPU_TYPE_I386 )
		return false;
	switch ( header->filetype() ) {
		case MH_DYLIB:
		case MH_DYLIB_STUB:
			return true;
		case MH_EXECUTE:
			return executableOrDylib;
		default:
			return false;
	}
}

template <>
bool Reader<x86_64>::validFile(const uint8_t* fileContent, bool executableOrDylib)
{
	const macho_header<P>* header = (const macho_header<P>*)fileContent;
	if ( header->magic() != MH_MAGIC_64 )
		return false;
	if ( header->cputype() != CPU_TYPE_X86_64 )
		return false;
	switch ( header->filetype() ) {
		case MH_DYLIB:
		case MH_DYLIB_STUB:
			return true;
		case MH_EXECUTE:
			return executableOrDylib;
		default:
			return false;
	}
}


}; // namespace dylib
}; // namespace mach_o


#endif // __OBJECT_FILE_DYLIB_MACH_O__
Commit	Line	Data
d696c285 A	1	/* -- mode: C++; c-basic-offset: 4; tab-width: 4 --
	2	*
	3	* Copyright (c) 2005-2006 Apple Computer, 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 __OBJECT_FILE_DYLIB_MACH_O__
	26	#define __OBJECT_FILE_DYLIB_MACH_O__
	27
	28	#include <stdint.h>
	29	#include <math.h>
	30	#include <unistd.h>
	31	#include <sys/param.h>
	32
	33
	34	#include <vector>
	35	#include <set>
	36	#include <algorithm>
	37	#include <ext/hash_map>
	38
	39	#include "MachOFileAbstraction.hpp"
	40	#include "ObjectFile.h"
	41
	42	//
	43	//
	44	// To implement architecture xxx, you must write template specializations for the following method:
	45	// Reader<xxx>::validFile()
	46	//
	47	//
	48
	49
	50
	51
	52	namespace mach_o {
	53	namespace dylib {
	54
	55
	56	// forward reference
	57	template <typename A> class Reader;
	58
	59
	60	class Segment : public ObjectFile::Segment
	61	{
	62	public:
	63	Segment(const char* name) { fName = name; }
	64	virtual const char* getName() const { return fName; }
65	virtual bool isContentReadable() const { return true; }
66	virtual bool isContentWritable() const { return false; }
67	virtual bool isContentExecutable() const { return false; }
68	private:
69	const char* fName;
70	};
71
72
73	//
74	// An ExportAtom has no content. It exists so that the linker can track which imported
75	// symbols can from which dynamic libraries.
76	//
77	template <typename A>
78	class ExportAtom : public ObjectFile::Atom
79	{
80	public:
81	virtual ObjectFile::Reader* getFile() const { return &fOwner; }
82	virtual bool getTranslationUnitSource(const char dir, const char name) const { return false; }
83	virtual const char* getName() const { return fName; }
84	virtual const char* getDisplayName() const { return fName; }
85	virtual Scope getScope() const { return ObjectFile::Atom::scopeGlobal; }
86	virtual DefinitionKind getDefinitionKind() const { return fWeakDefinition ? kExternalWeakDefinition : kExternalDefinition; }
87	virtual SymbolTableInclusion getSymbolTableInclusion() const { return ObjectFile::Atom::kSymbolTableIn; }
69a49097	88	virtual bool dontDeadStrip() const { return false; }
d696c285 A	89	virtual bool isZeroFill() const { return false; }
	90	virtual uint64_t getSize() const { return 0; }
	91	virtual std::vector<ObjectFile::Reference*>& getReferences() const { return fgEmptyReferenceList; }
	92	virtual bool mustRemainInSection() const { return false; }
	93	virtual const char* getSectionName() const { return "._imports"; }
	94	virtual Segment& getSegment() const { return fgImportSegment; }
	95	virtual bool requiresFollowOnAtom() const{ return false; }
	96	virtual ObjectFile::Atom& getFollowOnAtom() const { return ((ObjectFile::Atom)NULL); }
	97	virtual std::vector<ObjectFile::LineInfo>* getLineInfo() const { return NULL; }
74cfe461	98	virtual ObjectFile::Alignment getAlignment() const { return ObjectFile::Alignment(0); }
d696c285 A	99	virtual void copyRawContent(uint8_t buffer[]) const {}
	100
	101	virtual void setScope(Scope) { }
	102
	103	protected:
	104	friend class Reader<A>;
	105	typedef typename A::P P;
	106
	107	ExportAtom(ObjectFile::Reader& owner, const char* name, bool weak)
	108	: fOwner(owner), fName(name), fWeakDefinition(weak) {}
	109	virtual ~ExportAtom() {}
	110
	111	ObjectFile::Reader& fOwner;
	112	const char* fName;
	113	bool fWeakDefinition;
	114
	115	static std::vector<ObjectFile::Reference*> fgEmptyReferenceList;
	116	static Segment fgImportSegment;
	117	};
	118
	119	template <typename A>
	120	Segment ExportAtom<A>::fgImportSegment("__LINKEDIT");
	121
	122	template <typename A>
	123	std::vector<ObjectFile::Reference*> ExportAtom<A>::fgEmptyReferenceList;
	124
	125
	126	//
	127	// The reader for a dylib extracts all exported symbols names from the memory-mapped
	128	// dylib, builds a hash table, then unmaps the file. This is an important memory
	129	// savings for large dylibs.
	130	//
	131	template <typename A>
	132	class Reader : public ObjectFile::Reader
	133	{
	134	public:
69a49097 A	135	static bool validFile(const uint8_t* fileContent, bool executableOrDylib);
	136	static Reader<A>* make(const uint8_t* fileContent, uint64_t fileLength, const char* path,
	137	bool executableOrDylib, const ObjectFile::ReaderOptions& options)
	138	{ return new Reader<A>(fileContent, fileLength, path, executableOrDylib, options); }
	139	virtual ~Reader() {}
d696c285 A	140
	141	virtual const char* getPath() { return fPath; }
	142	virtual time_t getModificationTime() { return 0; }
	143	virtual DebugInfoKind getDebugInfoKind() { return ObjectFile::Reader::kDebugInfoNone; }
	144	virtual std::vector<class ObjectFile::Atom*>& getAtoms();
	145	virtual std::vector<class ObjectFile::Atom> getJustInTimeAtomsFor(const char* name);
	146	virtual std::vector<Stab>* getStabs() { return NULL; }
	147	virtual const char* getInstallPath() { return fDylibInstallPath; }
	148	virtual uint32_t getTimestamp() { return fDylibTimeStamp; }
	149	virtual uint32_t getCurrentVersion() { return fDylibtCurrentVersion; }
	150	virtual uint32_t getCompatibilityVersion() { return fDylibCompatibilityVersion; }
	151	virtual std::vector<const char> getDependentLibraryPaths();
	152	virtual bool reExports(ObjectFile::Reader*);
	153	virtual std::vector<const char> getAllowableClients();
	154
	155	protected:
	156	const char* parentUmbrella() { return fParentUmbrella; }
	157
	158	private:
	159	typedef typename A::P P;
	160	typedef typename A::P::E E;
	161
	162	class CStringEquals
	163	{
	164	public:
	165	bool operator()(const char* left, const char* right) const { return (strcmp(left, right) == 0); }
	166	};
	167	struct AtomAndWeak { ObjectFile::Atom* atom; bool weak; };
	168	typedef __gnu_cxx::hash_map<const char, AtomAndWeak, __gnu_cxx::hash<const char>, CStringEquals> NameToAtomMap;
	169	typedef typename NameToAtomMap::iterator NameToAtomMapIterator;
	170
	171	struct PathAndFlag { const char* path; bool reExport; };
	172
69a49097 A	173	Reader(const uint8_t* fileContent, uint64_t fileLength, const char* path,
69a49097 A	174	bool executableOrDylib, const ObjectFile::ReaderOptions& options);
d696c285 A	175
	176	const char* fPath;
	177	const char* fParentUmbrella;
	178	std::vector<const char*> fAllowableClients;
	179	const char* fDylibInstallPath;
	180	uint32_t fDylibTimeStamp;
	181	uint32_t fDylibtCurrentVersion;
	182	uint32_t fDylibCompatibilityVersion;
	183	std::vector<PathAndFlag> fDependentLibraryPaths;
	184	NameToAtomMap fAtoms;
	185
	186	static bool fgLogHashtable;
	187	static std::vector<class ObjectFile::Atom*> fgEmptyAtomList;
	188	};
	189
	190	template <typename A>
	191	std::vector<class ObjectFile::Atom*> Reader<A>::fgEmptyAtomList;
	192	template <typename A>
	193	bool Reader<A>::fgLogHashtable = false;
	194
	195
	196	template <typename A>
69a49097	197	Reader<A>::Reader(const uint8_t* fileContent, uint64_t fileLength, const char* path, bool executableOrDylib, const ObjectFile::ReaderOptions& options)
d696c285 A	198	: fParentUmbrella(NULL), fDylibInstallPath(NULL), fDylibTimeStamp(0), fDylibtCurrentVersion(0), fDylibCompatibilityVersion(0)
	199	{
	200	// sanity check
69a49097	201	if ( ! validFile(fileContent, executableOrDylib) )
d696c285 A	202	throw "not a valid mach-o object file";
	203
	204	fPath = strdup(path);
	205
	206	const macho_header<P>* header = (const macho_header<P>*)fileContent;
	207	const uint32_t cmd_count = header->ncmds();
	208	const macho_load_command<P>* const cmds = (macho_load_command<P>)((char)header + sizeof(macho_header<P>));
	209
	210	// a "blank" stub has zero load commands
	211	if ( (header->filetype() == MH_DYLIB_STUB) && (cmd_count == 0) ) {
	212	// no further processing needed
	213	munmap((caddr_t)fileContent, fileLength);
	214	return;
	215	}
	216
	217	// pass 1 builds list of all dependent libraries
	218	const macho_load_command<P>* cmd = cmds;
	219	for (uint32_t i = 0; i < cmd_count; ++i) {
	220	switch (cmd->cmd()) {
	221	case LC_LOAD_DYLIB:
	222	case LC_LOAD_WEAK_DYLIB:
	223	PathAndFlag entry;
	224	entry.path = strdup(((struct macho_dylib_command<P>*)cmd)->name());
	225	entry.reExport = false;
	226	fDependentLibraryPaths.push_back(entry);
	227	break;
	228	}
	229	cmd = (const macho_load_command<P>)(((char)cmd)+cmd->cmdsize());
	230	}
	231
	232	// pass 2 determines re-export info
	233	const macho_dysymtab_command<P>* dynamicInfo = NULL;
	234	const macho_nlist<P>* symbolTable = NULL;
	235	const char* strings = NULL;
	236	cmd = cmds;
	237	for (uint32_t i = 0; i < cmd_count; ++i) {
	238	switch (cmd->cmd()) {
	239	case LC_SYMTAB:
	240	{
	241	const macho_symtab_command<P>* symtab = (macho_symtab_command<P>*)cmd;
	242	symbolTable = (const macho_nlist<P>)((char)header + symtab->symoff());
	243	strings = (char*)header + symtab->stroff();
	244	}
	245	break;
	246	case LC_DYSYMTAB:
	247	dynamicInfo = (macho_dysymtab_command<P>*)cmd;
	248	break;
	249	case LC_ID_DYLIB:
	250	macho_dylib_command<P>* dylibID = (macho_dylib_command<P>*)cmd;
	251	fDylibInstallPath = strdup(dylibID->name());
	252	fDylibTimeStamp = dylibID->timestamp();
	253	fDylibtCurrentVersion = dylibID->current_version();
	254	fDylibCompatibilityVersion = dylibID->compatibility_version();
	255	break;
	256	case LC_SUB_UMBRELLA:
	257	if ( !options.fFlatNamespace ) {
	258	const char* frameworkLeafName = ((macho_sub_umbrella_command<P>*)cmd)->sub_umbrella();
	259	for (typename std::vector<PathAndFlag>::iterator it = fDependentLibraryPaths.begin(); it != fDependentLibraryPaths.end(); it++) {
	260	const char* dylibName = it->path;
	261	const char* lastSlash = strrchr(dylibName, '/');
	262	if ( (lastSlash != NULL) && (strcmp(&lastSlash[1], frameworkLeafName) == 0) )
	263	it->reExport = true;
	264	}
	265	}
266	break;
267	case LC_SUB_LIBRARY:
268	if ( !options.fFlatNamespace ) {
269	const char* dylibBaseName = ((macho_sub_library_command<P>*)cmd)->sub_library();
270	for (typename std::vector<PathAndFlag>::iterator it = fDependentLibraryPaths.begin(); it != fDependentLibraryPaths.end(); it++) {
271	const char* dylibName = it->path;
272	const char* lastSlash = strrchr(dylibName, '/');
273	const char* leafStart = &lastSlash[1];
274	if ( lastSlash == NULL )
275	leafStart = dylibName;
276	const char* firstDot = strchr(leafStart, '.');
277	int len = strlen(leafStart);
278	if ( firstDot != NULL )
279	len = firstDot - leafStart;
280	if ( strncmp(leafStart, dylibBaseName, len) == 0 )
281	it->reExport = true;
282	}
283	}
284	break;
285	case LC_SUB_FRAMEWORK:
286	fParentUmbrella = strdup(((macho_sub_framework_command<P>*)cmd)->umbrella());
287	break;
288	}
289
290	cmd = (const macho_load_command<P>)(((char)cmd)+cmd->cmdsize());
291	}
292	// Process the rest of the commands here.
293	cmd = cmds;
294	for (uint32_t i = 0; i < cmd_count; ++i) {
295	switch (cmd->cmd()) {
296	case LC_SUB_CLIENT:
297	const char temp = strdup(((macho_sub_client_command<P>)cmd)->client());
298
299	fAllowableClients.push_back(temp);
300	break;
301	}
302
303	cmd = (const macho_load_command<P>)(((char)cmd)+cmd->cmdsize());
304	}
305
306	// validate minimal load commands
69a49097	307	if ( (fDylibInstallPath == NULL) && (header->filetype() != MH_EXECUTE) )
d696c285 A	308	throw "dylib missing LC_ID_DYLIB load command";
	309	if ( symbolTable == NULL )
	310	throw "dylib missing LC_SYMTAB load command";
	311	if ( dynamicInfo == NULL )
	312	throw "dylib missing LC_DYSYMTAB load command";
	313
	314	// build hash table
	315	if ( dynamicInfo->tocoff() == 0 ) {
	316	if ( fgLogHashtable ) fprintf(stderr, "ld64: building hashtable of %u toc entries for %s\n", dynamicInfo->nextdefsym(), path);
	317	const macho_nlist<P>* start = &symbolTable[dynamicInfo->iextdefsym()];
	318	const macho_nlist<P>* end = &start[dynamicInfo->nextdefsym()];
	319	fAtoms.resize(dynamicInfo->nextdefsym()); // set initial bucket count
	320	for (const macho_nlist<P>* sym=start; sym < end; ++sym) {
	321	AtomAndWeak bucket;
	322	bucket.atom = NULL;
	323	bucket.weak = ((sym->n_desc() & N_WEAK_DEF) != 0);
	324	const char* name = strdup(&strings[sym->n_strx()]);
	325	if ( fgLogHashtable ) fprintf(stderr, " adding %s to hash table for %s\n", name, this->getPath());
	326	fAtoms[name] = bucket;
	327	}
	328	}
	329	else {
	330	int32_t count = dynamicInfo->ntoc();
	331	fAtoms.resize(count); // set initial bucket count
	332	if ( fgLogHashtable ) fprintf(stderr, "ld64: building hashtable of %u entries for %s\n", count, path);
	333	const struct dylib_table_of_contents* toc = (dylib_table_of_contents)((char)header + dynamicInfo->tocoff());
	334	for (int32_t i = 0; i < count; ++i) {
	335	const uint32_t index = E::get32(toc[i].symbol_index);
	336	const macho_nlist<P>* sym = &symbolTable[index];
	337	AtomAndWeak bucket;
	338	bucket.atom = NULL;
	339	bucket.weak = ((sym->n_desc() & N_WEAK_DEF) != 0);
	340	const char* name = strdup(&strings[sym->n_strx()]);
	341	if ( fgLogHashtable ) fprintf(stderr, " adding %s to hash table for %s\n", name, this->getPath());
	342	fAtoms[name] = bucket;
	343	}
	344	}
	345
	346	// unmap file
	347	munmap((caddr_t)fileContent, fileLength);
	348	}
	349
	350	template <typename A>
	351	std::vector<class ObjectFile::Atom*>& Reader<A>::getAtoms()
	352	{
	353	// TO DO: for flat-namespace libraries, when linking flat_namespace
	354	// we need to create an atom which references all undefines
	355	return fgEmptyAtomList;
	356	}
	357
	358
	359	template <typename A>
	360	std::vector<class ObjectFile::Atom> Reader<A>::getJustInTimeAtomsFor(const char* name)
	361	{
	362	std::vector<class ObjectFile::Atom> atoms = NULL;
	363
	364	NameToAtomMapIterator pos = fAtoms.find(name);
	365	if ( pos != fAtoms.end() ) {
	366	if ( pos->second.atom == NULL ) {
	367	// instantiate atom and update hash table
	368	pos->second.atom = new ExportAtom<A>(*this, name, pos->second.weak);
	369	if ( fgLogHashtable ) fprintf(stderr, "getJustInTimeAtomsFor: %s found in %s\n", name, this->getPath());
	370	}
	371	// return a vector of one atom
372	atoms = new std::vector<class ObjectFile::Atom*>;
373	atoms->push_back(pos->second.atom);
374	}
375	else {
376	if ( fgLogHashtable ) fprintf(stderr, "getJustInTimeAtomsFor: %s NOT found in %s\n", name, this->getPath());
377	}
378	return atoms;
379	}
380
381
382
383	template <typename A>
384	std::vector<const char> Reader<A>::getDependentLibraryPaths()
385	{
386	std::vector<const char> result = new std::vector<const char*>;
387	for (typename std::vector<PathAndFlag>::iterator it = fDependentLibraryPaths.begin(); it != fDependentLibraryPaths.end(); it++) {
388	result->push_back(it->path);
389	}
390	return result;
391	}
392
393	template <typename A>
394	std::vector<const char> Reader<A>::getAllowableClients()
395	{
396	std::vector<const char> result = new std::vector<const char*>;
397	for (typename std::vector<const char*>::iterator it = fAllowableClients.begin();
398	it != fAllowableClients.end();
399	it++) {
400	result->push_back(*it);
401	}
402	return (fAllowableClients.size() != 0 ? result : NULL);
403	}
404
405	template <typename A>
406	bool Reader<A>::reExports(ObjectFile::Reader* child)
407	{
408	// A dependent dylib is re-exported under two conditions:
409	// 1) parent contains LC_SUB_UMBRELLA or LC_SUB_LIBRARY with child name
69a49097	410	const char* childInstallPath = child->getInstallPath();
d696c285	411	for (typename std::vector<PathAndFlag>::iterator it = fDependentLibraryPaths.begin(); it != fDependentLibraryPaths.end(); it++) {
69a49097	412	if ( it->reExport && ((strcmp(it->path, child->getPath()) == 0) \|\| ((childInstallPath!=NULL) && (strcmp(it->path, childInstallPath)==0))) )
d696c285 A	413	return true;
	414	}
	415
	416	// 2) child contains LC_SUB_FRAMEWORK with parent name
	417	const char* parentUmbrellaName = ((Reader<A>*)child)->parentUmbrella();
	418	if ( parentUmbrellaName != NULL ) {
	419	const char* parentName = this->getPath();
	420	const char* lastSlash = strrchr(parentName, '/');
	421	if ( (lastSlash != NULL) && (strcmp(&lastSlash[1], parentUmbrellaName) == 0) )
	422	return true;
	423	}
	424
	425	return false;
	426	}
	427
	428	template <>
69a49097	429	bool Reader<ppc>::validFile(const uint8_t* fileContent, bool executableOrDylib)
d696c285 A	430	{
	431	const macho_header<P>* header = (const macho_header<P>*)fileContent;
	432	if ( header->magic() != MH_MAGIC )
	433	return false;
	434	if ( header->cputype() != CPU_TYPE_POWERPC )
	435	return false;
69a49097 A	436	switch ( header->filetype() ) {
	437	case MH_DYLIB:
	438	case MH_DYLIB_STUB:
	439	return true;
	440	case MH_EXECUTE:
	441	return executableOrDylib;
	442	default:
	443	return false;
	444	}
d696c285 A	445	}
	446
	447	template <>
69a49097	448	bool Reader<ppc64>::validFile(const uint8_t* fileContent, bool executableOrDylib)
d696c285 A	449	{
	450	const macho_header<P>* header = (const macho_header<P>*)fileContent;
	451	if ( header->magic() != MH_MAGIC_64 )
	452	return false;
	453	if ( header->cputype() != CPU_TYPE_POWERPC64 )
	454	return false;
69a49097 A	455	switch ( header->filetype() ) {
	456	case MH_DYLIB:
	457	case MH_DYLIB_STUB:
	458	return true;
	459	case MH_EXECUTE:
	460	return executableOrDylib;
	461	default:
	462	return false;
	463	}
d696c285 A	464	}
	465
	466	template <>
69a49097	467	bool Reader<x86>::validFile(const uint8_t* fileContent, bool executableOrDylib)
d696c285 A	468	{
	469	const macho_header<P>* header = (const macho_header<P>*)fileContent;
	470	if ( header->magic() != MH_MAGIC )
	471	return false;
	472	if ( header->cputype() != CPU_TYPE_I386 )
	473	return false;
69a49097 A	474	switch ( header->filetype() ) {
	475	case MH_DYLIB:
	476	case MH_DYLIB_STUB:
	477	return true;
	478	case MH_EXECUTE:
	479	return executableOrDylib;
	480	default:
	481	return false;
	482	}
d696c285 A	483	}
d696c285 A	484
69a49097 A	485	template <>
	486	bool Reader<x86_64>::validFile(const uint8_t* fileContent, bool executableOrDylib)
	487	{
	488	const macho_header<P>* header = (const macho_header<P>*)fileContent;
	489	if ( header->magic() != MH_MAGIC_64 )
	490	return false;
	491	if ( header->cputype() != CPU_TYPE_X86_64 )
	492	return false;
	493	switch ( header->filetype() ) {
	494	case MH_DYLIB:
	495	case MH_DYLIB_STUB:
	496	return true;
	497	case MH_EXECUTE:
	498	return executableOrDylib;
	499	default:
	500	return false;
	501	}
	502	}
d696c285 A	503
	504
	505
86b84c30	506
d696c285 A	507	}; // namespace dylib
	508	}; // namespace mach_o
	509
	510
	511	#endif // __OBJECT_FILE_DYLIB_MACH_O__