?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
binutils/
[binutils.git] / bfd / coff-rs6000.c
blob334353056f490ae3b23ccc945628681b3b7f099b
1 /* BFD back-end for IBM RS/6000 "XCOFF" files.
2 Copyright 1990-1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
3 2008, 2009 Free Software Foundation, Inc.
4 Written by Metin G. Ozisik, Mimi Phuong-Thao Vo, and John Gilmore.
5 Archive support from Damon A. Permezel.
6 Contributed by IBM Corporation and Cygnus Support.
7
8 This file is part of BFD, the Binary File Descriptor library.
9
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
23 MA 02110-1301, USA. */
24
25 #include "sysdep.h"
26 #include "bfd.h"
27 #include "bfdlink.h"
28 #include "libbfd.h"
29 #include "coff/internal.h"
30 #include "coff/xcoff.h"
31 #include "coff/rs6000.h"
32 #include "libcoff.h"
33 #include "libxcoff.h"
34
35 extern bfd_boolean _bfd_xcoff_mkobject
36 PARAMS ((bfd *));
37 extern bfd_boolean _bfd_xcoff_copy_private_bfd_data
38 PARAMS ((bfd *, bfd *));
39 extern bfd_boolean _bfd_xcoff_is_local_label_name
40 PARAMS ((bfd *, const char *));
41 extern reloc_howto_type *_bfd_xcoff_reloc_type_lookup
42 PARAMS ((bfd *, bfd_reloc_code_real_type));
43 extern bfd_boolean _bfd_xcoff_slurp_armap
44 PARAMS ((bfd *));
45 extern const bfd_target *_bfd_xcoff_archive_p
46 PARAMS ((bfd *));
47 extern PTR _bfd_xcoff_read_ar_hdr
48 PARAMS ((bfd *));
49 extern bfd *_bfd_xcoff_openr_next_archived_file
50 PARAMS ((bfd *, bfd *));
51 extern int _bfd_xcoff_stat_arch_elt
52 PARAMS ((bfd *, struct stat *));
53 extern bfd_boolean _bfd_xcoff_write_armap
54 PARAMS ((bfd *, unsigned int, struct orl *, unsigned int, int));
55 extern bfd_boolean _bfd_xcoff_write_archive_contents
56 PARAMS ((bfd *));
57 extern int _bfd_xcoff_sizeof_headers
58 PARAMS ((bfd *, struct bfd_link_info *));
59 extern void _bfd_xcoff_swap_sym_in
60 PARAMS ((bfd *, PTR, PTR));
61 extern unsigned int _bfd_xcoff_swap_sym_out
62 PARAMS ((bfd *, PTR, PTR));
63 extern void _bfd_xcoff_swap_aux_in
64 PARAMS ((bfd *, PTR, int, int, int, int, PTR));
65 extern unsigned int _bfd_xcoff_swap_aux_out
66 PARAMS ((bfd *, PTR, int, int, int, int, PTR));
67 static void xcoff_swap_reloc_in
68 PARAMS ((bfd *, PTR, PTR));
69 static unsigned int xcoff_swap_reloc_out
70 PARAMS ((bfd *, PTR, PTR));
71
72 /* Forward declare xcoff_rtype2howto for coffcode.h macro. */
73 void xcoff_rtype2howto
74 PARAMS ((arelent *, struct internal_reloc *));
75
76 /* coffcode.h needs these to be defined. */
77 #define RS6000COFF_C 1
78
79 #define SELECT_RELOC(internal, howto) \
80 { \
81 internal.r_type = howto->type; \
82 internal.r_size = \
83 ((howto->complain_on_overflow == complain_overflow_signed \
84 ? 0x80 \
85 : 0) \
86 | (howto->bitsize - 1)); \
87 }
88
89 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (3)
90 #define COFF_LONG_FILENAMES
91 #define NO_COFF_SYMBOLS
92 #define RTYPE2HOWTO(cache_ptr, dst) xcoff_rtype2howto (cache_ptr, dst)
93 #define coff_mkobject _bfd_xcoff_mkobject
94 #define coff_bfd_copy_private_bfd_data _bfd_xcoff_copy_private_bfd_data
95 #define coff_bfd_is_local_label_name _bfd_xcoff_is_local_label_name
96 #define coff_bfd_reloc_type_lookup _bfd_xcoff_reloc_type_lookup
97 #define coff_bfd_reloc_name_lookup _bfd_xcoff_reloc_name_lookup
98 #ifdef AIX_CORE
99 extern const bfd_target * rs6000coff_core_p
100 PARAMS ((bfd *abfd));
101 extern bfd_boolean rs6000coff_core_file_matches_executable_p
102 PARAMS ((bfd *cbfd, bfd *ebfd));
103 extern char *rs6000coff_core_file_failing_command
104 PARAMS ((bfd *abfd));
105 extern int rs6000coff_core_file_failing_signal
106 PARAMS ((bfd *abfd));
107 #define CORE_FILE_P rs6000coff_core_p
108 #define coff_core_file_failing_command \
109 rs6000coff_core_file_failing_command
110 #define coff_core_file_failing_signal \
111 rs6000coff_core_file_failing_signal
112 #define coff_core_file_matches_executable_p \
113 rs6000coff_core_file_matches_executable_p
114 #else
115 #define CORE_FILE_P _bfd_dummy_target
116 #define coff_core_file_failing_command \
117 _bfd_nocore_core_file_failing_command
118 #define coff_core_file_failing_signal \
119 _bfd_nocore_core_file_failing_signal
120 #define coff_core_file_matches_executable_p \
121 _bfd_nocore_core_file_matches_executable_p
122 #endif
123 #define coff_SWAP_sym_in _bfd_xcoff_swap_sym_in
124 #define coff_SWAP_sym_out _bfd_xcoff_swap_sym_out
125 #define coff_SWAP_aux_in _bfd_xcoff_swap_aux_in
126 #define coff_SWAP_aux_out _bfd_xcoff_swap_aux_out
127 #define coff_swap_reloc_in xcoff_swap_reloc_in
128 #define coff_swap_reloc_out xcoff_swap_reloc_out
129 #define NO_COFF_RELOCS
130
131 #ifndef bfd_pe_print_pdata
132 #define bfd_pe_print_pdata NULL
133 #endif
134
135 #include "coffcode.h"
136
137 /* The main body of code is in coffcode.h. */
138
139 static const char *normalize_filename
140 PARAMS ((bfd *));
141 static bfd_boolean xcoff_write_armap_old
142 PARAMS ((bfd *, unsigned int, struct orl *, unsigned int, int));
143 static bfd_boolean xcoff_write_armap_big
144 PARAMS ((bfd *, unsigned int, struct orl *, unsigned int, int));
145 static bfd_boolean xcoff_write_archive_contents_old
146 PARAMS ((bfd *));
147 static bfd_boolean xcoff_write_archive_contents_big
148 PARAMS ((bfd *));
149 static void xcoff_swap_ldhdr_in
150 PARAMS ((bfd *, const PTR, struct internal_ldhdr *));
151 static void xcoff_swap_ldhdr_out
152 PARAMS ((bfd *, const struct internal_ldhdr *, PTR));
153 static void xcoff_swap_ldsym_in
154 PARAMS ((bfd *, const PTR, struct internal_ldsym *));
155 static void xcoff_swap_ldsym_out
156 PARAMS ((bfd *, const struct internal_ldsym *, PTR));
157 static void xcoff_swap_ldrel_in
158 PARAMS ((bfd *, const PTR, struct internal_ldrel *));
159 static void xcoff_swap_ldrel_out
160 PARAMS ((bfd *, const struct internal_ldrel *, PTR));
161 static bfd_boolean xcoff_ppc_relocate_section
162 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
163 struct internal_reloc *, struct internal_syment *, asection **));
164 static bfd_boolean _bfd_xcoff_put_ldsymbol_name
165 PARAMS ((bfd *, struct xcoff_loader_info *, struct internal_ldsym *,
166 const char *));
167 static asection *xcoff_create_csect_from_smclas
168 PARAMS ((bfd *, union internal_auxent *, const char *));
169 static bfd_boolean xcoff_is_lineno_count_overflow
170 PARAMS ((bfd *, bfd_vma));
171 static bfd_boolean xcoff_is_reloc_count_overflow
172 PARAMS ((bfd *, bfd_vma));
173 static bfd_vma xcoff_loader_symbol_offset
174 PARAMS ((bfd *, struct internal_ldhdr *));
175 static bfd_vma xcoff_loader_reloc_offset
176 PARAMS ((bfd *, struct internal_ldhdr *));
177 static bfd_boolean xcoff_generate_rtinit
178 PARAMS ((bfd *, const char *, const char *, bfd_boolean));
179 static bfd_boolean do_pad
180 PARAMS ((bfd *, unsigned int));
181 static bfd_boolean do_copy
182 PARAMS ((bfd *, bfd *));
183 static bfd_boolean do_shared_object_padding
184 PARAMS ((bfd *, bfd *, file_ptr *, int));
185
186 /* Relocation functions */
187 static bfd_boolean xcoff_reloc_type_br
188 PARAMS ((XCOFF_RELOC_FUNCTION_ARGS));
189
190 static bfd_boolean xcoff_complain_overflow_dont_func
191 PARAMS ((XCOFF_COMPLAIN_FUNCTION_ARGS));
192 static bfd_boolean xcoff_complain_overflow_bitfield_func
193 PARAMS ((XCOFF_COMPLAIN_FUNCTION_ARGS));
194 static bfd_boolean xcoff_complain_overflow_signed_func
195 PARAMS ((XCOFF_COMPLAIN_FUNCTION_ARGS));
196 static bfd_boolean xcoff_complain_overflow_unsigned_func
197 PARAMS ((XCOFF_COMPLAIN_FUNCTION_ARGS));
198
199 bfd_boolean (*xcoff_calculate_relocation[XCOFF_MAX_CALCULATE_RELOCATION])
200 PARAMS ((XCOFF_RELOC_FUNCTION_ARGS)) =
201 {
202 xcoff_reloc_type_pos, /* R_POS (0x00) */
203 xcoff_reloc_type_neg, /* R_NEG (0x01) */
204 xcoff_reloc_type_rel, /* R_REL (0x02) */
205 xcoff_reloc_type_toc, /* R_TOC (0x03) */
206 xcoff_reloc_type_fail, /* R_RTB (0x04) */
207 xcoff_reloc_type_toc, /* R_GL (0x05) */
208 xcoff_reloc_type_toc, /* R_TCL (0x06) */
209 xcoff_reloc_type_fail, /* (0x07) */
210 xcoff_reloc_type_ba, /* R_BA (0x08) */
211 xcoff_reloc_type_fail, /* (0x09) */
212 xcoff_reloc_type_br, /* R_BR (0x0a) */
213 xcoff_reloc_type_fail, /* (0x0b) */
214 xcoff_reloc_type_pos, /* R_RL (0x0c) */
215 xcoff_reloc_type_pos, /* R_RLA (0x0d) */
216 xcoff_reloc_type_fail, /* (0x0e) */
217 xcoff_reloc_type_noop, /* R_REF (0x0f) */
218 xcoff_reloc_type_fail, /* (0x10) */
219 xcoff_reloc_type_fail, /* (0x11) */
220 xcoff_reloc_type_toc, /* R_TRL (0x12) */
221 xcoff_reloc_type_toc, /* R_TRLA (0x13) */
222 xcoff_reloc_type_fail, /* R_RRTBI (0x14) */
223 xcoff_reloc_type_fail, /* R_RRTBA (0x15) */
224 xcoff_reloc_type_ba, /* R_CAI (0x16) */
225 xcoff_reloc_type_crel, /* R_CREL (0x17) */
226 xcoff_reloc_type_ba, /* R_RBA (0x18) */
227 xcoff_reloc_type_ba, /* R_RBAC (0x19) */
228 xcoff_reloc_type_br, /* R_RBR (0x1a) */
229 xcoff_reloc_type_ba, /* R_RBRC (0x1b) */
230 };
231
232 bfd_boolean (*xcoff_complain_overflow[XCOFF_MAX_COMPLAIN_OVERFLOW])
233 PARAMS ((XCOFF_COMPLAIN_FUNCTION_ARGS)) =
234 {
235 xcoff_complain_overflow_dont_func,
236 xcoff_complain_overflow_bitfield_func,
237 xcoff_complain_overflow_signed_func,
238 xcoff_complain_overflow_unsigned_func,
239 };
240
241 /* We use our own tdata type. Its first field is the COFF tdata type,
242 so the COFF routines are compatible. */
243
244 bfd_boolean
245 _bfd_xcoff_mkobject (abfd)
246 bfd *abfd;
247 {
248 coff_data_type *coff;
249 bfd_size_type amt = sizeof (struct xcoff_tdata);
250
251 abfd->tdata.xcoff_obj_data = (struct xcoff_tdata *) bfd_zalloc (abfd, amt);
252 if (abfd->tdata.xcoff_obj_data == NULL)
253 return FALSE;
254 coff = coff_data (abfd);
255 coff->symbols = (coff_symbol_type *) NULL;
256 coff->conversion_table = (unsigned int *) NULL;
257 coff->raw_syments = (struct coff_ptr_struct *) NULL;
258 coff->relocbase = 0;
259
260 xcoff_data (abfd)->modtype = ('1' << 8) | 'L';
261
262 /* We set cputype to -1 to indicate that it has not been
263 initialized. */
264 xcoff_data (abfd)->cputype = -1;
265
266 xcoff_data (abfd)->csects = NULL;
267 xcoff_data (abfd)->debug_indices = NULL;
268
269 /* text section alignment is different than the default */
270 bfd_xcoff_text_align_power (abfd) = 2;
271
272 return TRUE;
273 }
274
275 /* Copy XCOFF data from one BFD to another. */
276
277 bfd_boolean
278 _bfd_xcoff_copy_private_bfd_data (ibfd, obfd)
279 bfd *ibfd;
280 bfd *obfd;
281 {
282 struct xcoff_tdata *ix, *ox;
283 asection *sec;
284
285 if (ibfd->xvec != obfd->xvec)
286 return TRUE;
287 ix = xcoff_data (ibfd);
288 ox = xcoff_data (obfd);
289 ox->full_aouthdr = ix->full_aouthdr;
290 ox->toc = ix->toc;
291 if (ix->sntoc == 0)
292 ox->sntoc = 0;
293 else
294 {
295 sec = coff_section_from_bfd_index (ibfd, ix->sntoc);
296 if (sec == NULL)
297 ox->sntoc = 0;
298 else
299 ox->sntoc = sec->output_section->target_index;
300 }
301 if (ix->snentry == 0)
302 ox->snentry = 0;
303 else
304 {
305 sec = coff_section_from_bfd_index (ibfd, ix->snentry);
306 if (sec == NULL)
307 ox->snentry = 0;
308 else
309 ox->snentry = sec->output_section->target_index;
310 }
311 bfd_xcoff_text_align_power (obfd) = bfd_xcoff_text_align_power (ibfd);
312 bfd_xcoff_data_align_power (obfd) = bfd_xcoff_data_align_power (ibfd);
313 ox->modtype = ix->modtype;
314 ox->cputype = ix->cputype;
315 ox->maxdata = ix->maxdata;
316 ox->maxstack = ix->maxstack;
317 return TRUE;
318 }
319
320 /* I don't think XCOFF really has a notion of local labels based on
321 name. This will mean that ld -X doesn't actually strip anything.
322 The AIX native linker does not have a -X option, and it ignores the
323 -x option. */
324
325 bfd_boolean
326 _bfd_xcoff_is_local_label_name (abfd, name)
327 bfd *abfd ATTRIBUTE_UNUSED;
328 const char *name ATTRIBUTE_UNUSED;
329 {
330 return FALSE;
331 }
332 \f
333 void
334 _bfd_xcoff_swap_sym_in (abfd, ext1, in1)
335 bfd *abfd;
336 PTR ext1;
337 PTR in1;
338 {
339 SYMENT *ext = (SYMENT *)ext1;
340 struct internal_syment * in = (struct internal_syment *)in1;
341
342 if (ext->e.e_name[0] != 0)
343 {
344 memcpy (in->_n._n_name, ext->e.e_name, SYMNMLEN);
345 }
346 else
347 {
348 in->_n._n_n._n_zeroes = 0;
349 in->_n._n_n._n_offset = H_GET_32 (abfd, ext->e.e.e_offset);
350 }
351
352 in->n_value = H_GET_32 (abfd, ext->e_value);
353 in->n_scnum = H_GET_16 (abfd, ext->e_scnum);
354 in->n_type = H_GET_16 (abfd, ext->e_type);
355 in->n_sclass = H_GET_8 (abfd, ext->e_sclass);
356 in->n_numaux = H_GET_8 (abfd, ext->e_numaux);
357 }
358
359 unsigned int
360 _bfd_xcoff_swap_sym_out (abfd, inp, extp)
361 bfd *abfd;
362 PTR inp;
363 PTR extp;
364 {
365 struct internal_syment *in = (struct internal_syment *)inp;
366 SYMENT *ext =(SYMENT *)extp;
367
368 if (in->_n._n_name[0] != 0)
369 {
370 memcpy (ext->e.e_name, in->_n._n_name, SYMNMLEN);
371 }
372 else
373 {
374 H_PUT_32 (abfd, 0, ext->e.e.e_zeroes);
375 H_PUT_32 (abfd, in->_n._n_n._n_offset, ext->e.e.e_offset);
376 }
377
378 H_PUT_32 (abfd, in->n_value, ext->e_value);
379 H_PUT_16 (abfd, in->n_scnum, ext->e_scnum);
380 H_PUT_16 (abfd, in->n_type, ext->e_type);
381 H_PUT_8 (abfd, in->n_sclass, ext->e_sclass);
382 H_PUT_8 (abfd, in->n_numaux, ext->e_numaux);
383 return bfd_coff_symesz (abfd);
384 }
385
386 void
387 _bfd_xcoff_swap_aux_in (abfd, ext1, type, class, indx, numaux, in1)
388 bfd *abfd;
389 PTR ext1;
390 int type;
391 int class;
392 int indx;
393 int numaux;
394 PTR in1;
395 {
396 AUXENT * ext = (AUXENT *)ext1;
397 union internal_auxent *in = (union internal_auxent *)in1;
398
399 switch (class)
400 {
401 case C_FILE:
402 if (ext->x_file.x_fname[0] == 0)
403 {
404 in->x_file.x_n.x_zeroes = 0;
405 in->x_file.x_n.x_offset =
406 H_GET_32 (abfd, ext->x_file.x_n.x_offset);
407 }
408 else
409 {
410 if (numaux > 1)
411 {
412 if (indx == 0)
413 memcpy (in->x_file.x_fname, ext->x_file.x_fname,
414 numaux * sizeof (AUXENT));
415 }
416 else
417 {
418 memcpy (in->x_file.x_fname, ext->x_file.x_fname, FILNMLEN);
419 }
420 }
421 goto end;
422
423 /* RS/6000 "csect" auxents */
424 case C_EXT:
425 case C_AIX_WEAKEXT:
426 case C_HIDEXT:
427 if (indx + 1 == numaux)
428 {
429 in->x_csect.x_scnlen.l = H_GET_32 (abfd, ext->x_csect.x_scnlen);
430 in->x_csect.x_parmhash = H_GET_32 (abfd, ext->x_csect.x_parmhash);
431 in->x_csect.x_snhash = H_GET_16 (abfd, ext->x_csect.x_snhash);
432 /* We don't have to hack bitfields in x_smtyp because it's
433 defined by shifts-and-ands, which are equivalent on all
434 byte orders. */
435 in->x_csect.x_smtyp = H_GET_8 (abfd, ext->x_csect.x_smtyp);
436 in->x_csect.x_smclas = H_GET_8 (abfd, ext->x_csect.x_smclas);
437 in->x_csect.x_stab = H_GET_32 (abfd, ext->x_csect.x_stab);
438 in->x_csect.x_snstab = H_GET_16 (abfd, ext->x_csect.x_snstab);
439 goto end;
440 }
441 break;
442
443 case C_STAT:
444 case C_LEAFSTAT:
445 case C_HIDDEN:
446 if (type == T_NULL)
447 {
448 in->x_scn.x_scnlen = H_GET_32 (abfd, ext->x_scn.x_scnlen);
449 in->x_scn.x_nreloc = H_GET_16 (abfd, ext->x_scn.x_nreloc);
450 in->x_scn.x_nlinno = H_GET_16 (abfd, ext->x_scn.x_nlinno);
451 /* PE defines some extra fields; we zero them out for
452 safety. */
453 in->x_scn.x_checksum = 0;
454 in->x_scn.x_associated = 0;
455 in->x_scn.x_comdat = 0;
456
457 goto end;
458 }
459 break;
460 }
461
462 in->x_sym.x_tagndx.l = H_GET_32 (abfd, ext->x_sym.x_tagndx);
463 in->x_sym.x_tvndx = H_GET_16 (abfd, ext->x_sym.x_tvndx);
464
465 if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
466 {
467 in->x_sym.x_fcnary.x_fcn.x_lnnoptr =
468 H_GET_32 (abfd, ext->x_sym.x_fcnary.x_fcn.x_lnnoptr);
469 in->x_sym.x_fcnary.x_fcn.x_endndx.l =
470 H_GET_32 (abfd, ext->x_sym.x_fcnary.x_fcn.x_endndx);
471 }
472 else
473 {
474 in->x_sym.x_fcnary.x_ary.x_dimen[0] =
475 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
476 in->x_sym.x_fcnary.x_ary.x_dimen[1] =
477 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
478 in->x_sym.x_fcnary.x_ary.x_dimen[2] =
479 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
480 in->x_sym.x_fcnary.x_ary.x_dimen[3] =
481 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
482 }
483
484 if (ISFCN (type))
485 {
486 in->x_sym.x_misc.x_fsize = H_GET_32 (abfd, ext->x_sym.x_misc.x_fsize);
487 }
488 else
489 {
490 in->x_sym.x_misc.x_lnsz.x_lnno =
491 H_GET_16 (abfd, ext->x_sym.x_misc.x_lnsz.x_lnno);
492 in->x_sym.x_misc.x_lnsz.x_size =
493 H_GET_16 (abfd, ext->x_sym.x_misc.x_lnsz.x_size);
494 }
495
496 end: ;
497 /* The semicolon is because MSVC doesn't like labels at
498 end of block. */
499 }
500
501
502 unsigned int _bfd_xcoff_swap_aux_out
503 PARAMS ((bfd *, PTR, int, int, int, int, PTR));
504
505 unsigned int
506 _bfd_xcoff_swap_aux_out (abfd, inp, type, class, indx, numaux, extp)
507 bfd * abfd;
508 PTR inp;
509 int type;
510 int class;
511 int indx ATTRIBUTE_UNUSED;
512 int numaux ATTRIBUTE_UNUSED;
513 PTR extp;
514 {
515 union internal_auxent *in = (union internal_auxent *)inp;
516 AUXENT *ext = (AUXENT *)extp;
517
518 memset ((PTR)ext, 0, bfd_coff_auxesz (abfd));
519 switch (class)
520 {
521 case C_FILE:
522 if (in->x_file.x_fname[0] == 0)
523 {
524 H_PUT_32 (abfd, 0, ext->x_file.x_n.x_zeroes);
525 H_PUT_32 (abfd, in->x_file.x_n.x_offset, ext->x_file.x_n.x_offset);
526 }
527 else
528 {
529 memcpy (ext->x_file.x_fname, in->x_file.x_fname, FILNMLEN);
530 }
531 goto end;
532
533 /* RS/6000 "csect" auxents */
534 case C_EXT:
535 case C_AIX_WEAKEXT:
536 case C_HIDEXT:
537 if (indx + 1 == numaux)
538 {
539 H_PUT_32 (abfd, in->x_csect.x_scnlen.l, ext->x_csect.x_scnlen);
540 H_PUT_32 (abfd, in->x_csect.x_parmhash, ext->x_csect.x_parmhash);
541 H_PUT_16 (abfd, in->x_csect.x_snhash, ext->x_csect.x_snhash);
542 /* We don't have to hack bitfields in x_smtyp because it's
543 defined by shifts-and-ands, which are equivalent on all
544 byte orders. */
545 H_PUT_8 (abfd, in->x_csect.x_smtyp, ext->x_csect.x_smtyp);
546 H_PUT_8 (abfd, in->x_csect.x_smclas, ext->x_csect.x_smclas);
547 H_PUT_32 (abfd, in->x_csect.x_stab, ext->x_csect.x_stab);
548 H_PUT_16 (abfd, in->x_csect.x_snstab, ext->x_csect.x_snstab);
549 goto end;
550 }
551 break;
552
553 case C_STAT:
554 case C_LEAFSTAT:
555 case C_HIDDEN:
556 if (type == T_NULL)
557 {
558 H_PUT_32 (abfd, in->x_scn.x_scnlen, ext->x_scn.x_scnlen);
559 H_PUT_16 (abfd, in->x_scn.x_nreloc, ext->x_scn.x_nreloc);
560 H_PUT_16 (abfd, in->x_scn.x_nlinno, ext->x_scn.x_nlinno);
561 goto end;
562 }
563 break;
564 }
565
566 H_PUT_32 (abfd, in->x_sym.x_tagndx.l, ext->x_sym.x_tagndx);
567 H_PUT_16 (abfd, in->x_sym.x_tvndx, ext->x_sym.x_tvndx);
568
569 if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
570 {
571 H_PUT_32 (abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr,
572 ext->x_sym.x_fcnary.x_fcn.x_lnnoptr);
573 H_PUT_32 (abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l,
574 ext->x_sym.x_fcnary.x_fcn.x_endndx);
575 }
576 else
577 {
578 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[0],
579 ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
580 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[1],
581 ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
582 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[2],
583 ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
584 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[3],
585 ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
586 }
587
588 if (ISFCN (type))
589 H_PUT_32 (abfd, in->x_sym.x_misc.x_fsize, ext->x_sym.x_misc.x_fsize);
590 else
591 {
592 H_PUT_16 (abfd, in->x_sym.x_misc.x_lnsz.x_lnno,
593 ext->x_sym.x_misc.x_lnsz.x_lnno);
594 H_PUT_16 (abfd, in->x_sym.x_misc.x_lnsz.x_size,
595 ext->x_sym.x_misc.x_lnsz.x_size);
596 }
597
598 end:
599 return bfd_coff_auxesz (abfd);
600 }
601
602
603 \f
604 /* The XCOFF reloc table. Actually, XCOFF relocations specify the
605 bitsize and whether they are signed or not, along with a
606 conventional type. This table is for the types, which are used for
607 different algorithms for putting in the reloc. Many of these
608 relocs need special_function entries, which I have not written. */
609
610
611 reloc_howto_type xcoff_howto_table[] =
612 {
613 /* Standard 32 bit relocation. */
614 HOWTO (R_POS, /* type */
615 0, /* rightshift */
616 2, /* size (0 = byte, 1 = short, 2 = long) */
617 32, /* bitsize */
618 FALSE, /* pc_relative */
619 0, /* bitpos */
620 complain_overflow_bitfield, /* complain_on_overflow */
621 0, /* special_function */
622 "R_POS", /* name */
623 TRUE, /* partial_inplace */
624 0xffffffff, /* src_mask */
625 0xffffffff, /* dst_mask */
626 FALSE), /* pcrel_offset */
627
628 /* 32 bit relocation, but store negative value. */
629 HOWTO (R_NEG, /* type */
630 0, /* rightshift */
631 -2, /* size (0 = byte, 1 = short, 2 = long) */
632 32, /* bitsize */
633 FALSE, /* pc_relative */
634 0, /* bitpos */
635 complain_overflow_bitfield, /* complain_on_overflow */
636 0, /* special_function */
637 "R_NEG", /* name */
638 TRUE, /* partial_inplace */
639 0xffffffff, /* src_mask */
640 0xffffffff, /* dst_mask */
641 FALSE), /* pcrel_offset */
642
643 /* 32 bit PC relative relocation. */
644 HOWTO (R_REL, /* type */
645 0, /* rightshift */
646 2, /* size (0 = byte, 1 = short, 2 = long) */
647 32, /* bitsize */
648 TRUE, /* pc_relative */
649 0, /* bitpos */
650 complain_overflow_signed, /* complain_on_overflow */
651 0, /* special_function */
652 "R_REL", /* name */
653 TRUE, /* partial_inplace */
654 0xffffffff, /* src_mask */
655 0xffffffff, /* dst_mask */
656 FALSE), /* pcrel_offset */
657
658 /* 16 bit TOC relative relocation. */
659 HOWTO (R_TOC, /* type */
660 0, /* rightshift */
661 1, /* size (0 = byte, 1 = short, 2 = long) */
662 16, /* bitsize */
663 FALSE, /* pc_relative */
664 0, /* bitpos */
665 complain_overflow_bitfield, /* complain_on_overflow */
666 0, /* special_function */
667 "R_TOC", /* name */
668 TRUE, /* partial_inplace */
669 0xffff, /* src_mask */
670 0xffff, /* dst_mask */
671 FALSE), /* pcrel_offset */
672
673 /* I don't really know what this is. */
674 HOWTO (R_RTB, /* type */
675 1, /* rightshift */
676 2, /* size (0 = byte, 1 = short, 2 = long) */
677 32, /* bitsize */
678 FALSE, /* pc_relative */
679 0, /* bitpos */
680 complain_overflow_bitfield, /* complain_on_overflow */
681 0, /* special_function */
682 "R_RTB", /* name */
683 TRUE, /* partial_inplace */
684 0xffffffff, /* src_mask */
685 0xffffffff, /* dst_mask */
686 FALSE), /* pcrel_offset */
687
688 /* External TOC relative symbol. */
689 HOWTO (R_GL, /* type */
690 0, /* rightshift */
691 1, /* size (0 = byte, 1 = short, 2 = long) */
692 16, /* bitsize */
693 FALSE, /* pc_relative */
694 0, /* bitpos */
695 complain_overflow_bitfield, /* complain_on_overflow */
696 0, /* special_function */
697 "R_GL", /* name */
698 TRUE, /* partial_inplace */
699 0xffff, /* src_mask */
700 0xffff, /* dst_mask */
701 FALSE), /* pcrel_offset */
702
703 /* Local TOC relative symbol. */
704 HOWTO (R_TCL, /* type */
705 0, /* rightshift */
706 1, /* size (0 = byte, 1 = short, 2 = long) */
707 16, /* bitsize */
708 FALSE, /* pc_relative */
709 0, /* bitpos */
710 complain_overflow_bitfield, /* complain_on_overflow */
711 0, /* special_function */
712 "R_TCL", /* name */
713 TRUE, /* partial_inplace */
714 0xffff, /* src_mask */
715 0xffff, /* dst_mask */
716 FALSE), /* pcrel_offset */
717
718 EMPTY_HOWTO (7),
719
720 /* Non modifiable absolute branch. */
721 HOWTO (R_BA, /* type */
722 0, /* rightshift */
723 2, /* size (0 = byte, 1 = short, 2 = long) */
724 26, /* bitsize */
725 FALSE, /* pc_relative */
726 0, /* bitpos */
727 complain_overflow_bitfield, /* complain_on_overflow */
728 0, /* special_function */
729 "R_BA_26", /* name */
730 TRUE, /* partial_inplace */
731 0x03fffffc, /* src_mask */
732 0x03fffffc, /* dst_mask */
733 FALSE), /* pcrel_offset */
734
735 EMPTY_HOWTO (9),
736
737 /* Non modifiable relative branch. */
738 HOWTO (R_BR, /* type */
739 0, /* rightshift */
740 2, /* size (0 = byte, 1 = short, 2 = long) */
741 26, /* bitsize */
742 TRUE, /* pc_relative */
743 0, /* bitpos */
744 complain_overflow_signed, /* complain_on_overflow */
745 0, /* special_function */
746 "R_BR", /* name */
747 TRUE, /* partial_inplace */
748 0x03fffffc, /* src_mask */
749 0x03fffffc, /* dst_mask */
750 FALSE), /* pcrel_offset */
751
752 EMPTY_HOWTO (0xb),
753
754 /* Indirect load. */
755 HOWTO (R_RL, /* type */
756 0, /* rightshift */
757 1, /* size (0 = byte, 1 = short, 2 = long) */
758 16, /* bitsize */
759 FALSE, /* pc_relative */
760 0, /* bitpos */
761 complain_overflow_bitfield, /* complain_on_overflow */
762 0, /* special_function */
763 "R_RL", /* name */
764 TRUE, /* partial_inplace */
765 0xffff, /* src_mask */
766 0xffff, /* dst_mask */
767 FALSE), /* pcrel_offset */
768
769 /* Load address. */
770 HOWTO (R_RLA, /* type */
771 0, /* rightshift */
772 1, /* size (0 = byte, 1 = short, 2 = long) */
773 16, /* bitsize */
774 FALSE, /* pc_relative */
775 0, /* bitpos */
776 complain_overflow_bitfield, /* complain_on_overflow */
777 0, /* special_function */
778 "R_RLA", /* name */
779 TRUE, /* partial_inplace */
780 0xffff, /* src_mask */
781 0xffff, /* dst_mask */
782 FALSE), /* pcrel_offset */
783
784 EMPTY_HOWTO (0xe),
785
786 /* Non-relocating reference. */
787 HOWTO (R_REF, /* type */
788 0, /* rightshift */
789 2, /* size (0 = byte, 1 = short, 2 = long) */
790 32, /* bitsize */
791 FALSE, /* pc_relative */
792 0, /* bitpos */
793 complain_overflow_dont, /* complain_on_overflow */
794 0, /* special_function */
795 "R_REF", /* name */
796 FALSE, /* partial_inplace */
797 0, /* src_mask */
798 0, /* dst_mask */
799 FALSE), /* pcrel_offset */
800
801 EMPTY_HOWTO (0x10),
802 EMPTY_HOWTO (0x11),
803
804 /* TOC relative indirect load. */
805 HOWTO (R_TRL, /* type */
806 0, /* rightshift */
807 1, /* size (0 = byte, 1 = short, 2 = long) */
808 16, /* bitsize */
809 FALSE, /* pc_relative */
810 0, /* bitpos */
811 complain_overflow_bitfield, /* complain_on_overflow */
812 0, /* special_function */
813 "R_TRL", /* name */
814 TRUE, /* partial_inplace */
815 0xffff, /* src_mask */
816 0xffff, /* dst_mask */
817 FALSE), /* pcrel_offset */
818
819 /* TOC relative load address. */
820 HOWTO (R_TRLA, /* type */
821 0, /* rightshift */
822 1, /* size (0 = byte, 1 = short, 2 = long) */
823 16, /* bitsize */
824 FALSE, /* pc_relative */
825 0, /* bitpos */
826 complain_overflow_bitfield, /* complain_on_overflow */
827 0, /* special_function */
828 "R_TRLA", /* name */
829 TRUE, /* partial_inplace */
830 0xffff, /* src_mask */
831 0xffff, /* dst_mask */
832 FALSE), /* pcrel_offset */
833
834 /* Modifiable relative branch. */
835 HOWTO (R_RRTBI, /* type */
836 1, /* rightshift */
837 2, /* size (0 = byte, 1 = short, 2 = long) */
838 32, /* bitsize */
839 FALSE, /* pc_relative */
840 0, /* bitpos */
841 complain_overflow_bitfield, /* complain_on_overflow */
842 0, /* special_function */
843 "R_RRTBI", /* name */
844 TRUE, /* partial_inplace */
845 0xffffffff, /* src_mask */
846 0xffffffff, /* dst_mask */
847 FALSE), /* pcrel_offset */
848
849 /* Modifiable absolute branch. */
850 HOWTO (R_RRTBA, /* type */
851 1, /* rightshift */
852 2, /* size (0 = byte, 1 = short, 2 = long) */
853 32, /* bitsize */
854 FALSE, /* pc_relative */
855 0, /* bitpos */
856 complain_overflow_bitfield, /* complain_on_overflow */
857 0, /* special_function */
858 "R_RRTBA", /* name */
859 TRUE, /* partial_inplace */
860 0xffffffff, /* src_mask */
861 0xffffffff, /* dst_mask */
862 FALSE), /* pcrel_offset */
863
864 /* Modifiable call absolute indirect. */
865 HOWTO (R_CAI, /* type */
866 0, /* rightshift */
867 1, /* size (0 = byte, 1 = short, 2 = long) */
868 16, /* bitsize */
869 FALSE, /* pc_relative */
870 0, /* bitpos */
871 complain_overflow_bitfield, /* complain_on_overflow */
872 0, /* special_function */
873 "R_CAI", /* name */
874 TRUE, /* partial_inplace */
875 0xffff, /* src_mask */
876 0xffff, /* dst_mask */
877 FALSE), /* pcrel_offset */
878
879 /* Modifiable call relative. */
880 HOWTO (R_CREL, /* type */
881 0, /* rightshift */
882 1, /* size (0 = byte, 1 = short, 2 = long) */
883 16, /* bitsize */
884 FALSE, /* pc_relative */
885 0, /* bitpos */
886 complain_overflow_bitfield, /* complain_on_overflow */
887 0, /* special_function */
888 "R_CREL", /* name */
889 TRUE, /* partial_inplace */
890 0xffff, /* src_mask */
891 0xffff, /* dst_mask */
892 FALSE), /* pcrel_offset */
893
894 /* Modifiable branch absolute. */
895 HOWTO (R_RBA, /* type */
896 0, /* rightshift */
897 2, /* size (0 = byte, 1 = short, 2 = long) */
898 26, /* bitsize */
899 FALSE, /* pc_relative */
900 0, /* bitpos */
901 complain_overflow_bitfield, /* complain_on_overflow */
902 0, /* special_function */
903 "R_RBA", /* name */
904 TRUE, /* partial_inplace */
905 0x03fffffc, /* src_mask */
906 0x03fffffc, /* dst_mask */
907 FALSE), /* pcrel_offset */
908
909 /* Modifiable branch absolute. */
910 HOWTO (R_RBAC, /* type */
911 0, /* rightshift */
912 2, /* size (0 = byte, 1 = short, 2 = long) */
913 32, /* bitsize */
914 FALSE, /* pc_relative */
915 0, /* bitpos */
916 complain_overflow_bitfield, /* complain_on_overflow */
917 0, /* special_function */
918 "R_RBAC", /* name */
919 TRUE, /* partial_inplace */
920 0xffffffff, /* src_mask */
921 0xffffffff, /* dst_mask */
922 FALSE), /* pcrel_offset */
923
924 /* Modifiable branch relative. */
925 HOWTO (R_RBR, /* type */
926 0, /* rightshift */
927 2, /* size (0 = byte, 1 = short, 2 = long) */
928 26, /* bitsize */
929 FALSE, /* pc_relative */
930 0, /* bitpos */
931 complain_overflow_signed, /* complain_on_overflow */
932 0, /* special_function */
933 "R_RBR_26", /* name */
934 TRUE, /* partial_inplace */
935 0x03fffffc, /* src_mask */
936 0x03fffffc, /* dst_mask */
937 FALSE), /* pcrel_offset */
938
939 /* Modifiable branch absolute. */
940 HOWTO (R_RBRC, /* type */
941 0, /* rightshift */
942 1, /* size (0 = byte, 1 = short, 2 = long) */
943 16, /* bitsize */
944 FALSE, /* pc_relative */
945 0, /* bitpos */
946 complain_overflow_bitfield, /* complain_on_overflow */
947 0, /* special_function */
948 "R_RBRC", /* name */
949 TRUE, /* partial_inplace */
950 0xffff, /* src_mask */
951 0xffff, /* dst_mask */
952 FALSE), /* pcrel_offset */
953
954 /* 16 bit Non modifiable absolute branch. */
955 HOWTO (R_BA, /* type */
956 0, /* rightshift */
957 1, /* size (0 = byte, 1 = short, 2 = long) */
958 16, /* bitsize */
959 FALSE, /* pc_relative */
960 0, /* bitpos */
961 complain_overflow_bitfield, /* complain_on_overflow */
962 0, /* special_function */
963 "R_BA_16", /* name */
964 TRUE, /* partial_inplace */
965 0xfffc, /* src_mask */
966 0xfffc, /* dst_mask */
967 FALSE), /* pcrel_offset */
968
969 /* Modifiable branch relative. */
970 HOWTO (R_RBR, /* type */
971 0, /* rightshift */
972 1, /* size (0 = byte, 1 = short, 2 = long) */
973 16, /* bitsize */
974 FALSE, /* pc_relative */
975 0, /* bitpos */
976 complain_overflow_signed, /* complain_on_overflow */
977 0, /* special_function */
978 "R_RBR_16", /* name */
979 TRUE, /* partial_inplace */
980 0xffff, /* src_mask */
981 0xffff, /* dst_mask */
982 FALSE), /* pcrel_offset */
983
984 /* Modifiable branch relative. */
985 HOWTO (R_RBA, /* type */
986 0, /* rightshift */
987 1, /* size (0 = byte, 1 = short, 2 = long) */
988 16, /* bitsize */
989 FALSE, /* pc_relative */
990 0, /* bitpos */
991 complain_overflow_signed, /* complain_on_overflow */
992 0, /* special_function */
993 "R_RBA_16", /* name */
994 TRUE, /* partial_inplace */
995 0xffff, /* src_mask */
996 0xffff, /* dst_mask */
997 FALSE), /* pcrel_offset */
998
999 };
1000
1001 void
1002 xcoff_rtype2howto (relent, internal)
1003 arelent *relent;
1004 struct internal_reloc *internal;
1005 {
1006 if (internal->r_type > R_RBRC)
1007 abort ();
1008
1009 /* Default howto layout works most of the time */
1010 relent->howto = &xcoff_howto_table[internal->r_type];
1011
1012 /* Special case some 16 bit reloc */
1013 if (15 == (internal->r_size & 0x1f))
1014 {
1015 if (R_BA == internal->r_type)
1016 relent->howto = &xcoff_howto_table[0x1c];
1017 else if (R_RBR == internal->r_type)
1018 relent->howto = &xcoff_howto_table[0x1d];
1019 else if (R_RBA == internal->r_type)
1020 relent->howto = &xcoff_howto_table[0x1e];
1021 }
1022
1023 /* The r_size field of an XCOFF reloc encodes the bitsize of the
1024 relocation, as well as indicating whether it is signed or not.
1025 Doublecheck that the relocation information gathered from the
1026 type matches this information. The bitsize is not significant
1027 for R_REF relocs. */
1028 if (relent->howto->dst_mask != 0
1029 && (relent->howto->bitsize
1030 != ((unsigned int) internal->r_size & 0x1f) + 1))
1031 abort ();
1032 }
1033
1034 reloc_howto_type *
1035 _bfd_xcoff_reloc_type_lookup (abfd, code)
1036 bfd *abfd ATTRIBUTE_UNUSED;
1037 bfd_reloc_code_real_type code;
1038 {
1039 switch (code)
1040 {
1041 case BFD_RELOC_PPC_B26:
1042 return &xcoff_howto_table[0xa];
1043 case BFD_RELOC_PPC_BA16:
1044 return &xcoff_howto_table[0x1c];
1045 case BFD_RELOC_PPC_BA26:
1046 return &xcoff_howto_table[8];
1047 case BFD_RELOC_PPC_TOC16:
1048 return &xcoff_howto_table[3];
1049 case BFD_RELOC_32:
1050 case BFD_RELOC_CTOR:
1051 return &xcoff_howto_table[0];
1052 default:
1053 return NULL;
1054 }
1055 }
1056
1057 static reloc_howto_type *
1058 _bfd_xcoff_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1059 const char *r_name)
1060 {
1061 unsigned int i;
1062
1063 for (i = 0;
1064 i < sizeof (xcoff_howto_table) / sizeof (xcoff_howto_table[0]);
1065 i++)
1066 if (xcoff_howto_table[i].name != NULL
1067 && strcasecmp (xcoff_howto_table[i].name, r_name) == 0)
1068 return &xcoff_howto_table[i];
1069
1070 return NULL;
1071 }
1072 \f
1073 /* XCOFF archive support. The original version of this code was by
1074 Damon A. Permezel. It was enhanced to permit cross support, and
1075 writing archive files, by Ian Lance Taylor, Cygnus Support.
1076
1077 XCOFF uses its own archive format. Everything is hooked together
1078 with file offset links, so it is possible to rapidly update an
1079 archive in place. Of course, we don't do that. An XCOFF archive
1080 has a real file header, not just an ARMAG string. The structure of
1081 the file header and of each archive header appear below.
1082
1083 An XCOFF archive also has a member table, which is a list of
1084 elements in the archive (you can get that by looking through the
1085 linked list, but you have to read a lot more of the file). The
1086 member table has a normal archive header with an empty name. It is
1087 normally (and perhaps must be) the second to last entry in the
1088 archive. The member table data is almost printable ASCII. It
1089 starts with a 12 character decimal string which is the number of
1090 entries in the table. For each entry it has a 12 character decimal
1091 string which is the offset in the archive of that member. These
1092 entries are followed by a series of null terminated strings which
1093 are the member names for each entry.
1094
1095 Finally, an XCOFF archive has a global symbol table, which is what
1096 we call the armap. The global symbol table has a normal archive
1097 header with an empty name. It is normally (and perhaps must be)
1098 the last entry in the archive. The contents start with a four byte
1099 binary number which is the number of entries. This is followed by
1100 a that many four byte binary numbers; each is the file offset of an
1101 entry in the archive. These numbers are followed by a series of
1102 null terminated strings, which are symbol names.
1103
1104 AIX 4.3 introduced a new archive format which can handle larger
1105 files and also 32- and 64-bit objects in the same archive. The
1106 things said above remain true except that there is now more than
1107 one global symbol table. The one is used to index 32-bit objects,
1108 the other for 64-bit objects.
1109
1110 The new archives (recognizable by the new ARMAG string) has larger
1111 field lengths so that we cannot really share any code. Also we have
1112 to take care that we are not generating the new form of archives
1113 on AIX 4.2 or earlier systems. */
1114
1115 /* XCOFF archives use this as a magic string. Note that both strings
1116 have the same length. */
1117
1118 /* Set the magic for archive. */
1119
1120 bfd_boolean
1121 bfd_xcoff_ar_archive_set_magic (abfd, magic)
1122 bfd *abfd ATTRIBUTE_UNUSED;
1123 char *magic ATTRIBUTE_UNUSED;
1124 {
1125 /* Not supported yet. */
1126 return FALSE;
1127 /* bfd_xcoff_archive_set_magic (abfd, magic); */
1128 }
1129
1130 /* Read in the armap of an XCOFF archive. */
1131
1132 bfd_boolean
1133 _bfd_xcoff_slurp_armap (abfd)
1134 bfd *abfd;
1135 {
1136 file_ptr off;
1137 size_t namlen;
1138 bfd_size_type sz;
1139 bfd_byte *contents, *cend;
1140 bfd_vma c, i;
1141 carsym *arsym;
1142 bfd_byte *p;
1143
1144 if (xcoff_ardata (abfd) == NULL)
1145 {
1146 bfd_has_map (abfd) = FALSE;
1147 return TRUE;
1148 }
1149
1150 if (! xcoff_big_format_p (abfd))
1151 {
1152 /* This is for the old format. */
1153 struct xcoff_ar_hdr hdr;
1154
1155 off = strtol (xcoff_ardata (abfd)->symoff, (char **) NULL, 10);
1156 if (off == 0)
1157 {
1158 bfd_has_map (abfd) = FALSE;
1159 return TRUE;
1160 }
1161
1162 if (bfd_seek (abfd, off, SEEK_SET) != 0)
1163 return FALSE;
1164
1165 /* The symbol table starts with a normal archive header. */
1166 if (bfd_bread ((PTR) &hdr, (bfd_size_type) SIZEOF_AR_HDR, abfd)
1167 != SIZEOF_AR_HDR)
1168 return FALSE;
1169
1170 /* Skip the name (normally empty). */
1171 namlen = strtol (hdr.namlen, (char **) NULL, 10);
1172 off = ((namlen + 1) & ~ (size_t) 1) + SXCOFFARFMAG;
1173 if (bfd_seek (abfd, off, SEEK_CUR) != 0)
1174 return FALSE;
1175
1176 sz = strtol (hdr.size, (char **) NULL, 10);
1177
1178 /* Read in the entire symbol table. */
1179 contents = (bfd_byte *) bfd_alloc (abfd, sz);
1180 if (contents == NULL)
1181 return FALSE;
1182 if (bfd_bread ((PTR) contents, sz, abfd) != sz)
1183 return FALSE;
1184
1185 /* The symbol table starts with a four byte count. */
1186 c = H_GET_32 (abfd, contents);
1187
1188 if (c * 4 >= sz)
1189 {
1190 bfd_set_error (bfd_error_bad_value);
1191 return FALSE;
1192 }
1193
1194 bfd_ardata (abfd)->symdefs =
1195 ((carsym *) bfd_alloc (abfd, c * sizeof (carsym)));
1196 if (bfd_ardata (abfd)->symdefs == NULL)
1197 return FALSE;
1198
1199 /* After the count comes a list of four byte file offsets. */
1200 for (i = 0, arsym = bfd_ardata (abfd)->symdefs, p = contents + 4;
1201 i < c;
1202 ++i, ++arsym, p += 4)
1203 arsym->file_offset = H_GET_32 (abfd, p);
1204 }
1205 else
1206 {
1207 /* This is for the new format. */
1208 struct xcoff_ar_hdr_big hdr;
1209
1210 off = strtol (xcoff_ardata_big (abfd)->symoff, (char **) NULL, 10);
1211 if (off == 0)
1212 {
1213 bfd_has_map (abfd) = FALSE;
1214 return TRUE;
1215 }
1216
1217 if (bfd_seek (abfd, off, SEEK_SET) != 0)
1218 return FALSE;
1219
1220 /* The symbol table starts with a normal archive header. */
1221 if (bfd_bread ((PTR) &hdr, (bfd_size_type) SIZEOF_AR_HDR_BIG, abfd)
1222 != SIZEOF_AR_HDR_BIG)
1223 return FALSE;
1224
1225 /* Skip the name (normally empty). */
1226 namlen = strtol (hdr.namlen, (char **) NULL, 10);
1227 off = ((namlen + 1) & ~ (size_t) 1) + SXCOFFARFMAG;
1228 if (bfd_seek (abfd, off, SEEK_CUR) != 0)
1229 return FALSE;
1230
1231 /* XXX This actually has to be a call to strtoll (at least on 32-bit
1232 machines) since the field width is 20 and there numbers with more
1233 than 32 bits can be represented. */
1234 sz = strtol (hdr.size, (char **) NULL, 10);
1235
1236 /* Read in the entire symbol table. */
1237 contents = (bfd_byte *) bfd_alloc (abfd, sz);
1238 if (contents == NULL)
1239 return FALSE;
1240 if (bfd_bread ((PTR) contents, sz, abfd) != sz)
1241 return FALSE;
1242
1243 /* The symbol table starts with an eight byte count. */
1244 c = H_GET_64 (abfd, contents);
1245
1246 if (c * 8 >= sz)
1247 {
1248 bfd_set_error (bfd_error_bad_value);
1249 return FALSE;
1250 }
1251
1252 bfd_ardata (abfd)->symdefs =
1253 ((carsym *) bfd_alloc (abfd, c * sizeof (carsym)));
1254 if (bfd_ardata (abfd)->symdefs == NULL)
1255 return FALSE;
1256
1257 /* After the count comes a list of eight byte file offsets. */
1258 for (i = 0, arsym = bfd_ardata (abfd)->symdefs, p = contents + 8;
1259 i < c;
1260 ++i, ++arsym, p += 8)
1261 arsym->file_offset = H_GET_64 (abfd, p);
1262 }
1263
1264 /* After the file offsets come null terminated symbol names. */
1265 cend = contents + sz;
1266 for (i = 0, arsym = bfd_ardata (abfd)->symdefs;
1267 i < c;
1268 ++i, ++arsym, p += strlen ((char *) p) + 1)
1269 {
1270 if (p >= cend)
1271 {
1272 bfd_set_error (bfd_error_bad_value);
1273 return FALSE;
1274 }
1275 arsym->name = (char *) p;
1276 }
1277
1278 bfd_ardata (abfd)->symdef_count = c;
1279 bfd_has_map (abfd) = TRUE;
1280
1281 return TRUE;
1282 }
1283
1284 /* See if this is an XCOFF archive. */
1285
1286 const bfd_target *
1287 _bfd_xcoff_archive_p (abfd)
1288 bfd *abfd;
1289 {
1290 struct artdata *tdata_hold;
1291 char magic[SXCOFFARMAG];
1292 bfd_size_type amt = SXCOFFARMAG;
1293
1294 if (bfd_bread ((PTR) magic, amt, abfd) != amt)
1295 {
1296 if (bfd_get_error () != bfd_error_system_call)
1297 bfd_set_error (bfd_error_wrong_format);
1298 return NULL;
1299 }
1300
1301 if (strncmp (magic, XCOFFARMAG, SXCOFFARMAG) != 0
1302 && strncmp (magic, XCOFFARMAGBIG, SXCOFFARMAG) != 0)
1303 {
1304 bfd_set_error (bfd_error_wrong_format);
1305 return NULL;
1306 }
1307
1308 tdata_hold = bfd_ardata (abfd);
1309
1310 amt = sizeof (struct artdata);
1311 bfd_ardata (abfd) = (struct artdata *) bfd_zalloc (abfd, amt);
1312 if (bfd_ardata (abfd) == (struct artdata *) NULL)
1313 goto error_ret_restore;
1314
1315 /* Cleared by bfd_zalloc above.
1316 bfd_ardata (abfd)->cache = NULL;
1317 bfd_ardata (abfd)->archive_head = NULL;
1318 bfd_ardata (abfd)->symdefs = NULL;
1319 bfd_ardata (abfd)->extended_names = NULL;
1320 bfd_ardata (abfd)->extended_names_size = 0; */
1321
1322 /* Now handle the two formats. */
1323 if (magic[1] != 'b')
1324 {
1325 /* This is the old format. */
1326 struct xcoff_ar_file_hdr hdr;
1327
1328 /* Copy over the magic string. */
1329 memcpy (hdr.magic, magic, SXCOFFARMAG);
1330
1331 /* Now read the rest of the file header. */
1332 amt = SIZEOF_AR_FILE_HDR - SXCOFFARMAG;
1333 if (bfd_bread ((PTR) &hdr.memoff, amt, abfd) != amt)
1334 {
1335 if (bfd_get_error () != bfd_error_system_call)
1336 bfd_set_error (bfd_error_wrong_format);
1337 goto error_ret;
1338 }
1339
1340 bfd_ardata (abfd)->first_file_filepos = strtol (hdr.firstmemoff,
1341 (char **) NULL, 10);
1342
1343 amt = SIZEOF_AR_FILE_HDR;
1344 bfd_ardata (abfd)->tdata = bfd_zalloc (abfd, amt);
1345 if (bfd_ardata (abfd)->tdata == NULL)
1346 goto error_ret;
1347
1348 memcpy (bfd_ardata (abfd)->tdata, &hdr, SIZEOF_AR_FILE_HDR);
1349 }
1350 else
1351 {
1352 /* This is the new format. */
1353 struct xcoff_ar_file_hdr_big hdr;
1354
1355 /* Copy over the magic string. */
1356 memcpy (hdr.magic, magic, SXCOFFARMAG);
1357
1358 /* Now read the rest of the file header. */
1359 amt = SIZEOF_AR_FILE_HDR_BIG - SXCOFFARMAG;
1360 if (bfd_bread ((PTR) &hdr.memoff, amt, abfd) != amt)
1361 {
1362 if (bfd_get_error () != bfd_error_system_call)
1363 bfd_set_error (bfd_error_wrong_format);
1364 goto error_ret;
1365 }
1366
1367 bfd_ardata (abfd)->first_file_filepos = bfd_scan_vma (hdr.firstmemoff,
1368 (const char **) 0,
1369 10);
1370
1371 amt = SIZEOF_AR_FILE_HDR_BIG;
1372 bfd_ardata (abfd)->tdata = bfd_zalloc (abfd, amt);
1373 if (bfd_ardata (abfd)->tdata == NULL)
1374 goto error_ret;
1375
1376 memcpy (bfd_ardata (abfd)->tdata, &hdr, SIZEOF_AR_FILE_HDR_BIG);
1377 }
1378
1379 if (! _bfd_xcoff_slurp_armap (abfd))
1380 {
1381 error_ret:
1382 bfd_release (abfd, bfd_ardata (abfd));
1383 error_ret_restore:
1384 bfd_ardata (abfd) = tdata_hold;
1385 return NULL;
1386 }
1387
1388 return abfd->xvec;
1389 }
1390
1391 /* Read the archive header in an XCOFF archive. */
1392
1393 PTR
1394 _bfd_xcoff_read_ar_hdr (abfd)
1395 bfd *abfd;
1396 {
1397 bfd_size_type namlen;
1398 struct areltdata *ret;
1399 bfd_size_type amt = sizeof (struct areltdata);
1400
1401 ret = (struct areltdata *) bfd_alloc (abfd, amt);
1402 if (ret == NULL)
1403 return NULL;
1404
1405 if (! xcoff_big_format_p (abfd))
1406 {
1407 struct xcoff_ar_hdr hdr;
1408 struct xcoff_ar_hdr *hdrp;
1409
1410 if (bfd_bread ((PTR) &hdr, (bfd_size_type) SIZEOF_AR_HDR, abfd)
1411 != SIZEOF_AR_HDR)
1412 {
1413 free (ret);
1414 return NULL;
1415 }
1416
1417 namlen = strtol (hdr.namlen, (char **) NULL, 10);
1418 amt = SIZEOF_AR_HDR + namlen + 1;
1419 hdrp = (struct xcoff_ar_hdr *) bfd_alloc (abfd, amt);
1420 if (hdrp == NULL)
1421 {
1422 free (ret);
1423 return NULL;
1424 }
1425 memcpy (hdrp, &hdr, SIZEOF_AR_HDR);
1426 if (bfd_bread ((char *) hdrp + SIZEOF_AR_HDR, namlen, abfd) != namlen)
1427 {
1428 free (ret);
1429 return NULL;
1430 }
1431 ((char *) hdrp)[SIZEOF_AR_HDR + namlen] = '\0';
1432
1433 ret->arch_header = (char *) hdrp;
1434 ret->parsed_size = strtol (hdr.size, (char **) NULL, 10);
1435 ret->filename = (char *) hdrp + SIZEOF_AR_HDR;
1436 }
1437 else
1438 {
1439 struct xcoff_ar_hdr_big hdr;
1440 struct xcoff_ar_hdr_big *hdrp;
1441
1442 if (bfd_bread ((PTR) &hdr, (bfd_size_type) SIZEOF_AR_HDR_BIG, abfd)
1443 != SIZEOF_AR_HDR_BIG)
1444 {
1445 free (ret);
1446 return NULL;
1447 }
1448
1449 namlen = strtol (hdr.namlen, (char **) NULL, 10);
1450 amt = SIZEOF_AR_HDR_BIG + namlen + 1;
1451 hdrp = (struct xcoff_ar_hdr_big *) bfd_alloc (abfd, amt);
1452 if (hdrp == NULL)
1453 {
1454 free (ret);
1455 return NULL;
1456 }
1457 memcpy (hdrp, &hdr, SIZEOF_AR_HDR_BIG);
1458 if (bfd_bread ((char *) hdrp + SIZEOF_AR_HDR_BIG, namlen, abfd) != namlen)
1459 {
1460 free (ret);
1461 return NULL;
1462 }
1463 ((char *) hdrp)[SIZEOF_AR_HDR_BIG + namlen] = '\0';
1464
1465 ret->arch_header = (char *) hdrp;
1466 /* XXX This actually has to be a call to strtoll (at least on 32-bit
1467 machines) since the field width is 20 and there numbers with more
1468 than 32 bits can be represented. */
1469 ret->parsed_size = strtol (hdr.size, (char **) NULL, 10);
1470 ret->filename = (char *) hdrp + SIZEOF_AR_HDR_BIG;
1471 }
1472
1473 /* Skip over the XCOFFARFMAG at the end of the file name. */
1474 if (bfd_seek (abfd, (file_ptr) ((namlen & 1) + SXCOFFARFMAG), SEEK_CUR) != 0)
1475 return NULL;
1476
1477 return (PTR) ret;
1478 }
1479
1480 /* Open the next element in an XCOFF archive. */
1481
1482 bfd *
1483 _bfd_xcoff_openr_next_archived_file (archive, last_file)
1484 bfd *archive;
1485 bfd *last_file;
1486 {
1487 file_ptr filestart;
1488
1489 if (xcoff_ardata (archive) == NULL)
1490 {
1491 bfd_set_error (bfd_error_invalid_operation);
1492 return NULL;
1493 }
1494
1495 if (! xcoff_big_format_p (archive))
1496 {
1497 if (last_file == NULL)
1498 filestart = bfd_ardata (archive)->first_file_filepos;
1499 else
1500 filestart = strtol (arch_xhdr (last_file)->nextoff, (char **) NULL,
1501 10);
1502
1503 if (filestart == 0
1504 || filestart == strtol (xcoff_ardata (archive)->memoff,
1505 (char **) NULL, 10)
1506 || filestart == strtol (xcoff_ardata (archive)->symoff,
1507 (char **) NULL, 10))
1508 {
1509 bfd_set_error (bfd_error_no_more_archived_files);
1510 return NULL;
1511 }
1512 }
1513 else
1514 {
1515 if (last_file == NULL)
1516 filestart = bfd_ardata (archive)->first_file_filepos;
1517 else
1518 /* XXX These actually have to be a calls to strtoll (at least
1519 on 32-bit machines) since the fields's width is 20 and
1520 there numbers with more than 32 bits can be represented. */
1521 filestart = strtol (arch_xhdr_big (last_file)->nextoff, (char **) NULL,
1522 10);
1523
1524 /* XXX These actually have to be calls to strtoll (at least on 32-bit
1525 machines) since the fields's width is 20 and there numbers with more
1526 than 32 bits can be represented. */
1527 if (filestart == 0
1528 || filestart == strtol (xcoff_ardata_big (archive)->memoff,
1529 (char **) NULL, 10)
1530 || filestart == strtol (xcoff_ardata_big (archive)->symoff,
1531 (char **) NULL, 10))
1532 {
1533 bfd_set_error (bfd_error_no_more_archived_files);
1534 return NULL;
1535 }
1536 }
1537
1538 return _bfd_get_elt_at_filepos (archive, filestart);
1539 }
1540
1541 /* Stat an element in an XCOFF archive. */
1542
1543 int
1544 _bfd_xcoff_stat_arch_elt (abfd, s)
1545 bfd *abfd;
1546 struct stat *s;
1547 {
1548 if (abfd->arelt_data == NULL)
1549 {
1550 bfd_set_error (bfd_error_invalid_operation);
1551 return -1;
1552 }
1553
1554 if (! xcoff_big_format_p (abfd->my_archive))
1555 {
1556 struct xcoff_ar_hdr *hdrp = arch_xhdr (abfd);
1557
1558 s->st_mtime = strtol (hdrp->date, (char **) NULL, 10);
1559 s->st_uid = strtol (hdrp->uid, (char **) NULL, 10);
1560 s->st_gid = strtol (hdrp->gid, (char **) NULL, 10);
1561 s->st_mode = strtol (hdrp->mode, (char **) NULL, 8);
1562 s->st_size = arch_eltdata (abfd)->parsed_size;
1563 }
1564 else
1565 {
1566 struct xcoff_ar_hdr_big *hdrp = arch_xhdr_big (abfd);
1567
1568 s->st_mtime = strtol (hdrp->date, (char **) NULL, 10);
1569 s->st_uid = strtol (hdrp->uid, (char **) NULL, 10);
1570 s->st_gid = strtol (hdrp->gid, (char **) NULL, 10);
1571 s->st_mode = strtol (hdrp->mode, (char **) NULL, 8);
1572 s->st_size = arch_eltdata (abfd)->parsed_size;
1573 }
1574
1575 return 0;
1576 }
1577
1578 /* Normalize a file name for inclusion in an archive. */
1579
1580 static const char *
1581 normalize_filename (abfd)
1582 bfd *abfd;
1583 {
1584 const char *file;
1585 const char *filename;
1586
1587 file = bfd_get_filename (abfd);
1588 filename = strrchr (file, '/');
1589 if (filename != NULL)
1590 filename++;
1591 else
1592 filename = file;
1593 return filename;
1594 }
1595
1596 /* Write out an XCOFF armap. */
1597
1598 static bfd_boolean
1599 xcoff_write_armap_old (abfd, elength, map, orl_count, stridx)
1600 bfd *abfd;
1601 unsigned int elength ATTRIBUTE_UNUSED;
1602 struct orl *map;
1603 unsigned int orl_count;
1604 int stridx;
1605 {
1606 struct xcoff_ar_hdr hdr;
1607 char *p;
1608 unsigned char buf[4];
1609 bfd *sub;
1610 file_ptr fileoff;
1611 unsigned int i;
1612
1613 memset (&hdr, 0, sizeof hdr);
1614 sprintf (hdr.size, "%ld", (long) (4 + orl_count * 4 + stridx));
1615 sprintf (hdr.nextoff, "%d", 0);
1616 memcpy (hdr.prevoff, xcoff_ardata (abfd)->memoff, XCOFFARMAG_ELEMENT_SIZE);
1617 sprintf (hdr.date, "%d", 0);
1618 sprintf (hdr.uid, "%d", 0);
1619 sprintf (hdr.gid, "%d", 0);
1620 sprintf (hdr.mode, "%d", 0);
1621 sprintf (hdr.namlen, "%d", 0);
1622
1623 /* We need spaces, not null bytes, in the header. */
1624 for (p = (char *) &hdr; p < (char *) &hdr + SIZEOF_AR_HDR; p++)
1625 if (*p == '\0')
1626 *p = ' ';
1627
1628 if (bfd_bwrite ((PTR) &hdr, (bfd_size_type) SIZEOF_AR_HDR, abfd)
1629 != SIZEOF_AR_HDR
1630 || (bfd_bwrite (XCOFFARFMAG, (bfd_size_type) SXCOFFARFMAG, abfd)
1631 != SXCOFFARFMAG))
1632 return FALSE;
1633
1634 H_PUT_32 (abfd, orl_count, buf);
1635 if (bfd_bwrite (buf, (bfd_size_type) 4, abfd) != 4)
1636 return FALSE;
1637
1638 sub = abfd->archive_head;
1639 fileoff = SIZEOF_AR_FILE_HDR;
1640 i = 0;
1641 while (sub != NULL && i < orl_count)
1642 {
1643 size_t namlen;
1644
1645 while (map[i].u.abfd == sub)
1646 {
1647 H_PUT_32 (abfd, fileoff, buf);
1648 if (bfd_bwrite (buf, (bfd_size_type) 4, abfd) != 4)
1649 return FALSE;
1650 ++i;
1651 }
1652 namlen = strlen (normalize_filename (sub));
1653 namlen = (namlen + 1) &~ (size_t) 1;
1654 fileoff += (SIZEOF_AR_HDR
1655 + namlen
1656 + SXCOFFARFMAG
1657 + arelt_size (sub));
1658 fileoff = (fileoff + 1) &~ 1;
1659 sub = sub->archive_next;
1660 }
1661
1662 for (i = 0; i < orl_count; i++)
1663 {
1664 const char *name;
1665 size_t namlen;
1666
1667 name = *map[i].name;
1668 namlen = strlen (name);
1669 if (bfd_bwrite (name, (bfd_size_type) (namlen + 1), abfd) != namlen + 1)
1670 return FALSE;
1671 }
1672
1673 if ((stridx & 1) != 0)
1674 {
1675 char b;
1676
1677 b = '\0';
1678 if (bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
1679 return FALSE;
1680 }
1681
1682 return TRUE;
1683 }
1684
1685 static char buff20[XCOFFARMAGBIG_ELEMENT_SIZE + 1];
1686 #define FMT20 "%-20lld"
1687 #define FMT12 "%-12d"
1688 #define FMT12_OCTAL "%-12o"
1689 #define FMT4 "%-4d"
1690 #define PRINT20(d, v) \
1691 sprintf (buff20, FMT20, (long long)(v)), \
1692 memcpy ((void *) (d), buff20, 20)
1693
1694 #define PRINT12(d, v) \
1695 sprintf (buff20, FMT12, (int)(v)), \
1696 memcpy ((void *) (d), buff20, 12)
1697
1698 #define PRINT12_OCTAL(d, v) \
1699 sprintf (buff20, FMT12_OCTAL, (unsigned int)(v)), \
1700 memcpy ((void *) (d), buff20, 12)
1701
1702 #define PRINT4(d, v) \
1703 sprintf (buff20, FMT4, (int)(v)), \
1704 memcpy ((void *) (d), buff20, 4)
1705
1706 #define READ20(d, v) \
1707 buff20[20] = 0, \
1708 memcpy (buff20, (d), 20), \
1709 (v) = bfd_scan_vma (buff20, (const char **) NULL, 10)
1710
1711 static bfd_boolean
1712 do_pad (abfd, number)
1713 bfd *abfd;
1714 unsigned int number;
1715 {
1716 bfd_byte b = 0;
1717
1718 /* Limit pad to <= 4096. */
1719 if (number > 4096)
1720 return FALSE;
1721
1722 while (number--)
1723 if (bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
1724 return FALSE;
1725
1726 return TRUE;
1727 }
1728
1729 static bfd_boolean
1730 do_copy (out_bfd, in_bfd)
1731 bfd *out_bfd;
1732 bfd *in_bfd;
1733 {
1734 bfd_size_type remaining;
1735 bfd_byte buffer[DEFAULT_BUFFERSIZE];
1736
1737 if (bfd_seek (in_bfd, (file_ptr) 0, SEEK_SET) != 0)
1738 return FALSE;
1739
1740 remaining = arelt_size (in_bfd);
1741
1742 while (remaining >= DEFAULT_BUFFERSIZE)
1743 {
1744 if (bfd_bread (buffer, DEFAULT_BUFFERSIZE, in_bfd) != DEFAULT_BUFFERSIZE
1745 || bfd_bwrite (buffer, DEFAULT_BUFFERSIZE, out_bfd) != DEFAULT_BUFFERSIZE)
1746 return FALSE;
1747
1748 remaining -= DEFAULT_BUFFERSIZE;
1749 }
1750
1751 if (remaining)
1752 {
1753 if (bfd_bread (buffer, remaining, in_bfd) != remaining
1754 || bfd_bwrite (buffer, remaining, out_bfd) != remaining)
1755 return FALSE;
1756 }
1757
1758 return TRUE;
1759 }
1760
1761 static bfd_boolean
1762 do_shared_object_padding (out_bfd, in_bfd, offset, ar_header_size)
1763 bfd *out_bfd;
1764 bfd *in_bfd;
1765 file_ptr *offset;
1766 int ar_header_size;
1767 {
1768 if (bfd_check_format (in_bfd, bfd_object)
1769 && bfd_get_flavour (in_bfd) == bfd_target_xcoff_flavour
1770 && (in_bfd->flags & DYNAMIC) != 0)
1771 {
1772 bfd_size_type pad = 0;
1773 int text_align_power;
1774
1775 text_align_power = bfd_xcoff_text_align_power (in_bfd);
1776
1777 pad = 1 << text_align_power;
1778 pad -= (*offset + ar_header_size) & (pad - 1);
1779
1780 if (! do_pad (out_bfd, pad))
1781 return FALSE;
1782
1783 *offset += pad;
1784 }
1785
1786 return TRUE;
1787 }
1788
1789 static bfd_boolean
1790 xcoff_write_armap_big (abfd, elength, map, orl_count, stridx)
1791 bfd *abfd;
1792 unsigned int elength ATTRIBUTE_UNUSED;
1793 struct orl *map;
1794 unsigned int orl_count;
1795 int stridx;
1796 {
1797 struct xcoff_ar_file_hdr_big *fhdr;
1798 bfd_vma i, sym_32, sym_64, str_32, str_64;
1799 const bfd_arch_info_type *arch_info = NULL;
1800 bfd *current_bfd;
1801 size_t string_length;
1802 file_ptr nextoff, prevoff;
1803
1804 /* First, we look through the symbols and work out which are
1805 from 32-bit objects and which from 64-bit ones. */
1806 sym_32 = sym_64 = str_32 = str_64 = 0;
1807
1808 current_bfd = abfd->archive_head;
1809 if (current_bfd != NULL)
1810 arch_info = bfd_get_arch_info (current_bfd);
1811 i = 0;
1812 while (current_bfd != NULL && i < orl_count)
1813 {
1814 while (map[i].u.abfd == current_bfd)
1815 {
1816 string_length = strlen (*map[i].name) + 1;
1817
1818 if (arch_info->bits_per_address == 64)
1819 {
1820 sym_64++;
1821 str_64 += string_length;
1822 }
1823 else
1824 {
1825 sym_32++;
1826 str_32 += string_length;
1827 }
1828 i++;
1829 }
1830 current_bfd = current_bfd->archive_next;
1831 if (current_bfd != NULL)
1832 arch_info = bfd_get_arch_info (current_bfd);
1833 }
1834
1835 /* A quick sanity check... */
1836 BFD_ASSERT (sym_64 + sym_32 == orl_count);
1837 /* Explicit cast to int for compiler. */
1838 BFD_ASSERT ((int)(str_64 + str_32) == stridx);
1839
1840 fhdr = xcoff_ardata_big (abfd);
1841
1842 /* xcoff_write_archive_contents_big passes nextoff in symoff. */
1843 READ20 (fhdr->memoff, prevoff);
1844 READ20 (fhdr->symoff, nextoff);
1845
1846 BFD_ASSERT (nextoff == bfd_tell (abfd));
1847
1848 /* Write out the symbol table.
1849 Layout :
1850
1851 standard big archive header
1852 0x0000 ar_size [0x14]
1853 0x0014 ar_nxtmem [0x14]
1854 0x0028 ar_prvmem [0x14]
1855 0x003C ar_date [0x0C]
1856 0x0048 ar_uid [0x0C]
1857 0x0054 ar_gid [0x0C]
1858 0x0060 ar_mod [0x0C]
1859 0x006C ar_namelen[0x04]
1860 0x0070 ar_fmag [SXCOFFARFMAG]
1861
1862 Symbol table
1863 0x0072 num_syms [0x08], binary
1864 0x0078 offsets [0x08 * num_syms], binary
1865 0x0086 + 0x08 * num_syms names [??]
1866 ?? pad to even bytes.
1867 */
1868
1869 if (sym_32)
1870 {
1871 struct xcoff_ar_hdr_big *hdr;
1872 char *symbol_table;
1873 char *st;
1874 file_ptr fileoff;
1875
1876 bfd_vma symbol_table_size =
1877 SIZEOF_AR_HDR_BIG
1878 + SXCOFFARFMAG
1879 + 8
1880 + 8 * sym_32
1881 + str_32 + (str_32 & 1);
1882
1883 symbol_table = bfd_zmalloc (symbol_table_size);
1884 if (symbol_table == NULL)
1885 return FALSE;
1886
1887 hdr = (struct xcoff_ar_hdr_big *) symbol_table;
1888
1889 PRINT20 (hdr->size, 8 + 8 * sym_32 + str_32 + (str_32 & 1));
1890
1891 if (sym_64)
1892 PRINT20 (hdr->nextoff, nextoff + symbol_table_size);
1893 else
1894 PRINT20 (hdr->nextoff, 0);
1895
1896 PRINT20 (hdr->prevoff, prevoff);
1897 PRINT12 (hdr->date, 0);
1898 PRINT12 (hdr->uid, 0);
1899 PRINT12 (hdr->gid, 0);
1900 PRINT12 (hdr->mode, 0);
1901 PRINT4 (hdr->namlen, 0) ;
1902
1903 st = symbol_table + SIZEOF_AR_HDR_BIG;
1904 memcpy (st, XCOFFARFMAG, SXCOFFARFMAG);
1905 st += SXCOFFARFMAG;
1906
1907 bfd_h_put_64 (abfd, sym_32, st);
1908 st += 8;
1909
1910 /* loop over the 32 bit offsets */
1911 current_bfd = abfd->archive_head;
1912 if (current_bfd != NULL)
1913 arch_info = bfd_get_arch_info (current_bfd);
1914 fileoff = SIZEOF_AR_FILE_HDR_BIG;
1915 i = 0;
1916 while (current_bfd != NULL && i < orl_count)
1917 {
1918 while (map[i].u.abfd == current_bfd)
1919 {
1920 if (arch_info->bits_per_address == 32)
1921 {
1922 bfd_h_put_64 (abfd, fileoff, st);
1923 st += 8;
1924 }
1925 i++;
1926 }
1927 string_length = strlen (normalize_filename (current_bfd));
1928 string_length += string_length & 1;
1929 fileoff += (SIZEOF_AR_HDR_BIG
1930 + string_length
1931 + SXCOFFARFMAG
1932 + arelt_size (current_bfd));
1933 fileoff += fileoff & 1;
1934 current_bfd = current_bfd->archive_next;
1935 if (current_bfd != NULL)
1936 arch_info = bfd_get_arch_info (current_bfd);
1937 }
1938
1939 /* loop over the 32 bit symbol names */
1940 current_bfd = abfd->archive_head;
1941 if (current_bfd != NULL)
1942 arch_info = bfd_get_arch_info (current_bfd);
1943 i = 0;
1944 while (current_bfd != NULL && i < orl_count)
1945 {
1946 while (map[i].u.abfd == current_bfd)
1947 {
1948 if (arch_info->bits_per_address == 32)
1949 {
1950 string_length = sprintf (st, "%s", *map[i].name);
1951 st += string_length + 1;
1952 }
1953 i++;
1954 }
1955 current_bfd = current_bfd->archive_next;
1956 if (current_bfd != NULL)
1957 arch_info = bfd_get_arch_info (current_bfd);
1958 }
1959
1960 bfd_bwrite (symbol_table, symbol_table_size, abfd);
1961
1962 free (symbol_table);
1963
1964 prevoff = nextoff;
1965 nextoff = nextoff + symbol_table_size;
1966 }
1967 else
1968 PRINT20 (fhdr->symoff, 0);
1969
1970 if (sym_64)
1971 {
1972 struct xcoff_ar_hdr_big *hdr;
1973 char *symbol_table;
1974 char *st;
1975 file_ptr fileoff;
1976
1977 bfd_vma symbol_table_size =
1978 SIZEOF_AR_HDR_BIG
1979 + SXCOFFARFMAG
1980 + 8
1981 + 8 * sym_64
1982 + str_64 + (str_64 & 1);
1983
1984 symbol_table = bfd_zmalloc (symbol_table_size);
1985 if (symbol_table == NULL)
1986 return FALSE;
1987
1988 hdr = (struct xcoff_ar_hdr_big *) symbol_table;
1989
1990 PRINT20 (hdr->size, 8 + 8 * sym_64 + str_64 + (str_64 & 1));
1991 PRINT20 (hdr->nextoff, 0);
1992 PRINT20 (hdr->prevoff, prevoff);
1993 PRINT12 (hdr->date, 0);
1994 PRINT12 (hdr->uid, 0);
1995 PRINT12 (hdr->gid, 0);
1996 PRINT12 (hdr->mode, 0);
1997 PRINT4 (hdr->namlen, 0);
1998
1999 st = symbol_table + SIZEOF_AR_HDR_BIG;
2000 memcpy (st, XCOFFARFMAG, SXCOFFARFMAG);
2001 st += SXCOFFARFMAG;
2002
2003 bfd_h_put_64 (abfd, sym_64, st);
2004 st += 8;
2005
2006 /* loop over the 64 bit offsets */
2007 current_bfd = abfd->archive_head;
2008 if (current_bfd != NULL)
2009 arch_info = bfd_get_arch_info (current_bfd);
2010 fileoff = SIZEOF_AR_FILE_HDR_BIG;
2011 i = 0;
2012 while (current_bfd != NULL && i < orl_count)
2013 {
2014 while (map[i].u.abfd == current_bfd)
2015 {
2016 if (arch_info->bits_per_address == 64)
2017 {
2018 bfd_h_put_64 (abfd, fileoff, st);
2019 st += 8;
2020 }
2021 i++;
2022 }
2023 string_length = strlen (normalize_filename (current_bfd));
2024 string_length += string_length & 1;
2025 fileoff += (SIZEOF_AR_HDR_BIG
2026 + string_length
2027 + SXCOFFARFMAG
2028 + arelt_size (current_bfd));
2029 fileoff += fileoff & 1;
2030 current_bfd = current_bfd->archive_next;
2031 if (current_bfd != NULL)
2032 arch_info = bfd_get_arch_info (current_bfd);
2033 }
2034
2035 /* loop over the 64 bit symbol names */
2036 current_bfd = abfd->archive_head;
2037 if (current_bfd != NULL)
2038 arch_info = bfd_get_arch_info (current_bfd);
2039 i = 0;
2040 while (current_bfd != NULL && i < orl_count)
2041 {
2042 while (map[i].u.abfd == current_bfd)
2043 {
2044 if (arch_info->bits_per_address == 64)
2045 {
2046 string_length = sprintf (st, "%s", *map[i].name);
2047 st += string_length + 1;
2048 }
2049 i++;
2050 }
2051 current_bfd = current_bfd->archive_next;
2052 if (current_bfd != NULL)
2053 arch_info = bfd_get_arch_info (current_bfd);
2054 }
2055
2056 bfd_bwrite (symbol_table, symbol_table_size, abfd);
2057
2058 free (symbol_table);
2059
2060 PRINT20 (fhdr->symoff64, nextoff);
2061 }
2062 else
2063 PRINT20 (fhdr->symoff64, 0);
2064
2065 return TRUE;
2066 }
2067
2068 bfd_boolean
2069 _bfd_xcoff_write_armap (abfd, elength, map, orl_count, stridx)
2070 bfd *abfd;
2071 unsigned int elength ATTRIBUTE_UNUSED;
2072 struct orl *map;
2073 unsigned int orl_count;
2074 int stridx;
2075 {
2076 if (! xcoff_big_format_p (abfd))
2077 return xcoff_write_armap_old (abfd, elength, map, orl_count, stridx);
2078 else
2079 return xcoff_write_armap_big (abfd, elength, map, orl_count, stridx);
2080 }
2081
2082 /* Write out an XCOFF archive. We always write an entire archive,
2083 rather than fussing with the freelist and so forth. */
2084
2085 static bfd_boolean
2086 xcoff_write_archive_contents_old (abfd)
2087 bfd *abfd;
2088 {
2089 struct xcoff_ar_file_hdr fhdr;
2090 bfd_size_type count;
2091 bfd_size_type total_namlen;
2092 file_ptr *offsets;
2093 bfd_boolean makemap;
2094 bfd_boolean hasobjects;
2095 file_ptr prevoff, nextoff;
2096 bfd *sub;
2097 size_t i;
2098 struct xcoff_ar_hdr ahdr;
2099 bfd_size_type size;
2100 char *p;
2101 char decbuf[XCOFFARMAG_ELEMENT_SIZE + 1];
2102
2103 memset (&fhdr, 0, sizeof fhdr);
2104 (void) strncpy (fhdr.magic, XCOFFARMAG, SXCOFFARMAG);
2105 sprintf (fhdr.firstmemoff, "%d", SIZEOF_AR_FILE_HDR);
2106 sprintf (fhdr.freeoff, "%d", 0);
2107
2108 count = 0;
2109 total_namlen = 0;
2110 for (sub = abfd->archive_head; sub != NULL; sub = sub->archive_next)
2111 {
2112 ++count;
2113 total_namlen += strlen (normalize_filename (sub)) + 1;
2114 }
2115 offsets = (file_ptr *) bfd_alloc (abfd, count * sizeof (file_ptr));
2116 if (offsets == NULL)
2117 return FALSE;
2118
2119 if (bfd_seek (abfd, (file_ptr) SIZEOF_AR_FILE_HDR, SEEK_SET) != 0)
2120 return FALSE;
2121
2122 makemap = bfd_has_map (abfd);
2123 hasobjects = FALSE;
2124 prevoff = 0;
2125 nextoff = SIZEOF_AR_FILE_HDR;
2126 for (sub = abfd->archive_head, i = 0;
2127 sub != NULL;
2128 sub = sub->archive_next, i++)
2129 {
2130 const char *name;
2131 bfd_size_type namlen;
2132 struct xcoff_ar_hdr *ahdrp;
2133 bfd_size_type remaining;
2134
2135 if (makemap && ! hasobjects)
2136 {
2137 if (bfd_check_format (sub, bfd_object))
2138 hasobjects = TRUE;
2139 }
2140
2141 name = normalize_filename (sub);
2142 namlen = strlen (name);
2143
2144 if (sub->arelt_data != NULL)
2145 ahdrp = arch_xhdr (sub);
2146 else
2147 ahdrp = NULL;
2148
2149 if (ahdrp == NULL)
2150 {
2151 struct stat s;
2152
2153 memset (&ahdr, 0, sizeof ahdr);
2154 ahdrp = &ahdr;
2155 if (stat (bfd_get_filename (sub), &s) != 0)
2156 {
2157 bfd_set_error (bfd_error_system_call);
2158 return FALSE;
2159 }
2160
2161 sprintf (ahdrp->size, "%ld", (long) s.st_size);
2162 sprintf (ahdrp->date, "%ld", (long) s.st_mtime);
2163 sprintf (ahdrp->uid, "%ld", (long) s.st_uid);
2164 sprintf (ahdrp->gid, "%ld", (long) s.st_gid);
2165 sprintf (ahdrp->mode, "%o", (unsigned int) s.st_mode);
2166
2167 if (sub->arelt_data == NULL)
2168 {
2169 size = sizeof (struct areltdata);
2170 sub->arelt_data = bfd_alloc (sub, size);
2171 if (sub->arelt_data == NULL)
2172 return FALSE;
2173 }
2174
2175 arch_eltdata (sub)->parsed_size = s.st_size;
2176 }
2177
2178 sprintf (ahdrp->prevoff, "%ld", (long) prevoff);
2179 sprintf (ahdrp->namlen, "%ld", (long) namlen);
2180
2181 /* If the length of the name is odd, we write out the null byte
2182 after the name as well. */
2183 namlen = (namlen + 1) &~ (bfd_size_type) 1;
2184
2185 remaining = arelt_size (sub);
2186 size = (SIZEOF_AR_HDR
2187 + namlen
2188 + SXCOFFARFMAG
2189 + remaining);
2190
2191 BFD_ASSERT (nextoff == bfd_tell (abfd));
2192
2193 offsets[i] = nextoff;
2194
2195 prevoff = nextoff;
2196 nextoff += size + (size & 1);
2197
2198 sprintf (ahdrp->nextoff, "%ld", (long) nextoff);
2199
2200 /* We need spaces, not null bytes, in the header. */
2201 for (p = (char *) ahdrp; p < (char *) ahdrp + SIZEOF_AR_HDR; p++)
2202 if (*p == '\0')
2203 *p = ' ';
2204
2205 if ((bfd_bwrite ((PTR) ahdrp, (bfd_size_type) SIZEOF_AR_HDR, abfd)
2206 != SIZEOF_AR_HDR)
2207 || bfd_bwrite ((PTR) name, namlen, abfd) != namlen
2208 || bfd_bwrite ((PTR) XCOFFARFMAG, (bfd_size_type) SXCOFFARFMAG,
2209 abfd) != SXCOFFARFMAG)
2210 return FALSE;
2211
2212 if (bfd_seek (sub, (file_ptr) 0, SEEK_SET) != 0)
2213 return FALSE;
2214
2215 if (! do_copy (abfd, sub))
2216 return FALSE;
2217
2218 if (! do_pad (abfd, size & 1))
2219 return FALSE;
2220 }
2221
2222 sprintf (fhdr.lastmemoff, "%ld", (long) prevoff);
2223
2224 /* Write out the member table. */
2225
2226 BFD_ASSERT (nextoff == bfd_tell (abfd));
2227 sprintf (fhdr.memoff, "%ld", (long) nextoff);
2228
2229 memset (&ahdr, 0, sizeof ahdr);
2230 sprintf (ahdr.size, "%ld", (long) (XCOFFARMAG_ELEMENT_SIZE
2231 + count * XCOFFARMAG_ELEMENT_SIZE
2232 + total_namlen));
2233 sprintf (ahdr.prevoff, "%ld", (long) prevoff);
2234 sprintf (ahdr.date, "%d", 0);
2235 sprintf (ahdr.uid, "%d", 0);
2236 sprintf (ahdr.gid, "%d", 0);
2237 sprintf (ahdr.mode, "%d", 0);
2238 sprintf (ahdr.namlen, "%d", 0);
2239
2240 size = (SIZEOF_AR_HDR
2241 + XCOFFARMAG_ELEMENT_SIZE
2242 + count * XCOFFARMAG_ELEMENT_SIZE
2243 + total_namlen
2244 + SXCOFFARFMAG);
2245
2246 prevoff = nextoff;
2247 nextoff += size + (size & 1);
2248
2249 if (makemap && hasobjects)
2250 sprintf (ahdr.nextoff, "%ld", (long) nextoff);
2251 else
2252 sprintf (ahdr.nextoff, "%d", 0);
2253
2254 /* We need spaces, not null bytes, in the header. */
2255 for (p = (char *) &ahdr; p < (char *) &ahdr + SIZEOF_AR_HDR; p++)
2256 if (*p == '\0')
2257 *p = ' ';
2258
2259 if ((bfd_bwrite ((PTR) &ahdr, (bfd_size_type) SIZEOF_AR_HDR, abfd)
2260 != SIZEOF_AR_HDR)
2261 || (bfd_bwrite ((PTR) XCOFFARFMAG, (bfd_size_type) SXCOFFARFMAG, abfd)
2262 != SXCOFFARFMAG))
2263 return FALSE;
2264
2265 sprintf (decbuf, "%-12ld", (long) count);
2266 if (bfd_bwrite ((PTR) decbuf, (bfd_size_type) XCOFFARMAG_ELEMENT_SIZE, abfd)
2267 != XCOFFARMAG_ELEMENT_SIZE)
2268 return FALSE;
2269 for (i = 0; i < (size_t) count; i++)
2270 {
2271 sprintf (decbuf, "%-12ld", (long) offsets[i]);
2272 if (bfd_bwrite ((PTR) decbuf, (bfd_size_type) XCOFFARMAG_ELEMENT_SIZE,
2273 abfd) != XCOFFARMAG_ELEMENT_SIZE)
2274 return FALSE;
2275 }
2276 for (sub = abfd->archive_head; sub != NULL; sub = sub->archive_next)
2277 {
2278 const char *name;
2279 bfd_size_type namlen;
2280
2281 name = normalize_filename (sub);
2282 namlen = strlen (name);
2283 if (bfd_bwrite ((PTR) name, namlen + 1, abfd) != namlen + 1)
2284 return FALSE;
2285 }
2286
2287 if (! do_pad (abfd, size & 1))
2288 return FALSE;
2289
2290 /* Write out the armap, if appropriate. */
2291 if (! makemap || ! hasobjects)
2292 sprintf (fhdr.symoff, "%d", 0);
2293 else
2294 {
2295 BFD_ASSERT (nextoff == bfd_tell (abfd));
2296 sprintf (fhdr.symoff, "%ld", (long) nextoff);
2297 bfd_ardata (abfd)->tdata = (PTR) &fhdr;
2298 if (! _bfd_compute_and_write_armap (abfd, 0))
2299 return FALSE;
2300 }
2301
2302 /* Write out the archive file header. */
2303
2304 /* We need spaces, not null bytes, in the header. */
2305 for (p = (char *) &fhdr; p < (char *) &fhdr + SIZEOF_AR_FILE_HDR; p++)
2306 if (*p == '\0')
2307 *p = ' ';
2308
2309 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
2310 || (bfd_bwrite ((PTR) &fhdr, (bfd_size_type) SIZEOF_AR_FILE_HDR, abfd)
2311 != SIZEOF_AR_FILE_HDR))
2312 return FALSE;
2313
2314 return TRUE;
2315 }
2316
2317 static bfd_boolean
2318 xcoff_write_archive_contents_big (abfd)
2319 bfd *abfd;
2320 {
2321 struct xcoff_ar_file_hdr_big fhdr;
2322 bfd_size_type count;
2323 bfd_size_type total_namlen;
2324 file_ptr *offsets;
2325 bfd_boolean makemap;
2326 bfd_boolean hasobjects;
2327 file_ptr prevoff, nextoff;
2328 bfd *current_bfd;
2329 size_t i;
2330 struct xcoff_ar_hdr_big *hdr, ahdr;
2331 bfd_size_type size;
2332 char *member_table, *mt;
2333 bfd_vma member_table_size;
2334
2335 memset (&fhdr, 0, SIZEOF_AR_FILE_HDR_BIG);
2336 memcpy (fhdr.magic, XCOFFARMAGBIG, SXCOFFARMAG);
2337
2338 if (bfd_seek (abfd, (file_ptr) SIZEOF_AR_FILE_HDR_BIG, SEEK_SET) != 0)
2339 return FALSE;
2340
2341 /* Calculate count and total_namlen. */
2342 makemap = bfd_has_map (abfd);
2343 hasobjects = FALSE;
2344 for (current_bfd = abfd->archive_head, count = 0, total_namlen = 0;
2345 current_bfd != NULL;
2346 current_bfd = current_bfd->archive_next, count++)
2347 {
2348 total_namlen += strlen (normalize_filename (current_bfd)) + 1;
2349
2350 if (makemap
2351 && ! hasobjects
2352 && bfd_check_format (current_bfd, bfd_object))
2353 hasobjects = TRUE;
2354 }
2355
2356 offsets = NULL;
2357 if (count)
2358 {
2359 offsets = (file_ptr *) bfd_malloc (count * sizeof (file_ptr));
2360 if (offsets == NULL)
2361 return FALSE;
2362 }
2363
2364 prevoff = 0;
2365 nextoff = SIZEOF_AR_FILE_HDR_BIG;
2366 for (current_bfd = abfd->archive_head, i = 0;
2367 current_bfd != NULL;
2368 current_bfd = current_bfd->archive_next, i++)
2369 {
2370 const char *name;
2371 bfd_size_type namlen;
2372 struct xcoff_ar_hdr_big *ahdrp;
2373 bfd_size_type remaining;
2374
2375 name = normalize_filename (current_bfd);
2376 namlen = strlen (name);
2377
2378 if (current_bfd->arelt_data != NULL)
2379 ahdrp = arch_xhdr_big (current_bfd);
2380 else
2381 ahdrp = NULL;
2382
2383 if (ahdrp == NULL)
2384 {
2385 struct stat s;
2386
2387 ahdrp = &ahdr;
2388 /* XXX This should actually be a call to stat64 (at least on
2389 32-bit machines).
2390 XXX This call will fail if the original object is not found. */
2391 if (stat (bfd_get_filename (current_bfd), &s) != 0)
2392 {
2393 bfd_set_error (bfd_error_system_call);
2394 return FALSE;
2395 }
2396
2397 PRINT20 (ahdrp->size, s.st_size);
2398 PRINT12 (ahdrp->date, s.st_mtime);
2399 PRINT12 (ahdrp->uid, s.st_uid);
2400 PRINT12 (ahdrp->gid, s.st_gid);
2401 PRINT12_OCTAL (ahdrp->mode, s.st_mode);
2402
2403 if (current_bfd->arelt_data == NULL)
2404 {
2405 size = sizeof (struct areltdata);
2406 current_bfd->arelt_data = bfd_alloc (current_bfd, size);
2407 if (current_bfd->arelt_data == NULL)
2408 return FALSE;
2409 }
2410
2411 arch_eltdata (current_bfd)->parsed_size = s.st_size;
2412 }
2413
2414 PRINT20 (ahdrp->prevoff, prevoff);
2415 PRINT4 (ahdrp->namlen, namlen);
2416
2417 /* If the length of the name is odd, we write out the null byte
2418 after the name as well. */
2419 namlen = (namlen + 1) &~ (bfd_size_type) 1;
2420
2421 remaining = arelt_size (current_bfd);
2422 size = (SIZEOF_AR_HDR_BIG
2423 + namlen
2424 + SXCOFFARFMAG
2425 + remaining);
2426
2427 BFD_ASSERT (nextoff == bfd_tell (abfd));
2428
2429 /* Check for xcoff shared objects.
2430 Their text section needs to be aligned wrt the archive file position.
2431 This requires extra padding before the archive header. */
2432 if (! do_shared_object_padding (abfd, current_bfd, & nextoff,
2433 SIZEOF_AR_HDR_BIG + namlen
2434 + SXCOFFARFMAG))
2435 return FALSE;
2436
2437 offsets[i] = nextoff;
2438
2439 prevoff = nextoff;
2440 nextoff += size + (size & 1);
2441
2442 PRINT20 (ahdrp->nextoff, nextoff);
2443
2444 if ((bfd_bwrite ((PTR) ahdrp, (bfd_size_type) SIZEOF_AR_HDR_BIG, abfd)
2445 != SIZEOF_AR_HDR_BIG)
2446 || bfd_bwrite ((PTR) name, (bfd_size_type) namlen, abfd) != namlen
2447 || (bfd_bwrite ((PTR) XCOFFARFMAG, (bfd_size_type) SXCOFFARFMAG,
2448 abfd) != SXCOFFARFMAG))
2449 return FALSE;
2450
2451 if (bfd_seek (current_bfd, (file_ptr) 0, SEEK_SET) != 0)
2452 return FALSE;
2453
2454 if (! do_copy (abfd, current_bfd))
2455 return FALSE;
2456
2457 if (! do_pad (abfd, size & 1))
2458 return FALSE;
2459 }
2460
2461 if (count)
2462 {
2463 PRINT20 (fhdr.firstmemoff, offsets[0]);
2464 PRINT20 (fhdr.lastmemoff, prevoff);
2465 }
2466
2467 /* Write out the member table.
2468 Layout :
2469
2470 standard big archive header
2471 0x0000 ar_size [0x14]
2472 0x0014 ar_nxtmem [0x14]
2473 0x0028 ar_prvmem [0x14]
2474 0x003C ar_date [0x0C]
2475 0x0048 ar_uid [0x0C]
2476 0x0054 ar_gid [0x0C]
2477 0x0060 ar_mod [0x0C]
2478 0x006C ar_namelen[0x04]
2479 0x0070 ar_fmag [0x02]
2480
2481 Member table
2482 0x0072 count [0x14]
2483 0x0086 offsets [0x14 * counts]
2484 0x0086 + 0x14 * counts names [??]
2485 ?? pad to even bytes.
2486 */
2487
2488 BFD_ASSERT (nextoff == bfd_tell (abfd));
2489
2490 member_table_size = (SIZEOF_AR_HDR_BIG
2491 + SXCOFFARFMAG
2492 + XCOFFARMAGBIG_ELEMENT_SIZE
2493 + count * XCOFFARMAGBIG_ELEMENT_SIZE
2494 + total_namlen);
2495
2496 member_table_size += member_table_size & 1;
2497 member_table = bfd_zmalloc (member_table_size);
2498 if (member_table == NULL)
2499 return FALSE;
2500
2501 hdr = (struct xcoff_ar_hdr_big *) member_table;
2502
2503 PRINT20 (hdr->size, (XCOFFARMAGBIG_ELEMENT_SIZE
2504 + count * XCOFFARMAGBIG_ELEMENT_SIZE
2505 + total_namlen + (total_namlen & 1)));
2506 if (makemap && hasobjects)
2507 PRINT20 (hdr->nextoff, nextoff + member_table_size);
2508 else
2509 PRINT20 (hdr->nextoff, 0);
2510 PRINT20 (hdr->prevoff, prevoff);
2511 PRINT12 (hdr->date, 0);
2512 PRINT12 (hdr->uid, 0);
2513 PRINT12 (hdr->gid, 0);
2514 PRINT12 (hdr->mode, 0);
2515 PRINT4 (hdr->namlen, 0);
2516
2517 mt = member_table + SIZEOF_AR_HDR_BIG;
2518 memcpy (mt, XCOFFARFMAG, SXCOFFARFMAG);
2519 mt += SXCOFFARFMAG;
2520
2521 PRINT20 (mt, count);
2522 mt += XCOFFARMAGBIG_ELEMENT_SIZE;
2523 for (i = 0; i < (size_t) count; i++)
2524 {
2525 PRINT20 (mt, offsets[i]);
2526 mt += XCOFFARMAGBIG_ELEMENT_SIZE;
2527 }
2528
2529 if (count)
2530 {
2531 free (offsets);
2532 offsets = NULL;
2533 }
2534
2535 for (current_bfd = abfd->archive_head;
2536 current_bfd != NULL;
2537 current_bfd = current_bfd->archive_next)
2538 {
2539 const char *name;
2540 size_t namlen;
2541
2542 name = normalize_filename (current_bfd);
2543 namlen = sprintf (mt, "%s", name);
2544 mt += namlen + 1;
2545 }
2546
2547 if (bfd_bwrite (member_table, member_table_size, abfd) != member_table_size)
2548 return FALSE;
2549
2550 free (member_table);
2551
2552 PRINT20 (fhdr.memoff, nextoff);
2553
2554 prevoff = nextoff;
2555 nextoff += member_table_size;
2556
2557 /* Write out the armap, if appropriate. */
2558
2559 if (! makemap || ! hasobjects)
2560 PRINT20 (fhdr.symoff, 0);
2561 else
2562 {
2563 BFD_ASSERT (nextoff == bfd_tell (abfd));
2564
2565 /* Save nextoff in fhdr.symoff so the armap routine can use it. */
2566 PRINT20 (fhdr.symoff, nextoff);
2567
2568 bfd_ardata (abfd)->tdata = (PTR) &fhdr;
2569 if (! _bfd_compute_and_write_armap (abfd, 0))
2570 return FALSE;
2571 }
2572
2573 /* Write out the archive file header. */
2574
2575 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
2576 || (bfd_bwrite ((PTR) &fhdr, (bfd_size_type) SIZEOF_AR_FILE_HDR_BIG,
2577 abfd) != SIZEOF_AR_FILE_HDR_BIG))
2578 return FALSE;
2579
2580 return TRUE;
2581 }
2582
2583 bfd_boolean
2584 _bfd_xcoff_write_archive_contents (abfd)
2585 bfd *abfd;
2586 {
2587 if (! xcoff_big_format_p (abfd))
2588 return xcoff_write_archive_contents_old (abfd);
2589 else
2590 return xcoff_write_archive_contents_big (abfd);
2591 }
2592 \f
2593 /* We can't use the usual coff_sizeof_headers routine, because AIX
2594 always uses an a.out header. */
2595
2596 int
2597 _bfd_xcoff_sizeof_headers (bfd *abfd,
2598 struct bfd_link_info *info ATTRIBUTE_UNUSED)
2599 {
2600 int size;
2601
2602 size = FILHSZ;
2603 if (xcoff_data (abfd)->full_aouthdr)
2604 size += AOUTSZ;
2605 else
2606 size += SMALL_AOUTSZ;
2607 size += abfd->section_count * SCNHSZ;
2608 return size;
2609 }
2610 \f
2611 /* Routines to swap information in the XCOFF .loader section. If we
2612 ever need to write an XCOFF loader, this stuff will need to be
2613 moved to another file shared by the linker (which XCOFF calls the
2614 ``binder'') and the loader. */
2615
2616 /* Swap in the ldhdr structure. */
2617
2618 static void
2619 xcoff_swap_ldhdr_in (abfd, s, dst)
2620 bfd *abfd;
2621 const PTR s;
2622 struct internal_ldhdr *dst;
2623 {
2624 const struct external_ldhdr *src = (const struct external_ldhdr *) s;
2625
2626 dst->l_version = bfd_get_32 (abfd, src->l_version);
2627 dst->l_nsyms = bfd_get_32 (abfd, src->l_nsyms);
2628 dst->l_nreloc = bfd_get_32 (abfd, src->l_nreloc);
2629 dst->l_istlen = bfd_get_32 (abfd, src->l_istlen);
2630 dst->l_nimpid = bfd_get_32 (abfd, src->l_nimpid);
2631 dst->l_impoff = bfd_get_32 (abfd, src->l_impoff);
2632 dst->l_stlen = bfd_get_32 (abfd, src->l_stlen);
2633 dst->l_stoff = bfd_get_32 (abfd, src->l_stoff);
2634 }
2635
2636 /* Swap out the ldhdr structure. */
2637
2638 static void
2639 xcoff_swap_ldhdr_out (abfd, src, d)
2640 bfd *abfd;
2641 const struct internal_ldhdr *src;
2642 PTR d;
2643 {
2644 struct external_ldhdr *dst = (struct external_ldhdr *) d;
2645
2646 bfd_put_32 (abfd, (bfd_vma) src->l_version, dst->l_version);
2647 bfd_put_32 (abfd, src->l_nsyms, dst->l_nsyms);
2648 bfd_put_32 (abfd, src->l_nreloc, dst->l_nreloc);
2649 bfd_put_32 (abfd, src->l_istlen, dst->l_istlen);
2650 bfd_put_32 (abfd, src->l_nimpid, dst->l_nimpid);
2651 bfd_put_32 (abfd, src->l_impoff, dst->l_impoff);
2652 bfd_put_32 (abfd, src->l_stlen, dst->l_stlen);
2653 bfd_put_32 (abfd, src->l_stoff, dst->l_stoff);
2654 }
2655
2656 /* Swap in the ldsym structure. */
2657
2658 static void
2659 xcoff_swap_ldsym_in (abfd, s, dst)
2660 bfd *abfd;
2661 const PTR s;
2662 struct internal_ldsym *dst;
2663 {
2664 const struct external_ldsym *src = (const struct external_ldsym *) s;
2665
2666 if (bfd_get_32 (abfd, src->_l._l_l._l_zeroes) != 0) {
2667 memcpy (dst->_l._l_name, src->_l._l_name, SYMNMLEN);
2668 } else {
2669 dst->_l._l_l._l_zeroes = 0;
2670 dst->_l._l_l._l_offset = bfd_get_32 (abfd, src->_l._l_l._l_offset);
2671 }
2672 dst->l_value = bfd_get_32 (abfd, src->l_value);
2673 dst->l_scnum = bfd_get_16 (abfd, src->l_scnum);
2674 dst->l_smtype = bfd_get_8 (abfd, src->l_smtype);
2675 dst->l_smclas = bfd_get_8 (abfd, src->l_smclas);
2676 dst->l_ifile = bfd_get_32 (abfd, src->l_ifile);
2677 dst->l_parm = bfd_get_32 (abfd, src->l_parm);
2678 }
2679
2680 /* Swap out the ldsym structure. */
2681
2682 static void
2683 xcoff_swap_ldsym_out (abfd, src, d)
2684 bfd *abfd;
2685 const struct internal_ldsym *src;
2686 PTR d;
2687 {
2688 struct external_ldsym *dst = (struct external_ldsym *) d;
2689
2690 if (src->_l._l_l._l_zeroes != 0)
2691 memcpy (dst->_l._l_name, src->_l._l_name, SYMNMLEN);
2692 else
2693 {
2694 bfd_put_32 (abfd, (bfd_vma) 0, dst->_l._l_l._l_zeroes);
2695 bfd_put_32 (abfd, (bfd_vma) src->_l._l_l._l_offset,
2696 dst->_l._l_l._l_offset);
2697 }
2698 bfd_put_32 (abfd, src->l_value, dst->l_value);
2699 bfd_put_16 (abfd, (bfd_vma) src->l_scnum, dst->l_scnum);
2700 bfd_put_8 (abfd, src->l_smtype, dst->l_smtype);
2701 bfd_put_8 (abfd, src->l_smclas, dst->l_smclas);
2702 bfd_put_32 (abfd, src->l_ifile, dst->l_ifile);
2703 bfd_put_32 (abfd, src->l_parm, dst->l_parm);
2704 }
2705
2706 static void
2707 xcoff_swap_reloc_in (abfd, s, d)
2708 bfd *abfd;
2709 PTR s;
2710 PTR d;
2711 {
2712 struct external_reloc *src = (struct external_reloc *) s;
2713 struct internal_reloc *dst = (struct internal_reloc *) d;
2714
2715 memset (dst, 0, sizeof (struct internal_reloc));
2716
2717 dst->r_vaddr = bfd_get_32 (abfd, src->r_vaddr);
2718 dst->r_symndx = bfd_get_32 (abfd, src->r_symndx);
2719 dst->r_size = bfd_get_8 (abfd, src->r_size);
2720 dst->r_type = bfd_get_8 (abfd, src->r_type);
2721 }
2722
2723 static unsigned int
2724 xcoff_swap_reloc_out (abfd, s, d)
2725 bfd *abfd;
2726 PTR s;
2727 PTR d;
2728 {
2729 struct internal_reloc *src = (struct internal_reloc *) s;
2730 struct external_reloc *dst = (struct external_reloc *) d;
2731
2732 bfd_put_32 (abfd, src->r_vaddr, dst->r_vaddr);
2733 bfd_put_32 (abfd, src->r_symndx, dst->r_symndx);
2734 bfd_put_8 (abfd, src->r_type, dst->r_type);
2735 bfd_put_8 (abfd, src->r_size, dst->r_size);
2736
2737 return bfd_coff_relsz (abfd);
2738 }
2739
2740 /* Swap in the ldrel structure. */
2741
2742 static void
2743 xcoff_swap_ldrel_in (abfd, s, dst)
2744 bfd *abfd;
2745 const PTR s;
2746 struct internal_ldrel *dst;
2747 {
2748 const struct external_ldrel *src = (const struct external_ldrel *) s;
2749
2750 dst->l_vaddr = bfd_get_32 (abfd, src->l_vaddr);
2751 dst->l_symndx = bfd_get_32 (abfd, src->l_symndx);
2752 dst->l_rtype = bfd_get_16 (abfd, src->l_rtype);
2753 dst->l_rsecnm = bfd_get_16 (abfd, src->l_rsecnm);
2754 }
2755
2756 /* Swap out the ldrel structure. */
2757
2758 static void
2759 xcoff_swap_ldrel_out (abfd, src, d)
2760 bfd *abfd;
2761 const struct internal_ldrel *src;
2762 PTR d;
2763 {
2764 struct external_ldrel *dst = (struct external_ldrel *) d;
2765
2766 bfd_put_32 (abfd, src->l_vaddr, dst->l_vaddr);
2767 bfd_put_32 (abfd, src->l_symndx, dst->l_symndx);
2768 bfd_put_16 (abfd, (bfd_vma) src->l_rtype, dst->l_rtype);
2769 bfd_put_16 (abfd, (bfd_vma) src->l_rsecnm, dst->l_rsecnm);
2770 }
2771 \f
2772
2773 bfd_boolean
2774 xcoff_reloc_type_noop (input_bfd, input_section, output_bfd, rel, sym, howto,
2775 val, addend, relocation, contents)
2776 bfd *input_bfd ATTRIBUTE_UNUSED;
2777 asection *input_section ATTRIBUTE_UNUSED;
2778 bfd *output_bfd ATTRIBUTE_UNUSED;
2779 struct internal_reloc *rel ATTRIBUTE_UNUSED;
2780 struct internal_syment *sym ATTRIBUTE_UNUSED;
2781 struct reloc_howto_struct *howto ATTRIBUTE_UNUSED;
2782 bfd_vma val ATTRIBUTE_UNUSED;
2783 bfd_vma addend ATTRIBUTE_UNUSED;
2784 bfd_vma *relocation ATTRIBUTE_UNUSED;
2785 bfd_byte *contents ATTRIBUTE_UNUSED;
2786 {
2787 return TRUE;
2788 }
2789
2790 bfd_boolean
2791 xcoff_reloc_type_fail (input_bfd, input_section, output_bfd, rel, sym, howto,
2792 val, addend, relocation, contents)
2793 bfd *input_bfd;
2794 asection *input_section ATTRIBUTE_UNUSED;
2795 bfd *output_bfd ATTRIBUTE_UNUSED;
2796 struct internal_reloc *rel;
2797 struct internal_syment *sym ATTRIBUTE_UNUSED;
2798 struct reloc_howto_struct *howto ATTRIBUTE_UNUSED;
2799 bfd_vma val ATTRIBUTE_UNUSED;
2800 bfd_vma addend ATTRIBUTE_UNUSED;
2801 bfd_vma *relocation ATTRIBUTE_UNUSED;
2802 bfd_byte *contents ATTRIBUTE_UNUSED;
2803 {
2804 (*_bfd_error_handler)
2805 (_("%s: unsupported relocation type 0x%02x"),
2806 bfd_get_filename (input_bfd), (unsigned int) rel->r_type);
2807 bfd_set_error (bfd_error_bad_value);
2808 return FALSE;
2809 }
2810
2811 bfd_boolean
2812 xcoff_reloc_type_pos (input_bfd, input_section, output_bfd, rel, sym, howto,
2813 val, addend, relocation, contents)
2814 bfd *input_bfd ATTRIBUTE_UNUSED;
2815 asection *input_section ATTRIBUTE_UNUSED;
2816 bfd *output_bfd ATTRIBUTE_UNUSED;
2817 struct internal_reloc *rel ATTRIBUTE_UNUSED;
2818 struct internal_syment *sym ATTRIBUTE_UNUSED;
2819 struct reloc_howto_struct *howto ATTRIBUTE_UNUSED;
2820 bfd_vma val;
2821 bfd_vma addend;
2822 bfd_vma *relocation;
2823 bfd_byte *contents ATTRIBUTE_UNUSED;
2824 {
2825 *relocation = val + addend;
2826 return TRUE;
2827 }
2828
2829 bfd_boolean
2830 xcoff_reloc_type_neg (input_bfd, input_section, output_bfd, rel, sym, howto,
2831 val, addend, relocation, contents)
2832 bfd *input_bfd ATTRIBUTE_UNUSED;
2833 asection *input_section ATTRIBUTE_UNUSED;
2834 bfd *output_bfd ATTRIBUTE_UNUSED;
2835 struct internal_reloc *rel ATTRIBUTE_UNUSED;
2836 struct internal_syment *sym ATTRIBUTE_UNUSED;
2837 struct reloc_howto_struct *howto ATTRIBUTE_UNUSED;
2838 bfd_vma val;
2839 bfd_vma addend;
2840 bfd_vma *relocation;
2841 bfd_byte *contents ATTRIBUTE_UNUSED;
2842 {
2843 *relocation = addend - val;
2844 return TRUE;
2845 }
2846
2847 bfd_boolean
2848 xcoff_reloc_type_rel (input_bfd, input_section, output_bfd, rel, sym, howto,
2849 val, addend, relocation, contents)
2850 bfd *input_bfd ATTRIBUTE_UNUSED;
2851 asection *input_section;
2852 bfd *output_bfd ATTRIBUTE_UNUSED;
2853 struct internal_reloc *rel ATTRIBUTE_UNUSED;
2854 struct internal_syment *sym ATTRIBUTE_UNUSED;
2855 struct reloc_howto_struct *howto;
2856 bfd_vma val;
2857 bfd_vma addend;
2858 bfd_vma *relocation;
2859 bfd_byte *contents ATTRIBUTE_UNUSED;
2860 {
2861 howto->pc_relative = TRUE;
2862
2863 /* A PC relative reloc includes the section address. */
2864 addend += input_section->vma;
2865
2866 *relocation = val + addend;
2867 *relocation -= (input_section->output_section->vma
2868 + input_section->output_offset);
2869 return TRUE;
2870 }
2871
2872 bfd_boolean
2873 xcoff_reloc_type_toc (input_bfd, input_section, output_bfd, rel, sym, howto,
2874 val, addend, relocation, contents)
2875 bfd *input_bfd;
2876 asection *input_section ATTRIBUTE_UNUSED;
2877 bfd *output_bfd;
2878 struct internal_reloc *rel;
2879 struct internal_syment *sym;
2880 struct reloc_howto_struct *howto ATTRIBUTE_UNUSED;
2881 bfd_vma val;
2882 bfd_vma addend ATTRIBUTE_UNUSED;
2883 bfd_vma *relocation;
2884 bfd_byte *contents ATTRIBUTE_UNUSED;
2885 {
2886 struct xcoff_link_hash_entry *h;
2887
2888 if (0 > rel->r_symndx)
2889 return FALSE;
2890
2891 h = obj_xcoff_sym_hashes (input_bfd)[rel->r_symndx];
2892
2893 if (h != NULL && h->smclas != XMC_TD)
2894 {
2895 if (h->toc_section == NULL)
2896 {
2897 (*_bfd_error_handler)
2898 (_("%s: TOC reloc at 0x%x to symbol `%s' with no TOC entry"),
2899 bfd_get_filename (input_bfd), rel->r_vaddr,
2900 h->root.root.string);
2901 bfd_set_error (bfd_error_bad_value);
2902 return FALSE;
2903 }
2904
2905 BFD_ASSERT ((h->flags & XCOFF_SET_TOC) == 0);
2906 val = (h->toc_section->output_section->vma
2907 + h->toc_section->output_offset);
2908 }
2909
2910 *relocation = ((val - xcoff_data (output_bfd)->toc)
2911 - (sym->n_value - xcoff_data (input_bfd)->toc));
2912 return TRUE;
2913 }
2914
2915 bfd_boolean
2916 xcoff_reloc_type_ba (input_bfd, input_section, output_bfd, rel, sym, howto,
2917 val, addend, relocation, contents)
2918 bfd *input_bfd ATTRIBUTE_UNUSED;
2919 asection *input_section ATTRIBUTE_UNUSED;
2920 bfd *output_bfd ATTRIBUTE_UNUSED;
2921 struct internal_reloc *rel ATTRIBUTE_UNUSED;
2922 struct internal_syment *sym ATTRIBUTE_UNUSED;
2923 struct reloc_howto_struct *howto;
2924 bfd_vma val;
2925 bfd_vma addend;
2926 bfd_vma *relocation;
2927 bfd_byte *contents ATTRIBUTE_UNUSED;
2928 {
2929 howto->src_mask &= ~3;
2930 howto->dst_mask = howto->src_mask;
2931
2932 *relocation = val + addend;
2933
2934 return TRUE;
2935 }
2936
2937 static bfd_boolean
2938 xcoff_reloc_type_br (input_bfd, input_section, output_bfd, rel, sym, howto,
2939 val, addend, relocation, contents)
2940 bfd *input_bfd;
2941 asection *input_section;
2942 bfd *output_bfd ATTRIBUTE_UNUSED;
2943 struct internal_reloc *rel;
2944 struct internal_syment *sym ATTRIBUTE_UNUSED;
2945 struct reloc_howto_struct *howto;
2946 bfd_vma val;
2947 bfd_vma addend;
2948 bfd_vma *relocation;
2949 bfd_byte *contents;
2950 {
2951 struct xcoff_link_hash_entry *h;
2952 bfd_vma section_offset;
2953
2954 if (0 > rel->r_symndx)
2955 return FALSE;
2956
2957 h = obj_xcoff_sym_hashes (input_bfd)[rel->r_symndx];
2958 section_offset = rel->r_vaddr - input_section->vma;
2959
2960 /* If we see an R_BR or R_RBR reloc which is jumping to global
2961 linkage code, and it is followed by an appropriate cror nop
2962 instruction, we replace the cror with lwz r2,20(r1). This
2963 restores the TOC after the glink code. Contrariwise, if the
2964 call is followed by a lwz r2,20(r1), but the call is not
2965 going to global linkage code, we can replace the load with a
2966 cror. */
2967 if (NULL != h
2968 && (bfd_link_hash_defined == h->root.type
2969 || bfd_link_hash_defweak == h->root.type)
2970 && section_offset + 8 <= input_section->size)
2971 {
2972 bfd_byte *pnext;
2973 unsigned long next;
2974
2975 pnext = contents + section_offset + 4;
2976 next = bfd_get_32 (input_bfd, pnext);
2977
2978 /* The _ptrgl function is magic. It is used by the AIX
2979 compiler to call a function through a pointer. */
2980 if (h->smclas == XMC_GL || strcmp (h->root.root.string, "._ptrgl") == 0)
2981 {
2982 if (next == 0x4def7b82 /* cror 15,15,15 */
2983 || next == 0x4ffffb82 /* cror 31,31,31 */
2984 || next == 0x60000000) /* ori r0,r0,0 */
2985 bfd_put_32 (input_bfd, 0x80410014, pnext); /* lwz r2,20(r1) */
2986
2987 }
2988 else
2989 {
2990 if (next == 0x80410014) /* lwz r2,20(r1) */
2991 bfd_put_32 (input_bfd, 0x60000000, pnext); /* ori r0,r0,0 */
2992 }
2993 }
2994 else if (NULL != h && bfd_link_hash_undefined == h->root.type)
2995 {
2996 /* Normally, this relocation is against a defined symbol. In the
2997 case where this is a partial link and the output section offset
2998 is greater than 2^25, the linker will return an invalid error
2999 message that the relocation has been truncated. Yes it has been
3000 truncated but no it not important. For this case, disable the
3001 overflow checking. */
3002
3003 howto->complain_on_overflow = complain_overflow_dont;
3004 }
3005
3006 /* The original PC-relative relocation is biased by -r_vaddr, so adding
3007 the value below will give the absolute target address. */
3008 *relocation = val + addend + rel->r_vaddr;
3009
3010 howto->src_mask &= ~3;
3011 howto->dst_mask = howto->src_mask;
3012
3013 if (h != NULL
3014 && (h->root.type == bfd_link_hash_defined
3015 || h->root.type == bfd_link_hash_defweak)
3016 && bfd_is_abs_section (h->root.u.def.section)
3017 && section_offset + 4 <= input_section->size)
3018 {
3019 bfd_byte *ptr;
3020 bfd_vma insn;
3021
3022 /* Turn the relative branch into an absolute one by setting the
3023 AA bit. */
3024 ptr = contents + section_offset;
3025 insn = bfd_get_32 (input_bfd, ptr);
3026 insn |= 2;
3027 bfd_put_32 (input_bfd, insn, ptr);
3028
3029 /* Make the howto absolute too. */
3030 howto->pc_relative = FALSE;
3031 howto->complain_on_overflow = complain_overflow_bitfield;
3032 }
3033 else
3034 {
3035 /* Use a PC-relative howto and subtract the instruction's address
3036 from the target address we calculated above. */
3037 howto->pc_relative = TRUE;
3038 *relocation -= (input_section->output_section->vma
3039 + input_section->output_offset
3040 + section_offset);
3041 }
3042 return TRUE;
3043 }
3044
3045 bfd_boolean
3046 xcoff_reloc_type_crel (input_bfd, input_section, output_bfd, rel, sym, howto,
3047 val, addend, relocation, contents)
3048 bfd *input_bfd ATTRIBUTE_UNUSED;
3049 asection *input_section;
3050 bfd *output_bfd ATTRIBUTE_UNUSED;
3051 struct internal_reloc *rel ATTRIBUTE_UNUSED;
3052 struct internal_syment *sym ATTRIBUTE_UNUSED;
3053 struct reloc_howto_struct *howto;
3054 bfd_vma val ATTRIBUTE_UNUSED;
3055 bfd_vma addend;
3056 bfd_vma *relocation;
3057 bfd_byte *contents ATTRIBUTE_UNUSED;
3058 {
3059 howto->pc_relative = TRUE;
3060 howto->src_mask &= ~3;
3061 howto->dst_mask = howto->src_mask;
3062
3063 /* A PC relative reloc includes the section address. */
3064 addend += input_section->vma;
3065
3066 *relocation = val + addend;
3067 *relocation -= (input_section->output_section->vma
3068 + input_section->output_offset);
3069 return TRUE;
3070 }
3071
3072 static bfd_boolean
3073 xcoff_complain_overflow_dont_func (input_bfd, val, relocation, howto)
3074 bfd *input_bfd ATTRIBUTE_UNUSED;
3075 bfd_vma val ATTRIBUTE_UNUSED;
3076 bfd_vma relocation ATTRIBUTE_UNUSED;
3077 struct reloc_howto_struct *howto ATTRIBUTE_UNUSED;
3078 {
3079 return FALSE;
3080 }
3081
3082 static bfd_boolean
3083 xcoff_complain_overflow_bitfield_func (input_bfd, val, relocation, howto)
3084 bfd *input_bfd;
3085 bfd_vma val;
3086 bfd_vma relocation;
3087 struct reloc_howto_struct *howto;
3088 {
3089 bfd_vma addrmask, fieldmask, signmask, ss;
3090 bfd_vma a, b, sum;
3091
3092 /* Get the values to be added together. For signed and unsigned
3093 relocations, we assume that all values should be truncated to
3094 the size of an address. For bitfields, all the bits matter.
3095 See also bfd_check_overflow. */
3096 fieldmask = N_ONES (howto->bitsize);
3097 addrmask = N_ONES (bfd_arch_bits_per_address (input_bfd)) | fieldmask;
3098 a = relocation;
3099 b = val & howto->src_mask;
3100
3101 /* Much like unsigned, except no trimming with addrmask. In
3102 addition, the sum overflows if there is a carry out of
3103 the bfd_vma, i.e., the sum is less than either input
3104 operand. */
3105 a >>= howto->rightshift;
3106 b >>= howto->bitpos;
3107
3108 /* Bitfields are sometimes used for signed numbers; for
3109 example, a 13-bit field sometimes represents values in
3110 0..8191 and sometimes represents values in -4096..4095.
3111 If the field is signed and a is -4095 (0x1001) and b is
3112 -1 (0x1fff), the sum is -4096 (0x1000), but (0x1001 +
3113 0x1fff is 0x3000). It's not clear how to handle this
3114 everywhere, since there is not way to know how many bits
3115 are significant in the relocation, but the original code
3116 assumed that it was fully sign extended, and we will keep
3117 that assumption. */
3118 signmask = (fieldmask >> 1) + 1;
3119
3120 if ((a & ~ fieldmask) != 0)
3121 {
3122 /* Some bits out of the field are set. This might not
3123 be a problem: if this is a signed bitfield, it is OK
3124 iff all the high bits are set, including the sign
3125 bit. We'll try setting all but the most significant
3126 bit in the original relocation value: if this is all
3127 ones, we are OK, assuming a signed bitfield. */
3128 ss = (signmask << howto->rightshift) - 1;
3129 if ((ss | relocation) != ~ (bfd_vma) 0)
3130 return TRUE;
3131 a &= fieldmask;
3132 }
3133
3134 /* We just assume (b & ~ fieldmask) == 0. */
3135
3136 /* We explicitly permit wrap around if this relocation
3137 covers the high bit of an address. The Linux kernel
3138 relies on it, and it is the only way to write assembler
3139 code which can run when loaded at a location 0x80000000
3140 away from the location at which it is linked. */
3141 if (howto->bitsize + howto->rightshift
3142 == bfd_arch_bits_per_address (input_bfd))
3143 return FALSE;
3144
3145 sum = a + b;
3146 if (sum < a || (sum & ~ fieldmask) != 0)
3147 {
3148 /* There was a carry out, or the field overflow. Test
3149 for signed operands again. Here is the overflow test
3150 is as for complain_overflow_signed. */
3151 if (((~ (a ^ b)) & (a ^ sum)) & signmask)
3152 return TRUE;
3153 }
3154
3155 return FALSE;
3156 }
3157
3158 static bfd_boolean
3159 xcoff_complain_overflow_signed_func (input_bfd, val, relocation, howto)
3160 bfd *input_bfd;
3161 bfd_vma val;
3162 bfd_vma relocation;
3163 struct reloc_howto_struct *howto;
3164 {
3165 bfd_vma addrmask, fieldmask, signmask, ss;
3166 bfd_vma a, b, sum;
3167
3168 /* Get the values to be added together. For signed and unsigned
3169 relocations, we assume that all values should be truncated to
3170 the size of an address. For bitfields, all the bits matter.
3171 See also bfd_check_overflow. */
3172 fieldmask = N_ONES (howto->bitsize);
3173 addrmask = N_ONES (bfd_arch_bits_per_address (input_bfd)) | fieldmask;
3174 a = relocation;
3175 b = val & howto->src_mask;
3176
3177 a = (a & addrmask) >> howto->rightshift;
3178
3179 /* If any sign bits are set, all sign bits must be set.
3180 That is, A must be a valid negative address after
3181 shifting. */
3182 signmask = ~ (fieldmask >> 1);
3183 ss = a & signmask;
3184 if (ss != 0 && ss != ((addrmask >> howto->rightshift) & signmask))
3185 return TRUE;
3186
3187 /* We only need this next bit of code if the sign bit of B
3188 is below the sign bit of A. This would only happen if
3189 SRC_MASK had fewer bits than BITSIZE. Note that if
3190 SRC_MASK has more bits than BITSIZE, we can get into
3191 trouble; we would need to verify that B is in range, as
3192 we do for A above. */
3193 signmask = ((~ howto->src_mask) >> 1) & howto->src_mask;
3194 if ((b & signmask) != 0)
3195 {
3196 /* Set all the bits above the sign bit. */
3197 b -= signmask <<= 1;
3198 }
3199
3200 b = (b & addrmask) >> howto->bitpos;
3201
3202 /* Now we can do the addition. */
3203 sum = a + b;
3204
3205 /* See if the result has the correct sign. Bits above the
3206 sign bit are junk now; ignore them. If the sum is
3207 positive, make sure we did not have all negative inputs;
3208 if the sum is negative, make sure we did not have all
3209 positive inputs. The test below looks only at the sign
3210 bits, and it really just
3211 SIGN (A) == SIGN (B) && SIGN (A) != SIGN (SUM)
3212 */
3213 signmask = (fieldmask >> 1) + 1;
3214 if (((~ (a ^ b)) & (a ^ sum)) & signmask)
3215 return TRUE;
3216
3217 return FALSE;
3218 }
3219
3220 static bfd_boolean
3221 xcoff_complain_overflow_unsigned_func (input_bfd, val, relocation, howto)
3222 bfd *input_bfd;
3223 bfd_vma val;
3224 bfd_vma relocation;
3225 struct reloc_howto_struct *howto;
3226 {
3227 bfd_vma addrmask, fieldmask;
3228 bfd_vma a, b, sum;
3229
3230 /* Get the values to be added together. For signed and unsigned
3231 relocations, we assume that all values should be truncated to
3232 the size of an address. For bitfields, all the bits matter.
3233 See also bfd_check_overflow. */
3234 fieldmask = N_ONES (howto->bitsize);
3235 addrmask = N_ONES (bfd_arch_bits_per_address (input_bfd)) | fieldmask;
3236 a = relocation;
3237 b = val & howto->src_mask;
3238
3239 /* Checking for an unsigned overflow is relatively easy:
3240 trim the addresses and add, and trim the result as well.
3241 Overflow is normally indicated when the result does not
3242 fit in the field. However, we also need to consider the
3243 case when, e.g., fieldmask is 0x7fffffff or smaller, an
3244 input is 0x80000000, and bfd_vma is only 32 bits; then we
3245 will get sum == 0, but there is an overflow, since the
3246 inputs did not fit in the field. Instead of doing a
3247 separate test, we can check for this by or-ing in the
3248 operands when testing for the sum overflowing its final
3249 field. */
3250 a = (a & addrmask) >> howto->rightshift;
3251 b = (b & addrmask) >> howto->bitpos;
3252 sum = (a + b) & addrmask;
3253 if ((a | b | sum) & ~ fieldmask)
3254 return TRUE;
3255
3256 return FALSE;
3257 }
3258
3259 /* This is the relocation function for the RS/6000/POWER/PowerPC.
3260 This is currently the only processor which uses XCOFF; I hope that
3261 will never change.
3262
3263 I took the relocation type definitions from two documents:
3264 the PowerPC AIX Version 4 Application Binary Interface, First
3265 Edition (April 1992), and the PowerOpen ABI, Big-Endian
3266 32-Bit Hardware Implementation (June 30, 1994). Differences
3267 between the documents are noted below.
3268
3269 Unsupported r_type's
3270
3271 R_RTB:
3272 R_RRTBI:
3273 R_RRTBA:
3274
3275 These relocs are defined by the PowerPC ABI to be
3276 relative branches which use half of the difference
3277 between the symbol and the program counter. I can't
3278 quite figure out when this is useful. These relocs are
3279 not defined by the PowerOpen ABI.
3280
3281 Supported r_type's
3282
3283 R_POS:
3284 Simple positive relocation.
3285
3286 R_NEG:
3287 Simple negative relocation.
3288
3289 R_REL:
3290 Simple PC relative relocation.
3291
3292 R_TOC:
3293 TOC relative relocation. The value in the instruction in
3294 the input file is the offset from the input file TOC to
3295 the desired location. We want the offset from the final
3296 TOC to the desired location. We have:
3297 isym = iTOC + in
3298 iinsn = in + o
3299 osym = oTOC + on
3300 oinsn = on + o
3301 so we must change insn by on - in.
3302
3303 R_GL:
3304 GL linkage relocation. The value of this relocation
3305 is the address of the entry in the TOC section.
3306
3307 R_TCL:
3308 Local object TOC address. I can't figure out the
3309 difference between this and case R_GL.
3310
3311 R_TRL:
3312 TOC relative relocation. A TOC relative load instruction
3313 which may be changed to a load address instruction.
3314 FIXME: We don't currently implement this optimization.
3315
3316 R_TRLA:
3317 TOC relative relocation. This is a TOC relative load
3318 address instruction which may be changed to a load
3319 instruction. FIXME: I don't know if this is the correct
3320 implementation.
3321
3322 R_BA:
3323 Absolute branch. We don't want to mess with the lower
3324 two bits of the instruction.
3325
3326 R_CAI:
3327 The PowerPC ABI defines this as an absolute call which
3328 may be modified to become a relative call. The PowerOpen
3329 ABI does not define this relocation type.
3330
3331 R_RBA:
3332 Absolute branch which may be modified to become a
3333 relative branch.
3334
3335 R_RBAC:
3336 The PowerPC ABI defines this as an absolute branch to a
3337 fixed address which may be modified to an absolute branch
3338 to a symbol. The PowerOpen ABI does not define this
3339 relocation type.
3340
3341 R_RBRC:
3342 The PowerPC ABI defines this as an absolute branch to a
3343 fixed address which may be modified to a relative branch.
3344 The PowerOpen ABI does not define this relocation type.
3345
3346 R_BR:
3347 Relative branch. We don't want to mess with the lower
3348 two bits of the instruction.
3349
3350 R_CREL:
3351 The PowerPC ABI defines this as a relative call which may
3352 be modified to become an absolute call. The PowerOpen
3353 ABI does not define this relocation type.
3354
3355 R_RBR:
3356 A relative branch which may be modified to become an
3357 absolute branch.
3358
3359 R_RL:
3360 The PowerPC AIX ABI describes this as a load which may be
3361 changed to a load address. The PowerOpen ABI says this
3362 is the same as case R_POS.
3363
3364 R_RLA:
3365 The PowerPC AIX ABI describes this as a load address
3366 which may be changed to a load. The PowerOpen ABI says
3367 this is the same as R_POS.
3368 */
3369
3370 bfd_boolean
3371 xcoff_ppc_relocate_section (output_bfd, info, input_bfd,
3372 input_section, contents, relocs, syms,
3373 sections)
3374 bfd *output_bfd;
3375 struct bfd_link_info *info;
3376 bfd *input_bfd;
3377 asection *input_section;
3378 bfd_byte *contents;
3379 struct internal_reloc *relocs;
3380 struct internal_syment *syms;
3381 asection **sections;
3382 {
3383 struct internal_reloc *rel;
3384 struct internal_reloc *relend;
3385
3386 rel = relocs;
3387 relend = rel + input_section->reloc_count;
3388 for (; rel < relend; rel++)
3389 {
3390 long symndx;
3391 struct xcoff_link_hash_entry *h;
3392 struct internal_syment *sym;
3393 bfd_vma addend;
3394 bfd_vma val;
3395 struct reloc_howto_struct howto;
3396 bfd_vma relocation;
3397 bfd_vma value_to_relocate;
3398 bfd_vma address;
3399 bfd_byte *location;
3400
3401 /* Relocation type R_REF is a special relocation type which is
3402 merely used to prevent garbage collection from occurring for
3403 the csect including the symbol which it references. */
3404 if (rel->r_type == R_REF)
3405 continue;
3406
3407 /* howto */
3408 howto.type = rel->r_type;
3409 howto.rightshift = 0;
3410 howto.bitsize = (rel->r_size & 0x1f) + 1;
3411 howto.size = howto.bitsize > 16 ? 2 : 1;
3412 howto.pc_relative = FALSE;
3413 howto.bitpos = 0;
3414 howto.complain_on_overflow = (rel->r_size & 0x80
3415 ? complain_overflow_signed
3416 : complain_overflow_bitfield);
3417 howto.special_function = NULL;
3418 howto.name = "internal";
3419 howto.partial_inplace = TRUE;
3420 howto.src_mask = howto.dst_mask = N_ONES (howto.bitsize);
3421 howto.pcrel_offset = FALSE;
3422
3423 /* symbol */
3424 val = 0;
3425 addend = 0;
3426 h = NULL;
3427 sym = NULL;
3428 symndx = rel->r_symndx;
3429
3430 if (-1 != symndx)
3431 {
3432 asection *sec;
3433
3434 h = obj_xcoff_sym_hashes (input_bfd)[symndx];
3435 sym = syms + symndx;
3436 addend = - sym->n_value;
3437
3438 if (NULL == h)
3439 {
3440 sec = sections[symndx];
3441 /* Hack to make sure we use the right TOC anchor value
3442 if this reloc is against the TOC anchor. */
3443 if (sec->name[3] == '0'
3444 && strcmp (sec->name, ".tc0") == 0)
3445 val = xcoff_data (output_bfd)->toc;
3446 else
3447 val = (sec->output_section->vma
3448 + sec->output_offset
3449 + sym->n_value
3450 - sec->vma);
3451 }
3452 else
3453 {
3454 if (info->unresolved_syms_in_objects != RM_IGNORE
3455 && (h->flags & XCOFF_WAS_UNDEFINED) != 0)
3456 {
3457 if (! ((*info->callbacks->undefined_symbol)
3458 (info, h->root.root.string,
3459 input_bfd, input_section,
3460 rel->r_vaddr - input_section->vma,
3461 (info->unresolved_syms_in_objects
3462 == RM_GENERATE_ERROR))))
3463 return FALSE;
3464 }
3465 if (h->root.type == bfd_link_hash_defined
3466 || h->root.type == bfd_link_hash_defweak)
3467 {
3468 sec = h->root.u.def.section;
3469 val = (h->root.u.def.value
3470 + sec->output_section->vma
3471 + sec->output_offset);
3472 }
3473 else if (h->root.type == bfd_link_hash_common)
3474 {
3475 sec = h->root.u.c.p->section;
3476 val = (sec->output_section->vma
3477 + sec->output_offset);
3478
3479 }
3480 else
3481 {
3482 BFD_ASSERT (info->relocatable
3483 || (h->flags & XCOFF_DEF_DYNAMIC) != 0
3484 || (h->flags & XCOFF_IMPORT) != 0);
3485 }
3486 }
3487 }
3488
3489 if (rel->r_type >= XCOFF_MAX_CALCULATE_RELOCATION
3490 || !((*xcoff_calculate_relocation[rel->r_type])
3491 (input_bfd, input_section, output_bfd, rel, sym, &howto, val,
3492 addend, &relocation, contents)))
3493 return FALSE;
3494
3495 /* address */
3496 address = rel->r_vaddr - input_section->vma;
3497 location = contents + address;
3498
3499 if (address > input_section->size)
3500 abort ();
3501
3502 /* Get the value we are going to relocate. */
3503 if (1 == howto.size)
3504 value_to_relocate = bfd_get_16 (input_bfd, location);
3505 else
3506 value_to_relocate = bfd_get_32 (input_bfd, location);
3507
3508 /* overflow.
3509
3510 FIXME: We may drop bits during the addition
3511 which we don't check for. We must either check at every single
3512 operation, which would be tedious, or we must do the computations
3513 in a type larger than bfd_vma, which would be inefficient. */
3514
3515 if ((unsigned int) howto.complain_on_overflow
3516 >= XCOFF_MAX_COMPLAIN_OVERFLOW)
3517 abort ();
3518
3519 if (((*xcoff_complain_overflow[howto.complain_on_overflow])
3520 (input_bfd, value_to_relocate, relocation, &howto)))
3521 {
3522 const char *name;
3523 char buf[SYMNMLEN + 1];
3524 char reloc_type_name[10];
3525
3526 if (symndx == -1)
3527 {
3528 name = "*ABS*";
3529 }
3530 else if (h != NULL)
3531 {
3532 name = NULL;
3533 }
3534 else
3535 {
3536 name = _bfd_coff_internal_syment_name (input_bfd, sym, buf);
3537 if (name == NULL)
3538 name = "UNKNOWN";
3539 }
3540 sprintf (reloc_type_name, "0x%02x", rel->r_type);
3541
3542 if (! ((*info->callbacks->reloc_overflow)
3543 (info, (h ? &h->root : NULL), name, reloc_type_name,
3544 (bfd_vma) 0, input_bfd, input_section,
3545 rel->r_vaddr - input_section->vma)))
3546 return FALSE;
3547 }
3548
3549 /* Add RELOCATION to the right bits of VALUE_TO_RELOCATE. */
3550 value_to_relocate = ((value_to_relocate & ~howto.dst_mask)
3551 | (((value_to_relocate & howto.src_mask)
3552 + relocation) & howto.dst_mask));
3553
3554 /* Put the value back in the object file. */
3555 if (1 == howto.size)
3556 bfd_put_16 (input_bfd, value_to_relocate, location);
3557 else
3558 bfd_put_32 (input_bfd, value_to_relocate, location);
3559 }
3560
3561 return TRUE;
3562 }
3563
3564 static bfd_boolean
3565 _bfd_xcoff_put_ldsymbol_name (abfd, ldinfo, ldsym, name)
3566 bfd *abfd ATTRIBUTE_UNUSED;
3567 struct xcoff_loader_info *ldinfo;
3568 struct internal_ldsym *ldsym;
3569 const char *name;
3570 {
3571 size_t len;
3572 len = strlen (name);
3573
3574 if (len <= SYMNMLEN)
3575 strncpy (ldsym->_l._l_name, name, SYMNMLEN);
3576 else
3577 {
3578 if (ldinfo->string_size + len + 3 > ldinfo->string_alc)
3579 {
3580 bfd_size_type newalc;
3581 char *newstrings;
3582
3583 newalc = ldinfo->string_alc * 2;
3584 if (newalc == 0)
3585 newalc = 32;
3586 while (ldinfo->string_size + len + 3 > newalc)
3587 newalc *= 2;
3588
3589 newstrings = bfd_realloc (ldinfo->strings, newalc);
3590 if (newstrings == NULL)
3591 {
3592 ldinfo->failed = TRUE;
3593 return FALSE;
3594 }
3595 ldinfo->string_alc = newalc;
3596 ldinfo->strings = newstrings;
3597 }
3598
3599 bfd_put_16 (ldinfo->output_bfd, (bfd_vma) (len + 1),
3600 ldinfo->strings + ldinfo->string_size);
3601 strcpy (ldinfo->strings + ldinfo->string_size + 2, name);
3602 ldsym->_l._l_l._l_zeroes = 0;
3603 ldsym->_l._l_l._l_offset = ldinfo->string_size + 2;
3604 ldinfo->string_size += len + 3;
3605 }
3606
3607 return TRUE;
3608 }
3609
3610 static bfd_boolean
3611 _bfd_xcoff_put_symbol_name (bfd *abfd, struct bfd_strtab_hash *strtab,
3612 struct internal_syment *sym,
3613 const char *name)
3614 {
3615 if (strlen (name) <= SYMNMLEN)
3616 {
3617 strncpy (sym->_n._n_name, name, SYMNMLEN);
3618 }
3619 else
3620 {
3621 bfd_boolean hash;
3622 bfd_size_type indx;
3623
3624 hash = TRUE;
3625 if ((abfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
3626 hash = FALSE;
3627 indx = _bfd_stringtab_add (strtab, name, hash, FALSE);
3628 if (indx == (bfd_size_type) -1)
3629 return FALSE;
3630 sym->_n._n_n._n_zeroes = 0;
3631 sym->_n._n_n._n_offset = STRING_SIZE_SIZE + indx;
3632 }
3633 return TRUE;
3634 }
3635
3636 static asection *
3637 xcoff_create_csect_from_smclas (abfd, aux, symbol_name)
3638 bfd *abfd;
3639 union internal_auxent *aux;
3640 const char *symbol_name;
3641 {
3642 asection *return_value = NULL;
3643
3644 /* .sv64 = x_smclas == 17
3645 This is an invalid csect for 32 bit apps. */
3646 static const char *names[19] =
3647 {
3648 ".pr", ".ro", ".db", ".tc", ".ua", ".rw", ".gl", ".xo",
3649 ".sv", ".bs", ".ds", ".uc", ".ti", ".tb", NULL, ".tc0",
3650 ".td", NULL, ".sv3264"
3651 };
3652
3653 if ((19 >= aux->x_csect.x_smclas)
3654 && (NULL != names[aux->x_csect.x_smclas]))
3655 {
3656 return_value = bfd_make_section_anyway
3657 (abfd, names[aux->x_csect.x_smclas]);
3658 }
3659 else
3660 {
3661 (*_bfd_error_handler)
3662 (_("%B: symbol `%s' has unrecognized smclas %d"),
3663 abfd, symbol_name, aux->x_csect.x_smclas);
3664 bfd_set_error (bfd_error_bad_value);
3665 }
3666
3667 return return_value;
3668 }
3669
3670 static bfd_boolean
3671 xcoff_is_lineno_count_overflow (abfd, value)
3672 bfd *abfd ATTRIBUTE_UNUSED;
3673 bfd_vma value;
3674 {
3675 if (0xffff <= value)
3676 return TRUE;
3677
3678 return FALSE;
3679 }
3680
3681 static bfd_boolean
3682 xcoff_is_reloc_count_overflow (abfd, value)
3683 bfd *abfd ATTRIBUTE_UNUSED;
3684 bfd_vma value;
3685 {
3686 if (0xffff <= value)
3687 return TRUE;
3688
3689 return FALSE;
3690 }
3691
3692 static bfd_vma
3693 xcoff_loader_symbol_offset (abfd, ldhdr)
3694 bfd *abfd;
3695 struct internal_ldhdr *ldhdr ATTRIBUTE_UNUSED;
3696 {
3697 return bfd_xcoff_ldhdrsz (abfd);
3698 }
3699
3700 static bfd_vma
3701 xcoff_loader_reloc_offset (abfd, ldhdr)
3702 bfd *abfd;
3703 struct internal_ldhdr *ldhdr;
3704 {
3705 return bfd_xcoff_ldhdrsz (abfd) + ldhdr->l_nsyms * bfd_xcoff_ldsymsz (abfd);
3706 }
3707
3708 static bfd_boolean
3709 xcoff_generate_rtinit (abfd, init, fini, rtld)
3710 bfd *abfd;
3711 const char *init;
3712 const char *fini;
3713 bfd_boolean rtld;
3714 {
3715 bfd_byte filehdr_ext[FILHSZ];
3716 bfd_byte scnhdr_ext[SCNHSZ];
3717 bfd_byte syment_ext[SYMESZ * 10];
3718 bfd_byte reloc_ext[RELSZ * 3];
3719 bfd_byte *data_buffer;
3720 bfd_size_type data_buffer_size;
3721 bfd_byte *string_table = NULL, *st_tmp = NULL;
3722 bfd_size_type string_table_size;
3723 bfd_vma val;
3724 size_t initsz, finisz;
3725 struct internal_filehdr filehdr;
3726 struct internal_scnhdr scnhdr;
3727 struct internal_syment syment;
3728 union internal_auxent auxent;
3729 struct internal_reloc reloc;
3730
3731 char *data_name = ".data";
3732 char *rtinit_name = "__rtinit";
3733 char *rtld_name = "__rtld";
3734
3735 if (! bfd_xcoff_rtinit_size (abfd))
3736 return FALSE;
3737
3738 initsz = (init == NULL ? 0 : 1 + strlen (init));
3739 finisz = (fini == NULL ? 0 : 1 + strlen (fini));
3740
3741 /* file header */
3742 memset (filehdr_ext, 0, FILHSZ);
3743 memset (&filehdr, 0, sizeof (struct internal_filehdr));
3744 filehdr.f_magic = bfd_xcoff_magic_number (abfd);
3745 filehdr.f_nscns = 1;
3746 filehdr.f_timdat = 0;
3747 filehdr.f_nsyms = 0; /* at least 6, no more than 10 */
3748 filehdr.f_symptr = 0; /* set below */
3749 filehdr.f_opthdr = 0;
3750 filehdr.f_flags = 0;
3751
3752 /* section header */
3753 memset (scnhdr_ext, 0, SCNHSZ);
3754 memset (&scnhdr, 0, sizeof (struct internal_scnhdr));
3755 memcpy (scnhdr.s_name, data_name, strlen (data_name));
3756 scnhdr.s_paddr = 0;
3757 scnhdr.s_vaddr = 0;
3758 scnhdr.s_size = 0; /* set below */
3759 scnhdr.s_scnptr = FILHSZ + SCNHSZ;
3760 scnhdr.s_relptr = 0; /* set below */
3761 scnhdr.s_lnnoptr = 0;
3762 scnhdr.s_nreloc = 0; /* either 1 or 2 */
3763 scnhdr.s_nlnno = 0;
3764 scnhdr.s_flags = STYP_DATA;
3765
3766 /* .data
3767 0x0000 0x00000000 : rtl
3768 0x0004 0x00000010 : offset to init, or 0
3769 0x0008 0x00000028 : offset to fini, or 0
3770 0x000C 0x0000000C : size of descriptor
3771 0x0010 0x00000000 : init, needs a reloc
3772 0x0014 0x00000040 : offset to init name
3773 0x0018 0x00000000 : flags, padded to a word
3774 0x001C 0x00000000 : empty init
3775 0x0020 0x00000000 :
3776 0x0024 0x00000000 :
3777 0x0028 0x00000000 : fini, needs a reloc
3778 0x002C 0x00000??? : offset to fini name
3779 0x0030 0x00000000 : flags, padded to a word
3780 0x0034 0x00000000 : empty fini
3781 0x0038 0x00000000 :
3782 0x003C 0x00000000 :
3783 0x0040 init name
3784 0x0040 + initsz fini name */
3785
3786 data_buffer_size = 0x0040 + initsz + finisz;
3787 data_buffer_size = (data_buffer_size + 7) &~ (bfd_size_type) 7;
3788 data_buffer = NULL;
3789 data_buffer = (bfd_byte *) bfd_zmalloc (data_buffer_size);
3790 if (data_buffer == NULL)
3791 return FALSE;
3792
3793 if (initsz)
3794 {
3795 val = 0x10;
3796 bfd_h_put_32 (abfd, val, &data_buffer[0x04]);
3797 val = 0x40;
3798 bfd_h_put_32 (abfd, val, &data_buffer[0x14]);
3799 memcpy (&data_buffer[val], init, initsz);
3800 }
3801
3802 if (finisz)
3803 {
3804 val = 0x28;
3805 bfd_h_put_32 (abfd, val, &data_buffer[0x08]);
3806 val = 0x40 + initsz;
3807 bfd_h_put_32 (abfd, val, &data_buffer[0x2C]);
3808 memcpy (&data_buffer[val], fini, finisz);
3809 }
3810
3811 val = 0x0C;
3812 bfd_h_put_32 (abfd, val, &data_buffer[0x0C]);
3813
3814 scnhdr.s_size = data_buffer_size;
3815
3816 /* string table */
3817 string_table_size = 0;
3818 if (initsz > 9)
3819 string_table_size += initsz;
3820 if (finisz > 9)
3821 string_table_size += finisz;
3822 if (string_table_size)
3823 {
3824 string_table_size += 4;
3825 string_table = (bfd_byte *) bfd_zmalloc (string_table_size);
3826 if (string_table == NULL)
3827 return FALSE;
3828
3829 val = string_table_size;
3830 bfd_h_put_32 (abfd, val, &string_table[0]);
3831 st_tmp = string_table + 4;
3832 }
3833
3834 /* symbols
3835 0. .data csect
3836 2. __rtinit
3837 4. init function
3838 6. fini function
3839 8. __rtld */
3840 memset (syment_ext, 0, 10 * SYMESZ);
3841 memset (reloc_ext, 0, 3 * RELSZ);
3842
3843 /* .data csect */
3844 memset (&syment, 0, sizeof (struct internal_syment));
3845 memset (&auxent, 0, sizeof (union internal_auxent));
3846 memcpy (syment._n._n_name, data_name, strlen (data_name));
3847 syment.n_scnum = 1;
3848 syment.n_sclass = C_HIDEXT;
3849 syment.n_numaux = 1;
3850 auxent.x_csect.x_scnlen.l = data_buffer_size;
3851 auxent.x_csect.x_smtyp = 3 << 3 | XTY_SD;
3852 auxent.x_csect.x_smclas = XMC_RW;
3853 bfd_coff_swap_sym_out (abfd, &syment,
3854 &syment_ext[filehdr.f_nsyms * SYMESZ]);
3855 bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
3856 syment.n_numaux,
3857 &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
3858 filehdr.f_nsyms += 2;
3859
3860 /* __rtinit */
3861 memset (&syment, 0, sizeof (struct internal_syment));
3862 memset (&auxent, 0, sizeof (union internal_auxent));
3863 memcpy (syment._n._n_name, rtinit_name, strlen (rtinit_name));
3864 syment.n_scnum = 1;
3865 syment.n_sclass = C_EXT;
3866 syment.n_numaux = 1;
3867 auxent.x_csect.x_smtyp = XTY_LD;
3868 auxent.x_csect.x_smclas = XMC_RW;
3869 bfd_coff_swap_sym_out (abfd, &syment,
3870 &syment_ext[filehdr.f_nsyms * SYMESZ]);
3871 bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
3872 syment.n_numaux,
3873 &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
3874 filehdr.f_nsyms += 2;
3875
3876 /* init */
3877 if (initsz)
3878 {
3879 memset (&syment, 0, sizeof (struct internal_syment));
3880 memset (&auxent, 0, sizeof (union internal_auxent));
3881
3882 if (initsz > 9)
3883 {
3884 syment._n._n_n._n_offset = st_tmp - string_table;
3885 memcpy (st_tmp, init, initsz);
3886 st_tmp += initsz;
3887 }
3888 else
3889 memcpy (syment._n._n_name, init, initsz - 1);
3890
3891 syment.n_sclass = C_EXT;
3892 syment.n_numaux = 1;
3893 bfd_coff_swap_sym_out (abfd, &syment,
3894 &syment_ext[filehdr.f_nsyms * SYMESZ]);
3895 bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
3896 syment.n_numaux,
3897 &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
3898
3899 /* reloc */
3900 memset (&reloc, 0, sizeof (struct internal_reloc));
3901 reloc.r_vaddr = 0x0010;
3902 reloc.r_symndx = filehdr.f_nsyms;
3903 reloc.r_type = R_POS;
3904 reloc.r_size = 31;
3905 bfd_coff_swap_reloc_out (abfd, &reloc, &reloc_ext[0]);
3906
3907 filehdr.f_nsyms += 2;
3908 scnhdr.s_nreloc += 1;
3909 }
3910
3911 /* fini */
3912 if (finisz)
3913 {
3914 memset (&syment, 0, sizeof (struct internal_syment));
3915 memset (&auxent, 0, sizeof (union internal_auxent));
3916
3917 if (finisz > 9)
3918 {
3919 syment._n._n_n._n_offset = st_tmp - string_table;
3920 memcpy (st_tmp, fini, finisz);
3921 st_tmp += finisz;
3922 }
3923 else
3924 memcpy (syment._n._n_name, fini, finisz - 1);
3925
3926 syment.n_sclass = C_EXT;
3927 syment.n_numaux = 1;
3928 bfd_coff_swap_sym_out (abfd, &syment,
3929 &syment_ext[filehdr.f_nsyms * SYMESZ]);
3930 bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
3931 syment.n_numaux,
3932 &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
3933
3934 /* reloc */
3935 memset (&reloc, 0, sizeof (struct internal_reloc));
3936 reloc.r_vaddr = 0x0028;
3937 reloc.r_symndx = filehdr.f_nsyms;
3938 reloc.r_type = R_POS;
3939 reloc.r_size = 31;
3940 bfd_coff_swap_reloc_out (abfd, &reloc,
3941 &reloc_ext[scnhdr.s_nreloc * RELSZ]);
3942
3943 filehdr.f_nsyms += 2;
3944 scnhdr.s_nreloc += 1;
3945 }
3946
3947 if (rtld)
3948 {
3949 memset (&syment, 0, sizeof (struct internal_syment));
3950 memset (&auxent, 0, sizeof (union internal_auxent));
3951 memcpy (syment._n._n_name, rtld_name, strlen (rtld_name));
3952 syment.n_sclass = C_EXT;
3953 syment.n_numaux = 1;
3954 bfd_coff_swap_sym_out (abfd, &syment,
3955 &syment_ext[filehdr.f_nsyms * SYMESZ]);
3956 bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
3957 syment.n_numaux,
3958 &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
3959
3960 /* reloc */
3961 memset (&reloc, 0, sizeof (struct internal_reloc));
3962 reloc.r_vaddr = 0x0000;
3963 reloc.r_symndx = filehdr.f_nsyms;
3964 reloc.r_type = R_POS;
3965 reloc.r_size = 31;
3966 bfd_coff_swap_reloc_out (abfd, &reloc,
3967 &reloc_ext[scnhdr.s_nreloc * RELSZ]);
3968
3969 filehdr.f_nsyms += 2;
3970 scnhdr.s_nreloc += 1;
3971 }
3972
3973 scnhdr.s_relptr = scnhdr.s_scnptr + data_buffer_size;
3974 filehdr.f_symptr = scnhdr.s_relptr + scnhdr.s_nreloc * RELSZ;
3975
3976 bfd_coff_swap_filehdr_out (abfd, &filehdr, filehdr_ext);
3977 bfd_bwrite (filehdr_ext, FILHSZ, abfd);
3978 bfd_coff_swap_scnhdr_out (abfd, &scnhdr, scnhdr_ext);
3979 bfd_bwrite (scnhdr_ext, SCNHSZ, abfd);
3980 bfd_bwrite (data_buffer, data_buffer_size, abfd);
3981 bfd_bwrite (reloc_ext, scnhdr.s_nreloc * RELSZ, abfd);
3982 bfd_bwrite (syment_ext, filehdr.f_nsyms * SYMESZ, abfd);
3983 bfd_bwrite (string_table, string_table_size, abfd);
3984
3985 free (data_buffer);
3986 data_buffer = NULL;
3987
3988 return TRUE;
3989 }
3990
3991
3992 static reloc_howto_type xcoff_dynamic_reloc =
3993 HOWTO (0, /* type */
3994 0, /* rightshift */
3995 2, /* size (0 = byte, 1 = short, 2 = long) */
3996 32, /* bitsize */
3997 FALSE, /* pc_relative */
3998 0, /* bitpos */
3999 complain_overflow_bitfield, /* complain_on_overflow */
4000 0, /* special_function */
4001 "R_POS", /* name */
4002 TRUE, /* partial_inplace */
4003 0xffffffff, /* src_mask */
4004 0xffffffff, /* dst_mask */
4005 FALSE); /* pcrel_offset */
4006
4007 /* glink
4008
4009 The first word of global linkage code must be modified by filling in
4010 the correct TOC offset. */
4011
4012 static unsigned long xcoff_glink_code[9] =
4013 {
4014 0x81820000, /* lwz r12,0(r2) */
4015 0x90410014, /* stw r2,20(r1) */
4016 0x800c0000, /* lwz r0,0(r12) */
4017 0x804c0004, /* lwz r2,4(r12) */
4018 0x7c0903a6, /* mtctr r0 */
4019 0x4e800420, /* bctr */
4020 0x00000000, /* start of traceback table */
4021 0x000c8000, /* traceback table */
4022 0x00000000, /* traceback table */
4023 };
4024
4025
4026 static const struct xcoff_backend_data_rec bfd_xcoff_backend_data =
4027 {
4028 { /* COFF backend, defined in libcoff.h. */
4029 _bfd_xcoff_swap_aux_in,
4030 _bfd_xcoff_swap_sym_in,
4031 coff_swap_lineno_in,
4032 _bfd_xcoff_swap_aux_out,
4033 _bfd_xcoff_swap_sym_out,
4034 coff_swap_lineno_out,
4035 xcoff_swap_reloc_out,
4036 coff_swap_filehdr_out,
4037 coff_swap_aouthdr_out,
4038 coff_swap_scnhdr_out,
4039 FILHSZ,
4040 AOUTSZ,
4041 SCNHSZ,
4042 SYMESZ,
4043 AUXESZ,
4044 RELSZ,
4045 LINESZ,
4046 FILNMLEN,
4047 TRUE, /* _bfd_coff_long_filenames */
4048 XCOFF_NO_LONG_SECTION_NAMES, /* _bfd_coff_long_section_names */
4049 3, /* _bfd_coff_default_section_alignment_power */
4050 FALSE, /* _bfd_coff_force_symnames_in_strings */
4051 2, /* _bfd_coff_debug_string_prefix_length */
4052 coff_swap_filehdr_in,
4053 coff_swap_aouthdr_in,
4054 coff_swap_scnhdr_in,
4055 xcoff_swap_reloc_in,
4056 coff_bad_format_hook,
4057 coff_set_arch_mach_hook,
4058 coff_mkobject_hook,
4059 styp_to_sec_flags,
4060 coff_set_alignment_hook,
4061 coff_slurp_symbol_table,
4062 symname_in_debug_hook,
4063 coff_pointerize_aux_hook,
4064 coff_print_aux,
4065 dummy_reloc16_extra_cases,
4066 dummy_reloc16_estimate,
4067 NULL, /* bfd_coff_sym_is_global */
4068 coff_compute_section_file_positions,
4069 NULL, /* _bfd_coff_start_final_link */
4070 xcoff_ppc_relocate_section,
4071 coff_rtype_to_howto,
4072 NULL, /* _bfd_coff_adjust_symndx */
4073 _bfd_generic_link_add_one_symbol,
4074 coff_link_output_has_begun,
4075 coff_final_link_postscript,
4076 NULL /* print_pdata. */
4077 },
4078
4079 0x01DF, /* magic number */
4080 bfd_arch_rs6000,
4081 bfd_mach_rs6k,
4082
4083 /* Function pointers to xcoff specific swap routines. */
4084 xcoff_swap_ldhdr_in,
4085 xcoff_swap_ldhdr_out,
4086 xcoff_swap_ldsym_in,
4087 xcoff_swap_ldsym_out,
4088 xcoff_swap_ldrel_in,
4089 xcoff_swap_ldrel_out,
4090
4091 /* Sizes. */
4092 LDHDRSZ,
4093 LDSYMSZ,
4094 LDRELSZ,
4095 12, /* _xcoff_function_descriptor_size */
4096 SMALL_AOUTSZ,
4097
4098 /* Versions. */
4099 1, /* _xcoff_ldhdr_version */
4100
4101 _bfd_xcoff_put_symbol_name,
4102 _bfd_xcoff_put_ldsymbol_name,
4103 &xcoff_dynamic_reloc,
4104 xcoff_create_csect_from_smclas,
4105
4106 /* Lineno and reloc count overflow. */
4107 xcoff_is_lineno_count_overflow,
4108 xcoff_is_reloc_count_overflow,
4109
4110 xcoff_loader_symbol_offset,
4111 xcoff_loader_reloc_offset,
4112
4113 /* glink. */
4114 &xcoff_glink_code[0],
4115 36, /* _xcoff_glink_size */
4116
4117 /* rtinit */
4118 64, /* _xcoff_rtinit_size */
4119 xcoff_generate_rtinit,
4120 };
4121
4122 /* The transfer vector that leads the outside world to all of the above. */
4123 const bfd_target rs6000coff_vec =
4124 {
4125 "aixcoff-rs6000",
4126 bfd_target_xcoff_flavour,
4127 BFD_ENDIAN_BIG, /* data byte order is big */
4128 BFD_ENDIAN_BIG, /* header byte order is big */
4129
4130 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | DYNAMIC
4131 | HAS_SYMS | HAS_LOCALS | WP_TEXT),
4132
4133 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA,
4134 0, /* leading char */
4135 '/', /* ar_pad_char */
4136 15, /* ar_max_namelen */
4137
4138 /* data */
4139 bfd_getb64,
4140 bfd_getb_signed_64,
4141 bfd_putb64,
4142 bfd_getb32,
4143 bfd_getb_signed_32,
4144 bfd_putb32,
4145 bfd_getb16,
4146 bfd_getb_signed_16,
4147 bfd_putb16,
4148
4149 /* hdrs */
4150 bfd_getb64,
4151 bfd_getb_signed_64,
4152 bfd_putb64,
4153 bfd_getb32,
4154 bfd_getb_signed_32,
4155 bfd_putb32,
4156 bfd_getb16,
4157 bfd_getb_signed_16,
4158 bfd_putb16,
4159
4160 { /* bfd_check_format */
4161 _bfd_dummy_target,
4162 coff_object_p,
4163 _bfd_xcoff_archive_p,
4164 CORE_FILE_P
4165 },
4166
4167 { /* bfd_set_format */
4168 bfd_false,
4169 coff_mkobject,
4170 _bfd_generic_mkarchive,
4171 bfd_false
4172 },
4173
4174 {/* bfd_write_contents */
4175 bfd_false,
4176 coff_write_object_contents,
4177 _bfd_xcoff_write_archive_contents,
4178 bfd_false
4179 },
4180
4181 /* Generic */
4182 bfd_true,
4183 bfd_true,
4184 coff_new_section_hook,
4185 _bfd_generic_get_section_contents,
4186 _bfd_generic_get_section_contents_in_window,
4187
4188 /* Copy */
4189 _bfd_xcoff_copy_private_bfd_data,
4190 ((bfd_boolean (*) (bfd *, bfd *)) bfd_true),
4191 _bfd_generic_init_private_section_data,
4192 ((bfd_boolean (*) (bfd *, asection *, bfd *, asection *)) bfd_true),
4193 ((bfd_boolean (*) (bfd *, asymbol *, bfd *, asymbol *)) bfd_true),
4194 ((bfd_boolean (*) (bfd *, bfd *)) bfd_true),
4195 ((bfd_boolean (*) (bfd *, flagword)) bfd_true),
4196 ((bfd_boolean (*) (bfd *, void * )) bfd_true),
4197
4198 /* Core */
4199 coff_core_file_failing_command,
4200 coff_core_file_failing_signal,
4201 coff_core_file_matches_executable_p,
4202
4203 /* Archive */
4204 _bfd_xcoff_slurp_armap,
4205 bfd_false,
4206 ((bfd_boolean (*) (bfd *, char **, bfd_size_type *, const char **)) bfd_false),
4207 bfd_dont_truncate_arname,
4208 _bfd_xcoff_write_armap,
4209 _bfd_xcoff_read_ar_hdr,
4210 _bfd_xcoff_openr_next_archived_file,
4211 _bfd_generic_get_elt_at_index,
4212 _bfd_xcoff_stat_arch_elt,
4213 bfd_true,
4214
4215 /* Symbols */
4216 coff_get_symtab_upper_bound,
4217 coff_canonicalize_symtab,
4218 coff_make_empty_symbol,
4219 coff_print_symbol,
4220 coff_get_symbol_info,
4221 _bfd_xcoff_is_local_label_name,
4222 coff_bfd_is_target_special_symbol,
4223 coff_get_lineno,
4224 coff_find_nearest_line,
4225 _bfd_generic_find_line,
4226 coff_find_inliner_info,
4227 coff_bfd_make_debug_symbol,
4228 _bfd_generic_read_minisymbols,
4229 _bfd_generic_minisymbol_to_symbol,
4230
4231 /* Reloc */
4232 coff_get_reloc_upper_bound,
4233 coff_canonicalize_reloc,
4234 _bfd_xcoff_reloc_type_lookup,
4235 _bfd_xcoff_reloc_name_lookup,
4236
4237 /* Write */
4238 coff_set_arch_mach,
4239 coff_set_section_contents,
4240
4241 /* Link */
4242 _bfd_xcoff_sizeof_headers,
4243 bfd_generic_get_relocated_section_contents,
4244 bfd_generic_relax_section,
4245 _bfd_xcoff_bfd_link_hash_table_create,
4246 _bfd_generic_link_hash_table_free,
4247 _bfd_xcoff_bfd_link_add_symbols,
4248 _bfd_generic_link_just_syms,
4249 _bfd_xcoff_bfd_final_link,
4250 _bfd_generic_link_split_section,
4251 bfd_generic_gc_sections,
4252 bfd_generic_merge_sections,
4253 bfd_generic_is_group_section,
4254 bfd_generic_discard_group,
4255 _bfd_generic_section_already_linked,
4256
4257 /* Dynamic */
4258 _bfd_xcoff_get_dynamic_symtab_upper_bound,
4259 _bfd_xcoff_canonicalize_dynamic_symtab,
4260 _bfd_nodynamic_get_synthetic_symtab,
4261 _bfd_xcoff_get_dynamic_reloc_upper_bound,
4262 _bfd_xcoff_canonicalize_dynamic_reloc,
4263
4264 /* Opposite endian version, none exists */
4265 NULL,
4266
4267 (void *) &bfd_xcoff_backend_data,
4268 };
4269
4270 /* xcoff-powermac target
4271 Old target.
4272 Only difference between this target and the rs6000 target is the
4273 the default architecture and machine type used in coffcode.h
4274
4275 PowerPC Macs use the same magic numbers as RS/6000
4276 (because that's how they were bootstrapped originally),
4277 but they are always PowerPC architecture. */
4278 static const struct xcoff_backend_data_rec bfd_pmac_xcoff_backend_data =
4279 {
4280 { /* COFF backend, defined in libcoff.h. */
4281 _bfd_xcoff_swap_aux_in,
4282 _bfd_xcoff_swap_sym_in,
4283 coff_swap_lineno_in,
4284 _bfd_xcoff_swap_aux_out,
4285 _bfd_xcoff_swap_sym_out,
4286 coff_swap_lineno_out,
4287 xcoff_swap_reloc_out,
4288 coff_swap_filehdr_out,
4289 coff_swap_aouthdr_out,
4290 coff_swap_scnhdr_out,
4291 FILHSZ,
4292 AOUTSZ,
4293 SCNHSZ,
4294 SYMESZ,
4295 AUXESZ,
4296 RELSZ,
4297 LINESZ,
4298 FILNMLEN,
4299 TRUE, /* _bfd_coff_long_filenames */
4300 XCOFF_NO_LONG_SECTION_NAMES, /* _bfd_coff_long_section_names */
4301 3, /* _bfd_coff_default_section_alignment_power */
4302 FALSE, /* _bfd_coff_force_symnames_in_strings */
4303 2, /* _bfd_coff_debug_string_prefix_length */
4304 coff_swap_filehdr_in,
4305 coff_swap_aouthdr_in,
4306 coff_swap_scnhdr_in,
4307 xcoff_swap_reloc_in,
4308 coff_bad_format_hook,
4309 coff_set_arch_mach_hook,
4310 coff_mkobject_hook,
4311 styp_to_sec_flags,
4312 coff_set_alignment_hook,
4313 coff_slurp_symbol_table,
4314 symname_in_debug_hook,
4315 coff_pointerize_aux_hook,
4316 coff_print_aux,
4317 dummy_reloc16_extra_cases,
4318 dummy_reloc16_estimate,
4319 NULL, /* bfd_coff_sym_is_global */
4320 coff_compute_section_file_positions,
4321 NULL, /* _bfd_coff_start_final_link */
4322 xcoff_ppc_relocate_section,
4323 coff_rtype_to_howto,
4324 NULL, /* _bfd_coff_adjust_symndx */
4325 _bfd_generic_link_add_one_symbol,
4326 coff_link_output_has_begun,
4327 coff_final_link_postscript,
4328 NULL /* print_pdata. */
4329 },
4330
4331 0x01DF, /* magic number */
4332 bfd_arch_powerpc,
4333 bfd_mach_ppc,
4334
4335 /* Function pointers to xcoff specific swap routines. */
4336 xcoff_swap_ldhdr_in,
4337 xcoff_swap_ldhdr_out,
4338 xcoff_swap_ldsym_in,
4339 xcoff_swap_ldsym_out,
4340 xcoff_swap_ldrel_in,
4341 xcoff_swap_ldrel_out,
4342
4343 /* Sizes. */
4344 LDHDRSZ,
4345 LDSYMSZ,
4346 LDRELSZ,
4347 12, /* _xcoff_function_descriptor_size */
4348 SMALL_AOUTSZ,
4349
4350 /* Versions. */
4351 1, /* _xcoff_ldhdr_version */
4352
4353 _bfd_xcoff_put_symbol_name,
4354 _bfd_xcoff_put_ldsymbol_name,
4355 &xcoff_dynamic_reloc,
4356 xcoff_create_csect_from_smclas,
4357
4358 /* Lineno and reloc count overflow. */
4359 xcoff_is_lineno_count_overflow,
4360 xcoff_is_reloc_count_overflow,
4361
4362 xcoff_loader_symbol_offset,
4363 xcoff_loader_reloc_offset,
4364
4365 /* glink. */
4366 &xcoff_glink_code[0],
4367 36, /* _xcoff_glink_size */
4368
4369 /* rtinit */
4370 0, /* _xcoff_rtinit_size */
4371 xcoff_generate_rtinit,
4372 };
4373
4374 /* The transfer vector that leads the outside world to all of the above. */
4375 const bfd_target pmac_xcoff_vec =
4376 {
4377 "xcoff-powermac",
4378 bfd_target_xcoff_flavour,
4379 BFD_ENDIAN_BIG, /* data byte order is big */
4380 BFD_ENDIAN_BIG, /* header byte order is big */
4381
4382 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | DYNAMIC
4383 | HAS_SYMS | HAS_LOCALS | WP_TEXT),
4384
4385 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA,
4386 0, /* leading char */
4387 '/', /* ar_pad_char */
4388 15, /* ar_max_namelen */
4389
4390 /* data */
4391 bfd_getb64,
4392 bfd_getb_signed_64,
4393 bfd_putb64,
4394 bfd_getb32,
4395 bfd_getb_signed_32,
4396 bfd_putb32,
4397 bfd_getb16,
4398 bfd_getb_signed_16,
4399 bfd_putb16,
4400
4401 /* hdrs */
4402 bfd_getb64,
4403 bfd_getb_signed_64,
4404 bfd_putb64,
4405 bfd_getb32,
4406 bfd_getb_signed_32,
4407 bfd_putb32,
4408 bfd_getb16,
4409 bfd_getb_signed_16,
4410 bfd_putb16,
4411
4412 { /* bfd_check_format */
4413 _bfd_dummy_target,
4414 coff_object_p,
4415 _bfd_xcoff_archive_p,
4416 CORE_FILE_P
4417 },
4418
4419 { /* bfd_set_format */
4420 bfd_false,
4421 coff_mkobject,
4422 _bfd_generic_mkarchive,
4423 bfd_false
4424 },
4425
4426 {/* bfd_write_contents */
4427 bfd_false,
4428 coff_write_object_contents,
4429 _bfd_xcoff_write_archive_contents,
4430 bfd_false
4431 },
4432
4433 /* Generic */
4434 bfd_true,
4435 bfd_true,
4436 coff_new_section_hook,
4437 _bfd_generic_get_section_contents,
4438 _bfd_generic_get_section_contents_in_window,
4439
4440 /* Copy */
4441 _bfd_xcoff_copy_private_bfd_data,
4442 ((bfd_boolean (*) (bfd *, bfd *)) bfd_true),
4443 _bfd_generic_init_private_section_data,
4444 ((bfd_boolean (*) (bfd *, asection *, bfd *, asection *)) bfd_true),
4445 ((bfd_boolean (*) (bfd *, asymbol *, bfd *, asymbol *)) bfd_true),
4446 ((bfd_boolean (*) (bfd *, bfd *)) bfd_true),
4447 ((bfd_boolean (*) (bfd *, flagword)) bfd_true),
4448 ((bfd_boolean (*) (bfd *, void * )) bfd_true),
4449
4450 /* Core */
4451 coff_core_file_failing_command,
4452 coff_core_file_failing_signal,
4453 coff_core_file_matches_executable_p,
4454
4455 /* Archive */
4456 _bfd_xcoff_slurp_armap,
4457 bfd_false,
4458 ((bfd_boolean (*) (bfd *, char **, bfd_size_type *, const char **)) bfd_false),
4459 bfd_dont_truncate_arname,
4460 _bfd_xcoff_write_armap,
4461 _bfd_xcoff_read_ar_hdr,
4462 _bfd_xcoff_openr_next_archived_file,
4463 _bfd_generic_get_elt_at_index,
4464 _bfd_xcoff_stat_arch_elt,
4465 bfd_true,
4466
4467 /* Symbols */
4468 coff_get_symtab_upper_bound,
4469 coff_canonicalize_symtab,
4470 coff_make_empty_symbol,
4471 coff_print_symbol,
4472 coff_get_symbol_info,
4473 _bfd_xcoff_is_local_label_name,
4474 coff_bfd_is_target_special_symbol,
4475 coff_get_lineno,
4476 coff_find_nearest_line,
4477 _bfd_generic_find_line,
4478 coff_find_inliner_info,
4479 coff_bfd_make_debug_symbol,
4480 _bfd_generic_read_minisymbols,
4481 _bfd_generic_minisymbol_to_symbol,
4482
4483 /* Reloc */
4484 coff_get_reloc_upper_bound,
4485 coff_canonicalize_reloc,
4486 _bfd_xcoff_reloc_type_lookup,
4487 _bfd_xcoff_reloc_name_lookup,
4488
4489 /* Write */
4490 coff_set_arch_mach,
4491 coff_set_section_contents,
4492
4493 /* Link */
4494 _bfd_xcoff_sizeof_headers,
4495 bfd_generic_get_relocated_section_contents,
4496 bfd_generic_relax_section,
4497 _bfd_xcoff_bfd_link_hash_table_create,
4498 _bfd_generic_link_hash_table_free,
4499 _bfd_xcoff_bfd_link_add_symbols,
4500 _bfd_generic_link_just_syms,
4501 _bfd_xcoff_bfd_final_link,
4502 _bfd_generic_link_split_section,
4503 bfd_generic_gc_sections,
4504 bfd_generic_merge_sections,
4505 bfd_generic_is_group_section,
4506 bfd_generic_discard_group,
4507 _bfd_generic_section_already_linked,
4508
4509 /* Dynamic */
4510 _bfd_xcoff_get_dynamic_symtab_upper_bound,
4511 _bfd_xcoff_canonicalize_dynamic_symtab,
4512 _bfd_nodynamic_get_synthetic_symtab,
4513 _bfd_xcoff_get_dynamic_reloc_upper_bound,
4514 _bfd_xcoff_canonicalize_dynamic_reloc,
4515
4516 /* Opposite endian version, none exists */
4517 NULL,
4518
4519 (void *) &bfd_pmac_xcoff_backend_data,
4520 };
git-cvsimport of binutils cvsroot