elf.c revision 33969
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#ifdef __FreeBSD__ 2873 /* Quick and dirty hack to brand the file as a FreeBSD ELF file. */ 2874 strncpy((char *) &i_ehdrp->e_ident[8], "FreeBSD", EI_NIDENT-8); 2875#endif 2876 2877 /* no program header, for now. */ 2878 i_ehdrp->e_phoff = 0; 2879 i_ehdrp->e_phentsize = 0; 2880 i_ehdrp->e_phnum = 0; 2881 2882 /* each bfd section is section header entry */ 2883 i_ehdrp->e_entry = bfd_get_start_address (abfd); 2884 i_ehdrp->e_shentsize = bed->s->sizeof_shdr; 2885 2886 /* if we're building an executable, we'll need a program header table */ 2887 if (abfd->flags & EXEC_P) 2888 { 2889 /* it all happens later */ 2890#if 0 2891 i_ehdrp->e_phentsize = sizeof (Elf_External_Phdr); 2892 2893 /* elf_build_phdrs() returns a (NULL-terminated) array of 2894 Elf_Internal_Phdrs */ 2895 i_phdrp = elf_build_phdrs (abfd, i_ehdrp, i_shdrp, &i_ehdrp->e_phnum); 2896 i_ehdrp->e_phoff = outbase; 2897 outbase += i_ehdrp->e_phentsize * i_ehdrp->e_phnum; 2898#endif 2899 } 2900 else 2901 { 2902 i_ehdrp->e_phentsize = 0; 2903 i_phdrp = 0; 2904 i_ehdrp->e_phoff = 0; 2905 } 2906 2907 elf_tdata (abfd)->symtab_hdr.sh_name = 2908 (unsigned int) _bfd_stringtab_add (shstrtab, ".symtab", true, false); 2909 elf_tdata (abfd)->strtab_hdr.sh_name = 2910 (unsigned int) _bfd_stringtab_add (shstrtab, ".strtab", true, false); 2911 elf_tdata (abfd)->shstrtab_hdr.sh_name = 2912 (unsigned int) _bfd_stringtab_add (shstrtab, ".shstrtab", true, false); 2913 if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1 2914 || elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1 2915 || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1) 2916 return false; 2917 2918 return true; 2919} 2920 2921/* Assign file positions for all the reloc sections which are not part 2922 of the loadable file image. */ 2923 2924void 2925_bfd_elf_assign_file_positions_for_relocs (abfd) 2926 bfd *abfd; 2927{ 2928 file_ptr off; 2929 unsigned int i; 2930 Elf_Internal_Shdr **shdrpp; 2931 2932 off = elf_tdata (abfd)->next_file_pos; 2933 2934 for (i = 1, shdrpp = elf_elfsections (abfd) + 1; 2935 i < elf_elfheader (abfd)->e_shnum; 2936 i++, shdrpp++) 2937 { 2938 Elf_Internal_Shdr *shdrp; 2939 2940 shdrp = *shdrpp; 2941 if ((shdrp->sh_type == SHT_REL || shdrp->sh_type == SHT_RELA) 2942 && shdrp->sh_offset == -1) 2943 off = _bfd_elf_assign_file_position_for_section (shdrp, off, true); 2944 } 2945 2946 elf_tdata (abfd)->next_file_pos = off; 2947} 2948 2949boolean 2950_bfd_elf_write_object_contents (abfd) 2951 bfd *abfd; 2952{ 2953 struct elf_backend_data *bed = get_elf_backend_data (abfd); 2954 Elf_Internal_Ehdr *i_ehdrp; 2955 Elf_Internal_Shdr **i_shdrp; 2956 boolean failed; 2957 unsigned int count; 2958 2959 if (! abfd->output_has_begun 2960 && ! _bfd_elf_compute_section_file_positions (abfd, 2961 (struct bfd_link_info *) NULL)) 2962 return false; 2963 2964 i_shdrp = elf_elfsections (abfd); 2965 i_ehdrp = elf_elfheader (abfd); 2966 2967 failed = false; 2968 bfd_map_over_sections (abfd, bed->s->write_relocs, &failed); 2969 if (failed) 2970 return false; 2971 _bfd_elf_assign_file_positions_for_relocs (abfd); 2972 2973 /* After writing the headers, we need to write the sections too... */ 2974 for (count = 1; count < i_ehdrp->e_shnum; count++) 2975 { 2976 if (bed->elf_backend_section_processing) 2977 (*bed->elf_backend_section_processing) (abfd, i_shdrp[count]); 2978 if (i_shdrp[count]->contents) 2979 { 2980 if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0 2981 || (bfd_write (i_shdrp[count]->contents, i_shdrp[count]->sh_size, 2982 1, abfd) 2983 != i_shdrp[count]->sh_size)) 2984 return false; 2985 } 2986 } 2987 2988 /* Write out the section header names. */ 2989 if (bfd_seek (abfd, elf_tdata (abfd)->shstrtab_hdr.sh_offset, SEEK_SET) != 0 2990 || ! _bfd_stringtab_emit (abfd, elf_shstrtab (abfd))) 2991 return false; 2992 2993 if (bed->elf_backend_final_write_processing) 2994 (*bed->elf_backend_final_write_processing) (abfd, 2995 elf_tdata (abfd)->linker); 2996 2997 return bed->s->write_shdrs_and_ehdr (abfd); 2998} 2999 3000/* given a section, search the header to find them... */ 3001int 3002_bfd_elf_section_from_bfd_section (abfd, asect) 3003 bfd *abfd; 3004 struct sec *asect; 3005{ 3006 struct elf_backend_data *bed = get_elf_backend_data (abfd); 3007 Elf_Internal_Shdr **i_shdrp = elf_elfsections (abfd); 3008 int index; 3009 Elf_Internal_Shdr *hdr; 3010 int maxindex = elf_elfheader (abfd)->e_shnum; 3011 3012 for (index = 0; index < maxindex; index++) 3013 { 3014 hdr = i_shdrp[index]; 3015 if (hdr->bfd_section == asect) 3016 return index; 3017 } 3018 3019 if (bed->elf_backend_section_from_bfd_section) 3020 { 3021 for (index = 0; index < maxindex; index++) 3022 { 3023 int retval; 3024 3025 hdr = i_shdrp[index]; 3026 retval = index; 3027 if ((*bed->elf_backend_section_from_bfd_section) 3028 (abfd, hdr, asect, &retval)) 3029 return retval; 3030 } 3031 } 3032 3033 if (bfd_is_abs_section (asect)) 3034 return SHN_ABS; 3035 if (bfd_is_com_section (asect)) 3036 return SHN_COMMON; 3037 if (bfd_is_und_section (asect)) 3038 return SHN_UNDEF; 3039 3040 return -1; 3041} 3042 3043/* Given a BFD symbol, return the index in the ELF symbol table, or -1 3044 on error. */ 3045 3046int 3047_bfd_elf_symbol_from_bfd_symbol (abfd, asym_ptr_ptr) 3048 bfd *abfd; 3049 asymbol **asym_ptr_ptr; 3050{ 3051 asymbol *asym_ptr = *asym_ptr_ptr; 3052 int idx; 3053 flagword flags = asym_ptr->flags; 3054 3055 /* When gas creates relocations against local labels, it creates its 3056 own symbol for the section, but does put the symbol into the 3057 symbol chain, so udata is 0. When the linker is generating 3058 relocatable output, this section symbol may be for one of the 3059 input sections rather than the output section. */ 3060 if (asym_ptr->udata.i == 0 3061 && (flags & BSF_SECTION_SYM) 3062 && asym_ptr->section) 3063 { 3064 int indx; 3065 3066 if (asym_ptr->section->output_section != NULL) 3067 indx = asym_ptr->section->output_section->index; 3068 else 3069 indx = asym_ptr->section->index; 3070 if (elf_section_syms (abfd)[indx]) 3071 asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i; 3072 } 3073 3074 idx = asym_ptr->udata.i; 3075 3076 if (idx == 0) 3077 { 3078 /* This case can occur when using --strip-symbol on a symbol 3079 which is used in a relocation entry. */ 3080 (*_bfd_error_handler) 3081 ("%s: symbol `%s' required but not present", 3082 bfd_get_filename (abfd), bfd_asymbol_name (asym_ptr)); 3083 bfd_set_error (bfd_error_no_symbols); 3084 return -1; 3085 } 3086 3087#if DEBUG & 4 3088 { 3089 fprintf (stderr, 3090 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n", 3091 (long) asym_ptr, asym_ptr->name, idx, flags, 3092 elf_symbol_flags (flags)); 3093 fflush (stderr); 3094 } 3095#endif 3096 3097 return idx; 3098} 3099 3100/* Copy private BFD data. This copies any program header information. */ 3101 3102static boolean 3103copy_private_bfd_data (ibfd, obfd) 3104 bfd *ibfd; 3105 bfd *obfd; 3106{ 3107 Elf_Internal_Ehdr *iehdr; 3108 struct elf_segment_map *mfirst; 3109 struct elf_segment_map **pm; 3110 Elf_Internal_Phdr *p; 3111 unsigned int i, c; 3112 3113 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour 3114 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 3115 return true; 3116 3117 if (elf_tdata (ibfd)->phdr == NULL) 3118 return true; 3119 3120 iehdr = elf_elfheader (ibfd); 3121 3122 mfirst = NULL; 3123 pm = &mfirst; 3124 3125 c = elf_elfheader (ibfd)->e_phnum; 3126 for (i = 0, p = elf_tdata (ibfd)->phdr; i < c; i++, p++) 3127 { 3128 unsigned int csecs; 3129 asection *s; 3130 struct elf_segment_map *m; 3131 unsigned int isec; 3132 3133 csecs = 0; 3134 3135 /* The complicated case when p_vaddr is 0 is to handle the 3136 Solaris linker, which generates a PT_INTERP section with 3137 p_vaddr and p_memsz set to 0. */ 3138 for (s = ibfd->sections; s != NULL; s = s->next) 3139 if (((s->vma >= p->p_vaddr 3140 && (s->vma + s->_raw_size <= p->p_vaddr + p->p_memsz 3141 || s->vma + s->_raw_size <= p->p_vaddr + p->p_filesz)) 3142 || (p->p_vaddr == 0 3143 && p->p_filesz > 0 3144 && (s->flags & SEC_HAS_CONTENTS) != 0 3145 && (bfd_vma) s->filepos >= p->p_offset 3146 && ((bfd_vma) s->filepos + s->_raw_size 3147 <= p->p_offset + p->p_filesz))) 3148 && (s->flags & SEC_ALLOC) != 0 3149 && s->output_section != NULL) 3150 ++csecs; 3151 3152 m = ((struct elf_segment_map *) 3153 bfd_alloc (obfd, 3154 (sizeof (struct elf_segment_map) 3155 + ((size_t) csecs - 1) * sizeof (asection *)))); 3156 if (m == NULL) 3157 return false; 3158 3159 m->next = NULL; 3160 m->p_type = p->p_type; 3161 m->p_flags = p->p_flags; 3162 m->p_flags_valid = 1; 3163 m->p_paddr = p->p_paddr; 3164 m->p_paddr_valid = 1; 3165 3166 m->includes_filehdr = (p->p_offset == 0 3167 && p->p_filesz >= iehdr->e_ehsize); 3168 3169 m->includes_phdrs = (p->p_offset <= (bfd_vma) iehdr->e_phoff 3170 && (p->p_offset + p->p_filesz 3171 >= ((bfd_vma) iehdr->e_phoff 3172 + iehdr->e_phnum * iehdr->e_phentsize))); 3173 3174 isec = 0; 3175 for (s = ibfd->sections; s != NULL; s = s->next) 3176 { 3177 if (((s->vma >= p->p_vaddr 3178 && (s->vma + s->_raw_size <= p->p_vaddr + p->p_memsz 3179 || s->vma + s->_raw_size <= p->p_vaddr + p->p_filesz)) 3180 || (p->p_vaddr == 0 3181 && p->p_filesz > 0 3182 && (s->flags & SEC_HAS_CONTENTS) != 0 3183 && (bfd_vma) s->filepos >= p->p_offset 3184 && ((bfd_vma) s->filepos + s->_raw_size 3185 <= p->p_offset + p->p_filesz))) 3186 && (s->flags & SEC_ALLOC) != 0 3187 && s->output_section != NULL) 3188 { 3189 m->sections[isec] = s->output_section; 3190 ++isec; 3191 } 3192 } 3193 BFD_ASSERT (isec == csecs); 3194 m->count = csecs; 3195 3196 *pm = m; 3197 pm = &m->next; 3198 } 3199 3200 elf_tdata (obfd)->segment_map = mfirst; 3201 3202 return true; 3203} 3204 3205/* Copy private section information. This copies over the entsize 3206 field, and sometimes the info field. */ 3207 3208boolean 3209_bfd_elf_copy_private_section_data (ibfd, isec, obfd, osec) 3210 bfd *ibfd; 3211 asection *isec; 3212 bfd *obfd; 3213 asection *osec; 3214{ 3215 Elf_Internal_Shdr *ihdr, *ohdr; 3216 3217 if (ibfd->xvec->flavour != bfd_target_elf_flavour 3218 || obfd->xvec->flavour != bfd_target_elf_flavour) 3219 return true; 3220 3221 /* Copy over private BFD data if it has not already been copied. 3222 This must be done here, rather than in the copy_private_bfd_data 3223 entry point, because the latter is called after the section 3224 contents have been set, which means that the program headers have 3225 already been worked out. */ 3226 if (elf_tdata (obfd)->segment_map == NULL 3227 && elf_tdata (ibfd)->phdr != NULL) 3228 { 3229 asection *s; 3230 3231 /* Only set up the segments when all the sections have been set 3232 up. */ 3233 for (s = ibfd->sections; s != NULL; s = s->next) 3234 if (s->output_section == NULL) 3235 break; 3236 if (s == NULL) 3237 { 3238 if (! copy_private_bfd_data (ibfd, obfd)) 3239 return false; 3240 } 3241 } 3242 3243 ihdr = &elf_section_data (isec)->this_hdr; 3244 ohdr = &elf_section_data (osec)->this_hdr; 3245 3246 ohdr->sh_entsize = ihdr->sh_entsize; 3247 3248 if (ihdr->sh_type == SHT_SYMTAB 3249 || ihdr->sh_type == SHT_DYNSYM 3250 || ihdr->sh_type == SHT_GNU_verneed 3251 || ihdr->sh_type == SHT_GNU_verdef) 3252 ohdr->sh_info = ihdr->sh_info; 3253 3254 return true; 3255} 3256 3257/* Copy private symbol information. If this symbol is in a section 3258 which we did not map into a BFD section, try to map the section 3259 index correctly. We use special macro definitions for the mapped 3260 section indices; these definitions are interpreted by the 3261 swap_out_syms function. */ 3262 3263#define MAP_ONESYMTAB (SHN_LORESERVE - 1) 3264#define MAP_DYNSYMTAB (SHN_LORESERVE - 2) 3265#define MAP_STRTAB (SHN_LORESERVE - 3) 3266#define MAP_SHSTRTAB (SHN_LORESERVE - 4) 3267 3268boolean 3269_bfd_elf_copy_private_symbol_data (ibfd, isymarg, obfd, osymarg) 3270 bfd *ibfd; 3271 asymbol *isymarg; 3272 bfd *obfd; 3273 asymbol *osymarg; 3274{ 3275 elf_symbol_type *isym, *osym; 3276 3277 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour 3278 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 3279 return true; 3280 3281 isym = elf_symbol_from (ibfd, isymarg); 3282 osym = elf_symbol_from (obfd, osymarg); 3283 3284 if (isym != NULL 3285 && osym != NULL 3286 && bfd_is_abs_section (isym->symbol.section)) 3287 { 3288 unsigned int shndx; 3289 3290 shndx = isym->internal_elf_sym.st_shndx; 3291 if (shndx == elf_onesymtab (ibfd)) 3292 shndx = MAP_ONESYMTAB; 3293 else if (shndx == elf_dynsymtab (ibfd)) 3294 shndx = MAP_DYNSYMTAB; 3295 else if (shndx == elf_tdata (ibfd)->strtab_section) 3296 shndx = MAP_STRTAB; 3297 else if (shndx == elf_tdata (ibfd)->shstrtab_section) 3298 shndx = MAP_SHSTRTAB; 3299 osym->internal_elf_sym.st_shndx = shndx; 3300 } 3301 3302 return true; 3303} 3304 3305/* Swap out the symbols. */ 3306 3307static boolean 3308swap_out_syms (abfd, sttp) 3309 bfd *abfd; 3310 struct bfd_strtab_hash **sttp; 3311{ 3312 struct elf_backend_data *bed = get_elf_backend_data (abfd); 3313 3314 if (!elf_map_symbols (abfd)) 3315 return false; 3316 3317 /* Dump out the symtabs. */ 3318 { 3319 int symcount = bfd_get_symcount (abfd); 3320 asymbol **syms = bfd_get_outsymbols (abfd); 3321 struct bfd_strtab_hash *stt; 3322 Elf_Internal_Shdr *symtab_hdr; 3323 Elf_Internal_Shdr *symstrtab_hdr; 3324 char *outbound_syms; 3325 int idx; 3326 3327 stt = _bfd_elf_stringtab_init (); 3328 if (stt == NULL) 3329 return false; 3330 3331 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 3332 symtab_hdr->sh_type = SHT_SYMTAB; 3333 symtab_hdr->sh_entsize = bed->s->sizeof_sym; 3334 symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1); 3335 symtab_hdr->sh_info = elf_num_locals (abfd) + 1; 3336 symtab_hdr->sh_addralign = bed->s->file_align; 3337 3338 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr; 3339 symstrtab_hdr->sh_type = SHT_STRTAB; 3340 3341 outbound_syms = bfd_alloc (abfd, 3342 (1 + symcount) * bed->s->sizeof_sym); 3343 if (outbound_syms == NULL) 3344 return false; 3345 symtab_hdr->contents = (PTR) outbound_syms; 3346 3347 /* now generate the data (for "contents") */ 3348 { 3349 /* Fill in zeroth symbol and swap it out. */ 3350 Elf_Internal_Sym sym; 3351 sym.st_name = 0; 3352 sym.st_value = 0; 3353 sym.st_size = 0; 3354 sym.st_info = 0; 3355 sym.st_other = 0; 3356 sym.st_shndx = SHN_UNDEF; 3357 bed->s->swap_symbol_out (abfd, &sym, (PTR) outbound_syms); 3358 outbound_syms += bed->s->sizeof_sym; 3359 } 3360 for (idx = 0; idx < symcount; idx++) 3361 { 3362 Elf_Internal_Sym sym; 3363 bfd_vma value = syms[idx]->value; 3364 elf_symbol_type *type_ptr; 3365 flagword flags = syms[idx]->flags; 3366 int type; 3367 3368 if (flags & BSF_SECTION_SYM) 3369 /* Section symbols have no names. */ 3370 sym.st_name = 0; 3371 else 3372 { 3373 sym.st_name = (unsigned long) _bfd_stringtab_add (stt, 3374 syms[idx]->name, 3375 true, false); 3376 if (sym.st_name == (unsigned long) -1) 3377 return false; 3378 } 3379 3380 type_ptr = elf_symbol_from (abfd, syms[idx]); 3381 3382 if (bfd_is_com_section (syms[idx]->section)) 3383 { 3384 /* ELF common symbols put the alignment into the `value' field, 3385 and the size into the `size' field. This is backwards from 3386 how BFD handles it, so reverse it here. */ 3387 sym.st_size = value; 3388 if (type_ptr == NULL 3389 || type_ptr->internal_elf_sym.st_value == 0) 3390 sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value)); 3391 else 3392 sym.st_value = type_ptr->internal_elf_sym.st_value; 3393 sym.st_shndx = _bfd_elf_section_from_bfd_section (abfd, 3394 syms[idx]->section); 3395 } 3396 else 3397 { 3398 asection *sec = syms[idx]->section; 3399 int shndx; 3400 3401 if (sec->output_section) 3402 { 3403 value += sec->output_offset; 3404 sec = sec->output_section; 3405 } 3406 value += sec->vma; 3407 sym.st_value = value; 3408 sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0; 3409 3410 if (bfd_is_abs_section (sec) 3411 && type_ptr != NULL 3412 && type_ptr->internal_elf_sym.st_shndx != 0) 3413 { 3414 /* This symbol is in a real ELF section which we did 3415 not create as a BFD section. Undo the mapping done 3416 by copy_private_symbol_data. */ 3417 shndx = type_ptr->internal_elf_sym.st_shndx; 3418 switch (shndx) 3419 { 3420 case MAP_ONESYMTAB: 3421 shndx = elf_onesymtab (abfd); 3422 break; 3423 case MAP_DYNSYMTAB: 3424 shndx = elf_dynsymtab (abfd); 3425 break; 3426 case MAP_STRTAB: 3427 shndx = elf_tdata (abfd)->strtab_section; 3428 break; 3429 case MAP_SHSTRTAB: 3430 shndx = elf_tdata (abfd)->shstrtab_section; 3431 break; 3432 default: 3433 break; 3434 } 3435 } 3436 else 3437 { 3438 shndx = _bfd_elf_section_from_bfd_section (abfd, sec); 3439 3440 if (shndx == -1) 3441 { 3442 asection *sec2; 3443 3444 /* Writing this would be a hell of a lot easier if 3445 we had some decent documentation on bfd, and 3446 knew what to expect of the library, and what to 3447 demand of applications. For example, it 3448 appears that `objcopy' might not set the 3449 section of a symbol to be a section that is 3450 actually in the output file. */ 3451 sec2 = bfd_get_section_by_name (abfd, sec->name); 3452 BFD_ASSERT (sec2 != 0); 3453 shndx = _bfd_elf_section_from_bfd_section (abfd, sec2); 3454 BFD_ASSERT (shndx != -1); 3455 } 3456 } 3457 3458 sym.st_shndx = shndx; 3459 } 3460 3461 if ((flags & BSF_FUNCTION) != 0) 3462 type = STT_FUNC; 3463 else if ((flags & BSF_OBJECT) != 0) 3464 type = STT_OBJECT; 3465 else 3466 type = STT_NOTYPE; 3467 3468 if (bfd_is_com_section (syms[idx]->section)) 3469 sym.st_info = ELF_ST_INFO (STB_GLOBAL, type); 3470 else if (bfd_is_und_section (syms[idx]->section)) 3471 sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK) 3472 ? STB_WEAK 3473 : STB_GLOBAL), 3474 type); 3475 else if (flags & BSF_SECTION_SYM) 3476 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION); 3477 else if (flags & BSF_FILE) 3478 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE); 3479 else 3480 { 3481 int bind = STB_LOCAL; 3482 3483 if (flags & BSF_LOCAL) 3484 bind = STB_LOCAL; 3485 else if (flags & BSF_WEAK) 3486 bind = STB_WEAK; 3487 else if (flags & BSF_GLOBAL) 3488 bind = STB_GLOBAL; 3489 3490 sym.st_info = ELF_ST_INFO (bind, type); 3491 } 3492 3493 if (type_ptr != NULL) 3494 sym.st_other = type_ptr->internal_elf_sym.st_other; 3495 else 3496 sym.st_other = 0; 3497 3498 bed->s->swap_symbol_out (abfd, &sym, (PTR) outbound_syms); 3499 outbound_syms += bed->s->sizeof_sym; 3500 } 3501 3502 *sttp = stt; 3503 symstrtab_hdr->sh_size = _bfd_stringtab_size (stt); 3504 symstrtab_hdr->sh_type = SHT_STRTAB; 3505 3506 symstrtab_hdr->sh_flags = 0; 3507 symstrtab_hdr->sh_addr = 0; 3508 symstrtab_hdr->sh_entsize = 0; 3509 symstrtab_hdr->sh_link = 0; 3510 symstrtab_hdr->sh_info = 0; 3511 symstrtab_hdr->sh_addralign = 1; 3512 } 3513 3514 return true; 3515} 3516 3517/* Return the number of bytes required to hold the symtab vector. 3518 3519 Note that we base it on the count plus 1, since we will null terminate 3520 the vector allocated based on this size. However, the ELF symbol table 3521 always has a dummy entry as symbol #0, so it ends up even. */ 3522 3523long 3524_bfd_elf_get_symtab_upper_bound (abfd) 3525 bfd *abfd; 3526{ 3527 long symcount; 3528 long symtab_size; 3529 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr; 3530 3531 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym; 3532 symtab_size = (symcount - 1 + 1) * (sizeof (asymbol *)); 3533 3534 return symtab_size; 3535} 3536 3537long 3538_bfd_elf_get_dynamic_symtab_upper_bound (abfd) 3539 bfd *abfd; 3540{ 3541 long symcount; 3542 long symtab_size; 3543 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr; 3544 3545 if (elf_dynsymtab (abfd) == 0) 3546 { 3547 bfd_set_error (bfd_error_invalid_operation); 3548 return -1; 3549 } 3550 3551 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym; 3552 symtab_size = (symcount - 1 + 1) * (sizeof (asymbol *)); 3553 3554 return symtab_size; 3555} 3556 3557long 3558_bfd_elf_get_reloc_upper_bound (abfd, asect) 3559 bfd *abfd; 3560 sec_ptr asect; 3561{ 3562 return (asect->reloc_count + 1) * sizeof (arelent *); 3563} 3564 3565/* Canonicalize the relocs. */ 3566 3567long 3568_bfd_elf_canonicalize_reloc (abfd, section, relptr, symbols) 3569 bfd *abfd; 3570 sec_ptr section; 3571 arelent **relptr; 3572 asymbol **symbols; 3573{ 3574 arelent *tblptr; 3575 unsigned int i; 3576 3577 if (! get_elf_backend_data (abfd)->s->slurp_reloc_table (abfd, 3578 section, 3579 symbols, 3580 false)) 3581 return -1; 3582 3583 tblptr = section->relocation; 3584 for (i = 0; i < section->reloc_count; i++) 3585 *relptr++ = tblptr++; 3586 3587 *relptr = NULL; 3588 3589 return section->reloc_count; 3590} 3591 3592long 3593_bfd_elf_get_symtab (abfd, alocation) 3594 bfd *abfd; 3595 asymbol **alocation; 3596{ 3597 long symcount = get_elf_backend_data (abfd)->s->slurp_symbol_table (abfd, alocation, false); 3598 3599 if (symcount >= 0) 3600 bfd_get_symcount (abfd) = symcount; 3601 return symcount; 3602} 3603 3604long 3605_bfd_elf_canonicalize_dynamic_symtab (abfd, alocation) 3606 bfd *abfd; 3607 asymbol **alocation; 3608{ 3609 return get_elf_backend_data (abfd)->s->slurp_symbol_table (abfd, alocation, true); 3610} 3611 3612/* Return the size required for the dynamic reloc entries. Any 3613 section that was actually installed in the BFD, and has type 3614 SHT_REL or SHT_RELA, and uses the dynamic symbol table, is 3615 considered to be a dynamic reloc section. */ 3616 3617long 3618_bfd_elf_get_dynamic_reloc_upper_bound (abfd) 3619 bfd *abfd; 3620{ 3621 long ret; 3622 asection *s; 3623 3624 if (elf_dynsymtab (abfd) == 0) 3625 { 3626 bfd_set_error (bfd_error_invalid_operation); 3627 return -1; 3628 } 3629 3630 ret = sizeof (arelent *); 3631 for (s = abfd->sections; s != NULL; s = s->next) 3632 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd) 3633 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL 3634 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA)) 3635 ret += ((s->_raw_size / elf_section_data (s)->this_hdr.sh_entsize) 3636 * sizeof (arelent *)); 3637 3638 return ret; 3639} 3640 3641/* Canonicalize the dynamic relocation entries. Note that we return 3642 the dynamic relocations as a single block, although they are 3643 actually associated with particular sections; the interface, which 3644 was designed for SunOS style shared libraries, expects that there 3645 is only one set of dynamic relocs. Any section that was actually 3646 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses 3647 the dynamic symbol table, is considered to be a dynamic reloc 3648 section. */ 3649 3650long 3651_bfd_elf_canonicalize_dynamic_reloc (abfd, storage, syms) 3652 bfd *abfd; 3653 arelent **storage; 3654 asymbol **syms; 3655{ 3656 boolean (*slurp_relocs) PARAMS ((bfd *, asection *, asymbol **, boolean)); 3657 asection *s; 3658 long ret; 3659 3660 if (elf_dynsymtab (abfd) == 0) 3661 { 3662 bfd_set_error (bfd_error_invalid_operation); 3663 return -1; 3664 } 3665 3666 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table; 3667 ret = 0; 3668 for (s = abfd->sections; s != NULL; s = s->next) 3669 { 3670 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd) 3671 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL 3672 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA)) 3673 { 3674 arelent *p; 3675 long count, i; 3676 3677 if (! (*slurp_relocs) (abfd, s, syms, true)) 3678 return -1; 3679 count = s->_raw_size / elf_section_data (s)->this_hdr.sh_entsize; 3680 p = s->relocation; 3681 for (i = 0; i < count; i++) 3682 *storage++ = p++; 3683 ret += count; 3684 } 3685 } 3686 3687 *storage = NULL; 3688 3689 return ret; 3690} 3691 3692/* Read in the version information. */ 3693 3694boolean 3695_bfd_elf_slurp_version_tables (abfd) 3696 bfd *abfd; 3697{ 3698 bfd_byte *contents = NULL; 3699 3700 if (elf_dynverdef (abfd) != 0) 3701 { 3702 Elf_Internal_Shdr *hdr; 3703 Elf_External_Verdef *everdef; 3704 Elf_Internal_Verdef *iverdef; 3705 unsigned int i; 3706 3707 hdr = &elf_tdata (abfd)->dynverdef_hdr; 3708 3709 elf_tdata (abfd)->verdef = 3710 ((Elf_Internal_Verdef *) 3711 bfd_zalloc (abfd, hdr->sh_info * sizeof (Elf_Internal_Verdef))); 3712 if (elf_tdata (abfd)->verdef == NULL) 3713 goto error_return; 3714 3715 elf_tdata (abfd)->cverdefs = hdr->sh_info; 3716 3717 contents = (bfd_byte *) bfd_malloc (hdr->sh_size); 3718 if (contents == NULL) 3719 goto error_return; 3720 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0 3721 || bfd_read ((PTR) contents, 1, hdr->sh_size, abfd) != hdr->sh_size) 3722 goto error_return; 3723 3724 everdef = (Elf_External_Verdef *) contents; 3725 iverdef = elf_tdata (abfd)->verdef; 3726 for (i = 0; i < hdr->sh_info; i++, iverdef++) 3727 { 3728 Elf_External_Verdaux *everdaux; 3729 Elf_Internal_Verdaux *iverdaux; 3730 unsigned int j; 3731 3732 _bfd_elf_swap_verdef_in (abfd, everdef, iverdef); 3733 3734 iverdef->vd_bfd = abfd; 3735 3736 iverdef->vd_auxptr = ((Elf_Internal_Verdaux *) 3737 bfd_alloc (abfd, 3738 (iverdef->vd_cnt 3739 * sizeof (Elf_Internal_Verdaux)))); 3740 if (iverdef->vd_auxptr == NULL) 3741 goto error_return; 3742 3743 everdaux = ((Elf_External_Verdaux *) 3744 ((bfd_byte *) everdef + iverdef->vd_aux)); 3745 iverdaux = iverdef->vd_auxptr; 3746 for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++) 3747 { 3748 _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux); 3749 3750 iverdaux->vda_nodename = 3751 bfd_elf_string_from_elf_section (abfd, hdr->sh_link, 3752 iverdaux->vda_name); 3753 if (iverdaux->vda_nodename == NULL) 3754 goto error_return; 3755 3756 if (j + 1 < iverdef->vd_cnt) 3757 iverdaux->vda_nextptr = iverdaux + 1; 3758 else 3759 iverdaux->vda_nextptr = NULL; 3760 3761 everdaux = ((Elf_External_Verdaux *) 3762 ((bfd_byte *) everdaux + iverdaux->vda_next)); 3763 } 3764 3765 iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename; 3766 3767 if (i + 1 < hdr->sh_info) 3768 iverdef->vd_nextdef = iverdef + 1; 3769 else 3770 iverdef->vd_nextdef = NULL; 3771 3772 everdef = ((Elf_External_Verdef *) 3773 ((bfd_byte *) everdef + iverdef->vd_next)); 3774 } 3775 3776 free (contents); 3777 contents = NULL; 3778 } 3779 3780 if (elf_dynverref (abfd) != 0) 3781 { 3782 Elf_Internal_Shdr *hdr; 3783 Elf_External_Verneed *everneed; 3784 Elf_Internal_Verneed *iverneed; 3785 unsigned int i; 3786 3787 hdr = &elf_tdata (abfd)->dynverref_hdr; 3788 3789 elf_tdata (abfd)->verref = 3790 ((Elf_Internal_Verneed *) 3791 bfd_zalloc (abfd, hdr->sh_info * sizeof (Elf_Internal_Verneed))); 3792 if (elf_tdata (abfd)->verref == NULL) 3793 goto error_return; 3794 3795 elf_tdata (abfd)->cverrefs = hdr->sh_info; 3796 3797 contents = (bfd_byte *) bfd_malloc (hdr->sh_size); 3798 if (contents == NULL) 3799 goto error_return; 3800 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0 3801 || bfd_read ((PTR) contents, 1, hdr->sh_size, abfd) != hdr->sh_size) 3802 goto error_return; 3803 3804 everneed = (Elf_External_Verneed *) contents; 3805 iverneed = elf_tdata (abfd)->verref; 3806 for (i = 0; i < hdr->sh_info; i++, iverneed++) 3807 { 3808 Elf_External_Vernaux *evernaux; 3809 Elf_Internal_Vernaux *ivernaux; 3810 unsigned int j; 3811 3812 _bfd_elf_swap_verneed_in (abfd, everneed, iverneed); 3813 3814 iverneed->vn_bfd = abfd; 3815 3816 iverneed->vn_filename = 3817 bfd_elf_string_from_elf_section (abfd, hdr->sh_link, 3818 iverneed->vn_file); 3819 if (iverneed->vn_filename == NULL) 3820 goto error_return; 3821 3822 iverneed->vn_auxptr = 3823 ((Elf_Internal_Vernaux *) 3824 bfd_alloc (abfd, 3825 iverneed->vn_cnt * sizeof (Elf_Internal_Vernaux))); 3826 3827 evernaux = ((Elf_External_Vernaux *) 3828 ((bfd_byte *) everneed + iverneed->vn_aux)); 3829 ivernaux = iverneed->vn_auxptr; 3830 for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++) 3831 { 3832 _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux); 3833 3834 ivernaux->vna_nodename = 3835 bfd_elf_string_from_elf_section (abfd, hdr->sh_link, 3836 ivernaux->vna_name); 3837 if (ivernaux->vna_nodename == NULL) 3838 goto error_return; 3839 3840 if (j + 1 < iverneed->vn_cnt) 3841 ivernaux->vna_nextptr = ivernaux + 1; 3842 else 3843 ivernaux->vna_nextptr = NULL; 3844 3845 evernaux = ((Elf_External_Vernaux *) 3846 ((bfd_byte *) evernaux + ivernaux->vna_next)); 3847 } 3848 3849 if (i + 1 < hdr->sh_info) 3850 iverneed->vn_nextref = iverneed + 1; 3851 else 3852 iverneed->vn_nextref = NULL; 3853 3854 everneed = ((Elf_External_Verneed *) 3855 ((bfd_byte *) everneed + iverneed->vn_next)); 3856 } 3857 3858 free (contents); 3859 contents = NULL; 3860 } 3861 3862 return true; 3863 3864 error_return: 3865 if (contents == NULL) 3866 free (contents); 3867 return false; 3868} 3869 3870asymbol * 3871_bfd_elf_make_empty_symbol (abfd) 3872 bfd *abfd; 3873{ 3874 elf_symbol_type *newsym; 3875 3876 newsym = (elf_symbol_type *) bfd_zalloc (abfd, sizeof (elf_symbol_type)); 3877 if (!newsym) 3878 return NULL; 3879 else 3880 { 3881 newsym->symbol.the_bfd = abfd; 3882 return &newsym->symbol; 3883 } 3884} 3885 3886void 3887_bfd_elf_get_symbol_info (ignore_abfd, symbol, ret) 3888 bfd *ignore_abfd; 3889 asymbol *symbol; 3890 symbol_info *ret; 3891{ 3892 bfd_symbol_info (symbol, ret); 3893} 3894 3895/* Return whether a symbol name implies a local symbol. Most targets 3896 use this function for the is_local_label_name entry point, but some 3897 override it. */ 3898 3899boolean 3900_bfd_elf_is_local_label_name (abfd, name) 3901 bfd *abfd; 3902 const char *name; 3903{ 3904 /* Normal local symbols start with ``.L''. */ 3905 if (name[0] == '.' && name[1] == 'L') 3906 return true; 3907 3908 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate 3909 DWARF debugging symbols starting with ``..''. */ 3910 if (name[0] == '.' && name[1] == '.') 3911 return true; 3912 3913 /* gcc will sometimes generate symbols beginning with ``_.L_'' when 3914 emitting DWARF debugging output. I suspect this is actually a 3915 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call 3916 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading 3917 underscore to be emitted on some ELF targets). For ease of use, 3918 we treat such symbols as local. */ 3919 if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_') 3920 return true; 3921 3922 return false; 3923} 3924 3925alent * 3926_bfd_elf_get_lineno (ignore_abfd, symbol) 3927 bfd *ignore_abfd; 3928 asymbol *symbol; 3929{ 3930 abort (); 3931 return NULL; 3932} 3933 3934boolean 3935_bfd_elf_set_arch_mach (abfd, arch, machine) 3936 bfd *abfd; 3937 enum bfd_architecture arch; 3938 unsigned long machine; 3939{ 3940 /* If this isn't the right architecture for this backend, and this 3941 isn't the generic backend, fail. */ 3942 if (arch != get_elf_backend_data (abfd)->arch 3943 && arch != bfd_arch_unknown 3944 && get_elf_backend_data (abfd)->arch != bfd_arch_unknown) 3945 return false; 3946 3947 return bfd_default_set_arch_mach (abfd, arch, machine); 3948} 3949 3950/* Find the nearest line to a particular section and offset, for error 3951 reporting. */ 3952 3953boolean 3954_bfd_elf_find_nearest_line (abfd, 3955 section, 3956 symbols, 3957 offset, 3958 filename_ptr, 3959 functionname_ptr, 3960 line_ptr) 3961 bfd *abfd; 3962 asection *section; 3963 asymbol **symbols; 3964 bfd_vma offset; 3965 CONST char **filename_ptr; 3966 CONST char **functionname_ptr; 3967 unsigned int *line_ptr; 3968{ 3969 boolean found; 3970 const char *filename; 3971 asymbol *func; 3972 bfd_vma low_func; 3973 asymbol **p; 3974 3975 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset, 3976 &found, filename_ptr, 3977 functionname_ptr, line_ptr, 3978 &elf_tdata (abfd)->line_info)) 3979 return false; 3980 if (found) 3981 return true; 3982 3983 if (symbols == NULL) 3984 return false; 3985 3986 filename = NULL; 3987 func = NULL; 3988 low_func = 0; 3989 3990 for (p = symbols; *p != NULL; p++) 3991 { 3992 elf_symbol_type *q; 3993 3994 q = (elf_symbol_type *) *p; 3995 3996 if (bfd_get_section (&q->symbol) != section) 3997 continue; 3998 3999 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info)) 4000 { 4001 default: 4002 break; 4003 case STT_FILE: 4004 filename = bfd_asymbol_name (&q->symbol); 4005 break; 4006 case STT_FUNC: 4007 if (q->symbol.section == section 4008 && q->symbol.value >= low_func 4009 && q->symbol.value <= offset) 4010 { 4011 func = (asymbol *) q; 4012 low_func = q->symbol.value; 4013 } 4014 break; 4015 } 4016 } 4017 4018 if (func == NULL) 4019 return false; 4020 4021 *filename_ptr = filename; 4022 *functionname_ptr = bfd_asymbol_name (func); 4023 *line_ptr = 0; 4024 return true; 4025} 4026 4027int 4028_bfd_elf_sizeof_headers (abfd, reloc) 4029 bfd *abfd; 4030 boolean reloc; 4031{ 4032 int ret; 4033 4034 ret = get_elf_backend_data (abfd)->s->sizeof_ehdr; 4035 if (! reloc) 4036 ret += get_program_header_size (abfd); 4037 return ret; 4038} 4039 4040boolean 4041_bfd_elf_set_section_contents (abfd, section, location, offset, count) 4042 bfd *abfd; 4043 sec_ptr section; 4044 PTR location; 4045 file_ptr offset; 4046 bfd_size_type count; 4047{ 4048 Elf_Internal_Shdr *hdr; 4049 4050 if (! abfd->output_has_begun 4051 && ! _bfd_elf_compute_section_file_positions (abfd, 4052 (struct bfd_link_info *) NULL)) 4053 return false; 4054 4055 hdr = &elf_section_data (section)->this_hdr; 4056 4057 if (bfd_seek (abfd, hdr->sh_offset + offset, SEEK_SET) == -1) 4058 return false; 4059 if (bfd_write (location, 1, count, abfd) != count) 4060 return false; 4061 4062 return true; 4063} 4064 4065void 4066_bfd_elf_no_info_to_howto (abfd, cache_ptr, dst) 4067 bfd *abfd; 4068 arelent *cache_ptr; 4069 Elf_Internal_Rela *dst; 4070{ 4071 abort (); 4072} 4073 4074#if 0 4075void 4076_bfd_elf_no_info_to_howto_rel (abfd, cache_ptr, dst) 4077 bfd *abfd; 4078 arelent *cache_ptr; 4079 Elf_Internal_Rel *dst; 4080{ 4081 abort (); 4082} 4083#endif 4084 4085/* Try to convert a non-ELF reloc into an ELF one. */ 4086 4087boolean 4088_bfd_elf_validate_reloc (abfd, areloc) 4089 bfd *abfd; 4090 arelent *areloc; 4091{ 4092 /* Check whether we really have an ELF howto. */ 4093 4094 if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec) 4095 { 4096 bfd_reloc_code_real_type code; 4097 reloc_howto_type *howto; 4098 4099 /* Alien reloc: Try to determine its type to replace it with an 4100 equivalent ELF reloc. */ 4101 4102 if (areloc->howto->pc_relative) 4103 { 4104 switch (areloc->howto->bitsize) 4105 { 4106 case 8: 4107 code = BFD_RELOC_8_PCREL; 4108 break; 4109 case 12: 4110 code = BFD_RELOC_12_PCREL; 4111 break; 4112 case 16: 4113 code = BFD_RELOC_16_PCREL; 4114 break; 4115 case 24: 4116 code = BFD_RELOC_24_PCREL; 4117 break; 4118 case 32: 4119 code = BFD_RELOC_32_PCREL; 4120 break; 4121 case 64: 4122 code = BFD_RELOC_64_PCREL; 4123 break; 4124 default: 4125 goto fail; 4126 } 4127 4128 howto = bfd_reloc_type_lookup (abfd, code); 4129 4130 if (areloc->howto->pcrel_offset != howto->pcrel_offset) 4131 { 4132 if (howto->pcrel_offset) 4133 areloc->addend += areloc->address; 4134 else 4135 areloc->addend -= areloc->address; /* addend is unsigned!! */ 4136 } 4137 } 4138 else 4139 { 4140 switch (areloc->howto->bitsize) 4141 { 4142 case 8: 4143 code = BFD_RELOC_8; 4144 break; 4145 case 14: 4146 code = BFD_RELOC_14; 4147 break; 4148 case 16: 4149 code = BFD_RELOC_16; 4150 break; 4151 case 26: 4152 code = BFD_RELOC_26; 4153 break; 4154 case 32: 4155 code = BFD_RELOC_32; 4156 break; 4157 case 64: 4158 code = BFD_RELOC_64; 4159 break; 4160 default: 4161 goto fail; 4162 } 4163 4164 howto = bfd_reloc_type_lookup (abfd, code); 4165 } 4166 4167 if (howto) 4168 areloc->howto = howto; 4169 else 4170 goto fail; 4171 } 4172 4173 return true; 4174 4175 fail: 4176 (*_bfd_error_handler) 4177 ("%s: unsupported relocation type %s", 4178 bfd_get_filename (abfd), areloc->howto->name); 4179 bfd_set_error (bfd_error_bad_value); 4180 return false; 4181} 4182