MX_Pmodule/Programming/ld64/files/PR-29679726.patch

From 08ebdd8bde8f21872f1ba716eaf887ef1628d738 Mon Sep 17 00:00:00 2001
From: Jeremy Huddleston Sequoia <jeremyhu@apple.com>
Date: Sun, 18 Dec 2016 00:24:11 -0800
Subject: [PATCH] Revert textstub_dylib_file.cpp back to ld64-264.3.102 version

Signed-off-by: Jeremy Huddleston Sequoia <jeremyhu@apple.com>
---
 ld64.xcodeproj/project.pbxproj         |   6 -
 src/ld/Options.cpp                     |  35 +-
 src/ld/parsers/generic_dylib_file.hpp  |  63 +++
 src/ld/parsers/macho_dylib_file.cpp    |  64 ---
 src/ld/parsers/textstub_dylib_file.cpp | 717 +++++++++++++++++++++++++++------
 5 files changed, 658 insertions(+), 227 deletions(-)

diff --git ld64.xcodeproj/project.pbxproj ld64.xcodeproj/project.pbxproj
index 600aeac9..db20e783 100644
--- ld64.xcodeproj/project.pbxproj
+++ ld64.xcodeproj/project.pbxproj
@@ -1284,8 +1284,6 @@
 					"-Wl,-lazy_library,$(DT_TOOLCHAIN_DIR)/usr/lib/libLTO.dylib",
 					"@$(DERIVED_FILE_DIR)/linkExtras",
 					"-Wl,-exported_symbol,__mh_execute_header",
-					"-L$(DT_TOOLCHAIN_DIR)/usr/lib",
-					"-ltapi",
 				);
 				PREBINDING = NO;
 				PRODUCT_NAME = ld;
@@ -1358,8 +1356,6 @@
 					"-Wl,-lazy_library,$(DT_TOOLCHAIN_DIR)/usr/lib/libLTO.dylib",
 					"@$(DERIVED_FILE_DIR)/linkExtras",
 					"-Wl,-exported_symbol,__mh_execute_header",
-					"-L$(DT_TOOLCHAIN_DIR)/usr/lib",
-					"-ltapi",
 				);
 				PREBINDING = NO;
 				PRODUCT_NAME = ld;
@@ -1577,8 +1573,6 @@
 					"-Wl,-lazy_library,$(DT_TOOLCHAIN_DIR)/usr/lib/libLTO.dylib",
 					"@$(DERIVED_FILE_DIR)/linkExtras",
 					"-Wl,-exported_symbol,__mh_execute_header",
-					"-L$(DT_TOOLCHAIN_DIR)/usr/lib",
-					"-ltapi",
 				);
 				PREBINDING = NO;
 				PRODUCT_NAME = ld;
diff --git src/ld/Options.cpp src/ld/Options.cpp
index b7e17091..227b0d84 100644
--- src/ld/Options.cpp
+++ src/ld/Options.cpp
@@ -34,7 +34,6 @@
 #include <spawn.h>
 #include <cxxabi.h>
 #include <Availability.h>
-#include <tapi/tapi.h>
 
 #include <vector>
 #include <map>
@@ -832,13 +831,7 @@ bool Options::findFile(const std::string &path, const std::vector<std::string> &
 		bool found = tbdInfo.checkFileExists(*this, newPath.c_str());
 		if ( fTraceDylibSearching )
 			printf("[Logging for XBS]%sfound library: '%s'\n", (found ? " " : " not "), newPath.c_str());
-		if ( found )
-			break;
-	}
-
-	// If we found a text-based stub file, check if it should be used.
-	if ( !tbdInfo.missing() ) {
-		if (tapi::LinkerInterfaceFile::shouldPreferTextBasedStubFile(tbdInfo.path)) {
+		if ( found ) {
 			result = tbdInfo;
 			return true;
 		}
@@ -848,31 +841,10 @@ bool Options::findFile(const std::string &path, const std::vector<std::string> &
 		bool found = dylibInfo.checkFileExists(*this, path.c_str());
 		if ( fTraceDylibSearching )
 			printf("[Logging for XBS]%sfound library: '%s'\n", (found ? " " : " not "), path.c_str());
-	}
-
-	// There is only a text-based stub file.
-	if ( !tbdInfo.missing() && dylibInfo.missing() ) {
-		result = tbdInfo;
-		return true;
-	}
-	// There is only a dynamic library file.
-	else if ( tbdInfo.missing() && !dylibInfo.missing() ) {
-		result = dylibInfo;
-		return true;
-	}
-	// There are both - a text-based stub file and a dynamic library file.
-	else if ( !tbdInfo.missing() && !dylibInfo.missing() ) {
-		// If the files are still in synv we can use and should use the text-based stub file.
-		if (tapi::LinkerInterfaceFile::areEquivalent(tbdInfo.path, dylibInfo.path)) {
-			result = tbdInfo;
-		}
-		// Otherwise issue a warning and fall-back to the dynamic library file.
-		else {
-			warning("text-based stub file %s and library file %s are out of sync. Falling back to library file for linking.", tbdInfo.path, dylibInfo.path);
+		if ( found ) {
 			result = dylibInfo;
-
+			return true;
 		}
-		return true;
 	}
 
 	return false;
@@ -3959,7 +3931,6 @@ void Options::buildSearchPaths(int argc, const char* argv[])
 				const char* ltoVers = lto::version();
 				if ( ltoVers != NULL )
 					fprintf(stderr, "LTO support using: %s\n", ltoVers);
-				fprintf(stderr, "TAPI support using: %s\n", tapi::Version::getFullVersionAsString().c_str());
 				exit(0);
 			}
 		}
diff --git src/ld/parsers/generic_dylib_file.hpp src/ld/parsers/generic_dylib_file.hpp
index 529e4ab6..d581ab37 100644
--- src/ld/parsers/generic_dylib_file.hpp
+++ src/ld/parsers/generic_dylib_file.hpp
@@ -191,6 +191,7 @@ private:
 
 protected:
 	bool						isPublicLocation(const char* path) const;
+	void						addSymbol(const char* name, bool weak = false, bool tlv = false, pint_t address = 0);
 
 private:
 	ld::Section							_importProxySection;
@@ -479,6 +480,68 @@ bool File<A>::isPublicLocation(const char* path) const
 	return false;
 }
 
