1 /* Support for the generic parts of COFF, for BFD. 2 Copyright (C) 1990-2020 Free Software Foundation, Inc. 3 Written by Cygnus Support. 4 5 This file is part of BFD, the Binary File Descriptor library. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program; if not, write to the Free Software 19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 20 MA 02110-1301, USA. */ 21 22 /* Most of this hacked by Steve Chamberlain, sac@cygnus.com. 23 Split out of coffcode.h by Ian Taylor, ian@cygnus.com. */ 24 25 /* This file contains COFF code that is not dependent on any 26 particular COFF target. There is only one version of this file in 27 libbfd.a, so no target specific code may be put in here. Or, to 28 put it another way, 29 30 ********** DO NOT PUT TARGET SPECIFIC CODE IN THIS FILE ********** 31 32 If you need to add some target specific behaviour, add a new hook 33 function to bfd_coff_backend_data. 34 35 Some of these functions are also called by the ECOFF routines. 36 Those functions may not use any COFF specific information, such as 37 coff_data (abfd). */ 38 39 #include "sysdep.h" 40 #include <limits.h> 41 #include "bfd.h" 42 #include "libbfd.h" 43 #include "coff/internal.h" 44 #include "libcoff.h" 45 46 /* Take a section header read from a coff file (in HOST byte order), 47 and make a BFD "section" out of it. This is used by ECOFF. */ 48 49 static bfd_boolean 50 make_a_section_from_file (bfd *abfd, 51 struct internal_scnhdr *hdr, 52 unsigned int target_index) 53 { 54 asection *return_section; 55 char *name; 56 bfd_boolean result = TRUE; 57 flagword flags; 58 59 name = NULL; 60 61 /* Handle long section names as in PE. On reading, we want to 62 accept long names if the format permits them at all, regardless 63 of the current state of the flag that dictates if we would generate 64 them in outputs; this construct checks if that is the case by 65 attempting to set the flag, without changing its state; the call 66 will fail for formats that do not support long names at all. */ 67 if (bfd_coff_set_long_section_names (abfd, bfd_coff_long_section_names (abfd)) 68 && hdr->s_name[0] == '/') 69 { 70 char buf[SCNNMLEN]; 71 long strindex; 72 char *p; 73 const char *strings; 74 75 /* Flag that this BFD uses long names, even though the format might 76 expect them to be off by default. This won't directly affect the 77 format of any output BFD created from this one, but the information 78 can be used to decide what to do. */ 79 bfd_coff_set_long_section_names (abfd, TRUE); 80 memcpy (buf, hdr->s_name + 1, SCNNMLEN - 1); 81 buf[SCNNMLEN - 1] = '\0'; 82 strindex = strtol (buf, &p, 10); 83 if (*p == '\0' && strindex >= 0) 84 { 85 strings = _bfd_coff_read_string_table (abfd); 86 if (strings == NULL) 87 return FALSE; 88 if ((bfd_size_type)(strindex + 2) >= obj_coff_strings_len (abfd)) 89 return FALSE; 90 strings += strindex; 91 name = (char *) bfd_alloc (abfd, 92 (bfd_size_type) strlen (strings) + 1 + 1); 93 if (name == NULL) 94 return FALSE; 95 strcpy (name, strings); 96 } 97 } 98 99 if (name == NULL) 100 { 101 /* Assorted wastage to null-terminate the name, thanks AT&T! */ 102 name = (char *) bfd_alloc (abfd, 103 (bfd_size_type) sizeof (hdr->s_name) + 1 + 1); 104 if (name == NULL) 105 return FALSE; 106 strncpy (name, (char *) &hdr->s_name[0], sizeof (hdr->s_name)); 107 name[sizeof (hdr->s_name)] = 0; 108 } 109 110 return_section = bfd_make_section_anyway (abfd, name); 111 if (return_section == NULL) 112 return FALSE; 113 114 return_section->vma = hdr->s_vaddr; 115 return_section->lma = hdr->s_paddr; 116 return_section->size = hdr->s_size; 117 return_section->filepos = hdr->s_scnptr; 118 return_section->rel_filepos = hdr->s_relptr; 119 return_section->reloc_count = hdr->s_nreloc; 120 121 bfd_coff_set_alignment_hook (abfd, return_section, hdr); 122 123 return_section->line_filepos = hdr->s_lnnoptr; 124 125 return_section->lineno_count = hdr->s_nlnno; 126 return_section->userdata = NULL; 127 return_section->next = NULL; 128 return_section->target_index = target_index; 129 130 if (! bfd_coff_styp_to_sec_flags_hook (abfd, hdr, name, return_section, 131 & flags)) 132 result = FALSE; 133 134 return_section->flags = flags; 135 136 /* At least on i386-coff, the line number count for a shared library 137 section must be ignored. */ 138 if ((return_section->flags & SEC_COFF_SHARED_LIBRARY) != 0) 139 return_section->lineno_count = 0; 140 141 if (hdr->s_nreloc != 0) 142 return_section->flags |= SEC_RELOC; 143 /* FIXME: should this check 'hdr->s_size > 0'. */ 144 if (hdr->s_scnptr != 0) 145 return_section->flags |= SEC_HAS_CONTENTS; 146 147 /* Compress/decompress DWARF debug sections with names: .debug_* and 148 .zdebug_*, after the section flags is set. */ 149 if ((flags & SEC_DEBUGGING) 150 && strlen (name) > 7 151 && ((name[1] == 'd' && name[6] == '_') 152 || (strlen (name) > 8 && name[1] == 'z' && name[7] == '_'))) 153 { 154 enum { nothing, compress, decompress } action = nothing; 155 char *new_name = NULL; 156 157 if (bfd_is_section_compressed (abfd, return_section)) 158 { 159 /* Compressed section. Check if we should decompress. */ 160 if ((abfd->flags & BFD_DECOMPRESS)) 161 action = decompress; 162 } 163 else if (!bfd_is_section_compressed (abfd, return_section)) 164 { 165 /* Normal section. Check if we should compress. */ 166 if ((abfd->flags & BFD_COMPRESS) && return_section->size != 0) 167 action = compress; 168 } 169 170 switch (action) 171 { 172 case nothing: 173 break; 174 case compress: 175 if (!bfd_init_section_compress_status (abfd, return_section)) 176 { 177 _bfd_error_handler 178 /* xgettext: c-format */ 179 (_("%pB: unable to initialize compress status for section %s"), 180 abfd, name); 181 return FALSE; 182 } 183 if (return_section->compress_status == COMPRESS_SECTION_DONE) 184 { 185 if (name[1] != 'z') 186 { 187 unsigned int len = strlen (name); 188 189 new_name = bfd_alloc (abfd, len + 2); 190 if (new_name == NULL) 191 return FALSE; 192 new_name[0] = '.'; 193 new_name[1] = 'z'; 194 memcpy (new_name + 2, name + 1, len); 195 } 196 } 197 break; 198 case decompress: 199 if (!bfd_init_section_decompress_status (abfd, return_section)) 200 { 201 _bfd_error_handler 202 /* xgettext: c-format */ 203 (_("%pB: unable to initialize decompress status for section %s"), 204 abfd, name); 205 return FALSE; 206 } 207 if (name[1] == 'z') 208 { 209 unsigned int len = strlen (name); 210 211 new_name = bfd_alloc (abfd, len); 212 if (new_name == NULL) 213 return FALSE; 214 new_name[0] = '.'; 215 memcpy (new_name + 1, name + 2, len - 1); 216 } 217 break; 218 } 219 if (new_name != NULL) 220 bfd_rename_section (return_section, new_name); 221 } 222 223 return result; 224 } 225 226 /* Read in a COFF object and make it into a BFD. This is used by 227 ECOFF as well. */ 228 const bfd_target * 229 coff_real_object_p (bfd *, 230 unsigned, 231 struct internal_filehdr *, 232 struct internal_aouthdr *); 233 const bfd_target * 234 coff_real_object_p (bfd *abfd, 235 unsigned nscns, 236 struct internal_filehdr *internal_f, 237 struct internal_aouthdr *internal_a) 238 { 239 flagword oflags = abfd->flags; 240 bfd_vma ostart = bfd_get_start_address (abfd); 241 void * tdata; 242 void * tdata_save; 243 bfd_size_type readsize; /* Length of file_info. */ 244 unsigned int scnhsz; 245 char *external_sections; 246 247 if (!(internal_f->f_flags & F_RELFLG)) 248 abfd->flags |= HAS_RELOC; 249 if ((internal_f->f_flags & F_EXEC)) 250 abfd->flags |= EXEC_P; 251 if (!(internal_f->f_flags & F_LNNO)) 252 abfd->flags |= HAS_LINENO; 253 if (!(internal_f->f_flags & F_LSYMS)) 254 abfd->flags |= HAS_LOCALS; 255 256 /* FIXME: How can we set D_PAGED correctly? */ 257 if ((internal_f->f_flags & F_EXEC) != 0) 258 abfd->flags |= D_PAGED; 259 260 abfd->symcount = internal_f->f_nsyms; 261 if (internal_f->f_nsyms) 262 abfd->flags |= HAS_SYMS; 263 264 if (internal_a != (struct internal_aouthdr *) NULL) 265 abfd->start_address = internal_a->entry; 266 else 267 abfd->start_address = 0; 268 269 /* Set up the tdata area. ECOFF uses its own routine, and overrides 270 abfd->flags. */ 271 tdata_save = abfd->tdata.any; 272 tdata = bfd_coff_mkobject_hook (abfd, (void *) internal_f, (void *) internal_a); 273 if (tdata == NULL) 274 goto fail2; 275 276 scnhsz = bfd_coff_scnhsz (abfd); 277 readsize = (bfd_size_type) nscns * scnhsz; 278 external_sections = (char *) bfd_alloc (abfd, readsize); 279 if (!external_sections) 280 goto fail; 281 282 if (bfd_bread ((void *) external_sections, readsize, abfd) != readsize) 283 goto fail; 284 285 /* Set the arch/mach *before* swapping in sections; section header swapping 286 may depend on arch/mach info. */ 287 if (! bfd_coff_set_arch_mach_hook (abfd, (void *) internal_f)) 288 goto fail; 289 290 /* Now copy data as required; construct all asections etc. */ 291 if (nscns != 0) 292 { 293 unsigned int i; 294 for (i = 0; i < nscns; i++) 295 { 296 struct internal_scnhdr tmp; 297 bfd_coff_swap_scnhdr_in (abfd, 298 (void *) (external_sections + i * scnhsz), 299 (void *) & tmp); 300 if (! make_a_section_from_file (abfd, &tmp, i + 1)) 301 goto fail; 302 } 303 } 304 305 obj_coff_keep_syms (abfd) = FALSE; 306 obj_coff_keep_strings (abfd) = FALSE; 307 _bfd_coff_free_symbols (abfd); 308 return abfd->xvec; 309 310 fail: 311 obj_coff_keep_syms (abfd) = FALSE; 312 obj_coff_keep_strings (abfd) = FALSE; 313 _bfd_coff_free_symbols (abfd); 314 bfd_release (abfd, tdata); 315 fail2: 316 abfd->tdata.any = tdata_save; 317 abfd->flags = oflags; 318 abfd->start_address = ostart; 319 return (const bfd_target *) NULL; 320 } 321 322 /* Turn a COFF file into a BFD, but fail with bfd_error_wrong_format if it is 323 not a COFF file. This is also used by ECOFF. */ 324 325 const bfd_target * 326 coff_object_p (bfd *abfd) 327 { 328 bfd_size_type filhsz; 329 bfd_size_type aoutsz; 330 unsigned int nscns; 331 void * filehdr; 332 struct internal_filehdr internal_f; 333 struct internal_aouthdr internal_a; 334 335 /* Figure out how much to read. */ 336 filhsz = bfd_coff_filhsz (abfd); 337 aoutsz = bfd_coff_aoutsz (abfd); 338 339 filehdr = bfd_alloc (abfd, filhsz); 340 if (filehdr == NULL) 341 return NULL; 342 if (bfd_bread (filehdr, filhsz, abfd) != filhsz) 343 { 344 if (bfd_get_error () != bfd_error_system_call) 345 bfd_set_error (bfd_error_wrong_format); 346 bfd_release (abfd, filehdr); 347 return NULL; 348 } 349 bfd_coff_swap_filehdr_in (abfd, filehdr, &internal_f); 350 bfd_release (abfd, filehdr); 351 352 /* The XCOFF format has two sizes for the f_opthdr. SMALL_AOUTSZ 353 (less than aoutsz) used in object files and AOUTSZ (equal to 354 aoutsz) in executables. The bfd_coff_swap_aouthdr_in function 355 expects this header to be aoutsz bytes in length, so we use that 356 value in the call to bfd_alloc below. But we must be careful to 357 only read in f_opthdr bytes in the call to bfd_bread. We should 358 also attempt to catch corrupt or non-COFF binaries with a strange 359 value for f_opthdr. */ 360 if (! bfd_coff_bad_format_hook (abfd, &internal_f) 361 || internal_f.f_opthdr > aoutsz) 362 { 363 bfd_set_error (bfd_error_wrong_format); 364 return NULL; 365 } 366 nscns = internal_f.f_nscns; 367 368 if (internal_f.f_opthdr) 369 { 370 void * opthdr; 371 372 opthdr = bfd_alloc (abfd, aoutsz); 373 if (opthdr == NULL) 374 return NULL; 375 if (bfd_bread (opthdr, (bfd_size_type) internal_f.f_opthdr, abfd) 376 != internal_f.f_opthdr) 377 { 378 bfd_release (abfd, opthdr); 379 return NULL; 380 } 381 /* PR 17512: file: 11056-1136-0.004. */ 382 if (internal_f.f_opthdr < aoutsz) 383 memset (((char *) opthdr) + internal_f.f_opthdr, 0, aoutsz - internal_f.f_opthdr); 384 385 bfd_coff_swap_aouthdr_in (abfd, opthdr, (void *) &internal_a); 386 bfd_release (abfd, opthdr); 387 } 388 389 return coff_real_object_p (abfd, nscns, &internal_f, 390 (internal_f.f_opthdr != 0 391 ? &internal_a 392 : (struct internal_aouthdr *) NULL)); 393 } 394 395 /* Get the BFD section from a COFF symbol section number. */ 396 397 asection * 398 coff_section_from_bfd_index (bfd *abfd, int section_index) 399 { 400 struct bfd_section *answer = abfd->sections; 401 402 if (section_index == N_ABS) 403 return bfd_abs_section_ptr; 404 if (section_index == N_UNDEF) 405 return bfd_und_section_ptr; 406 if (section_index == N_DEBUG) 407 return bfd_abs_section_ptr; 408 409 while (answer) 410 { 411 if (answer->target_index == section_index) 412 return answer; 413 answer = answer->next; 414 } 415 416 /* We should not reach this point, but the SCO 3.2v4 /lib/libc_s.a 417 has a bad symbol table in biglitpow.o. */ 418 return bfd_und_section_ptr; 419 } 420 421 /* Get the upper bound of a COFF symbol table. */ 422 423 long 424 coff_get_symtab_upper_bound (bfd *abfd) 425 { 426 if (!bfd_coff_slurp_symbol_table (abfd)) 427 return -1; 428 429 return (bfd_get_symcount (abfd) + 1) * (sizeof (coff_symbol_type *)); 430 } 431 432 /* Canonicalize a COFF symbol table. */ 433 434 long 435 coff_canonicalize_symtab (bfd *abfd, asymbol **alocation) 436 { 437 unsigned int counter; 438 coff_symbol_type *symbase; 439 coff_symbol_type **location = (coff_symbol_type **) alocation; 440 441 if (!bfd_coff_slurp_symbol_table (abfd)) 442 return -1; 443 444 symbase = obj_symbols (abfd); 445 counter = bfd_get_symcount (abfd); 446 while (counter-- > 0) 447 *location++ = symbase++; 448 449 *location = NULL; 450 451 return bfd_get_symcount (abfd); 452 } 453 454 /* Get the name of a symbol. The caller must pass in a buffer of size 455 >= SYMNMLEN + 1. */ 456 457 const char * 458 _bfd_coff_internal_syment_name (bfd *abfd, 459 const struct internal_syment *sym, 460 char *buf) 461 { 462 /* FIXME: It's not clear this will work correctly if sizeof 463 (_n_zeroes) != 4. */ 464 if (sym->_n._n_n._n_zeroes != 0 465 || sym->_n._n_n._n_offset == 0) 466 { 467 memcpy (buf, sym->_n._n_name, SYMNMLEN); 468 buf[SYMNMLEN] = '\0'; 469 return buf; 470 } 471 else 472 { 473 const char *strings; 474 475 BFD_ASSERT (sym->_n._n_n._n_offset >= STRING_SIZE_SIZE); 476 strings = obj_coff_strings (abfd); 477 if (strings == NULL) 478 { 479 strings = _bfd_coff_read_string_table (abfd); 480 if (strings == NULL) 481 return NULL; 482 } 483 /* PR 17910: Only check for string overflow if the length has been set. 484 Some DLLs, eg those produced by Visual Studio, may not set the length field. */ 485 if (obj_coff_strings_len (abfd) > 0 486 && sym->_n._n_n._n_offset >= obj_coff_strings_len (abfd)) 487 return NULL; 488 return strings + sym->_n._n_n._n_offset; 489 } 490 } 491 492 /* Read in and swap the relocs. This returns a buffer holding the 493 relocs for section SEC in file ABFD. If CACHE is TRUE and 494 INTERNAL_RELOCS is NULL, the relocs read in will be saved in case 495 the function is called again. If EXTERNAL_RELOCS is not NULL, it 496 is a buffer large enough to hold the unswapped relocs. If 497 INTERNAL_RELOCS is not NULL, it is a buffer large enough to hold 498 the swapped relocs. If REQUIRE_INTERNAL is TRUE, then the return 499 value must be INTERNAL_RELOCS. The function returns NULL on error. */ 500 501 struct internal_reloc * 502 _bfd_coff_read_internal_relocs (bfd *abfd, 503 asection *sec, 504 bfd_boolean cache, 505 bfd_byte *external_relocs, 506 bfd_boolean require_internal, 507 struct internal_reloc *internal_relocs) 508 { 509 bfd_size_type relsz; 510 bfd_byte *free_external = NULL; 511 struct internal_reloc *free_internal = NULL; 512 bfd_byte *erel; 513 bfd_byte *erel_end; 514 struct internal_reloc *irel; 515 bfd_size_type amt; 516 517 if (sec->reloc_count == 0) 518 return internal_relocs; /* Nothing to do. */ 519 520 if (coff_section_data (abfd, sec) != NULL 521 && coff_section_data (abfd, sec)->relocs != NULL) 522 { 523 if (! require_internal) 524 return coff_section_data (abfd, sec)->relocs; 525 memcpy (internal_relocs, coff_section_data (abfd, sec)->relocs, 526 sec->reloc_count * sizeof (struct internal_reloc)); 527 return internal_relocs; 528 } 529 530 relsz = bfd_coff_relsz (abfd); 531 532 amt = sec->reloc_count * relsz; 533 if (external_relocs == NULL) 534 { 535 free_external = (bfd_byte *) bfd_malloc (amt); 536 if (free_external == NULL) 537 goto error_return; 538 external_relocs = free_external; 539 } 540 541 if (bfd_seek (abfd, sec->rel_filepos, SEEK_SET) != 0 542 || bfd_bread (external_relocs, amt, abfd) != amt) 543 goto error_return; 544 545 if (internal_relocs == NULL) 546 { 547 amt = sec->reloc_count; 548 amt *= sizeof (struct internal_reloc); 549 free_internal = (struct internal_reloc *) bfd_malloc (amt); 550 if (free_internal == NULL) 551 goto error_return; 552 internal_relocs = free_internal; 553 } 554 555 /* Swap in the relocs. */ 556 erel = external_relocs; 557 erel_end = erel + relsz * sec->reloc_count; 558 irel = internal_relocs; 559 for (; erel < erel_end; erel += relsz, irel++) 560 bfd_coff_swap_reloc_in (abfd, (void *) erel, (void *) irel); 561 562 if (free_external != NULL) 563 { 564 free (free_external); 565 free_external = NULL; 566 } 567 568 if (cache && free_internal != NULL) 569 { 570 if (coff_section_data (abfd, sec) == NULL) 571 { 572 amt = sizeof (struct coff_section_tdata); 573 sec->used_by_bfd = bfd_zalloc (abfd, amt); 574 if (sec->used_by_bfd == NULL) 575 goto error_return; 576 coff_section_data (abfd, sec)->contents = NULL; 577 } 578 coff_section_data (abfd, sec)->relocs = free_internal; 579 } 580 581 return internal_relocs; 582 583 error_return: 584 if (free_external != NULL) 585 free (free_external); 586 if (free_internal != NULL) 587 free (free_internal); 588 return NULL; 589 } 590 591 /* Set lineno_count for the output sections of a COFF file. */ 592 593 int 594 coff_count_linenumbers (bfd *abfd) 595 { 596 unsigned int limit = bfd_get_symcount (abfd); 597 unsigned int i; 598 int total = 0; 599 asymbol **p; 600 asection *s; 601 602 if (limit == 0) 603 { 604 /* This may be from the backend linker, in which case the 605 lineno_count in the sections is correct. */ 606 for (s = abfd->sections; s != NULL; s = s->next) 607 total += s->lineno_count; 608 return total; 609 } 610 611 for (s = abfd->sections; s != NULL; s = s->next) 612 BFD_ASSERT (s->lineno_count == 0); 613 614 for (p = abfd->outsymbols, i = 0; i < limit; i++, p++) 615 { 616 asymbol *q_maybe = *p; 617 618 if (bfd_family_coff (bfd_asymbol_bfd (q_maybe))) 619 { 620 coff_symbol_type *q = coffsymbol (q_maybe); 621 622 /* The AIX 4.1 compiler can sometimes generate line numbers 623 attached to debugging symbols. We try to simply ignore 624 those here. */ 625 if (q->lineno != NULL 626 && q->symbol.section->owner != NULL) 627 { 628 /* This symbol has line numbers. Increment the owning 629 section's linenumber count. */ 630 alent *l = q->lineno; 631 632 do 633 { 634 asection * sec = q->symbol.section->output_section; 635 636 /* Do not try to update fields in read-only sections. */ 637 if (! bfd_is_const_section (sec)) 638 sec->lineno_count ++; 639 640 ++total; 641 ++l; 642 } 643 while (l->line_number != 0); 644 } 645 } 646 } 647 648 return total; 649 } 650 651 static void 652 fixup_symbol_value (bfd *abfd, 653 coff_symbol_type *coff_symbol_ptr, 654 struct internal_syment *syment) 655 { 656 /* Normalize the symbol flags. */ 657 if (coff_symbol_ptr->symbol.section 658 && bfd_is_com_section (coff_symbol_ptr->symbol.section)) 659 { 660 /* A common symbol is undefined with a value. */ 661 syment->n_scnum = N_UNDEF; 662 syment->n_value = coff_symbol_ptr->symbol.value; 663 } 664 else if ((coff_symbol_ptr->symbol.flags & BSF_DEBUGGING) != 0 665 && (coff_symbol_ptr->symbol.flags & BSF_DEBUGGING_RELOC) == 0) 666 { 667 syment->n_value = coff_symbol_ptr->symbol.value; 668 } 669 else if (bfd_is_und_section (coff_symbol_ptr->symbol.section)) 670 { 671 syment->n_scnum = N_UNDEF; 672 syment->n_value = 0; 673 } 674 /* FIXME: Do we need to handle the absolute section here? */ 675 else 676 { 677 if (coff_symbol_ptr->symbol.section) 678 { 679 syment->n_scnum = 680 coff_symbol_ptr->symbol.section->output_section->target_index; 681 682 syment->n_value = (coff_symbol_ptr->symbol.value 683 + coff_symbol_ptr->symbol.section->output_offset); 684 if (! obj_pe (abfd)) 685 { 686 syment->n_value += (syment->n_sclass == C_STATLAB) 687 ? coff_symbol_ptr->symbol.section->output_section->lma 688 : coff_symbol_ptr->symbol.section->output_section->vma; 689 } 690 } 691 else 692 { 693 BFD_ASSERT (0); 694 /* This can happen, but I don't know why yet (steve@cygnus.com) */ 695 syment->n_scnum = N_ABS; 696 syment->n_value = coff_symbol_ptr->symbol.value; 697 } 698 } 699 } 700 701 /* Run through all the symbols in the symbol table and work out what 702 their indexes into the symbol table will be when output. 703 704 Coff requires that each C_FILE symbol points to the next one in the 705 chain, and that the last one points to the first external symbol. We 706 do that here too. */ 707 708 bfd_boolean 709 coff_renumber_symbols (bfd *bfd_ptr, int *first_undef) 710 { 711 unsigned int symbol_count = bfd_get_symcount (bfd_ptr); 712 asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols; 713 unsigned int native_index = 0; 714 struct internal_syment *last_file = NULL; 715 unsigned int symbol_index; 716 717 /* COFF demands that undefined symbols come after all other symbols. 718 Since we don't need to impose this extra knowledge on all our 719 client programs, deal with that here. Sort the symbol table; 720 just move the undefined symbols to the end, leaving the rest 721 alone. The O'Reilly book says that defined global symbols come 722 at the end before the undefined symbols, so we do that here as 723 well. */ 724 /* @@ Do we have some condition we could test for, so we don't always 725 have to do this? I don't think relocatability is quite right, but 726 I'm not certain. [raeburn:19920508.1711EST] */ 727 { 728 asymbol **newsyms; 729 unsigned int i; 730 bfd_size_type amt; 731 732 amt = sizeof (asymbol *) * ((bfd_size_type) symbol_count + 1); 733 newsyms = (asymbol **) bfd_alloc (bfd_ptr, amt); 734 if (!newsyms) 735 return FALSE; 736 bfd_ptr->outsymbols = newsyms; 737 for (i = 0; i < symbol_count; i++) 738 if ((symbol_ptr_ptr[i]->flags & BSF_NOT_AT_END) != 0 739 || (!bfd_is_und_section (symbol_ptr_ptr[i]->section) 740 && !bfd_is_com_section (symbol_ptr_ptr[i]->section) 741 && ((symbol_ptr_ptr[i]->flags & BSF_FUNCTION) != 0 742 || ((symbol_ptr_ptr[i]->flags & (BSF_GLOBAL | BSF_WEAK)) 743 == 0)))) 744 *newsyms++ = symbol_ptr_ptr[i]; 745 746 for (i = 0; i < symbol_count; i++) 747 if ((symbol_ptr_ptr[i]->flags & BSF_NOT_AT_END) == 0 748 && !bfd_is_und_section (symbol_ptr_ptr[i]->section) 749 && (bfd_is_com_section (symbol_ptr_ptr[i]->section) 750 || ((symbol_ptr_ptr[i]->flags & BSF_FUNCTION) == 0 751 && ((symbol_ptr_ptr[i]->flags & (BSF_GLOBAL | BSF_WEAK)) 752 != 0)))) 753 *newsyms++ = symbol_ptr_ptr[i]; 754 755 *first_undef = newsyms - bfd_ptr->outsymbols; 756 757 for (i = 0; i < symbol_count; i++) 758 if ((symbol_ptr_ptr[i]->flags & BSF_NOT_AT_END) == 0 759 && bfd_is_und_section (symbol_ptr_ptr[i]->section)) 760 *newsyms++ = symbol_ptr_ptr[i]; 761 *newsyms = (asymbol *) NULL; 762 symbol_ptr_ptr = bfd_ptr->outsymbols; 763 } 764 765 for (symbol_index = 0; symbol_index < symbol_count; symbol_index++) 766 { 767 coff_symbol_type *coff_symbol_ptr; 768 769 coff_symbol_ptr = coff_symbol_from (symbol_ptr_ptr[symbol_index]); 770 symbol_ptr_ptr[symbol_index]->udata.i = symbol_index; 771 if (coff_symbol_ptr && coff_symbol_ptr->native) 772 { 773 combined_entry_type *s = coff_symbol_ptr->native; 774 int i; 775 776 BFD_ASSERT (s->is_sym); 777 if (s->u.syment.n_sclass == C_FILE) 778 { 779 if (last_file != NULL) 780 last_file->n_value = native_index; 781 last_file = &(s->u.syment); 782 } 783 else 784 /* Modify the symbol values according to their section and 785 type. */ 786 fixup_symbol_value (bfd_ptr, coff_symbol_ptr, &(s->u.syment)); 787 788 for (i = 0; i < s->u.syment.n_numaux + 1; i++) 789 s[i].offset = native_index++; 790 } 791 else 792 native_index++; 793 } 794 795 obj_conv_table_size (bfd_ptr) = native_index; 796 797 return TRUE; 798 } 799 800 /* Run thorough the symbol table again, and fix it so that all 801 pointers to entries are changed to the entries' index in the output 802 symbol table. */ 803 804 void 805 coff_mangle_symbols (bfd *bfd_ptr) 806 { 807 unsigned int symbol_count = bfd_get_symcount (bfd_ptr); 808 asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols; 809 unsigned int symbol_index; 810 811 for (symbol_index = 0; symbol_index < symbol_count; symbol_index++) 812 { 813 coff_symbol_type *coff_symbol_ptr; 814 815 coff_symbol_ptr = coff_symbol_from (symbol_ptr_ptr[symbol_index]); 816 if (coff_symbol_ptr && coff_symbol_ptr->native) 817 { 818 int i; 819 combined_entry_type *s = coff_symbol_ptr->native; 820 821 BFD_ASSERT (s->is_sym); 822 if (s->fix_value) 823 { 824 /* FIXME: We should use a union here. */ 825 s->u.syment.n_value = 826 (bfd_hostptr_t) ((combined_entry_type *) 827 ((bfd_hostptr_t) s->u.syment.n_value))->offset; 828 s->fix_value = 0; 829 } 830 if (s->fix_line) 831 { 832 /* The value is the offset into the line number entries 833 for the symbol's section. On output, the symbol's 834 section should be N_DEBUG. */ 835 s->u.syment.n_value = 836 (coff_symbol_ptr->symbol.section->output_section->line_filepos 837 + s->u.syment.n_value * bfd_coff_linesz (bfd_ptr)); 838 coff_symbol_ptr->symbol.section = 839 coff_section_from_bfd_index (bfd_ptr, N_DEBUG); 840 BFD_ASSERT (coff_symbol_ptr->symbol.flags & BSF_DEBUGGING); 841 } 842 for (i = 0; i < s->u.syment.n_numaux; i++) 843 { 844 combined_entry_type *a = s + i + 1; 845 846 BFD_ASSERT (! a->is_sym); 847 if (a->fix_tag) 848 { 849 a->u.auxent.x_sym.x_tagndx.l = 850 a->u.auxent.x_sym.x_tagndx.p->offset; 851 a->fix_tag = 0; 852 } 853 if (a->fix_end) 854 { 855 a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l = 856 a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p->offset; 857 a->fix_end = 0; 858 } 859 if (a->fix_scnlen) 860 { 861 a->u.auxent.x_csect.x_scnlen.l = 862 a->u.auxent.x_csect.x_scnlen.p->offset; 863 a->fix_scnlen = 0; 864 } 865 } 866 } 867 } 868 } 869 870 static void 871 coff_fix_symbol_name (bfd *abfd, 872 asymbol *symbol, 873 combined_entry_type *native, 874 bfd_size_type *string_size_p, 875 asection **debug_string_section_p, 876 bfd_size_type *debug_string_size_p) 877 { 878 unsigned int name_length; 879 union internal_auxent *auxent; 880 char *name = (char *) (symbol->name); 881 882 if (name == NULL) 883 { 884 /* COFF symbols always have names, so we'll make one up. */ 885 symbol->name = "strange"; 886 name = (char *) symbol->name; 887 } 888 name_length = strlen (name); 889 890 BFD_ASSERT (native->is_sym); 891 if (native->u.syment.n_sclass == C_FILE 892 && native->u.syment.n_numaux > 0) 893 { 894 unsigned int filnmlen; 895 896 if (bfd_coff_force_symnames_in_strings (abfd)) 897 { 898 native->u.syment._n._n_n._n_offset = 899 (*string_size_p + STRING_SIZE_SIZE); 900 native->u.syment._n._n_n._n_zeroes = 0; 901 *string_size_p += 6; /* strlen(".file") + 1 */ 902 } 903 else 904 strncpy (native->u.syment._n._n_name, ".file", SYMNMLEN); 905 906 BFD_ASSERT (! (native + 1)->is_sym); 907 auxent = &(native + 1)->u.auxent; 908 909 filnmlen = bfd_coff_filnmlen (abfd); 910 911 if (bfd_coff_long_filenames (abfd)) 912 { 913 if (name_length <= filnmlen) 914 strncpy (auxent->x_file.x_fname, name, filnmlen); 915 else 916 { 917 auxent->x_file.x_n.x_offset = *string_size_p + STRING_SIZE_SIZE; 918 auxent->x_file.x_n.x_zeroes = 0; 919 *string_size_p += name_length + 1; 920 } 921 } 922 else 923 { 924 strncpy (auxent->x_file.x_fname, name, filnmlen); 925 if (name_length > filnmlen) 926 name[filnmlen] = '\0'; 927 } 928 } 929 else 930 { 931 if (name_length <= SYMNMLEN && !bfd_coff_force_symnames_in_strings (abfd)) 932 /* This name will fit into the symbol neatly. */ 933 strncpy (native->u.syment._n._n_name, symbol->name, SYMNMLEN); 934 935 else if (!bfd_coff_symname_in_debug (abfd, &native->u.syment)) 936 { 937 native->u.syment._n._n_n._n_offset = (*string_size_p 938 + STRING_SIZE_SIZE); 939 native->u.syment._n._n_n._n_zeroes = 0; 940 *string_size_p += name_length + 1; 941 } 942 else 943 { 944 file_ptr filepos; 945 bfd_byte buf[4]; 946 int prefix_len = bfd_coff_debug_string_prefix_length (abfd); 947 948 /* This name should be written into the .debug section. For 949 some reason each name is preceded by a two byte length 950 and also followed by a null byte. FIXME: We assume that 951 the .debug section has already been created, and that it 952 is large enough. */ 953 if (*debug_string_section_p == (asection *) NULL) 954 *debug_string_section_p = bfd_get_section_by_name (abfd, ".debug"); 955 filepos = bfd_tell (abfd); 956 if (prefix_len == 4) 957 bfd_put_32 (abfd, (bfd_vma) (name_length + 1), buf); 958 else 959 bfd_put_16 (abfd, (bfd_vma) (name_length + 1), buf); 960 961 if (!bfd_set_section_contents (abfd, 962 *debug_string_section_p, 963 (void *) buf, 964 (file_ptr) *debug_string_size_p, 965 (bfd_size_type) prefix_len) 966 || !bfd_set_section_contents (abfd, 967 *debug_string_section_p, 968 (void *) symbol->name, 969 (file_ptr) (*debug_string_size_p 970 + prefix_len), 971 (bfd_size_type) name_length + 1)) 972 abort (); 973 if (bfd_seek (abfd, filepos, SEEK_SET) != 0) 974 abort (); 975 native->u.syment._n._n_n._n_offset = 976 *debug_string_size_p + prefix_len; 977 native->u.syment._n._n_n._n_zeroes = 0; 978 *debug_string_size_p += name_length + 1 + prefix_len; 979 } 980 } 981 } 982 983 /* We need to keep track of the symbol index so that when we write out 984 the relocs we can get the index for a symbol. This method is a 985 hack. FIXME. */ 986 987 #define set_index(symbol, idx) ((symbol)->udata.i = (idx)) 988 989 /* Write a symbol out to a COFF file. */ 990 991 static bfd_boolean 992 coff_write_symbol (bfd *abfd, 993 asymbol *symbol, 994 combined_entry_type *native, 995 bfd_vma *written, 996 bfd_size_type *string_size_p, 997 asection **debug_string_section_p, 998 bfd_size_type *debug_string_size_p) 999 { 1000 unsigned int numaux = native->u.syment.n_numaux; 1001 int type = native->u.syment.n_type; 1002 int n_sclass = (int) native->u.syment.n_sclass; 1003 asection *output_section = symbol->section->output_section 1004 ? symbol->section->output_section 1005 : symbol->section; 1006 void * buf; 1007 bfd_size_type symesz; 1008 1009 BFD_ASSERT (native->is_sym); 1010 1011 if (native->u.syment.n_sclass == C_FILE) 1012 symbol->flags |= BSF_DEBUGGING; 1013 1014 if (symbol->flags & BSF_DEBUGGING 1015 && bfd_is_abs_section (symbol->section)) 1016 native->u.syment.n_scnum = N_DEBUG; 1017 1018 else if (bfd_is_abs_section (symbol->section)) 1019 native->u.syment.n_scnum = N_ABS; 1020 1021 else if (bfd_is_und_section (symbol->section)) 1022 native->u.syment.n_scnum = N_UNDEF; 1023 1024 else 1025 native->u.syment.n_scnum = 1026 output_section->target_index; 1027 1028 coff_fix_symbol_name (abfd, symbol, native, string_size_p, 1029 debug_string_section_p, debug_string_size_p); 1030 1031 symesz = bfd_coff_symesz (abfd); 1032 buf = bfd_alloc (abfd, symesz); 1033 if (!buf) 1034 return FALSE; 1035 bfd_coff_swap_sym_out (abfd, &native->u.syment, buf); 1036 if (bfd_bwrite (buf, symesz, abfd) != symesz) 1037 return FALSE; 1038 bfd_release (abfd, buf); 1039 1040 if (native->u.syment.n_numaux > 0) 1041 { 1042 bfd_size_type auxesz; 1043 unsigned int j; 1044 1045 auxesz = bfd_coff_auxesz (abfd); 1046 buf = bfd_alloc (abfd, auxesz); 1047 if (!buf) 1048 return FALSE; 1049 for (j = 0; j < native->u.syment.n_numaux; j++) 1050 { 1051 BFD_ASSERT (! (native + j + 1)->is_sym); 1052 bfd_coff_swap_aux_out (abfd, 1053 &((native + j + 1)->u.auxent), 1054 type, n_sclass, (int) j, 1055 native->u.syment.n_numaux, 1056 buf); 1057 if (bfd_bwrite (buf, auxesz, abfd) != auxesz) 1058 return FALSE; 1059 } 1060 bfd_release (abfd, buf); 1061 } 1062 1063 /* Store the index for use when we write out the relocs. */ 1064 set_index (symbol, *written); 1065 1066 *written += numaux + 1; 1067 return TRUE; 1068 } 1069 1070 /* Write out a symbol to a COFF file that does not come from a COFF 1071 file originally. This symbol may have been created by the linker, 1072 or we may be linking a non COFF file to a COFF file. */ 1073 1074 bfd_boolean 1075 coff_write_alien_symbol (bfd *abfd, 1076 asymbol *symbol, 1077 struct internal_syment *isym, 1078 union internal_auxent *iaux, 1079 bfd_vma *written, 1080 bfd_size_type *string_size_p, 1081 asection **debug_string_section_p, 1082 bfd_size_type *debug_string_size_p) 1083 { 1084 combined_entry_type *native; 1085 combined_entry_type dummy[2]; 1086 asection *output_section = symbol->section->output_section 1087 ? symbol->section->output_section 1088 : symbol->section; 1089 struct bfd_link_info *link_info = coff_data (abfd)->link_info; 1090 bfd_boolean ret; 1091 1092 if ((!link_info || link_info->strip_discarded) 1093 && !bfd_is_abs_section (symbol->section) 1094 && symbol->section->output_section == bfd_abs_section_ptr) 1095 { 1096 symbol->name = ""; 1097 if (isym != NULL) 1098 memset (isym, 0, sizeof (*isym)); 1099 return TRUE; 1100 } 1101 native = dummy; 1102 native->is_sym = TRUE; 1103 native[1].is_sym = FALSE; 1104 native->u.syment.n_type = T_NULL; 1105 native->u.syment.n_flags = 0; 1106 native->u.syment.n_numaux = 0; 1107 if (bfd_is_und_section (symbol->section)) 1108 { 1109 native->u.syment.n_scnum = N_UNDEF; 1110 native->u.syment.n_value = symbol->value; 1111 } 1112 else if (bfd_is_com_section (symbol->section)) 1113 { 1114 native->u.syment.n_scnum = N_UNDEF; 1115 native->u.syment.n_value = symbol->value; 1116 } 1117 else if (symbol->flags & BSF_FILE) 1118 { 1119 native->u.syment.n_scnum = N_DEBUG; 1120 native->u.syment.n_numaux = 1; 1121 } 1122 else if (symbol->flags & BSF_DEBUGGING) 1123 { 1124 /* There isn't much point to writing out a debugging symbol 1125 unless we are prepared to convert it into COFF debugging 1126 format. So, we just ignore them. We must clobber the symbol 1127 name to keep it from being put in the string table. */ 1128 symbol->name = ""; 1129 if (isym != NULL) 1130 memset (isym, 0, sizeof (*isym)); 1131 return TRUE; 1132 } 1133 else 1134 { 1135 native->u.syment.n_scnum = output_section->target_index; 1136 native->u.syment.n_value = (symbol->value 1137 + symbol->section->output_offset); 1138 if (! obj_pe (abfd)) 1139 native->u.syment.n_value += output_section->vma; 1140 1141 /* Copy the any flags from the file header into the symbol. 1142 FIXME: Why? */ 1143 { 1144 coff_symbol_type *c = coff_symbol_from (symbol); 1145 if (c != (coff_symbol_type *) NULL) 1146 native->u.syment.n_flags = bfd_asymbol_bfd (&c->symbol)->flags; 1147 } 1148 } 1149 1150 native->u.syment.n_type = 0; 1151 if (symbol->flags & BSF_FILE) 1152 native->u.syment.n_sclass = C_FILE; 1153 else if (symbol->flags & BSF_LOCAL) 1154 native->u.syment.n_sclass = C_STAT; 1155 else if (symbol->flags & BSF_WEAK) 1156 native->u.syment.n_sclass = obj_pe (abfd) ? C_NT_WEAK : C_WEAKEXT; 1157 else 1158 native->u.syment.n_sclass = C_EXT; 1159 1160 ret = coff_write_symbol (abfd, symbol, native, written, string_size_p, 1161 debug_string_section_p, debug_string_size_p); 1162 if (isym != NULL) 1163 *isym = native->u.syment; 1164 if (iaux != NULL && native->u.syment.n_numaux) 1165 *iaux = native[1].u.auxent; 1166 return ret; 1167 } 1168 1169 /* Write a native symbol to a COFF file. */ 1170 1171 static bfd_boolean 1172 coff_write_native_symbol (bfd *abfd, 1173 coff_symbol_type *symbol, 1174 bfd_vma *written, 1175 bfd_size_type *string_size_p, 1176 asection **debug_string_section_p, 1177 bfd_size_type *debug_string_size_p) 1178 { 1179 combined_entry_type *native = symbol->native; 1180 alent *lineno = symbol->lineno; 1181 struct bfd_link_info *link_info = coff_data (abfd)->link_info; 1182 1183 if ((!link_info || link_info->strip_discarded) 1184 && !bfd_is_abs_section (symbol->symbol.section) 1185 && symbol->symbol.section->output_section == bfd_abs_section_ptr) 1186 { 1187 symbol->symbol.name = ""; 1188 return TRUE; 1189 } 1190 1191 BFD_ASSERT (native->is_sym); 1192 /* If this symbol has an associated line number, we must store the 1193 symbol index in the line number field. We also tag the auxent to 1194 point to the right place in the lineno table. */ 1195 if (lineno && !symbol->done_lineno && symbol->symbol.section->owner != NULL) 1196 { 1197 unsigned int count = 0; 1198 1199 lineno[count].u.offset = *written; 1200 if (native->u.syment.n_numaux) 1201 { 1202 union internal_auxent *a = &((native + 1)->u.auxent); 1203 1204 a->x_sym.x_fcnary.x_fcn.x_lnnoptr = 1205 symbol->symbol.section->output_section->moving_line_filepos; 1206 } 1207 1208 /* Count and relocate all other linenumbers. */ 1209 count++; 1210 while (lineno[count].line_number != 0) 1211 { 1212 lineno[count].u.offset += 1213 (symbol->symbol.section->output_section->vma 1214 + symbol->symbol.section->output_offset); 1215 count++; 1216 } 1217 symbol->done_lineno = TRUE; 1218 1219 if (! bfd_is_const_section (symbol->symbol.section->output_section)) 1220 symbol->symbol.section->output_section->moving_line_filepos += 1221 count * bfd_coff_linesz (abfd); 1222 } 1223 1224 return coff_write_symbol (abfd, &(symbol->symbol), native, written, 1225 string_size_p, debug_string_section_p, 1226 debug_string_size_p); 1227 } 1228 1229 static void 1230 null_error_handler (const char *fmt ATTRIBUTE_UNUSED, 1231 va_list ap ATTRIBUTE_UNUSED) 1232 { 1233 } 1234 1235 /* Write out the COFF symbols. */ 1236 1237 bfd_boolean 1238 coff_write_symbols (bfd *abfd) 1239 { 1240 bfd_size_type string_size; 1241 asection *debug_string_section; 1242 bfd_size_type debug_string_size; 1243 unsigned int i; 1244 unsigned int limit = bfd_get_symcount (abfd); 1245 bfd_vma written = 0; 1246 asymbol **p; 1247 1248 string_size = 0; 1249 debug_string_section = NULL; 1250 debug_string_size = 0; 1251 1252 /* If this target supports long section names, they must be put into 1253 the string table. This is supported by PE. This code must 1254 handle section names just as they are handled in 1255 coff_write_object_contents. */ 1256 if (bfd_coff_long_section_names (abfd)) 1257 { 1258 asection *o; 1259 1260 for (o = abfd->sections; o != NULL; o = o->next) 1261 { 1262 size_t len; 1263 1264 len = strlen (o->name); 1265 if (len > SCNNMLEN) 1266 string_size += len + 1; 1267 } 1268 } 1269 1270 /* Seek to the right place. */ 1271 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0) 1272 return FALSE; 1273 1274 /* Output all the symbols we have. */ 1275 written = 0; 1276 for (p = abfd->outsymbols, i = 0; i < limit; i++, p++) 1277 { 1278 asymbol *symbol = *p; 1279 coff_symbol_type *c_symbol = coff_symbol_from (symbol); 1280 1281 if (c_symbol == (coff_symbol_type *) NULL 1282 || c_symbol->native == (combined_entry_type *) NULL) 1283 { 1284 if (!coff_write_alien_symbol (abfd, symbol, NULL, NULL, &written, 1285 &string_size, &debug_string_section, 1286 &debug_string_size)) 1287 return FALSE; 1288 } 1289 else 1290 { 1291 if (coff_backend_info (abfd)->_bfd_coff_classify_symbol != NULL) 1292 { 1293 bfd_error_handler_type current_error_handler; 1294 enum coff_symbol_classification sym_class; 1295 unsigned char *n_sclass; 1296 1297 /* Suppress error reporting by bfd_coff_classify_symbol. 1298 Error messages can be generated when we are processing a local 1299 symbol which has no associated section and we do not have to 1300 worry about this, all we need to know is that it is local. */ 1301 current_error_handler = bfd_set_error_handler (null_error_handler); 1302 BFD_ASSERT (c_symbol->native->is_sym); 1303 sym_class = bfd_coff_classify_symbol (abfd, 1304 &c_symbol->native->u.syment); 1305 (void) bfd_set_error_handler (current_error_handler); 1306 1307 n_sclass = &c_symbol->native->u.syment.n_sclass; 1308 1309 /* If the symbol class has been changed (eg objcopy/ld script/etc) 1310 we cannot retain the existing sclass from the original symbol. 1311 Weak symbols only have one valid sclass, so just set it always. 1312 If it is not local class and should be, set it C_STAT. 1313 If it is global and not classified as global, or if it is 1314 weak (which is also classified as global), set it C_EXT. */ 1315 1316 if (symbol->flags & BSF_WEAK) 1317 *n_sclass = obj_pe (abfd) ? C_NT_WEAK : C_WEAKEXT; 1318 else if (symbol->flags & BSF_LOCAL && sym_class != COFF_SYMBOL_LOCAL) 1319 *n_sclass = C_STAT; 1320 else if (symbol->flags & BSF_GLOBAL 1321 && (sym_class != COFF_SYMBOL_GLOBAL 1322 #ifdef COFF_WITH_PE 1323 || *n_sclass == C_NT_WEAK 1324 #endif 1325 || *n_sclass == C_WEAKEXT)) 1326 c_symbol->native->u.syment.n_sclass = C_EXT; 1327 } 1328 1329 if (!coff_write_native_symbol (abfd, c_symbol, &written, 1330 &string_size, &debug_string_section, 1331 &debug_string_size)) 1332 return FALSE; 1333 } 1334 } 1335 1336 obj_raw_syment_count (abfd) = written; 1337 1338 /* Now write out strings. */ 1339 if (string_size != 0) 1340 { 1341 unsigned int size = string_size + STRING_SIZE_SIZE; 1342 bfd_byte buffer[STRING_SIZE_SIZE]; 1343 1344 #if STRING_SIZE_SIZE == 4 1345 H_PUT_32 (abfd, size, buffer); 1346 #else 1347 #error Change H_PUT_32 1348 #endif 1349 if (bfd_bwrite ((void *) buffer, (bfd_size_type) sizeof (buffer), abfd) 1350 != sizeof (buffer)) 1351 return FALSE; 1352 1353 /* Handle long section names. This code must handle section 1354 names just as they are handled in coff_write_object_contents. */ 1355 if (bfd_coff_long_section_names (abfd)) 1356 { 1357 asection *o; 1358 1359 for (o = abfd->sections; o != NULL; o = o->next) 1360 { 1361 size_t len; 1362 1363 len = strlen (o->name); 1364 if (len > SCNNMLEN) 1365 { 1366 if (bfd_bwrite (o->name, (bfd_size_type) (len + 1), abfd) 1367 != len + 1) 1368 return FALSE; 1369 } 1370 } 1371 } 1372 1373 for (p = abfd->outsymbols, i = 0; 1374 i < limit; 1375 i++, p++) 1376 { 1377 asymbol *q = *p; 1378 size_t name_length = strlen (q->name); 1379 coff_symbol_type *c_symbol = coff_symbol_from (q); 1380 size_t maxlen; 1381 1382 /* Figure out whether the symbol name should go in the string 1383 table. Symbol names that are short enough are stored 1384 directly in the syment structure. File names permit a 1385 different, longer, length in the syment structure. On 1386 XCOFF, some symbol names are stored in the .debug section 1387 rather than in the string table. */ 1388 1389 if (c_symbol == NULL 1390 || c_symbol->native == NULL) 1391 /* This is not a COFF symbol, so it certainly is not a 1392 file name, nor does it go in the .debug section. */ 1393 maxlen = bfd_coff_force_symnames_in_strings (abfd) ? 0 : SYMNMLEN; 1394 1395 else if (! c_symbol->native->is_sym) 1396 maxlen = bfd_coff_force_symnames_in_strings (abfd) ? 0 : SYMNMLEN; 1397 1398 else if (bfd_coff_symname_in_debug (abfd, 1399 &c_symbol->native->u.syment)) 1400 /* This symbol name is in the XCOFF .debug section. 1401 Don't write it into the string table. */ 1402 maxlen = name_length; 1403 1404 else if (c_symbol->native->u.syment.n_sclass == C_FILE 1405 && c_symbol->native->u.syment.n_numaux > 0) 1406 { 1407 if (bfd_coff_force_symnames_in_strings (abfd)) 1408 { 1409 if (bfd_bwrite (".file", (bfd_size_type) 6, abfd) != 6) 1410 return FALSE; 1411 } 1412 maxlen = bfd_coff_filnmlen (abfd); 1413 } 1414 else 1415 maxlen = bfd_coff_force_symnames_in_strings (abfd) ? 0 : SYMNMLEN; 1416 1417 if (name_length > maxlen) 1418 { 1419 if (bfd_bwrite ((void *) (q->name), (bfd_size_type) name_length + 1, 1420 abfd) != name_length + 1) 1421 return FALSE; 1422 } 1423 } 1424 } 1425 else 1426 { 1427 /* We would normally not write anything here, but we'll write 1428 out 4 so that any stupid coff reader which tries to read the 1429 string table even when there isn't one won't croak. */ 1430 unsigned int size = STRING_SIZE_SIZE; 1431 bfd_byte buffer[STRING_SIZE_SIZE]; 1432 1433 #if STRING_SIZE_SIZE == 4 1434 H_PUT_32 (abfd, size, buffer); 1435 #else 1436 #error Change H_PUT_32 1437 #endif 1438 if (bfd_bwrite ((void *) buffer, (bfd_size_type) STRING_SIZE_SIZE, abfd) 1439 != STRING_SIZE_SIZE) 1440 return FALSE; 1441 } 1442 1443 /* Make sure the .debug section was created to be the correct size. 1444 We should create it ourselves on the fly, but we don't because 1445 BFD won't let us write to any section until we know how large all 1446 the sections are. We could still do it by making another pass 1447 over the symbols. FIXME. */ 1448 BFD_ASSERT (debug_string_size == 0 1449 || (debug_string_section != (asection *) NULL 1450 && (BFD_ALIGN (debug_string_size, 1451 1 << debug_string_section->alignment_power) 1452 == debug_string_section->size))); 1453 1454 return TRUE; 1455 } 1456 1457 bfd_boolean 1458 coff_write_linenumbers (bfd *abfd) 1459 { 1460 asection *s; 1461 bfd_size_type linesz; 1462 void * buff; 1463 1464 linesz = bfd_coff_linesz (abfd); 1465 buff = bfd_alloc (abfd, linesz); 1466 if (!buff) 1467 return FALSE; 1468 for (s = abfd->sections; s != (asection *) NULL; s = s->next) 1469 { 1470 if (s->lineno_count) 1471 { 1472 asymbol **q = abfd->outsymbols; 1473 if (bfd_seek (abfd, s->line_filepos, SEEK_SET) != 0) 1474 return FALSE; 1475 /* Find all the linenumbers in this section. */ 1476 while (*q) 1477 { 1478 asymbol *p = *q; 1479 if (p->section->output_section == s) 1480 { 1481 alent *l = 1482 BFD_SEND (bfd_asymbol_bfd (p), _get_lineno, 1483 (bfd_asymbol_bfd (p), p)); 1484 if (l) 1485 { 1486 /* Found a linenumber entry, output. */ 1487 struct internal_lineno out; 1488 1489 memset ((void *) & out, 0, sizeof (out)); 1490 out.l_lnno = 0; 1491 out.l_addr.l_symndx = l->u.offset; 1492 bfd_coff_swap_lineno_out (abfd, &out, buff); 1493 if (bfd_bwrite (buff, (bfd_size_type) linesz, abfd) 1494 != linesz) 1495 return FALSE; 1496 l++; 1497 while (l->line_number) 1498 { 1499 out.l_lnno = l->line_number; 1500 out.l_addr.l_symndx = l->u.offset; 1501 bfd_coff_swap_lineno_out (abfd, &out, buff); 1502 if (bfd_bwrite (buff, (bfd_size_type) linesz, abfd) 1503 != linesz) 1504 return FALSE; 1505 l++; 1506 } 1507 } 1508 } 1509 q++; 1510 } 1511 } 1512 } 1513 bfd_release (abfd, buff); 1514 return TRUE; 1515 } 1516 1517 alent * 1518 coff_get_lineno (bfd *ignore_abfd ATTRIBUTE_UNUSED, asymbol *symbol) 1519 { 1520 return coffsymbol (symbol)->lineno; 1521 } 1522 1523 /* This function transforms the offsets into the symbol table into 1524 pointers to syments. */ 1525 1526 static void 1527 coff_pointerize_aux (bfd *abfd, 1528 combined_entry_type *table_base, 1529 combined_entry_type *symbol, 1530 unsigned int indaux, 1531 combined_entry_type *auxent, 1532 combined_entry_type *table_end) 1533 { 1534 unsigned int type = symbol->u.syment.n_type; 1535 unsigned int n_sclass = symbol->u.syment.n_sclass; 1536 1537 BFD_ASSERT (symbol->is_sym); 1538 if (coff_backend_info (abfd)->_bfd_coff_pointerize_aux_hook) 1539 { 1540 if ((*coff_backend_info (abfd)->_bfd_coff_pointerize_aux_hook) 1541 (abfd, table_base, symbol, indaux, auxent)) 1542 return; 1543 } 1544 1545 /* Don't bother if this is a file or a section. */ 1546 if (n_sclass == C_STAT && type == T_NULL) 1547 return; 1548 if (n_sclass == C_FILE) 1549 return; 1550 1551 BFD_ASSERT (! auxent->is_sym); 1552 /* Otherwise patch up. */ 1553 #define N_TMASK coff_data (abfd)->local_n_tmask 1554 #define N_BTSHFT coff_data (abfd)->local_n_btshft 1555 1556 if ((ISFCN (type) || ISTAG (n_sclass) || n_sclass == C_BLOCK 1557 || n_sclass == C_FCN) 1558 && auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l > 0 1559 && auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l 1560 < (long) obj_raw_syment_count (abfd) 1561 && table_base + auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l 1562 < table_end) 1563 { 1564 auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p = 1565 table_base + auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l; 1566 auxent->fix_end = 1; 1567 } 1568 1569 /* A negative tagndx is meaningless, but the SCO 3.2v4 cc can 1570 generate one, so we must be careful to ignore it. */ 1571 if ((unsigned long) auxent->u.auxent.x_sym.x_tagndx.l 1572 < obj_raw_syment_count (abfd) 1573 && table_base + auxent->u.auxent.x_sym.x_tagndx.l < table_end) 1574 { 1575 auxent->u.auxent.x_sym.x_tagndx.p = 1576 table_base + auxent->u.auxent.x_sym.x_tagndx.l; 1577 auxent->fix_tag = 1; 1578 } 1579 } 1580 1581 /* Allocate space for the ".debug" section, and read it. 1582 We did not read the debug section until now, because 1583 we didn't want to go to the trouble until someone needed it. */ 1584 1585 static char * 1586 build_debug_section (bfd *abfd, asection ** sect_return) 1587 { 1588 char *debug_section; 1589 file_ptr position; 1590 bfd_size_type sec_size; 1591 1592 asection *sect = bfd_get_section_by_name (abfd, ".debug"); 1593 1594 if (!sect) 1595 { 1596 bfd_set_error (bfd_error_no_debug_section); 1597 return NULL; 1598 } 1599 1600 sec_size = sect->size; 1601 debug_section = (char *) bfd_alloc (abfd, sec_size); 1602 if (debug_section == NULL) 1603 return NULL; 1604 1605 /* Seek to the beginning of the `.debug' section and read it. 1606 Save the current position first; it is needed by our caller. 1607 Then read debug section and reset the file pointer. */ 1608 1609 position = bfd_tell (abfd); 1610 if (bfd_seek (abfd, sect->filepos, SEEK_SET) != 0 1611 || bfd_bread (debug_section, sec_size, abfd) != sec_size 1612 || bfd_seek (abfd, position, SEEK_SET) != 0) 1613 return NULL; 1614 1615 * sect_return = sect; 1616 return debug_section; 1617 } 1618 1619 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be 1620 \0-terminated, but will not exceed 'maxlen' characters. The copy *will* 1621 be \0-terminated. */ 1622 1623 static char * 1624 copy_name (bfd *abfd, char *name, size_t maxlen) 1625 { 1626 size_t len; 1627 char *newname; 1628 1629 for (len = 0; len < maxlen; ++len) 1630 if (name[len] == '\0') 1631 break; 1632 1633 if ((newname = (char *) bfd_alloc (abfd, (bfd_size_type) len + 1)) == NULL) 1634 return NULL; 1635 1636 strncpy (newname, name, len); 1637 newname[len] = '\0'; 1638 return newname; 1639 } 1640 1641 /* Read in the external symbols. */ 1642 1643 bfd_boolean 1644 _bfd_coff_get_external_symbols (bfd *abfd) 1645 { 1646 bfd_size_type symesz; 1647 bfd_size_type size; 1648 void * syms; 1649 1650 if (obj_coff_external_syms (abfd) != NULL) 1651 return TRUE; 1652 1653 symesz = bfd_coff_symesz (abfd); 1654 1655 size = obj_raw_syment_count (abfd) * symesz; 1656 if (size == 0) 1657 return TRUE; 1658 /* Check for integer overflow and for unreasonable symbol counts. */ 1659 if (size < obj_raw_syment_count (abfd) 1660 || (bfd_get_file_size (abfd) > 0 1661 && size > bfd_get_file_size (abfd))) 1662 1663 { 1664 _bfd_error_handler (_("%pB: corrupt symbol count: %#" PRIx64 ""), 1665 abfd, (uint64_t) obj_raw_syment_count (abfd)); 1666 return FALSE; 1667 } 1668 1669 syms = bfd_malloc (size); 1670 if (syms == NULL) 1671 { 1672 /* PR 21013: Provide an error message when the alloc fails. */ 1673 _bfd_error_handler (_("%pB: not enough memory to allocate space " 1674 "for %#" PRIx64 " symbols of size %#" PRIx64), 1675 abfd, (uint64_t) obj_raw_syment_count (abfd), 1676 (uint64_t) symesz); 1677 return FALSE; 1678 } 1679 1680 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0 1681 || bfd_bread (syms, size, abfd) != size) 1682 { 1683 if (syms != NULL) 1684 free (syms); 1685 return FALSE; 1686 } 1687 1688 obj_coff_external_syms (abfd) = syms; 1689 return TRUE; 1690 } 1691 1692 /* Read in the external strings. The strings are not loaded until 1693 they are needed. This is because we have no simple way of 1694 detecting a missing string table in an archive. If the strings 1695 are loaded then the STRINGS and STRINGS_LEN fields in the 1696 coff_tdata structure will be set. */ 1697 1698 const char * 1699 _bfd_coff_read_string_table (bfd *abfd) 1700 { 1701 char extstrsize[STRING_SIZE_SIZE]; 1702 bfd_size_type strsize; 1703 char *strings; 1704 file_ptr pos; 1705 1706 if (obj_coff_strings (abfd) != NULL) 1707 return obj_coff_strings (abfd); 1708 1709 if (obj_sym_filepos (abfd) == 0) 1710 { 1711 bfd_set_error (bfd_error_no_symbols); 1712 return NULL; 1713 } 1714 1715 pos = obj_sym_filepos (abfd); 1716 pos += obj_raw_syment_count (abfd) * bfd_coff_symesz (abfd); 1717 if (bfd_seek (abfd, pos, SEEK_SET) != 0) 1718 return NULL; 1719 1720 if (bfd_bread (extstrsize, (bfd_size_type) sizeof extstrsize, abfd) 1721 != sizeof extstrsize) 1722 { 1723 if (bfd_get_error () != bfd_error_file_truncated) 1724 return NULL; 1725 1726 /* There is no string table. */ 1727 strsize = STRING_SIZE_SIZE; 1728 } 1729 else 1730 { 1731 #if STRING_SIZE_SIZE == 4 1732 strsize = H_GET_32 (abfd, extstrsize); 1733 #else 1734 #error Change H_GET_32 1735 #endif 1736 } 1737 1738 if (strsize < STRING_SIZE_SIZE || strsize > bfd_get_file_size (abfd)) 1739 { 1740 _bfd_error_handler 1741 /* xgettext: c-format */ 1742 (_("%pB: bad string table size %" PRIu64), abfd, (uint64_t) strsize); 1743 bfd_set_error (bfd_error_bad_value); 1744 return NULL; 1745 } 1746 1747 strings = (char *) bfd_malloc (strsize + 1); 1748 if (strings == NULL) 1749 return NULL; 1750 1751 /* PR 17521 file: 079-54929-0.004. 1752 A corrupt file could contain an index that points into the first 1753 STRING_SIZE_SIZE bytes of the string table, so make sure that 1754 they are zero. */ 1755 memset (strings, 0, STRING_SIZE_SIZE); 1756 1757 if (bfd_bread (strings + STRING_SIZE_SIZE, strsize - STRING_SIZE_SIZE, abfd) 1758 != strsize - STRING_SIZE_SIZE) 1759 { 1760 free (strings); 1761 return NULL; 1762 } 1763 1764 obj_coff_strings (abfd) = strings; 1765 obj_coff_strings_len (abfd) = strsize; 1766 /* Terminate the string table, just in case. */ 1767 strings[strsize] = 0; 1768 return strings; 1769 } 1770 1771 /* Free up the external symbols and strings read from a COFF file. */ 1772 1773 bfd_boolean 1774 _bfd_coff_free_symbols (bfd *abfd) 1775 { 1776 if (! bfd_family_coff (abfd)) 1777 return FALSE; 1778 1779 if (obj_coff_external_syms (abfd) != NULL 1780 && ! obj_coff_keep_syms (abfd)) 1781 { 1782 free (obj_coff_external_syms (abfd)); 1783 obj_coff_external_syms (abfd) = NULL; 1784 } 1785 1786 if (obj_coff_strings (abfd) != NULL 1787 && ! obj_coff_keep_strings (abfd)) 1788 { 1789 free (obj_coff_strings (abfd)); 1790 obj_coff_strings (abfd) = NULL; 1791 obj_coff_strings_len (abfd) = 0; 1792 } 1793 1794 return TRUE; 1795 } 1796 1797 /* Read a symbol table into freshly bfd_allocated memory, swap it, and 1798 knit the symbol names into a normalized form. By normalized here I 1799 mean that all symbols have an n_offset pointer that points to a null- 1800 terminated string. */ 1801 1802 combined_entry_type * 1803 coff_get_normalized_symtab (bfd *abfd) 1804 { 1805 combined_entry_type *internal; 1806 combined_entry_type *internal_ptr; 1807 combined_entry_type *symbol_ptr; 1808 combined_entry_type *internal_end; 1809 size_t symesz; 1810 char *raw_src; 1811 char *raw_end; 1812 const char *string_table = NULL; 1813 asection * debug_sec = NULL; 1814 char *debug_sec_data = NULL; 1815 bfd_size_type size; 1816 1817 if (obj_raw_syments (abfd) != NULL) 1818 return obj_raw_syments (abfd); 1819 1820 if (! _bfd_coff_get_external_symbols (abfd)) 1821 return NULL; 1822 1823 size = obj_raw_syment_count (abfd); 1824 /* Check for integer overflow. */ 1825 if (size > (bfd_size_type) -1 / sizeof (combined_entry_type)) 1826 return NULL; 1827 size *= sizeof (combined_entry_type); 1828 internal = (combined_entry_type *) bfd_zalloc (abfd, size); 1829 if (internal == NULL && size != 0) 1830 return NULL; 1831 internal_end = internal + obj_raw_syment_count (abfd); 1832 1833 raw_src = (char *) obj_coff_external_syms (abfd); 1834 1835 /* Mark the end of the symbols. */ 1836 symesz = bfd_coff_symesz (abfd); 1837 raw_end = (char *) raw_src + obj_raw_syment_count (abfd) * symesz; 1838 1839 /* FIXME SOMEDAY. A string table size of zero is very weird, but 1840 probably possible. If one shows up, it will probably kill us. */ 1841 1842 /* Swap all the raw entries. */ 1843 for (internal_ptr = internal; 1844 raw_src < raw_end; 1845 raw_src += symesz, internal_ptr++) 1846 { 1847 unsigned int i; 1848 1849 bfd_coff_swap_sym_in (abfd, (void *) raw_src, 1850 (void *) & internal_ptr->u.syment); 1851 symbol_ptr = internal_ptr; 1852 internal_ptr->is_sym = TRUE; 1853 1854 for (i = 0; 1855 i < symbol_ptr->u.syment.n_numaux; 1856 i++) 1857 { 1858 internal_ptr++; 1859 raw_src += symesz; 1860 1861 /* PR 17512: Prevent buffer overrun. */ 1862 if (raw_src >= raw_end || internal_ptr >= internal_end) 1863 { 1864 bfd_release (abfd, internal); 1865 return NULL; 1866 } 1867 1868 bfd_coff_swap_aux_in (abfd, (void *) raw_src, 1869 symbol_ptr->u.syment.n_type, 1870 symbol_ptr->u.syment.n_sclass, 1871 (int) i, symbol_ptr->u.syment.n_numaux, 1872 &(internal_ptr->u.auxent)); 1873 1874 internal_ptr->is_sym = FALSE; 1875 coff_pointerize_aux (abfd, internal, symbol_ptr, i, 1876 internal_ptr, internal_end); 1877 } 1878 } 1879 1880 /* Free the raw symbols, but not the strings (if we have them). */ 1881 obj_coff_keep_strings (abfd) = TRUE; 1882 if (! _bfd_coff_free_symbols (abfd)) 1883 return NULL; 1884 1885 for (internal_ptr = internal; internal_ptr < internal_end; 1886 internal_ptr++) 1887 { 1888 BFD_ASSERT (internal_ptr->is_sym); 1889 1890 if (internal_ptr->u.syment.n_sclass == C_FILE 1891 && internal_ptr->u.syment.n_numaux > 0) 1892 { 1893 combined_entry_type * aux = internal_ptr + 1; 1894 1895 /* Make a file symbol point to the name in the auxent, since 1896 the text ".file" is redundant. */ 1897 BFD_ASSERT (! aux->is_sym); 1898 1899 if (aux->u.auxent.x_file.x_n.x_zeroes == 0) 1900 { 1901 /* The filename is a long one, point into the string table. */ 1902 if (string_table == NULL) 1903 { 1904 string_table = _bfd_coff_read_string_table (abfd); 1905 if (string_table == NULL) 1906 return NULL; 1907 } 1908 1909 if ((bfd_size_type)(aux->u.auxent.x_file.x_n.x_offset) 1910 >= obj_coff_strings_len (abfd)) 1911 internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) _("<corrupt>"); 1912 else 1913 internal_ptr->u.syment._n._n_n._n_offset = 1914 (bfd_hostptr_t) (string_table + (aux->u.auxent.x_file.x_n.x_offset)); 1915 } 1916 else 1917 { 1918 /* Ordinary short filename, put into memory anyway. The 1919 Microsoft PE tools sometimes store a filename in 1920 multiple AUX entries. */ 1921 if (internal_ptr->u.syment.n_numaux > 1 1922 && coff_data (abfd)->pe) 1923 internal_ptr->u.syment._n._n_n._n_offset = 1924 (bfd_hostptr_t) 1925 copy_name (abfd, 1926 aux->u.auxent.x_file.x_fname, 1927 internal_ptr->u.syment.n_numaux * symesz); 1928 else 1929 internal_ptr->u.syment._n._n_n._n_offset = 1930 ((bfd_hostptr_t) 1931 copy_name (abfd, 1932 aux->u.auxent.x_file.x_fname, 1933 (size_t) bfd_coff_filnmlen (abfd))); 1934 } 1935 } 1936 else 1937 { 1938 if (internal_ptr->u.syment._n._n_n._n_zeroes != 0) 1939 { 1940 /* This is a "short" name. Make it long. */ 1941 size_t i; 1942 char *newstring; 1943 1944 /* Find the length of this string without walking into memory 1945 that isn't ours. */ 1946 for (i = 0; i < 8; ++i) 1947 if (internal_ptr->u.syment._n._n_name[i] == '\0') 1948 break; 1949 1950 newstring = (char *) bfd_zalloc (abfd, (bfd_size_type) (i + 1)); 1951 if (newstring == NULL) 1952 return NULL; 1953 strncpy (newstring, internal_ptr->u.syment._n._n_name, i); 1954 internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) newstring; 1955 internal_ptr->u.syment._n._n_n._n_zeroes = 0; 1956 } 1957 else if (internal_ptr->u.syment._n._n_n._n_offset == 0) 1958 internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) ""; 1959 else if (!bfd_coff_symname_in_debug (abfd, &internal_ptr->u.syment)) 1960 { 1961 /* Long name already. Point symbol at the string in the 1962 table. */ 1963 if (string_table == NULL) 1964 { 1965 string_table = _bfd_coff_read_string_table (abfd); 1966 if (string_table == NULL) 1967 return NULL; 1968 } 1969 if (internal_ptr->u.syment._n._n_n._n_offset >= obj_coff_strings_len (abfd) 1970 || string_table + internal_ptr->u.syment._n._n_n._n_offset < string_table) 1971 internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) _("<corrupt>"); 1972 else 1973 internal_ptr->u.syment._n._n_n._n_offset = 1974 ((bfd_hostptr_t) 1975 (string_table 1976 + internal_ptr->u.syment._n._n_n._n_offset)); 1977 } 1978 else 1979 { 1980 /* Long name in debug section. Very similar. */ 1981 if (debug_sec_data == NULL) 1982 debug_sec_data = build_debug_section (abfd, & debug_sec); 1983 if (debug_sec_data != NULL) 1984 { 1985 BFD_ASSERT (debug_sec != NULL); 1986 /* PR binutils/17512: Catch out of range offsets into the debug data. */ 1987 if (internal_ptr->u.syment._n._n_n._n_offset > debug_sec->size 1988 || debug_sec_data + internal_ptr->u.syment._n._n_n._n_offset < debug_sec_data) 1989 internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) _("<corrupt>"); 1990 else 1991 internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) 1992 (debug_sec_data + internal_ptr->u.syment._n._n_n._n_offset); 1993 } 1994 else 1995 internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) ""; 1996 } 1997 } 1998 internal_ptr += internal_ptr->u.syment.n_numaux; 1999 } 2000 2001 obj_raw_syments (abfd) = internal; 2002 BFD_ASSERT (obj_raw_syment_count (abfd) 2003 == (unsigned int) (internal_ptr - internal)); 2004 2005 return internal; 2006 } 2007 2008 long 2009 coff_get_reloc_upper_bound (bfd *abfd, sec_ptr asect) 2010 { 2011 if (bfd_get_format (abfd) != bfd_object) 2012 { 2013 bfd_set_error (bfd_error_invalid_operation); 2014 return -1; 2015 } 2016 #if SIZEOF_LONG == SIZEOF_INT 2017 if (asect->reloc_count >= LONG_MAX / sizeof (arelent *)) 2018 { 2019 bfd_set_error (bfd_error_file_too_big); 2020 return -1; 2021 } 2022 #endif 2023 return (asect->reloc_count + 1) * sizeof (arelent *); 2024 } 2025 2026 asymbol * 2027 coff_make_empty_symbol (bfd *abfd) 2028 { 2029 bfd_size_type amt = sizeof (coff_symbol_type); 2030 coff_symbol_type *new_symbol = (coff_symbol_type *) bfd_zalloc (abfd, amt); 2031 2032 if (new_symbol == NULL) 2033 return NULL; 2034 new_symbol->symbol.section = 0; 2035 new_symbol->native = NULL; 2036 new_symbol->lineno = NULL; 2037 new_symbol->done_lineno = FALSE; 2038 new_symbol->symbol.the_bfd = abfd; 2039 2040 return & new_symbol->symbol; 2041 } 2042 2043 /* Make a debugging symbol. */ 2044 2045 asymbol * 2046 coff_bfd_make_debug_symbol (bfd *abfd, 2047 void * ptr ATTRIBUTE_UNUSED, 2048 unsigned long sz ATTRIBUTE_UNUSED) 2049 { 2050 bfd_size_type amt = sizeof (coff_symbol_type); 2051 coff_symbol_type *new_symbol = (coff_symbol_type *) bfd_alloc (abfd, amt); 2052 2053 if (new_symbol == NULL) 2054 return NULL; 2055 /* @@ The 10 is a guess at a plausible maximum number of aux entries 2056 (but shouldn't be a constant). */ 2057 amt = sizeof (combined_entry_type) * 10; 2058 new_symbol->native = (combined_entry_type *) bfd_zalloc (abfd, amt); 2059 if (!new_symbol->native) 2060 return NULL; 2061 new_symbol->native->is_sym = TRUE; 2062 new_symbol->symbol.section = bfd_abs_section_ptr; 2063 new_symbol->symbol.flags = BSF_DEBUGGING; 2064 new_symbol->lineno = NULL; 2065 new_symbol->done_lineno = FALSE; 2066 new_symbol->symbol.the_bfd = abfd; 2067 2068 return & new_symbol->symbol; 2069 } 2070 2071 void 2072 coff_get_symbol_info (bfd *abfd, asymbol *symbol, symbol_info *ret) 2073 { 2074 bfd_symbol_info (symbol, ret); 2075 2076 if (coffsymbol (symbol)->native != NULL 2077 && coffsymbol (symbol)->native->fix_value 2078 && coffsymbol (symbol)->native->is_sym) 2079 ret->value = coffsymbol (symbol)->native->u.syment.n_value - 2080 (bfd_hostptr_t) obj_raw_syments (abfd); 2081 } 2082 2083 /* Print out information about COFF symbol. */ 2084 2085 void 2086 coff_print_symbol (bfd *abfd, 2087 void * filep, 2088 asymbol *symbol, 2089 bfd_print_symbol_type how) 2090 { 2091 FILE * file = (FILE *) filep; 2092 2093 switch (how) 2094 { 2095 case bfd_print_symbol_name: 2096 fprintf (file, "%s", symbol->name); 2097 break; 2098 2099 case bfd_print_symbol_more: 2100 fprintf (file, "coff %s %s", 2101 coffsymbol (symbol)->native ? "n" : "g", 2102 coffsymbol (symbol)->lineno ? "l" : " "); 2103 break; 2104 2105 case bfd_print_symbol_all: 2106 if (coffsymbol (symbol)->native) 2107 { 2108 bfd_vma val; 2109 unsigned int aux; 2110 combined_entry_type *combined = coffsymbol (symbol)->native; 2111 combined_entry_type *root = obj_raw_syments (abfd); 2112 struct lineno_cache_entry *l = coffsymbol (symbol)->lineno; 2113 2114 fprintf (file, "[%3ld]", (long) (combined - root)); 2115 2116 /* PR 17512: file: 079-33786-0.001:0.1. */ 2117 if (combined < obj_raw_syments (abfd) 2118 || combined >= obj_raw_syments (abfd) + obj_raw_syment_count (abfd)) 2119 { 2120 fprintf (file, _("<corrupt info> %s"), symbol->name); 2121 break; 2122 } 2123 2124 BFD_ASSERT (combined->is_sym); 2125 if (! combined->fix_value) 2126 val = (bfd_vma) combined->u.syment.n_value; 2127 else 2128 val = combined->u.syment.n_value - (bfd_hostptr_t) root; 2129 2130 fprintf (file, "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x", 2131 combined->u.syment.n_scnum, 2132 combined->u.syment.n_flags, 2133 combined->u.syment.n_type, 2134 combined->u.syment.n_sclass, 2135 combined->u.syment.n_numaux); 2136 bfd_fprintf_vma (abfd, file, val); 2137 fprintf (file, " %s", symbol->name); 2138 2139 for (aux = 0; aux < combined->u.syment.n_numaux; aux++) 2140 { 2141 combined_entry_type *auxp = combined + aux + 1; 2142 long tagndx; 2143 2144 BFD_ASSERT (! auxp->is_sym); 2145 if (auxp->fix_tag) 2146 tagndx = auxp->u.auxent.x_sym.x_tagndx.p - root; 2147 else 2148 tagndx = auxp->u.auxent.x_sym.x_tagndx.l; 2149 2150 fprintf (file, "\n"); 2151 2152 if (bfd_coff_print_aux (abfd, file, root, combined, auxp, aux)) 2153 continue; 2154 2155 switch (combined->u.syment.n_sclass) 2156 { 2157 case C_FILE: 2158 fprintf (file, "File "); 2159 break; 2160 2161 case C_STAT: 2162 if (combined->u.syment.n_type == T_NULL) 2163 /* Probably a section symbol ? */ 2164 { 2165 fprintf (file, "AUX scnlen 0x%lx nreloc %d nlnno %d", 2166 (unsigned long) auxp->u.auxent.x_scn.x_scnlen, 2167 auxp->u.auxent.x_scn.x_nreloc, 2168 auxp->u.auxent.x_scn.x_nlinno); 2169 if (auxp->u.auxent.x_scn.x_checksum != 0 2170 || auxp->u.auxent.x_scn.x_associated != 0 2171 || auxp->u.auxent.x_scn.x_comdat != 0) 2172 fprintf (file, " checksum 0x%lx assoc %d comdat %d", 2173 auxp->u.auxent.x_scn.x_checksum, 2174 auxp->u.auxent.x_scn.x_associated, 2175 auxp->u.auxent.x_scn.x_comdat); 2176 break; 2177 } 2178 /* Fall through. */ 2179 case C_EXT: 2180 case C_AIX_WEAKEXT: 2181 if (ISFCN (combined->u.syment.n_type)) 2182 { 2183 long next, llnos; 2184 2185 if (auxp->fix_end) 2186 next = (auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p 2187 - root); 2188 else 2189 next = auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l; 2190 llnos = auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_lnnoptr; 2191 fprintf (file, 2192 "AUX tagndx %ld ttlsiz 0x%lx lnnos %ld next %ld", 2193 tagndx, 2194 (unsigned long) auxp->u.auxent.x_sym.x_misc.x_fsize, 2195 llnos, next); 2196 break; 2197 } 2198 /* Fall through. */ 2199 default: 2200 fprintf (file, "AUX lnno %d size 0x%x tagndx %ld", 2201 auxp->u.auxent.x_sym.x_misc.x_lnsz.x_lnno, 2202 auxp->u.auxent.x_sym.x_misc.x_lnsz.x_size, 2203 tagndx); 2204 if (auxp->fix_end) 2205 fprintf (file, " endndx %ld", 2206 ((long) 2207 (auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p 2208 - root))); 2209 break; 2210 } 2211 } 2212 2213 if (l) 2214 { 2215 fprintf (file, "\n%s :", l->u.sym->name); 2216 l++; 2217 while (l->line_number) 2218 { 2219 if (l->line_number > 0) 2220 { 2221 fprintf (file, "\n%4d : ", l->line_number); 2222 bfd_fprintf_vma (abfd, file, l->u.offset + symbol->section->vma); 2223 } 2224 l++; 2225 } 2226 } 2227 } 2228 else 2229 { 2230 bfd_print_symbol_vandf (abfd, (void *) file, symbol); 2231 fprintf (file, " %-5s %s %s %s", 2232 symbol->section->name, 2233 coffsymbol (symbol)->native ? "n" : "g", 2234 coffsymbol (symbol)->lineno ? "l" : " ", 2235 symbol->name); 2236 } 2237 } 2238 } 2239 2240 /* Return whether a symbol name implies a local symbol. In COFF, 2241 local symbols generally start with ``.L''. Most targets use this 2242 function for the is_local_label_name entry point, but some may 2243 override it. */ 2244 2245 bfd_boolean 2246 _bfd_coff_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED, 2247 const char *name) 2248 { 2249 return name[0] == '.' && name[1] == 'L'; 2250 } 2251 2252 /* Provided a BFD, a section and an offset (in bytes, not octets) into the 2253 section, calculate and return the name of the source file and the line 2254 nearest to the wanted location. */ 2255 2256 bfd_boolean 2257 coff_find_nearest_line_with_names (bfd *abfd, 2258 asymbol **symbols, 2259 asection *section, 2260 bfd_vma offset, 2261 const char **filename_ptr, 2262 const char **functionname_ptr, 2263 unsigned int *line_ptr, 2264 const struct dwarf_debug_section *debug_sections) 2265 { 2266 bfd_boolean found; 2267 unsigned int i; 2268 unsigned int line_base; 2269 coff_data_type *cof = coff_data (abfd); 2270 /* Run through the raw syments if available. */ 2271 combined_entry_type *p; 2272 combined_entry_type *pend; 2273 alent *l; 2274 struct coff_section_tdata *sec_data; 2275 bfd_size_type amt; 2276 2277 /* Before looking through the symbol table, try to use a .stab 2278 section to find the information. */ 2279 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset, 2280 &found, filename_ptr, 2281 functionname_ptr, line_ptr, 2282 &coff_data(abfd)->line_info)) 2283 return FALSE; 2284 2285 if (found) 2286 return TRUE; 2287 2288 /* Also try examining DWARF2 debugging information. */ 2289 if (_bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section, offset, 2290 filename_ptr, functionname_ptr, 2291 line_ptr, NULL, debug_sections, 2292 &coff_data(abfd)->dwarf2_find_line_info)) 2293 return TRUE; 2294 2295 sec_data = coff_section_data (abfd, section); 2296 2297 /* If the DWARF lookup failed, but there is DWARF information available 2298 then the problem might be that the file has been rebased. This tool 2299 changes the VMAs of all the sections, but it does not update the DWARF 2300 information. So try again, using a bias against the address sought. */ 2301 if (coff_data (abfd)->dwarf2_find_line_info != NULL) 2302 { 2303 bfd_signed_vma bias = 0; 2304 2305 /* Create a cache of the result for the next call. */ 2306 if (sec_data == NULL && section->owner == abfd) 2307 { 2308 amt = sizeof (struct coff_section_tdata); 2309 section->used_by_bfd = bfd_zalloc (abfd, amt); 2310 sec_data = (struct coff_section_tdata *) section->used_by_bfd; 2311 } 2312 2313 if (sec_data != NULL && sec_data->saved_bias) 2314 bias = sec_data->saved_bias; 2315 else if (symbols) 2316 { 2317 bias = _bfd_dwarf2_find_symbol_bias (symbols, 2318 & coff_data (abfd)->dwarf2_find_line_info); 2319 2320 if (sec_data) 2321 { 2322 sec_data->saved_bias = TRUE; 2323 sec_data->bias = bias; 2324 } 2325 } 2326 2327 if (bias 2328 && _bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section, 2329 offset + bias, 2330 filename_ptr, functionname_ptr, 2331 line_ptr, NULL, debug_sections, 2332 &coff_data(abfd)->dwarf2_find_line_info)) 2333 return TRUE; 2334 } 2335 2336 *filename_ptr = 0; 2337 *functionname_ptr = 0; 2338 *line_ptr = 0; 2339 2340 /* Don't try and find line numbers in a non coff file. */ 2341 if (!bfd_family_coff (abfd)) 2342 return FALSE; 2343 2344 if (cof == NULL) 2345 return FALSE; 2346 2347 /* Find the first C_FILE symbol. */ 2348 p = cof->raw_syments; 2349 if (!p) 2350 return FALSE; 2351 2352 pend = p + cof->raw_syment_count; 2353 while (p < pend) 2354 { 2355 BFD_ASSERT (p->is_sym); 2356 if (p->u.syment.n_sclass == C_FILE) 2357 break; 2358 p += 1 + p->u.syment.n_numaux; 2359 } 2360 2361 if (p < pend) 2362 { 2363 bfd_vma sec_vma; 2364 bfd_vma maxdiff; 2365 2366 /* Look through the C_FILE symbols to find the best one. */ 2367 sec_vma = bfd_section_vma (section); 2368 *filename_ptr = (char *) p->u.syment._n._n_n._n_offset; 2369 maxdiff = (bfd_vma) 0 - (bfd_vma) 1; 2370 while (1) 2371 { 2372 bfd_vma file_addr; 2373 combined_entry_type *p2; 2374 2375 for (p2 = p + 1 + p->u.syment.n_numaux; 2376 p2 < pend; 2377 p2 += 1 + p2->u.syment.n_numaux) 2378 { 2379 BFD_ASSERT (p2->is_sym); 2380 if (p2->u.syment.n_scnum > 0 2381 && (section 2382 == coff_section_from_bfd_index (abfd, 2383 p2->u.syment.n_scnum))) 2384 break; 2385 if (p2->u.syment.n_sclass == C_FILE) 2386 { 2387 p2 = pend; 2388 break; 2389 } 2390 } 2391 if (p2 >= pend) 2392 break; 2393 2394 file_addr = (bfd_vma) p2->u.syment.n_value; 2395 /* PR 11512: Include the section address of the function name symbol. */ 2396 if (p2->u.syment.n_scnum > 0) 2397 file_addr += coff_section_from_bfd_index (abfd, 2398 p2->u.syment.n_scnum)->vma; 2399 /* We use <= MAXDIFF here so that if we get a zero length 2400 file, we actually use the next file entry. */ 2401 if (p2 < pend 2402 && offset + sec_vma >= file_addr 2403 && offset + sec_vma - file_addr <= maxdiff) 2404 { 2405 *filename_ptr = (char *) p->u.syment._n._n_n._n_offset; 2406 maxdiff = offset + sec_vma - p2->u.syment.n_value; 2407 } 2408 2409 if (p->u.syment.n_value >= cof->raw_syment_count) 2410 break; 2411 2412 /* Avoid endless loops on erroneous files by ensuring that 2413 we always move forward in the file. */ 2414 if (p >= cof->raw_syments + p->u.syment.n_value) 2415 break; 2416 2417 p = cof->raw_syments + p->u.syment.n_value; 2418 if (!p->is_sym || p->u.syment.n_sclass != C_FILE) 2419 break; 2420 } 2421 } 2422 2423 if (section->lineno_count == 0) 2424 { 2425 *functionname_ptr = NULL; 2426 *line_ptr = 0; 2427 return TRUE; 2428 } 2429 2430 /* Now wander though the raw linenumbers of the section. 2431 If we have been called on this section before, and the offset 2432 we want is further down then we can prime the lookup loop. */ 2433 if (sec_data != NULL 2434 && sec_data->i > 0 2435 && offset >= sec_data->offset) 2436 { 2437 i = sec_data->i; 2438 *functionname_ptr = sec_data->function; 2439 line_base = sec_data->line_base; 2440 } 2441 else 2442 { 2443 i = 0; 2444 line_base = 0; 2445 } 2446 2447 if (section->lineno != NULL) 2448 { 2449 bfd_vma last_value = 0; 2450 2451 l = §ion->lineno[i]; 2452 2453 for (; i < section->lineno_count; i++) 2454 { 2455 if (l->line_number == 0) 2456 { 2457 /* Get the symbol this line number points at. */ 2458 coff_symbol_type *coff = (coff_symbol_type *) (l->u.sym); 2459 if (coff->symbol.value > offset) 2460 break; 2461 2462 *functionname_ptr = coff->symbol.name; 2463 last_value = coff->symbol.value; 2464 if (coff->native) 2465 { 2466 combined_entry_type *s = coff->native; 2467 2468 BFD_ASSERT (s->is_sym); 2469 s = s + 1 + s->u.syment.n_numaux; 2470 2471 /* In XCOFF a debugging symbol can follow the 2472 function symbol. */ 2473 if (s->u.syment.n_scnum == N_DEBUG) 2474 s = s + 1 + s->u.syment.n_numaux; 2475 2476 /* S should now point to the .bf of the function. */ 2477 if (s->u.syment.n_numaux) 2478 { 2479 /* The linenumber is stored in the auxent. */ 2480 union internal_auxent *a = &((s + 1)->u.auxent); 2481 2482 line_base = a->x_sym.x_misc.x_lnsz.x_lnno; 2483 *line_ptr = line_base; 2484 } 2485 } 2486 } 2487 else 2488 { 2489 if (l->u.offset > offset) 2490 break; 2491 *line_ptr = l->line_number + line_base - 1; 2492 } 2493 l++; 2494 } 2495 2496 /* If we fell off the end of the loop, then assume that this 2497 symbol has no line number info. Otherwise, symbols with no 2498 line number info get reported with the line number of the 2499 last line of the last symbol which does have line number 2500 info. We use 0x100 as a slop to account for cases where the 2501 last line has executable code. */ 2502 if (i >= section->lineno_count 2503 && last_value != 0 2504 && offset - last_value > 0x100) 2505 { 2506 *functionname_ptr = NULL; 2507 *line_ptr = 0; 2508 } 2509 } 2510 2511 /* Cache the results for the next call. */ 2512 if (sec_data == NULL && section->owner == abfd) 2513 { 2514 amt = sizeof (struct coff_section_tdata); 2515 section->used_by_bfd = bfd_zalloc (abfd, amt); 2516 sec_data = (struct coff_section_tdata *) section->used_by_bfd; 2517 } 2518 2519 if (sec_data != NULL) 2520 { 2521 sec_data->offset = offset; 2522 sec_data->i = i - 1; 2523 sec_data->function = *functionname_ptr; 2524 sec_data->line_base = line_base; 2525 } 2526 2527 return TRUE; 2528 } 2529 2530 bfd_boolean 2531 coff_find_nearest_line (bfd *abfd, 2532 asymbol **symbols, 2533 asection *section, 2534 bfd_vma offset, 2535 const char **filename_ptr, 2536 const char **functionname_ptr, 2537 unsigned int *line_ptr, 2538 unsigned int *discriminator_ptr) 2539 { 2540 if (discriminator_ptr) 2541 *discriminator_ptr = 0; 2542 return coff_find_nearest_line_with_names (abfd, symbols, section, offset, 2543 filename_ptr, functionname_ptr, 2544 line_ptr, dwarf_debug_sections); 2545 } 2546 2547 bfd_boolean 2548 coff_find_inliner_info (bfd *abfd, 2549 const char **filename_ptr, 2550 const char **functionname_ptr, 2551 unsigned int *line_ptr) 2552 { 2553 bfd_boolean found; 2554 2555 found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr, 2556 functionname_ptr, line_ptr, 2557 &coff_data(abfd)->dwarf2_find_line_info); 2558 return (found); 2559 } 2560 2561 int 2562 coff_sizeof_headers (bfd *abfd, struct bfd_link_info *info) 2563 { 2564 size_t size; 2565 2566 if (!bfd_link_relocatable (info)) 2567 size = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd); 2568 else 2569 size = bfd_coff_filhsz (abfd); 2570 2571 size += abfd->section_count * bfd_coff_scnhsz (abfd); 2572 return size; 2573 } 2574 2575 /* Change the class of a coff symbol held by BFD. */ 2576 2577 bfd_boolean 2578 bfd_coff_set_symbol_class (bfd * abfd, 2579 asymbol * symbol, 2580 unsigned int symbol_class) 2581 { 2582 coff_symbol_type * csym; 2583 2584 csym = coff_symbol_from (symbol); 2585 if (csym == NULL) 2586 { 2587 bfd_set_error (bfd_error_invalid_operation); 2588 return FALSE; 2589 } 2590 else if (csym->native == NULL) 2591 { 2592 /* This is an alien symbol which no native coff backend data. 2593 We cheat here by creating a fake native entry for it and 2594 then filling in the class. This code is based on that in 2595 coff_write_alien_symbol(). */ 2596 2597 combined_entry_type * native; 2598 bfd_size_type amt = sizeof (* native); 2599 2600 native = (combined_entry_type *) bfd_zalloc (abfd, amt); 2601 if (native == NULL) 2602 return FALSE; 2603 2604 native->is_sym = TRUE; 2605 native->u.syment.n_type = T_NULL; 2606 native->u.syment.n_sclass = symbol_class; 2607 2608 if (bfd_is_und_section (symbol->section)) 2609 { 2610 native->u.syment.n_scnum = N_UNDEF; 2611 native->u.syment.n_value = symbol->value; 2612 } 2613 else if (bfd_is_com_section (symbol->section)) 2614 { 2615 native->u.syment.n_scnum = N_UNDEF; 2616 native->u.syment.n_value = symbol->value; 2617 } 2618 else 2619 { 2620 native->u.syment.n_scnum = 2621 symbol->section->output_section->target_index; 2622 native->u.syment.n_value = (symbol->value 2623 + symbol->section->output_offset); 2624 if (! obj_pe (abfd)) 2625 native->u.syment.n_value += symbol->section->output_section->vma; 2626 2627 /* Copy the any flags from the file header into the symbol. 2628 FIXME: Why? */ 2629 native->u.syment.n_flags = bfd_asymbol_bfd (& csym->symbol)->flags; 2630 } 2631 2632 csym->native = native; 2633 } 2634 else 2635 csym->native->u.syment.n_sclass = symbol_class; 2636 2637 return TRUE; 2638 } 2639 2640 bfd_boolean 2641 _bfd_coff_section_already_linked (bfd *abfd, 2642 asection *sec, 2643 struct bfd_link_info *info) 2644 { 2645 flagword flags; 2646 const char *name, *key; 2647 struct bfd_section_already_linked *l; 2648 struct bfd_section_already_linked_hash_entry *already_linked_list; 2649 struct coff_comdat_info *s_comdat; 2650 2651 if (sec->output_section == bfd_abs_section_ptr) 2652 return FALSE; 2653 2654 flags = sec->flags; 2655 if ((flags & SEC_LINK_ONCE) == 0) 2656 return FALSE; 2657 2658 /* The COFF backend linker doesn't support group sections. */ 2659 if ((flags & SEC_GROUP) != 0) 2660 return FALSE; 2661 2662 name = bfd_section_name (sec); 2663 s_comdat = bfd_coff_get_comdat_section (abfd, sec); 2664 2665 if (s_comdat != NULL) 2666 key = s_comdat->name; 2667 else 2668 { 2669 if (CONST_STRNEQ (name, ".gnu.linkonce.") 2670 && (key = strchr (name + sizeof (".gnu.linkonce.") - 1, '.')) != NULL) 2671 key++; 2672 else 2673 /* FIXME: gcc as of 2011-09 emits sections like .text$<key>, 2674 .xdata$<key> and .pdata$<key> only the first of which has a 2675 comdat key. Should these all match the LTO IR key? */ 2676 key = name; 2677 } 2678 2679 already_linked_list = bfd_section_already_linked_table_lookup (key); 2680 2681 for (l = already_linked_list->entry; l != NULL; l = l->next) 2682 { 2683 struct coff_comdat_info *l_comdat; 2684 2685 l_comdat = bfd_coff_get_comdat_section (l->sec->owner, l->sec); 2686 2687 /* The section names must match, and both sections must be 2688 comdat and have the same comdat name, or both sections must 2689 be non-comdat. LTO IR plugin sections are an exception. They 2690 are always named .gnu.linkonce.t.<key> (<key> is some string) 2691 and match any comdat section with comdat name of <key>, and 2692 any linkonce section with the same suffix, ie. 2693 .gnu.linkonce.*.<key>. */ 2694 if (((s_comdat != NULL) == (l_comdat != NULL) 2695 && strcmp (name, l->sec->name) == 0) 2696 || (l->sec->owner->flags & BFD_PLUGIN) != 0) 2697 { 2698 /* The section has already been linked. See if we should 2699 issue a warning. */ 2700 return _bfd_handle_already_linked (sec, l, info); 2701 } 2702 } 2703 2704 /* This is the first section with this name. Record it. */ 2705 if (!bfd_section_already_linked_table_insert (already_linked_list, sec)) 2706 info->callbacks->einfo (_("%F%P: already_linked_table: %E\n")); 2707 return FALSE; 2708 } 2709 2710 /* Initialize COOKIE for input bfd ABFD. */ 2711 2712 static bfd_boolean 2713 init_reloc_cookie (struct coff_reloc_cookie *cookie, 2714 struct bfd_link_info *info ATTRIBUTE_UNUSED, 2715 bfd *abfd) 2716 { 2717 /* Sometimes the symbol table does not yet have been loaded here. */ 2718 bfd_coff_slurp_symbol_table (abfd); 2719 2720 cookie->abfd = abfd; 2721 cookie->sym_hashes = obj_coff_sym_hashes (abfd); 2722 2723 cookie->symbols = obj_symbols (abfd); 2724 2725 return TRUE; 2726 } 2727 2728 /* Free the memory allocated by init_reloc_cookie, if appropriate. */ 2729 2730 static void 2731 fini_reloc_cookie (struct coff_reloc_cookie *cookie ATTRIBUTE_UNUSED, 2732 bfd *abfd ATTRIBUTE_UNUSED) 2733 { 2734 /* Nothing to do. */ 2735 } 2736 2737 /* Initialize the relocation information in COOKIE for input section SEC 2738 of input bfd ABFD. */ 2739 2740 static bfd_boolean 2741 init_reloc_cookie_rels (struct coff_reloc_cookie *cookie, 2742 struct bfd_link_info *info ATTRIBUTE_UNUSED, 2743 bfd *abfd, 2744 asection *sec) 2745 { 2746 if (sec->reloc_count == 0) 2747 { 2748 cookie->rels = NULL; 2749 cookie->relend = NULL; 2750 cookie->rel = NULL; 2751 return TRUE; 2752 } 2753 2754 cookie->rels = _bfd_coff_read_internal_relocs (abfd, sec, FALSE, NULL, 0, NULL); 2755 2756 if (cookie->rels == NULL) 2757 return FALSE; 2758 2759 cookie->rel = cookie->rels; 2760 cookie->relend = (cookie->rels + sec->reloc_count); 2761 return TRUE; 2762 } 2763 2764 /* Free the memory allocated by init_reloc_cookie_rels, 2765 if appropriate. */ 2766 2767 static void 2768 fini_reloc_cookie_rels (struct coff_reloc_cookie *cookie, 2769 asection *sec) 2770 { 2771 if (cookie->rels 2772 /* PR 20401. The relocs may not have been cached, so check first. 2773 If the relocs were loaded by init_reloc_cookie_rels() then this 2774 will be the case. FIXME: Would performance be improved if the 2775 relocs *were* cached ? */ 2776 && coff_section_data (NULL, sec) 2777 && coff_section_data (NULL, sec)->relocs != cookie->rels) 2778 free (cookie->rels); 2779 } 2780 2781 /* Initialize the whole of COOKIE for input section SEC. */ 2782 2783 static bfd_boolean 2784 init_reloc_cookie_for_section (struct coff_reloc_cookie *cookie, 2785 struct bfd_link_info *info, 2786 asection *sec) 2787 { 2788 if (!init_reloc_cookie (cookie, info, sec->owner)) 2789 return FALSE; 2790 2791 if (!init_reloc_cookie_rels (cookie, info, sec->owner, sec)) 2792 { 2793 fini_reloc_cookie (cookie, sec->owner); 2794 return FALSE; 2795 } 2796 return TRUE; 2797 } 2798 2799 /* Free the memory allocated by init_reloc_cookie_for_section, 2800 if appropriate. */ 2801 2802 static void 2803 fini_reloc_cookie_for_section (struct coff_reloc_cookie *cookie, 2804 asection *sec) 2805 { 2806 fini_reloc_cookie_rels (cookie, sec); 2807 fini_reloc_cookie (cookie, sec->owner); 2808 } 2809 2810 static asection * 2811 _bfd_coff_gc_mark_hook (asection *sec, 2812 struct bfd_link_info *info ATTRIBUTE_UNUSED, 2813 struct internal_reloc *rel ATTRIBUTE_UNUSED, 2814 struct coff_link_hash_entry *h, 2815 struct internal_syment *sym) 2816 { 2817 if (h != NULL) 2818 { 2819 switch (h->root.type) 2820 { 2821 case bfd_link_hash_defined: 2822 case bfd_link_hash_defweak: 2823 return h->root.u.def.section; 2824 2825 case bfd_link_hash_common: 2826 return h->root.u.c.p->section; 2827 2828 case bfd_link_hash_undefweak: 2829 if (h->symbol_class == C_NT_WEAK && h->numaux == 1) 2830 { 2831 /* PE weak externals. A weak symbol may include an auxiliary 2832 record indicating that if the weak symbol is not resolved, 2833 another external symbol is used instead. */ 2834 struct coff_link_hash_entry *h2 = 2835 h->auxbfd->tdata.coff_obj_data->sym_hashes[ 2836 h->aux->x_sym.x_tagndx.l]; 2837 2838 if (h2 && h2->root.type != bfd_link_hash_undefined) 2839 return h2->root.u.def.section; 2840 } 2841 break; 2842 2843 case bfd_link_hash_undefined: 2844 default: 2845 break; 2846 } 2847 return NULL; 2848 } 2849 2850 return coff_section_from_bfd_index (sec->owner, sym->n_scnum); 2851 } 2852 2853 /* COOKIE->rel describes a relocation against section SEC, which is 2854 a section we've decided to keep. Return the section that contains 2855 the relocation symbol, or NULL if no section contains it. */ 2856 2857 static asection * 2858 _bfd_coff_gc_mark_rsec (struct bfd_link_info *info, asection *sec, 2859 coff_gc_mark_hook_fn gc_mark_hook, 2860 struct coff_reloc_cookie *cookie) 2861 { 2862 struct coff_link_hash_entry *h; 2863 2864 h = cookie->sym_hashes[cookie->rel->r_symndx]; 2865 if (h != NULL) 2866 { 2867 while (h->root.type == bfd_link_hash_indirect 2868 || h->root.type == bfd_link_hash_warning) 2869 h = (struct coff_link_hash_entry *) h->root.u.i.link; 2870 2871 return (*gc_mark_hook) (sec, info, cookie->rel, h, NULL); 2872 } 2873 2874 return (*gc_mark_hook) (sec, info, cookie->rel, NULL, 2875 &(cookie->symbols 2876 + obj_convert (sec->owner)[cookie->rel->r_symndx])->native->u.syment); 2877 } 2878 2879 static bfd_boolean _bfd_coff_gc_mark 2880 (struct bfd_link_info *, asection *, coff_gc_mark_hook_fn); 2881 2882 /* COOKIE->rel describes a relocation against section SEC, which is 2883 a section we've decided to keep. Mark the section that contains 2884 the relocation symbol. */ 2885 2886 static bfd_boolean 2887 _bfd_coff_gc_mark_reloc (struct bfd_link_info *info, 2888 asection *sec, 2889 coff_gc_mark_hook_fn gc_mark_hook, 2890 struct coff_reloc_cookie *cookie) 2891 { 2892 asection *rsec; 2893 2894 rsec = _bfd_coff_gc_mark_rsec (info, sec, gc_mark_hook, cookie); 2895 if (rsec && !rsec->gc_mark) 2896 { 2897 if (bfd_get_flavour (rsec->owner) != bfd_target_coff_flavour) 2898 rsec->gc_mark = 1; 2899 else if (!_bfd_coff_gc_mark (info, rsec, gc_mark_hook)) 2900 return FALSE; 2901 } 2902 return TRUE; 2903 } 2904 2905 /* The mark phase of garbage collection. For a given section, mark 2906 it and any sections in this section's group, and all the sections 2907 which define symbols to which it refers. */ 2908 2909 static bfd_boolean 2910 _bfd_coff_gc_mark (struct bfd_link_info *info, 2911 asection *sec, 2912 coff_gc_mark_hook_fn gc_mark_hook) 2913 { 2914 bfd_boolean ret = TRUE; 2915 2916 sec->gc_mark = 1; 2917 2918 /* Look through the section relocs. */ 2919 if ((sec->flags & SEC_RELOC) != 0 2920 && sec->reloc_count > 0) 2921 { 2922 struct coff_reloc_cookie cookie; 2923 2924 if (!init_reloc_cookie_for_section (&cookie, info, sec)) 2925 ret = FALSE; 2926 else 2927 { 2928 for (; cookie.rel < cookie.relend; cookie.rel++) 2929 { 2930 if (!_bfd_coff_gc_mark_reloc (info, sec, gc_mark_hook, &cookie)) 2931 { 2932 ret = FALSE; 2933 break; 2934 } 2935 } 2936 fini_reloc_cookie_for_section (&cookie, sec); 2937 } 2938 } 2939 2940 return ret; 2941 } 2942 2943 static bfd_boolean 2944 _bfd_coff_gc_mark_extra_sections (struct bfd_link_info *info, 2945 coff_gc_mark_hook_fn mark_hook ATTRIBUTE_UNUSED) 2946 { 2947 bfd *ibfd; 2948 2949 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next) 2950 { 2951 asection *isec; 2952 bfd_boolean some_kept; 2953 2954 if (bfd_get_flavour (ibfd) != bfd_target_coff_flavour) 2955 continue; 2956 2957 /* Ensure all linker created sections are kept, and see whether 2958 any other section is already marked. */ 2959 some_kept = FALSE; 2960 for (isec = ibfd->sections; isec != NULL; isec = isec->next) 2961 { 2962 if ((isec->flags & SEC_LINKER_CREATED) != 0) 2963 isec->gc_mark = 1; 2964 else if (isec->gc_mark) 2965 some_kept = TRUE; 2966 } 2967 2968 /* If no section in this file will be kept, then we can 2969 toss out debug sections. */ 2970 if (!some_kept) 2971 continue; 2972 2973 /* Keep debug and special sections like .comment when they are 2974 not part of a group, or when we have single-member groups. */ 2975 for (isec = ibfd->sections; isec != NULL; isec = isec->next) 2976 if ((isec->flags & SEC_DEBUGGING) != 0 2977 || (isec->flags & (SEC_ALLOC | SEC_LOAD | SEC_RELOC)) == 0) 2978 isec->gc_mark = 1; 2979 } 2980 return TRUE; 2981 } 2982 2983 /* Sweep symbols in swept sections. Called via coff_link_hash_traverse. */ 2984 2985 static bfd_boolean 2986 coff_gc_sweep_symbol (struct coff_link_hash_entry *h, 2987 void *data ATTRIBUTE_UNUSED) 2988 { 2989 if (h->root.type == bfd_link_hash_warning) 2990 h = (struct coff_link_hash_entry *) h->root.u.i.link; 2991 2992 if ((h->root.type == bfd_link_hash_defined 2993 || h->root.type == bfd_link_hash_defweak) 2994 && !h->root.u.def.section->gc_mark 2995 && !(h->root.u.def.section->owner->flags & DYNAMIC)) 2996 { 2997 /* Do our best to hide the symbol. */ 2998 h->root.u.def.section = bfd_und_section_ptr; 2999 h->symbol_class = C_HIDDEN; 3000 } 3001 3002 return TRUE; 3003 } 3004 3005 /* The sweep phase of garbage collection. Remove all garbage sections. */ 3006 3007 typedef bfd_boolean (*gc_sweep_hook_fn) 3008 (bfd *, struct bfd_link_info *, asection *, const struct internal_reloc *); 3009 3010 static bfd_boolean 3011 coff_gc_sweep (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info) 3012 { 3013 bfd *sub; 3014 3015 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next) 3016 { 3017 asection *o; 3018 3019 if (bfd_get_flavour (sub) != bfd_target_coff_flavour) 3020 continue; 3021 3022 for (o = sub->sections; o != NULL; o = o->next) 3023 { 3024 /* Keep debug and special sections. */ 3025 if ((o->flags & (SEC_DEBUGGING | SEC_LINKER_CREATED)) != 0 3026 || (o->flags & (SEC_ALLOC | SEC_LOAD | SEC_RELOC)) == 0) 3027 o->gc_mark = 1; 3028 else if (CONST_STRNEQ (o->name, ".idata") 3029 || CONST_STRNEQ (o->name, ".pdata") 3030 || CONST_STRNEQ (o->name, ".xdata") 3031 || CONST_STRNEQ (o->name, ".rsrc")) 3032 o->gc_mark = 1; 3033 3034 if (o->gc_mark) 3035 continue; 3036 3037 /* Skip sweeping sections already excluded. */ 3038 if (o->flags & SEC_EXCLUDE) 3039 continue; 3040 3041 /* Since this is early in the link process, it is simple 3042 to remove a section from the output. */ 3043 o->flags |= SEC_EXCLUDE; 3044 3045 if (info->print_gc_sections && o->size != 0) 3046 /* xgettext: c-format */ 3047 _bfd_error_handler (_("removing unused section '%pA' in file '%pB'"), 3048 o, sub); 3049 3050 #if 0 3051 /* But we also have to update some of the relocation 3052 info we collected before. */ 3053 if (gc_sweep_hook 3054 && (o->flags & SEC_RELOC) != 0 3055 && o->reloc_count > 0 3056 && !bfd_is_abs_section (o->output_section)) 3057 { 3058 struct internal_reloc *internal_relocs; 3059 bfd_boolean r; 3060 3061 internal_relocs 3062 = _bfd_coff_link_read_relocs (o->owner, o, NULL, NULL, 3063 info->keep_memory); 3064 if (internal_relocs == NULL) 3065 return FALSE; 3066 3067 r = (*gc_sweep_hook) (o->owner, info, o, internal_relocs); 3068 3069 if (coff_section_data (o)->relocs != internal_relocs) 3070 free (internal_relocs); 3071 3072 if (!r) 3073 return FALSE; 3074 } 3075 #endif 3076 } 3077 } 3078 3079 /* Remove the symbols that were in the swept sections from the dynamic 3080 symbol table. */ 3081 coff_link_hash_traverse (coff_hash_table (info), coff_gc_sweep_symbol, 3082 NULL); 3083 3084 return TRUE; 3085 } 3086 3087 /* Keep all sections containing symbols undefined on the command-line, 3088 and the section containing the entry symbol. */ 3089 3090 static void 3091 _bfd_coff_gc_keep (struct bfd_link_info *info) 3092 { 3093 struct bfd_sym_chain *sym; 3094 3095 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next) 3096 { 3097 struct coff_link_hash_entry *h; 3098 3099 h = coff_link_hash_lookup (coff_hash_table (info), sym->name, 3100 FALSE, FALSE, FALSE); 3101 3102 if (h != NULL 3103 && (h->root.type == bfd_link_hash_defined 3104 || h->root.type == bfd_link_hash_defweak) 3105 && !bfd_is_abs_section (h->root.u.def.section)) 3106 h->root.u.def.section->flags |= SEC_KEEP; 3107 } 3108 } 3109 3110 /* Do mark and sweep of unused sections. */ 3111 3112 bfd_boolean 3113 bfd_coff_gc_sections (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info) 3114 { 3115 bfd *sub; 3116 3117 /* FIXME: Should we implement this? */ 3118 #if 0 3119 const bfd_coff_backend_data *bed = coff_backend_info (abfd); 3120 3121 if (!bed->can_gc_sections 3122 || !is_coff_hash_table (info->hash)) 3123 { 3124 _bfd_error_handler(_("warning: gc-sections option ignored")); 3125 return TRUE; 3126 } 3127 #endif 3128 3129 _bfd_coff_gc_keep (info); 3130 3131 /* Grovel through relocs to find out who stays ... */ 3132 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next) 3133 { 3134 asection *o; 3135 3136 if (bfd_get_flavour (sub) != bfd_target_coff_flavour) 3137 continue; 3138 3139 for (o = sub->sections; o != NULL; o = o->next) 3140 { 3141 if (((o->flags & (SEC_EXCLUDE | SEC_KEEP)) == SEC_KEEP 3142 || CONST_STRNEQ (o->name, ".vectors") 3143 || CONST_STRNEQ (o->name, ".ctors") 3144 || CONST_STRNEQ (o->name, ".dtors")) 3145 && !o->gc_mark) 3146 { 3147 if (!_bfd_coff_gc_mark (info, o, _bfd_coff_gc_mark_hook)) 3148 return FALSE; 3149 } 3150 } 3151 } 3152 3153 /* Allow the backend to mark additional target specific sections. */ 3154 _bfd_coff_gc_mark_extra_sections (info, _bfd_coff_gc_mark_hook); 3155 3156 /* ... and mark SEC_EXCLUDE for those that go. */ 3157 return coff_gc_sweep (abfd, info); 3158 } 3159 3160 /* Return name used to identify a comdat group. */ 3161 3162 const char * 3163 bfd_coff_group_name (bfd *abfd, const asection *sec) 3164 { 3165 struct coff_comdat_info *ci = bfd_coff_get_comdat_section (abfd, sec); 3166 if (ci != NULL) 3167 return ci->name; 3168 return NULL; 3169 } 3170 3171 bfd_boolean 3172 _bfd_coff_close_and_cleanup (bfd *abfd) 3173 { 3174 if (abfd->format == bfd_object 3175 && bfd_family_coff (abfd) 3176 && coff_data (abfd) != NULL) 3177 { 3178 obj_coff_keep_syms (abfd) = FALSE; 3179 obj_coff_keep_strings (abfd) = FALSE; 3180 if (!_bfd_coff_free_symbols (abfd)) 3181 return FALSE; 3182 } 3183 return _bfd_generic_close_and_cleanup (abfd); 3184 } 3185