?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* tc-arm.c (do_xsc_mia, do_xsc_mar, do_xsc_mra): Renamed from
[binutils.git] / bfd / coff-rs6000.c
blob2d6d6e95056ad59a68d02946d283750fd58a2351
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 ();
85 extern boolean rs6000coff_core_file_matches_executable_p ();
86 extern char *rs6000coff_core_file_failing_command PARAMS ((bfd *abfd));
87 extern int rs6000coff_core_file_failing_signal PARAMS ((bfd *abfd));
88 #define CORE_FILE_P rs6000coff_core_p
89 #define coff_core_file_failing_command \
90 rs6000coff_core_file_failing_command
91 #define coff_core_file_failing_signal \
92 rs6000coff_core_file_failing_signal
93 #define coff_core_file_matches_executable_p \
94 rs6000coff_core_file_matches_executable_p
95 #else
96 #define CORE_FILE_P _bfd_dummy_target
97 #define coff_core_file_failing_command \
98 _bfd_nocore_core_file_failing_command
99 #define coff_core_file_failing_signal \
100 _bfd_nocore_core_file_failing_signal
101 #define coff_core_file_matches_executable_p \
102 _bfd_nocore_core_file_matches_executable_p
103 #endif
104 #define coff_SWAP_sym_in _bfd_xcoff_swap_sym_in
105 #define coff_SWAP_sym_out _bfd_xcoff_swap_sym_out
106 #define coff_SWAP_aux_in _bfd_xcoff_swap_aux_in
107 #define coff_SWAP_aux_out _bfd_xcoff_swap_aux_out
108
109 #include "coffcode.h"
110
111 /* The main body of code is in coffcode.h. */
112
113 static const char *normalize_filename PARAMS ((bfd *));
114 static boolean xcoff_write_armap_old
115 PARAMS ((bfd *, unsigned int, struct orl *, unsigned int, int));
116 static boolean xcoff_write_armap_big
117 PARAMS ((bfd *, unsigned int, struct orl *, unsigned int, int));
118 static boolean xcoff_write_archive_contents_old PARAMS ((bfd *));
119 static boolean xcoff_write_archive_contents_big PARAMS ((bfd *));
120 static void xcoff_swap_ldhdr_in
121 PARAMS ((bfd *, const PTR, struct internal_ldhdr *));
122 static void xcoff_swap_ldhdr_out
123 PARAMS ((bfd *, const struct internal_ldhdr *, PTR));
124 static void xcoff_swap_ldsym_in
125 PARAMS ((bfd *, const PTR, struct internal_ldsym *));
126 static void xcoff_swap_ldsym_out
127 PARAMS ((bfd *, const struct internal_ldsym *, PTR));
128 static void xcoff_swap_ldrel_in
129 PARAMS ((bfd *, const PTR, struct internal_ldrel *));
130 static void xcoff_swap_ldrel_out
131 PARAMS ((bfd *, const struct internal_ldrel *, PTR));
132 static boolean xcoff_ppc_relocate_section
133 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
134 struct internal_reloc *, struct internal_syment *, asection **));
135 static boolean _bfd_xcoff_put_ldsymbol_name
136 PARAMS ((bfd *, struct xcoff_loader_info *, struct internal_ldsym *,
137 const char *));
138 static asection *xcoff_create_csect_from_smclas
139 PARAMS ((bfd *, union internal_auxent *, const char *));
140 static boolean xcoff_is_lineno_count_overflow PARAMS ((bfd *, bfd_vma));
141 static boolean xcoff_is_reloc_count_overflow PARAMS ((bfd *, bfd_vma));
142 static bfd_vma xcoff_loader_symbol_offset
143 PARAMS ((bfd *, struct internal_ldhdr *));
144 static bfd_vma xcoff_loader_reloc_offset
145 PARAMS ((bfd *, struct internal_ldhdr *));
146 static boolean xcoff_generate_rtinit
147 PARAMS((bfd *, const char *, const char *));
148
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 (0, /* 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 };
875
876 void
877 _bfd_xcoff_rtype2howto (relent, internal)
878 arelent *relent;
879 struct internal_reloc *internal;
880 {
881 relent->howto = xcoff_howto_table + internal->r_type;
882
883 /* Check for relocs we don't know of. */
884 if (internal->r_type
885 >= sizeof (xcoff_howto_table) / sizeof (xcoff_howto_table[0]))
886 abort ();
887 if (internal->r_type != relent->howto->type)
888 abort ();
889
890 /* The r_size field of an XCOFF reloc encodes the bitsize of the
891 relocation, as well as indicating whether it is signed or not.
892 Doublecheck that the relocation information gathered from the
893 type matches this information. The bitsize is not significant
894 for R_REF relocs. */
895 if (relent->howto->dst_mask != 0
896 && (relent->howto->bitsize
897 != ((unsigned int) internal->r_size & 0x3f) + 1))
898 abort ();
899 #if 0
900 if ((internal->r_size & 0x80) != 0
901 ? (relent->howto->complain_on_overflow != complain_overflow_signed)
902 : (relent->howto->complain_on_overflow != complain_overflow_bitfield))
903 abort ();
904 #endif
905 }
906
907 reloc_howto_type *
908 _bfd_xcoff_reloc_type_lookup (abfd, code)
909 bfd *abfd ATTRIBUTE_UNUSED;
910 bfd_reloc_code_real_type code;
911 {
912 switch (code)
913 {
914 case BFD_RELOC_PPC_B26:
915 return &xcoff_howto_table[0xa];
916 case BFD_RELOC_PPC_BA26:
917 return &xcoff_howto_table[8];
918 case BFD_RELOC_PPC_TOC16:
919 return &xcoff_howto_table[3];
920 case BFD_RELOC_32:
921 case BFD_RELOC_CTOR:
922 return &xcoff_howto_table[0];
923 case BFD_RELOC_64:
924 return &xcoff_howto_table[0x1c];
925 default:
926 return NULL;
927 }
928 }
929
930 \f
931 /* XCOFF archive support. The original version of this code was by
932 Damon A. Permezel. It was enhanced to permit cross support, and
933 writing archive files, by Ian Lance Taylor, Cygnus Support.
934
935 XCOFF uses its own archive format. Everything is hooked together
936 with file offset links, so it is possible to rapidly update an
937 archive in place. Of course, we don't do that. An XCOFF archive
938 has a real file header, not just an ARMAG string. The structure of
939 the file header and of each archive header appear below.
940
941 An XCOFF archive also has a member table, which is a list of
942 elements in the archive (you can get that by looking through the
943 linked list, but you have to read a lot more of the file). The
944 member table has a normal archive header with an empty name. It is
945 normally (and perhaps must be) the second to last entry in the
946 archive. The member table data is almost printable ASCII. It
947 starts with a 12 character decimal string which is the number of
948 entries in the table. For each entry it has a 12 character decimal
949 string which is the offset in the archive of that member. These
950 entries are followed by a series of null terminated strings which
951 are the member names for each entry.
952
953 Finally, an XCOFF archive has a global symbol table, which is what
954 we call the armap. The global symbol table has a normal archive
955 header with an empty name. It is normally (and perhaps must be)
956 the last entry in the archive. The contents start with a four byte
957 binary number which is the number of entries. This is followed by
958 a that many four byte binary numbers; each is the file offset of an
959 entry in the archive. These numbers are followed by a series of
960 null terminated strings, which are symbol names.
961
962 AIX 4.3 introduced a new archive format which can handle larger
963 files and also 32- and 64-bit objects in the same archive. The
964 things said above remain true except that there is now more than
965 one global symbol table. The one is used to index 32-bit objects,
966 the other for 64-bit objects.
967
968 The new archives (recognizable by the new ARMAG string) has larger
969 field lengths so that we cannot really share any code. Also we have
970 to take care that we are not generating the new form of archives
971 on AIX 4.2 or earlier systems. */
972
973 /* XCOFF archives use this as a magic string. Note that both strings
974 have the same length. */
975
976
977
978 /* Read in the armap of an XCOFF archive. */
979
980 boolean
981 _bfd_xcoff_slurp_armap (abfd)
982 bfd *abfd;
983 {
984 file_ptr off;
985 size_t namlen;
986 bfd_size_type sz;
987 bfd_byte *contents, *cend;
988 bfd_vma c, i;
989 carsym *arsym;
990 bfd_byte *p;
991
992 if (xcoff_ardata (abfd) == NULL)
993 {
994 bfd_has_map (abfd) = false;
995 return true;
996 }
997
998 if (! xcoff_big_format_p (abfd))
999 {
1000 /* This is for the old format. */
1001 struct xcoff_ar_hdr hdr;
1002
1003 off = strtol (xcoff_ardata (abfd)->symoff, (char **) NULL, 10);
1004 if (off == 0)
1005 {
1006 bfd_has_map (abfd) = false;
1007 return true;
1008 }
1009
1010 if (bfd_seek (abfd, off, SEEK_SET) != 0)
1011 return false;
1012
1013 /* The symbol table starts with a normal archive header. */
1014 if (bfd_bread ((PTR) &hdr, (bfd_size_type) SIZEOF_AR_HDR, abfd)
1015 != SIZEOF_AR_HDR)
1016 return false;
1017
1018 /* Skip the name (normally empty). */
1019 namlen = strtol (hdr.namlen, (char **) NULL, 10);
1020 off = ((namlen + 1) & ~ (size_t) 1) + SXCOFFARFMAG;
1021 if (bfd_seek (abfd, off, SEEK_CUR) != 0)
1022 return false;
1023
1024 sz = strtol (hdr.size, (char **) NULL, 10);
1025
1026 /* Read in the entire symbol table. */
1027 contents = (bfd_byte *) bfd_alloc (abfd, sz);
1028 if (contents == NULL)
1029 return false;
1030 if (bfd_bread ((PTR) contents, sz, abfd) != sz)
1031 return false;
1032
1033 /* The symbol table starts with a four byte count. */
1034 c = H_GET_32 (abfd, contents);
1035
1036 if (c * 4 >= sz)
1037 {
1038 bfd_set_error (bfd_error_bad_value);
1039 return false;
1040 }
1041
1042 bfd_ardata (abfd)->symdefs =
1043 ((carsym *) bfd_alloc (abfd, c * sizeof (carsym)));
1044 if (bfd_ardata (abfd)->symdefs == NULL)
1045 return false;
1046
1047 /* After the count comes a list of four byte file offsets. */
1048 for (i = 0, arsym = bfd_ardata (abfd)->symdefs, p = contents + 4;
1049 i < c;
1050 ++i, ++arsym, p += 4)
1051 arsym->file_offset = H_GET_32 (abfd, p);
1052 }
1053 else
1054 {
1055 /* This is for the new format. */
1056 struct xcoff_ar_hdr_big hdr;
1057
1058 off = strtol (xcoff_ardata_big (abfd)->symoff, (char **) NULL, 10);
1059 if (off == 0)
1060 {
1061 bfd_has_map (abfd) = false;
1062 return true;
1063 }
1064
1065 if (bfd_seek (abfd, off, SEEK_SET) != 0)
1066 return false;
1067
1068 /* The symbol table starts with a normal archive header. */
1069 if (bfd_bread ((PTR) &hdr, (bfd_size_type) SIZEOF_AR_HDR_BIG, abfd)
1070 != SIZEOF_AR_HDR_BIG)
1071 return false;
1072
1073 /* Skip the name (normally empty). */
1074 namlen = strtol (hdr.namlen, (char **) NULL, 10);
1075 off = ((namlen + 1) & ~ (size_t) 1) + SXCOFFARFMAG;
1076 if (bfd_seek (abfd, off, SEEK_CUR) != 0)
1077 return false;
1078
1079 /* XXX This actually has to be a call to strtoll (at least on 32-bit
1080 machines) since the field width is 20 and there numbers with more
1081 than 32 bits can be represented. */
1082 sz = strtol (hdr.size, (char **) NULL, 10);
1083
1084 /* Read in the entire symbol table. */
1085 contents = (bfd_byte *) bfd_alloc (abfd, sz);
1086 if (contents == NULL)
1087 return false;
1088 if (bfd_bread ((PTR) contents, sz, abfd) != sz)
1089 return false;
1090
1091 /* The symbol table starts with an eight byte count. */
1092 c = H_GET_64 (abfd, contents);
1093
1094 if (c * 8 >= sz)
1095 {
1096 bfd_set_error (bfd_error_bad_value);
1097 return false;
1098 }
1099
1100 bfd_ardata (abfd)->symdefs =
1101 ((carsym *) bfd_alloc (abfd, c * sizeof (carsym)));
1102 if (bfd_ardata (abfd)->symdefs == NULL)
1103 return false;
1104
1105 /* After the count comes a list of eight byte file offsets. */
1106 for (i = 0, arsym = bfd_ardata (abfd)->symdefs, p = contents + 8;
1107 i < c;
1108 ++i, ++arsym, p += 8)
1109 arsym->file_offset = H_GET_64 (abfd, p);
1110 }
1111
1112 /* After the file offsets come null terminated symbol names. */
1113 cend = contents + sz;
1114 for (i = 0, arsym = bfd_ardata (abfd)->symdefs;
1115 i < c;
1116 ++i, ++arsym, p += strlen ((char *) p) + 1)
1117 {
1118 if (p >= cend)
1119 {
1120 bfd_set_error (bfd_error_bad_value);
1121 return false;
1122 }
1123 arsym->name = (char *) p;
1124 }
1125
1126 bfd_ardata (abfd)->symdef_count = c;
1127 bfd_has_map (abfd) = true;
1128
1129 return true;
1130 }
1131
1132 /* See if this is an XCOFF archive. */
1133
1134 const bfd_target *
1135 _bfd_xcoff_archive_p (abfd)
1136 bfd *abfd;
1137 {
1138 char magic[SXCOFFARMAG];
1139 bfd_size_type amt;
1140
1141 if (bfd_bread ((PTR) magic, (bfd_size_type) SXCOFFARMAG, abfd) != SXCOFFARMAG)
1142 {
1143 if (bfd_get_error () != bfd_error_system_call)
1144 bfd_set_error (bfd_error_wrong_format);
1145 return NULL;
1146 }
1147
1148 if (strncmp (magic, XCOFFARMAG, SXCOFFARMAG) != 0
1149 && strncmp (magic, XCOFFARMAGBIG, SXCOFFARMAG) != 0)
1150 {
1151 bfd_set_error (bfd_error_wrong_format);
1152 return NULL;
1153 }
1154
1155 /* We are setting bfd_ardata(abfd) here, but since bfd_ardata
1156 involves a cast, we can't do it as the left operand of
1157 assignment. */
1158 amt = sizeof (struct artdata);
1159 abfd->tdata.aout_ar_data = (struct artdata *) bfd_zalloc (abfd, amt);
1160 if (bfd_ardata (abfd) == (struct artdata *) NULL)
1161 return NULL;
1162
1163 bfd_ardata (abfd)->cache = NULL;
1164 bfd_ardata (abfd)->archive_head = NULL;
1165 bfd_ardata (abfd)->symdefs = NULL;
1166 bfd_ardata (abfd)->extended_names = NULL;
1167
1168 /* Now handle the two formats. */
1169 if (magic[1] != 'b')
1170 {
1171 /* This is the old format. */
1172 struct xcoff_ar_file_hdr hdr;
1173
1174 /* Copy over the magic string. */
1175 memcpy (hdr.magic, magic, SXCOFFARMAG);
1176
1177 /* Now read the rest of the file header. */
1178 if (bfd_bread ((PTR) &hdr.memoff,
1179 (bfd_size_type) SIZEOF_AR_FILE_HDR - SXCOFFARMAG, abfd)
1180 != SIZEOF_AR_FILE_HDR - SXCOFFARMAG)
1181 {
1182 if (bfd_get_error () != bfd_error_system_call)
1183 bfd_set_error (bfd_error_wrong_format);
1184 return NULL;
1185 }
1186
1187 bfd_ardata (abfd)->first_file_filepos = strtol (hdr.firstmemoff,
1188 (char **) NULL, 10);
1189
1190 amt = SIZEOF_AR_FILE_HDR;
1191 bfd_ardata (abfd)->tdata = bfd_zalloc (abfd, amt);
1192 if (bfd_ardata (abfd)->tdata == NULL)
1193 return NULL;
1194
1195 memcpy (bfd_ardata (abfd)->tdata, &hdr, SIZEOF_AR_FILE_HDR);
1196 }
1197 else
1198 {
1199 /* This is the new format. */
1200 struct xcoff_ar_file_hdr_big hdr;
1201
1202 /* Copy over the magic string. */
1203 memcpy (hdr.magic, magic, SXCOFFARMAG);
1204
1205 /* Now read the rest of the file header. */
1206 if (bfd_bread ((PTR) &hdr.memoff,
1207 (bfd_size_type) SIZEOF_AR_FILE_HDR_BIG - SXCOFFARMAG, abfd)
1208 != SIZEOF_AR_FILE_HDR_BIG - SXCOFFARMAG)
1209 {
1210 if (bfd_get_error () != bfd_error_system_call)
1211 bfd_set_error (bfd_error_wrong_format);
1212 return NULL;
1213 }
1214
1215 /* XXX This actually has to be a call to strtoll (at least on 32-bit
1216 machines) since the field width is 20 and there numbers with more
1217 than 32 bits can be represented. */
1218 bfd_ardata (abfd)->first_file_filepos = strtol (hdr.firstmemoff,
1219 (char **) NULL, 10);
1220
1221 amt = SIZEOF_AR_FILE_HDR_BIG;
1222 bfd_ardata (abfd)->tdata = bfd_zalloc (abfd, amt);
1223 if (bfd_ardata (abfd)->tdata == NULL)
1224 return NULL;
1225
1226 memcpy (bfd_ardata (abfd)->tdata, &hdr, SIZEOF_AR_FILE_HDR_BIG);
1227 }
1228
1229 if (! _bfd_xcoff_slurp_armap (abfd))
1230 {
1231 bfd_release (abfd, bfd_ardata (abfd));
1232 abfd->tdata.aout_ar_data = (struct artdata *) NULL;
1233 return NULL;
1234 }
1235
1236 return abfd->xvec;
1237 }
1238
1239 /* Read the archive header in an XCOFF archive. */
1240
1241 PTR
1242 _bfd_xcoff_read_ar_hdr (abfd)
1243 bfd *abfd;
1244 {
1245 bfd_size_type namlen;
1246 struct areltdata *ret;
1247 bfd_size_type amt = sizeof (struct areltdata);
1248
1249 ret = (struct areltdata *) bfd_alloc (abfd, amt);
1250 if (ret == NULL)
1251 return NULL;
1252
1253 if (! xcoff_big_format_p (abfd))
1254 {
1255 struct xcoff_ar_hdr hdr;
1256 struct xcoff_ar_hdr *hdrp;
1257
1258 if (bfd_bread ((PTR) &hdr, (bfd_size_type) SIZEOF_AR_HDR, abfd)
1259 != SIZEOF_AR_HDR)
1260 {
1261 free (ret);
1262 return NULL;
1263 }
1264
1265 namlen = strtol (hdr.namlen, (char **) NULL, 10);
1266 amt = SIZEOF_AR_HDR + namlen + 1;
1267 hdrp = (struct xcoff_ar_hdr *) bfd_alloc (abfd, amt);
1268 if (hdrp == NULL)
1269 {
1270 free (ret);
1271 return NULL;
1272 }
1273 memcpy (hdrp, &hdr, SIZEOF_AR_HDR);
1274 if (bfd_bread ((char *) hdrp + SIZEOF_AR_HDR, namlen, abfd) != namlen)
1275 {
1276 free (ret);
1277 return NULL;
1278 }
1279 ((char *) hdrp)[SIZEOF_AR_HDR + namlen] = '\0';
1280
1281 ret->arch_header = (char *) hdrp;
1282 ret->parsed_size = strtol (hdr.size, (char **) NULL, 10);
1283 ret->filename = (char *) hdrp + SIZEOF_AR_HDR;
1284 }
1285 else
1286 {
1287 struct xcoff_ar_hdr_big hdr;
1288 struct xcoff_ar_hdr_big *hdrp;
1289
1290 if (bfd_bread ((PTR) &hdr, (bfd_size_type) SIZEOF_AR_HDR_BIG, abfd)
1291 != SIZEOF_AR_HDR_BIG)
1292 {
1293 free (ret);
1294 return NULL;
1295 }
1296
1297 namlen = strtol (hdr.namlen, (char **) NULL, 10);
1298 amt = SIZEOF_AR_HDR_BIG + namlen + 1;
1299 hdrp = (struct xcoff_ar_hdr_big *) bfd_alloc (abfd, amt);
1300 if (hdrp == NULL)
1301 {
1302 free (ret);
1303 return NULL;
1304 }
1305 memcpy (hdrp, &hdr, SIZEOF_AR_HDR_BIG);
1306 if (bfd_bread ((char *) hdrp + SIZEOF_AR_HDR_BIG, namlen, abfd) != namlen)
1307 {
1308 free (ret);
1309 return NULL;
1310 }
1311 ((char *) hdrp)[SIZEOF_AR_HDR_BIG + namlen] = '\0';
1312
1313 ret->arch_header = (char *) hdrp;
1314 /* XXX This actually has to be a call to strtoll (at least on 32-bit
1315 machines) since the field width is 20 and there numbers with more
1316 than 32 bits can be represented. */
1317 ret->parsed_size = strtol (hdr.size, (char **) NULL, 10);
1318 ret->filename = (char *) hdrp + SIZEOF_AR_HDR_BIG;
1319 }
1320
1321 /* Skip over the XCOFFARFMAG at the end of the file name. */
1322 if (bfd_seek (abfd, (file_ptr) ((namlen & 1) + SXCOFFARFMAG), SEEK_CUR) != 0)
1323 return NULL;
1324
1325 return (PTR) ret;
1326 }
1327
1328 /* Open the next element in an XCOFF archive. */
1329
1330 bfd *
1331 _bfd_xcoff_openr_next_archived_file (archive, last_file)
1332 bfd *archive;
1333 bfd *last_file;
1334 {
1335 file_ptr filestart;
1336
1337 if (xcoff_ardata (archive) == NULL)
1338 {
1339 bfd_set_error (bfd_error_invalid_operation);
1340 return NULL;
1341 }
1342
1343 if (! xcoff_big_format_p (archive))
1344 {
1345 if (last_file == NULL)
1346 filestart = bfd_ardata (archive)->first_file_filepos;
1347 else
1348 filestart = strtol (arch_xhdr (last_file)->nextoff, (char **) NULL,
1349 10);
1350
1351 if (filestart == 0
1352 || filestart == strtol (xcoff_ardata (archive)->memoff,
1353 (char **) NULL, 10)
1354 || filestart == strtol (xcoff_ardata (archive)->symoff,
1355 (char **) NULL, 10))
1356 {
1357 bfd_set_error (bfd_error_no_more_archived_files);
1358 return NULL;
1359 }
1360 }
1361 else
1362 {
1363 if (last_file == NULL)
1364 filestart = bfd_ardata (archive)->first_file_filepos;
1365 else
1366 /* XXX These actually have to be a calls to strtoll (at least
1367 on 32-bit machines) since the fields's width is 20 and
1368 there numbers with more than 32 bits can be represented. */
1369 filestart = strtol (arch_xhdr_big (last_file)->nextoff, (char **) NULL,
1370 10);
1371
1372 /* XXX These actually have to be calls to strtoll (at least on 32-bit
1373 machines) since the fields's width is 20 and there numbers with more
1374 than 32 bits can be represented. */
1375 if (filestart == 0
1376 || filestart == strtol (xcoff_ardata_big (archive)->memoff,
1377 (char **) NULL, 10)
1378 || filestart == strtol (xcoff_ardata_big (archive)->symoff,
1379 (char **) NULL, 10))
1380 {
1381 bfd_set_error (bfd_error_no_more_archived_files);
1382 return NULL;
1383 }
1384 }
1385
1386 return _bfd_get_elt_at_filepos (archive, filestart);
1387 }
1388
1389 /* Stat an element in an XCOFF archive. */
1390
1391 int
1392 _bfd_xcoff_generic_stat_arch_elt (abfd, s)
1393 bfd *abfd;
1394 struct stat *s;
1395 {
1396 if (abfd->arelt_data == NULL)
1397 {
1398 bfd_set_error (bfd_error_invalid_operation);
1399 return -1;
1400 }
1401
1402 if (! xcoff_big_format_p (abfd))
1403 {
1404 struct xcoff_ar_hdr *hdrp = arch_xhdr (abfd);
1405
1406 s->st_mtime = strtol (hdrp->date, (char **) NULL, 10);
1407 s->st_uid = strtol (hdrp->uid, (char **) NULL, 10);
1408 s->st_gid = strtol (hdrp->gid, (char **) NULL, 10);
1409 s->st_mode = strtol (hdrp->mode, (char **) NULL, 8);
1410 s->st_size = arch_eltdata (abfd)->parsed_size;
1411 }
1412 else
1413 {
1414 struct xcoff_ar_hdr_big *hdrp = arch_xhdr_big (abfd);
1415
1416 s->st_mtime = strtol (hdrp->date, (char **) NULL, 10);
1417 s->st_uid = strtol (hdrp->uid, (char **) NULL, 10);
1418 s->st_gid = strtol (hdrp->gid, (char **) NULL, 10);
1419 s->st_mode = strtol (hdrp->mode, (char **) NULL, 8);
1420 s->st_size = arch_eltdata (abfd)->parsed_size;
1421 }
1422
1423 return 0;
1424 }
1425
1426 /* Normalize a file name for inclusion in an archive. */
1427
1428 static const char *
1429 normalize_filename (abfd)
1430 bfd *abfd;
1431 {
1432 const char *file;
1433 const char *filename;
1434
1435 file = bfd_get_filename (abfd);
1436 filename = strrchr (file, '/');
1437 if (filename != NULL)
1438 filename++;
1439 else
1440 filename = file;
1441 return filename;
1442 }
1443
1444 /* Write out an XCOFF armap. */
1445
1446 /*ARGSUSED*/
1447 static boolean
1448 xcoff_write_armap_old (abfd, elength, map, orl_count, stridx)
1449 bfd *abfd;
1450 unsigned int elength ATTRIBUTE_UNUSED;
1451 struct orl *map;
1452 unsigned int orl_count;
1453 int stridx;
1454 {
1455 struct xcoff_ar_hdr hdr;
1456 char *p;
1457 unsigned char buf[4];
1458 bfd *sub;
1459 file_ptr fileoff;
1460 unsigned int i;
1461
1462 memset (&hdr, 0, sizeof hdr);
1463 sprintf (hdr.size, "%ld", (long) (4 + orl_count * 4 + stridx));
1464 sprintf (hdr.nextoff, "%d", 0);
1465 memcpy (hdr.prevoff, xcoff_ardata (abfd)->memoff, XCOFFARMAG_ELEMENT_SIZE);
1466 sprintf (hdr.date, "%d", 0);
1467 sprintf (hdr.uid, "%d", 0);
1468 sprintf (hdr.gid, "%d", 0);
1469 sprintf (hdr.mode, "%d", 0);
1470 sprintf (hdr.namlen, "%d", 0);
1471
1472 /* We need spaces, not null bytes, in the header. */
1473 for (p = (char *) &hdr; p < (char *) &hdr + SIZEOF_AR_HDR; p++)
1474 if (*p == '\0')
1475 *p = ' ';
1476
1477 if (bfd_bwrite ((PTR) &hdr, (bfd_size_type) SIZEOF_AR_HDR, abfd)
1478 != SIZEOF_AR_HDR
1479 || (bfd_bwrite (XCOFFARFMAG, (bfd_size_type) SXCOFFARFMAG, abfd)
1480 != SXCOFFARFMAG))
1481 return false;
1482
1483 H_PUT_32 (abfd, orl_count, buf);
1484 if (bfd_bwrite (buf, (bfd_size_type) 4, abfd) != 4)
1485 return false;
1486
1487 sub = abfd->archive_head;
1488 fileoff = SIZEOF_AR_FILE_HDR;
1489 i = 0;
1490 while (sub != NULL && i < orl_count)
1491 {
1492 size_t namlen;
1493
1494 while (map[i].u.abfd == sub)
1495 {
1496 H_PUT_32 (abfd, fileoff, buf);
1497 if (bfd_bwrite (buf, (bfd_size_type) 4, abfd) != 4)
1498 return false;
1499 ++i;
1500 }
1501 namlen = strlen (normalize_filename (sub));
1502 namlen = (namlen + 1) &~ (size_t) 1;
1503 fileoff += (SIZEOF_AR_HDR
1504 + namlen
1505 + SXCOFFARFMAG
1506 + arelt_size (sub));
1507 fileoff = (fileoff + 1) &~ 1;
1508 sub = sub->next;
1509 }
1510
1511 for (i = 0; i < orl_count; i++)
1512 {
1513 const char *name;
1514 size_t namlen;
1515
1516 name = *map[i].name;
1517 namlen = strlen (name);
1518 if (bfd_bwrite (name, (bfd_size_type) (namlen + 1), abfd) != namlen + 1)
1519 return false;
1520 }
1521
1522 if ((stridx & 1) != 0)
1523 {
1524 char b;
1525
1526 b = '\0';
1527 if (bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
1528 return false;
1529 }
1530
1531 return true;
1532 }
1533
1534 static char buff20[XCOFFARMAGBIG_ELEMENT_SIZE + 1];
1535 #define FMT20 "%-20lld"
1536 #define FMT12 "%-12d"
1537 #define FMT12_OCTAL "%-12o"
1538 #define FMT4 "%-4d"
1539 #define PRINT20(d, v) \
1540 sprintf (buff20, FMT20, (long long)(v)), \
1541 memcpy ((void *) (d), buff20, 20)
1542
1543 #define PRINT12(d, v) \
1544 sprintf (buff20, FMT12, (int)(v)), \
1545 memcpy ((void *) (d), buff20, 12)
1546
1547 #define PRINT12_OCTAL(d, v) \
1548 sprintf (buff20, FMT12_OCTAL, (unsigned int)(v)), \
1549 memcpy ((void *) (d), buff20, 12)
1550
1551 #define PRINT4(d, v) \
1552 sprintf (buff20, FMT4, (int)(v)), \
1553 memcpy ((void *) (d), buff20, 4)
1554
1555 #define READ20(d, v) \
1556 buff20[20] = 0, \
1557 memcpy (buff20, (d), 20), \
1558 (v) = bfd_scan_vma (buff20, (const char **) NULL, 10)
1559
1560 static boolean
1561 xcoff_write_armap_big (abfd, elength, map, orl_count, stridx)
1562 bfd *abfd;
1563 unsigned int elength ATTRIBUTE_UNUSED;
1564 struct orl *map;
1565 unsigned int orl_count;
1566 int stridx;
1567 {
1568 struct xcoff_ar_file_hdr_big *fhdr;
1569 bfd_vma i, sym_32, sym_64, str_32, str_64;
1570 const bfd_arch_info_type *arch_info = NULL;
1571 bfd *current_bfd;
1572 size_t string_length;
1573 ufile_ptr nextoff, prevoff;
1574
1575 /* First, we look through the symbols and work out which are
1576 from 32-bit objects and which from 64-bit ones. */
1577 sym_32 = sym_64 = str_32 = str_64 = 0;
1578
1579 current_bfd = abfd->archive_head;
1580 if (current_bfd != NULL)
1581 arch_info = bfd_get_arch_info (current_bfd);
1582 i = 0;
1583 while (current_bfd != NULL && i < orl_count)
1584 {
1585 while (map[i].u.abfd == current_bfd)
1586 {
1587 string_length = strlen (*map[i].name) + 1;
1588
1589 if (arch_info->bits_per_address == 64)
1590 {
1591 sym_64++;
1592 str_64 += string_length;
1593 }
1594 else
1595 {
1596 sym_32++;
1597 str_32 += string_length;
1598 }
1599 i++;
1600 }
1601 current_bfd = current_bfd->next;
1602 if (current_bfd != NULL)
1603 arch_info = bfd_get_arch_info (current_bfd);
1604 }
1605
1606 /* A quick sanity check... */
1607 BFD_ASSERT (sym_64 + sym_32 == orl_count);
1608 /* Explicit cast to int for compiler. */
1609 BFD_ASSERT ((int)(str_64 + str_32) == stridx);
1610
1611 fhdr = xcoff_ardata_big (abfd);
1612
1613 /* xcoff_write_archive_contents_big passes nextoff in symoff. */
1614 READ20 (fhdr->memoff, prevoff);
1615 READ20 (fhdr->symoff, nextoff);
1616
1617 BFD_ASSERT (nextoff == bfd_tell (abfd));
1618
1619 /* Write out the symbol table.
1620 Layout :
1621
1622 standard big archive header
1623 0x0000 ar_size [0x14]
1624 0x0014 ar_nxtmem [0x14]
1625 0x0028 ar_prvmem [0x14]
1626 0x003C ar_date [0x0C]
1627 0x0048 ar_uid [0x0C]
1628 0x0054 ar_gid [0x0C]
1629 0x0060 ar_mod [0x0C]
1630 0x006C ar_namelen[0x04]
1631 0x0070 ar_fmag [SXCOFFARFMAG]
1632
1633 Symbol table
1634 0x0072 num_syms [0x08], binary
1635 0x0078 offsets [0x08 * num_syms], binary
1636 0x0086 + 0x08 * num_syms names [??]
1637 ?? pad to even bytes.
1638 */
1639
1640 if (sym_32)
1641 {
1642 struct xcoff_ar_hdr_big *hdr;
1643 bfd_byte *symbol_table;
1644 bfd_byte *st;
1645 file_ptr fileoff;
1646
1647 bfd_vma symbol_table_size =
1648 SIZEOF_AR_HDR_BIG
1649 + SXCOFFARFMAG
1650 + 8
1651 + 8 * sym_32
1652 + str_32 + (str_32 & 1);
1653
1654 symbol_table = NULL;
1655 symbol_table = (bfd_byte *) bfd_malloc (symbol_table_size);
1656 if (symbol_table == NULL)
1657 return false;
1658 memset (symbol_table, 0, symbol_table_size);
1659
1660 hdr = (struct xcoff_ar_hdr_big *) symbol_table;
1661
1662 PRINT20 (hdr->size, 8 + 8 * sym_32 + str_32 + (str_32 & 1));
1663
1664 if (sym_64)
1665 PRINT20 (hdr->nextoff, nextoff + symbol_table_size);
1666 else
1667 PRINT20 (hdr->nextoff, 0);
1668
1669 PRINT20 (hdr->prevoff, prevoff);
1670 PRINT12 (hdr->date, 0);
1671 PRINT12 (hdr->uid, 0);
1672 PRINT12 (hdr->gid, 0);
1673 PRINT12 (hdr->mode, 0);
1674 PRINT4 (hdr->namlen, 0) ;
1675
1676 st = symbol_table + SIZEOF_AR_HDR_BIG;
1677 memcpy (st, XCOFFARFMAG, SXCOFFARFMAG);
1678 st += SXCOFFARFMAG;
1679
1680 bfd_h_put_64 (abfd, sym_32, st);
1681 st += 8;
1682
1683 /* loop over the 32 bit offsets */
1684 current_bfd = abfd->archive_head;
1685 if (current_bfd != NULL)
1686 arch_info = bfd_get_arch_info (current_bfd);
1687 fileoff = SIZEOF_AR_FILE_HDR_BIG;
1688 i = 0;
1689 while (current_bfd != NULL && i < orl_count)
1690 {
1691 while (map[i].u.abfd == current_bfd)
1692 {
1693 if (arch_info->bits_per_address == 32)
1694 {
1695 bfd_h_put_64 (abfd, fileoff, st);
1696 st += 8;
1697 }
1698 i++;
1699 }
1700 string_length = strlen (normalize_filename (current_bfd));
1701 string_length += string_length & 1;
1702 fileoff += (SIZEOF_AR_HDR_BIG
1703 + string_length
1704 + SXCOFFARFMAG
1705 + arelt_size (current_bfd));
1706 fileoff += fileoff & 1;
1707 current_bfd = current_bfd->next;
1708 if (current_bfd != NULL)
1709 arch_info = bfd_get_arch_info (current_bfd);
1710 }
1711
1712 /* loop over the 32 bit symbol names */
1713 current_bfd = abfd->archive_head;
1714 if (current_bfd != NULL)
1715 arch_info = bfd_get_arch_info (current_bfd);
1716 i = 0;
1717 while (current_bfd != NULL && i < orl_count)
1718 {
1719 while (map[i].u.abfd == current_bfd)
1720 {
1721 if (arch_info->bits_per_address == 32)
1722 {
1723 string_length = sprintf (st, "%s", *map[i].name);
1724 st += string_length + 1;
1725 }
1726 i++;
1727 }
1728 current_bfd = current_bfd->next;
1729 if (current_bfd != NULL)
1730 arch_info = bfd_get_arch_info (current_bfd);
1731 }
1732
1733 bfd_bwrite (symbol_table, symbol_table_size, abfd);
1734
1735 free (symbol_table);
1736 symbol_table = NULL;
1737
1738 prevoff = nextoff;
1739 nextoff = nextoff + symbol_table_size;
1740 }
1741 else
1742 PRINT20 (fhdr->symoff, 0);
1743
1744 if (sym_64)
1745 {
1746 struct xcoff_ar_hdr_big *hdr;
1747 bfd_byte *symbol_table;
1748 bfd_byte *st;
1749 file_ptr fileoff;
1750
1751 bfd_vma symbol_table_size =
1752 SIZEOF_AR_HDR_BIG
1753 + SXCOFFARFMAG
1754 + 8
1755 + 8 * sym_64
1756 + str_64 + (str_64 & 1);
1757
1758 symbol_table = NULL;
1759 symbol_table = (bfd_byte *) bfd_malloc (symbol_table_size);
1760 if (symbol_table == NULL)
1761 return false;
1762 memset (symbol_table, 0, symbol_table_size);
1763
1764 hdr = (struct xcoff_ar_hdr_big *) symbol_table;
1765
1766 PRINT20 (hdr->size, 8 + 8 * sym_64 + str_64 + (str_64 & 1));
1767 PRINT20 (hdr->nextoff, 0);
1768 PRINT20 (hdr->prevoff, prevoff);
1769 PRINT12 (hdr->date, 0);
1770 PRINT12 (hdr->uid, 0);
1771 PRINT12 (hdr->gid, 0);
1772 PRINT12 (hdr->mode, 0);
1773 PRINT4 (hdr->namlen, 0);
1774
1775 st = symbol_table + SIZEOF_AR_HDR_BIG;
1776 memcpy (st, XCOFFARFMAG, SXCOFFARFMAG);
1777 st += SXCOFFARFMAG;
1778
1779 bfd_h_put_64 (abfd, sym_64, st);
1780 st += 8;
1781
1782 /* loop over the 64 bit offsets */
1783 current_bfd = abfd->archive_head;
1784 if (current_bfd != NULL)
1785 arch_info = bfd_get_arch_info (current_bfd);
1786 fileoff = SIZEOF_AR_FILE_HDR_BIG;
1787 i = 0;
1788 while (current_bfd != NULL && i < orl_count)
1789 {
1790 while (map[i].u.abfd == current_bfd)
1791 {
1792 if (arch_info->bits_per_address == 64)
1793 {
1794 bfd_h_put_64 (abfd, fileoff, st);
1795 st += 8;
1796 }
1797 i++;
1798 }
1799 string_length = strlen (normalize_filename (current_bfd));
1800 string_length += string_length & 1;
1801 fileoff += (SIZEOF_AR_HDR_BIG
1802 + string_length
1803 + SXCOFFARFMAG
1804 + arelt_size (current_bfd));
1805 fileoff += fileoff & 1;
1806 current_bfd = current_bfd->next;
1807 if (current_bfd != NULL)
1808 arch_info = bfd_get_arch_info (current_bfd);
1809 }
1810
1811 /* loop over the 64 bit symbol names */
1812 current_bfd = abfd->archive_head;
1813 if (current_bfd != NULL)
1814 arch_info = bfd_get_arch_info (current_bfd);
1815 i = 0;
1816 while (current_bfd != NULL && i < orl_count)
1817 {
1818 while (map[i].u.abfd == current_bfd)
1819 {
1820 if (arch_info->bits_per_address == 64)
1821 {
1822 string_length = sprintf (st, "%s", *map[i].name);
1823 st += string_length + 1;
1824 }
1825 i++;
1826 }
1827 current_bfd = current_bfd->next;
1828 if (current_bfd != NULL)
1829 arch_info = bfd_get_arch_info (current_bfd);
1830 }
1831
1832 bfd_bwrite (symbol_table, symbol_table_size, abfd);
1833
1834 free (symbol_table);
1835 symbol_table = NULL;
1836
1837 PRINT20 (fhdr->symoff64, nextoff);
1838 }
1839 else
1840 PRINT20 (fhdr->symoff64, 0);
1841
1842 return true;
1843 }
1844
1845 boolean
1846 _bfd_xcoff_write_armap (abfd, elength, map, orl_count, stridx)
1847 bfd *abfd;
1848 unsigned int elength ATTRIBUTE_UNUSED;
1849 struct orl *map;
1850 unsigned int orl_count;
1851 int stridx;
1852 {
1853 if (! xcoff_big_format_p (abfd))
1854 return xcoff_write_armap_old (abfd, elength, map, orl_count, stridx);
1855 else
1856 return xcoff_write_armap_big (abfd, elength, map, orl_count, stridx);
1857 }
1858
1859 /* Write out an XCOFF archive. We always write an entire archive,
1860 rather than fussing with the freelist and so forth. */
1861
1862 static boolean
1863 xcoff_write_archive_contents_old (abfd)
1864 bfd *abfd;
1865 {
1866 struct xcoff_ar_file_hdr fhdr;
1867 bfd_size_type count;
1868 bfd_size_type total_namlen;
1869 file_ptr *offsets;
1870 boolean makemap;
1871 boolean hasobjects;
1872 ufile_ptr prevoff, nextoff;
1873 bfd *sub;
1874 size_t i;
1875 struct xcoff_ar_hdr ahdr;
1876 bfd_size_type size;
1877 char *p;
1878 char decbuf[XCOFFARMAG_ELEMENT_SIZE + 1];
1879
1880 memset (&fhdr, 0, sizeof fhdr);
1881 strncpy (fhdr.magic, XCOFFARMAG, SXCOFFARMAG);
1882 sprintf (fhdr.firstmemoff, "%d", SIZEOF_AR_FILE_HDR);
1883 sprintf (fhdr.freeoff, "%d", 0);
1884
1885 count = 0;
1886 total_namlen = 0;
1887 for (sub = abfd->archive_head; sub != NULL; sub = sub->next)
1888 {
1889 ++count;
1890 total_namlen += strlen (normalize_filename (sub)) + 1;
1891 }
1892 offsets = (file_ptr *) bfd_alloc (abfd, count * sizeof (file_ptr));
1893 if (offsets == NULL)
1894 return false;
1895
1896 if (bfd_seek (abfd, (file_ptr) SIZEOF_AR_FILE_HDR, SEEK_SET) != 0)
1897 return false;
1898
1899 makemap = bfd_has_map (abfd);
1900 hasobjects = false;
1901 prevoff = 0;
1902 nextoff = SIZEOF_AR_FILE_HDR;
1903 for (sub = abfd->archive_head, i = 0; sub != NULL; sub = sub->next, i++)
1904 {
1905 const char *name;
1906 bfd_size_type namlen;
1907 struct xcoff_ar_hdr *ahdrp;
1908 bfd_size_type remaining;
1909
1910 if (makemap && ! hasobjects)
1911 {
1912 if (bfd_check_format (sub, bfd_object))
1913 hasobjects = true;
1914 }
1915
1916 name = normalize_filename (sub);
1917 namlen = strlen (name);
1918
1919 if (sub->arelt_data != NULL)
1920 ahdrp = arch_xhdr (sub);
1921 else
1922 ahdrp = NULL;
1923
1924 if (ahdrp == NULL)
1925 {
1926 struct stat s;
1927
1928 memset (&ahdr, 0, sizeof ahdr);
1929 ahdrp = &ahdr;
1930 if (stat (bfd_get_filename (sub), &s) != 0)
1931 {
1932 bfd_set_error (bfd_error_system_call);
1933 return false;
1934 }
1935
1936 sprintf (ahdrp->size, "%ld", (long) s.st_size);
1937 sprintf (ahdrp->date, "%ld", (long) s.st_mtime);
1938 sprintf (ahdrp->uid, "%ld", (long) s.st_uid);
1939 sprintf (ahdrp->gid, "%ld", (long) s.st_gid);
1940 sprintf (ahdrp->mode, "%o", (unsigned int) s.st_mode);
1941
1942 if (sub->arelt_data == NULL)
1943 {
1944 size = sizeof (struct areltdata);
1945 sub->arelt_data = bfd_alloc (sub, size);
1946 if (sub->arelt_data == NULL)
1947 return false;
1948 }
1949
1950 arch_eltdata (sub)->parsed_size = s.st_size;
1951 }
1952
1953 sprintf (ahdrp->prevoff, "%ld", (long) prevoff);
1954 sprintf (ahdrp->namlen, "%ld", (long) namlen);
1955
1956 /* If the length of the name is odd, we write out the null byte
1957 after the name as well. */
1958 namlen = (namlen + 1) &~ (bfd_size_type) 1;
1959
1960 remaining = arelt_size (sub);
1961 size = (SIZEOF_AR_HDR
1962 + namlen
1963 + SXCOFFARFMAG
1964 + remaining);
1965
1966 BFD_ASSERT (nextoff == bfd_tell (abfd));
1967
1968 offsets[i] = nextoff;
1969
1970 prevoff = nextoff;
1971 nextoff += size + (size & 1);
1972
1973 sprintf (ahdrp->nextoff, "%ld", (long) nextoff);
1974
1975 /* We need spaces, not null bytes, in the header. */
1976 for (p = (char *) ahdrp; p < (char *) ahdrp + SIZEOF_AR_HDR; p++)
1977 if (*p == '\0')
1978 *p = ' ';
1979
1980 if ((bfd_bwrite ((PTR) ahdrp, (bfd_size_type) SIZEOF_AR_HDR, abfd)
1981 != SIZEOF_AR_HDR)
1982 || (bfd_bwrite ((PTR) name, namlen, abfd) != namlen)
1983 || (bfd_bwrite ((PTR) XCOFFARFMAG, (bfd_size_type) SXCOFFARFMAG, abfd)
1984 != SXCOFFARFMAG))
1985 return false;
1986
1987 if (bfd_seek (sub, (file_ptr) 0, SEEK_SET) != 0)
1988 return false;
1989 while (remaining != 0)
1990 {
1991 bfd_size_type amt;
1992 bfd_byte buffer[DEFAULT_BUFFERSIZE];
1993
1994 amt = sizeof buffer;
1995 if (amt > remaining)
1996 amt = remaining;
1997 if (bfd_bread (buffer, amt, sub) != amt
1998 || bfd_bwrite (buffer, amt, abfd) != amt)
1999 return false;
2000 remaining -= amt;
2001 }
2002
2003 if ((size & 1) != 0)
2004 {
2005 bfd_byte b;
2006
2007 b = '\0';
2008 if (bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
2009 return false;
2010 }
2011 }
2012
2013 sprintf (fhdr.lastmemoff, "%ld", (long) prevoff);
2014
2015 /* Write out the member table. */
2016
2017 BFD_ASSERT (nextoff == bfd_tell (abfd));
2018 sprintf (fhdr.memoff, "%ld", (long) nextoff);
2019
2020 memset (&ahdr, 0, sizeof ahdr);
2021 sprintf (ahdr.size, "%ld", (long) (XCOFFARMAG_ELEMENT_SIZE +
2022 count * XCOFFARMAG_ELEMENT_SIZE +
2023 total_namlen));
2024 sprintf (ahdr.prevoff, "%ld", (long) prevoff);
2025 sprintf (ahdr.date, "%d", 0);
2026 sprintf (ahdr.uid, "%d", 0);
2027 sprintf (ahdr.gid, "%d", 0);
2028 sprintf (ahdr.mode, "%d", 0);
2029 sprintf (ahdr.namlen, "%d", 0);
2030
2031 size = (SIZEOF_AR_HDR
2032 + XCOFFARMAG_ELEMENT_SIZE
2033 + count * XCOFFARMAG_ELEMENT_SIZE
2034 + total_namlen
2035 + SXCOFFARFMAG);
2036
2037 prevoff = nextoff;
2038 nextoff += size + (size & 1);
2039
2040 if (makemap && hasobjects)
2041 sprintf (ahdr.nextoff, "%ld", (long) nextoff);
2042 else
2043 sprintf (ahdr.nextoff, "%d", 0);
2044
2045 /* We need spaces, not null bytes, in the header. */
2046 for (p = (char *) &ahdr; p < (char *) &ahdr + SIZEOF_AR_HDR; p++)
2047 if (*p == '\0')
2048 *p = ' ';
2049
2050 if ((bfd_bwrite ((PTR) &ahdr, (bfd_size_type) SIZEOF_AR_HDR, abfd)
2051 != SIZEOF_AR_HDR)
2052 || (bfd_bwrite ((PTR) XCOFFARFMAG, (bfd_size_type) SXCOFFARFMAG, abfd)
2053 != SXCOFFARFMAG))
2054 return false;
2055
2056 sprintf (decbuf, "%-12ld", (long) count);
2057 if (bfd_bwrite ((PTR) decbuf, (bfd_size_type) XCOFFARMAG_ELEMENT_SIZE, abfd)
2058 != XCOFFARMAG_ELEMENT_SIZE)
2059 return false;
2060 for (i = 0; i < (size_t) count; i++)
2061 {
2062 sprintf (decbuf, "%-12ld", (long) offsets[i]);
2063 if (bfd_bwrite ((PTR) decbuf, (bfd_size_type) XCOFFARMAG_ELEMENT_SIZE,
2064 abfd) != XCOFFARMAG_ELEMENT_SIZE)
2065 return false;
2066 }
2067 for (sub = abfd->archive_head; sub != NULL; sub = sub->next)
2068 {
2069 const char *name;
2070 bfd_size_type namlen;
2071
2072 name = normalize_filename (sub);
2073 namlen = strlen (name);
2074 if (bfd_bwrite ((PTR) name, namlen + 1, abfd) != namlen + 1)
2075 return false;
2076 }
2077 if ((size & 1) != 0)
2078 {
2079 bfd_byte b;
2080
2081 b = '\0';
2082 if (bfd_bwrite ((PTR) &b, (bfd_size_type) 1, abfd) != 1)
2083 return false;
2084 }
2085
2086 /* Write out the armap, if appropriate. */
2087 if (! makemap || ! hasobjects)
2088 sprintf (fhdr.symoff, "%d", 0);
2089 else
2090 {
2091 BFD_ASSERT (nextoff == bfd_tell (abfd));
2092 sprintf (fhdr.symoff, "%ld", (long) nextoff);
2093 bfd_ardata (abfd)->tdata = (PTR) &fhdr;
2094 if (! _bfd_compute_and_write_armap (abfd, 0))
2095 return false;
2096 }
2097
2098 /* Write out the archive file header. */
2099
2100 /* We need spaces, not null bytes, in the header. */
2101 for (p = (char *) &fhdr; p < (char *) &fhdr + SIZEOF_AR_FILE_HDR; p++)
2102 if (*p == '\0')
2103 *p = ' ';
2104
2105 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
2106 || (bfd_bwrite ((PTR) &fhdr, (bfd_size_type) SIZEOF_AR_FILE_HDR, abfd)
2107 != SIZEOF_AR_FILE_HDR))
2108 return false;
2109
2110 return true;
2111 }
2112
2113 static boolean
2114 xcoff_write_archive_contents_big (abfd)
2115 bfd *abfd;
2116 {
2117 struct xcoff_ar_file_hdr_big fhdr;
2118 bfd_size_type count;
2119 bfd_size_type total_namlen;
2120 file_ptr *offsets;
2121 boolean makemap;
2122 boolean hasobjects;
2123 ufile_ptr prevoff, nextoff;
2124 bfd *current_bfd;
2125 size_t i;
2126 struct xcoff_ar_hdr_big *hdr, ahdr;
2127 bfd_size_type size;
2128 bfd_byte *member_table, *mt;
2129 bfd_vma member_table_size;
2130
2131 memcpy (fhdr.magic, XCOFFARMAGBIG, SXCOFFARMAG);
2132 PRINT20 (fhdr.firstmemoff, SIZEOF_AR_FILE_HDR_BIG);
2133 PRINT20 (fhdr.freeoff, 0);
2134
2135 /* Calculate count and total_namlen */
2136 for (current_bfd = abfd->archive_head, count = 0, total_namlen = 0;
2137 current_bfd != NULL;
2138 current_bfd = current_bfd->next, count++)
2139 total_namlen += strlen (normalize_filename (current_bfd)) + 1;
2140
2141 offsets = NULL;
2142 if (count)
2143 {
2144 offsets = (file_ptr *) bfd_malloc (count * sizeof (file_ptr));
2145 if (offsets == NULL)
2146 return false;
2147 }
2148 if (bfd_seek (abfd, (file_ptr) SIZEOF_AR_FILE_HDR_BIG, SEEK_SET) != 0)
2149 return false;
2150
2151 makemap = bfd_has_map (abfd);
2152 hasobjects = false;
2153 prevoff = 0;
2154 nextoff = SIZEOF_AR_FILE_HDR_BIG;
2155 for (current_bfd = abfd->archive_head, i = 0;
2156 current_bfd != NULL;
2157 current_bfd = current_bfd->next, i++)
2158 {
2159 const char *name;
2160 bfd_size_type namlen;
2161 struct xcoff_ar_hdr_big *ahdrp;
2162 bfd_size_type remaining;
2163
2164 if (makemap && ! hasobjects)
2165 {
2166 if (bfd_check_format (current_bfd, bfd_object))
2167 hasobjects = true;
2168 }
2169
2170 name = normalize_filename (current_bfd);
2171 namlen = strlen (name);
2172
2173 if (current_bfd->arelt_data != NULL)
2174 ahdrp = arch_xhdr_big (current_bfd);
2175 else
2176 ahdrp = NULL;
2177
2178 if (ahdrp == NULL)
2179 {
2180 struct stat s;
2181
2182 ahdrp = &ahdr;
2183 /* XXX This should actually be a call to stat64 (at least on
2184 32-bit machines).
2185 XXX This call will fail if the original object is not found. */
2186 if (stat (bfd_get_filename (current_bfd), &s) != 0)
2187 {
2188 bfd_set_error (bfd_error_system_call);
2189 return false;
2190 }
2191
2192 PRINT20 (ahdrp->size, s.st_size);
2193 PRINT12 (ahdrp->date, s.st_mtime);
2194 PRINT12 (ahdrp->uid, s.st_uid);
2195 PRINT12 (ahdrp->gid, s.st_gid);
2196 PRINT12_OCTAL (ahdrp->mode, s.st_mode);
2197
2198 if (current_bfd->arelt_data == NULL)
2199 {
2200 size = sizeof (struct areltdata);
2201 current_bfd->arelt_data = bfd_alloc (current_bfd, size);
2202 if (current_bfd->arelt_data == NULL)
2203 return false;
2204 }
2205
2206 arch_eltdata (current_bfd)->parsed_size = s.st_size;
2207 }
2208
2209 PRINT20 (ahdrp->prevoff, prevoff);
2210 PRINT4 (ahdrp->namlen, namlen);
2211
2212 /* If the length of the name is odd, we write out the null byte
2213 after the name as well. */
2214 namlen = (namlen + 1) &~ (bfd_size_type) 1;
2215
2216 remaining = arelt_size (current_bfd);
2217 size = (SIZEOF_AR_HDR_BIG
2218 + namlen
2219 + SXCOFFARFMAG
2220 + remaining);
2221
2222 BFD_ASSERT (nextoff == bfd_tell (abfd));
2223
2224 offsets[i] = nextoff;
2225
2226 prevoff = nextoff;
2227 nextoff += size + (size & 1);
2228
2229 PRINT20 (ahdrp->nextoff, nextoff);
2230
2231 if ((bfd_bwrite ((PTR) ahdrp, (bfd_size_type) SIZEOF_AR_HDR_BIG, abfd)
2232 != SIZEOF_AR_HDR_BIG)
2233 || bfd_bwrite ((PTR) name, (bfd_size_type) namlen, abfd) != namlen
2234 || (bfd_bwrite ((PTR) XCOFFARFMAG, (bfd_size_type) SXCOFFARFMAG,
2235 abfd) != SXCOFFARFMAG))
2236 return false;
2237
2238 if (bfd_seek (current_bfd, (file_ptr) 0, SEEK_SET) != 0)
2239 return false;
2240 while (remaining != 0)
2241 {
2242 bfd_size_type amt;
2243 bfd_byte buffer[DEFAULT_BUFFERSIZE];
2244
2245 amt = sizeof buffer;
2246 if (amt > remaining)
2247 amt = remaining;
2248 if (bfd_bread (buffer, amt, current_bfd) != amt
2249 || bfd_bwrite (buffer, amt, abfd) != amt)
2250 return false;
2251 remaining -= amt;
2252 }
2253
2254 if ((size & 1) != 0)
2255 {
2256 bfd_byte b;
2257
2258 b = '\0';
2259 if (bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
2260 return false;
2261 }
2262 }
2263
2264 PRINT20 (fhdr.lastmemoff, prevoff);
2265
2266 /* Write out the member table.
2267 Layout :
2268
2269 standard big archive header
2270 0x0000 ar_size [0x14]
2271 0x0014 ar_nxtmem [0x14]
2272 0x0028 ar_prvmem [0x14]
2273 0x003C ar_date [0x0C]
2274 0x0048 ar_uid [0x0C]
2275 0x0054 ar_gid [0x0C]
2276 0x0060 ar_mod [0x0C]
2277 0x006C ar_namelen[0x04]
2278 0x0070 ar_fmag [0x02]
2279
2280 Member table
2281 0x0072 count [0x14]
2282 0x0086 offsets [0x14 * counts]
2283 0x0086 + 0x14 * counts names [??]
2284 ?? pad to even bytes.
2285 */
2286
2287 BFD_ASSERT (nextoff == bfd_tell (abfd));
2288
2289 member_table_size = (SIZEOF_AR_HDR_BIG
2290 + SXCOFFARFMAG
2291 + XCOFFARMAGBIG_ELEMENT_SIZE
2292 + count * XCOFFARMAGBIG_ELEMENT_SIZE
2293 + total_namlen);
2294
2295 member_table_size += member_table_size & 1;
2296 member_table = NULL;
2297 member_table = (bfd_byte *) bfd_malloc (member_table_size);
2298 if (member_table == NULL)
2299 return false;
2300 memset (member_table, 0, member_table_size);
2301
2302 hdr = (struct xcoff_ar_hdr_big *) member_table;
2303
2304 PRINT20 (hdr->size, (XCOFFARMAGBIG_ELEMENT_SIZE +
2305 count * XCOFFARMAGBIG_ELEMENT_SIZE +
2306 total_namlen + (total_namlen & 1)));
2307 if (makemap && hasobjects)
2308 PRINT20 (hdr->nextoff, nextoff + member_table_size);
2309 else
2310 PRINT20 (hdr->nextoff, 0);
2311 PRINT20 (hdr->prevoff, prevoff);
2312 PRINT12 (hdr->date, 0);
2313 PRINT12 (hdr->uid, 0);
2314 PRINT12 (hdr->gid, 0);
2315 PRINT12 (hdr->mode, 0);
2316 PRINT4 (hdr->namlen, 0);
2317
2318 mt = member_table + SIZEOF_AR_HDR_BIG;
2319 memcpy (mt, XCOFFARFMAG, SXCOFFARFMAG);
2320 mt += SXCOFFARFMAG;
2321
2322 PRINT20 (mt, count);
2323 mt += XCOFFARMAGBIG_ELEMENT_SIZE;
2324 for (i = 0; i < (size_t) count; i++)
2325 {
2326 PRINT20 (mt, offsets[i]);
2327 mt += XCOFFARMAGBIG_ELEMENT_SIZE;
2328 }
2329
2330 if (count)
2331 {
2332 free (offsets);
2333 offsets = NULL;
2334 }
2335
2336 for (current_bfd = abfd->archive_head; current_bfd != NULL;
2337 current_bfd = current_bfd->next)
2338 {
2339 const char *name;
2340 size_t namlen;
2341
2342 name = normalize_filename (current_bfd);
2343 namlen = sprintf(mt, "%s", name);
2344 mt += namlen + 1;
2345 }
2346
2347 if (bfd_bwrite (member_table, member_table_size, abfd) != member_table_size)
2348 return false;
2349
2350 free (member_table);
2351 member_table = NULL;
2352
2353 PRINT20 (fhdr.memoff, nextoff);
2354
2355 prevoff = nextoff;
2356 nextoff += member_table_size;
2357
2358 /* Write out the armap, if appropriate. */
2359
2360 if (! makemap || ! hasobjects)
2361 PRINT20 (fhdr.symoff, 0);
2362 else
2363 {
2364 BFD_ASSERT (nextoff == bfd_tell (abfd));
2365
2366 /* Save nextoff in fhdr.symoff so the armap routine can use it. */
2367 PRINT20 (fhdr.symoff, nextoff);
2368
2369 bfd_ardata (abfd)->tdata = (PTR) &fhdr;
2370 if (! _bfd_compute_and_write_armap (abfd, 0))
2371 return false;
2372 }
2373
2374 /* Write out the archive file header. */
2375
2376 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
2377 || (bfd_bwrite ((PTR) &fhdr, (bfd_size_type) SIZEOF_AR_FILE_HDR_BIG,
2378 abfd) != SIZEOF_AR_FILE_HDR_BIG))
2379 return false;
2380
2381 return true;
2382 }
2383
2384 boolean
2385 _bfd_xcoff_write_archive_contents (abfd)
2386 bfd *abfd;
2387 {
2388 if (! xcoff_big_format_p (abfd))
2389 return xcoff_write_archive_contents_old (abfd);
2390 else
2391 return xcoff_write_archive_contents_big (abfd);
2392 }
2393 \f
2394 /* We can't use the usual coff_sizeof_headers routine, because AIX
2395 always uses an a.out header. */
2396
2397 int
2398 _bfd_xcoff_sizeof_headers (abfd, reloc)
2399 bfd *abfd;
2400 boolean reloc ATTRIBUTE_UNUSED;
2401 {
2402 int size;
2403
2404 size = FILHSZ;
2405 if (xcoff_data (abfd)->full_aouthdr)
2406 size += AOUTSZ;
2407 else
2408 size += SMALL_AOUTSZ;
2409 size += abfd->section_count * SCNHSZ;
2410 return size;
2411 }
2412 \f
2413 /* Routines to swap information in the XCOFF .loader section. If we
2414 ever need to write an XCOFF loader, this stuff will need to be
2415 moved to another file shared by the linker (which XCOFF calls the
2416 ``binder'') and the loader. */
2417
2418 /* Swap in the ldhdr structure. */
2419
2420 static void
2421 xcoff_swap_ldhdr_in (abfd, s, dst)
2422 bfd *abfd;
2423 const PTR s;
2424 struct internal_ldhdr *dst;
2425 {
2426 const struct external_ldhdr *src = (const struct external_ldhdr *) s;
2427
2428 dst->l_version = bfd_get_32 (abfd, src->l_version);
2429 dst->l_nsyms = bfd_get_32 (abfd, src->l_nsyms);
2430 dst->l_nreloc = bfd_get_32 (abfd, src->l_nreloc);
2431 dst->l_istlen = bfd_get_32 (abfd, src->l_istlen);
2432 dst->l_nimpid = bfd_get_32 (abfd, src->l_nimpid);
2433 dst->l_impoff = bfd_get_32 (abfd, src->l_impoff);
2434 dst->l_stlen = bfd_get_32 (abfd, src->l_stlen);
2435 dst->l_stoff = bfd_get_32 (abfd, src->l_stoff);
2436 }
2437
2438 /* Swap out the ldhdr structure. */
2439
2440 static void
2441 xcoff_swap_ldhdr_out (abfd, src, d)
2442 bfd *abfd;
2443 const struct internal_ldhdr *src;
2444 PTR d;
2445 {
2446 struct external_ldhdr *dst = (struct external_ldhdr *) d;
2447
2448 bfd_put_32 (abfd, (bfd_vma) src->l_version, dst->l_version);
2449 bfd_put_32 (abfd, src->l_nsyms, dst->l_nsyms);
2450 bfd_put_32 (abfd, src->l_nreloc, dst->l_nreloc);
2451 bfd_put_32 (abfd, src->l_istlen, dst->l_istlen);
2452 bfd_put_32 (abfd, src->l_nimpid, dst->l_nimpid);
2453 bfd_put_32 (abfd, src->l_impoff, dst->l_impoff);
2454 bfd_put_32 (abfd, src->l_stlen, dst->l_stlen);
2455 bfd_put_32 (abfd, src->l_stoff, dst->l_stoff);
2456 }
2457
2458 /* Swap in the ldsym structure. */
2459
2460 static void
2461 xcoff_swap_ldsym_in (abfd, s, dst)
2462 bfd *abfd;
2463 const PTR s;
2464 struct internal_ldsym *dst;
2465 {
2466 const struct external_ldsym *src = (const struct external_ldsym *) s;
2467
2468 if (bfd_get_32 (abfd, src->_l._l_l._l_zeroes) != 0) {
2469 memcpy (dst->_l._l_name, src->_l._l_name, SYMNMLEN);
2470 } else {
2471 dst->_l._l_l._l_zeroes = 0;
2472 dst->_l._l_l._l_offset = bfd_get_32 (abfd, src->_l._l_l._l_offset);
2473 }
2474 dst->l_value = bfd_get_32 (abfd, src->l_value);
2475 dst->l_scnum = bfd_get_16 (abfd, src->l_scnum);
2476 dst->l_smtype = bfd_get_8 (abfd, src->l_smtype);
2477 dst->l_smclas = bfd_get_8 (abfd, src->l_smclas);
2478 dst->l_ifile = bfd_get_32 (abfd, src->l_ifile);
2479 dst->l_parm = bfd_get_32 (abfd, src->l_parm);
2480 }
2481
2482 /* Swap out the ldsym structure. */
2483
2484 static void
2485 xcoff_swap_ldsym_out (abfd, src, d)
2486 bfd *abfd;
2487 const struct internal_ldsym *src;
2488 PTR d;
2489 {
2490 struct external_ldsym *dst = (struct external_ldsym *) d;
2491
2492 if (src->_l._l_l._l_zeroes != 0)
2493 memcpy (dst->_l._l_name, src->_l._l_name, SYMNMLEN);
2494 else
2495 {
2496 bfd_put_32 (abfd, (bfd_vma) 0, dst->_l._l_l._l_zeroes);
2497 bfd_put_32 (abfd, (bfd_vma) src->_l._l_l._l_offset,
2498 dst->_l._l_l._l_offset);
2499 }
2500 bfd_put_32 (abfd, src->l_value, dst->l_value);
2501 bfd_put_16 (abfd, (bfd_vma) src->l_scnum, dst->l_scnum);
2502 bfd_put_8 (abfd, src->l_smtype, dst->l_smtype);
2503 bfd_put_8 (abfd, src->l_smclas, dst->l_smclas);
2504 bfd_put_32 (abfd, src->l_ifile, dst->l_ifile);
2505 bfd_put_32 (abfd, src->l_parm, dst->l_parm);
2506 }
2507
2508 /* Swap in the ldrel structure. */
2509
2510 static void
2511 xcoff_swap_ldrel_in (abfd, s, dst)
2512 bfd *abfd;
2513 const PTR s;
2514 struct internal_ldrel *dst;
2515 {
2516 const struct external_ldrel *src = (const struct external_ldrel *) s;
2517
2518 dst->l_vaddr = bfd_get_32 (abfd, src->l_vaddr);
2519 dst->l_symndx = bfd_get_32 (abfd, src->l_symndx);
2520 dst->l_rtype = bfd_get_16 (abfd, src->l_rtype);
2521 dst->l_rsecnm = bfd_get_16 (abfd, src->l_rsecnm);
2522 }
2523
2524 /* Swap out the ldrel structure. */
2525
2526 static void
2527 xcoff_swap_ldrel_out (abfd, src, d)
2528 bfd *abfd;
2529 const struct internal_ldrel *src;
2530 PTR d;
2531 {
2532 struct external_ldrel *dst = (struct external_ldrel *) d;
2533
2534 bfd_put_32 (abfd, src->l_vaddr, dst->l_vaddr);
2535 bfd_put_32 (abfd, src->l_symndx, dst->l_symndx);
2536 bfd_put_16 (abfd, (bfd_vma) src->l_rtype, dst->l_rtype);
2537 bfd_put_16 (abfd, (bfd_vma) src->l_rsecnm, dst->l_rsecnm);
2538 }
2539 \f
2540
2541
2542 /* This is the relocation function for the RS/6000/POWER/PowerPC.
2543 This is currently the only processor which uses XCOFF; I hope that
2544 will never change. */
2545
2546 static boolean
2547 xcoff_ppc_relocate_section (output_bfd, info, input_bfd,
2548 input_section, contents, relocs, syms,
2549 sections)
2550 bfd *output_bfd;
2551 struct bfd_link_info *info;
2552 bfd *input_bfd;
2553 asection *input_section;
2554 bfd_byte *contents;
2555 struct internal_reloc *relocs;
2556 struct internal_syment *syms;
2557 asection **sections;
2558 {
2559 struct internal_reloc *rel;
2560 struct internal_reloc *relend;
2561
2562 rel = relocs;
2563 relend = rel + input_section->reloc_count;
2564
2565 for (; rel < relend; rel++)
2566 {
2567 long symndx;
2568 struct xcoff_link_hash_entry *h;
2569 struct internal_syment *sym;
2570 bfd_vma addend;
2571 bfd_vma val;
2572 struct reloc_howto_struct howto;
2573 bfd_reloc_status_type rstat;
2574
2575 /* Relocation type R_REF is a special relocation type which is
2576 merely used to prevent garbage collection from occurring for
2577 the csect including the symbol which it references. */
2578 if (rel->r_type == R_REF)
2579 continue;
2580
2581 symndx = rel->r_symndx;
2582
2583 if (symndx == -1)
2584 {
2585 h = NULL;
2586 sym = NULL;
2587 addend = 0;
2588 }
2589 else
2590 {
2591 h = obj_xcoff_sym_hashes (input_bfd)[symndx];
2592 sym = syms + symndx;
2593 addend = - sym->n_value;
2594
2595 }
2596
2597 /* We build the howto information on the fly. */
2598
2599 howto.type = rel->r_type;
2600 howto.rightshift = 0;
2601 howto.size = 2;
2602 howto.bitsize = (rel->r_size & 0x1f) + 1;
2603 howto.pc_relative = false;
2604 howto.bitpos = 0;
2605 if ((rel->r_size & 0x80) != 0)
2606 howto.complain_on_overflow = complain_overflow_signed;
2607 else
2608 howto.complain_on_overflow = complain_overflow_bitfield;
2609 howto.special_function = NULL;
2610 howto.name = "internal";
2611 howto.partial_inplace = true;
2612 if (howto.bitsize == 32)
2613 howto.src_mask = howto.dst_mask = 0xffffffff;
2614 else
2615 {
2616 howto.src_mask = howto.dst_mask = (1 << howto.bitsize) - 1;
2617 if (howto.bitsize == 16)
2618 howto.size = 1;
2619 }
2620 howto.pcrel_offset = false;
2621
2622 val = 0;
2623
2624 if (h == NULL)
2625 {
2626 asection *sec;
2627
2628 if (symndx == -1)
2629 {
2630 sec = bfd_abs_section_ptr;
2631 val = 0;
2632 }
2633 else
2634 {
2635 sec = sections[symndx];
2636 /* Hack to make sure we use the right TOC anchor value
2637 if this reloc is against the TOC anchor. */
2638
2639 if (sec->name[3] == '0'
2640 && strcmp (sec->name, ".tc0") == 0)
2641 {
2642 val = xcoff_data (output_bfd)->toc;
2643 }
2644 else
2645 {
2646 val = (sec->output_section->vma
2647 + sec->output_offset
2648 + sym->n_value
2649 - sec->vma);
2650 }
2651 }
2652 }
2653 else
2654 {
2655 if (h->root.type == bfd_link_hash_defined
2656 || h->root.type == bfd_link_hash_defweak)
2657 {
2658 asection *sec;
2659
2660 sec = h->root.u.def.section;
2661 val = (h->root.u.def.value
2662 + sec->output_section->vma
2663 + sec->output_offset);
2664 }
2665 else if (h->root.type == bfd_link_hash_common)
2666 {
2667 asection *sec;
2668
2669 sec = h->root.u.c.p->section;
2670 val = (sec->output_section->vma
2671 + sec->output_offset);
2672 }
2673 else if ((h->flags & XCOFF_DEF_DYNAMIC) != 0
2674 || (h->flags & XCOFF_IMPORT) != 0)
2675 {
2676 /* Every symbol in a shared object is defined somewhere. */
2677 val = 0;
2678 }
2679 else if (! info->relocateable)
2680 {
2681 if (! ((*info->callbacks->undefined_symbol)
2682 (info, h->root.root.string, input_bfd, input_section,
2683 rel->r_vaddr - input_section->vma, true)))
2684 return false;
2685
2686 /* Don't try to process the reloc. It can't help, and
2687 it may generate another error. */
2688 continue;
2689 }
2690 }
2691
2692 /* I took the relocation type definitions from two documents:
2693 the PowerPC AIX Version 4 Application Binary Interface, First
2694 Edition (April 1992), and the PowerOpen ABI, Big-Endian
2695 32-Bit Hardware Implementation (June 30, 1994). Differences
2696 between the documents are noted below. */
2697
2698 switch (rel->r_type)
2699 {
2700 case R_RTB:
2701 case R_RRTBI:
2702 case R_RRTBA:
2703 /* These relocs are defined by the PowerPC ABI to be
2704 relative branches which use half of the difference
2705 between the symbol and the program counter. I can't
2706 quite figure out when this is useful. These relocs are
2707 not defined by the PowerOpen ABI. */
2708 default:
2709 (*_bfd_error_handler)
2710 (_("%s: unsupported relocation type 0x%02x"),
2711 bfd_archive_filename (input_bfd), (unsigned int) rel->r_type);
2712 bfd_set_error (bfd_error_bad_value);
2713 return false;
2714 case R_POS:
2715 /* Simple positive relocation. */
2716 break;
2717 case R_NEG:
2718 /* Simple negative relocation. */
2719 val = - val;
2720 break;
2721 case R_REL:
2722 /* Simple PC relative relocation. */
2723 howto.pc_relative = true;
2724 break;
2725 case R_TOC:
2726 /* TOC relative relocation. The value in the instruction in
2727 the input file is the offset from the input file TOC to
2728 the desired location. We want the offset from the final
2729 TOC to the desired location. We have:
2730 isym = iTOC + in
2731 iinsn = in + o
2732 osym = oTOC + on
2733 oinsn = on + o
2734 so we must change insn by on - in.
2735 */
2736 case R_GL:
2737 /* Global linkage relocation. The value of this relocation
2738 is the address of the entry in the TOC section. */
2739 case R_TCL:
2740 /* Local object TOC address. I can't figure out the
2741 difference between this and case R_GL. */
2742 case R_TRL:
2743 /* TOC relative relocation. A TOC relative load instruction
2744 which may be changed to a load address instruction.
2745 FIXME: We don't currently implement this optimization. */
2746 case R_TRLA:
2747 /* TOC relative relocation. This is a TOC relative load
2748 address instruction which may be changed to a load
2749 instruction. FIXME: I don't know if this is the correct
2750 implementation. */
2751 if (h != NULL && h->smclas != XMC_TD)
2752 {
2753 if (h->toc_section == NULL)
2754 {
2755 (*_bfd_error_handler)
2756 (_("%s: TOC reloc at 0x%x to symbol `%s' with no TOC entry"),
2757 bfd_archive_filename (input_bfd), rel->r_vaddr,
2758 h->root.root.string);
2759 bfd_set_error (bfd_error_bad_value);
2760 return false;
2761 }
2762
2763 BFD_ASSERT ((h->flags & XCOFF_SET_TOC) == 0);
2764 val = (h->toc_section->output_section->vma
2765 + h->toc_section->output_offset);
2766 }
2767
2768 val = ((val - xcoff_data (output_bfd)->toc)
2769 - (sym->n_value - xcoff_data (input_bfd)->toc));
2770 addend = 0;
2771 break;
2772 case R_BA:
2773 /* Absolute branch. We don't want to mess with the lower
2774 two bits of the instruction. */
2775 case R_CAI:
2776 /* The PowerPC ABI defines this as an absolute call which
2777 may be modified to become a relative call. The PowerOpen
2778 ABI does not define this relocation type. */
2779 case R_RBA:
2780 /* Absolute branch which may be modified to become a
2781 relative branch. */
2782 case R_RBAC:
2783 /* The PowerPC ABI defines this as an absolute branch to a
2784 fixed address which may be modified to an absolute branch
2785 to a symbol. The PowerOpen ABI does not define this
2786 relocation type. */
2787 case R_RBRC:
2788 /* The PowerPC ABI defines this as an absolute branch to a
2789 fixed address which may be modified to a relative branch.
2790 The PowerOpen ABI does not define this relocation type. */
2791 howto.src_mask &= ~3;
2792 howto.dst_mask = howto.src_mask;
2793 break;
2794 case R_BR:
2795 /* Relative branch. We don't want to mess with the lower
2796 two bits of the instruction. */
2797 case R_CREL:
2798 /* The PowerPC ABI defines this as a relative call which may
2799 be modified to become an absolute call. The PowerOpen
2800 ABI does not define this relocation type. */
2801 case R_RBR:
2802 /* A relative branch which may be modified to become an
2803 absolute branch. FIXME: We don't implement this,
2804 although we should for symbols of storage mapping class
2805 XMC_XO. */
2806 howto.pc_relative = true;
2807 howto.src_mask &= ~3;
2808 howto.dst_mask = howto.src_mask;
2809 break;
2810 case R_RL:
2811 /* The PowerPC AIX ABI describes this as a load which may be
2812 changed to a load address. The PowerOpen ABI says this
2813 is the same as case R_POS. */
2814 break;
2815 case R_RLA:
2816 /* The PowerPC AIX ABI describes this as a load address
2817 which may be changed to a load. The PowerOpen ABI says
2818 this is the same as R_POS. */
2819 break;
2820 }
2821
2822 /* If we see an R_BR or R_RBR reloc which is jumping to global
2823 linkage code, and it is followed by an appropriate cror nop
2824 instruction, we replace the cror with lwz r2,20(r1). This
2825 restores the TOC after the glink code. Contrariwise, if the
2826 call is followed by a lwz r2,20(r1), but the call is not
2827 going to global linkage code, we can replace the load with a
2828 cror. */
2829 if ((rel->r_type == R_BR || rel->r_type == R_RBR)
2830 && h != NULL
2831 && h->root.type == bfd_link_hash_defined
2832 && (rel->r_vaddr - input_section->vma + 8
2833 <= input_section->_cooked_size))
2834 {
2835 bfd_byte *pnext;
2836 unsigned long next;
2837
2838 pnext = contents + (rel->r_vaddr - input_section->vma) + 4;
2839 next = bfd_get_32 (input_bfd, pnext);
2840
2841 /* The _ptrgl function is magic. It is used by the AIX
2842 compiler to call a function through a pointer. */
2843 if (h->smclas == XMC_GL
2844 || strcmp (h->root.root.string, "._ptrgl") == 0)
2845 {
2846 if (next == 0x4def7b82 /* cror 15,15,15 */
2847 || next == 0x4ffffb82 /* cror 31,31,31 */
2848 || next == 0x60000000) /* ori r0,r0,0 */
2849 bfd_put_32 (input_bfd,
2850 (bfd_vma) 0x80410014, /* lwz r1,20(r1) */
2851 pnext);
2852 }
2853 else
2854 {
2855 if (next == 0x80410014) /* lwz r1,20(r1) */
2856 bfd_put_32 (input_bfd,
2857 (bfd_vma) 0x60000000, /* ori r0,r0,0 */
2858 pnext);
2859 }
2860 }
2861
2862 /* A PC relative reloc includes the section address. */
2863 if (howto.pc_relative)
2864 addend += input_section->vma;
2865
2866 rstat = _bfd_final_link_relocate (&howto, input_bfd, input_section,
2867 contents,
2868 rel->r_vaddr - input_section->vma,
2869 val, addend);
2870
2871 switch (rstat)
2872 {
2873 default:
2874 abort ();
2875 case bfd_reloc_ok:
2876 break;
2877 case bfd_reloc_overflow:
2878 {
2879 const char *name;
2880 char buf[SYMNMLEN + 1];
2881 char howto_name[10];
2882
2883 if (symndx == -1)
2884 name = "*ABS*";
2885 else if (h != NULL)
2886 name = h->root.root.string;
2887 else
2888 {
2889 name = _bfd_coff_internal_syment_name (input_bfd, sym, buf);
2890
2891 if (name == NULL)
2892 return false;
2893 }
2894 sprintf (howto_name, "0x%02x", rel->r_type);
2895
2896 if (! ((*info->callbacks->reloc_overflow)
2897 (info, name, howto_name, (bfd_vma) 0, input_bfd,
2898 input_section, rel->r_vaddr - input_section->vma)))
2899 return false;
2900 }
2901 }
2902 }
2903
2904 return true;
2905 }
2906
2907 static boolean
2908 _bfd_xcoff_put_ldsymbol_name (abfd, ldinfo, ldsym, name)
2909 bfd *abfd ATTRIBUTE_UNUSED;
2910 struct xcoff_loader_info *ldinfo;
2911 struct internal_ldsym *ldsym;
2912 const char *name;
2913 {
2914 size_t len;
2915 len = strlen (name);
2916
2917 if (len <= SYMNMLEN)
2918 strncpy (ldsym->_l._l_name, name, SYMNMLEN);
2919 else
2920 {
2921 if (ldinfo->string_size + len + 3 > ldinfo->string_alc)
2922 {
2923 bfd_size_type newalc;
2924 bfd_byte *newstrings;
2925
2926 newalc = ldinfo->string_alc * 2;
2927 if (newalc == 0)
2928 newalc = 32;
2929 while (ldinfo->string_size + len + 3 > newalc)
2930 newalc *= 2;
2931
2932 newstrings = ((bfd_byte *)
2933 bfd_realloc ((PTR) ldinfo->strings, newalc));
2934 if (newstrings == NULL)
2935 {
2936 ldinfo->failed = true;
2937 return false;
2938 }
2939 ldinfo->string_alc = newalc;
2940 ldinfo->strings = newstrings;
2941 }
2942
2943 bfd_put_16 (ldinfo->output_bfd, (bfd_vma) (len + 1),
2944 ldinfo->strings + ldinfo->string_size);
2945 strcpy (ldinfo->strings + ldinfo->string_size + 2, name);
2946 ldsym->_l._l_l._l_zeroes = 0;
2947 ldsym->_l._l_l._l_offset = ldinfo->string_size + 2;
2948 ldinfo->string_size += len + 3;
2949 }
2950
2951 return true;
2952 }
2953
2954 static boolean
2955 _bfd_xcoff_put_symbol_name (bfd *abfd, struct bfd_strtab_hash *strtab,
2956 struct internal_syment *sym,
2957 const char *name)
2958 {
2959 if (strlen (name) <= SYMNMLEN)
2960 {
2961 strncpy (sym->_n._n_name, name, SYMNMLEN);
2962 }
2963 else
2964 {
2965 boolean hash;
2966 bfd_size_type indx;
2967
2968 hash = true;
2969 if ((abfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
2970 hash = false;
2971 indx = _bfd_stringtab_add (strtab, name, hash, false);
2972 if (indx == (bfd_size_type) -1)
2973 return false;
2974 sym->_n._n_n._n_zeroes = 0;
2975 sym->_n._n_n._n_offset = STRING_SIZE_SIZE + indx;
2976 }
2977 return true;
2978 }
2979
2980 static asection *
2981 xcoff_create_csect_from_smclas (abfd, aux, symbol_name)
2982 bfd *abfd;
2983 union internal_auxent *aux;
2984 const char *symbol_name;
2985 {
2986 asection *return_value = NULL;
2987
2988 /* .sv64 = x_smclas == 17
2989 This is an invalid csect for 32 bit apps. */
2990 static const char *names[19] =
2991 {
2992 ".pr", ".ro", ".db", ".tc", ".ua", ".rw", ".gl", ".xo",
2993 ".sv", ".bs", ".ds", ".uc", ".ti", ".tb", NULL, ".tc0",
2994 ".td", NULL, ".sv3264"
2995 };
2996
2997 if ((19 >= aux->x_csect.x_smclas) &&
2998 (NULL != names[aux->x_csect.x_smclas]))
2999 {
3000 return_value = bfd_make_section_anyway
3001 (abfd, names[aux->x_csect.x_smclas]);
3002 }
3003 else
3004 {
3005 (*_bfd_error_handler)
3006 (_("%s: symbol `%s' has unrecognized smclas %d"),
3007 bfd_archive_filename (abfd), symbol_name, aux->x_csect.x_smclas);
3008 bfd_set_error (bfd_error_bad_value);
3009 }
3010
3011 return return_value;
3012 }
3013
3014 static boolean
3015 xcoff_is_lineno_count_overflow (abfd, value)
3016 bfd *abfd ATTRIBUTE_UNUSED;
3017 bfd_vma value;
3018 {
3019 if (0xffff <= value)
3020 return true;
3021
3022 return false;
3023 }
3024
3025 static boolean
3026 xcoff_is_reloc_count_overflow (abfd, value)
3027 bfd *abfd ATTRIBUTE_UNUSED;
3028 bfd_vma value;
3029 {
3030 if (0xffff <= value)
3031 return true;
3032
3033 return false;
3034 }
3035
3036 static bfd_vma
3037 xcoff_loader_symbol_offset (abfd, ldhdr)
3038 bfd *abfd;
3039 struct internal_ldhdr *ldhdr ATTRIBUTE_UNUSED;
3040 {
3041 return bfd_xcoff_ldhdrsz(abfd);
3042 }
3043
3044 static bfd_vma
3045 xcoff_loader_reloc_offset (abfd, ldhdr)
3046 bfd *abfd;
3047 struct internal_ldhdr *ldhdr;
3048 {
3049 return bfd_xcoff_ldhdrsz(abfd) +
3050 (ldhdr->l_nsyms * bfd_xcoff_ldsymsz(abfd));
3051 }
3052
3053 static boolean
3054 xcoff_generate_rtinit (abfd, init, fini)
3055 bfd *abfd;
3056 const char *init;
3057 const char *fini;
3058 {
3059 bfd_byte filehdr_ext[FILHSZ];
3060 bfd_byte scnhdr_ext[SCNHSZ];
3061 bfd_byte syment_ext[SYMESZ * 8];
3062 bfd_byte reloc_ext[RELSZ * 2];
3063 bfd_byte *data_buffer;
3064 bfd_size_type data_buffer_size;
3065 bfd_byte *string_table, *st_tmp;
3066 bfd_size_type string_table_size;
3067 bfd_vma val;
3068 size_t initsz, finisz;
3069 struct internal_filehdr filehdr;
3070 struct internal_scnhdr scnhdr;
3071 struct internal_syment syment;
3072 union internal_auxent auxent;
3073 struct internal_reloc reloc;
3074
3075 char *data_name = ".data";
3076 char *rtinit_name = "__rtinit";
3077
3078 if (! bfd_xcoff_rtinit_size (abfd)
3079 || (init == NULL && fini == NULL))
3080 return false;
3081
3082 initsz = (init == NULL ? 0 : 1 + strlen (init));
3083 finisz = (fini == NULL ? 0 : 1 + strlen (fini));
3084
3085 /* file header */
3086 memset (filehdr_ext, 0, FILHSZ);
3087 memset (&filehdr, 0, sizeof (struct internal_filehdr));
3088 filehdr.f_magic = bfd_xcoff_magic_number (abfd);
3089 filehdr.f_nscns = 1;
3090 filehdr.f_timdat = 0;
3091 filehdr.f_nsyms = 0; /* at least 6, no more than 8 */
3092 filehdr.f_symptr = 0; /* set below */
3093 filehdr.f_opthdr = 0;
3094 filehdr.f_flags = 0;
3095
3096 /* section header */
3097 memset (scnhdr_ext, 0, SCNHSZ);
3098 memset (&scnhdr, 0, sizeof (struct internal_scnhdr));
3099 memcpy (scnhdr.s_name, data_name, strlen (data_name));
3100 scnhdr.s_paddr = 0;
3101 scnhdr.s_vaddr = 0;
3102 scnhdr.s_size = 0; /* set below */
3103 scnhdr.s_scnptr = FILHSZ + SCNHSZ;
3104 scnhdr.s_relptr = 0; /* set below */
3105 scnhdr.s_lnnoptr = 0;
3106 scnhdr.s_nreloc = 0; /* either 1 or 2 */
3107 scnhdr.s_nlnno = 0;
3108 scnhdr.s_flags = STYP_DATA;
3109
3110 /* .data
3111 0x0000 0x00000000 : rtl
3112 0x0004 0x00000010 : offset to init, or 0
3113 0x0008 0x00000028 : offset to fini, or 0
3114 0x000C 0x0000000C : size of descriptor
3115 0x0010 0x00000000 : init, needs a reloc
3116 0x0014 0x00000040 : offset to init name
3117 0x0018 0x00000000 : flags, padded to a word
3118 0x001C 0x00000000 : empty init
3119 0x0020 0x00000000 :
3120 0x0024 0x00000000 :
3121 0x0028 0x00000000 : fini, needs a reloc
3122 0x002C 0x00000??? : offset to fini name
3123 0x0030 0x00000000 : flags, padded to a word
3124 0x0034 0x00000000 : empty fini
3125 0x0038 0x00000000 :
3126 0x003C 0x00000000 :
3127 0x0040 init name
3128 0x0040 + initsz fini name */
3129
3130 data_buffer_size = 0x0040 + initsz + finisz;
3131 data_buffer_size += (data_buffer_size & 7) ? 8 - (data_buffer_size & 7) : 0;
3132 data_buffer = NULL;
3133 data_buffer = (bfd_byte *) bfd_malloc (data_buffer_size);
3134 if (data_buffer == NULL)
3135 return false;
3136
3137 memset (data_buffer, 0, data_buffer_size);
3138
3139 if (initsz)
3140 {
3141 val = 0x10;
3142 bfd_h_put_32 (abfd, val, &data_buffer[0x04]);
3143 val = 0x40;
3144 bfd_h_put_32 (abfd, val, &data_buffer[0x14]);
3145 memcpy (&data_buffer[val], init, initsz);
3146 }
3147
3148 if (finisz)
3149 {
3150 val = 0x28;
3151 bfd_h_put_32 (abfd, val, &data_buffer[0x08]);
3152 val = 0x40 + initsz;
3153 bfd_h_put_32 (abfd, val, &data_buffer[0x2C]);
3154 memcpy (&data_buffer[val], fini, finisz);
3155 }
3156
3157 val = 0x0C;
3158 bfd_h_put_32 (abfd, val, &data_buffer[0x0C]);
3159
3160 scnhdr.s_size = data_buffer_size;
3161
3162 /* string table */
3163 string_table_size = 0;
3164 if (initsz > 9)
3165 string_table_size += initsz;
3166 if (finisz > 9)
3167 string_table_size += finisz;
3168 if (string_table_size)
3169 {
3170 string_table_size += 4;
3171 string_table = (bfd_byte *)bfd_malloc (string_table_size);
3172 memset (string_table, 0, string_table_size);
3173 val = string_table_size;
3174 bfd_h_put_32 (abfd, val, &string_table[0]);
3175 st_tmp = string_table + 4;
3176 }
3177
3178 /* symbols
3179 0. .data csect
3180 2. __rtinit
3181 4. init function
3182 6. fini function */
3183 memset (syment_ext, 0, 8 * SYMESZ);
3184 memset (reloc_ext, 0, 2 * RELSZ);
3185
3186 /* .data csect */
3187 memset (&syment, 0, sizeof (struct internal_syment));
3188 memset (&auxent, 0, sizeof (union internal_auxent));
3189 memcpy (syment._n._n_name, data_name, strlen (data_name));
3190 syment.n_scnum = 1;
3191 syment.n_sclass = C_HIDEXT;
3192 syment.n_numaux = 1;
3193 auxent.x_csect.x_scnlen.l = data_buffer_size;
3194 auxent.x_csect.x_smtyp = 3 << 3 | XTY_SD;
3195 auxent.x_csect.x_smclas = XMC_RW;
3196 bfd_coff_swap_sym_out (abfd, &syment,
3197 &syment_ext[filehdr.f_nsyms * SYMESZ]);
3198 bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
3199 syment.n_numaux,
3200 &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
3201 filehdr.f_nsyms += 2;
3202
3203 /* __rtinit */
3204 memset (&syment, 0, sizeof (struct internal_syment));
3205 memset (&auxent, 0, sizeof (union internal_auxent));
3206 memcpy (syment._n._n_name, rtinit_name, strlen (rtinit_name));
3207 syment.n_scnum = 1;
3208 syment.n_sclass = C_EXT;
3209 syment.n_numaux = 1;
3210 auxent.x_csect.x_smtyp = XTY_LD;
3211 auxent.x_csect.x_smclas = XMC_RW;
3212 bfd_coff_swap_sym_out (abfd, &syment,
3213 &syment_ext[filehdr.f_nsyms * SYMESZ]);
3214 bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
3215 syment.n_numaux,
3216 &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
3217 filehdr.f_nsyms += 2;
3218
3219 /* init */
3220 if (initsz)
3221 {
3222 memset (&syment, 0, sizeof (struct internal_syment));
3223 memset (&auxent, 0, sizeof (union internal_auxent));
3224
3225 if (initsz > 9)
3226 {
3227 syment._n._n_n._n_offset = st_tmp - string_table;
3228 memcpy (st_tmp, init, initsz);
3229 st_tmp += initsz;
3230 }
3231 else
3232 memcpy (syment._n._n_name, init, initsz - 1);
3233
3234 syment.n_sclass = C_EXT;
3235 syment.n_numaux = 1;
3236 bfd_coff_swap_sym_out (abfd, &syment,
3237 &syment_ext[filehdr.f_nsyms * SYMESZ]);
3238 bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
3239 syment.n_numaux,
3240 &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
3241
3242 /* reloc */
3243 memset (&reloc, 0, sizeof (struct internal_reloc));
3244 reloc.r_vaddr = 0x0010;
3245 reloc.r_symndx = filehdr.f_nsyms;
3246 reloc.r_type = R_POS;
3247 reloc.r_size = 31;
3248 bfd_coff_swap_reloc_out (abfd, &reloc, &reloc_ext[0]);
3249
3250 filehdr.f_nsyms += 2;
3251 scnhdr.s_nreloc += 1;
3252 }
3253
3254 /* fini */
3255 if (finisz)
3256 {
3257 memset (&syment, 0, sizeof (struct internal_syment));
3258 memset (&auxent, 0, sizeof (union internal_auxent));
3259
3260 if (finisz > 9)
3261 {
3262 syment._n._n_n._n_offset = st_tmp - string_table;
3263 memcpy (st_tmp, fini, finisz);
3264 st_tmp += finisz;
3265 }
3266 else
3267 memcpy (syment._n._n_name, fini, finisz - 1);
3268
3269 syment.n_sclass = C_EXT;
3270 syment.n_numaux = 1;
3271 bfd_coff_swap_sym_out (abfd, &syment,
3272 &syment_ext[filehdr.f_nsyms * SYMESZ]);
3273 bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0,
3274 syment.n_numaux,
3275 &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]);
3276
3277 /* reloc */
3278 memset (&reloc, 0, sizeof (struct internal_reloc));
3279 reloc.r_vaddr = 0x0028;
3280 reloc.r_symndx = filehdr.f_nsyms;
3281 reloc.r_type = R_POS;
3282 reloc.r_size = 31;
3283 bfd_coff_swap_reloc_out (abfd, &reloc,
3284 &reloc_ext[scnhdr.s_nreloc * RELSZ]);
3285
3286 filehdr.f_nsyms += 2;
3287 scnhdr.s_nreloc += 1;
3288 }
3289
3290 scnhdr.s_relptr = scnhdr.s_scnptr + data_buffer_size;
3291 filehdr.f_symptr = scnhdr.s_relptr + scnhdr.s_nreloc * RELSZ;
3292
3293 bfd_coff_swap_filehdr_out (abfd, &filehdr, filehdr_ext);
3294 bfd_bwrite (filehdr_ext, FILHSZ, abfd);
3295 bfd_coff_swap_scnhdr_out (abfd, &scnhdr, scnhdr_ext);
3296 bfd_bwrite (scnhdr_ext, SCNHSZ, abfd);
3297 bfd_bwrite (data_buffer, data_buffer_size, abfd);
3298 bfd_bwrite (reloc_ext, scnhdr.s_nreloc * RELSZ, abfd);
3299 bfd_bwrite (syment_ext, filehdr.f_nsyms * SYMESZ, abfd);
3300 bfd_bwrite (string_table, string_table_size, abfd);
3301
3302 free (data_buffer);
3303 data_buffer = NULL;
3304
3305 return true;
3306 }
3307
3308
3309 static reloc_howto_type xcoff_dynamic_reloc =
3310 HOWTO (0, /* type */
3311 0, /* rightshift */
3312 2, /* size (0 = byte, 1 = short, 2 = long) */
3313 32, /* bitsize */
3314 false, /* pc_relative */
3315 0, /* bitpos */
3316 complain_overflow_bitfield, /* complain_on_overflow */
3317 0, /* special_function */
3318 "R_POS", /* name */
3319 true, /* partial_inplace */
3320 0xffffffff, /* src_mask */
3321 0xffffffff, /* dst_mask */
3322 false); /* pcrel_offset */
3323
3324 /* glink
3325
3326 The first word of global linkage code must be modified by filling in
3327 the correct TOC offset. */
3328
3329 static unsigned long xcoff_glink_code[9] =
3330 {
3331 0x81820000, /* lwz r12,0(r2) */
3332 0x90410014, /* stw r2,20(r1) */
3333 0x800c0000, /* lwz r0,0(r12) */
3334 0x804c0004, /* lwz r2,4(r12) */
3335 0x7c0903a6, /* mtctr r0 */
3336 0x4e800420, /* bctr */
3337 0x00000000, /* start of traceback table */
3338 0x000c8000, /* traceback table */
3339 0x00000000, /* traceback table */
3340 };
3341
3342
3343 static const struct xcoff_backend_data_rec bfd_xcoff_backend_data =
3344 {
3345 { /* COFF backend, defined in libcoff.h. */
3346 _bfd_xcoff_swap_aux_in, /* _bfd_coff_swap_aux_in */
3347 _bfd_xcoff_swap_sym_in, /* _bfd_coff_swap_sym_in */
3348 coff_swap_lineno_in, /* _bfd_coff_swap_lineno_in */
3349 _bfd_xcoff_swap_aux_out, /* _bfd_swap_aux_out */
3350 _bfd_xcoff_swap_sym_out, /* _bfd_swap_sym_out */
3351 coff_swap_lineno_out, /* _bfd_swap_lineno_out */
3352 coff_swap_reloc_out, /* _bfd_swap_reloc_out */
3353 coff_swap_filehdr_out, /* _bfd_swap_filehdr_out */
3354 coff_swap_aouthdr_out, /* _bfd_swap_aouthdr_out */
3355 coff_swap_scnhdr_out, /* _bfd_swap_scnhdr_out */
3356 FILHSZ, /* _bfd_filhsz */
3357 AOUTSZ, /* _bfd_aoutsz */
3358 SCNHSZ, /* _bfd_scnhsz */
3359 SYMESZ, /* _bfd_symesz */
3360 AUXESZ, /* _bfd_auxesz */
3361 RELSZ, /* _bfd_relsz */
3362 LINESZ, /* _bfd_linesz */
3363 FILNMLEN, /* _bfd_filnmlen */
3364 true, /* _bfd_coff_long_filenames */
3365 false, /* _bfd_coff_long_section_names */
3366 (3), /* _bfd_coff_default_section_alignment_power */
3367 false, /* _bfd_coff_force_symnames_in_strings */
3368 2, /* _bfd_coff_debug_string_prefix_length */
3369 coff_swap_filehdr_in, /* _bfd_coff_swap_filehdr_in */
3370 coff_swap_aouthdr_in, /* _bfd_swap_aouthdr_in */
3371 coff_swap_scnhdr_in, /* _bfd_swap_scnhdr_in */
3372 coff_swap_reloc_in, /* _bfd_reloc_in */
3373 coff_bad_format_hook, /* _bfd_bad_format_hook */
3374 coff_set_arch_mach_hook, /* _bfd_set_arch_mach_hook */
3375 coff_mkobject_hook, /* _bfd_mkobject_hook */
3376 styp_to_sec_flags, /* _bfd_syp_to_sec_flags */
3377 coff_set_alignment_hook, /* _bfd_set_alignment_hook */
3378 coff_slurp_symbol_table, /* _bfd_coff_slurp_symbol_table */
3379 symname_in_debug_hook, /* _coff_symname_in_debug_hook */
3380 coff_pointerize_aux_hook, /* _bfd_coff_pointerize_aux_hook */
3381 coff_print_aux, /* bfd_coff_print_aux */
3382 dummy_reloc16_extra_cases, /* _bfd_coff_reloc16_extra_cases */
3383 dummy_reloc16_estimate, /* _bfd_coff_reloc16_estimate */
3384 NULL, /* bfd_coff_sym_is_global */
3385 coff_compute_section_file_positions, /* _bfd_coff_compute_section_file_positions */
3386 NULL, /* _bfd_coff_start_final_link */
3387 xcoff_ppc_relocate_section, /* _bfd_coff_relocate_section */
3388 coff_rtype_to_howto, /* _bfd_coff_rtype_to_howto */
3389 NULL, /* _bfd_coff_addust_symndx */
3390 _bfd_generic_link_add_one_symbol, /* _bfd_coff_add_one_symbol */
3391 coff_link_output_has_begun, /* _bfd_coff_link_output_has_begun */
3392 coff_final_link_postscript /* _bfd_coff_final_link_postscript */
3393 },
3394
3395 0x01DF, /* magic number */
3396 bfd_arch_rs6000, /* architecture */
3397 bfd_mach_rs6k, /* machine */
3398
3399 /* Function pointers to xcoff specific swap routines. */
3400 xcoff_swap_ldhdr_in, /* _xcoff_swap_ldhdr_in */
3401 xcoff_swap_ldhdr_out, /* _xcoff_swap_ldhdr_out */
3402 xcoff_swap_ldsym_in, /* _xcoff_swap_ldsym_in */
3403 xcoff_swap_ldsym_out, /* _xcoff_swap_ldsym_out */
3404 xcoff_swap_ldrel_in, /* _xcoff_swap_ldrel_in */
3405 xcoff_swap_ldrel_out, /* _xcoff_swap_ldrel_out */
3406
3407 /* Sizes. */
3408 LDHDRSZ, /* _xcoff_ldhdrsz */
3409 LDSYMSZ, /* _xcoff_ldsymsz */
3410 LDRELSZ, /* _xcoff_ldrelsz */
3411 12, /* _xcoff_function_descriptor_size */
3412 SMALL_AOUTSZ, /* _xcoff_small_aout_header_size */
3413
3414 /* Versions. */
3415 1, /* _xcoff_ldhdr_version */
3416
3417 /* Xcoff vs xcoff64 putting symbol names. */
3418 _bfd_xcoff_put_symbol_name, /* _xcoff_put_symbol_name */
3419 _bfd_xcoff_put_ldsymbol_name, /* _xcoff_put_ldsymbol_name */
3420
3421 & xcoff_dynamic_reloc, /* dynamic reloc howto */
3422
3423 xcoff_create_csect_from_smclas, /* _xcoff_create_csect_from_smclas */
3424
3425 /* Lineno and reloc count overflow. */
3426 xcoff_is_lineno_count_overflow,
3427 xcoff_is_reloc_count_overflow,
3428
3429 xcoff_loader_symbol_offset,
3430 xcoff_loader_reloc_offset,
3431
3432 /* glink. */
3433 & xcoff_glink_code[0],
3434 (36), /* _xcoff_glink_size */
3435
3436 /* rtinit */
3437 64, /* _xcoff_rtinit_size */
3438 xcoff_generate_rtinit, /* _xcoff_generate_rtinit */
3439 };
3440
3441 /* The transfer vector that leads the outside world to all of the above. */
3442 const bfd_target rs6000coff_vec =
3443 {
3444 "aixcoff-rs6000",
3445 bfd_target_xcoff_flavour,
3446 BFD_ENDIAN_BIG, /* data byte order is big */
3447 BFD_ENDIAN_BIG, /* header byte order is big */
3448
3449 (HAS_RELOC | EXEC_P | /* object flags */
3450 HAS_LINENO | HAS_DEBUG | DYNAMIC |
3451 HAS_SYMS | HAS_LOCALS | WP_TEXT),
3452
3453 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
3454 0, /* leading char */
3455 '/', /* ar_pad_char */
3456 15, /* ar_max_namelen??? FIXMEmgo */
3457
3458 /* data */
3459 bfd_getb64, /* bfd_getx64 */
3460 bfd_getb_signed_64, /* bfd_getx_signed_64 */
3461 bfd_putb64, /* bfd_putx64 */
3462 bfd_getb32, /* bfd_getx32 */
3463 bfd_getb_signed_32, /* bfd_getx_signed_32 */
3464 bfd_putb32, /* bfd_putx32 */
3465 bfd_getb16, /* bfd_getx16 */
3466 bfd_getb_signed_16, /* bfd_getx_signed_16 */
3467 bfd_putb16, /* bfd_putx16 */
3468
3469 /* hdrs */
3470 bfd_getb64, /* bfd_h_getx64 */
3471 bfd_getb_signed_64, /* bfd_h_getx_signed_64 */
3472 bfd_putb64, /* bfd_h_putx64 */
3473 bfd_getb32, /* bfd_h_getx32 */
3474 bfd_getb_signed_32, /* bfd_h_getx_signed_32 */
3475 bfd_putb32, /* bfd_h_putx32 */
3476 bfd_getb16, /* bfd_h_getx16 */
3477 bfd_getb_signed_16, /* bfd_h_getx_signed_16 */
3478 bfd_putb16, /* bfd_h_putx16 */
3479
3480 { /* bfd_check_format */
3481 _bfd_dummy_target,
3482 coff_object_p,
3483 _bfd_xcoff_archive_p,
3484 CORE_FILE_P
3485 },
3486
3487 { /* bfd_set_format */
3488 bfd_false,
3489 coff_mkobject,
3490 _bfd_generic_mkarchive,
3491 bfd_false
3492 },
3493
3494 {/* bfd_write_contents */
3495 bfd_false,
3496 coff_write_object_contents,
3497 _bfd_xcoff_write_archive_contents,
3498 bfd_false
3499 },
3500
3501 /* Generic */
3502 bfd_true, /* _close_and_cleanup */
3503 bfd_true, /* _bfd_free_cached_info */
3504 coff_new_section_hook, /* _new_section_hook */
3505 _bfd_generic_get_section_contents, /* _bfd_get_section_contents */
3506 /* _bfd_get_section_contents_in_window */
3507 _bfd_generic_get_section_contents_in_window,
3508
3509 /* Copy */
3510 _bfd_xcoff_copy_private_bfd_data, /* _bfd_copy_private_bfd */
3511 /* _bfd_merge_private_bfd_data */
3512 ((boolean (*) (bfd *, bfd *)) bfd_true),
3513 /* _bfd_copy_pivate_section_data */
3514 ((boolean (*) (bfd *, asection *, bfd *, asection *)) bfd_true),
3515 /* _bfd_copy_private_symbol_data */
3516 ((boolean (*) (bfd *, asymbol *, bfd *, asymbol *)) bfd_true),
3517 ((boolean (*) (bfd *, flagword)) bfd_true), /* _bfd_set_private_flags */
3518 ((boolean (*) (bfd *, void * )) bfd_true), /* _bfd_print_private_bfd_data */
3519
3520 /* Core */
3521 coff_core_file_failing_command, /* _core_file_failing_command */
3522 coff_core_file_failing_signal, /* _core_file_failing_signal */
3523 /* _core_file_matches_executable_p */
3524 coff_core_file_matches_executable_p,
3525
3526 /* Archive */
3527 _bfd_xcoff_slurp_armap, /* _slurp_armap */
3528 /* XCOFF archives do not have
3529 anything which corresponds to
3530 an extended name table. */
3531 bfd_false, /* _slurp_extended_name_table */
3532 /* _construct_extended_name_table */
3533 ((boolean (*) (bfd *, char **, bfd_size_type *, const char **)) bfd_false),
3534 bfd_dont_truncate_arname, /* _truncate_arname */
3535 _bfd_xcoff_write_armap, /* _write_armap */
3536 _bfd_xcoff_read_ar_hdr, /* _read_ar_hdr */
3537 _bfd_xcoff_openr_next_archived_file, /* _openr_next_archived_file */
3538 _bfd_generic_get_elt_at_index, /* _get_elt_at_index */
3539 _bfd_xcoff_generic_stat_arch_elt, /* _generic_dtat_arch_elt */
3540 /* XCOFF archives do not have
3541 a timestamp. */
3542 bfd_true, /* _update_armap_timestamp */
3543
3544 /* Symbols */
3545 coff_get_symtab_upper_bound, /* _get_symtab_upper_bound */
3546 coff_get_symtab, /* _get_symtab */
3547 coff_make_empty_symbol, /* _make_empty_symbol */
3548 coff_print_symbol, /* _print_symbol */
3549 coff_get_symbol_info, /* _get_symbol_info */
3550 _bfd_xcoff_is_local_label_name, /* _bfd_is_local_label_name */
3551 coff_get_lineno, /* _get_lineno */
3552 coff_find_nearest_line, /* _find_nearest_line */
3553 coff_bfd_make_debug_symbol, /* _bfd_make_debug_symbol */
3554 _bfd_generic_read_minisymbols, /* _read_minisymbols */
3555 _bfd_generic_minisymbol_to_symbol, /* _minsymbol_to_symbol */
3556
3557 /* Reloc */
3558 coff_get_reloc_upper_bound, /* _get_reloc_upper_bound */
3559 coff_canonicalize_reloc, /* _cononicalize_reloc */
3560 _bfd_xcoff_reloc_type_lookup, /* _bfd_reloc_type_lookup */
3561
3562 /* Write */
3563 coff_set_arch_mach, /* _set_arch_mach */
3564 coff_set_section_contents, /* _set_section_contents */
3565
3566 /* Link */
3567 _bfd_xcoff_sizeof_headers, /* _sizeof_headers */
3568 /* _bfd_get_relocated_section_contents */
3569 bfd_generic_get_relocated_section_contents,
3570 bfd_generic_relax_section, /* _bfd_relax_section */
3571 _bfd_xcoff_bfd_link_hash_table_create, /* _bfd_link_hash_table_create */
3572 _bfd_xcoff_bfd_link_add_symbols, /* _bfd_link_add_symbols */
3573 _bfd_xcoff_bfd_final_link, /* _bfd_filnal_link */
3574 _bfd_generic_link_split_section, /* _bfd_link_split_section */
3575 bfd_generic_gc_sections, /* _bfd_gc_sections */
3576 bfd_generic_merge_sections, /* _bfd_merge_sections */
3577
3578 /* Dynamic */
3579 /* _get_dynamic_symtab_upper_bound */
3580 _bfd_xcoff_get_dynamic_symtab_upper_bound,
3581 _bfd_xcoff_canonicalize_dynamic_symtab, /* _cononicalize_dynamic_symtab */
3582 _bfd_xcoff_get_dynamic_reloc_upper_bound,/* _get_dynamic_reloc_upper_bound */
3583 _bfd_xcoff_canonicalize_dynamic_reloc, /* _cononicalize_dynamic_reloc */
3584
3585 /* Opposite endian version, none exists */
3586 NULL,
3587
3588 /* back end data */
3589 (void *) &bfd_xcoff_backend_data,
3590 };
3591
3592 /*
3593 * xcoff-powermac target
3594 * Old target.
3595 * Only difference between this target and the rs6000 target is the
3596 * the default architecture and machine type used in coffcode.h
3597 *
3598 * PowerPC Macs use the same magic numbers as RS/6000
3599 * (because that's how they were bootstrapped originally),
3600 * but they are always PowerPC architecture.
3601 */
3602 static const struct xcoff_backend_data_rec bfd_pmac_xcoff_backend_data =
3603 {
3604 { /* COFF backend, defined in libcoff.h */
3605 _bfd_xcoff_swap_aux_in, /* _bfd_coff_swap_aux_in */
3606 _bfd_xcoff_swap_sym_in, /* _bfd_coff_swap_sym_in */
3607 coff_swap_lineno_in, /* _bfd_coff_swap_lineno_in */
3608 _bfd_xcoff_swap_aux_out, /* _bfd_swap_aux_out */
3609 _bfd_xcoff_swap_sym_out, /* _bfd_swap_sym_out */
3610 coff_swap_lineno_out, /* _bfd_swap_lineno_out */
3611 coff_swap_reloc_out, /* _bfd_swap_reloc_out */
3612 coff_swap_filehdr_out, /* _bfd_swap_filehdr_out */
3613 coff_swap_aouthdr_out, /* _bfd_swap_aouthdr_out */
3614 coff_swap_scnhdr_out, /* _bfd_swap_scnhdr_out */
3615 FILHSZ, /* _bfd_filhsz */
3616 AOUTSZ, /* _bfd_aoutsz */
3617 SCNHSZ, /* _bfd_scnhsz */
3618 SYMESZ, /* _bfd_symesz */
3619 AUXESZ, /* _bfd_auxesz */
3620 RELSZ, /* _bfd_relsz */
3621 LINESZ, /* _bfd_linesz */
3622 FILNMLEN, /* _bfd_filnmlen */
3623 true, /* _bfd_coff_long_filenames */
3624 false, /* _bfd_coff_long_section_names */
3625 (3), /* _bfd_coff_default_section_alignment_power */
3626 false, /* _bfd_coff_force_symnames_in_strings */
3627 2, /* _bfd_coff_debug_string_prefix_length */
3628 coff_swap_filehdr_in, /* _bfd_coff_swap_filehdr_in */
3629 coff_swap_aouthdr_in, /* _bfd_swap_aouthdr_in */
3630 coff_swap_scnhdr_in, /* _bfd_swap_scnhdr_in */
3631 coff_swap_reloc_in, /* _bfd_reloc_in */
3632 coff_bad_format_hook, /* _bfd_bad_format_hook */
3633 coff_set_arch_mach_hook, /* _bfd_set_arch_mach_hook */
3634 coff_mkobject_hook, /* _bfd_mkobject_hook */
3635 styp_to_sec_flags, /* _bfd_syp_to_sec_flags */
3636 coff_set_alignment_hook, /* _bfd_set_alignment_hook */
3637 coff_slurp_symbol_table, /* _bfd_coff_slurp_symbol_table */
3638 symname_in_debug_hook, /* _coff_symname_in_debug_hook */
3639 coff_pointerize_aux_hook, /* _bfd_coff_pointerize_aux_hook */
3640 coff_print_aux, /* bfd_coff_print_aux */
3641 dummy_reloc16_extra_cases, /* _bfd_coff_reloc16_extra_cases */
3642 dummy_reloc16_estimate, /* _bfd_coff_reloc16_estimate */
3643 NULL, /* bfd_coff_sym_is_global */
3644 /* _bfd_coff_compute_section_file_positions */
3645 coff_compute_section_file_positions,
3646 NULL, /* _bfd_coff_start_final_link */
3647 xcoff_ppc_relocate_section, /* _bfd_coff_relocate_section */
3648 coff_rtype_to_howto, /* _bfd_coff_rtype_to_howto */
3649 NULL, /* _bfd_coff_addust_symndx */
3650 _bfd_generic_link_add_one_symbol, /* _bfd_coff_add_one_symbol */
3651 coff_link_output_has_begun, /* _bfd_coff_link_output_has_begun */
3652 coff_final_link_postscript /* _bfd_coff_final_link_postscript */
3653 },
3654
3655 0x01DF, /* magic number */
3656 bfd_arch_powerpc, /* architecture */
3657 bfd_mach_ppc, /* machine */
3658
3659 /* function pointers to xcoff specific swap routines */
3660 xcoff_swap_ldhdr_in, /* _xcoff_swap_ldhdr_in */
3661 xcoff_swap_ldhdr_out, /* _xcoff_swap_ldhdr_out */
3662 xcoff_swap_ldsym_in, /* _xcoff_swap_ldsym_in */
3663 xcoff_swap_ldsym_out, /* _xcoff_swap_ldsym_out */
3664 xcoff_swap_ldrel_in, /* _xcoff_swap_ldrel_in */
3665 xcoff_swap_ldrel_out, /* _xcoff_swap_ldrel_out */
3666
3667 /* sizes */
3668 LDHDRSZ, /* _xcoff_ldhdrsz */
3669 LDSYMSZ, /* _xcoff_ldsymsz */
3670 LDRELSZ, /* _xcoff_ldrelsz */
3671 12, /* _xcoff_function_descriptor_size */
3672 SMALL_AOUTSZ, /* _xcoff_small_aout_header_size */
3673
3674 /* versions */
3675 1, /* _xcoff_ldhdr_version */
3676
3677 /* xcoff vs xcoff64 putting symbol names */
3678 _bfd_xcoff_put_symbol_name, /* _xcoff_put_symbol_name */
3679 _bfd_xcoff_put_ldsymbol_name, /* _xcoff_put_ldsymbol_name */
3680
3681 &xcoff_dynamic_reloc, /* dynamic reloc howto */
3682
3683 xcoff_create_csect_from_smclas, /* _xcoff_create_csect_from_smclas */
3684
3685 /* lineno and reloc count overflow */
3686 xcoff_is_lineno_count_overflow,
3687 xcoff_is_reloc_count_overflow,
3688
3689 xcoff_loader_symbol_offset,
3690 xcoff_loader_reloc_offset,
3691
3692 /* glink */
3693 &xcoff_glink_code[0],
3694 (36), /* _xcoff_glink_size */
3695
3696 /* rtinit */
3697 0, /* _xcoff_rtinit_size */
3698 xcoff_generate_rtinit, /* _xcoff_generate_rtinit */
3699
3700 };
3701
3702 /* The transfer vector that leads the outside world to all of the above. */
3703 const bfd_target pmac_xcoff_vec =
3704 {
3705 "xcoff-powermac",
3706 bfd_target_xcoff_flavour,
3707 BFD_ENDIAN_BIG, /* data byte order is big */
3708 BFD_ENDIAN_BIG, /* header byte order is big */
3709
3710 (HAS_RELOC | EXEC_P | /* object flags */
3711 HAS_LINENO | HAS_DEBUG | DYNAMIC |
3712 HAS_SYMS | HAS_LOCALS | WP_TEXT),
3713
3714 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
3715 0, /* leading char */
3716 '/', /* ar_pad_char */
3717 15, /* ar_max_namelen??? FIXMEmgo */
3718
3719 /* data */
3720 bfd_getb64, /* bfd_getx64 */
3721 bfd_getb_signed_64, /* bfd_getx_signed_64 */
3722 bfd_putb64, /* bfd_putx64 */
3723 bfd_getb32, /* bfd_getx32 */
3724 bfd_getb_signed_32, /* bfd_getx_signed_32 */
3725 bfd_putb32, /* bfd_putx32 */
3726 bfd_getb16, /* bfd_getx16 */
3727 bfd_getb_signed_16, /* bfd_getx_signed_16 */
3728 bfd_putb16, /* bfd_putx16 */
3729
3730 /* hdrs */
3731 bfd_getb64, /* bfd_h_getx64 */
3732 bfd_getb_signed_64, /* bfd_h_getx_signed_64 */
3733 bfd_putb64, /* bfd_h_putx64 */
3734 bfd_getb32, /* bfd_h_getx32 */
3735 bfd_getb_signed_32, /* bfd_h_getx_signed_32 */
3736 bfd_putb32, /* bfd_h_putx32 */
3737 bfd_getb16, /* bfd_h_getx16 */
3738 bfd_getb_signed_16, /* bfd_h_getx_signed_16 */
3739 bfd_putb16, /* bfd_h_putx16 */
3740
3741 { /* bfd_check_format */
3742 _bfd_dummy_target,
3743 coff_object_p,
3744 _bfd_xcoff_archive_p,
3745 CORE_FILE_P
3746 },
3747
3748 { /* bfd_set_format */
3749 bfd_false,
3750 coff_mkobject,
3751 _bfd_generic_mkarchive,
3752 bfd_false
3753 },
3754
3755 {/* bfd_write_contents */
3756 bfd_false,
3757 coff_write_object_contents,
3758 _bfd_xcoff_write_archive_contents,
3759 bfd_false
3760 },
3761
3762 /* Generic */
3763 bfd_true, /* _close_and_cleanup */
3764 bfd_true, /* _bfd_free_cached_info */
3765 coff_new_section_hook, /* _new_section_hook */
3766 _bfd_generic_get_section_contents, /* _bfd_get_section_contents */
3767 /* _bfd_get_section_contents_in_window */
3768 _bfd_generic_get_section_contents_in_window,
3769
3770 /* Copy */
3771 _bfd_xcoff_copy_private_bfd_data, /* _bfd_copy_private_bfd */
3772 /* _bfd_merge_private_bfd_data */
3773 ((boolean (*) (bfd *, bfd *)) bfd_true),
3774 /* _bfd_copy_pivate_section_data */
3775 ((boolean (*) (bfd *, asection *, bfd *, asection *)) bfd_true),
3776 /* _bfd_copy_private_symbol_data */
3777 ((boolean (*) (bfd *, asymbol *, bfd *, asymbol *)) bfd_true),
3778 ((boolean (*) (bfd *, flagword)) bfd_true), /* _bfd_set_private_flags */
3779 ((boolean (*) (bfd *, void * )) bfd_true), /* _bfd_print_private_bfd_data */
3780
3781 /* Core */
3782 coff_core_file_failing_command, /* _core_file_failing_command */
3783 coff_core_file_failing_signal, /* _core_file_failing_signal */
3784 /* _core_file_matches_executable_p */
3785 coff_core_file_matches_executable_p,
3786
3787 /* Archive */
3788 _bfd_xcoff_slurp_armap, /* _slurp_armap */
3789 /* XCOFF archives do not have
3790 anything which corresponds to
3791 an extended name table. */
3792 bfd_false, /* _slurp_extended_name_table */
3793 /* _construct_extended_name_table */
3794 ((boolean (*) (bfd *, char **, bfd_size_type *, const char **)) bfd_false),
3795 bfd_dont_truncate_arname, /* _truncate_arname */
3796 _bfd_xcoff_write_armap, /* _write_armap */
3797 _bfd_xcoff_read_ar_hdr, /* _read_ar_hdr */
3798 _bfd_xcoff_openr_next_archived_file, /* _openr_next_archived_file */
3799 _bfd_generic_get_elt_at_index, /* _get_elt_at_index */
3800 _bfd_xcoff_generic_stat_arch_elt, /* _generic_dtat_arch_elt */
3801 /* XCOFF archives do not have
3802 a timestamp. */
3803 bfd_true, /* _update_armap_timestamp */
3804
3805 /* Symbols */
3806 coff_get_symtab_upper_bound, /* _get_symtab_upper_bound */
3807 coff_get_symtab, /* _get_symtab */
3808 coff_make_empty_symbol, /* _make_empty_symbol */
3809 coff_print_symbol, /* _print_symbol */
3810 coff_get_symbol_info, /* _get_symbol_info */
3811 _bfd_xcoff_is_local_label_name, /* _bfd_is_local_label_name */
3812 coff_get_lineno, /* _get_lineno */
3813 coff_find_nearest_line, /* _find_nearest_line */
3814 coff_bfd_make_debug_symbol, /* _bfd_make_debug_symbol */
3815 _bfd_generic_read_minisymbols, /* _read_minisymbols */
3816 _bfd_generic_minisymbol_to_symbol, /* _minsymbol_to_symbol */
3817
3818 /* Reloc */
3819 coff_get_reloc_upper_bound, /* _get_reloc_upper_bound */
3820 coff_canonicalize_reloc, /* _cononicalize_reloc */
3821 _bfd_xcoff_reloc_type_lookup, /* _bfd_reloc_type_lookup */
3822
3823 /* Write */
3824 coff_set_arch_mach, /* _set_arch_mach */
3825 coff_set_section_contents, /* _set_section_contents */
3826
3827 /* Link */
3828 _bfd_xcoff_sizeof_headers, /* _sizeof_headers */
3829 /* _bfd_get_relocated_section_contents */
3830 bfd_generic_get_relocated_section_contents,
3831 bfd_generic_relax_section, /* _bfd_relax_section */
3832 _bfd_xcoff_bfd_link_hash_table_create, /* _bfd_link_hash_table_create */
3833 _bfd_xcoff_bfd_link_add_symbols, /* _bfd_link_add_symbols */
3834 _bfd_xcoff_bfd_final_link, /* _bfd_filnal_link */
3835 _bfd_generic_link_split_section, /* _bfd_link_split_section */
3836 bfd_generic_gc_sections, /* _bfd_gc_sections */
3837 bfd_generic_merge_sections, /* _bfd_merge_sections */
3838
3839 /* Dynamic */
3840 /* _get_dynamic_symtab_upper_bound */
3841 _bfd_xcoff_get_dynamic_symtab_upper_bound,
3842 _bfd_xcoff_canonicalize_dynamic_symtab, /* _cononicalize_dynamic_symtab */
3843 _bfd_xcoff_get_dynamic_reloc_upper_bound,/* _get_dynamic_reloc_upper_bound */
3844 _bfd_xcoff_canonicalize_dynamic_reloc, /* _cononicalize_dynamic_reloc */
3845
3846 /* Opposite endian version, none exists */
3847 NULL,
3848
3849 /* back end data */
3850 (void *) &bfd_pmac_xcoff_backend_data,
3851 };
git-cvsimport of binutils cvsroot