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