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