Coverage Report

Created: 2024-05-21 06:29

/src/binutils-gdb/bfd/archive.c
Line
Count
Source (jump to first uncovered line)
1
/* BFD back-end for archive files (libraries).
2
   Copyright (C) 1990-2024 Free Software Foundation, Inc.
3
   Written by Cygnus Support.  Mostly Gumby Henkel-Wallace's fault.
4
5
   This file is part of BFD, the Binary File Descriptor library.
6
7
   This program is free software; you can redistribute it and/or modify
8
   it under the terms of the GNU General Public License as published by
9
   the Free Software Foundation; either version 3 of the License, or
10
   (at your option) any later version.
11
12
   This program is distributed in the hope that it will be useful,
13
   but WITHOUT ANY WARRANTY; without even the implied warranty of
14
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
   GNU General Public License for more details.
16
17
   You should have received a copy of the GNU General Public License
18
   along with this program; if not, write to the Free Software
19
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
20
21
/*
22
@setfilename archive-info
23
SECTION
24
  Archives
25
26
DESCRIPTION
27
  An archive (or library) is just another BFD.  It has a symbol
28
  table, although there's not much a user program will do with it.
29
30
  The big difference between an archive BFD and an ordinary BFD
31
  is that the archive doesn't have sections.  Instead it has a
32
  chain of BFDs that are considered its contents.  These BFDs can
33
  be manipulated like any other.  The BFDs contained in an
34
  archive opened for reading will all be opened for reading.  You
35
  may put either input or output BFDs into an archive opened for
36
  output; they will be handled correctly when the archive is closed.
37
38
  Use <<bfd_openr_next_archived_file>> to step through
39
  the contents of an archive opened for input.  You don't
40
  have to read the entire archive if you don't want
41
  to!  Read it until you find what you want.
42
43
  A BFD returned by <<bfd_openr_next_archived_file>> can be
44
  closed manually with <<bfd_close>>.  If you do not close it,
45
  then a second iteration through the members of an archive may
46
  return the same BFD.  If you close the archive BFD, then all
47
  the member BFDs will automatically be closed as well.
48
49
  Archive contents of output BFDs are chained through the
50
  <<archive_next>> pointer in a BFD.  The first one is findable
51
  through the <<archive_head>> slot of the archive.  Set it with
52
  <<bfd_set_archive_head>> (q.v.).  A given BFD may be in only
53
  one open output archive at a time.
54
55
  As expected, the BFD archive code is more general than the
56
  archive code of any given environment.  BFD archives may
57
  contain files of different formats (e.g., a.out and coff) and
58
  even different architectures.  You may even place archives
59
  recursively into archives!
60
61
  This can cause unexpected confusion, since some archive
62
  formats are more expressive than others.  For instance, Intel
63
  COFF archives can preserve long filenames; SunOS a.out archives
64
  cannot.  If you move a file from the first to the second
65
  format and back again, the filename may be truncated.
66
  Likewise, different a.out environments have different
67
  conventions as to how they truncate filenames, whether they
68
  preserve directory names in filenames, etc.  When
69
  interoperating with native tools, be sure your files are
70
  homogeneous.
71
72
  Beware: most of these formats do not react well to the
73
  presence of spaces in filenames.  We do the best we can, but
74
  can't always handle this case due to restrictions in the format of
75
  archives.  Many Unix utilities are braindead in regards to
76
  spaces and such in filenames anyway, so this shouldn't be much
77
  of a restriction.
78
79
  Archives are supported in BFD in <<archive.c>>.
80
81
SUBSECTION
82
  Archive functions
83
*/
84
85
/* Assumes:
86
   o - all archive elements start on an even boundary, newline padded;
87
   o - all arch headers are char *;
88
   o - all arch headers are the same size (across architectures).
89
*/
90
91
/* Some formats provide a way to cram a long filename into the short
92
   (16 chars) space provided by a BSD archive.  The trick is: make a
93
   special "file" in the front of the archive, sort of like the SYMDEF
94
   entry.  If the filename is too long to fit, put it in the extended
95
   name table, and use its index as the filename.  To prevent
96
   confusion prepend the index with a space.  This means you can't
97
   have filenames that start with a space, but then again, many Unix
98
   utilities can't handle that anyway.
99
100
   This scheme unfortunately requires that you stand on your head in
101
   order to write an archive since you need to put a magic file at the
102
   front, and need to touch every entry to do so.  C'est la vie.
103
104
   We support two variants of this idea:
105
   The SVR4 format (extended name table is named "//"),
106
   and an extended pseudo-BSD variant (extended name table is named
107
   "ARFILENAMES/").  The origin of the latter format is uncertain.
108
109
   BSD 4.4 uses a third scheme:  It writes a long filename
110
   directly after the header.  This allows 'ar q' to work.
111
*/
112
113
/* Summary of archive member names:
114
115
 Symbol table (must be first):
116
 "__.SYMDEF       " - Symbol table, Berkeley style, produced by ranlib.
117
 "/               " - Symbol table, system 5 style.
118
119
 Long name table (must be before regular file members):
120
 "//              " - Long name table, System 5 R4 style.
121
 "ARFILENAMES/    " - Long name table, non-standard extended BSD (not BSD 4.4).
122
123
 Regular file members with short names:
124
 "filename.o/     " - Regular file, System 5 style (embedded spaces ok).
125
 "filename.o      " - Regular file, Berkeley style (no embedded spaces).
126
127
 Regular files with long names (or embedded spaces, for BSD variants):
128
 "/18             " - SVR4 style, name at offset 18 in name table.
129
 "#1/23           " - Long name (or embedded spaces) 23 characters long,
130
          BSD 4.4 style, full name follows header.
131
 " 18             " - Long name 18 characters long, extended pseudo-BSD.
132
 */
133
134
#include "sysdep.h"
135
#include "bfd.h"
136
#include "libiberty.h"
137
#include "libbfd.h"
138
#include "aout/ar.h"
139
#include "aout/ranlib.h"
140
#include "safe-ctype.h"
141
#include "hashtab.h"
142
#include "filenames.h"
143
#include "bfdlink.h"
144
145
#ifndef errno
146
extern int errno;
147
#endif
148
149
/*
150
EXTERNAL
151
.{* A canonical archive symbol.  *}
152
.{* This is a type pun with struct symdef/struct ranlib on purpose!  *}
153
.typedef struct carsym
154
.{
155
.  const char *name;
156
.  file_ptr file_offset;  {* Look here to find the file.  *}
157
.}
158
.carsym;
159
.
160
.{* A count of carsyms (canonical archive symbols).  *}
161
. typedef unsigned long symindex;
162
.#define BFD_NO_MORE_SYMBOLS ((symindex) ~0)
163
.
164
165
INTERNAL
166
.{* Used in generating armaps (archive tables of contents).  *}
167
.struct orl   {* Output ranlib.  *}
168
.{
169
.  char **name;   {* Symbol name.  *}
170
.  union
171
.  {
172
.    file_ptr pos;
173
.    bfd *abfd;
174
.  } u;     {* bfd* or file position.  *}
175
.  int namidx;    {* Index into string table.  *}
176
.};
177
.
178
*/
179
180
/* We keep a cache of archive filepointers to archive elements to
181
   speed up searching the archive by filepos.  We only add an entry to
182
   the cache when we actually read one.  We also don't sort the cache;
183
   it's generally short enough to search linearly.
184
   Note that the pointers here point to the front of the ar_hdr, not
185
   to the front of the contents!  */
186
struct ar_cache
187
{
188
  file_ptr ptr;
189
  bfd *arbfd;
190
};
191
192
0
#define ar_padchar(abfd) ((abfd)->xvec->ar_pad_char)
193
13.0M
#define ar_maxnamelen(abfd) ((abfd)->xvec->ar_max_namelen)
194
195
3.39M
#define arch_eltdata(bfd) ((struct areltdata *) ((bfd)->arelt_data))
196
776
#define arch_hdr(bfd) ((struct ar_hdr *) arch_eltdata (bfd)->arch_header)
197
198
/* True iff NAME designated a BSD 4.4 extended name.  */
199
200
#define is_bsd44_extended_name(NAME) \
201
6.33M
  (NAME[0] == '#'  && NAME[1] == '1' && NAME[2] == '/' && ISDIGIT (NAME[3]))
202

203
void
204
_bfd_ar_spacepad (char *p, size_t n, const char *fmt, long val)
205
1.84k
{
206
1.84k
  char buf[20];
207
1.84k
  size_t len;
208
209
1.84k
  snprintf (buf, sizeof (buf), fmt, val);
210
1.84k
  len = strlen (buf);
211
1.84k
  if (len < n)
212
1.84k
    {
213
1.84k
      memcpy (p, buf, len);
214
1.84k
      memset (p + len, ' ', n - len);
215
1.84k
    }
216
0
  else
217
0
    memcpy (p, buf, n);
218
1.84k
}
219
220
bool
221
_bfd_ar_sizepad (char *p, size_t n, bfd_size_type size)
222
0
{
223
0
  char buf[21];
224
0
  size_t len;
225
226
0
  snprintf (buf, sizeof (buf), "%-10" PRIu64, (uint64_t) size);
227
0
  len = strlen (buf);
228
0
  if (len > n)
229
0
    {
230
0
      bfd_set_error (bfd_error_file_too_big);
231
0
      return false;
232
0
    }
233
0
  if (len < n)
234
0
    {
235
0
      memcpy (p, buf, len);
236
0
      memset (p + len, ' ', n - len);
237
0
    }
238
0
  else
239
0
    memcpy (p, buf, n);
240
0
  return true;
241
0
}
242

243
bool
244
_bfd_generic_mkarchive (bfd *abfd)
245
1
{
246
1
  size_t amt = sizeof (struct artdata);
247
248
1
  abfd->tdata.aout_ar_data = (struct artdata *) bfd_zalloc (abfd, amt);
249
1
  return bfd_ardata (abfd) != NULL;
250
1
}
251
252
/*
253
FUNCTION
254
  bfd_get_next_mapent
255
256
SYNOPSIS
257
  symindex bfd_get_next_mapent
258
    (bfd *abfd, symindex previous, carsym **sym);
259
260
DESCRIPTION
261
  Step through archive @var{abfd}'s symbol table (if it
262
  has one).  Successively update @var{sym} with the next symbol's
263
  information, returning that symbol's (internal) index into the
264
  symbol table.
265
266
  Supply <<BFD_NO_MORE_SYMBOLS>> as the @var{previous} entry to get
267
  the first one; returns <<BFD_NO_MORE_SYMBOLS>> when you've already
268
  got the last one.
269
270
  A <<carsym>> is a canonical archive symbol.  The only
271
  user-visible element is its name, a null-terminated string.
272
*/
273
274
symindex
275
bfd_get_next_mapent (bfd *abfd, symindex prev, carsym **entry)
276
0
{
277
0
  if (!bfd_has_map (abfd))
278
0
    {
279
0
      bfd_set_error (bfd_error_invalid_operation);
280
0
      return BFD_NO_MORE_SYMBOLS;
281
0
    }
282
283
0
  if (prev == BFD_NO_MORE_SYMBOLS)
284
0
    prev = 0;
285
0
  else
286
0
    ++prev;
287
0
  if (prev >= bfd_ardata (abfd)->symdef_count)
288
0
    return BFD_NO_MORE_SYMBOLS;
289
290
0
  *entry = (bfd_ardata (abfd)->symdefs + prev);
291
0
  return prev;
292
0
}
293
294
/* To be called by backends only.  */
295
296
bfd *
297
_bfd_create_empty_archive_element_shell (bfd *obfd)
298
1.62M
{
299
1.62M
  return _bfd_new_bfd_contained_in (obfd);
300
1.62M
}
301
302
/*
303
FUNCTION
304
  bfd_set_archive_head
305
306
SYNOPSIS
307
  bool bfd_set_archive_head (bfd *output, bfd *new_head);
308
309
DESCRIPTION
310
  Set the head of the chain of
311
  BFDs contained in the archive @var{output} to @var{new_head}.
312
*/
313
314
bool
315
bfd_set_archive_head (bfd *output_archive, bfd *new_head)
316
0
{
317
0
  output_archive->archive_head = new_head;
318
0
  return true;
319
0
}
320
321
bfd *
322
_bfd_look_for_bfd_in_cache (bfd *arch_bfd, file_ptr filepos)
323
1.63M
{
324
1.63M
  htab_t hash_table = bfd_ardata (arch_bfd)->cache;
325
1.63M
  struct ar_cache m;
326
327
1.63M
  m.ptr = filepos;
328
329
1.63M
  if (hash_table)
330
10.5k
    {
331
10.5k
      struct ar_cache *entry = (struct ar_cache *) htab_find (hash_table, &m);
332
10.5k
      if (!entry)
333
10.5k
  return NULL;
334
335
      /* Unfortunately this flag is set after checking that we have
336
   an archive, and checking for an archive means one element has
337
   sneaked into the cache.  */
338
0
      entry->arbfd->no_export = arch_bfd->no_export;
339
0
      return entry->arbfd;
340
10.5k
    }
341
1.62M
  else
342
1.62M
    return NULL;
343
1.63M
}
344
345
static hashval_t
346
hash_file_ptr (const void * p)
347
32.4k
{
348
32.4k
  return (hashval_t) (((struct ar_cache *) p)->ptr);
349
32.4k
}
350
351
/* Returns non-zero if P1 and P2 are equal.  */
352
353
static int
354
eq_file_ptr (const void * p1, const void * p2)
355
11.3k
{
356
11.3k
  struct ar_cache *arc1 = (struct ar_cache *) p1;
357
11.3k
  struct ar_cache *arc2 = (struct ar_cache *) p2;
358
11.3k
  return arc1->ptr == arc2->ptr;
359
11.3k
}
360
361
/* The calloc function doesn't always take size_t (e.g. on VMS)
362
   so wrap it to avoid a compile time warning.   */
363
364
static void *
365
_bfd_calloc_wrapper (size_t a, size_t b)
366
11.7k
{
367
11.7k
  return calloc (a, b);
368
11.7k
}
369
370
/* Kind of stupid to call cons for each one, but we don't do too many.  */
371
372
bool
373
_bfd_add_bfd_to_archive_cache (bfd *arch_bfd, file_ptr filepos, bfd *new_elt)
374
10.8k
{
375
10.8k
  struct ar_cache *cache;
376
10.8k
  htab_t hash_table = bfd_ardata (arch_bfd)->cache;
377
378
  /* If the hash table hasn't been created, create it.  */
379
10.8k
  if (hash_table == NULL)
380
5.82k
    {
381
5.82k
      hash_table = htab_create_alloc (16, hash_file_ptr, eq_file_ptr,
382
5.82k
              NULL, _bfd_calloc_wrapper, free);
383
5.82k
      if (hash_table == NULL)
384
0
  return false;
385
5.82k
      bfd_ardata (arch_bfd)->cache = hash_table;
386
5.82k
    }
387
388
  /* Insert new_elt into the hash table by filepos.  */
389
10.8k
  cache = (struct ar_cache *) bfd_zalloc (arch_bfd, sizeof (struct ar_cache));
390
10.8k
  cache->ptr = filepos;
391
10.8k
  cache->arbfd = new_elt;
392
10.8k
  *htab_find_slot (hash_table, (const void *) cache, INSERT) = cache;
393
394
  /* Provide a means of accessing this from child.  */
395
10.8k
  arch_eltdata (new_elt)->parent_cache = hash_table;
396
10.8k
  arch_eltdata (new_elt)->key = filepos;
397
398
10.8k
  return true;
399
10.8k
}
400

