← Back to branch summary

~ubuntu-branches/ubuntu/utopic/binutils-arm64-cross/utopic

« back to all changes in this revision

Viewing changes to binutils-2.23.52.20130611/binutils/elfcomm.c

  • Committer: Package Import Robot
  • Author(s): Matthias Klose
  • Date: 2013-06-20 17:38:09 UTC
  • Revision ID: package-import@ubuntu.com-20130620173809-app8lzgvymy5fg6c
Tags: 0.7
Build-depend on binutils-source (>= 2.23.52.20130620-1~).

Show diffs side-by-side

added added

removed removed

Lines of Context:
binutils-2.23.52.20130611/binutils/elfcomm.c
 
1
/* elfcomm.c -- common code for ELF format file.
 
2
   Copyright 2010-2013 Free Software Foundation, Inc.
 
3
 
 
4
   Originally developed by Eric Youngdale <eric@andante.jic.com>
 
5
   Modifications by Nick Clifton <nickc@redhat.com>
 
6
 
 
7
   This file is part of GNU Binutils.
 
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
 
22
   02110-1301, USA.  */
 
23
 
 
24
#include "sysdep.h"
 
25
#include "libiberty.h"
 
26
#include "filenames.h"
 
27
#include "bfd.h"
 
28
#include "aout/ar.h"
 
29
#include "bucomm.h"
 
30
#include "elfcomm.h"
 
31
#include <assert.h>
 
32
 
 
33
void
 
34
error (const char *message, ...)
 
35
{
 
36
  va_list args;
 
37
 
 
38
  /* Try to keep error messages in sync with the program's normal output.  */
 
39
  fflush (stdout);
 
40
 
 
41
  va_start (args, message);
 
42
  fprintf (stderr, _("%s: Error: "), program_name);
 
43
  vfprintf (stderr, message, args);
 
44
  va_end (args);
 
45
}
 
46
 
 
47
void
 
48
warn (const char *message, ...)
 
49
{
 
50
  va_list args;
 
51
 
 
52
  /* Try to keep warning messages in sync with the program's normal output.  */
 
53
  fflush (stdout);
 
54
  
 
55
  va_start (args, message);
 
56
  fprintf (stderr, _("%s: Warning: "), program_name);
 
57
  vfprintf (stderr, message, args);
 
58
  va_end (args);
 
59
}
 
60
 
 
61
void (*byte_put) (unsigned char *, elf_vma, int);
 
62
 
 
63
void
 
64
byte_put_little_endian (unsigned char * field, elf_vma value, int size)
 
65
{
 
66
  switch (size)
 
67
    {
 
68
    case 8:
 
69
      field[7] = (((value >> 24) >> 24) >> 8) & 0xff;
 
70
      field[6] = ((value >> 24) >> 24) & 0xff;
 
71
      field[5] = ((value >> 24) >> 16) & 0xff;
 
72
      field[4] = ((value >> 24) >> 8) & 0xff;
 
73
      /* Fall through.  */
 
74
    case 4:
 
75
      field[3] = (value >> 24) & 0xff;
 
76
      /* Fall through.  */
 
77
    case 3:
 
78
      field[2] = (value >> 16) & 0xff;
 
79
      /* Fall through.  */
 
80
    case 2:
 
81
      field[1] = (value >> 8) & 0xff;
 
82
      /* Fall through.  */
 
83
    case 1:
 
84
      field[0] = value & 0xff;
 
85
      break;
 
86
 
 
87
    default:
 
88
      error (_("Unhandled data length: %d\n"), size);
 
89
      abort ();
 
90
    }
 
91
}
 
92
 
 
93
void
 
94
byte_put_big_endian (unsigned char * field, elf_vma value, int size)
 
95
{
 
96
  switch (size)
 
97
    {
 
98
    case 8:
 
99
      field[7] = value & 0xff;
 
100
      field[6] = (value >> 8) & 0xff;
 
101
      field[5] = (value >> 16) & 0xff;
 
102
      field[4] = (value >> 24) & 0xff;
 
103
      value >>= 16;
 
104
      value >>= 16;
 
105
      /* Fall through.  */
 
106
    case 4:
 
107
      field[3] = value & 0xff;
 
108
      value >>= 8;
 
109
      /* Fall through.  */
 
110
    case 3:
 
111
      field[2] = value & 0xff;
 
112
      value >>= 8;
 
113
      /* Fall through.  */
 
114
    case 2:
 
115
      field[1] = value & 0xff;
 
116
      value >>= 8;
 
117
      /* Fall through.  */
 
118
    case 1:
 
119
      field[0] = value & 0xff;
 
120
      break;
 
121
 
 
122
    default:
 
123
      error (_("Unhandled data length: %d\n"), size);
 
124
      abort ();
 
125
    }
 
126
}
 
