URL https://opencores.org/ocsvn/open8_urisc/open8_urisc/trunk

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [binutils/] [elfcomm.c] - Blame information for rev 165

Go to most recent revision | Details | Compare with Previous | View Log


/* elfcomm.c -- common code for ELF format file.
   Copyright 2010
   Free Software Foundation, Inc.
 
   Originally developed by Eric Youngdale <eric@andante.jic.com>
   Modifications by Nick Clifton <nickc@redhat.com>
 
   This file is part of GNU Binutils.
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
   02110-1301, USA.  */
 
#include "sysdep.h"
#include "libiberty.h"
#include "filenames.h"
#include "bfd.h"
#include "aout/ar.h"
#include "bucomm.h"
#include "elfcomm.h"
 
void
error (const char *message, ...)
{
  va_list args;
 
  va_start (args, message);
  fprintf (stderr, _("%s: Error: "), program_name);
  vfprintf (stderr, message, args);
  va_end (args);
}
 
void
warn (const char *message, ...)
{
  va_list args;
 
  va_start (args, message);
  fprintf (stderr, _("%s: Warning: "), program_name);
  vfprintf (stderr, message, args);
  va_end (args);
}
 
void (*byte_put) (unsigned char *, elf_vma, int);
 
void
byte_put_little_endian (unsigned char * field, elf_vma value, int size)
{
  switch (size)
    {
    case 8:
      field[7] = (((value >> 24) >> 24) >> 8) & 0xff;
      field[6] = ((value >> 24) >> 24) & 0xff;
      field[5] = ((value >> 24) >> 16) & 0xff;
      field[4] = ((value >> 24) >> 8) & 0xff;
      /* Fall through.  */
    case 4:
      field[3] = (value >> 24) & 0xff;
      /* Fall through.  */
    case 3:
      field[2] = (value >> 16) & 0xff;
      /* Fall through.  */
    case 2:
      field[1] = (value >> 8) & 0xff;
      /* Fall through.  */
    case 1:
      field[0] = value & 0xff;
      break;
 
    default:
      error (_("Unhandled data length: %d\n"), size);
      abort ();
    }
}
 
void
byte_put_big_endian (unsigned char * field, elf_vma value, int size)
{
  switch (size)
    {
    case 8:
      field[7] = value & 0xff;
      field[6] = (value >> 8) & 0xff;
      field[5] = (value >> 16) & 0xff;
      field[4] = (value >> 24) & 0xff;
      value >>= 16;
      value >>= 16;
      /* Fall through.  */
    case 4:
      field[3] = value & 0xff;
      value >>= 8;
      /* Fall through.  */
    case 3:
      field[2] = value & 0xff;
      value >>= 8;
      /* Fall through.  */
    case 2:
      field[1] = value & 0xff;
      value >>= 8;
      /* Fall through.  */
    case 1:
      field[0] = value & 0xff;
      break;
 
    default:
      error (_("Unhandled data length: %d\n"), size);
      abort ();
    }
}
 
elf_vma (*byte_get) (unsigned char *, int);
 
elf_vma
byte_get_little_endian (unsigned char *field, int size)
{
  switch (size)
    {
    case 1:
      return *field;
 
    case 2:
      return  ((unsigned int) (field[0]))
        |    (((unsigned int) (field[1])) << 8);
 
    case 3:
      return  ((unsigned long) (field[0]))
        |    (((unsigned long) (field[1])) << 8)
        |    (((unsigned long) (field[2])) << 16);
 
    case 4:
      return  ((unsigned long) (field[0]))
        |    (((unsigned long) (field[1])) << 8)
        |    (((unsigned long) (field[2])) << 16)
        |    (((unsigned long) (field[3])) << 24);
 
    case 8:
      if (sizeof (elf_vma) == 8)
        return  ((elf_vma) (field[0]))
          |    (((elf_vma) (field[1])) << 8)
          |    (((elf_vma) (field[2])) << 16)
          |    (((elf_vma) (field[3])) << 24)
          |    (((elf_vma) (field[4])) << 32)
          |    (((elf_vma) (field[5])) << 40)
          |    (((elf_vma) (field[6])) << 48)
          |    (((elf_vma) (field[7])) << 56);
      else if (sizeof (elf_vma) == 4)
        /* We want to extract data from an 8 byte wide field and
           place it into a 4 byte wide field.  Since this is a little
           endian source we can just use the 4 byte extraction code.  */
        return  ((unsigned long) (field[0]))
          |    (((unsigned long) (field[1])) << 8)
          |    (((unsigned long) (field[2])) << 16)
          |    (((unsigned long) (field[3])) << 24);
 
    default:
      error (_("Unhandled data length: %d\n"), size);
      abort ();
    }
}
 
