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
_bfd_xcoff64_swap_lineno_in(bfd * abfd,void * ext1,void * in1)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
_bfd_xcoff64_swap_lineno_out(bfd * abfd,void * inp,void * outp)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
_bfd_xcoff64_swap_sym_in(bfd * abfd,void * ext1,void * in1)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
_bfd_xcoff64_swap_sym_out(bfd * abfd,void * inp,void * extp)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
_bfd_xcoff64_swap_aux_in(bfd * abfd,void * ext1,int type,int in_class,int indx,int numaux,void * in1)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
_bfd_xcoff64_swap_aux_out(bfd * abfd,void * inp,int type,int in_class,int indx ATTRIBUTE_UNUSED,int numaux ATTRIBUTE_UNUSED,void * extp)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
_bfd_xcoff64_put_symbol_name(bfd * abfd,struct bfd_strtab_hash * strtab,struct internal_syment * sym,const char * name)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
_bfd_xcoff64_put_ldsymbol_name(bfd * abfd ATTRIBUTE_UNUSED,struct xcoff_loader_info * ldinfo,struct internal_ldsym * ldsym,const char * name)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
xcoff64_swap_ldhdr_in(bfd * abfd,const void * s,struct internal_ldhdr * dst)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
xcoff64_swap_ldhdr_out(bfd * abfd,const struct internal_ldhdr * src,void * d)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
xcoff64_swap_ldsym_in(bfd * abfd,const void * s,struct internal_ldsym * dst)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
xcoff64_swap_ldsym_out(bfd * abfd,const struct internal_ldsym * src,void * d)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
xcoff64_swap_reloc_in(bfd * abfd,void * s,void * d)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
xcoff64_swap_reloc_out(bfd * abfd,void * s,void * d)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
xcoff64_swap_ldrel_in(bfd * abfd,const void * s,struct internal_ldrel * dst)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
xcoff64_swap_ldrel_out(bfd * abfd,const struct internal_ldrel * src,void * d)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
xcoff64_write_object_contents(bfd * abfd)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, §ion, &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
xcoff64_reloc_type_br(bfd * input_bfd,asection * input_section,bfd * output_bfd ATTRIBUTE_UNUSED,struct internal_reloc * rel,struct internal_syment * sym ATTRIBUTE_UNUSED,struct reloc_howto_struct * howto,bfd_vma val,bfd_vma addend,bfd_vma * relocation,bfd_byte * contents)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
xcoff64_ppc_relocate_section(bfd * output_bfd,struct bfd_link_info * info,bfd * input_bfd,asection * input_section,bfd_byte * contents,struct internal_reloc * relocs,struct internal_syment * syms,asection ** sections)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 /* 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 /* 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 /* 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 /* 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 /* 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 /* 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 /* 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 /* 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 /* 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 /* 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 /* 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 /* 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 /* 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 /* 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 /* 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 /* 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 /* 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 /* 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 /* 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 /* 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 /* 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 /* 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 HOWTO (R_POS, /* type */
1718 0, /* rightshift */
1719 2, /* size (0 = byte, 1 = short, 2 = long) */
1720 32, /* bitsize */
1721 FALSE, /* pc_relative */
1722 0, /* bitpos */
1723 complain_overflow_bitfield, /* complain_on_overflow */
1724 0, /* special_function */
1725 "R_POS_32", /* name */
1726 TRUE, /* partial_inplace */
1727 0xffffffff, /* src_mask */
1728 0xffffffff, /* dst_mask */
1729 FALSE), /* pcrel_offset */
1730
1731 /* 16 bit Non modifiable absolute branch. */
1732 HOWTO (R_BA, /* type */
1733 0, /* rightshift */
1734 1, /* size (0 = byte, 1 = short, 2 = long) */
1735 16, /* bitsize */
1736 FALSE, /* pc_relative */
1737 0, /* bitpos */
1738 complain_overflow_bitfield, /* complain_on_overflow */
1739 0, /* special_function */
1740 "R_BA_16", /* name */
1741 TRUE, /* partial_inplace */
1742 0xfffc, /* src_mask */
1743 0xfffc, /* dst_mask */
1744 FALSE), /* pcrel_offset */
1745
1746 /* Modifiable branch relative. */
1747 HOWTO (R_RBR, /* type */
1748 0, /* rightshift */
1749 1, /* size (0 = byte, 1 = short, 2 = long) */
1750 16, /* bitsize */
1751 FALSE, /* pc_relative */
1752 0, /* bitpos */
1753 complain_overflow_signed, /* complain_on_overflow */
1754 0, /* special_function */
1755 "R_RBR_16", /* name */
1756 TRUE, /* partial_inplace */
1757 0xffff, /* src_mask */
1758 0xffff, /* dst_mask */
1759 FALSE), /* pcrel_offset */
1760
1761 /* Modifiable branch absolute. */
1762 HOWTO (R_RBA, /* type */
1763 0, /* rightshift */
1764 1, /* size (0 = byte, 1 = short, 2 = long) */
1765 16, /* bitsize */
1766 FALSE, /* pc_relative */
1767 0, /* bitpos */
1768 complain_overflow_bitfield, /* complain_on_overflow */
1769 0, /* special_function */
1770 "R_RBA_16", /* name */
1771 TRUE, /* partial_inplace */
1772 0xffff, /* src_mask */
1773 0xffff, /* dst_mask */
1774 FALSE), /* pcrel_offset */
1775
1776 };
1777
1778 void
xcoff64_rtype2howto(arelent * relent,struct internal_reloc * internal)1779 xcoff64_rtype2howto (arelent *relent, struct internal_reloc *internal)
1780 {
1781 if (internal->r_type > R_RBRC)
1782 abort ();
1783
1784 /* Default howto layout works most of the time */
1785 relent->howto = &xcoff64_howto_table[internal->r_type];
1786
1787 /* Special case some 16 bit reloc */
1788 if (15 == (internal->r_size & 0x3f))
1789 {
1790 if (R_BA == internal->r_type)
1791 relent->howto = &xcoff64_howto_table[0x1d];
1792 else if (R_RBR == internal->r_type)
1793 relent->howto = &xcoff64_howto_table[0x1e];
1794 else if (R_RBA == internal->r_type)
1795 relent->howto = &xcoff64_howto_table[0x1f];
1796 }
1797 /* Special case 32 bit */
1798 else if (31 == (internal->r_size & 0x3f))
1799 {
1800 if (R_POS == internal->r_type)
1801 relent->howto = &xcoff64_howto_table[0x1c];
1802 }
1803
1804 /* The r_size field of an XCOFF reloc encodes the bitsize of the
1805 relocation, as well as indicating whether it is signed or not.
1806 Doublecheck that the relocation information gathered from the
1807 type matches this information. The bitsize is not significant
1808 for R_REF relocs. */
1809 if (relent->howto->dst_mask != 0
1810 && (relent->howto->bitsize
1811 != ((unsigned int) internal->r_size & 0x3f) + 1))
1812 abort ();
1813 }
1814
1815 reloc_howto_type *
xcoff64_reloc_type_lookup(bfd * abfd ATTRIBUTE_UNUSED,bfd_reloc_code_real_type code)1816 xcoff64_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1817 bfd_reloc_code_real_type code)
1818 {
1819 switch (code)
1820 {
1821 case BFD_RELOC_PPC_B26:
1822 return &xcoff64_howto_table[0xa];
1823 case BFD_RELOC_PPC_BA16:
1824 return &xcoff64_howto_table[0x1d];
1825 case BFD_RELOC_PPC_BA26:
1826 return &xcoff64_howto_table[8];
1827 case BFD_RELOC_PPC_TOC16:
1828 return &xcoff64_howto_table[3];
1829 case BFD_RELOC_32:
1830 case BFD_RELOC_CTOR:
1831 return &xcoff64_howto_table[0x1c];
1832 case BFD_RELOC_64:
1833 return &xcoff64_howto_table[0];
1834 case BFD_RELOC_NONE:
1835 return &xcoff64_howto_table[0xf];
1836 default:
1837 return NULL;
1838 }
1839 }
1840
1841 static reloc_howto_type *
xcoff64_reloc_name_lookup(bfd * abfd ATTRIBUTE_UNUSED,const char * r_name)1842 xcoff64_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1843 const char *r_name)
1844 {
1845 unsigned int i;
1846
1847 for (i = 0;
1848 i < sizeof (xcoff64_howto_table) / sizeof (xcoff64_howto_table[0]);
1849 i++)
1850 if (xcoff64_howto_table[i].name != NULL
1851 && strcasecmp (xcoff64_howto_table[i].name, r_name) == 0)
1852 return &xcoff64_howto_table[i];
1853
1854 return NULL;
1855 }
1856
1857 /* Read in the armap of an XCOFF archive. */
1858
1859 static bfd_boolean
xcoff64_slurp_armap(bfd * abfd)1860 xcoff64_slurp_armap (bfd *abfd)
1861 {
1862 file_ptr off;
1863 size_t namlen;
1864 bfd_size_type sz, amt;
1865 bfd_byte *contents, *cend;
1866 bfd_vma c, i;
1867 carsym *arsym;
1868 bfd_byte *p;
1869 file_ptr pos;
1870
1871 /* This is for the new format. */
1872 struct xcoff_ar_hdr_big hdr;
1873
1874 if (xcoff_ardata (abfd) == NULL)
1875 {
1876 bfd_has_map (abfd) = FALSE;
1877 return TRUE;
1878 }
1879
1880 off = bfd_scan_vma (xcoff_ardata_big (abfd)->symoff64,
1881 (const char **) NULL, 10);
1882 if (off == 0)
1883 {
1884 bfd_has_map (abfd) = FALSE;
1885 return TRUE;
1886 }
1887
1888 if (bfd_seek (abfd, off, SEEK_SET) != 0)
1889 return FALSE;
1890
1891 /* The symbol table starts with a normal archive header. */
1892 if (bfd_bread (&hdr, (bfd_size_type) SIZEOF_AR_HDR_BIG, abfd)
1893 != SIZEOF_AR_HDR_BIG)
1894 return FALSE;
1895
1896 /* Skip the name (normally empty). */
1897 namlen = strtol (hdr.namlen, (char **) NULL, 10);
1898 pos = ((namlen + 1) & ~(size_t) 1) + SXCOFFARFMAG;
1899 if (bfd_seek (abfd, pos, SEEK_CUR) != 0)
1900 return FALSE;
1901
1902 sz = bfd_scan_vma (hdr.size, (const char **) NULL, 10);
1903
1904 /* Read in the entire symbol table. */
1905 contents = (bfd_byte *) bfd_alloc (abfd, sz);
1906 if (contents == NULL)
1907 return FALSE;
1908 if (bfd_bread (contents, sz, abfd) != sz)
1909 return FALSE;
1910
1911 /* The symbol table starts with an eight byte count. */
1912 c = H_GET_64 (abfd, contents);
1913
1914 if (c * 8 >= sz)
1915 {
1916 bfd_set_error (bfd_error_bad_value);
1917 return FALSE;
1918 }
1919 amt = c;
1920 amt *= sizeof (carsym);
1921 bfd_ardata (abfd)->symdefs = (carsym *) bfd_alloc (abfd, amt);
1922 if (bfd_ardata (abfd)->symdefs == NULL)
1923 return FALSE;
1924
1925 /* After the count comes a list of eight byte file offsets. */
1926 for (i = 0, arsym = bfd_ardata (abfd)->symdefs, p = contents + 8;
1927 i < c;
1928 ++i, ++arsym, p += 8)
1929 arsym->file_offset = H_GET_64 (abfd, p);
1930
1931 /* After the file offsets come null terminated symbol names. */
1932 cend = contents + sz;
1933 for (i = 0, arsym = bfd_ardata (abfd)->symdefs;
1934 i < c;
1935 ++i, ++arsym, p += strlen ((char *) p) + 1)
1936 {
1937 if (p >= cend)
1938 {
1939 bfd_set_error (bfd_error_bad_value);
1940 return FALSE;
1941 }
1942 arsym->name = (char *) p;
1943 }
1944
1945 bfd_ardata (abfd)->symdef_count = c;
1946 bfd_has_map (abfd) = TRUE;
1947
1948 return TRUE;
1949 }
1950
1951
1952 /* See if this is an NEW XCOFF archive. */
1953
1954 static const bfd_target *
xcoff64_archive_p(bfd * abfd)1955 xcoff64_archive_p (bfd *abfd)
1956 {
1957 struct artdata *tdata_hold;
1958 char magic[SXCOFFARMAG];
1959 /* This is the new format. */
1960 struct xcoff_ar_file_hdr_big hdr;
1961 bfd_size_type amt = SXCOFFARMAG;
1962
1963 if (bfd_bread (magic, amt, abfd) != amt)
1964 {
1965 if (bfd_get_error () != bfd_error_system_call)
1966 bfd_set_error (bfd_error_wrong_format);
1967 return NULL;
1968 }
1969
1970 if (strncmp (magic, XCOFFARMAGBIG, SXCOFFARMAG) != 0)
1971 {
1972 bfd_set_error (bfd_error_wrong_format);
1973 return NULL;
1974 }
1975
1976 /* Copy over the magic string. */
1977 memcpy (hdr.magic, magic, SXCOFFARMAG);
1978
1979 /* Now read the rest of the file header. */
1980 amt = SIZEOF_AR_FILE_HDR_BIG - SXCOFFARMAG;
1981 if (bfd_bread (&hdr.memoff, amt, abfd) != amt)
1982 {
1983 if (bfd_get_error () != bfd_error_system_call)
1984 bfd_set_error (bfd_error_wrong_format);
1985 return NULL;
1986 }
1987
1988 tdata_hold = bfd_ardata (abfd);
1989
1990 amt = sizeof (struct artdata);
1991 bfd_ardata (abfd) = (struct artdata *) bfd_zalloc (abfd, amt);
1992 if (bfd_ardata (abfd) == (struct artdata *) NULL)
1993 goto error_ret_restore;
1994
1995 /* Already cleared by bfd_zalloc above.
1996 bfd_ardata (abfd)->cache = NULL;
1997 bfd_ardata (abfd)->archive_head = NULL;
1998 bfd_ardata (abfd)->symdefs = NULL;
1999 bfd_ardata (abfd)->extended_names = NULL;
2000 bfd_ardata (abfd)->extended_names_size = 0; */
2001 bfd_ardata (abfd)->first_file_filepos = bfd_scan_vma (hdr.firstmemoff,
2002 (const char **) NULL,
2003 10);
2004
2005 amt = SIZEOF_AR_FILE_HDR_BIG;
2006 bfd_ardata (abfd)->tdata = bfd_zalloc (abfd, amt);
2007 if (bfd_ardata (abfd)->tdata == NULL)
2008 goto error_ret;
2009
2010 memcpy (bfd_ardata (abfd)->tdata, &hdr, SIZEOF_AR_FILE_HDR_BIG);
2011
2012 if (! xcoff64_slurp_armap (abfd))
2013 {
2014 error_ret:
2015 bfd_release (abfd, bfd_ardata (abfd));
2016 error_ret_restore:
2017 bfd_ardata (abfd) = tdata_hold;
2018 return NULL;
2019 }
2020
2021 return abfd->xvec;
2022 }
2023
2024
2025 /* Open the next element in an XCOFF archive. */
2026
2027 static bfd *
xcoff64_openr_next_archived_file(bfd * archive,bfd * last_file)2028 xcoff64_openr_next_archived_file (bfd *archive, bfd *last_file)
2029 {
2030 bfd_vma filestart;
2031
2032 if ((xcoff_ardata (archive) == NULL)
2033 || ! xcoff_big_format_p (archive))
2034 {
2035 bfd_set_error (bfd_error_invalid_operation);
2036 return NULL;
2037 }
2038
2039 if (last_file == NULL)
2040 {
2041 filestart = bfd_ardata (archive)->first_file_filepos;
2042 }
2043 else
2044 {
2045 filestart = bfd_scan_vma (arch_xhdr_big (last_file)->nextoff,
2046 (const char **) NULL, 10);
2047 }
2048
2049 if (filestart == 0
2050 || filestart == bfd_scan_vma (xcoff_ardata_big (archive)->memoff,
2051 (const char **) NULL, 10)
2052 || filestart == bfd_scan_vma (xcoff_ardata_big (archive)->symoff,
2053 (const char **) NULL, 10))
2054 {
2055 bfd_set_error (bfd_error_no_more_archived_files);
2056 return NULL;
2057 }
2058
2059 return _bfd_get_elt_at_filepos (archive, (file_ptr) filestart);
2060 }
2061
2062 /* We can't use the usual coff_sizeof_headers routine, because AIX
2063 always uses an a.out header. */
2064
2065 static int
xcoff64_sizeof_headers(bfd * abfd,struct bfd_link_info * info ATTRIBUTE_UNUSED)2066 xcoff64_sizeof_headers (bfd *abfd,
2067 struct bfd_link_info *info ATTRIBUTE_UNUSED)
2068 {
2069 int size;
2070
2071 size = bfd_coff_filhsz (abfd);
2072
2073 /* Don't think the small aout header can be used since some of the
2074 old elements have been reordered past the end of the old coff
2075 small aout size. */
2076
2077 if (xcoff_data (abfd)->full_aouthdr)
2078 size += bfd_coff_aoutsz (abfd);
2079
2080 size += abfd->section_count * bfd_coff_scnhsz (abfd);
2081 return size;
2082 }
2083
2084 static asection *
xcoff64_create_csect_from_smclas(bfd * abfd,union internal_auxent * aux,const char * symbol_name)2085 xcoff64_create_csect_from_smclas (bfd *abfd, union internal_auxent *aux,
2086 const char *symbol_name)
2087 {
2088 asection *return_value = NULL;
2089
2090 /* Changes from 32 :
2091 .sv == 8, is only for 32 bit programs
2092 .ti == 12 and .tb == 13 are now reserved. */
2093 static const char *names[19] =
2094 {
2095 ".pr", ".ro", ".db", ".tc", ".ua", ".rw", ".gl", ".xo",
2096 NULL, ".bs", ".ds", ".uc", NULL, NULL, NULL, ".tc0",
2097 ".td", ".sv64", ".sv3264"
2098 };
2099
2100 if ((19 >= aux->x_csect.x_smclas)
2101 && (NULL != names[aux->x_csect.x_smclas]))
2102 {
2103
2104 return_value = bfd_make_section_anyway
2105 (abfd, names[aux->x_csect.x_smclas]);
2106
2107 }
2108 else
2109 {
2110 (*_bfd_error_handler)
2111 (_("%B: symbol `%s' has unrecognized smclas %d"),
2112 abfd, symbol_name, aux->x_csect.x_smclas);
2113 bfd_set_error (bfd_error_bad_value);
2114 }
2115
2116 return return_value;
2117 }
2118
2119 static bfd_boolean
xcoff64_is_lineno_count_overflow(bfd * abfd ATTRIBUTE_UNUSED,bfd_vma value ATTRIBUTE_UNUSED)2120 xcoff64_is_lineno_count_overflow (bfd *abfd ATTRIBUTE_UNUSED,
2121 bfd_vma value ATTRIBUTE_UNUSED)
2122 {
2123 return FALSE;
2124 }
2125
2126 static bfd_boolean
xcoff64_is_reloc_count_overflow(bfd * abfd ATTRIBUTE_UNUSED,bfd_vma value ATTRIBUTE_UNUSED)2127 xcoff64_is_reloc_count_overflow (bfd *abfd ATTRIBUTE_UNUSED,
2128 bfd_vma value ATTRIBUTE_UNUSED)
2129 {
2130 return FALSE;
2131 }
2132
2133 static bfd_vma
xcoff64_loader_symbol_offset(bfd * abfd ATTRIBUTE_UNUSED,struct internal_ldhdr * ldhdr)2134 xcoff64_loader_symbol_offset (bfd *abfd ATTRIBUTE_UNUSED,
2135 struct internal_ldhdr *ldhdr)
2136 {
2137 return (ldhdr->l_symoff);
2138 }
2139
2140 static bfd_vma
xcoff64_loader_reloc_offset(bfd * abfd ATTRIBUTE_UNUSED,struct internal_ldhdr * ldhdr)2141 xcoff64_loader_reloc_offset (bfd *abfd ATTRIBUTE_UNUSED,
2142 struct internal_ldhdr *ldhdr)
2143 {
2144 return (ldhdr->l_rldoff);
2145 }
2146
2147 static bfd_boolean
xcoff64_bad_format_hook(bfd * abfd,void * filehdr)2148 xcoff64_bad_format_hook (bfd * abfd, void *filehdr)
2149 {
2150 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
2151
2152 /* Check flavor first. */
2153 if (bfd_get_flavour (abfd) != bfd_target_xcoff_flavour)
2154 return FALSE;
2155
2156 if (bfd_xcoff_magic_number (abfd) != internal_f->f_magic)
2157 return FALSE;
2158
2159 return TRUE;
2160 }
2161
2162 static bfd_boolean
xcoff64_generate_rtinit(bfd * abfd,const char * init,const char * fini,bfd_boolean rtld)2163 xcoff64_generate_rtinit (bfd *abfd, const char *init, const char *fini,
2164 bfd_boolean rtld)
2165 {
2166 bfd_byte filehdr_ext[FILHSZ];
2167 bfd_byte scnhdr_ext[SCNHSZ * 3];
2168 bfd_byte syment_ext[SYMESZ * 10];
2169 bfd_byte reloc_ext[RELSZ * 3];
2170 bfd_byte *data_buffer;
2171 bfd_size_type data_buffer_size;
2172 bfd_byte *string_table, *st_tmp;
2173 bfd_size_type string_table_size;
2174 bfd_vma val;
2175 size_t initsz, finisz;
2176 struct internal_filehdr filehdr;
2177 struct internal_scnhdr text_scnhdr;
2178 struct internal_scnhdr data_scnhdr;
2179 struct internal_scnhdr bss_scnhdr;
2180 struct internal_syment syment;
2181 union internal_auxent auxent;
2182 struct internal_reloc reloc;
2183
2184 char *text_name = ".text";
2185 char *data_name = ".data";
2186 char *bss_name = ".bss";
2187 char *rtinit_name = "__rtinit";
2188 char *rtld_name = "__rtld";
2189
2190 if (! bfd_xcoff_rtinit_size (abfd))
2191 return FALSE;
2192
2193 initsz = (init == NULL ? 0 : 1 + strlen (init));
2194 finisz = (fini == NULL ? 0 : 1 + strlen (fini));
2195
2196 /* File header. */
2197 memset (filehdr_ext, 0, FILHSZ);
2198 memset (&filehdr, 0, sizeof (struct internal_filehdr));
2199 filehdr.f_magic = bfd_xcoff_magic_number (abfd);
2200 filehdr.f_nscns = 3;
2201 filehdr.f_timdat = 0;
2202 filehdr.f_nsyms = 0; /* at least 6, no more than 8 */
2203 filehdr.f_symptr = 0; /* set below */
2204 filehdr.f_opthdr = 0;
2205 filehdr.f_flags = 0;
2206
2207 /* Section headers. */
2208 memset (scnhdr_ext, 0, 3 * SCNHSZ);
2209
2210 /* Text. */
2211 memset (&text_scnhdr, 0, sizeof (struct internal_scnhdr));
2212 memcpy (text_scnhdr.s_name, text_name, strlen (text_name));
2213 text_scnhdr.s_paddr = 0;
2214 text_scnhdr.s_vaddr = 0;
2215 text_scnhdr.s_size = 0;
2216 text_scnhdr.s_scnptr = 0;
2217 text_scnhdr.s_relptr = 0;
2218 text_scnhdr.s_lnnoptr = 0;
2219 text_scnhdr.s_nreloc = 0;
2220 text_scnhdr.s_nlnno = 0;
2221 text_scnhdr.s_flags = STYP_TEXT;
2222
2223 /* Data. */
2224 memset (&data_scnhdr, 0, sizeof (struct internal_scnhdr));
2225 memcpy (data_scnhdr.s_name, data_name, strlen (data_name));
2226 data_scnhdr.s_paddr = 0;
2227 data_scnhdr.s_vaddr = 0;
2228 data_scnhdr.s_size = 0; /* set below */
2229 data_scnhdr.s_scnptr = FILHSZ + 3 * SCNHSZ;
2230 data_scnhdr.s_relptr = 0; /* set below */
2231 data_scnhdr.s_lnnoptr = 0;
2232 data_scnhdr.s_nreloc = 0; /* either 1 or 2 */
2233 data_scnhdr.s_nlnno = 0;
2234 data_scnhdr.s_flags = STYP_DATA;
2235
2236 /* Bss. */
2237 memset (&bss_scnhdr, 0, sizeof (struct internal_scnhdr));
2238 memcpy (bss_scnhdr.s_name, bss_name, strlen (bss_name));
2239 bss_scnhdr.s_paddr = 0; /* set below */
2240 bss_scnhdr.s_vaddr = 0; /* set below */
2241 bss_scnhdr.s_size = 0; /* set below */
2242 bss_scnhdr.s_scnptr = 0;
2243 bss_scnhdr.s_relptr = 0;
2244 bss_scnhdr.s_lnnoptr = 0;
2245 bss_scnhdr.s_nreloc = 0;
2246 bss_scnhdr.s_nlnno = 0;
2247 bss_scnhdr.s_flags = STYP_BSS;
2248
2249 /* .data
2250 0x0000 0x00000000 : rtl
2251 0x0004 0x00000000 :
2252 0x0008 0x00000018 : offset to init, or 0
2253 0x000C 0x00000038 : offset to fini, or 0
2254 0x0010 0x00000010 : size of descriptor
2255 0x0014 0x00000000 : pad
2256 0x0018 0x00000000 : init, needs a reloc
2257 0x001C 0x00000000 :
2258 0x0020 0x00000058 : offset to init name
2259 0x0024 0x00000000 : flags, padded to a word
2260 0x0028 0x00000000 : empty init
2261 0x002C 0x00000000 :
2262 0x0030 0x00000000 :
2263 0x0034 0x00000000 :
2264 0x0038 0x00000000 : fini, needs a reloc
2265 0x003C 0x00000000 :
2266 0x0040 0x00000??? : offset to fini name
2267 0x0044 0x00000000 : flags, padded to a word
2268 0x0048 0x00000000 : empty fini
2269 0x004C 0x00000000 :
2270 0x0050 0x00000000 :
2271 0x0054 0x00000000 :
2272 0x0058 init name
2273 0x0058 + initsz fini name */
2274
2275 data_buffer_size = 0x0058 + initsz + finisz;
2276 data_buffer_size = (data_buffer_size + 7) &~ (bfd_size_type) 7;
2277 data_buffer = NULL;
2278 data_buffer = (bfd_byte *) bfd_zmalloc (data_buffer_size);
2279 if (data_buffer == NULL)
2280 return FALSE;
2281
2282 if (initsz)
2283 {
2284 val = 0x18;
2285 bfd_put_32 (abfd, val, &data_buffer[0x08]);
2286 val = 0x58;
2287 bfd_put_32 (abfd, val, &data_buffer[0x20]);
2288 memcpy (&data_buffer[val], init, initsz);
2289 }
2290
2291 if (finisz)
2292 {
2293 val = 0x38;
2294 bfd_put_32 (abfd, val, &data_buffer[0x0C]);
2295 val = 0x58 + initsz;
2296 bfd_put_32 (abfd, val, &data_buffer[0x40]);
2297 memcpy (&data_buffer[val], fini, finisz);
2298 }
2299
2300 val = 0x10;
2301 bfd_put_32 (abfd, val, &data_buffer[0x10]);
2302 data_scnhdr.s_size = data_buffer_size;
2303 bss_scnhdr.s_paddr = bss_scnhdr.s_vaddr = data_scnhdr.s_size;
2304
2305 /* String table. */
2306 string_table_size = 4;
2307 string_table_size += strlen (data_name) + 1;
2308 string_table_size += strlen (rtinit_name) + 1;
2309 string_table_size += initsz;
2310 string_table_size += finisz;
2311 if (rtld)
2312 string_table_size += strlen (rtld_name) + 1;
2313
2314 string_table = (bfd_byte *) bfd_zmalloc (string_table_size);
2315 if (string_table == NULL)
2316 return FALSE;
2317
2318 val = string_table_size;
2319 bfd_put_32 (abfd, val, &string_table[0]);
2320 st_tmp = string_table + 4;
2321
2322 /* symbols
2323 0. .data csect
2324 2. __rtinit
2325 4. init function
2326 6. fini function
2327 8. __rtld */
2328 memset (syment_ext, 0, 10 * SYMESZ);
2329 memset (reloc_ext, 0, 3 * RELSZ);
2330
2331 /* .data csect */
2332 memset (&syment, 0, sizeof (struct internal_syment));
2333 memset (&auxent, 0, sizeof (union internal_auxent));
2334
2335 syment._n._n_n._n_offset = st_tmp - string_table;
2336 memcpy (st_tmp, data_name, strlen (data_name));
2337 st_tmp += strlen (data_name) + 1;
2338
2339 syment.n_scnum = 2;
2340 syment.n_sclass = C_HIDEXT;
2341 syment.n_numaux = 1;
2342 auxent.x_csect.x_scnlen.l = data_buffer_size;
2343 auxent.x_csect.x_smtyp = 3 << 3 | XTY_SD;
2344 auxent.x_csect.x_smclas = XMC_RW;
2345 bfd_coff_swap_sym_out (abfd, &syment,
2346 &syment_ext[filehdr.f_nsyms * SYMESZ]);
2347 bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
2348 syment.n_numaux,
2349 &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
2350 filehdr.f_nsyms += 2;
2351
2352 /* __rtinit */
2353 memset (&syment, 0, sizeof (struct internal_syment));
2354 memset (&auxent, 0, sizeof (union internal_auxent));
2355 syment._n._n_n._n_offset = st_tmp - string_table;
2356 memcpy (st_tmp, rtinit_name, strlen (rtinit_name));
2357 st_tmp += strlen (rtinit_name) + 1;
2358
2359 syment.n_scnum = 2;
2360 syment.n_sclass = C_EXT;
2361 syment.n_numaux = 1;
2362 auxent.x_csect.x_smtyp = XTY_LD;
2363 auxent.x_csect.x_smclas = XMC_RW;
2364 bfd_coff_swap_sym_out (abfd, &syment,
2365 &syment_ext[filehdr.f_nsyms * SYMESZ]);
2366 bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
2367 syment.n_numaux,
2368 &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
2369 filehdr.f_nsyms += 2;
2370
2371 /* Init. */
2372 if (initsz)
2373 {
2374 memset (&syment, 0, sizeof (struct internal_syment));
2375 memset (&auxent, 0, sizeof (union internal_auxent));
2376
2377 syment._n._n_n._n_offset = st_tmp - string_table;
2378 memcpy (st_tmp, init, initsz);
2379 st_tmp += initsz;
2380
2381 syment.n_sclass = C_EXT;
2382 syment.n_numaux = 1;
2383 bfd_coff_swap_sym_out (abfd, &syment,
2384 &syment_ext[filehdr.f_nsyms * SYMESZ]);
2385 bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
2386 syment.n_numaux,
2387 &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
2388 /* Reloc. */
2389 memset (&reloc, 0, sizeof (struct internal_reloc));
2390 reloc.r_vaddr = 0x0018;
2391 reloc.r_symndx = filehdr.f_nsyms;
2392 reloc.r_type = R_POS;
2393 reloc.r_size = 63;
2394 bfd_coff_swap_reloc_out (abfd, &reloc, &reloc_ext[0]);
2395
2396 filehdr.f_nsyms += 2;
2397 data_scnhdr.s_nreloc += 1;
2398 }
2399
2400 /* Finit. */
2401 if (finisz)
2402 {
2403 memset (&syment, 0, sizeof (struct internal_syment));
2404 memset (&auxent, 0, sizeof (union internal_auxent));
2405
2406 syment._n._n_n._n_offset = st_tmp - string_table;
2407 memcpy (st_tmp, fini, finisz);
2408 st_tmp += finisz;
2409
2410 syment.n_sclass = C_EXT;
2411 syment.n_numaux = 1;
2412 bfd_coff_swap_sym_out (abfd, &syment,
2413 &syment_ext[filehdr.f_nsyms * SYMESZ]);
2414 bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
2415 syment.n_numaux,
2416 &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
2417
2418 /* Reloc. */
2419 memset (&reloc, 0, sizeof (struct internal_reloc));
2420 reloc.r_vaddr = 0x0038;
2421 reloc.r_symndx = filehdr.f_nsyms;
2422 reloc.r_type = R_POS;
2423 reloc.r_size = 63;
2424 bfd_coff_swap_reloc_out (abfd, &reloc,
2425 &reloc_ext[data_scnhdr.s_nreloc * RELSZ]);
2426
2427 filehdr.f_nsyms += 2;
2428 data_scnhdr.s_nreloc += 1;
2429 }
2430
2431 if (rtld)
2432 {
2433 memset (&syment, 0, sizeof (struct internal_syment));
2434 memset (&auxent, 0, sizeof (union internal_auxent));
2435
2436 syment._n._n_n._n_offset = st_tmp - string_table;
2437 memcpy (st_tmp, rtld_name, strlen (rtld_name));
2438 st_tmp += strlen (rtld_name) + 1;
2439
2440 syment.n_sclass = C_EXT;
2441 syment.n_numaux = 1;
2442 bfd_coff_swap_sym_out (abfd, &syment,
2443 &syment_ext[filehdr.f_nsyms * SYMESZ]);
2444 bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
2445 syment.n_numaux,
2446 &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
2447
2448 /* Reloc. */
2449 memset (&reloc, 0, sizeof (struct internal_reloc));
2450 reloc.r_vaddr = 0x0000;
2451 reloc.r_symndx = filehdr.f_nsyms;
2452 reloc.r_type = R_POS;
2453 reloc.r_size = 63;
2454 bfd_coff_swap_reloc_out (abfd, &reloc,
2455 &reloc_ext[data_scnhdr.s_nreloc * RELSZ]);
2456
2457 filehdr.f_nsyms += 2;
2458 data_scnhdr.s_nreloc += 1;
2459
2460 bss_scnhdr.s_size = 0;
2461 }
2462
2463 data_scnhdr.s_relptr = data_scnhdr.s_scnptr + data_buffer_size;
2464 filehdr.f_symptr = data_scnhdr.s_relptr + data_scnhdr.s_nreloc * RELSZ;
2465
2466 bfd_coff_swap_filehdr_out (abfd, &filehdr, filehdr_ext);
2467 bfd_bwrite (filehdr_ext, FILHSZ, abfd);
2468 bfd_coff_swap_scnhdr_out (abfd, &text_scnhdr, &scnhdr_ext[SCNHSZ * 0]);
2469 bfd_coff_swap_scnhdr_out (abfd, &data_scnhdr, &scnhdr_ext[SCNHSZ * 1]);
2470 bfd_coff_swap_scnhdr_out (abfd, &bss_scnhdr, &scnhdr_ext[SCNHSZ * 2]);
2471 bfd_bwrite (scnhdr_ext, 3 * SCNHSZ, abfd);
2472 bfd_bwrite (data_buffer, data_buffer_size, abfd);
2473 bfd_bwrite (reloc_ext, data_scnhdr.s_nreloc * RELSZ, abfd);
2474 bfd_bwrite (syment_ext, filehdr.f_nsyms * SYMESZ, abfd);
2475 bfd_bwrite (string_table, string_table_size, abfd);
2476
2477 free (data_buffer);
2478 data_buffer = NULL;
2479
2480 return TRUE;
2481 }
2482
2483 /* The typical dynamic reloc. */
2484
2485 static reloc_howto_type xcoff64_dynamic_reloc =
2486 HOWTO (0, /* type */
2487 0, /* rightshift */
2488 4, /* size (0 = byte, 1 = short, 2 = long) */
2489 64, /* bitsize */
2490 FALSE, /* pc_relative */
2491 0, /* bitpos */
2492 complain_overflow_bitfield, /* complain_on_overflow */
2493 0, /* special_function */
2494 "R_POS", /* name */
2495 TRUE, /* partial_inplace */
2496 MINUS_ONE, /* src_mask */
2497 MINUS_ONE, /* dst_mask */
2498 FALSE); /* pcrel_offset */
2499
2500 static unsigned long xcoff64_glink_code[10] =
2501 {
2502 0xe9820000, /* ld r12,0(r2) */
2503 0xf8410028, /* std r2,40(r1) */
2504 0xe80c0000, /* ld r0,0(r12) */
2505 0xe84c0008, /* ld r0,8(r12) */
2506 0x7c0903a6, /* mtctr r0 */
2507 0x4e800420, /* bctr */
2508 0x00000000, /* start of traceback table */
2509 0x000ca000, /* traceback table */
2510 0x00000000, /* traceback table */
2511 0x00000018, /* ??? */
2512 };
2513
2514 static const struct xcoff_backend_data_rec bfd_xcoff_backend_data =
2515 {
2516 { /* COFF backend, defined in libcoff.h. */
2517 _bfd_xcoff64_swap_aux_in,
2518 _bfd_xcoff64_swap_sym_in,
2519 _bfd_xcoff64_swap_lineno_in,
2520 _bfd_xcoff64_swap_aux_out,
2521 _bfd_xcoff64_swap_sym_out,
2522 _bfd_xcoff64_swap_lineno_out,
2523 xcoff64_swap_reloc_out,
2524 coff_swap_filehdr_out,
2525 coff_swap_aouthdr_out,
2526 coff_swap_scnhdr_out,
2527 FILHSZ,
2528 AOUTSZ,
2529 SCNHSZ,
2530 SYMESZ,
2531 AUXESZ,
2532 RELSZ,
2533 LINESZ,
2534 FILNMLEN,
2535 TRUE, /* _bfd_coff_long_filenames */
2536 XCOFF_NO_LONG_SECTION_NAMES, /* _bfd_coff_long_section_names */
2537 3, /* _bfd_coff_default_section_alignment_power */
2538 TRUE, /* _bfd_coff_force_symnames_in_strings */
2539 4, /* _bfd_coff_debug_string_prefix_length */
2540 coff_swap_filehdr_in,
2541 coff_swap_aouthdr_in,
2542 coff_swap_scnhdr_in,
2543 xcoff64_swap_reloc_in,
2544 xcoff64_bad_format_hook,
2545 coff_set_arch_mach_hook,
2546 coff_mkobject_hook,
2547 styp_to_sec_flags,
2548 coff_set_alignment_hook,
2549 coff_slurp_symbol_table,
2550 symname_in_debug_hook,
2551 coff_pointerize_aux_hook,
2552 coff_print_aux,
2553 dummy_reloc16_extra_cases,
2554 dummy_reloc16_estimate,
2555 NULL, /* bfd_coff_symbol_classification */
2556 coff_compute_section_file_positions,
2557 NULL, /* _bfd_coff_start_final_link */
2558 xcoff64_ppc_relocate_section,
2559 coff_rtype_to_howto,
2560 NULL, /* _bfd_coff_adjust_symndx */
2561 _bfd_generic_link_add_one_symbol,
2562 coff_link_output_has_begun,
2563 coff_final_link_postscript,
2564 NULL /* print_pdata. */
2565 },
2566
2567 0x01EF, /* magic number */
2568 bfd_arch_powerpc,
2569 bfd_mach_ppc_620,
2570
2571 /* Function pointers to xcoff specific swap routines. */
2572 xcoff64_swap_ldhdr_in,
2573 xcoff64_swap_ldhdr_out,
2574 xcoff64_swap_ldsym_in,
2575 xcoff64_swap_ldsym_out,
2576 xcoff64_swap_ldrel_in,
2577 xcoff64_swap_ldrel_out,
2578
2579 /* Sizes. */
2580 LDHDRSZ,
2581 LDSYMSZ,
2582 LDRELSZ,
2583 24, /* _xcoff_function_descriptor_size */
2584 0, /* _xcoff_small_aout_header_size */
2585
2586 /* Versions. */
2587 2, /* _xcoff_ldhdr_version */
2588
2589 _bfd_xcoff64_put_symbol_name,
2590 _bfd_xcoff64_put_ldsymbol_name,
2591 &xcoff64_dynamic_reloc,
2592 xcoff64_create_csect_from_smclas,
2593
2594 /* Lineno and reloc count overflow. */
2595 xcoff64_is_lineno_count_overflow,
2596 xcoff64_is_reloc_count_overflow,
2597
2598 xcoff64_loader_symbol_offset,
2599 xcoff64_loader_reloc_offset,
2600
2601 /* glink. */
2602 &xcoff64_glink_code[0],
2603 40, /* _xcoff_glink_size */
2604
2605 /* rtinit. */
2606 88, /* _xcoff_rtinit_size */
2607 xcoff64_generate_rtinit,
2608 };
2609
2610 /* The transfer vector that leads the outside world to all of the above. */
2611 const bfd_target rs6000coff64_vec =
2612 {
2613 "aixcoff64-rs6000",
2614 bfd_target_xcoff_flavour,
2615 BFD_ENDIAN_BIG, /* data byte order is big */
2616 BFD_ENDIAN_BIG, /* header byte order is big */
2617
2618 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | DYNAMIC
2619 | HAS_SYMS | HAS_LOCALS | WP_TEXT),
2620
2621 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA,
2622 0, /* leading char */
2623 '/', /* ar_pad_char */
2624 15, /* ar_max_namelen */
2625 0, /* match priority. */
2626
2627 /* data */
2628 bfd_getb64,
2629 bfd_getb_signed_64,
2630 bfd_putb64,
2631 bfd_getb32,
2632 bfd_getb_signed_32,
2633 bfd_putb32,
2634 bfd_getb16,
2635 bfd_getb_signed_16,
2636 bfd_putb16,
2637
2638 /* hdrs */
2639 bfd_getb64,
2640 bfd_getb_signed_64,
2641 bfd_putb64,
2642 bfd_getb32,
2643 bfd_getb_signed_32,
2644 bfd_putb32,
2645 bfd_getb16,
2646 bfd_getb_signed_16,
2647 bfd_putb16,
2648
2649 { /* bfd_check_format */
2650 _bfd_dummy_target,
2651 coff_object_p,
2652 xcoff64_archive_p,
2653 CORE_FILE_P
2654 },
2655
2656 { /* bfd_set_format */
2657 bfd_false,
2658 coff_mkobject,
2659 _bfd_generic_mkarchive,
2660 bfd_false
2661 },
2662
2663 {/* bfd_write_contents */
2664 bfd_false,
2665 xcoff64_write_object_contents,
2666 _bfd_xcoff_write_archive_contents,
2667 bfd_false
2668 },
2669
2670 /* Generic */
2671 _bfd_archive_close_and_cleanup,
2672 bfd_true,
2673 coff_new_section_hook,
2674 _bfd_generic_get_section_contents,
2675 _bfd_generic_get_section_contents_in_window,
2676
2677 /* Copy */
2678 _bfd_xcoff_copy_private_bfd_data,
2679 _bfd_generic_bfd_merge_private_bfd_data,
2680 _bfd_generic_init_private_section_data,
2681 _bfd_generic_bfd_copy_private_section_data,
2682 _bfd_generic_bfd_copy_private_symbol_data,
2683 _bfd_generic_bfd_copy_private_header_data,
2684 _bfd_generic_bfd_set_private_flags,
2685 _bfd_generic_bfd_print_private_bfd_data,
2686
2687 /* Core */
2688 BFD_JUMP_TABLE_CORE (coff),
2689
2690 /* Archive */
2691 xcoff64_slurp_armap,
2692 _bfd_noarchive_slurp_extended_name_table,
2693 _bfd_noarchive_construct_extended_name_table,
2694 bfd_dont_truncate_arname,
2695 _bfd_xcoff_write_armap,
2696 _bfd_xcoff_read_ar_hdr,
2697 _bfd_generic_write_ar_hdr,
2698 xcoff64_openr_next_archived_file,
2699 _bfd_generic_get_elt_at_index,
2700 _bfd_xcoff_stat_arch_elt,
2701 bfd_true,
2702
2703 /* Symbols */
2704 coff_get_symtab_upper_bound,
2705 coff_canonicalize_symtab,
2706 coff_make_empty_symbol,
2707 coff_print_symbol,
2708 coff_get_symbol_info,
2709 _bfd_xcoff_is_local_label_name,
2710 coff_bfd_is_target_special_symbol,
2711 coff_get_lineno,
2712 coff_find_nearest_line,
2713 _bfd_generic_find_nearest_line_discriminator,
2714 _bfd_generic_find_line,
2715 coff_find_inliner_info,
2716 coff_bfd_make_debug_symbol,
2717 _bfd_generic_read_minisymbols,
2718 _bfd_generic_minisymbol_to_symbol,
2719
2720 /* Reloc */
2721 coff_get_reloc_upper_bound,
2722 coff_canonicalize_reloc,
2723 xcoff64_reloc_type_lookup,
2724 xcoff64_reloc_name_lookup,
2725
2726 /* Write */
2727 coff_set_arch_mach,
2728 coff_set_section_contents,
2729
2730 /* Link */
2731 xcoff64_sizeof_headers,
2732 bfd_generic_get_relocated_section_contents,
2733 bfd_generic_relax_section,
2734 _bfd_xcoff_bfd_link_hash_table_create,
2735 _bfd_generic_link_hash_table_free,
2736 _bfd_xcoff_bfd_link_add_symbols,
2737 _bfd_generic_link_just_syms,
2738 _bfd_generic_copy_link_hash_symbol_type,
2739 _bfd_xcoff_bfd_final_link,
2740 _bfd_generic_link_split_section,
2741 bfd_generic_gc_sections,
2742 bfd_generic_lookup_section_flags,
2743 bfd_generic_merge_sections,
2744 bfd_generic_is_group_section,
2745 bfd_generic_discard_group,
2746 _bfd_generic_section_already_linked,
2747 _bfd_xcoff_define_common_symbol,
2748
2749 /* Dynamic */
2750 _bfd_xcoff_get_dynamic_symtab_upper_bound,
2751 _bfd_xcoff_canonicalize_dynamic_symtab,
2752 _bfd_nodynamic_get_synthetic_symtab,
2753 _bfd_xcoff_get_dynamic_reloc_upper_bound,
2754 _bfd_xcoff_canonicalize_dynamic_reloc,
2755
2756 /* Opposite endian version, none exists */
2757 NULL,
2758
2759 &bfd_xcoff_backend_data,
2760 };
2761
2762 extern const bfd_target *xcoff64_core_p
2763 (bfd *);
2764 extern bfd_boolean xcoff64_core_file_matches_executable_p
2765 (bfd *, bfd *);
2766 extern char *xcoff64_core_file_failing_command
2767 (bfd *);
2768 extern int xcoff64_core_file_failing_signal
2769 (bfd *);
2770 #define xcoff64_core_file_pid _bfd_nocore_core_file_pid
2771
2772 /* AIX 5 */
2773 static const struct xcoff_backend_data_rec bfd_xcoff_aix5_backend_data =
2774 {
2775 { /* COFF backend, defined in libcoff.h. */
2776 _bfd_xcoff64_swap_aux_in,
2777 _bfd_xcoff64_swap_sym_in,
2778 _bfd_xcoff64_swap_lineno_in,
2779 _bfd_xcoff64_swap_aux_out,
2780 _bfd_xcoff64_swap_sym_out,
2781 _bfd_xcoff64_swap_lineno_out,
2782 xcoff64_swap_reloc_out,
2783 coff_swap_filehdr_out,
2784 coff_swap_aouthdr_out,
2785 coff_swap_scnhdr_out,
2786 FILHSZ,
2787 AOUTSZ,
2788 SCNHSZ,
2789 SYMESZ,
2790 AUXESZ,
2791 RELSZ,
2792 LINESZ,
2793 FILNMLEN,
2794 TRUE, /* _bfd_coff_long_filenames */
2795 XCOFF_NO_LONG_SECTION_NAMES, /* _bfd_coff_long_section_names */
2796 3, /* _bfd_coff_default_section_alignment_power */
2797 TRUE, /* _bfd_coff_force_symnames_in_strings */
2798 4, /* _bfd_coff_debug_string_prefix_length */
2799 coff_swap_filehdr_in,
2800 coff_swap_aouthdr_in,
2801 coff_swap_scnhdr_in,
2802 xcoff64_swap_reloc_in,
2803 xcoff64_bad_format_hook,
2804 coff_set_arch_mach_hook,
2805 coff_mkobject_hook,
2806 styp_to_sec_flags,
2807 coff_set_alignment_hook,
2808 coff_slurp_symbol_table,
2809 symname_in_debug_hook,
2810 coff_pointerize_aux_hook,
2811 coff_print_aux,
2812 dummy_reloc16_extra_cases,
2813 dummy_reloc16_estimate,
2814 NULL, /* bfd_coff_sym_is_global */
2815 coff_compute_section_file_positions,
2816 NULL, /* _bfd_coff_start_final_link */
2817 xcoff64_ppc_relocate_section,
2818 coff_rtype_to_howto,
2819 NULL, /* _bfd_coff_adjust_symndx */
2820 _bfd_generic_link_add_one_symbol,
2821 coff_link_output_has_begun,
2822 coff_final_link_postscript,
2823 NULL /* print_pdata. */
2824 },
2825
2826 U64_TOCMAGIC, /* magic number */
2827 bfd_arch_powerpc,
2828 bfd_mach_ppc_620,
2829
2830 /* Function pointers to xcoff specific swap routines. */
2831 xcoff64_swap_ldhdr_in,
2832 xcoff64_swap_ldhdr_out,
2833 xcoff64_swap_ldsym_in,
2834 xcoff64_swap_ldsym_out,
2835 xcoff64_swap_ldrel_in,
2836 xcoff64_swap_ldrel_out,
2837
2838 /* Sizes. */
2839 LDHDRSZ,
2840 LDSYMSZ,
2841 LDRELSZ,
2842 24, /* _xcoff_function_descriptor_size */
2843 0, /* _xcoff_small_aout_header_size */
2844 /* Versions. */
2845 2, /* _xcoff_ldhdr_version */
2846
2847 _bfd_xcoff64_put_symbol_name,
2848 _bfd_xcoff64_put_ldsymbol_name,
2849 &xcoff64_dynamic_reloc,
2850 xcoff64_create_csect_from_smclas,
2851
2852 /* Lineno and reloc count overflow. */
2853 xcoff64_is_lineno_count_overflow,
2854 xcoff64_is_reloc_count_overflow,
2855
2856 xcoff64_loader_symbol_offset,
2857 xcoff64_loader_reloc_offset,
2858
2859 /* glink. */
2860 &xcoff64_glink_code[0],
2861 40, /* _xcoff_glink_size */
2862
2863 /* rtinit. */
2864 88, /* _xcoff_rtinit_size */
2865 xcoff64_generate_rtinit,
2866 };
2867
2868 /* The transfer vector that leads the outside world to all of the above. */
2869 const bfd_target aix5coff64_vec =
2870 {
2871 "aix5coff64-rs6000",
2872 bfd_target_xcoff_flavour,
2873 BFD_ENDIAN_BIG, /* data byte order is big */
2874 BFD_ENDIAN_BIG, /* header byte order is big */
2875
2876 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | DYNAMIC
2877 | HAS_SYMS | HAS_LOCALS | WP_TEXT),
2878
2879 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA,
2880 0, /* leading char */
2881 '/', /* ar_pad_char */
2882 15, /* ar_max_namelen */
2883 0, /* match priority. */
2884
2885 /* data */
2886 bfd_getb64,
2887 bfd_getb_signed_64,
2888 bfd_putb64,
2889 bfd_getb32,
2890 bfd_getb_signed_32,
2891 bfd_putb32,
2892 bfd_getb16,
2893 bfd_getb_signed_16,
2894 bfd_putb16,
2895
2896 /* hdrs */
2897 bfd_getb64,
2898 bfd_getb_signed_64,
2899 bfd_putb64,
2900 bfd_getb32,
2901 bfd_getb_signed_32,
2902 bfd_putb32,
2903 bfd_getb16,
2904 bfd_getb_signed_16,
2905 bfd_putb16,
2906
2907 { /* bfd_check_format */
2908 _bfd_dummy_target,
2909 coff_object_p,
2910 xcoff64_archive_p,
2911 xcoff64_core_p
2912 },
2913
2914 { /* bfd_set_format */
2915 bfd_false,
2916 coff_mkobject,
2917 _bfd_generic_mkarchive,
2918 bfd_false
2919 },
2920
2921 {/* bfd_write_contents */
2922 bfd_false,
2923 xcoff64_write_object_contents,
2924 _bfd_xcoff_write_archive_contents,
2925 bfd_false
2926 },
2927
2928 /* Generic */
2929 _bfd_archive_close_and_cleanup,
2930 bfd_true,
2931 coff_new_section_hook,
2932 _bfd_generic_get_section_contents,
2933 _bfd_generic_get_section_contents_in_window,
2934
2935 /* Copy */
2936 _bfd_xcoff_copy_private_bfd_data,
2937 _bfd_generic_bfd_merge_private_bfd_data,
2938 _bfd_generic_init_private_section_data,
2939 _bfd_generic_bfd_copy_private_section_data,
2940 _bfd_generic_bfd_copy_private_symbol_data,
2941 _bfd_generic_bfd_copy_private_header_data,
2942 _bfd_generic_bfd_set_private_flags,
2943 _bfd_generic_bfd_print_private_bfd_data,
2944
2945 /* Core */
2946 BFD_JUMP_TABLE_CORE (xcoff64),
2947
2948 /* Archive */
2949 xcoff64_slurp_armap,
2950 _bfd_noarchive_slurp_extended_name_table,
2951 _bfd_noarchive_construct_extended_name_table,
2952 bfd_dont_truncate_arname,
2953 _bfd_xcoff_write_armap,
2954 _bfd_xcoff_read_ar_hdr,
2955 _bfd_generic_write_ar_hdr,
2956 xcoff64_openr_next_archived_file,
2957 _bfd_generic_get_elt_at_index,
2958 _bfd_xcoff_stat_arch_elt,
2959 bfd_true,
2960
2961 /* Symbols */
2962 coff_get_symtab_upper_bound,
2963 coff_canonicalize_symtab,
2964 coff_make_empty_symbol,
2965 coff_print_symbol,
2966 coff_get_symbol_info,
2967 _bfd_xcoff_is_local_label_name,
2968 coff_bfd_is_target_special_symbol,
2969 coff_get_lineno,
2970 coff_find_nearest_line,
2971 _bfd_generic_find_nearest_line_discriminator,
2972 _bfd_generic_find_line,
2973 coff_find_inliner_info,
2974 coff_bfd_make_debug_symbol,
2975 _bfd_generic_read_minisymbols,
2976 _bfd_generic_minisymbol_to_symbol,
2977
2978 /* Reloc */
2979 coff_get_reloc_upper_bound,
2980 coff_canonicalize_reloc,
2981 xcoff64_reloc_type_lookup,
2982 xcoff64_reloc_name_lookup,
2983
2984 /* Write */
2985 coff_set_arch_mach,
2986 coff_set_section_contents,
2987
2988 /* Link */
2989 xcoff64_sizeof_headers,
2990 bfd_generic_get_relocated_section_contents,
2991 bfd_generic_relax_section,
2992 _bfd_xcoff_bfd_link_hash_table_create,
2993 _bfd_generic_link_hash_table_free,
2994 _bfd_xcoff_bfd_link_add_symbols,
2995 _bfd_generic_link_just_syms,
2996 _bfd_generic_copy_link_hash_symbol_type,
2997 _bfd_xcoff_bfd_final_link,
2998 _bfd_generic_link_split_section,
2999 bfd_generic_gc_sections,
3000 bfd_generic_lookup_section_flags,
3001 bfd_generic_merge_sections,
3002 bfd_generic_is_group_section,
3003 bfd_generic_discard_group,
3004 _bfd_generic_section_already_linked,
3005 _bfd_xcoff_define_common_symbol,
3006
3007 /* Dynamic */
3008 _bfd_xcoff_get_dynamic_symtab_upper_bound,
3009 _bfd_xcoff_canonicalize_dynamic_symtab,
3010 _bfd_nodynamic_get_synthetic_symtab,
3011 _bfd_xcoff_get_dynamic_reloc_upper_bound,
3012 _bfd_xcoff_canonicalize_dynamic_reloc,
3013
3014 /* Opposite endian version, none exists. */
3015 NULL,
3016
3017 & bfd_xcoff_aix5_backend_data,
3018 };
3019