1 /* ELF STT_GNU_IFUNC support.
2 Copyright (C) 2009-2016 Free Software Foundation, Inc.
3
4 This file is part of BFD, the Binary File Descriptor library.
5
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 3 of the License, or
9 (at your option) any later version.
10
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.
15
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., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
20
21 #include "sysdep.h"
22 #include "bfd.h"
23 #include "bfdlink.h"
24 #include "libbfd.h"
25 #define ARCH_SIZE 0
26 #include "elf-bfd.h"
27 #include "safe-ctype.h"
28 #include "libiberty.h"
29 #include "objalloc.h"
30
31 /* Create sections needed by STT_GNU_IFUNC symbol. */
32
33 bfd_boolean
_bfd_elf_create_ifunc_sections(bfd * abfd,struct bfd_link_info * info)34 _bfd_elf_create_ifunc_sections (bfd *abfd, struct bfd_link_info *info)
35 {
36 flagword flags, pltflags;
37 asection *s;
38 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
39 struct elf_link_hash_table *htab = elf_hash_table (info);
40
41 if (htab->irelifunc != NULL || htab->iplt != NULL)
42 return TRUE;
43
44 flags = bed->dynamic_sec_flags;
45 pltflags = flags;
46 if (bed->plt_not_loaded)
47 /* We do not clear SEC_ALLOC here because we still want the OS to
48 allocate space for the section; it's just that there's nothing
49 to read in from the object file. */
50 pltflags &= ~ (SEC_CODE | SEC_LOAD | SEC_HAS_CONTENTS);
51 else
52 pltflags |= SEC_ALLOC | SEC_CODE | SEC_LOAD;
53 if (bed->plt_readonly)
54 pltflags |= SEC_READONLY;
55
56 if (bfd_link_pic (info))
57 {
58 /* We need to create .rel[a].ifunc for PIC objects. */
59 const char *rel_sec = (bed->rela_plts_and_copies_p
60 ? ".rela.ifunc" : ".rel.ifunc");
61
62 s = bfd_make_section_with_flags (abfd, rel_sec,
63 flags | SEC_READONLY);
64 if (s == NULL
65 || ! bfd_set_section_alignment (abfd, s,
66 bed->s->log_file_align))
67 return FALSE;
68 htab->irelifunc = s;
69 }
70 else
71 {
72 /* We need to create .iplt, .rel[a].iplt, .igot and .igot.plt
73 for static executables. */
74 s = bfd_make_section_with_flags (abfd, ".iplt", pltflags);
75 if (s == NULL
76 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
77 return FALSE;
78 htab->iplt = s;
79
80 s = bfd_make_section_with_flags (abfd,
81 (bed->rela_plts_and_copies_p
82 ? ".rela.iplt" : ".rel.iplt"),
83 flags | SEC_READONLY);
84 if (s == NULL
85 || ! bfd_set_section_alignment (abfd, s,
86 bed->s->log_file_align))
87 return FALSE;
88 htab->irelplt = s;
89
90 /* We don't need the .igot section if we have the .igot.plt
91 section. */
92 if (bed->want_got_plt)
93 s = bfd_make_section_with_flags (abfd, ".igot.plt", flags);
94 else
95 s = bfd_make_section_with_flags (abfd, ".igot", flags);
96 if (s == NULL
97 || !bfd_set_section_alignment (abfd, s,
98 bed->s->log_file_align))
99 return FALSE;
100 htab->igotplt = s;
101 }
102
103 return TRUE;
104 }
105
106 /* Allocate space in .plt, .got and associated reloc sections for
107 dynamic relocs against a STT_GNU_IFUNC symbol definition. */
108
109 bfd_boolean
_bfd_elf_allocate_ifunc_dyn_relocs(struct bfd_link_info * info,struct elf_link_hash_entry * h,struct elf_dyn_relocs ** head,bfd_boolean * readonly_dynrelocs_against_ifunc_p,unsigned int plt_entry_size,unsigned int plt_header_size,unsigned int got_entry_size,bfd_boolean avoid_plt)110 _bfd_elf_allocate_ifunc_dyn_relocs (struct bfd_link_info *info,
111 struct elf_link_hash_entry *h,
112 struct elf_dyn_relocs **head,
113 bfd_boolean *readonly_dynrelocs_against_ifunc_p,
114 unsigned int plt_entry_size,
115 unsigned int plt_header_size,
116 unsigned int got_entry_size,
117 bfd_boolean avoid_plt)
118 {
119 asection *plt, *gotplt, *relplt;
120 struct elf_dyn_relocs *p;
121 unsigned int sizeof_reloc;
122 const struct elf_backend_data *bed;
123 struct elf_link_hash_table *htab;
124 bfd_boolean readonly_dynrelocs_against_ifunc;
125 /* If AVOID_PLT is TRUE, don't use PLT if possible. */
126 bfd_boolean use_plt = !avoid_plt || h->plt.refcount > 0;
127 bfd_boolean need_dynreloc = !use_plt || bfd_link_pic (info);
128
129 /* When a PIC object references a STT_GNU_IFUNC symbol defined
130 in executable or it isn't referenced via PLT, the address of
131 the resolved function may be used. But in non-PIC executable,
132 the address of its .plt slot may be used. Pointer equality may
133 not work correctly. PIE or non-PLT reference should be used if
134 pointer equality is required here. */
135 if (!need_dynreloc
136 && (h->dynindx != -1
137 || info->export_dynamic)
138 && h->pointer_equality_needed)
139 {
140 info->callbacks->einfo
141 (_("%F%P: dynamic STT_GNU_IFUNC symbol `%s' with pointer "
142 "equality in `%B' can not be used when making an "
143 "executable; recompile with -fPIE and relink with -pie\n"),
144 h->root.root.string,
145 h->root.u.def.section->owner);
146 bfd_set_error (bfd_error_bad_value);
147 return FALSE;
148 }
149
150 htab = elf_hash_table (info);
151
152 /* When the symbol is marked with regular reference, if PLT isn't used
153 or we are building a PIC object, we must keep dynamic relocation
154 if there is non-GOT reference and use PLT if there is PC-relative
155 reference. */
156 if (need_dynreloc && h->ref_regular)
157 {
158 bfd_boolean keep = FALSE;
159 for (p = *head; p != NULL; p = p->next)
160 if (p->count)
161 {
162 h->non_got_ref = 1;
163 /* Need dynamic relocations for non-GOT reference. */
164 keep = TRUE;
165 if (p->pc_count)
166 {
167 /* Must use PLT for PC-relative reference. */
168 use_plt = TRUE;
169 need_dynreloc = bfd_link_pic (info);
170 break;
171 }
172 }
173 if (keep)
174 goto keep;
175 }
176
177 /* Support garbage collection against STT_GNU_IFUNC symbols. */
178 if (h->plt.refcount <= 0 && h->got.refcount <= 0)
179 {
180 h->got = htab->init_got_offset;
181 h->plt = htab->init_plt_offset;
182 *head = NULL;
183 return TRUE;
184 }
185
186 /* Return and discard space for dynamic relocations against it if
187 it is never referenced. */
188 if (!h->ref_regular)
189 {
190 if (h->plt.refcount > 0
191 || h->got.refcount > 0)
192 abort ();
193 h->got = htab->init_got_offset;
194 h->plt = htab->init_plt_offset;
195 *head = NULL;
196 return TRUE;
197 }
198
199 keep:
200 bed = get_elf_backend_data (info->output_bfd);
201 if (bed->rela_plts_and_copies_p)
202 sizeof_reloc = bed->s->sizeof_rela;
203 else
204 sizeof_reloc = bed->s->sizeof_rel;
205
206 /* When building a static executable, use .iplt, .igot.plt and
207 .rel[a].iplt sections for STT_GNU_IFUNC symbols. */
208 if (htab->splt != NULL)
209 {
210 plt = htab->splt;
211 gotplt = htab->sgotplt;
212 relplt = htab->srelplt;
213
214 /* If this is the first .plt entry and PLT is used, make room for
215 the special first entry. */
216 if (plt->size == 0 && use_plt)
217 plt->size += plt_header_size;
218 }
219 else
220 {
221 plt = htab->iplt;
222 gotplt = htab->igotplt;
223 relplt = htab->irelplt;
224 }
225
226 if (use_plt)
227 {
228 /* Don't update value of STT_GNU_IFUNC symbol to PLT. We need
229 the original value for R_*_IRELATIVE. */
230 h->plt.offset = plt->size;
231
232 /* Make room for this entry in the .plt/.iplt section. */
233 plt->size += plt_entry_size;
234
235 /* We also need to make an entry in the .got.plt/.got.iplt section,
236 which will be placed in the .got section by the linker script. */
237 gotplt->size += got_entry_size;
238 }
239
240 /* We also need to make an entry in the .rel[a].plt/.rel[a].iplt
241 section for GOTPLT relocation if PLT is used. */
242 if (use_plt)
243 {
244 relplt->size += sizeof_reloc;
245 relplt->reloc_count++;
246 }
247
248 /* We need dynamic relocation for STT_GNU_IFUNC symbol only when
249 there is a non-GOT reference in a PIC object or PLT isn't used. */
250 if (!need_dynreloc || !h->non_got_ref)
251 *head = NULL;
252
253 readonly_dynrelocs_against_ifunc = FALSE;
254
255 /* Finally, allocate space. */
256 p = *head;
257 if (p != NULL)
258 {
259 bfd_size_type count = 0;
260 do
261 {
262 if (!readonly_dynrelocs_against_ifunc)
263 {
264 asection *s = p->sec->output_section;
265 if (s != NULL && (s->flags & SEC_READONLY) != 0)
266 readonly_dynrelocs_against_ifunc = TRUE;
267 }
268 count += p->count;
269 p = p->next;
270 }
271 while (p != NULL);
272
273 /* Dynamic relocations are stored in
274 1. .rel[a].ifunc section in PIC object.
275 2. .rel[a].got section in dynamic executable.
276 3. .rel[a].iplt section in static executable. */
277 if (bfd_link_pic (info))
278 htab->irelifunc->size += count * sizeof_reloc;
279 else if (htab->splt != NULL)
280 htab->srelgot->size += count * sizeof_reloc;
281 else
282 {
283 relplt->size += count * sizeof_reloc;
284 relplt->reloc_count += count;
285 }
286 }
287
288 if (readonly_dynrelocs_against_ifunc_p)
289 *readonly_dynrelocs_against_ifunc_p = readonly_dynrelocs_against_ifunc;
290
291 /* For STT_GNU_IFUNC symbol, .got.plt has the real function address
292 and .got has the PLT entry adddress. We will load the GOT entry
293 with the PLT entry in finish_dynamic_symbol if it is used. For
294 branch, it uses .got.plt. For symbol value, if PLT is used,
295 1. Use .got.plt in a PIC object if it is forced local or not
296 dynamic.
297 2. Use .got.plt in a non-PIC object if pointer equality isn't
298 needed.
299 3. Use .got.plt in PIE.
300 4. Use .got.plt if .got isn't used.
301 5. Otherwise use .got so that it can be shared among different
302 objects at run-time.
303 If PLT isn't used, always use .got for symbol value.
304 We only need to relocate .got entry in PIC object or in dynamic
305 executable without PLT. */
306 if (use_plt
307 && (h->got.refcount <= 0
308 || (bfd_link_pic (info)
309 && (h->dynindx == -1
310 || h->forced_local))
311 || (!bfd_link_pic (info)
312 && !h->pointer_equality_needed)
313 || bfd_link_pie (info)
314 || htab->sgot == NULL))
315 {
316 /* Use .got.plt. */
317 h->got.offset = (bfd_vma) -1;
318 }
319 else
320 {
321 if (!use_plt)
322 {
323 /* PLT isn't used. */
324 h->plt.offset = (bfd_vma) -1;
325 }
326 if (h->got.refcount <= 0)
327 {
328 /* GOT isn't need when there are only relocations for static
329 pointers. */
330 h->got.offset = (bfd_vma) -1;
331 }
332 else
333 {
334 h->got.offset = htab->sgot->size;
335 htab->sgot->size += got_entry_size;
336 /* Need to relocate the GOT entry in a PIC object or PLT isn't
337 used. Otherwise, the GOT entry will be filled with the PLT
338 entry and dynamic GOT relocation isn't needed. */
339 if (need_dynreloc)
340 {
341 /* For non-static executable, dynamic GOT relocation is in
342 .rel[a].got section, but for static executable, it is
343 in .rel[a].iplt section. */
344 if (htab->splt != NULL)
345 htab->srelgot->size += sizeof_reloc;
346 else
347 {
348 relplt->size += sizeof_reloc;
349 relplt->reloc_count++;
350 }
351 }
352 }
353 }
354
355 return TRUE;
356 }
357
358 /* Similar to _bfd_elf_get_synthetic_symtab, optimized for unsorted PLT
359 entries. PLT is the PLT section. PLT_SYM_VAL is a function pointer
360 which returns an array of PLT entry symbol values. */
361
362 long
_bfd_elf_ifunc_get_synthetic_symtab(bfd * abfd,long symcount ATTRIBUTE_UNUSED,asymbol ** syms ATTRIBUTE_UNUSED,long dynsymcount,asymbol ** dynsyms,asymbol ** ret,asection * plt,bfd_vma * (* get_plt_sym_val)(bfd *,asymbol **,asection *,asection *))363 _bfd_elf_ifunc_get_synthetic_symtab
364 (bfd *abfd, long symcount ATTRIBUTE_UNUSED,
365 asymbol **syms ATTRIBUTE_UNUSED, long dynsymcount, asymbol **dynsyms,
366 asymbol **ret, asection *plt,
367 bfd_vma *(*get_plt_sym_val) (bfd *, asymbol **, asection *, asection *))
368 {
369 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
370 asection *relplt;
371 asymbol *s;
372 const char *relplt_name;
373 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
374 arelent *p;
375 long count, i, n;
376 size_t size;
377 Elf_Internal_Shdr *hdr;
378 char *names;
379 bfd_vma *plt_sym_val;
380
381 *ret = NULL;
382
383 if (plt == NULL)
384 return 0;
385
386 if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
387 return 0;
388
389 if (dynsymcount <= 0)
390 return 0;
391
392 relplt_name = bed->relplt_name;
393 if (relplt_name == NULL)
394 relplt_name = bed->rela_plts_and_copies_p ? ".rela.plt" : ".rel.plt";
395 relplt = bfd_get_section_by_name (abfd, relplt_name);
396 if (relplt == NULL)
397 return 0;
398
399 hdr = &elf_section_data (relplt)->this_hdr;
400 if (hdr->sh_link != elf_dynsymtab (abfd)
401 || (hdr->sh_type != SHT_REL && hdr->sh_type != SHT_RELA))
402 return 0;
403
404 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
405 if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
406 return -1;
407
408 count = relplt->size / hdr->sh_entsize;
409 size = count * sizeof (asymbol);
410 p = relplt->relocation;
411 for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel)
412 {
413 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
414 if (p->addend != 0)
415 {
416 #ifdef BFD64
417 size += sizeof ("+0x") - 1 + 8 + 8 * (bed->s->elfclass == ELFCLASS64);
418 #else
419 size += sizeof ("+0x") - 1 + 8;
420 #endif
421 }
422 }
423
424 plt_sym_val = get_plt_sym_val (abfd, dynsyms, plt, relplt);
425 if (plt_sym_val == NULL)
426 return -1;
427
428 s = *ret = (asymbol *) bfd_malloc (size);
429 if (s == NULL)
430 {
431 free (plt_sym_val);
432 return -1;
433 }
434
435 names = (char *) (s + count);
436 p = relplt->relocation;
437 n = 0;
438 for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel)
439 {
440 size_t len;
441 bfd_vma addr;
442
443 addr = plt_sym_val[i];
444 if (addr == (bfd_vma) -1)
445 continue;
446
447 *s = **p->sym_ptr_ptr;
448 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
449 we are defining a symbol, ensure one of them is set. */
450 if ((s->flags & BSF_LOCAL) == 0)
451 s->flags |= BSF_GLOBAL;
452 s->flags |= BSF_SYNTHETIC;
453 s->section = plt;
454 s->value = addr - plt->vma;
455 s->name = names;
456 s->udata.p = NULL;
457 len = strlen ((*p->sym_ptr_ptr)->name);
458 memcpy (names, (*p->sym_ptr_ptr)->name, len);
459 names += len;
460 if (p->addend != 0)
461 {
462 char buf[30], *a;
463
464 memcpy (names, "+0x", sizeof ("+0x") - 1);
465 names += sizeof ("+0x") - 1;
466 bfd_sprintf_vma (abfd, buf, p->addend);
467 for (a = buf; *a == '0'; ++a)
468 ;
469 len = strlen (a);
470 memcpy (names, a, len);
471 names += len;
472 }
473 memcpy (names, "@plt", sizeof ("@plt"));
474 names += sizeof ("@plt");
475 ++s, ++n;
476 }
477
478 free (plt_sym_val);
479
480 return n;
481 }
482