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