elf_vma
byte_get_big_endian (unsigned char *field, int size)
{
  switch (size)
    {
    case 1:
      return *field;
 
    case 2:
      return ((unsigned int) (field[1])) | (((int) (field[0])) << 8);
 
    case 3:
      return ((unsigned long) (field[2]))
        |   (((unsigned long) (field[1])) << 8)
        |   (((unsigned long) (field[0])) << 16);
 
    case 4:
      return ((unsigned long) (field[3]))
        |   (((unsigned long) (field[2])) << 8)
        |   (((unsigned long) (field[1])) << 16)
        |   (((unsigned long) (field[0])) << 24);
 
    case 8:
      if (sizeof (elf_vma) == 8)
        return ((elf_vma) (field[7]))
          |   (((elf_vma) (field[6])) << 8)
          |   (((elf_vma) (field[5])) << 16)
          |   (((elf_vma) (field[4])) << 24)
          |   (((elf_vma) (field[3])) << 32)
          |   (((elf_vma) (field[2])) << 40)
          |   (((elf_vma) (field[1])) << 48)
          |   (((elf_vma) (field[0])) << 56);
      else if (sizeof (elf_vma) == 4)
        {
          /* Although we are extracing data from an 8 byte wide field,
             we are returning only 4 bytes of data.  */
          field += 4;
          return ((unsigned long) (field[3]))
            |   (((unsigned long) (field[2])) << 8)
            |   (((unsigned long) (field[1])) << 16)
            |   (((unsigned long) (field[0])) << 24);
        }
 
    default:
      error (_("Unhandled data length: %d\n"), size);
      abort ();
    }
}
 
elf_vma
byte_get_signed (unsigned char *field, int size)
{
  elf_vma x = byte_get (field, size);
 
  switch (size)
    {
    case 1:
      return (x ^ 0x80) - 0x80;
    case 2:
      return (x ^ 0x8000) - 0x8000;
    case 4:
      return (x ^ 0x80000000) - 0x80000000;
    case 8:
      return x;
    default:
      abort ();
    }
}
 
/* Return the path name for a proxy entry in a thin archive, adjusted
   relative to the path name of the thin archive itself if necessary.
   Always returns a pointer to malloc'ed memory.  */
 
char *
adjust_relative_path (const char *file_name, const char *name,
                      int name_len)
{
  char * member_file_name;
  const char * base_name = lbasename (file_name);
 
  /* This is a proxy entry for a thin archive member.
     If the extended name table contains an absolute path
     name, or if the archive is in the current directory,
     use the path name as given.  Otherwise, we need to
     find the member relative to the directory where the
     archive is located.  */
  if (IS_ABSOLUTE_PATH (name) || base_name == file_name)
    {
      member_file_name = (char *) malloc (name_len + 1);
      if (member_file_name == NULL)
        {
          error (_("Out of memory\n"));
          return NULL;
        }
      memcpy (member_file_name, name, name_len);
      member_file_name[name_len] = '\0';
    }
  else
    {
      /* Concatenate the path components of the archive file name
         to the relative path name from the extended name table.  */
      size_t prefix_len = base_name - file_name;
      member_file_name = (char *) malloc (prefix_len + name_len + 1);
      if (member_file_name == NULL)
        {
          error (_("Out of memory\n"));
          return NULL;
        }
      memcpy (member_file_name, file_name, prefix_len);
      memcpy (member_file_name + prefix_len, name, name_len);
      member_file_name[prefix_len + name_len] = '\0';
    }
  return member_file_name;
}
 
