bfd/riscix.c

   1 /* BFD back-end for RISC iX (Acorn, arm) binaries.
   2    Copyright (C) 1994, 95, 96, 97, 98, 1999 Free Software Foundation, Inc.
   3    Contributed by Richard Earnshaw (rwe@pegasus.esprit.ec.org)
   4
   5 This file is part of BFD, the Binary File Descriptor library.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21
  22 /* RISC iX overloads the MAGIC field to indicate more than just the usual
  23    [ZNO]MAGIC values.  Also included are squeezing information and
  24    shared library usage.  */
  25
  26 /* The following come from the man page.  */
  27 #define SHLIBLEN 60
  28
  29 #define MF_IMPURE       00200
  30 #define MF_SQUEEZED     01000
  31 #define MF_USES_SL      02000
  32 #define MF_IS_SL        04000
  33
  34 /* Common combinations.  */
  35 #define IMAGIC          (MF_IMPURE|ZMAGIC)      /* Demand load (impure text) */
  36 #define SPOMAGIC        (MF_USES_SL|OMAGIC)     /* OMAGIC with large header */
  37                                         /* -- may contain a ref to a */
  38                                         /* shared lib required by the */
  39                                         /* object. */
  40 #define SLOMAGIC        (MF_IS_SL|OMAGIC) /* A reference to a shared library */
  41                                           /* The text portion of the object */
  42                                           /* contains "overflow text" from */
  43                                           /* the shared library to be linked */
  44                                           /* in with an object */
  45 #define QMAGIC          (MF_SQUEEZED|ZMAGIC)    /* Sqeezed demand paged. */
  46                                           /* NOTE: This interpretation of */
  47                                           /* QMAGIC seems to be at variance */
  48                                           /* With that used on other */
  49                                           /* architectures. */
  50 #define SPZMAGIC        (MF_USES_SL|ZMAGIC)     /* program which uses sl */
  51 #define SPQMAGIC        (MF_USES_SL|QMAGIC)     /* sqeezed ditto */
  52 #define SLZMAGIC        (MF_IS_SL|ZMAGIC)       /* shared lib part of prog */
  53 #define SLPZMAGIC       (MF_USES_SL|SLZMAGIC)   /* sl which uses another */
  54
  55 #define N_SHARED_LIB(x) ((x).a_info & MF_USES_SL)
  56
  57 /* Only a pure OMAGIC file has the minimal header */
  58 #define N_TXTOFF(x)                     \
  59  ((x).a_info == OMAGIC ? 32             \
  60   : (N_MAGIC(x) == ZMAGIC) ? TARGET_PAGE_SIZE  \
  61   : 999)
  62
  63 #define N_TXTADDR(x)                                                         \
  64   (N_MAGIC(x) != ZMAGIC ? 0 /* object file or NMAGIC */                      \
  65    /* Programs with shared libs are loaded at the first page after all the   \
  66       text segments of the shared library programs.  Without looking this    \
  67       up we can't know exactly what the address will be.  A reasonable guess \
  68       is that a_entry will be in the first page of the executable.  */       \
  69    : N_SHARED_LIB(x) ? ((x).a_entry & ~(TARGET_PAGE_SIZE - 1))                      \
  70    : TEXT_START_ADDR)
  71
  72 #define N_SYMOFF(x) \
  73   (N_TXTOFF (x) + (x).a_text + (x).a_data + (x).a_trsize + (x).a_drsize)
  74
  75 #define N_STROFF(x) (N_SYMOFF (x) + (x).a_syms)
  76
  77 #define TEXT_START_ADDR 32768
  78 #define TARGET_PAGE_SIZE 32768
  79 #define SEGMENT_SIZE TARGET_PAGE_SIZE
  80 #define DEFAULT_ARCH bfd_arch_arm
  81
  82 #define MY(OP) CAT(riscix_,OP)
  83 #define TARGETNAME "a.out-riscix"
  84 #define N_BADMAG(x) ((((x).a_info & ~007200) != ZMAGIC) && \
  85                      (((x).a_info & ~006000) != OMAGIC) && \
  86                      ((x).a_info != NMAGIC))
  87 #define N_MAGIC(x) ((x).a_info & ~07200)
  88
  89 #include "bfd.h"
  90 #include "sysdep.h"
  91 #include "libbfd.h"
  92
  93 #define WRITE_HEADERS(abfd, execp)                                         \
  94   {                                                                        \
  95     bfd_size_type text_size; /* dummy vars */                              \
  96     file_ptr text_end;                                                     \
  97     if (adata(abfd).magic == undecided_magic)                              \
  98       NAME(aout,adjust_sizes_and_vmas) (abfd, &text_size, &text_end);      \
  99                                                                            \
 100     execp->a_syms = bfd_get_symcount (abfd) * EXTERNAL_NLIST_SIZE;         \
 101     execp->a_entry = bfd_get_start_address (abfd);                         \
 102                                                                            \
 103     execp->a_trsize = ((obj_textsec (abfd)->reloc_count) *                 \
 104                        obj_reloc_entry_size (abfd));                       \
 105     execp->a_drsize = ((obj_datasec (abfd)->reloc_count) *                 \
 106                        obj_reloc_entry_size (abfd));                       \
 107     NAME(aout,swap_exec_header_out) (abfd, execp, &exec_bytes);            \
 108                                                                            \
 109     if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) return false;        \
 110     if (bfd_write ((PTR) &exec_bytes, 1, EXEC_BYTES_SIZE, abfd)            \
 111         != EXEC_BYTES_SIZE)                                                \
 112       return false;                                                        \
 113     /* Now write out reloc info, followed by syms and strings */           \
 114                                                                            \
 115     if (bfd_get_outsymbols (abfd) != (asymbol **) NULL                     \
 116         && bfd_get_symcount (abfd) != 0)                                   \
 117       {                                                                    \
 118         if (bfd_seek (abfd, (file_ptr)(N_SYMOFF(*execp)), SEEK_SET) != 0)  \
 119           return false;                                                    \
 120                                                                            \
 121         if (! NAME(aout,write_syms)(abfd)) return false;                   \
 122                                                                            \
 123         if (bfd_seek (abfd, (file_ptr)(N_TRELOFF(*execp)), SEEK_SET) != 0) \
 124           return false;                                                    \
 125                                                                            \
 126         if (! riscix_squirt_out_relocs (abfd, obj_textsec (abfd)))         \
 127           return false;                                                    \
 128         if (bfd_seek (abfd, (file_ptr)(N_DRELOFF(*execp)), SEEK_SET) != 0) \
 129           return false;                                                    \
 130                                                                            \
 131         if (!NAME(aout,squirt_out_relocs)(abfd, obj_datasec (abfd)))       \
 132           return false;                                                    \
 133       }                                                                    \
 134   }
 135
 136 #include "libaout.h"
 137 #include "aout/aout64.h"
 138
 139 static bfd_reloc_status_type
 140 riscix_fix_pcrel_26_done PARAMS ((bfd *, arelent *, asymbol *, PTR,
 141                                   asection *, bfd *, char **));
 142
 143 static bfd_reloc_status_type
 144 riscix_fix_pcrel_26 PARAMS ((bfd *, arelent *, asymbol *, PTR,
 145                              asection *, bfd *, char **));
 146
 147 static reloc_howto_type riscix_std_reloc_howto[] = {
 148   /* type              rs size bsz  pcrel bitpos ovrf                     sf name     part_inpl readmask  setmask    pcdone */
 149   HOWTO( 0,              0,  0,   8,  false, 0, complain_overflow_bitfield,0,"8",        true, 0x000000ff,0x000000ff, false),
 150   HOWTO( 1,              0,  1,   16, false, 0, complain_overflow_bitfield,0,"16",        true, 0x0000ffff,0x0000ffff, false),
 151   HOWTO( 2,              0,  2,   32, false, 0, complain_overflow_bitfield,0,"32",        true, 0xffffffff,0xffffffff, false),
 152   HOWTO( 3,              2,  3,   26, true, 0, complain_overflow_signed,  riscix_fix_pcrel_26 , "ARM26",      true, 0x00ffffff,0x00ffffff, false),
 153   HOWTO( 4,              0,  0,   8,  true,  0, complain_overflow_signed,  0,"DISP8",     true, 0x000000ff,0x000000ff, true),
 154   HOWTO( 5,              0,  1,   16, true,  0, complain_overflow_signed,  0,"DISP16",    true, 0x0000ffff,0x0000ffff, true),
 155   HOWTO( 6,              0,  2,   32, true,  0, complain_overflow_signed,  0,"DISP32",    true, 0xffffffff,0xffffffff, true),
 156   HOWTO( 7,              2,  3,   26, false, 0, complain_overflow_signed,  riscix_fix_pcrel_26_done, "ARM26D",true,0x00ffffff,0x00ffffff, false),
 157   EMPTY_HOWTO (-1),
 158   HOWTO( 9,              0, -1,   16, false, 0, complain_overflow_bitfield,0,"NEG16",        true, 0x0000ffff,0x0000ffff, false),
 159   HOWTO( 10,              0, -2,   32, false, 0, complain_overflow_bitfield,0,"NEG32",        true, 0xffffffff,0xffffffff, false)
 160 };
 161
 162 #define RISCIX_TABLE_SIZE \
 163   (sizeof (riscix_std_reloc_howto) / sizeof (reloc_howto_type))
 164
 165
 166 static bfd_reloc_status_type
 167 riscix_fix_pcrel_26_done (abfd, reloc_entry, symbol, data, input_section,
 168                           output_bfd, error_message)
 169      bfd *abfd ATTRIBUTE_UNUSED;
 170      arelent *reloc_entry ATTRIBUTE_UNUSED;
 171      asymbol *symbol ATTRIBUTE_UNUSED;
 172      PTR data ATTRIBUTE_UNUSED;
 173      asection *input_section ATTRIBUTE_UNUSED;
 174      bfd *output_bfd ATTRIBUTE_UNUSED;
 175      char **error_message ATTRIBUTE_UNUSED;
 176 {
 177   /* This is dead simple at present.  */
 178   return bfd_reloc_ok;
 179 }
 180
 181 static bfd_reloc_status_type
 182 riscix_fix_pcrel_26 (abfd, reloc_entry, symbol, data, input_section,
 183                      output_bfd, error_message)
 184      bfd *abfd;
 185      arelent *reloc_entry;
 186      asymbol *symbol;
 187      PTR data;
 188      asection *input_section;
 189      bfd *output_bfd;
 190      char **error_message ATTRIBUTE_UNUSED;
 191 {
 192   bfd_vma relocation;
 193   bfd_size_type addr = reloc_entry->address;
 194   long target = bfd_get_32 (abfd, (bfd_byte *) data + addr);
 195   bfd_reloc_status_type flag = bfd_reloc_ok;
 196
 197   /* If this is an undefined symbol, return error */
 198   if (symbol->section == &bfd_und_section
 199       && (symbol->flags & BSF_WEAK) == 0)
 200     return output_bfd ? bfd_reloc_continue : bfd_reloc_undefined;
 201
 202   /* If the sections are different, and we are doing a partial relocation,
 203      just ignore it for now.  */
 204   if (symbol->section->name != input_section->name
 205       && output_bfd != (bfd *)NULL)
 206     return bfd_reloc_continue;
 207
 208   relocation = (target & 0x00ffffff) << 2;
 209   relocation = (relocation ^ 0x02000000) - 0x02000000; /* Sign extend */
 210   relocation += symbol->value;
 211   relocation += symbol->section->output_section->vma;
 212   relocation += symbol->section->output_offset;
 213   relocation += reloc_entry->addend;
 214   relocation -= input_section->output_section->vma;
 215   relocation -= input_section->output_offset;
 216   relocation -= addr;
 217   if (relocation & 3)
 218     return bfd_reloc_overflow;
 219
 220   /* Check for overflow */
 221   if (relocation & 0x02000000)
 222     {
 223       if ((relocation & ~ (bfd_vma) 0x03ffffff) != ~ (bfd_vma) 0x03ffffff)
 224         flag = bfd_reloc_overflow;
 225     }
 226   else if (relocation & ~0x03ffffff)
 227     flag = bfd_reloc_overflow;
 228
 229   target &= ~0x00ffffff;
 230   target |= (relocation >> 2) & 0x00ffffff;
 231   bfd_put_32 (abfd, target, (bfd_byte *) data + addr);
 232
 233   /* Now the ARM magic... Change the reloc type so that it is marked as done.
 234      Strictly this is only necessary if we are doing a partial relocation.  */
 235   reloc_entry->howto = &riscix_std_reloc_howto[7];
 236
 237   return flag;
 238 }
 239
 240 reloc_howto_type *
 241 DEFUN(riscix_reloc_type_lookup,(abfd,code),
 242       bfd *abfd AND
 243       bfd_reloc_code_real_type code)
 244 {
 245 #define ASTD(i,j)       case i: return &riscix_std_reloc_howto[j]
 246   if (code == BFD_RELOC_CTOR)
 247     switch (bfd_get_arch_info (abfd)->bits_per_address)
 248       {
 249       case 32:
 250         code = BFD_RELOC_32;
 251         break;
 252       default: return (reloc_howto_type *) NULL;
 253       }
 254
 255   switch (code)
 256     {
 257       ASTD (BFD_RELOC_16, 1);
 258       ASTD (BFD_RELOC_32, 2);
 259       ASTD (BFD_RELOC_ARM_PCREL_BRANCH, 3);
 260       ASTD (BFD_RELOC_8_PCREL, 4);
 261       ASTD (BFD_RELOC_16_PCREL, 5);
 262       ASTD (BFD_RELOC_32_PCREL, 6);
 263     default: return (reloc_howto_type *) NULL;
 264     }
 265 }
 266
 267 #define MY_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
 268 #define MY_bfd_link_add_symbols _bfd_generic_link_add_symbols
 269 #define MY_final_link_callback should_not_be_used
 270 #define MY_bfd_final_link _bfd_generic_final_link
 271
 272 #define MY_bfd_reloc_type_lookup riscix_reloc_type_lookup
 273 #define MY_canonicalize_reloc riscix_canonicalize_reloc
 274 #define MY_object_p riscix_object_p
 275
 276 static const bfd_target *riscix_callback PARAMS ((bfd *));
 277
 278 void
 279 riscix_swap_std_reloc_out (abfd, g, natptr)
 280      bfd *abfd;
 281      arelent *g;
 282      struct reloc_std_external *natptr;
 283 {
 284   int r_index;
 285   asymbol *sym = *(g->sym_ptr_ptr);
 286   int r_extern;
 287   int r_length;
 288   int r_pcrel;
 289   int r_neg = 0;        /* Negative relocs use the BASEREL bit.  */
 290   asection *output_section = sym->section->output_section;
 291
 292   PUT_WORD(abfd, g->address, natptr->r_address);
 293
 294   r_length = g->howto->size ;   /* Size as a power of two */
 295   if (r_length < 0)
 296     {
 297       r_length = -r_length;
 298       r_neg = 1;
 299     }
 300
 301   r_pcrel  = (int) g->howto->pc_relative; /* Relative to PC? */
 302
 303   /* For RISC iX, in pc-relative relocs the r_pcrel bit means that the
 304      relocation has been done already (Only for the 26-bit one I think)???!!!
 305      */
 306
 307   if (r_length == 3)
 308     r_pcrel = r_pcrel ? 0 : 1;
 309
 310
 311 #if 0
 312   /* For a standard reloc, the addend is in the object file.  */
 313   r_addend = g->addend + (*(g->sym_ptr_ptr))->section->output_section->vma;
 314 #endif
 315
 316   /* name was clobbered by aout_write_syms to be symbol index */
 317
 318   /* If this relocation is relative to a symbol then set the
 319      r_index to the symbols index, and the r_extern bit.
 320
 321      Absolute symbols can come in in two ways, either as an offset
 322      from the abs section, or as a symbol which has an abs value.
 323      check for that here
 324      */
 325
 326   if (bfd_is_com_section (output_section)
 327       || output_section == &bfd_abs_section
 328       || output_section == &bfd_und_section)
 329     {
 330       if (bfd_abs_section.symbol == sym)
 331         {
 332           /* Whoops, looked like an abs symbol, but is really an offset
 333              from the abs section */
 334           r_index = 0;
 335           r_extern = 0;
 336         }
 337       else
 338         {
 339           /* Fill in symbol */
 340           r_extern = 1;
 341           r_index = (*g->sym_ptr_ptr)->udata.i;
 342         }
 343     }
 344   else
 345     {
 346       /* Just an ordinary section */
 347       r_extern = 0;
 348       r_index  = output_section->target_index;
 349     }
 350
 351   /* now the fun stuff */
 352   if (bfd_header_big_endian (abfd))
 353     {
 354       natptr->r_index[0] = r_index >> 16;
 355       natptr->r_index[1] = r_index >> 8;
 356       natptr->r_index[2] = r_index;
 357       natptr->r_type[0] =
 358         (  (r_extern ?   RELOC_STD_BITS_EXTERN_BIG: 0)
 359          | (r_pcrel  ?   RELOC_STD_BITS_PCREL_BIG: 0)
 360          | (r_neg    ?   RELOC_STD_BITS_BASEREL_BIG: 0)
 361          | (r_length <<  RELOC_STD_BITS_LENGTH_SH_BIG));
 362     }
 363   else
 364     {
 365       natptr->r_index[2] = r_index >> 16;
 366       natptr->r_index[1] = r_index >> 8;
 367       natptr->r_index[0] = r_index;
 368       natptr->r_type[0] =
 369         (  (r_extern ?   RELOC_STD_BITS_EXTERN_LITTLE: 0)
 370          | (r_pcrel  ?   RELOC_STD_BITS_PCREL_LITTLE: 0)
 371          | (r_neg    ?   RELOC_STD_BITS_BASEREL_LITTLE: 0)
 372          | (r_length <<  RELOC_STD_BITS_LENGTH_SH_LITTLE));
 373     }
 374 }
 375
 376 boolean
 377 riscix_squirt_out_relocs (abfd, section)
 378      bfd *abfd;
 379      asection *section;
 380 {
 381   arelent **generic;
 382   unsigned char *native, *natptr;
 383   size_t each_size;
 384
 385   unsigned int count = section->reloc_count;
 386   size_t natsize;
 387
 388   if (count == 0) return true;
 389
 390   each_size = obj_reloc_entry_size (abfd);
 391   natsize = each_size * count;
 392   native = (unsigned char *) bfd_zalloc (abfd, natsize);
 393   if (!native)
 394     return false;
 395
 396   generic = section->orelocation;
 397
 398   for (natptr = native;
 399        count != 0;
 400        --count, natptr += each_size, ++generic)
 401     riscix_swap_std_reloc_out (abfd, *generic,
 402                                (struct reloc_std_external *) natptr);
 403
 404   if ( bfd_write ((PTR) native, 1, natsize, abfd) != natsize)
 405     {
 406       bfd_release(abfd, native);
 407       return false;
 408     }
 409
 410   bfd_release (abfd, native);
 411   return true;
 412 }
 413
 414
 415 /*
 416  * This is just like the standard aoutx.h version but we need to do our
 417  * own mapping of external reloc type values to howto entries.
 418  */
 419 long
 420 MY(canonicalize_reloc)(abfd, section, relptr, symbols)
 421       bfd *abfd;
 422       sec_ptr section;
 423       arelent **relptr;
 424       asymbol **symbols;
 425 {
 426   arelent *tblptr = section->relocation;
 427   unsigned int count, c;
 428   extern reloc_howto_type NAME(aout,std_howto_table)[];
 429
 430   /* If we have already read in the relocation table, return the values. */
 431   if (section->flags & SEC_CONSTRUCTOR) {
 432     arelent_chain *chain = section->constructor_chain;
 433
 434     for (count = 0; count < section->reloc_count; count++) {
 435       *relptr++ = &chain->relent;
 436       chain = chain->next;
 437     }
 438     *relptr = 0;
 439     return section->reloc_count;
 440   }
 441   if (tblptr && section->reloc_count) {
 442     for (count = 0; count++ < section->reloc_count;)
 443       *relptr++ = tblptr++;
 444     *relptr = 0;
 445     return section->reloc_count;
 446   }
 447
 448   if (!NAME(aout,slurp_reloc_table)(abfd, section, symbols))
 449     return -1;
 450   tblptr = section->relocation;
 451
 452   /* fix up howto entries */
 453   for (count = 0; count++ < section->reloc_count;)
 454     {
 455       c = tblptr->howto - NAME(aout,std_howto_table);
 456       BFD_ASSERT (c < RISCIX_TABLE_SIZE);
 457       tblptr->howto = &riscix_std_reloc_howto[c];
 458
 459       *relptr++ = tblptr++;
 460     }
 461   *relptr = 0;
 462   return section->reloc_count;
 463 }
 464
 465 /* This is the same as NAME(aout,some_aout_object_p), but has different
 466    expansions of the macro definitions.  */
 467
 468 const bfd_target *
 469 riscix_some_aout_object_p (abfd, execp, callback_to_real_object_p)
 470      bfd *abfd;
 471      struct internal_exec *execp;
 472      const bfd_target *(*callback_to_real_object_p) PARAMS ((bfd *));
 473 {
 474   struct aout_data_struct *rawptr, *oldrawptr;
 475   const bfd_target *result;
 476
 477   rawptr = ((struct aout_data_struct  *)
 478             bfd_zalloc (abfd, sizeof (struct aout_data_struct )));
 479
 480   if (rawptr == NULL)
 481     return 0;
 482
 483   oldrawptr = abfd->tdata.aout_data;
 484   abfd->tdata.aout_data = rawptr;
 485
 486   /* Copy the contents of the old tdata struct.
 487      In particular, we want the subformat, since for hpux it was set in
 488      hp300hpux.c:swap_exec_header_in and will be used in
 489      hp300hpux.c:callback.  */
 490   if (oldrawptr != NULL)
 491     *abfd->tdata.aout_data = *oldrawptr;
 492
 493   abfd->tdata.aout_data->a.hdr = &rawptr->e;
 494   *(abfd->tdata.aout_data->a.hdr) = *execp;     /* Copy in the internal_exec
 495                                                    struct */
 496   execp = abfd->tdata.aout_data->a.hdr;
 497
 498   /* Set the file flags */
 499   abfd->flags = BFD_NO_FLAGS;
 500   if (execp->a_drsize || execp->a_trsize)
 501     abfd->flags |= HAS_RELOC;
 502   /* Setting of EXEC_P has been deferred to the bottom of this function */
 503   if (execp->a_syms)
 504     abfd->flags |= HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS;
 505   if (N_DYNAMIC(*execp))
 506     abfd->flags |= DYNAMIC;
 507
 508
 509   if ((execp->a_info & MF_SQUEEZED) != 0) /* Squeezed files aren't supported
 510                                              (yet)! */
 511     {
 512       bfd_set_error (bfd_error_wrong_format);
 513       return NULL;
 514     }
 515   else if ((execp->a_info & MF_IS_SL) != 0)     /* Nor are shared libraries */
 516     {
 517       bfd_set_error (bfd_error_wrong_format);
 518       return NULL;
 519     }
 520   else if (N_MAGIC (*execp) == ZMAGIC)
 521     {
 522       abfd->flags |= D_PAGED | WP_TEXT;
 523       adata (abfd).magic = z_magic;
 524     }
 525   else if (N_MAGIC (*execp) == NMAGIC)
 526     {
 527       abfd->flags |= WP_TEXT;
 528       adata (abfd).magic = n_magic;
 529     }
 530   else if (N_MAGIC (*execp) == OMAGIC)
 531     adata (abfd).magic = o_magic;
 532   else
 533     {
 534       /* Should have been checked with N_BADMAG before this routine
 535          was called.  */
 536       abort ();
 537     }
 538
 539   bfd_get_start_address (abfd) = execp->a_entry;
 540
 541   obj_aout_symbols (abfd) = (aout_symbol_type *)NULL;
 542   bfd_get_symcount (abfd) = execp->a_syms / sizeof (struct external_nlist);
 543
 544   /* The default relocation entry size is that of traditional V7 Unix.  */
 545   obj_reloc_entry_size (abfd) = RELOC_STD_SIZE;
 546
 547   /* The default symbol entry size is that of traditional Unix. */
 548   obj_symbol_entry_size (abfd) = EXTERNAL_NLIST_SIZE;
 549
 550   obj_aout_external_syms (abfd) = NULL;
 551   obj_aout_external_strings (abfd) = NULL;
 552   obj_aout_sym_hashes (abfd) = NULL;
 553
 554   if (! NAME(aout,make_sections) (abfd))
 555     return NULL;
 556
 557   obj_datasec (abfd)->_raw_size = execp->a_data;
 558   obj_bsssec (abfd)->_raw_size = execp->a_bss;
 559
 560   obj_textsec (abfd)->flags =
 561     (execp->a_trsize != 0
 562      ? (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS | SEC_RELOC)
 563      : (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS));
 564   obj_datasec (abfd)->flags =
 565     (execp->a_drsize != 0
 566      ? (SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_HAS_CONTENTS | SEC_RELOC)
 567      : (SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_HAS_CONTENTS));
 568   obj_bsssec (abfd)->flags = SEC_ALLOC;
 569
 570   result = (*callback_to_real_object_p)(abfd);
 571
 572 #if defined(MACH) || defined(STAT_FOR_EXEC)
 573   /* The original heuristic doesn't work in some important cases. The
 574    * a.out file has no information about the text start address. For
 575    * files (like kernels) linked to non-standard addresses (ld -Ttext
 576    * nnn) the entry point may not be between the default text start
 577    * (obj_textsec(abfd)->vma) and (obj_textsec(abfd)->vma) + text size
 578    * This is not just a mach issue. Many kernels are loaded at non
 579    * standard addresses.
 580    */
 581   {
 582     struct stat stat_buf;
 583     if (abfd->iostream != NULL
 584         && (abfd->flags & BFD_IN_MEMORY) == 0
 585         && (fstat(fileno((FILE *) (abfd->iostream)), &stat_buf) == 0)
 586         && ((stat_buf.st_mode & 0111) != 0))
 587       abfd->flags |= EXEC_P;
 588   }
 589 #else /* ! MACH */
 590   /* Now that the segment addresses have been worked out, take a better
 591      guess at whether the file is executable.  If the entry point
 592      is within the text segment, assume it is.  (This makes files
 593      executable even if their entry point address is 0, as long as
 594      their text starts at zero.)
 595
 596      At some point we should probably break down and stat the file and
 597      declare it executable if (one of) its 'x' bits are on...  */
 598   if ((execp->a_entry >= obj_textsec(abfd)->vma) &&
 599       (execp->a_entry < obj_textsec(abfd)->vma + obj_textsec(abfd)->_raw_size))
 600     abfd->flags |= EXEC_P;
 601 #endif /* MACH */
 602   if (result)
 603     {
 604     }
 605   else
 606     {
 607       free (rawptr);
 608       abfd->tdata.aout_data = oldrawptr;
 609     }
 610   return result;
 611 }
 612
 613
 614 static const bfd_target *
 615 MY(object_p) (abfd)
 616      bfd *abfd;
 617 {
 618   struct external_exec exec_bytes;      /* Raw exec header from file */
 619   struct internal_exec exec;            /* Cleaned-up exec header */
 620   const bfd_target *target;
 621
 622   if (bfd_read ((PTR) &exec_bytes, 1, EXEC_BYTES_SIZE, abfd)
 623       != EXEC_BYTES_SIZE) {
 624     if (bfd_get_error () != bfd_error_system_call)
 625       bfd_set_error (bfd_error_wrong_format);
 626     return 0;
 627   }
 628
 629   exec.a_info = bfd_h_get_32 (abfd, exec_bytes.e_info);
 630
 631   if (N_BADMAG (exec)) return 0;
 632 #ifdef MACHTYPE_OK
 633   if (!(MACHTYPE_OK (N_MACHTYPE (exec)))) return 0;
 634 #endif
 635
 636   NAME(aout,swap_exec_header_in)(abfd, &exec_bytes, &exec);
 637
 638   target = riscix_some_aout_object_p (abfd, &exec, MY(callback));
 639
 640   return target;
 641 }
 642
 643
 644 #include "aout-target.h"