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