401
static bfd *
402
open_nested_file (const char *filename, bfd *archive)
403
1.65k
{
404
1.65k
  const char *target;
405
1.65k
  bfd *n_bfd;
406
407
1.65k
  target = NULL;
408
1.65k
  if (!archive->target_defaulted)
409
12
    target = archive->xvec->name;
410
1.65k
  n_bfd = bfd_openr (filename, target);
411
1.65k
  if (n_bfd != NULL)
412
683
    {
413
683
      n_bfd->lto_output = archive->lto_output;
414
683
      n_bfd->no_export = archive->no_export;
415
683
      n_bfd->my_archive = archive;
416
683
    }
417
1.65k
  return n_bfd;
418
1.65k
}
419
420
static bfd *
421
find_nested_archive (const char *filename, bfd *arch_bfd)
422
15
{
423
15
  bfd *abfd;
424
425
  /* PR 15140: Don't allow a nested archive pointing to itself.  */
426
15
  if (filename_cmp (filename, bfd_get_filename (arch_bfd)) == 0)
427
0
    {
428
0
      bfd_set_error (bfd_error_malformed_archive);
429
0
      return NULL;
430
0
    }
431
432
15
  for (abfd = arch_bfd->nested_archives;
433
15
       abfd != NULL;
434
15
       abfd = abfd->archive_next)
435
1
    {
436
1
      if (filename_cmp (filename, bfd_get_filename (abfd)) == 0)
437
1
  return abfd;
438
1
    }
439
14
  abfd = open_nested_file (filename, arch_bfd);
440
14
  if (abfd)
441
5
    {
442
5
      abfd->archive_next = arch_bfd->nested_archives;
443
5
      arch_bfd->nested_archives = abfd;
444
5
    }
445
14
  return abfd;
446
15
}
447
448
/* The name begins with space.  Hence the rest of the name is an index into
449
   the string table.  */
450
451
static char *
452
get_extended_arelt_filename (bfd *arch, const char *name, file_ptr *originp)
453
1.28k
{
454
1.28k
  unsigned long table_index = 0;
455
1.28k
  const char *endp;
456
457
  /* Should extract string so that I can guarantee not to overflow into
458
     the next region, but I'm too lazy.  */
459
1.28k
  errno = 0;
460
  /* Skip first char, which is '/' in SVR4 or ' ' in some other variants.  */
461
1.28k
  table_index = strtol (name + 1, (char **) &endp, 10);
462
1.28k
  if (errno != 0 || table_index >= bfd_ardata (arch)->extended_names_size)
463
524
    {
464
524
      bfd_set_error (bfd_error_malformed_archive);
465
524
      return NULL;
466
524
    }
467
  /* In a thin archive, a member of an archive-within-an-archive
468
     will have the offset in the inner archive encoded here.  */
469
759
  if (bfd_is_thin_archive (arch) && endp != NULL && *endp == ':')
470
26
    {
471
26
      file_ptr origin = strtol (endp + 1, NULL, 10);
472
473
26
      if (errno != 0)
474
11
  {
475
11
    bfd_set_error (bfd_error_malformed_archive);
476
11
    return NULL;
477
11
  }
478
15
      *originp = origin;
479
15
    }
480
733
  else
481
733
    *originp = 0;
482
483
748
  return bfd_ardata (arch)->extended_names + table_index;
484
759
}
485
486
/* This functions reads an arch header and returns an areltdata pointer, or
487
   NULL on error.
488
489
   Presumes the file pointer is already in the right place (ie pointing
490
   to the ar_hdr in the file).   Moves the file pointer; on success it
491
   should be pointing to the front of the file contents; on failure it
492
   could have been moved arbitrarily.  */
493
494
void *
495
_bfd_generic_read_ar_hdr (bfd *abfd)
496
6.77M
{
497
6.77M
  return _bfd_generic_read_ar_hdr_mag (abfd, NULL);
498
6.77M
}
499
500
/* Alpha ECOFF uses an optional different ARFMAG value, so we have a
501
   variant of _bfd_generic_read_ar_hdr which accepts a magic string.  */
502
503
void *
504
_bfd_generic_read_ar_hdr_mag (bfd *abfd, const char *mag)
505
6.79M
{
506
6.79M
  struct ar_hdr hdr;
507
6.79M
  char *hdrp = (char *) &hdr;
508
6.79M
  uint64_t parsed_size;
509
6.79M
  struct areltdata *ared;
510
6.79M
  char *filename = NULL;
511
6.79M
  ufile_ptr filesize;
512
6.79M
  bfd_size_type namelen = 0;
513
6.79M
  bfd_size_type allocsize = sizeof (struct areltdata) + sizeof (struct ar_hdr);
514
6.79M
  char *allocptr = 0;
515
6.79M
  file_ptr origin = 0;
516
6.79M
  unsigned int extra_size = 0;
517
6.79M
  char fmag_save;
518
6.79M
  int scan;
519
520
6.79M
  if (bfd_read (hdrp, sizeof (struct ar_hdr), abfd) != sizeof (struct ar_hdr))
521
20.5k
    {
522
20.5k
      if (bfd_get_error () != bfd_error_system_call)
523
20.5k
  bfd_set_error (bfd_error_no_more_archived_files);
524
20.5k
      return NULL;
525
20.5k
    }
526
6.77M
  if (strncmp (hdr.ar_fmag, ARFMAG, 2) != 0
527
6.77M
      && (mag == NULL
528
283k
    || strncmp (hdr.ar_fmag, mag, 2) != 0))
529
280k
    {
530
280k
      bfd_set_error (bfd_error_malformed_archive);
531
280k
      return NULL;
532
280k
    }
533
534
6.49M
  errno = 0;
535
6.49M
  fmag_save = hdr.ar_fmag[0];
536
6.49M
  hdr.ar_fmag[0] = 0;
537
6.49M
  scan = sscanf (hdr.ar_size, "%" SCNu64, &parsed_size);
538
6.49M
  hdr.ar_fmag[0] = fmag_save;
539
6.49M
  if (scan != 1)
540
158k
    {
541
158k
      bfd_set_error (bfd_error_malformed_archive);
542
158k
      return NULL;
543
158k
    }
544
545
  /* Extract the filename from the archive - there are two ways to
546
     specify an extended name table, either the first char of the
547
     name is a space, or it's a slash.  */
548
6.33M
  if ((hdr.ar_name[0] == '/'
549
6.33M
       || (hdr.ar_name[0] == ' '
550
5.62M
     && memchr (hdr.ar_name, '/', ar_maxnamelen (abfd)) == NULL))
551
6.33M
      && bfd_ardata (abfd)->extended_names != NULL)
552
1.28k
    {
553
1.28k
      filename = get_extended_arelt_filename (abfd, hdr.ar_name, &origin);
554
1.28k
      if (filename == NULL)
555
535
  return NULL;
556
1.28k
    }
557
  /* BSD4.4-style long filename.  */
558
6.33M
  else if (is_bsd44_extended_name (hdr.ar_name))
559
5.93k
    {
560
      /* BSD-4.4 extended name */
561
5.93k
      namelen = atoi (&hdr.ar_name[3]);
562
5.93k
      filesize = bfd_get_file_size (abfd);
563
5.93k
      if (namelen > parsed_size
564
5.93k
    || namelen > -allocsize - 2
565
5.93k
    || (filesize != 0 && namelen > filesize))
566
1.03k
  {
567
1.03k
    bfd_set_error (bfd_error_malformed_archive);
568
1.03k
    return NULL;
569
1.03k
  }
570
4.89k
      allocsize += namelen + 1;
571
4.89k
      parsed_size -= namelen;
572
4.89k
      extra_size = namelen;
573
574
4.89k
      allocptr = (char *) bfd_malloc (allocsize);
575
4.89k
      if (allocptr == NULL)
576
0
  return NULL;
577
4.89k
      filename = (allocptr
578
4.89k
      + sizeof (struct areltdata)
579
4.89k
      + sizeof (struct ar_hdr));
580
4.89k
      if (bfd_read (filename, namelen, abfd) != namelen)
581
432
  {
582
432
    free (allocptr);
583
432
    if (bfd_get_error () != bfd_error_system_call)
584
432
      bfd_set_error (bfd_error_no_more_archived_files);
585
432
    return NULL;
586
432
  }
587
4.46k
      filename[namelen] = '\0';
588
4.46k
    }
589
6.32M
  else
590
6.32M
    {
591
      /* We judge the end of the name by looking for '/' or ' '.
592
   Note:  The SYSV format (terminated by '/') allows embedded
593
   spaces, so only look for ' ' if we don't find '/'.  */
594
595
6.32M
      char *e;
596
6.32M
      e = (char *) memchr (hdr.ar_name, '\0', ar_maxnamelen (abfd));
597
6.32M
      if (e == NULL)
598
4.65M
  {
599
4.65M
    e = (char *) memchr (hdr.ar_name, '/', ar_maxnamelen (abfd));
600
4.65M
    if (e == NULL)
601
1.73M
      e = (char *) memchr (hdr.ar_name, ' ', ar_maxnamelen (abfd));
602
4.65M
  }
603
604
6.32M
      if (e != NULL)
605
6.14M
  namelen = e - hdr.ar_name;
606
186k
      else
607
186k
  {
608
    /* If we didn't find a termination character, then the name
609
       must be the entire field.  */
610
186k
    namelen = ar_maxnamelen (abfd);
611
186k
  }
612
613
6.32M
      allocsize += namelen + 1;
614
6.32M
    }
615
616
6.33M
  if (!allocptr)
617
6.32M
    {
618
6.32M
      allocptr = (char *) bfd_malloc (allocsize);
619
6.32M
      if (allocptr == NULL)
620
0
  return NULL;
621
6.32M
    }
622
623
6.33M
  memset (allocptr, 0, sizeof (struct areltdata));
624
6.33M
  ared = (struct areltdata *) allocptr;
625
6.33M
  ared->arch_header = allocptr + sizeof (struct areltdata);
626
6.33M
  memcpy (ared->arch_header, &hdr, sizeof (struct ar_hdr));
627
6.33M
  ared->parsed_size = parsed_size;
628
6.33M
  ared->extra_size = extra_size;
629
6.33M
  ared->origin = origin;
630
631
6.33M
  if (filename != NULL)
632
5.20k
    ared->filename = filename;
633
6.32M
  else
634
6.32M
    {
635
6.32M
      ared->filename = allocptr + (sizeof (struct areltdata) +
636
6.32M
           sizeof (struct ar_hdr));
637
6.32M
      if (namelen)
638
4.73M
  memcpy (ared->filename, hdr.ar_name, namelen);
639
6.32M
      ared->filename[namelen] = '\0';
640
6.32M
    }
641
642
6.33M
  return ared;
643
6.33M
}
644

645
/* Append the relative pathname for a member of the thin archive
646
   to the pathname of the directory containing the archive.  */
647
648
char *
649
_bfd_append_relative_path (bfd *arch, char *elt_name)
650
1.33k
{
651
1.33k
  const char *arch_name = bfd_get_filename (arch);
652
1.33k
  const char *base_name = lbasename (arch_name);
653
1.33k
  size_t prefix_len;
654
1.33k
  char *filename;
655
656
1.33k
  if (base_name == arch_name)
657
0
    return elt_name;
658
659
1.33k
  prefix_len = base_name - arch_name;
660
1.33k
  filename = (char *) bfd_alloc (arch, prefix_len + strlen (elt_name) + 1);
661
1.33k
  if (filename == NULL)
662
0
    return NULL;
663
664
1.33k
  strncpy (filename, arch_name, prefix_len);
665
1.33k
  strcpy (filename + prefix_len, elt_name);
666
1.33k
  return filename;
667
1.33k
}
668
669
/* This is an internal function; it's mainly used when indexing
670
   through the archive symbol table, but also used to get the next
671
   element, since it handles the bookkeeping so nicely for us.  */
672
673
bfd *
674
_bfd_get_elt_at_filepos (bfd *archive, file_ptr filepos,
675
       struct bfd_link_info *info)
676
1.63M
{
677
1.63M
  struct areltdata *new_areldata;
678
1.63M
  bfd *n_bfd;
679
1.63M
  char *filename;
680
681
1.63M
  n_bfd = _bfd_look_for_bfd_in_cache (archive, filepos);
682
1.63M
  if (n_bfd)
683
0
    return n_bfd;
684
685
1.63M
  if (0 > bfd_seek (archive, filepos, SEEK_SET))
686
184
    return NULL;
687
688
1.63M
  if ((new_areldata = (struct areltdata *) _bfd_read_ar_hdr (archive)) == NULL)
689
10.9k
    return NULL;
690
691
1.62M
  filename = new_areldata->filename;
692
693
1.62M
  if (bfd_is_thin_archive (archive))
694
1.65k
    {
695
      /* This is a proxy entry for an external file.  */
696
1.65k
      if (! IS_ABSOLUTE_PATH (filename))
697
1.33k
  {
698
1.33k
    filename = _bfd_append_relative_path (archive, filename);
699
1.33k
    if (filename == NULL)
700
0
      {
701
0
        free (new_areldata);
702
0
        return NULL;
703
0
      }
704
1.33k
  }
705
706
1.65k
      if (new_areldata->origin > 0)
707
15
  {
708
    /* This proxy entry refers to an element of a nested archive.
709
       Locate the member of that archive and return a bfd for it.  */
710
15
    bfd *ext_arch = find_nested_archive (filename, archive);
711
712
15
    if (ext_arch == NULL
713
15
        || ! bfd_check_format (ext_arch, bfd_archive))
714
15
      {
715
15
        free (new_areldata);
716
15
        return NULL;
717
15
      }
718
0
    n_bfd = _bfd_get_elt_at_filepos (ext_arch,
719
0
             new_areldata->origin, info);
720
0
    if (n_bfd == NULL)
721
0
      {
722
0
        free (new_areldata);
723
0
        return NULL;
724
0
      }
725
0
    n_bfd->proxy_origin = bfd_tell (archive);
726
727
    /* Copy BFD_COMPRESS, BFD_DECOMPRESS and BFD_COMPRESS_GABI
728
       flags.  */
729
0
    n_bfd->flags |= archive->flags & (BFD_COMPRESS
730
0
              | BFD_DECOMPRESS
731
0
              | BFD_COMPRESS_GABI);
732
733
0
    return n_bfd;
734
0
  }
735
736
      /* It's not an element of a nested archive;
737
   open the external file as a bfd.  */
738
1.64k
      bfd_set_error (bfd_error_no_error);
739
1.64k
      n_bfd = open_nested_file (filename, archive);
740
1.64k
      if (n_bfd == NULL)
741
966
  {
742
966
    switch (bfd_get_error ())
743
966
      {
744
0
      default:
745
0
        break;
746
0
      case bfd_error_no_error:
747
0
        bfd_set_error (bfd_error_malformed_archive);
748
0
        break;
749
966
      case bfd_error_system_call:
750
966
        if (info != NULL)
751
0
    {
752
0
      info->callbacks->einfo
753
0
        (_("%F%P: %pB(%s): error opening thin archive member: %E\n"),
754
0
         archive, filename);
755
0
      break;
756
0
    }
757
966
        break;
758
966
      }
759
966
  }
760
1.64k
    }
761
1.62M
  else
762
1.62M
    {
763
1.62M
      n_bfd = _bfd_create_empty_archive_element_shell (archive);
764
1.62M
    }
765
766
1.62M
  if (n_bfd == NULL)
767
971
    {
768
971
      free (new_areldata);
769
971
      return NULL;
770
971
    }
771
772
1.62M
  n_bfd->proxy_origin = bfd_tell (archive);
773
774
1.62M
  if (bfd_is_thin_archive (archive))
775
678
    {
776
678
      n_bfd->origin = 0;
777
678
    }
778
1.62M
  else
779
1.62M
    {
780
1.62M
      n_bfd->origin = n_bfd->proxy_origin;
781
1.62M
      if (!bfd_set_filename (n_bfd, filename))
782
0
  goto out;
783
1.62M
    }
784
785
1.62M
  n_bfd->arelt_data = new_areldata;
786
787
  /* Copy BFD_COMPRESS, BFD_DECOMPRESS and BFD_COMPRESS_GABI flags.  */
788
1.62M
  n_bfd->flags |= archive->flags & (BFD_COMPRESS
789
1.62M
            | BFD_DECOMPRESS
790
1.62M
            | BFD_COMPRESS_GABI);
791
792
  /* Copy is_linker_input.  */
793
1.62M
  n_bfd->is_linker_input = archive->is_linker_input;
794
795
1.62M
  if (archive->no_element_cache
796
1.62M
      || _bfd_add_bfd_to_archive_cache (archive, filepos, n_bfd))
797
1.62M
    return n_bfd;
798
799
0
 out:
800
0
  free (new_areldata);
801
0
  n_bfd->arelt_data = NULL;
802
0
  bfd_close (n_bfd);
803
0
  return NULL;
804
1.62M
}
805
806
/* Return the BFD which is referenced by the symbol in ABFD indexed by
807
   SYM_INDEX.  SYM_INDEX should have been returned by bfd_get_next_mapent.  */
