1 /* BFD back-end for IBM RS/6000 "XCOFF64" files. 2 Copyright (C) 2000-2020 Free Software Foundation, Inc. 3 Written Clinton Popetz. 4 Contributed by Cygnus Support. 5 6 This file is part of BFD, the Binary File Descriptor library. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program; if not, write to the Free Software 20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 21 MA 02110-1301, USA. */ 22 23 #include "sysdep.h" 24 #include "bfd.h" 25 #include "bfdlink.h" 26 #include "libbfd.h" 27 #include "coff/internal.h" 28 #include "coff/xcoff.h" 29 #include "coff/rs6k64.h" 30 #include "libcoff.h" 31 #include "libxcoff.h" 32 33 #define GET_FILEHDR_SYMPTR H_GET_64 34 #define PUT_FILEHDR_SYMPTR H_PUT_64 35 #define GET_AOUTHDR_DATA_START H_GET_64 36 #define PUT_AOUTHDR_DATA_START H_PUT_64 37 #define GET_AOUTHDR_TEXT_START H_GET_64 38 #define PUT_AOUTHDR_TEXT_START H_PUT_64 39 #define GET_AOUTHDR_TSIZE H_GET_64 40 #define PUT_AOUTHDR_TSIZE H_PUT_64 41 #define GET_AOUTHDR_DSIZE H_GET_64 42 #define PUT_AOUTHDR_DSIZE H_PUT_64 43 #define GET_AOUTHDR_BSIZE H_GET_64 44 #define PUT_AOUTHDR_BSIZE H_PUT_64 45 #define GET_AOUTHDR_ENTRY H_GET_64 46 #define PUT_AOUTHDR_ENTRY H_PUT_64 47 #define GET_SCNHDR_PADDR H_GET_64 48 #define PUT_SCNHDR_PADDR H_PUT_64 49 #define GET_SCNHDR_VADDR H_GET_64 50 #define PUT_SCNHDR_VADDR H_PUT_64 51 #define GET_SCNHDR_SIZE H_GET_64 52 #define PUT_SCNHDR_SIZE H_PUT_64 53 #define GET_SCNHDR_SCNPTR H_GET_64 54 #define PUT_SCNHDR_SCNPTR H_PUT_64 55 #define GET_SCNHDR_RELPTR H_GET_64 56 #define PUT_SCNHDR_RELPTR H_PUT_64 57 #define GET_SCNHDR_LNNOPTR H_GET_64 58 #define PUT_SCNHDR_LNNOPTR H_PUT_64 59 #define GET_SCNHDR_NRELOC H_GET_32 60 #define MAX_SCNHDR_NRELOC 0xffffffff 61 #define PUT_SCNHDR_NRELOC H_PUT_32 62 #define GET_SCNHDR_NLNNO H_GET_32 63 #define MAX_SCNHDR_NLNNO 0xffffffff 64 #define PUT_SCNHDR_NLNNO H_PUT_32 65 #define GET_RELOC_VADDR H_GET_64 66 #define PUT_RELOC_VADDR H_PUT_64 67 68 #define COFF_FORCE_SYMBOLS_IN_STRINGS 69 #define COFF_DEBUG_STRING_WIDE_PREFIX 70 71 72 #define COFF_ADJUST_SCNHDR_OUT_POST(ABFD, INT, EXT) \ 73 do \ 74 { \ 75 memset (((SCNHDR *) EXT)->s_pad, 0, \ 76 sizeof (((SCNHDR *) EXT)->s_pad)); \ 77 } \ 78 while (0) 79 80 #define NO_COFF_LINENOS 81 82 #define coff_SWAP_lineno_in _bfd_xcoff64_swap_lineno_in 83 #define coff_SWAP_lineno_out _bfd_xcoff64_swap_lineno_out 84 85 static void _bfd_xcoff64_swap_lineno_in 86 (bfd *, void *, void *); 87 static unsigned int _bfd_xcoff64_swap_lineno_out 88 (bfd *, void *, void *); 89 static bfd_boolean _bfd_xcoff64_put_symbol_name 90 (struct bfd_link_info *, struct bfd_strtab_hash *, 91 struct internal_syment *, const char *); 92 static bfd_boolean _bfd_xcoff64_put_ldsymbol_name 93 (bfd *, struct xcoff_loader_info *, struct internal_ldsym *, const char *); 94 static void _bfd_xcoff64_swap_sym_in 95 (bfd *, void *, void *); 96 static unsigned int _bfd_xcoff64_swap_sym_out 97 (bfd *, void *, void *); 98 static void _bfd_xcoff64_swap_aux_in 99 (bfd *, void *, int, int, int, int, void *); 100 static unsigned int _bfd_xcoff64_swap_aux_out 101 (bfd *, void *, int, int, int, int, void *); 102 static void xcoff64_swap_reloc_in 103 (bfd *, void *, void *); 104 static unsigned int xcoff64_swap_reloc_out 105 (bfd *, void *, void *); 106 extern bfd_boolean _bfd_xcoff_mkobject 107 (bfd *); 108 extern bfd_boolean _bfd_xcoff_copy_private_bfd_data 109 (bfd *, bfd *); 110 extern bfd_boolean _bfd_xcoff_is_local_label_name 111 (bfd *, const char *); 112 extern void xcoff64_rtype2howto 113 (arelent *, struct internal_reloc *); 114 extern reloc_howto_type * xcoff64_reloc_type_lookup 115 (bfd *, bfd_reloc_code_real_type); 116 extern bfd_boolean _bfd_xcoff_slurp_armap 117 (bfd *); 118 extern void *_bfd_xcoff_read_ar_hdr 119 (bfd *); 120 extern bfd *_bfd_xcoff_openr_next_archived_file 121 (bfd *, bfd *); 122 extern int _bfd_xcoff_stat_arch_elt 123 (bfd *, struct stat *); 124 extern bfd_boolean _bfd_xcoff_write_armap 125 (bfd *, unsigned int, struct orl *, unsigned int, int); 126 extern bfd_boolean _bfd_xcoff_write_archive_contents 127 (bfd *); 128 extern int _bfd_xcoff_sizeof_headers 129 (bfd *, struct bfd_link_info *); 130 extern void _bfd_xcoff_swap_sym_in 131 (bfd *, void *, void *); 132 extern unsigned int _bfd_xcoff_swap_sym_out 133 (bfd *, void *, void *); 134 extern void _bfd_xcoff_swap_aux_in 135 (bfd *, void *, int, int, int, int, void *); 136 extern unsigned int _bfd_xcoff_swap_aux_out 137 (bfd *, void *, int, int, int, int, void *); 138 static void xcoff64_swap_ldhdr_in 139 (bfd *, const void *, struct internal_ldhdr *); 140 static void xcoff64_swap_ldhdr_out 141 (bfd *, const struct internal_ldhdr *, void *d); 142 static void xcoff64_swap_ldsym_in 143 (bfd *, const void *, struct internal_ldsym *); 144 static void xcoff64_swap_ldsym_out 145 (bfd *, const struct internal_ldsym *, void *d); 146 static void xcoff64_swap_ldrel_in 147 (bfd *, const void *, struct internal_ldrel *); 148 static void xcoff64_swap_ldrel_out 149 (bfd *, const struct internal_ldrel *, void *d); 150 static bfd_boolean xcoff64_write_object_contents 151 (bfd *); 152 static bfd_boolean xcoff64_ppc_relocate_section 153 (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, 154 struct internal_reloc *, struct internal_syment *, 155 asection **); 156 static bfd_boolean xcoff64_slurp_armap 157 (bfd *); 158 static const bfd_target *xcoff64_archive_p 159 (bfd *); 160 static bfd *xcoff64_openr_next_archived_file 161 (bfd *, bfd *); 162 static int xcoff64_sizeof_headers 163 (bfd *, struct bfd_link_info *); 164 static asection *xcoff64_create_csect_from_smclas 165 (bfd *, union internal_auxent *, const char *); 166 static bfd_boolean xcoff64_is_lineno_count_overflow 167 (bfd *, bfd_vma); 168 static bfd_boolean xcoff64_is_reloc_count_overflow 169 (bfd *, bfd_vma); 170 static bfd_vma xcoff64_loader_symbol_offset 171 (bfd *, struct internal_ldhdr *); 172 static bfd_vma xcoff64_loader_reloc_offset 173 (bfd *, struct internal_ldhdr *); 174 static bfd_boolean xcoff64_generate_rtinit 175 (bfd *, const char *, const char *, bfd_boolean); 176 static bfd_boolean xcoff64_bad_format_hook 177 (bfd *, void *); 178 179 /* Relocation functions */ 180 static bfd_boolean xcoff64_reloc_type_br 181 (XCOFF_RELOC_FUNCTION_ARGS); 182 183 bfd_boolean (*xcoff64_calculate_relocation[XCOFF_MAX_CALCULATE_RELOCATION]) 184 (XCOFF_RELOC_FUNCTION_ARGS) = 185 { 186 xcoff_reloc_type_pos, /* R_POS (0x00) */ 187 xcoff_reloc_type_neg, /* R_NEG (0x01) */ 188 xcoff_reloc_type_rel, /* R_REL (0x02) */ 189 xcoff_reloc_type_toc, /* R_TOC (0x03) */ 190 xcoff_reloc_type_fail, /* R_RTB (0x04) */ 191 xcoff_reloc_type_toc, /* R_GL (0x05) */ 192 xcoff_reloc_type_toc, /* R_TCL (0x06) */ 193 xcoff_reloc_type_fail, /* (0x07) */ 194 xcoff_reloc_type_ba, /* R_BA (0x08) */ 195 xcoff_reloc_type_fail, /* (0x09) */ 196 xcoff64_reloc_type_br, /* R_BR (0x0a) */ 197 xcoff_reloc_type_fail, /* (0x0b) */ 198 xcoff_reloc_type_pos, /* R_RL (0x0c) */ 199 xcoff_reloc_type_pos, /* R_RLA (0x0d) */ 200 xcoff_reloc_type_fail, /* (0x0e) */ 201 xcoff_reloc_type_noop, /* R_REF (0x0f) */ 202 xcoff_reloc_type_fail, /* (0x10) */ 203 xcoff_reloc_type_fail, /* (0x11) */ 204 xcoff_reloc_type_toc, /* R_TRL (0x12) */ 205 xcoff_reloc_type_toc, /* R_TRLA (0x13) */ 206 xcoff_reloc_type_fail, /* R_RRTBI (0x14) */ 207 xcoff_reloc_type_fail, /* R_RRTBA (0x15) */ 208 xcoff_reloc_type_ba, /* R_CAI (0x16) */ 209 xcoff_reloc_type_crel, /* R_CREL (0x17) */ 210 xcoff_reloc_type_ba, /* R_RBA (0x18) */ 211 xcoff_reloc_type_ba, /* R_RBAC (0x19) */ 212 xcoff64_reloc_type_br, /* R_RBR (0x1a) */ 213 xcoff_reloc_type_ba, /* R_RBRC (0x1b) */ 214 }; 215 216 /* coffcode.h needs these to be defined. */ 217 /* Internalcoff.h and coffcode.h modify themselves based on these flags. */ 218 #define XCOFF64 219 #define RS6000COFF_C 1 220 221 #define SELECT_RELOC(internal, howto) \ 222 { \ 223 internal.r_type = howto->type; \ 224 internal.r_size = \ 225 ((howto->complain_on_overflow == complain_overflow_signed \ 226 ? 0x80 \ 227 : 0) \ 228 | (howto->bitsize - 1)); \ 229 } 230 231 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (3) 232 #define COFF_LONG_FILENAMES 233 #define NO_COFF_SYMBOLS 234 #define RTYPE2HOWTO(cache_ptr, dst) xcoff64_rtype2howto (cache_ptr, dst) 235 #define coff_mkobject _bfd_xcoff_mkobject 236 #define coff_bfd_copy_private_bfd_data _bfd_xcoff_copy_private_bfd_data 237 #define coff_bfd_is_local_label_name _bfd_xcoff_is_local_label_name 238 #define coff_bfd_reloc_type_lookup xcoff64_reloc_type_lookup 239 #define coff_bfd_reloc_name_lookup xcoff64_reloc_name_lookup 240 #ifdef AIX_CORE 241 extern const bfd_target * rs6000coff_core_p 242 (bfd *abfd); 243 extern bfd_boolean rs6000coff_core_file_matches_executable_p 244 (bfd *cbfd, bfd *ebfd); 245 extern char *rs6000coff_core_file_failing_command 246 (bfd *abfd); 247 extern int rs6000coff_core_file_failing_signal 248 (bfd *abfd); 249 #define CORE_FILE_P rs6000coff_core_p 250 #define coff_core_file_failing_command \ 251 rs6000coff_core_file_failing_command 252 #define coff_core_file_failing_signal \ 253 rs6000coff_core_file_failing_signal 254 #define coff_core_file_matches_executable_p \ 255 rs6000coff_core_file_matches_executable_p 256 #define coff_core_file_pid \ 257 _bfd_nocore_core_file_pid 258 #else 259 #define CORE_FILE_P _bfd_dummy_target 260 #define coff_core_file_failing_command \ 261 _bfd_nocore_core_file_failing_command 262 #define coff_core_file_failing_signal \ 263 _bfd_nocore_core_file_failing_signal 264 #define coff_core_file_matches_executable_p \ 265 _bfd_nocore_core_file_matches_executable_p 266 #define coff_core_file_pid \ 267 _bfd_nocore_core_file_pid 268 #endif 269 #define coff_SWAP_sym_in _bfd_xcoff64_swap_sym_in 270 #define coff_SWAP_sym_out _bfd_xcoff64_swap_sym_out 271 #define coff_SWAP_aux_in _bfd_xcoff64_swap_aux_in 272 #define coff_SWAP_aux_out _bfd_xcoff64_swap_aux_out 273 #define coff_swap_reloc_in xcoff64_swap_reloc_in 274 #define coff_swap_reloc_out xcoff64_swap_reloc_out 275 #define NO_COFF_RELOCS 276 277 #ifndef bfd_pe_print_pdata 278 #define bfd_pe_print_pdata NULL 279 #endif 280 281 #include "coffcode.h" 282 283 /* For XCOFF64, the effective width of symndx changes depending on 284 whether we are the first entry. Sigh. */ 285 static void 286 _bfd_xcoff64_swap_lineno_in (bfd *abfd, void *ext1, void *in1) 287 { 288 LINENO *ext = (LINENO *) ext1; 289 struct internal_lineno *in = (struct internal_lineno *) in1; 290 291 in->l_lnno = H_GET_32 (abfd, (ext->l_lnno)); 292 if (in->l_lnno == 0) 293 in->l_addr.l_symndx = H_GET_32 (abfd, ext->l_addr.l_symndx); 294 else 295 in->l_addr.l_paddr = H_GET_64 (abfd, ext->l_addr.l_paddr); 296 } 297 298 static unsigned int 299 _bfd_xcoff64_swap_lineno_out (bfd *abfd, void *inp, void *outp) 300 { 301 struct internal_lineno *in = (struct internal_lineno *) inp; 302 struct external_lineno *ext = (struct external_lineno *) outp; 303 304 H_PUT_32 (abfd, in->l_addr.l_symndx, ext->l_addr.l_symndx); 305 H_PUT_32 (abfd, in->l_lnno, (ext->l_lnno)); 306 307 if (in->l_lnno == 0) 308 H_PUT_32 (abfd, in->l_addr.l_symndx, ext->l_addr.l_symndx); 309 else 310 H_PUT_64 (abfd, in->l_addr.l_paddr, ext->l_addr.l_paddr); 311 312 return bfd_coff_linesz (abfd); 313 } 314 315 static void 316 _bfd_xcoff64_swap_sym_in (bfd *abfd, void *ext1, void *in1) 317 { 318 struct external_syment *ext = (struct external_syment *) ext1; 319 struct internal_syment *in = (struct internal_syment *) in1; 320 321 in->_n._n_n._n_zeroes = 0; 322 in->_n._n_n._n_offset = H_GET_32 (abfd, ext->e_offset); 323 in->n_value = H_GET_64 (abfd, ext->e_value); 324 in->n_scnum = (short) H_GET_16 (abfd, ext->e_scnum); 325 in->n_type = H_GET_16 (abfd, ext->e_type); 326 in->n_sclass = H_GET_8 (abfd, ext->e_sclass); 327 in->n_numaux = H_GET_8 (abfd, ext->e_numaux); 328 } 329 330 static unsigned int 331 _bfd_xcoff64_swap_sym_out (bfd *abfd, void *inp, void *extp) 332 { 333 struct internal_syment *in = (struct internal_syment *) inp; 334 struct external_syment *ext = (struct external_syment *) extp; 335 336 H_PUT_32 (abfd, in->_n._n_n._n_offset, ext->e_offset); 337 H_PUT_64 (abfd, in->n_value, ext->e_value); 338 H_PUT_16 (abfd, in->n_scnum, ext->e_scnum); 339 H_PUT_16 (abfd, in->n_type, ext->e_type); 340 H_PUT_8 (abfd, in->n_sclass, ext->e_sclass); 341 H_PUT_8 (abfd, in->n_numaux, ext->e_numaux); 342 return bfd_coff_symesz (abfd); 343 } 344 345 static void 346 _bfd_xcoff64_swap_aux_in (bfd *abfd, void *ext1, int type, int in_class, 347 int indx, int numaux, void *in1) 348 { 349 union external_auxent *ext = (union external_auxent *) ext1; 350 union internal_auxent *in = (union internal_auxent *) in1; 351 352 switch (in_class) 353 { 354 case C_FILE: 355 if (ext->x_file.x_n.x_n.x_zeroes[0] == 0) 356 { 357 in->x_file.x_n.x_zeroes = 0; 358 in->x_file.x_n.x_offset = 359 H_GET_32 (abfd, ext->x_file.x_n.x_n.x_offset); 360 } 361 else 362 { 363 memcpy (in->x_file.x_fname, ext->x_file.x_n.x_fname, FILNMLEN); 364 } 365 goto end; 366 367 /* RS/6000 "csect" auxents */ 368 case C_EXT: 369 case C_AIX_WEAKEXT: 370 case C_HIDEXT: 371 if (indx + 1 == numaux) 372 { 373 bfd_signed_vma h = 0; 374 bfd_vma l = 0; 375 376 h = H_GET_S32 (abfd, ext->x_csect.x_scnlen_hi); 377 l = H_GET_32 (abfd, ext->x_csect.x_scnlen_lo); 378 379 in->x_csect.x_scnlen.l = h << 32 | (l & 0xffffffff); 380 381 in->x_csect.x_parmhash = H_GET_32 (abfd, ext->x_csect.x_parmhash); 382 in->x_csect.x_snhash = H_GET_16 (abfd, ext->x_csect.x_snhash); 383 /* We don't have to hack bitfields in x_smtyp because it's 384 defined by shifts-and-ands, which are equivalent on all 385 byte orders. */ 386 in->x_csect.x_smtyp = H_GET_8 (abfd, ext->x_csect.x_smtyp); 387 in->x_csect.x_smclas = H_GET_8 (abfd, ext->x_csect.x_smclas); 388 goto end; 389 } 390 break; 391 392 case C_STAT: 393 case C_LEAFSTAT: 394 case C_HIDDEN: 395 if (type == T_NULL) 396 { 397 /* PE defines some extra fields; we zero them out for 398 safety. */ 399 in->x_scn.x_checksum = 0; 400 in->x_scn.x_associated = 0; 401 in->x_scn.x_comdat = 0; 402 403 goto end; 404 } 405 break; 406 } 407 408 if (in_class == C_BLOCK || in_class == C_FCN || ISFCN (type) 409 || ISTAG (in_class)) 410 { 411 in->x_sym.x_fcnary.x_fcn.x_lnnoptr 412 = H_GET_64 (abfd, ext->x_sym.x_fcnary.x_fcn.x_lnnoptr); 413 in->x_sym.x_fcnary.x_fcn.x_endndx.l 414 = H_GET_32 (abfd, ext->x_sym.x_fcnary.x_fcn.x_endndx); 415 } 416 if (ISFCN (type)) 417 { 418 in->x_sym.x_misc.x_fsize 419 = H_GET_32 (abfd, ext->x_sym.x_fcnary.x_fcn.x_fsize); 420 } 421 else 422 { 423 in->x_sym.x_misc.x_lnsz.x_lnno 424 = H_GET_32 (abfd, ext->x_sym.x_fcnary.x_lnsz.x_lnno); 425 in->x_sym.x_misc.x_lnsz.x_size 426 = H_GET_16 (abfd, ext->x_sym.x_fcnary.x_lnsz.x_size); 427 } 428 429 end: ; 430 } 431 432 static unsigned int 433 _bfd_xcoff64_swap_aux_out (bfd *abfd, void *inp, int type, int in_class, 434 int indx ATTRIBUTE_UNUSED, 435 int numaux ATTRIBUTE_UNUSED, 436 void *extp) 437 { 438 union internal_auxent *in = (union internal_auxent *) inp; 439 union external_auxent *ext = (union external_auxent *) extp; 440 441 memset (ext, 0, bfd_coff_auxesz (abfd)); 442 switch (in_class) 443 { 444 case C_FILE: 445 if (in->x_file.x_n.x_zeroes == 0) 446 { 447 H_PUT_32 (abfd, 0, ext->x_file.x_n.x_n.x_zeroes); 448 H_PUT_32 (abfd, in->x_file.x_n.x_offset, 449 ext->x_file.x_n.x_n.x_offset); 450 } 451 else 452 { 453 memcpy (ext->x_file.x_n.x_fname, in->x_file.x_fname, FILNMLEN); 454 } 455 H_PUT_8 (abfd, _AUX_FILE, ext->x_auxtype.x_auxtype); 456 goto end; 457 458 /* RS/6000 "csect" auxents */ 459 case C_EXT: 460 case C_AIX_WEAKEXT: 461 case C_HIDEXT: 462 if (indx + 1 == numaux) 463 { 464 bfd_vma temp; 465 466 temp = in->x_csect.x_scnlen.l & 0xffffffff; 467 H_PUT_32 (abfd, temp, ext->x_csect.x_scnlen_lo); 468 temp = in->x_csect.x_scnlen.l >> 32; 469 H_PUT_32 (abfd, temp, ext->x_csect.x_scnlen_hi); 470 H_PUT_32 (abfd, in->x_csect.x_parmhash, ext->x_csect.x_parmhash); 471 H_PUT_16 (abfd, in->x_csect.x_snhash, ext->x_csect.x_snhash); 472 /* We don't have to hack bitfields in x_smtyp because it's 473 defined by shifts-and-ands, which are equivalent on all 474 byte orders. */ 475 H_PUT_8 (abfd, in->x_csect.x_smtyp, ext->x_csect.x_smtyp); 476 H_PUT_8 (abfd, in->x_csect.x_smclas, ext->x_csect.x_smclas); 477 H_PUT_8 (abfd, _AUX_CSECT, ext->x_auxtype.x_auxtype); 478 goto end; 479 } 480 break; 481 482 case C_STAT: 483 case C_LEAFSTAT: 484 case C_HIDDEN: 485 if (type == T_NULL) 486 { 487 goto end; 488 } 489 break; 490 } 491 492 if (in_class == C_BLOCK || in_class == C_FCN || ISFCN (type) 493 || ISTAG (in_class)) 494 { 495 H_PUT_64 (abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr, 496 ext->x_sym.x_fcnary.x_fcn.x_lnnoptr); 497 H_PUT_8 (abfd, _AUX_FCN, 498 ext->x_auxtype.x_auxtype); 499 H_PUT_32 (abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l, 500 ext->x_sym.x_fcnary.x_fcn.x_endndx); 501 } 502 if (ISFCN (type)) 503 { 504 H_PUT_32 (abfd, in->x_sym.x_misc.x_fsize, 505 ext->x_sym.x_fcnary.x_fcn.x_fsize); 506 } 507 else 508 { 509 H_PUT_32 (abfd, in->x_sym.x_misc.x_lnsz.x_lnno, 510 ext->x_sym.x_fcnary.x_lnsz.x_lnno); 511 H_PUT_16 (abfd, in->x_sym.x_misc.x_lnsz.x_size, 512 ext->x_sym.x_fcnary.x_lnsz.x_size); 513 } 514 515 end: 516 517 return bfd_coff_auxesz (abfd); 518 } 519 520 static bfd_boolean 521 _bfd_xcoff64_put_symbol_name (struct bfd_link_info *info, 522 struct bfd_strtab_hash *strtab, 523 struct internal_syment *sym, 524 const char *name) 525 { 526 bfd_boolean hash; 527 bfd_size_type indx; 528 529 hash = !info->traditional_format; 530 indx = _bfd_stringtab_add (strtab, name, hash, FALSE); 531 532 if (indx == (bfd_size_type) -1) 533 return FALSE; 534 535 sym->_n._n_n._n_zeroes = 0; 536 sym->_n._n_n._n_offset = STRING_SIZE_SIZE + indx; 537 538 return TRUE; 539 } 540 541 static bfd_boolean 542 _bfd_xcoff64_put_ldsymbol_name (bfd *abfd ATTRIBUTE_UNUSED, 543 struct xcoff_loader_info *ldinfo, 544 struct internal_ldsym *ldsym, 545 const char *name) 546 { 547 size_t len; 548 len = strlen (name); 549 550 if (ldinfo->string_size + len + 3 > ldinfo->string_alc) 551 { 552 bfd_size_type newalc; 553 char *newstrings; 554 555 newalc = ldinfo->string_alc * 2; 556 if (newalc == 0) 557 newalc = 32; 558 while (ldinfo->string_size + len + 3 > newalc) 559 newalc *= 2; 560 561 newstrings = bfd_realloc (ldinfo->strings, newalc); 562 if (newstrings == NULL) 563 { 564 ldinfo->failed = TRUE; 565 return FALSE; 566 } 567 ldinfo->string_alc = newalc; 568 ldinfo->strings = newstrings; 569 } 570 571 bfd_put_16 (ldinfo->output_bfd, (bfd_vma) (len + 1), 572 ldinfo->strings + ldinfo->string_size); 573 strcpy (ldinfo->strings + ldinfo->string_size + 2, name); 574 ldsym->_l._l_l._l_zeroes = 0; 575 ldsym->_l._l_l._l_offset = ldinfo->string_size + 2; 576 ldinfo->string_size += len + 3; 577 578 return TRUE; 579 } 580 581 /* Routines to swap information in the XCOFF .loader section. If we 582 ever need to write an XCOFF loader, this stuff will need to be 583 moved to another file shared by the linker (which XCOFF calls the 584 ``binder'') and the loader. */ 585 586 /* Swap in the ldhdr structure. */ 587 588 static void 589 xcoff64_swap_ldhdr_in (bfd *abfd, 590 const void *s, 591 struct internal_ldhdr *dst) 592 { 593 const struct external_ldhdr *src = (const struct external_ldhdr *) s; 594 595 dst->l_version = bfd_get_32 (abfd, src->l_version); 596 dst->l_nsyms = bfd_get_32 (abfd, src->l_nsyms); 597 dst->l_nreloc = bfd_get_32 (abfd, src->l_nreloc); 598 dst->l_istlen = bfd_get_32 (abfd, src->l_istlen); 599 dst->l_nimpid = bfd_get_32 (abfd, src->l_nimpid); 600 dst->l_stlen = bfd_get_32 (abfd, src->l_stlen); 601 dst->l_impoff = bfd_get_64 (abfd, src->l_impoff); 602 dst->l_stoff = bfd_get_64 (abfd, src->l_stoff); 603 dst->l_symoff = bfd_get_64 (abfd, src->l_symoff); 604 dst->l_rldoff = bfd_get_64 (abfd, src->l_rldoff); 605 } 606 607 /* Swap out the ldhdr structure. */ 608 609 static void 610 xcoff64_swap_ldhdr_out (bfd *abfd, const struct internal_ldhdr *src, void *d) 611 { 612 struct external_ldhdr *dst = (struct external_ldhdr *) d; 613 614 bfd_put_32 (abfd, (bfd_vma) src->l_version, dst->l_version); 615 bfd_put_32 (abfd, src->l_nsyms, dst->l_nsyms); 616 bfd_put_32 (abfd, src->l_nreloc, dst->l_nreloc); 617 bfd_put_32 (abfd, src->l_istlen, dst->l_istlen); 618 bfd_put_32 (abfd, src->l_nimpid, dst->l_nimpid); 619 bfd_put_32 (abfd, src->l_stlen, dst->l_stlen); 620 bfd_put_64 (abfd, src->l_impoff, dst->l_impoff); 621 bfd_put_64 (abfd, src->l_stoff, dst->l_stoff); 622 bfd_put_64 (abfd, src->l_symoff, dst->l_symoff); 623 bfd_put_64 (abfd, src->l_rldoff, dst->l_rldoff); 624 } 625 626 /* Swap in the ldsym structure. */ 627 628 static void 629 xcoff64_swap_ldsym_in (bfd *abfd, const void *s, struct internal_ldsym *dst) 630 { 631 const struct external_ldsym *src = (const struct external_ldsym *) s; 632 /* XCOFF64 does not use l_zeroes like XCOFF32 633 Set the internal l_zeroes to 0 so the common 32/64 code uses l_value 634 as an offset into the loader symbol table. */ 635 dst->_l._l_l._l_zeroes = 0; 636 dst->_l._l_l._l_offset = bfd_get_32 (abfd, src->l_offset); 637 dst->l_value = bfd_get_64 (abfd, src->l_value); 638 dst->l_scnum = bfd_get_16 (abfd, src->l_scnum); 639 dst->l_smtype = bfd_get_8 (abfd, src->l_smtype); 640 dst->l_smclas = bfd_get_8 (abfd, src->l_smclas); 641 dst->l_ifile = bfd_get_32 (abfd, src->l_ifile); 642 dst->l_parm = bfd_get_32 (abfd, src->l_parm); 643 } 644 645 /* Swap out the ldsym structure. */ 646 647 static void 648 xcoff64_swap_ldsym_out (bfd *abfd, const struct internal_ldsym *src, void *d) 649 { 650 struct external_ldsym *dst = (struct external_ldsym *) d; 651 652 bfd_put_64 (abfd, src->l_value, dst->l_value); 653 bfd_put_32 (abfd, (bfd_vma) src->_l._l_l._l_offset, dst->l_offset); 654 bfd_put_16 (abfd, (bfd_vma) src->l_scnum, dst->l_scnum); 655 bfd_put_8 (abfd, src->l_smtype, dst->l_smtype); 656 bfd_put_8 (abfd, src->l_smclas, dst->l_smclas); 657 bfd_put_32 (abfd, src->l_ifile, dst->l_ifile); 658 bfd_put_32 (abfd, src->l_parm, dst->l_parm); 659 } 660 661 static void 662 xcoff64_swap_reloc_in (bfd *abfd, void *s, void *d) 663 { 664 struct external_reloc *src = (struct external_reloc *) s; 665 struct internal_reloc *dst = (struct internal_reloc *) d; 666 667 memset (dst, 0, sizeof (struct internal_reloc)); 668 669 dst->r_vaddr = bfd_get_64 (abfd, src->r_vaddr); 670 dst->r_symndx = bfd_get_32 (abfd, src->r_symndx); 671 dst->r_size = bfd_get_8 (abfd, src->r_size); 672 dst->r_type = bfd_get_8 (abfd, src->r_type); 673 } 674 675 static unsigned int 676 xcoff64_swap_reloc_out (bfd *abfd, void *s, void *d) 677 { 678 struct internal_reloc *src = (struct internal_reloc *) s; 679 struct external_reloc *dst = (struct external_reloc *) d; 680 681 bfd_put_64 (abfd, src->r_vaddr, dst->r_vaddr); 682 bfd_put_32 (abfd, src->r_symndx, dst->r_symndx); 683 bfd_put_8 (abfd, src->r_type, dst->r_type); 684 bfd_put_8 (abfd, src->r_size, dst->r_size); 685 686 return bfd_coff_relsz (abfd); 687 } 688 689 /* Swap in the ldrel structure. */ 690 691 static void 692 xcoff64_swap_ldrel_in (bfd *abfd, const void *s, struct internal_ldrel *dst) 693 { 694 const struct external_ldrel *src = (const struct external_ldrel *) s; 695 696 dst->l_vaddr = bfd_get_64 (abfd, src->l_vaddr); 697 dst->l_symndx = bfd_get_32 (abfd, src->l_symndx); 698 dst->l_rtype = bfd_get_16 (abfd, src->l_rtype); 699 dst->l_rsecnm = bfd_get_16 (abfd, src->l_rsecnm); 700 } 701 702 /* Swap out the ldrel structure. */ 703 704 static void 705 xcoff64_swap_ldrel_out (bfd *abfd, const struct internal_ldrel *src, void *d) 706 { 707 struct external_ldrel *dst = (struct external_ldrel *) d; 708 709 bfd_put_64 (abfd, src->l_vaddr, dst->l_vaddr); 710 bfd_put_16 (abfd, (bfd_vma) src->l_rtype, dst->l_rtype); 711 bfd_put_16 (abfd, (bfd_vma) src->l_rsecnm, dst->l_rsecnm); 712 bfd_put_32 (abfd, src->l_symndx, dst->l_symndx); 713 } 714 715 static bfd_boolean 716 xcoff64_write_object_contents (bfd *abfd) 717 { 718 asection *current; 719 bfd_boolean hasrelocs = FALSE; 720 bfd_boolean haslinno = FALSE; 721 file_ptr scn_base; 722 file_ptr reloc_base; 723 file_ptr lineno_base; 724 file_ptr sym_base; 725 unsigned long reloc_size = 0; 726 unsigned long lnno_size = 0; 727 asection *text_sec = NULL; 728 asection *data_sec = NULL; 729 asection *bss_sec = NULL; 730 struct internal_filehdr internal_f; 731 struct internal_aouthdr internal_a; 732 733 bfd_set_error (bfd_error_system_call); 734 735 if (! abfd->output_has_begun) 736 { 737 if (! bfd_coff_compute_section_file_positions (abfd)) 738 return FALSE; 739 } 740 741 /* Work out the size of the reloc and linno areas. */ 742 reloc_base = obj_relocbase (abfd); 743 744 for (current = abfd->sections; current != NULL; current = current->next) 745 reloc_size += current->reloc_count * bfd_coff_relsz (abfd); 746 747 lineno_base = reloc_base + reloc_size; 748 749 /* Make a pass through the symbol table to count line number entries and 750 put them into the correct asections. */ 751 lnno_size = coff_count_linenumbers (abfd) * bfd_coff_linesz (abfd); 752 753 sym_base = lineno_base + lnno_size; 754 755 /* Indicate in each section->line_filepos its actual file address. */ 756 for (current = abfd->sections; current != NULL; current = current->next) 757 { 758 if (current->lineno_count) 759 { 760 current->line_filepos = lineno_base; 761 current->moving_line_filepos = lineno_base; 762 lineno_base += current->lineno_count * bfd_coff_linesz (abfd); 763 } 764 else 765 { 766 current->line_filepos = 0; 767 } 768 769 if (current->reloc_count) 770 { 771 current->rel_filepos = reloc_base; 772 reloc_base += current->reloc_count * bfd_coff_relsz (abfd); 773 } 774 else 775 { 776 current->rel_filepos = 0; 777 } 778 } 779 780 if ((abfd->flags & EXEC_P) != 0) 781 { 782 scn_base = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd); 783 internal_f.f_opthdr = bfd_coff_aoutsz (abfd); 784 } 785 else 786 { 787 scn_base = bfd_coff_filhsz (abfd); 788 internal_f.f_opthdr = 0; 789 } 790 791 internal_f.f_nscns = 0; 792 793 if (bfd_seek (abfd, scn_base, SEEK_SET) != 0) 794 return FALSE; 795 796 for (current = abfd->sections; current != NULL; current = current->next) 797 { 798 struct internal_scnhdr section; 799 struct external_scnhdr buff; 800 bfd_size_type amount; 801 802 internal_f.f_nscns++; 803 804 strncpy (section.s_name, current->name, SCNNMLEN); 805 806 section.s_vaddr = current->vma; 807 section.s_paddr = current->lma; 808 section.s_size = current->size; 809 810 /* If this section has no size or is unloadable then the scnptr 811 will be 0 too. */ 812 if (current->size == 0 813 || (current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0) 814 { 815 section.s_scnptr = 0; 816 } 817 else 818 { 819 section.s_scnptr = current->filepos; 820 } 821 822 section.s_relptr = current->rel_filepos; 823 section.s_lnnoptr = current->line_filepos; 824 section.s_nreloc = current->reloc_count; 825 826 section.s_nlnno = current->lineno_count; 827 if (current->reloc_count != 0) 828 hasrelocs = TRUE; 829 if (current->lineno_count != 0) 830 haslinno = TRUE; 831 832 section.s_flags = sec_to_styp_flags (current->name, current->flags); 833 834 if (!strcmp (current->name, _TEXT)) 835 { 836 text_sec = current; 837 } 838 else if (!strcmp (current->name, _DATA)) 839 { 840 data_sec = current; 841 } 842 else if (!strcmp (current->name, _BSS)) 843 { 844 bss_sec = current; 845 } 846 847 amount = bfd_coff_scnhsz (abfd); 848 if (bfd_coff_swap_scnhdr_out (abfd, §ion, &buff) == 0 849 || bfd_bwrite (&buff, amount, abfd) != amount) 850 return FALSE; 851 } 852 853 internal_f.f_timdat = 0; 854 855 internal_f.f_flags = 0; 856 857 if (!hasrelocs) 858 internal_f.f_flags |= F_RELFLG; 859 if (!haslinno) 860 internal_f.f_flags |= F_LNNO; 861 if (abfd->flags & EXEC_P) 862 internal_f.f_flags |= F_EXEC; 863 864 /* FIXME: this is wrong for PPC_PE! */ 865 if (bfd_little_endian (abfd)) 866 internal_f.f_flags |= F_AR32WR; 867 else 868 internal_f.f_flags |= F_AR32W; 869 870 if ((abfd->flags & DYNAMIC) != 0) 871 internal_f.f_flags |= F_SHROBJ; 872 if (bfd_get_section_by_name (abfd, _LOADER) != NULL) 873 internal_f.f_flags |= F_DYNLOAD; 874 875 memset (&internal_a, 0, sizeof internal_a); 876 877 internal_f.f_magic = bfd_xcoff_magic_number (abfd); 878 internal_a.magic = (abfd->flags & D_PAGED 879 ? RS6K_AOUTHDR_ZMAGIC 880 : (abfd->flags & WP_TEXT 881 ? RS6K_AOUTHDR_NMAGIC 882 : RS6K_AOUTHDR_OMAGIC)); 883 884 /* FIXME: Does anybody ever set this to another value? */ 885 internal_a.vstamp = 0; 886 887 /* Now should write relocs, strings, syms. */ 888 obj_sym_filepos (abfd) = sym_base; 889 890 internal_f.f_symptr = 0; 891 internal_f.f_nsyms = 0; 892 893 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF 894 backend linker, and obj_raw_syment_count is not valid until after 895 coff_write_symbols is called. */ 896 if (bfd_get_symcount (abfd) != 0) 897 { 898 int firstundef; 899 900 if (!coff_renumber_symbols (abfd, &firstundef)) 901 return FALSE; 902 coff_mangle_symbols (abfd); 903 if (! coff_write_symbols (abfd)) 904 return FALSE; 905 if (! coff_write_linenumbers (abfd)) 906 return FALSE; 907 if (! coff_write_relocs (abfd, firstundef)) 908 return FALSE; 909 910 internal_f.f_symptr = sym_base; 911 internal_f.f_nsyms = bfd_get_symcount (abfd); 912 } 913 else if (obj_raw_syment_count (abfd) != 0) 914 { 915 internal_f.f_symptr = sym_base; 916 917 /* AIX appears to require that F_RELFLG not be set if there are 918 local symbols but no relocations. */ 919 internal_f.f_flags &=~ F_RELFLG; 920 } 921 else 922 { 923 internal_f.f_flags |= F_LSYMS; 924 } 925 926 if (text_sec) 927 { 928 internal_a.tsize = text_sec->size; 929 internal_a.text_start = internal_a.tsize ? text_sec->vma : 0; 930 } 931 932 if (data_sec) 933 { 934 internal_a.dsize = data_sec->size; 935 internal_a.data_start = internal_a.dsize ? data_sec->vma : 0; 936 } 937 938 if (bss_sec) 939 { 940 internal_a.bsize = bss_sec->size; 941 if (internal_a.bsize && bss_sec->vma < internal_a.data_start) 942 internal_a.data_start = bss_sec->vma; 943 } 944 945 internal_a.entry = bfd_get_start_address (abfd); 946 internal_f.f_nsyms = obj_raw_syment_count (abfd); 947 948 if (xcoff_data (abfd)->full_aouthdr) 949 { 950 bfd_vma toc; 951 asection *loader_sec; 952 953 internal_a.vstamp = 1; 954 955 internal_a.o_snentry = xcoff_data (abfd)->snentry; 956 if (internal_a.o_snentry == 0) 957 internal_a.entry = (bfd_vma) -1; 958 959 if (text_sec != NULL) 960 { 961 internal_a.o_sntext = text_sec->target_index; 962 internal_a.o_algntext = bfd_section_alignment (text_sec); 963 } 964 else 965 { 966 internal_a.o_sntext = 0; 967 internal_a.o_algntext = 0; 968 } 969 970 if (data_sec != NULL) 971 { 972 internal_a.o_sndata = data_sec->target_index; 973 internal_a.o_algndata = bfd_section_alignment (data_sec); 974 } 975 else 976 { 977 internal_a.o_sndata = 0; 978 internal_a.o_algndata = 0; 979 } 980 981 loader_sec = bfd_get_section_by_name (abfd, ".loader"); 982 if (loader_sec != NULL) 983 internal_a.o_snloader = loader_sec->target_index; 984 else 985 internal_a.o_snloader = 0; 986 if (bss_sec != NULL) 987 internal_a.o_snbss = bss_sec->target_index; 988 else 989 internal_a.o_snbss = 0; 990 991 toc = xcoff_data (abfd)->toc; 992 internal_a.o_toc = toc; 993 internal_a.o_sntoc = xcoff_data (abfd)->sntoc; 994 995 internal_a.o_modtype = xcoff_data (abfd)->modtype; 996 if (xcoff_data (abfd)->cputype != -1) 997 internal_a.o_cputype = xcoff_data (abfd)->cputype; 998 else 999 { 1000 switch (bfd_get_arch (abfd)) 1001 { 1002 case bfd_arch_rs6000: 1003 internal_a.o_cputype = 4; 1004 break; 1005 case bfd_arch_powerpc: 1006 if (bfd_get_mach (abfd) == bfd_mach_ppc) 1007 internal_a.o_cputype = 3; 1008 else if (bfd_get_mach (abfd) == bfd_mach_ppc_620) 1009 internal_a.o_cputype = 2; 1010 else 1011 internal_a.o_cputype = 1; 1012 break; 1013 default: 1014 abort (); 1015 } 1016 } 1017 internal_a.o_maxstack = xcoff_data (abfd)->maxstack; 1018 internal_a.o_maxdata = xcoff_data (abfd)->maxdata; 1019 } 1020 1021 if (bfd_seek (abfd, (file_ptr) 0, 0) != 0) 1022 return FALSE; 1023 1024 { 1025 char * buff; 1026 bfd_size_type amount = bfd_coff_filhsz (abfd); 1027 1028 buff = bfd_malloc (amount); 1029 if (buff == NULL) 1030 return FALSE; 1031 1032 bfd_coff_swap_filehdr_out (abfd, &internal_f, buff); 1033 amount = bfd_bwrite (buff, amount, abfd); 1034 1035 free (buff); 1036 1037 if (amount != bfd_coff_filhsz (abfd)) 1038 return FALSE; 1039 } 1040 1041 if (abfd->flags & EXEC_P) 1042 { 1043 char * buff; 1044 bfd_size_type amount = bfd_coff_aoutsz (abfd); 1045 1046 buff = bfd_malloc (amount); 1047 if (buff == NULL) 1048 return FALSE; 1049 1050 bfd_coff_swap_aouthdr_out (abfd, &internal_a, buff); 1051 amount = bfd_bwrite (buff, amount, abfd); 1052 1053 free (buff); 1054 1055 if (amount != bfd_coff_aoutsz (abfd)) 1056 return FALSE; 1057 } 1058 1059 return TRUE; 1060 } 1061 1062 static bfd_boolean 1063 xcoff64_reloc_type_br (bfd *input_bfd, 1064 asection *input_section, 1065 bfd *output_bfd ATTRIBUTE_UNUSED, 1066 struct internal_reloc *rel, 1067 struct internal_syment *sym ATTRIBUTE_UNUSED, 1068 struct reloc_howto_struct *howto, 1069 bfd_vma val, 1070 bfd_vma addend, 1071 bfd_vma *relocation, 1072 bfd_byte *contents) 1073 { 1074 struct xcoff_link_hash_entry *h; 1075 bfd_vma section_offset; 1076 1077 if (0 > rel->r_symndx) 1078 return FALSE; 1079 1080 h = obj_xcoff_sym_hashes (input_bfd)[rel->r_symndx]; 1081 section_offset = rel->r_vaddr - input_section->vma; 1082 1083 /* If we see an R_BR or R_RBR reloc which is jumping to global 1084 linkage code, and it is followed by an appropriate cror nop 1085 instruction, we replace the cror with ld r2,40(r1). This 1086 restores the TOC after the glink code. Contrariwise, if the 1087 call is followed by a ld r2,40(r1), but the call is not 1088 going to global linkage code, we can replace the load with a 1089 cror. */ 1090 if (NULL != h 1091 && (bfd_link_hash_defined == h->root.type 1092 || bfd_link_hash_defweak == h->root.type) 1093 && section_offset + 8 <= input_section->size) 1094 { 1095 bfd_byte *pnext; 1096 unsigned long next; 1097 1098 pnext = contents + section_offset + 4; 1099 next = bfd_get_32 (input_bfd, pnext); 1100 1101 /* The _ptrgl function is magic. It is used by the AIX compiler to call 1102 a function through a pointer. */ 1103 if (h->smclas == XMC_GL || strcmp (h->root.root.string, "._ptrgl") == 0) 1104 { 1105 if (next == 0x4def7b82 /* cror 15,15,15 */ 1106 || next == 0x4ffffb82 /* cror 31,31,31 */ 1107 || next == 0x60000000) /* ori r0,r0,0 */ 1108 bfd_put_32 (input_bfd, 0xe8410028, pnext); /* ld r2,40(r1) */ 1109 } 1110 else 1111 { 1112 if (next == 0xe8410028) /* ld r2,40(r1) */ 1113 bfd_put_32 (input_bfd, 0x60000000, pnext); /* ori r0,r0,0 */ 1114 } 1115 } 1116 else if (NULL != h && bfd_link_hash_undefined == h->root.type) 1117 { 1118 /* Normally, this relocation is against a defined symbol. In the 1119 case where this is a partial link and the output section offset 1120 is greater than 2^25, the linker will return an invalid error 1121 message that the relocation has been truncated. Yes it has been 1122 truncated but no it not important. For this case, disable the 1123 overflow checking. */ 1124 howto->complain_on_overflow = complain_overflow_dont; 1125 } 1126 1127 /* The original PC-relative relocation is biased by -r_vaddr, so adding 1128 the value below will give the absolute target address. */ 1129 *relocation = val + addend + rel->r_vaddr; 1130 1131 howto->src_mask &= ~3; 1132 howto->dst_mask = howto->src_mask; 1133 1134 if (h != NULL 1135 && (h->root.type == bfd_link_hash_defined 1136 || h->root.type == bfd_link_hash_defweak) 1137 && bfd_is_abs_section (h->root.u.def.section) 1138 && section_offset + 4 <= input_section->size) 1139 { 1140 bfd_byte *ptr; 1141 bfd_vma insn; 1142 1143 /* Turn the relative branch into an absolute one by setting the 1144 AA bit. */ 1145 ptr = contents + section_offset; 1146 insn = bfd_get_32 (input_bfd, ptr); 1147 insn |= 2; 1148 bfd_put_32 (input_bfd, insn, ptr); 1149 1150 /* Make the howto absolute too. */ 1151 howto->pc_relative = FALSE; 1152 howto->complain_on_overflow = complain_overflow_bitfield; 1153 } 1154 else 1155 { 1156 /* Use a PC-relative howto and subtract the instruction's address 1157 from the target address we calculated above. */ 1158 howto->pc_relative = TRUE; 1159 *relocation -= (input_section->output_section->vma 1160 + input_section->output_offset 1161 + section_offset); 1162 } 1163 return TRUE; 1164 } 1165 1166 /* This is the relocation function for the PowerPC64. 1167 See xcoff_ppc_relocation_section for more information. */ 1168 1169 bfd_boolean 1170 xcoff64_ppc_relocate_section (bfd *output_bfd, 1171 struct bfd_link_info *info, 1172 bfd *input_bfd, 1173 asection *input_section, 1174 bfd_byte *contents, 1175 struct internal_reloc *relocs, 1176 struct internal_syment *syms, 1177 asection **sections) 1178 { 1179 struct internal_reloc *rel; 1180 struct internal_reloc *relend; 1181 1182 rel = relocs; 1183 relend = rel + input_section->reloc_count; 1184 for (; rel < relend; rel++) 1185 { 1186 long symndx; 1187 struct xcoff_link_hash_entry *h; 1188 struct internal_syment *sym; 1189 bfd_vma addend; 1190 bfd_vma val; 1191 struct reloc_howto_struct howto; 1192 bfd_vma relocation; 1193 bfd_vma value_to_relocate; 1194 bfd_vma address; 1195 bfd_byte *location; 1196 1197 /* Relocation type R_REF is a special relocation type which is 1198 merely used to prevent garbage collection from occurring for 1199 the csect including the symbol which it references. */ 1200 if (rel->r_type == R_REF) 1201 continue; 1202 1203 /* howto */ 1204 howto.type = rel->r_type; 1205 howto.rightshift = 0; 1206 howto.bitsize = (rel->r_size & 0x3f) + 1; 1207 howto.size = howto.bitsize > 16 ? (howto.bitsize > 32 ? 4 : 2) : 1; 1208 howto.pc_relative = FALSE; 1209 howto.bitpos = 0; 1210 howto.complain_on_overflow = (rel->r_size & 0x80 1211 ? complain_overflow_signed 1212 : complain_overflow_bitfield); 1213 howto.special_function = NULL; 1214 howto.name = "internal"; 1215 howto.partial_inplace = TRUE; 1216 howto.src_mask = howto.dst_mask = N_ONES (howto.bitsize); 1217 howto.pcrel_offset = FALSE; 1218 1219 /* symbol */ 1220 val = 0; 1221 addend = 0; 1222 h = NULL; 1223 sym = NULL; 1224 symndx = rel->r_symndx; 1225 1226 if (-1 != symndx) 1227 { 1228 asection *sec; 1229 1230 h = obj_xcoff_sym_hashes (input_bfd)[symndx]; 1231 sym = syms + symndx; 1232 addend = - sym->n_value; 1233 1234 if (NULL == h) 1235 { 1236 sec = sections[symndx]; 1237 /* Hack to make sure we use the right TOC anchor value 1238 if this reloc is against the TOC anchor. */ 1239 if (sec->name[3] == '0' 1240 && strcmp (sec->name, ".tc0") == 0) 1241 val = xcoff_data (output_bfd)->toc; 1242 else 1243 val = (sec->output_section->vma 1244 + sec->output_offset 1245 + sym->n_value 1246 - sec->vma); 1247 } 1248 else 1249 { 1250 if (info->unresolved_syms_in_objects != RM_IGNORE 1251 && (h->flags & XCOFF_WAS_UNDEFINED) != 0) 1252 (*info->callbacks->undefined_symbol) 1253 (info, h->root.root.string, input_bfd, input_section, 1254 rel->r_vaddr - input_section->vma, 1255 info->unresolved_syms_in_objects == RM_GENERATE_ERROR); 1256 1257 if (h->root.type == bfd_link_hash_defined 1258 || h->root.type == bfd_link_hash_defweak) 1259 { 1260 sec = h->root.u.def.section; 1261 val = (h->root.u.def.value 1262 + sec->output_section->vma 1263 + sec->output_offset); 1264 } 1265 else if (h->root.type == bfd_link_hash_common) 1266 { 1267 sec = h->root.u.c.p->section; 1268 val = (sec->output_section->vma 1269 + sec->output_offset); 1270 } 1271 else 1272 { 1273 BFD_ASSERT (bfd_link_relocatable (info) 1274 || (h->flags & XCOFF_DEF_DYNAMIC) != 0 1275 || (h->flags & XCOFF_IMPORT) != 0); 1276 } 1277 } 1278 } 1279 1280 if (rel->r_type >= XCOFF_MAX_CALCULATE_RELOCATION 1281 || !((*xcoff64_calculate_relocation[rel->r_type]) 1282 (input_bfd, input_section, output_bfd, rel, sym, &howto, val, 1283 addend, &relocation, contents))) 1284 return FALSE; 1285 1286 /* address */ 1287 address = rel->r_vaddr - input_section->vma; 1288 location = contents + address; 1289 1290 if (address > input_section->size) 1291 abort (); 1292 1293 /* Get the value we are going to relocate. */ 1294 if (1 == howto.size) 1295 value_to_relocate = bfd_get_16 (input_bfd, location); 1296 else if (2 == howto.size) 1297 value_to_relocate = bfd_get_32 (input_bfd, location); 1298 else 1299 value_to_relocate = bfd_get_64 (input_bfd, location); 1300 1301 /* overflow. 1302 1303 FIXME: We may drop bits during the addition 1304 which we don't check for. We must either check at every single 1305 operation, which would be tedious, or we must do the computations 1306 in a type larger than bfd_vma, which would be inefficient. */ 1307 1308 if (((*xcoff_complain_overflow[howto.complain_on_overflow]) 1309 (input_bfd, value_to_relocate, relocation, &howto))) 1310 { 1311 const char *name; 1312 char buf[SYMNMLEN + 1]; 1313 char reloc_type_name[10]; 1314 1315 if (symndx == -1) 1316 { 1317 name = "*ABS*"; 1318 } 1319 else if (h != NULL) 1320 { 1321 name = NULL; 1322 } 1323 else 1324 { 1325 name = _bfd_coff_internal_syment_name (input_bfd, sym, buf); 1326 if (name == NULL) 1327 name = "UNKNOWN"; 1328 } 1329 sprintf (reloc_type_name, "0x%02x", rel->r_type); 1330 1331 (*info->callbacks->reloc_overflow) 1332 (info, (h ? &h->root : NULL), name, reloc_type_name, 1333 (bfd_vma) 0, input_bfd, input_section, 1334 rel->r_vaddr - input_section->vma); 1335 } 1336 1337 /* Add RELOCATION to the right bits of VALUE_TO_RELOCATE. */ 1338 value_to_relocate = ((value_to_relocate & ~howto.dst_mask) 1339 | (((value_to_relocate & howto.src_mask) 1340 + relocation) & howto.dst_mask)); 1341 1342 /* Put the value back in the object file. */ 1343 if (1 == howto.size) 1344 bfd_put_16 (input_bfd, value_to_relocate, location); 1345 else if (2 == howto.size) 1346 bfd_put_32 (input_bfd, value_to_relocate, location); 1347 else 1348 bfd_put_64 (input_bfd, value_to_relocate, location); 1349 1350 } 1351 return TRUE; 1352 } 1353 1354 1355 /* The XCOFF reloc table. Actually, XCOFF relocations specify the 1356 bitsize and whether they are signed or not, along with a 1357 conventional type. This table is for the types, which are used for 1358 different algorithms for putting in the reloc. Many of these 1359 relocs need special_function entries, which I have not written. */ 1360 1361 reloc_howto_type xcoff64_howto_table[] = 1362 { 1363 /* 0x00: Standard 64 bit relocation. */ 1364 HOWTO (R_POS, /* type */ 1365 0, /* rightshift */ 1366 4, /* size (0 = byte, 1 = short, 2 = long) */ 1367 64, /* bitsize */ 1368 FALSE, /* pc_relative */ 1369 0, /* bitpos */ 1370 complain_overflow_bitfield, /* complain_on_overflow */ 1371 0, /* special_function */ 1372 "R_POS_64", /* name */ 1373 TRUE, /* partial_inplace */ 1374 MINUS_ONE, /* src_mask */ 1375 MINUS_ONE, /* dst_mask */ 1376 FALSE), /* pcrel_offset */ 1377 1378 /* 0x01: 64 bit relocation, but store negative value. */ 1379 HOWTO (R_NEG, /* type */ 1380 0, /* rightshift */ 1381 -4, /* size (0 = byte, 1 = short, 2 = long) */ 1382 64, /* bitsize */ 1383 FALSE, /* pc_relative */ 1384 0, /* bitpos */ 1385 complain_overflow_bitfield, /* complain_on_overflow */ 1386 0, /* special_function */ 1387 "R_NEG", /* name */ 1388 TRUE, /* partial_inplace */ 1389 MINUS_ONE, /* src_mask */ 1390 MINUS_ONE, /* dst_mask */ 1391 FALSE), /* pcrel_offset */ 1392 1393 /* 0x02: 32 bit PC relative relocation. */ 1394 HOWTO (R_REL, /* type */ 1395 0, /* rightshift */ 1396 2, /* size (0 = byte, 1 = short, 2 = long) */ 1397 32, /* bitsize */ 1398 TRUE, /* pc_relative */ 1399 0, /* bitpos */ 1400 complain_overflow_signed, /* complain_on_overflow */ 1401 0, /* special_function */ 1402 "R_REL", /* name */ 1403 TRUE, /* partial_inplace */ 1404 0xffffffff, /* src_mask */ 1405 0xffffffff, /* dst_mask */ 1406 FALSE), /* pcrel_offset */ 1407 1408 /* 0x03: 16 bit TOC relative relocation. */ 1409 HOWTO (R_TOC, /* type */ 1410 0, /* rightshift */ 1411 1, /* size (0 = byte, 1 = short, 2 = long) */ 1412 16, /* bitsize */ 1413 FALSE, /* pc_relative */ 1414 0, /* bitpos */ 1415 complain_overflow_bitfield, /* complain_on_overflow */ 1416 0, /* special_function */ 1417 "R_TOC", /* name */ 1418 TRUE, /* partial_inplace */ 1419 0xffff, /* src_mask */ 1420 0xffff, /* dst_mask */ 1421 FALSE), /* pcrel_offset */ 1422 1423 /* 0x04: I don't really know what this is. */ 1424 HOWTO (R_RTB, /* type */ 1425 1, /* rightshift */ 1426 2, /* size (0 = byte, 1 = short, 2 = long) */ 1427 32, /* bitsize */ 1428 FALSE, /* pc_relative */ 1429 0, /* bitpos */ 1430 complain_overflow_bitfield, /* complain_on_overflow */ 1431 0, /* special_function */ 1432 "R_RTB", /* name */ 1433 TRUE, /* partial_inplace */ 1434 0xffffffff, /* src_mask */ 1435 0xffffffff, /* dst_mask */ 1436 FALSE), /* pcrel_offset */ 1437 1438 /* 0x05: External TOC relative symbol. */ 1439 HOWTO (R_GL, /* type */ 1440 0, /* rightshift */ 1441 1, /* size (0 = byte, 1 = short, 2 = long) */ 1442 16, /* bitsize */ 1443 FALSE, /* pc_relative */ 1444 0, /* bitpos */ 1445 complain_overflow_bitfield, /* complain_on_overflow */ 1446 0, /* special_function */ 1447 "R_GL", /* name */ 1448 TRUE, /* partial_inplace */ 1449 0xffff, /* src_mask */ 1450 0xffff, /* dst_mask */ 1451 FALSE), /* pcrel_offset */ 1452 1453 /* 0x06: Local TOC relative symbol. */ 1454 HOWTO (R_TCL, /* type */ 1455 0, /* rightshift */ 1456 1, /* size (0 = byte, 1 = short, 2 = long) */ 1457 16, /* bitsize */ 1458 FALSE, /* pc_relative */ 1459 0, /* bitpos */ 1460 complain_overflow_bitfield, /* complain_on_overflow */ 1461 0, /* special_function */ 1462 "R_TCL", /* name */ 1463 TRUE, /* partial_inplace */ 1464 0xffff, /* src_mask */ 1465 0xffff, /* dst_mask */ 1466 FALSE), /* pcrel_offset */ 1467 1468 EMPTY_HOWTO (7), 1469 1470 /* 0x08: Non modifiable absolute branch. */ 1471 HOWTO (R_BA, /* type */ 1472 0, /* rightshift */ 1473 2, /* size (0 = byte, 1 = short, 2 = long) */ 1474 26, /* bitsize */ 1475 FALSE, /* pc_relative */ 1476 0, /* bitpos */ 1477 complain_overflow_bitfield, /* complain_on_overflow */ 1478 0, /* special_function */ 1479 "R_BA_26", /* name */ 1480 TRUE, /* partial_inplace */ 1481 0x03fffffc, /* src_mask */ 1482 0x03fffffc, /* dst_mask */ 1483 FALSE), /* pcrel_offset */ 1484 1485 EMPTY_HOWTO (9), 1486 1487 /* 0x0a: Non modifiable relative branch. */ 1488 HOWTO (R_BR, /* type */ 1489 0, /* rightshift */ 1490 2, /* size (0 = byte, 1 = short, 2 = long) */ 1491 26, /* bitsize */ 1492 TRUE, /* pc_relative */ 1493 0, /* bitpos */ 1494 complain_overflow_signed, /* complain_on_overflow */ 1495 0, /* special_function */ 1496 "R_BR", /* name */ 1497 TRUE, /* partial_inplace */ 1498 0x03fffffc, /* src_mask */ 1499 0x03fffffc, /* dst_mask */ 1500 FALSE), /* pcrel_offset */ 1501 1502 EMPTY_HOWTO (0xb), 1503 1504 /* 0x0c: Indirect load. */ 1505 HOWTO (R_RL, /* type */ 1506 0, /* rightshift */ 1507 1, /* size (0 = byte, 1 = short, 2 = long) */ 1508 16, /* bitsize */ 1509 FALSE, /* pc_relative */ 1510 0, /* bitpos */ 1511 complain_overflow_bitfield, /* complain_on_overflow */ 1512 0, /* special_function */ 1513 "R_RL", /* name */ 1514 TRUE, /* partial_inplace */ 1515 0xffff, /* src_mask */ 1516 0xffff, /* dst_mask */ 1517 FALSE), /* pcrel_offset */ 1518 1519 /* 0x0d: Load address. */ 1520 HOWTO (R_RLA, /* type */ 1521 0, /* rightshift */ 1522 1, /* size (0 = byte, 1 = short, 2 = long) */ 1523 16, /* bitsize */ 1524 FALSE, /* pc_relative */ 1525 0, /* bitpos */ 1526 complain_overflow_bitfield, /* complain_on_overflow */ 1527 0, /* special_function */ 1528 "R_RLA", /* name */ 1529 TRUE, /* partial_inplace */ 1530 0xffff, /* src_mask */ 1531 0xffff, /* dst_mask */ 1532 FALSE), /* pcrel_offset */ 1533 1534 EMPTY_HOWTO (0xe), 1535 1536 /* 0x0f: Non-relocating reference. Bitsize is 1 so that r_rsize is 0. */ 1537 HOWTO (R_REF, /* type */ 1538 0, /* rightshift */ 1539 0, /* size (0 = byte, 1 = short, 2 = long) */ 1540 1, /* bitsize */ 1541 FALSE, /* pc_relative */ 1542 0, /* bitpos */ 1543 complain_overflow_dont, /* complain_on_overflow */ 1544 0, /* special_function */ 1545 "R_REF", /* name */ 1546 FALSE, /* partial_inplace */ 1547 0, /* src_mask */ 1548 0, /* dst_mask */ 1549 FALSE), /* pcrel_offset */ 1550 1551 EMPTY_HOWTO (0x10), 1552 EMPTY_HOWTO (0x11), 1553 1554 /* 0x12: TOC relative indirect load. */ 1555 HOWTO (R_TRL, /* type */ 1556 0, /* rightshift */ 1557 1, /* size (0 = byte, 1 = short, 2 = long) */ 1558 16, /* bitsize */ 1559 FALSE, /* pc_relative */ 1560 0, /* bitpos */ 1561 complain_overflow_bitfield, /* complain_on_overflow */ 1562 0, /* special_function */ 1563 "R_TRL", /* name */ 1564 TRUE, /* partial_inplace */ 1565 0xffff, /* src_mask */ 1566 0xffff, /* dst_mask */ 1567 FALSE), /* pcrel_offset */ 1568 1569 /* 0x13: TOC relative load address. */ 1570 HOWTO (R_TRLA, /* type */ 1571 0, /* rightshift */ 1572 1, /* size (0 = byte, 1 = short, 2 = long) */ 1573 16, /* bitsize */ 1574 FALSE, /* pc_relative */ 1575 0, /* bitpos */ 1576 complain_overflow_bitfield, /* complain_on_overflow */ 1577 0, /* special_function */ 1578 "R_TRLA", /* name */ 1579 TRUE, /* partial_inplace */ 1580 0xffff, /* src_mask */ 1581 0xffff, /* dst_mask */ 1582 FALSE), /* pcrel_offset */ 1583 1584 /* 0x14: Modifiable relative branch. */ 1585 HOWTO (R_RRTBI, /* type */ 1586 1, /* rightshift */ 1587 2, /* size (0 = byte, 1 = short, 2 = long) */ 1588 32, /* bitsize */ 1589 FALSE, /* pc_relative */ 1590 0, /* bitpos */ 1591 complain_overflow_bitfield, /* complain_on_overflow */ 1592 0, /* special_function */ 1593 "R_RRTBI", /* name */ 1594 TRUE, /* partial_inplace */ 1595 0xffffffff, /* src_mask */ 1596 0xffffffff, /* dst_mask */ 1597 FALSE), /* pcrel_offset */ 1598 1599 /* 0x15: Modifiable absolute branch. */ 1600 HOWTO (R_RRTBA, /* type */ 1601 1, /* rightshift */ 1602 2, /* size (0 = byte, 1 = short, 2 = long) */ 1603 32, /* bitsize */ 1604 FALSE, /* pc_relative */ 1605 0, /* bitpos */ 1606 complain_overflow_bitfield, /* complain_on_overflow */ 1607 0, /* special_function */ 1608 "R_RRTBA", /* name */ 1609 TRUE, /* partial_inplace */ 1610 0xffffffff, /* src_mask */ 1611 0xffffffff, /* dst_mask */ 1612 FALSE), /* pcrel_offset */ 1613 1614 /* 0x16: Modifiable call absolute indirect. */ 1615 HOWTO (R_CAI, /* type */ 1616 0, /* rightshift */ 1617 1, /* size (0 = byte, 1 = short, 2 = long) */ 1618 16, /* bitsize */ 1619 FALSE, /* pc_relative */ 1620 0, /* bitpos */ 1621 complain_overflow_bitfield, /* complain_on_overflow */ 1622 0, /* special_function */ 1623 "R_CAI", /* name */ 1624 TRUE, /* partial_inplace */ 1625 0xffff, /* src_mask */ 1626 0xffff, /* dst_mask */ 1627 FALSE), /* pcrel_offset */ 1628 1629 /* 0x17: Modifiable call relative. */ 1630 HOWTO (R_CREL, /* type */ 1631 0, /* rightshift */ 1632 1, /* size (0 = byte, 1 = short, 2 = long) */ 1633 16, /* bitsize */ 1634 FALSE, /* pc_relative */ 1635 0, /* bitpos */ 1636 complain_overflow_bitfield, /* complain_on_overflow */ 1637 0, /* special_function */ 1638 "R_CREL", /* name */ 1639 TRUE, /* partial_inplace */ 1640 0xffff, /* src_mask */ 1641 0xffff, /* dst_mask */ 1642 FALSE), /* pcrel_offset */ 1643 1644 /* 0x18: Modifiable branch absolute. */ 1645 HOWTO (R_RBA, /* type */ 1646 0, /* rightshift */ 1647 2, /* size (0 = byte, 1 = short, 2 = long) */ 1648 26, /* bitsize */ 1649 FALSE, /* pc_relative */ 1650 0, /* bitpos */ 1651 complain_overflow_bitfield, /* complain_on_overflow */ 1652 0, /* special_function */ 1653 "R_RBA", /* name */ 1654 TRUE, /* partial_inplace */ 1655 0x03fffffc, /* src_mask */ 1656 0x03fffffc, /* dst_mask */ 1657 FALSE), /* pcrel_offset */ 1658 1659 /* 0x19: Modifiable branch absolute. */ 1660 HOWTO (R_RBAC, /* type */ 1661 0, /* rightshift */ 1662 2, /* size (0 = byte, 1 = short, 2 = long) */ 1663 32, /* bitsize */ 1664 FALSE, /* pc_relative */ 1665 0, /* bitpos */ 1666 complain_overflow_bitfield, /* complain_on_overflow */ 1667 0, /* special_function */ 1668 "R_RBAC", /* name */ 1669 TRUE, /* partial_inplace */ 1670 0xffffffff, /* src_mask */ 1671 0xffffffff, /* dst_mask */ 1672 FALSE), /* pcrel_offset */ 1673 1674 /* 0x1a: Modifiable branch relative. */ 1675 HOWTO (R_RBR, /* type */ 1676 0, /* rightshift */ 1677 2, /* size (0 = byte, 1 = short, 2 = long) */ 1678 26, /* bitsize */ 1679 FALSE, /* pc_relative */ 1680 0, /* bitpos */ 1681 complain_overflow_signed, /* complain_on_overflow */ 1682 0, /* special_function */ 1683 "R_RBR_26", /* name */ 1684 TRUE, /* partial_inplace */ 1685 0x03fffffc, /* src_mask */ 1686 0x03fffffc, /* dst_mask */ 1687 FALSE), /* pcrel_offset */ 1688 1689 /* 0x1b: Modifiable branch absolute. */ 1690 HOWTO (R_RBRC, /* type */ 1691 0, /* rightshift */ 1692 1, /* size (0 = byte, 1 = short, 2 = long) */ 1693 16, /* bitsize */ 1694 FALSE, /* pc_relative */ 1695 0, /* bitpos */ 1696 complain_overflow_bitfield, /* complain_on_overflow */ 1697 0, /* special_function */ 1698 "R_RBRC", /* name */ 1699 TRUE, /* partial_inplace */ 1700 0xffff, /* src_mask */ 1701 0xffff, /* dst_mask */ 1702 FALSE), /* pcrel_offset */ 1703 1704 /* 0x1c: Standard 32 bit relocation. */ 1705 HOWTO (R_POS, /* type */ 1706 0, /* rightshift */ 1707 2, /* size (0 = byte, 1 = short, 2 = long) */ 1708 32, /* bitsize */ 1709 FALSE, /* pc_relative */ 1710 0, /* bitpos */ 1711 complain_overflow_bitfield, /* complain_on_overflow */ 1712 0, /* special_function */ 1713 "R_POS_32", /* name */ 1714 TRUE, /* partial_inplace */ 1715 0xffffffff, /* src_mask */ 1716 0xffffffff, /* dst_mask */ 1717 FALSE), /* pcrel_offset */ 1718 1719 /* 0x1d: 16 bit Non modifiable absolute branch. */ 1720 HOWTO (R_BA, /* type */ 1721 0, /* rightshift */ 1722 1, /* size (0 = byte, 1 = short, 2 = long) */ 1723 16, /* bitsize */ 1724 FALSE, /* pc_relative */ 1725 0, /* bitpos */ 1726 complain_overflow_bitfield, /* complain_on_overflow */ 1727 0, /* special_function */ 1728 "R_BA_16", /* name */ 1729 TRUE, /* partial_inplace */ 1730 0xfffc, /* src_mask */ 1731 0xfffc, /* dst_mask */ 1732 FALSE), /* pcrel_offset */ 1733 1734 /* 0x1e: Modifiable branch relative. */ 1735 HOWTO (R_RBR, /* type */ 1736 0, /* rightshift */ 1737 1, /* size (0 = byte, 1 = short, 2 = long) */ 1738 16, /* bitsize */ 1739 TRUE, /* pc_relative */ 1740 0, /* bitpos */ 1741 complain_overflow_signed, /* complain_on_overflow */ 1742 0, /* special_function */ 1743 "R_RBR_16", /* name */ 1744 TRUE, /* partial_inplace */ 1745 0xfffc, /* src_mask */ 1746 0xfffc, /* dst_mask */ 1747 FALSE), /* pcrel_offset */ 1748 1749 /* 0x1f: Modifiable branch absolute. */ 1750 HOWTO (R_RBA, /* type */ 1751 0, /* rightshift */ 1752 1, /* size (0 = byte, 1 = short, 2 = long) */ 1753 16, /* bitsize */ 1754 FALSE, /* pc_relative */ 1755 0, /* bitpos */ 1756 complain_overflow_bitfield, /* complain_on_overflow */ 1757 0, /* special_function */ 1758 "R_RBA_16", /* name */ 1759 TRUE, /* partial_inplace */ 1760 0xffff, /* src_mask */ 1761 0xffff, /* dst_mask */ 1762 FALSE), /* pcrel_offset */ 1763 1764 }; 1765 1766 void 1767 xcoff64_rtype2howto (arelent *relent, struct internal_reloc *internal) 1768 { 1769 if (internal->r_type > R_RBRC) 1770 abort (); 1771 1772 /* Default howto layout works most of the time */ 1773 relent->howto = &xcoff64_howto_table[internal->r_type]; 1774 1775 /* Special case some 16 bit reloc */ 1776 if (15 == (internal->r_size & 0x3f)) 1777 { 1778 if (R_BA == internal->r_type) 1779 relent->howto = &xcoff64_howto_table[0x1d]; 1780 else if (R_RBR == internal->r_type) 1781 relent->howto = &xcoff64_howto_table[0x1e]; 1782 else if (R_RBA == internal->r_type) 1783 relent->howto = &xcoff64_howto_table[0x1f]; 1784 } 1785 /* Special case 32 bit */ 1786 else if (31 == (internal->r_size & 0x3f)) 1787 { 1788 if (R_POS == internal->r_type) 1789 relent->howto = &xcoff64_howto_table[0x1c]; 1790 } 1791 1792 /* The r_size field of an XCOFF reloc encodes the bitsize of the 1793 relocation, as well as indicating whether it is signed or not. 1794 Doublecheck that the relocation information gathered from the 1795 type matches this information. The bitsize is not significant 1796 for R_REF relocs. */ 1797 if (relent->howto->dst_mask != 0 1798 && (relent->howto->bitsize 1799 != ((unsigned int) internal->r_size & 0x3f) + 1)) 1800 abort (); 1801 } 1802 1803 reloc_howto_type * 1804 xcoff64_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, 1805 bfd_reloc_code_real_type code) 1806 { 1807 switch (code) 1808 { 1809 case BFD_RELOC_PPC_B26: 1810 return &xcoff64_howto_table[0xa]; 1811 case BFD_RELOC_PPC_BA16: 1812 return &xcoff64_howto_table[0x1d]; 1813 case BFD_RELOC_PPC_BA26: 1814 return &xcoff64_howto_table[8]; 1815 case BFD_RELOC_PPC_TOC16: 1816 return &xcoff64_howto_table[3]; 1817 case BFD_RELOC_16: 1818 /* Note that this relocation is only internally used by gas. */ 1819 return &xcoff64_howto_table[0xc]; 1820 case BFD_RELOC_PPC_B16: 1821 return &xcoff64_howto_table[0x1e]; 1822 case BFD_RELOC_32: 1823 case BFD_RELOC_CTOR: 1824 return &xcoff64_howto_table[0x1c]; 1825 case BFD_RELOC_64: 1826 return &xcoff64_howto_table[0]; 1827 case BFD_RELOC_NONE: 1828 return &xcoff64_howto_table[0xf]; 1829 default: 1830 return NULL; 1831 } 1832 } 1833 1834 static reloc_howto_type * 1835 xcoff64_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, 1836 const char *r_name) 1837 { 1838 unsigned int i; 1839 1840 for (i = 0; 1841 i < sizeof (xcoff64_howto_table) / sizeof (xcoff64_howto_table[0]); 1842 i++) 1843 if (xcoff64_howto_table[i].name != NULL 1844 && strcasecmp (xcoff64_howto_table[i].name, r_name) == 0) 1845 return &xcoff64_howto_table[i]; 1846 1847 return NULL; 1848 } 1849 1850 /* PR 21786: The PE/COFF standard does not require NUL termination for any of 1851 the ASCII fields in the archive headers. So in order to be able to extract 1852 numerical values we provide our own versions of strtol and strtoll which 1853 take a maximum length as an additional parameter. Also - just to save space, 1854 we omit the endptr return parameter, since we know that it is never used. */ 1855 1856 static long 1857 _bfd_strntol (const char * nptr, int base, unsigned int maxlen) 1858 { 1859 char buf[24]; /* Should be enough. */ 1860 1861 BFD_ASSERT (maxlen < (sizeof (buf) - 1)); 1862 1863 memcpy (buf, nptr, maxlen); 1864 buf[maxlen] = 0; 1865 return strtol (buf, NULL, base); 1866 } 1867 1868 static long long 1869 _bfd_strntoll (const char * nptr, int base, unsigned int maxlen) 1870 { 1871 char buf[32]; /* Should be enough. */ 1872 1873 BFD_ASSERT (maxlen < (sizeof (buf) - 1)); 1874 1875 memcpy (buf, nptr, maxlen); 1876 buf[maxlen] = 0; 1877 return strtoll (buf, NULL, base); 1878 } 1879 1880 /* Macro to read an ASCII value stored in an archive header field. */ 1881 #define GET_VALUE_IN_FIELD(VAR, FIELD, BASE) \ 1882 do \ 1883 { \ 1884 (VAR) = (sizeof (VAR) > sizeof (long) \ 1885 ? _bfd_strntoll (FIELD, BASE, sizeof FIELD) \ 1886 : _bfd_strntol (FIELD, BASE, sizeof FIELD)); \ 1887 } \ 1888 while (0) 1889 1890 /* Read in the armap of an XCOFF archive. */ 1891 1892 static bfd_boolean 1893 xcoff64_slurp_armap (bfd *abfd) 1894 { 1895 file_ptr off; 1896 size_t namlen; 1897 bfd_size_type sz, amt; 1898 bfd_byte *contents, *cend; 1899 bfd_vma c, i; 1900 carsym *arsym; 1901 bfd_byte *p; 1902 file_ptr pos; 1903 1904 /* This is for the new format. */ 1905 struct xcoff_ar_hdr_big hdr; 1906 1907 if (xcoff_ardata (abfd) == NULL) 1908 { 1909 abfd->has_armap = FALSE; 1910 return TRUE; 1911 } 1912 1913 off = bfd_scan_vma (xcoff_ardata_big (abfd)->symoff64, 1914 (const char **) NULL, 10); 1915 if (off == 0) 1916 { 1917 abfd->has_armap = FALSE; 1918 return TRUE; 1919 } 1920 1921 if (bfd_seek (abfd, off, SEEK_SET) != 0) 1922 return FALSE; 1923 1924 /* The symbol table starts with a normal archive header. */ 1925 if (bfd_bread (&hdr, (bfd_size_type) SIZEOF_AR_HDR_BIG, abfd) 1926 != SIZEOF_AR_HDR_BIG) 1927 return FALSE; 1928 1929 /* Skip the name (normally empty). */ 1930 GET_VALUE_IN_FIELD (namlen, hdr.namlen, 10); 1931 pos = ((namlen + 1) & ~(size_t) 1) + SXCOFFARFMAG; 1932 if (bfd_seek (abfd, pos, SEEK_CUR) != 0) 1933 return FALSE; 1934 1935 sz = bfd_scan_vma (hdr.size, (const char **) NULL, 10); 1936 if (sz == (bfd_size_type) -1) 1937 { 1938 bfd_set_error (bfd_error_no_memory); 1939 return FALSE; 1940 } 1941 1942 /* Read in the entire symbol table. */ 1943 contents = (bfd_byte *) bfd_alloc (abfd, sz + 1); 1944 if (contents == NULL) 1945 return FALSE; 1946 if (bfd_bread (contents, sz, abfd) != sz) 1947 return FALSE; 1948 1949 /* Ensure strings are NULL terminated so we don't wander off the end 1950 of the buffer. */ 1951 contents[sz] = 0; 1952 1953 /* The symbol table starts with an eight byte count. */ 1954 c = H_GET_64 (abfd, contents); 1955 1956 if (c >= sz / 8) 1957 { 1958 bfd_set_error (bfd_error_bad_value); 1959 return FALSE; 1960 } 1961 amt = c; 1962 amt *= sizeof (carsym); 1963 bfd_ardata (abfd)->symdefs = (carsym *) bfd_alloc (abfd, amt); 1964 if (bfd_ardata (abfd)->symdefs == NULL) 1965 return FALSE; 1966 1967 /* After the count comes a list of eight byte file offsets. */ 1968 for (i = 0, arsym = bfd_ardata (abfd)->symdefs, p = contents + 8; 1969 i < c; 1970 ++i, ++arsym, p += 8) 1971 arsym->file_offset = H_GET_64 (abfd, p); 1972 1973 /* After the file offsets come null terminated symbol names. */ 1974 cend = contents + sz; 1975 for (i = 0, arsym = bfd_ardata (abfd)->symdefs; 1976 i < c; 1977 ++i, ++arsym, p += strlen ((char *) p) + 1) 1978 { 1979 if (p >= cend) 1980 { 1981 bfd_set_error (bfd_error_bad_value); 1982 return FALSE; 1983 } 1984 arsym->name = (char *) p; 1985 } 1986 1987 bfd_ardata (abfd)->symdef_count = c; 1988 abfd->has_armap = TRUE; 1989 1990 return TRUE; 1991 } 1992 1993 1994 /* See if this is an NEW XCOFF archive. */ 1995 1996 static const bfd_target * 1997 xcoff64_archive_p (bfd *abfd) 1998 { 1999 struct artdata *tdata_hold; 2000 char magic[SXCOFFARMAG]; 2001 /* This is the new format. */ 2002 struct xcoff_ar_file_hdr_big hdr; 2003 bfd_size_type amt = SXCOFFARMAG; 2004 2005 if (bfd_bread (magic, amt, abfd) != amt) 2006 { 2007 if (bfd_get_error () != bfd_error_system_call) 2008 bfd_set_error (bfd_error_wrong_format); 2009 return NULL; 2010 } 2011 2012 if (strncmp (magic, XCOFFARMAGBIG, SXCOFFARMAG) != 0) 2013 { 2014 bfd_set_error (bfd_error_wrong_format); 2015 return NULL; 2016 } 2017 2018 /* Copy over the magic string. */ 2019 memcpy (hdr.magic, magic, SXCOFFARMAG); 2020 2021 /* Now read the rest of the file header. */ 2022 amt = SIZEOF_AR_FILE_HDR_BIG - SXCOFFARMAG; 2023 if (bfd_bread (&hdr.memoff, amt, abfd) != amt) 2024 { 2025 if (bfd_get_error () != bfd_error_system_call) 2026 bfd_set_error (bfd_error_wrong_format); 2027 return NULL; 2028 } 2029 2030 tdata_hold = bfd_ardata (abfd); 2031 2032 amt = sizeof (struct artdata); 2033 bfd_ardata (abfd) = (struct artdata *) bfd_zalloc (abfd, amt); 2034 if (bfd_ardata (abfd) == (struct artdata *) NULL) 2035 goto error_ret_restore; 2036 2037 /* Already cleared by bfd_zalloc above. 2038 bfd_ardata (abfd)->cache = NULL; 2039 bfd_ardata (abfd)->archive_head = NULL; 2040 bfd_ardata (abfd)->symdefs = NULL; 2041 bfd_ardata (abfd)->extended_names = NULL; 2042 bfd_ardata (abfd)->extended_names_size = 0; */ 2043 bfd_ardata (abfd)->first_file_filepos = bfd_scan_vma (hdr.firstmemoff, 2044 (const char **) NULL, 2045 10); 2046 2047 amt = SIZEOF_AR_FILE_HDR_BIG; 2048 bfd_ardata (abfd)->tdata = bfd_zalloc (abfd, amt); 2049 if (bfd_ardata (abfd)->tdata == NULL) 2050 goto error_ret; 2051 2052 memcpy (bfd_ardata (abfd)->tdata, &hdr, SIZEOF_AR_FILE_HDR_BIG); 2053 2054 if (! xcoff64_slurp_armap (abfd)) 2055 { 2056 error_ret: 2057 bfd_release (abfd, bfd_ardata (abfd)); 2058 error_ret_restore: 2059 bfd_ardata (abfd) = tdata_hold; 2060 return NULL; 2061 } 2062 2063 return abfd->xvec; 2064 } 2065 2066 2067 /* Open the next element in an XCOFF archive. */ 2068 2069 static bfd * 2070 xcoff64_openr_next_archived_file (bfd *archive, bfd *last_file) 2071 { 2072 bfd_vma filestart; 2073 2074 if ((xcoff_ardata (archive) == NULL) 2075 || ! xcoff_big_format_p (archive)) 2076 { 2077 bfd_set_error (bfd_error_invalid_operation); 2078 return NULL; 2079 } 2080 2081 if (last_file == NULL) 2082 { 2083 filestart = bfd_ardata (archive)->first_file_filepos; 2084 } 2085 else 2086 { 2087 filestart = bfd_scan_vma (arch_xhdr_big (last_file)->nextoff, 2088 (const char **) NULL, 10); 2089 } 2090 2091 if (filestart == 0 2092 || filestart == bfd_scan_vma (xcoff_ardata_big (archive)->memoff, 2093 (const char **) NULL, 10) 2094 || filestart == bfd_scan_vma (xcoff_ardata_big (archive)->symoff, 2095 (const char **) NULL, 10)) 2096 { 2097 bfd_set_error (bfd_error_no_more_archived_files); 2098 return NULL; 2099 } 2100 2101 return _bfd_get_elt_at_filepos (archive, (file_ptr) filestart); 2102 } 2103 2104 /* We can't use the usual coff_sizeof_headers routine, because AIX 2105 always uses an a.out header. */ 2106 2107 static int 2108 xcoff64_sizeof_headers (bfd *abfd, 2109 struct bfd_link_info *info ATTRIBUTE_UNUSED) 2110 { 2111 int size; 2112 2113 size = bfd_coff_filhsz (abfd); 2114 2115 /* Don't think the small aout header can be used since some of the 2116 old elements have been reordered past the end of the old coff 2117 small aout size. */ 2118 2119 if (xcoff_data (abfd)->full_aouthdr) 2120 size += bfd_coff_aoutsz (abfd); 2121 2122 size += abfd->section_count * bfd_coff_scnhsz (abfd); 2123 return size; 2124 } 2125 2126 static asection * 2127 xcoff64_create_csect_from_smclas (bfd *abfd, union internal_auxent *aux, 2128 const char *symbol_name) 2129 { 2130 asection *return_value = NULL; 2131 2132 /* Changes from 32 : 2133 .sv == 8, is only for 32 bit programs 2134 .ti == 12 and .tb == 13 are now reserved. */ 2135 static const char *names[19] = 2136 { 2137 ".pr", ".ro", ".db", ".tc", ".ua", ".rw", ".gl", ".xo", 2138 NULL, ".bs", ".ds", ".uc", NULL, NULL, NULL, ".tc0", 2139 ".td", ".sv64", ".sv3264" 2140 }; 2141 2142 if ((19 >= aux->x_csect.x_smclas) 2143 && (NULL != names[aux->x_csect.x_smclas])) 2144 { 2145 2146 return_value = bfd_make_section_anyway 2147 (abfd, names[aux->x_csect.x_smclas]); 2148 2149 } 2150 else 2151 { 2152 _bfd_error_handler 2153 /* xgettext: c-format */ 2154 (_("%pB: symbol `%s' has unrecognized smclas %d"), 2155 abfd, symbol_name, aux->x_csect.x_smclas); 2156 bfd_set_error (bfd_error_bad_value); 2157 } 2158 2159 return return_value; 2160 } 2161 2162 static bfd_boolean 2163 xcoff64_is_lineno_count_overflow (bfd *abfd ATTRIBUTE_UNUSED, 2164 bfd_vma value ATTRIBUTE_UNUSED) 2165 { 2166 return FALSE; 2167 } 2168 2169 static bfd_boolean 2170 xcoff64_is_reloc_count_overflow (bfd *abfd ATTRIBUTE_UNUSED, 2171 bfd_vma value ATTRIBUTE_UNUSED) 2172 { 2173 return FALSE; 2174 } 2175 2176 static bfd_vma 2177 xcoff64_loader_symbol_offset (bfd *abfd ATTRIBUTE_UNUSED, 2178 struct internal_ldhdr *ldhdr) 2179 { 2180 return (ldhdr->l_symoff); 2181 } 2182 2183 static bfd_vma 2184 xcoff64_loader_reloc_offset (bfd *abfd ATTRIBUTE_UNUSED, 2185 struct internal_ldhdr *ldhdr) 2186 { 2187 return (ldhdr->l_rldoff); 2188 } 2189 2190 static bfd_boolean 2191 xcoff64_bad_format_hook (bfd * abfd, void *filehdr) 2192 { 2193 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr; 2194 2195 /* Check flavor first. */ 2196 if (bfd_get_flavour (abfd) != bfd_target_xcoff_flavour) 2197 return FALSE; 2198 2199 if (bfd_xcoff_magic_number (abfd) != internal_f->f_magic) 2200 return FALSE; 2201 2202 return TRUE; 2203 } 2204 2205 static bfd_boolean 2206 xcoff64_generate_rtinit (bfd *abfd, const char *init, const char *fini, 2207 bfd_boolean rtld) 2208 { 2209 bfd_byte filehdr_ext[FILHSZ]; 2210 bfd_byte scnhdr_ext[SCNHSZ * 3]; 2211 bfd_byte syment_ext[SYMESZ * 10]; 2212 bfd_byte reloc_ext[RELSZ * 3]; 2213 bfd_byte *data_buffer; 2214 bfd_size_type data_buffer_size; 2215 bfd_byte *string_table, *st_tmp; 2216 bfd_size_type string_table_size; 2217 bfd_vma val; 2218 size_t initsz, finisz; 2219 struct internal_filehdr filehdr; 2220 struct internal_scnhdr text_scnhdr; 2221 struct internal_scnhdr data_scnhdr; 2222 struct internal_scnhdr bss_scnhdr; 2223 struct internal_syment syment; 2224 union internal_auxent auxent; 2225 struct internal_reloc reloc; 2226 2227 char *text_name = ".text"; 2228 char *data_name = ".data"; 2229 char *bss_name = ".bss"; 2230 char *rtinit_name = "__rtinit"; 2231 char *rtld_name = "__rtld"; 2232 2233 if (! bfd_xcoff_rtinit_size (abfd)) 2234 return FALSE; 2235 2236 initsz = (init == NULL ? 0 : 1 + strlen (init)); 2237 finisz = (fini == NULL ? 0 : 1 + strlen (fini)); 2238 2239 /* File header. */ 2240 memset (filehdr_ext, 0, FILHSZ); 2241 memset (&filehdr, 0, sizeof (struct internal_filehdr)); 2242 filehdr.f_magic = bfd_xcoff_magic_number (abfd); 2243 filehdr.f_nscns = 3; 2244 filehdr.f_timdat = 0; 2245 filehdr.f_nsyms = 0; /* at least 6, no more than 8 */ 2246 filehdr.f_symptr = 0; /* set below */ 2247 filehdr.f_opthdr = 0; 2248 filehdr.f_flags = 0; 2249 2250 /* Section headers. */ 2251 memset (scnhdr_ext, 0, 3 * SCNHSZ); 2252 2253 /* Text. */ 2254 memset (&text_scnhdr, 0, sizeof (struct internal_scnhdr)); 2255 memcpy (text_scnhdr.s_name, text_name, strlen (text_name)); 2256 text_scnhdr.s_paddr = 0; 2257 text_scnhdr.s_vaddr = 0; 2258 text_scnhdr.s_size = 0; 2259 text_scnhdr.s_scnptr = 0; 2260 text_scnhdr.s_relptr = 0; 2261 text_scnhdr.s_lnnoptr = 0; 2262 text_scnhdr.s_nreloc = 0; 2263 text_scnhdr.s_nlnno = 0; 2264 text_scnhdr.s_flags = STYP_TEXT; 2265 2266 /* Data. */ 2267 memset (&data_scnhdr, 0, sizeof (struct internal_scnhdr)); 2268 memcpy (data_scnhdr.s_name, data_name, strlen (data_name)); 2269 data_scnhdr.s_paddr = 0; 2270 data_scnhdr.s_vaddr = 0; 2271 data_scnhdr.s_size = 0; /* set below */ 2272 data_scnhdr.s_scnptr = FILHSZ + 3 * SCNHSZ; 2273 data_scnhdr.s_relptr = 0; /* set below */ 2274 data_scnhdr.s_lnnoptr = 0; 2275 data_scnhdr.s_nreloc = 0; /* either 1 or 2 */ 2276 data_scnhdr.s_nlnno = 0; 2277 data_scnhdr.s_flags = STYP_DATA; 2278 2279 /* Bss. */ 2280 memset (&bss_scnhdr, 0, sizeof (struct internal_scnhdr)); 2281 memcpy (bss_scnhdr.s_name, bss_name, strlen (bss_name)); 2282 bss_scnhdr.s_paddr = 0; /* set below */ 2283 bss_scnhdr.s_vaddr = 0; /* set below */ 2284 bss_scnhdr.s_size = 0; /* set below */ 2285 bss_scnhdr.s_scnptr = 0; 2286 bss_scnhdr.s_relptr = 0; 2287 bss_scnhdr.s_lnnoptr = 0; 2288 bss_scnhdr.s_nreloc = 0; 2289 bss_scnhdr.s_nlnno = 0; 2290 bss_scnhdr.s_flags = STYP_BSS; 2291 2292 /* .data 2293 0x0000 0x00000000 : rtl 2294 0x0004 0x00000000 : 2295 0x0008 0x00000018 : offset to init, or 0 2296 0x000C 0x00000038 : offset to fini, or 0 2297 0x0010 0x00000010 : size of descriptor 2298 0x0014 0x00000000 : pad 2299 0x0018 0x00000000 : init, needs a reloc 2300 0x001C 0x00000000 : 2301 0x0020 0x00000058 : offset to init name 2302 0x0024 0x00000000 : flags, padded to a word 2303 0x0028 0x00000000 : empty init 2304 0x002C 0x00000000 : 2305 0x0030 0x00000000 : 2306 0x0034 0x00000000 : 2307 0x0038 0x00000000 : fini, needs a reloc 2308 0x003C 0x00000000 : 2309 0x0040 0x00000??? : offset to fini name 2310 0x0044 0x00000000 : flags, padded to a word 2311 0x0048 0x00000000 : empty fini 2312 0x004C 0x00000000 : 2313 0x0050 0x00000000 : 2314 0x0054 0x00000000 : 2315 0x0058 init name 2316 0x0058 + initsz fini name */ 2317 2318 data_buffer_size = 0x0058 + initsz + finisz; 2319 data_buffer_size = (data_buffer_size + 7) &~ (bfd_size_type) 7; 2320 data_buffer = NULL; 2321 data_buffer = (bfd_byte *) bfd_zmalloc (data_buffer_size); 2322 if (data_buffer == NULL) 2323 return FALSE; 2324 2325 if (initsz) 2326 { 2327 val = 0x18; 2328 bfd_put_32 (abfd, val, &data_buffer[0x08]); 2329 val = 0x58; 2330 bfd_put_32 (abfd, val, &data_buffer[0x20]); 2331 memcpy (&data_buffer[val], init, initsz); 2332 } 2333 2334 if (finisz) 2335 { 2336 val = 0x38; 2337 bfd_put_32 (abfd, val, &data_buffer[0x0C]); 2338 val = 0x58 + initsz; 2339 bfd_put_32 (abfd, val, &data_buffer[0x40]); 2340 memcpy (&data_buffer[val], fini, finisz); 2341 } 2342 2343 val = 0x10; 2344 bfd_put_32 (abfd, val, &data_buffer[0x10]); 2345 data_scnhdr.s_size = data_buffer_size; 2346 bss_scnhdr.s_paddr = bss_scnhdr.s_vaddr = data_scnhdr.s_size; 2347 2348 /* String table. */ 2349 string_table_size = 4; 2350 string_table_size += strlen (data_name) + 1; 2351 string_table_size += strlen (rtinit_name) + 1; 2352 string_table_size += initsz; 2353 string_table_size += finisz; 2354 if (rtld) 2355 string_table_size += strlen (rtld_name) + 1; 2356 2357 string_table = (bfd_byte *) bfd_zmalloc (string_table_size); 2358 if (string_table == NULL) 2359 return FALSE; 2360 2361 val = string_table_size; 2362 bfd_put_32 (abfd, val, &string_table[0]); 2363 st_tmp = string_table + 4; 2364 2365 /* symbols 2366 0. .data csect 2367 2. __rtinit 2368 4. init function 2369 6. fini function 2370 8. __rtld */ 2371 memset (syment_ext, 0, 10 * SYMESZ); 2372 memset (reloc_ext, 0, 3 * RELSZ); 2373 2374 /* .data csect */ 2375 memset (&syment, 0, sizeof (struct internal_syment)); 2376 memset (&auxent, 0, sizeof (union internal_auxent)); 2377 2378 syment._n._n_n._n_offset = st_tmp - string_table; 2379 memcpy (st_tmp, data_name, strlen (data_name)); 2380 st_tmp += strlen (data_name) + 1; 2381 2382 syment.n_scnum = 2; 2383 syment.n_sclass = C_HIDEXT; 2384 syment.n_numaux = 1; 2385 auxent.x_csect.x_scnlen.l = data_buffer_size; 2386 auxent.x_csect.x_smtyp = 3 << 3 | XTY_SD; 2387 auxent.x_csect.x_smclas = XMC_RW; 2388 bfd_coff_swap_sym_out (abfd, &syment, 2389 &syment_ext[filehdr.f_nsyms * SYMESZ]); 2390 bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0, 2391 syment.n_numaux, 2392 &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]); 2393 filehdr.f_nsyms += 2; 2394 2395 /* __rtinit */ 2396 memset (&syment, 0, sizeof (struct internal_syment)); 2397 memset (&auxent, 0, sizeof (union internal_auxent)); 2398 syment._n._n_n._n_offset = st_tmp - string_table; 2399 memcpy (st_tmp, rtinit_name, strlen (rtinit_name)); 2400 st_tmp += strlen (rtinit_name) + 1; 2401 2402 syment.n_scnum = 2; 2403 syment.n_sclass = C_EXT; 2404 syment.n_numaux = 1; 2405 auxent.x_csect.x_smtyp = XTY_LD; 2406 auxent.x_csect.x_smclas = XMC_RW; 2407 bfd_coff_swap_sym_out (abfd, &syment, 2408 &syment_ext[filehdr.f_nsyms * SYMESZ]); 2409 bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0, 2410 syment.n_numaux, 2411 &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]); 2412 filehdr.f_nsyms += 2; 2413 2414 /* Init. */ 2415 if (initsz) 2416 { 2417 memset (&syment, 0, sizeof (struct internal_syment)); 2418 memset (&auxent, 0, sizeof (union internal_auxent)); 2419 2420 syment._n._n_n._n_offset = st_tmp - string_table; 2421 memcpy (st_tmp, init, initsz); 2422 st_tmp += initsz; 2423 2424 syment.n_sclass = C_EXT; 2425 syment.n_numaux = 1; 2426 bfd_coff_swap_sym_out (abfd, &syment, 2427 &syment_ext[filehdr.f_nsyms * SYMESZ]); 2428 bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0, 2429 syment.n_numaux, 2430 &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]); 2431 /* Reloc. */ 2432 memset (&reloc, 0, sizeof (struct internal_reloc)); 2433 reloc.r_vaddr = 0x0018; 2434 reloc.r_symndx = filehdr.f_nsyms; 2435 reloc.r_type = R_POS; 2436 reloc.r_size = 63; 2437 bfd_coff_swap_reloc_out (abfd, &reloc, &reloc_ext[0]); 2438 2439 filehdr.f_nsyms += 2; 2440 data_scnhdr.s_nreloc += 1; 2441 } 2442 2443 /* Finit. */ 2444 if (finisz) 2445 { 2446 memset (&syment, 0, sizeof (struct internal_syment)); 2447 memset (&auxent, 0, sizeof (union internal_auxent)); 2448 2449 syment._n._n_n._n_offset = st_tmp - string_table; 2450 memcpy (st_tmp, fini, finisz); 2451 st_tmp += finisz; 2452 2453 syment.n_sclass = C_EXT; 2454 syment.n_numaux = 1; 2455 bfd_coff_swap_sym_out (abfd, &syment, 2456 &syment_ext[filehdr.f_nsyms * SYMESZ]); 2457 bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0, 2458 syment.n_numaux, 2459 &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]); 2460 2461 /* Reloc. */ 2462 memset (&reloc, 0, sizeof (struct internal_reloc)); 2463 reloc.r_vaddr = 0x0038; 2464 reloc.r_symndx = filehdr.f_nsyms; 2465 reloc.r_type = R_POS; 2466 reloc.r_size = 63; 2467 bfd_coff_swap_reloc_out (abfd, &reloc, 2468 &reloc_ext[data_scnhdr.s_nreloc * RELSZ]); 2469 2470 filehdr.f_nsyms += 2; 2471 data_scnhdr.s_nreloc += 1; 2472 } 2473 2474 if (rtld) 2475 { 2476 memset (&syment, 0, sizeof (struct internal_syment)); 2477 memset (&auxent, 0, sizeof (union internal_auxent)); 2478 2479 syment._n._n_n._n_offset = st_tmp - string_table; 2480 memcpy (st_tmp, rtld_name, strlen (rtld_name)); 2481 st_tmp += strlen (rtld_name) + 1; 2482 2483 syment.n_sclass = C_EXT; 2484 syment.n_numaux = 1; 2485 bfd_coff_swap_sym_out (abfd, &syment, 2486 &syment_ext[filehdr.f_nsyms * SYMESZ]); 2487 bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0, 2488 syment.n_numaux, 2489 &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]); 2490 2491 /* Reloc. */ 2492 memset (&reloc, 0, sizeof (struct internal_reloc)); 2493 reloc.r_vaddr = 0x0000; 2494 reloc.r_symndx = filehdr.f_nsyms; 2495 reloc.r_type = R_POS; 2496 reloc.r_size = 63; 2497 bfd_coff_swap_reloc_out (abfd, &reloc, 2498 &reloc_ext[data_scnhdr.s_nreloc * RELSZ]); 2499 2500 filehdr.f_nsyms += 2; 2501 data_scnhdr.s_nreloc += 1; 2502 2503 bss_scnhdr.s_size = 0; 2504 } 2505 2506 data_scnhdr.s_relptr = data_scnhdr.s_scnptr + data_buffer_size; 2507 filehdr.f_symptr = data_scnhdr.s_relptr + data_scnhdr.s_nreloc * RELSZ; 2508 2509 bfd_coff_swap_filehdr_out (abfd, &filehdr, filehdr_ext); 2510 bfd_bwrite (filehdr_ext, FILHSZ, abfd); 2511 bfd_coff_swap_scnhdr_out (abfd, &text_scnhdr, &scnhdr_ext[SCNHSZ * 0]); 2512 bfd_coff_swap_scnhdr_out (abfd, &data_scnhdr, &scnhdr_ext[SCNHSZ * 1]); 2513 bfd_coff_swap_scnhdr_out (abfd, &bss_scnhdr, &scnhdr_ext[SCNHSZ * 2]); 2514 bfd_bwrite (scnhdr_ext, 3 * SCNHSZ, abfd); 2515 bfd_bwrite (data_buffer, data_buffer_size, abfd); 2516 bfd_bwrite (reloc_ext, data_scnhdr.s_nreloc * RELSZ, abfd); 2517 bfd_bwrite (syment_ext, filehdr.f_nsyms * SYMESZ, abfd); 2518 bfd_bwrite (string_table, string_table_size, abfd); 2519 2520 free (data_buffer); 2521 data_buffer = NULL; 2522 2523 return TRUE; 2524 } 2525 2526 /* The typical dynamic reloc. */ 2527 2528 static reloc_howto_type xcoff64_dynamic_reloc = 2529 HOWTO (0, /* type */ 2530 0, /* rightshift */ 2531 4, /* size (0 = byte, 1 = short, 2 = long) */ 2532 64, /* bitsize */ 2533 FALSE, /* pc_relative */ 2534 0, /* bitpos */ 2535 complain_overflow_bitfield, /* complain_on_overflow */ 2536 0, /* special_function */ 2537 "R_POS", /* name */ 2538 TRUE, /* partial_inplace */ 2539 MINUS_ONE, /* src_mask */ 2540 MINUS_ONE, /* dst_mask */ 2541 FALSE); /* pcrel_offset */ 2542 2543 static unsigned long xcoff64_glink_code[10] = 2544 { 2545 0xe9820000, /* ld r12,0(r2) */ 2546 0xf8410028, /* std r2,40(r1) */ 2547 0xe80c0000, /* ld r0,0(r12) */ 2548 0xe84c0008, /* ld r0,8(r12) */ 2549 0x7c0903a6, /* mtctr r0 */ 2550 0x4e800420, /* bctr */ 2551 0x00000000, /* start of traceback table */ 2552 0x000ca000, /* traceback table */ 2553 0x00000000, /* traceback table */ 2554 0x00000018, /* ??? */ 2555 }; 2556 2557 static const struct xcoff_backend_data_rec bfd_xcoff_backend_data = 2558 { 2559 { /* COFF backend, defined in libcoff.h. */ 2560 _bfd_xcoff64_swap_aux_in, 2561 _bfd_xcoff64_swap_sym_in, 2562 _bfd_xcoff64_swap_lineno_in, 2563 _bfd_xcoff64_swap_aux_out, 2564 _bfd_xcoff64_swap_sym_out, 2565 _bfd_xcoff64_swap_lineno_out, 2566 xcoff64_swap_reloc_out, 2567 coff_swap_filehdr_out, 2568 coff_swap_aouthdr_out, 2569 coff_swap_scnhdr_out, 2570 FILHSZ, 2571 AOUTSZ, 2572 SCNHSZ, 2573 SYMESZ, 2574 AUXESZ, 2575 RELSZ, 2576 LINESZ, 2577 FILNMLEN, 2578 TRUE, /* _bfd_coff_long_filenames */ 2579 XCOFF_NO_LONG_SECTION_NAMES, /* _bfd_coff_long_section_names */ 2580 3, /* _bfd_coff_default_section_alignment_power */ 2581 TRUE, /* _bfd_coff_force_symnames_in_strings */ 2582 4, /* _bfd_coff_debug_string_prefix_length */ 2583 32768, /* _bfd_coff_max_nscns */ 2584 coff_swap_filehdr_in, 2585 coff_swap_aouthdr_in, 2586 coff_swap_scnhdr_in, 2587 xcoff64_swap_reloc_in, 2588 xcoff64_bad_format_hook, 2589 coff_set_arch_mach_hook, 2590 coff_mkobject_hook, 2591 styp_to_sec_flags, 2592 coff_set_alignment_hook, 2593 coff_slurp_symbol_table, 2594 symname_in_debug_hook, 2595 coff_pointerize_aux_hook, 2596 coff_print_aux, 2597 dummy_reloc16_extra_cases, 2598 dummy_reloc16_estimate, 2599 NULL, /* bfd_coff_symbol_classification */ 2600 coff_compute_section_file_positions, 2601 NULL, /* _bfd_coff_start_final_link */ 2602 xcoff64_ppc_relocate_section, 2603 coff_rtype_to_howto, 2604 NULL, /* _bfd_coff_adjust_symndx */ 2605 _bfd_generic_link_add_one_symbol, 2606 coff_link_output_has_begun, 2607 coff_final_link_postscript, 2608 NULL /* print_pdata. */ 2609 }, 2610 2611 0x01EF, /* magic number */ 2612 bfd_arch_powerpc, 2613 bfd_mach_ppc_620, 2614 2615 /* Function pointers to xcoff specific swap routines. */ 2616 xcoff64_swap_ldhdr_in, 2617 xcoff64_swap_ldhdr_out, 2618 xcoff64_swap_ldsym_in, 2619 xcoff64_swap_ldsym_out, 2620 xcoff64_swap_ldrel_in, 2621 xcoff64_swap_ldrel_out, 2622 2623 /* Sizes. */ 2624 LDHDRSZ, 2625 LDSYMSZ, 2626 LDRELSZ, 2627 24, /* _xcoff_function_descriptor_size */ 2628 0, /* _xcoff_small_aout_header_size */ 2629 2630 /* Versions. */ 2631 2, /* _xcoff_ldhdr_version */ 2632 2633 _bfd_xcoff64_put_symbol_name, 2634 _bfd_xcoff64_put_ldsymbol_name, 2635 &xcoff64_dynamic_reloc, 2636 xcoff64_create_csect_from_smclas, 2637 2638 /* Lineno and reloc count overflow. */ 2639 xcoff64_is_lineno_count_overflow, 2640 xcoff64_is_reloc_count_overflow, 2641 2642 xcoff64_loader_symbol_offset, 2643 xcoff64_loader_reloc_offset, 2644 2645 /* glink. */ 2646 &xcoff64_glink_code[0], 2647 40, /* _xcoff_glink_size */ 2648 2649 /* rtinit. */ 2650 88, /* _xcoff_rtinit_size */ 2651 xcoff64_generate_rtinit, 2652 }; 2653 2654 /* The transfer vector that leads the outside world to all of the above. */ 2655 const bfd_target rs6000_xcoff64_vec = 2656 { 2657 "aixcoff64-rs6000", 2658 bfd_target_xcoff_flavour, 2659 BFD_ENDIAN_BIG, /* data byte order is big */ 2660 BFD_ENDIAN_BIG, /* header byte order is big */ 2661 2662 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | DYNAMIC 2663 | HAS_SYMS | HAS_LOCALS | WP_TEXT), 2664 2665 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA, 2666 0, /* leading char */ 2667 '/', /* ar_pad_char */ 2668 15, /* ar_max_namelen */ 2669 0, /* match priority. */ 2670 2671 /* data */ 2672 bfd_getb64, 2673 bfd_getb_signed_64, 2674 bfd_putb64, 2675 bfd_getb32, 2676 bfd_getb_signed_32, 2677 bfd_putb32, 2678 bfd_getb16, 2679 bfd_getb_signed_16, 2680 bfd_putb16, 2681 2682 /* hdrs */ 2683 bfd_getb64, 2684 bfd_getb_signed_64, 2685 bfd_putb64, 2686 bfd_getb32, 2687 bfd_getb_signed_32, 2688 bfd_putb32, 2689 bfd_getb16, 2690 bfd_getb_signed_16, 2691 bfd_putb16, 2692 2693 { /* bfd_check_format */ 2694 _bfd_dummy_target, 2695 coff_object_p, 2696 xcoff64_archive_p, 2697 CORE_FILE_P 2698 }, 2699 2700 { /* bfd_set_format */ 2701 _bfd_bool_bfd_false_error, 2702 coff_mkobject, 2703 _bfd_generic_mkarchive, 2704 _bfd_bool_bfd_false_error 2705 }, 2706 2707 {/* bfd_write_contents */ 2708 _bfd_bool_bfd_false_error, 2709 xcoff64_write_object_contents, 2710 _bfd_xcoff_write_archive_contents, 2711 _bfd_bool_bfd_false_error 2712 }, 2713 2714 /* Generic */ 2715 _bfd_archive_close_and_cleanup, 2716 _bfd_bool_bfd_true, 2717 coff_new_section_hook, 2718 _bfd_generic_get_section_contents, 2719 _bfd_generic_get_section_contents_in_window, 2720 2721 /* Copy */ 2722 _bfd_xcoff_copy_private_bfd_data, 2723 _bfd_generic_bfd_merge_private_bfd_data, 2724 _bfd_generic_init_private_section_data, 2725 _bfd_generic_bfd_copy_private_section_data, 2726 _bfd_generic_bfd_copy_private_symbol_data, 2727 _bfd_generic_bfd_copy_private_header_data, 2728 _bfd_generic_bfd_set_private_flags, 2729 _bfd_generic_bfd_print_private_bfd_data, 2730 2731 /* Core */ 2732 BFD_JUMP_TABLE_CORE (coff), 2733 2734 /* Archive */ 2735 xcoff64_slurp_armap, 2736 _bfd_noarchive_slurp_extended_name_table, 2737 _bfd_noarchive_construct_extended_name_table, 2738 bfd_dont_truncate_arname, 2739 _bfd_xcoff_write_armap, 2740 _bfd_xcoff_read_ar_hdr, 2741 _bfd_generic_write_ar_hdr, 2742 xcoff64_openr_next_archived_file, 2743 _bfd_generic_get_elt_at_index, 2744 _bfd_xcoff_stat_arch_elt, 2745 _bfd_bool_bfd_true, 2746 2747 /* Symbols */ 2748 coff_get_symtab_upper_bound, 2749 coff_canonicalize_symtab, 2750 coff_make_empty_symbol, 2751 coff_print_symbol, 2752 coff_get_symbol_info, 2753 coff_get_symbol_version_string, 2754 _bfd_xcoff_is_local_label_name, 2755 coff_bfd_is_target_special_symbol, 2756 coff_get_lineno, 2757 coff_find_nearest_line, 2758 coff_find_line, 2759 coff_find_inliner_info, 2760 coff_bfd_make_debug_symbol, 2761 _bfd_generic_read_minisymbols, 2762 _bfd_generic_minisymbol_to_symbol, 2763 2764 /* Reloc */ 2765 coff_get_reloc_upper_bound, 2766 coff_canonicalize_reloc, 2767 _bfd_generic_set_reloc, 2768 xcoff64_reloc_type_lookup, 2769 xcoff64_reloc_name_lookup, 2770 2771 /* Write */ 2772 coff_set_arch_mach, 2773 coff_set_section_contents, 2774 2775 /* Link */ 2776 xcoff64_sizeof_headers, 2777 bfd_generic_get_relocated_section_contents, 2778 bfd_generic_relax_section, 2779 _bfd_xcoff_bfd_link_hash_table_create, 2780 _bfd_xcoff_bfd_link_add_symbols, 2781 _bfd_generic_link_just_syms, 2782 _bfd_generic_copy_link_hash_symbol_type, 2783 _bfd_xcoff_bfd_final_link, 2784 _bfd_generic_link_split_section, 2785 _bfd_generic_link_check_relocs, 2786 bfd_generic_gc_sections, 2787 bfd_generic_lookup_section_flags, 2788 bfd_generic_merge_sections, 2789 bfd_generic_is_group_section, 2790 bfd_generic_group_name, 2791 bfd_generic_discard_group, 2792 _bfd_generic_section_already_linked, 2793 _bfd_xcoff_define_common_symbol, 2794 _bfd_generic_link_hide_symbol, 2795 bfd_generic_define_start_stop, 2796 2797 /* Dynamic */ 2798 _bfd_xcoff_get_dynamic_symtab_upper_bound, 2799 _bfd_xcoff_canonicalize_dynamic_symtab, 2800 _bfd_nodynamic_get_synthetic_symtab, 2801 _bfd_xcoff_get_dynamic_reloc_upper_bound, 2802 _bfd_xcoff_canonicalize_dynamic_reloc, 2803 2804 /* Opposite endian version, none exists */ 2805 NULL, 2806 2807 &bfd_xcoff_backend_data, 2808 }; 2809 2810 extern const bfd_target *xcoff64_core_p 2811 (bfd *); 2812 extern bfd_boolean xcoff64_core_file_matches_executable_p 2813 (bfd *, bfd *); 2814 extern char *xcoff64_core_file_failing_command 2815 (bfd *); 2816 extern int xcoff64_core_file_failing_signal 2817 (bfd *); 2818 #define xcoff64_core_file_pid _bfd_nocore_core_file_pid 2819 2820 /* AIX 5 */ 2821 static const struct xcoff_backend_data_rec bfd_xcoff_aix5_backend_data = 2822 { 2823 { /* COFF backend, defined in libcoff.h. */ 2824 _bfd_xcoff64_swap_aux_in, 2825 _bfd_xcoff64_swap_sym_in, 2826 _bfd_xcoff64_swap_lineno_in, 2827 _bfd_xcoff64_swap_aux_out, 2828 _bfd_xcoff64_swap_sym_out, 2829 _bfd_xcoff64_swap_lineno_out, 2830 xcoff64_swap_reloc_out, 2831 coff_swap_filehdr_out, 2832 coff_swap_aouthdr_out, 2833 coff_swap_scnhdr_out, 2834 FILHSZ, 2835 AOUTSZ, 2836 SCNHSZ, 2837 SYMESZ, 2838 AUXESZ, 2839 RELSZ, 2840 LINESZ, 2841 FILNMLEN, 2842 TRUE, /* _bfd_coff_long_filenames */ 2843 XCOFF_NO_LONG_SECTION_NAMES, /* _bfd_coff_long_section_names */ 2844 3, /* _bfd_coff_default_section_alignment_power */ 2845 TRUE, /* _bfd_coff_force_symnames_in_strings */ 2846 4, /* _bfd_coff_debug_string_prefix_length */ 2847 32768, /* _bfd_coff_max_nscns */ 2848 coff_swap_filehdr_in, 2849 coff_swap_aouthdr_in, 2850 coff_swap_scnhdr_in, 2851 xcoff64_swap_reloc_in, 2852 xcoff64_bad_format_hook, 2853 coff_set_arch_mach_hook, 2854 coff_mkobject_hook, 2855 styp_to_sec_flags, 2856 coff_set_alignment_hook, 2857 coff_slurp_symbol_table, 2858 symname_in_debug_hook, 2859 coff_pointerize_aux_hook, 2860 coff_print_aux, 2861 dummy_reloc16_extra_cases, 2862 dummy_reloc16_estimate, 2863 NULL, /* bfd_coff_sym_is_global */ 2864 coff_compute_section_file_positions, 2865 NULL, /* _bfd_coff_start_final_link */ 2866 xcoff64_ppc_relocate_section, 2867 coff_rtype_to_howto, 2868 NULL, /* _bfd_coff_adjust_symndx */ 2869 _bfd_generic_link_add_one_symbol, 2870 coff_link_output_has_begun, 2871 coff_final_link_postscript, 2872 NULL /* print_pdata. */ 2873 }, 2874 2875 U64_TOCMAGIC, /* magic number */ 2876 bfd_arch_powerpc, 2877 bfd_mach_ppc_620, 2878 2879 /* Function pointers to xcoff specific swap routines. */ 2880 xcoff64_swap_ldhdr_in, 2881 xcoff64_swap_ldhdr_out, 2882 xcoff64_swap_ldsym_in, 2883 xcoff64_swap_ldsym_out, 2884 xcoff64_swap_ldrel_in, 2885 xcoff64_swap_ldrel_out, 2886 2887 /* Sizes. */ 2888 LDHDRSZ, 2889 LDSYMSZ, 2890 LDRELSZ, 2891 24, /* _xcoff_function_descriptor_size */ 2892 0, /* _xcoff_small_aout_header_size */ 2893 /* Versions. */ 2894 2, /* _xcoff_ldhdr_version */ 2895 2896 _bfd_xcoff64_put_symbol_name, 2897 _bfd_xcoff64_put_ldsymbol_name, 2898 &xcoff64_dynamic_reloc, 2899 xcoff64_create_csect_from_smclas, 2900 2901 /* Lineno and reloc count overflow. */ 2902 xcoff64_is_lineno_count_overflow, 2903 xcoff64_is_reloc_count_overflow, 2904 2905 xcoff64_loader_symbol_offset, 2906 xcoff64_loader_reloc_offset, 2907 2908 /* glink. */ 2909 &xcoff64_glink_code[0], 2910 40, /* _xcoff_glink_size */ 2911 2912 /* rtinit. */ 2913 88, /* _xcoff_rtinit_size */ 2914 xcoff64_generate_rtinit, 2915 }; 2916 2917 /* The transfer vector that leads the outside world to all of the above. */ 2918 const bfd_target rs6000_xcoff64_aix_vec = 2919 { 2920 "aix5coff64-rs6000", 2921 bfd_target_xcoff_flavour, 2922 BFD_ENDIAN_BIG, /* data byte order is big */ 2923 BFD_ENDIAN_BIG, /* header byte order is big */ 2924 2925 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | DYNAMIC 2926 | HAS_SYMS | HAS_LOCALS | WP_TEXT), 2927 2928 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA, 2929 0, /* leading char */ 2930 '/', /* ar_pad_char */ 2931 15, /* ar_max_namelen */ 2932 0, /* match priority. */ 2933 2934 /* data */ 2935 bfd_getb64, 2936 bfd_getb_signed_64, 2937 bfd_putb64, 2938 bfd_getb32, 2939 bfd_getb_signed_32, 2940 bfd_putb32, 2941 bfd_getb16, 2942 bfd_getb_signed_16, 2943 bfd_putb16, 2944 2945 /* hdrs */ 2946 bfd_getb64, 2947 bfd_getb_signed_64, 2948 bfd_putb64, 2949 bfd_getb32, 2950 bfd_getb_signed_32, 2951 bfd_putb32, 2952 bfd_getb16, 2953 bfd_getb_signed_16, 2954 bfd_putb16, 2955 2956 { /* bfd_check_format */ 2957 _bfd_dummy_target, 2958 coff_object_p, 2959 xcoff64_archive_p, 2960 xcoff64_core_p 2961 }, 2962 2963 { /* bfd_set_format */ 2964 _bfd_bool_bfd_false_error, 2965 coff_mkobject, 2966 _bfd_generic_mkarchive, 2967 _bfd_bool_bfd_false_error 2968 }, 2969 2970 {/* bfd_write_contents */ 2971 _bfd_bool_bfd_false_error, 2972 xcoff64_write_object_contents, 2973 _bfd_xcoff_write_archive_contents, 2974 _bfd_bool_bfd_false_error 2975 }, 2976 2977 /* Generic */ 2978 _bfd_archive_close_and_cleanup, 2979 _bfd_bool_bfd_true, 2980 coff_new_section_hook, 2981 _bfd_generic_get_section_contents, 2982 _bfd_generic_get_section_contents_in_window, 2983 2984 /* Copy */ 2985 _bfd_xcoff_copy_private_bfd_data, 2986 _bfd_generic_bfd_merge_private_bfd_data, 2987 _bfd_generic_init_private_section_data, 2988 _bfd_generic_bfd_copy_private_section_data, 2989 _bfd_generic_bfd_copy_private_symbol_data, 2990 _bfd_generic_bfd_copy_private_header_data, 2991 _bfd_generic_bfd_set_private_flags, 2992 _bfd_generic_bfd_print_private_bfd_data, 2993 2994 /* Core */ 2995 BFD_JUMP_TABLE_CORE (xcoff64), 2996 2997 /* Archive */ 2998 xcoff64_slurp_armap, 2999 _bfd_noarchive_slurp_extended_name_table, 3000 _bfd_noarchive_construct_extended_name_table, 3001 bfd_dont_truncate_arname, 3002 _bfd_xcoff_write_armap, 3003 _bfd_xcoff_read_ar_hdr, 3004 _bfd_generic_write_ar_hdr, 3005 xcoff64_openr_next_archived_file, 3006 _bfd_generic_get_elt_at_index, 3007 _bfd_xcoff_stat_arch_elt, 3008 _bfd_bool_bfd_true, 3009 3010 /* Symbols */ 3011 coff_get_symtab_upper_bound, 3012 coff_canonicalize_symtab, 3013 coff_make_empty_symbol, 3014 coff_print_symbol, 3015 coff_get_symbol_info, 3016 coff_get_symbol_version_string, 3017 _bfd_xcoff_is_local_label_name, 3018 coff_bfd_is_target_special_symbol, 3019 coff_get_lineno, 3020 coff_find_nearest_line, 3021 coff_find_line, 3022 coff_find_inliner_info, 3023 coff_bfd_make_debug_symbol, 3024 _bfd_generic_read_minisymbols, 3025 _bfd_generic_minisymbol_to_symbol, 3026 3027 /* Reloc */ 3028 coff_get_reloc_upper_bound, 3029 coff_canonicalize_reloc, 3030 _bfd_generic_set_reloc, 3031 xcoff64_reloc_type_lookup, 3032 xcoff64_reloc_name_lookup, 3033 3034 /* Write */ 3035 coff_set_arch_mach, 3036 coff_set_section_contents, 3037 3038 /* Link */ 3039 xcoff64_sizeof_headers, 3040 bfd_generic_get_relocated_section_contents, 3041 bfd_generic_relax_section, 3042 _bfd_xcoff_bfd_link_hash_table_create, 3043 _bfd_xcoff_bfd_link_add_symbols, 3044 _bfd_generic_link_just_syms, 3045 _bfd_generic_copy_link_hash_symbol_type, 3046 _bfd_xcoff_bfd_final_link, 3047 _bfd_generic_link_split_section, 3048 _bfd_generic_link_check_relocs, 3049 bfd_generic_gc_sections, 3050 bfd_generic_lookup_section_flags, 3051 bfd_generic_merge_sections, 3052 bfd_generic_is_group_section, 3053 bfd_generic_group_name, 3054 bfd_generic_discard_group, 3055 _bfd_generic_section_already_linked, 3056 _bfd_xcoff_define_common_symbol, 3057 _bfd_generic_link_hide_symbol, 3058 bfd_generic_define_start_stop, 3059 3060 /* Dynamic */ 3061 _bfd_xcoff_get_dynamic_symtab_upper_bound, 3062 _bfd_xcoff_canonicalize_dynamic_symtab, 3063 _bfd_nodynamic_get_synthetic_symtab, 3064 _bfd_xcoff_get_dynamic_reloc_upper_bound, 3065 _bfd_xcoff_canonicalize_dynamic_reloc, 3066 3067 /* Opposite endian version, none exists. */ 3068 NULL, 3069 3070 & bfd_xcoff_aix5_backend_data, 3071 }; 3072