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