X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=tools%2Fllvm-ar%2Fllvm-ar.cpp;h=3271f7c82f46670635ee43aaf28d681e24582d57;hb=a75ce9f5d2236d93c117e861e60e6f3f748c9555;hp=e5abea4f904e084f63110da545677d1c7e13cbbb;hpb=e5c9cb5eb6bce502faaedea04014dab46f6540f4;p=oota-llvm.git diff --git a/tools/llvm-ar/llvm-ar.cpp b/tools/llvm-ar/llvm-ar.cpp index e5abea4f904..3271f7c82f4 100644 --- a/tools/llvm-ar/llvm-ar.cpp +++ b/tools/llvm-ar/llvm-ar.cpp @@ -2,29 +2,31 @@ // // 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/LLVMContext.h" #include "llvm/Module.h" -#include "llvm/Bytecode/Archive.h" +#include "llvm/Bitcode/Archive.h" #include "llvm/Support/CommandLine.h" -#include "llvm/Support/Compressor.h" -#include "llvm/System/Signals.h" -#include +#include "llvm/Support/ManagedStatic.h" +#include "llvm/Support/PrettyStackTrace.h" +#include "llvm/Support/Format.h" +#include "llvm/Support/raw_ostream.h" +#include "llvm/Support/Signals.h" #include -#include #include - +#include 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")); @@ -55,7 +57,7 @@ static cl::extrahelp MoreHelp( " [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" + " [k] - always print bitcode 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" @@ -89,7 +91,7 @@ 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 DontSkipBitcode = false; ///< 'k' modifier bool UseCount = false; ///< 'N' modifier bool OriginalDates = false; ///< 'o' modifier bool FullPath = false; ///< 'P' modifier @@ -189,12 +191,13 @@ ArchiveOperation parseCommandLine() { case 'd': ++NumOperations; Operation = Delete; break; case 'm': ++NumOperations; Operation = Move ; break; case 'p': ++NumOperations; Operation = Print; break; + case 'q': ++NumOperations; Operation = QuickAppend; break; case 'r': ++NumOperations; Operation = ReplaceOrInsert; break; case 't': ++NumOperations; Operation = DisplayTable; break; case 'x': ++NumOperations; Operation = Extract; break; case 'c': Create = true; break; case 'f': TruncateNames = true; break; - case 'k': DontSkipBytecode = true; break; + case 'k': DontSkipBitcode = true; break; case 'l': /* accepted but unused */ break; case 'o': OriginalDates = true; break; case 'P': FullPath = true; break; @@ -269,32 +272,39 @@ ArchiveOperation parseCommandLine() { // 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) { - std::set result; +bool +recurseDirectories(const sys::Path& path, + std::set& result, std::string* ErrMsg) { + result.clear(); if (RecurseDirectories) { std::set content; - path.getDirectoryContents(content); + if (path.getDirectoryContents(content, ErrMsg)) + return true; + for (std::set::iterator I = content.begin(), E = content.end(); I != E; ++I) { - // Make sure it exists and is a directory - sys::FileStatus Status; - if (!I->getFileStatus(Status)) { - if (Status.isDir) { - std::set moreResults = recurseDirectories(*I); - result.insert(moreResults.begin(), moreResults.end()); - } else { - result.insert(*I); - } - } + // Make sure it exists and is a directory + sys::PathWithStatus PwS(*I); + const sys::FileStatus *Status = PwS.getFileStatus(false, ErrMsg); + if (!Status) + return true; + if (Status->isDir) { + std::set moreResults; + if (recurseDirectories(*I, moreResults, ErrMsg)) + return true; + result.insert(moreResults.begin(), moreResults.end()); + } else { + result.insert(*I); + } } } - return result; + return false; } // 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])) @@ -302,12 +312,15 @@ void buildPaths(bool checkExistence = true) { 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)) + sys::PathWithStatus PwS(aPath); + const sys::FileStatus *si = PwS.getFileStatus(false, &Err); + if (!si) throw Err; - if (si.isDir) { - std::set dirpaths = recurseDirectories(aPath); + if (si->isDir) { + std::set dirpaths; + if (recurseDirectories(aPath, dirpaths, ErrMsg)) + return true; Paths.insert(dirpaths.begin(),dirpaths.end()); } else { Paths.insert(aPath); @@ -316,25 +329,27 @@ void buildPaths(bool checkExistence = true) { Paths.insert(aPath); } } + return false; } // printSymbolTable - print out the archive's symbol table. void printSymbolTable() { - std::cout << "\nArchive Symbol Table:\n"; + outs() << "\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"; + outs() << " " << format("%9u", offset) << "\t" << I->first <<"\n"; } } // 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); +bool doPrint(std::string* ErrMsg) { + if (buildPaths(false, ErrMsg)) + return true; unsigned countDown = Count; for (Archive::iterator I = TheArchive->begin(), E = TheArchive->end(); I != E; ++I ) { @@ -345,51 +360,48 @@ void doPrint() { // Skip things that don't make sense to print if (I->isLLVMSymbolTable() || I->isSVR4SymbolTable() || - I->isBSD4SymbolTable() || (!DontSkipBytecode && - (I->isBytecode() || I->isCompressedBytecode()))) + I->isBSD4SymbolTable() || (!DontSkipBitcode && I->isBitcode())) continue; if (Verbose) - std::cout << "Printing " << I->getPath().toString() << "\n"; + 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); - } + unsigned len = I->getSize(); + outs().write(data, len); } else { countDown--; } } } + 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() || @@ -397,38 +409,37 @@ void doDisplayTable() { 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"; + if (I->isBitcode()) + outs() << "b"; else if (I->isCompressed()) - std::cout << "Z"; + outs() << "Z"; else - std::cout << " "; + outs() << " "; 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() << " " << format("%4u", I->getUser()); + outs() << "/" << format("%4u", I->getGroup()); + outs() << " " << format("%8u", I->getSize()); + outs() << " " << format("%20s", I->getModTime().str().substr(4).c_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 -bool doExtract(std::string* ErrMsg) { - buildPaths(false); - unsigned countDown = Count; +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() || @@ -451,12 +462,8 @@ bool doExtract(std::string* ErrMsg) { const char* data = reinterpret_cast(I->getData()); unsigned len = I->getSize(); - // Write the data, making sure to uncompress things first - if (I->isCompressed()) { - Compressor::decompressToStream(data,len,file); - } else { - file.write(data,len); - } + // Write the data. + file.write(data,len); file.close(); // If we're supposed to retain the original modification times, etc. do so @@ -472,9 +479,12 @@ bool doExtract(std::string* ErrMsg) { // 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; +bool +doDelete(std::string* ErrMsg) { + if (buildPaths(false, ErrMsg)) + return true; + if (Paths.empty()) + return false; unsigned countDown = Count; for (Archive::iterator I = TheArchive->begin(), E = TheArchive->end(); I != E; ) { @@ -491,20 +501,21 @@ void doDelete() { } // We're done editting, reconstruct the archive. - std::string errmsg; - if (!TheArchive->writeToDisk(SymTable,TruncateNames,Compression,&errmsg)) - throw errmsg; + if (TheArchive->writeToDisk(SymTable,TruncateNames,Compression,ErrMsg)) + return true; if (ReallyVerbose) printSymbolTable(); + 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. @@ -516,7 +527,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++; @@ -545,41 +556,48 @@ void doMove() { } // We're done editting, reconstruct the archive. - std::string errmsg; - if (!TheArchive->writeToDisk(SymTable,TruncateNames,Compression,&errmsg)) - throw errmsg; + if (TheArchive->writeToDisk(SymTable,TruncateNames,Compression,ErrMsg)) + return true; if (ReallyVerbose) printSymbolTable(); + 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(); 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 (TheArchive->writeToDisk(SymTable,TruncateNames,Compression,ErrMsg)) + return true; if (ReallyVerbose) printSymbolTable(); + 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); @@ -597,7 +615,7 @@ void doReplaceOrInsert() { std::set::iterator found = remaining.end(); for (std::set::iterator RI = remaining.begin(), RE = remaining.end(); RI != RE; ++RI ) { - std::string compare(RI->toString()); + std::string compare(RI->str()); if (TruncateNames && compare.length() > 15) { const char* nm = compare.c_str(); unsigned len = compare.length(); @@ -610,25 +628,28 @@ void doReplaceOrInsert() { len = 15; compare.assign(nm,len); } - if (compare == I->getPath().toString()) { + 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::PathWithStatus PwS(*found); + const sys::FileStatus *si = PwS.getFileStatus(false, &Err); + if (!si) + return true; + if (!si->isDir) { if (OnlyUpdate) { // Replace the item only if it is newer. - if (si.modTime > I->getModTime()) - I->replaceWith(*found); + if (si->modTime > 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. @@ -639,9 +660,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++; } @@ -652,31 +673,34 @@ void doReplaceOrInsert() { if (!remaining.empty()) { 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 (TheArchive->writeToDisk(SymTable,TruncateNames,Compression,ErrMsg)) + return true; if (ReallyVerbose) printSymbolTable(); + return false; } // main - main program for llvm-ar .. see comments in the code int main(int argc, char **argv) { + // 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". @@ -694,14 +718,15 @@ int main(int argc, char **argv) { 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); + errs() << argv[0] << ": creating " << ArchivePath.str() << "\n"; + TheArchive = Archive::CreateEmpty(ArchivePath, Context); + TheArchive->writeToDisk(); } else { std::string Error; - TheArchive = Archive::OpenAndLoad(ArchivePath, &Error); + TheArchive = Archive::OpenAndLoad(ArchivePath, Context, &Error); if (TheArchive == 0) { - std::cerr << argv[0] << ": error loading '" << ArchivePath << "': " - << Error << "!\n"; + errs() << argv[0] << ": error loading '" << ArchivePath.str() << "': " + << Error << "!\n"; return 1; } } @@ -714,37 +739,37 @@ int main(int argc, char **argv) { // Perform the operation std::string ErrMsg; + bool haveError = false; 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: - if (doExtract(&ErrMsg)) { - std::cerr << argv[0] << ": " << ErrMsg << "\n"; - return 1; - } - break; + 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; case NoOperation: - std::cerr << argv[0] << ": No operation was selected.\n"; + errs() << argv[0] << ": No operation was selected.\n"; break; } + if (haveError) { + errs() << argv[0] << ": " << ErrMsg << "\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"; + errs() << 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"; + errs() << 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"; + errs() << argv[0] << ": An unexpected unknown exception occurred.\n"; exitCode = 3; }