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