1 /* BFD back-end for IBM RS/6000 "XCOFF" files. 2 Copyright 1990-1999, 2000, 2001, 2002, 2003 3 Free Software Foundation, Inc. 4 FIXME: Can someone provide a transliteration of this name into ASCII? 5 Using the following chars caused a compiler warning on HIUX (so I replaced 6 them with octal escapes), and isn't useful without an understanding of what 7 character set it is. 8 Written by Metin G. Ozisik, Mimi Ph\373\364ng-Th\345o V\365, 9 and John Gilmore. 10 Archive support from Damon A. Permezel. 11 Contributed by IBM Corporation and Cygnus Support. 12 13 This file is part of BFD, the Binary File Descriptor library. 14 15 This program is free software; you can redistribute it and/or modify 16 it under the terms of the GNU General Public License as published by 17 the Free Software Foundation; either version 2 of the License, or 18 (at your option) any later version. 19 20 This program is distributed in the hope that it will be useful, 21 but WITHOUT ANY WARRANTY; without even the implied warranty of 22 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 23 GNU General Public License for more details. 24 25 You should have received a copy of the GNU General Public License 26 along with this program; if not, write to the Free Software 27 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 28 29 #include "bfd.h" 30 #include "sysdep.h" 31 #include "bfdlink.h" 32 #include "libbfd.h" 33 #include "coff/internal.h" 34 #include "coff/xcoff.h" 35 #include "coff/rs6000.h" 36 #include "libcoff.h" 37 #include "libxcoff.h" 38 39 extern bfd_boolean _bfd_xcoff_mkobject 40 PARAMS ((bfd *)); 41 extern bfd_boolean _bfd_xcoff_copy_private_bfd_data 42 PARAMS ((bfd *, bfd *)); 43 extern bfd_boolean _bfd_xcoff_is_local_label_name 44 PARAMS ((bfd *, const char *)); 45 extern reloc_howto_type *_bfd_xcoff_reloc_type_lookup 46 PARAMS ((bfd *, bfd_reloc_code_real_type)); 47 extern bfd_boolean _bfd_xcoff_slurp_armap 48 PARAMS ((bfd *)); 49 extern const bfd_target *_bfd_xcoff_archive_p 50 PARAMS ((bfd *)); 51 extern PTR _bfd_xcoff_read_ar_hdr 52 PARAMS ((bfd *)); 53 extern bfd *_bfd_xcoff_openr_next_archived_file 54 PARAMS ((bfd *, bfd *)); 55 extern int _bfd_xcoff_stat_arch_elt 56 PARAMS ((bfd *, struct stat *)); 57 extern bfd_boolean _bfd_xcoff_write_armap 58 PARAMS ((bfd *, unsigned int, struct orl *, unsigned int, int)); 59 extern bfd_boolean _bfd_xcoff_write_archive_contents 60 PARAMS ((bfd *)); 61 extern int _bfd_xcoff_sizeof_headers 62 PARAMS ((bfd *, bfd_boolean)); 63 extern void _bfd_xcoff_swap_sym_in 64 PARAMS ((bfd *, PTR, PTR)); 65 extern unsigned int _bfd_xcoff_swap_sym_out 66 PARAMS ((bfd *, PTR, PTR)); 67 extern void _bfd_xcoff_swap_aux_in 68 PARAMS ((bfd *, PTR, int, int, int, int, PTR)); 69 extern unsigned int _bfd_xcoff_swap_aux_out 70 PARAMS ((bfd *, PTR, int, int, int, int, PTR)); 71 static void xcoff_swap_reloc_in 72 PARAMS ((bfd *, PTR, PTR)); 73 static unsigned int xcoff_swap_reloc_out 74 PARAMS ((bfd *, PTR, PTR)); 75 76 /* Forward declare xcoff_rtype2howto for coffcode.h macro. */ 77 void xcoff_rtype2howto 78 PARAMS ((arelent *, struct internal_reloc *)); 79 80 /* coffcode.h needs these to be defined. */ 81 #define RS6000COFF_C 1 82 83 #define SELECT_RELOC(internal, howto) \ 84 { \ 85 internal.r_type = howto->type; \ 86 internal.r_size = \ 87 ((howto->complain_on_overflow == complain_overflow_signed \ 88 ? 0x80 \ 89 : 0) \ 90 | (howto->bitsize - 1)); \ 91 } 92 93 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (3) 94 #define COFF_LONG_FILENAMES 95 #define NO_COFF_SYMBOLS 96 #define RTYPE2HOWTO(cache_ptr, dst) xcoff_rtype2howto (cache_ptr, dst) 97 #define coff_mkobject _bfd_xcoff_mkobject 98 #define coff_bfd_copy_private_bfd_data _bfd_xcoff_copy_private_bfd_data 99 #define coff_bfd_is_local_label_name _bfd_xcoff_is_local_label_name 100 #define coff_bfd_reloc_type_lookup _bfd_xcoff_reloc_type_lookup 101 #ifdef AIX_CORE 102 extern const bfd_target * rs6000coff_core_p 103 PARAMS ((bfd *abfd)); 104 extern bfd_boolean rs6000coff_core_file_matches_executable_p 105 PARAMS ((bfd *cbfd, bfd *ebfd)); 106 extern char *rs6000coff_core_file_failing_command 107 PARAMS ((bfd *abfd)); 108 extern int rs6000coff_core_file_failing_signal 109 PARAMS ((bfd *abfd)); 110 #define CORE_FILE_P rs6000coff_core_p 111 #define coff_core_file_failing_command \ 112 rs6000coff_core_file_failing_command 113 #define coff_core_file_failing_signal \ 114 rs6000coff_core_file_failing_signal 115 #define coff_core_file_matches_executable_p \ 116 rs6000coff_core_file_matches_executable_p 117 #else 118 #define CORE_FILE_P _bfd_dummy_target 119 #define coff_core_file_failing_command \ 120 _bfd_nocore_core_file_failing_command 121 #define coff_core_file_failing_signal \ 122 _bfd_nocore_core_file_failing_signal 123 #define coff_core_file_matches_executable_p \ 124 _bfd_nocore_core_file_matches_executable_p 125 #endif 126 #define coff_SWAP_sym_in _bfd_xcoff_swap_sym_in 127 #define coff_SWAP_sym_out _bfd_xcoff_swap_sym_out 128 #define coff_SWAP_aux_in _bfd_xcoff_swap_aux_in 129 #define coff_SWAP_aux_out _bfd_xcoff_swap_aux_out 130 #define coff_swap_reloc_in xcoff_swap_reloc_in 131 #define coff_swap_reloc_out xcoff_swap_reloc_out 132 #define NO_COFF_RELOCS 133 134 #include "coffcode.h" 135 136 /* The main body of code is in coffcode.h. */ 137 138 static const char *normalize_filename 139 PARAMS ((bfd *)); 140 static bfd_boolean xcoff_write_armap_old 141 PARAMS ((bfd *, unsigned int, struct orl *, unsigned int, int)); 142 static bfd_boolean xcoff_write_armap_big 143 PARAMS ((bfd *, unsigned int, struct orl *, unsigned int, int)); 144 static bfd_boolean xcoff_write_archive_contents_old 145 PARAMS ((bfd *)); 146 static bfd_boolean xcoff_write_archive_contents_big 147 PARAMS ((bfd *)); 148 static void xcoff_swap_ldhdr_in 149 PARAMS ((bfd *, const PTR, struct internal_ldhdr *)); 150 static void xcoff_swap_ldhdr_out 151 PARAMS ((bfd *, const struct internal_ldhdr *, PTR)); 152 static void xcoff_swap_ldsym_in 153 PARAMS ((bfd *, const PTR, struct internal_ldsym *)); 154 static void xcoff_swap_ldsym_out 155 PARAMS ((bfd *, const struct internal_ldsym *, PTR)); 156 static void xcoff_swap_ldrel_in 157 PARAMS ((bfd *, const PTR, struct internal_ldrel *)); 158 static void xcoff_swap_ldrel_out 159 PARAMS ((bfd *, const struct internal_ldrel *, PTR)); 160 static bfd_boolean xcoff_ppc_relocate_section 161 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, 162 struct internal_reloc *, struct internal_syment *, asection **)); 163 static bfd_boolean _bfd_xcoff_put_ldsymbol_name 164 PARAMS ((bfd *, struct xcoff_loader_info *, struct internal_ldsym *, 165 const char *)); 166 static asection *xcoff_create_csect_from_smclas 167 PARAMS ((bfd *, union internal_auxent *, const char *)); 168 static bfd_boolean xcoff_is_lineno_count_overflow 169 PARAMS ((bfd *, bfd_vma)); 170 static bfd_boolean xcoff_is_reloc_count_overflow 171 PARAMS ((bfd *, bfd_vma)); 172 static bfd_vma xcoff_loader_symbol_offset 173 PARAMS ((bfd *, struct internal_ldhdr *)); 174 static bfd_vma xcoff_loader_reloc_offset 175 PARAMS ((bfd *, struct internal_ldhdr *)); 176 static bfd_boolean xcoff_generate_rtinit 177 PARAMS ((bfd *, const char *, const char *, bfd_boolean)); 178 static bfd_boolean do_pad 179 PARAMS ((bfd *, unsigned int)); 180 static bfd_boolean do_copy 181 PARAMS ((bfd *, bfd *)); 182 static bfd_boolean do_shared_object_padding 183 PARAMS ((bfd *, bfd *, ufile_ptr *, int)); 184 185 /* Relocation functions */ 186 static bfd_boolean xcoff_reloc_type_br 187 PARAMS ((XCOFF_RELOC_FUNCTION_ARGS)); 188 189 static bfd_boolean xcoff_complain_overflow_dont_func 190 PARAMS ((XCOFF_COMPLAIN_FUNCTION_ARGS)); 191 static bfd_boolean xcoff_complain_overflow_bitfield_func 192 PARAMS ((XCOFF_COMPLAIN_FUNCTION_ARGS)); 193 static bfd_boolean xcoff_complain_overflow_signed_func 194 PARAMS ((XCOFF_COMPLAIN_FUNCTION_ARGS)); 195 static bfd_boolean xcoff_complain_overflow_unsigned_func 196 PARAMS ((XCOFF_COMPLAIN_FUNCTION_ARGS)); 197 198 bfd_boolean (*xcoff_calculate_relocation[XCOFF_MAX_CALCULATE_RELOCATION]) 199 PARAMS ((XCOFF_RELOC_FUNCTION_ARGS)) = 200 { 201 xcoff_reloc_type_pos, /* R_POS (0x00) */ 202 xcoff_reloc_type_neg, /* R_NEG (0x01) */ 203 xcoff_reloc_type_rel, /* R_REL (0x02) */ 204 xcoff_reloc_type_toc, /* R_TOC (0x03) */ 205 xcoff_reloc_type_fail, /* R_RTB (0x04) */ 206 xcoff_reloc_type_toc, /* R_GL (0x05) */ 207 xcoff_reloc_type_toc, /* R_TCL (0x06) */ 208 xcoff_reloc_type_fail, /* (0x07) */ 209 xcoff_reloc_type_ba, /* R_BA (0x08) */ 210 xcoff_reloc_type_fail, /* (0x09) */ 211 xcoff_reloc_type_br, /* R_BR (0x0a) */ 212 xcoff_reloc_type_fail, /* (0x0b) */ 213 xcoff_reloc_type_pos, /* R_RL (0x0c) */ 214 xcoff_reloc_type_pos, /* R_RLA (0x0d) */ 215 xcoff_reloc_type_fail, /* (0x0e) */ 216 xcoff_reloc_type_noop, /* R_REF (0x0f) */ 217 xcoff_reloc_type_fail, /* (0x10) */ 218 xcoff_reloc_type_fail, /* (0x11) */ 219 xcoff_reloc_type_toc, /* R_TRL (0x12) */ 220 xcoff_reloc_type_toc, /* R_TRLA (0x13) */ 221 xcoff_reloc_type_fail, /* R_RRTBI (0x14) */ 222 xcoff_reloc_type_fail, /* R_RRTBA (0x15) */ 223 xcoff_reloc_type_ba, /* R_CAI (0x16) */ 224 xcoff_reloc_type_crel, /* R_CREL (0x17) */ 225 xcoff_reloc_type_ba, /* R_RBA (0x18) */ 226 xcoff_reloc_type_ba, /* R_RBAC (0x19) */ 227 xcoff_reloc_type_br, /* R_RBR (0x1a) */ 228 xcoff_reloc_type_ba, /* R_RBRC (0x1b) */ 229 }; 230 231 bfd_boolean (*xcoff_complain_overflow[XCOFF_MAX_COMPLAIN_OVERFLOW]) 232 PARAMS ((XCOFF_COMPLAIN_FUNCTION_ARGS)) = 233 { 234 xcoff_complain_overflow_dont_func, 235 xcoff_complain_overflow_bitfield_func, 236 xcoff_complain_overflow_signed_func, 237 xcoff_complain_overflow_unsigned_func, 238 }; 239 240 /* We use our own tdata type. Its first field is the COFF tdata type, 241 so the COFF routines are compatible. */ 242 243 bfd_boolean 244 _bfd_xcoff_mkobject (abfd) 245 bfd *abfd; 246 { 247 coff_data_type *coff; 248 bfd_size_type amt = sizeof (struct xcoff_tdata); 249 250 abfd->tdata.xcoff_obj_data = (struct xcoff_tdata *) bfd_zalloc (abfd, amt); 251 if (abfd->tdata.xcoff_obj_data == NULL) 252 return FALSE; 253 coff = coff_data (abfd); 254 coff->symbols = (coff_symbol_type *) NULL; 255 coff->conversion_table = (unsigned int *) NULL; 256 coff->raw_syments = (struct coff_ptr_struct *) NULL; 257 coff->relocbase = 0; 258 259 xcoff_data (abfd)->modtype = ('1' << 8) | 'L'; 260 261 /* We set cputype to -1 to indicate that it has not been 262 initialized. */ 263 xcoff_data (abfd)->cputype = -1; 264 265 xcoff_data (abfd)->csects = NULL; 266 xcoff_data (abfd)->debug_indices = NULL; 267 268 /* text section alignment is different than the default */ 269 bfd_xcoff_text_align_power (abfd) = 2; 270 271 return TRUE; 272 } 273 274 /* Copy XCOFF data from one BFD to another. */ 275 276 bfd_boolean 277 _bfd_xcoff_copy_private_bfd_data (ibfd, obfd) 278 bfd *ibfd; 279 bfd *obfd; 280 { 281 struct xcoff_tdata *ix, *ox; 282 asection *sec; 283 284 if (ibfd->xvec != obfd->xvec) 285 return TRUE; 286 ix = xcoff_data (ibfd); 287 ox = xcoff_data (obfd); 288 ox->full_aouthdr = ix->full_aouthdr; 289 ox->toc = ix->toc; 290 if (ix->sntoc == 0) 291 ox->sntoc = 0; 292 else 293 { 294 sec = coff_section_from_bfd_index (ibfd, ix->sntoc); 295 if (sec == NULL) 296 ox->sntoc = 0; 297 else 298 ox->sntoc = sec->output_section->target_index; 299 } 300 if (ix->snentry == 0) 301 ox->snentry = 0; 302 else 303 { 304 sec = coff_section_from_bfd_index (ibfd, ix->snentry); 305 if (sec == NULL) 306 ox->snentry = 0; 307 else 308 ox->snentry = sec->output_section->target_index; 309 } 310 bfd_xcoff_text_align_power (obfd) = bfd_xcoff_text_align_power (ibfd); 311 bfd_xcoff_data_align_power (obfd) = bfd_xcoff_data_align_power (ibfd); 312 ox->modtype = ix->modtype; 313 ox->cputype = ix->cputype; 314 ox->maxdata = ix->maxdata; 315 ox->maxstack = ix->maxstack; 316 return TRUE; 317 } 318 319 /* I don't think XCOFF really has a notion of local labels based on 320 name. This will mean that ld -X doesn't actually strip anything. 321 The AIX native linker does not have a -X option, and it ignores the 322 -x option. */ 323 324 bfd_boolean 325 _bfd_xcoff_is_local_label_name (abfd, name) 326 bfd *abfd ATTRIBUTE_UNUSED; 327 const char *name ATTRIBUTE_UNUSED; 328 { 329 return FALSE; 330 } 331 332 void 333 _bfd_xcoff_swap_sym_in (abfd, ext1, in1) 334 bfd *abfd; 335 PTR ext1; 336 PTR in1; 337 { 338 SYMENT *ext = (SYMENT *)ext1; 339 struct internal_syment * in = (struct internal_syment *)in1; 340 341 if (ext->e.e_name[0] != 0) 342 { 343 memcpy (in->_n._n_name, ext->e.e_name, SYMNMLEN); 344 } 345 else 346 { 347 in->_n._n_n._n_zeroes = 0; 348 in->_n._n_n._n_offset = H_GET_32 (abfd, ext->e.e.e_offset); 349 } 350 351 in->n_value = H_GET_32 (abfd, ext->e_value); 352 in->n_scnum = H_GET_16 (abfd, ext->e_scnum); 353 in->n_type = H_GET_16 (abfd, ext->e_type); 354 in->n_sclass = H_GET_8 (abfd, ext->e_sclass); 355 in->n_numaux = H_GET_8 (abfd, ext->e_numaux); 356 } 357 358 unsigned int 359 _bfd_xcoff_swap_sym_out (abfd, inp, extp) 360 bfd *abfd; 361 PTR inp; 362 PTR extp; 363 { 364 struct internal_syment *in = (struct internal_syment *)inp; 365 SYMENT *ext =(SYMENT *)extp; 366 367 if (in->_n._n_name[0] != 0) 368 { 369 memcpy (ext->e.e_name, in->_n._n_name, SYMNMLEN); 370 } 371 else 372 { 373 H_PUT_32 (abfd, 0, ext->e.e.e_zeroes); 374 H_PUT_32 (abfd, in->_n._n_n._n_offset, ext->e.e.e_offset); 375 } 376 377 H_PUT_32 (abfd, in->n_value, ext->e_value); 378 H_PUT_16 (abfd, in->n_scnum, ext->e_scnum); 379 H_PUT_16 (abfd, in->n_type, ext->e_type); 380 H_PUT_8 (abfd, in->n_sclass, ext->e_sclass); 381 H_PUT_8 (abfd, in->n_numaux, ext->e_numaux); 382 return bfd_coff_symesz (abfd); 383 } 384 385 void 386 _bfd_xcoff_swap_aux_in (abfd, ext1, type, class, indx, numaux, in1) 387 bfd *abfd; 388 PTR ext1; 389 int type; 390 int class; 391 int indx; 392 int numaux; 393 PTR in1; 394 { 395 AUXENT * ext = (AUXENT *)ext1; 396 union internal_auxent *in = (union internal_auxent *)in1; 397 398 switch (class) 399 { 400 case C_FILE: 401 if (ext->x_file.x_fname[0] == 0) 402 { 403 in->x_file.x_n.x_zeroes = 0; 404 in->x_file.x_n.x_offset = 405 H_GET_32 (abfd, ext->x_file.x_n.x_offset); 406 } 407 else 408 { 409 if (numaux > 1) 410 { 411 if (indx == 0) 412 memcpy (in->x_file.x_fname, ext->x_file.x_fname, 413 numaux * sizeof (AUXENT)); 414 } 415 else 416 { 417 memcpy (in->x_file.x_fname, ext->x_file.x_fname, FILNMLEN); 418 } 419 } 420 goto end; 421 422 /* RS/6000 "csect" auxents */ 423 case C_EXT: 424 case C_HIDEXT: 425 if (indx + 1 == numaux) 426 { 427 in->x_csect.x_scnlen.l = H_GET_32 (abfd, ext->x_csect.x_scnlen); 428 in->x_csect.x_parmhash = H_GET_32 (abfd, ext->x_csect.x_parmhash); 429 in->x_csect.x_snhash = H_GET_16 (abfd, ext->x_csect.x_snhash); 430 /* We don't have to hack bitfields in x_smtyp because it's 431 defined by shifts-and-ands, which are equivalent on all 432 byte orders. */ 433 in->x_csect.x_smtyp = H_GET_8 (abfd, ext->x_csect.x_smtyp); 434 in->x_csect.x_smclas = H_GET_8 (abfd, ext->x_csect.x_smclas); 435 in->x_csect.x_stab = H_GET_32 (abfd, ext->x_csect.x_stab); 436 in->x_csect.x_snstab = H_GET_16 (abfd, ext->x_csect.x_snstab); 437 goto end; 438 } 439 break; 440 441 case C_STAT: 442 case C_LEAFSTAT: 443 case C_HIDDEN: 444 if (type == T_NULL) 445 { 446 in->x_scn.x_scnlen = H_GET_32 (abfd, ext->x_scn.x_scnlen); 447 in->x_scn.x_nreloc = H_GET_16 (abfd, ext->x_scn.x_nreloc); 448 in->x_scn.x_nlinno = H_GET_16 (abfd, ext->x_scn.x_nlinno); 449 /* PE defines some extra fields; we zero them out for 450 safety. */ 451 in->x_scn.x_checksum = 0; 452 in->x_scn.x_associated = 0; 453 in->x_scn.x_comdat = 0; 454 455 goto end; 456 } 457 break; 458 } 459 460 in->x_sym.x_tagndx.l = H_GET_32 (abfd, ext->x_sym.x_tagndx); 461 in->x_sym.x_tvndx = H_GET_16 (abfd, ext->x_sym.x_tvndx); 462 463 if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class)) 464 { 465 in->x_sym.x_fcnary.x_fcn.x_lnnoptr = 466 H_GET_32 (abfd, ext->x_sym.x_fcnary.x_fcn.x_lnnoptr); 467 in->x_sym.x_fcnary.x_fcn.x_endndx.l = 468 H_GET_32 (abfd, ext->x_sym.x_fcnary.x_fcn.x_endndx); 469 } 470 else 471 { 472 in->x_sym.x_fcnary.x_ary.x_dimen[0] = 473 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[0]); 474 in->x_sym.x_fcnary.x_ary.x_dimen[1] = 475 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[1]); 476 in->x_sym.x_fcnary.x_ary.x_dimen[2] = 477 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[2]); 478 in->x_sym.x_fcnary.x_ary.x_dimen[3] = 479 H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[3]); 480 } 481 482 if (ISFCN (type)) 483 { 484 in->x_sym.x_misc.x_fsize = H_GET_32 (abfd, ext->x_sym.x_misc.x_fsize); 485 } 486 else 487 { 488 in->x_sym.x_misc.x_lnsz.x_lnno = 489 H_GET_16 (abfd, ext->x_sym.x_misc.x_lnsz.x_lnno); 490 in->x_sym.x_misc.x_lnsz.x_size = 491 H_GET_16 (abfd, ext->x_sym.x_misc.x_lnsz.x_size); 492 } 493 494 end: ; 495 /* The semicolon is because MSVC doesn't like labels at 496 end of block. */ 497 } 498 499 500 unsigned int _bfd_xcoff_swap_aux_out 501 PARAMS ((bfd *, PTR, int, int, int, int, PTR)); 502 503 unsigned int 504 _bfd_xcoff_swap_aux_out (abfd, inp, type, class, indx, numaux, extp) 505 bfd * abfd; 506 PTR inp; 507 int type; 508 int class; 509 int indx ATTRIBUTE_UNUSED; 510 int numaux ATTRIBUTE_UNUSED; 511 PTR extp; 512 { 513 union internal_auxent *in = (union internal_auxent *)inp; 514 AUXENT *ext = (AUXENT *)extp; 515 516 memset ((PTR)ext, 0, bfd_coff_auxesz (abfd)); 517 switch (class) 518 { 519 case C_FILE: 520 if (in->x_file.x_fname[0] == 0) 521 { 522 H_PUT_32 (abfd, 0, ext->x_file.x_n.x_zeroes); 523 H_PUT_32 (abfd, in->x_file.x_n.x_offset, ext->x_file.x_n.x_offset); 524 } 525 else 526 { 527 memcpy (ext->x_file.x_fname, in->x_file.x_fname, FILNMLEN); 528 } 529 goto end; 530 531 /* RS/6000 "csect" auxents */ 532 case C_EXT: 533 case C_HIDEXT: 534 if (indx + 1 == numaux) 535 { 536 H_PUT_32 (abfd, in->x_csect.x_scnlen.l, ext->x_csect.x_scnlen); 537 H_PUT_32 (abfd, in->x_csect.x_parmhash, ext->x_csect.x_parmhash); 538 H_PUT_16 (abfd, in->x_csect.x_snhash, ext->x_csect.x_snhash); 539 /* We don't have to hack bitfields in x_smtyp because it's 540 defined by shifts-and-ands, which are equivalent on all 541 byte orders. */ 542 H_PUT_8 (abfd, in->x_csect.x_smtyp, ext->x_csect.x_smtyp); 543 H_PUT_8 (abfd, in->x_csect.x_smclas, ext->x_csect.x_smclas); 544 H_PUT_32 (abfd, in->x_csect.x_stab, ext->x_csect.x_stab); 545 H_PUT_16 (abfd, in->x_csect.x_snstab, ext->x_csect.x_snstab); 546 goto end; 547 } 548 break; 549 550 case C_STAT: 551 case C_LEAFSTAT: 552 case C_HIDDEN: 553 if (type == T_NULL) 554 { 555 H_PUT_32 (abfd, in->x_scn.x_scnlen, ext->x_scn.x_scnlen); 556 H_PUT_16 (abfd, in->x_scn.x_nreloc, ext->x_scn.x_nreloc); 557 H_PUT_16 (abfd, in->x_scn.x_nlinno, ext->x_scn.x_nlinno); 558 goto end; 559 } 560 break; 561 } 562 563 H_PUT_32 (abfd, in->x_sym.x_tagndx.l, ext->x_sym.x_tagndx); 564 H_PUT_16 (abfd, in->x_sym.x_tvndx, ext->x_sym.x_tvndx); 565 566 if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class)) 567 { 568 H_PUT_32 (abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr, 569 ext->x_sym.x_fcnary.x_fcn.x_lnnoptr); 570 H_PUT_32 (abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l, 571 ext->x_sym.x_fcnary.x_fcn.x_endndx); 572 } 573 else 574 { 575 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[0], 576 ext->x_sym.x_fcnary.x_ary.x_dimen[0]); 577 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[1], 578 ext->x_sym.x_fcnary.x_ary.x_dimen[1]); 579 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[2], 580 ext->x_sym.x_fcnary.x_ary.x_dimen[2]); 581 H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[3], 582 ext->x_sym.x_fcnary.x_ary.x_dimen[3]); 583 } 584 585 if (ISFCN (type)) 586 H_PUT_32 (abfd, in->x_sym.x_misc.x_fsize, ext->x_sym.x_misc.x_fsize); 587 else 588 { 589 H_PUT_16 (abfd, in->x_sym.x_misc.x_lnsz.x_lnno, 590 ext->x_sym.x_misc.x_lnsz.x_lnno); 591 H_PUT_16 (abfd, in->x_sym.x_misc.x_lnsz.x_size, 592 ext->x_sym.x_misc.x_lnsz.x_size); 593 } 594 595 end: 596 return bfd_coff_auxesz (abfd); 597 } 598 599 600 601 /* The XCOFF reloc table. Actually, XCOFF relocations specify the 602 bitsize and whether they are signed or not, along with a 603 conventional type. This table is for the types, which are used for 604 different algorithms for putting in the reloc. Many of these 605 relocs need special_function entries, which I have not written. */ 606 607 608 reloc_howto_type xcoff_howto_table[] = 609 { 610 /* Standard 32 bit relocation. */ 611 HOWTO (R_POS, /* type */ 612 0, /* rightshift */ 613 2, /* size (0 = byte, 1 = short, 2 = long) */ 614 32, /* bitsize */ 615 FALSE, /* pc_relative */ 616 0, /* bitpos */ 617 complain_overflow_bitfield, /* complain_on_overflow */ 618 0, /* special_function */ 619 "R_POS", /* name */ 620 TRUE, /* partial_inplace */ 621 0xffffffff, /* src_mask */ 622 0xffffffff, /* dst_mask */ 623 FALSE), /* pcrel_offset */ 624 625 /* 32 bit relocation, but store negative value. */ 626 HOWTO (R_NEG, /* type */ 627 0, /* rightshift */ 628 -2, /* size (0 = byte, 1 = short, 2 = long) */ 629 32, /* bitsize */ 630 FALSE, /* pc_relative */ 631 0, /* bitpos */ 632 complain_overflow_bitfield, /* complain_on_overflow */ 633 0, /* special_function */ 634 "R_NEG", /* name */ 635 TRUE, /* partial_inplace */ 636 0xffffffff, /* src_mask */ 637 0xffffffff, /* dst_mask */ 638 FALSE), /* pcrel_offset */ 639 640 /* 32 bit PC relative relocation. */ 641 HOWTO (R_REL, /* type */ 642 0, /* rightshift */ 643 2, /* size (0 = byte, 1 = short, 2 = long) */ 644 32, /* bitsize */ 645 TRUE, /* pc_relative */ 646 0, /* bitpos */ 647 complain_overflow_signed, /* complain_on_overflow */ 648 0, /* special_function */ 649 "R_REL", /* name */ 650 TRUE, /* partial_inplace */ 651 0xffffffff, /* src_mask */ 652 0xffffffff, /* dst_mask */ 653 FALSE), /* pcrel_offset */ 654 655 /* 16 bit TOC relative relocation. */ 656 HOWTO (R_TOC, /* type */ 657 0, /* rightshift */ 658 1, /* size (0 = byte, 1 = short, 2 = long) */ 659 16, /* bitsize */ 660 FALSE, /* pc_relative */ 661 0, /* bitpos */ 662 complain_overflow_bitfield, /* complain_on_overflow */ 663 0, /* special_function */ 664 "R_TOC", /* name */ 665 TRUE, /* partial_inplace */ 666 0xffff, /* src_mask */ 667 0xffff, /* dst_mask */ 668 FALSE), /* pcrel_offset */ 669 670 /* I don't really know what this is. */ 671 HOWTO (R_RTB, /* type */ 672 1, /* rightshift */ 673 2, /* size (0 = byte, 1 = short, 2 = long) */ 674 32, /* bitsize */ 675 FALSE, /* pc_relative */ 676 0, /* bitpos */ 677 complain_overflow_bitfield, /* complain_on_overflow */ 678 0, /* special_function */ 679 "R_RTB", /* name */ 680 TRUE, /* partial_inplace */ 681 0xffffffff, /* src_mask */ 682 0xffffffff, /* dst_mask */ 683 FALSE), /* pcrel_offset */ 684 685 /* External TOC relative symbol. */ 686 HOWTO (R_GL, /* type */ 687 0, /* rightshift */ 688 1, /* size (0 = byte, 1 = short, 2 = long) */ 689 16, /* bitsize */ 690 FALSE, /* pc_relative */ 691 0, /* bitpos */ 692 complain_overflow_bitfield, /* complain_on_overflow */ 693 0, /* special_function */ 694 "R_GL", /* name */ 695 TRUE, /* partial_inplace */ 696 0xffff, /* src_mask */ 697 0xffff, /* dst_mask */ 698 FALSE), /* pcrel_offset */ 699 700 /* Local TOC relative symbol. */ 701 HOWTO (R_TCL, /* type */ 702 0, /* rightshift */ 703 1, /* size (0 = byte, 1 = short, 2 = long) */ 704 16, /* bitsize */ 705 FALSE, /* pc_relative */ 706 0, /* bitpos */ 707 complain_overflow_bitfield, /* complain_on_overflow */ 708 0, /* special_function */ 709 "R_TCL", /* name */ 710 TRUE, /* partial_inplace */ 711 0xffff, /* src_mask */ 712 0xffff, /* dst_mask */ 713 FALSE), /* pcrel_offset */ 714 715 EMPTY_HOWTO (7), 716 717 /* Non modifiable absolute branch. */ 718 HOWTO (R_BA, /* type */ 719 0, /* rightshift */ 720 2, /* size (0 = byte, 1 = short, 2 = long) */ 721 26, /* bitsize */ 722 FALSE, /* pc_relative */ 723 0, /* bitpos */ 724 complain_overflow_bitfield, /* complain_on_overflow */ 725 0, /* special_function */ 726 "R_BA_26", /* name */ 727 TRUE, /* partial_inplace */ 728 0x03fffffc, /* src_mask */ 729 0x03fffffc, /* dst_mask */ 730 FALSE), /* pcrel_offset */ 731 732 EMPTY_HOWTO (9), 733 734 /* Non modifiable relative branch. */ 735 HOWTO (R_BR, /* type */ 736 0, /* rightshift */ 737 2, /* size (0 = byte, 1 = short, 2 = long) */ 738 26, /* bitsize */ 739 TRUE, /* pc_relative */ 740 0, /* bitpos */ 741 complain_overflow_signed, /* complain_on_overflow */ 742 0, /* special_function */ 743 "R_BR", /* name */ 744 TRUE, /* partial_inplace */ 745 0x03fffffc, /* src_mask */ 746 0x03fffffc, /* dst_mask */ 747 FALSE), /* pcrel_offset */ 748 749 EMPTY_HOWTO (0xb), 750 751 /* Indirect load. */ 752 HOWTO (R_RL, /* type */ 753 0, /* rightshift */ 754 1, /* size (0 = byte, 1 = short, 2 = long) */ 755 16, /* bitsize */ 756 FALSE, /* pc_relative */ 757 0, /* bitpos */ 758 complain_overflow_bitfield, /* complain_on_overflow */ 759 0, /* special_function */ 760 "R_RL", /* name */ 761 TRUE, /* partial_inplace */ 762 0xffff, /* src_mask */ 763 0xffff, /* dst_mask */ 764 FALSE), /* pcrel_offset */ 765 766 /* Load address. */ 767 HOWTO (R_RLA, /* type */ 768 0, /* rightshift */ 769 1, /* size (0 = byte, 1 = short, 2 = long) */ 770 16, /* bitsize */ 771 FALSE, /* pc_relative */ 772 0, /* bitpos */ 773 complain_overflow_bitfield, /* complain_on_overflow */ 774 0, /* special_function */ 775 "R_RLA", /* name */ 776 TRUE, /* partial_inplace */ 777 0xffff, /* src_mask */ 778 0xffff, /* dst_mask */ 779 FALSE), /* pcrel_offset */ 780 781 EMPTY_HOWTO (0xe), 782 783 /* Non-relocating reference. */ 784 HOWTO (R_REF, /* type */ 785 0, /* rightshift */ 786 2, /* size (0 = byte, 1 = short, 2 = long) */ 787 32, /* bitsize */ 788 FALSE, /* pc_relative */ 789 0, /* bitpos */ 790 complain_overflow_dont, /* complain_on_overflow */ 791 0, /* special_function */ 792 "R_REF", /* name */ 793 FALSE, /* partial_inplace */ 794 0, /* src_mask */ 795 0, /* dst_mask */ 796 FALSE), /* pcrel_offset */ 797 798 EMPTY_HOWTO (0x10), 799 EMPTY_HOWTO (0x11), 800 801 /* TOC relative indirect load. */ 802 HOWTO (R_TRL, /* type */ 803 0, /* rightshift */ 804 1, /* size (0 = byte, 1 = short, 2 = long) */ 805 16, /* bitsize */ 806 FALSE, /* pc_relative */ 807 0, /* bitpos */ 808 complain_overflow_bitfield, /* complain_on_overflow */ 809 0, /* special_function */ 810 "R_TRL", /* name */ 811 TRUE, /* partial_inplace */ 812 0xffff, /* src_mask */ 813 0xffff, /* dst_mask */ 814 FALSE), /* pcrel_offset */ 815 816 /* TOC relative load address. */ 817 HOWTO (R_TRLA, /* type */ 818 0, /* rightshift */ 819 1, /* size (0 = byte, 1 = short, 2 = long) */ 820 16, /* bitsize */ 821 FALSE, /* pc_relative */ 822 0, /* bitpos */ 823 complain_overflow_bitfield, /* complain_on_overflow */ 824 0, /* special_function */ 825 "R_TRLA", /* name */ 826 TRUE, /* partial_inplace */ 827 0xffff, /* src_mask */ 828 0xffff, /* dst_mask */ 829 FALSE), /* pcrel_offset */ 830 831 /* Modifiable relative branch. */ 832 HOWTO (R_RRTBI, /* type */ 833 1, /* rightshift */ 834 2, /* size (0 = byte, 1 = short, 2 = long) */ 835 32, /* bitsize */ 836 FALSE, /* pc_relative */ 837 0, /* bitpos */ 838 complain_overflow_bitfield, /* complain_on_overflow */ 839 0, /* special_function */ 840 "R_RRTBI", /* name */ 841 TRUE, /* partial_inplace */ 842 0xffffffff, /* src_mask */ 843 0xffffffff, /* dst_mask */ 844 FALSE), /* pcrel_offset */ 845 846 /* Modifiable absolute branch. */ 847 HOWTO (R_RRTBA, /* type */ 848 1, /* rightshift */ 849 2, /* size (0 = byte, 1 = short, 2 = long) */ 850 32, /* bitsize */ 851 FALSE, /* pc_relative */ 852 0, /* bitpos */ 853 complain_overflow_bitfield, /* complain_on_overflow */ 854 0, /* special_function */ 855 "R_RRTBA", /* name */ 856 TRUE, /* partial_inplace */ 857 0xffffffff, /* src_mask */ 858 0xffffffff, /* dst_mask */ 859 FALSE), /* pcrel_offset */ 860 861 /* Modifiable call absolute indirect. */ 862 HOWTO (R_CAI, /* type */ 863 0, /* rightshift */ 864 1, /* size (0 = byte, 1 = short, 2 = long) */ 865 16, /* bitsize */ 866 FALSE, /* pc_relative */ 867 0, /* bitpos */ 868 complain_overflow_bitfield, /* complain_on_overflow */ 869 0, /* special_function */ 870 "R_CAI", /* name */ 871 TRUE, /* partial_inplace */ 872 0xffff, /* src_mask */ 873 0xffff, /* dst_mask */ 874 FALSE), /* pcrel_offset */ 875 876 /* Modifiable call relative. */ 877 HOWTO (R_CREL, /* type */ 878 0, /* rightshift */ 879 1, /* size (0 = byte, 1 = short, 2 = long) */ 880 16, /* bitsize */ 881 FALSE, /* pc_relative */ 882 0, /* bitpos */ 883 complain_overflow_bitfield, /* complain_on_overflow */ 884 0, /* special_function */ 885 "R_CREL", /* name */ 886 TRUE, /* partial_inplace */ 887 0xffff, /* src_mask */ 888 0xffff, /* dst_mask */ 889 FALSE), /* pcrel_offset */ 890 891 /* Modifiable branch absolute. */ 892 HOWTO (R_RBA, /* type */ 893 0, /* rightshift */ 894 2, /* size (0 = byte, 1 = short, 2 = long) */ 895 26, /* bitsize */ 896 FALSE, /* pc_relative */ 897 0, /* bitpos */ 898 complain_overflow_bitfield, /* complain_on_overflow */ 899 0, /* special_function */ 900 "R_RBA", /* name */ 901 TRUE, /* partial_inplace */ 902 0x03fffffc, /* src_mask */ 903 0x03fffffc, /* dst_mask */ 904 FALSE), /* pcrel_offset */ 905 906 /* Modifiable branch absolute. */ 907 HOWTO (R_RBAC, /* type */ 908 0, /* rightshift */ 909 2, /* size (0 = byte, 1 = short, 2 = long) */ 910 32, /* bitsize */ 911 FALSE, /* pc_relative */ 912 0, /* bitpos */ 913 complain_overflow_bitfield, /* complain_on_overflow */ 914 0, /* special_function */ 915 "R_RBAC", /* name */ 916 TRUE, /* partial_inplace */ 917 0xffffffff, /* src_mask */ 918 0xffffffff, /* dst_mask */ 919 FALSE), /* pcrel_offset */ 920 921 /* Modifiable branch relative. */ 922 HOWTO (R_RBR, /* type */ 923 0, /* rightshift */ 924 2, /* size (0 = byte, 1 = short, 2 = long) */ 925 26, /* bitsize */ 926 FALSE, /* pc_relative */ 927 0, /* bitpos */ 928 complain_overflow_signed, /* complain_on_overflow */ 929 0, /* special_function */ 930 "R_RBR_26", /* name */ 931 TRUE, /* partial_inplace */ 932 0x03fffffc, /* src_mask */ 933 0x03fffffc, /* dst_mask */ 934 FALSE), /* pcrel_offset */ 935 936 /* Modifiable branch absolute. */ 937 HOWTO (R_RBRC, /* type */ 938 0, /* rightshift */ 939 1, /* size (0 = byte, 1 = short, 2 = long) */ 940 16, /* bitsize */ 941 FALSE, /* pc_relative */ 942 0, /* bitpos */ 943 complain_overflow_bitfield, /* complain_on_overflow */ 944 0, /* special_function */ 945 "R_RBRC", /* name */ 946 TRUE, /* partial_inplace */ 947 0xffff, /* src_mask */ 948 0xffff, /* dst_mask */ 949 FALSE), /* pcrel_offset */ 950 951 /* 16 bit Non modifiable absolute branch. */ 952 HOWTO (R_BA, /* type */ 953 0, /* rightshift */ 954 1, /* size (0 = byte, 1 = short, 2 = long) */ 955 16, /* bitsize */ 956 FALSE, /* pc_relative */ 957 0, /* bitpos */ 958 complain_overflow_bitfield, /* complain_on_overflow */ 959 0, /* special_function */ 960 "R_BA_16", /* name */ 961 TRUE, /* partial_inplace */ 962 0xfffc, /* src_mask */ 963 0xfffc, /* dst_mask */ 964 FALSE), /* pcrel_offset */ 965 966 /* Modifiable branch relative. */ 967 HOWTO (R_RBR, /* type */ 968 0, /* rightshift */ 969 1, /* size (0 = byte, 1 = short, 2 = long) */ 970 16, /* bitsize */ 971 FALSE, /* pc_relative */ 972 0, /* bitpos */ 973 complain_overflow_signed, /* complain_on_overflow */ 974 0, /* special_function */ 975 "R_RBR_16", /* name */ 976 TRUE, /* partial_inplace */ 977 0xffff, /* src_mask */ 978 0xffff, /* dst_mask */ 979 FALSE), /* pcrel_offset */ 980 981 /* Modifiable branch relative. */ 982 HOWTO (R_RBA, /* type */ 983 0, /* rightshift */ 984 1, /* size (0 = byte, 1 = short, 2 = long) */ 985 16, /* bitsize */ 986 FALSE, /* pc_relative */ 987 0, /* bitpos */ 988 complain_overflow_signed, /* complain_on_overflow */ 989 0, /* special_function */ 990 "R_RBA_16", /* name */ 991 TRUE, /* partial_inplace */ 992 0xffff, /* src_mask */ 993 0xffff, /* dst_mask */ 994 FALSE), /* pcrel_offset */ 995 996 }; 997 998 void 999 xcoff_rtype2howto (relent, internal) 1000 arelent *relent; 1001 struct internal_reloc *internal; 1002 { 1003 if (internal->r_type > R_RBRC) 1004 abort (); 1005 1006 /* Default howto layout works most of the time */ 1007 relent->howto = &xcoff_howto_table[internal->r_type]; 1008 1009 /* Special case some 16 bit reloc */ 1010 if (15 == (internal->r_size & 0x1f)) 1011 { 1012 if (R_BA == internal->r_type) 1013 relent->howto = &xcoff_howto_table[0x1c]; 1014 else if (R_RBR == internal->r_type) 1015 relent->howto = &xcoff_howto_table[0x1d]; 1016 else if (R_RBA == internal->r_type) 1017 relent->howto = &xcoff_howto_table[0x1e]; 1018 } 1019 1020 /* The r_size field of an XCOFF reloc encodes the bitsize of the 1021 relocation, as well as indicating whether it is signed or not. 1022 Doublecheck that the relocation information gathered from the 1023 type matches this information. The bitsize is not significant 1024 for R_REF relocs. */ 1025 if (relent->howto->dst_mask != 0 1026 && (relent->howto->bitsize 1027 != ((unsigned int) internal->r_size & 0x1f) + 1)) 1028 abort (); 1029 } 1030 1031 reloc_howto_type * 1032 _bfd_xcoff_reloc_type_lookup (abfd, code) 1033 bfd *abfd ATTRIBUTE_UNUSED; 1034 bfd_reloc_code_real_type code; 1035 { 1036 switch (code) 1037 { 1038 case BFD_RELOC_PPC_B26: 1039 return &xcoff_howto_table[0xa]; 1040 case BFD_RELOC_PPC_BA16: 1041 return &xcoff_howto_table[0x1c]; 1042 case BFD_RELOC_PPC_BA26: 1043 return &xcoff_howto_table[8]; 1044 case BFD_RELOC_PPC_TOC16: 1045 return &xcoff_howto_table[3]; 1046 case BFD_RELOC_32: 1047 case BFD_RELOC_CTOR: 1048 return &xcoff_howto_table[0]; 1049 default: 1050 return NULL; 1051 } 1052 } 1053 1054 1055 /* XCOFF archive support. The original version of this code was by 1056 Damon A. Permezel. It was enhanced to permit cross support, and 1057 writing archive files, by Ian Lance Taylor, Cygnus Support. 1058 1059 XCOFF uses its own archive format. Everything is hooked together 1060 with file offset links, so it is possible to rapidly update an 1061 archive in place. Of course, we don't do that. An XCOFF archive 1062 has a real file header, not just an ARMAG string. The structure of 1063 the file header and of each archive header appear below. 1064 1065 An XCOFF archive also has a member table, which is a list of 1066 elements in the archive (you can get that by looking through the 1067 linked list, but you have to read a lot more of the file). The 1068 member table has a normal archive header with an empty name. It is 1069 normally (and perhaps must be) the second to last entry in the 1070 archive. The member table data is almost printable ASCII. It 1071 starts with a 12 character decimal string which is the number of 1072 entries in the table. For each entry it has a 12 character decimal 1073 string which is the offset in the archive of that member. These 1074 entries are followed by a series of null terminated strings which 1075 are the member names for each entry. 1076 1077 Finally, an XCOFF archive has a global symbol table, which is what 1078 we call the armap. The global symbol table has a normal archive 1079 header with an empty name. It is normally (and perhaps must be) 1080 the last entry in the archive. The contents start with a four byte 1081 binary number which is the number of entries. This is followed by 1082 a that many four byte binary numbers; each is the file offset of an 1083 entry in the archive. These numbers are followed by a series of 1084 null terminated strings, which are symbol names. 1085 1086 AIX 4.3 introduced a new archive format which can handle larger 1087 files and also 32- and 64-bit objects in the same archive. The 1088 things said above remain true except that there is now more than 1089 one global symbol table. The one is used to index 32-bit objects, 1090 the other for 64-bit objects. 1091 1092 The new archives (recognizable by the new ARMAG string) has larger 1093 field lengths so that we cannot really share any code. Also we have 1094 to take care that we are not generating the new form of archives 1095 on AIX 4.2 or earlier systems. */ 1096 1097 /* XCOFF archives use this as a magic string. Note that both strings 1098 have the same length. */ 1099 1100 /* Set the magic for archive. */ 1101 1102 bfd_boolean 1103 bfd_xcoff_ar_archive_set_magic (abfd, magic) 1104 bfd *abfd ATTRIBUTE_UNUSED; 1105 char *magic ATTRIBUTE_UNUSED; 1106 { 1107 /* Not supported yet. */ 1108 return FALSE; 1109 /* bfd_xcoff_archive_set_magic (abfd, magic); */ 1110 } 1111 1112 /* Read in the armap of an XCOFF archive. */ 1113 1114 bfd_boolean 1115 _bfd_xcoff_slurp_armap (abfd) 1116 bfd *abfd; 1117 { 1118 file_ptr off; 1119 size_t namlen; 1120 bfd_size_type sz; 1121 bfd_byte *contents, *cend; 1122 bfd_vma c, i; 1123 carsym *arsym; 1124 bfd_byte *p; 1125 1126 if (xcoff_ardata (abfd) == NULL) 1127 { 1128 bfd_has_map (abfd) = FALSE; 1129 return TRUE; 1130 } 1131 1132 if (! xcoff_big_format_p (abfd)) 1133 { 1134 /* This is for the old format. */ 1135 struct xcoff_ar_hdr hdr; 1136 1137 off = strtol (xcoff_ardata (abfd)->symoff, (char **) NULL, 10); 1138 if (off == 0) 1139 { 1140 bfd_has_map (abfd) = FALSE; 1141 return TRUE; 1142 } 1143 1144 if (bfd_seek (abfd, off, SEEK_SET) != 0) 1145 return FALSE; 1146 1147 /* The symbol table starts with a normal archive header. */ 1148 if (bfd_bread ((PTR) &hdr, (bfd_size_type) SIZEOF_AR_HDR, abfd) 1149 != SIZEOF_AR_HDR) 1150 return FALSE; 1151 1152 /* Skip the name (normally empty). */ 1153 namlen = strtol (hdr.namlen, (char **) NULL, 10); 1154 off = ((namlen + 1) & ~ (size_t) 1) + SXCOFFARFMAG; 1155 if (bfd_seek (abfd, off, SEEK_CUR) != 0) 1156 return FALSE; 1157 1158 sz = strtol (hdr.size, (char **) NULL, 10); 1159 1160 /* Read in the entire symbol table. */ 1161 contents = (bfd_byte *) bfd_alloc (abfd, sz); 1162 if (contents == NULL) 1163 return FALSE; 1164 if (bfd_bread ((PTR) contents, sz, abfd) != sz) 1165 return FALSE; 1166 1167 /* The symbol table starts with a four byte count. */ 1168 c = H_GET_32 (abfd, contents); 1169 1170 if (c * 4 >= sz) 1171 { 1172 bfd_set_error (bfd_error_bad_value); 1173 return FALSE; 1174 } 1175 1176 bfd_ardata (abfd)->symdefs = 1177 ((carsym *) bfd_alloc (abfd, c * sizeof (carsym))); 1178 if (bfd_ardata (abfd)->symdefs == NULL) 1179 return FALSE; 1180 1181 /* After the count comes a list of four byte file offsets. */ 1182 for (i = 0, arsym = bfd_ardata (abfd)->symdefs, p = contents + 4; 1183 i < c; 1184 ++i, ++arsym, p += 4) 1185 arsym->file_offset = H_GET_32 (abfd, p); 1186 } 1187 else 1188 { 1189 /* This is for the new format. */ 1190 struct xcoff_ar_hdr_big hdr; 1191 1192 off = strtol (xcoff_ardata_big (abfd)->symoff, (char **) NULL, 10); 1193 if (off == 0) 1194 { 1195 bfd_has_map (abfd) = FALSE; 1196 return TRUE; 1197 } 1198 1199 if (bfd_seek (abfd, off, SEEK_SET) != 0) 1200 return FALSE; 1201 1202 /* The symbol table starts with a normal archive header. */ 1203 if (bfd_bread ((PTR) &hdr, (bfd_size_type) SIZEOF_AR_HDR_BIG, abfd) 1204 != SIZEOF_AR_HDR_BIG) 1205 return FALSE; 1206 1207 /* Skip the name (normally empty). */ 1208 namlen = strtol (hdr.namlen, (char **) NULL, 10); 1209 off = ((namlen + 1) & ~ (size_t) 1) + SXCOFFARFMAG; 1210 if (bfd_seek (abfd, off, SEEK_CUR) != 0) 1211 return FALSE; 1212 1213 /* XXX This actually has to be a call to strtoll (at least on 32-bit 1214 machines) since the field width is 20 and there numbers with more 1215 than 32 bits can be represented. */ 1216 sz = strtol (hdr.size, (char **) NULL, 10); 1217 1218 /* Read in the entire symbol table. */ 1219 contents = (bfd_byte *) bfd_alloc (abfd, sz); 1220 if (contents == NULL) 1221 return FALSE; 1222 if (bfd_bread ((PTR) contents, sz, abfd) != sz) 1223 return FALSE; 1224 1225 /* The symbol table starts with an eight byte count. */ 1226 c = H_GET_64 (abfd, contents); 1227 1228 if (c * 8 >= sz) 1229 { 1230 bfd_set_error (bfd_error_bad_value); 1231 return FALSE; 1232 } 1233 1234 bfd_ardata (abfd)->symdefs = 1235 ((carsym *) bfd_alloc (abfd, c * sizeof (carsym))); 1236 if (bfd_ardata (abfd)->symdefs == NULL) 1237 return FALSE; 1238 1239 /* After the count comes a list of eight byte file offsets. */ 1240 for (i = 0, arsym = bfd_ardata (abfd)->symdefs, p = contents + 8; 1241 i < c; 1242 ++i, ++arsym, p += 8) 1243 arsym->file_offset = H_GET_64 (abfd, p); 1244 } 1245 1246 /* After the file offsets come null terminated symbol names. */ 1247 cend = contents + sz; 1248 for (i = 0, arsym = bfd_ardata (abfd)->symdefs; 1249 i < c; 1250 ++i, ++arsym, p += strlen ((char *) p) + 1) 1251 { 1252 if (p >= cend) 1253 { 1254 bfd_set_error (bfd_error_bad_value); 1255 return FALSE; 1256 } 1257 arsym->name = (char *) p; 1258 } 1259 1260 bfd_ardata (abfd)->symdef_count = c; 1261 bfd_has_map (abfd) = TRUE; 1262 1263 return TRUE; 1264 } 1265 1266 /* See if this is an XCOFF archive. */ 1267 1268 const bfd_target * 1269 _bfd_xcoff_archive_p (abfd) 1270 bfd *abfd; 1271 { 1272 struct artdata *tdata_hold; 1273 char magic[SXCOFFARMAG]; 1274 bfd_size_type amt = SXCOFFARMAG; 1275 1276 if (bfd_bread ((PTR) magic, amt, abfd) != amt) 1277 { 1278 if (bfd_get_error () != bfd_error_system_call) 1279 bfd_set_error (bfd_error_wrong_format); 1280 return NULL; 1281 } 1282 1283 if (strncmp (magic, XCOFFARMAG, SXCOFFARMAG) != 0 1284 && strncmp (magic, XCOFFARMAGBIG, SXCOFFARMAG) != 0) 1285 { 1286 bfd_set_error (bfd_error_wrong_format); 1287 return NULL; 1288 } 1289 1290 tdata_hold = bfd_ardata (abfd); 1291 1292 amt = sizeof (struct artdata); 1293 bfd_ardata (abfd) = (struct artdata *) bfd_zalloc (abfd, amt); 1294 if (bfd_ardata (abfd) == (struct artdata *) NULL) 1295 goto error_ret_restore; 1296 1297 bfd_ardata (abfd)->cache = NULL; 1298 bfd_ardata (abfd)->archive_head = NULL; 1299 bfd_ardata (abfd)->symdefs = NULL; 1300 bfd_ardata (abfd)->extended_names = NULL; 1301 1302 /* Now handle the two formats. */ 1303 if (magic[1] != 'b') 1304 { 1305 /* This is the old format. */ 1306 struct xcoff_ar_file_hdr hdr; 1307 1308 /* Copy over the magic string. */ 1309 memcpy (hdr.magic, magic, SXCOFFARMAG); 1310 1311 /* Now read the rest of the file header. */ 1312 amt = SIZEOF_AR_FILE_HDR - SXCOFFARMAG; 1313 if (bfd_bread ((PTR) &hdr.memoff, amt, abfd) != amt) 1314 { 1315 if (bfd_get_error () != bfd_error_system_call) 1316 bfd_set_error (bfd_error_wrong_format); 1317 goto error_ret; 1318 } 1319 1320 bfd_ardata (abfd)->first_file_filepos = strtol (hdr.firstmemoff, 1321 (char **) NULL, 10); 1322 1323 amt = SIZEOF_AR_FILE_HDR; 1324 bfd_ardata (abfd)->tdata = bfd_zalloc (abfd, amt); 1325 if (bfd_ardata (abfd)->tdata == NULL) 1326 goto error_ret; 1327 1328 memcpy (bfd_ardata (abfd)->tdata, &hdr, SIZEOF_AR_FILE_HDR); 1329 } 1330 else 1331 { 1332 /* This is the new format. */ 1333 struct xcoff_ar_file_hdr_big hdr; 1334 1335 /* Copy over the magic string. */ 1336 memcpy (hdr.magic, magic, SXCOFFARMAG); 1337 1338 /* Now read the rest of the file header. */ 1339 amt = SIZEOF_AR_FILE_HDR_BIG - SXCOFFARMAG; 1340 if (bfd_bread ((PTR) &hdr.memoff, amt, abfd) != amt) 1341 { 1342 if (bfd_get_error () != bfd_error_system_call) 1343 bfd_set_error (bfd_error_wrong_format); 1344 goto error_ret; 1345 } 1346 1347 bfd_ardata (abfd)->first_file_filepos = bfd_scan_vma (hdr.firstmemoff, 1348 (const char **) 0, 1349 10); 1350 1351 amt = SIZEOF_AR_FILE_HDR_BIG; 1352 bfd_ardata (abfd)->tdata = bfd_zalloc (abfd, amt); 1353 if (bfd_ardata (abfd)->tdata == NULL) 1354 goto error_ret; 1355 1356 memcpy (bfd_ardata (abfd)->tdata, &hdr, SIZEOF_AR_FILE_HDR_BIG); 1357 } 1358 1359 if (! _bfd_xcoff_slurp_armap (abfd)) 1360 { 1361 error_ret: 1362 bfd_release (abfd, bfd_ardata (abfd)); 1363 error_ret_restore: 1364 bfd_ardata (abfd) = tdata_hold; 1365 return NULL; 1366 } 1367 1368 return abfd->xvec; 1369 } 1370 1371 /* Read the archive header in an XCOFF archive. */ 1372 1373 PTR 1374 _bfd_xcoff_read_ar_hdr (abfd) 1375 bfd *abfd; 1376 { 1377 bfd_size_type namlen; 1378 struct areltdata *ret; 1379 bfd_size_type amt = sizeof (struct areltdata); 1380 1381 ret = (struct areltdata *) bfd_alloc (abfd, amt); 1382 if (ret == NULL) 1383 return NULL; 1384 1385 if (! xcoff_big_format_p (abfd)) 1386 { 1387 struct xcoff_ar_hdr hdr; 1388 struct xcoff_ar_hdr *hdrp; 1389 1390 if (bfd_bread ((PTR) &hdr, (bfd_size_type) SIZEOF_AR_HDR, abfd) 1391 != SIZEOF_AR_HDR) 1392 { 1393 free (ret); 1394 return NULL; 1395 } 1396 1397 namlen = strtol (hdr.namlen, (char **) NULL, 10); 1398 amt = SIZEOF_AR_HDR + namlen + 1; 1399 hdrp = (struct xcoff_ar_hdr *) bfd_alloc (abfd, amt); 1400 if (hdrp == NULL) 1401 { 1402 free (ret); 1403 return NULL; 1404 } 1405 memcpy (hdrp, &hdr, SIZEOF_AR_HDR); 1406 if (bfd_bread ((char *) hdrp + SIZEOF_AR_HDR, namlen, abfd) != namlen) 1407 { 1408 free (ret); 1409 return NULL; 1410 } 1411 ((char *) hdrp)[SIZEOF_AR_HDR + namlen] = '\0'; 1412 1413 ret->arch_header = (char *) hdrp; 1414 ret->parsed_size = strtol (hdr.size, (char **) NULL, 10); 1415 ret->filename = (char *) hdrp + SIZEOF_AR_HDR; 1416 } 1417 else 1418 { 1419 struct xcoff_ar_hdr_big hdr; 1420 struct xcoff_ar_hdr_big *hdrp; 1421 1422 if (bfd_bread ((PTR) &hdr, (bfd_size_type) SIZEOF_AR_HDR_BIG, abfd) 1423 != SIZEOF_AR_HDR_BIG) 1424 { 1425 free (ret); 1426 return NULL; 1427 } 1428 1429 namlen = strtol (hdr.namlen, (char **) NULL, 10); 1430 amt = SIZEOF_AR_HDR_BIG + namlen + 1; 1431 hdrp = (struct xcoff_ar_hdr_big *) bfd_alloc (abfd, amt); 1432 if (hdrp == NULL) 1433 { 1434 free (ret); 1435 return NULL; 1436 } 1437 memcpy (hdrp, &hdr, SIZEOF_AR_HDR_BIG); 1438 if (bfd_bread ((char *) hdrp + SIZEOF_AR_HDR_BIG, namlen, abfd) != namlen) 1439 { 1440 free (ret); 1441 return NULL; 1442 } 1443 ((char *) hdrp)[SIZEOF_AR_HDR_BIG + namlen] = '\0'; 1444 1445 ret->arch_header = (char *) hdrp; 1446 /* XXX This actually has to be a call to strtoll (at least on 32-bit 1447 machines) since the field width is 20 and there numbers with more 1448 than 32 bits can be represented. */ 1449 ret->parsed_size = strtol (hdr.size, (char **) NULL, 10); 1450 ret->filename = (char *) hdrp + SIZEOF_AR_HDR_BIG; 1451 } 1452 1453 /* Skip over the XCOFFARFMAG at the end of the file name. */ 1454 if (bfd_seek (abfd, (file_ptr) ((namlen & 1) + SXCOFFARFMAG), SEEK_CUR) != 0) 1455 return NULL; 1456 1457 return (PTR) ret; 1458 } 1459 1460 /* Open the next element in an XCOFF archive. */ 1461 1462 bfd * 1463 _bfd_xcoff_openr_next_archived_file (archive, last_file) 1464 bfd *archive; 1465 bfd *last_file; 1466 { 1467 file_ptr filestart; 1468 1469 if (xcoff_ardata (archive) == NULL) 1470 { 1471 bfd_set_error (bfd_error_invalid_operation); 1472 return NULL; 1473 } 1474 1475 if (! xcoff_big_format_p (archive)) 1476 { 1477 if (last_file == NULL) 1478 filestart = bfd_ardata (archive)->first_file_filepos; 1479 else 1480 filestart = strtol (arch_xhdr (last_file)->nextoff, (char **) NULL, 1481 10); 1482 1483 if (filestart == 0 1484 || filestart == strtol (xcoff_ardata (archive)->memoff, 1485 (char **) NULL, 10) 1486 || filestart == strtol (xcoff_ardata (archive)->symoff, 1487 (char **) NULL, 10)) 1488 { 1489 bfd_set_error (bfd_error_no_more_archived_files); 1490 return NULL; 1491 } 1492 } 1493 else 1494 { 1495 if (last_file == NULL) 1496 filestart = bfd_ardata (archive)->first_file_filepos; 1497 else 1498 /* XXX These actually have to be a calls to strtoll (at least 1499 on 32-bit machines) since the fields's width is 20 and 1500 there numbers with more than 32 bits can be represented. */ 1501 filestart = strtol (arch_xhdr_big (last_file)->nextoff, (char **) NULL, 1502 10); 1503 1504 /* XXX These actually have to be calls to strtoll (at least on 32-bit 1505 machines) since the fields's width is 20 and there numbers with more 1506 than 32 bits can be represented. */ 1507 if (filestart == 0 1508 || filestart == strtol (xcoff_ardata_big (archive)->memoff, 1509 (char **) NULL, 10) 1510 || filestart == strtol (xcoff_ardata_big (archive)->symoff, 1511 (char **) NULL, 10)) 1512 { 1513 bfd_set_error (bfd_error_no_more_archived_files); 1514 return NULL; 1515 } 1516 } 1517 1518 return _bfd_get_elt_at_filepos (archive, filestart); 1519 } 1520 1521 /* Stat an element in an XCOFF archive. */ 1522 1523 int 1524 _bfd_xcoff_stat_arch_elt (abfd, s) 1525 bfd *abfd; 1526 struct stat *s; 1527 { 1528 if (abfd->arelt_data == NULL) 1529 { 1530 bfd_set_error (bfd_error_invalid_operation); 1531 return -1; 1532 } 1533 1534 if (! xcoff_big_format_p (abfd->my_archive)) 1535 { 1536 struct xcoff_ar_hdr *hdrp = arch_xhdr (abfd); 1537 1538 s->st_mtime = strtoll (hdrp->date, (char **) NULL, 10); 1539 s->st_uid = strtol (hdrp->uid, (char **) NULL, 10); 1540 s->st_gid = strtol (hdrp->gid, (char **) NULL, 10); 1541 s->st_mode = strtol (hdrp->mode, (char **) NULL, 8); 1542 s->st_size = arch_eltdata (abfd)->parsed_size; 1543 } 1544 else 1545 { 1546 struct xcoff_ar_hdr_big *hdrp = arch_xhdr_big (abfd); 1547 1548 s->st_mtime = strtoll (hdrp->date, (char **) NULL, 10); 1549 s->st_uid = strtol (hdrp->uid, (char **) NULL, 10); 1550 s->st_gid = strtol (hdrp->gid, (char **) NULL, 10); 1551 s->st_mode = strtol (hdrp->mode, (char **) NULL, 8); 1552 s->st_size = arch_eltdata (abfd)->parsed_size; 1553 } 1554 1555 return 0; 1556 } 1557 1558 /* Normalize a file name for inclusion in an archive. */ 1559 1560 static const char * 1561 normalize_filename (abfd) 1562 bfd *abfd; 1563 { 1564 const char *file; 1565 const char *filename; 1566 1567 file = bfd_get_filename (abfd); 1568 filename = strrchr (file, '/'); 1569 if (filename != NULL) 1570 filename++; 1571 else 1572 filename = file; 1573 return filename; 1574 } 1575 1576 /* Write out an XCOFF armap. */ 1577 1578 static bfd_boolean 1579 xcoff_write_armap_old (abfd, elength, map, orl_count, stridx) 1580 bfd *abfd; 1581 unsigned int elength ATTRIBUTE_UNUSED; 1582 struct orl *map; 1583 unsigned int orl_count; 1584 int stridx; 1585 { 1586 struct xcoff_ar_hdr hdr; 1587 char *p; 1588 unsigned char buf[4]; 1589 bfd *sub; 1590 file_ptr fileoff; 1591 unsigned int i; 1592 1593 memset (&hdr, 0, sizeof hdr); 1594 sprintf (hdr.size, "%ld", (long) (4 + orl_count * 4 + stridx)); 1595 sprintf (hdr.nextoff, "%d", 0); 1596 memcpy (hdr.prevoff, xcoff_ardata (abfd)->memoff, XCOFFARMAG_ELEMENT_SIZE); 1597 sprintf (hdr.date, "%d", 0); 1598 sprintf (hdr.uid, "%d", 0); 1599 sprintf (hdr.gid, "%d", 0); 1600 sprintf (hdr.mode, "%d", 0); 1601 sprintf (hdr.namlen, "%d", 0); 1602 1603 /* We need spaces, not null bytes, in the header. */ 1604 for (p = (char *) &hdr; p < (char *) &hdr + SIZEOF_AR_HDR; p++) 1605 if (*p == '\0') 1606 *p = ' '; 1607 1608 if (bfd_bwrite ((PTR) &hdr, (bfd_size_type) SIZEOF_AR_HDR, abfd) 1609 != SIZEOF_AR_HDR 1610 || (bfd_bwrite (XCOFFARFMAG, (bfd_size_type) SXCOFFARFMAG, abfd) 1611 != SXCOFFARFMAG)) 1612 return FALSE; 1613 1614 H_PUT_32 (abfd, orl_count, buf); 1615 if (bfd_bwrite (buf, (bfd_size_type) 4, abfd) != 4) 1616 return FALSE; 1617 1618 sub = abfd->archive_head; 1619 fileoff = SIZEOF_AR_FILE_HDR; 1620 i = 0; 1621 while (sub != NULL && i < orl_count) 1622 { 1623 size_t namlen; 1624 1625 while (map[i].u.abfd == sub) 1626 { 1627 H_PUT_32 (abfd, fileoff, buf); 1628 if (bfd_bwrite (buf, (bfd_size_type) 4, abfd) != 4) 1629 return FALSE; 1630 ++i; 1631 } 1632 namlen = strlen (normalize_filename (sub)); 1633 namlen = (namlen + 1) &~ (size_t) 1; 1634 fileoff += (SIZEOF_AR_HDR 1635 + namlen 1636 + SXCOFFARFMAG 1637 + arelt_size (sub)); 1638 fileoff = (fileoff + 1) &~ 1; 1639 sub = sub->next; 1640 } 1641 1642 for (i = 0; i < orl_count; i++) 1643 { 1644 const char *name; 1645 size_t namlen; 1646 1647 name = *map[i].name; 1648 namlen = strlen (name); 1649 if (bfd_bwrite (name, (bfd_size_type) (namlen + 1), abfd) != namlen + 1) 1650 return FALSE; 1651 } 1652 1653 if ((stridx & 1) != 0) 1654 { 1655 char b; 1656 1657 b = '\0'; 1658 if (bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1) 1659 return FALSE; 1660 } 1661 1662 return TRUE; 1663 } 1664 1665 static char buff20[XCOFFARMAGBIG_ELEMENT_SIZE + 1]; 1666 #define FMT20 "%-20lld" 1667 #define FMT12 "%-12d" 1668 #define FMT12_LL "%-12lld" 1669 #define FMT12_OCTAL "%-12o" 1670 #define FMT4 "%-4d" 1671 #define PRINT20(d, v) \ 1672 sprintf (buff20, FMT20, (long long)(v)), \ 1673 memcpy ((void *) (d), buff20, 20) 1674 1675 #define PRINT12(d, v) \ 1676 sprintf (buff20, FMT12, (int)(v)), \ 1677 memcpy ((void *) (d), buff20, 12) 1678 1679 #define PRINT12_LL(d, v) \ 1680 sprintf (buff20, FMT12_LL, (long long)(v)), \ 1681 memcpy ((void *) (d), buff20, 12) 1682 1683 #define PRINT12_OCTAL(d, v) \ 1684 sprintf (buff20, FMT12_OCTAL, (unsigned int)(v)), \ 1685 memcpy ((void *) (d), buff20, 12) 1686 1687 #define PRINT4(d, v) \ 1688 sprintf (buff20, FMT4, (int)(v)), \ 1689 memcpy ((void *) (d), buff20, 4) 1690 1691 #define READ20(d, v) \ 1692 buff20[20] = 0, \ 1693 memcpy (buff20, (d), 20), \ 1694 (v) = bfd_scan_vma (buff20, (const char **) NULL, 10) 1695 1696 static bfd_boolean 1697 do_pad (abfd, number) 1698 bfd *abfd; 1699 unsigned int number; 1700 { 1701 bfd_byte b = 0; 1702 1703 /* Limit pad to <= 4096. */ 1704 if (number > 4096) 1705 return FALSE; 1706 1707 while (number--) 1708 if (bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1) 1709 return FALSE; 1710 1711 return TRUE; 1712 } 1713 1714 static bfd_boolean 1715 do_copy (out_bfd, in_bfd) 1716 bfd *out_bfd; 1717 bfd *in_bfd; 1718 { 1719 bfd_size_type remaining; 1720 bfd_byte buffer[DEFAULT_BUFFERSIZE]; 1721 1722 if (bfd_seek (in_bfd, (file_ptr) 0, SEEK_SET) != 0) 1723 return FALSE; 1724 1725 remaining = arelt_size (in_bfd); 1726 1727 while (remaining >= DEFAULT_BUFFERSIZE) 1728 { 1729 if (bfd_bread (buffer, DEFAULT_BUFFERSIZE, in_bfd) != DEFAULT_BUFFERSIZE 1730 || bfd_bwrite (buffer, DEFAULT_BUFFERSIZE, out_bfd) != DEFAULT_BUFFERSIZE) 1731 return FALSE; 1732 1733 remaining -= DEFAULT_BUFFERSIZE; 1734 } 1735 1736 if (remaining) 1737 { 1738 if (bfd_bread (buffer, remaining, in_bfd) != remaining 1739 || bfd_bwrite (buffer, remaining, out_bfd) != remaining) 1740 return FALSE; 1741 } 1742 1743 return TRUE; 1744 } 1745 1746 static bfd_boolean 1747 do_shared_object_padding (out_bfd, in_bfd, offset, ar_header_size) 1748 bfd *out_bfd; 1749 bfd *in_bfd; 1750 ufile_ptr *offset; 1751 int ar_header_size; 1752 { 1753 if (bfd_check_format (in_bfd, bfd_object) 1754 && bfd_get_flavour (in_bfd) == bfd_target_xcoff_flavour 1755 && (in_bfd->flags & DYNAMIC) != 0) 1756 { 1757 bfd_size_type pad = 0; 1758 int text_align_power; 1759 1760 text_align_power = bfd_xcoff_text_align_power (in_bfd); 1761 1762 pad = 1 << text_align_power; 1763 pad -= (*offset + ar_header_size) & (pad - 1); 1764 1765 if (! do_pad (out_bfd, pad)) 1766 return FALSE; 1767 1768 *offset += pad; 1769 } 1770 1771 return TRUE; 1772 } 1773 1774 static bfd_boolean 1775 xcoff_write_armap_big (abfd, elength, map, orl_count, stridx) 1776 bfd *abfd; 1777 unsigned int elength ATTRIBUTE_UNUSED; 1778 struct orl *map; 1779 unsigned int orl_count; 1780 int stridx; 1781 { 1782 struct xcoff_ar_file_hdr_big *fhdr; 1783 bfd_vma i, sym_32, sym_64, str_32, str_64; 1784 const bfd_arch_info_type *arch_info = NULL; 1785 bfd *current_bfd; 1786 size_t string_length; 1787 ufile_ptr nextoff, prevoff; 1788 1789 /* First, we look through the symbols and work out which are 1790 from 32-bit objects and which from 64-bit ones. */ 1791 sym_32 = sym_64 = str_32 = str_64 = 0; 1792 1793 current_bfd = abfd->archive_head; 1794 if (current_bfd != NULL) 1795 arch_info = bfd_get_arch_info (current_bfd); 1796 i = 0; 1797 while (current_bfd != NULL && i < orl_count) 1798 { 1799 while (map[i].u.abfd == current_bfd) 1800 { 1801 string_length = strlen (*map[i].name) + 1; 1802 1803 if (arch_info->bits_per_address == 64) 1804 { 1805 sym_64++; 1806 str_64 += string_length; 1807 } 1808 else 1809 { 1810 sym_32++; 1811 str_32 += string_length; 1812 } 1813 i++; 1814 } 1815 current_bfd = current_bfd->next; 1816 if (current_bfd != NULL) 1817 arch_info = bfd_get_arch_info (current_bfd); 1818 } 1819 1820 /* A quick sanity check... */ 1821 BFD_ASSERT (sym_64 + sym_32 == orl_count); 1822 /* Explicit cast to int for compiler. */ 1823 BFD_ASSERT ((int)(str_64 + str_32) == stridx); 1824 1825 fhdr = xcoff_ardata_big (abfd); 1826 1827 /* xcoff_write_archive_contents_big passes nextoff in symoff. */ 1828 READ20 (fhdr->memoff, prevoff); 1829 READ20 (fhdr->symoff, nextoff); 1830 1831 BFD_ASSERT (nextoff == bfd_tell (abfd)); 1832 1833 /* Write out the symbol table. 1834 Layout : 1835 1836 standard big archive header 1837 0x0000 ar_size [0x14] 1838 0x0014 ar_nxtmem [0x14] 1839 0x0028 ar_prvmem [0x14] 1840 0x003C ar_date [0x0C] 1841 0x0048 ar_uid [0x0C] 1842 0x0054 ar_gid [0x0C] 1843 0x0060 ar_mod [0x0C] 1844 0x006C ar_namelen[0x04] 1845 0x0070 ar_fmag [SXCOFFARFMAG] 1846 1847 Symbol table 1848 0x0072 num_syms [0x08], binary 1849 0x0078 offsets [0x08 * num_syms], binary 1850 0x0086 + 0x08 * num_syms names [??] 1851 ?? pad to even bytes. 1852 */ 1853 1854 if (sym_32) 1855 { 1856 struct xcoff_ar_hdr_big *hdr; 1857 bfd_byte *symbol_table; 1858 bfd_byte *st; 1859 file_ptr fileoff; 1860 1861 bfd_vma symbol_table_size = 1862 SIZEOF_AR_HDR_BIG 1863 + SXCOFFARFMAG 1864 + 8 1865 + 8 * sym_32 1866 + str_32 + (str_32 & 1); 1867 1868 symbol_table = NULL; 1869 symbol_table = (bfd_byte *) bfd_zmalloc (symbol_table_size); 1870 if (symbol_table == NULL) 1871 return FALSE; 1872 1873 hdr = (struct xcoff_ar_hdr_big *) symbol_table; 1874 1875 PRINT20 (hdr->size, 8 + 8 * sym_32 + str_32 + (str_32 & 1)); 1876 1877 if (sym_64) 1878 PRINT20 (hdr->nextoff, nextoff + symbol_table_size); 1879 else 1880 PRINT20 (hdr->nextoff, 0); 1881 1882 PRINT20 (hdr->prevoff, prevoff); 1883 PRINT12 (hdr->date, 0); 1884 PRINT12 (hdr->uid, 0); 1885 PRINT12 (hdr->gid, 0); 1886 PRINT12 (hdr->mode, 0); 1887 PRINT4 (hdr->namlen, 0) ; 1888 1889 st = symbol_table + SIZEOF_AR_HDR_BIG; 1890 memcpy (st, XCOFFARFMAG, SXCOFFARFMAG); 1891 st += SXCOFFARFMAG; 1892 1893 bfd_h_put_64 (abfd, sym_32, st); 1894 st += 8; 1895 1896 /* loop over the 32 bit offsets */ 1897 current_bfd = abfd->archive_head; 1898 if (current_bfd != NULL) 1899 arch_info = bfd_get_arch_info (current_bfd); 1900 fileoff = SIZEOF_AR_FILE_HDR_BIG; 1901 i = 0; 1902 while (current_bfd != NULL && i < orl_count) 1903 { 1904 while (map[i].u.abfd == current_bfd) 1905 { 1906 if (arch_info->bits_per_address == 32) 1907 { 1908 bfd_h_put_64 (abfd, fileoff, st); 1909 st += 8; 1910 } 1911 i++; 1912 } 1913 string_length = strlen (normalize_filename (current_bfd)); 1914 string_length += string_length & 1; 1915 fileoff += (SIZEOF_AR_HDR_BIG 1916 + string_length 1917 + SXCOFFARFMAG 1918 + arelt_size (current_bfd)); 1919 fileoff += fileoff & 1; 1920 current_bfd = current_bfd->next; 1921 if (current_bfd != NULL) 1922 arch_info = bfd_get_arch_info (current_bfd); 1923 } 1924 1925 /* loop over the 32 bit symbol names */ 1926 current_bfd = abfd->archive_head; 1927 if (current_bfd != NULL) 1928 arch_info = bfd_get_arch_info (current_bfd); 1929 i = 0; 1930 while (current_bfd != NULL && i < orl_count) 1931 { 1932 while (map[i].u.abfd == current_bfd) 1933 { 1934 if (arch_info->bits_per_address == 32) 1935 { 1936 string_length = sprintf (st, "%s", *map[i].name); 1937 st += string_length + 1; 1938 } 1939 i++; 1940 } 1941 current_bfd = current_bfd->next; 1942 if (current_bfd != NULL) 1943 arch_info = bfd_get_arch_info (current_bfd); 1944 } 1945 1946 bfd_bwrite (symbol_table, symbol_table_size, abfd); 1947 1948 free (symbol_table); 1949 symbol_table = NULL; 1950 1951 prevoff = nextoff; 1952 nextoff = nextoff + symbol_table_size; 1953 } 1954 else 1955 PRINT20 (fhdr->symoff, 0); 1956 1957 if (sym_64) 1958 { 1959 struct xcoff_ar_hdr_big *hdr; 1960 bfd_byte *symbol_table; 1961 bfd_byte *st; 1962 file_ptr fileoff; 1963 1964 bfd_vma symbol_table_size = 1965 SIZEOF_AR_HDR_BIG 1966 + SXCOFFARFMAG 1967 + 8 1968 + 8 * sym_64 1969 + str_64 + (str_64 & 1); 1970 1971 symbol_table = NULL; 1972 symbol_table = (bfd_byte *) bfd_zmalloc (symbol_table_size); 1973 if (symbol_table == NULL) 1974 return FALSE; 1975 1976 hdr = (struct xcoff_ar_hdr_big *) symbol_table; 1977 1978 PRINT20 (hdr->size, 8 + 8 * sym_64 + str_64 + (str_64 & 1)); 1979 PRINT20 (hdr->nextoff, 0); 1980 PRINT20 (hdr->prevoff, prevoff); 1981 PRINT12 (hdr->date, 0); 1982 PRINT12 (hdr->uid, 0); 1983 PRINT12 (hdr->gid, 0); 1984 PRINT12 (hdr->mode, 0); 1985 PRINT4 (hdr->namlen, 0); 1986 1987 st = symbol_table + SIZEOF_AR_HDR_BIG; 1988 memcpy (st, XCOFFARFMAG, SXCOFFARFMAG); 1989 st += SXCOFFARFMAG; 1990 1991 bfd_h_put_64 (abfd, sym_64, st); 1992 st += 8; 1993 1994 /* loop over the 64 bit offsets */ 1995 current_bfd = abfd->archive_head; 1996 if (current_bfd != NULL) 1997 arch_info = bfd_get_arch_info (current_bfd); 1998 fileoff = SIZEOF_AR_FILE_HDR_BIG; 1999 i = 0; 2000 while (current_bfd != NULL && i < orl_count) 2001 { 2002 while (map[i].u.abfd == current_bfd) 2003 { 2004 if (arch_info->bits_per_address == 64) 2005 { 2006 bfd_h_put_64 (abfd, fileoff, st); 2007 st += 8; 2008 } 2009 i++; 2010 } 2011 string_length = strlen (normalize_filename (current_bfd)); 2012 string_length += string_length & 1; 2013 fileoff += (SIZEOF_AR_HDR_BIG 2014 + string_length 2015 + SXCOFFARFMAG 2016 + arelt_size (current_bfd)); 2017 fileoff += fileoff & 1; 2018 current_bfd = current_bfd->next; 2019 if (current_bfd != NULL) 2020 arch_info = bfd_get_arch_info (current_bfd); 2021 } 2022 2023 /* loop over the 64 bit symbol names */ 2024 current_bfd = abfd->archive_head; 2025 if (current_bfd != NULL) 2026 arch_info = bfd_get_arch_info (current_bfd); 2027 i = 0; 2028 while (current_bfd != NULL && i < orl_count) 2029 { 2030 while (map[i].u.abfd == current_bfd) 2031 { 2032 if (arch_info->bits_per_address == 64) 2033 { 2034 string_length = sprintf (st, "%s", *map[i].name); 2035 st += string_length + 1; 2036 } 2037 i++; 2038 } 2039 current_bfd = current_bfd->next; 2040 if (current_bfd != NULL) 2041 arch_info = bfd_get_arch_info (current_bfd); 2042 } 2043 2044 bfd_bwrite (symbol_table, symbol_table_size, abfd); 2045 2046 free (symbol_table); 2047 symbol_table = NULL; 2048 2049 PRINT20 (fhdr->symoff64, nextoff); 2050 } 2051 else 2052 PRINT20 (fhdr->symoff64, 0); 2053 2054 return TRUE; 2055 } 2056 2057 bfd_boolean 2058 _bfd_xcoff_write_armap (abfd, elength, map, orl_count, stridx) 2059 bfd *abfd; 2060 unsigned int elength ATTRIBUTE_UNUSED; 2061 struct orl *map; 2062 unsigned int orl_count; 2063 int stridx; 2064 { 2065 if (! xcoff_big_format_p (abfd)) 2066 return xcoff_write_armap_old (abfd, elength, map, orl_count, stridx); 2067 else 2068 return xcoff_write_armap_big (abfd, elength, map, orl_count, stridx); 2069 } 2070 2071 /* Write out an XCOFF archive. We always write an entire archive, 2072 rather than fussing with the freelist and so forth. */ 2073 2074 static bfd_boolean 2075 xcoff_write_archive_contents_old (abfd) 2076 bfd *abfd; 2077 { 2078 struct xcoff_ar_file_hdr fhdr; 2079 bfd_size_type count; 2080 bfd_size_type total_namlen; 2081 file_ptr *offsets; 2082 bfd_boolean makemap; 2083 bfd_boolean hasobjects; 2084 ufile_ptr prevoff, nextoff; 2085 bfd *sub; 2086 size_t i; 2087 struct xcoff_ar_hdr ahdr; 2088 bfd_size_type size; 2089 char *p; 2090 char decbuf[XCOFFARMAG_ELEMENT_SIZE + 1]; 2091 2092 memset (&fhdr, 0, sizeof fhdr); 2093 strncpy (fhdr.magic, XCOFFARMAG, SXCOFFARMAG); 2094 sprintf (fhdr.firstmemoff, "%d", SIZEOF_AR_FILE_HDR); 2095 sprintf (fhdr.freeoff, "%d", 0); 2096 2097 count = 0; 2098 total_namlen = 0; 2099 for (sub = abfd->archive_head; sub != NULL; sub = sub->next) 2100 { 2101 ++count; 2102 total_namlen += strlen (normalize_filename (sub)) + 1; 2103 } 2104 offsets = (file_ptr *) bfd_alloc (abfd, count * sizeof (file_ptr)); 2105 if (offsets == NULL) 2106 return FALSE; 2107 2108 if (bfd_seek (abfd, (file_ptr) SIZEOF_AR_FILE_HDR, SEEK_SET) != 0) 2109 return FALSE; 2110 2111 makemap = bfd_has_map (abfd); 2112 hasobjects = FALSE; 2113 prevoff = 0; 2114 nextoff = SIZEOF_AR_FILE_HDR; 2115 for (sub = abfd->archive_head, i = 0; sub != NULL; sub = sub->next, i++) 2116 { 2117 const char *name; 2118 bfd_size_type namlen; 2119 struct xcoff_ar_hdr *ahdrp; 2120 bfd_size_type remaining; 2121 2122 if (makemap && ! hasobjects) 2123 { 2124 if (bfd_check_format (sub, bfd_object)) 2125 hasobjects = TRUE; 2126 } 2127 2128 name = normalize_filename (sub); 2129 namlen = strlen (name); 2130 2131 if (sub->arelt_data != NULL) 2132 ahdrp = arch_xhdr (sub); 2133 else 2134 ahdrp = NULL; 2135 2136 if (ahdrp == NULL) 2137 { 2138 struct stat s; 2139 2140 memset (&ahdr, 0, sizeof ahdr); 2141 ahdrp = &ahdr; 2142 if (stat (bfd_get_filename (sub), &s) != 0) 2143 { 2144 bfd_set_error (bfd_error_system_call); 2145 return FALSE; 2146 } 2147 2148 sprintf (ahdrp->size, "%ld", (long) s.st_size); 2149 sprintf (ahdrp->date, "%lld", (long long) s.st_mtime); 2150 sprintf (ahdrp->uid, "%ld", (long) s.st_uid); 2151 sprintf (ahdrp->gid, "%ld", (long) s.st_gid); 2152 sprintf (ahdrp->mode, "%o", (unsigned int) s.st_mode); 2153 2154 if (sub->arelt_data == NULL) 2155 { 2156 size = sizeof (struct areltdata); 2157 sub->arelt_data = bfd_alloc (sub, size); 2158 if (sub->arelt_data == NULL) 2159 return FALSE; 2160 } 2161 2162 arch_eltdata (sub)->parsed_size = s.st_size; 2163 } 2164 2165 sprintf (ahdrp->prevoff, "%ld", (long) prevoff); 2166 sprintf (ahdrp->namlen, "%ld", (long) namlen); 2167 2168 /* If the length of the name is odd, we write out the null byte 2169 after the name as well. */ 2170 namlen = (namlen + 1) &~ (bfd_size_type) 1; 2171 2172 remaining = arelt_size (sub); 2173 size = (SIZEOF_AR_HDR 2174 + namlen 2175 + SXCOFFARFMAG 2176 + remaining); 2177 2178 BFD_ASSERT (nextoff == bfd_tell (abfd)); 2179 2180 offsets[i] = nextoff; 2181 2182 prevoff = nextoff; 2183 nextoff += size + (size & 1); 2184 2185 sprintf (ahdrp->nextoff, "%ld", (long) nextoff); 2186 2187 /* We need spaces, not null bytes, in the header. */ 2188 for (p = (char *) ahdrp; p < (char *) ahdrp + SIZEOF_AR_HDR; p++) 2189 if (*p == '\0') 2190 *p = ' '; 2191 2192 if ((bfd_bwrite ((PTR) ahdrp, (bfd_size_type) SIZEOF_AR_HDR, abfd) 2193 != SIZEOF_AR_HDR) 2194 || bfd_bwrite ((PTR) name, namlen, abfd) != namlen 2195 || bfd_bwrite ((PTR) XCOFFARFMAG, (bfd_size_type) SXCOFFARFMAG, 2196 abfd) != SXCOFFARFMAG) 2197 return FALSE; 2198 2199 if (bfd_seek (sub, (file_ptr) 0, SEEK_SET) != 0) 2200 return FALSE; 2201 2202 if (! do_copy (abfd, sub)) 2203 return FALSE; 2204 2205 if (! do_pad (abfd, size & 1)) 2206 return FALSE; 2207 } 2208 2209 sprintf (fhdr.lastmemoff, "%ld", (long) prevoff); 2210 2211 /* Write out the member table. */ 2212 2213 BFD_ASSERT (nextoff == bfd_tell (abfd)); 2214 sprintf (fhdr.memoff, "%ld", (long) nextoff); 2215 2216 memset (&ahdr, 0, sizeof ahdr); 2217 sprintf (ahdr.size, "%ld", (long) (XCOFFARMAG_ELEMENT_SIZE 2218 + count * XCOFFARMAG_ELEMENT_SIZE 2219 + total_namlen)); 2220 sprintf (ahdr.prevoff, "%ld", (long) prevoff); 2221 sprintf (ahdr.date, "%d", 0); 2222 sprintf (ahdr.uid, "%d", 0); 2223 sprintf (ahdr.gid, "%d", 0); 2224 sprintf (ahdr.mode, "%d", 0); 2225 sprintf (ahdr.namlen, "%d", 0); 2226 2227 size = (SIZEOF_AR_HDR 2228 + XCOFFARMAG_ELEMENT_SIZE 2229 + count * XCOFFARMAG_ELEMENT_SIZE 2230 + total_namlen 2231 + SXCOFFARFMAG); 2232 2233 prevoff = nextoff; 2234 nextoff += size + (size & 1); 2235 2236 if (makemap && hasobjects) 2237 sprintf (ahdr.nextoff, "%ld", (long) nextoff); 2238 else 2239 sprintf (ahdr.nextoff, "%d", 0); 2240 2241 /* We need spaces, not null bytes, in the header. */ 2242 for (p = (char *) &ahdr; p < (char *) &ahdr + SIZEOF_AR_HDR; p++) 2243 if (*p == '\0') 2244 *p = ' '; 2245 2246 if ((bfd_bwrite ((PTR) &ahdr, (bfd_size_type) SIZEOF_AR_HDR, abfd) 2247 != SIZEOF_AR_HDR) 2248 || (bfd_bwrite ((PTR) XCOFFARFMAG, (bfd_size_type) SXCOFFARFMAG, abfd) 2249 != SXCOFFARFMAG)) 2250 return FALSE; 2251 2252 sprintf (decbuf, "%-12ld", (long) count); 2253 if (bfd_bwrite ((PTR) decbuf, (bfd_size_type) XCOFFARMAG_ELEMENT_SIZE, abfd) 2254 != XCOFFARMAG_ELEMENT_SIZE) 2255 return FALSE; 2256 for (i = 0; i < (size_t) count; i++) 2257 { 2258 sprintf (decbuf, "%-12ld", (long) offsets[i]); 2259 if (bfd_bwrite ((PTR) decbuf, (bfd_size_type) XCOFFARMAG_ELEMENT_SIZE, 2260 abfd) != XCOFFARMAG_ELEMENT_SIZE) 2261 return FALSE; 2262 } 2263 for (sub = abfd->archive_head; sub != NULL; sub = sub->next) 2264 { 2265 const char *name; 2266 bfd_size_type namlen; 2267 2268 name = normalize_filename (sub); 2269 namlen = strlen (name); 2270 if (bfd_bwrite ((PTR) name, namlen + 1, abfd) != namlen + 1) 2271 return FALSE; 2272 } 2273 2274 if (! do_pad (abfd, size & 1)) 2275 return FALSE; 2276 2277 /* Write out the armap, if appropriate. */ 2278 if (! makemap || ! hasobjects) 2279 sprintf (fhdr.symoff, "%d", 0); 2280 else 2281 { 2282 BFD_ASSERT (nextoff == bfd_tell (abfd)); 2283 sprintf (fhdr.symoff, "%ld", (long) nextoff); 2284 bfd_ardata (abfd)->tdata = (PTR) &fhdr; 2285 if (! _bfd_compute_and_write_armap (abfd, 0)) 2286 return FALSE; 2287 } 2288 2289 /* Write out the archive file header. */ 2290 2291 /* We need spaces, not null bytes, in the header. */ 2292 for (p = (char *) &fhdr; p < (char *) &fhdr + SIZEOF_AR_FILE_HDR; p++) 2293 if (*p == '\0') 2294 *p = ' '; 2295 2296 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0 2297 || (bfd_bwrite ((PTR) &fhdr, (bfd_size_type) SIZEOF_AR_FILE_HDR, abfd) 2298 != SIZEOF_AR_FILE_HDR)) 2299 return FALSE; 2300 2301 return TRUE; 2302 } 2303 2304 static bfd_boolean 2305 xcoff_write_archive_contents_big (abfd) 2306 bfd *abfd; 2307 { 2308 struct xcoff_ar_file_hdr_big fhdr; 2309 bfd_size_type count; 2310 bfd_size_type total_namlen; 2311 file_ptr *offsets; 2312 bfd_boolean makemap; 2313 bfd_boolean hasobjects; 2314 ufile_ptr prevoff, nextoff; 2315 bfd *current_bfd; 2316 size_t i; 2317 struct xcoff_ar_hdr_big *hdr, ahdr; 2318 bfd_size_type size; 2319 bfd_byte *member_table, *mt; 2320 bfd_vma member_table_size; 2321 2322 memset (&fhdr, 0, SIZEOF_AR_FILE_HDR_BIG); 2323 memcpy (fhdr.magic, XCOFFARMAGBIG, SXCOFFARMAG); 2324 2325 if (bfd_seek (abfd, (file_ptr) SIZEOF_AR_FILE_HDR_BIG, SEEK_SET) != 0) 2326 return FALSE; 2327 2328 /* Calculate count and total_namlen. */ 2329 makemap = bfd_has_map (abfd); 2330 hasobjects = FALSE; 2331 for (current_bfd = abfd->archive_head, count = 0, total_namlen = 0; 2332 current_bfd != NULL; 2333 current_bfd = current_bfd->next, count++) 2334 { 2335 total_namlen += strlen (normalize_filename (current_bfd)) + 1; 2336 2337 if (makemap 2338 && ! hasobjects 2339 && bfd_check_format (current_bfd, bfd_object)) 2340 hasobjects = TRUE; 2341 } 2342 2343 offsets = NULL; 2344 if (count) 2345 { 2346 offsets = (file_ptr *) bfd_malloc (count * sizeof (file_ptr)); 2347 if (offsets == NULL) 2348 return FALSE; 2349 } 2350 2351 prevoff = 0; 2352 nextoff = SIZEOF_AR_FILE_HDR_BIG; 2353 for (current_bfd = abfd->archive_head, i = 0; 2354 current_bfd != NULL; 2355 current_bfd = current_bfd->next, i++) 2356 { 2357 const char *name; 2358 bfd_size_type namlen; 2359 struct xcoff_ar_hdr_big *ahdrp; 2360 bfd_size_type remaining; 2361 2362 name = normalize_filename (current_bfd); 2363 namlen = strlen (name); 2364 2365 if (current_bfd->arelt_data != NULL) 2366 ahdrp = arch_xhdr_big (current_bfd); 2367 else 2368 ahdrp = NULL; 2369 2370 if (ahdrp == NULL) 2371 { 2372 struct stat s; 2373 2374 ahdrp = &ahdr; 2375 /* XXX This should actually be a call to stat64 (at least on 2376 32-bit machines). 2377 XXX This call will fail if the original object is not found. */ 2378 if (stat (bfd_get_filename (current_bfd), &s) != 0) 2379 { 2380 bfd_set_error (bfd_error_system_call); 2381 return FALSE; 2382 } 2383 2384 PRINT20 (ahdrp->size, s.st_size); 2385 PRINT12_LL (ahdrp->date, s.st_mtime); 2386 PRINT12 (ahdrp->uid, s.st_uid); 2387 PRINT12 (ahdrp->gid, s.st_gid); 2388 PRINT12_OCTAL (ahdrp->mode, s.st_mode); 2389 2390 if (current_bfd->arelt_data == NULL) 2391 { 2392 size = sizeof (struct areltdata); 2393 current_bfd->arelt_data = bfd_alloc (current_bfd, size); 2394 if (current_bfd->arelt_data == NULL) 2395 return FALSE; 2396 } 2397 2398 arch_eltdata (current_bfd)->parsed_size = s.st_size; 2399 } 2400 2401 PRINT20 (ahdrp->prevoff, prevoff); 2402 PRINT4 (ahdrp->namlen, namlen); 2403 2404 /* If the length of the name is odd, we write out the null byte 2405 after the name as well. */ 2406 namlen = (namlen + 1) &~ (bfd_size_type) 1; 2407 2408 remaining = arelt_size (current_bfd); 2409 size = (SIZEOF_AR_HDR_BIG 2410 + namlen 2411 + SXCOFFARFMAG 2412 + remaining); 2413 2414 BFD_ASSERT (nextoff == bfd_tell (abfd)); 2415 2416 /* Check for xcoff shared objects. 2417 Their text section needs to be aligned wrt the archive file position. 2418 This requires extra padding before the archive header. */ 2419 if (! do_shared_object_padding (abfd, current_bfd, & nextoff, 2420 SIZEOF_AR_HDR_BIG + namlen 2421 + SXCOFFARFMAG)) 2422 return FALSE; 2423 2424 offsets[i] = nextoff; 2425 2426 prevoff = nextoff; 2427 nextoff += size + (size & 1); 2428 2429 PRINT20 (ahdrp->nextoff, nextoff); 2430 2431 if ((bfd_bwrite ((PTR) ahdrp, (bfd_size_type) SIZEOF_AR_HDR_BIG, abfd) 2432 != SIZEOF_AR_HDR_BIG) 2433 || bfd_bwrite ((PTR) name, (bfd_size_type) namlen, abfd) != namlen 2434 || (bfd_bwrite ((PTR) XCOFFARFMAG, (bfd_size_type) SXCOFFARFMAG, 2435 abfd) != SXCOFFARFMAG)) 2436 return FALSE; 2437 2438 if (bfd_seek (current_bfd, (file_ptr) 0, SEEK_SET) != 0) 2439 return FALSE; 2440 2441 if (! do_copy (abfd, current_bfd)) 2442 return FALSE; 2443 2444 if (! do_pad (abfd, size & 1)) 2445 return FALSE; 2446 } 2447 2448 if (count) 2449 { 2450 PRINT20 (fhdr.firstmemoff, offsets[0]); 2451 PRINT20 (fhdr.lastmemoff, prevoff); 2452 } 2453 2454 /* Write out the member table. 2455 Layout : 2456 2457 standard big archive header 2458 0x0000 ar_size [0x14] 2459 0x0014 ar_nxtmem [0x14] 2460 0x0028 ar_prvmem [0x14] 2461 0x003C ar_date [0x0C] 2462 0x0048 ar_uid [0x0C] 2463 0x0054 ar_gid [0x0C] 2464 0x0060 ar_mod [0x0C] 2465 0x006C ar_namelen[0x04] 2466 0x0070 ar_fmag [0x02] 2467 2468 Member table 2469 0x0072 count [0x14] 2470 0x0086 offsets [0x14 * counts] 2471 0x0086 + 0x14 * counts names [??] 2472 ?? pad to even bytes. 2473 */ 2474 2475 BFD_ASSERT (nextoff == bfd_tell (abfd)); 2476 2477 member_table_size = (SIZEOF_AR_HDR_BIG 2478 + SXCOFFARFMAG 2479 + XCOFFARMAGBIG_ELEMENT_SIZE 2480 + count * XCOFFARMAGBIG_ELEMENT_SIZE 2481 + total_namlen); 2482 2483 member_table_size += member_table_size & 1; 2484 member_table = NULL; 2485 member_table = (bfd_byte *) bfd_zmalloc (member_table_size); 2486 if (member_table == NULL) 2487 return FALSE; 2488 2489 hdr = (struct xcoff_ar_hdr_big *) member_table; 2490 2491 PRINT20 (hdr->size, (XCOFFARMAGBIG_ELEMENT_SIZE 2492 + count * XCOFFARMAGBIG_ELEMENT_SIZE 2493 + total_namlen + (total_namlen & 1))); 2494 if (makemap && hasobjects) 2495 PRINT20 (hdr->nextoff, nextoff + member_table_size); 2496 else 2497 PRINT20 (hdr->nextoff, 0); 2498 PRINT20 (hdr->prevoff, prevoff); 2499 PRINT12 (hdr->date, 0); 2500 PRINT12 (hdr->uid, 0); 2501 PRINT12 (hdr->gid, 0); 2502 PRINT12 (hdr->mode, 0); 2503 PRINT4 (hdr->namlen, 0); 2504 2505 mt = member_table + SIZEOF_AR_HDR_BIG; 2506 memcpy (mt, XCOFFARFMAG, SXCOFFARFMAG); 2507 mt += SXCOFFARFMAG; 2508 2509 PRINT20 (mt, count); 2510 mt += XCOFFARMAGBIG_ELEMENT_SIZE; 2511 for (i = 0; i < (size_t) count; i++) 2512 { 2513 PRINT20 (mt, offsets[i]); 2514 mt += XCOFFARMAGBIG_ELEMENT_SIZE; 2515 } 2516 2517 if (count) 2518 { 2519 free (offsets); 2520 offsets = NULL; 2521 } 2522 2523 for (current_bfd = abfd->archive_head; current_bfd != NULL; 2524 current_bfd = current_bfd->next) 2525 { 2526 const char *name; 2527 size_t namlen; 2528 2529 name = normalize_filename (current_bfd); 2530 namlen = sprintf (mt, "%s", name); 2531 mt += namlen + 1; 2532 } 2533 2534 if (bfd_bwrite (member_table, member_table_size, abfd) != member_table_size) 2535 return FALSE; 2536 2537 free (member_table); 2538 member_table = NULL; 2539 2540 PRINT20 (fhdr.memoff, nextoff); 2541 2542 prevoff = nextoff; 2543 nextoff += member_table_size; 2544 2545 /* Write out the armap, if appropriate. */ 2546 2547 if (! makemap || ! hasobjects) 2548 PRINT20 (fhdr.symoff, 0); 2549 else 2550 { 2551 BFD_ASSERT (nextoff == bfd_tell (abfd)); 2552 2553 /* Save nextoff in fhdr.symoff so the armap routine can use it. */ 2554 PRINT20 (fhdr.symoff, nextoff); 2555 2556 bfd_ardata (abfd)->tdata = (PTR) &fhdr; 2557 if (! _bfd_compute_and_write_armap (abfd, 0)) 2558 return FALSE; 2559 } 2560 2561 /* Write out the archive file header. */ 2562 2563 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0 2564 || (bfd_bwrite ((PTR) &fhdr, (bfd_size_type) SIZEOF_AR_FILE_HDR_BIG, 2565 abfd) != SIZEOF_AR_FILE_HDR_BIG)) 2566 return FALSE; 2567 2568 return TRUE; 2569 } 2570 2571 bfd_boolean 2572 _bfd_xcoff_write_archive_contents (abfd) 2573 bfd *abfd; 2574 { 2575 if (! xcoff_big_format_p (abfd)) 2576 return xcoff_write_archive_contents_old (abfd); 2577 else 2578 return xcoff_write_archive_contents_big (abfd); 2579 } 2580 2581 /* We can't use the usual coff_sizeof_headers routine, because AIX 2582 always uses an a.out header. */ 2583 2584 int 2585 _bfd_xcoff_sizeof_headers (abfd, reloc) 2586 bfd *abfd; 2587 bfd_boolean reloc ATTRIBUTE_UNUSED; 2588 { 2589 int size; 2590 2591 size = FILHSZ; 2592 if (xcoff_data (abfd)->full_aouthdr) 2593 size += AOUTSZ; 2594 else 2595 size += SMALL_AOUTSZ; 2596 size += abfd->section_count * SCNHSZ; 2597 return size; 2598 } 2599 2600 /* Routines to swap information in the XCOFF .loader section. If we 2601 ever need to write an XCOFF loader, this stuff will need to be 2602 moved to another file shared by the linker (which XCOFF calls the 2603 ``binder'') and the loader. */ 2604 2605 /* Swap in the ldhdr structure. */ 2606 2607 static void 2608 xcoff_swap_ldhdr_in (abfd, s, dst) 2609 bfd *abfd; 2610 const PTR s; 2611 struct internal_ldhdr *dst; 2612 { 2613 const struct external_ldhdr *src = (const struct external_ldhdr *) s; 2614 2615 dst->l_version = bfd_get_32 (abfd, src->l_version); 2616 dst->l_nsyms = bfd_get_32 (abfd, src->l_nsyms); 2617 dst->l_nreloc = bfd_get_32 (abfd, src->l_nreloc); 2618 dst->l_istlen = bfd_get_32 (abfd, src->l_istlen); 2619 dst->l_nimpid = bfd_get_32 (abfd, src->l_nimpid); 2620 dst->l_impoff = bfd_get_32 (abfd, src->l_impoff); 2621 dst->l_stlen = bfd_get_32 (abfd, src->l_stlen); 2622 dst->l_stoff = bfd_get_32 (abfd, src->l_stoff); 2623 } 2624 2625 /* Swap out the ldhdr structure. */ 2626 2627 static void 2628 xcoff_swap_ldhdr_out (abfd, src, d) 2629 bfd *abfd; 2630 const struct internal_ldhdr *src; 2631 PTR d; 2632 { 2633 struct external_ldhdr *dst = (struct external_ldhdr *) d; 2634 2635 bfd_put_32 (abfd, (bfd_vma) src->l_version, dst->l_version); 2636 bfd_put_32 (abfd, src->l_nsyms, dst->l_nsyms); 2637 bfd_put_32 (abfd, src->l_nreloc, dst->l_nreloc); 2638 bfd_put_32 (abfd, src->l_istlen, dst->l_istlen); 2639 bfd_put_32 (abfd, src->l_nimpid, dst->l_nimpid); 2640 bfd_put_32 (abfd, src->l_impoff, dst->l_impoff); 2641 bfd_put_32 (abfd, src->l_stlen, dst->l_stlen); 2642 bfd_put_32 (abfd, src->l_stoff, dst->l_stoff); 2643 } 2644 2645 /* Swap in the ldsym structure. */ 2646 2647 static void 2648 xcoff_swap_ldsym_in (abfd, s, dst) 2649 bfd *abfd; 2650 const PTR s; 2651 struct internal_ldsym *dst; 2652 { 2653 const struct external_ldsym *src = (const struct external_ldsym *) s; 2654 2655 if (bfd_get_32 (abfd, src->_l._l_l._l_zeroes) != 0) { 2656 memcpy (dst->_l._l_name, src->_l._l_name, SYMNMLEN); 2657 } else { 2658 dst->_l._l_l._l_zeroes = 0; 2659 dst->_l._l_l._l_offset = bfd_get_32 (abfd, src->_l._l_l._l_offset); 2660 } 2661 dst->l_value = bfd_get_32 (abfd, src->l_value); 2662 dst->l_scnum = bfd_get_16 (abfd, src->l_scnum); 2663 dst->l_smtype = bfd_get_8 (abfd, src->l_smtype); 2664 dst->l_smclas = bfd_get_8 (abfd, src->l_smclas); 2665 dst->l_ifile = bfd_get_32 (abfd, src->l_ifile); 2666 dst->l_parm = bfd_get_32 (abfd, src->l_parm); 2667 } 2668 2669 /* Swap out the ldsym structure. */ 2670 2671 static void 2672 xcoff_swap_ldsym_out (abfd, src, d) 2673 bfd *abfd; 2674 const struct internal_ldsym *src; 2675 PTR d; 2676 { 2677 struct external_ldsym *dst = (struct external_ldsym *) d; 2678 2679 if (src->_l._l_l._l_zeroes != 0) 2680 memcpy (dst->_l._l_name, src->_l._l_name, SYMNMLEN); 2681 else 2682 { 2683 bfd_put_32 (abfd, (bfd_vma) 0, dst->_l._l_l._l_zeroes); 2684 bfd_put_32 (abfd, (bfd_vma) src->_l._l_l._l_offset, 2685 dst->_l._l_l._l_offset); 2686 } 2687 bfd_put_32 (abfd, src->l_value, dst->l_value); 2688 bfd_put_16 (abfd, (bfd_vma) src->l_scnum, dst->l_scnum); 2689 bfd_put_8 (abfd, src->l_smtype, dst->l_smtype); 2690 bfd_put_8 (abfd, src->l_smclas, dst->l_smclas); 2691 bfd_put_32 (abfd, src->l_ifile, dst->l_ifile); 2692 bfd_put_32 (abfd, src->l_parm, dst->l_parm); 2693 } 2694 2695 static void 2696 xcoff_swap_reloc_in (abfd, s, d) 2697 bfd *abfd; 2698 PTR s; 2699 PTR d; 2700 { 2701 struct external_reloc *src = (struct external_reloc *) s; 2702 struct internal_reloc *dst = (struct internal_reloc *) d; 2703 2704 memset (dst, 0, sizeof (struct internal_reloc)); 2705 2706 dst->r_vaddr = bfd_get_32 (abfd, src->r_vaddr); 2707 dst->r_symndx = bfd_get_32 (abfd, src->r_symndx); 2708 dst->r_size = bfd_get_8 (abfd, src->r_size); 2709 dst->r_type = bfd_get_8 (abfd, src->r_type); 2710 } 2711 2712 static unsigned int 2713 xcoff_swap_reloc_out (abfd, s, d) 2714 bfd *abfd; 2715 PTR s; 2716 PTR d; 2717 { 2718 struct internal_reloc *src = (struct internal_reloc *) s; 2719 struct external_reloc *dst = (struct external_reloc *) d; 2720 2721 bfd_put_32 (abfd, src->r_vaddr, dst->r_vaddr); 2722 bfd_put_32 (abfd, src->r_symndx, dst->r_symndx); 2723 bfd_put_8 (abfd, src->r_type, dst->r_type); 2724 bfd_put_8 (abfd, src->r_size, dst->r_size); 2725 2726 return bfd_coff_relsz (abfd); 2727 } 2728 2729 /* Swap in the ldrel structure. */ 2730 2731 static void 2732 xcoff_swap_ldrel_in (abfd, s, dst) 2733 bfd *abfd; 2734 const PTR s; 2735 struct internal_ldrel *dst; 2736 { 2737 const struct external_ldrel *src = (const struct external_ldrel *) s; 2738 2739 dst->l_vaddr = bfd_get_32 (abfd, src->l_vaddr); 2740 dst->l_symndx = bfd_get_32 (abfd, src->l_symndx); 2741 dst->l_rtype = bfd_get_16 (abfd, src->l_rtype); 2742 dst->l_rsecnm = bfd_get_16 (abfd, src->l_rsecnm); 2743 } 2744 2745 /* Swap out the ldrel structure. */ 2746 2747 static void 2748 xcoff_swap_ldrel_out (abfd, src, d) 2749 bfd *abfd; 2750 const struct internal_ldrel *src; 2751 PTR d; 2752 { 2753 struct external_ldrel *dst = (struct external_ldrel *) d; 2754 2755 bfd_put_32 (abfd, src->l_vaddr, dst->l_vaddr); 2756 bfd_put_32 (abfd, src->l_symndx, dst->l_symndx); 2757 bfd_put_16 (abfd, (bfd_vma) src->l_rtype, dst->l_rtype); 2758 bfd_put_16 (abfd, (bfd_vma) src->l_rsecnm, dst->l_rsecnm); 2759 } 2760 2761 2762 bfd_boolean 2763 xcoff_reloc_type_noop (input_bfd, input_section, output_bfd, rel, sym, howto, 2764 val, addend, relocation, contents) 2765 bfd *input_bfd ATTRIBUTE_UNUSED; 2766 asection *input_section ATTRIBUTE_UNUSED; 2767 bfd *output_bfd ATTRIBUTE_UNUSED; 2768 struct internal_reloc *rel ATTRIBUTE_UNUSED; 2769 struct internal_syment *sym ATTRIBUTE_UNUSED; 2770 struct reloc_howto_struct *howto ATTRIBUTE_UNUSED; 2771 bfd_vma val ATTRIBUTE_UNUSED; 2772 bfd_vma addend ATTRIBUTE_UNUSED; 2773 bfd_vma *relocation ATTRIBUTE_UNUSED; 2774 bfd_byte *contents ATTRIBUTE_UNUSED; 2775 { 2776 return TRUE; 2777 } 2778 2779 bfd_boolean 2780 xcoff_reloc_type_fail (input_bfd, input_section, output_bfd, rel, sym, howto, 2781 val, addend, relocation, contents) 2782 bfd *input_bfd; 2783 asection *input_section ATTRIBUTE_UNUSED; 2784 bfd *output_bfd ATTRIBUTE_UNUSED; 2785 struct internal_reloc *rel; 2786 struct internal_syment *sym ATTRIBUTE_UNUSED; 2787 struct reloc_howto_struct *howto ATTRIBUTE_UNUSED; 2788 bfd_vma val ATTRIBUTE_UNUSED; 2789 bfd_vma addend ATTRIBUTE_UNUSED; 2790 bfd_vma *relocation ATTRIBUTE_UNUSED; 2791 bfd_byte *contents ATTRIBUTE_UNUSED; 2792 { 2793 (*_bfd_error_handler) 2794 (_("%s: unsupported relocation type 0x%02x"), 2795 bfd_get_filename (input_bfd), (unsigned int) rel->r_type); 2796 bfd_set_error (bfd_error_bad_value); 2797 return FALSE; 2798 } 2799 2800 bfd_boolean 2801 xcoff_reloc_type_pos (input_bfd, input_section, output_bfd, rel, sym, howto, 2802 val, addend, relocation, contents) 2803 bfd *input_bfd ATTRIBUTE_UNUSED; 2804 asection *input_section ATTRIBUTE_UNUSED; 2805 bfd *output_bfd ATTRIBUTE_UNUSED; 2806 struct internal_reloc *rel ATTRIBUTE_UNUSED; 2807 struct internal_syment *sym ATTRIBUTE_UNUSED; 2808 struct reloc_howto_struct *howto ATTRIBUTE_UNUSED; 2809 bfd_vma val; 2810 bfd_vma addend; 2811 bfd_vma *relocation; 2812 bfd_byte *contents ATTRIBUTE_UNUSED; 2813 { 2814 *relocation = val + addend; 2815 return TRUE; 2816 } 2817 2818 bfd_boolean 2819 xcoff_reloc_type_neg (input_bfd, input_section, output_bfd, rel, sym, howto, 2820 val, addend, relocation, contents) 2821 bfd *input_bfd ATTRIBUTE_UNUSED; 2822 asection *input_section ATTRIBUTE_UNUSED; 2823 bfd *output_bfd ATTRIBUTE_UNUSED; 2824 struct internal_reloc *rel ATTRIBUTE_UNUSED; 2825 struct internal_syment *sym ATTRIBUTE_UNUSED; 2826 struct reloc_howto_struct *howto ATTRIBUTE_UNUSED; 2827 bfd_vma val; 2828 bfd_vma addend; 2829 bfd_vma *relocation; 2830 bfd_byte *contents ATTRIBUTE_UNUSED; 2831 { 2832 *relocation = addend - val; 2833 return TRUE; 2834 } 2835 2836 bfd_boolean 2837 xcoff_reloc_type_rel (input_bfd, input_section, output_bfd, rel, sym, howto, 2838 val, addend, relocation, contents) 2839 bfd *input_bfd ATTRIBUTE_UNUSED; 2840 asection *input_section; 2841 bfd *output_bfd ATTRIBUTE_UNUSED; 2842 struct internal_reloc *rel ATTRIBUTE_UNUSED; 2843 struct internal_syment *sym ATTRIBUTE_UNUSED; 2844 struct reloc_howto_struct *howto; 2845 bfd_vma val; 2846 bfd_vma addend; 2847 bfd_vma *relocation; 2848 bfd_byte *contents ATTRIBUTE_UNUSED; 2849 { 2850 howto->pc_relative = TRUE; 2851 2852 /* A PC relative reloc includes the section address. */ 2853 addend += input_section->vma; 2854 2855 *relocation = val + addend; 2856 *relocation -= (input_section->output_section->vma 2857 + input_section->output_offset); 2858 return TRUE; 2859 } 2860 2861 bfd_boolean 2862 xcoff_reloc_type_toc (input_bfd, input_section, output_bfd, rel, sym, howto, 2863 val, addend, relocation, contents) 2864 bfd *input_bfd; 2865 asection *input_section ATTRIBUTE_UNUSED; 2866 bfd *output_bfd; 2867 struct internal_reloc *rel; 2868 struct internal_syment *sym; 2869 struct reloc_howto_struct *howto ATTRIBUTE_UNUSED; 2870 bfd_vma val; 2871 bfd_vma addend ATTRIBUTE_UNUSED; 2872 bfd_vma *relocation; 2873 bfd_byte *contents ATTRIBUTE_UNUSED; 2874 { 2875 struct xcoff_link_hash_entry *h; 2876 2877 if (0 > rel->r_symndx) 2878 return FALSE; 2879 2880 h = obj_xcoff_sym_hashes (input_bfd)[rel->r_symndx]; 2881 2882 if (h != NULL && h->smclas != XMC_TD) 2883 { 2884 if (h->toc_section == NULL) 2885 { 2886 (*_bfd_error_handler) 2887 (_("%s: TOC reloc at 0x%x to symbol `%s' with no TOC entry"), 2888 bfd_get_filename (input_bfd), rel->r_vaddr, 2889 h->root.root.string); 2890 bfd_set_error (bfd_error_bad_value); 2891 return FALSE; 2892 } 2893 2894 BFD_ASSERT ((h->flags & XCOFF_SET_TOC) == 0); 2895 val = (h->toc_section->output_section->vma 2896 + h->toc_section->output_offset); 2897 } 2898 2899 *relocation = ((val - xcoff_data (output_bfd)->toc) 2900 - (sym->n_value - xcoff_data (input_bfd)->toc)); 2901 return TRUE; 2902 } 2903 2904 bfd_boolean 2905 xcoff_reloc_type_ba (input_bfd, input_section, output_bfd, rel, sym, howto, 2906 val, addend, relocation, contents) 2907 bfd *input_bfd ATTRIBUTE_UNUSED; 2908 asection *input_section ATTRIBUTE_UNUSED; 2909 bfd *output_bfd ATTRIBUTE_UNUSED; 2910 struct internal_reloc *rel ATTRIBUTE_UNUSED; 2911 struct internal_syment *sym ATTRIBUTE_UNUSED; 2912 struct reloc_howto_struct *howto; 2913 bfd_vma val; 2914 bfd_vma addend; 2915 bfd_vma *relocation; 2916 bfd_byte *contents ATTRIBUTE_UNUSED; 2917 { 2918 howto->src_mask &= ~3; 2919 howto->dst_mask = howto->src_mask; 2920 2921 *relocation = val + addend; 2922 2923 return TRUE; 2924 } 2925 2926 static bfd_boolean 2927 xcoff_reloc_type_br (input_bfd, input_section, output_bfd, rel, sym, howto, 2928 val, addend, relocation, contents) 2929 bfd *input_bfd; 2930 asection *input_section; 2931 bfd *output_bfd ATTRIBUTE_UNUSED; 2932 struct internal_reloc *rel; 2933 struct internal_syment *sym ATTRIBUTE_UNUSED; 2934 struct reloc_howto_struct *howto; 2935 bfd_vma val; 2936 bfd_vma addend; 2937 bfd_vma *relocation; 2938 bfd_byte *contents; 2939 { 2940 struct xcoff_link_hash_entry *h; 2941 2942 if (0 > rel->r_symndx) 2943 return FALSE; 2944 2945 h = obj_xcoff_sym_hashes (input_bfd)[rel->r_symndx]; 2946 2947 /* If we see an R_BR or R_RBR reloc which is jumping to global 2948 linkage code, and it is followed by an appropriate cror nop 2949 instruction, we replace the cror with lwz r2,20(r1). This 2950 restores the TOC after the glink code. Contrariwise, if the 2951 call is followed by a lwz r2,20(r1), but the call is not 2952 going to global linkage code, we can replace the load with a 2953 cror. */ 2954 if (NULL != h 2955 && bfd_link_hash_defined == h->root.type 2956 && (rel->r_vaddr - input_section->vma + 8 2957 <= input_section->_cooked_size)) 2958 { 2959 bfd_byte *pnext; 2960 unsigned long next; 2961 2962 pnext = contents + (rel->r_vaddr - input_section->vma) + 4; 2963 next = bfd_get_32 (input_bfd, pnext); 2964 2965 /* The _ptrgl function is magic. It is used by the AIX 2966 compiler to call a function through a pointer. */ 2967 if (h->smclas == XMC_GL || strcmp (h->root.root.string, "._ptrgl") == 0) 2968 { 2969 if (next == 0x4def7b82 /* cror 15,15,15 */ 2970 || next == 0x4ffffb82 /* cror 31,31,31 */ 2971 || next == 0x60000000) /* ori r0,r0,0 */ 2972 bfd_put_32 (input_bfd, 0x80410014, pnext); /* lwz r1,20(r1) */ 2973 2974 } 2975 else 2976 { 2977 if (next == 0x80410014) /* lwz r1,20(r1) */ 2978 bfd_put_32 (input_bfd, 0x60000000, pnext); /* ori r0,r0,0 */ 2979 } 2980 } 2981 else if (NULL != h && bfd_link_hash_undefined == h->root.type) 2982 { 2983 /* Normally, this relocation is against a defined symbol. In the 2984 case where this is a partial link and the output section offset 2985 is greater than 2^25, the linker will return an invalid error 2986 message that the relocation has been truncated. Yes it has been 2987 truncated but no it not important. For this case, disable the 2988 overflow checking. */ 2989 2990 howto->complain_on_overflow = complain_overflow_dont; 2991 } 2992 2993 howto->pc_relative = TRUE; 2994 howto->src_mask &= ~3; 2995 howto->dst_mask = howto->src_mask; 2996 2997 /* A PC relative reloc includes the section address. */ 2998 addend += input_section->vma; 2999 3000 *relocation = val + addend; 3001 *relocation -= (input_section->output_section->vma 3002 + input_section->output_offset); 3003 return TRUE; 3004 } 3005 3006 bfd_boolean 3007 xcoff_reloc_type_crel (input_bfd, input_section, output_bfd, rel, sym, howto, 3008 val, addend, relocation, contents) 3009 bfd *input_bfd ATTRIBUTE_UNUSED; 3010 asection *input_section; 3011 bfd *output_bfd ATTRIBUTE_UNUSED; 3012 struct internal_reloc *rel ATTRIBUTE_UNUSED; 3013 struct internal_syment *sym ATTRIBUTE_UNUSED; 3014 struct reloc_howto_struct *howto; 3015 bfd_vma val ATTRIBUTE_UNUSED; 3016 bfd_vma addend; 3017 bfd_vma *relocation; 3018 bfd_byte *contents ATTRIBUTE_UNUSED; 3019 { 3020 howto->pc_relative = TRUE; 3021 howto->src_mask &= ~3; 3022 howto->dst_mask = howto->src_mask; 3023 3024 /* A PC relative reloc includes the section address. */ 3025 addend += input_section->vma; 3026 3027 *relocation = val + addend; 3028 *relocation -= (input_section->output_section->vma 3029 + input_section->output_offset); 3030 return TRUE; 3031 } 3032 3033 static bfd_boolean 3034 xcoff_complain_overflow_dont_func (input_bfd, val, relocation, howto) 3035 bfd *input_bfd ATTRIBUTE_UNUSED; 3036 bfd_vma val ATTRIBUTE_UNUSED; 3037 bfd_vma relocation ATTRIBUTE_UNUSED; 3038 struct reloc_howto_struct *howto ATTRIBUTE_UNUSED; 3039 { 3040 return FALSE; 3041 } 3042 3043 static bfd_boolean 3044 xcoff_complain_overflow_bitfield_func (input_bfd, val, relocation, howto) 3045 bfd *input_bfd; 3046 bfd_vma val; 3047 bfd_vma relocation; 3048 struct reloc_howto_struct *howto; 3049 { 3050 bfd_vma addrmask, fieldmask, signmask, ss; 3051 bfd_vma a, b, sum; 3052 3053 /* Get the values to be added together. For signed and unsigned 3054 relocations, we assume that all values should be truncated to 3055 the size of an address. For bitfields, all the bits matter. 3056 See also bfd_check_overflow. */ 3057 fieldmask = N_ONES (howto->bitsize); 3058 addrmask = N_ONES (bfd_arch_bits_per_address (input_bfd)) | fieldmask; 3059 a = relocation; 3060 b = val & howto->src_mask; 3061 3062 /* Much like unsigned, except no trimming with addrmask. In 3063 addition, the sum overflows if there is a carry out of 3064 the bfd_vma, i.e., the sum is less than either input 3065 operand. */ 3066 a >>= howto->rightshift; 3067 b >>= howto->bitpos; 3068 3069 /* Bitfields are sometimes used for signed numbers; for 3070 example, a 13-bit field sometimes represents values in 3071 0..8191 and sometimes represents values in -4096..4095. 3072 If the field is signed and a is -4095 (0x1001) and b is 3073 -1 (0x1fff), the sum is -4096 (0x1000), but (0x1001 + 3074 0x1fff is 0x3000). It's not clear how to handle this 3075 everywhere, since there is not way to know how many bits 3076 are significant in the relocation, but the original code 3077 assumed that it was fully sign extended, and we will keep 3078 that assumption. */ 3079 signmask = (fieldmask >> 1) + 1; 3080 3081 if ((a & ~ fieldmask) != 0) 3082 { 3083 /* Some bits out of the field are set. This might not 3084 be a problem: if this is a signed bitfield, it is OK 3085 iff all the high bits are set, including the sign 3086 bit. We'll try setting all but the most significant 3087 bit in the original relocation value: if this is all 3088 ones, we are OK, assuming a signed bitfield. */ 3089 ss = (signmask << howto->rightshift) - 1; 3090 if ((ss | relocation) != ~ (bfd_vma) 0) 3091 return TRUE; 3092 a &= fieldmask; 3093 } 3094 3095 /* We just assume (b & ~ fieldmask) == 0. */ 3096 3097 /* We explicitly permit wrap around if this relocation 3098 covers the high bit of an address. The Linux kernel 3099 relies on it, and it is the only way to write assembler 3100 code which can run when loaded at a location 0x80000000 3101 away from the location at which it is linked. */ 3102 if (howto->bitsize + howto->rightshift 3103 == bfd_arch_bits_per_address (input_bfd)) 3104 return FALSE; 3105 3106 sum = a + b; 3107 if (sum < a || (sum & ~ fieldmask) != 0) 3108 { 3109 /* There was a carry out, or the field overflow. Test 3110 for signed operands again. Here is the overflow test 3111 is as for complain_overflow_signed. */ 3112 if (((~ (a ^ b)) & (a ^ sum)) & signmask) 3113 return TRUE; 3114 } 3115 3116 return FALSE; 3117 } 3118 3119 static bfd_boolean 3120 xcoff_complain_overflow_signed_func (input_bfd, val, relocation, howto) 3121 bfd *input_bfd; 3122 bfd_vma val; 3123 bfd_vma relocation; 3124 struct reloc_howto_struct *howto; 3125 { 3126 bfd_vma addrmask, fieldmask, signmask, ss; 3127 bfd_vma a, b, sum; 3128 3129 /* Get the values to be added together. For signed and unsigned 3130 relocations, we assume that all values should be truncated to 3131 the size of an address. For bitfields, all the bits matter. 3132 See also bfd_check_overflow. */ 3133 fieldmask = N_ONES (howto->bitsize); 3134 addrmask = N_ONES (bfd_arch_bits_per_address (input_bfd)) | fieldmask; 3135 a = relocation; 3136 b = val & howto->src_mask; 3137 3138 a = (a & addrmask) >> howto->rightshift; 3139 3140 /* If any sign bits are set, all sign bits must be set. 3141 That is, A must be a valid negative address after 3142 shifting. */ 3143 signmask = ~ (fieldmask >> 1); 3144 ss = a & signmask; 3145 if (ss != 0 && ss != ((addrmask >> howto->rightshift) & signmask)) 3146 return TRUE; 3147 3148 /* We only need this next bit of code if the sign bit of B 3149 is below the sign bit of A. This would only happen if 3150 SRC_MASK had fewer bits than BITSIZE. Note that if 3151 SRC_MASK has more bits than BITSIZE, we can get into 3152 trouble; we would need to verify that B is in range, as 3153 we do for A above. */ 3154 signmask = ((~ howto->src_mask) >> 1) & howto->src_mask; 3155 if ((b & signmask) != 0) 3156 { 3157 /* Set all the bits above the sign bit. */ 3158 b -= signmask <<= 1; 3159 } 3160 3161 b = (b & addrmask) >> howto->bitpos; 3162 3163 /* Now we can do the addition. */ 3164 sum = a + b; 3165 3166 /* See if the result has the correct sign. Bits above the 3167 sign bit are junk now; ignore them. If the sum is 3168 positive, make sure we did not have all negative inputs; 3169 if the sum is negative, make sure we did not have all 3170 positive inputs. The test below looks only at the sign 3171 bits, and it really just 3172 SIGN (A) == SIGN (B) && SIGN (A) != SIGN (SUM) 3173 */ 3174 signmask = (fieldmask >> 1) + 1; 3175 if (((~ (a ^ b)) & (a ^ sum)) & signmask) 3176 return TRUE; 3177 3178 return FALSE; 3179 } 3180 3181 static bfd_boolean 3182 xcoff_complain_overflow_unsigned_func (input_bfd, val, relocation, howto) 3183 bfd *input_bfd; 3184 bfd_vma val; 3185 bfd_vma relocation; 3186 struct reloc_howto_struct *howto; 3187 { 3188 bfd_vma addrmask, fieldmask; 3189 bfd_vma a, b, sum; 3190 3191 /* Get the values to be added together. For signed and unsigned 3192 relocations, we assume that all values should be truncated to 3193 the size of an address. For bitfields, all the bits matter. 3194 See also bfd_check_overflow. */ 3195 fieldmask = N_ONES (howto->bitsize); 3196 addrmask = N_ONES (bfd_arch_bits_per_address (input_bfd)) | fieldmask; 3197 a = relocation; 3198 b = val & howto->src_mask; 3199 3200 /* Checking for an unsigned overflow is relatively easy: 3201 trim the addresses and add, and trim the result as well. 3202 Overflow is normally indicated when the result does not 3203 fit in the field. However, we also need to consider the 3204 case when, e.g., fieldmask is 0x7fffffff or smaller, an 3205 input is 0x80000000, and bfd_vma is only 32 bits; then we 3206 will get sum == 0, but there is an overflow, since the 3207 inputs did not fit in the field. Instead of doing a 3208 separate test, we can check for this by or-ing in the 3209 operands when testing for the sum overflowing its final 3210 field. */ 3211 a = (a & addrmask) >> howto->rightshift; 3212 b = (b & addrmask) >> howto->bitpos; 3213 sum = (a + b) & addrmask; 3214 if ((a | b | sum) & ~ fieldmask) 3215 return TRUE; 3216 3217 return FALSE; 3218 } 3219 3220 /* This is the relocation function for the RS/6000/POWER/PowerPC. 3221 This is currently the only processor which uses XCOFF; I hope that 3222 will never change. 3223 3224 I took the relocation type definitions from two documents: 3225 the PowerPC AIX Version 4 Application Binary Interface, First 3226 Edition (April 1992), and the PowerOpen ABI, Big-Endian 3227 32-Bit Hardware Implementation (June 30, 1994). Differences 3228 between the documents are noted below. 3229 3230 Unsupported r_type's 3231 3232 R_RTB: 3233 R_RRTBI: 3234 R_RRTBA: 3235 3236 These relocs are defined by the PowerPC ABI to be 3237 relative branches which use half of the difference 3238 between the symbol and the program counter. I can't 3239 quite figure out when this is useful. These relocs are 3240 not defined by the PowerOpen ABI. 3241 3242 Supported r_type's 3243 3244 R_POS: 3245 Simple positive relocation. 3246 3247 R_NEG: 3248 Simple negative relocation. 3249 3250 R_REL: 3251 Simple PC relative relocation. 3252 3253 R_TOC: 3254 TOC relative relocation. The value in the instruction in 3255 the input file is the offset from the input file TOC to 3256 the desired location. We want the offset from the final 3257 TOC to the desired location. We have: 3258 isym = iTOC + in 3259 iinsn = in + o 3260 osym = oTOC + on 3261 oinsn = on + o 3262 so we must change insn by on - in. 3263 3264 R_GL: 3265 GL linkage relocation. The value of this relocation 3266 is the address of the entry in the TOC section. 3267 3268 R_TCL: 3269 Local object TOC address. I can't figure out the 3270 difference between this and case R_GL. 3271 3272 R_TRL: 3273 TOC relative relocation. A TOC relative load instruction 3274 which may be changed to a load address instruction. 3275 FIXME: We don't currently implement this optimization. 3276 3277 R_TRLA: 3278 TOC relative relocation. This is a TOC relative load 3279 address instruction which may be changed to a load 3280 instruction. FIXME: I don't know if this is the correct 3281 implementation. 3282 3283 R_BA: 3284 Absolute branch. We don't want to mess with the lower 3285 two bits of the instruction. 3286 3287 R_CAI: 3288 The PowerPC ABI defines this as an absolute call which 3289 may be modified to become a relative call. The PowerOpen 3290 ABI does not define this relocation type. 3291 3292 R_RBA: 3293 Absolute branch which may be modified to become a 3294 relative branch. 3295 3296 R_RBAC: 3297 The PowerPC ABI defines this as an absolute branch to a 3298 fixed address which may be modified to an absolute branch 3299 to a symbol. The PowerOpen ABI does not define this 3300 relocation type. 3301 3302 R_RBRC: 3303 The PowerPC ABI defines this as an absolute branch to a 3304 fixed address which may be modified to a relative branch. 3305 The PowerOpen ABI does not define this relocation type. 3306 3307 R_BR: 3308 Relative branch. We don't want to mess with the lower 3309 two bits of the instruction. 3310 3311 R_CREL: 3312 The PowerPC ABI defines this as a relative call which may 3313 be modified to become an absolute call. The PowerOpen 3314 ABI does not define this relocation type. 3315 3316 R_RBR: 3317 A relative branch which may be modified to become an 3318 absolute branch. FIXME: We don't implement this, 3319 although we should for symbols of storage mapping class 3320 XMC_XO. 3321 3322 R_RL: 3323 The PowerPC AIX ABI describes this as a load which may be 3324 changed to a load address. The PowerOpen ABI says this 3325 is the same as case R_POS. 3326 3327 R_RLA: 3328 The PowerPC AIX ABI describes this as a load address 3329 which may be changed to a load. The PowerOpen ABI says 3330 this is the same as R_POS. 3331 */ 3332 3333 bfd_boolean 3334 xcoff_ppc_relocate_section (output_bfd, info, input_bfd, 3335 input_section, contents, relocs, syms, 3336 sections) 3337 bfd *output_bfd; 3338 struct bfd_link_info *info; 3339 bfd *input_bfd; 3340 asection *input_section; 3341 bfd_byte *contents; 3342 struct internal_reloc *relocs; 3343 struct internal_syment *syms; 3344 asection **sections; 3345 { 3346 struct internal_reloc *rel; 3347 struct internal_reloc *relend; 3348 3349 rel = relocs; 3350 relend = rel + input_section->reloc_count; 3351 for (; rel < relend; rel++) 3352 { 3353 long symndx; 3354 struct xcoff_link_hash_entry *h; 3355 struct internal_syment *sym; 3356 bfd_vma addend; 3357 bfd_vma val; 3358 struct reloc_howto_struct howto; 3359 bfd_vma relocation; 3360 bfd_vma value_to_relocate; 3361 bfd_vma address; 3362 bfd_byte *location; 3363 3364 /* Relocation type R_REF is a special relocation type which is 3365 merely used to prevent garbage collection from occurring for 3366 the csect including the symbol which it references. */ 3367 if (rel->r_type == R_REF) 3368 continue; 3369 3370 /* howto */ 3371 howto.type = rel->r_type; 3372 howto.rightshift = 0; 3373 howto.bitsize = (rel->r_size & 0x1f) + 1; 3374 howto.size = howto.bitsize > 16 ? 2 : 1; 3375 howto.pc_relative = FALSE; 3376 howto.bitpos = 0; 3377 howto.complain_on_overflow = (rel->r_size & 0x80 3378 ? complain_overflow_signed 3379 : complain_overflow_bitfield); 3380 howto.special_function = NULL; 3381 howto.name = "internal"; 3382 howto.partial_inplace = TRUE; 3383 howto.src_mask = howto.dst_mask = N_ONES (howto.bitsize); 3384 howto.pcrel_offset = FALSE; 3385 3386 /* symbol */ 3387 val = 0; 3388 addend = 0; 3389 h = NULL; 3390 sym = NULL; 3391 symndx = rel->r_symndx; 3392 3393 if (-1 != symndx) 3394 { 3395 asection *sec; 3396 3397 h = obj_xcoff_sym_hashes (input_bfd)[symndx]; 3398 sym = syms + symndx; 3399 addend = - sym->n_value; 3400 3401 if (NULL == h) 3402 { 3403 sec = sections[symndx]; 3404 /* Hack to make sure we use the right TOC anchor value 3405 if this reloc is against the TOC anchor. */ 3406 if (sec->name[3] == '0' 3407 && strcmp (sec->name, ".tc0") == 0) 3408 val = xcoff_data (output_bfd)->toc; 3409 else 3410 val = (sec->output_section->vma 3411 + sec->output_offset 3412 + sym->n_value 3413 - sec->vma); 3414 } 3415 else 3416 { 3417 if (h->root.type == bfd_link_hash_defined 3418 || h->root.type == bfd_link_hash_defweak) 3419 { 3420 sec = h->root.u.def.section; 3421 val = (h->root.u.def.value 3422 + sec->output_section->vma 3423 + sec->output_offset); 3424 } 3425 else if (h->root.type == bfd_link_hash_common) 3426 { 3427 sec = h->root.u.c.p->section; 3428 val = (sec->output_section->vma 3429 + sec->output_offset); 3430 3431 } 3432 else if ((0 == (h->flags & (XCOFF_DEF_DYNAMIC | XCOFF_IMPORT))) 3433 && ! info->relocatable) 3434 { 3435 if (! ((*info->callbacks->undefined_symbol) 3436 (info, h->root.root.string, input_bfd, input_section, 3437 rel->r_vaddr - input_section->vma, TRUE))) 3438 return FALSE; 3439 3440 /* Don't try to process the reloc. It can't help, and 3441 it may generate another error. */ 3442 continue; 3443 } 3444 } 3445 } 3446 3447 if (rel->r_type >= XCOFF_MAX_CALCULATE_RELOCATION 3448 || !((*xcoff_calculate_relocation[rel->r_type]) 3449 (input_bfd, input_section, output_bfd, rel, sym, &howto, val, 3450 addend, &relocation, contents))) 3451 return FALSE; 3452 3453 /* address */ 3454 address = rel->r_vaddr - input_section->vma; 3455 location = contents + address; 3456 3457 if (address > input_section->_raw_size) 3458 abort (); 3459 3460 /* Get the value we are going to relocate. */ 3461 if (1 == howto.size) 3462 value_to_relocate = bfd_get_16 (input_bfd, location); 3463 else 3464 value_to_relocate = bfd_get_32 (input_bfd, location); 3465 3466 /* overflow. 3467 3468 FIXME: We may drop bits during the addition 3469 which we don't check for. We must either check at every single 3470 operation, which would be tedious, or we must do the computations 3471 in a type larger than bfd_vma, which would be inefficient. */ 3472 3473 if ((unsigned int) howto.complain_on_overflow 3474 >= XCOFF_MAX_COMPLAIN_OVERFLOW) 3475 abort (); 3476 3477 if (((*xcoff_complain_overflow[howto.complain_on_overflow]) 3478 (input_bfd, value_to_relocate, relocation, &howto))) 3479 { 3480 const char *name; 3481 char buf[SYMNMLEN + 1]; 3482 char reloc_type_name[10]; 3483 3484 if (symndx == -1) 3485 { 3486 name = "*ABS*"; 3487 } 3488 else if (h != NULL) 3489 { 3490 name = h->root.root.string; 3491 } 3492 else 3493 { 3494 name = _bfd_coff_internal_syment_name (input_bfd, sym, buf); 3495 if (name == NULL) 3496 name = "UNKNOWN"; 3497 } 3498 sprintf (reloc_type_name, "0x%02x", rel->r_type); 3499 3500 if (! ((*info->callbacks->reloc_overflow) 3501 (info, name, reloc_type_name, (bfd_vma) 0, input_bfd, 3502 input_section, rel->r_vaddr - input_section->vma))) 3503 return FALSE; 3504 } 3505 3506 /* Add RELOCATION to the right bits of VALUE_TO_RELOCATE. */ 3507 value_to_relocate = ((value_to_relocate & ~howto.dst_mask) 3508 | (((value_to_relocate & howto.src_mask) 3509 + relocation) & howto.dst_mask)); 3510 3511 /* Put the value back in the object file. */ 3512 if (1 == howto.size) 3513 bfd_put_16 (input_bfd, value_to_relocate, location); 3514 else 3515 bfd_put_32 (input_bfd, value_to_relocate, location); 3516 } 3517 3518 return TRUE; 3519 } 3520 3521 static bfd_boolean 3522 _bfd_xcoff_put_ldsymbol_name (abfd, ldinfo, ldsym, name) 3523 bfd *abfd ATTRIBUTE_UNUSED; 3524 struct xcoff_loader_info *ldinfo; 3525 struct internal_ldsym *ldsym; 3526 const char *name; 3527 { 3528 size_t len; 3529 len = strlen (name); 3530 3531 if (len <= SYMNMLEN) 3532 strncpy (ldsym->_l._l_name, name, SYMNMLEN); 3533 else 3534 { 3535 if (ldinfo->string_size + len + 3 > ldinfo->string_alc) 3536 { 3537 bfd_size_type newalc; 3538 bfd_byte *newstrings; 3539 3540 newalc = ldinfo->string_alc * 2; 3541 if (newalc == 0) 3542 newalc = 32; 3543 while (ldinfo->string_size + len + 3 > newalc) 3544 newalc *= 2; 3545 3546 newstrings = ((bfd_byte *) 3547 bfd_realloc ((PTR) ldinfo->strings, newalc)); 3548 if (newstrings == NULL) 3549 { 3550 ldinfo->failed = TRUE; 3551 return FALSE; 3552 } 3553 ldinfo->string_alc = newalc; 3554 ldinfo->strings = newstrings; 3555 } 3556 3557 bfd_put_16 (ldinfo->output_bfd, (bfd_vma) (len + 1), 3558 ldinfo->strings + ldinfo->string_size); 3559 strcpy (ldinfo->strings + ldinfo->string_size + 2, name); 3560 ldsym->_l._l_l._l_zeroes = 0; 3561 ldsym->_l._l_l._l_offset = ldinfo->string_size + 2; 3562 ldinfo->string_size += len + 3; 3563 } 3564 3565 return TRUE; 3566 } 3567 3568 static bfd_boolean 3569 _bfd_xcoff_put_symbol_name (bfd *abfd, struct bfd_strtab_hash *strtab, 3570 struct internal_syment *sym, 3571 const char *name) 3572 { 3573 if (strlen (name) <= SYMNMLEN) 3574 { 3575 strncpy (sym->_n._n_name, name, SYMNMLEN); 3576 } 3577 else 3578 { 3579 bfd_boolean hash; 3580 bfd_size_type indx; 3581 3582 hash = TRUE; 3583 if ((abfd->flags & BFD_TRADITIONAL_FORMAT) != 0) 3584 hash = FALSE; 3585 indx = _bfd_stringtab_add (strtab, name, hash, FALSE); 3586 if (indx == (bfd_size_type) -1) 3587 return FALSE; 3588 sym->_n._n_n._n_zeroes = 0; 3589 sym->_n._n_n._n_offset = STRING_SIZE_SIZE + indx; 3590 } 3591 return TRUE; 3592 } 3593 3594 static asection * 3595 xcoff_create_csect_from_smclas (abfd, aux, symbol_name) 3596 bfd *abfd; 3597 union internal_auxent *aux; 3598 const char *symbol_name; 3599 { 3600 asection *return_value = NULL; 3601 3602 /* .sv64 = x_smclas == 17 3603 This is an invalid csect for 32 bit apps. */ 3604 static const char *names[19] = 3605 { 3606 ".pr", ".ro", ".db", ".tc", ".ua", ".rw", ".gl", ".xo", 3607 ".sv", ".bs", ".ds", ".uc", ".ti", ".tb", NULL, ".tc0", 3608 ".td", NULL, ".sv3264" 3609 }; 3610 3611 if ((19 >= aux->x_csect.x_smclas) 3612 && (NULL != names[aux->x_csect.x_smclas])) 3613 { 3614 return_value = bfd_make_section_anyway 3615 (abfd, names[aux->x_csect.x_smclas]); 3616 } 3617 else 3618 { 3619 (*_bfd_error_handler) 3620 (_("%s: symbol `%s' has unrecognized smclas %d"), 3621 bfd_archive_filename (abfd), symbol_name, aux->x_csect.x_smclas); 3622 bfd_set_error (bfd_error_bad_value); 3623 } 3624 3625 return return_value; 3626 } 3627 3628 static bfd_boolean 3629 xcoff_is_lineno_count_overflow (abfd, value) 3630 bfd *abfd ATTRIBUTE_UNUSED; 3631 bfd_vma value; 3632 { 3633 if (0xffff <= value) 3634 return TRUE; 3635 3636 return FALSE; 3637 } 3638 3639 static bfd_boolean 3640 xcoff_is_reloc_count_overflow (abfd, value) 3641 bfd *abfd ATTRIBUTE_UNUSED; 3642 bfd_vma value; 3643 { 3644 if (0xffff <= value) 3645 return TRUE; 3646 3647 return FALSE; 3648 } 3649 3650 static bfd_vma 3651 xcoff_loader_symbol_offset (abfd, ldhdr) 3652 bfd *abfd; 3653 struct internal_ldhdr *ldhdr ATTRIBUTE_UNUSED; 3654 { 3655 return bfd_xcoff_ldhdrsz (abfd); 3656 } 3657 3658 static bfd_vma 3659 xcoff_loader_reloc_offset (abfd, ldhdr) 3660 bfd *abfd; 3661 struct internal_ldhdr *ldhdr; 3662 { 3663 return bfd_xcoff_ldhdrsz (abfd) + ldhdr->l_nsyms * bfd_xcoff_ldsymsz (abfd); 3664 } 3665 3666 static bfd_boolean 3667 xcoff_generate_rtinit (abfd, init, fini, rtld) 3668 bfd *abfd; 3669 const char *init; 3670 const char *fini; 3671 bfd_boolean rtld; 3672 { 3673 bfd_byte filehdr_ext[FILHSZ]; 3674 bfd_byte scnhdr_ext[SCNHSZ]; 3675 bfd_byte syment_ext[SYMESZ * 10]; 3676 bfd_byte reloc_ext[RELSZ * 3]; 3677 bfd_byte *data_buffer; 3678 bfd_size_type data_buffer_size; 3679 bfd_byte *string_table = NULL, *st_tmp = NULL; 3680 bfd_size_type string_table_size; 3681 bfd_vma val; 3682 size_t initsz, finisz; 3683 struct internal_filehdr filehdr; 3684 struct internal_scnhdr scnhdr; 3685 struct internal_syment syment; 3686 union internal_auxent auxent; 3687 struct internal_reloc reloc; 3688 3689 char *data_name = ".data"; 3690 char *rtinit_name = "__rtinit"; 3691 char *rtld_name = "__rtld"; 3692 3693 if (! bfd_xcoff_rtinit_size (abfd)) 3694 return FALSE; 3695 3696 initsz = (init == NULL ? 0 : 1 + strlen (init)); 3697 finisz = (fini == NULL ? 0 : 1 + strlen (fini)); 3698 3699 /* file header */ 3700 memset (filehdr_ext, 0, FILHSZ); 3701 memset (&filehdr, 0, sizeof (struct internal_filehdr)); 3702 filehdr.f_magic = bfd_xcoff_magic_number (abfd); 3703 filehdr.f_nscns = 1; 3704 filehdr.f_timdat = 0; 3705 filehdr.f_nsyms = 0; /* at least 6, no more than 10 */ 3706 filehdr.f_symptr = 0; /* set below */ 3707 filehdr.f_opthdr = 0; 3708 filehdr.f_flags = 0; 3709 3710 /* section header */ 3711 memset (scnhdr_ext, 0, SCNHSZ); 3712 memset (&scnhdr, 0, sizeof (struct internal_scnhdr)); 3713 memcpy (scnhdr.s_name, data_name, strlen (data_name)); 3714 scnhdr.s_paddr = 0; 3715 scnhdr.s_vaddr = 0; 3716 scnhdr.s_size = 0; /* set below */ 3717 scnhdr.s_scnptr = FILHSZ + SCNHSZ; 3718 scnhdr.s_relptr = 0; /* set below */ 3719 scnhdr.s_lnnoptr = 0; 3720 scnhdr.s_nreloc = 0; /* either 1 or 2 */ 3721 scnhdr.s_nlnno = 0; 3722 scnhdr.s_flags = STYP_DATA; 3723 3724 /* .data 3725 0x0000 0x00000000 : rtl 3726 0x0004 0x00000010 : offset to init, or 0 3727 0x0008 0x00000028 : offset to fini, or 0 3728 0x000C 0x0000000C : size of descriptor 3729 0x0010 0x00000000 : init, needs a reloc 3730 0x0014 0x00000040 : offset to init name 3731 0x0018 0x00000000 : flags, padded to a word 3732 0x001C 0x00000000 : empty init 3733 0x0020 0x00000000 : 3734 0x0024 0x00000000 : 3735 0x0028 0x00000000 : fini, needs a reloc 3736 0x002C 0x00000??? : offset to fini name 3737 0x0030 0x00000000 : flags, padded to a word 3738 0x0034 0x00000000 : empty fini 3739 0x0038 0x00000000 : 3740 0x003C 0x00000000 : 3741 0x0040 init name 3742 0x0040 + initsz fini name */ 3743 3744 data_buffer_size = 0x0040 + initsz + finisz; 3745 data_buffer_size = (data_buffer_size + 7) &~ (bfd_size_type) 7; 3746 data_buffer = NULL; 3747 data_buffer = (bfd_byte *) bfd_zmalloc (data_buffer_size); 3748 if (data_buffer == NULL) 3749 return FALSE; 3750 3751 if (initsz) 3752 { 3753 val = 0x10; 3754 bfd_h_put_32 (abfd, val, &data_buffer[0x04]); 3755 val = 0x40; 3756 bfd_h_put_32 (abfd, val, &data_buffer[0x14]); 3757 memcpy (&data_buffer[val], init, initsz); 3758 } 3759 3760 if (finisz) 3761 { 3762 val = 0x28; 3763 bfd_h_put_32 (abfd, val, &data_buffer[0x08]); 3764 val = 0x40 + initsz; 3765 bfd_h_put_32 (abfd, val, &data_buffer[0x2C]); 3766 memcpy (&data_buffer[val], fini, finisz); 3767 } 3768 3769 val = 0x0C; 3770 bfd_h_put_32 (abfd, val, &data_buffer[0x0C]); 3771 3772 scnhdr.s_size = data_buffer_size; 3773 3774 /* string table */ 3775 string_table_size = 0; 3776 if (initsz > 9) 3777 string_table_size += initsz; 3778 if (finisz > 9) 3779 string_table_size += finisz; 3780 if (string_table_size) 3781 { 3782 string_table_size += 4; 3783 string_table = (bfd_byte *) bfd_zmalloc (string_table_size); 3784 if (string_table == NULL) 3785 return FALSE; 3786 3787 val = string_table_size; 3788 bfd_h_put_32 (abfd, val, &string_table[0]); 3789 st_tmp = string_table + 4; 3790 } 3791 3792 /* symbols 3793 0. .data csect 3794 2. __rtinit 3795 4. init function 3796 6. fini function 3797 8. __rtld */ 3798 memset (syment_ext, 0, 10 * SYMESZ); 3799 memset (reloc_ext, 0, 3 * RELSZ); 3800 3801 /* .data csect */ 3802 memset (&syment, 0, sizeof (struct internal_syment)); 3803 memset (&auxent, 0, sizeof (union internal_auxent)); 3804 memcpy (syment._n._n_name, data_name, strlen (data_name)); 3805 syment.n_scnum = 1; 3806 syment.n_sclass = C_HIDEXT; 3807 syment.n_numaux = 1; 3808 auxent.x_csect.x_scnlen.l = data_buffer_size; 3809 auxent.x_csect.x_smtyp = 3 << 3 | XTY_SD; 3810 auxent.x_csect.x_smclas = XMC_RW; 3811 bfd_coff_swap_sym_out (abfd, &syment, 3812 &syment_ext[filehdr.f_nsyms * SYMESZ]); 3813 bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0, 3814 syment.n_numaux, 3815 &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]); 3816 filehdr.f_nsyms += 2; 3817 3818 /* __rtinit */ 3819 memset (&syment, 0, sizeof (struct internal_syment)); 3820 memset (&auxent, 0, sizeof (union internal_auxent)); 3821 memcpy (syment._n._n_name, rtinit_name, strlen (rtinit_name)); 3822 syment.n_scnum = 1; 3823 syment.n_sclass = C_EXT; 3824 syment.n_numaux = 1; 3825 auxent.x_csect.x_smtyp = XTY_LD; 3826 auxent.x_csect.x_smclas = XMC_RW; 3827 bfd_coff_swap_sym_out (abfd, &syment, 3828 &syment_ext[filehdr.f_nsyms * SYMESZ]); 3829 bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0, 3830 syment.n_numaux, 3831 &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]); 3832 filehdr.f_nsyms += 2; 3833 3834 /* init */ 3835 if (initsz) 3836 { 3837 memset (&syment, 0, sizeof (struct internal_syment)); 3838 memset (&auxent, 0, sizeof (union internal_auxent)); 3839 3840 if (initsz > 9) 3841 { 3842 syment._n._n_n._n_offset = st_tmp - string_table; 3843 memcpy (st_tmp, init, initsz); 3844 st_tmp += initsz; 3845 } 3846 else 3847 memcpy (syment._n._n_name, init, initsz - 1); 3848 3849 syment.n_sclass = C_EXT; 3850 syment.n_numaux = 1; 3851 bfd_coff_swap_sym_out (abfd, &syment, 3852 &syment_ext[filehdr.f_nsyms * SYMESZ]); 3853 bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0, 3854 syment.n_numaux, 3855 &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]); 3856 3857 /* reloc */ 3858 memset (&reloc, 0, sizeof (struct internal_reloc)); 3859 reloc.r_vaddr = 0x0010; 3860 reloc.r_symndx = filehdr.f_nsyms; 3861 reloc.r_type = R_POS; 3862 reloc.r_size = 31; 3863 bfd_coff_swap_reloc_out (abfd, &reloc, &reloc_ext[0]); 3864 3865 filehdr.f_nsyms += 2; 3866 scnhdr.s_nreloc += 1; 3867 } 3868 3869 /* fini */ 3870 if (finisz) 3871 { 3872 memset (&syment, 0, sizeof (struct internal_syment)); 3873 memset (&auxent, 0, sizeof (union internal_auxent)); 3874 3875 if (finisz > 9) 3876 { 3877 syment._n._n_n._n_offset = st_tmp - string_table; 3878 memcpy (st_tmp, fini, finisz); 3879 st_tmp += finisz; 3880 } 3881 else 3882 memcpy (syment._n._n_name, fini, finisz - 1); 3883 3884 syment.n_sclass = C_EXT; 3885 syment.n_numaux = 1; 3886 bfd_coff_swap_sym_out (abfd, &syment, 3887 &syment_ext[filehdr.f_nsyms * SYMESZ]); 3888 bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0, 3889 syment.n_numaux, 3890 &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]); 3891 3892 /* reloc */ 3893 memset (&reloc, 0, sizeof (struct internal_reloc)); 3894 reloc.r_vaddr = 0x0028; 3895 reloc.r_symndx = filehdr.f_nsyms; 3896 reloc.r_type = R_POS; 3897 reloc.r_size = 31; 3898 bfd_coff_swap_reloc_out (abfd, &reloc, 3899 &reloc_ext[scnhdr.s_nreloc * RELSZ]); 3900 3901 filehdr.f_nsyms += 2; 3902 scnhdr.s_nreloc += 1; 3903 } 3904 3905 if (rtld) 3906 { 3907 memset (&syment, 0, sizeof (struct internal_syment)); 3908 memset (&auxent, 0, sizeof (union internal_auxent)); 3909 memcpy (syment._n._n_name, rtld_name, strlen (rtld_name)); 3910 syment.n_sclass = C_EXT; 3911 syment.n_numaux = 1; 3912 bfd_coff_swap_sym_out (abfd, &syment, 3913 &syment_ext[filehdr.f_nsyms * SYMESZ]); 3914 bfd_coff_swap_aux_out (abfd, &auxent, syment.n_type, syment.n_sclass, 0, 3915 syment.n_numaux, 3916 &syment_ext[(filehdr.f_nsyms + 1) * SYMESZ]); 3917 3918 /* reloc */ 3919 memset (&reloc, 0, sizeof (struct internal_reloc)); 3920 reloc.r_vaddr = 0x0000; 3921 reloc.r_symndx = filehdr.f_nsyms; 3922 reloc.r_type = R_POS; 3923 reloc.r_size = 31; 3924 bfd_coff_swap_reloc_out (abfd, &reloc, 3925 &reloc_ext[scnhdr.s_nreloc * RELSZ]); 3926 3927 filehdr.f_nsyms += 2; 3928 scnhdr.s_nreloc += 1; 3929 } 3930 3931 scnhdr.s_relptr = scnhdr.s_scnptr + data_buffer_size; 3932 filehdr.f_symptr = scnhdr.s_relptr + scnhdr.s_nreloc * RELSZ; 3933 3934 bfd_coff_swap_filehdr_out (abfd, &filehdr, filehdr_ext); 3935 bfd_bwrite (filehdr_ext, FILHSZ, abfd); 3936 bfd_coff_swap_scnhdr_out (abfd, &scnhdr, scnhdr_ext); 3937 bfd_bwrite (scnhdr_ext, SCNHSZ, abfd); 3938 bfd_bwrite (data_buffer, data_buffer_size, abfd); 3939 bfd_bwrite (reloc_ext, scnhdr.s_nreloc * RELSZ, abfd); 3940 bfd_bwrite (syment_ext, filehdr.f_nsyms * SYMESZ, abfd); 3941 bfd_bwrite (string_table, string_table_size, abfd); 3942 3943 free (data_buffer); 3944 data_buffer = NULL; 3945 3946 return TRUE; 3947 } 3948 3949 3950 static reloc_howto_type xcoff_dynamic_reloc = 3951 HOWTO (0, /* type */ 3952 0, /* rightshift */ 3953 2, /* size (0 = byte, 1 = short, 2 = long) */ 3954 32, /* bitsize */ 3955 FALSE, /* pc_relative */ 3956 0, /* bitpos */ 3957 complain_overflow_bitfield, /* complain_on_overflow */ 3958 0, /* special_function */ 3959 "R_POS", /* name */ 3960 TRUE, /* partial_inplace */ 3961 0xffffffff, /* src_mask */ 3962 0xffffffff, /* dst_mask */ 3963 FALSE); /* pcrel_offset */ 3964 3965 /* glink 3966 3967 The first word of global linkage code must be modified by filling in 3968 the correct TOC offset. */ 3969 3970 static unsigned long xcoff_glink_code[9] = 3971 { 3972 0x81820000, /* lwz r12,0(r2) */ 3973 0x90410014, /* stw r2,20(r1) */ 3974 0x800c0000, /* lwz r0,0(r12) */ 3975 0x804c0004, /* lwz r2,4(r12) */ 3976 0x7c0903a6, /* mtctr r0 */ 3977 0x4e800420, /* bctr */ 3978 0x00000000, /* start of traceback table */ 3979 0x000c8000, /* traceback table */ 3980 0x00000000, /* traceback table */ 3981 }; 3982 3983 3984 static const struct xcoff_backend_data_rec bfd_xcoff_backend_data = 3985 { 3986 { /* COFF backend, defined in libcoff.h. */ 3987 _bfd_xcoff_swap_aux_in, 3988 _bfd_xcoff_swap_sym_in, 3989 coff_swap_lineno_in, 3990 _bfd_xcoff_swap_aux_out, 3991 _bfd_xcoff_swap_sym_out, 3992 coff_swap_lineno_out, 3993 xcoff_swap_reloc_out, 3994 coff_swap_filehdr_out, 3995 coff_swap_aouthdr_out, 3996 coff_swap_scnhdr_out, 3997 FILHSZ, 3998 AOUTSZ, 3999 SCNHSZ, 4000 SYMESZ, 4001 AUXESZ, 4002 RELSZ, 4003 LINESZ, 4004 FILNMLEN, 4005 TRUE, /* _bfd_coff_long_filenames */ 4006 FALSE, /* _bfd_coff_long_section_names */ 4007 3, /* _bfd_coff_default_section_alignment_power */ 4008 FALSE, /* _bfd_coff_force_symnames_in_strings */ 4009 2, /* _bfd_coff_debug_string_prefix_length */ 4010 coff_swap_filehdr_in, 4011 coff_swap_aouthdr_in, 4012 coff_swap_scnhdr_in, 4013 xcoff_swap_reloc_in, 4014 coff_bad_format_hook, 4015 coff_set_arch_mach_hook, 4016 coff_mkobject_hook, 4017 styp_to_sec_flags, 4018 coff_set_alignment_hook, 4019 coff_slurp_symbol_table, 4020 symname_in_debug_hook, 4021 coff_pointerize_aux_hook, 4022 coff_print_aux, 4023 dummy_reloc16_extra_cases, 4024 dummy_reloc16_estimate, 4025 NULL, /* bfd_coff_sym_is_global */ 4026 coff_compute_section_file_positions, 4027 NULL, /* _bfd_coff_start_final_link */ 4028 xcoff_ppc_relocate_section, 4029 coff_rtype_to_howto, 4030 NULL, /* _bfd_coff_adjust_symndx */ 4031 _bfd_generic_link_add_one_symbol, 4032 coff_link_output_has_begun, 4033 coff_final_link_postscript 4034 }, 4035 4036 0x01DF, /* magic number */ 4037 bfd_arch_rs6000, 4038 bfd_mach_rs6k, 4039 4040 /* Function pointers to xcoff specific swap routines. */ 4041 xcoff_swap_ldhdr_in, 4042 xcoff_swap_ldhdr_out, 4043 xcoff_swap_ldsym_in, 4044 xcoff_swap_ldsym_out, 4045 xcoff_swap_ldrel_in, 4046 xcoff_swap_ldrel_out, 4047 4048 /* Sizes. */ 4049 LDHDRSZ, 4050 LDSYMSZ, 4051 LDRELSZ, 4052 12, /* _xcoff_function_descriptor_size */ 4053 SMALL_AOUTSZ, 4054 4055 /* Versions. */ 4056 1, /* _xcoff_ldhdr_version */ 4057 4058 _bfd_xcoff_put_symbol_name, 4059 _bfd_xcoff_put_ldsymbol_name, 4060 &xcoff_dynamic_reloc, 4061 xcoff_create_csect_from_smclas, 4062 4063 /* Lineno and reloc count overflow. */ 4064 xcoff_is_lineno_count_overflow, 4065 xcoff_is_reloc_count_overflow, 4066 4067 xcoff_loader_symbol_offset, 4068 xcoff_loader_reloc_offset, 4069 4070 /* glink. */ 4071 &xcoff_glink_code[0], 4072 36, /* _xcoff_glink_size */ 4073 4074 /* rtinit */ 4075 64, /* _xcoff_rtinit_size */ 4076 xcoff_generate_rtinit, 4077 }; 4078 4079 /* The transfer vector that leads the outside world to all of the above. */ 4080 const bfd_target rs6000coff_vec = 4081 { 4082 "aixcoff-rs6000", 4083 bfd_target_xcoff_flavour, 4084 BFD_ENDIAN_BIG, /* data byte order is big */ 4085 BFD_ENDIAN_BIG, /* header byte order is big */ 4086 4087 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | DYNAMIC 4088 | HAS_SYMS | HAS_LOCALS | WP_TEXT), 4089 4090 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA, 4091 0, /* leading char */ 4092 '/', /* ar_pad_char */ 4093 15, /* ar_max_namelen */ 4094 4095 /* data */ 4096 bfd_getb64, 4097 bfd_getb_signed_64, 4098 bfd_putb64, 4099 bfd_getb32, 4100 bfd_getb_signed_32, 4101 bfd_putb32, 4102 bfd_getb16, 4103 bfd_getb_signed_16, 4104 bfd_putb16, 4105 4106 /* hdrs */ 4107 bfd_getb64, 4108 bfd_getb_signed_64, 4109 bfd_putb64, 4110 bfd_getb32, 4111 bfd_getb_signed_32, 4112 bfd_putb32, 4113 bfd_getb16, 4114 bfd_getb_signed_16, 4115 bfd_putb16, 4116 4117 { /* bfd_check_format */ 4118 _bfd_dummy_target, 4119 coff_object_p, 4120 _bfd_xcoff_archive_p, 4121 CORE_FILE_P 4122 }, 4123 4124 { /* bfd_set_format */ 4125 bfd_false, 4126 coff_mkobject, 4127 _bfd_generic_mkarchive, 4128 bfd_false 4129 }, 4130 4131 {/* bfd_write_contents */ 4132 bfd_false, 4133 coff_write_object_contents, 4134 _bfd_xcoff_write_archive_contents, 4135 bfd_false 4136 }, 4137 4138 /* Generic */ 4139 bfd_true, 4140 bfd_true, 4141 coff_new_section_hook, 4142 _bfd_generic_get_section_contents, 4143 _bfd_generic_get_section_contents_in_window, 4144 4145 /* Copy */ 4146 _bfd_xcoff_copy_private_bfd_data, 4147 ((bfd_boolean (*) (bfd *, bfd *)) bfd_true), 4148 ((bfd_boolean (*) (bfd *, asection *, bfd *, asection *)) bfd_true), 4149 ((bfd_boolean (*) (bfd *, asymbol *, bfd *, asymbol *)) bfd_true), 4150 ((bfd_boolean (*) (bfd *, flagword)) bfd_true), 4151 ((bfd_boolean (*) (bfd *, void * )) bfd_true), 4152 4153 /* Core */ 4154 coff_core_file_failing_command, 4155 coff_core_file_failing_signal, 4156 coff_core_file_matches_executable_p, 4157 4158 /* Archive */ 4159 _bfd_xcoff_slurp_armap, 4160 bfd_false, 4161 ((bfd_boolean (*) (bfd *, char **, bfd_size_type *, const char **)) bfd_false), 4162 bfd_dont_truncate_arname, 4163 _bfd_xcoff_write_armap, 4164 _bfd_xcoff_read_ar_hdr, 4165 _bfd_xcoff_openr_next_archived_file, 4166 _bfd_generic_get_elt_at_index, 4167 _bfd_xcoff_stat_arch_elt, 4168 bfd_true, 4169 4170 /* Symbols */ 4171 coff_get_symtab_upper_bound, 4172 coff_canonicalize_symtab, 4173 coff_make_empty_symbol, 4174 coff_print_symbol, 4175 coff_get_symbol_info, 4176 _bfd_xcoff_is_local_label_name, 4177 coff_get_lineno, 4178 coff_find_nearest_line, 4179 coff_bfd_make_debug_symbol, 4180 _bfd_generic_read_minisymbols, 4181 _bfd_generic_minisymbol_to_symbol, 4182 4183 /* Reloc */ 4184 coff_get_reloc_upper_bound, 4185 coff_canonicalize_reloc, 4186 _bfd_xcoff_reloc_type_lookup, 4187 4188 /* Write */ 4189 coff_set_arch_mach, 4190 coff_set_section_contents, 4191 4192 /* Link */ 4193 _bfd_xcoff_sizeof_headers, 4194 bfd_generic_get_relocated_section_contents, 4195 bfd_generic_relax_section, 4196 _bfd_xcoff_bfd_link_hash_table_create, 4197 _bfd_generic_link_hash_table_free, 4198 _bfd_xcoff_bfd_link_add_symbols, 4199 _bfd_generic_link_just_syms, 4200 _bfd_xcoff_bfd_final_link, 4201 _bfd_generic_link_split_section, 4202 bfd_generic_gc_sections, 4203 bfd_generic_merge_sections, 4204 bfd_generic_discard_group, 4205 4206 /* Dynamic */ 4207 _bfd_xcoff_get_dynamic_symtab_upper_bound, 4208 _bfd_xcoff_canonicalize_dynamic_symtab, 4209 _bfd_xcoff_get_dynamic_reloc_upper_bound, 4210 _bfd_xcoff_canonicalize_dynamic_reloc, 4211 4212 /* Opposite endian version, none exists */ 4213 NULL, 4214 4215 (void *) &bfd_xcoff_backend_data, 4216 }; 4217 4218 /* xcoff-powermac target 4219 Old target. 4220 Only difference between this target and the rs6000 target is the 4221 the default architecture and machine type used in coffcode.h 4222 4223 PowerPC Macs use the same magic numbers as RS/6000 4224 (because that's how they were bootstrapped originally), 4225 but they are always PowerPC architecture. */ 4226 static const struct xcoff_backend_data_rec bfd_pmac_xcoff_backend_data = 4227 { 4228 { /* COFF backend, defined in libcoff.h. */ 4229 _bfd_xcoff_swap_aux_in, 4230 _bfd_xcoff_swap_sym_in, 4231 coff_swap_lineno_in, 4232 _bfd_xcoff_swap_aux_out, 4233 _bfd_xcoff_swap_sym_out, 4234 coff_swap_lineno_out, 4235 xcoff_swap_reloc_out, 4236 coff_swap_filehdr_out, 4237 coff_swap_aouthdr_out, 4238 coff_swap_scnhdr_out, 4239 FILHSZ, 4240 AOUTSZ, 4241 SCNHSZ, 4242 SYMESZ, 4243 AUXESZ, 4244 RELSZ, 4245 LINESZ, 4246 FILNMLEN, 4247 TRUE, /* _bfd_coff_long_filenames */ 4248 FALSE, /* _bfd_coff_long_section_names */ 4249 3, /* _bfd_coff_default_section_alignment_power */ 4250 FALSE, /* _bfd_coff_force_symnames_in_strings */ 4251 2, /* _bfd_coff_debug_string_prefix_length */ 4252 coff_swap_filehdr_in, 4253 coff_swap_aouthdr_in, 4254 coff_swap_scnhdr_in, 4255 xcoff_swap_reloc_in, 4256 coff_bad_format_hook, 4257 coff_set_arch_mach_hook, 4258 coff_mkobject_hook, 4259 styp_to_sec_flags, 4260 coff_set_alignment_hook, 4261 coff_slurp_symbol_table, 4262 symname_in_debug_hook, 4263 coff_pointerize_aux_hook, 4264 coff_print_aux, 4265 dummy_reloc16_extra_cases, 4266 dummy_reloc16_estimate, 4267 NULL, /* bfd_coff_sym_is_global */ 4268 coff_compute_section_file_positions, 4269 NULL, /* _bfd_coff_start_final_link */ 4270 xcoff_ppc_relocate_section, 4271 coff_rtype_to_howto, 4272 NULL, /* _bfd_coff_adjust_symndx */ 4273 _bfd_generic_link_add_one_symbol, 4274 coff_link_output_has_begun, 4275 coff_final_link_postscript 4276 }, 4277 4278 0x01DF, /* magic number */ 4279 bfd_arch_powerpc, 4280 bfd_mach_ppc, 4281 4282 /* Function pointers to xcoff specific swap routines. */ 4283 xcoff_swap_ldhdr_in, 4284 xcoff_swap_ldhdr_out, 4285 xcoff_swap_ldsym_in, 4286 xcoff_swap_ldsym_out, 4287 xcoff_swap_ldrel_in, 4288 xcoff_swap_ldrel_out, 4289 4290 /* Sizes. */ 4291 LDHDRSZ, 4292 LDSYMSZ, 4293 LDRELSZ, 4294 12, /* _xcoff_function_descriptor_size */ 4295 SMALL_AOUTSZ, 4296 4297 /* Versions. */ 4298 1, /* _xcoff_ldhdr_version */ 4299 4300 _bfd_xcoff_put_symbol_name, 4301 _bfd_xcoff_put_ldsymbol_name, 4302 &xcoff_dynamic_reloc, 4303 xcoff_create_csect_from_smclas, 4304 4305 /* Lineno and reloc count overflow. */ 4306 xcoff_is_lineno_count_overflow, 4307 xcoff_is_reloc_count_overflow, 4308 4309 xcoff_loader_symbol_offset, 4310 xcoff_loader_reloc_offset, 4311 4312 /* glink. */ 4313 &xcoff_glink_code[0], 4314 36, /* _xcoff_glink_size */ 4315 4316 /* rtinit */ 4317 0, /* _xcoff_rtinit_size */ 4318 xcoff_generate_rtinit, 4319 }; 4320 4321 /* The transfer vector that leads the outside world to all of the above. */ 4322 const bfd_target pmac_xcoff_vec = 4323 { 4324 "xcoff-powermac", 4325 bfd_target_xcoff_flavour, 4326 BFD_ENDIAN_BIG, /* data byte order is big */ 4327 BFD_ENDIAN_BIG, /* header byte order is big */ 4328 4329 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | DYNAMIC 4330 | HAS_SYMS | HAS_LOCALS | WP_TEXT), 4331 4332 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA, 4333 0, /* leading char */ 4334 '/', /* ar_pad_char */ 4335 15, /* ar_max_namelen */ 4336 4337 /* data */ 4338 bfd_getb64, 4339 bfd_getb_signed_64, 4340 bfd_putb64, 4341 bfd_getb32, 4342 bfd_getb_signed_32, 4343 bfd_putb32, 4344 bfd_getb16, 4345 bfd_getb_signed_16, 4346 bfd_putb16, 4347 4348 /* hdrs */ 4349 bfd_getb64, 4350 bfd_getb_signed_64, 4351 bfd_putb64, 4352 bfd_getb32, 4353 bfd_getb_signed_32, 4354 bfd_putb32, 4355 bfd_getb16, 4356 bfd_getb_signed_16, 4357 bfd_putb16, 4358 4359 { /* bfd_check_format */ 4360 _bfd_dummy_target, 4361 coff_object_p, 4362 _bfd_xcoff_archive_p, 4363 CORE_FILE_P 4364 }, 4365 4366 { /* bfd_set_format */ 4367 bfd_false, 4368 coff_mkobject, 4369 _bfd_generic_mkarchive, 4370 bfd_false 4371 }, 4372 4373 {/* bfd_write_contents */ 4374 bfd_false, 4375 coff_write_object_contents, 4376 _bfd_xcoff_write_archive_contents, 4377 bfd_false 4378 }, 4379 4380 /* Generic */ 4381 bfd_true, 4382 bfd_true, 4383 coff_new_section_hook, 4384 _bfd_generic_get_section_contents, 4385 _bfd_generic_get_section_contents_in_window, 4386 4387 /* Copy */ 4388 _bfd_xcoff_copy_private_bfd_data, 4389 ((bfd_boolean (*) (bfd *, bfd *)) bfd_true), 4390 ((bfd_boolean (*) (bfd *, asection *, bfd *, asection *)) bfd_true), 4391 ((bfd_boolean (*) (bfd *, asymbol *, bfd *, asymbol *)) bfd_true), 4392 ((bfd_boolean (*) (bfd *, flagword)) bfd_true), 4393 ((bfd_boolean (*) (bfd *, void * )) bfd_true), 4394 4395 /* Core */ 4396 coff_core_file_failing_command, 4397 coff_core_file_failing_signal, 4398 coff_core_file_matches_executable_p, 4399 4400 /* Archive */ 4401 _bfd_xcoff_slurp_armap, 4402 bfd_false, 4403 ((bfd_boolean (*) (bfd *, char **, bfd_size_type *, const char **)) bfd_false), 4404 bfd_dont_truncate_arname, 4405 _bfd_xcoff_write_armap, 4406 _bfd_xcoff_read_ar_hdr, 4407 _bfd_xcoff_openr_next_archived_file, 4408 _bfd_generic_get_elt_at_index, 4409 _bfd_xcoff_stat_arch_elt, 4410 bfd_true, 4411 4412 /* Symbols */ 4413 coff_get_symtab_upper_bound, 4414 coff_canonicalize_symtab, 4415 coff_make_empty_symbol, 4416 coff_print_symbol, 4417 coff_get_symbol_info, 4418 _bfd_xcoff_is_local_label_name, 4419 coff_get_lineno, 4420 coff_find_nearest_line, 4421 coff_bfd_make_debug_symbol, 4422 _bfd_generic_read_minisymbols, 4423 _bfd_generic_minisymbol_to_symbol, 4424 4425 /* Reloc */ 4426 coff_get_reloc_upper_bound, 4427 coff_canonicalize_reloc, 4428 _bfd_xcoff_reloc_type_lookup, 4429 4430 /* Write */ 4431 coff_set_arch_mach, 4432 coff_set_section_contents, 4433 4434 /* Link */ 4435 _bfd_xcoff_sizeof_headers, 4436 bfd_generic_get_relocated_section_contents, 4437 bfd_generic_relax_section, 4438 _bfd_xcoff_bfd_link_hash_table_create, 4439 _bfd_generic_link_hash_table_free, 4440 _bfd_xcoff_bfd_link_add_symbols, 4441 _bfd_generic_link_just_syms, 4442 _bfd_xcoff_bfd_final_link, 4443 _bfd_generic_link_split_section, 4444 bfd_generic_gc_sections, 4445 bfd_generic_merge_sections, 4446 bfd_generic_discard_group, 4447 4448 /* Dynamic */ 4449 _bfd_xcoff_get_dynamic_symtab_upper_bound, 4450 _bfd_xcoff_canonicalize_dynamic_symtab, 4451 _bfd_xcoff_get_dynamic_reloc_upper_bound, 4452 _bfd_xcoff_canonicalize_dynamic_reloc, 4453 4454 /* Opposite endian version, none exists */ 4455 NULL, 4456 4457 (void *) &bfd_pmac_xcoff_backend_data, 4458 }; 4459