127
 
 
128
elf_vma (*byte_get) (unsigned char *, int);
 
129
 
 
130
elf_vma
 
131
byte_get_little_endian (unsigned char *field, int size)
 
132
{
 
133
  switch (size)
 
134
    {
 
135
    case 1:
 
136
      return *field;
 
137
 
 
138
    case 2:
 
139
      return  ((unsigned int) (field[0]))
 
140
        |    (((unsigned int) (field[1])) << 8);
 
141
 
 
142
    case 3:
 
143
      return  ((unsigned long) (field[0]))
 
144
        |    (((unsigned long) (field[1])) << 8)
 
145
        |    (((unsigned long) (field[2])) << 16);
 
146
 
 
147
    case 4:
 
148
      return  ((unsigned long) (field[0]))
 
149
        |    (((unsigned long) (field[1])) << 8)
 
150
        |    (((unsigned long) (field[2])) << 16)
 
151
        |    (((unsigned long) (field[3])) << 24);
 
152
 
 
153
    case 5:
 
154
      if (sizeof (elf_vma) == 8)
 
155
        return  ((elf_vma) (field[0]))
 
156
          |    (((elf_vma) (field[1])) << 8)
 
157
          |    (((elf_vma) (field[2])) << 16)
 
158
          |    (((elf_vma) (field[3])) << 24)
 
159
          |    (((elf_vma) (field[4])) << 32);
 
160
      else if (sizeof (elf_vma) == 4)
 
161
        /* We want to extract data from an 8 byte wide field and
 
162
           place it into a 4 byte wide field.  Since this is a little
 
163
           endian source we can just use the 4 byte extraction code.  */
 
164
        return  ((unsigned long) (field[0]))
 
165
          |    (((unsigned long) (field[1])) << 8)
 
166
          |    (((unsigned long) (field[2])) << 16)
 
167
          |    (((unsigned long) (field[3])) << 24);
 
168
 
 
169
    case 6:
 
170
      if (sizeof (elf_vma) == 8)
 
171
        return  ((elf_vma) (field[0]))
 
172
          |    (((elf_vma) (field[1])) << 8)
 
173
          |    (((elf_vma) (field[2])) << 16)
 
174
          |    (((elf_vma) (field[3])) << 24)
 
175
          |    (((elf_vma) (field[4])) << 32)
 
176
          |    (((elf_vma) (field[5])) << 40);
 
177
      else if (sizeof (elf_vma) == 4)
 
178
        /* We want to extract data from an 8 byte wide field and
 
179
           place it into a 4 byte wide field.  Since this is a little
 
180
           endian source we can just use the 4 byte extraction code.  */
 
181
        return  ((unsigned long) (field[0]))
 
182
          |    (((unsigned long) (field[1])) << 8)
 
183
          |    (((unsigned long) (field[2])) << 16)
 
184
          |    (((unsigned long) (field[3])) << 24);
 
185
 
 
186
    case 7:
 
187
      if (sizeof (elf_vma) == 8)
 
188
        return  ((elf_vma) (field[0]))
 
189
          |    (((elf_vma) (field[1])) << 8)
 
190
          |    (((elf_vma) (field[2])) << 16)
 
191
          |    (((elf_vma) (field[3])) << 24)
 
192
          |    (((elf_vma) (field[4])) << 32)
 
193
          |    (((elf_vma) (field[5])) << 40)
 
194
          |    (((elf_vma) (field[6])) << 48);
 
195
      else if (sizeof (elf_vma) == 4)
 
196
        /* We want to extract data from an 8 byte wide field and
 
197
           place it into a 4 byte wide field.  Since this is a little
 
198
           endian source we can just use the 4 byte extraction code.  */
 
199
        return  ((unsigned long) (field[0]))
 
200
          |    (((unsigned long) (field[1])) << 8)
 
201
          |    (((unsigned long) (field[2])) << 16)
 
202
          |    (((unsigned long) (field[3])) << 24);
 
203
 
 
204
    case 8:
 
205
      if (sizeof (elf_vma) == 8)
 
206
        return  ((elf_vma) (field[0]))
 
207
          |    (((elf_vma) (field[1])) << 8)
 
208
          |    (((elf_vma) (field[2])) << 16)
 
209
          |    (((elf_vma) (field[3])) << 24)
 
210
          |    (((elf_vma) (field[4])) << 32)
 
211
          |    (((elf_vma) (field[5])) << 40)
 
212
          |    (((elf_vma) (field[6])) << 48)
 
213
          |    (((elf_vma) (field[7])) << 56);
 
214
      else if (sizeof (elf_vma) == 4)
 
215
        /* We want to extract data from an 8 byte wide field and
 
216
           place it into a 4 byte wide field.  Since this is a little
 
217
           endian source we can just use the 4 byte extraction code.  */
 
218
        return  ((unsigned long) (field[0]))
 
219
          |    (((unsigned long) (field[1])) << 8)
 
220
          |    (((unsigned long) (field[2])) << 16)
 
221
          |    (((unsigned long) (field[3])) << 24);
 
222
 
 
223
    default:
 
224
      error (_("Unhandled data length: %d\n"), size);
 
225
      abort ();
 
226
    }
 
227
}
 
