1 /* Inline functions for dynamic linking. 2 Copyright (C) 1995-2021 Free Software Foundation, Inc. 3 This file is part of the GNU C Library. 4 5 The GNU C Library is free software; you can redistribute it and/or 6 modify it under the terms of the GNU Lesser General Public 7 License as published by the Free Software Foundation; either 8 version 2.1 of the License, or (at your option) any later version. 9 10 The GNU C Library is distributed in the hope that it will be useful, 11 but WITHOUT ANY WARRANTY; without even the implied warranty of 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 Lesser General Public License for more details. 14 15 You should have received a copy of the GNU Lesser General Public 16 License along with the GNU C Library; if not, see 17 <https://www.gnu.org/licenses/>. */ 18 19 #include <dl-machine.h> 20 #include <elf.h> 21 22 #ifdef RESOLVE_MAP 23 /* We pass reloc_addr as a pointer to void, as opposed to a pointer to 24 ElfW(Addr), because not all architectures can assume that the 25 relocated address is properly aligned, whereas the compiler is 26 entitled to assume that a pointer to a type is properly aligned for 27 the type. Even if we cast the pointer back to some other type with 28 less strict alignment requirements, the compiler might still 29 remember that the pointer was originally more aligned, thereby 30 optimizing away alignment tests or using word instructions for 31 copying memory, breaking the very code written to handle the 32 unaligned cases. */ 33 # if ! ELF_MACHINE_NO_REL 34 static inline void __attribute__((always_inline)) 35 elf_machine_rel (struct link_map *map, struct r_scope_elem *scope[], 36 const ElfW(Rel) *reloc, const ElfW(Sym) *sym, 37 const struct r_found_version *version, 38 void *const reloc_addr, int skip_ifunc); 39 static inline void __attribute__((always_inline)) 40 elf_machine_rel_relative (ElfW(Addr) l_addr, const ElfW(Rel) *reloc, 41 void *const reloc_addr); 42 # endif 43 # if ! ELF_MACHINE_NO_RELA 44 static inline void __attribute__((always_inline)) 45 elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[], 46 const ElfW(Rela) *reloc, const ElfW(Sym) *sym, 47 const struct r_found_version *version, void *const reloc_addr, 48 int skip_ifunc); 49 static inline void __attribute__((always_inline)) 50 elf_machine_rela_relative (ElfW(Addr) l_addr, const ElfW(Rela) *reloc, 51 void *const reloc_addr); 52 # endif 53 # if ELF_MACHINE_NO_RELA || defined ELF_MACHINE_PLT_REL 54 static inline void __attribute__((always_inline)) 55 elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[], 56 ElfW(Addr) l_addr, const ElfW(Rel) *reloc, 57 int skip_ifunc); 58 # else 59 static inline void __attribute__((always_inline)) 60 elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[], 61 ElfW(Addr) l_addr, const ElfW(Rela) *reloc, 62 int skip_ifunc); 63 # endif 64 #endif 65 66 #ifdef RESOLVE_MAP 67 68 /* Get the definitions of `elf_dynamic_do_rel' and `elf_dynamic_do_rela'. 69 These functions are almost identical, so we use cpp magic to avoid 70 duplicating their code. It cannot be done in a more general function 71 because we must be able to completely inline. */ 72 73 /* On some machines, notably SPARC, DT_REL* includes DT_JMPREL in its 74 range. Note that according to the ELF spec, this is completely legal! 75 76 We are guarenteed that we have one of three situations. Either DT_JMPREL 77 comes immediately after DT_REL*, or there is overlap and DT_JMPREL 78 consumes precisely the very end of the DT_REL*, or DT_JMPREL and DT_REL* 79 are completely separate and there is a gap between them. */ 80 81 # define _ELF_DYNAMIC_DO_RELOC(RELOC, reloc, map, scope, do_lazy, skip_ifunc, test_rel) \ 82 do { \ 83 struct { ElfW(Addr) start, size; \ 84 __typeof (((ElfW(Dyn) *) 0)->d_un.d_val) nrelative; int lazy; } \ 85 ranges[2] = { { 0, 0, 0, 0 }, { 0, 0, 0, 0 } }; \ 86 \ 87 if ((map)->l_info[DT_##RELOC]) \ 88 { \ 89 ranges[0].start = D_PTR ((map), l_info[DT_##RELOC]); \ 90 ranges[0].size = (map)->l_info[DT_##RELOC##SZ]->d_un.d_val; \ 91 if (map->l_info[VERSYMIDX (DT_##RELOC##COUNT)] != NULL) \ 92 ranges[0].nrelative \ 93 = map->l_info[VERSYMIDX (DT_##RELOC##COUNT)]->d_un.d_val; \ 94 } \ 95 if ((map)->l_info[DT_PLTREL] \ 96 && (!test_rel || (map)->l_info[DT_PLTREL]->d_un.d_val == DT_##RELOC)) \ 97 { \ 98 ElfW(Addr) start = D_PTR ((map), l_info[DT_JMPREL]); \ 99 ElfW(Addr) size = (map)->l_info[DT_PLTRELSZ]->d_un.d_val; \ 100 \ 101 if (ranges[0].start + ranges[0].size == (start + size)) \ 102 ranges[0].size -= size; \ 103 if (!(do_lazy) \ 104 && (ranges[0].start + ranges[0].size) == start) \ 105 { \ 106 /* Combine processing the sections. */ \ 107 ranges[0].size += size; \ 108 } \ 109 else \ 110 { \ 111 ranges[1].start = start; \ 112 ranges[1].size = size; \ 113 ranges[1].lazy = (do_lazy); \ 114 } \ 115 } \ 116 \ 117 for (int ranges_index = 0; ranges_index < 2; ++ranges_index) \ 118 elf_dynamic_do_##reloc ((map), scope, \ 119 ranges[ranges_index].start, \ 120 ranges[ranges_index].size, \ 121 ranges[ranges_index].nrelative, \ 122 ranges[ranges_index].lazy, \ 123 skip_ifunc); \ 124 } while (0) 125 126 # if ELF_MACHINE_NO_REL || ELF_MACHINE_NO_RELA 127 # define _ELF_CHECK_REL 0 128 # else 129 # define _ELF_CHECK_REL 1 130 # endif 131 132 # if ! ELF_MACHINE_NO_REL 133 # include "do-rel.h" 134 # define ELF_DYNAMIC_DO_REL(map, scope, lazy, skip_ifunc) \ 135 _ELF_DYNAMIC_DO_RELOC (REL, Rel, map, scope, lazy, skip_ifunc, _ELF_CHECK_REL) 136 # else 137 # define ELF_DYNAMIC_DO_REL(map, scope, lazy, skip_ifunc) /* Nothing to do. */ 138 # endif 139 140 # if ! ELF_MACHINE_NO_RELA 141 # define DO_RELA 142 # include "do-rel.h" 143 # define ELF_DYNAMIC_DO_RELA(map, scope, lazy, skip_ifunc) \ 144 _ELF_DYNAMIC_DO_RELOC (RELA, Rela, map, scope, lazy, skip_ifunc, _ELF_CHECK_REL) 145 # else 146 # define ELF_DYNAMIC_DO_RELA(map, scope, lazy, skip_ifunc) /* Nothing to do. */ 147 # endif 148 149 /* This can't just be an inline function because GCC is too dumb 150 to inline functions containing inlines themselves. */ 151 # define ELF_DYNAMIC_RELOCATE(map, scope, lazy, consider_profile, skip_ifunc) \ 152 do { \ 153 int edr_lazy = elf_machine_runtime_setup ((map), (scope), (lazy), \ 154 (consider_profile)); \ 155 ELF_DYNAMIC_DO_REL ((map), (scope), edr_lazy, skip_ifunc); \ 156 ELF_DYNAMIC_DO_RELA ((map), (scope), edr_lazy, skip_ifunc); \ 157 } while (0) 158 159 #endif 160