diff options
Diffstat (limited to 'sys-devel/binutils-apple/files/ld64-242-gcc.patch')
| -rw-r--r-- | sys-devel/binutils-apple/files/ld64-242-gcc.patch | 1038 |
1 files changed, 1038 insertions, 0 deletions
diff --git a/sys-devel/binutils-apple/files/ld64-242-gcc.patch b/sys-devel/binutils-apple/files/ld64-242-gcc.patch new file mode 100644 index 000000000000..b6e1dbbbbe05 --- /dev/null +++ b/sys-devel/binutils-apple/files/ld64-242-gcc.patch @@ -0,0 +1,1038 @@ +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-242/src/ld/InputFiles.h.gcc 2015-08-03 01:11:48.000000000 +0200 ++++ ld64-242/src/ld/InputFiles.h 2015-08-03 01:11:57.000000000 +0200 +@@ -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" +@@ -112,7 +120,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-242/src/ld/ld.cpp.gcc 2015-08-03 01:11:48.000000000 +0200 ++++ ld64-242/src/ld/ld.cpp 2015-08-03 01:11:57.000000000 +0200 +@@ -56,7 +56,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" +@@ -153,7 +159,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-242/src/ld/ld.hpp.gcc 2015-08-03 01:11:48.000000000 +0200 ++++ ld64-242/src/ld/ld.hpp 2015-08-03 01:11:57.000000000 +0200 +@@ -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-242/src/ld/LinkEditClassic.hpp.gcc 2015-08-03 01:11:48.000000000 +0200 ++++ ld64-242/src/ld/LinkEditClassic.hpp 2015-08-03 01:11:57.000000000 +0200 +@@ -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 + + #if !defined(SET_COMM_ALIGN) + /* missing on < 10.5 */ +@@ -98,7 +103,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-242/src/ld/Options.cpp.gcc 2015-08-03 01:11:48.000000000 +0200 ++++ ld64-242/src/ld/Options.cpp 2015-08-03 01:11:57.000000000 +0200 +@@ -4743,7 +4743,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) ) { +@@ -4775,7 +4775,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-242/src/ld/Options.h.gcc 2015-08-03 01:11:48.000000000 +0200 ++++ ld64-242/src/ld/Options.h 2015-08-03 01:11:57.000000000 +0200 +@@ -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" +@@ -401,8 +410,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 }; +@@ -415,8 +424,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-242/src/ld/OutputFile.cpp.gcc 2015-08-03 01:11:48.000000000 +0200 ++++ ld64-242/src/ld/OutputFile.cpp 2015-08-03 01:11:57.000000000 +0200 +@@ -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> +@@ -4800,7 +4806,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-242/src/ld/parsers/archive_file.cpp.gcc 2015-08-03 01:11:48.000000000 +0200 ++++ ld64-242/src/ld/parsers/archive_file.cpp 2015-08-03 01:11:57.000000000 +0200 +@@ -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" +@@ -116,7 +122,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-242/src/ld/parsers/lto_file.cpp.gcc 2015-08-03 01:11:48.000000000 +0200 ++++ ld64-242/src/ld/parsers/lto_file.cpp 2015-08-03 01:11:57.000000000 +0200 +@@ -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-242/src/ld/parsers/macho_dylib_file.cpp.gcc 2015-08-03 01:11:48.000000000 +0200 ++++ ld64-242/src/ld/parsers/macho_dylib_file.cpp 2015-08-03 01:11:57.000000000 +0200 +@@ -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; }; + +@@ -566,14 +575,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-242/src/ld/parsers/macho_relocatable_file.cpp.gcc 2015-08-03 01:11:48.000000000 +0200 ++++ ld64-242/src/ld/parsers/macho_relocatable_file.cpp 2015-08-03 01:12:27.000000000 +0200 +@@ -66,7 +66,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; + +@@ -106,14 +106,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; +@@ -138,14 +138,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; +@@ -169,10 +169,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) { } + +@@ -196,11 +196,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; } +@@ -260,11 +260,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; +@@ -301,11 +301,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; } +@@ -323,11 +323,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; } +@@ -349,7 +349,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); +@@ -381,11 +381,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: +@@ -722,8 +722,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(); +@@ -740,7 +740,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) +@@ -750,7 +750,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), +@@ -773,7 +773,7 @@ + + private: + friend class Parser<A>; +- friend class Section<A>; ++ friend class MRFSection<A>; + friend class CStringSection<A>; + friend class AbsoluteSymbolSection<A>; + +@@ -1040,8 +1040,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); +@@ -1084,7 +1084,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; } +@@ -1113,7 +1113,7 @@ + + + private: +- friend class Section<A>; ++ friend class MRFSection<A>; + + enum SectionType { sectionTypeIgnore, sectionTypeLiteral4, sectionTypeLiteral8, sectionTypeLiteral16, + sectionTypeNonLazy, sectionTypeCFI, sectionTypeCString, sectionTypeCStringPointer, +@@ -1465,7 +1465,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 +@@ -1618,7 +1618,7 @@ + + #if SUPPORT_ARCH_arm_any + 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); + } +@@ -1667,7 +1667,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 +@@ -1764,7 +1764,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 +@@ -2331,11 +2331,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; + } +@@ -2431,24 +2431,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: +@@ -2536,7 +2536,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(); +@@ -2563,7 +2563,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(); +@@ -2579,7 +2579,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); + } + +@@ -2636,7 +2636,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; +@@ -2684,7 +2684,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; +@@ -3892,7 +3892,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 +@@ -3905,7 +3905,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 ) +@@ -3939,13 +3939,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 +@@ -3953,7 +3953,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 +@@ -3962,7 +3962,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: +@@ -4040,7 +4040,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; +@@ -4072,7 +4072,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)); +@@ -4082,7 +4082,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; +@@ -4727,7 +4727,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 +@@ -4754,7 +4754,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); +@@ -4776,7 +4776,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<arm>* nlSection = parser.sectionForAddress(nlPointerAddr); ++ MRFSection<arm>* 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 +@@ -4937,7 +4937,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: +@@ -4983,7 +4983,7 @@ + if ( ! this->_file.canScatterAtoms() ) + return true; + // call inherited +- return Section<A>::dontDeadStrip(); ++ return MRFSection<A>::dontDeadStrip(); + } + return false; + } +@@ -5847,7 +5847,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: +@@ -5864,7 +5864,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(); +@@ -6071,7 +6071,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; +@@ -6312,7 +6312,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; +@@ -6779,7 +6779,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; +@@ -7177,7 +7177,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: +@@ -7232,18 +7232,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()); +@@ -7254,7 +7254,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); + } + } + +@@ -7280,7 +7280,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-242/src/ld/passes/dtrace_dof.cpp.gcc 2015-08-03 01:11:48.000000000 +0200 ++++ ld64-242/src/ld/passes/dtrace_dof.cpp 2015-08-03 01:11:57.000000000 +0200 +@@ -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-242/src/ld/passes/order.cpp.gcc 2015-08-03 01:11:48.000000000 +0200 ++++ ld64-242/src/ld/passes/order.cpp 2015-08-03 01:11:57.000000000 +0200 +@@ -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-242/src/ld/Resolver.h.gcc 2015-08-03 01:11:48.000000000 +0200 ++++ ld64-242/src/ld/Resolver.h 2015-08-03 01:11:57.000000000 +0200 +@@ -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-242/src/ld/SymbolTable.h.gcc 2015-08-03 01:11:48.000000000 +0200 ++++ ld64-242/src/ld/SymbolTable.h 2015-08-03 01:11:57.000000000 +0200 +@@ -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-242/src/other/dyldinfo.cpp.gcc 2015-08-03 01:11:48.000000000 +0200 ++++ ld64-242/src/other/dyldinfo.cpp 2015-08-03 01:11:57.000000000 +0200 +@@ -33,7 +33,6 @@ + + #include <vector> + #include <set> +-#include <unordered_set> + + #include "configure.h" + #include "MachOFileAbstraction.hpp" +--- ld64-242/src/other/machochecker.cpp.gcc 2015-08-03 01:11:48.000000000 +0200 ++++ ld64-242/src/other/machochecker.cpp 2015-08-03 01:11:57.000000000 +0200 +@@ -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-242/src/other/unwinddump.cpp.gcc 2015-08-03 01:11:48.000000000 +0200 ++++ ld64-242/src/other/unwinddump.cpp 2015-08-03 01:11:57.000000000 +0200 +@@ -33,7 +33,6 @@ + + #include <vector> + #include <set> +-#include <unordered_set> + + #include "configure.h" + #include "MachOFileAbstraction.hpp" |