1 /* ELF linking support for BFD.
2 Copyright 1995 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. */
28 _bfd_elf_create_got_section (abfd
, info
)
30 struct bfd_link_info
*info
;
34 struct elf_link_hash_entry
*h
;
35 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
37 /* This function may be called more than once. */
38 if (bfd_get_section_by_name (abfd
, ".got") != NULL
)
41 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
43 s
= bfd_make_section (abfd
, ".got");
45 || !bfd_set_section_flags (abfd
, s
, flags
)
46 || !bfd_set_section_alignment (abfd
, s
, 2))
49 if (bed
->want_got_plt
)
51 s
= bfd_make_section (abfd
, ".got.plt");
53 || !bfd_set_section_flags (abfd
, s
, flags
)
54 || !bfd_set_section_alignment (abfd
, s
, 2))
58 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
59 (or .got.plt) section. We don't do this in the linker script
60 because we don't want to define the symbol if we are not creating
61 a global offset table. */
63 if (!(_bfd_generic_link_add_one_symbol
64 (info
, abfd
, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL
, s
, (bfd_vma
) 0,
65 (const char *) NULL
, false, get_elf_backend_data (abfd
)->collect
,
66 (struct bfd_link_hash_entry
**) &h
)))
68 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
72 && ! _bfd_elf_link_record_dynamic_symbol (info
, h
))
75 /* The first three global offset table entries are reserved. */
76 s
->_raw_size
+= 3 * 4;
82 /* Create dynamic sections when linking against a dynamic object. */
85 _bfd_elf_create_dynamic_sections (abfd
, info
)
87 struct bfd_link_info
*info
;
91 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
93 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
94 .rel[a].bss sections. */
96 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
;
98 s
= bfd_make_section (abfd
, ".plt");
100 || ! bfd_set_section_flags (abfd
, s
,
102 | (bed
->plt_readonly
? SEC_READONLY
: 0)))
103 || ! bfd_set_section_alignment (abfd
, s
, 2))
106 if (bed
->want_plt_sym
)
108 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
110 struct elf_link_hash_entry
*h
= NULL
;
111 if (! (_bfd_generic_link_add_one_symbol
112 (info
, abfd
, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL
, s
,
113 (bfd_vma
) 0, (const char *) NULL
, false,
114 get_elf_backend_data (abfd
)->collect
,
115 (struct bfd_link_hash_entry
**) &h
)))
117 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
118 h
->type
= STT_OBJECT
;
121 && ! _bfd_elf_link_record_dynamic_symbol (info
, h
))
125 s
= bfd_make_section (abfd
, bed
->use_rela_p
? ".rela.plt" : ".rel.plt");
127 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
128 || ! bfd_set_section_alignment (abfd
, s
, 2))
131 if (! _bfd_elf_create_got_section (abfd
, info
))
134 /* The .dynbss section is a place to put symbols which are defined
135 by dynamic objects, are referenced by regular objects, and are
136 not functions. We must allocate space for them in the process
137 image and use a R_*_COPY reloc to tell the dynamic linker to
138 initialize them at run time. The linker script puts the .dynbss
139 section into the .bss section of the final image. */
140 s
= bfd_make_section (abfd
, ".dynbss");
142 || ! bfd_set_section_flags (abfd
, s
, SEC_ALLOC
))
145 /* The .rel[a].bss section holds copy relocs. This section is not
146 normally needed. We need to create it here, though, so that the
147 linker will map it to an output section. We can't just create it
148 only if we need it, because we will not know whether we need it
149 until we have seen all the input files, and the first time the
150 main linker code calls BFD after examining all the input files
151 (size_dynamic_sections) the input sections have already been
152 mapped to the output sections. If the section turns out not to
153 be needed, we can discard it later. We will never need this
154 section when generating a shared object, since they do not use
158 s
= bfd_make_section (abfd
, bed
->use_rela_p
? ".rela.bss" : ".rel.bss");
160 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
161 || ! bfd_set_section_alignment (abfd
, s
, 2))
169 /* Record a new dynamic symbol. We record the dynamic symbols as we
170 read the input files, since we need to have a list of all of them
171 before we can determine the final sizes of the output sections.
172 Note that we may actually call this function even though we are not
173 going to output any dynamic symbols; in some cases we know that a
174 symbol should be in the dynamic symbol table, but only if there is
178 _bfd_elf_link_record_dynamic_symbol (info
, h
)
179 struct bfd_link_info
*info
;
180 struct elf_link_hash_entry
*h
;
182 if (h
->dynindx
== -1)
184 struct bfd_strtab_hash
*dynstr
;
186 h
->dynindx
= elf_hash_table (info
)->dynsymcount
;
187 ++elf_hash_table (info
)->dynsymcount
;
189 dynstr
= elf_hash_table (info
)->dynstr
;
192 /* Create a strtab to hold the dynamic symbol names. */
193 elf_hash_table (info
)->dynstr
= dynstr
= _bfd_elf_stringtab_init ();
198 h
->dynstr_index
= ((unsigned long)
199 _bfd_stringtab_add (dynstr
, h
->root
.root
.string
,
201 if (h
->dynstr_index
== (unsigned long) -1)
208 /* Create a special linker section, or return a pointer to a linker section already created */
210 elf_linker_section_t
*
211 _bfd_elf_create_linker_section (abfd
, info
, which
, defaults
)
213 struct bfd_link_info
*info
;
214 enum elf_linker_section_enum which
;
215 elf_linker_section_t
*defaults
;
217 bfd
*dynobj
= elf_hash_table (info
)->dynobj
;
218 elf_linker_section_t
*lsect
;
220 /* Record the first bfd section that needs the special section */
222 dynobj
= elf_hash_table (info
)->dynobj
= abfd
;
224 /* If this is the first time, create the section */
225 lsect
= elf_linker_section (dynobj
, which
);
229 static elf_linker_section_t zero_section
;
231 lsect
= (elf_linker_section_t
*)
232 bfd_alloc (dynobj
, sizeof (elf_linker_section_t
));
235 elf_linker_section (dynobj
, which
) = lsect
;
236 lsect
->which
= which
;
237 lsect
->hole_written_p
= false;
239 /* See if the sections already exist */
240 lsect
->section
= s
= bfd_get_section_by_name (dynobj
, lsect
->name
);
243 lsect
->section
= s
= bfd_make_section (dynobj
, lsect
->name
);
246 return (elf_linker_section_t
*)0;
248 bfd_set_section_flags (dynobj
, s
, defaults
->flags
);
249 bfd_set_section_alignment (dynobj
, s
, lsect
->alignment
);
251 else if (bfd_get_section_alignment (dynobj
, s
) < lsect
->alignment
)
252 bfd_set_section_alignment (dynobj
, s
, lsect
->alignment
);
254 s
->_raw_size
= align_power (s
->_raw_size
, lsect
->alignment
);
256 /* Is there a hole we have to provide? If so check whether the segment is
258 if (lsect
->hole_size
)
260 lsect
->hole_offset
= s
->_raw_size
;
261 s
->_raw_size
+= lsect
->hole_size
;
262 if (lsect
->hole_offset
> lsect
->max_hole_offset
)
264 (*_bfd_error_handler
) ("%s: Section %s is already to large to put hole of %ld bytes in",
265 bfd_get_filename (abfd
),
267 (long)lsect
->hole_size
);
269 bfd_set_error (bfd_error_bad_value
);
270 return (elf_linker_section_t
*)0;
275 fprintf (stderr
, "Creating section %s, current size = %ld\n",
276 lsect
->name
, (long)s
->_raw_size
);
281 struct elf_link_hash_entry
*h
= NULL
;
283 fprintf (stderr
, "Adding %s to section %s\n",
287 if (!(_bfd_generic_link_add_one_symbol (info
,
293 ? s
->_raw_size
- lsect
->hole_size
+ lsect
->sym_offset
294 : lsect
->sym_offset
),
297 get_elf_backend_data (abfd
)->collect
,
298 (struct bfd_link_hash_entry
**) &h
)))
299 return (elf_linker_section_t
*)0;
301 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_DYNAMIC
;
302 h
->type
= STT_OBJECT
;
306 && ! _bfd_elf_link_record_dynamic_symbol (info
, h
))
307 return (elf_linker_section_t
*)0;
311 /* Find the related sections if they have been created */
312 if (lsect
->bss_name
&& !lsect
->bss_section
)
313 lsect
->bss_section
= bfd_get_section_by_name (dynobj
, lsect
->bss_name
);
315 if (lsect
->rel_name
&& !lsect
->rel_section
)
316 lsect
->rel_section
= bfd_get_section_by_name (dynobj
, lsect
->rel_name
);
322 /* Find a linker generated pointer with a given addend and type. */
324 elf_linker_section_pointers_t
*
325 _bfd_elf_find_pointer_linker_section (linker_pointers
, addend
, which
)
326 elf_linker_section_pointers_t
*linker_pointers
;
327 bfd_signed_vma addend
;
328 elf_linker_section_enum_t which
;
330 for ( ; linker_pointers
!= NULL
; linker_pointers
= linker_pointers
->next
)
332 if (which
== linker_pointers
->which
&& addend
== linker_pointers
->addend
)
333 return linker_pointers
;
336 return (elf_linker_section_pointers_t
*)0;
340 /* Make the .rela section corresponding to the generated linker section. */
343 _bfd_elf_make_linker_section_rela (dynobj
, lsect
, alignment
)
345 elf_linker_section_t
*lsect
;
348 if (lsect
->rel_section
)
351 lsect
->rel_section
= bfd_get_section_by_name (dynobj
, lsect
->rel_name
);
352 if (lsect
->rel_section
== NULL
)
354 lsect
->rel_section
= bfd_make_section (dynobj
, lsect
->rel_name
);
355 if (lsect
->rel_section
== NULL
356 || ! bfd_set_section_flags (dynobj
,
363 || ! bfd_set_section_alignment (dynobj
, lsect
->rel_section
, alignment
))