/* Read the symbol table and long-name table from an archive.  */
 
int
setup_archive (struct archive_info *arch, const char *file_name,
               FILE *file, bfd_boolean is_thin_archive,
               bfd_boolean read_symbols)
{
  size_t got;
  unsigned long size;
 
  arch->file_name = strdup (file_name);
  arch->file = file;
  arch->index_num = 0;
  arch->index_array = NULL;
  arch->sym_table = NULL;
  arch->sym_size = 0;
  arch->longnames = NULL;
  arch->longnames_size = 0;
  arch->nested_member_origin = 0;
  arch->is_thin_archive = is_thin_archive;
  arch->next_arhdr_offset = SARMAG;
 
  /* Read the first archive member header.  */
  if (fseek (file, SARMAG, SEEK_SET) != 0)
    {
      error (_("%s: failed to seek to first archive header\n"), file_name);
      return 1;
    }
  got = fread (&arch->arhdr, 1, sizeof arch->arhdr, file);
  if (got != sizeof arch->arhdr)
    {
      if (got == 0)
        return 0;
 
      error (_("%s: failed to read archive header\n"), file_name);
      return 1;
    }
 
  /* See if this is the archive symbol table.  */
  if (const_strneq (arch->arhdr.ar_name, "/               ")
      || const_strneq (arch->arhdr.ar_name, "/SYM64/         "))
    {
      size = strtoul (arch->arhdr.ar_size, NULL, 10);
      size = size + (size & 1);
 
      arch->next_arhdr_offset += sizeof arch->arhdr + size;
 
      if (read_symbols)
        {
          unsigned long i;
          /* A buffer used to hold numbers read in from an archive index.
             These are always 4 bytes long and stored in big-endian
             format.  */
#define SIZEOF_AR_INDEX_NUMBERS 4
          unsigned char integer_buffer[SIZEOF_AR_INDEX_NUMBERS];
          unsigned char * index_buffer;
 
          /* Check the size of the archive index.  */
          if (size < SIZEOF_AR_INDEX_NUMBERS)
            {
              error (_("%s: the archive index is empty\n"), file_name);
              return 1;
            }
 
          /* Read the numer of entries in the archive index.  */
          got = fread (integer_buffer, 1, sizeof integer_buffer, file);
          if (got != sizeof (integer_buffer))
            {
              error (_("%s: failed to read archive index\n"), file_name);
              return 1;
            }
          arch->index_num = byte_get_big_endian (integer_buffer,
                                                 sizeof integer_buffer);
          size -= SIZEOF_AR_INDEX_NUMBERS;
 
          /* Read in the archive index.  */
          if (size < arch->index_num * SIZEOF_AR_INDEX_NUMBERS)
            {
              error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
                     file_name, arch->index_num);
              return 1;
            }
          index_buffer = (unsigned char *)
              malloc (arch->index_num * SIZEOF_AR_INDEX_NUMBERS);
          if (index_buffer == NULL)
            {
              error (_("Out of memory whilst trying to read archive symbol index\n"));
              return 1;
            }
          got = fread (index_buffer, SIZEOF_AR_INDEX_NUMBERS,
                       arch->index_num, file);
          if (got != arch->index_num)
            {
              free (index_buffer);
              error (_("%s: failed to read archive index\n"), file_name);
              return 1;
            }
          size -= arch->index_num * SIZEOF_AR_INDEX_NUMBERS;
 
          /* Convert the index numbers into the host's numeric format.  */
          arch->index_array = (long unsigned int *)
              malloc (arch->index_num * sizeof (* arch->index_array));
          if (arch->index_array == NULL)
            {
              free (index_buffer);
              error (_("Out of memory whilst trying to convert the archive symbol index\n"));
              return 1;
            }
 
          for (i = 0; i < arch->index_num; i++)
            arch->index_array[i] = byte_get_big_endian ((unsigned char *) (index_buffer + (i * SIZEOF_AR_INDEX_NUMBERS)),
                                                        SIZEOF_AR_INDEX_NUMBERS);
          free (index_buffer);
 
          /* The remaining space in the header is taken up by the symbol
             table.  */
          if (size < 1)
            {
              error (_("%s: the archive has an index but no symbols\n"),
                     file_name);
              return 1;
            }
          arch->sym_table = (char *) malloc (size);
          arch->sym_size = size;
          if (arch->sym_table == NULL)
            {
              error (_("Out of memory whilst trying to read archive index symbol table\n"));
              return 1;
            }
          got = fread (arch->sym_table, 1, size, file);
          if (got != size)
            {
              error (_("%s: failed to read archive index symbol table\n"),
                     file_name);
              return 1;
            }
        }
      else
        {
          if (fseek (file, size, SEEK_CUR) != 0)
            {
              error (_("%s: failed to skip archive symbol table\n"),
                     file_name);
              return 1;
            }
        }
 
      /* Read the next archive header.  */
      got = fread (&arch->arhdr, 1, sizeof arch->arhdr, file);
      if (got != sizeof arch->arhdr)
        {
          if (got == 0)
            return 0;
          error (_("%s: failed to read archive header following archive index\n"),
                 file_name);
          return 1;
        }
    }
  else if (read_symbols)
    printf (_("%s has no archive index\n"), file_name);
 
  if (const_strneq (arch->arhdr.ar_name, "//              "))
    {
      /* This is the archive string table holding long member names.  */
      arch->longnames_size = strtoul (arch->arhdr.ar_size, NULL, 10);
      arch->next_arhdr_offset += sizeof arch->arhdr + arch->longnames_size;
 
      arch->longnames = (char *) malloc (arch->longnames_size);
      if (arch->longnames == NULL)
        {
          error (_("Out of memory reading long symbol names in archive\n"));
          return 1;
        }
 
      if (fread (arch->longnames, arch->longnames_size, 1, file) != 1)
        {
          free (arch->longnames);
          arch->longnames = NULL;
          error (_("%s: failed to read long symbol name string table\n"),
                 file_name);
          return 1;
        }
 
      if ((arch->longnames_size & 1) != 0)
        getc (file);
    }
 
  return 0;
}
 
