Warning: That file was not part of the compilation database. It may have many parsing errors.

1/* Machine-dependent ELF dynamic relocation inline functions. Alpha version.
2 Copyright (C) 1996-2019 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Contributed by Richard Henderson <rth@tamu.edu>.
5
6 The GNU C Library is free software; you can redistribute it and/or
7 modify it under the terms of the GNU Lesser General Public
8 License as published by the Free Software Foundation; either
9 version 2.1 of the License, or (at your option) any later version.
10
11 The GNU C Library 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 GNU
14 Lesser General Public License for more details.
15
16 You should have received a copy of the GNU Lesser General Public
17 License along with the GNU C Library. If not, see
18 <http://www.gnu.org/licenses/>. */
19
20/* This was written in the absence of an ABI -- don't expect
21 it to remain unchanged. */
22
23#ifndef dl_machine_h
24#define dl_machine_h 1
25
26#define ELF_MACHINE_NAME "alpha"
27
28#include <string.h>
29
30
31/* Mask identifying addresses reserved for the user program,
32 where the dynamic linker should not map anything. */
33#define ELF_MACHINE_USER_ADDRESS_MASK 0x120000000UL
34
35/* Translate a processor specific dynamic tag to the index in l_info array. */
36#define DT_ALPHA(x) (DT_ALPHA_##x - DT_LOPROC + DT_NUM)
37
38/* Return nonzero iff ELF header is compatible with the running host. */
39static inline int
40elf_machine_matches_host (const Elf64_Ehdr *ehdr)
41{
42 return ehdr->e_machine == EM_ALPHA;
43}
44
45/* Return the link-time address of _DYNAMIC. The multiple-got-capable
46 linker no longer allocates the first .got entry for this. But not to
47 worry, no special tricks are needed. */
48static inline Elf64_Addr
49elf_machine_dynamic (void)
50{
51#ifndef NO_AXP_MULTI_GOT_LD
52 return (Elf64_Addr) &_DYNAMIC;
53#else
54 register Elf64_Addr *gp __asm__ ("$29");
55 return gp[-4096];
56#endif
57}
58
59/* Return the run-time load address of the shared object. */
60
61static inline Elf64_Addr
62elf_machine_load_address (void)
63{
64 /* This relies on the compiler using gp-relative addresses for static symbols. */
65 static void *dot = &dot;
66 return (void *)&dot - dot;
67}
68
69/* Set up the loaded object described by L so its unrelocated PLT
70 entries will jump to the on-demand fixup code in dl-runtime.c. */
71
72static inline int
73elf_machine_runtime_setup (struct link_map *map, int lazy, int profile)
74{
75 extern char _dl_runtime_resolve_new[] attribute_hidden;
76 extern char _dl_runtime_profile_new[] attribute_hidden;
77 extern char _dl_runtime_resolve_old[] attribute_hidden;
78 extern char _dl_runtime_profile_old[] attribute_hidden;
79
80 struct pltgot {
81 char *resolve;
82 struct link_map *link;
83 };
84
85 struct pltgot *pg;
86 long secureplt;
87 char *resolve;
88
89 if (map->l_info[DT_JMPREL] == 0 || !lazy)
90 return lazy;
91
92 /* Check to see if we're using the read-only plt form. */
93 secureplt = map->l_info[DT_ALPHA(PLTRO)] != 0;
94
95 /* If the binary uses the read-only secure plt format, PG points to
96 the .got.plt section, which is the right place for ld.so to place
97 its hooks. Otherwise, PG is currently pointing at the start of
98 the plt; the hooks go at offset 16. */
99 pg = (struct pltgot *) D_PTR (map, l_info[DT_PLTGOT]);
100 pg += !secureplt;
101
102 /* This function will be called to perform the relocation. They're
103 not declared as functions to convince the compiler to use gp
104 relative relocations for them. */
105 if (secureplt)
106 resolve = _dl_runtime_resolve_new;
107 else
108 resolve = _dl_runtime_resolve_old;
109
110 if (__builtin_expect (profile, 0))
111 {
112 if (secureplt)
113 resolve = _dl_runtime_profile_new;
114 else
115 resolve = _dl_runtime_profile_old;
116
117 if (GLRO(dl_profile) && _dl_name_match_p (GLRO(dl_profile), map))
118 {
119 /* This is the object we are looking for. Say that we really
120 want profiling and the timers are started. */
121 GL(dl_profile_map) = map;
122 }
123 }
124
125 pg->resolve = resolve;
126 pg->link = map;
127
128 return lazy;
129}
130
131/* Initial entry point code for the dynamic linker.
132 The C function `_dl_start' is the real entry point;
133 its return value is the user program's entry point. */
134
135#define RTLD_START asm ("\
136 .section .text \n\
137 .set at \n\
138 .globl _start \n\
139 .ent _start \n\
140_start: \n\
141 .frame $31,0,$31,0 \n\
142 br $gp, 0f \n\
1430: ldgp $gp, 0($gp) \n\
144 .prologue 0 \n\
145 /* Pass pointer to argument block to _dl_start. */ \n\
146 mov $sp, $16 \n\
147 bsr $26, _dl_start !samegp \n\
148 .end _start \n\
149 /* FALLTHRU */ \n\
150 .globl _dl_start_user \n\
151 .ent _dl_start_user \n\
152_dl_start_user: \n\
153 .frame $31,0,$31,0 \n\
154 .prologue 0 \n\
155 /* Save the user entry point address in s0. */ \n\
156 mov $0, $9 \n\
157 /* See if we were run as a command with the executable \n\
158 file name as an extra leading argument. */ \n\
159 ldah $1, _dl_skip_args($gp) !gprelhigh \n\
160 ldl $1, _dl_skip_args($1) !gprellow \n\
161 bne $1, $fixup_stack \n\
162$fixup_stack_ret: \n\
163 /* The special initializer gets called with the stack \n\
164 just as the application's entry point will see it; \n\
165 it can switch stacks if it moves these contents \n\
166 over. */ \n\
167" RTLD_START_SPECIAL_INIT " \n\
168 /* Call _dl_init(_dl_loaded, argc, argv, envp) to run \n\
169 initializers. */ \n\
170 ldah $16, _rtld_local($gp) !gprelhigh \n\
171 ldq $16, _rtld_local($16) !gprellow \n\
172 ldq $17, 0($sp) \n\
173 lda $18, 8($sp) \n\
174 s8addq $17, 8, $19 \n\
175 addq $19, $18, $19 \n\
176 bsr $26, _dl_init !samegp \n\
177 /* Pass our finalizer function to the user in $0. */ \n\
178 ldah $0, _dl_fini($gp) !gprelhigh \n\
179 lda $0, _dl_fini($0) !gprellow \n\
180 /* Jump to the user's entry point. */ \n\
181 mov $9, $27 \n\
182 jmp ($9) \n\
183$fixup_stack: \n\
184 /* Adjust the stack pointer to skip _dl_skip_args words.\n\
185 This involves copying everything down, since the \n\
186 stack pointer must always be 16-byte aligned. */ \n\
187 ldah $7, __GI__dl_argv($gp) !gprelhigh \n\
188 ldq $2, 0($sp) \n\
189 ldq $5, __GI__dl_argv($7) !gprellow \n\
190 subq $31, $1, $6 \n\
191 subq $2, $1, $2 \n\
192 s8addq $6, $5, $5 \n\
193 mov $sp, $4 \n\
194 s8addq $1, $sp, $3 \n\
195 stq $2, 0($sp) \n\
196 stq $5, __GI__dl_argv($7) !gprellow \n\
197 /* Copy down argv. */ \n\
1980: ldq $5, 8($3) \n\
199 addq $4, 8, $4 \n\
200 addq $3, 8, $3 \n\
201 stq $5, 0($4) \n\
202 bne $5, 0b \n\
203 /* Copy down envp. */ \n\
2041: ldq $5, 8($3) \n\
205 addq $4, 8, $4 \n\
206 addq $3, 8, $3 \n\
207 stq $5, 0($4) \n\
208 bne $5, 1b \n\
209 /* Copy down auxiliary table. */ \n\
2102: ldq $5, 8($3) \n\
211 ldq $6, 16($3) \n\
212 addq $4, 16, $4 \n\
213 addq $3, 16, $3 \n\
214 stq $5, -8($4) \n\
215 stq $6, 0($4) \n\
216 bne $5, 2b \n\
217 br $fixup_stack_ret \n\
218 .end _dl_start_user \n\
219 .set noat \n\
220.previous");
221
222#ifndef RTLD_START_SPECIAL_INIT
223#define RTLD_START_SPECIAL_INIT /* nothing */
224#endif
225
226/* ELF_RTYPE_CLASS_PLT iff TYPE describes relocation of a PLT entry
227 or TLS variables, so undefined references should not be allowed
228 to define the value.
229
230 ELF_RTYPE_CLASS_COPY iff TYPE should not be allowed to resolve
231 to one of the main executable's symbols, as for a COPY reloc.
232 This is unused on Alpha. */
233
234# define elf_machine_type_class(type) \
235 (((type) == R_ALPHA_JMP_SLOT \
236 || (type) == R_ALPHA_DTPMOD64 \
237 || (type) == R_ALPHA_DTPREL64 \
238 || (type) == R_ALPHA_TPREL64) * ELF_RTYPE_CLASS_PLT)
239
240/* A reloc type used for ld.so cmdline arg lookups to reject PLT entries. */
241#define ELF_MACHINE_JMP_SLOT R_ALPHA_JMP_SLOT
242
243/* The alpha never uses Elf64_Rel relocations. */
244#define ELF_MACHINE_NO_REL 1
245#define ELF_MACHINE_NO_RELA 0
246
247/* We define an initialization functions. This is called very early in
248 * _dl_sysdep_start. */
249#define DL_PLATFORM_INIT dl_platform_init ()
250
251static inline void __attribute__ ((unused))
252dl_platform_init (void)
253{
254 if (GLRO(dl_platform) != NULL && *GLRO(dl_platform) == '\0')
255 /* Avoid an empty string which would disturb us. */
256 GLRO(dl_platform) = NULL;
257}
258
259/* Fix up the instructions of a PLT entry to invoke the function
260 rather than the dynamic linker. */
261static inline Elf64_Addr
262elf_machine_fixup_plt (struct link_map *map, lookup_t t,
263 const ElfW(Sym) *refsym, const ElfW(Sym) *sym,
264 const Elf64_Rela *reloc,
265 Elf64_Addr *got_addr, Elf64_Addr value)
266{
267 const Elf64_Rela *rela_plt;
268 Elf64_Word *plte;
269 long int edisp;
270
271 /* Store the value we are going to load. */
272 *got_addr = value;
273
274 /* If this binary uses the read-only secure plt format, we're done. */
275 if (map->l_info[DT_ALPHA(PLTRO)])
276 return value;
277
278 /* Otherwise we have to modify the plt entry in place to do the branch. */
279
280 /* Recover the PLT entry address by calculating reloc's index into the
281 .rela.plt, and finding that entry in the .plt. */
282 rela_plt = (const Elf64_Rela *) D_PTR (map, l_info[DT_JMPREL]);
283 plte = (Elf64_Word *) (D_PTR (map, l_info[DT_PLTGOT]) + 32);
284 plte += 3 * (reloc - rela_plt);
285
286 /* Find the displacement from the plt entry to the function. */
287 edisp = (long int) (value - (Elf64_Addr)&plte[3]) / 4;
288
289 if (edisp >= -0x100000 && edisp < 0x100000)
290 {
291 /* If we are in range, use br to perfect branch prediction and
292 elide the dependency on the address load. This case happens,
293 e.g., when a shared library call is resolved to the same library. */
294
295 int hi, lo;
296 hi = value - (Elf64_Addr)&plte[0];
297 lo = (short int) hi;
298 hi = (hi - lo) >> 16;
299
300 /* Emit "lda $27,lo($27)" */
301 plte[1] = 0x237b0000 | (lo & 0xffff);
302
303 /* Emit "br $31,function" */
304 plte[2] = 0xc3e00000 | (edisp & 0x1fffff);
305
306 /* Think about thread-safety -- the previous instructions must be
307 committed to memory before the first is overwritten. */
308 __asm__ __volatile__("wmb" : : : "memory");
309
310 /* Emit "ldah $27,hi($27)" */
311 plte[0] = 0x277b0000 | (hi & 0xffff);
312 }
313 else
314 {
315 /* Don't bother with the hint since we already know the hint is
316 wrong. Eliding it prevents the wrong page from getting pulled
317 into the cache. */
318
319 int hi, lo;
320 hi = (Elf64_Addr)got_addr - (Elf64_Addr)&plte[0];
321 lo = (short)hi;
322 hi = (hi - lo) >> 16;
323
324 /* Emit "ldq $27,lo($27)" */
325 plte[1] = 0xa77b0000 | (lo & 0xffff);
326
327 /* Emit "jmp $31,($27)" */
328 plte[2] = 0x6bfb0000;
329
330 /* Think about thread-safety -- the previous instructions must be
331 committed to memory before the first is overwritten. */
332 __asm__ __volatile__("wmb" : : : "memory");
333
334 /* Emit "ldah $27,hi($27)" */
335 plte[0] = 0x277b0000 | (hi & 0xffff);
336 }
337
338 /* At this point, if we've been doing runtime resolution, Icache is dirty.
339 This will be taken care of in _dl_runtime_resolve. If instead we are
340 doing this as part of non-lazy startup relocation, that bit of code
341 hasn't made it into Icache yet, so there's nothing to clean up. */
342
343 return value;
344}
345
346/* Return the final value of a plt relocation. */
347static inline Elf64_Addr
348elf_machine_plt_value (struct link_map *map, const Elf64_Rela *reloc,
349 Elf64_Addr value)
350{
351 return value + reloc->r_addend;
352}
353
354/* Names of the architecture-specific auditing callback functions. */
355#define ARCH_LA_PLTENTER alpha_gnu_pltenter
356#define ARCH_LA_PLTEXIT alpha_gnu_pltexit
357
358#endif /* !dl_machine_h */
359
360#ifdef RESOLVE_MAP
361
362/* Perform the relocation specified by RELOC and SYM (which is fully resolved).
363 MAP is the object containing the reloc. */
364auto inline void
365__attribute__ ((always_inline))
366elf_machine_rela (struct link_map *map,
367 const Elf64_Rela *reloc,
368 const Elf64_Sym *sym,
369 const struct r_found_version *version,
370 void *const reloc_addr_arg,
371 int skip_ifunc)
372{
373 Elf64_Addr *const reloc_addr = reloc_addr_arg;
374 unsigned long int const r_type = ELF64_R_TYPE (reloc->r_info);
375
376#if !defined RTLD_BOOTSTRAP && !defined HAVE_Z_COMBRELOC && !defined SHARED
377 /* This is defined in rtld.c, but nowhere in the static libc.a; make the
378 reference weak so static programs can still link. This declaration
379 cannot be done when compiling rtld.c (i.e. #ifdef RTLD_BOOTSTRAP)
380 because rtld.c contains the common defn for _dl_rtld_map, which is
381 incompatible with a weak decl in the same file. */
382 weak_extern (_dl_rtld_map);
383#endif
384
385 /* We cannot use a switch here because we cannot locate the switch
386 jump table until we've self-relocated. */
387
388#if !defined RTLD_BOOTSTRAP || !defined HAVE_Z_COMBRELOC
389 if (__builtin_expect (r_type == R_ALPHA_RELATIVE, 0))
390 {
391# if !defined RTLD_BOOTSTRAP && !defined HAVE_Z_COMBRELOC
392 /* Already done in dynamic linker. */
393 if (map != &GL(dl_rtld_map))
394# endif
395 {
396 /* XXX Make some timings. Maybe it's preferable to test for
397 unaligned access and only do it the complex way if necessary. */
398 Elf64_Addr reloc_addr_val;
399
400 /* Load value without causing unaligned trap. */
401 memcpy (&reloc_addr_val, reloc_addr_arg, 8);
402 reloc_addr_val += map->l_addr;
403
404 /* Store value without causing unaligned trap. */
405 memcpy (reloc_addr_arg, &reloc_addr_val, 8);
406 }
407 }
408 else
409#endif
410 if (__builtin_expect (r_type == R_ALPHA_NONE, 0))
411 return;
412 else
413 {
414 struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
415 Elf64_Addr sym_value;
416 Elf64_Addr sym_raw_value;
417
418 sym_raw_value = sym_value = reloc->r_addend;
419 if (sym_map)
420 {
421 sym_raw_value += sym->st_value;
422 sym_value += SYMBOL_ADDRESS (sym_map, sym, true);
423 }
424
425 if (r_type == R_ALPHA_GLOB_DAT)
426 *reloc_addr = sym_value;
427#ifdef RESOLVE_CONFLICT_FIND_MAP
428 /* In .gnu.conflict section, R_ALPHA_JMP_SLOT relocations have
429 R_ALPHA_JMP_SLOT in lower 8 bits and the remaining 24 bits
430 are .rela.plt index. */
431 else if ((r_type & 0xff) == R_ALPHA_JMP_SLOT)
432 {
433 /* elf_machine_fixup_plt needs the map reloc_addr points into,
434 while in _dl_resolve_conflicts map is _dl_loaded. */
435 RESOLVE_CONFLICT_FIND_MAP (map, reloc_addr);
436 reloc = ((const Elf64_Rela *) D_PTR (map, l_info[DT_JMPREL]))
437 + (r_type >> 8);
438 elf_machine_fixup_plt (map, 0, 0, 0, reloc, reloc_addr, sym_value);
439 }
440#else
441 else if (r_type == R_ALPHA_JMP_SLOT)
442 elf_machine_fixup_plt (map, 0, 0, 0, reloc, reloc_addr, sym_value);
443#endif
444#ifndef RTLD_BOOTSTRAP
445 else if (r_type == R_ALPHA_REFQUAD)
446 {
447 /* Store value without causing unaligned trap. */
448 memcpy (reloc_addr_arg, &sym_value, 8);
449 }
450#endif
451 else if (r_type == R_ALPHA_DTPMOD64)
452 {
453# ifdef RTLD_BOOTSTRAP
454 /* During startup the dynamic linker is always index 1. */
455 *reloc_addr = 1;
456# else
457 /* Get the information from the link map returned by the
458 resolv function. */
459 if (sym_map != NULL)
460 *reloc_addr = sym_map->l_tls_modid;
461# endif
462 }
463 else if (r_type == R_ALPHA_DTPREL64)
464 {
465# ifndef RTLD_BOOTSTRAP
466 /* During relocation all TLS symbols are defined and used.
467 Therefore the offset is already correct. */
468 *reloc_addr = sym_raw_value;
469# endif
470 }
471 else if (r_type == R_ALPHA_TPREL64)
472 {
473# ifdef RTLD_BOOTSTRAP
474 *reloc_addr = sym_raw_value + map->l_tls_offset;
475# else
476 if (sym_map)
477 {
478 CHECK_STATIC_TLS (map, sym_map);
479 *reloc_addr = sym_raw_value + sym_map->l_tls_offset;
480 }
481# endif
482 }
483 else
484 _dl_reloc_bad_type (map, r_type, 0);
485 }
486}
487
488/* Let do-rel.h know that on Alpha if l_addr is 0, all RELATIVE relocs
489 can be skipped. */
490#define ELF_MACHINE_REL_RELATIVE 1
491
492auto inline void
493__attribute__ ((always_inline))
494elf_machine_rela_relative (Elf64_Addr l_addr, const Elf64_Rela *reloc,
495 void *const reloc_addr_arg)
496{
497 /* XXX Make some timings. Maybe it's preferable to test for
498 unaligned access and only do it the complex way if necessary. */
499 Elf64_Addr reloc_addr_val;
500
501 /* Load value without causing unaligned trap. */
502 memcpy (&reloc_addr_val, reloc_addr_arg, 8);
503 reloc_addr_val += l_addr;
504
505 /* Store value without causing unaligned trap. */
506 memcpy (reloc_addr_arg, &reloc_addr_val, 8);
507}
508
509auto inline void
510__attribute__ ((always_inline))
511elf_machine_lazy_rel (struct link_map *map,
512 Elf64_Addr l_addr, const Elf64_Rela *reloc,
513 int skip_ifunc)
514{
515 Elf64_Addr * const reloc_addr = (void *)(l_addr + reloc->r_offset);
516 unsigned long int const r_type = ELF64_R_TYPE (reloc->r_info);
517
518 if (r_type == R_ALPHA_JMP_SLOT)
519 {
520 /* Perform a RELATIVE reloc on the .got entry that transfers
521 to the .plt. */
522 *reloc_addr += l_addr;
523 }
524 else if (r_type == R_ALPHA_NONE)
525 return;
526 else
527 _dl_reloc_bad_type (map, r_type, 1);
528}
529
530#endif /* RESOLVE_MAP */
531

Warning: That file was not part of the compilation database. It may have many parsing errors.