This is an archive of the discontinued LLVM Phabricator instance.

Paths

Table of Contentst

-
tools/llvm-ar/
-
llvm-ar/
-
llvm-ar.cpp

Differential D53769

[llvm-ar] Strip trailing \r and format
ClosedPublic

Authored by MaskRay on Oct 26 2018, 10:26 AM.

Download Raw Diff

Details

Reviewers

mstorsjo
rupprecht
gbreynoo

Commits

rGf0333f0b07aa: [llvm-ar] Strip trailing \r and format
rL345410: [llvm-ar] Strip trailing \r and format

Diff Detail

Repository

rL LLVM

Build Status

Buildable 24252
Build 24251: arc lint + arc unit

Event Timeline

MaskRay created this revision.Oct 26 2018, 10:26 AM

Herald added a subscriber: llvm-commits. · View Herald TranscriptOct 26 2018, 10:26 AM

Harbormaster completed remote builds in B24252: Diff 171318.Oct 26 2018, 10:27 AM

Is this why r345383 showed so many diffs on lines w/ no visible changes? Thanks.

This revision is now accepted and ready to land.Oct 26 2018, 10:29 AM

Closed by commit rL345410: [llvm-ar] Strip trailing \r and format (authored by MaskRay). · Explain WhyOct 26 2018, 10:40 AM

This revision was automatically updated to reflect the committed changes.

In D53769#1277590, @rupprecht wrote:

Is this why r345383 showed so many diffs on lines w/ no visible changes? Thanks.

Yes. r345383 added \r to every line... Fortunately git log -b will ignore space changes

Revision Contents

Path

Size

tools/

llvm-ar/

llvm-ar.cpp

2064 lines

Diff 171318

