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