1/* Support for the generic parts of COFF, for BFD. 2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 3 2000, 2001, 2002 4 Free Software Foundation, Inc. 5 Written by Cygnus Support. 6 7This file is part of BFD, the Binary File Descriptor library. 8 9This program is free software; you can redistribute it and/or modify 10it under the terms of the GNU General Public License as published by 11the Free Software Foundation; either version 2 of the License, or 12(at your option) any later version. 13 14This program is distributed in the hope that it will be useful, 15but WITHOUT ANY WARRANTY; without even the implied warranty of 16MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17GNU General Public License for more details. 18 19You should have received a copy of the GNU General Public License 20along with this program; if not, write to the Free Software 21Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 22 23/* Most of this hacked by Steve Chamberlain, sac@cygnus.com. 24 Split out of coffcode.h by Ian Taylor, ian@cygnus.com. */ 25 26/* This file contains COFF code that is not dependent on any 27 particular COFF target. There is only one version of this file in 28 libbfd.a, so no target specific code may be put in here. Or, to 29 put it another way, 30 31 ********** DO NOT PUT TARGET SPECIFIC CODE IN THIS FILE ********** 32 33 If you need to add some target specific behaviour, add a new hook 34 function to bfd_coff_backend_data. 35 36 Some of these functions are also called by the ECOFF routines. 37 Those functions may not use any COFF specific information, such as 38 coff_data (abfd). */ 39 40#include "bfd.h" 41#include "sysdep.h" 42#include "libbfd.h" 43#include "coff/internal.h" 44#include "libcoff.h" 45 46static void coff_fix_symbol_name 47 PARAMS ((bfd *, asymbol *, combined_entry_type *, bfd_size_type *, 48 asection **, bfd_size_type *)); 49static boolean coff_write_symbol 50 PARAMS ((bfd *, asymbol *, combined_entry_type *, bfd_vma *, 51 bfd_size_type *, asection **, bfd_size_type *)); 52static boolean coff_write_alien_symbol 53 PARAMS ((bfd *, asymbol *, bfd_vma *, bfd_size_type *, 54 asection **, bfd_size_type *)); 55static boolean coff_write_native_symbol 56 PARAMS ((bfd *, coff_symbol_type *, bfd_vma *, bfd_size_type *, 57 asection **, bfd_size_type *)); 58static void coff_pointerize_aux 59 PARAMS ((bfd *, combined_entry_type *, combined_entry_type *, 60 unsigned int, combined_entry_type *)); 61static boolean make_a_section_from_file 62 PARAMS ((bfd *, struct internal_scnhdr *, unsigned int)); 63static const bfd_target *coff_real_object_p 64 PARAMS ((bfd *, unsigned, struct internal_filehdr *, 65 struct internal_aouthdr *)); 66static void fixup_symbol_value 67 PARAMS ((bfd *, coff_symbol_type *, struct internal_syment *)); 68static char *build_debug_section 69 PARAMS ((bfd *)); 70static char *copy_name 71 PARAMS ((bfd *, char *, size_t)); 72 73#define STRING_SIZE_SIZE (4) 74 75/* Take a section header read from a coff file (in HOST byte order), 76 and make a BFD "section" out of it. This is used by ECOFF. */ 77static boolean 78make_a_section_from_file (abfd, hdr, target_index) 79 bfd *abfd; 80 struct internal_scnhdr *hdr; 81 unsigned int target_index; 82{ 83 asection *return_section; 84 char *name; 85 boolean result = true; 86 flagword flags; 87 88 name = NULL; 89 90 /* Handle long section names as in PE. */ 91 if (bfd_coff_long_section_names (abfd) 92 && hdr->s_name[0] == '/') 93 { 94 char buf[SCNNMLEN]; 95 long strindex; 96 char *p; 97 const char *strings; 98 99 memcpy (buf, hdr->s_name + 1, SCNNMLEN - 1); 100 buf[SCNNMLEN - 1] = '\0'; 101 strindex = strtol (buf, &p, 10); 102 if (*p == '\0' && strindex >= 0) 103 { 104 strings = _bfd_coff_read_string_table (abfd); 105 if (strings == NULL) 106 return false; 107 /* FIXME: For extra safety, we should make sure that 108 strindex does not run us past the end, but right now we 109 don't know the length of the string table. */ 110 strings += strindex; 111 name = bfd_alloc (abfd, (bfd_size_type) strlen (strings) + 1); 112 if (name == NULL) 113 return false; 114 strcpy (name, strings); 115 } 116 } 117 118 if (name == NULL) 119 { 120 /* Assorted wastage to null-terminate the name, thanks AT&T! */ 121 name = bfd_alloc (abfd, (bfd_size_type) sizeof (hdr->s_name) + 1); 122 if (name == NULL) 123 return false; 124 strncpy (name, (char *) &hdr->s_name[0], sizeof (hdr->s_name)); 125 name[sizeof (hdr->s_name)] = 0; 126 } 127 128 return_section = bfd_make_section_anyway (abfd, name); 129 if (return_section == NULL) 130 return false; 131 132 return_section->vma = hdr->s_vaddr; 133 return_section->lma = hdr->s_paddr; 134 return_section->_raw_size = hdr->s_size; 135 return_section->filepos = hdr->s_scnptr; 136 return_section->rel_filepos = hdr->s_relptr; 137 return_section->reloc_count = hdr->s_nreloc; 138 139 bfd_coff_set_alignment_hook (abfd, return_section, hdr); 140 141 return_section->line_filepos = hdr->s_lnnoptr; 142 143 return_section->lineno_count = hdr->s_nlnno; 144 return_section->userdata = NULL; 145 return_section->next = (asection *) NULL; 146 return_section->target_index = target_index; 147 148 if (! bfd_coff_styp_to_sec_flags_hook (abfd, hdr, name, return_section, 149 & flags)) 150 result = false; 151 152 return_section->flags = flags; 153 154 /* At least on i386-coff, the line number count for a shared library 155 section must be ignored. */ 156 if ((return_section->flags & SEC_COFF_SHARED_LIBRARY) != 0) 157 return_section->lineno_count = 0; 158 159 if (hdr->s_nreloc != 0) 160 return_section->flags |= SEC_RELOC; 161 /* FIXME: should this check 'hdr->s_size > 0' */ 162 if (hdr->s_scnptr != 0) 163 return_section->flags |= SEC_HAS_CONTENTS; 164 165 return result; 166} 167 168/* Read in a COFF object and make it into a BFD. This is used by 169 ECOFF as well. */ 170 171static const bfd_target * 172coff_real_object_p (abfd, nscns, internal_f, internal_a) 173 bfd *abfd; 174 unsigned nscns; 175 struct internal_filehdr *internal_f; 176 struct internal_aouthdr *internal_a; 177{ 178 flagword oflags = abfd->flags; 179 bfd_vma ostart = bfd_get_start_address (abfd); 180 PTR tdata; 181 PTR tdata_save; 182 bfd_size_type readsize; /* length of file_info */ 183 unsigned int scnhsz; 184 char *external_sections; 185 186 if (!(internal_f->f_flags & F_RELFLG)) 187 abfd->flags |= HAS_RELOC; 188 if ((internal_f->f_flags & F_EXEC)) 189 abfd->flags |= EXEC_P; 190 if (!(internal_f->f_flags & F_LNNO)) 191 abfd->flags |= HAS_LINENO; 192 if (!(internal_f->f_flags & F_LSYMS)) 193 abfd->flags |= HAS_LOCALS; 194 195 /* FIXME: How can we set D_PAGED correctly? */ 196 if ((internal_f->f_flags & F_EXEC) != 0) 197 abfd->flags |= D_PAGED; 198 199 bfd_get_symcount (abfd) = internal_f->f_nsyms; 200 if (internal_f->f_nsyms) 201 abfd->flags |= HAS_SYMS; 202 203 if (internal_a != (struct internal_aouthdr *) NULL) 204 bfd_get_start_address (abfd) = internal_a->entry; 205 else 206 bfd_get_start_address (abfd) = 0; 207 208 /* Set up the tdata area. ECOFF uses its own routine, and overrides 209 abfd->flags. */ 210 tdata_save = abfd->tdata.any; 211 tdata = bfd_coff_mkobject_hook (abfd, (PTR) internal_f, (PTR) internal_a); 212 if (tdata == NULL) 213 goto fail2; 214 215 scnhsz = bfd_coff_scnhsz (abfd); 216 readsize = (bfd_size_type) nscns * scnhsz; 217 external_sections = (char *) bfd_alloc (abfd, readsize); 218 if (!external_sections) 219 goto fail; 220 221 if (bfd_bread ((PTR) external_sections, readsize, abfd) != readsize) 222 goto fail; 223 224 /* Set the arch/mach *before* swapping in sections; section header swapping 225 may depend on arch/mach info. */ 226 if (! bfd_coff_set_arch_mach_hook (abfd, (PTR) internal_f)) 227 goto fail; 228 229 /* Now copy data as required; construct all asections etc */ 230 if (nscns != 0) 231 { 232 unsigned int i; 233 for (i = 0; i < nscns; i++) 234 { 235 struct internal_scnhdr tmp; 236 bfd_coff_swap_scnhdr_in (abfd, 237 (PTR) (external_sections + i * scnhsz), 238 (PTR) & tmp); 239 if (! make_a_section_from_file (abfd, &tmp, i + 1)) 240 goto fail; 241 } 242 } 243 244 /* make_abs_section (abfd); */ 245 246 return abfd->xvec; 247 248 fail: 249 bfd_release (abfd, tdata); 250 fail2: 251 abfd->tdata.any = tdata_save; 252 abfd->flags = oflags; 253 bfd_get_start_address (abfd) = ostart; 254 return (const bfd_target *) NULL; 255} 256 257/* Turn a COFF file into a BFD, but fail with bfd_error_wrong_format if it is 258 not a COFF file. This is also used by ECOFF. */ 259 260const bfd_target * 261coff_object_p (abfd) 262 bfd *abfd; 263{ 264 bfd_size_type filhsz; 265 bfd_size_type aoutsz; 266 unsigned int nscns; 267 PTR filehdr; 268 struct internal_filehdr internal_f; 269 struct internal_aouthdr internal_a; 270 271 /* figure out how much to read */ 272 filhsz = bfd_coff_filhsz (abfd); 273 aoutsz = bfd_coff_aoutsz (abfd); 274 275 filehdr = bfd_alloc (abfd, filhsz); 276 if (filehdr == NULL) 277 return NULL; 278 if (bfd_bread (filehdr, filhsz, abfd) != filhsz) 279 { 280 if (bfd_get_error () != bfd_error_system_call) 281 bfd_set_error (bfd_error_wrong_format); 282 bfd_release (abfd, filehdr); 283 return NULL; 284 } 285 bfd_coff_swap_filehdr_in (abfd, filehdr, &internal_f); 286 bfd_release (abfd, filehdr); 287 288 /* The XCOFF format has two sizes for the f_opthdr. SMALL_AOUTSZ 289 (less than aoutsz) used in object files and AOUTSZ (equal to 290 aoutsz) in executables. The bfd_coff_swap_aouthdr_in function 291 expects this header to be aoutsz bytes in length, so we use that 292 value in the call to bfd_alloc below. But we must be careful to 293 only read in f_opthdr bytes in the call to bfd_bread. We should 294 also attempt to catch corrupt or non-COFF binaries with a strange 295 value for f_opthdr. */ 296 if (! bfd_coff_bad_format_hook (abfd, &internal_f) 297 || internal_f.f_opthdr > aoutsz) 298 { 299 bfd_set_error (bfd_error_wrong_format); 300 return NULL; 301 } 302 nscns = internal_f.f_nscns; 303 304 if (internal_f.f_opthdr) 305 { 306 PTR opthdr; 307 308 opthdr = bfd_alloc (abfd, aoutsz); 309 if (opthdr == NULL) 310 return NULL; 311 if (bfd_bread (opthdr, (bfd_size_type) internal_f.f_opthdr, abfd) 312 != internal_f.f_opthdr) 313 { 314 bfd_release (abfd, opthdr); 315 return NULL; 316 } 317 bfd_coff_swap_aouthdr_in (abfd, opthdr, (PTR) &internal_a); 318 bfd_release (abfd, opthdr); 319 } 320 321 return coff_real_object_p (abfd, nscns, &internal_f, 322 (internal_f.f_opthdr != 0 323 ? &internal_a 324 : (struct internal_aouthdr *) NULL)); 325} 326 327/* Get the BFD section from a COFF symbol section number. */ 328 329asection * 330coff_section_from_bfd_index (abfd, index) 331 bfd *abfd; 332 int index; 333{ 334 struct sec *answer = abfd->sections; 335 336 if (index == N_ABS) 337 return bfd_abs_section_ptr; 338 if (index == N_UNDEF) 339 return bfd_und_section_ptr; 340 if (index == N_DEBUG) 341 return bfd_abs_section_ptr; 342 343 while (answer) 344 { 345 if (answer->target_index == index) 346 return answer; 347 answer = answer->next; 348 } 349 350 /* We should not reach this point, but the SCO 3.2v4 /lib/libc_s.a 351 has a bad symbol table in biglitpow.o. */ 352 return bfd_und_section_ptr; 353} 354 355/* Get the upper bound of a COFF symbol table. */ 356 357long 358coff_get_symtab_upper_bound (abfd) 359 bfd *abfd; 360{ 361 if (!bfd_coff_slurp_symbol_table (abfd)) 362 return -1; 363 364 return (bfd_get_symcount (abfd) + 1) * (sizeof (coff_symbol_type *)); 365} 366 367/* Canonicalize a COFF symbol table. */ 368 369long 370coff_get_symtab (abfd, alocation) 371 bfd *abfd; 372 asymbol **alocation; 373{ 374 unsigned int counter; 375 coff_symbol_type *symbase; 376 coff_symbol_type **location = (coff_symbol_type **) alocation; 377 378 if (!bfd_coff_slurp_symbol_table (abfd)) 379 return -1; 380 381 symbase = obj_symbols (abfd); 382 counter = bfd_get_symcount (abfd); 383 while (counter-- > 0) 384 *location++ = symbase++; 385 386 *location = NULL; 387 388 return bfd_get_symcount (abfd); 389} 390 391/* Get the name of a symbol. The caller must pass in a buffer of size 392 >= SYMNMLEN + 1. */ 393 394const char * 395_bfd_coff_internal_syment_name (abfd, sym, buf) 396 bfd *abfd; 397 const struct internal_syment *sym; 398 char *buf; 399{ 400 /* FIXME: It's not clear this will work correctly if sizeof 401 (_n_zeroes) != 4. */ 402 if (sym->_n._n_n._n_zeroes != 0 403 || sym->_n._n_n._n_offset == 0) 404 { 405 memcpy (buf, sym->_n._n_name, SYMNMLEN); 406 buf[SYMNMLEN] = '\0'; 407 return buf; 408 } 409 else 410 { 411 const char *strings; 412 413 BFD_ASSERT (sym->_n._n_n._n_offset >= STRING_SIZE_SIZE); 414 strings = obj_coff_strings (abfd); 415 if (strings == NULL) 416 { 417 strings = _bfd_coff_read_string_table (abfd); 418 if (strings == NULL) 419 return NULL; 420 } 421 return strings + sym->_n._n_n._n_offset; 422 } 423} 424 425/* Read in and swap the relocs. This returns a buffer holding the 426 relocs for section SEC in file ABFD. If CACHE is true and 427 INTERNAL_RELOCS is NULL, the relocs read in will be saved in case 428 the function is called again. If EXTERNAL_RELOCS is not NULL, it 429 is a buffer large enough to hold the unswapped relocs. If 430 INTERNAL_RELOCS is not NULL, it is a buffer large enough to hold 431 the swapped relocs. If REQUIRE_INTERNAL is true, then the return 432 value must be INTERNAL_RELOCS. The function returns NULL on error. */ 433 434struct internal_reloc * 435_bfd_coff_read_internal_relocs (abfd, sec, cache, external_relocs, 436 require_internal, internal_relocs) 437 bfd *abfd; 438 asection *sec; 439 boolean cache; 440 bfd_byte *external_relocs; 441 boolean require_internal; 442 struct internal_reloc *internal_relocs; 443{ 444 bfd_size_type relsz; 445 bfd_byte *free_external = NULL; 446 struct internal_reloc *free_internal = NULL; 447 bfd_byte *erel; 448 bfd_byte *erel_end; 449 struct internal_reloc *irel; 450 bfd_size_type amt; 451 452 if (coff_section_data (abfd, sec) != NULL 453 && coff_section_data (abfd, sec)->relocs != NULL) 454 { 455 if (! require_internal) 456 return coff_section_data (abfd, sec)->relocs; 457 memcpy (internal_relocs, coff_section_data (abfd, sec)->relocs, 458 sec->reloc_count * sizeof (struct internal_reloc)); 459 return internal_relocs; 460 } 461 462 relsz = bfd_coff_relsz (abfd); 463 464 amt = sec->reloc_count * relsz; 465 if (external_relocs == NULL) 466 { 467 free_external = (bfd_byte *) bfd_malloc (amt); 468 if (free_external == NULL && sec->reloc_count > 0) 469 goto error_return; 470 external_relocs = free_external; 471 } 472 473 if (bfd_seek (abfd, sec->rel_filepos, SEEK_SET) != 0 474 || bfd_bread (external_relocs, amt, abfd) != amt) 475 goto error_return; 476 477 if (internal_relocs == NULL) 478 { 479 amt = sec->reloc_count; 480 amt *= sizeof (struct internal_reloc); 481 free_internal = (struct internal_reloc *) bfd_malloc (amt); 482 if (free_internal == NULL && sec->reloc_count > 0) 483 goto error_return; 484 internal_relocs = free_internal; 485 } 486 487 /* Swap in the relocs. */ 488 erel = external_relocs; 489 erel_end = erel + relsz * sec->reloc_count; 490 irel = internal_relocs; 491 for (; erel < erel_end; erel += relsz, irel++) 492 bfd_coff_swap_reloc_in (abfd, (PTR) erel, (PTR) irel); 493 494 if (free_external != NULL) 495 { 496 free (free_external); 497 free_external = NULL; 498 } 499 500 if (cache && free_internal != NULL) 501 { 502 if (coff_section_data (abfd, sec) == NULL) 503 { 504 amt = sizeof (struct coff_section_tdata); 505 sec->used_by_bfd = (PTR) bfd_zalloc (abfd, amt); 506 if (sec->used_by_bfd == NULL) 507 goto error_return; 508 coff_section_data (abfd, sec)->contents = NULL; 509 } 510 coff_section_data (abfd, sec)->relocs = free_internal; 511 } 512 513 return internal_relocs; 514 515 error_return: 516 if (free_external != NULL) 517 free (free_external); 518 if (free_internal != NULL) 519 free (free_internal); 520 return NULL; 521} 522 523/* Set lineno_count for the output sections of a COFF file. */ 524 525int 526coff_count_linenumbers (abfd) 527 bfd *abfd; 528{ 529 unsigned int limit = bfd_get_symcount (abfd); 530 unsigned int i; 531 int total = 0; 532 asymbol **p; 533 asection *s; 534 535 if (limit == 0) 536 { 537 /* This may be from the backend linker, in which case the 538 lineno_count in the sections is correct. */ 539 for (s = abfd->sections; s != NULL; s = s->next) 540 total += s->lineno_count; 541 return total; 542 } 543 544 for (s = abfd->sections; s != NULL; s = s->next) 545 BFD_ASSERT (s->lineno_count == 0); 546 547 for (p = abfd->outsymbols, i = 0; i < limit; i++, p++) 548 { 549 asymbol *q_maybe = *p; 550 551 if (bfd_family_coff (bfd_asymbol_bfd (q_maybe))) 552 { 553 coff_symbol_type *q = coffsymbol (q_maybe); 554 555 /* The AIX 4.1 compiler can sometimes generate line numbers 556 attached to debugging symbols. We try to simply ignore 557 those here. */ 558 if (q->lineno != NULL 559 && q->symbol.section->owner != NULL) 560 { 561 /* This symbol has line numbers. Increment the owning 562 section's linenumber count. */ 563 alent *l = q->lineno; 564 565 do 566 { 567 asection * sec = q->symbol.section->output_section; 568 569 /* Do not try to update fields in read-only sections. */ 570 if (! bfd_is_const_section (sec)) 571 sec->lineno_count ++; 572 573 ++total; 574 ++l; 575 } 576 while (l->line_number != 0); 577 } 578 } 579 } 580 581 return total; 582} 583 584/* Takes a bfd and a symbol, returns a pointer to the coff specific 585 area of the symbol if there is one. */ 586 587coff_symbol_type * 588coff_symbol_from (ignore_abfd, symbol) 589 bfd *ignore_abfd ATTRIBUTE_UNUSED; 590 asymbol *symbol; 591{ 592 if (!bfd_family_coff (bfd_asymbol_bfd (symbol))) 593 return (coff_symbol_type *) NULL; 594 595 if (bfd_asymbol_bfd (symbol)->tdata.coff_obj_data == (coff_data_type *) NULL) 596 return (coff_symbol_type *) NULL; 597 598 return (coff_symbol_type *) symbol; 599} 600 601static void 602fixup_symbol_value (abfd, coff_symbol_ptr, syment) 603 bfd *abfd; 604 coff_symbol_type *coff_symbol_ptr; 605 struct internal_syment *syment; 606{ 607 608 /* Normalize the symbol flags */ 609 if (bfd_is_com_section (coff_symbol_ptr->symbol.section)) 610 { 611 /* a common symbol is undefined with a value */ 612 syment->n_scnum = N_UNDEF; 613 syment->n_value = coff_symbol_ptr->symbol.value; 614 } 615 else if ((coff_symbol_ptr->symbol.flags & BSF_DEBUGGING) != 0 616 && (coff_symbol_ptr->symbol.flags & BSF_DEBUGGING_RELOC) == 0) 617 { 618 syment->n_value = coff_symbol_ptr->symbol.value; 619 } 620 else if (bfd_is_und_section (coff_symbol_ptr->symbol.section)) 621 { 622 syment->n_scnum = N_UNDEF; 623 syment->n_value = 0; 624 } 625 /* FIXME: Do we need to handle the absolute section here? */ 626 else 627 { 628 if (coff_symbol_ptr->symbol.section) 629 { 630 syment->n_scnum = 631 coff_symbol_ptr->symbol.section->output_section->target_index; 632 633 syment->n_value = (coff_symbol_ptr->symbol.value 634 + coff_symbol_ptr->symbol.section->output_offset); 635 if (! obj_pe (abfd)) 636 { 637 syment->n_value += (syment->n_sclass == C_STATLAB) 638 ? coff_symbol_ptr->symbol.section->output_section->lma 639 : coff_symbol_ptr->symbol.section->output_section->vma; 640 } 641 } 642 else 643 { 644 BFD_ASSERT (0); 645 /* This can happen, but I don't know why yet (steve@cygnus.com) */ 646 syment->n_scnum = N_ABS; 647 syment->n_value = coff_symbol_ptr->symbol.value; 648 } 649 } 650} 651 652/* Run through all the symbols in the symbol table and work out what 653 their indexes into the symbol table will be when output. 654 655 Coff requires that each C_FILE symbol points to the next one in the 656 chain, and that the last one points to the first external symbol. We 657 do that here too. */ 658 659boolean 660coff_renumber_symbols (bfd_ptr, first_undef) 661 bfd *bfd_ptr; 662 int *first_undef; 663{ 664 unsigned int symbol_count = bfd_get_symcount (bfd_ptr); 665 asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols; 666 unsigned int native_index = 0; 667 struct internal_syment *last_file = (struct internal_syment *) NULL; 668 unsigned int symbol_index; 669 670 /* COFF demands that undefined symbols come after all other symbols. 671 Since we don't need to impose this extra knowledge on all our 672 client programs, deal with that here. Sort the symbol table; 673 just move the undefined symbols to the end, leaving the rest 674 alone. The O'Reilly book says that defined global symbols come 675 at the end before the undefined symbols, so we do that here as 676 well. */ 677 /* @@ Do we have some condition we could test for, so we don't always 678 have to do this? I don't think relocatability is quite right, but 679 I'm not certain. [raeburn:19920508.1711EST] */ 680 { 681 asymbol **newsyms; 682 unsigned int i; 683 bfd_size_type amt; 684 685 amt = sizeof (asymbol *) * ((bfd_size_type) symbol_count + 1); 686 newsyms = (asymbol **) bfd_alloc (bfd_ptr, amt); 687 if (!newsyms) 688 return false; 689 bfd_ptr->outsymbols = newsyms; 690 for (i = 0; i < symbol_count; i++) 691 if ((symbol_ptr_ptr[i]->flags & BSF_NOT_AT_END) != 0 692 || (!bfd_is_und_section (symbol_ptr_ptr[i]->section) 693 && !bfd_is_com_section (symbol_ptr_ptr[i]->section) 694 && ((symbol_ptr_ptr[i]->flags & BSF_FUNCTION) != 0 695 || ((symbol_ptr_ptr[i]->flags & (BSF_GLOBAL | BSF_WEAK)) 696 == 0)))) 697 *newsyms++ = symbol_ptr_ptr[i]; 698 699 for (i = 0; i < symbol_count; i++) 700 if ((symbol_ptr_ptr[i]->flags & BSF_NOT_AT_END) == 0 701 && !bfd_is_und_section (symbol_ptr_ptr[i]->section) 702 && (bfd_is_com_section (symbol_ptr_ptr[i]->section) 703 || ((symbol_ptr_ptr[i]->flags & BSF_FUNCTION) == 0 704 && ((symbol_ptr_ptr[i]->flags & (BSF_GLOBAL | BSF_WEAK)) 705 != 0)))) 706 *newsyms++ = symbol_ptr_ptr[i]; 707 708 *first_undef = newsyms - bfd_ptr->outsymbols; 709 710 for (i = 0; i < symbol_count; i++) 711 if ((symbol_ptr_ptr[i]->flags & BSF_NOT_AT_END) == 0 712 && bfd_is_und_section (symbol_ptr_ptr[i]->section)) 713 *newsyms++ = symbol_ptr_ptr[i]; 714 *newsyms = (asymbol *) NULL; 715 symbol_ptr_ptr = bfd_ptr->outsymbols; 716 } 717 718 for (symbol_index = 0; symbol_index < symbol_count; symbol_index++) 719 { 720 coff_symbol_type *coff_symbol_ptr = coff_symbol_from (bfd_ptr, symbol_ptr_ptr[symbol_index]); 721 symbol_ptr_ptr[symbol_index]->udata.i = symbol_index; 722 if (coff_symbol_ptr && coff_symbol_ptr->native) 723 { 724 combined_entry_type *s = coff_symbol_ptr->native; 725 int i; 726 727 if (s->u.syment.n_sclass == C_FILE) 728 { 729 if (last_file != (struct internal_syment *) NULL) 730 last_file->n_value = native_index; 731 last_file = &(s->u.syment); 732 } 733 else 734 { 735 736 /* Modify the symbol values according to their section and 737 type */ 738 739 fixup_symbol_value (bfd_ptr, coff_symbol_ptr, &(s->u.syment)); 740 } 741 for (i = 0; i < s->u.syment.n_numaux + 1; i++) 742 s[i].offset = native_index++; 743 } 744 else 745 { 746 native_index++; 747 } 748 } 749 obj_conv_table_size (bfd_ptr) = native_index; 750 751 return true; 752} 753 754/* Run thorough the symbol table again, and fix it so that all 755 pointers to entries are changed to the entries' index in the output 756 symbol table. */ 757 758void 759coff_mangle_symbols (bfd_ptr) 760 bfd *bfd_ptr; 761{ 762 unsigned int symbol_count = bfd_get_symcount (bfd_ptr); 763 asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols; 764 unsigned int symbol_index; 765 766 for (symbol_index = 0; symbol_index < symbol_count; symbol_index++) 767 { 768 coff_symbol_type *coff_symbol_ptr = 769 coff_symbol_from (bfd_ptr, symbol_ptr_ptr[symbol_index]); 770 771 if (coff_symbol_ptr && coff_symbol_ptr->native) 772 { 773 int i; 774 combined_entry_type *s = coff_symbol_ptr->native; 775 776 if (s->fix_value) 777 { 778 /* FIXME: We should use a union here. */ 779 s->u.syment.n_value = 780 (bfd_vma)((combined_entry_type *) 781 ((unsigned long) s->u.syment.n_value))->offset; 782 s->fix_value = 0; 783 } 784 if (s->fix_line) 785 { 786 /* The value is the offset into the line number entries 787 for the symbol's section. On output, the symbol's 788 section should be N_DEBUG. */ 789 s->u.syment.n_value = 790 (coff_symbol_ptr->symbol.section->output_section->line_filepos 791 + s->u.syment.n_value * bfd_coff_linesz (bfd_ptr)); 792 coff_symbol_ptr->symbol.section = 793 coff_section_from_bfd_index (bfd_ptr, N_DEBUG); 794 BFD_ASSERT (coff_symbol_ptr->symbol.flags & BSF_DEBUGGING); 795 } 796 for (i = 0; i < s->u.syment.n_numaux; i++) 797 { 798 combined_entry_type *a = s + i + 1; 799 if (a->fix_tag) 800 { 801 a->u.auxent.x_sym.x_tagndx.l = 802 a->u.auxent.x_sym.x_tagndx.p->offset; 803 a->fix_tag = 0; 804 } 805 if (a->fix_end) 806 { 807 a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l = 808 a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p->offset; 809 a->fix_end = 0; 810 } 811 if (a->fix_scnlen) 812 { 813 a->u.auxent.x_csect.x_scnlen.l = 814 a->u.auxent.x_csect.x_scnlen.p->offset; 815 a->fix_scnlen = 0; 816 } 817 } 818 } 819 } 820} 821 822static void 823coff_fix_symbol_name (abfd, symbol, native, string_size_p, 824 debug_string_section_p, debug_string_size_p) 825 bfd *abfd; 826 asymbol *symbol; 827 combined_entry_type *native; 828 bfd_size_type *string_size_p; 829 asection **debug_string_section_p; 830 bfd_size_type *debug_string_size_p; 831{ 832 unsigned int name_length; 833 union internal_auxent *auxent; 834 char *name = (char *) (symbol->name); 835 836 if (name == (char *) NULL) 837 { 838 /* coff symbols always have names, so we'll make one up */ 839 symbol->name = "strange"; 840 name = (char *) symbol->name; 841 } 842 name_length = strlen (name); 843 844 if (native->u.syment.n_sclass == C_FILE 845 && native->u.syment.n_numaux > 0) 846 { 847 unsigned int filnmlen; 848 849 if (bfd_coff_force_symnames_in_strings (abfd)) 850 { 851 native->u.syment._n._n_n._n_offset = 852 (*string_size_p + STRING_SIZE_SIZE); 853 native->u.syment._n._n_n._n_zeroes = 0; 854 *string_size_p += 6; /* strlen(".file") + 1 */ 855 } 856 else 857 strncpy (native->u.syment._n._n_name, ".file", SYMNMLEN); 858 859 auxent = &(native + 1)->u.auxent; 860 861 filnmlen = bfd_coff_filnmlen (abfd); 862 863 if (bfd_coff_long_filenames (abfd)) 864 { 865 if (name_length <= filnmlen) 866 { 867 strncpy (auxent->x_file.x_fname, name, filnmlen); 868 } 869 else 870 { 871 auxent->x_file.x_n.x_offset = *string_size_p + STRING_SIZE_SIZE; 872 auxent->x_file.x_n.x_zeroes = 0; 873 *string_size_p += name_length + 1; 874 } 875 } 876 else 877 { 878 strncpy (auxent->x_file.x_fname, name, filnmlen); 879 if (name_length > filnmlen) 880 name[filnmlen] = '\0'; 881 } 882 } 883 else 884 { 885 if (name_length <= SYMNMLEN && !bfd_coff_force_symnames_in_strings (abfd)) 886 { 887 /* This name will fit into the symbol neatly */ 888 strncpy (native->u.syment._n._n_name, symbol->name, SYMNMLEN); 889 } 890 else if (!bfd_coff_symname_in_debug (abfd, &native->u.syment)) 891 { 892 native->u.syment._n._n_n._n_offset = (*string_size_p 893 + STRING_SIZE_SIZE); 894 native->u.syment._n._n_n._n_zeroes = 0; 895 *string_size_p += name_length + 1; 896 } 897 else 898 { 899 file_ptr filepos; 900 bfd_byte buf[4]; 901 int prefix_len = bfd_coff_debug_string_prefix_length (abfd); 902 903 /* This name should be written into the .debug section. For 904 some reason each name is preceded by a two byte length 905 and also followed by a null byte. FIXME: We assume that 906 the .debug section has already been created, and that it 907 is large enough. */ 908 if (*debug_string_section_p == (asection *) NULL) 909 *debug_string_section_p = bfd_get_section_by_name (abfd, ".debug"); 910 filepos = bfd_tell (abfd); 911 if (prefix_len == 4) 912 bfd_put_32 (abfd, (bfd_vma) (name_length + 1), buf); 913 else 914 bfd_put_16 (abfd, (bfd_vma) (name_length + 1), buf); 915 916 if (!bfd_set_section_contents (abfd, 917 *debug_string_section_p, 918 (PTR) buf, 919 (file_ptr) *debug_string_size_p, 920 (bfd_size_type) prefix_len) 921 || !bfd_set_section_contents (abfd, 922 *debug_string_section_p, 923 (PTR) symbol->name, 924 (file_ptr) (*debug_string_size_p 925 + prefix_len), 926 (bfd_size_type) name_length + 1)) 927 abort (); 928 if (bfd_seek (abfd, filepos, SEEK_SET) != 0) 929 abort (); 930 native->u.syment._n._n_n._n_offset = 931 *debug_string_size_p + prefix_len; 932 native->u.syment._n._n_n._n_zeroes = 0; 933 *debug_string_size_p += name_length + 1 + prefix_len; 934 } 935 } 936} 937 938/* We need to keep track of the symbol index so that when we write out 939 the relocs we can get the index for a symbol. This method is a 940 hack. FIXME. */ 941 942#define set_index(symbol, idx) ((symbol)->udata.i = (idx)) 943 944/* Write a symbol out to a COFF file. */ 945 946static boolean 947coff_write_symbol (abfd, symbol, native, written, string_size_p, 948 debug_string_section_p, debug_string_size_p) 949 bfd *abfd; 950 asymbol *symbol; 951 combined_entry_type *native; 952 bfd_vma *written; 953 bfd_size_type *string_size_p; 954 asection **debug_string_section_p; 955 bfd_size_type *debug_string_size_p; 956{ 957 unsigned int numaux = native->u.syment.n_numaux; 958 int type = native->u.syment.n_type; 959 int class = native->u.syment.n_sclass; 960 PTR buf; 961 bfd_size_type symesz; 962 963 if (native->u.syment.n_sclass == C_FILE) 964 symbol->flags |= BSF_DEBUGGING; 965 966 if (symbol->flags & BSF_DEBUGGING 967 && bfd_is_abs_section (symbol->section)) 968 { 969 native->u.syment.n_scnum = N_DEBUG; 970 } 971 else if (bfd_is_abs_section (symbol->section)) 972 { 973 native->u.syment.n_scnum = N_ABS; 974 } 975 else if (bfd_is_und_section (symbol->section)) 976 { 977 native->u.syment.n_scnum = N_UNDEF; 978 } 979 else 980 { 981 native->u.syment.n_scnum = 982 symbol->section->output_section->target_index; 983 } 984 985 coff_fix_symbol_name (abfd, symbol, native, string_size_p, 986 debug_string_section_p, debug_string_size_p); 987 988 symesz = bfd_coff_symesz (abfd); 989 buf = bfd_alloc (abfd, symesz); 990 if (!buf) 991 return false; 992 bfd_coff_swap_sym_out (abfd, &native->u.syment, buf); 993 if (bfd_bwrite (buf, symesz, abfd) != symesz) 994 return false; 995 bfd_release (abfd, buf); 996 997 if (native->u.syment.n_numaux > 0) 998 { 999 bfd_size_type auxesz; 1000 unsigned int j; 1001 1002 auxesz = bfd_coff_auxesz (abfd); 1003 buf = bfd_alloc (abfd, auxesz); 1004 if (!buf) 1005 return false; 1006 for (j = 0; j < native->u.syment.n_numaux; j++) 1007 { 1008 bfd_coff_swap_aux_out (abfd, 1009 &((native + j + 1)->u.auxent), 1010 type, 1011 class, 1012 (int) j, 1013 native->u.syment.n_numaux, 1014 buf); 1015 if (bfd_bwrite (buf, auxesz, abfd) != auxesz) 1016 return false; 1017 } 1018 bfd_release (abfd, buf); 1019 } 1020 1021 /* Store the index for use when we write out the relocs. */ 1022 set_index (symbol, *written); 1023 1024 *written += numaux + 1; 1025 return true; 1026} 1027 1028/* Write out a symbol to a COFF file that does not come from a COFF 1029 file originally. This symbol may have been created by the linker, 1030 or we may be linking a non COFF file to a COFF file. */ 1031 1032static boolean 1033coff_write_alien_symbol (abfd, symbol, written, string_size_p, 1034 debug_string_section_p, debug_string_size_p) 1035 bfd *abfd; 1036 asymbol *symbol; 1037 bfd_vma *written; 1038 bfd_size_type *string_size_p; 1039 asection **debug_string_section_p; 1040 bfd_size_type *debug_string_size_p; 1041{ 1042 combined_entry_type *native; 1043 combined_entry_type dummy; 1044 1045 native = &dummy; 1046 native->u.syment.n_type = T_NULL; 1047 native->u.syment.n_flags = 0; 1048 if (bfd_is_und_section (symbol->section)) 1049 { 1050 native->u.syment.n_scnum = N_UNDEF; 1051 native->u.syment.n_value = symbol->value; 1052 } 1053 else if (bfd_is_com_section (symbol->section)) 1054 { 1055 native->u.syment.n_scnum = N_UNDEF; 1056 native->u.syment.n_value = symbol->value; 1057 } 1058 else if (symbol->flags & BSF_DEBUGGING) 1059 { 1060 /* There isn't much point to writing out a debugging symbol 1061 unless we are prepared to convert it into COFF debugging 1062 format. So, we just ignore them. We must clobber the symbol 1063 name to keep it from being put in the string table. */ 1064 symbol->name = ""; 1065 return true; 1066 } 1067 else 1068 { 1069 native->u.syment.n_scnum = 1070 symbol->section->output_section->target_index; 1071 native->u.syment.n_value = (symbol->value 1072 + symbol->section->output_offset); 1073 if (! obj_pe (abfd)) 1074 native->u.syment.n_value += symbol->section->output_section->vma; 1075 1076 /* Copy the any flags from the file header into the symbol. 1077 FIXME: Why? */ 1078 { 1079 coff_symbol_type *c = coff_symbol_from (abfd, symbol); 1080 if (c != (coff_symbol_type *) NULL) 1081 native->u.syment.n_flags = bfd_asymbol_bfd (&c->symbol)->flags; 1082 } 1083 } 1084 1085 native->u.syment.n_type = 0; 1086 if (symbol->flags & BSF_LOCAL) 1087 native->u.syment.n_sclass = C_STAT; 1088 else if (symbol->flags & BSF_WEAK) 1089 native->u.syment.n_sclass = obj_pe (abfd) ? C_NT_WEAK : C_WEAKEXT; 1090 else 1091 native->u.syment.n_sclass = C_EXT; 1092 native->u.syment.n_numaux = 0; 1093 1094 return coff_write_symbol (abfd, symbol, native, written, string_size_p, 1095 debug_string_section_p, debug_string_size_p); 1096} 1097 1098/* Write a native symbol to a COFF file. */ 1099 1100static boolean 1101coff_write_native_symbol (abfd, symbol, written, string_size_p, 1102 debug_string_section_p, debug_string_size_p) 1103 bfd *abfd; 1104 coff_symbol_type *symbol; 1105 bfd_vma *written; 1106 bfd_size_type *string_size_p; 1107 asection **debug_string_section_p; 1108 bfd_size_type *debug_string_size_p; 1109{ 1110 combined_entry_type *native = symbol->native; 1111 alent *lineno = symbol->lineno; 1112 1113 /* If this symbol has an associated line number, we must store the 1114 symbol index in the line number field. We also tag the auxent to 1115 point to the right place in the lineno table. */ 1116 if (lineno && !symbol->done_lineno && symbol->symbol.section->owner != NULL) 1117 { 1118 unsigned int count = 0; 1119 lineno[count].u.offset = *written; 1120 if (native->u.syment.n_numaux) 1121 { 1122 union internal_auxent *a = &((native + 1)->u.auxent); 1123 1124 a->x_sym.x_fcnary.x_fcn.x_lnnoptr = 1125 symbol->symbol.section->output_section->moving_line_filepos; 1126 } 1127 1128 /* Count and relocate all other linenumbers. */ 1129 count++; 1130 while (lineno[count].line_number != 0) 1131 { 1132#if 0 1133 /* 13 april 92. sac 1134 I've been told this, but still need proof: 1135 > The second bug is also in `bfd/coffcode.h'. This bug 1136 > causes the linker to screw up the pc-relocations for 1137 > all the line numbers in COFF code. This bug isn't only 1138 > specific to A29K implementations, but affects all 1139 > systems using COFF format binaries. Note that in COFF 1140 > object files, the line number core offsets output by 1141 > the assembler are relative to the start of each 1142 > procedure, not to the start of the .text section. This 1143 > patch relocates the line numbers relative to the 1144 > `native->u.syment.n_value' instead of the section 1145 > virtual address. 1146 > modular!olson@cs.arizona.edu (Jon Olson) 1147 */ 1148 lineno[count].u.offset += native->u.syment.n_value; 1149#else 1150 lineno[count].u.offset += 1151 (symbol->symbol.section->output_section->vma 1152 + symbol->symbol.section->output_offset); 1153#endif 1154 count++; 1155 } 1156 symbol->done_lineno = true; 1157 1158 if (! bfd_is_const_section (symbol->symbol.section->output_section)) 1159 symbol->symbol.section->output_section->moving_line_filepos += 1160 count * bfd_coff_linesz (abfd); 1161 } 1162 1163 return coff_write_symbol (abfd, &(symbol->symbol), native, written, 1164 string_size_p, debug_string_section_p, 1165 debug_string_size_p); 1166} 1167 1168/* Write out the COFF symbols. */ 1169 1170boolean 1171coff_write_symbols (abfd) 1172 bfd *abfd; 1173{ 1174 bfd_size_type string_size; 1175 asection *debug_string_section; 1176 bfd_size_type debug_string_size; 1177 unsigned int i; 1178 unsigned int limit = bfd_get_symcount (abfd); 1179 bfd_signed_vma written = 0; 1180 asymbol **p; 1181 1182 string_size = 0; 1183 debug_string_section = NULL; 1184 debug_string_size = 0; 1185 1186 /* If this target supports long section names, they must be put into 1187 the string table. This is supported by PE. This code must 1188 handle section names just as they are handled in 1189 coff_write_object_contents. */ 1190 if (bfd_coff_long_section_names (abfd)) 1191 { 1192 asection *o; 1193 1194 for (o = abfd->sections; o != NULL; o = o->next) 1195 { 1196 size_t len; 1197 1198 len = strlen (o->name); 1199 if (len > SCNNMLEN) 1200 string_size += len + 1; 1201 } 1202 } 1203 1204 /* Seek to the right place */ 1205 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0) 1206 return false; 1207 1208 /* Output all the symbols we have */ 1209 1210 written = 0; 1211 for (p = abfd->outsymbols, i = 0; i < limit; i++, p++) 1212 { 1213 asymbol *symbol = *p; 1214 coff_symbol_type *c_symbol = coff_symbol_from (abfd, symbol); 1215 1216 if (c_symbol == (coff_symbol_type *) NULL 1217 || c_symbol->native == (combined_entry_type *) NULL) 1218 { 1219 if (!coff_write_alien_symbol (abfd, symbol, &written, &string_size, 1220 &debug_string_section, 1221 &debug_string_size)) 1222 return false; 1223 } 1224 else 1225 { 1226 if (!coff_write_native_symbol (abfd, c_symbol, &written, 1227 &string_size, &debug_string_section, 1228 &debug_string_size)) 1229 return false; 1230 } 1231 } 1232 1233 obj_raw_syment_count (abfd) = written; 1234 1235 /* Now write out strings */ 1236 1237 if (string_size != 0) 1238 { 1239 unsigned int size = string_size + STRING_SIZE_SIZE; 1240 bfd_byte buffer[STRING_SIZE_SIZE]; 1241 1242#if STRING_SIZE_SIZE == 4 1243 H_PUT_32 (abfd, size, buffer); 1244#else 1245 #error Change H_PUT_32 1246#endif 1247 if (bfd_bwrite ((PTR) buffer, (bfd_size_type) sizeof (buffer), abfd) 1248 != sizeof (buffer)) 1249 return false; 1250 1251 /* Handle long section names. This code must handle section 1252 names just as they are handled in coff_write_object_contents. */ 1253 if (bfd_coff_long_section_names (abfd)) 1254 { 1255 asection *o; 1256 1257 for (o = abfd->sections; o != NULL; o = o->next) 1258 { 1259 size_t len; 1260 1261 len = strlen (o->name); 1262 if (len > SCNNMLEN) 1263 { 1264 if (bfd_bwrite (o->name, (bfd_size_type) (len + 1), abfd) 1265 != len + 1) 1266 return false; 1267 } 1268 } 1269 } 1270 1271 for (p = abfd->outsymbols, i = 0; 1272 i < limit; 1273 i++, p++) 1274 { 1275 asymbol *q = *p; 1276 size_t name_length = strlen (q->name); 1277 coff_symbol_type *c_symbol = coff_symbol_from (abfd, q); 1278 size_t maxlen; 1279 1280 /* Figure out whether the symbol name should go in the string 1281 table. Symbol names that are short enough are stored 1282 directly in the syment structure. File names permit a 1283 different, longer, length in the syment structure. On 1284 XCOFF, some symbol names are stored in the .debug section 1285 rather than in the string table. */ 1286 1287 if (c_symbol == NULL 1288 || c_symbol->native == NULL) 1289 { 1290 /* This is not a COFF symbol, so it certainly is not a 1291 file name, nor does it go in the .debug section. */ 1292 maxlen = bfd_coff_force_symnames_in_strings (abfd) ? 0 : SYMNMLEN; 1293 } 1294 else if (bfd_coff_symname_in_debug (abfd, 1295 &c_symbol->native->u.syment)) 1296 { 1297 /* This symbol name is in the XCOFF .debug section. 1298 Don't write it into the string table. */ 1299 maxlen = name_length; 1300 } 1301 else if (c_symbol->native->u.syment.n_sclass == C_FILE 1302 && c_symbol->native->u.syment.n_numaux > 0) 1303 { 1304 if (bfd_coff_force_symnames_in_strings (abfd)) 1305 { 1306 if (bfd_bwrite (".file", (bfd_size_type) 6, abfd) != 6) 1307 return false; 1308 } 1309 maxlen = bfd_coff_filnmlen (abfd); 1310 } 1311 else 1312 maxlen = bfd_coff_force_symnames_in_strings (abfd) ? 0 : SYMNMLEN; 1313 1314 if (name_length > maxlen) 1315 { 1316 if (bfd_bwrite ((PTR) (q->name), (bfd_size_type) name_length + 1, 1317 abfd) != name_length + 1) 1318 return false; 1319 } 1320 } 1321 } 1322 else 1323 { 1324 /* We would normally not write anything here, but we'll write 1325 out 4 so that any stupid coff reader which tries to read the 1326 string table even when there isn't one won't croak. */ 1327 unsigned int size = STRING_SIZE_SIZE; 1328 bfd_byte buffer[STRING_SIZE_SIZE]; 1329 1330#if STRING_SIZE_SIZE == 4 1331 H_PUT_32 (abfd, size, buffer); 1332#else 1333 #error Change H_PUT_32 1334#endif 1335 if (bfd_bwrite ((PTR) buffer, (bfd_size_type) STRING_SIZE_SIZE, abfd) 1336 != STRING_SIZE_SIZE) 1337 return false; 1338 } 1339 1340 /* Make sure the .debug section was created to be the correct size. 1341 We should create it ourselves on the fly, but we don't because 1342 BFD won't let us write to any section until we know how large all 1343 the sections are. We could still do it by making another pass 1344 over the symbols. FIXME. */ 1345 BFD_ASSERT (debug_string_size == 0 1346 || (debug_string_section != (asection *) NULL 1347 && (BFD_ALIGN (debug_string_size, 1348 1 << debug_string_section->alignment_power) 1349 == bfd_section_size (abfd, debug_string_section)))); 1350 1351 return true; 1352} 1353 1354boolean 1355coff_write_linenumbers (abfd) 1356 bfd *abfd; 1357{ 1358 asection *s; 1359 bfd_size_type linesz; 1360 PTR buff; 1361 1362 linesz = bfd_coff_linesz (abfd); 1363 buff = bfd_alloc (abfd, linesz); 1364 if (!buff) 1365 return false; 1366 for (s = abfd->sections; s != (asection *) NULL; s = s->next) 1367 { 1368 if (s->lineno_count) 1369 { 1370 asymbol **q = abfd->outsymbols; 1371 if (bfd_seek (abfd, s->line_filepos, SEEK_SET) != 0) 1372 return false; 1373 /* Find all the linenumbers in this section */ 1374 while (*q) 1375 { 1376 asymbol *p = *q; 1377 if (p->section->output_section == s) 1378 { 1379 alent *l = 1380 BFD_SEND (bfd_asymbol_bfd (p), _get_lineno, 1381 (bfd_asymbol_bfd (p), p)); 1382 if (l) 1383 { 1384 /* Found a linenumber entry, output */ 1385 struct internal_lineno out; 1386 memset ((PTR) & out, 0, sizeof (out)); 1387 out.l_lnno = 0; 1388 out.l_addr.l_symndx = l->u.offset; 1389 bfd_coff_swap_lineno_out (abfd, &out, buff); 1390 if (bfd_bwrite (buff, (bfd_size_type) linesz, abfd) 1391 != linesz) 1392 return false; 1393 l++; 1394 while (l->line_number) 1395 { 1396 out.l_lnno = l->line_number; 1397 out.l_addr.l_symndx = l->u.offset; 1398 bfd_coff_swap_lineno_out (abfd, &out, buff); 1399 if (bfd_bwrite (buff, (bfd_size_type) linesz, abfd) 1400 != linesz) 1401 return false; 1402 l++; 1403 } 1404 } 1405 } 1406 q++; 1407 } 1408 } 1409 } 1410 bfd_release (abfd, buff); 1411 return true; 1412} 1413 1414alent * 1415coff_get_lineno (ignore_abfd, symbol) 1416 bfd *ignore_abfd ATTRIBUTE_UNUSED; 1417 asymbol *symbol; 1418{ 1419 return coffsymbol (symbol)->lineno; 1420} 1421 1422#if 0 1423 1424/* This is only called from coff_add_missing_symbols, which has been 1425 disabled. */ 1426 1427asymbol * 1428coff_section_symbol (abfd, name) 1429 bfd *abfd; 1430 char *name; 1431{ 1432 asection *sec = bfd_make_section_old_way (abfd, name); 1433 asymbol *sym; 1434 combined_entry_type *csym; 1435 1436 sym = sec->symbol; 1437 csym = coff_symbol_from (abfd, sym)->native; 1438 /* Make sure back-end COFF stuff is there. */ 1439 if (csym == 0) 1440 { 1441 struct foo 1442 { 1443 coff_symbol_type sym; 1444 /* @@FIXME This shouldn't use a fixed size!! */ 1445 combined_entry_type e[10]; 1446 }; 1447 struct foo *f; 1448 1449 f = (struct foo *) bfd_zalloc (abfd, (bfd_size_type) sizeof (*f)); 1450 if (!f) 1451 { 1452 bfd_set_error (bfd_error_no_error); 1453 return NULL; 1454 } 1455 coff_symbol_from (abfd, sym)->native = csym = f->e; 1456 } 1457 csym[0].u.syment.n_sclass = C_STAT; 1458 csym[0].u.syment.n_numaux = 1; 1459/* SF_SET_STATICS (sym); @@ ??? */ 1460 csym[1].u.auxent.x_scn.x_scnlen = sec->_raw_size; 1461 csym[1].u.auxent.x_scn.x_nreloc = sec->reloc_count; 1462 csym[1].u.auxent.x_scn.x_nlinno = sec->lineno_count; 1463 1464 if (sec->output_section == NULL) 1465 { 1466 sec->output_section = sec; 1467 sec->output_offset = 0; 1468 } 1469 1470 return sym; 1471} 1472 1473#endif /* 0 */ 1474 1475/* This function transforms the offsets into the symbol table into 1476 pointers to syments. */ 1477 1478static void 1479coff_pointerize_aux (abfd, table_base, symbol, indaux, auxent) 1480 bfd *abfd; 1481 combined_entry_type *table_base; 1482 combined_entry_type *symbol; 1483 unsigned int indaux; 1484 combined_entry_type *auxent; 1485{ 1486 unsigned int type = symbol->u.syment.n_type; 1487 unsigned int class = symbol->u.syment.n_sclass; 1488 1489 if (coff_backend_info (abfd)->_bfd_coff_pointerize_aux_hook) 1490 { 1491 if ((*coff_backend_info (abfd)->_bfd_coff_pointerize_aux_hook) 1492 (abfd, table_base, symbol, indaux, auxent)) 1493 return; 1494 } 1495 1496 /* Don't bother if this is a file or a section */ 1497 if (class == C_STAT && type == T_NULL) 1498 return; 1499 if (class == C_FILE) 1500 return; 1501 1502 /* Otherwise patch up */ 1503#define N_TMASK coff_data (abfd)->local_n_tmask 1504#define N_BTSHFT coff_data (abfd)->local_n_btshft 1505 if ((ISFCN (type) || ISTAG (class) || class == C_BLOCK || class == C_FCN) 1506 && auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l > 0) 1507 { 1508 auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p = 1509 table_base + auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l; 1510 auxent->fix_end = 1; 1511 } 1512 /* A negative tagndx is meaningless, but the SCO 3.2v4 cc can 1513 generate one, so we must be careful to ignore it. */ 1514 if (auxent->u.auxent.x_sym.x_tagndx.l > 0) 1515 { 1516 auxent->u.auxent.x_sym.x_tagndx.p = 1517 table_base + auxent->u.auxent.x_sym.x_tagndx.l; 1518 auxent->fix_tag = 1; 1519 } 1520} 1521 1522/* Allocate space for the ".debug" section, and read it. 1523 We did not read the debug section until now, because 1524 we didn't want to go to the trouble until someone needed it. */ 1525 1526static char * 1527build_debug_section (abfd) 1528 bfd *abfd; 1529{ 1530 char *debug_section; 1531 file_ptr position; 1532 bfd_size_type sec_size; 1533 1534 asection *sect = bfd_get_section_by_name (abfd, ".debug"); 1535 1536 if (!sect) 1537 { 1538 bfd_set_error (bfd_error_no_debug_section); 1539 return NULL; 1540 } 1541 1542 sec_size = bfd_get_section_size_before_reloc (sect); 1543 debug_section = (PTR) bfd_alloc (abfd, sec_size); 1544 if (debug_section == NULL) 1545 return NULL; 1546 1547 /* Seek to the beginning of the `.debug' section and read it. 1548 Save the current position first; it is needed by our caller. 1549 Then read debug section and reset the file pointer. */ 1550 1551 position = bfd_tell (abfd); 1552 if (bfd_seek (abfd, sect->filepos, SEEK_SET) != 0 1553 || bfd_bread (debug_section, sec_size, abfd) != sec_size 1554 || bfd_seek (abfd, position, SEEK_SET) != 0) 1555 return NULL; 1556 return debug_section; 1557} 1558 1559/* Return a pointer to a malloc'd copy of 'name'. 'name' may not be 1560 \0-terminated, but will not exceed 'maxlen' characters. The copy *will* 1561 be \0-terminated. */ 1562static char * 1563copy_name (abfd, name, maxlen) 1564 bfd *abfd; 1565 char *name; 1566 size_t maxlen; 1567{ 1568 size_t len; 1569 char *newname; 1570 1571 for (len = 0; len < maxlen; ++len) 1572 { 1573 if (name[len] == '\0') 1574 { 1575 break; 1576 } 1577 } 1578 1579 if ((newname = (PTR) bfd_alloc (abfd, (bfd_size_type) len + 1)) == NULL) 1580 return (NULL); 1581 strncpy (newname, name, len); 1582 newname[len] = '\0'; 1583 return newname; 1584} 1585 1586/* Read in the external symbols. */ 1587 1588boolean 1589_bfd_coff_get_external_symbols (abfd) 1590 bfd *abfd; 1591{ 1592 bfd_size_type symesz; 1593 bfd_size_type size; 1594 PTR syms; 1595 1596 if (obj_coff_external_syms (abfd) != NULL) 1597 return true; 1598 1599 symesz = bfd_coff_symesz (abfd); 1600 1601 size = obj_raw_syment_count (abfd) * symesz; 1602 1603 syms = (PTR) bfd_malloc (size); 1604 if (syms == NULL && size != 0) 1605 return false; 1606 1607 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0 1608 || bfd_bread (syms, size, abfd) != size) 1609 { 1610 if (syms != NULL) 1611 free (syms); 1612 return false; 1613 } 1614 1615 obj_coff_external_syms (abfd) = syms; 1616 1617 return true; 1618} 1619 1620/* Read in the external strings. The strings are not loaded until 1621 they are needed. This is because we have no simple way of 1622 detecting a missing string table in an archive. */ 1623 1624const char * 1625_bfd_coff_read_string_table (abfd) 1626 bfd *abfd; 1627{ 1628 char extstrsize[STRING_SIZE_SIZE]; 1629 bfd_size_type strsize; 1630 char *strings; 1631 file_ptr pos; 1632 1633 if (obj_coff_strings (abfd) != NULL) 1634 return obj_coff_strings (abfd); 1635 1636 if (obj_sym_filepos (abfd) == 0) 1637 { 1638 bfd_set_error (bfd_error_no_symbols); 1639 return NULL; 1640 } 1641 1642 pos = obj_sym_filepos (abfd); 1643 pos += obj_raw_syment_count (abfd) * bfd_coff_symesz (abfd); 1644 if (bfd_seek (abfd, pos, SEEK_SET) != 0) 1645 return NULL; 1646 1647 if (bfd_bread (extstrsize, (bfd_size_type) sizeof extstrsize, abfd) 1648 != sizeof extstrsize) 1649 { 1650 if (bfd_get_error () != bfd_error_file_truncated) 1651 return NULL; 1652 1653 /* There is no string table. */ 1654 strsize = STRING_SIZE_SIZE; 1655 } 1656 else 1657 { 1658#if STRING_SIZE_SIZE == 4 1659 strsize = H_GET_32 (abfd, extstrsize); 1660#else 1661 #error Change H_GET_32 1662#endif 1663 } 1664 1665 if (strsize < STRING_SIZE_SIZE) 1666 { 1667 (*_bfd_error_handler) 1668 (_("%s: bad string table size %lu"), bfd_archive_filename (abfd), 1669 (unsigned long) strsize); 1670 bfd_set_error (bfd_error_bad_value); 1671 return NULL; 1672 } 1673 1674 strings = (char *) bfd_malloc (strsize); 1675 if (strings == NULL) 1676 return NULL; 1677 1678 if (bfd_bread (strings + STRING_SIZE_SIZE, strsize - STRING_SIZE_SIZE, abfd) 1679 != strsize - STRING_SIZE_SIZE) 1680 { 1681 free (strings); 1682 return NULL; 1683 } 1684 1685 obj_coff_strings (abfd) = strings; 1686 1687 return strings; 1688} 1689 1690/* Free up the external symbols and strings read from a COFF file. */ 1691 1692boolean 1693_bfd_coff_free_symbols (abfd) 1694 bfd *abfd; 1695{ 1696 if (obj_coff_external_syms (abfd) != NULL 1697 && ! obj_coff_keep_syms (abfd)) 1698 { 1699 free (obj_coff_external_syms (abfd)); 1700 obj_coff_external_syms (abfd) = NULL; 1701 } 1702 if (obj_coff_strings (abfd) != NULL 1703 && ! obj_coff_keep_strings (abfd)) 1704 { 1705 free (obj_coff_strings (abfd)); 1706 obj_coff_strings (abfd) = NULL; 1707 } 1708 return true; 1709} 1710 1711/* Read a symbol table into freshly bfd_allocated memory, swap it, and 1712 knit the symbol names into a normalized form. By normalized here I 1713 mean that all symbols have an n_offset pointer that points to a null- 1714 terminated string. */ 1715 1716combined_entry_type * 1717coff_get_normalized_symtab (abfd) 1718 bfd *abfd; 1719{ 1720 combined_entry_type *internal; 1721 combined_entry_type *internal_ptr; 1722 combined_entry_type *symbol_ptr; 1723 combined_entry_type *internal_end; 1724 size_t symesz; 1725 char *raw_src; 1726 char *raw_end; 1727 const char *string_table = NULL; 1728 char *debug_section = NULL; 1729 bfd_size_type size; 1730 1731 if (obj_raw_syments (abfd) != NULL) 1732 return obj_raw_syments (abfd); 1733 1734 size = obj_raw_syment_count (abfd) * sizeof (combined_entry_type); 1735 internal = (combined_entry_type *) bfd_zalloc (abfd, size); 1736 if (internal == NULL && size != 0) 1737 return NULL; 1738 internal_end = internal + obj_raw_syment_count (abfd); 1739 1740 if (! _bfd_coff_get_external_symbols (abfd)) 1741 return NULL; 1742 1743 raw_src = (char *) obj_coff_external_syms (abfd); 1744 1745 /* mark the end of the symbols */ 1746 symesz = bfd_coff_symesz (abfd); 1747 raw_end = (char *) raw_src + obj_raw_syment_count (abfd) * symesz; 1748 1749 /* FIXME SOMEDAY. A string table size of zero is very weird, but 1750 probably possible. If one shows up, it will probably kill us. */ 1751 1752 /* Swap all the raw entries */ 1753 for (internal_ptr = internal; 1754 raw_src < raw_end; 1755 raw_src += symesz, internal_ptr++) 1756 { 1757 1758 unsigned int i; 1759 bfd_coff_swap_sym_in (abfd, (PTR) raw_src, 1760 (PTR) & internal_ptr->u.syment); 1761 symbol_ptr = internal_ptr; 1762 1763 for (i = 0; 1764 i < symbol_ptr->u.syment.n_numaux; 1765 i++) 1766 { 1767 internal_ptr++; 1768 raw_src += symesz; 1769 bfd_coff_swap_aux_in (abfd, (PTR) raw_src, 1770 symbol_ptr->u.syment.n_type, 1771 symbol_ptr->u.syment.n_sclass, 1772 (int) i, symbol_ptr->u.syment.n_numaux, 1773 &(internal_ptr->u.auxent)); 1774 coff_pointerize_aux (abfd, internal, symbol_ptr, i, 1775 internal_ptr); 1776 } 1777 } 1778 1779 /* Free the raw symbols, but not the strings (if we have them). */ 1780 obj_coff_keep_strings (abfd) = true; 1781 if (! _bfd_coff_free_symbols (abfd)) 1782 return NULL; 1783 1784 for (internal_ptr = internal; internal_ptr < internal_end; 1785 internal_ptr++) 1786 { 1787 if (internal_ptr->u.syment.n_sclass == C_FILE 1788 && internal_ptr->u.syment.n_numaux > 0) 1789 { 1790 /* make a file symbol point to the name in the auxent, since 1791 the text ".file" is redundant */ 1792 if ((internal_ptr + 1)->u.auxent.x_file.x_n.x_zeroes == 0) 1793 { 1794 /* the filename is a long one, point into the string table */ 1795 if (string_table == NULL) 1796 { 1797 string_table = _bfd_coff_read_string_table (abfd); 1798 if (string_table == NULL) 1799 return NULL; 1800 } 1801 1802 internal_ptr->u.syment._n._n_n._n_offset = 1803 ((long) 1804 (string_table 1805 + (internal_ptr + 1)->u.auxent.x_file.x_n.x_offset)); 1806 } 1807 else 1808 { 1809 /* Ordinary short filename, put into memory anyway. The 1810 Microsoft PE tools sometimes store a filename in 1811 multiple AUX entries. */ 1812 if (internal_ptr->u.syment.n_numaux > 1 1813 && coff_data (abfd)->pe) 1814 { 1815 internal_ptr->u.syment._n._n_n._n_offset = 1816 ((long) 1817 copy_name (abfd, 1818 (internal_ptr + 1)->u.auxent.x_file.x_fname, 1819 internal_ptr->u.syment.n_numaux * symesz)); 1820 } 1821 else 1822 { 1823 internal_ptr->u.syment._n._n_n._n_offset = 1824 ((long) 1825 copy_name (abfd, 1826 (internal_ptr + 1)->u.auxent.x_file.x_fname, 1827 (size_t) bfd_coff_filnmlen (abfd))); 1828 } 1829 } 1830 } 1831 else 1832 { 1833 if (internal_ptr->u.syment._n._n_n._n_zeroes != 0) 1834 { 1835 /* This is a "short" name. Make it long. */ 1836 size_t i; 1837 char *newstring; 1838 1839 /* find the length of this string without walking into memory 1840 that isn't ours. */ 1841 for (i = 0; i < 8; ++i) 1842 if (internal_ptr->u.syment._n._n_name[i] == '\0') 1843 break; 1844 1845 newstring = (PTR) bfd_zalloc (abfd, (bfd_size_type) (i + 1)); 1846 if (newstring == NULL) 1847 return (NULL); 1848 strncpy (newstring, internal_ptr->u.syment._n._n_name, i); 1849 internal_ptr->u.syment._n._n_n._n_offset = (long int) newstring; 1850 internal_ptr->u.syment._n._n_n._n_zeroes = 0; 1851 } 1852 else if (internal_ptr->u.syment._n._n_n._n_offset == 0) 1853 internal_ptr->u.syment._n._n_n._n_offset = (long int) ""; 1854 else if (!bfd_coff_symname_in_debug (abfd, &internal_ptr->u.syment)) 1855 { 1856 /* Long name already. Point symbol at the string in the 1857 table. */ 1858 if (string_table == NULL) 1859 { 1860 string_table = _bfd_coff_read_string_table (abfd); 1861 if (string_table == NULL) 1862 return NULL; 1863 } 1864 internal_ptr->u.syment._n._n_n._n_offset = 1865 ((long int) 1866 (string_table 1867 + internal_ptr->u.syment._n._n_n._n_offset)); 1868 } 1869 else 1870 { 1871 /* Long name in debug section. Very similar. */ 1872 if (debug_section == NULL) 1873 debug_section = build_debug_section (abfd); 1874 internal_ptr->u.syment._n._n_n._n_offset = (long int) 1875 (debug_section + internal_ptr->u.syment._n._n_n._n_offset); 1876 } 1877 } 1878 internal_ptr += internal_ptr->u.syment.n_numaux; 1879 } 1880 1881 obj_raw_syments (abfd) = internal; 1882 BFD_ASSERT (obj_raw_syment_count (abfd) 1883 == (unsigned int) (internal_ptr - internal)); 1884 1885 return (internal); 1886} /* coff_get_normalized_symtab() */ 1887 1888long 1889coff_get_reloc_upper_bound (abfd, asect) 1890 bfd *abfd; 1891 sec_ptr asect; 1892{ 1893 if (bfd_get_format (abfd) != bfd_object) 1894 { 1895 bfd_set_error (bfd_error_invalid_operation); 1896 return -1; 1897 } 1898 return (asect->reloc_count + 1) * sizeof (arelent *); 1899} 1900 1901asymbol * 1902coff_make_empty_symbol (abfd) 1903 bfd *abfd; 1904{ 1905 bfd_size_type amt = sizeof (coff_symbol_type); 1906 coff_symbol_type *new = (coff_symbol_type *) bfd_zalloc (abfd, amt); 1907 if (new == NULL) 1908 return (NULL); 1909 new->symbol.section = 0; 1910 new->native = 0; 1911 new->lineno = (alent *) NULL; 1912 new->done_lineno = false; 1913 new->symbol.the_bfd = abfd; 1914 return &new->symbol; 1915} 1916 1917/* Make a debugging symbol. */ 1918 1919asymbol * 1920coff_bfd_make_debug_symbol (abfd, ptr, sz) 1921 bfd *abfd; 1922 PTR ptr ATTRIBUTE_UNUSED; 1923 unsigned long sz ATTRIBUTE_UNUSED; 1924{ 1925 bfd_size_type amt = sizeof (coff_symbol_type); 1926 coff_symbol_type *new = (coff_symbol_type *) bfd_alloc (abfd, amt); 1927 if (new == NULL) 1928 return (NULL); 1929 /* @@ The 10 is a guess at a plausible maximum number of aux entries 1930 (but shouldn't be a constant). */ 1931 amt = sizeof (combined_entry_type) * 10; 1932 new->native = (combined_entry_type *) bfd_zalloc (abfd, amt); 1933 if (!new->native) 1934 return (NULL); 1935 new->symbol.section = bfd_abs_section_ptr; 1936 new->symbol.flags = BSF_DEBUGGING; 1937 new->lineno = (alent *) NULL; 1938 new->done_lineno = false; 1939 new->symbol.the_bfd = abfd; 1940 return &new->symbol; 1941} 1942 1943void 1944coff_get_symbol_info (abfd, symbol, ret) 1945 bfd *abfd; 1946 asymbol *symbol; 1947 symbol_info *ret; 1948{ 1949 bfd_symbol_info (symbol, ret); 1950 if (coffsymbol (symbol)->native != NULL 1951 && coffsymbol (symbol)->native->fix_value) 1952 { 1953 ret->value = coffsymbol (symbol)->native->u.syment.n_value - 1954 (unsigned long) obj_raw_syments (abfd); 1955 } 1956} 1957 1958/* Return the COFF syment for a symbol. */ 1959 1960boolean 1961bfd_coff_get_syment (abfd, symbol, psyment) 1962 bfd *abfd; 1963 asymbol *symbol; 1964 struct internal_syment *psyment; 1965{ 1966 coff_symbol_type *csym; 1967 1968 csym = coff_symbol_from (abfd, symbol); 1969 if (csym == NULL || csym->native == NULL) 1970 { 1971 bfd_set_error (bfd_error_invalid_operation); 1972 return false; 1973 } 1974 1975 *psyment = csym->native->u.syment; 1976 1977 if (csym->native->fix_value) 1978 psyment->n_value = psyment->n_value - 1979 (unsigned long) obj_raw_syments (abfd); 1980 1981 /* FIXME: We should handle fix_line here. */ 1982 1983 return true; 1984} 1985 1986/* Return the COFF auxent for a symbol. */ 1987 1988boolean 1989bfd_coff_get_auxent (abfd, symbol, indx, pauxent) 1990 bfd *abfd; 1991 asymbol *symbol; 1992 int indx; 1993 union internal_auxent *pauxent; 1994{ 1995 coff_symbol_type *csym; 1996 combined_entry_type *ent; 1997 1998 csym = coff_symbol_from (abfd, symbol); 1999 2000 if (csym == NULL 2001 || csym->native == NULL 2002 || indx >= csym->native->u.syment.n_numaux) 2003 { 2004 bfd_set_error (bfd_error_invalid_operation); 2005 return false; 2006 } 2007 2008 ent = csym->native + indx + 1; 2009 2010 *pauxent = ent->u.auxent; 2011 2012 if (ent->fix_tag) 2013 pauxent->x_sym.x_tagndx.l = 2014 ((combined_entry_type *) pauxent->x_sym.x_tagndx.p 2015 - obj_raw_syments (abfd)); 2016 2017 if (ent->fix_end) 2018 pauxent->x_sym.x_fcnary.x_fcn.x_endndx.l = 2019 ((combined_entry_type *) pauxent->x_sym.x_fcnary.x_fcn.x_endndx.p 2020 - obj_raw_syments (abfd)); 2021 2022 if (ent->fix_scnlen) 2023 pauxent->x_csect.x_scnlen.l = 2024 ((combined_entry_type *) pauxent->x_csect.x_scnlen.p 2025 - obj_raw_syments (abfd)); 2026 2027 return true; 2028} 2029 2030/* Print out information about COFF symbol. */ 2031 2032void 2033coff_print_symbol (abfd, filep, symbol, how) 2034 bfd *abfd; 2035 PTR filep; 2036 asymbol *symbol; 2037 bfd_print_symbol_type how; 2038{ 2039 FILE *file = (FILE *) filep; 2040 2041 switch (how) 2042 { 2043 case bfd_print_symbol_name: 2044 fprintf (file, "%s", symbol->name); 2045 break; 2046 2047 case bfd_print_symbol_more: 2048 fprintf (file, "coff %s %s", 2049 coffsymbol (symbol)->native ? "n" : "g", 2050 coffsymbol (symbol)->lineno ? "l" : " "); 2051 break; 2052 2053 case bfd_print_symbol_all: 2054 if (coffsymbol (symbol)->native) 2055 { 2056 bfd_vma val; 2057 unsigned int aux; 2058 combined_entry_type *combined = coffsymbol (symbol)->native; 2059 combined_entry_type *root = obj_raw_syments (abfd); 2060 struct lineno_cache_entry *l = coffsymbol (symbol)->lineno; 2061 2062 fprintf (file, "[%3ld]", (long) (combined - root)); 2063 2064 if (! combined->fix_value) 2065 val = (bfd_vma) combined->u.syment.n_value; 2066 else 2067 val = combined->u.syment.n_value - (unsigned long) root; 2068 2069#ifndef XCOFF64 2070 fprintf (file, 2071 "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x%08lx %s", 2072 combined->u.syment.n_scnum, 2073 combined->u.syment.n_flags, 2074 combined->u.syment.n_type, 2075 combined->u.syment.n_sclass, 2076 combined->u.syment.n_numaux, 2077 (unsigned long) val, 2078 symbol->name); 2079#else 2080 /* Print out the wide, 64 bit, symbol value */ 2081 fprintf (file, 2082 "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x%016llx %s", 2083 combined->u.syment.n_scnum, 2084 combined->u.syment.n_flags, 2085 combined->u.syment.n_type, 2086 combined->u.syment.n_sclass, 2087 combined->u.syment.n_numaux, 2088 val, 2089 symbol->name); 2090#endif 2091 2092 for (aux = 0; aux < combined->u.syment.n_numaux; aux++) 2093 { 2094 combined_entry_type *auxp = combined + aux + 1; 2095 long tagndx; 2096 2097 if (auxp->fix_tag) 2098 tagndx = auxp->u.auxent.x_sym.x_tagndx.p - root; 2099 else 2100 tagndx = auxp->u.auxent.x_sym.x_tagndx.l; 2101 2102 fprintf (file, "\n"); 2103 2104 if (bfd_coff_print_aux (abfd, file, root, combined, auxp, aux)) 2105 continue; 2106 2107 switch (combined->u.syment.n_sclass) 2108 { 2109 case C_FILE: 2110 fprintf (file, "File "); 2111 break; 2112 2113 case C_STAT: 2114 if (combined->u.syment.n_type == T_NULL) 2115 /* probably a section symbol? */ 2116 { 2117 fprintf (file, "AUX scnlen 0x%lx nreloc %d nlnno %d", 2118 (long) auxp->u.auxent.x_scn.x_scnlen, 2119 auxp->u.auxent.x_scn.x_nreloc, 2120 auxp->u.auxent.x_scn.x_nlinno); 2121 if (auxp->u.auxent.x_scn.x_checksum != 0 2122 || auxp->u.auxent.x_scn.x_associated != 0 2123 || auxp->u.auxent.x_scn.x_comdat != 0) 2124 fprintf (file, " checksum 0x%lx assoc %d comdat %d", 2125 auxp->u.auxent.x_scn.x_checksum, 2126 auxp->u.auxent.x_scn.x_associated, 2127 auxp->u.auxent.x_scn.x_comdat); 2128 break; 2129 } 2130 /* else fall through */ 2131 case C_EXT: 2132 if (ISFCN (combined->u.syment.n_type)) 2133 { 2134 long next, llnos; 2135 2136 if (auxp->fix_end) 2137 next = (auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p 2138 - root); 2139 else 2140 next = auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l; 2141 llnos = auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_lnnoptr; 2142 fprintf (file, 2143 "AUX tagndx %ld ttlsiz 0x%lx lnnos %ld next %ld", 2144 tagndx, auxp->u.auxent.x_sym.x_misc.x_fsize, 2145 llnos, next); 2146 break; 2147 } 2148 /* else fall through */ 2149 default: 2150 fprintf (file, "AUX lnno %d size 0x%x tagndx %ld", 2151 auxp->u.auxent.x_sym.x_misc.x_lnsz.x_lnno, 2152 auxp->u.auxent.x_sym.x_misc.x_lnsz.x_size, 2153 tagndx); 2154 if (auxp->fix_end) 2155 fprintf (file, " endndx %ld", 2156 ((long) 2157 (auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p 2158 - root))); 2159 break; 2160 } 2161 } 2162 2163 if (l) 2164 { 2165 fprintf (file, "\n%s :", l->u.sym->name); 2166 l++; 2167 while (l->line_number) 2168 { 2169 fprintf (file, "\n%4d : 0x%lx", 2170 l->line_number, 2171 ((unsigned long) 2172 (l->u.offset + symbol->section->vma))); 2173 l++; 2174 } 2175 } 2176 } 2177 else 2178 { 2179 bfd_print_symbol_vandf (abfd, (PTR) file, symbol); 2180 fprintf (file, " %-5s %s %s %s", 2181 symbol->section->name, 2182 coffsymbol (symbol)->native ? "n" : "g", 2183 coffsymbol (symbol)->lineno ? "l" : " ", 2184 symbol->name); 2185 } 2186 } 2187} 2188 2189/* Return whether a symbol name implies a local symbol. In COFF, 2190 local symbols generally start with ``.L''. Most targets use this 2191 function for the is_local_label_name entry point, but some may 2192 override it. */ 2193 2194boolean 2195_bfd_coff_is_local_label_name (abfd, name) 2196 bfd *abfd ATTRIBUTE_UNUSED; 2197 const char *name; 2198{
| 1/* Support for the generic parts of COFF, for BFD. 2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 3 2000, 2001, 2002 4 Free Software Foundation, Inc. 5 Written by Cygnus Support. 6 7This file is part of BFD, the Binary File Descriptor library. 8 9This program is free software; you can redistribute it and/or modify 10it under the terms of the GNU General Public License as published by 11the Free Software Foundation; either version 2 of the License, or 12(at your option) any later version. 13 14This program is distributed in the hope that it will be useful, 15but WITHOUT ANY WARRANTY; without even the implied warranty of 16MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17GNU General Public License for more details. 18 19You should have received a copy of the GNU General Public License 20along with this program; if not, write to the Free Software 21Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 22 23/* Most of this hacked by Steve Chamberlain, sac@cygnus.com. 24 Split out of coffcode.h by Ian Taylor, ian@cygnus.com. */ 25 26/* This file contains COFF code that is not dependent on any 27 particular COFF target. There is only one version of this file in 28 libbfd.a, so no target specific code may be put in here. Or, to 29 put it another way, 30 31 ********** DO NOT PUT TARGET SPECIFIC CODE IN THIS FILE ********** 32 33 If you need to add some target specific behaviour, add a new hook 34 function to bfd_coff_backend_data. 35 36 Some of these functions are also called by the ECOFF routines. 37 Those functions may not use any COFF specific information, such as 38 coff_data (abfd). */ 39 40#include "bfd.h" 41#include "sysdep.h" 42#include "libbfd.h" 43#include "coff/internal.h" 44#include "libcoff.h" 45 46static void coff_fix_symbol_name 47 PARAMS ((bfd *, asymbol *, combined_entry_type *, bfd_size_type *, 48 asection **, bfd_size_type *)); 49static boolean coff_write_symbol 50 PARAMS ((bfd *, asymbol *, combined_entry_type *, bfd_vma *, 51 bfd_size_type *, asection **, bfd_size_type *)); 52static boolean coff_write_alien_symbol 53 PARAMS ((bfd *, asymbol *, bfd_vma *, bfd_size_type *, 54 asection **, bfd_size_type *)); 55static boolean coff_write_native_symbol 56 PARAMS ((bfd *, coff_symbol_type *, bfd_vma *, bfd_size_type *, 57 asection **, bfd_size_type *)); 58static void coff_pointerize_aux 59 PARAMS ((bfd *, combined_entry_type *, combined_entry_type *, 60 unsigned int, combined_entry_type *)); 61static boolean make_a_section_from_file 62 PARAMS ((bfd *, struct internal_scnhdr *, unsigned int)); 63static const bfd_target *coff_real_object_p 64 PARAMS ((bfd *, unsigned, struct internal_filehdr *, 65 struct internal_aouthdr *)); 66static void fixup_symbol_value 67 PARAMS ((bfd *, coff_symbol_type *, struct internal_syment *)); 68static char *build_debug_section 69 PARAMS ((bfd *)); 70static char *copy_name 71 PARAMS ((bfd *, char *, size_t)); 72 73#define STRING_SIZE_SIZE (4) 74 75/* Take a section header read from a coff file (in HOST byte order), 76 and make a BFD "section" out of it. This is used by ECOFF. */ 77static boolean 78make_a_section_from_file (abfd, hdr, target_index) 79 bfd *abfd; 80 struct internal_scnhdr *hdr; 81 unsigned int target_index; 82{ 83 asection *return_section; 84 char *name; 85 boolean result = true; 86 flagword flags; 87 88 name = NULL; 89 90 /* Handle long section names as in PE. */ 91 if (bfd_coff_long_section_names (abfd) 92 && hdr->s_name[0] == '/') 93 { 94 char buf[SCNNMLEN]; 95 long strindex; 96 char *p; 97 const char *strings; 98 99 memcpy (buf, hdr->s_name + 1, SCNNMLEN - 1); 100 buf[SCNNMLEN - 1] = '\0'; 101 strindex = strtol (buf, &p, 10); 102 if (*p == '\0' && strindex >= 0) 103 { 104 strings = _bfd_coff_read_string_table (abfd); 105 if (strings == NULL) 106 return false; 107 /* FIXME: For extra safety, we should make sure that 108 strindex does not run us past the end, but right now we 109 don't know the length of the string table. */ 110 strings += strindex; 111 name = bfd_alloc (abfd, (bfd_size_type) strlen (strings) + 1); 112 if (name == NULL) 113 return false; 114 strcpy (name, strings); 115 } 116 } 117 118 if (name == NULL) 119 { 120 /* Assorted wastage to null-terminate the name, thanks AT&T! */ 121 name = bfd_alloc (abfd, (bfd_size_type) sizeof (hdr->s_name) + 1); 122 if (name == NULL) 123 return false; 124 strncpy (name, (char *) &hdr->s_name[0], sizeof (hdr->s_name)); 125 name[sizeof (hdr->s_name)] = 0; 126 } 127 128 return_section = bfd_make_section_anyway (abfd, name); 129 if (return_section == NULL) 130 return false; 131 132 return_section->vma = hdr->s_vaddr; 133 return_section->lma = hdr->s_paddr; 134 return_section->_raw_size = hdr->s_size; 135 return_section->filepos = hdr->s_scnptr; 136 return_section->rel_filepos = hdr->s_relptr; 137 return_section->reloc_count = hdr->s_nreloc; 138 139 bfd_coff_set_alignment_hook (abfd, return_section, hdr); 140 141 return_section->line_filepos = hdr->s_lnnoptr; 142 143 return_section->lineno_count = hdr->s_nlnno; 144 return_section->userdata = NULL; 145 return_section->next = (asection *) NULL; 146 return_section->target_index = target_index; 147 148 if (! bfd_coff_styp_to_sec_flags_hook (abfd, hdr, name, return_section, 149 & flags)) 150 result = false; 151 152 return_section->flags = flags; 153 154 /* At least on i386-coff, the line number count for a shared library 155 section must be ignored. */ 156 if ((return_section->flags & SEC_COFF_SHARED_LIBRARY) != 0) 157 return_section->lineno_count = 0; 158 159 if (hdr->s_nreloc != 0) 160 return_section->flags |= SEC_RELOC; 161 /* FIXME: should this check 'hdr->s_size > 0' */ 162 if (hdr->s_scnptr != 0) 163 return_section->flags |= SEC_HAS_CONTENTS; 164 165 return result; 166} 167 168/* Read in a COFF object and make it into a BFD. This is used by 169 ECOFF as well. */ 170 171static const bfd_target * 172coff_real_object_p (abfd, nscns, internal_f, internal_a) 173 bfd *abfd; 174 unsigned nscns; 175 struct internal_filehdr *internal_f; 176 struct internal_aouthdr *internal_a; 177{ 178 flagword oflags = abfd->flags; 179 bfd_vma ostart = bfd_get_start_address (abfd); 180 PTR tdata; 181 PTR tdata_save; 182 bfd_size_type readsize; /* length of file_info */ 183 unsigned int scnhsz; 184 char *external_sections; 185 186 if (!(internal_f->f_flags & F_RELFLG)) 187 abfd->flags |= HAS_RELOC; 188 if ((internal_f->f_flags & F_EXEC)) 189 abfd->flags |= EXEC_P; 190 if (!(internal_f->f_flags & F_LNNO)) 191 abfd->flags |= HAS_LINENO; 192 if (!(internal_f->f_flags & F_LSYMS)) 193 abfd->flags |= HAS_LOCALS; 194 195 /* FIXME: How can we set D_PAGED correctly? */ 196 if ((internal_f->f_flags & F_EXEC) != 0) 197 abfd->flags |= D_PAGED; 198 199 bfd_get_symcount (abfd) = internal_f->f_nsyms; 200 if (internal_f->f_nsyms) 201 abfd->flags |= HAS_SYMS; 202 203 if (internal_a != (struct internal_aouthdr *) NULL) 204 bfd_get_start_address (abfd) = internal_a->entry; 205 else 206 bfd_get_start_address (abfd) = 0; 207 208 /* Set up the tdata area. ECOFF uses its own routine, and overrides 209 abfd->flags. */ 210 tdata_save = abfd->tdata.any; 211 tdata = bfd_coff_mkobject_hook (abfd, (PTR) internal_f, (PTR) internal_a); 212 if (tdata == NULL) 213 goto fail2; 214 215 scnhsz = bfd_coff_scnhsz (abfd); 216 readsize = (bfd_size_type) nscns * scnhsz; 217 external_sections = (char *) bfd_alloc (abfd, readsize); 218 if (!external_sections) 219 goto fail; 220 221 if (bfd_bread ((PTR) external_sections, readsize, abfd) != readsize) 222 goto fail; 223 224 /* Set the arch/mach *before* swapping in sections; section header swapping 225 may depend on arch/mach info. */ 226 if (! bfd_coff_set_arch_mach_hook (abfd, (PTR) internal_f)) 227 goto fail; 228 229 /* Now copy data as required; construct all asections etc */ 230 if (nscns != 0) 231 { 232 unsigned int i; 233 for (i = 0; i < nscns; i++) 234 { 235 struct internal_scnhdr tmp; 236 bfd_coff_swap_scnhdr_in (abfd, 237 (PTR) (external_sections + i * scnhsz), 238 (PTR) & tmp); 239 if (! make_a_section_from_file (abfd, &tmp, i + 1)) 240 goto fail; 241 } 242 } 243 244 /* make_abs_section (abfd); */ 245 246 return abfd->xvec; 247 248 fail: 249 bfd_release (abfd, tdata); 250 fail2: 251 abfd->tdata.any = tdata_save; 252 abfd->flags = oflags; 253 bfd_get_start_address (abfd) = ostart; 254 return (const bfd_target *) NULL; 255} 256 257/* Turn a COFF file into a BFD, but fail with bfd_error_wrong_format if it is 258 not a COFF file. This is also used by ECOFF. */ 259 260const bfd_target * 261coff_object_p (abfd) 262 bfd *abfd; 263{ 264 bfd_size_type filhsz; 265 bfd_size_type aoutsz; 266 unsigned int nscns; 267 PTR filehdr; 268 struct internal_filehdr internal_f; 269 struct internal_aouthdr internal_a; 270 271 /* figure out how much to read */ 272 filhsz = bfd_coff_filhsz (abfd); 273 aoutsz = bfd_coff_aoutsz (abfd); 274 275 filehdr = bfd_alloc (abfd, filhsz); 276 if (filehdr == NULL) 277 return NULL; 278 if (bfd_bread (filehdr, filhsz, abfd) != filhsz) 279 { 280 if (bfd_get_error () != bfd_error_system_call) 281 bfd_set_error (bfd_error_wrong_format); 282 bfd_release (abfd, filehdr); 283 return NULL; 284 } 285 bfd_coff_swap_filehdr_in (abfd, filehdr, &internal_f); 286 bfd_release (abfd, filehdr); 287 288 /* The XCOFF format has two sizes for the f_opthdr. SMALL_AOUTSZ 289 (less than aoutsz) used in object files and AOUTSZ (equal to 290 aoutsz) in executables. The bfd_coff_swap_aouthdr_in function 291 expects this header to be aoutsz bytes in length, so we use that 292 value in the call to bfd_alloc below. But we must be careful to 293 only read in f_opthdr bytes in the call to bfd_bread. We should 294 also attempt to catch corrupt or non-COFF binaries with a strange 295 value for f_opthdr. */ 296 if (! bfd_coff_bad_format_hook (abfd, &internal_f) 297 || internal_f.f_opthdr > aoutsz) 298 { 299 bfd_set_error (bfd_error_wrong_format); 300 return NULL; 301 } 302 nscns = internal_f.f_nscns; 303 304 if (internal_f.f_opthdr) 305 { 306 PTR opthdr; 307 308 opthdr = bfd_alloc (abfd, aoutsz); 309 if (opthdr == NULL) 310 return NULL; 311 if (bfd_bread (opthdr, (bfd_size_type) internal_f.f_opthdr, abfd) 312 != internal_f.f_opthdr) 313 { 314 bfd_release (abfd, opthdr); 315 return NULL; 316 } 317 bfd_coff_swap_aouthdr_in (abfd, opthdr, (PTR) &internal_a); 318 bfd_release (abfd, opthdr); 319 } 320 321 return coff_real_object_p (abfd, nscns, &internal_f, 322 (internal_f.f_opthdr != 0 323 ? &internal_a 324 : (struct internal_aouthdr *) NULL)); 325} 326 327/* Get the BFD section from a COFF symbol section number. */ 328 329asection * 330coff_section_from_bfd_index (abfd, index) 331 bfd *abfd; 332 int index; 333{ 334 struct sec *answer = abfd->sections; 335 336 if (index == N_ABS) 337 return bfd_abs_section_ptr; 338 if (index == N_UNDEF) 339 return bfd_und_section_ptr; 340 if (index == N_DEBUG) 341 return bfd_abs_section_ptr; 342 343 while (answer) 344 { 345 if (answer->target_index == index) 346 return answer; 347 answer = answer->next; 348 } 349 350 /* We should not reach this point, but the SCO 3.2v4 /lib/libc_s.a 351 has a bad symbol table in biglitpow.o. */ 352 return bfd_und_section_ptr; 353} 354 355/* Get the upper bound of a COFF symbol table. */ 356 357long 358coff_get_symtab_upper_bound (abfd) 359 bfd *abfd; 360{ 361 if (!bfd_coff_slurp_symbol_table (abfd)) 362 return -1; 363 364 return (bfd_get_symcount (abfd) + 1) * (sizeof (coff_symbol_type *)); 365} 366 367/* Canonicalize a COFF symbol table. */ 368 369long 370coff_get_symtab (abfd, alocation) 371 bfd *abfd; 372 asymbol **alocation; 373{ 374 unsigned int counter; 375 coff_symbol_type *symbase; 376 coff_symbol_type **location = (coff_symbol_type **) alocation; 377 378 if (!bfd_coff_slurp_symbol_table (abfd)) 379 return -1; 380 381 symbase = obj_symbols (abfd); 382 counter = bfd_get_symcount (abfd); 383 while (counter-- > 0) 384 *location++ = symbase++; 385 386 *location = NULL; 387 388 return bfd_get_symcount (abfd); 389} 390 391/* Get the name of a symbol. The caller must pass in a buffer of size 392 >= SYMNMLEN + 1. */ 393 394const char * 395_bfd_coff_internal_syment_name (abfd, sym, buf) 396 bfd *abfd; 397 const struct internal_syment *sym; 398 char *buf; 399{ 400 /* FIXME: It's not clear this will work correctly if sizeof 401 (_n_zeroes) != 4. */ 402 if (sym->_n._n_n._n_zeroes != 0 403 || sym->_n._n_n._n_offset == 0) 404 { 405 memcpy (buf, sym->_n._n_name, SYMNMLEN); 406 buf[SYMNMLEN] = '\0'; 407 return buf; 408 } 409 else 410 { 411 const char *strings; 412 413 BFD_ASSERT (sym->_n._n_n._n_offset >= STRING_SIZE_SIZE); 414 strings = obj_coff_strings (abfd); 415 if (strings == NULL) 416 { 417 strings = _bfd_coff_read_string_table (abfd); 418 if (strings == NULL) 419 return NULL; 420 } 421 return strings + sym->_n._n_n._n_offset; 422 } 423} 424 425/* Read in and swap the relocs. This returns a buffer holding the 426 relocs for section SEC in file ABFD. If CACHE is true and 427 INTERNAL_RELOCS is NULL, the relocs read in will be saved in case 428 the function is called again. If EXTERNAL_RELOCS is not NULL, it 429 is a buffer large enough to hold the unswapped relocs. If 430 INTERNAL_RELOCS is not NULL, it is a buffer large enough to hold 431 the swapped relocs. If REQUIRE_INTERNAL is true, then the return 432 value must be INTERNAL_RELOCS. The function returns NULL on error. */ 433 434struct internal_reloc * 435_bfd_coff_read_internal_relocs (abfd, sec, cache, external_relocs, 436 require_internal, internal_relocs) 437 bfd *abfd; 438 asection *sec; 439 boolean cache; 440 bfd_byte *external_relocs; 441 boolean require_internal; 442 struct internal_reloc *internal_relocs; 443{ 444 bfd_size_type relsz; 445 bfd_byte *free_external = NULL; 446 struct internal_reloc *free_internal = NULL; 447 bfd_byte *erel; 448 bfd_byte *erel_end; 449 struct internal_reloc *irel; 450 bfd_size_type amt; 451 452 if (coff_section_data (abfd, sec) != NULL 453 && coff_section_data (abfd, sec)->relocs != NULL) 454 { 455 if (! require_internal) 456 return coff_section_data (abfd, sec)->relocs; 457 memcpy (internal_relocs, coff_section_data (abfd, sec)->relocs, 458 sec->reloc_count * sizeof (struct internal_reloc)); 459 return internal_relocs; 460 } 461 462 relsz = bfd_coff_relsz (abfd); 463 464 amt = sec->reloc_count * relsz; 465 if (external_relocs == NULL) 466 { 467 free_external = (bfd_byte *) bfd_malloc (amt); 468 if (free_external == NULL && sec->reloc_count > 0) 469 goto error_return; 470 external_relocs = free_external; 471 } 472 473 if (bfd_seek (abfd, sec->rel_filepos, SEEK_SET) != 0 474 || bfd_bread (external_relocs, amt, abfd) != amt) 475 goto error_return; 476 477 if (internal_relocs == NULL) 478 { 479 amt = sec->reloc_count; 480 amt *= sizeof (struct internal_reloc); 481 free_internal = (struct internal_reloc *) bfd_malloc (amt); 482 if (free_internal == NULL && sec->reloc_count > 0) 483 goto error_return; 484 internal_relocs = free_internal; 485 } 486 487 /* Swap in the relocs. */ 488 erel = external_relocs; 489 erel_end = erel + relsz * sec->reloc_count; 490 irel = internal_relocs; 491 for (; erel < erel_end; erel += relsz, irel++) 492 bfd_coff_swap_reloc_in (abfd, (PTR) erel, (PTR) irel); 493 494 if (free_external != NULL) 495 { 496 free (free_external); 497 free_external = NULL; 498 } 499 500 if (cache && free_internal != NULL) 501 { 502 if (coff_section_data (abfd, sec) == NULL) 503 { 504 amt = sizeof (struct coff_section_tdata); 505 sec->used_by_bfd = (PTR) bfd_zalloc (abfd, amt); 506 if (sec->used_by_bfd == NULL) 507 goto error_return; 508 coff_section_data (abfd, sec)->contents = NULL; 509 } 510 coff_section_data (abfd, sec)->relocs = free_internal; 511 } 512 513 return internal_relocs; 514 515 error_return: 516 if (free_external != NULL) 517 free (free_external); 518 if (free_internal != NULL) 519 free (free_internal); 520 return NULL; 521} 522 523/* Set lineno_count for the output sections of a COFF file. */ 524 525int 526coff_count_linenumbers (abfd) 527 bfd *abfd; 528{ 529 unsigned int limit = bfd_get_symcount (abfd); 530 unsigned int i; 531 int total = 0; 532 asymbol **p; 533 asection *s; 534 535 if (limit == 0) 536 { 537 /* This may be from the backend linker, in which case the 538 lineno_count in the sections is correct. */ 539 for (s = abfd->sections; s != NULL; s = s->next) 540 total += s->lineno_count; 541 return total; 542 } 543 544 for (s = abfd->sections; s != NULL; s = s->next) 545 BFD_ASSERT (s->lineno_count == 0); 546 547 for (p = abfd->outsymbols, i = 0; i < limit; i++, p++) 548 { 549 asymbol *q_maybe = *p; 550 551 if (bfd_family_coff (bfd_asymbol_bfd (q_maybe))) 552 { 553 coff_symbol_type *q = coffsymbol (q_maybe); 554 555 /* The AIX 4.1 compiler can sometimes generate line numbers 556 attached to debugging symbols. We try to simply ignore 557 those here. */ 558 if (q->lineno != NULL 559 && q->symbol.section->owner != NULL) 560 { 561 /* This symbol has line numbers. Increment the owning 562 section's linenumber count. */ 563 alent *l = q->lineno; 564 565 do 566 { 567 asection * sec = q->symbol.section->output_section; 568 569 /* Do not try to update fields in read-only sections. */ 570 if (! bfd_is_const_section (sec)) 571 sec->lineno_count ++; 572 573 ++total; 574 ++l; 575 } 576 while (l->line_number != 0); 577 } 578 } 579 } 580 581 return total; 582} 583 584/* Takes a bfd and a symbol, returns a pointer to the coff specific 585 area of the symbol if there is one. */ 586 587coff_symbol_type * 588coff_symbol_from (ignore_abfd, symbol) 589 bfd *ignore_abfd ATTRIBUTE_UNUSED; 590 asymbol *symbol; 591{ 592 if (!bfd_family_coff (bfd_asymbol_bfd (symbol))) 593 return (coff_symbol_type *) NULL; 594 595 if (bfd_asymbol_bfd (symbol)->tdata.coff_obj_data == (coff_data_type *) NULL) 596 return (coff_symbol_type *) NULL; 597 598 return (coff_symbol_type *) symbol; 599} 600 601static void 602fixup_symbol_value (abfd, coff_symbol_ptr, syment) 603 bfd *abfd; 604 coff_symbol_type *coff_symbol_ptr; 605 struct internal_syment *syment; 606{ 607 608 /* Normalize the symbol flags */ 609 if (bfd_is_com_section (coff_symbol_ptr->symbol.section)) 610 { 611 /* a common symbol is undefined with a value */ 612 syment->n_scnum = N_UNDEF; 613 syment->n_value = coff_symbol_ptr->symbol.value; 614 } 615 else if ((coff_symbol_ptr->symbol.flags & BSF_DEBUGGING) != 0 616 && (coff_symbol_ptr->symbol.flags & BSF_DEBUGGING_RELOC) == 0) 617 { 618 syment->n_value = coff_symbol_ptr->symbol.value; 619 } 620 else if (bfd_is_und_section (coff_symbol_ptr->symbol.section)) 621 { 622 syment->n_scnum = N_UNDEF; 623 syment->n_value = 0; 624 } 625 /* FIXME: Do we need to handle the absolute section here? */ 626 else 627 { 628 if (coff_symbol_ptr->symbol.section) 629 { 630 syment->n_scnum = 631 coff_symbol_ptr->symbol.section->output_section->target_index; 632 633 syment->n_value = (coff_symbol_ptr->symbol.value 634 + coff_symbol_ptr->symbol.section->output_offset); 635 if (! obj_pe (abfd)) 636 { 637 syment->n_value += (syment->n_sclass == C_STATLAB) 638 ? coff_symbol_ptr->symbol.section->output_section->lma 639 : coff_symbol_ptr->symbol.section->output_section->vma; 640 } 641 } 642 else 643 { 644 BFD_ASSERT (0); 645 /* This can happen, but I don't know why yet (steve@cygnus.com) */ 646 syment->n_scnum = N_ABS; 647 syment->n_value = coff_symbol_ptr->symbol.value; 648 } 649 } 650} 651 652/* Run through all the symbols in the symbol table and work out what 653 their indexes into the symbol table will be when output. 654 655 Coff requires that each C_FILE symbol points to the next one in the 656 chain, and that the last one points to the first external symbol. We 657 do that here too. */ 658 659boolean 660coff_renumber_symbols (bfd_ptr, first_undef) 661 bfd *bfd_ptr; 662 int *first_undef; 663{ 664 unsigned int symbol_count = bfd_get_symcount (bfd_ptr); 665 asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols; 666 unsigned int native_index = 0; 667 struct internal_syment *last_file = (struct internal_syment *) NULL; 668 unsigned int symbol_index; 669 670 /* COFF demands that undefined symbols come after all other symbols. 671 Since we don't need to impose this extra knowledge on all our 672 client programs, deal with that here. Sort the symbol table; 673 just move the undefined symbols to the end, leaving the rest 674 alone. The O'Reilly book says that defined global symbols come 675 at the end before the undefined symbols, so we do that here as 676 well. */ 677 /* @@ Do we have some condition we could test for, so we don't always 678 have to do this? I don't think relocatability is quite right, but 679 I'm not certain. [raeburn:19920508.1711EST] */ 680 { 681 asymbol **newsyms; 682 unsigned int i; 683 bfd_size_type amt; 684 685 amt = sizeof (asymbol *) * ((bfd_size_type) symbol_count + 1); 686 newsyms = (asymbol **) bfd_alloc (bfd_ptr, amt); 687 if (!newsyms) 688 return false; 689 bfd_ptr->outsymbols = newsyms; 690 for (i = 0; i < symbol_count; i++) 691 if ((symbol_ptr_ptr[i]->flags & BSF_NOT_AT_END) != 0 692 || (!bfd_is_und_section (symbol_ptr_ptr[i]->section) 693 && !bfd_is_com_section (symbol_ptr_ptr[i]->section) 694 && ((symbol_ptr_ptr[i]->flags & BSF_FUNCTION) != 0 695 || ((symbol_ptr_ptr[i]->flags & (BSF_GLOBAL | BSF_WEAK)) 696 == 0)))) 697 *newsyms++ = symbol_ptr_ptr[i]; 698 699 for (i = 0; i < symbol_count; i++) 700 if ((symbol_ptr_ptr[i]->flags & BSF_NOT_AT_END) == 0 701 && !bfd_is_und_section (symbol_ptr_ptr[i]->section) 702 && (bfd_is_com_section (symbol_ptr_ptr[i]->section) 703 || ((symbol_ptr_ptr[i]->flags & BSF_FUNCTION) == 0 704 && ((symbol_ptr_ptr[i]->flags & (BSF_GLOBAL | BSF_WEAK)) 705 != 0)))) 706 *newsyms++ = symbol_ptr_ptr[i]; 707 708 *first_undef = newsyms - bfd_ptr->outsymbols; 709 710 for (i = 0; i < symbol_count; i++) 711 if ((symbol_ptr_ptr[i]->flags & BSF_NOT_AT_END) == 0 712 && bfd_is_und_section (symbol_ptr_ptr[i]->section)) 713 *newsyms++ = symbol_ptr_ptr[i]; 714 *newsyms = (asymbol *) NULL; 715 symbol_ptr_ptr = bfd_ptr->outsymbols; 716 } 717 718 for (symbol_index = 0; symbol_index < symbol_count; symbol_index++) 719 { 720 coff_symbol_type *coff_symbol_ptr = coff_symbol_from (bfd_ptr, symbol_ptr_ptr[symbol_index]); 721 symbol_ptr_ptr[symbol_index]->udata.i = symbol_index; 722 if (coff_symbol_ptr && coff_symbol_ptr->native) 723 { 724 combined_entry_type *s = coff_symbol_ptr->native; 725 int i; 726 727 if (s->u.syment.n_sclass == C_FILE) 728 { 729 if (last_file != (struct internal_syment *) NULL) 730 last_file->n_value = native_index; 731 last_file = &(s->u.syment); 732 } 733 else 734 { 735 736 /* Modify the symbol values according to their section and 737 type */ 738 739 fixup_symbol_value (bfd_ptr, coff_symbol_ptr, &(s->u.syment)); 740 } 741 for (i = 0; i < s->u.syment.n_numaux + 1; i++) 742 s[i].offset = native_index++; 743 } 744 else 745 { 746 native_index++; 747 } 748 } 749 obj_conv_table_size (bfd_ptr) = native_index; 750 751 return true; 752} 753 754/* Run thorough the symbol table again, and fix it so that all 755 pointers to entries are changed to the entries' index in the output 756 symbol table. */ 757 758void 759coff_mangle_symbols (bfd_ptr) 760 bfd *bfd_ptr; 761{ 762 unsigned int symbol_count = bfd_get_symcount (bfd_ptr); 763 asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols; 764 unsigned int symbol_index; 765 766 for (symbol_index = 0; symbol_index < symbol_count; symbol_index++) 767 { 768 coff_symbol_type *coff_symbol_ptr = 769 coff_symbol_from (bfd_ptr, symbol_ptr_ptr[symbol_index]); 770 771 if (coff_symbol_ptr && coff_symbol_ptr->native) 772 { 773 int i; 774 combined_entry_type *s = coff_symbol_ptr->native; 775 776 if (s->fix_value) 777 { 778 /* FIXME: We should use a union here. */ 779 s->u.syment.n_value = 780 (bfd_vma)((combined_entry_type *) 781 ((unsigned long) s->u.syment.n_value))->offset; 782 s->fix_value = 0; 783 } 784 if (s->fix_line) 785 { 786 /* The value is the offset into the line number entries 787 for the symbol's section. On output, the symbol's 788 section should be N_DEBUG. */ 789 s->u.syment.n_value = 790 (coff_symbol_ptr->symbol.section->output_section->line_filepos 791 + s->u.syment.n_value * bfd_coff_linesz (bfd_ptr)); 792 coff_symbol_ptr->symbol.section = 793 coff_section_from_bfd_index (bfd_ptr, N_DEBUG); 794 BFD_ASSERT (coff_symbol_ptr->symbol.flags & BSF_DEBUGGING); 795 } 796 for (i = 0; i < s->u.syment.n_numaux; i++) 797 { 798 combined_entry_type *a = s + i + 1; 799 if (a->fix_tag) 800 { 801 a->u.auxent.x_sym.x_tagndx.l = 802 a->u.auxent.x_sym.x_tagndx.p->offset; 803 a->fix_tag = 0; 804 } 805 if (a->fix_end) 806 { 807 a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l = 808 a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p->offset; 809 a->fix_end = 0; 810 } 811 if (a->fix_scnlen) 812 { 813 a->u.auxent.x_csect.x_scnlen.l = 814 a->u.auxent.x_csect.x_scnlen.p->offset; 815 a->fix_scnlen = 0; 816 } 817 } 818 } 819 } 820} 821 822static void 823coff_fix_symbol_name (abfd, symbol, native, string_size_p, 824 debug_string_section_p, debug_string_size_p) 825 bfd *abfd; 826 asymbol *symbol; 827 combined_entry_type *native; 828 bfd_size_type *string_size_p; 829 asection **debug_string_section_p; 830 bfd_size_type *debug_string_size_p; 831{ 832 unsigned int name_length; 833 union internal_auxent *auxent; 834 char *name = (char *) (symbol->name); 835 836 if (name == (char *) NULL) 837 { 838 /* coff symbols always have names, so we'll make one up */ 839 symbol->name = "strange"; 840 name = (char *) symbol->name; 841 } 842 name_length = strlen (name); 843 844 if (native->u.syment.n_sclass == C_FILE 845 && native->u.syment.n_numaux > 0) 846 { 847 unsigned int filnmlen; 848 849 if (bfd_coff_force_symnames_in_strings (abfd)) 850 { 851 native->u.syment._n._n_n._n_offset = 852 (*string_size_p + STRING_SIZE_SIZE); 853 native->u.syment._n._n_n._n_zeroes = 0; 854 *string_size_p += 6; /* strlen(".file") + 1 */ 855 } 856 else 857 strncpy (native->u.syment._n._n_name, ".file", SYMNMLEN); 858 859 auxent = &(native + 1)->u.auxent; 860 861 filnmlen = bfd_coff_filnmlen (abfd); 862 863 if (bfd_coff_long_filenames (abfd)) 864 { 865 if (name_length <= filnmlen) 866 { 867 strncpy (auxent->x_file.x_fname, name, filnmlen); 868 } 869 else 870 { 871 auxent->x_file.x_n.x_offset = *string_size_p + STRING_SIZE_SIZE; 872 auxent->x_file.x_n.x_zeroes = 0; 873 *string_size_p += name_length + 1; 874 } 875 } 876 else 877 { 878 strncpy (auxent->x_file.x_fname, name, filnmlen); 879 if (name_length > filnmlen) 880 name[filnmlen] = '\0'; 881 } 882 } 883 else 884 { 885 if (name_length <= SYMNMLEN && !bfd_coff_force_symnames_in_strings (abfd)) 886 { 887 /* This name will fit into the symbol neatly */ 888 strncpy (native->u.syment._n._n_name, symbol->name, SYMNMLEN); 889 } 890 else if (!bfd_coff_symname_in_debug (abfd, &native->u.syment)) 891 { 892 native->u.syment._n._n_n._n_offset = (*string_size_p 893 + STRING_SIZE_SIZE); 894 native->u.syment._n._n_n._n_zeroes = 0; 895 *string_size_p += name_length + 1; 896 } 897 else 898 { 899 file_ptr filepos; 900 bfd_byte buf[4]; 901 int prefix_len = bfd_coff_debug_string_prefix_length (abfd); 902 903 /* This name should be written into the .debug section. For 904 some reason each name is preceded by a two byte length 905 and also followed by a null byte. FIXME: We assume that 906 the .debug section has already been created, and that it 907 is large enough. */ 908 if (*debug_string_section_p == (asection *) NULL) 909 *debug_string_section_p = bfd_get_section_by_name (abfd, ".debug"); 910 filepos = bfd_tell (abfd); 911 if (prefix_len == 4) 912 bfd_put_32 (abfd, (bfd_vma) (name_length + 1), buf); 913 else 914 bfd_put_16 (abfd, (bfd_vma) (name_length + 1), buf); 915 916 if (!bfd_set_section_contents (abfd, 917 *debug_string_section_p, 918 (PTR) buf, 919 (file_ptr) *debug_string_size_p, 920 (bfd_size_type) prefix_len) 921 || !bfd_set_section_contents (abfd, 922 *debug_string_section_p, 923 (PTR) symbol->name, 924 (file_ptr) (*debug_string_size_p 925 + prefix_len), 926 (bfd_size_type) name_length + 1)) 927 abort (); 928 if (bfd_seek (abfd, filepos, SEEK_SET) != 0) 929 abort (); 930 native->u.syment._n._n_n._n_offset = 931 *debug_string_size_p + prefix_len; 932 native->u.syment._n._n_n._n_zeroes = 0; 933 *debug_string_size_p += name_length + 1 + prefix_len; 934 } 935 } 936} 937 938/* We need to keep track of the symbol index so that when we write out 939 the relocs we can get the index for a symbol. This method is a 940 hack. FIXME. */ 941 942#define set_index(symbol, idx) ((symbol)->udata.i = (idx)) 943 944/* Write a symbol out to a COFF file. */ 945 946static boolean 947coff_write_symbol (abfd, symbol, native, written, string_size_p, 948 debug_string_section_p, debug_string_size_p) 949 bfd *abfd; 950 asymbol *symbol; 951 combined_entry_type *native; 952 bfd_vma *written; 953 bfd_size_type *string_size_p; 954 asection **debug_string_section_p; 955 bfd_size_type *debug_string_size_p; 956{ 957 unsigned int numaux = native->u.syment.n_numaux; 958 int type = native->u.syment.n_type; 959 int class = native->u.syment.n_sclass; 960 PTR buf; 961 bfd_size_type symesz; 962 963 if (native->u.syment.n_sclass == C_FILE) 964 symbol->flags |= BSF_DEBUGGING; 965 966 if (symbol->flags & BSF_DEBUGGING 967 && bfd_is_abs_section (symbol->section)) 968 { 969 native->u.syment.n_scnum = N_DEBUG; 970 } 971 else if (bfd_is_abs_section (symbol->section)) 972 { 973 native->u.syment.n_scnum = N_ABS; 974 } 975 else if (bfd_is_und_section (symbol->section)) 976 { 977 native->u.syment.n_scnum = N_UNDEF; 978 } 979 else 980 { 981 native->u.syment.n_scnum = 982 symbol->section->output_section->target_index; 983 } 984 985 coff_fix_symbol_name (abfd, symbol, native, string_size_p, 986 debug_string_section_p, debug_string_size_p); 987 988 symesz = bfd_coff_symesz (abfd); 989 buf = bfd_alloc (abfd, symesz); 990 if (!buf) 991 return false; 992 bfd_coff_swap_sym_out (abfd, &native->u.syment, buf); 993 if (bfd_bwrite (buf, symesz, abfd) != symesz) 994 return false; 995 bfd_release (abfd, buf); 996 997 if (native->u.syment.n_numaux > 0) 998 { 999 bfd_size_type auxesz; 1000 unsigned int j; 1001 1002 auxesz = bfd_coff_auxesz (abfd); 1003 buf = bfd_alloc (abfd, auxesz); 1004 if (!buf) 1005 return false; 1006 for (j = 0; j < native->u.syment.n_numaux; j++) 1007 { 1008 bfd_coff_swap_aux_out (abfd, 1009 &((native + j + 1)->u.auxent), 1010 type, 1011 class, 1012 (int) j, 1013 native->u.syment.n_numaux, 1014 buf); 1015 if (bfd_bwrite (buf, auxesz, abfd) != auxesz) 1016 return false; 1017 } 1018 bfd_release (abfd, buf); 1019 } 1020 1021 /* Store the index for use when we write out the relocs. */ 1022 set_index (symbol, *written); 1023 1024 *written += numaux + 1; 1025 return true; 1026} 1027 1028/* Write out a symbol to a COFF file that does not come from a COFF 1029 file originally. This symbol may have been created by the linker, 1030 or we may be linking a non COFF file to a COFF file. */ 1031 1032static boolean 1033coff_write_alien_symbol (abfd, symbol, written, string_size_p, 1034 debug_string_section_p, debug_string_size_p) 1035 bfd *abfd; 1036 asymbol *symbol; 1037 bfd_vma *written; 1038 bfd_size_type *string_size_p; 1039 asection **debug_string_section_p; 1040 bfd_size_type *debug_string_size_p; 1041{ 1042 combined_entry_type *native; 1043 combined_entry_type dummy; 1044 1045 native = &dummy; 1046 native->u.syment.n_type = T_NULL; 1047 native->u.syment.n_flags = 0; 1048 if (bfd_is_und_section (symbol->section)) 1049 { 1050 native->u.syment.n_scnum = N_UNDEF; 1051 native->u.syment.n_value = symbol->value; 1052 } 1053 else if (bfd_is_com_section (symbol->section)) 1054 { 1055 native->u.syment.n_scnum = N_UNDEF; 1056 native->u.syment.n_value = symbol->value; 1057 } 1058 else if (symbol->flags & BSF_DEBUGGING) 1059 { 1060 /* There isn't much point to writing out a debugging symbol 1061 unless we are prepared to convert it into COFF debugging 1062 format. So, we just ignore them. We must clobber the symbol 1063 name to keep it from being put in the string table. */ 1064 symbol->name = ""; 1065 return true; 1066 } 1067 else 1068 { 1069 native->u.syment.n_scnum = 1070 symbol->section->output_section->target_index; 1071 native->u.syment.n_value = (symbol->value 1072 + symbol->section->output_offset); 1073 if (! obj_pe (abfd)) 1074 native->u.syment.n_value += symbol->section->output_section->vma; 1075 1076 /* Copy the any flags from the file header into the symbol. 1077 FIXME: Why? */ 1078 { 1079 coff_symbol_type *c = coff_symbol_from (abfd, symbol); 1080 if (c != (coff_symbol_type *) NULL) 1081 native->u.syment.n_flags = bfd_asymbol_bfd (&c->symbol)->flags; 1082 } 1083 } 1084 1085 native->u.syment.n_type = 0; 1086 if (symbol->flags & BSF_LOCAL) 1087 native->u.syment.n_sclass = C_STAT; 1088 else if (symbol->flags & BSF_WEAK) 1089 native->u.syment.n_sclass = obj_pe (abfd) ? C_NT_WEAK : C_WEAKEXT; 1090 else 1091 native->u.syment.n_sclass = C_EXT; 1092 native->u.syment.n_numaux = 0; 1093 1094 return coff_write_symbol (abfd, symbol, native, written, string_size_p, 1095 debug_string_section_p, debug_string_size_p); 1096} 1097 1098/* Write a native symbol to a COFF file. */ 1099 1100static boolean 1101coff_write_native_symbol (abfd, symbol, written, string_size_p, 1102 debug_string_section_p, debug_string_size_p) 1103 bfd *abfd; 1104 coff_symbol_type *symbol; 1105 bfd_vma *written; 1106 bfd_size_type *string_size_p; 1107 asection **debug_string_section_p; 1108 bfd_size_type *debug_string_size_p; 1109{ 1110 combined_entry_type *native = symbol->native; 1111 alent *lineno = symbol->lineno; 1112 1113 /* If this symbol has an associated line number, we must store the 1114 symbol index in the line number field. We also tag the auxent to 1115 point to the right place in the lineno table. */ 1116 if (lineno && !symbol->done_lineno && symbol->symbol.section->owner != NULL) 1117 { 1118 unsigned int count = 0; 1119 lineno[count].u.offset = *written; 1120 if (native->u.syment.n_numaux) 1121 { 1122 union internal_auxent *a = &((native + 1)->u.auxent); 1123 1124 a->x_sym.x_fcnary.x_fcn.x_lnnoptr = 1125 symbol->symbol.section->output_section->moving_line_filepos; 1126 } 1127 1128 /* Count and relocate all other linenumbers. */ 1129 count++; 1130 while (lineno[count].line_number != 0) 1131 { 1132#if 0 1133 /* 13 april 92. sac 1134 I've been told this, but still need proof: 1135 > The second bug is also in `bfd/coffcode.h'. This bug 1136 > causes the linker to screw up the pc-relocations for 1137 > all the line numbers in COFF code. This bug isn't only 1138 > specific to A29K implementations, but affects all 1139 > systems using COFF format binaries. Note that in COFF 1140 > object files, the line number core offsets output by 1141 > the assembler are relative to the start of each 1142 > procedure, not to the start of the .text section. This 1143 > patch relocates the line numbers relative to the 1144 > `native->u.syment.n_value' instead of the section 1145 > virtual address. 1146 > modular!olson@cs.arizona.edu (Jon Olson) 1147 */ 1148 lineno[count].u.offset += native->u.syment.n_value; 1149#else 1150 lineno[count].u.offset += 1151 (symbol->symbol.section->output_section->vma 1152 + symbol->symbol.section->output_offset); 1153#endif 1154 count++; 1155 } 1156 symbol->done_lineno = true; 1157 1158 if (! bfd_is_const_section (symbol->symbol.section->output_section)) 1159 symbol->symbol.section->output_section->moving_line_filepos += 1160 count * bfd_coff_linesz (abfd); 1161 } 1162 1163 return coff_write_symbol (abfd, &(symbol->symbol), native, written, 1164 string_size_p, debug_string_section_p, 1165 debug_string_size_p); 1166} 1167 1168/* Write out the COFF symbols. */ 1169 1170boolean 1171coff_write_symbols (abfd) 1172 bfd *abfd; 1173{ 1174 bfd_size_type string_size; 1175 asection *debug_string_section; 1176 bfd_size_type debug_string_size; 1177 unsigned int i; 1178 unsigned int limit = bfd_get_symcount (abfd); 1179 bfd_signed_vma written = 0; 1180 asymbol **p; 1181 1182 string_size = 0; 1183 debug_string_section = NULL; 1184 debug_string_size = 0; 1185 1186 /* If this target supports long section names, they must be put into 1187 the string table. This is supported by PE. This code must 1188 handle section names just as they are handled in 1189 coff_write_object_contents. */ 1190 if (bfd_coff_long_section_names (abfd)) 1191 { 1192 asection *o; 1193 1194 for (o = abfd->sections; o != NULL; o = o->next) 1195 { 1196 size_t len; 1197 1198 len = strlen (o->name); 1199 if (len > SCNNMLEN) 1200 string_size += len + 1; 1201 } 1202 } 1203 1204 /* Seek to the right place */ 1205 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0) 1206 return false; 1207 1208 /* Output all the symbols we have */ 1209 1210 written = 0; 1211 for (p = abfd->outsymbols, i = 0; i < limit; i++, p++) 1212 { 1213 asymbol *symbol = *p; 1214 coff_symbol_type *c_symbol = coff_symbol_from (abfd, symbol); 1215 1216 if (c_symbol == (coff_symbol_type *) NULL 1217 || c_symbol->native == (combined_entry_type *) NULL) 1218 { 1219 if (!coff_write_alien_symbol (abfd, symbol, &written, &string_size, 1220 &debug_string_section, 1221 &debug_string_size)) 1222 return false; 1223 } 1224 else 1225 { 1226 if (!coff_write_native_symbol (abfd, c_symbol, &written, 1227 &string_size, &debug_string_section, 1228 &debug_string_size)) 1229 return false; 1230 } 1231 } 1232 1233 obj_raw_syment_count (abfd) = written; 1234 1235 /* Now write out strings */ 1236 1237 if (string_size != 0) 1238 { 1239 unsigned int size = string_size + STRING_SIZE_SIZE; 1240 bfd_byte buffer[STRING_SIZE_SIZE]; 1241 1242#if STRING_SIZE_SIZE == 4 1243 H_PUT_32 (abfd, size, buffer); 1244#else 1245 #error Change H_PUT_32 1246#endif 1247 if (bfd_bwrite ((PTR) buffer, (bfd_size_type) sizeof (buffer), abfd) 1248 != sizeof (buffer)) 1249 return false; 1250 1251 /* Handle long section names. This code must handle section 1252 names just as they are handled in coff_write_object_contents. */ 1253 if (bfd_coff_long_section_names (abfd)) 1254 { 1255 asection *o; 1256 1257 for (o = abfd->sections; o != NULL; o = o->next) 1258 { 1259 size_t len; 1260 1261 len = strlen (o->name); 1262 if (len > SCNNMLEN) 1263 { 1264 if (bfd_bwrite (o->name, (bfd_size_type) (len + 1), abfd) 1265 != len + 1) 1266 return false; 1267 } 1268 } 1269 } 1270 1271 for (p = abfd->outsymbols, i = 0; 1272 i < limit; 1273 i++, p++) 1274 { 1275 asymbol *q = *p; 1276 size_t name_length = strlen (q->name); 1277 coff_symbol_type *c_symbol = coff_symbol_from (abfd, q); 1278 size_t maxlen; 1279 1280 /* Figure out whether the symbol name should go in the string 1281 table. Symbol names that are short enough are stored 1282 directly in the syment structure. File names permit a 1283 different, longer, length in the syment structure. On 1284 XCOFF, some symbol names are stored in the .debug section 1285 rather than in the string table. */ 1286 1287 if (c_symbol == NULL 1288 || c_symbol->native == NULL) 1289 { 1290 /* This is not a COFF symbol, so it certainly is not a 1291 file name, nor does it go in the .debug section. */ 1292 maxlen = bfd_coff_force_symnames_in_strings (abfd) ? 0 : SYMNMLEN; 1293 } 1294 else if (bfd_coff_symname_in_debug (abfd, 1295 &c_symbol->native->u.syment)) 1296 { 1297 /* This symbol name is in the XCOFF .debug section. 1298 Don't write it into the string table. */ 1299 maxlen = name_length; 1300 } 1301 else if (c_symbol->native->u.syment.n_sclass == C_FILE 1302 && c_symbol->native->u.syment.n_numaux > 0) 1303 { 1304 if (bfd_coff_force_symnames_in_strings (abfd)) 1305 { 1306 if (bfd_bwrite (".file", (bfd_size_type) 6, abfd) != 6) 1307 return false; 1308 } 1309 maxlen = bfd_coff_filnmlen (abfd); 1310 } 1311 else 1312 maxlen = bfd_coff_force_symnames_in_strings (abfd) ? 0 : SYMNMLEN; 1313 1314 if (name_length > maxlen) 1315 { 1316 if (bfd_bwrite ((PTR) (q->name), (bfd_size_type) name_length + 1, 1317 abfd) != name_length + 1) 1318 return false; 1319 } 1320 } 1321 } 1322 else 1323 { 1324 /* We would normally not write anything here, but we'll write 1325 out 4 so that any stupid coff reader which tries to read the 1326 string table even when there isn't one won't croak. */ 1327 unsigned int size = STRING_SIZE_SIZE; 1328 bfd_byte buffer[STRING_SIZE_SIZE]; 1329 1330#if STRING_SIZE_SIZE == 4 1331 H_PUT_32 (abfd, size, buffer); 1332#else 1333 #error Change H_PUT_32 1334#endif 1335 if (bfd_bwrite ((PTR) buffer, (bfd_size_type) STRING_SIZE_SIZE, abfd) 1336 != STRING_SIZE_SIZE) 1337 return false; 1338 } 1339 1340 /* Make sure the .debug section was created to be the correct size. 1341 We should create it ourselves on the fly, but we don't because 1342 BFD won't let us write to any section until we know how large all 1343 the sections are. We could still do it by making another pass 1344 over the symbols. FIXME. */ 1345 BFD_ASSERT (debug_string_size == 0 1346 || (debug_string_section != (asection *) NULL 1347 && (BFD_ALIGN (debug_string_size, 1348 1 << debug_string_section->alignment_power) 1349 == bfd_section_size (abfd, debug_string_section)))); 1350 1351 return true; 1352} 1353 1354boolean 1355coff_write_linenumbers (abfd) 1356 bfd *abfd; 1357{ 1358 asection *s; 1359 bfd_size_type linesz; 1360 PTR buff; 1361 1362 linesz = bfd_coff_linesz (abfd); 1363 buff = bfd_alloc (abfd, linesz); 1364 if (!buff) 1365 return false; 1366 for (s = abfd->sections; s != (asection *) NULL; s = s->next) 1367 { 1368 if (s->lineno_count) 1369 { 1370 asymbol **q = abfd->outsymbols; 1371 if (bfd_seek (abfd, s->line_filepos, SEEK_SET) != 0) 1372 return false; 1373 /* Find all the linenumbers in this section */ 1374 while (*q) 1375 { 1376 asymbol *p = *q; 1377 if (p->section->output_section == s) 1378 { 1379 alent *l = 1380 BFD_SEND (bfd_asymbol_bfd (p), _get_lineno, 1381 (bfd_asymbol_bfd (p), p)); 1382 if (l) 1383 { 1384 /* Found a linenumber entry, output */ 1385 struct internal_lineno out; 1386 memset ((PTR) & out, 0, sizeof (out)); 1387 out.l_lnno = 0; 1388 out.l_addr.l_symndx = l->u.offset; 1389 bfd_coff_swap_lineno_out (abfd, &out, buff); 1390 if (bfd_bwrite (buff, (bfd_size_type) linesz, abfd) 1391 != linesz) 1392 return false; 1393 l++; 1394 while (l->line_number) 1395 { 1396 out.l_lnno = l->line_number; 1397 out.l_addr.l_symndx = l->u.offset; 1398 bfd_coff_swap_lineno_out (abfd, &out, buff); 1399 if (bfd_bwrite (buff, (bfd_size_type) linesz, abfd) 1400 != linesz) 1401 return false; 1402 l++; 1403 } 1404 } 1405 } 1406 q++; 1407 } 1408 } 1409 } 1410 bfd_release (abfd, buff); 1411 return true; 1412} 1413 1414alent * 1415coff_get_lineno (ignore_abfd, symbol) 1416 bfd *ignore_abfd ATTRIBUTE_UNUSED; 1417 asymbol *symbol; 1418{ 1419 return coffsymbol (symbol)->lineno; 1420} 1421 1422#if 0 1423 1424/* This is only called from coff_add_missing_symbols, which has been 1425 disabled. */ 1426 1427asymbol * 1428coff_section_symbol (abfd, name) 1429 bfd *abfd; 1430 char *name; 1431{ 1432 asection *sec = bfd_make_section_old_way (abfd, name); 1433 asymbol *sym; 1434 combined_entry_type *csym; 1435 1436 sym = sec->symbol; 1437 csym = coff_symbol_from (abfd, sym)->native; 1438 /* Make sure back-end COFF stuff is there. */ 1439 if (csym == 0) 1440 { 1441 struct foo 1442 { 1443 coff_symbol_type sym; 1444 /* @@FIXME This shouldn't use a fixed size!! */ 1445 combined_entry_type e[10]; 1446 }; 1447 struct foo *f; 1448 1449 f = (struct foo *) bfd_zalloc (abfd, (bfd_size_type) sizeof (*f)); 1450 if (!f) 1451 { 1452 bfd_set_error (bfd_error_no_error); 1453 return NULL; 1454 } 1455 coff_symbol_from (abfd, sym)->native = csym = f->e; 1456 } 1457 csym[0].u.syment.n_sclass = C_STAT; 1458 csym[0].u.syment.n_numaux = 1; 1459/* SF_SET_STATICS (sym); @@ ??? */ 1460 csym[1].u.auxent.x_scn.x_scnlen = sec->_raw_size; 1461 csym[1].u.auxent.x_scn.x_nreloc = sec->reloc_count; 1462 csym[1].u.auxent.x_scn.x_nlinno = sec->lineno_count; 1463 1464 if (sec->output_section == NULL) 1465 { 1466 sec->output_section = sec; 1467 sec->output_offset = 0; 1468 } 1469 1470 return sym; 1471} 1472 1473#endif /* 0 */ 1474 1475/* This function transforms the offsets into the symbol table into 1476 pointers to syments. */ 1477 1478static void 1479coff_pointerize_aux (abfd, table_base, symbol, indaux, auxent) 1480 bfd *abfd; 1481 combined_entry_type *table_base; 1482 combined_entry_type *symbol; 1483 unsigned int indaux; 1484 combined_entry_type *auxent; 1485{ 1486 unsigned int type = symbol->u.syment.n_type; 1487 unsigned int class = symbol->u.syment.n_sclass; 1488 1489 if (coff_backend_info (abfd)->_bfd_coff_pointerize_aux_hook) 1490 { 1491 if ((*coff_backend_info (abfd)->_bfd_coff_pointerize_aux_hook) 1492 (abfd, table_base, symbol, indaux, auxent)) 1493 return; 1494 } 1495 1496 /* Don't bother if this is a file or a section */ 1497 if (class == C_STAT && type == T_NULL) 1498 return; 1499 if (class == C_FILE) 1500 return; 1501 1502 /* Otherwise patch up */ 1503#define N_TMASK coff_data (abfd)->local_n_tmask 1504#define N_BTSHFT coff_data (abfd)->local_n_btshft 1505 if ((ISFCN (type) || ISTAG (class) || class == C_BLOCK || class == C_FCN) 1506 && auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l > 0) 1507 { 1508 auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p = 1509 table_base + auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l; 1510 auxent->fix_end = 1; 1511 } 1512 /* A negative tagndx is meaningless, but the SCO 3.2v4 cc can 1513 generate one, so we must be careful to ignore it. */ 1514 if (auxent->u.auxent.x_sym.x_tagndx.l > 0) 1515 { 1516 auxent->u.auxent.x_sym.x_tagndx.p = 1517 table_base + auxent->u.auxent.x_sym.x_tagndx.l; 1518 auxent->fix_tag = 1; 1519 } 1520} 1521 1522/* Allocate space for the ".debug" section, and read it. 1523 We did not read the debug section until now, because 1524 we didn't want to go to the trouble until someone needed it. */ 1525 1526static char * 1527build_debug_section (abfd) 1528 bfd *abfd; 1529{ 1530 char *debug_section; 1531 file_ptr position; 1532 bfd_size_type sec_size; 1533 1534 asection *sect = bfd_get_section_by_name (abfd, ".debug"); 1535 1536 if (!sect) 1537 { 1538 bfd_set_error (bfd_error_no_debug_section); 1539 return NULL; 1540 } 1541 1542 sec_size = bfd_get_section_size_before_reloc (sect); 1543 debug_section = (PTR) bfd_alloc (abfd, sec_size); 1544 if (debug_section == NULL) 1545 return NULL; 1546 1547 /* Seek to the beginning of the `.debug' section and read it. 1548 Save the current position first; it is needed by our caller. 1549 Then read debug section and reset the file pointer. */ 1550 1551 position = bfd_tell (abfd); 1552 if (bfd_seek (abfd, sect->filepos, SEEK_SET) != 0 1553 || bfd_bread (debug_section, sec_size, abfd) != sec_size 1554 || bfd_seek (abfd, position, SEEK_SET) != 0) 1555 return NULL; 1556 return debug_section; 1557} 1558 1559/* Return a pointer to a malloc'd copy of 'name'. 'name' may not be 1560 \0-terminated, but will not exceed 'maxlen' characters. The copy *will* 1561 be \0-terminated. */ 1562static char * 1563copy_name (abfd, name, maxlen) 1564 bfd *abfd; 1565 char *name; 1566 size_t maxlen; 1567{ 1568 size_t len; 1569 char *newname; 1570 1571 for (len = 0; len < maxlen; ++len) 1572 { 1573 if (name[len] == '\0') 1574 { 1575 break; 1576 } 1577 } 1578 1579 if ((newname = (PTR) bfd_alloc (abfd, (bfd_size_type) len + 1)) == NULL) 1580 return (NULL); 1581 strncpy (newname, name, len); 1582 newname[len] = '\0'; 1583 return newname; 1584} 1585 1586/* Read in the external symbols. */ 1587 1588boolean 1589_bfd_coff_get_external_symbols (abfd) 1590 bfd *abfd; 1591{ 1592 bfd_size_type symesz; 1593 bfd_size_type size; 1594 PTR syms; 1595 1596 if (obj_coff_external_syms (abfd) != NULL) 1597 return true; 1598 1599 symesz = bfd_coff_symesz (abfd); 1600 1601 size = obj_raw_syment_count (abfd) * symesz; 1602 1603 syms = (PTR) bfd_malloc (size); 1604 if (syms == NULL && size != 0) 1605 return false; 1606 1607 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0 1608 || bfd_bread (syms, size, abfd) != size) 1609 { 1610 if (syms != NULL) 1611 free (syms); 1612 return false; 1613 } 1614 1615 obj_coff_external_syms (abfd) = syms; 1616 1617 return true; 1618} 1619 1620/* Read in the external strings. The strings are not loaded until 1621 they are needed. This is because we have no simple way of 1622 detecting a missing string table in an archive. */ 1623 1624const char * 1625_bfd_coff_read_string_table (abfd) 1626 bfd *abfd; 1627{ 1628 char extstrsize[STRING_SIZE_SIZE]; 1629 bfd_size_type strsize; 1630 char *strings; 1631 file_ptr pos; 1632 1633 if (obj_coff_strings (abfd) != NULL) 1634 return obj_coff_strings (abfd); 1635 1636 if (obj_sym_filepos (abfd) == 0) 1637 { 1638 bfd_set_error (bfd_error_no_symbols); 1639 return NULL; 1640 } 1641 1642 pos = obj_sym_filepos (abfd); 1643 pos += obj_raw_syment_count (abfd) * bfd_coff_symesz (abfd); 1644 if (bfd_seek (abfd, pos, SEEK_SET) != 0) 1645 return NULL; 1646 1647 if (bfd_bread (extstrsize, (bfd_size_type) sizeof extstrsize, abfd) 1648 != sizeof extstrsize) 1649 { 1650 if (bfd_get_error () != bfd_error_file_truncated) 1651 return NULL; 1652 1653 /* There is no string table. */ 1654 strsize = STRING_SIZE_SIZE; 1655 } 1656 else 1657 { 1658#if STRING_SIZE_SIZE == 4 1659 strsize = H_GET_32 (abfd, extstrsize); 1660#else 1661 #error Change H_GET_32 1662#endif 1663 } 1664 1665 if (strsize < STRING_SIZE_SIZE) 1666 { 1667 (*_bfd_error_handler) 1668 (_("%s: bad string table size %lu"), bfd_archive_filename (abfd), 1669 (unsigned long) strsize); 1670 bfd_set_error (bfd_error_bad_value); 1671 return NULL; 1672 } 1673 1674 strings = (char *) bfd_malloc (strsize); 1675 if (strings == NULL) 1676 return NULL; 1677 1678 if (bfd_bread (strings + STRING_SIZE_SIZE, strsize - STRING_SIZE_SIZE, abfd) 1679 != strsize - STRING_SIZE_SIZE) 1680 { 1681 free (strings); 1682 return NULL; 1683 } 1684 1685 obj_coff_strings (abfd) = strings; 1686 1687 return strings; 1688} 1689 1690/* Free up the external symbols and strings read from a COFF file. */ 1691 1692boolean 1693_bfd_coff_free_symbols (abfd) 1694 bfd *abfd; 1695{ 1696 if (obj_coff_external_syms (abfd) != NULL 1697 && ! obj_coff_keep_syms (abfd)) 1698 { 1699 free (obj_coff_external_syms (abfd)); 1700 obj_coff_external_syms (abfd) = NULL; 1701 } 1702 if (obj_coff_strings (abfd) != NULL 1703 && ! obj_coff_keep_strings (abfd)) 1704 { 1705 free (obj_coff_strings (abfd)); 1706 obj_coff_strings (abfd) = NULL; 1707 } 1708 return true; 1709} 1710 1711/* Read a symbol table into freshly bfd_allocated memory, swap it, and 1712 knit the symbol names into a normalized form. By normalized here I 1713 mean that all symbols have an n_offset pointer that points to a null- 1714 terminated string. */ 1715 1716combined_entry_type * 1717coff_get_normalized_symtab (abfd) 1718 bfd *abfd; 1719{ 1720 combined_entry_type *internal; 1721 combined_entry_type *internal_ptr; 1722 combined_entry_type *symbol_ptr; 1723 combined_entry_type *internal_end; 1724 size_t symesz; 1725 char *raw_src; 1726 char *raw_end; 1727 const char *string_table = NULL; 1728 char *debug_section = NULL; 1729 bfd_size_type size; 1730 1731 if (obj_raw_syments (abfd) != NULL) 1732 return obj_raw_syments (abfd); 1733 1734 size = obj_raw_syment_count (abfd) * sizeof (combined_entry_type); 1735 internal = (combined_entry_type *) bfd_zalloc (abfd, size); 1736 if (internal == NULL && size != 0) 1737 return NULL; 1738 internal_end = internal + obj_raw_syment_count (abfd); 1739 1740 if (! _bfd_coff_get_external_symbols (abfd)) 1741 return NULL; 1742 1743 raw_src = (char *) obj_coff_external_syms (abfd); 1744 1745 /* mark the end of the symbols */ 1746 symesz = bfd_coff_symesz (abfd); 1747 raw_end = (char *) raw_src + obj_raw_syment_count (abfd) * symesz; 1748 1749 /* FIXME SOMEDAY. A string table size of zero is very weird, but 1750 probably possible. If one shows up, it will probably kill us. */ 1751 1752 /* Swap all the raw entries */ 1753 for (internal_ptr = internal; 1754 raw_src < raw_end; 1755 raw_src += symesz, internal_ptr++) 1756 { 1757 1758 unsigned int i; 1759 bfd_coff_swap_sym_in (abfd, (PTR) raw_src, 1760 (PTR) & internal_ptr->u.syment); 1761 symbol_ptr = internal_ptr; 1762 1763 for (i = 0; 1764 i < symbol_ptr->u.syment.n_numaux; 1765 i++) 1766 { 1767 internal_ptr++; 1768 raw_src += symesz; 1769 bfd_coff_swap_aux_in (abfd, (PTR) raw_src, 1770 symbol_ptr->u.syment.n_type, 1771 symbol_ptr->u.syment.n_sclass, 1772 (int) i, symbol_ptr->u.syment.n_numaux, 1773 &(internal_ptr->u.auxent)); 1774 coff_pointerize_aux (abfd, internal, symbol_ptr, i, 1775 internal_ptr); 1776 } 1777 } 1778 1779 /* Free the raw symbols, but not the strings (if we have them). */ 1780 obj_coff_keep_strings (abfd) = true; 1781 if (! _bfd_coff_free_symbols (abfd)) 1782 return NULL; 1783 1784 for (internal_ptr = internal; internal_ptr < internal_end; 1785 internal_ptr++) 1786 { 1787 if (internal_ptr->u.syment.n_sclass == C_FILE 1788 && internal_ptr->u.syment.n_numaux > 0) 1789 { 1790 /* make a file symbol point to the name in the auxent, since 1791 the text ".file" is redundant */ 1792 if ((internal_ptr + 1)->u.auxent.x_file.x_n.x_zeroes == 0) 1793 { 1794 /* the filename is a long one, point into the string table */ 1795 if (string_table == NULL) 1796 { 1797 string_table = _bfd_coff_read_string_table (abfd); 1798 if (string_table == NULL) 1799 return NULL; 1800 } 1801 1802 internal_ptr->u.syment._n._n_n._n_offset = 1803 ((long) 1804 (string_table 1805 + (internal_ptr + 1)->u.auxent.x_file.x_n.x_offset)); 1806 } 1807 else 1808 { 1809 /* Ordinary short filename, put into memory anyway. The 1810 Microsoft PE tools sometimes store a filename in 1811 multiple AUX entries. */ 1812 if (internal_ptr->u.syment.n_numaux > 1 1813 && coff_data (abfd)->pe) 1814 { 1815 internal_ptr->u.syment._n._n_n._n_offset = 1816 ((long) 1817 copy_name (abfd, 1818 (internal_ptr + 1)->u.auxent.x_file.x_fname, 1819 internal_ptr->u.syment.n_numaux * symesz)); 1820 } 1821 else 1822 { 1823 internal_ptr->u.syment._n._n_n._n_offset = 1824 ((long) 1825 copy_name (abfd, 1826 (internal_ptr + 1)->u.auxent.x_file.x_fname, 1827 (size_t) bfd_coff_filnmlen (abfd))); 1828 } 1829 } 1830 } 1831 else 1832 { 1833 if (internal_ptr->u.syment._n._n_n._n_zeroes != 0) 1834 { 1835 /* This is a "short" name. Make it long. */ 1836 size_t i; 1837 char *newstring; 1838 1839 /* find the length of this string without walking into memory 1840 that isn't ours. */ 1841 for (i = 0; i < 8; ++i) 1842 if (internal_ptr->u.syment._n._n_name[i] == '\0') 1843 break; 1844 1845 newstring = (PTR) bfd_zalloc (abfd, (bfd_size_type) (i + 1)); 1846 if (newstring == NULL) 1847 return (NULL); 1848 strncpy (newstring, internal_ptr->u.syment._n._n_name, i); 1849 internal_ptr->u.syment._n._n_n._n_offset = (long int) newstring; 1850 internal_ptr->u.syment._n._n_n._n_zeroes = 0; 1851 } 1852 else if (internal_ptr->u.syment._n._n_n._n_offset == 0) 1853 internal_ptr->u.syment._n._n_n._n_offset = (long int) ""; 1854 else if (!bfd_coff_symname_in_debug (abfd, &internal_ptr->u.syment)) 1855 { 1856 /* Long name already. Point symbol at the string in the 1857 table. */ 1858 if (string_table == NULL) 1859 { 1860 string_table = _bfd_coff_read_string_table (abfd); 1861 if (string_table == NULL) 1862 return NULL; 1863 } 1864 internal_ptr->u.syment._n._n_n._n_offset = 1865 ((long int) 1866 (string_table 1867 + internal_ptr->u.syment._n._n_n._n_offset)); 1868 } 1869 else 1870 { 1871 /* Long name in debug section. Very similar. */ 1872 if (debug_section == NULL) 1873 debug_section = build_debug_section (abfd); 1874 internal_ptr->u.syment._n._n_n._n_offset = (long int) 1875 (debug_section + internal_ptr->u.syment._n._n_n._n_offset); 1876 } 1877 } 1878 internal_ptr += internal_ptr->u.syment.n_numaux; 1879 } 1880 1881 obj_raw_syments (abfd) = internal; 1882 BFD_ASSERT (obj_raw_syment_count (abfd) 1883 == (unsigned int) (internal_ptr - internal)); 1884 1885 return (internal); 1886} /* coff_get_normalized_symtab() */ 1887 1888long 1889coff_get_reloc_upper_bound (abfd, asect) 1890 bfd *abfd; 1891 sec_ptr asect; 1892{ 1893 if (bfd_get_format (abfd) != bfd_object) 1894 { 1895 bfd_set_error (bfd_error_invalid_operation); 1896 return -1; 1897 } 1898 return (asect->reloc_count + 1) * sizeof (arelent *); 1899} 1900 1901asymbol * 1902coff_make_empty_symbol (abfd) 1903 bfd *abfd; 1904{ 1905 bfd_size_type amt = sizeof (coff_symbol_type); 1906 coff_symbol_type *new = (coff_symbol_type *) bfd_zalloc (abfd, amt); 1907 if (new == NULL) 1908 return (NULL); 1909 new->symbol.section = 0; 1910 new->native = 0; 1911 new->lineno = (alent *) NULL; 1912 new->done_lineno = false; 1913 new->symbol.the_bfd = abfd; 1914 return &new->symbol; 1915} 1916 1917/* Make a debugging symbol. */ 1918 1919asymbol * 1920coff_bfd_make_debug_symbol (abfd, ptr, sz) 1921 bfd *abfd; 1922 PTR ptr ATTRIBUTE_UNUSED; 1923 unsigned long sz ATTRIBUTE_UNUSED; 1924{ 1925 bfd_size_type amt = sizeof (coff_symbol_type); 1926 coff_symbol_type *new = (coff_symbol_type *) bfd_alloc (abfd, amt); 1927 if (new == NULL) 1928 return (NULL); 1929 /* @@ The 10 is a guess at a plausible maximum number of aux entries 1930 (but shouldn't be a constant). */ 1931 amt = sizeof (combined_entry_type) * 10; 1932 new->native = (combined_entry_type *) bfd_zalloc (abfd, amt); 1933 if (!new->native) 1934 return (NULL); 1935 new->symbol.section = bfd_abs_section_ptr; 1936 new->symbol.flags = BSF_DEBUGGING; 1937 new->lineno = (alent *) NULL; 1938 new->done_lineno = false; 1939 new->symbol.the_bfd = abfd; 1940 return &new->symbol; 1941} 1942 1943void 1944coff_get_symbol_info (abfd, symbol, ret) 1945 bfd *abfd; 1946 asymbol *symbol; 1947 symbol_info *ret; 1948{ 1949 bfd_symbol_info (symbol, ret); 1950 if (coffsymbol (symbol)->native != NULL 1951 && coffsymbol (symbol)->native->fix_value) 1952 { 1953 ret->value = coffsymbol (symbol)->native->u.syment.n_value - 1954 (unsigned long) obj_raw_syments (abfd); 1955 } 1956} 1957 1958/* Return the COFF syment for a symbol. */ 1959 1960boolean 1961bfd_coff_get_syment (abfd, symbol, psyment) 1962 bfd *abfd; 1963 asymbol *symbol; 1964 struct internal_syment *psyment; 1965{ 1966 coff_symbol_type *csym; 1967 1968 csym = coff_symbol_from (abfd, symbol); 1969 if (csym == NULL || csym->native == NULL) 1970 { 1971 bfd_set_error (bfd_error_invalid_operation); 1972 return false; 1973 } 1974 1975 *psyment = csym->native->u.syment; 1976 1977 if (csym->native->fix_value) 1978 psyment->n_value = psyment->n_value - 1979 (unsigned long) obj_raw_syments (abfd); 1980 1981 /* FIXME: We should handle fix_line here. */ 1982 1983 return true; 1984} 1985 1986/* Return the COFF auxent for a symbol. */ 1987 1988boolean 1989bfd_coff_get_auxent (abfd, symbol, indx, pauxent) 1990 bfd *abfd; 1991 asymbol *symbol; 1992 int indx; 1993 union internal_auxent *pauxent; 1994{ 1995 coff_symbol_type *csym; 1996 combined_entry_type *ent; 1997 1998 csym = coff_symbol_from (abfd, symbol); 1999 2000 if (csym == NULL 2001 || csym->native == NULL 2002 || indx >= csym->native->u.syment.n_numaux) 2003 { 2004 bfd_set_error (bfd_error_invalid_operation); 2005 return false; 2006 } 2007 2008 ent = csym->native + indx + 1; 2009 2010 *pauxent = ent->u.auxent; 2011 2012 if (ent->fix_tag) 2013 pauxent->x_sym.x_tagndx.l = 2014 ((combined_entry_type *) pauxent->x_sym.x_tagndx.p 2015 - obj_raw_syments (abfd)); 2016 2017 if (ent->fix_end) 2018 pauxent->x_sym.x_fcnary.x_fcn.x_endndx.l = 2019 ((combined_entry_type *) pauxent->x_sym.x_fcnary.x_fcn.x_endndx.p 2020 - obj_raw_syments (abfd)); 2021 2022 if (ent->fix_scnlen) 2023 pauxent->x_csect.x_scnlen.l = 2024 ((combined_entry_type *) pauxent->x_csect.x_scnlen.p 2025 - obj_raw_syments (abfd)); 2026 2027 return true; 2028} 2029 2030/* Print out information about COFF symbol. */ 2031 2032void 2033coff_print_symbol (abfd, filep, symbol, how) 2034 bfd *abfd; 2035 PTR filep; 2036 asymbol *symbol; 2037 bfd_print_symbol_type how; 2038{ 2039 FILE *file = (FILE *) filep; 2040 2041 switch (how) 2042 { 2043 case bfd_print_symbol_name: 2044 fprintf (file, "%s", symbol->name); 2045 break; 2046 2047 case bfd_print_symbol_more: 2048 fprintf (file, "coff %s %s", 2049 coffsymbol (symbol)->native ? "n" : "g", 2050 coffsymbol (symbol)->lineno ? "l" : " "); 2051 break; 2052 2053 case bfd_print_symbol_all: 2054 if (coffsymbol (symbol)->native) 2055 { 2056 bfd_vma val; 2057 unsigned int aux; 2058 combined_entry_type *combined = coffsymbol (symbol)->native; 2059 combined_entry_type *root = obj_raw_syments (abfd); 2060 struct lineno_cache_entry *l = coffsymbol (symbol)->lineno; 2061 2062 fprintf (file, "[%3ld]", (long) (combined - root)); 2063 2064 if (! combined->fix_value) 2065 val = (bfd_vma) combined->u.syment.n_value; 2066 else 2067 val = combined->u.syment.n_value - (unsigned long) root; 2068 2069#ifndef XCOFF64 2070 fprintf (file, 2071 "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x%08lx %s", 2072 combined->u.syment.n_scnum, 2073 combined->u.syment.n_flags, 2074 combined->u.syment.n_type, 2075 combined->u.syment.n_sclass, 2076 combined->u.syment.n_numaux, 2077 (unsigned long) val, 2078 symbol->name); 2079#else 2080 /* Print out the wide, 64 bit, symbol value */ 2081 fprintf (file, 2082 "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x%016llx %s", 2083 combined->u.syment.n_scnum, 2084 combined->u.syment.n_flags, 2085 combined->u.syment.n_type, 2086 combined->u.syment.n_sclass, 2087 combined->u.syment.n_numaux, 2088 val, 2089 symbol->name); 2090#endif 2091 2092 for (aux = 0; aux < combined->u.syment.n_numaux; aux++) 2093 { 2094 combined_entry_type *auxp = combined + aux + 1; 2095 long tagndx; 2096 2097 if (auxp->fix_tag) 2098 tagndx = auxp->u.auxent.x_sym.x_tagndx.p - root; 2099 else 2100 tagndx = auxp->u.auxent.x_sym.x_tagndx.l; 2101 2102 fprintf (file, "\n"); 2103 2104 if (bfd_coff_print_aux (abfd, file, root, combined, auxp, aux)) 2105 continue; 2106 2107 switch (combined->u.syment.n_sclass) 2108 { 2109 case C_FILE: 2110 fprintf (file, "File "); 2111 break; 2112 2113 case C_STAT: 2114 if (combined->u.syment.n_type == T_NULL) 2115 /* probably a section symbol? */ 2116 { 2117 fprintf (file, "AUX scnlen 0x%lx nreloc %d nlnno %d", 2118 (long) auxp->u.auxent.x_scn.x_scnlen, 2119 auxp->u.auxent.x_scn.x_nreloc, 2120 auxp->u.auxent.x_scn.x_nlinno); 2121 if (auxp->u.auxent.x_scn.x_checksum != 0 2122 || auxp->u.auxent.x_scn.x_associated != 0 2123 || auxp->u.auxent.x_scn.x_comdat != 0) 2124 fprintf (file, " checksum 0x%lx assoc %d comdat %d", 2125 auxp->u.auxent.x_scn.x_checksum, 2126 auxp->u.auxent.x_scn.x_associated, 2127 auxp->u.auxent.x_scn.x_comdat); 2128 break; 2129 } 2130 /* else fall through */ 2131 case C_EXT: 2132 if (ISFCN (combined->u.syment.n_type)) 2133 { 2134 long next, llnos; 2135 2136 if (auxp->fix_end) 2137 next = (auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p 2138 - root); 2139 else 2140 next = auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l; 2141 llnos = auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_lnnoptr; 2142 fprintf (file, 2143 "AUX tagndx %ld ttlsiz 0x%lx lnnos %ld next %ld", 2144 tagndx, auxp->u.auxent.x_sym.x_misc.x_fsize, 2145 llnos, next); 2146 break; 2147 } 2148 /* else fall through */ 2149 default: 2150 fprintf (file, "AUX lnno %d size 0x%x tagndx %ld", 2151 auxp->u.auxent.x_sym.x_misc.x_lnsz.x_lnno, 2152 auxp->u.auxent.x_sym.x_misc.x_lnsz.x_size, 2153 tagndx); 2154 if (auxp->fix_end) 2155 fprintf (file, " endndx %ld", 2156 ((long) 2157 (auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p 2158 - root))); 2159 break; 2160 } 2161 } 2162 2163 if (l) 2164 { 2165 fprintf (file, "\n%s :", l->u.sym->name); 2166 l++; 2167 while (l->line_number) 2168 { 2169 fprintf (file, "\n%4d : 0x%lx", 2170 l->line_number, 2171 ((unsigned long) 2172 (l->u.offset + symbol->section->vma))); 2173 l++; 2174 } 2175 } 2176 } 2177 else 2178 { 2179 bfd_print_symbol_vandf (abfd, (PTR) file, symbol); 2180 fprintf (file, " %-5s %s %s %s", 2181 symbol->section->name, 2182 coffsymbol (symbol)->native ? "n" : "g", 2183 coffsymbol (symbol)->lineno ? "l" : " ", 2184 symbol->name); 2185 } 2186 } 2187} 2188 2189/* Return whether a symbol name implies a local symbol. In COFF, 2190 local symbols generally start with ``.L''. Most targets use this 2191 function for the is_local_label_name entry point, but some may 2192 override it. */ 2193 2194boolean 2195_bfd_coff_is_local_label_name (abfd, name) 2196 bfd *abfd ATTRIBUTE_UNUSED; 2197 const char *name; 2198{
|