Handle +inf/+inf correctly.
[kopensolaris-gnu/glibc.git] / sysdeps / x86_64 / dl-machine.h
1 /* Machine-dependent ELF dynamic relocation inline functions.  x86-64 version.
2    Copyright (C) 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
3    This file is part of the GNU C Library.
4    Contributed by Andreas Jaeger <aj@suse.de>.
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, write to the Free
18    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
19    02111-1307 USA.  */
20
21 #ifndef dl_machine_h
22 #define dl_machine_h
23
24 #define ELF_MACHINE_NAME "x86_64"
25
26 #include <sys/param.h>
27 #include <sysdep.h>
28 #include <tls.h>
29
30 /* Return nonzero iff ELF header is compatible with the running host.  */
31 static inline int __attribute__ ((unused))
32 elf_machine_matches_host (const Elf64_Ehdr *ehdr)
33 {
34   return ehdr->e_machine == EM_X86_64;
35 }
36
37
38 /* Return the link-time address of _DYNAMIC.  Conveniently, this is the
39    first element of the GOT.  This must be inlined in a function which
40    uses global data.  */
41 static inline Elf64_Addr __attribute__ ((unused))
42 elf_machine_dynamic (void)
43 {
44   Elf64_Addr addr;
45
46   /* This works because we have our GOT address available in the small PIC
47      model.  */
48   addr = (Elf64_Addr) &_DYNAMIC;
49
50   return addr;
51 }
52
53
54 /* Return the run-time load address of the shared object.  */
55 static inline Elf64_Addr __attribute__ ((unused))
56 elf_machine_load_address (void)
57 {
58   register Elf64_Addr addr, tmp;
59
60   /* The easy way is just the same as on x86:
61        leaq _dl_start, %0
62        leaq _dl_start(%%rip), %1
63        subq %0, %1
64      but this does not work with binutils since we then have
65      a R_X86_64_32S relocation in a shared lib.
66
67      Instead we store the address of _dl_start in the data section
68      and compare it with the current value that we can get via
69      an RIP relative addressing mode.  */
70
71   asm ("movq 1f(%%rip), %1\n"
72        "0:\tleaq _dl_start(%%rip), %0\n\t"
73        "subq %1, %0\n\t"
74        ".section\t.data\n"
75        "1:\t.quad _dl_start\n\t"
76        ".previous\n\t"
77        : "=r" (addr), "=r" (tmp) : : "cc");
78
79   return addr;
80 }
81
82 /* Set up the loaded object described by L so its unrelocated PLT
83    entries will jump to the on-demand fixup code in dl-runtime.c.  */
84
85 static inline int __attribute__ ((unused, always_inline))
86 elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
87 {
88   Elf64_Addr *got;
89   extern void _dl_runtime_resolve (Elf64_Word) attribute_hidden;
90   extern void _dl_runtime_profile (Elf64_Word) attribute_hidden;
91
92   if (l->l_info[DT_JMPREL] && lazy)
93     {
94       /* The GOT entries for functions in the PLT have not yet been filled
95          in.  Their initial contents will arrange when called to push an
96          offset into the .rel.plt section, push _GLOBAL_OFFSET_TABLE_[1],
97          and then jump to _GLOBAL_OFFSET_TABLE[2].  */
98       got = (Elf64_Addr *) D_PTR (l, l_info[DT_PLTGOT]);
99       /* If a library is prelinked but we have to relocate anyway,
100          we have to be able to undo the prelinking of .got.plt.
101          The prelinker saved us here address of .plt + 0x16.  */
102       if (got[1])
103         {
104           l->l_mach.plt = got[1] + l->l_addr;
105           l->l_mach.gotplt = (Elf64_Addr) &got[3];
106         }
107       got[1] = (Elf64_Addr) l;  /* Identify this shared object.  */
108
109       /* The got[2] entry contains the address of a function which gets
110          called to get the address of a so far unresolved function and
111          jump to it.  The profiling extension of the dynamic linker allows
112          to intercept the calls to collect information.  In this case we
113          don't store the address in the GOT so that all future calls also
114          end in this function.  */
115       if (__builtin_expect (profile, 0))
116         {
117           got[2] = (Elf64_Addr) &_dl_runtime_profile;
118
119           if (_dl_name_match_p (GLRO(dl_profile), l))
120             /* This is the object we are looking for.  Say that we really
121                want profiling and the timers are started.  */
122             GL(dl_profile_map) = l;
123         }
124       else
125         /* This function will get called to fix up the GOT entry indicated by
126            the offset on the stack, and then jump to the resolved address.  */
127         got[2] = (Elf64_Addr) &_dl_runtime_resolve;
128     }
129
130   return lazy;
131 }
132
133 /* This code is used in dl-runtime.c to call the `fixup' function
134    and then redirect to the address it returns.  */
135 #ifndef PROF
136 # define ELF_MACHINE_RUNTIME_TRAMPOLINE asm ("\n\
137         .text\n\
138         .globl _dl_runtime_resolve\n\
139         .type _dl_runtime_resolve, @function\n\
140         .align 16\n\
141         " CFI_STARTPROC "\n\
142 _dl_runtime_resolve:\n\
143         subq $56,%rsp\n\
144         " CFI_ADJUST_CFA_OFFSET(72)" # Incorporate PLT\n\
145         movq %rax,(%rsp)        # Preserve registers otherwise clobbered.\n\
146         movq %rcx,8(%rsp)\n\
147         movq %rdx,16(%rsp)\n\
148         movq %rsi,24(%rsp)\n\
149         movq %rdi,32(%rsp)\n\
150         movq %r8,40(%rsp)\n\
151         movq %r9,48(%rsp)\n\
152         movq 64(%rsp), %rsi     # Copy args pushed by PLT in register.\n\
153         movq %rsi,%r11          # Multiply by 24\n\
154         addq %r11,%rsi\n\
155         addq %r11,%rsi\n\
156         shlq $3, %rsi\n\
157         movq 56(%rsp), %rdi     # %rdi: link_map, %rsi: reloc_offset\n\
158         call fixup              # Call resolver.\n\
159         movq %rax, %r11         # Save return value\n\
160         movq 48(%rsp),%r9       # Get register content back.\n\
161         movq 40(%rsp),%r8\n\
162         movq 32(%rsp),%rdi\n\
163         movq 24(%rsp),%rsi\n\
164         movq 16(%rsp),%rdx\n\
165         movq 8(%rsp),%rcx\n\
166         movq (%rsp),%rax\n\
167         addq $72,%rsp           # Adjust stack(PLT did 2 pushes)\n\
168         " CFI_ADJUST_CFA_OFFSET(-72)" \n\
169         jmp *%r11               # Jump to function address.\n\
170         " CFI_ENDPROC "\n\
171         .size _dl_runtime_resolve, .-_dl_runtime_resolve\n\
172 \n\
173         .globl _dl_runtime_profile\n\
174         .type _dl_runtime_profile, @function\n\
175         .align 16\n\
176         " CFI_STARTPROC "\n\
177 _dl_runtime_profile:\n\
178         subq $56,%rsp\n\
179         " CFI_ADJUST_CFA_OFFSET(72)" # Incorporate PLT\n\
180         movq %rax,(%rsp)        # Preserve registers otherwise clobbered.\n\
181         movq %rcx,8(%rsp)\n\
182         movq %rdx,16(%rsp)\n\
183         movq %rsi,24(%rsp)\n\
184         movq %rdi,32(%rsp)\n\
185         movq %r8,40(%rsp)\n\
186         movq %r9,48(%rsp)\n\
187         movq 72(%rsp), %rdx     # Load return address if needed\n\
188         movq 64(%rsp), %rsi     # Copy args pushed by PLT in register.\n\
189         movq %rsi,%r11          # Multiply by 24\n\
190         addq %r11,%rsi\n\
191         addq %r11,%rsi\n\
192         shlq $3, %rsi\n\
193         movq 56(%rsp), %rdi     # %rdi: link_map, %rsi: reloc_offset\n\
194         call profile_fixup      # Call resolver.\n\
195         movq %rax, %r11         # Save return value\n\
196         movq 48(%rsp),%r9       # Get register content back.\n\
197         movq 40(%rsp),%r8\n\
198         movq 32(%rsp),%rdi\n\
199         movq 24(%rsp),%rsi\n\
200         movq 16(%rsp),%rdx\n\
201         movq 8(%rsp),%rcx\n\
202         movq (%rsp),%rax\n\
203         addq $72,%rsp           # Adjust stack\n\
204         " CFI_ADJUST_CFA_OFFSET(-72)"\n\
205         jmp *%r11               # Jump to function address.\n\
206         " CFI_ENDPROC "\n\
207         .size _dl_runtime_profile, .-_dl_runtime_profile\n\
208         .previous\n\
209 ");
210 #else
211 # define ELF_MACHINE_RUNTIME_TRAMPOLINE asm ("\n\
212         .text\n\
213         .globl _dl_runtime_resolve\n\
214         .globl _dl_runtime_profile\n\
215         .type _dl_runtime_resolve, @function\n\
216         .type _dl_runtime_profile, @function\n\
217         .align 16\n\
218         " CFI_STARTPROC "\n\
219 _dl_runtime_resolve:\n\
220 _dl_runtime_profile:\n\
221         subq $56,%rsp\n\
222         " CFI_ADJUST_CFA_OFFSET(72)" # Incorporate PLT\n\
223         movq %rax,(%rsp)        # Preserve registers otherwise clobbered.\n\
224         movq %rcx,8(%rsp)\n\
225         movq %rdx,16(%rsp)\n\
226         movq %rsi,24(%rsp)\n\
227         movq %rdi,32(%rsp)\n\
228         movq %r8,40(%rsp)\n\
229         movq %r9,48(%rsp)\n\
230         movq 64(%rsp), %rsi     # Copy args pushed by PLT in register.\n\
231         movq %rsi,%r11          # Multiply by 24\n\
232         addq %r11,%rsi\n\
233         addq %r11,%rsi\n\
234         shlq $3, %rsi\n\
235         movq 56(%rsp), %rdi     # %rdi: link_map, %rsi: reloc_offset\n\
236         call fixup              # Call resolver.\n\
237         movq %rax, %r11         # Save return value\n\
238         movq 48(%rsp),%r9       # Get register content back.\n\
239         movq 40(%rsp),%r8\n\
240         movq 32(%rsp),%rdi\n\
241         movq 24(%rsp),%rsi\n\
242         movq 16(%rsp),%rdx\n\
243         movq 8(%rsp),%rcx\n\
244         movq (%rsp),%rax\n\
245         addq $72,%rsp           # Adjust stack\n\
246         " CFI_ADJUST_CFA_OFFSET(-72)"\n\
247         jmp *%r11               # Jump to function address.\n\
248         " CFI_ENDPROC "\n\
249         .size _dl_runtime_resolve, .-_dl_runtime_resolve\n\
250         .size _dl_runtime_profile, .-_dl_runtime_profile\n\
251         .previous\n\
252 ");
253 #endif
254
255 /* Initial entry point code for the dynamic linker.
256    The C function `_dl_start' is the real entry point;
257    its return value is the user program's entry point.  */
258 #define RTLD_START asm ("\n\
259 .text\n\
260         .align 16\n\
261 .globl _start\n\
262 .globl _dl_start_user\n\
263 _start:\n\
264         movq %rsp, %rdi\n\
265         call _dl_start\n\
266 _dl_start_user:\n\
267         # Save the user entry point address in %r12.\n\
268         movq %rax, %r12\n\
269         # See if we were run as a command with the executable file\n\
270         # name as an extra leading argument.\n\
271         movl _dl_skip_args(%rip), %eax\n\
272         # Pop the original argument count.\n\
273         popq %rdx\n\
274         # Adjust the stack pointer to skip _dl_skip_args words.\n\
275         leaq (%rsp,%rax,8), %rsp\n\
276         # Subtract _dl_skip_args from argc.\n\
277         subl %eax, %edx\n\
278         # Push argc back on the stack.\n\
279         pushq %rdx\n\
280         # Call _dl_init (struct link_map *main_map, int argc, char **argv, char **env)\n\
281         # argc -> rsi\n\
282         movq %rdx, %rsi\n\
283         # _dl_loaded -> rdi\n\
284         movq _rtld_local(%rip), %rdi\n\
285         # env -> rcx\n\
286         leaq 16(%rsp,%rdx,8), %rcx\n\
287         # argv -> rdx\n\
288         leaq 8(%rsp), %rdx\n\
289         # Call the function to run the initializers.\n\
290         call _dl_init_internal@PLT\n\
291         # Pass our finalizer function to the user in %rdx, as per ELF ABI.\n\
292         leaq _dl_fini(%rip), %rdx\n\
293         # Jump to the user's entry point.\n\
294         jmp *%r12\n\
295 .previous\n\
296 ");
297
298 /* ELF_RTYPE_CLASS_PLT iff TYPE describes relocation of a PLT entry or
299    TLS variable, so undefined references should not be allowed to
300    define the value.
301    ELF_RTYPE_CLASS_NOCOPY iff TYPE should not be allowed to resolve to one
302    of the main executable's symbols, as for a COPY reloc.  */
303 #if defined USE_TLS && (!defined RTLD_BOOTSTRAP || USE___THREAD)
304 # define elf_machine_type_class(type)                                         \
305   ((((type) == R_X86_64_JUMP_SLOT                                             \
306      || (type) == R_X86_64_DTPMOD64                                           \
307      || (type) == R_X86_64_DTPOFF64 || (type) == R_X86_64_TPOFF64)            \
308     * ELF_RTYPE_CLASS_PLT)                                                    \
309    | (((type) == R_X86_64_COPY) * ELF_RTYPE_CLASS_COPY))
310 #else
311 # define elf_machine_type_class(type) \
312   ((((type) == R_X86_64_JUMP_SLOT) * ELF_RTYPE_CLASS_PLT) \
313    | (((type) == R_X86_64_COPY) * ELF_RTYPE_CLASS_COPY))
314 #endif
315
316 /* A reloc type used for ld.so cmdline arg lookups to reject PLT entries.  */
317 #define ELF_MACHINE_JMP_SLOT    R_X86_64_JUMP_SLOT
318
319 /* The x86-64 never uses Elf64_Rel relocations.  */
320 #define ELF_MACHINE_NO_REL 1
321
322 /* We define an initialization functions.  This is called very early in
323    _dl_sysdep_start.  */
324 #define DL_PLATFORM_INIT dl_platform_init ()
325
326 static inline void __attribute__ ((unused))
327 dl_platform_init (void)
328 {
329   if (GLRO(dl_platform) != NULL && *GLRO(dl_platform) == '\0')
330     /* Avoid an empty string which would disturb us.  */
331     GLRO(dl_platform) = NULL;
332 }
333
334 static inline Elf64_Addr
335 elf_machine_fixup_plt (struct link_map *map, lookup_t t,
336                        const Elf64_Rela *reloc,
337                        Elf64_Addr *reloc_addr, Elf64_Addr value)
338 {
339   return *reloc_addr = value;
340 }
341
342 /* Return the final value of a plt relocation.  On x86-64 the
343    JUMP_SLOT relocation ignores the addend. */
344 static inline Elf64_Addr
345 elf_machine_plt_value (struct link_map *map, const Elf64_Rela *reloc,
346                        Elf64_Addr value)
347 {
348   return value;
349 }
350
351 #endif /* !dl_machine_h */
352
353 #ifdef RESOLVE
354
355 /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
356    MAP is the object containing the reloc.  */
357
358 auto inline void
359 __attribute__ ((always_inline))
360 elf_machine_rela (struct link_map *map, const Elf64_Rela *reloc,
361                   const Elf64_Sym *sym, const struct r_found_version *version,
362                   void *const reloc_addr_arg)
363 {
364   Elf64_Addr *const reloc_addr = reloc_addr_arg;
365   const unsigned long int r_type = ELF64_R_TYPE (reloc->r_info);
366
367 #if !defined RTLD_BOOTSTRAP || !defined HAVE_Z_COMBRELOC
368   if (__builtin_expect (r_type == R_X86_64_RELATIVE, 0))
369     {
370 # if !defined RTLD_BOOTSTRAP && !defined HAVE_Z_COMBRELOC
371       /* This is defined in rtld.c, but nowhere in the static libc.a;
372          make the reference weak so static programs can still link.
373          This declaration cannot be done when compiling rtld.c
374          (i.e. #ifdef RTLD_BOOTSTRAP) because rtld.c contains the
375          common defn for _dl_rtld_map, which is incompatible with a
376          weak decl in the same file.  */
377 #  ifndef SHARED
378       weak_extern (GL(dl_rtld_map));
379 #  endif
380       if (map != &GL(dl_rtld_map)) /* Already done in rtld itself.  */
381 # endif
382         *reloc_addr = map->l_addr + reloc->r_addend;
383     }
384   else
385 #endif
386   if (__builtin_expect (r_type == R_X86_64_NONE, 0))
387     return;
388   else
389     {
390 #ifndef RTLD_BOOTSTRAP
391       const Elf64_Sym *const refsym = sym;
392 #endif
393 #if defined USE_TLS && !defined RTLD_BOOTSTRAP
394       struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
395       Elf64_Addr value = (sym == NULL ? 0
396                           : (Elf64_Addr) sym_map->l_addr + sym->st_value);
397 #else
398       Elf64_Addr value = RESOLVE (&sym, version, r_type);
399
400 # ifndef RTLD_BOOTSTRAP
401       if (sym != NULL)
402 # endif
403         value += sym->st_value;
404 #endif
405
406 #if defined RTLD_BOOTSTRAP && !USE___THREAD
407       assert (r_type == R_X86_64_GLOB_DAT || r_type == R_X86_64_JUMP_SLOT);
408       *reloc_addr = value + reloc->r_addend;
409 #else
410       switch (r_type)
411         {
412         case R_X86_64_GLOB_DAT:
413         case R_X86_64_JUMP_SLOT:
414           *reloc_addr = value + reloc->r_addend;
415           break;
416
417 #if defined USE_TLS && !defined RESOLVE_CONFLICT_FIND_MAP
418         case R_X86_64_DTPMOD64:
419 # ifdef RTLD_BOOTSTRAP
420           /* During startup the dynamic linker is always the module
421              with index 1.
422              XXX If this relocation is necessary move before RESOLVE
423              call.  */
424           *reloc_addr = 1;
425 # else
426           /* Get the information from the link map returned by the
427              resolve function.  */
428           if (sym_map != NULL)
429             *reloc_addr = sym_map->l_tls_modid;
430 # endif
431           break;
432         case R_X86_64_DTPOFF64:
433 # ifndef RTLD_BOOTSTRAP
434           /* During relocation all TLS symbols are defined and used.
435              Therefore the offset is already correct.  */
436           if (sym != NULL)
437             *reloc_addr = sym->st_value + reloc->r_addend;
438 # endif
439           break;
440         case R_X86_64_TPOFF64:
441           /* The offset is negative, forward from the thread pointer.  */
442 # ifndef RTLD_BOOTSTRAP
443           if (sym != NULL)
444 # endif
445             {
446 # ifndef RTLD_BOOTSTRAP
447               CHECK_STATIC_TLS (map, sym_map);
448 # endif
449               /* We know the offset of the object the symbol is contained in.
450                  It is a negative value which will be added to the
451                  thread pointer.  */
452               *reloc_addr = (sym->st_value + reloc->r_addend
453                              - sym_map->l_tls_offset);
454             }
455           break;
456 #endif  /* use TLS */
457
458 #ifndef RTLD_BOOTSTRAP
459         case R_X86_64_64:
460           *reloc_addr = value + reloc->r_addend;
461           break;
462         case R_X86_64_32:
463           *(unsigned int *) reloc_addr = value + reloc->r_addend;
464           if (value + reloc->r_addend > UINT_MAX)
465             {
466               const char *strtab;
467
468               strtab = (const char *) D_PTR (map, l_info[DT_STRTAB]);
469
470               _dl_error_printf ("\
471 %s: Symbol `%s' causes overflow in R_X86_64_32 relocation\n",
472                                 rtld_progname ?: "<program name unknown>",
473                                 strtab + refsym->st_name);
474             }
475           break;
476 # ifndef RESOLVE_CONFLICT_FIND_MAP
477           /* Not needed for dl-conflict.c.  */
478         case R_X86_64_PC32:
479           *(unsigned int *) reloc_addr = value + reloc->r_addend
480             - (Elf64_Addr) reloc_addr;
481           if (value + reloc->r_addend - (Elf64_Addr) reloc_addr
482               != (int)(value + reloc->r_addend - (Elf64_Addr) reloc_addr))
483             {
484               const char *strtab;
485
486               strtab = (const char *) D_PTR (map, l_info[DT_STRTAB]);
487
488               _dl_error_printf ("\
489 %s: Symbol `%s' causes overflow in R_X86_64_PC32 relocation\n",
490                                 rtld_progname ?: "<program name unknown>",
491                                 strtab + refsym->st_name);
492             }
493           break;
494         case R_X86_64_COPY:
495           if (sym == NULL)
496             /* This can happen in trace mode if an object could not be
497                found.  */
498             break;
499           if (__builtin_expect (sym->st_size > refsym->st_size, 0)
500               || (__builtin_expect (sym->st_size < refsym->st_size, 0)
501                   && GLRO(dl_verbose)))
502             {
503               const char *strtab;
504
505               strtab = (const char *) D_PTR (map, l_info[DT_STRTAB]);
506               _dl_error_printf ("\
507 %s: Symbol `%s' has different size in shared object, consider re-linking\n",
508                                 rtld_progname ?: "<program name unknown>",
509                                 strtab + refsym->st_name);
510             }
511           memcpy (reloc_addr_arg, (void *) value,
512                   MIN (sym->st_size, refsym->st_size));
513           break;
514 # endif
515         default:
516           _dl_reloc_bad_type (map, r_type, 0);
517           break;
518 #endif
519         }
520 #endif
521     }
522 }
523
524 auto inline void
525 __attribute ((always_inline))
526 elf_machine_rela_relative (Elf64_Addr l_addr, const Elf64_Rela *reloc,
527                            void *const reloc_addr_arg)
528 {
529   Elf64_Addr *const reloc_addr = reloc_addr_arg;
530   assert (ELF64_R_TYPE (reloc->r_info) == R_X86_64_RELATIVE);
531   *reloc_addr = l_addr + reloc->r_addend;
532 }
533
534 auto inline void
535 __attribute ((always_inline))
536 elf_machine_lazy_rel (struct link_map *map,
537                       Elf64_Addr l_addr, const Elf64_Rela *reloc)
538 {
539   Elf64_Addr *const reloc_addr = (void *) (l_addr + reloc->r_offset);
540   const unsigned long int r_type = ELF64_R_TYPE (reloc->r_info);
541
542   /* Check for unexpected PLT reloc type.  */
543   if (__builtin_expect (r_type == R_X86_64_JUMP_SLOT, 1))
544     {
545       if (__builtin_expect (map->l_mach.plt, 0) == 0)
546         *reloc_addr += l_addr;
547       else
548         *reloc_addr =
549           map->l_mach.plt
550           + (((Elf64_Addr) reloc_addr) - map->l_mach.gotplt) * 2;
551     }
552   else
553     _dl_reloc_bad_type (map, r_type, 1);
554 }
555
556 #endif /* RESOLVE */