OpenCores
URL https://opencores.org/ocsvn/open8_urisc/open8_urisc/trunk

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [bfd/] [archive.c] - Blame information for rev 167

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.