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