binutils/ar.c

   1 /* ar.c - Archive modify and extract.
   2    Copyright (C) 1991-2019 Free Software Foundation, Inc.
   3
   4    This file is part of GNU Binutils.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  19    MA 02110-1301, USA.  */
  20 \f
  21 /*
  22    Bugs: GNU ar used to check file against filesystem in quick_update and
  23    replace operations (would check mtime). Doesn't warn when name truncated.
  24    No way to specify pos_end. Error messages should be more consistent.  */
  25
  26 #include "sysdep.h"
  27 #include "bfd.h"
  28 #include "libiberty.h"
  29 #include "progress.h"
  30 #include "getopt.h"
  31 #include "aout/ar.h"
  32 #include "bucomm.h"
  33 #include "arsup.h"
  34 #include "filenames.h"
  35 #include "binemul.h"
  36 #include "plugin-api.h"
  37 #include "plugin.h"
  38
  39 #ifdef __GO32___
  40 #define EXT_NAME_LEN 3          /* Bufflen of addition to name if it's MS-DOS.  */
  41 #else
  42 #define EXT_NAME_LEN 6          /* Ditto for *NIX.  */
  43 #endif
  44
  45 /* Static declarations.  */
  46
  47 static void mri_emul (void);
  48 static const char *normalize (const char *, bfd *);
  49 static void remove_output (void);
  50 static void map_over_members (bfd *, void (*)(bfd *), char **, int);
  51 static void print_contents (bfd * member);
  52 static void delete_members (bfd *, char **files_to_delete);
  53
  54 static void move_members (bfd *, char **files_to_move);
  55 static void replace_members
  56   (bfd *, char **files_to_replace, bfd_boolean quick);
  57 static void print_descr (bfd * abfd);
  58 static void write_archive (bfd *);
  59 static int  ranlib_only (const char *archname);
  60 static int  ranlib_touch (const char *archname);
  61 static void usage (int);
  62 \f
  63 /** Globals and flags.  */
  64
  65 static int mri_mode;
  66
  67 /* This flag distinguishes between ar and ranlib:
  68    1 means this is 'ranlib'; 0 means this is 'ar'.
  69    -1 means if we should use argv[0] to decide.  */
  70 extern int is_ranlib;
  71
  72 /* Nonzero means don't warn about creating the archive file if necessary.  */
  73 int silent_create = 0;
  74
  75 /* Nonzero means describe each action performed.  */
  76 int verbose = 0;
  77
  78 /* Nonzero means display offsets of files in the archive.  */
  79 int display_offsets = 0;
  80
  81 /* Nonzero means preserve dates of members when extracting them.  */
  82 int preserve_dates = 0;
  83
  84 /* Nonzero means don't replace existing members whose dates are more recent
  85    than the corresponding files.  */
  86 int newer_only = 0;
  87
  88 /* Controls the writing of an archive symbol table (in BSD: a __.SYMDEF
  89    member).  -1 means we've been explicitly asked to not write a symbol table;
  90    +1 means we've been explicitly asked to write it;
  91    0 is the default.
  92    Traditionally, the default in BSD has been to not write the table.
  93    However, for POSIX.2 compliance the default is now to write a symbol table
  94    if any of the members are object files.  */
  95 int write_armap = 0;
  96
  97 /* Operate in deterministic mode: write zero for timestamps, uids,
  98    and gids for archive members and the archive symbol table, and write
  99    consistent file modes.  */
 100 int deterministic = -1;                 /* Determinism indeterminate.  */
 101
 102 /* Nonzero means it's the name of an existing member; position new or moved
 103    files with respect to this one.  */
 104 char *posname = NULL;
 105
 106 /* Sez how to use `posname': pos_before means position before that member.
 107    pos_after means position after that member. pos_end means always at end.
 108    pos_default means default appropriately. For the latter two, `posname'
 109    should also be zero.  */
 110 enum pos
 111   {
 112     pos_default, pos_before, pos_after, pos_end
 113   } postype = pos_default;
 114
 115 enum operations
 116   {
 117     none = 0, del, replace, print_table,
 118     print_files, extract, move, quick_append
 119   } operation = none;
 120
 121 static bfd **
 122 get_pos_bfd (bfd **, enum pos, const char *);
 123
 124 /* For extract/delete only.  If COUNTED_NAME_MODE is TRUE, we only
 125    extract the COUNTED_NAME_COUNTER instance of that name.  */
 126 static bfd_boolean counted_name_mode = 0;
 127 static int counted_name_counter = 0;
 128
 129 /* Whether to truncate names of files stored in the archive.  */
 130 static bfd_boolean ar_truncate = FALSE;
 131
 132 /* Whether to use a full file name match when searching an archive.
 133    This is convenient for archives created by the Microsoft lib
 134    program.  */
 135 static bfd_boolean full_pathname = FALSE;
 136
 137 /* Whether to create a "thin" archive (symbol index only -- no files).  */
 138 static bfd_boolean make_thin_archive = FALSE;
 139
 140 static int show_version = 0;
 141
 142 static int show_help = 0;
 143
 144 #if BFD_SUPPORTS_PLUGINS
 145 static const char *plugin_target = "plugin";
 146 #else
 147 static const char *plugin_target = NULL;
 148 #endif
 149
 150 static const char *target = NULL;
 151
 152 #define OPTION_PLUGIN 201
 153 #define OPTION_TARGET 202
 154
 155 static struct option long_options[] =
 156 {
 157   {"help", no_argument, &show_help, 1},
 158   {"plugin", required_argument, NULL, OPTION_PLUGIN},
 159   {"target", required_argument, NULL, OPTION_TARGET},
 160   {"version", no_argument, &show_version, 1},
 161   {NULL, no_argument, NULL, 0}
 162 };
 163
 164 int interactive = 0;
 165
 166 static void
 167 mri_emul (void)
 168 {
 169   interactive = isatty (fileno (stdin));
 170   yyparse ();
 171 }
 172
 173 /* If COUNT is 0, then FUNCTION is called once on each entry.  If nonzero,
 174    COUNT is the length of the FILES chain; FUNCTION is called on each entry
 175    whose name matches one in FILES.  */
 176
 177 static void
 178 map_over_members (bfd *arch, void (*function)(bfd *), char **files, int count)
 179 {
 180   bfd *head;
 181   int match_count;
 182
 183   if (count == 0)
 184     {
 185       for (head = arch->archive_next; head; head = head->archive_next)
 186         {
 187           PROGRESS (1);
 188           function (head);
 189         }
 190       return;
 191     }
 192
 193   /* This may appear to be a baroque way of accomplishing what we want.
 194      However we have to iterate over the filenames in order to notice where
 195      a filename is requested but does not exist in the archive.  Ditto
 196      mapping over each file each time -- we want to hack multiple
 197      references.  */
 198
 199   for (head = arch->archive_next; head; head = head->archive_next)
 200     head->archive_pass = 0;
 201
 202   for (; count > 0; files++, count--)
 203     {
 204       bfd_boolean found = FALSE;
 205
 206       match_count = 0;
 207       for (head = arch->archive_next; head; head = head->archive_next)
 208         {
 209           const char * filename;
 210
 211           PROGRESS (1);
 212           /* PR binutils/15796: Once an archive element has been matched
 213              do not match it again.  If the user provides multiple same-named
 214              parameters on the command line their intent is to match multiple
 215              same-named entries in the archive, not the same entry multiple
 216              times.  */
 217           if (head->archive_pass)
 218             continue;
 219
 220           filename = head->filename;
 221           if (filename == NULL)
 222             {
 223               /* Some archive formats don't get the filenames filled in
 224                  until the elements are opened.  */
 225               struct stat buf;
 226               bfd_stat_arch_elt (head, &buf);
 227             }
 228           else if (bfd_is_thin_archive (arch))
 229             {
 230               /* Thin archives store full pathnames.  Need to normalize.  */
 231               filename = normalize (filename, arch);
 232             }
 233
 234           if (filename != NULL
 235               && !FILENAME_CMP (normalize (*files, arch), filename))
 236             {
 237               ++match_count;
 238               if (counted_name_mode
 239                   && match_count != counted_name_counter)
 240                 {
 241                   /* Counting, and didn't match on count; go on to the
 242                      next one.  */
 243                   continue;
 244                 }
 245
 246               found = TRUE;
 247               function (head);
 248               head->archive_pass = 1;
 249               /* PR binutils/15796: Once a file has been matched, do not
 250                  match any more same-named files in the archive.  If the
 251                  user does want to match multiple same-name files in an
 252                  archive they should provide multiple same-name parameters
 253                  to the ar command.  */
 254               break;
 255             }
 256         }
 257
 258       if (!found)
 259         /* xgettext:c-format */
 260         fprintf (stderr, _("no entry %s in archive\n"), *files);
 261     }
 262 }
 263 \f
 264 bfd_boolean operation_alters_arch = FALSE;
 265
 266 static void
 267 usage (int help)
 268 {
 269   FILE *s;
 270
 271 #if BFD_SUPPORTS_PLUGINS
 272   /* xgettext:c-format */
 273   const char *command_line
 274     = _("Usage: %s [emulation options] [-]{dmpqrstx}[abcDfilMNoOPsSTuvV]"
 275         " [--plugin <name>] [member-name] [count] archive-file file...\n");
 276
 277 #else
 278   /* xgettext:c-format */
 279   const char *command_line
 280     = _("Usage: %s [emulation options] [-]{dmpqrstx}[abcDfilMNoOPsSTuvV]"
 281         " [member-name] [count] archive-file file...\n");
 282 #endif
 283   s = help ? stdout : stderr;
 284
 285   fprintf (s, command_line, program_name);
 286
 287   /* xgettext:c-format */
 288   fprintf (s, _("       %s -M [<mri-script]\n"), program_name);
 289   fprintf (s, _(" commands:\n"));
 290   fprintf (s, _("  d            - delete file(s) from the archive\n"));
 291   fprintf (s, _("  m[ab]        - move file(s) in the archive\n"));
 292   fprintf (s, _("  p            - print file(s) found in the archive\n"));
 293   fprintf (s, _("  q[f]         - quick append file(s) to the archive\n"));
 294   fprintf (s, _("  r[ab][f][u]  - replace existing or insert new file(s) into the archive\n"));
 295   fprintf (s, _("  s            - act as ranlib\n"));
 296   fprintf (s, _("  t[O][v]      - display contents of the archive\n"));
 297   fprintf (s, _("  x[o]         - extract file(s) from the archive\n"));
 298   fprintf (s, _(" command specific modifiers:\n"));
 299   fprintf (s, _("  [a]          - put file(s) after [member-name]\n"));
 300   fprintf (s, _("  [b]          - put file(s) before [member-name] (same as [i])\n"));
 301   if (DEFAULT_AR_DETERMINISTIC)
 302     {
 303       fprintf (s, _("\
 304   [D]          - use zero for timestamps and uids/gids (default)\n"));
 305       fprintf (s, _("\
 306   [U]          - use actual timestamps and uids/gids\n"));
 307     }
 308   else
 309     {
 310       fprintf (s, _("\
 311   [D]          - use zero for timestamps and uids/gids\n"));
 312       fprintf (s, _("\
 313   [U]          - use actual timestamps and uids/gids (default)\n"));
 314     }
 315   fprintf (s, _("  [N]          - use instance [count] of name\n"));
 316   fprintf (s, _("  [f]          - truncate inserted file names\n"));
 317   fprintf (s, _("  [P]          - use full path names when matching\n"));
 318   fprintf (s, _("  [o]          - preserve original dates\n"));
 319   fprintf (s, _("  [O]          - display offsets of files in the archive\n"));
 320   fprintf (s, _("  [u]          - only replace files that are newer than current archive contents\n"));
 321   fprintf (s, _(" generic modifiers:\n"));
 322   fprintf (s, _("  [c]          - do not warn if the library had to be created\n"));
 323   fprintf (s, _("  [s]          - create an archive index (cf. ranlib)\n"));
 324   fprintf (s, _("  [S]          - do not build a symbol table\n"));
 325   fprintf (s, _("  [T]          - make a thin archive\n"));
 326   fprintf (s, _("  [v]          - be verbose\n"));
 327   fprintf (s, _("  [V]          - display the version number\n"));
 328   fprintf (s, _("  @<file>      - read options from <file>\n"));
 329   fprintf (s, _("  --target=BFDNAME - specify the target object format as BFDNAME\n"));
 330 #if BFD_SUPPORTS_PLUGINS
 331   fprintf (s, _(" optional:\n"));
 332   fprintf (s, _("  --plugin <p> - load the specified plugin\n"));
 333 #endif
 334
 335   ar_emul_usage (s);
 336
 337   list_supported_targets (program_name, s);
 338
 339   if (REPORT_BUGS_TO[0] && help)
 340     fprintf (s, _("Report bugs to %s\n"), REPORT_BUGS_TO);
 341
 342   xexit (help ? 0 : 1);
 343 }
 344
 345 static void
 346 ranlib_usage (int help)
 347 {
 348   FILE *s;
 349
 350   s = help ? stdout : stderr;
 351
 352   /* xgettext:c-format */
 353   fprintf (s, _("Usage: %s [options] archive\n"), program_name);
 354   fprintf (s, _(" Generate an index to speed access to archives\n"));
 355   fprintf (s, _(" The options are:\n\
 356   @<file>                      Read options from <file>\n"));
 357 #if BFD_SUPPORTS_PLUGINS
 358   fprintf (s, _("\
 359   --plugin <name>              Load the specified plugin\n"));
 360 #endif
 361   if (DEFAULT_AR_DETERMINISTIC)
 362     fprintf (s, _("\
 363   -D                           Use zero for symbol map timestamp (default)\n\
 364   -U                           Use an actual symbol map timestamp\n"));
 365   else
 366     fprintf (s, _("\
 367   -D                           Use zero for symbol map timestamp\n\
 368   -U                           Use actual symbol map timestamp (default)\n"));
 369   fprintf (s, _("\
 370   -t                           Update the archive's symbol map timestamp\n\
 371   -h --help                    Print this help message\n\
 372   -v --version                 Print version information\n"));
 373
 374   list_supported_targets (program_name, s);
 375
 376   if (REPORT_BUGS_TO[0] && help)
 377     fprintf (s, _("Report bugs to %s\n"), REPORT_BUGS_TO);
 378
 379   xexit (help ? 0 : 1);
 380 }
 381
 382 /* Normalize a file name specified on the command line into a file
 383    name which we will use in an archive.  */
 384
 385 static const char *
 386 normalize (const char *file, bfd *abfd)
 387 {
 388   const char *filename;
 389
 390   if (full_pathname)
 391     return file;
 392
 393   filename = lbasename (file);
 394
 395   if (ar_truncate
 396       && abfd != NULL
 397       && strlen (filename) > abfd->xvec->ar_max_namelen)
 398     {
 399       char *s;
 400
 401       /* Space leak.  */
 402       s = (char *) xmalloc (abfd->xvec->ar_max_namelen + 1);
 403       memcpy (s, filename, abfd->xvec->ar_max_namelen);
 404       s[abfd->xvec->ar_max_namelen] = '\0';
 405       filename = s;
 406     }
 407
 408   return filename;
 409 }
 410
 411 /* Remove any output file.  This is only called via xatexit.  */
 412
 413 static const char *output_filename = NULL;
 414 static FILE *output_file = NULL;
 415 static bfd *output_bfd = NULL;
 416
 417 static void
 418 remove_output (void)
 419 {
 420   if (output_filename != NULL)
 421     {
 422       if (output_bfd != NULL)
 423         bfd_cache_close (output_bfd);
 424       if (output_file != NULL)
 425         fclose (output_file);
 426       unlink_if_ordinary (output_filename);
 427     }
 428 }
 429
 430 static char **
 431 decode_options (int argc, char **argv)
 432 {
 433   int c;
 434
 435   /* Convert old-style ar call by exploding option element and rearranging
 436      options accordingly.  */
 437
 438  restart:
 439   if (argc > 1 && argv[1][0] != '-')
 440     {
 441       int new_argc;             /* argc value for rearranged arguments */
 442       char **new_argv;          /* argv value for rearranged arguments */
 443       char *const *in;          /* cursor into original argv */
 444       char **out;               /* cursor into rearranged argv */
 445       const char *letter;       /* cursor into old option letters */
 446       char buffer[3];           /* constructed option buffer */
 447
 448       /* Initialize a constructed option.  */
 449
 450       buffer[0] = '-';
 451       buffer[2] = '\0';
 452
 453       /* Allocate a new argument array, and copy program name in it.  */
 454
 455       new_argc = argc - 1 + strlen (argv[1]);
 456       new_argv = xmalloc ((new_argc + 1) * sizeof (*argv));
 457       in = argv;
 458       out = new_argv;
 459       *out++ = *in++;
 460
 461       /* Copy each old letter option as a separate option.  */
 462
 463       for (letter = *in++; *letter; letter++)
 464         {
 465           buffer[1] = *letter;
 466           *out++ = xstrdup (buffer);
 467         }
 468
 469       /* Copy all remaining options.  */
 470
 471       while (in < argv + argc)
 472         *out++ = *in++;
 473       *out = NULL;
 474
 475       /* Replace the old option list by the new one.  */
 476
 477       argc = new_argc;
 478       argv = new_argv;
 479     }
 480
 481   while ((c = getopt_long (argc, argv, "hdmpqrtxlcoOVsSuvabiMNfPTDU",
 482                            long_options, NULL)) != EOF)
 483     {
 484       switch (c)
 485         {
 486         case 'd':
 487         case 'm':
 488         case 'p':
 489         case 'q':
 490         case 'r':
 491         case 't':
 492         case 'x':
 493           if (operation != none)
 494             fatal (_("two different operation options specified"));
 495           break;
 496         }
 497
 498       switch (c)
 499         {
 500         case 'h':
 501           show_help = 1;
 502           break;
 503         case 'd':
 504           operation = del;
 505           operation_alters_arch = TRUE;
 506           break;
 507         case 'm':
 508           operation = move;
 509           operation_alters_arch = TRUE;
 510           break;
 511         case 'p':
 512           operation = print_files;
 513           break;
 514         case 'q':
 515           operation = quick_append;
 516           operation_alters_arch = TRUE;
 517           break;
 518         case 'r':
 519           operation = replace;
 520           operation_alters_arch = TRUE;
 521           break;
 522         case 't':
 523           operation = print_table;
 524           break;
 525         case 'x':
 526           operation = extract;
 527           break;
 528         case 'l':
 529           break;
 530         case 'c':
 531           silent_create = 1;
 532           break;
 533         case 'o':
 534           preserve_dates = 1;
 535           break;
 536         case 'O':
 537           display_offsets = 1;
 538           break;
 539         case 'V':
 540           show_version = TRUE;
 541           break;
 542         case 's':
 543           write_armap = 1;
 544           break;
 545         case 'S':
 546           write_armap = -1;
 547           break;
 548         case 'u':
 549           newer_only = 1;
 550           break;
 551         case 'v':
 552           verbose = 1;
 553           break;
 554         case 'a':
 555           postype = pos_after;
 556           break;
 557         case 'b':
 558           postype = pos_before;
 559           break;
 560         case 'i':
 561           postype = pos_before;
 562           break;
 563         case 'M':
 564           mri_mode = 1;
 565           break;
 566         case 'N':
 567           counted_name_mode = TRUE;
 568           break;
 569         case 'f':
 570           ar_truncate = TRUE;
 571           break;
 572         case 'P':
 573           full_pathname = TRUE;
 574           break;
 575         case 'T':
 576           make_thin_archive = TRUE;
 577           break;
 578         case 'D':
 579           deterministic = TRUE;
 580           break;
 581         case 'U':
 582           deterministic = FALSE;
 583           break;
 584         case OPTION_PLUGIN:
 585 #if BFD_SUPPORTS_PLUGINS
 586           bfd_plugin_set_plugin (optarg);
 587 #else
 588           fprintf (stderr, _("sorry - this program has been built without plugin support\n"));
 589           xexit (1);
 590 #endif
 591           break;
 592         case OPTION_TARGET:
 593           target = optarg;
 594           break;
 595         case 0:         /* A long option that just sets a flag.  */
 596           break;
 597         default:
 598           usage (0);
 599         }
 600     }
 601
 602   /* PR 13256: Allow for the possibility that the first command line option
 603      started with a dash (eg --plugin) but then the following option(s) are
 604      old style, non-dash-prefixed versions.  */
 605   if (operation == none && write_armap != 1 && !mri_mode
 606       && optind > 0 && optind < argc)
 607     {
 608       argv += (optind - 1);
 609       argc -= (optind - 1);
 610       optind = 0;
 611       goto restart;
 612     }
 613
 614   return &argv[optind];
 615 }
 616
 617 /* If neither -D nor -U was specified explicitly,
 618    then use the configured default.  */
 619 static void
 620 default_deterministic (void)
 621 {
 622   if (deterministic < 0)
 623     deterministic = DEFAULT_AR_DETERMINISTIC;
 624 }
 625
 626 static void
 627 ranlib_main (int argc, char **argv)
 628 {
 629   int arg_index, status = 0;
 630   bfd_boolean touch = FALSE;
 631   int c;
 632
 633   while ((c = getopt_long (argc, argv, "DhHUvVt", long_options, NULL)) != EOF)
 634     {
 635       switch (c)
 636         {
 637         case 'D':
 638           deterministic = TRUE;
 639           break;
 640         case 'U':
 641           deterministic = FALSE;
 642           break;
 643         case 'h':
 644         case 'H':
 645           show_help = 1;
 646           break;
 647         case 't':
 648           touch = TRUE;
 649           break;
 650         case 'v':
 651         case 'V':
 652           show_version = 1;
 653           break;
 654
 655           /* PR binutils/13493: Support plugins.  */
 656         case OPTION_PLUGIN:
 657 #if BFD_SUPPORTS_PLUGINS
 658           bfd_plugin_set_plugin (optarg);
 659 #else
 660           fprintf (stderr, _("sorry - this program has been built without plugin support\n"));
 661           xexit (1);
 662 #endif
 663           break;
 664         }
 665     }
 666
 667   if (argc < 2)
 668     ranlib_usage (0);
 669
 670   if (show_help)
 671     ranlib_usage (1);
 672
 673   if (show_version)
 674     print_version ("ranlib");
 675
 676   default_deterministic ();
 677
 678   arg_index = optind;
 679
 680   while (arg_index < argc)
 681     {
 682       if (! touch)
 683         status |= ranlib_only (argv[arg_index]);
 684       else
 685         status |= ranlib_touch (argv[arg_index]);
 686       ++arg_index;
 687     }
 688
 689   xexit (status);
 690 }
 691
 692 int main (int, char **);
 693
 694 int
 695 main (int argc, char **argv)
 696 {
 697   int arg_index;
 698   char **files;
 699   int file_count;
 700   char *inarch_filename;
 701   int i;
 702
 703 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
 704   setlocale (LC_MESSAGES, "");
 705 #endif
 706 #if defined (HAVE_SETLOCALE)
 707   setlocale (LC_CTYPE, "");
 708 #endif
 709   bindtextdomain (PACKAGE, LOCALEDIR);
 710   textdomain (PACKAGE);
 711
 712   program_name = argv[0];
 713   xmalloc_set_program_name (program_name);
 714   bfd_set_error_program_name (program_name);
 715 #if BFD_SUPPORTS_PLUGINS
 716   bfd_plugin_set_program_name (program_name);
 717 #endif
 718
 719   expandargv (&argc, &argv);
 720
 721   if (is_ranlib < 0)
 722     {
 723       const char *temp = lbasename (program_name);
 724
 725       if (strlen (temp) >= 6
 726           && FILENAME_CMP (temp + strlen (temp) - 6, "ranlib") == 0)
 727         is_ranlib = 1;
 728       else
 729         is_ranlib = 0;
 730     }
 731
 732   START_PROGRESS (program_name, 0);
 733
 734   if (bfd_init () != BFD_INIT_MAGIC)
 735     fatal (_("fatal error: libbfd ABI mismatch"));
 736   set_default_bfd_target ();
 737
 738   xatexit (remove_output);
 739
 740   for (i = 1; i < argc; i++)
 741     if (! ar_emul_parse_arg (argv[i]))
 742       break;
 743   argv += (i - 1);
 744   argc -= (i - 1);
 745
 746   if (is_ranlib)
 747     ranlib_main (argc, argv);
 748
 749   if (argc < 2)
 750     usage (0);
 751
 752   argv = decode_options (argc, argv);
 753
 754   if (show_help)
 755     usage (1);
 756
 757   if (show_version)
 758     print_version ("ar");
 759
 760   arg_index = 0;
 761
 762   if (mri_mode)
 763     {
 764       default_deterministic ();
 765       mri_emul ();
 766     }
 767   else
 768     {
 769       bfd *arch;
 770
 771       /* Fail if no files are specified on the command line.
 772          (But not for MRI mode which allows for reading arguments
 773          and filenames from stdin).  */
 774       if (argv[arg_index] == NULL)
 775         usage (0);
 776
 777       /* We don't use do_quick_append any more.  Too many systems
 778          expect ar to always rebuild the symbol table even when q is
 779          used.  */
 780
 781       /* We can't write an armap when using ar q, so just do ar r
 782          instead.  */
 783       if (operation == quick_append && write_armap)
 784         operation = replace;
 785
 786       if ((operation == none || operation == print_table)
 787           && write_armap == 1)
 788         xexit (ranlib_only (argv[arg_index]));
 789
 790       if (operation == none)
 791         fatal (_("no operation specified"));
 792
 793       if (newer_only && operation != replace)
 794         fatal (_("`u' is only meaningful with the `r' option."));
 795
 796       if (newer_only && deterministic > 0)
 797         fatal (_("`u' is not meaningful with the `D' option."));
 798
 799       if (newer_only && deterministic < 0 && DEFAULT_AR_DETERMINISTIC)
 800         non_fatal (_("\
 801 `u' modifier ignored since `D' is the default (see `U')"));
 802
 803       default_deterministic ();
 804
 805       if (postype != pos_default)
 806         {
 807           posname = argv[arg_index++];
 808           if (posname == NULL)
 809             fatal (_("missing position arg."));
 810         }
 811
 812       if (counted_name_mode)
 813         {
 814           if (operation != extract && operation != del)
 815             fatal (_("`N' is only meaningful with the `x' and `d' options."));
 816           if (argv[arg_index] == NULL)
 817             fatal (_("`N' missing value."));
 818           counted_name_counter = atoi (argv[arg_index++]);
 819           if (counted_name_counter <= 0)
 820             fatal (_("Value for `N' must be positive."));
 821         }
 822
 823       inarch_filename = argv[arg_index++];
 824       if (inarch_filename == NULL)
 825         usage (0);
 826
 827       for (file_count = 0; argv[arg_index + file_count] != NULL; file_count++)
 828         continue;
 829
 830       files = (file_count > 0) ? argv + arg_index : NULL;
 831
 832       arch = open_inarch (inarch_filename,
 833                           files == NULL ? (char *) NULL : files[0]);
 834
 835       if (operation == extract && bfd_is_thin_archive (arch))
 836         fatal (_("`x' cannot be used on thin archives."));
 837
 838       switch (operation)
 839         {
 840         case print_table:
 841           map_over_members (arch, print_descr, files, file_count);
 842           break;
 843
 844         case print_files:
 845           map_over_members (arch, print_contents, files, file_count);
 846           break;
 847
 848         case extract:
 849           map_over_members (arch, extract_file, files, file_count);
 850           break;
 851
 852         case del:
 853           if (files != NULL)
 854             delete_members (arch, files);
 855           else
 856             output_filename = NULL;
 857           break;
 858
 859         case move:
 860           /* PR 12558: Creating and moving at the same time does
 861              not make sense.  Just create the archive instead.  */
 862           if (! silent_create)
 863             {
 864               if (files != NULL)
 865                 move_members (arch, files);
 866               else
 867                 output_filename = NULL;
 868               break;
 869             }
 870           /* Fall through.  */
 871
 872         case replace:
 873         case quick_append:
 874           if (files != NULL || write_armap > 0)
 875             replace_members (arch, files, operation == quick_append);
 876           else
 877             output_filename = NULL;
 878           break;
 879
 880           /* Shouldn't happen! */
 881         default:
 882           /* xgettext:c-format */
 883           fatal (_("internal error -- this option not implemented"));
 884         }
 885     }
 886
 887   END_PROGRESS (program_name);
 888
 889   xexit (0);
 890   return 0;
 891 }
 892
 893 bfd *
 894 open_inarch (const char *archive_filename, const char *file)
 895 {
 896   bfd **last_one;
 897   bfd *next_one;
 898   struct stat sbuf;
 899   bfd *arch;
 900   char **matching;
 901
 902   bfd_set_error (bfd_error_no_error);
 903
 904   if (target == NULL)
 905     target = plugin_target;
 906
 907   if (stat (archive_filename, &sbuf) != 0)
 908     {
 909 #if !defined(__GO32__) || defined(__DJGPP__)
 910
 911       /* FIXME: I don't understand why this fragment was ifndef'ed
 912          away for __GO32__; perhaps it was in the days of DJGPP v1.x.
 913          stat() works just fine in v2.x, so I think this should be
 914          removed.  For now, I enable it for DJGPP v2. -- EZ.  */
 915
 916       /* KLUDGE ALERT! Temporary fix until I figger why
 917          stat() is wrong ... think it's buried in GO32's IDT - Jax */
 918       if (errno != ENOENT)
 919         bfd_fatal (archive_filename);
 920 #endif
 921
 922       if (!operation_alters_arch)
 923         {
 924           fprintf (stderr, "%s: ", program_name);
 925           perror (archive_filename);
 926           maybequit ();
 927           return NULL;
 928         }
 929
 930       /* If the target isn't set, try to figure out the target to use
 931          for the archive from the first object on the list.  */
 932       if (target == NULL && file != NULL)
 933         {
 934           bfd *obj;
 935
 936           obj = bfd_openr (file, target);
 937           if (obj != NULL)
 938             {
 939               if (bfd_check_format (obj, bfd_object))
 940                 target = bfd_get_target (obj);
 941               (void) bfd_close (obj);
 942             }
 943         }
 944
 945       /* Create an empty archive.  */
 946       arch = bfd_openw (archive_filename, target);
 947       if (arch == NULL
 948           || ! bfd_set_format (arch, bfd_archive)
 949           || ! bfd_close (arch))
 950         bfd_fatal (archive_filename);
 951       else if (!silent_create)
 952         non_fatal (_("creating %s"), archive_filename);
 953
 954       /* If we die creating a new archive, don't leave it around.  */
 955       output_filename = archive_filename;
 956     }
 957
 958   arch = bfd_openr (archive_filename, target);
 959   if (arch == NULL)
 960     {
 961     bloser:
 962       bfd_fatal (archive_filename);
 963     }
 964
 965   if (! bfd_check_format_matches (arch, bfd_archive, &matching))
 966     {
 967       bfd_nonfatal (archive_filename);
 968       if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
 969         {
 970           list_matching_formats (matching);
 971           free (matching);
 972         }
 973       xexit (1);
 974     }
 975
 976   if ((operation == replace || operation == quick_append)
 977       && bfd_openr_next_archived_file (arch, NULL) != NULL)
 978     {
 979       /* PR 15140: Catch attempts to convert a normal
 980          archive into a thin archive or vice versa.  */
 981       if (make_thin_archive && ! bfd_is_thin_archive (arch))
 982         {
 983           fatal (_("Cannot convert existing library %s to thin format"),
 984                  bfd_get_filename (arch));
 985           goto bloser;
 986         }
 987       else if (! make_thin_archive && bfd_is_thin_archive (arch))
 988         {
 989           fatal (_("Cannot convert existing thin library %s to normal format"),
 990                  bfd_get_filename (arch));
 991           goto bloser;
 992         }
 993     }
 994
 995   last_one = &(arch->archive_next);
 996   /* Read all the contents right away, regardless.  */
 997   for (next_one = bfd_openr_next_archived_file (arch, NULL);
 998        next_one;
 999        next_one = bfd_openr_next_archived_file (arch, next_one))
1000     {
1001       PROGRESS (1);
1002       *last_one = next_one;
1003       last_one = &next_one->archive_next;
1004     }
1005   *last_one = (bfd *) NULL;
1006   if (bfd_get_error () != bfd_error_no_more_archived_files)
1007     goto bloser;
1008   return arch;
1009 }
1010
1011 static void
1012 print_contents (bfd *abfd)
1013 {
1014   bfd_size_type ncopied = 0;
1015   bfd_size_type size;
1016   char *cbuf = (char *) xmalloc (BUFSIZE);
1017   struct stat buf;
1018
1019   if (bfd_stat_arch_elt (abfd, &buf) != 0)
1020     /* xgettext:c-format */
1021     fatal (_("internal stat error on %s"), bfd_get_filename (abfd));
1022
1023   if (verbose)
1024     printf ("\n<%s>\n\n", bfd_get_filename (abfd));
1025
1026   bfd_seek (abfd, (file_ptr) 0, SEEK_SET);
1027
1028   size = buf.st_size;
1029   while (ncopied < size)
1030     {
1031       bfd_size_type nread;
1032       bfd_size_type tocopy = size - ncopied;
1033
1034       if (tocopy > BUFSIZE)
1035         tocopy = BUFSIZE;
1036
1037       nread = bfd_bread (cbuf, tocopy, abfd);
1038       if (nread != tocopy)
1039         /* xgettext:c-format */
1040         fatal (_("%s is not a valid archive"),
1041                bfd_get_filename (abfd->my_archive));
1042
1043       /* fwrite in mingw32 may return int instead of bfd_size_type. Cast the
1044          return value to bfd_size_type to avoid comparison between signed and
1045          unsigned values.  */
1046       if ((bfd_size_type) fwrite (cbuf, 1, nread, stdout) != nread)
1047         fatal ("stdout: %s", strerror (errno));
1048       ncopied += tocopy;
1049     }
1050   free (cbuf);
1051 }
1052
1053 /* Extract a member of the archive into its own file.
1054
1055    We defer opening the new file until after we have read a BUFSIZ chunk of the
1056    old one, since we know we have just read the archive header for the old
1057    one.  Since most members are shorter than BUFSIZ, this means we will read
1058    the old header, read the old data, write a new inode for the new file, and
1059    write the new data, and be done. This 'optimization' is what comes from
1060    sitting next to a bare disk and hearing it every time it seeks.  -- Gnu
1061    Gilmore  */
1062
1063 void
1064 extract_file (bfd *abfd)
1065 {
1066   FILE *ostream;
1067   char *cbuf = (char *) xmalloc (BUFSIZE);
1068   bfd_size_type nread, tocopy;
1069   bfd_size_type ncopied = 0;
1070   bfd_size_type size;
1071   struct stat buf;
1072
1073   /* PR binutils/17533: Do not allow directory traversal
1074      outside of the current directory tree.  */
1075   if (! is_valid_archive_path (bfd_get_filename (abfd)))
1076     {
1077       non_fatal (_("illegal pathname found in archive member: %s"),
1078                  bfd_get_filename (abfd));
1079       free (cbuf);
1080       return;
1081     }
1082
1083   if (bfd_stat_arch_elt (abfd, &buf) != 0)
1084     /* xgettext:c-format */
1085     fatal (_("internal stat error on %s"), bfd_get_filename (abfd));
1086   size = buf.st_size;
1087
1088   if (verbose)
1089     printf ("x - %s\n", bfd_get_filename (abfd));
1090
1091   bfd_seek (abfd, (file_ptr) 0, SEEK_SET);
1092
1093   ostream = NULL;
1094   if (size == 0)
1095     {
1096       /* Seems like an abstraction violation, eh?  Well it's OK! */
1097       output_filename = bfd_get_filename (abfd);
1098
1099       ostream = fopen (bfd_get_filename (abfd), FOPEN_WB);
1100       if (ostream == NULL)
1101         {
1102           perror (bfd_get_filename (abfd));
1103           xexit (1);
1104         }
1105
1106       output_file = ostream;
1107     }
1108   else
1109     while (ncopied < size)
1110       {
1111         tocopy = size - ncopied;
1112         if (tocopy > BUFSIZE)
1113           tocopy = BUFSIZE;
1114
1115         nread = bfd_bread (cbuf, tocopy, abfd);
1116         if (nread != tocopy)
1117           /* xgettext:c-format */
1118           fatal (_("%s is not a valid archive"),
1119                  bfd_get_filename (abfd->my_archive));
1120
1121         /* See comment above; this saves disk arm motion */
1122         if (ostream == NULL)
1123           {
1124             /* Seems like an abstraction violation, eh?  Well it's OK! */
1125             output_filename = bfd_get_filename (abfd);
1126
1127             ostream = fopen (bfd_get_filename (abfd), FOPEN_WB);
1128             if (ostream == NULL)
1129               {
1130                 perror (bfd_get_filename (abfd));
1131                 xexit (1);
1132               }
1133
1134             output_file = ostream;
1135           }
1136
1137         /* fwrite in mingw32 may return int instead of bfd_size_type. Cast
1138            the return value to bfd_size_type to avoid comparison between
1139            signed and unsigned values.  */
1140         if ((bfd_size_type) fwrite (cbuf, 1, nread, ostream) != nread)
1141           fatal ("%s: %s", output_filename, strerror (errno));
1142         ncopied += tocopy;
1143       }
1144
1145   if (ostream != NULL)
1146     fclose (ostream);
1147
1148   output_file = NULL;
1149   output_filename = NULL;
1150
1151   chmod (bfd_get_filename (abfd), buf.st_mode);
1152
1153   if (preserve_dates)
1154     {
1155       /* Set access time to modification time.  Only st_mtime is
1156          initialized by bfd_stat_arch_elt.  */
1157       buf.st_atime = buf.st_mtime;
1158       set_times (bfd_get_filename (abfd), &buf);
1159     }
1160
1161   free (cbuf);
1162 }
1163
1164 static void
1165 write_archive (bfd *iarch)
1166 {
1167   bfd *obfd;
1168   char *old_name, *new_name;
1169   bfd *contents_head = iarch->archive_next;
1170
1171   old_name = (char *) xmalloc (strlen (bfd_get_filename (iarch)) + 1);
1172   strcpy (old_name, bfd_get_filename (iarch));
1173   new_name = make_tempname (old_name);
1174
1175   if (new_name == NULL)
1176     bfd_fatal (_("could not create temporary file whilst writing archive"));
1177
1178   output_filename = new_name;
1179
1180   obfd = bfd_openw (new_name, bfd_get_target (iarch));
1181
1182   if (obfd == NULL)
1183     bfd_fatal (old_name);
1184
1185   output_bfd = obfd;
1186
1187   bfd_set_format (obfd, bfd_archive);
1188
1189   /* Request writing the archive symbol table unless we've
1190      been explicitly requested not to.  */
1191   obfd->has_armap = write_armap >= 0;
1192
1193   if (ar_truncate)
1194     {
1195       /* This should really use bfd_set_file_flags, but that rejects
1196          archives.  */
1197       obfd->flags |= BFD_TRADITIONAL_FORMAT;
1198     }
1199
1200   if (deterministic)
1201     obfd->flags |= BFD_DETERMINISTIC_OUTPUT;
1202
1203   if (make_thin_archive || bfd_is_thin_archive (iarch))
1204     bfd_is_thin_archive (obfd) = 1;
1205
1206   if (!bfd_set_archive_head (obfd, contents_head))
1207     bfd_fatal (old_name);
1208
1209   if (!bfd_close (obfd))
1210     bfd_fatal (old_name);
1211
1212   output_bfd = NULL;
1213   output_filename = NULL;
1214
1215   /* We don't care if this fails; we might be creating the archive.  */
1216   bfd_close (iarch);
1217
1218   if (smart_rename (new_name, old_name, 0) != 0)
1219     xexit (1);
1220   free (old_name);
1221   free (new_name);
1222 }
1223
1224 /* Return a pointer to the pointer to the entry which should be rplacd'd
1225    into when altering.  DEFAULT_POS should be how to interpret pos_default,
1226    and should be a pos value.  */
1227
1228 static bfd **
1229 get_pos_bfd (bfd **contents, enum pos default_pos, const char *default_posname)
1230 {
1231   bfd **after_bfd = contents;
1232   enum pos realpos;
1233   const char *realposname;
1234
1235   if (postype == pos_default)
1236     {
1237       realpos = default_pos;
1238       realposname = default_posname;
1239     }
1240   else
1241     {
1242       realpos = postype;
1243       realposname = posname;
1244     }
1245
1246   if (realpos == pos_end)
1247     {
1248       while (*after_bfd)
1249         after_bfd = &((*after_bfd)->archive_next);
1250     }
1251   else
1252     {
1253       for (; *after_bfd; after_bfd = &(*after_bfd)->archive_next)
1254         if (FILENAME_CMP ((*after_bfd)->filename, realposname) == 0)
1255           {
1256             if (realpos == pos_after)
1257               after_bfd = &(*after_bfd)->archive_next;
1258             break;
1259           }
1260     }
1261   return after_bfd;
1262 }
1263
1264 static void
1265 delete_members (bfd *arch, char **files_to_delete)
1266 {
1267   bfd **current_ptr_ptr;
1268   bfd_boolean found;
1269   bfd_boolean something_changed = FALSE;
1270   int match_count;
1271
1272   for (; *files_to_delete != NULL; ++files_to_delete)
1273     {
1274       /* In a.out systems, the armap is optional.  It's also called
1275          __.SYMDEF.  So if the user asked to delete it, we should remember
1276          that fact. This isn't quite right for COFF systems (where
1277          __.SYMDEF might be regular member), but it's very unlikely
1278          to be a problem.  FIXME */
1279
1280       if (!strcmp (*files_to_delete, "__.SYMDEF"))
1281         {
1282           arch->has_armap = FALSE;
1283           write_armap = -1;
1284           continue;
1285         }
1286
1287       found = FALSE;
1288       match_count = 0;
1289       current_ptr_ptr = &(arch->archive_next);
1290       while (*current_ptr_ptr)
1291         {
1292           if (FILENAME_CMP (normalize (*files_to_delete, arch),
1293                             (*current_ptr_ptr)->filename) == 0)
1294             {
1295               ++match_count;
1296               if (counted_name_mode
1297                   && match_count != counted_name_counter)
1298                 {
1299                   /* Counting, and didn't match on count; go on to the
1300                      next one.  */
1301                 }
1302               else
1303                 {
1304                   found = TRUE;
1305                   something_changed = TRUE;
1306                   if (verbose)
1307                     printf ("d - %s\n",
1308                             *files_to_delete);
1309                   *current_ptr_ptr = ((*current_ptr_ptr)->archive_next);
1310                   goto next_file;
1311                 }
1312             }
1313
1314           current_ptr_ptr = &((*current_ptr_ptr)->archive_next);
1315         }
1316
1317       if (verbose && !found)
1318         {
1319           /* xgettext:c-format */
1320           printf (_("No member named `%s'\n"), *files_to_delete);
1321         }
1322     next_file:
1323       ;
1324     }
1325
1326   if (something_changed)
1327     write_archive (arch);
1328   else
1329     output_filename = NULL;
1330 }
1331
1332
1333 /* Reposition existing members within an archive */
1334
1335 static void
1336 move_members (bfd *arch, char **files_to_move)
1337 {
1338   bfd **after_bfd;              /* New entries go after this one */
1339   bfd **current_ptr_ptr;        /* cdr pointer into contents */
1340
1341   for (; *files_to_move; ++files_to_move)
1342     {
1343       current_ptr_ptr = &(arch->archive_next);
1344       while (*current_ptr_ptr)
1345         {
1346           bfd *current_ptr = *current_ptr_ptr;
1347           if (FILENAME_CMP (normalize (*files_to_move, arch),
1348                             current_ptr->filename) == 0)
1349             {
1350               /* Move this file to the end of the list - first cut from
1351                  where it is.  */
1352               bfd *link_bfd;
1353               *current_ptr_ptr = current_ptr->archive_next;
1354
1355               /* Now glue to end */
1356               after_bfd = get_pos_bfd (&arch->archive_next, pos_end, NULL);
1357               link_bfd = *after_bfd;
1358               *after_bfd = current_ptr;
1359               current_ptr->archive_next = link_bfd;
1360
1361               if (verbose)
1362                 printf ("m - %s\n", *files_to_move);
1363
1364               goto next_file;
1365             }
1366
1367           current_ptr_ptr = &((*current_ptr_ptr)->archive_next);
1368         }
1369       /* xgettext:c-format */
1370       fatal (_("no entry %s in archive %s!"), *files_to_move, arch->filename);
1371
1372     next_file:;
1373     }
1374
1375   write_archive (arch);
1376 }
1377
1378 /* Ought to default to replacing in place, but this is existing practice!  */
1379
1380 static void
1381 replace_members (bfd *arch, char **files_to_move, bfd_boolean quick)
1382 {
1383   bfd_boolean changed = FALSE;
1384   bfd **after_bfd;              /* New entries go after this one.  */
1385   bfd *current;
1386   bfd **current_ptr;
1387
1388   while (files_to_move && *files_to_move)
1389     {
1390       if (! quick)
1391         {
1392           current_ptr = &arch->archive_next;
1393           while (*current_ptr)
1394             {
1395               current = *current_ptr;
1396
1397               /* For compatibility with existing ar programs, we
1398                  permit the same file to be added multiple times.  */
1399               if (FILENAME_CMP (normalize (*files_to_move, arch),
1400                                 normalize (current->filename, arch)) == 0
1401                   && current->arelt_data != NULL)
1402                 {
1403                   if (newer_only)
1404                     {
1405                       struct stat fsbuf, asbuf;
1406
1407                       if (stat (*files_to_move, &fsbuf) != 0)
1408                         {
1409                           if (errno != ENOENT)
1410                             bfd_fatal (*files_to_move);
1411                           goto next_file;
1412                         }
1413                       if (bfd_stat_arch_elt (current, &asbuf) != 0)
1414                         /* xgettext:c-format */
1415                         fatal (_("internal stat error on %s"),
1416                                current->filename);
1417
1418                       if (fsbuf.st_mtime <= asbuf.st_mtime)
1419                         goto next_file;
1420                     }
1421
1422                   after_bfd = get_pos_bfd (&arch->archive_next, pos_after,
1423                                            current->filename);
1424                   if (ar_emul_replace (after_bfd, *files_to_move,
1425                                        target, verbose))
1426                     {
1427                       /* Snip out this entry from the chain.  */
1428                       *current_ptr = (*current_ptr)->archive_next;
1429                       changed = TRUE;
1430                     }
1431
1432                   goto next_file;
1433                 }
1434               current_ptr = &(current->archive_next);
1435             }
1436         }
1437
1438       /* Add to the end of the archive.  */
1439       after_bfd = get_pos_bfd (&arch->archive_next, pos_end, NULL);
1440
1441       if (ar_emul_append (after_bfd, *files_to_move, target,
1442                           verbose, make_thin_archive))
1443         changed = TRUE;
1444
1445     next_file:;
1446
1447       files_to_move++;
1448     }
1449
1450   if (changed)
1451     write_archive (arch);
1452   else
1453     output_filename = NULL;
1454 }
1455
1456 static int
1457 ranlib_only (const char *archname)
1458 {
1459   bfd *arch;
1460
1461   if (get_file_size (archname) < 1)
1462     return 1;
1463   write_armap = 1;
1464   arch = open_inarch (archname, (char *) NULL);
1465   if (arch == NULL)
1466     xexit (1);
1467   write_archive (arch);
1468   return 0;
1469 }
1470
1471 /* Update the timestamp of the symbol map of an archive.  */
1472
1473 static int
1474 ranlib_touch (const char *archname)
1475 {
1476 #ifdef __GO32__
1477   /* I don't think updating works on go32.  */
1478   ranlib_only (archname);
1479 #else
1480   int f;
1481   bfd *arch;
1482   char **matching;
1483
1484   if (get_file_size (archname) < 1)
1485     return 1;
1486   f = open (archname, O_RDWR | O_BINARY, 0);
1487   if (f < 0)
1488     {
1489       bfd_set_error (bfd_error_system_call);
1490       bfd_fatal (archname);
1491     }
1492
1493   arch = bfd_fdopenr (archname, (const char *) NULL, f);
1494   if (arch == NULL)
1495     bfd_fatal (archname);
1496   if (! bfd_check_format_matches (arch, bfd_archive, &matching))
1497     {
1498       bfd_nonfatal (archname);
1499       if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
1500         {
1501           list_matching_formats (matching);
1502           free (matching);
1503         }
1504       xexit (1);
1505     }
1506
1507   if (! bfd_has_map (arch))
1508     /* xgettext:c-format */
1509     fatal (_("%s: no archive map to update"), archname);
1510
1511   if (deterministic)
1512     arch->flags |= BFD_DETERMINISTIC_OUTPUT;
1513
1514   bfd_update_armap_timestamp (arch);
1515
1516   if (! bfd_close (arch))
1517     bfd_fatal (archname);
1518 #endif
1519   return 0;
1520 }
1521
1522 /* Things which are interesting to map over all or some of the files: */
1523
1524 static void
1525 print_descr (bfd *abfd)
1526 {
1527   print_arelt_descr (stdout, abfd, verbose, display_offsets);
1528 }