808
809
bfd *
810
_bfd_generic_get_elt_at_index (bfd *abfd, symindex sym_index)
811
0
{
812
0
  carsym *entry;
813
814
0
  entry = bfd_ardata (abfd)->symdefs + sym_index;
815
0
  return _bfd_get_elt_at_filepos (abfd, entry->file_offset, NULL);
816
0
}
817
818
bfd *
819
_bfd_noarchive_get_elt_at_index (bfd *abfd,
820
         symindex sym_index ATTRIBUTE_UNUSED)
821
0
{
822
0
  return (bfd *) _bfd_ptr_bfd_null_error (abfd);
823
0
}
824
825
/*
826
FUNCTION
827
  bfd_openr_next_archived_file
828
829
SYNOPSIS
830
  bfd *bfd_openr_next_archived_file (bfd *archive, bfd *previous);
831
832
DESCRIPTION
833
  Provided a BFD, @var{archive}, containing an archive and NULL, open
834
  an input BFD on the first contained element and returns that.
835
  Subsequent calls should pass the archive and the previous return
836
  value to return a created BFD to the next contained element.  NULL
837
  is returned when there are no more.
838
  Note - if you want to process the bfd returned by this call be
839
  sure to call bfd_check_format() on it first.
840
*/
841
842
bfd *
843
bfd_openr_next_archived_file (bfd *archive, bfd *last_file)
844
1.63M
{
845
1.63M
  if ((bfd_get_format (archive) != bfd_archive)
846
1.63M
      || (archive->direction == write_direction))
847
0
    {
848
0
      bfd_set_error (bfd_error_invalid_operation);
849
0
      return NULL;
850
0
    }
851
852
1.63M
  return BFD_SEND (archive,
853
1.63M
       openr_next_archived_file, (archive, last_file));
854
1.63M
}
855
856
bfd *
857
bfd_generic_openr_next_archived_file (bfd *archive, bfd *last_file)
858
1.63M
{
859
1.63M
  ufile_ptr filestart;
860
861
1.63M
  if (!last_file)
862
1.62M
    filestart = bfd_ardata (archive)->first_file_filepos;
863
9.55k
  else
864
9.55k
    {
865
9.55k
      filestart = last_file->proxy_origin;
866
9.55k
      if (! bfd_is_thin_archive (archive))
867
9.52k
  {
868
9.52k
    bfd_size_type size = arelt_size (last_file);
869
870
9.52k
    filestart += size;
871
    /* Pad to an even boundary...
872
       Note that last_file->origin can be odd in the case of
873
       BSD-4.4-style element with a long odd size.  */
874
9.52k
    filestart += filestart % 2;
875
9.52k
    if (filestart < last_file->proxy_origin)
876
30
      {
877
        /* Prevent looping.  See PR19256.  */
878
30
        bfd_set_error (bfd_error_malformed_archive);
879
30
        return NULL;
880
30
      }
881
9.52k
  }
882
9.55k
    }
883
884
1.63M
  return _bfd_get_elt_at_filepos (archive, filestart, NULL);
885
1.63M
}
886
887
bfd *
888
_bfd_noarchive_openr_next_archived_file (bfd *archive,
889
           bfd *last_file ATTRIBUTE_UNUSED)
890
0
{
891
0
  return (bfd *) _bfd_ptr_bfd_null_error (archive);
892
0
}
893
894
bfd_cleanup
895
bfd_generic_archive_p (bfd *abfd)
896
21.2M
{
897
21.2M
  struct artdata *tdata_hold;
898
21.2M
  char armag[SARMAG + 1];
899
21.2M
  size_t amt;
900
901
21.2M
  if (bfd_read (armag, SARMAG, abfd) != SARMAG)
902
96.6k
    {
903
96.6k
      if (bfd_get_error () != bfd_error_system_call)
904
93.5k
  bfd_set_error (bfd_error_wrong_format);
905
96.6k
      return NULL;
906
96.6k
    }
907
908
21.1M
  bfd_set_thin_archive (abfd, strncmp (armag, ARMAGT, SARMAG) == 0);
909
910
21.1M
  if (strncmp (armag, ARMAG, SARMAG) != 0
911
21.1M
      && ! bfd_is_thin_archive (abfd))
912
15.2M
    {
913
15.2M
      bfd_set_error (bfd_error_wrong_format);
914
15.2M
      return NULL;
915
15.2M
    }
916
917
5.88M
  tdata_hold = bfd_ardata (abfd);
918
919
5.88M
  amt = sizeof (struct artdata);
920
5.88M
  bfd_ardata (abfd) = (struct artdata *) bfd_zalloc (abfd, amt);
921
5.88M
  if (bfd_ardata (abfd) == NULL)
922
0
    {
923
0
      bfd_ardata (abfd) = tdata_hold;
924
0
      return NULL;
925
0
    }
926
927
5.88M
  bfd_ardata (abfd)->first_file_filepos = SARMAG;
928
929
5.88M
  if (!BFD_SEND (abfd, _bfd_slurp_armap, (abfd))
930
5.88M
      || !BFD_SEND (abfd, _bfd_slurp_extended_name_table, (abfd)))
931
3.00M
    {
932
3.00M
      if (bfd_get_error () != bfd_error_system_call)
933
3.00M
  bfd_set_error (bfd_error_wrong_format);
934
3.00M
      bfd_release (abfd, bfd_ardata (abfd));
935
3.00M
      bfd_ardata (abfd) = tdata_hold;
936
3.00M
      return NULL;
937
3.00M
    }
938
939
2.87M
  if (abfd->target_defaulted && bfd_has_map (abfd))
940
1.62M
    {
941
1.62M
      bfd *first;
942
1.62M
      unsigned int save;
943
944
      /* This archive has a map, so we may presume that the contents
945
   are object files.  Make sure that if the first file in the
946
   archive can be recognized as an object file, it is for this
947
   target.  If not, assume that this is the wrong format.  If
948
   the first file is not an object file, somebody is doing
949
   something weird, and we permit it so that ar -t will work.
950
951
   This is done because any normal format will recognize any
952
   normal archive, regardless of the format of the object files.
953
   We do accept an empty archive.  */
954
955
1.62M
      save = abfd->no_element_cache;
956
1.62M
      abfd->no_element_cache = 1;
957
1.62M
      first = bfd_openr_next_archived_file (abfd, NULL);
958
1.62M
      abfd->no_element_cache = save;
959
1.62M
      if (first != NULL)
960
1.61M
  {
961
1.61M
    first->target_defaulted = false;
962
1.61M
    if (bfd_check_format (first, bfd_object)
963
1.61M
        && first->xvec != abfd->xvec)
964
1.23M
      bfd_set_error (bfd_error_wrong_object_format);
965
1.61M
    bfd_close (first);
966
1.61M
  }
967
1.62M
    }
968
969
2.87M
  return _bfd_no_cleanup;
970
5.88M
}
971
972
/* Some constants for a 32 bit BSD archive structure.  We do not
973
   support 64 bit archives presently; so far as I know, none actually
974
   exist.  Supporting them would require changing these constants, and
975
   changing some H_GET_32 to H_GET_64.  */
976
977
/* The size of an external symdef structure.  */
978
3.34M
#define BSD_SYMDEF_SIZE 8
979
980
/* The offset from the start of a symdef structure to the file offset.  */
981
#define BSD_SYMDEF_OFFSET_SIZE 4
982
983
/* The size of the symdef count.  */
984
8.21M
#define BSD_SYMDEF_COUNT_SIZE 4
985
986
/* The size of the string count.  */
987
8.21M
#define BSD_STRING_COUNT_SIZE 4
988
989
/* Read a BSD-style archive symbol table.  Returns FALSE on error,
990
   TRUE otherwise.  */
991
992
static bool
993
do_slurp_bsd_armap (bfd *abfd)
994
3.57M
{
995
3.57M
  struct areltdata *mapdata;
996
3.57M
  size_t counter;
997
3.57M
  bfd_byte *raw_armap, *rbase;
998
3.57M
  struct artdata *ardata = bfd_ardata (abfd);
999
3.57M
  char *stringbase;
1000
3.57M
  bfd_size_type parsed_size;
1001
3.57M
  size_t amt, string_size;
1002
3.57M
  carsym *set;
1003
1004
3.57M
  mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
1005
3.57M
  if (mapdata == NULL)
1006
31.3k
    return false;
1007
3.54M
  parsed_size = mapdata->parsed_size;
1008
3.54M
  free (mapdata);
1009
  /* PR 17512: file: 883ff754.  */
1010
  /* PR 17512: file: 0458885f.  */
1011
3.54M
  if (parsed_size < BSD_SYMDEF_COUNT_SIZE + BSD_STRING_COUNT_SIZE)
1012
2.12k
    {
1013
2.12k
      bfd_set_error (bfd_error_malformed_archive);
1014
2.12k
      return false;
1015
2.12k
    }
1016
1017
3.54M
  raw_armap = (bfd_byte *) _bfd_alloc_and_read (abfd, parsed_size, parsed_size);
1018
3.54M
  if (raw_armap == NULL)
1019
30.4k
    return false;
1020
1021
3.51M
  parsed_size -= BSD_SYMDEF_COUNT_SIZE + BSD_STRING_COUNT_SIZE;
1022
3.51M
  amt = H_GET_32 (abfd, raw_armap);
1023
3.51M
  if (amt > parsed_size
1024
3.51M
      || amt % BSD_SYMDEF_SIZE != 0)
1025
2.36M
    {
1026
      /* Probably we're using the wrong byte ordering.  */
1027
2.36M
      bfd_set_error (bfd_error_wrong_format);
1028
2.36M
      goto release_armap;
1029
2.36M
    }
1030
1031
1.15M
  rbase = raw_armap + BSD_SYMDEF_COUNT_SIZE;
1032
1.15M
  stringbase = (char *) rbase + amt + BSD_STRING_COUNT_SIZE;
1033
1.15M
  string_size = parsed_size - amt;
1034
1035
1.15M
  ardata->symdef_count = amt / BSD_SYMDEF_SIZE;
1036
1.15M
  if (_bfd_mul_overflow (ardata->symdef_count, sizeof (carsym), &amt))
1037
0
    {
1038
0
      bfd_set_error (bfd_error_no_memory);
1039
0
      goto release_armap;
1040
0
    }
1041
1.15M
  ardata->symdefs = (struct carsym *) bfd_alloc (abfd, amt);
1042
1.15M
  if (!ardata->symdefs)
1043
0
    goto release_armap;
1044
1045
1.15M
  for (counter = 0, set = ardata->symdefs;
1046
2.19M
       counter < ardata->symdef_count;
1047
1.15M
       counter++, set++, rbase += BSD_SYMDEF_SIZE)
1048
1.04M
    {
1049
1.04M
      unsigned nameoff = H_GET_32 (abfd, rbase);
1050
1.04M
      if (nameoff >= string_size)
1051
6.04k
  {
1052
6.04k
    bfd_set_error (bfd_error_malformed_archive);
1053
6.04k
    goto release_armap;
1054
6.04k
  }
1055
1.03M
      set->name = stringbase + nameoff;
1056
1.03M
      set->file_offset = H_GET_32 (abfd, rbase + BSD_SYMDEF_OFFSET_SIZE);
1057
1.03M
    }
1058
1059
1.14M
  ardata->first_file_filepos = bfd_tell (abfd);
1060
  /* Pad to an even boundary if you have to.  */
1061
1.14M
  ardata->first_file_filepos += (ardata->first_file_filepos) % 2;
1062
  /* FIXME, we should provide some way to free raw_ardata when
1063
     we are done using the strings from it.  For now, it seems
1064
     to be allocated on an objalloc anyway...  */
1065
1.14M
  abfd->has_armap = true;
1066
1.14M
  return true;
1067
1068
2.36M
 release_armap:
1069
2.36M
  ardata->symdef_count = 0;
1070
2.36M
  ardata->symdefs = NULL;
1071
2.36M
  bfd_release (abfd, raw_armap);
1072
2.36M
  return false;
1073
1.15M
}
1074
1075
/* Read a COFF archive symbol table.  Returns FALSE on error, TRUE
1076
   otherwise.  */
