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