elf.c revision 33966
1/* ELF executable support for BFD. 2 Copyright 1993, 1994, 1995, 1996, 1997 Free Software Foundation, Inc. 3 4This file is part of BFD, the Binary File Descriptor library. 5 6This program is free software; you can redistribute it and/or modify 7it under the terms of the GNU General Public License as published by 8the Free Software Foundation; either version 2 of the License, or 9(at your option) any later version. 10 11This program is distributed in the hope that it will be useful, 12but WITHOUT ANY WARRANTY; without even the implied warranty of 13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14GNU General Public License for more details. 15 16You should have received a copy of the GNU General Public License 17along with this program; if not, write to the Free Software 18Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 19 20/* 21 22SECTION 23 ELF backends 24 25 BFD support for ELF formats is being worked on. 26 Currently, the best supported back ends are for sparc and i386 27 (running svr4 or Solaris 2). 28 29 Documentation of the internals of the support code still needs 30 to be written. The code is changing quickly enough that we 31 haven't bothered yet. 32 */ 33 34#include "bfd.h" 35#include "sysdep.h" 36#include "bfdlink.h" 37#include "libbfd.h" 38#define ARCH_SIZE 0 39#include "elf-bfd.h" 40 41static INLINE struct elf_segment_map *make_mapping 42 PARAMS ((bfd *, asection **, unsigned int, unsigned int, boolean)); 43static boolean map_sections_to_segments PARAMS ((bfd *)); 44static int elf_sort_sections PARAMS ((const PTR, const PTR)); 45static boolean assign_file_positions_for_segments PARAMS ((bfd *)); 46static boolean assign_file_positions_except_relocs PARAMS ((bfd *)); 47static boolean prep_headers PARAMS ((bfd *)); 48static boolean swap_out_syms PARAMS ((bfd *, struct bfd_strtab_hash **)); 49static boolean copy_private_bfd_data PARAMS ((bfd *, bfd *)); 50static char *elf_read PARAMS ((bfd *, long, unsigned int)); 51static void elf_fake_sections PARAMS ((bfd *, asection *, PTR)); 52static boolean assign_section_numbers PARAMS ((bfd *)); 53static INLINE int sym_is_global PARAMS ((bfd *, asymbol *)); 54static boolean elf_map_symbols PARAMS ((bfd *)); 55static bfd_size_type get_program_header_size PARAMS ((bfd *)); 56 57/* Swap version information in and out. The version information is 58 currently size independent. If that ever changes, this code will 59 need to move into elfcode.h. */ 60 61/* Swap in a Verdef structure. */ 62 63void 64_bfd_elf_swap_verdef_in (abfd, src, dst) 65 bfd *abfd; 66 const Elf_External_Verdef *src; 67 Elf_Internal_Verdef *dst; 68{ 69 dst->vd_version = bfd_h_get_16 (abfd, src->vd_version); 70 dst->vd_flags = bfd_h_get_16 (abfd, src->vd_flags); 71 dst->vd_ndx = bfd_h_get_16 (abfd, src->vd_ndx); 72 dst->vd_cnt = bfd_h_get_16 (abfd, src->vd_cnt); 73 dst->vd_hash = bfd_h_get_32 (abfd, src->vd_hash); 74 dst->vd_aux = bfd_h_get_32 (abfd, src->vd_aux); 75 dst->vd_next = bfd_h_get_32 (abfd, src->vd_next); 76} 77 78/* Swap out a Verdef structure. */ 79 80void 81_bfd_elf_swap_verdef_out (abfd, src, dst) 82 bfd *abfd; 83 const Elf_Internal_Verdef *src; 84 Elf_External_Verdef *dst; 85{ 86 bfd_h_put_16 (abfd, src->vd_version, dst->vd_version); 87 bfd_h_put_16 (abfd, src->vd_flags, dst->vd_flags); 88 bfd_h_put_16 (abfd, src->vd_ndx, dst->vd_ndx); 89 bfd_h_put_16 (abfd, src->vd_cnt, dst->vd_cnt); 90 bfd_h_put_32 (abfd, src->vd_hash, dst->vd_hash); 91 bfd_h_put_32 (abfd, src->vd_aux, dst->vd_aux); 92 bfd_h_put_32 (abfd, src->vd_next, dst->vd_next); 93} 94 95/* Swap in a Verdaux structure. */ 96 97void 98_bfd_elf_swap_verdaux_in (abfd, src, dst) 99 bfd *abfd; 100 const Elf_External_Verdaux *src; 101 Elf_Internal_Verdaux *dst; 102{ 103 dst->vda_name = bfd_h_get_32 (abfd, src->vda_name); 104 dst->vda_next = bfd_h_get_32 (abfd, src->vda_next); 105} 106 107/* Swap out a Verdaux structure. */ 108 109void 110_bfd_elf_swap_verdaux_out (abfd, src, dst) 111 bfd *abfd; 112 const Elf_Internal_Verdaux *src; 113 Elf_External_Verdaux *dst; 114{ 115 bfd_h_put_32 (abfd, src->vda_name, dst->vda_name); 116 bfd_h_put_32 (abfd, src->vda_next, dst->vda_next); 117} 118 119/* Swap in a Verneed structure. */ 120 121void 122_bfd_elf_swap_verneed_in (abfd, src, dst) 123 bfd *abfd; 124 const Elf_External_Verneed *src; 125 Elf_Internal_Verneed *dst; 126{ 127 dst->vn_version = bfd_h_get_16 (abfd, src->vn_version); 128 dst->vn_cnt = bfd_h_get_16 (abfd, src->vn_cnt); 129 dst->vn_file = bfd_h_get_32 (abfd, src->vn_file); 130 dst->vn_aux = bfd_h_get_32 (abfd, src->vn_aux); 131 dst->vn_next = bfd_h_get_32 (abfd, src->vn_next); 132} 133 134/* Swap out a Verneed structure. */ 135 136void 137_bfd_elf_swap_verneed_out (abfd, src, dst) 138 bfd *abfd; 139 const Elf_Internal_Verneed *src; 140 Elf_External_Verneed *dst; 141{ 142 bfd_h_put_16 (abfd, src->vn_version, dst->vn_version); 143 bfd_h_put_16 (abfd, src->vn_cnt, dst->vn_cnt); 144 bfd_h_put_32 (abfd, src->vn_file, dst->vn_file); 145 bfd_h_put_32 (abfd, src->vn_aux, dst->vn_aux); 146 bfd_h_put_32 (abfd, src->vn_next, dst->vn_next); 147} 148 149/* Swap in a Vernaux structure. */ 150 151void 152_bfd_elf_swap_vernaux_in (abfd, src, dst) 153 bfd *abfd; 154 const Elf_External_Vernaux *src; 155 Elf_Internal_Vernaux *dst; 156{ 157 dst->vna_hash = bfd_h_get_32 (abfd, src->vna_hash); 158 dst->vna_flags = bfd_h_get_16 (abfd, src->vna_flags); 159 dst->vna_other = bfd_h_get_16 (abfd, src->vna_other); 160 dst->vna_name = bfd_h_get_32 (abfd, src->vna_name); 161 dst->vna_next = bfd_h_get_32 (abfd, src->vna_next); 162} 163 164/* Swap out a Vernaux structure. */ 165 166void 167_bfd_elf_swap_vernaux_out (abfd, src, dst) 168 bfd *abfd; 169 const Elf_Internal_Vernaux *src; 170 Elf_External_Vernaux *dst; 171{ 172 bfd_h_put_32 (abfd, src->vna_hash, dst->vna_hash); 173 bfd_h_put_16 (abfd, src->vna_flags, dst->vna_flags); 174 bfd_h_put_16 (abfd, src->vna_other, dst->vna_other); 175 bfd_h_put_32 (abfd, src->vna_name, dst->vna_name); 176 bfd_h_put_32 (abfd, src->vna_next, dst->vna_next); 177} 178 179/* Swap in a Versym structure. */ 180 181void 182_bfd_elf_swap_versym_in (abfd, src, dst) 183 bfd *abfd; 184 const Elf_External_Versym *src; 185 Elf_Internal_Versym *dst; 186{ 187 dst->vs_vers = bfd_h_get_16 (abfd, src->vs_vers); 188} 189 190/* Swap out a Versym structure. */ 191 192void 193_bfd_elf_swap_versym_out (abfd, src, dst) 194 bfd *abfd; 195 const Elf_Internal_Versym *src; 196 Elf_External_Versym *dst; 197{ 198 bfd_h_put_16 (abfd, src->vs_vers, dst->vs_vers); 199} 200 201/* Standard ELF hash function. Do not change this function; you will 202 cause invalid hash tables to be generated. (Well, you would if this 203 were being used yet.) */ 204unsigned long 205bfd_elf_hash (name) 206 CONST unsigned char *name; 207{ 208 unsigned long h = 0; 209 unsigned long g; 210 int ch; 211 212 while ((ch = *name++) != '\0') 213 { 214 h = (h << 4) + ch; 215 if ((g = (h & 0xf0000000)) != 0) 216 { 217 h ^= g >> 24; 218 h &= ~g; 219 } 220 } 221 return h; 222} 223 224/* Read a specified number of bytes at a specified offset in an ELF 225 file, into a newly allocated buffer, and return a pointer to the 226 buffer. */ 227 228static char * 229elf_read (abfd, offset, size) 230 bfd * abfd; 231 long offset; 232 unsigned int size; 233{ 234 char *buf; 235 236 if ((buf = bfd_alloc (abfd, size)) == NULL) 237 return NULL; 238 if (bfd_seek (abfd, offset, SEEK_SET) == -1) 239 return NULL; 240 if (bfd_read ((PTR) buf, size, 1, abfd) != size) 241 { 242 if (bfd_get_error () != bfd_error_system_call) 243 bfd_set_error (bfd_error_file_truncated); 244 return NULL; 245 } 246 return buf; 247} 248 249boolean 250bfd_elf_mkobject (abfd) 251 bfd * abfd; 252{ 253 /* this just does initialization */ 254 /* coff_mkobject zalloc's space for tdata.coff_obj_data ... */ 255 elf_tdata (abfd) = (struct elf_obj_tdata *) 256 bfd_zalloc (abfd, sizeof (struct elf_obj_tdata)); 257 if (elf_tdata (abfd) == 0) 258 return false; 259 /* since everything is done at close time, do we need any 260 initialization? */ 261 262 return true; 263} 264 265char * 266bfd_elf_get_str_section (abfd, shindex) 267 bfd * abfd; 268 unsigned int shindex; 269{ 270 Elf_Internal_Shdr **i_shdrp; 271 char *shstrtab = NULL; 272 unsigned int offset; 273 unsigned int shstrtabsize; 274 275 i_shdrp = elf_elfsections (abfd); 276 if (i_shdrp == 0 || i_shdrp[shindex] == 0) 277 return 0; 278 279 shstrtab = (char *) i_shdrp[shindex]->contents; 280 if (shstrtab == NULL) 281 { 282 /* No cached one, attempt to read, and cache what we read. */ 283 offset = i_shdrp[shindex]->sh_offset; 284 shstrtabsize = i_shdrp[shindex]->sh_size; 285 shstrtab = elf_read (abfd, offset, shstrtabsize); 286 i_shdrp[shindex]->contents = (PTR) shstrtab; 287 } 288 return shstrtab; 289} 290 291char * 292bfd_elf_string_from_elf_section (abfd, shindex, strindex) 293 bfd * abfd; 294 unsigned int shindex; 295 unsigned int strindex; 296{ 297 Elf_Internal_Shdr *hdr; 298 299 if (strindex == 0) 300 return ""; 301 302 hdr = elf_elfsections (abfd)[shindex]; 303 304 if (hdr->contents == NULL 305 && bfd_elf_get_str_section (abfd, shindex) == NULL) 306 return NULL; 307 308 return ((char *) hdr->contents) + strindex; 309} 310 311/* Make a BFD section from an ELF section. We store a pointer to the 312 BFD section in the bfd_section field of the header. */ 313 314boolean 315_bfd_elf_make_section_from_shdr (abfd, hdr, name) 316 bfd *abfd; 317 Elf_Internal_Shdr *hdr; 318 const char *name; 319{ 320 asection *newsect; 321 flagword flags; 322 323 if (hdr->bfd_section != NULL) 324 { 325 BFD_ASSERT (strcmp (name, 326 bfd_get_section_name (abfd, hdr->bfd_section)) == 0); 327 return true; 328 } 329 330 newsect = bfd_make_section_anyway (abfd, name); 331 if (newsect == NULL) 332 return false; 333 334 newsect->filepos = hdr->sh_offset; 335 336 if (! bfd_set_section_vma (abfd, newsect, hdr->sh_addr) 337 || ! bfd_set_section_size (abfd, newsect, hdr->sh_size) 338 || ! bfd_set_section_alignment (abfd, newsect, 339 bfd_log2 (hdr->sh_addralign))) 340 return false; 341 342 flags = SEC_NO_FLAGS; 343 if (hdr->sh_type != SHT_NOBITS) 344 flags |= SEC_HAS_CONTENTS; 345 if ((hdr->sh_flags & SHF_ALLOC) != 0) 346 { 347 flags |= SEC_ALLOC; 348 if (hdr->sh_type != SHT_NOBITS) 349 flags |= SEC_LOAD; 350 } 351 if ((hdr->sh_flags & SHF_WRITE) == 0) 352 flags |= SEC_READONLY; 353 if ((hdr->sh_flags & SHF_EXECINSTR) != 0) 354 flags |= SEC_CODE; 355 else if ((flags & SEC_LOAD) != 0) 356 flags |= SEC_DATA; 357 358 /* The debugging sections appear to be recognized only by name, not 359 any sort of flag. */ 360 if (strncmp (name, ".debug", sizeof ".debug" - 1) == 0 361 || strncmp (name, ".line", sizeof ".line" - 1) == 0 362 || strncmp (name, ".stab", sizeof ".stab" - 1) == 0) 363 flags |= SEC_DEBUGGING; 364 365 /* As a GNU extension, if the name begins with .gnu.linkonce, we 366 only link a single copy of the section. This is used to support 367 g++. g++ will emit each template expansion in its own section. 368 The symbols will be defined as weak, so that multiple definitions 369 are permitted. The GNU linker extension is to actually discard 370 all but one of the sections. */ 371 if (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0) 372 flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD; 373 374 if (! bfd_set_section_flags (abfd, newsect, flags)) 375 return false; 376 377 if ((flags & SEC_ALLOC) != 0) 378 { 379 Elf_Internal_Phdr *phdr; 380 unsigned int i; 381 382 /* Look through the phdrs to see if we need to adjust the lma. */ 383 phdr = elf_tdata (abfd)->phdr; 384 for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++) 385 { 386 if (phdr->p_type == PT_LOAD 387 && phdr->p_paddr != 0 388 && phdr->p_vaddr != phdr->p_paddr 389 && phdr->p_vaddr <= hdr->sh_addr 390 && phdr->p_vaddr + phdr->p_memsz >= hdr->sh_addr + hdr->sh_size 391 && ((flags & SEC_LOAD) == 0 392 || (phdr->p_offset <= hdr->sh_offset 393 && (phdr->p_offset + phdr->p_filesz 394 >= hdr->sh_offset + hdr->sh_size)))) 395 { 396 newsect->lma += phdr->p_paddr - phdr->p_vaddr; 397 break; 398 } 399 } 400 } 401 402 hdr->bfd_section = newsect; 403 elf_section_data (newsect)->this_hdr = *hdr; 404 405 return true; 406} 407 408/* 409INTERNAL_FUNCTION 410 bfd_elf_find_section 411 412SYNOPSIS 413 struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name); 414 415DESCRIPTION 416 Helper functions for GDB to locate the string tables. 417 Since BFD hides string tables from callers, GDB needs to use an 418 internal hook to find them. Sun's .stabstr, in particular, 419 isn't even pointed to by the .stab section, so ordinary 420 mechanisms wouldn't work to find it, even if we had some. 421*/ 422 423struct elf_internal_shdr * 424bfd_elf_find_section (abfd, name) 425 bfd * abfd; 426 char *name; 427{ 428 Elf_Internal_Shdr **i_shdrp; 429 char *shstrtab; 430 unsigned int max; 431 unsigned int i; 432 433 i_shdrp = elf_elfsections (abfd); 434 if (i_shdrp != NULL) 435 { 436 shstrtab = bfd_elf_get_str_section (abfd, elf_elfheader (abfd)->e_shstrndx); 437 if (shstrtab != NULL) 438 { 439 max = elf_elfheader (abfd)->e_shnum; 440 for (i = 1; i < max; i++) 441 if (!strcmp (&shstrtab[i_shdrp[i]->sh_name], name)) 442 return i_shdrp[i]; 443 } 444 } 445 return 0; 446} 447 448const char *const bfd_elf_section_type_names[] = { 449 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB", 450 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE", 451 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM", 452}; 453 454/* ELF relocs are against symbols. If we are producing relocateable 455 output, and the reloc is against an external symbol, and nothing 456 has given us any additional addend, the resulting reloc will also 457 be against the same symbol. In such a case, we don't want to 458 change anything about the way the reloc is handled, since it will 459 all be done at final link time. Rather than put special case code 460 into bfd_perform_relocation, all the reloc types use this howto 461 function. It just short circuits the reloc if producing 462 relocateable output against an external symbol. */ 463 464/*ARGSUSED*/ 465bfd_reloc_status_type 466bfd_elf_generic_reloc (abfd, 467 reloc_entry, 468 symbol, 469 data, 470 input_section, 471 output_bfd, 472 error_message) 473 bfd *abfd; 474 arelent *reloc_entry; 475 asymbol *symbol; 476 PTR data; 477 asection *input_section; 478 bfd *output_bfd; 479 char **error_message; 480{ 481 if (output_bfd != (bfd *) NULL 482 && (symbol->flags & BSF_SECTION_SYM) == 0 483 && (! reloc_entry->howto->partial_inplace 484 || reloc_entry->addend == 0)) 485 { 486 reloc_entry->address += input_section->output_offset; 487 return bfd_reloc_ok; 488 } 489 490 return bfd_reloc_continue; 491} 492 493/* Print out the program headers. */ 494 495boolean 496_bfd_elf_print_private_bfd_data (abfd, farg) 497 bfd *abfd; 498 PTR farg; 499{ 500 FILE *f = (FILE *) farg; 501 Elf_Internal_Phdr *p; 502 asection *s; 503 bfd_byte *dynbuf = NULL; 504 505 p = elf_tdata (abfd)->phdr; 506 if (p != NULL) 507 { 508 unsigned int i, c; 509 510 fprintf (f, "\nProgram Header:\n"); 511 c = elf_elfheader (abfd)->e_phnum; 512 for (i = 0; i < c; i++, p++) 513 { 514 const char *s; 515 char buf[20]; 516 517 switch (p->p_type) 518 { 519 case PT_NULL: s = "NULL"; break; 520 case PT_LOAD: s = "LOAD"; break; 521 case PT_DYNAMIC: s = "DYNAMIC"; break; 522 case PT_INTERP: s = "INTERP"; break; 523 case PT_NOTE: s = "NOTE"; break; 524 case PT_SHLIB: s = "SHLIB"; break; 525 case PT_PHDR: s = "PHDR"; break; 526 default: sprintf (buf, "0x%lx", p->p_type); s = buf; break; 527 } 528 fprintf (f, "%8s off 0x", s); 529 fprintf_vma (f, p->p_offset); 530 fprintf (f, " vaddr 0x"); 531 fprintf_vma (f, p->p_vaddr); 532 fprintf (f, " paddr 0x"); 533 fprintf_vma (f, p->p_paddr); 534 fprintf (f, " align 2**%u\n", bfd_log2 (p->p_align)); 535 fprintf (f, " filesz 0x"); 536 fprintf_vma (f, p->p_filesz); 537 fprintf (f, " memsz 0x"); 538 fprintf_vma (f, p->p_memsz); 539 fprintf (f, " flags %c%c%c", 540 (p->p_flags & PF_R) != 0 ? 'r' : '-', 541 (p->p_flags & PF_W) != 0 ? 'w' : '-', 542 (p->p_flags & PF_X) != 0 ? 'x' : '-'); 543 if ((p->p_flags &~ (PF_R | PF_W | PF_X)) != 0) 544 fprintf (f, " %lx", p->p_flags &~ (PF_R | PF_W | PF_X)); 545 fprintf (f, "\n"); 546 } 547 } 548 549 s = bfd_get_section_by_name (abfd, ".dynamic"); 550 if (s != NULL) 551 { 552 int elfsec; 553 unsigned long link; 554 bfd_byte *extdyn, *extdynend; 555 size_t extdynsize; 556 void (*swap_dyn_in) PARAMS ((bfd *, const PTR, Elf_Internal_Dyn *)); 557 558 fprintf (f, "\nDynamic Section:\n"); 559 560 dynbuf = (bfd_byte *) bfd_malloc (s->_raw_size); 561 if (dynbuf == NULL) 562 goto error_return; 563 if (! bfd_get_section_contents (abfd, s, (PTR) dynbuf, (file_ptr) 0, 564 s->_raw_size)) 565 goto error_return; 566 567 elfsec = _bfd_elf_section_from_bfd_section (abfd, s); 568 if (elfsec == -1) 569 goto error_return; 570 link = elf_elfsections (abfd)[elfsec]->sh_link; 571 572 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn; 573 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in; 574 575 extdyn = dynbuf; 576 extdynend = extdyn + s->_raw_size; 577 for (; extdyn < extdynend; extdyn += extdynsize) 578 { 579 Elf_Internal_Dyn dyn; 580 const char *name; 581 char ab[20]; 582 boolean stringp; 583 584 (*swap_dyn_in) (abfd, (PTR) extdyn, &dyn); 585 586 if (dyn.d_tag == DT_NULL) 587 break; 588 589 stringp = false; 590 switch (dyn.d_tag) 591 { 592 default: 593 sprintf (ab, "0x%lx", (unsigned long) dyn.d_tag); 594 name = ab; 595 break; 596 597 case DT_NEEDED: name = "NEEDED"; stringp = true; break; 598 case DT_PLTRELSZ: name = "PLTRELSZ"; break; 599 case DT_PLTGOT: name = "PLTGOT"; break; 600 case DT_HASH: name = "HASH"; break; 601 case DT_STRTAB: name = "STRTAB"; break; 602 case DT_SYMTAB: name = "SYMTAB"; break; 603 case DT_RELA: name = "RELA"; break; 604 case DT_RELASZ: name = "RELASZ"; break; 605 case DT_RELAENT: name = "RELAENT"; break; 606 case DT_STRSZ: name = "STRSZ"; break; 607 case DT_SYMENT: name = "SYMENT"; break; 608 case DT_INIT: name = "INIT"; break; 609 case DT_FINI: name = "FINI"; break; 610 case DT_SONAME: name = "SONAME"; stringp = true; break; 611 case DT_RPATH: name = "RPATH"; stringp = true; break; 612 case DT_SYMBOLIC: name = "SYMBOLIC"; break; 613 case DT_REL: name = "REL"; break; 614 case DT_RELSZ: name = "RELSZ"; break; 615 case DT_RELENT: name = "RELENT"; break; 616 case DT_PLTREL: name = "PLTREL"; break; 617 case DT_DEBUG: name = "DEBUG"; break; 618 case DT_TEXTREL: name = "TEXTREL"; break; 619 case DT_JMPREL: name = "JMPREL"; break; 620 case DT_AUXILIARY: name = "AUXILIARY"; stringp = true; break; 621 case DT_FILTER: name = "FILTER"; stringp = true; break; 622 case DT_VERSYM: name = "VERSYM"; break; 623 case DT_VERDEF: name = "VERDEF"; break; 624 case DT_VERDEFNUM: name = "VERDEFNUM"; break; 625 case DT_VERNEED: name = "VERNEED"; break; 626 case DT_VERNEEDNUM: name = "VERNEEDNUM"; break; 627 } 628 629 fprintf (f, " %-11s ", name); 630 if (! stringp) 631 fprintf (f, "0x%lx", (unsigned long) dyn.d_un.d_val); 632 else 633 { 634 const char *string; 635 636 string = bfd_elf_string_from_elf_section (abfd, link, 637 dyn.d_un.d_val); 638 if (string == NULL) 639 goto error_return; 640 fprintf (f, "%s", string); 641 } 642 fprintf (f, "\n"); 643 } 644 645 free (dynbuf); 646 dynbuf = NULL; 647 } 648 649 if ((elf_dynverdef (abfd) != 0 && elf_tdata (abfd)->verdef == NULL) 650 || (elf_dynverref (abfd) != 0 && elf_tdata (abfd)->verref == NULL)) 651 { 652 if (! _bfd_elf_slurp_version_tables (abfd)) 653 return false; 654 } 655 656 if (elf_dynverdef (abfd) != 0) 657 { 658 Elf_Internal_Verdef *t; 659 660 fprintf (f, "\nVersion definitions:\n"); 661 for (t = elf_tdata (abfd)->verdef; t != NULL; t = t->vd_nextdef) 662 { 663 fprintf (f, "%d 0x%2.2x 0x%8.8lx %s\n", t->vd_ndx, 664 t->vd_flags, t->vd_hash, t->vd_nodename); 665 if (t->vd_auxptr->vda_nextptr != NULL) 666 { 667 Elf_Internal_Verdaux *a; 668 669 fprintf (f, "\t"); 670 for (a = t->vd_auxptr->vda_nextptr; 671 a != NULL; 672 a = a->vda_nextptr) 673 fprintf (f, "%s ", a->vda_nodename); 674 fprintf (f, "\n"); 675 } 676 } 677 } 678 679 if (elf_dynverref (abfd) != 0) 680 { 681 Elf_Internal_Verneed *t; 682 683 fprintf (f, "\nVersion References:\n"); 684 for (t = elf_tdata (abfd)->verref; t != NULL; t = t->vn_nextref) 685 { 686 Elf_Internal_Vernaux *a; 687 688 fprintf (f, " required from %s:\n", t->vn_filename); 689 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr) 690 fprintf (f, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a->vna_hash, 691 a->vna_flags, a->vna_other, a->vna_nodename); 692 } 693 } 694 695 return true; 696 697 error_return: 698 if (dynbuf != NULL) 699 free (dynbuf); 700 return false; 701} 702 703/* Display ELF-specific fields of a symbol. */ 704 705void 706bfd_elf_print_symbol (abfd, filep, symbol, how) 707 bfd *abfd; 708 PTR filep; 709 asymbol *symbol; 710 bfd_print_symbol_type how; 711{ 712 FILE *file = (FILE *) filep; 713 switch (how) 714 { 715 case bfd_print_symbol_name: 716 fprintf (file, "%s", symbol->name); 717 break; 718 case bfd_print_symbol_more: 719 fprintf (file, "elf "); 720 fprintf_vma (file, symbol->value); 721 fprintf (file, " %lx", (long) symbol->flags); 722 break; 723 case bfd_print_symbol_all: 724 { 725 CONST char *section_name; 726 section_name = symbol->section ? symbol->section->name : "(*none*)"; 727 bfd_print_symbol_vandf ((PTR) file, symbol); 728 fprintf (file, " %s\t", section_name); 729 /* Print the "other" value for a symbol. For common symbols, 730 we've already printed the size; now print the alignment. 731 For other symbols, we have no specified alignment, and 732 we've printed the address; now print the size. */ 733 fprintf_vma (file, 734 (bfd_is_com_section (symbol->section) 735 ? ((elf_symbol_type *) symbol)->internal_elf_sym.st_value 736 : ((elf_symbol_type *) symbol)->internal_elf_sym.st_size)); 737 738 /* If we have version information, print it. */ 739 if (elf_tdata (abfd)->dynversym_section != 0 740 && (elf_tdata (abfd)->dynverdef_section != 0 741 || elf_tdata (abfd)->dynverref_section != 0)) 742 { 743 unsigned int vernum; 744 const char *version_string; 745 746 vernum = ((elf_symbol_type *) symbol)->version & VERSYM_VERSION; 747 748 if (vernum == 0) 749 version_string = ""; 750 else if (vernum == 1) 751 version_string = "Base"; 752 else if (vernum <= elf_tdata (abfd)->cverdefs) 753 version_string = 754 elf_tdata (abfd)->verdef[vernum - 1].vd_nodename; 755 else 756 { 757 Elf_Internal_Verneed *t; 758 759 version_string = ""; 760 for (t = elf_tdata (abfd)->verref; 761 t != NULL; 762 t = t->vn_nextref) 763 { 764 Elf_Internal_Vernaux *a; 765 766 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr) 767 { 768 if (a->vna_other == vernum) 769 { 770 version_string = a->vna_nodename; 771 break; 772 } 773 } 774 } 775 } 776 777 if ((((elf_symbol_type *) symbol)->version & VERSYM_HIDDEN) == 0) 778 fprintf (file, " %-11s", version_string); 779 else 780 { 781 int i; 782 783 fprintf (file, " (%s)", version_string); 784 for (i = 10 - strlen (version_string); i > 0; --i) 785 putc (' ', file); 786 } 787 } 788 789 /* If the st_other field is not zero, print it. */ 790 if (((elf_symbol_type *) symbol)->internal_elf_sym.st_other != 0) 791 fprintf (file, " 0x%02x", 792 ((unsigned int) 793 ((elf_symbol_type *) symbol)->internal_elf_sym.st_other)); 794 795 fprintf (file, " %s", symbol->name); 796 } 797 break; 798 } 799} 800 801/* Create an entry in an ELF linker hash table. */ 802 803struct bfd_hash_entry * 804_bfd_elf_link_hash_newfunc (entry, table, string) 805 struct bfd_hash_entry *entry; 806 struct bfd_hash_table *table; 807 const char *string; 808{ 809 struct elf_link_hash_entry *ret = (struct elf_link_hash_entry *) entry; 810 811 /* Allocate the structure if it has not already been allocated by a 812 subclass. */ 813 if (ret == (struct elf_link_hash_entry *) NULL) 814 ret = ((struct elf_link_hash_entry *) 815 bfd_hash_allocate (table, sizeof (struct elf_link_hash_entry))); 816 if (ret == (struct elf_link_hash_entry *) NULL) 817 return (struct bfd_hash_entry *) ret; 818 819 /* Call the allocation method of the superclass. */ 820 ret = ((struct elf_link_hash_entry *) 821 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret, 822 table, string)); 823 if (ret != (struct elf_link_hash_entry *) NULL) 824 { 825 /* Set local fields. */ 826 ret->indx = -1; 827 ret->size = 0; 828 ret->dynindx = -1; 829 ret->dynstr_index = 0; 830 ret->weakdef = NULL; 831 ret->got_offset = (bfd_vma) -1; 832 ret->plt_offset = (bfd_vma) -1; 833 ret->linker_section_pointer = (elf_linker_section_pointers_t *)0; 834 ret->verinfo.verdef = NULL; 835 ret->type = STT_NOTYPE; 836 ret->other = 0; 837 /* Assume that we have been called by a non-ELF symbol reader. 838 This flag is then reset by the code which reads an ELF input 839 file. This ensures that a symbol created by a non-ELF symbol 840 reader will have the flag set correctly. */ 841 ret->elf_link_hash_flags = ELF_LINK_NON_ELF; 842 } 843 844 return (struct bfd_hash_entry *) ret; 845} 846 847/* Initialize an ELF linker hash table. */ 848 849boolean 850_bfd_elf_link_hash_table_init (table, abfd, newfunc) 851 struct elf_link_hash_table *table; 852 bfd *abfd; 853 struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *, 854 struct bfd_hash_table *, 855 const char *)); 856{ 857 table->dynamic_sections_created = false; 858 table->dynobj = NULL; 859 /* The first dynamic symbol is a dummy. */ 860 table->dynsymcount = 1; 861 table->dynstr = NULL; 862 table->bucketcount = 0; 863 table->needed = NULL; 864 table->hgot = NULL; 865 table->stab_info = NULL; 866 return _bfd_link_hash_table_init (&table->root, abfd, newfunc); 867} 868 869/* Create an ELF linker hash table. */ 870 871struct bfd_link_hash_table * 872_bfd_elf_link_hash_table_create (abfd) 873 bfd *abfd; 874{ 875 struct elf_link_hash_table *ret; 876 877 ret = ((struct elf_link_hash_table *) 878 bfd_alloc (abfd, sizeof (struct elf_link_hash_table))); 879 if (ret == (struct elf_link_hash_table *) NULL) 880 return NULL; 881 882 if (! _bfd_elf_link_hash_table_init (ret, abfd, _bfd_elf_link_hash_newfunc)) 883 { 884 bfd_release (abfd, ret); 885 return NULL; 886 } 887 888 return &ret->root; 889} 890 891/* This is a hook for the ELF emulation code in the generic linker to 892 tell the backend linker what file name to use for the DT_NEEDED 893 entry for a dynamic object. The generic linker passes name as an 894 empty string to indicate that no DT_NEEDED entry should be made. */ 895 896void 897bfd_elf_set_dt_needed_name (abfd, name) 898 bfd *abfd; 899 const char *name; 900{ 901 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour 902 && bfd_get_format (abfd) == bfd_object) 903 elf_dt_name (abfd) = name; 904} 905 906/* Get the list of DT_NEEDED entries for a link. This is a hook for 907 the ELF emulation code. */ 908 909struct bfd_link_needed_list * 910bfd_elf_get_needed_list (abfd, info) 911 bfd *abfd; 912 struct bfd_link_info *info; 913{ 914 if (info->hash->creator->flavour != bfd_target_elf_flavour) 915 return NULL; 916 return elf_hash_table (info)->needed; 917} 918 919/* Get the name actually used for a dynamic object for a link. This 920 is the SONAME entry if there is one. Otherwise, it is the string 921 passed to bfd_elf_set_dt_needed_name, or it is the filename. */ 922 923const char * 924bfd_elf_get_dt_soname (abfd) 925 bfd *abfd; 926{ 927 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour 928 && bfd_get_format (abfd) == bfd_object) 929 return elf_dt_name (abfd); 930 return NULL; 931} 932 933/* Allocate an ELF string table--force the first byte to be zero. */ 934 935struct bfd_strtab_hash * 936_bfd_elf_stringtab_init () 937{ 938 struct bfd_strtab_hash *ret; 939 940 ret = _bfd_stringtab_init (); 941 if (ret != NULL) 942 { 943 bfd_size_type loc; 944 945 loc = _bfd_stringtab_add (ret, "", true, false); 946 BFD_ASSERT (loc == 0 || loc == (bfd_size_type) -1); 947 if (loc == (bfd_size_type) -1) 948 { 949 _bfd_stringtab_free (ret); 950 ret = NULL; 951 } 952 } 953 return ret; 954} 955 956/* ELF .o/exec file reading */ 957 958/* Create a new bfd section from an ELF section header. */ 959 960boolean 961bfd_section_from_shdr (abfd, shindex) 962 bfd *abfd; 963 unsigned int shindex; 964{ 965 Elf_Internal_Shdr *hdr = elf_elfsections (abfd)[shindex]; 966 Elf_Internal_Ehdr *ehdr = elf_elfheader (abfd); 967 struct elf_backend_data *bed = get_elf_backend_data (abfd); 968 char *name; 969 970 name = elf_string_from_elf_strtab (abfd, hdr->sh_name); 971 972 switch (hdr->sh_type) 973 { 974 case SHT_NULL: 975 /* Inactive section. Throw it away. */ 976 return true; 977 978 case SHT_PROGBITS: /* Normal section with contents. */ 979 case SHT_DYNAMIC: /* Dynamic linking information. */ 980 case SHT_NOBITS: /* .bss section. */ 981 case SHT_HASH: /* .hash section. */ 982 case SHT_NOTE: /* .note section. */ 983 return _bfd_elf_make_section_from_shdr (abfd, hdr, name); 984 985 case SHT_SYMTAB: /* A symbol table */ 986 if (elf_onesymtab (abfd) == shindex) 987 return true; 988 989 BFD_ASSERT (hdr->sh_entsize == bed->s->sizeof_sym); 990 BFD_ASSERT (elf_onesymtab (abfd) == 0); 991 elf_onesymtab (abfd) = shindex; 992 elf_tdata (abfd)->symtab_hdr = *hdr; 993 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->symtab_hdr; 994 abfd->flags |= HAS_SYMS; 995 996 /* Sometimes a shared object will map in the symbol table. If 997 SHF_ALLOC is set, and this is a shared object, then we also 998 treat this section as a BFD section. We can not base the 999 decision purely on SHF_ALLOC, because that flag is sometimes 1000 set in a relocateable object file, which would confuse the 1001 linker. */ 1002 if ((hdr->sh_flags & SHF_ALLOC) != 0 1003 && (abfd->flags & DYNAMIC) != 0 1004 && ! _bfd_elf_make_section_from_shdr (abfd, hdr, name)) 1005 return false; 1006 1007 return true; 1008 1009 case SHT_DYNSYM: /* A dynamic symbol table */ 1010 if (elf_dynsymtab (abfd) == shindex) 1011 return true; 1012 1013 BFD_ASSERT (hdr->sh_entsize == bed->s->sizeof_sym); 1014 BFD_ASSERT (elf_dynsymtab (abfd) == 0); 1015 elf_dynsymtab (abfd) = shindex; 1016 elf_tdata (abfd)->dynsymtab_hdr = *hdr; 1017 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->dynsymtab_hdr; 1018 abfd->flags |= HAS_SYMS; 1019 1020 /* Besides being a symbol table, we also treat this as a regular 1021 section, so that objcopy can handle it. */ 1022 return _bfd_elf_make_section_from_shdr (abfd, hdr, name); 1023 1024 case SHT_STRTAB: /* A string table */ 1025 if (hdr->bfd_section != NULL) 1026 return true; 1027 if (ehdr->e_shstrndx == shindex) 1028 { 1029 elf_tdata (abfd)->shstrtab_hdr = *hdr; 1030 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->shstrtab_hdr; 1031 return true; 1032 } 1033 { 1034 unsigned int i; 1035 1036 for (i = 1; i < ehdr->e_shnum; i++) 1037 { 1038 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i]; 1039 if (hdr2->sh_link == shindex) 1040 { 1041 if (! bfd_section_from_shdr (abfd, i)) 1042 return false; 1043 if (elf_onesymtab (abfd) == i) 1044 { 1045 elf_tdata (abfd)->strtab_hdr = *hdr; 1046 elf_elfsections (abfd)[shindex] = 1047 &elf_tdata (abfd)->strtab_hdr; 1048 return true; 1049 } 1050 if (elf_dynsymtab (abfd) == i) 1051 { 1052 elf_tdata (abfd)->dynstrtab_hdr = *hdr; 1053 elf_elfsections (abfd)[shindex] = hdr = 1054 &elf_tdata (abfd)->dynstrtab_hdr; 1055 /* We also treat this as a regular section, so 1056 that objcopy can handle it. */ 1057 break; 1058 } 1059#if 0 /* Not handling other string tables specially right now. */ 1060 hdr2 = elf_elfsections (abfd)[i]; /* in case it moved */ 1061 /* We have a strtab for some random other section. */ 1062 newsect = (asection *) hdr2->bfd_section; 1063 if (!newsect) 1064 break; 1065 hdr->bfd_section = newsect; 1066 hdr2 = &elf_section_data (newsect)->str_hdr; 1067 *hdr2 = *hdr; 1068 elf_elfsections (abfd)[shindex] = hdr2; 1069#endif 1070 } 1071 } 1072 } 1073 1074 return _bfd_elf_make_section_from_shdr (abfd, hdr, name); 1075 1076 case SHT_REL: 1077 case SHT_RELA: 1078 /* *These* do a lot of work -- but build no sections! */ 1079 { 1080 asection *target_sect; 1081 Elf_Internal_Shdr *hdr2; 1082 1083 /* For some incomprehensible reason Oracle distributes 1084 libraries for Solaris in which some of the objects have 1085 bogus sh_link fields. It would be nice if we could just 1086 reject them, but, unfortunately, some people need to use 1087 them. We scan through the section headers; if we find only 1088 one suitable symbol table, we clobber the sh_link to point 1089 to it. I hope this doesn't break anything. */ 1090 if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_SYMTAB 1091 && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_DYNSYM) 1092 { 1093 int scan; 1094 int found; 1095 1096 found = 0; 1097 for (scan = 1; scan < ehdr->e_shnum; scan++) 1098 { 1099 if (elf_elfsections (abfd)[scan]->sh_type == SHT_SYMTAB 1100 || elf_elfsections (abfd)[scan]->sh_type == SHT_DYNSYM) 1101 { 1102 if (found != 0) 1103 { 1104 found = 0; 1105 break; 1106 } 1107 found = scan; 1108 } 1109 } 1110 if (found != 0) 1111 hdr->sh_link = found; 1112 } 1113 1114 /* Get the symbol table. */ 1115 if (elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_SYMTAB 1116 && ! bfd_section_from_shdr (abfd, hdr->sh_link)) 1117 return false; 1118 1119 /* If this reloc section does not use the main symbol table we 1120 don't treat it as a reloc section. BFD can't adequately 1121 represent such a section, so at least for now, we don't 1122 try. We just present it as a normal section. */ 1123 if (hdr->sh_link != elf_onesymtab (abfd)) 1124 return _bfd_elf_make_section_from_shdr (abfd, hdr, name); 1125 1126 if (! bfd_section_from_shdr (abfd, hdr->sh_info)) 1127 return false; 1128 target_sect = bfd_section_from_elf_index (abfd, hdr->sh_info); 1129 if (target_sect == NULL) 1130 return false; 1131 1132 if ((target_sect->flags & SEC_RELOC) == 0 1133 || target_sect->reloc_count == 0) 1134 hdr2 = &elf_section_data (target_sect)->rel_hdr; 1135 else 1136 { 1137 BFD_ASSERT (elf_section_data (target_sect)->rel_hdr2 == NULL); 1138 hdr2 = (Elf_Internal_Shdr *) bfd_alloc (abfd, sizeof (*hdr2)); 1139 elf_section_data (target_sect)->rel_hdr2 = hdr2; 1140 } 1141 *hdr2 = *hdr; 1142 elf_elfsections (abfd)[shindex] = hdr2; 1143 target_sect->reloc_count += hdr->sh_size / hdr->sh_entsize; 1144 target_sect->flags |= SEC_RELOC; 1145 target_sect->relocation = NULL; 1146 target_sect->rel_filepos = hdr->sh_offset; 1147 abfd->flags |= HAS_RELOC; 1148 return true; 1149 } 1150 break; 1151 1152 case SHT_GNU_verdef: 1153 elf_dynverdef (abfd) = shindex; 1154 elf_tdata (abfd)->dynverdef_hdr = *hdr; 1155 return _bfd_elf_make_section_from_shdr (abfd, hdr, name); 1156 break; 1157 1158 case SHT_GNU_versym: 1159 elf_dynversym (abfd) = shindex; 1160 elf_tdata (abfd)->dynversym_hdr = *hdr; 1161 return _bfd_elf_make_section_from_shdr (abfd, hdr, name); 1162 break; 1163 1164 case SHT_GNU_verneed: 1165 elf_dynverref (abfd) = shindex; 1166 elf_tdata (abfd)->dynverref_hdr = *hdr; 1167 return _bfd_elf_make_section_from_shdr (abfd, hdr, name); 1168 break; 1169 1170 case SHT_SHLIB: 1171 return true; 1172 1173 default: 1174 /* Check for any processor-specific section types. */ 1175 { 1176 if (bed->elf_backend_section_from_shdr) 1177 (*bed->elf_backend_section_from_shdr) (abfd, hdr, name); 1178 } 1179 break; 1180 } 1181 1182 return true; 1183} 1184 1185/* Given an ELF section number, retrieve the corresponding BFD 1186 section. */ 1187 1188asection * 1189bfd_section_from_elf_index (abfd, index) 1190 bfd *abfd; 1191 unsigned int index; 1192{ 1193 BFD_ASSERT (index > 0 && index < SHN_LORESERVE); 1194 if (index >= elf_elfheader (abfd)->e_shnum) 1195 return NULL; 1196 return elf_elfsections (abfd)[index]->bfd_section; 1197} 1198 1199boolean 1200_bfd_elf_new_section_hook (abfd, sec) 1201 bfd *abfd; 1202 asection *sec; 1203{ 1204 struct bfd_elf_section_data *sdata; 1205 1206 sdata = (struct bfd_elf_section_data *) bfd_alloc (abfd, sizeof (*sdata)); 1207 if (!sdata) 1208 return false; 1209 sec->used_by_bfd = (PTR) sdata; 1210 memset (sdata, 0, sizeof (*sdata)); 1211 return true; 1212} 1213 1214/* Create a new bfd section from an ELF program header. 1215 1216 Since program segments have no names, we generate a synthetic name 1217 of the form segment<NUM>, where NUM is generally the index in the 1218 program header table. For segments that are split (see below) we 1219 generate the names segment<NUM>a and segment<NUM>b. 1220 1221 Note that some program segments may have a file size that is different than 1222 (less than) the memory size. All this means is that at execution the 1223 system must allocate the amount of memory specified by the memory size, 1224 but only initialize it with the first "file size" bytes read from the 1225 file. This would occur for example, with program segments consisting 1226 of combined data+bss. 1227 1228 To handle the above situation, this routine generates TWO bfd sections 1229 for the single program segment. The first has the length specified by 1230 the file size of the segment, and the second has the length specified 1231 by the difference between the two sizes. In effect, the segment is split 1232 into it's initialized and uninitialized parts. 1233 1234 */ 1235 1236boolean 1237bfd_section_from_phdr (abfd, hdr, index) 1238 bfd *abfd; 1239 Elf_Internal_Phdr *hdr; 1240 int index; 1241{ 1242 asection *newsect; 1243 char *name; 1244 char namebuf[64]; 1245 int split; 1246 1247 split = ((hdr->p_memsz > 0) && 1248 (hdr->p_filesz > 0) && 1249 (hdr->p_memsz > hdr->p_filesz)); 1250 sprintf (namebuf, split ? "segment%da" : "segment%d", index); 1251 name = bfd_alloc (abfd, strlen (namebuf) + 1); 1252 if (!name) 1253 return false; 1254 strcpy (name, namebuf); 1255 newsect = bfd_make_section (abfd, name); 1256 if (newsect == NULL) 1257 return false; 1258 newsect->vma = hdr->p_vaddr; 1259 newsect->lma = hdr->p_paddr; 1260 newsect->_raw_size = hdr->p_filesz; 1261 newsect->filepos = hdr->p_offset; 1262 newsect->flags |= SEC_HAS_CONTENTS; 1263 if (hdr->p_type == PT_LOAD) 1264 { 1265 newsect->flags |= SEC_ALLOC; 1266 newsect->flags |= SEC_LOAD; 1267 if (hdr->p_flags & PF_X) 1268 { 1269 /* FIXME: all we known is that it has execute PERMISSION, 1270 may be data. */ 1271 newsect->flags |= SEC_CODE; 1272 } 1273 } 1274 if (!(hdr->p_flags & PF_W)) 1275 { 1276 newsect->flags |= SEC_READONLY; 1277 } 1278 1279 if (split) 1280 { 1281 sprintf (namebuf, "segment%db", index); 1282 name = bfd_alloc (abfd, strlen (namebuf) + 1); 1283 if (!name) 1284 return false; 1285 strcpy (name, namebuf); 1286 newsect = bfd_make_section (abfd, name); 1287 if (newsect == NULL) 1288 return false; 1289 newsect->vma = hdr->p_vaddr + hdr->p_filesz; 1290 newsect->lma = hdr->p_paddr + hdr->p_filesz; 1291 newsect->_raw_size = hdr->p_memsz - hdr->p_filesz; 1292 if (hdr->p_type == PT_LOAD) 1293 { 1294 newsect->flags |= SEC_ALLOC; 1295 if (hdr->p_flags & PF_X) 1296 newsect->flags |= SEC_CODE; 1297 } 1298 if (!(hdr->p_flags & PF_W)) 1299 newsect->flags |= SEC_READONLY; 1300 } 1301 1302 return true; 1303} 1304 1305/* Set up an ELF internal section header for a section. */ 1306 1307/*ARGSUSED*/ 1308static void 1309elf_fake_sections (abfd, asect, failedptrarg) 1310 bfd *abfd; 1311 asection *asect; 1312 PTR failedptrarg; 1313{ 1314 struct elf_backend_data *bed = get_elf_backend_data (abfd); 1315 boolean *failedptr = (boolean *) failedptrarg; 1316 Elf_Internal_Shdr *this_hdr; 1317 1318 if (*failedptr) 1319 { 1320 /* We already failed; just get out of the bfd_map_over_sections 1321 loop. */ 1322 return; 1323 } 1324 1325 this_hdr = &elf_section_data (asect)->this_hdr; 1326 1327 this_hdr->sh_name = (unsigned long) _bfd_stringtab_add (elf_shstrtab (abfd), 1328 asect->name, 1329 true, false); 1330 if (this_hdr->sh_name == (unsigned long) -1) 1331 { 1332 *failedptr = true; 1333 return; 1334 } 1335 1336 this_hdr->sh_flags = 0; 1337 1338 if ((asect->flags & SEC_ALLOC) != 0 1339 || asect->user_set_vma) 1340 this_hdr->sh_addr = asect->vma; 1341 else 1342 this_hdr->sh_addr = 0; 1343 1344 this_hdr->sh_offset = 0; 1345 this_hdr->sh_size = asect->_raw_size; 1346 this_hdr->sh_link = 0; 1347 this_hdr->sh_addralign = 1 << asect->alignment_power; 1348 /* The sh_entsize and sh_info fields may have been set already by 1349 copy_private_section_data. */ 1350 1351 this_hdr->bfd_section = asect; 1352 this_hdr->contents = NULL; 1353 1354 /* FIXME: This should not be based on section names. */ 1355 if (strcmp (asect->name, ".dynstr") == 0) 1356 this_hdr->sh_type = SHT_STRTAB; 1357 else if (strcmp (asect->name, ".hash") == 0) 1358 { 1359 this_hdr->sh_type = SHT_HASH; 1360 this_hdr->sh_entsize = bed->s->arch_size / 8; 1361 } 1362 else if (strcmp (asect->name, ".dynsym") == 0) 1363 { 1364 this_hdr->sh_type = SHT_DYNSYM; 1365 this_hdr->sh_entsize = bed->s->sizeof_sym; 1366 } 1367 else if (strcmp (asect->name, ".dynamic") == 0) 1368 { 1369 this_hdr->sh_type = SHT_DYNAMIC; 1370 this_hdr->sh_entsize = bed->s->sizeof_dyn; 1371 } 1372 else if (strncmp (asect->name, ".rela", 5) == 0 1373 && get_elf_backend_data (abfd)->use_rela_p) 1374 { 1375 this_hdr->sh_type = SHT_RELA; 1376 this_hdr->sh_entsize = bed->s->sizeof_rela; 1377 } 1378 else if (strncmp (asect->name, ".rel", 4) == 0 1379 && ! get_elf_backend_data (abfd)->use_rela_p) 1380 { 1381 this_hdr->sh_type = SHT_REL; 1382 this_hdr->sh_entsize = bed->s->sizeof_rel; 1383 } 1384 else if (strncmp (asect->name, ".note", 5) == 0) 1385 this_hdr->sh_type = SHT_NOTE; 1386 else if (strncmp (asect->name, ".stab", 5) == 0 1387 && strcmp (asect->name + strlen (asect->name) - 3, "str") == 0) 1388 this_hdr->sh_type = SHT_STRTAB; 1389 else if (strcmp (asect->name, ".gnu.version") == 0) 1390 { 1391 this_hdr->sh_type = SHT_GNU_versym; 1392 this_hdr->sh_entsize = sizeof (Elf_External_Versym); 1393 } 1394 else if (strcmp (asect->name, ".gnu.version_d") == 0) 1395 { 1396 this_hdr->sh_type = SHT_GNU_verdef; 1397 this_hdr->sh_entsize = 0; 1398 /* objcopy or strip will copy over sh_info, but may not set 1399 cverdefs. The linker will set cverdefs, but sh_info will be 1400 zero. */ 1401 if (this_hdr->sh_info == 0) 1402 this_hdr->sh_info = elf_tdata (abfd)->cverdefs; 1403 else 1404 BFD_ASSERT (elf_tdata (abfd)->cverdefs == 0 1405 || this_hdr->sh_info == elf_tdata (abfd)->cverdefs); 1406 } 1407 else if (strcmp (asect->name, ".gnu.version_r") == 0) 1408 { 1409 this_hdr->sh_type = SHT_GNU_verneed; 1410 this_hdr->sh_entsize = 0; 1411 /* objcopy or strip will copy over sh_info, but may not set 1412 cverrefs. The linker will set cverrefs, but sh_info will be 1413 zero. */ 1414 if (this_hdr->sh_info == 0) 1415 this_hdr->sh_info = elf_tdata (abfd)->cverrefs; 1416 else 1417 BFD_ASSERT (elf_tdata (abfd)->cverrefs == 0 1418 || this_hdr->sh_info == elf_tdata (abfd)->cverrefs); 1419 } 1420 else if ((asect->flags & SEC_ALLOC) != 0 1421 && (asect->flags & SEC_LOAD) != 0) 1422 this_hdr->sh_type = SHT_PROGBITS; 1423 else if ((asect->flags & SEC_ALLOC) != 0 1424 && ((asect->flags & SEC_LOAD) == 0)) 1425 this_hdr->sh_type = SHT_NOBITS; 1426 else 1427 { 1428 /* Who knows? */ 1429 this_hdr->sh_type = SHT_PROGBITS; 1430 } 1431 1432 if ((asect->flags & SEC_ALLOC) != 0) 1433 this_hdr->sh_flags |= SHF_ALLOC; 1434 if ((asect->flags & SEC_READONLY) == 0) 1435 this_hdr->sh_flags |= SHF_WRITE; 1436 if ((asect->flags & SEC_CODE) != 0) 1437 this_hdr->sh_flags |= SHF_EXECINSTR; 1438 1439 /* Check for processor-specific section types. */ 1440 { 1441 struct elf_backend_data *bed = get_elf_backend_data (abfd); 1442 1443 if (bed->elf_backend_fake_sections) 1444 (*bed->elf_backend_fake_sections) (abfd, this_hdr, asect); 1445 } 1446 1447 /* If the section has relocs, set up a section header for the 1448 SHT_REL[A] section. */ 1449 if ((asect->flags & SEC_RELOC) != 0) 1450 { 1451 Elf_Internal_Shdr *rela_hdr; 1452 int use_rela_p = get_elf_backend_data (abfd)->use_rela_p; 1453 char *name; 1454 1455 rela_hdr = &elf_section_data (asect)->rel_hdr; 1456 name = bfd_alloc (abfd, sizeof ".rela" + strlen (asect->name)); 1457 if (name == NULL) 1458 { 1459 *failedptr = true; 1460 return; 1461 } 1462 sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", asect->name); 1463 rela_hdr->sh_name = 1464 (unsigned int) _bfd_stringtab_add (elf_shstrtab (abfd), name, 1465 true, false); 1466 if (rela_hdr->sh_name == (unsigned int) -1) 1467 { 1468 *failedptr = true; 1469 return; 1470 } 1471 rela_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL; 1472 rela_hdr->sh_entsize = (use_rela_p 1473 ? bed->s->sizeof_rela 1474 : bed->s->sizeof_rel); 1475 rela_hdr->sh_addralign = bed->s->file_align; 1476 rela_hdr->sh_flags = 0; 1477 rela_hdr->sh_addr = 0; 1478 rela_hdr->sh_size = 0; 1479 rela_hdr->sh_offset = 0; 1480 } 1481} 1482 1483/* Assign all ELF section numbers. The dummy first section is handled here 1484 too. The link/info pointers for the standard section types are filled 1485 in here too, while we're at it. */ 1486 1487static boolean 1488assign_section_numbers (abfd) 1489 bfd *abfd; 1490{ 1491 struct elf_obj_tdata *t = elf_tdata (abfd); 1492 asection *sec; 1493 unsigned int section_number; 1494 Elf_Internal_Shdr **i_shdrp; 1495 struct elf_backend_data *bed = get_elf_backend_data (abfd); 1496 1497 section_number = 1; 1498 1499 for (sec = abfd->sections; sec; sec = sec->next) 1500 { 1501 struct bfd_elf_section_data *d = elf_section_data (sec); 1502 1503 d->this_idx = section_number++; 1504 if ((sec->flags & SEC_RELOC) == 0) 1505 d->rel_idx = 0; 1506 else 1507 d->rel_idx = section_number++; 1508 } 1509 1510 t->shstrtab_section = section_number++; 1511 elf_elfheader (abfd)->e_shstrndx = t->shstrtab_section; 1512 t->shstrtab_hdr.sh_size = _bfd_stringtab_size (elf_shstrtab (abfd)); 1513 1514 if (abfd->symcount > 0) 1515 { 1516 t->symtab_section = section_number++; 1517 t->strtab_section = section_number++; 1518 } 1519 1520 elf_elfheader (abfd)->e_shnum = section_number; 1521 1522 /* Set up the list of section header pointers, in agreement with the 1523 indices. */ 1524 i_shdrp = ((Elf_Internal_Shdr **) 1525 bfd_alloc (abfd, section_number * sizeof (Elf_Internal_Shdr *))); 1526 if (i_shdrp == NULL) 1527 return false; 1528 1529 i_shdrp[0] = ((Elf_Internal_Shdr *) 1530 bfd_alloc (abfd, sizeof (Elf_Internal_Shdr))); 1531 if (i_shdrp[0] == NULL) 1532 { 1533 bfd_release (abfd, i_shdrp); 1534 return false; 1535 } 1536 memset (i_shdrp[0], 0, sizeof (Elf_Internal_Shdr)); 1537 1538 elf_elfsections (abfd) = i_shdrp; 1539 1540 i_shdrp[t->shstrtab_section] = &t->shstrtab_hdr; 1541 if (abfd->symcount > 0) 1542 { 1543 i_shdrp[t->symtab_section] = &t->symtab_hdr; 1544 i_shdrp[t->strtab_section] = &t->strtab_hdr; 1545 t->symtab_hdr.sh_link = t->strtab_section; 1546 } 1547 for (sec = abfd->sections; sec; sec = sec->next) 1548 { 1549 struct bfd_elf_section_data *d = elf_section_data (sec); 1550 asection *s; 1551 const char *name; 1552 1553 i_shdrp[d->this_idx] = &d->this_hdr; 1554 if (d->rel_idx != 0) 1555 i_shdrp[d->rel_idx] = &d->rel_hdr; 1556 1557 /* Fill in the sh_link and sh_info fields while we're at it. */ 1558 1559 /* sh_link of a reloc section is the section index of the symbol 1560 table. sh_info is the section index of the section to which 1561 the relocation entries apply. */ 1562 if (d->rel_idx != 0) 1563 { 1564 d->rel_hdr.sh_link = t->symtab_section; 1565 d->rel_hdr.sh_info = d->this_idx; 1566 } 1567 1568 switch (d->this_hdr.sh_type) 1569 { 1570 case SHT_REL: 1571 case SHT_RELA: 1572 /* A reloc section which we are treating as a normal BFD 1573 section. sh_link is the section index of the symbol 1574 table. sh_info is the section index of the section to 1575 which the relocation entries apply. We assume that an 1576 allocated reloc section uses the dynamic symbol table. 1577 FIXME: How can we be sure? */ 1578 s = bfd_get_section_by_name (abfd, ".dynsym"); 1579 if (s != NULL) 1580 d->this_hdr.sh_link = elf_section_data (s)->this_idx; 1581 1582 /* We look up the section the relocs apply to by name. */ 1583 name = sec->name; 1584 if (d->this_hdr.sh_type == SHT_REL) 1585 name += 4; 1586 else 1587 name += 5; 1588 s = bfd_get_section_by_name (abfd, name); 1589 if (s != NULL) 1590 d->this_hdr.sh_info = elf_section_data (s)->this_idx; 1591 break; 1592 1593 case SHT_STRTAB: 1594 /* We assume that a section named .stab*str is a stabs 1595 string section. We look for a section with the same name 1596 but without the trailing ``str'', and set its sh_link 1597 field to point to this section. */ 1598 if (strncmp (sec->name, ".stab", sizeof ".stab" - 1) == 0 1599 && strcmp (sec->name + strlen (sec->name) - 3, "str") == 0) 1600 { 1601 size_t len; 1602 char *alc; 1603 1604 len = strlen (sec->name); 1605 alc = (char *) bfd_malloc (len - 2); 1606 if (alc == NULL) 1607 return false; 1608 strncpy (alc, sec->name, len - 3); 1609 alc[len - 3] = '\0'; 1610 s = bfd_get_section_by_name (abfd, alc); 1611 free (alc); 1612 if (s != NULL) 1613 { 1614 elf_section_data (s)->this_hdr.sh_link = d->this_idx; 1615 1616 /* This is a .stab section. */ 1617 elf_section_data (s)->this_hdr.sh_entsize = 1618 4 + 2 * (bed->s->arch_size / 8); 1619 } 1620 } 1621 break; 1622 1623 case SHT_DYNAMIC: 1624 case SHT_DYNSYM: 1625 case SHT_GNU_verneed: 1626 case SHT_GNU_verdef: 1627 /* sh_link is the section header index of the string table 1628 used for the dynamic entries, or the symbol table, or the 1629 version strings. */ 1630 s = bfd_get_section_by_name (abfd, ".dynstr"); 1631 if (s != NULL) 1632 d->this_hdr.sh_link = elf_section_data (s)->this_idx; 1633 break; 1634 1635 case SHT_HASH: 1636 case SHT_GNU_versym: 1637 /* sh_link is the section header index of the symbol table 1638 this hash table or version table is for. */ 1639 s = bfd_get_section_by_name (abfd, ".dynsym"); 1640 if (s != NULL) 1641 d->this_hdr.sh_link = elf_section_data (s)->this_idx; 1642 break; 1643 } 1644 } 1645 1646 return true; 1647} 1648 1649/* Map symbol from it's internal number to the external number, moving 1650 all local symbols to be at the head of the list. */ 1651 1652static INLINE int 1653sym_is_global (abfd, sym) 1654 bfd *abfd; 1655 asymbol *sym; 1656{ 1657 /* If the backend has a special mapping, use it. */ 1658 if (get_elf_backend_data (abfd)->elf_backend_sym_is_global) 1659 return ((*get_elf_backend_data (abfd)->elf_backend_sym_is_global) 1660 (abfd, sym)); 1661 1662 return ((sym->flags & (BSF_GLOBAL | BSF_WEAK)) != 0 1663 || bfd_is_und_section (bfd_get_section (sym)) 1664 || bfd_is_com_section (bfd_get_section (sym))); 1665} 1666 1667static boolean 1668elf_map_symbols (abfd) 1669 bfd *abfd; 1670{ 1671 int symcount = bfd_get_symcount (abfd); 1672 asymbol **syms = bfd_get_outsymbols (abfd); 1673 asymbol **sect_syms; 1674 int num_locals = 0; 1675 int num_globals = 0; 1676 int num_locals2 = 0; 1677 int num_globals2 = 0; 1678 int max_index = 0; 1679 int num_sections = 0; 1680 int idx; 1681 asection *asect; 1682 asymbol **new_syms; 1683 1684#ifdef DEBUG 1685 fprintf (stderr, "elf_map_symbols\n"); 1686 fflush (stderr); 1687#endif 1688 1689 /* Add a section symbol for each BFD section. FIXME: Is this really 1690 necessary? */ 1691 for (asect = abfd->sections; asect; asect = asect->next) 1692 { 1693 if (max_index < asect->index) 1694 max_index = asect->index; 1695 } 1696 1697 max_index++; 1698 sect_syms = (asymbol **) bfd_zalloc (abfd, max_index * sizeof (asymbol *)); 1699 if (sect_syms == NULL) 1700 return false; 1701 elf_section_syms (abfd) = sect_syms; 1702 1703 for (idx = 0; idx < symcount; idx++) 1704 { 1705 if ((syms[idx]->flags & BSF_SECTION_SYM) != 0 1706 && (syms[idx]->value + syms[idx]->section->vma) == 0) 1707 { 1708 asection *sec; 1709 1710 sec = syms[idx]->section; 1711 if (sec->owner != NULL) 1712 { 1713 if (sec->owner != abfd) 1714 { 1715 if (sec->output_offset != 0) 1716 continue; 1717 sec = sec->output_section; 1718 BFD_ASSERT (sec->owner == abfd); 1719 } 1720 sect_syms[sec->index] = syms[idx]; 1721 } 1722 } 1723 } 1724 1725 for (asect = abfd->sections; asect; asect = asect->next) 1726 { 1727 asymbol *sym; 1728 1729 if (sect_syms[asect->index] != NULL) 1730 continue; 1731 1732 sym = bfd_make_empty_symbol (abfd); 1733 if (sym == NULL) 1734 return false; 1735 sym->the_bfd = abfd; 1736 sym->name = asect->name; 1737 sym->value = 0; 1738 /* Set the flags to 0 to indicate that this one was newly added. */ 1739 sym->flags = 0; 1740 sym->section = asect; 1741 sect_syms[asect->index] = sym; 1742 num_sections++; 1743#ifdef DEBUG 1744 fprintf (stderr, 1745 "creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n", 1746 asect->name, (long) asect->vma, asect->index, (long) asect); 1747#endif 1748 } 1749 1750 /* Classify all of the symbols. */ 1751 for (idx = 0; idx < symcount; idx++) 1752 { 1753 if (!sym_is_global (abfd, syms[idx])) 1754 num_locals++; 1755 else 1756 num_globals++; 1757 } 1758 for (asect = abfd->sections; asect; asect = asect->next) 1759 { 1760 if (sect_syms[asect->index] != NULL 1761 && sect_syms[asect->index]->flags == 0) 1762 { 1763 sect_syms[asect->index]->flags = BSF_SECTION_SYM; 1764 if (!sym_is_global (abfd, sect_syms[asect->index])) 1765 num_locals++; 1766 else 1767 num_globals++; 1768 sect_syms[asect->index]->flags = 0; 1769 } 1770 } 1771 1772 /* Now sort the symbols so the local symbols are first. */ 1773 new_syms = ((asymbol **) 1774 bfd_alloc (abfd, 1775 (num_locals + num_globals) * sizeof (asymbol *))); 1776 if (new_syms == NULL) 1777 return false; 1778 1779 for (idx = 0; idx < symcount; idx++) 1780 { 1781 asymbol *sym = syms[idx]; 1782 int i; 1783 1784 if (!sym_is_global (abfd, sym)) 1785 i = num_locals2++; 1786 else 1787 i = num_locals + num_globals2++; 1788 new_syms[i] = sym; 1789 sym->udata.i = i + 1; 1790 } 1791 for (asect = abfd->sections; asect; asect = asect->next) 1792 { 1793 if (sect_syms[asect->index] != NULL 1794 && sect_syms[asect->index]->flags == 0) 1795 { 1796 asymbol *sym = sect_syms[asect->index]; 1797 int i; 1798 1799 sym->flags = BSF_SECTION_SYM; 1800 if (!sym_is_global (abfd, sym)) 1801 i = num_locals2++; 1802 else 1803 i = num_locals + num_globals2++; 1804 new_syms[i] = sym; 1805 sym->udata.i = i + 1; 1806 } 1807 } 1808 1809 bfd_set_symtab (abfd, new_syms, num_locals + num_globals); 1810 1811 elf_num_locals (abfd) = num_locals; 1812 elf_num_globals (abfd) = num_globals; 1813 return true; 1814} 1815 1816/* Align to the maximum file alignment that could be required for any 1817 ELF data structure. */ 1818 1819static INLINE file_ptr align_file_position PARAMS ((file_ptr, int)); 1820static INLINE file_ptr 1821align_file_position (off, align) 1822 file_ptr off; 1823 int align; 1824{ 1825 return (off + align - 1) & ~(align - 1); 1826} 1827 1828/* Assign a file position to a section, optionally aligning to the 1829 required section alignment. */ 1830 1831INLINE file_ptr 1832_bfd_elf_assign_file_position_for_section (i_shdrp, offset, align) 1833 Elf_Internal_Shdr *i_shdrp; 1834 file_ptr offset; 1835 boolean align; 1836{ 1837 if (align) 1838 { 1839 unsigned int al; 1840 1841 al = i_shdrp->sh_addralign; 1842 if (al > 1) 1843 offset = BFD_ALIGN (offset, al); 1844 } 1845 i_shdrp->sh_offset = offset; 1846 if (i_shdrp->bfd_section != NULL) 1847 i_shdrp->bfd_section->filepos = offset; 1848 if (i_shdrp->sh_type != SHT_NOBITS) 1849 offset += i_shdrp->sh_size; 1850 return offset; 1851} 1852 1853/* Compute the file positions we are going to put the sections at, and 1854 otherwise prepare to begin writing out the ELF file. If LINK_INFO 1855 is not NULL, this is being called by the ELF backend linker. */ 1856 1857boolean 1858_bfd_elf_compute_section_file_positions (abfd, link_info) 1859 bfd *abfd; 1860 struct bfd_link_info *link_info; 1861{ 1862 struct elf_backend_data *bed = get_elf_backend_data (abfd); 1863 boolean failed; 1864 struct bfd_strtab_hash *strtab; 1865 Elf_Internal_Shdr *shstrtab_hdr; 1866 1867 if (abfd->output_has_begun) 1868 return true; 1869 1870 /* Do any elf backend specific processing first. */ 1871 if (bed->elf_backend_begin_write_processing) 1872 (*bed->elf_backend_begin_write_processing) (abfd, link_info); 1873 1874 if (! prep_headers (abfd)) 1875 return false; 1876 1877 failed = false; 1878 bfd_map_over_sections (abfd, elf_fake_sections, &failed); 1879 if (failed) 1880 return false; 1881 1882 if (!assign_section_numbers (abfd)) 1883 return false; 1884 1885 /* The backend linker builds symbol table information itself. */ 1886 if (link_info == NULL && abfd->symcount > 0) 1887 { 1888 if (! swap_out_syms (abfd, &strtab)) 1889 return false; 1890 } 1891 1892 shstrtab_hdr = &elf_tdata (abfd)->shstrtab_hdr; 1893 /* sh_name was set in prep_headers. */ 1894 shstrtab_hdr->sh_type = SHT_STRTAB; 1895 shstrtab_hdr->sh_flags = 0; 1896 shstrtab_hdr->sh_addr = 0; 1897 shstrtab_hdr->sh_size = _bfd_stringtab_size (elf_shstrtab (abfd)); 1898 shstrtab_hdr->sh_entsize = 0; 1899 shstrtab_hdr->sh_link = 0; 1900 shstrtab_hdr->sh_info = 0; 1901 /* sh_offset is set in assign_file_positions_except_relocs. */ 1902 shstrtab_hdr->sh_addralign = 1; 1903 1904 if (!assign_file_positions_except_relocs (abfd)) 1905 return false; 1906 1907 if (link_info == NULL && abfd->symcount > 0) 1908 { 1909 file_ptr off; 1910 Elf_Internal_Shdr *hdr; 1911 1912 off = elf_tdata (abfd)->next_file_pos; 1913 1914 hdr = &elf_tdata (abfd)->symtab_hdr; 1915 off = _bfd_elf_assign_file_position_for_section (hdr, off, true); 1916 1917 hdr = &elf_tdata (abfd)->strtab_hdr; 1918 off = _bfd_elf_assign_file_position_for_section (hdr, off, true); 1919 1920 elf_tdata (abfd)->next_file_pos = off; 1921 1922 /* Now that we know where the .strtab section goes, write it 1923 out. */ 1924 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0 1925 || ! _bfd_stringtab_emit (abfd, strtab)) 1926 return false; 1927 _bfd_stringtab_free (strtab); 1928 } 1929 1930 abfd->output_has_begun = true; 1931 1932 return true; 1933} 1934 1935/* Create a mapping from a set of sections to a program segment. */ 1936 1937static INLINE struct elf_segment_map * 1938make_mapping (abfd, sections, from, to, phdr) 1939 bfd *abfd; 1940 asection **sections; 1941 unsigned int from; 1942 unsigned int to; 1943 boolean phdr; 1944{ 1945 struct elf_segment_map *m; 1946 unsigned int i; 1947 asection **hdrpp; 1948 1949 m = ((struct elf_segment_map *) 1950 bfd_zalloc (abfd, 1951 (sizeof (struct elf_segment_map) 1952 + (to - from - 1) * sizeof (asection *)))); 1953 if (m == NULL) 1954 return NULL; 1955 m->next = NULL; 1956 m->p_type = PT_LOAD; 1957 for (i = from, hdrpp = sections + from; i < to; i++, hdrpp++) 1958 m->sections[i - from] = *hdrpp; 1959 m->count = to - from; 1960 1961 if (from == 0 && phdr) 1962 { 1963 /* Include the headers in the first PT_LOAD segment. */ 1964 m->includes_filehdr = 1; 1965 m->includes_phdrs = 1; 1966 } 1967 1968 return m; 1969} 1970 1971/* Set up a mapping from BFD sections to program segments. */ 1972 1973static boolean 1974map_sections_to_segments (abfd) 1975 bfd *abfd; 1976{ 1977 asection **sections = NULL; 1978 asection *s; 1979 unsigned int i; 1980 unsigned int count; 1981 struct elf_segment_map *mfirst; 1982 struct elf_segment_map **pm; 1983 struct elf_segment_map *m; 1984 asection *last_hdr; 1985 unsigned int phdr_index; 1986 bfd_vma maxpagesize; 1987 asection **hdrpp; 1988 boolean phdr_in_section = true; 1989 boolean writable; 1990 asection *dynsec; 1991 1992 if (elf_tdata (abfd)->segment_map != NULL) 1993 return true; 1994 1995 if (bfd_count_sections (abfd) == 0) 1996 return true; 1997 1998 /* Select the allocated sections, and sort them. */ 1999 2000 sections = (asection **) bfd_malloc (bfd_count_sections (abfd) 2001 * sizeof (asection *)); 2002 if (sections == NULL) 2003 goto error_return; 2004 2005 i = 0; 2006 for (s = abfd->sections; s != NULL; s = s->next) 2007 { 2008 if ((s->flags & SEC_ALLOC) != 0) 2009 { 2010 sections[i] = s; 2011 ++i; 2012 } 2013 } 2014 BFD_ASSERT (i <= bfd_count_sections (abfd)); 2015 count = i; 2016 2017 qsort (sections, (size_t) count, sizeof (asection *), elf_sort_sections); 2018 2019 /* Build the mapping. */ 2020 2021 mfirst = NULL; 2022 pm = &mfirst; 2023 2024 /* If we have a .interp section, then create a PT_PHDR segment for 2025 the program headers and a PT_INTERP segment for the .interp 2026 section. */ 2027 s = bfd_get_section_by_name (abfd, ".interp"); 2028 if (s != NULL && (s->flags & SEC_LOAD) != 0) 2029 { 2030 m = ((struct elf_segment_map *) 2031 bfd_zalloc (abfd, sizeof (struct elf_segment_map))); 2032 if (m == NULL) 2033 goto error_return; 2034 m->next = NULL; 2035 m->p_type = PT_PHDR; 2036 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */ 2037 m->p_flags = PF_R | PF_X; 2038 m->p_flags_valid = 1; 2039 m->includes_phdrs = 1; 2040 2041 *pm = m; 2042 pm = &m->next; 2043 2044 m = ((struct elf_segment_map *) 2045 bfd_zalloc (abfd, sizeof (struct elf_segment_map))); 2046 if (m == NULL) 2047 goto error_return; 2048 m->next = NULL; 2049 m->p_type = PT_INTERP; 2050 m->count = 1; 2051 m->sections[0] = s; 2052 2053 *pm = m; 2054 pm = &m->next; 2055 } 2056 2057 /* Look through the sections. We put sections in the same program 2058 segment when the start of the second section can be placed within 2059 a few bytes of the end of the first section. */ 2060 last_hdr = NULL; 2061 phdr_index = 0; 2062 maxpagesize = get_elf_backend_data (abfd)->maxpagesize; 2063 writable = false; 2064 dynsec = bfd_get_section_by_name (abfd, ".dynamic"); 2065 if (dynsec != NULL 2066 && (dynsec->flags & SEC_LOAD) == 0) 2067 dynsec = NULL; 2068 2069 /* Deal with -Ttext or something similar such that the first section 2070 is not adjacent to the program headers. This is an 2071 approximation, since at this point we don't know exactly how many 2072 program headers we will need. */ 2073 if (count > 0) 2074 { 2075 bfd_size_type phdr_size; 2076 2077 phdr_size = elf_tdata (abfd)->program_header_size; 2078 if (phdr_size == 0) 2079 phdr_size = get_elf_backend_data (abfd)->s->sizeof_phdr; 2080 if ((abfd->flags & D_PAGED) == 0 2081 || sections[0]->lma % maxpagesize < phdr_size % maxpagesize) 2082 phdr_in_section = false; 2083 } 2084 2085 for (i = 0, hdrpp = sections; i < count; i++, hdrpp++) 2086 { 2087 asection *hdr; 2088 boolean new_segment; 2089 2090 hdr = *hdrpp; 2091 2092 /* See if this section and the last one will fit in the same 2093 segment. */ 2094 2095 if (last_hdr == NULL) 2096 { 2097 /* If we don't have a segment yet, then we don't need a new 2098 one (we build the last one after this loop). */ 2099 new_segment = false; 2100 } 2101 else if (last_hdr->lma - last_hdr->vma != hdr->lma - hdr->vma) 2102 { 2103 /* If this section has a different relation between the 2104 virtual address and the load address, then we need a new 2105 segment. */ 2106 new_segment = true; 2107 } 2108 else if (BFD_ALIGN (last_hdr->lma + last_hdr->_raw_size, maxpagesize) 2109 < hdr->lma) 2110 { 2111 /* If putting this section in this segment would force us to 2112 skip a page in the segment, then we need a new segment. */ 2113 new_segment = true; 2114 } 2115 else if ((abfd->flags & D_PAGED) == 0) 2116 { 2117 /* If the file is not demand paged, which means that we 2118 don't require the sections to be correctly aligned in the 2119 file, then there is no other reason for a new segment. */ 2120 new_segment = false; 2121 } 2122 else if ((last_hdr->flags & SEC_LOAD) == 0 2123 && (hdr->flags & SEC_LOAD) != 0) 2124 { 2125 /* We don't want to put a loadable section after a 2126 nonloadable section in the same segment. */ 2127 new_segment = true; 2128 } 2129 else if (! writable 2130 && (hdr->flags & SEC_READONLY) == 0 2131 && (BFD_ALIGN (last_hdr->lma + last_hdr->_raw_size, maxpagesize) 2132 == hdr->lma)) 2133 { 2134 /* We don't want to put a writable section in a read only 2135 segment, unless they are on the same page in memory 2136 anyhow. We already know that the last section does not 2137 bring us past the current section on the page, so the 2138 only case in which the new section is not on the same 2139 page as the previous section is when the previous section 2140 ends precisely on a page boundary. */ 2141 new_segment = true; 2142 } 2143 else 2144 { 2145 /* Otherwise, we can use the same segment. */ 2146 new_segment = false; 2147 } 2148 2149 if (! new_segment) 2150 { 2151 if ((hdr->flags & SEC_READONLY) == 0) 2152 writable = true; 2153 last_hdr = hdr; 2154 continue; 2155 } 2156 2157 /* We need a new program segment. We must create a new program 2158 header holding all the sections from phdr_index until hdr. */ 2159 2160 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_section); 2161 if (m == NULL) 2162 goto error_return; 2163 2164 *pm = m; 2165 pm = &m->next; 2166 2167 if ((hdr->flags & SEC_READONLY) == 0) 2168 writable = true; 2169 else 2170 writable = false; 2171 2172 last_hdr = hdr; 2173 phdr_index = i; 2174 phdr_in_section = false; 2175 } 2176 2177 /* Create a final PT_LOAD program segment. */ 2178 if (last_hdr != NULL) 2179 { 2180 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_section); 2181 if (m == NULL) 2182 goto error_return; 2183 2184 *pm = m; 2185 pm = &m->next; 2186 } 2187 2188 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */ 2189 if (dynsec != NULL) 2190 { 2191 m = ((struct elf_segment_map *) 2192 bfd_zalloc (abfd, sizeof (struct elf_segment_map))); 2193 if (m == NULL) 2194 goto error_return; 2195 m->next = NULL; 2196 m->p_type = PT_DYNAMIC; 2197 m->count = 1; 2198 m->sections[0] = dynsec; 2199 2200 *pm = m; 2201 pm = &m->next; 2202 } 2203 2204 /* For each loadable .note section, add a PT_NOTE segment. We don't 2205 use bfd_get_section_by_name, because if we link together 2206 nonloadable .note sections and loadable .note sections, we will 2207 generate two .note sections in the output file. FIXME: Using 2208 names for section types is bogus anyhow. */ 2209 for (s = abfd->sections; s != NULL; s = s->next) 2210 { 2211 if ((s->flags & SEC_LOAD) != 0 2212 && strncmp (s->name, ".note", 5) == 0) 2213 { 2214 m = ((struct elf_segment_map *) 2215 bfd_zalloc (abfd, sizeof (struct elf_segment_map))); 2216 if (m == NULL) 2217 goto error_return; 2218 m->next = NULL; 2219 m->p_type = PT_NOTE; 2220 m->count = 1; 2221 m->sections[0] = s; 2222 2223 *pm = m; 2224 pm = &m->next; 2225 } 2226 } 2227 2228 free (sections); 2229 sections = NULL; 2230 2231 elf_tdata (abfd)->segment_map = mfirst; 2232 return true; 2233 2234 error_return: 2235 if (sections != NULL) 2236 free (sections); 2237 return false; 2238} 2239 2240/* Sort sections by VMA. */ 2241 2242static int 2243elf_sort_sections (arg1, arg2) 2244 const PTR arg1; 2245 const PTR arg2; 2246{ 2247 const asection *sec1 = *(const asection **) arg1; 2248 const asection *sec2 = *(const asection **) arg2; 2249 2250 if (sec1->vma < sec2->vma) 2251 return -1; 2252 else if (sec1->vma > sec2->vma) 2253 return 1; 2254 2255 /* Sort by LMA. Normally the LMA and the VMA will be the same, and 2256 this will do nothing. */ 2257 if (sec1->lma < sec2->lma) 2258 return -1; 2259 else if (sec1->lma > sec2->lma) 2260 return 1; 2261 2262 /* Put !SEC_LOAD sections after SEC_LOAD ones. */ 2263 2264#define TOEND(x) (((x)->flags & SEC_LOAD) == 0) 2265 2266 if (TOEND (sec1)) 2267 if (TOEND (sec2)) 2268 return sec1->target_index - sec2->target_index; 2269 else 2270 return 1; 2271 2272 if (TOEND (sec2)) 2273 return -1; 2274 2275#undef TOEND 2276 2277 /* Sort by size, to put zero sized sections before others at the 2278 same address. */ 2279 2280 if (sec1->_raw_size < sec2->_raw_size) 2281 return -1; 2282 if (sec1->_raw_size > sec2->_raw_size) 2283 return 1; 2284 2285 return sec1->target_index - sec2->target_index; 2286} 2287 2288/* Assign file positions to the sections based on the mapping from 2289 sections to segments. This function also sets up some fields in 2290 the file header, and writes out the program headers. */ 2291 2292static boolean 2293assign_file_positions_for_segments (abfd) 2294 bfd *abfd; 2295{ 2296 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 2297 unsigned int count; 2298 struct elf_segment_map *m; 2299 unsigned int alloc; 2300 Elf_Internal_Phdr *phdrs; 2301 file_ptr off, voff; 2302 bfd_vma filehdr_vaddr, filehdr_paddr; 2303 bfd_vma phdrs_vaddr, phdrs_paddr; 2304 Elf_Internal_Phdr *p; 2305 2306 if (elf_tdata (abfd)->segment_map == NULL) 2307 { 2308 if (! map_sections_to_segments (abfd)) 2309 return false; 2310 } 2311 2312 if (bed->elf_backend_modify_segment_map) 2313 { 2314 if (! (*bed->elf_backend_modify_segment_map) (abfd)) 2315 return false; 2316 } 2317 2318 count = 0; 2319 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next) 2320 ++count; 2321 2322 elf_elfheader (abfd)->e_phoff = bed->s->sizeof_ehdr; 2323 elf_elfheader (abfd)->e_phentsize = bed->s->sizeof_phdr; 2324 elf_elfheader (abfd)->e_phnum = count; 2325 2326 if (count == 0) 2327 return true; 2328 2329 /* If we already counted the number of program segments, make sure 2330 that we allocated enough space. This happens when SIZEOF_HEADERS 2331 is used in a linker script. */ 2332 alloc = elf_tdata (abfd)->program_header_size / bed->s->sizeof_phdr; 2333 if (alloc != 0 && count > alloc) 2334 { 2335 ((*_bfd_error_handler) 2336 ("%s: Not enough room for program headers (allocated %u, need %u)", 2337 bfd_get_filename (abfd), alloc, count)); 2338 bfd_set_error (bfd_error_bad_value); 2339 return false; 2340 } 2341 2342 if (alloc == 0) 2343 alloc = count; 2344 2345 phdrs = ((Elf_Internal_Phdr *) 2346 bfd_alloc (abfd, alloc * sizeof (Elf_Internal_Phdr))); 2347 if (phdrs == NULL) 2348 return false; 2349 2350 off = bed->s->sizeof_ehdr; 2351 off += alloc * bed->s->sizeof_phdr; 2352 2353 filehdr_vaddr = 0; 2354 filehdr_paddr = 0; 2355 phdrs_vaddr = 0; 2356 phdrs_paddr = 0; 2357 for (m = elf_tdata (abfd)->segment_map, p = phdrs; 2358 m != NULL; 2359 m = m->next, p++) 2360 { 2361 unsigned int i; 2362 asection **secpp; 2363 2364 /* If elf_segment_map is not from map_sections_to_segments, the 2365 sections may not be correctly ordered. */ 2366 if (m->count > 0) 2367 qsort (m->sections, (size_t) m->count, sizeof (asection *), 2368 elf_sort_sections); 2369 2370 p->p_type = m->p_type; 2371 2372 if (m->p_flags_valid) 2373 p->p_flags = m->p_flags; 2374 else 2375 p->p_flags = 0; 2376 2377 if (p->p_type == PT_LOAD 2378 && m->count > 0 2379 && (m->sections[0]->flags & SEC_ALLOC) != 0) 2380 { 2381 if ((abfd->flags & D_PAGED) != 0) 2382 off += (m->sections[0]->vma - off) % bed->maxpagesize; 2383 else 2384 off += ((m->sections[0]->vma - off) 2385 % (1 << bfd_get_section_alignment (abfd, m->sections[0]))); 2386 } 2387 2388 if (m->count == 0) 2389 p->p_vaddr = 0; 2390 else 2391 p->p_vaddr = m->sections[0]->vma; 2392 2393 if (m->p_paddr_valid) 2394 p->p_paddr = m->p_paddr; 2395 else if (m->count == 0) 2396 p->p_paddr = 0; 2397 else 2398 p->p_paddr = m->sections[0]->lma; 2399 2400 if (p->p_type == PT_LOAD 2401 && (abfd->flags & D_PAGED) != 0) 2402 p->p_align = bed->maxpagesize; 2403 else if (m->count == 0) 2404 p->p_align = bed->s->file_align; 2405 else 2406 p->p_align = 0; 2407 2408 p->p_offset = 0; 2409 p->p_filesz = 0; 2410 p->p_memsz = 0; 2411 2412 if (m->includes_filehdr) 2413 { 2414 if (! m->p_flags_valid) 2415 p->p_flags |= PF_R; 2416 p->p_offset = 0; 2417 p->p_filesz = bed->s->sizeof_ehdr; 2418 p->p_memsz = bed->s->sizeof_ehdr; 2419 if (m->count > 0) 2420 { 2421 BFD_ASSERT (p->p_type == PT_LOAD); 2422 p->p_vaddr -= off; 2423 if (! m->p_paddr_valid) 2424 p->p_paddr -= off; 2425 } 2426 if (p->p_type == PT_LOAD) 2427 { 2428 filehdr_vaddr = p->p_vaddr; 2429 filehdr_paddr = p->p_paddr; 2430 } 2431 } 2432 2433 if (m->includes_phdrs) 2434 { 2435 if (! m->p_flags_valid) 2436 p->p_flags |= PF_R; 2437 if (m->includes_filehdr) 2438 { 2439 if (p->p_type == PT_LOAD) 2440 { 2441 phdrs_vaddr = p->p_vaddr + bed->s->sizeof_ehdr; 2442 phdrs_paddr = p->p_paddr + bed->s->sizeof_ehdr; 2443 } 2444 } 2445 else 2446 { 2447 p->p_offset = bed->s->sizeof_ehdr; 2448 if (m->count > 0) 2449 { 2450 BFD_ASSERT (p->p_type == PT_LOAD); 2451 p->p_vaddr -= off - p->p_offset; 2452 if (! m->p_paddr_valid) 2453 p->p_paddr -= off - p->p_offset; 2454 } 2455 if (p->p_type == PT_LOAD) 2456 { 2457 phdrs_vaddr = p->p_vaddr; 2458 phdrs_paddr = p->p_paddr; 2459 } 2460 } 2461 p->p_filesz += alloc * bed->s->sizeof_phdr; 2462 p->p_memsz += alloc * bed->s->sizeof_phdr; 2463 } 2464 2465 if (p->p_type == PT_LOAD) 2466 { 2467 if (! m->includes_filehdr && ! m->includes_phdrs) 2468 p->p_offset = off; 2469 else 2470 { 2471 file_ptr adjust; 2472 2473 adjust = off - (p->p_offset + p->p_filesz); 2474 p->p_filesz += adjust; 2475 p->p_memsz += adjust; 2476 } 2477 } 2478 2479 voff = off; 2480 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++) 2481 { 2482 asection *sec; 2483 flagword flags; 2484 bfd_size_type align; 2485 2486 sec = *secpp; 2487 flags = sec->flags; 2488 align = 1 << bfd_get_section_alignment (abfd, sec); 2489 2490 if (p->p_type == PT_LOAD) 2491 { 2492 bfd_vma adjust; 2493 2494 /* The section VMA must equal the file position modulo 2495 the page size. */ 2496 if ((flags & SEC_ALLOC) != 0) 2497 { 2498 if ((abfd->flags & D_PAGED) != 0) 2499 adjust = (sec->vma - voff) % bed->maxpagesize; 2500 else 2501 adjust = (sec->vma - voff) % align; 2502 if (adjust != 0) 2503 { 2504 if (i == 0) 2505 abort (); 2506 p->p_memsz += adjust; 2507 off += adjust; 2508 voff += adjust; 2509 if ((flags & SEC_LOAD) != 0) 2510 p->p_filesz += adjust; 2511 } 2512 } 2513 2514 sec->filepos = off; 2515 2516 if ((flags & SEC_LOAD) != 0) 2517 off += sec->_raw_size; 2518 if ((flags & SEC_ALLOC) != 0) 2519 voff += sec->_raw_size; 2520 } 2521 2522 p->p_memsz += sec->_raw_size; 2523 2524 if ((flags & SEC_LOAD) != 0) 2525 p->p_filesz += sec->_raw_size; 2526 2527 if (align > p->p_align) 2528 p->p_align = align; 2529 2530 if (! m->p_flags_valid) 2531 { 2532 p->p_flags |= PF_R; 2533 if ((flags & SEC_CODE) != 0) 2534 p->p_flags |= PF_X; 2535 if ((flags & SEC_READONLY) == 0) 2536 p->p_flags |= PF_W; 2537 } 2538 } 2539 } 2540 2541 /* Now that we have set the section file positions, we can set up 2542 the file positions for the non PT_LOAD segments. */ 2543 for (m = elf_tdata (abfd)->segment_map, p = phdrs; 2544 m != NULL; 2545 m = m->next, p++) 2546 { 2547 if (p->p_type != PT_LOAD && m->count > 0) 2548 { 2549 BFD_ASSERT (! m->includes_filehdr && ! m->includes_phdrs); 2550 p->p_offset = m->sections[0]->filepos; 2551 } 2552 if (m->count == 0) 2553 { 2554 if (m->includes_filehdr) 2555 { 2556 p->p_vaddr = filehdr_vaddr; 2557 if (! m->p_paddr_valid) 2558 p->p_paddr = filehdr_paddr; 2559 } 2560 else if (m->includes_phdrs) 2561 { 2562 p->p_vaddr = phdrs_vaddr; 2563 if (! m->p_paddr_valid) 2564 p->p_paddr = phdrs_paddr; 2565 } 2566 } 2567 } 2568 2569 /* Clear out any program headers we allocated but did not use. */ 2570 for (; count < alloc; count++, p++) 2571 { 2572 memset (p, 0, sizeof *p); 2573 p->p_type = PT_NULL; 2574 } 2575 2576 elf_tdata (abfd)->phdr = phdrs; 2577 2578 elf_tdata (abfd)->next_file_pos = off; 2579 2580 /* Write out the program headers. */ 2581 if (bfd_seek (abfd, bed->s->sizeof_ehdr, SEEK_SET) != 0 2582 || bed->s->write_out_phdrs (abfd, phdrs, alloc) != 0) 2583 return false; 2584 2585 return true; 2586} 2587 2588/* Get the size of the program header. 2589 2590 If this is called by the linker before any of the section VMA's are set, it 2591 can't calculate the correct value for a strange memory layout. This only 2592 happens when SIZEOF_HEADERS is used in a linker script. In this case, 2593 SORTED_HDRS is NULL and we assume the normal scenario of one text and one 2594 data segment (exclusive of .interp and .dynamic). 2595 2596 ??? User written scripts must either not use SIZEOF_HEADERS, or assume there 2597 will be two segments. */ 2598 2599static bfd_size_type 2600get_program_header_size (abfd) 2601 bfd *abfd; 2602{ 2603 size_t segs; 2604 asection *s; 2605 struct elf_backend_data *bed = get_elf_backend_data (abfd); 2606 2607 /* We can't return a different result each time we're called. */ 2608 if (elf_tdata (abfd)->program_header_size != 0) 2609 return elf_tdata (abfd)->program_header_size; 2610 2611 if (elf_tdata (abfd)->segment_map != NULL) 2612 { 2613 struct elf_segment_map *m; 2614 2615 segs = 0; 2616 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next) 2617 ++segs; 2618 elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr; 2619 return elf_tdata (abfd)->program_header_size; 2620 } 2621 2622 /* Assume we will need exactly two PT_LOAD segments: one for text 2623 and one for data. */ 2624 segs = 2; 2625 2626 s = bfd_get_section_by_name (abfd, ".interp"); 2627 if (s != NULL && (s->flags & SEC_LOAD) != 0) 2628 { 2629 /* If we have a loadable interpreter section, we need a 2630 PT_INTERP segment. In this case, assume we also need a 2631 PT_PHDR segment, although that may not be true for all 2632 targets. */ 2633 segs += 2; 2634 } 2635 2636 if (bfd_get_section_by_name (abfd, ".dynamic") != NULL) 2637 { 2638 /* We need a PT_DYNAMIC segment. */ 2639 ++segs; 2640 } 2641 2642 for (s = abfd->sections; s != NULL; s = s->next) 2643 { 2644 if ((s->flags & SEC_LOAD) != 0 2645 && strncmp (s->name, ".note", 5) == 0) 2646 { 2647 /* We need a PT_NOTE segment. */ 2648 ++segs; 2649 } 2650 } 2651 2652 /* Let the backend count up any program headers it might need. */ 2653 if (bed->elf_backend_additional_program_headers) 2654 { 2655 int a; 2656 2657 a = (*bed->elf_backend_additional_program_headers) (abfd); 2658 if (a == -1) 2659 abort (); 2660 segs += a; 2661 } 2662 2663 elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr; 2664 return elf_tdata (abfd)->program_header_size; 2665} 2666 2667/* Work out the file positions of all the sections. This is called by 2668 _bfd_elf_compute_section_file_positions. All the section sizes and 2669 VMAs must be known before this is called. 2670 2671 We do not consider reloc sections at this point, unless they form 2672 part of the loadable image. Reloc sections are assigned file 2673 positions in assign_file_positions_for_relocs, which is called by 2674 write_object_contents and final_link. 2675 2676 We also don't set the positions of the .symtab and .strtab here. */ 2677 2678static boolean 2679assign_file_positions_except_relocs (abfd) 2680 bfd *abfd; 2681{ 2682 struct elf_obj_tdata * const tdata = elf_tdata (abfd); 2683 Elf_Internal_Ehdr * const i_ehdrp = elf_elfheader (abfd); 2684 Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd); 2685 file_ptr off; 2686 struct elf_backend_data *bed = get_elf_backend_data (abfd); 2687 2688 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0) 2689 { 2690 Elf_Internal_Shdr **hdrpp; 2691 unsigned int i; 2692 2693 /* Start after the ELF header. */ 2694 off = i_ehdrp->e_ehsize; 2695 2696 /* We are not creating an executable, which means that we are 2697 not creating a program header, and that the actual order of 2698 the sections in the file is unimportant. */ 2699 for (i = 1, hdrpp = i_shdrpp + 1; i < i_ehdrp->e_shnum; i++, hdrpp++) 2700 { 2701 Elf_Internal_Shdr *hdr; 2702 2703 hdr = *hdrpp; 2704 if (hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA) 2705 { 2706 hdr->sh_offset = -1; 2707 continue; 2708 } 2709 if (i == tdata->symtab_section 2710 || i == tdata->strtab_section) 2711 { 2712 hdr->sh_offset = -1; 2713 continue; 2714 } 2715 2716 off = _bfd_elf_assign_file_position_for_section (hdr, off, true); 2717 } 2718 } 2719 else 2720 { 2721 unsigned int i; 2722 Elf_Internal_Shdr **hdrpp; 2723 2724 /* Assign file positions for the loaded sections based on the 2725 assignment of sections to segments. */ 2726 if (! assign_file_positions_for_segments (abfd)) 2727 return false; 2728 2729 /* Assign file positions for the other sections. */ 2730 2731 off = elf_tdata (abfd)->next_file_pos; 2732 for (i = 1, hdrpp = i_shdrpp + 1; i < i_ehdrp->e_shnum; i++, hdrpp++) 2733 { 2734 Elf_Internal_Shdr *hdr; 2735 2736 hdr = *hdrpp; 2737 if (hdr->bfd_section != NULL 2738 && hdr->bfd_section->filepos != 0) 2739 hdr->sh_offset = hdr->bfd_section->filepos; 2740 else if ((hdr->sh_flags & SHF_ALLOC) != 0) 2741 { 2742 ((*_bfd_error_handler) 2743 ("%s: warning: allocated section `%s' not in segment", 2744 bfd_get_filename (abfd), 2745 (hdr->bfd_section == NULL 2746 ? "*unknown*" 2747 : hdr->bfd_section->name))); 2748 if ((abfd->flags & D_PAGED) != 0) 2749 off += (hdr->sh_addr - off) % bed->maxpagesize; 2750 else 2751 off += (hdr->sh_addr - off) % hdr->sh_addralign; 2752 off = _bfd_elf_assign_file_position_for_section (hdr, off, 2753 false); 2754 } 2755 else if (hdr->sh_type == SHT_REL 2756 || hdr->sh_type == SHT_RELA 2757 || hdr == i_shdrpp[tdata->symtab_section] 2758 || hdr == i_shdrpp[tdata->strtab_section]) 2759 hdr->sh_offset = -1; 2760 else 2761 off = _bfd_elf_assign_file_position_for_section (hdr, off, true); 2762 } 2763 } 2764 2765 /* Place the section headers. */ 2766 off = align_file_position (off, bed->s->file_align); 2767 i_ehdrp->e_shoff = off; 2768 off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize; 2769 2770 elf_tdata (abfd)->next_file_pos = off; 2771 2772 return true; 2773} 2774 2775static boolean 2776prep_headers (abfd) 2777 bfd *abfd; 2778{ 2779 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */ 2780 Elf_Internal_Phdr *i_phdrp = 0; /* Program header table, internal form */ 2781 Elf_Internal_Shdr **i_shdrp; /* Section header table, internal form */ 2782 int count; 2783 struct bfd_strtab_hash *shstrtab; 2784 struct elf_backend_data *bed = get_elf_backend_data (abfd); 2785 2786 i_ehdrp = elf_elfheader (abfd); 2787 i_shdrp = elf_elfsections (abfd); 2788 2789 shstrtab = _bfd_elf_stringtab_init (); 2790 if (shstrtab == NULL) 2791 return false; 2792 2793 elf_shstrtab (abfd) = shstrtab; 2794 2795 i_ehdrp->e_ident[EI_MAG0] = ELFMAG0; 2796 i_ehdrp->e_ident[EI_MAG1] = ELFMAG1; 2797 i_ehdrp->e_ident[EI_MAG2] = ELFMAG2; 2798 i_ehdrp->e_ident[EI_MAG3] = ELFMAG3; 2799 2800 i_ehdrp->e_ident[EI_CLASS] = bed->s->elfclass; 2801 i_ehdrp->e_ident[EI_DATA] = 2802 bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB; 2803 i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current; 2804 2805 for (count = EI_PAD; count < EI_NIDENT; count++) 2806 i_ehdrp->e_ident[count] = 0; 2807 2808 if ((abfd->flags & DYNAMIC) != 0) 2809 i_ehdrp->e_type = ET_DYN; 2810 else if ((abfd->flags & EXEC_P) != 0) 2811 i_ehdrp->e_type = ET_EXEC; 2812 else 2813 i_ehdrp->e_type = ET_REL; 2814 2815 switch (bfd_get_arch (abfd)) 2816 { 2817 case bfd_arch_unknown: 2818 i_ehdrp->e_machine = EM_NONE; 2819 break; 2820 case bfd_arch_sparc: 2821 if (bed->s->arch_size == 64) 2822 i_ehdrp->e_machine = EM_SPARC64; 2823 else 2824 i_ehdrp->e_machine = EM_SPARC; 2825 break; 2826 case bfd_arch_i386: 2827 i_ehdrp->e_machine = EM_386; 2828 break; 2829 case bfd_arch_m68k: 2830 i_ehdrp->e_machine = EM_68K; 2831 break; 2832 case bfd_arch_m88k: 2833 i_ehdrp->e_machine = EM_88K; 2834 break; 2835 case bfd_arch_i860: 2836 i_ehdrp->e_machine = EM_860; 2837 break; 2838 case bfd_arch_mips: /* MIPS Rxxxx */ 2839 i_ehdrp->e_machine = EM_MIPS; /* only MIPS R3000 */ 2840 break; 2841 case bfd_arch_hppa: 2842 i_ehdrp->e_machine = EM_PARISC; 2843 break; 2844 case bfd_arch_powerpc: 2845 i_ehdrp->e_machine = EM_PPC; 2846 break; 2847 case bfd_arch_alpha: 2848 i_ehdrp->e_machine = EM_ALPHA; 2849 break; 2850 case bfd_arch_sh: 2851 i_ehdrp->e_machine = EM_SH; 2852 break; 2853 case bfd_arch_d10v: 2854 i_ehdrp->e_machine = EM_CYGNUS_D10V; 2855 break; 2856 case bfd_arch_m32r: 2857 i_ehdrp->e_machine = EM_CYGNUS_M32R; 2858 break; 2859 case bfd_arch_mn10200: 2860 i_ehdrp->e_machine = EM_CYGNUS_MN10200; 2861 break; 2862 case bfd_arch_mn10300: 2863 i_ehdrp->e_machine = EM_CYGNUS_MN10300; 2864 break; 2865 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */ 2866 default: 2867 i_ehdrp->e_machine = EM_NONE; 2868 } 2869 i_ehdrp->e_version = bed->s->ev_current; 2870 i_ehdrp->e_ehsize = bed->s->sizeof_ehdr; 2871 2872 /* no program header, for now. */ 2873 i_ehdrp->e_phoff = 0; 2874 i_ehdrp->e_phentsize = 0; 2875 i_ehdrp->e_phnum = 0; 2876 2877 /* each bfd section is section header entry */ 2878 i_ehdrp->e_entry = bfd_get_start_address (abfd); 2879 i_ehdrp->e_shentsize = bed->s->sizeof_shdr; 2880 2881 /* if we're building an executable, we'll need a program header table */ 2882 if (abfd->flags & EXEC_P) 2883 { 2884 /* it all happens later */ 2885#if 0 2886 i_ehdrp->e_phentsize = sizeof (Elf_External_Phdr); 2887 2888 /* elf_build_phdrs() returns a (NULL-terminated) array of 2889 Elf_Internal_Phdrs */ 2890 i_phdrp = elf_build_phdrs (abfd, i_ehdrp, i_shdrp, &i_ehdrp->e_phnum); 2891 i_ehdrp->e_phoff = outbase; 2892 outbase += i_ehdrp->e_phentsize * i_ehdrp->e_phnum; 2893#endif 2894 } 2895 else 2896 { 2897 i_ehdrp->e_phentsize = 0; 2898 i_phdrp = 0; 2899 i_ehdrp->e_phoff = 0; 2900 } 2901 2902 elf_tdata (abfd)->symtab_hdr.sh_name = 2903 (unsigned int) _bfd_stringtab_add (shstrtab, ".symtab", true, false); 2904 elf_tdata (abfd)->strtab_hdr.sh_name = 2905 (unsigned int) _bfd_stringtab_add (shstrtab, ".strtab", true, false); 2906 elf_tdata (abfd)->shstrtab_hdr.sh_name = 2907 (unsigned int) _bfd_stringtab_add (shstrtab, ".shstrtab", true, false); 2908 if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1 2909 || elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1 2910 || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1) 2911 return false; 2912 2913 return true; 2914} 2915 2916/* Assign file positions for all the reloc sections which are not part 2917 of the loadable file image. */ 2918 2919void 2920_bfd_elf_assign_file_positions_for_relocs (abfd) 2921 bfd *abfd; 2922{ 2923 file_ptr off; 2924 unsigned int i; 2925 Elf_Internal_Shdr **shdrpp; 2926 2927 off = elf_tdata (abfd)->next_file_pos; 2928 2929 for (i = 1, shdrpp = elf_elfsections (abfd) + 1; 2930 i < elf_elfheader (abfd)->e_shnum; 2931 i++, shdrpp++) 2932 { 2933 Elf_Internal_Shdr *shdrp; 2934 2935 shdrp = *shdrpp; 2936 if ((shdrp->sh_type == SHT_REL || shdrp->sh_type == SHT_RELA) 2937 && shdrp->sh_offset == -1) 2938 off = _bfd_elf_assign_file_position_for_section (shdrp, off, true); 2939 } 2940 2941 elf_tdata (abfd)->next_file_pos = off; 2942} 2943 2944boolean 2945_bfd_elf_write_object_contents (abfd) 2946 bfd *abfd; 2947{ 2948 struct elf_backend_data *bed = get_elf_backend_data (abfd); 2949 Elf_Internal_Ehdr *i_ehdrp; 2950 Elf_Internal_Shdr **i_shdrp; 2951 boolean failed; 2952 unsigned int count; 2953 2954 if (! abfd->output_has_begun 2955 && ! _bfd_elf_compute_section_file_positions (abfd, 2956 (struct bfd_link_info *) NULL)) 2957 return false; 2958 2959 i_shdrp = elf_elfsections (abfd); 2960 i_ehdrp = elf_elfheader (abfd); 2961 2962 failed = false; 2963 bfd_map_over_sections (abfd, bed->s->write_relocs, &failed); 2964 if (failed) 2965 return false; 2966 _bfd_elf_assign_file_positions_for_relocs (abfd); 2967 2968 /* After writing the headers, we need to write the sections too... */ 2969 for (count = 1; count < i_ehdrp->e_shnum; count++) 2970 { 2971 if (bed->elf_backend_section_processing) 2972 (*bed->elf_backend_section_processing) (abfd, i_shdrp[count]); 2973 if (i_shdrp[count]->contents) 2974 { 2975 if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0 2976 || (bfd_write (i_shdrp[count]->contents, i_shdrp[count]->sh_size, 2977 1, abfd) 2978 != i_shdrp[count]->sh_size)) 2979 return false; 2980 } 2981 } 2982 2983 /* Write out the section header names. */ 2984 if (bfd_seek (abfd, elf_tdata (abfd)->shstrtab_hdr.sh_offset, SEEK_SET) != 0 2985 || ! _bfd_stringtab_emit (abfd, elf_shstrtab (abfd))) 2986 return false; 2987 2988 if (bed->elf_backend_final_write_processing) 2989 (*bed->elf_backend_final_write_processing) (abfd, 2990 elf_tdata (abfd)->linker); 2991 2992 return bed->s->write_shdrs_and_ehdr (abfd); 2993} 2994 2995/* given a section, search the header to find them... */ 2996int 2997_bfd_elf_section_from_bfd_section (abfd, asect) 2998 bfd *abfd; 2999 struct sec *asect; 3000{ 3001 struct elf_backend_data *bed = get_elf_backend_data (abfd); 3002 Elf_Internal_Shdr **i_shdrp = elf_elfsections (abfd); 3003 int index; 3004 Elf_Internal_Shdr *hdr; 3005 int maxindex = elf_elfheader (abfd)->e_shnum; 3006 3007 for (index = 0; index < maxindex; index++) 3008 { 3009 hdr = i_shdrp[index]; 3010 if (hdr->bfd_section == asect) 3011 return index; 3012 } 3013 3014 if (bed->elf_backend_section_from_bfd_section) 3015 { 3016 for (index = 0; index < maxindex; index++) 3017 { 3018 int retval; 3019 3020 hdr = i_shdrp[index]; 3021 retval = index; 3022 if ((*bed->elf_backend_section_from_bfd_section) 3023 (abfd, hdr, asect, &retval)) 3024 return retval; 3025 } 3026 } 3027 3028 if (bfd_is_abs_section (asect)) 3029 return SHN_ABS; 3030 if (bfd_is_com_section (asect)) 3031 return SHN_COMMON; 3032 if (bfd_is_und_section (asect)) 3033 return SHN_UNDEF; 3034 3035 return -1; 3036} 3037 3038/* Given a BFD symbol, return the index in the ELF symbol table, or -1 3039 on error. */ 3040 3041int 3042_bfd_elf_symbol_from_bfd_symbol (abfd, asym_ptr_ptr) 3043 bfd *abfd; 3044 asymbol **asym_ptr_ptr; 3045{ 3046 asymbol *asym_ptr = *asym_ptr_ptr; 3047 int idx; 3048 flagword flags = asym_ptr->flags; 3049 3050 /* When gas creates relocations against local labels, it creates its 3051 own symbol for the section, but does put the symbol into the 3052 symbol chain, so udata is 0. When the linker is generating 3053 relocatable output, this section symbol may be for one of the 3054 input sections rather than the output section. */ 3055 if (asym_ptr->udata.i == 0 3056 && (flags & BSF_SECTION_SYM) 3057 && asym_ptr->section) 3058 { 3059 int indx; 3060 3061 if (asym_ptr->section->output_section != NULL) 3062 indx = asym_ptr->section->output_section->index; 3063 else 3064 indx = asym_ptr->section->index; 3065 if (elf_section_syms (abfd)[indx]) 3066 asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i; 3067 } 3068 3069 idx = asym_ptr->udata.i; 3070 3071 if (idx == 0) 3072 { 3073 /* This case can occur when using --strip-symbol on a symbol 3074 which is used in a relocation entry. */ 3075 (*_bfd_error_handler) 3076 ("%s: symbol `%s' required but not present", 3077 bfd_get_filename (abfd), bfd_asymbol_name (asym_ptr)); 3078 bfd_set_error (bfd_error_no_symbols); 3079 return -1; 3080 } 3081 3082#if DEBUG & 4 3083 { 3084 fprintf (stderr, 3085 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n", 3086 (long) asym_ptr, asym_ptr->name, idx, flags, 3087 elf_symbol_flags (flags)); 3088 fflush (stderr); 3089 } 3090#endif 3091 3092 return idx; 3093} 3094 3095/* Copy private BFD data. This copies any program header information. */ 3096 3097static boolean 3098copy_private_bfd_data (ibfd, obfd) 3099 bfd *ibfd; 3100 bfd *obfd; 3101{ 3102 Elf_Internal_Ehdr *iehdr; 3103 struct elf_segment_map *mfirst; 3104 struct elf_segment_map **pm; 3105 Elf_Internal_Phdr *p; 3106 unsigned int i, c; 3107 3108 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour 3109 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 3110 return true; 3111 3112 if (elf_tdata (ibfd)->phdr == NULL) 3113 return true; 3114 3115 iehdr = elf_elfheader (ibfd); 3116 3117 mfirst = NULL; 3118 pm = &mfirst; 3119 3120 c = elf_elfheader (ibfd)->e_phnum; 3121 for (i = 0, p = elf_tdata (ibfd)->phdr; i < c; i++, p++) 3122 { 3123 unsigned int csecs; 3124 asection *s; 3125 struct elf_segment_map *m; 3126 unsigned int isec; 3127 3128 csecs = 0; 3129 3130 /* The complicated case when p_vaddr is 0 is to handle the 3131 Solaris linker, which generates a PT_INTERP section with 3132 p_vaddr and p_memsz set to 0. */ 3133 for (s = ibfd->sections; s != NULL; s = s->next) 3134 if (((s->vma >= p->p_vaddr 3135 && (s->vma + s->_raw_size <= p->p_vaddr + p->p_memsz 3136 || s->vma + s->_raw_size <= p->p_vaddr + p->p_filesz)) 3137 || (p->p_vaddr == 0 3138 && p->p_filesz > 0 3139 && (s->flags & SEC_HAS_CONTENTS) != 0 3140 && (bfd_vma) s->filepos >= p->p_offset 3141 && ((bfd_vma) s->filepos + s->_raw_size 3142 <= p->p_offset + p->p_filesz))) 3143 && (s->flags & SEC_ALLOC) != 0 3144 && s->output_section != NULL) 3145 ++csecs; 3146 3147 m = ((struct elf_segment_map *) 3148 bfd_alloc (obfd, 3149 (sizeof (struct elf_segment_map) 3150 + ((size_t) csecs - 1) * sizeof (asection *)))); 3151 if (m == NULL) 3152 return false; 3153 3154 m->next = NULL; 3155 m->p_type = p->p_type; 3156 m->p_flags = p->p_flags; 3157 m->p_flags_valid = 1; 3158 m->p_paddr = p->p_paddr; 3159 m->p_paddr_valid = 1; 3160 3161 m->includes_filehdr = (p->p_offset == 0 3162 && p->p_filesz >= iehdr->e_ehsize); 3163 3164 m->includes_phdrs = (p->p_offset <= (bfd_vma) iehdr->e_phoff 3165 && (p->p_offset + p->p_filesz 3166 >= ((bfd_vma) iehdr->e_phoff 3167 + iehdr->e_phnum * iehdr->e_phentsize))); 3168 3169 isec = 0; 3170 for (s = ibfd->sections; s != NULL; s = s->next) 3171 { 3172 if (((s->vma >= p->p_vaddr 3173 && (s->vma + s->_raw_size <= p->p_vaddr + p->p_memsz 3174 || s->vma + s->_raw_size <= p->p_vaddr + p->p_filesz)) 3175 || (p->p_vaddr == 0 3176 && p->p_filesz > 0 3177 && (s->flags & SEC_HAS_CONTENTS) != 0 3178 && (bfd_vma) s->filepos >= p->p_offset 3179 && ((bfd_vma) s->filepos + s->_raw_size 3180 <= p->p_offset + p->p_filesz))) 3181 && (s->flags & SEC_ALLOC) != 0 3182 && s->output_section != NULL) 3183 { 3184 m->sections[isec] = s->output_section; 3185 ++isec; 3186 } 3187 } 3188 BFD_ASSERT (isec == csecs); 3189 m->count = csecs; 3190 3191 *pm = m; 3192 pm = &m->next; 3193 } 3194 3195 elf_tdata (obfd)->segment_map = mfirst; 3196 3197 return true; 3198} 3199 3200/* Copy private section information. This copies over the entsize 3201 field, and sometimes the info field. */ 3202 3203boolean 3204_bfd_elf_copy_private_section_data (ibfd, isec, obfd, osec) 3205 bfd *ibfd; 3206 asection *isec; 3207 bfd *obfd; 3208 asection *osec; 3209{ 3210 Elf_Internal_Shdr *ihdr, *ohdr; 3211 3212 if (ibfd->xvec->flavour != bfd_target_elf_flavour 3213 || obfd->xvec->flavour != bfd_target_elf_flavour) 3214 return true; 3215 3216 /* Copy over private BFD data if it has not already been copied. 3217 This must be done here, rather than in the copy_private_bfd_data 3218 entry point, because the latter is called after the section 3219 contents have been set, which means that the program headers have 3220 already been worked out. */ 3221 if (elf_tdata (obfd)->segment_map == NULL 3222 && elf_tdata (ibfd)->phdr != NULL) 3223 { 3224 asection *s; 3225 3226 /* Only set up the segments when all the sections have been set 3227 up. */ 3228 for (s = ibfd->sections; s != NULL; s = s->next) 3229 if (s->output_section == NULL) 3230 break; 3231 if (s == NULL) 3232 { 3233 if (! copy_private_bfd_data (ibfd, obfd)) 3234 return false; 3235 } 3236 } 3237 3238 ihdr = &elf_section_data (isec)->this_hdr; 3239 ohdr = &elf_section_data (osec)->this_hdr; 3240 3241 ohdr->sh_entsize = ihdr->sh_entsize; 3242 3243 if (ihdr->sh_type == SHT_SYMTAB 3244 || ihdr->sh_type == SHT_DYNSYM 3245 || ihdr->sh_type == SHT_GNU_verneed 3246 || ihdr->sh_type == SHT_GNU_verdef) 3247 ohdr->sh_info = ihdr->sh_info; 3248 3249 return true; 3250} 3251 3252/* Copy private symbol information. If this symbol is in a section 3253 which we did not map into a BFD section, try to map the section 3254 index correctly. We use special macro definitions for the mapped 3255 section indices; these definitions are interpreted by the 3256 swap_out_syms function. */ 3257 3258#define MAP_ONESYMTAB (SHN_LORESERVE - 1) 3259#define MAP_DYNSYMTAB (SHN_LORESERVE - 2) 3260#define MAP_STRTAB (SHN_LORESERVE - 3) 3261#define MAP_SHSTRTAB (SHN_LORESERVE - 4) 3262 3263boolean 3264_bfd_elf_copy_private_symbol_data (ibfd, isymarg, obfd, osymarg) 3265 bfd *ibfd; 3266 asymbol *isymarg; 3267 bfd *obfd; 3268 asymbol *osymarg; 3269{ 3270 elf_symbol_type *isym, *osym; 3271 3272 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour 3273 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 3274 return true; 3275 3276 isym = elf_symbol_from (ibfd, isymarg); 3277 osym = elf_symbol_from (obfd, osymarg); 3278 3279 if (isym != NULL 3280 && osym != NULL 3281 && bfd_is_abs_section (isym->symbol.section)) 3282 { 3283 unsigned int shndx; 3284 3285 shndx = isym->internal_elf_sym.st_shndx; 3286 if (shndx == elf_onesymtab (ibfd)) 3287 shndx = MAP_ONESYMTAB; 3288 else if (shndx == elf_dynsymtab (ibfd)) 3289 shndx = MAP_DYNSYMTAB; 3290 else if (shndx == elf_tdata (ibfd)->strtab_section) 3291 shndx = MAP_STRTAB; 3292 else if (shndx == elf_tdata (ibfd)->shstrtab_section) 3293 shndx = MAP_SHSTRTAB; 3294 osym->internal_elf_sym.st_shndx = shndx; 3295 } 3296 3297 return true; 3298} 3299 3300/* Swap out the symbols. */ 3301 3302static boolean 3303swap_out_syms (abfd, sttp) 3304 bfd *abfd; 3305 struct bfd_strtab_hash **sttp; 3306{ 3307 struct elf_backend_data *bed = get_elf_backend_data (abfd); 3308 3309 if (!elf_map_symbols (abfd)) 3310 return false; 3311 3312 /* Dump out the symtabs. */ 3313 { 3314 int symcount = bfd_get_symcount (abfd); 3315 asymbol **syms = bfd_get_outsymbols (abfd); 3316 struct bfd_strtab_hash *stt; 3317 Elf_Internal_Shdr *symtab_hdr; 3318 Elf_Internal_Shdr *symstrtab_hdr; 3319 char *outbound_syms; 3320 int idx; 3321 3322 stt = _bfd_elf_stringtab_init (); 3323 if (stt == NULL) 3324 return false; 3325 3326 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 3327 symtab_hdr->sh_type = SHT_SYMTAB; 3328 symtab_hdr->sh_entsize = bed->s->sizeof_sym; 3329 symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1); 3330 symtab_hdr->sh_info = elf_num_locals (abfd) + 1; 3331 symtab_hdr->sh_addralign = bed->s->file_align; 3332 3333 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr; 3334 symstrtab_hdr->sh_type = SHT_STRTAB; 3335 3336 outbound_syms = bfd_alloc (abfd, 3337 (1 + symcount) * bed->s->sizeof_sym); 3338 if (outbound_syms == NULL) 3339 return false; 3340 symtab_hdr->contents = (PTR) outbound_syms; 3341 3342 /* now generate the data (for "contents") */ 3343 { 3344 /* Fill in zeroth symbol and swap it out. */ 3345 Elf_Internal_Sym sym; 3346 sym.st_name = 0; 3347 sym.st_value = 0; 3348 sym.st_size = 0; 3349 sym.st_info = 0; 3350 sym.st_other = 0; 3351 sym.st_shndx = SHN_UNDEF; 3352 bed->s->swap_symbol_out (abfd, &sym, (PTR) outbound_syms); 3353 outbound_syms += bed->s->sizeof_sym; 3354 } 3355 for (idx = 0; idx < symcount; idx++) 3356 { 3357 Elf_Internal_Sym sym; 3358 bfd_vma value = syms[idx]->value; 3359 elf_symbol_type *type_ptr; 3360 flagword flags = syms[idx]->flags; 3361 int type; 3362 3363 if (flags & BSF_SECTION_SYM) 3364 /* Section symbols have no names. */ 3365 sym.st_name = 0; 3366 else 3367 { 3368 sym.st_name = (unsigned long) _bfd_stringtab_add (stt, 3369 syms[idx]->name, 3370 true, false); 3371 if (sym.st_name == (unsigned long) -1) 3372 return false; 3373 } 3374 3375 type_ptr = elf_symbol_from (abfd, syms[idx]); 3376 3377 if (bfd_is_com_section (syms[idx]->section)) 3378 { 3379 /* ELF common symbols put the alignment into the `value' field, 3380 and the size into the `size' field. This is backwards from 3381 how BFD handles it, so reverse it here. */ 3382 sym.st_size = value; 3383 if (type_ptr == NULL 3384 || type_ptr->internal_elf_sym.st_value == 0) 3385 sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value)); 3386 else 3387 sym.st_value = type_ptr->internal_elf_sym.st_value; 3388 sym.st_shndx = _bfd_elf_section_from_bfd_section (abfd, 3389 syms[idx]->section); 3390 } 3391 else 3392 { 3393 asection *sec = syms[idx]->section; 3394 int shndx; 3395 3396 if (sec->output_section) 3397 { 3398 value += sec->output_offset; 3399 sec = sec->output_section; 3400 } 3401 value += sec->vma; 3402 sym.st_value = value; 3403 sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0; 3404 3405 if (bfd_is_abs_section (sec) 3406 && type_ptr != NULL 3407 && type_ptr->internal_elf_sym.st_shndx != 0) 3408 { 3409 /* This symbol is in a real ELF section which we did 3410 not create as a BFD section. Undo the mapping done 3411 by copy_private_symbol_data. */ 3412 shndx = type_ptr->internal_elf_sym.st_shndx; 3413 switch (shndx) 3414 { 3415 case MAP_ONESYMTAB: 3416 shndx = elf_onesymtab (abfd); 3417 break; 3418 case MAP_DYNSYMTAB: 3419 shndx = elf_dynsymtab (abfd); 3420 break; 3421 case MAP_STRTAB: 3422 shndx = elf_tdata (abfd)->strtab_section; 3423 break; 3424 case MAP_SHSTRTAB: 3425 shndx = elf_tdata (abfd)->shstrtab_section; 3426 break; 3427 default: 3428 break; 3429 } 3430 } 3431 else 3432 { 3433 shndx = _bfd_elf_section_from_bfd_section (abfd, sec); 3434 3435 if (shndx == -1) 3436 { 3437 asection *sec2; 3438 3439 /* Writing this would be a hell of a lot easier if 3440 we had some decent documentation on bfd, and 3441 knew what to expect of the library, and what to 3442 demand of applications. For example, it 3443 appears that `objcopy' might not set the 3444 section of a symbol to be a section that is 3445 actually in the output file. */ 3446 sec2 = bfd_get_section_by_name (abfd, sec->name); 3447 BFD_ASSERT (sec2 != 0); 3448 shndx = _bfd_elf_section_from_bfd_section (abfd, sec2); 3449 BFD_ASSERT (shndx != -1); 3450 } 3451 } 3452 3453 sym.st_shndx = shndx; 3454 } 3455 3456 if ((flags & BSF_FUNCTION) != 0) 3457 type = STT_FUNC; 3458 else if ((flags & BSF_OBJECT) != 0) 3459 type = STT_OBJECT; 3460 else 3461 type = STT_NOTYPE; 3462 3463 if (bfd_is_com_section (syms[idx]->section)) 3464 sym.st_info = ELF_ST_INFO (STB_GLOBAL, type); 3465 else if (bfd_is_und_section (syms[idx]->section)) 3466 sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK) 3467 ? STB_WEAK 3468 : STB_GLOBAL), 3469 type); 3470 else if (flags & BSF_SECTION_SYM) 3471 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION); 3472 else if (flags & BSF_FILE) 3473 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE); 3474 else 3475 { 3476 int bind = STB_LOCAL; 3477 3478 if (flags & BSF_LOCAL) 3479 bind = STB_LOCAL; 3480 else if (flags & BSF_WEAK) 3481 bind = STB_WEAK; 3482 else if (flags & BSF_GLOBAL) 3483 bind = STB_GLOBAL; 3484 3485 sym.st_info = ELF_ST_INFO (bind, type); 3486 } 3487 3488 if (type_ptr != NULL) 3489 sym.st_other = type_ptr->internal_elf_sym.st_other; 3490 else 3491 sym.st_other = 0; 3492 3493 bed->s->swap_symbol_out (abfd, &sym, (PTR) outbound_syms); 3494 outbound_syms += bed->s->sizeof_sym; 3495 } 3496 3497 *sttp = stt; 3498 symstrtab_hdr->sh_size = _bfd_stringtab_size (stt); 3499 symstrtab_hdr->sh_type = SHT_STRTAB; 3500 3501 symstrtab_hdr->sh_flags = 0; 3502 symstrtab_hdr->sh_addr = 0; 3503 symstrtab_hdr->sh_entsize = 0; 3504 symstrtab_hdr->sh_link = 0; 3505 symstrtab_hdr->sh_info = 0; 3506 symstrtab_hdr->sh_addralign = 1; 3507 } 3508 3509 return true; 3510} 3511 3512/* Return the number of bytes required to hold the symtab vector. 3513 3514 Note that we base it on the count plus 1, since we will null terminate 3515 the vector allocated based on this size. However, the ELF symbol table 3516 always has a dummy entry as symbol #0, so it ends up even. */ 3517 3518long 3519_bfd_elf_get_symtab_upper_bound (abfd) 3520 bfd *abfd; 3521{ 3522 long symcount; 3523 long symtab_size; 3524 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr; 3525 3526 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym; 3527 symtab_size = (symcount - 1 + 1) * (sizeof (asymbol *)); 3528 3529 return symtab_size; 3530} 3531 3532long 3533_bfd_elf_get_dynamic_symtab_upper_bound (abfd) 3534 bfd *abfd; 3535{ 3536 long symcount; 3537 long symtab_size; 3538 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr; 3539 3540 if (elf_dynsymtab (abfd) == 0) 3541 { 3542 bfd_set_error (bfd_error_invalid_operation); 3543 return -1; 3544 } 3545 3546 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym; 3547 symtab_size = (symcount - 1 + 1) * (sizeof (asymbol *)); 3548 3549 return symtab_size; 3550} 3551 3552long 3553_bfd_elf_get_reloc_upper_bound (abfd, asect) 3554 bfd *abfd; 3555 sec_ptr asect; 3556{ 3557 return (asect->reloc_count + 1) * sizeof (arelent *); 3558} 3559 3560/* Canonicalize the relocs. */ 3561 3562long 3563_bfd_elf_canonicalize_reloc (abfd, section, relptr, symbols) 3564 bfd *abfd; 3565 sec_ptr section; 3566 arelent **relptr; 3567 asymbol **symbols; 3568{ 3569 arelent *tblptr; 3570 unsigned int i; 3571 3572 if (! get_elf_backend_data (abfd)->s->slurp_reloc_table (abfd, 3573 section, 3574 symbols, 3575 false)) 3576 return -1; 3577 3578 tblptr = section->relocation; 3579 for (i = 0; i < section->reloc_count; i++) 3580 *relptr++ = tblptr++; 3581 3582 *relptr = NULL; 3583 3584 return section->reloc_count; 3585} 3586 3587long 3588_bfd_elf_get_symtab (abfd, alocation) 3589 bfd *abfd; 3590 asymbol **alocation; 3591{ 3592 long symcount = get_elf_backend_data (abfd)->s->slurp_symbol_table (abfd, alocation, false); 3593 3594 if (symcount >= 0) 3595 bfd_get_symcount (abfd) = symcount; 3596 return symcount; 3597} 3598 3599long 3600_bfd_elf_canonicalize_dynamic_symtab (abfd, alocation) 3601 bfd *abfd; 3602 asymbol **alocation; 3603{ 3604 return get_elf_backend_data (abfd)->s->slurp_symbol_table (abfd, alocation, true); 3605} 3606 3607/* Return the size required for the dynamic reloc entries. Any 3608 section that was actually installed in the BFD, and has type 3609 SHT_REL or SHT_RELA, and uses the dynamic symbol table, is 3610 considered to be a dynamic reloc section. */ 3611 3612long 3613_bfd_elf_get_dynamic_reloc_upper_bound (abfd) 3614 bfd *abfd; 3615{ 3616 long ret; 3617 asection *s; 3618 3619 if (elf_dynsymtab (abfd) == 0) 3620 { 3621 bfd_set_error (bfd_error_invalid_operation); 3622 return -1; 3623 } 3624 3625 ret = sizeof (arelent *); 3626 for (s = abfd->sections; s != NULL; s = s->next) 3627 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd) 3628 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL 3629 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA)) 3630 ret += ((s->_raw_size / elf_section_data (s)->this_hdr.sh_entsize) 3631 * sizeof (arelent *)); 3632 3633 return ret; 3634} 3635 3636/* Canonicalize the dynamic relocation entries. Note that we return 3637 the dynamic relocations as a single block, although they are 3638 actually associated with particular sections; the interface, which 3639 was designed for SunOS style shared libraries, expects that there 3640 is only one set of dynamic relocs. Any section that was actually 3641 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses 3642 the dynamic symbol table, is considered to be a dynamic reloc 3643 section. */ 3644 3645long 3646_bfd_elf_canonicalize_dynamic_reloc (abfd, storage, syms) 3647 bfd *abfd; 3648 arelent **storage; 3649 asymbol **syms; 3650{ 3651 boolean (*slurp_relocs) PARAMS ((bfd *, asection *, asymbol **, boolean)); 3652 asection *s; 3653 long ret; 3654 3655 if (elf_dynsymtab (abfd) == 0) 3656 { 3657 bfd_set_error (bfd_error_invalid_operation); 3658 return -1; 3659 } 3660 3661 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table; 3662 ret = 0; 3663 for (s = abfd->sections; s != NULL; s = s->next) 3664 { 3665 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd) 3666 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL 3667 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA)) 3668 { 3669 arelent *p; 3670 long count, i; 3671 3672 if (! (*slurp_relocs) (abfd, s, syms, true)) 3673 return -1; 3674 count = s->_raw_size / elf_section_data (s)->this_hdr.sh_entsize; 3675 p = s->relocation; 3676 for (i = 0; i < count; i++) 3677 *storage++ = p++; 3678 ret += count; 3679 } 3680 } 3681 3682 *storage = NULL; 3683 3684 return ret; 3685} 3686 3687/* Read in the version information. */ 3688 3689boolean 3690_bfd_elf_slurp_version_tables (abfd) 3691 bfd *abfd; 3692{ 3693 bfd_byte *contents = NULL; 3694 3695 if (elf_dynverdef (abfd) != 0) 3696 { 3697 Elf_Internal_Shdr *hdr; 3698 Elf_External_Verdef *everdef; 3699 Elf_Internal_Verdef *iverdef; 3700 unsigned int i; 3701 3702 hdr = &elf_tdata (abfd)->dynverdef_hdr; 3703 3704 elf_tdata (abfd)->verdef = 3705 ((Elf_Internal_Verdef *) 3706 bfd_zalloc (abfd, hdr->sh_info * sizeof (Elf_Internal_Verdef))); 3707 if (elf_tdata (abfd)->verdef == NULL) 3708 goto error_return; 3709 3710 elf_tdata (abfd)->cverdefs = hdr->sh_info; 3711 3712 contents = (bfd_byte *) bfd_malloc (hdr->sh_size); 3713 if (contents == NULL) 3714 goto error_return; 3715 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0 3716 || bfd_read ((PTR) contents, 1, hdr->sh_size, abfd) != hdr->sh_size) 3717 goto error_return; 3718 3719 everdef = (Elf_External_Verdef *) contents; 3720 iverdef = elf_tdata (abfd)->verdef; 3721 for (i = 0; i < hdr->sh_info; i++, iverdef++) 3722 { 3723 Elf_External_Verdaux *everdaux; 3724 Elf_Internal_Verdaux *iverdaux; 3725 unsigned int j; 3726 3727 _bfd_elf_swap_verdef_in (abfd, everdef, iverdef); 3728 3729 iverdef->vd_bfd = abfd; 3730 3731 iverdef->vd_auxptr = ((Elf_Internal_Verdaux *) 3732 bfd_alloc (abfd, 3733 (iverdef->vd_cnt 3734 * sizeof (Elf_Internal_Verdaux)))); 3735 if (iverdef->vd_auxptr == NULL) 3736 goto error_return; 3737 3738 everdaux = ((Elf_External_Verdaux *) 3739 ((bfd_byte *) everdef + iverdef->vd_aux)); 3740 iverdaux = iverdef->vd_auxptr; 3741 for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++) 3742 { 3743 _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux); 3744 3745 iverdaux->vda_nodename = 3746 bfd_elf_string_from_elf_section (abfd, hdr->sh_link, 3747 iverdaux->vda_name); 3748 if (iverdaux->vda_nodename == NULL) 3749 goto error_return; 3750 3751 if (j + 1 < iverdef->vd_cnt) 3752 iverdaux->vda_nextptr = iverdaux + 1; 3753 else 3754 iverdaux->vda_nextptr = NULL; 3755 3756 everdaux = ((Elf_External_Verdaux *) 3757 ((bfd_byte *) everdaux + iverdaux->vda_next)); 3758 } 3759 3760 iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename; 3761 3762 if (i + 1 < hdr->sh_info) 3763 iverdef->vd_nextdef = iverdef + 1; 3764 else 3765 iverdef->vd_nextdef = NULL; 3766 3767 everdef = ((Elf_External_Verdef *) 3768 ((bfd_byte *) everdef + iverdef->vd_next)); 3769 } 3770 3771 free (contents); 3772 contents = NULL; 3773 } 3774 3775 if (elf_dynverref (abfd) != 0) 3776 { 3777 Elf_Internal_Shdr *hdr; 3778 Elf_External_Verneed *everneed; 3779 Elf_Internal_Verneed *iverneed; 3780 unsigned int i; 3781 3782 hdr = &elf_tdata (abfd)->dynverref_hdr; 3783 3784 elf_tdata (abfd)->verref = 3785 ((Elf_Internal_Verneed *) 3786 bfd_zalloc (abfd, hdr->sh_info * sizeof (Elf_Internal_Verneed))); 3787 if (elf_tdata (abfd)->verref == NULL) 3788 goto error_return; 3789 3790 elf_tdata (abfd)->cverrefs = hdr->sh_info; 3791 3792 contents = (bfd_byte *) bfd_malloc (hdr->sh_size); 3793 if (contents == NULL) 3794 goto error_return; 3795 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0 3796 || bfd_read ((PTR) contents, 1, hdr->sh_size, abfd) != hdr->sh_size) 3797 goto error_return; 3798 3799 everneed = (Elf_External_Verneed *) contents; 3800 iverneed = elf_tdata (abfd)->verref; 3801 for (i = 0; i < hdr->sh_info; i++, iverneed++) 3802 { 3803 Elf_External_Vernaux *evernaux; 3804 Elf_Internal_Vernaux *ivernaux; 3805 unsigned int j; 3806 3807 _bfd_elf_swap_verneed_in (abfd, everneed, iverneed); 3808 3809 iverneed->vn_bfd = abfd; 3810 3811 iverneed->vn_filename = 3812 bfd_elf_string_from_elf_section (abfd, hdr->sh_link, 3813 iverneed->vn_file); 3814 if (iverneed->vn_filename == NULL) 3815 goto error_return; 3816 3817 iverneed->vn_auxptr = 3818 ((Elf_Internal_Vernaux *) 3819 bfd_alloc (abfd, 3820 iverneed->vn_cnt * sizeof (Elf_Internal_Vernaux))); 3821 3822 evernaux = ((Elf_External_Vernaux *) 3823 ((bfd_byte *) everneed + iverneed->vn_aux)); 3824 ivernaux = iverneed->vn_auxptr; 3825 for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++) 3826 { 3827 _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux); 3828 3829 ivernaux->vna_nodename = 3830 bfd_elf_string_from_elf_section (abfd, hdr->sh_link, 3831 ivernaux->vna_name); 3832 if (ivernaux->vna_nodename == NULL) 3833 goto error_return; 3834 3835 if (j + 1 < iverneed->vn_cnt) 3836 ivernaux->vna_nextptr = ivernaux + 1; 3837 else 3838 ivernaux->vna_nextptr = NULL; 3839 3840 evernaux = ((Elf_External_Vernaux *) 3841 ((bfd_byte *) evernaux + ivernaux->vna_next)); 3842 } 3843 3844 if (i + 1 < hdr->sh_info) 3845 iverneed->vn_nextref = iverneed + 1; 3846 else 3847 iverneed->vn_nextref = NULL; 3848 3849 everneed = ((Elf_External_Verneed *) 3850 ((bfd_byte *) everneed + iverneed->vn_next)); 3851 } 3852 3853 free (contents); 3854 contents = NULL; 3855 } 3856 3857 return true; 3858 3859 error_return: 3860 if (contents == NULL) 3861 free (contents); 3862 return false; 3863} 3864 3865asymbol * 3866_bfd_elf_make_empty_symbol (abfd) 3867 bfd *abfd; 3868{ 3869 elf_symbol_type *newsym; 3870 3871 newsym = (elf_symbol_type *) bfd_zalloc (abfd, sizeof (elf_symbol_type)); 3872 if (!newsym) 3873 return NULL; 3874 else 3875 { 3876 newsym->symbol.the_bfd = abfd; 3877 return &newsym->symbol; 3878 } 3879} 3880 3881void 3882_bfd_elf_get_symbol_info (ignore_abfd, symbol, ret) 3883 bfd *ignore_abfd; 3884 asymbol *symbol; 3885 symbol_info *ret; 3886{ 3887 bfd_symbol_info (symbol, ret); 3888} 3889 3890/* Return whether a symbol name implies a local symbol. Most targets 3891 use this function for the is_local_label_name entry point, but some 3892 override it. */ 3893 3894boolean 3895_bfd_elf_is_local_label_name (abfd, name) 3896 bfd *abfd; 3897 const char *name; 3898{ 3899 /* Normal local symbols start with ``.L''. */ 3900 if (name[0] == '.' && name[1] == 'L') 3901 return true; 3902 3903 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate 3904 DWARF debugging symbols starting with ``..''. */ 3905 if (name[0] == '.' && name[1] == '.') 3906 return true; 3907 3908 /* gcc will sometimes generate symbols beginning with ``_.L_'' when 3909 emitting DWARF debugging output. I suspect this is actually a 3910 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call 3911 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading 3912 underscore to be emitted on some ELF targets). For ease of use, 3913 we treat such symbols as local. */ 3914 if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_') 3915 return true; 3916 3917 return false; 3918} 3919 3920alent * 3921_bfd_elf_get_lineno (ignore_abfd, symbol) 3922 bfd *ignore_abfd; 3923 asymbol *symbol; 3924{ 3925 abort (); 3926 return NULL; 3927} 3928 3929boolean 3930_bfd_elf_set_arch_mach (abfd, arch, machine) 3931 bfd *abfd; 3932 enum bfd_architecture arch; 3933 unsigned long machine; 3934{ 3935 /* If this isn't the right architecture for this backend, and this 3936 isn't the generic backend, fail. */ 3937 if (arch != get_elf_backend_data (abfd)->arch 3938 && arch != bfd_arch_unknown 3939 && get_elf_backend_data (abfd)->arch != bfd_arch_unknown) 3940 return false; 3941 3942 return bfd_default_set_arch_mach (abfd, arch, machine); 3943} 3944 3945/* Find the nearest line to a particular section and offset, for error 3946 reporting. */ 3947 3948boolean 3949_bfd_elf_find_nearest_line (abfd, 3950 section, 3951 symbols, 3952 offset, 3953 filename_ptr, 3954 functionname_ptr, 3955 line_ptr) 3956 bfd *abfd; 3957 asection *section; 3958 asymbol **symbols; 3959 bfd_vma offset; 3960 CONST char **filename_ptr; 3961 CONST char **functionname_ptr; 3962 unsigned int *line_ptr; 3963{ 3964 boolean found; 3965 const char *filename; 3966 asymbol *func; 3967 bfd_vma low_func; 3968 asymbol **p; 3969 3970 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset, 3971 &found, filename_ptr, 3972 functionname_ptr, line_ptr, 3973 &elf_tdata (abfd)->line_info)) 3974 return false; 3975 if (found) 3976 return true; 3977 3978 if (symbols == NULL) 3979 return false; 3980 3981 filename = NULL; 3982 func = NULL; 3983 low_func = 0; 3984 3985 for (p = symbols; *p != NULL; p++) 3986 { 3987 elf_symbol_type *q; 3988 3989 q = (elf_symbol_type *) *p; 3990 3991 if (bfd_get_section (&q->symbol) != section) 3992 continue; 3993 3994 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info)) 3995 { 3996 default: 3997 break; 3998 case STT_FILE: 3999 filename = bfd_asymbol_name (&q->symbol); 4000 break; 4001 case STT_FUNC: 4002 if (q->symbol.section == section 4003 && q->symbol.value >= low_func 4004 && q->symbol.value <= offset) 4005 { 4006 func = (asymbol *) q; 4007 low_func = q->symbol.value; 4008 } 4009 break; 4010 } 4011 } 4012 4013 if (func == NULL) 4014 return false; 4015 4016 *filename_ptr = filename; 4017 *functionname_ptr = bfd_asymbol_name (func); 4018 *line_ptr = 0; 4019 return true; 4020} 4021 4022int 4023_bfd_elf_sizeof_headers (abfd, reloc) 4024 bfd *abfd; 4025 boolean reloc; 4026{ 4027 int ret; 4028 4029 ret = get_elf_backend_data (abfd)->s->sizeof_ehdr; 4030 if (! reloc) 4031 ret += get_program_header_size (abfd); 4032 return ret; 4033} 4034 4035boolean 4036_bfd_elf_set_section_contents (abfd, section, location, offset, count) 4037 bfd *abfd; 4038 sec_ptr section; 4039 PTR location; 4040 file_ptr offset; 4041 bfd_size_type count; 4042{ 4043 Elf_Internal_Shdr *hdr; 4044 4045 if (! abfd->output_has_begun 4046 && ! _bfd_elf_compute_section_file_positions (abfd, 4047 (struct bfd_link_info *) NULL)) 4048 return false; 4049 4050 hdr = &elf_section_data (section)->this_hdr; 4051 4052 if (bfd_seek (abfd, hdr->sh_offset + offset, SEEK_SET) == -1) 4053 return false; 4054 if (bfd_write (location, 1, count, abfd) != count) 4055 return false; 4056 4057 return true; 4058} 4059 4060void 4061_bfd_elf_no_info_to_howto (abfd, cache_ptr, dst) 4062 bfd *abfd; 4063 arelent *cache_ptr; 4064 Elf_Internal_Rela *dst; 4065{ 4066 abort (); 4067} 4068 4069#if 0 4070void 4071_bfd_elf_no_info_to_howto_rel (abfd, cache_ptr, dst) 4072 bfd *abfd; 4073 arelent *cache_ptr; 4074 Elf_Internal_Rel *dst; 4075{ 4076 abort (); 4077} 4078#endif 4079 4080/* Try to convert a non-ELF reloc into an ELF one. */ 4081 4082boolean 4083_bfd_elf_validate_reloc (abfd, areloc) 4084 bfd *abfd; 4085 arelent *areloc; 4086{ 4087 /* Check whether we really have an ELF howto. */ 4088 4089 if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec) 4090 { 4091 bfd_reloc_code_real_type code; 4092 reloc_howto_type *howto; 4093 4094 /* Alien reloc: Try to determine its type to replace it with an 4095 equivalent ELF reloc. */ 4096 4097 if (areloc->howto->pc_relative) 4098 { 4099 switch (areloc->howto->bitsize) 4100 { 4101 case 8: 4102 code = BFD_RELOC_8_PCREL; 4103 break; 4104 case 12: 4105 code = BFD_RELOC_12_PCREL; 4106 break; 4107 case 16: 4108 code = BFD_RELOC_16_PCREL; 4109 break; 4110 case 24: 4111 code = BFD_RELOC_24_PCREL; 4112 break; 4113 case 32: 4114 code = BFD_RELOC_32_PCREL; 4115 break; 4116 case 64: 4117 code = BFD_RELOC_64_PCREL; 4118 break; 4119 default: 4120 goto fail; 4121 } 4122 4123 howto = bfd_reloc_type_lookup (abfd, code); 4124 4125 if (areloc->howto->pcrel_offset != howto->pcrel_offset) 4126 { 4127 if (howto->pcrel_offset) 4128 areloc->addend += areloc->address; 4129 else 4130 areloc->addend -= areloc->address; /* addend is unsigned!! */ 4131 } 4132 } 4133 else 4134 { 4135 switch (areloc->howto->bitsize) 4136 { 4137 case 8: 4138 code = BFD_RELOC_8; 4139 break; 4140 case 14: 4141 code = BFD_RELOC_14; 4142 break; 4143 case 16: 4144 code = BFD_RELOC_16; 4145 break; 4146 case 26: 4147 code = BFD_RELOC_26; 4148 break; 4149 case 32: 4150 code = BFD_RELOC_32; 4151 break; 4152 case 64: 4153 code = BFD_RELOC_64; 4154 break; 4155 default: 4156 goto fail; 4157 } 4158 4159 howto = bfd_reloc_type_lookup (abfd, code); 4160 } 4161 4162 if (howto) 4163 areloc->howto = howto; 4164 else 4165 goto fail; 4166 } 4167 4168 return true; 4169 4170 fail: 4171 (*_bfd_error_handler) 4172 ("%s: unsupported relocation type %s", 4173 bfd_get_filename (abfd), areloc->howto->name); 4174 bfd_set_error (bfd_error_bad_value); 4175 return false; 4176} 4177