Makefile.in (COLLECT2_OBJS): Add collect2-aix.o.

gcc/
	* Makefile.in (COLLECT2_OBJS): Add collect2-aix.o.
	(collect2.o): Depend on collect2-aix.h.
	(collect2-aix.o): New rule.
	* collect2-aix.h: New file.
	* collect2-aix.c: Likewise.
	* collect2.c: Include collect2-aix.h.  Don't undefine
	OBJECT_FORMAT_COFF if CROSS_AIX_SUPPORT is defined.
	Guard native includes with #ifndef CROSS_DIRECTORY_STRUCTURE.
	Use TARGET_AIX_VERSION instead of _AIX51.
	* config/rs6000/aix43.h (TARGET_AIX_VERSION): Define.
	* config/rs6000/aix51.h (TARGET_AIX_VERSION): Likewise.
	* config/rs6000/aix52.h (TARGET_AIX_VERSION): Likewise.
	* config/rs6000/aix53.h (TARGET_AIX_VERSION): Likewise.
	* config/rs6000/aix61.h (TARGET_AIX_VERSION): Likewise.

From-SVN: r148096

1 files changed, 371 insertions, 0 deletions

diff --git a/gcc/collect2-aix.c b/gcc/collect2-aix.c
new file mode 100644
index 0000000..7d25e7e
--- /dev/null
+++ b/gcc/collect2-aix.c
@@ -0,0 +1,371 @@
+/* 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