ld64-95.2.12.tar.gz

[apple/ld64.git] / src / ld / MachOReaderRelocatable.hpp

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

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

#include <vector>
#include <set>
#include <algorithm>

#include "MachOFileAbstraction.hpp"
#include "Architectures.hpp"
#include "ObjectFile.h"
#include "dwarf2.h"
#include "debugline.h"

#include <libunwind/DwarfInstructions.hpp>
#include <libunwind/AddressSpace.hpp>
#include <libunwind/Registers.hpp>

//
//
//	To implement architecture xxx, you must write template specializations for the following six methods:
//			Reader<xxx>::validFile()
//			Reader<xxx>::validSectionType()
//			Reader<xxx>::addRelocReference()
//			Reference<xxx>::getDescription()
//
//



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

namespace mach_o {
namespace relocatable {



class ReferenceSorter
{
public:
	bool operator()(const ObjectFile::Reference* left, const ObjectFile::Reference* right)
	{
		return ( left->getFixUpOffset() < right->getFixUpOffset() );
	}
};


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

struct AtomAndOffset
{
						AtomAndOffset(ObjectFile::Atom* a=NULL) : atom(a), offset(0) {}
						AtomAndOffset(ObjectFile::Atom* a, uint32_t off) : atom(a), offset(off) {}
	ObjectFile::Atom*	atom;
	uint32_t			offset;
};


template <typename A>
class Reference : public ObjectFile::Reference
{
public:
	typedef typename A::P						P;
	typedef typename A::P::uint_t				pint_t;
	typedef typename A::ReferenceKinds			Kinds;

							Reference(Kinds kind, const AtomAndOffset& at, const AtomAndOffset& toTarget);
							Reference(Kinds kind, const AtomAndOffset& at, const AtomAndOffset& fromTarget, const AtomAndOffset& toTarget);
							Reference(Kinds kind, const AtomAndOffset& at, const char* toName, uint32_t toOffset);

	virtual					~Reference() {}


	virtual ObjectFile::Reference::TargetBinding	getTargetBinding() const;
	virtual ObjectFile::Reference::TargetBinding	getFromTargetBinding() const;
	virtual uint8_t			getKind() const									{ return (uint8_t)fKind; }
	virtual uint64_t		getFixUpOffset() const							{ return fFixUpOffsetInSrc; }
	virtual const char*		getTargetName() const							{ return (fToTarget.atom != NULL) ? fToTarget.atom->getName() : fToTargetName;  }
	virtual ObjectFile::Atom& getTarget() const								{ return *fToTarget.atom; }
	virtual uint64_t		getTargetOffset() const							{ return (int64_t)((int32_t)fToTarget.offset); }
	virtual ObjectFile::Atom& getFromTarget() const							{ return *fFromTarget.atom; }
	virtual const char*		getFromTargetName() const						{ return (fFromTarget.atom != NULL) ? fFromTarget.atom->getName() : fFromTargetName; }
	virtual void			setTarget(ObjectFile::Atom& target, uint64_t offset)	{ fToTarget.atom = &target; fToTarget.offset = offset;  }
	virtual void			setToTargetOffset(uint64_t offset)				{ fToTarget.offset = offset; }
	virtual void			setFromTarget(ObjectFile::Atom& target)			{ fFromTarget.atom = &target; }
	virtual void			setFromTargetName(const char* name)				{ fFromTargetName = name; }
	virtual void			setFromTargetOffset(uint64_t offset)			{ fFromTarget.offset = offset; }
	virtual const char*		getDescription() const;
	virtual uint64_t		getFromTargetOffset() const						{ return fFromTarget.offset; }
	virtual bool			isBranch() const;
	virtual const char*		getTargetDisplayName() const					{ return (fToTarget.atom != NULL) ? fToTarget.atom->getDisplayName() : fToTargetName;  }
	virtual const char*		getFromTargetDisplayName() const				{ return (fFromTarget.atom != NULL) ? fFromTarget.atom->getDisplayName() : fFromTargetName; }

	static bool				fgForFinalLinkedImage;

private:
	pint_t					fFixUpOffsetInSrc;
	AtomAndOffset			fToTarget;
	AtomAndOffset			fFromTarget;
	const char*				fToTargetName;
	const char*				fFromTargetName;
	Kinds					fKind;
	
};


template <typename A> bool Reference<A>::fgForFinalLinkedImage = true;

template <typename A>
Reference<A>::Reference(Kinds kind, const AtomAndOffset& at, const AtomAndOffset& toTarget)
 : fFixUpOffsetInSrc(at.offset), fToTarget(toTarget), fToTargetName(NULL), fFromTargetName(NULL),
    fKind(kind)
{
	// make reference a by-name unless:
	// - the reference type is only used with direct references
	// - the target is translation unit scoped
	// - the target kind is not regular (is weak or tentative)
	if ( (kind != A::kNoFixUp) && (kind != A::kFollowOn) && (kind != A::kGroupSubordinate)
		&& (toTarget.atom->getScope() != ObjectFile::Atom::scopeTranslationUnit) 
		&& (toTarget.atom->getDefinitionKind() != ObjectFile::Atom::kRegularDefinition)
		&& (toTarget.atom != at.atom) ) {
		fToTargetName = toTarget.atom->getName();
		//fprintf(stderr, "Reference(): changing to by-name %p %s, target scope=%d, target section=%s\n", toTarget.atom, fToTargetName, toTarget.atom->getScope(), toTarget.atom->getSectionName());
		fToTarget.atom = NULL;
	}
	((class BaseAtom*)at.atom)->addReference(this);
	//fprintf(stderr, "Reference(): %p fToTarget<%s, %08X>\n", this, (fToTarget.atom != NULL) ? fToTarget.atom->getDisplayName() : fToTargetName , fToTarget.offset);
}

template <typename A>
Reference<A>::Reference(Kinds kind, const AtomAndOffset& at, const AtomAndOffset& fromTarget, const AtomAndOffset& toTarget)
 : fFixUpOffsetInSrc(at.offset), fToTarget(toTarget), fFromTarget(fromTarget),
   fToTargetName(NULL), fFromTargetName(NULL), fKind(kind)
{
	// make reference a by-name where needed
	if ( (kind != A::kNoFixUp) && (kind != A::kFollowOn) && (kind != A::kGroupSubordinate)
		&& (toTarget.atom->getScope() != ObjectFile::Atom::scopeTranslationUnit)
		&& (toTarget.atom->getDefinitionKind() != ObjectFile::Atom::kRegularDefinition) 
		&& (toTarget.atom != at.atom) ) {
			fToTargetName = toTarget.atom->getName();
			fToTarget.atom = NULL;
	}
	((class BaseAtom*)at.atom)->addReference(this);
	//fprintf(stderr, "Reference(): %p kind=%d, fToTarget<%s, %08X>, fromTarget<%s, %08X>\n", this, kind,
	//	 this->getTargetName(), fToTarget.offset, this->getFromTargetName(), fromTarget.offset);
}

template <typename A>
Reference<A>::Reference(Kinds kind, const AtomAndOffset& at, const char* toName, uint32_t toOffset)
 : fFixUpOffsetInSrc(at.offset),
   fToTargetName(toName), fFromTargetName(NULL), fKind(kind)
{
	fToTarget.offset = toOffset;
	((class BaseAtom*)at.atom)->addReference(this);
}

template <typename A>
ObjectFile::Reference::TargetBinding Reference<A>::getTargetBinding() const
{
	if ( fgForFinalLinkedImage ) {
		if ( (fKind == A::kDtraceProbe) || (fKind == A::kDtraceProbeSite) || (fKind == A::kDtraceIsEnabledSite) || (fKind == A::kDtraceTypeReference) )
			return ObjectFile::Reference::kDontBind;
	}
	if ( fToTarget.atom == NULL ) 
		return ObjectFile::Reference::kUnboundByName;
	if ( fToTargetName == NULL ) 
		return ObjectFile::Reference::kBoundDirectly;
	else
		return ObjectFile::Reference::kBoundByName;
}

template <typename A>
ObjectFile::Reference::TargetBinding Reference<A>::getFromTargetBinding() const
{
	if ( fFromTarget.atom == NULL ) {
		if ( fFromTargetName == NULL ) 
			return ObjectFile::Reference::kDontBind;
		else
			return ObjectFile::Reference::kUnboundByName;
	}
	else {
		if ( fFromTargetName == NULL ) 
			return ObjectFile::Reference::kBoundDirectly;
		else
			return ObjectFile::Reference::kBoundByName;
	}
}



template <typename A>
class Segment : public ObjectFile::Segment
{
public:
								Segment(const macho_section<typename A::P>* sect);
	virtual const char*			getName() const						{ return fSection->segname(); }
	virtual bool				isContentReadable() const			{ return true; }
	virtual bool				isContentWritable() const			{ return fWritable; }
	virtual bool				isContentExecutable() const			{ return fExecutable; }
private:
	const macho_section<typename A::P>*		fSection;
	bool									fWritable;
	bool									fExecutable;
};

template <typename A>
Segment<A>::Segment(const macho_section<typename A::P>* sect) 
 :	fSection(sect), fWritable(true),  fExecutable(false) 
{
	if ( strcmp(fSection->segname(), "__TEXT") == 0 ) {
		fWritable = false;
		fExecutable = true;
	}
	else if ( strcmp(fSection->segname(), "__IMPORT") == 0 ) {
		fWritable = true;
		fExecutable = true;
	}
}


class DataSegment : public ObjectFile::Segment
{
public:
	virtual const char*			getName() const						{ return "__DATA"; }
	virtual bool				isContentReadable() const			{ return true; }
	virtual bool				isContentWritable() const			{ return true; }
	virtual bool				isContentExecutable() const			{ return false; }

	static DataSegment			fgSingleton;
};

DataSegment DataSegment::fgSingleton;

class LinkEditSegment : public ObjectFile::Segment
{
public:
	virtual const char*			getName() const						{ return "__LINKEDIT"; }
	virtual bool				isContentReadable() const			{ return true; }
	virtual bool				isContentWritable() const			{ return false; }
	virtual bool				isContentExecutable() const			{ return false; }

	static LinkEditSegment			fgSingleton;
};

LinkEditSegment LinkEditSegment::fgSingleton;

class BaseAtom : public ObjectFile::Atom
{
public:
												BaseAtom() : fStabsStartIndex(0), fStabsCount(0), fHasCompactUnwindInfo(false) {}

	virtual void								setSize(uint64_t size) = 0;
	virtual void								addReference(ObjectFile::Reference* ref) = 0;
	virtual void								sortReferences() = 0;
	virtual void								addLineInfo(const ObjectFile::LineInfo& info) = 0;
	virtual const ObjectFile::ReaderOptions&	getOptions() const = 0;
	virtual uint64_t							getObjectAddress() const = 0;
	virtual uint32_t							getOrdinal() const { return fOrdinal; }
	virtual void								setOrdinal(uint32_t value) { fOrdinal = value; }
	virtual const void*							getSectionRecord() const = 0;
	virtual bool								isAlias() const { return false; }
	virtual uint8_t								getLSDAReferenceKind() const { return 0; }
	virtual uint8_t								getPersonalityReferenceKind() const { return 0; }
	virtual uint32_t							getCompactUnwindEncoding(uint64_t ehAtomAddress) { return 0; }
	virtual ObjectFile::UnwindInfo::iterator	beginUnwind()					{ return fHasCompactUnwindInfo ? &fSingleUnwindInfo[0] : NULL; }
	virtual ObjectFile::UnwindInfo::iterator	endUnwind()						{ return fHasCompactUnwindInfo ? &fSingleUnwindInfo[1] : NULL; }
	virtual ObjectFile::Reference*				getLSDA();
	virtual ObjectFile::Reference*				getFDE();
	virtual Atom*								getPersonalityPointer();
	virtual void								setCompactUnwindEncoding(uint64_t ehAtomAddress);

	uint32_t									fStabsStartIndex;
	uint32_t									fStabsCount;
	uint32_t									fOrdinal;
	ObjectFile::UnwindInfo						fSingleUnwindInfo[1];
	bool										fHasCompactUnwindInfo;
};


ObjectFile::Reference* BaseAtom::getLSDA()
{
	const uint8_t groupKind = this->getLSDAReferenceKind(); 
	const std::vector<ObjectFile::Reference*>& refs = this->getReferences();
	for (std::vector<ObjectFile::Reference*>::const_iterator it=refs.begin(); it != refs.end(); it++) {
		ObjectFile::Reference* ref = *it;
		if ( (ref->getKind() == groupKind) && (ref->getTarget().getContentType() == ObjectFile::Atom::kLSDAType) ) {
			return ref;
		}
	}
	return NULL;
}

ObjectFile::Reference* BaseAtom::getFDE()
{
	const uint8_t groupKind = this->getLSDAReferenceKind(); 
	const std::vector<ObjectFile::Reference*>& refs = this->getReferences();
	for (std::vector<ObjectFile::Reference*>::const_iterator it=refs.begin(); it != refs.end(); it++) {
		ObjectFile::Reference* ref = *it;
		if ( (ref->getKind() == groupKind) && (ref->getTarget().getContentType() == ObjectFile::Atom::kCFIType) ) {
			return ref;
		}
	}
	return NULL;
}

ObjectFile::Atom* BaseAtom::getPersonalityPointer()
{
	const uint8_t personalityKind = this->getPersonalityReferenceKind(); 
	const std::vector<ObjectFile::Reference*>& refs = this->getReferences();
	for (std::vector<ObjectFile::Reference*>::const_iterator it=refs.begin(); it != refs.end(); it++) {
		ObjectFile::Reference* ref = *it;
		if ( ref->getKind() == personalityKind ) {
			if ( strcmp(ref->getTarget().getSectionName(), "__nl_symbol_ptr") == 0 )
				return &ref->getTarget();
			if ( strcmp(ref->getTarget().getSectionName(), "__pointers") == 0 )
				return &ref->getTarget();
		}
	}
	return NULL;
}


void BaseAtom::setCompactUnwindEncoding(uint64_t ehAtomAddress)
{
	fSingleUnwindInfo[0].unwindInfo = this->getCompactUnwindEncoding(ehAtomAddress);
	fHasCompactUnwindInfo = true;
}


class BaseAtomSorter
{
public:
	bool operator()(const class BaseAtom* left, const class BaseAtom* right)  {
		if ( left == right )
			return false;
		uint64_t leftAddr  =  left->getObjectAddress();
		uint64_t rightAddr = right->getObjectAddress();
		if ( leftAddr < rightAddr ) {
			return true;
		}
		else if ( leftAddr > rightAddr ) {
			return false;
		}
		else {
			// if they have same address, one might be the end of a section and the other the start of the next section
			const void* leftSection  =  left->getSectionRecord();
			const void* rightSection =  right->getSectionRecord();
			if ( leftSection != rightSection ) {
				return ( leftSection < rightSection );
			}
			// if they have same address and section, one might be an alias
			bool leftAlias  = left->isAlias();
			bool rightAlias = right->isAlias();
			if ( leftAlias && rightAlias ) {
				// sort multiple aliases for same address first by scope
				ObjectFile::Atom::Scope	leftScope  = left->getScope();
				ObjectFile::Atom::Scope	rightScope = right->getScope();
				if ( leftScope != rightScope ) {
					return ( leftScope < rightScope );
				}
				// sort multiple aliases for same address then by name
				return ( strcmp(left->getName(), right->getName()) < 0 );
			}
			else if ( leftAlias ) {
				return true;
			}
			else if ( rightAlias ) {
				return false;
			}
			else {
				// they must be tentative defintions
				switch ( left->getDefinitionKind() ) {
					case ObjectFile::Atom::kTentativeDefinition:
						// sort tentative definitions by name
						return ( strcmp(left->getName(), right->getName()) < 0 );
					case ObjectFile::Atom::kAbsoluteSymbol:
						// sort absolute symbols with same address by name
						return ( strcmp(left->getName(), right->getName()) < 0 );
					default:
						// hack for rdar://problem/5102873
						if ( !left->isZeroFill() || !right->isZeroFill() )
							warning("atom sorting error for %s and %s in %s", left->getDisplayName(), right->getDisplayName(), left->getFile()->getPath());
						break;
				}
			}
		}
		return false;
	}
};


//
// A SymbolAtom represents a chunk of a mach-o object file that has a symbol table entry
// pointing to it.  A C function or global variable is represented by one of these atoms.
//
//
template <typename A>
class SymbolAtom : public BaseAtom
{
public:
	virtual ObjectFile::Reader*					getFile() const					{ return &fOwner; }
	virtual bool								getTranslationUnitSource(const char** dir, const char** name) const
																				{ return fOwner.getTranslationUnitSource(dir, name); }
	virtual const char*							getName() const					{ return &fOwner.fStrings[fSymbol->n_strx()]; }
	virtual const char*							getDisplayName() const			{ return getName(); }
	virtual ObjectFile::Atom::Scope				getScope() const				{ return fScope; }
	virtual ObjectFile::Atom::DefinitionKind	getDefinitionKind() const		{ return ((fSymbol->n_desc() & N_WEAK_DEF) != 0)
																						? ObjectFile::Atom::kWeakDefinition : ObjectFile::Atom::kRegularDefinition; }
	virtual ObjectFile::Atom::ContentType		getContentType() const			{ return fType; }
	virtual SymbolTableInclusion				getSymbolTableInclusion() const	{ return fSymbolTableInclusion; }
	virtual	bool								dontDeadStrip() const;
	virtual bool								isZeroFill() const				{ return ((fSection->flags() & SECTION_TYPE) == S_ZEROFILL); }
	virtual bool								isThumb() const					{ return ((fSymbol->n_desc() & N_ARM_THUMB_DEF) != 0); }
	virtual uint64_t							getSize() const					{ return fSize; }
	virtual std::vector<ObjectFile::Reference*>&  getReferences() const			{ return (std::vector<ObjectFile::Reference*>&)(fReferences); }
	virtual bool								mustRemainInSection() const		{ return true; }
	virtual const char*							getSectionName() const;
	virtual Segment<A>&							getSegment() const				{ return *fSegment; }
	virtual ObjectFile::Atom&					getFollowOnAtom() const;
	virtual std::vector<ObjectFile::LineInfo>*	getLineInfo() const				{ return (std::vector<ObjectFile::LineInfo>*)&fLineInfo; }
	virtual ObjectFile::Alignment				getAlignment() const			{ return fAlignment; }
	virtual void								copyRawContent(uint8_t buffer[]) const;
	virtual void								setScope(ObjectFile::Atom::Scope newScope)		{ fScope = newScope; }
	virtual void								setSize(uint64_t size);
	virtual void								addReference(ObjectFile::Reference* ref) { fReferences.push_back((Reference<A>*)ref); }
	virtual void								sortReferences() { std::sort(fReferences.begin(), fReferences.end(), ReferenceSorter()); }
	virtual void								addLineInfo(const  ObjectFile::LineInfo& info)	{ fLineInfo.push_back(info); }
	virtual const ObjectFile::ReaderOptions&	getOptions() const				{ return fOwner.fOptions; }
	virtual uint64_t							getObjectAddress() const 		{ return fAddress; }
	virtual const void*							getSectionRecord() const		{ return (const void*)fSection; }
	virtual uint8_t								getLSDAReferenceKind() const;
	virtual uint8_t								getPersonalityReferenceKind() const;
	virtual uint32_t							getCompactUnwindEncoding(uint64_t ehAtomAddress);

protected:
	typedef typename A::P						P;
	typedef typename A::P::E					E;
	typedef typename A::P::uint_t				pint_t;
	typedef typename A::ReferenceKinds			Kinds;
	typedef typename std::vector<Reference<A>*>			ReferenceVector;
	typedef typename ReferenceVector::iterator			ReferenceVectorIterator;		// seems to help C++ parser
	typedef typename ReferenceVector::const_iterator	ReferenceVectorConstIterator;	// seems to help C++ parser
	friend class Reader<A>;

											SymbolAtom(Reader<A>&, const macho_nlist<P>*, const macho_section<P>*);
	virtual									~SymbolAtom() {}

	Reader<A>&									fOwner;
	const macho_nlist<P>*						fSymbol;
	pint_t										fAddress;
	pint_t										fSize;
	const macho_section<P>*						fSection;
	Segment<A>*									fSegment;
	ReferenceVector								fReferences;
	std::vector<ObjectFile::LineInfo>			fLineInfo;
	ObjectFile::Atom::Scope						fScope;
	SymbolTableInclusion						fSymbolTableInclusion;
	ObjectFile::Atom::ContentType				fType;
	ObjectFile::Alignment						fAlignment;
};


template <typename A>
SymbolAtom<A>::SymbolAtom(Reader<A>& owner, const macho_nlist<P>* symbol, const macho_section<P>* section)
 : fOwner(owner), fSymbol(symbol), fAddress(0), fSize(0), fSection(section), fSegment(NULL), fType(ObjectFile::Atom::kUnclassifiedType), fAlignment(0)
{
    fSingleUnwindInfo[0].startOffset = 0;
	fSingleUnwindInfo[0].unwindInfo = 0;
	uint8_t type =  symbol->n_type();
	if ( (type & N_EXT) == 0 )
		fScope = ObjectFile::Atom::scopeTranslationUnit;
	else if ( (type & N_PEXT) != 0 )
		fScope = ObjectFile::Atom::scopeLinkageUnit;
	else
		fScope = ObjectFile::Atom::scopeGlobal;
	if ( (type & N_TYPE) == N_SECT ) {
		// real definition
 		fSegment = new Segment<A>(fSection);
		fAddress = fSymbol->n_value();
		pint_t sectionStartAddr = section->addr();
		pint_t sectionEndAddr = section->addr()+section->size();
		if ( (fAddress < sectionStartAddr) || (fAddress > (sectionEndAddr)) ) {
			throwf("malformed .o file, symbol %s with address 0x%0llX is not with section %d (%s,%s) address range of 0x%0llX to 0x%0llX",
				this->getName(), (uint64_t)fAddress, fSymbol->n_sect(), section->segname(), section->sectname(), 
				(uint64_t)sectionStartAddr, (uint64_t)(sectionEndAddr) );
		}
	}	
	else {
		warning("unknown symbol type: %d", type);
	}
	
	//fprintf(stderr, "SymbolAtom(%p) %s fAddress=0x%X\n", this, this->getDisplayName(), (uint32_t)fAddress);
	// support for .o files built with old ld64
	if ( (fSymbol->n_desc() & N_WEAK_DEF) && (strcmp(fSection->sectname(),"__picsymbolstub1__TEXT") == 0) ) {
		const char* name = this->getName();
		const int nameLen = strlen(name);
		if ( (nameLen > 6) && strcmp(&name[nameLen-5], "$stub") == 0 ) {
			// switch symbol to point at name that does not have trailing $stub
			char correctName[nameLen];
			strncpy(correctName, name, nameLen-5);
			correctName[nameLen-5] = '\0';
			const macho_nlist<P>* symbolsStart = fOwner.fSymbols;
			const macho_nlist<P>* symbolsEnd = &symbolsStart[fOwner.fSymbolCount];
			for(const macho_nlist<P>* s = symbolsStart; s < symbolsEnd; ++s) {
				if ( strcmp(&fOwner.fStrings[s->n_strx()], correctName) == 0 ) {
					fSymbol = s;
					break;
				}
			}
		}
	}
	// support for labeled stubs
	switch ( section->flags() & SECTION_TYPE ) {
		case S_SYMBOL_STUBS:
			setSize(section->reserved2());
			break;
		case S_LAZY_SYMBOL_POINTERS:
		case S_NON_LAZY_SYMBOL_POINTERS:
			setSize(sizeof(pint_t));
			break;
		case S_4BYTE_LITERALS:
			setSize(4);
			break;
		case S_8BYTE_LITERALS:
			setSize(8);
			break;
		case S_16BYTE_LITERALS:
			setSize(16);
			break;
		case S_CSTRING_LITERALS:
			setSize(strlen((char*)(fOwner.fHeader) + section->offset() + fAddress - section->addr()) + 1);
			fType = ObjectFile::Atom::kCStringType;
			break;
		case S_REGULAR:
		case S_ZEROFILL:
		case S_COALESCED:
			// size calculate later after next atom is found
			break;
	}
	
	// compute alignment
	fAlignment = ObjectFile::Alignment(fSection->align(), fAddress % (1 << fSection->align()));

	// compute whether this atom needs to be in symbol table
	if ( (fSymbol->n_desc() & REFERENCED_DYNAMICALLY) != 0) {
		fSymbolTableInclusion = ObjectFile::Atom::kSymbolTableInAndNeverStrip;
	}
	else if ( fOwner.fOptions.fForFinalLinkedImage && !fOwner.fOptions.fForStatic && (fOwner.fStrings[fSymbol->n_strx()] == 'l') ) {
		// labels beginning with a lowercase ell are automatically removed in final linked images <rdar://problem/4571042>
		// xnu code base uses a lot of asesembly labels that start with 'l', don't strip those (static executable)
		fSymbolTableInclusion = ObjectFile::Atom::kSymbolTableNotIn;
	}
	else {
		fSymbolTableInclusion = ObjectFile::Atom::kSymbolTableIn;
	}
	
	// work around malformed icc generated .o files  <rdar://problem/5349847>
	// if section starts with a symbol and that symbol address does not match section alignment, then force it to
	if ( (section->addr() == fAddress) && (fAlignment.modulus != 0) )
		fAlignment.modulus = 0;
}

template <typename A>
bool SymbolAtom<A>::dontDeadStrip() const
{
	// the symbol can have a no-dead-strip bit
	if ( (fSymbol->n_desc() & (N_NO_DEAD_STRIP|REFERENCED_DYNAMICALLY)) != 0 )
		return true;
	// or the section can have a no-dead-strip bit
	return ( fSection->flags() & S_ATTR_NO_DEAD_STRIP );
}


template <typename A>
const char*	SymbolAtom<A>::getSectionName() const
{
	if ( fOwner.fOptions.fForFinalLinkedImage ) {
		if ( strcmp(fSection->sectname(), "__textcoal_nt") == 0 )
			return "__text";
		else if ( strcmp(fSection->sectname(), "__const_coal") == 0 )
			return "__const";
		else if ( strcmp(fSection->sectname(), "__datacoal_nt") == 0 )
			return "__data";
		else if ( fOwner.fOptions.fAutoOrderInitializers && (strcmp(fSection->sectname(), "__StaticInit") == 0) )
			return "__text";
		else {
			switch ( fSection->flags() & SECTION_TYPE ) {
				case S_4BYTE_LITERALS:
				case S_8BYTE_LITERALS:
				case S_16BYTE_LITERALS:
					return "__const";
			}
		}
	}
	
	if ( strlen(fSection->sectname()) > 15 ) {
		static char temp[18];
		strncpy(temp, fSection->sectname(), 16);
		temp[17] = '\0';
		return temp;
	}
	return fSection->sectname();
}

template <typename A>
ObjectFile::Atom& SymbolAtom<A>::getFollowOnAtom() const
{
	for (ReferenceVectorConstIterator it=fReferences.begin(); it != fReferences.end(); it++) {
		Reference<A>* ref = *it;
		if ( ref->getKind() == A::kFollowOn )
			return ref->getTarget();
	}
	return *((ObjectFile::Atom*)NULL);
}


class Beyond
{
public:
	Beyond(uint64_t offset) : fOffset(offset) {}
	bool operator()(ObjectFile::Reference* ref) const {
		return ( ref->getFixUpOffset() >= fOffset );
	}
private:
	uint64_t fOffset;
};


template <typename A>
void SymbolAtom<A>::setSize(uint64_t size)
{
	// when resizing, any references beyond the new size are tossed
	if ( (fSize != 0) && (fReferences.size() > 0) ) 
		fReferences.erase(std::remove_if(fReferences.begin(), fReferences.end(), Beyond(size)), fReferences.end());
	// set new size
	fSize = size;
}

template <typename A>
void SymbolAtom<A>::copyRawContent(uint8_t buffer[]) const
{
	// copy base bytes
	if ( isZeroFill() )
		bzero(buffer, fSize);
	else {
		uint32_t fileOffset = fSection->offset() - fSection->addr() + fAddress;
		memcpy(buffer, (char*)(fOwner.fHeader)+fileOffset, fSize);
	}
}




//
// A SymbolAliasAtom represents an alternate name for a SymbolAtom
//
//
template <typename A>
class SymbolAliasAtom : public BaseAtom
{
public:
	virtual ObjectFile::Reader*					getFile() const					{ return fAliasOf.getFile(); }
	virtual bool								getTranslationUnitSource(const char** dir, const char** name) const
																				{ return fAliasOf.getTranslationUnitSource(dir, name); }
	virtual const char*							getName() const					{ return fName; }
	virtual const char*							getDisplayName() const			{ return fName; }
	virtual ObjectFile::Atom::Scope				getScope() const				{ return fScope; }
	virtual ObjectFile::Atom::DefinitionKind	getDefinitionKind() const		{ return fAliasOf.getDefinitionKind(); }
	virtual SymbolTableInclusion				getSymbolTableInclusion() const	{ return fAliasOf.getSymbolTableInclusion(); }
	virtual	bool								dontDeadStrip() const			{ return fDontDeadStrip; }
	virtual bool								isZeroFill() const				{ return fAliasOf.isZeroFill(); }
	virtual bool								isThumb() const					{ return fAliasOf.isThumb(); }
	virtual uint64_t							getSize() const					{ return 0; }
	virtual std::vector<ObjectFile::Reference*>&  getReferences() const			{ return (std::vector<ObjectFile::Reference*>&)(fReferences); }
	virtual bool								mustRemainInSection() const		{ return true; }
	virtual const char*							getSectionName() const			{ return fAliasOf.getSectionName(); }
	virtual Segment<A>&							getSegment() const				{ return (Segment<A>&)fAliasOf.getSegment(); }
	virtual ObjectFile::Atom&					getFollowOnAtom() const			{ return (ObjectFile::Atom&)fAliasOf; }
	virtual std::vector<ObjectFile::LineInfo>*	getLineInfo() const				{ return NULL; }
	virtual ObjectFile::Alignment				getAlignment() const			{ return  fAliasOf.getAlignment(); }
	virtual void								copyRawContent(uint8_t buffer[]) const {}
	virtual void								setScope(ObjectFile::Atom::Scope newScope)		{ fScope = newScope; }
	virtual void								setSize(uint64_t size)			{  }
	virtual void								addReference(ObjectFile::Reference* ref) { fReferences.push_back((Reference<A>*)ref); }
	virtual void								sortReferences() { std::sort(fReferences.begin(), fReferences.end(), ReferenceSorter()); }
	virtual void								addLineInfo(const  ObjectFile::LineInfo& info)	{  }
	virtual const ObjectFile::ReaderOptions&	getOptions() const				{ return fAliasOf.getOptions(); }
	virtual uint64_t							getObjectAddress() const		{ return fAliasOf.getObjectAddress(); }
	virtual const void*							getSectionRecord() const		{ return fAliasOf.getSectionRecord(); }
	virtual bool								isAlias() const					{ return true; }

protected:
	typedef typename A::P						P;
	typedef typename std::vector<Reference<A>*>			ReferenceVector;
	typedef typename ReferenceVector::iterator			ReferenceVectorIterator;		// seems to help C++ parser
	typedef typename ReferenceVector::const_iterator	ReferenceVectorConstIterator;	// seems to help C++ parser
	friend class Reader<A>;