tools/llvm-ar/llvm-ar.cpp

	//===-- llvm-ar.cpp - LLVM archive librarian utility ----------------------===//			//===-- llvm-ar.cpp - LLVM archive librarian utility ----------------------===//
	//			//
	// The LLVM Compiler Infrastructure			// The LLVM Compiler Infrastructure
	//			//
	// This file is distributed under the University of Illinois Open Source			// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.			// License. See LICENSE.TXT for details.
	//			//
	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//
	//			//
	// Builds up (relatively) standard unix archive files (.a) containing LLVM			// Builds up (relatively) standard unix archive files (.a) containing LLVM
	// bitcode or other files.			// bitcode or other files.
	//			//
	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//

	#include "llvm/ADT/StringSwitch.h"			#include "llvm/ADT/StringSwitch.h"
	#include "llvm/ADT/Triple.h"			#include "llvm/ADT/Triple.h"
	#include "llvm/IR/LLVMContext.h"			#include "llvm/IR/LLVMContext.h"
	#include "llvm/Object/Archive.h"			#include "llvm/Object/Archive.h"
	#include "llvm/Object/ArchiveWriter.h"			#include "llvm/Object/ArchiveWriter.h"
	#include "llvm/Object/MachO.h"			#include "llvm/Object/MachO.h"
	#include "llvm/Object/ObjectFile.h"			#include "llvm/Object/ObjectFile.h"
	#include "llvm/Support/Chrono.h"			#include "llvm/Support/Chrono.h"
	#include "llvm/Support/CommandLine.h"			#include "llvm/Support/CommandLine.h"
	#include "llvm/Support/Errc.h"			#include "llvm/Support/Errc.h"
	#include "llvm/Support/FileSystem.h"			#include "llvm/Support/FileSystem.h"
	#include "llvm/Support/Format.h"			#include "llvm/Support/Format.h"
	#include "llvm/Support/FormatVariadic.h"			#include "llvm/Support/FormatVariadic.h"
	#include "llvm/Support/InitLLVM.h"			#include "llvm/Support/InitLLVM.h"
	#include "llvm/Support/LineIterator.h"			#include "llvm/Support/LineIterator.h"
	#include "llvm/Support/MemoryBuffer.h"			#include "llvm/Support/MemoryBuffer.h"
	#include "llvm/Support/Path.h"			#include "llvm/Support/Path.h"
	#include "llvm/Support/Process.h"			#include "llvm/Support/Process.h"
	#include "llvm/Support/StringSaver.h"			#include "llvm/Support/StringSaver.h"
	#include "llvm/Support/TargetSelect.h"			#include "llvm/Support/TargetSelect.h"
	#include "llvm/Support/ToolOutputFile.h"			#include "llvm/Support/ToolOutputFile.h"
	#include "llvm/Support/raw_ostream.h"			#include "llvm/Support/raw_ostream.h"
	#include "llvm/ToolDrivers/llvm-dlltool/DlltoolDriver.h"			#include "llvm/ToolDrivers/llvm-dlltool/DlltoolDriver.h"
	#include "llvm/ToolDrivers/llvm-lib/LibDriver.h"			#include "llvm/ToolDrivers/llvm-lib/LibDriver.h"

	#if !defined(_MSC_VER) && !defined(__MINGW32__)			#if !defined(_MSC_VER) && !defined(__MINGW32__)
	#include <unistd.h>			#include <unistd.h>
	#else			#else
	#include <io.h>			#include <io.h>
	#endif			#endif

	using namespace llvm;			using namespace llvm;

	// The name this program was invoked as.			// The name this program was invoked as.
	static StringRef ToolName;			static StringRef ToolName;

	// The basename of this program.			// The basename of this program.
	static StringRef Stem;			static StringRef Stem;

	const char RanlibHelp[] = R"(			const char RanlibHelp[] = R"(
	OVERVIEW: LLVM Ranlib (llvm-ranlib)			OVERVIEW: LLVM Ranlib (llvm-ranlib)

	This program generates an index to speed access to archives			This program generates an index to speed access to archives

	USAGE: llvm-ranlib <archive-file>			USAGE: llvm-ranlib <archive-file>

	OPTIONS:			OPTIONS:
	-help - Display available options			-help - Display available options
	-version - Display the version of this program			-version - Display the version of this program
	)";			)";

	const char ArHelp[] = R"(			const char ArHelp[] = R"(
	OVERVIEW: LLVM Archiver			OVERVIEW: LLVM Archiver

	USAGE: llvm-ar [options] [-]<operation>[modifiers] [relpos] <archive> [files]			USAGE: llvm-ar [options] [-]<operation>[modifiers] [relpos] <archive> [files]
	llvm-ar -M [<mri-script]			llvm-ar -M [<mri-script]

	OPTIONS:			OPTIONS:
	--format - Archive format to create			--format - Archive format to create
	=default - default			=default - default
	=gnu - gnu			=gnu - gnu
	=darwin - darwin			=darwin - darwin
	=bsd - bsd			=bsd - bsd
	--plugin=<string> - Ignored for compatibility			--plugin=<string> - Ignored for compatibility
	--help - Display available options			--help - Display available options
	--version - Display the version of this program			--version - Display the version of this program

	OPERATIONS:			OPERATIONS:
	d - delete [files] from the archive			d - delete [files] from the archive
	m - move [files] in the archive			m - move [files] in the archive
	p - print [files] found in the archive			p - print [files] found in the archive
	q - quick append [files] to the archive			q - quick append [files] to the archive
	r - replace or insert [files] into the archive			r - replace or insert [files] into the archive
	s - act as ranlib			s - act as ranlib
	t - display contents of archive			t - display contents of archive
	x - extract [files] from the archive			x - extract [files] from the archive

	MODIFIERS:			MODIFIERS:
	[a] - put [files] after [relpos]			[a] - put [files] after [relpos]
	[b] - put [files] before [relpos] (same as [i])			[b] - put [files] before [relpos] (same as [i])
	[c] - do not warn if archive had to be created			[c] - do not warn if archive had to be created
	[D] - use zero for timestamps and uids/gids (default)			[D] - use zero for timestamps and uids/gids (default)
	[i] - put [files] before [relpos] (same as [b])			[i] - put [files] before [relpos] (same as [b])
	[l] - ignored for compatibility			[l] - ignored for compatibility
	[L] - add archive's contents			[L] - add archive's contents
	[o] - preserve original dates			[o] - preserve original dates
	[s] - create an archive index (cf. ranlib)			[s] - create an archive index (cf. ranlib)
	[S] - do not build a symbol table			[S] - do not build a symbol table
	[T] - create a thin archive			[T] - create a thin archive
	[u] - update only [files] newer than archive contents			[u] - update only [files] newer than archive contents
	[U] - use actual timestamps and uids/gids			[U] - use actual timestamps and uids/gids
	[v] - be verbose about actions taken			[v] - be verbose about actions taken
	)";			)";

	void printHelpMessage() {			void printHelpMessage() {
	if (Stem.contains_lower("ranlib"))			if (Stem.contains_lower("ranlib"))
	outs() << RanlibHelp;			outs() << RanlibHelp;
	else if (Stem.contains_lower("ar"))			else if (Stem.contains_lower("ar"))
	outs() << ArHelp;			outs() << ArHelp;
	}			}

	// Show the error message and exit.			// Show the error message and exit.
	LLVM_ATTRIBUTE_NORETURN static void fail(Twine Error) {			LLVM_ATTRIBUTE_NORETURN static void fail(Twine Error) {
	errs() << ToolName << ": " << Error << ".\n";			errs() << ToolName << ": " << Error << ".\n";
	printHelpMessage();			printHelpMessage();
	exit(1);			exit(1);
	}			}

	static void failIfError(std::error_code EC, Twine Context = "") {			static void failIfError(std::error_code EC, Twine Context = "") {
	if (!EC)			if (!EC)
	return;			return;

	std::string ContextStr = Context.str();			std::string ContextStr = Context.str();
	if (ContextStr == "")			if (ContextStr == "")
	fail(EC.message());			fail(EC.message());
	fail(Context + ": " + EC.message());			fail(Context + ": " + EC.message());
	}			}

	static void failIfError(Error E, Twine Context = "") {			static void failIfError(Error E, Twine Context = "") {
	if (!E)			if (!E)
	return;			return;

	handleAllErrors(std::move(E), [&](const llvm::ErrorInfoBase &EIB) {			handleAllErrors(std::move(E), [&](const llvm::ErrorInfoBase &EIB) {
	std::string ContextStr = Context.str();			std::string ContextStr = Context.str();
	if (ContextStr == "")			if (ContextStr == "")
	fail(EIB.message());			fail(EIB.message());
	fail(Context + ": " + EIB.message());			fail(Context + ": " + EIB.message());
	});			});
	}			}

	static SmallVector<const char *, 256> PositionalArgs;			static SmallVector<const char *, 256> PositionalArgs;

	static bool MRI;			static bool MRI;

	namespace {			namespace {
	enum Format { Default, GNU, BSD, DARWIN, Unknown };			enum Format { Default, GNU, BSD, DARWIN, Unknown };
	}			}

	static Format FormatType = Default;			static Format FormatType = Default;

	static std::string Options;			static std::string Options;

	// This enumeration delineates the kinds of operations on an archive			// This enumeration delineates the kinds of operations on an archive
	// that are permitted.			// that are permitted.
	enum ArchiveOperation {			enum ArchiveOperation {
	Print, ///< Print the contents of the archive			Print, ///< Print the contents of the archive
	Delete, ///< Delete the specified members			Delete, ///< Delete the specified members
	Move, ///< Move members to end or as given by {a,b,i} modifiers			Move, ///< Move members to end or as given by {a,b,i} modifiers
	QuickAppend, ///< Quickly append to end of archive			QuickAppend, ///< Quickly append to end of archive
	ReplaceOrInsert, ///< Replace or Insert members			ReplaceOrInsert, ///< Replace or Insert members
	DisplayTable, ///< Display the table of contents			DisplayTable, ///< Display the table of contents
	Extract, ///< Extract files back to file system			Extract, ///< Extract files back to file system
	CreateSymTab ///< Create a symbol table in an existing archive			CreateSymTab ///< Create a symbol table in an existing archive
	};			};

	// Modifiers to follow operation to vary behavior			// Modifiers to follow operation to vary behavior
	static bool AddAfter = false; ///< 'a' modifier			static bool AddAfter = false; ///< 'a' modifier
	static bool AddBefore = false; ///< 'b' modifier			static bool AddBefore = false; ///< 'b' modifier
	static bool Create = false; ///< 'c' modifier			static bool Create = false; ///< 'c' modifier
	static bool OriginalDates = false; ///< 'o' modifier			static bool OriginalDates = false; ///< 'o' modifier
	static bool OnlyUpdate = false; ///< 'u' modifier			static bool OnlyUpdate = false; ///< 'u' modifier
	static bool Verbose = false; ///< 'v' modifier			static bool Verbose = false; ///< 'v' modifier
	static bool Symtab = true; ///< 's' modifier			static bool Symtab = true; ///< 's' modifier
	static bool Deterministic = true; ///< 'D' and 'U' modifiers			static bool Deterministic = true; ///< 'D' and 'U' modifiers
	static bool Thin = false; ///< 'T' modifier			static bool Thin = false; ///< 'T' modifier
	static bool AddLibrary = false; ///< 'L' modifier			static bool AddLibrary = false; ///< 'L' modifier

	// Relative Positional Argument (for insert/move). This variable holds			// Relative Positional Argument (for insert/move). This variable holds
	// the name of the archive member to which the 'a', 'b' or 'i' modifier			// the name of the archive member to which the 'a', 'b' or 'i' modifier
	// refers. Only one of 'a', 'b' or 'i' can be specified so we only need			// refers. Only one of 'a', 'b' or 'i' can be specified so we only need
	// one variable.			// one variable.
	static std::string RelPos;			static std::string RelPos;

	// This variable holds the name of the archive file as given on the			// This variable holds the name of the archive file as given on the
	// command line.			// command line.
	static std::string ArchiveName;			static std::string ArchiveName;

	// This variable holds the list of member files to proecess, as given			// This variable holds the list of member files to proecess, as given
	// on the command line.			// on the command line.
	static std::vector<StringRef> Members;			static std::vector<StringRef> Members;

	// Extract the member filename from the command line for the [relpos] argument			// Extract the member filename from the command line for the [relpos] argument
	// associated with a, b, and i modifiers			// associated with a, b, and i modifiers
	static void getRelPos() {			static void getRelPos() {
	if (PositionalArgs.size() == 0)			if (PositionalArgs.size() == 0)
	fail("Expected [relpos] for a, b, or i modifier");			fail("Expected [relpos] for a, b, or i modifier");
	RelPos = PositionalArgs[0];			RelPos = PositionalArgs[0];
	PositionalArgs.erase(PositionalArgs.begin());			PositionalArgs.erase(PositionalArgs.begin());
	}			}

	// Get the archive file name from the command line			// Get the archive file name from the command line
	static void getArchive() {			static void getArchive() {
	if (PositionalArgs.size() == 0)			if (PositionalArgs.size() == 0)
	fail("An archive name must be specified");			fail("An archive name must be specified");
	ArchiveName = PositionalArgs[0];			ArchiveName = PositionalArgs[0];
	PositionalArgs.erase(PositionalArgs.begin());			PositionalArgs.erase(PositionalArgs.begin());
	}			}

	// Copy over remaining items in PositionalArgs to our Members vector			// Copy over remaining items in PositionalArgs to our Members vector
	static void getMembers() {			static void getMembers() {
	for (auto &Arg : PositionalArgs)			for (auto &Arg : PositionalArgs)
	Members.push_back(Arg);			Members.push_back(Arg);
	}			}

	std::vector<std::unique_ptr<MemoryBuffer>> ArchiveBuffers;			std::vector<std::unique_ptr<MemoryBuffer>> ArchiveBuffers;
	std::vector<std::unique_ptr<object::Archive>> Archives;			std::vector<std::unique_ptr<object::Archive>> Archives;

	static object::Archive &readLibrary(const Twine &Library) {			static object::Archive &readLibrary(const Twine &Library) {
	auto BufOrErr = MemoryBuffer::getFile(Library, -1, false);			auto BufOrErr = MemoryBuffer::getFile(Library, -1, false);
	failIfError(BufOrErr.getError(), "Could not open library");			failIfError(BufOrErr.getError(), "Could not open library");
	ArchiveBuffers.push_back(std::move(*BufOrErr));			ArchiveBuffers.push_back(std::move(*BufOrErr));
	auto LibOrErr =			auto LibOrErr =
	object::Archive::create(ArchiveBuffers.back()->getMemBufferRef());			object::Archive::create(ArchiveBuffers.back()->getMemBufferRef());
	failIfError(errorToErrorCode(LibOrErr.takeError()),			failIfError(errorToErrorCode(LibOrErr.takeError()),
	"Could not parse library");			"Could not parse library");
	Archives.push_back(std::move(*LibOrErr));			Archives.push_back(std::move(*LibOrErr));
	return *Archives.back();			return *Archives.back();
	}			}

	static void runMRIScript();			static void runMRIScript();

	// Parse the command line options as presented and return the operation			// Parse the command line options as presented and return the operation
	// specified. Process all modifiers and check to make sure that constraints on			// specified. Process all modifiers and check to make sure that constraints on
	// modifier/operation pairs have not been violated.			// modifier/operation pairs have not been violated.
	static ArchiveOperation parseCommandLine() {			static ArchiveOperation parseCommandLine() {
	if (MRI) {			if (MRI) {
	if (!PositionalArgs.empty() \|\| !Options.empty())			if (!PositionalArgs.empty() \|\| !Options.empty())
	fail("Cannot mix -M and other options");			fail("Cannot mix -M and other options");
	runMRIScript();			runMRIScript();
	}			}

	// Keep track of number of operations. We can only specify one			// Keep track of number of operations. We can only specify one
	// per execution.			// per execution.
	unsigned NumOperations = 0;			unsigned NumOperations = 0;

	// Keep track of the number of positional modifiers (a,b,i). Only			// Keep track of the number of positional modifiers (a,b,i). Only
	// one can be specified.			// one can be specified.
	unsigned NumPositional = 0;			unsigned NumPositional = 0;

	// Keep track of which operation was requested			// Keep track of which operation was requested
	ArchiveOperation Operation;			ArchiveOperation Operation;

	bool MaybeJustCreateSymTab = false;			bool MaybeJustCreateSymTab = false;

	for(unsigned i=0; i<Options.size(); ++i) {			for (unsigned i = 0; i < Options.size(); ++i) {
	switch(Options[i]) {			switch (Options[i]) {
	case 'd': ++NumOperations; Operation = Delete; break;			case 'd':
	case 'm': ++NumOperations; Operation = Move ; break;			++NumOperations;
	case 'p': ++NumOperations; Operation = Print; break;			Operation = Delete;
	case 'q': ++NumOperations; Operation = QuickAppend; break;			break;
	case 'r': ++NumOperations; Operation = ReplaceOrInsert; break;			case 'm':
	case 't': ++NumOperations; Operation = DisplayTable; break;			++NumOperations;
	case 'x': ++NumOperations; Operation = Extract; break;			Operation = Move;
	case 'c': Create = true; break;			break;
	case 'l': /* accepted but unused */ break;			case 'p':
	case 'o': OriginalDates = true; break;			++NumOperations;
	case 's':			Operation = Print;
	Symtab = true;			break;
	MaybeJustCreateSymTab = true;			case 'q':
	break;			++NumOperations;
	case 'S':			Operation = QuickAppend;
	Symtab = false;			break;
	break;			case 'r':
	case 'u': OnlyUpdate = true; break;			++NumOperations;
	case 'v': Verbose = true; break;			Operation = ReplaceOrInsert;
	case 'a':			break;
	getRelPos();			case 't':
	AddAfter = true;			++NumOperations;
	NumPositional++;			Operation = DisplayTable;
	break;			break;
	case 'b':			case 'x':
	getRelPos();			++NumOperations;
	AddBefore = true;			Operation = Extract;
	NumPositional++;			break;
	break;			case 'c':
	case 'i':			Create = true;
	getRelPos();			break;
	AddBefore = true;			case 'l': /* accepted but unused */
	NumPositional++;			break;
	break;			case 'o':
	case 'D':			OriginalDates = true;
	Deterministic = true;			break;
	break;			case 's':
	case 'U':			Symtab = true;
	Deterministic = false;			MaybeJustCreateSymTab = true;
	break;			break;
	case 'T':			case 'S':
	Thin = true;			Symtab = false;
	break;			break;
	case 'L':			case 'u':
	AddLibrary = true;			OnlyUpdate = true;
	break;			break;
	default:			case 'v':
	fail(std::string("unknown option ") + Options[i]);			Verbose = true;
	}			break;
	}			case 'a':
				getRelPos();
	// At this point, the next thing on the command line must be			AddAfter = true;
	// the archive name.			NumPositional++;
	getArchive();			break;
				case 'b':
	// Everything on the command line at this point is a member.			getRelPos();
	getMembers();			AddBefore = true;
				NumPositional++;
	if (NumOperations == 0 && MaybeJustCreateSymTab) {			break;
	NumOperations = 1;			case 'i':
	Operation = CreateSymTab;			getRelPos();
	if (!Members.empty())			AddBefore = true;
	fail("The s operation takes only an archive as argument");			NumPositional++;
	}			break;
				case 'D':
	// Perform various checks on the operation/modifier specification			Deterministic = true;
	// to make sure we are dealing with a legal request.			break;
	if (NumOperations == 0)			case 'U':
	fail("You must specify at least one of the operations");			Deterministic = false;
	if (NumOperations > 1)			break;
	fail("Only one operation may be specified");			case 'T':
	if (NumPositional > 1)			Thin = true;
	fail("You may only specify one of a, b, and i modifiers");			break;
	if (AddAfter \|\| AddBefore) {			case 'L':
	if (Operation != Move && Operation != ReplaceOrInsert)			AddLibrary = true;
	fail("The 'a', 'b' and 'i' modifiers can only be specified with "			break;
	"the 'm' or 'r' operations");			default:
	}			fail(std::string("unknown option ") + Options[i]);
	if (OriginalDates && Operation != Extract)			}
	fail("The 'o' modifier is only applicable to the 'x' operation");			}
	if (OnlyUpdate && Operation != ReplaceOrInsert)
	fail("The 'u' modifier is only applicable to the 'r' operation");			// At this point, the next thing on the command line must be
	if (AddLibrary && Operation != QuickAppend)			// the archive name.
	fail("The 'L' modifier is only applicable to the 'q' operation");			getArchive();

	// Return the parsed operation to the caller			// Everything on the command line at this point is a member.
	return Operation;			getMembers();
	}
				if (NumOperations == 0 && MaybeJustCreateSymTab) {
	// Implements the 'p' operation. This function traverses the archive			NumOperations = 1;
	// looking for members that match the path list.			Operation = CreateSymTab;
	static void doPrint(StringRef Name, const object::Archive::Child &C) {			if (!Members.empty())
	if (Verbose)			fail("The s operation takes only an archive as argument");
	outs() << "Printing " << Name << "\n";			}

	Expected<StringRef> DataOrErr = C.getBuffer();			// Perform various checks on the operation/modifier specification
	failIfError(DataOrErr.takeError());			// to make sure we are dealing with a legal request.
	StringRef Data = *DataOrErr;			if (NumOperations == 0)
	outs().write(Data.data(), Data.size());			fail("You must specify at least one of the operations");
	}			if (NumOperations > 1)
				fail("Only one operation may be specified");
	// Utility function for printing out the file mode when the 't' operation is in			if (NumPositional > 1)
	// verbose mode.			fail("You may only specify one of a, b, and i modifiers");
	static void printMode(unsigned mode) {			if (AddAfter \|\| AddBefore) {
	outs() << ((mode & 004) ? "r" : "-");			if (Operation != Move && Operation != ReplaceOrInsert)
	outs() << ((mode & 002) ? "w" : "-");			fail("The 'a', 'b' and 'i' modifiers can only be specified with "
	outs() << ((mode & 001) ? "x" : "-");			"the 'm' or 'r' operations");
	}			}
				if (OriginalDates && Operation != Extract)
	// Implement the 't' operation. This function prints out just			fail("The 'o' modifier is only applicable to the 'x' operation");
	// the file names of each of the members. However, if verbose mode is requested			if (OnlyUpdate && Operation != ReplaceOrInsert)
	// ('v' modifier) then the file type, permission mode, user, group, size, and			fail("The 'u' modifier is only applicable to the 'r' operation");
	// modification time are also printed.			if (AddLibrary && Operation != QuickAppend)
	static void doDisplayTable(StringRef Name, const object::Archive::Child &C) {			fail("The 'L' modifier is only applicable to the 'q' operation");
	if (Verbose) {
	Expected<sys::fs::perms> ModeOrErr = C.getAccessMode();			// Return the parsed operation to the caller
	failIfError(ModeOrErr.takeError());			return Operation;
	sys::fs::perms Mode = ModeOrErr.get();			}
	printMode((Mode >> 6) & 007);
	printMode((Mode >> 3) & 007);			// Implements the 'p' operation. This function traverses the archive
	printMode(Mode & 007);			// looking for members that match the path list.
	Expected<unsigned> UIDOrErr = C.getUID();			static void doPrint(StringRef Name, const object::Archive::Child &C) {
	failIfError(UIDOrErr.takeError());			if (Verbose)
	outs() << ' ' << UIDOrErr.get();			outs() << "Printing " << Name << "\n";
	Expected<unsigned> GIDOrErr = C.getGID();
	failIfError(GIDOrErr.takeError());			Expected<StringRef> DataOrErr = C.getBuffer();
	outs() << '/' << GIDOrErr.get();			failIfError(DataOrErr.takeError());
	Expected<uint64_t> Size = C.getSize();			StringRef Data = *DataOrErr;
	failIfError(Size.takeError());			outs().write(Data.data(), Data.size());
	outs() << ' ' << format("%6llu", Size.get());			}
	auto ModTimeOrErr = C.getLastModified();
	failIfError(ModTimeOrErr.takeError());			// Utility function for printing out the file mode when the 't' operation is in
	// Note: formatv() only handles the default TimePoint<>, which is in			// verbose mode.
	// nanoseconds.			static void printMode(unsigned mode) {
	// TODO: fix format_provider<TimePoint<>> to allow other units.			outs() << ((mode & 004) ? "r" : "-");
	sys::TimePoint<> ModTimeInNs = ModTimeOrErr.get();			outs() << ((mode & 002) ? "w" : "-");
	outs() << ' ' << formatv("{0:%b %e %H:%M %Y}", ModTimeInNs);			outs() << ((mode & 001) ? "x" : "-");
	outs() << ' ';			}
	}
				// Implement the 't' operation. This function prints out just
	if (C.getParent()->isThin()) {			// the file names of each of the members. However, if verbose mode is requested
	outs() << sys::path::parent_path(ArchiveName);			// ('v' modifier) then the file type, permission mode, user, group, size, and
	outs() << '/';			// modification time are also printed.
	}			static void doDisplayTable(StringRef Name, const object::Archive::Child &C) {
	outs() << Name << "\n";			if (Verbose) {
	}			Expected<sys::fs::perms> ModeOrErr = C.getAccessMode();
				failIfError(ModeOrErr.takeError());
	// Implement the 'x' operation. This function extracts files back to the file			sys::fs::perms Mode = ModeOrErr.get();
	// system.			printMode((Mode >> 6) & 007);
	static void doExtract(StringRef Name, const object::Archive::Child &C) {			printMode((Mode >> 3) & 007);
	// Retain the original mode.			printMode(Mode & 007);
	Expected<sys::fs::perms> ModeOrErr = C.getAccessMode();			Expected<unsigned> UIDOrErr = C.getUID();
	failIfError(ModeOrErr.takeError());			failIfError(UIDOrErr.takeError());
	sys::fs::perms Mode = ModeOrErr.get();			outs() << ' ' << UIDOrErr.get();
				Expected<unsigned> GIDOrErr = C.getGID();
	int FD;			failIfError(GIDOrErr.takeError());
	failIfError(sys::fs::openFileForWrite(sys::path::filename(Name), FD,			outs() << '/' << GIDOrErr.get();
	sys::fs::CD_CreateAlways,			Expected<uint64_t> Size = C.getSize();
	sys::fs::F_None, Mode),			failIfError(Size.takeError());
	Name);			outs() << ' ' << format("%6llu", Size.get());
				auto ModTimeOrErr = C.getLastModified();
	{			failIfError(ModTimeOrErr.takeError());
	raw_fd_ostream file(FD, false);			// Note: formatv() only handles the default TimePoint<>, which is in
				// nanoseconds.
	// Get the data and its length			// TODO: fix format_provider<TimePoint<>> to allow other units.
	Expected<StringRef> BufOrErr = C.getBuffer();			sys::TimePoint<> ModTimeInNs = ModTimeOrErr.get();
	failIfError(BufOrErr.takeError());			outs() << ' ' << formatv("{0:%b %e %H:%M %Y}", ModTimeInNs);
	StringRef Data = BufOrErr.get();			outs() << ' ';
				}
	// Write the data.
	file.write(Data.data(), Data.size());			if (C.getParent()->isThin()) {
	}			outs() << sys::path::parent_path(ArchiveName);
				outs() << '/';
	// If we're supposed to retain the original modification times, etc. do so			}
	// now.			outs() << Name << "\n";
	if (OriginalDates) {			}
	auto ModTimeOrErr = C.getLastModified();
	failIfError(ModTimeOrErr.takeError());			// Implement the 'x' operation. This function extracts files back to the file
	failIfError(			// system.
	sys::fs::setLastAccessAndModificationTime(FD, ModTimeOrErr.get()));			static void doExtract(StringRef Name, const object::Archive::Child &C) {
	}			// Retain the original mode.
				Expected<sys::fs::perms> ModeOrErr = C.getAccessMode();
	if (close(FD))			failIfError(ModeOrErr.takeError());
	fail("Could not close the file");			sys::fs::perms Mode = ModeOrErr.get();
	}
				int FD;
	static bool shouldCreateArchive(ArchiveOperation Op) {			failIfError(sys::fs::openFileForWrite(sys::path::filename(Name), FD,
	switch (Op) {			sys::fs::CD_CreateAlways,
	case Print:			sys::fs::F_None, Mode),
	case Delete:			Name);
	case Move:
	case DisplayTable:			{
	case Extract:			raw_fd_ostream file(FD, false);
	case CreateSymTab:
	return false;			// Get the data and its length
				Expected<StringRef> BufOrErr = C.getBuffer();
	case QuickAppend:			failIfError(BufOrErr.takeError());
	case ReplaceOrInsert:			StringRef Data = BufOrErr.get();
	return true;
	}			// Write the data.
				file.write(Data.data(), Data.size());
	llvm_unreachable("Missing entry in covered switch.");			}
	}
				// If we're supposed to retain the original modification times, etc. do so
	static void performReadOperation(ArchiveOperation Operation,			// now.
	object::Archive *OldArchive) {			if (OriginalDates) {
	if (Operation == Extract && OldArchive->isThin())			auto ModTimeOrErr = C.getLastModified();
	fail("extracting from a thin archive is not supported");			failIfError(ModTimeOrErr.takeError());
				failIfError(
	bool Filter = !Members.empty();			sys::fs::setLastAccessAndModificationTime(FD, ModTimeOrErr.get()));
	{			}
	Error Err = Error::success();
	for (auto &C : OldArchive->children(Err)) {			if (close(FD))
	Expected<StringRef> NameOrErr = C.getName();			fail("Could not close the file");
	failIfError(NameOrErr.takeError());			}
	StringRef Name = NameOrErr.get();
				static bool shouldCreateArchive(ArchiveOperation Op) {
	if (Filter) {			switch (Op) {
	auto I = find(Members, Name);			case Print:
	if (I == Members.end())			case Delete:
	continue;			case Move:
	Members.erase(I);			case DisplayTable:
	}			case Extract:
				case CreateSymTab:
	switch (Operation) {			return false;
	default:
	llvm_unreachable("Not a read operation");			case QuickAppend:
	case Print:			case ReplaceOrInsert:
	doPrint(Name, C);			return true;
	break;			}
	case DisplayTable:
	doDisplayTable(Name, C);			llvm_unreachable("Missing entry in covered switch.");
	break;			}
	case Extract:
	doExtract(Name, C);			static void performReadOperation(ArchiveOperation Operation,
	break;			object::Archive *OldArchive) {
	}			if (Operation == Extract && OldArchive->isThin())
	}			fail("extracting from a thin archive is not supported");
	failIfError(std::move(Err));
	}			bool Filter = !Members.empty();
				{
	if (Members.empty())			Error Err = Error::success();
	return;			for (auto &C : OldArchive->children(Err)) {
	for (StringRef Name : Members)			Expected<StringRef> NameOrErr = C.getName();
	errs() << Name << " was not found\n";			failIfError(NameOrErr.takeError());
	exit(1);			StringRef Name = NameOrErr.get();
	}
				if (Filter) {
	static void addMember(std::vector<NewArchiveMember> &Members,			auto I = find(Members, Name);
	StringRef FileName, int Pos = -1) {			if (I == Members.end())
	Expected<NewArchiveMember> NMOrErr =			continue;
	NewArchiveMember::getFile(FileName, Deterministic);			Members.erase(I);
	failIfError(NMOrErr.takeError(), FileName);			}

	// Use the basename of the object path for the member name.			switch (Operation) {
	NMOrErr->MemberName = sys::path::filename(NMOrErr->MemberName);			default:
				llvm_unreachable("Not a read operation");
	if (Pos == -1)			case Print:
	Members.push_back(std::move(*NMOrErr));			doPrint(Name, C);
	else			break;
	Members[Pos] = std::move(*NMOrErr);			case DisplayTable:
	}			doDisplayTable(Name, C);
				break;
	static void addMember(std::vector<NewArchiveMember> &Members,			case Extract:
	const object::Archive::Child &M, int Pos = -1) {			doExtract(Name, C);
	if (Thin && !M.getParent()->isThin())			break;
	fail("Cannot convert a regular archive to a thin one");			}
	Expected<NewArchiveMember> NMOrErr =			}
	NewArchiveMember::getOldMember(M, Deterministic);			failIfError(std::move(Err));
	failIfError(NMOrErr.takeError());			}
	if (Pos == -1)
	Members.push_back(std::move(*NMOrErr));			if (Members.empty())
	else			return;
	Members[Pos] = std::move(*NMOrErr);			for (StringRef Name : Members)
	}			errs() << Name << " was not found\n";
				exit(1);
	static void addLibMember(std::vector<NewArchiveMember> &Members,			}
	StringRef FileName) {
	Expected<NewArchiveMember> NMOrErr =			static void addMember(std::vector<NewArchiveMember> &Members,
	NewArchiveMember::getFile(FileName, Deterministic);			StringRef FileName, int Pos = -1) {
	failIfError(NMOrErr.takeError(), FileName);			Expected<NewArchiveMember> NMOrErr =
	if (identify_magic(NMOrErr->Buf->getBuffer()) == file_magic::archive) {			NewArchiveMember::getFile(FileName, Deterministic);
	object::Archive &Lib = readLibrary(FileName);			failIfError(NMOrErr.takeError(), FileName);
	Error Err = Error::success();
				// Use the basename of the object path for the member name.
	for (auto &Child : Lib.children(Err))			NMOrErr->MemberName = sys::path::filename(NMOrErr->MemberName);
	addMember(Members, Child);
				if (Pos == -1)
	failIfError(std::move(Err));			Members.push_back(std::move(*NMOrErr));
	} else {			else
	// Use the basename of the object path for the member name.			Members[Pos] = std::move(*NMOrErr);
	NMOrErr->MemberName = sys::path::filename(NMOrErr->MemberName);			}
	Members.push_back(std::move(*NMOrErr));
	}			static void addMember(std::vector<NewArchiveMember> &Members,
	}			const object::Archive::Child &M, int Pos = -1) {
				if (Thin && !M.getParent()->isThin())
	enum InsertAction {			fail("Cannot convert a regular archive to a thin one");
	IA_AddOldMember,			Expected<NewArchiveMember> NMOrErr =
	IA_AddNewMember,			NewArchiveMember::getOldMember(M, Deterministic);
	IA_Delete,			failIfError(NMOrErr.takeError());
	IA_MoveOldMember,			if (Pos == -1)
	IA_MoveNewMember			Members.push_back(std::move(*NMOrErr));
	};			else
				Members[Pos] = std::move(*NMOrErr);
	static InsertAction computeInsertAction(ArchiveOperation Operation,			}
	const object::Archive::Child &Member,
	StringRef Name,			static void addLibMember(std::vector<NewArchiveMember> &Members,
	std::vector<StringRef>::iterator &Pos) {			StringRef FileName) {
	if (Operation == QuickAppend \|\| Members.empty())			Expected<NewArchiveMember> NMOrErr =
	return IA_AddOldMember;			NewArchiveMember::getFile(FileName, Deterministic);
				failIfError(NMOrErr.takeError(), FileName);
	auto MI = find_if(Members, [Name](StringRef Path) {			if (identify_magic(NMOrErr->Buf->getBuffer()) == file_magic::archive) {
	return Name == sys::path::filename(Path);			object::Archive &Lib = readLibrary(FileName);
	});			Error Err = Error::success();

	if (MI == Members.end())			for (auto &Child : Lib.children(Err))
	return IA_AddOldMember;			addMember(Members, Child);

	Pos = MI;			failIfError(std::move(Err));
				} else {
	if (Operation == Delete)			// Use the basename of the object path for the member name.
	return IA_Delete;			NMOrErr->MemberName = sys::path::filename(NMOrErr->MemberName);
				Members.push_back(std::move(*NMOrErr));
	if (Operation == Move)			}
	return IA_MoveOldMember;			}

	if (Operation == ReplaceOrInsert) {			enum InsertAction {
	StringRef PosName = sys::path::filename(RelPos);			IA_AddOldMember,
	if (!OnlyUpdate) {			IA_AddNewMember,
	if (PosName.empty())			IA_Delete,
	return IA_AddNewMember;			IA_MoveOldMember,
	return IA_MoveNewMember;			IA_MoveNewMember
	}			};

	// We could try to optimize this to a fstat, but it is not a common			static InsertAction computeInsertAction(ArchiveOperation Operation,
	// operation.			const object::Archive::Child &Member,
	sys::fs::file_status Status;			StringRef Name,
	failIfError(sys::fs::status(MI, Status), MI);			std::vector<StringRef>::iterator &Pos) {
	auto ModTimeOrErr = Member.getLastModified();			if (Operation == QuickAppend \|\| Members.empty())
	failIfError(ModTimeOrErr.takeError());			return IA_AddOldMember;
	if (Status.getLastModificationTime() < ModTimeOrErr.get()) {
	if (PosName.empty())			auto MI = find_if(Members, [Name](StringRef Path) {
	return IA_AddOldMember;			return Name == sys::path::filename(Path);
	return IA_MoveOldMember;			});
	}
				if (MI == Members.end())
	if (PosName.empty())			return IA_AddOldMember;
	return IA_AddNewMember;
	return IA_MoveNewMember;			Pos = MI;
	}
	llvm_unreachable("No such operation");			if (Operation == Delete)
	}			return IA_Delete;

	// We have to walk this twice and computing it is not trivial, so creating an			if (Operation == Move)
	// explicit std::vector is actually fairly efficient.			return IA_MoveOldMember;
	static std::vector<NewArchiveMember>
	computeNewArchiveMembers(ArchiveOperation Operation,			if (Operation == ReplaceOrInsert) {
	object::Archive *OldArchive) {			StringRef PosName = sys::path::filename(RelPos);
	std::vector<NewArchiveMember> Ret;			if (!OnlyUpdate) {
	std::vector<NewArchiveMember> Moved;			if (PosName.empty())
	int InsertPos = -1;			return IA_AddNewMember;
	StringRef PosName = sys::path::filename(RelPos);			return IA_MoveNewMember;
	if (OldArchive) {			}
	Error Err = Error::success();
	for (auto &Child : OldArchive->children(Err)) {			// We could try to optimize this to a fstat, but it is not a common
	int Pos = Ret.size();			// operation.
	Expected<StringRef> NameOrErr = Child.getName();			sys::fs::file_status Status;
	failIfError(NameOrErr.takeError());			failIfError(sys::fs::status(MI, Status), MI);
	StringRef Name = NameOrErr.get();			auto ModTimeOrErr = Member.getLastModified();
	if (Name == PosName) {			failIfError(ModTimeOrErr.takeError());
	assert(AddAfter \|\| AddBefore);			if (Status.getLastModificationTime() < ModTimeOrErr.get()) {
	if (AddBefore)			if (PosName.empty())
	InsertPos = Pos;			return IA_AddOldMember;
	else			return IA_MoveOldMember;
	InsertPos = Pos + 1;			}
	}
				if (PosName.empty())
	std::vector<StringRef>::iterator MemberI = Members.end();			return IA_AddNewMember;
	InsertAction Action =			return IA_MoveNewMember;
	computeInsertAction(Operation, Child, Name, MemberI);			}
	switch (Action) {			llvm_unreachable("No such operation");
	case IA_AddOldMember:			}
	addMember(Ret, Child);
	break;			// We have to walk this twice and computing it is not trivial, so creating an
	case IA_AddNewMember:			// explicit std::vector is actually fairly efficient.
	addMember(Ret, *MemberI);			static std::vector<NewArchiveMember>
	break;			computeNewArchiveMembers(ArchiveOperation Operation,
	case IA_Delete:			object::Archive *OldArchive) {
	break;			std::vector<NewArchiveMember> Ret;
	case IA_MoveOldMember:			std::vector<NewArchiveMember> Moved;
	addMember(Moved, Child);			int InsertPos = -1;
	break;			StringRef PosName = sys::path::filename(RelPos);
	case IA_MoveNewMember:			if (OldArchive) {
	addMember(Moved, *MemberI);			Error Err = Error::success();
	break;			for (auto &Child : OldArchive->children(Err)) {
	}			int Pos = Ret.size();
	if (MemberI != Members.end())			Expected<StringRef> NameOrErr = Child.getName();
	Members.erase(MemberI);			failIfError(NameOrErr.takeError());
	}			StringRef Name = NameOrErr.get();
	failIfError(std::move(Err));			if (Name == PosName) {
	}			assert(AddAfter \|\| AddBefore);
				if (AddBefore)
	if (Operation == Delete)			InsertPos = Pos;
	return Ret;			else
				InsertPos = Pos + 1;
	if (!RelPos.empty() && InsertPos == -1)			}
	fail("Insertion point not found");
				std::vector<StringRef>::iterator MemberI = Members.end();
	if (RelPos.empty())			InsertAction Action =
	InsertPos = Ret.size();			computeInsertAction(Operation, Child, Name, MemberI);
				switch (Action) {
	assert(unsigned(InsertPos) <= Ret.size());			case IA_AddOldMember:
	int Pos = InsertPos;			addMember(Ret, Child);
	for (auto &M : Moved) {			break;
	Ret.insert(Ret.begin() + Pos, std::move(M));			case IA_AddNewMember:
	++Pos;			addMember(Ret, *MemberI);
	}			break;
				case IA_Delete:
	if (AddLibrary) {			break;
	assert(Operation == QuickAppend);			case IA_MoveOldMember:
	for (auto &Member : Members)			addMember(Moved, Child);
	addLibMember(Ret, Member);			break;
	return Ret;			case IA_MoveNewMember:
	}			addMember(Moved, *MemberI);
				break;
	for (unsigned I = 0; I != Members.size(); ++I)			}
	Ret.insert(Ret.begin() + InsertPos, NewArchiveMember());			if (MemberI != Members.end())
	Pos = InsertPos;			Members.erase(MemberI);
	for (auto &Member : Members) {			}
	addMember(Ret, Member, Pos);			failIfError(std::move(Err));
	++Pos;			}
	}
				if (Operation == Delete)
	return Ret;			return Ret;
	}
				if (!RelPos.empty() && InsertPos == -1)
	static object::Archive::Kind getDefaultForHost() {			fail("Insertion point not found");
	return Triple(sys::getProcessTriple()).isOSDarwin()
	? object::Archive::K_DARWIN			if (RelPos.empty())
	: object::Archive::K_GNU;			InsertPos = Ret.size();
	}
				assert(unsigned(InsertPos) <= Ret.size());
	static object::Archive::Kind getKindFromMember(const NewArchiveMember &Member) {			int Pos = InsertPos;
	Expected<std::unique_ptr<object::ObjectFile>> OptionalObject =			for (auto &M : Moved) {
	object::ObjectFile::createObjectFile(Member.Buf->getMemBufferRef());			Ret.insert(Ret.begin() + Pos, std::move(M));
				++Pos;
	if (OptionalObject)			}
	return isa<object::MachOObjectFile>(**OptionalObject)
	? object::Archive::K_DARWIN			if (AddLibrary) {
	: object::Archive::K_GNU;			assert(Operation == QuickAppend);
				for (auto &Member : Members)
	// squelch the error in case we had a non-object file			addLibMember(Ret, Member);
	consumeError(OptionalObject.takeError());			return Ret;
	return getDefaultForHost();			}
	}
				for (unsigned I = 0; I != Members.size(); ++I)
	static void			Ret.insert(Ret.begin() + InsertPos, NewArchiveMember());
	performWriteOperation(ArchiveOperation Operation,			Pos = InsertPos;
	object::Archive *OldArchive,			for (auto &Member : Members) {
	std::unique_ptr<MemoryBuffer> OldArchiveBuf,			addMember(Ret, Member, Pos);
	std::vector<NewArchiveMember> *NewMembersP) {			++Pos;
	std::vector<NewArchiveMember> NewMembers;			}
	if (!NewMembersP)
	NewMembers = computeNewArchiveMembers(Operation, OldArchive);			return Ret;
				}
	object::Archive::Kind Kind;
	switch (FormatType) {			static object::Archive::Kind getDefaultForHost() {
	case Default:			return Triple(sys::getProcessTriple()).isOSDarwin()
	if (Thin)			? object::Archive::K_DARWIN
	Kind = object::Archive::K_GNU;			: object::Archive::K_GNU;
	else if (OldArchive)			}
	Kind = OldArchive->kind();
	else if (NewMembersP)			static object::Archive::Kind getKindFromMember(const NewArchiveMember &Member) {
	Kind = NewMembersP->size() ? getKindFromMember(NewMembersP->front())			Expected<std::unique_ptr<object::ObjectFile>> OptionalObject =
	: getDefaultForHost();			object::ObjectFile::createObjectFile(Member.Buf->getMemBufferRef());
	else
	Kind = NewMembers.size() ? getKindFromMember(NewMembers.front())			if (OptionalObject)
	: getDefaultForHost();			return isa<object::MachOObjectFile>(**OptionalObject)
	break;			? object::Archive::K_DARWIN
	case GNU:			: object::Archive::K_GNU;
	Kind = object::Archive::K_GNU;
	break;			// squelch the error in case we had a non-object file
	case BSD:			consumeError(OptionalObject.takeError());
	if (Thin)			return getDefaultForHost();
	fail("Only the gnu format has a thin mode");			}
	Kind = object::Archive::K_BSD;
	break;			static void performWriteOperation(ArchiveOperation Operation,
	case DARWIN:			object::Archive *OldArchive,
	if (Thin)			std::unique_ptr<MemoryBuffer> OldArchiveBuf,
	fail("Only the gnu format has a thin mode");			std::vector<NewArchiveMember> *NewMembersP) {
	Kind = object::Archive::K_DARWIN;			std::vector<NewArchiveMember> NewMembers;
	break;			if (!NewMembersP)
	case Unknown:			NewMembers = computeNewArchiveMembers(Operation, OldArchive);
	llvm_unreachable("");
	}			object::Archive::Kind Kind;
				switch (FormatType) {
	Error E =			case Default:
	writeArchive(ArchiveName, NewMembersP ? *NewMembersP : NewMembers, Symtab,			if (Thin)
	Kind, Deterministic, Thin, std::move(OldArchiveBuf));			Kind = object::Archive::K_GNU;
	failIfError(std::move(E), ArchiveName);			else if (OldArchive)
	}			Kind = OldArchive->kind();
				else if (NewMembersP)
	static void createSymbolTable(object::Archive *OldArchive) {			Kind = NewMembersP->size() ? getKindFromMember(NewMembersP->front())
	// When an archive is created or modified, if the s option is given, the			: getDefaultForHost();
	// resulting archive will have a current symbol table. If the S option			else
	// is given, it will have no symbol table.			Kind = NewMembers.size() ? getKindFromMember(NewMembers.front())
	// In summary, we only need to update the symbol table if we have none.			: getDefaultForHost();
	// This is actually very common because of broken build systems that think			break;
	// they have to run ranlib.			case GNU:
	if (OldArchive->hasSymbolTable())			Kind = object::Archive::K_GNU;
	return;			break;
				case BSD:
	performWriteOperation(CreateSymTab, OldArchive, nullptr, nullptr);			if (Thin)
	}			fail("Only the gnu format has a thin mode");
				Kind = object::Archive::K_BSD;
	static void performOperation(ArchiveOperation Operation,			break;
	object::Archive *OldArchive,			case DARWIN:
	std::unique_ptr<MemoryBuffer> OldArchiveBuf,			if (Thin)
	std::vector<NewArchiveMember> *NewMembers) {			fail("Only the gnu format has a thin mode");
	switch (Operation) {			Kind = object::Archive::K_DARWIN;
	case Print:			break;
	case DisplayTable:			case Unknown:
	case Extract:			llvm_unreachable("");
	performReadOperation(Operation, OldArchive);			}
	return;
				Error E =
	case Delete:			writeArchive(ArchiveName, NewMembersP ? *NewMembersP : NewMembers, Symtab,
	case Move:			Kind, Deterministic, Thin, std::move(OldArchiveBuf));
	case QuickAppend:			failIfError(std::move(E), ArchiveName);
	case ReplaceOrInsert:			}
	performWriteOperation(Operation, OldArchive, std::move(OldArchiveBuf),
	NewMembers);			static void createSymbolTable(object::Archive *OldArchive) {
	return;			// When an archive is created or modified, if the s option is given, the
	case CreateSymTab:			// resulting archive will have a current symbol table. If the S option
	createSymbolTable(OldArchive);			// is given, it will have no symbol table.
	return;			// In summary, we only need to update the symbol table if we have none.
	}			// This is actually very common because of broken build systems that think
	llvm_unreachable("Unknown operation.");			// they have to run ranlib.
	}			if (OldArchive->hasSymbolTable())
				return;
	static int performOperation(ArchiveOperation Operation,
	std::vector<NewArchiveMember> *NewMembers) {			performWriteOperation(CreateSymTab, OldArchive, nullptr, nullptr);
	// Create or open the archive object.			}
	ErrorOr<std::unique_ptr<MemoryBuffer>> Buf =
	MemoryBuffer::getFile(ArchiveName, -1, false);			static void performOperation(ArchiveOperation Operation,
	std::error_code EC = Buf.getError();			object::Archive *OldArchive,
	if (EC && EC != errc::no_such_file_or_directory)			std::unique_ptr<MemoryBuffer> OldArchiveBuf,
	fail("error opening '" + ArchiveName + "': " + EC.message() + "!");			std::vector<NewArchiveMember> *NewMembers) {
				switch (Operation) {
	if (!EC) {			case Print:
	Error Err = Error::success();			case DisplayTable:
	object::Archive Archive(Buf.get()->getMemBufferRef(), Err);			case Extract:
	EC = errorToErrorCode(std::move(Err));			performReadOperation(Operation, OldArchive);
	failIfError(EC,			return;
	"error loading '" + ArchiveName + "': " + EC.message() + "!");
	performOperation(Operation, &Archive, std::move(Buf.get()), NewMembers);			case Delete:
	return 0;			case Move:
	}			case QuickAppend:
				case ReplaceOrInsert:
	assert(EC == errc::no_such_file_or_directory);			performWriteOperation(Operation, OldArchive, std::move(OldArchiveBuf),
				NewMembers);
	if (!shouldCreateArchive(Operation)) {			return;
	failIfError(EC, Twine("error loading '") + ArchiveName + "'");			case CreateSymTab:
	} else {			createSymbolTable(OldArchive);
	if (!Create) {			return;
	// Produce a warning if we should and we're creating the archive			}
	errs() << ToolName << ": creating " << ArchiveName << "\n";			llvm_unreachable("Unknown operation.");
	}			}
	}
				static int performOperation(ArchiveOperation Operation,
	performOperation(Operation, nullptr, nullptr, NewMembers);			std::vector<NewArchiveMember> *NewMembers) {
	return 0;			// Create or open the archive object.
	}			ErrorOr<std::unique_ptr<MemoryBuffer>> Buf =
				MemoryBuffer::getFile(ArchiveName, -1, false);
	static void runMRIScript() {			std::error_code EC = Buf.getError();
	enum class MRICommand { AddLib, AddMod, Create, Delete, Save, End, Invalid };			if (EC && EC != errc::no_such_file_or_directory)
				fail("error opening '" + ArchiveName + "': " + EC.message() + "!");
	ErrorOr<std::unique_ptr<MemoryBuffer>> Buf = MemoryBuffer::getSTDIN();
	failIfError(Buf.getError());			if (!EC) {
	const MemoryBuffer &Ref = *Buf.get();			Error Err = Error::success();
	bool Saved = false;			object::Archive Archive(Buf.get()->getMemBufferRef(), Err);
	std::vector<NewArchiveMember> NewMembers;			EC = errorToErrorCode(std::move(Err));
				failIfError(EC,
	for (line_iterator I(Ref, /SkipBlanks/ false), E; I != E; ++I) {			"error loading '" + ArchiveName + "': " + EC.message() + "!");
	StringRef Line = *I;			performOperation(Operation, &Archive, std::move(Buf.get()), NewMembers);
	Line = Line.split(';').first;			return 0;
	Line = Line.split('*').first;			}
	Line = Line.trim();
	if (Line.empty())			assert(EC == errc::no_such_file_or_directory);
	continue;
	StringRef CommandStr, Rest;			if (!shouldCreateArchive(Operation)) {
	std::tie(CommandStr, Rest) = Line.split(' ');			failIfError(EC, Twine("error loading '") + ArchiveName + "'");
	Rest = Rest.trim();			} else {
	if (!Rest.empty() && Rest.front() == '"' && Rest.back() == '"')			if (!Create) {
	Rest = Rest.drop_front().drop_back();			// Produce a warning if we should and we're creating the archive
	auto Command = StringSwitch<MRICommand>(CommandStr.lower())			errs() << ToolName << ": creating " << ArchiveName << "\n";
	.Case("addlib", MRICommand::AddLib)			}
	.Case("addmod", MRICommand::AddMod)			}
	.Case("create", MRICommand::Create)
	.Case("delete", MRICommand::Delete)			performOperation(Operation, nullptr, nullptr, NewMembers);
	.Case("save", MRICommand::Save)			return 0;
	.Case("end", MRICommand::End)			}
	.Default(MRICommand::Invalid);
				static void runMRIScript() {
	switch (Command) {			enum class MRICommand { AddLib, AddMod, Create, Delete, Save, End, Invalid };
	case MRICommand::AddLib: {
	object::Archive &Lib = readLibrary(Rest);			ErrorOr<std::unique_ptr<MemoryBuffer>> Buf = MemoryBuffer::getSTDIN();
	{			failIfError(Buf.getError());
	Error Err = Error::success();			const MemoryBuffer &Ref = *Buf.get();
	for (auto &Member : Lib.children(Err))			bool Saved = false;
	addMember(NewMembers, Member);			std::vector<NewArchiveMember> NewMembers;
	failIfError(std::move(Err));
	}			for (line_iterator I(Ref, /SkipBlanks/ false), E; I != E; ++I) {
	break;			StringRef Line = *I;
	}			Line = Line.split(';').first;
	case MRICommand::AddMod:			Line = Line.split('*').first;
	addMember(NewMembers, Rest);			Line = Line.trim();
	break;			if (Line.empty())
	case MRICommand::Create:			continue;
	Create = true;			StringRef CommandStr, Rest;
	if (!ArchiveName.empty())			std::tie(CommandStr, Rest) = Line.split(' ');
	fail("Editing multiple archives not supported");			Rest = Rest.trim();
	if (Saved)			if (!Rest.empty() && Rest.front() == '"' && Rest.back() == '"')
	fail("File already saved");			Rest = Rest.drop_front().drop_back();
	ArchiveName = Rest;			auto Command = StringSwitch<MRICommand>(CommandStr.lower())
	break;			.Case("addlib", MRICommand::AddLib)
	case MRICommand::Delete: {			.Case("addmod", MRICommand::AddMod)
	StringRef Name = sys::path::filename(Rest);			.Case("create", MRICommand::Create)
	llvm::erase_if(NewMembers,			.Case("delete", MRICommand::Delete)
	[=](NewArchiveMember &M) { return M.MemberName == Name; });			.Case("save", MRICommand::Save)
	break;			.Case("end", MRICommand::End)
	}			.Default(MRICommand::Invalid);
	case MRICommand::Save:
	Saved = true;			switch (Command) {
	break;			case MRICommand::AddLib: {
	case MRICommand::End:			object::Archive &Lib = readLibrary(Rest);
	break;			{
	case MRICommand::Invalid:			Error Err = Error::success();
	fail("Unknown command: " + CommandStr);			for (auto &Member : Lib.children(Err))
	}			addMember(NewMembers, Member);
	}			failIfError(std::move(Err));
				}
	// Nothing to do if not saved.			break;
	if (Saved)			}
	performOperation(ReplaceOrInsert, &NewMembers);			case MRICommand::AddMod:
	exit(0);			addMember(NewMembers, Rest);
	}			break;
				case MRICommand::Create:
	static bool handleGenericOption(StringRef arg) {			Create = true;
	if (arg == "-help" \|\| arg == "--help") {			if (!ArchiveName.empty())
	printHelpMessage();			fail("Editing multiple archives not supported");
	return true;			if (Saved)
	}			fail("File already saved");
	if (arg == "-version" \|\| arg == "--version") {			ArchiveName = Rest;
	cl::PrintVersionMessage();			break;
	return true;			case MRICommand::Delete: {
	}			StringRef Name = sys::path::filename(Rest);
	return false;			llvm::erase_if(NewMembers,
	}			[=](NewArchiveMember &M) { return M.MemberName == Name; });
				break;
	static int ar_main(int argc, char **argv) {			}
	SmallVector<const char *, 0> Argv(argv, argv + argc);			case MRICommand::Save:
	BumpPtrAllocator Alloc;			Saved = true;
	StringSaver Saver(Alloc);			break;
	cl::ExpandResponseFiles(Saver, cl::TokenizeGNUCommandLine, Argv);			case MRICommand::End:
	for(size_t i = 1; i < Argv.size(); ++i) {			break;
	StringRef Arg = Argv[i];			case MRICommand::Invalid:
	const char *match;			fail("Unknown command: " + CommandStr);
	auto MatchFlagWithArg = [&](const char *expected) {			}
	size_t len = strlen(expected);			}
	if (Arg == expected) {
	if (++i >= Argv.size())			// Nothing to do if not saved.
	fail(std::string(expected) + " requires an argument");			if (Saved)
	match = Argv[i];			performOperation(ReplaceOrInsert, &NewMembers);
	return true;			exit(0);
	}			}
	if (Arg.startswith(expected) && Arg.size() > len &&
	Arg[len] == '=') {			static bool handleGenericOption(StringRef arg) {
	match = Arg.data() + len + 1;			if (arg == "-help" \|\| arg == "--help") {
	return true;			printHelpMessage();
	}			return true;
	return false;			}
	};			if (arg == "-version" \|\| arg == "--version") {
	if (handleGenericOption(Argv[i]))			cl::PrintVersionMessage();
	return 0;			return true;
	if (Arg == "--") {			}
	for(; i < Argv.size(); ++i)			return false;
	PositionalArgs.push_back(Argv[i]);			}
	break;
	}			static int ar_main(int argc, char **argv) {
	if (Arg[0] == '-') {			SmallVector<const char *, 0> Argv(argv, argv + argc);
	if (Arg.startswith("--"))			BumpPtrAllocator Alloc;
	Arg = Argv[i] + 2;			StringSaver Saver(Alloc);
	else			cl::ExpandResponseFiles(Saver, cl::TokenizeGNUCommandLine, Argv);
	Arg = Argv[i] + 1;			for (size_t i = 1; i < Argv.size(); ++i) {
	if (Arg == "M") {			StringRef Arg = Argv[i];
	MRI = true;			const char *match;
	} else if (MatchFlagWithArg("format")) {			auto MatchFlagWithArg = [&](const char *expected) {
	FormatType = StringSwitch<Format>(match)			size_t len = strlen(expected);
	.Case("default", Default)			if (Arg == expected) {
	.Case("gnu", GNU)			if (++i >= Argv.size())
	.Case("darwin", DARWIN)			fail(std::string(expected) + " requires an argument");
	.Case("bsd", BSD)			match = Argv[i];
	.Default(Unknown);			return true;
	if (FormatType == Unknown)			}
	fail(std::string("Invalid format ") + match);			if (Arg.startswith(expected) && Arg.size() > len && Arg[len] == '=') {
	} else if (MatchFlagWithArg("plugin")) {			match = Arg.data() + len + 1;
	// Ignored.			return true;
	} else {			}
	Options += Argv[i] + 1;			return false;
	}			};
	} else if (Options.empty()) {			if (handleGenericOption(Argv[i]))
	Options += Argv[i];			return 0;
	} else {			if (Arg == "--") {
	PositionalArgs.push_back(Argv[i]);			for (; i < Argv.size(); ++i)
	}			PositionalArgs.push_back(Argv[i]);
	}			break;
	ArchiveOperation Operation = parseCommandLine();			}
	return performOperation(Operation, nullptr);			if (Arg[0] == '-') {
	}			if (Arg.startswith("--"))
				Arg = Argv[i] + 2;
	static int ranlib_main(int argc, char **argv) {			else
	bool ArchiveSpecified = false;			Arg = Argv[i] + 1;
	for(int i = 1; i < argc; ++i) {			if (Arg == "M") {
	if (handleGenericOption(argv[i])) {			MRI = true;
	return 0;			} else if (MatchFlagWithArg("format")) {
	} else {			FormatType = StringSwitch<Format>(match)
	if (ArchiveSpecified)			.Case("default", Default)
	fail("Exactly one archive should be specified");			.Case("gnu", GNU)
	ArchiveSpecified = true;			.Case("darwin", DARWIN)
	ArchiveName = argv[i];			.Case("bsd", BSD)
	}			.Default(Unknown);
	}			if (FormatType == Unknown)
	return performOperation(CreateSymTab, nullptr);			fail(std::string("Invalid format ") + match);
	}			} else if (MatchFlagWithArg("plugin")) {
				// Ignored.
	int main(int argc, char **argv) {			} else {
	InitLLVM X(argc, argv);			Options += Argv[i] + 1;
	ToolName = argv[0];			}
				} else if (Options.empty()) {
	llvm::InitializeAllTargetInfos();			Options += Argv[i];
	llvm::InitializeAllTargetMCs();			} else {
	llvm::InitializeAllAsmParsers();			PositionalArgs.push_back(Argv[i]);
				}
	Stem = sys::path::stem(ToolName);			}
	if (Stem.contains_lower("dlltool"))			ArchiveOperation Operation = parseCommandLine();
	return dlltoolDriverMain(makeArrayRef(argv, argc));			return performOperation(Operation, nullptr);
				}
	if (Stem.contains_lower("ranlib"))
	return ranlib_main(argc, argv);			static int ranlib_main(int argc, char **argv) {
				bool ArchiveSpecified = false;
	if (Stem.contains_lower("lib"))			for (int i = 1; i < argc; ++i) {
	return libDriverMain(makeArrayRef(argv, argc));			if (handleGenericOption(argv[i])) {
				return 0;
	if (Stem.contains_lower("ar"))			} else {
	return ar_main(argc, argv);			if (ArchiveSpecified)
	fail("Not ranlib, ar, lib or dlltool!");			fail("Exactly one archive should be specified");
	}			ArchiveSpecified = true;
				ArchiveName = argv[i];
				}
				}
				return performOperation(CreateSymTab, nullptr);
				}

				int main(int argc, char **argv) {
				InitLLVM X(argc, argv);
				ToolName = argv[0];

				llvm::InitializeAllTargetInfos();
				llvm::InitializeAllTargetMCs();
				llvm::InitializeAllAsmParsers();

				Stem = sys::path::stem(ToolName);
				if (Stem.contains_lower("dlltool"))
				return dlltoolDriverMain(makeArrayRef(argv, argc));

				if (Stem.contains_lower("ranlib"))
				return ranlib_main(argc, argv);

				if (Stem.contains_lower("lib"))
				return libDriverMain(makeArrayRef(argv, argc));

				if (Stem.contains_lower("ar"))
				return ar_main(argc, argv);
				fail("Not ranlib, ar, lib or dlltool!");
				}