1 /* ELF linking support for BFD.
2 Copyright 1995, 1996, 1997 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
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);
38 /* This function may be called more than once. */
39 if (bfd_get_section_by_name (abfd, ".got") != NULL)
42 switch (bed->s->arch_size)
44 case 32: ptralign = 2; break;
45 case 64: ptralign = 3; break;
49 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
50 | SEC_LINKER_CREATED);
52 s = bfd_make_section (abfd, ".got");
54 || !bfd_set_section_flags (abfd, s, flags)
55 || !bfd_set_section_alignment (abfd, s, ptralign))
58 if (bed->want_got_plt)
60 s = bfd_make_section (abfd, ".got.plt");
62 || !bfd_set_section_flags (abfd, s, flags)
63 || !bfd_set_section_alignment (abfd, s, ptralign))
67 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
68 (or .got.plt) section. We don't do this in the linker script
69 because we don't want to define the symbol if we are not creating
70 a global offset table. */
72 if (!(_bfd_generic_link_add_one_symbol
73 (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s,
74 bed->got_symbol_offset, (const char *) NULL, false,
75 bed->collect, (struct bfd_link_hash_entry **) &h)))
77 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
81 && ! _bfd_elf_link_record_dynamic_symbol (info, h))
84 elf_hash_table (info)->hgot = h;
86 /* The first bit of the global offset table is the header. */
87 s->_raw_size += bed->got_header_size + bed->got_symbol_offset;
93 /* Create dynamic sections when linking against a dynamic object. */
96 _bfd_elf_create_dynamic_sections (abfd, info)
98 struct bfd_link_info *info;
100 flagword flags, pltflags;
101 register asection *s;
102 struct elf_backend_data *bed = get_elf_backend_data (abfd);
105 switch (bed->s->arch_size)
107 case 32: ptralign = 2; break;
108 case 64: ptralign = 3; break;
112 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
113 .rel[a].bss sections. */
115 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
116 | SEC_LINKER_CREATED);
119 pltflags |= SEC_CODE;
120 if (bed->plt_not_loaded)
121 pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
122 if (bed->plt_readonly)
123 pltflags |= SEC_READONLY;
125 s = bfd_make_section (abfd, ".plt");
127 || ! bfd_set_section_flags (abfd, s, pltflags)
128 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
131 if (bed->want_plt_sym)
133 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
135 struct elf_link_hash_entry *h = NULL;
136 if (! (_bfd_generic_link_add_one_symbol
137 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
138 (bfd_vma) 0, (const char *) NULL, false,
139 get_elf_backend_data (abfd)->collect,
140 (struct bfd_link_hash_entry **) &h)))
142 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
143 h->type = STT_OBJECT;
146 && ! _bfd_elf_link_record_dynamic_symbol (info, h))
150 s = bfd_make_section (abfd, bed->use_rela_p ? ".rela.plt" : ".rel.plt");
152 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
153 || ! bfd_set_section_alignment (abfd, s, ptralign))
156 if (! _bfd_elf_create_got_section (abfd, info))
159 /* The .dynbss section is a place to put symbols which are defined
160 by dynamic objects, are referenced by regular objects, and are
161 not functions. We must allocate space for them in the process
162 image and use a R_*_COPY reloc to tell the dynamic linker to
163 initialize them at run time. The linker script puts the .dynbss
164 section into the .bss section of the final image. */
165 s = bfd_make_section (abfd, ".dynbss");
167 || ! bfd_set_section_flags (abfd, s, SEC_ALLOC))
170 /* The .rel[a].bss section holds copy relocs. This section is not
171 normally needed. We need to create it here, though, so that the
172 linker will map it to an output section. We can't just create it
173 only if we need it, because we will not know whether we need it
174 until we have seen all the input files, and the first time the
175 main linker code calls BFD after examining all the input files
176 (size_dynamic_sections) the input sections have already been
177 mapped to the output sections. If the section turns out not to
178 be needed, we can discard it later. We will never need this
179 section when generating a shared object, since they do not use
183 s = bfd_make_section (abfd, bed->use_rela_p ? ".rela.bss" : ".rel.bss");
185 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
186 || ! bfd_set_section_alignment (abfd, s, ptralign))
194 /* Record a new dynamic symbol. We record the dynamic symbols as we
195 read the input files, since we need to have a list of all of them
196 before we can determine the final sizes of the output sections.
197 Note that we may actually call this function even though we are not
198 going to output any dynamic symbols; in some cases we know that a
199 symbol should be in the dynamic symbol table, but only if there is
203 _bfd_elf_link_record_dynamic_symbol (info, h)
204 struct bfd_link_info *info;
205 struct elf_link_hash_entry *h;
207 if (h->dynindx == -1)
209 struct bfd_strtab_hash *dynstr;
215 h->dynindx = elf_hash_table (info)->dynsymcount;
216 ++elf_hash_table (info)->dynsymcount;
218 dynstr = elf_hash_table (info)->dynstr;
221 /* Create a strtab to hold the dynamic symbol names. */
222 elf_hash_table (info)->dynstr = dynstr = _bfd_elf_stringtab_init ();
227 /* We don't put any version information in the dynamic string
229 name = h->root.root.string;
230 p = strchr (name, ELF_VER_CHR);
238 alc = bfd_malloc (p - name + 1);
241 strncpy (alc, name, p - name);
242 alc[p - name] = '\0';
247 indx = _bfd_stringtab_add (dynstr, name, true, copy);
252 if (indx == (bfd_size_type) -1)
254 h->dynstr_index = indx;
260 /* Create a special linker section, or return a pointer to a linker section already created */
262 elf_linker_section_t *
263 _bfd_elf_create_linker_section (abfd, info, which, defaults)
265 struct bfd_link_info *info;
266 enum elf_linker_section_enum which;
267 elf_linker_section_t *defaults;
269 bfd *dynobj = elf_hash_table (info)->dynobj;
270 elf_linker_section_t *lsect;
272 /* Record the first bfd section that needs the special section */
274 dynobj = elf_hash_table (info)->dynobj = abfd;
276 /* If this is the first time, create the section */
277 lsect = elf_linker_section (dynobj, which);
282 lsect = (elf_linker_section_t *)
283 bfd_alloc (dynobj, sizeof (elf_linker_section_t));
286 elf_linker_section (dynobj, which) = lsect;
287 lsect->which = which;
288 lsect->hole_written_p = false;
290 /* See if the sections already exist */
291 lsect->section = s = bfd_get_section_by_name (dynobj, lsect->name);
292 if (!s || (s->flags & defaults->flags) != defaults->flags)
294 lsect->section = s = bfd_make_section_anyway (dynobj, lsect->name);
297 return (elf_linker_section_t *)0;
299 bfd_set_section_flags (dynobj, s, defaults->flags);
300 bfd_set_section_alignment (dynobj, s, lsect->alignment);
302 else if (bfd_get_section_alignment (dynobj, s) < lsect->alignment)
303 bfd_set_section_alignment (dynobj, s, lsect->alignment);
305 s->_raw_size = align_power (s->_raw_size, lsect->alignment);
307 /* Is there a hole we have to provide? If so check whether the segment is
309 if (lsect->hole_size)
311 lsect->hole_offset = s->_raw_size;
312 s->_raw_size += lsect->hole_size;
313 if (lsect->hole_offset > lsect->max_hole_offset)
315 (*_bfd_error_handler) (_("%s: Section %s is already to large to put hole of %ld bytes in"),
316 bfd_get_filename (abfd),
318 (long)lsect->hole_size);
320 bfd_set_error (bfd_error_bad_value);
321 return (elf_linker_section_t *)0;
326 fprintf (stderr, "Creating section %s, current size = %ld\n",
327 lsect->name, (long)s->_raw_size);
332 struct elf_link_hash_entry *h = NULL;
334 fprintf (stderr, "Adding %s to section %s\n",
338 h = (struct elf_link_hash_entry *)
339 bfd_link_hash_lookup (info->hash, lsect->sym_name, false, false, false);
341 if ((h == NULL || h->root.type == bfd_link_hash_undefined)
342 && !(_bfd_generic_link_add_one_symbol (info,
348 ? s->_raw_size - lsect->hole_size + lsect->sym_offset
349 : lsect->sym_offset),
352 get_elf_backend_data (abfd)->collect,
353 (struct bfd_link_hash_entry **) &h)))
354 return (elf_linker_section_t *)0;
356 if ((defaults->which != LINKER_SECTION_SDATA)
357 && (defaults->which != LINKER_SECTION_SDATA2))
358 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_DYNAMIC;
360 h->type = STT_OBJECT;
364 && ! _bfd_elf_link_record_dynamic_symbol (info, h))
365 return (elf_linker_section_t *)0;
370 /* This does not make sense. The sections which may exist in the
371 object file have nothing to do with the sections we want to
374 /* Find the related sections if they have been created */
375 if (lsect->bss_name && !lsect->bss_section)
376 lsect->bss_section = bfd_get_section_by_name (dynobj, lsect->bss_name);
378 if (lsect->rel_name && !lsect->rel_section)
379 lsect->rel_section = bfd_get_section_by_name (dynobj, lsect->rel_name);
386 /* Find a linker generated pointer with a given addend and type. */
388 elf_linker_section_pointers_t *
389 _bfd_elf_find_pointer_linker_section (linker_pointers, addend, which)
390 elf_linker_section_pointers_t *linker_pointers;
391 bfd_signed_vma addend;
392 elf_linker_section_enum_t which;
394 for ( ; linker_pointers != NULL; linker_pointers = linker_pointers->next)
396 if (which == linker_pointers->which && addend == linker_pointers->addend)
397 return linker_pointers;
400 return (elf_linker_section_pointers_t *)0;
404 /* Make the .rela section corresponding to the generated linker section. */
407 _bfd_elf_make_linker_section_rela (dynobj, lsect, alignment)
409 elf_linker_section_t *lsect;
412 if (lsect->rel_section)
415 lsect->rel_section = bfd_get_section_by_name (dynobj, lsect->rel_name);
416 if (lsect->rel_section == NULL)
418 lsect->rel_section = bfd_make_section (dynobj, lsect->rel_name);
419 if (lsect->rel_section == NULL
420 || ! bfd_set_section_flags (dynobj,
428 || ! bfd_set_section_alignment (dynobj, lsect->rel_section, alignment))