1077
1078
static bool
1079
do_slurp_coff_armap (bfd *abfd)
1080
869k
{
1081
869k
  struct areltdata *mapdata;
1082
869k
  int *raw_armap, *rawptr;
1083
869k
  struct artdata *ardata = bfd_ardata (abfd);
1084
869k
  char *stringbase;
1085
869k
  char *stringend;
1086
869k
  bfd_size_type stringsize;
1087
869k
  bfd_size_type parsed_size;
1088
869k
  ufile_ptr filesize;
1089
869k
  size_t nsymz, carsym_size, ptrsize, i;
1090
869k
  carsym *carsyms;
1091
869k
  bfd_vma (*swap) (const void *);
1092
869k
  char int_buf[4];
1093
869k
  struct areltdata *tmp;
1094
1095
869k
  mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
1096
869k
  if (mapdata == NULL)
1097
318k
    return false;
1098
550k
  parsed_size = mapdata->parsed_size;
1099
550k
  free (mapdata);
1100
1101
550k
  if (bfd_read (int_buf, 4, abfd) != 4)
1102
1.92k
    return false;
1103
1104
  /* It seems that all numeric information in a coff archive is always
1105
     in big endian format, no matter the host or target.  */
1106
548k
  swap = bfd_getb32;
1107
548k
  nsymz = bfd_getb32 (int_buf);
1108
1109
  /* The coff armap must be read sequentially.  So we construct a
1110
     bsd-style one in core all at once, for simplicity.  */
1111
1112
548k
  if (_bfd_mul_overflow (nsymz, sizeof (carsym), &carsym_size))
1113
0
    {
1114
0
      bfd_set_error (bfd_error_no_memory);
1115
0
      return false;
1116
0
    }
1117
1118
548k
  filesize = bfd_get_file_size (abfd);
1119
548k
  ptrsize = 4 * nsymz;
1120
548k
  if ((filesize != 0 && parsed_size > filesize)
1121
548k
      || parsed_size < 4
1122
548k
      || parsed_size - 4 < ptrsize)
1123
51.9k
    {
1124
51.9k
      bfd_set_error (bfd_error_malformed_archive);
1125
51.9k
      return false;
1126
51.9k
    }
1127
1128
496k
  stringsize = parsed_size - ptrsize - 4;
1129
1130
496k
  if (carsym_size + stringsize + 1 <= carsym_size)
1131
0
    {
1132
0
      bfd_set_error (bfd_error_no_memory);
1133
0
      return false;
1134
0
    }
1135
1136
  /* Allocate and read in the raw offsets.  */
1137
496k
  raw_armap = (int *) _bfd_malloc_and_read (abfd, ptrsize, ptrsize);
1138
496k
  if (raw_armap == NULL)
1139
3.12k
    return false;
1140
1141
493k
  ardata->symdefs = (struct carsym *) bfd_alloc (abfd,
1142
493k
             carsym_size + stringsize + 1);
1143
493k
  if (ardata->symdefs == NULL)
1144
0
    goto free_armap;
1145
493k
  carsyms = ardata->symdefs;
1146
493k
  stringbase = ((char *) ardata->symdefs) + carsym_size;
1147
1148
493k
  if (bfd_read (stringbase, stringsize, abfd) != stringsize)
1149
4.08k
    goto release_symdefs;
1150
1151
  /* OK, build the carsyms.  */
1152
489k
  stringend = stringbase + stringsize;
1153
489k
  *stringend = 0;
1154
1.08M
  for (i = 0; i < nsymz; i++)
1155
600k
    {
1156
600k
      rawptr = raw_armap + i;
1157
600k
      carsyms->file_offset = swap ((bfd_byte *) rawptr);
1158
600k
      carsyms->name = stringbase;
1159
600k
      stringbase += strlen (stringbase);
1160
600k
      if (stringbase != stringend)
1161
401k
  ++stringbase;
1162
600k
      carsyms++;
1163
600k
    }
1164
1165
489k
  ardata->symdef_count = nsymz;
1166
489k
  ardata->first_file_filepos = bfd_tell (abfd);
1167
  /* Pad to an even boundary if you have to.  */
1168
489k
  ardata->first_file_filepos += (ardata->first_file_filepos) % 2;
1169
489k
  if (bfd_seek (abfd, ardata->first_file_filepos, SEEK_SET) != 0)
1170
0
    goto release_symdefs;
1171
1172
489k
  abfd->has_armap = true;
1173
489k
  free (raw_armap);
1174
1175
  /* Check for a second archive header (as used by PE).  */
1176
489k
  tmp = (struct areltdata *) _bfd_read_ar_hdr (abfd);
1177
489k
  if (tmp != NULL)
1178
477k
    {
1179
477k
      if (tmp->arch_header[0] == '/'
1180
477k
    && tmp->arch_header[1] == ' ')
1181
1.46k
  ardata->first_file_filepos
1182
1.46k
    += (tmp->parsed_size + sizeof (struct ar_hdr) + 1) & ~(unsigned) 1;
1183
477k
      free (tmp);
1184
477k
    }
1185
1186
489k
  return true;
1187
1188
4.08k
 release_symdefs:
1189
4.08k
  bfd_release (abfd, (ardata)->symdefs);
1190
4.08k
 free_armap:
1191
4.08k
  free (raw_armap);
1192
4.08k
  return false;
1193
4.08k
}
1194
1195
/* This routine can handle either coff-style or bsd-style armaps
1196
   (archive symbol table).  Returns FALSE on error, TRUE otherwise */
1197
1198
bool
1199
bfd_slurp_armap (bfd *abfd)
1200
5.77M
{
1201
5.77M
  char nextname[17];
1202
5.77M
  int i = bfd_read (nextname, 16, abfd);
1203
1204
5.77M
  if (i == 0)
1205
1.41k
    return true;
1206
5.77M
  if (i != 16)
1207
5.19k
    return false;
1208
1209
5.76M
  if (bfd_seek (abfd, -16, SEEK_CUR) != 0)
1210
0
    return false;
1211
1212
5.76M
  if (startswith (nextname, "__.SYMDEF       ")
1213
5.76M
      || startswith (nextname, "__.SYMDEF/      ")) /* Old Linux archives.  */
1214
3.57M
    return do_slurp_bsd_armap (abfd);
1215
2.19M
  else if (startswith (nextname, "/               "))
1216
869k
    return do_slurp_coff_armap (abfd);
1217
1.32M
  else if (startswith (nextname, "/SYM64/         "))
1218
84.1k
    {
1219
      /* 64bit (Irix 6) archive.  */
1220
84.1k
#ifdef BFD64
1221
84.1k
      return _bfd_archive_64_bit_slurp_armap (abfd);
1222
#else
1223
      bfd_set_error (bfd_error_wrong_format);
1224
      return false;
1225
#endif
1226
84.1k
    }
1227
1.23M
  else if (startswith (nextname, "#1/20           "))
1228
9.20k
    {
1229
      /* Mach-O has a special name for armap when the map is sorted by name.
1230
   However because this name has a space it is slightly more difficult
1231
   to check it.  */
1232
9.20k
      struct ar_hdr hdr;
1233
9.20k
      char extname[21];
1234
1235
9.20k
      if (bfd_read (&hdr, sizeof (hdr), abfd) != sizeof (hdr))
1236
3.06k
  return false;
1237
      /* Read the extended name.  We know its length.  */
1238
6.13k
      if (bfd_read (extname, 20, abfd) != 20)
1239
1.88k
  return false;
1240
4.25k
      if (bfd_seek (abfd, -(file_ptr) (sizeof (hdr) + 20), SEEK_CUR) != 0)
1241
0
  return false;
1242
4.25k
      extname[20] = 0;
1243
4.25k
      if (startswith (extname, "__.SYMDEF SORTED")
1244
4.25k
    || startswith (extname, "__.SYMDEF"))
1245
3.06k
  return do_slurp_bsd_armap (abfd);
1246
4.25k
    }
1247
1248
1.23M
  abfd->has_armap = false;
1249
1.23M
  return true;
1250
5.76M
}
1251

1252
/** Extended name table.
1253
1254
  Normally archives support only 14-character filenames.
1255
1256
  Intel has extended the format: longer names are stored in a special
1257
  element (the first in the archive, or second if there is an armap);
1258
  the name in the ar_hdr is replaced by <space><index into filename
1259
  element>.  Index is the P.R. of an int (decimal).  Data General have
1260
  extended the format by using the prefix // for the special element.  */
1261
1262
/* Returns FALSE on error, TRUE otherwise.  */
1263
1264
bool
1265
_bfd_slurp_extended_name_table (bfd *abfd)
1266
2.97M
{
1267
2.97M
  char nextname[17];
1268
1269
  /* FIXME:  Formatting sucks here, and in case of failure of BFD_READ,
1270
     we probably don't want to return TRUE.  */
1271
2.97M
  if (bfd_seek (abfd, bfd_ardata (abfd)->first_file_filepos, SEEK_SET) != 0)
1272
0
    return false;
1273
1274
2.97M
  if (bfd_read (nextname, 16, abfd) == 16)
1275
2.97M
    {
1276
2.97M
      struct areltdata *namedata;
1277
2.97M
      bfd_size_type amt;
1278
2.97M
      ufile_ptr filesize;
1279
1280
2.97M
      if (bfd_seek (abfd, -16, SEEK_CUR) != 0)
1281
0
  return false;
1282
1283
2.97M
      if (! startswith (nextname, "ARFILENAMES/    ")
1284
2.97M
    && ! startswith (nextname, "//              "))
1285
2.83M
  {
1286
2.83M
    bfd_ardata (abfd)->extended_names = NULL;
1287
2.83M
    bfd_ardata (abfd)->extended_names_size = 0;
1288
2.83M
    return true;
1289
2.83M
  }
1290
1291
133k
      namedata = (struct areltdata *) _bfd_read_ar_hdr (abfd);
1292
133k
      if (namedata == NULL)
1293
83.8k
  return false;
1294
1295
50.1k
      filesize = bfd_get_file_size (abfd);
1296
50.1k
      amt = namedata->parsed_size;
1297
50.1k
      if (amt + 1 == 0 || (filesize != 0 && amt > filesize))
1298
11.6k
  {
1299
11.6k
    bfd_set_error (bfd_error_malformed_archive);
1300
11.6k
    goto byebye;
1301
11.6k
  }
1302
1303
38.4k
      bfd_ardata (abfd)->extended_names_size = amt;
1304
38.4k
      bfd_ardata (abfd)->extended_names = (char *) bfd_alloc (abfd, amt + 1);
1305
38.4k
      if (bfd_ardata (abfd)->extended_names == NULL)
1306
0
  {
1307
15.4k
  byebye:
1308
15.4k
    free (namedata);
1309
15.4k
    bfd_ardata (abfd)->extended_names = NULL;
1310
15.4k
    bfd_ardata (abfd)->extended_names_size = 0;
1311
15.4k
    return false;
1312
0
  }
1313
1314
38.4k
      if (bfd_read (bfd_ardata (abfd)->extended_names, amt, abfd) != amt)
1315
3.81k
  {
1316
3.81k
    if (bfd_get_error () != bfd_error_system_call)
1317
3.81k
      bfd_set_error (bfd_error_malformed_archive);
1318
3.81k
    bfd_release (abfd, (bfd_ardata (abfd)->extended_names));
1319
3.81k
    bfd_ardata (abfd)->extended_names = NULL;
1320
3.81k
    goto byebye;
1321
3.81k
  }
1322
34.6k
      bfd_ardata (abfd)->extended_names[amt] = 0;
1323
1324
      /* Since the archive is supposed to be printable if it contains
1325
   text, the entries in the list are newline-padded, not null
1326
   padded. In SVR4-style archives, the names also have a
1327
   trailing '/'.  DOS/NT created archive often have \ in them
1328
   We'll fix all problems here.  */
1329
34.6k
      {
1330
34.6k
  char *ext_names = bfd_ardata (abfd)->extended_names;
1331
34.6k
  char *temp = ext_names;
1332
34.6k
  char *limit = temp + namedata->parsed_size;
1333
1334
1.73M
  for (; temp < limit; ++temp)
1335
1.69M
    {
1336
1.69M
      if (*temp == ARFMAG[1])
1337
41.6k
        temp[temp > ext_names && temp[-1] == '/' ? -1 : 0] = '\0';
1338
1.69M
      if (*temp == '\\')
1339
11.4k
        *temp = '/';
1340
1.69M
    }
1341
34.6k
  *limit = '\0';
1342
34.6k
      }
1343
1344
      /* Pad to an even boundary if you have to.  */
1345
34.6k
      bfd_ardata (abfd)->first_file_filepos = bfd_tell (abfd);
1346
34.6k
      bfd_ardata (abfd)->first_file_filepos +=
1347
34.6k
  (bfd_ardata (abfd)->first_file_filepos) % 2;
1348
1349
34.6k
      free (namedata);
1350
34.6k
    }
1351
37.2k
  return true;
1352
2.97M
}
1353
1354
#ifdef VMS
1355
1356
/* Return a copy of the stuff in the filename between any :]> and a
1357
   semicolon.  */
1358
1359
static const char *
1360
normalize (bfd *abfd, const char *file)
1361
{
1362
  const char *first;
1363
  const char *last;
1364
  char *copy;
1365
1366
  if (abfd->flags & BFD_ARCHIVE_FULL_PATH)
1367
    return file;
1368
1369
  first = file + strlen (file) - 1;
1370
  last = first + 1;
1371
1372
  while (first != file)
1373
    {
1374
      if (*first == ';')
1375
  last = first;
1376
      if (*first == ':' || *first == ']' || *first == '>')
1377
  {
1378
    first++;
1379
    break;
1380
  }
1381
      first--;
1382
    }
1383
1384
  copy = bfd_alloc (abfd, last - first + 1);
1385
  if (copy == NULL)
1386
    return NULL;
1387
1388
  memcpy (copy, first, last - first);
1389
  copy[last - first] = 0;
1390
1391
  return copy;
1392
}
1393
1394
#else
1395
static const char *
1396
normalize (bfd *abfd, const char *file)
1397
0
{
1398
0
  if (abfd->flags & BFD_ARCHIVE_FULL_PATH)
1399
0
    return file;
1400
0
  return lbasename (file);
1401
0
}
1402
#endif
1403
1404
/* Adjust a relative path name based on the reference path.
1405
   For example:
1406
1407
     Relative path  Reference path  Result
1408
     -------------  --------------  ------
1409
     bar.o      lib.a     bar.o
1410
     foo/bar.o      lib.a     foo/bar.o
1411
     bar.o      foo/lib.a     ../bar.o
1412
     foo/bar.o      baz/lib.a     ../foo/bar.o
1413
     bar.o      ../lib.a      <parent of current dir>/bar.o
1414
   ; ../bar.o     ../lib.a      bar.o
1415
   ; ../bar.o     lib.a     ../bar.o
1416
     foo/bar.o      ../lib.a      <parent of current dir>/foo/bar.o
1417
     bar.o      ../../lib.a     <grandparent>/<parent>/bar.o
1418
     bar.o      foo/baz/lib.a   ../../bar.o
1419
1420
   Note - the semicolons above are there to prevent the BFD chew
1421
   utility from interpreting those lines as prototypes to put into
1422
   the autogenerated bfd.h header...
1423
1424
   Note - the string is returned in a static buffer.  */