/* Open and setup a nested archive, if not already open.  */
 
int
setup_nested_archive (struct archive_info *nested_arch,
                      const char *member_file_name)
{
  FILE * member_file;
 
  /* Have we already setup this archive?  */
  if (nested_arch->file_name != NULL
      && streq (nested_arch->file_name, member_file_name))
    return 0;
 
  /* Close previous file and discard cached information.  */
  if (nested_arch->file != NULL)
    fclose (nested_arch->file);
  release_archive (nested_arch);
 
  member_file = fopen (member_file_name, "rb");
  if (member_file == NULL)
    return 1;
  return setup_archive (nested_arch, member_file_name, member_file,
                        FALSE, FALSE);
}
 
/* Release the memory used for the archive information.  */
 
void
release_archive (struct archive_info * arch)
{
  if (arch->file_name != NULL)
    free (arch->file_name);
  if (arch->index_array != NULL)
    free (arch->index_array);
  if (arch->sym_table != NULL)
    free (arch->sym_table);
  if (arch->longnames != NULL)
    free (arch->longnames);
}
 
/* Get the name of an archive member from the current archive header.
   For simple names, this will modify the ar_name field of the current
   archive header.  For long names, it will return a pointer to the
   longnames table.  For nested archives, it will open the nested archive
   and get the name recursively.  NESTED_ARCH is a single-entry cache so
   we don't keep rereading the same information from a nested archive.  */
 
char *
get_archive_member_name (struct archive_info *arch,
                         struct archive_info *nested_arch)
{
  unsigned long j, k;
 
