Add support for shared library profiling.
[kopensolaris-gnu/glibc.git] / sysdeps / m68k / dl-machine.h
1 /* Machine-dependent ELF dynamic relocation inline functions.  m68k version.
2    Copyright (C) 1996, 1997 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 Library General Public License as
7    published by the Free Software Foundation; either version 2 of the
8    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    Library General Public License for more details.
14
15    You should have received a copy of the GNU Library General Public
16    License along with the GNU C Library; see the file COPYING.LIB.  If
17    not, write to the Free Software Foundation, Inc.,
18    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
19
20 #ifndef dl_machine_h
21 #define dl_machine_h
22
23 #define ELF_MACHINE_NAME "m68k"
24
25 #include <sys/param.h>
26
27 #include <assert.h>
28
29 /* Return nonzero iff E_MACHINE is compatible with the running host.  */
30 static inline int
31 elf_machine_matches_host (Elf32_Half e_machine)
32 {
33   switch (e_machine)
34     {
35     case EM_68K:
36       return 1;
37     default:
38       return 0;
39     }
40 }
41
42
43 /* Return the link-time address of _DYNAMIC.  Conveniently, this is the
44    first element of the GOT.  This must be inlined in a function which
45    uses global data.  */
46 static inline Elf32_Addr
47 elf_machine_dynamic (void)
48 {
49   register Elf32_Addr *got asm ("%a5");
50   return *got;
51 }
52
53
54 /* Return the run-time load address of the shared object.  */
55 static inline Elf32_Addr
56 elf_machine_load_address (void)
57 {
58   Elf32_Addr addr;
59   asm (".Lhere: lea .Lhere(%%pc), %0\n"
60        "        sub.l %#.Lhere, %0"
61        : "=a" (addr));
62   return addr;
63 }
64
65 /* The `subl' insn above will contain an R_68K_RELATIVE relocation
66    entry intended to insert the run-time address of the label `.Lhere'.
67    This will be the first relocation in the text of the dynamic
68    linker; we skip it to avoid trying to modify read-only text in this
69    early stage.  */
70 #define ELF_MACHINE_BEFORE_RTLD_RELOC(dynamic_info) \
71   ((dynamic_info)[DT_RELA]->d_un.d_ptr += sizeof (Elf32_Rela), \
72    (dynamic_info)[DT_RELASZ]->d_un.d_val -= sizeof (Elf32_Rela))
73
74
75 /* Set up the loaded object described by L so its unrelocated PLT
76    entries will jump to the on-demand fixup code in dl-runtime.c.  */
77
78 static inline int
79 elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
80 {
81   Elf32_Addr *got;
82   extern void _dl_runtime_resolve (Elf32_Word);
83   extern void _dl_runtime_profile (Elf32_Word);
84
85   if (l->l_info[DT_JMPREL] && lazy)
86     {
87       /* The GOT entries for functions in the PLT have not yet been
88          filled in.  Their initial contents will arrange when called
89          to push an offset into the .rela.plt section, push
90          _GLOBAL_OFFSET_TABLE_[1], and then jump to
91          _GLOBAL_OFFSET_TABLE_[2].  */
92       got = (Elf32_Addr *) (l->l_addr + l->l_info[DT_PLTGOT]->d_un.d_ptr);
93       got[1] = (Elf32_Addr) l;  /* Identify this shared object.  */
94
95       /* The got[2] entry contains the address of a function which gets
96          called to get the address of a so far unresolved function and
97          jump to it.  The profiling extension of the dynamic linker allows
98          to intercept the calls to collect information.  In this case we
99          don't store the address in the GOT so that all future calls also
100          end in this function.  */
101       if (profile)
102         {
103           got[2] = (Elf32_Addr) &_dl_runtime_profile;
104           /* Say that we really want profiling and the timers are started.  */
105           _dl_profile_map = l;
106         }
107       else
108         /* This function will get called to fix up the GOT entry indicated by
109            the offset on the stack, and then jump to the resolved address.  */
110         got[2] = (Elf32_Addr) &_dl_runtime_resolve;
111     }
112
113   return lazy;
114 }
115
116 /* This code is used in dl-runtime.c to call the `fixup' function
117    and then redirect to the address it returns.  */
118 #define TRAMPOLINE_TEMPLATE(tramp_name, fixup_name) \
119 "| Trampoline for " #fixup_name "
120         .globl " #tramp_name "
121         .type " #tramp_name ", @function
122 " #tramp_name ":
123         | Save %a0 (struct return address) and %a1.
124         move.l %a0, -(%sp)
125         move.l %a1, -(%sp)
126         | Call the real address resolver.
127         jbsr " #fixup_name "
128         | Restore register %a0 and %a1.
129         move.l (%sp)+, %a1
130         move.l (%sp)+, %a0
131         | Pop parameters
132         addq.l #8, %sp
133         | Call real function.
134         jmp (%d0)
135         .size " #tramp_name ", . - " #tramp_name "\n"
136 #ifndef PROF
137 #define ELF_MACHINE_RUNTIME_TRAMPOLINE \
138 asm (TRAMPOLINE_TEMPLATE (_dl_runtime_resolve, fixup) \
139      TRAMPOLINE_TEMPLATE (_dl_runtime_profile, profile_fixup));
140 #else
141 #define ELF_MACHINE_RUNTIME_TRAMPOLINE \
142 asm (TRAMPOLINE_TEMPLATE (_dl_runtime_resolve, fixup) \
143      ".globl _dl_runtime_profile\n" \
144      ".set _dl_runtime_profile, _dl_runtime_resolve");
145 #endif
146 #define ELF_MACHINE_RUNTIME_FIXUP_ARGS long int save_a0, long int save_a1
147 /* The PLT uses Elf32_Rela relocs.  */
148 #define elf_machine_relplt elf_machine_rela
149
150
151 /* Mask identifying addresses reserved for the user program,
152    where the dynamic linker should not map anything.  */
153 #define ELF_MACHINE_USER_ADDRESS_MASK   0x80000000UL
154
155 /* Initial entry point code for the dynamic linker.
156    The C function `_dl_start' is the real entry point;
157    its return value is the user program's entry point.  */
158
159 #define RTLD_START asm ("\
160 .text
161 .globl _start
162 .globl _dl_start_user
163 _start:
164         move.l %sp, -(%sp)
165         jbsr _dl_start
166         addq.l #4, %sp
167 _dl_start_user:
168         | Save the user entry point address in %a4.
169         move.l %d0, %a4
170         | Point %a5 at the GOT.
171         lea _GLOBAL_OFFSET_TABLE_@GOTPC(%pc), %a5
172         | See if we were run as a command with the executable file
173         | name as an extra leading argument.
174         move.l ([_dl_skip_args@GOT, %a5]), %d0
175         jeq 0f
176         | Pop the original argument count
177         move.l (%sp)+, %d1
178         | Subtract _dl_skip_args from it.
179         sub.l %d0, %d1
180         | Adjust the stack pointer to skip _dl_skip_args words.
181         lea (%sp, %d0*4), %sp
182         | Push back the modified argument count.
183         move.l %d1, -(%sp)
184 0:      | Push _dl_default_scope[2] as argument in _dl_init_next call below.
185         move.l ([_dl_default_scope@GOT, %a5], 8), %d2
186 0:      move.l %d2, -(%sp)
187         | Call _dl_init_next to return the address of an initializer
188         | function to run.
189         bsr.l _dl_init_next@PLTPC
190         add.l #4, %sp | Pop argument.
191         | Check for zero return, when out of initializers.
192         tst.l %d0
193         jeq 1f
194         | Call the shared object initializer function.
195         | NOTE: We depend only on the registers (%d2, %a4 and %a5)
196         | and the return address pushed by this call;
197         | the initializer is called with the stack just
198         | as it appears on entry, and it is free to move
199         | the stack around, as long as it winds up jumping to
200         | the return address on the top of the stack.
201         move.l %d0, %a0
202         jsr (%a0)
203         | Loop to call _dl_init_next for the next initializer.
204         jra 0b
205 1:      | Clear the startup flag.
206         clr.l _dl_starting_up@GOT(%a5)
207         | Pass our finalizer function to the user in %a1.
208         move.l _dl_fini@GOT(%a5), %a1
209         | Initialize %fp with the stack pointer.
210         move.l %sp, %fp
211         | Jump to the user's entry point.
212         jmp (%a4)");
213
214 /* Nonzero iff TYPE describes a relocation that should
215    skip the executable when looking up the symbol value.  */
216 #define elf_machine_lookup_noexec_p(type) ((type) == R_68K_COPY)
217
218 /* Nonzero iff TYPE describes relocation of a PLT entry, so
219    PLT entries should not be allowed to define the value.  */
220 #define elf_machine_lookup_noplt_p(type) ((type) == R_68K_JMP_SLOT)
221
222 /* A reloc type used for ld.so cmdline arg lookups to reject PLT entries.  */
223 #define ELF_MACHINE_RELOC_NOPLT R_68K_JMP_SLOT
224
225 /* The m68k never uses Elf32_Rel relocations.  */
226 #define ELF_MACHINE_NO_REL 1
227
228 #endif /* !dl_machine_h */
229
230 #ifdef RESOLVE
231
232 /* Perform the relocation specified by RELOC and SYM (which is fully resolved).
233    MAP is the object containing the reloc.  */
234
235 static inline void
236 elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
237                   const Elf32_Sym *sym, const struct r_found_version *version,
238                   Elf32_Addr *const reloc_addr)
239 {
240   if (ELF32_R_TYPE (reloc->r_info) == R_68K_RELATIVE)
241     *reloc_addr = map->l_addr + reloc->r_addend;
242   else
243     {
244       const Elf32_Sym *const refsym = sym;
245       Elf32_Addr value = RESOLVE (&sym, version, ELF32_R_TYPE (reloc->r_info));
246       if (sym)
247         value += sym->st_value;
248
249       switch (ELF32_R_TYPE (reloc->r_info))
250         {
251         case R_68K_COPY:
252           if (sym == NULL)
253             /* This can happen in trace mode if an object could not be
254                found.  */
255             break;
256           if (sym->st_size > refsym->st_size
257               || (_dl_verbose && sym->st_size < refsym->st_size))
258             {
259               extern char **_dl_argv;
260               const char *strtab;
261
262               strtab = ((void *) map->l_addr
263                         + map->l_info[DT_STRTAB]->d_un.d_ptr);
264               _dl_sysdep_error (_dl_argv[0] ?: "<program name unknown>",
265                                 ": Symbol `", strtab + refsym->st_name,
266                                 "' has different size in shared object, "
267                                 "consider re-linking\n", NULL);
268             }
269           memcpy (reloc_addr, (void *) value, MIN (sym->st_size,
270                                                    refsym->st_size));
271           break;
272         case R_68K_GLOB_DAT:
273         case R_68K_JMP_SLOT:
274           *reloc_addr = value;
275           break;
276         case R_68K_8:
277           *(char *) reloc_addr = value + reloc->r_addend;
278           break;
279         case R_68K_16:
280           *(short *) reloc_addr = value + reloc->r_addend;
281           break;
282         case R_68K_32:
283           *reloc_addr = value + reloc->r_addend;
284           break;
285         case R_68K_PC8:
286           *(char *) reloc_addr
287             = value + reloc->r_addend - (Elf32_Addr) reloc_addr;
288           break;
289         case R_68K_PC16:
290           *(short *) reloc_addr
291             = value + reloc->r_addend - (Elf32_Addr) reloc_addr;
292           break;
293         case R_68K_PC32:
294           *reloc_addr = value + reloc->r_addend - (Elf32_Addr) reloc_addr;
295           break;
296         case R_68K_NONE:                /* Alright, Wilbur.  */
297           break;
298         default:
299           assert (! "unexpected dynamic reloc type");
300           break;
301         }
302     }
303 }
304
305 static inline void
306 elf_machine_lazy_rel (struct link_map *map, const Elf32_Rela *reloc)
307 {
308   Elf32_Addr *const reloc_addr = (void *) (map->l_addr + reloc->r_offset);
309   switch (ELF32_R_TYPE (reloc->r_info))
310     {
311     case R_68K_JMP_SLOT:
312       *reloc_addr += map->l_addr;
313       break;
314     default:
315       assert (! "unexpected PLT reloc type");
316       break;
317     }
318 }
319
320 #endif /* RESOLVE */