proj/gentoo: Initial commit

This commit represents a new era for Gentoo:
Storing the gentoo-x86 tree in Git, as converted from CVS.

This commit is the start of the NEW history.
Any historical data is intended to be grafted onto this point.

Creation process:
1. Take final CVS checkout snapshot
2. Remove ALL ChangeLog* files
3. Transform all Manifests to thin
4. Remove empty Manifests
5. Convert all stale $Header$/$Id$ CVS keywords to non-expanded Git $Id$
5.1. Do not touch files with -kb/-ko keyword flags.

Signed-off-by: Robin H. Johnson <robbat2@gentoo.org>
X-Thanks: Alec Warner <antarus@gentoo.org> - did the GSoC 2006 migration tests
X-Thanks: Robin H. Johnson <robbat2@gentoo.org> - infra guy, herding this project
X-Thanks: Nguyen Thai Ngoc Duy <pclouds@gentoo.org> - Former Gentoo developer, wrote Git features for the migration
X-Thanks: Brian Harring <ferringb@gentoo.org> - wrote much python to improve cvs2svn
X-Thanks: Rich Freeman <rich0@gentoo.org> - validation scripts
X-Thanks: Patrick Lauer <patrick@gentoo.org> - Gentoo dev, running new 2014 work in migration
X-Thanks: Michał Górny <mgorny@gentoo.org> - scripts, QA, nagging
X-Thanks: All of other Gentoo developers - many ideas and lots of paint on the bikeshed

1 files changed, 1029 insertions, 0 deletions

