llvm-ar.cpp revision 249423
1//===-- llvm-ar.cpp - LLVM archive librarian utility ----------------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// Builds up (relatively) standard unix archive files (.a) containing LLVM 11// bitcode or other files. 12// 13//===----------------------------------------------------------------------===// 14 15#include "llvm/IR/LLVMContext.h" 16#include "llvm/Bitcode/Archive.h" 17#include "llvm/IR/Module.h" 18#include "llvm/Support/CommandLine.h" 19#include "llvm/Support/FileSystem.h" 20#include "llvm/Support/Format.h" 21#include "llvm/Support/ManagedStatic.h" 22#include "llvm/Support/PrettyStackTrace.h" 23#include "llvm/Support/Signals.h" 24#include "llvm/Support/raw_ostream.h" 25#include <algorithm> 26#include <cstdlib> 27#include <fstream> 28#include <memory> 29using namespace llvm; 30 31// Option for compatibility with AIX, not used but must allow it to be present. 32static cl::opt<bool> 33X32Option ("X32_64", cl::Hidden, 34 cl::desc("Ignored option for compatibility with AIX")); 35 36// llvm-ar operation code and modifier flags. This must come first. 37static cl::opt<std::string> 38Options(cl::Positional, cl::Required, cl::desc("{operation}[modifiers]...")); 39 40// llvm-ar remaining positional arguments. 41static cl::list<std::string> 42RestOfArgs(cl::Positional, cl::OneOrMore, 43 cl::desc("[relpos] [count] <archive-file> [members]...")); 44 45// MoreHelp - Provide additional help output explaining the operations and 46// modifiers of llvm-ar. This object instructs the CommandLine library 47// to print the text of the constructor when the --help option is given. 48static cl::extrahelp MoreHelp( 49 "\nOPERATIONS:\n" 50 " d[NsS] - delete file(s) from the archive\n" 51 " m[abiSs] - move file(s) in the archive\n" 52 " p[kN] - print file(s) found in the archive\n" 53 " q[ufsS] - quick append file(s) to the archive\n" 54 " r[abfiuRsS] - replace or insert file(s) into the archive\n" 55 " t - display contents of archive\n" 56 " x[No] - extract file(s) from the archive\n" 57 "\nMODIFIERS (operation specific):\n" 58 " [a] - put file(s) after [relpos]\n" 59 " [b] - put file(s) before [relpos] (same as [i])\n" 60 " [f] - truncate inserted file names\n" 61 " [i] - put file(s) before [relpos] (same as [b])\n" 62 " [k] - always print bitcode files (default is to skip them)\n" 63 " [N] - use instance [count] of name\n" 64 " [o] - preserve original dates\n" 65 " [P] - use full path names when matching\n" 66 " [R] - recurse through directories when inserting\n" 67 " [s] - create an archive index (cf. ranlib)\n" 68 " [S] - do not build a symbol table\n" 69 " [u] - update only files newer than archive contents\n" 70 "\nMODIFIERS (generic):\n" 71 " [c] - do not warn if the library had to be created\n" 72 " [v] - be verbose about actions taken\n" 73 " [V] - be *really* verbose about actions taken\n" 74); 75 76// This enumeration delineates the kinds of operations on an archive 77// that are permitted. 78enum ArchiveOperation { 79 NoOperation, ///< An operation hasn't been specified 80 Print, ///< Print the contents of the archive 81 Delete, ///< Delete the specified members 82 Move, ///< Move members to end or as given by {a,b,i} modifiers 83 QuickAppend, ///< Quickly append to end of archive 84 ReplaceOrInsert, ///< Replace or Insert members 85 DisplayTable, ///< Display the table of contents 86 Extract ///< Extract files back to file system 87}; 88 89// Modifiers to follow operation to vary behavior 90bool AddAfter = false; ///< 'a' modifier 91bool AddBefore = false; ///< 'b' modifier 92bool Create = false; ///< 'c' modifier 93bool TruncateNames = false; ///< 'f' modifier 94bool InsertBefore = false; ///< 'i' modifier 95bool DontSkipBitcode = false; ///< 'k' modifier 96bool UseCount = false; ///< 'N' modifier 97bool OriginalDates = false; ///< 'o' modifier 98bool FullPath = false; ///< 'P' modifier 99bool RecurseDirectories = false; ///< 'R' modifier 100bool SymTable = true; ///< 's' & 'S' modifiers 101bool OnlyUpdate = false; ///< 'u' modifier 102bool Verbose = false; ///< 'v' modifier 103bool ReallyVerbose = false; ///< 'V' modifier 104 105// Relative Positional Argument (for insert/move). This variable holds 106// the name of the archive member to which the 'a', 'b' or 'i' modifier 107// refers. Only one of 'a', 'b' or 'i' can be specified so we only need 108// one variable. 109std::string RelPos; 110 111// Select which of multiple entries in the archive with the same name should be 112// used (specified with -N) for the delete and extract operations. 113int Count = 1; 114 115// This variable holds the name of the archive file as given on the 116// command line. 117std::string ArchiveName; 118 119// This variable holds the list of member files to proecess, as given 120// on the command line. 121std::vector<std::string> Members; 122 123// This variable holds the (possibly expanded) list of path objects that 124// correspond to files we will 125std::set<sys::Path> Paths; 126 127// The Archive object to which all the editing operations will be sent. 128Archive* TheArchive = 0; 129 130// The name this program was invoked as. 131static const char *program_name; 132 133// show_help - Show the error message, the help message and exit. 134LLVM_ATTRIBUTE_NORETURN static void 135show_help(const std::string &msg) { 136 errs() << program_name << ": " << msg << "\n\n"; 137 cl::PrintHelpMessage(); 138 if (TheArchive) 139 delete TheArchive; 140 std::exit(1); 141} 142 143// fail - Show the error message and exit. 144LLVM_ATTRIBUTE_NORETURN static void 145fail(const std::string &msg) { 146 errs() << program_name << ": " << msg << "\n\n"; 147 if (TheArchive) 148 delete TheArchive; 149 std::exit(1); 150} 151 152// getRelPos - Extract the member filename from the command line for 153// the [relpos] argument associated with a, b, and i modifiers 154void getRelPos() { 155 if(RestOfArgs.size() == 0) 156 show_help("Expected [relpos] for a, b, or i modifier"); 157 RelPos = RestOfArgs[0]; 158 RestOfArgs.erase(RestOfArgs.begin()); 159} 160 161// getCount - Extract the [count] argument associated with the N modifier 162// from the command line and check its value. 163void getCount() { 164 if(RestOfArgs.size() == 0) 165 show_help("Expected [count] value with N modifier"); 166 167 Count = atoi(RestOfArgs[0].c_str()); 168 RestOfArgs.erase(RestOfArgs.begin()); 169 170 // Non-positive counts are not allowed 171 if (Count < 1) 172 show_help("Invalid [count] value (not a positive integer)"); 173} 174 175// getArchive - Get the archive file name from the command line 176void getArchive() { 177 if(RestOfArgs.size() == 0) 178 show_help("An archive name must be specified"); 179 ArchiveName = RestOfArgs[0]; 180 RestOfArgs.erase(RestOfArgs.begin()); 181} 182 183// getMembers - Copy over remaining items in RestOfArgs to our Members vector 184// This is just for clarity. 185void getMembers() { 186 if(RestOfArgs.size() > 0) 187 Members = std::vector<std::string>(RestOfArgs); 188} 189 190// parseCommandLine - Parse the command line options as presented and return the 191// operation specified. Process all modifiers and check to make sure that 192// constraints on modifier/operation pairs have not been violated. 193ArchiveOperation parseCommandLine() { 194 195 // Keep track of number of operations. We can only specify one 196 // per execution. 197 unsigned NumOperations = 0; 198 199 // Keep track of the number of positional modifiers (a,b,i). Only 200 // one can be specified. 201 unsigned NumPositional = 0; 202 203 // Keep track of which operation was requested 204 ArchiveOperation Operation = NoOperation; 205 206 for(unsigned i=0; i<Options.size(); ++i) { 207 switch(Options[i]) { 208 case 'd': ++NumOperations; Operation = Delete; break; 209 case 'm': ++NumOperations; Operation = Move ; break; 210 case 'p': ++NumOperations; Operation = Print; break; 211 case 'q': ++NumOperations; Operation = QuickAppend; break; 212 case 'r': ++NumOperations; Operation = ReplaceOrInsert; break; 213 case 't': ++NumOperations; Operation = DisplayTable; break; 214 case 'x': ++NumOperations; Operation = Extract; break; 215 case 'c': Create = true; break; 216 case 'f': TruncateNames = true; break; 217 case 'k': DontSkipBitcode = true; break; 218 case 'l': /* accepted but unused */ break; 219 case 'o': OriginalDates = true; break; 220 case 'P': FullPath = true; break; 221 case 'R': RecurseDirectories = true; break; 222 case 's': SymTable = true; break; 223 case 'S': SymTable = false; break; 224 case 'u': OnlyUpdate = true; break; 225 case 'v': Verbose = true; break; 226 case 'V': Verbose = ReallyVerbose = true; break; 227 case 'a': 228 getRelPos(); 229 AddAfter = true; 230 NumPositional++; 231 break; 232 case 'b': 233 getRelPos(); 234 AddBefore = true; 235 NumPositional++; 236 break; 237 case 'i': 238 getRelPos(); 239 InsertBefore = true; 240 NumPositional++; 241 break; 242 case 'N': 243 getCount(); 244 UseCount = true; 245 break; 246 default: 247 cl::PrintHelpMessage(); 248 } 249 } 250 251 // At this point, the next thing on the command line must be 252 // the archive name. 253 getArchive(); 254 255 // Everything on the command line at this point is a member. 256 getMembers(); 257 258 // Perform various checks on the operation/modifier specification 259 // to make sure we are dealing with a legal request. 260 if (NumOperations == 0) 261 show_help("You must specify at least one of the operations"); 262 if (NumOperations > 1) 263 show_help("Only one operation may be specified"); 264 if (NumPositional > 1) 265 show_help("You may only specify one of a, b, and i modifiers"); 266 if (AddAfter || AddBefore || InsertBefore) { 267 if (Operation != Move && Operation != ReplaceOrInsert) 268 show_help("The 'a', 'b' and 'i' modifiers can only be specified with " 269 "the 'm' or 'r' operations"); 270 } 271 if (RecurseDirectories && Operation != ReplaceOrInsert) 272 show_help("The 'R' modifiers is only applicabe to the 'r' operation"); 273 if (OriginalDates && Operation != Extract) 274 show_help("The 'o' modifier is only applicable to the 'x' operation"); 275 if (TruncateNames && Operation!=QuickAppend && Operation!=ReplaceOrInsert) 276 show_help("The 'f' modifier is only applicable to the 'q' and 'r' " 277 "operations"); 278 if (OnlyUpdate && Operation != ReplaceOrInsert) 279 show_help("The 'u' modifier is only applicable to the 'r' operation"); 280 if (Count > 1 && Members.size() > 1) 281 show_help("Only one member name may be specified with the 'N' modifier"); 282 283 // Return the parsed operation to the caller 284 return Operation; 285} 286 287// recurseDirectories - Implements the "R" modifier. This function scans through 288// the Paths vector (built by buildPaths, below) and replaces any directories it 289// finds with all the files in that directory (recursively). It uses the 290// sys::Path::getDirectoryContent method to perform the actual directory scans. 291bool 292recurseDirectories(const sys::Path& path, 293 std::set<sys::Path>& result, std::string* ErrMsg) { 294 result.clear(); 295 if (RecurseDirectories) { 296 std::set<sys::Path> content; 297 if (path.getDirectoryContents(content, ErrMsg)) 298 return true; 299 300 for (std::set<sys::Path>::iterator I = content.begin(), E = content.end(); 301 I != E; ++I) { 302 // Make sure it exists and is a directory 303 sys::PathWithStatus PwS(*I); 304 const sys::FileStatus *Status = PwS.getFileStatus(false, ErrMsg); 305 if (!Status) 306 return true; 307 if (Status->isDir) { 308 std::set<sys::Path> moreResults; 309 if (recurseDirectories(*I, moreResults, ErrMsg)) 310 return true; 311 result.insert(moreResults.begin(), moreResults.end()); 312 } else { 313 result.insert(*I); 314 } 315 } 316 } 317 return false; 318} 319 320// buildPaths - Convert the strings in the Members vector to sys::Path objects 321// and make sure they are valid and exist exist. This check is only needed for 322// the operations that add/replace files to the archive ('q' and 'r') 323bool buildPaths(bool checkExistence, std::string* ErrMsg) { 324 for (unsigned i = 0; i < Members.size(); i++) { 325 sys::Path aPath; 326 if (!aPath.set(Members[i])) 327 fail(std::string("File member name invalid: ") + Members[i]); 328 if (checkExistence) { 329 bool Exists; 330 if (sys::fs::exists(aPath.str(), Exists) || !Exists) 331 fail(std::string("File does not exist: ") + Members[i]); 332 std::string Err; 333 sys::PathWithStatus PwS(aPath); 334 const sys::FileStatus *si = PwS.getFileStatus(false, &Err); 335 if (!si) 336 fail(Err); 337 if (si->isDir) { 338 std::set<sys::Path> dirpaths; 339 if (recurseDirectories(aPath, dirpaths, ErrMsg)) 340 return true; 341 Paths.insert(dirpaths.begin(),dirpaths.end()); 342 } else { 343 Paths.insert(aPath); 344 } 345 } else { 346 Paths.insert(aPath); 347 } 348 } 349 return false; 350} 351 352// printSymbolTable - print out the archive's symbol table. 353void printSymbolTable() { 354 outs() << "\nArchive Symbol Table:\n"; 355 const Archive::SymTabType& symtab = TheArchive->getSymbolTable(); 356 for (Archive::SymTabType::const_iterator I=symtab.begin(), E=symtab.end(); 357 I != E; ++I ) { 358 unsigned offset = TheArchive->getFirstFileOffset() + I->second; 359 outs() << " " << format("%9u", offset) << "\t" << I->first <<"\n"; 360 } 361} 362 363// doPrint - Implements the 'p' operation. This function traverses the archive 364// looking for members that match the path list. It is careful to uncompress 365// things that should be and to skip bitcode files unless the 'k' modifier was 366// given. 367bool doPrint(std::string* ErrMsg) { 368 if (buildPaths(false, ErrMsg)) 369 return true; 370 unsigned countDown = Count; 371 for (Archive::iterator I = TheArchive->begin(), E = TheArchive->end(); 372 I != E; ++I ) { 373 if (Paths.empty() || 374 (std::find(Paths.begin(), Paths.end(), I->getPath()) != Paths.end())) { 375 if (countDown == 1) { 376 const char* data = reinterpret_cast<const char*>(I->getData()); 377 378 // Skip things that don't make sense to print 379 if (I->isLLVMSymbolTable() || I->isSVR4SymbolTable() || 380 I->isBSD4SymbolTable() || (!DontSkipBitcode && I->isBitcode())) 381 continue; 382 383 if (Verbose) 384 outs() << "Printing " << I->getPath().str() << "\n"; 385 386 unsigned len = I->getSize(); 387 outs().write(data, len); 388 } else { 389 countDown--; 390 } 391 } 392 } 393 return false; 394} 395 396// putMode - utility function for printing out the file mode when the 't' 397// operation is in verbose mode. 398void 399printMode(unsigned mode) { 400 if (mode & 004) 401 outs() << "r"; 402 else 403 outs() << "-"; 404 if (mode & 002) 405 outs() << "w"; 406 else 407 outs() << "-"; 408 if (mode & 001) 409 outs() << "x"; 410 else 411 outs() << "-"; 412} 413 414// doDisplayTable - Implement the 't' operation. This function prints out just 415// the file names of each of the members. However, if verbose mode is requested 416// ('v' modifier) then the file type, permission mode, user, group, size, and 417// modification time are also printed. 418bool 419doDisplayTable(std::string* ErrMsg) { 420 if (buildPaths(false, ErrMsg)) 421 return true; 422 for (Archive::iterator I = TheArchive->begin(), E = TheArchive->end(); 423 I != E; ++I ) { 424 if (Paths.empty() || 425 (std::find(Paths.begin(), Paths.end(), I->getPath()) != Paths.end())) { 426 if (Verbose) { 427 // FIXME: Output should be this format: 428 // Zrw-r--r-- 500/ 500 525 Nov 8 17:42 2004 Makefile 429 if (I->isBitcode()) 430 outs() << "b"; 431 else 432 outs() << " "; 433 unsigned mode = I->getMode(); 434 printMode((mode >> 6) & 007); 435 printMode((mode >> 3) & 007); 436 printMode(mode & 007); 437 outs() << " " << format("%4u", I->getUser()); 438 outs() << "/" << format("%4u", I->getGroup()); 439 outs() << " " << format("%8u", I->getSize()); 440 outs() << " " << format("%20s", I->getModTime().str().substr(4).c_str()); 441 outs() << " " << I->getPath().str() << "\n"; 442 } else { 443 outs() << I->getPath().str() << "\n"; 444 } 445 } 446 } 447 if (ReallyVerbose) 448 printSymbolTable(); 449 return false; 450} 451 452// doExtract - Implement the 'x' operation. This function extracts files back to 453// the file system. 454bool 455doExtract(std::string* ErrMsg) { 456 if (buildPaths(false, ErrMsg)) 457 return true; 458 for (Archive::iterator I = TheArchive->begin(), E = TheArchive->end(); 459 I != E; ++I ) { 460 if (Paths.empty() || 461 (std::find(Paths.begin(), Paths.end(), I->getPath()) != Paths.end())) { 462 463 // Make sure the intervening directories are created 464 if (I->hasPath()) { 465 sys::Path dirs(I->getPath()); 466 dirs.eraseComponent(); 467 if (dirs.createDirectoryOnDisk(/*create_parents=*/true, ErrMsg)) 468 return true; 469 } 470 471 // Open up a file stream for writing 472 std::ios::openmode io_mode = std::ios::out | std::ios::trunc | 473 std::ios::binary; 474 std::ofstream file(I->getPath().c_str(), io_mode); 475 476 // Get the data and its length 477 const char* data = reinterpret_cast<const char*>(I->getData()); 478 unsigned len = I->getSize(); 479 480 // Write the data. 481 file.write(data,len); 482 file.close(); 483 484 // If we're supposed to retain the original modification times, etc. do so 485 // now. 486 if (OriginalDates) 487 I->getPath().setStatusInfoOnDisk(I->getFileStatus()); 488 } 489 } 490 return false; 491} 492 493// doDelete - Implement the delete operation. This function deletes zero or more 494// members from the archive. Note that if the count is specified, there should 495// be no more than one path in the Paths list or else this algorithm breaks. 496// That check is enforced in parseCommandLine (above). 497bool 498doDelete(std::string* ErrMsg) { 499 if (buildPaths(false, ErrMsg)) 500 return true; 501 if (Paths.empty()) 502 return false; 503 unsigned countDown = Count; 504 for (Archive::iterator I = TheArchive->begin(), E = TheArchive->end(); 505 I != E; ) { 506 if (std::find(Paths.begin(), Paths.end(), I->getPath()) != Paths.end()) { 507 if (countDown == 1) { 508 Archive::iterator J = I; 509 ++I; 510 TheArchive->erase(J); 511 } else 512 countDown--; 513 } else { 514 ++I; 515 } 516 } 517 518 // We're done editting, reconstruct the archive. 519 if (TheArchive->writeToDisk(SymTable,TruncateNames,ErrMsg)) 520 return true; 521 if (ReallyVerbose) 522 printSymbolTable(); 523 return false; 524} 525 526// doMore - Implement the move operation. This function re-arranges just the 527// order of the archive members so that when the archive is written the move 528// of the members is accomplished. Note the use of the RelPos variable to 529// determine where the items should be moved to. 530bool 531doMove(std::string* ErrMsg) { 532 if (buildPaths(false, ErrMsg)) 533 return true; 534 535 // By default and convention the place to move members to is the end of the 536 // archive. 537 Archive::iterator moveto_spot = TheArchive->end(); 538 539 // However, if the relative positioning modifiers were used, we need to scan 540 // the archive to find the member in question. If we don't find it, its no 541 // crime, we just move to the end. 542 if (AddBefore || InsertBefore || AddAfter) { 543 for (Archive::iterator I = TheArchive->begin(), E= TheArchive->end(); 544 I != E; ++I ) { 545 if (RelPos == I->getPath().str()) { 546 if (AddAfter) { 547 moveto_spot = I; 548 moveto_spot++; 549 } else { 550 moveto_spot = I; 551 } 552 break; 553 } 554 } 555 } 556 557 // Keep a list of the paths remaining to be moved 558 std::set<sys::Path> remaining(Paths); 559 560 // Scan the archive again, this time looking for the members to move to the 561 // moveto_spot. 562 for (Archive::iterator I = TheArchive->begin(), E= TheArchive->end(); 563 I != E && !remaining.empty(); ++I ) { 564 std::set<sys::Path>::iterator found = 565 std::find(remaining.begin(),remaining.end(),I->getPath()); 566 if (found != remaining.end()) { 567 if (I != moveto_spot) 568 TheArchive->splice(moveto_spot,*TheArchive,I); 569 remaining.erase(found); 570 } 571 } 572 573 // We're done editting, reconstruct the archive. 574 if (TheArchive->writeToDisk(SymTable,TruncateNames,ErrMsg)) 575 return true; 576 if (ReallyVerbose) 577 printSymbolTable(); 578 return false; 579} 580 581// doQuickAppend - Implements the 'q' operation. This function just 582// indiscriminantly adds the members to the archive and rebuilds it. 583bool 584doQuickAppend(std::string* ErrMsg) { 585 // Get the list of paths to append. 586 if (buildPaths(true, ErrMsg)) 587 return true; 588 if (Paths.empty()) 589 return false; 590 591 // Append them quickly. 592 for (std::set<sys::Path>::iterator PI = Paths.begin(), PE = Paths.end(); 593 PI != PE; ++PI) { 594 if (TheArchive->addFileBefore(*PI,TheArchive->end(),ErrMsg)) 595 return true; 596 } 597 598 // We're done editting, reconstruct the archive. 599 if (TheArchive->writeToDisk(SymTable,TruncateNames,ErrMsg)) 600 return true; 601 if (ReallyVerbose) 602 printSymbolTable(); 603 return false; 604} 605 606// doReplaceOrInsert - Implements the 'r' operation. This function will replace 607// any existing files or insert new ones into the archive. 608bool 609doReplaceOrInsert(std::string* ErrMsg) { 610 611 // Build the list of files to be added/replaced. 612 if (buildPaths(true, ErrMsg)) 613 return true; 614 if (Paths.empty()) 615 return false; 616 617 // Keep track of the paths that remain to be inserted. 618 std::set<sys::Path> remaining(Paths); 619 620 // Default the insertion spot to the end of the archive 621 Archive::iterator insert_spot = TheArchive->end(); 622 623 // Iterate over the archive contents 624 for (Archive::iterator I = TheArchive->begin(), E = TheArchive->end(); 625 I != E && !remaining.empty(); ++I ) { 626 627 // Determine if this archive member matches one of the paths we're trying 628 // to replace. 629 630 std::set<sys::Path>::iterator found = remaining.end(); 631 for (std::set<sys::Path>::iterator RI = remaining.begin(), 632 RE = remaining.end(); RI != RE; ++RI ) { 633 std::string compare(RI->str()); 634 if (TruncateNames && compare.length() > 15) { 635 const char* nm = compare.c_str(); 636 unsigned len = compare.length(); 637 size_t slashpos = compare.rfind('/'); 638 if (slashpos != std::string::npos) { 639 nm += slashpos + 1; 640 len -= slashpos +1; 641 } 642 if (len > 15) 643 len = 15; 644 compare.assign(nm,len); 645 } 646 if (compare == I->getPath().str()) { 647 found = RI; 648 break; 649 } 650 } 651 652 if (found != remaining.end()) { 653 std::string Err; 654 sys::PathWithStatus PwS(*found); 655 const sys::FileStatus *si = PwS.getFileStatus(false, &Err); 656 if (!si) 657 return true; 658 if (!si->isDir) { 659 if (OnlyUpdate) { 660 // Replace the item only if it is newer. 661 if (si->modTime > I->getModTime()) 662 if (I->replaceWith(*found, ErrMsg)) 663 return true; 664 } else { 665 // Replace the item regardless of time stamp 666 if (I->replaceWith(*found, ErrMsg)) 667 return true; 668 } 669 } else { 670 // We purposefully ignore directories. 671 } 672 673 // Remove it from our "to do" list 674 remaining.erase(found); 675 } 676 677 // Determine if this is the place where we should insert 678 if ((AddBefore || InsertBefore) && RelPos == I->getPath().str()) 679 insert_spot = I; 680 else if (AddAfter && RelPos == I->getPath().str()) { 681 insert_spot = I; 682 insert_spot++; 683 } 684 } 685 686 // If we didn't replace all the members, some will remain and need to be 687 // inserted at the previously computed insert-spot. 688 if (!remaining.empty()) { 689 for (std::set<sys::Path>::iterator PI = remaining.begin(), 690 PE = remaining.end(); PI != PE; ++PI) { 691 if (TheArchive->addFileBefore(*PI,insert_spot, ErrMsg)) 692 return true; 693 } 694 } 695 696 // We're done editting, reconstruct the archive. 697 if (TheArchive->writeToDisk(SymTable,TruncateNames,ErrMsg)) 698 return true; 699 if (ReallyVerbose) 700 printSymbolTable(); 701 return false; 702} 703 704// main - main program for llvm-ar .. see comments in the code 705int main(int argc, char **argv) { 706 program_name = argv[0]; 707 // Print a stack trace if we signal out. 708 sys::PrintStackTraceOnErrorSignal(); 709 PrettyStackTraceProgram X(argc, argv); 710 LLVMContext &Context = getGlobalContext(); 711 llvm_shutdown_obj Y; // Call llvm_shutdown() on exit. 712 713 // Have the command line options parsed and handle things 714 // like --help and --version. 715 cl::ParseCommandLineOptions(argc, argv, 716 "LLVM Archiver (llvm-ar)\n\n" 717 " This program archives bitcode files into single libraries\n" 718 ); 719 720 int exitCode = 0; 721 722 // Do our own parsing of the command line because the CommandLine utility 723 // can't handle the grouped positional parameters without a dash. 724 ArchiveOperation Operation = parseCommandLine(); 725 726 // Check the path name of the archive 727 sys::Path ArchivePath; 728 if (!ArchivePath.set(ArchiveName)) { 729 errs() << argv[0] << ": Archive name invalid: " << ArchiveName << "\n"; 730 return 1; 731 } 732 733 // Create or open the archive object. 734 bool Exists; 735 if (llvm::sys::fs::exists(ArchivePath.str(), Exists) || !Exists) { 736 // Produce a warning if we should and we're creating the archive 737 if (!Create) 738 errs() << argv[0] << ": creating " << ArchivePath.str() << "\n"; 739 TheArchive = Archive::CreateEmpty(ArchivePath, Context); 740 TheArchive->writeToDisk(); 741 } else { 742 std::string Error; 743 TheArchive = Archive::OpenAndLoad(ArchivePath, Context, &Error); 744 if (TheArchive == 0) { 745 errs() << argv[0] << ": error loading '" << ArchivePath.str() << "': " 746 << Error << "!\n"; 747 return 1; 748 } 749 } 750 751 // Make sure we're not fooling ourselves. 752 assert(TheArchive && "Unable to instantiate the archive"); 753 754 // Perform the operation 755 std::string ErrMsg; 756 bool haveError = false; 757 switch (Operation) { 758 case Print: haveError = doPrint(&ErrMsg); break; 759 case Delete: haveError = doDelete(&ErrMsg); break; 760 case Move: haveError = doMove(&ErrMsg); break; 761 case QuickAppend: haveError = doQuickAppend(&ErrMsg); break; 762 case ReplaceOrInsert: haveError = doReplaceOrInsert(&ErrMsg); break; 763 case DisplayTable: haveError = doDisplayTable(&ErrMsg); break; 764 case Extract: haveError = doExtract(&ErrMsg); break; 765 case NoOperation: 766 errs() << argv[0] << ": No operation was selected.\n"; 767 break; 768 } 769 if (haveError) { 770 errs() << argv[0] << ": " << ErrMsg << "\n"; 771 return 1; 772 } 773 774 delete TheArchive; 775 TheArchive = 0; 776 777 // Return result code back to operating system. 778 return exitCode; 779} 780