gentoo-overlay/sys-devel/binutils-apple/files/ld64-241.9-gcc.patch

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"