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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.18.50/] [bfd/] [archive.c] - Blame information for rev 156

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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