											SymbolAliasAtom(const char* name, const macho_nlist<P>*, const BaseAtom& );
	virtual									~SymbolAliasAtom() {}

	const char*									fName;
	const BaseAtom&								fAliasOf;
	ObjectFile::Atom::Scope						fScope;
	bool										fDontDeadStrip;
	ReferenceVector								fReferences;
};


template <typename A>
SymbolAliasAtom<A>::SymbolAliasAtom(const char* name, const macho_nlist<P>* symbol, const BaseAtom& aliasOf)
 : fName(name), fAliasOf(aliasOf)
{
	//fprintf(stderr, "SymbolAliasAtom(%p) %s\n", this, name);
	if ( symbol != NULL ) {
		uint8_t type =  symbol->n_type();
		if ( (type & N_EXT) == 0 )
			fScope = ObjectFile::Atom::scopeTranslationUnit;
		else if ( (type & N_PEXT) != 0 )
			fScope = ObjectFile::Atom::scopeLinkageUnit;
		else
			fScope = ObjectFile::Atom::scopeGlobal;
		fDontDeadStrip = ((symbol->n_desc() & (N_NO_DEAD_STRIP|REFERENCED_DYNAMICALLY)) != 0);
	}
	else {
		// aliases defined on the command line are initially global scope
		fScope = ObjectFile::Atom::scopeGlobal;
		fDontDeadStrip = false;
	}
	// add follow-on reference to real atom	
	new Reference<A>(A::kFollowOn, AtomAndOffset(this), AtomAndOffset((ObjectFile::Atom*)&aliasOf));
}


//
// A TentativeAtom represents a C "common" or "tentative" defintion of data.
// For instance, "int foo;" is neither a declaration or a definition and
// is represented by a TentativeAtom.
//
template <typename A>
class TentativeAtom : public BaseAtom
{
public:
	virtual ObjectFile::Reader*					getFile() const					{ return &fOwner; }
	virtual bool								getTranslationUnitSource(const char** dir, const char** name) const
																				{ return fOwner.getTranslationUnitSource(dir, name); }
	virtual const char*							getName() const					{ return &fOwner.fStrings[fSymbol->n_strx()]; }
	virtual const char*							getDisplayName() const			{ return getName(); }
	virtual ObjectFile::Atom::Scope				getScope() const				{ return fScope; }
	virtual ObjectFile::Atom::DefinitionKind	getDefinitionKind() const		{ return ObjectFile::Atom::kTentativeDefinition; }
	virtual bool								isZeroFill() const				{ return true; }
	virtual bool								isThumb() const					{ return false; }
	virtual SymbolTableInclusion				getSymbolTableInclusion() const	{ return ((fSymbol->n_desc() & REFERENCED_DYNAMICALLY) != 0)
																						? ObjectFile::Atom::kSymbolTableInAndNeverStrip : ObjectFile::Atom::kSymbolTableIn; }
	virtual	bool								dontDeadStrip() const			{ return ((fSymbol->n_desc() & (N_NO_DEAD_STRIP|REFERENCED_DYNAMICALLY)) != 0); }
	virtual uint64_t							getSize() const					{ return fSymbol->n_value(); }
	virtual std::vector<ObjectFile::Reference*>&  getReferences() const			{ return fgNoReferences; }
	virtual bool								mustRemainInSection() const		{ return true; }
	virtual const char*							getSectionName() const;
	virtual ObjectFile::Segment&				getSegment() const				{ return DataSegment::fgSingleton; }
	virtual ObjectFile::Atom&					getFollowOnAtom() const			{ return *(ObjectFile::Atom*)NULL; }
	virtual std::vector<ObjectFile::LineInfo>*	getLineInfo() const				{ return NULL; }
	virtual ObjectFile::Alignment				getAlignment() const;
	virtual void								copyRawContent(uint8_t buffer[]) const;
	virtual void								setScope(ObjectFile::Atom::Scope newScope)		{ fScope = newScope; }
	virtual void								setSize(uint64_t size)			{ }
	virtual void								addReference(ObjectFile::Reference* ref) { throw "ld: can't add references"; }
	virtual void								sortReferences() { }
	virtual void								addLineInfo(const  ObjectFile::LineInfo& info)	{ throw "ld: can't add line info to tentative definition"; }
	virtual const ObjectFile::ReaderOptions&	getOptions() const				{ return fOwner.fOptions; }
	virtual uint64_t							getObjectAddress() const		{ return ULLONG_MAX; }
	virtual const void*							getSectionRecord() const		{ return NULL; }

protected:
	typedef typename A::P					P;
	typedef typename A::P::E				E;
	typedef typename A::P::uint_t			pint_t;
	typedef typename A::ReferenceKinds		Kinds;
	friend class Reader<A>;

											TentativeAtom(Reader<A>&, const macho_nlist<P>*);
	virtual									~TentativeAtom() {}

	Reader<A>&									fOwner;
	const macho_nlist<P>*						fSymbol;
	ObjectFile::Atom::Scope						fScope;
	static std::vector<ObjectFile::Reference*>	fgNoReferences;
};

template <typename A>
std::vector<ObjectFile::Reference*> TentativeAtom<A>::fgNoReferences;

template <typename A>
TentativeAtom<A>::TentativeAtom(Reader<A>& owner, const macho_nlist<P>* symbol)
 : fOwner(owner), fSymbol(symbol)
{
	uint8_t type =  symbol->n_type();
	if ( (type & N_EXT) == 0 )
		fScope = ObjectFile::Atom::scopeTranslationUnit;
	else if ( (type & N_PEXT) != 0 )
		fScope = ObjectFile::Atom::scopeLinkageUnit;
	else
		fScope = ObjectFile::Atom::scopeGlobal;
	if ( ((type & N_TYPE) == N_UNDF) && (symbol->n_value() != 0) ) {
		// tentative definition
	}
	else {
		warning("unknown symbol type: %d", type);
	}
	//fprintf(stderr, "TentativeAtom(%p) %s\n", this, this->getDisplayName());
}


template <typename A>
ObjectFile::Alignment TentativeAtom<A>::getAlignment() const
{
	uint8_t alignment = GET_COMM_ALIGN(fSymbol->n_desc());
	if ( alignment == 0 ) {
		// common symbols align to their size
		// that is, a 4-byte common aligns to 4-bytes
		// if this size is not a power of two, 
		// then round up to the next power of two
		uint64_t size = this->getSize();
		alignment = 63 - (uint8_t)__builtin_clzll(size);
		if ( size != (1ULL << alignment) )
			++alignment;
	}
	// limit alignment of extremely large commons to 2^15 bytes (8-page)
	if ( alignment < 12 )
		return ObjectFile::Alignment(alignment);
	else
		return ObjectFile::Alignment(12);
}

template <typename A>
const char* TentativeAtom<A>::getSectionName() const
{
	if ( fOwner.fOptions.fForFinalLinkedImage || fOwner.fOptions.fMakeTentativeDefinitionsReal )
		return "__common"; 
	else
		return "._tentdef"; 
}


template <typename A>
void TentativeAtom<A>::copyRawContent(uint8_t buffer[]) const
{
	bzero(buffer, getSize());
}


//
// An AnonymousAtom represents compiler generated data that has no name.
// For instance, a literal C-string or a 64-bit floating point constant
// is represented by an AnonymousAtom.
//
template <typename A>
class AnonymousAtom : public BaseAtom
{
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 fSynthesizedName; }
	virtual const char*							getDisplayName() const;
	virtual ObjectFile::Atom::Scope				getScope() const;
	virtual ObjectFile::Atom::DefinitionKind	getDefinitionKind() const       { return fKind; }
	virtual ObjectFile::Atom::ContentType		getContentType() const			{ return fType; }
	virtual ObjectFile::Atom::SymbolTableInclusion getSymbolTableInclusion() const	{ return fSymbolTableInclusion; }
	virtual	bool								dontDeadStrip() const			{ return fDontDeadStrip; }
	virtual bool								isZeroFill() const;
	virtual bool								isThumb() const					{ return false; }
	virtual uint64_t							getSize() const					{ return fSize; }
	virtual std::vector<ObjectFile::Reference*>&  getReferences() const			{ return (std::vector<ObjectFile::Reference*>&)(fReferences); }
	virtual bool								mustRemainInSection() const		{ return true; }
	virtual const char*							getSectionName() const;
	virtual Segment<A>&							getSegment() const				{ return *fSegment; }
	virtual ObjectFile::Atom&					getFollowOnAtom() const;
	virtual std::vector<ObjectFile::LineInfo>*	getLineInfo() const				{ return NULL; }
	virtual ObjectFile::Alignment				getAlignment() const;
	virtual void								copyRawContent(uint8_t buffer[]) const;
	virtual void								setScope(ObjectFile::Atom::Scope newScope)	{ fScope = newScope; }
	virtual void								setSize(uint64_t size)			{ fSize = size; }
	virtual void								addReference(ObjectFile::Reference* ref) { fReferences.push_back((Reference<A>*)ref); }
	virtual void								sortReferences() { std::sort(fReferences.begin(), fReferences.end(), ReferenceSorter()); }
	virtual void								addLineInfo(const  ObjectFile::LineInfo& info);
	virtual const ObjectFile::ReaderOptions&	getOptions() const				{ return fOwner.fOptions; }
	virtual uint64_t							getObjectAddress() const		{ return fAddress; }
	virtual const void*							getSectionRecord() const		{ return (const void*)fSection; }
	BaseAtom*									redirectTo()					{ return fRedirect; }
	bool										isWeakImportStub()				{ return fWeakImportStub; }
	void										resolveName();
	virtual uint8_t								getLSDAReferenceKind() const;
	virtual uint8_t								getPersonalityReferenceKind() const;
	virtual uint32_t							getCompactUnwindEncoding(uint64_t ehAtomAddress);
	
protected:
	typedef typename A::P						P;
	typedef typename A::P::E					E;
	typedef typename A::P::uint_t				pint_t;
	typedef typename A::ReferenceKinds			Kinds;
	typedef typename std::vector<Reference<A>*>			ReferenceVector;
	typedef typename ReferenceVector::iterator			ReferenceVectorIterator;		// seems to help C++ parser
	typedef typename ReferenceVector::const_iterator	ReferenceVectorConstIterator;	// seems to help C++ parser
	friend class Reader<A>;

											AnonymousAtom(Reader<A>&, const macho_section<P>*, pint_t addr, pint_t size);
	virtual									~AnonymousAtom() {}
	static bool									cstringsHaveLabels();

	Reader<A>&									fOwner;
	const char*									fSynthesizedName;
	const char*									fDisplayName;
	const macho_section<P>*						fSection;
	pint_t										fAddress;
	pint_t										fSize;
	Segment<A>*									fSegment;
	ReferenceVector								fReferences;
	BaseAtom*									fRedirect;
	bool										fDontDeadStrip;
	bool										fWeakImportStub;
	ObjectFile::Atom::SymbolTableInclusion		fSymbolTableInclusion;
	ObjectFile::Atom::Scope						fScope;
    ObjectFile::Atom::DefinitionKind            fKind;
	ObjectFile::Atom::ContentType				fType;
};

template <typename A>
AnonymousAtom<A>::AnonymousAtom(Reader<A>& owner, const macho_section<P>* section, pint_t addr, pint_t size)
 : fOwner(owner), fSynthesizedName(NULL), fDisplayName(NULL), fSection(section), fAddress(addr), fSize(size), 
	fSegment(NULL), fDontDeadStrip(true), fWeakImportStub(false), fSymbolTableInclusion(ObjectFile::Atom::kSymbolTableNotIn),
	fScope(ObjectFile::Atom::scopeTranslationUnit), fKind(ObjectFile::Atom::kRegularDefinition), 
	fType(ObjectFile::Atom::kUnclassifiedType)
{
	fSegment = new Segment<A>(fSection);
	fRedirect = this;
	uint8_t type = fSection->flags() & SECTION_TYPE;
	//fprintf(stderr, "AnonymousAtom(%p) addr=0x%llX in %s from %s\n", this, (long long)addr, section->sectname(), owner.getPath());
	switch ( type ) {
		case S_ZEROFILL:
			{
				asprintf((char**)&fSynthesizedName, "zero-fill-at-0x%08X", addr);
			}
			break;
		case S_COALESCED:
		case S_REGULAR:
			if ( section == owner.fehFrameSection ) {
				if ( fSize == 1 ) {
					// is CIE
					fSize = 0;
					fDontDeadStrip = false;
					if ( fOwner.fOptions.fForFinalLinkedImage ) 
						fSynthesizedName = "CIE";
					else
						fSynthesizedName = "EH_frame1";
				}
				else {
					// is FDE
					fSynthesizedName = ".eh_PENDING";
					fDontDeadStrip = false;
					owner.fAtomsPendingAName.push_back(this);
				}
				fType = ObjectFile::Atom::kCFIType;
				// FDEs and CIEs don't need to be in symbol table of final linked images <rdar://problem/4180168>
				if ( !fOwner.fOptions.fNoEHLabels ) 
					fSymbolTableInclusion = ObjectFile::Atom::kSymbolTableIn;
			}
			else if ( (strcmp(section->sectname(), "__class") == 0) && (strcmp(section->segname(), "__OBJC") == 0) && owner.fAppleObjc ) {
				// special case ObjC classes to synthesize .objc_class_name_* symbols, for Apple runtime only
				fSynthesizedName = ".objc_class_name_PENDING";
				owner.fAtomsPendingAName.push_back(this);
				owner.fSectionsWithAtomsPendingAName.insert(fSection);
				if ( fOwner.fOptions.fForFinalLinkedImage ) 
					fSymbolTableInclusion = ObjectFile::Atom::kSymbolTableIn;
				else
					fSymbolTableInclusion = ObjectFile::Atom::kSymbolTableInAsAbsolute;
				fScope = ObjectFile::Atom::scopeGlobal;
			}
			else if ( strcmp(fSection->sectname(), "__cstring") == 0 ) {
				// handle .o files created by old ld64 -r that are missing cstring section type
				const char* str = (char*)(owner.fHeader) + section->offset() + addr - section->addr();
				asprintf((char**)&fSynthesizedName, "cstring=%s", str);
			}
			else if ((strcmp(section->sectname(), "__cfstring") == 0) && (strcmp(section->segname(), "__DATA") == 0)) {
				fSynthesizedName = "cfstring-pointer-name-PENDING";
				fScope = ObjectFile::Atom::scopeLinkageUnit;
				owner.fAtomsPendingAName.push_back(this);
				owner.fSectionsWithAtomsPendingAName.insert(fSection);
				fDontDeadStrip = false;
				fKind = ObjectFile::Atom::kWeakDefinition;
			}
			else if ( (fSection->flags() & S_ATTR_SOME_INSTRUCTIONS) != 0 ) {
				fDontDeadStrip = false;
				asprintf((char**)&fSynthesizedName, "anon-func-0x%X", addr);
			}
			else if ( strncmp(fSection->sectname(), "__gcc_except_tab",16) == 0 ) {
				fType = ObjectFile::Atom::kLSDAType;
				fDontDeadStrip = false;
				fSynthesizedName = ".lsda_PENDING";
				owner.fAtomsPendingAName.push_back(this);
				if ( !fOwner.fOptions.fNoEHLabels ) 
					fSymbolTableInclusion = ObjectFile::Atom::kSymbolTableIn;
			}
			break;
		case S_CSTRING_LITERALS:
			{
				const char* str = (char*)(owner.fHeader) + section->offset() + addr - section->addr();
				if ( (strcmp(fSection->sectname(), "__cstring") == 0) && (strcmp(section->segname(), "__TEXT") == 0) ) 
					asprintf((char**)&fSynthesizedName, "cstring=%s", str);
				else
					asprintf((char**)&fSynthesizedName, "cstring%s%s=%s", fSection->segname(), fSection->sectname(), str);
				fScope = ObjectFile::Atom::scopeLinkageUnit;
				fKind = ObjectFile::Atom::kWeakDefinition;
				fType = ObjectFile::Atom::kCStringType;
				fDontDeadStrip = false;
				if ( !fOwner.fOptions.fForFinalLinkedImage && cstringsHaveLabels() ) 
					fSymbolTableInclusion = ObjectFile::Atom::kSymbolTableIn;
			}
			break;
		case S_4BYTE_LITERALS:
			{
				uint32_t value =  E::get32(*(uint32_t*)(((uint8_t*)owner.fHeader) + section->offset() + addr - section->addr()));
				asprintf((char**)&fSynthesizedName, "4-byte-literal=0x%08X", value);
				fScope = ObjectFile::Atom::scopeLinkageUnit;
				fKind = ObjectFile::Atom::kWeakDefinition;
				fDontDeadStrip = false;
			}
			break;
		case S_8BYTE_LITERALS:
			{
				uint64_t value =  E::get64(*(uint64_t*)(((uint8_t*)owner.fHeader) + section->offset() + addr - section->addr()));
				asprintf((char**)&fSynthesizedName, "8-byte-literal=0x%016llX", value);
				fScope = ObjectFile::Atom::scopeLinkageUnit;
				fKind = ObjectFile::Atom::kWeakDefinition;
				fDontDeadStrip = false;
			}
			break;
		case S_16BYTE_LITERALS:
			{
				uint64_t value1 =  E::get64(*(uint64_t*)(((uint8_t*)owner.fHeader) + section->offset() + addr - section->addr()));
				uint64_t value2 =  E::get64(*(uint64_t*)(((uint8_t*)owner.fHeader) + section->offset() + addr + 8 - section->addr()));
				asprintf((char**)&fSynthesizedName, "16-byte-literal=0x%016llX,%016llX", value1, value2);
				fScope = ObjectFile::Atom::scopeLinkageUnit;
				fKind = ObjectFile::Atom::kWeakDefinition;
				fDontDeadStrip = false;
			}
			break;
		case S_LITERAL_POINTERS:
			{
				//uint32_t literalNameAddr =  P::getP(*(pint_t*)(((uint8_t*)owner.fHeader) + section->offset() + addr - section->addr()));
				//const char* str = (char*)(owner.fHeader) + section->offset() + literalNameAddr - section->addr();
				//asprintf((char**)&fSynthesizedName, "literal-pointer@%s@%s@%s", section->segname(), section->sectname(), str);
				fSynthesizedName = "literal-pointer-name-PENDING";
				fScope = ObjectFile::Atom::scopeLinkageUnit;
				fKind = ObjectFile::Atom::kWeakDefinition;
				fDontDeadStrip = false;
				owner.fAtomsPendingAName.push_back(this);
				owner.fSectionsWithAtomsPendingAName.insert(fSection);
			}
			break;
		case S_MOD_INIT_FUNC_POINTERS:
				asprintf((char**)&fSynthesizedName, "initializer$%d", (addr - (uint32_t)fSection->addr())/sizeof(pint_t));
				break;
		case S_MOD_TERM_FUNC_POINTERS:
				asprintf((char**)&fSynthesizedName, "terminator$%d", (addr - (uint32_t)fSection->addr())/sizeof(pint_t));
				break;
		case S_SYMBOL_STUBS:
			{
				uint32_t index = (fAddress - fSection->addr()) / fSection->reserved2();
				index += fSection->reserved1();
				uint32_t symbolIndex = E::get32(fOwner.fIndirectTable[index]);
				const macho_nlist<P>* sym = &fOwner.fSymbols[symbolIndex];
				uint32_t strOffset = sym->n_strx();
				// want name to not have $stub suffix, this is what automatic stub generation expects
				fSynthesizedName = &fOwner.fStrings[strOffset];
				// check for weak import
				fWeakImportStub = fOwner.isWeakImportSymbol(sym);
				// sometimes the compiler gets confused and generates a stub to a static function
				// if so, we should redirect any call to the stub to be calls to the real static function atom
				if ( ((sym->n_type() & N_TYPE) != N_UNDF) && ((sym->n_type() & N_EXT) == 0) ) {
					BaseAtom* staticAtom = fOwner.findAtomByName(fSynthesizedName);
					if ( staticAtom != NULL ) 
						fRedirect = staticAtom;
				}
				fKind = ObjectFile::Atom::kWeakDefinition;
				// might be a spurious stub for a static function, make stub static too
				if ( (sym->n_type() & N_EXT) == 0 ) 
					fScope = ObjectFile::Atom::scopeTranslationUnit;
				else
					fScope = ObjectFile::Atom::scopeLinkageUnit;
			}
			break;
		case S_LAZY_SYMBOL_POINTERS:
		case S_NON_LAZY_SYMBOL_POINTERS:
			{
				// transform i386 __IMPORT/__pointers to __DATA/__nl_symbol_ptr when 
				// generating the new compressed LINKEDIT format
				if ( (type == S_NON_LAZY_SYMBOL_POINTERS) && fOwner.fOptions.fMakeCompressedDyldInfo && (strcmp(fSection->segname(),"__IMPORT") == 0) ) {
					macho_section<P>* dummySection = new macho_section<P>(*fSection);
					dummySection->set_segname("__DATA");
					dummySection->set_sectname("__nl_symbol_ptr");
					fSection = dummySection;
					fSegment = new Segment<A>(fSection);
				}
				
				fDontDeadStrip = false;
				fScope = ObjectFile::Atom::scopeLinkageUnit;
				uint32_t index = (fAddress - fSection->addr()) / sizeof(pint_t);
				index += fSection->reserved1();
				uint32_t symbolIndex = E::get32(fOwner.fIndirectTable[index]);
				if ( symbolIndex == INDIRECT_SYMBOL_LOCAL ) {
					// Silly codegen with non-lazy pointer to a local symbol
					uint32_t fileOffset = fSection->offset() - fSection->addr() + fAddress;
					pint_t nonLazyPtrValue = P::getP(*((pint_t*)((char*)(fOwner.fHeader)+fileOffset)));
					// All atoms not created yet, so we need to scan symbol table
					const macho_nlist<P>* closestSym = NULL; 
					const macho_nlist<P>* end = &fOwner.fSymbols[fOwner.fSymbolCount];
					for (const macho_nlist<P>* sym =  fOwner.fSymbols; sym < end; ++sym) {
						if ( ((sym->n_type() & N_TYPE) == N_SECT) 
						 && ((sym->n_type() & N_STAB) == 0) ) {
							if ( sym->n_value() == nonLazyPtrValue ) {
								const char* name = &fOwner.fStrings[sym->n_strx()];
								char* str = new char[strlen(name)+16];
								strcpy(str, name);
								strcat(str, "$non_lazy_ptr");
								fSynthesizedName = str;
								// add direct reference to target later, because its atom may not be constructed yet
								fOwner.fLocalNonLazys.push_back(this);
								fScope = ObjectFile::Atom::scopeTranslationUnit;
								return;
							}
							else if ( (sym->n_value() < nonLazyPtrValue) && ((closestSym == NULL) || (sym->n_value() > closestSym->n_value())) ) {
								closestSym = sym;
							}
						}
					}
					// add direct reference to target later, because its atom may not be constructed yet
					if ( closestSym != NULL ) {
						const char* name = &fOwner.fStrings[closestSym->n_strx()];
						char* str;
						asprintf(&str, "%s+%u$non_lazy_ptr", name, nonLazyPtrValue - closestSym->n_value());
						fSynthesizedName = str;
					}
					else {
						fSynthesizedName = "$interior$non_lazy_ptr";
					}
					fScope = ObjectFile::Atom::scopeTranslationUnit;
					fOwner.fLocalNonLazys.push_back(this);
					return;
				}
				const macho_nlist<P>* targetSymbol = &fOwner.fSymbols[symbolIndex];
				const char* name = &fOwner.fStrings[targetSymbol->n_strx()];
				char* str = new char[strlen(name)+16];
				strcpy(str, name);
				if ( type == S_LAZY_SYMBOL_POINTERS )
					strcat(str, "$lazy_ptr");
				else
					strcat(str, "$non_lazy_ptr");
				fSynthesizedName = str;

				if ( type == S_NON_LAZY_SYMBOL_POINTERS )
					fKind = ObjectFile::Atom::kWeakDefinition;

				if ( (targetSymbol->n_type() & N_EXT) == 0 ) {
					// target is translation unit scoped, so add direct reference to target
					//fOwner.makeReference(A::kPointer, addr, targetSymbol->n_value());
					new Reference<A>(A::kPointer, AtomAndOffset(this), fOwner.findAtomAndOffset(targetSymbol->n_value()));
				}
				else {	
					if ( fOwner.isWeakImportSymbol(targetSymbol) )
						new Reference<A>(A::kPointerWeakImport, AtomAndOffset(this), name, 0);
					else
						new Reference<A>(A::kPointer, AtomAndOffset(this), name, 0);
				}
			}
			break;
		default:
			throwf("section type %d not supported with address=0x%08X", type, addr);
	}
	//fprintf(stderr, "AnonymousAtom(%p) %s \n", this, this->getDisplayName());
}

// x86_64 uses L labels on cstrings to allow relocs with addends
template <> bool AnonymousAtom<x86_64>::cstringsHaveLabels() { return true; }
template <typename A> bool AnonymousAtom<A>::cstringsHaveLabels() { return false; }

template <typename A>
void AnonymousAtom<A>::addLineInfo(const ObjectFile::LineInfo& info) 
{ 
	// <rdar://problem/6545406> don't warn if line table has entries for stubs
	if ( (fSection->flags() & SECTION_TYPE) != S_SYMBOL_STUBS )
		warning("can't add line info to anonymous symbol %s from %s", this->getDisplayName(), this->getFile()->getPath()); 
}

template <typename A>
void AnonymousAtom<A>::resolveName()
{
	if ( (strcmp(fSection->sectname(), "__class") == 0) && (strcmp(fSection->segname(), "__OBJC") == 0) ) {
		std::vector<ObjectFile::Reference*>&  references = this->getReferences();
		// references are not yet sorted, so scan the vector
		for (std::vector<ObjectFile::Reference*>::iterator rit=references.begin(); rit != references.end(); rit++) {
			if ( ((*rit)->getFixUpOffset() == sizeof(pint_t)) && ((*rit)->getKind() == A::kPointer) ) {
				const char* superStr = (*rit)->getTargetName();
				if ( strncmp(superStr, "cstring", 7) == 0 ) {
					const char* superClassName;
					asprintf((char**)&superClassName, ".objc_class_name_%s", &superStr[8]);
					new Reference<A>(A::kNoFixUp, AtomAndOffset(this), superClassName, 0);
				}
				break;
			}
		}
		for (std::vector<ObjectFile::Reference*>::iterator rit=references.begin(); rit != references.end(); rit++) {
			if ( ((*rit)->getFixUpOffset() == 2*sizeof(pint_t)) && ((*rit)->getKind() == A::kPointer) ) {
				const char* classStr = (*rit)->getTargetName();
				if ( strncmp(classStr, "cstring", 7) == 0 ) {
					asprintf((char**)&fSynthesizedName, ".objc_class_name_%s", &classStr[8]);
				}
				break;
			}
		}
	}
	else if ( (fSection->flags() & SECTION_TYPE) == S_LITERAL_POINTERS) {
		std::vector<ObjectFile::Reference*>&  references = this->getReferences();
		if ( references.size() < 1 )
			throwf("S_LITERAL_POINTERS section %s,%s missing relocs", fSection->segname(), fSection->sectname());
		ObjectFile::Reference* ref = references[0];
		const char* str = ref->getTargetName();
		if ( strncmp(str, "cstring", 7) == 0 ) {
			asprintf((char**)&fSynthesizedName, "literal-pointer@%s@%s@%s", fSection->segname(), fSection->sectname(), &str[8]);
		}
	}
	else if ( (strcmp(fSection->sectname(), "__cfstring") == 0) && (strcmp(fSection->segname(), "__DATA") == 0) ) {
		// references are not yet sorted, so scan the vector
		std::vector<ObjectFile::Reference*>&  references = this->getReferences();
		for (std::vector<ObjectFile::Reference*>::iterator rit=references.begin(); rit != references.end(); rit++) {
			if ( ((*rit)->getFixUpOffset() == 2*sizeof(pint_t)) && ((*rit)->getKind() == A::kPointer) ) {
				const char* superStr = (*rit)->getTargetName();
				if ( (superStr != NULL) && (strncmp(superStr, "cstring=", 8) == 0) ) {
					asprintf((char**)&fSynthesizedName, "cfstring=%s", &superStr[8]);
				}
				else {
					// compiled with -fwritable-strings or a non-ASCII string 
					fKind = ObjectFile::Atom::kRegularDefinition; // these are not coalescable
					fScope = ObjectFile::Atom::scopeTranslationUnit;
					fSynthesizedName = "cfstring-not-coalesable";
					if ( (*rit)->getTargetOffset() != 0 )
						warning("-fwritable-strings not compatible with literal CF/NSString in %s", fOwner.getPath());
				}
				break;
			}
		}
	}
	else if ( fSection == fOwner.fehFrameSection ) {
		// give name to FDE
		ObjectFile::Atom* funcAtom = fOwner.getFunctionAtomFromFDEAddress(fAddress);
		if ( funcAtom != NULL )
			asprintf((char**)&fSynthesizedName, "%s.eh", funcAtom->getDisplayName());
	}
	else if ( fOwner.fLSDAAtoms.count(this) != 0) {
		// give name to LSDA
		ObjectFile::Atom* funcAtom = fOwner.getFunctionAtomFromLSDAAddress(fAddress);
		if ( funcAtom != NULL )
			asprintf((char**)&fSynthesizedName, "%s.lsda", funcAtom->getDisplayName());
	}
}


template <typename A>
const char* AnonymousAtom<A>::getDisplayName() const
{
	if ( fSynthesizedName != NULL )
		return fSynthesizedName;

	if ( fDisplayName != NULL )
		return fDisplayName;

	if ( (fSection->flags() & SECTION_TYPE) == S_CSTRING_LITERALS ) {
		uint32_t fileOffset = fSection->offset() - fSection->addr() + fAddress;
		asprintf((char**)&fDisplayName, "atom string literal: \"%s\"", (char*)(fOwner.fHeader)+fileOffset);
	}
	else {
		asprintf((char**)&fDisplayName, "%s@%d", fSection->sectname(), fAddress - (uint32_t)fSection->addr() );
	}
	return fDisplayName;
}


template <typename A>
ObjectFile::Atom::Scope AnonymousAtom<A>::getScope() const
{
	return fScope;
}


template <typename A>
bool AnonymousAtom<A>::isZeroFill() const
{
	return ( (fSection->flags() & SECTION_TYPE) == S_ZEROFILL );
}


template <typename A>
const char*	AnonymousAtom<A>::getSectionName() const
{
	if ( fOwner.fOptions.fForFinalLinkedImage ) {
		switch ( fSection->flags() & SECTION_TYPE ) {
			case S_4BYTE_LITERALS:
			case S_8BYTE_LITERALS:
			case S_16BYTE_LITERALS:
				return "__const";
		}
	}
	
	if ( strlen(fSection->sectname()) > 15 ) {
		static char temp[18];
		strncpy(temp, fSection->sectname(), 16);
		temp[17] = '\0';
		return temp;
	}
	return fSection->sectname();
}

template <typename A>
ObjectFile::Alignment AnonymousAtom<A>::getAlignment() const
{
	// FDEs and CIEs are always packed together in a final linked image, so ignore section alignment
	if ( fType == ObjectFile::Atom::kCFIType )
		return ObjectFile::Alignment(0);
		
	switch ( fSection->flags() & SECTION_TYPE ) {
		case S_4BYTE_LITERALS:
			return ObjectFile::Alignment(2);
		case S_8BYTE_LITERALS:
			return ObjectFile::Alignment(3);
		case S_16BYTE_LITERALS:
			return ObjectFile::Alignment(4);
		case S_NON_LAZY_SYMBOL_POINTERS:
			return ObjectFile::Alignment((uint8_t)log2(sizeof(pint_t)));
		case S_CSTRING_LITERALS:
			if ( ! fOwner.fOptions.fForFinalLinkedImage )
				return ObjectFile::Alignment(fSection->align());
		default:
			return ObjectFile::Alignment(fSection->align(), fAddress % (1 << fSection->align()));
	}
}


template <typename A>
ObjectFile::Atom& AnonymousAtom<A>::getFollowOnAtom() const
{
	for (ReferenceVectorConstIterator it=fReferences.begin(); it != fReferences.end(); it++) {
		Reference<A>* ref = *it;
		if ( ref->getKind() == A::kFollowOn )
			return ref->getTarget();
	}
	return *((ObjectFile::Atom*)NULL);
}

template <typename A>
void AnonymousAtom<A>::copyRawContent(uint8_t buffer[]) const
{
	// copy base bytes
	if ( isZeroFill() )
		bzero(buffer, fSize);
	else {
		uint32_t fileOffset = fSection->offset() - fSection->addr() + fAddress;
		memcpy(buffer, (char*)(fOwner.fHeader)+fileOffset, fSize);
	}
}

//
// An AbsoluteAtom represents an N_ABS symbol which can only be created in 
// assembly language and usable by static executables such as the kernel/
//
template <typename A>
class AbsoluteAtom : public BaseAtom
{
public:
	virtual ObjectFile::Reader*					getFile() const					{ return &fOwner; }
	virtual bool								getTranslationUnitSource(const char** dir, const char** name) const
																				{ return fOwner.getTranslationUnitSource(dir, name); }
	virtual const char*							getName() const					{ return &fOwner.fStrings[fSymbol->n_strx()]; }
	virtual const char*							getDisplayName() const			{ return getName(); }
	virtual ObjectFile::Atom::Scope				getScope() const				{ return fScope; }
	virtual ObjectFile::Atom::DefinitionKind	getDefinitionKind() const		{ return ObjectFile::Atom::kAbsoluteSymbol; }
	virtual bool								isZeroFill() const				{ return false; }
	virtual bool								isThumb() const					{ return ((fSymbol->n_desc() & N_ARM_THUMB_DEF) != 0); }
	virtual SymbolTableInclusion				getSymbolTableInclusion() const	{ return ObjectFile::Atom::kSymbolTableInAsAbsolute; }
	virtual	bool								dontDeadStrip() const			{ return false; }
	virtual uint64_t							getSize() const					{ return 0; }
	virtual std::vector<ObjectFile::Reference*>&  getReferences() const			{ return fgNoReferences; }
	virtual bool								mustRemainInSection() const		{ return true; }
	virtual const char*							getSectionName() const			{ return "._absolute"; } 
	virtual ObjectFile::Segment&				getSegment() const				{ return LinkEditSegment::fgSingleton; }
	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(ObjectFile::Atom::Scope newScope)		{ fScope = newScope; }
	virtual void								setSize(uint64_t size)			{ }
	virtual void								addReference(ObjectFile::Reference* ref) { throw "ld: can't add references"; }
	virtual void								sortReferences()				{ }
	virtual void								addLineInfo(const  ObjectFile::LineInfo& info)	{ throw "ld: can't add line info to tentative definition"; }
	virtual const ObjectFile::ReaderOptions&	getOptions() const				{ return fOwner.fOptions; }
	virtual uint64_t							getObjectAddress() const		{ return fSymbol->n_value(); }
	virtual void								setSectionOffset(uint64_t offset) { /* don't let fSectionOffset be altered*/ }
	virtual const void*							getSectionRecord() const		{ return NULL; }

protected:
	typedef typename A::P					P;
	typedef typename A::P::E				E;
	typedef typename A::P::uint_t			pint_t;
	typedef typename A::ReferenceKinds		Kinds;
	friend class Reader<A>;

