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 }