1 /* ELF executable support for BFD.
2 Copyright 1993, 1994, 1995, 1996, 1997 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
);
106 bfd_elf_mkobject (abfd
)
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;
476 case DT_AUXILIARY
: name
= "AUXILIARY"; stringp
= true; break;
477 case DT_FILTER
: name
= "FILTER"; stringp
= true; break;
480 fprintf (f
, " %-11s ", name
);
482 fprintf (f
, "0x%lx", (unsigned long) dyn
.d_un
.d_val
);
487 string
= bfd_elf_string_from_elf_section (abfd
, link
,
491 fprintf (f
, "%s", string
);
508 /* Display ELF-specific fields of a symbol. */
510 bfd_elf_print_symbol (ignore_abfd
, filep
, symbol
, how
)
514 bfd_print_symbol_type how
;
516 FILE *file
= (FILE *) filep
;
519 case bfd_print_symbol_name
:
520 fprintf (file
, "%s", symbol
->name
);
522 case bfd_print_symbol_more
:
523 fprintf (file
, "elf ");
524 fprintf_vma (file
, symbol
->value
);
525 fprintf (file
, " %lx", (long) symbol
->flags
);
527 case bfd_print_symbol_all
:
529 CONST
char *section_name
;
530 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
531 bfd_print_symbol_vandf ((PTR
) file
, symbol
);
532 fprintf (file
, " %s\t", section_name
);
533 /* Print the "other" value for a symbol. For common symbols,
534 we've already printed the size; now print the alignment.
535 For other symbols, we have no specified alignment, and
536 we've printed the address; now print the size. */
538 (bfd_is_com_section (symbol
->section
)
539 ? ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_value
540 : ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_size
));
541 /* If the st_other field is not zero, print it. */
542 if (((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_other
!= 0)
543 fprintf (file
, " 0x%02x",
545 ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_other
));
546 fprintf (file
, " %s", symbol
->name
);
552 /* Create an entry in an ELF linker hash table. */
554 struct bfd_hash_entry
*
555 _bfd_elf_link_hash_newfunc (entry
, table
, string
)
556 struct bfd_hash_entry
*entry
;
557 struct bfd_hash_table
*table
;
560 struct elf_link_hash_entry
*ret
= (struct elf_link_hash_entry
*) entry
;
562 /* Allocate the structure if it has not already been allocated by a
564 if (ret
== (struct elf_link_hash_entry
*) NULL
)
565 ret
= ((struct elf_link_hash_entry
*)
566 bfd_hash_allocate (table
, sizeof (struct elf_link_hash_entry
)));
567 if (ret
== (struct elf_link_hash_entry
*) NULL
)
568 return (struct bfd_hash_entry
*) ret
;
570 /* Call the allocation method of the superclass. */
571 ret
= ((struct elf_link_hash_entry
*)
572 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
574 if (ret
!= (struct elf_link_hash_entry
*) NULL
)
576 /* Set local fields. */
580 ret
->dynstr_index
= 0;
582 ret
->got_offset
= (bfd_vma
) -1;
583 ret
->plt_offset
= (bfd_vma
) -1;
584 ret
->linker_section_pointer
= (elf_linker_section_pointers_t
*)0;
585 ret
->type
= STT_NOTYPE
;
587 /* Assume that we have been called by a non-ELF symbol reader.
588 This flag is then reset by the code which reads an ELF input
589 file. This ensures that a symbol created by a non-ELF symbol
590 reader will have the flag set correctly. */
591 ret
->elf_link_hash_flags
= ELF_LINK_NON_ELF
;
594 return (struct bfd_hash_entry
*) ret
;
597 /* Initialize an ELF linker hash table. */
600 _bfd_elf_link_hash_table_init (table
, abfd
, newfunc
)
601 struct elf_link_hash_table
*table
;
603 struct bfd_hash_entry
*(*newfunc
) PARAMS ((struct bfd_hash_entry
*,
604 struct bfd_hash_table
*,
607 table
->dynamic_sections_created
= false;
608 table
->dynobj
= NULL
;
609 /* The first dynamic symbol is a dummy. */
610 table
->dynsymcount
= 1;
611 table
->dynstr
= NULL
;
612 table
->bucketcount
= 0;
613 table
->needed
= NULL
;
615 table
->stab_info
= NULL
;
616 return _bfd_link_hash_table_init (&table
->root
, abfd
, newfunc
);
619 /* Create an ELF linker hash table. */
621 struct bfd_link_hash_table
*
622 _bfd_elf_link_hash_table_create (abfd
)
625 struct elf_link_hash_table
*ret
;
627 ret
= ((struct elf_link_hash_table
*)
628 bfd_alloc (abfd
, sizeof (struct elf_link_hash_table
)));
629 if (ret
== (struct elf_link_hash_table
*) NULL
)
632 if (! _bfd_elf_link_hash_table_init (ret
, abfd
, _bfd_elf_link_hash_newfunc
))
634 bfd_release (abfd
, ret
);
641 /* This is a hook for the ELF emulation code in the generic linker to
642 tell the backend linker what file name to use for the DT_NEEDED
643 entry for a dynamic object. The generic linker passes name as an
644 empty string to indicate that no DT_NEEDED entry should be made. */
647 bfd_elf_set_dt_needed_name (abfd
, name
)
651 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
652 && bfd_get_format (abfd
) == bfd_object
)
653 elf_dt_name (abfd
) = name
;
656 /* Get the list of DT_NEEDED entries for a link. This is a hook for
657 the ELF emulation code. */
659 struct bfd_link_needed_list
*
660 bfd_elf_get_needed_list (abfd
, info
)
662 struct bfd_link_info
*info
;
664 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
666 return elf_hash_table (info
)->needed
;
669 /* Get the name actually used for a dynamic object for a link. This
670 is the SONAME entry if there is one. Otherwise, it is the string
671 passed to bfd_elf_set_dt_needed_name, or it is the filename. */
674 bfd_elf_get_dt_soname (abfd
)
677 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
678 && bfd_get_format (abfd
) == bfd_object
)
679 return elf_dt_name (abfd
);
683 /* Allocate an ELF string table--force the first byte to be zero. */
685 struct bfd_strtab_hash
*
686 _bfd_elf_stringtab_init ()
688 struct bfd_strtab_hash
*ret
;
690 ret
= _bfd_stringtab_init ();
695 loc
= _bfd_stringtab_add (ret
, "", true, false);
696 BFD_ASSERT (loc
== 0 || loc
== (bfd_size_type
) -1);
697 if (loc
== (bfd_size_type
) -1)
699 _bfd_stringtab_free (ret
);
706 /* ELF .o/exec file reading */
708 /* Create a new bfd section from an ELF section header. */
711 bfd_section_from_shdr (abfd
, shindex
)
713 unsigned int shindex
;
715 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[shindex
];
716 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
717 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
720 name
= elf_string_from_elf_strtab (abfd
, hdr
->sh_name
);
722 switch (hdr
->sh_type
)
725 /* Inactive section. Throw it away. */
728 case SHT_PROGBITS
: /* Normal section with contents. */
729 case SHT_DYNAMIC
: /* Dynamic linking information. */
730 case SHT_NOBITS
: /* .bss section. */
731 case SHT_HASH
: /* .hash section. */
732 case SHT_NOTE
: /* .note section. */
733 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
735 case SHT_SYMTAB
: /* A symbol table */
736 if (elf_onesymtab (abfd
) == shindex
)
739 BFD_ASSERT (hdr
->sh_entsize
== bed
->s
->sizeof_sym
);
740 BFD_ASSERT (elf_onesymtab (abfd
) == 0);
741 elf_onesymtab (abfd
) = shindex
;
742 elf_tdata (abfd
)->symtab_hdr
= *hdr
;
743 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->symtab_hdr
;
744 abfd
->flags
|= HAS_SYMS
;
746 /* Sometimes a shared object will map in the symbol table. If
747 SHF_ALLOC is set, and this is a shared object, then we also
748 treat this section as a BFD section. We can not base the
749 decision purely on SHF_ALLOC, because that flag is sometimes
750 set in a relocateable object file, which would confuse the
752 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
753 && (abfd
->flags
& DYNAMIC
) != 0
754 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
759 case SHT_DYNSYM
: /* A dynamic symbol table */
760 if (elf_dynsymtab (abfd
) == shindex
)
763 BFD_ASSERT (hdr
->sh_entsize
== bed
->s
->sizeof_sym
);
764 BFD_ASSERT (elf_dynsymtab (abfd
) == 0);
765 elf_dynsymtab (abfd
) = shindex
;
766 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
767 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
768 abfd
->flags
|= HAS_SYMS
;
770 /* Besides being a symbol table, we also treat this as a regular
771 section, so that objcopy can handle it. */
772 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
774 case SHT_STRTAB
: /* A string table */
775 if (hdr
->bfd_section
!= NULL
)
777 if (ehdr
->e_shstrndx
== shindex
)
779 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
780 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
786 for (i
= 1; i
< ehdr
->e_shnum
; i
++)
788 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
789 if (hdr2
->sh_link
== shindex
)
791 if (! bfd_section_from_shdr (abfd
, i
))
793 if (elf_onesymtab (abfd
) == i
)
795 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
796 elf_elfsections (abfd
)[shindex
] =
797 &elf_tdata (abfd
)->strtab_hdr
;
800 if (elf_dynsymtab (abfd
) == i
)
802 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
803 elf_elfsections (abfd
)[shindex
] = hdr
=
804 &elf_tdata (abfd
)->dynstrtab_hdr
;
805 /* We also treat this as a regular section, so
806 that objcopy can handle it. */
809 #if 0 /* Not handling other string tables specially right now. */
810 hdr2
= elf_elfsections (abfd
)[i
]; /* in case it moved */
811 /* We have a strtab for some random other section. */
812 newsect
= (asection
*) hdr2
->bfd_section
;
815 hdr
->bfd_section
= newsect
;
816 hdr2
= &elf_section_data (newsect
)->str_hdr
;
818 elf_elfsections (abfd
)[shindex
] = hdr2
;
824 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
828 /* *These* do a lot of work -- but build no sections! */
830 asection
*target_sect
;
831 Elf_Internal_Shdr
*hdr2
;
833 /* For some incomprehensible reason Oracle distributes
834 libraries for Solaris in which some of the objects have
835 bogus sh_link fields. It would be nice if we could just
836 reject them, but, unfortunately, some people need to use
837 them. We scan through the section headers; if we find only
838 one suitable symbol table, we clobber the sh_link to point
839 to it. I hope this doesn't break anything. */
840 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_SYMTAB
841 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_DYNSYM
)
847 for (scan
= 1; scan
< ehdr
->e_shnum
; scan
++)
849 if (elf_elfsections (abfd
)[scan
]->sh_type
== SHT_SYMTAB
850 || elf_elfsections (abfd
)[scan
]->sh_type
== SHT_DYNSYM
)
861 hdr
->sh_link
= found
;
864 /* Get the symbol table. */
865 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_SYMTAB
866 && ! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
869 /* If this reloc section does not use the main symbol table we
870 don't treat it as a reloc section. BFD can't adequately
871 represent such a section, so at least for now, we don't
872 try. We just present it as a normal section. */
873 if (hdr
->sh_link
!= elf_onesymtab (abfd
))
874 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
876 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
878 target_sect
= bfd_section_from_elf_index (abfd
, hdr
->sh_info
);
879 if (target_sect
== NULL
)
882 if ((target_sect
->flags
& SEC_RELOC
) == 0
883 || target_sect
->reloc_count
== 0)
884 hdr2
= &elf_section_data (target_sect
)->rel_hdr
;
887 BFD_ASSERT (elf_section_data (target_sect
)->rel_hdr2
== NULL
);
888 hdr2
= (Elf_Internal_Shdr
*) bfd_alloc (abfd
, sizeof (*hdr2
));
889 elf_section_data (target_sect
)->rel_hdr2
= hdr2
;
892 elf_elfsections (abfd
)[shindex
] = hdr2
;
893 target_sect
->reloc_count
+= hdr
->sh_size
/ hdr
->sh_entsize
;
894 target_sect
->flags
|= SEC_RELOC
;
895 target_sect
->relocation
= NULL
;
896 target_sect
->rel_filepos
= hdr
->sh_offset
;
897 abfd
->flags
|= HAS_RELOC
;
906 /* Check for any processor-specific section types. */
908 if (bed
->elf_backend_section_from_shdr
)
909 (*bed
->elf_backend_section_from_shdr
) (abfd
, hdr
, name
);
917 /* Given an ELF section number, retrieve the corresponding BFD
921 bfd_section_from_elf_index (abfd
, index
)
925 BFD_ASSERT (index
> 0 && index
< SHN_LORESERVE
);
926 if (index
>= elf_elfheader (abfd
)->e_shnum
)
928 return elf_elfsections (abfd
)[index
]->bfd_section
;
932 _bfd_elf_new_section_hook (abfd
, sec
)
936 struct bfd_elf_section_data
*sdata
;
938 sdata
= (struct bfd_elf_section_data
*) bfd_alloc (abfd
, sizeof (*sdata
));
941 sec
->used_by_bfd
= (PTR
) sdata
;
942 memset (sdata
, 0, sizeof (*sdata
));
946 /* Create a new bfd section from an ELF program header.
948 Since program segments have no names, we generate a synthetic name
949 of the form segment<NUM>, where NUM is generally the index in the
950 program header table. For segments that are split (see below) we
951 generate the names segment<NUM>a and segment<NUM>b.
953 Note that some program segments may have a file size that is different than
954 (less than) the memory size. All this means is that at execution the
955 system must allocate the amount of memory specified by the memory size,
956 but only initialize it with the first "file size" bytes read from the
957 file. This would occur for example, with program segments consisting
958 of combined data+bss.
960 To handle the above situation, this routine generates TWO bfd sections
961 for the single program segment. The first has the length specified by
962 the file size of the segment, and the second has the length specified
963 by the difference between the two sizes. In effect, the segment is split
964 into it's initialized and uninitialized parts.
969 bfd_section_from_phdr (abfd
, hdr
, index
)
971 Elf_Internal_Phdr
*hdr
;
979 split
= ((hdr
->p_memsz
> 0) &&
980 (hdr
->p_filesz
> 0) &&
981 (hdr
->p_memsz
> hdr
->p_filesz
));
982 sprintf (namebuf
, split
? "segment%da" : "segment%d", index
);
983 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
986 strcpy (name
, namebuf
);
987 newsect
= bfd_make_section (abfd
, name
);
990 newsect
->vma
= hdr
->p_vaddr
;
991 newsect
->lma
= hdr
->p_paddr
;
992 newsect
->_raw_size
= hdr
->p_filesz
;
993 newsect
->filepos
= hdr
->p_offset
;
994 newsect
->flags
|= SEC_HAS_CONTENTS
;
995 if (hdr
->p_type
== PT_LOAD
)
997 newsect
->flags
|= SEC_ALLOC
;
998 newsect
->flags
|= SEC_LOAD
;
999 if (hdr
->p_flags
& PF_X
)
1001 /* FIXME: all we known is that it has execute PERMISSION,
1003 newsect
->flags
|= SEC_CODE
;
1006 if (!(hdr
->p_flags
& PF_W
))
1008 newsect
->flags
|= SEC_READONLY
;
1013 sprintf (namebuf
, "segment%db", index
);
1014 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
1017 strcpy (name
, namebuf
);
1018 newsect
= bfd_make_section (abfd
, name
);
1019 if (newsect
== NULL
)
1021 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
1022 newsect
->lma
= hdr
->p_paddr
+ hdr
->p_filesz
;
1023 newsect
->_raw_size
= hdr
->p_memsz
- hdr
->p_filesz
;
1024 if (hdr
->p_type
== PT_LOAD
)
1026 newsect
->flags
|= SEC_ALLOC
;
1027 if (hdr
->p_flags
& PF_X
)
1028 newsect
->flags
|= SEC_CODE
;
1030 if (!(hdr
->p_flags
& PF_W
))
1031 newsect
->flags
|= SEC_READONLY
;
1037 /* Set up an ELF internal section header for a section. */
1041 elf_fake_sections (abfd
, asect
, failedptrarg
)
1046 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1047 boolean
*failedptr
= (boolean
*) failedptrarg
;
1048 Elf_Internal_Shdr
*this_hdr
;
1052 /* We already failed; just get out of the bfd_map_over_sections
1057 this_hdr
= &elf_section_data (asect
)->this_hdr
;
1059 this_hdr
->sh_name
= (unsigned long) _bfd_stringtab_add (elf_shstrtab (abfd
),
1062 if (this_hdr
->sh_name
== (unsigned long) -1)
1068 this_hdr
->sh_flags
= 0;
1070 if ((asect
->flags
& SEC_ALLOC
) != 0
1071 || asect
->user_set_vma
)
1072 this_hdr
->sh_addr
= asect
->vma
;
1074 this_hdr
->sh_addr
= 0;
1076 this_hdr
->sh_offset
= 0;
1077 this_hdr
->sh_size
= asect
->_raw_size
;
1078 this_hdr
->sh_link
= 0;
1079 this_hdr
->sh_addralign
= 1 << asect
->alignment_power
;
1080 /* The sh_entsize and sh_info fields may have been set already by
1081 copy_private_section_data. */
1083 this_hdr
->bfd_section
= asect
;
1084 this_hdr
->contents
= NULL
;
1086 /* FIXME: This should not be based on section names. */
1087 if (strcmp (asect
->name
, ".dynstr") == 0)
1088 this_hdr
->sh_type
= SHT_STRTAB
;
1089 else if (strcmp (asect
->name
, ".hash") == 0)
1091 this_hdr
->sh_type
= SHT_HASH
;
1092 this_hdr
->sh_entsize
= bed
->s
->arch_size
/ 8;
1094 else if (strcmp (asect
->name
, ".dynsym") == 0)
1096 this_hdr
->sh_type
= SHT_DYNSYM
;
1097 this_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
1099 else if (strcmp (asect
->name
, ".dynamic") == 0)
1101 this_hdr
->sh_type
= SHT_DYNAMIC
;
1102 this_hdr
->sh_entsize
= bed
->s
->sizeof_dyn
;
1104 else if (strncmp (asect
->name
, ".rela", 5) == 0
1105 && get_elf_backend_data (abfd
)->use_rela_p
)
1107 this_hdr
->sh_type
= SHT_RELA
;
1108 this_hdr
->sh_entsize
= bed
->s
->sizeof_rela
;
1110 else if (strncmp (asect
->name
, ".rel", 4) == 0
1111 && ! get_elf_backend_data (abfd
)->use_rela_p
)
1113 this_hdr
->sh_type
= SHT_REL
;
1114 this_hdr
->sh_entsize
= bed
->s
->sizeof_rel
;
1116 else if (strcmp (asect
->name
, ".note") == 0)
1117 this_hdr
->sh_type
= SHT_NOTE
;
1118 else if (strncmp (asect
->name
, ".stab", 5) == 0
1119 && strcmp (asect
->name
+ strlen (asect
->name
) - 3, "str") == 0)
1120 this_hdr
->sh_type
= SHT_STRTAB
;
1121 else if ((asect
->flags
& SEC_ALLOC
) != 0
1122 && (asect
->flags
& SEC_LOAD
) != 0)
1123 this_hdr
->sh_type
= SHT_PROGBITS
;
1124 else if ((asect
->flags
& SEC_ALLOC
) != 0
1125 && ((asect
->flags
& SEC_LOAD
) == 0))
1126 this_hdr
->sh_type
= SHT_NOBITS
;
1130 this_hdr
->sh_type
= SHT_PROGBITS
;
1133 if ((asect
->flags
& SEC_ALLOC
) != 0)
1134 this_hdr
->sh_flags
|= SHF_ALLOC
;
1135 if ((asect
->flags
& SEC_READONLY
) == 0)
1136 this_hdr
->sh_flags
|= SHF_WRITE
;
1137 if ((asect
->flags
& SEC_CODE
) != 0)
1138 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
1140 /* Check for processor-specific section types. */
1142 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1144 if (bed
->elf_backend_fake_sections
)
1145 (*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
);
1148 /* If the section has relocs, set up a section header for the
1149 SHT_REL[A] section. */
1150 if ((asect
->flags
& SEC_RELOC
) != 0)
1152 Elf_Internal_Shdr
*rela_hdr
;
1153 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1156 rela_hdr
= &elf_section_data (asect
)->rel_hdr
;
1157 name
= bfd_alloc (abfd
, sizeof ".rela" + strlen (asect
->name
));
1163 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", asect
->name
);
1165 (unsigned int) _bfd_stringtab_add (elf_shstrtab (abfd
), name
,
1167 if (rela_hdr
->sh_name
== (unsigned int) -1)
1172 rela_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
1173 rela_hdr
->sh_entsize
= (use_rela_p
1174 ? bed
->s
->sizeof_rela
1175 : bed
->s
->sizeof_rel
);
1176 rela_hdr
->sh_addralign
= bed
->s
->file_align
;
1177 rela_hdr
->sh_flags
= 0;
1178 rela_hdr
->sh_addr
= 0;
1179 rela_hdr
->sh_size
= 0;
1180 rela_hdr
->sh_offset
= 0;
1184 /* Assign all ELF section numbers. The dummy first section is handled here
1185 too. The link/info pointers for the standard section types are filled
1186 in here too, while we're at it. */
1189 assign_section_numbers (abfd
)
1192 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
1194 unsigned int section_number
;
1195 Elf_Internal_Shdr
**i_shdrp
;
1196 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1200 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1202 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1204 d
->this_idx
= section_number
++;
1205 if ((sec
->flags
& SEC_RELOC
) == 0)
1208 d
->rel_idx
= section_number
++;
1211 t
->shstrtab_section
= section_number
++;
1212 elf_elfheader (abfd
)->e_shstrndx
= t
->shstrtab_section
;
1213 t
->shstrtab_hdr
.sh_size
= _bfd_stringtab_size (elf_shstrtab (abfd
));
1215 if (abfd
->symcount
> 0)
1217 t
->symtab_section
= section_number
++;
1218 t
->strtab_section
= section_number
++;
1221 elf_elfheader (abfd
)->e_shnum
= section_number
;
1223 /* Set up the list of section header pointers, in agreement with the
1225 i_shdrp
= ((Elf_Internal_Shdr
**)
1226 bfd_alloc (abfd
, section_number
* sizeof (Elf_Internal_Shdr
*)));
1227 if (i_shdrp
== NULL
)
1230 i_shdrp
[0] = ((Elf_Internal_Shdr
*)
1231 bfd_alloc (abfd
, sizeof (Elf_Internal_Shdr
)));
1232 if (i_shdrp
[0] == NULL
)
1234 bfd_release (abfd
, i_shdrp
);
1237 memset (i_shdrp
[0], 0, sizeof (Elf_Internal_Shdr
));
1239 elf_elfsections (abfd
) = i_shdrp
;
1241 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
1242 if (abfd
->symcount
> 0)
1244 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
1245 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
1246 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
1248 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1250 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1254 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
1255 if (d
->rel_idx
!= 0)
1256 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
1258 /* Fill in the sh_link and sh_info fields while we're at it. */
1260 /* sh_link of a reloc section is the section index of the symbol
1261 table. sh_info is the section index of the section to which
1262 the relocation entries apply. */
1263 if (d
->rel_idx
!= 0)
1265 d
->rel_hdr
.sh_link
= t
->symtab_section
;
1266 d
->rel_hdr
.sh_info
= d
->this_idx
;
1269 switch (d
->this_hdr
.sh_type
)
1273 /* A reloc section which we are treating as a normal BFD
1274 section. sh_link is the section index of the symbol
1275 table. sh_info is the section index of the section to
1276 which the relocation entries apply. We assume that an
1277 allocated reloc section uses the dynamic symbol table.
1278 FIXME: How can we be sure? */
1279 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1281 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1283 /* We look up the section the relocs apply to by name. */
1285 if (d
->this_hdr
.sh_type
== SHT_REL
)
1289 s
= bfd_get_section_by_name (abfd
, name
);
1291 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
1295 /* We assume that a section named .stab*str is a stabs
1296 string section. We look for a section with the same name
1297 but without the trailing ``str'', and set its sh_link
1298 field to point to this section. */
1299 if (strncmp (sec
->name
, ".stab", sizeof ".stab" - 1) == 0
1300 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
1305 len
= strlen (sec
->name
);
1306 alc
= (char *) bfd_malloc (len
- 2);
1309 strncpy (alc
, sec
->name
, len
- 3);
1310 alc
[len
- 3] = '\0';
1311 s
= bfd_get_section_by_name (abfd
, alc
);
1315 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
1317 /* This is a .stab section. */
1318 elf_section_data (s
)->this_hdr
.sh_entsize
=
1319 4 + 2 * (bed
->s
->arch_size
/ 8);
1326 /* sh_link is the section header index of the string table
1327 used for the dynamic entries or symbol table. */
1328 s
= bfd_get_section_by_name (abfd
, ".dynstr");
1330 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1334 /* sh_link is the section header index of the symbol table
1335 this hash table is for. */
1336 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1338 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1346 /* Map symbol from it's internal number to the external number, moving
1347 all local symbols to be at the head of the list. */
1350 sym_is_global (abfd
, sym
)
1354 /* If the backend has a special mapping, use it. */
1355 if (get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1356 return ((*get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1359 return ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
1360 || bfd_is_und_section (bfd_get_section (sym
))
1361 || bfd_is_com_section (bfd_get_section (sym
)));
1365 elf_map_symbols (abfd
)
1368 int symcount
= bfd_get_symcount (abfd
);
1369 asymbol
**syms
= bfd_get_outsymbols (abfd
);
1370 asymbol
**sect_syms
;
1372 int num_globals
= 0;
1373 int num_locals2
= 0;
1374 int num_globals2
= 0;
1376 int num_sections
= 0;
1382 fprintf (stderr
, "elf_map_symbols\n");
1386 /* Add a section symbol for each BFD section. FIXME: Is this really
1388 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1390 if (max_index
< asect
->index
)
1391 max_index
= asect
->index
;
1395 sect_syms
= (asymbol
**) bfd_zalloc (abfd
, max_index
* sizeof (asymbol
*));
1396 if (sect_syms
== NULL
)
1398 elf_section_syms (abfd
) = sect_syms
;
1400 for (idx
= 0; idx
< symcount
; idx
++)
1402 if ((syms
[idx
]->flags
& BSF_SECTION_SYM
) != 0
1403 && (syms
[idx
]->value
+ syms
[idx
]->section
->vma
) == 0)
1407 sec
= syms
[idx
]->section
;
1408 if (sec
->owner
!= NULL
)
1410 if (sec
->owner
!= abfd
)
1412 if (sec
->output_offset
!= 0)
1414 sec
= sec
->output_section
;
1415 BFD_ASSERT (sec
->owner
== abfd
);
1417 sect_syms
[sec
->index
] = syms
[idx
];
1422 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1426 if (sect_syms
[asect
->index
] != NULL
)
1429 sym
= bfd_make_empty_symbol (abfd
);
1432 sym
->the_bfd
= abfd
;
1433 sym
->name
= asect
->name
;
1435 /* Set the flags to 0 to indicate that this one was newly added. */
1437 sym
->section
= asect
;
1438 sect_syms
[asect
->index
] = sym
;
1442 "creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n",
1443 asect
->name
, (long) asect
->vma
, asect
->index
, (long) asect
);
1447 /* Classify all of the symbols. */
1448 for (idx
= 0; idx
< symcount
; idx
++)
1450 if (!sym_is_global (abfd
, syms
[idx
]))
1455 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1457 if (sect_syms
[asect
->index
] != NULL
1458 && sect_syms
[asect
->index
]->flags
== 0)
1460 sect_syms
[asect
->index
]->flags
= BSF_SECTION_SYM
;
1461 if (!sym_is_global (abfd
, sect_syms
[asect
->index
]))
1465 sect_syms
[asect
->index
]->flags
= 0;
1469 /* Now sort the symbols so the local symbols are first. */
1470 new_syms
= ((asymbol
**)
1472 (num_locals
+ num_globals
) * sizeof (asymbol
*)));
1473 if (new_syms
== NULL
)
1476 for (idx
= 0; idx
< symcount
; idx
++)
1478 asymbol
*sym
= syms
[idx
];
1481 if (!sym_is_global (abfd
, sym
))
1484 i
= num_locals
+ num_globals2
++;
1486 sym
->udata
.i
= i
+ 1;
1488 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1490 if (sect_syms
[asect
->index
] != NULL
1491 && sect_syms
[asect
->index
]->flags
== 0)
1493 asymbol
*sym
= sect_syms
[asect
->index
];
1496 sym
->flags
= BSF_SECTION_SYM
;
1497 if (!sym_is_global (abfd
, sym
))
1500 i
= num_locals
+ num_globals2
++;
1502 sym
->udata
.i
= i
+ 1;
1506 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
1508 elf_num_locals (abfd
) = num_locals
;
1509 elf_num_globals (abfd
) = num_globals
;
1513 /* Align to the maximum file alignment that could be required for any
1514 ELF data structure. */
1516 static INLINE file_ptr align_file_position
PARAMS ((file_ptr
, int));
1517 static INLINE file_ptr
1518 align_file_position (off
, align
)
1522 return (off
+ align
- 1) & ~(align
- 1);
1525 /* Assign a file position to a section, optionally aligning to the
1526 required section alignment. */
1529 _bfd_elf_assign_file_position_for_section (i_shdrp
, offset
, align
)
1530 Elf_Internal_Shdr
*i_shdrp
;
1538 al
= i_shdrp
->sh_addralign
;
1540 offset
= BFD_ALIGN (offset
, al
);
1542 i_shdrp
->sh_offset
= offset
;
1543 if (i_shdrp
->bfd_section
!= NULL
)
1544 i_shdrp
->bfd_section
->filepos
= offset
;
1545 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
1546 offset
+= i_shdrp
->sh_size
;
1550 /* Compute the file positions we are going to put the sections at, and
1551 otherwise prepare to begin writing out the ELF file. If LINK_INFO
1552 is not NULL, this is being called by the ELF backend linker. */
1555 _bfd_elf_compute_section_file_positions (abfd
, link_info
)
1557 struct bfd_link_info
*link_info
;
1559 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1561 struct bfd_strtab_hash
*strtab
;
1562 Elf_Internal_Shdr
*shstrtab_hdr
;
1564 if (abfd
->output_has_begun
)
1567 /* Do any elf backend specific processing first. */
1568 if (bed
->elf_backend_begin_write_processing
)
1569 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
1571 if (! prep_headers (abfd
))
1575 bfd_map_over_sections (abfd
, elf_fake_sections
, &failed
);
1579 if (!assign_section_numbers (abfd
))
1582 /* The backend linker builds symbol table information itself. */
1583 if (link_info
== NULL
&& abfd
->symcount
> 0)
1585 if (! swap_out_syms (abfd
, &strtab
))
1589 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
1590 /* sh_name was set in prep_headers. */
1591 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
1592 shstrtab_hdr
->sh_flags
= 0;
1593 shstrtab_hdr
->sh_addr
= 0;
1594 shstrtab_hdr
->sh_size
= _bfd_stringtab_size (elf_shstrtab (abfd
));
1595 shstrtab_hdr
->sh_entsize
= 0;
1596 shstrtab_hdr
->sh_link
= 0;
1597 shstrtab_hdr
->sh_info
= 0;
1598 /* sh_offset is set in assign_file_positions_except_relocs. */
1599 shstrtab_hdr
->sh_addralign
= 1;
1601 if (!assign_file_positions_except_relocs (abfd
))
1604 if (link_info
== NULL
&& abfd
->symcount
> 0)
1607 Elf_Internal_Shdr
*hdr
;
1609 off
= elf_tdata (abfd
)->next_file_pos
;
1611 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1612 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
1614 hdr
= &elf_tdata (abfd
)->strtab_hdr
;
1615 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
1617 elf_tdata (abfd
)->next_file_pos
= off
;
1619 /* Now that we know where the .strtab section goes, write it
1621 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
1622 || ! _bfd_stringtab_emit (abfd
, strtab
))
1624 _bfd_stringtab_free (strtab
);
1627 abfd
->output_has_begun
= true;
1632 /* Create a mapping from a set of sections to a program segment. */
1634 static INLINE
struct elf_segment_map
*
1635 make_mapping (abfd
, sections
, from
, to
, phdr
)
1637 asection
**sections
;
1642 struct elf_segment_map
*m
;
1646 m
= ((struct elf_segment_map
*)
1648 (sizeof (struct elf_segment_map
)
1649 + (to
- from
- 1) * sizeof (asection
*))));
1653 m
->p_type
= PT_LOAD
;
1654 for (i
= from
, hdrpp
= sections
+ from
; i
< to
; i
++, hdrpp
++)
1655 m
->sections
[i
- from
] = *hdrpp
;
1656 m
->count
= to
- from
;
1658 if (from
== 0 && phdr
)
1660 /* Include the headers in the first PT_LOAD segment. */
1661 m
->includes_filehdr
= 1;
1662 m
->includes_phdrs
= 1;
1668 /* Set up a mapping from BFD sections to program segments. */
1671 map_sections_to_segments (abfd
)
1674 asection
**sections
= NULL
;
1678 struct elf_segment_map
*mfirst
;
1679 struct elf_segment_map
**pm
;
1680 struct elf_segment_map
*m
;
1682 unsigned int phdr_index
;
1683 bfd_vma maxpagesize
;
1685 boolean phdr_in_section
= true;
1689 if (elf_tdata (abfd
)->segment_map
!= NULL
)
1692 if (bfd_count_sections (abfd
) == 0)
1695 /* Select the allocated sections, and sort them. */
1697 sections
= (asection
**) bfd_malloc (bfd_count_sections (abfd
)
1698 * sizeof (asection
*));
1699 if (sections
== NULL
)
1703 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
1705 if ((s
->flags
& SEC_ALLOC
) != 0)
1711 BFD_ASSERT (i
<= bfd_count_sections (abfd
));
1714 qsort (sections
, (size_t) count
, sizeof (asection
*), elf_sort_sections
);
1716 /* Build the mapping. */
1721 /* If we have a .interp section, then create a PT_PHDR segment for
1722 the program headers and a PT_INTERP segment for the .interp
1724 s
= bfd_get_section_by_name (abfd
, ".interp");
1725 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
1727 m
= ((struct elf_segment_map
*)
1728 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
1732 m
->p_type
= PT_PHDR
;
1733 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
1734 m
->p_flags
= PF_R
| PF_X
;
1735 m
->p_flags_valid
= 1;
1736 m
->includes_phdrs
= 1;
1741 m
= ((struct elf_segment_map
*)
1742 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
1746 m
->p_type
= PT_INTERP
;
1754 /* Look through the sections. We put sections in the same program
1755 segment when the start of the second section can be placed within
1756 a few bytes of the end of the first section. */
1759 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
1761 dynsec
= bfd_get_section_by_name (abfd
, ".dynamic");
1763 && (dynsec
->flags
& SEC_LOAD
) == 0)
1766 /* Deal with -Ttext or something similar such that the first section
1767 is not adjacent to the program headers. This is an
1768 approximation, since at this point we don't know exactly how many
1769 program headers we will need. */
1772 bfd_size_type phdr_size
;
1774 phdr_size
= elf_tdata (abfd
)->program_header_size
;
1776 phdr_size
= get_elf_backend_data (abfd
)->s
->sizeof_phdr
;
1777 if ((abfd
->flags
& D_PAGED
) == 0
1778 || sections
[0]->lma
% maxpagesize
< phdr_size
% maxpagesize
)
1779 phdr_in_section
= false;
1782 for (i
= 0, hdrpp
= sections
; i
< count
; i
++, hdrpp
++)
1785 boolean new_segment
;
1789 /* See if this section and the last one will fit in the same
1792 if (last_hdr
== NULL
)
1794 /* If we don't have a segment yet, then we don't need a new
1795 one (we build the last one after this loop). */
1796 new_segment
= false;
1798 else if (last_hdr
->lma
- last_hdr
->vma
!= hdr
->lma
- hdr
->vma
)
1800 /* If this section has a different relation between the
1801 virtual address and the load address, then we need a new
1805 else if (BFD_ALIGN (last_hdr
->lma
+ last_hdr
->_raw_size
, maxpagesize
)
1808 /* If putting this section in this segment would force us to
1809 skip a page in the segment, then we need a new segment. */
1812 else if ((abfd
->flags
& D_PAGED
) == 0)
1814 /* If the file is not demand paged, which means that we
1815 don't require the sections to be correctly aligned in the
1816 file, then there is no other reason for a new segment. */
1817 new_segment
= false;
1819 else if ((last_hdr
->flags
& SEC_LOAD
) == 0
1820 && (hdr
->flags
& SEC_LOAD
) != 0)
1822 /* We don't want to put a loadable section after a
1823 nonloadable section in the same segment. */
1827 && (hdr
->flags
& SEC_READONLY
) == 0
1828 && (BFD_ALIGN (last_hdr
->lma
+ last_hdr
->_raw_size
, maxpagesize
)
1831 /* We don't want to put a writable section in a read only
1832 segment, unless they are on the same page in memory
1833 anyhow. We already know that the last section does not
1834 bring us past the current section on the page, so the
1835 only case in which the new section is not on the same
1836 page as the previous section is when the previous section
1837 ends precisely on a page boundary. */
1842 /* Otherwise, we can use the same segment. */
1843 new_segment
= false;
1848 if ((hdr
->flags
& SEC_READONLY
) == 0)
1854 /* We need a new program segment. We must create a new program
1855 header holding all the sections from phdr_index until hdr. */
1857 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_section
);
1864 if ((hdr
->flags
& SEC_READONLY
) == 0)
1871 phdr_in_section
= false;
1874 /* Create a final PT_LOAD program segment. */
1875 if (last_hdr
!= NULL
)
1877 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_section
);
1885 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
1888 m
= ((struct elf_segment_map
*)
1889 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
1893 m
->p_type
= PT_DYNAMIC
;
1895 m
->sections
[0] = dynsec
;
1904 elf_tdata (abfd
)->segment_map
= mfirst
;
1908 if (sections
!= NULL
)
1913 /* Sort sections by VMA. */
1916 elf_sort_sections (arg1
, arg2
)
1920 const asection
*sec1
= *(const asection
**) arg1
;
1921 const asection
*sec2
= *(const asection
**) arg2
;
1923 if (sec1
->vma
< sec2
->vma
)
1925 else if (sec1
->vma
> sec2
->vma
)
1928 /* Sort by LMA. Normally the LMA and the VMA will be the same, and
1929 this will do nothing. */
1930 if (sec1
->lma
< sec2
->lma
)
1932 else if (sec1
->lma
> sec2
->lma
)
1935 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
1937 #define TOEND(x) (((x)->flags & SEC_LOAD) == 0)
1941 return sec1
->target_index
- sec2
->target_index
;
1950 /* Sort by size, to put zero sized sections before others at the
1953 if (sec1
->_raw_size
< sec2
->_raw_size
)
1955 if (sec1
->_raw_size
> sec2
->_raw_size
)
1958 return sec1
->target_index
- sec2
->target_index
;
1961 /* Assign file positions to the sections based on the mapping from
1962 sections to segments. This function also sets up some fields in
1963 the file header, and writes out the program headers. */
1966 assign_file_positions_for_segments (abfd
)
1969 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1971 struct elf_segment_map
*m
;
1973 Elf_Internal_Phdr
*phdrs
;
1975 bfd_vma filehdr_vaddr
, filehdr_paddr
;
1976 bfd_vma phdrs_vaddr
, phdrs_paddr
;
1977 Elf_Internal_Phdr
*p
;
1979 if (elf_tdata (abfd
)->segment_map
== NULL
)
1981 if (! map_sections_to_segments (abfd
))
1985 if (bed
->elf_backend_modify_segment_map
)
1987 if (! (*bed
->elf_backend_modify_segment_map
) (abfd
))
1992 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
1995 elf_elfheader (abfd
)->e_phoff
= bed
->s
->sizeof_ehdr
;
1996 elf_elfheader (abfd
)->e_phentsize
= bed
->s
->sizeof_phdr
;
1997 elf_elfheader (abfd
)->e_phnum
= count
;
2002 /* If we already counted the number of program segments, make sure
2003 that we allocated enough space. This happens when SIZEOF_HEADERS
2004 is used in a linker script. */
2005 alloc
= elf_tdata (abfd
)->program_header_size
/ bed
->s
->sizeof_phdr
;
2006 if (alloc
!= 0 && count
> alloc
)
2008 ((*_bfd_error_handler
)
2009 ("%s: Not enough room for program headers (allocated %u, need %u)",
2010 bfd_get_filename (abfd
), alloc
, count
));
2011 bfd_set_error (bfd_error_bad_value
);
2018 phdrs
= ((Elf_Internal_Phdr
*)
2019 bfd_alloc (abfd
, alloc
* sizeof (Elf_Internal_Phdr
)));
2023 off
= bed
->s
->sizeof_ehdr
;
2024 off
+= alloc
* bed
->s
->sizeof_phdr
;
2030 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
2037 /* If elf_segment_map is not from map_sections_to_segments, the
2038 sections may not be correctly ordered. */
2040 qsort (m
->sections
, (size_t) m
->count
, sizeof (asection
*),
2043 p
->p_type
= m
->p_type
;
2045 if (m
->p_flags_valid
)
2046 p
->p_flags
= m
->p_flags
;
2050 if (p
->p_type
== PT_LOAD
2052 && (m
->sections
[0]->flags
& SEC_ALLOC
) != 0)
2054 if ((abfd
->flags
& D_PAGED
) != 0)
2055 off
+= (m
->sections
[0]->vma
- off
) % bed
->maxpagesize
;
2057 off
+= ((m
->sections
[0]->vma
- off
)
2058 % (1 << bfd_get_section_alignment (abfd
, m
->sections
[0])));
2064 p
->p_vaddr
= m
->sections
[0]->vma
;
2066 if (m
->p_paddr_valid
)
2067 p
->p_paddr
= m
->p_paddr
;
2068 else if (m
->count
== 0)
2071 p
->p_paddr
= m
->sections
[0]->lma
;
2073 if (p
->p_type
== PT_LOAD
2074 && (abfd
->flags
& D_PAGED
) != 0)
2075 p
->p_align
= bed
->maxpagesize
;
2076 else if (m
->count
== 0)
2077 p
->p_align
= bed
->s
->file_align
;
2085 if (m
->includes_filehdr
)
2087 if (! m
->p_flags_valid
)
2090 p
->p_filesz
= bed
->s
->sizeof_ehdr
;
2091 p
->p_memsz
= bed
->s
->sizeof_ehdr
;
2094 BFD_ASSERT (p
->p_type
== PT_LOAD
);
2096 if (! m
->p_paddr_valid
)
2099 if (p
->p_type
== PT_LOAD
)
2101 filehdr_vaddr
= p
->p_vaddr
;
2102 filehdr_paddr
= p
->p_paddr
;
2106 if (m
->includes_phdrs
)
2108 if (! m
->p_flags_valid
)
2110 if (m
->includes_filehdr
)
2112 if (p
->p_type
== PT_LOAD
)
2114 phdrs_vaddr
= p
->p_vaddr
+ bed
->s
->sizeof_ehdr
;
2115 phdrs_paddr
= p
->p_paddr
+ bed
->s
->sizeof_ehdr
;
2120 p
->p_offset
= bed
->s
->sizeof_ehdr
;
2123 BFD_ASSERT (p
->p_type
== PT_LOAD
);
2124 p
->p_vaddr
-= off
- p
->p_offset
;
2125 if (! m
->p_paddr_valid
)
2126 p
->p_paddr
-= off
- p
->p_offset
;
2128 if (p
->p_type
== PT_LOAD
)
2130 phdrs_vaddr
= p
->p_vaddr
;
2131 phdrs_paddr
= p
->p_paddr
;
2134 p
->p_filesz
+= alloc
* bed
->s
->sizeof_phdr
;
2135 p
->p_memsz
+= alloc
* bed
->s
->sizeof_phdr
;
2138 if (p
->p_type
== PT_LOAD
)
2140 if (! m
->includes_filehdr
&& ! m
->includes_phdrs
)
2146 adjust
= off
- (p
->p_offset
+ p
->p_filesz
);
2147 p
->p_filesz
+= adjust
;
2148 p
->p_memsz
+= adjust
;
2153 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
2157 bfd_size_type align
;
2161 align
= 1 << bfd_get_section_alignment (abfd
, sec
);
2163 if (p
->p_type
== PT_LOAD
)
2167 /* The section VMA must equal the file position modulo
2169 if ((flags
& SEC_ALLOC
) != 0)
2171 if ((abfd
->flags
& D_PAGED
) != 0)
2172 adjust
= (sec
->vma
- voff
) % bed
->maxpagesize
;
2174 adjust
= (sec
->vma
- voff
) % align
;
2179 p
->p_memsz
+= adjust
;
2182 if ((flags
& SEC_LOAD
) != 0)
2183 p
->p_filesz
+= adjust
;
2189 if ((flags
& SEC_LOAD
) != 0)
2190 off
+= sec
->_raw_size
;
2191 if ((flags
& SEC_ALLOC
) != 0)
2192 voff
+= sec
->_raw_size
;
2195 p
->p_memsz
+= sec
->_raw_size
;
2197 if ((flags
& SEC_LOAD
) != 0)
2198 p
->p_filesz
+= sec
->_raw_size
;
2200 if (align
> p
->p_align
)
2203 if (! m
->p_flags_valid
)
2206 if ((flags
& SEC_CODE
) != 0)
2208 if ((flags
& SEC_READONLY
) == 0)
2214 /* Now that we have set the section file positions, we can set up
2215 the file positions for the non PT_LOAD segments. */
2216 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
2220 if (p
->p_type
!= PT_LOAD
&& m
->count
> 0)
2222 BFD_ASSERT (! m
->includes_filehdr
&& ! m
->includes_phdrs
);
2223 p
->p_offset
= m
->sections
[0]->filepos
;
2227 if (m
->includes_filehdr
)
2229 p
->p_vaddr
= filehdr_vaddr
;
2230 if (! m
->p_paddr_valid
)
2231 p
->p_paddr
= filehdr_paddr
;
2233 else if (m
->includes_phdrs
)
2235 p
->p_vaddr
= phdrs_vaddr
;
2236 if (! m
->p_paddr_valid
)
2237 p
->p_paddr
= phdrs_paddr
;
2242 /* Clear out any program headers we allocated but did not use. */
2243 for (; count
< alloc
; count
++, p
++)
2245 memset (p
, 0, sizeof *p
);
2246 p
->p_type
= PT_NULL
;
2249 elf_tdata (abfd
)->phdr
= phdrs
;
2251 elf_tdata (abfd
)->next_file_pos
= off
;
2253 /* Write out the program headers. */
2254 if (bfd_seek (abfd
, bed
->s
->sizeof_ehdr
, SEEK_SET
) != 0
2255 || bed
->s
->write_out_phdrs (abfd
, phdrs
, alloc
) != 0)
2261 /* Get the size of the program header.
2263 If this is called by the linker before any of the section VMA's are set, it
2264 can't calculate the correct value for a strange memory layout. This only
2265 happens when SIZEOF_HEADERS is used in a linker script. In this case,
2266 SORTED_HDRS is NULL and we assume the normal scenario of one text and one
2267 data segment (exclusive of .interp and .dynamic).
2269 ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
2270 will be two segments. */
2272 static bfd_size_type
2273 get_program_header_size (abfd
)
2278 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2280 /* We can't return a different result each time we're called. */
2281 if (elf_tdata (abfd
)->program_header_size
!= 0)
2282 return elf_tdata (abfd
)->program_header_size
;
2284 if (elf_tdata (abfd
)->segment_map
!= NULL
)
2286 struct elf_segment_map
*m
;
2289 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
2291 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
2292 return elf_tdata (abfd
)->program_header_size
;
2295 /* Assume we will need exactly two PT_LOAD segments: one for text
2296 and one for data. */
2299 s
= bfd_get_section_by_name (abfd
, ".interp");
2300 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
2302 /* If we have a loadable interpreter section, we need a
2303 PT_INTERP segment. In this case, assume we also need a
2304 PT_PHDR segment, although that may not be true for all
2309 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
2311 /* We need a PT_DYNAMIC segment. */
2315 /* Let the backend count up any program headers it might need. */
2316 if (bed
->elf_backend_additional_program_headers
)
2320 a
= (*bed
->elf_backend_additional_program_headers
) (abfd
);
2326 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
2327 return elf_tdata (abfd
)->program_header_size
;
2330 /* Work out the file positions of all the sections. This is called by
2331 _bfd_elf_compute_section_file_positions. All the section sizes and
2332 VMAs must be known before this is called.
2334 We do not consider reloc sections at this point, unless they form
2335 part of the loadable image. Reloc sections are assigned file
2336 positions in assign_file_positions_for_relocs, which is called by
2337 write_object_contents and final_link.
2339 We also don't set the positions of the .symtab and .strtab here. */
2342 assign_file_positions_except_relocs (abfd
)
2345 struct elf_obj_tdata
* const tdata
= elf_tdata (abfd
);
2346 Elf_Internal_Ehdr
* const i_ehdrp
= elf_elfheader (abfd
);
2347 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
2349 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2351 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
2353 Elf_Internal_Shdr
**hdrpp
;
2356 /* Start after the ELF header. */
2357 off
= i_ehdrp
->e_ehsize
;
2359 /* We are not creating an executable, which means that we are
2360 not creating a program header, and that the actual order of
2361 the sections in the file is unimportant. */
2362 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2364 Elf_Internal_Shdr
*hdr
;
2367 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
2369 hdr
->sh_offset
= -1;
2372 if (i
== tdata
->symtab_section
2373 || i
== tdata
->strtab_section
)
2375 hdr
->sh_offset
= -1;
2379 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
2385 Elf_Internal_Shdr
**hdrpp
;
2387 /* Assign file positions for the loaded sections based on the
2388 assignment of sections to segments. */
2389 if (! assign_file_positions_for_segments (abfd
))
2392 /* Assign file positions for the other sections. */
2394 off
= elf_tdata (abfd
)->next_file_pos
;
2395 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2397 Elf_Internal_Shdr
*hdr
;
2400 if (hdr
->bfd_section
!= NULL
2401 && hdr
->bfd_section
->filepos
!= 0)
2402 hdr
->sh_offset
= hdr
->bfd_section
->filepos
;
2403 else if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
2405 ((*_bfd_error_handler
)
2406 ("%s: warning: allocated section `%s' not in segment",
2407 bfd_get_filename (abfd
),
2408 (hdr
->bfd_section
== NULL
2410 : hdr
->bfd_section
->name
)));
2411 if ((abfd
->flags
& D_PAGED
) != 0)
2412 off
+= (hdr
->sh_addr
- off
) % bed
->maxpagesize
;
2414 off
+= (hdr
->sh_addr
- off
) % hdr
->sh_addralign
;
2415 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
,
2418 else if (hdr
->sh_type
== SHT_REL
2419 || hdr
->sh_type
== SHT_RELA
2420 || hdr
== i_shdrpp
[tdata
->symtab_section
]
2421 || hdr
== i_shdrpp
[tdata
->strtab_section
])
2422 hdr
->sh_offset
= -1;
2424 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
2428 /* Place the section headers. */
2429 off
= align_file_position (off
, bed
->s
->file_align
);
2430 i_ehdrp
->e_shoff
= off
;
2431 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
2433 elf_tdata (abfd
)->next_file_pos
= off
;
2442 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2443 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
2444 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2446 struct bfd_strtab_hash
*shstrtab
;
2447 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2449 i_ehdrp
= elf_elfheader (abfd
);
2450 i_shdrp
= elf_elfsections (abfd
);
2452 shstrtab
= _bfd_elf_stringtab_init ();
2453 if (shstrtab
== NULL
)
2456 elf_shstrtab (abfd
) = shstrtab
;
2458 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
2459 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
2460 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
2461 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
2463 i_ehdrp
->e_ident
[EI_CLASS
] = bed
->s
->elfclass
;
2464 i_ehdrp
->e_ident
[EI_DATA
] =
2465 bfd_big_endian (abfd
) ? ELFDATA2MSB
: ELFDATA2LSB
;
2466 i_ehdrp
->e_ident
[EI_VERSION
] = bed
->s
->ev_current
;
2468 for (count
= EI_PAD
; count
< EI_NIDENT
; count
++)
2469 i_ehdrp
->e_ident
[count
] = 0;
2471 if ((abfd
->flags
& DYNAMIC
) != 0)
2472 i_ehdrp
->e_type
= ET_DYN
;
2473 else if ((abfd
->flags
& EXEC_P
) != 0)
2474 i_ehdrp
->e_type
= ET_EXEC
;
2476 i_ehdrp
->e_type
= ET_REL
;
2478 switch (bfd_get_arch (abfd
))
2480 case bfd_arch_unknown
:
2481 i_ehdrp
->e_machine
= EM_NONE
;
2483 case bfd_arch_sparc
:
2484 if (bed
->s
->arch_size
== 64)
2485 i_ehdrp
->e_machine
= EM_SPARC64
;
2487 i_ehdrp
->e_machine
= EM_SPARC
;
2490 i_ehdrp
->e_machine
= EM_386
;
2493 i_ehdrp
->e_machine
= EM_68K
;
2496 i_ehdrp
->e_machine
= EM_88K
;
2499 i_ehdrp
->e_machine
= EM_860
;
2501 case bfd_arch_mips
: /* MIPS Rxxxx */
2502 i_ehdrp
->e_machine
= EM_MIPS
; /* only MIPS R3000 */
2505 i_ehdrp
->e_machine
= EM_PARISC
;
2507 case bfd_arch_powerpc
:
2508 i_ehdrp
->e_machine
= EM_PPC
;
2510 case bfd_arch_alpha
:
2511 i_ehdrp
->e_machine
= EM_ALPHA
;
2514 i_ehdrp
->e_machine
= EM_SH
;
2516 /* start-sanitize-d10v */
2518 i_ehdrp
->e_machine
= EM_CYGNUS_D10V
;
2520 /* end-sanitize-d10v */
2521 /* start-sanitize-d30v */
2523 i_ehdrp
->e_machine
= EM_CYGNUS_D30V
;
2525 /* end-sanitize-d30v */
2526 /* start-sanitize-v850 */
2528 i_ehdrp
->e_machine
= EM_CYGNUS_V850
;
2530 /* end-sanitize-v850 */
2531 /* start-sanitize-arc */
2533 i_ehdrp
->e_machine
= EM_CYGNUS_ARC
;
2535 /* end-sanitize-arc */
2536 /* start-sanitize-m32r */
2538 i_ehdrp
->e_machine
= EM_CYGNUS_M32R
;
2540 /* end-sanitize-m32r */
2541 case bfd_arch_mn10200
:
2542 i_ehdrp
->e_machine
= EM_CYGNUS_MN10200
;
2544 case bfd_arch_mn10300
:
2545 i_ehdrp
->e_machine
= EM_CYGNUS_MN10300
;
2547 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
2549 i_ehdrp
->e_machine
= EM_NONE
;
2551 i_ehdrp
->e_version
= bed
->s
->ev_current
;
2552 i_ehdrp
->e_ehsize
= bed
->s
->sizeof_ehdr
;
2554 /* no program header, for now. */
2555 i_ehdrp
->e_phoff
= 0;
2556 i_ehdrp
->e_phentsize
= 0;
2557 i_ehdrp
->e_phnum
= 0;
2559 /* each bfd section is section header entry */
2560 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
2561 i_ehdrp
->e_shentsize
= bed
->s
->sizeof_shdr
;
2563 /* if we're building an executable, we'll need a program header table */
2564 if (abfd
->flags
& EXEC_P
)
2566 /* it all happens later */
2568 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
2570 /* elf_build_phdrs() returns a (NULL-terminated) array of
2571 Elf_Internal_Phdrs */
2572 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
2573 i_ehdrp
->e_phoff
= outbase
;
2574 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
2579 i_ehdrp
->e_phentsize
= 0;
2581 i_ehdrp
->e_phoff
= 0;
2584 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
2585 (unsigned int) _bfd_stringtab_add (shstrtab
, ".symtab", true, false);
2586 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
2587 (unsigned int) _bfd_stringtab_add (shstrtab
, ".strtab", true, false);
2588 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
2589 (unsigned int) _bfd_stringtab_add (shstrtab
, ".shstrtab", true, false);
2590 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2591 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2592 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
2598 /* Assign file positions for all the reloc sections which are not part
2599 of the loadable file image. */
2602 _bfd_elf_assign_file_positions_for_relocs (abfd
)
2607 Elf_Internal_Shdr
**shdrpp
;
2609 off
= elf_tdata (abfd
)->next_file_pos
;
2611 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1;
2612 i
< elf_elfheader (abfd
)->e_shnum
;
2615 Elf_Internal_Shdr
*shdrp
;
2618 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
2619 && shdrp
->sh_offset
== -1)
2620 off
= _bfd_elf_assign_file_position_for_section (shdrp
, off
, true);
2623 elf_tdata (abfd
)->next_file_pos
= off
;
2627 _bfd_elf_write_object_contents (abfd
)
2630 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2631 Elf_Internal_Ehdr
*i_ehdrp
;
2632 Elf_Internal_Shdr
**i_shdrp
;
2636 if (! abfd
->output_has_begun
2637 && ! _bfd_elf_compute_section_file_positions (abfd
,
2638 (struct bfd_link_info
*) NULL
))
2641 i_shdrp
= elf_elfsections (abfd
);
2642 i_ehdrp
= elf_elfheader (abfd
);
2645 bfd_map_over_sections (abfd
, bed
->s
->write_relocs
, &failed
);
2648 _bfd_elf_assign_file_positions_for_relocs (abfd
);
2650 /* After writing the headers, we need to write the sections too... */
2651 for (count
= 1; count
< i_ehdrp
->e_shnum
; count
++)
2653 if (bed
->elf_backend_section_processing
)
2654 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
2655 if (i_shdrp
[count
]->contents
)
2657 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
2658 || (bfd_write (i_shdrp
[count
]->contents
, i_shdrp
[count
]->sh_size
,
2660 != i_shdrp
[count
]->sh_size
))
2665 /* Write out the section header names. */
2666 if (bfd_seek (abfd
, elf_tdata (abfd
)->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
2667 || ! _bfd_stringtab_emit (abfd
, elf_shstrtab (abfd
)))
2670 if (bed
->elf_backend_final_write_processing
)
2671 (*bed
->elf_backend_final_write_processing
) (abfd
,
2672 elf_tdata (abfd
)->linker
);
2674 return bed
->s
->write_shdrs_and_ehdr (abfd
);
2677 /* given a section, search the header to find them... */
2679 _bfd_elf_section_from_bfd_section (abfd
, asect
)
2683 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2684 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
2686 Elf_Internal_Shdr
*hdr
;
2687 int maxindex
= elf_elfheader (abfd
)->e_shnum
;
2689 for (index
= 0; index
< maxindex
; index
++)
2691 hdr
= i_shdrp
[index
];
2692 if (hdr
->bfd_section
== asect
)
2696 if (bed
->elf_backend_section_from_bfd_section
)
2698 for (index
= 0; index
< maxindex
; index
++)
2702 hdr
= i_shdrp
[index
];
2704 if ((*bed
->elf_backend_section_from_bfd_section
)
2705 (abfd
, hdr
, asect
, &retval
))
2710 if (bfd_is_abs_section (asect
))
2712 if (bfd_is_com_section (asect
))
2714 if (bfd_is_und_section (asect
))
2720 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
2724 _bfd_elf_symbol_from_bfd_symbol (abfd
, asym_ptr_ptr
)
2726 asymbol
**asym_ptr_ptr
;
2728 asymbol
*asym_ptr
= *asym_ptr_ptr
;
2730 flagword flags
= asym_ptr
->flags
;
2732 /* When gas creates relocations against local labels, it creates its
2733 own symbol for the section, but does put the symbol into the
2734 symbol chain, so udata is 0. When the linker is generating
2735 relocatable output, this section symbol may be for one of the
2736 input sections rather than the output section. */
2737 if (asym_ptr
->udata
.i
== 0
2738 && (flags
& BSF_SECTION_SYM
)
2739 && asym_ptr
->section
)
2743 if (asym_ptr
->section
->output_section
!= NULL
)
2744 indx
= asym_ptr
->section
->output_section
->index
;
2746 indx
= asym_ptr
->section
->index
;
2747 if (elf_section_syms (abfd
)[indx
])
2748 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
2751 idx
= asym_ptr
->udata
.i
;
2755 /* This case can occur when using --strip-symbol on a symbol
2756 which is used in a relocation entry. */
2757 (*_bfd_error_handler
)
2758 ("%s: symbol `%s' required but not present",
2759 bfd_get_filename (abfd
), bfd_asymbol_name (asym_ptr
));
2760 bfd_set_error (bfd_error_no_symbols
);
2767 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
2768 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
,
2769 elf_symbol_flags (flags
));
2777 /* Copy private BFD data. This copies any program header information. */
2780 copy_private_bfd_data (ibfd
, obfd
)
2784 Elf_Internal_Ehdr
*iehdr
;
2785 struct elf_segment_map
*mfirst
;
2786 struct elf_segment_map
**pm
;
2787 Elf_Internal_Phdr
*p
;
2790 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2791 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2794 if (elf_tdata (ibfd
)->phdr
== NULL
)
2797 iehdr
= elf_elfheader (ibfd
);
2802 c
= elf_elfheader (ibfd
)->e_phnum
;
2803 for (i
= 0, p
= elf_tdata (ibfd
)->phdr
; i
< c
; i
++, p
++)
2807 struct elf_segment_map
*m
;
2812 /* The complicated case when p_vaddr is 0 is to handle the
2813 Solaris linker, which generates a PT_INTERP section with
2814 p_vaddr and p_memsz set to 0. */
2815 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2816 if (((s
->vma
>= p
->p_vaddr
2817 && (s
->vma
+ s
->_raw_size
<= p
->p_vaddr
+ p
->p_memsz
2818 || s
->vma
+ s
->_raw_size
<= p
->p_vaddr
+ p
->p_filesz
))
2821 && (s
->flags
& SEC_HAS_CONTENTS
) != 0
2822 && (bfd_vma
) s
->filepos
>= p
->p_offset
2823 && ((bfd_vma
) s
->filepos
+ s
->_raw_size
2824 <= p
->p_offset
+ p
->p_filesz
)))
2825 && (s
->flags
& SEC_ALLOC
) != 0
2826 && s
->output_section
!= NULL
)
2829 m
= ((struct elf_segment_map
*)
2831 (sizeof (struct elf_segment_map
)
2832 + (csecs
- 1) * sizeof (asection
*))));
2837 m
->p_type
= p
->p_type
;
2838 m
->p_flags
= p
->p_flags
;
2839 m
->p_flags_valid
= 1;
2840 m
->p_paddr
= p
->p_paddr
;
2841 m
->p_paddr_valid
= 1;
2843 m
->includes_filehdr
= (p
->p_offset
== 0
2844 && p
->p_filesz
>= iehdr
->e_ehsize
);
2846 m
->includes_phdrs
= (p
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
2847 && (p
->p_offset
+ p
->p_filesz
2848 >= ((bfd_vma
) iehdr
->e_phoff
2849 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
2852 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2854 if (((s
->vma
>= p
->p_vaddr
2855 && (s
->vma
+ s
->_raw_size
<= p
->p_vaddr
+ p
->p_memsz
2856 || s
->vma
+ s
->_raw_size
<= p
->p_vaddr
+ p
->p_filesz
))
2859 && (s
->flags
& SEC_HAS_CONTENTS
) != 0
2860 && (bfd_vma
) s
->filepos
>= p
->p_offset
2861 && ((bfd_vma
) s
->filepos
+ s
->_raw_size
2862 <= p
->p_offset
+ p
->p_filesz
)))
2863 && (s
->flags
& SEC_ALLOC
) != 0
2864 && s
->output_section
!= NULL
)
2866 m
->sections
[isec
] = s
->output_section
;
2870 BFD_ASSERT (isec
== csecs
);
2877 elf_tdata (obfd
)->segment_map
= mfirst
;
2882 /* Copy private section information. This copies over the entsize
2883 field, and sometimes the info field. */
2886 _bfd_elf_copy_private_section_data (ibfd
, isec
, obfd
, osec
)
2892 Elf_Internal_Shdr
*ihdr
, *ohdr
;
2894 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
2895 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
2898 /* Copy over private BFD data if it has not already been copied.
2899 This must be done here, rather than in the copy_private_bfd_data
2900 entry point, because the latter is called after the section
2901 contents have been set, which means that the program headers have
2902 already been worked out. */
2903 if (elf_tdata (obfd
)->segment_map
== NULL
2904 && elf_tdata (ibfd
)->phdr
!= NULL
)
2908 /* Only set up the segments when all the sections have been set
2910 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2911 if (s
->output_section
== NULL
)
2915 if (! copy_private_bfd_data (ibfd
, obfd
))
2920 ihdr
= &elf_section_data (isec
)->this_hdr
;
2921 ohdr
= &elf_section_data (osec
)->this_hdr
;
2923 ohdr
->sh_entsize
= ihdr
->sh_entsize
;
2925 if (ihdr
->sh_type
== SHT_SYMTAB
2926 || ihdr
->sh_type
== SHT_DYNSYM
)
2927 ohdr
->sh_info
= ihdr
->sh_info
;
2932 /* Copy private symbol information. If this symbol is in a section
2933 which we did not map into a BFD section, try to map the section
2934 index correctly. We use special macro definitions for the mapped
2935 section indices; these definitions are interpreted by the
2936 swap_out_syms function. */
2938 #define MAP_ONESYMTAB (SHN_LORESERVE - 1)
2939 #define MAP_DYNSYMTAB (SHN_LORESERVE - 2)
2940 #define MAP_STRTAB (SHN_LORESERVE - 3)
2941 #define MAP_SHSTRTAB (SHN_LORESERVE - 4)
2944 _bfd_elf_copy_private_symbol_data (ibfd
, isymarg
, obfd
, osymarg
)
2950 elf_symbol_type
*isym
, *osym
;
2952 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2953 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2956 isym
= elf_symbol_from (ibfd
, isymarg
);
2957 osym
= elf_symbol_from (obfd
, osymarg
);
2961 && bfd_is_abs_section (isym
->symbol
.section
))
2965 shndx
= isym
->internal_elf_sym
.st_shndx
;
2966 if (shndx
== elf_onesymtab (ibfd
))
2967 shndx
= MAP_ONESYMTAB
;
2968 else if (shndx
== elf_dynsymtab (ibfd
))
2969 shndx
= MAP_DYNSYMTAB
;
2970 else if (shndx
== elf_tdata (ibfd
)->strtab_section
)
2972 else if (shndx
== elf_tdata (ibfd
)->shstrtab_section
)
2973 shndx
= MAP_SHSTRTAB
;
2974 osym
->internal_elf_sym
.st_shndx
= shndx
;
2980 /* Swap out the symbols. */
2983 swap_out_syms (abfd
, sttp
)
2985 struct bfd_strtab_hash
**sttp
;
2987 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2989 if (!elf_map_symbols (abfd
))
2992 /* Dump out the symtabs. */
2994 int symcount
= bfd_get_symcount (abfd
);
2995 asymbol
**syms
= bfd_get_outsymbols (abfd
);
2996 struct bfd_strtab_hash
*stt
;
2997 Elf_Internal_Shdr
*symtab_hdr
;
2998 Elf_Internal_Shdr
*symstrtab_hdr
;
2999 char *outbound_syms
;
3002 stt
= _bfd_elf_stringtab_init ();
3006 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3007 symtab_hdr
->sh_type
= SHT_SYMTAB
;
3008 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
3009 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
3010 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
3011 symtab_hdr
->sh_addralign
= bed
->s
->file_align
;
3013 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
3014 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
3016 outbound_syms
= bfd_alloc (abfd
,
3017 (1 + symcount
) * bed
->s
->sizeof_sym
);
3018 if (outbound_syms
== NULL
)
3020 symtab_hdr
->contents
= (PTR
) outbound_syms
;
3022 /* now generate the data (for "contents") */
3024 /* Fill in zeroth symbol and swap it out. */
3025 Elf_Internal_Sym sym
;
3031 sym
.st_shndx
= SHN_UNDEF
;
3032 bed
->s
->swap_symbol_out (abfd
, &sym
, (PTR
) outbound_syms
);
3033 outbound_syms
+= bed
->s
->sizeof_sym
;
3035 for (idx
= 0; idx
< symcount
; idx
++)
3037 Elf_Internal_Sym sym
;
3038 bfd_vma value
= syms
[idx
]->value
;
3039 elf_symbol_type
*type_ptr
;
3040 flagword flags
= syms
[idx
]->flags
;
3043 if (flags
& BSF_SECTION_SYM
)
3044 /* Section symbols have no names. */
3048 sym
.st_name
= (unsigned long) _bfd_stringtab_add (stt
,
3051 if (sym
.st_name
== (unsigned long) -1)
3055 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
3057 if (bfd_is_com_section (syms
[idx
]->section
))
3059 /* ELF common symbols put the alignment into the `value' field,
3060 and the size into the `size' field. This is backwards from
3061 how BFD handles it, so reverse it here. */
3062 sym
.st_size
= value
;
3063 if (type_ptr
== NULL
3064 || type_ptr
->internal_elf_sym
.st_value
== 0)
3065 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
3067 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
3068 sym
.st_shndx
= _bfd_elf_section_from_bfd_section (abfd
,
3069 syms
[idx
]->section
);
3073 asection
*sec
= syms
[idx
]->section
;
3076 if (sec
->output_section
)
3078 value
+= sec
->output_offset
;
3079 sec
= sec
->output_section
;
3082 sym
.st_value
= value
;
3083 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
3085 if (bfd_is_abs_section (sec
)
3087 && type_ptr
->internal_elf_sym
.st_shndx
!= 0)
3089 /* This symbol is in a real ELF section which we did
3090 not create as a BFD section. Undo the mapping done
3091 by copy_private_symbol_data. */
3092 shndx
= type_ptr
->internal_elf_sym
.st_shndx
;
3096 shndx
= elf_onesymtab (abfd
);
3099 shndx
= elf_dynsymtab (abfd
);
3102 shndx
= elf_tdata (abfd
)->strtab_section
;
3105 shndx
= elf_tdata (abfd
)->shstrtab_section
;
3113 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
3119 /* Writing this would be a hell of a lot easier if
3120 we had some decent documentation on bfd, and
3121 knew what to expect of the library, and what to
3122 demand of applications. For example, it
3123 appears that `objcopy' might not set the
3124 section of a symbol to be a section that is
3125 actually in the output file. */
3126 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
3127 BFD_ASSERT (sec2
!= 0);
3128 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
3129 BFD_ASSERT (shndx
!= -1);
3133 sym
.st_shndx
= shndx
;
3136 if ((flags
& BSF_FUNCTION
) != 0)
3138 else if ((flags
& BSF_OBJECT
) != 0)
3143 if (bfd_is_com_section (syms
[idx
]->section
))
3144 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, type
);
3145 else if (bfd_is_und_section (syms
[idx
]->section
))
3146 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
3150 else if (flags
& BSF_SECTION_SYM
)
3151 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
3152 else if (flags
& BSF_FILE
)
3153 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
3156 int bind
= STB_LOCAL
;
3158 if (flags
& BSF_LOCAL
)
3160 else if (flags
& BSF_WEAK
)
3162 else if (flags
& BSF_GLOBAL
)
3165 sym
.st_info
= ELF_ST_INFO (bind
, type
);
3168 if (type_ptr
!= NULL
)
3169 sym
.st_other
= type_ptr
->internal_elf_sym
.st_other
;
3173 bed
->s
->swap_symbol_out (abfd
, &sym
, (PTR
) outbound_syms
);
3174 outbound_syms
+= bed
->s
->sizeof_sym
;
3178 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (stt
);
3179 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
3181 symstrtab_hdr
->sh_flags
= 0;
3182 symstrtab_hdr
->sh_addr
= 0;
3183 symstrtab_hdr
->sh_entsize
= 0;
3184 symstrtab_hdr
->sh_link
= 0;
3185 symstrtab_hdr
->sh_info
= 0;
3186 symstrtab_hdr
->sh_addralign
= 1;
3192 /* Return the number of bytes required to hold the symtab vector.
3194 Note that we base it on the count plus 1, since we will null terminate
3195 the vector allocated based on this size. However, the ELF symbol table
3196 always has a dummy entry as symbol #0, so it ends up even. */
3199 _bfd_elf_get_symtab_upper_bound (abfd
)
3204 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3206 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
3207 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
3213 _bfd_elf_get_dynamic_symtab_upper_bound (abfd
)
3218 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
3220 if (elf_dynsymtab (abfd
) == 0)
3222 bfd_set_error (bfd_error_invalid_operation
);
3226 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
3227 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
3233 _bfd_elf_get_reloc_upper_bound (abfd
, asect
)
3237 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
3240 /* Canonicalize the relocs. */
3243 _bfd_elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
3252 if (! get_elf_backend_data (abfd
)->s
->slurp_reloc_table (abfd
,
3258 tblptr
= section
->relocation
;
3259 for (i
= 0; i
< section
->reloc_count
; i
++)
3260 *relptr
++ = tblptr
++;
3264 return section
->reloc_count
;
3268 _bfd_elf_get_symtab (abfd
, alocation
)
3270 asymbol
**alocation
;
3272 long symcount
= get_elf_backend_data (abfd
)->s
->slurp_symbol_table (abfd
, alocation
, false);
3275 bfd_get_symcount (abfd
) = symcount
;
3280 _bfd_elf_canonicalize_dynamic_symtab (abfd
, alocation
)
3282 asymbol
**alocation
;
3284 return get_elf_backend_data (abfd
)->s
->slurp_symbol_table (abfd
, alocation
, true);
3287 /* Return the size required for the dynamic reloc entries. Any
3288 section that was actually installed in the BFD, and has type
3289 SHT_REL or SHT_RELA, and uses the dynamic symbol table, is
3290 considered to be a dynamic reloc section. */
3293 _bfd_elf_get_dynamic_reloc_upper_bound (abfd
)
3299 if (elf_dynsymtab (abfd
) == 0)
3301 bfd_set_error (bfd_error_invalid_operation
);
3305 ret
= sizeof (arelent
*);
3306 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3307 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
3308 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
3309 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
3310 ret
+= ((s
->_raw_size
/ elf_section_data (s
)->this_hdr
.sh_entsize
)
3311 * sizeof (arelent
*));
3316 /* Canonicalize the dynamic relocation entries. Note that we return
3317 the dynamic relocations as a single block, although they are
3318 actually associated with particular sections; the interface, which
3319 was designed for SunOS style shared libraries, expects that there
3320 is only one set of dynamic relocs. Any section that was actually
3321 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
3322 the dynamic symbol table, is considered to be a dynamic reloc
3326 _bfd_elf_canonicalize_dynamic_reloc (abfd
, storage
, syms
)
3331 boolean (*slurp_relocs
) PARAMS ((bfd
*, asection
*, asymbol
**, boolean
));
3335 if (elf_dynsymtab (abfd
) == 0)
3337 bfd_set_error (bfd_error_invalid_operation
);
3341 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
3343 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3345 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
3346 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
3347 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
3352 if (! (*slurp_relocs
) (abfd
, s
, syms
, true))
3354 count
= s
->_raw_size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
3356 for (i
= 0; i
< count
; i
++)
3368 _bfd_elf_make_empty_symbol (abfd
)
3371 elf_symbol_type
*newsym
;
3373 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (elf_symbol_type
));
3378 newsym
->symbol
.the_bfd
= abfd
;
3379 return &newsym
->symbol
;
3384 _bfd_elf_get_symbol_info (ignore_abfd
, symbol
, ret
)
3389 bfd_symbol_info (symbol
, ret
);
3393 _bfd_elf_get_lineno (ignore_abfd
, symbol
)
3402 _bfd_elf_set_arch_mach (abfd
, arch
, machine
)
3404 enum bfd_architecture arch
;
3405 unsigned long machine
;
3407 /* If this isn't the right architecture for this backend, and this
3408 isn't the generic backend, fail. */
3409 if (arch
!= get_elf_backend_data (abfd
)->arch
3410 && arch
!= bfd_arch_unknown
3411 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
3414 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
3417 /* Find the nearest line to a particular section and offset, for error
3421 _bfd_elf_find_nearest_line (abfd
,
3432 CONST
char **filename_ptr
;
3433 CONST
char **functionname_ptr
;
3434 unsigned int *line_ptr
;
3437 const char *filename
;
3442 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
3443 &found
, filename_ptr
,
3444 functionname_ptr
, line_ptr
,
3445 &elf_tdata (abfd
)->line_info
))
3450 if (symbols
== NULL
)
3457 for (p
= symbols
; *p
!= NULL
; p
++)
3461 q
= (elf_symbol_type
*) *p
;
3463 if (bfd_get_section (&q
->symbol
) != section
)
3466 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
3471 filename
= bfd_asymbol_name (&q
->symbol
);
3474 if (q
->symbol
.section
== section
3475 && q
->symbol
.value
>= low_func
3476 && q
->symbol
.value
<= offset
)
3478 func
= (asymbol
*) q
;
3479 low_func
= q
->symbol
.value
;
3488 *filename_ptr
= filename
;
3489 *functionname_ptr
= bfd_asymbol_name (func
);
3495 _bfd_elf_sizeof_headers (abfd
, reloc
)
3501 ret
= get_elf_backend_data (abfd
)->s
->sizeof_ehdr
;
3503 ret
+= get_program_header_size (abfd
);
3508 _bfd_elf_set_section_contents (abfd
, section
, location
, offset
, count
)
3513 bfd_size_type count
;
3515 Elf_Internal_Shdr
*hdr
;
3517 if (! abfd
->output_has_begun
3518 && ! _bfd_elf_compute_section_file_positions (abfd
,
3519 (struct bfd_link_info
*) NULL
))
3522 hdr
= &elf_section_data (section
)->this_hdr
;
3524 if (bfd_seek (abfd
, hdr
->sh_offset
+ offset
, SEEK_SET
) == -1)
3526 if (bfd_write (location
, 1, count
, abfd
) != count
)
3533 _bfd_elf_no_info_to_howto (abfd
, cache_ptr
, dst
)
3536 Elf_Internal_Rela
*dst
;
3543 _bfd_elf_no_info_to_howto_rel (abfd
, cache_ptr
, dst
)
3546 Elf_Internal_Rel
*dst
;
3552 /* Try to convert a non-ELF reloc into an ELF one. */
3555 _bfd_elf_validate_reloc (abfd
, areloc
)
3559 /* Check whether we really have an ELF howto. */
3561 if ((*areloc
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
)
3563 bfd_reloc_code_real_type code
;
3564 reloc_howto_type
*howto
;
3566 /* Alien reloc: Try to determine its type to replace it with an
3567 equivalent ELF reloc. */
3569 if (areloc
->howto
->pc_relative
)
3571 switch (areloc
->howto
->bitsize
)
3574 code
= BFD_RELOC_8_PCREL
;
3577 code
= BFD_RELOC_12_PCREL
;
3580 code
= BFD_RELOC_16_PCREL
;
3583 code
= BFD_RELOC_24_PCREL
;
3586 code
= BFD_RELOC_32_PCREL
;
3589 code
= BFD_RELOC_64_PCREL
;
3595 howto
= bfd_reloc_type_lookup (abfd
, code
);
3597 if (areloc
->howto
->pcrel_offset
!= howto
->pcrel_offset
)
3599 if (howto
->pcrel_offset
)
3600 areloc
->addend
+= areloc
->address
;
3602 areloc
->addend
-= areloc
->address
; /* addend is unsigned!! */
3607 switch (areloc
->howto
->bitsize
)
3613 code
= BFD_RELOC_14
;
3616 code
= BFD_RELOC_16
;
3619 code
= BFD_RELOC_26
;
3622 code
= BFD_RELOC_32
;
3625 code
= BFD_RELOC_64
;
3631 howto
= bfd_reloc_type_lookup (abfd
, code
);
3635 areloc
->howto
= howto
;
3643 (*_bfd_error_handler
)
3644 ("%s: unsupported relocation type %s",
3645 bfd_get_filename (abfd
), areloc
->howto
->name
);
3646 bfd_set_error (bfd_error_bad_value
);