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