											AbsoluteAtom(Reader<A>&, const macho_nlist<P>*);
	virtual									~AbsoluteAtom() {}

	Reader<A>&									fOwner;
	const macho_nlist<P>*						fSymbol;
	ObjectFile::Atom::Scope						fScope;
	static std::vector<ObjectFile::Reference*>	fgNoReferences;
};

template <typename A>
std::vector<ObjectFile::Reference*> AbsoluteAtom<A>::fgNoReferences;

template <typename A>
AbsoluteAtom<A>::AbsoluteAtom(Reader<A>& owner, const macho_nlist<P>* symbol)
 : fOwner(owner), fSymbol(symbol)
{
	// store absolute adress in fSectionOffset
	fSectionOffset = symbol->n_value();
	// compute scope
	uint8_t type =  symbol->n_type();
	if ( (type & N_EXT) == 0 )
		fScope = ObjectFile::Atom::scopeTranslationUnit;
	else if ( (type & N_PEXT) != 0 )
		fScope = ObjectFile::Atom::scopeLinkageUnit;
	else
		fScope = ObjectFile::Atom::scopeGlobal;
	//fprintf(stderr, "AbsoluteAtom(%p) %s\n", this, this->getDisplayName());
}




///
/// ObjectFileAddressSpace is used as a template parameter to UnwindCursor for parsing
/// dwarf CFI information in an object file.   
///
template <typename A>
class ObjectFileAddressSpace
{
public:
						ObjectFileAddressSpace(Reader<A>& reader);

		typedef typename A::P::uint_t	pint_t;
		typedef typename A::P			P;
		typedef typename A::P::uint_t	sint_t;

		uint8_t			get8(pint_t addr);
		uint16_t		get16(pint_t addr);
		uint32_t		get32(pint_t addr);
		uint64_t		get64(pint_t addr);
		pint_t			getP(pint_t addr);
		uint64_t		getULEB128(pint_t& addr, pint_t end);
		int64_t			getSLEB128(pint_t& addr, pint_t end);
		pint_t			getEncodedP(pint_t& addr, pint_t end, uint8_t encoding);
private:
	const void*			mappedAddress(pint_t addr, pint_t* relocTarget=NULL);
	pint_t				relocated(uint32_t sectOffset, uint32_t relocsOffset, uint32_t relocsCount);
	void				buildRelocatedMap(const macho_section<P>* sect, std::map<uint32_t,uint64_t>& map);
	
	Reader<A>&				fReader;
	const uint8_t*			fMappingStart;
	const macho_section<P>* fSectionsStart;
	const macho_section<P>* fSectionsEnd;
	std::map<uint32_t,uint64_t> fEHFrameOffsetToTargetMap;
};


template <typename A>
ObjectFileAddressSpace<A>::ObjectFileAddressSpace(Reader<A>& reader)
	: fReader(reader), fMappingStart(NULL), fSectionsStart(NULL), fSectionsEnd(NULL)
{
}



template <typename A>
const void* ObjectFileAddressSpace<A>::mappedAddress(pint_t addr, pint_t* relocTarget)
{
	if ( fMappingStart == NULL ) {
		// delay initialization until now when fReader.fSegment is set up
		fMappingStart = (uint8_t*)fReader.fHeader;
		fSectionsStart = (macho_section<P>*)((char*)fReader.fSegment + sizeof(macho_segment_command<P>));
		fSectionsEnd = &fSectionsStart[fReader.fSegment->nsects()];
		// find __eh_frame section and build map of relocations for performance
		buildRelocatedMap(fReader.fehFrameSection, fEHFrameOffsetToTargetMap);
	}
	// special case lookups in __eh_frame section to be fast
	const macho_section<P>* ehSect = fReader.fehFrameSection;
	if ( (ehSect->addr() <= addr) && (addr < (ehSect->addr()+ehSect->size())) ) {
		pint_t offsetOfAddrInSection = addr - ehSect->addr();
		if ( relocTarget != NULL ) {
			std::map<uint32_t,uint64_t>::iterator pos = fEHFrameOffsetToTargetMap.find(offsetOfAddrInSection);
			if ( pos != fEHFrameOffsetToTargetMap.end() )
				*relocTarget = pos->second;
			else
				*relocTarget = 0;
		}
		return fMappingStart + ehSect->offset() + offsetOfAddrInSection;
	}
	else {
		for (const macho_section<P>* sect=fSectionsStart; sect < fSectionsEnd; ++sect) {
			if ( (sect->addr() <= addr) && (addr < (sect->addr()+sect->size())) ) {
				pint_t offsetOfAddrInSection = addr - sect->addr();
				if ( (sect->flags() & SECTION_TYPE) == S_NON_LAZY_SYMBOL_POINTERS ) {
					const uint32_t indirectTableOffset = sect->reserved1();
					const uint32_t sectionIndex = offsetOfAddrInSection/sizeof(pint_t);
					const uint32_t symbolIndex = A::P::E::get32(fReader.fIndirectTable[indirectTableOffset+sectionIndex]);
					// return pointer to symbol name which this non-lazy-pointer will point to
					if ( relocTarget != NULL )
						*relocTarget = (uintptr_t)&fReader.fStrings[fReader.fSymbols[symbolIndex].n_strx()];
				}
				else {
					if ( relocTarget != NULL )
						*relocTarget = relocated(offsetOfAddrInSection, sect->reloff(), sect->nreloc());
				}
				return fMappingStart + sect->offset() + offsetOfAddrInSection;
			}
		}
		throwf("ObjectFileAddressSpace::mappedAddress(0x%0lX) not in any section", (long)addr);
	}
}




template <typename A>
uint8_t ObjectFileAddressSpace<A>::get8(pint_t logicalAddr)
{
	return *((uint8_t*)mappedAddress(logicalAddr));
}

template <typename A>
uint16_t ObjectFileAddressSpace<A>::get16(pint_t logicalAddr)
{
	return P::E::get16(*((uint16_t*)mappedAddress(logicalAddr)));
}

template <typename A>
uint32_t ObjectFileAddressSpace<A>::get32(pint_t logicalAddr)
{
	pint_t relocTarget;
	return P::E::get32(*((uint32_t*)mappedAddress(logicalAddr, &relocTarget))) + relocTarget;
}

template <typename A>
uint64_t ObjectFileAddressSpace<A>::get64(pint_t logicalAddr)
{
	pint_t relocTarget;
	return P::E::get64(*((uint64_t*)mappedAddress(logicalAddr, &relocTarget))) + relocTarget;
}

template <typename A>
typename A::P::uint_t ObjectFileAddressSpace<A>::getP(pint_t logicalAddr)
{
	pint_t relocTarget;
	return P::getP(*((pint_t*)mappedAddress(logicalAddr, &relocTarget))) + relocTarget;
}

template <typename A>
uint64_t ObjectFileAddressSpace<A>::getULEB128(pint_t& logicalAddr, pint_t end)
{
	uintptr_t size = (end - logicalAddr);
	libunwind::LocalAddressSpace::pint_t laddr = (libunwind::LocalAddressSpace::pint_t)mappedAddress(logicalAddr);
	libunwind::LocalAddressSpace::pint_t sladdr = laddr;
	uint64_t result = libunwind::LocalAddressSpace::getULEB128(laddr, laddr+size);
	logicalAddr += (laddr-sladdr);
	return result;
}

template <typename A>
int64_t ObjectFileAddressSpace<A>::getSLEB128(pint_t& logicalAddr, pint_t end)
{
	uintptr_t size = (end - logicalAddr);
	libunwind::LocalAddressSpace::pint_t laddr = (libunwind::LocalAddressSpace::pint_t)mappedAddress(logicalAddr);
	libunwind::LocalAddressSpace::pint_t sladdr = laddr;
	int64_t result = libunwind::LocalAddressSpace::getSLEB128(laddr, laddr+size);
	logicalAddr += (laddr-sladdr);
	return result;
}






template <typename A>
class Reader : public ObjectFile::Reader
{
public:
	static bool										validFile(const uint8_t* fileContent, bool subtypeMustMatch=false, cpu_subtype_t subtype=0);
													Reader(const uint8_t* fileContent, const char* path, time_t modTime, 
														const ObjectFile::ReaderOptions& options, uint32_t ordinalBase);
	virtual											~Reader() {}

	virtual const char*								getPath()				{ return fPath; }
	virtual time_t									getModificationTime()	{ return fModTime; }
	virtual ObjectFile::Reader::DebugInfoKind		getDebugInfoKind()		{ return fDebugInfo; }
	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 std::vector<Stab>*						getStabs()				{ return &fStabs; }
	virtual ObjectFile::Reader::ObjcConstraint		getObjCConstraint()		{ return fObjConstraint; }
    virtual uint32_t                                updateCpuConstraint(uint32_t current);
	virtual bool									canScatterAtoms()		{ return (fHeader->flags() & MH_SUBSECTIONS_VIA_SYMBOLS); }
	virtual bool									objcReplacementClasses(){ return fReplacementClasses; }
	virtual bool									hasLongBranchStubs()	{ return fHasLongBranchStubs; }

	 bool											getTranslationUnitSource(const char** dir, const char** name) const;

private:
	typedef typename A::P						P;
	typedef typename A::P::E					E;
	typedef typename A::P::uint_t				pint_t;
	//typedef typename std::vector<Atom<A>*>		AtomVector;
	//typedef typename AtomVector::iterator		AtomVectorIterator;	// seems to help C++ parser
	typedef typename A::ReferenceKinds			Kinds;
	typedef typename libunwind::CFI_Parser<ObjectFileAddressSpace<A> >::FDE_Atom_Info  FDE_Atom_Info;
	typedef typename libunwind::CFI_Parser<ObjectFileAddressSpace<A> >::CIE_Atom_Info  CIE_Atom_Info;
	typedef class ObjectFileAddressSpace<A>	OAS;
	friend class ObjectFileAddressSpace<A>;
	friend class AnonymousAtom<A>;
	friend class TentativeAtom<A>;
	friend class AbsoluteAtom<A>;
	friend class SymbolAtom<A>;
	typedef std::map<pint_t, BaseAtom*>			AddrToAtomMap;

	void										addReferencesForSection(const macho_section<P>* sect);
	bool										addRelocReference(const macho_section<P>* sect, const macho_relocation_info<P>* reloc);
	bool										addRelocReference_powerpc(const macho_section<P>* sect, const macho_relocation_info<P>* reloc);
	const char*									getDwarfString(uint64_t form, const uint8_t* p);
	bool										read_comp_unit(const char ** name, const char ** comp_dir, uint64_t *stmt_list);
	static bool									isWeakImportSymbol(const macho_nlist<P>* sym);
	static bool									skip_form(const uint8_t ** offset, const uint8_t * end, uint64_t form, uint8_t addr_size, bool dwarf64);
	static const char*							assureFullPath(const char* path);
	AtomAndOffset								findAtomAndOffset(pint_t addr);
	AtomAndOffset								findAtomAndOffset(pint_t baseAddr, pint_t realAddr);
	Reference<A>*								makeReference(Kinds kind, pint_t atAddr, pint_t toAddr);
	Reference<A>*								makeReference(Kinds kind, pint_t atAddr, pint_t fromAddr, pint_t toAddr);
	Reference<A>*								makeReferenceWithToBase(Kinds kind, pint_t atAddr, pint_t toAddr, pint_t toBaseAddr);
	Reference<A>*								makeReferenceWithToBase(Kinds kind, pint_t atAddr, pint_t fromAddr, pint_t toAddr, pint_t toBaseAddr);
	Reference<A>*								makeByNameReference(Kinds kind, pint_t atAddr, const char* toName, uint32_t toOffset);
	BaseAtom*									makeReferenceToEH(const char* ehName, pint_t ehAtomAddress, const macho_section<P>* ehSect);
	Reference<A>*								makeReferenceToSymbol(Kinds kind, pint_t atAddr, const macho_nlist<P>* toSymbol, pint_t toOffset);
	void										validSectionType(uint8_t type);
	void										addDtraceExtraInfos(uint32_t probeAddr, const char* providerName);
	void										setCpuConstraint(uint32_t cpusubtype);
	const macho_section<P>*						getSectionForAddress(pint_t);
	ObjectFile::Atom*							getFunctionAtomFromFDEAddress(pint_t);
	ObjectFile::Atom*							getFunctionAtomFromLSDAAddress(pint_t);
	void										addFdeReference(uint8_t encoding, AtomAndOffset inFDE, AtomAndOffset target);
	void										addCiePersonalityReference(BaseAtom* cieAtom, uint32_t offsetInCIE, uint8_t encoding);
	bool										isSectDiffReloc(uint8_t r_type);


	BaseAtom*									findAtomByName(const char*);

	const char*									fPath;
	time_t										fModTime;
	uint32_t									fOrdinalBase;
	const ObjectFile::ReaderOptions&			fOptions;
	const macho_header<P>*						fHeader;
	const char*									fStrings;
	const macho_nlist<P>*						fSymbols;
	uint32_t									fSymbolCount;
	const macho_segment_command<P>*				fSegment;
	const uint32_t*								fIndirectTable;
	std::vector<BaseAtom*>						fAtoms;
	AddrToAtomMap								fAddrToAtom;
	AddrToAtomMap								fAddrToAbsoluteAtom;
	std::vector<class AnonymousAtom<A>*>		fLocalNonLazys;
	std::vector<class AnonymousAtom<A>*>		fAtomsPendingAName;
	std::set<const macho_section<P>*>			fSectionsWithAtomsPendingAName;
	std::vector<const char*>					fDtraceProviderInfo;
	ObjectFile::Reader::DebugInfoKind			fDebugInfo;
	bool										fHasUUID;
	const macho_section<P>*						fehFrameSection;
	std::set<BaseAtom*>							fLSDAAtoms;
	const macho_section<P>*						fDwarfDebugInfoSect;
	const macho_section<P>*						fDwarfDebugAbbrevSect;
	const macho_section<P>*						fDwarfDebugLineSect;
	const macho_section<P>*						fDwarfDebugStringSect;
	const char*									fDwarfTranslationUnitDir;
	const char*									fDwarfTranslationUnitFile;
	std::map<uint32_t,const char*>				fDwarfIndexToFile;
	std::vector<Stab>							fStabs;
	std::vector<FDE_Atom_Info>					fFDEInfos;
	std::vector<CIE_Atom_Info>					fCIEInfos;
	bool										fAppleObjc;
	bool										fHasDTraceProbes;
	bool										fHaveIndirectSymbols;
	bool										fReplacementClasses;
	bool										fHasLongBranchStubs;
	ObjectFile::Reader::ObjcConstraint			fObjConstraint;
	uint32_t                                    fCpuConstraint;
	const macho_section<P>*						fSectionsStart;
	const macho_section<P>*						fSectionsEnd;
	OAS											fObjectAddressSpace;
};

template <typename A>
Reader<A>::Reader(const uint8_t* fileContent, const char* path, time_t modTime, const ObjectFile::ReaderOptions& options, uint32_t ordinalBase)
	: fPath(strdup(path)), fModTime(modTime), fOrdinalBase(ordinalBase), fOptions(options), fHeader((const macho_header<P>*)fileContent),
	 fStrings(NULL), fSymbols(NULL), fSymbolCount(0), fSegment(NULL), fIndirectTable(NULL),
	 fDebugInfo(kDebugInfoNone), fHasUUID(false), fehFrameSection(NULL), 
	 fDwarfDebugInfoSect(NULL), fDwarfDebugAbbrevSect(NULL), fDwarfDebugLineSect(NULL),
	  fDwarfTranslationUnitDir(NULL), fDwarfTranslationUnitFile(NULL), fAppleObjc(false), fHasDTraceProbes(false),
	  fHaveIndirectSymbols(false), fReplacementClasses(false), fHasLongBranchStubs(false),
	  fObjConstraint(ObjectFile::Reader::kObjcNone), fCpuConstraint(ObjectFile::Reader::kCpuAny),
	  fSectionsStart(NULL), fSectionsEnd(NULL), fObjectAddressSpace(*this)
{
	// sanity check
	if ( ! validFile(fileContent, false, 0) )
		throw "not a valid mach-o object file";

	Reference<A>::fgForFinalLinkedImage = options.fForFinalLinkedImage;

	// write out path for -t or -whatsloaded option
	if ( options.fLogObjectFiles || options.fLogAllFiles )
		printf("%s\n", path);

	// cache intersting pointers
	const macho_header<P>* header = (const macho_header<P>*)fileContent;
	this->setCpuConstraint(header->cpusubtype());
	const uint32_t cmd_count = header->ncmds();
	const macho_load_command<P>* const cmds = (macho_load_command<P>*)((char*)header + sizeof(macho_header<P>));
	const macho_load_command<P>* const cmdsEnd = (macho_load_command<P>*)((char*)header + sizeof(macho_header<P>) + header->sizeofcmds());
	const macho_load_command<P>* cmd = cmds;
	uint32_t undefinedStartIndex = 0;
	uint32_t undefinedEndIndex = 0;
	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;
					fSymbolCount = symtab->nsyms();
					fSymbols = (const macho_nlist<P>*)((char*)header + symtab->symoff());
					fStrings = (char*)header + symtab->stroff();
					if ( undefinedEndIndex == 0 ) {
						undefinedStartIndex = 0;
						undefinedEndIndex = symtab->nsyms();
					}
				}
				break;
			case LC_DYSYMTAB:
				{
					const macho_dysymtab_command<P>* dsymtab = (struct macho_dysymtab_command<P>*)cmd;
					fIndirectTable = (uint32_t*)((char*)fHeader + dsymtab->indirectsymoff());
					undefinedStartIndex = dsymtab->iundefsym();
					undefinedEndIndex = undefinedStartIndex + dsymtab->nundefsym();
				}
				break;
		    case LC_UUID:
				fHasUUID = true;
				break;

