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