Merge branch 'vendor/GCC50'
[dragonfly.git] / contrib / binutils-2.24 / 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 }