Subversion Repositories openrisc_2011-10-31

/* AIX cross support for collect2.

   Copyright (C) 2009 Free Software Foundation, Inc.

This file is part of GCC.

GCC 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, or (at your option) any later

version.

GCC 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 GCC; see the file COPYING3.  If not see

<http://www.gnu.org/licenses/>.  */

#include "config.h"

#include "system.h"

#include "coretypes.h"

#include "tm.h"

#include "collect2-aix.h"

#ifdef CROSS_AIX_SUPPORT

#include <sys/mman.h>

/* Read SIZE bytes starting at DATA as a big-endian value.  */

static inline bfd_vma

read_value (char *data, unsigned int size)

{

  bfd_vma value;

  unsigned int i;

  value = 0;

  for (i = 0; i < size; i++)

    {

      value <<= 8;

      value += (unsigned char) data[i];

    }

  return value;

}

/* FIELD is a char array.  Read the contents as a big-endian integer.  */

#define READ_FIELD(FIELD) \

  read_value (FIELD, sizeof (FIELD))

/* OBJECT is a char pointer to an in-file object of type struct TYPE.

   Return the address of field FIELD.  */

#define OBJECT_FIELD(OBJECT, TYPE, FIELD) \

  (OBJECT) + offsetof (struct TYPE, FIELD)

/* Return the size of FIELD, which is a field of struct TYPE.  */

#define FIELD_SIZE(TYPE, FIELD) \

  sizeof (((struct TYPE *) (0))->FIELD)

/* OBJECT is a char pointer to an in-file object of type struct TYPE.

   Read the value of field FIELD as a big-endian integer.  */

#define READ_OBJECT(OBJECT, TYPE, FIELD) \

  read_value (OBJECT_FIELD (OBJECT, TYPE, FIELD), FIELD_SIZE (TYPE, FIELD))

/* Copy FIELD from an external structure of type TYPE at address FROM

   to an internal structure pointed to by TO.  */

#define COPY_FIELD(TO, FROM, TYPE, FIELD) \

  ((TO)->FIELD = READ_OBJECT (FROM, TYPE, FIELD))

/* Return true if STRING is less than SIZE bytes long.  EXTRA_TERMINATOR

   is another character (besides '\0') that acts as a terminator,

   or '\0' if none.  */

static bool

string_within_bounds_p (const char *string, size_t size, char extra_terminator)

{

  const char *p;

  for (p = string; p < string + size; p++)

    if (*p == '\0' || *p == extra_terminator)

      return true;

  return false;

}

/* STRING is a pointer to a char array.  Try to read its value as an

   ASCII-encoded integer.  On success, return true and store the result

   in TARGET.  */

#define PARSE_INTEGER(TARGET, STRING) \

  (string_within_bounds_p (&(STRING)[0], sizeof (STRING), ' ') \

   && ((TARGET) = strtoul (STRING, NULL, 0), true))

/* Check that LDFILE's current object has SIZE bytes starting at OFFSET.  */

static inline bool

within_object_p (LDFILE *ldfile, size_t offset, size_t size)

{

  return offset <= ldfile->object_size && offset + size <= ldfile->object_size;

}

/* Try to read the file header for an XCOFF object at OFFSET bytes into

   LDFILE.  The object is expected to be OBJECT_SIZE bytes in size.

   If the object is a member of an archive, NEXT_MEMBER is the offset

   of the next member, otherwise it is -1.

   Return true on success, recording the object information in LDFILE.  */

static bool

read_xcoff_object (LDFILE *ldfile, size_t offset, size_t object_size,

                   off_t next_member)