1425
1426
static const char *
1427
adjust_relative_path (const char * path, const char * ref_path)
1428
0
{
1429
0
  static char *pathbuf = NULL;
1430
0
  static unsigned int pathbuf_len = 0;
1431
0
  const char *pathp;
1432
0
  const char *refp;
1433
0
  char * lpath;
1434
0
  char * rpath;
1435
0
  unsigned int len;
1436
0
  unsigned int dir_up = 0;
1437
0
  unsigned int dir_down = 0;
1438
0
  char *newp;
1439
0
  char * pwd = getpwd ();
1440
0
  const char * down;
1441
1442
  /* Remove symlinks, '.' and '..' from the paths, if possible.  */
1443
0
  lpath = lrealpath (path);
1444
0
  pathp = lpath == NULL ? path : lpath;
1445
1446
0
  rpath = lrealpath (ref_path);
1447
0
  refp = rpath == NULL ? ref_path : rpath;
1448
1449
  /* Remove common leading path elements.  */
1450
0
  for (;;)
1451
0
    {
1452
0
      const char *e1 = pathp;
1453
0
      const char *e2 = refp;
1454
1455
0
      while (*e1 && ! IS_DIR_SEPARATOR (*e1))
1456
0
  ++e1;
1457
0
      while (*e2 && ! IS_DIR_SEPARATOR (*e2))
1458
0
  ++e2;
1459
0
      if (*e1 == '\0' || *e2 == '\0' || e1 - pathp != e2 - refp
1460
0
    || filename_ncmp (pathp, refp, e1 - pathp) != 0)
1461
0
  break;
1462
0
      pathp = e1 + 1;
1463
0
      refp = e2 + 1;
1464
0
    }
1465
1466
0
  len = strlen (pathp) + 1;
1467
  /* For each leading path element in the reference path,
1468
     insert "../" into the path.  */
1469
0
  for (; *refp; ++refp)
1470
0
    if (IS_DIR_SEPARATOR (*refp))
1471
0
      {
1472
  /* PR 12710:  If the path element is "../" then instead of
1473
     inserting "../" we need to insert the name of the directory
1474
     at the current level.  */
1475
0
  if (refp > ref_path + 1
1476
0
      && refp[-1] == '.'
1477
0
      && refp[-2] == '.')
1478
0
    dir_down ++;
1479
0
  else
1480
0
    dir_up ++;
1481
0
      }
1482
1483
  /* If the lrealpath calls above succeeded then we should never
1484
     see dir_up and dir_down both being non-zero.  */
1485
1486
0
  len += 3 * dir_up;
1487
1488
0
  if (dir_down)
1489
0
    {
1490
0
      down = pwd + strlen (pwd) - 1;
1491
1492
0
      while (dir_down && down > pwd)
1493
0
  {
1494
0
    if (IS_DIR_SEPARATOR (*down))
1495
0
      --dir_down;
1496
0
  }
1497
0
      BFD_ASSERT (dir_down == 0);
1498
0
      len += strlen (down) + 1;
1499
0
    }
1500
0
  else
1501
0
    down = NULL;
1502
1503
0
  if (len > pathbuf_len)
1504
0
    {
1505
0
      free (pathbuf);
1506
0
      pathbuf_len = 0;
1507
0
      pathbuf = (char *) bfd_malloc (len);
1508
0
      if (pathbuf == NULL)
1509
0
  goto out;
1510
0
      pathbuf_len = len;
1511
0
    }
1512
1513
0
  newp = pathbuf;
1514
0
  while (dir_up-- > 0)
1515
0
    {
1516
      /* FIXME: Support Windows style path separators as well.  */
1517
0
      strcpy (newp, "../");
1518
0
      newp += 3;
1519
0
    }
1520
1521
0
  if (down)
1522
0
    sprintf (newp, "%s/%s", down, pathp);
1523
0
  else
1524
0
    strcpy (newp, pathp);
1525
1526
0
 out:
1527
0
  free (lpath);
1528
0
  free (rpath);
1529
0
  return pathbuf;
1530
0
}
1531
1532
/* Build a BFD style extended name table.  */
1533
1534
bool
1535
_bfd_archive_bsd_construct_extended_name_table (bfd *abfd,
1536
            char **tabloc,
1537
            bfd_size_type *tablen,
1538
            const char **name)
1539
3.59k
{
1540
3.59k
  *name = "ARFILENAMES/";
1541
3.59k
  return _bfd_construct_extended_name_table (abfd, false, tabloc, tablen);
1542
3.59k
}
1543
1544
/* Build an SVR4 style extended name table.  */
1545
1546
bool
1547
_bfd_archive_coff_construct_extended_name_table (bfd *abfd,
1548
             char **tabloc,
1549
             bfd_size_type *tablen,
1550
             const char **name)
1551
9.64k
{
1552
9.64k
  *name = "//";
1553
9.64k
  return _bfd_construct_extended_name_table (abfd, true, tabloc, tablen);
1554
9.64k
}
1555
1556
bool
1557
_bfd_noarchive_construct_extended_name_table (bfd *abfd ATTRIBUTE_UNUSED,
1558
                char **tabloc ATTRIBUTE_UNUSED,
1559
                bfd_size_type *len ATTRIBUTE_UNUSED,
1560
                const char **name ATTRIBUTE_UNUSED)
1561
3
{
1562
3
  return true;
1563
3
}
1564
1565
/* Follows archive_head and produces an extended name table if
1566
   necessary.  Returns (in tabloc) a pointer to an extended name
1567
   table, and in tablen the length of the table.  If it makes an entry
1568
   it clobbers the filename so that the element may be written without
1569
   further massage.  Returns TRUE if it ran successfully, FALSE if
1570
   something went wrong.  A successful return may still involve a
1571
   zero-length tablen!  */
1572
1573
bool
1574
_bfd_construct_extended_name_table (bfd *abfd,
1575
            bool trailing_slash,
1576
            char **tabloc,
1577
            bfd_size_type *tablen)
1578
13.2k
{
1579
13.2k
  unsigned int maxname = ar_maxnamelen (abfd);
1580
13.2k
  bfd_size_type total_namelen = 0;
1581
13.2k
  bfd *current;
1582
13.2k
  char *strptr;
1583
13.2k
  const char *last_filename;
1584
13.2k
  long last_stroff;
1585
1586
13.2k
  *tablen = 0;
1587
13.2k
  last_filename = NULL;
1588
1589
  /* Figure out how long the table should be.  */
1590
13.2k
  for (current = abfd->archive_head;
1591
13.2k
       current != NULL;
1592
13.2k
       current = current->archive_next)
1593
0
    {
1594
0
      const char *normal;
1595
0
      unsigned int thislen;
1596
1597
0
      if (bfd_is_thin_archive (abfd))
1598
0
  {
1599
0
    const char *filename = bfd_get_filename (current);
1600
1601
    /* If the element being added is a member of another archive
1602
       (i.e., we are flattening), use the containing archive's name.  */
1603
0
    if (current->my_archive
1604
0
        && ! bfd_is_thin_archive (current->my_archive))
1605
0
      filename = bfd_get_filename (current->my_archive);
1606
1607
    /* If the path is the same as the previous path seen,
1608
       reuse it.  This can happen when flattening a thin
1609
       archive that contains other archives.  */
1610
0
    if (last_filename && filename_cmp (last_filename, filename) == 0)
1611
0
      continue;
1612
1613
0
    last_filename = filename;
1614
1615
    /* If the path is relative, adjust it relative to
1616
       the containing archive. */
1617
0
    if (! IS_ABSOLUTE_PATH (filename)
1618
0
        && ! IS_ABSOLUTE_PATH (bfd_get_filename (abfd)))
1619
0
      normal = adjust_relative_path (filename, bfd_get_filename (abfd));
1620
0
    else
1621
0
      normal = filename;
1622
1623
    /* In a thin archive, always store the full pathname
1624
       in the extended name table.  */
1625
0
    total_namelen += strlen (normal) + 1;
1626
0
    if (trailing_slash)
1627
      /* Leave room for trailing slash.  */
1628
0
      ++total_namelen;
1629
1630
0
    continue;
1631
0
  }
1632
1633
0
      normal = normalize (abfd, bfd_get_filename (current));
1634
0
      if (normal == NULL)
1635
0
  return false;
1636
1637
0
      thislen = strlen (normal);
1638
1639
0
      if (thislen > maxname
1640
0
    && (bfd_get_file_flags (abfd) & BFD_TRADITIONAL_FORMAT) != 0)
1641
0
  thislen = maxname;
1642
1643
0
      if (thislen > maxname)
1644
0
  {
1645
    /* Add one to leave room for \n.  */
1646
0
    total_namelen += thislen + 1;
1647
0
    if (trailing_slash)
1648
0
      {
1649
        /* Leave room for trailing slash.  */
1650
0
        ++total_namelen;
1651
0
      }
1652
0
  }
1653
0
      else
1654
0
  {
1655
0
    struct ar_hdr *hdr = arch_hdr (current);
1656
0
    if (filename_ncmp (normal, hdr->ar_name, thislen) != 0
1657
0
        || (thislen < sizeof hdr->ar_name
1658
0
      && hdr->ar_name[thislen] != ar_padchar (current)))
1659
0
      {
1660
        /* Must have been using extended format even though it
1661
     didn't need to.  Fix it to use normal format.  */
1662
0
        memcpy (hdr->ar_name, normal, thislen);
1663
0
        if (thislen < maxname
1664
0
      || (thislen == maxname && thislen < sizeof hdr->ar_name))
1665
0
    hdr->ar_name[thislen] = ar_padchar (current);
1666
0
      }
1667
0
  }
1668
0
    }
1669
1670
13.2k
  if (total_namelen == 0)
1671
13.2k
    return true;
1672
1673
0
  *tabloc = (char *) bfd_alloc (abfd, total_namelen);
1674
0
  if (*tabloc == NULL)
1675
0
    return false;
1676
1677
0
  *tablen = total_namelen;
1678
0
  strptr = *tabloc;
1679
1680
0
  last_filename = NULL;
1681
0
  last_stroff = 0;
1682
1683
0
  for (current = abfd->archive_head;
1684
0
       current != NULL;
1685
0
       current = current->archive_next)
1686
0
    {
1687
0
      const char *normal;
1688
0
      unsigned int thislen;
1689
0
      long stroff;
1690
0
      const char *filename = bfd_get_filename (current);
1691
1692
0
      if (bfd_is_thin_archive (abfd))
1693
0
  {
1694
    /* If the element being added is a member of another archive
1695
       (i.e., we are flattening), use the containing archive's name.  */
1696
0
    if (current->my_archive
1697
0
        && ! bfd_is_thin_archive (current->my_archive))
1698
0
      filename = bfd_get_filename (current->my_archive);
1699
    /* If the path is the same as the previous path seen,
1700
       reuse it.  This can happen when flattening a thin
1701
       archive that contains other archives.
1702
       If the path is relative, adjust it relative to
1703
       the containing archive.  */
1704
0
    if (last_filename && filename_cmp (last_filename, filename) == 0)
1705
0
      normal = last_filename;
1706
0
    else if (! IS_ABSOLUTE_PATH (filename)
1707
0
       && ! IS_ABSOLUTE_PATH (bfd_get_filename (abfd)))
1708
0
      normal = adjust_relative_path (filename, bfd_get_filename (abfd));
1709
0
    else
1710
0
      normal = filename;
1711
0
  }
1712
0
      else
1713
0
  {
1714
0
    normal = normalize (abfd, filename);
1715
0
    if (normal == NULL)
1716
0
      return false;
1717
0
  }
1718
1719
0
      thislen = strlen (normal);
1720
0
      if (thislen > maxname || bfd_is_thin_archive (abfd))
1721
0
  {
1722
    /* Works for now; may need to be re-engineered if we
1723
       encounter an oddball archive format and want to
1724
       generalise this hack.  */
1725
0
    struct ar_hdr *hdr = arch_hdr (current);
1726
0
    if (normal == last_filename)
1727
0
      stroff = last_stroff;
1728
0
    else
1729
0
      {
1730
0
        last_filename = filename;
1731
0
        stroff = strptr - *tabloc;
1732
0
        last_stroff = stroff;
1733
0
        memcpy (strptr, normal, thislen);
1734
0
        strptr += thislen;
1735
0
        if (trailing_slash)
1736
0
    *strptr++ = '/';
1737
0
        *strptr++ = ARFMAG[1];
1738
0
      }
1739
0
    hdr->ar_name[0] = ar_padchar (current);
1740
0
    if (bfd_is_thin_archive (abfd) && current->origin > 0)
1741
0
      {
1742
0
        int len = snprintf (hdr->ar_name + 1, maxname - 1, "%-ld:",
1743
0
          stroff);
1744
0
        _bfd_ar_spacepad (hdr->ar_name + 1 + len, maxname - 1 - len,
1745
0
        "%-ld",
1746
0
        current->origin - sizeof (struct ar_hdr));
1747
0
      }
1748
0
    else
1749
0
      _bfd_ar_spacepad (hdr->ar_name + 1, maxname - 1, "%-ld", stroff);
1750
0
  }
1751
0
    }
1752
1753
0
  return true;
1754
0
}
1755
1756
/* Do not construct an extended name table but transforms name field into
1757
   its extended form.  */
1758
1759
bool
1760
_bfd_archive_bsd44_construct_extended_name_table (bfd *abfd,
1761
              char **tabloc,
1762
              bfd_size_type *tablen,
1763
              const char **name)
1764
4
{
1765
4
  unsigned int maxname = ar_maxnamelen (abfd);
1766
4
  bfd *current;
1767
1768
4
  *tablen = 0;
1769
4
  *tabloc = NULL;
1770
4
  *name = NULL;
1771
1772
4
  for (current = abfd->archive_head;
1773
4
       current != NULL;
1774
4
       current = current->archive_next)
1775
0
    {
1776
0
      const char *normal = normalize (abfd, bfd_get_filename (current));
1777
0
      int has_space = 0;
1778
0
      unsigned int len;
1779
1780
0
      if (normal == NULL)
1781
0
  return false;
1782
1783
0
      for (len = 0; normal[len]; len++)
1784
0
  if (normal[len] == ' ')
1785
0
    has_space = 1;
1786
1787
0
      if (len > maxname || has_space)
1788
0
  {
1789
0
    struct ar_hdr *hdr = arch_hdr (current);
1790
1791
0
    len = (len + 3) & ~3;
1792
0
    arch_eltdata (current)->extra_size = len;
1793
0
    _bfd_ar_spacepad (hdr->ar_name, maxname, "#1/%lu", len);
1794
0
  }
1795
0
    }
1796
1797
4
  return true;
1798
4
}
1799

1800
/* Write an archive header.  */
1801
1802
bool
1803
_bfd_generic_write_ar_hdr (bfd *archive, bfd *abfd)
1804
0
{
1805
0
  struct ar_hdr *hdr = arch_hdr (abfd);
1806
1807
0
  if (bfd_write (hdr, sizeof (*hdr), archive) != sizeof (*hdr))
1808
0
    return false;
1809
0
  return true;
1810
0
}
1811
1812
/* Write an archive header using BSD4.4 convention.  */
1813
1814
bool
1815
_bfd_bsd44_write_ar_hdr (bfd *archive, bfd *abfd)
1816
0
{
1817
0
  struct ar_hdr *hdr = arch_hdr (abfd);
1818
1819
0
  if (is_bsd44_extended_name (hdr->ar_name))
1820
0
    {
1821
      /* This is a BSD 4.4 extended name.  */
1822
0
      const char *fullname = normalize (abfd, bfd_get_filename (abfd));
1823
0
      unsigned int len = strlen (fullname);
1824
0
      unsigned int padded_len = (len + 3) & ~3;
1825
1826
0
      BFD_ASSERT (padded_len == arch_eltdata (abfd)->extra_size);
1827
1828
0
      if (!_bfd_ar_sizepad (hdr->ar_size, sizeof (hdr->ar_size),
1829
0
          arch_eltdata (abfd)->parsed_size + padded_len))
1830
0
  return false;
1831
1832
0
      if (bfd_write (hdr, sizeof (*hdr), archive) != sizeof (*hdr))
1833
0
  return false;
1834
1835
0
      if (bfd_write (fullname, len, archive) != len)
1836
0
  return false;
1837
1838
0
      if (len & 3)
1839
0
  {
1840
0
    static const char pad[3] = { 0, 0, 0 };
1841
1842
0
    len = 4 - (len & 3);
1843
0
    if (bfd_write (pad, len, archive) != len)
1844
0
      return false;
1845
0
  }
1846
0
    }
1847
0
  else
1848
0
    {
1849
0
      if (bfd_write (hdr, sizeof (*hdr), archive) != sizeof (*hdr))
1850
0
  return false;
1851
0
    }
1852
0
  return true;
1853
0
}
1854
1855
bool
1856
_bfd_noarchive_write_ar_hdr (bfd *archive, bfd *abfd ATTRIBUTE_UNUSED)
1857
0
{
1858
0
  return _bfd_bool_bfd_false_error (archive);
1859
0
}
1860