228
 
 
229
elf_vma
 
230
byte_get_big_endian (unsigned char *field, int size)
 
231
{
 
232
  switch (size)
 
233
    {
 
234
    case 1:
 
235
      return *field;
 
236
 
 
237
    case 2:
 
238
      return ((unsigned int) (field[1])) | (((int) (field[0])) << 8);
 
239
 
 
240
    case 3:
 
241
      return ((unsigned long) (field[2]))
 
242
        |   (((unsigned long) (field[1])) << 8)
 
243
        |   (((unsigned long) (field[0])) << 16);
 
244
 
 
245
    case 4:
 
246
      return ((unsigned long) (field[3]))
 
247
        |   (((unsigned long) (field[2])) << 8)
 
248
        |   (((unsigned long) (field[1])) << 16)
 
249
        |   (((unsigned long) (field[0])) << 24);
 
250
 
 
251
    case 5:
 
252
      if (sizeof (elf_vma) == 8)
 
253
        return ((elf_vma) (field[4]))
 
254
          |   (((elf_vma) (field[3])) << 8)
 
255
          |   (((elf_vma) (field[2])) << 16)
 
256
          |   (((elf_vma) (field[1])) << 24)
 
257
          |   (((elf_vma) (field[0])) << 32);
 
258
      else if (sizeof (elf_vma) == 4)
 
259
        {
 
260
          /* Although we are extracting data from an 8 byte wide field,
 
261
             we are returning only 4 bytes of data.  */
 
262
          field += 1;
 
263
          return ((unsigned long) (field[3]))
 
264
            |   (((unsigned long) (field[2])) << 8)
 
265
            |   (((unsigned long) (field[1])) << 16)
 
266
            |   (((unsigned long) (field[0])) << 24);
 
267
        }
 
268
 
 
269
    case 6:
 
270
      if (sizeof (elf_vma) == 8)
 
271
        return ((elf_vma) (field[5]))
 
272
          |   (((elf_vma) (field[4])) << 8)
 
273
          |   (((elf_vma) (field[3])) << 16)
 
274
          |   (((elf_vma) (field[2])) << 24)
 
275
          |   (((elf_vma) (field[1])) << 32)
 
276
          |   (((elf_vma) (field[0])) << 40);
 
277
      else if (sizeof (elf_vma) == 4)
 
278
        {
 
279
          /* Although we are extracting data from an 8 byte wide field,
 
280
             we are returning only 4 bytes of data.  */
 
281
          field += 2;
 
282
          return ((unsigned long) (field[3]))
 
283
            |   (((unsigned long) (field[2])) << 8)
 
284
            |   (((unsigned long) (field[1])) << 16)
 
285
            |   (((unsigned long) (field[0])) << 24);
 
286
        }
 
287
 
 
288
    case 7:
 
289
      if (sizeof (elf_vma) == 8)
 
290
        return ((elf_vma) (field[6]))
 
291
          |   (((elf_vma) (field[5])) << 8)
 
292
          |   (((elf_vma) (field[4])) << 16)
 
293
          |   (((elf_vma) (field[3])) << 24)
 
294
          |   (((elf_vma) (field[2])) << 32)
 
295
          |   (((elf_vma) (field[1])) << 40)
 
296
          |   (((elf_vma) (field[0])) << 48);
 
297
      else if (sizeof (elf_vma) == 4)
 
298
        {
 
299
          /* Although we are extracting data from an 8 byte wide field,
 
300
             we are returning only 4 bytes of data.  */
 
301
          field += 3;
 
302
          return ((unsigned long) (field[3]))
 
303
            |   (((unsigned long) (field[2])) << 8)
 
304
            |   (((unsigned long) (field[1])) << 16)
 
305
            |   (((unsigned long) (field[0])) << 24);
 
306
        }
 
307
 
 
308
    case 8:
 
309
      if (sizeof (elf_vma) == 8)
 
310
        return ((elf_vma) (field[7]))
 
311
          |   (((elf_vma) (field[6])) << 8)
 
312
          |   (((elf_vma) (field[5])) << 16)
 
313
          |   (((elf_vma) (field[4])) << 24)
 
314
          |   (((elf_vma) (field[3])) << 32)
 
315
          |   (((elf_vma) (field[2])) << 40)
 
316
          |   (((elf_vma) (field[1])) << 48)
 
317
          |   (((elf_vma) (field[0])) << 56);
 
318
      else if (sizeof (elf_vma) == 4)
 
319
        {
 
320
          /* Although we are extracting data from an 8 byte wide field,
 
321
             we are returning only 4 bytes of data.  */
 
322
          field += 4;
 
323
          return ((unsigned long) (field[3]))
 
324
            |   (((unsigned long) (field[2])) << 8)
 
325
            |   (((unsigned long) (field[1])) << 16)
 
326
            |   (((unsigned long) (field[0])) << 24);
 
327
        }
 
328
 
 
329
    default:
 
330
      error (_("Unhandled data length: %d\n"), size);
 
331
      abort ();
 
332
    }
 
333
}
 