			default:
				if ( cmd->cmd() == macho_segment_command<P>::CMD ) {
					fSegment = (macho_segment_command<P>*)cmd;
				}
				break;
		}
		cmd = (const macho_load_command<P>*)(((char*)cmd)+cmd->cmdsize());
		if ( cmd > cmdsEnd )
			throwf("malformed dylb, load command #%d is outside size of load commands in %s", i, path);
	}

	// if there are no load commands, then this file has no content, so no atoms
	if ( header->ncmds() < 1 )
		return;

	fSectionsStart = (macho_section<P>*)((char*)fSegment + sizeof(macho_segment_command<P>));
	fSectionsEnd = &fSectionsStart[fSegment->nsects()];

	// inital guess for number of atoms
	fAtoms.reserve(fSymbolCount);

	// if there is an __eh_frame section, decode it into chunks to get atoms in that
	// section as well as division points for functions in __text
	for (const macho_section<P>* sect=fSectionsStart; sect < fSectionsEnd; ++sect) {
		if ( (strcmp(sect->sectname(), "__eh_frame") == 0) && (strcmp(sect->segname(), "__TEXT") == 0) ) {
			fehFrameSection = sect;
			const char* msg = libunwind::CFI_Parser<ObjectFileAddressSpace<A> >::getCFIs(fObjectAddressSpace, sect->addr(), 
																						sect->size(), fFDEInfos, fCIEInfos);
			if ( msg != NULL ) {
				throwf("malformed __eh_frame section: %s", msg);
			}
			else {
				//fprintf(stderr, "%lu CIEs, %lu FDEs\n", fCIEInfos.size(), fFDEInfos.size());
				// add anonymous atoms for each CIE
				for (typename std::vector<CIE_Atom_Info>::const_iterator it = fCIEInfos.begin(); it != fCIEInfos.end(); ++it) {
					AnonymousAtom<A>* cieAtom = new AnonymousAtom<A>(*this, sect, it->cieAddress, 1);
					fAtoms.push_back(cieAtom);
					fAddrToAtom[it->cieAddress] = cieAtom;
				}
				// add anonymous atoms for each FDE and LSDA
				for (typename std::vector<FDE_Atom_Info>::const_iterator it = fFDEInfos.begin(); it != fFDEInfos.end(); ++it) {
					//fprintf(stderr, "fdeAddress=0x%08llX, lsdaAddr=0x%08llX, funcAddr=0x%08llX\n", (uint64_t)it->fdeAddress, (uint64_t)it->lsda.address,  (uint64_t)it->function.address);
					AnonymousAtom<A>* fdeAtom = new AnonymousAtom<A>(*this, sect, it->fdeAddress, 0);
					fAtoms.push_back(fdeAtom);
					fAddrToAtom[it->fdeAddress] = fdeAtom;
					if ( it->lsda.address != 0 ) {
						AnonymousAtom<A>* lsdaAtom = new AnonymousAtom<A>(*this, getSectionForAddress(it->lsda.address), it->lsda.address, 0); 
						fAtoms.push_back(lsdaAtom);
						fAddrToAtom[it->lsda.address] = lsdaAtom;
						fLSDAAtoms.insert(lsdaAtom);
					}
				}
			}
		}
	}


	// add all atoms that have entries in symbol table
	BaseAtom* sectionEndAtoms[fSegment->nsects()];
	for (unsigned int i=0; i < fSegment->nsects(); ++i)
		sectionEndAtoms[i] = NULL;
	for (int i=fSymbolCount-1; i >= 0 ; --i) {
		// walk backwards through symbol table so globals are see before locals, otherwise a local alias would beome the real name
		const macho_nlist<P>& sym = fSymbols[i];
		if ( (sym.n_type() & N_STAB) == 0 ) {
			uint8_t type =  (sym.n_type() & N_TYPE);
			if ( type == N_SECT ) {
				const macho_section<P>* section	= &fSectionsStart[sym.n_sect()-1];
				const pint_t sectionStartAddr = section->addr();
				const pint_t sectionEndAddr = sectionStartAddr + section->size();
				bool suppress = false;
				// ignore atoms in debugger sections 
				if ( (section->flags() & S_ATTR_DEBUG) == 0 ) {
					if ( strncmp(&fStrings[sym.n_strx()], "__dtrace_probe$", 15) == 0 ) {
						// ignore dtrace probe labels 
						fHasDTraceProbes = true;
					}
					else if ( fStrings[sym.n_strx()] == 'L' ) {
						// ignore L labels, <rdar://problem/3962731>
					}
					else if ( section == fehFrameSection ) {
						// ignore labels in __eh_frame section
					}
					else {
						// ignore labels for atoms in other sections
						switch ( section->flags() & SECTION_TYPE ) {
							case S_REGULAR:
								if ( (sym.n_desc() & N_WEAK_DEF) && strcmp(section->sectname(), "__picsymbolstub1__TEXT") == 0 )
									suppress = true; // ignore stubs in crt1.o built by old ld64 that was missing S_SYMBOL_STUBS
							case S_ZEROFILL:
							case S_COALESCED:
							case S_4BYTE_LITERALS:
							case S_8BYTE_LITERALS:
							case S_16BYTE_LITERALS:
							case S_CSTRING_LITERALS:
								{
									BaseAtom* newAtom;
									typename AddrToAtomMap::iterator pos = fAddrToAtom.find(sym.n_value());
									if ( (pos != fAddrToAtom.end()) && (pos->second->getSectionRecord() == section) ) {
										if ( fLSDAAtoms.count(pos->second) != 0 ) {
											// already have LSDA atom from for this address, ignore compiler's label
											suppress = true;
											break;
										}
										else {
											// another label to an existing address in the same section, make this an alias
											newAtom = new SymbolAliasAtom<A>(&fStrings[sym.n_strx()], &sym, *pos->second);
										}
									}
									else {
										if ( sym.n_value() == sectionEndAddr ) {
											// Symbol address is at end of section.  This can interfere
											// with a symbol at the start of the next section, so don't
											// add to fAddrToAtom. But do track in sectionEndAtoms so we
											// still make aliases if there are duplicates.
											if ( sectionEndAtoms[sym.n_sect()-1] == NULL ) {
												newAtom = new SymbolAtom<A>(*this, &sym, section);
												sectionEndAtoms[sym.n_sect()-1] = newAtom;
												// if this is a zero length section, so add to fAddrToAtom
												if ( sym.n_value() == sectionStartAddr )
													fAddrToAtom[newAtom->getObjectAddress()] = newAtom;
											}
											else {
												newAtom = new SymbolAliasAtom<A>(&fStrings[sym.n_strx()], &sym, *sectionEndAtoms[sym.n_sect()-1]);
											}
										}
										else {
											// make SymbolAtom atom for this address
											newAtom = new SymbolAtom<A>(*this, &sym, section);
											fAddrToAtom[newAtom->getObjectAddress()] = newAtom;
										}
									}
									if ( ! suppress )
										fAtoms.push_back(newAtom);
									}
								break;
							case S_SYMBOL_STUBS:
							case S_LAZY_SYMBOL_POINTERS:
							case S_NON_LAZY_SYMBOL_POINTERS:
								// ignore symboled stubs produces by old ld64
								break;
							default:
								warning("symbol %s found in unsupported section in %s",
									&fStrings[sym.n_strx()], this->getPath());
						}
					}
				}
			}
			else if ( (type == N_UNDF) && (sym.n_value() != 0) ) {
				fAtoms.push_back(new TentativeAtom<A>(*this, &sym));
			}
			else if ( type == N_ABS ) {
				const char* symName = &fStrings[sym.n_strx()];
				if ( strncmp(symName, ".objc_class_name_", 17) == 0 ) {
					// ignore .objc_class_name_* symbols 
					fAppleObjc = true;
				}
				else if ( strcmp(&symName[strlen(symName)-3], ".eh") == 0 ) {
					// ignore empty *.eh symbols
				}
				else {
					BaseAtom* abAtom = new AbsoluteAtom<A>(*this, &sym);
					fAtoms.push_back(abAtom);
					fAddrToAbsoluteAtom[sym.n_value()] = abAtom;
				}
			}
			else if ( type == N_INDR ) {
				fHaveIndirectSymbols = true;
			}
		}
	}

	// add anonymous atoms for any functions (as determined by dwarf unwind) have no symbol names
	if ( fehFrameSection != NULL ) {
		for (typename std::vector<FDE_Atom_Info>::const_iterator it = fFDEInfos.begin(); it != fFDEInfos.end(); ++it) {
			// add if not already an atom at that address
			if ( fAddrToAtom.find(it->function.address) == fAddrToAtom.end() ) {
				AnonymousAtom<A>* funcAtom = new AnonymousAtom<A>(*this, getSectionForAddress(it->function.address), it->function.address, 0);
				fAtoms.push_back(funcAtom);
				fAddrToAtom[it->function.address] = funcAtom;
				// even though we've made a new atom, be conservative and make sure they lay out together
				if ( canScatterAtoms() ) {
					AtomAndOffset prev = findAtomAndOffset(it->function.address-1);
					if ( prev.atom != NULL ) {
						if ( ((BaseAtom*)(prev.atom))->getSectionRecord() == funcAtom->getSectionRecord() )
							new Reference<A>(A::kFollowOn, prev, AtomAndOffset(funcAtom));
					}
				}
			}
		}
	}


	// add all fixed size anonymous atoms from special sections
	for (const macho_section<P>* sect=fSectionsStart; sect < fSectionsEnd; ++sect) {
		pint_t atomSize = 0;
		uint8_t type (sect->flags() & SECTION_TYPE);
		validSectionType(type);
		bool suppress = false;
		switch ( type ) {
			case S_SYMBOL_STUBS:
				suppress = true;
				atomSize = sect->reserved2();
				break;
			case S_LAZY_SYMBOL_POINTERS:
				suppress = true;
				atomSize = sizeof(pint_t);
				break;
			case S_NON_LAZY_SYMBOL_POINTERS:
			case S_LITERAL_POINTERS:
			case S_MOD_INIT_FUNC_POINTERS:
			case S_MOD_TERM_FUNC_POINTERS:
				atomSize = sizeof(pint_t);
				break;
			case S_INTERPOSING:
				atomSize = sizeof(pint_t)*2;
				break;
			case S_4BYTE_LITERALS:
				atomSize = 4;
				break;
			case S_8BYTE_LITERALS:
				atomSize = 8;
				break;
			case S_16BYTE_LITERALS:
				atomSize = 16;
				break;
			case S_REGULAR:
				// special case ObjC classes to synthesize .objc_class_name_* symbols
				if ( (strcmp(sect->sectname(), "__class") == 0) && (strcmp(sect->segname(), "__OBJC") == 0) && fAppleObjc ) {
					// gcc sometimes over aligns class structure
					uint32_t align = 1 << sect->align();
					atomSize = ((12 * sizeof(pint_t)) + align-1) & (-align);
				}
				// get objc Garbage Collection info
				else if ( ((strcmp(sect->sectname(), "__image_info") == 0) && (strcmp(sect->segname(), "__OBJC") == 0))
					   || ((strncmp(sect->sectname(), "__objc_imageinfo", 16) == 0) && (strcmp(sect->segname(), "__DATA") == 0)) ) {
					//	struct objc_image_info  {
					//		uint32_t	version;	// initially 0
					//		uint32_t	flags;
					//	};
					// #define OBJC_IMAGE_SUPPORTS_GC   2
					// #define OBJC_IMAGE_GC_ONLY       4
					//
					const uint32_t* contents = (uint32_t*)(((char*)fHeader) + sect->offset());
					if ( (sect->size() >= 8) && (contents[0] == 0) ) {
						uint32_t flags = E::get32(contents[1]);
						if ( (flags & 4) == 4 )
							fObjConstraint = ObjectFile::Reader::kObjcGC;
						else if ( (flags & 2) == 2 )
							fObjConstraint = ObjectFile::Reader::kObjcRetainReleaseOrGC;
						else
							fObjConstraint = ObjectFile::Reader::kObjcRetainRelease;
						if ( (flags & 1) == 1 )
							fReplacementClasses = true;
						// don't make atom for this section
						atomSize = sect->size();
						suppress = true;
					}
					else {
						warning("can't parse __OBJC/__image_info section in %s", fPath);
					}
				}
				// special case constant NS/CFString literals and make an atom out of each one
				else if ((strcmp(sect->sectname(), "__cfstring") == 0) && (strcmp(sect->segname(), "__DATA") == 0)) {
					atomSize = 4 * sizeof(pint_t);
				}
				break;
		}
		if ( atomSize != 0 ) {
			for(pint_t sectOffset=0; sectOffset < sect->size(); sectOffset += atomSize) {
				pint_t atomAddr = sect->addr() + sectOffset;
				// add if not already an atom at that address
				if ( fAddrToAtom.find(atomAddr) == fAddrToAtom.end() ) {
					AnonymousAtom<A>* newAtom = new AnonymousAtom<A>(*this, sect, atomAddr, atomSize);
					if ( !suppress )
						fAtoms.push_back(newAtom);
					fAddrToAtom[atomAddr] = newAtom->redirectTo();
				}
			}
		}
	}

	// add all c-string anonymous atoms
	for (const macho_section<P>* sect=fSectionsStart; sect < fSectionsEnd; ++sect) {
		if ( ((sect->flags() & SECTION_TYPE) == S_CSTRING_LITERALS) || strcmp(sect->sectname(), "__cstring") == 0 ) {
			uint32_t stringLen;
			pint_t stringAddr;
			BaseAtom* mostAlignedEmptyString = NULL;
			uint32_t mostAlignedEmptyStringTrailingZeros = 0;
			std::vector<std::pair<pint_t,BaseAtom*> > emptyStrings;
			for(pint_t sectOffset=0; sectOffset < sect->size(); sectOffset += stringLen) {
				stringAddr = sect->addr() + sectOffset;
				stringLen  = strlen((char*)(fHeader) + sect->offset() + sectOffset) + 1;
				// add if not already an atom at that address
				if ( fAddrToAtom.find(stringAddr) == fAddrToAtom.end() ) {
					BaseAtom* newAtom = new AnonymousAtom<A>(*this, sect, stringAddr, stringLen);
					if ( stringLen == 1 ) {
						// because of padding it may look like there are lots of empty strings, keep track of all
						emptyStrings.push_back(std::make_pair<pint_t,BaseAtom*>(stringAddr, newAtom));
						// record empty string with greatest alignment requirement
						uint32_t stringAddrTrailingZeros = (stringAddr==0) ? sect->align() : __builtin_ctz(stringAddr);
						if ( (mostAlignedEmptyString == NULL) 
							|| ( stringAddrTrailingZeros > mostAlignedEmptyStringTrailingZeros) ) {
							mostAlignedEmptyString = newAtom;
							mostAlignedEmptyStringTrailingZeros = stringAddrTrailingZeros;
						}
					}
					else {
						fAtoms.push_back(newAtom);
						fAddrToAtom[stringAddr] = newAtom;
					}
				}
			}
			// map all uses of empty strings to the most aligned one
			if ( mostAlignedEmptyString != NULL ) {
				// make most aligned atom a real atom
				fAtoms.push_back(mostAlignedEmptyString);
				// map all other empty atoms to this one
				for (typename std::vector<std::pair<pint_t,BaseAtom*> >::iterator it=emptyStrings.begin(); it != emptyStrings.end(); it++) {
					fAddrToAtom[it->first] = mostAlignedEmptyString;
				}
			}
		}
	}

	// sort all atoms so far by address and section
	std::sort(fAtoms.begin(), fAtoms.end(), BaseAtomSorter());

	//fprintf(stderr, "sorted atoms:\n");
	//for (std::vector<BaseAtom*>::iterator it=fAtoms.begin(); it != fAtoms.end(); it++) 
	//	fprintf(stderr, "0x%08llX %s\n", (*it)->getObjectAddress(), (*it)->getDisplayName());

	// create atoms to cover any non-debug ranges not handled above
	for (const macho_section<P>* sect=fSectionsStart; sect < fSectionsEnd; ++sect) {
		pint_t sectionStartAddr = sect->addr();
		pint_t sectionEndAddr   = sect->addr() + sect->size();
		// don't set follow-on atoms in __eh_frame section
		const bool setFollowOnAtom = !canScatterAtoms() && (sect != fehFrameSection);
		if ( sect->size() != 0 ) {
			// ignore dwarf sections.  If ld every supports processing dwarf, this logic will need to change
			if ( (sect->flags() & S_ATTR_DEBUG) != 0 ) {
				fDebugInfo = kDebugInfoDwarf;
				if ( strcmp(sect->sectname(), "__debug_info") == 0 )
					fDwarfDebugInfoSect = sect;
				else if ( strcmp(sect->sectname(), "__debug_abbrev") == 0 )
					fDwarfDebugAbbrevSect = sect;
				else if ( strcmp(sect->sectname(), "__debug_line") == 0 )
					fDwarfDebugLineSect = sect;
				else if ( strcmp(sect->sectname(), "__debug_str") == 0 )
					fDwarfDebugStringSect = sect;
			}
			else {
				if ( strcmp(sect->segname(), "__DWARFA") == 0 ) {
					throw "object file contains old DWARF debug info - rebuild with newer compiler";
				}
				uint8_t type (sect->flags() & SECTION_TYPE);
				switch ( type ) {
					case S_REGULAR:
					case S_ZEROFILL:
					case S_COALESCED:
						// if there is not an atom already at the start of this section, add an anonymous one
						pint_t previousAtomAddr = 0;
						BaseAtom* previousAtom = NULL;
						if ( fAddrToAtom.find(sectionStartAddr) == fAddrToAtom.end() ) {
							BaseAtom* newAtom = new AnonymousAtom<A>(*this, sect, sect->addr(), 0);
							fAddrToAtom[sect->addr()] = newAtom;
							fAtoms.push_back(newAtom);
							previousAtomAddr = sectionStartAddr;
							previousAtom = newAtom;
							std::sort(fAtoms.begin(), fAtoms.end(), BaseAtomSorter());
						}
						// calculate size of all atoms in this section and add follow-on references
						for (std::vector<BaseAtom*>::iterator it=fAtoms.begin(); it != fAtoms.end(); it++) {
							BaseAtom* atom = (BaseAtom*)(*it);
							pint_t atomAddr = atom->getObjectAddress();
							if ( atom->getSectionRecord() == sect ) {
								//fprintf(stderr, "addr=0x%08llX, atom=%s\n", (uint64_t)atomAddr, atom->getDisplayName());
								if ( (previousAtom != NULL) && (previousAtomAddr != atomAddr) ) {
									previousAtom->setSize(atomAddr - previousAtomAddr);
									if ( setFollowOnAtom && (atom != previousAtom) )
										new Reference<A>(A::kFollowOn, AtomAndOffset(previousAtom), AtomAndOffset(atom));
								}
								previousAtomAddr = atomAddr;
								previousAtom = atom;
							} 
						}
						if ( previousAtom != NULL ) {
							// set last atom in section
							previousAtom->setSize(sectionEndAddr - previousAtomAddr);
						}
						break;
				}
			}
		}
	}

	// check for object file that defines no objc classes, but uses objc classes
	// check for dtrace provider info
	for (uint32_t i=undefinedStartIndex; i < undefinedEndIndex; ++i) {
		const macho_nlist<P>& sym = fSymbols[i];
		if ( (sym.n_type() & N_STAB) == 0 ) {
			if ( (sym.n_type() & N_TYPE) == N_UNDF ) {
				const char* undefinedName = &fStrings[sym.n_strx()];
				if ( !fAppleObjc && (strncmp(undefinedName, ".objc_class_name_", 17) == 0) ) {
					fAppleObjc = true;
				}
				else if ( strncmp(undefinedName, "___dtrace_", 10) == 0 ) {
					if ( strchr(undefinedName, '$') != NULL  ) {
						if ( (strncmp(&undefinedName[10], "probe$", 6) != 0) && (strncmp(&undefinedName[10], "isenabled$", 10) != 0) ) {
							// any undefined starting with __dtrace_*$ that is not ___dtrace_probe$* or ___dtrace_isenabled$*
							// is extra provider info
							fDtraceProviderInfo.push_back(undefinedName);
						}
					}
				}
			}
		}
	}
	
	// add relocation based references to sections that have atoms with pending names
	for (const macho_section<P>* sect=fSectionsStart; sect < fSectionsEnd; ++sect) {
		if ( fSectionsWithAtomsPendingAName.count(sect) != 0 )
			addReferencesForSection(sect);
	}
	
	// update any anonymous atoms that need references built in order to name themselves
	for (typename std::vector<AnonymousAtom<A>*>::iterator it=fAtomsPendingAName.begin(); it != fAtomsPendingAName.end(); it++) {
		(*it)->resolveName();
	}

	// add relocation based references to other sections
	for (const macho_section<P>* sect=fSectionsStart; sect < fSectionsEnd; ++sect) {
		if ( fSectionsWithAtomsPendingAName.count(sect) == 0 )
			addReferencesForSection(sect);
	}

	// add objective-c references
	if ( fAppleObjc ) {
		for (const macho_section<P>* sect=fSectionsStart; sect < fSectionsEnd; ++sect) {
			if ( (strcmp(sect->sectname(), "__cls_refs") == 0) && (strcmp(sect->segname(), "__OBJC") == 0) ) {
				for (uint32_t offset = 0; offset < sect->size(); offset += sizeof(pint_t)) {
					AtomAndOffset ao = this->findAtomAndOffset(sect->addr()+offset);
					ObjectFile::Reference* classRef = ao.atom->getReferences()[0];
					if ( classRef->getFixUpOffset() == 0 ) {
						const char* classStr = classRef->getTargetName();
						if ( strncmp(classStr, "cstring=", 8) == 0 ) {
							const char* className;
							asprintf((char**)&className, ".objc_class_name_%s", &classStr[8]);
							new Reference<A>(A::kNoFixUp, ao, className, 0);
						}
					}
				}
			}
		}
	}

	// add direct references to local non-lazy-pointers, can do this now that all atoms are constructed
	for (typename std::vector<AnonymousAtom<A>*>::iterator it=fLocalNonLazys.begin(); it != fLocalNonLazys.end(); it++) {
		AnonymousAtom<A>* localNonLazy = *it;
		uint32_t fileOffset = localNonLazy->fSection->offset() - localNonLazy->fSection->addr() + localNonLazy->fAddress;
		pint_t nonLazyPtrValue = P::getP(*((pint_t*)((char*)(fHeader)+fileOffset)));
		makeReference(A::kPointer, localNonLazy->fAddress, nonLazyPtrValue);
	}
	

	// add personality references to CIEs
	for (typename std::vector<CIE_Atom_Info>::const_iterator it = fCIEInfos.begin(); it != fCIEInfos.end(); ++it) {
		if ( it->personality.offsetInFDE != 0 )
			addCiePersonalityReference(fAddrToAtom[it->cieAddress], it->personality.offsetInFDE, it->personality.encodingOfAddress);
	}

	// add all references for FDEs, including implicit group references
	for (typename std::vector<FDE_Atom_Info>::const_iterator it = fFDEInfos.begin(); it != fFDEInfos.end(); ++it) {
		AtomAndOffset funcAO = this->findAtomAndOffset(it->function.address);
		if ( funcAO.offset != 0 )
			warning("FDE does not point to start of function %s\n", funcAO.atom->getDisplayName());
		AtomAndOffset fdeAO = this->findAtomAndOffset(it->fdeAddress);
		if ( fdeAO.offset != 0 )
			warning("FDE does start its own atom %s\n", funcAO.atom->getDisplayName());
		AtomAndOffset cieAO = this->findAtomAndOffset(it->cie.address);
		if ( cieAO.offset != 0 )
			warning("CIE does start its own atom %s\n", cieAO.atom->getDisplayName());
		AtomAndOffset lsdaAO;
		if ( it->lsda.address != 0 ) {
			lsdaAO = this->findAtomAndOffset(it->lsda.address);
			if ( lsdaAO.offset != 0 )
				warning("LSDA does start its own atom %s\n", lsdaAO.atom->getDisplayName());
		}
		
		// add reference from FDE to CIE	
		AtomAndOffset cieInfdeAO = AtomAndOffset(fdeAO.atom, it->cie.offsetInFDE);
		new Reference<A>(A::kPointerDiff32, cieInfdeAO, cieAO, cieInfdeAO);
		
		// add reference from FDE to function
		addFdeReference(it->function.encodingOfAddress, AtomAndOffset(fdeAO.atom, it->function.offsetInFDE), funcAO);
				
		// add reference from FDE to LSDA
		if ( it->lsda.address != 0 ) {
			addFdeReference(it->lsda.encodingOfAddress, AtomAndOffset(fdeAO.atom, it->lsda.offsetInFDE), lsdaAO);
		}
		
		// FDE is in group lead by function atom
		new Reference<A>(A::kGroupSubordinate, funcAO, fdeAO);
		
		// LSDA is in group lead by function atom
		if ( it->lsda.address != 0 ) {
			new Reference<A>(A::kGroupSubordinate, funcAO, lsdaAO);
			// add back reference from LSDA to owning function
			new Reference<A>(A::kNoFixUp, lsdaAO, funcAO);
		}

		// compute compact encoding for this FDE
		if ( fOptions.fAddCompactUnwindEncoding ) {
			((BaseAtom*)(funcAO.atom))->setCompactUnwindEncoding(it->fdeAddress);
			// add reference from function atom to personality function
			// the only reference a CIE can have is the reference to the personality function
			std::vector<class ObjectFile::Reference*>& cieRefs = cieAO.atom->getReferences();
			if ( cieRefs.size() == 1 ) {
				new Reference<A>((typename A::ReferenceKinds)((BaseAtom*)(funcAO.atom))->getPersonalityReferenceKind(), 
									funcAO, cieRefs[0]->getTargetName(), 0);
			}
		}
	}

	// add command line aliases
	for(std::vector<ObjectFile::ReaderOptions::AliasPair>::const_iterator it = fOptions.fAliases.begin(); it != fOptions.fAliases.end(); ++it) { 
		BaseAtom* target = this->findAtomByName(it->realName);
		if ( (target != NULL) && target->getSymbolTableInclusion() != ObjectFile::Atom::kSymbolTableNotIn )
			fAtoms.push_back(new SymbolAliasAtom<A>(it->alias, NULL, *target));
	}

	// add dtrace probe locations
	if ( fHasDTraceProbes ) {
		for (uint32_t i=0; i < fSymbolCount; ++i) {
			const macho_nlist<P>& sym = fSymbols[i];
			if ( (sym.n_type() & N_STAB) == 0 ) {
				if ( (sym.n_type() & N_TYPE) == N_SECT ) {
					const char* symbolName = &fStrings[sym.n_strx()];
					if ( strncmp(symbolName, "__dtrace_probe$", 15) == 0 ) {
						//fprintf(stderr, "adding dtrace probe at 0x%08llX %s\n", sym.n_value(), symbolName);
						makeByNameReference(A::kDtraceProbe, sym.n_value(), symbolName, 0);
					}
				}
			}
		}
	}
	
	// turn indirect symbols into SymbolAliasAtom 
	if ( fHaveIndirectSymbols ) {
		for (uint32_t i=0; i < fSymbolCount; ++i) {
			const macho_nlist<P>& sym = fSymbols[i];
			if ( (sym.n_type() & N_STAB) == 0 ) {
				if ( (sym.n_type() & N_TYPE) == N_INDR ) {
					const char* aliasName = &fStrings[sym.n_strx()];
					const char* targetName = &fStrings[sym.n_value()];
					//fprintf(stderr, "found alias %s for %s\n", aliasName, targetName);
					BaseAtom* target = this->findAtomByName(targetName);
					// only currently support N_INDR based aliases to something in the same .o file 
					if ( target != NULL ) {
						fAtoms.push_back(new SymbolAliasAtom<A>(aliasName, &sym, *target));
						//fprintf(stderr, "creating alias %s for %s\n", aliasName, targetName);
					}
				}
			}
		}
	}

	//for (typename AddrToAtomMap::iterator it=fAddrToAtom.begin(); it != fAddrToAtom.end(); it++) {
	//	fprintf(stderr, "[0x%0X -> 0x%0llX) : %s\n", it->first, it->first+it->second->getSize(), it->second->getDisplayName());
	//}

	// add translation unit info from dwarf
	uint64_t stmtList;
	if ( (fDebugInfo == kDebugInfoDwarf) && (fOptions.fDebugInfoStripping != ObjectFile::ReaderOptions::kDebugInfoNone) ) {
		// compiler sometimes emits emtpty dwarf sections when there is no debug info, skip those
		if ( (fDwarfDebugInfoSect != NULL) && (fDwarfDebugInfoSect->size() != 0) ) {
			if ( !read_comp_unit(&fDwarfTranslationUnitFile, &fDwarfTranslationUnitDir, &stmtList) ) {
				// if can't parse dwarf, warn and give up
				fDwarfTranslationUnitFile = NULL;
				fDwarfTranslationUnitDir = NULL;
				warning("can't parse dwarf compilation unit info in %s", this->getPath());
				fDebugInfo = kDebugInfoNone;
			}
		}
	}

	// add line number info to atoms from dwarf
	if ( (fDebugInfo == kDebugInfoDwarf) && (fOptions.fDebugInfoStripping != ObjectFile::ReaderOptions::kDebugInfoNone) ) {
		// file with just data will have no __debug_line info
		if ( (fDwarfDebugLineSect != NULL) && (fDwarfDebugLineSect->size() != 0) && (fAddrToAtom.size() != 0)
			&& (fDwarfDebugInfoSect != NULL) && (fDwarfDebugInfoSect->size() != 0) ) {
			// validate stmt_list
			if ( (stmtList != (uint64_t)-1) && (stmtList < fDwarfDebugLineSect->size()) ) {
				const uint8_t* debug_line = (uint8_t*)(fHeader) + fDwarfDebugLineSect->offset();
				if ( debug_line != NULL ) {
					struct line_reader_data* lines = line_open(&debug_line[stmtList],
															fDwarfDebugLineSect->size() - stmtList, E::little_endian);
					struct line_info result;
					ObjectFile::Atom* curAtom = NULL;
					uint32_t curAtomOffset = 0;
					uint32_t curAtomAddress = 0;
					uint32_t curAtomSize = 0;
					if ( lines != NULL ) {
						while ( line_next (lines, &result, line_stop_pc) ) {
							//fprintf(stderr, "curAtom=%p, result.pc=0x%llX, result.line=%llu, result.end_of_sequence=%d, curAtomAddress=0x%X, curAtomSize=0x%X\n",
							//		curAtom, result.pc, result.line, result.end_of_sequence, curAtomAddress, curAtomSize);
							// work around weird debug line table compiler generates if no functions in __text section
							if ( (curAtom == NULL) && (result.pc == 0) && result.end_of_sequence && (result.file == 1))
								continue;
							// for performance, see if in next pc is in current atom
							if ( (curAtom != NULL) && (curAtomAddress <= result.pc) && (result.pc < (curAtomAddress+curAtomSize)) ) {
								curAtomOffset = result.pc - curAtomAddress;
							}
							// or pc at end of current atom
							else if ( result.end_of_sequence && (curAtom != NULL) && (result.pc == (curAtomAddress+curAtomSize)) ) {
								curAtomOffset = result.pc - curAtomAddress;
							}
							else {
								// do slow look up of atom by address
								AtomAndOffset ao = this->findAtomAndOffset(result.pc);
								curAtom			= ao.atom;
								if ( curAtom == NULL )
									break; // file has line info but no functions
								if ( result.end_of_sequence && (curAtomAddress+curAtomSize < result.pc) ) {	
									// a one line function can be returned by line_next() as one entry with pc at end of blob
									// look for alt atom starting at end of previous atom
									uint32_t previousEnd = curAtomAddress+curAtomSize;
									AtomAndOffset alt = this->findAtomAndOffset(previousEnd);
									if ( result.pc <= previousEnd - alt.offset + alt.atom->getSize() ) {
										curAtom			= alt.atom;
										curAtomOffset	= alt.offset;
										curAtomAddress	= previousEnd - alt.offset;
										curAtomSize		= curAtom->getSize();
									}
									else {
										curAtomOffset	= ao.offset;
										curAtomAddress	= result.pc - ao.offset;
										curAtomSize		= curAtom->getSize();
									}
								}
								else {
									curAtomOffset	= ao.offset;
									curAtomAddress	= result.pc - ao.offset;
									curAtomSize		= curAtom->getSize();
								}
							}
							const char* filename;
							std::map<uint32_t,const char*>::iterator pos = fDwarfIndexToFile.find(result.file);
							if ( pos == fDwarfIndexToFile.end() ) {
								filename = line_file(lines, result.file);
								fDwarfIndexToFile[result.file] = filename;
							}
							else {
								filename = pos->second;
							}
							ObjectFile::LineInfo info;
							info.atomOffset = curAtomOffset;
							info.fileName = filename;
							info.lineNumber = result.line;
							//fprintf(stderr, "addr=0x%08llX, line=%lld, file=%s, atom=%s, atom.size=0x%X, end=%d\n", 
							//		result.pc, result.line, filename, curAtom->getDisplayName(), curAtomSize, result.end_of_sequence);
							((BaseAtom*)curAtom)->addLineInfo(info);
							if ( result.end_of_sequence ) {
								curAtom = NULL;
							}
						}
					line_free(lines);
					}
				}
				else {
					warning("could not parse dwarf line number info in %s", this->getPath());
				}
			}
		}
	}

	// if no dwarf, try processing stabs debugging info
	if ( (fDebugInfo == kDebugInfoNone) && (fOptions.fDebugInfoStripping != ObjectFile::ReaderOptions::kDebugInfoNone) ) {
		// scan symbol table for stabs entries
		fStabs.reserve(fSymbolCount);  // reduce re-allocations
		BaseAtom* currentAtom = NULL;
		pint_t currentAtomAddress = 0;
		enum { start, inBeginEnd, inFun } state = start;
		for (uint32_t symbolIndex = 0; symbolIndex < fSymbolCount; ++symbolIndex ) {
			const macho_nlist<P>* sym = &fSymbols[symbolIndex];
			bool useStab = true;
			uint8_t type = sym->n_type();
			const char* symString = (sym->n_strx() != 0) ? &fStrings[sym->n_strx()] : NULL;
			if ( (type & N_STAB) != 0 ) {
				fDebugInfo =  (fHasUUID ? kDebugInfoStabsUUID : kDebugInfoStabs);
				Stab stab;
				stab.atom	= NULL;
				stab.type	= type;
				stab.other	= sym->n_sect();
				stab.desc	= sym->n_desc();
				stab.value	= sym->n_value();
				stab.string = NULL;
				switch (state) {
					case start:
						switch (type) {
							case N_BNSYM:
								// beginning of function block
								state = inBeginEnd;
								// fall into case to lookup atom by addresss
							case N_LCSYM:
							case N_STSYM:
								currentAtomAddress = sym->n_value();
								currentAtom = (BaseAtom*)this->findAtomAndOffset(currentAtomAddress).atom;
								if ( currentAtom != NULL ) {
									stab.atom = currentAtom;
									stab.string = symString;
								}
								else {
									fprintf(stderr, "can't find atom for stabs BNSYM at %08llX in %s",
										(uint64_t)sym->n_value(), path);
								}
								break;
							case N_SO:
							case N_OSO:
							case N_OPT:
							case N_LSYM:
							case N_RSYM:
							case N_PSYM:
								// not associated with an atom, just copy
								stab.string = symString;
								break;
							case N_GSYM:
							{
								// n_value field is NOT atom address ;-(
								// need to find atom by name match
								const char* colon = strchr(symString, ':');
								if ( colon != NULL ) {
									// build underscore leading name
									int nameLen = colon - symString;
									char symName[nameLen+2];
									strlcpy(&symName[1], symString, nameLen+1);
									symName[0] = '_';
									symName[nameLen+1] = '\0';
									currentAtom = findAtomByName(symName);
									if ( currentAtom != NULL ) {
										stab.atom = currentAtom;
										stab.string = symString;
									}
								}
								else {
									// might be a debug-note without trailing :G()
									currentAtom = findAtomByName(symString);
									if ( currentAtom != NULL ) {
										stab.atom = currentAtom;
										stab.string = symString;
									}
								}
								if ( stab.atom == NULL ) {
									// ld_classic added bogus GSYM stabs for old style dtrace probes
									if ( (strncmp(symString, "__dtrace_probe$", 15) != 0) )
										warning("can't find atom for N_GSYM stabs %s in %s", symString, path);
									useStab = false;
								}
								break;
							}
							case N_FUN:
								// old style stabs without BNSYM
								state = inFun;
								currentAtomAddress = sym->n_value();
								currentAtom = (BaseAtom*)this->findAtomAndOffset(currentAtomAddress).atom;
								if ( currentAtom != NULL ) {
									stab.atom = currentAtom;
									stab.string = symString;
								}
								else {
									warning("can't find atom for stabs FUN at %08llX in %s",
										(uint64_t)currentAtomAddress, path);
								}
								break;
							case N_SOL:
							case N_SLINE:
								stab.string = symString;
								// old stabs
								break;
							case N_BINCL:
							case N_EINCL:
							case N_EXCL:
								stab.string = symString;
								// -gfull built .o file
								break;
							default:
								warning("unknown stabs type 0x%X in %s", type, path);
						}
						break;
					case inBeginEnd:
						stab.atom = currentAtom;
						switch (type) {
							case N_ENSYM:
								state = start;
								currentAtom = NULL;
								break;
							case N_LCSYM:
							case N_STSYM:
							{
								BaseAtom* nestedAtom = (BaseAtom*)this->findAtomAndOffset(sym->n_value()).atom;
								if ( nestedAtom != NULL ) {
									stab.atom = nestedAtom;
									stab.string = symString;
								}
								else {
									warning("can't find atom for stabs 0x%X at %08llX in %s",
										type, (uint64_t)sym->n_value(), path);
								}
								break;
							}
							case N_LBRAC:
							case N_RBRAC:
							case N_SLINE:
								// adjust value to be offset in atom
								stab.value -= currentAtomAddress;
							default:
								stab.string = symString;
								break;
						}
						break;
					case inFun:
						switch (type) {
							case N_FUN:
								if ( sym->n_sect() != 0 ) {
									// found another start stab, must be really old stabs...
									currentAtomAddress = sym->n_value();
									currentAtom = (BaseAtom*)this->findAtomAndOffset(currentAtomAddress).atom;
									if ( currentAtom != NULL ) {
										stab.atom = currentAtom;
										stab.string = symString;
									}
									else {
										warning("can't find atom for stabs FUN at %08llX in %s",
											(uint64_t)currentAtomAddress, path);
									}
								}
								else {
									// found ending stab, switch back to start state
									stab.string = symString;
									stab.atom = currentAtom;
									state = start;
									currentAtom = NULL;
								}
								break;
							case N_LBRAC:
							case N_RBRAC:
							case N_SLINE:
								// adjust value to be offset in atom
								stab.value -= currentAtomAddress;
								stab.atom = currentAtom;
								break;
							case N_SO:
								stab.string = symString;
								state = start;
								break;
							default:
								stab.atom = currentAtom;
								stab.string = symString;
								break;
						}
						break;
				}
				// add to list of stabs for this .o file
				if ( useStab )
					fStabs.push_back(stab);
			}
		}
	}

#if 0
	// special case precompiled header .o file (which has no content) to have one empty atom
	if ( fAtoms.size() == 0 ) {
		int pathLen = strlen(path);
		if ( (pathLen > 6) && (strcmp(&path[pathLen-6], ".gch.o")==0) ) {
			ObjectFile::Atom* phony = new AnonymousAtom<A>(*this, (uint32_t)0);
			//phony->fSynthesizedName = ".gch.o";
			fAtoms.push_back(phony);
		}
	}
#endif

	// sort all atoms by address
	std::sort(fAtoms.begin(), fAtoms.end(), BaseAtomSorter());

	// set ordinal and sort references in each atom
	uint32_t index = fOrdinalBase;
	for (std::vector<BaseAtom*>::iterator it=fAtoms.begin(); it != fAtoms.end(); it++) {
		BaseAtom* atom = (BaseAtom*)(*it);
		atom->setOrdinal(index++);
		atom->sortReferences();
	}
	
}

template <typename A>
const macho_section<typename A::P>* Reader<A>::getSectionForAddress(pint_t addr)
{
	for (const macho_section<P>* sect=fSectionsStart; sect < fSectionsEnd; ++sect) {
		if ( (sect->addr() <= addr) && (addr < (sect->addr()+sect->size())) ) 
			return sect;
	}
	throwf("section not found for address 0x%08llX", (uint64_t)addr);
}

template <typename A>
ObjectFile::Atom* Reader<A>::getFunctionAtomFromFDEAddress(pint_t addr)
{
	for (typename std::vector<FDE_Atom_Info>::const_iterator it = fFDEInfos.begin(); it != fFDEInfos.end(); ++it) {
		if ( it->fdeAddress == addr ) {
			return findAtomAndOffset(it->function.address).atom;
		}
	}
	// CIEs won't be in fFDEInfos
	return NULL;
}