1861
/* A couple of functions for creating ar_hdrs.  */
1862
1863
#ifdef HPUX_LARGE_AR_IDS
1864
/* Function to encode large UID/GID values according to HP.  */
1865
1866
static void
1867
hpux_uid_gid_encode (char str[6], long int id)
1868
{
1869
  int cnt;
1870
1871
  str[5] = '@' + (id & 3);
1872
  id >>= 2;
1873
1874
  for (cnt = 4; cnt >= 0; --cnt, id >>= 6)
1875
    str[cnt] = ' ' + (id & 0x3f);
1876
}
1877
#endif  /* HPUX_LARGE_AR_IDS */
1878
1879
/* Takes a filename, returns an arelt_data for it, or NULL if it can't
1880
   make one.  The filename must refer to a filename in the filesystem.
1881
   The filename field of the ar_hdr will NOT be initialized.  If member
1882
   is set, and it's an in-memory bfd, we fake it.  */
1883
1884
static struct areltdata *
1885
bfd_ar_hdr_from_filesystem (bfd *abfd, const char *filename, bfd *member)
1886
0
{
1887
0
  struct stat status;
1888
0
  struct areltdata *ared;
1889
0
  struct ar_hdr *hdr;
1890
0
  size_t amt;
1891
1892
0
  if (member && (member->flags & BFD_IN_MEMORY) != 0)
1893
0
    {
1894
      /* Assume we just "made" the member, and fake it.  */
1895
0
      struct bfd_in_memory *bim = (struct bfd_in_memory *) member->iostream;
1896
0
      status.st_mtime = bfd_get_current_time (0);
1897
0
      status.st_uid = getuid ();
1898
0
      status.st_gid = getgid ();
1899
0
      status.st_mode = 0644;
1900
0
      status.st_size = bim->size;
1901
0
    }
1902
0
  else if (stat (filename, &status) != 0)
1903
0
    {
1904
0
      bfd_set_error (bfd_error_system_call);
1905
0
      return NULL;
1906
0
    }
1907
0
  else
1908
0
    {
1909
      /* The call to stat() above has filled in the st_mtime field
1910
   with the real time that the object was modified.  But if
1911
   we are trying to generate deterministic archives based upon
1912
   the SOURCE_DATE_EPOCH environment variable then we want to
1913
   override that.  */
1914
0
      status.st_mtime = bfd_get_current_time (status.st_mtime);
1915
0
    }
1916
1917
  /* If the caller requested that the BFD generate deterministic output,
1918
     fake values for modification time, UID, GID, and file mode.  */
1919
0
  if ((abfd->flags & BFD_DETERMINISTIC_OUTPUT) != 0)
1920
0
    {
1921
0
      status.st_mtime = 0;
1922
0
      status.st_uid = 0;
1923
0
      status.st_gid = 0;
1924
0
      status.st_mode = 0644;
1925
0
    }
1926
1927
0
  amt = sizeof (struct ar_hdr) + sizeof (struct areltdata);
1928
0
  ared = (struct areltdata *) bfd_zmalloc (amt);
1929
0
  if (ared == NULL)
1930
0
    return NULL;
1931
0
  hdr = (struct ar_hdr *) (((char *) ared) + sizeof (struct areltdata));
1932
1933
  /* ar headers are space padded, not null padded!  */
1934
0
  memset (hdr, ' ', sizeof (struct ar_hdr));
1935
1936
0
  _bfd_ar_spacepad (hdr->ar_date, sizeof (hdr->ar_date), "%-12ld",
1937
0
        status.st_mtime);
1938
#ifdef HPUX_LARGE_AR_IDS
1939
  /* HP has a very "special" way to handle UID/GID's with numeric values
1940
     > 99999.  */
1941
  if (status.st_uid > 99999)
1942
    hpux_uid_gid_encode (hdr->ar_uid, (long) status.st_uid);
1943
  else
1944
#endif
1945
0
    _bfd_ar_spacepad (hdr->ar_uid, sizeof (hdr->ar_uid), "%ld",
1946
0
          status.st_uid);
1947
#ifdef HPUX_LARGE_AR_IDS
1948
  /* HP has a very "special" way to handle UID/GID's with numeric values
1949
     > 99999.  */
1950
  if (status.st_gid > 99999)
1951
    hpux_uid_gid_encode (hdr->ar_gid, (long) status.st_gid);
1952
  else
1953
#endif
1954
0
    _bfd_ar_spacepad (hdr->ar_gid, sizeof (hdr->ar_gid), "%ld",
1955
0
          status.st_gid);
1956
0
  _bfd_ar_spacepad (hdr->ar_mode, sizeof (hdr->ar_mode), "%-8lo",
1957
0
        status.st_mode);
1958
0
  if (status.st_size - (bfd_size_type) status.st_size != 0)
1959
0
    {
1960
0
      bfd_set_error (bfd_error_file_too_big);
1961
0
      free (ared);
1962
0
      return NULL;
1963
0
    }
1964
0
  if (!_bfd_ar_sizepad (hdr->ar_size, sizeof (hdr->ar_size), status.st_size))
1965
0
    {
1966
0
      free (ared);
1967
0
      return NULL;
1968
0
    }
1969
0
  memcpy (hdr->ar_fmag, ARFMAG, 2);
1970
0
  ared->parsed_size = status.st_size;
1971
0
  ared->arch_header = (char *) hdr;
1972
1973
0
  return ared;
1974
0
}
1975
1976
/* Analogous to stat call.  */
1977
1978
int
1979
bfd_generic_stat_arch_elt (bfd *abfd, struct stat *buf)
1980
13.1k
{
1981
13.1k
  struct ar_hdr *hdr;
1982
13.1k
  char *aloser;
1983
1984
13.1k
  if (abfd->arelt_data == NULL)
1985
12.3k
    {
1986
12.3k
      bfd_set_error (bfd_error_invalid_operation);
1987
12.3k
      return -1;
1988
12.3k
    }
1989
1990
776
  hdr = arch_hdr (abfd);
1991
  /* PR 17512: file: 3d9e9fe9.  */
1992
776
  if (hdr == NULL)
1993
0
    return -1;
1994
776
#define foo(arelt, stelt, size)       \
1995
1.23k
  buf->stelt = strtol (hdr->arelt, &aloser, size);  \
1996
1.23k
  if (aloser == hdr->arelt)       \
1997
1.23k
    return -1;
1998
1999
  /* Some platforms support special notations for large IDs.  */
2000
#ifdef HPUX_LARGE_AR_IDS
2001
# define foo2(arelt, stelt, size)         \
2002
  if (hdr->arelt[5] == ' ')           \
2003
    {                 \
2004
      foo (arelt, stelt, size);           \
2005
    }                 \
2006
  else                  \
2007
    {                 \
2008
      int cnt;                \
2009
      for (buf->stelt = cnt = 0; cnt < 5; ++cnt)      \
2010
  {               \
2011
    if (hdr->arelt[cnt] < ' ' || hdr->arelt[cnt] > ' ' + 0x3f)  \
2012
      return -1;              \
2013
    buf->stelt <<= 6;           \
2014
    buf->stelt += hdr->arelt[cnt] - ' ';        \
2015
  }               \
2016
      if (hdr->arelt[5] < '@' || hdr->arelt[5] > '@' + 3)   \
2017
  return -1;              \
2018
      buf->stelt <<= 2;             \
2019
      buf->stelt += hdr->arelt[5] - '@';        \
2020
    }
2021
#else
2022
776
# define foo2(arelt, stelt, size) foo (arelt, stelt, size)
2023
776
#endif
2024
2025
776
  foo (ar_date, st_mtime, 10);
2026
163
  foo2 (ar_uid, st_uid, 10);
2027
151
  foo2 (ar_gid, st_gid, 10);
2028
142
  foo (ar_mode, st_mode, 8);
2029
2030
140
  buf->st_size = arch_eltdata (abfd)->parsed_size;
2031
2032
140
  return 0;
2033
142
}
2034
2035
void
2036
bfd_dont_truncate_arname (bfd *abfd, const char *pathname, char *arhdr)
2037
0
{
2038
  /* FIXME: This interacts unpleasantly with ar's quick-append option.
2039
     Fortunately ic960 users will never use that option.  Fixing this
2040
     is very hard; fortunately I know how to do it and will do so once
2041
     intel's release is out the door.  */
2042
2043
0
  struct ar_hdr *hdr = (struct ar_hdr *) arhdr;
2044
0
  size_t length;
2045
0
  const char *filename;
2046
0
  size_t maxlen = ar_maxnamelen (abfd);
2047
2048
0
  if ((bfd_get_file_flags (abfd) & BFD_TRADITIONAL_FORMAT) != 0)
2049
0
    {
2050
0
      bfd_bsd_truncate_arname (abfd, pathname, arhdr);
2051
0
      return;
2052
0
    }
2053
2054
0
  filename = normalize (abfd, pathname);
2055
0
  if (filename == NULL)
2056
0
    {
2057
      /* FIXME */
2058
0
      abort ();
2059
0
    }
2060
2061
0
  length = strlen (filename);
2062
2063
0
  if (length <= maxlen)
2064
0
    memcpy (hdr->ar_name, filename, length);
2065
2066
  /* Add the padding character if there is room for it.  */
2067
0
  if (length < maxlen
2068
0
      || (length == maxlen && length < sizeof hdr->ar_name))
2069
0
    (hdr->ar_name)[length] = ar_padchar (abfd);
2070
0
}
2071
2072
void
2073
bfd_bsd_truncate_arname (bfd *abfd, const char *pathname, char *arhdr)
2074
0
{
2075
0
  struct ar_hdr *hdr = (struct ar_hdr *) arhdr;
2076
0
  size_t length;
2077
0
  const char *filename = lbasename (pathname);
2078
0
  size_t maxlen = ar_maxnamelen (abfd);
2079
2080
0
  length = strlen (filename);
2081
2082
0
  if (length <= maxlen)
2083
0
    memcpy (hdr->ar_name, filename, length);
2084
0
  else
2085
0
    {
2086
      /* pathname: meet procrustes */
2087
0
      memcpy (hdr->ar_name, filename, maxlen);
2088
0
      length = maxlen;
2089
0
    }
2090
2091
0
  if (length < maxlen)
2092
0
    (hdr->ar_name)[length] = ar_padchar (abfd);
2093
0
}
2094
2095
/* Store name into ar header.  Truncates the name to fit.
2096
   1> strip pathname to be just the basename.
2097
   2> if it's short enuf to fit, stuff it in.
2098
   3> If it doesn't end with .o, truncate it to fit
2099
   4> truncate it before the .o, append .o, stuff THAT in.  */
2100
2101
/* This is what gnu ar does.  It's better but incompatible with the
2102
   bsd ar.  */
2103
2104
void
2105
bfd_gnu_truncate_arname (bfd *abfd, const char *pathname, char *arhdr)
2106
0
{
2107
0
  struct ar_hdr *hdr = (struct ar_hdr *) arhdr;
2108
0
  size_t length;
2109
0
  const char *filename = lbasename (pathname);
2110
0
  size_t maxlen = ar_maxnamelen (abfd);
2111
2112
0
  length = strlen (filename);
2113
2114
0
  if (length <= maxlen)
2115
0
    memcpy (hdr->ar_name, filename, length);
2116
0
  else
2117
0
    {
2118
      /* pathname: meet procrustes.  */
2119
0
      memcpy (hdr->ar_name, filename, maxlen);
2120
0
      if ((filename[length - 2] == '.') && (filename[length - 1] == 'o'))
2121
0
  {
2122
0
    hdr->ar_name[maxlen - 2] = '.';
2123
0
    hdr->ar_name[maxlen - 1] = 'o';
2124
0
  }
2125
0
      length = maxlen;
2126
0
    }
2127
2128
0
  if (length < 16)
2129
0
    (hdr->ar_name)[length] = ar_padchar (abfd);
2130
0
}
2131
2132
void
2133
_bfd_noarchive_truncate_arname (bfd *abfd ATTRIBUTE_UNUSED,
2134
        const char *pathname ATTRIBUTE_UNUSED,
2135
        char *arhdr ATTRIBUTE_UNUSED)
2136
0
{
2137
0
}
2138