334
 
 
335
elf_vma
 
336
byte_get_signed (unsigned char *field, int size)
 
337
{
 
338
  elf_vma x = byte_get (field, size);
 
339
 
 
340
  switch (size)
 
341
    {
 
342
    case 1:
 
343
      return (x ^ 0x80) - 0x80;
 
344
    case 2:
 
345
      return (x ^ 0x8000) - 0x8000;
 
346
    case 3:
 
347
      return (x ^ 0x800000) - 0x800000;
 
348
    case 4:
 
349
      return (x ^ 0x80000000) - 0x80000000;
 
350
    case 5:
 
351
    case 6:
 
352
    case 7:
 
353
    case 8:
 
354
      /* Reads of 5-, 6-, and 7-byte numbers are the result of
 
355
         trying to read past the end of a buffer, and will therefore
 
356
         not have meaningful values, so we don't try to deal with
 
357
         the sign in these cases.  */
 
358
      return x;
 
359
    default:
 
360
      abort ();
 
361
    }
 
362
}
 
363
 
 
364
/* Return the high-order 32-bits and the low-order 32-bits
 
365
   of an 8-byte value separately.  */
 
366
 
 
367
void
 
368
byte_get_64 (unsigned char *field, elf_vma *high, elf_vma *low)
 
369
{
 
370
  if (byte_get == byte_get_big_endian)
 
371
    {
 
372
      *high = byte_get_big_endian (field, 4);
 
373
      *low = byte_get_big_endian (field + 4, 4);
 
374
    }
 
375
  else
 
376
    {
 
377
      *high = byte_get_little_endian (field + 4, 4);
 
378
      *low = byte_get_little_endian (field, 4);
 
379
    }
 
380
  return;
 
381
}
 
382
 
 
383
/* Return the path name for a proxy entry in a thin archive, adjusted
 
384
   relative to the path name of the thin archive itself if necessary.
 
385
   Always returns a pointer to malloc'ed memory.  */
 
386
 
 
387
char *
 
388
adjust_relative_path (const char *file_name, const char *name,
 
389
                      int name_len)
 
390
{
 
391
  char * member_file_name;
 
392
  const char * base_name = lbasename (file_name);
 
393
 
 
394
  /* This is a proxy entry for a thin archive member.
 
395
     If the extended name table contains an absolute path
 
396
     name, or if the archive is in the current directory,
 
397
     use the path name as given.  Otherwise, we need to
 
398
     find the member relative to the directory where the
 
399
     archive is located.  */
 
400
  if (IS_ABSOLUTE_PATH (name) || base_name == file_name)
 
401
    {
 
402
      member_file_name = (char *) malloc (name_len + 1);
 
403
      if (member_file_name == NULL)
 
404
        {
 
405
          error (_("Out of memory\n"));
 
406
          return NULL;
 
407
        }
 
408
      memcpy (member_file_name, name, name_len);
 
409
      member_file_name[name_len] = '\0';
 
410
    }
 
411
  else
 
412
    {
 
413
      /* Concatenate the path components of the archive file name
 
414
         to the relative path name from the extended name table.  */
 
415
      size_t prefix_len = base_name - file_name;
 
416
      member_file_name = (char *) malloc (prefix_len + name_len + 1);
 
417
      if (member_file_name == NULL)
 
418
        {
 
419
          error (_("Out of memory\n"));
 
420
          return NULL;
 
421
        }
 
422
      memcpy (member_file_name, file_name, prefix_len);
 
423
      memcpy (member_file_name + prefix_len, name, name_len);
 
424
      member_file_name[prefix_len + name_len] = '\0';
 
425
    }
 
426
  return member_file_name;
 
427
}
 
