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