binutils/elfcomm.c

   1 /* elfcomm.c -- common code for ELF format file.
   2    Copyright 2010
   3    Free Software Foundation, Inc.
   4
   5    Originally developed by Eric Youngdale <eric@andante.jic.com>
   6    Modifications by Nick Clifton <nickc@redhat.com>
   7
   8    This file is part of GNU Binutils.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
  23    02110-1301, USA.  */
  24
  25 #include "sysdep.h"
  26 #include "libiberty.h"
  27 #include "filenames.h"
  28 #include "bfd.h"
  29 #include "aout/ar.h"
  30 #include "bucomm.h"
  31 #include "elfcomm.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 path name for a proxy entry in a thin archive, adjusted
 242    relative to the path name of the thin archive itself if necessary.
 243    Always returns a pointer to malloc'ed memory.  */
 244
 245 char *
 246 adjust_relative_path (const char *file_name, const char *name,
 247                       int name_len)
 248 {
 249   char * member_file_name;
 250   const char * base_name = lbasename (file_name);
 251
 252   /* This is a proxy entry for a thin archive member.
 253      If the extended name table contains an absolute path
 254      name, or if the archive is in the current directory,
 255      use the path name as given.  Otherwise, we need to
 256      find the member relative to the directory where the
 257      archive is located.  */
 258   if (IS_ABSOLUTE_PATH (name) || base_name == file_name)
 259     {
 260       member_file_name = (char *) malloc (name_len + 1);
 261       if (member_file_name == NULL)
 262         {
 263           error (_("Out of memory\n"));
 264           return NULL;
 265         }
 266       memcpy (member_file_name, name, name_len);
 267       member_file_name[name_len] = '\0';
 268     }
 269   else
 270     {
 271       /* Concatenate the path components of the archive file name
 272          to the relative path name from the extended name table.  */
 273       size_t prefix_len = base_name - file_name;
 274       member_file_name = (char *) malloc (prefix_len + name_len + 1);
 275       if (member_file_name == NULL)
 276         {
 277           error (_("Out of memory\n"));
 278           return NULL;
 279         }
 280       memcpy (member_file_name, file_name, prefix_len);
 281       memcpy (member_file_name + prefix_len, name, name_len);
 282       member_file_name[prefix_len + name_len] = '\0';
 283     }
 284   return member_file_name;
 285 }
 286
 287 /* Read the symbol table and long-name table from an archive.  */
 288
 289 int
 290 setup_archive (struct archive_info *arch, const char *file_name,
 291                FILE *file, bfd_boolean is_thin_archive,
 292                bfd_boolean read_symbols)
 293 {
 294   size_t got;
 295   unsigned long size;
 296
 297   arch->file_name = strdup (file_name);
 298   arch->file = file;
 299   arch->index_num = 0;
 300   arch->index_array = NULL;
 301   arch->sym_table = NULL;
 302   arch->sym_size = 0;
 303   arch->longnames = NULL;
 304   arch->longnames_size = 0;
 305   arch->nested_member_origin = 0;
 306   arch->is_thin_archive = is_thin_archive;
 307   arch->next_arhdr_offset = SARMAG;
 308
 309   /* Read the first archive member header.  */
 310   if (fseek (file, SARMAG, SEEK_SET) != 0)
 311     {
 312       error (_("%s: failed to seek to first archive header\n"), file_name);
 313       return 1;
 314     }
 315   got = fread (&arch->arhdr, 1, sizeof arch->arhdr, file);
 316   if (got != sizeof arch->arhdr)
 317     {
 318       if (got == 0)
 319         return 0;
 320
 321       error (_("%s: failed to read archive header\n"), file_name);
 322       return 1;
 323     }
 324
 325   /* See if this is the archive symbol table.  */
 326   if (const_strneq (arch->arhdr.ar_name, "/               ")
 327       || const_strneq (arch->arhdr.ar_name, "/SYM64/         "))
 328     {
 329       size = strtoul (arch->arhdr.ar_size, NULL, 10);
 330       size = size + (size & 1);
 331
 332       arch->next_arhdr_offset += sizeof arch->arhdr + size;
 333
 334       if (read_symbols)
 335         {
 336           unsigned long i;
 337           /* A buffer used to hold numbers read in from an archive index.
 338              These are always 4 bytes long and stored in big-endian
 339              format.  */
 340 #define SIZEOF_AR_INDEX_NUMBERS 4
 341           unsigned char integer_buffer[SIZEOF_AR_INDEX_NUMBERS];
 342           unsigned char * index_buffer;
 343
 344           /* Check the size of the archive index.  */
 345           if (size < SIZEOF_AR_INDEX_NUMBERS)
 346             {
 347               error (_("%s: the archive index is empty\n"), file_name);
 348               return 1;
 349             }
 350
 351           /* Read the numer of entries in the archive index.  */
 352           got = fread (integer_buffer, 1, sizeof integer_buffer, file);
 353           if (got != sizeof (integer_buffer))
 354             {
 355               error (_("%s: failed to read archive index\n"), file_name);
 356               return 1;
 357             }
 358           arch->index_num = byte_get_big_endian (integer_buffer,
 359                                                  sizeof integer_buffer);
 360           size -= SIZEOF_AR_INDEX_NUMBERS;
 361
 362           /* Read in the archive index.  */
 363           if (size < arch->index_num * SIZEOF_AR_INDEX_NUMBERS)
 364             {
 365               error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
 366                      file_name, arch->index_num);
 367               return 1;
 368             }
 369           index_buffer = (unsigned char *)
 370               malloc (arch->index_num * SIZEOF_AR_INDEX_NUMBERS);
 371           if (index_buffer == NULL)
 372             {
 373               error (_("Out of memory whilst trying to read archive symbol index\n"));
 374               return 1;
 375             }
 376           got = fread (index_buffer, SIZEOF_AR_INDEX_NUMBERS,
 377                        arch->index_num, file);
 378           if (got != arch->index_num)
 379             {
 380               free (index_buffer);
 381               error (_("%s: failed to read archive index\n"), file_name);
 382               return 1;
 383             }
 384           size -= arch->index_num * SIZEOF_AR_INDEX_NUMBERS;
 385
 386           /* Convert the index numbers into the host's numeric format.  */
 387           arch->index_array = (long unsigned int *)
 388               malloc (arch->index_num * sizeof (* arch->index_array));
 389           if (arch->index_array == NULL)
 390             {
 391               free (index_buffer);
 392               error (_("Out of memory whilst trying to convert the archive symbol index\n"));
 393               return 1;
 394             }
 395
 396           for (i = 0; i < arch->index_num; i++)
 397             arch->index_array[i] = byte_get_big_endian ((unsigned char *) (index_buffer + (i * SIZEOF_AR_INDEX_NUMBERS)),
 398                                                         SIZEOF_AR_INDEX_NUMBERS);
 399           free (index_buffer);
 400
 401           /* The remaining space in the header is taken up by the symbol
 402              table.  */
 403           if (size < 1)
 404             {
 405               error (_("%s: the archive has an index but no symbols\n"),
 406                      file_name);
 407               return 1;
 408             }
 409           arch->sym_table = (char *) malloc (size);
 410           arch->sym_size = size;
 411           if (arch->sym_table == NULL)
 412             {
 413               error (_("Out of memory whilst trying to read archive index symbol table\n"));
 414               return 1;
 415             }
 416           got = fread (arch->sym_table, 1, size, file);
 417           if (got != size)
 418             {
 419               error (_("%s: failed to read archive index symbol table\n"),
 420                      file_name);
 421               return 1;
 422             }
 423         }
 424       else
 425         {
 426           if (fseek (file, size, SEEK_CUR) != 0)
 427             {
 428               error (_("%s: failed to skip archive symbol table\n"),
 429                      file_name);
 430               return 1;
 431             }
 432         }
 433
 434       /* Read the next archive header.  */
 435       got = fread (&arch->arhdr, 1, sizeof arch->arhdr, file);
 436       if (got != sizeof arch->arhdr)
 437         {
 438           if (got == 0)
 439             return 0;
 440           error (_("%s: failed to read archive header following archive index\n"),
 441                  file_name);
 442           return 1;
 443         }
 444     }
 445   else if (read_symbols)
 446     printf (_("%s has no archive index\n"), file_name);
 447
 448   if (const_strneq (arch->arhdr.ar_name, "//              "))
 449     {
 450       /* This is the archive string table holding long member names.  */
 451       arch->longnames_size = strtoul (arch->arhdr.ar_size, NULL, 10);
 452       arch->next_arhdr_offset += sizeof arch->arhdr + arch->longnames_size;
 453
 454       arch->longnames = (char *) malloc (arch->longnames_size);
 455       if (arch->longnames == NULL)
 456         {
 457           error (_("Out of memory reading long symbol names in archive\n"));
 458           return 1;
 459         }
 460
 461       if (fread (arch->longnames, arch->longnames_size, 1, file) != 1)
 462         {
 463           free (arch->longnames);
 464           arch->longnames = NULL;
 465           error (_("%s: failed to read long symbol name string table\n"),
 466                  file_name);
 467           return 1;
 468         }
 469
 470       if ((arch->longnames_size & 1) != 0)
 471         getc (file);
 472     }
 473
 474   return 0;
 475 }
 476
 477 /* Open and setup a nested archive, if not already open.  */
 478
 479 int
 480 setup_nested_archive (struct archive_info *nested_arch,
 481                       const char *member_file_name)
 482 {
 483   FILE * member_file;
 484
 485   /* Have we already setup this archive?  */
 486   if (nested_arch->file_name != NULL
 487       && streq (nested_arch->file_name, member_file_name))
 488     return 0;
 489
 490   /* Close previous file and discard cached information.  */
 491   if (nested_arch->file != NULL)
 492     fclose (nested_arch->file);
 493   release_archive (nested_arch);
 494
 495   member_file = fopen (member_file_name, "rb");
 496   if (member_file == NULL)
 497     return 1;
 498   return setup_archive (nested_arch, member_file_name, member_file,
 499                         FALSE, FALSE);
 500 }
 501
 502 /* Release the memory used for the archive information.  */
 503
 504 void
 505 release_archive (struct archive_info * arch)
 506 {
 507   if (arch->file_name != NULL)
 508     free (arch->file_name);
 509   if (arch->index_array != NULL)
 510     free (arch->index_array);
 511   if (arch->sym_table != NULL)
 512     free (arch->sym_table);
 513   if (arch->longnames != NULL)
 514     free (arch->longnames);
 515 }
 516
 517 /* Get the name of an archive member from the current archive header.
 518    For simple names, this will modify the ar_name field of the current
 519    archive header.  For long names, it will return a pointer to the
 520    longnames table.  For nested archives, it will open the nested archive
 521    and get the name recursively.  NESTED_ARCH is a single-entry cache so
 522    we don't keep rereading the same information from a nested archive.  */
 523
 524 char *
 525 get_archive_member_name (struct archive_info *arch,
 526                          struct archive_info *nested_arch)
 527 {
 528   unsigned long j, k;
 529
 530   if (arch->arhdr.ar_name[0] == '/')
 531     {
 532       /* We have a long name.  */
 533       char *endp;
 534       char *member_file_name;
 535       char *member_name;
 536
 537       arch->nested_member_origin = 0;
 538       k = j = strtoul (arch->arhdr.ar_name + 1, &endp, 10);
 539       if (arch->is_thin_archive && endp != NULL && * endp == ':')
 540         arch->nested_member_origin = strtoul (endp + 1, NULL, 10);
 541
 542       while ((j < arch->longnames_size)
 543              && (arch->longnames[j] != '\n')
 544              && (arch->longnames[j] != '\0'))
 545         j++;
 546       if (arch->longnames[j-1] == '/')
 547         j--;
 548       arch->longnames[j] = '\0';
 549
 550       if (!arch->is_thin_archive || arch->nested_member_origin == 0)
 551         return arch->longnames + k;
 552
 553       /* This is a proxy for a member of a nested archive.
 554          Find the name of the member in that archive.  */
 555       member_file_name = adjust_relative_path (arch->file_name,
 556                                                arch->longnames + k, j - k);
 557       if (member_file_name != NULL
 558           && setup_nested_archive (nested_arch, member_file_name) == 0)
 559         {
 560           member_name = get_archive_member_name_at (nested_arch,
 561                                                     arch->nested_member_origin,
 562                                                     NULL);
 563           if (member_name != NULL)
 564             {
 565               free (member_file_name);
 566               return member_name;
 567             }
 568         }
 569       free (member_file_name);
 570
 571       /* Last resort: just return the name of the nested archive.  */
 572       return arch->longnames + k;
 573     }
 574
 575   /* We have a normal (short) name.  */
 576   for (j = 0; j < sizeof (arch->arhdr.ar_name); j++)
 577     if (arch->arhdr.ar_name[j] == '/')
 578       {
 579         arch->arhdr.ar_name[j] = '\0';
 580         return arch->arhdr.ar_name;
 581       }
 582
 583   /* The full ar_name field is used.  Don't rely on ar_date starting
 584      with a zero byte.  */
 585   {
 586     char *name = xmalloc (sizeof (arch->arhdr.ar_name) + 1);
 587     memcpy (name, arch->arhdr.ar_name, sizeof (arch->arhdr.ar_name));
 588     name[sizeof (arch->arhdr.ar_name)] = '\0';
 589     return name;
 590   }
 591 }
 592
 593 /* Get the name of an archive member at a given OFFSET within an archive
 594    ARCH.  */
 595
 596 char *
 597 get_archive_member_name_at (struct archive_info *arch,
 598                             unsigned long offset,
 599                             struct archive_info *nested_arch)
 600 {
 601   size_t got;
 602
 603   if (fseek (arch->file, offset, SEEK_SET) != 0)
 604     {
 605       error (_("%s: failed to seek to next file name\n"), arch->file_name);
 606       return NULL;
 607     }
 608   got = fread (&arch->arhdr, 1, sizeof arch->arhdr, arch->file);
 609   if (got != sizeof arch->arhdr)
 610     {
 611       error (_("%s: failed to read archive header\n"), arch->file_name);
 612       return NULL;
 613     }
 614   if (memcmp (arch->arhdr.ar_fmag, ARFMAG, 2) != 0)
 615     {
 616       error (_("%s: did not find a valid archive header\n"),
 617              arch->file_name);
 618       return NULL;
 619     }
 620
 621   return get_archive_member_name (arch, nested_arch);
 622 }
 623
 624 /* Construct a string showing the name of the archive member, qualified
 625    with the name of the containing archive file.  For thin archives, we
 626    use square brackets to denote the indirection.  For nested archives,
 627    we show the qualified name of the external member inside the square
 628    brackets (e.g., "thin.a[normal.a(foo.o)]").  */
 629
 630 char *
 631 make_qualified_name (struct archive_info * arch,
 632                      struct archive_info * nested_arch,
 633                      const char *member_name)
 634 {
 635   size_t len;
 636   char * name;
 637
 638   len = strlen (arch->file_name) + strlen (member_name) + 3;
 639   if (arch->is_thin_archive && arch->nested_member_origin != 0)
 640     len += strlen (nested_arch->file_name) + 2;
 641
 642   name = (char *) malloc (len);
 643   if (name == NULL)
 644     {
 645       error (_("Out of memory\n"));
 646       return NULL;
 647     }
 648
 649   if (arch->is_thin_archive && arch->nested_member_origin != 0)
 650     snprintf (name, len, "%s[%s(%s)]", arch->file_name,
 651               nested_arch->file_name, member_name);
 652   else if (arch->is_thin_archive)
 653     snprintf (name, len, "%s[%s]", arch->file_name, member_name);
 654   else
 655     snprintf (name, len, "%s(%s)", arch->file_name, member_name);
 656
 657   return name;
 658 }