428
 
 
429
/* Processes the archive index table and symbol table in ARCH.
 
430
   Entries in the index table are SIZEOF_AR_INDEX bytes long.
 
431
   Fills in ARCH->next_arhdr_offset and ARCH->arhdr.
 
432
   If READ_SYMBOLS is true then fills in ARCH->index_num, ARCH->index_array,
 
433
    ARCH->sym_size and ARCH->sym_table.
 
434
   It is the caller's responsibility to free ARCH->index_array and
 
435
    ARCH->sym_table.
 
436
   Returns TRUE upon success, FALSE otherwise.
 
437
   If failure occurs an error message is printed.  */
 
438
 
 
439
static bfd_boolean
 
440
process_archive_index_and_symbols (struct archive_info *  arch,
 
441
                                   unsigned int           sizeof_ar_index,
 
442
                                   bfd_boolean            read_symbols)
 
443
{
 
444
  size_t got;
 
445
  unsigned long size;
 
446
 
 
447
  size = strtoul (arch->arhdr.ar_size, NULL, 10);
 
448
  size = size + (size & 1);
 
449
 
 
450
  arch->next_arhdr_offset += sizeof arch->arhdr + size;
 
451
 
 
452
  if (! read_symbols)
 
453
    {
 
454
      if (fseek (arch->file, size, SEEK_CUR) != 0)
 
455
        {
 
456
          error (_("%s: failed to skip archive symbol table\n"),
 
457
                 arch->file_name);
 
458
          return FALSE;
 
459
        }
 
460
    }
 
461
  else
 
462
    {
 
463
      unsigned long i;
 
464
      /* A buffer used to hold numbers read in from an archive index.
 
465
         These are always SIZEOF_AR_INDEX bytes long and stored in
 
466
         big-endian format.  */
 
467
      unsigned char integer_buffer[sizeof arch->index_num];
 
468
      unsigned char * index_buffer;
 
469
 
 
470
      assert (sizeof_ar_index <= sizeof integer_buffer);
 
471
  
 
472
      /* Check the size of the archive index.  */
 
473
      if (size < sizeof_ar_index)
 
474
        {
 
475
          error (_("%s: the archive index is empty\n"), arch->file_name);
 
476
          return FALSE;
 
477
        }
 
478
 
 
479
      /* Read the number of entries in the archive index.  */
 
480
      got = fread (integer_buffer, 1, sizeof_ar_index, arch->file);
 
481
      if (got != sizeof_ar_index)
 
482
        {
 
483
          error (_("%s: failed to read archive index\n"), arch->file_name);
 
484
          return FALSE;
 
485
        }
 
486
 
 
487
      arch->index_num = byte_get_big_endian (integer_buffer, sizeof_ar_index);
 
488
      size -= sizeof_ar_index;
 
489
 
 
490
      if (size < arch->index_num * sizeof_ar_index)
 
491
        {
 
492
          error (_("%s: the archive index is supposed to have %ld entries of %d bytes, but the size is only %ld\n"),
 
493
                 arch->file_name, (long) arch->index_num, sizeof_ar_index, size);
 
494
          return FALSE;
 
495
        }
 
496
 
 
497
      /* Read in the archive index.  */
 
498
      index_buffer = (unsigned char *)
 
499
        malloc (arch->index_num * sizeof_ar_index);
 
500
      if (index_buffer == NULL)
 
501
        {
 
502
          error (_("Out of memory whilst trying to read archive symbol index\n"));
 
503
          return FALSE;
 
504
        }
 
505
 
 
506
      got = fread (index_buffer, sizeof_ar_index, arch->index_num, arch->file);
 
507
      if (got != arch->index_num)
 
508
        {
 
509
          free (index_buffer);
 
510
          error (_("%s: failed to read archive index\n"), arch->file_name);
 
511
          return FALSE;
 
512
        }
 
513
 
 
514
      size -= arch->index_num * sizeof_ar_index;
 
515
 
 
516
      /* Convert the index numbers into the host's numeric format.  */
 
517
      arch->index_array = (elf_vma *)
 
518
        malloc (arch->index_num * sizeof (* arch->index_array));
 
519
      if (arch->index_array == NULL)
 
520
        {
 
521
          free (index_buffer);
 
522
          error (_("Out of memory whilst trying to convert the archive symbol index\n"));
 
523
          return FALSE;
 
524
        }
 
525
 
 
526
      for (i = 0; i < arch->index_num; i++)
 
527
        arch->index_array[i] =
 
528
          byte_get_big_endian ((unsigned char *) (index_buffer + (i * sizeof_ar_index)),
 
529
                               sizeof_ar_index);
 
530
      free (index_buffer);
 
531
 
 
532
      /* The remaining space in the header is taken up by the symbol table.  */
 
533
      if (size < 1)
 
534
        {
 
535
          error (_("%s: the archive has an index but no symbols\n"),
 
536
                 arch->file_name);
 
537
          return FALSE;
 
538
        }
 
539
 
 
540
      arch->sym_table = (char *) malloc (size);
 
541
      if (arch->sym_table == NULL)
 
542
        {
 
543
          error (_("Out of memory whilst trying to read archive index symbol table\n"));
 
544
          return FALSE;
 
545
        }
 
546
 
 
547
      arch->sym_size = size;
 
548
      got = fread (arch->sym_table, 1, size, arch->file);
 
549
      if (got != size)
 
550
        {
 
551
          error (_("%s: failed to read archive index symbol table\n"),
 
552
                 arch->file_name);
 
553
          return FALSE;
 
554
        }
 
555
    }
 
556
 
 
557
  /* Read the next archive header.  */
 
558
  got = fread (&arch->arhdr, 1, sizeof arch->arhdr, arch->file);
 
559
  if (got != sizeof arch->arhdr && got != 0)
 
560
    {
 
561
      error (_("%s: failed to read archive header following archive index\n"),
 
562
             arch->file_name);
 
563
      return FALSE;
 
564
    }
 
565
 
 
566
  return TRUE;
 
567
}
 
