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 file_ptr map_program_segments
PARAMS ((bfd
*, file_ptr
,
45 static boolean assign_file_positions_except_relocs
PARAMS ((bfd
*, boolean
));
46 static boolean prep_headers
PARAMS ((bfd
*));
47 static boolean swap_out_syms
PARAMS ((bfd
*, struct bfd_strtab_hash
**));
49 /* Standard ELF hash function. Do not change this function; you will
50 cause invalid hash tables to be generated. (Well, you would if this
51 were being used yet.) */
54 CONST
unsigned char *name
;
60 while ((ch
= *name
++) != '\0')
63 if ((g
= (h
& 0xf0000000)) != 0)
72 /* Read a specified number of bytes at a specified offset in an ELF
73 file, into a newly allocated buffer, and return a pointer to the
77 elf_read (abfd
, offset
, size
)
84 if ((buf
= bfd_alloc (abfd
, size
)) == NULL
)
86 bfd_set_error (bfd_error_no_memory
);
89 if (bfd_seek (abfd
, offset
, SEEK_SET
) == -1)
91 if (bfd_read ((PTR
) buf
, size
, 1, abfd
) != size
)
93 if (bfd_get_error () != bfd_error_system_call
)
94 bfd_set_error (bfd_error_file_truncated
);
104 /* this just does initialization */
105 /* coff_mkobject zalloc's space for tdata.coff_obj_data ... */
106 elf_tdata (abfd
) = (struct elf_obj_tdata
*)
107 bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
108 if (elf_tdata (abfd
) == 0)
110 bfd_set_error (bfd_error_no_memory
);
113 /* since everything is done at close time, do we need any
120 bfd_elf_get_str_section (abfd
, shindex
)
122 unsigned int shindex
;
124 Elf_Internal_Shdr
**i_shdrp
;
125 char *shstrtab
= NULL
;
127 unsigned int shstrtabsize
;
129 i_shdrp
= elf_elfsections (abfd
);
130 if (i_shdrp
== 0 || i_shdrp
[shindex
] == 0)
133 shstrtab
= (char *) i_shdrp
[shindex
]->contents
;
134 if (shstrtab
== NULL
)
136 /* No cached one, attempt to read, and cache what we read. */
137 offset
= i_shdrp
[shindex
]->sh_offset
;
138 shstrtabsize
= i_shdrp
[shindex
]->sh_size
;
139 shstrtab
= elf_read (abfd
, offset
, shstrtabsize
);
140 i_shdrp
[shindex
]->contents
= (PTR
) shstrtab
;
146 bfd_elf_string_from_elf_section (abfd
, shindex
, strindex
)
148 unsigned int shindex
;
149 unsigned int strindex
;
151 Elf_Internal_Shdr
*hdr
;
156 hdr
= elf_elfsections (abfd
)[shindex
];
158 if (hdr
->contents
== NULL
159 && bfd_elf_get_str_section (abfd
, shindex
) == NULL
)
162 return ((char *) hdr
->contents
) + strindex
;
165 /* Make a BFD section from an ELF section. We store a pointer to the
166 BFD section in the bfd_section field of the header. */
169 _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
)
171 Elf_Internal_Shdr
*hdr
;
177 if (hdr
->bfd_section
!= NULL
)
179 BFD_ASSERT (strcmp (name
,
180 bfd_get_section_name (abfd
, hdr
->bfd_section
)) == 0);
184 newsect
= bfd_make_section_anyway (abfd
, name
);
188 newsect
->filepos
= hdr
->sh_offset
;
190 if (! bfd_set_section_vma (abfd
, newsect
, hdr
->sh_addr
)
191 || ! bfd_set_section_size (abfd
, newsect
, hdr
->sh_size
)
192 || ! bfd_set_section_alignment (abfd
, newsect
,
193 bfd_log2 (hdr
->sh_addralign
)))
196 flags
= SEC_NO_FLAGS
;
197 if (hdr
->sh_type
!= SHT_NOBITS
)
198 flags
|= SEC_HAS_CONTENTS
;
199 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
202 if (hdr
->sh_type
!= SHT_NOBITS
)
205 if ((hdr
->sh_flags
& SHF_WRITE
) == 0)
206 flags
|= SEC_READONLY
;
207 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
209 else if ((flags
& SEC_LOAD
) != 0)
212 /* The debugging sections appear to be recognized only by name, not
214 if (strncmp (name
, ".debug", sizeof ".debug" - 1) == 0
215 || strncmp (name
, ".line", sizeof ".line" - 1) == 0
216 || strncmp (name
, ".stab", sizeof ".stab" - 1) == 0)
217 flags
|= SEC_DEBUGGING
;
219 if (! bfd_set_section_flags (abfd
, newsect
, flags
))
222 hdr
->bfd_section
= newsect
;
223 elf_section_data (newsect
)->this_hdr
= *hdr
;
233 struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name);
236 Helper functions for GDB to locate the string tables.
237 Since BFD hides string tables from callers, GDB needs to use an
238 internal hook to find them. Sun's .stabstr, in particular,
239 isn't even pointed to by the .stab section, so ordinary
240 mechanisms wouldn't work to find it, even if we had some.
243 struct elf_internal_shdr
*
244 bfd_elf_find_section (abfd
, name
)
248 Elf_Internal_Shdr
**i_shdrp
;
253 i_shdrp
= elf_elfsections (abfd
);
256 shstrtab
= bfd_elf_get_str_section (abfd
, elf_elfheader (abfd
)->e_shstrndx
);
257 if (shstrtab
!= NULL
)
259 max
= elf_elfheader (abfd
)->e_shnum
;
260 for (i
= 1; i
< max
; i
++)
261 if (!strcmp (&shstrtab
[i_shdrp
[i
]->sh_name
], name
))
268 const char *const bfd_elf_section_type_names
[] = {
269 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
270 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
271 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
274 /* ELF relocs are against symbols. If we are producing relocateable
275 output, and the reloc is against an external symbol, and nothing
276 has given us any additional addend, the resulting reloc will also
277 be against the same symbol. In such a case, we don't want to
278 change anything about the way the reloc is handled, since it will
279 all be done at final link time. Rather than put special case code
280 into bfd_perform_relocation, all the reloc types use this howto
281 function. It just short circuits the reloc if producing
282 relocateable output against an external symbol. */
285 bfd_reloc_status_type
286 bfd_elf_generic_reloc (abfd
,
294 arelent
*reloc_entry
;
297 asection
*input_section
;
299 char **error_message
;
301 if (output_bfd
!= (bfd
*) NULL
302 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
303 && (! reloc_entry
->howto
->partial_inplace
304 || reloc_entry
->addend
== 0))
306 reloc_entry
->address
+= input_section
->output_offset
;
310 return bfd_reloc_continue
;
313 /* Display ELF-specific fields of a symbol. */
315 bfd_elf_print_symbol (ignore_abfd
, filep
, symbol
, how
)
319 bfd_print_symbol_type how
;
321 FILE *file
= (FILE *) filep
;
324 case bfd_print_symbol_name
:
325 fprintf (file
, "%s", symbol
->name
);
327 case bfd_print_symbol_more
:
328 fprintf (file
, "elf ");
329 fprintf_vma (file
, symbol
->value
);
330 fprintf (file
, " %lx", (long) symbol
->flags
);
332 case bfd_print_symbol_all
:
334 CONST
char *section_name
;
335 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
336 bfd_print_symbol_vandf ((PTR
) file
, symbol
);
337 fprintf (file
, " %s\t", section_name
);
338 /* Print the "other" value for a symbol. For common symbols,
339 we've already printed the size; now print the alignment.
340 For other symbols, we have no specified alignment, and
341 we've printed the address; now print the size. */
343 (bfd_is_com_section (symbol
->section
)
344 ? ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_value
345 : ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_size
));
346 fprintf (file
, " %s", symbol
->name
);
352 /* Create an entry in an ELF linker hash table. */
354 struct bfd_hash_entry
*
355 _bfd_elf_link_hash_newfunc (entry
, table
, string
)
356 struct bfd_hash_entry
*entry
;
357 struct bfd_hash_table
*table
;
360 struct elf_link_hash_entry
*ret
= (struct elf_link_hash_entry
*) entry
;
362 /* Allocate the structure if it has not already been allocated by a
364 if (ret
== (struct elf_link_hash_entry
*) NULL
)
365 ret
= ((struct elf_link_hash_entry
*)
366 bfd_hash_allocate (table
, sizeof (struct elf_link_hash_entry
)));
367 if (ret
== (struct elf_link_hash_entry
*) NULL
)
369 bfd_set_error (bfd_error_no_memory
);
370 return (struct bfd_hash_entry
*) ret
;
373 /* Call the allocation method of the superclass. */
374 ret
= ((struct elf_link_hash_entry
*)
375 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
377 if (ret
!= (struct elf_link_hash_entry
*) NULL
)
379 /* Set local fields. */
383 ret
->dynstr_index
= 0;
385 ret
->got_offset
= (bfd_vma
) -1;
386 ret
->plt_offset
= (bfd_vma
) -1;
387 ret
->type
= STT_NOTYPE
;
388 ret
->elf_link_hash_flags
= 0;
391 return (struct bfd_hash_entry
*) ret
;
394 /* Initialize an ELF linker hash table. */
397 _bfd_elf_link_hash_table_init (table
, abfd
, newfunc
)
398 struct elf_link_hash_table
*table
;
400 struct bfd_hash_entry
*(*newfunc
) PARAMS ((struct bfd_hash_entry
*,
401 struct bfd_hash_table
*,
404 table
->dynamic_sections_created
= false;
405 table
->dynobj
= NULL
;
406 /* The first dynamic symbol is a dummy. */
407 table
->dynsymcount
= 1;
408 table
->dynstr
= NULL
;
409 table
->bucketcount
= 0;
410 table
->needed
= NULL
;
411 return _bfd_link_hash_table_init (&table
->root
, abfd
, newfunc
);
414 /* Create an ELF linker hash table. */
416 struct bfd_link_hash_table
*
417 _bfd_elf_link_hash_table_create (abfd
)
420 struct elf_link_hash_table
*ret
;
422 ret
= ((struct elf_link_hash_table
*)
423 bfd_alloc (abfd
, sizeof (struct elf_link_hash_table
)));
424 if (ret
== (struct elf_link_hash_table
*) NULL
)
426 bfd_set_error (bfd_error_no_memory
);
430 if (! _bfd_elf_link_hash_table_init (ret
, abfd
, _bfd_elf_link_hash_newfunc
))
432 bfd_release (abfd
, ret
);
439 /* This is a hook for the ELF emulation code in the generic linker to
440 tell the backend linker what file name to use for the DT_NEEDED
441 entry for a dynamic object. The generic linker passes name as an
442 empty string to indicate that no DT_NEEDED entry should be made. */
445 bfd_elf_set_dt_needed_name (abfd
, name
)
449 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
450 elf_dt_needed_name (abfd
) = name
;
453 /* Get the list of DT_NEEDED entries for a link. */
455 struct bfd_link_needed_list
*
456 bfd_elf_get_needed_list (abfd
, info
)
458 struct bfd_link_info
*info
;
460 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
462 return elf_hash_table (info
)->needed
;
465 /* Allocate an ELF string table--force the first byte to be zero. */
467 struct bfd_strtab_hash
*
468 _bfd_elf_stringtab_init ()
470 struct bfd_strtab_hash
*ret
;
472 ret
= _bfd_stringtab_init ();
477 loc
= _bfd_stringtab_add (ret
, "", true, false);
478 BFD_ASSERT (loc
== 0 || loc
== (bfd_size_type
) -1);
479 if (loc
== (bfd_size_type
) -1)
481 _bfd_stringtab_free (ret
);
488 /* ELF .o/exec file reading */
490 /* Create a new bfd section from an ELF section header. */
493 bfd_section_from_shdr (abfd
, shindex
)
495 unsigned int shindex
;
497 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[shindex
];
498 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
499 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
502 name
= elf_string_from_elf_strtab (abfd
, hdr
->sh_name
);
504 switch (hdr
->sh_type
)
507 /* Inactive section. Throw it away. */
510 case SHT_PROGBITS
: /* Normal section with contents. */
511 case SHT_DYNAMIC
: /* Dynamic linking information. */
512 case SHT_NOBITS
: /* .bss section. */
513 case SHT_HASH
: /* .hash section. */
514 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
516 case SHT_SYMTAB
: /* A symbol table */
517 if (elf_onesymtab (abfd
) == shindex
)
520 BFD_ASSERT (hdr
->sh_entsize
== bed
->s
->sizeof_sym
);
521 BFD_ASSERT (elf_onesymtab (abfd
) == 0);
522 elf_onesymtab (abfd
) = shindex
;
523 elf_tdata (abfd
)->symtab_hdr
= *hdr
;
524 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->symtab_hdr
;
525 abfd
->flags
|= HAS_SYMS
;
527 /* Sometimes a shared object will map in the symbol table. If
528 SHF_ALLOC is set, and this is a shared object, then we also
529 treat this section as a BFD section. We can not base the
530 decision purely on SHF_ALLOC, because that flag is sometimes
531 set in a relocateable object file, which would confuse the
533 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
534 && (abfd
->flags
& DYNAMIC
) != 0
535 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
540 case SHT_DYNSYM
: /* A dynamic symbol table */
541 if (elf_dynsymtab (abfd
) == shindex
)
544 BFD_ASSERT (hdr
->sh_entsize
== bed
->s
->sizeof_sym
);
545 BFD_ASSERT (elf_dynsymtab (abfd
) == 0);
546 elf_dynsymtab (abfd
) = shindex
;
547 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
548 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->dynsymtab_hdr
;
549 abfd
->flags
|= HAS_SYMS
;
551 /* Besides being a symbol table, we also treat this as a regular
552 section, so that objcopy can handle it. */
553 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
555 case SHT_STRTAB
: /* A string table */
556 if (hdr
->bfd_section
!= NULL
)
558 if (ehdr
->e_shstrndx
== shindex
)
560 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
561 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
567 for (i
= 1; i
< ehdr
->e_shnum
; i
++)
569 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
570 if (hdr2
->sh_link
== shindex
)
572 if (! bfd_section_from_shdr (abfd
, i
))
574 if (elf_onesymtab (abfd
) == i
)
576 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
577 elf_elfsections (abfd
)[shindex
] =
578 &elf_tdata (abfd
)->strtab_hdr
;
581 if (elf_dynsymtab (abfd
) == i
)
583 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
584 elf_elfsections (abfd
)[shindex
] =
585 &elf_tdata (abfd
)->dynstrtab_hdr
;
586 /* We also treat this as a regular section, so
587 that objcopy can handle it. */
590 #if 0 /* Not handling other string tables specially right now. */
591 hdr2
= elf_elfsections (abfd
)[i
]; /* in case it moved */
592 /* We have a strtab for some random other section. */
593 newsect
= (asection
*) hdr2
->bfd_section
;
596 hdr
->bfd_section
= newsect
;
597 hdr2
= &elf_section_data (newsect
)->str_hdr
;
599 elf_elfsections (abfd
)[shindex
] = hdr2
;
605 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
609 /* *These* do a lot of work -- but build no sections! */
611 asection
*target_sect
;
612 Elf_Internal_Shdr
*hdr2
;
613 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
615 /* For some incomprehensible reason Oracle distributes
616 libraries for Solaris in which some of the objects have
617 bogus sh_link fields. It would be nice if we could just
618 reject them, but, unfortunately, some people need to use
619 them. We scan through the section headers; if we find only
620 one suitable symbol table, we clobber the sh_link to point
621 to it. I hope this doesn't break anything. */
622 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_SYMTAB
623 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_DYNSYM
)
629 for (scan
= 1; scan
< ehdr
->e_shnum
; scan
++)
631 if (elf_elfsections (abfd
)[scan
]->sh_type
== SHT_SYMTAB
632 || elf_elfsections (abfd
)[scan
]->sh_type
== SHT_DYNSYM
)
643 hdr
->sh_link
= found
;
646 /* Get the symbol table. */
647 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_SYMTAB
648 && ! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
651 /* If this reloc section does not use the main symbol table we
652 don't treat it as a reloc section. BFD can't adequately
653 represent such a section, so at least for now, we don't
654 try. We just present it as a normal section. */
655 if (hdr
->sh_link
!= elf_onesymtab (abfd
))
656 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
658 /* Don't allow REL relocations on a machine that uses RELA and
660 /* @@ Actually, the generic ABI does suggest that both might be
661 used in one file. But the four ABI Processor Supplements I
662 have access to right now all specify that only one is used on
663 each of those architectures. It's conceivable that, e.g., a
664 bunch of absolute 32-bit relocs might be more compact in REL
665 form even on a RELA machine... */
666 BFD_ASSERT (use_rela_p
667 ? (hdr
->sh_type
== SHT_RELA
668 && hdr
->sh_entsize
== bed
->s
->sizeof_rela
)
669 : (hdr
->sh_type
== SHT_REL
670 && hdr
->sh_entsize
== bed
->s
->sizeof_rel
));
672 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
674 target_sect
= bfd_section_from_elf_index (abfd
, hdr
->sh_info
);
675 if (target_sect
== NULL
)
678 hdr2
= &elf_section_data (target_sect
)->rel_hdr
;
680 elf_elfsections (abfd
)[shindex
] = hdr2
;
681 target_sect
->reloc_count
= hdr
->sh_size
/ hdr
->sh_entsize
;
682 target_sect
->flags
|= SEC_RELOC
;
683 target_sect
->relocation
= NULL
;
684 target_sect
->rel_filepos
= hdr
->sh_offset
;
685 abfd
->flags
|= HAS_RELOC
;
697 /* Check for any processor-specific section types. */
699 if (bed
->elf_backend_section_from_shdr
)
700 (*bed
->elf_backend_section_from_shdr
) (abfd
, hdr
, name
);
708 /* Given an ELF section number, retrieve the corresponding BFD
712 bfd_section_from_elf_index (abfd
, index
)
716 BFD_ASSERT (index
> 0 && index
< SHN_LORESERVE
);
717 if (index
>= elf_elfheader (abfd
)->e_shnum
)
719 return elf_elfsections (abfd
)[index
]->bfd_section
;
723 _bfd_elf_new_section_hook (abfd
, sec
)
727 struct bfd_elf_section_data
*sdata
;
729 sdata
= (struct bfd_elf_section_data
*) bfd_alloc (abfd
, sizeof (*sdata
));
732 bfd_set_error (bfd_error_no_memory
);
735 sec
->used_by_bfd
= (PTR
) sdata
;
736 memset (sdata
, 0, sizeof (*sdata
));
740 /* Create a new bfd section from an ELF program header.
742 Since program segments have no names, we generate a synthetic name
743 of the form segment<NUM>, where NUM is generally the index in the
744 program header table. For segments that are split (see below) we
745 generate the names segment<NUM>a and segment<NUM>b.
747 Note that some program segments may have a file size that is different than
748 (less than) the memory size. All this means is that at execution the
749 system must allocate the amount of memory specified by the memory size,
750 but only initialize it with the first "file size" bytes read from the
751 file. This would occur for example, with program segments consisting
752 of combined data+bss.
754 To handle the above situation, this routine generates TWO bfd sections
755 for the single program segment. The first has the length specified by
756 the file size of the segment, and the second has the length specified
757 by the difference between the two sizes. In effect, the segment is split
758 into it's initialized and uninitialized parts.
763 bfd_section_from_phdr (abfd
, hdr
, index
)
765 Elf_Internal_Phdr
*hdr
;
773 split
= ((hdr
->p_memsz
> 0) &&
774 (hdr
->p_filesz
> 0) &&
775 (hdr
->p_memsz
> hdr
->p_filesz
));
776 sprintf (namebuf
, split
? "segment%da" : "segment%d", index
);
777 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
780 bfd_set_error (bfd_error_no_memory
);
783 strcpy (name
, namebuf
);
784 newsect
= bfd_make_section (abfd
, name
);
787 newsect
->vma
= hdr
->p_vaddr
;
788 newsect
->lma
= hdr
->p_paddr
;
789 newsect
->_raw_size
= hdr
->p_filesz
;
790 newsect
->filepos
= hdr
->p_offset
;
791 newsect
->flags
|= SEC_HAS_CONTENTS
;
792 if (hdr
->p_type
== PT_LOAD
)
794 newsect
->flags
|= SEC_ALLOC
;
795 newsect
->flags
|= SEC_LOAD
;
796 if (hdr
->p_flags
& PF_X
)
798 /* FIXME: all we known is that it has execute PERMISSION,
800 newsect
->flags
|= SEC_CODE
;
803 if (!(hdr
->p_flags
& PF_W
))
805 newsect
->flags
|= SEC_READONLY
;
810 sprintf (namebuf
, "segment%db", index
);
811 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
814 bfd_set_error (bfd_error_no_memory
);
817 strcpy (name
, namebuf
);
818 newsect
= bfd_make_section (abfd
, name
);
821 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
822 newsect
->lma
= hdr
->p_paddr
+ hdr
->p_filesz
;
823 newsect
->_raw_size
= hdr
->p_memsz
- hdr
->p_filesz
;
824 if (hdr
->p_type
== PT_LOAD
)
826 newsect
->flags
|= SEC_ALLOC
;
827 if (hdr
->p_flags
& PF_X
)
828 newsect
->flags
|= SEC_CODE
;
830 if (!(hdr
->p_flags
& PF_W
))
831 newsect
->flags
|= SEC_READONLY
;
837 /* Set up an ELF internal section header for a section. */
841 elf_fake_sections (abfd
, asect
, failedptrarg
)
846 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
847 boolean
*failedptr
= (boolean
*) failedptrarg
;
848 Elf_Internal_Shdr
*this_hdr
;
852 /* We already failed; just get out of the bfd_map_over_sections
857 this_hdr
= &elf_section_data (asect
)->this_hdr
;
859 this_hdr
->sh_name
= (unsigned long) _bfd_stringtab_add (elf_shstrtab (abfd
),
862 if (this_hdr
->sh_name
== (unsigned long) -1)
868 this_hdr
->sh_flags
= 0;
870 /* FIXME: This should really use vma, rather than lma. However,
871 that would mean that the lma information was lost, which would
872 mean that the AT keyword in linker scripts would not work.
873 Fortunately, native scripts do not use the AT keyword, so we can
874 get away with using lma here. The right way to handle this is to
875 1) read the program headers as well as the section headers, and
876 set the lma fields of the BFD sections based on the p_paddr
877 fields of the program headers, and 2) set the p_paddr fields of
878 the program headers based on the section lma fields when writing
880 if ((asect
->flags
& SEC_ALLOC
) != 0)
881 this_hdr
->sh_addr
= asect
->lma
;
883 this_hdr
->sh_addr
= 0;
885 this_hdr
->sh_offset
= 0;
886 this_hdr
->sh_size
= asect
->_raw_size
;
887 this_hdr
->sh_link
= 0;
888 this_hdr
->sh_info
= 0;
889 this_hdr
->sh_addralign
= 1 << asect
->alignment_power
;
890 this_hdr
->sh_entsize
= 0;
892 this_hdr
->bfd_section
= asect
;
893 this_hdr
->contents
= NULL
;
895 /* FIXME: This should not be based on section names. */
896 if (strcmp (asect
->name
, ".dynstr") == 0)
897 this_hdr
->sh_type
= SHT_STRTAB
;
898 else if (strcmp (asect
->name
, ".hash") == 0)
900 this_hdr
->sh_type
= SHT_HASH
;
901 this_hdr
->sh_entsize
= bed
->s
->arch_size
/ 8;
903 else if (strcmp (asect
->name
, ".dynsym") == 0)
905 this_hdr
->sh_type
= SHT_DYNSYM
;
906 this_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
908 else if (strcmp (asect
->name
, ".dynamic") == 0)
910 this_hdr
->sh_type
= SHT_DYNAMIC
;
911 this_hdr
->sh_entsize
= bed
->s
->sizeof_dyn
;
913 else if (strncmp (asect
->name
, ".rela", 5) == 0
914 && get_elf_backend_data (abfd
)->use_rela_p
)
916 this_hdr
->sh_type
= SHT_RELA
;
917 this_hdr
->sh_entsize
= bed
->s
->sizeof_rela
;
919 else if (strncmp (asect
->name
, ".rel", 4) == 0
920 && ! get_elf_backend_data (abfd
)->use_rela_p
)
922 this_hdr
->sh_type
= SHT_REL
;
923 this_hdr
->sh_entsize
= bed
->s
->sizeof_rel
;
925 else if (strcmp (asect
->name
, ".note") == 0)
926 this_hdr
->sh_type
= SHT_NOTE
;
927 else if (strncmp (asect
->name
, ".stab", 5) == 0
928 && strcmp (asect
->name
+ strlen (asect
->name
) - 3, "str") == 0)
929 this_hdr
->sh_type
= SHT_STRTAB
;
930 else if ((asect
->flags
& SEC_ALLOC
) != 0
931 && (asect
->flags
& SEC_LOAD
) != 0)
932 this_hdr
->sh_type
= SHT_PROGBITS
;
933 else if ((asect
->flags
& SEC_ALLOC
) != 0
934 && ((asect
->flags
& SEC_LOAD
) == 0))
935 this_hdr
->sh_type
= SHT_NOBITS
;
939 this_hdr
->sh_type
= SHT_PROGBITS
;
942 if ((asect
->flags
& SEC_ALLOC
) != 0)
943 this_hdr
->sh_flags
|= SHF_ALLOC
;
944 if ((asect
->flags
& SEC_READONLY
) == 0)
945 this_hdr
->sh_flags
|= SHF_WRITE
;
946 if ((asect
->flags
& SEC_CODE
) != 0)
947 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
949 /* Check for processor-specific section types. */
951 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
953 if (bed
->elf_backend_fake_sections
)
954 (*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
);
957 /* If the section has relocs, set up a section header for the
958 SHT_REL[A] section. */
959 if ((asect
->flags
& SEC_RELOC
) != 0)
961 Elf_Internal_Shdr
*rela_hdr
;
962 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
965 rela_hdr
= &elf_section_data (asect
)->rel_hdr
;
966 name
= bfd_alloc (abfd
, sizeof ".rela" + strlen (asect
->name
));
969 bfd_set_error (bfd_error_no_memory
);
973 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", asect
->name
);
975 (unsigned int) _bfd_stringtab_add (elf_shstrtab (abfd
), name
,
977 if (rela_hdr
->sh_name
== (unsigned int) -1)
982 rela_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
983 rela_hdr
->sh_entsize
= (use_rela_p
984 ? bed
->s
->sizeof_rela
985 : bed
->s
->sizeof_rel
);
986 rela_hdr
->sh_addralign
= bed
->s
->file_align
;
987 rela_hdr
->sh_flags
= 0;
988 rela_hdr
->sh_addr
= 0;
989 rela_hdr
->sh_size
= 0;
990 rela_hdr
->sh_offset
= 0;
994 /* Assign all ELF section numbers. The dummy first section is handled here
995 too. The link/info pointers for the standard section types are filled
996 in here too, while we're at it. */
999 assign_section_numbers (abfd
)
1002 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
1004 unsigned int section_number
;
1005 Elf_Internal_Shdr
**i_shdrp
;
1006 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1010 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1012 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1014 d
->this_idx
= section_number
++;
1015 if ((sec
->flags
& SEC_RELOC
) == 0)
1018 d
->rel_idx
= section_number
++;
1021 t
->shstrtab_section
= section_number
++;
1022 elf_elfheader (abfd
)->e_shstrndx
= t
->shstrtab_section
;
1023 t
->shstrtab_hdr
.sh_size
= _bfd_stringtab_size (elf_shstrtab (abfd
));
1025 if (abfd
->symcount
> 0)
1027 t
->symtab_section
= section_number
++;
1028 t
->strtab_section
= section_number
++;
1031 elf_elfheader (abfd
)->e_shnum
= section_number
;
1033 /* Set up the list of section header pointers, in agreement with the
1035 i_shdrp
= ((Elf_Internal_Shdr
**)
1036 bfd_alloc (abfd
, section_number
* sizeof (Elf_Internal_Shdr
*)));
1037 if (i_shdrp
== NULL
)
1039 bfd_set_error (bfd_error_no_memory
);
1043 i_shdrp
[0] = ((Elf_Internal_Shdr
*)
1044 bfd_alloc (abfd
, sizeof (Elf_Internal_Shdr
)));
1045 if (i_shdrp
[0] == NULL
)
1047 bfd_release (abfd
, i_shdrp
);
1048 bfd_set_error (bfd_error_no_memory
);
1051 memset (i_shdrp
[0], 0, sizeof (Elf_Internal_Shdr
));
1053 elf_elfsections (abfd
) = i_shdrp
;
1055 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
1056 if (abfd
->symcount
> 0)
1058 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
1059 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
1060 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
1062 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1064 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1068 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
1069 if (d
->rel_idx
!= 0)
1070 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
1072 /* Fill in the sh_link and sh_info fields while we're at it. */
1074 /* sh_link of a reloc section is the section index of the symbol
1075 table. sh_info is the section index of the section to which
1076 the relocation entries apply. */
1077 if (d
->rel_idx
!= 0)
1079 d
->rel_hdr
.sh_link
= t
->symtab_section
;
1080 d
->rel_hdr
.sh_info
= d
->this_idx
;
1083 switch (d
->this_hdr
.sh_type
)
1087 /* A reloc section which we are treating as a normal BFD
1088 section. sh_link is the section index of the symbol
1089 table. sh_info is the section index of the section to
1090 which the relocation entries apply. We assume that an
1091 allocated reloc section uses the dynamic symbol table.
1092 FIXME: How can we be sure? */
1093 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1095 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1097 /* We look up the section the relocs apply to by name. */
1099 if (d
->this_hdr
.sh_type
== SHT_REL
)
1103 s
= bfd_get_section_by_name (abfd
, name
);
1105 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
1109 /* We assume that a section named .stab*str is a stabs
1110 string section. We look for a section with the same name
1111 but without the trailing ``str'', and set its sh_link
1112 field to point to this section. */
1113 if (strncmp (sec
->name
, ".stab", sizeof ".stab" - 1) == 0
1114 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
1119 len
= strlen (sec
->name
);
1120 alc
= (char *) malloc (len
- 2);
1123 bfd_set_error (bfd_error_no_memory
);
1126 strncpy (alc
, sec
->name
, len
- 3);
1127 alc
[len
- 3] = '\0';
1128 s
= bfd_get_section_by_name (abfd
, alc
);
1132 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
1134 /* This is a .stab section. */
1135 elf_section_data (s
)->this_hdr
.sh_entsize
=
1136 4 + 2 * (bed
->s
->arch_size
/ 8);
1143 /* sh_link is the section header index of the string table
1144 used for the dynamic entries or symbol table. */
1145 s
= bfd_get_section_by_name (abfd
, ".dynstr");
1147 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1151 /* sh_link is the section header index of the symbol table
1152 this hash table is for. */
1153 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1155 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1163 /* Map symbol from it's internal number to the external number, moving
1164 all local symbols to be at the head of the list. */
1167 sym_is_global (abfd
, sym
)
1171 /* If the backend has a special mapping, use it. */
1172 if (get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1173 return ((*get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1176 return ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
1177 || bfd_is_und_section (bfd_get_section (sym
))
1178 || bfd_is_com_section (bfd_get_section (sym
)));
1182 elf_map_symbols (abfd
)
1185 int symcount
= bfd_get_symcount (abfd
);
1186 asymbol
**syms
= bfd_get_outsymbols (abfd
);
1187 asymbol
**sect_syms
;
1189 int num_globals
= 0;
1190 int num_locals2
= 0;
1191 int num_globals2
= 0;
1193 int num_sections
= 0;
1199 fprintf (stderr
, "elf_map_symbols\n");
1203 /* Add a section symbol for each BFD section. FIXME: Is this really
1205 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1207 if (max_index
< asect
->index
)
1208 max_index
= asect
->index
;
1212 sect_syms
= (asymbol
**) bfd_zalloc (abfd
, max_index
* sizeof (asymbol
*));
1213 if (sect_syms
== NULL
)
1215 bfd_set_error (bfd_error_no_memory
);
1218 elf_section_syms (abfd
) = sect_syms
;
1220 for (idx
= 0; idx
< symcount
; idx
++)
1222 if ((syms
[idx
]->flags
& BSF_SECTION_SYM
) != 0
1223 && syms
[idx
]->value
== 0)
1227 sec
= syms
[idx
]->section
;
1228 if (sec
->owner
!= NULL
)
1230 if (sec
->owner
!= abfd
)
1232 if (sec
->output_offset
!= 0)
1234 sec
= sec
->output_section
;
1235 BFD_ASSERT (sec
->owner
== abfd
);
1237 sect_syms
[sec
->index
] = syms
[idx
];
1242 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1246 if (sect_syms
[asect
->index
] != NULL
)
1249 sym
= bfd_make_empty_symbol (abfd
);
1252 sym
->the_bfd
= abfd
;
1253 sym
->name
= asect
->name
;
1255 /* Set the flags to 0 to indicate that this one was newly added. */
1257 sym
->section
= asect
;
1258 sect_syms
[asect
->index
] = sym
;
1262 "creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n",
1263 asect
->name
, (long) asect
->vma
, asect
->index
, (long) asect
);
1267 /* Classify all of the symbols. */
1268 for (idx
= 0; idx
< symcount
; idx
++)
1270 if (!sym_is_global (abfd
, syms
[idx
]))
1275 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1277 if (sect_syms
[asect
->index
] != NULL
1278 && sect_syms
[asect
->index
]->flags
== 0)
1280 sect_syms
[asect
->index
]->flags
= BSF_SECTION_SYM
;
1281 if (!sym_is_global (abfd
, sect_syms
[asect
->index
]))
1285 sect_syms
[asect
->index
]->flags
= 0;
1289 /* Now sort the symbols so the local symbols are first. */
1290 new_syms
= ((asymbol
**)
1292 (num_locals
+ num_globals
) * sizeof (asymbol
*)));
1293 if (new_syms
== NULL
)
1295 bfd_set_error (bfd_error_no_memory
);
1299 for (idx
= 0; idx
< symcount
; idx
++)
1301 asymbol
*sym
= syms
[idx
];
1304 if (!sym_is_global (abfd
, sym
))
1307 i
= num_locals
+ num_globals2
++;
1309 sym
->udata
.i
= i
+ 1;
1311 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1313 if (sect_syms
[asect
->index
] != NULL
1314 && sect_syms
[asect
->index
]->flags
== 0)
1316 asymbol
*sym
= sect_syms
[asect
->index
];
1319 sym
->flags
= BSF_SECTION_SYM
;
1320 if (!sym_is_global (abfd
, sym
))
1323 i
= num_locals
+ num_globals2
++;
1325 sym
->udata
.i
= i
+ 1;
1329 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
1331 elf_num_locals (abfd
) = num_locals
;
1332 elf_num_globals (abfd
) = num_globals
;
1336 /* Compute the file positions we are going to put the sections at, and
1337 otherwise prepare to begin writing out the ELF file. If LINK_INFO
1338 is not NULL, this is being called by the ELF backend linker. */
1341 _bfd_elf_compute_section_file_positions (abfd
, link_info
)
1343 struct bfd_link_info
*link_info
;
1345 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1347 struct bfd_strtab_hash
*strtab
;
1348 Elf_Internal_Shdr
*shstrtab_hdr
;
1350 if (abfd
->output_has_begun
)
1353 /* Do any elf backend specific processing first. */
1354 if (bed
->elf_backend_begin_write_processing
)
1355 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
1357 if (! prep_headers (abfd
))
1361 bfd_map_over_sections (abfd
, elf_fake_sections
, &failed
);
1365 if (!assign_section_numbers (abfd
))
1368 /* The backend linker builds symbol table information itself. */
1369 if (link_info
== NULL
)
1371 if (! swap_out_syms (abfd
, &strtab
))
1375 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
1376 /* sh_name was set in prep_headers. */
1377 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
1378 shstrtab_hdr
->sh_flags
= 0;
1379 shstrtab_hdr
->sh_addr
= 0;
1380 shstrtab_hdr
->sh_size
= _bfd_stringtab_size (elf_shstrtab (abfd
));
1381 shstrtab_hdr
->sh_entsize
= 0;
1382 shstrtab_hdr
->sh_link
= 0;
1383 shstrtab_hdr
->sh_info
= 0;
1384 /* sh_offset is set in assign_file_positions_for_symtabs_and_strtabs. */
1385 shstrtab_hdr
->sh_addralign
= 1;
1387 if (!assign_file_positions_except_relocs (abfd
,
1388 link_info
== NULL
? true : false))
1391 if (link_info
== NULL
)
1393 /* Now that we know where the .strtab section goes, write it
1395 if ((bfd_seek (abfd
, elf_tdata (abfd
)->strtab_hdr
.sh_offset
, SEEK_SET
)
1397 || ! _bfd_stringtab_emit (abfd
, strtab
))
1399 _bfd_stringtab_free (strtab
);
1402 abfd
->output_has_begun
= true;
1408 /* Align to the maximum file alignment that could be required for any
1409 ELF data structure. */
1411 static INLINE file_ptr align_file_position
PARAMS ((file_ptr
, int));
1412 static INLINE file_ptr
1413 align_file_position (off
, align
)
1417 return (off
+ align
- 1) & ~(align
- 1);
1420 /* Assign a file position to a section, optionally aligning to the
1421 required section alignment. */
1424 _bfd_elf_assign_file_position_for_section (i_shdrp
, offset
, align
)
1425 Elf_Internal_Shdr
*i_shdrp
;
1433 al
= i_shdrp
->sh_addralign
;
1435 offset
= BFD_ALIGN (offset
, al
);
1437 i_shdrp
->sh_offset
= offset
;
1438 if (i_shdrp
->bfd_section
!= NULL
)
1439 i_shdrp
->bfd_section
->filepos
= offset
;
1440 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
1441 offset
+= i_shdrp
->sh_size
;
1445 /* Get the size of the program header.
1447 SORTED_HDRS, if non-NULL, is an array of COUNT pointers to headers sorted
1448 by VMA. Non-allocated sections (!SHF_ALLOC) must appear last. All
1449 section VMAs and sizes are known so we can compute the correct value.
1450 (??? This may not be perfectly true. What cases do we miss?)
1452 If SORTED_HDRS is NULL we assume there are two segments: text and data
1453 (exclusive of .interp and .dynamic).
1455 If this is called by the linker before any of the section VMA's are set, it
1456 can't calculate the correct value for a strange memory layout. This only
1457 happens when SIZEOF_HEADERS is used in a linker script. In this case,
1458 SORTED_HDRS is NULL and we assume the normal scenario of one text and one
1459 data segment (exclusive of .interp and .dynamic).
1461 ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
1462 will be two segments. */
1464 static bfd_size_type
1465 get_program_header_size (abfd
, sorted_hdrs
, count
, maxpagesize
)
1467 Elf_Internal_Shdr
**sorted_hdrs
;
1469 bfd_vma maxpagesize
;
1473 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1475 /* We can't return a different result each time we're called. */
1476 if (elf_tdata (abfd
)->program_header_size
!= 0)
1477 return elf_tdata (abfd
)->program_header_size
;
1479 if (sorted_hdrs
!= NULL
)
1482 unsigned int last_type
;
1483 Elf_Internal_Shdr
**hdrpp
;
1484 /* What we think the current segment's offset is. */
1486 /* What we think the current segment's address is. */
1488 /* How big we think the current segment is. */
1490 /* What we think the current file offset is. */
1491 bfd_vma file_offset
;
1492 bfd_vma next_offset
;
1494 /* Scan the headers and compute the number of segments required. This
1495 code is intentionally similar to the code in map_program_segments.
1497 The `sh_offset' field isn't valid at this point, so we keep our own
1498 running total in `file_offset'.
1500 This works because section VMAs are already known. */
1503 /* Make sure the first section goes in the first segment. */
1504 file_offset
= p_offset
= sorted_hdrs
[0]->sh_addr
% maxpagesize
;
1505 p_vaddr
= sorted_hdrs
[0]->sh_addr
;
1507 last_type
= SHT_PROGBITS
;
1509 for (i
= 0, hdrpp
= sorted_hdrs
; i
< count
; i
++, hdrpp
++)
1511 Elf_Internal_Shdr
*hdr
;
1515 /* Ignore any section which will not be part of the process
1517 if ((hdr
->sh_flags
& SHF_ALLOC
) == 0)
1520 /* Keep track of where this and the next sections go.
1521 The section VMA must equal the file position modulo
1523 file_offset
+= (hdr
->sh_addr
- file_offset
) % maxpagesize
;
1524 next_offset
= file_offset
;
1525 if (hdr
->sh_type
!= SHT_NOBITS
)
1526 next_offset
= file_offset
+ hdr
->sh_size
;
1528 /* If this section fits in the segment we are constructing, add
1530 if ((file_offset
- (p_offset
+ p_memsz
)
1531 == hdr
->sh_addr
- (p_vaddr
+ p_memsz
))
1532 && (last_type
!= SHT_NOBITS
|| hdr
->sh_type
== SHT_NOBITS
))
1534 bfd_size_type adjust
;
1536 adjust
= hdr
->sh_addr
- (p_vaddr
+ p_memsz
);
1537 p_memsz
+= hdr
->sh_size
+ adjust
;
1538 file_offset
= next_offset
;
1539 last_type
= hdr
->sh_type
;
1543 /* The section won't fit, start a new segment. */
1546 /* Initialize the segment. */
1547 p_vaddr
= hdr
->sh_addr
;
1548 p_memsz
= hdr
->sh_size
;
1549 p_offset
= file_offset
;
1550 file_offset
= next_offset
;
1552 last_type
= hdr
->sh_type
;
1557 /* Assume we will need exactly two PT_LOAD segments: one for text
1558 and one for data. */
1562 s
= bfd_get_section_by_name (abfd
, ".interp");
1563 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
1565 /* If we have a loadable interpreter section, we need a
1566 PT_INTERP segment. In this case, assume we also need a
1567 PT_PHDR segment, although that may not be true for all
1572 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
1574 /* We need a PT_DYNAMIC segment. */
1578 /* Let the backend count up any program headers it might need. */
1579 if (bed
->elf_backend_create_program_headers
)
1580 segs
= ((*bed
->elf_backend_create_program_headers
)
1581 (abfd
, (Elf_Internal_Phdr
*) NULL
, segs
));
1583 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
1584 return elf_tdata (abfd
)->program_header_size
;
1587 /* Create the program header. OFF is the file offset where the
1588 program header should be written. FIRST is the first loadable ELF
1589 section. SORTED_HDRS is the ELF sections sorted by section
1590 address. PHDR_SIZE is the size of the program header as returned
1591 by get_program_header_size. */
1594 map_program_segments (abfd
, off
, first
, sorted_hdrs
, phdr_size
)
1597 Elf_Internal_Shdr
*first
;
1598 Elf_Internal_Shdr
**sorted_hdrs
;
1599 bfd_size_type phdr_size
;
1601 Elf_Internal_Phdr phdrs
[10];
1602 unsigned int phdr_count
;
1603 Elf_Internal_Phdr
*phdr
;
1604 int phdr_size_adjust
;
1606 Elf_Internal_Shdr
**hdrpp
;
1607 asection
*sinterp
, *sdyn
;
1608 unsigned int last_type
;
1609 Elf_Internal_Ehdr
*i_ehdrp
;
1610 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1612 BFD_ASSERT ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0);
1613 BFD_ASSERT (phdr_size
/ sizeof (Elf_Internal_Phdr
)
1614 <= sizeof phdrs
/ sizeof (phdrs
[0]));
1619 if (bed
->want_hdr_in_seg
)
1620 phdr_size_adjust
= first
->sh_offset
- phdr_size
;
1622 phdr_size_adjust
= 0;
1624 /* If we have a loadable .interp section, we must create a PT_INTERP
1625 segment which must precede all PT_LOAD segments. We assume that
1626 we must also create a PT_PHDR segment, although that may not be
1627 true for all targets. */
1628 sinterp
= bfd_get_section_by_name (abfd
, ".interp");
1629 if (sinterp
!= NULL
&& (sinterp
->flags
& SEC_LOAD
) != 0)
1631 BFD_ASSERT (first
!= NULL
);
1633 phdr
->p_type
= PT_PHDR
;
1635 phdr
->p_offset
= off
;
1637 /* Account for any adjustment made because of the alignment of
1638 the first loadable section. */
1639 phdr_size_adjust
= (first
->sh_offset
- phdr_size
) - off
;
1640 BFD_ASSERT (phdr_size_adjust
>= 0 && phdr_size_adjust
< 128);
1642 /* The program header precedes all loadable sections. This lets
1643 us compute its loadable address. This depends on the linker
1645 phdr
->p_vaddr
= first
->sh_addr
- (phdr_size
+ phdr_size_adjust
);
1648 phdr
->p_filesz
= phdr_size
;
1649 phdr
->p_memsz
= phdr_size
;
1651 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
1652 phdr
->p_flags
= PF_R
| PF_X
;
1654 phdr
->p_align
= bed
->s
->file_align
;
1655 BFD_ASSERT ((phdr
->p_vaddr
- phdr
->p_offset
) % bed
->s
->file_align
== 0);
1657 /* Include the ELF header in the first loadable segment. */
1658 phdr_size_adjust
+= off
;
1663 phdr
->p_type
= PT_INTERP
;
1664 phdr
->p_offset
= sinterp
->filepos
;
1665 phdr
->p_vaddr
= sinterp
->vma
;
1667 phdr
->p_filesz
= sinterp
->_raw_size
;
1668 phdr
->p_memsz
= sinterp
->_raw_size
;
1669 phdr
->p_flags
= PF_R
;
1670 phdr
->p_align
= 1 << bfd_get_section_alignment (abfd
, sinterp
);
1676 /* Look through the sections to see how they will be divided into
1677 program segments. The sections must be arranged in order by
1678 sh_addr for this to work correctly. */
1679 phdr
->p_type
= PT_NULL
;
1680 last_type
= SHT_PROGBITS
;
1681 for (i
= 1, hdrpp
= sorted_hdrs
;
1682 i
< elf_elfheader (abfd
)->e_shnum
;
1685 Elf_Internal_Shdr
*hdr
;
1689 /* Ignore any section which will not be part of the process
1691 if ((hdr
->sh_flags
& SHF_ALLOC
) == 0)
1694 /* If this section fits in the segment we are constructing, add
1696 if (phdr
->p_type
!= PT_NULL
1697 && (hdr
->sh_offset
- (phdr
->p_offset
+ phdr
->p_memsz
)
1698 == hdr
->sh_addr
- (phdr
->p_vaddr
+ phdr
->p_memsz
))
1699 && (last_type
!= SHT_NOBITS
|| hdr
->sh_type
== SHT_NOBITS
))
1701 bfd_size_type adjust
;
1703 adjust
= hdr
->sh_addr
- (phdr
->p_vaddr
+ phdr
->p_memsz
);
1704 phdr
->p_memsz
+= hdr
->sh_size
+ adjust
;
1705 if (hdr
->sh_type
!= SHT_NOBITS
)
1706 phdr
->p_filesz
+= hdr
->sh_size
+ adjust
;
1707 if ((hdr
->sh_flags
& SHF_WRITE
) != 0)
1708 phdr
->p_flags
|= PF_W
;
1709 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
1710 phdr
->p_flags
|= PF_X
;
1711 last_type
= hdr
->sh_type
;
1715 /* The section won't fit, start a new segment. If we're already in one,
1716 move to the next one. */
1717 if (phdr
->p_type
!= PT_NULL
)
1723 /* Initialize the segment. */
1724 phdr
->p_type
= PT_LOAD
;
1725 phdr
->p_offset
= hdr
->sh_offset
;
1726 phdr
->p_vaddr
= hdr
->sh_addr
;
1728 if (hdr
->sh_type
== SHT_NOBITS
)
1731 phdr
->p_filesz
= hdr
->sh_size
;
1732 phdr
->p_memsz
= hdr
->sh_size
;
1733 phdr
->p_flags
= PF_R
;
1734 if ((hdr
->sh_flags
& SHF_WRITE
) != 0)
1735 phdr
->p_flags
|= PF_W
;
1736 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
1737 phdr
->p_flags
|= PF_X
;
1738 phdr
->p_align
= bed
->maxpagesize
;
1741 && (bed
->want_hdr_in_seg
1743 && (sinterp
->flags
& SEC_LOAD
) != 0)))
1745 phdr
->p_offset
-= phdr_size
+ phdr_size_adjust
;
1746 phdr
->p_vaddr
-= phdr_size
+ phdr_size_adjust
;
1747 phdr
->p_filesz
+= phdr_size
+ phdr_size_adjust
;
1748 phdr
->p_memsz
+= phdr_size
+ phdr_size_adjust
;
1751 last_type
= hdr
->sh_type
;
1754 if (phdr
->p_type
!= PT_NULL
)
1760 /* If we have a .dynamic section, create a PT_DYNAMIC segment. */
1761 sdyn
= bfd_get_section_by_name (abfd
, ".dynamic");
1762 if (sdyn
!= NULL
&& (sdyn
->flags
& SEC_LOAD
) != 0)
1764 phdr
->p_type
= PT_DYNAMIC
;
1765 phdr
->p_offset
= sdyn
->filepos
;
1766 phdr
->p_vaddr
= sdyn
->vma
;
1768 phdr
->p_filesz
= sdyn
->_raw_size
;
1769 phdr
->p_memsz
= sdyn
->_raw_size
;
1770 phdr
->p_flags
= PF_R
;
1771 if ((sdyn
->flags
& SEC_READONLY
) == 0)
1772 phdr
->p_flags
|= PF_W
;
1773 if ((sdyn
->flags
& SEC_CODE
) != 0)
1774 phdr
->p_flags
|= PF_X
;
1775 phdr
->p_align
= 1 << bfd_get_section_alignment (abfd
, sdyn
);
1781 /* Let the backend create additional program headers. */
1782 if (bed
->elf_backend_create_program_headers
)
1783 phdr_count
= (*bed
->elf_backend_create_program_headers
) (abfd
,
1787 /* Make sure the return value from get_program_header_size matches
1788 what we computed here. Actually, it's OK if we allocated too
1789 much space in the program header. */
1790 if (phdr_count
> phdr_size
/ bed
->s
->sizeof_phdr
)
1792 ((*_bfd_error_handler
)
1793 ("%s: Not enough room for program headers (allocated %lu, need %u)",
1794 bfd_get_filename (abfd
),
1795 (unsigned long) (phdr_size
/ bed
->s
->sizeof_phdr
),
1797 bfd_set_error (bfd_error_bad_value
);
1798 return (file_ptr
) -1;
1801 /* Set up program header information. */
1802 i_ehdrp
= elf_elfheader (abfd
);
1803 i_ehdrp
->e_phentsize
= bed
->s
->sizeof_phdr
;
1804 i_ehdrp
->e_phoff
= off
;
1805 i_ehdrp
->e_phnum
= phdr_count
;
1807 /* Save the program headers away. I don't think anybody uses this
1808 information right now. */
1809 elf_tdata (abfd
)->phdr
= ((Elf_Internal_Phdr
*)
1812 * sizeof (Elf_Internal_Phdr
))));
1813 if (elf_tdata (abfd
)->phdr
== NULL
&& phdr_count
!= 0)
1815 bfd_set_error (bfd_error_no_memory
);
1816 return (file_ptr
) -1;
1818 memcpy (elf_tdata (abfd
)->phdr
, phdrs
,
1819 phdr_count
* sizeof (Elf_Internal_Phdr
));
1821 /* Write out the program headers. */
1822 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0)
1823 return (file_ptr
) -1;
1825 if (bed
->s
->write_out_phdrs (abfd
, phdrs
, phdr_count
) != 0)
1826 return (file_ptr
) -1;
1828 return off
+ phdr_count
* bed
->s
->sizeof_phdr
;
1831 /* Work out the file positions of all the sections. This is called by
1832 _bfd_elf_compute_section_file_positions. All the section sizes and
1833 VMAs must be known before this is called.
1835 We do not consider reloc sections at this point, unless they form
1836 part of the loadable image. Reloc sections are assigned file
1837 positions in assign_file_positions_for_relocs, which is called by
1838 write_object_contents and final_link.
1840 If DOSYMS is false, we do not assign file positions for the symbol
1841 table or the string table. */
1843 static int elf_sort_hdrs
PARAMS ((const PTR
, const PTR
));
1846 assign_file_positions_except_relocs (abfd
, dosyms
)
1850 struct elf_obj_tdata
* const tdata
= elf_tdata (abfd
);
1851 Elf_Internal_Ehdr
* const i_ehdrp
= elf_elfheader (abfd
);
1852 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
1854 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1856 /* Start after the ELF header. */
1857 off
= i_ehdrp
->e_ehsize
;
1859 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
1861 Elf_Internal_Shdr
**hdrpp
;
1864 /* We are not creating an executable, which means that we are
1865 not creating a program header, and that the actual order of
1866 the sections in the file is unimportant. */
1867 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
1869 Elf_Internal_Shdr
*hdr
;
1872 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
1874 hdr
->sh_offset
= -1;
1878 && (i
== tdata
->symtab_section
1879 || i
== tdata
->strtab_section
))
1881 hdr
->sh_offset
= -1;
1885 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
1891 bfd_size_type phdr_size
;
1892 bfd_vma maxpagesize
;
1894 Elf_Internal_Shdr
**sorted_hdrs
;
1895 Elf_Internal_Shdr
**hdrpp
;
1897 Elf_Internal_Shdr
*first
;
1900 /* We are creating an executable. */
1902 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
1903 if (maxpagesize
== 0)
1906 /* We must sort the sections. The GNU linker will always create
1907 the sections in an appropriate order, but the Irix 5 linker
1908 will not. We don't include the dummy first section in the
1909 sort. We sort sections which are not SHF_ALLOC to the end. */
1910 hdrppsize
= (i_ehdrp
->e_shnum
- 1) * sizeof (Elf_Internal_Shdr
*);
1911 sorted_hdrs
= (Elf_Internal_Shdr
**) malloc (hdrppsize
);
1912 if (sorted_hdrs
== NULL
)
1914 bfd_set_error (bfd_error_no_memory
);
1918 memcpy (sorted_hdrs
, i_shdrpp
+ 1, hdrppsize
);
1919 qsort (sorted_hdrs
, (size_t) i_ehdrp
->e_shnum
- 1,
1920 sizeof (Elf_Internal_Shdr
*), elf_sort_hdrs
);
1922 /* We can't actually create the program header until we have set the
1923 file positions for the sections, and we can't do that until we know
1924 how big the header is going to be. */
1925 off
= align_file_position (off
, bed
->s
->file_align
);
1926 phdr_size
= get_program_header_size (abfd
,
1927 sorted_hdrs
, i_ehdrp
->e_shnum
- 1,
1929 if (phdr_size
== (bfd_size_type
) -1)
1932 /* Compute the file offsets of each section. */
1936 for (i
= 1, hdrpp
= sorted_hdrs
; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
1938 Elf_Internal_Shdr
*hdr
;
1941 if ((hdr
->sh_flags
& SHF_ALLOC
) == 0)
1943 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
1945 hdr
->sh_offset
= -1;
1949 && (hdr
== i_shdrpp
[tdata
->symtab_section
]
1950 || hdr
== i_shdrpp
[tdata
->strtab_section
]))
1952 hdr
->sh_offset
= -1;
1955 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
,
1963 /* The section VMA must equal the file position modulo
1964 the page size. This is required by the program
1966 off
+= (hdr
->sh_addr
- off
) % maxpagesize
;
1967 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
,
1972 /* Create the program header. */
1973 phdr_map
= map_program_segments (abfd
, phdr_off
, first
, sorted_hdrs
,
1975 if (phdr_map
== (file_ptr
) -1)
1977 BFD_ASSERT ((bfd_size_type
) phdr_map
1978 <= (bfd_size_type
) phdr_off
+ phdr_size
);
1983 /* Place the section headers. */
1984 off
= align_file_position (off
, bed
->s
->file_align
);
1985 i_ehdrp
->e_shoff
= off
;
1986 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
1988 elf_tdata (abfd
)->next_file_pos
= off
;
1993 /* Sort the ELF headers by VMA. We sort headers which are not
1994 SHF_ALLOC to the end. */
1996 elf_sort_hdrs (arg1
, arg2
)
2001 const Elf_Internal_Shdr
*hdr1
= *(const Elf_Internal_Shdr
**) arg1
;
2002 const Elf_Internal_Shdr
*hdr2
= *(const Elf_Internal_Shdr
**) arg2
;
2004 #define TOEND(x) (((x)->sh_flags & SHF_ALLOC)==0)
2015 if (hdr1
->sh_addr
< hdr2
->sh_addr
)
2017 else if (hdr1
->sh_addr
> hdr2
->sh_addr
)
2020 /* Put !SHT_NOBITS sections before SHT_NOBITS ones.
2021 The main loop in map_program_segments requires this. */
2023 ret
= (hdr1
->sh_type
== SHT_NOBITS
) - (hdr2
->sh_type
== SHT_NOBITS
);
2027 if (hdr1
->sh_size
< hdr2
->sh_size
)
2029 if (hdr1
->sh_size
> hdr2
->sh_size
)
2038 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2039 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
2040 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2042 struct bfd_strtab_hash
*shstrtab
;
2043 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2045 i_ehdrp
= elf_elfheader (abfd
);
2046 i_shdrp
= elf_elfsections (abfd
);
2048 shstrtab
= _bfd_elf_stringtab_init ();
2049 if (shstrtab
== NULL
)
2052 elf_shstrtab (abfd
) = shstrtab
;
2054 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
2055 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
2056 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
2057 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
2059 i_ehdrp
->e_ident
[EI_CLASS
] = bed
->s
->elfclass
;
2060 i_ehdrp
->e_ident
[EI_DATA
] =
2061 abfd
->xvec
->byteorder_big_p
? ELFDATA2MSB
: ELFDATA2LSB
;
2062 i_ehdrp
->e_ident
[EI_VERSION
] = bed
->s
->ev_current
;
2064 for (count
= EI_PAD
; count
< EI_NIDENT
; count
++)
2065 i_ehdrp
->e_ident
[count
] = 0;
2067 if ((abfd
->flags
& DYNAMIC
) != 0)
2068 i_ehdrp
->e_type
= ET_DYN
;
2069 else if ((abfd
->flags
& EXEC_P
) != 0)
2070 i_ehdrp
->e_type
= ET_EXEC
;
2072 i_ehdrp
->e_type
= ET_REL
;
2074 switch (bfd_get_arch (abfd
))
2076 case bfd_arch_unknown
:
2077 i_ehdrp
->e_machine
= EM_NONE
;
2079 case bfd_arch_sparc
:
2080 if (bed
->s
->arch_size
== 64)
2081 i_ehdrp
->e_machine
= EM_SPARC64
;
2083 i_ehdrp
->e_machine
= EM_SPARC
;
2086 i_ehdrp
->e_machine
= EM_386
;
2089 i_ehdrp
->e_machine
= EM_68K
;
2092 i_ehdrp
->e_machine
= EM_88K
;
2095 i_ehdrp
->e_machine
= EM_860
;
2097 case bfd_arch_mips
: /* MIPS Rxxxx */
2098 i_ehdrp
->e_machine
= EM_MIPS
; /* only MIPS R3000 */
2101 i_ehdrp
->e_machine
= EM_PARISC
;
2103 case bfd_arch_powerpc
:
2104 i_ehdrp
->e_machine
= EM_PPC
;
2106 /* start-sanitize-arc */
2108 i_ehdrp
->e_machine
= EM_CYGNUS_ARC
;
2110 /* end-sanitize-arc */
2111 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
2113 i_ehdrp
->e_machine
= EM_NONE
;
2115 i_ehdrp
->e_version
= bed
->s
->ev_current
;
2116 i_ehdrp
->e_ehsize
= bed
->s
->sizeof_ehdr
;
2118 /* no program header, for now. */
2119 i_ehdrp
->e_phoff
= 0;
2120 i_ehdrp
->e_phentsize
= 0;
2121 i_ehdrp
->e_phnum
= 0;
2123 /* each bfd section is section header entry */
2124 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
2125 i_ehdrp
->e_shentsize
= bed
->s
->sizeof_shdr
;
2127 /* if we're building an executable, we'll need a program header table */
2128 if (abfd
->flags
& EXEC_P
)
2130 /* it all happens later */
2132 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
2134 /* elf_build_phdrs() returns a (NULL-terminated) array of
2135 Elf_Internal_Phdrs */
2136 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
2137 i_ehdrp
->e_phoff
= outbase
;
2138 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
2143 i_ehdrp
->e_phentsize
= 0;
2145 i_ehdrp
->e_phoff
= 0;
2148 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
2149 (unsigned int) _bfd_stringtab_add (shstrtab
, ".symtab", true, false);
2150 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
2151 (unsigned int) _bfd_stringtab_add (shstrtab
, ".strtab", true, false);
2152 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
2153 (unsigned int) _bfd_stringtab_add (shstrtab
, ".shstrtab", true, false);
2154 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2155 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2156 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
2162 /* Assign file positions for all the reloc sections which are not part
2163 of the loadable file image. */
2166 _bfd_elf_assign_file_positions_for_relocs (abfd
)
2171 Elf_Internal_Shdr
**shdrpp
;
2173 off
= elf_tdata (abfd
)->next_file_pos
;
2175 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1;
2176 i
< elf_elfheader (abfd
)->e_shnum
;
2179 Elf_Internal_Shdr
*shdrp
;
2182 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
2183 && shdrp
->sh_offset
== -1)
2184 off
= _bfd_elf_assign_file_position_for_section (shdrp
, off
, true);
2187 elf_tdata (abfd
)->next_file_pos
= off
;
2191 _bfd_elf_write_object_contents (abfd
)
2194 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2195 Elf_Internal_Ehdr
*i_ehdrp
;
2196 Elf_Internal_Shdr
**i_shdrp
;
2200 if (! abfd
->output_has_begun
2201 && ! _bfd_elf_compute_section_file_positions (abfd
,
2202 (struct bfd_link_info
*) NULL
))
2205 i_shdrp
= elf_elfsections (abfd
);
2206 i_ehdrp
= elf_elfheader (abfd
);
2209 bfd_map_over_sections (abfd
, bed
->s
->write_relocs
, &failed
);
2212 _bfd_elf_assign_file_positions_for_relocs (abfd
);
2214 /* After writing the headers, we need to write the sections too... */
2215 for (count
= 1; count
< i_ehdrp
->e_shnum
; count
++)
2217 if (bed
->elf_backend_section_processing
)
2218 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
2219 if (i_shdrp
[count
]->contents
)
2221 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
2222 || (bfd_write (i_shdrp
[count
]->contents
, i_shdrp
[count
]->sh_size
,
2224 != i_shdrp
[count
]->sh_size
))
2229 /* Write out the section header names. */
2230 if (bfd_seek (abfd
, elf_tdata (abfd
)->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
2231 || ! _bfd_stringtab_emit (abfd
, elf_shstrtab (abfd
)))
2234 if (bed
->elf_backend_final_write_processing
)
2235 (*bed
->elf_backend_final_write_processing
) (abfd
,
2236 elf_tdata (abfd
)->linker
);
2238 return bed
->s
->write_shdrs_and_ehdr (abfd
);
2241 /* given a section, search the header to find them... */
2243 _bfd_elf_section_from_bfd_section (abfd
, asect
)
2247 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2248 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
2250 Elf_Internal_Shdr
*hdr
;
2251 int maxindex
= elf_elfheader (abfd
)->e_shnum
;
2253 for (index
= 0; index
< maxindex
; index
++)
2255 hdr
= i_shdrp
[index
];
2256 if (hdr
->bfd_section
== asect
)
2260 if (bed
->elf_backend_section_from_bfd_section
)
2262 for (index
= 0; index
< maxindex
; index
++)
2266 hdr
= i_shdrp
[index
];
2268 if ((*bed
->elf_backend_section_from_bfd_section
)
2269 (abfd
, hdr
, asect
, &retval
))
2274 if (bfd_is_abs_section (asect
))
2276 if (bfd_is_com_section (asect
))
2278 if (bfd_is_und_section (asect
))
2284 /* given a symbol, return the bfd index for that symbol. */
2286 _bfd_elf_symbol_from_bfd_symbol (abfd
, asym_ptr_ptr
)
2288 struct symbol_cache_entry
**asym_ptr_ptr
;
2290 struct symbol_cache_entry
*asym_ptr
= *asym_ptr_ptr
;
2292 flagword flags
= asym_ptr
->flags
;
2294 /* When gas creates relocations against local labels, it creates its
2295 own symbol for the section, but does put the symbol into the
2296 symbol chain, so udata is 0. When the linker is generating
2297 relocatable output, this section symbol may be for one of the
2298 input sections rather than the output section. */
2299 if (asym_ptr
->udata
.i
== 0
2300 && (flags
& BSF_SECTION_SYM
)
2301 && asym_ptr
->section
)
2305 if (asym_ptr
->section
->output_section
!= NULL
)
2306 indx
= asym_ptr
->section
->output_section
->index
;
2308 indx
= asym_ptr
->section
->index
;
2309 if (elf_section_syms (abfd
)[indx
])
2310 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
2313 idx
= asym_ptr
->udata
.i
;
2314 BFD_ASSERT (idx
!= 0);
2319 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
2320 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
, elf_symbol_flags (flags
));
2329 swap_out_syms (abfd
, sttp
)
2331 struct bfd_strtab_hash
**sttp
;
2333 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2335 if (!elf_map_symbols (abfd
))
2338 /* Dump out the symtabs. */
2340 int symcount
= bfd_get_symcount (abfd
);
2341 asymbol
**syms
= bfd_get_outsymbols (abfd
);
2342 struct bfd_strtab_hash
*stt
;
2343 Elf_Internal_Shdr
*symtab_hdr
;
2344 Elf_Internal_Shdr
*symstrtab_hdr
;
2345 char *outbound_syms
;
2348 stt
= _bfd_elf_stringtab_init ();
2352 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2353 symtab_hdr
->sh_type
= SHT_SYMTAB
;
2354 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
2355 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
2356 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
2357 symtab_hdr
->sh_addralign
= bed
->s
->file_align
;
2359 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2360 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2362 outbound_syms
= bfd_alloc (abfd
,
2363 (1 + symcount
) * bed
->s
->sizeof_sym
);
2364 if (outbound_syms
== NULL
)
2366 bfd_set_error (bfd_error_no_memory
);
2369 symtab_hdr
->contents
= (PTR
) outbound_syms
;
2371 /* now generate the data (for "contents") */
2373 /* Fill in zeroth symbol and swap it out. */
2374 Elf_Internal_Sym sym
;
2380 sym
.st_shndx
= SHN_UNDEF
;
2381 bed
->s
->swap_symbol_out (abfd
, &sym
, (PTR
) outbound_syms
);
2382 outbound_syms
+= bed
->s
->sizeof_sym
;
2384 for (idx
= 0; idx
< symcount
; idx
++)
2386 Elf_Internal_Sym sym
;
2387 bfd_vma value
= syms
[idx
]->value
;
2388 elf_symbol_type
*type_ptr
;
2389 flagword flags
= syms
[idx
]->flags
;
2391 if (flags
& BSF_SECTION_SYM
)
2392 /* Section symbols have no names. */
2396 sym
.st_name
= (unsigned long) _bfd_stringtab_add (stt
,
2399 if (sym
.st_name
== (unsigned long) -1)
2403 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
2405 if (bfd_is_com_section (syms
[idx
]->section
))
2407 /* ELF common symbols put the alignment into the `value' field,
2408 and the size into the `size' field. This is backwards from
2409 how BFD handles it, so reverse it here. */
2410 sym
.st_size
= value
;
2411 if (type_ptr
== NULL
2412 || type_ptr
->internal_elf_sym
.st_value
== 0)
2413 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
2415 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
2416 sym
.st_shndx
= _bfd_elf_section_from_bfd_section (abfd
,
2417 syms
[idx
]->section
);
2421 asection
*sec
= syms
[idx
]->section
;
2424 if (sec
->output_section
)
2426 value
+= sec
->output_offset
;
2427 sec
= sec
->output_section
;
2430 sym
.st_value
= value
;
2431 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
2432 sym
.st_shndx
= shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
2436 /* Writing this would be a hell of a lot easier if we had
2437 some decent documentation on bfd, and knew what to expect
2438 of the library, and what to demand of applications. For
2439 example, it appears that `objcopy' might not set the
2440 section of a symbol to be a section that is actually in
2442 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
2443 BFD_ASSERT (sec2
!= 0);
2444 sym
.st_shndx
= shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
2445 BFD_ASSERT (shndx
!= -1);
2449 if (bfd_is_com_section (syms
[idx
]->section
))
2450 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_OBJECT
);
2451 else if (bfd_is_und_section (syms
[idx
]->section
))
2452 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
2455 ((flags
& BSF_FUNCTION
)
2458 else if (flags
& BSF_SECTION_SYM
)
2459 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
2460 else if (flags
& BSF_FILE
)
2461 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
2464 int bind
= STB_LOCAL
;
2465 int type
= STT_OBJECT
;
2467 if (flags
& BSF_LOCAL
)
2469 else if (flags
& BSF_WEAK
)
2471 else if (flags
& BSF_GLOBAL
)
2474 if (flags
& BSF_FUNCTION
)
2477 sym
.st_info
= ELF_ST_INFO (bind
, type
);
2481 bed
->s
->swap_symbol_out (abfd
, &sym
, (PTR
) outbound_syms
);
2482 outbound_syms
+= bed
->s
->sizeof_sym
;
2486 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (stt
);
2487 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2489 symstrtab_hdr
->sh_flags
= 0;
2490 symstrtab_hdr
->sh_addr
= 0;
2491 symstrtab_hdr
->sh_entsize
= 0;
2492 symstrtab_hdr
->sh_link
= 0;
2493 symstrtab_hdr
->sh_info
= 0;
2494 symstrtab_hdr
->sh_addralign
= 1;
2500 /* Return the number of bytes required to hold the symtab vector.
2502 Note that we base it on the count plus 1, since we will null terminate
2503 the vector allocated based on this size. However, the ELF symbol table
2504 always has a dummy entry as symbol #0, so it ends up even. */
2507 _bfd_elf_get_symtab_upper_bound (abfd
)
2512 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2514 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
2515 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
2521 _bfd_elf_get_dynamic_symtab_upper_bound (abfd
)
2526 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2528 if (elf_dynsymtab (abfd
) == 0)
2530 bfd_set_error (bfd_error_invalid_operation
);
2534 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
2535 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
2541 _bfd_elf_get_reloc_upper_bound (abfd
, asect
)
2545 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
2548 /* Canonicalize the relocs. */
2551 _bfd_elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
2560 if (! get_elf_backend_data (abfd
)->s
->slurp_reloc_table (abfd
, section
, symbols
))
2563 tblptr
= section
->relocation
;
2564 for (i
= 0; i
< section
->reloc_count
; i
++)
2565 *relptr
++ = tblptr
++;
2569 return section
->reloc_count
;
2573 _bfd_elf_get_symtab (abfd
, alocation
)
2575 asymbol
**alocation
;
2577 long symcount
= get_elf_backend_data (abfd
)->s
->slurp_symbol_table (abfd
, alocation
, false);
2580 bfd_get_symcount (abfd
) = symcount
;
2585 _bfd_elf_canonicalize_dynamic_symtab (abfd
, alocation
)
2587 asymbol
**alocation
;
2589 return get_elf_backend_data (abfd
)->s
->slurp_symbol_table (abfd
, alocation
, true);
2593 _bfd_elf_make_empty_symbol (abfd
)
2596 elf_symbol_type
*newsym
;
2598 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (elf_symbol_type
));
2601 bfd_set_error (bfd_error_no_memory
);
2606 newsym
->symbol
.the_bfd
= abfd
;
2607 return &newsym
->symbol
;
2612 _bfd_elf_get_symbol_info (ignore_abfd
, symbol
, ret
)
2617 bfd_symbol_info (symbol
, ret
);
2621 _bfd_elf_get_lineno (ignore_abfd
, symbol
)
2630 _bfd_elf_set_arch_mach (abfd
, arch
, machine
)
2632 enum bfd_architecture arch
;
2633 unsigned long machine
;
2635 /* If this isn't the right architecture for this backend, and this
2636 isn't the generic backend, fail. */
2637 if (arch
!= get_elf_backend_data (abfd
)->arch
2638 && arch
!= bfd_arch_unknown
2639 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
2642 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
2645 /* Find the nearest line to a particular section and offset, for error
2649 _bfd_elf_find_nearest_line (abfd
,
2660 CONST
char **filename_ptr
;
2661 CONST
char **functionname_ptr
;
2662 unsigned int *line_ptr
;
2664 const char *filename
;
2668 if (symbols
== NULL
)
2674 for (p
= symbols
; *p
!= NULL
; p
++)
2678 q
= (elf_symbol_type
*) *p
;
2680 if (bfd_get_section (&q
->symbol
) != section
)
2683 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
2688 filename
= bfd_asymbol_name (&q
->symbol
);
2692 || q
->symbol
.value
<= offset
)
2693 func
= (asymbol
*) q
;
2701 *filename_ptr
= filename
;
2702 *functionname_ptr
= bfd_asymbol_name (func
);
2708 _bfd_elf_sizeof_headers (abfd
, reloc
)
2714 ret
= get_elf_backend_data (abfd
)->s
->sizeof_ehdr
;
2716 ret
+= get_program_header_size (abfd
, (Elf_Internal_Shdr
**) NULL
, 0,
2722 _bfd_elf_set_section_contents (abfd
, section
, location
, offset
, count
)
2727 bfd_size_type count
;
2729 Elf_Internal_Shdr
*hdr
;
2731 if (! abfd
->output_has_begun
2732 && ! _bfd_elf_compute_section_file_positions (abfd
,
2733 (struct bfd_link_info
*) NULL
))
2736 hdr
= &elf_section_data (section
)->this_hdr
;
2738 if (bfd_seek (abfd
, hdr
->sh_offset
+ offset
, SEEK_SET
) == -1)
2740 if (bfd_write (location
, 1, count
, abfd
) != count
)
2747 _bfd_elf_no_info_to_howto (abfd
, cache_ptr
, dst
)
2750 Elf_Internal_Rela
*dst
;
2757 _bfd_elf_no_info_to_howto_rel (abfd
, cache_ptr
, dst
)
2760 Elf_Internal_Rel
*dst
;