+template <typename A>
+void File<A>::addSymbol(const char* name, bool weakDef, bool tlv, pint_t address)
+{
+	// symbols that start with $ld$ are meta-data to the static linker
+	// <rdar://problem/5182537> need way for ld and dyld to see different exported symbols in a dylib
+	if ( strncmp(name, "$ld$", 4) == 0 ) {
+		//    $ld$ <action> $ <condition> $ <symbol-name>
+		const char* symAction = &name[4];
+		const char* symCond = strchr(symAction, '$');
+		if ( symCond != nullptr ) {
+			char curOSVers[16];
+			sprintf(curOSVers, "$os%d.%d$", (this->_linkMinOSVersion >> 16), ((this->_linkMinOSVersion >> 8) & 0xFF));
+			if ( strncmp(symCond, curOSVers, strlen(curOSVers)) == 0 ) {
+				const char* symName = strchr(&symCond[1], '$');
+				if ( symName != nullptr ) {
+					++symName;
+					if ( strncmp(symAction, "hide$", 5) == 0 ) {
+						if ( this->_s_logHashtable )
+							fprintf(stderr, "  adding %s to ignore set for %s\n", symName, this->path());
+						this->_ignoreExports.insert(strdup(symName));
+						return;
+					}
+					else if ( strncmp(symAction, "add$", 4) == 0 ) {
+						this->addSymbol(symName, weakDef);
+						return;
+					}
+					else if ( strncmp(symAction, "weak$", 5) == 0 ) {
+						if ( !this->_allowWeakImports )
+							this->_ignoreExports.insert(strdup(symName));
+					}
+					else if ( strncmp(symAction, "install_name$", 13) == 0 ) {
+						this->_dylibInstallPath = strdup(symName);
+						this->_installPathOverride = true;
+						// <rdar://problem/14448206> CoreGraphics redirects to ApplicationServices, but with wrong compat version
+						if ( strcmp(this->_dylibInstallPath, "/System/Library/Frameworks/ApplicationServices.framework/Versions/A/ApplicationServices") == 0 )
+							this->_dylibCompatibilityVersion = Options::parseVersionNumber32("1.0");
+						return;
+					}
+					else if ( strncmp(symAction, "compatibility_version$", 22) == 0 ) {
+						this->_dylibCompatibilityVersion = Options::parseVersionNumber32(symName);
+						return;
+					}
+					else {
+						warning("bad symbol action: %s in dylib %s", name, this->path());
+					}
+				}
+			}
+		}
+		else {
+			warning("bad symbol condition: %s in dylib %s", name, this->path());
+		}
+	}
+
+	// add symbol as possible export if we are not supposed to ignore it
+	if ( this->_ignoreExports.count(name) == 0 ) {
+		AtomAndWeak bucket = { nullptr, weakDef, tlv, address };
+		if ( this->_s_logHashtable )
+			fprintf(stderr, "  adding %s to hash table for %s\n", name, this->path());
+		this->_atoms[strdup(name)] = bucket;
+	}
+}
+
 // <rdar://problem/5529626> If only weak_import symbols are used, linker should use LD_LOAD_WEAK_DYLIB
 template <typename A>
 bool File<A>::allSymbolsAreWeakImported() const
diff --git src/ld/parsers/macho_dylib_file.cpp src/ld/parsers/macho_dylib_file.cpp
index 16d3f5d7..a8233055 100644
--- src/ld/parsers/macho_dylib_file.cpp
+++ src/ld/parsers/macho_dylib_file.cpp
@@ -70,7 +70,6 @@ public:
 private:
 	using P = typename A::P;
 	using E = typename A::P::E;
-	using pint_t = typename A::P::uint_t;
 
 	void				addDyldFastStub();
 	void				buildExportHashTableFromExportInfo(const macho_dyld_info_command<P>* dyldInfo,
@@ -78,7 +77,6 @@ private:
 	void				buildExportHashTableFromSymbolTable(const macho_dysymtab_command<P>* dynamicInfo,
 														const macho_nlist<P>* symbolTable, const char* strings,
 														const uint8_t* fileContent);
-	void				addSymbol(const char* name, bool weakDef = false, bool tlv = false, pint_t address = 0);
 	static const char*	objCInfoSegmentName();
 	static const char*	objCInfoSectionName();
 
@@ -526,68 +524,6 @@ void File<A>::buildExportHashTableFromExportInfo(const macho_dyld_info_command<P
 	}
 }
 
