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
;
580 /* Assume that we have been called by a non-ELF symbol reader.
581 This flag is then reset by the code which reads an ELF input
582 file. This ensures that a symbol created by a non-ELF symbol
583 reader will have the flag set correctly. */
584 ret
->elf_link_hash_flags
= ELF_LINK_NON_ELF
;
587 return (struct bfd_hash_entry
*) ret
;
590 /* Initialize an ELF linker hash table. */
593 _bfd_elf_link_hash_table_init (table
, abfd
, newfunc
)
594 struct elf_link_hash_table
*table
;
596 struct bfd_hash_entry
*(*newfunc
) PARAMS ((struct bfd_hash_entry
*,
597 struct bfd_hash_table
*,
600 table
->dynamic_sections_created
= false;
601 table
->dynobj
= NULL
;
602 /* The first dynamic symbol is a dummy. */
603 table
->dynsymcount
= 1;
604 table
->dynstr
= NULL
;
605 table
->bucketcount
= 0;
606 table
->needed
= NULL
;
608 table
->stab_info
= NULL
;
609 return _bfd_link_hash_table_init (&table
->root
, abfd
, newfunc
);
612 /* Create an ELF linker hash table. */
614 struct bfd_link_hash_table
*
615 _bfd_elf_link_hash_table_create (abfd
)
618 struct elf_link_hash_table
*ret
;
620 ret
= ((struct elf_link_hash_table
*)
621 bfd_alloc (abfd
, sizeof (struct elf_link_hash_table
)));
622 if (ret
== (struct elf_link_hash_table
*) NULL
)
625 if (! _bfd_elf_link_hash_table_init (ret
, abfd
, _bfd_elf_link_hash_newfunc
))
627 bfd_release (abfd
, ret
);
634 /* This is a hook for the ELF emulation code in the generic linker to
635 tell the backend linker what file name to use for the DT_NEEDED
636 entry for a dynamic object. The generic linker passes name as an
637 empty string to indicate that no DT_NEEDED entry should be made. */
640 bfd_elf_set_dt_needed_name (abfd
, name
)
644 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
645 && bfd_get_format (abfd
) == bfd_object
)
646 elf_dt_name (abfd
) = name
;
649 /* Get the list of DT_NEEDED entries for a link. This is a hook for
650 the ELF emulation code. */
652 struct bfd_link_needed_list
*
653 bfd_elf_get_needed_list (abfd
, info
)
655 struct bfd_link_info
*info
;
657 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
659 return elf_hash_table (info
)->needed
;
662 /* Get the name actually used for a dynamic object for a link. This
663 is the SONAME entry if there is one. Otherwise, it is the string
664 passed to bfd_elf_set_dt_needed_name, or it is the filename. */
667 bfd_elf_get_dt_soname (abfd
)
670 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
671 && bfd_get_format (abfd
) == bfd_object
)
672 return elf_dt_name (abfd
);
676 /* Allocate an ELF string table--force the first byte to be zero. */
678 struct bfd_strtab_hash
*
679 _bfd_elf_stringtab_init ()
681 struct bfd_strtab_hash
*ret
;
683 ret
= _bfd_stringtab_init ();
688 loc
= _bfd_stringtab_add (ret
, "", true, false);
689 BFD_ASSERT (loc
== 0 || loc
== (bfd_size_type
) -1);
690 if (loc
== (bfd_size_type
) -1)
692 _bfd_stringtab_free (ret
);
699 /* ELF .o/exec file reading */
701 /* Create a new bfd section from an ELF section header. */
704 bfd_section_from_shdr (abfd
, shindex
)
706 unsigned int shindex
;
708 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[shindex
];
709 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
710 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
713 name
= elf_string_from_elf_strtab (abfd
, hdr
->sh_name
);
715 switch (hdr
->sh_type
)
718 /* Inactive section. Throw it away. */
721 case SHT_PROGBITS
: /* Normal section with contents. */
722 case SHT_DYNAMIC
: /* Dynamic linking information. */
723 case SHT_NOBITS
: /* .bss section. */
724 case SHT_HASH
: /* .hash section. */
725 case SHT_NOTE
: /* .note section. */
726 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
728 case SHT_SYMTAB
: /* A symbol table */
729 if (elf_onesymtab (abfd
) == shindex
)
732 BFD_ASSERT (hdr
->sh_entsize
== bed
->s
->sizeof_sym
);
733 BFD_ASSERT (elf_onesymtab (abfd
) == 0);
734 elf_onesymtab (abfd
) = shindex
;
735 elf_tdata (abfd
)->symtab_hdr
= *hdr
;
736 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->symtab_hdr
;
737 abfd
->flags
|= HAS_SYMS
;
739 /* Sometimes a shared object will map in the symbol table. If
740 SHF_ALLOC is set, and this is a shared object, then we also
741 treat this section as a BFD section. We can not base the
742 decision purely on SHF_ALLOC, because that flag is sometimes
743 set in a relocateable object file, which would confuse the
745 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
746 && (abfd
->flags
& DYNAMIC
) != 0
747 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
752 case SHT_DYNSYM
: /* A dynamic symbol table */
753 if (elf_dynsymtab (abfd
) == shindex
)
756 BFD_ASSERT (hdr
->sh_entsize
== bed
->s
->sizeof_sym
);
757 BFD_ASSERT (elf_dynsymtab (abfd
) == 0);
758 elf_dynsymtab (abfd
) = shindex
;
759 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
760 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
761 abfd
->flags
|= HAS_SYMS
;
763 /* Besides being a symbol table, we also treat this as a regular
764 section, so that objcopy can handle it. */
765 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
767 case SHT_STRTAB
: /* A string table */
768 if (hdr
->bfd_section
!= NULL
)
770 if (ehdr
->e_shstrndx
== shindex
)
772 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
773 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
779 for (i
= 1; i
< ehdr
->e_shnum
; i
++)
781 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
782 if (hdr2
->sh_link
== shindex
)
784 if (! bfd_section_from_shdr (abfd
, i
))
786 if (elf_onesymtab (abfd
) == i
)
788 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
789 elf_elfsections (abfd
)[shindex
] =
790 &elf_tdata (abfd
)->strtab_hdr
;
793 if (elf_dynsymtab (abfd
) == i
)
795 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
796 elf_elfsections (abfd
)[shindex
] = hdr
=
797 &elf_tdata (abfd
)->dynstrtab_hdr
;
798 /* We also treat this as a regular section, so
799 that objcopy can handle it. */
802 #if 0 /* Not handling other string tables specially right now. */
803 hdr2
= elf_elfsections (abfd
)[i
]; /* in case it moved */
804 /* We have a strtab for some random other section. */
805 newsect
= (asection
*) hdr2
->bfd_section
;
808 hdr
->bfd_section
= newsect
;
809 hdr2
= &elf_section_data (newsect
)->str_hdr
;
811 elf_elfsections (abfd
)[shindex
] = hdr2
;
817 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
821 /* *These* do a lot of work -- but build no sections! */
823 asection
*target_sect
;
824 Elf_Internal_Shdr
*hdr2
;
826 /* For some incomprehensible reason Oracle distributes
827 libraries for Solaris in which some of the objects have
828 bogus sh_link fields. It would be nice if we could just
829 reject them, but, unfortunately, some people need to use
830 them. We scan through the section headers; if we find only
831 one suitable symbol table, we clobber the sh_link to point
832 to it. I hope this doesn't break anything. */
833 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_SYMTAB
834 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_DYNSYM
)
840 for (scan
= 1; scan
< ehdr
->e_shnum
; scan
++)
842 if (elf_elfsections (abfd
)[scan
]->sh_type
== SHT_SYMTAB
843 || elf_elfsections (abfd
)[scan
]->sh_type
== SHT_DYNSYM
)
854 hdr
->sh_link
= found
;
857 /* Get the symbol table. */
858 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_SYMTAB
859 && ! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
862 /* If this reloc section does not use the main symbol table we
863 don't treat it as a reloc section. BFD can't adequately
864 represent such a section, so at least for now, we don't
865 try. We just present it as a normal section. */
866 if (hdr
->sh_link
!= elf_onesymtab (abfd
))
868 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
870 if (hdr
->bfd_section
!= NULL
872 && bfd_section_from_shdr (abfd
, hdr
->sh_info
))
874 target_sect
= bfd_section_from_elf_index (abfd
, hdr
->sh_info
);
875 if (target_sect
!= NULL
876 && (target_sect
->flags
& SEC_DEBUGGING
) != 0)
877 hdr
->bfd_section
->flags
|= SEC_DEBUGGING
;
882 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
884 target_sect
= bfd_section_from_elf_index (abfd
, hdr
->sh_info
);
885 if (target_sect
== NULL
)
888 if ((target_sect
->flags
& SEC_RELOC
) == 0
889 || target_sect
->reloc_count
== 0)
890 hdr2
= &elf_section_data (target_sect
)->rel_hdr
;
893 BFD_ASSERT (elf_section_data (target_sect
)->rel_hdr2
== NULL
);
894 hdr2
= (Elf_Internal_Shdr
*) bfd_alloc (abfd
, sizeof (*hdr2
));
895 elf_section_data (target_sect
)->rel_hdr2
= hdr2
;
898 elf_elfsections (abfd
)[shindex
] = hdr2
;
899 target_sect
->reloc_count
+= hdr
->sh_size
/ hdr
->sh_entsize
;
900 target_sect
->flags
|= SEC_RELOC
;
901 target_sect
->relocation
= NULL
;
902 target_sect
->rel_filepos
= hdr
->sh_offset
;
903 abfd
->flags
|= HAS_RELOC
;
912 /* Check for any processor-specific section types. */
914 if (bed
->elf_backend_section_from_shdr
)
915 (*bed
->elf_backend_section_from_shdr
) (abfd
, hdr
, name
);
923 /* Given an ELF section number, retrieve the corresponding BFD
927 bfd_section_from_elf_index (abfd
, index
)
931 BFD_ASSERT (index
> 0 && index
< SHN_LORESERVE
);
932 if (index
>= elf_elfheader (abfd
)->e_shnum
)
934 return elf_elfsections (abfd
)[index
]->bfd_section
;
938 _bfd_elf_new_section_hook (abfd
, sec
)
942 struct bfd_elf_section_data
*sdata
;
944 sdata
= (struct bfd_elf_section_data
*) bfd_alloc (abfd
, sizeof (*sdata
));
947 sec
->used_by_bfd
= (PTR
) sdata
;
948 memset (sdata
, 0, sizeof (*sdata
));
952 /* Create a new bfd section from an ELF program header.
954 Since program segments have no names, we generate a synthetic name
955 of the form segment<NUM>, where NUM is generally the index in the
956 program header table. For segments that are split (see below) we
957 generate the names segment<NUM>a and segment<NUM>b.
959 Note that some program segments may have a file size that is different than
960 (less than) the memory size. All this means is that at execution the
961 system must allocate the amount of memory specified by the memory size,
962 but only initialize it with the first "file size" bytes read from the
963 file. This would occur for example, with program segments consisting
964 of combined data+bss.
966 To handle the above situation, this routine generates TWO bfd sections
967 for the single program segment. The first has the length specified by
968 the file size of the segment, and the second has the length specified
969 by the difference between the two sizes. In effect, the segment is split
970 into it's initialized and uninitialized parts.
975 bfd_section_from_phdr (abfd
, hdr
, index
)
977 Elf_Internal_Phdr
*hdr
;
985 split
= ((hdr
->p_memsz
> 0) &&
986 (hdr
->p_filesz
> 0) &&
987 (hdr
->p_memsz
> hdr
->p_filesz
));
988 sprintf (namebuf
, split
? "segment%da" : "segment%d", index
);
989 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
992 strcpy (name
, namebuf
);
993 newsect
= bfd_make_section (abfd
, name
);
996 newsect
->vma
= hdr
->p_vaddr
;
997 newsect
->lma
= hdr
->p_paddr
;
998 newsect
->_raw_size
= hdr
->p_filesz
;
999 newsect
->filepos
= hdr
->p_offset
;
1000 newsect
->flags
|= SEC_HAS_CONTENTS
;
1001 if (hdr
->p_type
== PT_LOAD
)
1003 newsect
->flags
|= SEC_ALLOC
;
1004 newsect
->flags
|= SEC_LOAD
;
1005 if (hdr
->p_flags
& PF_X
)
1007 /* FIXME: all we known is that it has execute PERMISSION,
1009 newsect
->flags
|= SEC_CODE
;
1012 if (!(hdr
->p_flags
& PF_W
))
1014 newsect
->flags
|= SEC_READONLY
;
1019 sprintf (namebuf
, "segment%db", index
);
1020 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
1023 strcpy (name
, namebuf
);
1024 newsect
= bfd_make_section (abfd
, name
);
1025 if (newsect
== NULL
)
1027 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
1028 newsect
->lma
= hdr
->p_paddr
+ hdr
->p_filesz
;
1029 newsect
->_raw_size
= hdr
->p_memsz
- hdr
->p_filesz
;
1030 if (hdr
->p_type
== PT_LOAD
)
1032 newsect
->flags
|= SEC_ALLOC
;
1033 if (hdr
->p_flags
& PF_X
)
1034 newsect
->flags
|= SEC_CODE
;
1036 if (!(hdr
->p_flags
& PF_W
))
1037 newsect
->flags
|= SEC_READONLY
;
1043 /* Set up an ELF internal section header for a section. */
1047 elf_fake_sections (abfd
, asect
, failedptrarg
)
1052 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1053 boolean
*failedptr
= (boolean
*) failedptrarg
;
1054 Elf_Internal_Shdr
*this_hdr
;
1058 /* We already failed; just get out of the bfd_map_over_sections
1063 this_hdr
= &elf_section_data (asect
)->this_hdr
;
1065 this_hdr
->sh_name
= (unsigned long) _bfd_stringtab_add (elf_shstrtab (abfd
),
1068 if (this_hdr
->sh_name
== (unsigned long) -1)
1074 this_hdr
->sh_flags
= 0;
1076 if ((asect
->flags
& SEC_ALLOC
) != 0
1077 || asect
->user_set_vma
)
1078 this_hdr
->sh_addr
= asect
->vma
;
1080 this_hdr
->sh_addr
= 0;
1082 this_hdr
->sh_offset
= 0;
1083 this_hdr
->sh_size
= asect
->_raw_size
;
1084 this_hdr
->sh_link
= 0;
1085 this_hdr
->sh_addralign
= 1 << asect
->alignment_power
;
1086 /* The sh_entsize and sh_info fields may have been set already by
1087 copy_private_section_data. */
1089 this_hdr
->bfd_section
= asect
;
1090 this_hdr
->contents
= NULL
;
1092 /* FIXME: This should not be based on section names. */
1093 if (strcmp (asect
->name
, ".dynstr") == 0)
1094 this_hdr
->sh_type
= SHT_STRTAB
;
1095 else if (strcmp (asect
->name
, ".hash") == 0)
1097 this_hdr
->sh_type
= SHT_HASH
;
1098 this_hdr
->sh_entsize
= bed
->s
->arch_size
/ 8;
1100 else if (strcmp (asect
->name
, ".dynsym") == 0)
1102 this_hdr
->sh_type
= SHT_DYNSYM
;
1103 this_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
1105 else if (strcmp (asect
->name
, ".dynamic") == 0)
1107 this_hdr
->sh_type
= SHT_DYNAMIC
;
1108 this_hdr
->sh_entsize
= bed
->s
->sizeof_dyn
;
1110 else if (strncmp (asect
->name
, ".rela", 5) == 0
1111 && get_elf_backend_data (abfd
)->use_rela_p
)
1113 this_hdr
->sh_type
= SHT_RELA
;
1114 this_hdr
->sh_entsize
= bed
->s
->sizeof_rela
;
1116 else if (strncmp (asect
->name
, ".rel", 4) == 0
1117 && ! get_elf_backend_data (abfd
)->use_rela_p
)
1119 this_hdr
->sh_type
= SHT_REL
;
1120 this_hdr
->sh_entsize
= bed
->s
->sizeof_rel
;
1122 else if (strcmp (asect
->name
, ".note") == 0)
1123 this_hdr
->sh_type
= SHT_NOTE
;
1124 else if (strncmp (asect
->name
, ".stab", 5) == 0
1125 && strcmp (asect
->name
+ strlen (asect
->name
) - 3, "str") == 0)
1126 this_hdr
->sh_type
= SHT_STRTAB
;
1127 else if ((asect
->flags
& SEC_ALLOC
) != 0
1128 && (asect
->flags
& SEC_LOAD
) != 0)
1129 this_hdr
->sh_type
= SHT_PROGBITS
;
1130 else if ((asect
->flags
& SEC_ALLOC
) != 0
1131 && ((asect
->flags
& SEC_LOAD
) == 0))
1132 this_hdr
->sh_type
= SHT_NOBITS
;
1136 this_hdr
->sh_type
= SHT_PROGBITS
;
1139 if ((asect
->flags
& SEC_ALLOC
) != 0)
1140 this_hdr
->sh_flags
|= SHF_ALLOC
;
1141 if ((asect
->flags
& SEC_READONLY
) == 0)
1142 this_hdr
->sh_flags
|= SHF_WRITE
;
1143 if ((asect
->flags
& SEC_CODE
) != 0)
1144 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
1146 /* Check for processor-specific section types. */
1148 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1150 if (bed
->elf_backend_fake_sections
)
1151 (*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
);
1154 /* If the section has relocs, set up a section header for the
1155 SHT_REL[A] section. */
1156 if ((asect
->flags
& SEC_RELOC
) != 0)
1158 Elf_Internal_Shdr
*rela_hdr
;
1159 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1162 rela_hdr
= &elf_section_data (asect
)->rel_hdr
;
1163 name
= bfd_alloc (abfd
, sizeof ".rela" + strlen (asect
->name
));
1169 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", asect
->name
);
1171 (unsigned int) _bfd_stringtab_add (elf_shstrtab (abfd
), name
,
1173 if (rela_hdr
->sh_name
== (unsigned int) -1)
1178 rela_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
1179 rela_hdr
->sh_entsize
= (use_rela_p
1180 ? bed
->s
->sizeof_rela
1181 : bed
->s
->sizeof_rel
);
1182 rela_hdr
->sh_addralign
= bed
->s
->file_align
;
1183 rela_hdr
->sh_flags
= 0;
1184 rela_hdr
->sh_addr
= 0;
1185 rela_hdr
->sh_size
= 0;
1186 rela_hdr
->sh_offset
= 0;
1190 /* Assign all ELF section numbers. The dummy first section is handled here
1191 too. The link/info pointers for the standard section types are filled
1192 in here too, while we're at it. */
1195 assign_section_numbers (abfd
)
1198 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
1200 unsigned int section_number
;
1201 Elf_Internal_Shdr
**i_shdrp
;
1202 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1206 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1208 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1210 d
->this_idx
= section_number
++;
1211 if ((sec
->flags
& SEC_RELOC
) == 0)
1214 d
->rel_idx
= section_number
++;
1217 t
->shstrtab_section
= section_number
++;
1218 elf_elfheader (abfd
)->e_shstrndx
= t
->shstrtab_section
;
1219 t
->shstrtab_hdr
.sh_size
= _bfd_stringtab_size (elf_shstrtab (abfd
));
1221 if (abfd
->symcount
> 0)
1223 t
->symtab_section
= section_number
++;
1224 t
->strtab_section
= section_number
++;
1227 elf_elfheader (abfd
)->e_shnum
= section_number
;
1229 /* Set up the list of section header pointers, in agreement with the
1231 i_shdrp
= ((Elf_Internal_Shdr
**)
1232 bfd_alloc (abfd
, section_number
* sizeof (Elf_Internal_Shdr
*)));
1233 if (i_shdrp
== NULL
)
1236 i_shdrp
[0] = ((Elf_Internal_Shdr
*)
1237 bfd_alloc (abfd
, sizeof (Elf_Internal_Shdr
)));
1238 if (i_shdrp
[0] == NULL
)
1240 bfd_release (abfd
, i_shdrp
);
1243 memset (i_shdrp
[0], 0, sizeof (Elf_Internal_Shdr
));
1245 elf_elfsections (abfd
) = i_shdrp
;
1247 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
1248 if (abfd
->symcount
> 0)
1250 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
1251 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
1252 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
1254 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1256 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1260 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
1261 if (d
->rel_idx
!= 0)
1262 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
1264 /* Fill in the sh_link and sh_info fields while we're at it. */
1266 /* sh_link of a reloc section is the section index of the symbol
1267 table. sh_info is the section index of the section to which
1268 the relocation entries apply. */
1269 if (d
->rel_idx
!= 0)
1271 d
->rel_hdr
.sh_link
= t
->symtab_section
;
1272 d
->rel_hdr
.sh_info
= d
->this_idx
;
1275 switch (d
->this_hdr
.sh_type
)
1279 /* A reloc section which we are treating as a normal BFD
1280 section. sh_link is the section index of the symbol
1281 table. sh_info is the section index of the section to
1282 which the relocation entries apply. We assume that an
1283 allocated reloc section uses the dynamic symbol table.
1284 FIXME: How can we be sure? */
1285 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1287 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1289 /* We look up the section the relocs apply to by name. */
1291 if (d
->this_hdr
.sh_type
== SHT_REL
)
1295 s
= bfd_get_section_by_name (abfd
, name
);
1297 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
1301 /* We assume that a section named .stab*str is a stabs
1302 string section. We look for a section with the same name
1303 but without the trailing ``str'', and set its sh_link
1304 field to point to this section. */
1305 if (strncmp (sec
->name
, ".stab", sizeof ".stab" - 1) == 0
1306 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
1311 len
= strlen (sec
->name
);
1312 alc
= (char *) bfd_malloc (len
- 2);
1315 strncpy (alc
, sec
->name
, len
- 3);
1316 alc
[len
- 3] = '\0';
1317 s
= bfd_get_section_by_name (abfd
, alc
);
1321 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
1323 /* This is a .stab section. */
1324 elf_section_data (s
)->this_hdr
.sh_entsize
=
1325 4 + 2 * (bed
->s
->arch_size
/ 8);
1332 /* sh_link is the section header index of the string table
1333 used for the dynamic entries or symbol table. */
1334 s
= bfd_get_section_by_name (abfd
, ".dynstr");
1336 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1340 /* sh_link is the section header index of the symbol table
1341 this hash table is for. */
1342 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1344 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1352 /* Map symbol from it's internal number to the external number, moving
1353 all local symbols to be at the head of the list. */
1356 sym_is_global (abfd
, sym
)
1360 /* If the backend has a special mapping, use it. */
1361 if (get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1362 return ((*get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1365 return ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
1366 || bfd_is_und_section (bfd_get_section (sym
))
1367 || bfd_is_com_section (bfd_get_section (sym
)));
1371 elf_map_symbols (abfd
)
1374 int symcount
= bfd_get_symcount (abfd
);
1375 asymbol
**syms
= bfd_get_outsymbols (abfd
);
1376 asymbol
**sect_syms
;
1378 int num_globals
= 0;
1379 int num_locals2
= 0;
1380 int num_globals2
= 0;
1382 int num_sections
= 0;
1388 fprintf (stderr
, "elf_map_symbols\n");
1392 /* Add a section symbol for each BFD section. FIXME: Is this really
1394 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1396 if (max_index
< asect
->index
)
1397 max_index
= asect
->index
;
1401 sect_syms
= (asymbol
**) bfd_zalloc (abfd
, max_index
* sizeof (asymbol
*));
1402 if (sect_syms
== NULL
)
1404 elf_section_syms (abfd
) = sect_syms
;
1406 for (idx
= 0; idx
< symcount
; idx
++)
1408 if ((syms
[idx
]->flags
& BSF_SECTION_SYM
) != 0
1409 && (syms
[idx
]->value
+ syms
[idx
]->section
->vma
) == 0)
1413 sec
= syms
[idx
]->section
;
1414 if (sec
->owner
!= NULL
)
1416 if (sec
->owner
!= abfd
)
1418 if (sec
->output_offset
!= 0)
1420 sec
= sec
->output_section
;
1421 BFD_ASSERT (sec
->owner
== abfd
);
1423 sect_syms
[sec
->index
] = syms
[idx
];
1428 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1432 if (sect_syms
[asect
->index
] != NULL
)
1435 sym
= bfd_make_empty_symbol (abfd
);
1438 sym
->the_bfd
= abfd
;
1439 sym
->name
= asect
->name
;
1441 /* Set the flags to 0 to indicate that this one was newly added. */
1443 sym
->section
= asect
;
1444 sect_syms
[asect
->index
] = sym
;
1448 "creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n",
1449 asect
->name
, (long) asect
->vma
, asect
->index
, (long) asect
);
1453 /* Classify all of the symbols. */
1454 for (idx
= 0; idx
< symcount
; idx
++)
1456 if (!sym_is_global (abfd
, syms
[idx
]))
1461 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1463 if (sect_syms
[asect
->index
] != NULL
1464 && sect_syms
[asect
->index
]->flags
== 0)
1466 sect_syms
[asect
->index
]->flags
= BSF_SECTION_SYM
;
1467 if (!sym_is_global (abfd
, sect_syms
[asect
->index
]))
1471 sect_syms
[asect
->index
]->flags
= 0;
1475 /* Now sort the symbols so the local symbols are first. */
1476 new_syms
= ((asymbol
**)
1478 (num_locals
+ num_globals
) * sizeof (asymbol
*)));
1479 if (new_syms
== NULL
)
1482 for (idx
= 0; idx
< symcount
; idx
++)
1484 asymbol
*sym
= syms
[idx
];
1487 if (!sym_is_global (abfd
, sym
))
1490 i
= num_locals
+ num_globals2
++;
1492 sym
->udata
.i
= i
+ 1;
1494 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1496 if (sect_syms
[asect
->index
] != NULL
1497 && sect_syms
[asect
->index
]->flags
== 0)
1499 asymbol
*sym
= sect_syms
[asect
->index
];
1502 sym
->flags
= BSF_SECTION_SYM
;
1503 if (!sym_is_global (abfd
, sym
))
1506 i
= num_locals
+ num_globals2
++;
1508 sym
->udata
.i
= i
+ 1;
1512 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
1514 elf_num_locals (abfd
) = num_locals
;
1515 elf_num_globals (abfd
) = num_globals
;
1519 /* Align to the maximum file alignment that could be required for any
1520 ELF data structure. */
1522 static INLINE file_ptr align_file_position
PARAMS ((file_ptr
, int));
1523 static INLINE file_ptr
1524 align_file_position (off
, align
)
1528 return (off
+ align
- 1) & ~(align
- 1);
1531 /* Assign a file position to a section, optionally aligning to the
1532 required section alignment. */
1535 _bfd_elf_assign_file_position_for_section (i_shdrp
, offset
, align
)
1536 Elf_Internal_Shdr
*i_shdrp
;
1544 al
= i_shdrp
->sh_addralign
;
1546 offset
= BFD_ALIGN (offset
, al
);
1548 i_shdrp
->sh_offset
= offset
;
1549 if (i_shdrp
->bfd_section
!= NULL
)
1550 i_shdrp
->bfd_section
->filepos
= offset
;
1551 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
1552 offset
+= i_shdrp
->sh_size
;
1556 /* Compute the file positions we are going to put the sections at, and
1557 otherwise prepare to begin writing out the ELF file. If LINK_INFO
1558 is not NULL, this is being called by the ELF backend linker. */
1561 _bfd_elf_compute_section_file_positions (abfd
, link_info
)
1563 struct bfd_link_info
*link_info
;
1565 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1567 struct bfd_strtab_hash
*strtab
;
1568 Elf_Internal_Shdr
*shstrtab_hdr
;
1570 if (abfd
->output_has_begun
)
1573 /* Do any elf backend specific processing first. */
1574 if (bed
->elf_backend_begin_write_processing
)
1575 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
1577 if (! prep_headers (abfd
))
1581 bfd_map_over_sections (abfd
, elf_fake_sections
, &failed
);
1585 if (!assign_section_numbers (abfd
))
1588 /* The backend linker builds symbol table information itself. */
1589 if (link_info
== NULL
&& abfd
->symcount
> 0)
1591 if (! swap_out_syms (abfd
, &strtab
))
1595 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
1596 /* sh_name was set in prep_headers. */
1597 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
1598 shstrtab_hdr
->sh_flags
= 0;
1599 shstrtab_hdr
->sh_addr
= 0;
1600 shstrtab_hdr
->sh_size
= _bfd_stringtab_size (elf_shstrtab (abfd
));
1601 shstrtab_hdr
->sh_entsize
= 0;
1602 shstrtab_hdr
->sh_link
= 0;
1603 shstrtab_hdr
->sh_info
= 0;
1604 /* sh_offset is set in assign_file_positions_except_relocs. */
1605 shstrtab_hdr
->sh_addralign
= 1;
1607 if (!assign_file_positions_except_relocs (abfd
))
1610 if (link_info
== NULL
&& abfd
->symcount
> 0)
1613 Elf_Internal_Shdr
*hdr
;
1615 off
= elf_tdata (abfd
)->next_file_pos
;
1617 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1618 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
1620 hdr
= &elf_tdata (abfd
)->strtab_hdr
;
1621 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
1623 elf_tdata (abfd
)->next_file_pos
= off
;
1625 /* Now that we know where the .strtab section goes, write it
1627 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
1628 || ! _bfd_stringtab_emit (abfd
, strtab
))
1630 _bfd_stringtab_free (strtab
);
1633 abfd
->output_has_begun
= true;
1638 /* Create a mapping from a set of sections to a program segment. */
1640 static INLINE
struct elf_segment_map
*
1641 make_mapping (abfd
, sections
, from
, to
, phdr
)
1643 asection
**sections
;
1648 struct elf_segment_map
*m
;
1652 m
= ((struct elf_segment_map
*)
1654 (sizeof (struct elf_segment_map
)
1655 + (to
- from
- 1) * sizeof (asection
*))));
1659 m
->p_type
= PT_LOAD
;
1660 for (i
= from
, hdrpp
= sections
+ from
; i
< to
; i
++, hdrpp
++)
1661 m
->sections
[i
- from
] = *hdrpp
;
1662 m
->count
= to
- from
;
1664 if (from
== 0 && phdr
)
1666 /* Include the headers in the first PT_LOAD segment. */
1667 m
->includes_filehdr
= 1;
1668 m
->includes_phdrs
= 1;
1674 /* Set up a mapping from BFD sections to program segments. */
1677 map_sections_to_segments (abfd
)
1680 asection
**sections
= NULL
;
1684 struct elf_segment_map
*mfirst
;
1685 struct elf_segment_map
**pm
;
1686 struct elf_segment_map
*m
;
1688 unsigned int phdr_index
;
1689 bfd_vma maxpagesize
;
1691 boolean phdr_in_section
= true;
1695 if (elf_tdata (abfd
)->segment_map
!= NULL
)
1698 if (bfd_count_sections (abfd
) == 0)
1701 /* Select the allocated sections, and sort them. */
1703 sections
= (asection
**) bfd_malloc (bfd_count_sections (abfd
)
1704 * sizeof (asection
*));
1705 if (sections
== NULL
)
1709 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
1711 if ((s
->flags
& SEC_ALLOC
) != 0)
1717 BFD_ASSERT (i
<= bfd_count_sections (abfd
));
1720 qsort (sections
, (size_t) count
, sizeof (asection
*), elf_sort_sections
);
1722 /* Build the mapping. */
1727 /* If we have a .interp section, then create a PT_PHDR segment for
1728 the program headers and a PT_INTERP segment for the .interp
1730 s
= bfd_get_section_by_name (abfd
, ".interp");
1731 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
1733 m
= ((struct elf_segment_map
*)
1734 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
1738 m
->p_type
= PT_PHDR
;
1739 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
1740 m
->p_flags
= PF_R
| PF_X
;
1741 m
->p_flags_valid
= 1;
1742 m
->includes_phdrs
= 1;
1747 m
= ((struct elf_segment_map
*)
1748 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
1752 m
->p_type
= PT_INTERP
;
1760 /* Look through the sections. We put sections in the same program
1761 segment when the start of the second section can be placed within
1762 a few bytes of the end of the first section. */
1765 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
1767 dynsec
= bfd_get_section_by_name (abfd
, ".dynamic");
1769 && (dynsec
->flags
& SEC_LOAD
) == 0)
1772 /* Deal with -Ttext or something similar such that the first section
1773 is not adjacent to the program headers. This is an
1774 approximation, since at this point we don't know exactly how many
1775 program headers we will need. */
1778 bfd_size_type phdr_size
;
1780 phdr_size
= elf_tdata (abfd
)->program_header_size
;
1782 phdr_size
= get_elf_backend_data (abfd
)->s
->sizeof_phdr
;
1783 if ((abfd
->flags
& D_PAGED
) == 0
1784 || sections
[0]->lma
% maxpagesize
< phdr_size
% maxpagesize
)
1785 phdr_in_section
= false;
1788 for (i
= 0, hdrpp
= sections
; i
< count
; i
++, hdrpp
++)
1791 boolean new_segment
;
1795 /* See if this section and the last one will fit in the same
1798 if (last_hdr
== NULL
)
1800 /* If we don't have a segment yet, then we don't need a new
1801 one (we build the last one after this loop). */
1802 new_segment
= false;
1804 else if (last_hdr
->lma
- last_hdr
->vma
!= hdr
->lma
- hdr
->vma
)
1806 /* If this section has a different relation between the
1807 virtual address and the load address, then we need a new
1811 else if (BFD_ALIGN (last_hdr
->lma
+ last_hdr
->_raw_size
, maxpagesize
)
1814 /* If putting this section in this segment would force us to
1815 skip a page in the segment, then we need a new segment. */
1818 else if ((abfd
->flags
& D_PAGED
) == 0)
1820 /* If the file is not demand paged, which means that we
1821 don't require the sections to be correctly aligned in the
1822 file, then there is no other reason for a new segment. */
1823 new_segment
= false;
1825 else if ((last_hdr
->flags
& SEC_LOAD
) == 0
1826 && (hdr
->flags
& SEC_LOAD
) != 0)
1828 /* We don't want to put a loadable section after a
1829 nonloadable section in the same segment. */
1833 && (hdr
->flags
& SEC_READONLY
) == 0
1834 && (BFD_ALIGN (last_hdr
->lma
+ last_hdr
->_raw_size
, maxpagesize
)
1837 /* We don't want to put a writable section in a read only
1838 segment, unless they are on the same page in memory
1839 anyhow. We already know that the last section does not
1840 bring us past the current section on the page, so the
1841 only case in which the new section is not on the same
1842 page as the previous section is when the previous section
1843 ends precisely on a page boundary. */
1848 /* Otherwise, we can use the same segment. */
1849 new_segment
= false;
1854 if ((hdr
->flags
& SEC_READONLY
) == 0)
1860 /* We need a new program segment. We must create a new program
1861 header holding all the sections from phdr_index until hdr. */
1863 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_section
);
1870 if ((hdr
->flags
& SEC_READONLY
) == 0)
1877 phdr_in_section
= false;
1880 /* Create a final PT_LOAD program segment. */
1881 if (last_hdr
!= NULL
)
1883 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_section
);
1891 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
1894 m
= ((struct elf_segment_map
*)
1895 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
1899 m
->p_type
= PT_DYNAMIC
;
1901 m
->sections
[0] = dynsec
;
1910 elf_tdata (abfd
)->segment_map
= mfirst
;
1914 if (sections
!= NULL
)
1919 /* Sort sections by VMA. */
1922 elf_sort_sections (arg1
, arg2
)
1926 const asection
*sec1
= *(const asection
**) arg1
;
1927 const asection
*sec2
= *(const asection
**) arg2
;
1929 if (sec1
->vma
< sec2
->vma
)
1931 else if (sec1
->vma
> sec2
->vma
)
1934 /* Sort by LMA. Normally the LMA and the VMA will be the same, and
1935 this will do nothing. */
1936 if (sec1
->lma
< sec2
->lma
)
1938 else if (sec1
->lma
> sec2
->lma
)
1941 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
1943 #define TOEND(x) (((x)->flags & SEC_LOAD) == 0)
1947 return sec1
->target_index
- sec2
->target_index
;
1956 /* Sort by size, to put zero sized sections before others at the
1959 if (sec1
->_raw_size
< sec2
->_raw_size
)
1961 if (sec1
->_raw_size
> sec2
->_raw_size
)
1964 return sec1
->target_index
- sec2
->target_index
;
1967 /* Assign file positions to the sections based on the mapping from
1968 sections to segments. This function also sets up some fields in
1969 the file header, and writes out the program headers. */
1972 assign_file_positions_for_segments (abfd
)
1975 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1977 struct elf_segment_map
*m
;
1979 Elf_Internal_Phdr
*phdrs
;
1981 bfd_vma filehdr_vaddr
, filehdr_paddr
;
1982 bfd_vma phdrs_vaddr
, phdrs_paddr
;
1983 Elf_Internal_Phdr
*p
;
1985 if (elf_tdata (abfd
)->segment_map
== NULL
)
1987 if (! map_sections_to_segments (abfd
))
1991 if (bed
->elf_backend_modify_segment_map
)
1993 if (! (*bed
->elf_backend_modify_segment_map
) (abfd
))
1998 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
2001 elf_elfheader (abfd
)->e_phoff
= bed
->s
->sizeof_ehdr
;
2002 elf_elfheader (abfd
)->e_phentsize
= bed
->s
->sizeof_phdr
;
2003 elf_elfheader (abfd
)->e_phnum
= count
;
2008 /* If we already counted the number of program segments, make sure
2009 that we allocated enough space. This happens when SIZEOF_HEADERS
2010 is used in a linker script. */
2011 alloc
= elf_tdata (abfd
)->program_header_size
/ bed
->s
->sizeof_phdr
;
2012 if (alloc
!= 0 && count
> alloc
)
2014 ((*_bfd_error_handler
)
2015 ("%s: Not enough room for program headers (allocated %u, need %u)",
2016 bfd_get_filename (abfd
), alloc
, count
));
2017 bfd_set_error (bfd_error_bad_value
);
2024 phdrs
= ((Elf_Internal_Phdr
*)
2025 bfd_alloc (abfd
, alloc
* sizeof (Elf_Internal_Phdr
)));
2029 off
= bed
->s
->sizeof_ehdr
;
2030 off
+= alloc
* bed
->s
->sizeof_phdr
;
2036 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
2043 /* If elf_segment_map is not from map_sections_to_segments, the
2044 sections may not be correctly ordered. */
2046 qsort (m
->sections
, (size_t) m
->count
, sizeof (asection
*),
2049 p
->p_type
= m
->p_type
;
2051 if (m
->p_flags_valid
)
2052 p
->p_flags
= m
->p_flags
;
2056 if (p
->p_type
== PT_LOAD
2058 && (m
->sections
[0]->flags
& SEC_ALLOC
) != 0)
2060 if ((abfd
->flags
& D_PAGED
) != 0)
2061 off
+= (m
->sections
[0]->vma
- off
) % bed
->maxpagesize
;
2063 off
+= ((m
->sections
[0]->vma
- off
)
2064 % (1 << bfd_get_section_alignment (abfd
, m
->sections
[0])));
2070 p
->p_vaddr
= m
->sections
[0]->vma
;
2072 if (m
->p_paddr_valid
)
2073 p
->p_paddr
= m
->p_paddr
;
2074 else if (m
->count
== 0)
2077 p
->p_paddr
= m
->sections
[0]->lma
;
2079 if (p
->p_type
== PT_LOAD
2080 && (abfd
->flags
& D_PAGED
) != 0)
2081 p
->p_align
= bed
->maxpagesize
;
2082 else if (m
->count
== 0)
2083 p
->p_align
= bed
->s
->file_align
;
2091 if (m
->includes_filehdr
)
2093 if (! m
->p_flags_valid
)
2096 p
->p_filesz
= bed
->s
->sizeof_ehdr
;
2097 p
->p_memsz
= bed
->s
->sizeof_ehdr
;
2100 BFD_ASSERT (p
->p_type
== PT_LOAD
);
2102 if (! m
->p_paddr_valid
)
2105 if (p
->p_type
== PT_LOAD
)
2107 filehdr_vaddr
= p
->p_vaddr
;
2108 filehdr_paddr
= p
->p_paddr
;
2112 if (m
->includes_phdrs
)
2114 if (! m
->p_flags_valid
)
2116 if (m
->includes_filehdr
)
2118 if (p
->p_type
== PT_LOAD
)
2120 phdrs_vaddr
= p
->p_vaddr
+ bed
->s
->sizeof_ehdr
;
2121 phdrs_paddr
= p
->p_paddr
+ bed
->s
->sizeof_ehdr
;
2126 p
->p_offset
= bed
->s
->sizeof_ehdr
;
2129 BFD_ASSERT (p
->p_type
== PT_LOAD
);
2130 p
->p_vaddr
-= off
- p
->p_offset
;
2131 if (! m
->p_paddr_valid
)
2132 p
->p_paddr
-= off
- p
->p_offset
;
2134 if (p
->p_type
== PT_LOAD
)
2136 phdrs_vaddr
= p
->p_vaddr
;
2137 phdrs_paddr
= p
->p_paddr
;
2140 p
->p_filesz
+= alloc
* bed
->s
->sizeof_phdr
;
2141 p
->p_memsz
+= alloc
* bed
->s
->sizeof_phdr
;
2144 if (p
->p_type
== PT_LOAD
)
2146 if (! m
->includes_filehdr
&& ! m
->includes_phdrs
)
2152 adjust
= off
- (p
->p_offset
+ p
->p_filesz
);
2153 p
->p_filesz
+= adjust
;
2154 p
->p_memsz
+= adjust
;
2159 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
2163 bfd_size_type align
;
2167 align
= 1 << bfd_get_section_alignment (abfd
, sec
);
2169 if (p
->p_type
== PT_LOAD
)
2173 /* The section VMA must equal the file position modulo
2175 if ((flags
& SEC_ALLOC
) != 0)
2177 if ((abfd
->flags
& D_PAGED
) != 0)
2178 adjust
= (sec
->vma
- voff
) % bed
->maxpagesize
;
2180 adjust
= (sec
->vma
- voff
) % align
;
2185 p
->p_memsz
+= adjust
;
2188 if ((flags
& SEC_LOAD
) != 0)
2189 p
->p_filesz
+= adjust
;
2195 if ((flags
& SEC_LOAD
) != 0)
2196 off
+= sec
->_raw_size
;
2197 if ((flags
& SEC_ALLOC
) != 0)
2198 voff
+= sec
->_raw_size
;
2201 p
->p_memsz
+= sec
->_raw_size
;
2203 if ((flags
& SEC_LOAD
) != 0)
2204 p
->p_filesz
+= sec
->_raw_size
;
2206 if (align
> p
->p_align
)
2209 if (! m
->p_flags_valid
)
2212 if ((flags
& SEC_CODE
) != 0)
2214 if ((flags
& SEC_READONLY
) == 0)
2220 /* Now that we have set the section file positions, we can set up
2221 the file positions for the non PT_LOAD segments. */
2222 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
2226 if (p
->p_type
!= PT_LOAD
&& m
->count
> 0)
2228 BFD_ASSERT (! m
->includes_filehdr
&& ! m
->includes_phdrs
);
2229 p
->p_offset
= m
->sections
[0]->filepos
;
2233 if (m
->includes_filehdr
)
2235 p
->p_vaddr
= filehdr_vaddr
;
2236 if (! m
->p_paddr_valid
)
2237 p
->p_paddr
= filehdr_paddr
;
2239 else if (m
->includes_phdrs
)
2241 p
->p_vaddr
= phdrs_vaddr
;
2242 if (! m
->p_paddr_valid
)
2243 p
->p_paddr
= phdrs_paddr
;
2248 /* Clear out any program headers we allocated but did not use. */
2249 for (; count
< alloc
; count
++, p
++)
2251 memset (p
, 0, sizeof *p
);
2252 p
->p_type
= PT_NULL
;
2255 elf_tdata (abfd
)->phdr
= phdrs
;
2257 elf_tdata (abfd
)->next_file_pos
= off
;
2259 /* Write out the program headers. */
2260 if (bfd_seek (abfd
, bed
->s
->sizeof_ehdr
, SEEK_SET
) != 0
2261 || bed
->s
->write_out_phdrs (abfd
, phdrs
, alloc
) != 0)
2267 /* Get the size of the program header.
2269 If this is called by the linker before any of the section VMA's are set, it
2270 can't calculate the correct value for a strange memory layout. This only
2271 happens when SIZEOF_HEADERS is used in a linker script. In this case,
2272 SORTED_HDRS is NULL and we assume the normal scenario of one text and one
2273 data segment (exclusive of .interp and .dynamic).
2275 ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
2276 will be two segments. */
2278 static bfd_size_type
2279 get_program_header_size (abfd
)
2284 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2286 /* We can't return a different result each time we're called. */
2287 if (elf_tdata (abfd
)->program_header_size
!= 0)
2288 return elf_tdata (abfd
)->program_header_size
;
2290 if (elf_tdata (abfd
)->segment_map
!= NULL
)
2292 struct elf_segment_map
*m
;
2295 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
2297 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
2298 return elf_tdata (abfd
)->program_header_size
;
2301 /* Assume we will need exactly two PT_LOAD segments: one for text
2302 and one for data. */
2305 s
= bfd_get_section_by_name (abfd
, ".interp");
2306 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
2308 /* If we have a loadable interpreter section, we need a
2309 PT_INTERP segment. In this case, assume we also need a
2310 PT_PHDR segment, although that may not be true for all
2315 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
2317 /* We need a PT_DYNAMIC segment. */
2321 /* Let the backend count up any program headers it might need. */
2322 if (bed
->elf_backend_additional_program_headers
)
2326 a
= (*bed
->elf_backend_additional_program_headers
) (abfd
);
2332 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
2333 return elf_tdata (abfd
)->program_header_size
;
2336 /* Work out the file positions of all the sections. This is called by
2337 _bfd_elf_compute_section_file_positions. All the section sizes and
2338 VMAs must be known before this is called.
2340 We do not consider reloc sections at this point, unless they form
2341 part of the loadable image. Reloc sections are assigned file
2342 positions in assign_file_positions_for_relocs, which is called by
2343 write_object_contents and final_link.
2345 We also don't set the positions of the .symtab and .strtab here. */
2348 assign_file_positions_except_relocs (abfd
)
2351 struct elf_obj_tdata
* const tdata
= elf_tdata (abfd
);
2352 Elf_Internal_Ehdr
* const i_ehdrp
= elf_elfheader (abfd
);
2353 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
2355 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2357 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
2359 Elf_Internal_Shdr
**hdrpp
;
2362 /* Start after the ELF header. */
2363 off
= i_ehdrp
->e_ehsize
;
2365 /* We are not creating an executable, which means that we are
2366 not creating a program header, and that the actual order of
2367 the sections in the file is unimportant. */
2368 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2370 Elf_Internal_Shdr
*hdr
;
2373 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
2375 hdr
->sh_offset
= -1;
2378 if (i
== tdata
->symtab_section
2379 || i
== tdata
->strtab_section
)
2381 hdr
->sh_offset
= -1;
2385 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
2391 Elf_Internal_Shdr
**hdrpp
;
2393 /* Assign file positions for the loaded sections based on the
2394 assignment of sections to segments. */
2395 if (! assign_file_positions_for_segments (abfd
))
2398 /* Assign file positions for the other sections. */
2400 off
= elf_tdata (abfd
)->next_file_pos
;
2401 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2403 Elf_Internal_Shdr
*hdr
;
2406 if (hdr
->bfd_section
!= NULL
2407 && hdr
->bfd_section
->filepos
!= 0)
2408 hdr
->sh_offset
= hdr
->bfd_section
->filepos
;
2409 else if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
2411 ((*_bfd_error_handler
)
2412 ("%s: warning: allocated section `%s' not in segment",
2413 bfd_get_filename (abfd
),
2414 (hdr
->bfd_section
== NULL
2416 : hdr
->bfd_section
->name
)));
2417 if ((abfd
->flags
& D_PAGED
) != 0)
2418 off
+= (hdr
->sh_addr
- off
) % bed
->maxpagesize
;
2420 off
+= (hdr
->sh_addr
- off
) % hdr
->sh_addralign
;
2421 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
,
2424 else if (hdr
->sh_type
== SHT_REL
2425 || hdr
->sh_type
== SHT_RELA
2426 || hdr
== i_shdrpp
[tdata
->symtab_section
]
2427 || hdr
== i_shdrpp
[tdata
->strtab_section
])
2428 hdr
->sh_offset
= -1;
2430 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
2434 /* Place the section headers. */
2435 off
= align_file_position (off
, bed
->s
->file_align
);
2436 i_ehdrp
->e_shoff
= off
;
2437 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
2439 elf_tdata (abfd
)->next_file_pos
= off
;
2448 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2449 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
2450 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2452 struct bfd_strtab_hash
*shstrtab
;
2453 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2455 i_ehdrp
= elf_elfheader (abfd
);
2456 i_shdrp
= elf_elfsections (abfd
);
2458 shstrtab
= _bfd_elf_stringtab_init ();
2459 if (shstrtab
== NULL
)
2462 elf_shstrtab (abfd
) = shstrtab
;
2464 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
2465 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
2466 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
2467 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
2469 i_ehdrp
->e_ident
[EI_CLASS
] = bed
->s
->elfclass
;
2470 i_ehdrp
->e_ident
[EI_DATA
] =
2471 bfd_big_endian (abfd
) ? ELFDATA2MSB
: ELFDATA2LSB
;
2472 i_ehdrp
->e_ident
[EI_VERSION
] = bed
->s
->ev_current
;
2474 for (count
= EI_PAD
; count
< EI_NIDENT
; count
++)
2475 i_ehdrp
->e_ident
[count
] = 0;
2477 if ((abfd
->flags
& DYNAMIC
) != 0)
2478 i_ehdrp
->e_type
= ET_DYN
;
2479 else if ((abfd
->flags
& EXEC_P
) != 0)
2480 i_ehdrp
->e_type
= ET_EXEC
;
2482 i_ehdrp
->e_type
= ET_REL
;
2484 switch (bfd_get_arch (abfd
))
2486 case bfd_arch_unknown
:
2487 i_ehdrp
->e_machine
= EM_NONE
;
2489 case bfd_arch_sparc
:
2490 if (bed
->s
->arch_size
== 64)
2491 i_ehdrp
->e_machine
= EM_SPARC64
;
2493 i_ehdrp
->e_machine
= EM_SPARC
;
2496 i_ehdrp
->e_machine
= EM_386
;
2499 i_ehdrp
->e_machine
= EM_68K
;
2502 i_ehdrp
->e_machine
= EM_88K
;
2505 i_ehdrp
->e_machine
= EM_860
;
2507 case bfd_arch_mips
: /* MIPS Rxxxx */
2508 i_ehdrp
->e_machine
= EM_MIPS
; /* only MIPS R3000 */
2511 i_ehdrp
->e_machine
= EM_PARISC
;
2513 case bfd_arch_powerpc
:
2514 i_ehdrp
->e_machine
= EM_PPC
;
2516 case bfd_arch_alpha
:
2517 i_ehdrp
->e_machine
= EM_ALPHA
;
2520 i_ehdrp
->e_machine
= EM_SH
;
2522 /* start-sanitize-d10v */
2524 i_ehdrp
->e_machine
= EM_CYGNUS_D10V
;
2526 /* end-sanitize-d10v */
2527 /* start-sanitize-v850 */
2529 i_ehdrp
->e_machine
= EM_CYGNUS_V850
;
2531 /* end-sanitize-v850 */
2532 /* start-sanitize-arc */
2534 i_ehdrp
->e_machine
= EM_CYGNUS_ARC
;
2536 /* end-sanitize-arc */
2537 /* start-sanitize-m32r */
2539 i_ehdrp
->e_machine
= EM_CYGNUS_M32R
;
2541 /* end-sanitize-m32r */
2542 case bfd_arch_mn10200
:
2543 i_ehdrp
->e_machine
= EM_CYGNUS_MN10200
;
2545 case bfd_arch_mn10300
:
2546 i_ehdrp
->e_machine
= EM_CYGNUS_MN10300
;
2548 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
2550 i_ehdrp
->e_machine
= EM_NONE
;
2552 i_ehdrp
->e_version
= bed
->s
->ev_current
;
2553 i_ehdrp
->e_ehsize
= bed
->s
->sizeof_ehdr
;
2555 /* no program header, for now. */
2556 i_ehdrp
->e_phoff
= 0;
2557 i_ehdrp
->e_phentsize
= 0;
2558 i_ehdrp
->e_phnum
= 0;
2560 /* each bfd section is section header entry */
2561 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
2562 i_ehdrp
->e_shentsize
= bed
->s
->sizeof_shdr
;
2564 /* if we're building an executable, we'll need a program header table */
2565 if (abfd
->flags
& EXEC_P
)
2567 /* it all happens later */
2569 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
2571 /* elf_build_phdrs() returns a (NULL-terminated) array of
2572 Elf_Internal_Phdrs */
2573 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
2574 i_ehdrp
->e_phoff
= outbase
;
2575 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
2580 i_ehdrp
->e_phentsize
= 0;
2582 i_ehdrp
->e_phoff
= 0;
2585 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
2586 (unsigned int) _bfd_stringtab_add (shstrtab
, ".symtab", true, false);
2587 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
2588 (unsigned int) _bfd_stringtab_add (shstrtab
, ".strtab", true, false);
2589 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
2590 (unsigned int) _bfd_stringtab_add (shstrtab
, ".shstrtab", true, false);
2591 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2592 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2593 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
2599 /* Assign file positions for all the reloc sections which are not part
2600 of the loadable file image. */
2603 _bfd_elf_assign_file_positions_for_relocs (abfd
)
2608 Elf_Internal_Shdr
**shdrpp
;
2610 off
= elf_tdata (abfd
)->next_file_pos
;
2612 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1;
2613 i
< elf_elfheader (abfd
)->e_shnum
;
2616 Elf_Internal_Shdr
*shdrp
;
2619 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
2620 && shdrp
->sh_offset
== -1)
2621 off
= _bfd_elf_assign_file_position_for_section (shdrp
, off
, true);
2624 elf_tdata (abfd
)->next_file_pos
= off
;
2628 _bfd_elf_write_object_contents (abfd
)
2631 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2632 Elf_Internal_Ehdr
*i_ehdrp
;
2633 Elf_Internal_Shdr
**i_shdrp
;
2637 if (! abfd
->output_has_begun
2638 && ! _bfd_elf_compute_section_file_positions (abfd
,
2639 (struct bfd_link_info
*) NULL
))
2642 i_shdrp
= elf_elfsections (abfd
);
2643 i_ehdrp
= elf_elfheader (abfd
);
2646 bfd_map_over_sections (abfd
, bed
->s
->write_relocs
, &failed
);
2649 _bfd_elf_assign_file_positions_for_relocs (abfd
);
2651 /* After writing the headers, we need to write the sections too... */
2652 for (count
= 1; count
< i_ehdrp
->e_shnum
; count
++)
2654 if (bed
->elf_backend_section_processing
)
2655 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
2656 if (i_shdrp
[count
]->contents
)
2658 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
2659 || (bfd_write (i_shdrp
[count
]->contents
, i_shdrp
[count
]->sh_size
,
2661 != i_shdrp
[count
]->sh_size
))
2666 /* Write out the section header names. */
2667 if (bfd_seek (abfd
, elf_tdata (abfd
)->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
2668 || ! _bfd_stringtab_emit (abfd
, elf_shstrtab (abfd
)))
2671 if (bed
->elf_backend_final_write_processing
)
2672 (*bed
->elf_backend_final_write_processing
) (abfd
,
2673 elf_tdata (abfd
)->linker
);
2675 return bed
->s
->write_shdrs_and_ehdr (abfd
);
2678 /* given a section, search the header to find them... */
2680 _bfd_elf_section_from_bfd_section (abfd
, asect
)
2684 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2685 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
2687 Elf_Internal_Shdr
*hdr
;
2688 int maxindex
= elf_elfheader (abfd
)->e_shnum
;
2690 for (index
= 0; index
< maxindex
; index
++)
2692 hdr
= i_shdrp
[index
];
2693 if (hdr
->bfd_section
== asect
)
2697 if (bed
->elf_backend_section_from_bfd_section
)
2699 for (index
= 0; index
< maxindex
; index
++)
2703 hdr
= i_shdrp
[index
];
2705 if ((*bed
->elf_backend_section_from_bfd_section
)
2706 (abfd
, hdr
, asect
, &retval
))
2711 if (bfd_is_abs_section (asect
))
2713 if (bfd_is_com_section (asect
))
2715 if (bfd_is_und_section (asect
))
2721 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
2725 _bfd_elf_symbol_from_bfd_symbol (abfd
, asym_ptr_ptr
)
2727 asymbol
**asym_ptr_ptr
;
2729 asymbol
*asym_ptr
= *asym_ptr_ptr
;
2731 flagword flags
= asym_ptr
->flags
;
2733 /* When gas creates relocations against local labels, it creates its
2734 own symbol for the section, but does put the symbol into the
2735 symbol chain, so udata is 0. When the linker is generating
2736 relocatable output, this section symbol may be for one of the
2737 input sections rather than the output section. */
2738 if (asym_ptr
->udata
.i
== 0
2739 && (flags
& BSF_SECTION_SYM
)
2740 && asym_ptr
->section
)
2744 if (asym_ptr
->section
->output_section
!= NULL
)
2745 indx
= asym_ptr
->section
->output_section
->index
;
2747 indx
= asym_ptr
->section
->index
;
2748 if (elf_section_syms (abfd
)[indx
])
2749 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
2752 idx
= asym_ptr
->udata
.i
;
2756 /* This case can occur when using --strip-symbol on a symbol
2757 which is used in a relocation entry. */
2758 (*_bfd_error_handler
)
2759 ("%s: symbol `%s' required but not present",
2760 bfd_get_filename (abfd
), bfd_asymbol_name (asym_ptr
));
2761 bfd_set_error (bfd_error_no_symbols
);
2768 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
2769 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
,
2770 elf_symbol_flags (flags
));
2778 /* Copy private BFD data. This copies any program header information. */
2781 copy_private_bfd_data (ibfd
, obfd
)
2785 Elf_Internal_Ehdr
*iehdr
;
2786 struct elf_segment_map
*mfirst
;
2787 struct elf_segment_map
**pm
;
2788 Elf_Internal_Phdr
*p
;
2791 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2792 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2795 if (elf_tdata (ibfd
)->phdr
== NULL
)
2798 iehdr
= elf_elfheader (ibfd
);
2803 c
= elf_elfheader (ibfd
)->e_phnum
;
2804 for (i
= 0, p
= elf_tdata (ibfd
)->phdr
; i
< c
; i
++, p
++)
2808 struct elf_segment_map
*m
;
2813 /* The complicated case when p_vaddr is 0 is to handle the
2814 Solaris linker, which generates a PT_INTERP section with
2815 p_vaddr and p_memsz set to 0. */
2816 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2817 if (((s
->vma
>= p
->p_vaddr
2818 && (s
->vma
+ s
->_raw_size
<= p
->p_vaddr
+ p
->p_memsz
2819 || s
->vma
+ s
->_raw_size
<= p
->p_vaddr
+ p
->p_filesz
))
2822 && (s
->flags
& SEC_HAS_CONTENTS
) != 0
2823 && (bfd_vma
) s
->filepos
>= p
->p_offset
2824 && ((bfd_vma
) s
->filepos
+ s
->_raw_size
2825 <= p
->p_offset
+ p
->p_filesz
)))
2826 && (s
->flags
& SEC_ALLOC
) != 0
2827 && s
->output_section
!= NULL
)
2830 m
= ((struct elf_segment_map
*)
2832 (sizeof (struct elf_segment_map
)
2833 + (csecs
- 1) * sizeof (asection
*))));
2838 m
->p_type
= p
->p_type
;
2839 m
->p_flags
= p
->p_flags
;
2840 m
->p_flags_valid
= 1;
2841 m
->p_paddr
= p
->p_paddr
;
2842 m
->p_paddr_valid
= 1;
2844 m
->includes_filehdr
= (p
->p_offset
== 0
2845 && p
->p_filesz
>= iehdr
->e_ehsize
);
2847 m
->includes_phdrs
= (p
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
2848 && (p
->p_offset
+ p
->p_filesz
2849 >= ((bfd_vma
) iehdr
->e_phoff
2850 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
2853 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2855 if (((s
->vma
>= p
->p_vaddr
2856 && (s
->vma
+ s
->_raw_size
<= p
->p_vaddr
+ p
->p_memsz
2857 || s
->vma
+ s
->_raw_size
<= p
->p_vaddr
+ p
->p_filesz
))
2860 && (s
->flags
& SEC_HAS_CONTENTS
) != 0
2861 && (bfd_vma
) s
->filepos
>= p
->p_offset
2862 && ((bfd_vma
) s
->filepos
+ s
->_raw_size
2863 <= p
->p_offset
+ p
->p_filesz
)))
2864 && (s
->flags
& SEC_ALLOC
) != 0
2865 && s
->output_section
!= NULL
)
2867 m
->sections
[isec
] = s
->output_section
;
2871 BFD_ASSERT (isec
== csecs
);
2878 elf_tdata (obfd
)->segment_map
= mfirst
;
2883 /* Copy private section information. This copies over the entsize
2884 field, and sometimes the info field. */
2887 _bfd_elf_copy_private_section_data (ibfd
, isec
, obfd
, osec
)
2893 Elf_Internal_Shdr
*ihdr
, *ohdr
;
2895 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
2896 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
2899 /* Copy over private BFD data if it has not already been copied.
2900 This must be done here, rather than in the copy_private_bfd_data
2901 entry point, because the latter is called after the section
2902 contents have been set, which means that the program headers have
2903 already been worked out. */
2904 if (elf_tdata (obfd
)->segment_map
== NULL
2905 && elf_tdata (ibfd
)->phdr
!= NULL
)
2909 /* Only set up the segments when all the sections have been set
2911 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2912 if (s
->output_section
== NULL
)
2916 if (! copy_private_bfd_data (ibfd
, obfd
))
2921 ihdr
= &elf_section_data (isec
)->this_hdr
;
2922 ohdr
= &elf_section_data (osec
)->this_hdr
;
2924 ohdr
->sh_entsize
= ihdr
->sh_entsize
;
2926 if (ihdr
->sh_type
== SHT_SYMTAB
2927 || ihdr
->sh_type
== SHT_DYNSYM
)
2928 ohdr
->sh_info
= ihdr
->sh_info
;
2933 /* Copy private symbol information. If this symbol is in a section
2934 which we did not map into a BFD section, try to map the section
2935 index correctly. We use special macro definitions for the mapped
2936 section indices; these definitions are interpreted by the
2937 swap_out_syms function. */
2939 #define MAP_ONESYMTAB (SHN_LORESERVE - 1)
2940 #define MAP_DYNSYMTAB (SHN_LORESERVE - 2)
2941 #define MAP_STRTAB (SHN_LORESERVE - 3)
2942 #define MAP_SHSTRTAB (SHN_LORESERVE - 4)
2945 _bfd_elf_copy_private_symbol_data (ibfd
, isymarg
, obfd
, osymarg
)
2951 elf_symbol_type
*isym
, *osym
;
2953 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2954 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2957 isym
= elf_symbol_from (ibfd
, isymarg
);
2958 osym
= elf_symbol_from (obfd
, osymarg
);
2962 && bfd_is_abs_section (isym
->symbol
.section
))
2966 shndx
= isym
->internal_elf_sym
.st_shndx
;
2967 if (shndx
== elf_onesymtab (ibfd
))
2968 shndx
= MAP_ONESYMTAB
;
2969 else if (shndx
== elf_dynsymtab (ibfd
))
2970 shndx
= MAP_DYNSYMTAB
;
2971 else if (shndx
== elf_tdata (ibfd
)->strtab_section
)
2973 else if (shndx
== elf_tdata (ibfd
)->shstrtab_section
)
2974 shndx
= MAP_SHSTRTAB
;
2975 osym
->internal_elf_sym
.st_shndx
= shndx
;
2981 /* Swap out the symbols. */
2984 swap_out_syms (abfd
, sttp
)
2986 struct bfd_strtab_hash
**sttp
;
2988 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2990 if (!elf_map_symbols (abfd
))
2993 /* Dump out the symtabs. */
2995 int symcount
= bfd_get_symcount (abfd
);
2996 asymbol
**syms
= bfd_get_outsymbols (abfd
);
2997 struct bfd_strtab_hash
*stt
;
2998 Elf_Internal_Shdr
*symtab_hdr
;
2999 Elf_Internal_Shdr
*symstrtab_hdr
;
3000 char *outbound_syms
;
3003 stt
= _bfd_elf_stringtab_init ();
3007 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3008 symtab_hdr
->sh_type
= SHT_SYMTAB
;
3009 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
3010 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
3011 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
3012 symtab_hdr
->sh_addralign
= bed
->s
->file_align
;
3014 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
3015 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
3017 outbound_syms
= bfd_alloc (abfd
,
3018 (1 + symcount
) * bed
->s
->sizeof_sym
);
3019 if (outbound_syms
== NULL
)
3021 symtab_hdr
->contents
= (PTR
) outbound_syms
;
3023 /* now generate the data (for "contents") */
3025 /* Fill in zeroth symbol and swap it out. */
3026 Elf_Internal_Sym sym
;
3032 sym
.st_shndx
= SHN_UNDEF
;
3033 bed
->s
->swap_symbol_out (abfd
, &sym
, (PTR
) outbound_syms
);
3034 outbound_syms
+= bed
->s
->sizeof_sym
;
3036 for (idx
= 0; idx
< symcount
; idx
++)
3038 Elf_Internal_Sym sym
;
3039 bfd_vma value
= syms
[idx
]->value
;
3040 elf_symbol_type
*type_ptr
;
3041 flagword flags
= syms
[idx
]->flags
;
3044 if (flags
& BSF_SECTION_SYM
)
3045 /* Section symbols have no names. */
3049 sym
.st_name
= (unsigned long) _bfd_stringtab_add (stt
,
3052 if (sym
.st_name
== (unsigned long) -1)
3056 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
3058 if (bfd_is_com_section (syms
[idx
]->section
))
3060 /* ELF common symbols put the alignment into the `value' field,
3061 and the size into the `size' field. This is backwards from
3062 how BFD handles it, so reverse it here. */
3063 sym
.st_size
= value
;
3064 if (type_ptr
== NULL
3065 || type_ptr
->internal_elf_sym
.st_value
== 0)
3066 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
3068 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
3069 sym
.st_shndx
= _bfd_elf_section_from_bfd_section (abfd
,
3070 syms
[idx
]->section
);
3074 asection
*sec
= syms
[idx
]->section
;
3077 if (sec
->output_section
)
3079 value
+= sec
->output_offset
;
3080 sec
= sec
->output_section
;
3083 sym
.st_value
= value
;
3084 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
3086 if (bfd_is_abs_section (sec
)
3088 && type_ptr
->internal_elf_sym
.st_shndx
!= 0)
3090 /* This symbol is in a real ELF section which we did
3091 not create as a BFD section. Undo the mapping done
3092 by copy_private_symbol_data. */
3093 shndx
= type_ptr
->internal_elf_sym
.st_shndx
;
3097 shndx
= elf_onesymtab (abfd
);
3100 shndx
= elf_dynsymtab (abfd
);
3103 shndx
= elf_tdata (abfd
)->strtab_section
;
3106 shndx
= elf_tdata (abfd
)->shstrtab_section
;
3114 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
3120 /* Writing this would be a hell of a lot easier if
3121 we had some decent documentation on bfd, and
3122 knew what to expect of the library, and what to
3123 demand of applications. For example, it
3124 appears that `objcopy' might not set the
3125 section of a symbol to be a section that is
3126 actually in the output file. */
3127 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
3128 BFD_ASSERT (sec2
!= 0);
3129 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
3130 BFD_ASSERT (shndx
!= -1);
3134 sym
.st_shndx
= shndx
;
3137 if ((flags
& BSF_FUNCTION
) != 0)
3139 else if ((flags
& BSF_OBJECT
) != 0)
3144 if (bfd_is_com_section (syms
[idx
]->section
))
3145 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, type
);
3146 else if (bfd_is_und_section (syms
[idx
]->section
))
3147 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
3151 else if (flags
& BSF_SECTION_SYM
)
3152 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
3153 else if (flags
& BSF_FILE
)
3154 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
3157 int bind
= STB_LOCAL
;
3159 if (flags
& BSF_LOCAL
)
3161 else if (flags
& BSF_WEAK
)
3163 else if (flags
& BSF_GLOBAL
)
3166 sym
.st_info
= ELF_ST_INFO (bind
, type
);
3169 if (type_ptr
!= NULL
)
3170 sym
.st_other
= type_ptr
->internal_elf_sym
.st_other
;
3174 bed
->s
->swap_symbol_out (abfd
, &sym
, (PTR
) outbound_syms
);
3175 outbound_syms
+= bed
->s
->sizeof_sym
;
3179 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (stt
);
3180 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
3182 symstrtab_hdr
->sh_flags
= 0;
3183 symstrtab_hdr
->sh_addr
= 0;
3184 symstrtab_hdr
->sh_entsize
= 0;
3185 symstrtab_hdr
->sh_link
= 0;
3186 symstrtab_hdr
->sh_info
= 0;
3187 symstrtab_hdr
->sh_addralign
= 1;
3193 /* Return the number of bytes required to hold the symtab vector.
3195 Note that we base it on the count plus 1, since we will null terminate
3196 the vector allocated based on this size. However, the ELF symbol table
3197 always has a dummy entry as symbol #0, so it ends up even. */
3200 _bfd_elf_get_symtab_upper_bound (abfd
)
3205 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3207 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
3208 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
3214 _bfd_elf_get_dynamic_symtab_upper_bound (abfd
)
3219 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
3221 if (elf_dynsymtab (abfd
) == 0)
3223 bfd_set_error (bfd_error_invalid_operation
);
3227 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
3228 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
3234 _bfd_elf_get_reloc_upper_bound (abfd
, asect
)
3238 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
3241 /* Canonicalize the relocs. */
3244 _bfd_elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
3253 if (! get_elf_backend_data (abfd
)->s
->slurp_reloc_table (abfd
,
3259 tblptr
= section
->relocation
;
3260 for (i
= 0; i
< section
->reloc_count
; i
++)
3261 *relptr
++ = tblptr
++;
3265 return section
->reloc_count
;
3269 _bfd_elf_get_symtab (abfd
, alocation
)
3271 asymbol
**alocation
;
3273 long symcount
= get_elf_backend_data (abfd
)->s
->slurp_symbol_table (abfd
, alocation
, false);
3276 bfd_get_symcount (abfd
) = symcount
;
3281 _bfd_elf_canonicalize_dynamic_symtab (abfd
, alocation
)
3283 asymbol
**alocation
;
3285 return get_elf_backend_data (abfd
)->s
->slurp_symbol_table (abfd
, alocation
, true);
3288 /* Return the size required for the dynamic reloc entries. Any
3289 section that was actually installed in the BFD, and has type
3290 SHT_REL or SHT_RELA, and uses the dynamic symbol table, is
3291 considered to be a dynamic reloc section. */
3294 _bfd_elf_get_dynamic_reloc_upper_bound (abfd
)
3300 if (elf_dynsymtab (abfd
) == 0)
3302 bfd_set_error (bfd_error_invalid_operation
);
3306 ret
= sizeof (arelent
*);
3307 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3308 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
3309 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
3310 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
3311 ret
+= ((s
->_raw_size
/ elf_section_data (s
)->this_hdr
.sh_entsize
)
3312 * sizeof (arelent
*));
3317 /* Canonicalize the dynamic relocation entries. Note that we return
3318 the dynamic relocations as a single block, although they are
3319 actually associated with particular sections; the interface, which
3320 was designed for SunOS style shared libraries, expects that there
3321 is only one set of dynamic relocs. Any section that was actually
3322 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
3323 the dynamic symbol table, is considered to be a dynamic reloc
3327 _bfd_elf_canonicalize_dynamic_reloc (abfd
, storage
, syms
)
3332 boolean (*slurp_relocs
) PARAMS ((bfd
*, asection
*, asymbol
**, boolean
));
3336 if (elf_dynsymtab (abfd
) == 0)
3338 bfd_set_error (bfd_error_invalid_operation
);
3342 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
3344 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3346 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
3347 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
3348 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
3353 if (! (*slurp_relocs
) (abfd
, s
, syms
, true))
3355 count
= s
->_raw_size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
3357 for (i
= 0; i
< count
; i
++)
3369 _bfd_elf_make_empty_symbol (abfd
)
3372 elf_symbol_type
*newsym
;
3374 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (elf_symbol_type
));
3379 newsym
->symbol
.the_bfd
= abfd
;
3380 return &newsym
->symbol
;
3385 _bfd_elf_get_symbol_info (ignore_abfd
, symbol
, ret
)
3390 bfd_symbol_info (symbol
, ret
);
3394 _bfd_elf_get_lineno (ignore_abfd
, symbol
)
3403 _bfd_elf_set_arch_mach (abfd
, arch
, machine
)
3405 enum bfd_architecture arch
;
3406 unsigned long machine
;
3408 /* If this isn't the right architecture for this backend, and this
3409 isn't the generic backend, fail. */
3410 if (arch
!= get_elf_backend_data (abfd
)->arch
3411 && arch
!= bfd_arch_unknown
3412 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
3415 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
3418 /* Find the nearest line to a particular section and offset, for error
3422 _bfd_elf_find_nearest_line (abfd
,
3433 CONST
char **filename_ptr
;
3434 CONST
char **functionname_ptr
;
3435 unsigned int *line_ptr
;
3438 const char *filename
;
3443 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
3444 &found
, filename_ptr
,
3445 functionname_ptr
, line_ptr
,
3446 &elf_tdata (abfd
)->line_info
))
3451 if (symbols
== NULL
)
3458 for (p
= symbols
; *p
!= NULL
; p
++)
3462 q
= (elf_symbol_type
*) *p
;
3464 if (bfd_get_section (&q
->symbol
) != section
)
3467 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
3472 filename
= bfd_asymbol_name (&q
->symbol
);
3475 if (q
->symbol
.section
== section
3476 && q
->symbol
.value
>= low_func
3477 && q
->symbol
.value
<= offset
)
3479 func
= (asymbol
*) q
;
3480 low_func
= q
->symbol
.value
;
3489 *filename_ptr
= filename
;
3490 *functionname_ptr
= bfd_asymbol_name (func
);
3496 _bfd_elf_sizeof_headers (abfd
, reloc
)
3502 ret
= get_elf_backend_data (abfd
)->s
->sizeof_ehdr
;
3504 ret
+= get_program_header_size (abfd
);
3509 _bfd_elf_set_section_contents (abfd
, section
, location
, offset
, count
)
3514 bfd_size_type count
;
3516 Elf_Internal_Shdr
*hdr
;
3518 if (! abfd
->output_has_begun
3519 && ! _bfd_elf_compute_section_file_positions (abfd
,
3520 (struct bfd_link_info
*) NULL
))
3523 hdr
= &elf_section_data (section
)->this_hdr
;
3525 if (bfd_seek (abfd
, hdr
->sh_offset
+ offset
, SEEK_SET
) == -1)
3527 if (bfd_write (location
, 1, count
, abfd
) != count
)
3534 _bfd_elf_no_info_to_howto (abfd
, cache_ptr
, dst
)
3537 Elf_Internal_Rela
*dst
;
3544 _bfd_elf_no_info_to_howto_rel (abfd
, cache_ptr
, dst
)
3547 Elf_Internal_Rel
*dst
;
3553 /* Try to convert a non-ELF reloc into an ELF one. */
3556 _bfd_elf_validate_reloc (abfd
, areloc
)
3560 /* Check whether we really have an ELF howto. */
3562 if ((*areloc
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
)
3564 bfd_reloc_code_real_type code
;
3565 reloc_howto_type
*howto
;
3567 /* Alien reloc: Try to determine its type to replace it with an
3568 equivalent ELF reloc. */
3570 if (areloc
->howto
->pc_relative
)
3572 switch (areloc
->howto
->bitsize
)
3575 code
= BFD_RELOC_8_PCREL
;
3578 code
= BFD_RELOC_12_PCREL
;
3581 code
= BFD_RELOC_16_PCREL
;
3584 code
= BFD_RELOC_24_PCREL
;
3587 code
= BFD_RELOC_32_PCREL
;
3590 code
= BFD_RELOC_64_PCREL
;
3596 howto
= bfd_reloc_type_lookup (abfd
, code
);
3598 if (areloc
->howto
->pcrel_offset
!= howto
->pcrel_offset
)
3600 if (howto
->pcrel_offset
)
3601 areloc
->addend
+= areloc
->address
;
3603 areloc
->addend
-= areloc
->address
; /* addend is unsigned!! */
3608 switch (areloc
->howto
->bitsize
)
3614 code
= BFD_RELOC_14
;
3617 code
= BFD_RELOC_16
;
3620 code
= BFD_RELOC_26
;
3623 code
= BFD_RELOC_32
;
3626 code
= BFD_RELOC_64
;
3632 howto
= bfd_reloc_type_lookup (abfd
, code
);
3636 areloc
->howto
= howto
;
3644 (*_bfd_error_handler
)
3645 ("%s: unsupported relocation type %s",
3646 bfd_get_filename (abfd
), areloc
->howto
->name
);
3647 bfd_set_error (bfd_error_bad_value
);