template <typename A>
ObjectFile::Atom* Reader<A>::getFunctionAtomFromLSDAAddress(pint_t addr)
{
	for (typename std::vector<FDE_Atom_Info>::const_iterator it = fFDEInfos.begin(); it != fFDEInfos.end(); ++it) {
		if ( it->lsda.address == addr ) {
			return findAtomAndOffset(it->function.address).atom;
		}
	}
	return NULL;
}


template <>
void ObjectFileAddressSpace<x86_64>::buildRelocatedMap(const macho_section<P>* sect, std::map<uint32_t,uint64_t>& map)
{	
	// mach-o x86_64 is different, the content of a section with a relocation is the addend
	const macho_relocation_info<P>* relocs = (macho_relocation_info<P>*)((char*)(fReader.fHeader) + sect->reloff());
	const macho_relocation_info<P>* relocsEnd = &relocs[sect->nreloc()];
	for (const macho_relocation_info<P>* reloc = relocs; reloc < relocsEnd; ++reloc) {
		std::map<uint32_t,uint64_t>::iterator pos;
		switch ( reloc->r_type() ) {
			case X86_64_RELOC_UNSIGNED:
				pos = map.find(reloc->r_address());
				if ( pos != map.end() )
					pos->second += fReader.fSymbols[reloc->r_symbolnum()].n_value();
				else
					map[reloc->r_address()] = fReader.fSymbols[reloc->r_symbolnum()].n_value();
				break;
			case X86_64_RELOC_SUBTRACTOR:
				map[reloc->r_address()] = -fReader.fSymbols[reloc->r_symbolnum()].n_value();
				break;
			case X86_64_RELOC_GOT:
				// there is no good address to return here.
				// GOT slots are synthsized by the linker
				// this is used for the reference to the personality function in CIEs
				map[reloc->r_address()] = 0;
				break;
			default:
				fprintf(stderr, "ObjectFileAddressSpace::buildRelocatedMap() unexpected relocation at r_address=0x%08X\n", reloc->r_address());
				break;
		}
	}
}

template <typename A>
void ObjectFileAddressSpace<A>::buildRelocatedMap(const macho_section<P>* sect, std::map<uint32_t,uint64_t>& map)
{
	// in all architectures except x86_64, the section contents are already fixed up to point
	// to content in the same object file.
}

template <>
uint64_t ObjectFileAddressSpace<x86_64>::relocated(uint32_t sectOffset, uint32_t relocsOffset, uint32_t relocsCount)
{	
	// mach-o x86_64 is different, the content of a section with a relocation is the addend
	uint64_t result = 0;
	const macho_relocation_info<P>* relocs = (macho_relocation_info<P>*)((char*)(fReader.fHeader) + relocsOffset);
	const macho_relocation_info<P>* relocsEnd = &relocs[relocsCount];
	for (const macho_relocation_info<P>* reloc = relocs; reloc < relocsEnd; ++reloc) {
		//fprintf(stderr, "ObjectFileAddressSpace::relocated(0x%08X), r_address=0x%08X\n", sectOffset, reloc->r_address());
		if ( reloc->r_address() == sectOffset ) {
			switch ( reloc->r_type() ) {
				case X86_64_RELOC_UNSIGNED:
					result += fReader.fSymbols[reloc->r_symbolnum()].n_value();
					break;
				case X86_64_RELOC_SUBTRACTOR:
					result -= fReader.fSymbols[reloc->r_symbolnum()].n_value();
					break;
				case X86_64_RELOC_GOT:
					// there is no good address to return here.
					// GOT slots are synthsized by the linker
					// this is used for the reference to the personality function in CIEs
					result = 0;
					break;
				default:
					fprintf(stderr, "ObjectFileAddressSpace::relocated(0x%08X) => type=%d, value=0x%08X\n", sectOffset, reloc->r_type(), reloc->r_symbolnum());
					break;
			}
		}
	}
	//fprintf(stderr, "ObjectFileAddressSpace::relocated(0x%08X) => 0x%0llX\n", sectOffset, result);
	return result;
}

template <typename A>
typename A::P::uint_t ObjectFileAddressSpace<A>::relocated(uint32_t sectOffset, uint32_t relocsOffset, uint32_t relocsCount)
{
	// in all architectures except x86_64, the section contents are already fixed up to point
	// to content in the same object file.
	return 0;
}



// FSF exception handling Pointer-Encoding constants 
// Used in CFI augmentation by gcc compiler
enum {
	DW_EH_PE_ptr       = 0x00,
	DW_EH_PE_uleb128   = 0x01,
	DW_EH_PE_udata2    = 0x02,
	DW_EH_PE_udata4    = 0x03,
	DW_EH_PE_udata8    = 0x04,
	DW_EH_PE_signed    = 0x08,
	DW_EH_PE_sleb128   = 0x09,
	DW_EH_PE_sdata2    = 0x0A,
	DW_EH_PE_sdata4    = 0x0B,
	DW_EH_PE_sdata8    = 0x0C,
	DW_EH_PE_absptr    = 0x00,
	DW_EH_PE_pcrel     = 0x10,
	DW_EH_PE_textrel   = 0x20,
	DW_EH_PE_datarel   = 0x30,
	DW_EH_PE_funcrel   = 0x40,
	DW_EH_PE_aligned   = 0x50,
	DW_EH_PE_indirect  = 0x80,
	DW_EH_PE_omit      = 0xFF
};

template <>
void Reader<x86_64>::addCiePersonalityReference(BaseAtom* cieAtom, uint32_t offsetInCIE, uint8_t encoding)
{
	if ( encoding != (DW_EH_PE_indirect|DW_EH_PE_pcrel|DW_EH_PE_sdata4) )
		throw "unexpected personality encoding in CIE";

	// walk relocs looking for reloc in this CIE
	uint32_t sectOffset = (cieAtom->getObjectAddress() + offsetInCIE) - fehFrameSection->addr();
	const macho_relocation_info<P>* relocs = (macho_relocation_info<P>*)((char*)(fHeader) + fehFrameSection->reloff());
	const macho_relocation_info<P>* relocsEnd = &relocs[fehFrameSection->nreloc()];
	for (const macho_relocation_info<P>* reloc = relocs; reloc < relocsEnd; ++reloc) {
		if ( reloc->r_address() == sectOffset ) {
			switch ( reloc->r_type() ) {
				case X86_64_RELOC_GOT:
					if ( !reloc->r_extern() )
						throw "GOT reloc not extern for personality function";
					new Reference<x86_64>(x86_64::kPCRel32GOT, AtomAndOffset(cieAtom, offsetInCIE), &fStrings[fSymbols[reloc->r_symbolnum()].n_strx()], 4);
					return;
				default:
					throw "expected GOT reloc for personality function";
			}
		}
	}
	throw "personality function not found for CIE";
}

template <>
bool Reader<ppc>::isSectDiffReloc(uint8_t r_type)
{
	switch ( r_type ) {
		case PPC_RELOC_LOCAL_SECTDIFF:
		case PPC_RELOC_SECTDIFF:
			return true;
	}
	return false;
}

template <>
bool Reader<ppc64>::isSectDiffReloc(uint8_t r_type)
{
	switch ( r_type ) {
		case PPC_RELOC_LOCAL_SECTDIFF:
		case PPC_RELOC_SECTDIFF:
			return true;
	}
	return false;
}

template <>
bool Reader<x86>::isSectDiffReloc(uint8_t r_type)
{
	switch ( r_type ) {
		case GENERIC_RELOC_LOCAL_SECTDIFF:
		case GENERIC_RELOC_SECTDIFF:
			return true;
	}
	return false;
}

template <>
bool Reader<arm>::isSectDiffReloc(uint8_t r_type)
{
	switch ( r_type ) {
		case ARM_RELOC_LOCAL_SECTDIFF:
		case ARM_RELOC_SECTDIFF:
			return true;
	}
	return false;
}

template <typename A>
void Reader<A>::addCiePersonalityReference(BaseAtom* cieAtom, uint32_t offsetInCIE, uint8_t encoding)
{
	if ( (encoding != (DW_EH_PE_indirect|DW_EH_PE_pcrel|DW_EH_PE_sdata4)) && (encoding != (DW_EH_PE_indirect|DW_EH_PE_pcrel)) )
		throw "unexpected personality encoding in CIE";

	// walk relocs looking for personality reloc in this CIE
	uint32_t sectOffset = (cieAtom->getObjectAddress() + offsetInCIE) - fehFrameSection->addr();
	const macho_relocation_info<P>* relocs = (macho_relocation_info<P>*)((char*)(fHeader) + fehFrameSection->reloff());
	const macho_relocation_info<P>* relocsEnd = &relocs[fehFrameSection->nreloc()];
	for (const macho_relocation_info<P>* reloc = relocs; reloc < relocsEnd; ++reloc) {
		if ( (reloc->r_address() & R_SCATTERED) == 0 ) {
			// ignore
		}
		else {
		const macho_scattered_relocation_info<P>* sreloc = (macho_scattered_relocation_info<P>*)reloc;
			if ( sreloc->r_address() == sectOffset ) {
				if ( isSectDiffReloc(sreloc->r_type()) ) {
					// r_value is address of non-lazy-pointer to personality function
					new Reference<A>(A::kPointerDiff32, AtomAndOffset(cieAtom, offsetInCIE), AtomAndOffset(cieAtom, offsetInCIE), 
											findAtomAndOffset(sreloc->r_value()));
					return;
				}
			}
		}
	}
	throw "can't find relocation for personality in CIE";
}

template <typename A>
void Reader<A>::addFdeReference(uint8_t encoding, AtomAndOffset inFDE, AtomAndOffset target)
{
	if ( (encoding & 0xF0) != DW_EH_PE_pcrel ) 
		throw "unsupported encoding in FDE";
	Kinds kind = A::kNoFixUp;
	switch ( encoding & 0xF ) {
		case DW_EH_PE_ptr:
			kind = A::kPointerDiff;
			break;
		case DW_EH_PE_sdata4:
			kind = A::kPointerDiff32;
			break;
		default:
			throw "unsupported encoding in FDE";
	}
	new Reference<A>(kind, inFDE, inFDE, target);
}

template <typename A>
typename A::P::uint_t ObjectFileAddressSpace<A>::getEncodedP(pint_t& addr, pint_t end, uint8_t encoding)
{
	pint_t startAddr = addr;
	pint_t p = addr;
	pint_t result;
	
	// first get value
	switch (encoding & 0x0F) {
		case DW_EH_PE_ptr:
			result = getP(addr);
			p += sizeof(pint_t);
			addr = (pint_t)p;
			break;
		case DW_EH_PE_uleb128:
			result = getULEB128(addr, end);
			break;
		case DW_EH_PE_udata2:
			result = get16(addr);
			p += 2;
			addr = (pint_t)p;
			break;
		case DW_EH_PE_udata4:
			result = get32(addr);
			p += 4;
			addr = (pint_t)p;
			break;
		case DW_EH_PE_udata8:
			result = get64(addr);
			p += 8;
			addr = (pint_t)p;
			break;
		case DW_EH_PE_sleb128:
			result = getSLEB128(addr, end);
			break;
		case DW_EH_PE_sdata2:
			result = (int16_t)get16(addr);
			p += 2;
			addr = (pint_t)p;
			break;
		case DW_EH_PE_sdata4:
			result = (int32_t)get32(addr);
			p += 4;
			addr = (pint_t)p;
			break;
		case DW_EH_PE_sdata8:
			result = get64(addr);
			p += 8;
			addr = (pint_t)p;
			break;
		default:
			throwf("ObjectFileAddressSpace<A>::getEncodedP() encoding 0x%08X not supported", encoding);
	}
	
	// then add relative offset
	switch ( encoding & 0x70 ) {
		case DW_EH_PE_absptr:
			// do nothing
			break;
		case DW_EH_PE_pcrel:
			result += startAddr;
			break;
		case DW_EH_PE_textrel:
			throw "DW_EH_PE_textrel pointer encoding not supported";
			break;
		case DW_EH_PE_datarel:
			throw "DW_EH_PE_datarel pointer encoding not supported";
			break;
		case DW_EH_PE_funcrel:
			throw "DW_EH_PE_funcrel pointer encoding not supported";
			break;
		case DW_EH_PE_aligned:
			throw "DW_EH_PE_aligned pointer encoding not supported";
			break;
		default:
			throwf("ObjectFileAddressSpace<A>::getEncodedP() encoding 0x%08X not supported", encoding);
			break;
	}
	
	if ( encoding & DW_EH_PE_indirect )
		result = getP(result);
	
	return result;
}

template <>
uint32_t SymbolAtom<x86>::getCompactUnwindEncoding(uint64_t ehAtomAddress)
{
	pint_t lsda;
	pint_t personality;
	char warningBuffer[1024];
	uint32_t result = libunwind::DwarfInstructions<class ObjectFileAddressSpace<x86>, libunwind::Registers_x86>::createCompactEncodingFromFDE(
											fOwner.fObjectAddressSpace, ehAtomAddress, &lsda, &personality, warningBuffer);
	if ( (result & UNWIND_X86_MODE_MASK) == UNWIND_X86_MODE_DWARF ) {
		//if ( fOwner.fOptions.fForDyld )
		//	throwf("can't make compact unwind encoding from dwarf for %s",  this->getDisplayName());
		//else
			if ( fOwner.fOptions.fWarnCompactUnwind )
				warning("can't make compact unwind encoding from dwarf for %s in %s because %s", this->getDisplayName(), fOwner.getPath(), warningBuffer);
	}
	return result;
}

template <>
uint32_t SymbolAtom<x86_64>::getCompactUnwindEncoding(uint64_t ehAtomAddress)
{
	pint_t lsda;
	pint_t personality;
	char warningBuffer[1024];
	uint32_t result = libunwind::DwarfInstructions<class ObjectFileAddressSpace<x86_64>, libunwind::Registers_x86_64>::createCompactEncodingFromFDE(
											fOwner.fObjectAddressSpace, ehAtomAddress, &lsda, &personality, warningBuffer);
	if ( (result & UNWIND_X86_64_MODE_MASK) == UNWIND_X86_64_MODE_DWARF ) {
		//if ( fOwner.fOptions.fForDyld )
		//	throwf("can't make compact unwind encoding from dwarf for %s",  this->getDisplayName());
		//else
			if ( fOwner.fOptions.fWarnCompactUnwind )
				warning("can't make compact unwind encoding from dwarf for %s in %s because %s", this->getDisplayName(), fOwner.getPath(), warningBuffer);
	}
	return result;
}

template <>
uint32_t SymbolAtom<ppc>::getCompactUnwindEncoding(uint64_t ehAtomAddress)
{
	// compact encoding not supported for ppc
	return 0;
}

template <>
uint32_t SymbolAtom<ppc64>::getCompactUnwindEncoding(uint64_t ehAtomAddress)
{
	// compact encoding not supported for ppc64
	return 0;
}

template <>
uint32_t SymbolAtom<arm>::getCompactUnwindEncoding(uint64_t ehAtomAddress)
{
	// compact encoding not supported for arm
	return 0;
}


template <typename A>
uint8_t SymbolAtom<A>::getLSDAReferenceKind() const 
{
	return A::kGroupSubordinate;
}

template <>
uint8_t SymbolAtom<x86_64>::getPersonalityReferenceKind() const
{
	return x86_64::kGOTNoFixUp;
}

template <>
uint8_t SymbolAtom<x86>::getPersonalityReferenceKind() const
{
	return x86::kNoFixUp;
}

template <typename A>
uint8_t SymbolAtom<A>::getPersonalityReferenceKind() const
{
	// only used with architectures that support compact unwinding 
	return 0;
}


template <>
uint32_t AnonymousAtom<x86>::getCompactUnwindEncoding(uint64_t ehAtomAddress)
{
	pint_t lsda;
	pint_t personality;
	char warningBuffer[1024];
	uint32_t result = libunwind::DwarfInstructions<class ObjectFileAddressSpace<x86>, libunwind::Registers_x86>::createCompactEncodingFromFDE(
											fOwner.fObjectAddressSpace, ehAtomAddress, &lsda, &personality, warningBuffer);
	if ( (result & UNWIND_X86_MODE_MASK) == UNWIND_X86_MODE_DWARF ) {
		//if ( fOwner.fOptions.fForDyld )
		//	throwf("can't make compact unwind encoding from dwarf for %s",  this->getDisplayName());
		//else
		if ( fOwner.fOptions.fWarnCompactUnwind )
			warning("can't make compact unwind encoding from dwarf for %s in %s", this->getDisplayName(), fOwner.getPath());
	}
	return result;
}

template <>
uint32_t AnonymousAtom<x86_64>::getCompactUnwindEncoding(uint64_t ehAtomAddress)
{
	pint_t lsda;
	pint_t personality;
	char warningBuffer[1024];
	uint32_t result = libunwind::DwarfInstructions<class ObjectFileAddressSpace<x86_64>, libunwind::Registers_x86_64>::createCompactEncodingFromFDE(
												fOwner.fObjectAddressSpace, ehAtomAddress, &lsda, &personality, warningBuffer);
	if ( (result & UNWIND_X86_64_MODE_MASK) == UNWIND_X86_64_MODE_DWARF ) {
		//if ( fOwner.fOptions.fForDyld )
		//	throwf("can't make compact unwind encoding from dwarf for %s",  this->getDisplayName());
		//else
		if ( fOwner.fOptions.fWarnCompactUnwind )
			warning("can't make compact unwind encoding from dwarf for %s in %s", this->getDisplayName(), fOwner.getPath());
	}
	return result;
}

template <>
uint32_t AnonymousAtom<ppc>::getCompactUnwindEncoding(uint64_t ehAtomAddress)
{
	// compact encoding not supported for ppc
	return 0;
}

template <>
uint32_t AnonymousAtom<ppc64>::getCompactUnwindEncoding(uint64_t ehAtomAddress)
{
	// compact encoding not supported for ppc64
	return 0;
}

template <>
uint32_t AnonymousAtom<arm>::getCompactUnwindEncoding(uint64_t ehAtomAddress)
{
	// compact encoding not supported for arm
	return 0;
}


template <typename A>
uint8_t AnonymousAtom<A>::getLSDAReferenceKind() const 
{
	return A::kGroupSubordinate;
}

template <>
uint8_t AnonymousAtom<x86_64>::getPersonalityReferenceKind() const
{
	return x86_64::kGOTNoFixUp;
}

template <>
uint8_t AnonymousAtom<x86>::getPersonalityReferenceKind() const
{
	return x86::kNoFixUp;
}

template <typename A>
uint8_t AnonymousAtom<A>::getPersonalityReferenceKind() const
{
	// only used with architectures that support compact unwinding 
	return 0;
}







template <>
void Reader<ppc>::setCpuConstraint(uint32_t cpusubtype)
{
	switch (cpusubtype) {
		case CPU_SUBTYPE_POWERPC_ALL:
		case CPU_SUBTYPE_POWERPC_750:
		case CPU_SUBTYPE_POWERPC_7400:
		case CPU_SUBTYPE_POWERPC_7450:
		case CPU_SUBTYPE_POWERPC_970:
			fCpuConstraint = cpusubtype;
			break;
		default:
			warning("unknown ppc subtype 0x%08X in %s, defaulting to ALL", cpusubtype, fPath);
			fCpuConstraint = CPU_SUBTYPE_POWERPC_ALL;
            break;
	}
}

template <>
void Reader<arm>::setCpuConstraint(uint32_t cpusubtype)
{
	switch (cpusubtype) {
		case CPU_SUBTYPE_ARM_ALL:
		case CPU_SUBTYPE_ARM_V4T:
		case CPU_SUBTYPE_ARM_V5TEJ:
		case CPU_SUBTYPE_ARM_V6:
		case CPU_SUBTYPE_ARM_XSCALE:
		case CPU_SUBTYPE_ARM_V7:
			fCpuConstraint = cpusubtype;
			break;
		default:
			warning("unknown arm subtype 0x%08X in %s, defaulting to ALL", cpusubtype, fPath);
			fCpuConstraint = CPU_SUBTYPE_ARM_ALL;
            break;
	}
}

template <typename A>
void Reader<A>::setCpuConstraint(uint32_t cpusubtype)
{
	// no cpu sub types for this architecture
}

template <>
uint32_t Reader<ppc>::updateCpuConstraint(uint32_t previous)
{
	switch ( previous ) {
    case CPU_SUBTYPE_POWERPC_ALL:
        return fCpuConstraint;
        break;
    case CPU_SUBTYPE_POWERPC_750:
        if ( fCpuConstraint == CPU_SUBTYPE_POWERPC_7400 ||
             fCpuConstraint == CPU_SUBTYPE_POWERPC_7450 ||
             fCpuConstraint == CPU_SUBTYPE_POWERPC_970 )
            return fCpuConstraint;
        break;
    case CPU_SUBTYPE_POWERPC_7400:
    case CPU_SUBTYPE_POWERPC_7450:
        if ( fCpuConstraint == CPU_SUBTYPE_POWERPC_970 )
            return fCpuConstraint;
        break;
    case CPU_SUBTYPE_POWERPC_970:
        // G5 can run everything
        break;
    default:
        throw "Unhandled PPC cpu subtype!";
        break;
	}
    return previous;
}



template <>
uint32_t Reader<arm>::updateCpuConstraint(uint32_t previous)
{
    switch (previous) {
		case CPU_SUBTYPE_ARM_ALL:
			return fCpuConstraint;
			break;
		case CPU_SUBTYPE_ARM_V5TEJ:
			// v6, v7, and xscale are more constrained than previous file (v5), so use it
			if (   (fCpuConstraint == CPU_SUBTYPE_ARM_V6)
				|| (fCpuConstraint == CPU_SUBTYPE_ARM_V7) 
				|| (fCpuConstraint == CPU_SUBTYPE_ARM_XSCALE) )
				return fCpuConstraint;
			break;
		case CPU_SUBTYPE_ARM_V4T:
			// v5, v6, v7, and xscale are more constrained than previous file (v4t), so use it
			if (   (fCpuConstraint == CPU_SUBTYPE_ARM_V7)
				|| (fCpuConstraint == CPU_SUBTYPE_ARM_V6)
				|| (fCpuConstraint == CPU_SUBTYPE_ARM_V5TEJ)
				|| (fCpuConstraint == CPU_SUBTYPE_ARM_XSCALE) )
				return fCpuConstraint;
			break;
		case CPU_SUBTYPE_ARM_V6:
			// v6 can run everything except xscale and v7
			if ( fCpuConstraint == CPU_SUBTYPE_ARM_XSCALE )
				throw "can't mix xscale and v6 code";
			if ( fCpuConstraint == CPU_SUBTYPE_ARM_V7 )
				return fCpuConstraint;
			break;
		case CPU_SUBTYPE_ARM_XSCALE:
			// xscale can run everything except v6 and v7
			if ( fCpuConstraint == CPU_SUBTYPE_ARM_V6 )
				throw "can't mix xscale and v6 code";
			if ( fCpuConstraint == CPU_SUBTYPE_ARM_V7 )
				throw "can't mix xscale and v7 code";
			break;
		case CPU_SUBTYPE_ARM_V7:
			// v7 can run everything except xscale
			if ( fCpuConstraint == CPU_SUBTYPE_ARM_XSCALE )
				throw "can't mix xscale and v7 code";
			break;
		default:
			throw "Unhandled ARM cpu subtype!";
    }
    return previous;
}

template <typename A>
uint32_t Reader<A>::updateCpuConstraint(uint32_t current)
{
	// no cpu sub types for this architecture
	return current;
}

template <typename A>
void Reader<A>::addDtraceExtraInfos(uint32_t probeAddr, const char* providerName)
{
	// for every ___dtrace_stability$* and ___dtrace_typedefs$* undefine with
	// a matching provider name, add a by-name kDtraceTypeReference at probe site
 	const char* dollar = strchr(providerName, '$');
	if ( dollar != NULL ) {
		int providerNameLen = dollar-providerName+1;
		for ( std::vector<const char*>::iterator it = fDtraceProviderInfo.begin(); it != fDtraceProviderInfo.end(); ++it) {
			const char* typeDollar = strchr(*it, '$');
			if ( typeDollar != NULL ) {
				if ( strncmp(typeDollar+1, providerName, providerNameLen) == 0 ) {
					makeByNameReference(A::kDtraceTypeReference, probeAddr, *it, 0);
				}
			}
		}
	}
}


template <>
void Reader<x86_64>::validSectionType(uint8_t type)
{
	switch ( type ) {
		case S_SYMBOL_STUBS:
			throw "symbol_stub sections not valid in x86_64 object files";
		case S_LAZY_SYMBOL_POINTERS:
			throw "lazy pointer sections not valid in x86_64 object files";
		case S_NON_LAZY_SYMBOL_POINTERS:
			throw "non lazy pointer sections not valid in x86_64 object files";
	}
}

template <typename A>
void Reader<A>::validSectionType(uint8_t type)
{
}

template <typename A>
bool Reader<A>::getTranslationUnitSource(const char** dir, const char** name) const
{
	if ( fDebugInfo == kDebugInfoDwarf ) {
		*dir = fDwarfTranslationUnitDir;
		*name = fDwarfTranslationUnitFile;
		return (fDwarfTranslationUnitFile != NULL);
	}
	return false;
}

template <typename A>
BaseAtom* Reader<A>::findAtomByName(const char* name)
{
	// first search the more important atoms
	for (typename AddrToAtomMap::iterator it=fAddrToAtom.begin(); it != fAddrToAtom.end(); it++) {
		const char* atomName = it->second->getName();
		if ( (atomName != NULL) && (strcmp(atomName, name) == 0) ) {
			return it->second;
		}
	}
	// try all atoms, because this might have been a tentative definition
	for (std::vector<BaseAtom*>::iterator it=fAtoms.begin(); it != fAtoms.end(); it++) {
		BaseAtom* atom = (BaseAtom*)(*it);
		const char* atomName = atom->getName();
		if ( (atomName != NULL) && (strcmp(atomName, name) == 0) ) {
			return atom;
		}
	}
	return NULL;
}

template <typename A>
Reference<A>* Reader<A>::makeReference(Kinds kind, pint_t atAddr, pint_t toAddr)
{
	return new Reference<A>(kind, findAtomAndOffset(atAddr), findAtomAndOffset(toAddr));
}

template <typename A>
Reference<A>* Reader<A>::makeReference(Kinds kind, pint_t atAddr, pint_t fromAddr, pint_t toAddr)
{
	return new Reference<A>(kind, findAtomAndOffset(atAddr), findAtomAndOffset(fromAddr), findAtomAndOffset(toAddr));
}

template <typename A>
Reference<A>* Reader<A>::makeReferenceWithToBase(Kinds kind, pint_t atAddr, pint_t toAddr, pint_t toBaseAddr)
{
	return new Reference<A>(kind, findAtomAndOffset(atAddr), findAtomAndOffset(toBaseAddr, toAddr));
}

template <typename A>
Reference<A>* Reader<A>::makeReferenceWithToBase(Kinds kind, pint_t atAddr, pint_t fromAddr, pint_t toAddr, pint_t toBaseAddr)
{
	return new Reference<A>(kind, findAtomAndOffset(atAddr), findAtomAndOffset(fromAddr), findAtomAndOffset(toBaseAddr, toAddr));
}

template <typename A>
Reference<A>* Reader<A>::makeByNameReference(Kinds kind, pint_t atAddr, const char* toName, uint32_t toOffset)
{
	return new Reference<A>(kind, findAtomAndOffset(atAddr), toName, toOffset);
}

template <typename A>
BaseAtom* Reader<A>::makeReferenceToEH(const char* ehName, pint_t ehAtomAddress, const macho_section<P>* ehSect)
{
	// add a group subordinate reference from function atom to its eh frame atom
	const uint8_t* ehContent = (const uint8_t*)(fHeader) + ehAtomAddress - ehSect->addr() + ehSect->offset();
	int32_t deltaMinus8 = P::getP(*(pint_t*)(&ehContent[8]));	// offset 8 in eh info is delta to function
	pint_t funcAddr = ehAtomAddress + deltaMinus8 + 8;
	ObjectFile::Atom* funcAtom = findAtomAndOffset(funcAddr).atom;
	ObjectFile::Atom* ehAtom = findAtomAndOffset(ehAtomAddress).atom;
	new Reference<A>(A::kGroupSubordinate, funcAtom, ehAtom);
	return (BaseAtom*)funcAtom;
}


template <>
Reference<x86_64>* Reader<x86_64>::makeByNameReference(Kinds kind, pint_t atAddr, const char* toName, uint32_t toOffset)
{
	// x86_64 uses external relocations everywhere, so external relocations do not imply by-name references
	// instead check scope of target
	BaseAtom* target = findAtomByName(toName);
	if ( (target != NULL) && (target->getScope() == ObjectFile::Atom::scopeTranslationUnit) )
		return new Reference<x86_64>(kind, findAtomAndOffset(atAddr), AtomAndOffset(target, toOffset));
	else
		return new Reference<x86_64>(kind, findAtomAndOffset(atAddr), toName, toOffset);
}

template <>
Reference<x86_64>* Reader<x86_64>::makeReferenceToSymbol(Kinds kind, pint_t atAddr, const macho_nlist<P>* toSymbol, pint_t toOffset)
{
	// x86_64 uses external relocations everywhere, so external relocations do not imply by-name references
	// instead check scope of target
	const char* symbolName = &fStrings[toSymbol->n_strx()];
	if ( ((toSymbol->n_type() & N_TYPE) == N_SECT) && (((toSymbol->n_type() & N_EXT) == 0) || (symbolName[0] == 'L')) ) 
		return new Reference<x86_64>(kind, findAtomAndOffset(atAddr), findAtomAndOffset(toSymbol->n_value(), toSymbol->n_value()+toOffset));
	else
		return new Reference<x86_64>(kind, findAtomAndOffset(atAddr), symbolName, toOffset);
}


template <>
BaseAtom* Reader<x86_64>::makeReferenceToEH(const char* ehName, pint_t ehAtomAddress, const macho_section<P>* ehSect)
{
	// add a group subordinate reference from function atom to its eh frame atom
	// for x86_64 the __eh_frame section contains the addends, so need to use relocs to find target
	uint32_t ehAtomDeltaSectionOffset = ehAtomAddress + 8 - ehSect->addr(); // offset 8 in eh info is delta to function
	const macho_relocation_info<P>* relocs = (macho_relocation_info<P>*)((char*)(fHeader) + ehSect->reloff());
	const macho_relocation_info<P>* relocsEnd = &relocs[ehSect->nreloc()];
	for (const macho_relocation_info<P>* reloc = relocs; reloc < relocsEnd; ++reloc) {
		if ( (reloc->r_address() == ehAtomDeltaSectionOffset) && (reloc->r_type() == X86_64_RELOC_UNSIGNED) ) {
			pint_t funcAddr = fSymbols[reloc->r_symbolnum()].n_value();
			ObjectFile::Atom* funcAtom = findAtomAndOffset(funcAddr).atom;
			ObjectFile::Atom* ehAtom = findAtomAndOffset(ehAtomAddress).atom;
			new Reference<x86_64>(x86_64::kGroupSubordinate, funcAtom, ehAtom);
			return (BaseAtom*)funcAtom;
		}
	}
	warning("can't find matching function for eh symbol %s", ehName);
	return NULL;
}


