1/* Inline functions for dynamic linking.
2 Copyright (C) 1995-2020 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/* This macro is used as a callback from elf_machine_rel{a,} when a
20 static TLS reloc is about to be performed. Since (in dl-load.c) we
21 permit dynamic loading of objects that might use such relocs, we
22 have to check whether each use is actually doable. If the object
23 whose TLS segment the reference resolves to was allocated space in
24 the static TLS block at startup, then it's ok. Otherwise, we make
25 an attempt to allocate it in surplus space on the fly. If that
26 can't be done, we fall back to the error that DF_STATIC_TLS is
27 intended to produce. */
28#define HAVE_STATIC_TLS(map, sym_map) \
29 (__builtin_expect ((sym_map)->l_tls_offset != NO_TLS_OFFSET \
30 && ((sym_map)->l_tls_offset \
31 != FORCED_DYNAMIC_TLS_OFFSET), 1))
32
33#define CHECK_STATIC_TLS(map, sym_map) \
34 do { \
35 if (!HAVE_STATIC_TLS (map, sym_map)) \
36 _dl_allocate_static_tls (sym_map); \
37 } while (0)
38
39#define TRY_STATIC_TLS(map, sym_map) \
40 (__builtin_expect ((sym_map)->l_tls_offset \
41 != FORCED_DYNAMIC_TLS_OFFSET, 1) \
42 && (__builtin_expect ((sym_map)->l_tls_offset != NO_TLS_OFFSET, 1) \
43 || _dl_try_allocate_static_tls (sym_map, true) == 0))
44
45int _dl_try_allocate_static_tls (struct link_map *map, bool optional)
46 attribute_hidden;
47
48#include <elf.h>
49
50#ifdef RESOLVE_MAP
51/* We pass reloc_addr as a pointer to void, as opposed to a pointer to
52 ElfW(Addr), because not all architectures can assume that the
53 relocated address is properly aligned, whereas the compiler is
54 entitled to assume that a pointer to a type is properly aligned for
55 the type. Even if we cast the pointer back to some other type with
56 less strict alignment requirements, the compiler might still
57 remember that the pointer was originally more aligned, thereby
58 optimizing away alignment tests or using word instructions for
59 copying memory, breaking the very code written to handle the
60 unaligned cases. */
61# if ! ELF_MACHINE_NO_REL
62auto inline void __attribute__((always_inline))
63elf_machine_rel (struct link_map *map, const ElfW(Rel) *reloc,
64 const ElfW(Sym) *sym, const struct r_found_version *version,
65 void *const reloc_addr, int skip_ifunc);
66auto inline void __attribute__((always_inline))
67elf_machine_rel_relative (ElfW(Addr) l_addr, const ElfW(Rel) *reloc,
68 void *const reloc_addr);
69# endif
70# if ! ELF_MACHINE_NO_RELA
71auto inline void __attribute__((always_inline))
72elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc,
73 const ElfW(Sym) *sym, const struct r_found_version *version,
74 void *const reloc_addr, int skip_ifunc);
75auto inline void __attribute__((always_inline))
76elf_machine_rela_relative (ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
77 void *const reloc_addr);
78# endif
79# if ELF_MACHINE_NO_RELA || defined ELF_MACHINE_PLT_REL
80auto inline void __attribute__((always_inline))
81elf_machine_lazy_rel (struct link_map *map,
82 ElfW(Addr) l_addr, const ElfW(Rel) *reloc,
83 int skip_ifunc);
84# else
85auto inline void __attribute__((always_inline))
86elf_machine_lazy_rel (struct link_map *map,
87 ElfW(Addr) l_addr, const ElfW(Rela) *reloc,
88 int skip_ifunc);
89# endif
90#endif
91
92#include <dl-machine.h>
93
94#include "get-dynamic-info.h"
95
96#ifdef RESOLVE_MAP
97
98# if defined RTLD_BOOTSTRAP || defined STATIC_PIE_BOOTSTRAP
99# define ELF_DURING_STARTUP (1)
100# else
101# define ELF_DURING_STARTUP (0)
102# endif
103
104/* Get the definitions of `elf_dynamic_do_rel' and `elf_dynamic_do_rela'.
105 These functions are almost identical, so we use cpp magic to avoid
106 duplicating their code. It cannot be done in a more general function
107 because we must be able to completely inline. */
108
109/* On some machines, notably SPARC, DT_REL* includes DT_JMPREL in its
110 range. Note that according to the ELF spec, this is completely legal!
111
112 We are guarenteed that we have one of three situations. Either DT_JMPREL
113 comes immediately after DT_REL*, or there is overlap and DT_JMPREL
114 consumes precisely the very end of the DT_REL*, or DT_JMPREL and DT_REL*
115 are completely separate and there is a gap between them. */
116
117# define _ELF_DYNAMIC_DO_RELOC(RELOC, reloc, map, do_lazy, skip_ifunc, test_rel) \
118 do { \
119 struct { ElfW(Addr) start, size; \
120 __typeof (((ElfW(Dyn) *) 0)->d_un.d_val) nrelative; int lazy; } \
121 ranges[2] = { { 0, 0, 0, 0 }, { 0, 0, 0, 0 } }; \
122 \
123 if ((map)->l_info[DT_##RELOC]) \
124 { \
125 ranges[0].start = D_PTR ((map), l_info[DT_##RELOC]); \
126 ranges[0].size = (map)->l_info[DT_##RELOC##SZ]->d_un.d_val; \
127 if (map->l_info[VERSYMIDX (DT_##RELOC##COUNT)] != NULL) \
128 ranges[0].nrelative \
129 = map->l_info[VERSYMIDX (DT_##RELOC##COUNT)]->d_un.d_val; \
130 } \
131 if ((map)->l_info[DT_PLTREL] \
132 && (!test_rel || (map)->l_info[DT_PLTREL]->d_un.d_val == DT_##RELOC)) \
133 { \
134 ElfW(Addr) start = D_PTR ((map), l_info[DT_JMPREL]); \
135 ElfW(Addr) size = (map)->l_info[DT_PLTRELSZ]->d_un.d_val; \
136 \
137 if (ranges[0].start + ranges[0].size == (start + size)) \
138 ranges[0].size -= size; \
139 if (ELF_DURING_STARTUP \
140 || (!(do_lazy) \
141 && (ranges[0].start + ranges[0].size) == start)) \
142 { \
143 /* Combine processing the sections. */ \
144 ranges[0].size += size; \
145 } \
146 else \
147 { \
148 ranges[1].start = start; \
149 ranges[1].size = size; \
150 ranges[1].lazy = (do_lazy); \
151 } \
152 } \
153 \
154 if (ELF_DURING_STARTUP) \
155 elf_dynamic_do_##reloc ((map), ranges[0].start, ranges[0].size, \
156 ranges[0].nrelative, 0, skip_ifunc); \
157 else \
158 { \
159 int ranges_index; \
160 for (ranges_index = 0; ranges_index < 2; ++ranges_index) \
161 elf_dynamic_do_##reloc ((map), \
162 ranges[ranges_index].start, \
163 ranges[ranges_index].size, \
164 ranges[ranges_index].nrelative, \
165 ranges[ranges_index].lazy, \
166 skip_ifunc); \
167 } \
168 } while (0)
169
170# if ELF_MACHINE_NO_REL || ELF_MACHINE_NO_RELA
171# define _ELF_CHECK_REL 0
172# else
173# define _ELF_CHECK_REL 1
174# endif
175
176# if ! ELF_MACHINE_NO_REL
177# include "do-rel.h"
178# define ELF_DYNAMIC_DO_REL(map, lazy, skip_ifunc) \
179 _ELF_DYNAMIC_DO_RELOC (REL, Rel, map, lazy, skip_ifunc, _ELF_CHECK_REL)
180# else
181# define ELF_DYNAMIC_DO_REL(map, lazy, skip_ifunc) /* Nothing to do. */
182# endif
183
184# if ! ELF_MACHINE_NO_RELA
185# define DO_RELA
186# include "do-rel.h"
187# define ELF_DYNAMIC_DO_RELA(map, lazy, skip_ifunc) \
188 _ELF_DYNAMIC_DO_RELOC (RELA, Rela, map, lazy, skip_ifunc, _ELF_CHECK_REL)
189# else
190# define ELF_DYNAMIC_DO_RELA(map, lazy, skip_ifunc) /* Nothing to do. */
191# endif
192
193/* This can't just be an inline function because GCC is too dumb
194 to inline functions containing inlines themselves. */
195# define ELF_DYNAMIC_RELOCATE(map, lazy, consider_profile, skip_ifunc) \
196 do { \
197 int edr_lazy = elf_machine_runtime_setup ((map), (lazy), \
198 (consider_profile)); \
199 ELF_DYNAMIC_DO_REL ((map), edr_lazy, skip_ifunc); \
200 ELF_DYNAMIC_DO_RELA ((map), edr_lazy, skip_ifunc); \
201 } while (0)
202
203#endif
204