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