-template <typename A>
-void File<A>::addSymbol(const char* name, bool weakDef, bool tlv, pint_t address)
-{
-	// symbols that start with $ld$ are meta-data to the static linker
-	// <rdar://problem/5182537> need way for ld and dyld to see different exported symbols in a dylib
-	if ( strncmp(name, "$ld$", 4) == 0 ) {
-		//    $ld$ <action> $ <condition> $ <symbol-name>
-		const char* symAction = &name[4];
-		const char* symCond = strchr(symAction, '$');
-		if ( symCond != nullptr ) {
-			char curOSVers[16];
-			sprintf(curOSVers, "$os%d.%d$", (this->_linkMinOSVersion >> 16), ((this->_linkMinOSVersion >> 8) & 0xFF));
-			if ( strncmp(symCond, curOSVers, strlen(curOSVers)) == 0 ) {
-				const char* symName = strchr(&symCond[1], '$');
-				if ( symName != nullptr ) {
-					++symName;
-					if ( strncmp(symAction, "hide$", 5) == 0 ) {
-						if ( this->_s_logHashtable )
-							fprintf(stderr, "  adding %s to ignore set for %s\n", symName, this->path());
-						this->_ignoreExports.insert(strdup(symName));
-						return;
-					}
-					else if ( strncmp(symAction, "add$", 4) == 0 ) {
-						this->addSymbol(symName, weakDef);
-						return;
-					}
-					else if ( strncmp(symAction, "weak$", 5) == 0 ) {
-						if ( !this->_allowWeakImports )
-							this->_ignoreExports.insert(strdup(symName));
-					}
-					else if ( strncmp(symAction, "install_name$", 13) == 0 ) {
-						this->_dylibInstallPath = symName;
-						this->_installPathOverride = true;
-						// <rdar://problem/14448206> CoreGraphics redirects to ApplicationServices, but with wrong compat version
-						if ( strcmp(this->_dylibInstallPath, "/System/Library/Frameworks/ApplicationServices.framework/Versions/A/ApplicationServices") == 0 )
-							this->_dylibCompatibilityVersion = Options::parseVersionNumber32("1.0");
-						return;
-					}
-					else if ( strncmp(symAction, "compatibility_version$", 22) == 0 ) {
-						this->_dylibCompatibilityVersion = Options::parseVersionNumber32(symName);
-						return;
-					}
-					else {
-						warning("bad symbol action: %s in dylib %s", name, this->path());
-					}
-				}
-			}
-		}
-		else {
-			warning("bad symbol condition: %s in dylib %s", name, this->path());
-		}
-	}
-
-	// add symbol as possible export if we are not supposed to ignore it
-	if ( this->_ignoreExports.count(name) == 0 ) {
-		typename Base::AtomAndWeak bucket = { nullptr, weakDef, tlv, address };
-		if ( this->_s_logHashtable )
-			fprintf(stderr, "  adding %s to hash table for %s\n", name, this->path());
-		this->_atoms[strdup(name)] = bucket;
-	}
-}
-
 template <>
 void File<x86_64>::addDyldFastStub()
 {
diff --git src/ld/parsers/textstub_dylib_file.cpp src/ld/parsers/textstub_dylib_file.cpp
index 58544625..74dbcd7c 100644
--- src/ld/parsers/textstub_dylib_file.cpp
+++ src/ld/parsers/textstub_dylib_file.cpp
@@ -25,7 +25,7 @@
 
 #include <sys/param.h>
 #include <sys/mman.h>
-#include <tapi/tapi.h>
+
 #include <vector>
 
 #include "Architectures.hpp"
@@ -35,6 +35,469 @@
 #include "generic_dylib_file.hpp"
 #include "textstub_dylib_file.hpp"
 
+namespace {
+
+///
+/// A token is a light-weight reference to the content of an nmap'ed file. It
+/// doesn't own the data and it doesn't make a copy of it. The referenced data
+/// is only valid as long as the file is mapped in.
+///
+class Token {
+	const char* _p;
+	size_t _size;
+
+	int compareMemory(const char* lhs, const char* rhs, size_t size) const {
+		if (size == 0)
+			return 0;
+		return ::memcmp(lhs, rhs, size);
+	}
+
+public:
+	Token() : _p(nullptr), _size(0) {}
+
+	Token(const char* p) : _p(p), _size(0) {
+		if (p)
+			_size = ::strlen(p);
+	}
+
+	Token(const char* p, size_t s) : _p(p), _size(s) {}
+
+	const char* data() const { return _p; }
+
+	size_t size() const { return _size; }
+
+	std::string str() const { return std::string(_p, _size); }
+
+	bool empty() const { return _size == 0; }
+
+	bool operator==(Token other) const {
+		if (_size != other._size)
+			return false;
+		return compareMemory(_p, other._p, _size) == 0;
+	}
+
+	bool operator!=(Token other) const {
+		return !(*this == other);
+	}
+};
+
+///
+/// Simple text-based dynamic library file tokenizer.
+///
+class Tokenizer {
+	const char* _start;
+	const char* _current;
+	const char* _end;
+	Token _currentToken;
+
+	void fetchNextToken();
+	void scanToNextToken();
+	void skip(unsigned distance) {
+		_current += distance;
+		assert(_current <= _end && "Skipped past the end");
+	}
+
+	const char* skipLineBreak(const char* pos) const;
+	bool isDelimiter(const char* pos) const;
+
+public:
+	Tokenizer(const char* data, uint64_t size) : _start(data), _current(data), _end(data + size) {}
+
+	void reset() {
+		_current = _start;
+		fetchNextToken();
+	}
+
+	Token peek() { return _currentToken; }
+	Token next() {
+		Token token = peek();
+		fetchNextToken();
+		return token;
+	}
+};
+
+const char* Tokenizer::skipLineBreak(const char* pos) const
+{
+	if ( pos == _end )
+		return pos;
+
+	// Carriage return.
+	if ( *pos == 0x0D ) {
+		// line feed.
+		if ( pos + 1 != _end && *(pos + 1) == 0x0A)
+			return pos + 2;
+		return pos + 1;
+	}
+
+	// line feed.
+	if ( *pos == 0x0A )
+		return pos + 1;
+
+	return pos;
+}
+
+void Tokenizer::scanToNextToken() {
+	while (true) {
+		while ( isDelimiter(_current) )
+			skip(1);
+
+		const char* i = skipLineBreak(_current);
+		if ( i == _current )
+			break;
+
+		_current = i;
+	}
+}
+
+
+bool Tokenizer::isDelimiter(const char* pos) const {
+	if ( pos == _end )
+		return false;
+	if ( *pos == ' ' || *pos == '\t' || *pos == '\r' || *pos == '\n' || *pos == ',' || *pos == ':' || *pos == '\'' || *pos == '\"' )
+		return true;
+	return false;
+}
+
+void Tokenizer::fetchNextToken() {
+	scanToNextToken();
+
+	if (_current == _end) {
+		_currentToken = Token();
+		return;
+	}
+
+	auto start = _current;
+	while ( !isDelimiter(_current) ) {
+		++_current;
+	}
+
+	_currentToken = Token(start, _current - start);
+}
+
+///
+/// Representation of a parsed text-based dynamic library file.
+///
+struct DynamicLibrary {
+	Token _installName;
+	uint32_t _currentVersion;
+	uint32_t _compatibilityVersion;
+	uint8_t _swiftVersion;
+	ld::File::ObjcConstraint _objcConstraint;
+	Options::Platform _platform;
+	std::vector<Token> _allowedClients;
+	std::vector<Token> _reexportedLibraries;
+	std::vector<Token> _symbols;
+	std::vector<Token> _classes;
+	std::vector<Token> _ivars;
+	std::vector<Token> _weakDefSymbols;
+	std::vector<Token> _tlvSymbols;
+
+	DynamicLibrary() : _currentVersion(0x10000), _compatibilityVersion(0x10000), _swiftVersion(0),
+		_objcConstraint(ld::File::objcConstraintNone)  {}
+};
+
+///
+/// A simple text-based dynamic library file parser.
+///
+class TBDFile {
+	Tokenizer _tokenizer;
+
+	Token peek() { return _tokenizer.peek(); }
+	Token next() { return _tokenizer.next(); }
+
+	void expectToken(Token str) {
+		Token token = next();
+		if (token != str)
+			throwf("unexpected token: %s", token.str().c_str());
+	}
+
+	bool hasOptionalToken(Token str) {
+		auto token = peek();
+		if ( token == str ) {
+			next();
+			return true;
+		}
+		return false;
+	}
+
+
+	void parseFlowSequence(std::function<void (Token)> func) {
+		expectToken("[");
+
+		while ( true ) {
+			auto token = peek();
+			if ( token == "]" )
+				break;
+
+			token = next();
+			func(token);
+		}
+
+		expectToken("]");
+	}
+
+	void parseAllowedClients(DynamicLibrary& lib) {
+		if ( !hasOptionalToken("allowed-clients") )
+			return;
+		parseFlowSequence([&](Token name) {
+			lib._allowedClients.emplace_back(name);
+		});
+	}
+
+	void parseReexportedDylibs(DynamicLibrary& lib) {
+		if ( !hasOptionalToken("re-exports") )
+			return;
+		parseFlowSequence([&](Token name) {
+			lib._reexportedLibraries.emplace_back(name);
+		});
+	}
+
+	void parseSymbols(DynamicLibrary& lib) {
+		if ( hasOptionalToken("symbols") ) {
+			parseFlowSequence([&](Token name) {
+				lib._symbols.emplace_back(name);
+			});
+		}
+
+		if ( hasOptionalToken("objc-classes") ) {
+			parseFlowSequence([&](Token name) {
+				lib._classes.emplace_back(name);
+			});
+		}
+
+		if ( hasOptionalToken("objc-ivars") ) {
+			parseFlowSequence([&](Token name) {
+				lib._ivars.emplace_back(name);
+			});
+		}
+
+		if ( hasOptionalToken("weak-def-symbols") ) {
+			parseFlowSequence([&](Token name) {
+				lib._weakDefSymbols.emplace_back(name);
+			});
+		}
+
+		if ( hasOptionalToken("thread-local-symbols") ) {
+			parseFlowSequence([&](Token name) {
+				lib._tlvSymbols.emplace_back(name);
+			});
+		}
+	}
+
+	std::vector<std::string> parseArchFlowSequence() {
+		std::vector<std::string> availabledArchitectures;
+		expectToken("archs");
+		parseFlowSequence([&](Token name) {
+			availabledArchitectures.emplace_back(name.str());
+		});
+		return availabledArchitectures;
+	}
+
+	bool parseArchFlowSequence(std::string &selectedArchName) {
+		auto availabledArchitectures = parseArchFlowSequence();
+
+		for (const auto &archName : availabledArchitectures) {
+			if (archName == selectedArchName)
+				return true;
+		}
+
+		return false;
+	}
+
+	void parsePlatform(DynamicLibrary& lib) {
+		expectToken("platform");
+
+		auto token =  next();
+		if (token == "macosx")
+			lib._platform = Options::kPlatformOSX;
+		else if (token == "ios")
+			lib._platform = Options::kPlatformiOS;
+		else if (token == "watchos")
+			lib._platform = Options::kPlatformWatchOS;
+#if SUPPORT_APPLE_TV
+		else if (token == "tvos")
+			lib._platform = Options::kPlatform_tvOS;
+#endif
+		else
+			lib._platform = Options::kPlatformUnknown;
+	}
+
+	void parseInstallName(DynamicLibrary& lib) {
+		expectToken("install-name");
+
+		lib._installName = next();
+		if ( lib._installName.empty() )
+			throwf("no install name specified");
+	}
+
+	uint32_t parseVersionNumber32(Token token) {
+		if ( token.size() >= 128 )
+			throwf("malformed version number");
+
+		// Make a null-terminated string.
+		char buffer[128];
+		::memcpy(buffer, token.data(), token.size());
+		buffer[token.size()] = '\0';
+
+		return Options::parseVersionNumber32(buffer);
+	}
+
+	void parseCurrentVersion(DynamicLibrary& lib) {
+		if ( !hasOptionalToken("current-version") )
+			return;
+		lib._currentVersion = parseVersionNumber32(next());
+	}
+
+	void parseCompatibilityVersion(DynamicLibrary& lib) {
+		if ( !hasOptionalToken("compatibility-version") )
+			return;
+		lib._compatibilityVersion = parseVersionNumber32(next());
+	}
+
+	void parseSwiftVersion(DynamicLibrary& lib) {
+		if ( !hasOptionalToken("swift-version") )
+			return;
+		auto token = next();
+		if ( token == "1.0" )
+			lib._swiftVersion = 1;
+		else if ( token == "1.1" )
+			lib._swiftVersion = 2;
+		else if ( token == "2.0" )
+			lib._swiftVersion = 3;
+		else
+			throwf("unsupported Swift ABI version: %s", token.str().c_str());
+	}
+
+	void parseObjCConstraint(DynamicLibrary& lib) {
+		if ( !hasOptionalToken("objc-constraint") )
+			return;
+		auto token = next();
+		if ( token == "none" )
+			lib._objcConstraint = ld::File::objcConstraintNone;
+		else if ( token == "retain_release" )
+			lib._objcConstraint = ld::File::objcConstraintRetainRelease;
+		else if ( token == "retain_release_for_simulator" )
+			lib._objcConstraint = ld::File::objcConstraintRetainReleaseForSimulator;
+		else if ( token == "retain_release_or_gc" )
+			lib._objcConstraint = ld::File::objcConstraintRetainReleaseOrGC;
+		else if ( token == "gc" )
+			lib._objcConstraint = ld::File::objcConstraintGC;
+		else
+			throwf("unexpected token: %s", token.str().c_str());
+	}
+	void parseExportsBlock(DynamicLibrary& lib, std::string &selectedArchName) {
+		if ( !hasOptionalToken("exports") )
+			return;
+
+		if ( !hasOptionalToken("-") )
+			return;
+
+		while ( true ) {
+			if ( !parseArchFlowSequence(selectedArchName) ) {
+				Token token;
+				while ( true ) {
+					token = peek();
+					if ( token == "archs" || token == "..." || token.empty() )
+						break;
+					next();
+				}
+				if (token == "..." || token.empty() )
+					break;
+
+				continue;
+			}
+
+			parseAllowedClients(lib);
+			parseReexportedDylibs(lib);
+			parseSymbols(lib);
+			if ( !hasOptionalToken("-") )
+				break;
+		}
+	}
+
+	std::vector<std::string> getCompatibleArchList(std::string &requestedArchName) {
+		if (requestedArchName == "i386")
+			return {"i386"};
+		else if (requestedArchName == "x86_64" || requestedArchName == "x86_64h")
+			return {"x86_64", "x86_64h"};
+		else if (requestedArchName == "armv7" || requestedArchName == "armv7s")
+			return {"armv7", "armv7s"};
+		else if (requestedArchName == "armv7k")
+			return {"armv7k"};
+		else if (requestedArchName == "arm64")
+			return {"arm64"};
+		else
+			return {};
+	}
+
+	std::string parseAndSelectArchitecture(std::string &requestedArchName) {
+		auto availabledArchitectures = parseArchFlowSequence();
+
+		// First try to find an exact match (cpu type and sub-cpu type).
+		if (std::find(availabledArchitectures.begin(), availabledArchitectures.end(), requestedArchName)
+			!= availabledArchitectures.end())
+			return requestedArchName;
+
+		// If there is no exact match, then try to find an ABI compatible slice.
+		auto compatibleArchitectures = getCompatibleArchList(requestedArchName);
+		std::vector<std::string> result;
+		std::sort(availabledArchitectures.begin(), availabledArchitectures.end());
+		std::sort(compatibleArchitectures.begin(), compatibleArchitectures.end());
+		std::set_intersection(availabledArchitectures.begin(), availabledArchitectures.end(),
+							  compatibleArchitectures.begin(), compatibleArchitectures.end(),
+							  std::back_inserter(result));
+
+		if (result.empty())
+			return std::string();
+		else
+			return result.front();
+	}
+
+	void parseDocument(DynamicLibrary& lib, std::string &requestedArchName) {
+		auto selectedArchName = parseAndSelectArchitecture(requestedArchName);
+		if (selectedArchName.empty())
+			throwf("invalid arch");
+
+		parsePlatform(lib);
+		parseInstallName(lib);
+		parseCurrentVersion(lib);
+		parseCompatibilityVersion(lib);
+		parseSwiftVersion(lib);
+		parseObjCConstraint(lib);
+		parseExportsBlock(lib, selectedArchName);
+	}
+
+public:
+	TBDFile(const char* data, uint64_t size) : _tokenizer(data, size) {}
+
+	DynamicLibrary parseFileForArch(std::string requestedArchName) {
+		_tokenizer.reset();
+		DynamicLibrary lib;
+		expectToken("---");
+		parseDocument(lib, requestedArchName);
+		expectToken("...");
+		return lib;
+	}
+
+	bool validForArch(std::string requestedArchName) {
+		_tokenizer.reset();
+		auto token = next();
+		if ( token != "---" )
+			return false;
+		return !parseAndSelectArchitecture(requestedArchName).empty();
+	}
+
+	void dumpTokens() {
+		_tokenizer.reset();
+		Token token;
+		do {
+			token = next();
+			printf("token: %s\n", token.str().c_str());
+		} while ( !token.empty() );
+	}
+};
+
+} // end anonymous namespace
 
 namespace textstub {
 namespace dylib {
@@ -50,94 +513,51 @@ class File final : public generic::dylib::File<A>
 	using Base = generic::dylib::File<A>;
 
 public:
-					File(const char* path, const uint8_t* fileContent, uint64_t fileLength,
+	static bool		validFile(const uint8_t* fileContent, bool executableOrDylib);
+					File(const uint8_t* fileContent, uint64_t fileLength, const char* path,
 						 time_t mTime, ld::File::Ordinal ordinal, bool linkingFlatNamespace,
-						 bool linkingMainExecutable, bool hoistImplicitPublicDylibs,
-						 Options::Platform platform, uint32_t linkMinOSVersion, bool allowWeakImports,
-						 cpu_type_t cpuType, cpu_subtype_t cpuSubType, bool enforceDylibSubtypesMatch,
-						 bool allowSimToMacOSX, bool addVers, bool buildingForSimulator,
+						 bool hoistImplicitPublicDylibs, Options::Platform platform,
+						 cpu_type_t cpuType, const char* archName, uint32_t linkMinOSVersion,
+						 bool allowWeakImports, bool allowSimToMacOSX, bool addVers, bool buildingForSimulator,
 						 bool logAllFiles, const char* installPath, bool indirectDylib);
 	virtual			~File() noexcept {}
 
 private:
-	void			buildExportHashTable(const tapi::LinkerInterfaceFile* file);
-};
-
-static ld::File::ObjcConstraint mapObjCConstraint(tapi::ObjCConstraint constraint) {
-	switch (constraint) {
-	case tapi::ObjCConstraint::None:
-		return ld::File::objcConstraintNone;
-	case tapi::ObjCConstraint::Retain_Release:
-		return ld::File::objcConstraintRetainRelease;
-	case tapi::ObjCConstraint::Retain_Release_For_Simulator:
-		return ld::File::objcConstraintRetainReleaseForSimulator;
-	case tapi::ObjCConstraint::Retain_Release_Or_GC:
-		return ld::File::objcConstraintRetainReleaseOrGC;
-	case tapi::ObjCConstraint::GC:
-		return ld::File::objcConstraintGC;
-	}
-
-	return ld::File::objcConstraintNone;
-}
+	void			buildExportHashTable(const DynamicLibrary &lib);
 
-static Options::Platform mapPlatform(tapi::Platform platform) {
-	switch (platform) {
-	case tapi::Platform::Unknown:
-		return Options::kPlatformUnknown;
-	case tapi::Platform::OSX:
-		return Options::kPlatformOSX;
-	case tapi::Platform::iOS:
-		return Options::kPlatformiOS;
-	case tapi::Platform::watchOS:
-		return Options::kPlatformWatchOS;
-	case tapi::Platform::tvOS:
-		return Options::kPlatform_tvOS;
-	}
-
-	return Options::kPlatformUnknown;
-}
+	cpu_type_t		_cpuType;
+};
 
 template <typename A>
-	File<A>::File(const char* path, const uint8_t* fileContent, uint64_t fileLength,
-			  time_t mTime, ld::File::Ordinal ord, bool linkingFlatNamespace,
-			  bool linkingMainExecutable, bool hoistImplicitPublicDylibs, Options::Platform platform,
-			  uint32_t linkMinOSVersion, bool allowWeakImports, cpu_type_t cpuType, cpu_subtype_t cpuSubType,
-				bool enforceDylibSubtypesMatch, bool allowSimToMacOSX, bool addVers,
+File<A>::File(const uint8_t* fileContent, uint64_t fileLength, const char* path, time_t mTime,
+			  ld::File::Ordinal ord, bool linkingFlatNamespace, bool hoistImplicitPublicDylibs,
+			  Options::Platform platform, cpu_type_t cpuType, const char* archName,
+			  uint32_t linkMinOSVersion, bool allowWeakImports, bool allowSimToMacOSX, bool addVers,
 			  bool buildingForSimulator, bool logAllFiles, const char* targetInstallPath,
 			  bool indirectDylib)
 	: Base(strdup(path), mTime, ord, platform, linkMinOSVersion, allowWeakImports, linkingFlatNamespace,
-		   hoistImplicitPublicDylibs, allowSimToMacOSX, addVers)
+		   hoistImplicitPublicDylibs, allowSimToMacOSX, addVers),
+	  _cpuType(cpuType)
 {
-	auto matchingType = enforceDylibSubtypesMatch ?
-			tapi::CpuSubTypeMatching::Exact : tapi::CpuSubTypeMatching::ABI_Compatible;
-
-	std::string errorMessage;
-	auto file = std::unique_ptr<tapi::LinkerInterfaceFile>(
-		tapi::LinkerInterfaceFile::create(path, fileContent, fileLength, cpuType,
-										  cpuSubType, matchingType,
-										  tapi::PackedVersion32(linkMinOSVersion), errorMessage));
-
-	if (file == nullptr)
-		throw strdup(errorMessage.c_str());
-
-	// unmap file - it is no longer needed.
-	munmap((caddr_t)fileContent, fileLength);
+	this->_bitcode = std::unique_ptr<ld::Bitcode>(new ld::Bitcode(nullptr, 0));
+	// Text stubs are implicit app extension safe.
+	this->_appExtensionSafe = true;
 
 	// write out path for -t option
 	if ( logAllFiles )
 		printf("%s\n", path);
 
-	this->_bitcode = std::unique_ptr<ld::Bitcode>(new ld::Bitcode(nullptr, 0));
-	this->_noRexports = !file->hasReexportedLibraries();
-	this->_hasWeakExports = file->hasWeakDefinedExports();
-	this->_dylibInstallPath = strdup(file->getInstallName().c_str());
-	this->_installPathOverride = file->isInstallNameVersionSpecific();
-	this->_dylibCurrentVersion = file->getCurrentVersion();
-	this->_dylibCompatibilityVersion = file->getCompatibilityVersion();
-	this->_swiftVersion = file->getSwiftVersion();
-	this->_objcConstraint = mapObjCConstraint(file->getObjCConstraint());
-	this->_parentUmbrella = file->getParentFrameworkName().empty() ? nullptr : strdup(file->getParentFrameworkName().c_str());
-	this->_appExtensionSafe = file->isApplicationExtensionSafe();
+	TBDFile stub((const char*)fileContent, fileLength);
+	auto lib = stub.parseFileForArch(archName);
+
+	this->_noRexports = lib._reexportedLibraries.empty();
+	this->_hasWeakExports = !lib._weakDefSymbols.empty();
+	this->_dylibInstallPath = strdup(lib._installName.str().c_str());
+	this->_dylibCurrentVersion = lib._currentVersion;
+	this->_dylibCompatibilityVersion = lib._compatibilityVersion;
+	this->_swiftVersion = lib._swiftVersion;
+	this->_objcConstraint = lib._objcConstraint;
+	this->_hasPublicInstallName = this->isPublicLocation(this->_dylibInstallPath);
 
 	// if framework, capture framework name
 	const char* lastSlash = strrchr(this->_dylibInstallPath, '/');
@@ -151,69 +571,100 @@ template <typename A>
 			this->_frameworkName = leafName;
 	}
 
-	for (auto &client : file->allowableClients())
-		this->_allowableClients.push_back(strdup(client.c_str()));
+  // TEMPORARY HACK BEGIN: Support ancient re-export command LC_SUB_FRAMEWORK.
+	// <rdar://problem/23614899> [TAPI] Support LC_SUB_FRAMEWORK as re-export indicator.
+	auto installName = std::string(this->_dylibInstallPath);
+
+	// All sub-frameworks of ApplicationServices use LC_SUB_FRAMEWORK.
+	if (installName.find("/System/Library/Frameworks/ApplicationServices.framework/Versions/A/Frameworks/") == 0 &&
+			installName.find(".dylib") == std::string::npos) {
+		this->_parentUmbrella = "ApplicationServices";
+	} else if (installName.find("/System/Library/Frameworks/Carbon.framework/Versions/A/Frameworks/") == 0) {
+		this->_parentUmbrella = "Carbon";
+	} else if (installName.find("/System/Library/Frameworks/CoreServices.framework/Versions/A/Frameworks/") == 0 &&
+					 installName.find(".dylib") == std::string::npos) {
+		this->_parentUmbrella = "CoreServices";
+	} else if (installName.find("/System/Library/Frameworks/Accelerate.framework/Versions/A/Frameworks/vecLib.framework/Versions/A/libLinearAlgebra.dylib") == 0 ||
+					 installName.find("/System/Library/Frameworks/Accelerate.framework/Versions/A/Frameworks/vecLib.framework/Versions/A/libQuadrature.dylib") == 0 ||
+					 installName.find("System/Library/Frameworks/Accelerate.framework/Versions/A/Frameworks/vecLib.framework/Versions/A/libSparseBLAS.dylib") == 0) {
+		this->_parentUmbrella = "vecLib";
+	} else if (installName.find("/System/Library/Frameworks/WebKit.framework/Versions/A/Frameworks/WebCore.framework/Versions/A/WebCore") == 0) {
+		this->_parentUmbrella = "WebKit";
+	} else if (installName.find("/usr/lib/system/") == 0 &&
+			   installName != "/usr/lib/system/libkxld.dylib") {
+		this->_parentUmbrella = "System";
+	}
+	// TEMPORARY HACK END
+
+	for (auto &client : lib._allowedClients) {
+		if ((this->_parentUmbrella != nullptr) && (client.str() != this->_parentUmbrella))
+			this->_allowableClients.push_back(strdup(client.str().c_str()));
+	}
 
 	// <rdar://problem/20659505> [TAPI] Don't hoist "public" (in /usr/lib/) dylibs that should not be directly linked
-	this->_hasPublicInstallName = file->hasAllowableClients() ? false : this->isPublicLocation(file->getInstallName().c_str());
-
-	for (const auto &client : file->allowableClients())
-		this->_allowableClients.emplace_back(strdup(client.c_str()));
+	if ( !this->_allowableClients.empty() )
+		this->_hasPublicInstallName = false;
 
-	auto dylibPlatform = mapPlatform(file->getPlatform());
-	if ( (dylibPlatform != platform) && (platform != Options::kPlatformUnknown) ) {
+	if ( (lib._platform != platform) && (platform != Options::kPlatformUnknown) ) {
 		this->_wrongOS = true;
 		if ( this->_addVersionLoadCommand && !indirectDylib ) {
 			if ( buildingForSimulator ) {
 				if ( !this->_allowSimToMacOSXLinking )
 					throwf("building for %s simulator, but linking against dylib built for %s (%s).",
-							Options::platformName(platform), Options::platformName(dylibPlatform), path);
+							Options::platformName(platform), Options::platformName(lib._platform), path);
 			} else {
 				throwf("building for %s, but linking against dylib built for %s (%s).",
-						Options::platformName(platform), Options::platformName(dylibPlatform), path);
+						Options::platformName(platform), Options::platformName(lib._platform), path);
 			}
 		}
 	}
 
-	for (const auto& reexport : file->reexportedLibraries()) {
-		const char *path = strdup(reexport.c_str());
+	this->_dependentDylibs.reserve(lib._reexportedLibraries.size());
+	for ( const auto& reexport : lib._reexportedLibraries ) {
+		const char *path = strdup(reexport.str().c_str());
 		if ( (targetInstallPath == nullptr) || (strcmp(targetInstallPath, path) != 0) )
 			this->_dependentDylibs.emplace_back(path, true);
 	}
 
-	for (const auto& symbol : file->ignoreExports())
-		this->_ignoreExports.insert(strdup(symbol.c_str()));
-
-	// if linking flat and this is a flat dylib, create one atom that references all imported symbols.
-	if ( linkingFlatNamespace && linkingMainExecutable && (file->hasTwoLevelNamespace() == false) ) {
-		std::vector<const char*> importNames;
-		importNames.reserve(file->undefineds().size());
-		// We do not need to strdup the name, because that will be done by the
-		// ImportAtom constructor.
-		for (const auto &sym : file->undefineds())
-			importNames.emplace_back(sym.getName().c_str());
-		this->_importAtom = new generic::dylib::ImportAtom<A>(*this, importNames);
-	}
-
 	// build hash table
-	buildExportHashTable(file.get());
+	buildExportHashTable(lib);
+
+	munmap((caddr_t)fileContent, fileLength);
 }
 
 template <typename A>
-void File<A>::buildExportHashTable(const tapi::LinkerInterfaceFile* file) {
+void File<A>::buildExportHashTable(const DynamicLibrary& lib) {
 	if (this->_s_logHashtable )
 		fprintf(stderr, "ld: building hashtable from text-stub info in %s\n", this->path());
 
-	for (const auto &sym : file->exports()) {
-		const char* name = sym.getName().c_str();
-		bool weakDef = sym.isWeakDefined();
-		bool tlv = sym.isThreadLocalValue();
+	for (auto &sym : lib._symbols)
+		this->addSymbol(sym.str().c_str());
 
-		typename Base::AtomAndWeak bucket = { nullptr, weakDef, tlv, 0 };
-		if ( this->_s_logHashtable )
-			fprintf(stderr, "  adding %s to hash table for %s\n", name, this->path());
-		this->_atoms[strdup(name)] = bucket;
+#if SUPPORT_ARCH_i386
+	if (this->_platform == Options::kPlatformOSX && _cpuType == CPU_TYPE_I386) {
+		for (auto &sym : lib._classes)
+			this->addSymbol((".objc_class_name" + sym.str()).c_str());
+	} else {
+		for (auto &sym : lib._classes) {
+			this->addSymbol(("_OBJC_CLASS_$" + sym.str()).c_str());
+			this->addSymbol(("_OBJC_METACLASS_$" + sym.str()).c_str());
+		}
 	}
+#else
+	for (auto &sym : lib._classes) {
+		this->addSymbol(("_OBJC_CLASS_$" + sym.str()).c_str());
+		this->addSymbol(("_OBJC_METACLASS_$" + sym.str()).c_str());
+	}
+#endif
+
+	for (auto &sym : lib._ivars)
+		this->addSymbol(("_OBJC_IVAR_$" + sym.str()).c_str());
+
+	for (auto &sym : lib._weakDefSymbols)
+		this->addSymbol(sym.str().c_str(), /*weak=*/true);
+
+	for (auto &sym : lib._tlvSymbols)
+		this->addSymbol(sym.str().c_str(), /*weak=*/false, /*tlv=*/true);
 }
 
 template <typename A>
@@ -222,21 +673,20 @@ class Parser
 public:
 	using P = typename A::P;
 
-	static ld::dylib::File*	parse(const char* path, const uint8_t* fileContent,
-								  uint64_t fileLength, time_t mTime,
-								  ld::File::Ordinal ordinal, const Options& opts,
+	static bool				validFile(const uint8_t* fileContent, uint64_t fileLength,
+									  const std::string &path, const char* archName);
+	static ld::dylib::File*	parse(const uint8_t* fileContent, uint64_t fileLength, const char* path,
+								  time_t mTime, ld::File::Ordinal ordinal, const Options& opts,
 								  bool indirectDylib)
 	{
-		return new File<A>(path, fileContent, fileLength,mTime, ordinal,
+		return new File<A>(fileContent, fileLength, path, mTime, ordinal,
 						   opts.flatNamespace(),
-						   opts.linkingMainExecutable(),
 						   opts.implicitlyLinkIndirectPublicDylibs(),
 						   opts.platform(),
+						   opts.architecture(),
+						   opts.architectureName(),
 						   opts.minOSversion(),
 						   opts.allowWeakImports(),
-						   opts.architecture(),
-						   opts.subArchitecture(),
-						   opts.enforceDylibSubtypesMatch(),
 						   opts.allowSimulatorToLinkWithMacOSX(),
 						   opts.addVersionLoadCommand(),
 						   opts.targetIOSSimulator(),
@@ -246,6 +696,20 @@ public:
 	}
 };
 
+template <typename A>
+bool Parser<A>::validFile(const uint8_t* fileContent, uint64_t fileLength, const std::string &path,
+						  const char* archName)
+{
+	if ( path.find(".tbd", path.size()-4) == std::string::npos )
+		return false;
+
+	TBDFile stub((const char*)fileContent, fileLength);
+	if ( !stub.validForArch(archName) )
+		throwf("missing required architecture %s in file %s", archName, path.c_str());
+
+	return true;
+}
+
 //
 // main function used by linker to instantiate ld::Files
 //
@@ -253,27 +717,30 @@ ld::dylib::File* parse(const uint8_t* fileContent, uint64_t fileLength, const ch
 					   time_t modTime, const Options& opts, ld::File::Ordinal ordinal,
 					   bool bundleLoader, bool indirectDylib)
 {
-
 	switch ( opts.architecture() ) {
 #if SUPPORT_ARCH_x86_64
 		case CPU_TYPE_X86_64:
-		if (tapi::LinkerInterfaceFile::isSupported(path, fileContent, fileLength))
-			return Parser<x86_64>::parse(path, fileContent, fileLength, modTime, ordinal, opts, indirectDylib);
+			if ( Parser<x86_64>::validFile(fileContent, fileLength, path, opts.architectureName()) )
+				return Parser<x86_64>::parse(fileContent, fileLength, path, modTime, ordinal, opts, indirectDylib);
+			break;
 #endif
 #if SUPPORT_ARCH_i386
 		case CPU_TYPE_I386:
-		if (tapi::LinkerInterfaceFile::isSupported(path, fileContent, fileLength))
-			return Parser<x86>::parse(path, fileContent, fileLength, modTime, ordinal, opts, indirectDylib);
+			if ( Parser<x86>::validFile(fileContent, fileLength, path, opts.architectureName()) )
+				return Parser<x86>::parse(fileContent, fileLength, path, modTime, ordinal, opts, indirectDylib);
+			break;
 #endif
 #if SUPPORT_ARCH_arm_any
 		case CPU_TYPE_ARM:
-		if (tapi::LinkerInterfaceFile::isSupported(path, fileContent, fileLength))
-			return Parser<arm>::parse(path, fileContent, fileLength, modTime, ordinal, opts, indirectDylib);
+			if ( Parser<arm>::validFile(fileContent, fileLength, path, opts.architectureName()) )
+				return Parser<arm>::parse(fileContent, fileLength, path, modTime, ordinal, opts, indirectDylib);
+			break;
 #endif
 #if SUPPORT_ARCH_arm64
 		case CPU_TYPE_ARM64:
-		if (tapi::LinkerInterfaceFile::isSupported(path, fileContent, fileLength))
-			return Parser<arm64>::parse(path, fileContent, fileLength, modTime, ordinal, opts, indirectDylib);
+			if ( Parser<arm64>::validFile(fileContent, fileLength, path, opts.architectureName()) )
+				return Parser<arm64>::parse(fileContent, fileLength, path, modTime, ordinal, opts, indirectDylib);
+			break;
 #endif
 	}
 	return nullptr;
-- 
2.11.0