568
 
 
569
/* Read the symbol table and long-name table from an archive.  */
 
570
 
 
571
int
 
572
setup_archive (struct archive_info *arch, const char *file_name,
 
573
               FILE *file, bfd_boolean is_thin_archive,
 
574
               bfd_boolean read_symbols)
 
575
{
 
576
  size_t got;
 
577
 
 
578
  arch->file_name = strdup (file_name);
 
579
  arch->file = file;
 
580
  arch->index_num = 0;
 
581
  arch->index_array = NULL;
 
582
  arch->sym_table = NULL;
 
583
  arch->sym_size = 0;
 
584
  arch->longnames = NULL;
 
585
  arch->longnames_size = 0;
 
586
  arch->nested_member_origin = 0;
 
587
  arch->is_thin_archive = is_thin_archive;
 
588
  arch->uses_64bit_indicies = FALSE;
 
589
  arch->next_arhdr_offset = SARMAG;
 
590
 
 
591
  /* Read the first archive member header.  */
 
592
  if (fseek (file, SARMAG, SEEK_SET) != 0)
 
593
    {
 
594
      error (_("%s: failed to seek to first archive header\n"), file_name);
 
595
      return 1;
 
596
    }
 
597
  got = fread (&arch->arhdr, 1, sizeof arch->arhdr, file);
 
598
  if (got != sizeof arch->arhdr)
 
599
    {
 
600
      if (got == 0)
 
601
        return 0;
 
602
 
 
603
      error (_("%s: failed to read archive header\n"), file_name);
 
604
      return 1;
 
605
    }
 
606
 
 
607
  /* See if this is the archive symbol table.  */
 
608
  if (const_strneq (arch->arhdr.ar_name, "/               "))
 
609
    {
 
610
      if (! process_archive_index_and_symbols (arch, 4, read_symbols))
 
611
        return 1;
 
612
    }
 
613
  else if (const_strneq (arch->arhdr.ar_name, "/SYM64/         "))
 
614
    {
 
615
      arch->uses_64bit_indicies = TRUE;
 
616
      if (! process_archive_index_and_symbols (arch, 8, read_symbols))
 
617
        return 1;
 
618
    }
 
619
  else if (read_symbols)
 
620
    printf (_("%s has no archive index\n"), file_name);
 
621
 
 
622
  if (const_strneq (arch->arhdr.ar_name, "//              "))
 
623
    {
 
624
      /* This is the archive string table holding long member names.  */
 
625
      arch->longnames_size = strtoul (arch->arhdr.ar_size, NULL, 10);
 
626
      arch->next_arhdr_offset += sizeof arch->arhdr + arch->longnames_size;
 
627
 
 
628
      arch->longnames = (char *) malloc (arch->longnames_size);
 
629
      if (arch->longnames == NULL)
 
630
        {
 
631
          error (_("Out of memory reading long symbol names in archive\n"));
 
632
          return 1;
 
633
        }
 
634
 
 
635
      if (fread (arch->longnames, arch->longnames_size, 1, file) != 1)
 
636
        {
 
637
          free (arch->longnames);
 
638
          arch->longnames = NULL;
 
639
          error (_("%s: failed to read long symbol name string table\n"),
 
640
                 file_name);
 
641
          return 1;
 
642
        }
 
643
 
 
644
      if ((arch->longnames_size & 1) != 0)
 
645
        getc (file);
 
646
    }
 
647
 
 
648
  return 0;
 
649
}
 
