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