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