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