191094Sdes/* Generic ECOFF (Extended-COFF) routines. 292289Sdes Copyright (C) 1990-2020 Free Software Foundation, Inc. 391094Sdes Original version by Per Bothner. 491094Sdes Full support added by Ian Lance Taylor, ian@cygnus.com. 591094Sdes 699158Sdes This file is part of BFD, the Binary File Descriptor library. 799158Sdes 899158Sdes This program is free software; you can redistribute it and/or modify 991094Sdes it under the terms of the GNU General Public License as published by 1091094Sdes the Free Software Foundation; either version 3 of the License, or 1191094Sdes (at your option) any later version. 1291094Sdes 1391094Sdes This program is distributed in the hope that it will be useful, 1491094Sdes but WITHOUT ANY WARRANTY; without even the implied warranty of 1591094Sdes MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 1691094Sdes GNU General Public License for more details. 1791094Sdes 1891094Sdes You should have received a copy of the GNU General Public License 1991094Sdes along with this program; if not, write to the Free Software 2091094Sdes Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 2191094Sdes MA 02110-1301, USA. */ 2291094Sdes 2391094Sdes#include "sysdep.h" 2491094Sdes#include "bfd.h" 2591094Sdes#include "bfdlink.h" 2691094Sdes#include "libbfd.h" 2791094Sdes#include "ecoff-bfd.h" 2891094Sdes#include "aout/ar.h" 2991094Sdes#include "aout/stab_gnu.h" 3091094Sdes 3191094Sdes/* FIXME: We need the definitions of N_SET[ADTB], but aout64.h defines 3291094Sdes some other stuff which we don't want and which conflicts with stuff 3391094Sdes we do want. */ 34107937Sdes#include "libaout.h" 3591094Sdes#include "aout/aout64.h" 3691094Sdes#undef N_ABS 3791094Sdes#undef exec_hdr 3891094Sdes#undef obj_sym_filepos 3991094Sdes 4091094Sdes#include "coff/internal.h" 4191094Sdes#include "coff/sym.h" 4291094Sdes#include "coff/symconst.h" 4391094Sdes#include "coff/ecoff.h" 4491094Sdes#include "libcoff.h" 4591094Sdes#include "libecoff.h" 4691094Sdes#include "libiberty.h" 4791094Sdes 4891094Sdes#define streq(a, b) (strcmp ((a), (b)) == 0) 4991094Sdes#define strneq(a, b, n) (strncmp ((a), (b), (n)) == 0) 5091094Sdes 5191094Sdes 5291094Sdes/* This stuff is somewhat copied from coffcode.h. */ 5391094Sdesstatic asection bfd_debug_section = 5491684Sdes{ 5591094Sdes /* name, id, section_id, index, next, prev, flags, */ 56107937Sdes "*DEBUG*", 0, 0, 0, NULL, NULL, 0, 5793982Sdes /* user_set_vma, */ 58107937Sdes 0, 5991684Sdes /* linker_mark, linker_has_input, gc_mark, compress_status, */ 6091684Sdes 0, 0, 1, 0, 6191684Sdes /* segment_mark, sec_info_type, use_rela_p, */ 6291684Sdes 0, 0, 0, 6391684Sdes /* sec_flg0, sec_flg1, sec_flg2, sec_flg3, sec_flg4, sec_flg5, */ 6491684Sdes 0, 0, 0, 0, 0, 0, 6591684Sdes /* vma, lma, size, rawsize, compressed_size, relax, relax_count, */ 66107937Sdes 0, 0, 0, 0, 0, 0, 0, 6791094Sdes /* output_offset, output_section, alignment_power, */ 6891100Sdes 0, NULL, 0, 6991100Sdes /* relocation, orelocation, reloc_count, filepos, rel_filepos, */ 7091100Sdes NULL, NULL, 0, 0, 0, 7191100Sdes /* line_filepos, userdata, contents, lineno, lineno_count, */ 7291100Sdes 0, NULL, NULL, NULL, 0, 7391100Sdes /* entsize, kept_section, moving_line_filepos, */ 7491100Sdes 0, NULL, 0, 7591684Sdes /* target_index, used_by_bfd, constructor_chain, owner, */ 7691100Sdes 0, NULL, NULL, NULL, 7793982Sdes /* symbol, */ 7893982Sdes NULL, 7993982Sdes /* symbol_ptr_ptr, */ 8093982Sdes NULL, 8193982Sdes /* map_head, map_tail, */ 8293982Sdes { NULL }, { NULL }, 8393982Sdes /* already_assigned */ 8493982Sdes NULL, 8593982Sdes}; 8694670Sdes 8793982Sdes/* Create an ECOFF object. */ 8894670Sdes 8993982Sdesbfd_boolean 9094670Sdes_bfd_ecoff_mkobject (bfd *abfd) 9194670Sdes{ 9293982Sdes size_t amt = sizeof (ecoff_data_type); 93 94 abfd->tdata.ecoff_obj_data = (struct ecoff_tdata *) bfd_zalloc (abfd, amt); 95 if (abfd->tdata.ecoff_obj_data == NULL) 96 return FALSE; 97 98 return TRUE; 99} 100 101/* This is a hook called by coff_real_object_p to create any backend 102 specific information. */ 103 104void * 105_bfd_ecoff_mkobject_hook (bfd *abfd, void * filehdr, void * aouthdr) 106{ 107 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr; 108 struct internal_aouthdr *internal_a = (struct internal_aouthdr *) aouthdr; 109 ecoff_data_type *ecoff; 110 111 if (! _bfd_ecoff_mkobject (abfd)) 112 return NULL; 113 114 ecoff = ecoff_data (abfd); 115 ecoff->gp_size = 8; 116 ecoff->sym_filepos = internal_f->f_symptr; 117 118 if (internal_a != NULL) 119 { 120 int i; 121 122 ecoff->text_start = internal_a->text_start; 123 ecoff->text_end = internal_a->text_start + internal_a->tsize; 124 ecoff->gp = internal_a->gp_value; 125 ecoff->gprmask = internal_a->gprmask; 126 for (i = 0; i < 4; i++) 127 ecoff->cprmask[i] = internal_a->cprmask[i]; 128 ecoff->fprmask = internal_a->fprmask; 129 if (internal_a->magic == ECOFF_AOUT_ZMAGIC) 130 abfd->flags |= D_PAGED; 131 else 132 abfd->flags &=~ D_PAGED; 133 } 134 135 /* It turns out that no special action is required by the MIPS or 136 Alpha ECOFF backends. They have different information in the 137 a.out header, but we just copy it all (e.g., gprmask, cprmask and 138 fprmask) and let the swapping routines ensure that only relevant 139 information is written out. */ 140 141 return (void *) ecoff; 142} 143 144/* Initialize a new section. */ 145 146bfd_boolean 147_bfd_ecoff_new_section_hook (bfd *abfd, asection *section) 148{ 149 unsigned int i; 150 static struct 151 { 152 const char * name; 153 flagword flags; 154 } 155 section_flags [] = 156 { 157 { _TEXT, SEC_ALLOC | SEC_CODE | SEC_LOAD }, 158 { _INIT, SEC_ALLOC | SEC_CODE | SEC_LOAD }, 159 { _FINI, SEC_ALLOC | SEC_CODE | SEC_LOAD }, 160 { _DATA, SEC_ALLOC | SEC_DATA | SEC_LOAD }, 161 { _SDATA, SEC_ALLOC | SEC_DATA | SEC_LOAD | SEC_SMALL_DATA }, 162 { _RDATA, SEC_ALLOC | SEC_DATA | SEC_LOAD | SEC_READONLY}, 163 { _LIT8, SEC_ALLOC | SEC_DATA | SEC_LOAD | SEC_READONLY | SEC_SMALL_DATA}, 164 { _LIT4, SEC_ALLOC | SEC_DATA | SEC_LOAD | SEC_READONLY | SEC_SMALL_DATA}, 165 { _RCONST, SEC_ALLOC | SEC_DATA | SEC_LOAD | SEC_READONLY}, 166 { _PDATA, SEC_ALLOC | SEC_DATA | SEC_LOAD | SEC_READONLY}, 167 { _BSS, SEC_ALLOC}, 168 { _SBSS, SEC_ALLOC | SEC_SMALL_DATA}, 169 /* An Irix 4 shared libary. */ 170 { _LIB, SEC_COFF_SHARED_LIBRARY} 171 }; 172 173 section->alignment_power = 4; 174 175 for (i = 0; i < ARRAY_SIZE (section_flags); i++) 176 if (streq (section->name, section_flags[i].name)) 177 { 178 section->flags |= section_flags[i].flags; 179 break; 180 } 181 182 183 /* Probably any other section name is SEC_NEVER_LOAD, but I'm 184 uncertain about .init on some systems and I don't know how shared 185 libraries work. */ 186 187 return _bfd_generic_new_section_hook (abfd, section); 188} 189 190void 191_bfd_ecoff_set_alignment_hook (bfd *abfd ATTRIBUTE_UNUSED, 192 asection *section ATTRIBUTE_UNUSED, 193 void *scnhdr ATTRIBUTE_UNUSED) 194{ 195} 196 197/* Determine the machine architecture and type. This is called from 198 the generic COFF routines. It is the inverse of ecoff_get_magic, 199 below. This could be an ECOFF backend routine, with one version 200 for each target, but there aren't all that many ECOFF targets. */ 201 202bfd_boolean 203_bfd_ecoff_set_arch_mach_hook (bfd *abfd, void * filehdr) 204{ 205 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr; 206 enum bfd_architecture arch; 207 unsigned long mach; 208 209 switch (internal_f->f_magic) 210 { 211 case MIPS_MAGIC_1: 212 case MIPS_MAGIC_LITTLE: 213 case MIPS_MAGIC_BIG: 214 arch = bfd_arch_mips; 215 mach = bfd_mach_mips3000; 216 break; 217 218 case MIPS_MAGIC_LITTLE2: 219 case MIPS_MAGIC_BIG2: 220 /* MIPS ISA level 2: the r6000. */ 221 arch = bfd_arch_mips; 222 mach = bfd_mach_mips6000; 223 break; 224 225 case MIPS_MAGIC_LITTLE3: 226 case MIPS_MAGIC_BIG3: 227 /* MIPS ISA level 3: the r4000. */ 228 arch = bfd_arch_mips; 229 mach = bfd_mach_mips4000; 230 break; 231 232 case ALPHA_MAGIC: 233 arch = bfd_arch_alpha; 234 mach = 0; 235 break; 236 237 default: 238 arch = bfd_arch_obscure; 239 mach = 0; 240 break; 241 } 242 243 return bfd_default_set_arch_mach (abfd, arch, mach); 244} 245 246bfd_boolean 247_bfd_ecoff_no_long_sections (bfd *abfd, int enable) 248{ 249 (void) abfd; 250 (void) enable; 251 return FALSE; 252} 253 254/* Get the magic number to use based on the architecture and machine. 255 This is the inverse of _bfd_ecoff_set_arch_mach_hook, above. */ 256 257static int 258ecoff_get_magic (bfd *abfd) 259{ 260 int big, little; 261 262 switch (bfd_get_arch (abfd)) 263 { 264 case bfd_arch_mips: 265 switch (bfd_get_mach (abfd)) 266 { 267 default: 268 case 0: 269 case bfd_mach_mips3000: 270 big = MIPS_MAGIC_BIG; 271 little = MIPS_MAGIC_LITTLE; 272 break; 273 274 case bfd_mach_mips6000: 275 big = MIPS_MAGIC_BIG2; 276 little = MIPS_MAGIC_LITTLE2; 277 break; 278 279 case bfd_mach_mips4000: 280 big = MIPS_MAGIC_BIG3; 281 little = MIPS_MAGIC_LITTLE3; 282 break; 283 } 284 285 return bfd_big_endian (abfd) ? big : little; 286 287 case bfd_arch_alpha: 288 return ALPHA_MAGIC; 289 290 default: 291 abort (); 292 return 0; 293 } 294} 295 296/* Get the section s_flags to use for a section. */ 297 298static long 299ecoff_sec_to_styp_flags (const char *name, flagword flags) 300{ 301 unsigned int i; 302 static struct 303 { 304 const char * name; 305 long flags; 306 } 307 styp_flags [] = 308 { 309 { _TEXT, STYP_TEXT }, 310 { _DATA, STYP_DATA }, 311 { _SDATA, STYP_SDATA }, 312 { _RDATA, STYP_RDATA }, 313 { _LITA, STYP_LITA }, 314 { _LIT8, STYP_LIT8 }, 315 { _LIT4, STYP_LIT4 }, 316 { _BSS, STYP_BSS }, 317 { _SBSS, STYP_SBSS }, 318 { _INIT, STYP_ECOFF_INIT }, 319 { _FINI, STYP_ECOFF_FINI }, 320 { _PDATA, STYP_PDATA }, 321 { _XDATA, STYP_XDATA }, 322 { _LIB, STYP_ECOFF_LIB }, 323 { _GOT, STYP_GOT }, 324 { _HASH, STYP_HASH }, 325 { _DYNAMIC, STYP_DYNAMIC }, 326 { _LIBLIST, STYP_LIBLIST }, 327 { _RELDYN, STYP_RELDYN }, 328 { _CONFLIC, STYP_CONFLIC }, 329 { _DYNSTR, STYP_DYNSTR }, 330 { _DYNSYM, STYP_DYNSYM }, 331 { _RCONST, STYP_RCONST } 332 }; 333 long styp = 0; 334 335 for (i = 0; i < ARRAY_SIZE (styp_flags); i++) 336 if (streq (name, styp_flags[i].name)) 337 { 338 styp = styp_flags[i].flags; 339 break; 340 } 341 342 if (styp == 0) 343 { 344 if (streq (name, _COMMENT)) 345 { 346 styp = STYP_COMMENT; 347 flags &=~ SEC_NEVER_LOAD; 348 } 349 else if (flags & SEC_CODE) 350 styp = STYP_TEXT; 351 else if (flags & SEC_DATA) 352 styp = STYP_DATA; 353 else if (flags & SEC_READONLY) 354 styp = STYP_RDATA; 355 else if (flags & SEC_LOAD) 356 styp = STYP_REG; 357 else 358 styp = STYP_BSS; 359 } 360 361 if (flags & SEC_NEVER_LOAD) 362 styp |= STYP_NOLOAD; 363 364 return styp; 365} 366 367/* Get the BFD flags to use for a section. */ 368 369bfd_boolean 370_bfd_ecoff_styp_to_sec_flags (bfd *abfd ATTRIBUTE_UNUSED, 371 void * hdr, 372 const char *name ATTRIBUTE_UNUSED, 373 asection *section ATTRIBUTE_UNUSED, 374 flagword * flags_ptr) 375{ 376 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr; 377 long styp_flags = internal_s->s_flags; 378 flagword sec_flags = 0; 379 380 if (styp_flags & STYP_NOLOAD) 381 sec_flags |= SEC_NEVER_LOAD; 382 383 /* For 386 COFF, at least, an unloadable text or data section is 384 actually a shared library section. */ 385 if ((styp_flags & STYP_TEXT) 386 || (styp_flags & STYP_ECOFF_INIT) 387 || (styp_flags & STYP_ECOFF_FINI) 388 || (styp_flags & STYP_DYNAMIC) 389 || (styp_flags & STYP_LIBLIST) 390 || (styp_flags & STYP_RELDYN) 391 || styp_flags == STYP_CONFLIC 392 || (styp_flags & STYP_DYNSTR) 393 || (styp_flags & STYP_DYNSYM) 394 || (styp_flags & STYP_HASH)) 395 { 396 if (sec_flags & SEC_NEVER_LOAD) 397 sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY; 398 else 399 sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC; 400 } 401 else if ((styp_flags & STYP_DATA) 402 || (styp_flags & STYP_RDATA) 403 || (styp_flags & STYP_SDATA) 404 || styp_flags == STYP_PDATA 405 || styp_flags == STYP_XDATA 406 || (styp_flags & STYP_GOT) 407 || styp_flags == STYP_RCONST) 408 { 409 if (sec_flags & SEC_NEVER_LOAD) 410 sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY; 411 else 412 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC; 413 if ((styp_flags & STYP_RDATA) 414 || styp_flags == STYP_PDATA 415 || styp_flags == STYP_RCONST) 416 sec_flags |= SEC_READONLY; 417 if (styp_flags & STYP_SDATA) 418 sec_flags |= SEC_SMALL_DATA; 419 } 420 else if (styp_flags & STYP_SBSS) 421 sec_flags |= SEC_ALLOC | SEC_SMALL_DATA; 422 else if (styp_flags & STYP_BSS) 423 sec_flags |= SEC_ALLOC; 424 else if ((styp_flags & STYP_INFO) || styp_flags == STYP_COMMENT) 425 sec_flags |= SEC_NEVER_LOAD; 426 else if ((styp_flags & STYP_LITA) 427 || (styp_flags & STYP_LIT8) 428 || (styp_flags & STYP_LIT4)) 429 sec_flags |= SEC_DATA |SEC_SMALL_DATA | SEC_LOAD | SEC_ALLOC | SEC_READONLY; 430 else if (styp_flags & STYP_ECOFF_LIB) 431 sec_flags |= SEC_COFF_SHARED_LIBRARY; 432 else 433 sec_flags |= SEC_ALLOC | SEC_LOAD; 434 435 * flags_ptr = sec_flags; 436 return TRUE; 437} 438 439/* Read in the symbolic header for an ECOFF object file. */ 440 441static bfd_boolean 442ecoff_slurp_symbolic_header (bfd *abfd) 443{ 444 const struct ecoff_backend_data * const backend = ecoff_backend (abfd); 445 bfd_size_type external_hdr_size; 446 void * raw = NULL; 447 HDRR *internal_symhdr; 448 449 /* See if we've already read it in. */ 450 if (ecoff_data (abfd)->debug_info.symbolic_header.magic == 451 backend->debug_swap.sym_magic) 452 return TRUE; 453 454 /* See whether there is a symbolic header. */ 455 if (ecoff_data (abfd)->sym_filepos == 0) 456 { 457 abfd->symcount = 0; 458 return TRUE; 459 } 460 461 /* At this point bfd_get_symcount (abfd) holds the number of symbols 462 as read from the file header, but on ECOFF this is always the 463 size of the symbolic information header. It would be cleaner to 464 handle this when we first read the file in coffgen.c. */ 465 external_hdr_size = backend->debug_swap.external_hdr_size; 466 if (bfd_get_symcount (abfd) != external_hdr_size) 467 { 468 bfd_set_error (bfd_error_bad_value); 469 return FALSE; 470 } 471 472 /* Read the symbolic information header. */ 473 if (bfd_seek (abfd, ecoff_data (abfd)->sym_filepos, SEEK_SET) != 0) 474 goto error_return; 475 raw = _bfd_malloc_and_read (abfd, external_hdr_size, external_hdr_size); 476 if (raw == NULL) 477 goto error_return; 478 479 internal_symhdr = &ecoff_data (abfd)->debug_info.symbolic_header; 480 (*backend->debug_swap.swap_hdr_in) (abfd, raw, internal_symhdr); 481 482 if (internal_symhdr->magic != backend->debug_swap.sym_magic) 483 { 484 bfd_set_error (bfd_error_bad_value); 485 goto error_return; 486 } 487 488 /* Now we can get the correct number of symbols. */ 489 abfd->symcount = internal_symhdr->isymMax + internal_symhdr->iextMax; 490 491 free (raw); 492 return TRUE; 493 error_return: 494 free (raw); 495 return FALSE; 496} 497 498/* Read in and swap the important symbolic information for an ECOFF 499 object file. This is called by gdb via the read_debug_info entry 500 point in the backend structure. */ 501 502bfd_boolean 503_bfd_ecoff_slurp_symbolic_info (bfd *abfd, 504 asection *ignore ATTRIBUTE_UNUSED, 505 struct ecoff_debug_info *debug) 506{ 507 const struct ecoff_backend_data * const backend = ecoff_backend (abfd); 508 HDRR *internal_symhdr; 509 bfd_size_type raw_base; 510 bfd_size_type raw_size; 511 void * raw; 512 bfd_size_type external_fdr_size; 513 char *fraw_src; 514 char *fraw_end; 515 struct fdr *fdr_ptr; 516 bfd_size_type raw_end; 517 bfd_size_type cb_end; 518 file_ptr pos; 519 size_t amt; 520 521 BFD_ASSERT (debug == &ecoff_data (abfd)->debug_info); 522 523 /* Check whether we've already gotten it, and whether there's any to 524 get. */ 525 if (ecoff_data (abfd)->raw_syments != NULL) 526 return TRUE; 527 if (ecoff_data (abfd)->sym_filepos == 0) 528 { 529 abfd->symcount = 0; 530 return TRUE; 531 } 532 533 if (! ecoff_slurp_symbolic_header (abfd)) 534 return FALSE; 535 536 internal_symhdr = &debug->symbolic_header; 537 538 /* Read all the symbolic information at once. */ 539 raw_base = (ecoff_data (abfd)->sym_filepos 540 + backend->debug_swap.external_hdr_size); 541 542 /* Alpha ecoff makes the determination of raw_size difficult. It has 543 an undocumented debug data section between the symhdr and the first 544 documented section. And the ordering of the sections varies between 545 statically and dynamically linked executables. 546 If bfd supports SEEK_END someday, this code could be simplified. */ 547 raw_end = 0; 548 549#define UPDATE_RAW_END(start, count, size) \ 550 cb_end = internal_symhdr->start + internal_symhdr->count * (size); \ 551 if (cb_end > raw_end) \ 552 raw_end = cb_end 553 554 UPDATE_RAW_END (cbLineOffset, cbLine, sizeof (unsigned char)); 555 UPDATE_RAW_END (cbDnOffset, idnMax, backend->debug_swap.external_dnr_size); 556 UPDATE_RAW_END (cbPdOffset, ipdMax, backend->debug_swap.external_pdr_size); 557 UPDATE_RAW_END (cbSymOffset, isymMax, backend->debug_swap.external_sym_size); 558 /* eraxxon@alumni.rice.edu: ioptMax refers to the size of the 559 optimization symtab, not the number of entries. */ 560 UPDATE_RAW_END (cbOptOffset, ioptMax, sizeof (char)); 561 UPDATE_RAW_END (cbAuxOffset, iauxMax, sizeof (union aux_ext)); 562 UPDATE_RAW_END (cbSsOffset, issMax, sizeof (char)); 563 UPDATE_RAW_END (cbSsExtOffset, issExtMax, sizeof (char)); 564 UPDATE_RAW_END (cbFdOffset, ifdMax, backend->debug_swap.external_fdr_size); 565 UPDATE_RAW_END (cbRfdOffset, crfd, backend->debug_swap.external_rfd_size); 566 UPDATE_RAW_END (cbExtOffset, iextMax, backend->debug_swap.external_ext_size); 567 568#undef UPDATE_RAW_END 569 570 raw_size = raw_end - raw_base; 571 if (raw_size == 0) 572 { 573 ecoff_data (abfd)->sym_filepos = 0; 574 return TRUE; 575 } 576 pos = ecoff_data (abfd)->sym_filepos; 577 pos += backend->debug_swap.external_hdr_size; 578 if (bfd_seek (abfd, pos, SEEK_SET) != 0) 579 return FALSE; 580 raw = _bfd_alloc_and_read (abfd, raw_size, raw_size); 581 if (raw == NULL) 582 return FALSE; 583 584 ecoff_data (abfd)->raw_syments = raw; 585 586 /* Get pointers for the numeric offsets in the HDRR structure. */ 587#define FIX(off1, off2, type) \ 588 if (internal_symhdr->off1 == 0) \ 589 debug->off2 = NULL; \ 590 else \ 591 debug->off2 = (type) ((char *) raw \ 592 + (internal_symhdr->off1 \ 593 - raw_base)) 594 595 FIX (cbLineOffset, line, unsigned char *); 596 FIX (cbDnOffset, external_dnr, void *); 597 FIX (cbPdOffset, external_pdr, void *); 598 FIX (cbSymOffset, external_sym, void *); 599 FIX (cbOptOffset, external_opt, void *); 600 FIX (cbAuxOffset, external_aux, union aux_ext *); 601 FIX (cbSsOffset, ss, char *); 602 FIX (cbSsExtOffset, ssext, char *); 603 FIX (cbFdOffset, external_fdr, void *); 604 FIX (cbRfdOffset, external_rfd, void *); 605 FIX (cbExtOffset, external_ext, void *); 606#undef FIX 607 608 /* I don't want to always swap all the data, because it will just 609 waste time and most programs will never look at it. The only 610 time the linker needs most of the debugging information swapped 611 is when linking big-endian and little-endian MIPS object files 612 together, which is not a common occurrence. 613 614 We need to look at the fdr to deal with a lot of information in 615 the symbols, so we swap them here. */ 616 if (_bfd_mul_overflow ((unsigned long) internal_symhdr->ifdMax, 617 sizeof (struct fdr), &amt)) 618 { 619 bfd_set_error (bfd_error_file_too_big); 620 return FALSE; 621 } 622 debug->fdr = (FDR *) bfd_alloc (abfd, amt); 623 if (debug->fdr == NULL) 624 return FALSE; 625 external_fdr_size = backend->debug_swap.external_fdr_size; 626 fdr_ptr = debug->fdr; 627 fraw_src = (char *) debug->external_fdr; 628 /* PR 17512: file: 3372-1243-0.004. */ 629 if (fraw_src == NULL && internal_symhdr->ifdMax > 0) 630 return FALSE; 631 fraw_end = fraw_src + internal_symhdr->ifdMax * external_fdr_size; 632 for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++) 633 (*backend->debug_swap.swap_fdr_in) (abfd, (void *) fraw_src, fdr_ptr); 634 635 return TRUE; 636} 637 638/* ECOFF symbol table routines. The ECOFF symbol table is described 639 in gcc/mips-tfile.c. */ 640 641/* ECOFF uses two common sections. One is the usual one, and the 642 other is for small objects. All the small objects are kept 643 together, and then referenced via the gp pointer, which yields 644 faster assembler code. This is what we use for the small common 645 section. */ 646static asection ecoff_scom_section; 647static asymbol ecoff_scom_symbol; 648static asymbol *ecoff_scom_symbol_ptr; 649 650/* Create an empty symbol. */ 651 652asymbol * 653_bfd_ecoff_make_empty_symbol (bfd *abfd) 654{ 655 ecoff_symbol_type *new_symbol; 656 size_t amt = sizeof (ecoff_symbol_type); 657 658 new_symbol = (ecoff_symbol_type *) bfd_zalloc (abfd, amt); 659 if (new_symbol == NULL) 660 return NULL; 661 new_symbol->symbol.section = NULL; 662 new_symbol->fdr = NULL; 663 new_symbol->local = FALSE; 664 new_symbol->native = NULL; 665 new_symbol->symbol.the_bfd = abfd; 666 return &new_symbol->symbol; 667} 668 669/* Set the BFD flags and section for an ECOFF symbol. */ 670 671static bfd_boolean 672ecoff_set_symbol_info (bfd *abfd, 673 SYMR *ecoff_sym, 674 asymbol *asym, 675 int ext, 676 int weak) 677{ 678 asym->the_bfd = abfd; 679 asym->value = ecoff_sym->value; 680 asym->section = &bfd_debug_section; 681 asym->udata.i = 0; 682 683 /* Most symbol types are just for debugging. */ 684 switch (ecoff_sym->st) 685 { 686 case stGlobal: 687 case stStatic: 688 case stLabel: 689 case stProc: 690 case stStaticProc: 691 break; 692 case stNil: 693 if (ECOFF_IS_STAB (ecoff_sym)) 694 { 695 asym->flags = BSF_DEBUGGING; 696 return TRUE; 697 } 698 break; 699 default: 700 asym->flags = BSF_DEBUGGING; 701 return TRUE; 702 } 703 704 if (weak) 705 asym->flags = BSF_EXPORT | BSF_WEAK; 706 else if (ext) 707 asym->flags = BSF_EXPORT | BSF_GLOBAL; 708 else 709 { 710 asym->flags = BSF_LOCAL; 711 /* Normally, a local stProc symbol will have a corresponding 712 external symbol. We mark the local symbol as a debugging 713 symbol, in order to prevent nm from printing both out. 714 Similarly, we mark stLabel and stabs symbols as debugging 715 symbols. In both cases, we do want to set the value 716 correctly based on the symbol class. */ 717 if (ecoff_sym->st == stProc 718 || ecoff_sym->st == stLabel 719 || ECOFF_IS_STAB (ecoff_sym)) 720 asym->flags |= BSF_DEBUGGING; 721 } 722 723 if (ecoff_sym->st == stProc || ecoff_sym->st == stStaticProc) 724 asym->flags |= BSF_FUNCTION; 725 726 switch (ecoff_sym->sc) 727 { 728 case scNil: 729 /* Used for compiler generated labels. Leave them in the 730 debugging section, and mark them as local. If BSF_DEBUGGING 731 is set, then nm does not display them for some reason. If no 732 flags are set then the linker whines about them. */ 733 asym->flags = BSF_LOCAL; 734 break; 735 case scText: 736 asym->section = bfd_make_section_old_way (abfd, _TEXT); 737 asym->value -= asym->section->vma; 738 break; 739 case scData: 740 asym->section = bfd_make_section_old_way (abfd, _DATA); 741 asym->value -= asym->section->vma; 742 break; 743 case scBss: 744 asym->section = bfd_make_section_old_way (abfd, _BSS); 745 asym->value -= asym->section->vma; 746 break; 747 case scRegister: 748 asym->flags = BSF_DEBUGGING; 749 break; 750 case scAbs: 751 asym->section = bfd_abs_section_ptr; 752 break; 753 case scUndefined: 754 asym->section = bfd_und_section_ptr; 755 asym->flags = 0; 756 asym->value = 0; 757 break; 758 case scCdbLocal: 759 case scBits: 760 case scCdbSystem: 761 case scRegImage: 762 case scInfo: 763 case scUserStruct: 764 asym->flags = BSF_DEBUGGING; 765 break; 766 case scSData: 767 asym->section = bfd_make_section_old_way (abfd, ".sdata"); 768 asym->value -= asym->section->vma; 769 break; 770 case scSBss: 771 asym->section = bfd_make_section_old_way (abfd, ".sbss"); 772 asym->value -= asym->section->vma; 773 break; 774 case scRData: 775 asym->section = bfd_make_section_old_way (abfd, ".rdata"); 776 asym->value -= asym->section->vma; 777 break; 778 case scVar: 779 asym->flags = BSF_DEBUGGING; 780 break; 781 case scCommon: 782 if (asym->value > ecoff_data (abfd)->gp_size) 783 { 784 asym->section = bfd_com_section_ptr; 785 asym->flags = 0; 786 break; 787 } 788 /* Fall through. */ 789 case scSCommon: 790 if (ecoff_scom_section.name == NULL) 791 { 792 /* Initialize the small common section. */ 793 ecoff_scom_section.name = SCOMMON; 794 ecoff_scom_section.flags = SEC_IS_COMMON | SEC_SMALL_DATA; 795 ecoff_scom_section.output_section = &ecoff_scom_section; 796 ecoff_scom_section.symbol = &ecoff_scom_symbol; 797 ecoff_scom_section.symbol_ptr_ptr = &ecoff_scom_symbol_ptr; 798 ecoff_scom_symbol.name = SCOMMON; 799 ecoff_scom_symbol.flags = BSF_SECTION_SYM; 800 ecoff_scom_symbol.section = &ecoff_scom_section; 801 ecoff_scom_symbol_ptr = &ecoff_scom_symbol; 802 } 803 asym->section = &ecoff_scom_section; 804 asym->flags = 0; 805 break; 806 case scVarRegister: 807 case scVariant: 808 asym->flags = BSF_DEBUGGING; 809 break; 810 case scSUndefined: 811 asym->section = bfd_und_section_ptr; 812 asym->flags = 0; 813 asym->value = 0; 814 break; 815 case scInit: 816 asym->section = bfd_make_section_old_way (abfd, ".init"); 817 asym->value -= asym->section->vma; 818 break; 819 case scBasedVar: 820 case scXData: 821 case scPData: 822 asym->flags = BSF_DEBUGGING; 823 break; 824 case scFini: 825 asym->section = bfd_make_section_old_way (abfd, ".fini"); 826 asym->value -= asym->section->vma; 827 break; 828 case scRConst: 829 asym->section = bfd_make_section_old_way (abfd, ".rconst"); 830 asym->value -= asym->section->vma; 831 break; 832 default: 833 break; 834 } 835 836 /* Look for special constructors symbols and make relocation entries 837 in a special construction section. These are produced by the 838 -fgnu-linker argument to g++. */ 839 if (ECOFF_IS_STAB (ecoff_sym)) 840 { 841 switch (ECOFF_UNMARK_STAB (ecoff_sym->index)) 842 { 843 default: 844 break; 845 846 case N_SETA: 847 case N_SETT: 848 case N_SETD: 849 case N_SETB: 850 /* Mark the symbol as a constructor. */ 851 asym->flags |= BSF_CONSTRUCTOR; 852 break; 853 } 854 } 855 return TRUE; 856} 857 858/* Read an ECOFF symbol table. */ 859 860bfd_boolean 861_bfd_ecoff_slurp_symbol_table (bfd *abfd) 862{ 863 const struct ecoff_backend_data * const backend = ecoff_backend (abfd); 864 const bfd_size_type external_ext_size 865 = backend->debug_swap.external_ext_size; 866 const bfd_size_type external_sym_size 867 = backend->debug_swap.external_sym_size; 868 void (* const swap_ext_in) (bfd *, void *, EXTR *) 869 = backend->debug_swap.swap_ext_in; 870 void (* const swap_sym_in) (bfd *, void *, SYMR *) 871 = backend->debug_swap.swap_sym_in; 872 ecoff_symbol_type *internal; 873 ecoff_symbol_type *internal_ptr; 874 char *eraw_src; 875 char *eraw_end; 876 FDR *fdr_ptr; 877 FDR *fdr_end; 878 size_t amt; 879 880 /* If we've already read in the symbol table, do nothing. */ 881 if (ecoff_data (abfd)->canonical_symbols != NULL) 882 return TRUE; 883 884 /* Get the symbolic information. */ 885 if (! _bfd_ecoff_slurp_symbolic_info (abfd, NULL, 886 &ecoff_data (abfd)->debug_info)) 887 return FALSE; 888 if (bfd_get_symcount (abfd) == 0) 889 return TRUE; 890 891 if (_bfd_mul_overflow (bfd_get_symcount (abfd), 892 sizeof (ecoff_symbol_type), &amt)) 893 { 894 bfd_set_error (bfd_error_file_too_big); 895 return FALSE; 896 } 897 internal = (ecoff_symbol_type *) bfd_alloc (abfd, amt); 898 if (internal == NULL) 899 return FALSE; 900 901 internal_ptr = internal; 902 eraw_src = (char *) ecoff_data (abfd)->debug_info.external_ext; 903 eraw_end = (eraw_src 904 + (ecoff_data (abfd)->debug_info.symbolic_header.iextMax 905 * external_ext_size)); 906 for (; eraw_src < eraw_end; eraw_src += external_ext_size, internal_ptr++) 907 { 908 EXTR internal_esym; 909 910 (*swap_ext_in) (abfd, (void *) eraw_src, &internal_esym); 911 912 /* PR 17512: file: 3372-1000-0.004. */ 913 if (internal_esym.asym.iss >= ecoff_data (abfd)->debug_info.symbolic_header.issExtMax 914 || internal_esym.asym.iss < 0) 915 return FALSE; 916 917 internal_ptr->symbol.name = (ecoff_data (abfd)->debug_info.ssext 918 + internal_esym.asym.iss); 919 920 if (!ecoff_set_symbol_info (abfd, &internal_esym.asym, 921 &internal_ptr->symbol, 1, 922 internal_esym.weakext)) 923 return FALSE; 924 925 /* The alpha uses a negative ifd field for section symbols. */ 926 if (internal_esym.ifd >= 0) 927 { 928 /* PR 17512: file: 3372-1983-0.004. */ 929 if (internal_esym.ifd >= ecoff_data (abfd)->debug_info.symbolic_header.ifdMax) 930 internal_ptr->fdr = NULL; 931 else 932 internal_ptr->fdr = (ecoff_data (abfd)->debug_info.fdr 933 + internal_esym.ifd); 934 } 935 else 936 internal_ptr->fdr = NULL; 937 internal_ptr->local = FALSE; 938 internal_ptr->native = (void *) eraw_src; 939 } 940 941 /* The local symbols must be accessed via the fdr's, because the 942 string and aux indices are relative to the fdr information. */ 943 fdr_ptr = ecoff_data (abfd)->debug_info.fdr; 944 fdr_end = fdr_ptr + ecoff_data (abfd)->debug_info.symbolic_header.ifdMax; 945 for (; fdr_ptr < fdr_end; fdr_ptr++) 946 { 947 char *lraw_src; 948 char *lraw_end; 949 950 lraw_src = ((char *) ecoff_data (abfd)->debug_info.external_sym 951 + fdr_ptr->isymBase * external_sym_size); 952 lraw_end = lraw_src + fdr_ptr->csym * external_sym_size; 953 for (; 954 lraw_src < lraw_end; 955 lraw_src += external_sym_size, internal_ptr++) 956 { 957 SYMR internal_sym; 958 959 (*swap_sym_in) (abfd, (void *) lraw_src, &internal_sym); 960 internal_ptr->symbol.name = (ecoff_data (abfd)->debug_info.ss 961 + fdr_ptr->issBase 962 + internal_sym.iss); 963 if (!ecoff_set_symbol_info (abfd, &internal_sym, 964 &internal_ptr->symbol, 0, 0)) 965 return FALSE; 966 internal_ptr->fdr = fdr_ptr; 967 internal_ptr->local = TRUE; 968 internal_ptr->native = (void *) lraw_src; 969 } 970 } 971 972 /* PR 17512: file: 3372-3080-0.004. 973 A discrepancy between ecoff_data (abfd)->debug_info.symbolic_header.isymMax 974 and ecoff_data (abfd)->debug_info.symbolic_header.ifdMax can mean that 975 we have fewer symbols than we were expecting. Allow for this by updating 976 the symbol count and warning the user. */ 977 if (internal_ptr - internal < (ptrdiff_t) bfd_get_symcount (abfd)) 978 { 979 abfd->symcount = internal_ptr - internal; 980 _bfd_error_handler 981 /* xgettext:c-format */ 982 (_("%pB: warning: isymMax (%ld) is greater than ifdMax (%ld)"), 983 abfd, ecoff_data (abfd)->debug_info.symbolic_header.isymMax, 984 ecoff_data (abfd)->debug_info.symbolic_header.ifdMax); 985 } 986 987 ecoff_data (abfd)->canonical_symbols = internal; 988 989 return TRUE; 990} 991 992/* Return the amount of space needed for the canonical symbols. */ 993 994long 995_bfd_ecoff_get_symtab_upper_bound (bfd *abfd) 996{ 997 if (! _bfd_ecoff_slurp_symbolic_info (abfd, NULL, 998 &ecoff_data (abfd)->debug_info)) 999 return -1; 1000 1001 if (bfd_get_symcount (abfd) == 0) 1002 return 0; 1003 1004 return (bfd_get_symcount (abfd) + 1) * (sizeof (ecoff_symbol_type *)); 1005} 1006 1007/* Get the canonical symbols. */ 1008 1009long 1010_bfd_ecoff_canonicalize_symtab (bfd *abfd, asymbol **alocation) 1011{ 1012 unsigned int counter = 0; 1013 ecoff_symbol_type *symbase; 1014 ecoff_symbol_type **location = (ecoff_symbol_type **) alocation; 1015 1016 if (! _bfd_ecoff_slurp_symbol_table (abfd)) 1017 return -1; 1018 if (bfd_get_symcount (abfd) == 0) 1019 return 0; 1020 1021 symbase = ecoff_data (abfd)->canonical_symbols; 1022 while (counter < bfd_get_symcount (abfd)) 1023 { 1024 *(location++) = symbase++; 1025 counter++; 1026 } 1027 *location++ = NULL; 1028 return bfd_get_symcount (abfd); 1029} 1030 1031/* Turn ECOFF type information into a printable string. 1032 ecoff_emit_aggregate and ecoff_type_to_string are from 1033 gcc/mips-tdump.c, with swapping added and used_ptr removed. */ 1034 1035/* Write aggregate information to a string. */ 1036 1037static void 1038ecoff_emit_aggregate (bfd *abfd, 1039 FDR *fdr, 1040 char *string, 1041 RNDXR *rndx, 1042 long isym, 1043 const char *which) 1044{ 1045 const struct ecoff_debug_swap * const debug_swap = 1046 &ecoff_backend (abfd)->debug_swap; 1047 struct ecoff_debug_info * const debug_info = &ecoff_data (abfd)->debug_info; 1048 unsigned int ifd = rndx->rfd; 1049 unsigned int indx = rndx->index; 1050 const char *name; 1051 1052 if (ifd == 0xfff) 1053 ifd = isym; 1054 1055 /* An ifd of -1 is an opaque type. An escaped index of 0 is a 1056 struct return type of a procedure compiled without -g. */ 1057 if (ifd == 0xffffffff 1058 || (rndx->rfd == 0xfff && indx == 0)) 1059 name = "<undefined>"; 1060 else if (indx == indexNil) 1061 name = "<no name>"; 1062 else 1063 { 1064 SYMR sym; 1065 1066 if (debug_info->external_rfd == NULL) 1067 fdr = debug_info->fdr + ifd; 1068 else 1069 { 1070 RFDT rfd; 1071 1072 (*debug_swap->swap_rfd_in) (abfd, 1073 ((char *) debug_info->external_rfd 1074 + ((fdr->rfdBase + ifd) 1075 * debug_swap->external_rfd_size)), 1076 &rfd); 1077 fdr = debug_info->fdr + rfd; 1078 } 1079 1080 indx += fdr->isymBase; 1081 1082 (*debug_swap->swap_sym_in) (abfd, 1083 ((char *) debug_info->external_sym 1084 + indx * debug_swap->external_sym_size), 1085 &sym); 1086 1087 name = debug_info->ss + fdr->issBase + sym.iss; 1088 } 1089 1090 sprintf (string, 1091 "%s %s { ifd = %u, index = %lu }", 1092 which, name, ifd, 1093 ((unsigned long) indx 1094 + debug_info->symbolic_header.iextMax)); 1095} 1096 1097/* Convert the type information to string format. */ 1098 1099static char * 1100ecoff_type_to_string (bfd *abfd, FDR *fdr, unsigned int indx) 1101{ 1102 union aux_ext *aux_ptr; 1103 int bigendian; 1104 AUXU u; 1105 struct qual 1106 { 1107 unsigned int type; 1108 int low_bound; 1109 int high_bound; 1110 int stride; 1111 } qualifiers[7]; 1112 unsigned int basic_type; 1113 int i; 1114 char buffer1[1024]; 1115 static char buffer2[1024]; 1116 char *p1 = buffer1; 1117 char *p2 = buffer2; 1118 RNDXR rndx; 1119 1120 aux_ptr = ecoff_data (abfd)->debug_info.external_aux + fdr->iauxBase; 1121 bigendian = fdr->fBigendian; 1122 1123 for (i = 0; i < 7; i++) 1124 { 1125 qualifiers[i].low_bound = 0; 1126 qualifiers[i].high_bound = 0; 1127 qualifiers[i].stride = 0; 1128 } 1129 1130 if (AUX_GET_ISYM (bigendian, &aux_ptr[indx]) == (bfd_vma) -1) 1131 return "-1 (no type)"; 1132 _bfd_ecoff_swap_tir_in (bigendian, &aux_ptr[indx++].a_ti, &u.ti); 1133 1134 basic_type = u.ti.bt; 1135 qualifiers[0].type = u.ti.tq0; 1136 qualifiers[1].type = u.ti.tq1; 1137 qualifiers[2].type = u.ti.tq2; 1138 qualifiers[3].type = u.ti.tq3; 1139 qualifiers[4].type = u.ti.tq4; 1140 qualifiers[5].type = u.ti.tq5; 1141 qualifiers[6].type = tqNil; 1142 1143 /* Go get the basic type. */ 1144 switch (basic_type) 1145 { 1146 case btNil: /* Undefined. */ 1147 strcpy (p1, "nil"); 1148 break; 1149 1150 case btAdr: /* Address - integer same size as pointer. */ 1151 strcpy (p1, "address"); 1152 break; 1153 1154 case btChar: /* Character. */ 1155 strcpy (p1, "char"); 1156 break; 1157 1158 case btUChar: /* Unsigned character. */ 1159 strcpy (p1, "unsigned char"); 1160 break; 1161 1162 case btShort: /* Short. */ 1163 strcpy (p1, "short"); 1164 break; 1165 1166 case btUShort: /* Unsigned short. */ 1167 strcpy (p1, "unsigned short"); 1168 break; 1169 1170 case btInt: /* Int. */ 1171 strcpy (p1, "int"); 1172 break; 1173 1174 case btUInt: /* Unsigned int. */ 1175 strcpy (p1, "unsigned int"); 1176 break; 1177 1178 case btLong: /* Long. */ 1179 strcpy (p1, "long"); 1180 break; 1181 1182 case btULong: /* Unsigned long. */ 1183 strcpy (p1, "unsigned long"); 1184 break; 1185 1186 case btFloat: /* Float (real). */ 1187 strcpy (p1, "float"); 1188 break; 1189 1190 case btDouble: /* Double (real). */ 1191 strcpy (p1, "double"); 1192 break; 1193 1194 /* Structures add 1-2 aux words: 1195 1st word is [ST_RFDESCAPE, offset] pointer to struct def; 1196 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */ 1197 1198 case btStruct: /* Structure (Record). */ 1199 _bfd_ecoff_swap_rndx_in (bigendian, &aux_ptr[indx].a_rndx, &rndx); 1200 ecoff_emit_aggregate (abfd, fdr, p1, &rndx, 1201 (long) AUX_GET_ISYM (bigendian, &aux_ptr[indx+1]), 1202 "struct"); 1203 indx++; /* Skip aux words. */ 1204 break; 1205 1206 /* Unions add 1-2 aux words: 1207 1st word is [ST_RFDESCAPE, offset] pointer to union def; 1208 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */ 1209 1210 case btUnion: /* Union. */ 1211 _bfd_ecoff_swap_rndx_in (bigendian, &aux_ptr[indx].a_rndx, &rndx); 1212 ecoff_emit_aggregate (abfd, fdr, p1, &rndx, 1213 (long) AUX_GET_ISYM (bigendian, &aux_ptr[indx+1]), 1214 "union"); 1215 indx++; /* Skip aux words. */ 1216 break; 1217 1218 /* Enumerations add 1-2 aux words: 1219 1st word is [ST_RFDESCAPE, offset] pointer to enum def; 1220 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */ 1221 1222 case btEnum: /* Enumeration. */ 1223 _bfd_ecoff_swap_rndx_in (bigendian, &aux_ptr[indx].a_rndx, &rndx); 1224 ecoff_emit_aggregate (abfd, fdr, p1, &rndx, 1225 (long) AUX_GET_ISYM (bigendian, &aux_ptr[indx+1]), 1226 "enum"); 1227 indx++; /* Skip aux words. */ 1228 break; 1229 1230 case btTypedef: /* Defined via a typedef, isymRef points. */ 1231 strcpy (p1, "typedef"); 1232 break; 1233 1234 case btRange: /* Subrange of int. */ 1235 strcpy (p1, "subrange"); 1236 break; 1237 1238 case btSet: /* Pascal sets. */ 1239 strcpy (p1, "set"); 1240 break; 1241 1242 case btComplex: /* Fortran complex. */ 1243 strcpy (p1, "complex"); 1244 break; 1245 1246 case btDComplex: /* Fortran double complex. */ 1247 strcpy (p1, "double complex"); 1248 break; 1249 1250 case btIndirect: /* Forward or unnamed typedef. */ 1251 strcpy (p1, "forward/unamed typedef"); 1252 break; 1253 1254 case btFixedDec: /* Fixed Decimal. */ 1255 strcpy (p1, "fixed decimal"); 1256 break; 1257 1258 case btFloatDec: /* Float Decimal. */ 1259 strcpy (p1, "float decimal"); 1260 break; 1261 1262 case btString: /* Varying Length Character String. */ 1263 strcpy (p1, "string"); 1264 break; 1265 1266 case btBit: /* Aligned Bit String. */ 1267 strcpy (p1, "bit"); 1268 break; 1269 1270 case btPicture: /* Picture. */ 1271 strcpy (p1, "picture"); 1272 break; 1273 1274 case btVoid: /* Void. */ 1275 strcpy (p1, "void"); 1276 break; 1277 1278 default: 1279 sprintf (p1, _("unknown basic type %d"), (int) basic_type); 1280 break; 1281 } 1282 1283 p1 += strlen (buffer1); 1284 1285 /* If this is a bitfield, get the bitsize. */ 1286 if (u.ti.fBitfield) 1287 { 1288 int bitsize; 1289 1290 bitsize = AUX_GET_WIDTH (bigendian, &aux_ptr[indx++]); 1291 sprintf (p1, " : %d", bitsize); 1292 p1 += strlen (buffer1); 1293 } 1294 1295 /* Deal with any qualifiers. */ 1296 if (qualifiers[0].type != tqNil) 1297 { 1298 /* Snarf up any array bounds in the correct order. Arrays 1299 store 5 successive words in the aux. table: 1300 word 0 RNDXR to type of the bounds (ie, int) 1301 word 1 Current file descriptor index 1302 word 2 low bound 1303 word 3 high bound (or -1 if []) 1304 word 4 stride size in bits. */ 1305 for (i = 0; i < 7; i++) 1306 { 1307 if (qualifiers[i].type == tqArray) 1308 { 1309 qualifiers[i].low_bound = 1310 AUX_GET_DNLOW (bigendian, &aux_ptr[indx+2]); 1311 qualifiers[i].high_bound = 1312 AUX_GET_DNHIGH (bigendian, &aux_ptr[indx+3]); 1313 qualifiers[i].stride = 1314 AUX_GET_WIDTH (bigendian, &aux_ptr[indx+4]); 1315 indx += 5; 1316 } 1317 } 1318 1319 /* Now print out the qualifiers. */ 1320 for (i = 0; i < 6; i++) 1321 { 1322 switch (qualifiers[i].type) 1323 { 1324 case tqNil: 1325 case tqMax: 1326 break; 1327 1328 case tqPtr: 1329 strcpy (p2, "ptr to "); 1330 p2 += sizeof ("ptr to ")-1; 1331 break; 1332 1333 case tqVol: 1334 strcpy (p2, "volatile "); 1335 p2 += sizeof ("volatile ")-1; 1336 break; 1337 1338 case tqFar: 1339 strcpy (p2, "far "); 1340 p2 += sizeof ("far ")-1; 1341 break; 1342 1343 case tqProc: 1344 strcpy (p2, "func. ret. "); 1345 p2 += sizeof ("func. ret. "); 1346 break; 1347 1348 case tqArray: 1349 { 1350 int first_array = i; 1351 int j; 1352 1353 /* Print array bounds reversed (ie, in the order the C 1354 programmer writes them). C is such a fun language.... */ 1355 while (i < 5 && qualifiers[i+1].type == tqArray) 1356 i++; 1357 1358 for (j = i; j >= first_array; j--) 1359 { 1360 strcpy (p2, "array ["); 1361 p2 += sizeof ("array [")-1; 1362 if (qualifiers[j].low_bound != 0) 1363 sprintf (p2, 1364 "%ld:%ld {%ld bits}", 1365 (long) qualifiers[j].low_bound, 1366 (long) qualifiers[j].high_bound, 1367 (long) qualifiers[j].stride); 1368 1369 else if (qualifiers[j].high_bound != -1) 1370 sprintf (p2, 1371 "%ld {%ld bits}", 1372 (long) (qualifiers[j].high_bound + 1), 1373 (long) (qualifiers[j].stride)); 1374 1375 else 1376 sprintf (p2, " {%ld bits}", (long) (qualifiers[j].stride)); 1377 1378 p2 += strlen (p2); 1379 strcpy (p2, "] of "); 1380 p2 += sizeof ("] of ")-1; 1381 } 1382 } 1383 break; 1384 } 1385 } 1386 } 1387 1388 strcpy (p2, buffer1); 1389 return buffer2; 1390} 1391 1392/* Return information about ECOFF symbol SYMBOL in RET. */ 1393 1394void 1395_bfd_ecoff_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED, 1396 asymbol *symbol, 1397 symbol_info *ret) 1398{ 1399 bfd_symbol_info (symbol, ret); 1400} 1401 1402/* Return whether this is a local label. */ 1403 1404bfd_boolean 1405_bfd_ecoff_bfd_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED, 1406 const char *name) 1407{ 1408 return name[0] == '$'; 1409} 1410 1411/* Print information about an ECOFF symbol. */ 1412 1413void 1414_bfd_ecoff_print_symbol (bfd *abfd, 1415 void * filep, 1416 asymbol *symbol, 1417 bfd_print_symbol_type how) 1418{ 1419 const struct ecoff_debug_swap * const debug_swap 1420 = &ecoff_backend (abfd)->debug_swap; 1421 FILE *file = (FILE *)filep; 1422 1423 switch (how) 1424 { 1425 case bfd_print_symbol_name: 1426 fprintf (file, "%s", symbol->name); 1427 break; 1428 case bfd_print_symbol_more: 1429 if (ecoffsymbol (symbol)->local) 1430 { 1431 SYMR ecoff_sym; 1432 1433 (*debug_swap->swap_sym_in) (abfd, ecoffsymbol (symbol)->native, 1434 &ecoff_sym); 1435 fprintf (file, "ecoff local "); 1436 fprintf_vma (file, (bfd_vma) ecoff_sym.value); 1437 fprintf (file, " %x %x", (unsigned) ecoff_sym.st, 1438 (unsigned) ecoff_sym.sc); 1439 } 1440 else 1441 { 1442 EXTR ecoff_ext; 1443 1444 (*debug_swap->swap_ext_in) (abfd, ecoffsymbol (symbol)->native, 1445 &ecoff_ext); 1446 fprintf (file, "ecoff extern "); 1447 fprintf_vma (file, (bfd_vma) ecoff_ext.asym.value); 1448 fprintf (file, " %x %x", (unsigned) ecoff_ext.asym.st, 1449 (unsigned) ecoff_ext.asym.sc); 1450 } 1451 break; 1452 case bfd_print_symbol_all: 1453 /* Print out the symbols in a reasonable way. */ 1454 { 1455 char type; 1456 int pos; 1457 EXTR ecoff_ext; 1458 char jmptbl; 1459 char cobol_main; 1460 char weakext; 1461 1462 if (ecoffsymbol (symbol)->local) 1463 { 1464 (*debug_swap->swap_sym_in) (abfd, ecoffsymbol (symbol)->native, 1465 &ecoff_ext.asym); 1466 type = 'l'; 1467 pos = ((((char *) ecoffsymbol (symbol)->native 1468 - (char *) ecoff_data (abfd)->debug_info.external_sym) 1469 / debug_swap->external_sym_size) 1470 + ecoff_data (abfd)->debug_info.symbolic_header.iextMax); 1471 jmptbl = ' '; 1472 cobol_main = ' '; 1473 weakext = ' '; 1474 } 1475 else 1476 { 1477 (*debug_swap->swap_ext_in) (abfd, ecoffsymbol (symbol)->native, 1478 &ecoff_ext); 1479 type = 'e'; 1480 pos = (((char *) ecoffsymbol (symbol)->native 1481 - (char *) ecoff_data (abfd)->debug_info.external_ext) 1482 / debug_swap->external_ext_size); 1483 jmptbl = ecoff_ext.jmptbl ? 'j' : ' '; 1484 cobol_main = ecoff_ext.cobol_main ? 'c' : ' '; 1485 weakext = ecoff_ext.weakext ? 'w' : ' '; 1486 } 1487 1488 fprintf (file, "[%3d] %c ", 1489 pos, type); 1490 fprintf_vma (file, (bfd_vma) ecoff_ext.asym.value); 1491 fprintf (file, " st %x sc %x indx %x %c%c%c %s", 1492 (unsigned) ecoff_ext.asym.st, 1493 (unsigned) ecoff_ext.asym.sc, 1494 (unsigned) ecoff_ext.asym.index, 1495 jmptbl, cobol_main, weakext, 1496 symbol->name); 1497 1498 if (ecoffsymbol (symbol)->fdr != NULL 1499 && ecoff_ext.asym.index != indexNil) 1500 { 1501 FDR *fdr; 1502 unsigned int indx; 1503 int bigendian; 1504 bfd_size_type sym_base; 1505 union aux_ext *aux_base; 1506 1507 fdr = ecoffsymbol (symbol)->fdr; 1508 indx = ecoff_ext.asym.index; 1509 1510 /* sym_base is used to map the fdr relative indices which 1511 appear in the file to the position number which we are 1512 using. */ 1513 sym_base = fdr->isymBase; 1514 if (ecoffsymbol (symbol)->local) 1515 sym_base += 1516 ecoff_data (abfd)->debug_info.symbolic_header.iextMax; 1517 1518 /* aux_base is the start of the aux entries for this file; 1519 asym.index is an offset from this. */ 1520 aux_base = (ecoff_data (abfd)->debug_info.external_aux 1521 + fdr->iauxBase); 1522 1523 /* The aux entries are stored in host byte order; the 1524 order is indicated by a bit in the fdr. */ 1525 bigendian = fdr->fBigendian; 1526 1527 /* This switch is basically from gcc/mips-tdump.c. */ 1528 switch (ecoff_ext.asym.st) 1529 { 1530 case stNil: 1531 case stLabel: 1532 break; 1533 1534 case stFile: 1535 case stBlock: 1536 fprintf (file, _("\n End+1 symbol: %ld"), 1537 (long) (indx + sym_base)); 1538 break; 1539 1540 case stEnd: 1541 if (ecoff_ext.asym.sc == scText 1542 || ecoff_ext.asym.sc == scInfo) 1543 fprintf (file, _("\n First symbol: %ld"), 1544 (long) (indx + sym_base)); 1545 else 1546 fprintf (file, _("\n First symbol: %ld"), 1547 ((long) 1548 (AUX_GET_ISYM (bigendian, 1549 &aux_base[ecoff_ext.asym.index]) 1550 + sym_base))); 1551 break; 1552 1553 case stProc: 1554 case stStaticProc: 1555 if (ECOFF_IS_STAB (&ecoff_ext.asym)) 1556 ; 1557 else if (ecoffsymbol (symbol)->local) 1558 /* xgettext:c-format */ 1559 fprintf (file, _("\n End+1 symbol: %-7ld Type: %s"), 1560 ((long) 1561 (AUX_GET_ISYM (bigendian, 1562 &aux_base[ecoff_ext.asym.index]) 1563 + sym_base)), 1564 ecoff_type_to_string (abfd, fdr, indx + 1)); 1565 else 1566 fprintf (file, _("\n Local symbol: %ld"), 1567 ((long) indx 1568 + (long) sym_base 1569 + (ecoff_data (abfd) 1570 ->debug_info.symbolic_header.iextMax))); 1571 break; 1572 1573 case stStruct: 1574 fprintf (file, _("\n struct; End+1 symbol: %ld"), 1575 (long) (indx + sym_base)); 1576 break; 1577 1578 case stUnion: 1579 fprintf (file, _("\n union; End+1 symbol: %ld"), 1580 (long) (indx + sym_base)); 1581 break; 1582 1583 case stEnum: 1584 fprintf (file, _("\n enum; End+1 symbol: %ld"), 1585 (long) (indx + sym_base)); 1586 break; 1587 1588 default: 1589 if (! ECOFF_IS_STAB (&ecoff_ext.asym)) 1590 fprintf (file, _("\n Type: %s"), 1591 ecoff_type_to_string (abfd, fdr, indx)); 1592 break; 1593 } 1594 } 1595 } 1596 break; 1597 } 1598} 1599 1600/* Read in the relocs for a section. */ 1601 1602static bfd_boolean 1603ecoff_slurp_reloc_table (bfd *abfd, 1604 asection *section, 1605 asymbol **symbols) 1606{ 1607 const struct ecoff_backend_data * const backend = ecoff_backend (abfd); 1608 arelent *internal_relocs; 1609 bfd_size_type external_reloc_size; 1610 bfd_size_type amt; 1611 bfd_byte *external_relocs; 1612 arelent *rptr; 1613 unsigned int i; 1614 1615 if (section->relocation != NULL 1616 || section->reloc_count == 0 1617 || (section->flags & SEC_CONSTRUCTOR) != 0) 1618 return TRUE; 1619 1620 if (! _bfd_ecoff_slurp_symbol_table (abfd)) 1621 return FALSE; 1622 1623 external_reloc_size = backend->external_reloc_size; 1624 amt = external_reloc_size * section->reloc_count; 1625 if (bfd_seek (abfd, section->rel_filepos, SEEK_SET) != 0) 1626 return FALSE; 1627 external_relocs = _bfd_malloc_and_read (abfd, amt, amt); 1628 if (external_relocs == NULL) 1629 return FALSE; 1630 1631 amt = section->reloc_count; 1632 amt *= sizeof (arelent); 1633 internal_relocs = (arelent *) bfd_alloc (abfd, amt); 1634 if (internal_relocs == NULL) 1635 { 1636 free (external_relocs); 1637 return FALSE; 1638 } 1639 1640 for (i = 0, rptr = internal_relocs; i < section->reloc_count; i++, rptr++) 1641 { 1642 struct internal_reloc intern; 1643 1644 (*backend->swap_reloc_in) (abfd, 1645 external_relocs + i * external_reloc_size, 1646 &intern); 1647 1648 if (intern.r_extern) 1649 { 1650 /* r_symndx is an index into the external symbols. */ 1651 BFD_ASSERT (intern.r_symndx >= 0 1652 && (intern.r_symndx 1653 < (ecoff_data (abfd) 1654 ->debug_info.symbolic_header.iextMax))); 1655 rptr->sym_ptr_ptr = symbols + intern.r_symndx; 1656 rptr->addend = 0; 1657 } 1658 else if (intern.r_symndx == RELOC_SECTION_NONE 1659 || intern.r_symndx == RELOC_SECTION_ABS) 1660 { 1661 rptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; 1662 rptr->addend = 0; 1663 } 1664 else 1665 { 1666 const char *sec_name; 1667 asection *sec; 1668 1669 /* r_symndx is a section key. */ 1670 switch (intern.r_symndx) 1671 { 1672 case RELOC_SECTION_TEXT: sec_name = _TEXT; break; 1673 case RELOC_SECTION_RDATA: sec_name = _RDATA; break; 1674 case RELOC_SECTION_DATA: sec_name = _DATA; break; 1675 case RELOC_SECTION_SDATA: sec_name = _SDATA; break; 1676 case RELOC_SECTION_SBSS: sec_name = _SBSS; break; 1677 case RELOC_SECTION_BSS: sec_name = _BSS; break; 1678 case RELOC_SECTION_INIT: sec_name = _INIT; break; 1679 case RELOC_SECTION_LIT8: sec_name = _LIT8; break; 1680 case RELOC_SECTION_LIT4: sec_name = _LIT4; break; 1681 case RELOC_SECTION_XDATA: sec_name = _XDATA; break; 1682 case RELOC_SECTION_PDATA: sec_name = _PDATA; break; 1683 case RELOC_SECTION_FINI: sec_name = _FINI; break; 1684 case RELOC_SECTION_LITA: sec_name = _LITA; break; 1685 case RELOC_SECTION_RCONST: sec_name = _RCONST; break; 1686 default: abort (); 1687 } 1688 1689 sec = bfd_get_section_by_name (abfd, sec_name); 1690 if (sec == NULL) 1691 abort (); 1692 rptr->sym_ptr_ptr = sec->symbol_ptr_ptr; 1693 1694 rptr->addend = - bfd_section_vma (sec); 1695 } 1696 1697 rptr->address = intern.r_vaddr - bfd_section_vma (section); 1698 1699 /* Let the backend select the howto field and do any other 1700 required processing. */ 1701 (*backend->adjust_reloc_in) (abfd, &intern, rptr); 1702 } 1703 1704 free (external_relocs); 1705 1706 section->relocation = internal_relocs; 1707 1708 return TRUE; 1709} 1710 1711/* Get a canonical list of relocs. */ 1712 1713long 1714_bfd_ecoff_canonicalize_reloc (bfd *abfd, 1715 asection *section, 1716 arelent **relptr, 1717 asymbol **symbols) 1718{ 1719 unsigned int count; 1720 1721 if (section->flags & SEC_CONSTRUCTOR) 1722 { 1723 arelent_chain *chain; 1724 1725 /* This section has relocs made up by us, not the file, so take 1726 them out of their chain and place them into the data area 1727 provided. */ 1728 for (count = 0, chain = section->constructor_chain; 1729 count < section->reloc_count; 1730 count++, chain = chain->next) 1731 *relptr++ = &chain->relent; 1732 } 1733 else 1734 { 1735 arelent *tblptr; 1736 1737 if (! ecoff_slurp_reloc_table (abfd, section, symbols)) 1738 return -1; 1739 1740 tblptr = section->relocation; 1741 1742 for (count = 0; count < section->reloc_count; count++) 1743 *relptr++ = tblptr++; 1744 } 1745 1746 *relptr = NULL; 1747 1748 return section->reloc_count; 1749} 1750 1751/* Provided a BFD, a section and an offset into the section, calculate 1752 and return the name of the source file and the line nearest to the 1753 wanted location. */ 1754 1755bfd_boolean 1756_bfd_ecoff_find_nearest_line (bfd *abfd, 1757 asymbol **symbols ATTRIBUTE_UNUSED, 1758 asection *section, 1759 bfd_vma offset, 1760 const char **filename_ptr, 1761 const char **functionname_ptr, 1762 unsigned int *retline_ptr, 1763 unsigned int *discriminator_ptr) 1764{ 1765 const struct ecoff_debug_swap * const debug_swap 1766 = &ecoff_backend (abfd)->debug_swap; 1767 struct ecoff_debug_info * const debug_info = &ecoff_data (abfd)->debug_info; 1768 struct ecoff_find_line *line_info; 1769 1770 /* Make sure we have the FDR's. */ 1771 if (! _bfd_ecoff_slurp_symbolic_info (abfd, NULL, debug_info) 1772 || bfd_get_symcount (abfd) == 0) 1773 return FALSE; 1774 1775 if (ecoff_data (abfd)->find_line_info == NULL) 1776 { 1777 size_t amt = sizeof (struct ecoff_find_line); 1778 1779 ecoff_data (abfd)->find_line_info = 1780 (struct ecoff_find_line *) bfd_zalloc (abfd, amt); 1781 if (ecoff_data (abfd)->find_line_info == NULL) 1782 return FALSE; 1783 } 1784 1785 if (discriminator_ptr) 1786 *discriminator_ptr = 0; 1787 line_info = ecoff_data (abfd)->find_line_info; 1788 return _bfd_ecoff_locate_line (abfd, section, offset, debug_info, 1789 debug_swap, line_info, filename_ptr, 1790 functionname_ptr, retline_ptr); 1791} 1792 1793/* Copy private BFD data. This is called by objcopy and strip. We 1794 use it to copy the ECOFF debugging information from one BFD to the 1795 other. It would be theoretically possible to represent the ECOFF 1796 debugging information in the symbol table. However, it would be a 1797 lot of work, and there would be little gain (gas, gdb, and ld 1798 already access the ECOFF debugging information via the 1799 ecoff_debug_info structure, and that structure would have to be 1800 retained in order to support ECOFF debugging in MIPS ELF). 1801 1802 The debugging information for the ECOFF external symbols comes from 1803 the symbol table, so this function only handles the other debugging 1804 information. */ 1805 1806bfd_boolean 1807_bfd_ecoff_bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd) 1808{ 1809 struct ecoff_debug_info *iinfo = &ecoff_data (ibfd)->debug_info; 1810 struct ecoff_debug_info *oinfo = &ecoff_data (obfd)->debug_info; 1811 int i; 1812 asymbol **sym_ptr_ptr; 1813 size_t c; 1814 bfd_boolean local; 1815 1816 /* We only want to copy information over if both BFD's use ECOFF 1817 format. */ 1818 if (bfd_get_flavour (ibfd) != bfd_target_ecoff_flavour 1819 || bfd_get_flavour (obfd) != bfd_target_ecoff_flavour) 1820 return TRUE; 1821 1822 /* Copy the GP value and the register masks. */ 1823 ecoff_data (obfd)->gp = ecoff_data (ibfd)->gp; 1824 ecoff_data (obfd)->gprmask = ecoff_data (ibfd)->gprmask; 1825 ecoff_data (obfd)->fprmask = ecoff_data (ibfd)->fprmask; 1826 for (i = 0; i < 3; i++) 1827 ecoff_data (obfd)->cprmask[i] = ecoff_data (ibfd)->cprmask[i]; 1828 1829 /* Copy the version stamp. */ 1830 oinfo->symbolic_header.vstamp = iinfo->symbolic_header.vstamp; 1831 1832 /* If there are no symbols, don't copy any debugging information. */ 1833 c = bfd_get_symcount (obfd); 1834 sym_ptr_ptr = bfd_get_outsymbols (obfd); 1835 if (c == 0 || sym_ptr_ptr == NULL) 1836 return TRUE; 1837 1838 /* See if there are any local symbols. */ 1839 local = FALSE; 1840 for (; c > 0; c--, sym_ptr_ptr++) 1841 { 1842 if (ecoffsymbol (*sym_ptr_ptr)->local) 1843 { 1844 local = TRUE; 1845 break; 1846 } 1847 } 1848 1849 if (local) 1850 { 1851 /* There are some local symbols. We just bring over all the 1852 debugging information. FIXME: This is not quite the right 1853 thing to do. If the user has asked us to discard all 1854 debugging information, then we are probably going to wind up 1855 keeping it because there will probably be some local symbol 1856 which objcopy did not discard. We should actually break 1857 apart the debugging information and only keep that which 1858 applies to the symbols we want to keep. */ 1859 oinfo->symbolic_header.ilineMax = iinfo->symbolic_header.ilineMax; 1860 oinfo->symbolic_header.cbLine = iinfo->symbolic_header.cbLine; 1861 oinfo->line = iinfo->line; 1862 1863 oinfo->symbolic_header.idnMax = iinfo->symbolic_header.idnMax; 1864 oinfo->external_dnr = iinfo->external_dnr; 1865 1866 oinfo->symbolic_header.ipdMax = iinfo->symbolic_header.ipdMax; 1867 oinfo->external_pdr = iinfo->external_pdr; 1868 1869 oinfo->symbolic_header.isymMax = iinfo->symbolic_header.isymMax; 1870 oinfo->external_sym = iinfo->external_sym; 1871 1872 oinfo->symbolic_header.ioptMax = iinfo->symbolic_header.ioptMax; 1873 oinfo->external_opt = iinfo->external_opt; 1874 1875 oinfo->symbolic_header.iauxMax = iinfo->symbolic_header.iauxMax; 1876 oinfo->external_aux = iinfo->external_aux; 1877 1878 oinfo->symbolic_header.issMax = iinfo->symbolic_header.issMax; 1879 oinfo->ss = iinfo->ss; 1880 1881 oinfo->symbolic_header.ifdMax = iinfo->symbolic_header.ifdMax; 1882 oinfo->external_fdr = iinfo->external_fdr; 1883 1884 oinfo->symbolic_header.crfd = iinfo->symbolic_header.crfd; 1885 oinfo->external_rfd = iinfo->external_rfd; 1886 } 1887 else 1888 { 1889 /* We are discarding all the local symbol information. Look 1890 through the external symbols and remove all references to FDR 1891 or aux information. */ 1892 c = bfd_get_symcount (obfd); 1893 sym_ptr_ptr = bfd_get_outsymbols (obfd); 1894 for (; c > 0; c--, sym_ptr_ptr++) 1895 { 1896 EXTR esym; 1897 1898 (*(ecoff_backend (obfd)->debug_swap.swap_ext_in)) 1899 (obfd, ecoffsymbol (*sym_ptr_ptr)->native, &esym); 1900 esym.ifd = ifdNil; 1901 esym.asym.index = indexNil; 1902 (*(ecoff_backend (obfd)->debug_swap.swap_ext_out)) 1903 (obfd, &esym, ecoffsymbol (*sym_ptr_ptr)->native); 1904 } 1905 } 1906 1907 return TRUE; 1908} 1909 1910/* Set the architecture. The supported architecture is stored in the 1911 backend pointer. We always set the architecture anyhow, since many 1912 callers ignore the return value. */ 1913 1914bfd_boolean 1915_bfd_ecoff_set_arch_mach (bfd *abfd, 1916 enum bfd_architecture arch, 1917 unsigned long machine) 1918{ 1919 bfd_default_set_arch_mach (abfd, arch, machine); 1920 return arch == ecoff_backend (abfd)->arch; 1921} 1922 1923/* Get the size of the section headers. */ 1924 1925int 1926_bfd_ecoff_sizeof_headers (bfd *abfd, 1927 struct bfd_link_info *info ATTRIBUTE_UNUSED) 1928{ 1929 asection *current; 1930 int c; 1931 int ret; 1932 1933 c = 0; 1934 for (current = abfd->sections; 1935 current != NULL; 1936 current = current->next) 1937 ++c; 1938 1939 ret = (bfd_coff_filhsz (abfd) 1940 + bfd_coff_aoutsz (abfd) 1941 + c * bfd_coff_scnhsz (abfd)); 1942 return (int) BFD_ALIGN (ret, 16); 1943} 1944 1945/* Get the contents of a section. */ 1946 1947bfd_boolean 1948_bfd_ecoff_get_section_contents (bfd *abfd, 1949 asection *section, 1950 void * location, 1951 file_ptr offset, 1952 bfd_size_type count) 1953{ 1954 return _bfd_generic_get_section_contents (abfd, section, location, 1955 offset, count); 1956} 1957 1958/* Sort sections by VMA, but put SEC_ALLOC sections first. This is 1959 called via qsort. */ 1960 1961static int 1962ecoff_sort_hdrs (const void * arg1, const void * arg2) 1963{ 1964 const asection *hdr1 = *(const asection **) arg1; 1965 const asection *hdr2 = *(const asection **) arg2; 1966 1967 if ((hdr1->flags & SEC_ALLOC) != 0) 1968 { 1969 if ((hdr2->flags & SEC_ALLOC) == 0) 1970 return -1; 1971 } 1972 else 1973 { 1974 if ((hdr2->flags & SEC_ALLOC) != 0) 1975 return 1; 1976 } 1977 if (hdr1->vma < hdr2->vma) 1978 return -1; 1979 else if (hdr1->vma > hdr2->vma) 1980 return 1; 1981 else 1982 return 0; 1983} 1984 1985/* Calculate the file position for each section, and set 1986 reloc_filepos. */ 1987 1988static bfd_boolean 1989ecoff_compute_section_file_positions (bfd *abfd) 1990{ 1991 file_ptr sofar, file_sofar; 1992 asection **sorted_hdrs; 1993 asection *current; 1994 unsigned int i; 1995 file_ptr old_sofar; 1996 bfd_boolean rdata_in_text; 1997 bfd_boolean first_data, first_nonalloc; 1998 const bfd_vma round = ecoff_backend (abfd)->round; 1999 bfd_size_type amt; 2000 2001 sofar = _bfd_ecoff_sizeof_headers (abfd, NULL); 2002 file_sofar = sofar; 2003 2004 /* Sort the sections by VMA. */ 2005 amt = abfd->section_count; 2006 amt *= sizeof (asection *); 2007 sorted_hdrs = (asection **) bfd_malloc (amt); 2008 if (sorted_hdrs == NULL) 2009 return FALSE; 2010 for (current = abfd->sections, i = 0; 2011 current != NULL; 2012 current = current->next, i++) 2013 sorted_hdrs[i] = current; 2014 BFD_ASSERT (i == abfd->section_count); 2015 2016 qsort (sorted_hdrs, abfd->section_count, sizeof (asection *), 2017 ecoff_sort_hdrs); 2018 2019 /* Some versions of the OSF linker put the .rdata section in the 2020 text segment, and some do not. */ 2021 rdata_in_text = ecoff_backend (abfd)->rdata_in_text; 2022 if (rdata_in_text) 2023 { 2024 for (i = 0; i < abfd->section_count; i++) 2025 { 2026 current = sorted_hdrs[i]; 2027 if (streq (current->name, _RDATA)) 2028 break; 2029 if ((current->flags & SEC_CODE) == 0 2030 && ! streq (current->name, _PDATA) 2031 && ! streq (current->name, _RCONST)) 2032 { 2033 rdata_in_text = FALSE; 2034 break; 2035 } 2036 } 2037 } 2038 ecoff_data (abfd)->rdata_in_text = rdata_in_text; 2039 2040 first_data = TRUE; 2041 first_nonalloc = TRUE; 2042 for (i = 0; i < abfd->section_count; i++) 2043 { 2044 unsigned int alignment_power; 2045 2046 current = sorted_hdrs[i]; 2047 2048 /* For the Alpha ECOFF .pdata section the lnnoptr field is 2049 supposed to indicate the number of .pdata entries that are 2050 really in the section. Each entry is 8 bytes. We store this 2051 away in line_filepos before increasing the section size. */ 2052 if (streq (current->name, _PDATA)) 2053 current->line_filepos = current->size / 8; 2054 2055 alignment_power = current->alignment_power; 2056 2057 /* On Ultrix, the data sections in an executable file must be 2058 aligned to a page boundary within the file. This does not 2059 affect the section size, though. FIXME: Does this work for 2060 other platforms? It requires some modification for the 2061 Alpha, because .rdata on the Alpha goes with the text, not 2062 the data. */ 2063 if ((abfd->flags & EXEC_P) != 0 2064 && (abfd->flags & D_PAGED) != 0 2065 && ! first_data 2066 && (current->flags & SEC_CODE) == 0 2067 && (! rdata_in_text 2068 || ! streq (current->name, _RDATA)) 2069 && ! streq (current->name, _PDATA) 2070 && ! streq (current->name, _RCONST)) 2071 { 2072 sofar = (sofar + round - 1) &~ (round - 1); 2073 file_sofar = (file_sofar + round - 1) &~ (round - 1); 2074 first_data = FALSE; 2075 } 2076 else if (streq (current->name, _LIB)) 2077 { 2078 /* On Irix 4, the location of contents of the .lib section 2079 from a shared library section is also rounded up to a 2080 page boundary. */ 2081 2082 sofar = (sofar + round - 1) &~ (round - 1); 2083 file_sofar = (file_sofar + round - 1) &~ (round - 1); 2084 } 2085 else if (first_nonalloc 2086 && (current->flags & SEC_ALLOC) == 0 2087 && (abfd->flags & D_PAGED) != 0) 2088 { 2089 /* Skip up to the next page for an unallocated section, such 2090 as the .comment section on the Alpha. This leaves room 2091 for the .bss section. */ 2092 first_nonalloc = FALSE; 2093 sofar = (sofar + round - 1) &~ (round - 1); 2094 file_sofar = (file_sofar + round - 1) &~ (round - 1); 2095 } 2096 2097 /* Align the sections in the file to the same boundary on 2098 which they are aligned in virtual memory. */ 2099 sofar = BFD_ALIGN (sofar, 1 << alignment_power); 2100 if ((current->flags & SEC_HAS_CONTENTS) != 0) 2101 file_sofar = BFD_ALIGN (file_sofar, 1 << alignment_power); 2102 2103 if ((abfd->flags & D_PAGED) != 0 2104 && (current->flags & SEC_ALLOC) != 0) 2105 { 2106 sofar += (current->vma - sofar) % round; 2107 if ((current->flags & SEC_HAS_CONTENTS) != 0) 2108 file_sofar += (current->vma - file_sofar) % round; 2109 } 2110 2111 if ((current->flags & (SEC_HAS_CONTENTS | SEC_LOAD)) != 0) 2112 current->filepos = file_sofar; 2113 2114 sofar += current->size; 2115 if ((current->flags & SEC_HAS_CONTENTS) != 0) 2116 file_sofar += current->size; 2117 2118 /* Make sure that this section is of the right size too. */ 2119 old_sofar = sofar; 2120 sofar = BFD_ALIGN (sofar, 1 << alignment_power); 2121 if ((current->flags & SEC_HAS_CONTENTS) != 0) 2122 file_sofar = BFD_ALIGN (file_sofar, 1 << alignment_power); 2123 current->size += sofar - old_sofar; 2124 } 2125 2126 free (sorted_hdrs); 2127 sorted_hdrs = NULL; 2128 2129 ecoff_data (abfd)->reloc_filepos = file_sofar; 2130 2131 return TRUE; 2132} 2133 2134/* Determine the location of the relocs for all the sections in the 2135 output file, as well as the location of the symbolic debugging 2136 information. */ 2137 2138static bfd_size_type 2139ecoff_compute_reloc_file_positions (bfd *abfd) 2140{ 2141 const bfd_size_type external_reloc_size = 2142 ecoff_backend (abfd)->external_reloc_size; 2143 file_ptr reloc_base; 2144 bfd_size_type reloc_size; 2145 asection *current; 2146 file_ptr sym_base; 2147 2148 if (! abfd->output_has_begun) 2149 { 2150 if (! ecoff_compute_section_file_positions (abfd)) 2151 abort (); 2152 abfd->output_has_begun = TRUE; 2153 } 2154 2155 reloc_base = ecoff_data (abfd)->reloc_filepos; 2156 2157 reloc_size = 0; 2158 for (current = abfd->sections; 2159 current != NULL; 2160 current = current->next) 2161 { 2162 if (current->reloc_count == 0) 2163 current->rel_filepos = 0; 2164 else 2165 { 2166 bfd_size_type relsize; 2167 2168 current->rel_filepos = reloc_base; 2169 relsize = current->reloc_count * external_reloc_size; 2170 reloc_size += relsize; 2171 reloc_base += relsize; 2172 } 2173 } 2174 2175 sym_base = ecoff_data (abfd)->reloc_filepos + reloc_size; 2176 2177 /* At least on Ultrix, the symbol table of an executable file must 2178 be aligned to a page boundary. FIXME: Is this true on other 2179 platforms? */ 2180 if ((abfd->flags & EXEC_P) != 0 2181 && (abfd->flags & D_PAGED) != 0) 2182 sym_base = ((sym_base + ecoff_backend (abfd)->round - 1) 2183 &~ (ecoff_backend (abfd)->round - 1)); 2184 2185 ecoff_data (abfd)->sym_filepos = sym_base; 2186 2187 return reloc_size; 2188} 2189 2190/* Set the contents of a section. */ 2191 2192bfd_boolean 2193_bfd_ecoff_set_section_contents (bfd *abfd, 2194 asection *section, 2195 const void * location, 2196 file_ptr offset, 2197 bfd_size_type count) 2198{ 2199 file_ptr pos; 2200 2201 /* This must be done first, because bfd_set_section_contents is 2202 going to set output_has_begun to TRUE. */ 2203 if (! abfd->output_has_begun 2204 && ! ecoff_compute_section_file_positions (abfd)) 2205 return FALSE; 2206 2207 /* Handle the .lib section specially so that Irix 4 shared libraries 2208 work out. See coff_set_section_contents in coffcode.h. */ 2209 if (streq (section->name, _LIB)) 2210 { 2211 bfd_byte *rec, *recend; 2212 2213 rec = (bfd_byte *) location; 2214 recend = rec + count; 2215 while (rec < recend) 2216 { 2217 ++section->lma; 2218 rec += bfd_get_32 (abfd, rec) * 4; 2219 } 2220 2221 BFD_ASSERT (rec == recend); 2222 } 2223 2224 if (count == 0) 2225 return TRUE; 2226 2227 pos = section->filepos + offset; 2228 if (bfd_seek (abfd, pos, SEEK_SET) != 0 2229 || bfd_bwrite (location, count, abfd) != count) 2230 return FALSE; 2231 2232 return TRUE; 2233} 2234 2235/* Set the GP value for an ECOFF file. This is a hook used by the 2236 assembler. */ 2237 2238bfd_boolean 2239bfd_ecoff_set_gp_value (bfd *abfd, bfd_vma gp_value) 2240{ 2241 if (bfd_get_flavour (abfd) != bfd_target_ecoff_flavour 2242 || bfd_get_format (abfd) != bfd_object) 2243 { 2244 bfd_set_error (bfd_error_invalid_operation); 2245 return FALSE; 2246 } 2247 2248 ecoff_data (abfd)->gp = gp_value; 2249 2250 return TRUE; 2251} 2252 2253/* Set the register masks for an ECOFF file. This is a hook used by 2254 the assembler. */ 2255 2256bfd_boolean 2257bfd_ecoff_set_regmasks (bfd *abfd, 2258 unsigned long gprmask, 2259 unsigned long fprmask, 2260 unsigned long *cprmask) 2261{ 2262 ecoff_data_type *tdata; 2263 2264 if (bfd_get_flavour (abfd) != bfd_target_ecoff_flavour 2265 || bfd_get_format (abfd) != bfd_object) 2266 { 2267 bfd_set_error (bfd_error_invalid_operation); 2268 return FALSE; 2269 } 2270 2271 tdata = ecoff_data (abfd); 2272 tdata->gprmask = gprmask; 2273 tdata->fprmask = fprmask; 2274 if (cprmask != NULL) 2275 { 2276 int i; 2277 2278 for (i = 0; i < 3; i++) 2279 tdata->cprmask[i] = cprmask[i]; 2280 } 2281 2282 return TRUE; 2283} 2284 2285/* Get ECOFF EXTR information for an external symbol. This function 2286 is passed to bfd_ecoff_debug_externals. */ 2287 2288static bfd_boolean 2289ecoff_get_extr (asymbol *sym, EXTR *esym) 2290{ 2291 ecoff_symbol_type *ecoff_sym_ptr; 2292 bfd *input_bfd; 2293 2294 if (bfd_asymbol_flavour (sym) != bfd_target_ecoff_flavour 2295 || ecoffsymbol (sym)->native == NULL) 2296 { 2297 /* Don't include debugging, local, or section symbols. */ 2298 if ((sym->flags & BSF_DEBUGGING) != 0 2299 || (sym->flags & BSF_LOCAL) != 0 2300 || (sym->flags & BSF_SECTION_SYM) != 0) 2301 return FALSE; 2302 2303 esym->jmptbl = 0; 2304 esym->cobol_main = 0; 2305 esym->weakext = (sym->flags & BSF_WEAK) != 0; 2306 esym->reserved = 0; 2307 esym->ifd = ifdNil; 2308 /* FIXME: we can do better than this for st and sc. */ 2309 esym->asym.st = stGlobal; 2310 esym->asym.sc = scAbs; 2311 esym->asym.reserved = 0; 2312 esym->asym.index = indexNil; 2313 return TRUE; 2314 } 2315 2316 ecoff_sym_ptr = ecoffsymbol (sym); 2317 2318 if (ecoff_sym_ptr->local) 2319 return FALSE; 2320 2321 input_bfd = bfd_asymbol_bfd (sym); 2322 (*(ecoff_backend (input_bfd)->debug_swap.swap_ext_in)) 2323 (input_bfd, ecoff_sym_ptr->native, esym); 2324 2325 /* If the symbol was defined by the linker, then esym will be 2326 undefined but sym will not be. Get a better class for such a 2327 symbol. */ 2328 if ((esym->asym.sc == scUndefined 2329 || esym->asym.sc == scSUndefined) 2330 && ! bfd_is_und_section (bfd_asymbol_section (sym))) 2331 esym->asym.sc = scAbs; 2332 2333 /* Adjust the FDR index for the symbol by that used for the input 2334 BFD. */ 2335 if (esym->ifd != -1) 2336 { 2337 struct ecoff_debug_info *input_debug; 2338 2339 input_debug = &ecoff_data (input_bfd)->debug_info; 2340 BFD_ASSERT (esym->ifd < input_debug->symbolic_header.ifdMax); 2341 if (input_debug->ifdmap != NULL) 2342 esym->ifd = input_debug->ifdmap[esym->ifd]; 2343 } 2344 2345 return TRUE; 2346} 2347 2348/* Set the external symbol index. This routine is passed to 2349 bfd_ecoff_debug_externals. */ 2350 2351static void 2352ecoff_set_index (asymbol *sym, bfd_size_type indx) 2353{ 2354 ecoff_set_sym_index (sym, indx); 2355} 2356 2357/* Write out an ECOFF file. */ 2358 2359bfd_boolean 2360_bfd_ecoff_write_object_contents (bfd *abfd) 2361{ 2362 const struct ecoff_backend_data * const backend = ecoff_backend (abfd); 2363 const bfd_vma round = backend->round; 2364 const bfd_size_type filhsz = bfd_coff_filhsz (abfd); 2365 const bfd_size_type aoutsz = bfd_coff_aoutsz (abfd); 2366 const bfd_size_type scnhsz = bfd_coff_scnhsz (abfd); 2367 const bfd_size_type external_hdr_size 2368 = backend->debug_swap.external_hdr_size; 2369 const bfd_size_type external_reloc_size = backend->external_reloc_size; 2370 void (* const adjust_reloc_out) (bfd *, const arelent *, struct internal_reloc *) 2371 = backend->adjust_reloc_out; 2372 void (* const swap_reloc_out) (bfd *, const struct internal_reloc *, void *) 2373 = backend->swap_reloc_out; 2374 struct ecoff_debug_info * const debug = &ecoff_data (abfd)->debug_info; 2375 HDRR * const symhdr = &debug->symbolic_header; 2376 asection *current; 2377 unsigned int count; 2378 bfd_size_type reloc_size; 2379 bfd_size_type text_size; 2380 bfd_vma text_start; 2381 bfd_boolean set_text_start; 2382 bfd_size_type data_size; 2383 bfd_vma data_start; 2384 bfd_boolean set_data_start; 2385 bfd_size_type bss_size; 2386 void * buff = NULL; 2387 void * reloc_buff = NULL; 2388 struct internal_filehdr internal_f; 2389 struct internal_aouthdr internal_a; 2390 int i; 2391 2392 /* Determine where the sections and relocs will go in the output 2393 file. */ 2394 reloc_size = ecoff_compute_reloc_file_positions (abfd); 2395 2396 count = 1; 2397 for (current = abfd->sections; 2398 current != NULL; 2399 current = current->next) 2400 { 2401 current->target_index = count; 2402 ++count; 2403 } 2404 2405 if ((abfd->flags & D_PAGED) != 0) 2406 text_size = _bfd_ecoff_sizeof_headers (abfd, NULL); 2407 else 2408 text_size = 0; 2409 text_start = 0; 2410 set_text_start = FALSE; 2411 data_size = 0; 2412 data_start = 0; 2413 set_data_start = FALSE; 2414 bss_size = 0; 2415 2416 /* Write section headers to the file. */ 2417 2418 /* Allocate buff big enough to hold a section header, 2419 file header, or a.out header. */ 2420 { 2421 bfd_size_type siz; 2422 2423 siz = scnhsz; 2424 if (siz < filhsz) 2425 siz = filhsz; 2426 if (siz < aoutsz) 2427 siz = aoutsz; 2428 buff = bfd_malloc (siz); 2429 if (buff == NULL) 2430 goto error_return; 2431 } 2432 2433 internal_f.f_nscns = 0; 2434 if (bfd_seek (abfd, (file_ptr) (filhsz + aoutsz), SEEK_SET) != 0) 2435 goto error_return; 2436 2437 for (current = abfd->sections; 2438 current != NULL; 2439 current = current->next) 2440 { 2441 struct internal_scnhdr section; 2442 bfd_vma vma; 2443 2444 ++internal_f.f_nscns; 2445 2446 strncpy (section.s_name, current->name, sizeof section.s_name); 2447 2448 /* This seems to be correct for Irix 4 shared libraries. */ 2449 vma = bfd_section_vma (current); 2450 if (streq (current->name, _LIB)) 2451 section.s_vaddr = 0; 2452 else 2453 section.s_vaddr = vma; 2454 2455 section.s_paddr = current->lma; 2456 section.s_size = current->size; 2457 2458 /* If this section is unloadable then the scnptr will be 0. */ 2459 if ((current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0) 2460 section.s_scnptr = 0; 2461 else 2462 section.s_scnptr = current->filepos; 2463 section.s_relptr = current->rel_filepos; 2464 2465 /* FIXME: the lnnoptr of the .sbss or .sdata section of an 2466 object file produced by the assembler is supposed to point to 2467 information about how much room is required by objects of 2468 various different sizes. I think this only matters if we 2469 want the linker to compute the best size to use, or 2470 something. I don't know what happens if the information is 2471 not present. */ 2472 if (! streq (current->name, _PDATA)) 2473 section.s_lnnoptr = 0; 2474 else 2475 { 2476 /* The Alpha ECOFF .pdata section uses the lnnoptr field to 2477 hold the number of entries in the section (each entry is 2478 8 bytes). We stored this in the line_filepos field in 2479 ecoff_compute_section_file_positions. */ 2480 section.s_lnnoptr = current->line_filepos; 2481 } 2482 2483 section.s_nreloc = current->reloc_count; 2484 section.s_nlnno = 0; 2485 section.s_flags = ecoff_sec_to_styp_flags (current->name, 2486 current->flags); 2487 2488 if (bfd_coff_swap_scnhdr_out (abfd, (void *) §ion, buff) == 0 2489 || bfd_bwrite (buff, scnhsz, abfd) != scnhsz) 2490 goto error_return; 2491 2492 if ((section.s_flags & STYP_TEXT) != 0 2493 || ((section.s_flags & STYP_RDATA) != 0 2494 && ecoff_data (abfd)->rdata_in_text) 2495 || section.s_flags == STYP_PDATA 2496 || (section.s_flags & STYP_DYNAMIC) != 0 2497 || (section.s_flags & STYP_LIBLIST) != 0 2498 || (section.s_flags & STYP_RELDYN) != 0 2499 || section.s_flags == STYP_CONFLIC 2500 || (section.s_flags & STYP_DYNSTR) != 0 2501 || (section.s_flags & STYP_DYNSYM) != 0 2502 || (section.s_flags & STYP_HASH) != 0 2503 || (section.s_flags & STYP_ECOFF_INIT) != 0 2504 || (section.s_flags & STYP_ECOFF_FINI) != 0 2505 || section.s_flags == STYP_RCONST) 2506 { 2507 text_size += current->size; 2508 if (! set_text_start || text_start > vma) 2509 { 2510 text_start = vma; 2511 set_text_start = TRUE; 2512 } 2513 } 2514 else if ((section.s_flags & STYP_RDATA) != 0 2515 || (section.s_flags & STYP_DATA) != 0 2516 || (section.s_flags & STYP_LITA) != 0 2517 || (section.s_flags & STYP_LIT8) != 0 2518 || (section.s_flags & STYP_LIT4) != 0 2519 || (section.s_flags & STYP_SDATA) != 0 2520 || section.s_flags == STYP_XDATA 2521 || (section.s_flags & STYP_GOT) != 0) 2522 { 2523 data_size += current->size; 2524 if (! set_data_start || data_start > vma) 2525 { 2526 data_start = vma; 2527 set_data_start = TRUE; 2528 } 2529 } 2530 else if ((section.s_flags & STYP_BSS) != 0 2531 || (section.s_flags & STYP_SBSS) != 0) 2532 bss_size += current->size; 2533 else if (section.s_flags == 0 2534 || (section.s_flags & STYP_ECOFF_LIB) != 0 2535 || section.s_flags == STYP_COMMENT) 2536 /* Do nothing. */ ; 2537 else 2538 abort (); 2539 } 2540 2541 /* Set up the file header. */ 2542 internal_f.f_magic = ecoff_get_magic (abfd); 2543 2544 /* We will NOT put a fucking timestamp in the header here. Every 2545 time you put it back, I will come in and take it out again. I'm 2546 sorry. This field does not belong here. We fill it with a 0 so 2547 it compares the same but is not a reasonable time. -- 2548 gnu@cygnus.com. */ 2549 internal_f.f_timdat = 0; 2550 2551 if (bfd_get_symcount (abfd) != 0) 2552 { 2553 /* The ECOFF f_nsyms field is not actually the number of 2554 symbols, it's the size of symbolic information header. */ 2555 internal_f.f_nsyms = external_hdr_size; 2556 internal_f.f_symptr = ecoff_data (abfd)->sym_filepos; 2557 } 2558 else 2559 { 2560 internal_f.f_nsyms = 0; 2561 internal_f.f_symptr = 0; 2562 } 2563 2564 internal_f.f_opthdr = aoutsz; 2565 2566 internal_f.f_flags = F_LNNO; 2567 if (reloc_size == 0) 2568 internal_f.f_flags |= F_RELFLG; 2569 if (bfd_get_symcount (abfd) == 0) 2570 internal_f.f_flags |= F_LSYMS; 2571 if (abfd->flags & EXEC_P) 2572 internal_f.f_flags |= F_EXEC; 2573 2574 if (bfd_little_endian (abfd)) 2575 internal_f.f_flags |= F_AR32WR; 2576 else 2577 internal_f.f_flags |= F_AR32W; 2578 2579 /* Set up the ``optional'' header. */ 2580 if ((abfd->flags & D_PAGED) != 0) 2581 internal_a.magic = ECOFF_AOUT_ZMAGIC; 2582 else 2583 internal_a.magic = ECOFF_AOUT_OMAGIC; 2584 2585 /* FIXME: Is this really correct? */ 2586 internal_a.vstamp = symhdr->vstamp; 2587 2588 /* At least on Ultrix, these have to be rounded to page boundaries. 2589 FIXME: Is this true on other platforms? */ 2590 if ((abfd->flags & D_PAGED) != 0) 2591 { 2592 internal_a.tsize = (text_size + round - 1) &~ (round - 1); 2593 internal_a.text_start = text_start &~ (round - 1); 2594 internal_a.dsize = (data_size + round - 1) &~ (round - 1); 2595 internal_a.data_start = data_start &~ (round - 1); 2596 } 2597 else 2598 { 2599 internal_a.tsize = text_size; 2600 internal_a.text_start = text_start; 2601 internal_a.dsize = data_size; 2602 internal_a.data_start = data_start; 2603 } 2604 2605 /* On Ultrix, the initial portions of the .sbss and .bss segments 2606 are at the end of the data section. The bsize field in the 2607 optional header records how many bss bytes are required beyond 2608 those in the data section. The value is not rounded to a page 2609 boundary. */ 2610 if (bss_size < internal_a.dsize - data_size) 2611 bss_size = 0; 2612 else 2613 bss_size -= internal_a.dsize - data_size; 2614 internal_a.bsize = bss_size; 2615 internal_a.bss_start = internal_a.data_start + internal_a.dsize; 2616 2617 internal_a.entry = bfd_get_start_address (abfd); 2618 2619 internal_a.gp_value = ecoff_data (abfd)->gp; 2620 2621 internal_a.gprmask = ecoff_data (abfd)->gprmask; 2622 internal_a.fprmask = ecoff_data (abfd)->fprmask; 2623 for (i = 0; i < 4; i++) 2624 internal_a.cprmask[i] = ecoff_data (abfd)->cprmask[i]; 2625 2626 /* Let the backend adjust the headers if necessary. */ 2627 if (backend->adjust_headers) 2628 { 2629 if (! (*backend->adjust_headers) (abfd, &internal_f, &internal_a)) 2630 goto error_return; 2631 } 2632 2633 /* Write out the file header and the optional header. */ 2634 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) 2635 goto error_return; 2636 2637 bfd_coff_swap_filehdr_out (abfd, (void *) &internal_f, buff); 2638 if (bfd_bwrite (buff, filhsz, abfd) != filhsz) 2639 goto error_return; 2640 2641 bfd_coff_swap_aouthdr_out (abfd, (void *) &internal_a, buff); 2642 if (bfd_bwrite (buff, aoutsz, abfd) != aoutsz) 2643 goto error_return; 2644 2645 /* Build the external symbol information. This must be done before 2646 writing out the relocs so that we know the symbol indices. We 2647 don't do this if this BFD was created by the backend linker, 2648 since it will have already handled the symbols and relocs. */ 2649 if (! ecoff_data (abfd)->linker) 2650 { 2651 symhdr->iextMax = 0; 2652 symhdr->issExtMax = 0; 2653 debug->external_ext = debug->external_ext_end = NULL; 2654 debug->ssext = debug->ssext_end = NULL; 2655 if (! bfd_ecoff_debug_externals (abfd, debug, &backend->debug_swap, 2656 (abfd->flags & EXEC_P) == 0, 2657 ecoff_get_extr, ecoff_set_index)) 2658 goto error_return; 2659 2660 /* Write out the relocs. */ 2661 for (current = abfd->sections; 2662 current != NULL; 2663 current = current->next) 2664 { 2665 arelent **reloc_ptr_ptr; 2666 arelent **reloc_end; 2667 char *out_ptr; 2668 bfd_size_type amt; 2669 2670 if (current->reloc_count == 0) 2671 continue; 2672 2673 amt = current->reloc_count * external_reloc_size; 2674 reloc_buff = bfd_alloc (abfd, amt); 2675 if (reloc_buff == NULL) 2676 goto error_return; 2677 2678 reloc_ptr_ptr = current->orelocation; 2679 reloc_end = reloc_ptr_ptr + current->reloc_count; 2680 out_ptr = (char *) reloc_buff; 2681 2682 for (; 2683 reloc_ptr_ptr < reloc_end; 2684 reloc_ptr_ptr++, out_ptr += external_reloc_size) 2685 { 2686 arelent *reloc; 2687 asymbol *sym; 2688 struct internal_reloc in; 2689 2690 memset ((void *) &in, 0, sizeof in); 2691 2692 reloc = *reloc_ptr_ptr; 2693 sym = *reloc->sym_ptr_ptr; 2694 2695 /* If the howto field has not been initialised then skip this reloc. 2696 This assumes that an error message has been issued elsewhere. */ 2697 if (reloc->howto == NULL) 2698 continue; 2699 2700 in.r_vaddr = reloc->address + bfd_section_vma (current); 2701 in.r_type = reloc->howto->type; 2702 2703 if ((sym->flags & BSF_SECTION_SYM) == 0) 2704 { 2705 in.r_symndx = ecoff_get_sym_index (*reloc->sym_ptr_ptr); 2706 in.r_extern = 1; 2707 } 2708 else 2709 { 2710 const char *name; 2711 unsigned int j; 2712 static struct 2713 { 2714 const char * name; 2715 long r_symndx; 2716 } 2717 section_symndx [] = 2718 { 2719 { _TEXT, RELOC_SECTION_TEXT }, 2720 { _RDATA, RELOC_SECTION_RDATA }, 2721 { _DATA, RELOC_SECTION_DATA }, 2722 { _SDATA, RELOC_SECTION_SDATA }, 2723 { _SBSS, RELOC_SECTION_SBSS }, 2724 { _BSS, RELOC_SECTION_BSS }, 2725 { _INIT, RELOC_SECTION_INIT }, 2726 { _LIT8, RELOC_SECTION_LIT8 }, 2727 { _LIT4, RELOC_SECTION_LIT4 }, 2728 { _XDATA, RELOC_SECTION_XDATA }, 2729 { _PDATA, RELOC_SECTION_PDATA }, 2730 { _FINI, RELOC_SECTION_FINI }, 2731 { _LITA, RELOC_SECTION_LITA }, 2732 { "*ABS*", RELOC_SECTION_ABS }, 2733 { _RCONST, RELOC_SECTION_RCONST } 2734 }; 2735 2736 name = bfd_section_name (bfd_asymbol_section (sym)); 2737 2738 for (j = 0; j < ARRAY_SIZE (section_symndx); j++) 2739 if (streq (name, section_symndx[j].name)) 2740 { 2741 in.r_symndx = section_symndx[j].r_symndx; 2742 break; 2743 } 2744 2745 if (j == ARRAY_SIZE (section_symndx)) 2746 abort (); 2747 in.r_extern = 0; 2748 } 2749 2750 (*adjust_reloc_out) (abfd, reloc, &in); 2751 2752 (*swap_reloc_out) (abfd, &in, (void *) out_ptr); 2753 } 2754 2755 if (bfd_seek (abfd, current->rel_filepos, SEEK_SET) != 0) 2756 goto error_return; 2757 amt = current->reloc_count * external_reloc_size; 2758 if (bfd_bwrite (reloc_buff, amt, abfd) != amt) 2759 goto error_return; 2760 bfd_release (abfd, reloc_buff); 2761 reloc_buff = NULL; 2762 } 2763 2764 /* Write out the symbolic debugging information. */ 2765 if (bfd_get_symcount (abfd) > 0) 2766 { 2767 /* Write out the debugging information. */ 2768 if (! bfd_ecoff_write_debug (abfd, debug, &backend->debug_swap, 2769 ecoff_data (abfd)->sym_filepos)) 2770 goto error_return; 2771 } 2772 } 2773 2774 /* The .bss section of a demand paged executable must receive an 2775 entire page. If there are symbols, the symbols will start on the 2776 next page. If there are no symbols, we must fill out the page by 2777 hand. */ 2778 if (bfd_get_symcount (abfd) == 0 2779 && (abfd->flags & EXEC_P) != 0 2780 && (abfd->flags & D_PAGED) != 0) 2781 { 2782 char c; 2783 2784 if (bfd_seek (abfd, (file_ptr) ecoff_data (abfd)->sym_filepos - 1, 2785 SEEK_SET) != 0) 2786 goto error_return; 2787 if (bfd_bread (&c, (bfd_size_type) 1, abfd) == 0) 2788 c = 0; 2789 if (bfd_seek (abfd, (file_ptr) ecoff_data (abfd)->sym_filepos - 1, 2790 SEEK_SET) != 0) 2791 goto error_return; 2792 if (bfd_bwrite (&c, (bfd_size_type) 1, abfd) != 1) 2793 goto error_return; 2794 } 2795 2796 if (reloc_buff != NULL) 2797 bfd_release (abfd, reloc_buff); 2798 free (buff); 2799 return TRUE; 2800 error_return: 2801 if (reloc_buff != NULL) 2802 bfd_release (abfd, reloc_buff); 2803 free (buff); 2804 return FALSE; 2805} 2806 2807/* Archive handling. ECOFF uses what appears to be a unique type of 2808 archive header (armap). The byte ordering of the armap and the 2809 contents are encoded in the name of the armap itself. At least for 2810 now, we only support archives with the same byte ordering in the 2811 armap and the contents. 2812 2813 The first four bytes in the armap are the number of symbol 2814 definitions. This is always a power of two. 2815 2816 This is followed by the symbol definitions. Each symbol definition 2817 occupies 8 bytes. The first four bytes are the offset from the 2818 start of the armap strings to the null-terminated string naming 2819 this symbol. The second four bytes are the file offset to the 2820 archive member which defines this symbol. If the second four bytes 2821 are 0, then this is not actually a symbol definition, and it should 2822 be ignored. 2823 2824 The symbols are hashed into the armap with a closed hashing scheme. 2825 See the functions below for the details of the algorithm. 2826 2827 After the symbol definitions comes four bytes holding the size of 2828 the string table, followed by the string table itself. */ 2829 2830/* The name of an archive headers looks like this: 2831 __________E[BL]E[BL]_ (with a trailing space). 2832 The trailing space is changed to an X if the archive is changed to 2833 indicate that the armap is out of date. 2834 2835 The Alpha seems to use ________64E[BL]E[BL]_. */ 2836 2837#define ARMAP_BIG_ENDIAN 'B' 2838#define ARMAP_LITTLE_ENDIAN 'L' 2839#define ARMAP_MARKER 'E' 2840#define ARMAP_START_LENGTH 10 2841#define ARMAP_HEADER_MARKER_INDEX 10 2842#define ARMAP_HEADER_ENDIAN_INDEX 11 2843#define ARMAP_OBJECT_MARKER_INDEX 12 2844#define ARMAP_OBJECT_ENDIAN_INDEX 13 2845#define ARMAP_END_INDEX 14 2846#define ARMAP_END "_ " 2847 2848/* This is a magic number used in the hashing algorithm. */ 2849#define ARMAP_HASH_MAGIC 0x9dd68ab5 2850 2851/* This returns the hash value to use for a string. It also sets 2852 *REHASH to the rehash adjustment if the first slot is taken. SIZE 2853 is the number of entries in the hash table, and HLOG is the log 2854 base 2 of SIZE. */ 2855 2856static unsigned int 2857ecoff_armap_hash (const char *s, 2858 unsigned int *rehash, 2859 unsigned int size, 2860 unsigned int hlog) 2861{ 2862 unsigned int hash; 2863 2864 if (hlog == 0) 2865 return 0; 2866 hash = *s++; 2867 while (*s != '\0') 2868 hash = ((hash >> 27) | (hash << 5)) + *s++; 2869 hash *= ARMAP_HASH_MAGIC; 2870 *rehash = (hash & (size - 1)) | 1; 2871 return hash >> (32 - hlog); 2872} 2873 2874/* Read in the armap. */ 2875 2876bfd_boolean 2877_bfd_ecoff_slurp_armap (bfd *abfd) 2878{ 2879 char nextname[17]; 2880 unsigned int i; 2881 struct areltdata *mapdata; 2882 bfd_size_type parsed_size, stringsize; 2883 char *raw_armap; 2884 struct artdata *ardata; 2885 unsigned int count; 2886 char *raw_ptr; 2887 carsym *symdef_ptr; 2888 char *stringbase; 2889 bfd_size_type amt; 2890 2891 /* Get the name of the first element. */ 2892 i = bfd_bread ((void *) nextname, (bfd_size_type) 16, abfd); 2893 if (i == 0) 2894 return TRUE; 2895 if (i != 16) 2896 return FALSE; 2897 2898 if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0) 2899 return FALSE; 2900 2901 /* Irix 4.0.5F apparently can use either an ECOFF armap or a 2902 standard COFF armap. We could move the ECOFF armap stuff into 2903 bfd_slurp_armap, but that seems inappropriate since no other 2904 target uses this format. Instead, we check directly for a COFF 2905 armap. */ 2906 if (CONST_STRNEQ (nextname, "/ ")) 2907 return bfd_slurp_armap (abfd); 2908 2909 /* See if the first element is an armap. */ 2910 if (! strneq (nextname, ecoff_backend (abfd)->armap_start, ARMAP_START_LENGTH) 2911 || nextname[ARMAP_HEADER_MARKER_INDEX] != ARMAP_MARKER 2912 || (nextname[ARMAP_HEADER_ENDIAN_INDEX] != ARMAP_BIG_ENDIAN 2913 && nextname[ARMAP_HEADER_ENDIAN_INDEX] != ARMAP_LITTLE_ENDIAN) 2914 || nextname[ARMAP_OBJECT_MARKER_INDEX] != ARMAP_MARKER 2915 || (nextname[ARMAP_OBJECT_ENDIAN_INDEX] != ARMAP_BIG_ENDIAN 2916 && nextname[ARMAP_OBJECT_ENDIAN_INDEX] != ARMAP_LITTLE_ENDIAN) 2917 || ! strneq (nextname + ARMAP_END_INDEX, ARMAP_END, sizeof ARMAP_END - 1)) 2918 { 2919 abfd->has_armap = FALSE; 2920 return TRUE; 2921 } 2922 2923 /* Make sure we have the right byte ordering. */ 2924 if (((nextname[ARMAP_HEADER_ENDIAN_INDEX] == ARMAP_BIG_ENDIAN) 2925 ^ (bfd_header_big_endian (abfd))) 2926 || ((nextname[ARMAP_OBJECT_ENDIAN_INDEX] == ARMAP_BIG_ENDIAN) 2927 ^ (bfd_big_endian (abfd)))) 2928 { 2929 bfd_set_error (bfd_error_wrong_format); 2930 return FALSE; 2931 } 2932 2933 /* Read in the armap. */ 2934 ardata = bfd_ardata (abfd); 2935 mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd); 2936 if (mapdata == NULL) 2937 return FALSE; 2938 parsed_size = mapdata->parsed_size; 2939 free (mapdata); 2940 2941 if (parsed_size + 1 < 9) 2942 { 2943 bfd_set_error (bfd_error_malformed_archive); 2944 return FALSE; 2945 } 2946 2947 raw_armap = (char *) _bfd_alloc_and_read (abfd, parsed_size + 1, parsed_size); 2948 if (raw_armap == NULL) 2949 return FALSE; 2950 raw_armap[parsed_size] = 0; 2951 2952 ardata->tdata = (void *) raw_armap; 2953 2954 count = H_GET_32 (abfd, raw_armap); 2955 if ((parsed_size - 8) / 8 < count) 2956 goto error_malformed; 2957 2958 ardata->symdef_count = 0; 2959 ardata->cache = NULL; 2960 2961 /* This code used to overlay the symdefs over the raw archive data, 2962 but that doesn't work on a 64 bit host. */ 2963 stringbase = raw_armap + count * 8 + 8; 2964 stringsize = parsed_size - (count * 8 + 8); 2965 2966#ifdef CHECK_ARMAP_HASH 2967 { 2968 unsigned int hlog; 2969 2970 /* Double check that I have the hashing algorithm right by making 2971 sure that every symbol can be looked up successfully. */ 2972 hlog = 0; 2973 for (i = 1; i < count; i <<= 1) 2974 hlog++; 2975 BFD_ASSERT (i == count); 2976 2977 raw_ptr = raw_armap + 4; 2978 for (i = 0; i < count; i++, raw_ptr += 8) 2979 { 2980 unsigned int name_offset, file_offset; 2981 unsigned int hash, rehash, srch; 2982 2983 name_offset = H_GET_32 (abfd, raw_ptr); 2984 file_offset = H_GET_32 (abfd, (raw_ptr + 4)); 2985 if (file_offset == 0) 2986 continue; 2987 hash = ecoff_armap_hash (stringbase + name_offset, &rehash, count, 2988 hlog); 2989 if (hash == i) 2990 continue; 2991 2992 /* See if we can rehash to this location. */ 2993 for (srch = (hash + rehash) & (count - 1); 2994 srch != hash && srch != i; 2995 srch = (srch + rehash) & (count - 1)) 2996 BFD_ASSERT (H_GET_32 (abfd, (raw_armap + 8 + srch * 8)) != 0); 2997 BFD_ASSERT (srch == i); 2998 } 2999 } 3000 3001#endif /* CHECK_ARMAP_HASH */ 3002 3003 raw_ptr = raw_armap + 4; 3004 for (i = 0; i < count; i++, raw_ptr += 8) 3005 if (H_GET_32 (abfd, (raw_ptr + 4)) != 0) 3006 ++ardata->symdef_count; 3007 3008 amt = ardata->symdef_count; 3009 amt *= sizeof (carsym); 3010 symdef_ptr = (carsym *) bfd_alloc (abfd, amt); 3011 if (!symdef_ptr) 3012 goto error_exit; 3013 3014 ardata->symdefs = symdef_ptr; 3015 3016 raw_ptr = raw_armap + 4; 3017 for (i = 0; i < count; i++, raw_ptr += 8) 3018 { 3019 unsigned int name_offset, file_offset; 3020 3021 file_offset = H_GET_32 (abfd, (raw_ptr + 4)); 3022 if (file_offset == 0) 3023 continue; 3024 name_offset = H_GET_32 (abfd, raw_ptr); 3025 if (name_offset > stringsize) 3026 goto error_malformed; 3027 symdef_ptr->name = stringbase + name_offset; 3028 symdef_ptr->file_offset = file_offset; 3029 ++symdef_ptr; 3030 } 3031 3032 ardata->first_file_filepos = bfd_tell (abfd); 3033 /* Pad to an even boundary. */ 3034 ardata->first_file_filepos += ardata->first_file_filepos % 2; 3035 abfd->has_armap = TRUE; 3036 return TRUE; 3037 3038 error_malformed: 3039 bfd_set_error (bfd_error_malformed_archive); 3040 error_exit: 3041 ardata->symdef_count = 0; 3042 ardata->symdefs = NULL; 3043 ardata->tdata = NULL; 3044 bfd_release (abfd, raw_armap); 3045 return FALSE; 3046} 3047 3048/* Write out an armap. */ 3049 3050bfd_boolean 3051_bfd_ecoff_write_armap (bfd *abfd, 3052 unsigned int elength, 3053 struct orl *map, 3054 unsigned int orl_count, 3055 int stridx) 3056{ 3057 unsigned int hashsize, hashlog; 3058 bfd_size_type symdefsize; 3059 int padit; 3060 unsigned int stringsize; 3061 unsigned int mapsize; 3062 file_ptr firstreal; 3063 struct ar_hdr hdr; 3064 struct stat statbuf; 3065 unsigned int i; 3066 bfd_byte temp[4]; 3067 bfd_byte *hashtable; 3068 bfd *current; 3069 bfd *last_elt; 3070 3071 /* Ultrix appears to use as a hash table size the least power of two 3072 greater than twice the number of entries. */ 3073 for (hashlog = 0; ((unsigned int) 1 << hashlog) <= 2 * orl_count; hashlog++) 3074 ; 3075 hashsize = 1 << hashlog; 3076 3077 symdefsize = hashsize * 8; 3078 padit = stridx % 2; 3079 stringsize = stridx + padit; 3080 3081 /* Include 8 bytes to store symdefsize and stringsize in output. */ 3082 mapsize = symdefsize + stringsize + 8; 3083 3084 firstreal = SARMAG + sizeof (struct ar_hdr) + mapsize + elength; 3085 3086 memset ((void *) &hdr, 0, sizeof hdr); 3087 3088 /* Work out the ECOFF armap name. */ 3089 strcpy (hdr.ar_name, ecoff_backend (abfd)->armap_start); 3090 hdr.ar_name[ARMAP_HEADER_MARKER_INDEX] = ARMAP_MARKER; 3091 hdr.ar_name[ARMAP_HEADER_ENDIAN_INDEX] = 3092 (bfd_header_big_endian (abfd) 3093 ? ARMAP_BIG_ENDIAN 3094 : ARMAP_LITTLE_ENDIAN); 3095 hdr.ar_name[ARMAP_OBJECT_MARKER_INDEX] = ARMAP_MARKER; 3096 hdr.ar_name[ARMAP_OBJECT_ENDIAN_INDEX] = 3097 bfd_big_endian (abfd) ? ARMAP_BIG_ENDIAN : ARMAP_LITTLE_ENDIAN; 3098 memcpy (hdr.ar_name + ARMAP_END_INDEX, ARMAP_END, sizeof ARMAP_END - 1); 3099 3100 /* Write the timestamp of the archive header to be just a little bit 3101 later than the timestamp of the file, otherwise the linker will 3102 complain that the index is out of date. Actually, the Ultrix 3103 linker just checks the archive name; the GNU linker may check the 3104 date. */ 3105 stat (bfd_get_filename (abfd), &statbuf); 3106 _bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld", 3107 (long) (statbuf.st_mtime + 60)); 3108 3109 /* The DECstation uses zeroes for the uid, gid and mode of the 3110 armap. */ 3111 hdr.ar_uid[0] = '0'; 3112 hdr.ar_gid[0] = '0'; 3113 /* Building gcc ends up extracting the armap as a file - twice. */ 3114 hdr.ar_mode[0] = '6'; 3115 hdr.ar_mode[1] = '4'; 3116 hdr.ar_mode[2] = '4'; 3117 3118 _bfd_ar_spacepad (hdr.ar_size, sizeof (hdr.ar_size), "%-10ld", mapsize); 3119 3120 hdr.ar_fmag[0] = '`'; 3121 hdr.ar_fmag[1] = '\012'; 3122 3123 /* Turn all null bytes in the header into spaces. */ 3124 for (i = 0; i < sizeof (struct ar_hdr); i++) 3125 if (((char *) (&hdr))[i] == '\0') 3126 (((char *) (&hdr))[i]) = ' '; 3127 3128 if (bfd_bwrite ((void *) &hdr, (bfd_size_type) sizeof (struct ar_hdr), abfd) 3129 != sizeof (struct ar_hdr)) 3130 return FALSE; 3131 3132 H_PUT_32 (abfd, hashsize, temp); 3133 if (bfd_bwrite ((void *) temp, (bfd_size_type) 4, abfd) != 4) 3134 return FALSE; 3135 3136 hashtable = (bfd_byte *) bfd_zalloc (abfd, symdefsize); 3137 if (!hashtable) 3138 return FALSE; 3139 3140 current = abfd->archive_head; 3141 last_elt = current; 3142 for (i = 0; i < orl_count; i++) 3143 { 3144 unsigned int hash, rehash = 0; 3145 3146 /* Advance firstreal to the file position of this archive 3147 element. */ 3148 if (map[i].u.abfd != last_elt) 3149 { 3150 do 3151 { 3152 firstreal += arelt_size (current) + sizeof (struct ar_hdr); 3153 firstreal += firstreal % 2; 3154 current = current->archive_next; 3155 } 3156 while (current != map[i].u.abfd); 3157 } 3158 3159 last_elt = current; 3160 3161 hash = ecoff_armap_hash (*map[i].name, &rehash, hashsize, hashlog); 3162 if (H_GET_32 (abfd, (hashtable + (hash * 8) + 4)) != 0) 3163 { 3164 unsigned int srch; 3165 3166 /* The desired slot is already taken. */ 3167 for (srch = (hash + rehash) & (hashsize - 1); 3168 srch != hash; 3169 srch = (srch + rehash) & (hashsize - 1)) 3170 if (H_GET_32 (abfd, (hashtable + (srch * 8) + 4)) == 0) 3171 break; 3172 3173 BFD_ASSERT (srch != hash); 3174 3175 hash = srch; 3176 } 3177 3178 H_PUT_32 (abfd, map[i].namidx, (hashtable + hash * 8)); 3179 H_PUT_32 (abfd, firstreal, (hashtable + hash * 8 + 4)); 3180 } 3181 3182 if (bfd_bwrite ((void *) hashtable, symdefsize, abfd) != symdefsize) 3183 return FALSE; 3184 3185 bfd_release (abfd, hashtable); 3186 3187 /* Now write the strings. */ 3188 H_PUT_32 (abfd, stringsize, temp); 3189 if (bfd_bwrite ((void *) temp, (bfd_size_type) 4, abfd) != 4) 3190 return FALSE; 3191 for (i = 0; i < orl_count; i++) 3192 { 3193 bfd_size_type len; 3194 3195 len = strlen (*map[i].name) + 1; 3196 if (bfd_bwrite ((void *) (*map[i].name), len, abfd) != len) 3197 return FALSE; 3198 } 3199 3200 /* The spec sez this should be a newline. But in order to be 3201 bug-compatible for DECstation ar we use a null. */ 3202 if (padit) 3203 { 3204 if (bfd_bwrite ("", (bfd_size_type) 1, abfd) != 1) 3205 return FALSE; 3206 } 3207 3208 return TRUE; 3209} 3210 3211/* ECOFF linker code. */ 3212 3213/* Routine to create an entry in an ECOFF link hash table. */ 3214 3215static struct bfd_hash_entry * 3216ecoff_link_hash_newfunc (struct bfd_hash_entry *entry, 3217 struct bfd_hash_table *table, 3218 const char *string) 3219{ 3220 struct ecoff_link_hash_entry *ret = (struct ecoff_link_hash_entry *) entry; 3221 3222 /* Allocate the structure if it has not already been allocated by a 3223 subclass. */ 3224 if (ret == NULL) 3225 ret = ((struct ecoff_link_hash_entry *) 3226 bfd_hash_allocate (table, sizeof (struct ecoff_link_hash_entry))); 3227 if (ret == NULL) 3228 return NULL; 3229 3230 /* Call the allocation method of the superclass. */ 3231 ret = ((struct ecoff_link_hash_entry *) 3232 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret, 3233 table, string)); 3234 3235 if (ret) 3236 { 3237 /* Set local fields. */ 3238 ret->indx = -1; 3239 ret->abfd = NULL; 3240 ret->written = 0; 3241 ret->small = 0; 3242 } 3243 memset ((void *) &ret->esym, 0, sizeof ret->esym); 3244 3245 return (struct bfd_hash_entry *) ret; 3246} 3247 3248/* Create an ECOFF link hash table. */ 3249 3250struct bfd_link_hash_table * 3251_bfd_ecoff_bfd_link_hash_table_create (bfd *abfd) 3252{ 3253 struct ecoff_link_hash_table *ret; 3254 size_t amt = sizeof (struct ecoff_link_hash_table); 3255 3256 ret = (struct ecoff_link_hash_table *) bfd_malloc (amt); 3257 if (ret == NULL) 3258 return NULL; 3259 if (!_bfd_link_hash_table_init (&ret->root, abfd, 3260 ecoff_link_hash_newfunc, 3261 sizeof (struct ecoff_link_hash_entry))) 3262 { 3263 free (ret); 3264 return NULL; 3265 } 3266 return &ret->root; 3267} 3268 3269/* Look up an entry in an ECOFF link hash table. */ 3270 3271#define ecoff_link_hash_lookup(table, string, create, copy, follow) \ 3272 ((struct ecoff_link_hash_entry *) \ 3273 bfd_link_hash_lookup (&(table)->root, (string), (create), (copy), (follow))) 3274 3275/* Get the ECOFF link hash table from the info structure. This is 3276 just a cast. */ 3277 3278#define ecoff_hash_table(p) ((struct ecoff_link_hash_table *) ((p)->hash)) 3279 3280/* Add the external symbols of an object file to the global linker 3281 hash table. The external symbols and strings we are passed are 3282 just allocated on the stack, and will be discarded. We must 3283 explicitly save any information we may need later on in the link. 3284 We do not want to read the external symbol information again. */ 3285 3286static bfd_boolean 3287ecoff_link_add_externals (bfd *abfd, 3288 struct bfd_link_info *info, 3289 void * external_ext, 3290 char *ssext) 3291{ 3292 const struct ecoff_backend_data * const backend = ecoff_backend (abfd); 3293 void (* const swap_ext_in) (bfd *, void *, EXTR *) 3294 = backend->debug_swap.swap_ext_in; 3295 bfd_size_type external_ext_size = backend->debug_swap.external_ext_size; 3296 unsigned long ext_count; 3297 struct bfd_link_hash_entry **sym_hash; 3298 char *ext_ptr; 3299 char *ext_end; 3300 bfd_size_type amt; 3301 3302 ext_count = ecoff_data (abfd)->debug_info.symbolic_header.iextMax; 3303 3304 amt = ext_count; 3305 amt *= sizeof (struct bfd_link_hash_entry *); 3306 sym_hash = (struct bfd_link_hash_entry **) bfd_alloc (abfd, amt); 3307 if (!sym_hash) 3308 return FALSE; 3309 ecoff_data (abfd)->sym_hashes = (struct ecoff_link_hash_entry **) sym_hash; 3310 3311 ext_ptr = (char *) external_ext; 3312 ext_end = ext_ptr + ext_count * external_ext_size; 3313 for (; ext_ptr < ext_end; ext_ptr += external_ext_size, sym_hash++) 3314 { 3315 EXTR esym; 3316 bfd_boolean skip; 3317 bfd_vma value; 3318 asection *section; 3319 const char *name; 3320 struct ecoff_link_hash_entry *h; 3321 3322 *sym_hash = NULL; 3323 3324 (*swap_ext_in) (abfd, (void *) ext_ptr, &esym); 3325 3326 /* Skip debugging symbols. */ 3327 skip = FALSE; 3328 switch (esym.asym.st) 3329 { 3330 case stGlobal: 3331 case stStatic: 3332 case stLabel: 3333 case stProc: 3334 case stStaticProc: 3335 break; 3336 default: 3337 skip = TRUE; 3338 break; 3339 } 3340 3341 if (skip) 3342 continue; 3343 3344 /* Get the information for this symbol. */ 3345 value = esym.asym.value; 3346 switch (esym.asym.sc) 3347 { 3348 default: 3349 case scNil: 3350 case scRegister: 3351 case scCdbLocal: 3352 case scBits: 3353 case scCdbSystem: 3354 case scRegImage: 3355 case scInfo: 3356 case scUserStruct: 3357 case scVar: 3358 case scVarRegister: 3359 case scVariant: 3360 case scBasedVar: 3361 case scXData: 3362 case scPData: 3363 section = NULL; 3364 break; 3365 case scText: 3366 section = bfd_make_section_old_way (abfd, _TEXT); 3367 value -= section->vma; 3368 break; 3369 case scData: 3370 section = bfd_make_section_old_way (abfd, _DATA); 3371 value -= section->vma; 3372 break; 3373 case scBss: 3374 section = bfd_make_section_old_way (abfd, _BSS); 3375 value -= section->vma; 3376 break; 3377 case scAbs: 3378 section = bfd_abs_section_ptr; 3379 break; 3380 case scUndefined: 3381 section = bfd_und_section_ptr; 3382 break; 3383 case scSData: 3384 section = bfd_make_section_old_way (abfd, _SDATA); 3385 value -= section->vma; 3386 break; 3387 case scSBss: 3388 section = bfd_make_section_old_way (abfd, _SBSS); 3389 value -= section->vma; 3390 break; 3391 case scRData: 3392 section = bfd_make_section_old_way (abfd, _RDATA); 3393 value -= section->vma; 3394 break; 3395 case scCommon: 3396 if (value > ecoff_data (abfd)->gp_size) 3397 { 3398 section = bfd_com_section_ptr; 3399 break; 3400 } 3401 /* Fall through. */ 3402 case scSCommon: 3403 if (ecoff_scom_section.name == NULL) 3404 { 3405 /* Initialize the small common section. */ 3406 ecoff_scom_section.name = SCOMMON; 3407 ecoff_scom_section.flags = SEC_IS_COMMON | SEC_SMALL_DATA; 3408 ecoff_scom_section.output_section = &ecoff_scom_section; 3409 ecoff_scom_section.symbol = &ecoff_scom_symbol; 3410 ecoff_scom_section.symbol_ptr_ptr = &ecoff_scom_symbol_ptr; 3411 ecoff_scom_symbol.name = SCOMMON; 3412 ecoff_scom_symbol.flags = BSF_SECTION_SYM; 3413 ecoff_scom_symbol.section = &ecoff_scom_section; 3414 ecoff_scom_symbol_ptr = &ecoff_scom_symbol; 3415 } 3416 section = &ecoff_scom_section; 3417 break; 3418 case scSUndefined: 3419 section = bfd_und_section_ptr; 3420 break; 3421 case scInit: 3422 section = bfd_make_section_old_way (abfd, _INIT); 3423 value -= section->vma; 3424 break; 3425 case scFini: 3426 section = bfd_make_section_old_way (abfd, _FINI); 3427 value -= section->vma; 3428 break; 3429 case scRConst: 3430 section = bfd_make_section_old_way (abfd, _RCONST); 3431 value -= section->vma; 3432 break; 3433 } 3434 3435 if (section == NULL) 3436 continue; 3437 3438 name = ssext + esym.asym.iss; 3439 3440 if (! (_bfd_generic_link_add_one_symbol 3441 (info, abfd, name, 3442 (flagword) (esym.weakext ? BSF_WEAK : BSF_GLOBAL), 3443 section, value, NULL, TRUE, TRUE, sym_hash))) 3444 return FALSE; 3445 3446 h = (struct ecoff_link_hash_entry *) *sym_hash; 3447 3448 /* If we are building an ECOFF hash table, save the external 3449 symbol information. */ 3450 if (bfd_get_flavour (info->output_bfd) == bfd_get_flavour (abfd)) 3451 { 3452 if (h->abfd == NULL 3453 || (! bfd_is_und_section (section) 3454 && (! bfd_is_com_section (section) 3455 || (h->root.type != bfd_link_hash_defined 3456 && h->root.type != bfd_link_hash_defweak)))) 3457 { 3458 h->abfd = abfd; 3459 h->esym = esym; 3460 } 3461 3462 /* Remember whether this symbol was small undefined. */ 3463 if (esym.asym.sc == scSUndefined) 3464 h->small = 1; 3465 3466 /* If this symbol was ever small undefined, it needs to wind 3467 up in a GP relative section. We can't control the 3468 section of a defined symbol, but we can control the 3469 section of a common symbol. This case is actually needed 3470 on Ultrix 4.2 to handle the symbol cred in -lckrb. */ 3471 if (h->small 3472 && h->root.type == bfd_link_hash_common 3473 && streq (h->root.u.c.p->section->name, SCOMMON)) 3474 { 3475 h->root.u.c.p->section = bfd_make_section_old_way (abfd, 3476 SCOMMON); 3477 h->root.u.c.p->section->flags = SEC_ALLOC; 3478 if (h->esym.asym.sc == scCommon) 3479 h->esym.asym.sc = scSCommon; 3480 } 3481 } 3482 } 3483 3484 return TRUE; 3485} 3486 3487/* Add symbols from an ECOFF object file to the global linker hash 3488 table. */ 3489 3490static bfd_boolean 3491ecoff_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info) 3492{ 3493 HDRR *symhdr; 3494 bfd_size_type external_ext_size; 3495 void * external_ext = NULL; 3496 bfd_size_type esize; 3497 char *ssext = NULL; 3498 bfd_boolean result; 3499 3500 if (! ecoff_slurp_symbolic_header (abfd)) 3501 return FALSE; 3502 3503 /* If there are no symbols, we don't want it. */ 3504 if (bfd_get_symcount (abfd) == 0) 3505 return TRUE; 3506 3507 symhdr = &ecoff_data (abfd)->debug_info.symbolic_header; 3508 3509 /* Read in the external symbols and external strings. */ 3510 if (bfd_seek (abfd, symhdr->cbExtOffset, SEEK_SET) != 0) 3511 return FALSE; 3512 external_ext_size = ecoff_backend (abfd)->debug_swap.external_ext_size; 3513 esize = symhdr->iextMax * external_ext_size; 3514 external_ext = _bfd_malloc_and_read (abfd, esize, esize); 3515 if (external_ext == NULL && esize != 0) 3516 goto error_return; 3517 3518 if (bfd_seek (abfd, symhdr->cbSsExtOffset, SEEK_SET) != 0) 3519 goto error_return; 3520 ssext = (char *) _bfd_malloc_and_read (abfd, symhdr->issExtMax, 3521 symhdr->issExtMax); 3522 if (ssext == NULL && symhdr->issExtMax != 0) 3523 goto error_return; 3524 3525 result = ecoff_link_add_externals (abfd, info, external_ext, ssext); 3526 3527 free (ssext); 3528 free (external_ext); 3529 return result; 3530 3531 error_return: 3532 free (ssext); 3533 free (external_ext); 3534 return FALSE; 3535} 3536 3537/* This is called if we used _bfd_generic_link_add_archive_symbols 3538 because we were not dealing with an ECOFF archive. */ 3539 3540static bfd_boolean 3541ecoff_link_check_archive_element (bfd *abfd, 3542 struct bfd_link_info *info, 3543 struct bfd_link_hash_entry *h, 3544 const char *name, 3545 bfd_boolean *pneeded) 3546{ 3547 *pneeded = FALSE; 3548 3549 /* Unlike the generic linker, we do not pull in elements because 3550 of common symbols. */ 3551 if (h->type != bfd_link_hash_undefined) 3552 return TRUE; 3553 3554 /* Include this element? */ 3555 if (!(*info->callbacks->add_archive_element) (info, abfd, name, &abfd)) 3556 return TRUE; 3557 *pneeded = TRUE; 3558 3559 return ecoff_link_add_object_symbols (abfd, info); 3560} 3561 3562/* Add the symbols from an archive file to the global hash table. 3563 This looks through the undefined symbols, looks each one up in the 3564 archive hash table, and adds any associated object file. We do not 3565 use _bfd_generic_link_add_archive_symbols because ECOFF archives 3566 already have a hash table, so there is no reason to construct 3567 another one. */ 3568 3569static bfd_boolean 3570ecoff_link_add_archive_symbols (bfd *abfd, struct bfd_link_info *info) 3571{ 3572 const struct ecoff_backend_data * const backend = ecoff_backend (abfd); 3573 const bfd_byte *raw_armap; 3574 struct bfd_link_hash_entry **pundef; 3575 unsigned int armap_count; 3576 unsigned int armap_log; 3577 unsigned int i; 3578 const bfd_byte *hashtable; 3579 const char *stringbase; 3580 3581 if (! bfd_has_map (abfd)) 3582 { 3583 /* An empty archive is a special case. */ 3584 if (bfd_openr_next_archived_file (abfd, NULL) == NULL) 3585 return TRUE; 3586 bfd_set_error (bfd_error_no_armap); 3587 return FALSE; 3588 } 3589 3590 /* If we don't have any raw data for this archive, as can happen on 3591 Irix 4.0.5F, we call the generic routine. 3592 FIXME: We should be more clever about this, since someday tdata 3593 may get to something for a generic archive. */ 3594 raw_armap = (const bfd_byte *) bfd_ardata (abfd)->tdata; 3595 if (raw_armap == NULL) 3596 return (_bfd_generic_link_add_archive_symbols 3597 (abfd, info, ecoff_link_check_archive_element)); 3598 3599 armap_count = H_GET_32 (abfd, raw_armap); 3600 3601 armap_log = 0; 3602 for (i = 1; i < armap_count; i <<= 1) 3603 armap_log++; 3604 BFD_ASSERT (i == armap_count); 3605 3606 hashtable = raw_armap + 4; 3607 stringbase = (const char *) raw_armap + armap_count * 8 + 8; 3608 3609 /* Look through the list of undefined symbols. */ 3610 pundef = &info->hash->undefs; 3611 while (*pundef != NULL) 3612 { 3613 struct bfd_link_hash_entry *h; 3614 unsigned int hash, rehash = 0; 3615 unsigned int file_offset; 3616 const char *name; 3617 bfd *element; 3618 3619 h = *pundef; 3620 3621 /* When a symbol is defined, it is not necessarily removed from 3622 the list. */ 3623 if (h->type != bfd_link_hash_undefined 3624 && h->type != bfd_link_hash_common) 3625 { 3626 /* Remove this entry from the list, for general cleanliness 3627 and because we are going to look through the list again 3628 if we search any more libraries. We can't remove the 3629 entry if it is the tail, because that would lose any 3630 entries we add to the list later on. */ 3631 if (*pundef != info->hash->undefs_tail) 3632 *pundef = (*pundef)->u.undef.next; 3633 else 3634 pundef = &(*pundef)->u.undef.next; 3635 continue; 3636 } 3637 3638 /* Native ECOFF linkers do not pull in archive elements merely 3639 to satisfy common definitions, so neither do we. We leave 3640 them on the list, though, in case we are linking against some 3641 other object format. */ 3642 if (h->type != bfd_link_hash_undefined) 3643 { 3644 pundef = &(*pundef)->u.undef.next; 3645 continue; 3646 } 3647 3648 /* Look for this symbol in the archive hash table. */ 3649 hash = ecoff_armap_hash (h->root.string, &rehash, armap_count, 3650 armap_log); 3651 3652 file_offset = H_GET_32 (abfd, hashtable + (hash * 8) + 4); 3653 if (file_offset == 0) 3654 { 3655 /* Nothing in this slot. */ 3656 pundef = &(*pundef)->u.undef.next; 3657 continue; 3658 } 3659 3660 name = stringbase + H_GET_32 (abfd, hashtable + (hash * 8)); 3661 if (name[0] != h->root.string[0] 3662 || ! streq (name, h->root.string)) 3663 { 3664 unsigned int srch; 3665 bfd_boolean found; 3666 3667 /* That was the wrong symbol. Try rehashing. */ 3668 found = FALSE; 3669 for (srch = (hash + rehash) & (armap_count - 1); 3670 srch != hash; 3671 srch = (srch + rehash) & (armap_count - 1)) 3672 { 3673 file_offset = H_GET_32 (abfd, hashtable + (srch * 8) + 4); 3674 if (file_offset == 0) 3675 break; 3676 name = stringbase + H_GET_32 (abfd, hashtable + (srch * 8)); 3677 if (name[0] == h->root.string[0] 3678 && streq (name, h->root.string)) 3679 { 3680 found = TRUE; 3681 break; 3682 } 3683 } 3684 3685 if (! found) 3686 { 3687 pundef = &(*pundef)->u.undef.next; 3688 continue; 3689 } 3690 3691 hash = srch; 3692 } 3693 3694 element = (*backend->get_elt_at_filepos) (abfd, (file_ptr) file_offset); 3695 if (element == NULL) 3696 return FALSE; 3697 3698 if (! bfd_check_format (element, bfd_object)) 3699 return FALSE; 3700 3701 /* Unlike the generic linker, we know that this element provides 3702 a definition for an undefined symbol and we know that we want 3703 to include it. We don't need to check anything. */ 3704 if (!(*info->callbacks 3705 ->add_archive_element) (info, element, name, &element)) 3706 return FALSE; 3707 if (! ecoff_link_add_object_symbols (element, info)) 3708 return FALSE; 3709 3710 pundef = &(*pundef)->u.undef.next; 3711 } 3712 3713 return TRUE; 3714} 3715 3716/* Given an ECOFF BFD, add symbols to the global hash table as 3717 appropriate. */ 3718 3719bfd_boolean 3720_bfd_ecoff_bfd_link_add_symbols (bfd *abfd, struct bfd_link_info *info) 3721{ 3722 switch (bfd_get_format (abfd)) 3723 { 3724 case bfd_object: 3725 return ecoff_link_add_object_symbols (abfd, info); 3726 case bfd_archive: 3727 return ecoff_link_add_archive_symbols (abfd, info); 3728 default: 3729 bfd_set_error (bfd_error_wrong_format); 3730 return FALSE; 3731 } 3732} 3733 3734 3735/* ECOFF final link routines. */ 3736 3737/* Structure used to pass information to ecoff_link_write_external. */ 3738 3739struct extsym_info 3740{ 3741 bfd *abfd; 3742 struct bfd_link_info *info; 3743}; 3744 3745/* Accumulate the debugging information for an input BFD into the 3746 output BFD. This must read in the symbolic information of the 3747 input BFD. */ 3748 3749static bfd_boolean 3750ecoff_final_link_debug_accumulate (bfd *output_bfd, 3751 bfd *input_bfd, 3752 struct bfd_link_info *info, 3753 void * handle) 3754{ 3755 struct ecoff_debug_info * const debug = &ecoff_data (input_bfd)->debug_info; 3756 const struct ecoff_debug_swap * const swap = 3757 &ecoff_backend (input_bfd)->debug_swap; 3758 HDRR *symhdr = &debug->symbolic_header; 3759 bfd_boolean ret; 3760 3761#define READ(ptr, offset, count, size, type) \ 3762 do \ 3763 { \ 3764 size_t amt; \ 3765 debug->ptr = NULL; \ 3766 if (symhdr->count == 0) \ 3767 break; \ 3768 if (_bfd_mul_overflow (size, symhdr->count, &amt)) \ 3769 { \ 3770 bfd_set_error (bfd_error_file_too_big); \ 3771 ret = FALSE; \ 3772 goto return_something; \ 3773 } \ 3774 if (bfd_seek (input_bfd, symhdr->offset, SEEK_SET) != 0) \ 3775 { \ 3776 ret = FALSE; \ 3777 goto return_something; \ 3778 } \ 3779 debug->ptr = (type) _bfd_malloc_and_read (input_bfd, amt, amt); \ 3780 if (debug->ptr == NULL) \ 3781 { \ 3782 ret = FALSE; \ 3783 goto return_something; \ 3784 } \ 3785 } while (0) 3786 3787 /* If raw_syments is not NULL, then the data was already by read by 3788 _bfd_ecoff_slurp_symbolic_info. */ 3789 if (ecoff_data (input_bfd)->raw_syments == NULL) 3790 { 3791 READ (line, cbLineOffset, cbLine, sizeof (unsigned char), 3792 unsigned char *); 3793 READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, void *); 3794 READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, void *); 3795 READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, void *); 3796 READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, void *); 3797 READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext), 3798 union aux_ext *); 3799 READ (ss, cbSsOffset, issMax, sizeof (char), char *); 3800 READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, void *); 3801 READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, void *); 3802 } 3803#undef READ 3804 3805 /* We do not read the external strings or the external symbols. */ 3806 3807 ret = (bfd_ecoff_debug_accumulate 3808 (handle, output_bfd, &ecoff_data (output_bfd)->debug_info, 3809 &ecoff_backend (output_bfd)->debug_swap, 3810 input_bfd, debug, swap, info)); 3811 3812 return_something: 3813 if (ecoff_data (input_bfd)->raw_syments == NULL) 3814 { 3815 free (debug->line); 3816 free (debug->external_dnr); 3817 free (debug->external_pdr); 3818 free (debug->external_sym); 3819 free (debug->external_opt); 3820 free (debug->external_aux); 3821 free (debug->ss); 3822 free (debug->external_fdr); 3823 free (debug->external_rfd); 3824 3825 /* Make sure we don't accidentally follow one of these pointers 3826 into freed memory. */ 3827 debug->line = NULL; 3828 debug->external_dnr = NULL; 3829 debug->external_pdr = NULL; 3830 debug->external_sym = NULL; 3831 debug->external_opt = NULL; 3832 debug->external_aux = NULL; 3833 debug->ss = NULL; 3834 debug->external_fdr = NULL; 3835 debug->external_rfd = NULL; 3836 } 3837 3838 return ret; 3839} 3840 3841/* Relocate and write an ECOFF section into an ECOFF output file. */ 3842 3843static bfd_boolean 3844ecoff_indirect_link_order (bfd *output_bfd, 3845 struct bfd_link_info *info, 3846 asection *output_section, 3847 struct bfd_link_order *link_order) 3848{ 3849 asection *input_section; 3850 bfd *input_bfd; 3851 bfd_byte *contents = NULL; 3852 bfd_size_type external_reloc_size; 3853 bfd_size_type external_relocs_size; 3854 void * external_relocs = NULL; 3855 3856 BFD_ASSERT ((output_section->flags & SEC_HAS_CONTENTS) != 0); 3857 3858 input_section = link_order->u.indirect.section; 3859 input_bfd = input_section->owner; 3860 if (input_section->size == 0) 3861 return TRUE; 3862 3863 BFD_ASSERT (input_section->output_section == output_section); 3864 BFD_ASSERT (input_section->output_offset == link_order->offset); 3865 BFD_ASSERT (input_section->size == link_order->size); 3866 3867 /* Get the section contents. */ 3868 if (!bfd_malloc_and_get_section (input_bfd, input_section, &contents)) 3869 goto error_return; 3870 3871 /* Get the relocs. If we are relaxing MIPS code, they will already 3872 have been read in. Otherwise, we read them in now. */ 3873 external_reloc_size = ecoff_backend (input_bfd)->external_reloc_size; 3874 external_relocs_size = external_reloc_size * input_section->reloc_count; 3875 3876 if (bfd_seek (input_bfd, input_section->rel_filepos, SEEK_SET) != 0) 3877 goto error_return; 3878 external_relocs = _bfd_malloc_and_read (input_bfd, external_relocs_size, 3879 external_relocs_size); 3880 if (external_relocs == NULL && external_relocs_size != 0) 3881 goto error_return; 3882 3883 /* Relocate the section contents. */ 3884 if (! ((*ecoff_backend (input_bfd)->relocate_section) 3885 (output_bfd, info, input_bfd, input_section, contents, 3886 external_relocs))) 3887 goto error_return; 3888 3889 /* Write out the relocated section. */ 3890 if (! bfd_set_section_contents (output_bfd, 3891 output_section, 3892 contents, 3893 input_section->output_offset, 3894 input_section->size)) 3895 goto error_return; 3896 3897 /* If we are producing relocatable output, the relocs were 3898 modified, and we write them out now. We use the reloc_count 3899 field of output_section to keep track of the number of relocs we 3900 have output so far. */ 3901 if (bfd_link_relocatable (info)) 3902 { 3903 file_ptr pos = (output_section->rel_filepos 3904 + output_section->reloc_count * external_reloc_size); 3905 if (bfd_seek (output_bfd, pos, SEEK_SET) != 0 3906 || (bfd_bwrite (external_relocs, external_relocs_size, output_bfd) 3907 != external_relocs_size)) 3908 goto error_return; 3909 output_section->reloc_count += input_section->reloc_count; 3910 } 3911 3912 free (contents); 3913 free (external_relocs); 3914 return TRUE; 3915 3916 error_return: 3917 free (contents); 3918 free (external_relocs); 3919 return FALSE; 3920} 3921 3922/* Generate a reloc when linking an ECOFF file. This is a reloc 3923 requested by the linker, and does come from any input file. This 3924 is used to build constructor and destructor tables when linking 3925 with -Ur. */ 3926 3927static bfd_boolean 3928ecoff_reloc_link_order (bfd *output_bfd, 3929 struct bfd_link_info *info, 3930 asection *output_section, 3931 struct bfd_link_order *link_order) 3932{ 3933 enum bfd_link_order_type type; 3934 asection *section; 3935 bfd_vma addend; 3936 arelent rel; 3937 struct internal_reloc in; 3938 bfd_size_type external_reloc_size; 3939 bfd_byte *rbuf; 3940 bfd_boolean ok; 3941 file_ptr pos; 3942 3943 type = link_order->type; 3944 section = NULL; 3945 addend = link_order->u.reloc.p->addend; 3946 3947 /* We set up an arelent to pass to the backend adjust_reloc_out 3948 routine. */ 3949 rel.address = link_order->offset; 3950 3951 rel.howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc); 3952 if (rel.howto == 0) 3953 { 3954 bfd_set_error (bfd_error_bad_value); 3955 return FALSE; 3956 } 3957 3958 if (type == bfd_section_reloc_link_order) 3959 { 3960 section = link_order->u.reloc.p->u.section; 3961 rel.sym_ptr_ptr = section->symbol_ptr_ptr; 3962 } 3963 else 3964 { 3965 struct bfd_link_hash_entry *h; 3966 3967 /* Treat a reloc against a defined symbol as though it were 3968 actually against the section. */ 3969 h = bfd_wrapped_link_hash_lookup (output_bfd, info, 3970 link_order->u.reloc.p->u.name, 3971 FALSE, FALSE, FALSE); 3972 if (h != NULL 3973 && (h->type == bfd_link_hash_defined 3974 || h->type == bfd_link_hash_defweak)) 3975 { 3976 type = bfd_section_reloc_link_order; 3977 section = h->u.def.section->output_section; 3978 /* It seems that we ought to add the symbol value to the 3979 addend here, but in practice it has already been added 3980 because it was passed to constructor_callback. */ 3981 addend += section->vma + h->u.def.section->output_offset; 3982 } 3983 else 3984 { 3985 /* We can't set up a reloc against a symbol correctly, 3986 because we have no asymbol structure. Currently no 3987 adjust_reloc_out routine cares. */ 3988 rel.sym_ptr_ptr = NULL; 3989 } 3990 } 3991 3992 /* All ECOFF relocs are in-place. Put the addend into the object 3993 file. */ 3994 3995 BFD_ASSERT (rel.howto->partial_inplace); 3996 if (addend != 0) 3997 { 3998 bfd_size_type size; 3999 bfd_reloc_status_type rstat; 4000 bfd_byte *buf; 4001 4002 size = bfd_get_reloc_size (rel.howto); 4003 buf = (bfd_byte *) bfd_zmalloc (size); 4004 if (buf == NULL && size != 0) 4005 return FALSE; 4006 rstat = _bfd_relocate_contents (rel.howto, output_bfd, 4007 (bfd_vma) addend, buf); 4008 switch (rstat) 4009 { 4010 case bfd_reloc_ok: 4011 break; 4012 default: 4013 case bfd_reloc_outofrange: 4014 abort (); 4015 case bfd_reloc_overflow: 4016 (*info->callbacks->reloc_overflow) 4017 (info, NULL, 4018 (link_order->type == bfd_section_reloc_link_order 4019 ? bfd_section_name (section) 4020 : link_order->u.reloc.p->u.name), 4021 rel.howto->name, addend, NULL, NULL, (bfd_vma) 0); 4022 break; 4023 } 4024 ok = bfd_set_section_contents (output_bfd, output_section, (void *) buf, 4025 (file_ptr) link_order->offset, size); 4026 free (buf); 4027 if (! ok) 4028 return FALSE; 4029 } 4030 4031 rel.addend = 0; 4032 4033 /* Move the information into an internal_reloc structure. */ 4034 in.r_vaddr = rel.address + bfd_section_vma (output_section); 4035 in.r_type = rel.howto->type; 4036 4037 if (type == bfd_symbol_reloc_link_order) 4038 { 4039 struct ecoff_link_hash_entry *h; 4040 4041 h = ((struct ecoff_link_hash_entry *) 4042 bfd_wrapped_link_hash_lookup (output_bfd, info, 4043 link_order->u.reloc.p->u.name, 4044 FALSE, FALSE, TRUE)); 4045 if (h != NULL 4046 && h->indx != -1) 4047 in.r_symndx = h->indx; 4048 else 4049 { 4050 (*info->callbacks->unattached_reloc) 4051 (info, link_order->u.reloc.p->u.name, NULL, NULL, (bfd_vma) 0); 4052 in.r_symndx = 0; 4053 } 4054 in.r_extern = 1; 4055 } 4056 else 4057 { 4058 const char *name; 4059 unsigned int i; 4060 static struct 4061 { 4062 const char * name; 4063 long r_symndx; 4064 } 4065 section_symndx [] = 4066 { 4067 { _TEXT, RELOC_SECTION_TEXT }, 4068 { _RDATA, RELOC_SECTION_RDATA }, 4069 { _DATA, RELOC_SECTION_DATA }, 4070 { _SDATA, RELOC_SECTION_SDATA }, 4071 { _SBSS, RELOC_SECTION_SBSS }, 4072 { _BSS, RELOC_SECTION_BSS }, 4073 { _INIT, RELOC_SECTION_INIT }, 4074 { _LIT8, RELOC_SECTION_LIT8 }, 4075 { _LIT4, RELOC_SECTION_LIT4 }, 4076 { _XDATA, RELOC_SECTION_XDATA }, 4077 { _PDATA, RELOC_SECTION_PDATA }, 4078 { _FINI, RELOC_SECTION_FINI }, 4079 { _LITA, RELOC_SECTION_LITA }, 4080 { "*ABS*", RELOC_SECTION_ABS }, 4081 { _RCONST, RELOC_SECTION_RCONST } 4082 }; 4083 4084 name = bfd_section_name (section); 4085 4086 for (i = 0; i < ARRAY_SIZE (section_symndx); i++) 4087 if (streq (name, section_symndx[i].name)) 4088 { 4089 in.r_symndx = section_symndx[i].r_symndx; 4090 break; 4091 } 4092 4093 if (i == ARRAY_SIZE (section_symndx)) 4094 abort (); 4095 4096 in.r_extern = 0; 4097 } 4098 4099 /* Let the BFD backend adjust the reloc. */ 4100 (*ecoff_backend (output_bfd)->adjust_reloc_out) (output_bfd, &rel, &in); 4101 4102 /* Get some memory and swap out the reloc. */ 4103 external_reloc_size = ecoff_backend (output_bfd)->external_reloc_size; 4104 rbuf = (bfd_byte *) bfd_malloc (external_reloc_size); 4105 if (rbuf == NULL) 4106 return FALSE; 4107 4108 (*ecoff_backend (output_bfd)->swap_reloc_out) (output_bfd, &in, (void *) rbuf); 4109 4110 pos = (output_section->rel_filepos 4111 + output_section->reloc_count * external_reloc_size); 4112 ok = (bfd_seek (output_bfd, pos, SEEK_SET) == 0 4113 && (bfd_bwrite ((void *) rbuf, external_reloc_size, output_bfd) 4114 == external_reloc_size)); 4115 4116 if (ok) 4117 ++output_section->reloc_count; 4118 4119 free (rbuf); 4120 4121 return ok; 4122} 4123 4124/* Put out information for an external symbol. These come only from 4125 the hash table. */ 4126 4127static bfd_boolean 4128ecoff_link_write_external (struct bfd_hash_entry *bh, void * data) 4129{ 4130 struct ecoff_link_hash_entry *h = (struct ecoff_link_hash_entry *) bh; 4131 struct extsym_info *einfo = (struct extsym_info *) data; 4132 bfd *output_bfd = einfo->abfd; 4133 bfd_boolean strip; 4134 4135 if (h->root.type == bfd_link_hash_warning) 4136 { 4137 h = (struct ecoff_link_hash_entry *) h->root.u.i.link; 4138 if (h->root.type == bfd_link_hash_new) 4139 return TRUE; 4140 } 4141 4142 /* We need to check if this symbol is being stripped. */ 4143 if (h->root.type == bfd_link_hash_undefined 4144 || h->root.type == bfd_link_hash_undefweak) 4145 strip = FALSE; 4146 else if (einfo->info->strip == strip_all 4147 || (einfo->info->strip == strip_some 4148 && bfd_hash_lookup (einfo->info->keep_hash, 4149 h->root.root.string, 4150 FALSE, FALSE) == NULL)) 4151 strip = TRUE; 4152 else 4153 strip = FALSE; 4154 4155 if (strip || h->written) 4156 return TRUE; 4157 4158 if (h->abfd == NULL) 4159 { 4160 h->esym.jmptbl = 0; 4161 h->esym.cobol_main = 0; 4162 h->esym.weakext = 0; 4163 h->esym.reserved = 0; 4164 h->esym.ifd = ifdNil; 4165 h->esym.asym.value = 0; 4166 h->esym.asym.st = stGlobal; 4167 4168 if (h->root.type != bfd_link_hash_defined 4169 && h->root.type != bfd_link_hash_defweak) 4170 h->esym.asym.sc = scAbs; 4171 else 4172 { 4173 asection *output_section; 4174 const char *name; 4175 unsigned int i; 4176 static struct 4177 { 4178 const char * name; 4179 int sc; 4180 } 4181 section_storage_classes [] = 4182 { 4183 { _TEXT, scText }, 4184 { _DATA, scData }, 4185 { _SDATA, scSData }, 4186 { _RDATA, scRData }, 4187 { _BSS, scBss }, 4188 { _SBSS, scSBss }, 4189 { _INIT, scInit }, 4190 { _FINI, scFini }, 4191 { _PDATA, scPData }, 4192 { _XDATA, scXData }, 4193 { _RCONST, scRConst } 4194 }; 4195 4196 output_section = h->root.u.def.section->output_section; 4197 name = bfd_section_name (output_section); 4198 4199 for (i = 0; i < ARRAY_SIZE (section_storage_classes); i++) 4200 if (streq (name, section_storage_classes[i].name)) 4201 { 4202 h->esym.asym.sc = section_storage_classes[i].sc; 4203 break; 4204 } 4205 4206 if (i == ARRAY_SIZE (section_storage_classes)) 4207 h->esym.asym.sc = scAbs; 4208 } 4209 4210 h->esym.asym.reserved = 0; 4211 h->esym.asym.index = indexNil; 4212 } 4213 else if (h->esym.ifd != -1) 4214 { 4215 struct ecoff_debug_info *debug; 4216 4217 /* Adjust the FDR index for the symbol by that used for the 4218 input BFD. */ 4219 debug = &ecoff_data (h->abfd)->debug_info; 4220 BFD_ASSERT (h->esym.ifd >= 0 4221 && h->esym.ifd < debug->symbolic_header.ifdMax); 4222 h->esym.ifd = debug->ifdmap[h->esym.ifd]; 4223 } 4224 4225 switch (h->root.type) 4226 { 4227 default: 4228 case bfd_link_hash_warning: 4229 case bfd_link_hash_new: 4230 abort (); 4231 case bfd_link_hash_undefined: 4232 case bfd_link_hash_undefweak: 4233 if (h->esym.asym.sc != scUndefined 4234 && h->esym.asym.sc != scSUndefined) 4235 h->esym.asym.sc = scUndefined; 4236 break; 4237 case bfd_link_hash_defined: 4238 case bfd_link_hash_defweak: 4239 if (h->esym.asym.sc == scUndefined 4240 || h->esym.asym.sc == scSUndefined) 4241 h->esym.asym.sc = scAbs; 4242 else if (h->esym.asym.sc == scCommon) 4243 h->esym.asym.sc = scBss; 4244 else if (h->esym.asym.sc == scSCommon) 4245 h->esym.asym.sc = scSBss; 4246 h->esym.asym.value = (h->root.u.def.value 4247 + h->root.u.def.section->output_section->vma 4248 + h->root.u.def.section->output_offset); 4249 break; 4250 case bfd_link_hash_common: 4251 if (h->esym.asym.sc != scCommon 4252 && h->esym.asym.sc != scSCommon) 4253 h->esym.asym.sc = scCommon; 4254 h->esym.asym.value = h->root.u.c.size; 4255 break; 4256 case bfd_link_hash_indirect: 4257 /* We ignore these symbols, since the indirected symbol is 4258 already in the hash table. */ 4259 return TRUE; 4260 } 4261 4262 /* bfd_ecoff_debug_one_external uses iextMax to keep track of the 4263 symbol number. */ 4264 h->indx = ecoff_data (output_bfd)->debug_info.symbolic_header.iextMax; 4265 h->written = 1; 4266 4267 return (bfd_ecoff_debug_one_external 4268 (output_bfd, &ecoff_data (output_bfd)->debug_info, 4269 &ecoff_backend (output_bfd)->debug_swap, h->root.root.string, 4270 &h->esym)); 4271} 4272 4273/* ECOFF final link routine. This looks through all the input BFDs 4274 and gathers together all the debugging information, and then 4275 processes all the link order information. This may cause it to 4276 close and reopen some input BFDs; I'll see how bad this is. */ 4277 4278bfd_boolean 4279_bfd_ecoff_bfd_final_link (bfd *abfd, struct bfd_link_info *info) 4280{ 4281 const struct ecoff_backend_data * const backend = ecoff_backend (abfd); 4282 struct ecoff_debug_info * const debug = &ecoff_data (abfd)->debug_info; 4283 HDRR *symhdr; 4284 void * handle; 4285 bfd *input_bfd; 4286 asection *o; 4287 struct bfd_link_order *p; 4288 struct extsym_info einfo; 4289 4290 /* We accumulate the debugging information counts in the symbolic 4291 header. */ 4292 symhdr = &debug->symbolic_header; 4293 symhdr->vstamp = 0; 4294 symhdr->ilineMax = 0; 4295 symhdr->cbLine = 0; 4296 symhdr->idnMax = 0; 4297 symhdr->ipdMax = 0; 4298 symhdr->isymMax = 0; 4299 symhdr->ioptMax = 0; 4300 symhdr->iauxMax = 0; 4301 symhdr->issMax = 0; 4302 symhdr->issExtMax = 0; 4303 symhdr->ifdMax = 0; 4304 symhdr->crfd = 0; 4305 symhdr->iextMax = 0; 4306 4307 /* We accumulate the debugging information itself in the debug_info 4308 structure. */ 4309 debug->line = NULL; 4310 debug->external_dnr = NULL; 4311 debug->external_pdr = NULL; 4312 debug->external_sym = NULL; 4313 debug->external_opt = NULL; 4314 debug->external_aux = NULL; 4315 debug->ss = NULL; 4316 debug->ssext = debug->ssext_end = NULL; 4317 debug->external_fdr = NULL; 4318 debug->external_rfd = NULL; 4319 debug->external_ext = debug->external_ext_end = NULL; 4320 4321 handle = bfd_ecoff_debug_init (abfd, debug, &backend->debug_swap, info); 4322 if (handle == NULL) 4323 return FALSE; 4324 4325 /* Accumulate the debugging symbols from each input BFD. */ 4326 for (input_bfd = info->input_bfds; 4327 input_bfd != NULL; 4328 input_bfd = input_bfd->link.next) 4329 { 4330 bfd_boolean ret; 4331 4332 if (bfd_get_flavour (input_bfd) == bfd_target_ecoff_flavour) 4333 { 4334 /* Arbitrarily set the symbolic header vstamp to the vstamp 4335 of the first object file in the link. */ 4336 if (symhdr->vstamp == 0) 4337 symhdr->vstamp 4338 = ecoff_data (input_bfd)->debug_info.symbolic_header.vstamp; 4339 ret = ecoff_final_link_debug_accumulate (abfd, input_bfd, info, 4340 handle); 4341 } 4342 else 4343 ret = bfd_ecoff_debug_accumulate_other (handle, abfd, 4344 debug, &backend->debug_swap, 4345 input_bfd, info); 4346 if (! ret) 4347 return FALSE; 4348 4349 /* Combine the register masks. */ 4350 ecoff_data (abfd)->gprmask |= ecoff_data (input_bfd)->gprmask; 4351 ecoff_data (abfd)->fprmask |= ecoff_data (input_bfd)->fprmask; 4352 ecoff_data (abfd)->cprmask[0] |= ecoff_data (input_bfd)->cprmask[0]; 4353 ecoff_data (abfd)->cprmask[1] |= ecoff_data (input_bfd)->cprmask[1]; 4354 ecoff_data (abfd)->cprmask[2] |= ecoff_data (input_bfd)->cprmask[2]; 4355 ecoff_data (abfd)->cprmask[3] |= ecoff_data (input_bfd)->cprmask[3]; 4356 } 4357 4358 /* Write out the external symbols. */ 4359 einfo.abfd = abfd; 4360 einfo.info = info; 4361 bfd_hash_traverse (&info->hash->table, ecoff_link_write_external, &einfo); 4362 4363 if (bfd_link_relocatable (info)) 4364 { 4365 /* We need to make a pass over the link_orders to count up the 4366 number of relocations we will need to output, so that we know 4367 how much space they will take up. */ 4368 for (o = abfd->sections; o != NULL; o = o->next) 4369 { 4370 o->reloc_count = 0; 4371 for (p = o->map_head.link_order; 4372 p != NULL; 4373 p = p->next) 4374 if (p->type == bfd_indirect_link_order) 4375 o->reloc_count += p->u.indirect.section->reloc_count; 4376 else if (p->type == bfd_section_reloc_link_order 4377 || p->type == bfd_symbol_reloc_link_order) 4378 ++o->reloc_count; 4379 } 4380 } 4381 4382 /* Compute the reloc and symbol file positions. */ 4383 ecoff_compute_reloc_file_positions (abfd); 4384 4385 /* Write out the debugging information. */ 4386 if (! bfd_ecoff_write_accumulated_debug (handle, abfd, debug, 4387 &backend->debug_swap, info, 4388 ecoff_data (abfd)->sym_filepos)) 4389 return FALSE; 4390 4391 bfd_ecoff_debug_free (handle, abfd, debug, &backend->debug_swap, info); 4392 4393 if (bfd_link_relocatable (info)) 4394 { 4395 /* Now reset the reloc_count field of the sections in the output 4396 BFD to 0, so that we can use them to keep track of how many 4397 relocs we have output thus far. */ 4398 for (o = abfd->sections; o != NULL; o = o->next) 4399 o->reloc_count = 0; 4400 } 4401 4402 /* Get a value for the GP register. */ 4403 if (ecoff_data (abfd)->gp == 0) 4404 { 4405 struct bfd_link_hash_entry *h; 4406 4407 h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE); 4408 if (h != NULL 4409 && h->type == bfd_link_hash_defined) 4410 ecoff_data (abfd)->gp = (h->u.def.value 4411 + h->u.def.section->output_section->vma 4412 + h->u.def.section->output_offset); 4413 else if (bfd_link_relocatable (info)) 4414 { 4415 bfd_vma lo; 4416 4417 /* Make up a value. */ 4418 lo = (bfd_vma) -1; 4419 for (o = abfd->sections; o != NULL; o = o->next) 4420 { 4421 if (o->vma < lo 4422 && (streq (o->name, _SBSS) 4423 || streq (o->name, _SDATA) 4424 || streq (o->name, _LIT4) 4425 || streq (o->name, _LIT8) 4426 || streq (o->name, _LITA))) 4427 lo = o->vma; 4428 } 4429 ecoff_data (abfd)->gp = lo + 0x8000; 4430 } 4431 else 4432 { 4433 /* If the relocate_section function needs to do a reloc 4434 involving the GP value, it should make a reloc_dangerous 4435 callback to warn that GP is not defined. */ 4436 } 4437 } 4438 4439 for (o = abfd->sections; o != NULL; o = o->next) 4440 { 4441 for (p = o->map_head.link_order; 4442 p != NULL; 4443 p = p->next) 4444 { 4445 if (p->type == bfd_indirect_link_order 4446 && (bfd_get_flavour (p->u.indirect.section->owner) 4447 == bfd_target_ecoff_flavour)) 4448 { 4449 if (! ecoff_indirect_link_order (abfd, info, o, p)) 4450 return FALSE; 4451 } 4452 else if (p->type == bfd_section_reloc_link_order 4453 || p->type == bfd_symbol_reloc_link_order) 4454 { 4455 if (! ecoff_reloc_link_order (abfd, info, o, p)) 4456 return FALSE; 4457 } 4458 else 4459 { 4460 if (! _bfd_default_link_order (abfd, info, o, p)) 4461 return FALSE; 4462 } 4463 } 4464 } 4465 4466 abfd->symcount = symhdr->iextMax + symhdr->isymMax; 4467 4468 ecoff_data (abfd)->linker = TRUE; 4469 4470 return TRUE; 4471} 4472