2139
/* The BFD is open for write and has its format set to bfd_archive.  */
2140
2141
bool
2142
_bfd_write_archive_contents (bfd *arch)
2143
13.2k
{
2144
13.2k
  bfd *current;
2145
13.2k
  char *etable = NULL;
2146
13.2k
  bfd_size_type elength = 0;
2147
13.2k
  const char *ename = NULL;
2148
13.2k
  bool makemap = bfd_has_map (arch);
2149
  /* If no .o's, don't bother to make a map.  */
2150
13.2k
  bool hasobjects = false;
2151
13.2k
  bfd_size_type wrote;
2152
13.2k
  int tries;
2153
13.2k
  char *armag;
2154
13.2k
  char *buffer = NULL;
2155
2156
  /* Verify the viability of all entries; if any of them live in the
2157
     filesystem (as opposed to living in an archive open for input)
2158
     then construct a fresh ar_hdr for them.  */
2159
13.2k
  for (current = arch->archive_head;
2160
13.2k
       current != NULL;
2161
13.2k
       current = current->archive_next)
2162
0
    {
2163
      /* This check is checking the bfds for the objects we're reading
2164
   from (which are usually either an object file or archive on
2165
   disk), not the archive entries we're writing to.  We don't
2166
   actually create bfds for the archive members, we just copy
2167
   them byte-wise when we write out the archive.  */
2168
0
      if (bfd_write_p (current))
2169
0
  {
2170
0
    bfd_set_error (bfd_error_invalid_operation);
2171
0
    goto input_err;
2172
0
  }
2173
0
      if (!current->arelt_data)
2174
0
  {
2175
0
    current->arelt_data =
2176
0
      bfd_ar_hdr_from_filesystem (arch, bfd_get_filename (current),
2177
0
          current);
2178
0
    if (!current->arelt_data)
2179
0
      goto input_err;
2180
2181
    /* Put in the file name.  */
2182
0
    BFD_SEND (arch, _bfd_truncate_arname,
2183
0
        (arch, bfd_get_filename (current),
2184
0
         (char *) arch_hdr (current)));
2185
0
  }
2186
2187
0
      if (makemap && ! hasobjects)
2188
0
  {     /* Don't bother if we won't make a map!  */
2189
0
    if ((bfd_check_format (current, bfd_object)))
2190
0
      hasobjects = true;
2191
0
  }
2192
0
    }
2193
2194
13.2k
  if (!BFD_SEND (arch, _bfd_construct_extended_name_table,
2195
13.2k
     (arch, &etable, &elength, &ename)))
2196
0
    return false;
2197
2198
13.2k
  if (bfd_seek (arch, 0, SEEK_SET) != 0)
2199
0
    return false;
2200
13.2k
  armag = ARMAG;
2201
13.2k
  if (bfd_is_thin_archive (arch))
2202
36
    armag = ARMAGT;
2203
13.2k
  wrote = bfd_write (armag, SARMAG, arch);
2204
13.2k
  if (wrote != SARMAG)
2205
0
    return false;
2206
2207
13.2k
  if (makemap && hasobjects)
2208
0
    {
2209
0
      if (! _bfd_compute_and_write_armap (arch, (unsigned int) elength))
2210
0
  return false;
2211
0
    }
2212
2213
13.2k
  if (elength != 0)
2214
0
    {
2215
0
      struct ar_hdr hdr;
2216
2217
0
      memset (&hdr, ' ', sizeof (struct ar_hdr));
2218
0
      memcpy (hdr.ar_name, ename, strlen (ename));
2219
      /* Round size up to even number in archive header.  */
2220
0
      if (!_bfd_ar_sizepad (hdr.ar_size, sizeof (hdr.ar_size),
2221
0
          (elength + 1) & ~(bfd_size_type) 1))
2222
0
  return false;
2223
0
      memcpy (hdr.ar_fmag, ARFMAG, 2);
2224
0
      if ((bfd_write (&hdr, sizeof (struct ar_hdr), arch)
2225
0
     != sizeof (struct ar_hdr))
2226
0
    || bfd_write (etable, elength, arch) != elength)
2227
0
  return false;
2228
0
      if ((elength % 2) == 1)
2229
0
  {
2230
0
    if (bfd_write (&ARFMAG[1], 1, arch) != 1)
2231
0
      return false;
2232
0
  }
2233
0
    }
2234
2235
13.2k
#define AR_WRITE_BUFFERSIZE (8 * 1024 * 1024)
2236
2237
  /* FIXME: Find a way to test link_info.reduce_memory_overheads
2238
     and change the buffer size.  */
2239
13.2k
  buffer = bfd_malloc (AR_WRITE_BUFFERSIZE);
2240
13.2k
  if (buffer == NULL)
2241
0
    goto input_err;
2242
2243
13.2k
  for (current = arch->archive_head;
2244
13.2k
       current != NULL;
2245
13.2k
       current = current->archive_next)
2246
0
    {
2247
0
      bfd_size_type remaining = arelt_size (current);
2248
2249
      /* Write ar header.  */
2250
0
      if (!_bfd_write_ar_hdr (arch, current))
2251
0
  goto input_err;
2252
0
      if (bfd_is_thin_archive (arch))
2253
0
  continue;
2254
0
      if (bfd_seek (current, 0, SEEK_SET) != 0)
2255
0
  goto input_err;
2256
2257
0
      while (remaining)
2258
0
  {
2259
0
    size_t amt = AR_WRITE_BUFFERSIZE;
2260
2261
0
    if (amt > remaining)
2262
0
      amt = remaining;
2263
0
    errno = 0;
2264
0
    if (bfd_read (buffer, amt, current) != amt)
2265
0
      goto input_err;
2266
0
    if (bfd_write (buffer, amt, arch) != amt)
2267
0
      goto input_err;
2268
0
    remaining -= amt;
2269
0
  }
2270
2271
0
      if ((arelt_size (current) % 2) == 1)
2272
0
  {
2273
0
    if (bfd_write (&ARFMAG[1], 1, arch) != 1)
2274
0
      goto input_err;
2275
0
  }
2276
0
    }
2277
2278
13.2k
  free (buffer);
2279
2280
13.2k
  if (makemap && hasobjects)
2281
0
    {
2282
      /* Verify the timestamp in the archive file.  If it would not be
2283
   accepted by the linker, rewrite it until it would be.  If
2284
   anything odd happens, break out and just return.  (The
2285
   Berkeley linker checks the timestamp and refuses to read the
2286
   table-of-contents if it is >60 seconds less than the file's
2287
   modified-time.  That painful hack requires this painful hack.  */
2288
0
      tries = 1;
2289
0
      do
2290
0
  {
2291
0
    if (bfd_update_armap_timestamp (arch))
2292
0
      break;
2293
0
    _bfd_error_handler
2294
0
      (_("warning: writing archive was slow: rewriting timestamp"));
2295
0
  }
2296
0
      while (++tries < 6);
2297
0
    }
2298
2299
0
  return true;
2300
2301
0
 input_err:
2302
0
  bfd_set_input_error (current, bfd_get_error ());
2303
0
  free (buffer);
2304
0
  return false;
2305
13.2k
}
2306

2307
/* Note that the namidx for the first symbol is 0.  */
2308
2309
bool
2310
_bfd_compute_and_write_armap (bfd *arch, unsigned int elength)
2311
0
{
2312
0
  char *first_name = NULL;
2313
0
  bfd *current;
2314
0
  file_ptr elt_no = 0;
2315
0
  struct orl *map = NULL;
2316
0
  unsigned int orl_max = 1024;    /* Fine initial default.  */
2317
0
  unsigned int orl_count = 0;
2318
0
  int stridx = 0;
2319
0
  asymbol **syms = NULL;
2320
0
  long syms_max = 0;
2321
0
  bool ret;
2322
0
  size_t amt;
2323
0
  static bool report_plugin_err = true;
2324
2325
  /* Dunno if this is the best place for this info...  */
2326
0
  if (elength != 0)
2327
0
    elength += sizeof (struct ar_hdr);
2328
0
  elength += elength % 2;
2329
2330
0
  amt = orl_max * sizeof (struct orl);
2331
0
  map = (struct orl *) bfd_malloc (amt);
2332
0
  if (map == NULL)
2333
0
    goto error_return;
2334
2335
  /* We put the symbol names on the arch objalloc, and then discard
2336
     them when done.  */
2337
0
  first_name = (char *) bfd_alloc (arch, 1);
2338
0
  if (first_name == NULL)
2339
0
    goto error_return;
2340
2341
  /* Drop all the files called __.SYMDEF, we're going to make our own.  */
2342
0
  while (arch->archive_head
2343
0
   && strcmp (bfd_get_filename (arch->archive_head), "__.SYMDEF") == 0)
2344
0
    arch->archive_head = arch->archive_head->archive_next;
2345
2346
  /* Map over each element.  */
2347
0
  for (current = arch->archive_head;
2348
0
       current != NULL;
2349
0
       current = current->archive_next, elt_no++)
2350
0
    {
2351
0
      if (bfd_check_format (current, bfd_object)
2352
0
    && (bfd_get_file_flags (current) & HAS_SYMS) != 0)
2353
0
  {
2354
0
    long storage;
2355
0
    long symcount;
2356
0
    long src_count;
2357
2358
0
    if (bfd_get_lto_type (current) == lto_slim_ir_object
2359
0
        && report_plugin_err)
2360
0
      {
2361
0
        report_plugin_err = false;
2362
0
        _bfd_error_handler
2363
0
    (_("%pB: plugin needed to handle lto object"),
2364
0
     current);
2365
0
      }
2366
2367
0
    storage = bfd_get_symtab_upper_bound (current);
2368
0
    if (storage < 0)
2369
0
      goto error_return;
2370
2371
0
    if (storage != 0)
2372
0
      {
2373
0
        if (storage > syms_max)
2374
0
    {
2375
0
      free (syms);
2376
0
      syms_max = storage;
2377
0
      syms = (asymbol **) bfd_malloc (syms_max);
2378
0
      if (syms == NULL)
2379
0
        goto error_return;
2380
0
    }
2381
0
        symcount = bfd_canonicalize_symtab (current, syms);
2382
0
        if (symcount < 0)
2383
0
    goto error_return;
2384
2385
        /* Now map over all the symbols, picking out the ones we
2386
     want.  */
2387
0
        for (src_count = 0; src_count < symcount; src_count++)
2388
0
    {
2389
0
      flagword flags = (syms[src_count])->flags;
2390
0
      asection *sec = syms[src_count]->section;
2391
2392
0
      if (((flags & (BSF_GLOBAL
2393
0
         | BSF_WEAK
2394
0
         | BSF_INDIRECT
2395
0
         | BSF_GNU_UNIQUE)) != 0
2396
0
           || bfd_is_com_section (sec))
2397
0
          && ! bfd_is_und_section (sec))
2398
0
        {
2399
0
          bfd_size_type namelen;
2400
0
          struct orl *new_map;
2401
2402
          /* This symbol will go into the archive header.  */
2403
0
          if (orl_count == orl_max)
2404
0
      {
2405
0
        orl_max *= 2;
2406
0
        amt = orl_max * sizeof (struct orl);
2407
0
        new_map = (struct orl *) bfd_realloc (map, amt);
2408
0
        if (new_map == NULL)
2409
0
          goto error_return;
2410
2411
0
        map = new_map;
2412
0
      }
2413
2414
0
          if (syms[src_count]->name != NULL
2415
0
        && syms[src_count]->name[0] == '_'
2416
0
        && syms[src_count]->name[1] == '_'
2417
0
        && strcmp (syms[src_count]->name
2418
0
             + (syms[src_count]->name[2] == '_'),
2419
0
             "__gnu_lto_slim") == 0
2420
0
        && report_plugin_err)
2421
0
      {
2422
0
        report_plugin_err = false;
2423
0
        _bfd_error_handler
2424
0
          (_("%pB: plugin needed to handle lto object"),
2425
0
           current);
2426
0
      }
2427
0
          namelen = strlen (syms[src_count]->name);
2428
0
          amt = sizeof (char *);
2429
0
          map[orl_count].name = (char **) bfd_alloc (arch, amt);
2430
0
          if (map[orl_count].name == NULL)
2431
0
      goto error_return;
2432
0
          *(map[orl_count].name) = (char *) bfd_alloc (arch,
2433
0
                   namelen + 1);
2434
0
          if (*(map[orl_count].name) == NULL)
2435
0
      goto error_return;
2436
0
          strcpy (*(map[orl_count].name), syms[src_count]->name);
2437
0
          map[orl_count].u.abfd = current;
2438
0
          map[orl_count].namidx = stridx;
2439
2440
0
          stridx += namelen + 1;
2441
0
          ++orl_count;
2442
0
        }
2443
0
    }
2444
0
      }
2445
2446
    /* Now ask the BFD to free up any cached information, so we
2447
       don't fill all of memory with symbol tables.  */
2448
0
    if (! bfd_free_cached_info (current))
2449
0
      goto error_return;
2450
0
  }
2451
0
    }
2452
2453
  /* OK, now we have collected all the data, let's write them out.  */
2454
0
  ret = BFD_SEND (arch, write_armap,
2455
0
      (arch, elength, map, orl_count, stridx));
2456
2457
0
  free (syms);
2458
0
  free (map);
2459
0
  if (first_name != NULL)
2460
0
    bfd_release (arch, first_name);
2461
2462
0
  return ret;
2463
2464
0
 error_return:
2465
0
  free (syms);
2466
0
  free (map);
2467
0
  if (first_name != NULL)
2468
0
    bfd_release (arch, first_name);
2469
2470
0
  return false;
2471
0
}
2472
2473
bool
2474
_bfd_bsd_write_armap (bfd *arch,
2475
          unsigned int elength,
2476
          struct orl *map,
2477
          unsigned int orl_count,
2478
          int stridx)
2479
0
{
2480
0
  int padit = stridx & 1;
2481
0
  unsigned int ranlibsize = orl_count * BSD_SYMDEF_SIZE;
2482
0
  unsigned int stringsize = stridx + padit;
2483
  /* Include 8 bytes to store ranlibsize and stringsize in output.  */
2484
0
  unsigned int mapsize = ranlibsize + stringsize + 8;
2485
0
  file_ptr firstreal, first;
2486
0
  bfd *current;
2487
0
  bfd *last_elt;
2488
0
  bfd_byte temp[4];
2489
0
  unsigned int count;
2490
0
  struct ar_hdr hdr;
2491
0
  long uid, gid;
2492
2493
0
  first = mapsize + elength + sizeof (struct ar_hdr) + SARMAG;
2494
2495
0
#ifdef BFD64
2496
0
  firstreal = first;
2497
0
  current = arch->archive_head;
2498
0
  last_elt = current; /* Last element arch seen.  */
2499
0
  for (count = 0; count < orl_count; count++)
2500
0
    {
2501
0
      unsigned int offset;
2502
2503
0
      if (map[count].u.abfd != last_elt)
2504
0
  {
2505
0
    do
2506
0
      {
2507
0
        struct areltdata *ared = arch_eltdata (current);
2508
2509
0
        firstreal += (ared->parsed_size + ared->extra_size
2510
0
          + sizeof (struct ar_hdr));
2511
0
        firstreal += firstreal % 2;
2512
0
        current = current->archive_next;
2513
0
      }
2514
0
    while (current != map[count].u.abfd);
2515
0
  }
2516
2517
      /* The archive file format only has 4 bytes to store the offset
2518
   of the member.  Generate 64-bit archive if an archive is past
2519
   its 4Gb limit.  */
2520
0
      offset = (unsigned int) firstreal;
2521
0
      if (firstreal != (file_ptr) offset)
2522
0
  return _bfd_archive_64_bit_write_armap (arch, elength, map,
2523
0
            orl_count, stridx);
2524
2525
0
      last_elt = current;
2526
0
    }
2527
0
#endif
2528
2529
  /* If deterministic, we use 0 as the timestamp in the map.
2530
     Some linkers may require that the archive filesystem modification
2531
     time is less than (or near to) the archive map timestamp.  Those
2532
     linkers should not be used with deterministic mode.  (GNU ld and
2533
     Gold do not have this restriction.)  */
2534
0
  bfd_ardata (arch)->armap_timestamp = 0;
2535
0
  uid = 0;
2536
0
  gid = 0;
2537
0
  if ((arch->flags & BFD_DETERMINISTIC_OUTPUT) == 0)
2538
0
    {
2539
0
      struct stat statbuf;
2540
2541
0
      if (stat (bfd_get_filename (arch), &statbuf) == 0)
2542
0
  {
2543
    /* If asked, replace the time with a deterministic value. */
2544
0
    statbuf.st_mtime = bfd_get_current_time (statbuf.st_mtime);
2545
2546
0
    bfd_ardata (arch)->armap_timestamp = (statbuf.st_mtime
2547
0
            + ARMAP_TIME_OFFSET);
2548
0
  }
2549
0
      uid = getuid();
2550
0
      gid = getgid();
2551
0
    }
2552
2553
0
  memset (&hdr, ' ', sizeof (struct ar_hdr));
2554
0
  memcpy (hdr.ar_name, RANLIBMAG, strlen (RANLIBMAG));
2555
0
  bfd_ardata (arch)->armap_datepos = (SARMAG
2556
0
              + offsetof (struct ar_hdr, ar_date[0]));
2557
0
  _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld",
2558
0
        bfd_ardata (arch)->armap_timestamp);
2559
0
  _bfd_ar_spacepad (hdr.ar_uid, sizeof (hdr.ar_uid), "%ld", uid);
2560
0
  _bfd_ar_spacepad (hdr.ar_gid, sizeof (hdr.ar_gid), "%ld", gid);
2561
0
  if (!_bfd_ar_sizepad (hdr.ar_size, sizeof (hdr.ar_size), mapsize))
2562
0
    return false;
2563
0
  memcpy (hdr.ar_fmag, ARFMAG, 2);
2564
0
  if (bfd_write (&hdr, sizeof (struct ar_hdr), arch)
2565
0
      != sizeof (struct ar_hdr))
2566
0
    return false;
2567
0
  H_PUT_32 (arch, ranlibsize, temp);
2568
0
  if (bfd_write (temp, sizeof (temp), arch) != sizeof (temp))
2569
0
    return false;
2570
2571
0
  firstreal = first;
2572
0
  current = arch->archive_head;
2573
0
  last_elt = current; /* Last element arch seen.  */
