1 /* ELF executable support for BFD.
2 Copyright 1993 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));
43 static int elf_sort_sections
PARAMS ((const PTR
, const PTR
));
44 static boolean assign_file_positions_for_segments
PARAMS ((bfd
*));
45 static boolean assign_file_positions_except_relocs
PARAMS ((bfd
*));
46 static boolean prep_headers
PARAMS ((bfd
*));
47 static boolean swap_out_syms
PARAMS ((bfd
*, struct bfd_strtab_hash
**));
48 static boolean copy_private_bfd_data
PARAMS ((bfd
*, bfd
*));
50 /* Standard ELF hash function. Do not change this function; you will
51 cause invalid hash tables to be generated. (Well, you would if this
52 were being used yet.) */
55 CONST
unsigned char *name
;
61 while ((ch
= *name
++) != '\0')
64 if ((g
= (h
& 0xf0000000)) != 0)
73 /* Read a specified number of bytes at a specified offset in an ELF
74 file, into a newly allocated buffer, and return a pointer to the
78 elf_read (abfd
, offset
, size
)
85 if ((buf
= bfd_alloc (abfd
, size
)) == NULL
)
87 if (bfd_seek (abfd
, offset
, SEEK_SET
) == -1)
89 if (bfd_read ((PTR
) buf
, size
, 1, abfd
) != size
)
91 if (bfd_get_error () != bfd_error_system_call
)
92 bfd_set_error (bfd_error_file_truncated
);
102 /* this just does initialization */
103 /* coff_mkobject zalloc's space for tdata.coff_obj_data ... */
104 elf_tdata (abfd
) = (struct elf_obj_tdata
*)
105 bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
106 if (elf_tdata (abfd
) == 0)
108 /* since everything is done at close time, do we need any
115 bfd_elf_get_str_section (abfd
, shindex
)
117 unsigned int shindex
;
119 Elf_Internal_Shdr
**i_shdrp
;
120 char *shstrtab
= NULL
;
122 unsigned int shstrtabsize
;
124 i_shdrp
= elf_elfsections (abfd
);
125 if (i_shdrp
== 0 || i_shdrp
[shindex
] == 0)
128 shstrtab
= (char *) i_shdrp
[shindex
]->contents
;
129 if (shstrtab
== NULL
)
131 /* No cached one, attempt to read, and cache what we read. */
132 offset
= i_shdrp
[shindex
]->sh_offset
;
133 shstrtabsize
= i_shdrp
[shindex
]->sh_size
;
134 shstrtab
= elf_read (abfd
, offset
, shstrtabsize
);
135 i_shdrp
[shindex
]->contents
= (PTR
) shstrtab
;
141 bfd_elf_string_from_elf_section (abfd
, shindex
, strindex
)
143 unsigned int shindex
;
144 unsigned int strindex
;
146 Elf_Internal_Shdr
*hdr
;
151 hdr
= elf_elfsections (abfd
)[shindex
];
153 if (hdr
->contents
== NULL
154 && bfd_elf_get_str_section (abfd
, shindex
) == NULL
)
157 return ((char *) hdr
->contents
) + strindex
;
160 /* Make a BFD section from an ELF section. We store a pointer to the
161 BFD section in the bfd_section field of the header. */
164 _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
)
166 Elf_Internal_Shdr
*hdr
;
172 if (hdr
->bfd_section
!= NULL
)
174 BFD_ASSERT (strcmp (name
,
175 bfd_get_section_name (abfd
, hdr
->bfd_section
)) == 0);
179 newsect
= bfd_make_section_anyway (abfd
, name
);
183 newsect
->filepos
= hdr
->sh_offset
;
185 if (! bfd_set_section_vma (abfd
, newsect
, hdr
->sh_addr
)
186 || ! bfd_set_section_size (abfd
, newsect
, hdr
->sh_size
)
187 || ! bfd_set_section_alignment (abfd
, newsect
,
188 bfd_log2 (hdr
->sh_addralign
)))
191 flags
= SEC_NO_FLAGS
;
192 if (hdr
->sh_type
!= SHT_NOBITS
)
193 flags
|= SEC_HAS_CONTENTS
;
194 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
197 if (hdr
->sh_type
!= SHT_NOBITS
)
200 if ((hdr
->sh_flags
& SHF_WRITE
) == 0)
201 flags
|= SEC_READONLY
;
202 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
204 else if ((flags
& SEC_LOAD
) != 0)
207 /* The debugging sections appear to be recognized only by name, not
209 if (strncmp (name
, ".debug", sizeof ".debug" - 1) == 0
210 || strncmp (name
, ".line", sizeof ".line" - 1) == 0
211 || strncmp (name
, ".stab", sizeof ".stab" - 1) == 0)
212 flags
|= SEC_DEBUGGING
;
214 if (! bfd_set_section_flags (abfd
, newsect
, flags
))
217 if ((flags
& SEC_ALLOC
) != 0)
219 Elf_Internal_Phdr
*phdr
;
222 /* Look through the phdrs to see if we need to adjust the lma. */
223 phdr
= elf_tdata (abfd
)->phdr
;
224 for (i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
226 if (phdr
->p_type
== PT_LOAD
227 && phdr
->p_paddr
!= 0
228 && phdr
->p_vaddr
!= phdr
->p_paddr
229 && phdr
->p_vaddr
<= hdr
->sh_addr
230 && phdr
->p_vaddr
+ phdr
->p_memsz
>= hdr
->sh_addr
+ hdr
->sh_size
)
232 newsect
->lma
+= phdr
->p_paddr
- phdr
->p_vaddr
;
238 hdr
->bfd_section
= newsect
;
239 elf_section_data (newsect
)->this_hdr
= *hdr
;
249 struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name);
252 Helper functions for GDB to locate the string tables.
253 Since BFD hides string tables from callers, GDB needs to use an
254 internal hook to find them. Sun's .stabstr, in particular,
255 isn't even pointed to by the .stab section, so ordinary
256 mechanisms wouldn't work to find it, even if we had some.
259 struct elf_internal_shdr
*
260 bfd_elf_find_section (abfd
, name
)
264 Elf_Internal_Shdr
**i_shdrp
;
269 i_shdrp
= elf_elfsections (abfd
);
272 shstrtab
= bfd_elf_get_str_section (abfd
, elf_elfheader (abfd
)->e_shstrndx
);
273 if (shstrtab
!= NULL
)
275 max
= elf_elfheader (abfd
)->e_shnum
;
276 for (i
= 1; i
< max
; i
++)
277 if (!strcmp (&shstrtab
[i_shdrp
[i
]->sh_name
], name
))
284 const char *const bfd_elf_section_type_names
[] = {
285 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
286 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
287 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
290 /* ELF relocs are against symbols. If we are producing relocateable
291 output, and the reloc is against an external symbol, and nothing
292 has given us any additional addend, the resulting reloc will also
293 be against the same symbol. In such a case, we don't want to
294 change anything about the way the reloc is handled, since it will
295 all be done at final link time. Rather than put special case code
296 into bfd_perform_relocation, all the reloc types use this howto
297 function. It just short circuits the reloc if producing
298 relocateable output against an external symbol. */
301 bfd_reloc_status_type
302 bfd_elf_generic_reloc (abfd
,
310 arelent
*reloc_entry
;
313 asection
*input_section
;
315 char **error_message
;
317 if (output_bfd
!= (bfd
*) NULL
318 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
319 && (! reloc_entry
->howto
->partial_inplace
320 || reloc_entry
->addend
== 0))
322 reloc_entry
->address
+= input_section
->output_offset
;
326 return bfd_reloc_continue
;
329 /* Print out the program headers. */
332 _bfd_elf_print_private_bfd_data (abfd
, farg
)
336 FILE *f
= (FILE *) farg
;
337 Elf_Internal_Phdr
*p
;
339 bfd_byte
*dynbuf
= NULL
;
341 p
= elf_tdata (abfd
)->phdr
;
346 fprintf (f
, "\nProgram Header:\n");
347 c
= elf_elfheader (abfd
)->e_phnum
;
348 for (i
= 0; i
< c
; i
++, p
++)
355 case PT_NULL
: s
= "NULL"; break;
356 case PT_LOAD
: s
= "LOAD"; break;
357 case PT_DYNAMIC
: s
= "DYNAMIC"; break;
358 case PT_INTERP
: s
= "INTERP"; break;
359 case PT_NOTE
: s
= "NOTE"; break;
360 case PT_SHLIB
: s
= "SHLIB"; break;
361 case PT_PHDR
: s
= "PHDR"; break;
362 default: sprintf (buf
, "0x%lx", p
->p_type
); s
= buf
; break;
364 fprintf (f
, "%8s off 0x", s
);
365 fprintf_vma (f
, p
->p_offset
);
366 fprintf (f
, " vaddr 0x");
367 fprintf_vma (f
, p
->p_vaddr
);
368 fprintf (f
, " paddr 0x");
369 fprintf_vma (f
, p
->p_paddr
);
370 fprintf (f
, " align 2**%u\n", bfd_log2 (p
->p_align
));
371 fprintf (f
, " filesz 0x");
372 fprintf_vma (f
, p
->p_filesz
);
373 fprintf (f
, " memsz 0x");
374 fprintf_vma (f
, p
->p_memsz
);
375 fprintf (f
, " flags %c%c%c",
376 (p
->p_flags
& PF_R
) != 0 ? 'r' : '-',
377 (p
->p_flags
& PF_W
) != 0 ? 'w' : '-',
378 (p
->p_flags
& PF_X
) != 0 ? 'x' : '-');
379 if ((p
->p_flags
&~ (PF_R
| PF_W
| PF_X
)) != 0)
380 fprintf (f
, " %lx", p
->p_flags
&~ (PF_R
| PF_W
| PF_X
));
385 s
= bfd_get_section_by_name (abfd
, ".dynamic");
390 bfd_byte
*extdyn
, *extdynend
;
392 void (*swap_dyn_in
) PARAMS ((bfd
*, const PTR
, Elf_Internal_Dyn
*));
394 fprintf (f
, "\nDynamic Section:\n");
396 dynbuf
= (bfd_byte
*) bfd_malloc (s
->_raw_size
);
399 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
, (file_ptr
) 0,
403 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
406 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
408 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
409 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
412 extdynend
= extdyn
+ s
->_raw_size
;
413 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
415 Elf_Internal_Dyn dyn
;
420 (*swap_dyn_in
) (abfd
, (PTR
) extdyn
, &dyn
);
422 if (dyn
.d_tag
== DT_NULL
)
429 sprintf (ab
, "0x%lx", (unsigned long) dyn
.d_tag
);
433 case DT_NEEDED
: name
= "NEEDED"; stringp
= true; break;
434 case DT_PLTRELSZ
: name
= "PLTRELSZ"; break;
435 case DT_PLTGOT
: name
= "PLTGOT"; break;
436 case DT_HASH
: name
= "HASH"; break;
437 case DT_STRTAB
: name
= "STRTAB"; break;
438 case DT_SYMTAB
: name
= "SYMTAB"; break;
439 case DT_RELA
: name
= "RELA"; break;
440 case DT_RELASZ
: name
= "RELASZ"; break;
441 case DT_RELAENT
: name
= "RELAENT"; break;
442 case DT_STRSZ
: name
= "STRSZ"; break;
443 case DT_SYMENT
: name
= "SYMENT"; break;
444 case DT_INIT
: name
= "INIT"; break;
445 case DT_FINI
: name
= "FINI"; break;
446 case DT_SONAME
: name
= "SONAME"; stringp
= true; break;
447 case DT_RPATH
: name
= "RPATH"; stringp
= true; break;
448 case DT_SYMBOLIC
: name
= "SYMBOLIC"; break;
449 case DT_REL
: name
= "REL"; break;
450 case DT_RELSZ
: name
= "RELSZ"; break;
451 case DT_RELENT
: name
= "RELENT"; break;
452 case DT_PLTREL
: name
= "PLTREL"; break;
453 case DT_DEBUG
: name
= "DEBUG"; break;
454 case DT_TEXTREL
: name
= "TEXTREL"; break;
455 case DT_JMPREL
: name
= "JMPREL"; break;
458 fprintf (f
, " %-11s ", name
);
460 fprintf (f
, "0x%lx", (unsigned long) dyn
.d_un
.d_val
);
465 string
= bfd_elf_string_from_elf_section (abfd
, link
,
469 fprintf (f
, "%s", string
);
486 /* Display ELF-specific fields of a symbol. */
488 bfd_elf_print_symbol (ignore_abfd
, filep
, symbol
, how
)
492 bfd_print_symbol_type how
;
494 FILE *file
= (FILE *) filep
;
497 case bfd_print_symbol_name
:
498 fprintf (file
, "%s", symbol
->name
);
500 case bfd_print_symbol_more
:
501 fprintf (file
, "elf ");
502 fprintf_vma (file
, symbol
->value
);
503 fprintf (file
, " %lx", (long) symbol
->flags
);
505 case bfd_print_symbol_all
:
507 CONST
char *section_name
;
508 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
509 bfd_print_symbol_vandf ((PTR
) file
, symbol
);
510 fprintf (file
, " %s\t", section_name
);
511 /* Print the "other" value for a symbol. For common symbols,
512 we've already printed the size; now print the alignment.
513 For other symbols, we have no specified alignment, and
514 we've printed the address; now print the size. */
516 (bfd_is_com_section (symbol
->section
)
517 ? ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_value
518 : ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_size
));
519 fprintf (file
, " %s", symbol
->name
);
525 /* Create an entry in an ELF linker hash table. */
527 struct bfd_hash_entry
*
528 _bfd_elf_link_hash_newfunc (entry
, table
, string
)
529 struct bfd_hash_entry
*entry
;
530 struct bfd_hash_table
*table
;
533 struct elf_link_hash_entry
*ret
= (struct elf_link_hash_entry
*) entry
;
535 /* Allocate the structure if it has not already been allocated by a
537 if (ret
== (struct elf_link_hash_entry
*) NULL
)
538 ret
= ((struct elf_link_hash_entry
*)
539 bfd_hash_allocate (table
, sizeof (struct elf_link_hash_entry
)));
540 if (ret
== (struct elf_link_hash_entry
*) NULL
)
541 return (struct bfd_hash_entry
*) ret
;
543 /* Call the allocation method of the superclass. */
544 ret
= ((struct elf_link_hash_entry
*)
545 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
547 if (ret
!= (struct elf_link_hash_entry
*) NULL
)
549 /* Set local fields. */
553 ret
->dynstr_index
= 0;
555 ret
->got_offset
= (bfd_vma
) -1;
556 ret
->plt_offset
= (bfd_vma
) -1;
557 ret
->type
= STT_NOTYPE
;
558 ret
->elf_link_hash_flags
= 0;
561 return (struct bfd_hash_entry
*) ret
;
564 /* Initialize an ELF linker hash table. */
567 _bfd_elf_link_hash_table_init (table
, abfd
, newfunc
)
568 struct elf_link_hash_table
*table
;
570 struct bfd_hash_entry
*(*newfunc
) PARAMS ((struct bfd_hash_entry
*,
571 struct bfd_hash_table
*,
574 table
->dynamic_sections_created
= false;
575 table
->dynobj
= NULL
;
576 /* The first dynamic symbol is a dummy. */
577 table
->dynsymcount
= 1;
578 table
->dynstr
= NULL
;
579 table
->bucketcount
= 0;
580 table
->needed
= NULL
;
581 return _bfd_link_hash_table_init (&table
->root
, abfd
, newfunc
);
584 /* Create an ELF linker hash table. */
586 struct bfd_link_hash_table
*
587 _bfd_elf_link_hash_table_create (abfd
)
590 struct elf_link_hash_table
*ret
;
592 ret
= ((struct elf_link_hash_table
*)
593 bfd_alloc (abfd
, sizeof (struct elf_link_hash_table
)));
594 if (ret
== (struct elf_link_hash_table
*) NULL
)
597 if (! _bfd_elf_link_hash_table_init (ret
, abfd
, _bfd_elf_link_hash_newfunc
))
599 bfd_release (abfd
, ret
);
606 /* This is a hook for the ELF emulation code in the generic linker to
607 tell the backend linker what file name to use for the DT_NEEDED
608 entry for a dynamic object. The generic linker passes name as an
609 empty string to indicate that no DT_NEEDED entry should be made. */
612 bfd_elf_set_dt_needed_name (abfd
, name
)
616 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
617 elf_dt_needed_name (abfd
) = name
;
620 /* Get the list of DT_NEEDED entries for a link. */
622 struct bfd_link_needed_list
*
623 bfd_elf_get_needed_list (abfd
, info
)
625 struct bfd_link_info
*info
;
627 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
629 return elf_hash_table (info
)->needed
;
632 /* Allocate an ELF string table--force the first byte to be zero. */
634 struct bfd_strtab_hash
*
635 _bfd_elf_stringtab_init ()
637 struct bfd_strtab_hash
*ret
;
639 ret
= _bfd_stringtab_init ();
644 loc
= _bfd_stringtab_add (ret
, "", true, false);
645 BFD_ASSERT (loc
== 0 || loc
== (bfd_size_type
) -1);
646 if (loc
== (bfd_size_type
) -1)
648 _bfd_stringtab_free (ret
);
655 /* ELF .o/exec file reading */
657 /* Create a new bfd section from an ELF section header. */
660 bfd_section_from_shdr (abfd
, shindex
)
662 unsigned int shindex
;
664 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[shindex
];
665 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
666 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
669 name
= elf_string_from_elf_strtab (abfd
, hdr
->sh_name
);
671 switch (hdr
->sh_type
)
674 /* Inactive section. Throw it away. */
677 case SHT_PROGBITS
: /* Normal section with contents. */
678 case SHT_DYNAMIC
: /* Dynamic linking information. */
679 case SHT_NOBITS
: /* .bss section. */
680 case SHT_HASH
: /* .hash section. */
681 case SHT_NOTE
: /* .note section. */
682 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
684 case SHT_SYMTAB
: /* A symbol table */
685 if (elf_onesymtab (abfd
) == shindex
)
688 BFD_ASSERT (hdr
->sh_entsize
== bed
->s
->sizeof_sym
);
689 BFD_ASSERT (elf_onesymtab (abfd
) == 0);
690 elf_onesymtab (abfd
) = shindex
;
691 elf_tdata (abfd
)->symtab_hdr
= *hdr
;
692 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->symtab_hdr
;
693 abfd
->flags
|= HAS_SYMS
;
695 /* Sometimes a shared object will map in the symbol table. If
696 SHF_ALLOC is set, and this is a shared object, then we also
697 treat this section as a BFD section. We can not base the
698 decision purely on SHF_ALLOC, because that flag is sometimes
699 set in a relocateable object file, which would confuse the
701 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
702 && (abfd
->flags
& DYNAMIC
) != 0
703 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
708 case SHT_DYNSYM
: /* A dynamic symbol table */
709 if (elf_dynsymtab (abfd
) == shindex
)
712 BFD_ASSERT (hdr
->sh_entsize
== bed
->s
->sizeof_sym
);
713 BFD_ASSERT (elf_dynsymtab (abfd
) == 0);
714 elf_dynsymtab (abfd
) = shindex
;
715 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
716 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
717 abfd
->flags
|= HAS_SYMS
;
719 /* Besides being a symbol table, we also treat this as a regular
720 section, so that objcopy can handle it. */
721 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
723 case SHT_STRTAB
: /* A string table */
724 if (hdr
->bfd_section
!= NULL
)
726 if (ehdr
->e_shstrndx
== shindex
)
728 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
729 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
735 for (i
= 1; i
< ehdr
->e_shnum
; i
++)
737 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
738 if (hdr2
->sh_link
== shindex
)
740 if (! bfd_section_from_shdr (abfd
, i
))
742 if (elf_onesymtab (abfd
) == i
)
744 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
745 elf_elfsections (abfd
)[shindex
] =
746 &elf_tdata (abfd
)->strtab_hdr
;
749 if (elf_dynsymtab (abfd
) == i
)
751 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
752 elf_elfsections (abfd
)[shindex
] = hdr
=
753 &elf_tdata (abfd
)->dynstrtab_hdr
;
754 /* We also treat this as a regular section, so
755 that objcopy can handle it. */
758 #if 0 /* Not handling other string tables specially right now. */
759 hdr2
= elf_elfsections (abfd
)[i
]; /* in case it moved */
760 /* We have a strtab for some random other section. */
761 newsect
= (asection
*) hdr2
->bfd_section
;
764 hdr
->bfd_section
= newsect
;
765 hdr2
= &elf_section_data (newsect
)->str_hdr
;
767 elf_elfsections (abfd
)[shindex
] = hdr2
;
773 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
777 /* *These* do a lot of work -- but build no sections! */
779 asection
*target_sect
;
780 Elf_Internal_Shdr
*hdr2
;
781 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
783 /* For some incomprehensible reason Oracle distributes
784 libraries for Solaris in which some of the objects have
785 bogus sh_link fields. It would be nice if we could just
786 reject them, but, unfortunately, some people need to use
787 them. We scan through the section headers; if we find only
788 one suitable symbol table, we clobber the sh_link to point
789 to it. I hope this doesn't break anything. */
790 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_SYMTAB
791 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_DYNSYM
)
797 for (scan
= 1; scan
< ehdr
->e_shnum
; scan
++)
799 if (elf_elfsections (abfd
)[scan
]->sh_type
== SHT_SYMTAB
800 || elf_elfsections (abfd
)[scan
]->sh_type
== SHT_DYNSYM
)
811 hdr
->sh_link
= found
;
814 /* Get the symbol table. */
815 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_SYMTAB
816 && ! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
819 /* If this reloc section does not use the main symbol table we
820 don't treat it as a reloc section. BFD can't adequately
821 represent such a section, so at least for now, we don't
822 try. We just present it as a normal section. */
823 if (hdr
->sh_link
!= elf_onesymtab (abfd
))
824 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
826 /* Don't allow REL relocations on a machine that uses RELA and
828 /* @@ Actually, the generic ABI does suggest that both might be
829 used in one file. But the four ABI Processor Supplements I
830 have access to right now all specify that only one is used on
831 each of those architectures. It's conceivable that, e.g., a
832 bunch of absolute 32-bit relocs might be more compact in REL
833 form even on a RELA machine... */
834 BFD_ASSERT (use_rela_p
835 ? (hdr
->sh_type
== SHT_RELA
836 && hdr
->sh_entsize
== bed
->s
->sizeof_rela
)
837 : (hdr
->sh_type
== SHT_REL
838 && hdr
->sh_entsize
== bed
->s
->sizeof_rel
));
840 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
842 target_sect
= bfd_section_from_elf_index (abfd
, hdr
->sh_info
);
843 if (target_sect
== NULL
)
846 hdr2
= &elf_section_data (target_sect
)->rel_hdr
;
848 elf_elfsections (abfd
)[shindex
] = hdr2
;
849 target_sect
->reloc_count
= hdr
->sh_size
/ hdr
->sh_entsize
;
850 target_sect
->flags
|= SEC_RELOC
;
851 target_sect
->relocation
= NULL
;
852 target_sect
->rel_filepos
= hdr
->sh_offset
;
853 abfd
->flags
|= HAS_RELOC
;
862 /* Check for any processor-specific section types. */
864 if (bed
->elf_backend_section_from_shdr
)
865 (*bed
->elf_backend_section_from_shdr
) (abfd
, hdr
, name
);
873 /* Given an ELF section number, retrieve the corresponding BFD
877 bfd_section_from_elf_index (abfd
, index
)
881 BFD_ASSERT (index
> 0 && index
< SHN_LORESERVE
);
882 if (index
>= elf_elfheader (abfd
)->e_shnum
)
884 return elf_elfsections (abfd
)[index
]->bfd_section
;
888 _bfd_elf_new_section_hook (abfd
, sec
)
892 struct bfd_elf_section_data
*sdata
;
894 sdata
= (struct bfd_elf_section_data
*) bfd_alloc (abfd
, sizeof (*sdata
));
897 sec
->used_by_bfd
= (PTR
) sdata
;
898 memset (sdata
, 0, sizeof (*sdata
));
902 /* Create a new bfd section from an ELF program header.
904 Since program segments have no names, we generate a synthetic name
905 of the form segment<NUM>, where NUM is generally the index in the
906 program header table. For segments that are split (see below) we
907 generate the names segment<NUM>a and segment<NUM>b.
909 Note that some program segments may have a file size that is different than
910 (less than) the memory size. All this means is that at execution the
911 system must allocate the amount of memory specified by the memory size,
912 but only initialize it with the first "file size" bytes read from the
913 file. This would occur for example, with program segments consisting
914 of combined data+bss.
916 To handle the above situation, this routine generates TWO bfd sections
917 for the single program segment. The first has the length specified by
918 the file size of the segment, and the second has the length specified
919 by the difference between the two sizes. In effect, the segment is split
920 into it's initialized and uninitialized parts.
925 bfd_section_from_phdr (abfd
, hdr
, index
)
927 Elf_Internal_Phdr
*hdr
;
935 split
= ((hdr
->p_memsz
> 0) &&
936 (hdr
->p_filesz
> 0) &&
937 (hdr
->p_memsz
> hdr
->p_filesz
));
938 sprintf (namebuf
, split
? "segment%da" : "segment%d", index
);
939 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
942 strcpy (name
, namebuf
);
943 newsect
= bfd_make_section (abfd
, name
);
946 newsect
->vma
= hdr
->p_vaddr
;
947 newsect
->lma
= hdr
->p_paddr
;
948 newsect
->_raw_size
= hdr
->p_filesz
;
949 newsect
->filepos
= hdr
->p_offset
;
950 newsect
->flags
|= SEC_HAS_CONTENTS
;
951 if (hdr
->p_type
== PT_LOAD
)
953 newsect
->flags
|= SEC_ALLOC
;
954 newsect
->flags
|= SEC_LOAD
;
955 if (hdr
->p_flags
& PF_X
)
957 /* FIXME: all we known is that it has execute PERMISSION,
959 newsect
->flags
|= SEC_CODE
;
962 if (!(hdr
->p_flags
& PF_W
))
964 newsect
->flags
|= SEC_READONLY
;
969 sprintf (namebuf
, "segment%db", index
);
970 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
973 strcpy (name
, namebuf
);
974 newsect
= bfd_make_section (abfd
, name
);
977 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
978 newsect
->lma
= hdr
->p_paddr
+ hdr
->p_filesz
;
979 newsect
->_raw_size
= hdr
->p_memsz
- hdr
->p_filesz
;
980 if (hdr
->p_type
== PT_LOAD
)
982 newsect
->flags
|= SEC_ALLOC
;
983 if (hdr
->p_flags
& PF_X
)
984 newsect
->flags
|= SEC_CODE
;
986 if (!(hdr
->p_flags
& PF_W
))
987 newsect
->flags
|= SEC_READONLY
;
993 /* Set up an ELF internal section header for a section. */
997 elf_fake_sections (abfd
, asect
, failedptrarg
)
1002 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1003 boolean
*failedptr
= (boolean
*) failedptrarg
;
1004 Elf_Internal_Shdr
*this_hdr
;
1008 /* We already failed; just get out of the bfd_map_over_sections
1013 this_hdr
= &elf_section_data (asect
)->this_hdr
;
1015 this_hdr
->sh_name
= (unsigned long) _bfd_stringtab_add (elf_shstrtab (abfd
),
1018 if (this_hdr
->sh_name
== (unsigned long) -1)
1024 this_hdr
->sh_flags
= 0;
1026 if ((asect
->flags
& SEC_ALLOC
) != 0)
1027 this_hdr
->sh_addr
= asect
->vma
;
1029 this_hdr
->sh_addr
= 0;
1031 this_hdr
->sh_offset
= 0;
1032 this_hdr
->sh_size
= asect
->_raw_size
;
1033 this_hdr
->sh_link
= 0;
1034 this_hdr
->sh_addralign
= 1 << asect
->alignment_power
;
1035 /* The sh_entsize and sh_info fields may have been set already by
1036 copy_private_section_data. */
1038 this_hdr
->bfd_section
= asect
;
1039 this_hdr
->contents
= NULL
;
1041 /* FIXME: This should not be based on section names. */
1042 if (strcmp (asect
->name
, ".dynstr") == 0)
1043 this_hdr
->sh_type
= SHT_STRTAB
;
1044 else if (strcmp (asect
->name
, ".hash") == 0)
1046 this_hdr
->sh_type
= SHT_HASH
;
1047 this_hdr
->sh_entsize
= bed
->s
->arch_size
/ 8;
1049 else if (strcmp (asect
->name
, ".dynsym") == 0)
1051 this_hdr
->sh_type
= SHT_DYNSYM
;
1052 this_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
1054 else if (strcmp (asect
->name
, ".dynamic") == 0)
1056 this_hdr
->sh_type
= SHT_DYNAMIC
;
1057 this_hdr
->sh_entsize
= bed
->s
->sizeof_dyn
;
1059 else if (strncmp (asect
->name
, ".rela", 5) == 0
1060 && get_elf_backend_data (abfd
)->use_rela_p
)
1062 this_hdr
->sh_type
= SHT_RELA
;
1063 this_hdr
->sh_entsize
= bed
->s
->sizeof_rela
;
1065 else if (strncmp (asect
->name
, ".rel", 4) == 0
1066 && ! get_elf_backend_data (abfd
)->use_rela_p
)
1068 this_hdr
->sh_type
= SHT_REL
;
1069 this_hdr
->sh_entsize
= bed
->s
->sizeof_rel
;
1071 else if (strcmp (asect
->name
, ".note") == 0)
1072 this_hdr
->sh_type
= SHT_NOTE
;
1073 else if (strncmp (asect
->name
, ".stab", 5) == 0
1074 && strcmp (asect
->name
+ strlen (asect
->name
) - 3, "str") == 0)
1075 this_hdr
->sh_type
= SHT_STRTAB
;
1076 else if ((asect
->flags
& SEC_ALLOC
) != 0
1077 && (asect
->flags
& SEC_LOAD
) != 0)
1078 this_hdr
->sh_type
= SHT_PROGBITS
;
1079 else if ((asect
->flags
& SEC_ALLOC
) != 0
1080 && ((asect
->flags
& SEC_LOAD
) == 0))
1081 this_hdr
->sh_type
= SHT_NOBITS
;
1085 this_hdr
->sh_type
= SHT_PROGBITS
;
1088 if ((asect
->flags
& SEC_ALLOC
) != 0)
1089 this_hdr
->sh_flags
|= SHF_ALLOC
;
1090 if ((asect
->flags
& SEC_READONLY
) == 0)
1091 this_hdr
->sh_flags
|= SHF_WRITE
;
1092 if ((asect
->flags
& SEC_CODE
) != 0)
1093 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
1095 /* Check for processor-specific section types. */
1097 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1099 if (bed
->elf_backend_fake_sections
)
1100 (*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
);
1103 /* If the section has relocs, set up a section header for the
1104 SHT_REL[A] section. */
1105 if ((asect
->flags
& SEC_RELOC
) != 0)
1107 Elf_Internal_Shdr
*rela_hdr
;
1108 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1111 rela_hdr
= &elf_section_data (asect
)->rel_hdr
;
1112 name
= bfd_alloc (abfd
, sizeof ".rela" + strlen (asect
->name
));
1118 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", asect
->name
);
1120 (unsigned int) _bfd_stringtab_add (elf_shstrtab (abfd
), name
,
1122 if (rela_hdr
->sh_name
== (unsigned int) -1)
1127 rela_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
1128 rela_hdr
->sh_entsize
= (use_rela_p
1129 ? bed
->s
->sizeof_rela
1130 : bed
->s
->sizeof_rel
);
1131 rela_hdr
->sh_addralign
= bed
->s
->file_align
;
1132 rela_hdr
->sh_flags
= 0;
1133 rela_hdr
->sh_addr
= 0;
1134 rela_hdr
->sh_size
= 0;
1135 rela_hdr
->sh_offset
= 0;
1139 /* Assign all ELF section numbers. The dummy first section is handled here
1140 too. The link/info pointers for the standard section types are filled
1141 in here too, while we're at it. */
1144 assign_section_numbers (abfd
)
1147 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
1149 unsigned int section_number
;
1150 Elf_Internal_Shdr
**i_shdrp
;
1151 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1155 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1157 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1159 d
->this_idx
= section_number
++;
1160 if ((sec
->flags
& SEC_RELOC
) == 0)
1163 d
->rel_idx
= section_number
++;
1166 t
->shstrtab_section
= section_number
++;
1167 elf_elfheader (abfd
)->e_shstrndx
= t
->shstrtab_section
;
1168 t
->shstrtab_hdr
.sh_size
= _bfd_stringtab_size (elf_shstrtab (abfd
));
1170 if (abfd
->symcount
> 0)
1172 t
->symtab_section
= section_number
++;
1173 t
->strtab_section
= section_number
++;
1176 elf_elfheader (abfd
)->e_shnum
= section_number
;
1178 /* Set up the list of section header pointers, in agreement with the
1180 i_shdrp
= ((Elf_Internal_Shdr
**)
1181 bfd_alloc (abfd
, section_number
* sizeof (Elf_Internal_Shdr
*)));
1182 if (i_shdrp
== NULL
)
1185 i_shdrp
[0] = ((Elf_Internal_Shdr
*)
1186 bfd_alloc (abfd
, sizeof (Elf_Internal_Shdr
)));
1187 if (i_shdrp
[0] == NULL
)
1189 bfd_release (abfd
, i_shdrp
);
1192 memset (i_shdrp
[0], 0, sizeof (Elf_Internal_Shdr
));
1194 elf_elfsections (abfd
) = i_shdrp
;
1196 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
1197 if (abfd
->symcount
> 0)
1199 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
1200 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
1201 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
1203 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1205 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1209 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
1210 if (d
->rel_idx
!= 0)
1211 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
1213 /* Fill in the sh_link and sh_info fields while we're at it. */
1215 /* sh_link of a reloc section is the section index of the symbol
1216 table. sh_info is the section index of the section to which
1217 the relocation entries apply. */
1218 if (d
->rel_idx
!= 0)
1220 d
->rel_hdr
.sh_link
= t
->symtab_section
;
1221 d
->rel_hdr
.sh_info
= d
->this_idx
;
1224 switch (d
->this_hdr
.sh_type
)
1228 /* A reloc section which we are treating as a normal BFD
1229 section. sh_link is the section index of the symbol
1230 table. sh_info is the section index of the section to
1231 which the relocation entries apply. We assume that an
1232 allocated reloc section uses the dynamic symbol table.
1233 FIXME: How can we be sure? */
1234 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1236 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1238 /* We look up the section the relocs apply to by name. */
1240 if (d
->this_hdr
.sh_type
== SHT_REL
)
1244 s
= bfd_get_section_by_name (abfd
, name
);
1246 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
1250 /* We assume that a section named .stab*str is a stabs
1251 string section. We look for a section with the same name
1252 but without the trailing ``str'', and set its sh_link
1253 field to point to this section. */
1254 if (strncmp (sec
->name
, ".stab", sizeof ".stab" - 1) == 0
1255 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
1260 len
= strlen (sec
->name
);
1261 alc
= (char *) bfd_malloc (len
- 2);
1264 strncpy (alc
, sec
->name
, len
- 3);
1265 alc
[len
- 3] = '\0';
1266 s
= bfd_get_section_by_name (abfd
, alc
);
1270 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
1272 /* This is a .stab section. */
1273 elf_section_data (s
)->this_hdr
.sh_entsize
=
1274 4 + 2 * (bed
->s
->arch_size
/ 8);
1281 /* sh_link is the section header index of the string table
1282 used for the dynamic entries or symbol table. */
1283 s
= bfd_get_section_by_name (abfd
, ".dynstr");
1285 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1289 /* sh_link is the section header index of the symbol table
1290 this hash table is for. */
1291 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1293 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1301 /* Map symbol from it's internal number to the external number, moving
1302 all local symbols to be at the head of the list. */
1305 sym_is_global (abfd
, sym
)
1309 /* If the backend has a special mapping, use it. */
1310 if (get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1311 return ((*get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1314 return ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
1315 || bfd_is_und_section (bfd_get_section (sym
))
1316 || bfd_is_com_section (bfd_get_section (sym
)));
1320 elf_map_symbols (abfd
)
1323 int symcount
= bfd_get_symcount (abfd
);
1324 asymbol
**syms
= bfd_get_outsymbols (abfd
);
1325 asymbol
**sect_syms
;
1327 int num_globals
= 0;
1328 int num_locals2
= 0;
1329 int num_globals2
= 0;
1331 int num_sections
= 0;
1337 fprintf (stderr
, "elf_map_symbols\n");
1341 /* Add a section symbol for each BFD section. FIXME: Is this really
1343 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1345 if (max_index
< asect
->index
)
1346 max_index
= asect
->index
;
1350 sect_syms
= (asymbol
**) bfd_zalloc (abfd
, max_index
* sizeof (asymbol
*));
1351 if (sect_syms
== NULL
)
1353 elf_section_syms (abfd
) = sect_syms
;
1355 for (idx
= 0; idx
< symcount
; idx
++)
1357 if ((syms
[idx
]->flags
& BSF_SECTION_SYM
) != 0
1358 && (syms
[idx
]->value
+ syms
[idx
]->section
->vma
) == 0)
1362 sec
= syms
[idx
]->section
;
1363 if (sec
->owner
!= NULL
)
1365 if (sec
->owner
!= abfd
)
1367 if (sec
->output_offset
!= 0)
1369 sec
= sec
->output_section
;
1370 BFD_ASSERT (sec
->owner
== abfd
);
1372 sect_syms
[sec
->index
] = syms
[idx
];
1377 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1381 if (sect_syms
[asect
->index
] != NULL
)
1384 sym
= bfd_make_empty_symbol (abfd
);
1387 sym
->the_bfd
= abfd
;
1388 sym
->name
= asect
->name
;
1390 /* Set the flags to 0 to indicate that this one was newly added. */
1392 sym
->section
= asect
;
1393 sect_syms
[asect
->index
] = sym
;
1397 "creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n",
1398 asect
->name
, (long) asect
->vma
, asect
->index
, (long) asect
);
1402 /* Classify all of the symbols. */
1403 for (idx
= 0; idx
< symcount
; idx
++)
1405 if (!sym_is_global (abfd
, syms
[idx
]))
1410 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1412 if (sect_syms
[asect
->index
] != NULL
1413 && sect_syms
[asect
->index
]->flags
== 0)
1415 sect_syms
[asect
->index
]->flags
= BSF_SECTION_SYM
;
1416 if (!sym_is_global (abfd
, sect_syms
[asect
->index
]))
1420 sect_syms
[asect
->index
]->flags
= 0;
1424 /* Now sort the symbols so the local symbols are first. */
1425 new_syms
= ((asymbol
**)
1427 (num_locals
+ num_globals
) * sizeof (asymbol
*)));
1428 if (new_syms
== NULL
)
1431 for (idx
= 0; idx
< symcount
; idx
++)
1433 asymbol
*sym
= syms
[idx
];
1436 if (!sym_is_global (abfd
, sym
))
1439 i
= num_locals
+ num_globals2
++;
1441 sym
->udata
.i
= i
+ 1;
1443 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1445 if (sect_syms
[asect
->index
] != NULL
1446 && sect_syms
[asect
->index
]->flags
== 0)
1448 asymbol
*sym
= sect_syms
[asect
->index
];
1451 sym
->flags
= BSF_SECTION_SYM
;
1452 if (!sym_is_global (abfd
, sym
))
1455 i
= num_locals
+ num_globals2
++;
1457 sym
->udata
.i
= i
+ 1;
1461 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
1463 elf_num_locals (abfd
) = num_locals
;
1464 elf_num_globals (abfd
) = num_globals
;
1468 /* Align to the maximum file alignment that could be required for any
1469 ELF data structure. */
1471 static INLINE file_ptr align_file_position
PARAMS ((file_ptr
, int));
1472 static INLINE file_ptr
1473 align_file_position (off
, align
)
1477 return (off
+ align
- 1) & ~(align
- 1);
1480 /* Assign a file position to a section, optionally aligning to the
1481 required section alignment. */
1484 _bfd_elf_assign_file_position_for_section (i_shdrp
, offset
, align
)
1485 Elf_Internal_Shdr
*i_shdrp
;
1493 al
= i_shdrp
->sh_addralign
;
1495 offset
= BFD_ALIGN (offset
, al
);
1497 i_shdrp
->sh_offset
= offset
;
1498 if (i_shdrp
->bfd_section
!= NULL
)
1499 i_shdrp
->bfd_section
->filepos
= offset
;
1500 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
1501 offset
+= i_shdrp
->sh_size
;
1505 /* Compute the file positions we are going to put the sections at, and
1506 otherwise prepare to begin writing out the ELF file. If LINK_INFO
1507 is not NULL, this is being called by the ELF backend linker. */
1510 _bfd_elf_compute_section_file_positions (abfd
, link_info
)
1512 struct bfd_link_info
*link_info
;
1514 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1516 struct bfd_strtab_hash
*strtab
;
1517 Elf_Internal_Shdr
*shstrtab_hdr
;
1519 if (abfd
->output_has_begun
)
1522 /* Do any elf backend specific processing first. */
1523 if (bed
->elf_backend_begin_write_processing
)
1524 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
1526 if (! prep_headers (abfd
))
1530 bfd_map_over_sections (abfd
, elf_fake_sections
, &failed
);
1534 if (!assign_section_numbers (abfd
))
1537 /* The backend linker builds symbol table information itself. */
1538 if (link_info
== NULL
&& abfd
->symcount
> 0)
1540 if (! swap_out_syms (abfd
, &strtab
))
1544 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
1545 /* sh_name was set in prep_headers. */
1546 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
1547 shstrtab_hdr
->sh_flags
= 0;
1548 shstrtab_hdr
->sh_addr
= 0;
1549 shstrtab_hdr
->sh_size
= _bfd_stringtab_size (elf_shstrtab (abfd
));
1550 shstrtab_hdr
->sh_entsize
= 0;
1551 shstrtab_hdr
->sh_link
= 0;
1552 shstrtab_hdr
->sh_info
= 0;
1553 /* sh_offset is set in assign_file_positions_except_relocs. */
1554 shstrtab_hdr
->sh_addralign
= 1;
1556 if (!assign_file_positions_except_relocs (abfd
))
1559 if (link_info
== NULL
&& abfd
->symcount
> 0)
1562 Elf_Internal_Shdr
*hdr
;
1564 off
= elf_tdata (abfd
)->next_file_pos
;
1566 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1567 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
1569 hdr
= &elf_tdata (abfd
)->strtab_hdr
;
1570 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
1572 elf_tdata (abfd
)->next_file_pos
= off
;
1574 /* Now that we know where the .strtab section goes, write it
1576 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
1577 || ! _bfd_stringtab_emit (abfd
, strtab
))
1579 _bfd_stringtab_free (strtab
);
1582 abfd
->output_has_begun
= true;
1587 /* Create a mapping from a set of sections to a program segment. */
1589 static INLINE
struct elf_segment_map
*
1590 make_mapping (abfd
, sections
, from
, to
)
1592 asection
**sections
;
1596 struct elf_segment_map
*m
;
1600 m
= ((struct elf_segment_map
*)
1602 (sizeof (struct elf_segment_map
)
1603 + (to
- from
- 1) * sizeof (asection
*))));
1607 m
->p_type
= PT_LOAD
;
1608 for (i
= from
, hdrpp
= sections
+ from
; i
< to
; i
++, hdrpp
++)
1609 m
->sections
[i
- from
] = *hdrpp
;
1610 m
->count
= to
- from
;
1614 /* Include the headers in the first PT_LOAD segment. */
1615 m
->includes_filehdr
= 1;
1616 m
->includes_phdrs
= 1;
1622 /* Set up a mapping from BFD sections to program segments. */
1625 map_sections_to_segments (abfd
)
1628 asection
**sections
= NULL
;
1632 struct elf_segment_map
*mfirst
;
1633 struct elf_segment_map
**pm
;
1634 struct elf_segment_map
*m
;
1636 unsigned int phdr_index
;
1637 bfd_vma maxpagesize
;
1640 if (elf_tdata (abfd
)->segment_map
!= NULL
)
1643 if (bfd_count_sections (abfd
) == 0)
1646 /* Select the allocated sections, and sort them. */
1648 sections
= (asection
**) bfd_malloc (bfd_count_sections (abfd
)
1649 * sizeof (asection
*));
1650 if (sections
== NULL
)
1654 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
1656 if ((s
->flags
& SEC_ALLOC
) != 0)
1662 BFD_ASSERT (i
<= bfd_count_sections (abfd
));
1665 qsort (sections
, (size_t) count
, sizeof (asection
*), elf_sort_sections
);
1667 /* Build the mapping. */
1672 /* If we have a .interp section, then create a PT_PHDR segment for
1673 the program headers and a PT_INTERP segment for the .interp
1675 s
= bfd_get_section_by_name (abfd
, ".interp");
1676 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
1678 m
= ((struct elf_segment_map
*)
1679 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
1683 m
->p_type
= PT_PHDR
;
1684 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
1685 m
->p_flags
= PF_R
| PF_X
;
1686 m
->p_flags_valid
= 1;
1687 m
->includes_phdrs
= 1;
1692 m
= ((struct elf_segment_map
*)
1693 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
1697 m
->p_type
= PT_INTERP
;
1705 /* Look through the sections. We put sections in the same program
1706 segment when the start of the second section can be placed within
1707 a few bytes of the end of the first section. */
1710 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
1711 for (i
= 0, hdrpp
= sections
; i
< count
; i
++, hdrpp
++)
1717 /* See if this section and the last one will fit in the same
1719 if (last_hdr
== NULL
1720 || ((BFD_ALIGN (last_hdr
->lma
+ last_hdr
->_raw_size
, maxpagesize
)
1722 && ((last_hdr
->flags
& SEC_LOAD
) != 0
1723 || (hdr
->flags
& SEC_LOAD
) == 0)))
1729 /* This section won't fit in the program segment. We must
1730 create a new program header holding all the sections from
1731 phdr_index until hdr. */
1733 m
= make_mapping (abfd
, sections
, phdr_index
, i
);
1744 /* Create a final PT_LOAD program segment. */
1745 if (last_hdr
!= NULL
)
1747 m
= make_mapping (abfd
, sections
, phdr_index
, i
);
1755 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
1756 s
= bfd_get_section_by_name (abfd
, ".dynamic");
1757 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
1759 m
= ((struct elf_segment_map
*)
1760 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
1764 m
->p_type
= PT_DYNAMIC
;
1775 elf_tdata (abfd
)->segment_map
= mfirst
;
1779 if (sections
!= NULL
)
1784 /* Sort sections by VMA. */
1787 elf_sort_sections (arg1
, arg2
)
1791 const asection
*sec1
= *(const asection
**) arg1
;
1792 const asection
*sec2
= *(const asection
**) arg2
;
1794 if (sec1
->vma
< sec2
->vma
)
1796 else if (sec1
->vma
> sec2
->vma
)
1799 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
1801 #define TOEND(x) (((x)->flags & SEC_LOAD) == 0)
1805 return sec1
->target_index
- sec2
->target_index
;
1814 /* Sort by size, to put zero sized sections before others at the
1817 if (sec1
->_raw_size
< sec2
->_raw_size
)
1819 if (sec1
->_raw_size
> sec2
->_raw_size
)
1822 return sec1
->target_index
- sec2
->target_index
;
1825 /* Assign file positions to the sections based on the mapping from
1826 sections to segments. This function also sets up some fields in
1827 the file header, and writes out the program headers. */
1830 assign_file_positions_for_segments (abfd
)
1833 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1835 struct elf_segment_map
*m
;
1837 Elf_Internal_Phdr
*phdrs
;
1839 bfd_vma filehdr_vaddr
, filehdr_paddr
;
1840 bfd_vma phdrs_vaddr
, phdrs_paddr
;
1841 Elf_Internal_Phdr
*p
;
1843 if (elf_tdata (abfd
)->segment_map
== NULL
)
1845 if (! map_sections_to_segments (abfd
))
1849 if (bed
->elf_backend_modify_segment_map
)
1851 if (! (*bed
->elf_backend_modify_segment_map
) (abfd
))
1856 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
1859 elf_elfheader (abfd
)->e_phoff
= bed
->s
->sizeof_ehdr
;
1860 elf_elfheader (abfd
)->e_phentsize
= bed
->s
->sizeof_phdr
;
1861 elf_elfheader (abfd
)->e_phnum
= count
;
1866 /* If we already counted the number of program segments, make sure
1867 that we allocated enough space. This happens when SIZEOF_HEADERS
1868 is used in a linker script. */
1869 alloc
= elf_tdata (abfd
)->program_header_size
/ bed
->s
->sizeof_phdr
;
1870 if (alloc
!= 0 && count
> alloc
)
1872 ((*_bfd_error_handler
)
1873 ("%s: Not enough room for program headers (allocated %u, need %u)",
1874 bfd_get_filename (abfd
), alloc
, count
));
1875 bfd_set_error (bfd_error_bad_value
);
1882 phdrs
= ((Elf_Internal_Phdr
*)
1883 bfd_alloc (abfd
, alloc
* sizeof (Elf_Internal_Phdr
)));
1887 off
= bed
->s
->sizeof_ehdr
;
1888 off
+= alloc
* bed
->s
->sizeof_phdr
;
1894 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
1901 /* If elf_segment_map is not from map_sections_to_segments, the
1902 sections may not be correctly ordered. */
1904 qsort (m
->sections
, (size_t) m
->count
, sizeof (asection
*),
1907 p
->p_type
= m
->p_type
;
1909 if (m
->p_flags_valid
)
1910 p
->p_flags
= m
->p_flags
;
1912 if (p
->p_type
== PT_LOAD
&& m
->count
> 0)
1913 off
+= (m
->sections
[0]->vma
- off
) % bed
->maxpagesize
;
1918 p
->p_vaddr
= m
->sections
[0]->vma
;
1920 if (m
->p_paddr_valid
)
1921 p
->p_paddr
= m
->p_paddr
;
1922 else if (m
->count
== 0)
1925 p
->p_paddr
= m
->sections
[0]->lma
;
1927 if (p
->p_type
== PT_LOAD
)
1928 p
->p_align
= bed
->maxpagesize
;
1929 else if (m
->count
== 0)
1930 p
->p_align
= bed
->s
->file_align
;
1938 if (m
->includes_filehdr
)
1941 p
->p_filesz
= bed
->s
->sizeof_ehdr
;
1942 p
->p_memsz
= bed
->s
->sizeof_ehdr
;
1945 BFD_ASSERT (p
->p_type
== PT_LOAD
);
1947 if (! m
->p_paddr_valid
)
1950 if (p
->p_type
== PT_LOAD
)
1952 filehdr_vaddr
= p
->p_vaddr
;
1953 filehdr_paddr
= p
->p_paddr
;
1957 if (m
->includes_phdrs
)
1959 if (m
->includes_filehdr
)
1961 if (p
->p_type
== PT_LOAD
)
1963 phdrs_vaddr
= p
->p_vaddr
+ bed
->s
->sizeof_ehdr
;
1964 phdrs_paddr
= p
->p_paddr
+ bed
->s
->sizeof_ehdr
;
1969 p
->p_offset
= bed
->s
->sizeof_ehdr
;
1972 BFD_ASSERT (p
->p_type
== PT_LOAD
);
1973 p
->p_vaddr
-= off
- p
->p_offset
;
1974 if (! m
->p_paddr_valid
)
1975 p
->p_paddr
-= off
- p
->p_offset
;
1977 if (p
->p_type
== PT_LOAD
)
1979 phdrs_vaddr
= p
->p_vaddr
;
1980 phdrs_paddr
= p
->p_paddr
;
1983 p
->p_filesz
+= alloc
* bed
->s
->sizeof_phdr
;
1984 p
->p_memsz
+= alloc
* bed
->s
->sizeof_phdr
;
1987 if (p
->p_type
== PT_LOAD
)
1989 if (! m
->includes_filehdr
&& ! m
->includes_phdrs
)
1995 adjust
= off
- (p
->p_offset
+ p
->p_filesz
);
1996 p
->p_filesz
+= adjust
;
1997 p
->p_memsz
+= adjust
;
2001 if (! m
->p_flags_valid
)
2003 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
2007 bfd_size_type align
;
2012 if (p
->p_type
== PT_LOAD
)
2016 /* The section VMA must equal the file position modulo
2018 adjust
= (sec
->vma
- off
) % bed
->maxpagesize
;
2023 p
->p_memsz
+= adjust
;
2024 if ((flags
& SEC_LOAD
) != 0)
2025 p
->p_filesz
+= adjust
;
2031 if ((flags
& SEC_LOAD
) != 0)
2032 off
+= sec
->_raw_size
;
2035 p
->p_memsz
+= sec
->_raw_size
;
2037 if ((flags
& SEC_LOAD
) != 0)
2038 p
->p_filesz
+= sec
->_raw_size
;
2040 align
= 1 << bfd_get_section_alignment (abfd
, sec
);
2041 if (align
> p
->p_align
)
2044 if (! m
->p_flags_valid
)
2046 if ((flags
& SEC_CODE
) != 0)
2048 if ((flags
& SEC_READONLY
) == 0)
2054 /* Now that we have set the section file positions, we can set up
2055 the file positions for the non PT_LOAD segments. */
2056 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
2060 if (p
->p_type
!= PT_LOAD
&& m
->count
> 0)
2062 BFD_ASSERT (! m
->includes_filehdr
&& ! m
->includes_phdrs
);
2063 p
->p_offset
= m
->sections
[0]->filepos
;
2067 if (m
->includes_filehdr
)
2069 p
->p_vaddr
= filehdr_vaddr
;
2070 if (! m
->p_paddr_valid
)
2071 p
->p_paddr
= filehdr_paddr
;
2073 else if (m
->includes_phdrs
)
2075 p
->p_vaddr
= phdrs_vaddr
;
2076 if (! m
->p_paddr_valid
)
2077 p
->p_paddr
= phdrs_paddr
;
2082 /* Clear out any program headers we allocated but did not use. */
2083 for (; count
< alloc
; count
++, p
++)
2085 memset (p
, 0, sizeof *p
);
2086 p
->p_type
= PT_NULL
;
2089 elf_tdata (abfd
)->phdr
= phdrs
;
2091 elf_tdata (abfd
)->next_file_pos
= off
;
2093 /* Write out the program headers. */
2094 if (bfd_seek (abfd
, bed
->s
->sizeof_ehdr
, SEEK_SET
) != 0
2095 || bed
->s
->write_out_phdrs (abfd
, phdrs
, alloc
) != 0)
2101 /* Get the size of the program header.
2103 If this is called by the linker before any of the section VMA's are set, it
2104 can't calculate the correct value for a strange memory layout. This only
2105 happens when SIZEOF_HEADERS is used in a linker script. In this case,
2106 SORTED_HDRS is NULL and we assume the normal scenario of one text and one
2107 data segment (exclusive of .interp and .dynamic).
2109 ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
2110 will be two segments. */
2112 static bfd_size_type
2113 get_program_header_size (abfd
)
2118 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2120 /* We can't return a different result each time we're called. */
2121 if (elf_tdata (abfd
)->program_header_size
!= 0)
2122 return elf_tdata (abfd
)->program_header_size
;
2124 if (elf_tdata (abfd
)->segment_map
!= NULL
)
2126 struct elf_segment_map
*m
;
2129 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
2131 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
2132 return elf_tdata (abfd
)->program_header_size
;
2135 /* Assume we will need exactly two PT_LOAD segments: one for text
2136 and one for data. */
2139 s
= bfd_get_section_by_name (abfd
, ".interp");
2140 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
2142 /* If we have a loadable interpreter section, we need a
2143 PT_INTERP segment. In this case, assume we also need a
2144 PT_PHDR segment, although that may not be true for all
2149 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
2151 /* We need a PT_DYNAMIC segment. */
2155 /* Let the backend count up any program headers it might need. */
2156 if (bed
->elf_backend_additional_program_headers
)
2160 a
= (*bed
->elf_backend_additional_program_headers
) (abfd
);
2166 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
2167 return elf_tdata (abfd
)->program_header_size
;
2170 /* Work out the file positions of all the sections. This is called by
2171 _bfd_elf_compute_section_file_positions. All the section sizes and
2172 VMAs must be known before this is called.
2174 We do not consider reloc sections at this point, unless they form
2175 part of the loadable image. Reloc sections are assigned file
2176 positions in assign_file_positions_for_relocs, which is called by
2177 write_object_contents and final_link.
2179 We also don't set the positions of the .symtab and .strtab here. */
2182 assign_file_positions_except_relocs (abfd
)
2185 struct elf_obj_tdata
* const tdata
= elf_tdata (abfd
);
2186 Elf_Internal_Ehdr
* const i_ehdrp
= elf_elfheader (abfd
);
2187 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
2189 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2191 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
2193 Elf_Internal_Shdr
**hdrpp
;
2196 /* Start after the ELF header. */
2197 off
= i_ehdrp
->e_ehsize
;
2199 /* We are not creating an executable, which means that we are
2200 not creating a program header, and that the actual order of
2201 the sections in the file is unimportant. */
2202 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2204 Elf_Internal_Shdr
*hdr
;
2207 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
2209 hdr
->sh_offset
= -1;
2212 if (i
== tdata
->symtab_section
2213 || i
== tdata
->strtab_section
)
2215 hdr
->sh_offset
= -1;
2219 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
2225 Elf_Internal_Shdr
**hdrpp
;
2227 /* Assign file positions for the loaded sections based on the
2228 assignment of sections to segments. */
2229 if (! assign_file_positions_for_segments (abfd
))
2232 /* Assign file positions for the other sections. */
2234 off
= elf_tdata (abfd
)->next_file_pos
;
2235 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2237 Elf_Internal_Shdr
*hdr
;
2240 if (hdr
->bfd_section
!= NULL
2241 && hdr
->bfd_section
->filepos
!= 0)
2242 hdr
->sh_offset
= hdr
->bfd_section
->filepos
;
2243 else if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
2245 ((*_bfd_error_handler
)
2246 ("%s: warning: allocated section `%s' not in segment",
2247 bfd_get_filename (abfd
),
2248 (hdr
->bfd_section
== NULL
2250 : hdr
->bfd_section
->name
)));
2251 off
+= (hdr
->sh_addr
- off
) % bed
->maxpagesize
;
2252 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
,
2255 else if (hdr
->sh_type
== SHT_REL
2256 || hdr
->sh_type
== SHT_RELA
2257 || hdr
== i_shdrpp
[tdata
->symtab_section
]
2258 || hdr
== i_shdrpp
[tdata
->strtab_section
])
2259 hdr
->sh_offset
= -1;
2261 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
2265 /* Place the section headers. */
2266 off
= align_file_position (off
, bed
->s
->file_align
);
2267 i_ehdrp
->e_shoff
= off
;
2268 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
2270 elf_tdata (abfd
)->next_file_pos
= off
;
2279 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2280 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
2281 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2283 struct bfd_strtab_hash
*shstrtab
;
2284 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2286 i_ehdrp
= elf_elfheader (abfd
);
2287 i_shdrp
= elf_elfsections (abfd
);
2289 shstrtab
= _bfd_elf_stringtab_init ();
2290 if (shstrtab
== NULL
)
2293 elf_shstrtab (abfd
) = shstrtab
;
2295 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
2296 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
2297 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
2298 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
2300 i_ehdrp
->e_ident
[EI_CLASS
] = bed
->s
->elfclass
;
2301 i_ehdrp
->e_ident
[EI_DATA
] =
2302 bfd_big_endian (abfd
) ? ELFDATA2MSB
: ELFDATA2LSB
;
2303 i_ehdrp
->e_ident
[EI_VERSION
] = bed
->s
->ev_current
;
2305 for (count
= EI_PAD
; count
< EI_NIDENT
; count
++)
2306 i_ehdrp
->e_ident
[count
] = 0;
2308 if ((abfd
->flags
& DYNAMIC
) != 0)
2309 i_ehdrp
->e_type
= ET_DYN
;
2310 else if ((abfd
->flags
& EXEC_P
) != 0)
2311 i_ehdrp
->e_type
= ET_EXEC
;
2313 i_ehdrp
->e_type
= ET_REL
;
2315 switch (bfd_get_arch (abfd
))
2317 case bfd_arch_unknown
:
2318 i_ehdrp
->e_machine
= EM_NONE
;
2320 case bfd_arch_sparc
:
2321 if (bed
->s
->arch_size
== 64)
2322 i_ehdrp
->e_machine
= EM_SPARC64
;
2324 i_ehdrp
->e_machine
= EM_SPARC
;
2327 i_ehdrp
->e_machine
= EM_386
;
2330 i_ehdrp
->e_machine
= EM_68K
;
2333 i_ehdrp
->e_machine
= EM_88K
;
2336 i_ehdrp
->e_machine
= EM_860
;
2338 case bfd_arch_mips
: /* MIPS Rxxxx */
2339 i_ehdrp
->e_machine
= EM_MIPS
; /* only MIPS R3000 */
2342 i_ehdrp
->e_machine
= EM_PARISC
;
2344 case bfd_arch_powerpc
:
2345 i_ehdrp
->e_machine
= EM_PPC
;
2347 /* start-sanitize-arc */
2349 i_ehdrp
->e_machine
= EM_CYGNUS_ARC
;
2351 /* end-sanitize-arc */
2352 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
2354 i_ehdrp
->e_machine
= EM_NONE
;
2356 i_ehdrp
->e_version
= bed
->s
->ev_current
;
2357 i_ehdrp
->e_ehsize
= bed
->s
->sizeof_ehdr
;
2359 /* no program header, for now. */
2360 i_ehdrp
->e_phoff
= 0;
2361 i_ehdrp
->e_phentsize
= 0;
2362 i_ehdrp
->e_phnum
= 0;
2364 /* each bfd section is section header entry */
2365 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
2366 i_ehdrp
->e_shentsize
= bed
->s
->sizeof_shdr
;
2368 /* if we're building an executable, we'll need a program header table */
2369 if (abfd
->flags
& EXEC_P
)
2371 /* it all happens later */
2373 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
2375 /* elf_build_phdrs() returns a (NULL-terminated) array of
2376 Elf_Internal_Phdrs */
2377 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
2378 i_ehdrp
->e_phoff
= outbase
;
2379 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
2384 i_ehdrp
->e_phentsize
= 0;
2386 i_ehdrp
->e_phoff
= 0;
2389 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
2390 (unsigned int) _bfd_stringtab_add (shstrtab
, ".symtab", true, false);
2391 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
2392 (unsigned int) _bfd_stringtab_add (shstrtab
, ".strtab", true, false);
2393 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
2394 (unsigned int) _bfd_stringtab_add (shstrtab
, ".shstrtab", true, false);
2395 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2396 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2397 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
2403 /* Assign file positions for all the reloc sections which are not part
2404 of the loadable file image. */
2407 _bfd_elf_assign_file_positions_for_relocs (abfd
)
2412 Elf_Internal_Shdr
**shdrpp
;
2414 off
= elf_tdata (abfd
)->next_file_pos
;
2416 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1;
2417 i
< elf_elfheader (abfd
)->e_shnum
;
2420 Elf_Internal_Shdr
*shdrp
;
2423 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
2424 && shdrp
->sh_offset
== -1)
2425 off
= _bfd_elf_assign_file_position_for_section (shdrp
, off
, true);
2428 elf_tdata (abfd
)->next_file_pos
= off
;
2432 _bfd_elf_write_object_contents (abfd
)
2435 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2436 Elf_Internal_Ehdr
*i_ehdrp
;
2437 Elf_Internal_Shdr
**i_shdrp
;
2441 if (! abfd
->output_has_begun
2442 && ! _bfd_elf_compute_section_file_positions (abfd
,
2443 (struct bfd_link_info
*) NULL
))
2446 i_shdrp
= elf_elfsections (abfd
);
2447 i_ehdrp
= elf_elfheader (abfd
);
2450 bfd_map_over_sections (abfd
, bed
->s
->write_relocs
, &failed
);
2453 _bfd_elf_assign_file_positions_for_relocs (abfd
);
2455 /* After writing the headers, we need to write the sections too... */
2456 for (count
= 1; count
< i_ehdrp
->e_shnum
; count
++)
2458 if (bed
->elf_backend_section_processing
)
2459 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
2460 if (i_shdrp
[count
]->contents
)
2462 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
2463 || (bfd_write (i_shdrp
[count
]->contents
, i_shdrp
[count
]->sh_size
,
2465 != i_shdrp
[count
]->sh_size
))
2470 /* Write out the section header names. */
2471 if (bfd_seek (abfd
, elf_tdata (abfd
)->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
2472 || ! _bfd_stringtab_emit (abfd
, elf_shstrtab (abfd
)))
2475 if (bed
->elf_backend_final_write_processing
)
2476 (*bed
->elf_backend_final_write_processing
) (abfd
,
2477 elf_tdata (abfd
)->linker
);
2479 return bed
->s
->write_shdrs_and_ehdr (abfd
);
2482 /* given a section, search the header to find them... */
2484 _bfd_elf_section_from_bfd_section (abfd
, asect
)
2488 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2489 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
2491 Elf_Internal_Shdr
*hdr
;
2492 int maxindex
= elf_elfheader (abfd
)->e_shnum
;
2494 for (index
= 0; index
< maxindex
; index
++)
2496 hdr
= i_shdrp
[index
];
2497 if (hdr
->bfd_section
== asect
)
2501 if (bed
->elf_backend_section_from_bfd_section
)
2503 for (index
= 0; index
< maxindex
; index
++)
2507 hdr
= i_shdrp
[index
];
2509 if ((*bed
->elf_backend_section_from_bfd_section
)
2510 (abfd
, hdr
, asect
, &retval
))
2515 if (bfd_is_abs_section (asect
))
2517 if (bfd_is_com_section (asect
))
2519 if (bfd_is_und_section (asect
))
2525 /* given a symbol, return the bfd index for that symbol. */
2527 _bfd_elf_symbol_from_bfd_symbol (abfd
, asym_ptr_ptr
)
2529 struct symbol_cache_entry
**asym_ptr_ptr
;
2531 struct symbol_cache_entry
*asym_ptr
= *asym_ptr_ptr
;
2533 flagword flags
= asym_ptr
->flags
;
2535 /* When gas creates relocations against local labels, it creates its
2536 own symbol for the section, but does put the symbol into the
2537 symbol chain, so udata is 0. When the linker is generating
2538 relocatable output, this section symbol may be for one of the
2539 input sections rather than the output section. */
2540 if (asym_ptr
->udata
.i
== 0
2541 && (flags
& BSF_SECTION_SYM
)
2542 && asym_ptr
->section
)
2546 if (asym_ptr
->section
->output_section
!= NULL
)
2547 indx
= asym_ptr
->section
->output_section
->index
;
2549 indx
= asym_ptr
->section
->index
;
2550 if (elf_section_syms (abfd
)[indx
])
2551 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
2554 idx
= asym_ptr
->udata
.i
;
2555 BFD_ASSERT (idx
!= 0);
2560 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
2561 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
, elf_symbol_flags (flags
));
2569 /* Copy private BFD data. This copies any program header information. */
2572 copy_private_bfd_data (ibfd
, obfd
)
2576 Elf_Internal_Ehdr
*iehdr
;
2577 struct elf_segment_map
*mfirst
;
2578 struct elf_segment_map
**pm
;
2579 Elf_Internal_Phdr
*p
;
2582 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2583 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2586 if (elf_tdata (ibfd
)->phdr
== NULL
)
2589 iehdr
= elf_elfheader (ibfd
);
2594 c
= elf_elfheader (ibfd
)->e_phnum
;
2595 for (i
= 0, p
= elf_tdata (ibfd
)->phdr
; i
< c
; i
++, p
++)
2599 struct elf_segment_map
*m
;
2604 /* The complicated case when p_vaddr is 0 is to handle the
2605 Solaris linker, which generates a PT_INTERP section with
2606 p_vaddr and p_memsz set to 0. */
2607 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2608 if (((s
->vma
>= p
->p_vaddr
2609 && (s
->vma
+ s
->_raw_size
<= p
->p_vaddr
+ p
->p_memsz
2610 || s
->vma
+ s
->_raw_size
<= p
->p_vaddr
+ p
->p_filesz
))
2613 && (s
->flags
& SEC_HAS_CONTENTS
) != 0
2614 && (bfd_vma
) s
->filepos
>= p
->p_offset
2615 && ((bfd_vma
) s
->filepos
+ s
->_raw_size
2616 <= p
->p_offset
+ p
->p_filesz
)))
2617 && (s
->flags
& SEC_ALLOC
) != 0
2618 && s
->output_section
!= NULL
)
2621 m
= ((struct elf_segment_map
*)
2623 (sizeof (struct elf_segment_map
)
2624 + (csecs
- 1) * sizeof (asection
*))));
2629 m
->p_type
= p
->p_type
;
2630 m
->p_flags
= p
->p_flags
;
2631 m
->p_flags_valid
= 1;
2632 m
->p_paddr
= p
->p_paddr
;
2633 m
->p_paddr_valid
= 1;
2635 m
->includes_filehdr
= (p
->p_offset
== 0
2636 && p
->p_filesz
>= iehdr
->e_ehsize
);
2638 m
->includes_phdrs
= (p
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
2639 && (p
->p_offset
+ p
->p_filesz
2640 >= ((bfd_vma
) iehdr
->e_phoff
2641 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
2644 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2646 if (((s
->vma
>= p
->p_vaddr
2647 && (s
->vma
+ s
->_raw_size
<= p
->p_vaddr
+ p
->p_memsz
2648 || s
->vma
+ s
->_raw_size
<= p
->p_vaddr
+ p
->p_filesz
))
2651 && (s
->flags
& SEC_HAS_CONTENTS
) != 0
2652 && (bfd_vma
) s
->filepos
>= p
->p_offset
2653 && ((bfd_vma
) s
->filepos
+ s
->_raw_size
2654 <= p
->p_offset
+ p
->p_filesz
)))
2655 && (s
->flags
& SEC_ALLOC
) != 0
2656 && s
->output_section
!= NULL
)
2658 m
->sections
[isec
] = s
->output_section
;
2662 BFD_ASSERT (isec
== csecs
);
2669 elf_tdata (obfd
)->segment_map
= mfirst
;
2674 /* Copy private section information. This copies over the entsize
2675 field, and sometimes the info field. */
2678 _bfd_elf_copy_private_section_data (ibfd
, isec
, obfd
, osec
)
2684 Elf_Internal_Shdr
*ihdr
, *ohdr
;
2686 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
2687 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
2690 /* Copy over private BFD data if it has not already been copied.
2691 This must be done here, rather than in the copy_private_bfd_data
2692 entry point, because the latter is called after the section
2693 contents have been set, which means that the program headers have
2694 already been worked out. */
2695 if (elf_tdata (obfd
)->segment_map
== NULL
2696 && elf_tdata (ibfd
)->phdr
!= NULL
)
2700 /* Only set up the segments when all the sections have been set
2702 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2703 if (s
->output_section
== NULL
)
2707 if (! copy_private_bfd_data (ibfd
, obfd
))
2712 ihdr
= &elf_section_data (isec
)->this_hdr
;
2713 ohdr
= &elf_section_data (osec
)->this_hdr
;
2715 ohdr
->sh_entsize
= ihdr
->sh_entsize
;
2717 if (ihdr
->sh_type
== SHT_SYMTAB
2718 || ihdr
->sh_type
== SHT_DYNSYM
)
2719 ohdr
->sh_info
= ihdr
->sh_info
;
2724 /* Copy private symbol information. If this symbol is in a section
2725 which we did not map into a BFD section, try to map the section
2726 index correctly. We use special macro definitions for the mapped
2727 section indices; these definitions are interpreted by the
2728 swap_out_syms function. */
2730 #define MAP_ONESYMTAB (SHN_LORESERVE - 1)
2731 #define MAP_DYNSYMTAB (SHN_LORESERVE - 2)
2732 #define MAP_STRTAB (SHN_LORESERVE - 3)
2733 #define MAP_SHSTRTAB (SHN_LORESERVE - 4)
2736 _bfd_elf_copy_private_symbol_data (ibfd
, isymarg
, obfd
, osymarg
)
2742 elf_symbol_type
*isym
, *osym
;
2744 isym
= elf_symbol_from (ibfd
, isymarg
);
2745 osym
= elf_symbol_from (obfd
, osymarg
);
2749 && bfd_is_abs_section (isym
->symbol
.section
))
2753 shndx
= isym
->internal_elf_sym
.st_shndx
;
2754 if (shndx
== elf_onesymtab (ibfd
))
2755 shndx
= MAP_ONESYMTAB
;
2756 else if (shndx
== elf_dynsymtab (ibfd
))
2757 shndx
= MAP_DYNSYMTAB
;
2758 else if (shndx
== elf_tdata (ibfd
)->strtab_section
)
2760 else if (shndx
== elf_tdata (ibfd
)->shstrtab_section
)
2761 shndx
= MAP_SHSTRTAB
;
2762 osym
->internal_elf_sym
.st_shndx
= shndx
;
2768 /* Swap out the symbols. */
2771 swap_out_syms (abfd
, sttp
)
2773 struct bfd_strtab_hash
**sttp
;
2775 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2777 if (!elf_map_symbols (abfd
))
2780 /* Dump out the symtabs. */
2782 int symcount
= bfd_get_symcount (abfd
);
2783 asymbol
**syms
= bfd_get_outsymbols (abfd
);
2784 struct bfd_strtab_hash
*stt
;
2785 Elf_Internal_Shdr
*symtab_hdr
;
2786 Elf_Internal_Shdr
*symstrtab_hdr
;
2787 char *outbound_syms
;
2790 stt
= _bfd_elf_stringtab_init ();
2794 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2795 symtab_hdr
->sh_type
= SHT_SYMTAB
;
2796 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
2797 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
2798 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
2799 symtab_hdr
->sh_addralign
= bed
->s
->file_align
;
2801 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2802 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2804 outbound_syms
= bfd_alloc (abfd
,
2805 (1 + symcount
) * bed
->s
->sizeof_sym
);
2806 if (outbound_syms
== NULL
)
2808 symtab_hdr
->contents
= (PTR
) outbound_syms
;
2810 /* now generate the data (for "contents") */
2812 /* Fill in zeroth symbol and swap it out. */
2813 Elf_Internal_Sym sym
;
2819 sym
.st_shndx
= SHN_UNDEF
;
2820 bed
->s
->swap_symbol_out (abfd
, &sym
, (PTR
) outbound_syms
);
2821 outbound_syms
+= bed
->s
->sizeof_sym
;
2823 for (idx
= 0; idx
< symcount
; idx
++)
2825 Elf_Internal_Sym sym
;
2826 bfd_vma value
= syms
[idx
]->value
;
2827 elf_symbol_type
*type_ptr
;
2828 flagword flags
= syms
[idx
]->flags
;
2830 if (flags
& BSF_SECTION_SYM
)
2831 /* Section symbols have no names. */
2835 sym
.st_name
= (unsigned long) _bfd_stringtab_add (stt
,
2838 if (sym
.st_name
== (unsigned long) -1)
2842 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
2844 if (bfd_is_com_section (syms
[idx
]->section
))
2846 /* ELF common symbols put the alignment into the `value' field,
2847 and the size into the `size' field. This is backwards from
2848 how BFD handles it, so reverse it here. */
2849 sym
.st_size
= value
;
2850 if (type_ptr
== NULL
2851 || type_ptr
->internal_elf_sym
.st_value
== 0)
2852 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
2854 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
2855 sym
.st_shndx
= _bfd_elf_section_from_bfd_section (abfd
,
2856 syms
[idx
]->section
);
2860 asection
*sec
= syms
[idx
]->section
;
2863 if (sec
->output_section
)
2865 value
+= sec
->output_offset
;
2866 sec
= sec
->output_section
;
2869 sym
.st_value
= value
;
2870 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
2872 if (bfd_is_abs_section (sec
)
2874 && type_ptr
->internal_elf_sym
.st_shndx
!= 0)
2876 /* This symbol is in a real ELF section which we did
2877 not create as a BFD section. Undo the mapping done
2878 by copy_private_symbol_data. */
2879 shndx
= type_ptr
->internal_elf_sym
.st_shndx
;
2883 shndx
= elf_onesymtab (abfd
);
2886 shndx
= elf_dynsymtab (abfd
);
2889 shndx
= elf_tdata (abfd
)->strtab_section
;
2892 shndx
= elf_tdata (abfd
)->shstrtab_section
;
2900 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
2906 /* Writing this would be a hell of a lot easier if
2907 we had some decent documentation on bfd, and
2908 knew what to expect of the library, and what to
2909 demand of applications. For example, it
2910 appears that `objcopy' might not set the
2911 section of a symbol to be a section that is
2912 actually in the output file. */
2913 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
2914 BFD_ASSERT (sec2
!= 0);
2915 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
2916 BFD_ASSERT (shndx
!= -1);
2920 sym
.st_shndx
= shndx
;
2923 if (bfd_is_com_section (syms
[idx
]->section
))
2924 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_OBJECT
);
2925 else if (bfd_is_und_section (syms
[idx
]->section
))
2926 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
2929 ((flags
& BSF_FUNCTION
)
2932 else if (flags
& BSF_SECTION_SYM
)
2933 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
2934 else if (flags
& BSF_FILE
)
2935 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
2938 int bind
= STB_LOCAL
;
2939 int type
= STT_OBJECT
;
2941 if (flags
& BSF_LOCAL
)
2943 else if (flags
& BSF_WEAK
)
2945 else if (flags
& BSF_GLOBAL
)
2948 if (flags
& BSF_FUNCTION
)
2951 sym
.st_info
= ELF_ST_INFO (bind
, type
);
2955 bed
->s
->swap_symbol_out (abfd
, &sym
, (PTR
) outbound_syms
);
2956 outbound_syms
+= bed
->s
->sizeof_sym
;
2960 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (stt
);
2961 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2963 symstrtab_hdr
->sh_flags
= 0;
2964 symstrtab_hdr
->sh_addr
= 0;
2965 symstrtab_hdr
->sh_entsize
= 0;
2966 symstrtab_hdr
->sh_link
= 0;
2967 symstrtab_hdr
->sh_info
= 0;
2968 symstrtab_hdr
->sh_addralign
= 1;
2974 /* Return the number of bytes required to hold the symtab vector.
2976 Note that we base it on the count plus 1, since we will null terminate
2977 the vector allocated based on this size. However, the ELF symbol table
2978 always has a dummy entry as symbol #0, so it ends up even. */
2981 _bfd_elf_get_symtab_upper_bound (abfd
)
2986 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2988 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
2989 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
2995 _bfd_elf_get_dynamic_symtab_upper_bound (abfd
)
3000 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
3002 if (elf_dynsymtab (abfd
) == 0)
3004 bfd_set_error (bfd_error_invalid_operation
);
3008 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
3009 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
3015 _bfd_elf_get_reloc_upper_bound (abfd
, asect
)
3019 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
3022 /* Canonicalize the relocs. */
3025 _bfd_elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
3034 if (! get_elf_backend_data (abfd
)->s
->slurp_reloc_table (abfd
, section
, symbols
))
3037 tblptr
= section
->relocation
;
3038 for (i
= 0; i
< section
->reloc_count
; i
++)
3039 *relptr
++ = tblptr
++;
3043 return section
->reloc_count
;
3047 _bfd_elf_get_symtab (abfd
, alocation
)
3049 asymbol
**alocation
;
3051 long symcount
= get_elf_backend_data (abfd
)->s
->slurp_symbol_table (abfd
, alocation
, false);
3054 bfd_get_symcount (abfd
) = symcount
;
3059 _bfd_elf_canonicalize_dynamic_symtab (abfd
, alocation
)
3061 asymbol
**alocation
;
3063 return get_elf_backend_data (abfd
)->s
->slurp_symbol_table (abfd
, alocation
, true);
3067 _bfd_elf_make_empty_symbol (abfd
)
3070 elf_symbol_type
*newsym
;
3072 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (elf_symbol_type
));
3077 newsym
->symbol
.the_bfd
= abfd
;
3078 return &newsym
->symbol
;
3083 _bfd_elf_get_symbol_info (ignore_abfd
, symbol
, ret
)
3088 bfd_symbol_info (symbol
, ret
);
3092 _bfd_elf_get_lineno (ignore_abfd
, symbol
)
3101 _bfd_elf_set_arch_mach (abfd
, arch
, machine
)
3103 enum bfd_architecture arch
;
3104 unsigned long machine
;
3106 /* If this isn't the right architecture for this backend, and this
3107 isn't the generic backend, fail. */
3108 if (arch
!= get_elf_backend_data (abfd
)->arch
3109 && arch
!= bfd_arch_unknown
3110 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
3113 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
3116 /* Find the nearest line to a particular section and offset, for error
3120 _bfd_elf_find_nearest_line (abfd
,
3131 CONST
char **filename_ptr
;
3132 CONST
char **functionname_ptr
;
3133 unsigned int *line_ptr
;
3135 const char *filename
;
3139 if (symbols
== NULL
)
3145 for (p
= symbols
; *p
!= NULL
; p
++)
3149 q
= (elf_symbol_type
*) *p
;
3151 if (bfd_get_section (&q
->symbol
) != section
)
3154 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
3159 filename
= bfd_asymbol_name (&q
->symbol
);
3163 || q
->symbol
.value
<= offset
)
3164 func
= (asymbol
*) q
;
3172 *filename_ptr
= filename
;
3173 *functionname_ptr
= bfd_asymbol_name (func
);
3179 _bfd_elf_sizeof_headers (abfd
, reloc
)
3185 ret
= get_elf_backend_data (abfd
)->s
->sizeof_ehdr
;
3187 ret
+= get_program_header_size (abfd
);
3192 _bfd_elf_set_section_contents (abfd
, section
, location
, offset
, count
)
3197 bfd_size_type count
;
3199 Elf_Internal_Shdr
*hdr
;
3201 if (! abfd
->output_has_begun
3202 && ! _bfd_elf_compute_section_file_positions (abfd
,
3203 (struct bfd_link_info
*) NULL
))
3206 hdr
= &elf_section_data (section
)->this_hdr
;
3208 if (bfd_seek (abfd
, hdr
->sh_offset
+ offset
, SEEK_SET
) == -1)
3210 if (bfd_write (location
, 1, count
, abfd
) != count
)
3217 _bfd_elf_no_info_to_howto (abfd
, cache_ptr
, dst
)
3220 Elf_Internal_Rela
*dst
;
3227 _bfd_elf_no_info_to_howto_rel (abfd
, cache_ptr
, dst
)
3230 Elf_Internal_Rel
*dst
;