{

  struct internal_filehdr *internal;

  char *external;

  void *map;

  size_t page_size;

  /* First try to map the file into memory.  */

  page_size = getpagesize ();

  ldfile->page_offset = offset & (page_size - 1);

  map = mmap (NULL, object_size + ldfile->page_offset, PROT_READ,

              MAP_SHARED, ldfile->fd, offset - ldfile->page_offset);

  if (map == MAP_FAILED)

    return false;

  /* Record the success.  */

  ldfile->object = (char *) map + ldfile->page_offset;

  ldfile->object_size = object_size;

  ldfile->next_member = next_member;

  /* Read the magic value to determine the type of file.  */

  if (!within_object_p (ldfile, 0, F_MAGIC_SIZE))

    return false;

  internal = &ldfile->filehdr;

  external = ldfile->object;

  internal->f_magic = read_value (external, F_MAGIC_SIZE);

  if (internal->f_magic == U802TOCMAGIC)

    {

      if (!within_object_p (ldfile, 0, sizeof (struct external_filehdr_32)))

        return false;

      COPY_FIELD (internal, external, external_filehdr_32, f_nscns);

      COPY_FIELD (internal, external, external_filehdr_32, f_timdat);

      COPY_FIELD (internal, external, external_filehdr_32, f_symptr);

      COPY_FIELD (internal, external, external_filehdr_32, f_nsyms);

      COPY_FIELD (internal, external, external_filehdr_32, f_opthdr);

      COPY_FIELD (internal, external, external_filehdr_32, f_flags);

      return true;

    }

  else if (internal->f_magic == U803XTOCMAGIC

           || internal->f_magic == U64_TOCMAGIC)

    {

      if (!within_object_p (ldfile, 0, sizeof (struct external_filehdr_64)))

        return false;

      COPY_FIELD (internal, external, external_filehdr_64, f_nscns);

      COPY_FIELD (internal, external, external_filehdr_64, f_timdat);

      COPY_FIELD (internal, external, external_filehdr_64, f_symptr);

      COPY_FIELD (internal, external, external_filehdr_64, f_nsyms);

      COPY_FIELD (internal, external, external_filehdr_64, f_opthdr);

      COPY_FIELD (internal, external, external_filehdr_64, f_flags);

      return true;

    }

  return false;

}

/* Try to read an archive member at OFFSET bytes into LDFILE.

   Return true on success, recording the member and object

   information in LDFILE.  */

static bool

read_archive_member (LDFILE *ldfile, size_t offset)

{

  struct external_big_ar_member member;

  size_t namlen;

  size_t size;

  off_t next_member;

  if (lseek (ldfile->fd, offset, SEEK_SET) >= 0

      && read (ldfile->fd, &member, sizeof (member)) == sizeof (member)

      && PARSE_INTEGER (namlen, member.ar_namlen)

      /* Stop once we reach the member table entry, which has a name

         of length 0.  */

      && namlen > 0

      && PARSE_INTEGER (size, member.ar_size)

      && PARSE_INTEGER (next_member, member.ar_nextoff))

    {

      /* The archive is followed by an even-padded name, then by

         a magic string of length SXCOFFARFMAG.  The object itself

         starts after that. */

      offset += sizeof (member) + namlen + SXCOFFARFMAG;

      offset += offset & 1;

      return read_xcoff_object (ldfile, offset, size, next_member);

    }

  return false;

}

/* Try to treat LDFILE as a non-empty big archive.  Return true

   on success, storing the member and object information for

   the first member in LDFILE.  */

static bool

read_big_archive (LDFILE *ldfile)

{

  struct external_big_ar_filehdr filehdr;

  size_t offset;

  return (lseek (ldfile->fd, 0L, SEEK_SET) == 0

          && read (ldfile->fd, &filehdr, sizeof (filehdr)) == sizeof (filehdr)

          && memcmp (filehdr.fl_magic, FL_MAGIC_BIG_AR, FL_MAGIC_SIZE) == 0

          && PARSE_INTEGER (offset, filehdr.fl_firstmemoff)

          && read_archive_member (ldfile, offset));

}

/* LDFILE is a zero-initialized structure.  Try to open FILENAME,

   returning true on success.  */

static bool

open_file (LDFILE *ldfile, const char *filename)

{

  struct stat st;

  ldfile->fd = open (filename, O_RDONLY);

  if (ldfile->fd < 0)

    return false;

  if (read_big_archive (ldfile))

    return true;

  if (fstat (ldfile->fd, &st) < 0)

    return false;

  return read_xcoff_object (ldfile, 0, st.st_size, -1);

}

/* Release the memory associated with the current object, if one has

   been mapped.  */