template <typename A>
AtomAndOffset Reader<A>::findAtomAndOffset(pint_t addr)
{
	// STL has no built-in for "find largest key that is same or less than"
	typename AddrToAtomMap::iterator it = fAddrToAtom.upper_bound(addr);
	// if no atoms up to this address return none found
	if ( it == fAddrToAtom.begin() ) 
		return AtomAndOffset(NULL);
	// otherwise upper_bound gets us next key, so we back up one	
	--it;
	AtomAndOffset result;
	result.atom = it->second;
	result.offset = addr - it->first;
	//fprintf(stderr, "findAtomAndOffset(0x%0llX) ==> %s (0x%0llX -> 0x%0llX)\n",
	//			(uint64_t)addr, result.atom->getDisplayName(), (uint64_t)it->first, it->first+result.atom->getSize());
	return result;
}

// "scattered" relocations enable you to offset into an atom past the end of it
// baseAddr is the address of the target atom,
// realAddr is the points into it
template <typename A>
AtomAndOffset Reader<A>::findAtomAndOffset(pint_t baseAddr, pint_t realAddr)
{
	typename AddrToAtomMap::iterator it = fAddrToAtom.find(baseAddr);
	if ( it != fAddrToAtom.end() ) {
		AtomAndOffset result;
		result.atom = it->second;
		result.offset = realAddr - it->first;
		if ( result.atom->isThumb() )
			result.offset &= -2;
		//fprintf(stderr, "findAtomAndOffset(0x%08X, 0x%08X) => %s + 0x%08X\n", baseAddr, realAddr, result.atom->getDisplayName(), result.offset);
		return result;
	}
	// getting here means we have a scattered relocation to an address without a label
	// so, find the atom that contains the baseAddr, and offset from that to the readAddr
	AtomAndOffset result = findAtomAndOffset(baseAddr);
	result.offset += (realAddr-baseAddr);
	return result;
}


/* Skip over a LEB128 value (signed or unsigned).  */
static void
skip_leb128 (const uint8_t ** offset, const uint8_t * end)
{
  while (*offset != end && **offset >= 0x80)
    (*offset)++;
  if (*offset != end)
    (*offset)++;
}

/* Read a ULEB128 into a 64-bit word.  Return (uint64_t)-1 on overflow
   or error.  On overflow, skip past the rest of the uleb128.  */
static uint64_t
read_uleb128 (const uint8_t ** offset, const uint8_t * end)
{
  uint64_t result = 0;
  int bit = 0;

  do  {
    uint64_t b;

    if (*offset == end)
      return (uint64_t) -1;

    b = **offset & 0x7f;

    if (bit >= 64 || b << bit >> bit != b)
      result = (uint64_t) -1;
    else
      result |= b << bit, bit += 7;
  } while (*(*offset)++ >= 0x80);
  return result;
}


/* Skip over a DWARF attribute of form FORM.  */
template <typename A>
bool Reader<A>::skip_form(const uint8_t ** offset, const uint8_t * end, uint64_t form,
							uint8_t addr_size, bool dwarf64)
{
  int64_t sz=0;

  switch (form)
    {
    case DW_FORM_addr:
      sz = addr_size;
      break;

    case DW_FORM_block2:
      if (end - *offset < 2)
	return false;
      sz = 2 + A::P::E::get16(*(uint16_t*)offset);
      break;

    case DW_FORM_block4:
      if (end - *offset < 4)
	return false;
      sz = 2 + A::P::E::get32(*(uint32_t*)offset);
      break;

    case DW_FORM_data2:
    case DW_FORM_ref2:
      sz = 2;
      break;

    case DW_FORM_data4:
    case DW_FORM_ref4:
      sz = 4;
      break;

    case DW_FORM_data8:
    case DW_FORM_ref8:
      sz = 8;
      break;

    case DW_FORM_string:
      while (*offset != end && **offset)
	++*offset;
    case DW_FORM_data1:
    case DW_FORM_flag:
    case DW_FORM_ref1:
      sz = 1;
      break;

    case DW_FORM_block:
      sz = read_uleb128 (offset, end);
      break;

    case DW_FORM_block1:
      if (*offset == end)
	return false;
      sz = 1 + **offset;
      break;

    case DW_FORM_sdata:
    case DW_FORM_udata:
    case DW_FORM_ref_udata:
      skip_leb128 (offset, end);
      return true;

    case DW_FORM_strp:
    case DW_FORM_ref_addr:
      sz = 4;
      break;

    default:
      return false;
    }
  if (end - *offset < sz)
    return false;
  *offset += sz;
  return true;
}

template <typename A>
const char* Reader<A>::getDwarfString(uint64_t form, const uint8_t* p)
{
	if ( form == DW_FORM_string )
		return (const char*)p;
	else if ( form == DW_FORM_strp ) {
		uint32_t offset = E::get32(*((uint32_t*)p));
		const char* dwarfStrings = (char*)(fHeader) + fDwarfDebugStringSect->offset();
		if ( offset > fDwarfDebugStringSect->size() ) {
			warning("unknown dwarf DW_FORM_strp (offset=0x%08X) is too big in %s\n", offset, this->getPath());
			return NULL;
		}
		return &dwarfStrings[offset];
	}
	warning("unknown dwarf string encoding (form=%lld) in %s\n", form, this->getPath());
	return NULL;
}


// Look at the compilation unit DIE and determine
// its NAME, compilation directory (in COMP_DIR) and its
// line number information offset (in STMT_LIST).  NAME and COMP_DIR
// may be NULL (especially COMP_DIR) if they are not in the .o file;
// STMT_LIST will be (uint64_t) -1.
//
// At present this assumes that there's only one compilation unit DIE.
//
template <typename A>
bool Reader<A>::read_comp_unit(const char ** name, const char ** comp_dir,
							uint64_t *stmt_list)
{
	const uint8_t * debug_info;
	const uint8_t * debug_abbrev;
	const uint8_t * di;
	const uint8_t * da;
	const uint8_t * end;
	const uint8_t * enda;
	uint64_t sz;
	uint16_t vers;
	uint64_t abbrev_base;
	uint64_t abbrev;
	uint8_t address_size;
	bool dwarf64;

	*name = NULL;
	*comp_dir = NULL;
	*stmt_list = (uint64_t) -1;

	if ( (fDwarfDebugInfoSect == NULL) || (fDwarfDebugAbbrevSect == NULL) )
		return false;

	debug_info = (uint8_t*)(fHeader) + fDwarfDebugInfoSect->offset();
	debug_abbrev = (uint8_t*)(fHeader) + fDwarfDebugAbbrevSect->offset();
	di = debug_info;

	if (fDwarfDebugInfoSect->size() < 12)
		/* Too small to be a real debug_info section.  */
		return false;
	sz = A::P::E::get32(*(uint32_t*)di);
	di += 4;
	dwarf64 = sz == 0xffffffff;
	if (dwarf64)
		sz = A::P::E::get64(*(uint64_t*)di), di += 8;
	else if (sz > 0xffffff00)
		/* Unknown dwarf format.  */
		return false;

	/* Verify claimed size.  */
	if (sz + (di - debug_info) > fDwarfDebugInfoSect->size() || sz <= (dwarf64 ? 23 : 11))
		return false;

	vers = A::P::E::get16(*(uint16_t*)di);
	if (vers < 2 || vers > 3)
	/* DWARF version wrong for this code.
	   Chances are we could continue anyway, but we don't know for sure.  */
		return false;
	di += 2;

	/* Find the debug_abbrev section.  */
	abbrev_base = dwarf64 ? A::P::E::get64(*(uint64_t*)di) : A::P::E::get32(*(uint32_t*)di);
	di += dwarf64 ? 8 : 4;

	if (abbrev_base > fDwarfDebugAbbrevSect->size())
		return false;
	da = debug_abbrev + abbrev_base;
	enda = debug_abbrev + fDwarfDebugAbbrevSect->size();

	address_size = *di++;

	/* Find the abbrev number we're looking for.  */
	end = di + sz;
	abbrev = read_uleb128 (&di, end);
	if (abbrev == (uint64_t) -1)
		return false;

	/* Skip through the debug_abbrev section looking for that abbrev.  */
	for (;;)
	{
		uint64_t this_abbrev = read_uleb128 (&da, enda);
		uint64_t attr;

		if (this_abbrev == abbrev)
			/* This is almost always taken.  */
			break;
		skip_leb128 (&da, enda); /* Skip the tag.  */
		if (da == enda)
			return false;
		da++;  /* Skip the DW_CHILDREN_* value.  */

		do {
			attr = read_uleb128 (&da, enda);
			skip_leb128 (&da, enda);
		} while (attr != 0 && attr != (uint64_t) -1);
		if (attr != 0)
			return false;
	}

	/* Check that the abbrev is one for a DW_TAG_compile_unit.  */
	if (read_uleb128 (&da, enda) != DW_TAG_compile_unit)
	return false;
	if (da == enda)
	return false;
	da++;  /* Skip the DW_CHILDREN_* value.  */

	/* Now, go through the DIE looking for DW_AT_name,
	 DW_AT_comp_dir, and DW_AT_stmt_list.  */
	for (;;)
	{
		uint64_t attr = read_uleb128 (&da, enda);
		uint64_t form = read_uleb128 (&da, enda);

		if (attr == (uint64_t) -1)
			return false;
		else if (attr == 0)
			return true;

		if (form == DW_FORM_indirect)
			form = read_uleb128 (&di, end);

		if (attr == DW_AT_name)
			*name = getDwarfString(form, di);
		else if (attr == DW_AT_comp_dir)
			*comp_dir = getDwarfString(form, di);
		else if (attr == DW_AT_stmt_list && form == DW_FORM_data4)
			*stmt_list = A::P::E::get32(*(uint32_t*)di);
		else if (attr == DW_AT_stmt_list && form == DW_FORM_data8)
			*stmt_list = A::P::E::get64(*(uint64_t*)di);
		if (! skip_form (&di, end, form, address_size, dwarf64))
			return false;
	}
}

template <typename A>
const char* Reader<A>::assureFullPath(const char* path)
{
	if ( path[0] == '/' )
		return path;
	char cwdbuff[MAXPATHLEN];
	if ( getcwd(cwdbuff, MAXPATHLEN) != NULL ) {
		char* result;
		asprintf(&result, "%s/%s", cwdbuff, path);
		if ( result != NULL )
			return result;
	}
	return path;
}


//
//
//	To implement architecture xxx, you must write template specializations for the following six methods:
//			Reader<xxx>::validFile()
//			Reader<xxx>::addRelocReference()
//			Reference<xxx>::getDescription()
//
//


template <>
bool Reader<ppc>::validFile(const uint8_t* fileContent, bool, cpu_subtype_t)
{
	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;
	if ( header->filetype() != MH_OBJECT )
		return false;
	return true;
}

template <>
bool Reader<ppc64>::validFile(const uint8_t* fileContent, bool, cpu_subtype_t)
{
	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;
	if ( header->filetype() != MH_OBJECT )
		return false;
	return true;
}

template <>
bool Reader<x86>::validFile(const uint8_t* fileContent, bool, cpu_subtype_t)
{
	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;
	if ( header->filetype() != MH_OBJECT )
		return false;
	return true;
}

template <>
bool Reader<x86_64>::validFile(const uint8_t* fileContent, bool, cpu_subtype_t)
{
	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;
	if ( header->filetype() != MH_OBJECT )
		return false;
	return true;
}

template <>
bool Reader<arm>::validFile(const uint8_t* fileContent, bool subtypeMustMatch, cpu_subtype_t subtype)
{
	const macho_header<P>* header = (const macho_header<P>*)fileContent;
	if ( header->magic() != MH_MAGIC )
		return false;
	if ( header->cputype() != CPU_TYPE_ARM )
		return false;
	if ( header->filetype() != MH_OBJECT )
		return false;
	if ( subtypeMustMatch && ((cpu_subtype_t)header->cpusubtype() != subtype) )
		return false;
	return true;
}

template <typename A>
bool Reader<A>::isWeakImportSymbol(const macho_nlist<P>* sym)
{
	return ( ((sym->n_type() & N_TYPE) == N_UNDF) && ((sym->n_desc() & N_WEAK_REF) != 0) );
}

template <>
bool Reader<ppc64>::addRelocReference(const macho_section<ppc64::P>* sect, const macho_relocation_info<ppc64::P>* reloc)
{
	return addRelocReference_powerpc(sect, reloc);
}

template <>
bool Reader<ppc>::addRelocReference(const macho_section<ppc::P>* sect, const macho_relocation_info<ppc::P>* reloc)
{
	return addRelocReference_powerpc(sect, reloc);
}


//
// ppc and ppc64 both use the same relocations, so process them in one common routine
//
template <typename A>
bool Reader<A>::addRelocReference_powerpc(const macho_section<typename A::P>* sect,
										  const macho_relocation_info<typename A::P>* reloc)
{
	uint32_t srcAddr;
	uint32_t dstAddr;
	uint32_t* fixUpPtr;
	int32_t displacement = 0;
	uint32_t instruction = 0;
	uint32_t offsetInTarget;
	int16_t lowBits;
	bool result = false;
	if ( (reloc->r_address() & R_SCATTERED) == 0 ) {
		const macho_relocation_info<P>* nextReloc = &reloc[1];
		const char* targetName = NULL;
		bool weakImport = false;
		fixUpPtr = (uint32_t*)((char*)(fHeader) + sect->offset() + reloc->r_address());
		if ( reloc->r_type() != PPC_RELOC_PAIR )
			instruction = BigEndian::get32(*fixUpPtr);
		srcAddr = sect->addr() + reloc->r_address();
		if ( reloc->r_extern() ) {
			const macho_nlist<P>* targetSymbol = &fSymbols[reloc->r_symbolnum()];
			targetName = &fStrings[targetSymbol->n_strx()];
			weakImport = this->isWeakImportSymbol(targetSymbol);
		}
		switch ( reloc->r_type() ) {
			case PPC_RELOC_BR24:
				{
					if ( (instruction & 0x4C000000) == 0x48000000 ) {
						displacement = (instruction & 0x03FFFFFC);
						if ( (displacement & 0x02000000) != 0 )
							displacement |= 0xFC000000;
					}
					else {
						printf("bad instruction for BR24 reloc");
					}
					if ( reloc->r_extern() ) {
						offsetInTarget = srcAddr + displacement;
						if ( strncmp(targetName, "___dtrace_probe$", 16) == 0 ) {
							makeByNameReference(A::kDtraceProbeSite, srcAddr, targetName, 0);
							addDtraceExtraInfos(srcAddr, &targetName[16]);
						}
						else if ( strncmp(targetName, "___dtrace_isenabled$", 20) == 0 ) {
							makeByNameReference(A::kDtraceIsEnabledSite, srcAddr, targetName, 0);
							addDtraceExtraInfos(srcAddr, &targetName[20]);
						}
						else if ( weakImport )
							makeByNameReference(A::kBranch24WeakImport, srcAddr, targetName, offsetInTarget);
						else
							makeByNameReference(A::kBranch24, srcAddr, targetName, offsetInTarget);
					}
					else {
						dstAddr = srcAddr + displacement;
						// if this is a branch to a stub, we need to see if the stub is for a weak imported symbol
						ObjectFile::Atom* atom = findAtomAndOffset(dstAddr).atom;
						targetName = atom->getName();
						if ( (targetName != NULL) && (strncmp(targetName, "___dtrace_probe$", 16) == 0) ) {
							makeByNameReference(A::kDtraceProbeSite, srcAddr, targetName, 0);
							addDtraceExtraInfos(srcAddr, &targetName[16]);
						}
						else if ( (targetName != NULL) && (strncmp(targetName, "___dtrace_isenabled$", 20) == 0) ) {
							makeByNameReference(A::kDtraceIsEnabledSite, srcAddr, targetName, 0);
							addDtraceExtraInfos(srcAddr, &targetName[20]);
						}
						else if ( (atom->getSymbolTableInclusion() == ObjectFile::Atom::kSymbolTableNotIn)
							&& ((AnonymousAtom<A>*)atom)->isWeakImportStub() )
							makeReference(A::kBranch24WeakImport, srcAddr, dstAddr);
						else
							makeReference(A::kBranch24, srcAddr, dstAddr);
					}
				}
				break;
			case PPC_RELOC_BR14:
				{
					displacement = (instruction & 0x0000FFFC);
					if ( (displacement & 0x00008000) != 0 )
						displacement |= 0xFFFF0000;
					if ( reloc->r_extern() ) {
						offsetInTarget = srcAddr + displacement;
						makeByNameReference(A::kBranch14, srcAddr, targetName, offsetInTarget);
					}
					else {
						dstAddr = srcAddr + displacement;
						makeReference(A::kBranch14, srcAddr, dstAddr);
					}
				}
				break;
			case PPC_RELOC_PAIR:
				// skip, processed by a previous look ahead
				break;
			case PPC_RELOC_LO16:
				{
					if ( nextReloc->r_type() != PPC_RELOC_PAIR ) {
						throw "PPC_RELOC_LO16 missing following pair";
					}
					result = true;
					lowBits = (instruction & 0xFFFF);
					if ( reloc->r_extern() ) {
						offsetInTarget = (nextReloc->r_address() << 16) | ((uint32_t)lowBits & 0x0000FFFF);
						makeByNameReference(A::kAbsLow16, srcAddr, targetName, offsetInTarget);
					}
					else {
						dstAddr = (nextReloc->r_address() << 16) + ((uint32_t)lowBits & 0x0000FFFF);
						if ( reloc->r_symbolnum() == R_ABS ) {
							// find absolute symbol that corresponds to pointerValue
							typename AddrToAtomMap::iterator pos = fAddrToAbsoluteAtom.find(dstAddr);
							if ( pos != fAddrToAbsoluteAtom.end() ) 
								makeByNameReference(A::kAbsLow16, srcAddr, pos->second->getName(), 0);
							else
								makeReference(A::kAbsLow16, srcAddr, dstAddr);
						}
						else {
							makeReference(A::kAbsLow16, srcAddr, dstAddr);
						}
					}
				}
				break;
			case PPC_RELOC_LO14:
				{
					if ( nextReloc->r_type() != PPC_RELOC_PAIR ) {
						throw "PPC_RELOC_LO14 missing following pair";
					}
					result = true;
					lowBits = (instruction & 0xFFFC);
					if ( reloc->r_extern() ) {
						offsetInTarget = (nextReloc->r_address() << 16) | ((uint32_t)lowBits & 0x0000FFFF);
						makeByNameReference(A::kAbsLow14, srcAddr, targetName, offsetInTarget);
					}
					else {
						dstAddr = (nextReloc->r_address() << 16) | ((uint32_t)lowBits & 0x0000FFFF);
						if ( reloc->r_symbolnum() == R_ABS ) {
							// find absolute symbol that corresponds to pointerValue
							typename AddrToAtomMap::iterator pos = fAddrToAbsoluteAtom.find(dstAddr);
							if ( pos != fAddrToAbsoluteAtom.end() ) 
								makeByNameReference(A::kAbsLow14, srcAddr, pos->second->getName(), 0);
							else
								makeReference(A::kAbsLow14, srcAddr, dstAddr);
						}
						else {
							makeReference(A::kAbsLow14, srcAddr, dstAddr);
						}
					}
				}
				break;
			case PPC_RELOC_HI16:
				{
					if ( nextReloc->r_type() != PPC_RELOC_PAIR ) {
						throw "PPC_RELOC_HI16 missing following pair";
					}
					result = true;
					if ( reloc->r_extern() ) {
						offsetInTarget = ((instruction & 0x0000FFFF) << 16) | (nextReloc->r_address() & 0x0000FFFF);
						makeByNameReference(A::kAbsHigh16, srcAddr, targetName, offsetInTarget);
					}
					else {
						dstAddr = ((instruction & 0x0000FFFF) << 16) | (nextReloc->r_address() & 0x0000FFFF);
						if ( reloc->r_symbolnum() == R_ABS ) {
							// find absolute symbol that corresponds to pointerValue
							typename AddrToAtomMap::iterator pos = fAddrToAbsoluteAtom.find(dstAddr);
							if ( pos != fAddrToAbsoluteAtom.end() ) 
								makeByNameReference(A::kAbsHigh16, srcAddr, pos->second->getName(), 0);
							else
								makeReference(A::kAbsHigh16, srcAddr, dstAddr);
						}
						else {
							makeReference(A::kAbsHigh16, srcAddr, dstAddr);
						}
					}
				}
				break;
			case PPC_RELOC_HA16:
				{
					if ( nextReloc->r_type() != PPC_RELOC_PAIR ) {
						throw "PPC_RELOC_HA16 missing following pair";
					}
					result = true;
					lowBits = (nextReloc->r_address() & 0x0000FFFF);
					if ( reloc->r_extern() ) {
						offsetInTarget = ((instruction & 0x0000FFFF) << 16) + (int32_t)lowBits;
						makeByNameReference(A::kAbsHigh16AddLow, srcAddr, targetName, offsetInTarget);
					}
					else {
						dstAddr = ((instruction & 0x0000FFFF) << 16) + (int32_t)lowBits;
						if ( reloc->r_symbolnum() == R_ABS ) {
							// find absolute symbol that corresponds to pointerValue
							typename AddrToAtomMap::iterator pos = fAddrToAbsoluteAtom.find(dstAddr);
							if ( pos != fAddrToAbsoluteAtom.end() ) 
								makeByNameReference(A::kAbsHigh16AddLow, srcAddr, pos->second->getName(), 0);
							else
								makeReference(A::kAbsHigh16AddLow, srcAddr, dstAddr);
						}
						else {
							makeReference(A::kAbsHigh16AddLow, srcAddr, dstAddr);
						}
					}
				}
				break;
			case PPC_RELOC_VANILLA:
				{
					pint_t pointerValue = P::getP(*((pint_t*)fixUpPtr));
					if ( reloc->r_extern() ) {
						if ( weakImport )
							makeByNameReference(A::kPointerWeakImport, srcAddr, targetName, pointerValue);
						else
							makeByNameReference(A::kPointer, srcAddr, targetName, pointerValue);
					}
					else {
						makeReference(A::kPointer, srcAddr, pointerValue);
					}
				}
				break;
			case PPC_RELOC_JBSR:
				// this is from -mlong-branch codegen.  We ignore the jump island and make reference to the real target
				if ( nextReloc->r_type() != PPC_RELOC_PAIR ) {
					throw "PPC_RELOC_JBSR missing following pair";
				}
				if ( !fHasLongBranchStubs )
					warning("object file compiled with -mlong-branch which is no longer needed. To remove this warning, recompile without -mlong-branch: %s", fPath);
				fHasLongBranchStubs = true;
				result = true;
				if ( reloc->r_extern() ) {
					throw "PPC_RELOC_JBSR should not be using an external relocation";
				}
				makeReference(A::kBranch24, srcAddr, nextReloc->r_address());
				if ( (instruction & 0x4C000000) == 0x48000000 ) {
					displacement = (instruction & 0x03FFFFFC);
					if ( (displacement & 0x02000000) != 0 )
						displacement |= 0xFC000000;
				}
				else {
					fprintf(stderr, "bad instruction for BR24 reloc");
				}
				break;
			default:
				warning("unknown relocation type %d", reloc->r_type());
		}
	}
	else {
		const macho_scattered_relocation_info<P>* sreloc = (macho_scattered_relocation_info<P>*)reloc;
		srcAddr = sect->addr() + sreloc->r_address();
		dstAddr = sreloc->r_value();
		uint32_t betterDstAddr;
		fixUpPtr = (uint32_t*)((char*)(fHeader) + sect->offset() + sreloc->r_address());
		const macho_scattered_relocation_info<P>* nextSReloc = &sreloc[1];
		const macho_relocation_info<P>* nextReloc = &reloc[1];
		// file format allows pair to be scattered or not
		bool nextRelocIsPair = false;
		uint32_t nextRelocAddress = 0;
		uint32_t nextRelocValue = 0;
		if ( (nextReloc->r_address() & R_SCATTERED) == 0 ) {
			if ( nextReloc->r_type() == PPC_RELOC_PAIR ) {
				nextRelocIsPair = true;
				nextRelocAddress = nextReloc->r_address();
				result = true;
			}
		}
		else {
			if ( nextSReloc->r_type() == PPC_RELOC_PAIR ) {
				nextRelocIsPair = true;
				nextRelocAddress = nextSReloc->r_address();
				nextRelocValue = nextSReloc->r_value();
				result = true;
			}
		}
		switch (sreloc->r_type()) {
			case PPC_RELOC_VANILLA:
				{
					betterDstAddr = P::getP(*(pint_t*)fixUpPtr);
					//fprintf(stderr, "scattered pointer reloc: srcAddr=0x%08X, dstAddr=0x%08X, pointer=0x%08X\n", srcAddr, dstAddr, betterDstAddr);
					// with a scattered relocation we get both the target (sreloc->r_value()) and the target+offset (*fixUpPtr)
					makeReferenceWithToBase(A::kPointer, srcAddr, betterDstAddr, dstAddr);
				}
				break;
			case PPC_RELOC_BR14:
				{
					instruction = BigEndian::get32(*fixUpPtr);
					displacement = (instruction & 0x0000FFFC);
					if ( (displacement & 0x00008000) != 0 )
						displacement |= 0xFFFF0000;
					betterDstAddr = srcAddr+displacement;
					//fprintf(stderr, "betterDstAddr=0x%08X, srcAddr=0x%08X, displacement=0x%08X\n",  betterDstAddr, srcAddr, displacement);
					makeReferenceWithToBase(A::kBranch14, srcAddr, betterDstAddr, dstAddr);
				}
				break;
			case PPC_RELOC_BR24:
				{
					instruction = BigEndian::get32(*fixUpPtr);
					if ( (instruction & 0x4C000000) == 0x48000000 ) {
						displacement = (instruction & 0x03FFFFFC);
						if ( (displacement & 0x02000000) != 0 )
							displacement |= 0xFC000000;
						betterDstAddr = srcAddr+displacement;
						makeReferenceWithToBase(A::kBranch24, srcAddr, betterDstAddr, dstAddr);
					}
				}
				break;
			case PPC_RELOC_LO16_SECTDIFF:
				{
					if ( ! nextRelocIsPair ) {
						throw "PPC_RELOC_LO16_SECTDIFF missing following pair";
					}
					instruction = BigEndian::get32(*fixUpPtr);
					lowBits = (instruction & 0xFFFF);
					displacement = (nextRelocAddress << 16) | ((uint32_t)lowBits & 0x0000FFFF);
					makeReferenceWithToBase(A::kPICBaseLow16, srcAddr, nextRelocValue, nextRelocValue + displacement, dstAddr);
				}
				break;
			case PPC_RELOC_LO14_SECTDIFF:
				{
					if ( ! nextRelocIsPair ) {
						throw "PPC_RELOC_LO14_SECTDIFF missing following pair";
					}
					instruction = BigEndian::get32(*fixUpPtr);
					lowBits = (instruction & 0xFFFC);
					displacement = (nextRelocAddress << 16) | ((uint32_t)lowBits & 0x0000FFFF);
					makeReferenceWithToBase(A::kPICBaseLow14, srcAddr, nextRelocValue, nextRelocValue + displacement, dstAddr);
				}
				break;
			case PPC_RELOC_HA16_SECTDIFF:
				{
					if ( ! nextRelocIsPair ) {
						throw "PPC_RELOC_HA16_SECTDIFF missing following pair";
					}
					instruction = BigEndian::get32(*fixUpPtr);
					lowBits = (nextRelocAddress & 0x0000FFFF);
					displacement = ((instruction & 0x0000FFFF) << 16) + (int32_t)lowBits;
					makeReferenceWithToBase(A::kPICBaseHigh16, srcAddr, nextRelocValue, nextRelocValue + displacement, dstAddr);
				}
				break;
			case PPC_RELOC_LO14:
				{
					if ( ! nextRelocIsPair ) {
						throw "PPC_RELOC_LO14 missing following pair";
					}
					instruction = BigEndian::get32(*fixUpPtr);
					lowBits = (instruction & 0xFFFC);
					betterDstAddr = (nextRelocAddress << 16) + ((uint32_t)lowBits & 0x0000FFFF);
					makeReferenceWithToBase(A::kAbsLow14, srcAddr, betterDstAddr, dstAddr);
				}
				break;
			case PPC_RELOC_LO16:
				{
					if ( ! nextRelocIsPair ) {
						throw "PPC_RELOC_LO16 missing following pair";
					}
					instruction = BigEndian::get32(*fixUpPtr);
					lowBits = (instruction & 0xFFFF);
					betterDstAddr = (nextRelocAddress << 16) + ((uint32_t)lowBits & 0x0000FFFF);
					makeReferenceWithToBase(A::kAbsLow16, srcAddr, betterDstAddr, dstAddr);
				}
				break;
			case PPC_RELOC_HA16:
				{
					if ( ! nextRelocIsPair ) {
						throw "PPC_RELOC_HA16 missing following pair";
					}
					instruction = BigEndian::get32(*fixUpPtr);
					lowBits = (nextRelocAddress & 0xFFFF);
					betterDstAddr = ((instruction & 0xFFFF) << 16) + (int32_t)lowBits;
					makeReferenceWithToBase(A::kAbsHigh16AddLow, srcAddr, betterDstAddr, dstAddr);
				}
				break;
			case PPC_RELOC_HI16:
				{
					if ( ! nextRelocIsPair ) {
						throw "PPC_RELOC_HI16 missing following pair";
					}
					instruction = BigEndian::get32(*fixUpPtr);
					lowBits = (nextRelocAddress & 0xFFFF);
					betterDstAddr = ((instruction & 0xFFFF) << 16) | (lowBits & 0x0000FFFF);
					makeReferenceWithToBase(A::kAbsHigh16, srcAddr, betterDstAddr, dstAddr);
				}
				break;
			case PPC_RELOC_SECTDIFF:
			case PPC_RELOC_LOCAL_SECTDIFF:
				{
					if ( ! nextRelocIsPair ) {
						throw "PPC_RELOC_SECTDIFF missing following pair";
					}
					Kinds kind = A::kPointerDiff32;;
					uint32_t contentAddr = 0;
					switch ( sreloc->r_length() ) {
						case 0:
							throw "bad diff relocations r_length (0) for ppc architecture";
						case 1:
							kind = A::kPointerDiff16;
							contentAddr = BigEndian::get16(*((uint16_t*)fixUpPtr));
							break;
						case 2:
							kind = A::kPointerDiff32;
							contentAddr = BigEndian::get32(*fixUpPtr);
							break;
						case 3:
							kind = A::kPointerDiff64;
							contentAddr = BigEndian::get64(*((uint64_t*)fixUpPtr));
							break;
					}
					AtomAndOffset srcao  = findAtomAndOffset(srcAddr);
					AtomAndOffset fromao = findAtomAndOffset(nextRelocValue);
					AtomAndOffset toao   = findAtomAndOffset(dstAddr);
					// check for addend encoded in the section content
					//fprintf(stderr, "addRef: dstAddr=0x%X, nextRelocValue=0x%X, contentAddr=0x%X\n",
					//		dstAddr, nextRelocValue, contentAddr);
					if ( (dstAddr - nextRelocValue) != contentAddr ) {
						if ( toao.atom == srcao.atom )
							toao.offset += (contentAddr + nextRelocValue) - dstAddr;
						else if ( fromao.atom == srcao.atom )
							toao.offset += (contentAddr + nextRelocValue) - dstAddr;
						else
							fromao.offset += (dstAddr - contentAddr) - nextRelocValue;
					}
					//fprintf(stderr, "addRef: src=%s+0x%X, from=%s+0x%X, to=%s+0x%X\n",
					//	srcao.atom->getDisplayName(), srcao.offset, 
					//	fromao.atom->getDisplayName(), fromao.offset, 
					//	toao.atom->getDisplayName(), toao.offset);
					new Reference<A>(kind, srcao, fromao, toao);
				}
				break;
			case PPC_RELOC_PAIR:
				break;
			case PPC_RELOC_HI16_SECTDIFF:
				warning("unexpected scattered relocation type PPC_RELOC_HI16_SECTDIFF");
				break;
			default:
				warning("unknown scattered relocation type %d", sreloc->r_type());
		}
	}
	return result;
}