2574
0
  for (count = 0; count < orl_count; count++)
2575
0
    {
2576
0
      unsigned int offset;
2577
0
      bfd_byte buf[BSD_SYMDEF_SIZE];
2578
2579
0
      if (map[count].u.abfd != last_elt)
2580
0
  {
2581
0
    do
2582
0
      {
2583
0
        struct areltdata *ared = arch_eltdata (current);
2584
2585
0
        firstreal += (ared->parsed_size + ared->extra_size
2586
0
          + sizeof (struct ar_hdr));
2587
0
        firstreal += firstreal % 2;
2588
0
        current = current->archive_next;
2589
0
      }
2590
0
    while (current != map[count].u.abfd);
2591
0
  }
2592
2593
      /* The archive file format only has 4 bytes to store the offset
2594
   of the member.  Check to make sure that firstreal has not grown
2595
   too big.  */
2596
0
      offset = (unsigned int) firstreal;
2597
0
      if (firstreal != (file_ptr) offset)
2598
0
  {
2599
0
    bfd_set_error (bfd_error_file_truncated);
2600
0
    return false;
2601
0
  }
2602
2603
0
      last_elt = current;
2604
0
      H_PUT_32 (arch, map[count].namidx, buf);
2605
0
      H_PUT_32 (arch, firstreal, buf + BSD_SYMDEF_OFFSET_SIZE);
2606
0
      if (bfd_write (buf, BSD_SYMDEF_SIZE, arch)
2607
0
    != BSD_SYMDEF_SIZE)
2608
0
  return false;
2609
0
    }
2610
2611
  /* Now write the strings themselves.  */
2612
0
  H_PUT_32 (arch, stringsize, temp);
2613
0
  if (bfd_write (temp, sizeof (temp), arch) != sizeof (temp))
2614
0
    return false;
2615
0
  for (count = 0; count < orl_count; count++)
2616
0
    {
2617
0
      size_t len = strlen (*map[count].name) + 1;
2618
2619
0
      if (bfd_write (*map[count].name, len, arch) != len)
2620
0
  return false;
2621
0
    }
2622
2623
  /* The spec sez this should be a newline.  But in order to be
2624
     bug-compatible for sun's ar we use a null.  */
2625
0
  if (padit)
2626
0
    {
2627
0
      if (bfd_write ("", 1, arch) != 1)
2628
0
  return false;
2629
0
    }
2630
2631
0
  return true;
2632
0
}
2633
2634
/* At the end of archive file handling, update the timestamp in the
2635
   file, so older linkers will accept it.  (This does not apply to
2636
   ld.bfd or ld.gold).
2637
2638
   Return TRUE if the timestamp was OK, or an unusual problem happened.
2639
   Return FALSE if we updated the timestamp.  */
2640
2641
bool
2642
_bfd_archive_bsd_update_armap_timestamp (bfd *arch)
2643
1.84k
{
2644
1.84k
  struct stat archstat;
2645
1.84k
  struct ar_hdr hdr;
2646
2647
  /* If creating deterministic archives, just leave the timestamp as-is.  */
2648
1.84k
  if ((arch->flags & BFD_DETERMINISTIC_OUTPUT) != 0)
2649
0
    return true;
2650
2651
  /* Flush writes, get last-write timestamp from file, and compare it
2652
     to the timestamp IN the file.  */
2653
1.84k
  bfd_flush (arch);
2654
1.84k
  if (bfd_stat (arch, &archstat) == -1)
2655
0
    {
2656
0
      bfd_perror (_("Reading archive file mod timestamp"));
2657
2658
      /* Can't read mod time for some reason.  */
2659
0
      return true;
2660
0
    }
2661
2662
1.84k
  if (((long) archstat.st_mtime) <= bfd_ardata (arch)->armap_timestamp)
2663
    /* OK by the linker's rules.  */
2664
0
    return true;
2665
2666
1.84k
  if (getenv ("SOURCE_DATE_EPOCH") != NULL
2667
1.84k
      && bfd_ardata (arch)->armap_timestamp == bfd_get_current_time (0) + ARMAP_TIME_OFFSET)
2668
    /* If the archive's timestamp has been set to SOURCE_DATE_EPOCH
2669
       then leave it as-is.  */
2670
0
    return true;
2671
  
2672
  /* Update the timestamp.  */
2673
1.84k
  bfd_ardata (arch)->armap_timestamp = archstat.st_mtime + ARMAP_TIME_OFFSET;
2674
2675
  /* Prepare an ASCII version suitable for writing.  */
2676
1.84k
  memset (hdr.ar_date, ' ', sizeof (hdr.ar_date));
2677
1.84k
  _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld",
2678
1.84k
        bfd_ardata (arch)->armap_timestamp);
2679
2680
  /* Write it into the file.  */
2681
1.84k
  bfd_ardata (arch)->armap_datepos = (SARMAG
2682
1.84k
              + offsetof (struct ar_hdr, ar_date[0]));
2683
1.84k
  if (bfd_seek (arch, bfd_ardata (arch)->armap_datepos, SEEK_SET) != 0
2684
1.84k
      || (bfd_write (hdr.ar_date, sizeof (hdr.ar_date), arch)
2685
1.84k
    != sizeof (hdr.ar_date)))
2686
0
    {
2687
0
      bfd_perror (_("Writing updated armap timestamp"));
2688
2689
      /* Some error while writing.  */
2690
0
      return true;
2691
0
    }
2692
2693
  /* We updated the timestamp successfully.  */
2694
1.84k
  return false;
2695
1.84k
}
2696

2697
/* A coff armap looks like :
2698
   lARMAG
2699
   struct ar_hdr with name = '/'
2700
   number of symbols
2701
   offset of file for symbol 0
2702
   offset of file for symbol 1
2703
2704
   offset of file for symbol n-1
2705
   symbol name 0
2706
   symbol name 1
2707
2708
   symbol name n-1  */
2709
2710
bool
2711
_bfd_coff_write_armap (bfd *arch,
2712
           unsigned int elength,
2713
           struct orl *map,
2714
           unsigned int symbol_count,
2715
           int stridx)
2716
0
{
2717
  /* The size of the ranlib is the number of exported symbols in the
2718
     archive * the number of bytes in an int, + an int for the count.  */
2719
0
  unsigned int ranlibsize = (symbol_count * 4) + 4;
2720
0
  unsigned int stringsize = stridx;
2721
0
  unsigned int mapsize = stringsize + ranlibsize;
2722
0
  file_ptr archive_member_file_ptr;
2723
0
  file_ptr first_archive_member_file_ptr;
2724
0
  bfd *current = arch->archive_head;
2725
0
  unsigned int count;
2726
0
  struct ar_hdr hdr;
2727
0
  int padit = mapsize & 1;
2728
2729
0
  if (padit)
2730
0
    mapsize++;
2731
2732
  /* Work out where the first object file will go in the archive.  */
2733
0
  first_archive_member_file_ptr = (mapsize
2734
0
           + elength
2735
0
           + sizeof (struct ar_hdr)
2736
0
           + SARMAG);
2737
2738
0
#ifdef BFD64
2739
0
  current = arch->archive_head;
2740
0
  count = 0;
2741
0
  archive_member_file_ptr = first_archive_member_file_ptr;
2742
0
  while (current != NULL && count < symbol_count)
2743
0
    {
2744
      /* For each symbol which is used defined in this object, write
2745
   out the object file's address in the archive.  */
2746
2747
0
      while (count < symbol_count && map[count].u.abfd == current)
2748
0
  {
2749
0
    unsigned int offset = (unsigned int) archive_member_file_ptr;
2750
2751
    /* Generate 64-bit archive if an archive is past its 4Gb
2752
       limit.  */
2753
0
    if (archive_member_file_ptr != (file_ptr) offset)
2754
0
      return _bfd_archive_64_bit_write_armap (arch, elength, map,
2755
0
                symbol_count, stridx);
2756
0
    count++;
2757
0
  }
2758
0
      archive_member_file_ptr += sizeof (struct ar_hdr);
2759
0
      if (! bfd_is_thin_archive (arch))
2760
0
  {
2761
    /* Add size of this archive entry.  */
2762
0
    archive_member_file_ptr += arelt_size (current);
2763
    /* Remember about the even alignment.  */
2764
0
    archive_member_file_ptr += archive_member_file_ptr % 2;
2765
0
  }
2766
0
      current = current->archive_next;
2767
0
    }
2768
0
#endif
2769
2770
0
  memset (&hdr, ' ', sizeof (struct ar_hdr));
2771
0
  hdr.ar_name[0] = '/';
2772
0
  if (!_bfd_ar_sizepad (hdr.ar_size, sizeof (hdr.ar_size), mapsize))
2773
0
    return false;
2774
0
  _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld",
2775
0
        ((arch->flags & BFD_DETERMINISTIC_OUTPUT) == 0
2776
0
         ? time (NULL) : 0));
2777
  /* This, at least, is what Intel coff sets the values to.  */
2778
0
  _bfd_ar_spacepad (hdr.ar_uid, sizeof (hdr.ar_uid), "%ld", 0);
2779
0
  _bfd_ar_spacepad (hdr.ar_gid, sizeof (hdr.ar_gid), "%ld", 0);
2780
0
  _bfd_ar_spacepad (hdr.ar_mode, sizeof (hdr.ar_mode), "%-7lo", 0);
2781
0
  memcpy (hdr.ar_fmag, ARFMAG, 2);
2782
2783
  /* Write the ar header for this item and the number of symbols.  */
2784
0
  if (bfd_write (&hdr, sizeof (struct ar_hdr), arch)
2785
0
      != sizeof (struct ar_hdr))
2786
0
    return false;
2787
2788
0
  if (!bfd_write_bigendian_4byte_int (arch, symbol_count))
2789
0
    return false;
2790
2791
  /* Two passes, first write the file offsets for each symbol -
2792
     remembering that each offset is on a two byte boundary.  */
2793
2794
  /* Write out the file offset for the file associated with each
2795
     symbol, and remember to keep the offsets padded out.  */
2796
2797
0
  current = arch->archive_head;
2798
0
  count = 0;
2799
0
  archive_member_file_ptr = first_archive_member_file_ptr;
2800
0
  while (current != NULL && count < symbol_count)
2801
0
    {
2802
      /* For each symbol which is used defined in this object, write
2803
   out the object file's address in the archive.  */
2804
2805
0
      while (count < symbol_count && map[count].u.abfd == current)
2806
0
  {
2807
0
    unsigned int offset = (unsigned int) archive_member_file_ptr;
2808
2809
    /* Catch an attempt to grow an archive past its 4Gb limit.  */
2810
0
    if (archive_member_file_ptr != (file_ptr) offset)
2811
0
      {
2812
0
        bfd_set_error (bfd_error_file_truncated);
2813
0
        return false;
2814
0
      }
2815
0
    if (!bfd_write_bigendian_4byte_int (arch, offset))
2816
0
      return false;
2817
0
    count++;
2818
0
  }
2819
0
      archive_member_file_ptr += sizeof (struct ar_hdr);
2820
0
      if (! bfd_is_thin_archive (arch))
2821
0
  {
2822
    /* Add size of this archive entry.  */
2823
0
    archive_member_file_ptr += arelt_size (current);
2824
    /* Remember about the even alignment.  */
2825
0
    archive_member_file_ptr += archive_member_file_ptr % 2;
2826
0
  }
2827
0
      current = current->archive_next;
2828
0
    }
2829
2830
  /* Now write the strings themselves.  */
2831
0
  for (count = 0; count < symbol_count; count++)
2832
0
    {
2833
0
      size_t len = strlen (*map[count].name) + 1;
2834
2835
0
      if (bfd_write (*map[count].name, len, arch) != len)
2836
0
  return false;
2837
0
    }
2838
2839
  /* The spec sez this should be a newline.  But in order to be
2840
     bug-compatible for arc960 we use a null.  */
2841
0
  if (padit)
2842
0
    {
2843
0
      if (bfd_write ("", 1, arch) != 1)
2844
0
  return false;
2845
0
    }
2846
2847
0
  return true;
2848
0
}
2849
2850
bool
2851
_bfd_noarchive_write_armap
2852
    (bfd *arch ATTRIBUTE_UNUSED,
2853
     unsigned int elength ATTRIBUTE_UNUSED,
2854
     struct orl *map ATTRIBUTE_UNUSED,
2855
     unsigned int orl_count ATTRIBUTE_UNUSED,
2856
     int stridx ATTRIBUTE_UNUSED)
2857
0
{
2858
0
  return true;
2859
0
}
2860
2861
static int
2862
archive_close_worker (void **slot, void *inf ATTRIBUTE_UNUSED)
2863
0
{
2864
0
  struct ar_cache *ent = (struct ar_cache *) *slot;
2865
2866
0
  bfd_close_all_done (ent->arbfd);
2867
0
  return 1;
2868
0
}
2869
2870
void
2871
_bfd_unlink_from_archive_parent (bfd *abfd)
2872
1.75M
{
2873
1.75M
  if (arch_eltdata (abfd) != NULL)
2874
1.62M
    {
2875
1.62M
      struct areltdata *ared = arch_eltdata (abfd);
2876
1.62M
      htab_t htab = (htab_t) ared->parent_cache;
2877
2878
1.62M
      if (htab)
2879
10.8k
  {
2880
10.8k
    struct ar_cache ent;
2881
10.8k
    void **slot;
2882
2883
10.8k
    ent.ptr = ared->key;
2884
10.8k
    slot = htab_find_slot (htab, &ent, NO_INSERT);
2885
10.8k
    if (slot != NULL)
2886
10.8k
      {
2887
10.8k
        BFD_ASSERT (((struct ar_cache *) *slot)->arbfd == abfd);
2888
10.8k
        htab_clear_slot (htab, slot);
2889
10.8k
      }
2890
10.8k
  }
2891
1.62M
    }
2892
1.75M
}
2893
2894
bool
2895
_bfd_archive_close_and_cleanup (bfd *abfd)
2896
1.75M
{
2897
1.75M
  if (bfd_read_p (abfd) && abfd->format == bfd_archive)
2898
35.0k
    {
2899
35.0k
      bfd *nbfd;
2900
35.0k
      bfd *next;
2901
35.0k
      htab_t htab;
2902
2903
      /* Close nested archives (if this bfd is a thin archive).  */
2904
35.0k
      for (nbfd = abfd->nested_archives; nbfd; nbfd = next)
2905
5
  {
2906
5
    next = nbfd->archive_next;
2907
5
    bfd_close (nbfd);
2908
5
  }
2909
2910
35.0k
      htab = bfd_ardata (abfd)->cache;
2911
35.0k
      if (htab)
2912
5.82k
  {
2913
5.82k
    htab_traverse_noresize (htab, archive_close_worker, NULL);
2914
5.82k
    htab_delete (htab);
2915
5.82k
    bfd_ardata (abfd)->cache = NULL;
2916
5.82k
  }
2917
2918
      /* Close the archive plugin file descriptor if needed.  */
2919
35.0k
      if (abfd->archive_plugin_fd > 0)
2920
0
  close (abfd->archive_plugin_fd);
2921
35.0k
    }
2922
2923
1.75M
  _bfd_unlink_from_archive_parent (abfd);
2924
2925
1.75M
  if (abfd->is_linker_output)
2926
0
    (*abfd->link.hash->hash_table_free) (abfd);
2927
2928
1.75M
  return true;
2929
1.75M
}