diff --git a/sys-devel/binutils-apple/files/ld64-241.9-gcc.patch b/sys-devel/binutils-apple/files/ld64-241.9-gcc.patch
new file mode 100644
index 000000000000..06b735b242a5
--- /dev/null
+++ b/sys-devel/binutils-apple/files/ld64-241.9-gcc.patch
@@ -0,0 +1,1029 @@
+Provide c++11 headers from tr1 include directory and namespace.
+
+Work around weird namespacing bug in gcc-4.2.1 where class ld::Section
+conflicts with template mach_o::relocatable::Section by renaming the latter to
+MRFSection (could possibly be done using sed from ebuild or avoided by figuring
+out, what's actually going on with those namespaces).
+
+--- ./ld64-241.9/src/ld/InputFiles.h.gcc	2014-09-11 00:24:46.000000000 +0200
++++ ./ld64-241.9/src/ld/InputFiles.h	2015-01-12 22:12:18.000000000 +0100
+@@ -46,6 +46,14 @@
+ #include <pthread.h>
+ #endif
+ 
++#ifdef __GLIBCXX__
++#include <tr1/unordered_map>
++#define UNORDERED_MAP tr1::unordered_map
++#else
++#include <unordered_map>
++#define UNORDERED_MAP unordered_map
++#endif
++
+ #include <vector>
+ 
+ #include "Options.h"
+@@ -107,7 +115,7 @@
+ 	static void					parseWorkerThread(InputFiles *inputFiles);
+ 	void						startThread(void (*threadFunc)(InputFiles *)) const;
+ 
+-	typedef std::unordered_map<const char*, ld::dylib::File*, CStringHash, CStringEquals>	InstallNameToDylib;
++	typedef std::UNORDERED_MAP<const char*, ld::dylib::File*, CStringHash, CStringEquals>	InstallNameToDylib;
+ 
+ 	const Options&				_options;
+ 	std::vector<ld::File*>		_inputFiles;
+--- ./ld64-241.9/src/ld/ld.cpp.gcc	2014-09-11 00:24:46.000000000 +0200
++++ ./ld64-241.9/src/ld/ld.cpp	2015-01-12 22:12:18.000000000 +0100
+@@ -54,7 +54,13 @@
+ #include <vector>
+ #include <list>
+ #include <algorithm>
++#ifdef __GLIBCXX__
++#include <tr1/unordered_map>
++#define UNORDERED_MAP tr1::unordered_map
++#else
+ #include <unordered_map>
++#define UNORDERED_MAP unordered_map
++#endif
+ #include <cxxabi.h>
+ 
+ #include "Options.h"
+@@ -149,7 +155,7 @@
+ 	struct SectionEquals {
+ 		bool operator()(const ld::Section* left, const ld::Section* right) const;
+ 	};
+-	typedef std::unordered_map<const ld::Section*, FinalSection*, SectionHash, SectionEquals> SectionInToOut;
++	typedef std::UNORDERED_MAP<const ld::Section*, FinalSection*, SectionHash, SectionEquals> SectionInToOut;
+ 	
+ 
+ 	SectionInToOut			_sectionInToFinalMap;
+--- ./ld64-241.9/src/ld/ld.hpp.gcc	2014-09-11 00:24:46.000000000 +0200
++++ ./ld64-241.9/src/ld/ld.hpp	2015-01-12 22:12:18.000000000 +0100
+@@ -32,7 +32,13 @@
+ #include <assert.h>
+ 
+ #include <vector>
++#ifdef __GLIBCXX__
++#include <tr1/unordered_set>
++#define UNORDERED_SET tr1::unordered_set
++#else
+ #include <unordered_set>
++#define UNORDERED_SET unordered_set
++#endif
+ 
+ #include "configure.h"
+ 
+@@ -822,7 +828,7 @@
+ 	bool operator()(const char* left, const char* right) const { return (strcmp(left, right) == 0); }
+ };
+ 
+-typedef	std::unordered_set<const char*, ld::CStringHash, ld::CStringEquals>  CStringSet;
++typedef	std::UNORDERED_SET<const char*, ld::CStringHash, ld::CStringEquals>  CStringSet;
+ 
+ class Internal
+ {
+--- ./ld64-241.9/src/ld/LinkEditClassic.hpp.gcc	2014-09-11 00:24:46.000000000 +0200
++++ ./ld64-241.9/src/ld/LinkEditClassic.hpp	2015-01-12 22:12:18.000000000 +0100
+@@ -31,8 +31,13 @@
+ #include <limits.h>
+ #include <unistd.h>
+ 
+-#include <vector>
++#ifdef __GLIBCXX__
++#include <tr1/unordered_map>
++#define UNORDERED_MAP tr1::unordered_map
++#else
+ #include <unordered_map>
++#define UNORDERED_MAP unordered_map
++#endif
+ 
+ #include "Options.h"
+ #include "ld.hpp"
+@@ -92,7 +97,7 @@
+ 
+ private:
+ 	enum { kBufferSize = 0x01000000 };
+-	typedef std::unordered_map<const char*, int32_t, CStringHash, CStringEquals> StringToOffset;
++	typedef std::UNORDERED_MAP<const char*, int32_t, CStringHash, CStringEquals> StringToOffset;
+ 
+ 	const uint32_t							_pointerSize;
+ 	std::vector<char*>						_fullBuffers;
+--- ./ld64-241.9/src/ld/Options.cpp.gcc	2014-11-04 00:25:08.000000000 +0100
++++ ./ld64-241.9/src/ld/Options.cpp	2015-01-12 22:12:18.000000000 +0100
+@@ -4548,7 +4548,7 @@
+ 
+ 	// make sure all required exported symbols exist
+ 	std::vector<const char*> impliedExports;
+-	for (NameSet::iterator it=fExportSymbols.regularBegin(); it != fExportSymbols.regularEnd(); ++it) {
++	for (NameSet::const_iterator it=fExportSymbols.regularBegin(); it != fExportSymbols.regularEnd(); ++it) {
+ 		const char* name = *it;
+ 		const int len = strlen(name);
+ 		if ( (strcmp(&name[len-3], ".eh") == 0) || (strncmp(name, ".objc_category_name_", 20) == 0) ) {
+@@ -4580,7 +4580,7 @@
+ 	}
+ 
+ 	// make sure all required re-exported symbols exist
+-	for (NameSet::iterator it=fReExportSymbols.regularBegin(); it != fReExportSymbols.regularEnd(); ++it) {
++	for (NameSet::const_iterator it=fReExportSymbols.regularBegin(); it != fReExportSymbols.regularEnd(); ++it) {
+ 		fInitialUndefines.push_back(*it);
+ 	}
+ 	
+--- ./ld64-241.9/src/ld/Options.h.gcc	2014-11-04 00:29:32.000000000 +0100
++++ ./ld64-241.9/src/ld/Options.h	2015-01-12 22:12:18.000000000 +0100
+@@ -30,8 +30,17 @@
+ #include <mach/machine.h>
+ 
+ #include <vector>
++#ifdef __GLIBCXX__
++#include <tr1/unordered_set>
++#include <tr1/unordered_map>
++#define UNORDERED_MAP tr1::unordered_map
++#define UNORDERED_SET tr1::unordered_set
++#else
+ #include <unordered_set>
+ #include <unordered_map>
++#define UNORDERED_MAP unordered_map
++#define UNORDERED_SET unordered_set
++#endif
+ 
+ #include "ld.hpp"
+ #include "Snapshot.h"
+@@ -396,8 +405,8 @@
+ 	bool						moveRwSymbol(const char* symName, const char* filePath, const char*& seg, bool& wildCardMatch) const;
+ 
+ private:
+-	typedef std::unordered_map<const char*, unsigned int, ld::CStringHash, ld::CStringEquals> NameToOrder;
+-	typedef std::unordered_set<const char*, ld::CStringHash, ld::CStringEquals>  NameSet;
++	typedef std::UNORDERED_MAP<const char*, unsigned int, ld::CStringHash, ld::CStringEquals> NameToOrder;
++	typedef std::UNORDERED_SET<const char*, ld::CStringHash, ld::CStringEquals>  NameSet;
+ 	enum ExportMode { kExportDefault, kExportSome, kDontExportSome };
+ 	enum LibrarySearchMode { kSearchDylibAndArchiveInEachDir, kSearchAllDirsForDylibsThenAllDirsForArchives };
+ 	enum InterposeMode { kInterposeNone, kInterposeAllExternal, kInterposeSome };
+@@ -410,8 +419,8 @@
+ 		bool					containsNonWildcard(const char*) const;
+ 		bool					empty() const			{ return fRegular.empty() && fWildCard.empty(); }
+ 		bool					hasWildCards() const	{ return !fWildCard.empty(); }
+-		NameSet::iterator		regularBegin() const	{ return fRegular.begin(); }
+-		NameSet::iterator		regularEnd() const		{ return fRegular.end(); }
++		NameSet::const_iterator		regularBegin() const	{ return fRegular.begin(); }
++		NameSet::const_iterator		regularEnd() const		{ return fRegular.end(); }
+ 		void					remove(const NameSet&); 
+ 	private:
+ 		static bool				hasWildCards(const char*);
+--- ./ld64-241.9/src/ld/OutputFile.cpp.gcc	2014-09-11 00:24:46.000000000 +0200
++++ ./ld64-241.9/src/ld/OutputFile.cpp	2015-01-12 22:12:18.000000000 +0100
+@@ -50,7 +50,13 @@
+ #include <vector>
+ #include <list>
+ #include <algorithm>
++#ifdef __GLIBCXX__
++#include <tr1/unordered_set>
++#define UNORDERED_SET tr1::unordered_set
++#else
+ #include <unordered_set>
++#define UNORDERED_SET unordered_set
++#endif
+ 
+ #include <CommonCrypto/CommonDigest.h>
+ #include <AvailabilityMacros.h>
+@@ -4748,7 +4754,7 @@
+ 	const char* filename = NULL;
+ 	bool wroteStartSO = false;
+ 	state.stabs.reserve(atomsNeedingDebugNotes.size()*4);
+-	std::unordered_set<const char*, CStringHash, CStringEquals>  seenFiles;
++	std::UNORDERED_SET<const char*, CStringHash, CStringEquals>  seenFiles;
+ 	for (std::vector<const ld::Atom*>::iterator it=atomsNeedingDebugNotes.begin(); it != atomsNeedingDebugNotes.end(); it++) {
+ 		const ld::Atom* atom = *it;
+ 		const ld::File* atomFile = atom->file();
+--- ./ld64-241.9/src/ld/parsers/archive_file.cpp.gcc	2014-09-11 00:24:46.000000000 +0200
++++ ./ld64-241.9/src/ld/parsers/archive_file.cpp	2015-01-12 22:12:18.000000000 +0100
+@@ -33,7 +33,13 @@
+ #include <set>
+ #include <map>
+ #include <algorithm>
++#ifdef __GLIBCXX__
++#include <tr1/unordered_map>
++#define UNORDERED_MAP tr1::unordered_map
++#else
+ #include <unordered_map>
++#define UNORDERED_MAP unordered_map
++#endif
+ 
+ #include "MachOFileAbstraction.hpp"
+ #include "Architectures.hpp"
+@@ -112,7 +118,7 @@
+ 	struct MemberState { ld::relocatable::File* file; const Entry *entry; bool logged; bool loaded; uint32_t index;};
+ 	bool											loadMember(MemberState& state, ld::File::AtomHandler& handler, const char *format, ...) const;
+ 
+-	typedef std::unordered_map<const char*, const struct ranlib*, ld::CStringHash, ld::CStringEquals> NameToEntryMap;
++	typedef std::UNORDERED_MAP<const char*, const struct ranlib*, ld::CStringHash, ld::CStringEquals> NameToEntryMap;
+ 
+ 	typedef typename A::P							P;
+ 	typedef typename A::P::E						E;
+--- ./ld64-241.9/src/ld/parsers/lto_file.cpp.gcc	2014-11-04 00:59:51.000000000 +0100
++++ ./ld64-241.9/src/ld/parsers/lto_file.cpp	2015-01-12 22:12:18.000000000 +0100
+@@ -33,8 +33,17 @@
+ #include <pthread.h>
+ #include <mach-o/dyld.h>
+ #include <vector>
++#ifdef __GLIBCXX__
++#include <tr1/unordered_set>
++#include <tr1/unordered_map>
++#define UNORDERED_MAP tr1::unordered_map
++#define UNORDERED_SET tr1::unordered_set
++#else
+ #include <unordered_set>
+ #include <unordered_map>
++#define UNORDERED_MAP unordered_map
++#define UNORDERED_SET unordered_set
++#endif
+ 
+ #include "MachOFileAbstraction.hpp"
+ #include "Architectures.hpp"
+@@ -218,8 +227,8 @@
+ 	static void ltoDiagnosticHandler(lto_codegen_diagnostic_severity_t, const char*, void*);
+ #endif
+ 
+-	typedef	std::unordered_set<const char*, ld::CStringHash, ld::CStringEquals>  CStringSet;
+-	typedef std::unordered_map<const char*, Atom*, ld::CStringHash, ld::CStringEquals> CStringToAtom;
++	typedef	std::UNORDERED_SET<const char*, ld::CStringHash, ld::CStringEquals>  CStringSet;
++	typedef std::UNORDERED_MAP<const char*, Atom*, ld::CStringHash, ld::CStringEquals> CStringToAtom;
+ 	
+ 	class AtomSyncer : public ld::File::AtomHandler {
+ 	public:
+--- ./ld64-241.9/src/ld/parsers/macho_dylib_file.cpp.gcc	2014-09-11 00:24:46.000000000 +0200
++++ ./ld64-241.9/src/ld/parsers/macho_dylib_file.cpp	2015-01-12 22:12:18.000000000 +0100
+@@ -34,8 +34,17 @@
+ #include <vector>
+ #include <set>
+ #include <algorithm>
+-#include <unordered_map>
++#ifdef __GLIBCXX__
++#include <tr1/unordered_set>
++#include <tr1/unordered_map>
++#define UNORDERED_MAP tr1::unordered_map
++#define UNORDERED_SET tr1::unordered_set
++#else
+ #include <unordered_set>
++#include <unordered_map>
++#define UNORDERED_MAP unordered_map
++#define UNORDERED_SET unordered_set
++#endif
+ 
+ #include "Architectures.hpp"
+ #include "MachOFileAbstraction.hpp"
+@@ -193,8 +202,8 @@
+ 		};
+ 	};
+ 	struct AtomAndWeak { ld::Atom* atom; bool weakDef; bool tlv; pint_t address; };
+-	typedef std::unordered_map<const char*, AtomAndWeak, ld::CStringHash, ld::CStringEquals> NameToAtomMap;
+-	typedef std::unordered_set<const char*, CStringHash, ld::CStringEquals>  NameSet;
++	typedef std::UNORDERED_MAP<const char*, AtomAndWeak, ld::CStringHash, ld::CStringEquals> NameToAtomMap;
++	typedef std::UNORDERED_SET<const char*, CStringHash, ld::CStringEquals>  NameSet;
+ 
+ 	struct Dependent { const char* path; File<A>* dylib; bool reExport; };
+ 
+@@ -562,14 +571,18 @@
+ 		if ( _s_logHashtable ) fprintf(stderr, "ld: building hashtable of %u toc entries for %s\n", dynamicInfo->nextdefsym(), this->path());
+ 		const macho_nlist<P>* start = &symbolTable[dynamicInfo->iextdefsym()];
+ 		const macho_nlist<P>* end = &start[dynamicInfo->nextdefsym()];
++#ifndef __GLIBCXX__
+ 		_atoms.reserve(dynamicInfo->nextdefsym()); // set initial bucket count
++#endif
+ 		for (const macho_nlist<P>* sym=start; sym < end; ++sym) {
+ 			this->addSymbol(&strings[sym->n_strx()], (sym->n_desc() & N_WEAK_DEF) != 0, false, sym->n_value());
+ 		}
+ 	}
+ 	else {
+ 		int32_t count = dynamicInfo->ntoc();
++#ifndef __GLIBCXX__
+ 		_atoms.reserve(count); // set initial bucket count
++#endif
+ 		if ( _s_logHashtable ) fprintf(stderr, "ld: building hashtable of %u entries for %s\n", count, this->path());
+ 		const struct dylib_table_of_contents* toc = (dylib_table_of_contents*)(fileContent + dynamicInfo->tocoff());
+ 		for (int32_t i = 0; i < count; ++i) {
+--- ./ld64-241.9/src/ld/parsers/macho_relocatable_file.cpp.gcc	2014-11-04 00:57:10.000000000 +0100
++++ ./ld64-241.9/src/ld/parsers/macho_relocatable_file.cpp	2015-01-12 22:22:53.000000000 +0100
+@@ -62,7 +62,7 @@
+ // forward reference
+ template <typename A> class Parser;
+ template <typename A> class Atom;
+-template <typename A> class Section;
++template <typename A> class MRFSection;
+ template <typename A> class CFISection;
+ template <typename A> class CUSection;
+ 
+@@ -102,14 +102,14 @@
+ 	const uint8_t*										fileContent()					{ return _fileContent; }
+ private:
+ 	friend class Atom<A>;
+-	friend class Section<A>;
++	friend class MRFSection<A>;
+ 	friend class Parser<A>;
+ 	friend class CFISection<A>::OAS;
+ 	
+ 	typedef typename A::P					P;
+ 	
+ 	const uint8_t*							_fileContent;
+-	Section<A>**							_sectionsArray;
++	MRFSection<A>**							_sectionsArray;
+ 	uint8_t*								_atomsArray;
+ 	uint8_t*								_aliasAtomsArray;
+ 	uint32_t								_sectionsArrayCount;
+@@ -134,14 +134,14 @@
+ 
+ 
+ template <typename A>
+-class Section : public ld::Section
++class MRFSection : public ld::Section
+ {
+ public:
+ 	typedef typename A::P::uint_t	pint_t;
+ 	typedef typename A::P			P;
+ 	typedef typename A::P::E		E;
+ 
+-	virtual							~Section()					{ }
++	virtual							~MRFSection()					{ }
+ 	class File<A>&					file() const				{ return _file; }
+ 	const macho_section<P>*			machoSection() const		{ return _machOSection; }
+ 	uint32_t						sectionNum(class Parser<A>&) const;
+@@ -165,10 +165,10 @@
+ 	static const char*				makeSectionName(const macho_section<typename A::P>* s);
+ 
+ protected:	
+-						Section(File<A>& f, const macho_section<typename A::P>* s)
++						MRFSection(File<A>& f, const macho_section<typename A::P>* s)
+ 							: ld::Section(makeSegmentName(s), makeSectionName(s), sectionType(s)),
+ 								_file(f), _machOSection(s), _beginAtoms(NULL), _endAtoms(NULL), _hasAliases(false) { }
+-						Section(File<A>& f, const char* segName, const char* sectName, ld::Section::Type t, bool hidden=false)
++						MRFSection(File<A>& f, const char* segName, const char* sectName, ld::Section::Type t, bool hidden=false)
+ 							: ld::Section(segName, sectName, t, hidden), _file(f), _machOSection(NULL), 
+ 								_beginAtoms(NULL), _endAtoms(NULL), _hasAliases(false) { }
+ 
+@@ -192,11 +192,11 @@
+ 
+ 
+ template <typename A>
+-class CFISection : public Section<A>
++class CFISection : public MRFSection<A>
+ {
+ public:
+ 						CFISection(Parser<A>& parser, File<A>& f, const macho_section<typename A::P>* s)
+-							: Section<A>(f, s) { }
++							: MRFSection<A>(f, s) { }
+ 	uint32_t			cfiCount(Parser<A>& parser);
+ 
+ 	virtual ld::Atom::ContentType	contentType()		{ return ld::Atom::typeCFI; }
+@@ -256,11 +256,11 @@
+ 
+ 
+ template <typename A>
+-class CUSection : public Section<A>
++class CUSection : public MRFSection<A>
+ {
+ public:
+ 						CUSection(Parser<A>& parser, File<A>& f, const macho_section<typename A::P>* s)
+-							: Section<A>(f, s) { }
++							: MRFSection<A>(f, s) { }
+ 
+ 	typedef typename A::P::uint_t	pint_t;
+ 	typedef typename A::P			P;
+@@ -297,11 +297,11 @@
+ 
+ 
+ template <typename A>
+-class TentativeDefinitionSection : public Section<A>
++class TentativeDefinitionSection : public MRFSection<A>
+ {
+ public:
+ 						TentativeDefinitionSection(Parser<A>& parser, File<A>& f)
+-							: Section<A>(f, "__DATA", "__comm/tent", ld::Section::typeTentativeDefs)  {}
++							: MRFSection<A>(f, "__DATA", "__comm/tent", ld::Section::typeTentativeDefs)  {}
+ 
+ 	virtual ld::Atom::ContentType	contentType()		{ return ld::Atom::typeZeroFill; }
+ 	virtual bool		addFollowOnFixups() const	{ return false; }
+@@ -319,11 +319,11 @@
+ 
+ 
+ template <typename A>
+-class AbsoluteSymbolSection : public Section<A>
++class AbsoluteSymbolSection : public MRFSection<A>
+ {
+ public:
+ 						AbsoluteSymbolSection(Parser<A>& parser, File<A>& f)
+-							: Section<A>(f, "__DATA", "__abs", ld::Section::typeAbsoluteSymbols, true)  {}
++							: MRFSection<A>(f, "__DATA", "__abs", ld::Section::typeAbsoluteSymbols, true)  {}
+ 
+ 	virtual ld::Atom::ContentType	contentType()		{ return ld::Atom::typeUnclassified; }
+ 	virtual bool					dontDeadStrip()		{ return false; }
+@@ -345,7 +345,7 @@
+ 
+ 
+ template <typename A>
+-class SymboledSection : public Section<A>
++class SymboledSection : public MRFSection<A>
+ {
+ public:
+ 						SymboledSection(Parser<A>& parser, File<A>& f, const macho_section<typename A::P>* s);
+@@ -377,11 +377,11 @@
+ 
+ 
+ template <typename A>
+-class ImplicitSizeSection : public Section<A>
++class ImplicitSizeSection : public MRFSection<A>
+ {
+ public:
+ 						ImplicitSizeSection(Parser<A>& parser, File<A>& f, const macho_section<typename A::P>* s)
+-							: Section<A>(f, s) { }
++							: MRFSection<A>(f, s) { }
+ 	virtual uint32_t	computeAtomCount(class Parser<A>& parser, struct Parser<A>::LabelAndCFIBreakIterator& it, const struct Parser<A>::CFI_CU_InfoArrays&);
+ 	virtual uint32_t	appendAtoms(class Parser<A>& parser, uint8_t* buffer, struct Parser<A>::LabelAndCFIBreakIterator& it, const struct Parser<A>::CFI_CU_InfoArrays&);
+ protected:
+@@ -715,8 +715,8 @@
+ 
+ public:
+ 	// methods for all atoms from mach-o object file
+-			Section<A>&							sect() const			{ return (Section<A>&)section(); }
+-			File<A>&							machofile() const			{ return ((Section<A>*)(this->_section))->file(); }
++			MRFSection<A>&							sect() const			{ return (MRFSection<A>&)section(); }
++			File<A>&							machofile() const			{ return ((MRFSection<A>*)(this->_section))->file(); }
+ 			void								setFixupsRange(uint32_t s, uint32_t c);
+ 			void								setUnwindInfoRange(uint32_t s, uint32_t c);
+ 			void								extendUnwindInfoRange();
+@@ -733,7 +733,7 @@
+ 	typedef typename A::P::E					E;
+ 	typedef typename A::P::uint_t				pint_t;
+ 												// constuct via all attributes
+-												Atom(Section<A>& sct, const char* nm, pint_t addr, uint64_t sz, 
++												Atom(MRFSection<A>& sct, const char* nm, pint_t addr, uint64_t sz, 
+ 													ld::Atom::Definition d, ld::Atom::Combine c, ld::Atom::Scope s, 
+ 													ld::Atom::ContentType ct, ld::Atom::SymbolTableInclusion i, 
+ 													bool dds, bool thumb, bool al, ld::Atom::Alignment a) 
+@@ -743,7 +743,7 @@
+ 															_unwindInfoStartIndex(0), _fixupsCount(0),  
+ 															_lineInfoCount(0), _unwindInfoCount(0) { }
+ 												// construct via symbol table entry
+-												Atom(Section<A>& sct, Parser<A>& parser, const macho_nlist<P>& sym, 
++												Atom(MRFSection<A>& sct, Parser<A>& parser, const macho_nlist<P>& sym, 
+ 																uint64_t sz, bool alias=false)
+ 														: ld::Atom((ld::Section&)sct, parser.definitionFromSymbol(sym), 
+ 																parser.combineFromSymbol(sym), parser.scopeFromSymbol(sym),
+@@ -766,7 +766,7 @@
+ 
+ private:
+ 	friend class Parser<A>;
+-	friend class Section<A>;
++	friend class MRFSection<A>;
+ 	friend class CStringSection<A>;
+ 	friend class AbsoluteSymbolSection<A>;
+ 	
+@@ -1031,8 +1031,8 @@
+ 	uint32_t										undefinedStartIndex() { return _undefinedStartIndex; }
+ 	uint32_t										undefinedEndIndex() { return _undefinedEndIndex; }
+ 	void											addFixup(FixupInAtom f) { _allFixups.push_back(f); }
+-	Section<A>*										sectionForNum(unsigned int sectNum);
+-	Section<A>*										sectionForAddress(pint_t addr);
++	MRFSection<A>*										sectionForNum(unsigned int sectNum);
++	MRFSection<A>*										sectionForAddress(pint_t addr);
+ 	Atom<A>*										findAtomByAddress(pint_t addr);
+ 	Atom<A>*										findAtomByAddressOrNullIfStub(pint_t addr);
+ 	Atom<A>*										findAtomByAddressOrLocalTargetOfStub(pint_t addr, uint32_t* offsetInAtom);
+@@ -1074,7 +1074,7 @@
+ 									: sortedSymbolIndexes(ssa), sortedSymbolCount(ssc), cfiStartsArray(cfisa), 
+ 										cfiStartsCount(cfisc), fileHasOverlappingSymbols(ols),
+ 										newSection(false), cfiIndex(0), symIndex(0) {}
+-		bool					next(Parser<A>& parser, const Section<A>& sect, uint32_t sectNum, pint_t startAddr, pint_t endAddr, 
++		bool					next(Parser<A>& parser, const MRFSection<A>& sect, uint32_t sectNum, pint_t startAddr, pint_t endAddr, 
+ 										pint_t* addr, pint_t* size, const macho_nlist<P>** sym);
+ 		pint_t					peek(Parser<A>& parser, pint_t startAddr, pint_t endAddr);
+ 		void					beginSection() { newSection = true; symIndex = 0; }
+@@ -1103,7 +1103,7 @@
+ 
+ 
+ private:
+-	friend class Section<A>;
++	friend class MRFSection<A>;
+ 	
+ 	enum SectionType { sectionTypeIgnore, sectionTypeLiteral4, sectionTypeLiteral8, sectionTypeLiteral16, 
+ 						sectionTypeNonLazy, sectionTypeCFI, sectionTypeCString, sectionTypeCStringPointer, 
+@@ -1448,7 +1448,7 @@
+ // was becuase of a label, the symbol). Returns false when no more chunks.
+ //
+ template <typename A>
+-bool Parser<A>::LabelAndCFIBreakIterator::next(Parser<A>& parser, const Section<A>& sect, uint32_t sectNum, pint_t startAddr, pint_t endAddr, 
++bool Parser<A>::LabelAndCFIBreakIterator::next(Parser<A>& parser, const MRFSection<A>& sect, uint32_t sectNum, pint_t startAddr, pint_t endAddr, 
+ 												pint_t* addr, pint_t* size, const macho_nlist<P>** symbol)
+ {
+ 	// may not be a label on start of section, but need atom demarcation there
+@@ -1600,7 +1600,7 @@
+ }
+ 
+ template <>
+-typename arm::P::uint_t Parser<arm>::realAddr(typename arm::P::uint_t addr)
++arm::P::uint_t Parser<arm>::realAddr(arm::P::uint_t addr)
+ {
+ 	return addr & (-2);
+ }
+@@ -1646,7 +1646,7 @@
+ 	uint32_t sortedSymbolIndexes[_symbolsInSections];
+ 	this->makeSortedSymbolsArray(sortedSymbolIndexes, sortedSectionIndexes);
+ 		
+-	// allocate Section<A> object for each mach-o section
++	// allocate MRFSection<A> object for each mach-o section
+ 	makeSections();
+ 	
+ 	// if it exists, do special early parsing of __compact_unwind section
+@@ -1743,7 +1743,7 @@
+ 	#endif	
+ 	}
+ 	
+-	Section<A>** sections = _file->_sectionsArray;
++	MRFSection<A>** sections = _file->_sectionsArray;
+ 	uint32_t	sectionsCount = _file->_sectionsArrayCount;
+ 
+ 	// figure out how many atoms will be allocated and allocate
+@@ -2306,11 +2306,11 @@
+ 				_file->_swiftVersion = ((flags >> 8) & 0xFF);
+ 				if ( sect->size() > 8 ) {
+ 					warning("section %s/%s has unexpectedly large size %llu in %s", 
+-							sect->segname(), Section<A>::makeSectionName(sect), sect->size(), _file->path());
++							sect->segname(), MRFSection<A>::makeSectionName(sect), sect->size(), _file->path());
+ 				}
+ 			}
+ 			else {
+-				warning("can't parse %s/%s section in %s", sect->segname(), Section<A>::makeSectionName(sect), _file->path());
++				warning("can't parse %s/%s section in %s", sect->segname(), MRFSection<A>::makeSectionName(sect), _file->path());
+ 			}
+ 			continue;
+ 		}
+@@ -2406,24 +2406,24 @@
+ 	// sort by address (mach-o object files don't aways have sections sorted)
+ 	::qsort(machOSects, count, sizeof(MachOSectionAndSectionClass<P>), MachOSectionAndSectionClass<P>::sorter);
+ 		
+-	// we will synthesize a dummy Section<A> object for tentative definitions
++	// we will synthesize a dummy MRFSection<A> object for tentative definitions
+ 	if ( _tentativeDefinitionCount > 0 ) {
+ 		totalSectionsSize += sizeof(TentativeDefinitionSection<A>);
+ 		machOSects[count++].type = sectionTypeTentativeDefinitions;
+ 	}
+ 	
+-	// we will synthesize a dummy Section<A> object for Absolute symbols
++	// we will synthesize a dummy MRFSection<A> object for Absolute symbols
+ 	if ( _absoluteSymbolCount > 0 ) {
+ 		totalSectionsSize += sizeof(AbsoluteSymbolSection<A>);
+ 		machOSects[count++].type = sectionTypeAbsoluteSymbols;
+ 	}
+ 
+ 	// allocate one block for all Section objects as well as pointers to each
+-	uint8_t* space = new uint8_t[totalSectionsSize+count*sizeof(Section<A>*)];
+-	_file->_sectionsArray = (Section<A>**)space;
++	uint8_t* space = new uint8_t[totalSectionsSize+count*sizeof(MRFSection<A>*)];
++	_file->_sectionsArray = (MRFSection<A>**)space;
+ 	_file->_sectionsArrayCount = count;
+-	Section<A>** objects = _file->_sectionsArray;
+-	space += count*sizeof(Section<A>*);
++	MRFSection<A>** objects = _file->_sectionsArray;
++	space += count*sizeof(MRFSection<A>*);
+ 	for (uint32_t i=0; i < count; ++i) {
+ 		switch ( machOSects[i].type ) {
+ 			case sectionTypeIgnore:
+@@ -2511,7 +2511,7 @@
+ 
+ 
+ template <typename A>
+-Section<A>* Parser<A>::sectionForAddress(typename A::P::uint_t addr)
++MRFSection<A>* Parser<A>::sectionForAddress(typename A::P::uint_t addr)
+ {
+ 	for (uint32_t i=0; i < _file->_sectionsArrayCount; ++i ) {
+ 		const macho_section<typename A::P>* sect = _file->_sectionsArray[i]->machoSection();
+@@ -2538,7 +2538,7 @@
+ }
+ 
+ template <typename A>
+-Section<A>* Parser<A>::sectionForNum(unsigned int num)
++MRFSection<A>* Parser<A>::sectionForNum(unsigned int num)
+ {
+ 	for (uint32_t i=0; i < _file->_sectionsArrayCount; ++i ) {
+ 		const macho_section<typename A::P>* sect = _file->_sectionsArray[i]->machoSection();
+@@ -2554,7 +2554,7 @@
+ template <typename A>
+ Atom<A>* Parser<A>::findAtomByAddress(pint_t addr)
+ {
+-	Section<A>* section = this->sectionForAddress(addr);
++	MRFSection<A>* section = this->sectionForAddress(addr);
+ 	return section->findAtomByAddress(addr);
+ }
+ 
+@@ -2611,7 +2611,7 @@
+ 		target.addend = 0;
+ 		return;
+ 	}
+-	Section<A>* section = this->sectionForAddress(addr);
++	MRFSection<A>* section = this->sectionForAddress(addr);
+ 	target.atom = section->findAtomByAddress(addr);
+ 	target.addend = addr - target.atom->_objAddress;
+ 	target.weakImport = false;
+@@ -2659,7 +2659,7 @@
+ 		}
+ 		return;
+ 	}
+-	Section<A>* section = this->sectionForNum(sectNum);
++	MRFSection<A>* section = this->sectionForNum(sectNum);
+ 	target.atom = section->findAtomByAddress(addr);
+ 	if ( target.atom == NULL ) {
+ 		typedef typename A::P::sint_t sint_t;
+@@ -3867,7 +3867,7 @@
+ }
+ 
+ template <typename A>
+-const char* Section<A>::makeSegmentName(const macho_section<typename A::P>* sect)
++const char* MRFSection<A>::makeSegmentName(const macho_section<typename A::P>* sect)
+ {
+ 	// mach-o section record only has room for 16-byte seg/sect names
+ 	// so a 16-byte name has no trailing zero
+@@ -3880,7 +3880,7 @@
+ }
+ 
+ template <typename A>
+-const char* Section<A>::makeSectionName(const macho_section<typename A::P>* sect)
++const char* MRFSection<A>::makeSectionName(const macho_section<typename A::P>* sect)
+ {
+ 	const char* name = sect->sectname();
+ 	if ( strlen(name) < 16 ) 
+@@ -3914,13 +3914,13 @@
+ }
+ 
+ template <typename A>
+-bool Section<A>::readable(const macho_section<typename A::P>* sect)
++bool MRFSection<A>::readable(const macho_section<typename A::P>* sect)
+ {
+ 	return true;
+ }
+ 
+ template <typename A>
+-bool Section<A>::writable(const macho_section<typename A::P>* sect)
++bool MRFSection<A>::writable(const macho_section<typename A::P>* sect)
+ {
+ 	// mach-o .o files do not contain segment permissions
+ 	// we just know TEXT is special
+@@ -3928,7 +3928,7 @@
+ }
+ 
+ template <typename A>
+-bool Section<A>::exectuable(const macho_section<typename A::P>* sect)
++bool MRFSection<A>::exectuable(const macho_section<typename A::P>* sect)
+ {
+ 	// mach-o .o files do not contain segment permissions
+ 	// we just know TEXT is special
+@@ -3937,7 +3937,7 @@
+ 
+ 
+ template <typename A>
+-ld::Section::Type Section<A>::sectionType(const macho_section<typename A::P>* sect)
++ld::Section::Type MRFSection<A>::sectionType(const macho_section<typename A::P>* sect)
+ {
+ 	switch ( sect->flags() & SECTION_TYPE ) {
+ 		case S_ZEROFILL:
+@@ -4015,7 +4015,7 @@
+ 
+ 
+ template <typename A>
+-Atom<A>* Section<A>::findContentAtomByAddress(pint_t addr, class Atom<A>* start, class Atom<A>* end)
++Atom<A>* MRFSection<A>::findContentAtomByAddress(pint_t addr, class Atom<A>* start, class Atom<A>* end)
+ {
+ 	// do a binary search of atom array
+ 	uint32_t atomCount = end - start;
+@@ -4047,7 +4047,7 @@
+ }
+ 
+ template <typename A>
+-ld::Atom::Alignment Section<A>::alignmentForAddress(pint_t addr) 
++ld::Atom::Alignment MRFSection<A>::alignmentForAddress(pint_t addr) 
+ { 
+ 	const uint32_t sectionAlignment = this->_machOSection->align();
+ 	uint32_t modulus = (addr % (1 << sectionAlignment));
+@@ -4057,7 +4057,7 @@
+ }
+ 
+ template <typename A>
+-uint32_t Section<A>::sectionNum(class Parser<A>& parser) const	
++uint32_t MRFSection<A>::sectionNum(class Parser<A>& parser) const	
+ { 
+ 	if ( _machOSection == NULL )
+ 		return 0;
+@@ -4650,7 +4650,7 @@
+ 		// support __LD, __compact_unwind personality entries which are pointer to personality non-lazy pointer
+ 		const pint_t* content = (pint_t*)(this->file().fileContent() + this->_machOSection->offset() + reloc->r_address());
+ 		pint_t nlPointerAddr = *content;
+-		Section<x86>* nlSection = parser.sectionForAddress(nlPointerAddr);
++		MRFSection<x86>* nlSection = parser.sectionForAddress(nlPointerAddr);
+ 		if ( nlSection->type() == ld::Section::typeCode ) {
+ 			// personality function is defined in this .o file, so this is a direct reference to it
+ 			// atoms may not be constructed yet, so scan symbol table for labels
+@@ -4677,7 +4677,7 @@
+ 	else {
+ 		const pint_t* content = (pint_t*)(this->file().fileContent() + this->_machOSection->offset() + reloc->r_address());
+ 		pint_t personalityAddr = *content;
+-		Section<arm64>* personalitySection = parser.sectionForAddress(personalityAddr);
++		MRFSection<arm64>* personalitySection = parser.sectionForAddress(personalityAddr);
+ 		assert((personalitySection->type() == ld::Section::typeCode) && "personality column in __compact_unwind section is not pointer to function");
+ 		// atoms may not be constructed yet, so scan symbol table for labels
+ 		const char* name = parser.scanSymbolTableForAddress(personalityAddr);
+@@ -4831,7 +4831,7 @@
+ 
+ template <typename A>
+ SymboledSection<A>::SymboledSection(Parser<A>& parser, File<A>& f, const macho_section<typename A::P>* s)
+-	: Section<A>(f, s), _type(ld::Atom::typeUnclassified) 
++	: MRFSection<A>(f, s), _type(ld::Atom::typeUnclassified) 
+ {
+ 	switch ( s->flags() & SECTION_TYPE ) {
+ 		case S_ZEROFILL:
+@@ -4877,7 +4877,7 @@
+ 			if ( ! this->_file.canScatterAtoms() )
+ 				return true;
+ 			// call inherited
+-			return Section<A>::dontDeadStrip();
++			return MRFSection<A>::dontDeadStrip();
+ 	}
+ 	return false;
+ }
+@@ -5724,7 +5724,7 @@
+ 
+ 
+ template <>
+-uint32_t Section<x86_64>::x86_64PcRelOffset(uint8_t r_type)
++uint32_t MRFSection<x86_64>::x86_64PcRelOffset(uint8_t r_type)
+ {
+ 	switch ( r_type ) {
+ 		case X86_64_RELOC_SIGNED:
+@@ -5741,7 +5741,7 @@
+ 
+ 
+ template <>
+-bool Section<x86_64>::addRelocFixup(class Parser<x86_64>& parser, const macho_relocation_info<P>* reloc)
++bool MRFSection<x86_64>::addRelocFixup(class Parser<x86_64>& parser, const macho_relocation_info<P>* reloc)
+ {
+ 	const macho_section<P>* sect = this->machoSection();
+ 	uint64_t srcAddr = sect->addr() + reloc->r_address();
+@@ -5948,7 +5948,7 @@
+ 
+ 
+ template <>
+-bool Section<x86>::addRelocFixup(class Parser<x86>& parser, const macho_relocation_info<P>* reloc)
++bool MRFSection<x86>::addRelocFixup(class Parser<x86>& parser, const macho_relocation_info<P>* reloc)
+ {
+ 	const macho_section<P>* sect = this->machoSection();
+ 	uint32_t srcAddr;
+@@ -6189,7 +6189,7 @@
+ 
+ #if SUPPORT_ARCH_arm_any
+ template <>
+-bool Section<arm>::addRelocFixup(class Parser<arm>& parser, const macho_relocation_info<P>* reloc)
++bool MRFSection<arm>::addRelocFixup(class Parser<arm>& parser, const macho_relocation_info<P>* reloc)
+ {
+ 	const macho_section<P>* sect = this->machoSection();
+ 	bool result = false;
+@@ -6656,7 +6656,7 @@
+ 
+ #if SUPPORT_ARCH_arm64
+ template <>
+-bool Section<arm64>::addRelocFixup(class Parser<arm64>& parser, const macho_relocation_info<P>* reloc)
++bool MRFSection<arm64>::addRelocFixup(class Parser<arm64>& parser, const macho_relocation_info<P>* reloc)
+ {
+ 	bool result = false;
+ 	Parser<arm64>::SourceLocation	src;
+@@ -7054,7 +7054,7 @@
+ 
+ #if SUPPORT_ARCH_arm64
+ template <>
+-void Section<arm64>::addLOH(class Parser<arm64>& parser, int kind, int count, const uint64_t addrs[]) {
++void MRFSection<arm64>::addLOH(class Parser<arm64>& parser, int kind, int count, const uint64_t addrs[]) {
+ 	switch (kind) {
+ 		case LOH_ARM64_ADRP_ADRP:
+ 		case LOH_ARM64_ADRP_LDR:
+@@ -7109,18 +7109,18 @@
+ 	extra.info.delta2 = (count > 1) ? ((addrs[1] - lowestAddress) >> 2) : 0;
+ 	extra.info.delta3 = (count > 2) ? ((addrs[2] - lowestAddress) >> 2) : 0;
+ 	extra.info.delta4 = (count > 3) ? ((addrs[3] - lowestAddress) >> 2) : 0;
+-	typename Parser<arm64>::SourceLocation src(inAtom, lowestAddress- inAtom->objectAddress());
++	Parser<arm64>::SourceLocation src(inAtom, lowestAddress- inAtom->objectAddress());
+ 	parser.addFixup(src, ld::Fixup::k1of1, ld::Fixup::kindLinkerOptimizationHint, extra.addend);
+ }
+ #endif
+ 
+ template <typename A>
+-void Section<A>::addLOH(class Parser<A>& parser, int kind, int count, const uint64_t addrs[]) {
++void MRFSection<A>::addLOH(class Parser<A>& parser, int kind, int count, const uint64_t addrs[]) {
+ 
+ }
+ 
+ template <typename A>
+-void Section<A>::makeFixups(class Parser<A>& parser, const struct Parser<A>::CFI_CU_InfoArrays&)
++void MRFSection<A>::makeFixups(class Parser<A>& parser, const struct Parser<A>::CFI_CU_InfoArrays&)
+ {
+ 	const macho_section<P>* sect = this->machoSection();
+ 	const macho_relocation_info<P>* relocs = (macho_relocation_info<P>*)(file().fileContent() + sect->reloff());
+@@ -7131,7 +7131,7 @@
+ 				++r; // skip next
+ 		}
+ 		catch (const char* msg) {
+-			throwf("in section %s,%s reloc %u: %s", sect->segname(), Section<A>::makeSectionName(sect), r, msg);
++			throwf("in section %s,%s reloc %u: %s", sect->segname(), MRFSection<A>::makeSectionName(sect), r, msg);
+ 		}
+ 	}
+ 	
+@@ -7157,7 +7157,7 @@
+ 	}
+ 	if ( !this->_altEntries.empty() && !this->addFollowOnFixups() ) {
+ 		if ( _altEntries.count(_beginAtoms) != 0 ) 
+-			warning("N_ALT_ENTRY bit set on first atom in section %s/%s", sect->segname(), Section<A>::makeSectionName(sect));
++			warning("N_ALT_ENTRY bit set on first atom in section %s/%s", sect->segname(), MRFSection<A>::makeSectionName(sect));
+ 
+ 		Atom<A>* end = &_endAtoms[-1];
+ 		for(Atom<A>* p = _beginAtoms; p < end; ++p) {
+--- ./ld64-241.9/src/ld/passes/dtrace_dof.cpp.gcc	2014-09-11 00:24:46.000000000 +0200
++++ ./ld64-241.9/src/ld/passes/dtrace_dof.cpp	2015-01-12 22:12:18.000000000 +0100
+@@ -30,8 +30,17 @@
+ 
+ #include <vector>
+ #include <map>
++#ifdef __GLIBCXX__
++#include <tr1/unordered_map>
++#include <tr1/unordered_set>
++#define UNORDERED_MAP tr1::unordered_map
++#define UNORDERED_SET tr1::unordered_set
++#else
+ #include <unordered_map>
+ #include <unordered_set>
++#define UNORDERED_MAP unordered_map
++#define UNORDERED_SET unordered_set
++#endif
+ 
+ #include "ld.hpp"
+ #include "MachOFileAbstraction.hpp"
+@@ -111,8 +120,8 @@
+ 	uint32_t						offset;
+ 	const char*						probeName;
+ };
+-typedef std::unordered_map<const char*, std::vector<DTraceProbeInfo>, CStringHash, CStringEquals>	ProviderToProbes;
+-typedef	std::unordered_set<const char*, CStringHash, CStringEquals>  CStringSet;
++typedef std::UNORDERED_MAP<const char*, std::vector<DTraceProbeInfo>, CStringHash, CStringEquals>	ProviderToProbes;
++typedef	std::UNORDERED_SET<const char*, CStringHash, CStringEquals>  CStringSet;
+ 
+ 
+ 
+--- ./ld64-241.9/src/ld/passes/order.cpp.gcc	2014-09-11 00:24:46.000000000 +0200
++++ ./ld64-241.9/src/ld/passes/order.cpp	2015-01-12 22:12:18.000000000 +0100
+@@ -32,7 +32,13 @@
+ #include <vector>
+ #include <map>
+ #include <set>
++#ifdef __GLIBCXX__
++#include <tr1/unordered_map>
++#define UNORDERED_MAP tr1::unordered_map
++#else
+ #include <unordered_map>
++#define UNORDERED_MAP unordered_map
++#endif
+ 
+ #include "ld.hpp"
+ #include "order.h"
+@@ -85,7 +91,7 @@
+ 		ld::Internal&	_state;
+ 	};
+ 				
+-	typedef std::unordered_map<const char*, const ld::Atom*, CStringHash, CStringEquals> NameToAtom;
++	typedef std::UNORDERED_MAP<const char*, const ld::Atom*, CStringHash, CStringEquals> NameToAtom;
+ 	
+ 	typedef std::map<const ld::Atom*, const ld::Atom*> AtomToAtom;
+ 	
+--- ./ld64-241.9/src/ld/Resolver.h.gcc	2014-09-11 00:24:46.000000000 +0200
++++ ./ld64-241.9/src/ld/Resolver.h	2015-01-12 22:12:18.000000000 +0100
+@@ -42,7 +42,13 @@
+ #include <mach-o/dyld.h>
+ 
+ #include <vector>
++#ifdef __GLIBCXX__
++#include <tr1/unordered_set>
++#define UNORDERED_SET tr1::unordered_set
++#else
+ #include <unordered_set>
++#define UNORDERED_SET unordered_set
++#endif
+ 
+ #include "Options.h"
+ #include "ld.hpp"
+@@ -105,7 +111,7 @@
+ 	void					doLinkerOption(const std::vector<const char*>& linkerOption, const char* fileName);
+ 	void					dumpAtoms();
+ 
+-	typedef std::unordered_set<const char*, CStringHash, CStringEquals>  StringSet;
++	typedef std::UNORDERED_SET<const char*, CStringHash, CStringEquals>  StringSet;
+ 
+ 	class NotLive {
+ 	public:
+--- ./ld64-241.9/src/ld/SymbolTable.h.gcc	2014-09-11 00:24:46.000000000 +0200
++++ ./ld64-241.9/src/ld/SymbolTable.h	2015-01-12 22:12:18.000000000 +0100
+@@ -42,7 +42,13 @@
+ #include <mach-o/dyld.h>
+ 
+ #include <vector>
++#ifdef __GLIBCXX__
++#include <tr1/unordered_map>
++#define UNORDERED_MAP tr1::unordered_map
++#else
+ #include <unordered_map>
++#define UNORDERED_MAP unordered_map
++#endif
+ 
+ #include "Options.h"
+ #include "ld.hpp"
+@@ -57,38 +63,38 @@
+ 	typedef uint32_t IndirectBindingSlot;
+ 
+ private:
+-	typedef std::unordered_map<const char*, IndirectBindingSlot, CStringHash, CStringEquals> NameToSlot;
++	typedef std::UNORDERED_MAP<const char*, IndirectBindingSlot, CStringHash, CStringEquals> NameToSlot;
+ 
+ 	class ContentFuncs {
+ 	public:
+ 		size_t	operator()(const ld::Atom*) const;
+ 		bool	operator()(const ld::Atom* left, const ld::Atom* right) const;
+ 	};
+-	typedef std::unordered_map<const ld::Atom*, IndirectBindingSlot, ContentFuncs, ContentFuncs> ContentToSlot;
++	typedef std::UNORDERED_MAP<const ld::Atom*, IndirectBindingSlot, ContentFuncs, ContentFuncs> ContentToSlot;
+ 
+ 	class ReferencesHashFuncs {
+ 	public:
+ 		size_t	operator()(const ld::Atom*) const;
+ 		bool	operator()(const ld::Atom* left, const ld::Atom* right) const;
+ 	};
+-	typedef std::unordered_map<const ld::Atom*, IndirectBindingSlot, ReferencesHashFuncs, ReferencesHashFuncs> ReferencesToSlot;
++	typedef std::UNORDERED_MAP<const ld::Atom*, IndirectBindingSlot, ReferencesHashFuncs, ReferencesHashFuncs> ReferencesToSlot;
+ 
+ 	class CStringHashFuncs {
+ 	public:
+ 		size_t	operator()(const ld::Atom*) const;
+ 		bool	operator()(const ld::Atom* left, const ld::Atom* right) const;
+ 	};
+-	typedef std::unordered_map<const ld::Atom*, IndirectBindingSlot, CStringHashFuncs, CStringHashFuncs> CStringToSlot;
++	typedef std::UNORDERED_MAP<const ld::Atom*, IndirectBindingSlot, CStringHashFuncs, CStringHashFuncs> CStringToSlot;
+ 
+ 	class UTF16StringHashFuncs {
+ 	public:
+ 		size_t	operator()(const ld::Atom*) const;
+ 		bool	operator()(const ld::Atom* left, const ld::Atom* right) const;
+ 	};
+-	typedef std::unordered_map<const ld::Atom*, IndirectBindingSlot, UTF16StringHashFuncs, UTF16StringHashFuncs> UTF16StringToSlot;
++	typedef std::UNORDERED_MAP<const ld::Atom*, IndirectBindingSlot, UTF16StringHashFuncs, UTF16StringHashFuncs> UTF16StringToSlot;
+ 
+ 	typedef std::map<IndirectBindingSlot, const char*> SlotToName;
+-	typedef std::unordered_map<const char*, CStringToSlot*, CStringHash, CStringEquals> NameToMap;
++	typedef std::UNORDERED_MAP<const char*, CStringToSlot*, CStringHash, CStringEquals> NameToMap;
+     
+     typedef std::vector<const ld::Atom *> DuplicatedSymbolAtomList;
+     typedef std::map<const char *, DuplicatedSymbolAtomList * > DuplicateSymbols;
+--- ./ld64-241.9/src/other/dyldinfo.cpp.gcc	2014-09-11 00:24:46.000000000 +0200
++++ ./ld64-241.9/src/other/dyldinfo.cpp	2015-01-12 22:12:18.000000000 +0100
+@@ -33,7 +33,6 @@
+ 
+ #include <vector>
+ #include <set>
+-#include <unordered_set>
+ 
+ #include "configure.h"
+ #include "MachOFileAbstraction.hpp"
+--- ./ld64-241.9/src/other/machochecker.cpp.gcc	2014-09-11 00:24:46.000000000 +0200
++++ ./ld64-241.9/src/other/machochecker.cpp	2015-01-12 22:12:18.000000000 +0100
+@@ -33,7 +33,13 @@
+ 
+ #include <vector>
+ #include <set>
++#ifdef __GLIBCXX__
++#include <tr1/unordered_set>
++#define UNORDERED_SET tr1::unordered_set
++#else
+ #include <unordered_set>
++#define UNORDERED_SET unordered_set
++#endif
+ 
+ #include "configure.h"
+ 
+@@ -124,7 +130,7 @@
+ 		bool operator()(const char* left, const char* right) const { return (strcmp(left, right) == 0); }
+ 	};
+ 
+-	typedef std::unordered_set<const char*, CStringHash, CStringEquals>  StringSet;
++	typedef std::UNORDERED_SET<const char*, CStringHash, CStringEquals>  StringSet;
+ 
+ 												MachOChecker(const uint8_t* fileContent, uint32_t fileLength, const char* path);
+ 	void										checkMachHeader();
+--- ./ld64-241.9/src/other/unwinddump.cpp.gcc	2014-11-04 00:56:18.000000000 +0100
++++ ./ld64-241.9/src/other/unwinddump.cpp	2015-01-12 22:12:18.000000000 +0100
+@@ -33,7 +33,6 @@
+ 
+ #include <vector>
+ #include <set>
+-#include <unordered_set>
+ 
+ #include "configure.h"
+ #include "MachOFileAbstraction.hpp"