1 /* ELF STT_GNU_IFUNC support. 2 Copyright (C) 2009-2020 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 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 (s, bed->s->log_file_align)) 66 return FALSE; 67 htab->irelifunc = s; 68 } 69 else 70 { 71 /* We need to create .iplt, .rel[a].iplt, .igot and .igot.plt 72 for static executables. */ 73 s = bfd_make_section_with_flags (abfd, ".iplt", pltflags); 74 if (s == NULL 75 || !bfd_set_section_alignment (s, bed->plt_alignment)) 76 return FALSE; 77 htab->iplt = s; 78 79 s = bfd_make_section_with_flags (abfd, 80 (bed->rela_plts_and_copies_p 81 ? ".rela.iplt" : ".rel.iplt"), 82 flags | SEC_READONLY); 83 if (s == NULL 84 || !bfd_set_section_alignment (s, bed->s->log_file_align)) 85 return FALSE; 86 htab->irelplt = s; 87 88 /* We don't need the .igot section if we have the .igot.plt 89 section. */ 90 if (bed->want_got_plt) 91 s = bfd_make_section_with_flags (abfd, ".igot.plt", flags); 92 else 93 s = bfd_make_section_with_flags (abfd, ".igot", flags); 94 if (s == NULL 95 || !bfd_set_section_alignment (s, bed->s->log_file_align)) 96 return FALSE; 97 htab->igotplt = s; 98 } 99 100 return TRUE; 101 } 102 103 /* Allocate space in .plt, .got and associated reloc sections for 104 dynamic relocs against a STT_GNU_IFUNC symbol definition. */ 105 106 bfd_boolean 107 _bfd_elf_allocate_ifunc_dyn_relocs (struct bfd_link_info *info, 108 struct elf_link_hash_entry *h, 109 struct elf_dyn_relocs **head, 110 unsigned int plt_entry_size, 111 unsigned int plt_header_size, 112 unsigned int got_entry_size, 113 bfd_boolean avoid_plt) 114 { 115 asection *plt, *gotplt, *relplt; 116 struct elf_dyn_relocs *p; 117 unsigned int sizeof_reloc; 118 const struct elf_backend_data *bed; 119 struct elf_link_hash_table *htab; 120 /* If AVOID_PLT is TRUE, don't use PLT if possible. */ 121 bfd_boolean use_plt = !avoid_plt || h->plt.refcount > 0; 122 bfd_boolean need_dynreloc = !use_plt || bfd_link_pic (info); 123 124 /* When a PIC object references a STT_GNU_IFUNC symbol defined 125 in executable or it isn't referenced via PLT, the address of 126 the resolved function may be used. But in non-PIC executable, 127 the address of its .plt slot may be used. Pointer equality may 128 not work correctly. PIE or non-PLT reference should be used if 129 pointer equality is required here. 130 131 If STT_GNU_IFUNC symbol is defined in position-dependent executable, 132 backend should change it to the normal function and set its address 133 to its PLT entry which should be resolved by R_*_IRELATIVE at 134 run-time. All external references should be resolved to its PLT in 135 executable. */ 136 if (!need_dynreloc 137 && !(bfd_link_pde (info) && h->def_regular) 138 && (h->dynindx != -1 139 || info->export_dynamic) 140 && h->pointer_equality_needed) 141 { 142 info->callbacks->einfo 143 /* xgettext:c-format */ 144 (_("%F%P: dynamic STT_GNU_IFUNC symbol `%s' with pointer " 145 "equality in `%pB' can not be used when making an " 146 "executable; recompile with -fPIE and relink with -pie\n"), 147 h->root.root.string, 148 h->root.u.def.section->owner); 149 bfd_set_error (bfd_error_bad_value); 150 return FALSE; 151 } 152 153 htab = elf_hash_table (info); 154 155 /* When the symbol is marked with regular reference, if PLT isn't used 156 or we are building a PIC object, we must keep dynamic relocation 157 if there is non-GOT reference and use PLT if there is PC-relative 158 reference. */ 159 if (need_dynreloc && h->ref_regular) 160 { 161 bfd_boolean keep = FALSE; 162 for (p = *head; p != NULL; p = p->next) 163 if (p->count) 164 { 165 h->non_got_ref = 1; 166 /* Need dynamic relocations for non-GOT reference. */ 167 keep = TRUE; 168 if (p->pc_count) 169 { 170 /* Must use PLT for PC-relative reference. */ 171 use_plt = TRUE; 172 need_dynreloc = bfd_link_pic (info); 173 break; 174 } 175 } 176 if (keep) 177 goto keep; 178 } 179 180 /* Support garbage collection against STT_GNU_IFUNC symbols. */ 181 if (h->plt.refcount <= 0 && h->got.refcount <= 0) 182 { 183 h->got = htab->init_got_offset; 184 h->plt = htab->init_plt_offset; 185 *head = NULL; 186 return TRUE; 187 } 188 189 /* Return and discard space for dynamic relocations against it if 190 it is never referenced. */ 191 if (!h->ref_regular) 192 { 193 if (h->plt.refcount > 0 194 || h->got.refcount > 0) 195 abort (); 196 h->got = htab->init_got_offset; 197 h->plt = htab->init_plt_offset; 198 *head = NULL; 199 return TRUE; 200 } 201 202 keep: 203 bed = get_elf_backend_data (info->output_bfd); 204 if (bed->rela_plts_and_copies_p) 205 sizeof_reloc = bed->s->sizeof_rela; 206 else 207 sizeof_reloc = bed->s->sizeof_rel; 208 209 /* When building a static executable, use .iplt, .igot.plt and 210 .rel[a].iplt sections for STT_GNU_IFUNC symbols. */ 211 if (htab->splt != NULL) 212 { 213 plt = htab->splt; 214 gotplt = htab->sgotplt; 215 relplt = htab->srelplt; 216 217 /* If this is the first .plt entry and PLT is used, make room for 218 the special first entry. */ 219 if (plt->size == 0 && use_plt) 220 plt->size += plt_header_size; 221 } 222 else 223 { 224 plt = htab->iplt; 225 gotplt = htab->igotplt; 226 relplt = htab->irelplt; 227 } 228 229 if (use_plt) 230 { 231 /* Don't update value of STT_GNU_IFUNC symbol to PLT. We need 232 the original value for R_*_IRELATIVE. */ 233 h->plt.offset = plt->size; 234 235 /* Make room for this entry in the .plt/.iplt section. */ 236 plt->size += plt_entry_size; 237 238 /* We also need to make an entry in the .got.plt/.got.iplt section, 239 which will be placed in the .got section by the linker script. */ 240 gotplt->size += got_entry_size; 241 } 242 243 /* We also need to make an entry in the .rel[a].plt/.rel[a].iplt 244 section for GOTPLT relocation if PLT is used. */ 245 if (use_plt) 246 { 247 relplt->size += sizeof_reloc; 248 relplt->reloc_count++; 249 } 250 251 /* We need dynamic relocation for STT_GNU_IFUNC symbol only when 252 there is a non-GOT reference in a PIC object or PLT isn't used. */ 253 if (!need_dynreloc || !h->non_got_ref) 254 *head = NULL; 255 256 /* Finally, allocate space. */ 257 p = *head; 258 if (p != NULL) 259 { 260 bfd_size_type count = 0; 261 do 262 { 263 count += p->count; 264 p = p->next; 265 } 266 while (p != NULL); 267 268 htab->ifunc_resolvers = count != 0; 269 270 /* Dynamic relocations are stored in 271 1. .rel[a].ifunc section in PIC object. 272 2. .rel[a].got section in dynamic executable. 273 3. .rel[a].iplt section in static executable. */ 274 if (bfd_link_pic (info)) 275 htab->irelifunc->size += count * sizeof_reloc; 276 else if (htab->splt != NULL) 277 htab->srelgot->size += count * sizeof_reloc; 278 else 279 { 280 relplt->size += count * sizeof_reloc; 281 relplt->reloc_count += count; 282 } 283 } 284 285 /* For STT_GNU_IFUNC symbol, .got.plt has the real function address 286 and .got has the PLT entry adddress. We will load the GOT entry 287 with the PLT entry in finish_dynamic_symbol if it is used. For 288 branch, it uses .got.plt. For symbol value, if PLT is used, 289 1. Use .got.plt in a PIC object if it is forced local or not 290 dynamic. 291 2. Use .got.plt in a non-PIC object if pointer equality isn't 292 needed. 293 3. Use .got.plt in PIE. 294 4. Use .got.plt if .got isn't used. 295 5. Otherwise use .got so that it can be shared among different 296 objects at run-time. 297 If PLT isn't used, always use .got for symbol value. 298 We only need to relocate .got entry in PIC object or in dynamic 299 executable without PLT. */ 300 if (use_plt 301 && (h->got.refcount <= 0 302 || (bfd_link_pic (info) 303 && (h->dynindx == -1 304 || h->forced_local)) 305 || (!bfd_link_pic (info) 306 && !h->pointer_equality_needed) 307 || bfd_link_pie (info) 308 || htab->sgot == NULL)) 309 { 310 /* Use .got.plt. */ 311 h->got.offset = (bfd_vma) -1; 312 } 313 else 314 { 315 if (!use_plt) 316 { 317 /* PLT isn't used. */ 318 h->plt.offset = (bfd_vma) -1; 319 } 320 if (h->got.refcount <= 0) 321 { 322 /* GOT isn't need when there are only relocations for static 323 pointers. */ 324 h->got.offset = (bfd_vma) -1; 325 } 326 else 327 { 328 h->got.offset = htab->sgot->size; 329 htab->sgot->size += got_entry_size; 330 /* Need to relocate the GOT entry in a PIC object or PLT isn't 331 used. Otherwise, the GOT entry will be filled with the PLT 332 entry and dynamic GOT relocation isn't needed. */ 333 if (need_dynreloc) 334 { 335 /* For non-static executable, dynamic GOT relocation is in 336 .rel[a].got section, but for static executable, it is 337 in .rel[a].iplt section. */ 338 if (htab->splt != NULL) 339 htab->srelgot->size += sizeof_reloc; 340 else 341 { 342 relplt->size += sizeof_reloc; 343 relplt->reloc_count++; 344 } 345 } 346 } 347 } 348 349 return TRUE; 350 } 351