X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=tools%2Fllvm-ar%2Fllvm-ar.cpp;h=6578bfc04c48aff00b8d07d164908f8e3d8a5f36;hb=71857ccdb83b6374f7a791c2dae45ce9934a85af;hp=2ec431727a6bf29d821a952d4a49a3408aaf94cd;hpb=252ad03d7db0add504fdcc6bd67c1bc1e28bdd57;p=oota-llvm.git diff --git a/tools/llvm-ar/llvm-ar.cpp b/tools/llvm-ar/llvm-ar.cpp index 2ec431727a6..6578bfc04c4 100644 --- a/tools/llvm-ar/llvm-ar.cpp +++ b/tools/llvm-ar/llvm-ar.cpp @@ -2,29 +2,40 @@ // // The LLVM Compiler Infrastructure // -// This file was developed by the LLVM research group and is distributed under -// the University of Illinois Open Source License. See LICENSE.TXT for details. +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // Builds up (relatively) standard unix archive files (.a) containing LLVM -// bytecode or other files. +// bitcode or other files. // //===----------------------------------------------------------------------===// -#include "llvm/Module.h" -#include "llvm/Bytecode/Archive.h" +#include "Archive.h" +#include "llvm/IR/LLVMContext.h" +#include "llvm/IR/Module.h" #include "llvm/Support/CommandLine.h" -#include "llvm/Support/Compressor.h" -#include "llvm/System/Signals.h" -#include +#include "llvm/Support/FileSystem.h" +#include "llvm/Support/Format.h" +#include "llvm/Support/ManagedStatic.h" +#include "llvm/Support/PrettyStackTrace.h" +#include "llvm/Support/Signals.h" +#include "llvm/Support/raw_ostream.h" #include -#include +#include +#include #include +#if !defined(_MSC_VER) && !defined(__MINGW32__) +#include +#else +#include +#endif + using namespace llvm; -// Option for compatibility with ASIX, not used but must allow it to be present. +// Option for compatibility with AIX, not used but must allow it to be present. static cl::opt X32Option ("X32_64", cl::Hidden, cl::desc("Ignored option for compatibility with AIX")); @@ -47,33 +58,26 @@ static cl::extrahelp MoreHelp( " m[abiSs] - move file(s) in the archive\n" " p[kN] - print file(s) found in the archive\n" " q[ufsS] - quick append file(s) to the archive\n" - " r[abfiuzRsS] - replace or insert file(s) into the archive\n" + " r[abfiuRsS] - replace or insert file(s) into the archive\n" " t - display contents of archive\n" " x[No] - extract file(s) from the archive\n" "\nMODIFIERS (operation specific):\n" " [a] - put file(s) after [relpos]\n" " [b] - put file(s) before [relpos] (same as [i])\n" - " [f] - truncate inserted file names\n" " [i] - put file(s) before [relpos] (same as [b])\n" - " [k] - always print bytecode files (default is to skip them)\n" " [N] - use instance [count] of name\n" " [o] - preserve original dates\n" - " [P] - use full path names when matching\n" - " [R] - recurse through directories when inserting\n" " [s] - create an archive index (cf. ranlib)\n" " [S] - do not build a symbol table\n" " [u] - update only files newer than archive contents\n" - " [z] - compress files before inserting/extracting\n" "\nMODIFIERS (generic):\n" " [c] - do not warn if the library had to be created\n" " [v] - be verbose about actions taken\n" - " [V] - be *really* verbose about actions taken\n" ); // This enumeration delineates the kinds of operations on an archive // that are permitted. enum ArchiveOperation { - NoOperation, ///< An operation hasn't been specified Print, ///< Print the contents of the archive Delete, ///< Delete the specified members Move, ///< Move members to end or as given by {a,b,i} modifiers @@ -87,18 +91,11 @@ enum ArchiveOperation { bool AddAfter = false; ///< 'a' modifier bool AddBefore = false; ///< 'b' modifier bool Create = false; ///< 'c' modifier -bool TruncateNames = false; ///< 'f' modifier bool InsertBefore = false; ///< 'i' modifier -bool DontSkipBytecode = false; ///< 'k' modifier -bool UseCount = false; ///< 'N' modifier bool OriginalDates = false; ///< 'o' modifier -bool FullPath = false; ///< 'P' modifier -bool RecurseDirectories = false; ///< 'R' modifier bool SymTable = true; ///< 's' & 'S' modifiers bool OnlyUpdate = false; ///< 'u' modifier bool Verbose = false; ///< 'v' modifier -bool ReallyVerbose = false; ///< 'V' modifier -bool Compression = false; ///< 'z' modifier // Relative Positional Argument (for insert/move). This variable holds // the name of the archive member to which the 'a', 'b' or 'i' modifier @@ -106,10 +103,6 @@ bool Compression = false; ///< 'z' modifier // one variable. std::string RelPos; -// Select which of multiple entries in the archive with the same name should be -// used (specified with -N) for the delete and extract operations. -int Count = 1; - // This variable holds the name of the archive file as given on the // command line. std::string ArchiveName; @@ -120,45 +113,48 @@ std::vector Members; // This variable holds the (possibly expanded) list of path objects that // correspond to files we will -std::set Paths; +std::set Paths; // The Archive object to which all the editing operations will be sent. Archive* TheArchive = 0; -// getRelPos - Extract the member filename from the command line for -// the [relpos] argument associated with a, b, and i modifiers -void getRelPos() { - if(RestOfArgs.size() > 0) { - RelPos = RestOfArgs[0]; - RestOfArgs.erase(RestOfArgs.begin()); - } - else - throw "Expected [relpos] for a, b, or i modifier"; +// The name this program was invoked as. +static const char *program_name; + +// show_help - Show the error message, the help message and exit. +LLVM_ATTRIBUTE_NORETURN static void +show_help(const std::string &msg) { + errs() << program_name << ": " << msg << "\n\n"; + cl::PrintHelpMessage(); + if (TheArchive) + delete TheArchive; + std::exit(1); } -// getCount - Extract the [count] argument associated with the N modifier -// from the command line and check its value. -void getCount() { - if(RestOfArgs.size() > 0) { - Count = atoi(RestOfArgs[0].c_str()); - RestOfArgs.erase(RestOfArgs.begin()); - } - else - throw "Expected [count] value with N modifier"; +// fail - Show the error message and exit. +LLVM_ATTRIBUTE_NORETURN static void +fail(const std::string &msg) { + errs() << program_name << ": " << msg << "\n\n"; + if (TheArchive) + delete TheArchive; + std::exit(1); +} - // Non-positive counts are not allowed - if (Count < 1) - throw "Invalid [count] value (not a positive integer)"; +// getRelPos - Extract the member filename from the command line for +// the [relpos] argument associated with a, b, and i modifiers +void getRelPos() { + if(RestOfArgs.size() == 0) + show_help("Expected [relpos] for a, b, or i modifier"); + RelPos = RestOfArgs[0]; + RestOfArgs.erase(RestOfArgs.begin()); } // getArchive - Get the archive file name from the command line void getArchive() { - if(RestOfArgs.size() > 0) { - ArchiveName = RestOfArgs[0]; - RestOfArgs.erase(RestOfArgs.begin()); - } - else - throw "An archive name must be specified."; + if(RestOfArgs.size() == 0) + show_help("An archive name must be specified"); + ArchiveName = RestOfArgs[0]; + RestOfArgs.erase(RestOfArgs.begin()); } // getMembers - Copy over remaining items in RestOfArgs to our Members vector @@ -182,29 +178,24 @@ ArchiveOperation parseCommandLine() { unsigned NumPositional = 0; // Keep track of which operation was requested - ArchiveOperation Operation = NoOperation; + ArchiveOperation Operation; for(unsigned i=0; i 1) - throw "Only one operation may be specified"; + show_help("Only one operation may be specified"); if (NumPositional > 1) - throw "You may only specify one of a, b, and i modifiers"; - if (AddAfter || AddBefore || InsertBefore) + show_help("You may only specify one of a, b, and i modifiers"); + if (AddAfter || AddBefore || InsertBefore) { if (Operation != Move && Operation != ReplaceOrInsert) - throw "The 'a', 'b' and 'i' modifiers can only be specified with " - "the 'm' or 'r' operations"; - if (RecurseDirectories && Operation != ReplaceOrInsert) - throw "The 'R' modifiers is only applicabe to the 'r' operation"; + show_help("The 'a', 'b' and 'i' modifiers can only be specified with " + "the 'm' or 'r' operations"); + } if (OriginalDates && Operation != Extract) - throw "The 'o' modifier is only applicable to the 'x' operation"; - if (TruncateNames && Operation!=QuickAppend && Operation!=ReplaceOrInsert) - throw "The 'f' modifier is only applicable to the 'q' and 'r' operations"; + show_help("The 'o' modifier is only applicable to the 'x' operation"); if (OnlyUpdate && Operation != ReplaceOrInsert) - throw "The 'u' modifier is only applicable to the 'r' operation"; - if (Compression && Operation!=ReplaceOrInsert && Operation!=Extract) - throw "The 'z' modifier is only applicable to the 'r' and 'x' operations"; - if (Count > 1 && Members.size() > 1) - throw "Only one member name may be specified with the 'N' modifier"; + show_help("The 'u' modifier is only applicable to the 'r' operation"); // Return the parsed operation to the caller return Operation; } -// recurseDirectories - Implements the "R" modifier. This function scans through -// the Paths vector (built by buildPaths, below) and replaces any directories it -// finds with all the files in that directory (recursively). It uses the -// sys::Path::getDirectoryContent method to perform the actual directory scans. -std::set recurseDirectories(const sys::Path& path) { - assert(path.isDirectory() && "Oops, can't recurse a file"); - std::set result; - if (RecurseDirectories) { - std::set content; - path.getDirectoryContents(content); - for (std::set::iterator I = content.begin(), E = content.end(); - I != E; ++I) { - if (I->isDirectory()) { - std::set moreResults = recurseDirectories(*I); - result.insert(moreResults.begin(), moreResults.end()); - } else { - result.insert(*I); - } - } - } - return result; -} - // buildPaths - Convert the strings in the Members vector to sys::Path objects // and make sure they are valid and exist exist. This check is only needed for // the operations that add/replace files to the archive ('q' and 'r') -void buildPaths(bool checkExistence = true) { +bool buildPaths(bool checkExistence, std::string* ErrMsg) { for (unsigned i = 0; i < Members.size(); i++) { - sys::Path aPath; - if (!aPath.set(Members[i])) - throw std::string("File member name invalid: ") + Members[i]; + std::string aPath = Members[i]; if (checkExistence) { - if (!aPath.exists()) - throw std::string("File does not exist: ") + Members[i]; - sys::FileStatus si; - std::string Err; - if (aPath.getFileStatus(si, &Err)) - throw Err; - if (si.isDir) { - std::set dirpaths = recurseDirectories(aPath); - Paths.insert(dirpaths.begin(),dirpaths.end()); - } else { - Paths.insert(aPath); - } + bool IsDirectory; + error_code EC = sys::fs::is_directory(aPath, IsDirectory); + if (EC) + fail(aPath + ": " + EC.message()); + if (IsDirectory) + fail(aPath + " Is a directory"); + + Paths.insert(aPath); } else { Paths.insert(aPath); } } -} - -// printSymbolTable - print out the archive's symbol table. -void printSymbolTable() { - std::cout << "\nArchive Symbol Table:\n"; - const Archive::SymTabType& symtab = TheArchive->getSymbolTable(); - for (Archive::SymTabType::const_iterator I=symtab.begin(), E=symtab.end(); - I != E; ++I ) { - unsigned offset = TheArchive->getFirstFileOffset() + I->second; - std::cout << " " << std::setw(9) << offset << "\t" << I->first <<"\n"; - } + return false; } // doPrint - Implements the 'p' operation. This function traverses the archive // looking for members that match the path list. It is careful to uncompress -// things that should be and to skip bytecode files unless the 'k' modifier was +// things that should be and to skip bitcode files unless the 'k' modifier was // given. -void doPrint() { - buildPaths(false); - unsigned countDown = Count; +bool doPrint(std::string* ErrMsg) { + if (buildPaths(false, ErrMsg)) + return true; for (Archive::iterator I = TheArchive->begin(), E = TheArchive->end(); I != E; ++I ) { if (Paths.empty() || (std::find(Paths.begin(), Paths.end(), I->getPath()) != Paths.end())) { - if (countDown == 1) { - const char* data = reinterpret_cast(I->getData()); + const char *data = reinterpret_cast(I->getData()); - // Skip things that don't make sense to print - if (I->isLLVMSymbolTable() || I->isSVR4SymbolTable() || - I->isBSD4SymbolTable() || (!DontSkipBytecode && - (I->isBytecode() || I->isCompressedBytecode()))) - continue; + // Skip things that don't make sense to print + if (I->isSVR4SymbolTable() || I->isBSD4SymbolTable()) + continue; - if (Verbose) - std::cout << "Printing " << I->getPath().toString() << "\n"; + if (Verbose) + outs() << "Printing " << I->getPath().str() << "\n"; - if (I->isCompressedBytecode()) - Compressor::decompressToStream(data+4,I->getSize()-4,std::cout); - else if (I->isCompressed()) { - Compressor::decompressToStream(data,I->getSize(),std::cout); - } else { - unsigned len = I->getSize(); - std::cout.write(data, len); - } - } else { - countDown--; - } + unsigned len = I->getSize(); + outs().write(data, len); } } + return false; } // putMode - utility function for printing out the file mode when the 't' // operation is in verbose mode. -void printMode(unsigned mode) { +void +printMode(unsigned mode) { if (mode & 004) - std::cout << "r"; + outs() << "r"; else - std::cout << "-"; + outs() << "-"; if (mode & 002) - std::cout << "w"; + outs() << "w"; else - std::cout << "-"; + outs() << "-"; if (mode & 001) - std::cout << "x"; + outs() << "x"; else - std::cout << "-"; + outs() << "-"; } // doDisplayTable - Implement the 't' operation. This function prints out just // the file names of each of the members. However, if verbose mode is requested // ('v' modifier) then the file type, permission mode, user, group, size, and // modification time are also printed. -void doDisplayTable() { - buildPaths(false); +bool +doDisplayTable(std::string* ErrMsg) { + if (buildPaths(false, ErrMsg)) + return true; for (Archive::iterator I = TheArchive->begin(), E = TheArchive->end(); I != E; ++I ) { if (Paths.empty() || (std::find(Paths.begin(), Paths.end(), I->getPath()) != Paths.end())) { if (Verbose) { - // FIXME: Output should be this format: - // Zrw-r--r-- 500/ 500 525 Nov 8 17:42 2004 Makefile - if (I->isBytecode()) - std::cout << "b"; - else if (I->isCompressedBytecode()) - std::cout << "B"; - else if (I->isCompressed()) - std::cout << "Z"; - else - std::cout << " "; unsigned mode = I->getMode(); printMode((mode >> 6) & 007); printMode((mode >> 3) & 007); printMode(mode & 007); - std::cout << " " << std::setw(4) << I->getUser(); - std::cout << "/" << std::setw(4) << I->getGroup(); - std::cout << " " << std::setw(8) << I->getSize(); - std::cout << " " << std::setw(20) << - I->getModTime().toString().substr(4); - std::cout << " " << I->getPath().toString() << "\n"; + outs() << ' ' << I->getUser(); + outs() << "/" << I->getGroup(); + outs() << ' ' << format("%6u", I->getSize()); + sys::TimeValue ModTime = I->getModTime(); + outs() << " " << ModTime.str(); + outs() << " " << I->getPath().str() << "\n"; } else { - std::cout << I->getPath().toString() << "\n"; + outs() << I->getPath().str() << "\n"; } } } - if (ReallyVerbose) - printSymbolTable(); + return false; } // doExtract - Implement the 'x' operation. This function extracts files back to -// the file system, making sure to uncompress any that were compressed. -void doExtract() { - buildPaths(false); - unsigned countDown = Count; +// the file system. +bool +doExtract(std::string* ErrMsg) { + if (buildPaths(false, ErrMsg)) + return true; for (Archive::iterator I = TheArchive->begin(), E = TheArchive->end(); I != E; ++I ) { if (Paths.empty() || (std::find(Paths.begin(), Paths.end(), I->getPath()) != Paths.end())) { - // Make sure the intervening directories are created - if (I->hasPath()) { - sys::Path dirs(I->getPath()); - dirs.eraseComponent(); - dirs.createDirectoryOnDisk(/*create_parents=*/true); - } - // Open up a file stream for writing - std::ios::openmode io_mode = std::ios::out | std::ios::trunc | - std::ios::binary; - std::ofstream file(I->getPath().c_str(), io_mode); + int OpenFlags = O_TRUNC | O_WRONLY | O_CREAT; +#ifdef O_BINARY + OpenFlags |= O_BINARY; +#endif - // Get the data and its length - const char* data = reinterpret_cast(I->getData()); - unsigned len = I->getSize(); + // Retain the original mode. + sys::fs::perms Mode = sys::fs::perms(I->getMode()); - // Write the data, making sure to uncompress things first - if (I->isCompressed()) { - Compressor::decompressToStream(data,len,file); - } else { - file.write(data,len); + int FD = open(I->getPath().str().c_str(), OpenFlags, Mode); + if (FD < 0) + return true; + + { + raw_fd_ostream file(FD, false); + + // Get the data and its length + const char* data = reinterpret_cast(I->getData()); + unsigned len = I->getSize(); + + // Write the data. + file.write(data, len); } - file.close(); // If we're supposed to retain the original modification times, etc. do so // now. - if (OriginalDates) - I->getPath().setStatusInfoOnDisk(I->getFileStatus()); + if (OriginalDates) { + error_code EC = + sys::fs::setLastModificationAndAccessTime(FD, I->getModTime()); + if (EC) + fail(EC.message()); + } + if (close(FD)) + return true; } } + return false; } // doDelete - Implement the delete operation. This function deletes zero or more // members from the archive. Note that if the count is specified, there should // be no more than one path in the Paths list or else this algorithm breaks. // That check is enforced in parseCommandLine (above). -void doDelete() { - buildPaths(false); - if (Paths.empty()) return; - unsigned countDown = Count; +bool +doDelete(std::string* ErrMsg) { + if (buildPaths(false, ErrMsg)) + return true; + if (Paths.empty()) + return false; for (Archive::iterator I = TheArchive->begin(), E = TheArchive->end(); I != E; ) { if (std::find(Paths.begin(), Paths.end(), I->getPath()) != Paths.end()) { - if (countDown == 1) { - Archive::iterator J = I; - ++I; - TheArchive->erase(J); - } else - countDown--; + Archive::iterator J = I; + ++I; + TheArchive->erase(J); } else { ++I; } } // We're done editting, reconstruct the archive. - std::string errmsg; - if (!TheArchive->writeToDisk(SymTable,TruncateNames,Compression,&errmsg)) - throw errmsg; - if (ReallyVerbose) - printSymbolTable(); + if (TheArchive->writeToDisk(ErrMsg)) + return true; + return false; } // doMore - Implement the move operation. This function re-arranges just the // order of the archive members so that when the archive is written the move // of the members is accomplished. Note the use of the RelPos variable to // determine where the items should be moved to. -void doMove() { - - buildPaths(false); +bool +doMove(std::string* ErrMsg) { + if (buildPaths(false, ErrMsg)) + return true; // By default and convention the place to move members to is the end of the // archive. @@ -511,7 +439,7 @@ void doMove() { if (AddBefore || InsertBefore || AddAfter) { for (Archive::iterator I = TheArchive->begin(), E= TheArchive->end(); I != E; ++I ) { - if (RelPos == I->getPath().toString()) { + if (RelPos == I->getPath().str()) { if (AddAfter) { moveto_spot = I; moveto_spot++; @@ -524,14 +452,14 @@ void doMove() { } // Keep a list of the paths remaining to be moved - std::set remaining(Paths); + std::set remaining(Paths); // Scan the archive again, this time looking for the members to move to the // moveto_spot. for (Archive::iterator I = TheArchive->begin(), E= TheArchive->end(); I != E && !remaining.empty(); ++I ) { - std::set::iterator found = - std::find(remaining.begin(),remaining.end(),I->getPath()); + std::set::iterator found = + std::find(remaining.begin(),remaining.end(), I->getPath()); if (found != remaining.end()) { if (I != moveto_spot) TheArchive->splice(moveto_spot,*TheArchive,I); @@ -540,44 +468,47 @@ void doMove() { } // We're done editting, reconstruct the archive. - std::string errmsg; - if (!TheArchive->writeToDisk(SymTable,TruncateNames,Compression,&errmsg)) - throw errmsg; - if (ReallyVerbose) - printSymbolTable(); + if (TheArchive->writeToDisk(ErrMsg)) + return true; + return false; } // doQuickAppend - Implements the 'q' operation. This function just // indiscriminantly adds the members to the archive and rebuilds it. -void doQuickAppend() { +bool +doQuickAppend(std::string* ErrMsg) { // Get the list of paths to append. - buildPaths(true); - if (Paths.empty()) return; + if (buildPaths(true, ErrMsg)) + return true; + if (Paths.empty()) + return false; // Append them quickly. - for (std::set::iterator PI = Paths.begin(), PE = Paths.end(); + for (std::set::iterator PI = Paths.begin(), PE = Paths.end(); PI != PE; ++PI) { - TheArchive->addFileBefore(*PI,TheArchive->end()); + if (TheArchive->addFileBefore(*PI, TheArchive->end(), ErrMsg)) + return true; } // We're done editting, reconstruct the archive. - std::string errmsg; - if (!TheArchive->writeToDisk(SymTable,TruncateNames,Compression,&errmsg)) - throw errmsg; - if (ReallyVerbose) - printSymbolTable(); + if (TheArchive->writeToDisk(ErrMsg)) + return true; + return false; } // doReplaceOrInsert - Implements the 'r' operation. This function will replace // any existing files or insert new ones into the archive. -void doReplaceOrInsert() { +bool +doReplaceOrInsert(std::string* ErrMsg) { // Build the list of files to be added/replaced. - buildPaths(true); - if (Paths.empty()) return; + if (buildPaths(true, ErrMsg)) + return true; + if (Paths.empty()) + return false; // Keep track of the paths that remain to be inserted. - std::set remaining(Paths); + std::set remaining(Paths); // Default the insertion spot to the end of the archive Archive::iterator insert_spot = TheArchive->end(); @@ -589,41 +520,31 @@ void doReplaceOrInsert() { // Determine if this archive member matches one of the paths we're trying // to replace. - std::set::iterator found = remaining.end(); - for (std::set::iterator RI = remaining.begin(), + std::set::iterator found = remaining.end(); + for (std::set::iterator RI = remaining.begin(), RE = remaining.end(); RI != RE; ++RI ) { - std::string compare(RI->toString()); - if (TruncateNames && compare.length() > 15) { - const char* nm = compare.c_str(); - unsigned len = compare.length(); - size_t slashpos = compare.rfind('/'); - if (slashpos != std::string::npos) { - nm += slashpos + 1; - len -= slashpos +1; - } - if (len > 15) - len = 15; - compare.assign(nm,len); - } - if (compare == I->getPath().toString()) { + std::string compare(sys::path::filename(*RI)); + if (compare == I->getPath().str()) { found = RI; break; } } if (found != remaining.end()) { - sys::FileStatus si; - std::string Err; - if (found->getFileStatus(si, &Err)) - throw Err; - if (si.isDir) { + sys::fs::file_status Status; + error_code EC = sys::fs::status(*found, Status); + if (EC) + return true; + if (!sys::fs::is_directory(Status)) { if (OnlyUpdate) { // Replace the item only if it is newer. - if (si.modTime > I->getModTime()) - I->replaceWith(*found); + if (Status.getLastModificationTime() > I->getModTime()) + if (I->replaceWith(*found, ErrMsg)) + return true; } else { // Replace the item regardless of time stamp - I->replaceWith(*found); + if (I->replaceWith(*found, ErrMsg)) + return true; } } else { // We purposefully ignore directories. @@ -634,9 +555,9 @@ void doReplaceOrInsert() { } // Determine if this is the place where we should insert - if ((AddBefore || InsertBefore) && (RelPos == I->getPath().toString())) + if ((AddBefore || InsertBefore) && RelPos == I->getPath().str()) insert_spot = I; - else if (AddAfter && (RelPos == I->getPath().toString())) { + else if (AddAfter && RelPos == I->getPath().str()) { insert_spot = I; insert_spot++; } @@ -645,98 +566,100 @@ void doReplaceOrInsert() { // If we didn't replace all the members, some will remain and need to be // inserted at the previously computed insert-spot. if (!remaining.empty()) { - for (std::set::iterator PI = remaining.begin(), + for (std::set::iterator PI = remaining.begin(), PE = remaining.end(); PI != PE; ++PI) { - TheArchive->addFileBefore(*PI,insert_spot); + if (TheArchive->addFileBefore(*PI, insert_spot, ErrMsg)) + return true; } } // We're done editting, reconstruct the archive. - std::string errmsg; - if (!TheArchive->writeToDisk(SymTable,TruncateNames,Compression,&errmsg)) - throw errmsg; - if (ReallyVerbose) - printSymbolTable(); + if (TheArchive->writeToDisk(ErrMsg)) + return true; + return false; +} + +bool shouldCreateArchive(ArchiveOperation Op) { + switch (Op) { + case Print: + case Delete: + case Move: + case DisplayTable: + case Extract: + return false; + + case QuickAppend: + case ReplaceOrInsert: + return true; + } + + llvm_unreachable("Missing entry in covered switch."); } // main - main program for llvm-ar .. see comments in the code int main(int argc, char **argv) { + program_name = argv[0]; + // Print a stack trace if we signal out. + sys::PrintStackTraceOnErrorSignal(); + PrettyStackTraceProgram X(argc, argv); + LLVMContext &Context = getGlobalContext(); + llvm_shutdown_obj Y; // Call llvm_shutdown() on exit. // Have the command line options parsed and handle things // like --help and --version. cl::ParseCommandLineOptions(argc, argv, - " LLVM Archiver (llvm-ar)\n\n" - " This program archives bytecode files into single libraries\n" + "LLVM Archiver (llvm-ar)\n\n" + " This program archives bitcode files into single libraries\n" ); - // Print a stack trace if we signal out. - sys::PrintStackTraceOnErrorSignal(); - int exitCode = 0; - // Make sure we don't exit with "unhandled exception". - try { - // Do our own parsing of the command line because the CommandLine utility - // can't handle the grouped positional parameters without a dash. - ArchiveOperation Operation = parseCommandLine(); - - // Check the path name of the archive - sys::Path ArchivePath; - if (!ArchivePath.set(ArchiveName)) - throw std::string("Archive name invalid: ") + ArchiveName; - - // Create or open the archive object. - if (!ArchivePath.exists()) { - // Produce a warning if we should and we're creating the archive - if (!Create) - std::cerr << argv[0] << ": creating " << ArchivePath.toString() << "\n"; - TheArchive = Archive::CreateEmpty(ArchivePath); - } else { - std::string Error; - TheArchive = Archive::OpenAndLoad(ArchivePath, &Error); - if (TheArchive == 0) { - std::cerr << argv[0] << ": error loading '" << ArchivePath << "': " - << Error << "!\n"; - return 1; - } - } + // Do our own parsing of the command line because the CommandLine utility + // can't handle the grouped positional parameters without a dash. + ArchiveOperation Operation = parseCommandLine(); + + // Create or open the archive object. + if (shouldCreateArchive(Operation) && !llvm::sys::fs::exists(ArchiveName)) { + // Produce a warning if we should and we're creating the archive + if (!Create) + errs() << argv[0] << ": creating " << ArchiveName << "\n"; + TheArchive = Archive::CreateEmpty(ArchiveName, Context); + TheArchive->writeToDisk(); + } - // Make sure we're not fooling ourselves. - assert(TheArchive && "Unable to instantiate the archive"); - - // Make sure we clean up the archive even on failure. - std::auto_ptr AutoArchive(TheArchive); - - // Perform the operation - switch (Operation) { - case Print: doPrint(); break; - case Delete: doDelete(); break; - case Move: doMove(); break; - case QuickAppend: /* FALL THROUGH */ - case ReplaceOrInsert: doReplaceOrInsert(); break; - case DisplayTable: doDisplayTable(); break; - case Extract: doExtract(); break; - case NoOperation: - std::cerr << argv[0] << ": No operation was selected.\n"; - break; + if (!TheArchive) { + std::string Error; + TheArchive = Archive::OpenAndLoad(ArchiveName, Context, &Error); + if (TheArchive == 0) { + errs() << argv[0] << ": error loading '" << ArchiveName << "': " + << Error << "!\n"; + return 1; } - } catch (const char*msg) { - // These errors are usage errors, thrown only by the various checks in the - // code above. - std::cerr << argv[0] << ": " << msg << "\n\n"; - cl::PrintHelpMessage(); - exitCode = 1; - } catch (const std::string& msg) { - // These errors are thrown by LLVM libraries (e.g. lib System) and represent - // a more serious error so we bump the exitCode and don't print the usage. - std::cerr << argv[0] << ": " << msg << "\n"; - exitCode = 2; - } catch (...) { - // This really shouldn't happen, but just in case .... - std::cerr << argv[0] << ": An unexpected unknown exception occurred.\n"; - exitCode = 3; } + // Make sure we're not fooling ourselves. + assert(TheArchive && "Unable to instantiate the archive"); + + // Perform the operation + std::string ErrMsg; + bool haveError = false; + switch (Operation) { + case Print: haveError = doPrint(&ErrMsg); break; + case Delete: haveError = doDelete(&ErrMsg); break; + case Move: haveError = doMove(&ErrMsg); break; + case QuickAppend: haveError = doQuickAppend(&ErrMsg); break; + case ReplaceOrInsert: haveError = doReplaceOrInsert(&ErrMsg); break; + case DisplayTable: haveError = doDisplayTable(&ErrMsg); break; + case Extract: haveError = doExtract(&ErrMsg); break; + } + if (haveError) { + errs() << argv[0] << ": " << ErrMsg << "\n"; + return 1; + } + + delete TheArchive; + TheArchive = 0; + // Return result code back to operating system. return exitCode; }