Ignore:
Timestamp:
Aug 16, 2003, 6:59:22 PM (22 years ago)
Author:
bird
Message:

binutils v2.14 - offical sources.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • branches/GNU/src/binutils/bfd/coff64-rs6000.c

    • Property cvs2svn:cvs-rev changed from 1.1 to 1.1.1.2
    r608 r609  
    11/* BFD back-end for IBM RS/6000 "XCOFF64" files.
    2    Copyright 2000, 2001
     2   Copyright 2000, 2001, 2002
    33   Free Software Foundation, Inc.
    44   Written Clinton Popetz.
    55   Contributed by Cygnus Support.
    66
    7 This file is part of BFD, the Binary File Descriptor library.
    8 
    9 This program is free software; you can redistribute it and/or modify
    10 it under the terms of the GNU General Public License as published by
    11 the Free Software Foundation; either version 2 of the License, or
    12 (at your option) any later version.
    13 
    14 This program is distributed in the hope that it will be useful,
    15 but WITHOUT ANY WARRANTY; without even the implied warranty of
    16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    17 GNU General Public License for more details.
    18 
    19 You should have received a copy of the GNU General Public License
    20 along with this program; if not, write to the Free Software
    21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
    22 
     7   This file is part of BFD, the Binary File Descriptor library.
     8
     9   This program is free software; you can redistribute it and/or modify
     10   it under the terms of the GNU General Public License as published by
     11   the Free Software Foundation; either version 2 of the License, or
     12   (at your option) any later version.
     13
     14   This program is distributed in the hope that it will be useful,
     15   but WITHOUT ANY WARRANTY; without even the implied warranty of
     16   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     17   GNU General Public License for more details.
     18
     19   You should have received a copy of the GNU General Public License
     20   along with this program; if not, write to the Free Software
     21   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
     22
     23#include "bfd.h"
     24#include "sysdep.h"
     25#include "bfdlink.h"
     26#include "libbfd.h"
     27#include "coff/internal.h"
     28#include "coff/xcoff.h"
     29#include "coff/rs6k64.h"
     30#include "libcoff.h"
     31#include "libxcoff.h"
     32
     33#define GET_FILEHDR_SYMPTR H_GET_64
     34#define PUT_FILEHDR_SYMPTR H_PUT_64
     35#define GET_AOUTHDR_DATA_START H_GET_64
     36#define PUT_AOUTHDR_DATA_START H_PUT_64
     37#define GET_AOUTHDR_TEXT_START H_GET_64
     38#define PUT_AOUTHDR_TEXT_START H_PUT_64
     39#define GET_AOUTHDR_TSIZE H_GET_64
     40#define PUT_AOUTHDR_TSIZE H_PUT_64
     41#define GET_AOUTHDR_DSIZE H_GET_64
     42#define PUT_AOUTHDR_DSIZE H_PUT_64
     43#define GET_AOUTHDR_BSIZE H_GET_64
     44#define PUT_AOUTHDR_BSIZE H_PUT_64
     45#define GET_AOUTHDR_ENTRY H_GET_64
     46#define PUT_AOUTHDR_ENTRY H_PUT_64
     47#define GET_SCNHDR_PADDR H_GET_64
     48#define PUT_SCNHDR_PADDR H_PUT_64
     49#define GET_SCNHDR_VADDR H_GET_64
     50#define PUT_SCNHDR_VADDR H_PUT_64
     51#define GET_SCNHDR_SIZE H_GET_64
     52#define PUT_SCNHDR_SIZE H_PUT_64
     53#define GET_SCNHDR_SCNPTR H_GET_64
     54#define PUT_SCNHDR_SCNPTR H_PUT_64
     55#define GET_SCNHDR_RELPTR H_GET_64
     56#define PUT_SCNHDR_RELPTR H_PUT_64
     57#define GET_SCNHDR_LNNOPTR H_GET_64
     58#define PUT_SCNHDR_LNNOPTR H_PUT_64
     59#define GET_SCNHDR_NRELOC H_GET_32
     60#define MAX_SCNHDR_NRELOC 0xffffffff
     61#define PUT_SCNHDR_NRELOC H_PUT_32
     62#define GET_SCNHDR_NLNNO H_GET_32
     63#define MAX_SCNHDR_NLNNO 0xffffffff
     64#define PUT_SCNHDR_NLNNO H_PUT_32
     65#define GET_RELOC_VADDR H_GET_64
     66#define PUT_RELOC_VADDR H_PUT_64
     67
     68#define COFF_FORCE_SYMBOLS_IN_STRINGS
     69#define COFF_DEBUG_STRING_WIDE_PREFIX
     70
     71
     72#define COFF_ADJUST_SCNHDR_OUT_POST(ABFD, INT, EXT)                     \
     73  do                                                                    \
     74    {                                                                   \
     75      memset (((SCNHDR *) EXT)->s_pad, 0,                               \
     76              sizeof (((SCNHDR *) EXT)->s_pad));                        \
     77    }                                                                   \
     78  while (0)
     79
     80#define NO_COFF_LINENOS
     81
     82#define coff_SWAP_lineno_in _bfd_xcoff64_swap_lineno_in
     83#define coff_SWAP_lineno_out _bfd_xcoff64_swap_lineno_out
     84
     85static void _bfd_xcoff64_swap_lineno_in
     86  PARAMS ((bfd *, PTR, PTR));
     87static unsigned int _bfd_xcoff64_swap_lineno_out
     88  PARAMS ((bfd *, PTR, PTR));
     89static bfd_boolean _bfd_xcoff64_put_symbol_name
     90  PARAMS ((bfd *, struct bfd_strtab_hash *, struct internal_syment *,
     91           const char *));
     92static bfd_boolean _bfd_xcoff64_put_ldsymbol_name
     93  PARAMS ((bfd *, struct xcoff_loader_info *, struct internal_ldsym *,
     94           const char *));
     95static void _bfd_xcoff64_swap_sym_in
     96  PARAMS ((bfd *, PTR, PTR));
     97static unsigned int _bfd_xcoff64_swap_sym_out
     98  PARAMS ((bfd *, PTR, PTR));
     99static void _bfd_xcoff64_swap_aux_in
     100  PARAMS ((bfd *, PTR, int, int, int, int, PTR));
     101static unsigned int _bfd_xcoff64_swap_aux_out
     102  PARAMS ((bfd *, PTR, int, int, int, int, PTR));
     103static void xcoff64_swap_reloc_in
     104  PARAMS ((bfd *, PTR, PTR));
     105static unsigned int xcoff64_swap_reloc_out
     106  PARAMS ((bfd *, PTR, PTR));
     107extern bfd_boolean _bfd_xcoff_mkobject
     108  PARAMS ((bfd *));
     109extern bfd_boolean _bfd_xcoff_copy_private_bfd_data
     110  PARAMS ((bfd *, bfd *));
     111extern bfd_boolean _bfd_xcoff_is_local_label_name
     112  PARAMS ((bfd *, const char *));
     113extern void xcoff64_rtype2howto
     114  PARAMS ((arelent *, struct internal_reloc *));
     115extern reloc_howto_type * xcoff64_reloc_type_lookup
     116  PARAMS ((bfd *, bfd_reloc_code_real_type));
     117extern bfd_boolean _bfd_xcoff_slurp_armap
     118  PARAMS ((bfd *));
     119extern PTR _bfd_xcoff_read_ar_hdr
     120  PARAMS ((bfd *));
     121extern bfd *_bfd_xcoff_openr_next_archived_file
     122  PARAMS ((bfd *, bfd *));
     123extern int _bfd_xcoff_stat_arch_elt
     124  PARAMS ((bfd *, struct stat *));
     125extern bfd_boolean _bfd_xcoff_write_armap
     126  PARAMS ((bfd *, unsigned int, struct orl *, unsigned int, int));
     127extern bfd_boolean _bfd_xcoff_write_archive_contents
     128  PARAMS ((bfd *));
     129extern int _bfd_xcoff_sizeof_headers
     130  PARAMS ((bfd *, bfd_boolean));
     131extern void _bfd_xcoff_swap_sym_in
     132  PARAMS ((bfd *, PTR, PTR));
     133extern unsigned int _bfd_xcoff_swap_sym_out
     134  PARAMS ((bfd *, PTR, PTR));
     135extern void _bfd_xcoff_swap_aux_in
     136  PARAMS ((bfd *, PTR, int, int, int, int, PTR));
     137extern unsigned int _bfd_xcoff_swap_aux_out
     138  PARAMS ((bfd *, PTR, int, int, int, int, PTR));
     139static void xcoff64_swap_ldhdr_in
     140  PARAMS ((bfd *, const PTR, struct internal_ldhdr *));
     141static void xcoff64_swap_ldhdr_out
     142  PARAMS ((bfd *, const struct internal_ldhdr *, PTR d));
     143static void xcoff64_swap_ldsym_in
     144  PARAMS ((bfd *, const PTR, struct internal_ldsym *));
     145static void xcoff64_swap_ldsym_out
     146  PARAMS ((bfd *, const struct internal_ldsym *, PTR d));
     147static void xcoff64_swap_ldrel_in
     148  PARAMS ((bfd *, const PTR, struct internal_ldrel *));
     149static void xcoff64_swap_ldrel_out
     150  PARAMS ((bfd *, const struct internal_ldrel *, PTR d));
     151static bfd_boolean xcoff64_write_object_contents
     152  PARAMS ((bfd *));
     153static bfd_boolean xcoff64_ppc_relocate_section
     154  PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
     155           struct internal_reloc *, struct internal_syment *,
     156           asection **));
     157static bfd_boolean xcoff64_slurp_armap
     158  PARAMS ((bfd *));
     159static const bfd_target *xcoff64_archive_p
     160  PARAMS ((bfd *));
     161static bfd *xcoff64_openr_next_archived_file
     162  PARAMS ((bfd *, bfd *));
     163static int xcoff64_sizeof_headers
     164  PARAMS ((bfd *, bfd_boolean));
     165static asection *xcoff64_create_csect_from_smclas
     166  PARAMS ((bfd *, union internal_auxent *, const char *));
     167static bfd_boolean xcoff64_is_lineno_count_overflow
     168  PARAMS ((bfd *, bfd_vma));
     169static bfd_boolean xcoff64_is_reloc_count_overflow
     170  PARAMS ((bfd *, bfd_vma));
     171static bfd_vma xcoff64_loader_symbol_offset
     172  PARAMS ((bfd *, struct internal_ldhdr *));
     173static bfd_vma xcoff64_loader_reloc_offset
     174  PARAMS ((bfd *, struct internal_ldhdr *));
     175static bfd_boolean xcoff64_generate_rtinit
     176  PARAMS ((bfd *, const char *, const char *, bfd_boolean));
     177static bfd_boolean xcoff64_bad_format_hook
     178  PARAMS ((bfd *, PTR ));
     179
     180/* Relocation functions */
     181static bfd_boolean xcoff64_reloc_type_br
     182  PARAMS ((XCOFF_RELOC_FUNCTION_ARGS));
     183
     184bfd_boolean (*xcoff64_calculate_relocation[XCOFF_MAX_CALCULATE_RELOCATION])
     185  PARAMS ((XCOFF_RELOC_FUNCTION_ARGS)) =
     186{
     187  xcoff_reloc_type_pos,  /* R_POS   (0x00) */
     188  xcoff_reloc_type_neg,  /* R_NEG   (0x01) */
     189  xcoff_reloc_type_rel,  /* R_REL   (0x02) */
     190  xcoff_reloc_type_toc,  /* R_TOC   (0x03) */
     191  xcoff_reloc_type_fail, /* R_RTB   (0x04) */
     192  xcoff_reloc_type_toc,  /* R_GL    (0x05) */
     193  xcoff_reloc_type_toc,  /* R_TCL   (0x06) */
     194  xcoff_reloc_type_fail, /*         (0x07) */
     195  xcoff_reloc_type_ba,   /* R_BA    (0x08) */
     196  xcoff_reloc_type_fail, /*         (0x09) */
     197  xcoff64_reloc_type_br, /* R_BR    (0x0a) */
     198  xcoff_reloc_type_fail, /*         (0x0b) */
     199  xcoff_reloc_type_pos,  /* R_RL    (0x0c) */
     200  xcoff_reloc_type_pos,  /* R_RLA   (0x0d) */
     201  xcoff_reloc_type_fail, /*         (0x0e) */
     202  xcoff_reloc_type_noop, /* R_REF   (0x0f) */
     203  xcoff_reloc_type_fail, /*         (0x10) */
     204  xcoff_reloc_type_fail, /*         (0x11) */
     205  xcoff_reloc_type_toc,  /* R_TRL   (0x12) */
     206  xcoff_reloc_type_toc,  /* R_TRLA  (0x13) */
     207  xcoff_reloc_type_fail, /* R_RRTBI (0x14) */
     208  xcoff_reloc_type_fail, /* R_RRTBA (0x15) */
     209  xcoff_reloc_type_ba,   /* R_CAI   (0x16) */
     210  xcoff_reloc_type_crel, /* R_CREL  (0x17) */
     211  xcoff_reloc_type_ba,   /* R_RBA   (0x18) */
     212  xcoff_reloc_type_ba,   /* R_RBAC  (0x19) */
     213  xcoff64_reloc_type_br, /* R_RBR   (0x1a) */
     214  xcoff_reloc_type_ba,   /* R_RBRC  (0x1b) */
     215};
     216
     217/* coffcode.h needs these to be defined.  */
    23218/* Internalcoff.h and coffcode.h modify themselves based on these flags.  */
    24219#define XCOFF64
    25220#define RS6000COFF_C 1
    26221
    27 #include "bfd.h"
    28 #include "sysdep.h"
    29 #include "libbfd.h"
    30 #include "coff/internal.h"
    31 #include "coff/rs6k64.h"
    32 #include "libcoff.h"
    33 
    34 #define GET_FILEHDR_SYMPTR bfd_h_get_64
    35 #define PUT_FILEHDR_SYMPTR bfd_h_put_64
    36 #define GET_AOUTHDR_DATA_START bfd_h_get_64
    37 #define PUT_AOUTHDR_DATA_START bfd_h_put_64
    38 #define GET_AOUTHDR_TEXT_START bfd_h_get_64
    39 #define PUT_AOUTHDR_TEXT_START bfd_h_put_64
    40 #define GET_AOUTHDR_TSIZE bfd_h_get_64
    41 #define PUT_AOUTHDR_TSIZE bfd_h_put_64
    42 #define GET_AOUTHDR_DSIZE bfd_h_get_64
    43 #define PUT_AOUTHDR_DSIZE bfd_h_put_64
    44 #define GET_AOUTHDR_BSIZE bfd_h_get_64
    45 #define PUT_AOUTHDR_BSIZE bfd_h_put_64
    46 #define GET_AOUTHDR_ENTRY bfd_h_get_64
    47 #define PUT_AOUTHDR_ENTRY bfd_h_put_64
    48 #define GET_SCNHDR_PADDR bfd_h_get_64
    49 #define PUT_SCNHDR_PADDR bfd_h_put_64
    50 #define GET_SCNHDR_VADDR bfd_h_get_64
    51 #define PUT_SCNHDR_VADDR bfd_h_put_64
    52 #define GET_SCNHDR_SIZE bfd_h_get_64
    53 #define PUT_SCNHDR_SIZE bfd_h_put_64
    54 #define GET_SCNHDR_SCNPTR bfd_h_get_64
    55 #define PUT_SCNHDR_SCNPTR bfd_h_put_64
    56 #define GET_SCNHDR_RELPTR bfd_h_get_64
    57 #define PUT_SCNHDR_RELPTR bfd_h_put_64
    58 #define GET_SCNHDR_LNNOPTR bfd_h_get_64
    59 #define PUT_SCNHDR_LNNOPTR bfd_h_put_64
    60 #define GET_SCNHDR_NRELOC bfd_h_get_32
    61 #define MAX_SCNHDR_NRELOC 0xffffffff
    62 #define PUT_SCNHDR_NRELOC bfd_h_put_32
    63 #define GET_SCNHDR_NLNNO bfd_h_get_32
    64 #define MAX_SCNHDR_NLNNO 0xffffffff
    65 #define PUT_SCNHDR_NLNNO bfd_h_put_32
    66 #define GET_RELOC_VADDR bfd_h_get_64
    67 #define PUT_RELOC_VADDR bfd_h_put_64
    68 
    69 #define COFF_FORCE_SYMBOLS_IN_STRINGS
    70 #define COFF_DEBUG_STRING_WIDE_PREFIX
    71 
    72 #define COFF_ADJUST_SCNHDR_OUT_POST(ABFD,INT,EXT) \
    73 do { \
    74   memset (((SCNHDR *)EXT)->s_pad, 0, sizeof (((SCNHDR *)EXT)->s_pad));\
    75 } while (0)
    76 
    77 #define NO_COFF_LINENOS
    78 
    79 #define coff_SWAP_lineno_in xcoff64_swap_lineno_in
    80 #define coff_SWAP_lineno_out xcoff64_swap_lineno_out
    81 
    82 #define PUTWORD bfd_h_put_32
    83 #define PUTHALF bfd_h_put_16
    84 #define PUTBYTE bfd_h_put_8
    85 #define GETWORD bfd_h_get_32
    86 #define GETHALF bfd_h_get_16
    87 #define GETBYTE bfd_h_get_8
     222#define SELECT_RELOC(internal, howto)                                   \
     223  {                                                                     \
     224    internal.r_type = howto->type;                                      \
     225    internal.r_size =                                                   \
     226      ((howto->complain_on_overflow == complain_overflow_signed         \
     227        ? 0x80                                                          \
     228        : 0)                                                            \
     229       | (howto->bitsize - 1));                                         \
     230  }
     231
     232#define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (3)
     233#define COFF_LONG_FILENAMES
     234#define NO_COFF_SYMBOLS
     235#define RTYPE2HOWTO(cache_ptr, dst) xcoff64_rtype2howto (cache_ptr, dst)
     236#define coff_mkobject _bfd_xcoff_mkobject
     237#define coff_bfd_copy_private_bfd_data _bfd_xcoff_copy_private_bfd_data
     238#define coff_bfd_is_local_label_name _bfd_xcoff_is_local_label_name
     239#define coff_bfd_reloc_type_lookup xcoff64_reloc_type_lookup
     240#ifdef AIX_CORE
     241extern const bfd_target * rs6000coff_core_p
     242  PARAMS ((bfd *abfd));
     243extern bfd_boolean rs6000coff_core_file_matches_executable_p
     244  PARAMS ((bfd *cbfd, bfd *ebfd));
     245extern char *rs6000coff_core_file_failing_command
     246  PARAMS ((bfd *abfd));
     247extern int rs6000coff_core_file_failing_signal
     248  PARAMS ((bfd *abfd));
     249#define CORE_FILE_P rs6000coff_core_p
     250#define coff_core_file_failing_command \
     251  rs6000coff_core_file_failing_command
     252#define coff_core_file_failing_signal \
     253  rs6000coff_core_file_failing_signal
     254#define coff_core_file_matches_executable_p \
     255  rs6000coff_core_file_matches_executable_p
     256#else
     257#define CORE_FILE_P _bfd_dummy_target
     258#define coff_core_file_failing_command \
     259  _bfd_nocore_core_file_failing_command
     260#define coff_core_file_failing_signal \
     261  _bfd_nocore_core_file_failing_signal
     262#define coff_core_file_matches_executable_p \
     263  _bfd_nocore_core_file_matches_executable_p
     264#endif
     265#define coff_SWAP_sym_in _bfd_xcoff64_swap_sym_in
     266#define coff_SWAP_sym_out _bfd_xcoff64_swap_sym_out
     267#define coff_SWAP_aux_in _bfd_xcoff64_swap_aux_in
     268#define coff_SWAP_aux_out _bfd_xcoff64_swap_aux_out
     269#define coff_swap_reloc_in xcoff64_swap_reloc_in
     270#define coff_swap_reloc_out xcoff64_swap_reloc_out
     271#define NO_COFF_RELOCS
     272
     273#include "coffcode.h"
    88274
    89275/* For XCOFF64, the effective width of symndx changes depending on
    90276   whether we are the first entry.  Sigh.  */
    91277static void
    92 xcoff64_swap_lineno_in (abfd, ext1, in1)
    93      bfd            *abfd;
     278_bfd_xcoff64_swap_lineno_in (abfd, ext1, in1)
     279     bfd *abfd;
    94280     PTR ext1;
    95281     PTR in1;
    96282{
    97   LINENO *ext = (LINENO *)ext1;
    98   struct internal_lineno      *in = (struct internal_lineno *)in1;
    99 
    100   in->l_lnno = bfd_h_get_32(abfd, (bfd_byte *) (ext->l_lnno));
     283  LINENO *ext = (LINENO *) ext1;
     284  struct internal_lineno *in = (struct internal_lineno *) in1;
     285
     286  in->l_lnno = H_GET_32 (abfd, (ext->l_lnno));
    101287  if (in->l_lnno == 0)
    102     in->l_addr.l_symndx =
    103             bfd_h_get_32(abfd, (bfd_byte *) ext->l_addr.l_symndx);
     288    in->l_addr.l_symndx = H_GET_32 (abfd, ext->l_addr.l_symndx);
    104289  else
    105     in->l_addr.l_symndx =
    106             bfd_h_get_64(abfd, (bfd_byte *) ext->l_addr.l_symndx);
     290    in->l_addr.l_paddr = H_GET_64 (abfd, ext->l_addr.l_paddr);
    107291}
    108292
    109293static unsigned int
    110 xcoff64_swap_lineno_out (abfd, inp, outp)
    111      bfd       *abfd;
    112      PTR        inp;
    113      PTR        outp;
    114 {
    115   struct internal_lineno *in = (struct internal_lineno *)inp;
    116   struct external_lineno *ext = (struct external_lineno *)outp;
    117   PUTWORD(abfd, in->l_addr.l_symndx, (bfd_byte *)
    118           ext->l_addr.l_symndx);
    119 
    120   bfd_h_put_32 (abfd, in->l_lnno,  (bfd_byte *) (ext->l_lnno));
     294_bfd_xcoff64_swap_lineno_out (abfd, inp, outp)
     295     bfd *abfd;
     296     PTR inp;
     297     PTR outp;
     298{
     299  struct internal_lineno *in = (struct internal_lineno *) inp;
     300  struct external_lineno *ext = (struct external_lineno *) outp;
     301
     302  H_PUT_32 (abfd, in->l_addr.l_symndx, ext->l_addr.l_symndx);
     303  H_PUT_32 (abfd, in->l_lnno, (ext->l_lnno));
     304
    121305  if (in->l_lnno == 0)
    122     bfd_h_put_32 (abfd, in->l_addr.l_symndx, (bfd_byte *)ext->l_addr.l_symndx);
     306    H_PUT_32 (abfd, in->l_addr.l_symndx, ext->l_addr.l_symndx);
    123307  else
    124     bfd_h_put_64 (abfd, in->l_addr.l_symndx, (bfd_byte *)ext->l_addr.l_symndx);
     308    H_PUT_64 (abfd, in->l_addr.l_paddr, ext->l_addr.l_paddr);
    125309
    126310  return bfd_coff_linesz (abfd);
    127311}
    128312
    129 static void xcoff64_swap_sym_in PARAMS ((bfd *, PTR, PTR));
    130 static unsigned int xcoff64_swap_sym_out PARAMS ((bfd *, PTR, PTR));
    131 static void xcoff64_swap_aux_in PARAMS ((bfd *, PTR, int, int, int, int, PTR));
    132 static unsigned int xcoff64_swap_aux_out PARAMS ((bfd *, PTR, int, int, int, int, PTR));
    133 
    134313static void
    135 xcoff64_swap_sym_in (abfd, ext1, in1)
    136      bfd            *abfd;
     314_bfd_xcoff64_swap_sym_in (abfd, ext1, in1)
     315     bfd *abfd;
    137316     PTR ext1;
    138317     PTR in1;
    139318{
    140   SYMENT *ext = (SYMENT *)ext1;
    141   struct internal_syment      *in = (struct internal_syment *)in1;
     319  struct external_syment *ext = (struct external_syment *) ext1;
     320  struct internal_syment *in = (struct internal_syment *) in1;
    142321
    143322  in->_n._n_n._n_zeroes = 0;
    144   in->_n._n_n._n_offset = bfd_h_get_32(abfd, (bfd_byte *) ext->e_offset);
    145   in->n_value = bfd_h_get_64(abfd, (bfd_byte *) ext->e.e_value);
    146   in->n_scnum = bfd_h_get_16(abfd, (bfd_byte *) ext->e_scnum);
    147   in->n_type = bfd_h_get_16(abfd, (bfd_byte *) ext->e_type);
    148   in->n_sclass = bfd_h_get_8(abfd, ext->e_sclass);
    149   in->n_numaux = bfd_h_get_8(abfd, ext->e_numaux);
     323  in->_n._n_n._n_offset = H_GET_32 (abfd, ext->e_offset);
     324  in->n_value = H_GET_64 (abfd, ext->e_value);
     325  in->n_scnum = H_GET_16 (abfd, ext->e_scnum);
     326  in->n_type = H_GET_16 (abfd, ext->e_type);
     327  in->n_sclass = H_GET_8 (abfd, ext->e_sclass);
     328  in->n_numaux = H_GET_8 (abfd, ext->e_numaux);
    150329}
    151330
    152331static unsigned int
    153 xcoff64_swap_sym_out (abfd, inp, extp)
    154      bfd       *abfd;
    155      PTR        inp;
    156      PTR        extp;
    157 {
    158   struct internal_syment *in = (struct internal_syment *)inp;
    159   SYMENT *ext =(SYMENT *)extp;
    160 
    161   bfd_h_put_32(abfd, in->_n._n_n._n_offset, (bfd_byte *) ext->e_offset);
    162   bfd_h_put_64(abfd,  in->n_value , (bfd_byte *) ext->e.e_value);
    163   bfd_h_put_16(abfd,  in->n_scnum , (bfd_byte *) ext->e_scnum);
    164   bfd_h_put_16(abfd,  in->n_type , (bfd_byte *) ext->e_type);
    165   bfd_h_put_8(abfd,  in->n_sclass , ext->e_sclass);
    166   bfd_h_put_8(abfd,  in->n_numaux , ext->e_numaux);
     332_bfd_xcoff64_swap_sym_out (abfd, inp, extp)
     333     bfd *abfd;
     334     PTR inp;
     335     PTR extp;
     336{
     337  struct internal_syment *in = (struct internal_syment *) inp;
     338  struct external_syment *ext = (struct external_syment *) extp;
     339
     340  H_PUT_32 (abfd, in->_n._n_n._n_offset, ext->e_offset);
     341  H_PUT_64 (abfd, in->n_value, ext->e_value);
     342  H_PUT_16 (abfd, in->n_scnum, ext->e_scnum);
     343  H_PUT_16 (abfd, in->n_type, ext->e_type);
     344  H_PUT_8 (abfd, in->n_sclass, ext->e_sclass);
     345  H_PUT_8 (abfd, in->n_numaux, ext->e_numaux);
    167346  return bfd_coff_symesz (abfd);
    168347}
    169348
    170349static void
    171 xcoff64_swap_aux_in (abfd, ext1, type, class, indx, numaux, in1)
    172      bfd            *abfd;
    173      PTR              ext1;
    174      int             type;
    175      int             class;
    176      int              indx;
    177      int              numaux;
    178      PTR              in1;
    179 {
    180   AUXENT    *ext = (AUXENT *)ext1;
    181   union internal_auxent *in = (union internal_auxent *)in1;
    182 
    183   switch (class) {
     350_bfd_xcoff64_swap_aux_in (abfd, ext1, type, class, indx, numaux, in1)
     351     bfd *abfd;
     352     PTR ext1;
     353     int type;
     354     int class;
     355     int indx;
     356     int numaux;
     357     PTR in1;
     358{
     359  union external_auxent *ext = (union external_auxent *) ext1;
     360  union internal_auxent *in = (union internal_auxent *) in1;
     361
     362  switch (class)
     363    {
    184364    case C_FILE:
    185       if (ext->x_file.x_fname[0] == 0) {
     365      if (ext->x_file.x_n.x_zeroes[0] == 0)
     366        {
    186367          in->x_file.x_n.x_zeroes = 0;
    187           in->x_file.x_n.x_offset =
    188            bfd_h_get_32(abfd, (bfd_byte *) ext->x_file.x_n.x_offset);
    189         } else {
    190             if (numaux > 1)
    191               {
    192                 if (indx == 0)
    193           memcpy (in->x_file.x_fname, ext->x_file.x_fname,
    194                           numaux * sizeof (AUXENT));
    195               }
    196             else
    197               {
    198                 memcpy (in->x_file.x_fname, ext->x_file.x_fname, FILNMLEN);
    199               }
    200           }
     368          in->x_file.x_n.x_offset = H_GET_32 (abfd, ext->x_file.x_n.x_offset);
     369        }
     370      else
     371        {
     372          memcpy (in->x_file.x_fname, ext->x_file.x_fname, FILNMLEN);
     373        }
    201374      goto end;
    202375
    … …  
    206379      if (indx + 1 == numaux)
    207380        {
    208           in->x_csect.x_scnlen.l =
    209               bfd_h_get_32(abfd, ext->x_csect.x_scnlen_lo);
    210           /* FIXME: If we want section lengths larger than 32 bits, we need
    211              to modify the internal coff structures to support it.  */
    212           in->x_csect.x_parmhash = bfd_h_get_32 (abfd,
    213                                                  ext->x_csect.x_parmhash);
    214           in->x_csect.x_snhash   = bfd_h_get_16 (abfd, ext->x_csect.x_snhash);
     381          bfd_signed_vma h = 0;
     382          bfd_vma l = 0;
     383
     384          h = H_GET_S32 (abfd, ext->x_csect.x_scnlen_hi);
     385          l = H_GET_32 (abfd, ext->x_csect.x_scnlen_lo);
     386
     387          in->x_csect.x_scnlen.l = h << 32 | (l & 0xffffffff);
     388
     389          in->x_csect.x_parmhash = H_GET_32 (abfd, ext->x_csect.x_parmhash);
     390          in->x_csect.x_snhash = H_GET_16 (abfd, ext->x_csect.x_snhash);
    215391          /* We don't have to hack bitfields in x_smtyp because it's
    216392             defined by shifts-and-ands, which are equivalent on all
    217393             byte orders.  */
    218           in->x_csect.x_smtyp    = bfd_h_get_8 (abfd, ext->x_csect.x_smtyp);
    219           in->x_csect.x_smclas   = bfd_h_get_8 (abfd, ext->x_csect.x_smclas);
     394          in->x_csect.x_smtyp = H_GET_8 (abfd, ext->x_csect.x_smtyp);
     395          in->x_csect.x_smclas = H_GET_8 (abfd, ext->x_csect.x_smclas);
    220396          goto end;
    221397        }
    … …  
    225401    case C_LEAFSTAT:
    226402    case C_HIDDEN:
    227       if (type == T_NULL) {
     403      if (type == T_NULL)
     404        {
    228405          /* PE defines some extra fields; we zero them out for
    229              safety.  */
     406             safety.  */
    230407          in->x_scn.x_checksum = 0;
    231408          in->x_scn.x_associated = 0;
    … …  
    239416  if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
    240417    {
    241       in->x_sym.x_fcnary.x_fcn.x_lnnoptr = bfd_h_get_64(abfd, (bfd_byte *)
    242               ext->x_sym.x_fcnary.x_fcn.x_lnnoptr);
    243       in->x_sym.x_fcnary.x_fcn.x_endndx.l = bfd_h_get_32(abfd, (bfd_byte *)
    244               ext->x_sym.x_fcnary.x_fcn.x_endndx);
    245     }
    246   if (ISFCN(type)) {
    247     in->x_sym.x_misc.x_fsize = bfd_h_get_32(abfd, (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_fsize);
     418      in->x_sym.x_fcnary.x_fcn.x_lnnoptr
     419        = H_GET_64 (abfd, ext->x_sym.x_fcnary.x_fcn.x_lnnoptr);
     420      in->x_sym.x_fcnary.x_fcn.x_endndx.l
     421        = H_GET_32 (abfd, ext->x_sym.x_fcnary.x_fcn.x_endndx);
     422    }
     423  if (ISFCN (type))
     424    {
     425      in->x_sym.x_misc.x_fsize
     426        = H_GET_32 (abfd, ext->x_sym.x_fcnary.x_fcn.x_fsize);
     427    }
     428  else
     429    {
     430      in->x_sym.x_misc.x_lnsz.x_lnno
     431        = H_GET_32 (abfd, ext->x_sym.x_fcnary.x_lnsz.x_lnno);
     432      in->x_sym.x_misc.x_lnsz.x_size
     433        = H_GET_16 (abfd, ext->x_sym.x_fcnary.x_lnsz.x_size);
     434    }
     435
     436 end: ;
     437}
     438
     439static unsigned int
     440_bfd_xcoff64_swap_aux_out (abfd, inp, type, class, indx, numaux, extp)
     441     bfd *abfd;
     442     PTR inp;
     443     int type;
     444     int class;
     445     int indx ATTRIBUTE_UNUSED;
     446     int numaux ATTRIBUTE_UNUSED;
     447     PTR extp;
     448{
     449  union internal_auxent *in = (union internal_auxent *) inp;
     450  union external_auxent *ext = (union external_auxent *) extp;
     451
     452  memset ((PTR) ext, 0, bfd_coff_auxesz (abfd));
     453  switch (class)
     454    {
     455    case C_FILE:
     456      if (in->x_file.x_n.x_zeroes == 0)
     457        {
     458          H_PUT_32 (abfd, 0, ext->x_file.x_n.x_zeroes);
     459          H_PUT_32 (abfd, in->x_file.x_n.x_offset, ext->x_file.x_n.x_offset);
     460        }
     461      else
     462        {
     463          memcpy (ext->x_file.x_fname, in->x_file.x_fname, FILNMLEN);
     464        }
     465      H_PUT_8 (abfd, _AUX_FILE, ext->x_auxtype.x_auxtype);
     466      goto end;
     467
     468      /* RS/6000 "csect" auxents */
     469    case C_EXT:
     470    case C_HIDEXT:
     471      if (indx + 1 == numaux)
     472        {
     473          bfd_vma temp;
     474
     475          temp = in->x_csect.x_scnlen.l & 0xffffffff;
     476          H_PUT_32 (abfd, temp, ext->x_csect.x_scnlen_lo);
     477          temp = in->x_csect.x_scnlen.l >> 32;
     478          H_PUT_32 (abfd, temp, ext->x_csect.x_scnlen_hi);
     479          H_PUT_32 (abfd, in->x_csect.x_parmhash, ext->x_csect.x_parmhash);
     480          H_PUT_16 (abfd, in->x_csect.x_snhash, ext->x_csect.x_snhash);
     481          /* We don't have to hack bitfields in x_smtyp because it's
     482             defined by shifts-and-ands, which are equivalent on all
     483             byte orders.  */
     484          H_PUT_8 (abfd, in->x_csect.x_smtyp, ext->x_csect.x_smtyp);
     485          H_PUT_8 (abfd, in->x_csect.x_smclas, ext->x_csect.x_smclas);
     486          H_PUT_8 (abfd, _AUX_CSECT, ext->x_auxtype.x_auxtype);
     487          goto end;
     488        }
     489      break;
     490
     491    case C_STAT:
     492    case C_LEAFSTAT:
     493    case C_HIDDEN:
     494      if (type == T_NULL)
     495        {
     496          goto end;
     497        }
     498      break;
     499    }
     500
     501  if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
     502    {
     503      H_PUT_64 (abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr,
     504               ext->x_sym.x_fcnary.x_fcn.x_lnnoptr);
     505      H_PUT_8 (abfd, _AUX_FCN,
     506               ext->x_auxtype.x_auxtype);
     507      H_PUT_32 (abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l,
     508               ext->x_sym.x_fcnary.x_fcn.x_endndx);
     509    }
     510  if (ISFCN (type))
     511    {
     512      H_PUT_32 (abfd, in->x_sym.x_misc.x_fsize,
     513               ext->x_sym.x_fcnary.x_fcn.x_fsize);
     514    }
     515  else
     516    {
     517      H_PUT_32 (abfd, in->x_sym.x_misc.x_lnsz.x_lnno,
     518               ext->x_sym.x_fcnary.x_lnsz.x_lnno);
     519      H_PUT_16 (abfd, in->x_sym.x_misc.x_lnsz.x_size,
     520               ext->x_sym.x_fcnary.x_lnsz.x_size);
     521    }
     522
     523 end:
     524
     525  return bfd_coff_auxesz (abfd);
     526}
     527
     528static bfd_boolean
     529_bfd_xcoff64_put_symbol_name (abfd, strtab, sym, name)
     530     bfd *abfd;
     531     struct bfd_strtab_hash *strtab;
     532     struct internal_syment *sym;
     533     const char *name;
     534{
     535  bfd_boolean hash;
     536  bfd_size_type indx;
     537
     538  hash = TRUE;
     539
     540  if ((abfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
     541    hash = FALSE;
     542
     543  indx = _bfd_stringtab_add (strtab, name, hash, FALSE);
     544
     545  if (indx == (bfd_size_type) -1)
     546    return FALSE;
     547
     548  sym->_n._n_n._n_zeroes = 0;
     549  sym->_n._n_n._n_offset = STRING_SIZE_SIZE + indx;
     550
     551  return TRUE;
     552}
     553
     554static bfd_boolean
     555_bfd_xcoff64_put_ldsymbol_name (abfd, ldinfo, ldsym, name)
     556     bfd *abfd ATTRIBUTE_UNUSED;
     557     struct xcoff_loader_info *ldinfo;
     558     struct internal_ldsym *ldsym;
     559     const char *name;
     560{
     561  size_t len;
     562  len = strlen (name);
     563
     564  if (ldinfo->string_size + len + 3 > ldinfo->string_alc)
     565    {
     566      bfd_size_type newalc;
     567      bfd_byte *newstrings;
     568
     569      newalc = ldinfo->string_alc * 2;
     570      if (newalc == 0)
     571        newalc = 32;
     572      while (ldinfo->string_size + len + 3 > newalc)
     573        newalc *= 2;
     574
     575      newstrings = ((bfd_byte *)
     576                    bfd_realloc ((PTR) ldinfo->strings, newalc));
     577      if (newstrings == NULL)
     578        {
     579          ldinfo->failed = TRUE;
     580          return FALSE;
     581        }
     582      ldinfo->string_alc = newalc;
     583      ldinfo->strings = newstrings;
     584    }
     585
     586  bfd_put_16 (ldinfo->output_bfd, (bfd_vma) (len + 1),
     587              ldinfo->strings + ldinfo->string_size);
     588  strcpy (ldinfo->strings + ldinfo->string_size + 2, name);
     589  ldsym->_l._l_l._l_zeroes = 0;
     590  ldsym->_l._l_l._l_offset = ldinfo->string_size + 2;
     591  ldinfo->string_size += len + 3;
     592
     593  return TRUE;
     594}
     595
     596/* Routines to swap information in the XCOFF .loader section.  If we
     597   ever need to write an XCOFF loader, this stuff will need to be
     598   moved to another file shared by the linker (which XCOFF calls the
     599   ``binder'') and the loader.  */
     600
     601/* Swap in the ldhdr structure.  */
     602
     603static void
     604xcoff64_swap_ldhdr_in (abfd, s, dst)
     605     bfd *abfd;
     606     const PTR s;
     607     struct internal_ldhdr *dst;
     608{
     609  const struct external_ldhdr *src = (const struct external_ldhdr *) s;
     610
     611  dst->l_version = bfd_get_32 (abfd, src->l_version);
     612  dst->l_nsyms = bfd_get_32 (abfd, src->l_nsyms);
     613  dst->l_nreloc = bfd_get_32 (abfd, src->l_nreloc);
     614  dst->l_istlen = bfd_get_32 (abfd, src->l_istlen);
     615  dst->l_nimpid = bfd_get_32 (abfd, src->l_nimpid);
     616  dst->l_stlen = bfd_get_32 (abfd, src->l_stlen);
     617  dst->l_impoff = bfd_get_64 (abfd, src->l_impoff);
     618  dst->l_stoff = bfd_get_64 (abfd, src->l_stoff);
     619  dst->l_symoff = bfd_get_64 (abfd, src->l_symoff);
     620  dst->l_rldoff = bfd_get_64 (abfd, src->l_rldoff);
     621}
     622
     623/* Swap out the ldhdr structure.  */
     624
     625static void
     626xcoff64_swap_ldhdr_out (abfd, src, d)
     627     bfd *abfd;
     628     const struct internal_ldhdr *src;
     629     PTR d;
     630{
     631  struct external_ldhdr *dst = (struct external_ldhdr *) d;
     632
     633  bfd_put_32 (abfd, (bfd_vma) src->l_version, dst->l_version);
     634  bfd_put_32 (abfd, src->l_nsyms, dst->l_nsyms);
     635  bfd_put_32 (abfd, src->l_nreloc, dst->l_nreloc);
     636  bfd_put_32 (abfd, src->l_istlen, dst->l_istlen);
     637  bfd_put_32 (abfd, src->l_nimpid, dst->l_nimpid);
     638  bfd_put_32 (abfd, src->l_stlen, dst->l_stlen);
     639  bfd_put_64 (abfd, src->l_impoff, dst->l_impoff);
     640  bfd_put_64 (abfd, src->l_stoff, dst->l_stoff);
     641  bfd_put_64 (abfd, src->l_symoff, dst->l_symoff);
     642  bfd_put_64 (abfd, src->l_rldoff, dst->l_rldoff);
     643}
     644
     645/* Swap in the ldsym structure.  */
     646
     647static void
     648xcoff64_swap_ldsym_in (abfd, s, dst)
     649     bfd *abfd;
     650     const PTR s;
     651     struct internal_ldsym *dst;
     652{
     653  const struct external_ldsym *src = (const struct external_ldsym *) s;
     654  /* XCOFF64 does not use l_zeroes like XCOFF32
     655     Set the internal l_zeroes to 0 so the common 32/64 code uses l_value
     656     as an offset into the loader symbol table.  */
     657  dst->_l._l_l._l_zeroes = 0;
     658  dst->_l._l_l._l_offset = bfd_get_32 (abfd, src->l_offset);
     659  dst->l_value = bfd_get_64 (abfd, src->l_value);
     660  dst->l_scnum = bfd_get_16 (abfd, src->l_scnum);
     661  dst->l_smtype = bfd_get_8 (abfd, src->l_smtype);
     662  dst->l_smclas = bfd_get_8 (abfd, src->l_smclas);
     663  dst->l_ifile = bfd_get_32 (abfd, src->l_ifile);
     664  dst->l_parm = bfd_get_32 (abfd, src->l_parm);
     665}
     666
     667/* Swap out the ldsym structure.  */
     668
     669static void
     670xcoff64_swap_ldsym_out (abfd, src, d)
     671     bfd *abfd;
     672     const struct internal_ldsym *src;
     673     PTR d;
     674{
     675  struct external_ldsym *dst = (struct external_ldsym *) d;
     676
     677  bfd_put_64 (abfd, src->l_value, dst->l_value);
     678  bfd_put_32 (abfd, (bfd_vma) src->_l._l_l._l_offset, dst->l_offset);
     679  bfd_put_16 (abfd, (bfd_vma) src->l_scnum, dst->l_scnum);
     680  bfd_put_8 (abfd, src->l_smtype, dst->l_smtype);
     681  bfd_put_8 (abfd, src->l_smclas, dst->l_smclas);
     682  bfd_put_32 (abfd, src->l_ifile, dst->l_ifile);
     683  bfd_put_32 (abfd, src->l_parm, dst->l_parm);
     684}
     685
     686static void
     687xcoff64_swap_reloc_in (abfd, s, d)
     688     bfd *abfd;
     689     PTR s;
     690     PTR d;
     691{
     692  struct external_reloc *src = (struct external_reloc *) s;
     693  struct internal_reloc *dst = (struct internal_reloc *) d;
     694
     695  memset (dst, 0, sizeof (struct internal_reloc));
     696
     697  dst->r_vaddr = bfd_get_64 (abfd, src->r_vaddr);
     698  dst->r_symndx = bfd_get_32 (abfd, src->r_symndx);
     699  dst->r_size = bfd_get_8 (abfd, src->r_size);
     700  dst->r_type = bfd_get_8 (abfd, src->r_type);
     701}
     702
     703static unsigned int
     704xcoff64_swap_reloc_out (abfd, s, d)
     705     bfd *abfd;
     706     PTR s;
     707     PTR d;
     708{
     709  struct internal_reloc *src = (struct internal_reloc *) s;
     710  struct external_reloc *dst = (struct external_reloc *) d;
     711
     712  bfd_put_64 (abfd, src->r_vaddr, dst->r_vaddr);
     713  bfd_put_32 (abfd, src->r_symndx, dst->r_symndx);
     714  bfd_put_8 (abfd, src->r_type, dst->r_type);
     715  bfd_put_8 (abfd, src->r_size, dst->r_size);
     716
     717  return bfd_coff_relsz (abfd);
     718}
     719
     720/* Swap in the ldrel structure.  */
     721
     722static void
     723xcoff64_swap_ldrel_in (abfd, s, dst)
     724     bfd *abfd;
     725     const PTR s;
     726     struct internal_ldrel *dst;
     727{
     728  const struct external_ldrel *src = (const struct external_ldrel *) s;
     729
     730  dst->l_vaddr = bfd_get_64 (abfd, src->l_vaddr);
     731  dst->l_symndx = bfd_get_32 (abfd, src->l_symndx);
     732  dst->l_rtype = bfd_get_16 (abfd, src->l_rtype);
     733  dst->l_rsecnm = bfd_get_16 (abfd, src->l_rsecnm);
     734}
     735
     736/* Swap out the ldrel structure.  */
     737
     738static void
     739xcoff64_swap_ldrel_out (abfd, src, d)
     740     bfd *abfd;
     741     const struct internal_ldrel *src;
     742     PTR d;
     743{
     744  struct external_ldrel *dst = (struct external_ldrel *) d;
     745
     746  bfd_put_64 (abfd, src->l_vaddr, dst->l_vaddr);
     747  bfd_put_16 (abfd, (bfd_vma) src->l_rtype, dst->l_rtype);
     748  bfd_put_16 (abfd, (bfd_vma) src->l_rsecnm, dst->l_rsecnm);
     749  bfd_put_32 (abfd, src->l_symndx, dst->l_symndx);
     750}
     751
     752static bfd_boolean
     753xcoff64_write_object_contents (abfd)
     754     bfd *abfd;
     755{
     756  asection *current;
     757  bfd_boolean hasrelocs = FALSE;
     758  bfd_boolean haslinno = FALSE;
     759  file_ptr scn_base;
     760  file_ptr reloc_base;
     761  file_ptr lineno_base;
     762  file_ptr sym_base;
     763  unsigned long reloc_size = 0;
     764  unsigned long lnno_size = 0;
     765  bfd_boolean long_section_names;
     766  asection *text_sec = ((void *) 0);
     767  asection *data_sec = ((void *) 0);
     768  asection *bss_sec = ((void *) 0);
     769  struct internal_filehdr internal_f;
     770  struct internal_aouthdr internal_a;
     771
     772  bfd_set_error (bfd_error_system_call);
     773
     774  if (! abfd->output_has_begun)
     775    {
     776      if (! bfd_coff_compute_section_file_positions (abfd))
     777        return FALSE;
     778    }
     779
     780  /* Work out the size of the reloc and linno areas.  */
     781  reloc_base = obj_relocbase (abfd);
     782
     783  for (current = abfd->sections; current != NULL; current = current->next)
     784    reloc_size += current->reloc_count * bfd_coff_relsz (abfd);
     785
     786  lineno_base = reloc_base + reloc_size;
     787
     788  /* Make a pass through the symbol table to count line number entries and
     789     put them into the correct asections.  */
     790  lnno_size = coff_count_linenumbers (abfd) * bfd_coff_linesz (abfd);
     791
     792  sym_base = lineno_base + lnno_size;
     793
     794  /* Indicate in each section->line_filepos its actual file address.  */
     795  for (current = abfd->sections; current != NULL; current =  current->next)
     796    {
     797      if (current->lineno_count)
     798        {
     799          current->line_filepos = lineno_base;
     800          current->moving_line_filepos = lineno_base;
     801          lineno_base += current->lineno_count * bfd_coff_linesz (abfd);
     802        }
     803      else
     804        {
     805          current->line_filepos = 0;
     806        }
     807
     808      if (current->reloc_count)
     809        {
     810          current->rel_filepos = reloc_base;
     811          reloc_base += current->reloc_count * bfd_coff_relsz (abfd);
     812        }
     813      else
     814        {
     815          current->rel_filepos = 0;
     816        }
     817    }
     818
     819  if ((abfd->flags & EXEC_P) != 0)
     820    {
     821      scn_base = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
     822      internal_f.f_opthdr = bfd_coff_aoutsz (abfd);
     823    }
     824  else
     825    {
     826      scn_base = bfd_coff_filhsz (abfd);
     827      internal_f.f_opthdr = 0;
     828    }
     829
     830  internal_f.f_nscns = 0;
     831
     832  if (bfd_seek (abfd, scn_base, SEEK_SET) != 0)
     833    return FALSE;
     834
     835  long_section_names = FALSE;
     836  for (current = abfd->sections; current != NULL; current = current->next)
     837    {
     838      struct internal_scnhdr section;
     839      struct external_scnhdr buff;
     840      bfd_size_type amount;
     841
     842      internal_f.f_nscns++;
     843
     844      strncpy (section.s_name, current->name, SCNNMLEN);
     845
     846      section.s_vaddr = current->vma;
     847      section.s_paddr = current->lma;
     848      section.s_size =  current->_raw_size;
     849
     850      /* If this section has no size or is unloadable then the scnptr
     851         will be 0 too.  */
     852      if (current->_raw_size == 0
     853          || (current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
     854        {
     855          section.s_scnptr = 0;
     856        }
     857      else
     858        {
     859          section.s_scnptr = current->filepos;
     860        }
     861
     862      section.s_relptr = current->rel_filepos;
     863      section.s_lnnoptr = current->line_filepos;
     864      section.s_nreloc = current->reloc_count;
     865
     866      section.s_nlnno = current->lineno_count;
     867      if (current->reloc_count != 0)
     868        hasrelocs = TRUE;
     869      if (current->lineno_count != 0)
     870        haslinno = TRUE;
     871
     872      section.s_flags = sec_to_styp_flags (current->name, current->flags);
     873
     874      if (!strcmp (current->name, _TEXT))
     875        {
     876          text_sec = current;
     877        }
     878      else if (!strcmp (current->name, _DATA))
     879        {
     880          data_sec = current;
     881        }
     882      else if (!strcmp (current->name, _BSS))
     883        {
     884          bss_sec = current;
     885        }
     886
     887      amount = bfd_coff_scnhsz (abfd);
     888      if (bfd_coff_swap_scnhdr_out (abfd, &section, &buff) == 0
     889          || bfd_bwrite ((PTR) (&buff), amount, abfd) != amount)
     890        return FALSE;
     891    }
     892
     893  internal_f.f_timdat = 0;
     894
     895  internal_f.f_flags = 0;
     896
     897  if (!hasrelocs)
     898    internal_f.f_flags |= F_RELFLG;
     899  if (!haslinno)
     900    internal_f.f_flags |= F_LNNO;
     901  if (abfd->flags & EXEC_P)
     902    internal_f.f_flags |= F_EXEC;
     903
     904  /* FIXME: this is wrong for PPC_PE!  */
     905  if (bfd_little_endian (abfd))
     906    internal_f.f_flags |= F_AR32WR;
     907  else
     908    internal_f.f_flags |= F_AR32W;
     909
     910  if ((abfd->flags & DYNAMIC) != 0)
     911    internal_f.f_flags |= F_SHROBJ;
     912  if (bfd_get_section_by_name (abfd, _LOADER) != NULL)
     913    internal_f.f_flags |= F_DYNLOAD;
     914
     915  memset (&internal_a, 0, sizeof internal_a);
     916
     917  internal_f.f_magic = bfd_xcoff_magic_number (abfd);
     918  internal_a.magic = (abfd->flags & D_PAGED
     919                      ? RS6K_AOUTHDR_ZMAGIC
     920                      : (abfd->flags & WP_TEXT
     921                         ? RS6K_AOUTHDR_NMAGIC
     922                         : RS6K_AOUTHDR_OMAGIC));
     923
     924  /* FIXME: Does anybody ever set this to another value?  */
     925  internal_a.vstamp = 0;
     926
     927  /* Now should write relocs, strings, syms.  */
     928  obj_sym_filepos (abfd) = sym_base;
     929
     930  internal_f.f_symptr = 0;
     931  internal_f.f_nsyms = 0;
     932
     933  /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
     934     backend linker, and obj_raw_syment_count is not valid until after
     935     coff_write_symbols is called.  */
     936  if (bfd_get_symcount (abfd) != 0)
     937    {
     938      int firstundef;
     939
     940      if (!coff_renumber_symbols (abfd, &firstundef))
     941        return FALSE;
     942      coff_mangle_symbols (abfd);
     943      if (! coff_write_symbols (abfd))
     944        return FALSE;
     945      if (! coff_write_linenumbers (abfd))
     946        return FALSE;
     947      if (! coff_write_relocs (abfd, firstundef))
     948        return FALSE;
     949
     950      internal_f.f_symptr = sym_base;
     951      internal_f.f_nsyms = bfd_get_symcount (abfd);
     952    }
     953  else if (obj_raw_syment_count (abfd) != 0)
     954    {
     955      internal_f.f_symptr = sym_base;
     956
     957      /* AIX appears to require that F_RELFLG not be set if there are
     958         local symbols but no relocations.  */
     959      internal_f.f_flags &=~ F_RELFLG;
     960    }
     961  else
     962    {
     963      internal_f.f_flags |= F_LSYMS;
     964    }
     965
     966  if (text_sec)
     967    {
     968      internal_a.tsize = bfd_get_section_size_before_reloc (text_sec);
     969      internal_a.text_start = internal_a.tsize ? text_sec->vma : 0;
     970    }
     971
     972  if (data_sec)
     973    {
     974      internal_a.dsize = bfd_get_section_size_before_reloc (data_sec);
     975      internal_a.data_start = internal_a.dsize ? data_sec->vma : 0;
     976    }
     977
     978  if (bss_sec)
     979    {
     980      internal_a.bsize = bfd_get_section_size_before_reloc (bss_sec);
     981      if (internal_a.bsize && bss_sec->vma < internal_a.data_start)
     982        internal_a.data_start = bss_sec->vma;
     983    }
     984
     985  internal_a.entry = bfd_get_start_address (abfd);
     986  internal_f.f_nsyms = obj_raw_syment_count (abfd);
     987
     988  if (xcoff_data (abfd)->full_aouthdr)
     989    {
     990      bfd_vma toc;
     991      asection *loader_sec;
     992
     993      internal_a.vstamp = 1;
     994
     995      internal_a.o_snentry = xcoff_data (abfd)->snentry;
     996      if (internal_a.o_snentry == 0)
     997        internal_a.entry = (bfd_vma) -1;
     998
     999      if (text_sec != NULL)
     1000        {
     1001          internal_a.o_sntext = text_sec->target_index;
     1002          internal_a.o_algntext = bfd_get_section_alignment (abfd, text_sec);
     1003        }
     1004      else
     1005        {
     1006          internal_a.o_sntext = 0;
     1007          internal_a.o_algntext = 0;
     1008        }
     1009
     1010      if (data_sec != NULL)
     1011        {
     1012          internal_a.o_sndata = data_sec->target_index;
     1013          internal_a.o_algndata = bfd_get_section_alignment (abfd, data_sec);
     1014        }
     1015      else
     1016        {
     1017          internal_a.o_sndata = 0;
     1018          internal_a.o_algndata = 0;
     1019        }
     1020
     1021      loader_sec = bfd_get_section_by_name (abfd, ".loader");
     1022      if (loader_sec != NULL)
     1023        internal_a.o_snloader = loader_sec->target_index;
     1024      else
     1025        internal_a.o_snloader = 0;
     1026      if (bss_sec != NULL)
     1027        internal_a.o_snbss = bss_sec->target_index;
     1028      else
     1029        internal_a.o_snbss = 0;
     1030
     1031      toc = xcoff_data (abfd)->toc;
     1032      internal_a.o_toc = toc;
     1033      internal_a.o_sntoc = xcoff_data (abfd)->sntoc;
     1034
     1035      internal_a.o_modtype = xcoff_data (abfd)->modtype;
     1036      if (xcoff_data (abfd)->cputype != -1)
     1037        internal_a.o_cputype = xcoff_data (abfd)->cputype;
     1038      else
     1039        {
     1040          switch (bfd_get_arch (abfd))
     1041            {
     1042            case bfd_arch_rs6000:
     1043              internal_a.o_cputype = 4;
     1044              break;
     1045            case bfd_arch_powerpc:
     1046              if (bfd_get_mach (abfd) == bfd_mach_ppc)
     1047                internal_a.o_cputype = 3;
     1048              else
     1049                internal_a.o_cputype = 1;
     1050              break;
     1051            default:
     1052              abort ();
     1053            }
     1054        }
     1055      internal_a.o_maxstack = xcoff_data (abfd)->maxstack;
     1056      internal_a.o_maxdata = xcoff_data (abfd)->maxdata;
     1057    }
     1058
     1059  if (bfd_seek (abfd, (file_ptr) 0, 0) != 0)
     1060    return FALSE;
     1061
     1062  {
     1063    char * buff;
     1064    bfd_size_type amount = bfd_coff_filhsz (abfd);
     1065
     1066    buff = bfd_malloc (amount);
     1067    if (buff == NULL)
     1068      return FALSE;
     1069
     1070    bfd_coff_swap_filehdr_out (abfd, (PTR) &internal_f, (PTR) buff);
     1071    amount = bfd_bwrite ((PTR) buff, amount, abfd);
     1072
     1073    free (buff);
     1074
     1075    if (amount != bfd_coff_filhsz (abfd))
     1076      return FALSE;
    2481077  }
    249   else {
    250     in->x_sym.x_misc.x_lnsz.x_lnno = bfd_h_get_32(abfd, (bfd_byte *)
    251             ext->x_sym.x_fcnary.x_lnsz.x_lnno);
    252     in->x_sym.x_misc.x_lnsz.x_size = bfd_h_get_16(abfd, (bfd_byte *)
    253             ext->x_sym.x_fcnary.x_lnsz.x_size);
    254   }
    255 
    256 end: ;
    257   /* the semicolon is because MSVC doesn't like labels at
    258      end of block.  */
    259 
    260 }
    261 
    262 static unsigned int
    263 xcoff64_swap_aux_out (abfd, inp, type, class, indx, numaux, extp)
    264      bfd   *abfd;
    265      PTR        inp;
    266      int   type;
    267      int   class;
    268      int   indx ATTRIBUTE_UNUSED;
    269      int   numaux ATTRIBUTE_UNUSED;
    270      PTR        extp;
    271 {
    272   union internal_auxent *in = (union internal_auxent *)inp;
    273   AUXENT *ext = (AUXENT *)extp;
    274 
    275   memset((PTR)ext, 0, bfd_coff_auxesz (abfd));
    276   switch (class)
    277     {
    278   case C_FILE:
    279     if (in->x_file.x_fname[0] == 0)
    280       {
    281       PUTWORD(abfd, 0, (bfd_byte *) ext->x_file.x_n.x_zeroes);
    282       PUTWORD(abfd,
    283               in->x_file.x_n.x_offset,
    284               (bfd_byte *) ext->x_file.x_n.x_offset);
    285     }
    286     else
    287       {
    288       memcpy (ext->x_file.x_fname, in->x_file.x_fname, FILNMLEN);
    289       }
    290     PUTBYTE (abfd, _AUX_FILE, (bfd_byte *) ext->x_auxtype.x_auxtype);
    291     goto end;
    292 
    293   /* RS/6000 "csect" auxents */
    294   case C_EXT:
    295   case C_HIDEXT:
    296     if (indx + 1 == numaux)
    297       {
    298         PUTWORD (abfd, in->x_csect.x_scnlen.l, ext->x_csect.x_scnlen_lo);
    299         PUTWORD (abfd, in->x_csect.x_parmhash,  ext->x_csect.x_parmhash);
    300         PUTHALF (abfd, in->x_csect.x_snhash,    ext->x_csect.x_snhash);
    301         /* We don't have to hack bitfields in x_smtyp because it's
    302            defined by shifts-and-ands, which are equivalent on all
    303            byte orders.  */
    304         PUTBYTE (abfd, in->x_csect.x_smtyp,     ext->x_csect.x_smtyp);
    305         PUTBYTE (abfd, in->x_csect.x_smclas,    ext->x_csect.x_smclas);
    306         PUTBYTE (abfd, _AUX_CSECT, (bfd_byte *) ext->x_auxtype.x_auxtype);
    307         goto end;
    308       }
    309     break;
    310 
    311   case C_STAT:
    312   case C_LEAFSTAT:
    313   case C_HIDDEN:
    314     if (type == T_NULL) {
    315       goto end;
    316     }
    317     break;
    318   }
    319 
    320   if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
    321     {
    322       bfd_h_put_64(abfd,  in->x_sym.x_fcnary.x_fcn.x_lnnoptr,
    323               (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_lnnoptr);
    324       PUTBYTE (abfd, _AUX_FCN, (bfd_byte *) ext->x_auxtype.x_auxtype);
    325       PUTWORD(abfd,  in->x_sym.x_fcnary.x_fcn.x_endndx.l,
    326               (bfd_byte *) ext->x_sym.x_fcnary.x_fcn.x_endndx);
    327     }
    328   if (ISFCN (type))
    329     PUTWORD (abfd, in->x_sym.x_misc.x_fsize,
    330              (bfd_byte *)  ext->x_sym.x_fcnary.x_fcn.x_fsize);
     1078
     1079  if (abfd->flags & EXEC_P)
     1080    {
     1081      char * buff;
     1082      bfd_size_type amount = bfd_coff_aoutsz (abfd);
     1083
     1084      buff = bfd_malloc (amount);
     1085      if (buff == NULL)
     1086        return FALSE;
     1087
     1088      bfd_coff_swap_aouthdr_out (abfd, (PTR) &internal_a, (PTR) buff);
     1089      amount = bfd_bwrite ((PTR) buff, amount, abfd);
     1090
     1091      free (buff);
     1092
     1093      if (amount != bfd_coff_aoutsz (abfd))
     1094        return FALSE;
     1095    }
     1096
     1097  return TRUE;
     1098}
     1099
     1100static bfd_boolean
     1101xcoff64_reloc_type_br (input_bfd, input_section, output_bfd, rel, sym, howto,
     1102                       val, addend, relocation, contents)
     1103     bfd *input_bfd;
     1104     asection *input_section;
     1105     bfd *output_bfd ATTRIBUTE_UNUSED;
     1106     struct internal_reloc *rel;
     1107     struct internal_syment *sym ATTRIBUTE_UNUSED;
     1108     struct reloc_howto_struct *howto;
     1109     bfd_vma val;
     1110     bfd_vma addend;
     1111     bfd_vma *relocation;
     1112     bfd_byte *contents;
     1113{
     1114  struct xcoff_link_hash_entry *h;
     1115
     1116  if (0 > rel->r_symndx)
     1117    return FALSE;
     1118
     1119  h = obj_xcoff_sym_hashes (input_bfd)[rel->r_symndx];
     1120
     1121  /* If we see an R_BR or R_RBR reloc which is jumping to global
     1122     linkage code, and it is followed by an appropriate cror nop
     1123     instruction, we replace the cror with ld r2,40(r1).  This
     1124     restores the TOC after the glink code.  Contrariwise, if the
     1125     call is followed by a ld r2,40(r1), but the call is not
     1126     going to global linkage code, we can replace the load with a
     1127     cror.  */
     1128  if (NULL != h
     1129      && bfd_link_hash_defined == h->root.type
     1130      && (rel->r_vaddr - input_section->vma + 8
     1131          <= input_section->_cooked_size))
     1132    {
     1133      bfd_byte *pnext;
     1134      unsigned long next;
     1135
     1136      pnext = contents + (rel->r_vaddr - input_section->vma) + 4;
     1137      next = bfd_get_32 (input_bfd, pnext);
     1138
     1139      /* The _ptrgl function is magic.  It is used by the AIX compiler to call
     1140         a function through a pointer.  */
     1141      if (h->smclas == XMC_GL || strcmp (h->root.root.string, "._ptrgl") == 0)
     1142        {
     1143          if (next == 0x4def7b82                        /* cror 15,15,15  */
     1144              || next == 0x4ffffb82                     /* cror 31,31,31  */
     1145              || next == 0x60000000)                    /* ori  r0,r0,0   */
     1146            bfd_put_32 (input_bfd, 0xe8410028, pnext);  /* ld   r2,40(r1) */
     1147        }
     1148      else
     1149        {
     1150          if (next == 0xe8410028)                       /* ld r2,40(r1)   */
     1151            bfd_put_32 (input_bfd, 0x60000000, pnext);  /* ori r0,r0,0    */
     1152        }
     1153    }
     1154  else if (NULL != h && bfd_link_hash_undefined == h->root.type)
     1155    {
     1156      /* Normally, this relocation is against a defined symbol.  In the
     1157         case where this is a partial link and the output section offset
     1158         is greater than 2^25, the linker will return an invalid error
     1159         message that the relocation has been truncated.  Yes it has been
     1160         truncated but no it not important.  For this case, disable the
     1161         overflow checking. */
     1162      howto->complain_on_overflow = complain_overflow_dont;
     1163    }
     1164
     1165  howto->pc_relative = TRUE;
     1166  howto->src_mask &= ~3;
     1167  howto->dst_mask = howto->src_mask;
     1168
     1169  /* A PC relative reloc includes the section address.  */
     1170  addend += input_section->vma;
     1171
     1172  *relocation = val + addend;
     1173  *relocation -= (input_section->output_section->vma
     1174                  + input_section->output_offset);
     1175  return TRUE;
     1176}
     1177
     1178/* This is the relocation function for the PowerPC64.
     1179   See xcoff_ppc_relocation_section for more information. */
     1180
     1181bfd_boolean
     1182xcoff64_ppc_relocate_section (output_bfd, info, input_bfd,
     1183                              input_section, contents, relocs, syms,
     1184                              sections)
     1185     bfd *output_bfd;
     1186     struct bfd_link_info *info;
     1187     bfd *input_bfd;
     1188     asection *input_section;
     1189     bfd_byte *contents;
     1190     struct internal_reloc *relocs;
     1191     struct internal_syment *syms;
     1192     asection **sections;
     1193{
     1194  struct internal_reloc *rel;
     1195  struct internal_reloc *relend;
     1196
     1197  rel = relocs;
     1198  relend = rel + input_section->reloc_count;
     1199  for (; rel < relend; rel++)
     1200    {
     1201      long symndx;
     1202      struct xcoff_link_hash_entry *h;
     1203      struct internal_syment *sym;
     1204      bfd_vma addend;
     1205      bfd_vma val;
     1206      struct reloc_howto_struct howto;
     1207      bfd_vma relocation;
     1208      bfd_vma value_to_relocate;
     1209      bfd_vma address;
     1210      bfd_byte *location;
     1211
     1212      /* Relocation type R_REF is a special relocation type which is
     1213         merely used to prevent garbage collection from occurring for
     1214         the csect including the symbol which it references.  */
     1215      if (rel->r_type == R_REF)
     1216        continue;
     1217
     1218      /* howto */
     1219      howto.type = rel->r_type;
     1220      howto.rightshift = 0;
     1221      howto.bitsize = (rel->r_size & 0x3f) + 1;
     1222      howto.size = howto.bitsize > 16 ? (howto.bitsize > 32 ? 4 : 2) : 1;
     1223      howto.pc_relative = FALSE;
     1224      howto.bitpos = 0;
     1225      howto.complain_on_overflow = (rel->r_size & 0x80
     1226                                    ? complain_overflow_signed
     1227                                    : complain_overflow_bitfield);
     1228      howto.special_function = NULL;
     1229      howto.name = "internal";
     1230      howto.partial_inplace = TRUE;
     1231      howto.src_mask = howto.dst_mask = N_ONES (howto.bitsize);
     1232      howto.pcrel_offset = FALSE;
     1233
     1234      /* symbol */
     1235      val = 0;
     1236      addend = 0;
     1237      h = NULL;
     1238      sym = NULL;
     1239      symndx = rel->r_symndx;
     1240
     1241      if (-1 != symndx)
     1242        {
     1243          asection *sec;
     1244
     1245          h = obj_xcoff_sym_hashes (input_bfd)[symndx];
     1246          sym = syms + symndx;
     1247          addend = - sym->n_value;
     1248
     1249          if (NULL == h)
     1250            {
     1251              sec = sections[symndx];
     1252              /* Hack to make sure we use the right TOC anchor value
     1253                 if this reloc is against the TOC anchor.  */
     1254              if (sec->name[3] == '0'
     1255                  && strcmp (sec->name, ".tc0") == 0)
     1256                val = xcoff_data (output_bfd)->toc;
     1257              else
     1258                val = (sec->output_section->vma
     1259                       + sec->output_offset
     1260                       + sym->n_value
     1261                       - sec->vma);
     1262            }
     1263          else
     1264            {
     1265              if (h->root.type == bfd_link_hash_defined
     1266                  || h->root.type == bfd_link_hash_defweak)
     1267                {
     1268                  sec = h->root.u.def.section;
     1269                  val = (h->root.u.def.value
     1270                         + sec->output_section->vma
     1271                         + sec->output_offset);
     1272                }
     1273              else if (h->root.type == bfd_link_hash_common)
     1274                {
     1275                  sec = h->root.u.c.p->section;
     1276                  val = (sec->output_section->vma
     1277                         + sec->output_offset);
     1278                }
     1279              else if ((0 == (h->flags & (XCOFF_DEF_DYNAMIC | XCOFF_IMPORT)))
     1280                       && ! info->relocateable)
     1281                {
     1282                  if (! ((*info->callbacks->undefined_symbol)
     1283                         (info, h->root.root.string, input_bfd, input_section,
     1284                          rel->r_vaddr - input_section->vma, TRUE)))
     1285                    return FALSE;
     1286
     1287                  /* Don't try to process the reloc.  It can't help, and
     1288                     it may generate another error.  */
     1289                  continue;
     1290                }
     1291            }
     1292        }
     1293
     1294      if (rel->r_type >= XCOFF_MAX_CALCULATE_RELOCATION
     1295          || !((*xcoff64_calculate_relocation[rel->r_type])
     1296              (input_bfd, input_section, output_bfd, rel, sym, &howto, val,
     1297               addend, &relocation, contents)))
     1298        return FALSE;
     1299
     1300      /* address */
     1301      address = rel->r_vaddr - input_section->vma;
     1302      location = contents + address;
     1303
     1304      if (address > input_section->_raw_size)
     1305        abort ();
     1306
     1307      /* Get the value we are going to relocate.  */
     1308      if (1 == howto.size)
     1309        value_to_relocate = bfd_get_16 (input_bfd, location);
     1310      else if (2 == howto.size)
     1311        value_to_relocate = bfd_get_32 (input_bfd, location);
     1312      else
     1313        value_to_relocate = bfd_get_64 (input_bfd, location);
     1314
     1315      /* overflow.
     1316
     1317         FIXME: We may drop bits during the addition
     1318         which we don't check for.  We must either check at every single
     1319         operation, which would be tedious, or we must do the computations
     1320         in a type larger than bfd_vma, which would be inefficient.  */
     1321
     1322      if ((unsigned int) howto.complain_on_overflow
     1323          >= XCOFF_MAX_COMPLAIN_OVERFLOW)
     1324        abort ();
     1325
     1326      if (((*xcoff_complain_overflow[howto.complain_on_overflow])
     1327           (input_bfd, value_to_relocate, relocation, &howto)))
     1328        {
     1329          const char *name;
     1330          char buf[SYMNMLEN + 1];
     1331          char reloc_type_name[10];
     1332
     1333          if (symndx == -1)
     1334            {
     1335              name = "*ABS*";
     1336            }
     1337          else if (h != NULL)
     1338            {
     1339              name = h->root.root.string;
     1340            }
     1341          else
     1342            {
     1343              name = _bfd_coff_internal_syment_name (input_bfd, sym, buf);
     1344              if (name == NULL)
     1345                name = "UNKNOWN";
     1346            }
     1347          sprintf (reloc_type_name, "0x%02x", rel->r_type);
     1348
     1349          if (! ((*info->callbacks->reloc_overflow)
     1350                 (info, name, reloc_type_name, (bfd_vma) 0, input_bfd,
     1351                  input_section, rel->r_vaddr - input_section->vma)))
     1352            return FALSE;
     1353        }
     1354
     1355      /* Add RELOCATION to the right bits of VALUE_TO_RELOCATE.  */
     1356      value_to_relocate = ((value_to_relocate & ~howto.dst_mask)
     1357                           | (((value_to_relocate & howto.src_mask)
     1358                               + relocation) & howto.dst_mask));
     1359
     1360      /* Put the value back in the object file.  */
     1361      if (1 == howto.size)
     1362        bfd_put_16 (input_bfd, value_to_relocate, location);
     1363      else if (2 == howto.size)
     1364        bfd_put_32 (input_bfd, value_to_relocate, location);
     1365      else
     1366        bfd_put_64 (input_bfd, value_to_relocate, location);
     1367
     1368    }
     1369  return TRUE;
     1370}
     1371
     1372
     1373
     1374/* The XCOFF reloc table.  Actually, XCOFF relocations specify the
     1375   bitsize and whether they are signed or not, along with a
     1376   conventional type.  This table is for the types, which are used for
     1377   different algorithms for putting in the reloc.  Many of these
     1378   relocs need special_function entries, which I have not written.  */
     1379
     1380reloc_howto_type xcoff64_howto_table[] =
     1381{
     1382  /* Standard 64 bit relocation.  */
     1383  HOWTO (R_POS,                 /* type */
     1384         0,                     /* rightshift */
     1385         4,                     /* size (0 = byte, 1 = short, 2 = long) */
     1386         64,                    /* bitsize */
     1387         FALSE,                 /* pc_relative */
     1388         0,                     /* bitpos */
     1389         complain_overflow_bitfield, /* complain_on_overflow */
     1390         0,                     /* special_function */
     1391         "R_POS_64",            /* name */
     1392         TRUE,                  /* partial_inplace */
     1393         MINUS_ONE,             /* src_mask */
     1394         MINUS_ONE,             /* dst_mask */
     1395         FALSE),                /* pcrel_offset */
     1396
     1397  /* 64 bit relocation, but store negative value.  */
     1398  HOWTO (R_NEG,                 /* type */
     1399         0,                     /* rightshift */
     1400         -4,                    /* size (0 = byte, 1 = short, 2 = long) */
     1401         64,                    /* bitsize */
     1402         FALSE,                 /* pc_relative */
     1403         0,                     /* bitpos */
     1404         complain_overflow_bitfield, /* complain_on_overflow */
     1405         0,                     /* special_function */
     1406         "R_NEG",               /* name */
     1407         TRUE,                  /* partial_inplace */
     1408         MINUS_ONE,             /* src_mask */
     1409         MINUS_ONE,             /* dst_mask */
     1410         FALSE),                /* pcrel_offset */
     1411
     1412  /* 32 bit PC relative relocation.  */
     1413  HOWTO (R_REL,                 /* type */
     1414         0,                     /* rightshift */
     1415         2,                     /* size (0 = byte, 1 = short, 2 = long) */
     1416         32,                    /* bitsize */
     1417         TRUE,                  /* pc_relative */
     1418         0,                     /* bitpos */
     1419         complain_overflow_signed, /* complain_on_overflow */
     1420         0,                     /* special_function */
     1421         "R_REL",               /* name */
     1422         TRUE,                  /* partial_inplace */
     1423         0xffffffff,            /* src_mask */
     1424         0xffffffff,            /* dst_mask */
     1425         FALSE),                /* pcrel_offset */
     1426
     1427  /* 16 bit TOC relative relocation.  */
     1428  HOWTO (R_TOC,                 /* type */
     1429         0,                     /* rightshift */
     1430         1,                     /* size (0 = byte, 1 = short, 2 = long) */
     1431         16,                    /* bitsize */
     1432         FALSE,                 /* pc_relative */
     1433         0,                     /* bitpos */
     1434         complain_overflow_bitfield, /* complain_on_overflow */
     1435         0,                     /* special_function */
     1436         "R_TOC",               /* name */
     1437         TRUE,                  /* partial_inplace */
     1438         0xffff,                /* src_mask */
     1439         0xffff,                /* dst_mask */
     1440         FALSE),                /* pcrel_offset */
     1441
     1442  /* I don't really know what this is.  */
     1443  HOWTO (R_RTB,                 /* type */
     1444         1,                     /* rightshift */
     1445         2,                     /* size (0 = byte, 1 = short, 2 = long) */
     1446         32,                    /* bitsize */
     1447         FALSE,                 /* pc_relative */
     1448         0,                     /* bitpos */
     1449         complain_overflow_bitfield, /* complain_on_overflow */
     1450         0,                     /* special_function */
     1451         "R_RTB",               /* name */
     1452         TRUE,                  /* partial_inplace */
     1453         0xffffffff,            /* src_mask */
     1454         0xffffffff,            /* dst_mask */
     1455         FALSE),                /* pcrel_offset */
     1456
     1457  /* External TOC relative symbol.  */
     1458  HOWTO (R_GL,                  /* type */
     1459         0,                     /* rightshift */
     1460         1,                     /* size (0 = byte, 1 = short, 2 = long) */
     1461         16,                    /* bitsize */
     1462         FALSE,                 /* pc_relative */
     1463         0,                     /* bitpos */
     1464         complain_overflow_bitfield, /* complain_on_overflow */
     1465         0,                     /* special_function */
     1466         "R_GL",                /* name */
     1467         TRUE,                  /* partial_inplace */
     1468         0xffff,                /* src_mask */
     1469         0xffff,                /* dst_mask */
     1470         FALSE),                /* pcrel_offset */
     1471
     1472  /* Local TOC relative symbol.  */
     1473  HOWTO (R_TCL,                 /* type */
     1474         0,                     /* rightshift */
     1475         1,                     /* size (0 = byte, 1 = short, 2 = long) */
     1476         16,                    /* bitsize */
     1477         FALSE,                 /* pc_relative */
     1478         0,                     /* bitpos */
     1479         complain_overflow_bitfield, /* complain_on_overflow */
     1480         0,                     /* special_function */
     1481         "R_TCL",               /* name */
     1482         TRUE,                  /* partial_inplace */
     1483         0xffff,                /* src_mask */
     1484         0xffff,                /* dst_mask */
     1485         FALSE),                /* pcrel_offset */
     1486
     1487  EMPTY_HOWTO (7),
     1488
     1489  /* Non modifiable absolute branch.  */
     1490  HOWTO (R_BA,                  /* type */
     1491         0,                     /* rightshift */
     1492         2,                     /* size (0 = byte, 1 = short, 2 = long) */
     1493         26,                    /* bitsize */
     1494         FALSE,                 /* pc_relative */
     1495         0,                     /* bitpos */
     1496         complain_overflow_bitfield, /* complain_on_overflow */
     1497         0,                     /* special_function */
     1498         "R_BA_26",             /* name */
     1499         TRUE,                  /* partial_inplace */
     1500         0x03fffffc,            /* src_mask */
     1501         0x03fffffc,            /* dst_mask */
     1502         FALSE),                /* pcrel_offset */
     1503
     1504  EMPTY_HOWTO (9),
     1505
     1506  /* Non modifiable relative branch.  */
     1507  HOWTO (R_BR,                  /* type */
     1508         0,                     /* rightshift */
     1509         2,                     /* size (0 = byte, 1 = short, 2 = long) */
     1510         26,                    /* bitsize */
     1511         TRUE,                  /* pc_relative */
     1512         0,                     /* bitpos */
     1513         complain_overflow_signed, /* complain_on_overflow */
     1514         0,                     /* special_function */
     1515         "R_BR",                /* name */
     1516         TRUE,                  /* partial_inplace */
     1517         0x03fffffc,            /* src_mask */
     1518         0x03fffffc,            /* dst_mask */
     1519         FALSE),                /* pcrel_offset */
     1520
     1521  EMPTY_HOWTO (0xb),
     1522
     1523  /* Indirect load.  */
     1524  HOWTO (R_RL,                  /* type */
     1525         0,                     /* rightshift */
     1526         1,                     /* size (0 = byte, 1 = short, 2 = long) */
     1527         16,                    /* bitsize */
     1528         FALSE,                 /* pc_relative */
     1529         0,                     /* bitpos */
     1530         complain_overflow_bitfield, /* complain_on_overflow */
     1531         0,                     /* special_function */
     1532         "R_RL",                /* name */
     1533         TRUE,                  /* partial_inplace */
     1534         0xffff,                /* src_mask */
     1535         0xffff,                /* dst_mask */
     1536         FALSE),                /* pcrel_offset */
     1537
     1538  /* Load address.  */
     1539  HOWTO (R_RLA,                 /* type */
     1540         0,                     /* rightshift */
     1541         1,                     /* size (0 = byte, 1 = short, 2 = long) */
     1542         16,                    /* bitsize */
     1543         FALSE,                 /* pc_relative */
     1544         0,                     /* bitpos */
     1545         complain_overflow_bitfield, /* complain_on_overflow */
     1546         0,                     /* special_function */
     1547         "R_RLA",               /* name */
     1548         TRUE,                  /* partial_inplace */
     1549         0xffff,                /* src_mask */
     1550         0xffff,                /* dst_mask */
     1551         FALSE),                /* pcrel_offset */
     1552
     1553  EMPTY_HOWTO (0xe),
     1554
     1555  /* Non-relocating reference.  */
     1556  HOWTO (R_REF,                 /* type */
     1557         0,                     /* rightshift */
     1558         2,                     /* size (0 = byte, 1 = short, 2 = long) */
     1559         32,                    /* bitsize */
     1560         FALSE,                 /* pc_relative */
     1561         0,                     /* bitpos */
     1562         complain_overflow_dont, /* complain_on_overflow */
     1563         0,                     /* special_function */
     1564         "R_REF",               /* name */
     1565         FALSE,                 /* partial_inplace */
     1566         0,                     /* src_mask */
     1567         0,                     /* dst_mask */
     1568         FALSE),                /* pcrel_offset */
     1569
     1570  EMPTY_HOWTO (0x10),
     1571  EMPTY_HOWTO (0x11),
     1572
     1573  /* TOC relative indirect load.  */
     1574  HOWTO (R_TRL,                 /* type */
     1575         0,                     /* rightshift */
     1576         1,                     /* size (0 = byte, 1 = short, 2 = long) */
     1577         16,                    /* bitsize */
     1578         FALSE,                 /* pc_relative */
     1579         0,                     /* bitpos */
     1580         complain_overflow_bitfield, /* complain_on_overflow */
     1581         0,                     /* special_function */
     1582         "R_TRL",               /* name */
     1583         TRUE,                  /* partial_inplace */
     1584         0xffff,                /* src_mask */
     1585         0xffff,                /* dst_mask */
     1586         FALSE),                /* pcrel_offset */
     1587
     1588  /* TOC relative load address.  */
     1589  HOWTO (R_TRLA,                /* type */
     1590         0,                     /* rightshift */
     1591         1,                     /* size (0 = byte, 1 = short, 2 = long) */
     1592         16,                    /* bitsize */
     1593         FALSE,                 /* pc_relative */
     1594         0,                     /* bitpos */
     1595         complain_overflow_bitfield, /* complain_on_overflow */
     1596         0,                     /* special_function */
     1597         "R_TRLA",              /* name */
     1598         TRUE,                  /* partial_inplace */
     1599         0xffff,                /* src_mask */
     1600         0xffff,                /* dst_mask */
     1601         FALSE),                /* pcrel_offset */
     1602
     1603  /* Modifiable relative branch.  */
     1604  HOWTO (R_RRTBI,               /* type */
     1605         1,                     /* rightshift */
     1606         2,                     /* size (0 = byte, 1 = short, 2 = long) */
     1607         32,                    /* bitsize */
     1608         FALSE,                 /* pc_relative */
     1609         0,                     /* bitpos */
     1610         complain_overflow_bitfield, /* complain_on_overflow */
     1611         0,                     /* special_function */
     1612         "R_RRTBI",             /* name */
     1613         TRUE,                  /* partial_inplace */
     1614         0xffffffff,            /* src_mask */
     1615         0xffffffff,            /* dst_mask */
     1616         FALSE),                /* pcrel_offset */
     1617
     1618  /* Modifiable absolute branch.  */
     1619  HOWTO (R_RRTBA,               /* type */
     1620         1,                     /* rightshift */
     1621         2,                     /* size (0 = byte, 1 = short, 2 = long) */
     1622         32,                    /* bitsize */
     1623         FALSE,                 /* pc_relative */
     1624         0,                     /* bitpos */
     1625         complain_overflow_bitfield, /* complain_on_overflow */
     1626         0,                     /* special_function */
     1627         "R_RRTBA",             /* name */
     1628         TRUE,                  /* partial_inplace */
     1629         0xffffffff,            /* src_mask */
     1630         0xffffffff,            /* dst_mask */
     1631         FALSE),                /* pcrel_offset */
     1632
     1633  /* Modifiable call absolute indirect.  */
     1634  HOWTO (R_CAI,                 /* type */
     1635         0,                     /* rightshift */
     1636         1,                     /* size (0 = byte, 1 = short, 2 = long) */
     1637         16,                    /* bitsize */
     1638         FALSE,                 /* pc_relative */
     1639         0,                     /* bitpos */
     1640         complain_overflow_bitfield, /* complain_on_overflow */
     1641         0,                     /* special_function */
     1642         "R_CAI",               /* name */
     1643         TRUE,                  /* partial_inplace */
     1644         0xffff,                /* src_mask */
     1645         0xffff,                /* dst_mask */
     1646         FALSE),                /* pcrel_offset */
     1647
     1648  /* Modifiable call relative.  */
     1649  HOWTO (R_CREL,                /* type */
     1650         0,                     /* rightshift */
     1651         1,                     /* size (0 = byte, 1 = short, 2 = long) */
     1652         16,                    /* bitsize */
     1653         FALSE,                 /* pc_relative */
     1654         0,                     /* bitpos */
     1655         complain_overflow_bitfield, /* complain_on_overflow */
     1656         0,                     /* special_function */
     1657         "R_CREL",              /* name */
     1658         TRUE,                  /* partial_inplace */
     1659         0xffff,                /* src_mask */
     1660         0xffff,                /* dst_mask */
     1661         FALSE),                /* pcrel_offset */
     1662
     1663  /* Modifiable branch absolute.  */
     1664  HOWTO (R_RBA,                 /* type */
     1665         0,                     /* rightshift */
     1666         2,                     /* size (0 = byte, 1 = short, 2 = long) */
     1667         26,                    /* bitsize */
     1668         FALSE,                 /* pc_relative */
     1669         0,                     /* bitpos */
     1670         complain_overflow_bitfield, /* complain_on_overflow */
     1671         0,                     /* special_function */
     1672         "R_RBA",               /* name */
     1673         TRUE,                  /* partial_inplace */
     1674         0x03fffffc,            /* src_mask */
     1675         0x03fffffc,            /* dst_mask */
     1676         FALSE),                /* pcrel_offset */
     1677
     1678  /* Modifiable branch absolute.  */
     1679  HOWTO (R_RBAC,                /* type */
     1680         0,                     /* rightshift */
     1681         2,                     /* size (0 = byte, 1 = short, 2 = long) */
     1682         32,                    /* bitsize */
     1683         FALSE,                 /* pc_relative */
     1684         0,                     /* bitpos */
     1685         complain_overflow_bitfield, /* complain_on_overflow */
     1686         0,                     /* special_function */
     1687         "R_RBAC",              /* name */
     1688         TRUE,                  /* partial_inplace */
     1689         0xffffffff,            /* src_mask */
     1690         0xffffffff,            /* dst_mask */
     1691         FALSE),                /* pcrel_offset */
     1692
     1693  /* Modifiable branch relative.  */
     1694  HOWTO (R_RBR,                 /* type */
     1695         0,                     /* rightshift */
     1696         2,                     /* size (0 = byte, 1 = short, 2 = long) */
     1697         26,                    /* bitsize */
     1698         FALSE,                 /* pc_relative */
     1699         0,                     /* bitpos */
     1700         complain_overflow_signed, /* complain_on_overflow */
     1701         0,                     /* special_function */
     1702         "R_RBR_26",            /* name */
     1703         TRUE,                  /* partial_inplace */
     1704         0x03fffffc,            /* src_mask */
     1705         0x03fffffc,            /* dst_mask */
     1706         FALSE),                /* pcrel_offset */
     1707
     1708  /* Modifiable branch absolute.  */
     1709  HOWTO (R_RBRC,                /* type */
     1710         0,                     /* rightshift */
     1711         1,                     /* size (0 = byte, 1 = short, 2 = long) */
     1712         16,                    /* bitsize */
     1713         FALSE,                 /* pc_relative */
     1714         0,                     /* bitpos */
     1715         complain_overflow_bitfield, /* complain_on_overflow */
     1716         0,                     /* special_function */
     1717         "R_RBRC",              /* name */
     1718         TRUE,                  /* partial_inplace */
     1719         0xffff,                /* src_mask */
     1720         0xffff,                /* dst_mask */
     1721         FALSE),                /* pcrel_offset */
     1722
     1723  HOWTO (R_POS,                 /* type */
     1724         0,                     /* rightshift */
     1725         2,                     /* size (0 = byte, 1 = short, 2 = long) */
     1726         32,                    /* bitsize */
     1727         FALSE,                 /* pc_relative */
     1728         0,                     /* bitpos */
     1729         complain_overflow_bitfield, /* complain_on_overflow */
     1730         0,                     /* special_function */
     1731         "R_POS_32",            /* name */
     1732         TRUE,                  /* partial_inplace */
     1733         0xffffffff,            /* src_mask */
     1734         0xffffffff,            /* dst_mask */
     1735         FALSE),                /* pcrel_offset */
     1736
     1737  /* 16 bit Non modifiable absolute branch.  */
     1738  HOWTO (R_BA,                  /* type */
     1739         0,                     /* rightshift */
     1740         1,                     /* size (0 = byte, 1 = short, 2 = long) */
     1741         16,                    /* bitsize */
     1742         FALSE,                 /* pc_relative */
     1743         0,                     /* bitpos */
     1744         complain_overflow_bitfield, /* complain_on_overflow */
     1745         0,                     /* special_function */
     1746         "R_BA_16",             /* name */
     1747         TRUE,                  /* partial_inplace */
     1748         0xfffc,                /* src_mask */
     1749         0xfffc,                /* dst_mask */
     1750         FALSE),                /* pcrel_offset */
     1751
     1752  /* Modifiable branch relative.  */
     1753  HOWTO (R_RBR,                 /* type */
     1754         0,                     /* rightshift */
     1755         1,                     /* size (0 = byte, 1 = short, 2 = long) */
     1756         16,                    /* bitsize */
     1757         FALSE,                 /* pc_relative */
     1758         0,                     /* bitpos */
     1759         complain_overflow_signed, /* complain_on_overflow */
     1760         0,                     /* special_function */
     1761         "R_RBR_16",            /* name */
     1762         TRUE,                  /* partial_inplace */
     1763         0xffff,                /* src_mask */
     1764         0xffff,                /* dst_mask */
     1765         FALSE),                /* pcrel_offset */
     1766
     1767  /* Modifiable branch absolute.  */
     1768  HOWTO (R_RBA,                 /* type */
     1769         0,                     /* rightshift */
     1770         1,                     /* size (0 = byte, 1 = short, 2 = long) */
     1771         16,                    /* bitsize */
     1772         FALSE,                 /* pc_relative */
     1773         0,                     /* bitpos */
     1774         complain_overflow_bitfield, /* complain_on_overflow */
     1775         0,                     /* special_function */
     1776         "R_RBA_16",            /* name */
     1777         TRUE,                  /* partial_inplace */
     1778         0xffff,                /* src_mask */
     1779         0xffff,                /* dst_mask */
     1780         FALSE),                /* pcrel_offset */
     1781
     1782};
     1783
     1784void
     1785xcoff64_rtype2howto (relent, internal)
     1786     arelent *relent;
     1787     struct internal_reloc *internal;
     1788{
     1789  if (internal->r_type > R_RBRC)
     1790    abort ();
     1791
     1792  /* Default howto layout works most of the time */
     1793  relent->howto = &xcoff64_howto_table[internal->r_type];
     1794
     1795  /* Special case some 16 bit reoloc */
     1796  if (15 == (internal->r_size & 0x3f))
     1797    {
     1798      if (R_BA == internal->r_type)
     1799        relent->howto = &xcoff64_howto_table[0x1d];
     1800      else if (R_RBR == internal->r_type)
     1801        relent->howto = &xcoff64_howto_table[0x1e];
     1802      else if (R_RBA == internal->r_type)
     1803        relent->howto = &xcoff64_howto_table[0x1f];
     1804    }
     1805  /* Special case 32 bit */
     1806  else if (31 == (internal->r_size & 0x3f))
     1807    {
     1808      if (R_POS == internal->r_type)
     1809        relent->howto = &xcoff64_howto_table[0x1c];
     1810    }
     1811
     1812  /* The r_size field of an XCOFF reloc encodes the bitsize of the
     1813     relocation, as well as indicating whether it is signed or not.
     1814     Doublecheck that the relocation information gathered from the
     1815     type matches this information.  The bitsize is not significant
     1816     for R_REF relocs.  */
     1817  if (relent->howto->dst_mask != 0
     1818      && (relent->howto->bitsize
     1819          != ((unsigned int) internal->r_size & 0x3f) + 1))
     1820    abort ();
     1821}
     1822
     1823reloc_howto_type *
     1824xcoff64_reloc_type_lookup (abfd, code)
     1825     bfd *abfd ATTRIBUTE_UNUSED;
     1826     bfd_reloc_code_real_type code;
     1827{
     1828  switch (code)
     1829    {
     1830    case BFD_RELOC_PPC_B26:
     1831      return &xcoff64_howto_table[0xa];
     1832    case BFD_RELOC_PPC_BA16:
     1833      return &xcoff64_howto_table[0x1d];
     1834    case BFD_RELOC_PPC_BA26:
     1835      return &xcoff64_howto_table[8];
     1836    case BFD_RELOC_PPC_TOC16:
     1837      return &xcoff64_howto_table[3];
     1838    case BFD_RELOC_32:
     1839    case BFD_RELOC_CTOR:
     1840      return &xcoff64_howto_table[0x1c];
     1841    case BFD_RELOC_64:
     1842      return &xcoff64_howto_table[0];
     1843    default:
     1844      return NULL;
     1845    }
     1846}
     1847
     1848/* Read in the armap of an XCOFF archive.  */
     1849
     1850static bfd_boolean
     1851xcoff64_slurp_armap (abfd)
     1852     bfd *abfd;
     1853{
     1854  file_ptr off;
     1855  size_t namlen;
     1856  bfd_size_type sz, amt;
     1857  bfd_byte *contents, *cend;
     1858  bfd_vma c, i;
     1859  carsym *arsym;
     1860  bfd_byte *p;
     1861  file_ptr pos;
     1862
     1863  /* This is for the new format.  */
     1864  struct xcoff_ar_hdr_big hdr;
     1865
     1866  if (xcoff_ardata (abfd) == NULL)
     1867    {
     1868      bfd_has_map (abfd) = FALSE;
     1869      return TRUE;
     1870    }
     1871
     1872  off = bfd_scan_vma (xcoff_ardata_big (abfd)->symoff64,
     1873                      (const char **) NULL, 10);
     1874  if (off == 0)
     1875    {
     1876      bfd_has_map (abfd) = FALSE;
     1877      return TRUE;
     1878    }
     1879
     1880  if (bfd_seek (abfd, off, SEEK_SET) != 0)
     1881    return FALSE;
     1882
     1883  /* The symbol table starts with a normal archive header.  */
     1884  if (bfd_bread ((PTR) &hdr, (bfd_size_type) SIZEOF_AR_HDR_BIG, abfd)
     1885      != SIZEOF_AR_HDR_BIG)
     1886    return FALSE;
     1887
     1888  /* Skip the name (normally empty).  */
     1889  namlen = strtol (hdr.namlen, (char **) NULL, 10);
     1890  pos = ((namlen + 1) & ~(size_t) 1) + SXCOFFARFMAG;
     1891  if (bfd_seek (abfd, pos, SEEK_CUR) != 0)
     1892    return FALSE;
     1893
     1894  sz = bfd_scan_vma (hdr.size, (const char **) NULL, 10);
     1895
     1896  /* Read in the entire symbol table.  */
     1897  contents = (bfd_byte *) bfd_alloc (abfd, sz);
     1898  if (contents == NULL)
     1899    return FALSE;
     1900  if (bfd_bread ((PTR) contents, sz, abfd) != sz)
     1901    return FALSE;
     1902
     1903  /* The symbol table starts with an eight byte count.  */
     1904  c = H_GET_64 (abfd, contents);
     1905
     1906  if (c * 8 >= sz)
     1907    {
     1908      bfd_set_error (bfd_error_bad_value);
     1909      return FALSE;
     1910    }
     1911  amt = c;
     1912  amt *= sizeof (carsym);
     1913  bfd_ardata (abfd)->symdefs = (carsym *) bfd_alloc (abfd, amt);
     1914  if (bfd_ardata (abfd)->symdefs == NULL)
     1915    return FALSE;
     1916
     1917  /* After the count comes a list of eight byte file offsets.  */
     1918  for (i = 0, arsym = bfd_ardata (abfd)->symdefs, p = contents + 8;
     1919       i < c;
     1920       ++i, ++arsym, p += 8)
     1921    arsym->file_offset = H_GET_64 (abfd, p);
     1922
     1923  /* After the file offsets come null terminated symbol names.  */
     1924  cend = contents + sz;
     1925  for (i = 0, arsym = bfd_ardata (abfd)->symdefs;
     1926       i < c;
     1927       ++i, ++arsym, p += strlen ((char *) p) + 1)
     1928    {
     1929      if (p >= cend)
     1930        {
     1931          bfd_set_error (bfd_error_bad_value);
     1932          return FALSE;
     1933        }
     1934      arsym->name = (char *) p;
     1935    }
     1936
     1937  bfd_ardata (abfd)->symdef_count = c;
     1938  bfd_has_map (abfd) = TRUE;
     1939
     1940  return TRUE;
     1941}
     1942
     1943
     1944/* See if this is an NEW XCOFF archive.  */
     1945
     1946static const bfd_target *
     1947xcoff64_archive_p (abfd)
     1948     bfd *abfd;
     1949{
     1950  struct artdata *tdata_hold;
     1951  char magic[SXCOFFARMAG];
     1952  /* This is the new format.  */
     1953  struct xcoff_ar_file_hdr_big hdr;
     1954  bfd_size_type amt = SXCOFFARMAG;
     1955
     1956  if (bfd_bread ((PTR) magic, amt, abfd) != amt)
     1957    {
     1958      if (bfd_get_error () != bfd_error_system_call)
     1959        bfd_set_error (bfd_error_wrong_format);
     1960      return NULL;
     1961    }
     1962
     1963  if (strncmp (magic, XCOFFARMAGBIG, SXCOFFARMAG) != 0)
     1964    {
     1965      bfd_set_error (bfd_error_wrong_format);
     1966      return NULL;
     1967    }
     1968
     1969  /* Copy over the magic string.  */
     1970  memcpy (hdr.magic, magic, SXCOFFARMAG);
     1971
     1972  /* Now read the rest of the file header.  */
     1973  amt = SIZEOF_AR_FILE_HDR_BIG - SXCOFFARMAG;
     1974  if (bfd_bread ((PTR) &hdr.memoff, amt, abfd) != amt)
     1975    {
     1976      if (bfd_get_error () != bfd_error_system_call)
     1977        bfd_set_error (bfd_error_wrong_format);
     1978      return NULL;
     1979    }
     1980
     1981  tdata_hold = bfd_ardata (abfd);
     1982
     1983  amt = sizeof (struct artdata);
     1984  bfd_ardata (abfd) = (struct artdata *) bfd_zalloc (abfd, amt);
     1985  if (bfd_ardata (abfd) == (struct artdata *) NULL)
     1986    goto error_ret_restore;
     1987
     1988  bfd_ardata (abfd)->cache = NULL;
     1989  bfd_ardata (abfd)->archive_head = NULL;
     1990  bfd_ardata (abfd)->symdefs = NULL;
     1991  bfd_ardata (abfd)->extended_names = NULL;
     1992  bfd_ardata (abfd)->first_file_filepos = bfd_scan_vma (hdr.firstmemoff,
     1993                                                        (const char **) NULL,
     1994                                                        10);
     1995
     1996  amt = SIZEOF_AR_FILE_HDR_BIG;
     1997  bfd_ardata (abfd)->tdata = bfd_zalloc (abfd, amt);
     1998  if (bfd_ardata (abfd)->tdata == NULL)
     1999    goto error_ret;
     2000
     2001  memcpy (bfd_ardata (abfd)->tdata, &hdr, SIZEOF_AR_FILE_HDR_BIG);
     2002
     2003  if (! xcoff64_slurp_armap (abfd))
     2004    {
     2005    error_ret:
     2006      bfd_release (abfd, bfd_ardata (abfd));
     2007    error_ret_restore:
     2008      bfd_ardata (abfd) = tdata_hold;
     2009      return NULL;
     2010    }
     2011
     2012  return abfd->xvec;
     2013}
     2014
     2015
     2016/* Open the next element in an XCOFF archive.  */
     2017
     2018static bfd *
     2019xcoff64_openr_next_archived_file (archive, last_file)
     2020     bfd *archive;
     2021     bfd *last_file;
     2022{
     2023  bfd_vma filestart;
     2024
     2025  if ((xcoff_ardata (archive) == NULL)
     2026      || ! xcoff_big_format_p (archive))
     2027    {
     2028      bfd_set_error (bfd_error_invalid_operation);
     2029      return NULL;
     2030    }
     2031
     2032  if (last_file == NULL)
     2033    {
     2034      filestart = bfd_ardata (archive)->first_file_filepos;
     2035    }
    3312036  else
    3322037    {
    333       bfd_h_put_32(abfd, in->x_sym.x_misc.x_lnsz.x_lnno,
    334               (bfd_byte *)ext->x_sym.x_fcnary.x_lnsz.x_lnno);
    335       bfd_h_put_16(abfd, in->x_sym.x_misc.x_lnsz.x_size,
    336               (bfd_byte *)ext->x_sym.x_fcnary.x_lnsz.x_size);
    337     }
    338 
    339 end:
    340   return bfd_coff_auxesz (abfd);
    341 }
    342 
    343 #define coff_SWAP_sym_in xcoff64_swap_sym_in
    344 #define coff_SWAP_sym_out xcoff64_swap_sym_out
    345 #define coff_SWAP_aux_in xcoff64_swap_aux_in
    346 #define coff_SWAP_aux_out xcoff64_swap_aux_out
    347 
    348 #define TARGET_NAME "aixcoff64-rs6000"
    349 #define TARGET_SYM rs6000coff64_vec
    350 
    351 #include "xcoff-target.h"
     2038      filestart = bfd_scan_vma (arch_xhdr_big (last_file)->nextoff,
     2039                                (const char **) NULL, 10);
     2040    }
     2041
     2042  if (filestart == 0
     2043      || filestart == bfd_scan_vma (xcoff_ardata_big (archive)->memoff,
     2044                                    (const char **) NULL, 10)
     2045      || filestart == bfd_scan_vma (xcoff_ardata_big (archive)->symoff,
     2046                                    (const char **) NULL, 10))
     2047    {
     2048      bfd_set_error (bfd_error_no_more_archived_files);
     2049      return NULL;
     2050    }
     2051
     2052  return _bfd_get_elt_at_filepos (archive, (file_ptr) filestart);
     2053}
     2054
     2055/* We can't use the usual coff_sizeof_headers routine, because AIX
     2056   always uses an a.out header.  */
     2057
     2058/*ARGSUSED*/
     2059static int
     2060xcoff64_sizeof_headers (abfd, reloc)
     2061     bfd *abfd;
     2062     bfd_boolean reloc ATTRIBUTE_UNUSED;
     2063{
     2064  int size;
     2065
     2066  size = bfd_coff_filhsz (abfd);
     2067
     2068  /* Don't think the small aout header can be used since some of the
     2069     old elements have been reordered past the end of the old coff
     2070     small aout size.  */
     2071
     2072  if (xcoff_data (abfd)->full_aouthdr)
     2073    size += bfd_coff_aoutsz (abfd);
     2074
     2075  size += abfd->section_count * bfd_coff_scnhsz (abfd);
     2076  return size;
     2077}
     2078
     2079
     2080
     2081static asection *
     2082xcoff64_create_csect_from_smclas (abfd, aux, symbol_name)
     2083     bfd *abfd;
     2084     union internal_auxent *aux;
     2085     const char *symbol_name;
     2086{
     2087  asection *return_value = NULL;
     2088
     2089  /* Changes from 32 :
     2090     .sv == 8, is only for 32 bit programs
     2091     .ti == 12 and .tb == 13 are now reserved.  */
     2092  static const char *names[19] =
     2093  {
     2094    ".pr", ".ro", ".db", ".tc", ".ua", ".rw", ".gl", ".xo",
     2095    NULL, ".bs", ".ds", ".uc", NULL,  NULL,  NULL,  ".tc0",
     2096    ".td", ".sv64", ".sv3264"
     2097  };
     2098
     2099  if ((19 >= aux->x_csect.x_smclas)
     2100      && (NULL != names[aux->x_csect.x_smclas]))
     2101    {
     2102
     2103      return_value = bfd_make_section_anyway
     2104        (abfd, names[aux->x_csect.x_smclas]);
     2105
     2106    }
     2107  else
     2108    {
     2109      (*_bfd_error_handler)
     2110        (_("%s: symbol `%s' has unrecognized smclas %d"),
     2111         bfd_archive_filename (abfd), symbol_name, aux->x_csect.x_smclas);
     2112      bfd_set_error (bfd_error_bad_value);
     2113    }
     2114
     2115  return return_value;
     2116}
     2117
     2118static bfd_boolean
     2119xcoff64_is_lineno_count_overflow (abfd, value)
     2120     bfd *abfd ATTRIBUTE_UNUSED;
     2121     bfd_vma value ATTRIBUTE_UNUSED;
     2122{
     2123  return FALSE;
     2124}
     2125
     2126static bfd_boolean
     2127xcoff64_is_reloc_count_overflow (abfd, value)
     2128     bfd *abfd ATTRIBUTE_UNUSED;
     2129     bfd_vma value ATTRIBUTE_UNUSED;
     2130{
     2131  return FALSE;
     2132}
     2133
     2134static bfd_vma
     2135xcoff64_loader_symbol_offset (abfd, ldhdr)
     2136     bfd *abfd ATTRIBUTE_UNUSED;
     2137     struct internal_ldhdr *ldhdr;
     2138{
     2139  return (ldhdr->l_symoff);
     2140}
     2141
     2142static bfd_vma
     2143xcoff64_loader_reloc_offset (abfd, ldhdr)
     2144     bfd *abfd ATTRIBUTE_UNUSED;
     2145     struct internal_ldhdr *ldhdr;
     2146{
     2147  return (ldhdr->l_rldoff);
     2148}
     2149
     2150static bfd_boolean
     2151xcoff64_bad_format_hook (abfd, filehdr)
     2152     bfd * abfd;
     2153     PTR filehdr;
     2154{
     2155  struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
     2156
     2157  /* Check flavor first.  */
     2158  if (bfd_get_flavour (abfd) != bfd_target_xcoff_flavour)
     2159    return FALSE;
     2160
     2161  if (bfd_xcoff_magic_number (abfd) != internal_f->f_magic)
     2162    return FALSE;
     2163
     2164  return TRUE;
     2165}
     2166
     2167static bfd_boolean
     2168xcoff64_generate_rtinit (abfd, init, fini, rtld)
     2169     bfd *abfd;
     2170     const char *init;
     2171     const char *fini;
     2172     bfd_boolean rtld;
     2173{
     2174  bfd_byte filehdr_ext[FILHSZ];
     2175  bfd_byte scnhdr_ext[SCNHSZ * 3];
     2176  bfd_byte syment_ext[SYMESZ * 10];
     2177  bfd_byte reloc_ext[RELSZ * 3];
     2178  bfd_byte *data_buffer;
     2179  bfd_size_type data_buffer_size;
     2180  bfd_byte *string_table, *st_tmp;
     2181  bfd_size_type string_table_size;
     2182  bfd_vma val;
     2183  size_t initsz, finisz;
     2184  struct internal_filehdr filehdr;
     2185  struct internal_scnhdr text_scnhdr;
     2186  struct internal_scnhdr data_scnhdr;
     2187  struct internal_scnhdr bss_scnhdr;
     2188  struct internal_syment syment;
     2189  union internal_auxent auxent;
     2190  struct internal_reloc reloc;
     2191
     2192  char *text_name = ".text";
     2193  char *data_name = ".data";
     2194  char *bss_name = ".bss";
     2195  char *rtinit_name = "__rtinit";
     2196  char *rtld_name = "__rtld";
     2197
     2198  if (! bfd_xcoff_rtinit_size (abfd))
     2199    return FALSE;
     2200
     2201  initsz = (init == NULL ? 0 : 1 + strlen (init));
     2202  finisz = (fini == NULL ? 0 : 1 + strlen (fini));
     2203
     2204  /* File header.  */
     2205  memset (filehdr_ext, 0, FILHSZ);
     2206  memset (&filehdr, 0, sizeof (struct internal_filehdr));
     2207  filehdr.f_magic = bfd_xcoff_magic_number (abfd);
     2208  filehdr.f_nscns = 3;
     2209  filehdr.f_timdat = 0;
     2210  filehdr.f_nsyms = 0;  /* at least 6, no more than 8 */
     2211  filehdr.f_symptr = 0; /* set below */
     2212  filehdr.f_opthdr = 0;
     2213  filehdr.f_flags = 0;
     2214
     2215  /* Section headers.  */
     2216  memset (scnhdr_ext, 0, 3 * SCNHSZ);
     2217
     2218  /* Text.  */
     2219  memset (&text_scnhdr, 0, sizeof (struct internal_scnhdr));
     2220  memcpy (text_scnhdr.s_name, text_name, strlen (text_name));
     2221  text_scnhdr.s_paddr = 0;
     2222  text_scnhdr.s_vaddr = 0;
     2223  text_scnhdr.s_size = 0;
     2224  text_scnhdr.s_scnptr = 0;
     2225  text_scnhdr.s_relptr = 0;
     2226  text_scnhdr.s_lnnoptr = 0;
     2227  text_scnhdr.s_nreloc = 0;
     2228  text_scnhdr.s_nlnno = 0;
     2229  text_scnhdr.s_flags = STYP_TEXT;
     2230
     2231  /* Data.  */
     2232  memset (&data_scnhdr, 0, sizeof (struct internal_scnhdr));
     2233  memcpy (data_scnhdr.s_name, data_name, strlen (data_name));
     2234  data_scnhdr.s_paddr = 0;
     2235  data_scnhdr.s_vaddr = 0;
     2236  data_scnhdr.s_size = 0;    /* set below */
     2237  data_scnhdr.s_scnptr = FILHSZ + 3 * SCNHSZ;
     2238  data_scnhdr.s_relptr = 0;  /* set below */
     2239  data_scnhdr.s_lnnoptr = 0;
     2240  data_scnhdr.s_nreloc = 0;  /* either 1 or 2 */
     2241  data_scnhdr.s_nlnno = 0;
     2242  data_scnhdr.s_flags = STYP_DATA;
     2243
     2244  /* Bss.  */
     2245  memset (&bss_scnhdr, 0, sizeof (struct internal_scnhdr));
     2246  memcpy (bss_scnhdr.s_name, bss_name, strlen (bss_name));
     2247  bss_scnhdr.s_paddr = 0; /* set below */
     2248  bss_scnhdr.s_vaddr = 0; /* set below */
     2249  bss_scnhdr.s_size = 0;  /* set below */
     2250  bss_scnhdr.s_scnptr = 0;
     2251  bss_scnhdr.s_relptr = 0;
     2252  bss_scnhdr.s_lnnoptr = 0;
     2253  bss_scnhdr.s_nreloc = 0;
     2254  bss_scnhdr.s_nlnno = 0;
     2255  bss_scnhdr.s_flags = STYP_BSS;
     2256
     2257  /* .data
     2258     0x0000           0x00000000 : rtl
     2259     0x0004           0x00000000 :
     2260     0x0008           0x00000018 : offset to init, or 0
     2261     0x000C           0x00000038 : offset to fini, or 0
     2262     0x0010           0x00000010 : size of descriptor
     2263     0x0014           0x00000000 : pad
     2264     0x0018           0x00000000 : init, needs a reloc
     2265     0x001C           0x00000000 :
     2266     0x0020           0x00000058 : offset to init name
     2267     0x0024           0x00000000 : flags, padded to a word
     2268     0x0028           0x00000000 : empty init
     2269     0x002C           0x00000000 :
     2270     0x0030           0x00000000 :
     2271     0x0034           0x00000000 :
     2272     0x0038           0x00000000 : fini, needs a reloc
     2273     0x003C           0x00000000 :
     2274     0x0040           0x00000??? : offset to fini name
     2275     0x0044           0x00000000 : flags, padded to a word
     2276     0x0048           0x00000000 : empty fini
     2277     0x004C           0x00000000 :
     2278     0x0050           0x00000000 :
     2279     0x0054           0x00000000 :
     2280     0x0058           init name
     2281     0x0058 + initsz  fini name */
     2282
     2283  data_buffer_size = 0x0058 + initsz + finisz;
     2284  data_buffer_size = (data_buffer_size + 7) &~ (bfd_size_type) 7;
     2285  data_buffer = NULL;
     2286  data_buffer = (bfd_byte *) bfd_zmalloc (data_buffer_size);
     2287  if (data_buffer == NULL)
     2288    return FALSE;
     2289
     2290  if (initsz)
     2291    {
     2292      val = 0x18;
     2293      bfd_put_32 (abfd, val, &data_buffer[0x08]);
     2294      val = 0x58;
     2295      bfd_put_32 (abfd, val, &data_buffer[0x20]);
     2296      memcpy (&data_buffer[val], init, initsz);
     2297    }
     2298
     2299  if (finisz)
     2300    {
     2301      val = 0x38;
     2302      bfd_put_32 (abfd, val, &data_buffer[0x0C]);
     2303      val = 0x58 + initsz;
     2304      bfd_put_32 (abfd, val, &data_buffer[0x40]);
     2305      memcpy (&data_buffer[val], fini, finisz);
     2306    }
     2307
     2308  val = 0x10;
     2309  bfd_put_32 (abfd, val, &data_buffer[0x10]);
     2310  data_scnhdr.s_size = data_buffer_size;
     2311  bss_scnhdr.s_paddr = bss_scnhdr.s_vaddr = data_scnhdr.s_size;
     2312
     2313  /* String table.  */
     2314  string_table_size = 4;
     2315  string_table_size += strlen (data_name) + 1;
     2316  string_table_size += strlen (rtinit_name) + 1;
     2317  string_table_size += initsz;
     2318  string_table_size += finisz;
     2319  if (rtld)
     2320    string_table_size += strlen (rtld_name) + 1;
     2321
     2322  string_table = (bfd_byte *) bfd_zmalloc (string_table_size);
     2323  if (string_table == NULL)
     2324    return FALSE;
     2325
     2326  val = string_table_size;
     2327  bfd_put_32 (abfd, val, &string_table[0]);
     2328  st_tmp = string_table + 4;
     2329
     2330  /* symbols
     2331     0. .data csect
     2332     2. __rtinit
     2333     4. init function
     2334     6. fini function
     2335     8. __rtld  */
     2336  memset (syment_ext, 0, 10 * SYMESZ);
     2337  memset (reloc_ext, 0, 3 * RELSZ);
     2338
     2339  /* .data csect */
     2340  memset (&syment, 0, sizeof (struct internal_syment));
     2341  memset (&auxent, 0, sizeof (union internal_auxent));
     2342
     2343  syment._n._n_n._n_offset = st_tmp - string_table;
     2344  memcpy (st_tmp, data_name, strlen (data_name));
     2345  st_tmp += strlen (data_name) + 1;
     2346
     2347  syment.n_scnum = 2;
     2348  syment.n_sclass = C_HIDEXT;
     2349  syment.n_numaux = 1;
     2350  auxent.x_csect.x_scnlen.l = data_buffer_size;
     2351  auxent.x_csect.x_smtyp = 3 << 3 | XTY_SD;
     2352  auxent.x_csect.x_smclas = XMC_RW;
     2353  bfd_coff_swap_sym_out (abfd, &syment,
     2354                         &syment_ext[filehdr.f_nsyms * SYMESZ]);
     2355  bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
     2356                         syment.n_numaux,
     2357                         &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
     2358  filehdr.f_nsyms += 2;
     2359
     2360  /* __rtinit */
     2361  memset (&syment, 0, sizeof (struct internal_syment));
     2362  memset (&auxent, 0, sizeof (union internal_auxent));
     2363  syment._n._n_n._n_offset = st_tmp - string_table;
     2364  memcpy (st_tmp, rtinit_name, strlen (rtinit_name));
     2365  st_tmp += strlen (rtinit_name) + 1;
     2366
     2367  syment.n_scnum = 2;
     2368  syment.n_sclass = C_EXT;
     2369  syment.n_numaux = 1;
     2370  auxent.x_csect.x_smtyp = XTY_LD;
     2371  auxent.x_csect.x_smclas = XMC_RW;
     2372  bfd_coff_swap_sym_out (abfd, &syment,
     2373                         &syment_ext[filehdr.f_nsyms * SYMESZ]);
     2374  bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
     2375                         syment.n_numaux,
     2376                         &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
     2377  filehdr.f_nsyms += 2;
     2378
     2379  /* Init.  */
     2380  if (initsz)
     2381    {
     2382      memset (&syment, 0, sizeof (struct internal_syment));
     2383      memset (&auxent, 0, sizeof (union internal_auxent));
     2384
     2385      syment._n._n_n._n_offset = st_tmp - string_table;
     2386      memcpy (st_tmp, init, initsz);
     2387      st_tmp += initsz;
     2388
     2389      syment.n_sclass = C_EXT;
     2390      syment.n_numaux = 1;
     2391      bfd_coff_swap_sym_out (abfd, &syment,
     2392                             &syment_ext[filehdr.f_nsyms * SYMESZ]);
     2393      bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
     2394                             syment.n_numaux,
     2395                             &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
     2396      /* Reloc.  */
     2397      memset (&reloc, 0, sizeof (struct internal_reloc));
     2398      reloc.r_vaddr = 0x0018;
     2399      reloc.r_symndx = filehdr.f_nsyms;
     2400      reloc.r_type = R_POS;
     2401      reloc.r_size = 63;
     2402      bfd_coff_swap_reloc_out (abfd, &reloc, &reloc_ext[0]);
     2403
     2404      filehdr.f_nsyms += 2;
     2405      data_scnhdr.s_nreloc += 1;
     2406    }
     2407
     2408  /* Finit.  */
     2409  if (finisz)
     2410    {
     2411      memset (&syment, 0, sizeof (struct internal_syment));
     2412      memset (&auxent, 0, sizeof (union internal_auxent));
     2413
     2414      syment._n._n_n._n_offset = st_tmp - string_table;
     2415      memcpy (st_tmp, fini, finisz);
     2416      st_tmp += finisz;
     2417
     2418      syment.n_sclass = C_EXT;
     2419      syment.n_numaux = 1;
     2420      bfd_coff_swap_sym_out (abfd, &syment,
     2421                             &syment_ext[filehdr.f_nsyms * SYMESZ]);
     2422      bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
     2423                             syment.n_numaux,
     2424                             &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
     2425
     2426      /* Reloc.  */
     2427      memset (&reloc, 0, sizeof (struct internal_reloc));
     2428      reloc.r_vaddr = 0x0038;
     2429      reloc.r_symndx = filehdr.f_nsyms;
     2430      reloc.r_type = R_POS;
     2431      reloc.r_size = 63;
     2432      bfd_coff_swap_reloc_out (abfd, &reloc,
     2433                               &reloc_ext[data_scnhdr.s_nreloc * RELSZ]);
     2434
     2435      filehdr.f_nsyms += 2;
     2436      data_scnhdr.s_nreloc += 1;
     2437    }
     2438
     2439  if (rtld)
     2440    {
     2441      memset (&syment, 0, sizeof (struct internal_syment));
     2442      memset (&auxent, 0, sizeof (union internal_auxent));
     2443
     2444      syment._n._n_n._n_offset = st_tmp - string_table;
     2445      memcpy (st_tmp, rtld_name, strlen (rtld_name));
     2446      st_tmp += strlen (rtld_name) + 1;
     2447
     2448      syment.n_sclass = C_EXT;
     2449      syment.n_numaux = 1;
     2450      bfd_coff_swap_sym_out (abfd, &syment,
     2451                             &syment_ext[filehdr.f_nsyms * SYMESZ]);
     2452      bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
     2453                             syment.n_numaux,
     2454                             &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
     2455
     2456      /* Reloc.  */
     2457      memset (&reloc, 0, sizeof (struct internal_reloc));
     2458      reloc.r_vaddr = 0x0000;
     2459      reloc.r_symndx = filehdr.f_nsyms;
     2460      reloc.r_type = R_POS;
     2461      reloc.r_size = 63;
     2462      bfd_coff_swap_reloc_out (abfd, &reloc,
     2463                               &reloc_ext[data_scnhdr.s_nreloc * RELSZ]);
     2464
     2465      filehdr.f_nsyms += 2;
     2466      data_scnhdr.s_nreloc += 1;
     2467
     2468      bss_scnhdr.s_size = 0;
     2469    }
     2470
     2471  data_scnhdr.s_relptr = data_scnhdr.s_scnptr + data_buffer_size;
     2472  filehdr.f_symptr = data_scnhdr.s_relptr + data_scnhdr.s_nreloc * RELSZ;
     2473
     2474  bfd_coff_swap_filehdr_out (abfd, &filehdr, filehdr_ext);
     2475  bfd_bwrite (filehdr_ext, FILHSZ, abfd);
     2476  bfd_coff_swap_scnhdr_out (abfd, &text_scnhdr, &scnhdr_ext[SCNHSZ * 0]);
     2477  bfd_coff_swap_scnhdr_out (abfd, &data_scnhdr, &scnhdr_ext[SCNHSZ * 1]);
     2478  bfd_coff_swap_scnhdr_out (abfd, &bss_scnhdr, &scnhdr_ext[SCNHSZ * 2]);
     2479  bfd_bwrite (scnhdr_ext, 3 * SCNHSZ, abfd);
     2480  bfd_bwrite (data_buffer, data_buffer_size, abfd);
     2481  bfd_bwrite (reloc_ext, data_scnhdr.s_nreloc * RELSZ, abfd);
     2482  bfd_bwrite (syment_ext, filehdr.f_nsyms * SYMESZ, abfd);
     2483  bfd_bwrite (string_table, string_table_size, abfd);
     2484
     2485  free (data_buffer);
     2486  data_buffer = NULL;
     2487
     2488  return TRUE;
     2489}
     2490
     2491/* The typical dynamic reloc.  */
     2492
     2493static reloc_howto_type xcoff64_dynamic_reloc =
     2494HOWTO (0,                       /* type */
     2495       0,                       /* rightshift */
     2496       4,                       /* size (0 = byte, 1 = short, 2 = long) */
     2497       64,                      /* bitsize */
     2498       FALSE,                   /* pc_relative */
     2499       0,                       /* bitpos */
     2500       complain_overflow_bitfield, /* complain_on_overflow */
     2501       0,                       /* special_function */
     2502       "R_POS",                 /* name */
     2503       TRUE,                    /* partial_inplace */
     2504       MINUS_ONE,               /* src_mask */
     2505       MINUS_ONE,               /* dst_mask */
     2506       FALSE);                  /* pcrel_offset */
     2507
     2508static unsigned long xcoff64_glink_code[10] =
     2509{
     2510  0xe9820000,   /* ld r12,0(r2) */
     2511  0xf8410028,   /* std r2,40(r1) */
     2512  0xe80c0000,   /* ld r0,0(r12) */
     2513  0xe84c0008,   /* ld r0,8(r12) */
     2514  0x7c0903a6,   /* mtctr r0 */
     2515  0x4e800420,   /* bctr */
     2516  0x00000000,   /* start of traceback table */
     2517  0x000ca000,   /* traceback table */
     2518  0x00000000,   /* traceback table */
     2519  0x00000018,   /* ??? */
     2520};
     2521
     2522static const struct xcoff_backend_data_rec bfd_xcoff_backend_data =
     2523  {
     2524    { /* COFF backend, defined in libcoff.h.  */
     2525      _bfd_xcoff64_swap_aux_in,
     2526      _bfd_xcoff64_swap_sym_in,
     2527      _bfd_xcoff64_swap_lineno_in,
     2528      _bfd_xcoff64_swap_aux_out,
     2529      _bfd_xcoff64_swap_sym_out,
     2530      _bfd_xcoff64_swap_lineno_out,
     2531      xcoff64_swap_reloc_out,
     2532      coff_swap_filehdr_out,
     2533      coff_swap_aouthdr_out,
     2534      coff_swap_scnhdr_out,
     2535      FILHSZ,
     2536      AOUTSZ,
     2537      SCNHSZ,
     2538      SYMESZ,
     2539      AUXESZ,
     2540      RELSZ,
     2541      LINESZ,
     2542      FILNMLEN,
     2543      TRUE,                     /* _bfd_coff_long_filenames */
     2544      FALSE,                    /* _bfd_coff_long_section_names */
     2545      3,                        /* _bfd_coff_default_section_alignment_power */
     2546      TRUE,                     /* _bfd_coff_force_symnames_in_strings */
     2547      4,                        /* _bfd_coff_debug_string_prefix_length */
     2548      coff_swap_filehdr_in,
     2549      coff_swap_aouthdr_in,
     2550      coff_swap_scnhdr_in,
     2551      xcoff64_swap_reloc_in,
     2552      xcoff64_bad_format_hook,
     2553      coff_set_arch_mach_hook,
     2554      coff_mkobject_hook,
     2555      styp_to_sec_flags,
     2556      coff_set_alignment_hook,
     2557      coff_slurp_symbol_table,
     2558      symname_in_debug_hook,
     2559      coff_pointerize_aux_hook,
     2560      coff_print_aux,
     2561      dummy_reloc16_extra_cases,
     2562      dummy_reloc16_estimate,
     2563      NULL,                     /* bfd_coff_sym_is_global */
     2564      coff_compute_section_file_positions,
     2565      NULL,                     /* _bfd_coff_start_final_link */
     2566      xcoff64_ppc_relocate_section,
     2567      coff_rtype_to_howto,
     2568      NULL,                     /* _bfd_coff_adjust_symndx */
     2569      _bfd_generic_link_add_one_symbol,
     2570      coff_link_output_has_begun,
     2571      coff_final_link_postscript
     2572    },
     2573
     2574    0x01EF,                     /* magic number */
     2575    bfd_arch_powerpc,
     2576    bfd_mach_ppc_620,
     2577
     2578    /* Function pointers to xcoff specific swap routines.  */
     2579    xcoff64_swap_ldhdr_in,
     2580    xcoff64_swap_ldhdr_out,
     2581    xcoff64_swap_ldsym_in,
     2582    xcoff64_swap_ldsym_out,
     2583    xcoff64_swap_ldrel_in,
     2584    xcoff64_swap_ldrel_out,
     2585
     2586    /* Sizes.  */
     2587    LDHDRSZ,
     2588    LDSYMSZ,
     2589    LDRELSZ,
     2590    24,                         /* _xcoff_function_descriptor_size */
     2591    0,                          /* _xcoff_small_aout_header_size */
     2592
     2593    /* Versions.  */
     2594    2,                          /* _xcoff_ldhdr_version */
     2595
     2596    _bfd_xcoff64_put_symbol_name,
     2597    _bfd_xcoff64_put_ldsymbol_name,
     2598    &xcoff64_dynamic_reloc,
     2599    xcoff64_create_csect_from_smclas,
     2600
     2601    /* Lineno and reloc count overflow.  */
     2602    xcoff64_is_lineno_count_overflow,
     2603    xcoff64_is_reloc_count_overflow,
     2604
     2605    xcoff64_loader_symbol_offset,
     2606    xcoff64_loader_reloc_offset,
     2607
     2608    /* glink.  */
     2609    &xcoff64_glink_code[0],
     2610    40,                         /* _xcoff_glink_size */
     2611
     2612    /* rtinit.  */
     2613    88,                         /* _xcoff_rtinit_size */
     2614    xcoff64_generate_rtinit,
     2615  };
     2616
     2617/* The transfer vector that leads the outside world to all of the above.  */
     2618const bfd_target rs6000coff64_vec =
     2619  {
     2620    "aixcoff64-rs6000",
     2621    bfd_target_xcoff_flavour,
     2622    BFD_ENDIAN_BIG,             /* data byte order is big */
     2623    BFD_ENDIAN_BIG,             /* header byte order is big */
     2624
     2625    (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | DYNAMIC
     2626     | HAS_SYMS | HAS_LOCALS | WP_TEXT),
     2627
     2628    SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA,
     2629    0,                          /* leading char */
     2630    '/',                        /* ar_pad_char */
     2631    15,                         /* ar_max_namelen */
     2632
     2633    /* data */
     2634    bfd_getb64,
     2635    bfd_getb_signed_64,
     2636    bfd_putb64,
     2637    bfd_getb32,
     2638    bfd_getb_signed_32,
     2639    bfd_putb32,
     2640    bfd_getb16,
     2641    bfd_getb_signed_16,
     2642    bfd_putb16,
     2643
     2644    /* hdrs */
     2645    bfd_getb64,
     2646    bfd_getb_signed_64,
     2647    bfd_putb64,
     2648    bfd_getb32,
     2649    bfd_getb_signed_32,
     2650    bfd_putb32,
     2651    bfd_getb16,
     2652    bfd_getb_signed_16,
     2653    bfd_putb16,
     2654
     2655    { /* bfd_check_format */
     2656      _bfd_dummy_target,
     2657      coff_object_p,
     2658      xcoff64_archive_p,
     2659      CORE_FILE_P
     2660    },
     2661
     2662    { /* bfd_set_format */
     2663      bfd_false,
     2664      coff_mkobject,
     2665      _bfd_generic_mkarchive,
     2666      bfd_false
     2667    },
     2668
     2669    {/* bfd_write_contents */
     2670      bfd_false,
     2671      xcoff64_write_object_contents,
     2672      _bfd_xcoff_write_archive_contents,
     2673      bfd_false
     2674    },
     2675
     2676    /* Generic */
     2677    bfd_true,
     2678    bfd_true,
     2679    coff_new_section_hook,
     2680    _bfd_generic_get_section_contents,
     2681    _bfd_generic_get_section_contents_in_window,
     2682
     2683    /* Copy */
     2684    _bfd_xcoff_copy_private_bfd_data,
     2685    ((bfd_boolean (*) (bfd *, bfd *)) bfd_true),
     2686    ((bfd_boolean (*) (bfd *, asection *, bfd *, asection *)) bfd_true),
     2687    ((bfd_boolean (*) (bfd *, asymbol *, bfd *, asymbol *)) bfd_true),
     2688    ((bfd_boolean (*) (bfd *, flagword)) bfd_true),
     2689    ((bfd_boolean (*) (bfd *, void * )) bfd_true),
     2690
     2691    /* Core */
     2692    coff_core_file_failing_command,
     2693    coff_core_file_failing_signal,
     2694    coff_core_file_matches_executable_p,
     2695
     2696    /* Archive */
     2697    xcoff64_slurp_armap,
     2698    bfd_false,
     2699    ((bfd_boolean (*) (bfd *, char **, bfd_size_type *, const char **)) bfd_false),
     2700    bfd_dont_truncate_arname,
     2701    _bfd_xcoff_write_armap,
     2702    _bfd_xcoff_read_ar_hdr,
     2703    xcoff64_openr_next_archived_file,
     2704    _bfd_generic_get_elt_at_index,
     2705    _bfd_xcoff_stat_arch_elt,
     2706    bfd_true,
     2707
     2708    /* Symbols */
     2709    coff_get_symtab_upper_bound,
     2710    coff_get_symtab,
     2711    coff_make_empty_symbol,
     2712    coff_print_symbol,
     2713    coff_get_symbol_info,
     2714    _bfd_xcoff_is_local_label_name,
     2715    coff_get_lineno,
     2716    coff_find_nearest_line,
     2717    coff_bfd_make_debug_symbol,
     2718    _bfd_generic_read_minisymbols,
     2719    _bfd_generic_minisymbol_to_symbol,
     2720
     2721    /* Reloc */
     2722    coff_get_reloc_upper_bound,
     2723    coff_canonicalize_reloc,
     2724    xcoff64_reloc_type_lookup,
     2725
     2726    /* Write */
     2727    coff_set_arch_mach,
     2728    coff_set_section_contents,
     2729
     2730    /* Link */
     2731    xcoff64_sizeof_headers,
     2732    bfd_generic_get_relocated_section_contents,
     2733    bfd_generic_relax_section,
     2734    _bfd_xcoff_bfd_link_hash_table_create,
     2735    _bfd_generic_link_hash_table_free,
     2736    _bfd_xcoff_bfd_link_add_symbols,
     2737    _bfd_generic_link_just_syms,
     2738    _bfd_xcoff_bfd_final_link,
     2739    _bfd_generic_link_split_section,
     2740    bfd_generic_gc_sections,
     2741    bfd_generic_merge_sections,
     2742    bfd_generic_discard_group,
     2743
     2744    /* Dynamic */
     2745    _bfd_xcoff_get_dynamic_symtab_upper_bound,
     2746    _bfd_xcoff_canonicalize_dynamic_symtab,
     2747    _bfd_xcoff_get_dynamic_reloc_upper_bound,
     2748    _bfd_xcoff_canonicalize_dynamic_reloc,
     2749
     2750    /* Opposite endian version, none exists */
     2751    NULL,
     2752
     2753    (void *) &bfd_xcoff_backend_data,
     2754  };
     2755
     2756extern const bfd_target *xcoff64_core_p
     2757  PARAMS ((bfd *));
     2758extern bfd_boolean xcoff64_core_file_matches_executable_p
     2759  PARAMS ((bfd *, bfd *));
     2760extern char *xcoff64_core_file_failing_command
     2761  PARAMS ((bfd *));
     2762extern int xcoff64_core_file_failing_signal
     2763  PARAMS ((bfd *));
     2764
     2765/* AIX 5 */
     2766static const struct xcoff_backend_data_rec bfd_xcoff_aix5_backend_data =
     2767  {
     2768    { /* COFF backend, defined in libcoff.h.  */
     2769      _bfd_xcoff64_swap_aux_in,
     2770      _bfd_xcoff64_swap_sym_in,
     2771      _bfd_xcoff64_swap_lineno_in,
     2772      _bfd_xcoff64_swap_aux_out,
     2773      _bfd_xcoff64_swap_sym_out,
     2774      _bfd_xcoff64_swap_lineno_out,
     2775      xcoff64_swap_reloc_out,
     2776      coff_swap_filehdr_out,
     2777      coff_swap_aouthdr_out,
     2778      coff_swap_scnhdr_out,
     2779      FILHSZ,
     2780      AOUTSZ,
     2781      SCNHSZ,
     2782      SYMESZ,
     2783      AUXESZ,
     2784      RELSZ,
     2785      LINESZ,
     2786      FILNMLEN,
     2787      TRUE,                     /* _bfd_coff_long_filenames */
     2788      FALSE,                    /* _bfd_coff_long_section_names */
     2789      3,                        /* _bfd_coff_default_section_alignment_power */
     2790      TRUE,                     /* _bfd_coff_force_symnames_in_strings */
     2791      4,                        /* _bfd_coff_debug_string_prefix_length */
     2792      coff_swap_filehdr_in,
     2793      coff_swap_aouthdr_in,
     2794      coff_swap_scnhdr_in,
     2795      xcoff64_swap_reloc_in,
     2796      xcoff64_bad_format_hook,
     2797      coff_set_arch_mach_hook,
     2798      coff_mkobject_hook,
     2799      styp_to_sec_flags,
     2800      coff_set_alignment_hook,
     2801      coff_slurp_symbol_table,
     2802      symname_in_debug_hook,
     2803      coff_pointerize_aux_hook,
     2804      coff_print_aux,
     2805      dummy_reloc16_extra_cases,
     2806      dummy_reloc16_estimate,
     2807      NULL,                     /* bfd_coff_sym_is_global */
     2808      coff_compute_section_file_positions,
     2809      NULL,                     /* _bfd_coff_start_final_link */
     2810      xcoff64_ppc_relocate_section,
     2811      coff_rtype_to_howto,
     2812      NULL,                     /* _bfd_coff_adjust_symndx */
     2813      _bfd_generic_link_add_one_symbol,
     2814      coff_link_output_has_begun,
     2815      coff_final_link_postscript
     2816    },
     2817
     2818    U64_TOCMAGIC,               /* magic number */
     2819    bfd_arch_powerpc,
     2820    bfd_mach_ppc_620,
     2821
     2822    /* Function pointers to xcoff specific swap routines.  */
     2823    xcoff64_swap_ldhdr_in,
     2824    xcoff64_swap_ldhdr_out,
     2825    xcoff64_swap_ldsym_in,
     2826    xcoff64_swap_ldsym_out,
     2827    xcoff64_swap_ldrel_in,
     2828    xcoff64_swap_ldrel_out,
     2829
     2830    /* Sizes.  */
     2831    LDHDRSZ,
     2832    LDSYMSZ,
     2833    LDRELSZ,
     2834    24,                         /* _xcoff_function_descriptor_size */
     2835    0,                          /* _xcoff_small_aout_header_size */
     2836    /* Versions.  */
     2837    2,                          /* _xcoff_ldhdr_version */
     2838
     2839    _bfd_xcoff64_put_symbol_name,
     2840    _bfd_xcoff64_put_ldsymbol_name,
     2841    &xcoff64_dynamic_reloc,
     2842    xcoff64_create_csect_from_smclas,
     2843
     2844    /* Lineno and reloc count overflow.  */
     2845    xcoff64_is_lineno_count_overflow,
     2846    xcoff64_is_reloc_count_overflow,
     2847
     2848    xcoff64_loader_symbol_offset,
     2849    xcoff64_loader_reloc_offset,
     2850
     2851    /* glink.  */
     2852    &xcoff64_glink_code[0],
     2853    40,                         /* _xcoff_glink_size */
     2854
     2855    /* rtinit.  */
     2856    88,                         /* _xcoff_rtinit_size */
     2857    xcoff64_generate_rtinit,
     2858  };
     2859
     2860/* The transfer vector that leads the outside world to all of the above.  */
     2861const bfd_target aix5coff64_vec =
     2862  {
     2863    "aix5coff64-rs6000",
     2864    bfd_target_xcoff_flavour,
     2865    BFD_ENDIAN_BIG,             /* data byte order is big */
     2866    BFD_ENDIAN_BIG,             /* header byte order is big */
     2867
     2868    (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | DYNAMIC
     2869     | HAS_SYMS | HAS_LOCALS | WP_TEXT),
     2870
     2871    SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA,
     2872    0,                          /* leading char */
     2873    '/',                        /* ar_pad_char */
     2874    15,                         /* ar_max_namelen */
     2875
     2876    /* data */
     2877    bfd_getb64,
     2878    bfd_getb_signed_64,
     2879    bfd_putb64,
     2880    bfd_getb32,
     2881    bfd_getb_signed_32,
     2882    bfd_putb32,
     2883    bfd_getb16,
     2884    bfd_getb_signed_16,
     2885    bfd_putb16,
     2886
     2887    /* hdrs */
     2888    bfd_getb64,
     2889    bfd_getb_signed_64,
     2890    bfd_putb64,
     2891    bfd_getb32,
     2892    bfd_getb_signed_32,
     2893    bfd_putb32,
     2894    bfd_getb16,
     2895    bfd_getb_signed_16,
     2896    bfd_putb16,
     2897
     2898    { /* bfd_check_format */
     2899      _bfd_dummy_target,
     2900      coff_object_p,
     2901      xcoff64_archive_p,
     2902      xcoff64_core_p
     2903    },
     2904
     2905    { /* bfd_set_format */
     2906      bfd_false,
     2907      coff_mkobject,
     2908      _bfd_generic_mkarchive,
     2909      bfd_false
     2910    },
     2911
     2912    {/* bfd_write_contents */
     2913      bfd_false,
     2914      xcoff64_write_object_contents,
     2915      _bfd_xcoff_write_archive_contents,
     2916      bfd_false
     2917    },
     2918
     2919    /* Generic */
     2920    bfd_true,
     2921    bfd_true,
     2922    coff_new_section_hook,
     2923    _bfd_generic_get_section_contents,
     2924    _bfd_generic_get_section_contents_in_window,
     2925
     2926    /* Copy */
     2927    _bfd_xcoff_copy_private_bfd_data,
     2928    ((bfd_boolean (*) (bfd *, bfd *)) bfd_true),
     2929    ((bfd_boolean (*) (bfd *, asection *, bfd *, asection *)) bfd_true),
     2930    ((bfd_boolean (*) (bfd *, asymbol *, bfd *, asymbol *)) bfd_true),
     2931    ((bfd_boolean (*) (bfd *, flagword)) bfd_true),
     2932    ((bfd_boolean (*) (bfd *, void * )) bfd_true),
     2933
     2934    /* Core */
     2935    xcoff64_core_file_failing_command,
     2936    xcoff64_core_file_failing_signal,
     2937    xcoff64_core_file_matches_executable_p,
     2938
     2939    /* Archive */
     2940    xcoff64_slurp_armap,
     2941    bfd_false,
     2942    ((bfd_boolean (*) (bfd *, char **, bfd_size_type *, const char **)) bfd_false),
     2943    bfd_dont_truncate_arname,
     2944    _bfd_xcoff_write_armap,
     2945    _bfd_xcoff_read_ar_hdr,
     2946    xcoff64_openr_next_archived_file,
     2947    _bfd_generic_get_elt_at_index,
     2948    _bfd_xcoff_stat_arch_elt,
     2949    bfd_true,
     2950
     2951    /* Symbols */
     2952    coff_get_symtab_upper_bound,
     2953    coff_get_symtab,
     2954    coff_make_empty_symbol,
     2955    coff_print_symbol,
     2956    coff_get_symbol_info,
     2957    _bfd_xcoff_is_local_label_name,
     2958    coff_get_lineno,
     2959    coff_find_nearest_line,
     2960    coff_bfd_make_debug_symbol,
     2961    _bfd_generic_read_minisymbols,
     2962    _bfd_generic_minisymbol_to_symbol,
     2963
     2964    /* Reloc */
     2965    coff_get_reloc_upper_bound,
     2966    coff_canonicalize_reloc,
     2967    xcoff64_reloc_type_lookup,
     2968
     2969    /* Write */
     2970    coff_set_arch_mach,
     2971    coff_set_section_contents,
     2972
     2973    /* Link */
     2974    xcoff64_sizeof_headers,
     2975    bfd_generic_get_relocated_section_contents,
     2976    bfd_generic_relax_section,
     2977    _bfd_xcoff_bfd_link_hash_table_create,
     2978    _bfd_generic_link_hash_table_free,
     2979    _bfd_xcoff_bfd_link_add_symbols,
     2980    _bfd_generic_link_just_syms,
     2981    _bfd_xcoff_bfd_final_link,
     2982    _bfd_generic_link_split_section,
     2983    bfd_generic_gc_sections,
     2984    bfd_generic_merge_sections,
     2985    bfd_generic_discard_group,
     2986
     2987    /* Dynamic */
     2988    _bfd_xcoff_get_dynamic_symtab_upper_bound,
     2989    _bfd_xcoff_canonicalize_dynamic_symtab,
     2990    _bfd_xcoff_get_dynamic_reloc_upper_bound,
     2991    _bfd_xcoff_canonicalize_dynamic_reloc,
     2992
     2993    /* Opposite endian version, none exists.  */
     2994    NULL,
     2995
     2996    (void *) & bfd_xcoff_aix5_backend_data,
     2997  };
Note: See TracChangeset for help on using the changeset viewer.