  if (arch->arhdr.ar_name[0] == '/')
    {
      /* We have a long name.  */
      char *endp;
      char *member_file_name;
      char *member_name;
 
      arch->nested_member_origin = 0;
      k = j = strtoul (arch->arhdr.ar_name + 1, &endp, 10);
      if (arch->is_thin_archive && endp != NULL && * endp == ':')
        arch->nested_member_origin = strtoul (endp + 1, NULL, 10);
 
      while ((j < arch->longnames_size)
             && (arch->longnames[j] != '\n')
             && (arch->longnames[j] != '\0'))
        j++;
      if (arch->longnames[j-1] == '/')
        j--;
      arch->longnames[j] = '\0';
 
      if (!arch->is_thin_archive || arch->nested_member_origin == 0)
        return arch->longnames + k;
 
      /* This is a proxy for a member of a nested archive.
         Find the name of the member in that archive.  */
      member_file_name = adjust_relative_path (arch->file_name,
                                               arch->longnames + k, j - k);
      if (member_file_name != NULL
          && setup_nested_archive (nested_arch, member_file_name) == 0)
        {
          member_name = get_archive_member_name_at (nested_arch,
                                                    arch->nested_member_origin,
                                                    NULL);
          if (member_name != NULL)
            {
              free (member_file_name);
              return member_name;
            }
        }
      free (member_file_name);
 
      /* Last resort: just return the name of the nested archive.  */
      return arch->longnames + k;
    }
 
  /* We have a normal (short) name.  */
  for (j = 0; j < sizeof (arch->arhdr.ar_name); j++)
    if (arch->arhdr.ar_name[j] == '/')
      {
        arch->arhdr.ar_name[j] = '\0';
        return arch->arhdr.ar_name;
      }
 
  /* The full ar_name field is used.  Don't rely on ar_date starting
     with a zero byte.  */
  {
    char *name = xmalloc (sizeof (arch->arhdr.ar_name) + 1);
    memcpy (name, arch->arhdr.ar_name, sizeof (arch->arhdr.ar_name));
    name[sizeof (arch->arhdr.ar_name)] = '\0';
    return name;
  }
}
 
/* Get the name of an archive member at a given OFFSET within an archive
   ARCH.  */
 
char *
get_archive_member_name_at (struct archive_info *arch,
                            unsigned long offset,
                            struct archive_info *nested_arch)
{
  size_t got;
 
  if (fseek (arch->file, offset, SEEK_SET) != 0)
    {
      error (_("%s: failed to seek to next file name\n"), arch->file_name);
      return NULL;
    }
  got = fread (&arch->arhdr, 1, sizeof arch->arhdr, arch->file);
  if (got != sizeof arch->arhdr)
    {
      error (_("%s: failed to read archive header\n"), arch->file_name);
      return NULL;
    }
  if (memcmp (arch->arhdr.ar_fmag, ARFMAG, 2) != 0)
    {
      error (_("%s: did not find a valid archive header\n"),
             arch->file_name);
      return NULL;
    }
 
  return get_archive_member_name (arch, nested_arch);
}
 
/* Construct a string showing the name of the archive member, qualified
   with the name of the containing archive file.  For thin archives, we
   use square brackets to denote the indirection.  For nested archives,
   we show the qualified name of the external member inside the square
   brackets (e.g., "thin.a[normal.a(foo.o)]").  */
 
char *
make_qualified_name (struct archive_info * arch,
                     struct archive_info * nested_arch,
                     const char *member_name)
{
  size_t len;
  char * name;
 
  len = strlen (arch->file_name) + strlen (member_name) + 3;
  if (arch->is_thin_archive && arch->nested_member_origin != 0)
    len += strlen (nested_arch->file_name) + 2;
 
  name = (char *) malloc (len);
  if (name == NULL)
    {
      error (_("Out of memory\n"));
      return NULL;
    }
 
  if (arch->is_thin_archive && arch->nested_member_origin != 0)
    snprintf (name, len, "%s[%s(%s)]", arch->file_name,
              nested_arch->file_name, member_name);
  else if (arch->is_thin_archive)
    snprintf (name, len, "%s[%s]", arch->file_name, member_name);
  else
    snprintf (name, len, "%s(%s)", arch->file_name, member_name);
 
  return name;
}

Browse

Tools

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [binutils/] [elfcomm.c] - Blame information for rev 165

Line No.	Rev	Author	Line
1	15	khays	`/* 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			`}`