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