ld64-85.2.2.tar.gz

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

/* -*- mode: C++; c-basic-offset: 4; tab-width: 4 -*-
 *
 * Copyright (c) 2006-2008 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 __LTO_READER_H__
#define __LTO_READER_H__

#include <stdlib.h>
#include <mach-o/dyld.h>
#include <vector>
#include <ext/hash_set>
#include <ext/hash_map>

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

#include "llvm-c/lto.h"


namespace lto {


//
// Reference handles Atom references. These references facilitate 
// symbol resolution.
//

class Reference : public ObjectFile::Reference
{
public:
										Reference(const char* name) : fTargetName(name), fTargetAtom(NULL) { }
										Reference(ObjectFile::Atom& atom) : fTargetName(NULL), fTargetAtom(&atom) { }

	bool 								isTargetUnbound() const 			{ return fTargetAtom == NULL; }
	bool 								isFromTargetUnbound() const 		{ return true; }
	uint8_t 							getKind() const 					{ return 0; }
	uint64_t 							getFixUpOffset() const 				{ return 0; }
	const char * 						getTargetName() const 				{ return fTargetName; }
	ObjectFile::Atom& 					getTarget() const 					{ return *fTargetAtom; }
	uint64_t 							getTargetOffset() const 			{ return 0; }
	bool 								hasFromTarget() const 				{ return false; }
	ObjectFile::Atom& 					getFromTarget() const 				{ return *((ObjectFile::Atom*)NULL); }
	const char *						getFromTargetName() const 			{ return NULL; }
	uint64_t 							getFromTargetOffset() const 		{ return 0; }
	TargetBinding						getTargetBinding() const;
	TargetBinding						getFromTargetBinding() const  { return kDontBind; }
	void 								setTarget (ObjectFile::Atom& a, uint64_t offset) 
										{ fTargetAtom = &a; }
	void 								setFromTarget(ObjectFile::Atom &a) 	{ }
	const char *						getDescription() const;

private:
	const char *						fTargetName;
	ObjectFile::Atom *					fTargetAtom;
};


ObjectFile::Reference::TargetBinding Reference::getTargetBinding() const 
{ 
	if ( fTargetAtom == NULL ) 
		return kUnboundByName;
	else if ( fTargetName == NULL ) 
		return kBoundDirectly;
	else
		return kBoundByName;
}

const char* Reference::getDescription() const
{ 
	static char temp[256];
	strcpy(temp, "reference to ");
	if ( fTargetName != NULL )
		strcat(temp, fTargetName);
	else
		strcat(temp, fTargetAtom->getDisplayName());
	return temp; 
}


class Segment : public ObjectFile::Segment
{
public:
										Segment(const char* name, bool readable, bool writable, bool executable, bool fixedAddress)
											: fName(name), fReadable(readable), fWritable(writable), fExecutable(executable), fFixedAddress(fixedAddress) {}
	virtual const char*					getName() const						{ return fName; }
	virtual bool						isContentReadable() const			{ return fReadable; }
	virtual bool						isContentWritable() const			{ return fWritable; }
	virtual bool						isContentExecutable() const			{ return fExecutable; }
	virtual bool						hasFixedAddress() const				{ return fFixedAddress; }

	static Segment						fgBootstrapSegment;

private:
	const char*							fName;
	const bool							fReadable;
	const bool							fWritable;
	const bool							fExecutable;
	const bool							fFixedAddress;
};

Segment	Segment:: fgBootstrapSegment("__TEMP", true, false, false, false);
  
	
	  

//
// Atom acts as a proxy Atom for the symbols that are exported by LLVM bitcode file. Initially,
// Reader creates Atoms to allow linker proceed with usual symbol resolution phase. After
// optimization is performed, real Atoms are created for these symobls. However these real Atoms
// are not inserted into global symbol table. Atom holds real Atom and forwards appropriate
// methods to real atom.
//
class Atom : public ObjectFile::Atom
{
public:
												Atom(class Reader& owner, const char* name, Scope, DefinitionKind, uint8_t alignment, ObjectFile::Atom& internalAtom);
	
	ObjectFile::Reader*							getFile() const 			{ return (ObjectFile::Reader*)&fOwner; }
	bool 										getTranslationUnitSource (const char **dir, const char **name) const 
																			{ return fRealAtom->getTranslationUnitSource(dir, name); }
	const char *								getName () const 			{ return fName;	}
	const char *								getDisplayName() const 		{ return this->getName(); }
	Scope 										getScope() const 			{ return fScope; }
	DefinitionKind 								getDefinitionKind() const	{ return (fRealAtom ? fRealAtom->getDefinitionKind() : fKind); }
	SymbolTableInclusion 						getSymbolTableInclusion() const 
																			{ return fRealAtom->getSymbolTableInclusion(); }
	bool 										dontDeadStrip() const 		{ return false; }
	bool 										isZeroFill() const 			{ return (fRealAtom ? fRealAtom->isZeroFill() : false); }
	bool										isThumb() const				{ return false; }
	uint64_t 									getSize() const 			{ return (fRealAtom ? fRealAtom->getSize() : 0); }
	std::vector<ObjectFile::Reference*>& 		getReferences() const 
																			{ return (fRealAtom ? fRealAtom->getReferences() : (std::vector<ObjectFile::Reference*>&)fReferences); }
	bool 										mustRemainInSection() const { return fRealAtom->mustRemainInSection(); }
	const char *								getSectionName() const 		{ return (fRealAtom ? fRealAtom->getSectionName() : NULL); }
	// Linker::optimize() sets section for this atom, not fRealAtom. Use this Atom's fSection.
	class ObjectFile::Section *					getSection() const 			{ return fSection; }
	ObjectFile::Segment& 						getSegment() const 			{ return (fRealAtom ? fRealAtom->getSegment() : Segment::fgBootstrapSegment); }
	uint32_t									getOrdinal() const			{ return (fRealAtom ? fRealAtom->getOrdinal() : 0); }
	ObjectFile::Atom& 							getFollowOnAtom() const 	{ return fRealAtom->getFollowOnAtom(); }
	std::vector<ObjectFile::LineInfo>* 			getLineInfo() const 		{ return (fRealAtom ? fRealAtom->getLineInfo() : NULL); }
	ObjectFile::Alignment						getAlignment() const		{ return (fRealAtom ? fRealAtom->getAlignment() : ObjectFile::Alignment(fAlignment)); }
	void 										copyRawContent(uint8_t buffer[]) const 
																			{ if (fRealAtom) fRealAtom->copyRawContent(buffer); }
	void 										setScope(Scope s) 			{ if (fRealAtom) fRealAtom->setScope(s); else fScope = s; }

	void 										setRealAtom (ObjectFile::Atom *atom) 
																			{ fRealAtom = atom; }
	ObjectFile::Atom *							getRealAtom() { return fRealAtom; }
	void 										addReference(ObjectFile::Reference *ref) 
																			{ fReferences.push_back(ref); }

	void										setSectionOffset(uint64_t offset) { fSectionOffset = offset; if (fRealAtom) fRealAtom->setSectionOffset(offset); }
	void										setSection(class ObjectFile::Section* sect) { fSection = sect; if (fRealAtom) fRealAtom->setSection(sect); }
																			
private:
	class Reader&								fOwner;
	const char*									fName;
	ObjectFile::Atom::Scope						fScope;
	ObjectFile::Atom::DefinitionKind 			fKind;
	uint8_t										fAlignment;
	ObjectFile::Atom*							fRealAtom;
	std::vector<ObjectFile::Reference*> 		fReferences;
};


Atom::Atom(class Reader& owner, const char* name, Scope scope, DefinitionKind kind, uint8_t alignment, ObjectFile::Atom& internalAtom) 
: fOwner(owner), fName(name), fScope(scope), fKind(kind), fAlignment(alignment), fRealAtom(NULL)
{
	// every Atom references the InternalAtom for its reader
	fReferences.push_back(new Reference(internalAtom));
}


//
// ld64 only tracks non-internal symbols from an llvm bitcode file.  
// We model this by having an InternalAtom which represent all internal functions and data.
// All non-interal symbols from a bitcode file are represented by a Atom
// and each Atom has a reference to the InternalAtom.  The InternalAtom
// also has references to each symbol external to the bitcode file. 
//
class InternalAtom : public ObjectFile::Atom
{
public:
												InternalAtom(class Reader& owner) : fOwner(owner) {}

	ObjectFile::Reader *						getFile() const 			{ return (ObjectFile::Reader*)&fOwner; }
	bool 										getTranslationUnitSource (const char **dir, const char **name) const 
																			{ return false; }
	const char *								getName () const 			{ return "__llvm-internal-atom";	}
	const char *								getDisplayName() const 		{ return this->getName(); }
	Scope 										getScope() const 			{ return scopeTranslationUnit; }
	DefinitionKind 								getDefinitionKind() const   { return kRegularDefinition; }
	SymbolTableInclusion 						getSymbolTableInclusion() const { return kSymbolTableNotIn; }
	bool 										dontDeadStrip() const 		{ return false; }
	bool 										isZeroFill() const 			{ return false; }
	bool										isThumb() const				{ return false; }
	uint64_t 									getSize() const 			{ return 0; }
	std::vector<ObjectFile::Reference*>& 		getReferences() const   	{ return  (std::vector<ObjectFile::Reference*>&)fReferences; }
	bool 										mustRemainInSection() const { return false; }
	const char *								getSectionName() const 		{ return NULL; }
	class ObjectFile::Section *					getSection() const 			{ return NULL; }
	ObjectFile::Segment& 						getSegment() const 			{ return Segment::fgBootstrapSegment; }
	uint32_t									getOrdinal() const          { return 0; }
	ObjectFile::Atom& 							getFollowOnAtom() const 	{ return *((ObjectFile::Atom*)NULL); }
	std::vector<ObjectFile::LineInfo>* 			getLineInfo() const 		{ return NULL; }
	ObjectFile::Alignment						getAlignment() const 		{ return ObjectFile::Alignment(0); }
	void 										copyRawContent(uint8_t buffer[]) const { }
	void 										setScope(Scope s) 			{ }

	void 										addReference(const char* targetName);
	
private:
	class Reader&							fOwner;
	std::vector<ObjectFile::Reference*> 		fReferences;
};


void InternalAtom::addReference(const char* name)
{
	fReferences.push_back(new Reference(name));
}




class RemovableAtoms
{
public:
	RemovableAtoms(std::set<ObjectFile::Atom*>& iAtoms) : fAtoms(iAtoms) {}

	bool operator()(ObjectFile::Atom*& atom) const {
		return ( fAtoms.count(atom) != 0 );
	}

private:
	std::set<ObjectFile::Atom*>& fAtoms;
};



//
// LLVM bitcode file reader
//
class Reader : public ObjectFile::Reader
{
public:
	static bool										validFile(const uint8_t* fileContent, uint64_t fileLength, cpu_type_t architecture);
	static bool										loaded() { return (::lto_get_version() != NULL); }
													Reader(const uint8_t* fileContent, uint64_t fileLength, 
																const char* path, time_t modTime, 
																const ObjectFile::ReaderOptions&, cpu_type_t arch);
	virtual											~Reader();
	
	virtual std::vector<class ObjectFile::Atom*>&	getAtoms()				{ return (std::vector<class ObjectFile::Atom*>&)(fAtoms); }
	virtual std::vector<class ObjectFile::Atom*>*	getJustInTimeAtomsFor(const char* name) { return NULL; }
	virtual const char*								getPath()				{ return fPath; }
	virtual time_t									getModificationTime()	{ return fModTime; }
	virtual ObjectFile::Reader::DebugInfoKind		getDebugInfoKind()		{ return kDebugInfoNone; }
	virtual std::vector<Stab>*						getStabs()				{ return NULL; }
	virtual void									optimize(std::vector<ObjectFile::Atom*> &allAtoms, std::vector<ObjectFile::Atom*> &newAtoms, 
																std::vector<const char*> &additionalUndefines, uint32_t nextInputOrdinal, 
																ObjectFile::Reader* writer, bool allGlobalsAReDeadStripRoots,
																int outputKind, bool verbose, bool saveTemps, const char* outputFilePath,
																bool pie, bool allowTextRelocs);

private:

	class CStringEquals
	{
	public:
		bool operator()(const char* left, const char* right) const { return (strcmp(left, right) == 0); }
	};
	typedef	__gnu_cxx::hash_set<const char*, __gnu_cxx::hash<const char*>, CStringEquals>  CStringSet;
	typedef __gnu_cxx::hash_map<const char*, Atom*, __gnu_cxx::hash<const char*>, CStringEquals> CStringToAtom;
	
	ObjectFile::Reader*								makeMachOReader(const uint8_t* p, size_t len, uint32_t nextInputOrdinal);
	static const char*								tripletPrefixForArch(cpu_type_t);

	cpu_type_t										fArchitecture;
	const char*										fPath;
	time_t											fModTime;
	lto_module_t									fModule;
	std::vector<ObjectFile::Atom*>					fAtoms;
	InternalAtom									fInternalAtom;
	const ObjectFile::ReaderOptions&				fReaderOptions;
	static std::set<Reader*>						fgReaders;
	static bool										fgOptimized;
};

bool					Reader::fgOptimized = false;
std::set<Reader*>		Reader::fgReaders;


Reader::~Reader()
{
	if ( fModule != NULL )
		::lto_module_dispose(fModule);
}

Reader::Reader(const uint8_t* fileContent, uint64_t fileLength, const char* path, time_t modTime, 
				const ObjectFile::ReaderOptions& options, cpu_type_t arch)
	: fArchitecture(arch), fPath(path), fModTime(modTime), fInternalAtom(*this), fReaderOptions(options)
{
	fgReaders.insert(this);

	fModule = ::lto_module_create_from_memory(fileContent, fileLength);
    if ( fModule == NULL )
		throwf("could not parse object file %s: %s", path, lto_get_error_message());
	
	
	uint32_t count = ::lto_module_get_num_symbols(fModule);
	for (uint32_t i=0; i < count; ++i) {
		const char* name = ::lto_module_get_symbol_name(fModule, i);
		lto_symbol_attributes attr = lto_module_get_symbol_attribute(fModule, i);
		
		ObjectFile::Atom::DefinitionKind kind;
		switch ( attr & LTO_SYMBOL_DEFINITION_MASK ) {
			case LTO_SYMBOL_DEFINITION_REGULAR:
				kind = ObjectFile::Atom::kRegularDefinition;
				break;
			case LTO_SYMBOL_DEFINITION_TENTATIVE:
				kind = ObjectFile::Atom::kTentativeDefinition;
				break;
			case LTO_SYMBOL_DEFINITION_WEAK:
				kind = ObjectFile::Atom::kWeakDefinition;
				break;
			case LTO_SYMBOL_DEFINITION_UNDEFINED:
				kind = ObjectFile::Atom::kExternalDefinition;
				break;
			default:
				throwf("unknown definition kind for symbol %s in bitcode file %s", name, path);
		}

		// make LLVM atoms for definitions and a reference for undefines
		if ( kind != ObjectFile::Atom::kExternalDefinition ) {
			ObjectFile::Atom::Scope scope;
			switch ( attr & LTO_SYMBOL_SCOPE_MASK) {
				case LTO_SYMBOL_SCOPE_INTERNAL:
					scope = ObjectFile::Atom::scopeTranslationUnit;
					break;
				case LTO_SYMBOL_SCOPE_HIDDEN:
					scope = ObjectFile::Atom::scopeLinkageUnit;
					break;
				case LTO_SYMBOL_SCOPE_DEFAULT:
					scope = ObjectFile::Atom::scopeGlobal;
					break;
				default:
					throwf("unknown scope for symbol %s in bitcode file %s", name, path);
			}
			// only make atoms for non-internal symbols 
			if ( scope == ObjectFile::Atom::scopeTranslationUnit )
				continue;
			uint8_t alignment = (attr & LTO_SYMBOL_ALIGNMENT_MASK);
			// make Atom
			fAtoms.push_back(new Atom(*this, name, scope, kind, alignment, fInternalAtom));
		}
		else {
			// add to list of external references
			fInternalAtom.addReference(name);
		}
	}
}

const char* Reader::tripletPrefixForArch(cpu_type_t arch)
{
	switch (arch) {
		case CPU_TYPE_POWERPC:
			return "powerpc-";
		case CPU_TYPE_POWERPC64:
			return "powerpc64-";
		case CPU_TYPE_I386:
			return "i386-";
		case CPU_TYPE_X86_64:
			return "x86_64-";
		case CPU_TYPE_ARM:
			return "arm-";
	}
	return "";
}

bool Reader::validFile(const uint8_t* fileContent, uint64_t fileLength, cpu_type_t architecture)
{
	return ::lto_module_is_object_file_in_memory_for_target(fileContent, fileLength, tripletPrefixForArch(architecture));
}

void Reader::optimize(std::vector<ObjectFile::Atom *>& allAtoms, std::vector<ObjectFile::Atom*>& newAtoms, 
							std::vector<const char*>& additionalUndefines, uint32_t nextInputOrdinal, 
							ObjectFile::Reader* writer, bool allGlobalsAReDeadStripRoots,
							int okind, bool verbose, bool saveTemps, const char* outputFilePath,
							bool pie, bool allowTextRelocs)
{ 
	// this method is call on all Readers.  We want the first call to trigger optimization
	// across all Readers and the subsequent calls to do nothing.
	if ( fgOptimized ) 
		return;
	fgOptimized = true;
	
	Options::OutputKind outputKind = (Options::OutputKind)okind; // HACK to work around upward dependency

	// print out LTO version string if -v was used
	if ( verbose )
		fprintf(stderr, "%s\n", lto_get_version());
	
	// create optimizer and add each Reader
	lto_code_gen_t generator = ::lto_codegen_create();
	for (std::set<Reader*>::iterator it=fgReaders.begin(); it != fgReaders.end(); ++it) {
		if ( ::lto_codegen_add_module(generator, (*it)->fModule) )
			throwf("lto: could not merge in %s", (*it)->fPath);
	}

	// the linker must preserve all globals in dylibs and flat images
	const bool globalsNeedPreserving = allGlobalsAReDeadStripRoots || fReaderOptions.fFlatNamespace;
	
	// The atom graph uses directed edges (references). Collect all references where 
	// originating atom is not part of any LTO Reader. This allows optimizer to optimize an 
	// external (i.e. not originated from same .o file) reference if all originating atoms are also 
	// defined in llvm bitcode file.
	CStringSet nonLLVMRefs;
	CStringToAtom llvmAtoms;
    bool hasNonllvmAtoms = false;
	for (std::vector<ObjectFile::Atom*>::iterator it = allAtoms.begin(); it != allAtoms.end(); ++it) {
		ObjectFile::Atom* atom = *it;
		// only look at references come from an atom that is not an llvm atom
		if ( fgReaders.count((Reader*)(atom->getFile())) == 0 ) {
				// remember if we've seen an atoms not from an llvm reader and not from the writer
				if ( atom->getFile() != writer )
					hasNonllvmAtoms = true;
				std::vector<ObjectFile::Reference*>& refs = atom->getReferences();
				for (std::vector<ObjectFile::Reference*>::iterator ri=refs.begin(), re=refs.end(); ri != re; ++ri) {
					ObjectFile::Reference* ref = *ri;
					// add target name to set if target is an llvm atom
					if ( (ref->getTargetName() != NULL) && (fgReaders.count((Reader*)(ref->getTarget().getFile())) != 0) ) {
						nonLLVMRefs.insert(ref->getTargetName());
				}
			}
		}
		else {
			const char* name = atom->getName();
			if ( name != NULL )
				llvmAtoms[name] = (Atom*)atom;
		}
	}
	// tell code generator about symbols that must be preserved
	for (CStringToAtom::iterator it = llvmAtoms.begin(); it != llvmAtoms.end(); ++it) {
		const char* name = it->first;
		Atom* atom = it->second;
		// Include llvm Symbol in export list if it meets one of following two conditions
		// 1 - globals need preserving and atom scope is global (and not linkage unit).
		// 2 - included in nonLLVMRefs set.
		// If a symbol is not listed in exportList then LTO is free to optimize it away.
		if ( globalsNeedPreserving && (atom->getScope() == ObjectFile::Atom::scopeGlobal) )
			::lto_codegen_add_must_preserve_symbol(generator, name);
		else if ( nonLLVMRefs.find(name) != nonLLVMRefs.end() )
			::lto_codegen_add_must_preserve_symbol(generator, name);
	}
	
    // special case running ld -r on all bitcode files to produce another bitcode file (instead of mach-o)
    if ( (outputKind == Options::kObjectFile) && !hasNonllvmAtoms ) {
		if ( ! ::lto_codegen_write_merged_modules(generator, outputFilePath) ) {
			// HACK, no good way to tell linker we are all done, so just quit
			exit(0);
		}
		warning("could not produce merged bitcode file");
    }
    
    // if requested, save off merged bitcode file
    if ( saveTemps ) {
        char tempBitcodePath[MAXPATHLEN];
        strcpy(tempBitcodePath, outputFilePath);
        strcat(tempBitcodePath, ".lto.bc");
        ::lto_codegen_write_merged_modules(generator, tempBitcodePath);
    }

	// set code-gen model
	lto_codegen_model model = LTO_CODEGEN_PIC_MODEL_DYNAMIC;
	switch ( outputKind ) {
		case Options::kDynamicExecutable:
			if ( pie )
				model = LTO_CODEGEN_PIC_MODEL_DYNAMIC;
			else
				model = LTO_CODEGEN_PIC_MODEL_DYNAMIC_NO_PIC;
			break;
		case Options::kDynamicLibrary:
		case Options::kDynamicBundle:
		case Options::kObjectFile: // ?? Is this appropriate ?
		case Options::kDyld:
			if ( allowTextRelocs )
				model = LTO_CODEGEN_PIC_MODEL_DYNAMIC_NO_PIC;
			else
				model = LTO_CODEGEN_PIC_MODEL_DYNAMIC;
			break;
		case Options::kStaticExecutable:
			model = LTO_CODEGEN_PIC_MODEL_STATIC;
			break;
	}
	if ( ::lto_codegen_set_pic_model(generator, model) )
		throwf("could not create set codegen model: %s", lto_get_error_message());

	// run code generator
	size_t machOFileLen;
	const uint8_t* machOFile = (uint8_t*)::lto_codegen_compile(generator, &machOFileLen);
	if ( machOFile == NULL ) 
		throwf("could not do LTO codegen: %s", ::lto_get_error_message());
	
    // if requested, save off temp mach-o file
    if ( saveTemps ) {
        char tempMachoPath[MAXPATHLEN];
        strcpy(tempMachoPath, outputFilePath);
        strcat(tempMachoPath, ".lto.o");
        int fd = ::open(tempMachoPath, O_CREAT | O_WRONLY | O_TRUNC, 0666);
		if ( fd != -1) {
			::write(fd, machOFile, machOFileLen);
			::close(fd);
		}
    }

	// parse generated mach-o file into a MachOReader
	ObjectFile::Reader* machoReader = this->makeMachOReader(machOFile, machOFileLen, nextInputOrdinal);
	
	// sync generated mach-o atoms with existing atoms ld know about
	std::vector<ObjectFile::Atom*> machoAtoms = machoReader->getAtoms();
	for (std::vector<ObjectFile::Atom *>::iterator it = machoAtoms.begin(); it != machoAtoms.end(); ++it) {
		ObjectFile::Atom* atom = *it;
		const char* name = atom->getName();
		if ( name != NULL ) {
			CStringToAtom::iterator pos = llvmAtoms.find(name);
			if ( pos != llvmAtoms.end() ) {
				// turn Atom into a proxy for this mach-o atom
				pos->second->setRealAtom(atom);
			}
			else {
				// this atom is did not exist orginally, tell ld about it
				newAtoms.push_back(atom);
			}
		}
		else {
			// ld only knew about named atoms, so this one must be new
			newAtoms.push_back(atom);
		}
		std::vector<class ObjectFile::Reference*>& references = atom->getReferences();
		for (std::vector<ObjectFile::Reference*>::iterator rit=references.begin(); rit != references.end(); ++rit) {
			ObjectFile::Reference* ref = *rit;
			const char* targetName = ref->getTargetName();
			CStringToAtom::iterator pos;
			if (targetName != NULL) {
				switch ( ref->getTargetBinding() ) {
					case ObjectFile::Reference::kUnboundByName:
						// accumulate unbounded references so that ld can bound them.
						additionalUndefines.push_back(targetName);
						break;
					case ObjectFile::Reference::kBoundDirectly:
					case ObjectFile::Reference::kBoundByName:
						// If mach-o atom is referencing another mach-o atom then 
						// reference is not going through Atom proxy. Fix it here to ensure that all
						// llvm symbol references always go through Atom proxy.
						pos = llvmAtoms.find(targetName);
						if ( pos != llvmAtoms.end() )
							ref->setTarget(*pos->second, ref->getTargetOffset());
						break;
					case ObjectFile::Reference::kDontBind:
						break;
				}
			}
		}
	}
		
	// Remove InternalAtoms from ld
	std::set<class ObjectFile::Atom*> deletedAtoms;
	for (std::set<Reader*>::iterator it=fgReaders.begin(); it != fgReaders.end(); ++it) {
		deletedAtoms.insert(&((*it)->fInternalAtom));
	}
	// Remove Atoms from ld if code generator optimized them away
	for (CStringToAtom::iterator li = llvmAtoms.begin(), le = llvmAtoms.end(); li != le; ++li) {
		// check if setRealAtom() called on this Atom
		if ( li->second->getRealAtom() == NULL )
			deletedAtoms.insert(li->second);
	}
	allAtoms.erase(std::remove_if(allAtoms.begin(), allAtoms.end(), RemovableAtoms(deletedAtoms)), allAtoms.end());
}


ObjectFile::Reader* Reader::makeMachOReader(const uint8_t* p, size_t len, uint32_t nextInputOrdinal) 
{
	switch ( fArchitecture ) {
		case CPU_TYPE_POWERPC:
			if ( mach_o::relocatable::Reader<ppc>::validFile(p) )
				return new mach_o::relocatable::Reader<ppc>(p, "/tmp/lto.o", 0, fReaderOptions, nextInputOrdinal);
			break;
		case CPU_TYPE_POWERPC64:
			if ( mach_o::relocatable::Reader<ppc64>::validFile(p) )
				return new mach_o::relocatable::Reader<ppc64>(p, "/tmp/lto.o", 0, fReaderOptions, nextInputOrdinal);
			break;
		case CPU_TYPE_I386:
			if ( mach_o::relocatable::Reader<x86>::validFile(p) )
				return new mach_o::relocatable::Reader<x86>(p, "/tmp/lto.o", 0, fReaderOptions, nextInputOrdinal);
			break;
		case CPU_TYPE_X86_64:
			if ( mach_o::relocatable::Reader<x86_64>::validFile(p) )
				return new mach_o::relocatable::Reader<x86_64>(p, "/tmp/lto.o", 0, fReaderOptions, nextInputOrdinal);
			break;
		case CPU_TYPE_ARM:
			if ( mach_o::relocatable::Reader<arm>::validFile(p) )
				return new mach_o::relocatable::Reader<arm>(p, "/tmp/lto.o", 0, fReaderOptions, nextInputOrdinal);
			break;
	}
	throw "LLVM LTO, file is not of required architecture";
}

}; // namespace lto


void printLTOVersion(Options &opts) {
	const char* vers = lto_get_version();
	if ( vers != NULL )
		fprintf(stderr, "%s\n", vers);
}


#endif