home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / gdb-4.16-base.tgz / gdb-4.16-base.tar / fsf / gdb / bfd / riscix.c < prev    next >
C/C++ Source or Header  |  1996-01-09  |  22KB  |  645 lines
  1. /* BFD back-end for RISC iX (Acorn, arm) binaries.
  2.    Copyright (C) 1994, 1995, 1996 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. #include "assert.h"
  93.  
  94. #define WRITE_HEADERS(abfd, execp)                       \
  95.   {                                       \
  96.     bfd_size_type text_size; /* dummy vars */                   \
  97.     file_ptr text_end;                               \
  98.     if (adata(abfd).magic == undecided_magic)                   \
  99.       NAME(aout,adjust_sizes_and_vmas) (abfd, &text_size, &text_end);       \
  100.                                            \
  101.     execp->a_syms = bfd_get_symcount (abfd) * EXTERNAL_NLIST_SIZE;       \
  102.     execp->a_entry = bfd_get_start_address (abfd);               \
  103.                                            \
  104.     execp->a_trsize = ((obj_textsec (abfd)->reloc_count) *           \
  105.                obj_reloc_entry_size (abfd));               \
  106.     execp->a_drsize = ((obj_datasec (abfd)->reloc_count) *           \
  107.                obj_reloc_entry_size (abfd));               \
  108.     NAME(aout,swap_exec_header_out) (abfd, execp, &exec_bytes);           \
  109.                                            \
  110.     if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) return false;       \
  111.     if (bfd_write ((PTR) &exec_bytes, 1, EXEC_BYTES_SIZE, abfd)           \
  112.     != EXEC_BYTES_SIZE)                           \
  113.       return false;                               \
  114.     /* Now write out reloc info, followed by syms and strings */       \
  115.                                        \
  116.     if (bfd_get_outsymbols (abfd) != (asymbol **) NULL               \
  117.     && bfd_get_symcount (abfd) != 0)                   \
  118.       {                                       \
  119.     if (bfd_seek (abfd, (file_ptr)(N_SYMOFF(*execp)), SEEK_SET) != 0)  \
  120.       return false;                               \
  121.                                        \
  122.     if (! NAME(aout,write_syms)(abfd)) return false;           \
  123.                                        \
  124.     if (bfd_seek (abfd, (file_ptr)(N_TRELOFF(*execp)), SEEK_SET) != 0) \
  125.       return false;                               \
  126.                                        \
  127.     if (! riscix_squirt_out_relocs (abfd, obj_textsec (abfd)))       \
  128.       return false;                               \
  129.     if (bfd_seek (abfd, (file_ptr)(N_DRELOFF(*execp)), SEEK_SET) != 0) \
  130.       return false;                               \
  131.                                        \
  132.     if (!NAME(aout,squirt_out_relocs)(abfd, obj_datasec (abfd)))       \
  133.       return false;                               \
  134.       }                                       \
  135.   }
  136.  
  137. #include "libaout.h"
  138. #include "aout/aout64.h"
  139.  
  140. static bfd_reloc_status_type
  141. riscix_fix_pcrel_26_done PARAMS ((bfd *, arelent *, asymbol *, PTR,
  142.                   asection *, bfd *, char **));
  143.  
  144. static bfd_reloc_status_type
  145. riscix_fix_pcrel_26 PARAMS ((bfd *, arelent *, asymbol *, PTR,
  146.                  asection *, bfd *, char **));
  147.  
  148. static reloc_howto_type riscix_std_reloc_howto[] = {
  149.   /* type              rs size bsz  pcrel bitpos ovrf                     sf name     part_inpl readmask  setmask    pcdone */
  150.   HOWTO( 0,              0,  0,   8,  false, 0, complain_overflow_bitfield,0,"8",        true, 0x000000ff,0x000000ff, false),
  151.   HOWTO( 1,              0,  1,   16, false, 0, complain_overflow_bitfield,0,"16",        true, 0x0000ffff,0x0000ffff, false),
  152.   HOWTO( 2,              0,  2,   32, false, 0, complain_overflow_bitfield,0,"32",        true, 0xffffffff,0xffffffff, false),
  153.   HOWTO( 3,              2,  3,   26, true, 0, complain_overflow_signed,  riscix_fix_pcrel_26 , "ARM26",      true, 0x00ffffff,0x00ffffff, false),
  154.   HOWTO( 4,              0,  0,   8,  true,  0, complain_overflow_signed,  0,"DISP8",     true, 0x000000ff,0x000000ff, true),
  155.   HOWTO( 5,              0,  1,   16, true,  0, complain_overflow_signed,  0,"DISP16",    true, 0x0000ffff,0x0000ffff, true),
  156.   HOWTO( 6,              0,  2,   32, true,  0, complain_overflow_signed,  0,"DISP32",    true, 0xffffffff,0xffffffff, true),
  157.   HOWTO( 7,              2,  3,   26, false, 0, complain_overflow_signed,  riscix_fix_pcrel_26_done, "ARM26D",true,0x00ffffff,0x00ffffff, false),
  158.   {-1},
  159.   HOWTO( 9,              0, -1,   16, false, 0, complain_overflow_bitfield,0,"NEG16",        true, 0x0000ffff,0x0000ffff, false),
  160.   HOWTO( 10,              0, -2,   32, false, 0, complain_overflow_bitfield,0,"NEG32",        true, 0xffffffff,0xffffffff, false)
  161. };
  162.  
  163. #define RISCIX_TABLE_SIZE \
  164.   (sizeof (riscix_std_reloc_howto) / sizeof (reloc_howto_type))
  165.  
  166.  
  167. static bfd_reloc_status_type
  168. riscix_fix_pcrel_26_done (abfd, reloc_entry, symbol, data, input_section,
  169.               output_bfd, error_message)
  170.      bfd *abfd;
  171.      arelent *reloc_entry;
  172.      asymbol *symbol;
  173.      PTR data;
  174.      asection *input_section;
  175.      bfd *output_bfd;
  176.      char **error_message;
  177. {
  178.   /* This is dead simple at present.  */
  179.   return bfd_reloc_ok;
  180. }
  181.  
  182. static bfd_reloc_status_type
  183. riscix_fix_pcrel_26 (abfd, reloc_entry, symbol, data, input_section,
  184.              output_bfd, error_message)
  185.      bfd *abfd;
  186.      arelent *reloc_entry;
  187.      asymbol *symbol;
  188.      PTR data;
  189.      asection *input_section;
  190.      bfd *output_bfd;
  191.      char **error_message;
  192. {
  193.   bfd_vma relocation;
  194.   bfd_size_type addr = reloc_entry->address;
  195.   long target = bfd_get_32 (abfd, (bfd_byte *) data + addr);
  196.   bfd_reloc_status_type flag = bfd_reloc_ok;
  197.   
  198.   /* If this is an undefined symbol, return error */
  199.   if (symbol->section == &bfd_und_section
  200.       && (symbol->flags & BSF_WEAK) == 0)
  201.     return output_bfd ? bfd_reloc_continue : bfd_reloc_undefined;
  202.  
  203.   /* If the sections are different, and we are doing a partial relocation,
  204.      just ignore it for now.  */
  205.   if (symbol->section->name != input_section->name
  206.       && output_bfd != (bfd *)NULL)
  207.     return bfd_reloc_continue;
  208.  
  209.   relocation = (target & 0x00ffffff) << 2;
  210.   relocation = (relocation ^ 0x02000000) - 0x02000000; /* Sign extend */
  211.   relocation += symbol->value;
  212.   relocation += symbol->section->output_section->vma;
  213.   relocation += symbol->section->output_offset;
  214.   relocation += reloc_entry->addend;
  215.   relocation -= input_section->output_section->vma;
  216.   relocation -= input_section->output_offset;
  217.   relocation -= addr;
  218.   if (relocation & 3)
  219.     return bfd_reloc_overflow;
  220.  
  221.   /* Check for overflow */
  222.   if (relocation & 0x02000000)
  223.     {
  224.       if ((relocation & ~0x03ffffff) != ~0x03ffffff)
  225.     flag = bfd_reloc_overflow;
  226.     }
  227.   else if (relocation & ~0x03ffffff)
  228.     flag = bfd_reloc_overflow;
  229.  
  230.   target &= ~0x00ffffff;
  231.   target |= (relocation >> 2) & 0x00ffffff;
  232.   bfd_put_32 (abfd, target, (bfd_byte *) data + addr);
  233.  
  234.   /* Now the ARM magic... Change the reloc type so that it is marked as done.
  235.      Strictly this is only necessary if we are doing a partial relocation.  */
  236.   reloc_entry->howto = &riscix_std_reloc_howto[7];
  237.   
  238.   return flag;
  239. }
  240.  
  241. reloc_howto_type *
  242. DEFUN(riscix_reloc_type_lookup,(abfd,code),
  243.       bfd *abfd AND
  244.       bfd_reloc_code_real_type code)
  245. {
  246. #define ASTD(i,j)       case i: return &riscix_std_reloc_howto[j]
  247.   if (code == BFD_RELOC_CTOR)
  248.     switch (bfd_get_arch_info (abfd)->bits_per_address)
  249.       {
  250.       case 32:
  251.         code = BFD_RELOC_32;
  252.         break;
  253.       default: return (reloc_howto_type *) NULL;
  254.       }
  255.  
  256.   switch (code)
  257.     {
  258.       ASTD (BFD_RELOC_16, 1);
  259.       ASTD (BFD_RELOC_32, 2);
  260.       ASTD (BFD_RELOC_ARM_PCREL_BRANCH, 3);
  261.       ASTD (BFD_RELOC_8_PCREL, 4);
  262.       ASTD (BFD_RELOC_16_PCREL, 5);
  263.       ASTD (BFD_RELOC_32_PCREL, 6);
  264.     default: return (reloc_howto_type *) NULL;
  265.     }
  266. }
  267.  
  268. #define MY_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
  269. #define MY_bfd_link_add_symbols _bfd_generic_link_add_symbols
  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 =  stoi((*(g->sym_ptr_ptr))->flags);
  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.       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 = 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"
  645.