static void

free_object (LDFILE *ldfile)

{

  if (ldfile->object)

    munmap (ldfile->object - ldfile->page_offset,

            ldfile->object_size + ldfile->page_offset);

}

/* Free LDFILE and all resources associated with it.  */

static void

free_ldfile (LDFILE *ldfile)

{

  if (ldfile->fd >= 0)

    close (ldfile->fd);

  XDELETE (ldfile);

}

/* Implement the API-defined ldopen function.  */

LDFILE *

ldopen (char *filename, LDFILE *ldfile)

{

  if (ldfile == NULL)

    {

      ldfile = XCNEW (LDFILE);

      if (!open_file (ldfile, filename))

        {

          free_object (ldfile);

          free_ldfile (ldfile);

          return NULL;

        }

    }

  return ldfile;

}

/* Implement the API-defined ldtbread function.  */

int

ldtbread (LDFILE *ldfile, long index, SYMENT *internal)

{

  size_t offset, name_length;

  char *external;

  /* Make sure that the symbol index is valid.  */

  if (index < 0 || index >= HEADER (ldfile).f_nsyms)

    return FAILURE;

  /* Work out the offset of the symbol table entry.  */

  offset = HEADER (ldfile).f_symptr + index * sizeof (struct external_syment);

  if (!within_object_p (ldfile, offset, sizeof (struct external_syment)))

    return FAILURE;

  /* Read all the fields.  The format differs between 32-bit and

     64-bit files.  */

  external = ldfile->object + offset;

  if (HEADER (ldfile).f_magic == U802TOCMAGIC)

    {

      /* Copy the n_zeroes/n_offset interpretation.  */

      internal->n_zeroes = READ_OBJECT (external, external_syment,

                                        u.xcoff32.u.u.n_zeroes);

      internal->n_offset = READ_OBJECT (external, external_syment,

                                        u.xcoff32.u.u.n_offset);

      /* Copy the n_name interpretation.  The internal version has room

         for a null terminator.  */

      name_length = FIELD_SIZE (external_syment, u.xcoff32.u.n_name);

      memcpy (internal->n_name,

              external + offsetof (struct external_syment, u.xcoff32.u.n_name),

              name_length);

      internal->n_name[name_length] = 0;

      internal->n_value = READ_OBJECT (external, external_syment,

                                       u.xcoff32.n_value);

    }

  else

    {

      internal->n_zeroes = 0;

      internal->n_offset = READ_OBJECT (external, external_syment,

                                        u.xcoff64.n_offset);

      internal->n_value = READ_OBJECT (external, external_syment,

                                       u.xcoff64.n_value);

    }

  COPY_FIELD (internal, external, external_syment, n_scnum);

  COPY_FIELD (internal, external, external_syment, n_type);

  COPY_FIELD (internal, external, external_syment, n_sclass);

  COPY_FIELD (internal, external, external_syment, n_numaux);

  return SUCCESS;

}

/* Implement the API-defined ldgetname function.  */

char *

ldgetname (LDFILE *ldfile, SYMENT *symbol)

{

  char *name;

  size_t offset;

  /* If the zeroes field is nonzero, the name is in the symbol table

     entry itself.  */

  if (symbol->n_zeroes != 0)

    return symbol->n_name;

  /* Otherwise, the symbol table entry contains an offset into the

     string table, which starts after the end of the symbol table.  */

  offset = (HEADER (ldfile).f_symptr

            + HEADER (ldfile).f_nsyms * sizeof (struct external_syment)

            + symbol->n_offset);

  if (offset >= ldfile->object_size)

    return NULL;

  /* Make sure that the name is entirely contained within the object.  */

  name = ldfile->object + offset;

  if (!string_within_bounds_p (name, ldfile->object_size - offset, '\0'))

    return NULL;

  return name;

}

/* Implement the API-defined ldclose function.  */

int

ldclose (LDFILE *ldfile)

{

  free_object (ldfile);

  if (ldfile->next_member >= 0

      && read_archive_member (ldfile, ldfile->next_member))

    return FAILURE;

  free_ldfile (ldfile);

  return SUCCESS;

}

#endif