650
 
 
651
/* Open and setup a nested archive, if not already open.  */
 
652
 
 
653
int
 
654
setup_nested_archive (struct archive_info *nested_arch,
 
655
                      const char *member_file_name)
 
656
{
 
657
  FILE * member_file;
 
658
 
 
659
  /* Have we already setup this archive?  */
 
660
  if (nested_arch->file_name != NULL
 
661
      && streq (nested_arch->file_name, member_file_name))
 
662
    return 0;
 
663
 
 
664
  /* Close previous file and discard cached information.  */
 
665
  if (nested_arch->file != NULL)
 
666
    fclose (nested_arch->file);
 
667
  release_archive (nested_arch);
 
668
 
 
669
  member_file = fopen (member_file_name, "rb");
 
670
  if (member_file == NULL)
 
671
    return 1;
 
672
  return setup_archive (nested_arch, member_file_name, member_file,
 
673
                        FALSE, FALSE);
 
674
}
 
675
 
 
676
/* Release the memory used for the archive information.  */
 
677
 
 
678
void
 
679
release_archive (struct archive_info * arch)
 
680
{
 
681
  if (arch->file_name != NULL)
 
682
    free (arch->file_name);
 
683
  if (arch->index_array != NULL)
 
684
    free (arch->index_array);
 
685
  if (arch->sym_table != NULL)
 
686
    free (arch->sym_table);
 
687
  if (arch->longnames != NULL)
 
688
    free (arch->longnames);
 
689
}
 
690
 
 
691
/* Get the name of an archive member from the current archive header.
 
692
   For simple names, this will modify the ar_name field of the current
 
693
   archive header.  For long names, it will return a pointer to the
 
694
   longnames table.  For nested archives, it will open the nested archive
 
695
   and get the name recursively.  NESTED_ARCH is a single-entry cache so
 
696
   we don't keep rereading the same information from a nested archive.  */
 
697
 
 
698
char *
 
699
get_archive_member_name (struct archive_info *arch,
 
700
                         struct archive_info *nested_arch)
 
701
{
 
702
  unsigned long j, k;
 
703
 
 
704
  if (arch->arhdr.ar_name[0] == '/')
 
705
    {
 
706
      /* We have a long name.  */
 
707
      char *endp;
 
708
      char *member_file_name;
 
709
      char *member_name;
 
710
 
 
711
      if (arch->longnames == NULL || arch->longnames_size == 0)
 
712
        {
 
713
          error (_("Archive member uses long names, but no longname table found\n"));
 
714
          return NULL;
 
715
        }
 
716
      
 
717
      arch->nested_member_origin = 0;
 
718
      k = j = strtoul (arch->arhdr.ar_name + 1, &endp, 10);
 
719
      if (arch->is_thin_archive && endp != NULL && * endp == ':')
 
720
        arch->nested_member_origin = strtoul (endp + 1, NULL, 10);
 
721
 
 
722
      while ((j < arch->longnames_size)
 
723
             && (arch->longnames[j] != '\n')
 
724
             && (arch->longnames[j] != '\0'))
 
725
        j++;
 
726
      if (arch->longnames[j-1] == '/')
 
727
        j--;
 
728
      arch->longnames[j] = '\0';
 
729
 
 
730
      if (!arch->is_thin_archive || arch->nested_member_origin == 0)
 
731
        return arch->longnames + k;
 
732
 
 
733
      /* This is a proxy for a member of a nested archive.
 
734
         Find the name of the member in that archive.  */
 
735
      member_file_name = adjust_relative_path (arch->file_name,
 
736
                                               arch->longnames + k, j - k);
 
737
      if (member_file_name != NULL
 
738
          && setup_nested_archive (nested_arch, member_file_name) == 0)
 
739
        {
 
740
          member_name = get_archive_member_name_at (nested_arch,
 
741
                                                    arch->nested_member_origin,
 
742
                                                    NULL);
 
743
          if (member_name != NULL)
 
744
            {
 
745
              free (member_file_name);
 
746
              return member_name;
 
747
            }
 
748
        }
 
749
      free (member_file_name);
 
750
 
 
751
      /* Last resort: just return the name of the nested archive.  */
 
752
      return arch->longnames + k;
 
753
    }
 
754
 
 
755
  /* We have a normal (short) name.  */
 
756
  for (j = 0; j < sizeof (arch->arhdr.ar_name); j++)
 
757
    if (arch->arhdr.ar_name[j] == '/')
 
758
      {
 
759
        arch->arhdr.ar_name[j] = '\0';
 
760
        return arch->arhdr.ar_name;
 
761
      }
 
762
 
 
763
  /* The full ar_name field is used.  Don't rely on ar_date starting
 
764
     with a zero byte.  */
 
765
  {
 
766
    char *name = xmalloc (sizeof (arch->arhdr.ar_name) + 1);
 
767
    memcpy (name, arch->arhdr.ar_name, sizeof (arch->arhdr.ar_name));
 
768
    name[sizeof (arch->arhdr.ar_name)] = '\0';
 
769
    return name;
 
770
  }
 
771
}
 
