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
*));
50 static char *elf_read
PARAMS ((bfd
*, long, unsigned int));
51 static void elf_fake_sections
PARAMS ((bfd
*, asection
*, PTR
));
52 static boolean assign_section_numbers
PARAMS ((bfd
*));
53 static INLINE
int sym_is_global
PARAMS ((bfd
*, asymbol
*));
54 static boolean elf_map_symbols
PARAMS ((bfd
*));
55 static bfd_size_type get_program_header_size
PARAMS ((bfd
*));
57 /* Standard ELF hash function. Do not change this function; you will
58 cause invalid hash tables to be generated. (Well, you would if this
59 were being used yet.) */
62 CONST
unsigned char *name
;
68 while ((ch
= *name
++) != '\0')
71 if ((g
= (h
& 0xf0000000)) != 0)
80 /* Read a specified number of bytes at a specified offset in an ELF
81 file, into a newly allocated buffer, and return a pointer to the
85 elf_read (abfd
, offset
, size
)
92 if ((buf
= bfd_alloc (abfd
, size
)) == NULL
)
94 if (bfd_seek (abfd
, offset
, SEEK_SET
) == -1)
96 if (bfd_read ((PTR
) buf
, size
, 1, abfd
) != size
)
98 if (bfd_get_error () != bfd_error_system_call
)
99 bfd_set_error (bfd_error_file_truncated
);
109 /* this just does initialization */
110 /* coff_mkobject zalloc's space for tdata.coff_obj_data ... */
111 elf_tdata (abfd
) = (struct elf_obj_tdata
*)
112 bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
113 if (elf_tdata (abfd
) == 0)
115 /* since everything is done at close time, do we need any
122 bfd_elf_get_str_section (abfd
, shindex
)
124 unsigned int shindex
;
126 Elf_Internal_Shdr
**i_shdrp
;
127 char *shstrtab
= NULL
;
129 unsigned int shstrtabsize
;
131 i_shdrp
= elf_elfsections (abfd
);
132 if (i_shdrp
== 0 || i_shdrp
[shindex
] == 0)
135 shstrtab
= (char *) i_shdrp
[shindex
]->contents
;
136 if (shstrtab
== NULL
)
138 /* No cached one, attempt to read, and cache what we read. */
139 offset
= i_shdrp
[shindex
]->sh_offset
;
140 shstrtabsize
= i_shdrp
[shindex
]->sh_size
;
141 shstrtab
= elf_read (abfd
, offset
, shstrtabsize
);
142 i_shdrp
[shindex
]->contents
= (PTR
) shstrtab
;
148 bfd_elf_string_from_elf_section (abfd
, shindex
, strindex
)
150 unsigned int shindex
;
151 unsigned int strindex
;
153 Elf_Internal_Shdr
*hdr
;
158 hdr
= elf_elfsections (abfd
)[shindex
];
160 if (hdr
->contents
== NULL
161 && bfd_elf_get_str_section (abfd
, shindex
) == NULL
)
164 return ((char *) hdr
->contents
) + strindex
;
167 /* Make a BFD section from an ELF section. We store a pointer to the
168 BFD section in the bfd_section field of the header. */
171 _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
)
173 Elf_Internal_Shdr
*hdr
;
179 if (hdr
->bfd_section
!= NULL
)
181 BFD_ASSERT (strcmp (name
,
182 bfd_get_section_name (abfd
, hdr
->bfd_section
)) == 0);
186 newsect
= bfd_make_section_anyway (abfd
, name
);
190 newsect
->filepos
= hdr
->sh_offset
;
192 if (! bfd_set_section_vma (abfd
, newsect
, hdr
->sh_addr
)
193 || ! bfd_set_section_size (abfd
, newsect
, hdr
->sh_size
)
194 || ! bfd_set_section_alignment (abfd
, newsect
,
195 bfd_log2 (hdr
->sh_addralign
)))
198 flags
= SEC_NO_FLAGS
;
199 if (hdr
->sh_type
!= SHT_NOBITS
)
200 flags
|= SEC_HAS_CONTENTS
;
201 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
204 if (hdr
->sh_type
!= SHT_NOBITS
)
207 if ((hdr
->sh_flags
& SHF_WRITE
) == 0)
208 flags
|= SEC_READONLY
;
209 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
211 else if ((flags
& SEC_LOAD
) != 0)
214 /* The debugging sections appear to be recognized only by name, not
216 if (strncmp (name
, ".debug", sizeof ".debug" - 1) == 0
217 || strncmp (name
, ".line", sizeof ".line" - 1) == 0
218 || strncmp (name
, ".stab", sizeof ".stab" - 1) == 0)
219 flags
|= SEC_DEBUGGING
;
221 /* As a GNU extension, if the name begins with .gnu.linkonce, we
222 only link a single copy of the section. This is used to support
223 g++. g++ will emit each template expansion in its own section.
224 The symbols will be defined as weak, so that multiple definitions
225 are permitted. The GNU linker extension is to actually discard
226 all but one of the sections. */
227 if (strncmp (name
, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
228 flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
230 if (! bfd_set_section_flags (abfd
, newsect
, flags
))
233 if ((flags
& SEC_ALLOC
) != 0)
235 Elf_Internal_Phdr
*phdr
;
238 /* Look through the phdrs to see if we need to adjust the lma. */
239 phdr
= elf_tdata (abfd
)->phdr
;
240 for (i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
242 if (phdr
->p_type
== PT_LOAD
243 && phdr
->p_paddr
!= 0
244 && phdr
->p_vaddr
!= phdr
->p_paddr
245 && phdr
->p_vaddr
<= hdr
->sh_addr
246 && phdr
->p_vaddr
+ phdr
->p_memsz
>= hdr
->sh_addr
+ hdr
->sh_size
247 && ((flags
& SEC_LOAD
) == 0
248 || (phdr
->p_offset
<= hdr
->sh_offset
249 && (phdr
->p_offset
+ phdr
->p_filesz
250 >= hdr
->sh_offset
+ hdr
->sh_size
))))
252 newsect
->lma
+= phdr
->p_paddr
- phdr
->p_vaddr
;
258 hdr
->bfd_section
= newsect
;
259 elf_section_data (newsect
)->this_hdr
= *hdr
;
269 struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name);
272 Helper functions for GDB to locate the string tables.
273 Since BFD hides string tables from callers, GDB needs to use an
274 internal hook to find them. Sun's .stabstr, in particular,
275 isn't even pointed to by the .stab section, so ordinary
276 mechanisms wouldn't work to find it, even if we had some.
279 struct elf_internal_shdr
*
280 bfd_elf_find_section (abfd
, name
)
284 Elf_Internal_Shdr
**i_shdrp
;
289 i_shdrp
= elf_elfsections (abfd
);
292 shstrtab
= bfd_elf_get_str_section (abfd
, elf_elfheader (abfd
)->e_shstrndx
);
293 if (shstrtab
!= NULL
)
295 max
= elf_elfheader (abfd
)->e_shnum
;
296 for (i
= 1; i
< max
; i
++)
297 if (!strcmp (&shstrtab
[i_shdrp
[i
]->sh_name
], name
))
304 const char *const bfd_elf_section_type_names
[] = {
305 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
306 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
307 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
310 /* ELF relocs are against symbols. If we are producing relocateable
311 output, and the reloc is against an external symbol, and nothing
312 has given us any additional addend, the resulting reloc will also
313 be against the same symbol. In such a case, we don't want to
314 change anything about the way the reloc is handled, since it will
315 all be done at final link time. Rather than put special case code
316 into bfd_perform_relocation, all the reloc types use this howto
317 function. It just short circuits the reloc if producing
318 relocateable output against an external symbol. */
321 bfd_reloc_status_type
322 bfd_elf_generic_reloc (abfd
,
330 arelent
*reloc_entry
;
333 asection
*input_section
;
335 char **error_message
;
337 if (output_bfd
!= (bfd
*) NULL
338 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
339 && (! reloc_entry
->howto
->partial_inplace
340 || reloc_entry
->addend
== 0))
342 reloc_entry
->address
+= input_section
->output_offset
;
346 return bfd_reloc_continue
;
349 /* Print out the program headers. */
352 _bfd_elf_print_private_bfd_data (abfd
, farg
)
356 FILE *f
= (FILE *) farg
;
357 Elf_Internal_Phdr
*p
;
359 bfd_byte
*dynbuf
= NULL
;
361 p
= elf_tdata (abfd
)->phdr
;
366 fprintf (f
, "\nProgram Header:\n");
367 c
= elf_elfheader (abfd
)->e_phnum
;
368 for (i
= 0; i
< c
; i
++, p
++)
375 case PT_NULL
: s
= "NULL"; break;
376 case PT_LOAD
: s
= "LOAD"; break;
377 case PT_DYNAMIC
: s
= "DYNAMIC"; break;
378 case PT_INTERP
: s
= "INTERP"; break;
379 case PT_NOTE
: s
= "NOTE"; break;
380 case PT_SHLIB
: s
= "SHLIB"; break;
381 case PT_PHDR
: s
= "PHDR"; break;
382 default: sprintf (buf
, "0x%lx", p
->p_type
); s
= buf
; break;
384 fprintf (f
, "%8s off 0x", s
);
385 fprintf_vma (f
, p
->p_offset
);
386 fprintf (f
, " vaddr 0x");
387 fprintf_vma (f
, p
->p_vaddr
);
388 fprintf (f
, " paddr 0x");
389 fprintf_vma (f
, p
->p_paddr
);
390 fprintf (f
, " align 2**%u\n", bfd_log2 (p
->p_align
));
391 fprintf (f
, " filesz 0x");
392 fprintf_vma (f
, p
->p_filesz
);
393 fprintf (f
, " memsz 0x");
394 fprintf_vma (f
, p
->p_memsz
);
395 fprintf (f
, " flags %c%c%c",
396 (p
->p_flags
& PF_R
) != 0 ? 'r' : '-',
397 (p
->p_flags
& PF_W
) != 0 ? 'w' : '-',
398 (p
->p_flags
& PF_X
) != 0 ? 'x' : '-');
399 if ((p
->p_flags
&~ (PF_R
| PF_W
| PF_X
)) != 0)
400 fprintf (f
, " %lx", p
->p_flags
&~ (PF_R
| PF_W
| PF_X
));
405 s
= bfd_get_section_by_name (abfd
, ".dynamic");
410 bfd_byte
*extdyn
, *extdynend
;
412 void (*swap_dyn_in
) PARAMS ((bfd
*, const PTR
, Elf_Internal_Dyn
*));
414 fprintf (f
, "\nDynamic Section:\n");
416 dynbuf
= (bfd_byte
*) bfd_malloc (s
->_raw_size
);
419 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
, (file_ptr
) 0,
423 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
426 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
428 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
429 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
432 extdynend
= extdyn
+ s
->_raw_size
;
433 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
435 Elf_Internal_Dyn dyn
;
440 (*swap_dyn_in
) (abfd
, (PTR
) extdyn
, &dyn
);
442 if (dyn
.d_tag
== DT_NULL
)
449 sprintf (ab
, "0x%lx", (unsigned long) dyn
.d_tag
);
453 case DT_NEEDED
: name
= "NEEDED"; stringp
= true; break;
454 case DT_PLTRELSZ
: name
= "PLTRELSZ"; break;
455 case DT_PLTGOT
: name
= "PLTGOT"; break;
456 case DT_HASH
: name
= "HASH"; break;
457 case DT_STRTAB
: name
= "STRTAB"; break;
458 case DT_SYMTAB
: name
= "SYMTAB"; break;
459 case DT_RELA
: name
= "RELA"; break;
460 case DT_RELASZ
: name
= "RELASZ"; break;
461 case DT_RELAENT
: name
= "RELAENT"; break;
462 case DT_STRSZ
: name
= "STRSZ"; break;
463 case DT_SYMENT
: name
= "SYMENT"; break;
464 case DT_INIT
: name
= "INIT"; break;
465 case DT_FINI
: name
= "FINI"; break;
466 case DT_SONAME
: name
= "SONAME"; stringp
= true; break;
467 case DT_RPATH
: name
= "RPATH"; stringp
= true; break;
468 case DT_SYMBOLIC
: name
= "SYMBOLIC"; break;
469 case DT_REL
: name
= "REL"; break;
470 case DT_RELSZ
: name
= "RELSZ"; break;
471 case DT_RELENT
: name
= "RELENT"; break;
472 case DT_PLTREL
: name
= "PLTREL"; break;
473 case DT_DEBUG
: name
= "DEBUG"; break;
474 case DT_TEXTREL
: name
= "TEXTREL"; break;
475 case DT_JMPREL
: name
= "JMPREL"; break;
478 fprintf (f
, " %-11s ", name
);
480 fprintf (f
, "0x%lx", (unsigned long) dyn
.d_un
.d_val
);
485 string
= bfd_elf_string_from_elf_section (abfd
, link
,
489 fprintf (f
, "%s", string
);
506 /* Display ELF-specific fields of a symbol. */
508 bfd_elf_print_symbol (ignore_abfd
, filep
, symbol
, how
)
512 bfd_print_symbol_type how
;
514 FILE *file
= (FILE *) filep
;
517 case bfd_print_symbol_name
:
518 fprintf (file
, "%s", symbol
->name
);
520 case bfd_print_symbol_more
:
521 fprintf (file
, "elf ");
522 fprintf_vma (file
, symbol
->value
);
523 fprintf (file
, " %lx", (long) symbol
->flags
);
525 case bfd_print_symbol_all
:
527 CONST
char *section_name
;
528 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
529 bfd_print_symbol_vandf ((PTR
) file
, symbol
);
530 fprintf (file
, " %s\t", section_name
);
531 /* Print the "other" value for a symbol. For common symbols,
532 we've already printed the size; now print the alignment.
533 For other symbols, we have no specified alignment, and
534 we've printed the address; now print the size. */
536 (bfd_is_com_section (symbol
->section
)
537 ? ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_value
538 : ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_size
));
539 fprintf (file
, " %s", symbol
->name
);
545 /* Create an entry in an ELF linker hash table. */
547 struct bfd_hash_entry
*
548 _bfd_elf_link_hash_newfunc (entry
, table
, string
)
549 struct bfd_hash_entry
*entry
;
550 struct bfd_hash_table
*table
;
553 struct elf_link_hash_entry
*ret
= (struct elf_link_hash_entry
*) entry
;
555 /* Allocate the structure if it has not already been allocated by a
557 if (ret
== (struct elf_link_hash_entry
*) NULL
)
558 ret
= ((struct elf_link_hash_entry
*)
559 bfd_hash_allocate (table
, sizeof (struct elf_link_hash_entry
)));
560 if (ret
== (struct elf_link_hash_entry
*) NULL
)
561 return (struct bfd_hash_entry
*) ret
;
563 /* Call the allocation method of the superclass. */
564 ret
= ((struct elf_link_hash_entry
*)
565 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
567 if (ret
!= (struct elf_link_hash_entry
*) NULL
)
569 /* Set local fields. */
573 ret
->dynstr_index
= 0;
575 ret
->got_offset
= (bfd_vma
) -1;
576 ret
->plt_offset
= (bfd_vma
) -1;
577 ret
->linker_section_pointer
= (elf_linker_section_pointers_t
*)0;
578 ret
->type
= STT_NOTYPE
;
579 /* Assume that we have been called by a non-ELF symbol reader.
580 This flag is then reset by the code which reads an ELF input
581 file. This ensures that a symbol created by a non-ELF symbol
582 reader will have the flag set correctly. */
583 ret
->elf_link_hash_flags
= ELF_LINK_NON_ELF
;
586 return (struct bfd_hash_entry
*) ret
;
589 /* Initialize an ELF linker hash table. */
592 _bfd_elf_link_hash_table_init (table
, abfd
, newfunc
)
593 struct elf_link_hash_table
*table
;
595 struct bfd_hash_entry
*(*newfunc
) PARAMS ((struct bfd_hash_entry
*,
596 struct bfd_hash_table
*,
599 table
->dynamic_sections_created
= false;
600 table
->dynobj
= NULL
;
601 /* The first dynamic symbol is a dummy. */
602 table
->dynsymcount
= 1;
603 table
->dynstr
= NULL
;
604 table
->bucketcount
= 0;
605 table
->needed
= NULL
;
607 table
->stab_info
= NULL
;
608 return _bfd_link_hash_table_init (&table
->root
, abfd
, newfunc
);
611 /* Create an ELF linker hash table. */
613 struct bfd_link_hash_table
*
614 _bfd_elf_link_hash_table_create (abfd
)
617 struct elf_link_hash_table
*ret
;
619 ret
= ((struct elf_link_hash_table
*)
620 bfd_alloc (abfd
, sizeof (struct elf_link_hash_table
)));
621 if (ret
== (struct elf_link_hash_table
*) NULL
)
624 if (! _bfd_elf_link_hash_table_init (ret
, abfd
, _bfd_elf_link_hash_newfunc
))
626 bfd_release (abfd
, ret
);
633 /* This is a hook for the ELF emulation code in the generic linker to
634 tell the backend linker what file name to use for the DT_NEEDED
635 entry for a dynamic object. The generic linker passes name as an
636 empty string to indicate that no DT_NEEDED entry should be made. */
639 bfd_elf_set_dt_needed_name (abfd
, name
)
643 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
644 && bfd_get_format (abfd
) == bfd_object
)
645 elf_dt_name (abfd
) = name
;
648 /* Get the list of DT_NEEDED entries for a link. This is a hook for
649 the ELF emulation code. */
651 struct bfd_link_needed_list
*
652 bfd_elf_get_needed_list (abfd
, info
)
654 struct bfd_link_info
*info
;
656 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
658 return elf_hash_table (info
)->needed
;
661 /* Get the name actually used for a dynamic object for a link. This
662 is the SONAME entry if there is one. Otherwise, it is the string
663 passed to bfd_elf_set_dt_needed_name, or it is the filename. */
666 bfd_elf_get_dt_soname (abfd
)
669 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
670 && bfd_get_format (abfd
) == bfd_object
)
671 return elf_dt_name (abfd
);
675 /* Allocate an ELF string table--force the first byte to be zero. */
677 struct bfd_strtab_hash
*
678 _bfd_elf_stringtab_init ()
680 struct bfd_strtab_hash
*ret
;
682 ret
= _bfd_stringtab_init ();
687 loc
= _bfd_stringtab_add (ret
, "", true, false);
688 BFD_ASSERT (loc
== 0 || loc
== (bfd_size_type
) -1);
689 if (loc
== (bfd_size_type
) -1)
691 _bfd_stringtab_free (ret
);
698 /* ELF .o/exec file reading */
700 /* Create a new bfd section from an ELF section header. */
703 bfd_section_from_shdr (abfd
, shindex
)
705 unsigned int shindex
;
707 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[shindex
];
708 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
709 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
712 name
= elf_string_from_elf_strtab (abfd
, hdr
->sh_name
);
714 switch (hdr
->sh_type
)
717 /* Inactive section. Throw it away. */
720 case SHT_PROGBITS
: /* Normal section with contents. */
721 case SHT_DYNAMIC
: /* Dynamic linking information. */
722 case SHT_NOBITS
: /* .bss section. */
723 case SHT_HASH
: /* .hash section. */
724 case SHT_NOTE
: /* .note section. */
725 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
727 case SHT_SYMTAB
: /* A symbol table */
728 if (elf_onesymtab (abfd
) == shindex
)
731 BFD_ASSERT (hdr
->sh_entsize
== bed
->s
->sizeof_sym
);
732 BFD_ASSERT (elf_onesymtab (abfd
) == 0);
733 elf_onesymtab (abfd
) = shindex
;
734 elf_tdata (abfd
)->symtab_hdr
= *hdr
;
735 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->symtab_hdr
;
736 abfd
->flags
|= HAS_SYMS
;
738 /* Sometimes a shared object will map in the symbol table. If
739 SHF_ALLOC is set, and this is a shared object, then we also
740 treat this section as a BFD section. We can not base the
741 decision purely on SHF_ALLOC, because that flag is sometimes
742 set in a relocateable object file, which would confuse the
744 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
745 && (abfd
->flags
& DYNAMIC
) != 0
746 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
751 case SHT_DYNSYM
: /* A dynamic symbol table */
752 if (elf_dynsymtab (abfd
) == shindex
)
755 BFD_ASSERT (hdr
->sh_entsize
== bed
->s
->sizeof_sym
);
756 BFD_ASSERT (elf_dynsymtab (abfd
) == 0);
757 elf_dynsymtab (abfd
) = shindex
;
758 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
759 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
760 abfd
->flags
|= HAS_SYMS
;
762 /* Besides being a symbol table, we also treat this as a regular
763 section, so that objcopy can handle it. */
764 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
766 case SHT_STRTAB
: /* A string table */
767 if (hdr
->bfd_section
!= NULL
)
769 if (ehdr
->e_shstrndx
== shindex
)
771 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
772 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
778 for (i
= 1; i
< ehdr
->e_shnum
; i
++)
780 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
781 if (hdr2
->sh_link
== shindex
)
783 if (! bfd_section_from_shdr (abfd
, i
))
785 if (elf_onesymtab (abfd
) == i
)
787 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
788 elf_elfsections (abfd
)[shindex
] =
789 &elf_tdata (abfd
)->strtab_hdr
;
792 if (elf_dynsymtab (abfd
) == i
)
794 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
795 elf_elfsections (abfd
)[shindex
] = hdr
=
796 &elf_tdata (abfd
)->dynstrtab_hdr
;
797 /* We also treat this as a regular section, so
798 that objcopy can handle it. */
801 #if 0 /* Not handling other string tables specially right now. */
802 hdr2
= elf_elfsections (abfd
)[i
]; /* in case it moved */
803 /* We have a strtab for some random other section. */
804 newsect
= (asection
*) hdr2
->bfd_section
;
807 hdr
->bfd_section
= newsect
;
808 hdr2
= &elf_section_data (newsect
)->str_hdr
;
810 elf_elfsections (abfd
)[shindex
] = hdr2
;
816 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
820 /* *These* do a lot of work -- but build no sections! */
822 asection
*target_sect
;
823 Elf_Internal_Shdr
*hdr2
;
825 /* For some incomprehensible reason Oracle distributes
826 libraries for Solaris in which some of the objects have
827 bogus sh_link fields. It would be nice if we could just
828 reject them, but, unfortunately, some people need to use
829 them. We scan through the section headers; if we find only
830 one suitable symbol table, we clobber the sh_link to point
831 to it. I hope this doesn't break anything. */
832 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_SYMTAB
833 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_DYNSYM
)
839 for (scan
= 1; scan
< ehdr
->e_shnum
; scan
++)
841 if (elf_elfsections (abfd
)[scan
]->sh_type
== SHT_SYMTAB
842 || elf_elfsections (abfd
)[scan
]->sh_type
== SHT_DYNSYM
)
853 hdr
->sh_link
= found
;
856 /* Get the symbol table. */
857 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_SYMTAB
858 && ! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
861 /* If this reloc section does not use the main symbol table we
862 don't treat it as a reloc section. BFD can't adequately
863 represent such a section, so at least for now, we don't
864 try. We just present it as a normal section. */
865 if (hdr
->sh_link
!= elf_onesymtab (abfd
))
866 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
868 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
870 target_sect
= bfd_section_from_elf_index (abfd
, hdr
->sh_info
);
871 if (target_sect
== NULL
)
874 if ((target_sect
->flags
& SEC_RELOC
) == 0
875 || target_sect
->reloc_count
== 0)
876 hdr2
= &elf_section_data (target_sect
)->rel_hdr
;
879 BFD_ASSERT (elf_section_data (target_sect
)->rel_hdr2
== NULL
);
880 hdr2
= (Elf_Internal_Shdr
*) bfd_alloc (abfd
, sizeof (*hdr2
));
881 elf_section_data (target_sect
)->rel_hdr2
= hdr2
;
884 elf_elfsections (abfd
)[shindex
] = hdr2
;
885 target_sect
->reloc_count
+= hdr
->sh_size
/ hdr
->sh_entsize
;
886 target_sect
->flags
|= SEC_RELOC
;
887 target_sect
->relocation
= NULL
;
888 target_sect
->rel_filepos
= hdr
->sh_offset
;
889 abfd
->flags
|= HAS_RELOC
;
898 /* Check for any processor-specific section types. */
900 if (bed
->elf_backend_section_from_shdr
)
901 (*bed
->elf_backend_section_from_shdr
) (abfd
, hdr
, name
);
909 /* Given an ELF section number, retrieve the corresponding BFD
913 bfd_section_from_elf_index (abfd
, index
)
917 BFD_ASSERT (index
> 0 && index
< SHN_LORESERVE
);
918 if (index
>= elf_elfheader (abfd
)->e_shnum
)
920 return elf_elfsections (abfd
)[index
]->bfd_section
;
924 _bfd_elf_new_section_hook (abfd
, sec
)
928 struct bfd_elf_section_data
*sdata
;
930 sdata
= (struct bfd_elf_section_data
*) bfd_alloc (abfd
, sizeof (*sdata
));
933 sec
->used_by_bfd
= (PTR
) sdata
;
934 memset (sdata
, 0, sizeof (*sdata
));
938 /* Create a new bfd section from an ELF program header.
940 Since program segments have no names, we generate a synthetic name
941 of the form segment<NUM>, where NUM is generally the index in the
942 program header table. For segments that are split (see below) we
943 generate the names segment<NUM>a and segment<NUM>b.
945 Note that some program segments may have a file size that is different than
946 (less than) the memory size. All this means is that at execution the
947 system must allocate the amount of memory specified by the memory size,
948 but only initialize it with the first "file size" bytes read from the
949 file. This would occur for example, with program segments consisting
950 of combined data+bss.
952 To handle the above situation, this routine generates TWO bfd sections
953 for the single program segment. The first has the length specified by
954 the file size of the segment, and the second has the length specified
955 by the difference between the two sizes. In effect, the segment is split
956 into it's initialized and uninitialized parts.
961 bfd_section_from_phdr (abfd
, hdr
, index
)
963 Elf_Internal_Phdr
*hdr
;
971 split
= ((hdr
->p_memsz
> 0) &&
972 (hdr
->p_filesz
> 0) &&
973 (hdr
->p_memsz
> hdr
->p_filesz
));
974 sprintf (namebuf
, split
? "segment%da" : "segment%d", index
);
975 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
978 strcpy (name
, namebuf
);
979 newsect
= bfd_make_section (abfd
, name
);
982 newsect
->vma
= hdr
->p_vaddr
;
983 newsect
->lma
= hdr
->p_paddr
;
984 newsect
->_raw_size
= hdr
->p_filesz
;
985 newsect
->filepos
= hdr
->p_offset
;
986 newsect
->flags
|= SEC_HAS_CONTENTS
;
987 if (hdr
->p_type
== PT_LOAD
)
989 newsect
->flags
|= SEC_ALLOC
;
990 newsect
->flags
|= SEC_LOAD
;
991 if (hdr
->p_flags
& PF_X
)
993 /* FIXME: all we known is that it has execute PERMISSION,
995 newsect
->flags
|= SEC_CODE
;
998 if (!(hdr
->p_flags
& PF_W
))
1000 newsect
->flags
|= SEC_READONLY
;
1005 sprintf (namebuf
, "segment%db", index
);
1006 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
1009 strcpy (name
, namebuf
);
1010 newsect
= bfd_make_section (abfd
, name
);
1011 if (newsect
== NULL
)
1013 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
1014 newsect
->lma
= hdr
->p_paddr
+ hdr
->p_filesz
;
1015 newsect
->_raw_size
= hdr
->p_memsz
- hdr
->p_filesz
;
1016 if (hdr
->p_type
== PT_LOAD
)
1018 newsect
->flags
|= SEC_ALLOC
;
1019 if (hdr
->p_flags
& PF_X
)
1020 newsect
->flags
|= SEC_CODE
;
1022 if (!(hdr
->p_flags
& PF_W
))
1023 newsect
->flags
|= SEC_READONLY
;
1029 /* Set up an ELF internal section header for a section. */
1033 elf_fake_sections (abfd
, asect
, failedptrarg
)
1038 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1039 boolean
*failedptr
= (boolean
*) failedptrarg
;
1040 Elf_Internal_Shdr
*this_hdr
;
1044 /* We already failed; just get out of the bfd_map_over_sections
1049 this_hdr
= &elf_section_data (asect
)->this_hdr
;
1051 this_hdr
->sh_name
= (unsigned long) _bfd_stringtab_add (elf_shstrtab (abfd
),
1054 if (this_hdr
->sh_name
== (unsigned long) -1)
1060 this_hdr
->sh_flags
= 0;
1062 if ((asect
->flags
& SEC_ALLOC
) != 0
1063 || asect
->user_set_vma
)
1064 this_hdr
->sh_addr
= asect
->vma
;
1066 this_hdr
->sh_addr
= 0;
1068 this_hdr
->sh_offset
= 0;
1069 this_hdr
->sh_size
= asect
->_raw_size
;
1070 this_hdr
->sh_link
= 0;
1071 this_hdr
->sh_addralign
= 1 << asect
->alignment_power
;
1072 /* The sh_entsize and sh_info fields may have been set already by
1073 copy_private_section_data. */
1075 this_hdr
->bfd_section
= asect
;
1076 this_hdr
->contents
= NULL
;
1078 /* FIXME: This should not be based on section names. */
1079 if (strcmp (asect
->name
, ".dynstr") == 0)
1080 this_hdr
->sh_type
= SHT_STRTAB
;
1081 else if (strcmp (asect
->name
, ".hash") == 0)
1083 this_hdr
->sh_type
= SHT_HASH
;
1084 this_hdr
->sh_entsize
= bed
->s
->arch_size
/ 8;
1086 else if (strcmp (asect
->name
, ".dynsym") == 0)
1088 this_hdr
->sh_type
= SHT_DYNSYM
;
1089 this_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
1091 else if (strcmp (asect
->name
, ".dynamic") == 0)
1093 this_hdr
->sh_type
= SHT_DYNAMIC
;
1094 this_hdr
->sh_entsize
= bed
->s
->sizeof_dyn
;
1096 else if (strncmp (asect
->name
, ".rela", 5) == 0
1097 && get_elf_backend_data (abfd
)->use_rela_p
)
1099 this_hdr
->sh_type
= SHT_RELA
;
1100 this_hdr
->sh_entsize
= bed
->s
->sizeof_rela
;
1102 else if (strncmp (asect
->name
, ".rel", 4) == 0
1103 && ! get_elf_backend_data (abfd
)->use_rela_p
)
1105 this_hdr
->sh_type
= SHT_REL
;
1106 this_hdr
->sh_entsize
= bed
->s
->sizeof_rel
;
1108 else if (strcmp (asect
->name
, ".note") == 0)
1109 this_hdr
->sh_type
= SHT_NOTE
;
1110 else if (strncmp (asect
->name
, ".stab", 5) == 0
1111 && strcmp (asect
->name
+ strlen (asect
->name
) - 3, "str") == 0)
1112 this_hdr
->sh_type
= SHT_STRTAB
;
1113 else if ((asect
->flags
& SEC_ALLOC
) != 0
1114 && (asect
->flags
& SEC_LOAD
) != 0)
1115 this_hdr
->sh_type
= SHT_PROGBITS
;
1116 else if ((asect
->flags
& SEC_ALLOC
) != 0
1117 && ((asect
->flags
& SEC_LOAD
) == 0))
1118 this_hdr
->sh_type
= SHT_NOBITS
;
1122 this_hdr
->sh_type
= SHT_PROGBITS
;
1125 if ((asect
->flags
& SEC_ALLOC
) != 0)
1126 this_hdr
->sh_flags
|= SHF_ALLOC
;
1127 if ((asect
->flags
& SEC_READONLY
) == 0)
1128 this_hdr
->sh_flags
|= SHF_WRITE
;
1129 if ((asect
->flags
& SEC_CODE
) != 0)
1130 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
1132 /* Check for processor-specific section types. */
1134 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1136 if (bed
->elf_backend_fake_sections
)
1137 (*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
);
1140 /* If the section has relocs, set up a section header for the
1141 SHT_REL[A] section. */
1142 if ((asect
->flags
& SEC_RELOC
) != 0)
1144 Elf_Internal_Shdr
*rela_hdr
;
1145 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1148 rela_hdr
= &elf_section_data (asect
)->rel_hdr
;
1149 name
= bfd_alloc (abfd
, sizeof ".rela" + strlen (asect
->name
));
1155 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", asect
->name
);
1157 (unsigned int) _bfd_stringtab_add (elf_shstrtab (abfd
), name
,
1159 if (rela_hdr
->sh_name
== (unsigned int) -1)
1164 rela_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
1165 rela_hdr
->sh_entsize
= (use_rela_p
1166 ? bed
->s
->sizeof_rela
1167 : bed
->s
->sizeof_rel
);
1168 rela_hdr
->sh_addralign
= bed
->s
->file_align
;
1169 rela_hdr
->sh_flags
= 0;
1170 rela_hdr
->sh_addr
= 0;
1171 rela_hdr
->sh_size
= 0;
1172 rela_hdr
->sh_offset
= 0;
1176 /* Assign all ELF section numbers. The dummy first section is handled here
1177 too. The link/info pointers for the standard section types are filled
1178 in here too, while we're at it. */
1181 assign_section_numbers (abfd
)
1184 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
1186 unsigned int section_number
;
1187 Elf_Internal_Shdr
**i_shdrp
;
1188 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1192 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1194 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1196 d
->this_idx
= section_number
++;
1197 if ((sec
->flags
& SEC_RELOC
) == 0)
1200 d
->rel_idx
= section_number
++;
1203 t
->shstrtab_section
= section_number
++;
1204 elf_elfheader (abfd
)->e_shstrndx
= t
->shstrtab_section
;
1205 t
->shstrtab_hdr
.sh_size
= _bfd_stringtab_size (elf_shstrtab (abfd
));
1207 if (abfd
->symcount
> 0)
1209 t
->symtab_section
= section_number
++;
1210 t
->strtab_section
= section_number
++;
1213 elf_elfheader (abfd
)->e_shnum
= section_number
;
1215 /* Set up the list of section header pointers, in agreement with the
1217 i_shdrp
= ((Elf_Internal_Shdr
**)
1218 bfd_alloc (abfd
, section_number
* sizeof (Elf_Internal_Shdr
*)));
1219 if (i_shdrp
== NULL
)
1222 i_shdrp
[0] = ((Elf_Internal_Shdr
*)
1223 bfd_alloc (abfd
, sizeof (Elf_Internal_Shdr
)));
1224 if (i_shdrp
[0] == NULL
)
1226 bfd_release (abfd
, i_shdrp
);
1229 memset (i_shdrp
[0], 0, sizeof (Elf_Internal_Shdr
));
1231 elf_elfsections (abfd
) = i_shdrp
;
1233 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
1234 if (abfd
->symcount
> 0)
1236 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
1237 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
1238 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
1240 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1242 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1246 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
1247 if (d
->rel_idx
!= 0)
1248 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
1250 /* Fill in the sh_link and sh_info fields while we're at it. */
1252 /* sh_link of a reloc section is the section index of the symbol
1253 table. sh_info is the section index of the section to which
1254 the relocation entries apply. */
1255 if (d
->rel_idx
!= 0)
1257 d
->rel_hdr
.sh_link
= t
->symtab_section
;
1258 d
->rel_hdr
.sh_info
= d
->this_idx
;
1261 switch (d
->this_hdr
.sh_type
)
1265 /* A reloc section which we are treating as a normal BFD
1266 section. sh_link is the section index of the symbol
1267 table. sh_info is the section index of the section to
1268 which the relocation entries apply. We assume that an
1269 allocated reloc section uses the dynamic symbol table.
1270 FIXME: How can we be sure? */
1271 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1273 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1275 /* We look up the section the relocs apply to by name. */
1277 if (d
->this_hdr
.sh_type
== SHT_REL
)
1281 s
= bfd_get_section_by_name (abfd
, name
);
1283 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
1287 /* We assume that a section named .stab*str is a stabs
1288 string section. We look for a section with the same name
1289 but without the trailing ``str'', and set its sh_link
1290 field to point to this section. */
1291 if (strncmp (sec
->name
, ".stab", sizeof ".stab" - 1) == 0
1292 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
1297 len
= strlen (sec
->name
);
1298 alc
= (char *) bfd_malloc (len
- 2);
1301 strncpy (alc
, sec
->name
, len
- 3);
1302 alc
[len
- 3] = '\0';
1303 s
= bfd_get_section_by_name (abfd
, alc
);
1307 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
1309 /* This is a .stab section. */
1310 elf_section_data (s
)->this_hdr
.sh_entsize
=
1311 4 + 2 * (bed
->s
->arch_size
/ 8);
1318 /* sh_link is the section header index of the string table
1319 used for the dynamic entries or symbol table. */
1320 s
= bfd_get_section_by_name (abfd
, ".dynstr");
1322 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1326 /* sh_link is the section header index of the symbol table
1327 this hash table is for. */
1328 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1330 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1338 /* Map symbol from it's internal number to the external number, moving
1339 all local symbols to be at the head of the list. */
1342 sym_is_global (abfd
, sym
)
1346 /* If the backend has a special mapping, use it. */
1347 if (get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1348 return ((*get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1351 return ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
1352 || bfd_is_und_section (bfd_get_section (sym
))
1353 || bfd_is_com_section (bfd_get_section (sym
)));
1357 elf_map_symbols (abfd
)
1360 int symcount
= bfd_get_symcount (abfd
);
1361 asymbol
**syms
= bfd_get_outsymbols (abfd
);
1362 asymbol
**sect_syms
;
1364 int num_globals
= 0;
1365 int num_locals2
= 0;
1366 int num_globals2
= 0;
1368 int num_sections
= 0;
1374 fprintf (stderr
, "elf_map_symbols\n");
1378 /* Add a section symbol for each BFD section. FIXME: Is this really
1380 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1382 if (max_index
< asect
->index
)
1383 max_index
= asect
->index
;
1387 sect_syms
= (asymbol
**) bfd_zalloc (abfd
, max_index
* sizeof (asymbol
*));
1388 if (sect_syms
== NULL
)
1390 elf_section_syms (abfd
) = sect_syms
;
1392 for (idx
= 0; idx
< symcount
; idx
++)
1394 if ((syms
[idx
]->flags
& BSF_SECTION_SYM
) != 0
1395 && (syms
[idx
]->value
+ syms
[idx
]->section
->vma
) == 0)
1399 sec
= syms
[idx
]->section
;
1400 if (sec
->owner
!= NULL
)
1402 if (sec
->owner
!= abfd
)
1404 if (sec
->output_offset
!= 0)
1406 sec
= sec
->output_section
;
1407 BFD_ASSERT (sec
->owner
== abfd
);
1409 sect_syms
[sec
->index
] = syms
[idx
];
1414 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1418 if (sect_syms
[asect
->index
] != NULL
)
1421 sym
= bfd_make_empty_symbol (abfd
);
1424 sym
->the_bfd
= abfd
;
1425 sym
->name
= asect
->name
;
1427 /* Set the flags to 0 to indicate that this one was newly added. */
1429 sym
->section
= asect
;
1430 sect_syms
[asect
->index
] = sym
;
1434 "creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n",
1435 asect
->name
, (long) asect
->vma
, asect
->index
, (long) asect
);
1439 /* Classify all of the symbols. */
1440 for (idx
= 0; idx
< symcount
; idx
++)
1442 if (!sym_is_global (abfd
, syms
[idx
]))
1447 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1449 if (sect_syms
[asect
->index
] != NULL
1450 && sect_syms
[asect
->index
]->flags
== 0)
1452 sect_syms
[asect
->index
]->flags
= BSF_SECTION_SYM
;
1453 if (!sym_is_global (abfd
, sect_syms
[asect
->index
]))
1457 sect_syms
[asect
->index
]->flags
= 0;
1461 /* Now sort the symbols so the local symbols are first. */
1462 new_syms
= ((asymbol
**)
1464 (num_locals
+ num_globals
) * sizeof (asymbol
*)));
1465 if (new_syms
== NULL
)
1468 for (idx
= 0; idx
< symcount
; idx
++)
1470 asymbol
*sym
= syms
[idx
];
1473 if (!sym_is_global (abfd
, sym
))
1476 i
= num_locals
+ num_globals2
++;
1478 sym
->udata
.i
= i
+ 1;
1480 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1482 if (sect_syms
[asect
->index
] != NULL
1483 && sect_syms
[asect
->index
]->flags
== 0)
1485 asymbol
*sym
= sect_syms
[asect
->index
];
1488 sym
->flags
= BSF_SECTION_SYM
;
1489 if (!sym_is_global (abfd
, sym
))
1492 i
= num_locals
+ num_globals2
++;
1494 sym
->udata
.i
= i
+ 1;
1498 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
1500 elf_num_locals (abfd
) = num_locals
;
1501 elf_num_globals (abfd
) = num_globals
;
1505 /* Align to the maximum file alignment that could be required for any
1506 ELF data structure. */
1508 static INLINE file_ptr align_file_position
PARAMS ((file_ptr
, int));
1509 static INLINE file_ptr
1510 align_file_position (off
, align
)
1514 return (off
+ align
- 1) & ~(align
- 1);
1517 /* Assign a file position to a section, optionally aligning to the
1518 required section alignment. */
1521 _bfd_elf_assign_file_position_for_section (i_shdrp
, offset
, align
)
1522 Elf_Internal_Shdr
*i_shdrp
;
1530 al
= i_shdrp
->sh_addralign
;
1532 offset
= BFD_ALIGN (offset
, al
);
1534 i_shdrp
->sh_offset
= offset
;
1535 if (i_shdrp
->bfd_section
!= NULL
)
1536 i_shdrp
->bfd_section
->filepos
= offset
;
1537 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
1538 offset
+= i_shdrp
->sh_size
;
1542 /* Compute the file positions we are going to put the sections at, and
1543 otherwise prepare to begin writing out the ELF file. If LINK_INFO
1544 is not NULL, this is being called by the ELF backend linker. */
1547 _bfd_elf_compute_section_file_positions (abfd
, link_info
)
1549 struct bfd_link_info
*link_info
;
1551 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1553 struct bfd_strtab_hash
*strtab
;
1554 Elf_Internal_Shdr
*shstrtab_hdr
;
1556 if (abfd
->output_has_begun
)
1559 /* Do any elf backend specific processing first. */
1560 if (bed
->elf_backend_begin_write_processing
)
1561 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
1563 if (! prep_headers (abfd
))
1567 bfd_map_over_sections (abfd
, elf_fake_sections
, &failed
);
1571 if (!assign_section_numbers (abfd
))
1574 /* The backend linker builds symbol table information itself. */
1575 if (link_info
== NULL
&& abfd
->symcount
> 0)
1577 if (! swap_out_syms (abfd
, &strtab
))
1581 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
1582 /* sh_name was set in prep_headers. */
1583 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
1584 shstrtab_hdr
->sh_flags
= 0;
1585 shstrtab_hdr
->sh_addr
= 0;
1586 shstrtab_hdr
->sh_size
= _bfd_stringtab_size (elf_shstrtab (abfd
));
1587 shstrtab_hdr
->sh_entsize
= 0;
1588 shstrtab_hdr
->sh_link
= 0;
1589 shstrtab_hdr
->sh_info
= 0;
1590 /* sh_offset is set in assign_file_positions_except_relocs. */
1591 shstrtab_hdr
->sh_addralign
= 1;
1593 if (!assign_file_positions_except_relocs (abfd
))
1596 if (link_info
== NULL
&& abfd
->symcount
> 0)
1599 Elf_Internal_Shdr
*hdr
;
1601 off
= elf_tdata (abfd
)->next_file_pos
;
1603 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1604 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
1606 hdr
= &elf_tdata (abfd
)->strtab_hdr
;
1607 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
1609 elf_tdata (abfd
)->next_file_pos
= off
;
1611 /* Now that we know where the .strtab section goes, write it
1613 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
1614 || ! _bfd_stringtab_emit (abfd
, strtab
))
1616 _bfd_stringtab_free (strtab
);
1619 abfd
->output_has_begun
= true;
1624 /* Create a mapping from a set of sections to a program segment. */
1626 static INLINE
struct elf_segment_map
*
1627 make_mapping (abfd
, sections
, from
, to
, phdr
)
1629 asection
**sections
;
1634 struct elf_segment_map
*m
;
1638 m
= ((struct elf_segment_map
*)
1640 (sizeof (struct elf_segment_map
)
1641 + (to
- from
- 1) * sizeof (asection
*))));
1645 m
->p_type
= PT_LOAD
;
1646 for (i
= from
, hdrpp
= sections
+ from
; i
< to
; i
++, hdrpp
++)
1647 m
->sections
[i
- from
] = *hdrpp
;
1648 m
->count
= to
- from
;
1650 if (from
== 0 && phdr
)
1652 /* Include the headers in the first PT_LOAD segment. */
1653 m
->includes_filehdr
= 1;
1654 m
->includes_phdrs
= 1;
1660 /* Set up a mapping from BFD sections to program segments. */
1663 map_sections_to_segments (abfd
)
1666 asection
**sections
= NULL
;
1670 struct elf_segment_map
*mfirst
;
1671 struct elf_segment_map
**pm
;
1672 struct elf_segment_map
*m
;
1674 unsigned int phdr_index
;
1675 bfd_vma maxpagesize
;
1677 boolean phdr_in_section
= true;
1681 if (elf_tdata (abfd
)->segment_map
!= NULL
)
1684 if (bfd_count_sections (abfd
) == 0)
1687 /* Select the allocated sections, and sort them. */
1689 sections
= (asection
**) bfd_malloc (bfd_count_sections (abfd
)
1690 * sizeof (asection
*));
1691 if (sections
== NULL
)
1695 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
1697 if ((s
->flags
& SEC_ALLOC
) != 0)
1703 BFD_ASSERT (i
<= bfd_count_sections (abfd
));
1706 qsort (sections
, (size_t) count
, sizeof (asection
*), elf_sort_sections
);
1708 /* Build the mapping. */
1713 /* If we have a .interp section, then create a PT_PHDR segment for
1714 the program headers and a PT_INTERP segment for the .interp
1716 s
= bfd_get_section_by_name (abfd
, ".interp");
1717 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
1719 m
= ((struct elf_segment_map
*)
1720 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
1724 m
->p_type
= PT_PHDR
;
1725 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
1726 m
->p_flags
= PF_R
| PF_X
;
1727 m
->p_flags_valid
= 1;
1728 m
->includes_phdrs
= 1;
1733 m
= ((struct elf_segment_map
*)
1734 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
1738 m
->p_type
= PT_INTERP
;
1746 /* Look through the sections. We put sections in the same program
1747 segment when the start of the second section can be placed within
1748 a few bytes of the end of the first section. */
1751 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
1753 dynsec
= bfd_get_section_by_name (abfd
, ".dynamic");
1755 && (dynsec
->flags
& SEC_LOAD
) == 0)
1758 /* Deal with -Ttext or something similar such that the first section
1759 is not adjacent to the program headers. This is an
1760 approximation, since at this point we don't know exactly how many
1761 program headers we will need. */
1764 bfd_size_type phdr_size
;
1766 phdr_size
= elf_tdata (abfd
)->program_header_size
;
1768 phdr_size
= get_elf_backend_data (abfd
)->s
->sizeof_phdr
;
1769 if ((abfd
->flags
& D_PAGED
) == 0
1770 || sections
[0]->lma
% maxpagesize
< phdr_size
% maxpagesize
)
1771 phdr_in_section
= false;
1774 for (i
= 0, hdrpp
= sections
; i
< count
; i
++, hdrpp
++)
1777 boolean new_segment
;
1781 /* See if this section and the last one will fit in the same
1784 if (last_hdr
== NULL
)
1786 /* If we don't have a segment yet, then we don't need a new
1787 one (we build the last one after this loop). */
1788 new_segment
= false;
1790 else if (last_hdr
->lma
- last_hdr
->vma
!= hdr
->lma
- hdr
->vma
)
1792 /* If this section has a different relation between the
1793 virtual address and the load address, then we need a new
1797 else if (BFD_ALIGN (last_hdr
->lma
+ last_hdr
->_raw_size
, maxpagesize
)
1800 /* If putting this section in this segment would force us to
1801 skip a page in the segment, then we need a new segment. */
1804 else if ((abfd
->flags
& D_PAGED
) == 0)
1806 /* If the file is not demand paged, which means that we
1807 don't require the sections to be correctly aligned in the
1808 file, then there is no other reason for a new segment. */
1809 new_segment
= false;
1811 else if ((last_hdr
->flags
& SEC_LOAD
) == 0
1812 && (hdr
->flags
& SEC_LOAD
) != 0)
1814 /* We don't want to put a loadable section after a
1815 nonloadable section in the same segment. */
1819 && (hdr
->flags
& SEC_READONLY
) == 0
1820 && (BFD_ALIGN (last_hdr
->lma
+ last_hdr
->_raw_size
, maxpagesize
)
1823 /* We don't want to put a writable section in a read only
1824 segment, unless they are on the same page in memory
1825 anyhow. We already know that the last section does not
1826 bring us past the current section on the page, so the
1827 only case in which the new section is not on the same
1828 page as the previous section is when the previous section
1829 ends precisely on a page boundary. */
1834 /* Otherwise, we can use the same segment. */
1835 new_segment
= false;
1840 if ((hdr
->flags
& SEC_READONLY
) == 0)
1846 /* We need a new program segment. We must create a new program
1847 header holding all the sections from phdr_index until hdr. */
1849 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_section
);
1856 if ((hdr
->flags
& SEC_READONLY
) == 0)
1863 phdr_in_section
= false;
1866 /* Create a final PT_LOAD program segment. */
1867 if (last_hdr
!= NULL
)
1869 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_section
);
1877 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
1880 m
= ((struct elf_segment_map
*)
1881 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
1885 m
->p_type
= PT_DYNAMIC
;
1887 m
->sections
[0] = dynsec
;
1896 elf_tdata (abfd
)->segment_map
= mfirst
;
1900 if (sections
!= NULL
)
1905 /* Sort sections by VMA. */
1908 elf_sort_sections (arg1
, arg2
)
1912 const asection
*sec1
= *(const asection
**) arg1
;
1913 const asection
*sec2
= *(const asection
**) arg2
;
1915 if (sec1
->vma
< sec2
->vma
)
1917 else if (sec1
->vma
> sec2
->vma
)
1920 /* Sort by LMA. Normally the LMA and the VMA will be the same, and
1921 this will do nothing. */
1922 if (sec1
->lma
< sec2
->lma
)
1924 else if (sec1
->lma
> sec2
->lma
)
1927 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
1929 #define TOEND(x) (((x)->flags & SEC_LOAD) == 0)
1933 return sec1
->target_index
- sec2
->target_index
;
1942 /* Sort by size, to put zero sized sections before others at the
1945 if (sec1
->_raw_size
< sec2
->_raw_size
)
1947 if (sec1
->_raw_size
> sec2
->_raw_size
)
1950 return sec1
->target_index
- sec2
->target_index
;
1953 /* Assign file positions to the sections based on the mapping from
1954 sections to segments. This function also sets up some fields in
1955 the file header, and writes out the program headers. */
1958 assign_file_positions_for_segments (abfd
)
1961 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1963 struct elf_segment_map
*m
;
1965 Elf_Internal_Phdr
*phdrs
;
1967 bfd_vma filehdr_vaddr
, filehdr_paddr
;
1968 bfd_vma phdrs_vaddr
, phdrs_paddr
;
1969 Elf_Internal_Phdr
*p
;
1971 if (elf_tdata (abfd
)->segment_map
== NULL
)
1973 if (! map_sections_to_segments (abfd
))
1977 if (bed
->elf_backend_modify_segment_map
)
1979 if (! (*bed
->elf_backend_modify_segment_map
) (abfd
))
1984 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
1987 elf_elfheader (abfd
)->e_phoff
= bed
->s
->sizeof_ehdr
;
1988 elf_elfheader (abfd
)->e_phentsize
= bed
->s
->sizeof_phdr
;
1989 elf_elfheader (abfd
)->e_phnum
= count
;
1994 /* If we already counted the number of program segments, make sure
1995 that we allocated enough space. This happens when SIZEOF_HEADERS
1996 is used in a linker script. */
1997 alloc
= elf_tdata (abfd
)->program_header_size
/ bed
->s
->sizeof_phdr
;
1998 if (alloc
!= 0 && count
> alloc
)
2000 ((*_bfd_error_handler
)
2001 ("%s: Not enough room for program headers (allocated %u, need %u)",
2002 bfd_get_filename (abfd
), alloc
, count
));
2003 bfd_set_error (bfd_error_bad_value
);
2010 phdrs
= ((Elf_Internal_Phdr
*)
2011 bfd_alloc (abfd
, alloc
* sizeof (Elf_Internal_Phdr
)));
2015 off
= bed
->s
->sizeof_ehdr
;
2016 off
+= alloc
* bed
->s
->sizeof_phdr
;
2022 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
2029 /* If elf_segment_map is not from map_sections_to_segments, the
2030 sections may not be correctly ordered. */
2032 qsort (m
->sections
, (size_t) m
->count
, sizeof (asection
*),
2035 p
->p_type
= m
->p_type
;
2037 if (m
->p_flags_valid
)
2038 p
->p_flags
= m
->p_flags
;
2042 if (p
->p_type
== PT_LOAD
2044 && (m
->sections
[0]->flags
& SEC_LOAD
) != 0)
2046 if ((abfd
->flags
& D_PAGED
) != 0)
2047 off
+= (m
->sections
[0]->vma
- off
) % bed
->maxpagesize
;
2049 off
+= ((m
->sections
[0]->vma
- off
)
2050 % (1 << bfd_get_section_alignment (abfd
, m
->sections
[0])));
2056 p
->p_vaddr
= m
->sections
[0]->vma
;
2058 if (m
->p_paddr_valid
)
2059 p
->p_paddr
= m
->p_paddr
;
2060 else if (m
->count
== 0)
2063 p
->p_paddr
= m
->sections
[0]->lma
;
2065 if (p
->p_type
== PT_LOAD
2066 && (abfd
->flags
& D_PAGED
) != 0)
2067 p
->p_align
= bed
->maxpagesize
;
2068 else if (m
->count
== 0)
2069 p
->p_align
= bed
->s
->file_align
;
2077 if (m
->includes_filehdr
)
2079 if (! m
->p_flags_valid
)
2082 p
->p_filesz
= bed
->s
->sizeof_ehdr
;
2083 p
->p_memsz
= bed
->s
->sizeof_ehdr
;
2086 BFD_ASSERT (p
->p_type
== PT_LOAD
);
2088 if (! m
->p_paddr_valid
)
2091 if (p
->p_type
== PT_LOAD
)
2093 filehdr_vaddr
= p
->p_vaddr
;
2094 filehdr_paddr
= p
->p_paddr
;
2098 if (m
->includes_phdrs
)
2100 if (! m
->p_flags_valid
)
2102 if (m
->includes_filehdr
)
2104 if (p
->p_type
== PT_LOAD
)
2106 phdrs_vaddr
= p
->p_vaddr
+ bed
->s
->sizeof_ehdr
;
2107 phdrs_paddr
= p
->p_paddr
+ bed
->s
->sizeof_ehdr
;
2112 p
->p_offset
= bed
->s
->sizeof_ehdr
;
2115 BFD_ASSERT (p
->p_type
== PT_LOAD
);
2116 p
->p_vaddr
-= off
- p
->p_offset
;
2117 if (! m
->p_paddr_valid
)
2118 p
->p_paddr
-= off
- p
->p_offset
;
2120 if (p
->p_type
== PT_LOAD
)
2122 phdrs_vaddr
= p
->p_vaddr
;
2123 phdrs_paddr
= p
->p_paddr
;
2126 p
->p_filesz
+= alloc
* bed
->s
->sizeof_phdr
;
2127 p
->p_memsz
+= alloc
* bed
->s
->sizeof_phdr
;
2130 if (p
->p_type
== PT_LOAD
)
2132 if (! m
->includes_filehdr
&& ! m
->includes_phdrs
)
2138 adjust
= off
- (p
->p_offset
+ p
->p_filesz
);
2139 p
->p_filesz
+= adjust
;
2140 p
->p_memsz
+= adjust
;
2145 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
2149 bfd_size_type align
;
2153 align
= 1 << bfd_get_section_alignment (abfd
, sec
);
2155 if (p
->p_type
== PT_LOAD
)
2159 /* The section VMA must equal the file position modulo
2161 if ((flags
& SEC_ALLOC
) != 0)
2163 if ((abfd
->flags
& D_PAGED
) != 0)
2164 adjust
= (sec
->vma
- voff
) % bed
->maxpagesize
;
2166 adjust
= (sec
->vma
- voff
) % align
;
2171 p
->p_memsz
+= adjust
;
2174 if ((flags
& SEC_LOAD
) != 0)
2175 p
->p_filesz
+= adjust
;
2181 if ((flags
& SEC_LOAD
) != 0)
2182 off
+= sec
->_raw_size
;
2183 if ((flags
& SEC_ALLOC
) != 0)
2184 voff
+= sec
->_raw_size
;
2187 p
->p_memsz
+= sec
->_raw_size
;
2189 if ((flags
& SEC_LOAD
) != 0)
2190 p
->p_filesz
+= sec
->_raw_size
;
2192 if (align
> p
->p_align
)
2195 if (! m
->p_flags_valid
)
2198 if ((flags
& SEC_CODE
) != 0)
2200 if ((flags
& SEC_READONLY
) == 0)
2206 /* Now that we have set the section file positions, we can set up
2207 the file positions for the non PT_LOAD segments. */
2208 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
2212 if (p
->p_type
!= PT_LOAD
&& m
->count
> 0)
2214 BFD_ASSERT (! m
->includes_filehdr
&& ! m
->includes_phdrs
);
2215 p
->p_offset
= m
->sections
[0]->filepos
;
2219 if (m
->includes_filehdr
)
2221 p
->p_vaddr
= filehdr_vaddr
;
2222 if (! m
->p_paddr_valid
)
2223 p
->p_paddr
= filehdr_paddr
;
2225 else if (m
->includes_phdrs
)
2227 p
->p_vaddr
= phdrs_vaddr
;
2228 if (! m
->p_paddr_valid
)
2229 p
->p_paddr
= phdrs_paddr
;
2234 /* Clear out any program headers we allocated but did not use. */
2235 for (; count
< alloc
; count
++, p
++)
2237 memset (p
, 0, sizeof *p
);
2238 p
->p_type
= PT_NULL
;
2241 elf_tdata (abfd
)->phdr
= phdrs
;
2243 elf_tdata (abfd
)->next_file_pos
= off
;
2245 /* Write out the program headers. */
2246 if (bfd_seek (abfd
, bed
->s
->sizeof_ehdr
, SEEK_SET
) != 0
2247 || bed
->s
->write_out_phdrs (abfd
, phdrs
, alloc
) != 0)
2253 /* Get the size of the program header.
2255 If this is called by the linker before any of the section VMA's are set, it
2256 can't calculate the correct value for a strange memory layout. This only
2257 happens when SIZEOF_HEADERS is used in a linker script. In this case,
2258 SORTED_HDRS is NULL and we assume the normal scenario of one text and one
2259 data segment (exclusive of .interp and .dynamic).
2261 ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
2262 will be two segments. */
2264 static bfd_size_type
2265 get_program_header_size (abfd
)
2270 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2272 /* We can't return a different result each time we're called. */
2273 if (elf_tdata (abfd
)->program_header_size
!= 0)
2274 return elf_tdata (abfd
)->program_header_size
;
2276 if (elf_tdata (abfd
)->segment_map
!= NULL
)
2278 struct elf_segment_map
*m
;
2281 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
2283 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
2284 return elf_tdata (abfd
)->program_header_size
;
2287 /* Assume we will need exactly two PT_LOAD segments: one for text
2288 and one for data. */
2291 s
= bfd_get_section_by_name (abfd
, ".interp");
2292 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
2294 /* If we have a loadable interpreter section, we need a
2295 PT_INTERP segment. In this case, assume we also need a
2296 PT_PHDR segment, although that may not be true for all
2301 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
2303 /* We need a PT_DYNAMIC segment. */
2307 /* Let the backend count up any program headers it might need. */
2308 if (bed
->elf_backend_additional_program_headers
)
2312 a
= (*bed
->elf_backend_additional_program_headers
) (abfd
);
2318 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
2319 return elf_tdata (abfd
)->program_header_size
;
2322 /* Work out the file positions of all the sections. This is called by
2323 _bfd_elf_compute_section_file_positions. All the section sizes and
2324 VMAs must be known before this is called.
2326 We do not consider reloc sections at this point, unless they form
2327 part of the loadable image. Reloc sections are assigned file
2328 positions in assign_file_positions_for_relocs, which is called by
2329 write_object_contents and final_link.
2331 We also don't set the positions of the .symtab and .strtab here. */
2334 assign_file_positions_except_relocs (abfd
)
2337 struct elf_obj_tdata
* const tdata
= elf_tdata (abfd
);
2338 Elf_Internal_Ehdr
* const i_ehdrp
= elf_elfheader (abfd
);
2339 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
2341 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2343 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
2345 Elf_Internal_Shdr
**hdrpp
;
2348 /* Start after the ELF header. */
2349 off
= i_ehdrp
->e_ehsize
;
2351 /* We are not creating an executable, which means that we are
2352 not creating a program header, and that the actual order of
2353 the sections in the file is unimportant. */
2354 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2356 Elf_Internal_Shdr
*hdr
;
2359 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
2361 hdr
->sh_offset
= -1;
2364 if (i
== tdata
->symtab_section
2365 || i
== tdata
->strtab_section
)
2367 hdr
->sh_offset
= -1;
2371 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
2377 Elf_Internal_Shdr
**hdrpp
;
2379 /* Assign file positions for the loaded sections based on the
2380 assignment of sections to segments. */
2381 if (! assign_file_positions_for_segments (abfd
))
2384 /* Assign file positions for the other sections. */
2386 off
= elf_tdata (abfd
)->next_file_pos
;
2387 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2389 Elf_Internal_Shdr
*hdr
;
2392 if (hdr
->bfd_section
!= NULL
2393 && hdr
->bfd_section
->filepos
!= 0)
2394 hdr
->sh_offset
= hdr
->bfd_section
->filepos
;
2395 else if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
2397 ((*_bfd_error_handler
)
2398 ("%s: warning: allocated section `%s' not in segment",
2399 bfd_get_filename (abfd
),
2400 (hdr
->bfd_section
== NULL
2402 : hdr
->bfd_section
->name
)));
2403 if ((abfd
->flags
& D_PAGED
) != 0)
2404 off
+= (hdr
->sh_addr
- off
) % bed
->maxpagesize
;
2406 off
+= (hdr
->sh_addr
- off
) % hdr
->sh_addralign
;
2407 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
,
2410 else if (hdr
->sh_type
== SHT_REL
2411 || hdr
->sh_type
== SHT_RELA
2412 || hdr
== i_shdrpp
[tdata
->symtab_section
]
2413 || hdr
== i_shdrpp
[tdata
->strtab_section
])
2414 hdr
->sh_offset
= -1;
2416 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
2420 /* Place the section headers. */
2421 off
= align_file_position (off
, bed
->s
->file_align
);
2422 i_ehdrp
->e_shoff
= off
;
2423 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
2425 elf_tdata (abfd
)->next_file_pos
= off
;
2434 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2435 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
2436 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2438 struct bfd_strtab_hash
*shstrtab
;
2439 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2441 i_ehdrp
= elf_elfheader (abfd
);
2442 i_shdrp
= elf_elfsections (abfd
);
2444 shstrtab
= _bfd_elf_stringtab_init ();
2445 if (shstrtab
== NULL
)
2448 elf_shstrtab (abfd
) = shstrtab
;
2450 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
2451 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
2452 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
2453 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
2455 i_ehdrp
->e_ident
[EI_CLASS
] = bed
->s
->elfclass
;
2456 i_ehdrp
->e_ident
[EI_DATA
] =
2457 bfd_big_endian (abfd
) ? ELFDATA2MSB
: ELFDATA2LSB
;
2458 i_ehdrp
->e_ident
[EI_VERSION
] = bed
->s
->ev_current
;
2460 for (count
= EI_PAD
; count
< EI_NIDENT
; count
++)
2461 i_ehdrp
->e_ident
[count
] = 0;
2463 if ((abfd
->flags
& DYNAMIC
) != 0)
2464 i_ehdrp
->e_type
= ET_DYN
;
2465 else if ((abfd
->flags
& EXEC_P
) != 0)
2466 i_ehdrp
->e_type
= ET_EXEC
;
2468 i_ehdrp
->e_type
= ET_REL
;
2470 switch (bfd_get_arch (abfd
))
2472 case bfd_arch_unknown
:
2473 i_ehdrp
->e_machine
= EM_NONE
;
2475 case bfd_arch_sparc
:
2476 if (bed
->s
->arch_size
== 64)
2477 i_ehdrp
->e_machine
= EM_SPARC64
;
2479 i_ehdrp
->e_machine
= EM_SPARC
;
2482 i_ehdrp
->e_machine
= EM_386
;
2485 i_ehdrp
->e_machine
= EM_68K
;
2488 i_ehdrp
->e_machine
= EM_88K
;
2491 i_ehdrp
->e_machine
= EM_860
;
2493 case bfd_arch_mips
: /* MIPS Rxxxx */
2494 i_ehdrp
->e_machine
= EM_MIPS
; /* only MIPS R3000 */
2497 i_ehdrp
->e_machine
= EM_PARISC
;
2499 case bfd_arch_powerpc
:
2500 i_ehdrp
->e_machine
= EM_PPC
;
2502 case bfd_arch_alpha
:
2503 i_ehdrp
->e_machine
= EM_ALPHA
;
2506 i_ehdrp
->e_machine
= EM_SH
;
2508 /* start-sanitize-d10v */
2510 i_ehdrp
->e_machine
= EM_CYGNUS_D10V
;
2512 /* end-sanitize-d10v */
2513 /* start-sanitize-v850 */
2515 i_ehdrp
->e_machine
= EM_CYGNUS_V850
;
2517 /* end-sanitize-v850 */
2518 /* start-sanitize-arc */
2520 i_ehdrp
->e_machine
= EM_CYGNUS_ARC
;
2522 /* end-sanitize-arc */
2523 /* start-sanitize-m32r */
2525 i_ehdrp
->e_machine
= EM_CYGNUS_M32R
;
2527 /* end-sanitize-m32r */
2528 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
2530 i_ehdrp
->e_machine
= EM_NONE
;
2532 i_ehdrp
->e_version
= bed
->s
->ev_current
;
2533 i_ehdrp
->e_ehsize
= bed
->s
->sizeof_ehdr
;
2535 /* no program header, for now. */
2536 i_ehdrp
->e_phoff
= 0;
2537 i_ehdrp
->e_phentsize
= 0;
2538 i_ehdrp
->e_phnum
= 0;
2540 /* each bfd section is section header entry */
2541 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
2542 i_ehdrp
->e_shentsize
= bed
->s
->sizeof_shdr
;
2544 /* if we're building an executable, we'll need a program header table */
2545 if (abfd
->flags
& EXEC_P
)
2547 /* it all happens later */
2549 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
2551 /* elf_build_phdrs() returns a (NULL-terminated) array of
2552 Elf_Internal_Phdrs */
2553 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
2554 i_ehdrp
->e_phoff
= outbase
;
2555 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
2560 i_ehdrp
->e_phentsize
= 0;
2562 i_ehdrp
->e_phoff
= 0;
2565 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
2566 (unsigned int) _bfd_stringtab_add (shstrtab
, ".symtab", true, false);
2567 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
2568 (unsigned int) _bfd_stringtab_add (shstrtab
, ".strtab", true, false);
2569 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
2570 (unsigned int) _bfd_stringtab_add (shstrtab
, ".shstrtab", true, false);
2571 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2572 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2573 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
2579 /* Assign file positions for all the reloc sections which are not part
2580 of the loadable file image. */
2583 _bfd_elf_assign_file_positions_for_relocs (abfd
)
2588 Elf_Internal_Shdr
**shdrpp
;
2590 off
= elf_tdata (abfd
)->next_file_pos
;
2592 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1;
2593 i
< elf_elfheader (abfd
)->e_shnum
;
2596 Elf_Internal_Shdr
*shdrp
;
2599 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
2600 && shdrp
->sh_offset
== -1)
2601 off
= _bfd_elf_assign_file_position_for_section (shdrp
, off
, true);
2604 elf_tdata (abfd
)->next_file_pos
= off
;
2608 _bfd_elf_write_object_contents (abfd
)
2611 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2612 Elf_Internal_Ehdr
*i_ehdrp
;
2613 Elf_Internal_Shdr
**i_shdrp
;
2617 if (! abfd
->output_has_begun
2618 && ! _bfd_elf_compute_section_file_positions (abfd
,
2619 (struct bfd_link_info
*) NULL
))
2622 i_shdrp
= elf_elfsections (abfd
);
2623 i_ehdrp
= elf_elfheader (abfd
);
2626 bfd_map_over_sections (abfd
, bed
->s
->write_relocs
, &failed
);
2629 _bfd_elf_assign_file_positions_for_relocs (abfd
);
2631 /* After writing the headers, we need to write the sections too... */
2632 for (count
= 1; count
< i_ehdrp
->e_shnum
; count
++)
2634 if (bed
->elf_backend_section_processing
)
2635 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
2636 if (i_shdrp
[count
]->contents
)
2638 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
2639 || (bfd_write (i_shdrp
[count
]->contents
, i_shdrp
[count
]->sh_size
,
2641 != i_shdrp
[count
]->sh_size
))
2646 /* Write out the section header names. */
2647 if (bfd_seek (abfd
, elf_tdata (abfd
)->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
2648 || ! _bfd_stringtab_emit (abfd
, elf_shstrtab (abfd
)))
2651 if (bed
->elf_backend_final_write_processing
)
2652 (*bed
->elf_backend_final_write_processing
) (abfd
,
2653 elf_tdata (abfd
)->linker
);
2655 return bed
->s
->write_shdrs_and_ehdr (abfd
);
2658 /* given a section, search the header to find them... */
2660 _bfd_elf_section_from_bfd_section (abfd
, asect
)
2664 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2665 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
2667 Elf_Internal_Shdr
*hdr
;
2668 int maxindex
= elf_elfheader (abfd
)->e_shnum
;
2670 for (index
= 0; index
< maxindex
; index
++)
2672 hdr
= i_shdrp
[index
];
2673 if (hdr
->bfd_section
== asect
)
2677 if (bed
->elf_backend_section_from_bfd_section
)
2679 for (index
= 0; index
< maxindex
; index
++)
2683 hdr
= i_shdrp
[index
];
2685 if ((*bed
->elf_backend_section_from_bfd_section
)
2686 (abfd
, hdr
, asect
, &retval
))
2691 if (bfd_is_abs_section (asect
))
2693 if (bfd_is_com_section (asect
))
2695 if (bfd_is_und_section (asect
))
2701 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
2705 _bfd_elf_symbol_from_bfd_symbol (abfd
, asym_ptr_ptr
)
2707 asymbol
**asym_ptr_ptr
;
2709 asymbol
*asym_ptr
= *asym_ptr_ptr
;
2711 flagword flags
= asym_ptr
->flags
;
2713 /* When gas creates relocations against local labels, it creates its
2714 own symbol for the section, but does put the symbol into the
2715 symbol chain, so udata is 0. When the linker is generating
2716 relocatable output, this section symbol may be for one of the
2717 input sections rather than the output section. */
2718 if (asym_ptr
->udata
.i
== 0
2719 && (flags
& BSF_SECTION_SYM
)
2720 && asym_ptr
->section
)
2724 if (asym_ptr
->section
->output_section
!= NULL
)
2725 indx
= asym_ptr
->section
->output_section
->index
;
2727 indx
= asym_ptr
->section
->index
;
2728 if (elf_section_syms (abfd
)[indx
])
2729 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
2732 idx
= asym_ptr
->udata
.i
;
2736 /* This case can occur when using --strip-symbol on a symbol
2737 which is used in a relocation entry. */
2738 (*_bfd_error_handler
)
2739 ("%s: symbol `%s' required but not present",
2740 bfd_get_filename (abfd
), bfd_asymbol_name (asym_ptr
));
2741 bfd_set_error (bfd_error_no_symbols
);
2748 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
2749 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
,
2750 elf_symbol_flags (flags
));
2758 /* Copy private BFD data. This copies any program header information. */
2761 copy_private_bfd_data (ibfd
, obfd
)
2765 Elf_Internal_Ehdr
*iehdr
;
2766 struct elf_segment_map
*mfirst
;
2767 struct elf_segment_map
**pm
;
2768 Elf_Internal_Phdr
*p
;
2771 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2772 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2775 if (elf_tdata (ibfd
)->phdr
== NULL
)
2778 iehdr
= elf_elfheader (ibfd
);
2783 c
= elf_elfheader (ibfd
)->e_phnum
;
2784 for (i
= 0, p
= elf_tdata (ibfd
)->phdr
; i
< c
; i
++, p
++)
2788 struct elf_segment_map
*m
;
2793 /* The complicated case when p_vaddr is 0 is to handle the
2794 Solaris linker, which generates a PT_INTERP section with
2795 p_vaddr and p_memsz set to 0. */
2796 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2797 if (((s
->vma
>= p
->p_vaddr
2798 && (s
->vma
+ s
->_raw_size
<= p
->p_vaddr
+ p
->p_memsz
2799 || s
->vma
+ s
->_raw_size
<= p
->p_vaddr
+ p
->p_filesz
))
2802 && (s
->flags
& SEC_HAS_CONTENTS
) != 0
2803 && (bfd_vma
) s
->filepos
>= p
->p_offset
2804 && ((bfd_vma
) s
->filepos
+ s
->_raw_size
2805 <= p
->p_offset
+ p
->p_filesz
)))
2806 && (s
->flags
& SEC_ALLOC
) != 0
2807 && s
->output_section
!= NULL
)
2810 m
= ((struct elf_segment_map
*)
2812 (sizeof (struct elf_segment_map
)
2813 + (csecs
- 1) * sizeof (asection
*))));
2818 m
->p_type
= p
->p_type
;
2819 m
->p_flags
= p
->p_flags
;
2820 m
->p_flags_valid
= 1;
2821 m
->p_paddr
= p
->p_paddr
;
2822 m
->p_paddr_valid
= 1;
2824 m
->includes_filehdr
= (p
->p_offset
== 0
2825 && p
->p_filesz
>= iehdr
->e_ehsize
);
2827 m
->includes_phdrs
= (p
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
2828 && (p
->p_offset
+ p
->p_filesz
2829 >= ((bfd_vma
) iehdr
->e_phoff
2830 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
2833 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2835 if (((s
->vma
>= p
->p_vaddr
2836 && (s
->vma
+ s
->_raw_size
<= p
->p_vaddr
+ p
->p_memsz
2837 || s
->vma
+ s
->_raw_size
<= p
->p_vaddr
+ p
->p_filesz
))
2840 && (s
->flags
& SEC_HAS_CONTENTS
) != 0
2841 && (bfd_vma
) s
->filepos
>= p
->p_offset
2842 && ((bfd_vma
) s
->filepos
+ s
->_raw_size
2843 <= p
->p_offset
+ p
->p_filesz
)))
2844 && (s
->flags
& SEC_ALLOC
) != 0
2845 && s
->output_section
!= NULL
)
2847 m
->sections
[isec
] = s
->output_section
;
2851 BFD_ASSERT (isec
== csecs
);
2858 elf_tdata (obfd
)->segment_map
= mfirst
;
2863 /* Copy private section information. This copies over the entsize
2864 field, and sometimes the info field. */
2867 _bfd_elf_copy_private_section_data (ibfd
, isec
, obfd
, osec
)
2873 Elf_Internal_Shdr
*ihdr
, *ohdr
;
2875 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
2876 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
2879 /* Copy over private BFD data if it has not already been copied.
2880 This must be done here, rather than in the copy_private_bfd_data
2881 entry point, because the latter is called after the section
2882 contents have been set, which means that the program headers have
2883 already been worked out. */
2884 if (elf_tdata (obfd
)->segment_map
== NULL
2885 && elf_tdata (ibfd
)->phdr
!= NULL
)
2889 /* Only set up the segments when all the sections have been set
2891 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2892 if (s
->output_section
== NULL
)
2896 if (! copy_private_bfd_data (ibfd
, obfd
))
2901 ihdr
= &elf_section_data (isec
)->this_hdr
;
2902 ohdr
= &elf_section_data (osec
)->this_hdr
;
2904 ohdr
->sh_entsize
= ihdr
->sh_entsize
;
2906 if (ihdr
->sh_type
== SHT_SYMTAB
2907 || ihdr
->sh_type
== SHT_DYNSYM
)
2908 ohdr
->sh_info
= ihdr
->sh_info
;
2913 /* Copy private symbol information. If this symbol is in a section
2914 which we did not map into a BFD section, try to map the section
2915 index correctly. We use special macro definitions for the mapped
2916 section indices; these definitions are interpreted by the
2917 swap_out_syms function. */
2919 #define MAP_ONESYMTAB (SHN_LORESERVE - 1)
2920 #define MAP_DYNSYMTAB (SHN_LORESERVE - 2)
2921 #define MAP_STRTAB (SHN_LORESERVE - 3)
2922 #define MAP_SHSTRTAB (SHN_LORESERVE - 4)
2925 _bfd_elf_copy_private_symbol_data (ibfd
, isymarg
, obfd
, osymarg
)
2931 elf_symbol_type
*isym
, *osym
;
2933 isym
= elf_symbol_from (ibfd
, isymarg
);
2934 osym
= elf_symbol_from (obfd
, osymarg
);
2938 && bfd_is_abs_section (isym
->symbol
.section
))
2942 shndx
= isym
->internal_elf_sym
.st_shndx
;
2943 if (shndx
== elf_onesymtab (ibfd
))
2944 shndx
= MAP_ONESYMTAB
;
2945 else if (shndx
== elf_dynsymtab (ibfd
))
2946 shndx
= MAP_DYNSYMTAB
;
2947 else if (shndx
== elf_tdata (ibfd
)->strtab_section
)
2949 else if (shndx
== elf_tdata (ibfd
)->shstrtab_section
)
2950 shndx
= MAP_SHSTRTAB
;
2951 osym
->internal_elf_sym
.st_shndx
= shndx
;
2957 /* Swap out the symbols. */
2960 swap_out_syms (abfd
, sttp
)
2962 struct bfd_strtab_hash
**sttp
;
2964 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2966 if (!elf_map_symbols (abfd
))
2969 /* Dump out the symtabs. */
2971 int symcount
= bfd_get_symcount (abfd
);
2972 asymbol
**syms
= bfd_get_outsymbols (abfd
);
2973 struct bfd_strtab_hash
*stt
;
2974 Elf_Internal_Shdr
*symtab_hdr
;
2975 Elf_Internal_Shdr
*symstrtab_hdr
;
2976 char *outbound_syms
;
2979 stt
= _bfd_elf_stringtab_init ();
2983 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2984 symtab_hdr
->sh_type
= SHT_SYMTAB
;
2985 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
2986 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
2987 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
2988 symtab_hdr
->sh_addralign
= bed
->s
->file_align
;
2990 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2991 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2993 outbound_syms
= bfd_alloc (abfd
,
2994 (1 + symcount
) * bed
->s
->sizeof_sym
);
2995 if (outbound_syms
== NULL
)
2997 symtab_hdr
->contents
= (PTR
) outbound_syms
;
2999 /* now generate the data (for "contents") */
3001 /* Fill in zeroth symbol and swap it out. */
3002 Elf_Internal_Sym sym
;
3008 sym
.st_shndx
= SHN_UNDEF
;
3009 bed
->s
->swap_symbol_out (abfd
, &sym
, (PTR
) outbound_syms
);
3010 outbound_syms
+= bed
->s
->sizeof_sym
;
3012 for (idx
= 0; idx
< symcount
; idx
++)
3014 Elf_Internal_Sym sym
;
3015 bfd_vma value
= syms
[idx
]->value
;
3016 elf_symbol_type
*type_ptr
;
3017 flagword flags
= syms
[idx
]->flags
;
3020 if (flags
& BSF_SECTION_SYM
)
3021 /* Section symbols have no names. */
3025 sym
.st_name
= (unsigned long) _bfd_stringtab_add (stt
,
3028 if (sym
.st_name
== (unsigned long) -1)
3032 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
3034 if (bfd_is_com_section (syms
[idx
]->section
))
3036 /* ELF common symbols put the alignment into the `value' field,
3037 and the size into the `size' field. This is backwards from
3038 how BFD handles it, so reverse it here. */
3039 sym
.st_size
= value
;
3040 if (type_ptr
== NULL
3041 || type_ptr
->internal_elf_sym
.st_value
== 0)
3042 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
3044 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
3045 sym
.st_shndx
= _bfd_elf_section_from_bfd_section (abfd
,
3046 syms
[idx
]->section
);
3050 asection
*sec
= syms
[idx
]->section
;
3053 if (sec
->output_section
)
3055 value
+= sec
->output_offset
;
3056 sec
= sec
->output_section
;
3059 sym
.st_value
= value
;
3060 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
3062 if (bfd_is_abs_section (sec
)
3064 && type_ptr
->internal_elf_sym
.st_shndx
!= 0)
3066 /* This symbol is in a real ELF section which we did
3067 not create as a BFD section. Undo the mapping done
3068 by copy_private_symbol_data. */
3069 shndx
= type_ptr
->internal_elf_sym
.st_shndx
;
3073 shndx
= elf_onesymtab (abfd
);
3076 shndx
= elf_dynsymtab (abfd
);
3079 shndx
= elf_tdata (abfd
)->strtab_section
;
3082 shndx
= elf_tdata (abfd
)->shstrtab_section
;
3090 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
3096 /* Writing this would be a hell of a lot easier if
3097 we had some decent documentation on bfd, and
3098 knew what to expect of the library, and what to
3099 demand of applications. For example, it
3100 appears that `objcopy' might not set the
3101 section of a symbol to be a section that is
3102 actually in the output file. */
3103 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
3104 BFD_ASSERT (sec2
!= 0);
3105 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
3106 BFD_ASSERT (shndx
!= -1);
3110 sym
.st_shndx
= shndx
;
3113 if ((flags
& BSF_FUNCTION
) != 0)
3115 else if ((flags
& BSF_OBJECT
) != 0)
3120 if (bfd_is_com_section (syms
[idx
]->section
))
3121 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, type
);
3122 else if (bfd_is_und_section (syms
[idx
]->section
))
3123 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
3127 else if (flags
& BSF_SECTION_SYM
)
3128 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
3129 else if (flags
& BSF_FILE
)
3130 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
3133 int bind
= STB_LOCAL
;
3135 if (flags
& BSF_LOCAL
)
3137 else if (flags
& BSF_WEAK
)
3139 else if (flags
& BSF_GLOBAL
)
3142 sym
.st_info
= ELF_ST_INFO (bind
, type
);
3146 bed
->s
->swap_symbol_out (abfd
, &sym
, (PTR
) outbound_syms
);
3147 outbound_syms
+= bed
->s
->sizeof_sym
;
3151 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (stt
);
3152 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
3154 symstrtab_hdr
->sh_flags
= 0;
3155 symstrtab_hdr
->sh_addr
= 0;
3156 symstrtab_hdr
->sh_entsize
= 0;
3157 symstrtab_hdr
->sh_link
= 0;
3158 symstrtab_hdr
->sh_info
= 0;
3159 symstrtab_hdr
->sh_addralign
= 1;
3165 /* Return the number of bytes required to hold the symtab vector.
3167 Note that we base it on the count plus 1, since we will null terminate
3168 the vector allocated based on this size. However, the ELF symbol table
3169 always has a dummy entry as symbol #0, so it ends up even. */
3172 _bfd_elf_get_symtab_upper_bound (abfd
)
3177 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3179 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
3180 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
3186 _bfd_elf_get_dynamic_symtab_upper_bound (abfd
)
3191 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
3193 if (elf_dynsymtab (abfd
) == 0)
3195 bfd_set_error (bfd_error_invalid_operation
);
3199 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
3200 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
3206 _bfd_elf_get_reloc_upper_bound (abfd
, asect
)
3210 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
3213 /* Canonicalize the relocs. */
3216 _bfd_elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
3225 if (! get_elf_backend_data (abfd
)->s
->slurp_reloc_table (abfd
, section
, symbols
))
3228 tblptr
= section
->relocation
;
3229 for (i
= 0; i
< section
->reloc_count
; i
++)
3230 *relptr
++ = tblptr
++;
3234 return section
->reloc_count
;
3238 _bfd_elf_get_symtab (abfd
, alocation
)
3240 asymbol
**alocation
;
3242 long symcount
= get_elf_backend_data (abfd
)->s
->slurp_symbol_table (abfd
, alocation
, false);
3245 bfd_get_symcount (abfd
) = symcount
;
3250 _bfd_elf_canonicalize_dynamic_symtab (abfd
, alocation
)
3252 asymbol
**alocation
;
3254 return get_elf_backend_data (abfd
)->s
->slurp_symbol_table (abfd
, alocation
, true);
3258 _bfd_elf_make_empty_symbol (abfd
)
3261 elf_symbol_type
*newsym
;
3263 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (elf_symbol_type
));
3268 newsym
->symbol
.the_bfd
= abfd
;
3269 return &newsym
->symbol
;
3274 _bfd_elf_get_symbol_info (ignore_abfd
, symbol
, ret
)
3279 bfd_symbol_info (symbol
, ret
);
3283 _bfd_elf_get_lineno (ignore_abfd
, symbol
)
3292 _bfd_elf_set_arch_mach (abfd
, arch
, machine
)
3294 enum bfd_architecture arch
;
3295 unsigned long machine
;
3297 /* If this isn't the right architecture for this backend, and this
3298 isn't the generic backend, fail. */
3299 if (arch
!= get_elf_backend_data (abfd
)->arch
3300 && arch
!= bfd_arch_unknown
3301 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
3304 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
3307 /* Find the nearest line to a particular section and offset, for error
3311 _bfd_elf_find_nearest_line (abfd
,
3322 CONST
char **filename_ptr
;
3323 CONST
char **functionname_ptr
;
3324 unsigned int *line_ptr
;
3327 const char *filename
;
3332 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
3333 &found
, filename_ptr
,
3334 functionname_ptr
, line_ptr
,
3335 &elf_tdata (abfd
)->line_info
))
3340 if (symbols
== NULL
)
3347 for (p
= symbols
; *p
!= NULL
; p
++)
3351 q
= (elf_symbol_type
*) *p
;
3353 if (bfd_get_section (&q
->symbol
) != section
)
3356 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
3361 filename
= bfd_asymbol_name (&q
->symbol
);
3364 if (q
->symbol
.section
== section
3365 && q
->symbol
.value
>= low_func
3366 && q
->symbol
.value
<= offset
)
3368 func
= (asymbol
*) q
;
3369 low_func
= q
->symbol
.value
;
3378 *filename_ptr
= filename
;
3379 *functionname_ptr
= bfd_asymbol_name (func
);
3385 _bfd_elf_sizeof_headers (abfd
, reloc
)
3391 ret
= get_elf_backend_data (abfd
)->s
->sizeof_ehdr
;
3393 ret
+= get_program_header_size (abfd
);
3398 _bfd_elf_set_section_contents (abfd
, section
, location
, offset
, count
)
3403 bfd_size_type count
;
3405 Elf_Internal_Shdr
*hdr
;
3407 if (! abfd
->output_has_begun
3408 && ! _bfd_elf_compute_section_file_positions (abfd
,
3409 (struct bfd_link_info
*) NULL
))
3412 hdr
= &elf_section_data (section
)->this_hdr
;
3414 if (bfd_seek (abfd
, hdr
->sh_offset
+ offset
, SEEK_SET
) == -1)
3416 if (bfd_write (location
, 1, count
, abfd
) != count
)
3423 _bfd_elf_no_info_to_howto (abfd
, cache_ptr
, dst
)
3426 Elf_Internal_Rela
*dst
;
3433 _bfd_elf_no_info_to_howto_rel (abfd
, cache_ptr
, dst
)
3436 Elf_Internal_Rel
*dst
;
3442 /* Try to convert a non-ELF reloc into an ELF one. */
3445 _bfd_elf_validate_reloc (abfd
, areloc
)
3449 /* Check whether we really have an ELF howto. */
3451 if ((*areloc
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
)
3453 bfd_reloc_code_real_type code
;
3454 reloc_howto_type
*howto
;
3456 /* Alien reloc: Try to determine its type to replace it with an
3457 equivalent ELF reloc. */
3459 if (areloc
->howto
->pc_relative
)
3461 switch (areloc
->howto
->bitsize
)
3464 code
= BFD_RELOC_8_PCREL
;
3467 code
= BFD_RELOC_12_PCREL
;
3470 code
= BFD_RELOC_16_PCREL
;
3473 code
= BFD_RELOC_24_PCREL
;
3476 code
= BFD_RELOC_32_PCREL
;
3479 code
= BFD_RELOC_64_PCREL
;
3485 howto
= bfd_reloc_type_lookup (abfd
, code
);
3487 if (areloc
->howto
->pcrel_offset
!= howto
->pcrel_offset
)
3489 if (howto
->pcrel_offset
)
3490 areloc
->addend
+= areloc
->address
;
3492 areloc
->addend
-= areloc
->address
; /* addend is unsigned!! */
3497 switch (areloc
->howto
->bitsize
)
3503 code
= BFD_RELOC_14
;
3506 code
= BFD_RELOC_16
;
3509 code
= BFD_RELOC_26
;
3512 code
= BFD_RELOC_32
;
3515 code
= BFD_RELOC_64
;
3521 howto
= bfd_reloc_type_lookup (abfd
, code
);
3525 areloc
->howto
= howto
;
3533 (*_bfd_error_handler
)
3534 ("%s: unsupported relocation type %s",
3535 bfd_get_filename (abfd
), areloc
->howto
->name
);
3536 bfd_set_error (bfd_error_bad_value
);