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 && optind > 0 && optind < argc)
 606     {
 607       argv += (optind - 1);
 608       argc -= (optind - 1);
 609       optind = 0;
 610       goto restart;
 611     }
 612
 613   return &argv[optind];
 614 }
 615
 616 /* If neither -D nor -U was specified explicitly,
 617    then use the configured default.  */
 618 static void
 619 default_deterministic (void)
 620 {
 621   if (deterministic < 0)
 622     deterministic = DEFAULT_AR_DETERMINISTIC;
 623 }
 624
 625 static void
 626 ranlib_main (int argc, char **argv)
 627 {
 628   int arg_index, status = 0;
 629   bfd_boolean touch = FALSE;
 630   int c;
 631
 632   while ((c = getopt_long (argc, argv, "DhHUvVt", long_options, NULL)) != EOF)
 633     {
 634       switch (c)
 635         {
 636         case 'D':
 637           deterministic = TRUE;
 638           break;
 639         case 'U':
 640           deterministic = FALSE;
 641           break;
 642         case 'h':
 643         case 'H':
 644           show_help = 1;
 645           break;
 646         case 't':
 647           touch = TRUE;
 648           break;
 649         case 'v':
 650         case 'V':
 651           show_version = 1;
 652           break;
 653
 654           /* PR binutils/13493: Support plugins.  */
 655         case OPTION_PLUGIN:
 656 #if BFD_SUPPORTS_PLUGINS
 657           bfd_plugin_set_plugin (optarg);
 658 #else
 659           fprintf (stderr, _("sorry - this program has been built without plugin support\n"));
 660           xexit (1);
 661 #endif
 662           break;
 663         }
 664     }
 665
 666   if (argc < 2)
 667     ranlib_usage (0);
 668
 669   if (show_help)
 670     ranlib_usage (1);
 671
 672   if (show_version)
 673     print_version ("ranlib");
 674
 675   default_deterministic ();
 676
 677   arg_index = optind;
 678
 679   while (arg_index < argc)
 680     {
 681       if (! touch)
 682         status |= ranlib_only (argv[arg_index]);
 683       else
 684         status |= ranlib_touch (argv[arg_index]);
 685       ++arg_index;
 686     }
 687
 688   xexit (status);
 689 }
 690
 691 int main (int, char **);
 692
 693 int
 694 main (int argc, char **argv)
 695 {
 696   int arg_index;
 697   char **files;
 698   int file_count;
 699   char *inarch_filename;
 700   int i;
 701
 702 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
 703   setlocale (LC_MESSAGES, "");
 704 #endif
 705 #if defined (HAVE_SETLOCALE)
 706   setlocale (LC_CTYPE, "");
 707 #endif
 708   bindtextdomain (PACKAGE, LOCALEDIR);
 709   textdomain (PACKAGE);
 710
 711   program_name = argv[0];
 712   xmalloc_set_program_name (program_name);
 713   bfd_set_error_program_name (program_name);
 714 #if BFD_SUPPORTS_PLUGINS
 715   bfd_plugin_set_program_name (program_name);
 716 #endif
 717
 718   expandargv (&argc, &argv);
 719
 720   if (is_ranlib < 0)
 721     {
 722       const char *temp = lbasename (program_name);
 723
 724       if (strlen (temp) >= 6
 725           && FILENAME_CMP (temp + strlen (temp) - 6, "ranlib") == 0)
 726         is_ranlib = 1;
 727       else
 728         is_ranlib = 0;
 729     }
 730
 731   START_PROGRESS (program_name, 0);
 732
 733   if (bfd_init () != BFD_INIT_MAGIC)
 734     fatal (_("fatal error: libbfd ABI mismatch"));
 735   set_default_bfd_target ();
 736
 737   xatexit (remove_output);
 738
 739   for (i = 1; i < argc; i++)
 740     if (! ar_emul_parse_arg (argv[i]))
 741       break;
 742   argv += (i - 1);
 743   argc -= (i - 1);
 744
 745   if (is_ranlib)
 746     ranlib_main (argc, argv);
 747
 748   if (argc < 2)
 749     usage (0);
 750
 751   argv = decode_options (argc, argv);
 752
 753   if (show_help)
 754     usage (1);
 755
 756   if (show_version)
 757     print_version ("ar");
 758
 759   arg_index = 0;
 760
 761   if (mri_mode)
 762     {
 763       default_deterministic ();
 764       mri_emul ();
 765     }
 766   else
 767     {
 768       bfd *arch;
 769
 770       /* Fail if no files are specified on the command line.
 771          (But not for MRI mode which allows for reading arguments
 772          and filenames from stdin).  */
 773       if (argv[arg_index] == NULL)
 774         usage (0);
 775
 776       /* We don't use do_quick_append any more.  Too many systems
 777          expect ar to always rebuild the symbol table even when q is
 778          used.  */
 779
 780       /* We can't write an armap when using ar q, so just do ar r
 781          instead.  */
 782       if (operation == quick_append && write_armap)
 783         operation = replace;
 784
 785       if ((operation == none || operation == print_table)
 786           && write_armap == 1)
 787         xexit (ranlib_only (argv[arg_index]));
 788
 789       if (operation == none)
 790         fatal (_("no operation specified"));
 791
 792       if (newer_only && operation != replace)
 793         fatal (_("`u' is only meaningful with the `r' option."));
 794
 795       if (newer_only && deterministic > 0)
 796         fatal (_("`u' is not meaningful with the `D' option."));
 797
 798       if (newer_only && deterministic < 0 && DEFAULT_AR_DETERMINISTIC)
 799         non_fatal (_("\
 800 `u' modifier ignored since `D' is the default (see `U')"));
 801
 802       default_deterministic ();
 803
 804       if (postype != pos_default)
 805         {
 806           posname = argv[arg_index++];
 807           if (posname == NULL)
 808             fatal (_("missing position arg."));
 809         }
 810
 811       if (counted_name_mode)
 812         {
 813           if (operation != extract && operation != del)
 814             fatal (_("`N' is only meaningful with the `x' and `d' options."));
 815           if (argv[arg_index] == NULL)
 816             fatal (_("`N' missing value."));
 817           counted_name_counter = atoi (argv[arg_index++]);
 818           if (counted_name_counter <= 0)
 819             fatal (_("Value for `N' must be positive."));
 820         }
 821
 822       inarch_filename = argv[arg_index++];
 823       if (inarch_filename == NULL)
 824         usage (0);
 825
 826       for (file_count = 0; argv[arg_index + file_count] != NULL; file_count++)
 827         continue;
 828
 829       files = (file_count > 0) ? argv + arg_index : NULL;
 830
 831       arch = open_inarch (inarch_filename,
 832                           files == NULL ? (char *) NULL : files[0]);
 833
 834       if (operation == extract && bfd_is_thin_archive (arch))
 835         fatal (_("`x' cannot be used on thin archives."));
 836
 837       switch (operation)
 838         {
 839         case print_table:
 840           map_over_members (arch, print_descr, files, file_count);
 841           break;
 842
 843         case print_files:
 844           map_over_members (arch, print_contents, files, file_count);
 845           break;
 846
 847         case extract:
 848           map_over_members (arch, extract_file, files, file_count);
 849           break;
 850
 851         case del:
 852           if (files != NULL)
 853             delete_members (arch, files);
 854           else
 855             output_filename = NULL;
 856           break;
 857
 858         case move:
 859           /* PR 12558: Creating and moving at the same time does
 860              not make sense.  Just create the archive instead.  */
 861           if (! silent_create)
 862             {
 863               if (files != NULL)
 864                 move_members (arch, files);
 865               else
 866                 output_filename = NULL;
 867               break;
 868             }
 869           /* Fall through.  */
 870
 871         case replace:
 872         case quick_append:
 873           if (files != NULL || write_armap > 0)
 874             replace_members (arch, files, operation == quick_append);
 875           else
 876             output_filename = NULL;
 877           break;
 878
 879           /* Shouldn't happen! */
 880         default:
 881           /* xgettext:c-format */
 882           fatal (_("internal error -- this option not implemented"));
 883         }
 884     }
 885
 886   END_PROGRESS (program_name);
 887
 888   xexit (0);
 889   return 0;
 890 }
 891
 892 bfd *
 893 open_inarch (const char *archive_filename, const char *file)
 894 {
 895   bfd **last_one;
 896   bfd *next_one;
 897   struct stat sbuf;
 898   bfd *arch;
 899   char **matching;
 900
 901   bfd_set_error (bfd_error_no_error);
 902
 903   if (target == NULL)
 904     target = plugin_target;
 905
 906   if (stat (archive_filename, &sbuf) != 0)
 907     {
 908 #if !defined(__GO32__) || defined(__DJGPP__)
 909
 910       /* FIXME: I don't understand why this fragment was ifndef'ed
 911          away for __GO32__; perhaps it was in the days of DJGPP v1.x.
 912          stat() works just fine in v2.x, so I think this should be
 913          removed.  For now, I enable it for DJGPP v2. -- EZ.  */
 914
 915       /* KLUDGE ALERT! Temporary fix until I figger why
 916          stat() is wrong ... think it's buried in GO32's IDT - Jax */
 917       if (errno != ENOENT)
 918         bfd_fatal (archive_filename);
 919 #endif
 920
 921       if (!operation_alters_arch)
 922         {
 923           fprintf (stderr, "%s: ", program_name);
 924           perror (archive_filename);
 925           maybequit ();
 926           return NULL;
 927         }
 928
 929       /* If the target isn't set, try to figure out the target to use
 930          for the archive from the first object on the list.  */
 931       if (target == NULL && file != NULL)
 932         {
 933           bfd *obj;
 934
 935           obj = bfd_openr (file, target);
 936           if (obj != NULL)
 937             {
 938               if (bfd_check_format (obj, bfd_object))
 939                 target = bfd_get_target (obj);
 940               (void) bfd_close (obj);
 941             }
 942         }
 943
 944       /* Create an empty archive.  */
 945       arch = bfd_openw (archive_filename, target);
 946       if (arch == NULL
 947           || ! bfd_set_format (arch, bfd_archive)
 948           || ! bfd_close (arch))
 949         bfd_fatal (archive_filename);
 950       else if (!silent_create)
 951         non_fatal (_("creating %s"), archive_filename);
 952
 953       /* If we die creating a new archive, don't leave it around.  */
 954       output_filename = archive_filename;
 955     }
 956
 957   arch = bfd_openr (archive_filename, target);
 958   if (arch == NULL)
 959     {
 960     bloser:
 961       bfd_fatal (archive_filename);
 962     }
 963
 964   if (! bfd_check_format_matches (arch, bfd_archive, &matching))
 965     {
 966       bfd_nonfatal (archive_filename);
 967       if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
 968         {
 969           list_matching_formats (matching);
 970           free (matching);
 971         }
 972       xexit (1);
 973     }
 974
 975   if ((operation == replace || operation == quick_append)
 976       && bfd_openr_next_archived_file (arch, NULL) != NULL)
 977     {
 978       /* PR 15140: Catch attempts to convert a normal
 979          archive into a thin archive or vice versa.  */
 980       if (make_thin_archive && ! bfd_is_thin_archive (arch))
 981         {
 982           fatal (_("Cannot convert existing library %s to thin format"),
 983                  bfd_get_filename (arch));
 984           goto bloser;
 985         }
 986       else if (! make_thin_archive && bfd_is_thin_archive (arch))
 987         {
 988           fatal (_("Cannot convert existing thin library %s to normal format"),
 989                  bfd_get_filename (arch));
 990           goto bloser;
 991         }
 992     }
 993
 994   last_one = &(arch->archive_next);
 995   /* Read all the contents right away, regardless.  */
 996   for (next_one = bfd_openr_next_archived_file (arch, NULL);
 997        next_one;
 998        next_one = bfd_openr_next_archived_file (arch, next_one))
 999     {
1000       PROGRESS (1);
1001       *last_one = next_one;
1002       last_one = &next_one->archive_next;
1003     }
1004   *last_one = (bfd *) NULL;
1005   if (bfd_get_error () != bfd_error_no_more_archived_files)
1006     goto bloser;
1007   return arch;
1008 }
1009
1010 static void
1011 print_contents (bfd *abfd)
1012 {
1013   bfd_size_type ncopied = 0;
1014   bfd_size_type size;
1015   char *cbuf = (char *) xmalloc (BUFSIZE);
1016   struct stat buf;
1017
1018   if (bfd_stat_arch_elt (abfd, &buf) != 0)
1019     /* xgettext:c-format */
1020     fatal (_("internal stat error on %s"), bfd_get_filename (abfd));
1021
1022   if (verbose)
1023     printf ("\n<%s>\n\n", bfd_get_filename (abfd));
1024
1025   bfd_seek (abfd, (file_ptr) 0, SEEK_SET);
1026
1027   size = buf.st_size;
1028   while (ncopied < size)
1029     {
1030       bfd_size_type nread;
1031       bfd_size_type tocopy = size - ncopied;
1032
1033       if (tocopy > BUFSIZE)
1034         tocopy = BUFSIZE;
1035
1036       nread = bfd_bread (cbuf, tocopy, abfd);
1037       if (nread != tocopy)
1038         /* xgettext:c-format */
1039         fatal (_("%s is not a valid archive"),
1040                bfd_get_filename (abfd->my_archive));
1041
1042       /* fwrite in mingw32 may return int instead of bfd_size_type. Cast the
1043          return value to bfd_size_type to avoid comparison between signed and
1044          unsigned values.  */
1045       if ((bfd_size_type) fwrite (cbuf, 1, nread, stdout) != nread)
1046         fatal ("stdout: %s", strerror (errno));
1047       ncopied += tocopy;
1048     }
1049   free (cbuf);
1050 }
1051
1052 /* Extract a member of the archive into its own file.
1053
1054    We defer opening the new file until after we have read a BUFSIZ chunk of the
1055    old one, since we know we have just read the archive header for the old
1056    one.  Since most members are shorter than BUFSIZ, this means we will read
1057    the old header, read the old data, write a new inode for the new file, and
1058    write the new data, and be done. This 'optimization' is what comes from
1059    sitting next to a bare disk and hearing it every time it seeks.  -- Gnu
1060    Gilmore  */
1061
1062 void
1063 extract_file (bfd *abfd)
1064 {
1065   FILE *ostream;
1066   char *cbuf = (char *) xmalloc (BUFSIZE);
1067   bfd_size_type nread, tocopy;
1068   bfd_size_type ncopied = 0;
1069   bfd_size_type size;
1070   struct stat buf;
1071
1072   /* PR binutils/17533: Do not allow directory traversal
1073      outside of the current directory tree.  */
1074   if (! is_valid_archive_path (bfd_get_filename (abfd)))
1075     {
1076       non_fatal (_("illegal pathname found in archive member: %s"),
1077                  bfd_get_filename (abfd));
1078       free (cbuf);
1079       return;
1080     }
1081
1082   if (bfd_stat_arch_elt (abfd, &buf) != 0)
1083     /* xgettext:c-format */
1084     fatal (_("internal stat error on %s"), bfd_get_filename (abfd));
1085   size = buf.st_size;
1086
1087   if (verbose)
1088     printf ("x - %s\n", bfd_get_filename (abfd));
1089
1090   bfd_seek (abfd, (file_ptr) 0, SEEK_SET);
1091
1092   ostream = NULL;
1093   if (size == 0)
1094     {
1095       /* Seems like an abstraction violation, eh?  Well it's OK! */
1096       output_filename = bfd_get_filename (abfd);
1097
1098       ostream = fopen (bfd_get_filename (abfd), FOPEN_WB);
1099       if (ostream == NULL)
1100         {
1101           perror (bfd_get_filename (abfd));
1102           xexit (1);
1103         }
1104
1105       output_file = ostream;
1106     }
1107   else
1108     while (ncopied < size)
1109       {
1110         tocopy = size - ncopied;
1111         if (tocopy > BUFSIZE)
1112           tocopy = BUFSIZE;
1113
1114         nread = bfd_bread (cbuf, tocopy, abfd);
1115         if (nread != tocopy)
1116           /* xgettext:c-format */
1117           fatal (_("%s is not a valid archive"),
1118                  bfd_get_filename (abfd->my_archive));
1119
1120         /* See comment above; this saves disk arm motion */
1121         if (ostream == NULL)
1122           {
1123             /* Seems like an abstraction violation, eh?  Well it's OK! */
1124             output_filename = bfd_get_filename (abfd);
1125
1126             ostream = fopen (bfd_get_filename (abfd), FOPEN_WB);
1127             if (ostream == NULL)
1128               {
1129                 perror (bfd_get_filename (abfd));
1130                 xexit (1);
1131               }
1132
1133             output_file = ostream;
1134           }
1135
1136         /* fwrite in mingw32 may return int instead of bfd_size_type. Cast
1137            the return value to bfd_size_type to avoid comparison between
1138            signed and unsigned values.  */
1139         if ((bfd_size_type) fwrite (cbuf, 1, nread, ostream) != nread)
1140           fatal ("%s: %s", output_filename, strerror (errno));
1141         ncopied += tocopy;
1142       }
1143
1144   if (ostream != NULL)
1145     fclose (ostream);
1146
1147   output_file = NULL;
1148   output_filename = NULL;
1149
1150   chmod (bfd_get_filename (abfd), buf.st_mode);
1151
1152   if (preserve_dates)
1153     {
1154       /* Set access time to modification time.  Only st_mtime is
1155          initialized by bfd_stat_arch_elt.  */
1156       buf.st_atime = buf.st_mtime;
1157       set_times (bfd_get_filename (abfd), &buf);
1158     }
1159
1160   free (cbuf);
1161 }
1162
1163 static void
1164 write_archive (bfd *iarch)
1165 {
1166   bfd *obfd;
1167   char *old_name, *new_name;
1168   bfd *contents_head = iarch->archive_next;
1169
1170   old_name = (char *) xmalloc (strlen (bfd_get_filename (iarch)) + 1);
1171   strcpy (old_name, bfd_get_filename (iarch));
1172   new_name = make_tempname (old_name);
1173
1174   if (new_name == NULL)
1175     bfd_fatal (_("could not create temporary file whilst writing archive"));
1176
1177   output_filename = new_name;
1178
1179   obfd = bfd_openw (new_name, bfd_get_target (iarch));
1180
1181   if (obfd == NULL)
1182     bfd_fatal (old_name);
1183
1184   output_bfd = obfd;
1185
1186   bfd_set_format (obfd, bfd_archive);
1187
1188   /* Request writing the archive symbol table unless we've
1189      been explicitly requested not to.  */
1190   obfd->has_armap = write_armap >= 0;
1191
1192   if (ar_truncate)
1193     {
1194       /* This should really use bfd_set_file_flags, but that rejects
1195          archives.  */
1196       obfd->flags |= BFD_TRADITIONAL_FORMAT;
1197     }
1198
1199   if (deterministic)
1200     obfd->flags |= BFD_DETERMINISTIC_OUTPUT;
1201
1202   if (make_thin_archive || bfd_is_thin_archive (iarch))
1203     bfd_is_thin_archive (obfd) = 1;
1204
1205   if (!bfd_set_archive_head (obfd, contents_head))
1206     bfd_fatal (old_name);
1207
1208   if (!bfd_close (obfd))
1209     bfd_fatal (old_name);
1210
1211   output_bfd = NULL;
1212   output_filename = NULL;
1213
1214   /* We don't care if this fails; we might be creating the archive.  */
1215   bfd_close (iarch);
1216
1217   if (smart_rename (new_name, old_name, 0) != 0)
1218     xexit (1);
1219   free (old_name);
1220   free (new_name);
1221 }
1222
1223 /* Return a pointer to the pointer to the entry which should be rplacd'd
1224    into when altering.  DEFAULT_POS should be how to interpret pos_default,
1225    and should be a pos value.  */
1226
1227 static bfd **
1228 get_pos_bfd (bfd **contents, enum pos default_pos, const char *default_posname)
1229 {
1230   bfd **after_bfd = contents;
1231   enum pos realpos;
1232   const char *realposname;
1233
1234   if (postype == pos_default)
1235     {
1236       realpos = default_pos;
1237       realposname = default_posname;
1238     }
1239   else
1240     {
1241       realpos = postype;
1242       realposname = posname;
1243     }
1244
1245   if (realpos == pos_end)
1246     {
1247       while (*after_bfd)
1248         after_bfd = &((*after_bfd)->archive_next);
1249     }
1250   else
1251     {
1252       for (; *after_bfd; after_bfd = &(*after_bfd)->archive_next)
1253         if (FILENAME_CMP ((*after_bfd)->filename, realposname) == 0)
1254           {
1255             if (realpos == pos_after)
1256               after_bfd = &(*after_bfd)->archive_next;
1257             break;
1258           }
1259     }
1260   return after_bfd;
1261 }
1262
1263 static void
1264 delete_members (bfd *arch, char **files_to_delete)
1265 {
1266   bfd **current_ptr_ptr;
1267   bfd_boolean found;
1268   bfd_boolean something_changed = FALSE;
1269   int match_count;
1270
1271   for (; *files_to_delete != NULL; ++files_to_delete)
1272     {
1273       /* In a.out systems, the armap is optional.  It's also called
1274          __.SYMDEF.  So if the user asked to delete it, we should remember
1275          that fact. This isn't quite right for COFF systems (where
1276          __.SYMDEF might be regular member), but it's very unlikely
1277          to be a problem.  FIXME */
1278
1279       if (!strcmp (*files_to_delete, "__.SYMDEF"))
1280         {
1281           arch->has_armap = FALSE;
1282           write_armap = -1;
1283           continue;
1284         }
1285
1286       found = FALSE;
1287       match_count = 0;
1288       current_ptr_ptr = &(arch->archive_next);
1289       while (*current_ptr_ptr)
1290         {
1291           if (FILENAME_CMP (normalize (*files_to_delete, arch),
1292                             (*current_ptr_ptr)->filename) == 0)
1293             {
1294               ++match_count;
1295               if (counted_name_mode
1296                   && match_count != counted_name_counter)
1297                 {
1298                   /* Counting, and didn't match on count; go on to the
1299                      next one.  */
1300                 }
1301               else
1302                 {
1303                   found = TRUE;
1304                   something_changed = TRUE;
1305                   if (verbose)
1306                     printf ("d - %s\n",
1307                             *files_to_delete);
1308                   *current_ptr_ptr = ((*current_ptr_ptr)->archive_next);
1309                   goto next_file;
1310                 }
1311             }
1312
1313           current_ptr_ptr = &((*current_ptr_ptr)->archive_next);
1314         }
1315
1316       if (verbose && !found)
1317         {
1318           /* xgettext:c-format */
1319           printf (_("No member named `%s'\n"), *files_to_delete);
1320         }
1321     next_file:
1322       ;
1323     }
1324
1325   if (something_changed)
1326     write_archive (arch);
1327   else
1328     output_filename = NULL;
1329 }
1330
1331
1332 /* Reposition existing members within an archive */
1333
1334 static void
1335 move_members (bfd *arch, char **files_to_move)
1336 {
1337   bfd **after_bfd;              /* New entries go after this one */
1338   bfd **current_ptr_ptr;        /* cdr pointer into contents */
1339
1340   for (; *files_to_move; ++files_to_move)
1341     {
1342       current_ptr_ptr = &(arch->archive_next);
1343       while (*current_ptr_ptr)
1344         {
1345           bfd *current_ptr = *current_ptr_ptr;
1346           if (FILENAME_CMP (normalize (*files_to_move, arch),
1347                             current_ptr->filename) == 0)
1348             {
1349               /* Move this file to the end of the list - first cut from
1350                  where it is.  */
1351               bfd *link_bfd;
1352               *current_ptr_ptr = current_ptr->archive_next;
1353
1354               /* Now glue to end */
1355               after_bfd = get_pos_bfd (&arch->archive_next, pos_end, NULL);
1356               link_bfd = *after_bfd;
1357               *after_bfd = current_ptr;
1358               current_ptr->archive_next = link_bfd;
1359
1360               if (verbose)
1361                 printf ("m - %s\n", *files_to_move);
1362
1363               goto next_file;
1364             }
1365
1366           current_ptr_ptr = &((*current_ptr_ptr)->archive_next);
1367         }
1368       /* xgettext:c-format */
1369       fatal (_("no entry %s in archive %s!"), *files_to_move, arch->filename);
1370
1371     next_file:;
1372     }
1373
1374   write_archive (arch);
1375 }
1376
1377 /* Ought to default to replacing in place, but this is existing practice!  */
1378
1379 static void
1380 replace_members (bfd *arch, char **files_to_move, bfd_boolean quick)
1381 {
1382   bfd_boolean changed = FALSE;
1383   bfd **after_bfd;              /* New entries go after this one.  */
1384   bfd *current;
1385   bfd **current_ptr;
1386
1387   while (files_to_move && *files_to_move)
1388     {
1389       if (! quick)
1390         {
1391           current_ptr = &arch->archive_next;
1392           while (*current_ptr)
1393             {
1394               current = *current_ptr;
1395
1396               /* For compatibility with existing ar programs, we
1397                  permit the same file to be added multiple times.  */
1398               if (FILENAME_CMP (normalize (*files_to_move, arch),
1399                                 normalize (current->filename, arch)) == 0
1400                   && current->arelt_data != NULL)
1401                 {
1402                   if (newer_only)
1403                     {
1404                       struct stat fsbuf, asbuf;
1405
1406                       if (stat (*files_to_move, &fsbuf) != 0)
1407                         {
1408                           if (errno != ENOENT)
1409                             bfd_fatal (*files_to_move);
1410                           goto next_file;
1411                         }
1412                       if (bfd_stat_arch_elt (current, &asbuf) != 0)
1413                         /* xgettext:c-format */
1414                         fatal (_("internal stat error on %s"),
1415                                current->filename);
1416
1417                       if (fsbuf.st_mtime <= asbuf.st_mtime)
1418                         goto next_file;
1419                     }
1420
1421                   after_bfd = get_pos_bfd (&arch->archive_next, pos_after,
1422                                            current->filename);
1423                   if (ar_emul_replace (after_bfd, *files_to_move,
1424                                        target, verbose))
1425                     {
1426                       /* Snip out this entry from the chain.  */
1427                       *current_ptr = (*current_ptr)->archive_next;
1428                       changed = TRUE;
1429                     }
1430
1431                   goto next_file;
1432                 }
1433               current_ptr = &(current->archive_next);
1434             }
1435         }
1436
1437       /* Add to the end of the archive.  */
1438       after_bfd = get_pos_bfd (&arch->archive_next, pos_end, NULL);
1439
1440       if (ar_emul_append (after_bfd, *files_to_move, target,
1441                           verbose, make_thin_archive))
1442         changed = TRUE;
1443
1444     next_file:;
1445
1446       files_to_move++;
1447     }
1448
1449   if (changed)
1450     write_archive (arch);
1451   else
1452     output_filename = NULL;
1453 }
1454
1455 static int
1456 ranlib_only (const char *archname)
1457 {
1458   bfd *arch;
1459
1460   if (get_file_size (archname) < 1)
1461     return 1;
1462   write_armap = 1;
1463   arch = open_inarch (archname, (char *) NULL);
1464   if (arch == NULL)
1465     xexit (1);
1466   write_archive (arch);
1467   return 0;
1468 }
1469
1470 /* Update the timestamp of the symbol map of an archive.  */
1471
1472 static int
1473 ranlib_touch (const char *archname)
1474 {
1475 #ifdef __GO32__
1476   /* I don't think updating works on go32.  */
1477   ranlib_only (archname);
1478 #else
1479   int f;
1480   bfd *arch;
1481   char **matching;
1482
1483   if (get_file_size (archname) < 1)
1484     return 1;
1485   f = open (archname, O_RDWR | O_BINARY, 0);
1486   if (f < 0)
1487     {
1488       bfd_set_error (bfd_error_system_call);
1489       bfd_fatal (archname);
1490     }
1491
1492   arch = bfd_fdopenr (archname, (const char *) NULL, f);
1493   if (arch == NULL)
1494     bfd_fatal (archname);
1495   if (! bfd_check_format_matches (arch, bfd_archive, &matching))
1496     {
1497       bfd_nonfatal (archname);
1498       if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
1499         {
1500           list_matching_formats (matching);
1501           free (matching);
1502         }
1503       xexit (1);
1504     }
1505
1506   if (! bfd_has_map (arch))
1507     /* xgettext:c-format */
1508     fatal (_("%s: no archive map to update"), archname);
1509
1510   if (deterministic)
1511     arch->flags |= BFD_DETERMINISTIC_OUTPUT;
1512
1513   bfd_update_armap_timestamp (arch);
1514
1515   if (! bfd_close (arch))
1516     bfd_fatal (archname);
1517 #endif
1518   return 0;
1519 }
1520
1521 /* Things which are interesting to map over all or some of the files: */
1522
1523 static void
1524 print_descr (bfd *abfd)
1525 {
1526   print_arelt_descr (stdout, abfd, verbose, display_offsets);
1527 }