gcc/collect2-aix.c

   1 /* AIX cross support for collect2.
   2    Copyright (C) 2009 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify it under
   7 the terms of the GNU General Public License as published by the Free
   8 Software Foundation; either version 3, or (at your option) any later
   9 version.
  10
  11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GCC; see the file COPYING3.  If not see
  18 <http://www.gnu.org/licenses/>.  */
  19
  20 #include "config.h"
  21 #include "system.h"
  22 #include "coretypes.h"
  23 #include "tm.h"
  24 #include "collect2-aix.h"
  25
  26 #ifdef CROSS_AIX_SUPPORT
  27
  28 #include <sys/mman.h>
  29
  30 /* Read SIZE bytes starting at DATA as a big-endian value.  */
  31
  32 static inline bfd_vma
  33 read_value (char *data, unsigned int size)
  34 {
  35   bfd_vma value;
  36   unsigned int i;
  37
  38   value = 0;
  39   for (i = 0; i < size; i++)
  40     {
  41       value <<= 8;
  42       value += (unsigned char) data[i];
  43     }
  44   return value;
  45 }
  46
  47 /* FIELD is a char array.  Read the contents as a big-endian integer.  */
  48 #define READ_FIELD(FIELD) \
  49   read_value (FIELD, sizeof (FIELD))
  50
  51 /* OBJECT is a char pointer to an in-file object of type struct TYPE.
  52    Return the address of field FIELD.  */
  53 #define OBJECT_FIELD(OBJECT, TYPE, FIELD) \
  54   (OBJECT) + offsetof (struct TYPE, FIELD)
  55
  56 /* Return the size of FIELD, which is a field of struct TYPE.  */
  57 #define FIELD_SIZE(TYPE, FIELD) \
  58   sizeof (((struct TYPE *) (0))->FIELD)
  59
  60 /* OBJECT is a char pointer to an in-file object of type struct TYPE.
  61    Read the value of field FIELD as a big-endian integer.  */
  62 #define READ_OBJECT(OBJECT, TYPE, FIELD) \
  63   read_value (OBJECT_FIELD (OBJECT, TYPE, FIELD), FIELD_SIZE (TYPE, FIELD))
  64
  65 /* Copy FIELD from an external structure of type TYPE at address FROM
  66    to an internal structure pointed to by TO.  */
  67 #define COPY_FIELD(TO, FROM, TYPE, FIELD) \
  68   ((TO)->FIELD = READ_OBJECT (FROM, TYPE, FIELD))
  69
  70 /* Return true if STRING is less than SIZE bytes long.  EXTRA_TERMINATOR
  71    is another character (besides '\0') that acts as a terminator,
  72    or '\0' if none.  */
  73
  74 static bool
  75 string_within_bounds_p (const char *string, size_t size, char extra_terminator)
  76 {
  77   const char *p;
  78
  79   for (p = string; p < string + size; p++)
  80     if (*p == '\0' || *p == extra_terminator)
  81       return true;
  82   return false;
  83 }
  84
  85 /* STRING is a pointer to a char array.  Try to read its value as an
  86    ASCII-encoded integer.  On success, return true and store the result
  87    in TARGET.  */
  88 #define PARSE_INTEGER(TARGET, STRING) \
  89   (string_within_bounds_p (&(STRING)[0], sizeof (STRING), ' ') \
  90    && ((TARGET) = strtoul (STRING, NULL, 0), true))
  91
  92 /* Check that LDFILE's current object has SIZE bytes starting at OFFSET.  */
  93
  94 static inline bool
  95 within_object_p (LDFILE *ldfile, size_t offset, size_t size)
  96 {
  97   return offset <= ldfile->object_size && offset + size <= ldfile->object_size;
  98 }
  99
 100 /* Try to read the file header for an XCOFF object at OFFSET bytes into
 101    LDFILE.  The object is expected to be OBJECT_SIZE bytes in size.
 102    If the object is a member of an archive, NEXT_MEMBER is the offset
 103    of the next member, otherwise it is -1.
 104
 105    Return true on success, recording the object information in LDFILE.  */
 106
 107 static bool
 108 read_xcoff_object (LDFILE *ldfile, size_t offset, size_t object_size,
 109                    off_t next_member)
 110 {
 111   struct internal_filehdr *internal;
 112   char *external;
 113   void *map;
 114   size_t page_size;
 115
 116   /* First try to map the file into memory.  */
 117   page_size = getpagesize ();
 118   ldfile->page_offset = offset & (page_size - 1);
 119   map = mmap (NULL, object_size + ldfile->page_offset, PROT_READ,
 120               MAP_SHARED, ldfile->fd, offset - ldfile->page_offset);
 121   if (map == MAP_FAILED)
 122     return false;
 123
 124   /* Record the success.  */
 125   ldfile->object = (char *) map + ldfile->page_offset;
 126   ldfile->object_size = object_size;
 127   ldfile->next_member = next_member;
 128
 129   /* Read the magic value to determine the type of file.  */
 130   if (!within_object_p (ldfile, 0, F_MAGIC_SIZE))
 131     return false;
 132
 133   internal = &ldfile->filehdr;
 134   external = ldfile->object;
 135   internal->f_magic = read_value (external, F_MAGIC_SIZE);
 136   if (internal->f_magic == U802TOCMAGIC)
 137     {
 138       if (!within_object_p (ldfile, 0, sizeof (struct external_filehdr_32)))
 139         return false;
 140
 141       COPY_FIELD (internal, external, external_filehdr_32, f_nscns);
 142       COPY_FIELD (internal, external, external_filehdr_32, f_timdat);
 143       COPY_FIELD (internal, external, external_filehdr_32, f_symptr);
 144       COPY_FIELD (internal, external, external_filehdr_32, f_nsyms);
 145       COPY_FIELD (internal, external, external_filehdr_32, f_opthdr);
 146       COPY_FIELD (internal, external, external_filehdr_32, f_flags);
 147       return true;
 148     }
 149   else if (internal->f_magic == U803XTOCMAGIC
 150            || internal->f_magic == U64_TOCMAGIC)
 151     {
 152       if (!within_object_p (ldfile, 0, sizeof (struct external_filehdr_64)))
 153         return false;
 154
 155       COPY_FIELD (internal, external, external_filehdr_64, f_nscns);
 156       COPY_FIELD (internal, external, external_filehdr_64, f_timdat);
 157       COPY_FIELD (internal, external, external_filehdr_64, f_symptr);
 158       COPY_FIELD (internal, external, external_filehdr_64, f_nsyms);
 159       COPY_FIELD (internal, external, external_filehdr_64, f_opthdr);
 160       COPY_FIELD (internal, external, external_filehdr_64, f_flags);
 161       return true;
 162     }
 163   return false;
 164 }
 165
 166 /* Try to read an archive member at OFFSET bytes into LDFILE.
 167    Return true on success, recording the member and object
 168    information in LDFILE.  */
 169
 170 static bool
 171 read_archive_member (LDFILE *ldfile, size_t offset)
 172 {
 173   struct external_big_ar_member member;
 174   size_t namlen;
 175   size_t size;
 176   off_t next_member;
 177
 178   if (lseek (ldfile->fd, offset, SEEK_SET) >= 0
 179       && read (ldfile->fd, &member, sizeof (member)) == sizeof (member)
 180       && PARSE_INTEGER (namlen, member.ar_namlen)
 181       /* Stop once we reach the member table entry, which has a name
 182          of length 0.  */
 183       && namlen > 0
 184       && PARSE_INTEGER (size, member.ar_size)
 185       && PARSE_INTEGER (next_member, member.ar_nextoff))
 186     {
 187       /* The archive is followed by an even-padded name, then by
 188          a magic string of length SXCOFFARFMAG.  The object itself
 189          starts after that. */
 190       offset += sizeof (member) + namlen + SXCOFFARFMAG;
 191       offset += offset & 1;
 192       return read_xcoff_object (ldfile, offset, size, next_member);
 193     }
 194   return false;
 195 }
 196
 197 /* Try to treat LDFILE as a non-empty big archive.  Return true
 198    on success, storing the member and object information for
 199    the first member in LDFILE.  */
 200
 201 static bool
 202 read_big_archive (LDFILE *ldfile)
 203 {
 204   struct external_big_ar_filehdr filehdr;
 205   size_t offset;
 206
 207   return (lseek (ldfile->fd, 0L, SEEK_SET) == 0
 208           && read (ldfile->fd, &filehdr, sizeof (filehdr)) == sizeof (filehdr)
 209           && memcmp (filehdr.fl_magic, FL_MAGIC_BIG_AR, FL_MAGIC_SIZE) == 0
 210           && PARSE_INTEGER (offset, filehdr.fl_firstmemoff)
 211           && read_archive_member (ldfile, offset));
 212 }
 213
 214 /* LDFILE is a zero-initialized structure.  Try to open FILENAME,
 215    returning true on success.  */
 216
 217 static bool
 218 open_file (LDFILE *ldfile, const char *filename)
 219 {
 220   struct stat st;
 221
 222   ldfile->fd = open (filename, O_RDONLY);
 223   if (ldfile->fd < 0)
 224     return false;
 225
 226   if (read_big_archive (ldfile))
 227     return true;
 228
 229   if (fstat (ldfile->fd, &st) < 0)
 230     return false;
 231
 232   return read_xcoff_object (ldfile, 0, st.st_size, -1);
 233 }
 234
 235 /* Release the memory associated with the current object, if one has
 236    been mapped.  */
 237
 238 static void
 239 free_object (LDFILE *ldfile)
 240 {
 241   if (ldfile->object)
 242     munmap (ldfile->object - ldfile->page_offset,
 243             ldfile->object_size + ldfile->page_offset);
 244 }
 245
 246 /* Free LDFILE and all resources associated with it.  */
 247
 248 static void
 249 free_ldfile (LDFILE *ldfile)
 250 {
 251   if (ldfile->fd >= 0)
 252     close (ldfile->fd);
 253   XDELETE (ldfile);
 254 }
 255
 256 /* Implement the API-defined ldopen function.  */
 257
 258 LDFILE *
 259 ldopen (char *filename, LDFILE *ldfile)
 260 {
 261   if (ldfile == NULL)
 262     {
 263       ldfile = XCNEW (LDFILE);
 264       if (!open_file (ldfile, filename))
 265         {
 266           free_object (ldfile);
 267           free_ldfile (ldfile);
 268           return NULL;
 269         }
 270     }
 271   return ldfile;
 272 }
 273
 274 /* Implement the API-defined ldtbread function.  */
 275
 276 int
 277 ldtbread (LDFILE *ldfile, long index, SYMENT *internal)
 278 {
 279   size_t offset, name_length;
 280   char *external;
 281
 282   /* Make sure that the symbol index is valid.  */
 283   if (index < 0 || index >= HEADER (ldfile).f_nsyms)
 284     return FAILURE;
 285
 286   /* Work out the offset of the symbol table entry.  */
 287   offset = HEADER (ldfile).f_symptr + index * sizeof (struct external_syment);
 288   if (!within_object_p (ldfile, offset, sizeof (struct external_syment)))
 289     return FAILURE;
 290
 291   /* Read all the fields.  The format differs between 32-bit and
 292      64-bit files.  */
 293   external = ldfile->object + offset;
 294   if (HEADER (ldfile).f_magic == U802TOCMAGIC)
 295     {
 296       /* Copy the n_zeroes/n_offset interpretation.  */
 297       internal->n_zeroes = READ_OBJECT (external, external_syment,
 298                                         u.xcoff32.u.u.n_zeroes);
 299       internal->n_offset = READ_OBJECT (external, external_syment,
 300                                         u.xcoff32.u.u.n_offset);
 301
 302       /* Copy the n_name interpretation.  The internal version has room
 303          for a null terminator.  */
 304       name_length = FIELD_SIZE (external_syment, u.xcoff32.u.n_name);
 305       memcpy (internal->n_name,
 306               external + offsetof (struct external_syment, u.xcoff32.u.n_name),
 307               name_length);
 308       internal->n_name[name_length] = 0;
 309
 310       internal->n_value = READ_OBJECT (external, external_syment,
 311                                        u.xcoff32.n_value);
 312     }
 313   else
 314     {
 315       internal->n_zeroes = 0;
 316       internal->n_offset = READ_OBJECT (external, external_syment,
 317                                         u.xcoff64.n_offset);
 318       internal->n_value = READ_OBJECT (external, external_syment,
 319                                        u.xcoff64.n_value);
 320     }
 321   COPY_FIELD (internal, external, external_syment, n_scnum);
 322   COPY_FIELD (internal, external, external_syment, n_type);
 323   COPY_FIELD (internal, external, external_syment, n_sclass);
 324   COPY_FIELD (internal, external, external_syment, n_numaux);
 325   return SUCCESS;
 326 }
 327
 328 /* Implement the API-defined ldgetname function.  */
 329
 330 char *
 331 ldgetname (LDFILE *ldfile, SYMENT *symbol)
 332 {
 333   char *name;
 334   size_t offset;
 335
 336   /* If the zeroes field is nonzero, the name is in the symbol table
 337      entry itself.  */
 338   if (symbol->n_zeroes != 0)
 339     return symbol->n_name;
 340
 341   /* Otherwise, the symbol table entry contains an offset into the
 342      string table, which starts after the end of the symbol table.  */
 343   offset = (HEADER (ldfile).f_symptr
 344             + HEADER (ldfile).f_nsyms * sizeof (struct external_syment)
 345             + symbol->n_offset);
 346   if (offset >= ldfile->object_size)
 347     return NULL;
 348
 349   /* Make sure that the name is entirely contained within the object.  */
 350   name = ldfile->object + offset;
 351   if (!string_within_bounds_p (name, ldfile->object_size - offset, '\0'))
 352     return NULL;
 353
 354   return name;
 355 }
 356
 357 /* Implement the API-defined ldclose function.  */
 358
 359 int
 360 ldclose (LDFILE *ldfile)
 361 {
 362   free_object (ldfile);
 363   if (ldfile->next_member >= 0
 364       && read_archive_member (ldfile, ldfile->next_member))
 365     return FAILURE;
 366
 367   free_ldfile (ldfile);
 368   return SUCCESS;
 369 }
 370
 371 #endif