template <>
bool Reader<x86>::addRelocReference(const macho_section<x86::P>* sect, const macho_relocation_info<x86::P>* reloc)
{
	uint32_t srcAddr;
	uint32_t dstAddr;
	uint32_t* fixUpPtr;
	bool result = false;
	if ( (reloc->r_address() & R_SCATTERED) == 0 ) {
		srcAddr = sect->addr() + reloc->r_address();
		fixUpPtr = (uint32_t*)((char*)(fHeader) + sect->offset() + reloc->r_address());
		switch ( reloc->r_type() ) {
			case GENERIC_RELOC_VANILLA:
				{
					x86::ReferenceKinds kind = x86::kPointer;
					uint32_t pointerValue = E::get32(*fixUpPtr);
					if ( reloc->r_pcrel() ) {
						switch( reloc->r_length() ) {
							case 0:
								kind = x86::kPCRel8;
								pointerValue = srcAddr + *((int8_t*)fixUpPtr) + sizeof(int8_t);
								break;
							case 1:
								kind = x86::kPCRel16;
								pointerValue = srcAddr + (int16_t)E::get16(*((uint16_t*)fixUpPtr)) + sizeof(uint16_t);
								break;
							case 2:
								kind = x86::kPCRel32;
								pointerValue += srcAddr + sizeof(uint32_t);
								break;
							case 3:
								throw "bad pc-rel vanilla relocation length";
						}
					}
					else if ( strcmp(sect->segname(), "__TEXT") == 0 ) {
						kind = x86::kAbsolute32;
						if ( reloc->r_length() != 2 )
							throw "bad vanilla relocation length";
					}
					else {
						kind = x86::kPointer;
						if ( reloc->r_length() != 2 )
							throw "bad vanilla relocation length";
					}
					if ( reloc->r_extern() ) {
						const macho_nlist<P>* targetSymbol = &fSymbols[reloc->r_symbolnum()];
						if ( this->isWeakImportSymbol(targetSymbol) ) {
							if ( reloc->r_pcrel() )
								kind = x86::kPCRel32WeakImport;
							else
								kind = x86::kPointerWeakImport;
						}
						const char* targetName = &fStrings[targetSymbol->n_strx()];
						if ( strncmp(targetName, "___dtrace_probe$", 16) == 0 ) {
							makeByNameReference(x86::kDtraceProbeSite, srcAddr, targetName, 0);
							addDtraceExtraInfos(srcAddr, &targetName[16]);
						}
						else if ( strncmp(targetName, "___dtrace_isenabled$", 20) == 0 ) {
							makeByNameReference(x86::kDtraceIsEnabledSite, srcAddr, targetName, 0);
							addDtraceExtraInfos(srcAddr, &targetName[20]);
						}
						else
							makeByNameReference(kind, srcAddr, targetName, pointerValue);
					}
					else {
						// if this is a branch to a stub, we need to see if the stub is for a weak imported symbol
						ObjectFile::Atom* atom = findAtomAndOffset(pointerValue).atom;
						const char* targetName = atom->getName();
						if ( (targetName != NULL) && (strncmp(targetName, "___dtrace_probe$", 16) == 0) ) {
							makeByNameReference(x86::kDtraceProbeSite, srcAddr, targetName, 0);
							addDtraceExtraInfos(srcAddr, &targetName[16]);
						}
						else if ( (targetName != NULL) && (strncmp(targetName, "___dtrace_isenabled$", 20) == 0) ) {
							makeByNameReference(x86::kDtraceIsEnabledSite, srcAddr, targetName, 0);
							addDtraceExtraInfos(srcAddr, &targetName[20]);
						}
						else if ( reloc->r_pcrel() && (atom->getSymbolTableInclusion() == ObjectFile::Atom::kSymbolTableNotIn)
							&& ((AnonymousAtom<x86>*)atom)->isWeakImportStub() )
							makeReference(x86::kPCRel32WeakImport, srcAddr, pointerValue);
						else if ( reloc->r_symbolnum() != R_ABS )
							makeReference(kind, srcAddr, pointerValue);
						else {
							// find absolute symbol that corresponds to pointerValue
							AddrToAtomMap::iterator pos = fAddrToAbsoluteAtom.find(pointerValue);
							if ( pos != fAddrToAbsoluteAtom.end() ) 
								makeByNameReference(kind, srcAddr, pos->second->getName(), 0);
							else
								throwf("R_ABS reloc but no absolute symbol at target address");
						}
					}
				}
				break;
			default:
				warning("unknown relocation type %d", reloc->r_type());
		}
	}
	else {
		const macho_scattered_relocation_info<P>* sreloc = (macho_scattered_relocation_info<P>*)reloc;
		srcAddr = sect->addr() + sreloc->r_address();
		dstAddr = sreloc->r_value();
		fixUpPtr = (uint32_t*)((char*)(fHeader) + sect->offset() + sreloc->r_address());
		const macho_scattered_relocation_info<P>* nextSReloc = &sreloc[1];
		const macho_relocation_info<P>* nextReloc = &reloc[1];
		pint_t betterDstAddr;
		// file format allows pair to be scattered or not
		bool nextRelocIsPair = false;
		uint32_t nextRelocAddress = 0;
		uint32_t nextRelocValue = 0;
 		if ( (nextReloc->r_address() & R_SCATTERED) == 0 ) {
			if ( nextReloc->r_type() == GENERIC_RELOC_PAIR ) {
				nextRelocIsPair = true;
				nextRelocAddress = nextReloc->r_address();
				result = true;
			}
		}
		else {
			if ( nextSReloc->r_type() == GENERIC_RELOC_PAIR ) {
				nextRelocIsPair = true;
				nextRelocAddress = nextSReloc->r_address();
				nextRelocValue = nextSReloc->r_value();
			}
		}
		switch (sreloc->r_type()) {
			case GENERIC_RELOC_VANILLA:
					betterDstAddr = LittleEndian::get32(*fixUpPtr);
					//fprintf(stderr, "pointer reloc: srcAddr=0x%08X, dstAddr=0x%08X, pointer=0x%08lX\n", srcAddr, dstAddr, betterDstAddr);
					// with a scattered relocation we get both the target (sreloc->r_value()) and the target+offset (*fixUpPtr)
					if ( sreloc->r_pcrel() ) {
						switch ( sreloc->r_length() ) {
							case 2:
								betterDstAddr += srcAddr + 4;
								makeReferenceWithToBase(x86::kPCRel32, srcAddr, betterDstAddr, dstAddr);
								break;
							case 1:
								betterDstAddr = LittleEndian::get16(*((uint16_t*)fixUpPtr)) + srcAddr + 2;
								makeReferenceWithToBase(x86::kPCRel16, srcAddr, betterDstAddr, dstAddr);
								break;
							case 0:
								betterDstAddr = *((uint8_t*)fixUpPtr) + srcAddr + 1;
								makeReferenceWithToBase(x86::kPCRel8, srcAddr, betterDstAddr, dstAddr);
								break;
							case 3:
								throwf("unsupported r_length=3 for scattered pc-rel vanilla reloc");
								break;
						}
					}
					else {
						if ( sreloc->r_length() != 2 )
							throwf("unsupported r_length=%d for scattered vanilla reloc", sreloc->r_length());
						if ( strcmp(sect->segname(), "__TEXT") == 0 )
							makeReferenceWithToBase(x86::kAbsolute32, srcAddr, betterDstAddr, dstAddr);
						else
							makeReferenceWithToBase(x86::kPointer, srcAddr, betterDstAddr, dstAddr);
					}
				break;
			case GENERIC_RELOC_SECTDIFF:
			case GENERIC_RELOC_LOCAL_SECTDIFF:
				{
					if ( !nextRelocIsPair ) {
						throw "GENERIC_RELOC_SECTDIFF missing following pair";
					}
					x86::ReferenceKinds kind = x86::kPointerDiff;
					uint32_t contentAddr = 0;
					switch ( sreloc->r_length() ) {
						case 0:
						case 3:
							throw "bad length for GENERIC_RELOC_SECTDIFF";
						case 1:
							kind = x86::kPointerDiff16;
							contentAddr = LittleEndian::get16(*((uint16_t*)fixUpPtr));
							break;
						case 2:
							kind = x86::kPointerDiff;
							contentAddr = LittleEndian::get32(*fixUpPtr);
							break;
					}
					AtomAndOffset srcao  = findAtomAndOffset(srcAddr);
					AtomAndOffset fromao = findAtomAndOffset(nextRelocValue);
					AtomAndOffset toao   = findAtomAndOffset(dstAddr);
					// check for addend encoded in the section content
					//fprintf(stderr, "addRef: dstAddr=0x%X, nextRelocValue=0x%X, contentAddr=0x%X\n",
					//		dstAddr, nextRelocValue, contentAddr);
					if ( (dstAddr - nextRelocValue) != contentAddr ) {
						if ( toao.atom == srcao.atom )
							toao.offset += (contentAddr + nextRelocValue) - dstAddr;
						else if ( fromao.atom == srcao.atom )
							toao.offset += (contentAddr + nextRelocValue) - dstAddr;
						else
							fromao.offset += (dstAddr - contentAddr) - nextRelocValue;
					}
					//fprintf(stderr, "addRef: src=%s+0x%X, from=%s+0x%X, to=%s+0x%X\n",
					//	srcao.atom->getDisplayName(), srcao.offset, 
					//	fromao.atom->getDisplayName(), fromao.offset, 
					//	toao.atom->getDisplayName(), toao.offset);
					new Reference<x86>(kind, srcao, fromao, toao);
				}
				break;
			case GENERIC_RELOC_PAIR:
				// do nothing, already used via a look ahead
				break;
			default:
				warning("unknown scattered relocation type %d", sreloc->r_type());
		}
	}
	return result;
}

template <>
bool Reader<x86_64>::addRelocReference(const macho_section<x86_64::P>* sect, const macho_relocation_info<x86_64::P>* reloc)
{
	uint64_t srcAddr;
	uint64_t dstAddr = 0;
	uint64_t addend;
	uint32_t* fixUpPtr;
	x86_64::ReferenceKinds kind = x86_64::kNoFixUp;
	bool result = false;
	const macho_nlist<P>* targetSymbol = NULL;
	const char* targetName = NULL;
	srcAddr = sect->addr() + reloc->r_address();
	fixUpPtr = (uint32_t*)((char*)(fHeader) + sect->offset() + reloc->r_address());
	//fprintf(stderr, "addReloc type=%d, len=%d, address=0x%X\n", reloc->r_type(), reloc->r_length(), reloc->r_address());
	if ( reloc->r_extern() ) {
		targetSymbol = &fSymbols[reloc->r_symbolnum()];
		targetName = &fStrings[targetSymbol->n_strx()];
	}
	switch ( reloc->r_type() ) {
		case X86_64_RELOC_UNSIGNED:
			if ( reloc->r_pcrel() )
				throw "pcrel and X86_64_RELOC_UNSIGNED not supported";
			switch ( reloc->r_length() ) {
				case 0:
				case 1:
					throw "length < 2 and X86_64_RELOC_UNSIGNED not supported";
				case 2:
					kind = x86_64::kPointer32;
					break;
				case 3:
					if ( reloc->r_extern() && isWeakImportSymbol(targetSymbol) )
						kind = x86_64::kPointerWeakImport;
					else
						kind = x86_64::kPointer;
					break;
			}
			dstAddr = E::get64(*((uint64_t*)fixUpPtr));
			if ( reloc->r_extern() ) {
				makeReferenceToSymbol(kind, srcAddr, targetSymbol, dstAddr);
			}
			else {
				makeReference(kind, srcAddr, dstAddr);
				// verify that dstAddr is in the section being targeted
				int sectNum = reloc->r_symbolnum();
				const macho_section<P>* const sectionsStart = (macho_section<P>*)((char*)fSegment + sizeof(macho_segment_command<P>));
				const macho_section<P>* const targetSection = &sectionsStart[sectNum-1];
				if ( (dstAddr < targetSection->addr()) || (dstAddr > (targetSection->addr()+targetSection->size())) ) {
					throwf("local relocation for address 0x%08llX in section %s does not target section %s", 
							srcAddr, sect->sectname(), targetSection->sectname());
				}
			}
			break;
		case X86_64_RELOC_SIGNED:
		case X86_64_RELOC_SIGNED_1:
		case X86_64_RELOC_SIGNED_2:
		case X86_64_RELOC_SIGNED_4:
			if ( ! reloc->r_pcrel() )
				throw "not pcrel and X86_64_RELOC_SIGNED* not supported";
			if ( reloc->r_length() != 2 ) 
				throw "length != 2 and X86_64_RELOC_SIGNED* not supported";
			addend = (int64_t)((int32_t)(E::get32(*fixUpPtr)));
			if ( reloc->r_extern() ) {
				switch ( reloc->r_type() ) {
					case X86_64_RELOC_SIGNED:
						kind = x86_64::kPCRel32;
						// begin support for old .o files before X86_64_RELOC_SIGNED_1 was created
						if ( addend == (uint64_t)(-1) ) {
							addend = 0;
							kind = x86_64::kPCRel32_1;
						}
						else if ( addend == (uint64_t)(-2) ) {
							addend = 0;
							kind = x86_64::kPCRel32_2;
						}
						else if ( addend == (uint64_t)(-4) ) {
							addend = 0;
							kind = x86_64::kPCRel32_4;
						}
						break;
						// end support for old .o files before X86_64_RELOC_SIGNED_1 was created
					case X86_64_RELOC_SIGNED_1:
						kind = x86_64::kPCRel32_1;
						addend += 1;
						break;	
					case X86_64_RELOC_SIGNED_2:
						kind = x86_64::kPCRel32_2;
						addend += 2;
						break;	
					case X86_64_RELOC_SIGNED_4:
						kind = x86_64::kPCRel32_4;
						addend += 4;
						break;
				}
				makeReferenceToSymbol(kind, srcAddr, targetSymbol, addend);
			}
			else {
				uint64_t ripRelativeOffset = addend;
				switch ( reloc->r_type() ) {
					case X86_64_RELOC_SIGNED:
						dstAddr = srcAddr + 4 + ripRelativeOffset;
						kind = x86_64::kPCRel32;
						break;
					case X86_64_RELOC_SIGNED_1:
						dstAddr = srcAddr + 5 + ripRelativeOffset;
						kind = x86_64::kPCRel32_1;
						break;	
					case X86_64_RELOC_SIGNED_2:
						dstAddr = srcAddr + 6 + ripRelativeOffset;
						kind = x86_64::kPCRel32_2;
						break;	
					case X86_64_RELOC_SIGNED_4:
						dstAddr = srcAddr + 8 + ripRelativeOffset;
						kind = x86_64::kPCRel32_4;
						break;
				}
				makeReference(kind, srcAddr, dstAddr);
				// verify that dstAddr is in the section being targeted
				int sectNum = reloc->r_symbolnum();
				const macho_section<P>* const sectionsStart = (macho_section<P>*)((char*)fSegment + sizeof(macho_segment_command<P>));
				const macho_section<P>* const targetSection = &sectionsStart[sectNum-1];
				if ( (dstAddr < targetSection->addr()) || (dstAddr > (targetSection->addr()+targetSection->size())) ) {
					throwf("local relocation for address 0x%08llX in section %s does not target section %s", 
							srcAddr, sect->sectname(), targetSection->sectname());
				}
			}	
			break;
		case X86_64_RELOC_BRANCH:
			if ( ! reloc->r_pcrel() )
				throw "not pcrel and X86_64_RELOC_BRANCH not supported";
			if ( reloc->r_length() == 2 ) {
				dstAddr = (int64_t)((int32_t)(E::get32(*fixUpPtr)));
				if ( reloc->r_extern() ) {
					if ( strncmp(targetName, "___dtrace_probe$", 16) == 0 ) {
						makeByNameReference(x86_64::kDtraceProbeSite, srcAddr, targetName, 0);
						addDtraceExtraInfos(srcAddr, &targetName[16]);
					}
					else if ( strncmp(targetName, "___dtrace_isenabled$", 20) == 0 ) {
						makeByNameReference(x86_64::kDtraceIsEnabledSite, srcAddr, targetName, 0);
						addDtraceExtraInfos(srcAddr, &targetName[16]);
					}
					else if ( isWeakImportSymbol(targetSymbol) )
						makeReferenceToSymbol(x86_64::kBranchPCRel32WeakImport, srcAddr, targetSymbol, dstAddr);
					else
						makeReferenceToSymbol(x86_64::kBranchPCRel32, srcAddr, targetSymbol, dstAddr);
				}
				else {
					makeReference(x86_64::kBranchPCRel32, srcAddr, srcAddr+4+dstAddr);
				}
			}
			else if ( reloc->r_length() == 0 ) {
				dstAddr = *((int8_t*)fixUpPtr);
				if ( reloc->r_extern() ) {
					makeReferenceToSymbol(x86_64::kBranchPCRel8, srcAddr, targetSymbol, dstAddr);
				}
				else {
					makeReference(x86_64::kBranchPCRel8, srcAddr, srcAddr+1+dstAddr);
				}
			}
			else {
				throwf("length=%d and X86_64_RELOC_BRANCH not supported", reloc->r_length());;
			}
			break;
		case X86_64_RELOC_GOT:
			if ( ! reloc->r_extern() ) 
				throw "not extern and X86_64_RELOC_GOT not supported";
			if ( ! reloc->r_pcrel() )
				throw "not pcrel and X86_64_RELOC_GOT not supported";
			if ( reloc->r_length() != 2 ) 
				throw "length != 2 and X86_64_RELOC_GOT not supported";
			addend = (int64_t)((int32_t)(E::get32(*fixUpPtr)));
			if ( isWeakImportSymbol(targetSymbol) )
				makeReferenceToSymbol(x86_64::kPCRel32GOTWeakImport, srcAddr, targetSymbol, addend);
			else
				makeReferenceToSymbol(x86_64::kPCRel32GOT, srcAddr, targetSymbol, addend);
			break;
		case X86_64_RELOC_GOT_LOAD:
			if ( ! reloc->r_extern() ) 
				throw "not extern and X86_64_RELOC_GOT_LOAD not supported";
			if ( ! reloc->r_pcrel() )
				throw "not pcrel and X86_64_RELOC_GOT_LOAD not supported";
			if ( reloc->r_length() != 2 ) 
				throw "length != 2 and X86_64_RELOC_GOT_LOAD not supported";
			addend = (int64_t)((int32_t)(E::get32(*fixUpPtr)));
			if ( isWeakImportSymbol(targetSymbol) )
				makeReferenceToSymbol(x86_64::kPCRel32GOTLoadWeakImport, srcAddr, targetSymbol, addend);
			else
				makeReferenceToSymbol(x86_64::kPCRel32GOTLoad, srcAddr, targetSymbol, addend);
			break;
		case X86_64_RELOC_SUBTRACTOR:
		{
			if ( reloc->r_pcrel() )
				throw "X86_64_RELOC_SUBTRACTOR cannot be pc-relative";
			if ( reloc->r_length() < 2 )
				throw "X86_64_RELOC_SUBTRACTOR must have r_length of 2 or 3";
			if ( !reloc->r_extern() )
				throw "X86_64_RELOC_SUBTRACTOR must have r_extern=1";
			const macho_relocation_info<x86_64::P>* nextReloc = &reloc[1];
			if ( nextReloc->r_type() != X86_64_RELOC_UNSIGNED )
				throw "X86_64_RELOC_SUBTRACTOR must be followed by X86_64_RELOC_UNSIGNED";
			result = true;
			if ( nextReloc->r_pcrel() )
				throw "X86_64_RELOC_UNSIGNED following a X86_64_RELOC_SUBTRACTOR cannot be pc-relative";
			if ( nextReloc->r_length() != reloc->r_length() )
				throw "X86_64_RELOC_UNSIGNED following a X86_64_RELOC_SUBTRACTOR must have same r_length";
			Reference<x86_64>* ref;
			bool negativeAddend;
			if ( reloc->r_length() == 2 ) {
				kind = x86_64::kPointerDiff32;
				dstAddr = E::get32(*fixUpPtr); // addend is in content
				negativeAddend = ((dstAddr & 0x80000000) != 0);
			}
			else {
				kind = x86_64::kPointerDiff;
				dstAddr = E::get64(*((uint64_t*)fixUpPtr)); // addend is in content
				negativeAddend = ((dstAddr & 0x8000000000000000ULL) != 0);
			}
			AtomAndOffset inAtomAndOffset = this->findAtomAndOffset(srcAddr);
			ObjectFile::Atom* inAtom = inAtomAndOffset.atom;
			// create reference with "to" target
			if ( nextReloc->r_extern() ) {
				const macho_nlist<P>* targetSymbol = &fSymbols[nextReloc->r_symbolnum()];
				const char* targetName = &fStrings[targetSymbol->n_strx()];
				ref = makeReferenceToSymbol(kind, srcAddr, targetSymbol, 0);
				// if "to" is in this atom, change by-name to a direct reference
				if ( strcmp(targetName, inAtom->getName()) == 0 )
					ref->setTarget(*inAtom, 0);
			}
			else {
				ref = makeReference(kind, srcAddr, dstAddr);
			}
			// add in "from" target
			if ( reloc->r_extern() ) {
				const macho_nlist<P>* targetFromSymbol = &fSymbols[reloc->r_symbolnum()];
				const char* fromTargetName = &fStrings[targetFromSymbol->n_strx()];
				if ( (targetFromSymbol->n_type() & N_EXT) == 0 ) {
					// from target is translation unit scoped, so use a direct reference
					ref->setFromTarget(*(findAtomAndOffset(targetSymbol->n_value()).atom));
				}
				else if ( strcmp(fromTargetName, inAtom->getName()) == 0 ) {
					// if "from" is in this atom, change by-name to a direct reference
					ref->setFromTarget(*inAtom);
				}
				else {
					// some non-static other atom
					ref->setFromTargetName(fromTargetName);
				}
			}
			else {
				throw "X86_64_RELOC_SUBTRACTOR not supported with r_extern=0";
			}
			// addend goes in from side iff negative
			if ( negativeAddend )
				ref->setFromTargetOffset(-dstAddr);
			else
				ref->setToTargetOffset(dstAddr);
			break;
		}
		default:
			warning("unknown relocation type %d", reloc->r_type());
	}
	return result;
}


/// Reader<arm>::addRelocReference - 
/// turns arm relocation entries into references.  Returns true if the next
/// relocation should be skipped, false otherwise.
template <>
bool Reader<arm>::addRelocReference(const macho_section<arm::P>* sect, 
                                    const macho_relocation_info<arm::P>* reloc)
{
	uint32_t *  fixUpPtr;
	int32_t		displacement;												
	uint32_t    instruction = 0;
	bool        result = false;
	uint32_t	srcAddr;
	uint32_t	dstAddr;
	uint32_t	pointerValue;
	arm::ReferenceKinds kind = arm::kNoFixUp;
	
	if ( (reloc->r_address() & R_SCATTERED) == 0 ) {
		// non-scattered relocation
		const char* targetName = NULL;
		bool        weakImport = false;
    
		srcAddr = sect->addr() + reloc->r_address();
		fixUpPtr = (uint32_t*)((char*)(fHeader) + sect->offset() + reloc->r_address());
		if ( reloc->r_type() != ARM_RELOC_PAIR )
			instruction = LittleEndian::get32(*fixUpPtr);
    
		if ( reloc->r_extern() ) {
			const macho_nlist<P>* targetSymbol = &fSymbols[reloc->r_symbolnum()];
			targetName = &fStrings[targetSymbol->n_strx()];
			weakImport = this->isWeakImportSymbol(targetSymbol);
		}
    
		switch ( reloc->r_type() ) {
			case ARM_RELOC_BR24:
				// Sign-extend displacement
				displacement = (instruction & 0x00FFFFFF) << 2;
				if ( (displacement & 0x02000000) != 0 )
					displacement |= 0xFC000000;
				// The pc added will be +8 from the pc
				displacement += 8;
				// If this is BLX add H << 1
				if ((instruction & 0xFE000000) == 0xFA000000)
					displacement += ((instruction & 0x01000000) >> 23);

				if ( reloc->r_extern() ) {
					uint32_t offsetInTarget = srcAddr + displacement;
					if ( strncmp(targetName, "___dtrace_probe$", 16) == 0 ) {
						makeByNameReference(arm::kDtraceProbeSite, srcAddr, targetName, 0);
						addDtraceExtraInfos(srcAddr, &targetName[16]);
					}
					else if ( strncmp(targetName, "___dtrace_isenabled$", 20) == 0 ) {
						makeByNameReference(arm::kDtraceIsEnabledSite, srcAddr, targetName, 0);
						addDtraceExtraInfos(srcAddr, &targetName[20]);
					}
					else if ( weakImport )
						makeByNameReference(arm::kBranch24WeakImport, srcAddr, targetName, offsetInTarget);
					else
						makeByNameReference(arm::kBranch24, srcAddr, targetName, offsetInTarget);
				}
				else {
					dstAddr = srcAddr + displacement;
					ObjectFile::Atom* atom = findAtomAndOffset(dstAddr).atom;
					// check for dtrace probes and weak_import stubs 
					const char* targetName = atom->getName();
					if ( (targetName != NULL) && (strncmp(targetName, "___dtrace_probe$", 16) == 0) ) {
						makeByNameReference(arm::kDtraceProbeSite, srcAddr, targetName, 0);
						addDtraceExtraInfos(srcAddr, &targetName[16]);
					}
					else if ( (targetName != NULL) && (strncmp(targetName, "___dtrace_isenabled$", 20) == 0) ) {
						makeByNameReference(arm::kDtraceIsEnabledSite, srcAddr, targetName, 0);
						addDtraceExtraInfos(srcAddr, &targetName[20]);
					}
					else if ( (atom->getSymbolTableInclusion() == ObjectFile::Atom::kSymbolTableNotIn)
						&& ((AnonymousAtom<x86>*)atom)->isWeakImportStub() )
						makeReference(arm::kBranch24WeakImport, srcAddr, dstAddr);
					else if ( reloc->r_symbolnum() != R_ABS )
						makeReference(arm::kBranch24, srcAddr, dstAddr);
					else {
						// find absolute symbol that corresponds to pointerValue
						AddrToAtomMap::iterator pos = fAddrToAbsoluteAtom.find(dstAddr);
						if ( pos != fAddrToAbsoluteAtom.end() ) 
							makeByNameReference(arm::kBranch24, srcAddr, pos->second->getName(), 0);
						else
							throwf("R_ABS reloc but no absolute symbol at target address");
					}
				}
				break;
	
			case ARM_THUMB_RELOC_BR22:
				// thumb2 added two more bits to displacement, complicating the displacement decoding
				{
					uint32_t s = (instruction >> 10) & 0x1;
					uint32_t j1 = (instruction >> 29) & 0x1;
					uint32_t j2 = (instruction >> 27) & 0x1;
					uint32_t imm10 = instruction & 0x3FF;
					uint32_t imm11 = (instruction >> 16) & 0x7FF;
					uint32_t i1 = (j1 == s);
					uint32_t i2 = (j2 == s);
					uint32_t dis = (s << 24) | (i1 << 23) | (i2 << 22) | (imm10 << 12) | (imm11 << 1);
					int32_t sdis = dis;
					if ( s )
						sdis |= 0xFE000000;
					displacement = sdis;
				}
				// The pc added will be +4 from the pc
				displacement += 4;
				// If the instruction was blx, force the low 2 bits to be clear
				dstAddr = srcAddr + displacement;
				if ((instruction & 0xF8000000) == 0xE8000000)
					dstAddr &= 0xFFFFFFFC;

				if ( reloc->r_extern() ) {
					uint32_t offsetInTarget = dstAddr;
					if ( strncmp(targetName, "___dtrace_probe$", 16) == 0 ) {
						makeByNameReference(arm::kDtraceProbeSite, srcAddr, targetName, 0);
						addDtraceExtraInfos(srcAddr, &targetName[16]);
					}
					else if ( strncmp(targetName, "___dtrace_isenabled$", 20) == 0 ) {
						makeByNameReference(arm::kDtraceIsEnabledSite, srcAddr, targetName, 0);
						addDtraceExtraInfos(srcAddr, &targetName[20]);
					}
					else if ( weakImport )
						makeByNameReference(arm::kThumbBranch22WeakImport, srcAddr, targetName, offsetInTarget);
					else
						makeByNameReference(arm::kThumbBranch22, srcAddr, targetName, offsetInTarget);
				}
				else {
					ObjectFile::Atom* atom = findAtomAndOffset(dstAddr).atom;
					// check for dtrace probes and weak_import stubs 
					const char* targetName = atom->getName();
					if ( (targetName != NULL) && (strncmp(targetName, "___dtrace_probe$", 16) == 0) ) {
						makeByNameReference(arm::kDtraceProbeSite, srcAddr, targetName, 0);
						addDtraceExtraInfos(srcAddr, &targetName[16]);
					}
					else if ( (targetName != NULL) && (strncmp(targetName, "___dtrace_isenabled$", 20) == 0) ) {
						makeByNameReference(arm::kDtraceIsEnabledSite, srcAddr, targetName, 0);
						addDtraceExtraInfos(srcAddr, &targetName[20]);
					}
					else if ( (atom->getSymbolTableInclusion() == ObjectFile::Atom::kSymbolTableNotIn)
						&& ((AnonymousAtom<x86>*)atom)->isWeakImportStub() )
						makeReference(arm::kThumbBranch22WeakImport, srcAddr, dstAddr);
					else if ( reloc->r_symbolnum() != R_ABS )
						makeReference(arm::kThumbBranch22, srcAddr, dstAddr);
					else {
						// find absolute symbol that corresponds to pointerValue
						AddrToAtomMap::iterator pos = fAddrToAbsoluteAtom.find(dstAddr);
						if ( pos != fAddrToAbsoluteAtom.end() ) 
							makeByNameReference(arm::kThumbBranch22, srcAddr, pos->second->getName(), 0);
						else
							throwf("R_ABS reloc but no absolute symbol at target address");
					}
				}
				break;

			case ARM_RELOC_VANILLA:
				if ( reloc->r_length() != 2 )
					throw "bad length for ARM_RELOC_VANILLA";

				pointerValue = instruction;
				kind = arm::kPointer;
				if ( strcmp(sect->segname(), "__TEXT") == 0 )
					kind = arm::kReadOnlyPointer;
				if ( weakImport )
					kind = arm::kPointerWeakImport;
				if ( reloc->r_extern() ) {
					makeByNameReference(kind, srcAddr, targetName, pointerValue);
				}
				else {
					AtomAndOffset at = findAtomAndOffset(srcAddr);
					AtomAndOffset to = findAtomAndOffset(pointerValue);
					if ( to.atom->isThumb() )
						to.offset &= -2;
					new Reference<arm>(kind, at, to);
				}
				break;
				
			case ARM_THUMB_32BIT_BRANCH:
				// work around for <rdar://problem/6489480>
				break;
				
			default:
				warning("unexpected relocation type %u", reloc->r_type());
				break;
		}
	} 
	else {
		const macho_scattered_relocation_info<P>* sreloc = (macho_scattered_relocation_info<P>*)reloc;
		const macho_scattered_relocation_info<P>* nextSReloc = &sreloc[1];
		srcAddr = sect->addr() + sreloc->r_address();
		dstAddr = sreloc->r_value();
		uint32_t betterDstAddr;
		fixUpPtr = (uint32_t*)((char*)(fHeader) + sect->offset() + sreloc->r_address());
		instruction = LittleEndian::get32(*fixUpPtr);
		
		// A ARM_RELOC_PAIR only follows ARM_RELOC_{SECTDIFF,LOCAL_SECTDIFF}
		// relocation types, and it is an error to see one otherwise.
		bool nextRelocIsPair = false;
		uint32_t nextRelocAddress = 0;
		uint32_t nextRelocValue = 0;
		if ( nextSReloc->r_type() == ARM_RELOC_PAIR ) {
			nextRelocIsPair = true;
			nextRelocAddress = nextSReloc->r_address();
			nextRelocValue = nextSReloc->r_value();
			result = true;
		}
		
		switch (sreloc->r_type()) {
			case ARM_RELOC_VANILLA:
				if ( sreloc->r_length() != 2 )
					throw "bad length for ARM_RELOC_VANILLA";

				//fprintf(stderr, "scattered pointer reloc: srcAddr=0x%08X, dstAddr=0x%08X, pointer=0x%08X\n", srcAddr, dstAddr, betterDstAddr);
				betterDstAddr = LittleEndian::get32(*fixUpPtr);
				kind = arm::kPointer;
				if ( strcmp(sect->segname(), "__TEXT") == 0 )
					kind = arm::kReadOnlyPointer;
				// with a scattered relocation we get both the target (sreloc->r_value()) and the target+offset (*fixUpPtr)
				makeReferenceWithToBase(kind, srcAddr, betterDstAddr, dstAddr);
				break;
		
			case ARM_RELOC_BR24:
				// Sign-extend displacement
				displacement = (instruction & 0x00FFFFFF) << 2;
				if ( (displacement & 0x02000000) != 0 )
					displacement |= 0xFC000000;
				// The pc added will be +8 from the pc
				displacement += 8;
				// If this is BLX add H << 1
				if ((instruction & 0xFE000000) == 0xFA000000)
					displacement += ((instruction & 0x01000000) >> 23);
				betterDstAddr = srcAddr+displacement;
				makeReferenceWithToBase(arm::kBranch24, srcAddr, betterDstAddr, dstAddr);
				break;
		
			case ARM_THUMB_RELOC_BR22:
				// thumb2 added two more bits to displacement, complicating the displacement decoding
				{
					uint32_t s = (instruction >> 10) & 0x1;
					uint32_t j1 = (instruction >> 29) & 0x1;
					uint32_t j2 = (instruction >> 27) & 0x1;
					uint32_t imm10 = instruction & 0x3FF;
					uint32_t imm11 = (instruction >> 16) & 0x7FF;
					uint32_t i1 = (j1 == s);
					uint32_t i2 = (j2 == s);
					uint32_t dis = (s << 24) | (i1 << 23) | (i2 << 22) | (imm10 << 12) | (imm11 << 1);
					int32_t sdis = dis;
					if ( s )
						sdis |= 0xFE000000;
					displacement = sdis;
				}
				// The pc added will be +4 from the pc
				displacement += 4;
				betterDstAddr = srcAddr+displacement;
				// If the instruction was blx, force the low 2 bits to be clear
				if ((instruction & 0xF8000000) == 0xE8000000)
					betterDstAddr &= 0xFFFFFFFC;
				makeReferenceWithToBase(arm::kThumbBranch22, srcAddr, betterDstAddr, dstAddr);
				break;
		
			case ARM_RELOC_SECTDIFF:
			case ARM_RELOC_LOCAL_SECTDIFF:
				if ( !nextRelocIsPair ) {
					throw "ARM_RELOC_SECTDIFF missing following pair";
				}
				if ( sreloc->r_length() != 2 )
					throw "bad length for ARM_RELOC_SECTDIFF";
				{
				AtomAndOffset srcao  = findAtomAndOffset(srcAddr);
				AtomAndOffset fromao = findAtomAndOffset(nextRelocValue);
				AtomAndOffset toao   = findAtomAndOffset(dstAddr);
				// check for addend encoded in the section content
				pointerValue = LittleEndian::get32(*fixUpPtr);
				if ( (dstAddr - nextRelocValue) != pointerValue ) {
					if ( toao.atom == srcao.atom )
						toao.offset += (pointerValue + nextRelocValue) - dstAddr;
					else if ( fromao.atom == srcao.atom )
						toao.offset += (pointerValue + nextRelocValue) - dstAddr;
					else
						fromao.offset += (dstAddr - pointerValue) - nextRelocValue;
				}
				new Reference<arm>(arm::kPointerDiff, srcao, fromao, toao);
				}
				break;
			
			default:
				warning("unexpected srelocation type %u", sreloc->r_type());
				break;
		}
	}
	return result;
}

