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