1 /* ELF executable support for BFD.
2 Copyright 1993, 1994, 1995, 1996 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
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).
29 Documentation of the internals of the support code still needs
30 to be written. The code is changing quickly enough that we
41 static INLINE
struct elf_segment_map
*make_mapping
42 PARAMS ((bfd
*, asection
**, unsigned int, unsigned int, boolean
));
43 static boolean map_sections_to_segments
PARAMS ((bfd
*));
44 static int elf_sort_sections
PARAMS ((const PTR
, const PTR
));
45 static boolean assign_file_positions_for_segments
PARAMS ((bfd
*));
46 static boolean assign_file_positions_except_relocs
PARAMS ((bfd
*));
47 static boolean prep_headers
PARAMS ((bfd
*));
48 static boolean swap_out_syms
PARAMS ((bfd
*, struct bfd_strtab_hash
**));
49 static boolean copy_private_bfd_data
PARAMS ((bfd
*, bfd
*));
51 /* Standard ELF hash function. Do not change this function; you will
52 cause invalid hash tables to be generated. (Well, you would if this
53 were being used yet.) */
56 CONST
unsigned char *name
;
62 while ((ch
= *name
++) != '\0')
65 if ((g
= (h
& 0xf0000000)) != 0)
74 /* Read a specified number of bytes at a specified offset in an ELF
75 file, into a newly allocated buffer, and return a pointer to the
79 elf_read (abfd
, offset
, size
)
86 if ((buf
= bfd_alloc (abfd
, size
)) == NULL
)
88 if (bfd_seek (abfd
, offset
, SEEK_SET
) == -1)
90 if (bfd_read ((PTR
) buf
, size
, 1, abfd
) != size
)
92 if (bfd_get_error () != bfd_error_system_call
)
93 bfd_set_error (bfd_error_file_truncated
);
103 /* this just does initialization */
104 /* coff_mkobject zalloc's space for tdata.coff_obj_data ... */
105 elf_tdata (abfd
) = (struct elf_obj_tdata
*)
106 bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
107 if (elf_tdata (abfd
) == 0)
109 /* since everything is done at close time, do we need any
116 bfd_elf_get_str_section (abfd
, shindex
)
118 unsigned int shindex
;
120 Elf_Internal_Shdr
**i_shdrp
;
121 char *shstrtab
= NULL
;
123 unsigned int shstrtabsize
;
125 i_shdrp
= elf_elfsections (abfd
);
126 if (i_shdrp
== 0 || i_shdrp
[shindex
] == 0)
129 shstrtab
= (char *) i_shdrp
[shindex
]->contents
;
130 if (shstrtab
== NULL
)
132 /* No cached one, attempt to read, and cache what we read. */
133 offset
= i_shdrp
[shindex
]->sh_offset
;
134 shstrtabsize
= i_shdrp
[shindex
]->sh_size
;
135 shstrtab
= elf_read (abfd
, offset
, shstrtabsize
);
136 i_shdrp
[shindex
]->contents
= (PTR
) shstrtab
;
142 bfd_elf_string_from_elf_section (abfd
, shindex
, strindex
)
144 unsigned int shindex
;
145 unsigned int strindex
;
147 Elf_Internal_Shdr
*hdr
;
152 hdr
= elf_elfsections (abfd
)[shindex
];
154 if (hdr
->contents
== NULL
155 && bfd_elf_get_str_section (abfd
, shindex
) == NULL
)
158 return ((char *) hdr
->contents
) + strindex
;
161 /* Make a BFD section from an ELF section. We store a pointer to the
162 BFD section in the bfd_section field of the header. */
165 _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
)
167 Elf_Internal_Shdr
*hdr
;
173 if (hdr
->bfd_section
!= NULL
)
175 BFD_ASSERT (strcmp (name
,
176 bfd_get_section_name (abfd
, hdr
->bfd_section
)) == 0);
180 newsect
= bfd_make_section_anyway (abfd
, name
);
184 newsect
->filepos
= hdr
->sh_offset
;
186 if (! bfd_set_section_vma (abfd
, newsect
, hdr
->sh_addr
)
187 || ! bfd_set_section_size (abfd
, newsect
, hdr
->sh_size
)
188 || ! bfd_set_section_alignment (abfd
, newsect
,
189 bfd_log2 (hdr
->sh_addralign
)))
192 flags
= SEC_NO_FLAGS
;
193 if (hdr
->sh_type
!= SHT_NOBITS
)
194 flags
|= SEC_HAS_CONTENTS
;
195 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
198 if (hdr
->sh_type
!= SHT_NOBITS
)
201 if ((hdr
->sh_flags
& SHF_WRITE
) == 0)
202 flags
|= SEC_READONLY
;
203 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
205 else if ((flags
& SEC_LOAD
) != 0)
208 /* The debugging sections appear to be recognized only by name, not
210 if (strncmp (name
, ".debug", sizeof ".debug" - 1) == 0
211 || strncmp (name
, ".line", sizeof ".line" - 1) == 0
212 || strncmp (name
, ".stab", sizeof ".stab" - 1) == 0)
213 flags
|= SEC_DEBUGGING
;
215 if (! bfd_set_section_flags (abfd
, newsect
, flags
))
218 if ((flags
& SEC_ALLOC
) != 0)
220 Elf_Internal_Phdr
*phdr
;
223 /* Look through the phdrs to see if we need to adjust the lma. */
224 phdr
= elf_tdata (abfd
)->phdr
;
225 for (i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
227 if (phdr
->p_type
== PT_LOAD
228 && phdr
->p_paddr
!= 0
229 && phdr
->p_vaddr
!= phdr
->p_paddr
230 && phdr
->p_vaddr
<= hdr
->sh_addr
231 && phdr
->p_vaddr
+ phdr
->p_memsz
>= hdr
->sh_addr
+ hdr
->sh_size
232 && ((flags
& SEC_LOAD
) == 0
233 || (phdr
->p_offset
<= hdr
->sh_offset
234 && (phdr
->p_offset
+ phdr
->p_filesz
235 >= hdr
->sh_offset
+ hdr
->sh_size
))))
237 newsect
->lma
+= phdr
->p_paddr
- phdr
->p_vaddr
;
243 hdr
->bfd_section
= newsect
;
244 elf_section_data (newsect
)->this_hdr
= *hdr
;
254 struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name);
257 Helper functions for GDB to locate the string tables.
258 Since BFD hides string tables from callers, GDB needs to use an
259 internal hook to find them. Sun's .stabstr, in particular,
260 isn't even pointed to by the .stab section, so ordinary
261 mechanisms wouldn't work to find it, even if we had some.
264 struct elf_internal_shdr
*
265 bfd_elf_find_section (abfd
, name
)
269 Elf_Internal_Shdr
**i_shdrp
;
274 i_shdrp
= elf_elfsections (abfd
);
277 shstrtab
= bfd_elf_get_str_section (abfd
, elf_elfheader (abfd
)->e_shstrndx
);
278 if (shstrtab
!= NULL
)
280 max
= elf_elfheader (abfd
)->e_shnum
;
281 for (i
= 1; i
< max
; i
++)
282 if (!strcmp (&shstrtab
[i_shdrp
[i
]->sh_name
], name
))
289 const char *const bfd_elf_section_type_names
[] = {
290 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
291 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
292 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
295 /* ELF relocs are against symbols. If we are producing relocateable
296 output, and the reloc is against an external symbol, and nothing
297 has given us any additional addend, the resulting reloc will also
298 be against the same symbol. In such a case, we don't want to
299 change anything about the way the reloc is handled, since it will
300 all be done at final link time. Rather than put special case code
301 into bfd_perform_relocation, all the reloc types use this howto
302 function. It just short circuits the reloc if producing
303 relocateable output against an external symbol. */
306 bfd_reloc_status_type
307 bfd_elf_generic_reloc (abfd
,
315 arelent
*reloc_entry
;
318 asection
*input_section
;
320 char **error_message
;
322 if (output_bfd
!= (bfd
*) NULL
323 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
324 && (! reloc_entry
->howto
->partial_inplace
325 || reloc_entry
->addend
== 0))
327 reloc_entry
->address
+= input_section
->output_offset
;
331 return bfd_reloc_continue
;
334 /* Print out the program headers. */
337 _bfd_elf_print_private_bfd_data (abfd
, farg
)
341 FILE *f
= (FILE *) farg
;
342 Elf_Internal_Phdr
*p
;
344 bfd_byte
*dynbuf
= NULL
;
346 p
= elf_tdata (abfd
)->phdr
;
351 fprintf (f
, "\nProgram Header:\n");
352 c
= elf_elfheader (abfd
)->e_phnum
;
353 for (i
= 0; i
< c
; i
++, p
++)
360 case PT_NULL
: s
= "NULL"; break;
361 case PT_LOAD
: s
= "LOAD"; break;
362 case PT_DYNAMIC
: s
= "DYNAMIC"; break;
363 case PT_INTERP
: s
= "INTERP"; break;
364 case PT_NOTE
: s
= "NOTE"; break;
365 case PT_SHLIB
: s
= "SHLIB"; break;
366 case PT_PHDR
: s
= "PHDR"; break;
367 default: sprintf (buf
, "0x%lx", p
->p_type
); s
= buf
; break;
369 fprintf (f
, "%8s off 0x", s
);
370 fprintf_vma (f
, p
->p_offset
);
371 fprintf (f
, " vaddr 0x");
372 fprintf_vma (f
, p
->p_vaddr
);
373 fprintf (f
, " paddr 0x");
374 fprintf_vma (f
, p
->p_paddr
);
375 fprintf (f
, " align 2**%u\n", bfd_log2 (p
->p_align
));
376 fprintf (f
, " filesz 0x");
377 fprintf_vma (f
, p
->p_filesz
);
378 fprintf (f
, " memsz 0x");
379 fprintf_vma (f
, p
->p_memsz
);
380 fprintf (f
, " flags %c%c%c",
381 (p
->p_flags
& PF_R
) != 0 ? 'r' : '-',
382 (p
->p_flags
& PF_W
) != 0 ? 'w' : '-',
383 (p
->p_flags
& PF_X
) != 0 ? 'x' : '-');
384 if ((p
->p_flags
&~ (PF_R
| PF_W
| PF_X
)) != 0)
385 fprintf (f
, " %lx", p
->p_flags
&~ (PF_R
| PF_W
| PF_X
));
390 s
= bfd_get_section_by_name (abfd
, ".dynamic");
395 bfd_byte
*extdyn
, *extdynend
;
397 void (*swap_dyn_in
) PARAMS ((bfd
*, const PTR
, Elf_Internal_Dyn
*));
399 fprintf (f
, "\nDynamic Section:\n");
401 dynbuf
= (bfd_byte
*) bfd_malloc (s
->_raw_size
);
404 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
, (file_ptr
) 0,
408 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
411 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
413 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
414 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
417 extdynend
= extdyn
+ s
->_raw_size
;
418 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
420 Elf_Internal_Dyn dyn
;
425 (*swap_dyn_in
) (abfd
, (PTR
) extdyn
, &dyn
);
427 if (dyn
.d_tag
== DT_NULL
)
434 sprintf (ab
, "0x%lx", (unsigned long) dyn
.d_tag
);
438 case DT_NEEDED
: name
= "NEEDED"; stringp
= true; break;
439 case DT_PLTRELSZ
: name
= "PLTRELSZ"; break;
440 case DT_PLTGOT
: name
= "PLTGOT"; break;
441 case DT_HASH
: name
= "HASH"; break;
442 case DT_STRTAB
: name
= "STRTAB"; break;
443 case DT_SYMTAB
: name
= "SYMTAB"; break;
444 case DT_RELA
: name
= "RELA"; break;
445 case DT_RELASZ
: name
= "RELASZ"; break;
446 case DT_RELAENT
: name
= "RELAENT"; break;
447 case DT_STRSZ
: name
= "STRSZ"; break;
448 case DT_SYMENT
: name
= "SYMENT"; break;
449 case DT_INIT
: name
= "INIT"; break;
450 case DT_FINI
: name
= "FINI"; break;
451 case DT_SONAME
: name
= "SONAME"; stringp
= true; break;
452 case DT_RPATH
: name
= "RPATH"; stringp
= true; break;
453 case DT_SYMBOLIC
: name
= "SYMBOLIC"; break;
454 case DT_REL
: name
= "REL"; break;
455 case DT_RELSZ
: name
= "RELSZ"; break;
456 case DT_RELENT
: name
= "RELENT"; break;
457 case DT_PLTREL
: name
= "PLTREL"; break;
458 case DT_DEBUG
: name
= "DEBUG"; break;
459 case DT_TEXTREL
: name
= "TEXTREL"; break;
460 case DT_JMPREL
: name
= "JMPREL"; break;
463 fprintf (f
, " %-11s ", name
);
465 fprintf (f
, "0x%lx", (unsigned long) dyn
.d_un
.d_val
);
470 string
= bfd_elf_string_from_elf_section (abfd
, link
,
474 fprintf (f
, "%s", string
);
491 /* Display ELF-specific fields of a symbol. */
493 bfd_elf_print_symbol (ignore_abfd
, filep
, symbol
, how
)
497 bfd_print_symbol_type how
;
499 FILE *file
= (FILE *) filep
;
502 case bfd_print_symbol_name
:
503 fprintf (file
, "%s", symbol
->name
);
505 case bfd_print_symbol_more
:
506 fprintf (file
, "elf ");
507 fprintf_vma (file
, symbol
->value
);
508 fprintf (file
, " %lx", (long) symbol
->flags
);
510 case bfd_print_symbol_all
:
512 CONST
char *section_name
;
513 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
514 bfd_print_symbol_vandf ((PTR
) file
, symbol
);
515 fprintf (file
, " %s\t", section_name
);
516 /* Print the "other" value for a symbol. For common symbols,
517 we've already printed the size; now print the alignment.
518 For other symbols, we have no specified alignment, and
519 we've printed the address; now print the size. */
521 (bfd_is_com_section (symbol
->section
)
522 ? ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_value
523 : ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_size
));
524 fprintf (file
, " %s", symbol
->name
);
530 /* Create an entry in an ELF linker hash table. */
532 struct bfd_hash_entry
*
533 _bfd_elf_link_hash_newfunc (entry
, table
, string
)
534 struct bfd_hash_entry
*entry
;
535 struct bfd_hash_table
*table
;
538 struct elf_link_hash_entry
*ret
= (struct elf_link_hash_entry
*) entry
;
540 /* Allocate the structure if it has not already been allocated by a
542 if (ret
== (struct elf_link_hash_entry
*) NULL
)
543 ret
= ((struct elf_link_hash_entry
*)
544 bfd_hash_allocate (table
, sizeof (struct elf_link_hash_entry
)));
545 if (ret
== (struct elf_link_hash_entry
*) NULL
)
546 return (struct bfd_hash_entry
*) ret
;
548 /* Call the allocation method of the superclass. */
549 ret
= ((struct elf_link_hash_entry
*)
550 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
552 if (ret
!= (struct elf_link_hash_entry
*) NULL
)
554 /* Set local fields. */
558 ret
->dynstr_index
= 0;
560 ret
->got_offset
= (bfd_vma
) -1;
561 ret
->plt_offset
= (bfd_vma
) -1;
562 ret
->linker_section_pointer
= (elf_linker_section_pointers_t
*)0;
563 ret
->type
= STT_NOTYPE
;
564 /* Assume that we have been called by a non-ELF symbol reader.
565 This flag is then reset by the code which reads an ELF input
566 file. This ensures that a symbol created by a non-ELF symbol
567 reader will have the flag set correctly. */
568 ret
->elf_link_hash_flags
= ELF_LINK_NON_ELF
;
571 return (struct bfd_hash_entry
*) ret
;
574 /* Initialize an ELF linker hash table. */
577 _bfd_elf_link_hash_table_init (table
, abfd
, newfunc
)
578 struct elf_link_hash_table
*table
;
580 struct bfd_hash_entry
*(*newfunc
) PARAMS ((struct bfd_hash_entry
*,
581 struct bfd_hash_table
*,
584 table
->dynamic_sections_created
= false;
585 table
->dynobj
= NULL
;
586 /* The first dynamic symbol is a dummy. */
587 table
->dynsymcount
= 1;
588 table
->dynstr
= NULL
;
589 table
->bucketcount
= 0;
590 table
->needed
= NULL
;
592 table
->stab_info
= NULL
;
593 return _bfd_link_hash_table_init (&table
->root
, abfd
, newfunc
);
596 /* Create an ELF linker hash table. */
598 struct bfd_link_hash_table
*
599 _bfd_elf_link_hash_table_create (abfd
)
602 struct elf_link_hash_table
*ret
;
604 ret
= ((struct elf_link_hash_table
*)
605 bfd_alloc (abfd
, sizeof (struct elf_link_hash_table
)));
606 if (ret
== (struct elf_link_hash_table
*) NULL
)
609 if (! _bfd_elf_link_hash_table_init (ret
, abfd
, _bfd_elf_link_hash_newfunc
))
611 bfd_release (abfd
, ret
);
618 /* This is a hook for the ELF emulation code in the generic linker to
619 tell the backend linker what file name to use for the DT_NEEDED
620 entry for a dynamic object. The generic linker passes name as an
621 empty string to indicate that no DT_NEEDED entry should be made. */
624 bfd_elf_set_dt_needed_name (abfd
, name
)
628 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
629 && bfd_get_format (abfd
) == bfd_object
)
630 elf_dt_name (abfd
) = name
;
633 /* Get the list of DT_NEEDED entries for a link. This is a hook for
634 the ELF emulation code. */
636 struct bfd_link_needed_list
*
637 bfd_elf_get_needed_list (abfd
, info
)
639 struct bfd_link_info
*info
;
641 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
643 return elf_hash_table (info
)->needed
;
646 /* Get the name actually used for a dynamic object for a link. This
647 is the SONAME entry if there is one. Otherwise, it is the string
648 passed to bfd_elf_set_dt_needed_name, or it is the filename. */
651 bfd_elf_get_dt_soname (abfd
)
654 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
655 && bfd_get_format (abfd
) == bfd_object
)
656 return elf_dt_name (abfd
);
660 /* Allocate an ELF string table--force the first byte to be zero. */
662 struct bfd_strtab_hash
*
663 _bfd_elf_stringtab_init ()
665 struct bfd_strtab_hash
*ret
;
667 ret
= _bfd_stringtab_init ();
672 loc
= _bfd_stringtab_add (ret
, "", true, false);
673 BFD_ASSERT (loc
== 0 || loc
== (bfd_size_type
) -1);
674 if (loc
== (bfd_size_type
) -1)
676 _bfd_stringtab_free (ret
);
683 /* ELF .o/exec file reading */
685 /* Create a new bfd section from an ELF section header. */
688 bfd_section_from_shdr (abfd
, shindex
)
690 unsigned int shindex
;
692 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[shindex
];
693 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
694 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
697 name
= elf_string_from_elf_strtab (abfd
, hdr
->sh_name
);
699 switch (hdr
->sh_type
)
702 /* Inactive section. Throw it away. */
705 case SHT_PROGBITS
: /* Normal section with contents. */
706 case SHT_DYNAMIC
: /* Dynamic linking information. */
707 case SHT_NOBITS
: /* .bss section. */
708 case SHT_HASH
: /* .hash section. */
709 case SHT_NOTE
: /* .note section. */
710 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
712 case SHT_SYMTAB
: /* A symbol table */
713 if (elf_onesymtab (abfd
) == shindex
)
716 BFD_ASSERT (hdr
->sh_entsize
== bed
->s
->sizeof_sym
);
717 BFD_ASSERT (elf_onesymtab (abfd
) == 0);
718 elf_onesymtab (abfd
) = shindex
;
719 elf_tdata (abfd
)->symtab_hdr
= *hdr
;
720 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->symtab_hdr
;
721 abfd
->flags
|= HAS_SYMS
;
723 /* Sometimes a shared object will map in the symbol table. If
724 SHF_ALLOC is set, and this is a shared object, then we also
725 treat this section as a BFD section. We can not base the
726 decision purely on SHF_ALLOC, because that flag is sometimes
727 set in a relocateable object file, which would confuse the
729 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
730 && (abfd
->flags
& DYNAMIC
) != 0
731 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
736 case SHT_DYNSYM
: /* A dynamic symbol table */
737 if (elf_dynsymtab (abfd
) == shindex
)
740 BFD_ASSERT (hdr
->sh_entsize
== bed
->s
->sizeof_sym
);
741 BFD_ASSERT (elf_dynsymtab (abfd
) == 0);
742 elf_dynsymtab (abfd
) = shindex
;
743 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
744 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
745 abfd
->flags
|= HAS_SYMS
;
747 /* Besides being a symbol table, we also treat this as a regular
748 section, so that objcopy can handle it. */
749 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
751 case SHT_STRTAB
: /* A string table */
752 if (hdr
->bfd_section
!= NULL
)
754 if (ehdr
->e_shstrndx
== shindex
)
756 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
757 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
763 for (i
= 1; i
< ehdr
->e_shnum
; i
++)
765 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
766 if (hdr2
->sh_link
== shindex
)
768 if (! bfd_section_from_shdr (abfd
, i
))
770 if (elf_onesymtab (abfd
) == i
)
772 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
773 elf_elfsections (abfd
)[shindex
] =
774 &elf_tdata (abfd
)->strtab_hdr
;
777 if (elf_dynsymtab (abfd
) == i
)
779 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
780 elf_elfsections (abfd
)[shindex
] = hdr
=
781 &elf_tdata (abfd
)->dynstrtab_hdr
;
782 /* We also treat this as a regular section, so
783 that objcopy can handle it. */
786 #if 0 /* Not handling other string tables specially right now. */
787 hdr2
= elf_elfsections (abfd
)[i
]; /* in case it moved */
788 /* We have a strtab for some random other section. */
789 newsect
= (asection
*) hdr2
->bfd_section
;
792 hdr
->bfd_section
= newsect
;
793 hdr2
= &elf_section_data (newsect
)->str_hdr
;
795 elf_elfsections (abfd
)[shindex
] = hdr2
;
801 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
805 /* *These* do a lot of work -- but build no sections! */
807 asection
*target_sect
;
808 Elf_Internal_Shdr
*hdr2
;
810 /* For some incomprehensible reason Oracle distributes
811 libraries for Solaris in which some of the objects have
812 bogus sh_link fields. It would be nice if we could just
813 reject them, but, unfortunately, some people need to use
814 them. We scan through the section headers; if we find only
815 one suitable symbol table, we clobber the sh_link to point
816 to it. I hope this doesn't break anything. */
817 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_SYMTAB
818 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_DYNSYM
)
824 for (scan
= 1; scan
< ehdr
->e_shnum
; scan
++)
826 if (elf_elfsections (abfd
)[scan
]->sh_type
== SHT_SYMTAB
827 || elf_elfsections (abfd
)[scan
]->sh_type
== SHT_DYNSYM
)
838 hdr
->sh_link
= found
;
841 /* Get the symbol table. */
842 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_SYMTAB
843 && ! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
846 /* If this reloc section does not use the main symbol table we
847 don't treat it as a reloc section. BFD can't adequately
848 represent such a section, so at least for now, we don't
849 try. We just present it as a normal section. */
850 if (hdr
->sh_link
!= elf_onesymtab (abfd
))
851 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
853 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
855 target_sect
= bfd_section_from_elf_index (abfd
, hdr
->sh_info
);
856 if (target_sect
== NULL
)
859 if ((target_sect
->flags
& SEC_RELOC
) == 0
860 || target_sect
->reloc_count
== 0)
861 hdr2
= &elf_section_data (target_sect
)->rel_hdr
;
864 BFD_ASSERT (elf_section_data (target_sect
)->rel_hdr2
== NULL
);
865 hdr2
= (Elf_Internal_Shdr
*) bfd_alloc (abfd
, sizeof (*hdr2
));
866 elf_section_data (target_sect
)->rel_hdr2
= hdr2
;
869 elf_elfsections (abfd
)[shindex
] = hdr2
;
870 target_sect
->reloc_count
+= hdr
->sh_size
/ hdr
->sh_entsize
;
871 target_sect
->flags
|= SEC_RELOC
;
872 target_sect
->relocation
= NULL
;
873 target_sect
->rel_filepos
= hdr
->sh_offset
;
874 abfd
->flags
|= HAS_RELOC
;
883 /* Check for any processor-specific section types. */
885 if (bed
->elf_backend_section_from_shdr
)
886 (*bed
->elf_backend_section_from_shdr
) (abfd
, hdr
, name
);
894 /* Given an ELF section number, retrieve the corresponding BFD
898 bfd_section_from_elf_index (abfd
, index
)
902 BFD_ASSERT (index
> 0 && index
< SHN_LORESERVE
);
903 if (index
>= elf_elfheader (abfd
)->e_shnum
)
905 return elf_elfsections (abfd
)[index
]->bfd_section
;
909 _bfd_elf_new_section_hook (abfd
, sec
)
913 struct bfd_elf_section_data
*sdata
;
915 sdata
= (struct bfd_elf_section_data
*) bfd_alloc (abfd
, sizeof (*sdata
));
918 sec
->used_by_bfd
= (PTR
) sdata
;
919 memset (sdata
, 0, sizeof (*sdata
));
923 /* Create a new bfd section from an ELF program header.
925 Since program segments have no names, we generate a synthetic name
926 of the form segment<NUM>, where NUM is generally the index in the
927 program header table. For segments that are split (see below) we
928 generate the names segment<NUM>a and segment<NUM>b.
930 Note that some program segments may have a file size that is different than
931 (less than) the memory size. All this means is that at execution the
932 system must allocate the amount of memory specified by the memory size,
933 but only initialize it with the first "file size" bytes read from the
934 file. This would occur for example, with program segments consisting
935 of combined data+bss.
937 To handle the above situation, this routine generates TWO bfd sections
938 for the single program segment. The first has the length specified by
939 the file size of the segment, and the second has the length specified
940 by the difference between the two sizes. In effect, the segment is split
941 into it's initialized and uninitialized parts.
946 bfd_section_from_phdr (abfd
, hdr
, index
)
948 Elf_Internal_Phdr
*hdr
;
956 split
= ((hdr
->p_memsz
> 0) &&
957 (hdr
->p_filesz
> 0) &&
958 (hdr
->p_memsz
> hdr
->p_filesz
));
959 sprintf (namebuf
, split
? "segment%da" : "segment%d", index
);
960 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
963 strcpy (name
, namebuf
);
964 newsect
= bfd_make_section (abfd
, name
);
967 newsect
->vma
= hdr
->p_vaddr
;
968 newsect
->lma
= hdr
->p_paddr
;
969 newsect
->_raw_size
= hdr
->p_filesz
;
970 newsect
->filepos
= hdr
->p_offset
;
971 newsect
->flags
|= SEC_HAS_CONTENTS
;
972 if (hdr
->p_type
== PT_LOAD
)
974 newsect
->flags
|= SEC_ALLOC
;
975 newsect
->flags
|= SEC_LOAD
;
976 if (hdr
->p_flags
& PF_X
)
978 /* FIXME: all we known is that it has execute PERMISSION,
980 newsect
->flags
|= SEC_CODE
;
983 if (!(hdr
->p_flags
& PF_W
))
985 newsect
->flags
|= SEC_READONLY
;
990 sprintf (namebuf
, "segment%db", index
);
991 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
994 strcpy (name
, namebuf
);
995 newsect
= bfd_make_section (abfd
, name
);
998 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
999 newsect
->lma
= hdr
->p_paddr
+ hdr
->p_filesz
;
1000 newsect
->_raw_size
= hdr
->p_memsz
- hdr
->p_filesz
;
1001 if (hdr
->p_type
== PT_LOAD
)
1003 newsect
->flags
|= SEC_ALLOC
;
1004 if (hdr
->p_flags
& PF_X
)
1005 newsect
->flags
|= SEC_CODE
;
1007 if (!(hdr
->p_flags
& PF_W
))
1008 newsect
->flags
|= SEC_READONLY
;
1014 /* Set up an ELF internal section header for a section. */
1018 elf_fake_sections (abfd
, asect
, failedptrarg
)
1023 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1024 boolean
*failedptr
= (boolean
*) failedptrarg
;
1025 Elf_Internal_Shdr
*this_hdr
;
1029 /* We already failed; just get out of the bfd_map_over_sections
1034 this_hdr
= &elf_section_data (asect
)->this_hdr
;
1036 this_hdr
->sh_name
= (unsigned long) _bfd_stringtab_add (elf_shstrtab (abfd
),
1039 if (this_hdr
->sh_name
== (unsigned long) -1)
1045 this_hdr
->sh_flags
= 0;
1047 if ((asect
->flags
& SEC_ALLOC
) != 0
1048 || asect
->user_set_vma
)
1049 this_hdr
->sh_addr
= asect
->vma
;
1051 this_hdr
->sh_addr
= 0;
1053 this_hdr
->sh_offset
= 0;
1054 this_hdr
->sh_size
= asect
->_raw_size
;
1055 this_hdr
->sh_link
= 0;
1056 this_hdr
->sh_addralign
= 1 << asect
->alignment_power
;
1057 /* The sh_entsize and sh_info fields may have been set already by
1058 copy_private_section_data. */
1060 this_hdr
->bfd_section
= asect
;
1061 this_hdr
->contents
= NULL
;
1063 /* FIXME: This should not be based on section names. */
1064 if (strcmp (asect
->name
, ".dynstr") == 0)
1065 this_hdr
->sh_type
= SHT_STRTAB
;
1066 else if (strcmp (asect
->name
, ".hash") == 0)
1068 this_hdr
->sh_type
= SHT_HASH
;
1069 this_hdr
->sh_entsize
= bed
->s
->arch_size
/ 8;
1071 else if (strcmp (asect
->name
, ".dynsym") == 0)
1073 this_hdr
->sh_type
= SHT_DYNSYM
;
1074 this_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
1076 else if (strcmp (asect
->name
, ".dynamic") == 0)
1078 this_hdr
->sh_type
= SHT_DYNAMIC
;
1079 this_hdr
->sh_entsize
= bed
->s
->sizeof_dyn
;
1081 else if (strncmp (asect
->name
, ".rela", 5) == 0
1082 && get_elf_backend_data (abfd
)->use_rela_p
)
1084 this_hdr
->sh_type
= SHT_RELA
;
1085 this_hdr
->sh_entsize
= bed
->s
->sizeof_rela
;
1087 else if (strncmp (asect
->name
, ".rel", 4) == 0
1088 && ! get_elf_backend_data (abfd
)->use_rela_p
)
1090 this_hdr
->sh_type
= SHT_REL
;
1091 this_hdr
->sh_entsize
= bed
->s
->sizeof_rel
;
1093 else if (strcmp (asect
->name
, ".note") == 0)
1094 this_hdr
->sh_type
= SHT_NOTE
;
1095 else if (strncmp (asect
->name
, ".stab", 5) == 0
1096 && strcmp (asect
->name
+ strlen (asect
->name
) - 3, "str") == 0)
1097 this_hdr
->sh_type
= SHT_STRTAB
;
1098 else if ((asect
->flags
& SEC_ALLOC
) != 0
1099 && (asect
->flags
& SEC_LOAD
) != 0)
1100 this_hdr
->sh_type
= SHT_PROGBITS
;
1101 else if ((asect
->flags
& SEC_ALLOC
) != 0
1102 && ((asect
->flags
& SEC_LOAD
) == 0))
1103 this_hdr
->sh_type
= SHT_NOBITS
;
1107 this_hdr
->sh_type
= SHT_PROGBITS
;
1110 if ((asect
->flags
& SEC_ALLOC
) != 0)
1111 this_hdr
->sh_flags
|= SHF_ALLOC
;
1112 if ((asect
->flags
& SEC_READONLY
) == 0)
1113 this_hdr
->sh_flags
|= SHF_WRITE
;
1114 if ((asect
->flags
& SEC_CODE
) != 0)
1115 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
1117 /* Check for processor-specific section types. */
1119 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1121 if (bed
->elf_backend_fake_sections
)
1122 (*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
);
1125 /* If the section has relocs, set up a section header for the
1126 SHT_REL[A] section. */
1127 if ((asect
->flags
& SEC_RELOC
) != 0)
1129 Elf_Internal_Shdr
*rela_hdr
;
1130 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1133 rela_hdr
= &elf_section_data (asect
)->rel_hdr
;
1134 name
= bfd_alloc (abfd
, sizeof ".rela" + strlen (asect
->name
));
1140 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", asect
->name
);
1142 (unsigned int) _bfd_stringtab_add (elf_shstrtab (abfd
), name
,
1144 if (rela_hdr
->sh_name
== (unsigned int) -1)
1149 rela_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
1150 rela_hdr
->sh_entsize
= (use_rela_p
1151 ? bed
->s
->sizeof_rela
1152 : bed
->s
->sizeof_rel
);
1153 rela_hdr
->sh_addralign
= bed
->s
->file_align
;
1154 rela_hdr
->sh_flags
= 0;
1155 rela_hdr
->sh_addr
= 0;
1156 rela_hdr
->sh_size
= 0;
1157 rela_hdr
->sh_offset
= 0;
1161 /* Assign all ELF section numbers. The dummy first section is handled here
1162 too. The link/info pointers for the standard section types are filled
1163 in here too, while we're at it. */
1166 assign_section_numbers (abfd
)
1169 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
1171 unsigned int section_number
;
1172 Elf_Internal_Shdr
**i_shdrp
;
1173 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1177 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1179 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1181 d
->this_idx
= section_number
++;
1182 if ((sec
->flags
& SEC_RELOC
) == 0)
1185 d
->rel_idx
= section_number
++;
1188 t
->shstrtab_section
= section_number
++;
1189 elf_elfheader (abfd
)->e_shstrndx
= t
->shstrtab_section
;
1190 t
->shstrtab_hdr
.sh_size
= _bfd_stringtab_size (elf_shstrtab (abfd
));
1192 if (abfd
->symcount
> 0)
1194 t
->symtab_section
= section_number
++;
1195 t
->strtab_section
= section_number
++;
1198 elf_elfheader (abfd
)->e_shnum
= section_number
;
1200 /* Set up the list of section header pointers, in agreement with the
1202 i_shdrp
= ((Elf_Internal_Shdr
**)
1203 bfd_alloc (abfd
, section_number
* sizeof (Elf_Internal_Shdr
*)));
1204 if (i_shdrp
== NULL
)
1207 i_shdrp
[0] = ((Elf_Internal_Shdr
*)
1208 bfd_alloc (abfd
, sizeof (Elf_Internal_Shdr
)));
1209 if (i_shdrp
[0] == NULL
)
1211 bfd_release (abfd
, i_shdrp
);
1214 memset (i_shdrp
[0], 0, sizeof (Elf_Internal_Shdr
));
1216 elf_elfsections (abfd
) = i_shdrp
;
1218 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
1219 if (abfd
->symcount
> 0)
1221 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
1222 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
1223 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
1225 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1227 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1231 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
1232 if (d
->rel_idx
!= 0)
1233 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
1235 /* Fill in the sh_link and sh_info fields while we're at it. */
1237 /* sh_link of a reloc section is the section index of the symbol
1238 table. sh_info is the section index of the section to which
1239 the relocation entries apply. */
1240 if (d
->rel_idx
!= 0)
1242 d
->rel_hdr
.sh_link
= t
->symtab_section
;
1243 d
->rel_hdr
.sh_info
= d
->this_idx
;
1246 switch (d
->this_hdr
.sh_type
)
1250 /* A reloc section which we are treating as a normal BFD
1251 section. sh_link is the section index of the symbol
1252 table. sh_info is the section index of the section to
1253 which the relocation entries apply. We assume that an
1254 allocated reloc section uses the dynamic symbol table.
1255 FIXME: How can we be sure? */
1256 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1258 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1260 /* We look up the section the relocs apply to by name. */
1262 if (d
->this_hdr
.sh_type
== SHT_REL
)
1266 s
= bfd_get_section_by_name (abfd
, name
);
1268 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
1272 /* We assume that a section named .stab*str is a stabs
1273 string section. We look for a section with the same name
1274 but without the trailing ``str'', and set its sh_link
1275 field to point to this section. */
1276 if (strncmp (sec
->name
, ".stab", sizeof ".stab" - 1) == 0
1277 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
1282 len
= strlen (sec
->name
);
1283 alc
= (char *) bfd_malloc (len
- 2);
1286 strncpy (alc
, sec
->name
, len
- 3);
1287 alc
[len
- 3] = '\0';
1288 s
= bfd_get_section_by_name (abfd
, alc
);
1292 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
1294 /* This is a .stab section. */
1295 elf_section_data (s
)->this_hdr
.sh_entsize
=
1296 4 + 2 * (bed
->s
->arch_size
/ 8);
1303 /* sh_link is the section header index of the string table
1304 used for the dynamic entries or symbol table. */
1305 s
= bfd_get_section_by_name (abfd
, ".dynstr");
1307 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1311 /* sh_link is the section header index of the symbol table
1312 this hash table is for. */
1313 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1315 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1323 /* Map symbol from it's internal number to the external number, moving
1324 all local symbols to be at the head of the list. */
1327 sym_is_global (abfd
, sym
)
1331 /* If the backend has a special mapping, use it. */
1332 if (get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1333 return ((*get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1336 return ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
1337 || bfd_is_und_section (bfd_get_section (sym
))
1338 || bfd_is_com_section (bfd_get_section (sym
)));
1342 elf_map_symbols (abfd
)
1345 int symcount
= bfd_get_symcount (abfd
);
1346 asymbol
**syms
= bfd_get_outsymbols (abfd
);
1347 asymbol
**sect_syms
;
1349 int num_globals
= 0;
1350 int num_locals2
= 0;
1351 int num_globals2
= 0;
1353 int num_sections
= 0;
1359 fprintf (stderr
, "elf_map_symbols\n");
1363 /* Add a section symbol for each BFD section. FIXME: Is this really
1365 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1367 if (max_index
< asect
->index
)
1368 max_index
= asect
->index
;
1372 sect_syms
= (asymbol
**) bfd_zalloc (abfd
, max_index
* sizeof (asymbol
*));
1373 if (sect_syms
== NULL
)
1375 elf_section_syms (abfd
) = sect_syms
;
1377 for (idx
= 0; idx
< symcount
; idx
++)
1379 if ((syms
[idx
]->flags
& BSF_SECTION_SYM
) != 0
1380 && (syms
[idx
]->value
+ syms
[idx
]->section
->vma
) == 0)
1384 sec
= syms
[idx
]->section
;
1385 if (sec
->owner
!= NULL
)
1387 if (sec
->owner
!= abfd
)
1389 if (sec
->output_offset
!= 0)
1391 sec
= sec
->output_section
;
1392 BFD_ASSERT (sec
->owner
== abfd
);
1394 sect_syms
[sec
->index
] = syms
[idx
];
1399 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1403 if (sect_syms
[asect
->index
] != NULL
)
1406 sym
= bfd_make_empty_symbol (abfd
);
1409 sym
->the_bfd
= abfd
;
1410 sym
->name
= asect
->name
;
1412 /* Set the flags to 0 to indicate that this one was newly added. */
1414 sym
->section
= asect
;
1415 sect_syms
[asect
->index
] = sym
;
1419 "creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n",
1420 asect
->name
, (long) asect
->vma
, asect
->index
, (long) asect
);
1424 /* Classify all of the symbols. */
1425 for (idx
= 0; idx
< symcount
; idx
++)
1427 if (!sym_is_global (abfd
, syms
[idx
]))
1432 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1434 if (sect_syms
[asect
->index
] != NULL
1435 && sect_syms
[asect
->index
]->flags
== 0)
1437 sect_syms
[asect
->index
]->flags
= BSF_SECTION_SYM
;
1438 if (!sym_is_global (abfd
, sect_syms
[asect
->index
]))
1442 sect_syms
[asect
->index
]->flags
= 0;
1446 /* Now sort the symbols so the local symbols are first. */
1447 new_syms
= ((asymbol
**)
1449 (num_locals
+ num_globals
) * sizeof (asymbol
*)));
1450 if (new_syms
== NULL
)
1453 for (idx
= 0; idx
< symcount
; idx
++)
1455 asymbol
*sym
= syms
[idx
];
1458 if (!sym_is_global (abfd
, sym
))
1461 i
= num_locals
+ num_globals2
++;
1463 sym
->udata
.i
= i
+ 1;
1465 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1467 if (sect_syms
[asect
->index
] != NULL
1468 && sect_syms
[asect
->index
]->flags
== 0)
1470 asymbol
*sym
= sect_syms
[asect
->index
];
1473 sym
->flags
= BSF_SECTION_SYM
;
1474 if (!sym_is_global (abfd
, sym
))
1477 i
= num_locals
+ num_globals2
++;
1479 sym
->udata
.i
= i
+ 1;
1483 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
1485 elf_num_locals (abfd
) = num_locals
;
1486 elf_num_globals (abfd
) = num_globals
;
1490 /* Align to the maximum file alignment that could be required for any
1491 ELF data structure. */
1493 static INLINE file_ptr align_file_position
PARAMS ((file_ptr
, int));
1494 static INLINE file_ptr
1495 align_file_position (off
, align
)
1499 return (off
+ align
- 1) & ~(align
- 1);
1502 /* Assign a file position to a section, optionally aligning to the
1503 required section alignment. */
1506 _bfd_elf_assign_file_position_for_section (i_shdrp
, offset
, align
)
1507 Elf_Internal_Shdr
*i_shdrp
;
1515 al
= i_shdrp
->sh_addralign
;
1517 offset
= BFD_ALIGN (offset
, al
);
1519 i_shdrp
->sh_offset
= offset
;
1520 if (i_shdrp
->bfd_section
!= NULL
)
1521 i_shdrp
->bfd_section
->filepos
= offset
;
1522 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
1523 offset
+= i_shdrp
->sh_size
;
1527 /* Compute the file positions we are going to put the sections at, and
1528 otherwise prepare to begin writing out the ELF file. If LINK_INFO
1529 is not NULL, this is being called by the ELF backend linker. */
1532 _bfd_elf_compute_section_file_positions (abfd
, link_info
)
1534 struct bfd_link_info
*link_info
;
1536 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1538 struct bfd_strtab_hash
*strtab
;
1539 Elf_Internal_Shdr
*shstrtab_hdr
;
1541 if (abfd
->output_has_begun
)
1544 /* Do any elf backend specific processing first. */
1545 if (bed
->elf_backend_begin_write_processing
)
1546 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
1548 if (! prep_headers (abfd
))
1552 bfd_map_over_sections (abfd
, elf_fake_sections
, &failed
);
1556 if (!assign_section_numbers (abfd
))
1559 /* The backend linker builds symbol table information itself. */
1560 if (link_info
== NULL
&& abfd
->symcount
> 0)
1562 if (! swap_out_syms (abfd
, &strtab
))
1566 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
1567 /* sh_name was set in prep_headers. */
1568 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
1569 shstrtab_hdr
->sh_flags
= 0;
1570 shstrtab_hdr
->sh_addr
= 0;
1571 shstrtab_hdr
->sh_size
= _bfd_stringtab_size (elf_shstrtab (abfd
));
1572 shstrtab_hdr
->sh_entsize
= 0;
1573 shstrtab_hdr
->sh_link
= 0;
1574 shstrtab_hdr
->sh_info
= 0;
1575 /* sh_offset is set in assign_file_positions_except_relocs. */
1576 shstrtab_hdr
->sh_addralign
= 1;
1578 if (!assign_file_positions_except_relocs (abfd
))
1581 if (link_info
== NULL
&& abfd
->symcount
> 0)
1584 Elf_Internal_Shdr
*hdr
;
1586 off
= elf_tdata (abfd
)->next_file_pos
;
1588 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1589 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
1591 hdr
= &elf_tdata (abfd
)->strtab_hdr
;
1592 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
1594 elf_tdata (abfd
)->next_file_pos
= off
;
1596 /* Now that we know where the .strtab section goes, write it
1598 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
1599 || ! _bfd_stringtab_emit (abfd
, strtab
))
1601 _bfd_stringtab_free (strtab
);
1604 abfd
->output_has_begun
= true;
1609 /* Create a mapping from a set of sections to a program segment. */
1611 static INLINE
struct elf_segment_map
*
1612 make_mapping (abfd
, sections
, from
, to
, phdr
)
1614 asection
**sections
;
1619 struct elf_segment_map
*m
;
1623 m
= ((struct elf_segment_map
*)
1625 (sizeof (struct elf_segment_map
)
1626 + (to
- from
- 1) * sizeof (asection
*))));
1630 m
->p_type
= PT_LOAD
;
1631 for (i
= from
, hdrpp
= sections
+ from
; i
< to
; i
++, hdrpp
++)
1632 m
->sections
[i
- from
] = *hdrpp
;
1633 m
->count
= to
- from
;
1635 if (from
== 0 && phdr
)
1637 /* Include the headers in the first PT_LOAD segment. */
1638 m
->includes_filehdr
= 1;
1639 m
->includes_phdrs
= 1;
1645 /* Set up a mapping from BFD sections to program segments. */
1648 map_sections_to_segments (abfd
)
1651 asection
**sections
= NULL
;
1655 struct elf_segment_map
*mfirst
;
1656 struct elf_segment_map
**pm
;
1657 struct elf_segment_map
*m
;
1659 unsigned int phdr_index
;
1660 bfd_vma maxpagesize
;
1662 boolean phdr_in_section
= true;
1666 if (elf_tdata (abfd
)->segment_map
!= NULL
)
1669 if (bfd_count_sections (abfd
) == 0)
1672 /* Select the allocated sections, and sort them. */
1674 sections
= (asection
**) bfd_malloc (bfd_count_sections (abfd
)
1675 * sizeof (asection
*));
1676 if (sections
== NULL
)
1680 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
1682 if ((s
->flags
& SEC_ALLOC
) != 0)
1688 BFD_ASSERT (i
<= bfd_count_sections (abfd
));
1691 qsort (sections
, (size_t) count
, sizeof (asection
*), elf_sort_sections
);
1693 /* Build the mapping. */
1698 /* If we have a .interp section, then create a PT_PHDR segment for
1699 the program headers and a PT_INTERP segment for the .interp
1701 s
= bfd_get_section_by_name (abfd
, ".interp");
1702 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
1704 m
= ((struct elf_segment_map
*)
1705 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
1709 m
->p_type
= PT_PHDR
;
1710 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
1711 m
->p_flags
= PF_R
| PF_X
;
1712 m
->p_flags_valid
= 1;
1713 m
->includes_phdrs
= 1;
1718 m
= ((struct elf_segment_map
*)
1719 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
1723 m
->p_type
= PT_INTERP
;
1731 /* Look through the sections. We put sections in the same program
1732 segment when the start of the second section can be placed within
1733 a few bytes of the end of the first section. */
1736 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
1738 dynsec
= bfd_get_section_by_name (abfd
, ".dynamic");
1740 && (dynsec
->flags
& SEC_LOAD
) == 0)
1743 /* Deal with -Ttext or something similar such that the first section
1744 is not adjacent to the program headers. This is an
1745 approximation, since at this point we don't know exactly how many
1746 program headers we will need. */
1749 bfd_size_type phdr_size
;
1751 phdr_size
= elf_tdata (abfd
)->program_header_size
;
1753 phdr_size
= get_elf_backend_data (abfd
)->s
->sizeof_phdr
;
1754 if ((abfd
->flags
& D_PAGED
) == 0
1755 || sections
[0]->lma
% maxpagesize
< phdr_size
% maxpagesize
)
1756 phdr_in_section
= false;
1759 for (i
= 0, hdrpp
= sections
; i
< count
; i
++, hdrpp
++)
1762 boolean new_segment
;
1766 /* See if this section and the last one will fit in the same
1769 if (last_hdr
== NULL
)
1771 /* If we don't have a segment yet, then we don't need a new
1772 one (we build the last one after this loop). */
1773 new_segment
= false;
1775 else if (last_hdr
->lma
- last_hdr
->vma
!= hdr
->lma
- hdr
->vma
)
1777 /* If this section has a different relation between the
1778 virtual address and the load address, then we need a new
1782 else if ((abfd
->flags
& D_PAGED
) == 0)
1784 /* If the file is not demand paged, which means that we
1785 don't require the sections to be correctly aligned in the
1786 file, then there is no other reason for a new segment. */
1787 new_segment
= false;
1789 else if (BFD_ALIGN (last_hdr
->lma
+ last_hdr
->_raw_size
, maxpagesize
)
1792 /* If putting this section in this segment would force us to
1793 skip a page in the segment, then we need a new segment. */
1796 else if ((last_hdr
->flags
& SEC_LOAD
) == 0
1797 && (hdr
->flags
& SEC_LOAD
) != 0)
1799 /* We don't want to put a loadable section after a
1800 nonloadable section in the same segment. */
1804 && (hdr
->flags
& SEC_READONLY
) == 0
1805 && (BFD_ALIGN (last_hdr
->lma
+ last_hdr
->_raw_size
, maxpagesize
)
1808 /* We don't want to put a writable section in a read only
1809 segment, unless they are on the same page in memory
1810 anyhow. We already know that the last section does not
1811 bring us past the current section on the page, so the
1812 only case in which the new section is not on the same
1813 page as the previous section is when the previous section
1814 ends precisely on a page boundary. */
1819 /* Otherwise, we can use the same segment. */
1820 new_segment
= false;
1825 if ((hdr
->flags
& SEC_READONLY
) == 0)
1831 /* We need a new program segment. We must create a new program
1832 header holding all the sections from phdr_index until hdr. */
1834 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_section
);
1841 if ((hdr
->flags
& SEC_READONLY
) == 0)
1848 phdr_in_section
= false;
1851 /* Create a final PT_LOAD program segment. */
1852 if (last_hdr
!= NULL
)
1854 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_section
);
1862 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
1865 m
= ((struct elf_segment_map
*)
1866 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
1870 m
->p_type
= PT_DYNAMIC
;
1872 m
->sections
[0] = dynsec
;
1881 elf_tdata (abfd
)->segment_map
= mfirst
;
1885 if (sections
!= NULL
)
1890 /* Sort sections by VMA. */
1893 elf_sort_sections (arg1
, arg2
)
1897 const asection
*sec1
= *(const asection
**) arg1
;
1898 const asection
*sec2
= *(const asection
**) arg2
;
1900 if (sec1
->vma
< sec2
->vma
)
1902 else if (sec1
->vma
> sec2
->vma
)
1905 /* Sort by LMA. Normally the LMA and the VMA will be the same, and
1906 this will do nothing. */
1907 if (sec1
->lma
< sec2
->lma
)
1909 else if (sec1
->lma
> sec2
->lma
)
1912 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
1914 #define TOEND(x) (((x)->flags & SEC_LOAD) == 0)
1918 return sec1
->target_index
- sec2
->target_index
;
1927 /* Sort by size, to put zero sized sections before others at the
1930 if (sec1
->_raw_size
< sec2
->_raw_size
)
1932 if (sec1
->_raw_size
> sec2
->_raw_size
)
1935 return sec1
->target_index
- sec2
->target_index
;
1938 /* Assign file positions to the sections based on the mapping from
1939 sections to segments. This function also sets up some fields in
1940 the file header, and writes out the program headers. */
1943 assign_file_positions_for_segments (abfd
)
1946 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1948 struct elf_segment_map
*m
;
1950 Elf_Internal_Phdr
*phdrs
;
1952 bfd_vma filehdr_vaddr
, filehdr_paddr
;
1953 bfd_vma phdrs_vaddr
, phdrs_paddr
;
1954 Elf_Internal_Phdr
*p
;
1956 if (elf_tdata (abfd
)->segment_map
== NULL
)
1958 if (! map_sections_to_segments (abfd
))
1962 if (bed
->elf_backend_modify_segment_map
)
1964 if (! (*bed
->elf_backend_modify_segment_map
) (abfd
))
1969 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
1972 elf_elfheader (abfd
)->e_phoff
= bed
->s
->sizeof_ehdr
;
1973 elf_elfheader (abfd
)->e_phentsize
= bed
->s
->sizeof_phdr
;
1974 elf_elfheader (abfd
)->e_phnum
= count
;
1979 /* If we already counted the number of program segments, make sure
1980 that we allocated enough space. This happens when SIZEOF_HEADERS
1981 is used in a linker script. */
1982 alloc
= elf_tdata (abfd
)->program_header_size
/ bed
->s
->sizeof_phdr
;
1983 if (alloc
!= 0 && count
> alloc
)
1985 ((*_bfd_error_handler
)
1986 ("%s: Not enough room for program headers (allocated %u, need %u)",
1987 bfd_get_filename (abfd
), alloc
, count
));
1988 bfd_set_error (bfd_error_bad_value
);
1995 phdrs
= ((Elf_Internal_Phdr
*)
1996 bfd_alloc (abfd
, alloc
* sizeof (Elf_Internal_Phdr
)));
2000 off
= bed
->s
->sizeof_ehdr
;
2001 off
+= alloc
* bed
->s
->sizeof_phdr
;
2007 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
2014 /* If elf_segment_map is not from map_sections_to_segments, the
2015 sections may not be correctly ordered. */
2017 qsort (m
->sections
, (size_t) m
->count
, sizeof (asection
*),
2020 p
->p_type
= m
->p_type
;
2022 if (m
->p_flags_valid
)
2023 p
->p_flags
= m
->p_flags
;
2027 if (p
->p_type
== PT_LOAD
2029 && (m
->sections
[0]->flags
& SEC_LOAD
) != 0)
2031 if ((abfd
->flags
& D_PAGED
) != 0)
2032 off
+= (m
->sections
[0]->vma
- off
) % bed
->maxpagesize
;
2034 off
+= ((m
->sections
[0]->vma
- off
)
2035 % (1 << bfd_get_section_alignment (abfd
, m
->sections
[0])));
2041 p
->p_vaddr
= m
->sections
[0]->vma
;
2043 if (m
->p_paddr_valid
)
2044 p
->p_paddr
= m
->p_paddr
;
2045 else if (m
->count
== 0)
2048 p
->p_paddr
= m
->sections
[0]->lma
;
2050 if (p
->p_type
== PT_LOAD
2051 && (abfd
->flags
& D_PAGED
) != 0)
2052 p
->p_align
= bed
->maxpagesize
;
2053 else if (m
->count
== 0)
2054 p
->p_align
= bed
->s
->file_align
;
2062 if (m
->includes_filehdr
)
2064 if (! m
->p_flags_valid
)
2067 p
->p_filesz
= bed
->s
->sizeof_ehdr
;
2068 p
->p_memsz
= bed
->s
->sizeof_ehdr
;
2071 BFD_ASSERT (p
->p_type
== PT_LOAD
);
2073 if (! m
->p_paddr_valid
)
2076 if (p
->p_type
== PT_LOAD
)
2078 filehdr_vaddr
= p
->p_vaddr
;
2079 filehdr_paddr
= p
->p_paddr
;
2083 if (m
->includes_phdrs
)
2085 if (! m
->p_flags_valid
)
2087 if (m
->includes_filehdr
)
2089 if (p
->p_type
== PT_LOAD
)
2091 phdrs_vaddr
= p
->p_vaddr
+ bed
->s
->sizeof_ehdr
;
2092 phdrs_paddr
= p
->p_paddr
+ bed
->s
->sizeof_ehdr
;
2097 p
->p_offset
= bed
->s
->sizeof_ehdr
;
2100 BFD_ASSERT (p
->p_type
== PT_LOAD
);
2101 p
->p_vaddr
-= off
- p
->p_offset
;
2102 if (! m
->p_paddr_valid
)
2103 p
->p_paddr
-= off
- p
->p_offset
;
2105 if (p
->p_type
== PT_LOAD
)
2107 phdrs_vaddr
= p
->p_vaddr
;
2108 phdrs_paddr
= p
->p_paddr
;
2111 p
->p_filesz
+= alloc
* bed
->s
->sizeof_phdr
;
2112 p
->p_memsz
+= alloc
* bed
->s
->sizeof_phdr
;
2115 if (p
->p_type
== PT_LOAD
)
2117 if (! m
->includes_filehdr
&& ! m
->includes_phdrs
)
2123 adjust
= off
- (p
->p_offset
+ p
->p_filesz
);
2124 p
->p_filesz
+= adjust
;
2125 p
->p_memsz
+= adjust
;
2130 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
2134 bfd_size_type align
;
2138 align
= 1 << bfd_get_section_alignment (abfd
, sec
);
2140 if (p
->p_type
== PT_LOAD
)
2144 /* The section VMA must equal the file position modulo
2146 if ((flags
& SEC_ALLOC
) != 0)
2148 if ((abfd
->flags
& D_PAGED
) != 0)
2149 adjust
= (sec
->vma
- voff
) % bed
->maxpagesize
;
2151 adjust
= (sec
->vma
- voff
) % align
;
2156 p
->p_memsz
+= adjust
;
2159 if ((flags
& SEC_LOAD
) != 0)
2160 p
->p_filesz
+= adjust
;
2166 if ((flags
& SEC_LOAD
) != 0)
2167 off
+= sec
->_raw_size
;
2168 if ((flags
& SEC_ALLOC
) != 0)
2169 voff
+= sec
->_raw_size
;
2172 p
->p_memsz
+= sec
->_raw_size
;
2174 if ((flags
& SEC_LOAD
) != 0)
2175 p
->p_filesz
+= sec
->_raw_size
;
2177 if (align
> p
->p_align
)
2180 if (! m
->p_flags_valid
)
2183 if ((flags
& SEC_CODE
) != 0)
2185 if ((flags
& SEC_READONLY
) == 0)
2191 /* Now that we have set the section file positions, we can set up
2192 the file positions for the non PT_LOAD segments. */
2193 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
2197 if (p
->p_type
!= PT_LOAD
&& m
->count
> 0)
2199 BFD_ASSERT (! m
->includes_filehdr
&& ! m
->includes_phdrs
);
2200 p
->p_offset
= m
->sections
[0]->filepos
;
2204 if (m
->includes_filehdr
)
2206 p
->p_vaddr
= filehdr_vaddr
;
2207 if (! m
->p_paddr_valid
)
2208 p
->p_paddr
= filehdr_paddr
;
2210 else if (m
->includes_phdrs
)
2212 p
->p_vaddr
= phdrs_vaddr
;
2213 if (! m
->p_paddr_valid
)
2214 p
->p_paddr
= phdrs_paddr
;
2219 /* Clear out any program headers we allocated but did not use. */
2220 for (; count
< alloc
; count
++, p
++)
2222 memset (p
, 0, sizeof *p
);
2223 p
->p_type
= PT_NULL
;
2226 elf_tdata (abfd
)->phdr
= phdrs
;
2228 elf_tdata (abfd
)->next_file_pos
= off
;
2230 /* Write out the program headers. */
2231 if (bfd_seek (abfd
, bed
->s
->sizeof_ehdr
, SEEK_SET
) != 0
2232 || bed
->s
->write_out_phdrs (abfd
, phdrs
, alloc
) != 0)
2238 /* Get the size of the program header.
2240 If this is called by the linker before any of the section VMA's are set, it
2241 can't calculate the correct value for a strange memory layout. This only
2242 happens when SIZEOF_HEADERS is used in a linker script. In this case,
2243 SORTED_HDRS is NULL and we assume the normal scenario of one text and one
2244 data segment (exclusive of .interp and .dynamic).
2246 ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
2247 will be two segments. */
2249 static bfd_size_type
2250 get_program_header_size (abfd
)
2255 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2257 /* We can't return a different result each time we're called. */
2258 if (elf_tdata (abfd
)->program_header_size
!= 0)
2259 return elf_tdata (abfd
)->program_header_size
;
2261 if (elf_tdata (abfd
)->segment_map
!= NULL
)
2263 struct elf_segment_map
*m
;
2266 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
2268 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
2269 return elf_tdata (abfd
)->program_header_size
;
2272 /* Assume we will need exactly two PT_LOAD segments: one for text
2273 and one for data. */
2276 s
= bfd_get_section_by_name (abfd
, ".interp");
2277 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
2279 /* If we have a loadable interpreter section, we need a
2280 PT_INTERP segment. In this case, assume we also need a
2281 PT_PHDR segment, although that may not be true for all
2286 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
2288 /* We need a PT_DYNAMIC segment. */
2292 /* Let the backend count up any program headers it might need. */
2293 if (bed
->elf_backend_additional_program_headers
)
2297 a
= (*bed
->elf_backend_additional_program_headers
) (abfd
);
2303 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
2304 return elf_tdata (abfd
)->program_header_size
;
2307 /* Work out the file positions of all the sections. This is called by
2308 _bfd_elf_compute_section_file_positions. All the section sizes and
2309 VMAs must be known before this is called.
2311 We do not consider reloc sections at this point, unless they form
2312 part of the loadable image. Reloc sections are assigned file
2313 positions in assign_file_positions_for_relocs, which is called by
2314 write_object_contents and final_link.
2316 We also don't set the positions of the .symtab and .strtab here. */
2319 assign_file_positions_except_relocs (abfd
)
2322 struct elf_obj_tdata
* const tdata
= elf_tdata (abfd
);
2323 Elf_Internal_Ehdr
* const i_ehdrp
= elf_elfheader (abfd
);
2324 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
2326 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2328 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
2330 Elf_Internal_Shdr
**hdrpp
;
2333 /* Start after the ELF header. */
2334 off
= i_ehdrp
->e_ehsize
;
2336 /* We are not creating an executable, which means that we are
2337 not creating a program header, and that the actual order of
2338 the sections in the file is unimportant. */
2339 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2341 Elf_Internal_Shdr
*hdr
;
2344 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
2346 hdr
->sh_offset
= -1;
2349 if (i
== tdata
->symtab_section
2350 || i
== tdata
->strtab_section
)
2352 hdr
->sh_offset
= -1;
2356 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
2362 Elf_Internal_Shdr
**hdrpp
;
2364 /* Assign file positions for the loaded sections based on the
2365 assignment of sections to segments. */
2366 if (! assign_file_positions_for_segments (abfd
))
2369 /* Assign file positions for the other sections. */
2371 off
= elf_tdata (abfd
)->next_file_pos
;
2372 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2374 Elf_Internal_Shdr
*hdr
;
2377 if (hdr
->bfd_section
!= NULL
2378 && hdr
->bfd_section
->filepos
!= 0)
2379 hdr
->sh_offset
= hdr
->bfd_section
->filepos
;
2380 else if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
2382 ((*_bfd_error_handler
)
2383 ("%s: warning: allocated section `%s' not in segment",
2384 bfd_get_filename (abfd
),
2385 (hdr
->bfd_section
== NULL
2387 : hdr
->bfd_section
->name
)));
2388 if ((abfd
->flags
& D_PAGED
) != 0)
2389 off
+= (hdr
->sh_addr
- off
) % bed
->maxpagesize
;
2391 off
+= (hdr
->sh_addr
- off
) % hdr
->sh_addralign
;
2392 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
,
2395 else if (hdr
->sh_type
== SHT_REL
2396 || hdr
->sh_type
== SHT_RELA
2397 || hdr
== i_shdrpp
[tdata
->symtab_section
]
2398 || hdr
== i_shdrpp
[tdata
->strtab_section
])
2399 hdr
->sh_offset
= -1;
2401 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
2405 /* Place the section headers. */
2406 off
= align_file_position (off
, bed
->s
->file_align
);
2407 i_ehdrp
->e_shoff
= off
;
2408 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
2410 elf_tdata (abfd
)->next_file_pos
= off
;
2419 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2420 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
2421 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2423 struct bfd_strtab_hash
*shstrtab
;
2424 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2426 i_ehdrp
= elf_elfheader (abfd
);
2427 i_shdrp
= elf_elfsections (abfd
);
2429 shstrtab
= _bfd_elf_stringtab_init ();
2430 if (shstrtab
== NULL
)
2433 elf_shstrtab (abfd
) = shstrtab
;
2435 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
2436 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
2437 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
2438 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
2440 i_ehdrp
->e_ident
[EI_CLASS
] = bed
->s
->elfclass
;
2441 i_ehdrp
->e_ident
[EI_DATA
] =
2442 bfd_big_endian (abfd
) ? ELFDATA2MSB
: ELFDATA2LSB
;
2443 i_ehdrp
->e_ident
[EI_VERSION
] = bed
->s
->ev_current
;
2445 for (count
= EI_PAD
; count
< EI_NIDENT
; count
++)
2446 i_ehdrp
->e_ident
[count
] = 0;
2448 if ((abfd
->flags
& DYNAMIC
) != 0)
2449 i_ehdrp
->e_type
= ET_DYN
;
2450 else if ((abfd
->flags
& EXEC_P
) != 0)
2451 i_ehdrp
->e_type
= ET_EXEC
;
2453 i_ehdrp
->e_type
= ET_REL
;
2455 switch (bfd_get_arch (abfd
))
2457 case bfd_arch_unknown
:
2458 i_ehdrp
->e_machine
= EM_NONE
;
2460 case bfd_arch_sparc
:
2461 if (bed
->s
->arch_size
== 64)
2462 i_ehdrp
->e_machine
= EM_SPARC64
;
2464 i_ehdrp
->e_machine
= EM_SPARC
;
2467 i_ehdrp
->e_machine
= EM_386
;
2470 i_ehdrp
->e_machine
= EM_68K
;
2473 i_ehdrp
->e_machine
= EM_88K
;
2476 i_ehdrp
->e_machine
= EM_860
;
2478 case bfd_arch_mips
: /* MIPS Rxxxx */
2479 i_ehdrp
->e_machine
= EM_MIPS
; /* only MIPS R3000 */
2482 i_ehdrp
->e_machine
= EM_PARISC
;
2484 case bfd_arch_powerpc
:
2485 i_ehdrp
->e_machine
= EM_PPC
;
2487 case bfd_arch_alpha
:
2488 i_ehdrp
->e_machine
= EM_ALPHA
;
2490 /* start-sanitize-d10v */
2492 i_ehdrp
->e_machine
= EM_CYGNUS_D10V
;
2494 /* end-sanitize-d10v */
2495 /* start-sanitize-arc */
2497 i_ehdrp
->e_machine
= EM_CYGNUS_ARC
;
2499 /* end-sanitize-arc */
2500 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
2502 i_ehdrp
->e_machine
= EM_NONE
;
2504 i_ehdrp
->e_version
= bed
->s
->ev_current
;
2505 i_ehdrp
->e_ehsize
= bed
->s
->sizeof_ehdr
;
2507 /* no program header, for now. */
2508 i_ehdrp
->e_phoff
= 0;
2509 i_ehdrp
->e_phentsize
= 0;
2510 i_ehdrp
->e_phnum
= 0;
2512 /* each bfd section is section header entry */
2513 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
2514 i_ehdrp
->e_shentsize
= bed
->s
->sizeof_shdr
;
2516 /* if we're building an executable, we'll need a program header table */
2517 if (abfd
->flags
& EXEC_P
)
2519 /* it all happens later */
2521 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
2523 /* elf_build_phdrs() returns a (NULL-terminated) array of
2524 Elf_Internal_Phdrs */
2525 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
2526 i_ehdrp
->e_phoff
= outbase
;
2527 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
2532 i_ehdrp
->e_phentsize
= 0;
2534 i_ehdrp
->e_phoff
= 0;
2537 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
2538 (unsigned int) _bfd_stringtab_add (shstrtab
, ".symtab", true, false);
2539 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
2540 (unsigned int) _bfd_stringtab_add (shstrtab
, ".strtab", true, false);
2541 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
2542 (unsigned int) _bfd_stringtab_add (shstrtab
, ".shstrtab", true, false);
2543 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2544 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2545 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
2551 /* Assign file positions for all the reloc sections which are not part
2552 of the loadable file image. */
2555 _bfd_elf_assign_file_positions_for_relocs (abfd
)
2560 Elf_Internal_Shdr
**shdrpp
;
2562 off
= elf_tdata (abfd
)->next_file_pos
;
2564 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1;
2565 i
< elf_elfheader (abfd
)->e_shnum
;
2568 Elf_Internal_Shdr
*shdrp
;
2571 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
2572 && shdrp
->sh_offset
== -1)
2573 off
= _bfd_elf_assign_file_position_for_section (shdrp
, off
, true);
2576 elf_tdata (abfd
)->next_file_pos
= off
;
2580 _bfd_elf_write_object_contents (abfd
)
2583 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2584 Elf_Internal_Ehdr
*i_ehdrp
;
2585 Elf_Internal_Shdr
**i_shdrp
;
2589 if (! abfd
->output_has_begun
2590 && ! _bfd_elf_compute_section_file_positions (abfd
,
2591 (struct bfd_link_info
*) NULL
))
2594 i_shdrp
= elf_elfsections (abfd
);
2595 i_ehdrp
= elf_elfheader (abfd
);
2598 bfd_map_over_sections (abfd
, bed
->s
->write_relocs
, &failed
);
2601 _bfd_elf_assign_file_positions_for_relocs (abfd
);
2603 /* After writing the headers, we need to write the sections too... */
2604 for (count
= 1; count
< i_ehdrp
->e_shnum
; count
++)
2606 if (bed
->elf_backend_section_processing
)
2607 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
2608 if (i_shdrp
[count
]->contents
)
2610 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
2611 || (bfd_write (i_shdrp
[count
]->contents
, i_shdrp
[count
]->sh_size
,
2613 != i_shdrp
[count
]->sh_size
))
2618 /* Write out the section header names. */
2619 if (bfd_seek (abfd
, elf_tdata (abfd
)->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
2620 || ! _bfd_stringtab_emit (abfd
, elf_shstrtab (abfd
)))
2623 if (bed
->elf_backend_final_write_processing
)
2624 (*bed
->elf_backend_final_write_processing
) (abfd
,
2625 elf_tdata (abfd
)->linker
);
2627 return bed
->s
->write_shdrs_and_ehdr (abfd
);
2630 /* given a section, search the header to find them... */
2632 _bfd_elf_section_from_bfd_section (abfd
, asect
)
2636 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2637 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
2639 Elf_Internal_Shdr
*hdr
;
2640 int maxindex
= elf_elfheader (abfd
)->e_shnum
;
2642 for (index
= 0; index
< maxindex
; index
++)
2644 hdr
= i_shdrp
[index
];
2645 if (hdr
->bfd_section
== asect
)
2649 if (bed
->elf_backend_section_from_bfd_section
)
2651 for (index
= 0; index
< maxindex
; index
++)
2655 hdr
= i_shdrp
[index
];
2657 if ((*bed
->elf_backend_section_from_bfd_section
)
2658 (abfd
, hdr
, asect
, &retval
))
2663 if (bfd_is_abs_section (asect
))
2665 if (bfd_is_com_section (asect
))
2667 if (bfd_is_und_section (asect
))
2673 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
2677 _bfd_elf_symbol_from_bfd_symbol (abfd
, asym_ptr_ptr
)
2679 asymbol
**asym_ptr_ptr
;
2681 asymbol
*asym_ptr
= *asym_ptr_ptr
;
2683 flagword flags
= asym_ptr
->flags
;
2685 /* When gas creates relocations against local labels, it creates its
2686 own symbol for the section, but does put the symbol into the
2687 symbol chain, so udata is 0. When the linker is generating
2688 relocatable output, this section symbol may be for one of the
2689 input sections rather than the output section. */
2690 if (asym_ptr
->udata
.i
== 0
2691 && (flags
& BSF_SECTION_SYM
)
2692 && asym_ptr
->section
)
2696 if (asym_ptr
->section
->output_section
!= NULL
)
2697 indx
= asym_ptr
->section
->output_section
->index
;
2699 indx
= asym_ptr
->section
->index
;
2700 if (elf_section_syms (abfd
)[indx
])
2701 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
2704 idx
= asym_ptr
->udata
.i
;
2708 /* This case can occur when using --strip-symbol on a symbol
2709 which is used in a relocation entry. */
2710 (*_bfd_error_handler
)
2711 ("%s: symbol `%s' required but not present",
2712 bfd_get_filename (abfd
), bfd_asymbol_name (asym_ptr
));
2713 bfd_set_error (bfd_error_no_symbols
);
2720 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
2721 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
,
2722 elf_symbol_flags (flags
));
2730 /* Copy private BFD data. This copies any program header information. */
2733 copy_private_bfd_data (ibfd
, obfd
)
2737 Elf_Internal_Ehdr
*iehdr
;
2738 struct elf_segment_map
*mfirst
;
2739 struct elf_segment_map
**pm
;
2740 Elf_Internal_Phdr
*p
;
2743 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2744 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2747 if (elf_tdata (ibfd
)->phdr
== NULL
)
2750 iehdr
= elf_elfheader (ibfd
);
2755 c
= elf_elfheader (ibfd
)->e_phnum
;
2756 for (i
= 0, p
= elf_tdata (ibfd
)->phdr
; i
< c
; i
++, p
++)
2760 struct elf_segment_map
*m
;
2765 /* The complicated case when p_vaddr is 0 is to handle the
2766 Solaris linker, which generates a PT_INTERP section with
2767 p_vaddr and p_memsz set to 0. */
2768 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2769 if (((s
->vma
>= p
->p_vaddr
2770 && (s
->vma
+ s
->_raw_size
<= p
->p_vaddr
+ p
->p_memsz
2771 || s
->vma
+ s
->_raw_size
<= p
->p_vaddr
+ p
->p_filesz
))
2774 && (s
->flags
& SEC_HAS_CONTENTS
) != 0
2775 && (bfd_vma
) s
->filepos
>= p
->p_offset
2776 && ((bfd_vma
) s
->filepos
+ s
->_raw_size
2777 <= p
->p_offset
+ p
->p_filesz
)))
2778 && (s
->flags
& SEC_ALLOC
) != 0
2779 && s
->output_section
!= NULL
)
2782 m
= ((struct elf_segment_map
*)
2784 (sizeof (struct elf_segment_map
)
2785 + (csecs
- 1) * sizeof (asection
*))));
2790 m
->p_type
= p
->p_type
;
2791 m
->p_flags
= p
->p_flags
;
2792 m
->p_flags_valid
= 1;
2793 m
->p_paddr
= p
->p_paddr
;
2794 m
->p_paddr_valid
= 1;
2796 m
->includes_filehdr
= (p
->p_offset
== 0
2797 && p
->p_filesz
>= iehdr
->e_ehsize
);
2799 m
->includes_phdrs
= (p
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
2800 && (p
->p_offset
+ p
->p_filesz
2801 >= ((bfd_vma
) iehdr
->e_phoff
2802 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
2805 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2807 if (((s
->vma
>= p
->p_vaddr
2808 && (s
->vma
+ s
->_raw_size
<= p
->p_vaddr
+ p
->p_memsz
2809 || s
->vma
+ s
->_raw_size
<= p
->p_vaddr
+ p
->p_filesz
))
2812 && (s
->flags
& SEC_HAS_CONTENTS
) != 0
2813 && (bfd_vma
) s
->filepos
>= p
->p_offset
2814 && ((bfd_vma
) s
->filepos
+ s
->_raw_size
2815 <= p
->p_offset
+ p
->p_filesz
)))
2816 && (s
->flags
& SEC_ALLOC
) != 0
2817 && s
->output_section
!= NULL
)
2819 m
->sections
[isec
] = s
->output_section
;
2823 BFD_ASSERT (isec
== csecs
);
2830 elf_tdata (obfd
)->segment_map
= mfirst
;
2835 /* Copy private section information. This copies over the entsize
2836 field, and sometimes the info field. */
2839 _bfd_elf_copy_private_section_data (ibfd
, isec
, obfd
, osec
)
2845 Elf_Internal_Shdr
*ihdr
, *ohdr
;
2847 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
2848 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
2851 /* Copy over private BFD data if it has not already been copied.
2852 This must be done here, rather than in the copy_private_bfd_data
2853 entry point, because the latter is called after the section
2854 contents have been set, which means that the program headers have
2855 already been worked out. */
2856 if (elf_tdata (obfd
)->segment_map
== NULL
2857 && elf_tdata (ibfd
)->phdr
!= NULL
)
2861 /* Only set up the segments when all the sections have been set
2863 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2864 if (s
->output_section
== NULL
)
2868 if (! copy_private_bfd_data (ibfd
, obfd
))
2873 ihdr
= &elf_section_data (isec
)->this_hdr
;
2874 ohdr
= &elf_section_data (osec
)->this_hdr
;
2876 ohdr
->sh_entsize
= ihdr
->sh_entsize
;
2878 if (ihdr
->sh_type
== SHT_SYMTAB
2879 || ihdr
->sh_type
== SHT_DYNSYM
)
2880 ohdr
->sh_info
= ihdr
->sh_info
;
2885 /* Copy private symbol information. If this symbol is in a section
2886 which we did not map into a BFD section, try to map the section
2887 index correctly. We use special macro definitions for the mapped
2888 section indices; these definitions are interpreted by the
2889 swap_out_syms function. */
2891 #define MAP_ONESYMTAB (SHN_LORESERVE - 1)
2892 #define MAP_DYNSYMTAB (SHN_LORESERVE - 2)
2893 #define MAP_STRTAB (SHN_LORESERVE - 3)
2894 #define MAP_SHSTRTAB (SHN_LORESERVE - 4)
2897 _bfd_elf_copy_private_symbol_data (ibfd
, isymarg
, obfd
, osymarg
)
2903 elf_symbol_type
*isym
, *osym
;
2905 isym
= elf_symbol_from (ibfd
, isymarg
);
2906 osym
= elf_symbol_from (obfd
, osymarg
);
2910 && bfd_is_abs_section (isym
->symbol
.section
))
2914 shndx
= isym
->internal_elf_sym
.st_shndx
;
2915 if (shndx
== elf_onesymtab (ibfd
))
2916 shndx
= MAP_ONESYMTAB
;
2917 else if (shndx
== elf_dynsymtab (ibfd
))
2918 shndx
= MAP_DYNSYMTAB
;
2919 else if (shndx
== elf_tdata (ibfd
)->strtab_section
)
2921 else if (shndx
== elf_tdata (ibfd
)->shstrtab_section
)
2922 shndx
= MAP_SHSTRTAB
;
2923 osym
->internal_elf_sym
.st_shndx
= shndx
;
2929 /* Swap out the symbols. */
2932 swap_out_syms (abfd
, sttp
)
2934 struct bfd_strtab_hash
**sttp
;
2936 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2938 if (!elf_map_symbols (abfd
))
2941 /* Dump out the symtabs. */
2943 int symcount
= bfd_get_symcount (abfd
);
2944 asymbol
**syms
= bfd_get_outsymbols (abfd
);
2945 struct bfd_strtab_hash
*stt
;
2946 Elf_Internal_Shdr
*symtab_hdr
;
2947 Elf_Internal_Shdr
*symstrtab_hdr
;
2948 char *outbound_syms
;
2951 stt
= _bfd_elf_stringtab_init ();
2955 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2956 symtab_hdr
->sh_type
= SHT_SYMTAB
;
2957 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
2958 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
2959 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
2960 symtab_hdr
->sh_addralign
= bed
->s
->file_align
;
2962 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2963 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2965 outbound_syms
= bfd_alloc (abfd
,
2966 (1 + symcount
) * bed
->s
->sizeof_sym
);
2967 if (outbound_syms
== NULL
)
2969 symtab_hdr
->contents
= (PTR
) outbound_syms
;
2971 /* now generate the data (for "contents") */
2973 /* Fill in zeroth symbol and swap it out. */
2974 Elf_Internal_Sym sym
;
2980 sym
.st_shndx
= SHN_UNDEF
;
2981 bed
->s
->swap_symbol_out (abfd
, &sym
, (PTR
) outbound_syms
);
2982 outbound_syms
+= bed
->s
->sizeof_sym
;
2984 for (idx
= 0; idx
< symcount
; idx
++)
2986 Elf_Internal_Sym sym
;
2987 bfd_vma value
= syms
[idx
]->value
;
2988 elf_symbol_type
*type_ptr
;
2989 flagword flags
= syms
[idx
]->flags
;
2992 if (flags
& BSF_SECTION_SYM
)
2993 /* Section symbols have no names. */
2997 sym
.st_name
= (unsigned long) _bfd_stringtab_add (stt
,
3000 if (sym
.st_name
== (unsigned long) -1)
3004 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
3006 if (bfd_is_com_section (syms
[idx
]->section
))
3008 /* ELF common symbols put the alignment into the `value' field,
3009 and the size into the `size' field. This is backwards from
3010 how BFD handles it, so reverse it here. */
3011 sym
.st_size
= value
;
3012 if (type_ptr
== NULL
3013 || type_ptr
->internal_elf_sym
.st_value
== 0)
3014 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
3016 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
3017 sym
.st_shndx
= _bfd_elf_section_from_bfd_section (abfd
,
3018 syms
[idx
]->section
);
3022 asection
*sec
= syms
[idx
]->section
;
3025 if (sec
->output_section
)
3027 value
+= sec
->output_offset
;
3028 sec
= sec
->output_section
;
3031 sym
.st_value
= value
;
3032 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
3034 if (bfd_is_abs_section (sec
)
3036 && type_ptr
->internal_elf_sym
.st_shndx
!= 0)
3038 /* This symbol is in a real ELF section which we did
3039 not create as a BFD section. Undo the mapping done
3040 by copy_private_symbol_data. */
3041 shndx
= type_ptr
->internal_elf_sym
.st_shndx
;
3045 shndx
= elf_onesymtab (abfd
);
3048 shndx
= elf_dynsymtab (abfd
);
3051 shndx
= elf_tdata (abfd
)->strtab_section
;
3054 shndx
= elf_tdata (abfd
)->shstrtab_section
;
3062 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
3068 /* Writing this would be a hell of a lot easier if
3069 we had some decent documentation on bfd, and
3070 knew what to expect of the library, and what to
3071 demand of applications. For example, it
3072 appears that `objcopy' might not set the
3073 section of a symbol to be a section that is
3074 actually in the output file. */
3075 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
3076 BFD_ASSERT (sec2
!= 0);
3077 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
3078 BFD_ASSERT (shndx
!= -1);
3082 sym
.st_shndx
= shndx
;
3085 if ((flags
& BSF_FUNCTION
) != 0)
3087 else if ((flags
& BSF_OBJECT
) != 0)
3092 if (bfd_is_com_section (syms
[idx
]->section
))
3093 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, type
);
3094 else if (bfd_is_und_section (syms
[idx
]->section
))
3095 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
3099 else if (flags
& BSF_SECTION_SYM
)
3100 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
3101 else if (flags
& BSF_FILE
)
3102 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
3105 int bind
= STB_LOCAL
;
3107 if (flags
& BSF_LOCAL
)
3109 else if (flags
& BSF_WEAK
)
3111 else if (flags
& BSF_GLOBAL
)
3114 sym
.st_info
= ELF_ST_INFO (bind
, type
);
3118 bed
->s
->swap_symbol_out (abfd
, &sym
, (PTR
) outbound_syms
);
3119 outbound_syms
+= bed
->s
->sizeof_sym
;
3123 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (stt
);
3124 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
3126 symstrtab_hdr
->sh_flags
= 0;
3127 symstrtab_hdr
->sh_addr
= 0;
3128 symstrtab_hdr
->sh_entsize
= 0;
3129 symstrtab_hdr
->sh_link
= 0;
3130 symstrtab_hdr
->sh_info
= 0;
3131 symstrtab_hdr
->sh_addralign
= 1;
3137 /* Return the number of bytes required to hold the symtab vector.
3139 Note that we base it on the count plus 1, since we will null terminate
3140 the vector allocated based on this size. However, the ELF symbol table
3141 always has a dummy entry as symbol #0, so it ends up even. */
3144 _bfd_elf_get_symtab_upper_bound (abfd
)
3149 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3151 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
3152 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
3158 _bfd_elf_get_dynamic_symtab_upper_bound (abfd
)
3163 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
3165 if (elf_dynsymtab (abfd
) == 0)
3167 bfd_set_error (bfd_error_invalid_operation
);
3171 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
3172 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
3178 _bfd_elf_get_reloc_upper_bound (abfd
, asect
)
3182 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
3185 /* Canonicalize the relocs. */
3188 _bfd_elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
3197 if (! get_elf_backend_data (abfd
)->s
->slurp_reloc_table (abfd
, section
, symbols
))
3200 tblptr
= section
->relocation
;
3201 for (i
= 0; i
< section
->reloc_count
; i
++)
3202 *relptr
++ = tblptr
++;
3206 return section
->reloc_count
;
3210 _bfd_elf_get_symtab (abfd
, alocation
)
3212 asymbol
**alocation
;
3214 long symcount
= get_elf_backend_data (abfd
)->s
->slurp_symbol_table (abfd
, alocation
, false);
3217 bfd_get_symcount (abfd
) = symcount
;
3222 _bfd_elf_canonicalize_dynamic_symtab (abfd
, alocation
)
3224 asymbol
**alocation
;
3226 return get_elf_backend_data (abfd
)->s
->slurp_symbol_table (abfd
, alocation
, true);
3230 _bfd_elf_make_empty_symbol (abfd
)
3233 elf_symbol_type
*newsym
;
3235 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (elf_symbol_type
));
3240 newsym
->symbol
.the_bfd
= abfd
;
3241 return &newsym
->symbol
;
3246 _bfd_elf_get_symbol_info (ignore_abfd
, symbol
, ret
)
3251 bfd_symbol_info (symbol
, ret
);
3255 _bfd_elf_get_lineno (ignore_abfd
, symbol
)
3264 _bfd_elf_set_arch_mach (abfd
, arch
, machine
)
3266 enum bfd_architecture arch
;
3267 unsigned long machine
;
3269 /* If this isn't the right architecture for this backend, and this
3270 isn't the generic backend, fail. */
3271 if (arch
!= get_elf_backend_data (abfd
)->arch
3272 && arch
!= bfd_arch_unknown
3273 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
3276 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
3279 /* Find the nearest line to a particular section and offset, for error
3283 _bfd_elf_find_nearest_line (abfd
,
3294 CONST
char **filename_ptr
;
3295 CONST
char **functionname_ptr
;
3296 unsigned int *line_ptr
;
3299 const char *filename
;
3304 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
3305 &found
, filename_ptr
,
3306 functionname_ptr
, line_ptr
,
3307 &elf_tdata (abfd
)->line_info
))
3312 if (symbols
== NULL
)
3319 for (p
= symbols
; *p
!= NULL
; p
++)
3323 q
= (elf_symbol_type
*) *p
;
3325 if (bfd_get_section (&q
->symbol
) != section
)
3328 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
3333 filename
= bfd_asymbol_name (&q
->symbol
);
3336 if (q
->symbol
.section
== section
3337 && q
->symbol
.value
>= low_func
3338 && q
->symbol
.value
<= offset
)
3340 func
= (asymbol
*) q
;
3341 low_func
= q
->symbol
.value
;
3350 *filename_ptr
= filename
;
3351 *functionname_ptr
= bfd_asymbol_name (func
);
3357 _bfd_elf_sizeof_headers (abfd
, reloc
)
3363 ret
= get_elf_backend_data (abfd
)->s
->sizeof_ehdr
;
3365 ret
+= get_program_header_size (abfd
);
3370 _bfd_elf_set_section_contents (abfd
, section
, location
, offset
, count
)
3375 bfd_size_type count
;
3377 Elf_Internal_Shdr
*hdr
;
3379 if (! abfd
->output_has_begun
3380 && ! _bfd_elf_compute_section_file_positions (abfd
,
3381 (struct bfd_link_info
*) NULL
))
3384 hdr
= &elf_section_data (section
)->this_hdr
;
3386 if (bfd_seek (abfd
, hdr
->sh_offset
+ offset
, SEEK_SET
) == -1)
3388 if (bfd_write (location
, 1, count
, abfd
) != count
)
3395 _bfd_elf_no_info_to_howto (abfd
, cache_ptr
, dst
)
3398 Elf_Internal_Rela
*dst
;
3405 _bfd_elf_no_info_to_howto_rel (abfd
, cache_ptr
, dst
)
3408 Elf_Internal_Rel
*dst
;
3414 /* Try to convert a non-ELF reloc into an ELF one. */
3417 _bfd_elf_validate_reloc (abfd
, areloc
)
3421 /* Check whether we really have an ELF howto. */
3423 if ((*areloc
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
)
3425 bfd_reloc_code_real_type code
;
3426 reloc_howto_type
*howto
;
3428 /* Alien reloc: Try to determine its type to replace it with an
3429 equivalent ELF reloc. */
3431 if (areloc
->howto
->pc_relative
)
3433 switch (areloc
->howto
->bitsize
)
3436 code
= BFD_RELOC_8_PCREL
;
3439 code
= BFD_RELOC_12_PCREL
;
3442 code
= BFD_RELOC_16_PCREL
;
3445 code
= BFD_RELOC_24_PCREL
;
3448 code
= BFD_RELOC_32_PCREL
;
3451 code
= BFD_RELOC_64_PCREL
;
3457 howto
= bfd_reloc_type_lookup (abfd
, code
);
3459 if (areloc
->howto
->pcrel_offset
!= howto
->pcrel_offset
)
3461 if (howto
->pcrel_offset
)
3462 areloc
->addend
+= areloc
->address
;
3464 areloc
->addend
-= areloc
->address
; /* addend is unsigned!! */
3469 switch (areloc
->howto
->bitsize
)
3475 code
= BFD_RELOC_14
;
3478 code
= BFD_RELOC_16
;
3481 code
= BFD_RELOC_26
;
3484 code
= BFD_RELOC_32
;
3487 code
= BFD_RELOC_64
;
3493 howto
= bfd_reloc_type_lookup (abfd
, code
);
3497 areloc
->howto
= howto
;
3505 (*_bfd_error_handler
)
3506 ("%s: unsupported relocation type %s",
3507 bfd_get_filename (abfd
), areloc
->howto
->name
);
3508 bfd_set_error (bfd_error_bad_value
);