template <typename A>
void Reader<A>::addReferencesForSection(const macho_section<P>* sect)
{
	// ignore dwarf sections.  If ld ever supports processing dwarf, this logic will need to change
	if ( (sect->flags() & S_ATTR_DEBUG) == 0 ) {
		switch ( sect->flags() & SECTION_TYPE ) {
			case S_SYMBOL_STUBS:
			case S_LAZY_SYMBOL_POINTERS:
				// we ignore compiler generated stubs, so ignore those relocs too
				break;
			default:
				// ignore all relocations in __eh_frame section
				if ( sect == fehFrameSection )
					return;
				const macho_relocation_info<P>* relocs = (macho_relocation_info<P>*)((char*)(fHeader) + sect->reloff());
				const uint32_t relocCount = sect->nreloc();
				//fprintf(stderr, "relocCount = %d in section %s\n", relocCount, sect->sectname());
				for (uint32_t r = 0; r < relocCount; ++r) {
					try {
						if ( addRelocReference(sect, &relocs[r]) )
							++r; // skip next
					}
					catch (const char* msg) {
						throwf("in section %s,%s reloc %u: %s", sect->segname(), sect->sectname(), r, msg);
					}
				}
		}
	}
}


template <>
const char* Reference<x86>::getDescription() const
{
	static char temp[2048];
	switch( fKind ) {
		case x86::kNoFixUp:
			sprintf(temp, "reference to ");
			break;
		case x86::kFollowOn:
			sprintf(temp, "followed by ");
			break;
		case x86::kGroupSubordinate:
			sprintf(temp, "group subordinate ");
			break;
		case x86::kPointerWeakImport:
			sprintf(temp, "offset 0x%04X, weak import pointer to ", fFixUpOffsetInSrc);
			break;
		case x86::kPointer:
			sprintf(temp, "offset 0x%04X, pointer to ", fFixUpOffsetInSrc);
			break;
		case x86::kPointerDiff:
			{
			// by-name references have quoted names
			const char* targetQuotes = (&(this->getTarget()) == NULL) ? "\"" : "";
			const char* fromQuotes = (&(this->getFromTarget()) == NULL) ? "\"" : "";
			sprintf(temp, "offset 0x%04X, 32-bit pointer difference: (&%s%s%s + 0x%08X) - (&%s%s%s + 0x%08X)",
				fFixUpOffsetInSrc, targetQuotes, this->getTargetDisplayName(), targetQuotes, fToTarget.offset,
							   fromQuotes, this->getFromTargetDisplayName(), fromQuotes, fFromTarget.offset );
			return temp;
			}
			break;
		case x86::kPointerDiff16:
			{
			// by-name references have quoted names
			const char* targetQuotes = (&(this->getTarget()) == NULL) ? "\"" : "";
			const char* fromQuotes = (&(this->getFromTarget()) == NULL) ? "\"" : "";
			sprintf(temp, "offset 0x%04X, 16-bit pointer difference: (&%s%s%s + 0x%08X) - (&%s%s%s + 0x%08X)",
				fFixUpOffsetInSrc, targetQuotes, this->getTargetDisplayName(), targetQuotes, fToTarget.offset,
							   fromQuotes, this->getFromTargetDisplayName(), fromQuotes, fFromTarget.offset );
			return temp;
			}
			break;
		case x86::kPCRel32WeakImport:
			sprintf(temp, "offset 0x%04X, rel32 reference to weak imported ", fFixUpOffsetInSrc);
			break;
		case x86::kPCRel32:
			sprintf(temp, "offset 0x%04X, rel32 reference to ", fFixUpOffsetInSrc);
			break;
		case x86::kPCRel16:
			sprintf(temp, "offset 0x%04X, rel16 reference to ", fFixUpOffsetInSrc);
			break;
		case x86::kPCRel8:
			sprintf(temp, "offset 0x%04X, rel8 reference to ", fFixUpOffsetInSrc);
			break;
		case x86::kAbsolute32:
			sprintf(temp, "offset 0x%04X, absolute32 reference to ", fFixUpOffsetInSrc);
			break;
		case x86::kImageOffset32:
			sprintf(temp, "offset 0x%04X, 32-bit offset of ", fFixUpOffsetInSrc);
			break;
		case x86::kPointerDiff24:
			sprintf(temp, "offset 0x%04X, 24-bit pointer difference: (&%s + 0x%08X) - (&%s + 0x%08X)",
				fFixUpOffsetInSrc, this->getTargetDisplayName(), fToTarget.offset,
							   this->getFromTargetDisplayName(), fFromTarget.offset );
			return temp;
			break;
		case x86::kSectionOffset24:
			sprintf(temp, "offset 0x%04X, 24-bit section offset of ", fFixUpOffsetInSrc);
			break;
		case x86::kDtraceProbe:
			sprintf(temp, "offset 0x%04X, dtrace static probe ", fFixUpOffsetInSrc);
			break;
		case x86::kDtraceProbeSite:
			sprintf(temp, "offset 0x%04X, dtrace static probe site", fFixUpOffsetInSrc);
			break;
		case x86::kDtraceIsEnabledSite:
			sprintf(temp, "offset 0x%04X, dtrace static probe is-enabled site", fFixUpOffsetInSrc);
			break;
		case x86::kDtraceTypeReference:
			sprintf(temp, "offset 0x%04X, dtrace type/stability reference", fFixUpOffsetInSrc);
			break;
	}
	// always quote by-name references
	if ( fToTargetName != NULL ) {
		strcat(temp, "\"");
		strcat(temp, fToTargetName);
		strcat(temp, "\"");
	}
	else if ( fToTarget.atom != NULL ) {
		strcat(temp, fToTarget.atom->getDisplayName());
	}
	else {
		strcat(temp, "NULL target");
	}
	if ( fToTarget.offset != 0 )
		sprintf(&temp[strlen(temp)], " plus 0x%08X", fToTarget.offset);

	return temp;
}


template <>
const char* Reference<ppc>::getDescription() const
{
	static char temp[2048];
	switch( fKind ) {
		case ppc::kNoFixUp:
			sprintf(temp, "reference to ");
			break;
		case ppc::kFollowOn:
			sprintf(temp, "followed by ");
			break;
		case ppc::kGroupSubordinate:
			sprintf(temp, "group subordinate ");
			break;
		case ppc::kPointerWeakImport:
			sprintf(temp, "offset 0x%04X, weak import pointer to ", fFixUpOffsetInSrc);
			break;
		case ppc::kPointer:
			sprintf(temp, "offset 0x%04X, pointer to ", fFixUpOffsetInSrc);
			break;
		case ppc::kPointerDiff16:
			{
			// by-name references have quoted names
			const char* targetQuotes = (&(this->getTarget()) == NULL) ? "\"" : "";
			const char* fromQuotes = (&(this->getFromTarget()) == NULL) ? "\"" : "";
			sprintf(temp, "offset 0x%04X, 16-bit pointer difference: (&%s%s%s + %d) - (&%s%s%s + %d)",
				fFixUpOffsetInSrc, targetQuotes, this->getTargetDisplayName(), targetQuotes, fToTarget.offset,
							   fromQuotes, this->getFromTargetDisplayName(), fromQuotes, fFromTarget.offset );
			return temp;
			}
		case ppc::kPointerDiff32:
			{
			// by-name references have quoted names
			const char* targetQuotes = (&(this->getTarget()) == NULL) ? "\"" : "";
			const char* fromQuotes = (&(this->getFromTarget()) == NULL) ? "\"" : "";
			sprintf(temp, "offset 0x%04X, 32-bit pointer difference: (&%s%s%s + %d) - (&%s%s%s + %d)",
				fFixUpOffsetInSrc, targetQuotes, this->getTargetDisplayName(), targetQuotes, fToTarget.offset,
							   fromQuotes, this->getFromTargetDisplayName(), fromQuotes, fFromTarget.offset );
			return temp;
			}
		case ppc::kPointerDiff64:
			throw "unsupported refrence kind";
			break;
		case ppc::kBranch24WeakImport:
			sprintf(temp, "offset 0x%04X, pc-rel branch fixup to weak imported ", fFixUpOffsetInSrc);
			break;
		case ppc::kBranch24:
		case ppc::kBranch14:
			sprintf(temp, "offset 0x%04X, pc-rel branch fixup to ", fFixUpOffsetInSrc);
			break;
		case ppc::kPICBaseLow16:
			sprintf(temp, "offset 0x%04X, low  16 fixup from pic-base of %s plus 0x%04X to ", fFixUpOffsetInSrc, fFromTarget.atom->getDisplayName(), fFromTarget.offset);
			break;
		case ppc::kPICBaseLow14:
			sprintf(temp, "offset 0x%04X, low  14 fixup from pic-base of %s plus 0x%04X to ", fFixUpOffsetInSrc, fFromTarget.atom->getDisplayName(), fFromTarget.offset);
			break;
		case ppc::kPICBaseHigh16:
			sprintf(temp, "offset 0x%04X, high 16 fixup from pic-base of %s plus 0x%04X to ", fFixUpOffsetInSrc, fFromTarget.atom->getDisplayName(), fFromTarget.offset);
			break;
		case ppc::kAbsLow16:
			sprintf(temp, "offset 0x%04X, low  16 fixup to absolute address of ", fFixUpOffsetInSrc);
			break;
		case ppc::kAbsLow14:
			sprintf(temp, "offset 0x%04X, low  14 fixup to absolute address of ", fFixUpOffsetInSrc);
			break;
		case ppc::kAbsHigh16:
			sprintf(temp, "offset 0x%04X, high 16 fixup or to absolute address of ", fFixUpOffsetInSrc);
			break;
		case ppc::kAbsHigh16AddLow:
			sprintf(temp, "offset 0x%04X, high 16 fixup add to absolute address of ", fFixUpOffsetInSrc);
			break;
		case ppc::kDtraceProbe:
			sprintf(temp, "offset 0x%04X, dtrace static probe ", fFixUpOffsetInSrc);
			break;
		case ppc::kDtraceProbeSite:
			sprintf(temp, "offset 0x%04X, dtrace static probe site", fFixUpOffsetInSrc);
			break;
		case ppc::kDtraceIsEnabledSite:
			sprintf(temp, "offset 0x%04X, dtrace static probe is-enabled site", fFixUpOffsetInSrc);
			break;
		case ppc::kDtraceTypeReference:
			sprintf(temp, "offset 0x%04X, dtrace type/stability reference", fFixUpOffsetInSrc);
			break;
	}
	// always quote by-name references
	if ( fToTargetName != NULL ) {
		strcat(temp, "\"");
		strcat(temp, fToTargetName);
		strcat(temp, "\"");
	}
	else if ( fToTarget.atom != NULL ) {
		strcat(temp, fToTarget.atom->getDisplayName());
	}
	else {
		strcat(temp, "NULL target");
	}
	if ( fToTarget.offset != 0 )
		sprintf(&temp[strlen(temp)], " plus 0x%08X", fToTarget.offset);

	return temp;
}

template <>
const char* Reference<ppc64>::getDescription() const
{
	static char temp[2048];
	switch( fKind ) {
		case ppc64::kNoFixUp:
			sprintf(temp, "reference to ");
			break;
		case ppc64::kFollowOn:
			sprintf(temp, "followed by ");
			break;
		case ppc64::kGroupSubordinate:
			sprintf(temp, "group subordinate ");
			break;
		case ppc64::kPointerWeakImport:
			sprintf(temp, "offset 0x%04llX, weak import pointer to ", fFixUpOffsetInSrc);
			break;
		case ppc64::kPointer:
			sprintf(temp, "offset 0x%04llX, pointer to ", fFixUpOffsetInSrc);
			break;
		case ppc64::kPointerDiff64:
			{
			// by-name references have quoted names
			const char* targetQuotes = (&(this->getTarget()) == NULL) ? "\"" : "";
			const char* fromQuotes = (&(this->getFromTarget()) == NULL) ? "\"" : "";
			sprintf(temp, "offset 0x%04llX, 64-bit pointer difference: (&%s%s%s + %u) - (&%s%s%s + %u)",
				fFixUpOffsetInSrc, targetQuotes, this->getTargetDisplayName(), targetQuotes, fToTarget.offset,
							   fromQuotes, this->getFromTargetDisplayName(), fromQuotes, fFromTarget.offset );
			return temp;
			}
		case ppc64::kPointerDiff32:
			{
			// by-name references have quoted names
			const char* targetQuotes = (&(this->getTarget()) == NULL) ? "\"" : "";
			const char* fromQuotes = (&(this->getFromTarget()) == NULL) ? "\"" : "";
			sprintf(temp, "offset 0x%04llX, 32-bit pointer difference: (&%s%s%s + %u) - (&%s%s%s + %u)",
				fFixUpOffsetInSrc, targetQuotes, this->getTargetDisplayName(), targetQuotes, fToTarget.offset,
							   fromQuotes, this->getFromTargetDisplayName(), fromQuotes, fFromTarget.offset );
			return temp;
			}
		case ppc64::kPointerDiff16:
			{
			// by-name references have quoted names
			const char* targetQuotes = (&(this->getTarget()) == NULL) ? "\"" : "";
			const char* fromQuotes = (&(this->getFromTarget()) == NULL) ? "\"" : "";
			sprintf(temp, "offset 0x%04llX, 16-bit pointer difference: (&%s%s%s + %u) - (&%s%s%s + %u)",
				fFixUpOffsetInSrc, targetQuotes, this->getTargetDisplayName(), targetQuotes, fToTarget.offset,
							   fromQuotes, this->getFromTargetDisplayName(), fromQuotes, fFromTarget.offset );
			return temp;
			}
		case ppc64::kBranch24WeakImport:
			sprintf(temp, "offset 0x%04llX, pc-rel branch fixup to weak imported ", fFixUpOffsetInSrc);
			break;
		case ppc64::kBranch24:
		case ppc64::kBranch14:
			sprintf(temp, "offset 0x%04llX, pc-rel branch fixup to ", fFixUpOffsetInSrc);
			break;
		case ppc64::kPICBaseLow16:
			sprintf(temp, "offset 0x%04llX, low  16 fixup from pic-base offset 0x%04X to ", fFixUpOffsetInSrc, fFromTarget.offset);
			break;
		case ppc64::kPICBaseLow14:
			sprintf(temp, "offset 0x%04llX, low  14 fixup from pic-base offset 0x%04X to ", fFixUpOffsetInSrc, fFromTarget.offset);
			break;
		case ppc64::kPICBaseHigh16:
			sprintf(temp, "offset 0x%04llX, high 16 fixup from pic-base offset 0x%04X to ", fFixUpOffsetInSrc, fFromTarget.offset);
			break;
		case ppc64::kAbsLow16:
			sprintf(temp, "offset 0x%04llX, low  16 fixup to absolute address of ", fFixUpOffsetInSrc);
			break;
		case ppc64::kAbsLow14:
			sprintf(temp, "offset 0x%04llX, low  14 fixup to absolute address of ", fFixUpOffsetInSrc);
			break;
		case ppc64::kAbsHigh16:
			sprintf(temp, "offset 0x%04llX, high 16 fixup or to absolute address of ", fFixUpOffsetInSrc);
			break;
		case ppc64::kAbsHigh16AddLow:
			sprintf(temp, "offset 0x%04llX, high 16 fixup add to absolute address of ", fFixUpOffsetInSrc);
			break;
		case ppc64::kDtraceProbe:
			sprintf(temp, "offset 0x%04llX, dtrace static probe ", fFixUpOffsetInSrc);
			break;
		case ppc64::kDtraceProbeSite:
			sprintf(temp, "offset 0x%04llX, dtrace static probe site", fFixUpOffsetInSrc);
			break;
		case ppc64::kDtraceIsEnabledSite:
			sprintf(temp, "offset 0x%04llX, dtrace static probe is-enabled site", fFixUpOffsetInSrc);
			break;
		case ppc64::kDtraceTypeReference:
			sprintf(temp, "offset 0x%04llX, dtrace type/stability reference", fFixUpOffsetInSrc);
			break;
	}
	// always quote by-name references
	if ( fToTargetName != NULL ) {
		strcat(temp, "\"");
		strcat(temp, fToTargetName);
		strcat(temp, "\"");
	}
	else if ( fToTarget.atom != NULL ) {
		strcat(temp, fToTarget.atom->getDisplayName());
	}
	else {
		strcat(temp, "NULL target");
	}
	if ( fToTarget.offset != 0 )
		sprintf(&temp[strlen(temp)], " plus 0x%llX", this->getTargetOffset());

	return temp;
}


template <>
const char* Reference<x86_64>::getDescription() const
{
	static char temp[2048];
	switch( fKind ) {
		case x86_64::kNoFixUp:
			sprintf(temp, "reference to ");
			break;
		case x86_64::kFollowOn:
			sprintf(temp, "followed by ");
			break;
		case x86_64::kGroupSubordinate:
			sprintf(temp, "group subordinate ");
			break;
		case x86_64::kPointerWeakImport:
			sprintf(temp, "offset 0x%04llX, weak import pointer to ", fFixUpOffsetInSrc);
			break;
		case x86_64::kPointer:
			sprintf(temp, "offset 0x%04llX, pointer to ", fFixUpOffsetInSrc);
			break;
		case x86_64::kPointer32:
			sprintf(temp, "offset 0x%04llX, 32-bit pointer to ", fFixUpOffsetInSrc);
			break;
		case x86_64::kPointerDiff32:
		case x86_64::kPointerDiff:
			{
			// by-name references have quoted names
			const char* targetQuotes = (&(this->getTarget()) == NULL) ? "\"" : "";
			const char* fromQuotes = (&(this->getFromTarget()) == NULL) ? "\"" : "";
			const char* size = (fKind == x86_64::kPointerDiff32) ? "32-bit" : "64-bit";
			sprintf(temp, "offset 0x%04llX, %s pointer difference: (&%s%s%s + 0x%08X) - (&%s%s%s + 0x%08X)",
				fFixUpOffsetInSrc, size, targetQuotes, this->getTargetDisplayName(), targetQuotes, fToTarget.offset,
							   fromQuotes, this->getFromTargetDisplayName(), fromQuotes, fFromTarget.offset );
			return temp;
			}
			break;
		case x86_64::kPCRel32:
			sprintf(temp, "offset 0x%04llX, rel32 reference to ", fFixUpOffsetInSrc);
			break;
		case x86_64::kPCRel32_1:
			sprintf(temp, "offset 0x%04llX, rel32-1 reference to ", fFixUpOffsetInSrc);
			break;
		case x86_64::kPCRel32_2:
			sprintf(temp, "offset 0x%04llX, rel32-2 reference to ", fFixUpOffsetInSrc);
			break;
		case x86_64::kPCRel32_4:
			sprintf(temp, "offset 0x%04llX, rel32-4 reference to ", fFixUpOffsetInSrc);
			break;
		case x86_64::kBranchPCRel32:
			sprintf(temp, "offset 0x%04llX, branch rel32 reference to ", fFixUpOffsetInSrc);
			break;
		case x86_64::kBranchPCRel32WeakImport:
			sprintf(temp, "offset 0x%04llX, branch rel32 reference to weak imported ", fFixUpOffsetInSrc);
			break;
		case x86_64::kPCRel32GOT:
			sprintf(temp, "offset 0x%04llX, rel32 reference to GOT entry for ", fFixUpOffsetInSrc);
			break;
		case x86_64::kPCRel32GOTWeakImport:
			sprintf(temp, "offset 0x%04llX, rel32 reference to GOT entry for weak imported ", fFixUpOffsetInSrc);
			break;
		case x86_64::kPCRel32GOTLoad:
			sprintf(temp, "offset 0x%04llX, rel32 reference to GOT entry for ", fFixUpOffsetInSrc);
			break;
		case x86_64::kPCRel32GOTLoadWeakImport:
			sprintf(temp, "offset 0x%04llX, rel32 reference to GOT entry for weak imported ", fFixUpOffsetInSrc);
			break;
		case x86_64::kGOTNoFixUp:
			sprintf(temp, "reference to GOT entry for ");
			break;
		case x86_64::kBranchPCRel8:
			sprintf(temp, "offset 0x%04llX, branch rel8 reference to ", fFixUpOffsetInSrc);
			break;
		case x86_64::kPointerDiff24:
			sprintf(temp, "offset 0x%04llX, 24-bit pointer difference: (&%s + 0x%08X) - (&%s + 0x%08X)",
				fFixUpOffsetInSrc, this->getTargetDisplayName(), fToTarget.offset,
							   this->getFromTargetDisplayName(), fFromTarget.offset );
			return temp;
		case x86_64::kImageOffset32:
			sprintf(temp, "offset 0x%04llX, 32bit offset of ", fFixUpOffsetInSrc);
			break;
		case x86_64::kSectionOffset24:
			sprintf(temp, "offset 0x%04llX, 24-bit section offset of ", fFixUpOffsetInSrc);
			break;
		case x86_64::kDtraceProbe:
			sprintf(temp, "offset 0x%04llX, dtrace static probe ", fFixUpOffsetInSrc);
			break;
		case x86_64::kDtraceProbeSite:
			sprintf(temp, "offset 0x%04llX, dtrace static probe site", fFixUpOffsetInSrc);
			break;
		case x86_64::kDtraceIsEnabledSite:
			sprintf(temp, "offset 0x%04llX, dtrace static probe is-enabled site", fFixUpOffsetInSrc);
			break;
		case x86_64::kDtraceTypeReference:
			sprintf(temp, "offset 0x%04llX, dtrace type/stability reference", fFixUpOffsetInSrc);
			break;
	}
	// always quote by-name references
	if ( fToTargetName != NULL ) {
		strcat(temp, "\"");
		strcat(temp, fToTargetName);
		strcat(temp, "\"");
	}
	else if ( fToTarget.atom != NULL ) {
		strcat(temp, fToTarget.atom->getDisplayName());
	}
	else {
		strcat(temp, "NULL target");
	}
	if ( fToTarget.offset != 0 )
		sprintf(&temp[strlen(temp)], " plus 0x%llX", this->getTargetOffset());

	return temp;
}


template <>
const char* Reference<arm>::getDescription() const
{
	static char temp[2048];
	switch( fKind ) {
		case arm::kNoFixUp:
			sprintf(temp, "reference to ");
			break;
		case arm::kFollowOn:
			sprintf(temp, "followed by ");
			break;
		case arm::kGroupSubordinate:
			sprintf(temp, "group subordinate ");
			break;
		case arm::kPointer:
			sprintf(temp, "offset 0x%04X, pointer to ", fFixUpOffsetInSrc);
			break;
		case arm::kPointerWeakImport:
			sprintf(temp, "offset 0x%04X, weak import pointer to ", fFixUpOffsetInSrc);
			break;
		case arm::kPointerDiff:
			{
			// by-name references have quoted names
			const char* targetQuotes = (&(this->getTarget()) == NULL) ? "\"" : "";
			const char* fromQuotes = (&(this->getFromTarget()) == NULL) ? "\"" : "";
			sprintf(temp, "offset 0x%04X, 32-bit pointer difference: (&%s%s%s + %d) - (&%s%s%s + %d)",
				fFixUpOffsetInSrc, targetQuotes, this->getTargetDisplayName(), targetQuotes, fToTarget.offset,
							   fromQuotes, this->getFromTargetDisplayName(), fromQuotes, fFromTarget.offset );
			return temp;
			}
		case arm::kReadOnlyPointer:
			sprintf(temp, "offset 0x%04X, read-only pointer to ", fFixUpOffsetInSrc);
			break;
		case arm::kBranch24:
        case arm::kThumbBranch22:
			sprintf(temp, "offset 0x%04X, pc-rel branch fixup to ", fFixUpOffsetInSrc);
			break;
		case arm::kBranch24WeakImport:
        case arm::kThumbBranch22WeakImport:
			sprintf(temp, "offset 0x%04X, pc-rel branch fixup to weak imported ", fFixUpOffsetInSrc);
			break;
		case arm::kDtraceProbe:
			sprintf(temp, "offset 0x%04X, dtrace static probe ", fFixUpOffsetInSrc);
			break;
		case arm::kDtraceProbeSite:
			sprintf(temp, "offset 0x%04X, dtrace static probe site", fFixUpOffsetInSrc);
			break;
		case arm::kDtraceIsEnabledSite:
			sprintf(temp, "offset 0x%04X, dtrace static probe is-enabled site", fFixUpOffsetInSrc);
			break;
		case arm::kDtraceTypeReference:
			sprintf(temp, "offset 0x%04X, dtrace type/stability reference", fFixUpOffsetInSrc);
			break;
	}
	// always quote by-name references
	if ( fToTargetName != NULL ) {
		strcat(temp, "\"");
		strcat(temp, fToTargetName);
		strcat(temp, "\"");
	}
	else if ( fToTarget.atom != NULL ) {
		strcat(temp, fToTarget.atom->getDisplayName());
	}
	else {
		strcat(temp, "NULL target");
	}
	if ( fToTarget.offset != 0 )
		sprintf(&temp[strlen(temp)], " plus 0x%08X", fToTarget.offset);

	return temp;
}


template <>
bool Reference<x86>::isBranch() const
{
	switch ( fKind ) {
		case x86::kPCRel32:
		case x86::kPCRel32WeakImport:
			return true;
		default:
			return false;
	}
}

template <>
bool Reference<x86_64>::isBranch() const
{
	switch ( fKind ) {
		case x86_64::kBranchPCRel32:
		case x86_64::kBranchPCRel32WeakImport:
			return true;
		default:
			return false;
	}
}

template <>
bool Reference<ppc>::isBranch() const
{
	switch ( fKind ) {
		case ppc::kBranch24:
		case ppc::kBranch24WeakImport:
			return true;
		default:
			return false;
	}
}

template <>
bool Reference<ppc64>::isBranch() const
{
	switch ( fKind ) {
		case ppc64::kBranch24:
		case ppc64::kBranch24WeakImport:
			return true;
		default:
			return false;
	}
}

template <>
bool Reference<arm>::isBranch() const
{
	switch ( fKind ) {
		case arm::kBranch24:
		case arm::kBranch24WeakImport:
		case arm::kThumbBranch22:
		case arm::kThumbBranch22WeakImport:
			return true;
		default:
			return false;
	}
}



}; // namespace relocatable
}; // namespace mach_o

#endif // __OBJECT_FILE_MACH_O__