772
 
 
773
/* Get the name of an archive member at a given OFFSET within an archive
 
774
   ARCH.  */
 
775
 
 
776
char *
 
777
get_archive_member_name_at (struct archive_info *arch,
 
778
                            unsigned long offset,
 
779
                            struct archive_info *nested_arch)
 
780
{
 
781
  size_t got;
 
782
 
 
783
  if (fseek (arch->file, offset, SEEK_SET) != 0)
 
784
    {
 
785
      error (_("%s: failed to seek to next file name\n"), arch->file_name);
 
786
      return NULL;
 
787
    }
 
788
  got = fread (&arch->arhdr, 1, sizeof arch->arhdr, arch->file);
 
789
  if (got != sizeof arch->arhdr)
 
790
    {
 
791
      error (_("%s: failed to read archive header\n"), arch->file_name);
 
792
      return NULL;
 
793
    }
 
794
  if (memcmp (arch->arhdr.ar_fmag, ARFMAG, 2) != 0)
 
795
    {
 
796
      error (_("%s: did not find a valid archive header\n"),
 
797
             arch->file_name);
 
798
      return NULL;
 
799
    }
 
800
 
 
801
  return get_archive_member_name (arch, nested_arch);
 
802
}
 
803
 
 
804
/* Construct a string showing the name of the archive member, qualified
 
805
   with the name of the containing archive file.  For thin archives, we
 
806
   use square brackets to denote the indirection.  For nested archives,
 
807
   we show the qualified name of the external member inside the square
 
808
   brackets (e.g., "thin.a[normal.a(foo.o)]").  */
 
809
 
 
810
char *
 
811
make_qualified_name (struct archive_info * arch,
 
812
                     struct archive_info * nested_arch,
 
813
                     const char *member_name)
 
814
{
 
815
  const char * error_name = _("<corrupt>");
 
816
  size_t len;
 
817
  char * name;
 
818
 
 
819
  len = strlen (arch->file_name) + strlen (member_name) + 3;
 
820
  if (arch->is_thin_archive
 
821
      && arch->nested_member_origin != 0)
 
822
    {
 
823
      /* PR 15140: Allow for corrupt thin archives.  */
 
824
      if (nested_arch->file_name)
 
825
        len += strlen (nested_arch->file_name) + 2;
 
826
      else
 
827
        len += strlen (error_name) + 2;
 
828
    }
 
829
 
 
830
  name = (char *) malloc (len);
 
831
  if (name == NULL)
 
832
    {
 
833
      error (_("Out of memory\n"));
 
834
      return NULL;
 
835
    }
 
836
 
 
837
  if (arch->is_thin_archive
 
838
      && arch->nested_member_origin != 0)
 
839
    {
 
840
      if (nested_arch->file_name)
 
841
        snprintf (name, len, "%s[%s(%s)]", arch->file_name,
 
842
                  nested_arch->file_name, member_name);
 
843
      else
 
844
        snprintf (name, len, "%s[%s(%s)]", arch->file_name,
 
845
                  error_name, member_name);     
 
846
    }
 
847
  else if (arch->is_thin_archive)
 
848
    snprintf (name, len, "%s[%s]", arch->file_name, member_name);
 
849
  else
 
850
    snprintf (name, len, "%s(%s)", arch->file_name, member_name);
 
851
 
 
852
  return name;
 
853
}