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